block: Implement support for WRITE SAME

The WRITE SAME command supported on some SCSI devices allows the same
block to be efficiently replicated throughout a block range. Only a
single logical block is transferred from the host and the storage device
writes the same data to all blocks described by the I/O.

This patch implements support for WRITE SAME in the block layer. The
blkdev_issue_write_same() function can be used by filesystems and block
drivers to replicate a buffer across a block range. This can be used to
efficiently initialize software RAID devices, etc.

Signed-off-by: Martin K. Petersen <martin.petersen@oracle.com>
Acked-by: Mike Snitzer <snitzer@redhat.com>
Signed-off-by: Jens Axboe <axboe@kernel.dk>

1 files changed, 74 insertions, 0 deletions

diff --git a/block/blk-lib.c b/block/blk-lib.c
index 19cc761cacb2..a062543c58ac 100644
--- a/block/blk-lib.c
+++ b/block/blk-lib.c
@@ -130,6 +130,80 @@ int blkdev_issue_discard(struct block_device *bdev, sector_t sector,
 EXPORT_SYMBOL(blkdev_issue_discard);
 
 /**
+ * blkdev_issue_write_same - queue a write same operation
+ * @bdev:       target blockdev
+ * @sector:     start sector
+ * @nr_sects:   number of sectors to write
+ * @gfp_mask:   memory allocation flags (for bio_alloc)
+ * @page:       page containing data to write
+ *
+ * Description:
+ *    Issue a write same request for the sectors in question.
+ */
+int blkdev_issue_write_same(struct block_device *bdev, sector_t sector,
+                            sector_t nr_sects, gfp_t gfp_mask,
+                            struct page *page)
+{
+        DECLARE_COMPLETION_ONSTACK(wait);
+        struct request_queue *q = bdev_get_queue(bdev);
+        unsigned int max_write_same_sectors;
+        struct bio_batch bb;
+        struct bio *bio;
+        int ret = 0;
+
+        if (!q)
+                return -ENXIO;
+
+        max_write_same_sectors = q->limits.max_write_same_sectors;
+
+        if (max_write_same_sectors == 0)
+                return -EOPNOTSUPP;
+
+        atomic_set(&bb.done, 1);
+        bb.flags = 1 << BIO_UPTODATE;
+        bb.wait = &wait;
+
+        while (nr_sects) {
+                bio = bio_alloc(gfp_mask, 1);
+                if (!bio) {
+                        ret = -ENOMEM;
+                        break;
+                }
+
+                bio->bi_sector = sector;
+                bio->bi_end_io = bio_batch_end_io;
+                bio->bi_bdev = bdev;
+                bio->bi_private = &bb;
+                bio->bi_vcnt = 1;
+                bio->bi_io_vec->bv_page = page;
+                bio->bi_io_vec->bv_offset = 0;
+                bio->bi_io_vec->bv_len = bdev_logical_block_size(bdev);
+
+                if (nr_sects > max_write_same_sectors) {
+                        bio->bi_size = max_write_same_sectors << 9;
+                        nr_sects -= max_write_same_sectors;
+                        sector += max_write_same_sectors;
+                } else {
+                        bio->bi_size = nr_sects << 9;
+                        nr_sects = 0;
+                }
+
+                atomic_inc(&bb.done);
+                submit_bio(REQ_WRITE | REQ_WRITE_SAME, bio);
+        }
+
+        /* Wait for bios in-flight */
+        if (!atomic_dec_and_test(&bb.done))
+                wait_for_completion(&wait);
+
+        if (!test_bit(BIO_UPTODATE, &bb.flags))
+                ret = -ENOTSUPP;
+
+        return ret;
+}
+EXPORT_SYMBOL(blkdev_issue_write_same);
+
+/**
  * blkdev_issue_zeroout - generate number of zero filed write bios
  * @bdev:       blockdev to issue
  * @sector:     start sector