block: don't allocate a payload for discard request

Allocating a fixed payload for discard requests always was a horrible hack,
and it's not coming to byte us when adding support for discard in DM/MD.

So change the code to leave the allocation of a payload to the lowlevel
driver.  Unfortunately that means we'll need another hack, which allows
us to update the various block layer length fields indicating that we
have a payload.  Instead of hiding this in sd.c, which we already partially
do for UNMAP support add a documented helper in the core block layer for it.

Signed-off-by: Christoph Hellwig <hch@lst.de>
Acked-by: Mike Snitzer <snitzer@redhat.com>
Signed-off-by: Jens Axboe <jaxboe@fusionio.com>

2 files changed, 38 insertions, 27 deletions

diff --git a/block/blk-core.c b/block/blk-core.c
index 66c3cfe94d0a..3531d8e1da04 100644
--- a/block/blk-core.c
+++ b/block/blk-core.c
@@ -1135,6 +1135,38 @@ void blk_put_request(struct request *req)
 }
 EXPORT_SYMBOL(blk_put_request);
 
+/**
+ * blk_add_request_payload - add a payload to a request
+ * @rq: request to update
+ * @page: page backing the payload
+ * @len: length of the payload.
+ *
+ * This allows to later add a payload to an already submitted request by
+ * a block driver.  The driver needs to take care of freeing the payload
+ * itself.
+ *
+ * Note that this is a quite horrible hack and nothing but handling of
+ * discard requests should ever use it.
+ */
+void blk_add_request_payload(struct request *rq, struct page *page,
+                unsigned int len)
+{
+        struct bio *bio = rq->bio;
+
+        bio->bi_io_vec->bv_page = page;
+        bio->bi_io_vec->bv_offset = 0;
+        bio->bi_io_vec->bv_len = len;
+
+        bio->bi_size = len;
+        bio->bi_vcnt = 1;
+        bio->bi_phys_segments = 1;
+
+        rq->__data_len = rq->resid_len = len;
+        rq->nr_phys_segments = 1;
+        rq->buffer = bio_data(bio);
+}
+EXPORT_SYMBOL_GPL(blk_add_request_payload);
+
 void init_request_from_bio(struct request *req, struct bio *bio)
 {
         req->cpu = bio->bi_comp_cpu;
diff --git a/block/blk-lib.c b/block/blk-lib.c
index d0216b9f22d4..e16185b0d8e1 100644
--- a/block/blk-lib.c
+++ b/block/blk-lib.c
@@ -19,7 +19,6 @@ static void blkdev_discard_end_io(struct bio *bio, int err)
 
         if (bio->bi_private)
                 complete(bio->bi_private);
-        __free_page(bio_page(bio));
 
         bio_put(bio);
 }
@@ -43,7 +42,6 @@ int blkdev_issue_discard(struct block_device *bdev, sector_t sector,
         int type = flags & BLKDEV_IFL_BARRIER ?
                 DISCARD_BARRIER : DISCARD_NOBARRIER;
         struct bio *bio;
-        struct page *page;
         int ret = 0;
 
         if (!q)
@@ -53,35 +51,21 @@ int blkdev_issue_discard(struct block_device *bdev, sector_t sector,
                 return -EOPNOTSUPP;
 
         while (nr_sects && !ret) {
-                unsigned int sector_size = q->limits.logical_block_size;
                 unsigned int max_discard_sectors =
                         min(q->limits.max_discard_sectors, UINT_MAX >> 9);
 
                 bio = bio_alloc(gfp_mask, 1);
-                if (!bio)
-                        goto out;
+                if (!bio) {
+                        ret = -ENOMEM;
+                        break;
+                }
+
                 bio->bi_sector = sector;
                 bio->bi_end_io = blkdev_discard_end_io;
                 bio->bi_bdev = bdev;
                 if (flags & BLKDEV_IFL_WAIT)
                         bio->bi_private = &wait;
 
-                /*
-                 * Add a zeroed one-sector payload as that's what
-                 * our current implementations need.  If we'll ever need
-                 * more the interface will need revisiting.
-                 */
-                page = alloc_page(gfp_mask | __GFP_ZERO);
-                if (!page)
-                        goto out_free_bio;
-                if (bio_add_pc_page(q, bio, page, sector_size, 0) < sector_size)
-                        goto out_free_page;
-
-                /*
-                 * And override the bio size - the way discard works we
-                 * touch many more blocks on disk than the actual payload
-                 * length.
-                 */
                 if (nr_sects > max_discard_sectors) {
                         bio->bi_size = max_discard_sectors << 9;
                         nr_sects -= max_discard_sectors;
@@ -103,13 +87,8 @@ int blkdev_issue_discard(struct block_device *bdev, sector_t sector,
                         ret = -EIO;
                 bio_put(bio);
         }
+
         return ret;
-out_free_page:
-        __free_page(page);
-out_free_bio:
-        bio_put(bio);
-out:
-        return -ENOMEM;
 }
 EXPORT_SYMBOL(blkdev_issue_discard);