| Message ID | 20210315013137epcms2p861f06e66be9faff32b6648401778434a@epcms2p8 (mailing list archive) |
|---|---|
| State | Superseded |
| Headers | show |
| Series | scsi: ufs: Add Host Performance Booster Support | expand |
On 2021-03-15 09:31, Daejun Park wrote: > This patch supports the HPB 2.0. > > The HPB 2.0 supports read of varying sizes from 4KB to 512KB. > In the case of Read (<= 32KB) is supported as single HPB read. > In the case of Read (36KB ~ 512KB) is supported by as a combination of > write buffer command and HPB read command to deliver more PPN. > The write buffer commands may not be issued immediately due to busy > tags. > To use HPB read more aggressively, the driver can requeue the write > buffer > command. The requeue threshold is implemented as timeout and can be > modified with requeue_timeout_ms entry in sysfs. > > Signed-off-by: Daejun Park <daejun7.park@samsung.com> > --- > +static struct attribute *hpb_dev_param_attrs[] = { > + &dev_attr_requeue_timeout_ms.attr, > + NULL, > +}; > + > +struct attribute_group ufs_sysfs_hpb_param_group = { > + .name = "hpb_param_sysfs", > + .attrs = hpb_dev_param_attrs, > +}; > + > +static int ufshpb_pre_req_mempool_init(struct ufshpb_lu *hpb) > +{ > + struct ufshpb_req *pre_req = NULL; > + int qd = hpb->sdev_ufs_lu->queue_depth / 2; > + int i, j; > + > + INIT_LIST_HEAD(&hpb->lh_pre_req_free); > + > + hpb->pre_req = kcalloc(qd, sizeof(struct ufshpb_req), GFP_KERNEL); > + hpb->throttle_pre_req = qd; > + hpb->num_inflight_pre_req = 0; > + > + if (!hpb->pre_req) > + goto release_mem; > + > + for (i = 0; i < qd; i++) { > + pre_req = hpb->pre_req + i; > + INIT_LIST_HEAD(&pre_req->list_req); > + pre_req->req = NULL; > + pre_req->bio = NULL; Why don't prepare bio as same as wb.m_page? Won't that save more time for ufshpb_issue_pre_req()? Thanks, Can Guo. > + > + pre_req->wb.m_page = alloc_page(GFP_KERNEL | __GFP_ZERO); > + if (!pre_req->wb.m_page) { > + for (j = 0; j < i; j++) > + __free_page(hpb->pre_req[j].wb.m_page); > + > + goto release_mem; > + } > + list_add_tail(&pre_req->list_req, &hpb->lh_pre_req_free); > + } > + > + return 0; > +release_mem: > + kfree(hpb->pre_req); > + return -ENOMEM; > +} > +
On 2021-03-15 09:31, Daejun Park wrote: > This patch supports the HPB 2.0. > > The HPB 2.0 supports read of varying sizes from 4KB to 512KB. > In the case of Read (<= 32KB) is supported as single HPB read. > In the case of Read (36KB ~ 512KB) is supported by as a combination of > write buffer command and HPB read command to deliver more PPN. > The write buffer commands may not be issued immediately due to busy > tags. > To use HPB read more aggressively, the driver can requeue the write > buffer > command. The requeue threshold is implemented as timeout and can be > modified with requeue_timeout_ms entry in sysfs. > > Signed-off-by: Daejun Park <daejun7.park@samsung.com> > --- > +static int ufshpb_issue_pre_req(struct ufshpb_lu *hpb, struct > scsi_cmnd *cmd, > + int *read_id) > +{ > + struct ufshpb_req *pre_req; > + struct request *req = NULL; > + struct bio *bio = NULL; > + unsigned long flags; > + int _read_id; > + int ret = 0; > + > + req = blk_get_request(cmd->device->request_queue, To keep symmetry with ufshpb_get_req(), can we use hpb->sdev_ufs_lu->request_queue? Thanks, Can Guo. > + REQ_OP_SCSI_OUT | REQ_SYNC, BLK_MQ_REQ_NOWAIT); > + if (IS_ERR(req)) > + return -EAGAIN; > + > + bio = bio_alloc(GFP_ATOMIC, 1); > + if (!bio) { > + blk_put_request(req); > + return -EAGAIN; > + } > + > + spin_lock_irqsave(&hpb->rgn_state_lock, flags); > + pre_req = ufshpb_get_pre_req(hpb); > + if (!pre_req) { > + ret = -EAGAIN; > + goto unlock_out; > + } > + _read_id = ufshpb_get_read_id(hpb); > + spin_unlock_irqrestore(&hpb->rgn_state_lock, flags); > + > + pre_req->req = req; > + pre_req->bio = bio; > + > + ret = ufshpb_execute_pre_req(hpb, cmd, pre_req, _read_id); > + if (ret) > + goto free_pre_req; > + > + *read_id = _read_id; > + > + return ret; > +free_pre_req: > + spin_lock_irqsave(&hpb->rgn_state_lock, flags); > + ufshpb_put_pre_req(hpb, pre_req); > +unlock_out: > + spin_unlock_irqrestore(&hpb->rgn_state_lock, flags); > + bio_put(bio); > + blk_put_request(req); > + return ret; > +} > +
>> This patch supports the HPB 2.0. >> >> The HPB 2.0 supports read of varying sizes from 4KB to 512KB. >> In the case of Read (<= 32KB) is supported as single HPB read. >> In the case of Read (36KB ~ 512KB) is supported by as a combination of >> write buffer command and HPB read command to deliver more PPN. >> The write buffer commands may not be issued immediately due to busy >> tags. >> To use HPB read more aggressively, the driver can requeue the write >> buffer >> command. The requeue threshold is implemented as timeout and can be >> modified with requeue_timeout_ms entry in sysfs. >> >> Signed-off-by: Daejun Park <daejun7.park@samsung.com> >> --- >> +static struct attribute *hpb_dev_param_attrs[] = { >> + &dev_attr_requeue_timeout_ms.attr, >> + NULL, >> +}; >> + >> +struct attribute_group ufs_sysfs_hpb_param_group = { >> + .name = "hpb_param_sysfs", >> + .attrs = hpb_dev_param_attrs, >> +}; >> + >> +static int ufshpb_pre_req_mempool_init(struct ufshpb_lu *hpb) >> +{ >> + struct ufshpb_req *pre_req = NULL; >> + int qd = hpb->sdev_ufs_lu->queue_depth / 2; >> + int i, j; >> + >> + INIT_LIST_HEAD(&hpb->lh_pre_req_free); >> + >> + hpb->pre_req = kcalloc(qd, sizeof(struct ufshpb_req), GFP_KERNEL); >> + hpb->throttle_pre_req = qd; >> + hpb->num_inflight_pre_req = 0; >> + >> + if (!hpb->pre_req) >> + goto release_mem; >> + >> + for (i = 0; i < qd; i++) { >> + pre_req = hpb->pre_req + i; >> + INIT_LIST_HEAD(&pre_req->list_req); >> + pre_req->req = NULL; >> + pre_req->bio = NULL; > >Why don't prepare bio as same as wb.m_page? Won't that save more time >for ufshpb_issue_pre_req()? It is pre_req pool. So although we prepare bio at this time, it just only for first pre_req. After use it, it should be prepared bio at issue phase. Thanks, Daejun > >Thanks, >Can Guo. > >> + >> + pre_req->wb.m_page = alloc_page(GFP_KERNEL | __GFP_ZERO); >> + if (!pre_req->wb.m_page) { >> + for (j = 0; j < i; j++) >> + __free_page(hpb->pre_req[j].wb.m_page); >> + >> + goto release_mem; >> + } >> + list_add_tail(&pre_req->list_req, &hpb->lh_pre_req_free); >> + } >> + >> + return 0; >> +release_mem: >> + kfree(hpb->pre_req); >> + return -ENOMEM; >> +} >> + > > >
On 2021-03-15 15:07, Daejun Park wrote: >>> This patch supports the HPB 2.0. >>> >>> The HPB 2.0 supports read of varying sizes from 4KB to 512KB. >>> In the case of Read (<= 32KB) is supported as single HPB read. >>> In the case of Read (36KB ~ 512KB) is supported by as a combination >>> of >>> write buffer command and HPB read command to deliver more PPN. >>> The write buffer commands may not be issued immediately due to busy >>> tags. >>> To use HPB read more aggressively, the driver can requeue the write >>> buffer >>> command. The requeue threshold is implemented as timeout and can be >>> modified with requeue_timeout_ms entry in sysfs. >>> >>> Signed-off-by: Daejun Park <daejun7.park@samsung.com> >>> --- >>> +static struct attribute *hpb_dev_param_attrs[] = { >>> + &dev_attr_requeue_timeout_ms.attr, >>> + NULL, >>> +}; >>> + >>> +struct attribute_group ufs_sysfs_hpb_param_group = { >>> + .name = "hpb_param_sysfs", >>> + .attrs = hpb_dev_param_attrs, >>> +}; >>> + >>> +static int ufshpb_pre_req_mempool_init(struct ufshpb_lu *hpb) >>> +{ >>> + struct ufshpb_req *pre_req = NULL; >>> + int qd = hpb->sdev_ufs_lu->queue_depth / 2; >>> + int i, j; >>> + >>> + INIT_LIST_HEAD(&hpb->lh_pre_req_free); >>> + >>> + hpb->pre_req = kcalloc(qd, sizeof(struct ufshpb_req), >>> GFP_KERNEL); >>> + hpb->throttle_pre_req = qd; >>> + hpb->num_inflight_pre_req = 0; >>> + >>> + if (!hpb->pre_req) >>> + goto release_mem; >>> + >>> + for (i = 0; i < qd; i++) { >>> + pre_req = hpb->pre_req + i; >>> + INIT_LIST_HEAD(&pre_req->list_req); >>> + pre_req->req = NULL; >>> + pre_req->bio = NULL; >> >> Why don't prepare bio as same as wb.m_page? Won't that save more time >> for ufshpb_issue_pre_req()? > > It is pre_req pool. So although we prepare bio at this time, it just > only for first pre_req. I meant removing the bio_alloc() in ufshpb_issue_pre_req() and bio_put() in ufshpb_pre_req_compl_fn(). bios, in pre_req's case, just hold a page. So, prepare 16 (if queue depth is 32) bios here, just use them along with wb.m_page and call bio_reset() in ufshpb_pre_req_compl_fn(). Shall it work? Thanks, Can Guo. > After use it, it should be prepared bio at issue phase. > > Thanks, > Daejun > >> >> Thanks, >> Can Guo. >> >>> + >>> + pre_req->wb.m_page = alloc_page(GFP_KERNEL | >>> __GFP_ZERO); >>> + if (!pre_req->wb.m_page) { >>> + for (j = 0; j < i; j++) >>> + >>> __free_page(hpb->pre_req[j].wb.m_page); >>> + >>> + goto release_mem; >>> + } >>> + list_add_tail(&pre_req->list_req, >>> &hpb->lh_pre_req_free); >>> + } >>> + >>> + return 0; >>> +release_mem: >>> + kfree(hpb->pre_req); >>> + return -ENOMEM; >>> +} >>> + >> >> >>
On 2021-03-15 15:23, Can Guo wrote: > On 2021-03-15 15:07, Daejun Park wrote: >>>> This patch supports the HPB 2.0. >>>> >>>> The HPB 2.0 supports read of varying sizes from 4KB to 512KB. >>>> In the case of Read (<= 32KB) is supported as single HPB read. >>>> In the case of Read (36KB ~ 512KB) is supported by as a combination >>>> of >>>> write buffer command and HPB read command to deliver more PPN. >>>> The write buffer commands may not be issued immediately due to busy >>>> tags. >>>> To use HPB read more aggressively, the driver can requeue the write >>>> buffer >>>> command. The requeue threshold is implemented as timeout and can be >>>> modified with requeue_timeout_ms entry in sysfs. >>>> >>>> Signed-off-by: Daejun Park <daejun7.park@samsung.com> >>>> --- >>>> +static struct attribute *hpb_dev_param_attrs[] = { >>>> + &dev_attr_requeue_timeout_ms.attr, >>>> + NULL, >>>> +}; >>>> + >>>> +struct attribute_group ufs_sysfs_hpb_param_group = { >>>> + .name = "hpb_param_sysfs", >>>> + .attrs = hpb_dev_param_attrs, >>>> +}; >>>> + >>>> +static int ufshpb_pre_req_mempool_init(struct ufshpb_lu *hpb) >>>> +{ >>>> + struct ufshpb_req *pre_req = NULL; >>>> + int qd = hpb->sdev_ufs_lu->queue_depth / 2; >>>> + int i, j; >>>> + >>>> + INIT_LIST_HEAD(&hpb->lh_pre_req_free); >>>> + >>>> + hpb->pre_req = kcalloc(qd, sizeof(struct ufshpb_req), >>>> GFP_KERNEL); >>>> + hpb->throttle_pre_req = qd; >>>> + hpb->num_inflight_pre_req = 0; >>>> + >>>> + if (!hpb->pre_req) >>>> + goto release_mem; >>>> + >>>> + for (i = 0; i < qd; i++) { >>>> + pre_req = hpb->pre_req + i; >>>> + INIT_LIST_HEAD(&pre_req->list_req); >>>> + pre_req->req = NULL; >>>> + pre_req->bio = NULL; >>> >>> Why don't prepare bio as same as wb.m_page? Won't that save more time >>> for ufshpb_issue_pre_req()? >> >> It is pre_req pool. So although we prepare bio at this time, it just >> only for first pre_req. > > I meant removing the bio_alloc() in ufshpb_issue_pre_req() and > bio_put() > in ufshpb_pre_req_compl_fn(). bios, in pre_req's case, just hold a > page. > So, prepare 16 (if queue depth is 32) bios here, just use them along > with > wb.m_page and call bio_reset() in ufshpb_pre_req_compl_fn(). Shall it > work? > If it works, you can even have the bio_add_pc_page() called here. Later in ufshpb_execute_pre_req(), you don't need to call ufshpb_pre_req_add_bio_page(), just call ufshpb_prep_entry() once instead - it save many repeated steps for a pre_req, and you don't even need to call bio_reset() in this case, since for a bio, nothing changes after it is binded with a specific page... Can Guo. > Thanks, > Can Guo. > >> After use it, it should be prepared bio at issue phase. >> >> Thanks, >> Daejun >> >>> >>> Thanks, >>> Can Guo. >>> >>>> + >>>> + pre_req->wb.m_page = alloc_page(GFP_KERNEL | >>>> __GFP_ZERO); >>>> + if (!pre_req->wb.m_page) { >>>> + for (j = 0; j < i; j++) >>>> + >>>> __free_page(hpb->pre_req[j].wb.m_page); >>>> + >>>> + goto release_mem; >>>> + } >>>> + list_add_tail(&pre_req->list_req, >>>> &hpb->lh_pre_req_free); >>>> + } >>>> + >>>> + return 0; >>>> +release_mem: >>>> + kfree(hpb->pre_req); >>>> + return -ENOMEM; >>>> +} >>>> + >>> >>> >>>
>On 2021-03-15 15:23, Can Guo wrote: >> On 2021-03-15 15:07, Daejun Park wrote: >>>>> This patch supports the HPB 2.0. >>>>> >>>>> The HPB 2.0 supports read of varying sizes from 4KB to 512KB. >>>>> In the case of Read (<= 32KB) is supported as single HPB read. >>>>> In the case of Read (36KB ~ 512KB) is supported by as a combination >>>>> of >>>>> write buffer command and HPB read command to deliver more PPN. >>>>> The write buffer commands may not be issued immediately due to busy >>>>> tags. >>>>> To use HPB read more aggressively, the driver can requeue the write >>>>> buffer >>>>> command. The requeue threshold is implemented as timeout and can be >>>>> modified with requeue_timeout_ms entry in sysfs. >>>>> >>>>> Signed-off-by: Daejun Park <daejun7.park@samsung.com> >>>>> --- >>>>> +static struct attribute *hpb_dev_param_attrs[] = { >>>>> + &dev_attr_requeue_timeout_ms.attr, >>>>> + NULL, >>>>> +}; >>>>> + >>>>> +struct attribute_group ufs_sysfs_hpb_param_group = { >>>>> + .name = "hpb_param_sysfs", >>>>> + .attrs = hpb_dev_param_attrs, >>>>> +}; >>>>> + >>>>> +static int ufshpb_pre_req_mempool_init(struct ufshpb_lu *hpb) >>>>> +{ >>>>> + struct ufshpb_req *pre_req = NULL; >>>>> + int qd = hpb->sdev_ufs_lu->queue_depth / 2; >>>>> + int i, j; >>>>> + >>>>> + INIT_LIST_HEAD(&hpb->lh_pre_req_free); >>>>> + >>>>> + hpb->pre_req = kcalloc(qd, sizeof(struct ufshpb_req), >>>>> GFP_KERNEL); >>>>> + hpb->throttle_pre_req = qd; >>>>> + hpb->num_inflight_pre_req = 0; >>>>> + >>>>> + if (!hpb->pre_req) >>>>> + goto release_mem; >>>>> + >>>>> + for (i = 0; i < qd; i++) { >>>>> + pre_req = hpb->pre_req + i; >>>>> + INIT_LIST_HEAD(&pre_req->list_req); >>>>> + pre_req->req = NULL; >>>>> + pre_req->bio = NULL; >>>> >>>> Why don't prepare bio as same as wb.m_page? Won't that save more time >>>> for ufshpb_issue_pre_req()? >>> >>> It is pre_req pool. So although we prepare bio at this time, it just >>> only for first pre_req. >> >> I meant removing the bio_alloc() in ufshpb_issue_pre_req() and >> bio_put() >> in ufshpb_pre_req_compl_fn(). bios, in pre_req's case, just hold a >> page. >> So, prepare 16 (if queue depth is 32) bios here, just use them along >> with >> wb.m_page and call bio_reset() in ufshpb_pre_req_compl_fn(). Shall it >> work? >> > >If it works, you can even have the bio_add_pc_page() called here. Later >in >ufshpb_execute_pre_req(), you don't need to call >ufshpb_pre_req_add_bio_page(), >just call ufshpb_prep_entry() once instead - it save many repeated steps >for a >pre_req, and you don't even need to call bio_reset() in this case, since >for a >bio, nothing changes after it is binded with a specific page... Hi, Can Guo I tried the idea that you suggested, but it doesn't work properly. This optimization should be done next time for enhancement. Thanks Daejun >Can Guo. > >> Thanks, >> Can Guo. >> >>> After use it, it should be prepared bio at issue phase. >>> >>> Thanks, >>> Daejun >>> >>>> >>>> Thanks, >>>> Can Guo. >>>> >>>>> + >>>>> + pre_req->wb.m_page = alloc_page(GFP_KERNEL | >>>>> __GFP_ZERO); >>>>> + if (!pre_req->wb.m_page) { >>>>> + for (j = 0; j < i; j++) >>>>> + >>>>> __free_page(hpb->pre_req[j].wb.m_page); >>>>> + >>>>> + goto release_mem; >>>>> + } >>>>> + list_add_tail(&pre_req->list_req, >>>>> &hpb->lh_pre_req_free); >>>>> + } >>>>> + >>>>> + return 0; >>>>> +release_mem: >>>>> + kfree(hpb->pre_req); >>>>> + return -ENOMEM; >>>>> +} >>>>> + >>>> >>>> >>>> > > >
On 2021-03-17 09:42, Daejun Park wrote: >> On 2021-03-15 15:23, Can Guo wrote: >>> On 2021-03-15 15:07, Daejun Park wrote: >>>>>> This patch supports the HPB 2.0. >>>>>> >>>>>> The HPB 2.0 supports read of varying sizes from 4KB to 512KB. >>>>>> In the case of Read (<= 32KB) is supported as single HPB read. >>>>>> In the case of Read (36KB ~ 512KB) is supported by as a >>>>>> combination >>>>>> of >>>>>> write buffer command and HPB read command to deliver more PPN. >>>>>> The write buffer commands may not be issued immediately due to >>>>>> busy >>>>>> tags. >>>>>> To use HPB read more aggressively, the driver can requeue the >>>>>> write >>>>>> buffer >>>>>> command. The requeue threshold is implemented as timeout and can >>>>>> be >>>>>> modified with requeue_timeout_ms entry in sysfs. >>>>>> >>>>>> Signed-off-by: Daejun Park <daejun7.park@samsung.com> >>>>>> --- >>>>>> +static struct attribute *hpb_dev_param_attrs[] = { >>>>>> + &dev_attr_requeue_timeout_ms.attr, >>>>>> + NULL, >>>>>> +}; >>>>>> + >>>>>> +struct attribute_group ufs_sysfs_hpb_param_group = { >>>>>> + .name = "hpb_param_sysfs", >>>>>> + .attrs = hpb_dev_param_attrs, >>>>>> +}; >>>>>> + >>>>>> +static int ufshpb_pre_req_mempool_init(struct ufshpb_lu *hpb) >>>>>> +{ >>>>>> + struct ufshpb_req *pre_req = NULL; >>>>>> + int qd = hpb->sdev_ufs_lu->queue_depth / 2; >>>>>> + int i, j; >>>>>> + >>>>>> + INIT_LIST_HEAD(&hpb->lh_pre_req_free); >>>>>> + >>>>>> + hpb->pre_req = kcalloc(qd, sizeof(struct ufshpb_req), >>>>>> GFP_KERNEL); >>>>>> + hpb->throttle_pre_req = qd; >>>>>> + hpb->num_inflight_pre_req = 0; >>>>>> + >>>>>> + if (!hpb->pre_req) >>>>>> + goto release_mem; >>>>>> + >>>>>> + for (i = 0; i < qd; i++) { >>>>>> + pre_req = hpb->pre_req + i; >>>>>> + INIT_LIST_HEAD(&pre_req->list_req); >>>>>> + pre_req->req = NULL; >>>>>> + pre_req->bio = NULL; >>>>> >>>>> Why don't prepare bio as same as wb.m_page? Won't that save more >>>>> time >>>>> for ufshpb_issue_pre_req()? >>>> >>>> It is pre_req pool. So although we prepare bio at this time, it just >>>> only for first pre_req. >>> >>> I meant removing the bio_alloc() in ufshpb_issue_pre_req() and >>> bio_put() >>> in ufshpb_pre_req_compl_fn(). bios, in pre_req's case, just hold a >>> page. >>> So, prepare 16 (if queue depth is 32) bios here, just use them along >>> with >>> wb.m_page and call bio_reset() in ufshpb_pre_req_compl_fn(). Shall it >>> work? >>> >> >> If it works, you can even have the bio_add_pc_page() called here. >> Later >> in >> ufshpb_execute_pre_req(), you don't need to call >> ufshpb_pre_req_add_bio_page(), >> just call ufshpb_prep_entry() once instead - it save many repeated >> steps >> for a >> pre_req, and you don't even need to call bio_reset() in this case, >> since >> for a >> bio, nothing changes after it is binded with a specific page... > > Hi, Can Guo > > I tried the idea that you suggested, but it doesn't work properly. > This optimization should be done next time for enhancement. Can you elaborate please? Any error seen? Per my understanding, in the case for pre_reqs, a bio is no different from a page. Here it can reserve 16 pages for later use, which can be done the same for bios. This is not an enhancement, but a doubt - why not? Unless it is not doable. Thanks, Can Guo. > > Thanks > Daejun > >> Can Guo. >> >>> Thanks, >>> Can Guo. >>> >>>> After use it, it should be prepared bio at issue phase. >>>> >>>> Thanks, >>>> Daejun >>>> >>>>> >>>>> Thanks, >>>>> Can Guo. >>>>> >>>>>> + >>>>>> + pre_req->wb.m_page = alloc_page(GFP_KERNEL | >>>>>> __GFP_ZERO); >>>>>> + if (!pre_req->wb.m_page) { >>>>>> + for (j = 0; j < i; j++) >>>>>> + >>>>>> __free_page(hpb->pre_req[j].wb.m_page); >>>>>> + >>>>>> + goto release_mem; >>>>>> + } >>>>>> + list_add_tail(&pre_req->list_req, >>>>>> &hpb->lh_pre_req_free); >>>>>> + } >>>>>> + >>>>>> + return 0; >>>>>> +release_mem: >>>>>> + kfree(hpb->pre_req); >>>>>> + return -ENOMEM; >>>>>> +} >>>>>> + >>>>> >>>>> >>>>> >> >> >>
>On 2021-03-17 09:42, Daejun Park wrote: >>> On 2021-03-15 15:23, Can Guo wrote: >>>> On 2021-03-15 15:07, Daejun Park wrote: >>>>>>> This patch supports the HPB 2.0. >>>>>>> >>>>>>> The HPB 2.0 supports read of varying sizes from 4KB to 512KB. >>>>>>> In the case of Read (<= 32KB) is supported as single HPB read. >>>>>>> In the case of Read (36KB ~ 512KB) is supported by as a >>>>>>> combination >>>>>>> of >>>>>>> write buffer command and HPB read command to deliver more PPN. >>>>>>> The write buffer commands may not be issued immediately due to >>>>>>> busy >>>>>>> tags. >>>>>>> To use HPB read more aggressively, the driver can requeue the >>>>>>> write >>>>>>> buffer >>>>>>> command. The requeue threshold is implemented as timeout and can >>>>>>> be >>>>>>> modified with requeue_timeout_ms entry in sysfs. >>>>>>> >>>>>>> Signed-off-by: Daejun Park <daejun7.park@samsung.com> >>>>>>> --- >>>>>>> +static struct attribute *hpb_dev_param_attrs[] = { >>>>>>> + &dev_attr_requeue_timeout_ms.attr, >>>>>>> + NULL, >>>>>>> +}; >>>>>>> + >>>>>>> +struct attribute_group ufs_sysfs_hpb_param_group = { >>>>>>> + .name = "hpb_param_sysfs", >>>>>>> + .attrs = hpb_dev_param_attrs, >>>>>>> +}; >>>>>>> + >>>>>>> +static int ufshpb_pre_req_mempool_init(struct ufshpb_lu *hpb) >>>>>>> +{ >>>>>>> + struct ufshpb_req *pre_req = NULL; >>>>>>> + int qd = hpb->sdev_ufs_lu->queue_depth / 2; >>>>>>> + int i, j; >>>>>>> + >>>>>>> + INIT_LIST_HEAD(&hpb->lh_pre_req_free); >>>>>>> + >>>>>>> + hpb->pre_req = kcalloc(qd, sizeof(struct ufshpb_req), >>>>>>> GFP_KERNEL); >>>>>>> + hpb->throttle_pre_req = qd; >>>>>>> + hpb->num_inflight_pre_req = 0; >>>>>>> + >>>>>>> + if (!hpb->pre_req) >>>>>>> + goto release_mem; >>>>>>> + >>>>>>> + for (i = 0; i < qd; i++) { >>>>>>> + pre_req = hpb->pre_req + i; >>>>>>> + INIT_LIST_HEAD(&pre_req->list_req); >>>>>>> + pre_req->req = NULL; >>>>>>> + pre_req->bio = NULL; >>>>>> >>>>>> Why don't prepare bio as same as wb.m_page? Won't that save more >>>>>> time >>>>>> for ufshpb_issue_pre_req()? >>>>> >>>>> It is pre_req pool. So although we prepare bio at this time, it just >>>>> only for first pre_req. >>>> >>>> I meant removing the bio_alloc() in ufshpb_issue_pre_req() and >>>> bio_put() >>>> in ufshpb_pre_req_compl_fn(). bios, in pre_req's case, just hold a >>>> page. >>>> So, prepare 16 (if queue depth is 32) bios here, just use them along >>>> with >>>> wb.m_page and call bio_reset() in ufshpb_pre_req_compl_fn(). Shall it >>>> work? >>>> >>> >>> If it works, you can even have the bio_add_pc_page() called here. >>> Later >>> in >>> ufshpb_execute_pre_req(), you don't need to call >>> ufshpb_pre_req_add_bio_page(), >>> just call ufshpb_prep_entry() once instead - it save many repeated >>> steps >>> for a >>> pre_req, and you don't even need to call bio_reset() in this case, >>> since >>> for a >>> bio, nothing changes after it is binded with a specific page... >> >> Hi, Can Guo >> >> I tried the idea that you suggested, but it doesn't work properly. >> This optimization should be done next time for enhancement. > >Can you elaborate please? Any error seen? > >Per my understanding, in the case for pre_reqs, a bio is no different >from a page. Here it can reserve 16 pages for later use, which can be >done the same for bios. I found some problem with re-using pre allocated bio. The following kernel message is related with problem. [ 2.750530] ------------[ cut here ]------------ [ 2.751404] WARNING: CPU: 4 PID: 170 at drivers/scsi/scsi_lib.c:1020 scsi_alloc_sgtables+0x253/0x2b0 [ 2.753054] Modules linked in: [ 2.753651] CPU: 4 PID: 170 Comm: mount Not tainted 5.12.0-rc1+ #331 [ 2.754752] Hardware name: QEMU Standard PC (i440FX + PIIX, 1996), BIOS rel-1.13.0-0-gf21b5a4aeb02-prebuilt.qemu.org 04/01/2014 [ 2.756813] RIP: 0010:scsi_alloc_sgtables+0x253/0x2b0 [ 2.757699] Code: 85 c0 74 19 41 0f b6 44 24 18 8d 50 e0 83 fa 03 76 30 41 bd 01 00 00 00 e9 1f fe ff ff be 01 00 00 00 45 31 ed e9 19 fe ff ff <0f> 0b b8 0a f [ 2.761021] RSP: 0018:ffffb06e0027f538 EFLAGS: 00010246 [ 2.761902] RAX: 0000000000000000 RBX: ffff9c3a42d424d0 RCX: ffffb06e0027f5e0 [ 2.763184] RDX: ffff9c3a42d426a8 RSI: 0000000000000000 RDI: ffff9c3a42d424d0 [ 2.764446] RBP: ffffb06e0027f570 R08: 0000000000000000 R09: 0000000000000000 [ 2.765704] R10: ffffffff8eb0dda0 R11: 00000000fffb7675 R12: ffff9c3a42d423c0 [ 2.766976] R13: 0000000000000000 R14: ffff9c3a41bed000 R15: ffff9c3a420f4000 [ 2.768225] FS: 00007f42d1eab100(0000) GS:ffff9c3b77c00000(0000) knlGS:0000000000000000 [ 2.769666] CS: 0010 DS: 0000 ES: 0000 CR0: 0000000080050033 [ 2.770719] CR2: 00007f42d1ac1000 CR3: 0000000104bee006 CR4: 0000000000370ee0 [ 2.771997] DR0: 0000000000000000 DR1: 0000000000000000 DR2: 0000000000000000 [ 2.773288] DR3: 0000000000000000 DR6: 00000000fffe0ff0 DR7: 0000000000000400 [ 2.774543] Call Trace: [ 2.775092] scsi_queue_rq+0x9b6/0xb20 [ 2.775754] __blk_mq_try_issue_directly+0x150/0x1f0 [ 2.776636] blk_mq_request_issue_directly+0x49/0x80 [ 2.777616] blk_insert_cloned_request+0x85/0xd0 [ 2.778470] ufshpb_prep.cold+0x793/0x7be [ 2.779179] ufshcd_queuecommand+0x114/0x690 [ 2.779986] scsi_queue_rq+0x38a/0xb20 [ 2.780755] blk_mq_dispatch_rq_list+0x13d/0x760 [ 2.781605] ? dd_dispatch_request+0x67/0x1c0 [ 2.782337] __blk_mq_do_dispatch_sched+0xb5/0x2c0 [ 2.783291] __blk_mq_sched_dispatch_requests+0x13c/0x180 [ 2.784209] blk_mq_sched_dispatch_requests+0x30/0x60 [ 2.785195] __blk_mq_run_hw_queue+0x49/0x90 [ 2.786024] __blk_mq_delay_run_hw_queue+0x162/0x180 [ 2.786890] blk_mq_run_hw_queue+0x85/0xe0 [ 2.787590] blk_mq_sched_insert_requests+0xdf/0x2b0 [ 2.788558] blk_mq_flush_plug_list+0x118/0x240 [ 2.789405] blk_flush_plug_list+0xde/0x110 [ 2.790225] blk_finish_plug+0x21/0x30 [ 2.790878] read_pages+0x16a/0x1d0 [ 2.791534] page_cache_ra_unbounded+0x123/0x1c0 [ 2.792392] do_page_cache_ra+0x38/0x40 [ 2.793183] force_page_cache_ra+0x97/0x110 [ 2.793875] page_cache_sync_ra+0x26/0x50 [ 2.794671] filemap_get_pages+0xc8/0x4b0 [ 2.795482] filemap_read+0xc9/0x340 [ 2.796144] ? find_held_lock+0x31/0x90 [ 2.796809] generic_file_read_iter+0xcc/0x130 [ 2.797644] blkdev_read_iter+0x30/0x40 [ 2.798436] new_sync_read+0x10e/0x190 [ 2.799112] vfs_read+0x178/0x1d0 [ 2.799732] ksys_read+0x6b/0xf0 [ 2.800361] __x64_sys_read+0x15/0x20 [ 2.801027] do_syscall_64+0x38/0x50 [ 2.801770] entry_SYSCALL_64_after_hwframe+0x44/0xae [ 2.802655] RIP: 0033:0x7f42d209a461 [ 2.803313] Code: fe ff ff 50 48 8d 3d fe d0 09 00 e8 e9 03 02 00 66 0f 1f 84 00 00 00 00 00 48 8d 05 99 62 0d 00 8b 00 85 c0 75 13 31 c0 0f 05 <48> 3d 00 f0 8 [ 2.806632] RSP: 002b:00007ffe7b88bc88 EFLAGS: 00000246 ORIG_RAX: 0000000000000000 [ 2.807942] RAX: ffffffffffffffda RBX: 000055ccb2e070d0 RCX: 00007f42d209a461 [ 2.809218] RDX: 0000000000040000 RSI: 00007f42d1ac1038 RDI: 0000000000000004 [ 2.810482] RBP: 000055ccb2e07120 R08: 00007f42d1ac1010 R09: 0000000000000000 [ 2.811729] R10: 0000000000000022 R11: 0000000000000246 R12: 0000003b95fc0000 [ 2.813005] R13: 0000000000040000 R14: 00007f42d1ac1028 R15: 00007f42d1ac1010 [ 2.814276] irq event stamp: 9319 [ 2.814868] hardirqs last enabled at (9327): [<ffffffff8c4d2033>] console_unlock+0x4d3/0x5e0 [ 2.816349] hardirqs last disabled at (9336): [<ffffffff8c4d1fa6>] console_unlock+0x446/0x5e0 [ 2.817837] softirqs last enabled at (8674): [<ffffffff8d4002ec>] __do_softirq+0x2ec/0x40f [ 2.819298] softirqs last disabled at (8669): [<ffffffff8c46ad9e>] irq_exit_rcu+0xae/0xb0 [ 2.820744] ---[ end trace af3986a7787eeecf ]--- It is related to bi_iter value of bio is changed after use it. Thanks, Daejun >This is not an enhancement, but a doubt - why not? Unless it is not >doable. > >Thanks, >Can Guo. > >> >> Thanks >> Daejun >> >>> Can Guo. >>> >>>> Thanks, >>>> Can Guo. >>>> >>>>> After use it, it should be prepared bio at issue phase. >>>>> >>>>> Thanks, >>>>> Daejun >>>>> >>>>>> >>>>>> Thanks, >>>>>> Can Guo. >>>>>> >>>>>>> + >>>>>>> + pre_req->wb.m_page = alloc_page(GFP_KERNEL | >>>>>>> __GFP_ZERO); >>>>>>> + if (!pre_req->wb.m_page) { >>>>>>> + for (j = 0; j < i; j++) >>>>>>> + >>>>>>> __free_page(hpb->pre_req[j].wb.m_page); >>>>>>> + >>>>>>> + goto release_mem; >>>>>>> + } >>>>>>> + list_add_tail(&pre_req->list_req, >>>>>>> &hpb->lh_pre_req_free); >>>>>>> + } >>>>>>> + >>>>>>> + return 0; >>>>>>> +release_mem: >>>>>>> + kfree(hpb->pre_req); >>>>>>> + return -ENOMEM; >>>>>>> +} >>>>>>> + >>>>>> >>>>>> >>>>>> >>> >>> >>> > > >
On 2021-03-18 10:02, Daejun Park wrote: >> On 2021-03-17 09:42, Daejun Park wrote: >>>> On 2021-03-15 15:23, Can Guo wrote: >>>>> On 2021-03-15 15:07, Daejun Park wrote: >>>>>>>> This patch supports the HPB 2.0. >>>>>>>> >>>>>>>> The HPB 2.0 supports read of varying sizes from 4KB to 512KB. >>>>>>>> In the case of Read (<= 32KB) is supported as single HPB read. >>>>>>>> In the case of Read (36KB ~ 512KB) is supported by as a >>>>>>>> combination >>>>>>>> of >>>>>>>> write buffer command and HPB read command to deliver more PPN. >>>>>>>> The write buffer commands may not be issued immediately due to >>>>>>>> busy >>>>>>>> tags. >>>>>>>> To use HPB read more aggressively, the driver can requeue the >>>>>>>> write >>>>>>>> buffer >>>>>>>> command. The requeue threshold is implemented as timeout and can >>>>>>>> be >>>>>>>> modified with requeue_timeout_ms entry in sysfs. >>>>>>>> >>>>>>>> Signed-off-by: Daejun Park <daejun7.park@samsung.com> >>>>>>>> --- >>>>>>>> +static struct attribute *hpb_dev_param_attrs[] = { >>>>>>>> + &dev_attr_requeue_timeout_ms.attr, >>>>>>>> + NULL, >>>>>>>> +}; >>>>>>>> + >>>>>>>> +struct attribute_group ufs_sysfs_hpb_param_group = { >>>>>>>> + .name = "hpb_param_sysfs", >>>>>>>> + .attrs = hpb_dev_param_attrs, >>>>>>>> +}; >>>>>>>> + >>>>>>>> +static int ufshpb_pre_req_mempool_init(struct ufshpb_lu *hpb) >>>>>>>> +{ >>>>>>>> + struct ufshpb_req *pre_req = NULL; >>>>>>>> + int qd = hpb->sdev_ufs_lu->queue_depth / 2; >>>>>>>> + int i, j; >>>>>>>> + >>>>>>>> + INIT_LIST_HEAD(&hpb->lh_pre_req_free); >>>>>>>> + >>>>>>>> + hpb->pre_req = kcalloc(qd, sizeof(struct ufshpb_req), >>>>>>>> GFP_KERNEL); >>>>>>>> + hpb->throttle_pre_req = qd; >>>>>>>> + hpb->num_inflight_pre_req = 0; >>>>>>>> + >>>>>>>> + if (!hpb->pre_req) >>>>>>>> + goto release_mem; >>>>>>>> + >>>>>>>> + for (i = 0; i < qd; i++) { >>>>>>>> + pre_req = hpb->pre_req + i; >>>>>>>> + INIT_LIST_HEAD(&pre_req->list_req); >>>>>>>> + pre_req->req = NULL; >>>>>>>> + pre_req->bio = NULL; >>>>>>> >>>>>>> Why don't prepare bio as same as wb.m_page? Won't that save more >>>>>>> time >>>>>>> for ufshpb_issue_pre_req()? >>>>>> >>>>>> It is pre_req pool. So although we prepare bio at this time, it >>>>>> just >>>>>> only for first pre_req. >>>>> >>>>> I meant removing the bio_alloc() in ufshpb_issue_pre_req() and >>>>> bio_put() >>>>> in ufshpb_pre_req_compl_fn(). bios, in pre_req's case, just hold a >>>>> page. >>>>> So, prepare 16 (if queue depth is 32) bios here, just use them >>>>> along >>>>> with >>>>> wb.m_page and call bio_reset() in ufshpb_pre_req_compl_fn(). Shall >>>>> it >>>>> work? >>>>> >>>> >>>> If it works, you can even have the bio_add_pc_page() called here. >>>> Later >>>> in >>>> ufshpb_execute_pre_req(), you don't need to call >>>> ufshpb_pre_req_add_bio_page(), >>>> just call ufshpb_prep_entry() once instead - it save many repeated >>>> steps >>>> for a >>>> pre_req, and you don't even need to call bio_reset() in this case, >>>> since >>>> for a >>>> bio, nothing changes after it is binded with a specific page... >>> >>> Hi, Can Guo >>> >>> I tried the idea that you suggested, but it doesn't work properly. >>> This optimization should be done next time for enhancement. >> >> Can you elaborate please? Any error seen? >> >> Per my understanding, in the case for pre_reqs, a bio is no different >> from a page. Here it can reserve 16 pages for later use, which can be >> done the same for bios. > > I found some problem with re-using pre allocated bio. > > The following kernel message is related with problem. > [ 2.750530] ------------[ cut here ]------------ > [ 2.751404] WARNING: CPU: 4 PID: 170 at > drivers/scsi/scsi_lib.c:1020 scsi_alloc_sgtables+0x253/0x2b0 > [ 2.753054] Modules linked in: > [ 2.753651] CPU: 4 PID: 170 Comm: mount Not tainted 5.12.0-rc1+ #331 > [ 2.754752] Hardware name: QEMU Standard PC (i440FX + PIIX, 1996), > BIOS rel-1.13.0-0-gf21b5a4aeb02-prebuilt.qemu.org 04/01/2014 > [ 2.756813] RIP: 0010:scsi_alloc_sgtables+0x253/0x2b0 > [ 2.757699] Code: 85 c0 74 19 41 0f b6 44 24 18 8d 50 e0 83 fa 03 > 76 30 41 bd 01 00 00 00 e9 1f fe ff ff be 01 00 00 00 45 31 ed e9 19 > fe ff ff <0f> 0b b8 0a f > [ 2.761021] RSP: 0018:ffffb06e0027f538 EFLAGS: 00010246 > [ 2.761902] RAX: 0000000000000000 RBX: ffff9c3a42d424d0 RCX: > ffffb06e0027f5e0 > [ 2.763184] RDX: ffff9c3a42d426a8 RSI: 0000000000000000 RDI: > ffff9c3a42d424d0 > [ 2.764446] RBP: ffffb06e0027f570 R08: 0000000000000000 R09: > 0000000000000000 > [ 2.765704] R10: ffffffff8eb0dda0 R11: 00000000fffb7675 R12: > ffff9c3a42d423c0 > [ 2.766976] R13: 0000000000000000 R14: ffff9c3a41bed000 R15: > ffff9c3a420f4000 > [ 2.768225] FS: 00007f42d1eab100(0000) GS:ffff9c3b77c00000(0000) > knlGS:0000000000000000 > [ 2.769666] CS: 0010 DS: 0000 ES: 0000 CR0: 0000000080050033 > [ 2.770719] CR2: 00007f42d1ac1000 CR3: 0000000104bee006 CR4: > 0000000000370ee0 > [ 2.771997] DR0: 0000000000000000 DR1: 0000000000000000 DR2: > 0000000000000000 > [ 2.773288] DR3: 0000000000000000 DR6: 00000000fffe0ff0 DR7: > 0000000000000400 > [ 2.774543] Call Trace: > [ 2.775092] scsi_queue_rq+0x9b6/0xb20 > [ 2.775754] __blk_mq_try_issue_directly+0x150/0x1f0 > [ 2.776636] blk_mq_request_issue_directly+0x49/0x80 > [ 2.777616] blk_insert_cloned_request+0x85/0xd0 > [ 2.778470] ufshpb_prep.cold+0x793/0x7be > [ 2.779179] ufshcd_queuecommand+0x114/0x690 > [ 2.779986] scsi_queue_rq+0x38a/0xb20 > [ 2.780755] blk_mq_dispatch_rq_list+0x13d/0x760 > [ 2.781605] ? dd_dispatch_request+0x67/0x1c0 > [ 2.782337] __blk_mq_do_dispatch_sched+0xb5/0x2c0 > [ 2.783291] __blk_mq_sched_dispatch_requests+0x13c/0x180 > [ 2.784209] blk_mq_sched_dispatch_requests+0x30/0x60 > [ 2.785195] __blk_mq_run_hw_queue+0x49/0x90 > [ 2.786024] __blk_mq_delay_run_hw_queue+0x162/0x180 > [ 2.786890] blk_mq_run_hw_queue+0x85/0xe0 > [ 2.787590] blk_mq_sched_insert_requests+0xdf/0x2b0 > [ 2.788558] blk_mq_flush_plug_list+0x118/0x240 > [ 2.789405] blk_flush_plug_list+0xde/0x110 > [ 2.790225] blk_finish_plug+0x21/0x30 > [ 2.790878] read_pages+0x16a/0x1d0 > [ 2.791534] page_cache_ra_unbounded+0x123/0x1c0 > [ 2.792392] do_page_cache_ra+0x38/0x40 > [ 2.793183] force_page_cache_ra+0x97/0x110 > [ 2.793875] page_cache_sync_ra+0x26/0x50 > [ 2.794671] filemap_get_pages+0xc8/0x4b0 > [ 2.795482] filemap_read+0xc9/0x340 > [ 2.796144] ? find_held_lock+0x31/0x90 > [ 2.796809] generic_file_read_iter+0xcc/0x130 > [ 2.797644] blkdev_read_iter+0x30/0x40 > [ 2.798436] new_sync_read+0x10e/0x190 > [ 2.799112] vfs_read+0x178/0x1d0 > [ 2.799732] ksys_read+0x6b/0xf0 > [ 2.800361] __x64_sys_read+0x15/0x20 > [ 2.801027] do_syscall_64+0x38/0x50 > [ 2.801770] entry_SYSCALL_64_after_hwframe+0x44/0xae > [ 2.802655] RIP: 0033:0x7f42d209a461 > [ 2.803313] Code: fe ff ff 50 48 8d 3d fe d0 09 00 e8 e9 03 02 00 > 66 0f 1f 84 00 00 00 00 00 48 8d 05 99 62 0d 00 8b 00 85 c0 75 13 31 > c0 0f 05 <48> 3d 00 f0 8 > [ 2.806632] RSP: 002b:00007ffe7b88bc88 EFLAGS: 00000246 ORIG_RAX: > 0000000000000000 > [ 2.807942] RAX: ffffffffffffffda RBX: 000055ccb2e070d0 RCX: > 00007f42d209a461 > [ 2.809218] RDX: 0000000000040000 RSI: 00007f42d1ac1038 RDI: > 0000000000000004 > [ 2.810482] RBP: 000055ccb2e07120 R08: 00007f42d1ac1010 R09: > 0000000000000000 > [ 2.811729] R10: 0000000000000022 R11: 0000000000000246 R12: > 0000003b95fc0000 > [ 2.813005] R13: 0000000000040000 R14: 00007f42d1ac1028 R15: > 00007f42d1ac1010 > [ 2.814276] irq event stamp: 9319 > [ 2.814868] hardirqs last enabled at (9327): [<ffffffff8c4d2033>] > console_unlock+0x4d3/0x5e0 > [ 2.816349] hardirqs last disabled at (9336): [<ffffffff8c4d1fa6>] > console_unlock+0x446/0x5e0 > [ 2.817837] softirqs last enabled at (8674): [<ffffffff8d4002ec>] > __do_softirq+0x2ec/0x40f > [ 2.819298] softirqs last disabled at (8669): [<ffffffff8c46ad9e>] > irq_exit_rcu+0xae/0xb0 > [ 2.820744] ---[ end trace af3986a7787eeecf ]--- > > It is related to bi_iter value of bio is changed after use it. > Can you share the change through attechment? Thanks, Can Guo. > Thanks, > Daejun > >> This is not an enhancement, but a doubt - why not? Unless it is not >> doable. >> >> Thanks, >> Can Guo. >> >>> >>> Thanks >>> Daejun >>> >>>> Can Guo. >>>> >>>>> Thanks, >>>>> Can Guo. >>>>> >>>>>> After use it, it should be prepared bio at issue phase. >>>>>> >>>>>> Thanks, >>>>>> Daejun >>>>>> >>>>>>> >>>>>>> Thanks, >>>>>>> Can Guo. >>>>>>> >>>>>>>> + >>>>>>>> + pre_req->wb.m_page = alloc_page(GFP_KERNEL | >>>>>>>> __GFP_ZERO); >>>>>>>> + if (!pre_req->wb.m_page) { >>>>>>>> + for (j = 0; j < i; j++) >>>>>>>> + >>>>>>>> __free_page(hpb->pre_req[j].wb.m_page); >>>>>>>> + >>>>>>>> + goto release_mem; >>>>>>>> + } >>>>>>>> + list_add_tail(&pre_req->list_req, >>>>>>>> &hpb->lh_pre_req_free); >>>>>>>> + } >>>>>>>> + >>>>>>>> + return 0; >>>>>>>> +release_mem: >>>>>>>> + kfree(hpb->pre_req); >>>>>>>> + return -ENOMEM; >>>>>>>> +} >>>>>>>> + >>>>>>> >>>>>>> >>>>>>> >>>> >>>> >>>> >> >> >>
>On 2021-03-18 10:02, Daejun Park wrote: >>> On 2021-03-17 09:42, Daejun Park wrote: >>>>> On 2021-03-15 15:23, Can Guo wrote: >>>>>> On 2021-03-15 15:07, Daejun Park wrote: >>>>>>>>> This patch supports the HPB 2.0. >>>>>>>>> >>>>>>>>> The HPB 2.0 supports read of varying sizes from 4KB to 512KB. >>>>>>>>> In the case of Read (<= 32KB) is supported as single HPB read. >>>>>>>>> In the case of Read (36KB ~ 512KB) is supported by as a >>>>>>>>> combination >>>>>>>>> of >>>>>>>>> write buffer command and HPB read command to deliver more PPN. >>>>>>>>> The write buffer commands may not be issued immediately due to >>>>>>>>> busy >>>>>>>>> tags. >>>>>>>>> To use HPB read more aggressively, the driver can requeue the >>>>>>>>> write >>>>>>>>> buffer >>>>>>>>> command. The requeue threshold is implemented as timeout and can >>>>>>>>> be >>>>>>>>> modified with requeue_timeout_ms entry in sysfs. >>>>>>>>> >>>>>>>>> Signed-off-by: Daejun Park <daejun7.park@samsung.com> >>>>>>>>> --- >>>>>>>>> +static struct attribute *hpb_dev_param_attrs[] = { >>>>>>>>> + &dev_attr_requeue_timeout_ms.attr, >>>>>>>>> + NULL, >>>>>>>>> +}; >>>>>>>>> + >>>>>>>>> +struct attribute_group ufs_sysfs_hpb_param_group = { >>>>>>>>> + .name = "hpb_param_sysfs", >>>>>>>>> + .attrs = hpb_dev_param_attrs, >>>>>>>>> +}; >>>>>>>>> + >>>>>>>>> +static int ufshpb_pre_req_mempool_init(struct ufshpb_lu *hpb) >>>>>>>>> +{ >>>>>>>>> + struct ufshpb_req *pre_req = NULL; >>>>>>>>> + int qd = hpb->sdev_ufs_lu->queue_depth / 2; >>>>>>>>> + int i, j; >>>>>>>>> + >>>>>>>>> + INIT_LIST_HEAD(&hpb->lh_pre_req_free); >>>>>>>>> + >>>>>>>>> + hpb->pre_req = kcalloc(qd, sizeof(struct ufshpb_req), >>>>>>>>> GFP_KERNEL); >>>>>>>>> + hpb->throttle_pre_req = qd; >>>>>>>>> + hpb->num_inflight_pre_req = 0; >>>>>>>>> + >>>>>>>>> + if (!hpb->pre_req) >>>>>>>>> + goto release_mem; >>>>>>>>> + >>>>>>>>> + for (i = 0; i < qd; i++) { >>>>>>>>> + pre_req = hpb->pre_req + i; >>>>>>>>> + INIT_LIST_HEAD(&pre_req->list_req); >>>>>>>>> + pre_req->req = NULL; >>>>>>>>> + pre_req->bio = NULL; >>>>>>>> >>>>>>>> Why don't prepare bio as same as wb.m_page? Won't that save more >>>>>>>> time >>>>>>>> for ufshpb_issue_pre_req()? >>>>>>> >>>>>>> It is pre_req pool. So although we prepare bio at this time, it >>>>>>> just >>>>>>> only for first pre_req. >>>>>> >>>>>> I meant removing the bio_alloc() in ufshpb_issue_pre_req() and >>>>>> bio_put() >>>>>> in ufshpb_pre_req_compl_fn(). bios, in pre_req's case, just hold a >>>>>> page. >>>>>> So, prepare 16 (if queue depth is 32) bios here, just use them >>>>>> along >>>>>> with >>>>>> wb.m_page and call bio_reset() in ufshpb_pre_req_compl_fn(). Shall >>>>>> it >>>>>> work? >>>>>> >>>>> >>>>> If it works, you can even have the bio_add_pc_page() called here. >>>>> Later >>>>> in >>>>> ufshpb_execute_pre_req(), you don't need to call >>>>> ufshpb_pre_req_add_bio_page(), >>>>> just call ufshpb_prep_entry() once instead - it save many repeated >>>>> steps >>>>> for a >>>>> pre_req, and you don't even need to call bio_reset() in this case, >>>>> since >>>>> for a >>>>> bio, nothing changes after it is binded with a specific page... >>>> >>>> Hi, Can Guo >>>> >>>> I tried the idea that you suggested, but it doesn't work properly. >>>> This optimization should be done next time for enhancement. >>> >>> Can you elaborate please? Any error seen? >>> >>> Per my understanding, in the case for pre_reqs, a bio is no different >>> from a page. Here it can reserve 16 pages for later use, which can be >>> done the same for bios. >> >> I found some problem with re-using pre allocated bio. >> >> The following kernel message is related with problem. >> [ 2.750530] ------------[ cut here ]------------ >> [ 2.751404] WARNING: CPU: 4 PID: 170 at >> drivers/scsi/scsi_lib.c:1020 scsi_alloc_sgtables+0x253/0x2b0 >> [ 2.753054] Modules linked in: >> [ 2.753651] CPU: 4 PID: 170 Comm: mount Not tainted 5.12.0-rc1+ #331 >> [ 2.754752] Hardware name: QEMU Standard PC (i440FX + PIIX, 1996), >> BIOS rel-1.13.0-0-gf21b5a4aeb02-prebuilt.qemu.org 04/01/2014 >> [ 2.756813] RIP: 0010:scsi_alloc_sgtables+0x253/0x2b0 >> [ 2.757699] Code: 85 c0 74 19 41 0f b6 44 24 18 8d 50 e0 83 fa 03 >> 76 30 41 bd 01 00 00 00 e9 1f fe ff ff be 01 00 00 00 45 31 ed e9 19 >> fe ff ff <0f> 0b b8 0a f >> [ 2.761021] RSP: 0018:ffffb06e0027f538 EFLAGS: 00010246 >> [ 2.761902] RAX: 0000000000000000 RBX: ffff9c3a42d424d0 RCX: >> ffffb06e0027f5e0 >> [ 2.763184] RDX: ffff9c3a42d426a8 RSI: 0000000000000000 RDI: >> ffff9c3a42d424d0 >> [ 2.764446] RBP: ffffb06e0027f570 R08: 0000000000000000 R09: >> 0000000000000000 >> [ 2.765704] R10: ffffffff8eb0dda0 R11: 00000000fffb7675 R12: >> ffff9c3a42d423c0 >> [ 2.766976] R13: 0000000000000000 R14: ffff9c3a41bed000 R15: >> ffff9c3a420f4000 >> [ 2.768225] FS: 00007f42d1eab100(0000) GS:ffff9c3b77c00000(0000) >> knlGS:0000000000000000 >> [ 2.769666] CS: 0010 DS: 0000 ES: 0000 CR0: 0000000080050033 >> [ 2.770719] CR2: 00007f42d1ac1000 CR3: 0000000104bee006 CR4: >> 0000000000370ee0 >> [ 2.771997] DR0: 0000000000000000 DR1: 0000000000000000 DR2: >> 0000000000000000 >> [ 2.773288] DR3: 0000000000000000 DR6: 00000000fffe0ff0 DR7: >> 0000000000000400 >> [ 2.774543] Call Trace: >> [ 2.775092] scsi_queue_rq+0x9b6/0xb20 >> [ 2.775754] __blk_mq_try_issue_directly+0x150/0x1f0 >> [ 2.776636] blk_mq_request_issue_directly+0x49/0x80 >> [ 2.777616] blk_insert_cloned_request+0x85/0xd0 >> [ 2.778470] ufshpb_prep.cold+0x793/0x7be >> [ 2.779179] ufshcd_queuecommand+0x114/0x690 >> [ 2.779986] scsi_queue_rq+0x38a/0xb20 >> [ 2.780755] blk_mq_dispatch_rq_list+0x13d/0x760 >> [ 2.781605] ? dd_dispatch_request+0x67/0x1c0 >> [ 2.782337] __blk_mq_do_dispatch_sched+0xb5/0x2c0 >> [ 2.783291] __blk_mq_sched_dispatch_requests+0x13c/0x180 >> [ 2.784209] blk_mq_sched_dispatch_requests+0x30/0x60 >> [ 2.785195] __blk_mq_run_hw_queue+0x49/0x90 >> [ 2.786024] __blk_mq_delay_run_hw_queue+0x162/0x180 >> [ 2.786890] blk_mq_run_hw_queue+0x85/0xe0 >> [ 2.787590] blk_mq_sched_insert_requests+0xdf/0x2b0 >> [ 2.788558] blk_mq_flush_plug_list+0x118/0x240 >> [ 2.789405] blk_flush_plug_list+0xde/0x110 >> [ 2.790225] blk_finish_plug+0x21/0x30 >> [ 2.790878] read_pages+0x16a/0x1d0 >> [ 2.791534] page_cache_ra_unbounded+0x123/0x1c0 >> [ 2.792392] do_page_cache_ra+0x38/0x40 >> [ 2.793183] force_page_cache_ra+0x97/0x110 >> [ 2.793875] page_cache_sync_ra+0x26/0x50 >> [ 2.794671] filemap_get_pages+0xc8/0x4b0 >> [ 2.795482] filemap_read+0xc9/0x340 >> [ 2.796144] ? find_held_lock+0x31/0x90 >> [ 2.796809] generic_file_read_iter+0xcc/0x130 >> [ 2.797644] blkdev_read_iter+0x30/0x40 >> [ 2.798436] new_sync_read+0x10e/0x190 >> [ 2.799112] vfs_read+0x178/0x1d0 >> [ 2.799732] ksys_read+0x6b/0xf0 >> [ 2.800361] __x64_sys_read+0x15/0x20 >> [ 2.801027] do_syscall_64+0x38/0x50 >> [ 2.801770] entry_SYSCALL_64_after_hwframe+0x44/0xae >> [ 2.802655] RIP: 0033:0x7f42d209a461 >> [ 2.803313] Code: fe ff ff 50 48 8d 3d fe d0 09 00 e8 e9 03 02 00 >> 66 0f 1f 84 00 00 00 00 00 48 8d 05 99 62 0d 00 8b 00 85 c0 75 13 31 >> c0 0f 05 <48> 3d 00 f0 8 >> [ 2.806632] RSP: 002b:00007ffe7b88bc88 EFLAGS: 00000246 ORIG_RAX: >> 0000000000000000 >> [ 2.807942] RAX: ffffffffffffffda RBX: 000055ccb2e070d0 RCX: >> 00007f42d209a461 >> [ 2.809218] RDX: 0000000000040000 RSI: 00007f42d1ac1038 RDI: >> 0000000000000004 >> [ 2.810482] RBP: 000055ccb2e07120 R08: 00007f42d1ac1010 R09: >> 0000000000000000 >> [ 2.811729] R10: 0000000000000022 R11: 0000000000000246 R12: >> 0000003b95fc0000 >> [ 2.813005] R13: 0000000000040000 R14: 00007f42d1ac1028 R15: >> 00007f42d1ac1010 >> [ 2.814276] irq event stamp: 9319 >> [ 2.814868] hardirqs last enabled at (9327): [<ffffffff8c4d2033>] >> console_unlock+0x4d3/0x5e0 >> [ 2.816349] hardirqs last disabled at (9336): [<ffffffff8c4d1fa6>] >> console_unlock+0x446/0x5e0 >> [ 2.817837] softirqs last enabled at (8674): [<ffffffff8d4002ec>] >> __do_softirq+0x2ec/0x40f >> [ 2.819298] softirqs last disabled at (8669): [<ffffffff8c46ad9e>] >> irq_exit_rcu+0xae/0xb0 >> [ 2.820744] ---[ end trace af3986a7787eeecf ]--- >> >> It is related to bi_iter value of bio is changed after use it. >> > >Can you share the change through attechment? Sure, diff --git a/drivers/scsi/ufs/ufshpb.c b/drivers/scsi/ufs/ufshpb.c index 3522197b977e..7288eda44018 100644 --- a/drivers/scsi/ufs/ufshpb.c +++ b/drivers/scsi/ufs/ufshpb.c @@ -335,7 +335,7 @@ static inline void ufshpb_put_pre_req(struct ufshpb_lu *hpb, struct ufshpb_req *pre_req) { pre_req->req = NULL; - pre_req->bio = NULL; + //pre_req->bio = NULL; list_add_tail(&pre_req->list_req, &hpb->lh_pre_req_free); hpb->num_inflight_pre_req--; } @@ -363,7 +363,6 @@ static void ufshpb_pre_req_compl_fn(struct request *req, blk_status_t error) sshdr.byte6, sshdr.additional_length); } - bio_put(pre_req->bio); blk_mq_free_request(req); spin_lock_irqsave(&hpb->rgn_state_lock, flags); ufshpb_put_pre_req(pre_req->hpb, pre_req); @@ -427,27 +426,14 @@ static int ufshpb_prep_entry(struct ufshpb_req *pre_req, struct page *page) } static int ufshpb_pre_req_add_bio_page(struct ufshpb_lu *hpb, - struct request_queue *q, struct ufshpb_req *pre_req) { - struct page *page = pre_req->wb.m_page; - struct bio *bio = pre_req->bio; - int entries_bytes, ret; - - if (!page) + if (!pre_req->wb.m_page) return -ENOMEM; - if (ufshpb_prep_entry(pre_req, page)) + if (ufshpb_prep_entry(pre_req, pre_req->wb.m_page)) return -ENOMEM; - entries_bytes = pre_req->wb.len * sizeof(u64); - - ret = bio_add_pc_page(q, bio, page, entries_bytes, 0); - if (ret != entries_bytes) { - dev_err(&hpb->sdev_ufs_lu->sdev_dev, - "bio_add_pc_page fail: %d", ret); - return -ENOMEM; - } return 0; } @@ -472,7 +458,7 @@ static int ufshpb_execute_pre_req(struct ufshpb_lu *hpb, struct scsi_cmnd *cmd, blk_rq_pos(cmd->request)); pre_req->wb.len = sectors_to_logical(cmd->device, blk_rq_sectors(cmd->request)); - if (ufshpb_pre_req_add_bio_page(hpb, q, pre_req)) + if (ufshpb_pre_req_add_bio_page(hpb, pre_req)) return -ENOMEM; req = pre_req->req; @@ -482,7 +468,7 @@ static int ufshpb_execute_pre_req(struct ufshpb_lu *hpb, struct scsi_cmnd *cmd, req->rq_disk = NULL; req->end_io_data = (void *)pre_req; req->end_io = ufshpb_pre_req_compl_fn; - + dev_err(&hpb->sdev_ufs_lu->sdev_dev, "bi vcnt %d\n",bio->bi_vcnt); /* 2. scsi_request setup */ rq = scsi_req(req); rq->retries = 1; @@ -504,7 +490,6 @@ static int ufshpb_issue_pre_req(struct ufshpb_lu *hpb, struct scsi_cmnd *cmd, { struct ufshpb_req *pre_req; struct request *req = NULL; - struct bio *bio = NULL; unsigned long flags; int _read_id; int ret = 0; @@ -514,12 +499,6 @@ static int ufshpb_issue_pre_req(struct ufshpb_lu *hpb, struct scsi_cmnd *cmd, if (IS_ERR(req)) return -EAGAIN; - bio = bio_alloc(GFP_ATOMIC, 1); - if (!bio) { - blk_put_request(req); - return -EAGAIN; - } - spin_lock_irqsave(&hpb->rgn_state_lock, flags); pre_req = ufshpb_get_pre_req(hpb); if (!pre_req) { @@ -530,7 +509,7 @@ static int ufshpb_issue_pre_req(struct ufshpb_lu *hpb, struct scsi_cmnd *cmd, spin_unlock_irqrestore(&hpb->rgn_state_lock, flags); pre_req->req = req; - pre_req->bio = bio; + dev_err(&hpb->sdev_ufs_lu->sdev_dev,"bio->bi_vcnt %d\n",pre_req->bio->bi_vcnt); ret = ufshpb_execute_pre_req(hpb, cmd, pre_req, _read_id); if (ret) @@ -544,7 +523,6 @@ static int ufshpb_issue_pre_req(struct ufshpb_lu *hpb, struct scsi_cmnd *cmd, ufshpb_put_pre_req(hpb, pre_req); unlock_out: spin_unlock_irqrestore(&hpb->rgn_state_lock, flags); - bio_put(bio); blk_put_request(req); return ret; } @@ -625,7 +603,6 @@ int ufshpb_prep(struct ufs_hba *hba, struct ufshcd_lrb *lrbp) dev_err(hba->dev, "get ppn failed. err %d\n", err); return err; } - if (!ufshpb_is_legacy(hba) && ufshpb_is_required_wb(hpb, transfer_len)) { err = ufshpb_issue_pre_req(hpb, cmd, &read_id); @@ -1809,9 +1786,9 @@ struct attribute_group ufs_sysfs_hpb_param_group = { static int ufshpb_pre_req_mempool_init(struct ufshpb_lu *hpb) { - struct ufshpb_req *pre_req = NULL; + struct ufshpb_req *pre_req = NULL, *t; int qd = hpb->sdev_ufs_lu->queue_depth / 2; - int i, j; + int i; INIT_LIST_HEAD(&hpb->lh_pre_req_free); @@ -1823,23 +1800,46 @@ static int ufshpb_pre_req_mempool_init(struct ufshpb_lu *hpb) goto release_mem; for (i = 0; i < qd; i++) { + int ret; + pre_req = hpb->pre_req + i; INIT_LIST_HEAD(&pre_req->list_req); pre_req->req = NULL; - pre_req->bio = NULL; + + pre_req->bio = bio_alloc(GFP_KERNEL, 1); + if (!pre_req->bio) + goto release_mem; pre_req->wb.m_page = alloc_page(GFP_KERNEL | __GFP_ZERO); if (!pre_req->wb.m_page) { - for (j = 0; j < i; j++) - __free_page(hpb->pre_req[j].wb.m_page); + bio_put(pre_req->bio); + goto release_mem; + } + + ret = bio_add_pc_page(hpb->sdev_ufs_lu->request_queue, + pre_req->bio, pre_req->wb.m_page, + PAGE_SIZE, 0); + dev_err(&hpb->sdev_ufs_lu->sdev_dev,"bio->bi_vcnt %d\n",pre_req->bio->bi_vcnt); + if (ret != PAGE_SIZE) { + dev_err(&hpb->sdev_ufs_lu->sdev_dev, + "bio_add_pc_page fail: %d", ret); + bio_put(pre_req->bio); + __free_page(pre_req->wb.m_page); goto release_mem; } + list_add_tail(&pre_req->list_req, &hpb->lh_pre_req_free); } return 0; release_mem: + list_for_each_entry_safe(pre_req, t, &hpb->lh_pre_req_free, list_req) { + list_del_init(&pre_req->list_req); + bio_put(pre_req->bio); + __free_page(pre_req->wb.m_page); + } + kfree(hpb->pre_req); return -ENOMEM; } @@ -1851,6 +1851,7 @@ static void ufshpb_pre_req_mempool_destroy(struct ufshpb_lu *hpb) for (i = 0; i < hpb->throttle_pre_req; i++) { pre_req = hpb->pre_req + i; + bio_put(hpb->pre_req[i].bio); if (!pre_req->wb.m_page) __free_page(hpb->pre_req[i].wb.m_page); list_del_init(&pre_req->list_req); >Thanks, >Can Guo. > >> Thanks, >> Daejun >> >>> This is not an enhancement, but a doubt - why not? Unless it is not >>> doable. >>> >>> Thanks, >>> Can Guo. >>> >>>> >>>> Thanks >>>> Daejun >>>> >>>>> Can Guo. >>>>> >>>>>> Thanks, >>>>>> Can Guo. >>>>>> >>>>>>> After use it, it should be prepared bio at issue phase. >>>>>>> >>>>>>> Thanks, >>>>>>> Daejun >>>>>>> >>>>>>>> >>>>>>>> Thanks, >>>>>>>> Can Guo. >>>>>>>> >>>>>>>>> + >>>>>>>>> + pre_req->wb.m_page = alloc_page(GFP_KERNEL | >>>>>>>>> __GFP_ZERO); >>>>>>>>> + if (!pre_req->wb.m_page) { >>>>>>>>> + for (j = 0; j < i; j++) >>>>>>>>> + >>>>>>>>> __free_page(hpb->pre_req[j].wb.m_page); >>>>>>>>> + >>>>>>>>> + goto release_mem; >>>>>>>>> + } >>>>>>>>> + list_add_tail(&pre_req->list_req, >>>>>>>>> &hpb->lh_pre_req_free); >>>>>>>>> + } >>>>>>>>> + >>>>>>>>> + return 0; >>>>>>>>> +release_mem: >>>>>>>>> + kfree(hpb->pre_req); >>>>>>>>> + return -ENOMEM; >>>>>>>>> +} >>>>>>>>> + >>>>>>>> >>>>>>>> >>>>>>>> >>>>> >>>>> >>>>> >>> >>> >>> > > >
On 2021-03-18 10:02, Daejun Park wrote: >> On 2021-03-17 09:42, Daejun Park wrote: >>>> On 2021-03-15 15:23, Can Guo wrote: >>>>> On 2021-03-15 15:07, Daejun Park wrote: >>>>>>>> This patch supports the HPB 2.0. >>>>>>>> >>>>>>>> The HPB 2.0 supports read of varying sizes from 4KB to 512KB. >>>>>>>> In the case of Read (<= 32KB) is supported as single HPB read. >>>>>>>> In the case of Read (36KB ~ 512KB) is supported by as a >>>>>>>> combination >>>>>>>> of >>>>>>>> write buffer command and HPB read command to deliver more PPN. >>>>>>>> The write buffer commands may not be issued immediately due to >>>>>>>> busy >>>>>>>> tags. >>>>>>>> To use HPB read more aggressively, the driver can requeue the >>>>>>>> write >>>>>>>> buffer >>>>>>>> command. The requeue threshold is implemented as timeout and can >>>>>>>> be >>>>>>>> modified with requeue_timeout_ms entry in sysfs. >>>>>>>> >>>>>>>> Signed-off-by: Daejun Park <daejun7.park@samsung.com> >>>>>>>> --- >>>>>>>> +static struct attribute *hpb_dev_param_attrs[] = { >>>>>>>> + &dev_attr_requeue_timeout_ms.attr, >>>>>>>> + NULL, >>>>>>>> +}; >>>>>>>> + >>>>>>>> +struct attribute_group ufs_sysfs_hpb_param_group = { >>>>>>>> + .name = "hpb_param_sysfs", >>>>>>>> + .attrs = hpb_dev_param_attrs, >>>>>>>> +}; >>>>>>>> + >>>>>>>> +static int ufshpb_pre_req_mempool_init(struct ufshpb_lu *hpb) >>>>>>>> +{ >>>>>>>> + struct ufshpb_req *pre_req = NULL; >>>>>>>> + int qd = hpb->sdev_ufs_lu->queue_depth / 2; >>>>>>>> + int i, j; >>>>>>>> + >>>>>>>> + INIT_LIST_HEAD(&hpb->lh_pre_req_free); >>>>>>>> + >>>>>>>> + hpb->pre_req = kcalloc(qd, sizeof(struct ufshpb_req), >>>>>>>> GFP_KERNEL); >>>>>>>> + hpb->throttle_pre_req = qd; >>>>>>>> + hpb->num_inflight_pre_req = 0; >>>>>>>> + >>>>>>>> + if (!hpb->pre_req) >>>>>>>> + goto release_mem; >>>>>>>> + >>>>>>>> + for (i = 0; i < qd; i++) { >>>>>>>> + pre_req = hpb->pre_req + i; >>>>>>>> + INIT_LIST_HEAD(&pre_req->list_req); >>>>>>>> + pre_req->req = NULL; >>>>>>>> + pre_req->bio = NULL; >>>>>>> >>>>>>> Why don't prepare bio as same as wb.m_page? Won't that save more >>>>>>> time >>>>>>> for ufshpb_issue_pre_req()? >>>>>> >>>>>> It is pre_req pool. So although we prepare bio at this time, it >>>>>> just >>>>>> only for first pre_req. >>>>> >>>>> I meant removing the bio_alloc() in ufshpb_issue_pre_req() and >>>>> bio_put() >>>>> in ufshpb_pre_req_compl_fn(). bios, in pre_req's case, just hold a >>>>> page. >>>>> So, prepare 16 (if queue depth is 32) bios here, just use them >>>>> along >>>>> with >>>>> wb.m_page and call bio_reset() in ufshpb_pre_req_compl_fn(). Shall >>>>> it >>>>> work? >>>>> >>>> >>>> If it works, you can even have the bio_add_pc_page() called here. >>>> Later >>>> in >>>> ufshpb_execute_pre_req(), you don't need to call >>>> ufshpb_pre_req_add_bio_page(), >>>> just call ufshpb_prep_entry() once instead - it save many repeated >>>> steps >>>> for a >>>> pre_req, and you don't even need to call bio_reset() in this case, >>>> since >>>> for a >>>> bio, nothing changes after it is binded with a specific page... >>> >>> Hi, Can Guo >>> >>> I tried the idea that you suggested, but it doesn't work properly. >>> This optimization should be done next time for enhancement. >> >> Can you elaborate please? Any error seen? >> >> Per my understanding, in the case for pre_reqs, a bio is no different >> from a page. Here it can reserve 16 pages for later use, which can be >> done the same for bios. > > I found some problem with re-using pre allocated bio. > > The following kernel message is related with problem. > [ 2.750530] ------------[ cut here ]------------ > [ 2.751404] WARNING: CPU: 4 PID: 170 at > drivers/scsi/scsi_lib.c:1020 scsi_alloc_sgtables+0x253/0x2b0 > [ 2.753054] Modules linked in: > [ 2.753651] CPU: 4 PID: 170 Comm: mount Not tainted 5.12.0-rc1+ #331 > [ 2.754752] Hardware name: QEMU Standard PC (i440FX + PIIX, 1996), > BIOS rel-1.13.0-0-gf21b5a4aeb02-prebuilt.qemu.org 04/01/2014 > [ 2.756813] RIP: 0010:scsi_alloc_sgtables+0x253/0x2b0 > [ 2.757699] Code: 85 c0 74 19 41 0f b6 44 24 18 8d 50 e0 83 fa 03 > 76 30 41 bd 01 00 00 00 e9 1f fe ff ff be 01 00 00 00 45 31 ed e9 19 > fe ff ff <0f> 0b b8 0a f > [ 2.761021] RSP: 0018:ffffb06e0027f538 EFLAGS: 00010246 > [ 2.761902] RAX: 0000000000000000 RBX: ffff9c3a42d424d0 RCX: > ffffb06e0027f5e0 > [ 2.763184] RDX: ffff9c3a42d426a8 RSI: 0000000000000000 RDI: > ffff9c3a42d424d0 > [ 2.764446] RBP: ffffb06e0027f570 R08: 0000000000000000 R09: > 0000000000000000 > [ 2.765704] R10: ffffffff8eb0dda0 R11: 00000000fffb7675 R12: > ffff9c3a42d423c0 > [ 2.766976] R13: 0000000000000000 R14: ffff9c3a41bed000 R15: > ffff9c3a420f4000 > [ 2.768225] FS: 00007f42d1eab100(0000) GS:ffff9c3b77c00000(0000) > knlGS:0000000000000000 > [ 2.769666] CS: 0010 DS: 0000 ES: 0000 CR0: 0000000080050033 > [ 2.770719] CR2: 00007f42d1ac1000 CR3: 0000000104bee006 CR4: > 0000000000370ee0 > [ 2.771997] DR0: 0000000000000000 DR1: 0000000000000000 DR2: > 0000000000000000 > [ 2.773288] DR3: 0000000000000000 DR6: 00000000fffe0ff0 DR7: > 0000000000000400 > [ 2.774543] Call Trace: > [ 2.775092] scsi_queue_rq+0x9b6/0xb20 > [ 2.775754] __blk_mq_try_issue_directly+0x150/0x1f0 > [ 2.776636] blk_mq_request_issue_directly+0x49/0x80 > [ 2.777616] blk_insert_cloned_request+0x85/0xd0 > [ 2.778470] ufshpb_prep.cold+0x793/0x7be > [ 2.779179] ufshcd_queuecommand+0x114/0x690 > [ 2.779986] scsi_queue_rq+0x38a/0xb20 > [ 2.780755] blk_mq_dispatch_rq_list+0x13d/0x760 > [ 2.781605] ? dd_dispatch_request+0x67/0x1c0 > [ 2.782337] __blk_mq_do_dispatch_sched+0xb5/0x2c0 > [ 2.783291] __blk_mq_sched_dispatch_requests+0x13c/0x180 > [ 2.784209] blk_mq_sched_dispatch_requests+0x30/0x60 > [ 2.785195] __blk_mq_run_hw_queue+0x49/0x90 > [ 2.786024] __blk_mq_delay_run_hw_queue+0x162/0x180 > [ 2.786890] blk_mq_run_hw_queue+0x85/0xe0 > [ 2.787590] blk_mq_sched_insert_requests+0xdf/0x2b0 > [ 2.788558] blk_mq_flush_plug_list+0x118/0x240 > [ 2.789405] blk_flush_plug_list+0xde/0x110 > [ 2.790225] blk_finish_plug+0x21/0x30 > [ 2.790878] read_pages+0x16a/0x1d0 > [ 2.791534] page_cache_ra_unbounded+0x123/0x1c0 > [ 2.792392] do_page_cache_ra+0x38/0x40 > [ 2.793183] force_page_cache_ra+0x97/0x110 > [ 2.793875] page_cache_sync_ra+0x26/0x50 > [ 2.794671] filemap_get_pages+0xc8/0x4b0 > [ 2.795482] filemap_read+0xc9/0x340 > [ 2.796144] ? find_held_lock+0x31/0x90 > [ 2.796809] generic_file_read_iter+0xcc/0x130 > [ 2.797644] blkdev_read_iter+0x30/0x40 > [ 2.798436] new_sync_read+0x10e/0x190 > [ 2.799112] vfs_read+0x178/0x1d0 > [ 2.799732] ksys_read+0x6b/0xf0 > [ 2.800361] __x64_sys_read+0x15/0x20 > [ 2.801027] do_syscall_64+0x38/0x50 > [ 2.801770] entry_SYSCALL_64_after_hwframe+0x44/0xae > [ 2.802655] RIP: 0033:0x7f42d209a461 > [ 2.803313] Code: fe ff ff 50 48 8d 3d fe d0 09 00 e8 e9 03 02 00 > 66 0f 1f 84 00 00 00 00 00 48 8d 05 99 62 0d 00 8b 00 85 c0 75 13 31 > c0 0f 05 <48> 3d 00 f0 8 > [ 2.806632] RSP: 002b:00007ffe7b88bc88 EFLAGS: 00000246 ORIG_RAX: > 0000000000000000 > [ 2.807942] RAX: ffffffffffffffda RBX: 000055ccb2e070d0 RCX: > 00007f42d209a461 > [ 2.809218] RDX: 0000000000040000 RSI: 00007f42d1ac1038 RDI: > 0000000000000004 > [ 2.810482] RBP: 000055ccb2e07120 R08: 00007f42d1ac1010 R09: > 0000000000000000 > [ 2.811729] R10: 0000000000000022 R11: 0000000000000246 R12: > 0000003b95fc0000 > [ 2.813005] R13: 0000000000040000 R14: 00007f42d1ac1028 R15: > 00007f42d1ac1010 > [ 2.814276] irq event stamp: 9319 > [ 2.814868] hardirqs last enabled at (9327): [<ffffffff8c4d2033>] > console_unlock+0x4d3/0x5e0 > [ 2.816349] hardirqs last disabled at (9336): [<ffffffff8c4d1fa6>] > console_unlock+0x446/0x5e0 > [ 2.817837] softirqs last enabled at (8674): [<ffffffff8d4002ec>] > __do_softirq+0x2ec/0x40f > [ 2.819298] softirqs last disabled at (8669): [<ffffffff8c46ad9e>] > irq_exit_rcu+0xae/0xb0 > [ 2.820744] ---[ end trace af3986a7787eeecf ]--- > > It is related to bi_iter value of bio is changed after use it. Understood the problem now, let's take the 1st way - 1. prepare bios in ufshpb_pre_req_mempool_init() (leave bio_add_pc_page() where it was) 2. call bio_reset() in ufshpb_put_pre_req() This should work. Thanks, Can Guo. > > Thanks, > Daejun > >> This is not an enhancement, but a doubt - why not? Unless it is not >> doable. >> >> Thanks, >> Can Guo. >> >>> >>> Thanks >>> Daejun >>> >>>> Can Guo. >>>> >>>>> Thanks, >>>>> Can Guo. >>>>> >>>>>> After use it, it should be prepared bio at issue phase. >>>>>> >>>>>> Thanks, >>>>>> Daejun >>>>>> >>>>>>> >>>>>>> Thanks, >>>>>>> Can Guo. >>>>>>> >>>>>>>> + >>>>>>>> + pre_req->wb.m_page = alloc_page(GFP_KERNEL | >>>>>>>> __GFP_ZERO); >>>>>>>> + if (!pre_req->wb.m_page) { >>>>>>>> + for (j = 0; j < i; j++) >>>>>>>> + >>>>>>>> __free_page(hpb->pre_req[j].wb.m_page); >>>>>>>> + >>>>>>>> + goto release_mem; >>>>>>>> + } >>>>>>>> + list_add_tail(&pre_req->list_req, >>>>>>>> &hpb->lh_pre_req_free); >>>>>>>> + } >>>>>>>> + >>>>>>>> + return 0; >>>>>>>> +release_mem: >>>>>>>> + kfree(hpb->pre_req); >>>>>>>> + return -ENOMEM; >>>>>>>> +} >>>>>>>> + >>>>>>> >>>>>>> >>>>>>> >>>> >>>> >>>> >> >> >>
>On 2021-03-18 10:02, Daejun Park wrote: >>> On 2021-03-17 09:42, Daejun Park wrote: >>>>> On 2021-03-15 15:23, Can Guo wrote: >>>>>> On 2021-03-15 15:07, Daejun Park wrote: >>>>>>>>> This patch supports the HPB 2.0. >>>>>>>>> >>>>>>>>> The HPB 2.0 supports read of varying sizes from 4KB to 512KB. >>>>>>>>> In the case of Read (<= 32KB) is supported as single HPB read. >>>>>>>>> In the case of Read (36KB ~ 512KB) is supported by as a >>>>>>>>> combination >>>>>>>>> of >>>>>>>>> write buffer command and HPB read command to deliver more PPN. >>>>>>>>> The write buffer commands may not be issued immediately due to >>>>>>>>> busy >>>>>>>>> tags. >>>>>>>>> To use HPB read more aggressively, the driver can requeue the >>>>>>>>> write >>>>>>>>> buffer >>>>>>>>> command. The requeue threshold is implemented as timeout and can >>>>>>>>> be >>>>>>>>> modified with requeue_timeout_ms entry in sysfs. >>>>>>>>> >>>>>>>>> Signed-off-by: Daejun Park <daejun7.park@samsung.com> >>>>>>>>> --- >>>>>>>>> +static struct attribute *hpb_dev_param_attrs[] = { >>>>>>>>> + &dev_attr_requeue_timeout_ms.attr, >>>>>>>>> + NULL, >>>>>>>>> +}; >>>>>>>>> + >>>>>>>>> +struct attribute_group ufs_sysfs_hpb_param_group = { >>>>>>>>> + .name = "hpb_param_sysfs", >>>>>>>>> + .attrs = hpb_dev_param_attrs, >>>>>>>>> +}; >>>>>>>>> + >>>>>>>>> +static int ufshpb_pre_req_mempool_init(struct ufshpb_lu *hpb) >>>>>>>>> +{ >>>>>>>>> + struct ufshpb_req *pre_req = NULL; >>>>>>>>> + int qd = hpb->sdev_ufs_lu->queue_depth / 2; >>>>>>>>> + int i, j; >>>>>>>>> + >>>>>>>>> + INIT_LIST_HEAD(&hpb->lh_pre_req_free); >>>>>>>>> + >>>>>>>>> + hpb->pre_req = kcalloc(qd, sizeof(struct ufshpb_req), >>>>>>>>> GFP_KERNEL); >>>>>>>>> + hpb->throttle_pre_req = qd; >>>>>>>>> + hpb->num_inflight_pre_req = 0; >>>>>>>>> + >>>>>>>>> + if (!hpb->pre_req) >>>>>>>>> + goto release_mem; >>>>>>>>> + >>>>>>>>> + for (i = 0; i < qd; i++) { >>>>>>>>> + pre_req = hpb->pre_req + i; >>>>>>>>> + INIT_LIST_HEAD(&pre_req->list_req); >>>>>>>>> + pre_req->req = NULL; >>>>>>>>> + pre_req->bio = NULL; >>>>>>>> >>>>>>>> Why don't prepare bio as same as wb.m_page? Won't that save more >>>>>>>> time >>>>>>>> for ufshpb_issue_pre_req()? >>>>>>> >>>>>>> It is pre_req pool. So although we prepare bio at this time, it >>>>>>> just >>>>>>> only for first pre_req. >>>>>> >>>>>> I meant removing the bio_alloc() in ufshpb_issue_pre_req() and >>>>>> bio_put() >>>>>> in ufshpb_pre_req_compl_fn(). bios, in pre_req's case, just hold a >>>>>> page. >>>>>> So, prepare 16 (if queue depth is 32) bios here, just use them >>>>>> along >>>>>> with >>>>>> wb.m_page and call bio_reset() in ufshpb_pre_req_compl_fn(). Shall >>>>>> it >>>>>> work? >>>>>> >>>>> >>>>> If it works, you can even have the bio_add_pc_page() called here. >>>>> Later >>>>> in >>>>> ufshpb_execute_pre_req(), you don't need to call >>>>> ufshpb_pre_req_add_bio_page(), >>>>> just call ufshpb_prep_entry() once instead - it save many repeated >>>>> steps >>>>> for a >>>>> pre_req, and you don't even need to call bio_reset() in this case, >>>>> since >>>>> for a >>>>> bio, nothing changes after it is binded with a specific page... >>>> >>>> Hi, Can Guo >>>> >>>> I tried the idea that you suggested, but it doesn't work properly. >>>> This optimization should be done next time for enhancement. >>> >>> Can you elaborate please? Any error seen? >>> >>> Per my understanding, in the case for pre_reqs, a bio is no different >>> from a page. Here it can reserve 16 pages for later use, which can be >>> done the same for bios. >> >> I found some problem with re-using pre allocated bio. >> >> The following kernel message is related with problem. >> [ 2.750530] ------------[ cut here ]------------ >> [ 2.751404] WARNING: CPU: 4 PID: 170 at >> drivers/scsi/scsi_lib.c:1020 scsi_alloc_sgtables+0x253/0x2b0 >> [ 2.753054] Modules linked in: >> [ 2.753651] CPU: 4 PID: 170 Comm: mount Not tainted 5.12.0-rc1+ #331 >> [ 2.754752] Hardware name: QEMU Standard PC (i440FX + PIIX, 1996), >> BIOS rel-1.13.0-0-gf21b5a4aeb02-prebuilt.qemu.org 04/01/2014 >> [ 2.756813] RIP: 0010:scsi_alloc_sgtables+0x253/0x2b0 >> [ 2.757699] Code: 85 c0 74 19 41 0f b6 44 24 18 8d 50 e0 83 fa 03 >> 76 30 41 bd 01 00 00 00 e9 1f fe ff ff be 01 00 00 00 45 31 ed e9 19 >> fe ff ff <0f> 0b b8 0a f >> [ 2.761021] RSP: 0018:ffffb06e0027f538 EFLAGS: 00010246 >> [ 2.761902] RAX: 0000000000000000 RBX: ffff9c3a42d424d0 RCX: >> ffffb06e0027f5e0 >> [ 2.763184] RDX: ffff9c3a42d426a8 RSI: 0000000000000000 RDI: >> ffff9c3a42d424d0 >> [ 2.764446] RBP: ffffb06e0027f570 R08: 0000000000000000 R09: >> 0000000000000000 >> [ 2.765704] R10: ffffffff8eb0dda0 R11: 00000000fffb7675 R12: >> ffff9c3a42d423c0 >> [ 2.766976] R13: 0000000000000000 R14: ffff9c3a41bed000 R15: >> ffff9c3a420f4000 >> [ 2.768225] FS: 00007f42d1eab100(0000) GS:ffff9c3b77c00000(0000) >> knlGS:0000000000000000 >> [ 2.769666] CS: 0010 DS: 0000 ES: 0000 CR0: 0000000080050033 >> [ 2.770719] CR2: 00007f42d1ac1000 CR3: 0000000104bee006 CR4: >> 0000000000370ee0 >> [ 2.771997] DR0: 0000000000000000 DR1: 0000000000000000 DR2: >> 0000000000000000 >> [ 2.773288] DR3: 0000000000000000 DR6: 00000000fffe0ff0 DR7: >> 0000000000000400 >> [ 2.774543] Call Trace: >> [ 2.775092] scsi_queue_rq+0x9b6/0xb20 >> [ 2.775754] __blk_mq_try_issue_directly+0x150/0x1f0 >> [ 2.776636] blk_mq_request_issue_directly+0x49/0x80 >> [ 2.777616] blk_insert_cloned_request+0x85/0xd0 >> [ 2.778470] ufshpb_prep.cold+0x793/0x7be >> [ 2.779179] ufshcd_queuecommand+0x114/0x690 >> [ 2.779986] scsi_queue_rq+0x38a/0xb20 >> [ 2.780755] blk_mq_dispatch_rq_list+0x13d/0x760 >> [ 2.781605] ? dd_dispatch_request+0x67/0x1c0 >> [ 2.782337] __blk_mq_do_dispatch_sched+0xb5/0x2c0 >> [ 2.783291] __blk_mq_sched_dispatch_requests+0x13c/0x180 >> [ 2.784209] blk_mq_sched_dispatch_requests+0x30/0x60 >> [ 2.785195] __blk_mq_run_hw_queue+0x49/0x90 >> [ 2.786024] __blk_mq_delay_run_hw_queue+0x162/0x180 >> [ 2.786890] blk_mq_run_hw_queue+0x85/0xe0 >> [ 2.787590] blk_mq_sched_insert_requests+0xdf/0x2b0 >> [ 2.788558] blk_mq_flush_plug_list+0x118/0x240 >> [ 2.789405] blk_flush_plug_list+0xde/0x110 >> [ 2.790225] blk_finish_plug+0x21/0x30 >> [ 2.790878] read_pages+0x16a/0x1d0 >> [ 2.791534] page_cache_ra_unbounded+0x123/0x1c0 >> [ 2.792392] do_page_cache_ra+0x38/0x40 >> [ 2.793183] force_page_cache_ra+0x97/0x110 >> [ 2.793875] page_cache_sync_ra+0x26/0x50 >> [ 2.794671] filemap_get_pages+0xc8/0x4b0 >> [ 2.795482] filemap_read+0xc9/0x340 >> [ 2.796144] ? find_held_lock+0x31/0x90 >> [ 2.796809] generic_file_read_iter+0xcc/0x130 >> [ 2.797644] blkdev_read_iter+0x30/0x40 >> [ 2.798436] new_sync_read+0x10e/0x190 >> [ 2.799112] vfs_read+0x178/0x1d0 >> [ 2.799732] ksys_read+0x6b/0xf0 >> [ 2.800361] __x64_sys_read+0x15/0x20 >> [ 2.801027] do_syscall_64+0x38/0x50 >> [ 2.801770] entry_SYSCALL_64_after_hwframe+0x44/0xae >> [ 2.802655] RIP: 0033:0x7f42d209a461 >> [ 2.803313] Code: fe ff ff 50 48 8d 3d fe d0 09 00 e8 e9 03 02 00 >> 66 0f 1f 84 00 00 00 00 00 48 8d 05 99 62 0d 00 8b 00 85 c0 75 13 31 >> c0 0f 05 <48> 3d 00 f0 8 >> [ 2.806632] RSP: 002b:00007ffe7b88bc88 EFLAGS: 00000246 ORIG_RAX: >> 0000000000000000 >> [ 2.807942] RAX: ffffffffffffffda RBX: 000055ccb2e070d0 RCX: >> 00007f42d209a461 >> [ 2.809218] RDX: 0000000000040000 RSI: 00007f42d1ac1038 RDI: >> 0000000000000004 >> [ 2.810482] RBP: 000055ccb2e07120 R08: 00007f42d1ac1010 R09: >> 0000000000000000 >> [ 2.811729] R10: 0000000000000022 R11: 0000000000000246 R12: >> 0000003b95fc0000 >> [ 2.813005] R13: 0000000000040000 R14: 00007f42d1ac1028 R15: >> 00007f42d1ac1010 >> [ 2.814276] irq event stamp: 9319 >> [ 2.814868] hardirqs last enabled at (9327): [<ffffffff8c4d2033>] >> console_unlock+0x4d3/0x5e0 >> [ 2.816349] hardirqs last disabled at (9336): [<ffffffff8c4d1fa6>] >> console_unlock+0x446/0x5e0 >> [ 2.817837] softirqs last enabled at (8674): [<ffffffff8d4002ec>] >> __do_softirq+0x2ec/0x40f >> [ 2.819298] softirqs last disabled at (8669): [<ffffffff8c46ad9e>] >> irq_exit_rcu+0xae/0xb0 >> [ 2.820744] ---[ end trace af3986a7787eeecf ]--- >> >> It is related to bi_iter value of bio is changed after use it. > >Understood the problem now, let's take the 1st way - >1. prepare bios in ufshpb_pre_req_mempool_init() (leave >bio_add_pc_page() where it was) >2. call bio_reset() in ufshpb_put_pre_req() > >This should work. OK, I will try this. Thanks, Daejuin >Thanks, >Can Guo. > >> >> Thanks, >> Daejun >> >>> This is not an enhancement, but a doubt - why not? Unless it is not >>> doable. >>> >>> Thanks, >>> Can Guo. >>> >>>> >>>> Thanks >>>> Daejun >>>> >>>>> Can Guo. >>>>> >>>>>> Thanks, >>>>>> Can Guo. >>>>>> >>>>>>> After use it, it should be prepared bio at issue phase. >>>>>>> >>>>>>> Thanks, >>>>>>> Daejun >>>>>>> >>>>>>>> >>>>>>>> Thanks, >>>>>>>> Can Guo. >>>>>>>> >>>>>>>>> + >>>>>>>>> + pre_req->wb.m_page = alloc_page(GFP_KERNEL | >>>>>>>>> __GFP_ZERO); >>>>>>>>> + if (!pre_req->wb.m_page) { >>>>>>>>> + for (j = 0; j < i; j++) >>>>>>>>> + >>>>>>>>> __free_page(hpb->pre_req[j].wb.m_page); >>>>>>>>> + >>>>>>>>> + goto release_mem; >>>>>>>>> + } >>>>>>>>> + list_add_tail(&pre_req->list_req, >>>>>>>>> &hpb->lh_pre_req_free); >>>>>>>>> + } >>>>>>>>> + >>>>>>>>> + return 0; >>>>>>>>> +release_mem: >>>>>>>>> + kfree(hpb->pre_req); >>>>>>>>> + return -ENOMEM; >>>>>>>>> +} >>>>>>>>> + >>>>>>>> >>>>>>>> >>>>>>>> >>>>> >>>>> >>>>> >>> >>> >>> > > >
> +static int ufshpb_execute_umap_req(struct ufshpb_lu *hpb, > + struct ufshpb_req *umap_req, > + struct ufshpb_region *rgn) > +{ > + struct request *req; > + struct scsi_request *rq; > + > + req = umap_req->req; > + req->timeout = 0; > + req->end_io_data = (void *)umap_req; > + rq = scsi_req(req); > + ufshpb_set_unmap_cmd(rq->cmd, rgn); > + rq->cmd_len = HPB_WRITE_BUFFER_CMD_LENGTH; > + > + blk_execute_rq_nowait(NULL, req, 1, ufshpb_umap_req_compl_fn); Typo? Forgot the struct request_queue *q? > + > + return 0; > +} > + > static int ufshpb_execute_map_req(struct ufshpb_lu *hpb, > struct ufshpb_req *map_req, bool last) > { > @@ -533,12 +878,12 @@ static int ufshpb_execute_map_req(struct ufshpb_lu > *hpb, > > q = hpb->sdev_ufs_lu->request_queue; > for (i = 0; i < hpb->pages_per_srgn; i++) { > - ret = bio_add_pc_page(q, map_req->bio, map_req->mctx->m_page[i], > + ret = bio_add_pc_page(q, map_req->bio, map_req->rb.mctx- > >m_page[i], > PAGE_SIZE, 0); > if (ret != PAGE_SIZE) { > dev_err(&hpb->sdev_ufs_lu->sdev_dev, > "bio_add_pc_page fail %d - %d\n", > - map_req->rgn_idx, map_req->srgn_idx); > + map_req->rb.rgn_idx, map_req->rb.srgn_idx); > return ret; > } > } > @@ -554,8 +899,8 @@ static int ufshpb_execute_map_req(struct ufshpb_lu > *hpb, > if (unlikely(last)) > mem_size = hpb->last_srgn_entries * HPB_ENTRY_SIZE; > > - ufshpb_set_read_buf_cmd(rq->cmd, map_req->rgn_idx, > - map_req->srgn_idx, mem_size); > + ufshpb_set_read_buf_cmd(rq->cmd, map_req->rb.rgn_idx, > + map_req->rb.srgn_idx, mem_size); > rq->cmd_len = HPB_READ_BUFFER_CMD_LENGTH; > > blk_execute_rq_nowait(NULL, req, 1, ufshpb_map_req_compl_fn); Ditto Thanks, Avri
Hi Avri, >> +static int ufshpb_execute_umap_req(struct ufshpb_lu *hpb, >> + struct ufshpb_req *umap_req, >> + struct ufshpb_region *rgn) >> +{ >> + struct request *req; >> + struct scsi_request *rq; >> + >> + req = umap_req->req; >> + req->timeout = 0; >> + req->end_io_data = (void *)umap_req; >> + rq = scsi_req(req); >> + ufshpb_set_unmap_cmd(rq->cmd, rgn); >> + rq->cmd_len = HPB_WRITE_BUFFER_CMD_LENGTH; >> + >> + blk_execute_rq_nowait(NULL, req, 1, ufshpb_umap_req_compl_fn); >Typo? Forgot the struct request_queue *q? The argument of q is removed after this patch. https://lore.kernel.org/linux-scsi/1611550198-17142-1-git-send-email-guoqing.jiang@cloud.ionos.com/#r Thanks, Daejun >> + >> + return 0; >> +} >> + >> static int ufshpb_execute_map_req(struct ufshpb_lu *hpb, >> struct ufshpb_req *map_req, bool last) >> { >> @@ -533,12 +878,12 @@ static int ufshpb_execute_map_req(struct ufshpb_lu >> *hpb, >> >> q = hpb->sdev_ufs_lu->request_queue; >> for (i = 0; i < hpb->pages_per_srgn; i++) { >> - ret = bio_add_pc_page(q, map_req->bio, map_req->mctx->m_page[i], >> + ret = bio_add_pc_page(q, map_req->bio, map_req->rb.mctx- >> >m_page[i], >> PAGE_SIZE, 0); >> if (ret != PAGE_SIZE) { >> dev_err(&hpb->sdev_ufs_lu->sdev_dev, >> "bio_add_pc_page fail %d - %d\n", >> - map_req->rgn_idx, map_req->srgn_idx); >> + map_req->rb.rgn_idx, map_req->rb.srgn_idx); >> return ret; >> } >> } >> @@ -554,8 +899,8 @@ static int ufshpb_execute_map_req(struct ufshpb_lu >> *hpb, >> if (unlikely(last)) >> mem_size = hpb->last_srgn_entries * HPB_ENTRY_SIZE; >> >> - ufshpb_set_read_buf_cmd(rq->cmd, map_req->rgn_idx, >> - map_req->srgn_idx, mem_size); >> + ufshpb_set_read_buf_cmd(rq->cmd, map_req->rb.rgn_idx, >> + map_req->rb.srgn_idx, mem_size); >> rq->cmd_len = HPB_READ_BUFFER_CMD_LENGTH; >> >> blk_execute_rq_nowait(NULL, req, 1, ufshpb_map_req_compl_fn); >Ditto > > >Thanks, >Avri > > >
diff --git a/Documentation/ABI/testing/sysfs-driver-ufs b/Documentation/ABI/testing/sysfs-driver-ufs index 528bf89fc98b..419adf450b89 100644 --- a/Documentation/ABI/testing/sysfs-driver-ufs +++ b/Documentation/ABI/testing/sysfs-driver-ufs @@ -1253,14 +1253,14 @@ Description: This entry shows the number of HPB pinned regions assigned to The file is read only. -What: /sys/class/scsi_device/*/device/hpb_sysfs/hit_cnt +What: /sys/class/scsi_device/*/device/hpb_stat_sysfs/hit_cnt Date: March 2021 Contact: Daejun Park <daejun7.park@samsung.com> Description: This entry shows the number of reads that changed to HPB read. The file is read only. -What: /sys/class/scsi_device/*/device/hpb_sysfs/miss_cnt +What: /sys/class/scsi_device/*/device/hpb_stat_sysfs/miss_cnt Date: March 2021 Contact: Daejun Park <daejun7.park@samsung.com> Description: This entry shows the number of reads that cannot be changed to @@ -1268,7 +1268,7 @@ Description: This entry shows the number of reads that cannot be changed to The file is read only. -What: /sys/class/scsi_device/*/device/hpb_sysfs/rb_noti_cnt +What: /sys/class/scsi_device/*/device/hpb_stat_sysfs/rb_noti_cnt Date: March 2021 Contact: Daejun Park <daejun7.park@samsung.com> Description: This entry shows the number of response UPIUs that has @@ -1276,7 +1276,7 @@ Description: This entry shows the number of response UPIUs that has The file is read only. -What: /sys/class/scsi_device/*/device/hpb_sysfs/rb_active_cnt +What: /sys/class/scsi_device/*/device/hpb_stat_sysfs/rb_active_cnt Date: March 2021 Contact: Daejun Park <daejun7.park@samsung.com> Description: This entry shows the number of active sub-regions recommended by @@ -1284,7 +1284,7 @@ Description: This entry shows the number of active sub-regions recommended by The file is read only. -What: /sys/class/scsi_device/*/device/hpb_sysfs/rb_inactive_cnt +What: /sys/class/scsi_device/*/device/hpb_stat_sysfs/rb_inactive_cnt Date: March 2021 Contact: Daejun Park <daejun7.park@samsung.com> Description: This entry shows the number of inactive regions recommended by @@ -1292,10 +1292,45 @@ Description: This entry shows the number of inactive regions recommended by The file is read only. -What: /sys/class/scsi_device/*/device/hpb_sysfs/map_req_cnt +What: /sys/class/scsi_device/*/device/hpb_stat_sysfs/map_req_cnt Date: March 2021 Contact: Daejun Park <daejun7.park@samsung.com> Description: This entry shows the number of read buffer commands for activating sub-regions recommended by response UPIUs. The file is read only. + +What: /sys/class/scsi_device/*/device/hpb_param_sysfs/requeue_timeout_ms +Date: March 2021 +Contact: Daejun Park <daejun7.park@samsung.com> +Description: This entry shows the requeue timeout threshold for write buffer + command in ms. This value can be changed by writing proper integer to + this entry. + +What: /sys/bus/platform/drivers/ufshcd/*/attributes/max_data_size_hpb_single_cmd +Date: March 2021 +Contact: Daejun Park <daejun7.park@samsung.com> +Description: This entry shows the maximum HPB data size for using single HPB + command. + + === ======== + 00h 4KB + 01h 8KB + 02h 12KB + ... + FFh 1024KB + === ======== + + The file is read only. + +What: /sys/bus/platform/drivers/ufshcd/*/flags/wb_enable +Date: March 2021 +Contact: Daejun Park <daejun7.park@samsung.com> +Description: This entry shows the status of HPB. + + == ============================ + 0 HPB is not enabled. + 1 HPB is enabled + == ============================ + + The file is read only. diff --git a/drivers/scsi/ufs/ufs-sysfs.c b/drivers/scsi/ufs/ufs-sysfs.c index 2546e7a1ac4f..92a883866e12 100644 --- a/drivers/scsi/ufs/ufs-sysfs.c +++ b/drivers/scsi/ufs/ufs-sysfs.c @@ -782,6 +782,7 @@ UFS_FLAG(disable_fw_update, _PERMANENTLY_DISABLE_FW_UPDATE); UFS_FLAG(wb_enable, _WB_EN); UFS_FLAG(wb_flush_en, _WB_BUFF_FLUSH_EN); UFS_FLAG(wb_flush_during_h8, _WB_BUFF_FLUSH_DURING_HIBERN8); +UFS_FLAG(hpb_enable, _HPB_EN); static struct attribute *ufs_sysfs_device_flags[] = { &dev_attr_device_init.attr, @@ -795,6 +796,7 @@ static struct attribute *ufs_sysfs_device_flags[] = { &dev_attr_wb_enable.attr, &dev_attr_wb_flush_en.attr, &dev_attr_wb_flush_during_h8.attr, + &dev_attr_hpb_enable.attr, NULL, }; @@ -841,6 +843,7 @@ out: \ static DEVICE_ATTR_RO(_name) UFS_ATTRIBUTE(boot_lun_enabled, _BOOT_LU_EN); +UFS_ATTRIBUTE(max_data_size_hpb_single_cmd, _MAX_HPB_SINGLE_CMD); UFS_ATTRIBUTE(current_power_mode, _POWER_MODE); UFS_ATTRIBUTE(active_icc_level, _ACTIVE_ICC_LVL); UFS_ATTRIBUTE(ooo_data_enabled, _OOO_DATA_EN); @@ -864,6 +867,7 @@ UFS_ATTRIBUTE(wb_cur_buf, _CURR_WB_BUFF_SIZE); static struct attribute *ufs_sysfs_attributes[] = { &dev_attr_boot_lun_enabled.attr, + &dev_attr_max_data_size_hpb_single_cmd.attr, &dev_attr_current_power_mode.attr, &dev_attr_active_icc_level.attr, &dev_attr_ooo_data_enabled.attr, diff --git a/drivers/scsi/ufs/ufs.h b/drivers/scsi/ufs/ufs.h index bfb84d2ba990..8c6b38b1b142 100644 --- a/drivers/scsi/ufs/ufs.h +++ b/drivers/scsi/ufs/ufs.h @@ -123,12 +123,13 @@ enum flag_idn { QUERY_FLAG_IDN_WB_BUFF_FLUSH_EN = 0x0F, QUERY_FLAG_IDN_WB_BUFF_FLUSH_DURING_HIBERN8 = 0x10, QUERY_FLAG_IDN_HPB_RESET = 0x11, + QUERY_FLAG_IDN_HPB_EN = 0x12, }; /* Attribute idn for Query requests */ enum attr_idn { QUERY_ATTR_IDN_BOOT_LU_EN = 0x00, - QUERY_ATTR_IDN_RESERVED = 0x01, + QUERY_ATTR_IDN_MAX_HPB_SINGLE_CMD = 0x01, QUERY_ATTR_IDN_POWER_MODE = 0x02, QUERY_ATTR_IDN_ACTIVE_ICC_LVL = 0x03, QUERY_ATTR_IDN_OOO_DATA_EN = 0x04, diff --git a/drivers/scsi/ufs/ufshcd.c b/drivers/scsi/ufs/ufshcd.c index 88dd0f34fa09..4bf20f30213b 100644 --- a/drivers/scsi/ufs/ufshcd.c +++ b/drivers/scsi/ufs/ufshcd.c @@ -2656,7 +2656,12 @@ static int ufshcd_queuecommand(struct Scsi_Host *host, struct scsi_cmnd *cmd) lrbp->req_abort_skip = false; - ufshpb_prep(hba, lrbp); + err = ufshpb_prep(hba, lrbp); + if (err == -EAGAIN) { + lrbp->cmd = NULL; + ufshcd_release(hba); + goto out; + } ufshcd_comp_scsi_upiu(hba, lrbp); @@ -3110,7 +3115,7 @@ int ufshcd_query_attr(struct ufs_hba *hba, enum query_opcode opcode, * * Returns 0 for success, non-zero in case of failure */ -static int ufshcd_query_attr_retry(struct ufs_hba *hba, +int ufshcd_query_attr_retry(struct ufs_hba *hba, enum query_opcode opcode, enum attr_idn idn, u8 index, u8 selector, u32 *attr_val) { @@ -4865,7 +4870,8 @@ static int ufshcd_change_queue_depth(struct scsi_device *sdev, int depth) static void ufshcd_hpb_destroy(struct ufs_hba *hba, struct scsi_device *sdev) { /* skip well-known LU */ - if ((sdev->lun >= UFS_UPIU_MAX_UNIT_NUM_ID) || !ufshpb_is_allowed(hba)) + if ((sdev->lun >= UFS_UPIU_MAX_UNIT_NUM_ID) || + !(hba->dev_info.hpb_enabled) || !ufshpb_is_allowed(hba)) return; ufshpb_destroy_lu(hba, sdev); @@ -7462,8 +7468,18 @@ static int ufs_get_device_desc(struct ufs_hba *hba) if (dev_info->wspecversion >= UFS_DEV_HPB_SUPPORT_VERSION && (b_ufs_feature_sup & UFS_DEV_HPB_SUPPORT)) { - dev_info->hpb_enabled = true; + bool hpb_en = false; + ufshpb_get_dev_info(hba, desc_buf); + + if (!ufshpb_is_legacy(hba)) + err = ufshcd_query_flag_retry(hba, + UPIU_QUERY_OPCODE_READ_FLAG, + QUERY_FLAG_IDN_HPB_EN, 0, + &hpb_en); + + if (ufshpb_is_legacy(hba) || (!err && hpb_en)) + dev_info->hpb_enabled = true; } err = ufshcd_read_string_desc(hba, model_index, @@ -8036,6 +8052,7 @@ static const struct attribute_group *ufshcd_driver_groups[] = { &ufs_sysfs_lun_attributes_group, #ifdef CONFIG_SCSI_UFS_HPB &ufs_sysfs_hpb_stat_group, + &ufs_sysfs_hpb_param_group, #endif NULL, }; diff --git a/drivers/scsi/ufs/ufshcd.h b/drivers/scsi/ufs/ufshcd.h index 008a5f7146c0..8aca8f327981 100644 --- a/drivers/scsi/ufs/ufshcd.h +++ b/drivers/scsi/ufs/ufshcd.h @@ -654,6 +654,8 @@ struct ufs_hba_variant_params { * @srgn_size: device reported HPB sub-region size * @slave_conf_cnt: counter to check all lu finished initialization * @hpb_disabled: flag to check if HPB is disabled + * @max_hpb_single_cmd: maximum size of single HPB command + * @is_legacy: flag to check HPB 1.0 */ struct ufshpb_dev_info { int num_lu; @@ -661,6 +663,8 @@ struct ufshpb_dev_info { int srgn_size; atomic_t slave_conf_cnt; bool hpb_disabled; + int max_hpb_single_cmd; + bool is_legacy; }; #endif @@ -1096,6 +1100,9 @@ int ufshcd_read_desc_param(struct ufs_hba *hba, u8 param_offset, u8 *param_read_buf, u8 param_size); +int ufshcd_query_attr_retry(struct ufs_hba *hba, enum query_opcode opcode, + enum attr_idn idn, u8 index, u8 selector, + u32 *attr_val); int ufshcd_query_attr(struct ufs_hba *hba, enum query_opcode opcode, enum attr_idn idn, u8 index, u8 selector, u32 *attr_val); int ufshcd_query_flag(struct ufs_hba *hba, enum query_opcode opcode, diff --git a/drivers/scsi/ufs/ufshpb.c b/drivers/scsi/ufs/ufshpb.c index 201dc24d55b3..18353231fc2d 100644 --- a/drivers/scsi/ufs/ufshpb.c +++ b/drivers/scsi/ufs/ufshpb.c @@ -31,6 +31,11 @@ bool ufshpb_is_allowed(struct ufs_hba *hba) return !(hba->ufshpb_dev.hpb_disabled); } +bool ufshpb_is_legacy(struct ufs_hba *hba) +{ + return hba->ufshpb_dev.is_legacy; +} + static struct ufshpb_lu *ufshpb_get_hpb_data(struct scsi_device *sdev) { return sdev->hostdata; @@ -64,9 +69,19 @@ static bool ufshpb_is_write_or_discard_cmd(struct scsi_cmnd *cmd) op_is_discard(req_op(cmd->request)); } -static bool ufshpb_is_support_chunk(int transfer_len) +static bool ufshpb_is_support_chunk(struct ufshpb_lu *hpb, int transfer_len) { - return transfer_len <= HPB_MULTI_CHUNK_HIGH; + return transfer_len <= hpb->pre_req_max_tr_len; +} + +/* + * In this driver, WRITE_BUFFER CMD support 36KB (len=9) ~ 512KB (len=128) as + * default. It is possible to change range of transfer_len through sysfs. + */ +static inline bool ufshpb_is_required_wb(struct ufshpb_lu *hpb, int len) +{ + return (len > hpb->pre_req_min_tr_len && + len <= hpb->pre_req_max_tr_len); } static bool ufshpb_is_general_lun(int lun) @@ -74,8 +89,7 @@ static bool ufshpb_is_general_lun(int lun) return lun < UFS_UPIU_MAX_UNIT_NUM_ID; } -static bool -ufshpb_is_pinned_region(struct ufshpb_lu *hpb, int rgn_idx) +static bool ufshpb_is_pinned_region(struct ufshpb_lu *hpb, int rgn_idx) { if (hpb->lu_pinned_end != PINNED_NOT_SET && rgn_idx >= hpb->lu_pinned_start && @@ -264,7 +278,8 @@ ufshpb_get_pos_from_lpn(struct ufshpb_lu *hpb, unsigned long lpn, int *rgn_idx, static void ufshpb_set_hpb_read_to_upiu(struct ufshpb_lu *hpb, struct ufshcd_lrb *lrbp, - u32 lpn, u64 ppn, unsigned int transfer_len) + u32 lpn, u64 ppn, unsigned int transfer_len, + int read_id) { unsigned char *cdb = lrbp->cmd->cmnd; @@ -273,15 +288,271 @@ ufshpb_set_hpb_read_to_upiu(struct ufshpb_lu *hpb, struct ufshcd_lrb *lrbp, /* ppn value is stored as big-endian in the host memory */ memcpy(&cdb[6], &ppn, sizeof(u64)); cdb[14] = transfer_len; + cdb[15] = read_id; lrbp->cmd->cmd_len = UFS_CDB_SIZE; } +static inline void ufshpb_set_write_buf_cmd(unsigned char *cdb, + unsigned long lpn, unsigned int len, + int read_id) +{ + cdb[0] = UFSHPB_WRITE_BUFFER; + cdb[1] = UFSHPB_WRITE_BUFFER_PREFETCH_ID; + + put_unaligned_be32(lpn, &cdb[2]); + cdb[6] = read_id; + put_unaligned_be16(len * HPB_ENTRY_SIZE, &cdb[7]); + + cdb[9] = 0x00; /* Control = 0x00 */ +} + +static struct ufshpb_req *ufshpb_get_pre_req(struct ufshpb_lu *hpb) +{ + struct ufshpb_req *pre_req; + + if (hpb->num_inflight_pre_req >= hpb->throttle_pre_req) { + dev_info(&hpb->sdev_ufs_lu->sdev_dev, + "pre_req throttle. inflight %d throttle %d", + hpb->num_inflight_pre_req, hpb->throttle_pre_req); + return NULL; + } + + pre_req = list_first_entry_or_null(&hpb->lh_pre_req_free, + struct ufshpb_req, list_req); + if (!pre_req) { + dev_info(&hpb->sdev_ufs_lu->sdev_dev, "There is no pre_req"); + return NULL; + } + + list_del_init(&pre_req->list_req); + hpb->num_inflight_pre_req++; + + return pre_req; +} + +static inline void ufshpb_put_pre_req(struct ufshpb_lu *hpb, + struct ufshpb_req *pre_req) +{ + pre_req->req = NULL; + pre_req->bio = NULL; + list_add_tail(&pre_req->list_req, &hpb->lh_pre_req_free); + hpb->num_inflight_pre_req--; +} + +static void ufshpb_pre_req_compl_fn(struct request *req, blk_status_t error) +{ + struct ufshpb_req *pre_req = (struct ufshpb_req *)req->end_io_data; + struct ufshpb_lu *hpb = pre_req->hpb; + unsigned long flags; + + if (error) { + struct scsi_request *rq = scsi_req(req); + struct scsi_sense_hdr sshdr; + + dev_err(&hpb->sdev_ufs_lu->sdev_dev, "block status %d", error); + scsi_normalize_sense(rq->sense, SCSI_SENSE_BUFFERSIZE, + &sshdr); + dev_err(&hpb->sdev_ufs_lu->sdev_dev, + "code %x sense_key %x asc %x ascq %x", + sshdr.response_code, + sshdr.sense_key, sshdr.asc, sshdr.ascq); + dev_err(&hpb->sdev_ufs_lu->sdev_dev, + "byte4 %x byte5 %x byte6 %x additional_len %x", + sshdr.byte4, sshdr.byte5, + sshdr.byte6, sshdr.additional_length); + } + + bio_put(pre_req->bio); + blk_mq_free_request(req); + spin_lock_irqsave(&hpb->rgn_state_lock, flags); + ufshpb_put_pre_req(pre_req->hpb, pre_req); + spin_unlock_irqrestore(&hpb->rgn_state_lock, flags); +} + +static int ufshpb_prep_entry(struct ufshpb_req *pre_req, struct page *page) +{ + struct ufshpb_lu *hpb = pre_req->hpb; + struct ufshpb_region *rgn; + struct ufshpb_subregion *srgn; + u64 *addr; + int offset = 0; + int copied; + unsigned long lpn = pre_req->wb.lpn; + int rgn_idx, srgn_idx, srgn_offset; + unsigned long flags; + + addr = page_address(page); + ufshpb_get_pos_from_lpn(hpb, lpn, &rgn_idx, &srgn_idx, &srgn_offset); + + spin_lock_irqsave(&hpb->rgn_state_lock, flags); + +next_offset: + rgn = hpb->rgn_tbl + rgn_idx; + srgn = rgn->srgn_tbl + srgn_idx; + + if (!ufshpb_is_valid_srgn(rgn, srgn)) + goto mctx_error; + + if (!srgn->mctx) + goto mctx_error; + + copied = ufshpb_fill_ppn_from_page(hpb, srgn->mctx, srgn_offset, + pre_req->wb.len - offset, + &addr[offset]); + + if (copied < 0) + goto mctx_error; + + offset += copied; + srgn_offset += copied; + + if (srgn_offset == hpb->entries_per_srgn) { + srgn_offset = 0; + + if (++srgn_idx == hpb->srgns_per_rgn) { + srgn_idx = 0; + rgn_idx++; + } + } + + if (offset < pre_req->wb.len) + goto next_offset; + + spin_unlock_irqrestore(&hpb->rgn_state_lock, flags); + return 0; +mctx_error: + spin_unlock_irqrestore(&hpb->rgn_state_lock, flags); + return -ENOMEM; +} + +static int ufshpb_pre_req_add_bio_page(struct ufshpb_lu *hpb, + struct request_queue *q, + struct ufshpb_req *pre_req) +{ + struct page *page = pre_req->wb.m_page; + struct bio *bio = pre_req->bio; + int entries_bytes, ret; + + if (!page) + return -ENOMEM; + + if (ufshpb_prep_entry(pre_req, page)) + return -ENOMEM; + + entries_bytes = pre_req->wb.len * sizeof(u64); + + ret = bio_add_pc_page(q, bio, page, entries_bytes, 0); + if (ret != entries_bytes) { + dev_err(&hpb->sdev_ufs_lu->sdev_dev, + "bio_add_pc_page fail: %d", ret); + return -ENOMEM; + } + return 0; +} + +static inline int ufshpb_get_read_id(struct ufshpb_lu *hpb) +{ + if (++hpb->cur_read_id >= MAX_HPB_READ_ID) + hpb->cur_read_id = 1; + return hpb->cur_read_id; +} + +static int ufshpb_execute_pre_req(struct ufshpb_lu *hpb, struct scsi_cmnd *cmd, + struct ufshpb_req *pre_req, int read_id) +{ + struct scsi_device *sdev = cmd->device; + struct request_queue *q = sdev->request_queue; + struct request *req; + struct scsi_request *rq; + struct bio *bio = pre_req->bio; + + pre_req->hpb = hpb; + pre_req->wb.lpn = sectors_to_logical(cmd->device, + blk_rq_pos(cmd->request)); + pre_req->wb.len = sectors_to_logical(cmd->device, + blk_rq_sectors(cmd->request)); + if (ufshpb_pre_req_add_bio_page(hpb, q, pre_req)) + return -ENOMEM; + + req = pre_req->req; + + /* 1. request setup */ + blk_rq_append_bio(req, &bio); + req->rq_disk = NULL; + req->end_io_data = (void *)pre_req; + req->end_io = ufshpb_pre_req_compl_fn; + + /* 2. scsi_request setup */ + rq = scsi_req(req); + rq->retries = 1; + + ufshpb_set_write_buf_cmd(rq->cmd, pre_req->wb.lpn, pre_req->wb.len, + read_id); + rq->cmd_len = scsi_command_size(rq->cmd); + + if (blk_insert_cloned_request(q, req) != BLK_STS_OK) + return -EAGAIN; + + hpb->stats.pre_req_cnt++; + + return 0; +} + +static int ufshpb_issue_pre_req(struct ufshpb_lu *hpb, struct scsi_cmnd *cmd, + int *read_id) +{ + struct ufshpb_req *pre_req; + struct request *req = NULL; + struct bio *bio = NULL; + unsigned long flags; + int _read_id; + int ret = 0; + + req = blk_get_request(cmd->device->request_queue, + REQ_OP_SCSI_OUT | REQ_SYNC, BLK_MQ_REQ_NOWAIT); + if (IS_ERR(req)) + return -EAGAIN; + + bio = bio_alloc(GFP_ATOMIC, 1); + if (!bio) { + blk_put_request(req); + return -EAGAIN; + } + + spin_lock_irqsave(&hpb->rgn_state_lock, flags); + pre_req = ufshpb_get_pre_req(hpb); + if (!pre_req) { + ret = -EAGAIN; + goto unlock_out; + } + _read_id = ufshpb_get_read_id(hpb); + spin_unlock_irqrestore(&hpb->rgn_state_lock, flags); + + pre_req->req = req; + pre_req->bio = bio; + + ret = ufshpb_execute_pre_req(hpb, cmd, pre_req, _read_id); + if (ret) + goto free_pre_req; + + *read_id = _read_id; + + return ret; +free_pre_req: + spin_lock_irqsave(&hpb->rgn_state_lock, flags); + ufshpb_put_pre_req(hpb, pre_req); +unlock_out: + spin_unlock_irqrestore(&hpb->rgn_state_lock, flags); + bio_put(bio); + blk_put_request(req); + return ret; +} + /* * This function will set up HPB read command using host-side L2P map data. - * In HPB v1.0, maximum size of HPB read command is 4KB. */ -void ufshpb_prep(struct ufs_hba *hba, struct ufshcd_lrb *lrbp) +int ufshpb_prep(struct ufs_hba *hba, struct ufshcd_lrb *lrbp) { struct ufshpb_lu *hpb; struct ufshpb_region *rgn; @@ -291,29 +562,30 @@ void ufshpb_prep(struct ufs_hba *hba, struct ufshcd_lrb *lrbp) u64 ppn; unsigned long flags; int transfer_len, rgn_idx, srgn_idx, srgn_offset; + int read_id = 0; int err = 0; hpb = ufshpb_get_hpb_data(cmd->device); if (!hpb) - return; + return -ENODEV; if (ufshpb_get_state(hpb) == HPB_INIT) - return; + return -ENODEV; if (ufshpb_get_state(hpb) != HPB_PRESENT) { dev_notice(&hpb->sdev_ufs_lu->sdev_dev, "%s: ufshpb state is not PRESENT", __func__); - return; + return -ENODEV; } if (!ufshpb_is_write_or_discard_cmd(cmd) && !ufshpb_is_read_cmd(cmd)) - return; + return 0; transfer_len = sectors_to_logical(cmd->device, blk_rq_sectors(cmd->request)); if (unlikely(!transfer_len)) - return; + return 0; lpn = sectors_to_logical(cmd->device, blk_rq_pos(cmd->request)); ufshpb_get_pos_from_lpn(hpb, lpn, &rgn_idx, &srgn_idx, &srgn_offset); @@ -326,18 +598,18 @@ void ufshpb_prep(struct ufs_hba *hba, struct ufshcd_lrb *lrbp) ufshpb_set_ppn_dirty(hpb, rgn_idx, srgn_idx, srgn_offset, transfer_len); spin_unlock_irqrestore(&hpb->rgn_state_lock, flags); - return; + return 0; } - if (!ufshpb_is_support_chunk(transfer_len)) - return; + if (!ufshpb_is_support_chunk(hpb, transfer_len)) + return 0; spin_lock_irqsave(&hpb->rgn_state_lock, flags); if (ufshpb_test_ppn_dirty(hpb, rgn_idx, srgn_idx, srgn_offset, transfer_len)) { hpb->stats.miss_cnt++; spin_unlock_irqrestore(&hpb->rgn_state_lock, flags); - return; + return 0; } err = ufshpb_fill_ppn_from_page(hpb, srgn->mctx, srgn_offset, 1, &ppn); @@ -350,28 +622,46 @@ void ufshpb_prep(struct ufs_hba *hba, struct ufshcd_lrb *lrbp) * active state. */ dev_err(hba->dev, "get ppn failed. err %d\n", err); - return; + return err; } - ufshpb_set_hpb_read_to_upiu(hpb, lrbp, lpn, ppn, transfer_len); + if (!ufshpb_is_legacy(hba) && + ufshpb_is_required_wb(hpb, transfer_len)) { + err = ufshpb_issue_pre_req(hpb, cmd, &read_id); + if (err) { + unsigned long timeout; + + timeout = cmd->jiffies_at_alloc + msecs_to_jiffies( + hpb->params.requeue_timeout_ms); + + if (time_before(jiffies, timeout)) + return -EAGAIN; + + hpb->stats.miss_cnt++; + return 0; + } + } + + ufshpb_set_hpb_read_to_upiu(hpb, lrbp, lpn, ppn, transfer_len, read_id); hpb->stats.hit_cnt++; + return 0; } -static struct ufshpb_req *ufshpb_get_map_req(struct ufshpb_lu *hpb, - struct ufshpb_subregion *srgn) + +static struct ufshpb_req *ufshpb_get_req(struct ufshpb_lu *hpb, + int rgn_idx, enum req_opf dir) { - struct ufshpb_req *map_req; + struct ufshpb_req *rq; struct request *req; - struct bio *bio; int retries = HPB_MAP_REQ_RETRIES; - map_req = kmem_cache_alloc(hpb->map_req_cache, GFP_KERNEL); - if (!map_req) + rq = kmem_cache_alloc(hpb->map_req_cache, GFP_KERNEL); + if (!rq) return NULL; retry: - req = blk_get_request(hpb->sdev_ufs_lu->request_queue, - REQ_OP_SCSI_IN, BLK_MQ_REQ_NOWAIT); + req = blk_get_request(hpb->sdev_ufs_lu->request_queue, dir, + BLK_MQ_REQ_NOWAIT); if ((PTR_ERR(req) == -EWOULDBLOCK) && (--retries > 0)) { usleep_range(3000, 3100); @@ -379,35 +669,54 @@ static struct ufshpb_req *ufshpb_get_map_req(struct ufshpb_lu *hpb, } if (IS_ERR(req)) - goto free_map_req; + goto free_rq; + + rq->hpb = hpb; + rq->req = req; + rq->rb.rgn_idx = rgn_idx; + + return rq; + +free_rq: + kmem_cache_free(hpb->map_req_cache, rq); + return NULL; +} + +static void ufshpb_put_req(struct ufshpb_lu *hpb, struct ufshpb_req *rq) +{ + blk_put_request(rq->req); + kmem_cache_free(hpb->map_req_cache, rq); +} + +static struct ufshpb_req *ufshpb_get_map_req(struct ufshpb_lu *hpb, + struct ufshpb_subregion *srgn) +{ + struct ufshpb_req *map_req; + struct bio *bio; + + map_req = ufshpb_get_req(hpb, srgn->rgn_idx, REQ_OP_SCSI_IN); + if (!map_req) + return NULL; bio = bio_alloc(GFP_KERNEL, hpb->pages_per_srgn); if (!bio) { - blk_put_request(req); - goto free_map_req; + ufshpb_put_req(hpb, map_req); + return NULL; } - map_req->hpb = hpb; - map_req->req = req; map_req->bio = bio; - map_req->rgn_idx = srgn->rgn_idx; - map_req->srgn_idx = srgn->srgn_idx; - map_req->mctx = srgn->mctx; + map_req->rb.srgn_idx = srgn->srgn_idx; + map_req->rb.mctx = srgn->mctx; return map_req; - -free_map_req: - kmem_cache_free(hpb->map_req_cache, map_req); - return NULL; } static void ufshpb_put_map_req(struct ufshpb_lu *hpb, struct ufshpb_req *map_req) { bio_put(map_req->bio); - blk_put_request(map_req->req); - kmem_cache_free(hpb->map_req_cache, map_req); + ufshpb_put_req(hpb, map_req); } static int ufshpb_clear_dirty_bitmap(struct ufshpb_lu *hpb, @@ -490,6 +799,13 @@ static void ufshpb_activate_subregion(struct ufshpb_lu *hpb, srgn->srgn_state = HPB_SRGN_VALID; } +static void ufshpb_umap_req_compl_fn(struct request *req, blk_status_t error) +{ + struct ufshpb_req *umap_req = (struct ufshpb_req *)req->end_io_data; + + ufshpb_put_req(umap_req->hpb, umap_req); +} + static void ufshpb_map_req_compl_fn(struct request *req, blk_status_t error) { struct ufshpb_req *map_req = (struct ufshpb_req *) req->end_io_data; @@ -497,8 +813,8 @@ static void ufshpb_map_req_compl_fn(struct request *req, blk_status_t error) struct ufshpb_subregion *srgn; unsigned long flags; - srgn = hpb->rgn_tbl[map_req->rgn_idx].srgn_tbl + - map_req->srgn_idx; + srgn = hpb->rgn_tbl[map_req->rb.rgn_idx].srgn_tbl + + map_req->rb.srgn_idx; ufshpb_clear_dirty_bitmap(hpb, srgn); spin_lock_irqsave(&hpb->rgn_state_lock, flags); @@ -508,6 +824,16 @@ static void ufshpb_map_req_compl_fn(struct request *req, blk_status_t error) ufshpb_put_map_req(map_req->hpb, map_req); } +static void ufshpb_set_unmap_cmd(unsigned char *cdb, struct ufshpb_region *rgn) +{ + cdb[0] = UFSHPB_WRITE_BUFFER; + cdb[1] = rgn ? UFSHPB_WRITE_BUFFER_INACT_SINGLE_ID : + UFSHPB_WRITE_BUFFER_INACT_ALL_ID; + if (rgn) + put_unaligned_be16(rgn->rgn_idx, &cdb[2]); + cdb[9] = 0x00; +} + static void ufshpb_set_read_buf_cmd(unsigned char *cdb, int rgn_idx, int srgn_idx, int srgn_mem_size) { @@ -521,6 +847,25 @@ static void ufshpb_set_read_buf_cmd(unsigned char *cdb, int rgn_idx, cdb[9] = 0x00; } +static int ufshpb_execute_umap_req(struct ufshpb_lu *hpb, + struct ufshpb_req *umap_req, + struct ufshpb_region *rgn) +{ + struct request *req; + struct scsi_request *rq; + + req = umap_req->req; + req->timeout = 0; + req->end_io_data = (void *)umap_req; + rq = scsi_req(req); + ufshpb_set_unmap_cmd(rq->cmd, rgn); + rq->cmd_len = HPB_WRITE_BUFFER_CMD_LENGTH; + + blk_execute_rq_nowait(NULL, req, 1, ufshpb_umap_req_compl_fn); + + return 0; +} + static int ufshpb_execute_map_req(struct ufshpb_lu *hpb, struct ufshpb_req *map_req, bool last) { @@ -533,12 +878,12 @@ static int ufshpb_execute_map_req(struct ufshpb_lu *hpb, q = hpb->sdev_ufs_lu->request_queue; for (i = 0; i < hpb->pages_per_srgn; i++) { - ret = bio_add_pc_page(q, map_req->bio, map_req->mctx->m_page[i], + ret = bio_add_pc_page(q, map_req->bio, map_req->rb.mctx->m_page[i], PAGE_SIZE, 0); if (ret != PAGE_SIZE) { dev_err(&hpb->sdev_ufs_lu->sdev_dev, "bio_add_pc_page fail %d - %d\n", - map_req->rgn_idx, map_req->srgn_idx); + map_req->rb.rgn_idx, map_req->rb.srgn_idx); return ret; } } @@ -554,8 +899,8 @@ static int ufshpb_execute_map_req(struct ufshpb_lu *hpb, if (unlikely(last)) mem_size = hpb->last_srgn_entries * HPB_ENTRY_SIZE; - ufshpb_set_read_buf_cmd(rq->cmd, map_req->rgn_idx, - map_req->srgn_idx, mem_size); + ufshpb_set_read_buf_cmd(rq->cmd, map_req->rb.rgn_idx, + map_req->rb.srgn_idx, mem_size); rq->cmd_len = HPB_READ_BUFFER_CMD_LENGTH; blk_execute_rq_nowait(NULL, req, 1, ufshpb_map_req_compl_fn); @@ -687,6 +1032,31 @@ static void ufshpb_purge_active_subregion(struct ufshpb_lu *hpb, } } +static int ufshpb_issue_umap_req(struct ufshpb_lu *hpb, + struct ufshpb_region *rgn) +{ + struct ufshpb_req *umap_req; + int rgn_idx = rgn ? rgn->rgn_idx : 0; + + umap_req = ufshpb_get_req(hpb, rgn_idx, REQ_OP_SCSI_OUT); + if (!umap_req) + return -ENOMEM; + + if (ufshpb_execute_umap_req(hpb, umap_req, rgn)) + goto free_umap_req; + + return 0; + +free_umap_req: + ufshpb_put_req(hpb, umap_req); + return -EAGAIN; +} + +static int ufshpb_issue_umap_all_req(struct ufshpb_lu *hpb) +{ + return ufshpb_issue_umap_req(hpb, NULL); +} + static void __ufshpb_evict_region(struct ufshpb_lu *hpb, struct ufshpb_region *rgn) { @@ -1215,6 +1585,17 @@ static void ufshpb_lu_parameter_init(struct ufs_hba *hba, u32 entries_per_rgn; u64 rgn_mem_size, tmp; + /* for pre_req */ + hpb->pre_req_min_tr_len = hpb_dev_info->max_hpb_single_cmd + 1; + + if (ufshpb_is_legacy(hba)) + hpb->pre_req_max_tr_len = HPB_LEGACY_CHUNK_HIGH; + else + hpb->pre_req_max_tr_len = max(HPB_MULTI_CHUNK_HIGH, + hpb->pre_req_min_tr_len); + + hpb->cur_read_id = 0; + hpb->lu_pinned_start = hpb_lu_info->pinned_start; hpb->lu_pinned_end = hpb_lu_info->num_pinned ? (hpb_lu_info->pinned_start + hpb_lu_info->num_pinned - 1) @@ -1362,7 +1743,7 @@ ufshpb_sysfs_attr_show_func(rb_active_cnt); ufshpb_sysfs_attr_show_func(rb_inactive_cnt); ufshpb_sysfs_attr_show_func(map_req_cnt); -static struct attribute *hpb_dev_attrs[] = { +static struct attribute *hpb_dev_stat_attrs[] = { &dev_attr_hit_cnt.attr, &dev_attr_miss_cnt.attr, &dev_attr_rb_noti_cnt.attr, @@ -1373,10 +1754,109 @@ static struct attribute *hpb_dev_attrs[] = { }; struct attribute_group ufs_sysfs_hpb_stat_group = { - .name = "hpb_sysfs", - .attrs = hpb_dev_attrs, + .name = "hpb_stat_sysfs", + .attrs = hpb_dev_stat_attrs, }; +/* SYSFS functions */ +#define ufshpb_sysfs_param_show_func(__name) \ +static ssize_t __name##_show(struct device *dev, \ + struct device_attribute *attr, char *buf) \ +{ \ + struct scsi_device *sdev = to_scsi_device(dev); \ + struct ufshpb_lu *hpb = ufshpb_get_hpb_data(sdev); \ + if (!hpb) \ + return -ENODEV; \ + \ + return sysfs_emit(buf, "%d\n", hpb->params.__name); \ +} + +ufshpb_sysfs_param_show_func(requeue_timeout_ms); +static ssize_t +requeue_timeout_ms_store(struct device *dev, struct device_attribute *attr, + const char *buf, size_t count) +{ + struct scsi_device *sdev = to_scsi_device(dev); + struct ufshpb_lu *hpb = ufshpb_get_hpb_data(sdev); + int val; + + if (!hpb) + return -ENODEV; + + if (kstrtouint(buf, 0, &val)) + return -EINVAL; + + if (val <= 0) + return -EINVAL; + + hpb->params.requeue_timeout_ms = val; + + return count; +} +static DEVICE_ATTR_RW(requeue_timeout_ms); + +static struct attribute *hpb_dev_param_attrs[] = { + &dev_attr_requeue_timeout_ms.attr, + NULL, +}; + +struct attribute_group ufs_sysfs_hpb_param_group = { + .name = "hpb_param_sysfs", + .attrs = hpb_dev_param_attrs, +}; + +static int ufshpb_pre_req_mempool_init(struct ufshpb_lu *hpb) +{ + struct ufshpb_req *pre_req = NULL; + int qd = hpb->sdev_ufs_lu->queue_depth / 2; + int i, j; + + INIT_LIST_HEAD(&hpb->lh_pre_req_free); + + hpb->pre_req = kcalloc(qd, sizeof(struct ufshpb_req), GFP_KERNEL); + hpb->throttle_pre_req = qd; + hpb->num_inflight_pre_req = 0; + + if (!hpb->pre_req) + goto release_mem; + + for (i = 0; i < qd; i++) { + pre_req = hpb->pre_req + i; + INIT_LIST_HEAD(&pre_req->list_req); + pre_req->req = NULL; + pre_req->bio = NULL; + + pre_req->wb.m_page = alloc_page(GFP_KERNEL | __GFP_ZERO); + if (!pre_req->wb.m_page) { + for (j = 0; j < i; j++) + __free_page(hpb->pre_req[j].wb.m_page); + + goto release_mem; + } + list_add_tail(&pre_req->list_req, &hpb->lh_pre_req_free); + } + + return 0; +release_mem: + kfree(hpb->pre_req); + return -ENOMEM; +} + +static void ufshpb_pre_req_mempool_destroy(struct ufshpb_lu *hpb) +{ + struct ufshpb_req *pre_req = NULL; + int i; + + for (i = 0; i < hpb->throttle_pre_req; i++) { + pre_req = hpb->pre_req + i; + if (!pre_req->wb.m_page) + __free_page(hpb->pre_req[i].wb.m_page); + list_del_init(&pre_req->list_req); + } + + kfree(hpb->pre_req); +} + static void ufshpb_stat_init(struct ufshpb_lu *hpb) { hpb->stats.hit_cnt = 0; @@ -1387,6 +1867,11 @@ static void ufshpb_stat_init(struct ufshpb_lu *hpb) hpb->stats.map_req_cnt = 0; } +static void ufshpb_param_init(struct ufshpb_lu *hpb) +{ + hpb->params.requeue_timeout_ms = HPB_REQUEUE_TIME_MS; +} + static int ufshpb_lu_hpb_init(struct ufs_hba *hba, struct ufshpb_lu *hpb) { int ret; @@ -1419,14 +1904,24 @@ static int ufshpb_lu_hpb_init(struct ufs_hba *hba, struct ufshpb_lu *hpb) goto release_req_cache; } + ret = ufshpb_pre_req_mempool_init(hpb); + if (ret) { + dev_err(hba->dev, "ufshpb(%d) pre_req_mempool init fail", + hpb->lun); + goto release_m_page_cache; + } + ret = ufshpb_alloc_region_tbl(hba, hpb); if (ret) - goto release_m_page_cache; + goto release_pre_req_mempool; ufshpb_stat_init(hpb); + ufshpb_param_init(hpb); return 0; +release_pre_req_mempool: + ufshpb_pre_req_mempool_destroy(hpb); release_m_page_cache: kmem_cache_destroy(hpb->m_page_cache); release_req_cache: @@ -1435,7 +1930,7 @@ static int ufshpb_lu_hpb_init(struct ufs_hba *hba, struct ufshpb_lu *hpb) } static struct ufshpb_lu * -ufshpb_alloc_hpb_lu(struct ufs_hba *hba, int lun, +ufshpb_alloc_hpb_lu(struct ufs_hba *hba, struct scsi_device *sdev, struct ufshpb_dev_info *hpb_dev_info, struct ufshpb_lu_info *hpb_lu_info) { @@ -1446,7 +1941,8 @@ ufshpb_alloc_hpb_lu(struct ufs_hba *hba, int lun, if (!hpb) return NULL; - hpb->lun = lun; + hpb->lun = sdev->lun; + hpb->sdev_ufs_lu = sdev; ufshpb_lu_parameter_init(hba, hpb, hpb_dev_info, hpb_lu_info); @@ -1456,6 +1952,7 @@ ufshpb_alloc_hpb_lu(struct ufs_hba *hba, int lun, goto release_hpb; } + sdev->hostdata = hpb; return hpb; release_hpb: @@ -1658,6 +2155,7 @@ void ufshpb_destroy_lu(struct ufs_hba *hba, struct scsi_device *sdev) ufshpb_cancel_jobs(hpb); + ufshpb_pre_req_mempool_destroy(hpb); ufshpb_destroy_region_tbl(hpb); kmem_cache_destroy(hpb->map_req_cache); @@ -1697,6 +2195,7 @@ static void ufshpb_hpb_lu_prepared(struct ufs_hba *hba) ufshpb_set_state(hpb, HPB_PRESENT); if ((hpb->lu_pinned_end - hpb->lu_pinned_start) > 0) queue_work(ufshpb_wq, &hpb->map_work); + ufshpb_issue_umap_all_req(hpb); } else { dev_err(hba->dev, "destroy HPB lu %d\n", hpb->lun); ufshpb_destroy_lu(hba, sdev); @@ -1721,7 +2220,7 @@ void ufshpb_init_hpb_lu(struct ufs_hba *hba, struct scsi_device *sdev) if (ret) goto out; - hpb = ufshpb_alloc_hpb_lu(hba, lun, &hba->ufshpb_dev, + hpb = ufshpb_alloc_hpb_lu(hba, sdev, &hba->ufshpb_dev, &hpb_lu_info); if (!hpb) goto out; @@ -1729,9 +2228,6 @@ void ufshpb_init_hpb_lu(struct ufs_hba *hba, struct scsi_device *sdev) tot_active_srgn_pages += hpb_lu_info.max_active_rgns * hpb->srgns_per_rgn * hpb->pages_per_srgn; - hpb->sdev_ufs_lu = sdev; - sdev->hostdata = hpb; - out: /* All LUs are initialized */ if (atomic_dec_and_test(&hba->ufshpb_dev.slave_conf_cnt)) @@ -1818,8 +2314,9 @@ void ufshpb_get_geo_info(struct ufs_hba *hba, u8 *geo_buf) void ufshpb_get_dev_info(struct ufs_hba *hba, u8 *desc_buf) { struct ufshpb_dev_info *hpb_dev_info = &hba->ufshpb_dev; - int version; + int version, ret; u8 hpb_mode; + u32 max_hpb_single_cmd = 0; hpb_mode = desc_buf[DEVICE_DESC_PARAM_HPB_CONTROL]; if (hpb_mode == HPB_HOST_CONTROL) { @@ -1830,13 +2327,27 @@ void ufshpb_get_dev_info(struct ufs_hba *hba, u8 *desc_buf) } version = get_unaligned_be16(desc_buf + DEVICE_DESC_PARAM_HPB_VER); - if (version != HPB_SUPPORT_VERSION) { + if ((version != HPB_SUPPORT_VERSION) && + (version != HPB_SUPPORT_LEGACY_VERSION)) { dev_err(hba->dev, "%s: HPB %x version is not supported.\n", __func__, version); hpb_dev_info->hpb_disabled = true; return; } + if (version == HPB_SUPPORT_LEGACY_VERSION) + hpb_dev_info->is_legacy = true; + + pm_runtime_get_sync(hba->dev); + ret = ufshcd_query_attr_retry(hba, UPIU_QUERY_OPCODE_READ_ATTR, + QUERY_ATTR_IDN_MAX_HPB_SINGLE_CMD, 0, 0, &max_hpb_single_cmd); + pm_runtime_put_sync(hba->dev); + + if (ret) + dev_err(hba->dev, "%s: idn: read max size of single hpb cmd query request failed", + __func__); + hpb_dev_info->max_hpb_single_cmd = max_hpb_single_cmd; + /* * Get the number of user logical unit to check whether all * scsi_device finish initialization diff --git a/drivers/scsi/ufs/ufshpb.h b/drivers/scsi/ufs/ufshpb.h index 6e6a0252dc15..56d84353f178 100644 --- a/drivers/scsi/ufs/ufshpb.h +++ b/drivers/scsi/ufs/ufshpb.h @@ -30,19 +30,28 @@ #define PINNED_NOT_SET U32_MAX /* hpb support chunk size */ -#define HPB_MULTI_CHUNK_HIGH 1 +#define HPB_LEGACY_CHUNK_HIGH 1 +#define HPB_MULTI_CHUNK_HIGH 128 /* hpb vender defined opcode */ #define UFSHPB_READ 0xF8 #define UFSHPB_READ_BUFFER 0xF9 #define UFSHPB_READ_BUFFER_ID 0x01 +#define UFSHPB_WRITE_BUFFER 0xFA +#define UFSHPB_WRITE_BUFFER_INACT_SINGLE_ID 0x01 +#define UFSHPB_WRITE_BUFFER_PREFETCH_ID 0x02 +#define UFSHPB_WRITE_BUFFER_INACT_ALL_ID 0x03 +#define HPB_WRITE_BUFFER_CMD_LENGTH 10 +#define MAX_HPB_READ_ID 0x7F #define HPB_READ_BUFFER_CMD_LENGTH 10 #define LU_ENABLED_HPB_FUNC 0x02 #define HPB_RESET_REQ_RETRIES 10 #define HPB_MAP_REQ_RETRIES 5 +#define HPB_REQUEUE_TIME_MS 0 -#define HPB_SUPPORT_VERSION 0x100 +#define HPB_SUPPORT_VERSION 0x200 +#define HPB_SUPPORT_LEGACY_VERSION 0x100 enum UFSHPB_MODE { HPB_HOST_CONTROL, @@ -119,23 +128,38 @@ struct ufshpb_region { (i)++) /** - * struct ufshpb_req - UFSHPB READ BUFFER (for caching map) request structure - * @req: block layer request for READ BUFFER - * @bio: bio for holding map page - * @hpb: ufshpb_lu structure that related to the L2P map + * struct ufshpb_req - HPB related request structure (write/read buffer) + * @req: block layer request structure + * @bio: bio for this request + * @hpb: ufshpb_lu structure that related to + * @list_req: ufshpb_req mempool list + * @sense: store its sense data * @mctx: L2P map information * @rgn_idx: target region index * @srgn_idx: target sub-region index * @lun: target logical unit number + * @m_page: L2P map information data for pre-request + * @len: length of host-side cached L2P map in m_page + * @lpn: start LPN of L2P map in m_page */ struct ufshpb_req { struct request *req; struct bio *bio; struct ufshpb_lu *hpb; - struct ufshpb_map_ctx *mctx; - - unsigned int rgn_idx; - unsigned int srgn_idx; + struct list_head list_req; + union { + struct { + struct ufshpb_map_ctx *mctx; + unsigned int rgn_idx; + unsigned int srgn_idx; + unsigned int lun; + } rb; + struct { + struct page *m_page; + unsigned int len; + unsigned long lpn; + } wb; + }; }; struct victim_select_info { @@ -144,6 +168,10 @@ struct victim_select_info { atomic_t active_cnt; }; +struct ufshpb_params { + unsigned int requeue_timeout_ms; +}; + struct ufshpb_stats { u64 hit_cnt; u64 miss_cnt; @@ -151,6 +179,7 @@ struct ufshpb_stats { u64 rb_active_cnt; u64 rb_inactive_cnt; u64 map_req_cnt; + u64 pre_req_cnt; }; struct ufshpb_lu { @@ -166,6 +195,15 @@ struct ufshpb_lu { struct list_head lh_act_srgn; /* hold rsp_list_lock */ struct list_head lh_inact_rgn; /* hold rsp_list_lock */ + /* pre request information */ + struct ufshpb_req *pre_req; + int num_inflight_pre_req; + int throttle_pre_req; + struct list_head lh_pre_req_free; + int cur_read_id; + int pre_req_min_tr_len; + int pre_req_max_tr_len; + /* cached L2P map management worker */ struct work_struct map_work; @@ -190,6 +228,7 @@ struct ufshpb_lu { u32 pages_per_srgn; struct ufshpb_stats stats; + struct ufshpb_params params; struct kmem_cache *map_req_cache; struct kmem_cache *m_page_cache; @@ -201,7 +240,7 @@ struct ufs_hba; struct ufshcd_lrb; #ifndef CONFIG_SCSI_UFS_HPB -static void ufshpb_prep(struct ufs_hba *hba, struct ufshcd_lrb *lrbp) {} +static int ufshpb_prep(struct ufs_hba *hba, struct ufshcd_lrb *lrbp) { return 0; } static void ufshpb_rsp_upiu(struct ufs_hba *hba, struct ufshcd_lrb *lrbp) {} static void ufshpb_resume(struct ufs_hba *hba) {} static void ufshpb_suspend(struct ufs_hba *hba) {} @@ -214,8 +253,9 @@ static void ufshpb_remove(struct ufs_hba *hba) {} static bool ufshpb_is_allowed(struct ufs_hba *hba) { return false; } static void ufshpb_get_geo_info(struct ufs_hba *hba, u8 *geo_buf) {} static void ufshpb_get_dev_info(struct ufs_hba *hba, u8 *desc_buf) {} +static bool ufshpb_is_legacy(struct ufs_hba *hba) { return false; } #else -void ufshpb_prep(struct ufs_hba *hba, struct ufshcd_lrb *lrbp); +int ufshpb_prep(struct ufs_hba *hba, struct ufshcd_lrb *lrbp); void ufshpb_rsp_upiu(struct ufs_hba *hba, struct ufshcd_lrb *lrbp); void ufshpb_resume(struct ufs_hba *hba); void ufshpb_suspend(struct ufs_hba *hba); @@ -228,7 +268,9 @@ void ufshpb_remove(struct ufs_hba *hba); bool ufshpb_is_allowed(struct ufs_hba *hba); void ufshpb_get_geo_info(struct ufs_hba *hba, u8 *geo_buf); void ufshpb_get_dev_info(struct ufs_hba *hba, u8 *desc_buf); +bool ufshpb_is_legacy(struct ufs_hba *hba); extern struct attribute_group ufs_sysfs_hpb_stat_group; +extern struct attribute_group ufs_sysfs_hpb_param_group; #endif #endif /* End of Header */
This patch supports the HPB 2.0. The HPB 2.0 supports read of varying sizes from 4KB to 512KB. In the case of Read (<= 32KB) is supported as single HPB read. In the case of Read (36KB ~ 512KB) is supported by as a combination of write buffer command and HPB read command to deliver more PPN. The write buffer commands may not be issued immediately due to busy tags. To use HPB read more aggressively, the driver can requeue the write buffer command. The requeue threshold is implemented as timeout and can be modified with requeue_timeout_ms entry in sysfs. Signed-off-by: Daejun Park <daejun7.park@samsung.com> --- Documentation/ABI/testing/sysfs-driver-ufs | 47 +- drivers/scsi/ufs/ufs-sysfs.c | 4 + drivers/scsi/ufs/ufs.h | 3 +- drivers/scsi/ufs/ufshcd.c | 25 +- drivers/scsi/ufs/ufshcd.h | 7 + drivers/scsi/ufs/ufshpb.c | 627 +++++++++++++++++++-- drivers/scsi/ufs/ufshpb.h | 66 ++- 7 files changed, 698 insertions(+), 81 deletions(-)