> +/* Keeps track of all outstanding copy IO */
> +struct blkdev_copy_io {
> + atomic_t refcount;
> + ssize_t copied;
> + int status;
> + struct task_struct *waiter;
> + void (*endio)(void *private, int status, ssize_t copied);
> + void *private;
> +};
> +
> +/* Keeps track of single outstanding copy offload IO */
> +struct blkdev_copy_offload_io {
> + struct blkdev_copy_io *cio;
> + loff_t offset;
> +};
The structure names confuse me, and the comments make things even worse.
AFAICT:
blkdev_copy_io is a per-call structure, I'd name it blkdev_copy_ctx.
blkdev_copy_offload_io is per-bio pair, and something like blkdev_copy_chunk
might be a better idea. Or we could just try to kill it entirely and add
a field to struct bio in the union currently holding the integrity
information.
I'm also quite confused what kind of offset this offset field is. The
type and name suggest it is an offset in a file, which for a block device
based helper is pretty odd to start with. blkdev_copy_offload
initializes it to len - rem, so it kind is an offset, but relative
to the operation and not to a file. blkdev_copy_offload_src_endio then
uses to set the ->copied field, but based on a min which means
->copied can only be decreased. Something is really off there.
Taking about types and units: blkdev_copy_offload obviously can only
work in terms of LBAs. Any reason to not make it work in terms of
512-byte block layer sectors instead of in bytes?
> + if ((pos_in & align) || (pos_out & align) || (len & align) || !len ||
> + len >= BLK_COPY_MAX_BYTES)
> + return -EINVAL;
This can be cleaned up an optimized a bit:
if (!len || len >= BLK_COPY_MAX_BYTES)
return -EINVAL;
if ((pos_in | pos_out | len) & align)
return -EINVAL;
> + *
> + * For synchronous operation returns the length of bytes copied or error
> + * For asynchronous operation returns -EIOCBQUEUED or error
> + *
> + * Description:
> + * Copy source offset to destination offset within block device, using
> + * device's native copy offload feature.
> + * We perform copy operation using 2 bio's.
> + * 1. We take a plug and send a REQ_OP_COPY_DST bio along with destination
> + * sector and length. Once this bio reaches request layer, we form a
> + * request and wait for dst bio to arrive.
> + * 2. We issue REQ_OP_COPY_SRC bio along with source sector, length.
> + * Once this bio reaches request layer and find a request with previously
> + * sent destination info we merge the source bio and return.
> + * 3. Release the plug and request is sent to driver
> + * This design works only for drivers with request queue.
The wording with all the We here is a bit odd. Much of this also seem
superfluous or at least misplaced in the kernel doc comment as it doesn't
document the API, but just what is done in the code below.
> + cio = kzalloc(sizeof(*cio), gfp);
> + if (!cio)
> + return -ENOMEM;
> + atomic_set(&cio->refcount, 1);
> + cio->waiter = current;
> + cio->endio = endio;
> + cio->private = private;
For the main use this could be allocated on-stack. Is there any good
reason to not let callers that really want an async version to implement
the async behavior themselves using suitable helpers?
> + src_bio = blk_next_bio(dst_bio, bdev, 0, REQ_OP_COPY_SRC, gfp);
Please switch to use bio_chain_and_submit, which is a easier to
understand API. I'm trying to phase out blk_next_bio in favour of
bio_chain_and_submit over the next few merge windows.
> + if (!src_bio)
> + goto err_free_dst_bio;
> + src_bio->bi_iter.bi_size = chunk;
> + src_bio->bi_iter.bi_sector = pos_in >> SECTOR_SHIFT;
> + src_bio->bi_end_io = blkdev_copy_offload_src_endio;
> + src_bio->bi_private = offload_io;
> +
> + atomic_inc(&cio->refcount);
> + submit_bio(src_bio);
> + blk_finish_plug(&plug);
plugs should be hold over all I/Os, submitted from the same caller,
which is the point of them.
