Add 'discard' request handling

Some block devices benefit from a hint that they can forget the contents
of certain sectors. Add basic support for this to the block core, along
with a 'blkdev_issue_discard()' helper function which issues such
requests.

The caller doesn't get to provide an end_io functio, since
blkdev_issue_discard() will automatically split the request up into
multiple bios if appropriate. Neither does the function wait for
completion -- it's expected that callers won't care about when, or even
_if_, the request completes. It's only a hint to the device anyway. By
definition, the file system doesn't _care_ about these sectors any more.

[With feedback from OGAWA Hirofumi <hirofumi@mail.parknet.co.jp> and
Jens Axboe <jens.axboe@oracle.com]

Signed-off-by: David Woodhouse <David.Woodhouse@intel.com>
Signed-off-by: Jens Axboe <jens.axboe@oracle.com>

3 files changed, 106 insertions, 8 deletions

diff --git a/block/blk-barrier.c b/block/blk-barrier.c
index a09ead19f9c5..273121c0eb80 100644
--- a/block/blk-barrier.c
+++ b/block/blk-barrier.c
@@ -315,3 +315,72 @@ int blkdev_issue_flush(struct block_device *bdev, sector_t *error_sector)
         return ret;
 }
 EXPORT_SYMBOL(blkdev_issue_flush);
+
+static void blkdev_discard_end_io(struct bio *bio, int err)
+{
+        if (err) {
+                if (err == -EOPNOTSUPP)
+                        set_bit(BIO_EOPNOTSUPP, &bio->bi_flags);
+                clear_bit(BIO_UPTODATE, &bio->bi_flags);
+        }
+
+        bio_put(bio);
+}
+
+/**
+ * blkdev_issue_discard - queue a discard
+ * @bdev:       blockdev to issue discard for
+ * @sector:     start sector
+ * @nr_sects:   number of sectors to discard
+ *
+ * Description:
+ *    Issue a discard request for the sectors in question. Does not wait.
+ */
+int blkdev_issue_discard(struct block_device *bdev, sector_t sector,
+                         unsigned nr_sects)
+{
+        struct request_queue *q;
+        struct bio *bio;
+        int ret = 0;
+
+        if (bdev->bd_disk == NULL)
+                return -ENXIO;
+
+        q = bdev_get_queue(bdev);
+        if (!q)
+                return -ENXIO;
+
+        if (!q->prepare_discard_fn)
+                return -EOPNOTSUPP;
+
+        while (nr_sects && !ret) {
+                bio = bio_alloc(GFP_KERNEL, 0);
+                if (!bio)
+                        return -ENOMEM;
+
+                bio->bi_end_io = blkdev_discard_end_io;
+                bio->bi_bdev = bdev;
+
+                bio->bi_sector = sector;
+
+                if (nr_sects > q->max_hw_sectors) {
+                        bio->bi_size = q->max_hw_sectors << 9;
+                        nr_sects -= q->max_hw_sectors;
+                        sector += q->max_hw_sectors;
+                } else {
+                        bio->bi_size = nr_sects << 9;
+                        nr_sects = 0;
+                }
+                bio_get(bio);
+                submit_bio(WRITE_DISCARD, bio);
+
+                /* Check if it failed immediately */
+                if (bio_flagged(bio, BIO_EOPNOTSUPP))
+                        ret = -EOPNOTSUPP;
+                else if (!bio_flagged(bio, BIO_UPTODATE))
+                        ret = -EIO;
+                bio_put(bio);
+        }
+        return ret;
+}
+EXPORT_SYMBOL(blkdev_issue_discard);
diff --git a/block/blk-core.c b/block/blk-core.c
index a496727df7ef..1e143c4f9d34 100644
--- a/block/blk-core.c
+++ b/block/blk-core.c
@@ -1079,6 +1079,10 @@ void init_request_from_bio(struct request *req, struct bio *bio)
          */
         if (unlikely(bio_barrier(bio)))
                 req->cmd_flags |= (REQ_HARDBARRIER | REQ_NOMERGE);
+        if (unlikely(bio_discard(bio))) {
+                req->cmd_flags |= (REQ_SOFTBARRIER | REQ_DISCARD);
+                req->q->prepare_discard_fn(req->q, req);
+        }
 
         if (bio_sync(bio))
                 req->cmd_flags |= REQ_RW_SYNC;
@@ -1095,7 +1099,7 @@ void init_request_from_bio(struct request *req, struct bio *bio)
 static int __make_request(struct request_queue *q, struct bio *bio)
 {
         struct request *req;
-        int el_ret, nr_sectors, barrier, err;
+        int el_ret, nr_sectors, barrier, discard, err;
         const unsigned short prio = bio_prio(bio);
         const int sync = bio_sync(bio);
         int rw_flags;
@@ -1115,6 +1119,12 @@ static int __make_request(struct request_queue *q, struct bio *bio)
                 goto end_io;
         }
 
+        discard = bio_discard(bio);
+        if (unlikely(discard) && !q->prepare_discard_fn) {
+                err = -EOPNOTSUPP;
+                goto end_io;
+        }
+
         spin_lock_irq(q->queue_lock);
 
         if (unlikely(barrier) || elv_queue_empty(q))
@@ -1405,7 +1415,8 @@ end_io:
 
                 if (bio_check_eod(bio, nr_sectors))
                         goto end_io;
-                if (bio_empty_barrier(bio) && !q->prepare_flush_fn) {
+                if ((bio_empty_barrier(bio) && !q->prepare_flush_fn) ||
+                    (bio_discard(bio) && !q->prepare_discard_fn)) {
                         err = -EOPNOTSUPP;
                         goto end_io;
                 }
@@ -1487,7 +1498,6 @@ void submit_bio(int rw, struct bio *bio)
          * go through the normal accounting stuff before submission.
          */
         if (bio_has_data(bio)) {
-
                 if (rw & WRITE) {
                         count_vm_events(PGPGOUT, count);
                 } else {
@@ -1881,7 +1891,7 @@ static int blk_end_io(struct request *rq, int error, unsigned int nr_bytes,
         struct request_queue *q = rq->q;
         unsigned long flags = 0UL;
 
-        if (bio_has_data(rq->bio)) {
+        if (bio_has_data(rq->bio) || blk_discard_rq(rq)) {
                 if (__end_that_request_first(rq, error, nr_bytes))
                         return 1;
 
@@ -1939,7 +1949,7 @@ EXPORT_SYMBOL_GPL(blk_end_request);
  **/
 int __blk_end_request(struct request *rq, int error, unsigned int nr_bytes)
 {
-        if (bio_has_data(rq->bio) &&
+        if ((bio_has_data(rq->bio) || blk_discard_rq(rq)) &&
             __end_that_request_first(rq, error, nr_bytes))
                 return 1;
 
@@ -2012,12 +2022,14 @@ void blk_rq_bio_prep(struct request_queue *q, struct request *rq,
            we want BIO_RW_AHEAD (bit 1) to imply REQ_FAILFAST (bit 1). */
         rq->cmd_flags |= (bio->bi_rw & 3);
 
-        rq->nr_phys_segments = bio_phys_segments(q, bio);
-        rq->nr_hw_segments = bio_hw_segments(q, bio);
+        if (bio_has_data(bio)) {
+                rq->nr_phys_segments = bio_phys_segments(q, bio);
+                rq->nr_hw_segments = bio_hw_segments(q, bio);
+                rq->buffer = bio_data(bio);
+        }
         rq->current_nr_sectors = bio_cur_sectors(bio);
         rq->hard_cur_sectors = rq->current_nr_sectors;
         rq->hard_nr_sectors = rq->nr_sectors = bio_sectors(bio);
-        rq->buffer = bio_data(bio);
         rq->data_len = bio->bi_size;
 
         rq->bio = rq->biotail = bio;
diff --git a/block/blk-settings.c b/block/blk-settings.c
index dfc77012843f..539d873c820d 100644
--- a/block/blk-settings.c
+++ b/block/blk-settings.c
@@ -33,6 +33,23 @@ void blk_queue_prep_rq(struct request_queue *q, prep_rq_fn *pfn)
 EXPORT_SYMBOL(blk_queue_prep_rq);
 
 /**
+ * blk_queue_set_discard - set a discard_sectors function for queue
+ * @q:          queue
+ * @dfn:        prepare_discard function
+ *
+ * It's possible for a queue to register a discard callback which is used
+ * to transform a discard request into the appropriate type for the
+ * hardware. If none is registered, then discard requests are failed
+ * with %EOPNOTSUPP.
+ *
+ */
+void blk_queue_set_discard(struct request_queue *q, prepare_discard_fn *dfn)
+{
+        q->prepare_discard_fn = dfn;
+}
+EXPORT_SYMBOL(blk_queue_set_discard);
+
+/**
  * blk_queue_merge_bvec - set a merge_bvec function for queue
  * @q:          queue
  * @mbfn:       merge_bvec_fn