On 8/10/23 05:23, Bart Van Assche wrote: > Measurements have shown that limiting the queue depth to one per zone for > zoned writes has a significant negative performance impact on zoned UFS > devices. Hence this patch that disables zone locking by the mq-deadline > scheduler if the storage controller preserves the command order. This > patch is based on the following assumptions: > - It happens infrequently that zoned write requests are reordered by the > block layer. > - The I/O priority of all write requests is the same per zone. > - Either no I/O scheduler is used or an I/O scheduler is used that > serializes write requests per zone. > > Cc: Damien Le Moal <dlemoal@xxxxxxxxxx> > Cc: Christoph Hellwig <hch@xxxxxx> > Cc: Ming Lei <ming.lei@xxxxxxxxxx> > Signed-off-by: Bart Van Assche <bvanassche@xxxxxxx> > --- > block/mq-deadline.c | 24 ++++++++++++++++++------ > 1 file changed, 18 insertions(+), 6 deletions(-) > > diff --git a/block/mq-deadline.c b/block/mq-deadline.c > index f958e79277b8..cd2504205ff8 100644 > --- a/block/mq-deadline.c > +++ b/block/mq-deadline.c > @@ -338,6 +338,16 @@ static struct request *deadline_skip_seq_writes(struct deadline_data *dd, > return rq; > } > > +/* > + * Whether or not to use zone write locking. Not using zone write locking for > + * sequential write required zones is only safe if the block driver preserves > + * the request order. > + */ > +static bool dd_use_zone_write_locking(struct request_queue *q) > +{ > + return q->limits.use_zone_write_lock && blk_queue_is_zoned(q); use_zone_write_lock should be true ONLY if the queue is zoned. So the "&& blk_queue_is_zoned(q)" seems unnecessary to me. This little helper could be moved to be generic in blkdev.h too. > +} > + > /* > * For the specified data direction, return the next request to > * dispatch using arrival ordered lists. > @@ -353,7 +363,7 @@ deadline_fifo_request(struct deadline_data *dd, struct dd_per_prio *per_prio, > return NULL; > > rq = rq_entry_fifo(per_prio->fifo_list[data_dir].next); > - if (data_dir == DD_READ || !blk_queue_is_zoned(rq->q)) > + if (data_dir == DD_READ || !dd_use_zone_write_locking(rq->q)) > return rq; > > /* > @@ -398,7 +408,7 @@ deadline_next_request(struct deadline_data *dd, struct dd_per_prio *per_prio, > if (!rq) > return NULL; > > - if (data_dir == DD_READ || !blk_queue_is_zoned(rq->q)) > + if (data_dir == DD_READ || !dd_use_zone_write_locking(rq->q)) > return rq; > > /* > @@ -526,8 +536,9 @@ static struct request *__dd_dispatch_request(struct deadline_data *dd, > } > > /* > - * For a zoned block device, if we only have writes queued and none of > - * them can be dispatched, rq will be NULL. > + * For a zoned block device that requires write serialization, if we > + * only have writes queued and none of them can be dispatched, rq will > + * be NULL. > */ > if (!rq) > return NULL; > @@ -552,7 +563,8 @@ static struct request *__dd_dispatch_request(struct deadline_data *dd, > /* > * If the request needs its target zone locked, do it. > */ > - blk_req_zone_write_lock(rq); > + if (dd_use_zone_write_locking(rq->q)) > + blk_req_zone_write_lock(rq); > rq->rq_flags |= RQF_STARTED; > return rq; > } > @@ -934,7 +946,7 @@ static void dd_finish_request(struct request *rq) > > atomic_inc(&per_prio->stats.completed); > > - if (blk_queue_is_zoned(q)) { > + if (dd_use_zone_write_locking(rq->q)) { > unsigned long flags; > > spin_lock_irqsave(&dd->zone_lock, flags); -- Damien Le Moal Western Digital Research