use block_device based APIs in block layer consumers v3
Subsystems (39)
Christoph Hellwig
maintainerHi Jens,
this series cleanups up the block layer API so that APIs consumed by file systems are (almost) only struct block_devic based, so that file systems don't have to poke into block layer internals like the request_queue.
I also found a bunch of existing bugs related to partition offsets and discard so these are fixed while going along.
Changes since v2:
- fix an inverted check in btrfs
- set max_discard_sectors to 0 in all places where the flag was previously cleared
- fix a few sligtly incorrect collected Acks
Changes since v1:
- fix a bisection hazard
- minor spelling fixes
- reorder hunks between two patches to make the changes more obvious
- reorder a patch to be earlier in the series to ease backporting
Diffstat:
arch/um/drivers/ubd_kern.c | 2 block/blk-core.c | 4 - block/blk-lib.c | 124 ++++++++++++++++++++--------------- block/blk-mq-debugfs.c | 2 block/blk-settings.c | 74 ++++++++++++++++++++ block/blk.h | 14 --- block/fops.c | 2 block/genhd.c | 4 - block/ioctl.c | 48 ++++++++++--- block/partitions/core.c | 12 --- drivers/block/drbd/drbd_main.c | 51 ++++++-------- drivers/block/drbd/drbd_nl.c | 94 +++++++++++--------------- drivers/block/drbd/drbd_receiver.c | 13 +-- drivers/block/loop.c | 15 +--- drivers/block/nbd.c | 5 - drivers/block/null_blk/main.c | 1 drivers/block/rbd.c | 1 drivers/block/rnbd/rnbd-clt.c | 6 - drivers/block/rnbd/rnbd-srv-dev.h | 8 -- drivers/block/rnbd/rnbd-srv.c | 5 - drivers/block/virtio_blk.c | 2 drivers/block/xen-blkback/blkback.c | 15 ++-- drivers/block/xen-blkback/xenbus.c | 9 -- drivers/block/xen-blkfront.c | 8 +- drivers/block/zram/zram_drv.c | 1 drivers/md/bcache/alloc.c | 2 drivers/md/bcache/request.c | 4 - drivers/md/bcache/super.c | 3 drivers/md/bcache/sysfs.c | 2 drivers/md/dm-cache-target.c | 9 -- drivers/md/dm-clone-target.c | 9 -- drivers/md/dm-io.c | 2 drivers/md/dm-log-writes.c | 3 drivers/md/dm-raid.c | 9 -- drivers/md/dm-table.c | 25 +------ drivers/md/dm-thin.c | 15 ---- drivers/md/dm.c | 3 drivers/md/md-linear.c | 11 --- drivers/md/md.c | 5 - drivers/md/raid0.c | 7 - drivers/md/raid1.c | 18 ----- drivers/md/raid10.c | 20 ----- drivers/md/raid5-cache.c | 8 +- drivers/md/raid5.c | 14 +-- drivers/mmc/core/queue.c | 3 drivers/mtd/mtd_blkdevs.c | 1 drivers/nvme/host/core.c | 4 - drivers/nvme/target/io-cmd-bdev.c | 2 drivers/nvme/target/zns.c | 3 drivers/s390/block/dasd_fba.c | 1 drivers/scsi/sd.c | 2 drivers/target/target_core_device.c | 20 ++--- drivers/target/target_core_file.c | 10 +- drivers/target/target_core_iblock.c | 17 +--- fs/btrfs/disk-io.c | 3 fs/btrfs/extent-tree.c | 8 +- fs/btrfs/ioctl.c | 12 +-- fs/btrfs/volumes.c | 4 - fs/btrfs/zoned.c | 3 fs/direct-io.c | 32 +-------- fs/exfat/file.c | 5 - fs/exfat/super.c | 10 -- fs/ext4/ioctl.c | 10 -- fs/ext4/mballoc.c | 10 +- fs/ext4/super.c | 10 -- fs/f2fs/f2fs.h | 3 fs/f2fs/file.c | 19 ++--- fs/f2fs/segment.c | 8 -- fs/fat/file.c | 5 - fs/fat/inode.c | 10 -- fs/gfs2/rgrp.c | 7 - fs/iomap/direct-io.c | 3 fs/jbd2/journal.c | 9 -- fs/jfs/ioctl.c | 5 - fs/jfs/super.c | 8 -- fs/nilfs2/ioctl.c | 6 - fs/nilfs2/sufile.c | 4 - fs/nilfs2/the_nilfs.c | 4 - fs/ntfs3/file.c | 6 - fs/ntfs3/super.c | 10 +- fs/ocfs2/ioctl.c | 5 - fs/super.c | 2 fs/xfs/xfs_discard.c | 8 +- fs/xfs/xfs_log_cil.c | 2 fs/xfs/xfs_super.c | 12 +-- fs/zonefs/super.c | 3 include/linux/blkdev.h | 112 +++++++++++-------------------- include/target/target_core_backend.h | 4 - mm/swapfile.c | 31 ++------ 89 files changed, 494 insertions(+), 651 deletions(-)
Christoph Hellwig
maintainerPATCH 1/27 target: remove an incorrect unmap zeroes data deduction
For block devices, the SCSI target drivers implements UNMAP as calls to blkdev_issue_discard, which does not guarantee zeroing just because Write Zeroes is supported.
Note that this does not affect the file backed path which uses fallocate to punch holes.
--- drivers/target/target_core_device.c | 1 - 1 file changed, 1 deletion(-)
drivers/target/target_core_device.c +0 -1
@@ -850,7 +850,6 @@ 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.max_write_zeroes_sectors);return true; }EXPORT_SYMBOL (target_configure_unmap_from_queue);
Signature · 1 line
2.30.2
Re: [PATCH 01/27] target: remove an incorrect unmap zeroes data deduction
Quoted 10 lines · Christoph Hellwig
For block devices, the SCSI target drivers implements UNMAP as calls to
blkdev_issue_discard, which does not guarantee zeroing just because Write Zeroes is supported.Note that this does not affect the file backed path which uses fallocate to punch holes.
Fixes 2237498f0b5c ("target/iblock: Convert WRITE_SAME to blkdev_issue_zeroout")Signed-off-by Christoph Hellwig <[email protected]>Reviewed-by Martin K. Petersen <[email protected]>
Not a good assumption to have for sure.
Looks good.
-ck
Christoph Hellwig
maintainerPATCH 2/27 target: pass a block_device to target_configure_unmap_from_queue
In reply to Christoph HellwigThe SCSI target drivers is a consumer of the block layer and shoul d generally work on struct block_device.
--- drivers/target/target_core_device.c | 5 +++-- drivers/target/target_core_file.c | 7 ++++--- drivers/target/target_core_iblock.c | 2 +- include/target/target_core_backend.h | 4 ++-- 4 files changed, 10 insertions(+), 8 deletions(-)
drivers/target/target_core_device.c +3 -2
@@ -834,9 +834,10 @@ struct se_device *target_alloc_device(struct se_hba *hba, const char *name)* in ATA and we need to set TPE=1 */ bool target_configure_unmap_from_queue (struct se_dev_attrib *attrib, -struct request_queue *q) +struct block_device *bdev) { -int block_size =queue_logical_block_size (q); +struct request_queue *q =bdev_get_queue (bdev); +int block_size =bdev_logical_block_size (bdev);if (!blk_queue_discard (q))return false;
drivers/target/target_core_file.c +4 -3
@@ -134,10 +134,11 @@ static int fd_configure_device(struct se_device *dev)*/ inode = file->f_mapping->host;if (S_ISBLK (inode->i_mode)) { -struct request_queue *q =bdev_get_queue (I_BDEV (inode)); +struct block_device *bdev =I_BDEV (inode); +struct request_queue *q =bdev_get_queue (bdev);unsigned long long dev_size; - fd_dev->fd_block_size =bdev_logical_block_size (I_BDEV (inode)); + fd_dev->fd_block_size =bdev_logical_block_size (bdev);/* * Determine the number of bytes from i_size_read() minus * one (1) logical sector from underlying struct block_device
@@ -150,7 +151,7 @@ static int fd_configure_device(struct se_device *dev) dev_size,div_u64 (dev_size, fd_dev->fd_block_size), fd_dev->fd_block_size); -if (target_configure_unmap_from_queue (&dev->dev_attrib, q)) +if (target_configure_unmap_from_queue (&dev->dev_attrib, bdev))pr_debug ("IFILE: BLOCK Discard support available," " disabled by default\n" );/*
drivers/target/target_core_iblock.c +1 -1
@@ -119,7 +119,7 @@ static int iblock_configure_device(struct se_device *dev) dev->dev_attrib.hw_max_sectors =queue_max_hw_sectors (q); dev->dev_attrib.hw_queue_depth = q->nr_requests; -if (target_configure_unmap_from_queue (&dev->dev_attrib, q)) +if (target_configure_unmap_from_queue (&dev->dev_attrib, bd))pr_debug ("IBLOCK: BLOCK Discard support available," " disabled by default\n" );
include/target/target_core_backend.h +2 -2
@@ -14,7 +14,7 @@#define TRANSPORT_FLAG_PASSTHROUGH_ALUA 0x2#define TRANSPORT_FLAG_PASSTHROUGH_PGR 0x4 -struct request_queue ; +struct block_device ;struct scatterlist ;struct target_backend_ops {
@@ -117,7 +117,7 @@ sense_reason_t passthrough_parse_cdb(struct se_cmd *cmd,bool target_sense_desc_format (struct se_device *dev);sector_t target_to_linux_sector (struct se_device *dev,sector_t lb);bool target_configure_unmap_from_queue (struct se_dev_attrib *attrib, -struct request_queue *q); +struct block_device *bdev);static inline bool target_dev_configured (struct se_device *se_dev) {
Signature · 1 line
2.30.2
Re: [PATCH 02/27] target: pass a block_device to target_configure_unmap_from_queue
Quoted 4 lines · Christoph Hellwig
The SCSI target drivers is a consumer of the block layer and shoul d generally work on struct
block_device.Quoted 1 line
Signed-off-by Christoph Hellwig <[email protected]>Reviewed-by Martin K. Petersen <[email protected]>
Except from split word in log "should", looks good.
-ck
Christoph Hellwig
maintainerPATCH 3/27 target: fix discard alignment on partitions
In reply to Christoph HellwigUse the proper bdev_discard_alignment helper that accounts for partition offsets.
--- drivers/target/target_core_device.c | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-)
drivers/target/target_core_device.c +2 -2
@@ -849,8 +849,8 @@ bool target_configure_unmap_from_queue(struct se_dev_attrib *attrib,*/ attrib->max_unmap_block_desc_count =1 ; attrib->unmap_granularity = q->limits.discard_granularity / block_size; - attrib->unmap_granularity_alignment = q->limits.discard_alignment / - block_size; + attrib->unmap_granularity_alignment = +bdev_discard_alignment (bdev) / block_size;return true; }EXPORT_SYMBOL (target_configure_unmap_from_queue);
Signature · 1 line
2.30.2
Re: [PATCH 03/27] target: fix discard alignment on partitions
Quoted 7 lines · Christoph Hellwig
Use the proper
bdev_discard_alignmenthelper that accounts for partition offsets.Fixes c66ac9db8d4a ("[SCSI] target: Add LIO target core v4.0.0-rc6")Signed-off-by Christoph Hellwig <[email protected]>Reviewed-by Martin K. Petersen <[email protected]>---
Helper does handle the case for of partition.
Looks good.
-ck
Christoph Hellwig
maintainerPATCH 4/27 drbd: remove assign_p_sizes_qlim
In reply to Christoph HellwigFold each branch into its only caller.
--- drivers/block/drbd/drbd_main.c | 47 +++++++++++++++------------------- 1 file changed, 20 insertions(+), 27 deletions(-)
drivers/block/drbd/drbd_main.c +20 -27
@@ -903,31 +903,6 @@ void drbd_gen_and_send_sync_uuid(struct drbd_peer_device *peer_device) } } -/* communicated if (agreed_features & DRBD_FF_WSAME) */ -static void -assign_p_sizes_qlim (struct drbd_device *device,struct p_sizes *p, -struct request_queue *q) -{ -if (q) { - p->qlim->physical_block_size =cpu_to_be32 (queue_physical_block_size (q)); - p->qlim->logical_block_size =cpu_to_be32 (queue_logical_block_size (q)); - p->qlim->alignment_offset =cpu_to_be32 (queue_alignment_offset (q)); - 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->write_same_capable =0 ; - }else { - q = device->rq_queue; - p->qlim->physical_block_size =cpu_to_be32 (queue_physical_block_size (q)); - p->qlim->logical_block_size =cpu_to_be32 (queue_logical_block_size (q)); - p->qlim->alignment_offset =0 ; - 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->write_same_capable =0 ; - } -} -int drbd_send_sizes (struct drbd_peer_device *peer_device,int trigger_reply,enum dds_flags flags) {struct drbd_device *device = peer_device->device;
@@ -957,14 +932,32 @@ int drbd_send_sizes(struct drbd_peer_device *peer_device, int trigger_reply, enu q_order_type =drbd_queue_order_type (device); max_bio_size =queue_max_hw_sectors (q) <<9 ; max_bio_size =min (max_bio_size,DRBD_MAX_BIO_SIZE ); -assign_p_sizes_qlim (device, p, q); + p->qlim->physical_block_size = +cpu_to_be32 (queue_physical_block_size (q)); + p->qlim->logical_block_size = +cpu_to_be32 (queue_logical_block_size (q)); + p->qlim->alignment_offset = +cpu_to_be32 (queue_alignment_offset (q)); + 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);put_ldev (device); }else { +struct request_queue *q = device->rq_queue; + + p->qlim->physical_block_size = +cpu_to_be32 (queue_physical_block_size (q)); + p->qlim->logical_block_size = +cpu_to_be32 (queue_logical_block_size (q)); + p->qlim->alignment_offset =0 ; + 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 ; + d_size =0 ; u_size =0 ; q_order_type =QUEUE_ORDERED_NONE ; max_bio_size =DRBD_MAX_BIO_SIZE ;/* ... multiple BIOs per peer_request */ -assign_p_sizes_qlim (device, p,NULL ); }if (peer_device->connection->agreed_pro_version <=94 )
Signature · 1 line
2.30.2
Christoph Hellwig
maintainerPATCH 5/27 drbd: use bdev based limit helpers in drbd_send_sizes
In reply to Christoph HellwigUse the bdev based limits helpers where they exist.
--- drivers/block/drbd/drbd_main.c | 12 +++++++----- 1 file changed, 7 insertions(+), 5 deletions(-)
drivers/block/drbd/drbd_main.c +7 -5
@@ -924,7 +924,9 @@ int drbd_send_sizes(struct drbd_peer_device *peer_device, int trigger_reply, enumemset (p,0 , packet_size);if (get_ldev_if_state (device,D_NEGOTIATING )) { -struct request_queue *q =bdev_get_queue (device->ldev->backing_bdev); +struct block_device *bdev = device->ldev->backing_bdev; +struct request_queue *q =bdev_get_queue (bdev); + d_size =drbd_get_max_capacity (device->ldev);rcu_read_lock (); u_size =rcu_dereference (device->ldev->disk_conf)->disk_size;
@@ -933,13 +935,13 @@ int drbd_send_sizes(struct drbd_peer_device *peer_device, int trigger_reply, enu max_bio_size =queue_max_hw_sectors (q) <<9 ; max_bio_size =min (max_bio_size,DRBD_MAX_BIO_SIZE ); p->qlim->physical_block_size = -cpu_to_be32 (queue_physical_block_size (q)); +cpu_to_be32 (bdev_physical_block_size (bdev)); p->qlim->logical_block_size = -cpu_to_be32 (queue_logical_block_size (q)); +cpu_to_be32 (bdev_logical_block_size (bdev)); p->qlim->alignment_offset =cpu_to_be32 (queue_alignment_offset (q)); - p->qlim->io_min =cpu_to_be32 (queue_io_min (q)); - p->qlim->io_opt =cpu_to_be32 (queue_io_opt (q)); + p->qlim->io_min =cpu_to_be32 (bdev_io_min (bdev)); + p->qlim->io_opt =cpu_to_be32 (bdev_io_opt (bdev)); p->qlim->discard_enabled =blk_queue_discard (q);put_ldev (device); }else {
Signature · 1 line
2.30.2
Christoph Hellwig
maintainerPATCH 6/27 drbd: use bdev_alignment_offset instead of queue_alignment_offset
In reply to Christoph HellwigThe bdev version does the right thing for partitions, so use that.
--- drivers/block/drbd/drbd_main.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-)
drivers/block/drbd/drbd_main.c +1 -1
@@ -939,7 +939,7 @@ int drbd_send_sizes(struct drbd_peer_device *peer_device, int trigger_reply, enu p->qlim->logical_block_size =cpu_to_be32 (bdev_logical_block_size (bdev)); p->qlim->alignment_offset = -cpu_to_be32 (queue_alignment_offset (q)); +cpu_to_be32 (bdev_alignment_offset (bdev)); p->qlim->io_min =cpu_to_be32 (bdev_io_min (bdev)); p->qlim->io_opt =cpu_to_be32 (bdev_io_opt (bdev)); p->qlim->discard_enabled =blk_queue_discard (q);
Signature · 1 line
2.30.2
Christoph Hellwig
maintainerPATCH 7/27 drbd: cleanup decide_on_discard_support
In reply to Christoph HellwigSanitize the calling conventions and use a goto label to cleanup the code flow.
--- drivers/block/drbd/drbd_nl.c | 68 +++++++++++++++++++----------------- 1 file changed, 35 insertions(+), 33 deletions(-)
drivers/block/drbd/drbd_nl.c +35 -33
@@ -1204,38 +1204,42 @@ static unsigned int drbd_max_discard_sectors(struct drbd_connection *connection) }static void decide_on_discard_support (struct drbd_device *device, -struct request_queue *q, -struct request_queue *b, -bool discard_zeroes_if_aligned) +struct drbd_backing_dev *bdev) { -/* q = drbd device queue (device->rq_queue) -* b = backing device queue (device->ldev->backing_bdev->bd_disk->queue), -* or NULL if diskless -*/ -struct drbd_connection *connection =first_peer_device (device)->connection; -bool can_do = b ?blk_queue_discard (b) : true; - -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" ); - } -if (can_do) { -/* We don't care for the granularity, really. -* Stacking limits below should fix it for the local -* device. Whether or not it is a suitable granularity -* on the remote device is not our problem, really. If -* you care, you need to use devices with similar -* topology on all peers. */ -blk_queue_discard_granularity (q,512 ); - q->limits.max_discard_sectors =drbd_max_discard_sectors (connection); -blk_queue_flag_set (QUEUE_FLAG_DISCARD , q); - q->limits.max_write_zeroes_sectors =drbd_max_discard_sectors (connection); - }else { -blk_queue_flag_clear (QUEUE_FLAG_DISCARD , q); -blk_queue_discard_granularity (q,0 ); - q->limits.max_discard_sectors =0 ; - q->limits.max_write_zeroes_sectors =0 ; +struct drbd_connection *connection = +first_peer_device (device)->connection; +struct request_queue *q = device->rq_queue; + +if (bdev && !blk_queue_discard (bdev->backing_bdev->bd_disk->queue)) + goto not_supported; + +if (connection->cstate >=C_CONNECTED && + !(connection->agreed_features &DRBD_FF_TRIM )) { +drbd_info (connection, +"peer DRBD too old, does not support TRIM: disabling discards\n" ); + goto not_supported; } + +/* +* We don't care for the granularity, really. +* +* Stacking limits below should fix it for the local device. Whether or +* not it is a suitable granularity on the remote device is not our +* problem, really. If you care, you need to use devices with similar +* topology on all peers. +*/ +blk_queue_discard_granularity (q,512 ); + q->limits.max_discard_sectors =drbd_max_discard_sectors (connection); +blk_queue_flag_set (QUEUE_FLAG_DISCARD , q); + q->limits.max_write_zeroes_sectors = +drbd_max_discard_sectors (connection); +return ; + +not_supported: +blk_queue_flag_clear (QUEUE_FLAG_DISCARD , q); +blk_queue_discard_granularity (q,0 ); + q->limits.max_discard_sectors =0 ; + q->limits.max_write_zeroes_sectors =0 ; }static void fixup_discard_if_not_supported (struct request_queue *q)
@@ -1273,7 +1277,6 @@ static void drbd_setup_queue_param(struct drbd_device *device, struct drbd_backiunsigned int max_segments =0 ;struct request_queue *b =NULL ;struct disk_conf *dc; -bool discard_zeroes_if_aligned = true;if (bdev) { b = bdev->backing_bdev->bd_disk->queue;
@@ -1282,7 +1285,6 @@ static void drbd_setup_queue_param(struct drbd_device *device, struct drbd_backircu_read_lock (); dc =rcu_dereference (device->ldev->disk_conf); max_segments = dc->max_bio_bvecs; - discard_zeroes_if_aligned = dc->discard_zeroes_if_aligned;rcu_read_unlock ();blk_set_stacking_limits (&q->limits);
@@ -1292,7 +1294,7 @@ static void drbd_setup_queue_param(struct drbd_device *device, struct drbd_backi/* This is the workaround for "bio would need to, but cannot, be split" */ blk_queue_max_segments (q, max_segments ? max_segments :BLK_MAX_SEGMENTS );blk_queue_segment_boundary (q,PAGE_SIZE -1 ); -decide_on_discard_support (device, q, b, discard_zeroes_if_aligned); +decide_on_discard_support (device, bdev);if (b) {blk_stack_limits (&q->limits, &b->limits,0 );
Signature · 1 line
2.30.2
Christoph Hellwig
maintainerPATCH 8/27 btrfs: use bdev_max_active_zones instead of open coding it
In reply to Christoph Hellwig--- fs/btrfs/zoned.c | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-)
fs/btrfs/zoned.c +1 -2
@@ -350,7 +350,6 @@ int btrfs_get_dev_zone_info(struct btrfs_device *device, bool populate_cache)struct btrfs_fs_info *fs_info = device->fs_info;struct btrfs_zoned_device_info *zone_info =NULL ;struct block_device *bdev = device->bdev; -struct request_queue *queue =bdev_get_queue (bdev);unsigned int max_active_zones;unsigned int nactive;sector_t nr_sectors;
@@ -410,7 +409,7 @@ int btrfs_get_dev_zone_info(struct btrfs_device *device, bool populate_cache)if (!IS_ALIGNED (nr_sectors, zone_sectors)) zone_info->nr_zones++; - max_active_zones =queue_max_active_zones (queue); + max_active_zones =bdev_max_active_zones (bdev);if (max_active_zones && max_active_zones <BTRFS_MIN_ACTIVE_ZONES ) { btrfs_err_in_rcu(fs_info, "zoned: %s: max active zones %u is too small, need@least %u active zones",
Signature · 1 line
2.30.2
Re: [PATCH 08/27] btrfs: use bdev_max_active_zones instead of open coding it
Quoted 4 lines · Christoph Hellwig
Signed-off-by Christoph Hellwig <[email protected]>Reviewed-by Johannes Thumshirn <[email protected]>Acked-by David Sterba <[email protected]>---
Looks good.
-ck
Re: [PATCH 08/27] btrfs: use bdev_max_active_zones instead of open coding it
In reply to Christoph HellwigQuoted 3 lines · Christoph Hellwig
Signed-off-by Christoph Hellwig <[email protected]>Reviewed-by Johannes Thumshirn <[email protected]>Acked-by David Sterba <[email protected]>
LGTM.
Quoted 25 lines
--- fs/btrfs/zoned.c | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-)fs/btrfs/zoned.c +1
-2@@ -350,7 +350,6 @@ int btrfs_get_dev_zone_info(struct btrfs_device *device, bool populate_cache)struct btrfs_fs_info *fs_info = device->fs_info;struct btrfs_zoned_device_info *zone_info =NULL ;struct block_device *bdev = device->bdev; -struct request_queue *queue =bdev_get_queue (bdev);unsigned int max_active_zones;unsigned int nactive;sector_t nr_sectors;@@ -410,7 +409,7 @@ int btrfs_get_dev_zone_info(struct btrfs_device *device, bool populate_cache)if (!IS_ALIGNED (nr_sectors, zone_sectors)) zone_info->nr_zones++; - max_active_zones =queue_max_active_zones (queue); + max_active_zones =bdev_max_active_zones (bdev);if (max_active_zones && max_active_zones <BTRFS_MIN_ACTIVE_ZONES ) { btrfs_err_in_rcu(fs_info, "zoned: %s: max active zones %u is too small, need at least %u active zones",
Christoph Hellwig
maintainerPATCH 9/27 ntfs3: use bdev_logical_block_size instead of open coding it
In reply to Christoph Hellwig--- fs/ntfs3/super.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-)
fs/ntfs3/super.c +1 -1
@@ -920,7 +920,7 @@ static int ntfs_fill_super(struct super_block *sb, struct fs_context *fc) }/* Parse boot. */ - err =ntfs_init_from_boot (sb, rq ?queue_logical_block_size (rq) :512 , + err =ntfs_init_from_boot (sb,bdev_logical_block_size (bdev),bdev_nr_bytes (bdev));if (err) goto out;
Signature · 1 line
2.30.2
Christoph Hellwig
maintainerPATCH 10/27 mm: use bdev_is_zoned in claim_swapfile
In reply to Christoph HellwigUse the bdev based helper instead of poking into the queue.
--- mm/swapfile.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-)
mm/swapfile.c +1 -1
@@ -2761,7 +2761,7 @@ static int claim_swapfile(struct swap_info_struct *p, struct inode *inode)* write only restriction. Hence zoned block devices are not * suitable for swapping. Disallow them here. */ -if (blk_queue_is_zoned (p->bdev->bd_disk->queue)) +if (bdev_is_zoned (p->bdev))return -EINVAL ; p->flags |=SWP_BLKDEV ; }else if (S_ISREG (inode->i_mode)) {
Signature · 1 line
2.30.2
Re: [PATCH 10/27] mm: use bdev_is_zoned in claim_swapfile
Quoted 12 lines · Christoph Hellwig
Use the bdev based helper instead of poking into the queue.
Signed-off-by Christoph Hellwig <[email protected]>--- mm/swapfile.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-)mm/swapfile.c +0
-0
mm/swapfile.c static int claim_swapfile(struct swap_info_struct *p, struct inode *inode) · line 2767
Quoted 8 lines
mm/swapfile.c +1
-1@@ -2761,7 +2761,7 @@ static int claim_swapfile(struct swap_info_struct *p, struct inode *inode)* write only restriction. Hence zoned block devices are not * suitable for swapping. Disallow them here. */ -if (blk_queue_is_zoned (p->bdev->bd_disk->queue)) +if (bdev_is_zoned (p->bdev))return -EINVAL ; p->flags |=SWP_BLKDEV ; }else if (S_ISREG (inode->i_mode)) {
Looks good.
Signature · 2 lines
Damien Le Moal Western Digital Research
Re: [PATCH 10/27] mm: use bdev_is_zoned in claim_swapfile
In reply to Christoph HellwigQuoted 4 lines · Christoph Hellwig
Use the bdev based helper instead of poking into the queue.
Signed-off-by Christoph Hellwig <[email protected]>---
Looks good.
-ck
Christoph Hellwig
maintainerPATCH 11/27 block: add a bdev_nonrot helper
In reply to Christoph HellwigAdd a helper to check the nonrot flag based on the block_device instead of having to poke into the block layer internal request_queue.
--- block/ioctl.c | 2 +- drivers/block/loop.c | 2 +- drivers/md/dm-table.c | 4 +--- drivers/md/md.c | 3 +-- drivers/md/raid1.c | 2 +- drivers/md/raid10.c | 2 +- drivers/md/raid5.c | 2 +- drivers/target/target_core_file.c | 3 +-- drivers/target/target_core_iblock.c | 2 +- fs/btrfs/volumes.c | 4 ++-- fs/ext4/mballoc.c | 2 +- include/linux/blkdev.h | 5 +++++ mm/swapfile.c | 4 ++-- 13 files changed, 19 insertions(+), 18 deletions(-)
block/ioctl.c +1 -1
@@ -489,7 +489,7 @@ static int blkdev_common_ioctl(struct block_device *bdev, fmode_t mode, queue_max_sectors(bdev_get_queue(bdev)));return put_ushort (argp, max_sectors);case BLKROTATIONAL : -return put_ushort (argp, !blk_queue_nonrot (bdev_get_queue (bdev))); +return put_ushort (argp, !bdev_nonrot (bdev));case BLKRASET :case BLKFRASET :if (!capable (CAP_SYS_ADMIN ))
drivers/block/loop.c +1 -1
@@ -903,7 +903,7 @@ static void loop_update_rotational(struct loop_device *lo)/* not all filesystems (e.g. tmpfs) have a sb->s_bdev */ if (file_bdev) - nonrot =blk_queue_nonrot (bdev_get_queue (file_bdev)); + nonrot =bdev_nonrot (file_bdev);if (nonrot)blk_queue_flag_set (QUEUE_FLAG_NONROT , q);
drivers/md/dm-table.c +1 -3
@@ -1820,9 +1820,7 @@ static int device_dax_write_cache_enabled(struct dm_target *ti,static int device_is_rotational (struct dm_target *ti,struct dm_dev *dev,sector_t start,sector_t len,void *data) { -struct request_queue *q =bdev_get_queue (dev->bdev); - -return !blk_queue_nonrot (q); +return !bdev_nonrot (dev->bdev); } static int device_is_not_random(struct dm_target *ti, struct dm_dev *dev,
drivers/md/md.c +1 -2
@@ -5991,8 +5991,7 @@ int md_run(struct mddev *mddev)bool nonrot = true;rdev_for_each (rdev, mddev) { -if (rdev->raid_disk >=0 && - !blk_queue_nonrot (bdev_get_queue (rdev->bdev))) { +if (rdev->raid_disk >=0 && !bdev_nonrot (rdev->bdev)) { nonrot = false;break ; }
drivers/md/raid1.c +1 -1
@@ -704,7 +704,7 @@ static int read_balance(struct r1conf *conf, struct r1bio *r1_bio, int *max_sect/* At least two disks to choose from so failfast is OK */ set_bit (R1BIO_FailFast, &r1_bio->state); - nonrot =blk_queue_nonrot (bdev_get_queue (rdev->bdev)); + nonrot =bdev_nonrot (rdev->bdev); has_nonrot_disk |= nonrot; pending =atomic_read (&rdev->nr_pending); dist =abs (this_sector - conf->mirrors[disk].head_position);
drivers/md/raid10.c +1 -1
@@ -796,7 +796,7 @@ static struct md_rdev *read_balance(struct r10conf *conf,if (!do_balance)break ; - nonrot =blk_queue_nonrot (bdev_get_queue (rdev->bdev)); + nonrot =bdev_nonrot (rdev->bdev); has_nonrot_disk |= nonrot; pending =atomic_read (&rdev->nr_pending);if (min_pending > pending && nonrot) {
drivers/md/raid5.c +1 -1
@@ -7242,7 +7242,7 @@ static struct r5conf *setup_conf(struct mddev *mddev)rdev_for_each (rdev, mddev) {if (test_bit (Journal, &rdev->flags))continue ; -if (blk_queue_nonrot (bdev_get_queue (rdev->bdev))) { +if (bdev_nonrot (rdev->bdev)) { conf->batch_bio_dispatch = false;break ; }
drivers/target/target_core_file.c +1 -2
@@ -135,7 +135,6 @@ static int fd_configure_device(struct se_device *dev) inode = file->f_mapping->host;if (S_ISBLK (inode->i_mode)) {struct block_device *bdev =I_BDEV (inode); -struct request_queue *q =bdev_get_queue (bdev);unsigned long long dev_size; fd_dev->fd_block_size =bdev_logical_block_size (bdev);
@@ -160,7 +159,7 @@ static int fd_configure_device(struct se_device *dev)*/ dev->dev_attrib.max_write_same_len =0xFFFF ; -if (blk_queue_nonrot (q)) +if (bdev_nonrot (bdev)) dev->dev_attrib.is_nonrot =1 ; }else {if (!(fd_dev->fbd_flags &FBDF_HAS_SIZE )) {
drivers/target/target_core_iblock.c +1 -1
@@ -133,7 +133,7 @@ static int iblock_configure_device(struct se_device *dev)else dev->dev_attrib.max_write_same_len =0xFFFF ; -if (blk_queue_nonrot (q)) +if (bdev_nonrot (bd)) dev->dev_attrib.is_nonrot =1 ; bi =bdev_get_integrity (bd);
fs/btrfs/volumes.c +2 -2
@@ -643,7 +643,7 @@ static int btrfs_open_one_device(struct btrfs_fs_devices *fs_devices,set_bit (BTRFS_DEV_STATE_WRITEABLE , &device->dev_state); } -if (!blk_queue_nonrot (bdev_get_queue (bdev))) +if (!bdev_nonrot (bdev)) fs_devices->rotating = true; device->bdev = bdev;
@@ -2706,7 +2706,7 @@ int btrfs_init_new_device(struct btrfs_fs_info *fs_info, const char *device_pathatomic64_add (device->total_bytes, &fs_info->free_chunk_space); -if (!blk_queue_nonrot (bdev_get_queue (bdev))) +if (!bdev_nonrot (bdev)) fs_devices->rotating = true; orig_super_total_bytes =btrfs_super_total_bytes (fs_info->super_copy);
fs/ext4/mballoc.c +1 -1
@@ -3498,7 +3498,7 @@ int ext4_mb_init(struct super_block *sb)spin_lock_init (&lg->lg_prealloc_lock); } -if (blk_queue_nonrot (bdev_get_queue (sb->s_bdev))) +if (bdev_nonrot (sb->s_bdev)) sbi->s_mb_max_linear_groups =0 ;else sbi->s_mb_max_linear_groups =MB_DEFAULT_LINEAR_LIMIT ;
include/linux/blkdev.h +5 -0
@@ -1326,6 +1326,11 @@ static inline unsigned int bdev_write_zeroes_sectors(struct block_device *bdev)return 0 ; } +static inline bool bdev_nonrot (struct block_device *bdev) +{ +return blk_queue_nonrot (bdev_get_queue (bdev)); +} +static inline enum blk_zoned_model bdev_zoned_model (struct block_device *bdev) {struct request_queue *q =bdev_get_queue (bdev);
mm/swapfile.c +2 -2
@@ -2466,7 +2466,7 @@ SYSCALL_DEFINE1(swapoff, const char __user *, specialfile)if (p->flags &SWP_CONTINUED )free_swap_count_continuations (p); -if (!p->bdev || !blk_queue_nonrot (bdev_get_queue (p->bdev))) +if (!p->bdev || !bdev_nonrot (p->bdev))atomic_dec (&nr_rotate_swap);mutex_lock (&swapon_mutex);
@@ -3071,7 +3071,7 @@ SYSCALL_DEFINE2(swapon, const char __user *, specialfile, int, swap_flags)if (p->bdev && p->bdev->bd_disk->fops->rw_page) p->flags |=SWP_SYNCHRONOUS_IO ; -if (p->bdev &&blk_queue_nonrot (bdev_get_queue (p->bdev))) { +if (p->bdev &&bdev_nonrot (p->bdev)) {int cpu;unsigned long ci, nr_cluster;
Signature · 1 line
2.30.2
Re: [PATCH 11/27] block: add a bdev_nonrot helper
Quoted 7 lines · Christoph Hellwig
Add a helper to check the nonrot flag based on the
block_deviceinstead of having to poke into the block layer internalrequest_queue.Signed-off-by Christoph Hellwig <[email protected]>Reviewed-by Martin K. Petersen <[email protected]>---
Looks good.
-ck
Christoph Hellwig
maintainerPATCH 12/27 block: add a bdev_write_cache helper
In reply to Christoph HellwigAdd a helper to check the write cache flag based on the block_device instead of having to poke into the block layer internal request_queue.
--- drivers/block/rnbd/rnbd-srv.c | 2 +- drivers/block/xen-blkback/xenbus.c | 2 +- drivers/target/target_core_iblock.c | 8 ++------ fs/btrfs/disk-io.c | 3 +-- include/linux/blkdev.h | 5 +++++ 5 files changed, 10 insertions(+), 10 deletions(-)
drivers/block/rnbd/rnbd-srv.c +1 -1
@@ -558,7 +558,7 @@ static void rnbd_srv_fill_msg_open_rsp(struct rnbd_msg_open_rsp *rsp, rsp->secure_discard =cpu_to_le16 (rnbd_dev_get_secure_discard (rnbd_dev)); rsp->cache_policy =0 ; -if (test_bit (QUEUE_FLAG_WC , &q->queue_flags)) +if (bdev_write_cache (rnbd_dev->bdev)) rsp->cache_policy |=RNBD_WRITEBACK ;if (blk_queue_fua (q)) rsp->cache_policy |=RNBD_FUA ;
drivers/block/xen-blkback/xenbus.c +1 -1
@@ -517,7 +517,7 @@ static int xen_vbd_create(struct xen_blkif *blkif, blkif_vdev_t handle, vbd->type |=VDISK_REMOVABLE ; q =bdev_get_queue (bdev); -if (q &&test_bit (QUEUE_FLAG_WC , &q->queue_flags)) +if (bdev_write_cache (bdev)) vbd->flush_support = true;if (q &&blk_queue_secure_erase (q))
drivers/target/target_core_iblock.c +2 -6
@@ -737,7 +737,7 @@ iblock_execute_rw(struct se_cmd *cmd, struct scatterlist *sgl, u32 sgl_nents,if (test_bit (QUEUE_FLAG_FUA , &q->queue_flags)) {if (cmd->se_cmd_flags &SCF_FUA ) opf |=REQ_FUA ; -else if (!test_bit (QUEUE_FLAG_WC , &q->queue_flags)) +else if (!bdev_write_cache (ib_dev->ibd_bd)) opf |=REQ_FUA ; } }else {
@@ -886,11 +886,7 @@ iblock_parse_cdb(struct se_cmd *cmd)static bool iblock_get_write_cache (struct se_device *dev) { -struct iblock_dev *ib_dev =IBLOCK_DEV (dev); -struct block_device *bd = ib_dev->ibd_bd; -struct request_queue *q =bdev_get_queue (bd); - -return test_bit (QUEUE_FLAG_WC , &q->queue_flags); +return bdev_write_cache (IBLOCK_DEV (dev)->ibd_bd); }static const struct target_backend_ops iblock_ops = {
fs/btrfs/disk-io.c +1 -2
@@ -4247,8 +4247,7 @@ static void write_dev_flush(struct btrfs_device *device)* of simplicity, since this is a debug tool and not meant for use in * non-debug builds. */ -struct request_queue *q =bdev_get_queue (device->bdev); -if (!test_bit (QUEUE_FLAG_WC , &q->queue_flags)) +if (!bdev_write_cache (device->bdev))return ;#endif
include/linux/blkdev.h +5 -0
@@ -1331,6 +1331,11 @@ static inline bool bdev_nonrot(struct block_device *bdev)return blk_queue_nonrot (bdev_get_queue (bdev)); } +static inline bool bdev_write_cache (struct block_device *bdev) +{ +return test_bit (QUEUE_FLAG_WC , &bdev_get_queue (bdev)->queue_flags); +} +static inline enum blk_zoned_model bdev_zoned_model (struct block_device *bdev) {struct request_queue *q =bdev_get_queue (bdev);
Signature · 1 line
2.30.2
Re: [PATCH 12/27] block: add a bdev_write_cache helper
Quoted 7 lines · Christoph Hellwig
Add a helper to check the write cache flag based on the
block_deviceinstead of having to poke into the block layer internalrequest_queue.Signed-off-by Christoph Hellwig <[email protected]>Reviewed-by Martin K. Petersen <[email protected]>---
Looks good.
-ck
Christoph Hellwig
maintainerPATCH 13/27 block: add a bdev_fua helper
In reply to Christoph HellwigAdd a helper to check the FUA flag based on the block_device instead of having to poke into the block layer internal request_queue.
--- drivers/block/rnbd/rnbd-srv.c | 3 +-- drivers/target/target_core_iblock.c | 3 +-- fs/iomap/direct-io.c | 3 +-- include/linux/blkdev.h | 6 +++++- 4 files changed, 8 insertions(+), 7 deletions(-)
drivers/block/rnbd/rnbd-srv.c +1 -2
@@ -533,7 +533,6 @@ static void rnbd_srv_fill_msg_open_rsp(struct rnbd_msg_open_rsp *rsp, struct rnbd_srv_sess_dev *sess_dev) {struct rnbd_dev *rnbd_dev = sess_dev->rnbd_dev; -struct request_queue *q =bdev_get_queue (rnbd_dev->bdev); rsp->hdr.type =cpu_to_le16 (RNBD_MSG_OPEN_RSP ); rsp->device_id =
@@ -560,7 +559,7 @@ static void rnbd_srv_fill_msg_open_rsp(struct rnbd_msg_open_rsp *rsp, rsp->cache_policy =0 ;if (bdev_write_cache (rnbd_dev->bdev)) rsp->cache_policy |=RNBD_WRITEBACK ; -if (blk_queue_fua (q)) +if (bdev_fua (rnbd_dev->bdev)) rsp->cache_policy |=RNBD_FUA ; }
drivers/target/target_core_iblock.c +1 -2
@@ -727,14 +727,13 @@ iblock_execute_rw(struct se_cmd *cmd, struct scatterlist *sgl, u32 sgl_nents,if (data_direction ==DMA_TO_DEVICE ) {struct iblock_dev *ib_dev =IBLOCK_DEV (dev); -struct request_queue *q =bdev_get_queue (ib_dev->ibd_bd);/* * Force writethrough using REQ_FUA if a volatile write cache * is not enabled, or if initiator set the Force Unit Access bit. */ opf =REQ_OP_WRITE ; miter_dir =SG_MITER_TO_SG ; -if (test_bit (QUEUE_FLAG_FUA , &q->queue_flags)) { +if (bdev_fua (ib_dev->ibd_bd)) {if (cmd->se_cmd_flags &SCF_FUA ) opf |=REQ_FUA ;else if (!bdev_write_cache (ib_dev->ibd_bd))
fs/iomap/direct-io.c +1 -2
@@ -265,8 +265,7 @@ static loff_t iomap_dio_bio_iter(const struct iomap_iter *iter,* cache flushes on IO completion. */ if (!(iomap->flags & (IOMAP_F_SHARED |IOMAP_F_DIRTY )) && - (dio->flags &IOMAP_DIO_WRITE_FUA ) && -blk_queue_fua (bdev_get_queue (iomap->bdev))) + (dio->flags &IOMAP_DIO_WRITE_FUA ) &&bdev_fua (iomap->bdev)) use_fua = true; }
include/linux/blkdev.h +5 -1
@@ -602,7 +602,6 @@ bool blk_queue_flag_test_and_set(unsigned int flag, struct request_queue *q); REQ_FAILFAST_DRIVER))#define blk_queue_quiesced (q) test_bit(QUEUE_FLAG_QUIESCED, &(q)->queue_flags)#define blk_queue_pm_only (q) atomic_read(&(q)->pm_only) -#define blk_queue_fua (q) test_bit(QUEUE_FLAG_FUA, &(q)->queue_flags)#define blk_queue_registered (q) test_bit(QUEUE_FLAG_REGISTERED, &(q)->queue_flags)#define blk_queue_nowait (q) test_bit(QUEUE_FLAG_NOWAIT, &(q)->queue_flags)
@@ -1336,6 +1335,11 @@ static inline bool bdev_write_cache(struct block_device *bdev)return test_bit (QUEUE_FLAG_WC , &bdev_get_queue (bdev)->queue_flags); } +static inline bool bdev_fua (struct block_device *bdev) +{ +return test_bit (QUEUE_FLAG_FUA , &bdev_get_queue (bdev)->queue_flags); +} +static inline enum blk_zoned_model bdev_zoned_model (struct block_device *bdev) {struct request_queue *q =bdev_get_queue (bdev);
Signature · 1 line
2.30.2
Re: [PATCH 13/27] block: add a bdev_fua helper
Quoted 5 lines · Christoph Hellwig
Add a helper to check the FUA flag based on the
block_deviceinstead of having to poke into the block layer internalrequest_queue.Signed-off-by Christoph Hellwig <[email protected]>Reviewed-by Martin K. Petersen <[email protected]>
Looks good.
-ck
Christoph Hellwig
maintainerPATCH 14/27 block: add a bdev_stable_writes helper
In reply to Christoph HellwigAdd a helper to check the stable writes flag based on the block_device instead of having to poke into the block layer internal request_queue.
--- drivers/md/dm-table.c | 4 +--- fs/super.c | 2 +- include/linux/blkdev.h | 6 ++++++ mm/swapfile.c | 2 +- 4 files changed, 9 insertions(+), 5 deletions(-)
drivers/md/dm-table.c +1 -3
@@ -1950,9 +1950,7 @@ static int device_requires_stable_pages(struct dm_target *ti, struct dm_dev *dev, sector_t start, sector_t len, void *data) { - struct request_queue *q = bdev_get_queue(dev->bdev); - -return blk_queue_stable_writes (q); + return bdev_stable_writes(dev->bdev); } int dm_table_set_restrictions(struct dm_table *t, struct request_queue *q,
fs/super.c +1 -1
@@ -1204,7 +1204,7 @@ static int set_bdev_super(struct super_block *s, void *data) s->s_dev = s->s_bdev->bd_dev; s->s_bdi =bdi_get (s->s_bdev->bd_disk->bdi); -if (blk_queue_stable_writes (s->s_bdev->bd_disk->queue)) +if (bdev_stable_writes (s->s_bdev)) s->s_iflags |=SB_I_STABLE_WRITES ;return 0 ; }
include/linux/blkdev.h +6 -0
@@ -1330,6 +1330,12 @@ static inline bool bdev_nonrot(struct block_device *bdev)return blk_queue_nonrot (bdev_get_queue (bdev)); } +static inline bool bdev_stable_writes (struct block_device *bdev) +{ +return test_bit (QUEUE_FLAG_STABLE_WRITES , + &bdev_get_queue (bdev)->queue_flags); +} +static inline bool bdev_write_cache (struct block_device *bdev) {return test_bit (QUEUE_FLAG_WC , &bdev_get_queue (bdev)->queue_flags);
mm/swapfile.c +1 -1
@@ -3065,7 +3065,7 @@ SYSCALL_DEFINE2(swapon, const char __user *, specialfile, int, swap_flags) goto bad_swap_unlock_inode; } -if (p->bdev &&blk_queue_stable_writes (p->bdev->bd_disk->queue)) +if (p->bdev &&bdev_stable_writes (p->bdev)) p->flags |=SWP_STABLE_WRITES ;if (p->bdev && p->bdev->bd_disk->fops->rw_page)
Signature · 1 line
2.30.2
Re: [PATCH 14/27] block: add a bdev_stable_writes helper
Quoted 6 lines · Christoph Hellwig
Add a helper to check the stable writes flag based on the
block_deviceinstead of having to poke into the block layer internalrequest_queue.Signed-off-by Christoph Hellwig <[email protected]>Reviewed-by Martin K. Petersen <[email protected]>---
Looks good.
-ck
Christoph Hellwig
maintainerPATCH 15/27 block: add a bdev_max_zone_append_sectors helper
In reply to Christoph HellwigAdd a helper to check the max supported sectors for zone append based on the block_device instead of having to poke into the block layer internal request_queue.
--- drivers/nvme/target/zns.c | 3 +-- fs/zonefs/super.c | 3 +-- include/linux/blkdev.h | 6 ++++++ 3 files changed, 8 insertions(+), 4 deletions(-)
drivers/nvme/target/zns.c +1 -2
@@ -34,8 +34,7 @@ static int validate_conv_zones_cb(struct blk_zone *z,bool nvmet_bdev_zns_enable (struct nvmet_ns *ns) { -struct request_queue *q = ns->bdev->bd_disk->queue; -u8 zasl =nvmet_zasl (queue_max_zone_append_sectors (q)); +u8 zasl =nvmet_zasl (bdev_max_zone_append_sectors (ns->bdev));struct gendisk *bd_disk = ns->bdev->bd_disk;int ret;
fs/zonefs/super.c +1 -2
@@ -678,13 +678,12 @@ static ssize_t zonefs_file_dio_append(struct kiocb *iocb, struct iov_iter *from)struct inode *inode =file_inode (iocb->ki_filp);struct zonefs_inode_info *zi =ZONEFS_I (inode);struct block_device *bdev = inode->i_sb->s_bdev; -unsigned int max; +unsigned int max =bdev_max_zone_append_sectors (bdev);struct bio *bio;ssize_t size;int nr_pages;ssize_t ret; - max =queue_max_zone_append_sectors (bdev_get_queue (bdev)); max =ALIGN_DOWN (max <<SECTOR_SHIFT , inode->i_sb->s_blocksize);iov_iter_truncate (from, max);
include/linux/blkdev.h +6 -0
@@ -1188,6 +1188,12 @@ static inline unsigned int queue_max_zone_append_sectors(const struct request_qureturn min (l->max_zone_append_sectors, l->max_sectors); } +static inline unsigned int +bdev_max_zone_append_sectors (struct block_device *bdev) +{ +return queue_max_zone_append_sectors (bdev_get_queue (bdev)); +} +static inline unsigned queue_logical_block_size (const struct request_queue *q) {int retval =512 ;
Signature · 1 line
2.30.2
Re: [PATCH 15/27] block: add a bdev_max_zone_append_sectors helper
Quoted 9 lines · Christoph Hellwig
Add a helper to check the max supported sectors for zone append based on the
block_deviceinstead of having to poke into the block layer internalrequest_queue.Signed-off-by Christoph Hellwig <[email protected]>Acked-by Damien Le Moal <[email protected]>Reviewed-by Martin K. Petersen <[email protected]>Reviewed-by Johannes Thumshirn <[email protected]>---
Looks good.
-ck
Christoph Hellwig
maintainerPATCH 16/27 block: use bdev_alignment_offset in part_alignment_offset_show
In reply to Christoph HellwigReplace the open coded offset calculation with the proper helper. This is an ABI change in that the -1 for a misaligned partition is properly propagated, which can be considered a bug fix and matches what is done on the whole device.
--- block/partitions/core.c | 6 +----- 1 file changed, 1 insertion(+), 5 deletions(-)
block/partitions/core.c +1 -5
@@ -200,11 +200,7 @@ static ssize_t part_ro_show(struct device *dev,static ssize_t part_alignment_offset_show (struct device *dev,struct device_attribute *attr,char *buf) { -struct block_device *bdev =dev_to_bdev (dev); - -return sprintf (buf,"%u\n" , -queue_limit_alignment_offset (&bdev_get_queue (bdev)->limits, - bdev->bd_start_sect)); +return sprintf (buf,"%u\n" ,bdev_alignment_offset (dev_to_bdev (dev))); } static ssize_t part_discard_alignment_show(struct device *dev,
Signature · 1 line
2.30.2
Re: [PATCH 16/27] block: use bdev_alignment_offset in part_alignment_offset_show
Quoted 8 lines · Christoph Hellwig
Replace the open coded offset calculation with the proper helper. This is an ABI change in that the -1 for a misaligned partition is properly propagated, which can be considered a bug fix and matches what is done on the whole device.
Signed-off-by Christoph Hellwig <[email protected]>Reviewed-by Martin K. Petersen <[email protected]>---
Neat!
Looks good.
-ck
Christoph Hellwig
maintainerPATCH 17/27 block: use bdev_alignment_offset in disk_alignment_offset_show
In reply to Christoph HellwigThis does the same as the open coded variant except for an extra branch, and allows to remove queue_alignment_offset entirely.
--- block/genhd.c | 2 +- include/linux/blkdev.h | 8 -------- 2 files changed, 1 insertion(+), 9 deletions(-)
block/genhd.c +1 -1
@@ -1010,7 +1010,7 @@ static ssize_t disk_alignment_offset_show(struct device *dev, {struct gendisk *disk =dev_to_disk (dev); -return sprintf (buf,"%d\n" ,queue_alignment_offset (disk->queue)); +return sprintf (buf,"%d\n" ,bdev_alignment_offset (disk->part0)); } static ssize_t disk_discard_alignment_show(struct device *dev,
include/linux/blkdev.h +0 -8
@@ -1251,14 +1251,6 @@ bdev_zone_write_granularity(struct block_device *bdev)return queue_zone_write_granularity (bdev_get_queue (bdev)); } -static inline int queue_alignment_offset (const struct request_queue *q) -{ -if (q->limits.misaligned) -return -1 ; - -return q->limits.alignment_offset; -} -static inline int queue_limit_alignment_offset (struct queue_limits *lim,sector_t sector) {unsigned int granularity =max (lim->physical_block_size, lim->io_min);
Signature · 1 line
2.30.2
Christoph Hellwig
maintainerPATCH 18/27 block: move bdev_alignment_offset and queue_limit_alignment_offset out of line
In reply to Christoph HellwigNo need to inline these fairly larger helpers.
--- block/blk-settings.c | 23 +++++++++++++++++++++++ include/linux/blkdev.h | 21 +-------------------- 2 files changed, 24 insertions(+), 20 deletions(-)
block/blk-settings.c +23 -0
@@ -468,6 +468,16 @@ void blk_queue_io_opt(struct request_queue *q, unsigned int opt) }EXPORT_SYMBOL (blk_queue_io_opt); +static int queue_limit_alignment_offset (struct queue_limits *lim, +sector_t sector) +{ +unsigned int granularity =max (lim->physical_block_size, lim->io_min); +unsigned int alignment =sector_div (sector, granularity >>SECTOR_SHIFT ) + <<SECTOR_SHIFT ; + +return (granularity + lim->alignment_offset - alignment) % granularity; +} +static unsigned int blk_round_down_sectors (unsigned int sectors,unsigned int lbs) { sectors =round_down (sectors, lbs >>SECTOR_SHIFT );
@@ -901,3 +911,16 @@ void blk_queue_set_zoned(struct gendisk *disk, enum blk_zoned_model model) } }EXPORT_SYMBOL_GPL (blk_queue_set_zoned); + +int bdev_alignment_offset (struct block_device *bdev) +{ +struct request_queue *q =bdev_get_queue (bdev); + +if (q->limits.misaligned) +return -1 ; +if (bdev_is_partition (bdev)) +return queue_limit_alignment_offset (&q->limits, + bdev->bd_start_sect); +return q->limits.alignment_offset; +} +EXPORT_SYMBOL_GPL (bdev_alignment_offset);
include/linux/blkdev.h +1 -20
@@ -1251,26 +1251,7 @@ bdev_zone_write_granularity(struct block_device *bdev)return queue_zone_write_granularity (bdev_get_queue (bdev)); } -static inline int queue_limit_alignment_offset (struct queue_limits *lim,sector_t sector) -{ -unsigned int granularity =max (lim->physical_block_size, lim->io_min); -unsigned int alignment =sector_div (sector, granularity >>SECTOR_SHIFT ) - <<SECTOR_SHIFT ; - -return (granularity + lim->alignment_offset - alignment) % granularity; -} - -static inline int bdev_alignment_offset (struct block_device *bdev) -{ -struct request_queue *q =bdev_get_queue (bdev); - -if (q->limits.misaligned) -return -1 ; -if (bdev_is_partition (bdev)) -return queue_limit_alignment_offset (&q->limits, - bdev->bd_start_sect); -return q->limits.alignment_offset; -} +int bdev_alignment_offset (struct block_device *bdev);static inline int queue_discard_alignment (const struct request_queue *q) {
Signature · 1 line
2.30.2
Christoph Hellwig
maintainerPATCH 19/27 block: remove queue_discard_alignment
In reply to Christoph HellwigJust use bdev_alignment_offset in disk_discard_alignment_show instead. That helpers is the same except for an always false branch that doesn't matter in this slow path.
--- block/genhd.c | 2 +- include/linux/blkdev.h | 8 -------- 2 files changed, 1 insertion(+), 9 deletions(-)
block/genhd.c +1 -1
@@ -1019,7 +1019,7 @@ static ssize_t disk_discard_alignment_show(struct device *dev, {struct gendisk *disk =dev_to_disk (dev); -return sprintf (buf,"%d\n" ,queue_discard_alignment (disk->queue)); +return sprintf (buf,"%d\n" ,bdev_alignment_offset (disk->part0)); } static ssize_t diskseq_show(struct device *dev,
include/linux/blkdev.h +0 -8
@@ -1253,14 +1253,6 @@ bdev_zone_write_granularity(struct block_device *bdev)int bdev_alignment_offset (struct block_device *bdev); -static inline int queue_discard_alignment (const struct request_queue *q) -{ -if (q->limits.discard_misaligned) -return -1 ; - -return q->limits.discard_alignment; -} -static inline int queue_limit_discard_alignment (struct queue_limits *lim,sector_t sector) {unsigned int alignment, granularity, offset;
Signature · 1 line
2.30.2
Christoph Hellwig
maintainerPATCH 20/27 block: use bdev_discard_alignment in part_discard_alignment_show
In reply to Christoph HellwigUse the bdev based alignment helper instead of open coding it.
--- block/partitions/core.c | 6 +----- 1 file changed, 1 insertion(+), 5 deletions(-)
block/partitions/core.c +1 -5
@@ -206,11 +206,7 @@ static ssize_t part_alignment_offset_show(struct device *dev,static ssize_t part_discard_alignment_show (struct device *dev,struct device_attribute *attr,char *buf) { -struct block_device *bdev =dev_to_bdev (dev); - -return sprintf (buf,"%u\n" , -queue_limit_discard_alignment (&bdev_get_queue (bdev)->limits, - bdev->bd_start_sect)); +return sprintf (buf,"%u\n" ,bdev_discard_alignment (dev_to_bdev (dev))); } static DEVICE_ATTR(partition, 0444, part_partition_show, NULL);
Signature · 1 line
2.30.2
Christoph Hellwig
maintainerPATCH 21/27 block: move {bdev,queue_limit}_discard_alignment out of line
In reply to Christoph HellwigNo need to inline these fairly larger helpers. Also fix the return value to be unsigned, just like the field in struct queue_limits.
--- block/blk-settings.c | 35 +++++++++++++++++++++++++++++++++++ include/linux/blkdev.h | 34 +--------------------------------- 2 files changed, 36 insertions(+), 33 deletions(-)
block/blk-settings.c +35 -0
@@ -478,6 +478,30 @@ static int queue_limit_alignment_offset(struct queue_limits *lim,return (granularity + lim->alignment_offset - alignment) % granularity; } +static unsigned int queue_limit_discard_alignment (struct queue_limits *lim, +sector_t sector) +{ +unsigned int alignment, granularity, offset; + +if (!lim->max_discard_sectors) +return 0 ; + +/* Why are these in bytes, not sectors? */ + alignment = lim->discard_alignment >>SECTOR_SHIFT ; + granularity = lim->discard_granularity >>SECTOR_SHIFT ; +if (!granularity) +return 0 ; + +/* Offset of the partition start in 'granularity' sectors */ + offset =sector_div (sector, granularity); + +/* And why do we do this modulus *again* in blkdev_issue_discard()? */ + offset = (granularity + alignment - offset) % granularity; + +/* Turn it back into bytes, gaah */ +return offset <<SECTOR_SHIFT ; +} +static unsigned int blk_round_down_sectors (unsigned int sectors,unsigned int lbs) { sectors =round_down (sectors, lbs >>SECTOR_SHIFT );
@@ -924,3 +948,14 @@ int bdev_alignment_offset(struct block_device *bdev)return q->limits.alignment_offset; }EXPORT_SYMBOL_GPL (bdev_alignment_offset); + +unsigned int bdev_discard_alignment (struct block_device *bdev) +{ +struct request_queue *q =bdev_get_queue (bdev); + +if (bdev_is_partition (bdev)) +return queue_limit_discard_alignment (&q->limits, + bdev->bd_start_sect); +return q->limits.discard_alignment; +} +EXPORT_SYMBOL_GPL (bdev_discard_alignment);
include/linux/blkdev.h +1 -33
@@ -1252,39 +1252,7 @@ bdev_zone_write_granularity(struct block_device *bdev) }int bdev_alignment_offset (struct block_device *bdev); - -static inline int queue_limit_discard_alignment (struct queue_limits *lim,sector_t sector) -{ -unsigned int alignment, granularity, offset; - -if (!lim->max_discard_sectors) -return 0 ; - -/* Why are these in bytes, not sectors? */ - alignment = lim->discard_alignment >>SECTOR_SHIFT ; - granularity = lim->discard_granularity >>SECTOR_SHIFT ; -if (!granularity) -return 0 ; - -/* Offset of the partition start in 'granularity' sectors */ - offset =sector_div (sector, granularity); - -/* And why do we do this modulus *again* in blkdev_issue_discard()? */ - offset = (granularity + alignment - offset) % granularity; - -/* Turn it back into bytes, gaah */ -return offset <<SECTOR_SHIFT ; -} - -static inline int bdev_discard_alignment (struct block_device *bdev) -{ -struct request_queue *q =bdev_get_queue (bdev); - -if (bdev_is_partition (bdev)) -return queue_limit_discard_alignment (&q->limits, - bdev->bd_start_sect); -return q->limits.discard_alignment; -} +unsigned int bdev_discard_alignment (struct block_device *bdev);static inline unsigned int bdev_write_zeroes_sectors (struct block_device *bdev) {
Signature · 1 line
2.30.2
Christoph Hellwig
maintainerPATCH 22/27 block: refactor discard bio size limiting
In reply to Christoph HellwigMove all the logic to limit the discard bio size into a common helper so that it is better documented.
--- block/blk-lib.c | 59 ++++++++++++++++++++++++------------------------- block/blk.h | 14 ------------ 2 files changed, 29 insertions(+), 44 deletions(-)
block/blk-lib.c +29 -30
@@ -10,6 +10,32 @@#include "blk.h" +static sector_t bio_discard_limit (struct block_device *bdev,sector_t sector) +{ +unsigned int discard_granularity = +bdev_get_queue (bdev)->limits.discard_granularity; +sector_t granularity_aligned_sector; + +if (bdev_is_partition (bdev)) + sector += bdev->bd_start_sect; + + granularity_aligned_sector = +round_up (sector, discard_granularity >>SECTOR_SHIFT ); + +/* +* Make sure subsequent bios start aligned to the discard granularity if +* it needs to be split. +*/ +if (granularity_aligned_sector != sector) +return granularity_aligned_sector - sector; + +/* +* Align the bio size to the discard granularity to make splitting the bio +* at discard granularity boundaries easier in the driver if needed. +*/ +return round_down (UINT_MAX , discard_granularity) >>SECTOR_SHIFT ; +} +int __blkdev_issue_discard (struct block_device *bdev,sector_t sector,sector_t nr_sects,gfp_t gfp_mask,int flags,struct bio **biop)
@@ -17,7 +43,7 @@ int __blkdev_issue_discard(struct block_device *bdev, sector_t sector,struct request_queue *q =bdev_get_queue (bdev);struct bio *bio = *biop;unsigned int op; -sector_t bs_mask, part_offset =0 ; +sector_t bs_mask;if (bdev_read_only (bdev))return -EPERM ;
@@ -48,36 +74,9 @@ int __blkdev_issue_discard(struct block_device *bdev, sector_t sector,if (!nr_sects)return -EINVAL ; -/* In case the discard request is in a partition */ -if (bdev_is_partition (bdev)) - part_offset = bdev->bd_start_sect; -while (nr_sects) { -sector_t granularity_aligned_lba, req_sects; -sector_t sector_mapped = sector + part_offset; - - granularity_aligned_lba =round_up (sector_mapped, - q->limits.discard_granularity >>SECTOR_SHIFT ); - -/* -* Check whether the discard bio starts at a discard_granularity -* aligned LBA, -* - If no: set (granularity_aligned_lba - sector_mapped) to -* bi_size of the first split bio, then the second bio will -* start at a discard_granularity aligned LBA on the device. -* - If yes: use bio_aligned_discard_max_sectors() as the max -* possible bi_size of the first split bio. Then when this bio -* is split in device drive, the split ones are very probably -* to be aligned to discard_granularity of the device's queue. -*/ -if (granularity_aligned_lba == sector_mapped) - req_sects =min_t (sector_t, nr_sects, -bio_aligned_discard_max_sectors (q)); -else - req_sects =min_t (sector_t, nr_sects, - granularity_aligned_lba - sector_mapped); - -WARN_ON_ONCE ((req_sects <<9 ) >UINT_MAX ); +sector_t req_sects = +min (nr_sects,bio_discard_limit (bdev, sector)); bio =blk_next_bio (bio, bdev,0 , op, gfp_mask); bio->bi_iter.bi_sector = sector;
block/blk.h +0 -14
@@ -346,20 +346,6 @@ static inline unsigned int bio_allowed_max_sectors(struct request_queue *q)return round_down (UINT_MAX ,queue_logical_block_size (q)) >>9 ; } -/* -* The max bio size which is aligned to q->limits.discard_granularity. This -* is a hint to split large discard bio in generic block layer, then if device -* driver needs to split the discard bio into smaller ones, their bi_size can -* be very probably and easily aligned to discard_granularity of the device's -* queue. -*/ -static inline unsigned int bio_aligned_discard_max_sectors ( -struct request_queue *q) -{ -return round_down (UINT_MAX , q->limits.discard_granularity) >> -SECTOR_SHIFT ; -} -/* * Internal io_context interface */
Signature · 1 line
2.30.2
Re: [PATCH 22/27] block: refactor discard bio size limiting
Quoted 7 lines · Christoph Hellwig
Move all the logic to limit the discard bio size into a common helper so that it is better documented.
Signed-off-by Christoph Hellwig <[email protected]>Reviewed-by Martin K. Petersen <[email protected]>Acked-by Coly Li <[email protected]>---
Looks good.
-ck
Christoph Hellwig
maintainerPATCH 23/27 block: add a bdev_max_discard_sectors helper
In reply to Christoph HellwigAdd a helper to query the number of sectors support per each discard bio based on the block device and use this helper to stop various places from poking into the request_queue to see if discard is supported and if so how much. This mirrors what is done e.g. for write zeroes as well.
--- drivers/block/drbd/drbd_nl.c | 8 +++++--- drivers/block/drbd/drbd_receiver.c | 2 +- drivers/block/rnbd/rnbd-srv-dev.h | 3 +-- drivers/md/dm-io.c | 2 +- drivers/target/target_core_device.c | 7 +++---- fs/f2fs/segment.c | 6 ++---- include/linux/blkdev.h | 5 +++++ 7 files changed, 18 insertions(+), 15 deletions(-)
drivers/block/drbd/drbd_nl.c +5 -3
@@ -1439,7 +1439,8 @@ static bool write_ordering_changed(struct disk_conf *a, struct disk_conf *b)static void sanitize_disk_conf (struct drbd_device *device,struct disk_conf *disk_conf,struct drbd_backing_dev *nbc) { -struct request_queue *const q = nbc->backing_bdev->bd_disk->queue; +struct block_device *bdev = nbc->backing_bdev; +struct request_queue *q = bdev->bd_disk->queue;if (disk_conf->al_extents <DRBD_AL_EXTENTS_MIN ) disk_conf->al_extents =DRBD_AL_EXTENTS_MIN ;
@@ -1455,6 +1456,7 @@ static void sanitize_disk_conf(struct drbd_device *device, struct disk_conf *disif (disk_conf->rs_discard_granularity) {int orig_value = disk_conf->rs_discard_granularity; +sector_t discard_size =bdev_max_discard_sectors (bdev) <<9 ;int remainder;if (q->limits.discard_granularity > disk_conf->rs_discard_granularity)
@@ -1463,8 +1465,8 @@ static void sanitize_disk_conf(struct drbd_device *device, struct disk_conf *dis remainder = disk_conf->rs_discard_granularity % q->limits.discard_granularity; disk_conf->rs_discard_granularity += remainder; -if (disk_conf->rs_discard_granularity > q->limits.max_discard_sectors <<9 ) - disk_conf->rs_discard_granularity = q->limits.max_discard_sectors <<9 ; +if (disk_conf->rs_discard_granularity > discard_size) + disk_conf->rs_discard_granularity = discard_size;if (disk_conf->rs_discard_granularity != orig_value) drbd_info(device, "rs_discard_granularity changed to %d\n",
drivers/block/drbd/drbd_receiver.c +1 -1
@@ -1524,7 +1524,7 @@ int drbd_issue_discard_or_zero_out(struct drbd_device *device, sector_t start, u granularity =max (q->limits.discard_granularity >>9 ,1U ); alignment = (bdev_discard_alignment (bdev) >>9 ) % granularity; - max_discard_sectors =min (q->limits.max_discard_sectors, (1U <<22 )); + max_discard_sectors =min (bdev_max_discard_sectors (bdev), (1U <<22 )); max_discard_sectors -= max_discard_sectors % granularity;if (unlikely (!max_discard_sectors)) goto zero_out;
drivers/block/rnbd/rnbd-srv-dev.h +1 -2
@@ -52,8 +52,7 @@ static inline int rnbd_dev_get_max_discard_sects(const struct rnbd_dev *dev)if (!blk_queue_discard (bdev_get_queue (dev->bdev)))return 0 ; -return blk_queue_get_max_sectors (bdev_get_queue (dev->bdev), -REQ_OP_DISCARD ); +return bdev_max_discard_sectors (dev->bdev); }static inline int rnbd_dev_get_discard_granularity (const struct rnbd_dev *dev)
drivers/md/dm-io.c +1 -1
@@ -311,7 +311,7 @@ static void do_region(int op, int op_flags, unsigned region,* Reject unsupported discard and write same requests. */ if (op ==REQ_OP_DISCARD ) - special_cmd_max_sectors = q->limits.max_discard_sectors; + special_cmd_max_sectors =bdev_max_discard_sectors (where->bdev);else if (op ==REQ_OP_WRITE_ZEROES ) special_cmd_max_sectors = q->limits.max_write_zeroes_sectors; if ((op == REQ_OP_DISCARD || op == REQ_OP_WRITE_ZEROES) &&
drivers/target/target_core_device.c +3 -4
@@ -829,9 +829,8 @@ struct se_device *target_alloc_device(struct se_hba *hba, const char *name) }/* -* Check if the underlying struct block_device request_queue supports -* the QUEUE_FLAG_DISCARD bit for UNMAP/WRITE_SAME in SCSI + TRIM -* in ATA and we need to set TPE=1 +* Check if the underlying struct block_device supports discard and if yes +* configure the UNMAP parameters. */ bool target_configure_unmap_from_queue (struct se_dev_attrib *attrib,struct block_device *bdev)
@@ -843,7 +842,7 @@ bool target_configure_unmap_from_queue(struct se_dev_attrib *attrib,return false; attrib->max_unmap_lba_count = - q->limits.max_discard_sectors >> (ilog2 (block_size) -9 ); +bdev_max_discard_sectors (bdev) >> (ilog2 (block_size) -9 );/* * Currently hardcoded to 1 in Linux/SCSI code.. */
fs/f2fs/segment.c +2 -4
@@ -1196,9 +1196,8 @@ static int __submit_discard_cmd(struct f2fs_sb_info *sbi, unsigned int *issued) {struct block_device *bdev = dc->bdev; -struct request_queue *q =bdev_get_queue (bdev);unsigned int max_discard_blocks = -SECTOR_TO_BLOCK (q->limits.max_discard_sectors); +SECTOR_TO_BLOCK (bdev_max_discard_sectors (bdev));struct discard_cmd_control *dcc =SM_I (sbi)->dcc_info;struct list_head *wait_list = (dpolicy->type ==DPOLICY_FSTRIM ) ? &(dcc->fstrim_list) : &(dcc->wait_list);
@@ -1375,9 +1374,8 @@ static void __update_discard_tree_range(struct f2fs_sb_info *sbi,struct discard_cmd *dc;struct discard_info di = {0 };struct rb_node **insert_p =NULL , *insert_parent =NULL ; -struct request_queue *q =bdev_get_queue (bdev);unsigned int max_discard_blocks = -SECTOR_TO_BLOCK (q->limits.max_discard_sectors); +SECTOR_TO_BLOCK (bdev_max_discard_sectors (bdev));block_t end = lstart + len; dc = (struct discard_cmd *)f2fs_lookup_rb_tree_ret(&dcc->root,
include/linux/blkdev.h +5 -0
@@ -1254,6 +1254,11 @@ bdev_zone_write_granularity(struct block_device *bdev)int bdev_alignment_offset (struct block_device *bdev);unsigned int bdev_discard_alignment (struct block_device *bdev); +static inline unsigned int bdev_max_discard_sectors (struct block_device *bdev) +{ +return bdev_get_queue (bdev)->limits.max_discard_sectors; +} +static inline unsigned int bdev_write_zeroes_sectors (struct block_device *bdev) {struct request_queue *q =bdev_get_queue (bdev);
Signature · 1 line
2.30.2
Re: [PATCH 23/27] block: add a bdev_max_discard_sectors helper
Quoted 11 lines · Christoph Hellwig
Add a helper to query the number of sectors support per each discard bio based on the block device and use this helper to stop various places from poking into the
request_queueto see if discard is supported and if so how much. This mirrors what is done e.g. for write zeroes as well.Signed-off-by Christoph Hellwig <[email protected]>Reviewed-by Martin K. Petersen <[email protected]>Acked-by Coly Li <[email protected]> [bcache]---
Looks good.
-ck
Christoph Hellwig
maintainerPATCH 24/27 block: remove QUEUE_FLAG_DISCARD
In reply to Christoph HellwigJust use a non-zero max_discard_sectors as an indicator for discard support, similar to what is done for write zeroes.
The only places where needs special attention is the RAID5 driver, which must clear discard support for security reasons by default, even if the default stacking rules would allow for it.
--- arch/um/drivers/ubd_kern.c | 2 -- block/blk-core.c | 2 +- block/blk-lib.c | 2 +- block/blk-mq-debugfs.c | 1 - block/ioctl.c | 3 +-- drivers/block/drbd/drbd_main.c | 2 +- drivers/block/drbd/drbd_nl.c | 19 ++----------------- drivers/block/drbd/drbd_receiver.c | 3 +-- drivers/block/loop.c | 11 +++-------- drivers/block/nbd.c | 5 +---- drivers/block/null_blk/main.c | 1 - drivers/block/rbd.c | 1 - drivers/block/rnbd/rnbd-clt.c | 2 -- drivers/block/rnbd/rnbd-srv-dev.h | 3 --- drivers/block/virtio_blk.c | 2 -- drivers/block/xen-blkback/xenbus.c | 2 +- drivers/block/xen-blkfront.c | 3 +-- drivers/block/zram/zram_drv.c | 1 - drivers/md/bcache/request.c | 4 ++-- drivers/md/bcache/super.c | 3 +-- drivers/md/bcache/sysfs.c | 2 +- drivers/md/dm-cache-target.c | 9 +-------- drivers/md/dm-clone-target.c | 9 +-------- drivers/md/dm-log-writes.c | 3 +-- drivers/md/dm-raid.c | 9 ++------- drivers/md/dm-table.c | 9 ++------- drivers/md/dm-thin.c | 11 +---------- drivers/md/dm.c | 3 +-- drivers/md/md-linear.c | 11 +---------- drivers/md/raid0.c | 7 ------- drivers/md/raid1.c | 16 +--------------- drivers/md/raid10.c | 18 ++---------------- drivers/md/raid5-cache.c | 2 +- drivers/md/raid5.c | 12 ++++-------- drivers/mmc/core/queue.c | 1 - drivers/mtd/mtd_blkdevs.c | 1 - drivers/nvme/host/core.c | 4 ++-- drivers/s390/block/dasd_fba.c | 1 - drivers/scsi/sd.c | 2 -- drivers/target/target_core_device.c | 2 +- fs/btrfs/extent-tree.c | 4 ++-- fs/btrfs/ioctl.c | 2 +- fs/exfat/file.c | 2 +- fs/exfat/super.c | 10 +++------- fs/ext4/ioctl.c | 10 +++------- fs/ext4/super.c | 10 +++------- fs/f2fs/f2fs.h | 3 +-- fs/fat/file.c | 2 +- fs/fat/inode.c | 10 +++------- fs/gfs2/rgrp.c | 2 +- fs/jbd2/journal.c | 7 ++----- fs/jfs/ioctl.c | 2 +- fs/jfs/super.c | 8 ++------ fs/nilfs2/ioctl.c | 2 +- fs/ntfs3/file.c | 2 +- fs/ntfs3/super.c | 2 +- fs/ocfs2/ioctl.c | 2 +- fs/xfs/xfs_discard.c | 2 +- fs/xfs/xfs_super.c | 12 ++++-------- include/linux/blkdev.h | 2 -- mm/swapfile.c | 17 ++--------------- 61 files changed, 73 insertions(+), 244 deletions(-)
arch/um/drivers/ubd_kern.c +0 -2
@@ -483,7 +483,6 @@ static void ubd_handler(void)if ((io_req->error ==BLK_STS_NOTSUPP ) && (req_op (io_req->req) ==REQ_OP_DISCARD )) {blk_queue_max_discard_sectors (io_req->req->q,0 );blk_queue_max_write_zeroes_sectors (io_req->req->q,0 ); -blk_queue_flag_clear (QUEUE_FLAG_DISCARD , io_req->req->q); }blk_mq_end_request (io_req->req, io_req->error);kfree (io_req);
@@ -803,7 +802,6 @@ static int ubd_open_dev(struct ubd *ubd_dev) ubd_dev->queue->limits.discard_alignment =SECTOR_SIZE ;blk_queue_max_discard_sectors (ubd_dev->queue,UBD_MAX_REQUEST );blk_queue_max_write_zeroes_sectors (ubd_dev->queue,UBD_MAX_REQUEST ); -blk_queue_flag_set (QUEUE_FLAG_DISCARD , ubd_dev->queue); }blk_queue_flag_set (QUEUE_FLAG_NONROT , ubd_dev->queue);return 0 ;
block/blk-core.c +1 -1
@@ -820,7 +820,7 @@ void submit_bio_noacct(struct bio *bio)switch (bio_op (bio)) {case REQ_OP_DISCARD : -if (!blk_queue_discard (q)) +if (!bdev_max_discard_sectors (bdev)) goto not_supported;break ;case REQ_OP_SECURE_ERASE :
block/blk-lib.c +1 -1
@@ -53,7 +53,7 @@ int __blkdev_issue_discard(struct block_device *bdev, sector_t sector,return -EOPNOTSUPP ; op =REQ_OP_SECURE_ERASE ; }else { -if (!blk_queue_discard (q)) +if (!bdev_max_discard_sectors (bdev))return -EOPNOTSUPP ; op =REQ_OP_DISCARD ; }
block/blk-mq-debugfs.c +0 -1
@@ -113,7 +113,6 @@ static const char *const blk_queue_flag_name[] = {QUEUE_FLAG_NAME (FAIL_IO ),QUEUE_FLAG_NAME (NONROT ),QUEUE_FLAG_NAME (IO_STAT ), -QUEUE_FLAG_NAME (DISCARD ),QUEUE_FLAG_NAME (NOXMERGES ),QUEUE_FLAG_NAME (ADD_RANDOM ), QUEUE_FLAG_NAME(SECERASE),
block/ioctl.c +1 -2
@@ -87,14 +87,13 @@ static int blk_ioctl_discard(struct block_device *bdev, fmode_t mode, {uint64_t range[2 ];uint64_t start, len; -struct request_queue *q =bdev_get_queue (bdev);struct inode *inode = bdev->bd_inode;int err;if (!(mode &FMODE_WRITE ))return -EBADF ; -if (!blk_queue_discard (q)) +if (!bdev_max_discard_sectors (bdev))return -EOPNOTSUPP ;if (copy_from_user (range, (void __user *)arg,sizeof (range)))
drivers/block/drbd/drbd_main.c +1 -1
@@ -942,7 +942,7 @@ int drbd_send_sizes(struct drbd_peer_device *peer_device, int trigger_reply, enucpu_to_be32 (bdev_alignment_offset (bdev)); p->qlim->io_min =cpu_to_be32 (bdev_io_min (bdev)); p->qlim->io_opt =cpu_to_be32 (bdev_io_opt (bdev)); - p->qlim->discard_enabled =blk_queue_discard (q); + p->qlim->discard_enabled = !!bdev_max_discard_sectors (bdev);put_ldev (device); }else {struct request_queue *q = device->rq_queue;
drivers/block/drbd/drbd_nl.c +2 -17
@@ -1210,7 +1210,7 @@ static void decide_on_discard_support(struct drbd_device *device,first_peer_device (device)->connection;struct request_queue *q = device->rq_queue; -if (bdev && !blk_queue_discard (bdev->backing_bdev->bd_disk->queue)) +if (bdev && !bdev_max_discard_sectors (bdev->backing_bdev)) goto not_supported; if (connection->cstate >= C_CONNECTED &&
@@ -1230,30 +1230,16 @@ static void decide_on_discard_support(struct drbd_device *device,*/ blk_queue_discard_granularity (q,512 ); q->limits.max_discard_sectors =drbd_max_discard_sectors (connection); -blk_queue_flag_set (QUEUE_FLAG_DISCARD , q); q->limits.max_write_zeroes_sectors =drbd_max_discard_sectors (connection);return ; not_supported: -blk_queue_flag_clear (QUEUE_FLAG_DISCARD , q);blk_queue_discard_granularity (q,0 ); q->limits.max_discard_sectors =0 ; q->limits.max_write_zeroes_sectors =0 ; } -static void fixup_discard_if_not_supported (struct request_queue *q) -{ -/* To avoid confusion, if this queue does not support discard, clear -* max_discard_sectors, which is what lsblk -D reports to the user. -* Older kernels got this wrong in "stack limits". -* */ -if (!blk_queue_discard (q)) { -blk_queue_max_discard_sectors (q,0 ); -blk_queue_discard_granularity (q,0 ); - } -} -static void fixup_write_zeroes (struct drbd_device *device,struct request_queue *q) {/* Fixup max_write_zeroes_sectors after blk_stack_limits():
@@ -1300,7 +1286,6 @@ static void drbd_setup_queue_param(struct drbd_device *device, struct drbd_backiblk_stack_limits (&q->limits, &b->limits,0 );disk_update_readahead (device->vdisk); } -fixup_discard_if_not_supported (q);fixup_write_zeroes (device, q); }
@@ -1447,7 +1432,7 @@ static void sanitize_disk_conf(struct drbd_device *device, struct disk_conf *disif (disk_conf->al_extents >drbd_al_extents_max (nbc)) disk_conf->al_extents =drbd_al_extents_max (nbc); -if (!blk_queue_discard (q)) { +if (!bdev_max_discard_sectors (bdev)) {if (disk_conf->rs_discard_granularity) { disk_conf->rs_discard_granularity =0 ;/* disable feature */ drbd_info (device,"rs_discard_granularity feature disabled\n" );
drivers/block/drbd/drbd_receiver.c +1 -2
@@ -1575,11 +1575,10 @@ int drbd_issue_discard_or_zero_out(struct drbd_device *device, sector_t start, ustatic bool can_do_reliable_discards (struct drbd_device *device) { -struct request_queue *q =bdev_get_queue (device->ldev->backing_bdev);struct disk_conf *dc;bool can_do; -if (!blk_queue_discard (q)) +if (!bdev_max_discard_sectors (device->ldev->backing_bdev))return false;rcu_read_lock ();
drivers/block/loop.c +3 -8
@@ -314,15 +314,12 @@ static int lo_fallocate(struct loop_device *lo, struct request *rq, loff_t pos, mode |=FALLOC_FL_KEEP_SIZE ; -if (!blk_queue_discard (lo->lo_queue)) { - ret = -EOPNOTSUPP ; - goto out; - } +if (!bdev_max_discard_sectors (lo->lo_device)) +return -EOPNOTSUPP ; ret = file->f_op->fallocate (file, mode, pos,blk_rq_bytes (rq));if (unlikely (ret && ret != -EINVAL && ret != -EOPNOTSUPP )) - ret = -EIO ; - out: +return -EIO ;return ret; }
@@ -787,12 +784,10 @@ static void loop_config_discard(struct loop_device *lo) q->limits.discard_granularity = granularity;blk_queue_max_discard_sectors (q, max_discard_sectors);blk_queue_max_write_zeroes_sectors (q, max_discard_sectors); -blk_queue_flag_set (QUEUE_FLAG_DISCARD , q); }else { q->limits.discard_granularity =0 ;blk_queue_max_discard_sectors (q,0 );blk_queue_max_write_zeroes_sectors (q,0 ); -blk_queue_flag_clear (QUEUE_FLAG_DISCARD , q); } q->limits.discard_alignment =0 ; }
drivers/block/nbd.c +1 -4
@@ -1231,8 +1231,6 @@ static void nbd_parse_flags(struct nbd_device *nbd)set_disk_ro (nbd->disk, true); else set_disk_ro(nbd->disk, false); -if (config->flags &NBD_FLAG_SEND_TRIM ) -blk_queue_flag_set (QUEUE_FLAG_DISCARD , nbd->disk->queue);if (config->flags &NBD_FLAG_SEND_FLUSH ) {if (config->flags &NBD_FLAG_SEND_FUA )blk_queue_write_cache (nbd->disk->queue, true, true);
@@ -1319,8 +1317,7 @@ static void nbd_config_put(struct nbd_device *nbd) nbd->tag_set.timeout =0 ; nbd->disk->queue->limits.discard_granularity =0 ; nbd->disk->queue->limits.discard_alignment =0 ; -blk_queue_max_discard_sectors (nbd->disk->queue,UINT_MAX ); -blk_queue_flag_clear (QUEUE_FLAG_DISCARD , nbd->disk->queue); +blk_queue_max_discard_sectors (nbd->disk->queue,0 );mutex_unlock (&nbd->config_lock);nbd_put (nbd);
drivers/block/null_blk/main.c +0 -1
@@ -1767,7 +1767,6 @@ static void null_config_discard(struct nullb *nullb) nullb->q->limits.discard_granularity = nullb->dev->blocksize; nullb->q->limits.discard_alignment = nullb->dev->blocksize;blk_queue_max_discard_sectors (nullb->q,UINT_MAX >>9 ); -blk_queue_flag_set (QUEUE_FLAG_DISCARD , nullb->q); }static const struct block_device_operations null_bio_ops = {
drivers/block/rbd.c +0 -1
@@ -4942,7 +4942,6 @@ static int rbd_init_disk(struct rbd_device *rbd_dev)blk_queue_io_opt (q, rbd_dev->opts->alloc_size);if (rbd_dev->opts->trim) { -blk_queue_flag_set (QUEUE_FLAG_DISCARD , q); q->limits.discard_granularity = rbd_dev->opts->alloc_size;blk_queue_max_discard_sectors (q, objset_bytes >>SECTOR_SHIFT );blk_queue_max_write_zeroes_sectors (q, objset_bytes >>SECTOR_SHIFT );
drivers/block/rnbd/rnbd-clt.c +0 -2
@@ -1364,8 +1364,6 @@ static void setup_request_queue(struct rnbd_clt_dev *dev)blk_queue_max_discard_sectors (dev->queue, dev->max_discard_sectors); dev->queue->limits.discard_granularity = dev->discard_granularity; dev->queue->limits.discard_alignment = dev->discard_alignment; -if (dev->max_discard_sectors) -blk_queue_flag_set (QUEUE_FLAG_DISCARD , dev->queue);if (dev->secure_discard)blk_queue_flag_set (QUEUE_FLAG_SECERASE , dev->queue);
drivers/block/rnbd/rnbd-srv-dev.h +0 -3
@@ -49,9 +49,6 @@ static inline int rnbd_dev_get_secure_discard(const struct rnbd_dev *dev)static inline int rnbd_dev_get_max_discard_sects (const struct rnbd_dev *dev) { -if (!blk_queue_discard (bdev_get_queue (dev->bdev))) -return 0 ; -return bdev_max_discard_sectors (dev->bdev); }
drivers/block/virtio_blk.c +0 -2
@@ -888,8 +888,6 @@ static int virtblk_probe(struct virtio_device *vdev) v = sg_elems;blk_queue_max_discard_segments (q,min (v,MAX_DISCARD_SEGMENTS )); - -blk_queue_flag_set (QUEUE_FLAG_DISCARD , q); }if (virtio_has_feature (vdev,VIRTIO_BLK_F_WRITE_ZEROES )) {
drivers/block/xen-blkback/xenbus.c +1 -1
@@ -583,7 +583,7 @@ static void xen_blkbk_discard(struct xenbus_transaction xbt, struct backend_infoif (!xenbus_read_unsigned (dev->nodename,"discard-enable" ,1 ))return ; -if (blk_queue_discard (q)) { +if (bdev_max_discard_sectors (bdev)) { err =xenbus_printf (xbt, dev->nodename,"discard-granularity" ,"%u" , q->limits.discard_granularity);
drivers/block/xen-blkfront.c +1 -2
@@ -944,7 +944,6 @@ static void blkif_set_queue_limits(struct blkfront_info *info)blk_queue_flag_set (QUEUE_FLAG_VIRT , rq);if (info->feature_discard) { -blk_queue_flag_set (QUEUE_FLAG_DISCARD , rq);blk_queue_max_discard_sectors (rq,get_capacity (gd)); rq->limits.discard_granularity = info->discard_granularity ?: info->physical_sector_size;
@@ -1606,7 +1605,7 @@ static irqreturn_t blkif_interrupt(int irq, void *dev_id)blkif_req (req)->error =BLK_STS_NOTSUPP ; info->feature_discard =0 ; info->feature_secdiscard =0 ; -blk_queue_flag_clear (QUEUE_FLAG_DISCARD , rq); +blk_queue_max_discard_sectors (rq,0 );blk_queue_flag_clear (QUEUE_FLAG_SECERASE , rq); }break ;
drivers/block/zram/zram_drv.c +0 -1
@@ -1952,7 +1952,6 @@ static int zram_add(void)blk_queue_io_opt (zram->disk->queue,PAGE_SIZE ); zram->disk->queue->limits.discard_granularity =PAGE_SIZE ;blk_queue_max_discard_sectors (zram->disk->queue,UINT_MAX ); -blk_queue_flag_set (QUEUE_FLAG_DISCARD , zram->disk->queue);/* * zram_bio_discard() will clear all logical blocks if logical block
drivers/md/bcache/request.c +2 -2
@@ -1005,7 +1005,7 @@ static void cached_dev_write(struct cached_dev *dc, struct search *s)bio_get (s->iop.bio);if (bio_op (bio) ==REQ_OP_DISCARD && - !blk_queue_discard (bdev_get_queue (dc->bdev))) + !bdev_max_discard_sectors (dc->bdev)) goto insert_data;/* I/O request sent to backing device */
@@ -1115,7 +1115,7 @@ static void detached_dev_do_request(struct bcache_device *d, struct bio *bio, bio->bi_private = ddip;if ((bio_op (bio) ==REQ_OP_DISCARD ) && - !blk_queue_discard (bdev_get_queue (dc->bdev))) + !bdev_max_discard_sectors (dc->bdev)) bio->bi_end_io (bio);else submit_bio_noacct (bio);
drivers/md/bcache/super.c +1 -2
@@ -973,7 +973,6 @@ static int bcache_device_init(struct bcache_device *d, unsigned int block_size,blk_queue_flag_set (QUEUE_FLAG_NONROT , d->disk->queue);blk_queue_flag_clear (QUEUE_FLAG_ADD_RANDOM , d->disk->queue); -blk_queue_flag_set (QUEUE_FLAG_DISCARD , d->disk->queue);blk_queue_write_cache (q, true, true);
@@ -2350,7 +2349,7 @@ static int register_cache(struct cache_sb *sb, struct cache_sb_disk *sb_disk, ca->bdev->bd_holder = ca; ca->sb_disk = sb_disk; -if (blk_queue_discard (bdev_get_queue (bdev))) +if (bdev_max_discard_sectors ((bdev))) ca->discard =CACHE_DISCARD (&ca->sb); ret =cache_alloc (ca);
drivers/md/bcache/sysfs.c +1 -1
@@ -1151,7 +1151,7 @@ STORE(__bch_cache)if (attr == &sysfs_discard) {bool v =strtoul_or_return (buf); -if (blk_queue_discard (bdev_get_queue (ca->bdev))) +if (bdev_max_discard_sectors (ca->bdev)) ca->discard = v;if (v !=CACHE_DISCARD (&ca->sb)) {
drivers/md/dm-cache-target.c +1 -8
@@ -3329,13 +3329,6 @@ static int cache_iterate_devices(struct dm_target *ti,return r; } -static bool origin_dev_supports_discard (struct block_device *origin_bdev) -{ -struct request_queue *q =bdev_get_queue (origin_bdev); - -return blk_queue_discard (q); -} -/* * If discard_passdown was enabled verify that the origin device * supports discards. Disable discard_passdown if not.
@@ -3349,7 +3342,7 @@ static void disable_passdown_if_not_supported(struct cache *cache)if (!cache->features.discard_passdown)return ; -if (!origin_dev_supports_discard (origin_bdev)) +if (!bdev_max_discard_sectors (origin_bdev)) reason ="discard unsupported" ;else if (origin_limits->max_discard_sectors < cache->sectors_per_block)
drivers/md/dm-clone-target.c +1 -8
@@ -2016,13 +2016,6 @@ static void clone_resume(struct dm_target *ti)do_waker (&clone->waker.work); } -static bool bdev_supports_discards (struct block_device *bdev) -{ -struct request_queue *q =bdev_get_queue (bdev); - -return (q &&blk_queue_discard (q)); -} -/* * If discard_passdown was enabled verify that the destination device supports * discards. Disable discard_passdown if not.
@@ -2036,7 +2029,7 @@ static void disable_passdown_if_not_supported(struct clone *clone)if (!test_bit (DM_CLONE_DISCARD_PASSDOWN , &clone->flags))return ; -if (!bdev_supports_discards (dest_dev)) +if (!bdev_max_discard_sectors (dest_dev)) reason ="discard unsupported" ;else if (dest_limits->max_discard_sectors < clone->region_size) reason ="max discard sectors smaller than a region" ;
drivers/md/dm-log-writes.c +1 -2
@@ -866,9 +866,8 @@ static int log_writes_message(struct dm_target *ti, unsigned argc, char **argv,static void log_writes_io_hints (struct dm_target *ti,struct queue_limits *limits) {struct log_writes_c *lc = ti->private; -struct request_queue *q =bdev_get_queue (lc->dev->bdev); -if (!q || !blk_queue_discard (q)) { +if (!bdev_max_discard_sectors (lc->dev->bdev)) { lc->device_supports_discard = false; limits->discard_granularity = lc->sectorsize; limits->max_discard_sectors = (UINT_MAX >>SECTOR_SHIFT );
drivers/md/dm-raid.c +2 -7
@@ -2963,13 +2963,8 @@ static void configure_discard_support(struct raid_set *rs) raid456 =rs_is_raid456 (rs);for (i =0 ; i < rs->raid_disks; i++) { -struct request_queue *q; - -if (!rs->dev[i].rdev.bdev) -continue ; - - q =bdev_get_queue (rs->dev[i].rdev.bdev); -if (!q || !blk_queue_discard (q)) +if (!rs->dev[i].rdev.bdev || + !bdev_max_discard_sectors (rs->dev[i].rdev.bdev))return ;if (raid456) {
drivers/md/dm-table.c +2 -7
@@ -1888,9 +1888,7 @@ static bool dm_table_supports_nowait(struct dm_table *t)static int device_not_discard_capable (struct dm_target *ti,struct dm_dev *dev,sector_t start,sector_t len,void *data) { -struct request_queue *q =bdev_get_queue (dev->bdev); - -return !blk_queue_discard (q); +return !bdev_max_discard_sectors (dev->bdev); }static bool dm_table_supports_discards (struct dm_table *t)
@@ -1970,15 +1968,12 @@ int dm_table_set_restrictions(struct dm_table *t, struct request_queue *q,blk_queue_flag_clear (QUEUE_FLAG_NOWAIT , q);if (!dm_table_supports_discards (t)) { -blk_queue_flag_clear (QUEUE_FLAG_DISCARD , q); -/* Must also clear discard limits... */ q->limits.max_discard_sectors =0 ; q->limits.max_hw_discard_sectors =0 ; q->limits.discard_granularity =0 ; q->limits.discard_alignment =0 ; q->limits.discard_misaligned =0 ; - }else -blk_queue_flag_set (QUEUE_FLAG_DISCARD , q); + }if (dm_table_supports_secure_erase (t))blk_queue_flag_set (QUEUE_FLAG_SECERASE , q);
drivers/md/dm-thin.c +1 -10
@@ -2802,13 +2802,6 @@ static void requeue_bios(struct pool *pool)/*---------------------------------------------------------------- * Binding of control targets to a pool object *--------------------------------------------------------------*/ -static bool data_dev_supports_discard (struct pool_c *pt) -{ -struct request_queue *q =bdev_get_queue (pt->data_dev->bdev); - -return blk_queue_discard (q); -} -static bool is_factor (sector_t block_size,uint32_t n) {return !sector_div (block_size, n);
@@ -2828,7 +2821,7 @@ static void disable_passdown_if_not_supported(struct pool_c *pt)if (!pt->adjusted_pf.discard_passdown)return ; -if (!data_dev_supports_discard (pt)) +if (!bdev_max_discard_sectors (pt->data_dev->bdev)) reason ="discard unsupported" ;else if (data_limits->max_discard_sectors < pool->sectors_per_block)
@@ -4057,8 +4050,6 @@ static void pool_io_hints(struct dm_target *ti, struct queue_limits *limits)/* * Must explicitly disallow stacking discard limits otherwise the * block layer will stack them if pool's data device has support. -* QUEUE_FLAG_DISCARD wouldn't be set but there is no way for the -* user to see that, so make sure to set all discard limits to 0. */ limits->discard_granularity =0 ;return ;
drivers/md/dm.c +1 -2
@@ -955,7 +955,6 @@ void disable_discard(struct mapped_device *md)/* device doesn't really support DISCARD, disable it */ limits->max_discard_sectors =0 ; -blk_queue_flag_clear (QUEUE_FLAG_DISCARD , md->queue); }void disable_write_zeroes (struct mapped_device *md)
@@ -982,7 +981,7 @@ static void clone_endio(struct bio *bio)if (unlikely (error ==BLK_STS_TARGET )) {if (bio_op (bio) ==REQ_OP_DISCARD && - !q->limits.max_discard_sectors) + !bdev_max_discard_sectors (bio->bi_bdev))disable_discard (md);else if (bio_op (bio) ==REQ_OP_WRITE_ZEROES && !q->limits.max_write_zeroes_sectors)
drivers/md/md-linear.c +1 -10
@@ -64,7 +64,6 @@ static struct linear_conf *linear_conf(struct mddev *mddev, int raid_disks)struct linear_conf *conf;struct md_rdev *rdev;int i, cnt; -bool discard_supported = false; conf =kzalloc (struct_size (conf, disks, raid_disks),GFP_KERNEL );if (!conf)
@@ -96,9 +95,6 @@ static struct linear_conf *linear_conf(struct mddev *mddev, int raid_disks) conf->array_sectors += rdev->sectors; cnt++; - -if (blk_queue_discard (bdev_get_queue (rdev->bdev))) - discard_supported = true; }if (cnt != raid_disks) { pr_warn("md/linear:%s: not enough drives present. Aborting!\n",
@@ -106,11 +102,6 @@ static struct linear_conf *linear_conf(struct mddev *mddev, int raid_disks) goto out; } -if (!discard_supported) -blk_queue_flag_clear (QUEUE_FLAG_DISCARD , mddev->queue); -else -blk_queue_flag_set (QUEUE_FLAG_DISCARD , mddev->queue); -/* * Here we calculate the device offsets. */
@@ -252,7 +243,7 @@ static bool linear_make_request(struct mddev *mddev, struct bio *bio) start_sector + data_offset;if (unlikely ((bio_op (bio) ==REQ_OP_DISCARD ) && - !blk_queue_discard (bio->bi_bdev->bd_disk->queue))) { + !bdev_max_discard_sectors (bio->bi_bdev))) {/* Just ignore it */ bio_endio (bio); }else {
drivers/md/raid0.c +0 -7
@@ -399,7 +399,6 @@ static int raid0_run(struct mddev *mddev) conf = mddev->private;if (mddev->queue) {struct md_rdev *rdev; -bool discard_supported = false;blk_queue_max_hw_sectors (mddev->queue, mddev->chunk_sectors);blk_queue_max_write_zeroes_sectors (mddev->queue, mddev->chunk_sectors);
@@ -412,13 +411,7 @@ static int raid0_run(struct mddev *mddev)rdev_for_each (rdev, mddev) {disk_stack_limits (mddev->gendisk, rdev->bdev, rdev->data_offset <<9 ); -if (blk_queue_discard (bdev_get_queue (rdev->bdev))) - discard_supported = true; } -if (!discard_supported) -blk_queue_flag_clear (QUEUE_FLAG_DISCARD , mddev->queue); -else -blk_queue_flag_set (QUEUE_FLAG_DISCARD , mddev->queue); }/* calculate array device size */
drivers/md/raid1.c +1 -15
@@ -802,7 +802,7 @@ static void flush_bio_list(struct r1conf *conf, struct bio *bio)if (test_bit (Faulty, &rdev->flags)) {bio_io_error (bio); }else if (unlikely ((bio_op (bio) ==REQ_OP_DISCARD ) && - !blk_queue_discard (bio->bi_bdev->bd_disk->queue))) + !bdev_max_discard_sectors (bio->bi_bdev)))/* Just ignore it */ bio_endio (bio);else
@@ -1826,8 +1826,6 @@ static int raid1_add_disk(struct mddev *mddev, struct md_rdev *rdev)break ; } } -if (mddev->queue &&blk_queue_discard (bdev_get_queue (rdev->bdev))) -blk_queue_flag_set (QUEUE_FLAG_DISCARD , mddev->queue);print_conf (conf);return err; }
@@ -3106,7 +3104,6 @@ static int raid1_run(struct mddev *mddev)int i;struct md_rdev *rdev;int ret; -bool discard_supported = false;if (mddev->level !=1 ) { pr_warn("md/raid1:%s: raid level not set to mirroring (%d)\n",
@@ -3141,8 +3138,6 @@ static int raid1_run(struct mddev *mddev)continue ;disk_stack_limits (mddev->gendisk, rdev->bdev, rdev->data_offset <<9 ); -if (blk_queue_discard (bdev_get_queue (rdev->bdev))) - discard_supported = true; } mddev->degraded =0 ;
@@ -3179,15 +3174,6 @@ static int raid1_run(struct mddev *mddev)md_set_array_sectors (mddev,raid1_size (mddev,0 ,0 )); -if (mddev->queue) { -if (discard_supported) -blk_queue_flag_set (QUEUE_FLAG_DISCARD , - mddev->queue); -else -blk_queue_flag_clear (QUEUE_FLAG_DISCARD , - mddev->queue); - } - ret =md_integrity_register (mddev);if (ret) {md_unregister_thread (&mddev->thread);
drivers/md/raid10.c +2 -16
@@ -888,7 +888,7 @@ static void flush_pending_writes(struct r10conf *conf)if (test_bit (Faulty, &rdev->flags)) {bio_io_error (bio); }else if (unlikely ((bio_op (bio) ==REQ_OP_DISCARD ) && - !blk_queue_discard (bio->bi_bdev->bd_disk->queue))) + !bdev_max_discard_sectors (bio->bi_bdev)))/* Just ignore it */ bio_endio (bio);else
@@ -1083,7 +1083,7 @@ static void raid10_unplug(struct blk_plug_cb *cb, bool from_schedule)if (test_bit (Faulty, &rdev->flags)) {bio_io_error (bio); }else if (unlikely ((bio_op (bio) ==REQ_OP_DISCARD ) && - !blk_queue_discard (bio->bi_bdev->bd_disk->queue))) + !bdev_max_discard_sectors (bio->bi_bdev)))/* Just ignore it */ bio_endio (bio);else
@@ -2144,8 +2144,6 @@ static int raid10_add_disk(struct mddev *mddev, struct md_rdev *rdev)rcu_assign_pointer (p->rdev, rdev);break ; } -if (mddev->queue &&blk_queue_discard (bdev_get_queue (rdev->bdev))) -blk_queue_flag_set (QUEUE_FLAG_DISCARD , mddev->queue);print_conf (conf);return err;
@@ -4069,7 +4067,6 @@ static int raid10_run(struct mddev *mddev)sector_t size;sector_t min_offset_diff =0 ;int first =1 ; -bool discard_supported = false;if (mddev_init_writes_pending (mddev) <0 )return -ENOMEM ;
@@ -4140,20 +4137,9 @@ static int raid10_run(struct mddev *mddev) rdev->data_offset << 9); disk->head_position =0 ; - -if (blk_queue_discard (bdev_get_queue (rdev->bdev))) - discard_supported = true; first =0 ; } -if (mddev->queue) { -if (discard_supported) -blk_queue_flag_set (QUEUE_FLAG_DISCARD , - mddev->queue); -else -blk_queue_flag_clear (QUEUE_FLAG_DISCARD , - mddev->queue); - }/* need to check that every block has at least one working mirror */ if (!enough (conf,-1 )) { pr_err("md/raid10:%s: not enough operational mirrors.\n",
drivers/md/raid5-cache.c +1 -1
@@ -1318,7 +1318,7 @@ static void r5l_write_super_and_discard_space(struct r5l_log *log,r5l_write_super (log, end); -if (!blk_queue_discard (bdev_get_queue (bdev))) +if (!bdev_max_discard_sectors (bdev))return ; mddev = log->rdev->mddev;
drivers/md/raid5.c +4 -8
@@ -7776,14 +7776,10 @@ static int raid5_run(struct mddev *mddev)* 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) -blk_queue_flag_set (QUEUE_FLAG_DISCARD , - mddev->queue); -else -blk_queue_flag_clear (QUEUE_FLAG_DISCARD , - mddev->queue); +if (!devices_handle_discard_safely || + mddev->queue->limits.max_discard_sectors < (stripe >>9 ) || + mddev->queue->limits.discard_granularity < stripe) +blk_queue_max_discard_sectors (mddev->queue,0 );blk_queue_max_hw_sectors (mddev->queue,UINT_MAX ); }
drivers/mmc/core/queue.c +0 -1
@@ -183,7 +183,6 @@ static void mmc_queue_setup_discard(struct request_queue *q,if (!max_discard)return ; -blk_queue_flag_set (QUEUE_FLAG_DISCARD , q);blk_queue_max_discard_sectors (q, max_discard); q->limits.discard_granularity = card->pref_erase <<9 ;/* granularity must not be greater than max. discard */
drivers/mtd/mtd_blkdevs.c +0 -1
@@ -377,7 +377,6 @@ int add_mtd_blktrans_dev(struct mtd_blktrans_dev *new)blk_queue_flag_clear (QUEUE_FLAG_ADD_RANDOM , new->rq);if (tr->discard) { -blk_queue_flag_set (QUEUE_FLAG_DISCARD , new->rq);blk_queue_max_discard_sectors (new->rq,UINT_MAX ); new->rq->limits.discard_granularity = tr->blksize; }
drivers/nvme/host/core.c +2 -2
@@ -1608,7 +1608,7 @@ static void nvme_config_discard(struct gendisk *disk, struct nvme_ns *ns)u32 size =queue_logical_block_size (queue);if (ctrl->max_discard_sectors ==0 ) { -blk_queue_flag_clear (QUEUE_FLAG_DISCARD , queue); +blk_queue_max_discard_sectors (queue,0 );return ; }
@@ -1619,7 +1619,7 @@ static void nvme_config_discard(struct gendisk *disk, struct nvme_ns *ns) queue->limits.discard_granularity = size;/* If discard is already enabled, don't reset queue limits */ -if (blk_queue_flag_test_and_set (QUEUE_FLAG_DISCARD , queue)) +if (queue->limits.max_discard_sectors)return ;blk_queue_max_discard_sectors (queue, ctrl->max_discard_sectors);
drivers/s390/block/dasd_fba.c +0 -1
@@ -791,7 +791,6 @@ static void dasd_fba_setup_blk_queue(struct dasd_block *block)blk_queue_max_discard_sectors (q, max_discard_sectors);blk_queue_max_write_zeroes_sectors (q, max_discard_sectors); -blk_queue_flag_set (QUEUE_FLAG_DISCARD , q); } static int dasd_fba_pe_handler(struct dasd_device *device,
drivers/scsi/sd.c +0 -2
@@ -797,7 +797,6 @@ static void sd_config_discard(struct scsi_disk *sdkp, unsigned int mode)case SD_LBP_FULL :case SD_LBP_DISABLE :blk_queue_max_discard_sectors (q,0 ); -blk_queue_flag_clear (QUEUE_FLAG_DISCARD , q);return ;case SD_LBP_UNMAP :
@@ -830,7 +829,6 @@ static void sd_config_discard(struct scsi_disk *sdkp, unsigned int mode) }blk_queue_max_discard_sectors (q, max_blocks * (logical_block_size >>9 )); -blk_queue_flag_set (QUEUE_FLAG_DISCARD , q); }static blk_status_t sd_setup_unmap_cmnd (struct scsi_cmnd *cmd)
drivers/target/target_core_device.c +1 -1
@@ -838,7 +838,7 @@ bool target_configure_unmap_from_queue(struct se_dev_attrib *attrib,struct request_queue *q =bdev_get_queue (bdev);int block_size =bdev_logical_block_size (bdev); -if (!blk_queue_discard (q)) +if (!bdev_max_discard_sectors (bdev))return false; attrib->max_unmap_lba_count =
fs/btrfs/extent-tree.c +2 -2
@@ -1291,7 +1291,7 @@ static int do_discard_extent(struct btrfs_io_stripe *stripe, u64 *bytes) ret =btrfs_reset_device_zone (dev_replace->tgtdev, phys, len, &discarded); discarded += src_disc; - }else if (blk_queue_discard (bdev_get_queue (stripe->dev->bdev))) { + }else if (bdev_max_discard_sectors (stripe->dev->bdev)) { ret =btrfs_issue_discard (dev->bdev, phys, len, &discarded); }else { ret =0 ;
@@ -5987,7 +5987,7 @@ static int btrfs_trim_free_extents(struct btrfs_device *device, u64 *trimmed) *trimmed =0 ;/* Discard not supported = nothing to do. */ -if (!blk_queue_discard (bdev_get_queue (device->bdev))) +if (!bdev_max_discard_sectors (device->bdev))return 0 ;/* Not writable = nothing to do. */
fs/btrfs/ioctl.c +1 -1
@@ -501,7 +501,7 @@ static noinline int btrfs_ioctl_fitrim(struct btrfs_fs_info *fs_info,if (!device->bdev)continue ; q =bdev_get_queue (device->bdev); -if (blk_queue_discard (q)) { +if (bdev_max_discard_sectors (device->bdev)) { num_devices++; minlen =min_t (u64, q->limits.discard_granularity, minlen);
fs/exfat/file.c +1 -1
@@ -358,7 +358,7 @@ static int exfat_ioctl_fitrim(struct inode *inode, unsigned long arg)if (!capable (CAP_SYS_ADMIN ))return -EPERM ; -if (!blk_queue_discard (q)) +if (!bdev_max_discard_sectors (inode->i_sb->s_bdev))return -EOPNOTSUPP ;if (copy_from_user (&range, (struct fstrim_range __user *)arg,sizeof (range)))
fs/exfat/super.c +3 -7
@@ -627,13 +627,9 @@ static int exfat_fill_super(struct super_block *sb, struct fs_context *fc)if (opts->allow_utime == (unsigned short )-1 ) opts->allow_utime = ~opts->fs_dmask &0022 ; -if (opts->discard) { -struct request_queue *q =bdev_get_queue (sb->s_bdev); - -if (!blk_queue_discard (q)) { -exfat_warn (sb,"mounting with \"discard\" option, but the device does not support discard" ); - opts->discard =0 ; - } +if (opts->discard && !bdev_max_discard_sectors (sb->s_bdev)) { +exfat_warn (sb,"mounting with \"discard\" option, but the device does not support discard" ); + opts->discard =0 ; } sb->s_flags |=SB_NODIRATIME ;
fs/ext4/ioctl.c +3 -7
@@ -1044,7 +1044,6 @@ static int ext4_ioctl_checkpoint(struct file *filp, unsigned long arg)__u32 flags =0 ;unsigned int flush_flags =0 ;struct super_block *sb =file_inode (filp)->i_sb; -struct request_queue *q;if (copy_from_user (&flags, (__u32 __user *)arg,sizeof (__u32)))
@@ -1065,10 +1064,8 @@ static int ext4_ioctl_checkpoint(struct file *filp, unsigned long arg)if (flags & ~EXT4_IOC_CHECKPOINT_FLAG_VALID )return -EINVAL ; - q =bdev_get_queue (EXT4_SB (sb)->s_journal->j_dev); -if (!q) -return -ENXIO ; -if ((flags &JBD2_JOURNAL_FLUSH_DISCARD ) && !blk_queue_discard (q)) +if ((flags &JBD2_JOURNAL_FLUSH_DISCARD ) && + !bdev_max_discard_sectors (EXT4_SB (sb)->s_journal->j_dev))return -EOPNOTSUPP ;if (flags &EXT4_IOC_CHECKPOINT_FLAG_DRY_RUN )
@@ -1393,14 +1390,13 @@ static long __ext4_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)case FITRIM : { -struct request_queue *q =bdev_get_queue (sb->s_bdev);struct fstrim_range range;int ret =0 ;if (!capable (CAP_SYS_ADMIN ))return -EPERM ; -if (!blk_queue_discard (q)) +if (!bdev_max_discard_sectors (sb->s_bdev))return -EOPNOTSUPP ;/*
fs/ext4/super.c +3 -7
@@ -5458,13 +5458,9 @@ static int __ext4_fill_super(struct fs_context *fc, struct super_block *sb) goto failed_mount9; } -if (test_opt (sb,DISCARD )) { -struct request_queue *q =bdev_get_queue (sb->s_bdev); -if (!blk_queue_discard (q)) -ext4_msg (sb,KERN_WARNING , -"mounting with \"discard\" option, but " -"the device does not support discard" ); - } +if (test_opt (sb,DISCARD ) && !bdev_max_discard_sectors (sb->s_bdev)) +ext4_msg (sb,KERN_WARNING , +"mounting with \"discard\" option, but the device does not support discard" );if (es->s_error_count)mod_timer (&sbi->s_err_report, jiffies +300 *HZ );/* 5 minutes */
fs/f2fs/f2fs.h +1 -2
@@ -4381,8 +4381,7 @@ static inline bool f2fs_hw_should_discard(struct f2fs_sb_info *sbi)static inline bool f2fs_bdev_support_discard (struct block_device *bdev) { -return blk_queue_discard (bdev_get_queue (bdev)) || -bdev_is_zoned (bdev); +return bdev_max_discard_sectors (bdev) ||bdev_is_zoned (bdev); }static inline bool f2fs_hw_support_discard (struct f2fs_sb_info *sbi)
fs/fat/file.c +1 -1
@@ -133,7 +133,7 @@ static int fat_ioctl_fitrim(struct inode *inode, unsigned long arg)if (!capable (CAP_SYS_ADMIN ))return -EPERM ; -if (!blk_queue_discard (q)) +if (!bdev_max_discard_sectors (sb->s_bdev))return -EOPNOTSUPP ; user_range = (struct fstrim_range __user *)arg;
fs/fat/inode.c +3 -7
@@ -1872,13 +1872,9 @@ int fat_fill_super(struct super_block *sb, void *data, int silent, int isvfat, goto out_fail; } -if (sbi->options.discard) { -struct request_queue *q =bdev_get_queue (sb->s_bdev); -if (!blk_queue_discard (q)) -fat_msg (sb,KERN_WARNING , -"mounting with \"discard\" option, but " -"the device does not support discard" ); - } +if (sbi->options.discard && !bdev_max_discard_sectors (sb->s_bdev)) +fat_msg (sb,KERN_WARNING , +"mounting with \"discard\" option, but the device does not support discard" );fat_set_state (sb,1 ,0 );return 0 ;
fs/gfs2/rgrp.c +1 -1
@@ -1405,7 +1405,7 @@ int gfs2_fitrim(struct file *filp, void __user *argp)if (!test_bit (SDF_JOURNAL_LIVE , &sdp->sd_flags))return -EROFS ; -if (!blk_queue_discard (q)) +if (!bdev_max_discard_sectors (sdp->sd_vfs->s_bdev))return -EOPNOTSUPP ;if (copy_from_user (&r, argp,sizeof (r)))
fs/jbd2/journal.c +2 -5
@@ -1762,7 +1762,6 @@ static int __jbd2_journal_erase(journal_t *journal, unsigned int flags)unsigned long block, log_offset;/* logical */ unsigned long long phys_block, block_start, block_stop;/* physical */ loff_t byte_start, byte_stop, byte_count; -struct request_queue *q =bdev_get_queue (journal->j_dev);/* flags must be set to either discard or zeroout */ if ((flags & ~JBD2_JOURNAL_FLUSH_VALID) || !flags ||
@@ -1770,10 +1769,8 @@ static int __jbd2_journal_erase(journal_t *journal, unsigned int flags) (flags & JBD2_JOURNAL_FLUSH_ZEROOUT)))return -EINVAL ; -if (!q) -return -ENXIO ; - -if ((flags &JBD2_JOURNAL_FLUSH_DISCARD ) && !blk_queue_discard (q)) +if ((flags &JBD2_JOURNAL_FLUSH_DISCARD ) && + !bdev_max_discard_sectors (journal->j_dev))return -EOPNOTSUPP ;/*
fs/jfs/ioctl.c +1 -1
@@ -117,7 +117,7 @@ long jfs_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)if (!capable (CAP_SYS_ADMIN ))return -EPERM ; -if (!blk_queue_discard (q)) { +if (!bdev_max_discard_sectors (sb->s_bdev)) {jfs_warn ("FITRIM not supported on device" );return -EOPNOTSUPP ; }
fs/jfs/super.c +2 -6
@@ -372,19 +372,16 @@ static int parse_options(char *options, struct super_block *sb, s64 *newLVSize, }case Opt_discard: - { -struct request_queue *q =bdev_get_queue (sb->s_bdev);/* if set to 1, even copying files will cause * trimming :O * -> user has more control over the online trimming */ sbi->minblks_trim =64 ; -if (blk_queue_discard (q)) +if (bdev_max_discard_sectors (sb->s_bdev)) *flag |=JFS_DISCARD ;else pr_err ("JFS: discard option not supported on device\n" );break ; - }case Opt_nodiscard: *flag &= ~JFS_DISCARD ;
@@ -392,10 +389,9 @@ static int parse_options(char *options, struct super_block *sb, s64 *newLVSize,case Opt_discard_minblk: { -struct request_queue *q =bdev_get_queue (sb->s_bdev);char *minblks_trim = args[0 ].from;int rc; -if (blk_queue_discard (q)) { +if (bdev_max_discard_sectors (sb->s_bdev)) { *flag |=JFS_DISCARD ; rc =kstrtouint (minblks_trim,0 , &sbi->minblks_trim);
fs/nilfs2/ioctl.c +1 -1
@@ -1059,7 +1059,7 @@ static int nilfs_ioctl_trim_fs(struct inode *inode, void __user *argp)if (!capable (CAP_SYS_ADMIN ))return -EPERM ; -if (!blk_queue_discard (q)) +if (!bdev_max_discard_sectors (nilfs->ns_bdev))return -EOPNOTSUPP ;if (copy_from_user (&range, argp,sizeof (range)))
fs/ntfs3/file.c +1 -1
@@ -28,7 +28,7 @@ static int ntfs_ioctl_fitrim(struct ntfs_sb_info *sbi, unsigned long arg)if (!capable (CAP_SYS_ADMIN ))return -EPERM ; -if (!blk_queue_discard (q)) +if (!bdev_max_discard_sectors (sbi->sb->s_bdev))return -EOPNOTSUPP ; user_range = (struct fstrim_range __user *)arg;
fs/ntfs3/super.c +1 -1
@@ -913,7 +913,7 @@ static int ntfs_fill_super(struct super_block *sb, struct fs_context *fc) } rq =bdev_get_queue (bdev); -if (blk_queue_discard (rq) && rq->limits.discard_granularity) { +if (bdev_max_discard_sectors (bdev) && rq->limits.discard_granularity) { sbi->discard_granularity = rq->limits.discard_granularity; sbi->discard_granularity_mask_inv = ~(u64)(sbi->discard_granularity -1 );
fs/ocfs2/ioctl.c +1 -1
@@ -910,7 +910,7 @@ long ocfs2_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)if (!capable (CAP_SYS_ADMIN ))return -EPERM ; -if (!blk_queue_discard (q)) +if (!bdev_max_discard_sectors (sb->s_bdev))return -EOPNOTSUPP ;if (copy_from_user (&range, argp,sizeof (range)))
fs/xfs/xfs_discard.c +1 -1
@@ -162,7 +162,7 @@ xfs_ioc_trim(if (!capable (CAP_SYS_ADMIN ))return -EPERM ; -if (!blk_queue_discard (q)) +if (!bdev_max_discard_sectors (mp->m_ddev_targp->bt_bdev))return -EOPNOTSUPP ;/*
fs/xfs/xfs_super.c +4 -8
@@ -1608,14 +1608,10 @@ xfs_fs_fill_super( goto out_filestream_unmount; } -if (xfs_has_discard (mp)) { -struct request_queue *q =bdev_get_queue (sb->s_bdev); - -if (!blk_queue_discard (q)) { -xfs_warn (mp,"mounting with \"discard\" option, but " -"the device does not support discard" ); - mp->m_features &= ~XFS_FEAT_DISCARD ; - } +if (xfs_has_discard (mp) && !bdev_max_discard_sectors (sb->s_bdev)) { +xfs_warn (mp, +"mounting with \"discard\" option, but the device does not support discard" ); + mp->m_features &= ~XFS_FEAT_DISCARD ; }if (xfs_has_reflink (mp)) {
include/linux/blkdev.h +0 -2
@@ -540,7 +540,6 @@ struct request_queue {#define QUEUE_FLAG_NONROT 6/* non-rotational device (SSD) */ #define QUEUE_FLAG_VIRT QUEUE_FLAG_NONROT/* paravirt device */ #define QUEUE_FLAG_IO_STAT 7/* do disk/partitions IO accounting */ -#define QUEUE_FLAG_DISCARD 8/* supports DISCARD */ #define QUEUE_FLAG_NOXMERGES 9/* No extended merges */ #define QUEUE_FLAG_ADD_RANDOM 10/* Contributes to random pool */ #define QUEUE_FLAG_SECERASE 11/* supports secure erase */
@@ -582,7 +581,6 @@ bool blk_queue_flag_test_and_set(unsigned int flag, struct request_queue *q); test_bit(QUEUE_FLAG_STABLE_WRITES, &(q)->queue_flags)#define blk_queue_io_stat (q) test_bit(QUEUE_FLAG_IO_STAT, &(q)->queue_flags)#define blk_queue_add_random (q) test_bit(QUEUE_FLAG_ADD_RANDOM, &(q)->queue_flags) -#define blk_queue_discard (q) test_bit(QUEUE_FLAG_DISCARD, &(q)->queue_flags)#define blk_queue_zone_resetall (q) \ test_bit(QUEUE_FLAG_ZONE_RESETALL, &(q)->queue_flags)#define blk_queue_secure_erase (q) \
mm/swapfile.c +2 -15
@@ -2957,20 +2957,6 @@ static int setup_swap_map_and_extents(struct swap_info_struct *p,return nr_extents; } -/* -* Helper to sys_swapon determining if a given swap -* backing device queue supports DISCARD operations. -*/ -static bool swap_discardable (struct swap_info_struct *si) -{ -struct request_queue *q =bdev_get_queue (si->bdev); - -if (!blk_queue_discard (q)) -return false; - -return true; -} - SYSCALL_DEFINE2(swapon, const char __user *, specialfile, int, swap_flags) {struct swap_info_struct *p;
@@ -3132,7 +3118,8 @@ SYSCALL_DEFINE2(swapon, const char __user *, specialfile, int, swap_flags)sizeof (long ), GFP_KERNEL); -if (p->bdev && (swap_flags &SWAP_FLAG_DISCARD ) &&swap_discardable (p)) { +if ((swap_flags &SWAP_FLAG_DISCARD ) && + p->bdev &&bdev_max_discard_sectors (p->bdev)) {/* * When discard is enabled for swap with no particular * policy flagged, we set all swap discard flags here in
Signature · 1 line
2.30.2
Re: [PATCH 24/27] block: remove QUEUE_FLAG_DISCARD
Quoted 7 lines · Christoph Hellwig
Just use a non-zero
max_discard_sectorsas an indicator for discard support, similar to what is done for write zeroes.The only places where needs special attention is the RAID5 driver, which must clear discard support for security reasons by default, even if the default stacking rules would allow for it.
Quoted 7 lines
Signed-off-by Christoph Hellwig <[email protected]>Reviewed-by Martin K. Petersen <[email protected]>Acked-by Coly Li <[email protected]> [bcache]---
Looks good.
-ck
Christoph Hellwig
maintainerPATCH 25/27 block: add a bdev_discard_granularity helper
In reply to Christoph HellwigAbstract away implementation details from file systems by providing a block_device based helper to retrieve the discard granularity.
--- block/blk-lib.c | 5 ++--- drivers/block/drbd/drbd_nl.c | 9 +++++---- drivers/block/drbd/drbd_receiver.c | 3 +-- drivers/block/loop.c | 2 +- drivers/target/target_core_device.c | 3 +-- fs/btrfs/ioctl.c | 12 ++++-------- fs/exfat/file.c | 3 +-- fs/ext4/mballoc.c | 6 +++--- fs/f2fs/file.c | 3 +-- fs/fat/file.c | 3 +-- fs/gfs2/rgrp.c | 7 +++---- fs/jfs/ioctl.c | 3 +-- fs/nilfs2/ioctl.c | 4 ++-- fs/ntfs3/file.c | 4 ++-- fs/ntfs3/super.c | 6 ++---- fs/ocfs2/ioctl.c | 3 +-- fs/xfs/xfs_discard.c | 4 ++-- include/linux/blkdev.h | 5 +++++ 18 files changed, 38 insertions(+), 47 deletions(-)
block/blk-lib.c +2 -3
@@ -12,8 +12,7 @@static sector_t bio_discard_limit (struct block_device *bdev,sector_t sector) { -unsigned int discard_granularity = -bdev_get_queue (bdev)->limits.discard_granularity; +unsigned int discard_granularity =bdev_discard_granularity (bdev);sector_t granularity_aligned_sector;if (bdev_is_partition (bdev))
@@ -59,7 +58,7 @@ int __blkdev_issue_discard(struct block_device *bdev, sector_t sector, }/* In case the discard granularity isn't set by buggy device driver */ -if (WARN_ON_ONCE (!q->limits.discard_granularity)) { +if (WARN_ON_ONCE (!bdev_discard_granularity (bdev))) {char dev_name[BDEVNAME_SIZE ];bdevname (bdev, dev_name);
drivers/block/drbd/drbd_nl.c +5 -4
@@ -1425,7 +1425,6 @@ static void sanitize_disk_conf(struct drbd_device *device, struct disk_conf *dis struct drbd_backing_dev *nbc) {struct block_device *bdev = nbc->backing_bdev; -struct request_queue *q = bdev->bd_disk->queue;if (disk_conf->al_extents <DRBD_AL_EXTENTS_MIN ) disk_conf->al_extents =DRBD_AL_EXTENTS_MIN ;
@@ -1442,12 +1441,14 @@ static void sanitize_disk_conf(struct drbd_device *device, struct disk_conf *disif (disk_conf->rs_discard_granularity) {int orig_value = disk_conf->rs_discard_granularity;sector_t discard_size =bdev_max_discard_sectors (bdev) <<9 ; +unsigned int discard_granularity =bdev_discard_granularity (bdev);int remainder; -if (q->limits.discard_granularity > disk_conf->rs_discard_granularity) - disk_conf->rs_discard_granularity = q->limits.discard_granularity; +if (discard_granularity > disk_conf->rs_discard_granularity) + disk_conf->rs_discard_granularity = discard_granularity; - remainder = disk_conf->rs_discard_granularity % q->limits.discard_granularity; + remainder = disk_conf->rs_discard_granularity % + discard_granularity; disk_conf->rs_discard_granularity += remainder;if (disk_conf->rs_discard_granularity > discard_size)
drivers/block/drbd/drbd_receiver.c +1 -2
@@ -1511,7 +1511,6 @@ void drbd_bump_write_ordering(struct drbd_resource *resource, struct drbd_backinint drbd_issue_discard_or_zero_out (struct drbd_device *device,sector_t start,unsigned int nr_sectors,int flags) {struct block_device *bdev = device->ldev->backing_bdev; -struct request_queue *q =bdev_get_queue (bdev);sector_t tmp, nr;unsigned int max_discard_sectors, granularity;int alignment;
@@ -1521,7 +1520,7 @@ int drbd_issue_discard_or_zero_out(struct drbd_device *device, sector_t start, u goto zero_out;/* Zero-sector (unknown) and one-sector granularities are the same. */ - granularity =max (q->limits.discard_granularity >>9 ,1U ); + granularity =max (bdev_discard_granularity (bdev) >>9 ,1U ); alignment = (bdev_discard_alignment (bdev) >>9 ) % granularity; max_discard_sectors =min (bdev_max_discard_sectors (bdev), (1U <<22 ));
drivers/block/loop.c +1 -1
@@ -759,7 +759,7 @@ static void loop_config_discard(struct loop_device *lo)struct request_queue *backingq =bdev_get_queue (I_BDEV (inode)); max_discard_sectors = backingq->limits.max_write_zeroes_sectors; - granularity = backingq->limits.discard_granularity ?: + granularity =bdev_discard_granularity (I_BDEV (inode)) ?:queue_physical_block_size (backingq);/*
drivers/target/target_core_device.c +1 -2
@@ -835,7 +835,6 @@ struct se_device *target_alloc_device(struct se_hba *hba, const char *name)bool target_configure_unmap_from_queue (struct se_dev_attrib *attrib,struct block_device *bdev) { -struct request_queue *q =bdev_get_queue (bdev);int block_size =bdev_logical_block_size (bdev);if (!bdev_max_discard_sectors (bdev))
@@ -847,7 +846,7 @@ bool target_configure_unmap_from_queue(struct se_dev_attrib *attrib,* Currently hardcoded to 1 in Linux/SCSI code.. */ attrib->max_unmap_block_desc_count =1 ; - attrib->unmap_granularity = q->limits.discard_granularity / block_size; + attrib->unmap_granularity =bdev_discard_granularity (bdev) / block_size; attrib->unmap_granularity_alignment =bdev_discard_alignment (bdev) / block_size;return true;
fs/btrfs/ioctl.c +4 -8
@@ -468,7 +468,6 @@ static noinline int btrfs_ioctl_fitrim(struct btrfs_fs_info *fs_info, void __user *arg) {struct btrfs_device *device; -struct request_queue *q;struct fstrim_range range;u64 minlen =ULLONG_MAX ;u64 num_devices =0 ;
@@ -498,14 +497,11 @@ static noinline int btrfs_ioctl_fitrim(struct btrfs_fs_info *fs_info,rcu_read_lock ();list_for_each_entry_rcu (device, &fs_info->fs_devices->devices, dev_list) { -if (!device->bdev) +if (!device->bdev || !bdev_max_discard_sectors (device->bdev))continue ; - q =bdev_get_queue (device->bdev); -if (bdev_max_discard_sectors (device->bdev)) { - num_devices++; - minlen =min_t (u64, q->limits.discard_granularity, - minlen); - } + num_devices++; + minlen =min_t (u64,bdev_discard_granularity (device->bdev), + minlen); }rcu_read_unlock ();
fs/exfat/file.c +1 -2
@@ -351,7 +351,6 @@ int exfat_setattr(struct user_namespace *mnt_userns, struct dentry *dentry,static int exfat_ioctl_fitrim (struct inode *inode,unsigned long arg) { -struct request_queue *q =bdev_get_queue (inode->i_sb->s_bdev);struct fstrim_range range;int ret =0 ;
@@ -365,7 +364,7 @@ static int exfat_ioctl_fitrim(struct inode *inode, unsigned long arg)return -EFAULT ; range.minlen = max_t(unsigned int, range.minlen, - q->limits.discard_granularity); +bdev_discard_granularity (inode->i_sb->s_bdev)); ret =exfat_trim_fs (inode, &range);if (ret <0 )
fs/ext4/mballoc.c +3 -3
@@ -6455,7 +6455,7 @@ ext4_trim_all_free(struct super_block *sb, ext4_group_t group,*/ int ext4_trim_fs (struct super_block *sb,struct fstrim_range *range) { -struct request_queue *q =bdev_get_queue (sb->s_bdev); +unsigned int discard_granularity =bdev_discard_granularity (sb->s_bdev);struct ext4_group_info *grp;ext4_group_t group, first_group, last_group;ext4_grpblk_t cnt =0 , first_cluster, last_cluster;
@@ -6475,9 +6475,9 @@ int ext4_trim_fs(struct super_block *sb, struct fstrim_range *range) range->len < sb->s_blocksize)return -EINVAL ;/* No point to try to trim less than discard granularity */ -if (range->minlen < q->limits.discard_granularity) { +if (range->minlen < discard_granularity) { minlen =EXT4_NUM_B2C (EXT4_SB (sb), - q->limits.discard_granularity >> sb->s_blocksize_bits); + discard_granularity >> sb->s_blocksize_bits);if (minlen >EXT4_CLUSTERS_PER_GROUP (sb)) goto out; }
fs/f2fs/file.c +1 -2
@@ -2285,7 +2285,6 @@ static int f2fs_ioc_fitrim(struct file *filp, unsigned long arg) {struct inode *inode =file_inode (filp);struct super_block *sb = inode->i_sb; -struct request_queue *q =bdev_get_queue (sb->s_bdev);struct fstrim_range range;int ret;
@@ -2304,7 +2303,7 @@ static int f2fs_ioc_fitrim(struct file *filp, unsigned long arg)return ret; range.minlen =max ((unsigned int )range.minlen, - q->limits.discard_granularity); +bdev_discard_granularity (sb->s_bdev)); ret =f2fs_trim_fs (F2FS_SB (sb), &range);mnt_drop_write_file (filp);if (ret <0 )
fs/fat/file.c +1 -2
@@ -127,7 +127,6 @@ static int fat_ioctl_fitrim(struct inode *inode, unsigned long arg)struct super_block *sb = inode->i_sb;struct fstrim_range __user *user_range;struct fstrim_range range; -struct request_queue *q =bdev_get_queue (sb->s_bdev);int err;if (!capable (CAP_SYS_ADMIN ))
@@ -141,7 +140,7 @@ static int fat_ioctl_fitrim(struct inode *inode, unsigned long arg)return -EFAULT ; range.minlen = max_t(unsigned int, range.minlen, - q->limits.discard_granularity); +bdev_discard_granularity (sb->s_bdev)); err =fat_trim_fs (inode, &range);if (err <0 )
fs/gfs2/rgrp.c +3 -4
@@ -1386,7 +1386,7 @@ int gfs2_fitrim(struct file *filp, void __user *argp) {struct inode *inode =file_inode (filp);struct gfs2_sbd *sdp =GFS2_SB (inode); -struct request_queue *q =bdev_get_queue (sdp->sd_vfs->s_bdev); +struct block_device *bdev = sdp->sd_vfs->s_bdev;struct buffer_head *bh;struct gfs2_rgrpd *rgd;struct gfs2_rgrpd *rgd_end;
@@ -1405,7 +1405,7 @@ int gfs2_fitrim(struct file *filp, void __user *argp)if (!test_bit (SDF_JOURNAL_LIVE , &sdp->sd_flags))return -EROFS ; -if (!bdev_max_discard_sectors (sdp->sd_vfs->s_bdev)) +if (!bdev_max_discard_sectors (bdev))return -EOPNOTSUPP ;if (copy_from_user (&r, argp,sizeof (r)))
@@ -1418,8 +1418,7 @@ int gfs2_fitrim(struct file *filp, void __user *argp) start = r.start >> bs_shift; end = start + (r.len >> bs_shift); minlen =max_t (u64, r.minlen, sdp->sd_sb.sb_bsize); - minlen =max_t (u64, minlen, - q->limits.discard_granularity) >> bs_shift; + minlen =max_t (u64, minlen,bdev_discard_granularity (bdev)) >> bs_shift;if (end <= start || minlen > sdp->sd_max_rg_data)return -EINVAL ;
fs/jfs/ioctl.c +1 -2
@@ -110,7 +110,6 @@ long jfs_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)case FITRIM : {struct super_block *sb = inode->i_sb; -struct request_queue *q =bdev_get_queue (sb->s_bdev);struct fstrim_range range;s64 ret =0 ;
@@ -127,7 +126,7 @@ long jfs_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)return -EFAULT ; range.minlen = max_t(unsigned int, range.minlen, - q->limits.discard_granularity); +bdev_discard_granularity (sb->s_bdev)); ret =jfs_ioc_trim (inode, &range);if (ret <0 )
fs/nilfs2/ioctl.c +2 -2
@@ -1052,7 +1052,6 @@ static int nilfs_ioctl_resize(struct inode *inode, struct file *filp,static int nilfs_ioctl_trim_fs (struct inode *inode,void __user *argp) {struct the_nilfs *nilfs = inode->i_sb->s_fs_info; -struct request_queue *q =bdev_get_queue (nilfs->ns_bdev);struct fstrim_range range;int ret;
@@ -1065,7 +1064,8 @@ static int nilfs_ioctl_trim_fs(struct inode *inode, void __user *argp)if (copy_from_user (&range, argp,sizeof (range)))return -EFAULT ; - range.minlen =max_t (u64, range.minlen, q->limits.discard_granularity); + range.minlen =max_t (u64, range.minlen, +bdev_discard_granularity (nilfs->ns_bdev));down_read (&nilfs->ns_segctor_sem); ret =nilfs_sufile_trim_fs (nilfs->ns_sufile, &range);
fs/ntfs3/file.c +2 -2
@@ -22,7 +22,6 @@ static int ntfs_ioctl_fitrim(struct ntfs_sb_info *sbi, unsigned long arg) {struct fstrim_range __user *user_range;struct fstrim_range range; -struct request_queue *q =bdev_get_queue (sbi->sb->s_bdev);int err;if (!capable (CAP_SYS_ADMIN ))
@@ -35,7 +34,8 @@ static int ntfs_ioctl_fitrim(struct ntfs_sb_info *sbi, unsigned long arg)if (copy_from_user (&range, user_range,sizeof (range)))return -EFAULT ; - range.minlen =max_t (u32, range.minlen, q->limits.discard_granularity); + range.minlen =max_t (u32, range.minlen, +bdev_discard_granularity (sbi->sb->s_bdev)); err =ntfs_trim_fs (sbi, &range);if (err <0 )
fs/ntfs3/super.c +2 -4
@@ -882,7 +882,6 @@ static int ntfs_fill_super(struct super_block *sb, struct fs_context *fc)int err;struct ntfs_sb_info *sbi = sb->s_fs_info;struct block_device *bdev = sb->s_bdev; -struct request_queue *rq;struct inode *inode;struct ntfs_inode *ni;size_t i, tt;
@@ -912,9 +911,8 @@ static int ntfs_fill_super(struct super_block *sb, struct fs_context *fc) goto out; } - rq =bdev_get_queue (bdev); -if (bdev_max_discard_sectors (bdev) && rq->limits.discard_granularity) { - sbi->discard_granularity = rq->limits.discard_granularity; +if (bdev_max_discard_sectors (bdev) &&bdev_discard_granularity (bdev)) { + sbi->discard_granularity =bdev_discard_granularity (bdev); sbi->discard_granularity_mask_inv = ~(u64)(sbi->discard_granularity -1 ); }
fs/ocfs2/ioctl.c +1 -2
@@ -903,7 +903,6 @@ long ocfs2_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)case FITRIM : {struct super_block *sb = inode->i_sb; -struct request_queue *q =bdev_get_queue (sb->s_bdev);struct fstrim_range range;int ret =0 ;
@@ -916,7 +915,7 @@ long ocfs2_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)if (copy_from_user (&range, argp,sizeof (range)))return -EFAULT ; - range.minlen =max_t (u64, q->limits.discard_granularity, + range.minlen =max_t (u64,bdev_discard_granularity (sb->s_bdev), range.minlen); ret =ocfs2_trim_fs (sb, &range);if (ret <0 )
fs/xfs/xfs_discard.c +2 -2
@@ -152,8 +152,8 @@ xfs_ioc_trim(struct xfs_mount *mp, struct fstrim_range __user *urange) { - struct request_queue *q = bdev_get_queue(mp->m_ddev_targp->bt_bdev); -unsigned int granularity = q->limits.discard_granularity; + unsigned int granularity = +bdev_discard_granularity (mp->m_ddev_targp->bt_bdev);struct fstrim_range range;xfs_daddr_t start, end, minlen;xfs_agnumber_t start_agno, end_agno, agno;
include/linux/blkdev.h +5 -0
@@ -1257,6 +1257,11 @@ static inline unsigned int bdev_max_discard_sectors(struct block_device *bdev)return bdev_get_queue (bdev)->limits.max_discard_sectors; } +static inline unsigned int bdev_discard_granularity (struct block_device *bdev) +{ +return bdev_get_queue (bdev)->limits.discard_granularity; +} +static inline unsigned int bdev_write_zeroes_sectors (struct block_device *bdev) {struct request_queue *q =bdev_get_queue (bdev);
Signature · 1 line
2.30.2
Christoph Hellwig
maintainerPATCH 26/27 block: decouple REQ_OP_SECURE_ERASE from REQ_OP_DISCARD
In reply to Christoph HellwigSecure erase is a very different operation from discard in that it is a data integrity operation vs hint. Fully split the limits and helper infrastructure to make the separation more clear.
--- block/blk-core.c | 2 +- block/blk-lib.c | 64 ++++++++++++++++++++--------- block/blk-mq-debugfs.c | 1 - block/blk-settings.c | 16 +++++++- block/fops.c | 2 +- block/ioctl.c | 43 +++++++++++++++---- drivers/block/drbd/drbd_receiver.c | 5 ++- drivers/block/rnbd/rnbd-clt.c | 4 +- drivers/block/rnbd/rnbd-srv-dev.h | 2 +- drivers/block/xen-blkback/blkback.c | 15 +++---- drivers/block/xen-blkback/xenbus.c | 5 +-- drivers/block/xen-blkfront.c | 5 ++- drivers/md/bcache/alloc.c | 2 +- drivers/md/dm-table.c | 8 ++-- drivers/md/dm-thin.c | 4 +- drivers/md/md.c | 2 +- drivers/md/raid5-cache.c | 6 +-- drivers/mmc/core/queue.c | 2 +- drivers/nvme/target/io-cmd-bdev.c | 2 +- drivers/target/target_core_file.c | 2 +- drivers/target/target_core_iblock.c | 2 +- fs/btrfs/extent-tree.c | 4 +- fs/ext4/mballoc.c | 2 +- fs/f2fs/file.c | 16 ++++---- fs/f2fs/segment.c | 2 +- fs/jbd2/journal.c | 2 +- fs/nilfs2/sufile.c | 4 +- fs/nilfs2/the_nilfs.c | 4 +- fs/ntfs3/super.c | 2 +- fs/xfs/xfs_discard.c | 2 +- fs/xfs/xfs_log_cil.c | 2 +- include/linux/blkdev.h | 27 +++++++----- mm/swapfile.c | 6 +-- 33 files changed, 168 insertions(+), 99 deletions(-)
block/blk-core.c +1 -1
@@ -824,7 +824,7 @@ void submit_bio_noacct(struct bio *bio) goto not_supported;break ;case REQ_OP_SECURE_ERASE : -if (!blk_queue_secure_erase (q)) +if (!bdev_max_secure_erase_sectors (bdev)) goto not_supported;break ;case REQ_OP_ZONE_APPEND :
block/blk-lib.c +45 -19
102 lines not on this page · raw message
block/blk-mq-debugfs.c +0 -1
@@ -115,7 +115,6 @@ static const char *const blk_queue_flag_name[] = {QUEUE_FLAG_NAME (IO_STAT ),QUEUE_FLAG_NAME (NOXMERGES ),QUEUE_FLAG_NAME (ADD_RANDOM ), -QUEUE_FLAG_NAME (SECERASE ),QUEUE_FLAG_NAME (SAME_FORCE ),QUEUE_FLAG_NAME (DEAD ), QUEUE_FLAG_NAME(INIT_DONE),
block/blk-settings.c +15 -1
@@ -46,6 +46,7 @@ void blk_set_default_limits(struct queue_limits *lim) lim->max_zone_append_sectors =0 ; lim->max_discard_sectors =0 ; lim->max_hw_discard_sectors =0 ; + lim->max_secure_erase_sectors =0 ; lim->discard_granularity =0 ; lim->discard_alignment =0 ; lim->discard_misaligned =0 ;
@@ -176,6 +177,18 @@ void blk_queue_max_discard_sectors(struct request_queue *q, }EXPORT_SYMBOL (blk_queue_max_discard_sectors); +/** +* blk_queue_max_secure_erase_sectors - set max sectors for a secure erase +* @q: the request queue for the device +* @max_sectors: maximum number of sectors to secure_erase +**/ +void blk_queue_max_secure_erase_sectors (struct request_queue *q, +unsigned int max_sectors) +{ + q->limits.max_secure_erase_sectors = max_sectors; +} +EXPORT_SYMBOL (blk_queue_max_secure_erase_sectors); +/** * blk_queue_max_write_zeroes_sectors - set max sectors for a single * write zeroes
@@ -661,7 +674,8 @@ int blk_stack_limits(struct queue_limits *t, struct queue_limits *b, t->discard_alignment =lcm_not_zero (t->discard_alignment, alignment) % t->discard_granularity; } - + t->max_secure_erase_sectors =min_not_zero (t->max_secure_erase_sectors, + b->max_secure_erase_sectors); t->zone_write_granularity =max (t->zone_write_granularity, b->zone_write_granularity); t->zoned =max (t->zoned, b->zoned);
block/fops.c +1 -1
@@ -677,7 +677,7 @@ static long blkdev_fallocate(struct file *file, int mode, loff_t start,break ;case FALLOC_FL_PUNCH_HOLE |FALLOC_FL_KEEP_SIZE |FALLOC_FL_NO_HIDE_STALE : error =blkdev_issue_discard (bdev, start >>SECTOR_SHIFT , - len >>SECTOR_SHIFT ,GFP_KERNEL ,0 ); + len >>SECTOR_SHIFT ,GFP_KERNEL );break ;default : error = -EOPNOTSUPP ;
block/ioctl.c +35 -8
67 lines not on this page · raw message
drivers/block/drbd/drbd_receiver.c +3 -2
@@ -1547,7 +1547,8 @@ int drbd_issue_discard_or_zero_out(struct drbd_device *device, sector_t start, u start = tmp; }while (nr_sectors >= max_discard_sectors) { - err |=blkdev_issue_discard (bdev, start, max_discard_sectors,GFP_NOIO ,0 ); + err |=blkdev_issue_discard (bdev, start, max_discard_sectors, +GFP_NOIO ); nr_sectors -= max_discard_sectors; start += max_discard_sectors; }
@@ -1559,7 +1560,7 @@ int drbd_issue_discard_or_zero_out(struct drbd_device *device, sector_t start, u nr = nr_sectors; nr -= (unsigned int )nr % granularity;if (nr) { - err |=blkdev_issue_discard (bdev, start, nr,GFP_NOIO ,0 ); + err |=blkdev_issue_discard (bdev, start, nr,GFP_NOIO ); nr_sectors -= nr; start += nr; }
drivers/block/rnbd/rnbd-clt.c +2 -2
@@ -1365,8 +1365,8 @@ static void setup_request_queue(struct rnbd_clt_dev *dev) dev->queue->limits.discard_granularity = dev->discard_granularity; dev->queue->limits.discard_alignment = dev->discard_alignment;if (dev->secure_discard) -blk_queue_flag_set (QUEUE_FLAG_SECERASE , dev->queue); - +blk_queue_max_secure_erase_sectors (dev->queue, + dev->max_discard_sectors);blk_queue_flag_set (QUEUE_FLAG_SAME_COMP , dev->queue);blk_queue_flag_set (QUEUE_FLAG_SAME_FORCE , dev->queue);blk_queue_max_segments (dev->queue, dev->max_segments);
drivers/block/rnbd/rnbd-srv-dev.h +1 -1
@@ -44,7 +44,7 @@ static inline int rnbd_dev_get_max_hw_sects(const struct rnbd_dev *dev)static inline int rnbd_dev_get_secure_discard (const struct rnbd_dev *dev) { -return blk_queue_secure_erase (bdev_get_queue (dev->bdev)); +return bdev_max_secure_erase_sectors (dev->bdev); }static inline int rnbd_dev_get_max_discard_sects (const struct rnbd_dev *dev)
drivers/block/xen-blkback/blkback.c +8 -7
@@ -970,7 +970,6 @@ static int dispatch_discard_io(struct xen_blkif_ring *ring,int status =BLKIF_RSP_OKAY ;struct xen_blkif *blkif = ring->blkif;struct block_device *bdev = blkif->vbd.bdev; -unsigned long secure;struct phys_req preq;xen_blkif_get (blkif);
@@ -987,13 +986,15 @@ static int dispatch_discard_io(struct xen_blkif_ring *ring, } ring->st_ds_req++; - secure = (blkif->vbd.discard_secure && - (req->u.discard.flag &BLKIF_DISCARD_SECURE )) ? -BLKDEV_DISCARD_SECURE :0 ; +if (blkif->vbd.discard_secure && + (req->u.discard.flag &BLKIF_DISCARD_SECURE )) + err =blkdev_issue_secure_erase (bdev, + req->u.discard.sector_number, + req->u.discard.nr_sectors,GFP_KERNEL ); +else + err =blkdev_issue_discard (bdev, req->u.discard.sector_number, + req->u.discard.nr_sectors,GFP_KERNEL ); - err =blkdev_issue_discard (bdev, req->u.discard.sector_number, - req->u.discard.nr_sectors, -GFP_KERNEL , secure); fail_response:if (err == -EOPNOTSUPP ) {pr_debug ("discard op failed, not supported\n" );
drivers/block/xen-blkback/xenbus.c +1 -4
@@ -484,7 +484,6 @@ static int xen_vbd_create(struct xen_blkif *blkif, blkif_vdev_t handle, {struct xen_vbd *vbd;struct block_device *bdev; -struct request_queue *q; vbd = &blkif->vbd; vbd->handle = handle;
@@ -516,11 +515,9 @@ static int xen_vbd_create(struct xen_blkif *blkif, blkif_vdev_t handle,if (vbd->bdev->bd_disk->flags &GENHD_FL_REMOVABLE ) vbd->type |=VDISK_REMOVABLE ; - q =bdev_get_queue (bdev);if (bdev_write_cache (bdev)) vbd->flush_support = true; - -if (q &&blk_queue_secure_erase (q)) +if (bdev_max_secure_erase_sectors (bdev)) vbd->discard_secure = true; vbd->feature_gnt_persistent = feature_persistent;
drivers/block/xen-blkfront.c +3 -2
@@ -949,7 +949,8 @@ static void blkif_set_queue_limits(struct blkfront_info *info) info->physical_sector_size; rq->limits.discard_alignment = info->discard_alignment;if (info->feature_secdiscard) -blk_queue_flag_set (QUEUE_FLAG_SECERASE , rq); +blk_queue_max_secure_erase_sectors (rq, +get_capacity (gd)); }/* Hard sector size and max sectors impersonate the equiv. hardware. */
@@ -1606,7 +1607,7 @@ static irqreturn_t blkif_interrupt(int irq, void *dev_id) info->feature_discard =0 ; info->feature_secdiscard =0 ;blk_queue_max_discard_sectors (rq,0 ); -blk_queue_flag_clear (QUEUE_FLAG_SECERASE , rq); +blk_queue_max_secure_erase_sectors (rq,0 ); }break ;case BLKIF_OP_FLUSH_DISKCACHE :
drivers/md/bcache/alloc.c +1 -1
@@ -336,7 +336,7 @@ static int bch_allocator_thread(void *arg)mutex_unlock (&ca->set->bucket_lock);blkdev_issue_discard (ca->bdev,bucket_to_sector (ca->set, bucket), - ca->sb.bucket_size,GFP_KERNEL ,0 ); + ca->sb.bucket_size,GFP_KERNEL );mutex_lock (&ca->set->bucket_lock); }
drivers/md/dm-table.c +3 -5
@@ -1920,9 +1920,7 @@ static int device_not_secure_erase_capable(struct dm_target *ti, struct dm_dev *dev, sector_t start, sector_t len, void *data) { - struct request_queue *q = bdev_get_queue(dev->bdev); - -return !blk_queue_secure_erase (q); + return !bdev_max_secure_erase_sectors(dev->bdev); }static bool dm_table_supports_secure_erase (struct dm_table *t)
@@ -1975,8 +1973,8 @@ int dm_table_set_restrictions(struct dm_table *t, struct request_queue *q, q->limits.discard_misaligned =0 ; } -if (dm_table_supports_secure_erase (t)) -blk_queue_flag_set (QUEUE_FLAG_SECERASE , q); +if (!dm_table_supports_secure_erase (t)) + q->limits.max_secure_erase_sectors =0 ;if (dm_table_supports_flush (t, (1UL <<QUEUE_FLAG_WC ))) { wc = true;
drivers/md/dm-thin.c +2 -2
@@ -398,8 +398,8 @@ static int issue_discard(struct discard_op *op, dm_block_t data_b, dm_block_t dasector_t s =block_to_sectors (tc->pool, data_b);sector_t len =block_to_sectors (tc->pool, data_e - data_b); -return __blkdev_issue_discard (tc->pool_dev->bdev, s, len, -GFP_NOWAIT ,0 , &op->bio); +return __blkdev_issue_discard (tc->pool_dev->bdev, s, len,GFP_NOWAIT , + &op->bio); }static void end_discard (struct discard_op *op,int r)
drivers/md/md.c +1 -1
@@ -8584,7 +8584,7 @@ void md_submit_discard_bio(struct mddev *mddev, struct md_rdev *rdev, {struct bio *discard_bio =NULL ; -if (__blkdev_issue_discard (rdev->bdev, start, size,GFP_NOIO ,0 , +if (__blkdev_issue_discard (rdev->bdev, start, size,GFP_NOIO , &discard_bio) || !discard_bio)return ;
drivers/md/raid5-cache.c +3 -3
@@ -1344,14 +1344,14 @@ static void r5l_write_super_and_discard_space(struct r5l_log *log,if (log->last_checkpoint < end) {blkdev_issue_discard (bdev, log->last_checkpoint + log->rdev->data_offset, - end - log->last_checkpoint,GFP_NOIO ,0 ); + end - log->last_checkpoint,GFP_NOIO ); }else {blkdev_issue_discard (bdev, log->last_checkpoint + log->rdev->data_offset, log->device_size - log->last_checkpoint, -GFP_NOIO ,0 ); +GFP_NOIO );blkdev_issue_discard (bdev, log->rdev->data_offset, end, -GFP_NOIO ,0 ); +GFP_NOIO ); } }
drivers/mmc/core/queue.c +1 -1
@@ -189,7 +189,7 @@ static void mmc_queue_setup_discard(struct request_queue *q,if (card->pref_erase > max_discard) q->limits.discard_granularity =SECTOR_SIZE ;if (mmc_can_secure_erase_trim (card)) -blk_queue_flag_set (QUEUE_FLAG_SECERASE , q); +blk_queue_max_secure_erase_sectors (q, max_discard); }static unsigned short mmc_get_max_segments (struct mmc_host *host)
drivers/nvme/target/io-cmd-bdev.c +1 -1
@@ -360,7 +360,7 @@ static u16 nvmet_bdev_discard_range(struct nvmet_req *req, ret =__blkdev_issue_discard (ns->bdev,nvmet_lba_to_sect (ns, range->slba),le32_to_cpu (range->nlb) << (ns->blksize_shift -9 ), -GFP_KERNEL ,0 , bio); +GFP_KERNEL , bio);if (ret && ret != -EOPNOTSUPP ) { req->error_slba =le64_to_cpu (range->slba);return errno_to_nvme_status (req, ret);
drivers/target/target_core_file.c +1 -1
@@ -558,7 +558,7 @@ fd_execute_unmap(struct se_cmd *cmd, sector_t lba, sector_t nolb) ret =blkdev_issue_discard (bdev,target_to_linux_sector (dev, lba),target_to_linux_sector (dev, nolb), -GFP_KERNEL ,0 ); +GFP_KERNEL );if (ret <0 ) {pr_warn ("FILEIO: blkdev_issue_discard() failed: %d\n" , ret);
drivers/target/target_core_iblock.c +1 -1
@@ -434,7 +434,7 @@ iblock_execute_unmap(struct se_cmd *cmd, sector_t lba, sector_t nolb) ret =blkdev_issue_discard (bdev,target_to_linux_sector (dev, lba),target_to_linux_sector (dev, nolb), -GFP_KERNEL ,0 ); +GFP_KERNEL );if (ret <0 ) {pr_err ("blkdev_issue_discard() failed: %d\n" , ret);return TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE ;
fs/btrfs/extent-tree.c +2 -2
@@ -1239,7 +1239,7 @@ static int btrfs_issue_discard(struct block_device *bdev, u64 start, u64 len,if (size) { ret =blkdev_issue_discard (bdev, start >>9 , size >>9 , -GFP_NOFS ,0 ); +GFP_NOFS );if (!ret) *discarded_bytes += size;else if (ret != -EOPNOTSUPP )
@@ -1256,7 +1256,7 @@ static int btrfs_issue_discard(struct block_device *bdev, u64 start, u64 len,if (bytes_left) { ret =blkdev_issue_discard (bdev, start >>9 , bytes_left >>9 , -GFP_NOFS ,0 ); +GFP_NOFS );if (!ret) *discarded_bytes += bytes_left; }
fs/ext4/mballoc.c +1 -1
@@ -3629,7 +3629,7 @@ static inline int ext4_issue_discard(struct super_block *sb,return __blkdev_issue_discard (sb->s_bdev, (sector_t )discard_block << (sb->s_blocksize_bits -9 ), (sector_t )count << (sb->s_blocksize_bits -9 ), -GFP_NOFS ,0 , biop); +GFP_NOFS , biop); }else return sb_issue_discard (sb, discard_block, count,GFP_NOFS ,0 ); }
fs/f2fs/file.c +8 -8
@@ -3685,18 +3685,18 @@ static int f2fs_reserve_compress_blocks(struct file *filp, unsigned long arg)static int f2fs_secure_erase (struct block_device *bdev,struct inode *inode,pgoff_t off,block_t block,block_t len,u32 flags) { -struct request_queue *q =bdev_get_queue (bdev);sector_t sector =SECTOR_FROM_BLOCK (block);sector_t nr_sects =SECTOR_FROM_BLOCK (len);int ret =0 ; -if (!q) -return -ENXIO ; - -if (flags &F2FS_TRIM_FILE_DISCARD ) - ret =blkdev_issue_discard (bdev, sector, nr_sects,GFP_NOFS , -blk_queue_secure_erase (q) ? -BLKDEV_DISCARD_SECURE :0 ); +if (flags &F2FS_TRIM_FILE_DISCARD ) { +if (bdev_max_secure_erase_sectors (bdev)) + ret =blkdev_issue_secure_erase (bdev, sector, nr_sects, +GFP_NOFS ); +else + ret =blkdev_issue_discard (bdev, sector, nr_sects, +GFP_NOFS ); + }if (!ret && (flags &F2FS_TRIM_FILE_ZEROOUT )) {if (IS_ENCRYPTED (inode))
fs/f2fs/segment.c +1 -1
@@ -1244,7 +1244,7 @@ static int __submit_discard_cmd(struct f2fs_sb_info *sbi, err =__blkdev_issue_discard (bdev,SECTOR_FROM_BLOCK (start),SECTOR_FROM_BLOCK (len), -GFP_NOFS ,0 , &bio); +GFP_NOFS , &bio); submit:if (err) {spin_lock_irqsave (&dc->lock, flags);
fs/jbd2/journal.c +1 -1
@@ -1825,7 +1825,7 @@ static int __jbd2_journal_erase(journal_t *journal, unsigned int flags) err =blkdev_issue_discard (journal->j_dev, byte_start >>SECTOR_SHIFT , byte_count >>SECTOR_SHIFT , -GFP_NOFS ,0 ); +GFP_NOFS ); }else if (flags &JBD2_JOURNAL_FLUSH_ZEROOUT ) { err = blkdev_issue_zeroout(journal->j_dev, byte_start >> SECTOR_SHIFT,
fs/nilfs2/sufile.c +2 -2
@@ -1100,7 +1100,7 @@ int nilfs_sufile_trim_fs(struct inode *sufile, struct fstrim_range *range) ret =blkdev_issue_discard (nilfs->ns_bdev, start * sects_per_block, nblocks * sects_per_block, -GFP_NOFS ,0 ); +GFP_NOFS );if (ret <0 ) {put_bh (su_bh); goto out_sem;
@@ -1134,7 +1134,7 @@ int nilfs_sufile_trim_fs(struct inode *sufile, struct fstrim_range *range) ret =blkdev_issue_discard (nilfs->ns_bdev, start * sects_per_block, nblocks * sects_per_block, -GFP_NOFS ,0 ); +GFP_NOFS );if (!ret) ndiscarded += nblocks; }
fs/nilfs2/the_nilfs.c +2 -2
@@ -672,7 +672,7 @@ int nilfs_discard_segments(struct the_nilfs *nilfs, __u64 *segnump, ret =blkdev_issue_discard (nilfs->ns_bdev, start * sects_per_block, nblocks * sects_per_block, -GFP_NOFS ,0 ); +GFP_NOFS );if (ret <0 )return ret; nblocks =0 ;
@@ -682,7 +682,7 @@ int nilfs_discard_segments(struct the_nilfs *nilfs, __u64 *segnump, ret =blkdev_issue_discard (nilfs->ns_bdev, start * sects_per_block, nblocks * sects_per_block, -GFP_NOFS ,0 ); +GFP_NOFS );return ret; }
fs/ntfs3/super.c +1 -1
@@ -1333,7 +1333,7 @@ int ntfs_discard(struct ntfs_sb_info *sbi, CLST lcn, CLST len)return 0 ; err =blkdev_issue_discard (sb->s_bdev, start >>9 , (end - start) >>9 , -GFP_NOFS ,0 ); +GFP_NOFS );if (err == -EOPNOTSUPP ) sbi->flags |=NTFS_FLAGS_NODISCARD ;
fs/xfs/xfs_discard.c +1 -1
@@ -114,7 +114,7 @@ xfs_trim_extents( }trace_xfs_discard_extent (mp, agno, fbno, flen); - error =blkdev_issue_discard (bdev, dbno, dlen,GFP_NOFS ,0 ); + error =blkdev_issue_discard (bdev, dbno, dlen,GFP_NOFS );if (error) goto out_del_cursor; *blocks_trimmed += flen;
fs/xfs/xfs_log_cil.c +1 -1
@@ -605,7 +605,7 @@ xlog_discard_busy_extents( error =__blkdev_issue_discard (mp->m_ddev_targp->bt_bdev,XFS_AGB_TO_DADDR (mp, busyp->agno, busyp->bno),XFS_FSB_TO_BB (mp, busyp->length), -GFP_NOFS ,0 , &bio); +GFP_NOFS , &bio);if (error && error != -EOPNOTSUPP ) { xfs_info(mp, "discard failed for extent [0x%llx,%u], error %d",
include/linux/blkdev.h +16 -11
@@ -248,6 +248,7 @@ struct queue_limits {unsigned int io_opt;unsigned int max_discard_sectors;unsigned int max_hw_discard_sectors; +unsigned int max_secure_erase_sectors;unsigned int max_write_zeroes_sectors;unsigned int max_zone_append_sectors;unsigned int discard_granularity;
@@ -542,7 +543,6 @@ struct request_queue {#define QUEUE_FLAG_IO_STAT 7/* do disk/partitions IO accounting */ #define QUEUE_FLAG_NOXMERGES 9/* No extended merges */ #define QUEUE_FLAG_ADD_RANDOM 10/* Contributes to random pool */ -#define QUEUE_FLAG_SECERASE 11/* supports secure erase */ #define QUEUE_FLAG_SAME_FORCE 12/* force complete on same CPU */ #define QUEUE_FLAG_DEAD 13/* queue tear-down finished */ #define QUEUE_FLAG_INIT_DONE 14/* queue is initialized */
@@ -583,8 +583,6 @@ bool blk_queue_flag_test_and_set(unsigned int flag, struct request_queue *q);#define blk_queue_add_random (q) test_bit(QUEUE_FLAG_ADD_RANDOM, &(q)->queue_flags)#define blk_queue_zone_resetall (q) \ test_bit(QUEUE_FLAG_ZONE_RESETALL, &(q)->queue_flags) -#define blk_queue_secure_erase (q) \ - (test_bit(QUEUE_FLAG_SECERASE, &(q)->queue_flags))#define blk_queue_dax (q) test_bit(QUEUE_FLAG_DAX, &(q)->queue_flags)#define blk_queue_pci_p2pdma (q) \ test_bit(QUEUE_FLAG_PCI_P2PDMA, &(q)->queue_flags)
@@ -947,6 +945,8 @@ extern void blk_queue_chunk_sectors(struct request_queue *, unsigned int);extern void blk_queue_max_segments (struct request_queue *,unsigned short );extern void blk_queue_max_discard_segments (struct request_queue *,unsigned short ); +void blk_queue_max_secure_erase_sectors (struct request_queue *q, +unsigned int max_sectors);extern void blk_queue_max_segment_size (struct request_queue *,unsigned int );extern void blk_queue_max_discard_sectors (struct request_queue *q,unsigned int max_discard_sectors);
@@ -1087,13 +1087,12 @@ static inline long nr_blockdev_pages(void)extern void blk_io_schedule (void ); -#define BLKDEV_DISCARD_SECURE (1 << 0)/* issue a secure erase */ - -extern int blkdev_issue_discard (struct block_device *bdev,sector_t sector, -sector_t nr_sects,gfp_t gfp_mask,unsigned long flags); -extern int __blkdev_issue_discard (struct block_device *bdev,sector_t sector, -sector_t nr_sects,gfp_t gfp_mask,int flags, -struct bio **biop); +int blkdev_issue_discard (struct block_device *bdev,sector_t sector, +sector_t nr_sects,gfp_t gfp_mask); +int __blkdev_issue_discard (struct block_device *bdev,sector_t sector, +sector_t nr_sects,gfp_t gfp_mask,struct bio **biop); +int blkdev_issue_secure_erase (struct block_device *bdev,sector_t sector, +sector_t nr_sects,gfp_t gfp);#define BLKDEV_ZERO_NOUNMAP (1 << 0)/* do not free blocks */ #define BLKDEV_ZERO_NOFALLBACK (1 << 1)/* don't write explicit zeroes */
@@ -1112,7 +1111,7 @@ static inline int sb_issue_discard(struct super_block *sb, sector_t block, SECTOR_SHIFT), nr_blocks << (sb->s_blocksize_bits -SECTOR_SHIFT ), - gfp_mask, flags); + gfp_mask); }static inline int sb_issue_zeroout (struct super_block *sb,sector_t block,sector_t nr_blocks,gfp_t gfp_mask)
@@ -1262,6 +1261,12 @@ static inline unsigned int bdev_discard_granularity(struct block_device *bdev)return bdev_get_queue (bdev)->limits.discard_granularity; } +static inline unsigned int +bdev_max_secure_erase_sectors (struct block_device *bdev) +{ +return bdev_get_queue (bdev)->limits.max_secure_erase_sectors; +} +static inline unsigned int bdev_write_zeroes_sectors (struct block_device *bdev) {struct request_queue *q =bdev_get_queue (bdev);
mm/swapfile.c +3 -3
@@ -179,7 +179,7 @@ static int discard_swap(struct swap_info_struct *si) nr_blocks = ((sector_t )se->nr_pages -1 ) << (PAGE_SHIFT -9 );if (nr_blocks) { err =blkdev_issue_discard (si->bdev, start_block, - nr_blocks,GFP_KERNEL ,0 ); + nr_blocks,GFP_KERNEL );if (err)return err;cond_resched ();
@@ -190,7 +190,7 @@ static int discard_swap(struct swap_info_struct *si) nr_blocks = (sector_t )se->nr_pages << (PAGE_SHIFT -9 ); err =blkdev_issue_discard (si->bdev, start_block, - nr_blocks,GFP_KERNEL ,0 ); + nr_blocks,GFP_KERNEL );if (err)break ;
@@ -254,7 +254,7 @@ static void discard_swap_cluster(struct swap_info_struct *si, start_block <<=PAGE_SHIFT -9 ; nr_blocks <<=PAGE_SHIFT -9 ;if (blkdev_issue_discard (si->bdev, start_block, - nr_blocks,GFP_NOIO ,0 )) + nr_blocks,GFP_NOIO ))break ; se =next_se (se);
Signature · 1 line
2.30.2
Re: [PATCH 26/27] block: decouple REQ_OP_SECURE_ERASE from REQ_OP_DISCARD
Quoted 4 lines · Christoph Hellwig
Secure erase is a very different operation from discard in that it is a data integrity operation vs hint. Fully split the limits and helper infrastructure to make the separation more clear.
Quoted 8 lines
Signed-off-by Christoph Hellwig <[email protected]>Reviewed-by Martin K. Petersen <[email protected]>Acked-by Coly Li <[email protected]> [bcache]---
Looks good.
-ck
Re: [f2fs-dev] [PATCH 26/27] block: decouple REQ_OP_SECURE_ERASE from REQ_OP_DISCARD
In reply to Christoph HellwigQuoted 11 lines · Christoph Hellwig
Secure erase is a very different operation from discard in that it is a data integrity operation vs hint. Fully split the limits and helper infrastructure to make the separation more clear.
Signed-off-by Christoph Hellwig <[email protected]>Reviewed-by Martin K. Petersen <[email protected]>Acked-by Coly Li <[email protected]> [bcache]
For f2fs part,
Thanks,
Christoph Hellwig
maintainerPATCH 27/27 direct-io: remove random prefetches
In reply to Christoph HellwigRandomly poking into block device internals for manual prefetches isn't exactly a very maintainable thing to do. And none of the performance criticil direct I/O implementations still use this library function anyway, so just drop it.
--- fs/direct-io.c | 32 ++++---------------------------- 1 file changed, 4 insertions(+), 28 deletions(-)
fs/direct-io.c +4 -28
@@ -1115,11 +1115,10 @@ static inline int drop_refcount(struct dio *dio)* individual fields and will generate much worse code. This is important * for the whole file. */ -static inline ssize_t -do_blockdev_direct_IO (struct kiocb *iocb,struct inode *inode, -struct block_device *bdev,struct iov_iter *iter, -get_block_t get_block,dio_iodone_t end_io, -dio_submit_t submit_io,int flags) +ssize_t __blockdev_direct_IO (struct kiocb *iocb,struct inode *inode, +struct block_device *bdev,struct iov_iter *iter, +get_block_t get_block,dio_iodone_t end_io, +dio_submit_t submit_io,int flags) {unsigned i_blkbits =READ_ONCE (inode->i_blkbits);unsigned blkbits = i_blkbits;
@@ -1334,29 +1333,6 @@ do_blockdev_direct_IO(struct kiocb *iocb, struct inode *inode,kmem_cache_free (dio_cache, dio);return retval; } - -ssize_t __blockdev_direct_IO (struct kiocb *iocb,struct inode *inode, -struct block_device *bdev,struct iov_iter *iter, -get_block_t get_block, -dio_iodone_t end_io,dio_submit_t submit_io, -int flags) -{ -/* -* The block device state is needed in the end to finally -* submit everything. Since it's likely to be cache cold -* prefetch it here as first thing to hide some of the -* latency. -* -* Attempt to prefetch the pieces we likely need later. -*/ -prefetch (&bdev->bd_disk->part_tbl); -prefetch (bdev->bd_disk->queue); -prefetch ((char *)bdev->bd_disk->queue +SMP_CACHE_BYTES ); - -return do_blockdev_direct_IO (iocb, inode, bdev, iter, get_block, - end_io, submit_io, flags); -} -EXPORT_SYMBOL (__blockdev_direct_IO);static __init int dio_init (void )
Signature · 1 line
2.30.2
Re: [PATCH 27/27] direct-io: remove random prefetches
Quoted 3 lines · Christoph Hellwig
Randomly poking into block device internals for manual prefetches isn't exactly a very maintainable thing to do. And none of the performance criticil direct I/O implementations still use this library function
s/criticil/critical
Quoted 3 lines
anyway, so just drop it.
Signed-off-by Christoph Hellwig <[email protected]>
Looks good to me.
Signature · 2 lines
Damien Le Moal Western Digital Research
Re: [PATCH 27/27] direct-io: remove random prefetches
In reply to Christoph HellwigQuoted 6 lines · Christoph Hellwig
Randomly poking into block device internals for manual prefetches isn't exactly a very maintainable thing to do. And none of the performance criticil direct I/O implementations still use this library function anyway, so just drop it.
Signed-off-by Christoph Hellwig <[email protected]>
That the direct io function needed a valid bdev just for the prefetch but nothing else was one of the reasons we had to keep the latest_bdev in btrfs, so good riddance.
You may want to add the reference to the patch that added the prefetch, 65dd2aa90aa1 ("dio: optimize cache misses in the submission path") and also remove #include <linux/prefetch.h> as there are no more uses of prefetch in the file.
With that
Quoted 9 lines · Christoph Hellwig
this series cleanups up the block layer API so that APIs consumed by file systems are (almost) only struct
block_devicbased, so that file systems don't have to poke into block layer internals like therequest_queue.I also found a bunch of existing bugs related to partition offsets and discard so these are fixed while going along.
[...]
Applied, thanks!
[01/27] target: remove an incorrect unmap zeroes data deduction
commit: 179d8609d8424529e95021df939ed7b0b82b37f1
[02/27] target: pass a block_device to target_configure_unmap_from_queue
commit: 817e8b51eb3d927ce6d56ecf9f48bc3c5b26168b
[03/27] target: fix discard alignment on partitions
commit: 968786b9ef56e75e0109158a4936ffffea962c1e
[04/27] drbd: remove assign_p_sizes_qlim
commit: 40349d0e16cedd0de561f59752c3249780fb749b
[05/27] drbd: use bdev based limit helpers in drbd_send_sizes
commit: 7a38acce229685968b770d1d9e64e01396b93643
[06/27] drbd: use bdev_alignment_offset instead of queue_alignment_offset
commit: c6f23b1a05441a26f765e59dd95e8ba7354f9388
[07/27] drbd: cleanup decide_on_discard_support
commit: 998e9cbcd615e5e6a7baa69e673ee845f812744e
[08/27] btrfs: use bdev_max_active_zones instead of open coding it
commit: c1e7b24416400ef13ff92a1c60c336c9a2834d7b
[09/27] ntfs3: use bdev_logical_block_size instead of open coding it
commit: f09dac9afb8e3ce4b6485dbc091a9b9c742db023
[10/27] mm: use bdev_is_zoned in claim_swapfile
commit: 9964e674559b02619fee2012a56839624143d02e
[11/27] block: add a bdev_nonrot helper
commit: 10f0d2a517796b8f6dc04fb0cc3e49003ae6b0bc
[12/27] block: add a bdev_write_cache helper
commit: 08e688fdb8f7e862092ae64cee20bc8b463d1046
[13/27] block: add a bdev_fua helper
commit: a557e82e5a01826f902bd94fc925c03f253cb712
[14/27] block: add a bdev_stable_writes helper
commit: 36d254893aa6a6e204075c3cce94bb572ac32c04
[15/27] block: add a bdev_max_zone_append_sectors helper
commit: 2aba0d19f4d8c8929b4b3b94a9cfde2aa20e6ee2
[16/27] block: use bdev_alignment_offset in part_alignment_offset_show
commit: 64dcc7c2717395b7c83ffb10f040d3be795d03c1
[17/27] block: use bdev_alignment_offset in disk_alignment_offset_show
commit: 640f2a23911b8388989547f89d055afbb910b88e
[18/27] block: move bdev_alignment_offset and queue_limit_alignment_offset out of line
commit: 89098b075cb74a80083bc4ed6b71d0ee18b6898f
[19/27] block: remove queue_discard_alignment
commit: 4e1462ffe8998749884d61f91be251a7a8719677
[20/27] block: use bdev_discard_alignment in part_discard_alignment_show
commit: f0f975a4dde890bfe25ce17bf07a6495453988a4
[21/27] block: move {bdev,queue_limit}_discard_alignment out of line
commit: 5c4b4a5c6f11c869a57c6bd977143430bc9dc43d
[22/27] block: refactor discard bio size limiting
commit: e3cc28ea28b5f8794db2aed24f8a0282ad2e85a2
[23/27] block: add a bdev_max_discard_sectors helper
commit: cf0fbf894bb543f472f682c486be48298eccf199
[24/27] block: remove QUEUE_FLAG_DISCARD
commit: 70200574cc229f6ba038259e8142af2aa09e6976
[25/27] block: add a bdev_discard_granularity helper
commit: 7b47ef52d0a2025fd1408a8a0990933b8e1e510f
[26/27] block: decouple REQ_OP_SECURE_ERASE from REQ_OP_DISCARD
commit: 44abff2c0b970ae3d310b97617525dc01f248d7c
[27/27] direct-io: remove random prefetches
commit: c22198e78d523c8fa079bbb70b2523bb6aa51849Best regards,
Signature · 1 line
Jens Axboe