blk-mq: allow REQ_NOWAIT to return an error inline
Subsystems (2)
Jens Axboe
maintainerPATCH 1/2 blk-mq: allow REQ_NOWAIT to return an error inline
In reply to a message not in the archiveBy default, if a caller sets REQ_NOWAIT and we need to block, we'll return -EAGAIN through the bio->bi_end_io() callback. For some use cases, this makes it hard to use.
Allow a caller to ask for inline return of errors related to blocking by also setting REQ_NOWAIT_INLINE.
--- block/blk-mq.c | 9 +++++++-- include/linux/blk_types.h | 5 ++++- 2 files changed, 11 insertions(+), 3 deletions(-)
block/blk-mq.c +7 -2
@@ -1960,9 +1960,14 @@ static blk_qc_t blk_mq_make_request(struct request_queue *q, struct bio *bio) rq =blk_mq_get_request (q, bio, &data);if (unlikely (!rq)) {rq_qos_cleanup (q, bio); -if (bio->bi_opf &REQ_NOWAIT ) + +if (bio->bi_opf &REQ_NOWAIT_INLINE ) { + cookie =BLK_QC_T_EAGAIN ; + }else if (bio->bi_opf &REQ_NOWAIT ) {bio_wouldblock_error (bio); -return BLK_QC_T_NONE ; + cookie =BLK_QC_T_NONE ; + } +return cookie; }trace_block_getrq (q, bio, bio->bi_opf);
include/linux/blk_types.h +4 -1
@@ -311,6 +311,7 @@ enum req_flag_bits { __REQ_RAHEAD,/* read ahead, can fail anytime */ __REQ_BACKGROUND,/* background IO */ __REQ_NOWAIT,/* Don't wait if request will block */ + __REQ_NOWAIT_INLINE,/* Return would-block error inline */ /* * When a shared kthread needs to issue a bio for a cgroup, doing * so synchronously can lead to priority inversions as the kthread
@@ -345,6 +346,7 @@ enum req_flag_bits {#define REQ_RAHEAD (1ULL << __REQ_RAHEAD)#define REQ_BACKGROUND (1ULL << __REQ_BACKGROUND)#define REQ_NOWAIT (1ULL << __REQ_NOWAIT) +#define REQ_NOWAIT_INLINE (1ULL << __REQ_NOWAIT_INLINE)#define REQ_CGROUP_PUNT (1ULL << __REQ_CGROUP_PUNT)#define REQ_NOUNMAP (1ULL << __REQ_NOUNMAP)
@@ -418,12 +420,13 @@ static inline int op_stat_group(unsigned int op)typedef unsigned int blk_qc_t ;#define BLK_QC_T_NONE -1U +#define BLK_QC_T_EAGAIN -2U#define BLK_QC_T_SHIFT 16#define BLK_QC_T_INTERNAL (1U << 31)static inline bool blk_qc_t_valid (blk_qc_t cookie) { -return cookie !=BLK_QC_T_NONE ; +return cookie !=BLK_QC_T_NONE && cookie !=BLK_QC_T_EAGAIN ; }static inline unsigned int blk_qc_t_to_queue_num (blk_qc_t cookie)
Signature · 1 line
2.17.1
Jens Axboe
maintainerPATCH 2/2 block: properly handle IOCB_NOWAIT for async O_DIRECT IO
In reply to a message not in the archiveA caller is supposed to pass in REQ_NOWAIT if we can't block for any given operation, but O_DIRECT for block devices just ignore this. Hence we'll block for various resource shortages on the block layer side, like having to wait for requests.
Use the new REQ_NOWAIT_INLINE to ask for this error to be returned inline, so we can handle it appropriately and return -EAGAIN to the caller.
--- fs/block_dev.c | 41 ++++++++++++++++++++++++++++++++++++++--- 1 file changed, 38 insertions(+), 3 deletions(-)
fs/block_dev.c +38 -3
@@ -344,15 +344,24 @@ __blkdev_direct_IO(struct kiocb *iocb, struct iov_iter *iter, int nr_pages)struct bio *bio;bool is_poll = (iocb->ki_flags &IOCB_HIPRI ) !=0 ;bool is_read = (iov_iter_rw (iter) ==READ ), is_sync; +bool nowait = (iocb->ki_flags &IOCB_NOWAIT ) !=0 ;loff_t pos = iocb->ki_pos;blk_qc_t qc =BLK_QC_T_NONE ; +gfp_t gfp;int ret =0 ;if ((pos |iov_iter_alignment (iter)) & (bdev_logical_block_size (bdev) -1 ))return -EINVAL ; - bio =bio_alloc_bioset (GFP_KERNEL , nr_pages, &blkdev_dio_pool); +if (nowait) + gfp =GFP_NOWAIT ; +else + gfp =GFP_KERNEL ; + + bio =bio_alloc_bioset (gfp, nr_pages, &blkdev_dio_pool); +if (!bio) +return -EAGAIN ; dio = container_of(bio, struct blkdev_dio, bio); dio->is_sync = is_sync =is_sync_kiocb (iocb);
@@ -398,6 +407,14 @@ __blkdev_direct_IO(struct kiocb *iocb, struct iov_iter *iter, int nr_pages)task_io_account_write (bio->bi_iter.bi_size); } +/* +* Tell underlying layer to not block for resource shortage. +* And if we would have blocked, return error inline instead +* of through the bio->bi_end_io() callback. +*/ +if (nowait) + bio->bi_opf |= (REQ_NOWAIT |REQ_NOWAIT_INLINE ); + dio->size += bio->bi_iter.bi_size; pos += bio->bi_iter.bi_size;
@@ -411,6 +428,10 @@ __blkdev_direct_IO(struct kiocb *iocb, struct iov_iter *iter, int nr_pages) } qc =submit_bio (bio); +if (qc ==BLK_QC_T_EAGAIN ) { + ret = -EAGAIN ; + goto err; + }if (polled)WRITE_ONCE (iocb->ki_cookie, qc);
@@ -431,8 +452,17 @@ __blkdev_direct_IO(struct kiocb *iocb, struct iov_iter *iter, int nr_pages)atomic_inc (&dio->ref); } -submit_bio (bio); - bio =bio_alloc (GFP_KERNEL , nr_pages); + qc =submit_bio (bio); +if (qc ==BLK_QC_T_EAGAIN ) { + ret = -EAGAIN ; + goto err; + } + + bio =bio_alloc (gfp, nr_pages); +if (!bio) { + ret = -EAGAIN ; + goto err; + } }if (!is_poll)
@@ -452,6 +482,7 @@ __blkdev_direct_IO(struct kiocb *iocb, struct iov_iter *iter, int nr_pages) }__set_current_state (TASK_RUNNING ); +out:if (!ret) ret =blk_status_to_errno (dio->bio.bi_status);if (likely (!ret))
@@ -459,6 +490,10 @@ __blkdev_direct_IO(struct kiocb *iocb, struct iov_iter *iter, int nr_pages)bio_put (&dio->bio);return ret; +err: +if (!is_poll) +blk_finish_plug (&plug); + goto out; } static ssize_t
Signature · 1 line
2.17.1