block: add request clone interface
Subsystems (2)
PATCH 1/1 block: add request clone interface
Hi Jens,
Recently, I posted an updated version of request-based dm patch-set
(http://marc.info/?l=dm-devel&m=124392590507004&w=2) which was made on top of block#for-2.6.31.
In block#for-2.6.31, __sector and __data_len of struct request are commented as 'internal, NEVER access directly'.
However, since request-based dm needs to copy the latest status of the original request to clone, those fields are still accessed directly in the request-based dm patch-set.
I'd like to solve this issue without breaking the new block-layer policy. If those fields should not be accessed directly, I need a helper function to copy the original request.
What do you think about the following patch which adds request cloning interface to the block-layer?
Please apply if you have no problem.
This patch adds the following 2 interfaces for request-stacking drivers:
- blk_rq_prep_clone(struct request *clone, struct request *orig, struct bio_set *bs, gfp_t gfp_mask, int (*bio_ctr)(struct bio *, struct bio*, void *), void *data)
* Clones bios in the original request to the clone request (bio_ctr is called for each cloned bios.)
* Copies the clone-related information of the original request to the clone request.
- blk_rq_unprep_clone(struct request *clone)
* Frees cloned bios from the clone request.
Request stacking drivers (e.g. request-based dm) need to make a clone request for a submitted request and dispatch it to other devices.
To allocate request for the clone, request stacking drivers may not be able to use blk_get_request() because the allocation may be done in an irq-disabled context.
So blk_rq_prep_clone() takes a request allocated by the caller as an argument.
For each clone bio in the clone request, request stacking drivers should be able to set up their own completion handler. So blk_rq_prep_clone() takes a callback function which is called for each clone bio, and a pointer for private data which is passed to the callback.
--- block/blk-core.c | 98 +++++++++++++++++++++++++++++++++++++++++++++++++ include/linux/blkdev.h | 5 ++ 2 files changed, 103 insertions(+)
block/blk-core.c +98 -0
@@ -2295,6 +2295,104 @@ int blk_lld_busy(struct request_queue *q }EXPORT_SYMBOL_GPL (blk_lld_busy); +/** +* blk_rq_unprep_clone - Helper function to free all bios in a cloned request +* @rq: the clone request to be cleaned up +* +* Description: +* Free all bios in @rq for a cloned request. +*/ +void blk_rq_unprep_clone (struct request *rq) +{ +struct bio *bio; + +while ((bio = rq->bio) !=NULL ) { + rq->bio = bio->bi_next; + +bio_put (bio); + } +} +EXPORT_SYMBOL_GPL (blk_rq_unprep_clone); + +/* +* Copy request information of the original request to the clone request. +*/ +static void __blk_rq_prep_clone (struct request *dst,struct request *src) +{ + dst->cpu = src->cpu; + dst->cmd_flags = (rq_data_dir (src) |REQ_NOMERGE ); + dst->cmd_type = src->cmd_type; + dst->__sector =blk_rq_pos (src); + dst->__data_len =blk_rq_bytes (src); + dst->nr_phys_segments = src->nr_phys_segments; + dst->ioprio = src->ioprio; + dst->buffer = src->buffer; + dst->cmd_len = src->cmd_len; + dst->cmd = src->cmd; + dst->extra_len = src->extra_len; + dst->sense = src->sense; +} + +/** +* blk_rq_prep_clone - Helper function to setup clone request +* @rq: the request to be setup +* @rq_src: original request to be cloned +* @bs: bio_set that bios for clone are allocated from +* @gfp_mask: memory allocation mask for bio +* @bio_ctr: setup function to be called for each clone bio. +* Returns %0 for success, non %0 for failure. +* @data: private data to be passed to @bio_ctr +* +* Description: +* Clones bios in @rq_src to @rq, and copies clone-related information +* of @rq_src to @rq. +*/ +int blk_rq_prep_clone (struct request *rq,struct request *rq_src, +struct bio_set *bs,gfp_t gfp_mask, +int (*bio_ctr)(struct bio *,struct bio *,void *), +void *data) +{ +struct bio *bio, *bio_src; + +if (!bs) + bs = fs_bio_set; + +blk_rq_init (NULL , rq); + +__rq_for_each_bio (bio_src, rq_src) { + bio =bio_alloc_bioset (gfp_mask, bio_src->bi_max_vecs, bs); +if (!bio) + goto free_and_out; + +__bio_clone (bio, bio_src); + +if (bio_integrity (bio_src) && +bio_integrity_clone (bio, bio_src, gfp_mask)) + goto free_and_out; + +if (bio_ctr &&bio_ctr (bio, bio_src, data)) + goto free_and_out; + +if (rq->bio) { + rq->biotail->bi_next = bio; + rq->biotail = bio; + }else + rq->bio = rq->biotail = bio; + } + +__blk_rq_prep_clone (rq, rq_src); + +return 0 ; + +free_and_out: +if (bio) +bio_free (bio, bs); +blk_rq_unprep_clone (rq); + +return -ENOMEM ; +} +EXPORT_SYMBOL_GPL (blk_rq_prep_clone); +int kblockd_schedule_work (struct request_queue *q,struct work_struct *work) {return queue_work (kblockd_workqueue, work);
include/linux/blkdev.h +5 -0
@@ -765,6 +765,11 @@ extern void blk_insert_request(struct reextern void blk_requeue_request (struct request_queue *,struct request *);extern int blk_rq_check_limits (struct request_queue *q,struct request *rq);extern int blk_lld_busy (struct request_queue *q); +extern int blk_rq_prep_clone (struct request *rq,struct request *rq_src, +struct bio_set *bs,gfp_t gfp_mask, +int (*bio_ctr)(struct bio *,struct bio *,void *), +void *data); +extern void blk_rq_unprep_clone (struct request *rq);extern int blk_insert_cloned_request (struct request_queue *q,struct request *rq);extern void blk_plug_device (struct request_queue *);
Quoted 49 lines · Kiyoshi Ueda
Hi Jens,
Recently, I posted an updated version of request-based dm patch-set
(http://marc.info/?l=dm-devel&m=124392590507004&w=2) which was made on top of block#for-2.6.31.
In block#for-2.6.31,__sectorand__data_lenof struct request are commented as 'internal, NEVER access directly'.
However, since request-based dm needs to copy the latest status of the original request to clone, those fields are still accessed directly in the request-based dm patch-set.I'd like to solve this issue without breaking the new block-layer policy. If those fields should not be accessed directly, I need a helper function to copy the original request.
What do you think about the following patch which adds request cloning interface to the block-layer?
Please apply if you have no problem.This patch adds the following 2 interfaces for request-stacking drivers:
- blk_rq_prep_clone(struct request *clone, struct request *orig, struct
bio_set*bs,gfp_tgfp_mask, int (*bio_ctr)(struct bio *, struct bio*, void *), void *data)
* Clones bios in the original request to the clone request (bio_ctris called for each cloned bios.)
* Copies the clone-related information of the original request to the clone request.-
blk_rq_unprep_clone(struct request *clone)
* Frees cloned bios from the clone request.Request stacking drivers (e.g. request-based dm) need to make a clone request for a submitted request and dispatch it to other devices.
To allocate request for the clone, request stacking drivers may not be able to use
blk_get_request()because the allocation may be done in an irq-disabled context.
Soblk_rq_prep_clone()takes a request allocated by the caller as an argument.For each clone bio in the clone request, request stacking drivers should be able to set up their own completion handler. So
blk_rq_prep_clone()takes a callback function which is called for each clone bio, and a pointer for private data which is passed to the callback.
Quoted 3 lines
Signed-off-by Kiyoshi Ueda <[email protected]>Signed-off-by Jun'ichi Nomura <[email protected]>Cc Jens Axboe <[email protected]>
Please CC me on this patch. I have use of it also for stacking block driver. Once/if it hits mainline I would like to use this function.
(Have not tested it yet)
Thanks
Quoted 136 lines
--- block/blk-core.c | 98 +++++++++++++++++++++++++++++++++++++++++++++++++ include/linux/blkdev.h | 5 ++ 2 files changed, 103 insertions(+)Index:
linux-2.6-block/block/blk-core.c
===================================================================block/blk-core.c +98
-0@@ -2295,6 +2295,104 @@ int blk_lld_busy(struct request_queue *q }EXPORT_SYMBOL_GPL (blk_lld_busy); +/** +* blk_rq_unprep_clone - Helper function to free all bios in a cloned request +* @rq: the clone request to be cleaned up +* +* Description: +* Free all bios in @rq for a cloned request. +*/ +void blk_rq_unprep_clone (struct request *rq) +{ +struct bio *bio; + +while ((bio = rq->bio) !=NULL ) { + rq->bio = bio->bi_next; + +bio_put (bio); + } +} +EXPORT_SYMBOL_GPL (blk_rq_unprep_clone); + +/* +* Copy request information of the original request to the clone request. +*/ +static void __blk_rq_prep_clone (struct request *dst,struct request *src) +{ + dst->cpu = src->cpu; + dst->cmd_flags = (rq_data_dir (src) |REQ_NOMERGE ); + dst->cmd_type = src->cmd_type; + dst->__sector =blk_rq_pos (src); + dst->__data_len =blk_rq_bytes (src); + dst->nr_phys_segments = src->nr_phys_segments; + dst->ioprio = src->ioprio; + dst->buffer = src->buffer; + dst->cmd_len = src->cmd_len; + dst->cmd = src->cmd; + dst->extra_len = src->extra_len; + dst->sense = src->sense; +} + +/** +* blk_rq_prep_clone - Helper function to setup clone request +* @rq: the request to be setup +* @rq_src: original request to be cloned +* @bs: bio_set that bios for clone are allocated from +* @gfp_mask: memory allocation mask for bio +* @bio_ctr: setup function to be called for each clone bio. +* Returns %0 for success, non %0 for failure. +* @data: private data to be passed to @bio_ctr +* +* Description: +* Clones bios in @rq_src to @rq, and copies clone-related information +* of @rq_src to @rq. +*/ +int blk_rq_prep_clone (struct request *rq,struct request *rq_src, +struct bio_set *bs,gfp_t gfp_mask, +int (*bio_ctr)(struct bio *,struct bio *,void *), +void *data) +{ +struct bio *bio, *bio_src; + +if (!bs) + bs = fs_bio_set; + +blk_rq_init (NULL , rq); + +__rq_for_each_bio (bio_src, rq_src) { + bio =bio_alloc_bioset (gfp_mask, bio_src->bi_max_vecs, bs); +if (!bio) + goto free_and_out; + +__bio_clone (bio, bio_src); + +if (bio_integrity (bio_src) && +bio_integrity_clone (bio, bio_src, gfp_mask)) + goto free_and_out; + +if (bio_ctr &&bio_ctr (bio, bio_src, data)) + goto free_and_out; + +if (rq->bio) { + rq->biotail->bi_next = bio; + rq->biotail = bio; + }else + rq->bio = rq->biotail = bio; + } + +__blk_rq_prep_clone (rq, rq_src); + +return 0 ; + +free_and_out: +if (bio) +bio_free (bio, bs); +blk_rq_unprep_clone (rq); + +return -ENOMEM ; +} +EXPORT_SYMBOL_GPL (blk_rq_prep_clone); +int kblockd_schedule_work (struct request_queue *q,struct work_struct *work) {return queue_work (kblockd_workqueue, work);Index:
linux-2.6-block/include/linux/blkdev.h
===================================================================include/linux/blkdev.h +5
-1@@ -765,6 +765,11 @@ extern void blk_insert_request(struct reextern void blk_requeue_request (struct request_queue *,struct request *);extern int blk_rq_check_limits (struct request_queue *q,struct request *rq);extern int blk_lld_busy (struct request_queue *q); +extern int blk_rq_prep_clone (struct request *rq,struct request *rq_src, +struct bio_set *bs,gfp_t gfp_mask, +int (*bio_ctr)(struct bio *,struct bio *,void *), +void *data); +extern void blk_rq_unprep_clone (struct request *rq);extern int blk_insert_cloned_request (struct request_queue *q,struct request *rq);extern void blk_plug_device (struct request_queue *); --To unsubscribe from this list: send the line "unsubscribe linux-kernel" in the body of a message to [email protected]
More majordomo info at http://vger.kernel.org/majordomo-info.html
Please read the FAQ at http://www.tux.org/lkml/
Quoted 7 lines · Kiyoshi Ueda
Hi Jens,
block/blk-core.c +5
-0+/* +* Copy request information of the original request to the clone request. +*/ +static void __blk_rq_prep_clone (struct request *dst,struct request *src) +{
block/blk-core.c int blk_lld_busy(struct request_queue *q · line 2331
Quoted 10 lines
block/blk-core.c +10
-0+ dst->cpu = src->cpu; + dst->cmd_flags = (rq_data_dir (src) |REQ_NOMERGE ); + dst->cmd_type = src->cmd_type; + dst->__sector =blk_rq_pos (src); + dst->__data_len =blk_rq_bytes (src); + dst->nr_phys_segments = src->nr_phys_segments; + dst->ioprio = src->ioprio; + dst->buffer = src->buffer; + dst->cmd_len = src->cmd_len; + dst->cmd = src->cmd;
Are you making sure that 'src' always exists while 'dst' is alive?
Signature · 1 line
Jens Axboe
Hi Jens,
Quoted 12 lines · Jens Axboe
Quoted 11 lines · Kiyoshi Ueda
Hi Jens,
block/blk-core.c +9
-0+/* +* Copy request information of the original request to the clone request. +*/ +static void __blk_rq_prep_clone (struct request *dst,struct request *src) +{ + dst->cpu = src->cpu; + dst->cmd_flags = (rq_data_dir (src) |REQ_NOMERGE ); + dst->cmd_type = src->cmd_type; + dst->__sector =blk_rq_pos (src);
Quoted 8 lines
block/blk-core.c int blk_lld_busy(struct request_queue *q · line 2331
Quoted 6 lines
block/blk-core.c +6
-0+ dst->__data_len =blk_rq_bytes (src); + dst->nr_phys_segments = src->nr_phys_segments; + dst->ioprio = src->ioprio; + dst->buffer = src->buffer; + dst->cmd_len = src->cmd_len; + dst->cmd = src->cmd;Are you making sure that 'src' always exists while 'dst' is alive?
Yes.
Request-based dm is the owner of 'src' (original) and it never frees 'src' until the 'dst' (clone) are completed.
I avoided deep-copying __cmd/buffer/sense as it's costly (additional allocation and memcpy).
And I don't think there are any needs for that. But if anyone really wants that even with the copying cost, please speak up.
Thanks,
Kiyoshi Ueda
Quoted 28 lines · Kiyoshi Ueda
Hi Jens,
Quoted 12 lines · Jens Axboe
Quoted 11 lines · Kiyoshi Ueda
Hi Jens,
block/blk-core.c +9
-0+/* +* Copy request information of the original request to the clone request. +*/ +static void __blk_rq_prep_clone (struct request *dst,struct request *src) +{ + dst->cpu = src->cpu; + dst->cmd_flags = (rq_data_dir (src) |REQ_NOMERGE ); + dst->cmd_type = src->cmd_type; + dst->__sector =blk_rq_pos (src);Quoted 8 lines
block/blk-core.c int blk_lld_busy(struct request_queue *q · line 2331
Quoted 6 lines
block/blk-core.c +6
-0+ dst->__data_len =blk_rq_bytes (src); + dst->nr_phys_segments = src->nr_phys_segments; + dst->ioprio = src->ioprio; + dst->buffer = src->buffer; + dst->cmd_len = src->cmd_len; + dst->cmd = src->cmd;Are you making sure that 'src' always exists while 'dst' is alive?
Yes.
Request-based dm is the owner of 'src' (original) and it never frees 'src' until the 'dst' (clone) are completed.
Quoted 5 lines
I avoided deep-copying __cmd/buffer/sense as it's costly (additional allocation and memcpy).
And I don't think there are any needs for that. But if anyone really wants that even with the copying cost, please speak up.
I just worry that the interface is easy to misuse. You don't document the requirement that the src request may not go away while dst is used, yet it's an important fact. The function advertises itself as a copy, you would not normally expect any such restrictions.
Signature · 1 line
Jens Axboe
Quoted 23 lines · Kiyoshi Ueda
Hi Jens,
Quoted 19 lines · Jens Axboe
Quoted 7 lines · Kiyoshi Ueda
Hi Jens,
block/blk-core.c +5
-0+/* +* Copy request information of the original request to the clone request. +*/ +static void __blk_rq_prep_clone (struct request *dst,struct request *src) +{block/blk-core.c int blk_lld_busy(struct request_queue *q · line 2331
Quoted 10 lines
block/blk-core.c +10
-0+ dst->cpu = src->cpu; + dst->cmd_flags = (rq_data_dir (src) |REQ_NOMERGE ); + dst->cmd_type = src->cmd_type; + dst->__sector =blk_rq_pos (src); + dst->__data_len =blk_rq_bytes (src); + dst->nr_phys_segments = src->nr_phys_segments; + dst->ioprio = src->ioprio; + dst->buffer = src->buffer; + dst->cmd_len = src->cmd_len; + dst->cmd = src->cmd;Are you making sure that 'src' always exists while 'dst' is alive?
Quoted 6 lines
Yes.
Request-based dm is the owner of 'src' (original) and it never frees 'src' until the 'dst' (clone) are completed.I avoided deep-copying __cmd/buffer/sense as it's costly (additional allocation and memcpy).
For my needs for example dst->cmd will be different then src->cmd. Could be untouched. The caller will set what he needs.
dst->sense should be untouched, caller can set to src->sense if he wants to. Or like me he already have another buffer.
dst->buffer is always NULL in my path so I don't know what that is. Tejun?
It should only be about bios and lengths.
And a big fat comment about what it does and what it does not.
Quoted 6 lines
And I don't think there are any needs for that. But if anyone really wants that even with the copying cost, please speak up.
Thanks,
Kiyoshi Ueda
Thanks
Boaz
Hi Jens,
Quoted 31 lines · Jens Axboe
Quoted 24 lines · Kiyoshi Ueda
Quoted 19 lines · Jens Axboe
Quoted 7 lines · Kiyoshi Ueda
Hi Jens,
block/blk-core.c +5
-0+/* +* Copy request information of the original request to the clone request. +*/ +static void __blk_rq_prep_clone (struct request *dst,struct request *src) +{block/blk-core.c int blk_lld_busy(struct request_queue *q · line 2331
Quoted 10 lines
block/blk-core.c +10
-0+ dst->cpu = src->cpu; + dst->cmd_flags = (rq_data_dir (src) |REQ_NOMERGE ); + dst->cmd_type = src->cmd_type; + dst->__sector =blk_rq_pos (src); + dst->__data_len =blk_rq_bytes (src); + dst->nr_phys_segments = src->nr_phys_segments; + dst->ioprio = src->ioprio; + dst->buffer = src->buffer; + dst->cmd_len = src->cmd_len; + dst->cmd = src->cmd;Are you making sure that 'src' always exists while 'dst' is alive?
Yes.
Request-based dm is the owner of 'src' (original) and it never frees 'src' until the 'dst' (clone) are completed.Quoted 5 lines
I avoided deep-copying __cmd/buffer/sense as it's costly (additional allocation and memcpy).
And I don't think there are any needs for that. But if anyone really wants that even with the copying cost, please speak up.
Quoted 4 lines
I just worry that the interface is easy to misuse. You don't document the requirement that the src request may not go away while dst is used, yet it's an important fact. The function advertises itself as a copy, you would not normally expect any such restrictions.
OK, I see.
Since forcing such restrictions by code-level is pretty difficult (e.g. bio also points pages which are not copied), I'd like to put documents for this.
Please see the updated patch also reflecting Boaz's comments:
http://marc.info/?l=dm-devel&m=124468991432260&w=2
Thanks,
Kiyoshi Ueda
Hi Boaz,
Quoted 35 lines · Boaz Harrosh
Quoted 20 lines · Kiyoshi Ueda
Quoted 19 lines · Jens Axboe
Quoted 7 lines · Kiyoshi Ueda
Hi Jens,
block/blk-core.c +5
-0+/* +* Copy request information of the original request to the clone request. +*/ +static void __blk_rq_prep_clone (struct request *dst,struct request *src) +{block/blk-core.c int blk_lld_busy(struct request_queue *q · line 2331
Quoted 10 lines
block/blk-core.c +10
-0+ dst->cpu = src->cpu; + dst->cmd_flags = (rq_data_dir (src) |REQ_NOMERGE ); + dst->cmd_type = src->cmd_type; + dst->__sector =blk_rq_pos (src); + dst->__data_len =blk_rq_bytes (src); + dst->nr_phys_segments = src->nr_phys_segments; + dst->ioprio = src->ioprio; + dst->buffer = src->buffer; + dst->cmd_len = src->cmd_len; + dst->cmd = src->cmd;Are you making sure that 'src' always exists while 'dst' is alive?
Quoted 6 lines
Yes.
Request-based dm is the owner of 'src' (original) and it never frees 'src' until the 'dst' (clone) are completed.I avoided deep-copying __cmd/buffer/sense as it's costly (additional allocation and memcpy).
For my needs for example
dst->cmdwill be different thensrc->cmd. Could be untouched. The caller will set what he needs.
dst->senseshould be untouched, caller can set tosrc->senseif he wants to. Or like me he already have another buffer.
Quoted 7 lines
dst->bufferis always NULL in my path so I don't know what that is. Tejun?It should only be about bios and lengths.
And a big fat comment about what it does and what it does not.
OK, I removed ->cmd, ->sense and ->buffer from __blk_rq_prep_clone() and added some documents.
Please see the updated patch:
http://marc.info/?l=dm-devel&m=124468991432260&w=2
Thanks,
Kiyoshi Ueda
Quoted 34 lines · Kiyoshi Ueda
Hi Jens,
Quoted 31 lines · Jens Axboe
Quoted 29 lines · Kiyoshi Ueda
Quoted 19 lines · Jens Axboe
Quoted 7 lines · Kiyoshi Ueda
Hi Jens,
block/blk-core.c +5
-0+/* +* Copy request information of the original request to the clone request. +*/ +static void __blk_rq_prep_clone (struct request *dst,struct request *src) +{block/blk-core.c int blk_lld_busy(struct request_queue *q · line 2331
Quoted 10 lines
block/blk-core.c +10
-0+ dst->cpu = src->cpu; + dst->cmd_flags = (rq_data_dir (src) |REQ_NOMERGE ); + dst->cmd_type = src->cmd_type; + dst->__sector =blk_rq_pos (src); + dst->__data_len =blk_rq_bytes (src); + dst->nr_phys_segments = src->nr_phys_segments; + dst->ioprio = src->ioprio; + dst->buffer = src->buffer; + dst->cmd_len = src->cmd_len; + dst->cmd = src->cmd;Are you making sure that 'src' always exists while 'dst' is alive?
Yes.
Request-based dm is the owner of 'src' (original) and it never frees 'src' until the 'dst' (clone) are completed.I avoided deep-copying __cmd/buffer/sense as it's costly (additional allocation and memcpy).
And I don't think there are any needs for that. But if anyone really wants that even with the copying cost, please speak up.
Quoted 8 lines
Quoted 4 lines
I just worry that the interface is easy to misuse. You don't document the requirement that the src request may not go away while dst is used, yet it's an important fact. The function advertises itself as a copy, you would not normally expect any such restrictions.
OK, I see.
Since forcing such restrictions by code-level is pretty difficult (e.g. bio also points pages which are not copied), I'd like to put
That's not really an issue, since the IO path doesn't deal with references on the pages. In the case where it does, it has allocated the page itself and the clone and original end IO must of course deal with releasing them properly.
I'm not saying that linking to the src->__cmd is necessarily a problem, if you stack nicely and release the original when the clone is done (like you normally would), then it's all peachy. It just needs to be made explicit :-)
Quoted 6 lines
documents for this.
Please see the updated patch also reflecting Boaz's comments:http://marc.info/?l=dm-devel&m=124468991432260&w=2Thanks,
Kiyoshi Ueda
Signature · 1 line
Jens Axboe
Hello, Boaz.
Quoted 2 lines · Boaz Harrosh
dst->bufferis always NULL in my path so I don't know what that is. Tejun?
Sorry about late reply.
It points to the head of the data buffer (bio) if the address is in addressable range (actually gets bogus value if not) and is used mostly by PIO-only drivers. It's set in blk_rq_bio_prep(), gets updated on merge and partial request completion.
Thanks.
Signature · 1 line
tejun