block: remove the discard_zeroes_data flag

Now that we use the proper REQ_OP_WRITE_ZEROES operation everywhere we can
kill this hack.

Signed-off-by: Christoph Hellwig <hch@lst.de>
Reviewed-by: Martin K. Petersen <martin.petersen@oracle.com>
Reviewed-by: Hannes Reinecke <hare@suse.com>
Signed-off-by: Jens Axboe <axboe@fb.com>

diff --git a/Documentation/ABI/testing/sysfs-block b/Documentation/ABI/testing/sysfs-block
index 2da04ce6aeef482645bfd9edd924ce195275ea26..dea212db9df3531f3dfc69204c8e4fcac8ec2bb5 100644 (file)
--- a/Documentation/ABI/testing/sysfs-block
+++ b/Documentation/ABI/testing/sysfs-block
@@ -213,14 +213,8 @@ What:              /sys/block/<disk>/queue/discard_zeroes_data
 Date:          May 2011
 Contact:       Martin K. Petersen <martin.petersen@oracle.com>
 Description:
-               Devices that support discard functionality may return
-               stale or random data when a previously discarded block
-               is read back. This can cause problems if the filesystem
-               expects discarded blocks to be explicitly cleared. If a
-               device reports that it deterministically returns zeroes
-               when a discarded area is read the discard_zeroes_data
-               parameter will be set to one. Otherwise it will be 0 and
-               the result of reading a discarded area is undefined.
+               Will always return 0.  Don't rely on any specific behavior
+               for discards, and don't read this file.
 
 What:          /sys/block/<disk>/queue/write_same_max_bytes
 Date:          January 2012

diff --git a/Documentation/block/queue-sysfs.txt b/Documentation/block/queue-sysfs.txt
index b7f6bdc96d73c90d84a6380cc357399007301dd0..2c1e67058fd3bdf02336a71dc34ec885b9b84c2d 100644 (file)
--- a/Documentation/block/queue-sysfs.txt
+++ b/Documentation/block/queue-sysfs.txt
@@ -43,11 +43,6 @@ large discards are issued, setting this value lower will make Linux issue
 smaller discards and potentially help reduce latencies induced by large
 discard operations.
 
-discard_zeroes_data (RO)
-------------------------
-When read, this file will show if the discarded block are zeroed by the
-device or not. If its value is '1' the blocks are zeroed otherwise not.
-
 hw_sector_size (RO)
 -------------------
 This is the hardware sector size of the device, in bytes.

diff --git a/block/blk-lib.c b/block/blk-lib.c
index b0c6c4bcf44181c294aa8e2ce61320287fafd230..e8caecd71688e00a4974b5d45b95bc53e4eaeac5 100644 (file)
--- a/block/blk-lib.c
+++ b/block/blk-lib.c
@@ -37,17 +37,12 @@ int __blkdev_issue_discard(struct block_device *bdev, sector_t sector,
                return -ENXIO;
 
        if (flags & BLKDEV_DISCARD_SECURE) {
-               if (flags & BLKDEV_DISCARD_ZERO)
-                       return -EOPNOTSUPP;
                if (!blk_queue_secure_erase(q))
                        return -EOPNOTSUPP;
                op = REQ_OP_SECURE_ERASE;
        } else {
                if (!blk_queue_discard(q))
                        return -EOPNOTSUPP;
-               if ((flags & BLKDEV_DISCARD_ZERO) &&
-                   !q->limits.discard_zeroes_data)
-                       return -EOPNOTSUPP;
                op = REQ_OP_DISCARD;
        }
 
@@ -126,7 +121,7 @@ int blkdev_issue_discard(struct block_device *bdev, sector_t sector,
                        &bio);
        if (!ret && bio) {
                ret = submit_bio_wait(bio);
-               if (ret == -EOPNOTSUPP && !(flags & BLKDEV_DISCARD_ZERO))
+               if (ret == -EOPNOTSUPP)
                        ret = 0;
                bio_put(bio);
        }

diff --git a/block/blk-settings.c b/block/blk-settings.c
index 1e7174ffc9d49d0757cf7cb7da1ffe822f7fbbd6..4fa81ed383cab4ec1f543fa33e0536cbac8d7540 100644 (file)
--- a/block/blk-settings.c
+++ b/block/blk-settings.c
@@ -103,7 +103,6 @@ void blk_set_default_limits(struct queue_limits *lim)
        lim->discard_granularity = 0;
        lim->discard_alignment = 0;
        lim->discard_misaligned = 0;
-       lim->discard_zeroes_data = 0;
        lim->logical_block_size = lim->physical_block_size = lim->io_min = 512;
        lim->bounce_pfn = (unsigned long)(BLK_BOUNCE_ANY >> PAGE_SHIFT);
        lim->alignment_offset = 0;
@@ -127,7 +126,6 @@ void blk_set_stacking_limits(struct queue_limits *lim)
        blk_set_default_limits(lim);
 
        /* Inherit limits from component devices */
-       lim->discard_zeroes_data = 1;
        lim->max_segments = USHRT_MAX;
        lim->max_discard_segments = 1;
        lim->max_hw_sectors = UINT_MAX;
@@ -609,7 +607,6 @@ int blk_stack_limits(struct queue_limits *t, struct queue_limits *b,
        t->io_opt = lcm_not_zero(t->io_opt, b->io_opt);
 
        t->cluster &= b->cluster;
-       t->discard_zeroes_data &= b->discard_zeroes_data;
 
        /* Physical block size a multiple of the logical block size? */
        if (t->physical_block_size & (t->logical_block_size - 1)) {

diff --git a/block/blk-sysfs.c b/block/blk-sysfs.c
index c47db43a40cc95c0c86f283eb153c517c242dd5d..fc20489f0d2b49528fcc2dad9366a8b0ae3ab829 100644 (file)
--- a/block/blk-sysfs.c
+++ b/block/blk-sysfs.c
@@ -208,7 +208,7 @@ static ssize_t queue_discard_max_store(struct request_queue *q,
 
 static ssize_t queue_discard_zeroes_data_show(struct request_queue *q, char *page)
 {
-       return queue_var_show(queue_discard_zeroes_data(q), page);
+       return queue_var_show(0, page);
 }
 
 static ssize_t queue_write_same_max_show(struct request_queue *q, char *page)

diff --git a/block/compat_ioctl.c b/block/compat_ioctl.c
index 570021a0dc1ca5b903c990c1ae26d5913e71cd47..04325b81c2b410ed560b43af82a4a906e040f16d 100644 (file)
--- a/block/compat_ioctl.c
+++ b/block/compat_ioctl.c
@@ -685,7 +685,7 @@ long compat_blkdev_ioctl(struct file *file, unsigned cmd, unsigned long arg)
        case BLKALIGNOFF:
                return compat_put_int(arg, bdev_alignment_offset(bdev));
        case BLKDISCARDZEROES:
-               return compat_put_uint(arg, bdev_discard_zeroes_data(bdev));
+               return compat_put_uint(arg, 0);
        case BLKFLSBUF:
        case BLKROSET:
        case BLKDISCARD:

diff --git a/block/ioctl.c b/block/ioctl.c
index 8ea00a41be01da6b6a15149ec7dcd36c589c346a..0de02ee67eed89282a7651605d622db4206cf5fa 100644 (file)
--- a/block/ioctl.c
+++ b/block/ioctl.c
@@ -547,7 +547,7 @@ int blkdev_ioctl(struct block_device *bdev, fmode_t mode, unsigned cmd,
        case BLKALIGNOFF:
                return put_int(arg, bdev_alignment_offset(bdev));
        case BLKDISCARDZEROES:
-               return put_uint(arg, bdev_discard_zeroes_data(bdev));
+               return put_uint(arg, 0);
        case BLKSECTGET:
                max_sectors = min_t(unsigned int, USHRT_MAX,
                                    queue_max_sectors(bdev_get_queue(bdev)));

diff --git a/drivers/block/drbd/drbd_main.c b/drivers/block/drbd/drbd_main.c
index 8e62d9f6551082445815a9b60e05e705996dc57f..84455c365f578892e5ba2f7d0da714b974959ce6 100644 (file)
--- a/drivers/block/drbd/drbd_main.c
+++ b/drivers/block/drbd/drbd_main.c
@@ -931,7 +931,6 @@ void assign_p_sizes_qlim(struct drbd_device *device, struct p_sizes *p, struct r
                p->qlim->io_min = cpu_to_be32(queue_io_min(q));
                p->qlim->io_opt = cpu_to_be32(queue_io_opt(q));
                p->qlim->discard_enabled = blk_queue_discard(q);
-               p->qlim->discard_zeroes_data = queue_discard_zeroes_data(q);
                p->qlim->write_same_capable = !!q->limits.max_write_same_sectors;
        } else {
                q = device->rq_queue;
@@ -941,7 +940,6 @@ void assign_p_sizes_qlim(struct drbd_device *device, struct p_sizes *p, struct r
                p->qlim->io_min = cpu_to_be32(queue_io_min(q));
                p->qlim->io_opt = cpu_to_be32(queue_io_opt(q));
                p->qlim->discard_enabled = 0;
-               p->qlim->discard_zeroes_data = 0;
                p->qlim->write_same_capable = 0;
        }
 }

diff --git a/drivers/block/drbd/drbd_nl.c b/drivers/block/drbd/drbd_nl.c
index e4516d3b971d0cc5b3d5b7b0bc62d26b2966c2ea..02255a0d68b9ac9dde77887c030fb0fededbf7e2 100644 (file)
--- a/drivers/block/drbd/drbd_nl.c
+++ b/drivers/block/drbd/drbd_nl.c
@@ -1199,10 +1199,6 @@ static void decide_on_discard_support(struct drbd_device *device,
        struct drbd_connection *connection = first_peer_device(device)->connection;
        bool can_do = b ? blk_queue_discard(b) : true;
 
-       if (can_do && b && !b->limits.discard_zeroes_data && !discard_zeroes_if_aligned) {
-               can_do = false;
-               drbd_info(device, "discard_zeroes_data=0 and discard_zeroes_if_aligned=no: disabling discards\n");
-       }
        if (can_do && connection->cstate >= C_CONNECTED && !(connection->agreed_features & DRBD_FF_TRIM)) {
                can_do = false;
                drbd_info(connection, "peer DRBD too old, does not support TRIM: disabling discards\n");
@@ -1484,8 +1480,7 @@ static void sanitize_disk_conf(struct drbd_device *device, struct disk_conf *dis
        if (disk_conf->al_extents > drbd_al_extents_max(nbc))
                disk_conf->al_extents = drbd_al_extents_max(nbc);
 
-       if (!blk_queue_discard(q)
-           || (!q->limits.discard_zeroes_data && !disk_conf->discard_zeroes_if_aligned)) {
+       if (!blk_queue_discard(q)) {
                if (disk_conf->rs_discard_granularity) {
                        disk_conf->rs_discard_granularity = 0; /* disable feature */
                        drbd_info(device, "rs_discard_granularity feature disabled\n");

diff --git a/drivers/block/loop.c b/drivers/block/loop.c
index 3bb04c1a4ba16d3acc612ae4547485df75e6b864..3081d83d2ea3a4a03555b8c2225c607b66aaa90f 100644 (file)
--- a/drivers/block/loop.c
+++ b/drivers/block/loop.c
@@ -828,7 +828,6 @@ static void loop_config_discard(struct loop_device *lo)
                q->limits.discard_alignment = 0;
                blk_queue_max_discard_sectors(q, 0);
                blk_queue_max_write_zeroes_sectors(q, 0);
-               q->limits.discard_zeroes_data = 0;
                queue_flag_clear_unlocked(QUEUE_FLAG_DISCARD, q);
                return;
        }
@@ -837,7 +836,6 @@ static void loop_config_discard(struct loop_device *lo)
        q->limits.discard_alignment = 0;
        blk_queue_max_discard_sectors(q, UINT_MAX >> 9);
        blk_queue_max_write_zeroes_sectors(q, UINT_MAX >> 9);
-       q->limits.discard_zeroes_data = 1;
        queue_flag_set_unlocked(QUEUE_FLAG_DISCARD, q);
 }
 

diff --git a/drivers/block/mtip32xx/mtip32xx.c b/drivers/block/mtip32xx/mtip32xx.c
index 30076e7753bc70bfe7c2a0f8d0381958fa94ab39..05e3e664ea1b877c8af9fd5b9177d5dcf957f070 100644 (file)
--- a/drivers/block/mtip32xx/mtip32xx.c
+++ b/drivers/block/mtip32xx/mtip32xx.c
@@ -4025,7 +4025,6 @@ skip_create_disk:
                dd->queue->limits.discard_granularity = 4096;
                blk_queue_max_discard_sectors(dd->queue,
                        MTIP_MAX_TRIM_ENTRY_LEN * MTIP_MAX_TRIM_ENTRIES);
-               dd->queue->limits.discard_zeroes_data = 0;
        }
 
        /* Set the capacity of the device in 512 byte sectors. */

diff --git a/drivers/block/nbd.c b/drivers/block/nbd.c
index 03ae72985c79eb1fadef479ce3ea0c9185314060..b02f2362fdf7878deb1b6aa031301f0e24a06581 100644 (file)
--- a/drivers/block/nbd.c
+++ b/drivers/block/nbd.c
@@ -1110,7 +1110,6 @@ static int nbd_dev_add(int index)
        queue_flag_clear_unlocked(QUEUE_FLAG_ADD_RANDOM, disk->queue);
        disk->queue->limits.discard_granularity = 512;
        blk_queue_max_discard_sectors(disk->queue, UINT_MAX);
-       disk->queue->limits.discard_zeroes_data = 0;
        blk_queue_max_hw_sectors(disk->queue, 65536);
        disk->queue->limits.max_sectors = 256;
 

diff --git a/drivers/md/dm-cache-target.c b/drivers/md/dm-cache-target.c
index 9c689b34e6e792105d64f2bb4835e11e37c91578..975922c8f23143c4fcf586714015343f9ed0b41d 100644 (file)
--- a/drivers/md/dm-cache-target.c
+++ b/drivers/md/dm-cache-target.c
@@ -2773,7 +2773,6 @@ static int cache_create(struct cache_args *ca, struct cache **result)
 
        ti->num_discard_bios = 1;
        ti->discards_supported = true;
-       ti->discard_zeroes_data_unsupported = true;
        ti->split_discard_bios = false;
 
        cache->features = ca->features;

diff --git a/drivers/md/dm-crypt.c b/drivers/md/dm-crypt.c
index 389a3637ffcc637c9a4540cec4db3b65a5cf773f..ef1d836bd81b61ec8f79a1e305685f272c776580 100644 (file)
--- a/drivers/md/dm-crypt.c
+++ b/drivers/md/dm-crypt.c
@@ -2030,7 +2030,6 @@ static int crypt_ctr(struct dm_target *ti, unsigned int argc, char **argv)
        wake_up_process(cc->write_thread);
 
        ti->num_flush_bios = 1;
-       ti->discard_zeroes_data_unsupported = true;
 
        return 0;
 

diff --git a/drivers/md/dm-raid.c b/drivers/md/dm-raid.c
index f8564d63982f43f9e3fb453fc9adedf3f14be51a..468f1380de1d352ab6ea4fff66e65402dccdaf15 100644 (file)
--- a/drivers/md/dm-raid.c
+++ b/drivers/md/dm-raid.c
@@ -2813,7 +2813,9 @@ static void configure_discard_support(struct raid_set *rs)
        /* Assume discards not supported until after checks below. */
        ti->discards_supported = false;
 
-       /* RAID level 4,5,6 require discard_zeroes_data for data integrity! */
+       /*
+        * XXX: RAID level 4,5,6 require zeroing for safety.
+        */
        raid456 = (rs->md.level == 4 || rs->md.level == 5 || rs->md.level == 6);
 
        for (i = 0; i < rs->raid_disks; i++) {
@@ -2827,8 +2829,6 @@ static void configure_discard_support(struct raid_set *rs)
                        return;
 
                if (raid456) {
-                       if (!q->limits.discard_zeroes_data)
-                               return;
                        if (!devices_handle_discard_safely) {
                                DMERR("raid456 discard support disabled due to discard_zeroes_data uncertainty.");
                                DMERR("Set dm-raid.devices_handle_discard_safely=Y to override.");

diff --git a/drivers/md/dm-raid1.c b/drivers/md/dm-raid1.c
index 2ddc2d20e62d17c603900959d40f541bf5eec076..a95cbb80fb34444144bad346b3e769c625e8c788 100644 (file)
--- a/drivers/md/dm-raid1.c
+++ b/drivers/md/dm-raid1.c
@@ -1124,7 +1124,6 @@ static int mirror_ctr(struct dm_target *ti, unsigned int argc, char **argv)
        ti->num_flush_bios = 1;
        ti->num_discard_bios = 1;
        ti->per_io_data_size = sizeof(struct dm_raid1_bio_record);
-       ti->discard_zeroes_data_unsupported = true;
 
        ms->kmirrord_wq = alloc_workqueue("kmirrord", WQ_MEM_RECLAIM, 0);
        if (!ms->kmirrord_wq) {

diff --git a/drivers/md/dm-table.c b/drivers/md/dm-table.c
index 5cd665c91ead89f3fd82176cae0d94f425973325..958275aca008454a460b0fbe22f543bad2f4172a 100644 (file)
--- a/drivers/md/dm-table.c
+++ b/drivers/md/dm-table.c
@@ -1449,22 +1449,6 @@ static bool dm_table_supports_flush(struct dm_table *t, unsigned long flush)
        return false;
 }
 
-static bool dm_table_discard_zeroes_data(struct dm_table *t)
-{
-       struct dm_target *ti;
-       unsigned i = 0;
-
-       /* Ensure that all targets supports discard_zeroes_data. */
-       while (i < dm_table_get_num_targets(t)) {
-               ti = dm_table_get_target(t, i++);
-
-               if (ti->discard_zeroes_data_unsupported)
-                       return false;
-       }
-
-       return true;
-}
-
 static int device_is_nonrot(struct dm_target *ti, struct dm_dev *dev,
                            sector_t start, sector_t len, void *data)
 {
@@ -1620,9 +1604,6 @@ void dm_table_set_restrictions(struct dm_table *t, struct request_queue *q,
        }
        blk_queue_write_cache(q, wc, fua);
 
-       if (!dm_table_discard_zeroes_data(t))
-               q->limits.discard_zeroes_data = 0;
-
        /* Ensure that all underlying devices are non-rotational. */
        if (dm_table_all_devices_attribute(t, device_is_nonrot))
                queue_flag_set_unlocked(QUEUE_FLAG_NONROT, q);

diff --git a/drivers/md/dm-thin.c b/drivers/md/dm-thin.c
index 2b266a2b5035b9fa699eb1afdf4c5dc53da54c66..a5f1916f621a9972449dbbfa2408397484a5d7f3 100644 (file)
--- a/drivers/md/dm-thin.c
+++ b/drivers/md/dm-thin.c
@@ -3263,7 +3263,6 @@ static int pool_ctr(struct dm_target *ti, unsigned argc, char **argv)
         * them down to the data device.  The thin device's discard
         * processing will cause mappings to be removed from the btree.
         */
-       ti->discard_zeroes_data_unsupported = true;
        if (pf.discard_enabled && pf.discard_passdown) {
                ti->num_discard_bios = 1;
 
@@ -4119,7 +4118,6 @@ static int thin_ctr(struct dm_target *ti, unsigned argc, char **argv)
        ti->per_io_data_size = sizeof(struct dm_thin_endio_hook);
 
        /* In case the pool supports discards, pass them on. */
-       ti->discard_zeroes_data_unsupported = true;
        if (tc->pool->pf.discard_enabled) {
                ti->discards_supported = true;
                ti->num_discard_bios = 1;

diff --git a/drivers/md/raid5.c b/drivers/md/raid5.c
index 1725a54042bb26f92bb0355c664a3ce2a9c1aff7..2efdb0d6746074a0416f18b0c0dfbab7cc5be6a8 100644 (file)
--- a/drivers/md/raid5.c
+++ b/drivers/md/raid5.c
@@ -7227,7 +7227,6 @@ static int raid5_run(struct mddev *mddev)
 
        if (mddev->queue) {
                int chunk_size;
-               bool discard_supported = true;
                /* read-ahead size must cover two whole stripes, which
                 * is 2 * (datadisks) * chunksize where 'n' is the
                 * number of raid devices
@@ -7263,12 +7262,6 @@ static int raid5_run(struct mddev *mddev)
                blk_queue_max_discard_sectors(mddev->queue,
                                              0xfffe * STRIPE_SECTORS);
 
-               /*
-                * unaligned part of discard request will be ignored, so can't
-                * guarantee discard_zeroes_data
-                */
-               mddev->queue->limits.discard_zeroes_data = 0;
-
                blk_queue_max_write_same_sectors(mddev->queue, 0);
                blk_queue_max_write_zeroes_sectors(mddev->queue, 0);
 
@@ -7277,35 +7270,24 @@ static int raid5_run(struct mddev *mddev)
                                          rdev->data_offset << 9);
                        disk_stack_limits(mddev->gendisk, rdev->bdev,
                                          rdev->new_data_offset << 9);
-                       /*
-                        * discard_zeroes_data is required, otherwise data
-                        * could be lost. Consider a scenario: discard a stripe
-                        * (the stripe could be inconsistent if
-                        * discard_zeroes_data is 0); write one disk of the
-                        * stripe (the stripe could be inconsistent again
-                        * depending on which disks are used to calculate
-                        * parity); the disk is broken; The stripe data of this
-                        * disk is lost.
-                        */
-                       if (!blk_queue_discard(bdev_get_queue(rdev->bdev)) ||
-                           !bdev_get_queue(rdev->bdev)->
-                                               limits.discard_zeroes_data)
-                               discard_supported = false;
-                       /* Unfortunately, discard_zeroes_data is not currently
-                        * a guarantee - just a hint.  So we only allow DISCARD
-                        * if the sysadmin has confirmed that only safe devices
-                        * are in use by setting a module parameter.
-                        */
-                       if (!devices_handle_discard_safely) {
-                               if (discard_supported) {
-                                       pr_info("md/raid456: discard support disabled due to uncertainty.\n");
-                                       pr_info("Set raid456.devices_handle_discard_safely=Y to override.\n");
-                               }
-                               discard_supported = false;
-                       }
                }
 
-               if (discard_supported &&
+               /*
+                * zeroing is required, otherwise data
+                * could be lost. Consider a scenario: discard a stripe
+                * (the stripe could be inconsistent if
+                * discard_zeroes_data is 0); write one disk of the
+                * stripe (the stripe could be inconsistent again
+                * depending on which disks are used to calculate
+                * parity); the disk is broken; The stripe data of this
+                * disk is lost.
+                *
+                * We only allow DISCARD if the sysadmin has confirmed that
+                * only safe devices are in use by setting a module parameter.
+                * A better idea might be to turn DISCARD into WRITE_ZEROES
+                * requests, as that is required to be safe.
+                */
+               if (devices_handle_discard_safely &&
                    mddev->queue->limits.max_discard_sectors >= (stripe >> 9) &&
                    mddev->queue->limits.discard_granularity >= stripe)
                        queue_flag_set_unlocked(QUEUE_FLAG_DISCARD,

diff --git a/drivers/scsi/sd.c b/drivers/scsi/sd.c
index 001593ed04449fb83d1d280649d723be55af3ac7..bcb0cb020fd2e358482c7f97eb3b569f10760785 100644 (file)
--- a/drivers/scsi/sd.c
+++ b/drivers/scsi/sd.c
@@ -644,8 +644,6 @@ static void sd_config_discard(struct scsi_disk *sdkp, unsigned int mode)
        unsigned int logical_block_size = sdkp->device->sector_size;
        unsigned int max_blocks = 0;
 
-       q->limits.discard_zeroes_data = 0;
-
        /*
         * When LBPRZ is reported, discard alignment and granularity
         * must be fixed to the logical block size. Otherwise the block
@@ -681,19 +679,16 @@ static void sd_config_discard(struct scsi_disk *sdkp, unsigned int mode)
        case SD_LBP_WS16:
                max_blocks = min_not_zero(sdkp->max_ws_blocks,
                                          (u32)SD_MAX_WS16_BLOCKS);
-               q->limits.discard_zeroes_data = sdkp->lbprz;
                break;
 
        case SD_LBP_WS10:
                max_blocks = min_not_zero(sdkp->max_ws_blocks,
                                          (u32)SD_MAX_WS10_BLOCKS);
-               q->limits.discard_zeroes_data = sdkp->lbprz;
                break;
 
        case SD_LBP_ZERO:
                max_blocks = min_not_zero(sdkp->max_ws_blocks,
                                          (u32)SD_MAX_WS10_BLOCKS);
-               q->limits.discard_zeroes_data = 1;
                break;
        }
 

diff --git a/drivers/target/target_core_device.c b/drivers/target/target_core_device.c
index c754ae33bf7b154a5ce368c066ad336f2c4ee5d5..d2f089cfa9aedcd63f204aa898d775c16330d150 100644 (file)
--- a/drivers/target/target_core_device.c
+++ b/drivers/target/target_core_device.c
@@ -851,7 +851,7 @@ bool target_configure_unmap_from_queue(struct se_dev_attrib *attrib,
        attrib->unmap_granularity = q->limits.discard_granularity / block_size;
        attrib->unmap_granularity_alignment = q->limits.discard_alignment /
                                                                block_size;
-       attrib->unmap_zeroes_data = q->limits.discard_zeroes_data;
+       attrib->unmap_zeroes_data = 0;
        return true;
 }
 EXPORT_SYMBOL(target_configure_unmap_from_queue);

diff --git a/include/linux/blkdev.h b/include/linux/blkdev.h
index 21a30f011674625b2f91e136c665024bc0990388..ec993573e0a80650eedc70a9b31fac9a437fc8f1 100644 (file)
--- a/include/linux/blkdev.h
+++ b/include/linux/blkdev.h
@@ -339,7 +339,6 @@ struct queue_limits {
        unsigned char           misaligned;
        unsigned char           discard_misaligned;
        unsigned char           cluster;
-       unsigned char           discard_zeroes_data;
        unsigned char           raid_partial_stripes_expensive;
        enum blk_zoned_model    zoned;
 };
@@ -1341,7 +1340,6 @@ extern int blkdev_issue_write_same(struct block_device *bdev, sector_t sector,
                sector_t nr_sects, gfp_t gfp_mask, struct page *page);
 
 #define BLKDEV_DISCARD_SECURE  (1 << 0)        /* issue a secure erase */
-#define BLKDEV_DISCARD_ZERO    (1 << 1)        /* must reliably zero data */
 
 extern int blkdev_issue_discard(struct block_device *bdev, sector_t sector,
                sector_t nr_sects, gfp_t gfp_mask, unsigned long flags);
@@ -1541,19 +1539,6 @@ static inline int bdev_discard_alignment(struct block_device *bdev)
        return q->limits.discard_alignment;
 }
 
-static inline unsigned int queue_discard_zeroes_data(struct request_queue *q)
-{
-       if (q->limits.max_discard_sectors && q->limits.discard_zeroes_data == 1)
-               return 1;
-
-       return 0;
-}
-
-static inline unsigned int bdev_discard_zeroes_data(struct block_device *bdev)
-{
-       return queue_discard_zeroes_data(bdev_get_queue(bdev));
-}
-
 static inline unsigned int bdev_write_same(struct block_device *bdev)
 {
        struct request_queue *q = bdev_get_queue(bdev);

diff --git a/include/linux/device-mapper.h b/include/linux/device-mapper.h
index 3829bee2302a47f3f7772ff377c51e981eb6dfa5..c7ea33e38fb9e705baf2921f6cefe167574f9483 100644 (file)
--- a/include/linux/device-mapper.h
+++ b/include/linux/device-mapper.h
@@ -296,11 +296,6 @@ struct dm_target {
         * on max_io_len boundary.
         */
        bool split_discard_bios:1;
-
-       /*
-        * Set if this target does not return zeroes on discarded blocks.
-        */
-       bool discard_zeroes_data_unsupported:1;
 };
 
 /* Each target can link one of these into the table */