* [PATCH 01/14] block: add a queue_limits_set helper
2024-02-28 22:56 atomic queue limit updates for stackable devices v3 Christoph Hellwig
@ 2024-02-28 22:56 ` Christoph Hellwig
2024-02-28 22:56 ` [PATCH 02/14] block: add a queue_limits_stack_bdev helper Christoph Hellwig
` (14 subsequent siblings)
15 siblings, 0 replies; 18+ messages in thread
From: Christoph Hellwig @ 2024-02-28 22:56 UTC (permalink / raw)
To: Jens Axboe, Mike Snitzer, Mikulas Patocka, Song Liu, Yu Kuai
Cc: dm-devel, linux-block, linux-raid
Add a small wrapper around queue_limits_commit_update for stacking
drivers that don't want to update existing limits, but set an
entirely new set.
Signed-off-by: Christoph Hellwig <hch@lst.de>
---
block/blk-settings.c | 18 ++++++++++++++++++
include/linux/blkdev.h | 1 +
2 files changed, 19 insertions(+)
diff --git a/block/blk-settings.c b/block/blk-settings.c
index b6bbe683d218fa..1989a177be201b 100644
--- a/block/blk-settings.c
+++ b/block/blk-settings.c
@@ -266,6 +266,24 @@ int queue_limits_commit_update(struct request_queue *q,
}
EXPORT_SYMBOL_GPL(queue_limits_commit_update);
+/**
+ * queue_limits_commit_set - apply queue limits to queue
+ * @q: queue to update
+ * @lim: limits to apply
+ *
+ * Apply the limits in @lim that were freshly initialized to @q.
+ * To update existing limits use queue_limits_start_update() and
+ * queue_limits_commit_update() instead.
+ *
+ * Returns 0 if successful, else a negative error code.
+ */
+int queue_limits_set(struct request_queue *q, struct queue_limits *lim)
+{
+ mutex_lock(&q->limits_lock);
+ return queue_limits_commit_update(q, lim);
+}
+EXPORT_SYMBOL_GPL(queue_limits_set);
+
/**
* blk_queue_bounce_limit - set bounce buffer limit for queue
* @q: the request queue for the device
diff --git a/include/linux/blkdev.h b/include/linux/blkdev.h
index a14ea934413850..dd510ad7ce4b45 100644
--- a/include/linux/blkdev.h
+++ b/include/linux/blkdev.h
@@ -889,6 +889,7 @@ queue_limits_start_update(struct request_queue *q)
}
int queue_limits_commit_update(struct request_queue *q,
struct queue_limits *lim);
+int queue_limits_set(struct request_queue *q, struct queue_limits *lim);
/*
* Access functions for manipulating queue properties
--
2.39.2
^ permalink raw reply related [flat|nested] 18+ messages in thread* [PATCH 02/14] block: add a queue_limits_stack_bdev helper
2024-02-28 22:56 atomic queue limit updates for stackable devices v3 Christoph Hellwig
2024-02-28 22:56 ` [PATCH 01/14] block: add a queue_limits_set helper Christoph Hellwig
@ 2024-02-28 22:56 ` Christoph Hellwig
2024-02-28 22:56 ` [PATCH 03/14] dm: use queue_limits_set Christoph Hellwig
` (13 subsequent siblings)
15 siblings, 0 replies; 18+ messages in thread
From: Christoph Hellwig @ 2024-02-28 22:56 UTC (permalink / raw)
To: Jens Axboe, Mike Snitzer, Mikulas Patocka, Song Liu, Yu Kuai
Cc: dm-devel, linux-block, linux-raid
Add a small wrapper around blk_stack_limits that allows passing a bdev
for the bottom device and prints an error in case of misaligned
device. The name fits into the new queue limits API and the intent is
to eventually replace disk_stack_limits.
Signed-off-by: Christoph Hellwig <hch@lst.de>
---
block/blk-settings.c | 25 +++++++++++++++++++++++++
include/linux/blkdev.h | 2 ++
2 files changed, 27 insertions(+)
diff --git a/block/blk-settings.c b/block/blk-settings.c
index 1989a177be201b..865fe4ebbf9b83 100644
--- a/block/blk-settings.c
+++ b/block/blk-settings.c
@@ -891,6 +891,31 @@ int blk_stack_limits(struct queue_limits *t, struct queue_limits *b,
}
EXPORT_SYMBOL(blk_stack_limits);
+/**
+ * queue_limits_stack_bdev - adjust queue_limits for stacked devices
+ * @t: the stacking driver limits (top device)
+ * @bdev: the underlying block device (bottom)
+ * @offset: offset to beginning of data within component device
+ * @pfx: prefix to use for warnings logged
+ *
+ * Description:
+ * This function is used by stacking drivers like MD and DM to ensure
+ * that all component devices have compatible block sizes and
+ * alignments. The stacking driver must provide a queue_limits
+ * struct (top) and then iteratively call the stacking function for
+ * all component (bottom) devices. The stacking function will
+ * attempt to combine the values and ensure proper alignment.
+ */
+void queue_limits_stack_bdev(struct queue_limits *t, struct block_device *bdev,
+ sector_t offset, const char *pfx)
+{
+ if (blk_stack_limits(t, &bdev_get_queue(bdev)->limits,
+ get_start_sect(bdev) + offset))
+ pr_notice("%s: Warning: Device %pg is misaligned\n",
+ pfx, bdev);
+}
+EXPORT_SYMBOL_GPL(queue_limits_stack_bdev);
+
/**
* disk_stack_limits - adjust queue limits for stacked drivers
* @disk: MD/DM gendisk (top)
diff --git a/include/linux/blkdev.h b/include/linux/blkdev.h
index dd510ad7ce4b45..285e82723d641f 100644
--- a/include/linux/blkdev.h
+++ b/include/linux/blkdev.h
@@ -924,6 +924,8 @@ extern void blk_set_queue_depth(struct request_queue *q, unsigned int depth);
extern void blk_set_stacking_limits(struct queue_limits *lim);
extern int blk_stack_limits(struct queue_limits *t, struct queue_limits *b,
sector_t offset);
+void queue_limits_stack_bdev(struct queue_limits *t, struct block_device *bdev,
+ sector_t offset, const char *pfx);
extern void disk_stack_limits(struct gendisk *disk, struct block_device *bdev,
sector_t offset);
extern void blk_queue_update_dma_pad(struct request_queue *, unsigned int);
--
2.39.2
^ permalink raw reply related [flat|nested] 18+ messages in thread* [PATCH 03/14] dm: use queue_limits_set
2024-02-28 22:56 atomic queue limit updates for stackable devices v3 Christoph Hellwig
2024-02-28 22:56 ` [PATCH 01/14] block: add a queue_limits_set helper Christoph Hellwig
2024-02-28 22:56 ` [PATCH 02/14] block: add a queue_limits_stack_bdev helper Christoph Hellwig
@ 2024-02-28 22:56 ` Christoph Hellwig
2024-02-28 22:56 ` [PATCH 04/14] md: add a mddev_trace_remap helper Christoph Hellwig
` (12 subsequent siblings)
15 siblings, 0 replies; 18+ messages in thread
From: Christoph Hellwig @ 2024-02-28 22:56 UTC (permalink / raw)
To: Jens Axboe, Mike Snitzer, Mikulas Patocka, Song Liu, Yu Kuai
Cc: dm-devel, linux-block, linux-raid
Use queue_limits_set which validates the limits and takes care of
updating the readahead settings instead of directly assigning them to
the queue. For that make sure all limits are actually updated before
the assignment.
Signed-off-by: Christoph Hellwig <hch@lst.de>
Reviewed-by: Mike Snitzer <snitzer@kernel.org>
---
block/blk-settings.c | 2 +-
drivers/md/dm-table.c | 27 ++++++++++++---------------
2 files changed, 13 insertions(+), 16 deletions(-)
diff --git a/block/blk-settings.c b/block/blk-settings.c
index 865fe4ebbf9b83..13865a9f89726c 100644
--- a/block/blk-settings.c
+++ b/block/blk-settings.c
@@ -267,7 +267,7 @@ int queue_limits_commit_update(struct request_queue *q,
EXPORT_SYMBOL_GPL(queue_limits_commit_update);
/**
- * queue_limits_commit_set - apply queue limits to queue
+ * queue_limits_set - apply queue limits to queue
* @q: queue to update
* @lim: limits to apply
*
diff --git a/drivers/md/dm-table.c b/drivers/md/dm-table.c
index 41f1d731ae5ac2..88114719fe187a 100644
--- a/drivers/md/dm-table.c
+++ b/drivers/md/dm-table.c
@@ -1963,26 +1963,27 @@ int dm_table_set_restrictions(struct dm_table *t, struct request_queue *q,
bool wc = false, fua = false;
int r;
- /*
- * Copy table's limits to the DM device's request_queue
- */
- q->limits = *limits;
-
if (dm_table_supports_nowait(t))
blk_queue_flag_set(QUEUE_FLAG_NOWAIT, q);
else
blk_queue_flag_clear(QUEUE_FLAG_NOWAIT, q);
if (!dm_table_supports_discards(t)) {
- 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;
+ limits->max_hw_discard_sectors = 0;
+ limits->discard_granularity = 0;
+ limits->discard_alignment = 0;
+ limits->discard_misaligned = 0;
}
+ if (!dm_table_supports_write_zeroes(t))
+ limits->max_write_zeroes_sectors = 0;
+
if (!dm_table_supports_secure_erase(t))
- q->limits.max_secure_erase_sectors = 0;
+ limits->max_secure_erase_sectors = 0;
+
+ r = queue_limits_set(q, limits);
+ if (r)
+ return r;
if (dm_table_supports_flush(t, (1UL << QUEUE_FLAG_WC))) {
wc = true;
@@ -2007,9 +2008,6 @@ int dm_table_set_restrictions(struct dm_table *t, struct request_queue *q,
else
blk_queue_flag_set(QUEUE_FLAG_NONROT, q);
- if (!dm_table_supports_write_zeroes(t))
- q->limits.max_write_zeroes_sectors = 0;
-
dm_table_verify_integrity(t);
/*
@@ -2047,7 +2045,6 @@ int dm_table_set_restrictions(struct dm_table *t, struct request_queue *q,
}
dm_update_crypto_profile(q, t);
- disk_update_readahead(t->md->disk);
/*
* Check for request-based device is left to
--
2.39.2
^ permalink raw reply related [flat|nested] 18+ messages in thread* [PATCH 04/14] md: add a mddev_trace_remap helper
2024-02-28 22:56 atomic queue limit updates for stackable devices v3 Christoph Hellwig
` (2 preceding siblings ...)
2024-02-28 22:56 ` [PATCH 03/14] dm: use queue_limits_set Christoph Hellwig
@ 2024-02-28 22:56 ` Christoph Hellwig
2024-02-28 22:56 ` [PATCH 05/14] md: add a mddev_add_trace_msg helper Christoph Hellwig
` (11 subsequent siblings)
15 siblings, 0 replies; 18+ messages in thread
From: Christoph Hellwig @ 2024-02-28 22:56 UTC (permalink / raw)
To: Jens Axboe, Mike Snitzer, Mikulas Patocka, Song Liu, Yu Kuai
Cc: dm-devel, linux-block, linux-raid
Add a helper to trace bio remapping that hides some argument
dereferences and the check for a DM-mapped MD device.
Signed-off-by: Christoph Hellwig <hch@lst.de>
---
drivers/md/md.c | 6 +-----
drivers/md/md.h | 8 ++++++++
drivers/md/raid0.c | 5 +----
drivers/md/raid1.c | 11 ++---------
drivers/md/raid10.c | 10 ++--------
drivers/md/raid5.c | 14 +++-----------
6 files changed, 17 insertions(+), 37 deletions(-)
diff --git a/drivers/md/md.c b/drivers/md/md.c
index 75266c34b1f99b..ccbc66ce8c4d13 100644
--- a/drivers/md/md.c
+++ b/drivers/md/md.c
@@ -65,7 +65,6 @@
#include <linux/percpu-refcount.h>
#include <linux/part_stat.h>
-#include <trace/events/block.h>
#include "md.h"
#include "md-bitmap.h"
#include "md-cluster.h"
@@ -8663,10 +8662,7 @@ void md_submit_discard_bio(struct mddev *mddev, struct md_rdev *rdev,
bio_chain(discard_bio, bio);
bio_clone_blkg_association(discard_bio, bio);
- if (mddev->gendisk)
- trace_block_bio_remap(discard_bio,
- disk_devt(mddev->gendisk),
- bio->bi_iter.bi_sector);
+ mddev_trace_remap(mddev, discard_bio, bio->bi_iter.bi_sector);
submit_bio_noacct(discard_bio);
}
EXPORT_SYMBOL_GPL(md_submit_discard_bio);
diff --git a/drivers/md/md.h b/drivers/md/md.h
index 8d881cc597992f..6465411d3afd5d 100644
--- a/drivers/md/md.h
+++ b/drivers/md/md.h
@@ -18,6 +18,7 @@
#include <linux/timer.h>
#include <linux/wait.h>
#include <linux/workqueue.h>
+#include <trace/events/block.h>
#include "md-cluster.h"
#define MaxSector (~(sector_t)0)
@@ -863,4 +864,11 @@ int do_md_run(struct mddev *mddev);
extern const struct block_device_operations md_fops;
+static inline void mddev_trace_remap(struct mddev *mddev, struct bio *bio,
+ sector_t sector)
+{
+ if (mddev->gendisk)
+ trace_block_bio_remap(bio, disk_devt(mddev->gendisk), sector);
+}
+
#endif /* _MD_MD_H */
diff --git a/drivers/md/raid0.c b/drivers/md/raid0.c
index c50a7abda744ad..aff094de974347 100644
--- a/drivers/md/raid0.c
+++ b/drivers/md/raid0.c
@@ -578,10 +578,7 @@ static void raid0_map_submit_bio(struct mddev *mddev, struct bio *bio)
bio_set_dev(bio, tmp_dev->bdev);
bio->bi_iter.bi_sector = sector + zone->dev_start +
tmp_dev->data_offset;
-
- if (mddev->gendisk)
- trace_block_bio_remap(bio, disk_devt(mddev->gendisk),
- bio_sector);
+ mddev_trace_remap(mddev, bio, bio_sector);
mddev_check_write_zeroes(mddev, bio);
submit_bio_noacct(bio);
}
diff --git a/drivers/md/raid1.c b/drivers/md/raid1.c
index 286f8b16c7bde7..cb64477fa89feb 100644
--- a/drivers/md/raid1.c
+++ b/drivers/md/raid1.c
@@ -1320,11 +1320,7 @@ static void raid1_read_request(struct mddev *mddev, struct bio *bio,
test_bit(R1BIO_FailFast, &r1_bio->state))
read_bio->bi_opf |= MD_FAILFAST;
read_bio->bi_private = r1_bio;
-
- if (mddev->gendisk)
- trace_block_bio_remap(read_bio, disk_devt(mddev->gendisk),
- r1_bio->sector);
-
+ mddev_trace_remap(mddev, read_bio, r1_bio->sector);
submit_bio_noacct(read_bio);
}
@@ -1557,10 +1553,7 @@ static void raid1_write_request(struct mddev *mddev, struct bio *bio,
mbio->bi_private = r1_bio;
atomic_inc(&r1_bio->remaining);
-
- if (mddev->gendisk)
- trace_block_bio_remap(mbio, disk_devt(mddev->gendisk),
- r1_bio->sector);
+ mddev_trace_remap(mddev, mbio, r1_bio->sector);
/* flush_pending_writes() needs access to the rdev so...*/
mbio->bi_bdev = (void *)rdev;
if (!raid1_add_bio_to_plug(mddev, mbio, raid1_unplug, disks)) {
diff --git a/drivers/md/raid10.c b/drivers/md/raid10.c
index 7412066ea22c7a..ae90cca8335b50 100644
--- a/drivers/md/raid10.c
+++ b/drivers/md/raid10.c
@@ -1249,10 +1249,7 @@ static void raid10_read_request(struct mddev *mddev, struct bio *bio,
test_bit(R10BIO_FailFast, &r10_bio->state))
read_bio->bi_opf |= MD_FAILFAST;
read_bio->bi_private = r10_bio;
-
- if (mddev->gendisk)
- trace_block_bio_remap(read_bio, disk_devt(mddev->gendisk),
- r10_bio->sector);
+ mddev_trace_remap(mddev, read_bio, r10_bio->sector);
submit_bio_noacct(read_bio);
return;
}
@@ -1288,10 +1285,7 @@ static void raid10_write_one_disk(struct mddev *mddev, struct r10bio *r10_bio,
&& enough(conf, devnum))
mbio->bi_opf |= MD_FAILFAST;
mbio->bi_private = r10_bio;
-
- if (conf->mddev->gendisk)
- trace_block_bio_remap(mbio, disk_devt(conf->mddev->gendisk),
- r10_bio->sector);
+ mddev_trace_remap(mddev, mbio, r10_bio->sector);
/* flush_pending_writes() needs access to the rdev so...*/
mbio->bi_bdev = (void *)rdev;
diff --git a/drivers/md/raid5.c b/drivers/md/raid5.c
index 14f2cf75abbd72..c7da69c6e7c50c 100644
--- a/drivers/md/raid5.c
+++ b/drivers/md/raid5.c
@@ -1295,10 +1295,7 @@ static void ops_run_io(struct stripe_head *sh, struct stripe_head_state *s)
if (rrdev)
set_bit(R5_DOUBLE_LOCKED, &sh->dev[i].flags);
- if (conf->mddev->gendisk)
- trace_block_bio_remap(bi,
- disk_devt(conf->mddev->gendisk),
- sh->dev[i].sector);
+ mddev_trace_remap(conf->mddev, bi, sh->dev[i].sector);
if (should_defer && op_is_write(op))
bio_list_add(&pending_bios, bi);
else
@@ -1342,10 +1339,7 @@ static void ops_run_io(struct stripe_head *sh, struct stripe_head_state *s)
*/
if (op == REQ_OP_DISCARD)
rbi->bi_vcnt = 0;
- if (conf->mddev->gendisk)
- trace_block_bio_remap(rbi,
- disk_devt(conf->mddev->gendisk),
- sh->dev[i].sector);
+ mddev_trace_remap(conf->mddev, rbi, sh->dev[i].sector);
if (should_defer && op_is_write(op))
bio_list_add(&pending_bios, rbi);
else
@@ -5530,9 +5524,7 @@ static int raid5_read_one_chunk(struct mddev *mddev, struct bio *raid_bio)
spin_unlock_irq(&conf->device_lock);
}
- if (mddev->gendisk)
- trace_block_bio_remap(align_bio, disk_devt(mddev->gendisk),
- raid_bio->bi_iter.bi_sector);
+ mddev_trace_remap(mddev, align_bio, raid_bio->bi_iter.bi_sector);
submit_bio_noacct(align_bio);
return 1;
}
--
2.39.2
^ permalink raw reply related [flat|nested] 18+ messages in thread* [PATCH 05/14] md: add a mddev_add_trace_msg helper
2024-02-28 22:56 atomic queue limit updates for stackable devices v3 Christoph Hellwig
` (3 preceding siblings ...)
2024-02-28 22:56 ` [PATCH 04/14] md: add a mddev_trace_remap helper Christoph Hellwig
@ 2024-02-28 22:56 ` Christoph Hellwig
2024-02-28 22:56 ` [PATCH 06/14] md: add a mddev_is_dm helper Christoph Hellwig
` (10 subsequent siblings)
15 siblings, 0 replies; 18+ messages in thread
From: Christoph Hellwig @ 2024-02-28 22:56 UTC (permalink / raw)
To: Jens Axboe, Mike Snitzer, Mikulas Patocka, Song Liu, Yu Kuai
Cc: dm-devel, linux-block, linux-raid
Add a small wrapper around blk_add_trace_msg that hides some argument
dereferences and the check for a DM-mapped MD device.
Signed-off-by: Christoph Hellwig <hch@lst.de>
---
drivers/md/md-bitmap.c | 9 +++------
drivers/md/md.c | 3 +--
drivers/md/md.h | 6 ++++++
drivers/md/raid1.c | 10 ++++------
drivers/md/raid10.c | 15 +++++++--------
drivers/md/raid5.c | 14 +++++++-------
6 files changed, 28 insertions(+), 29 deletions(-)
diff --git a/drivers/md/md-bitmap.c b/drivers/md/md-bitmap.c
index 9672f75c30503c..a0935a3d66c2d7 100644
--- a/drivers/md/md-bitmap.c
+++ b/drivers/md/md-bitmap.c
@@ -1043,9 +1043,8 @@ void md_bitmap_unplug(struct bitmap *bitmap)
if (dirty || need_write) {
if (!writing) {
md_bitmap_wait_writes(bitmap);
- if (bitmap->mddev->queue)
- blk_add_trace_msg(bitmap->mddev->queue,
- "md bitmap_unplug");
+ mddev_add_trace_msg(bitmap->mddev,
+ "md bitmap_unplug");
}
clear_page_attr(bitmap, i, BITMAP_PAGE_PENDING);
filemap_write_page(bitmap, i, false);
@@ -1316,9 +1315,7 @@ void md_bitmap_daemon_work(struct mddev *mddev)
}
bitmap->allclean = 1;
- if (bitmap->mddev->queue)
- blk_add_trace_msg(bitmap->mddev->queue,
- "md bitmap_daemon_work");
+ mddev_add_trace_msg(bitmap->mddev, "md bitmap_daemon_work");
/* Any file-page which is PENDING now needs to be written.
* So set NEEDWRITE now, then after we make any last-minute changes
diff --git a/drivers/md/md.c b/drivers/md/md.c
index ccbc66ce8c4d13..409e57242b27f6 100644
--- a/drivers/md/md.c
+++ b/drivers/md/md.c
@@ -2847,8 +2847,7 @@ void md_update_sb(struct mddev *mddev, int force_change)
pr_debug("md: updating %s RAID superblock on device (in sync %d)\n",
mdname(mddev), mddev->in_sync);
- if (mddev->queue)
- blk_add_trace_msg(mddev->queue, "md md_update_sb");
+ mddev_add_trace_msg(mddev, "md md_update_sb");
rewrite:
md_bitmap_update_sb(mddev->bitmap);
rdev_for_each(rdev, mddev) {
diff --git a/drivers/md/md.h b/drivers/md/md.h
index 6465411d3afd5d..91ee8951fc8dcb 100644
--- a/drivers/md/md.h
+++ b/drivers/md/md.h
@@ -871,4 +871,10 @@ static inline void mddev_trace_remap(struct mddev *mddev, struct bio *bio,
trace_block_bio_remap(bio, disk_devt(mddev->gendisk), sector);
}
+#define mddev_add_trace_msg(mddev, fmt, args...) \
+do { \
+ if ((mddev)->gendisk) \
+ blk_add_trace_msg((mddev)->queue, fmt, ##args); \
+} while (0)
+
#endif /* _MD_MD_H */
diff --git a/drivers/md/raid1.c b/drivers/md/raid1.c
index cb64477fa89feb..3f47fe828b21bb 100644
--- a/drivers/md/raid1.c
+++ b/drivers/md/raid1.c
@@ -46,9 +46,6 @@
static void allow_barrier(struct r1conf *conf, sector_t sector_nr);
static void lower_barrier(struct r1conf *conf, sector_t sector_nr);
-#define raid1_log(md, fmt, args...) \
- do { if ((md)->queue) blk_add_trace_msg((md)->queue, "raid1 " fmt, ##args); } while (0)
-
#define RAID_1_10_NAME "raid1"
#include "raid1-10.c"
@@ -1098,7 +1095,7 @@ static void freeze_array(struct r1conf *conf, int extra)
*/
spin_lock_irq(&conf->resync_lock);
conf->array_frozen = 1;
- raid1_log(conf->mddev, "wait freeze");
+ mddev_add_trace_msg(conf->mddev, "raid1 wait freeze");
wait_event_lock_irq_cmd(
conf->wait_barrier,
get_unqueued_pending(conf) == extra,
@@ -1287,7 +1284,7 @@ static void raid1_read_request(struct mddev *mddev, struct bio *bio,
* Reading from a write-mostly device must take care not to
* over-take any writes that are 'behind'
*/
- raid1_log(mddev, "wait behind writes");
+ mddev_add_trace_msg(mddev, "raid1 wait behind writes");
wait_event(bitmap->behind_wait,
atomic_read(&bitmap->behind_writes) == 0);
}
@@ -1470,7 +1467,8 @@ static void raid1_write_request(struct mddev *mddev, struct bio *bio,
bio_wouldblock_error(bio);
return;
}
- raid1_log(mddev, "wait rdev %d blocked", blocked_rdev->raid_disk);
+ mddev_add_trace_msg(mddev, "raid1 wait rdev %d blocked",
+ blocked_rdev->raid_disk);
md_wait_for_blocked_rdev(blocked_rdev, mddev);
wait_barrier(conf, bio->bi_iter.bi_sector, false);
goto retry_write;
diff --git a/drivers/md/raid10.c b/drivers/md/raid10.c
index ae90cca8335b50..b6c5194c22308d 100644
--- a/drivers/md/raid10.c
+++ b/drivers/md/raid10.c
@@ -76,9 +76,6 @@ static void reshape_request_write(struct mddev *mddev, struct r10bio *r10_bio);
static void end_reshape_write(struct bio *bio);
static void end_reshape(struct r10conf *conf);
-#define raid10_log(md, fmt, args...) \
- do { if ((md)->queue) blk_add_trace_msg((md)->queue, "raid10 " fmt, ##args); } while (0)
-
#include "raid1-10.c"
#define NULL_CMD
@@ -1033,7 +1030,7 @@ static bool wait_barrier(struct r10conf *conf, bool nowait)
ret = false;
} else {
conf->nr_waiting++;
- raid10_log(conf->mddev, "wait barrier");
+ mddev_add_trace_msg(conf->mddev, "raid10 wait barrier");
wait_event_barrier(conf, stop_waiting_barrier(conf));
conf->nr_waiting--;
}
@@ -1152,7 +1149,7 @@ static bool regular_request_wait(struct mddev *mddev, struct r10conf *conf,
bio_wouldblock_error(bio);
return false;
}
- raid10_log(conf->mddev, "wait reshape");
+ mddev_add_trace_msg(conf->mddev, "raid10 wait reshape");
wait_event(conf->wait_barrier,
conf->reshape_progress <= bio->bi_iter.bi_sector ||
conf->reshape_progress >= bio->bi_iter.bi_sector +
@@ -1354,8 +1351,9 @@ static void wait_blocked_dev(struct mddev *mddev, struct r10bio *r10_bio)
if (unlikely(blocked_rdev)) {
/* Have to wait for this device to get unblocked, then retry */
allow_barrier(conf);
- raid10_log(conf->mddev, "%s wait rdev %d blocked",
- __func__, blocked_rdev->raid_disk);
+ mddev_add_trace_msg(conf->mddev,
+ "raid10 %s wait rdev %d blocked",
+ __func__, blocked_rdev->raid_disk);
md_wait_for_blocked_rdev(blocked_rdev, mddev);
wait_barrier(conf, false);
goto retry_wait;
@@ -1410,7 +1408,8 @@ static void raid10_write_request(struct mddev *mddev, struct bio *bio,
bio_wouldblock_error(bio);
return;
}
- raid10_log(conf->mddev, "wait reshape metadata");
+ mddev_add_trace_msg(conf->mddev,
+ "raid10 wait reshape metadata");
wait_event(mddev->sb_wait,
!test_bit(MD_SB_CHANGE_PENDING, &mddev->sb_flags));
diff --git a/drivers/md/raid5.c b/drivers/md/raid5.c
index c7da69c6e7c50c..969df5c584653e 100644
--- a/drivers/md/raid5.c
+++ b/drivers/md/raid5.c
@@ -4199,10 +4199,9 @@ static int handle_stripe_dirtying(struct r5conf *conf,
set_bit(STRIPE_HANDLE, &sh->state);
if ((rmw < rcw || (rmw == rcw && conf->rmw_level == PARITY_PREFER_RMW)) && rmw > 0) {
/* prefer read-modify-write, but need to get some data */
- if (conf->mddev->queue)
- blk_add_trace_msg(conf->mddev->queue,
- "raid5 rmw %llu %d",
- (unsigned long long)sh->sector, rmw);
+ mddev_add_trace_msg(conf->mddev, "raid5 rmw %llu %d",
+ sh->sector, rmw);
+
for (i = disks; i--; ) {
struct r5dev *dev = &sh->dev[i];
if (test_bit(R5_InJournal, &dev->flags) &&
@@ -4280,9 +4279,10 @@ static int handle_stripe_dirtying(struct r5conf *conf,
}
}
if (rcw && conf->mddev->queue)
- blk_add_trace_msg(conf->mddev->queue, "raid5 rcw %llu %d %d %d",
- (unsigned long long)sh->sector,
- rcw, qread, test_bit(STRIPE_DELAYED, &sh->state));
+ mddev_add_trace_msg(conf->mddev,
+ "raid5 rcw %llu %d %d %d",
+ sh->sector, rcw, qread,
+ test_bit(STRIPE_DELAYED, &sh->state));
}
if (rcw > disks && rmw > disks &&
--
2.39.2
^ permalink raw reply related [flat|nested] 18+ messages in thread* [PATCH 06/14] md: add a mddev_is_dm helper
2024-02-28 22:56 atomic queue limit updates for stackable devices v3 Christoph Hellwig
` (4 preceding siblings ...)
2024-02-28 22:56 ` [PATCH 05/14] md: add a mddev_add_trace_msg helper Christoph Hellwig
@ 2024-02-28 22:56 ` Christoph Hellwig
2024-02-28 22:56 ` [PATCH 07/14] md: add queue limit helpers Christoph Hellwig
` (9 subsequent siblings)
15 siblings, 0 replies; 18+ messages in thread
From: Christoph Hellwig @ 2024-02-28 22:56 UTC (permalink / raw)
To: Jens Axboe, Mike Snitzer, Mikulas Patocka, Song Liu, Yu Kuai
Cc: dm-devel, linux-block, linux-raid
Add a helper to check for a DM-mapped MD device instead of using
the obfuscated ->gendisk or ->queue NULL checks.
Signed-off-by: Christoph Hellwig <hch@lst.de>
---
drivers/md/md.c | 15 +++++++--------
drivers/md/md.h | 12 ++++++++++--
drivers/md/raid0.c | 2 +-
drivers/md/raid1.c | 13 +++++--------
drivers/md/raid10.c | 10 +++++-----
drivers/md/raid5.c | 21 ++++++++++-----------
6 files changed, 38 insertions(+), 35 deletions(-)
diff --git a/drivers/md/md.c b/drivers/md/md.c
index 409e57242b27f6..01a219b2559bdb 100644
--- a/drivers/md/md.c
+++ b/drivers/md/md.c
@@ -2401,7 +2401,7 @@ int md_integrity_register(struct mddev *mddev)
if (list_empty(&mddev->disks))
return 0; /* nothing to do */
- if (!mddev->gendisk || blk_get_integrity(mddev->gendisk))
+ if (mddev_is_dm(mddev) || blk_get_integrity(mddev->gendisk))
return 0; /* shouldn't register, or already is */
rdev_for_each(rdev, mddev) {
/* skip spares and non-functional disks */
@@ -2454,7 +2454,7 @@ int md_integrity_add_rdev(struct md_rdev *rdev, struct mddev *mddev)
{
struct blk_integrity *bi_mddev;
- if (!mddev->gendisk)
+ if (mddev_is_dm(mddev))
return 0;
bi_mddev = blk_get_integrity(mddev->gendisk);
@@ -5923,7 +5923,7 @@ int md_run(struct mddev *mddev)
invalidate_bdev(rdev->bdev);
if (mddev->ro != MD_RDONLY && rdev_read_only(rdev)) {
mddev->ro = MD_RDONLY;
- if (mddev->gendisk)
+ if (!mddev_is_dm(mddev))
set_disk_ro(mddev->gendisk, 1);
}
@@ -6082,7 +6082,7 @@ int md_run(struct mddev *mddev)
}
}
- if (mddev->queue) {
+ if (!mddev_is_dm(mddev)) {
bool nonrot = true;
rdev_for_each(rdev, mddev) {
@@ -6338,7 +6338,7 @@ static void mddev_detach(struct mddev *mddev)
mddev->pers->quiesce(mddev, 0);
}
md_unregister_thread(mddev, &mddev->thread);
- if (mddev->queue)
+ if (!mddev_is_dm(mddev))
blk_sync_queue(mddev->queue); /* the unplug fn references 'conf'*/
}
@@ -7304,10 +7304,9 @@ static int update_size(struct mddev *mddev, sector_t num_sectors)
if (!rv) {
if (mddev_is_clustered(mddev))
md_cluster_ops->update_size(mddev, old_dev_sectors);
- else if (mddev->queue) {
+ else if (!mddev_is_dm(mddev))
set_capacity_and_notify(mddev->gendisk,
mddev->array_sectors);
- }
}
return rv;
}
@@ -9137,7 +9136,7 @@ void md_do_sync(struct md_thread *thread)
mddev->delta_disks > 0 &&
mddev->pers->finish_reshape &&
mddev->pers->size &&
- mddev->queue) {
+ !mddev_is_dm(mddev)) {
mddev_lock_nointr(mddev);
md_set_array_sectors(mddev, mddev->pers->size(mddev, 0, 0));
mddev_unlock(mddev);
diff --git a/drivers/md/md.h b/drivers/md/md.h
index 91ee8951fc8dcb..b08e655f8bec41 100644
--- a/drivers/md/md.h
+++ b/drivers/md/md.h
@@ -864,16 +864,24 @@ int do_md_run(struct mddev *mddev);
extern const struct block_device_operations md_fops;
+/*
+ * MD devices can be used undeneath by DM, in which case ->gendisk is NULL.
+ */
+static inline bool mddev_is_dm(struct mddev *mddev)
+{
+ return !mddev->gendisk;
+}
+
static inline void mddev_trace_remap(struct mddev *mddev, struct bio *bio,
sector_t sector)
{
- if (mddev->gendisk)
+ if (!mddev_is_dm(mddev))
trace_block_bio_remap(bio, disk_devt(mddev->gendisk), sector);
}
#define mddev_add_trace_msg(mddev, fmt, args...) \
do { \
- if ((mddev)->gendisk) \
+ if (!mddev_is_dm(mddev)) \
blk_add_trace_msg((mddev)->queue, fmt, ##args); \
} while (0)
diff --git a/drivers/md/raid0.c b/drivers/md/raid0.c
index aff094de974347..9f787ae77ede88 100644
--- a/drivers/md/raid0.c
+++ b/drivers/md/raid0.c
@@ -399,7 +399,7 @@ static int raid0_run(struct mddev *mddev)
mddev->private = conf;
}
conf = mddev->private;
- if (mddev->queue) {
+ if (!mddev_is_dm(mddev)) {
struct md_rdev *rdev;
blk_queue_max_hw_sectors(mddev->queue, mddev->chunk_sectors);
diff --git a/drivers/md/raid1.c b/drivers/md/raid1.c
index 3f47fe828b21bb..3b1227f67a6d61 100644
--- a/drivers/md/raid1.c
+++ b/drivers/md/raid1.c
@@ -1782,7 +1782,7 @@ static int raid1_add_disk(struct mddev *mddev, struct md_rdev *rdev)
for (mirror = first; mirror <= last; mirror++) {
p = conf->mirrors + mirror;
if (!p->rdev) {
- if (mddev->gendisk)
+ if (!mddev_is_dm(mddev))
disk_stack_limits(mddev->gendisk, rdev->bdev,
rdev->data_offset << 9);
@@ -3109,14 +3109,11 @@ static int raid1_run(struct mddev *mddev)
if (IS_ERR(conf))
return PTR_ERR(conf);
- if (mddev->queue)
+ if (!mddev_is_dm(mddev)) {
blk_queue_max_write_zeroes_sectors(mddev->queue, 0);
-
- rdev_for_each(rdev, mddev) {
- if (!mddev->gendisk)
- continue;
- disk_stack_limits(mddev->gendisk, rdev->bdev,
- rdev->data_offset << 9);
+ rdev_for_each(rdev, mddev)
+ disk_stack_limits(mddev->gendisk, rdev->bdev,
+ rdev->data_offset << 9);
}
mddev->degraded = 0;
diff --git a/drivers/md/raid10.c b/drivers/md/raid10.c
index b6c5194c22308d..95fa9e728f95a9 100644
--- a/drivers/md/raid10.c
+++ b/drivers/md/raid10.c
@@ -2124,7 +2124,7 @@ static int raid10_add_disk(struct mddev *mddev, struct md_rdev *rdev)
continue;
}
- if (mddev->gendisk)
+ if (!mddev_is_dm(mddev))
disk_stack_limits(mddev->gendisk, rdev->bdev,
rdev->data_offset << 9);
@@ -2144,7 +2144,7 @@ static int raid10_add_disk(struct mddev *mddev, struct md_rdev *rdev)
set_bit(Replacement, &rdev->flags);
rdev->raid_disk = repl_slot;
err = 0;
- if (mddev->gendisk)
+ if (!mddev_is_dm(mddev))
disk_stack_limits(mddev->gendisk, rdev->bdev,
rdev->data_offset << 9);
conf->fullsync = 1;
@@ -4040,7 +4040,7 @@ static int raid10_run(struct mddev *mddev)
}
}
- if (mddev->queue) {
+ if (!mddev_is_dm(conf->mddev)) {
blk_queue_max_write_zeroes_sectors(mddev->queue, 0);
blk_queue_io_min(mddev->queue, mddev->chunk_sectors << 9);
raid10_set_io_opt(conf);
@@ -4074,7 +4074,7 @@ static int raid10_run(struct mddev *mddev)
if (first || diff < min_offset_diff)
min_offset_diff = diff;
- if (mddev->gendisk)
+ if (!mddev_is_dm(mddev))
disk_stack_limits(mddev->gendisk, rdev->bdev,
rdev->data_offset << 9);
@@ -4959,7 +4959,7 @@ static void end_reshape(struct r10conf *conf)
conf->reshape_safe = MaxSector;
spin_unlock_irq(&conf->device_lock);
- if (conf->mddev->queue)
+ if (!mddev_is_dm(conf->mddev))
raid10_set_io_opt(conf);
conf->fullsync = 0;
}
diff --git a/drivers/md/raid5.c b/drivers/md/raid5.c
index 969df5c584653e..287fc1540a8d32 100644
--- a/drivers/md/raid5.c
+++ b/drivers/md/raid5.c
@@ -2416,12 +2416,12 @@ static int grow_stripes(struct r5conf *conf, int num)
size_t namelen = sizeof(conf->cache_name[0]);
int devs = max(conf->raid_disks, conf->previous_raid_disks);
- if (conf->mddev->gendisk)
+ if (mddev_is_dm(conf->mddev))
snprintf(conf->cache_name[0], namelen,
- "raid%d-%s", conf->level, mdname(conf->mddev));
+ "raid%d-%p", conf->level, conf->mddev);
else
snprintf(conf->cache_name[0], namelen,
- "raid%d-%p", conf->level, conf->mddev);
+ "raid%d-%s", conf->level, mdname(conf->mddev));
snprintf(conf->cache_name[1], namelen, "%.27s-alt", conf->cache_name[0]);
conf->active_name = 0;
@@ -4278,11 +4278,10 @@ static int handle_stripe_dirtying(struct r5conf *conf,
set_bit(STRIPE_DELAYED, &sh->state);
}
}
- if (rcw && conf->mddev->queue)
- mddev_add_trace_msg(conf->mddev,
- "raid5 rcw %llu %d %d %d",
- sh->sector, rcw, qread,
- test_bit(STRIPE_DELAYED, &sh->state));
+ if (rcw && !mddev_is_dm(conf->mddev))
+ blk_add_trace_msg(conf->mddev->queue, "raid5 rcw %llu %d %d %d",
+ (unsigned long long)sh->sector,
+ rcw, qread, test_bit(STRIPE_DELAYED, &sh->state));
}
if (rcw > disks && rmw > disks &&
@@ -5693,7 +5692,7 @@ static void raid5_unplug(struct blk_plug_cb *blk_cb, bool from_schedule)
}
release_inactive_stripe_list(conf, cb->temp_inactive_list,
NR_STRIPE_HASH_LOCKS);
- if (mddev->queue)
+ if (!mddev_is_dm(mddev))
trace_block_unplug(mddev->queue, cnt, !from_schedule);
kfree(cb);
}
@@ -7942,7 +7941,7 @@ static int raid5_run(struct mddev *mddev)
mdname(mddev));
md_set_array_sectors(mddev, raid5_size(mddev, 0, 0));
- if (mddev->queue) {
+ if (!mddev_is_dm(mddev)) {
int chunk_size;
/* read-ahead size must cover two whole stripes, which
* is 2 * (datadisks) * chunksize where 'n' is the
@@ -8546,7 +8545,7 @@ static void end_reshape(struct r5conf *conf)
spin_unlock_irq(&conf->device_lock);
wake_up(&conf->wait_for_overlap);
- if (conf->mddev->queue)
+ if (!mddev_is_dm(conf->mddev))
raid5_set_io_opt(conf);
}
}
--
2.39.2
^ permalink raw reply related [flat|nested] 18+ messages in thread* [PATCH 07/14] md: add queue limit helpers
2024-02-28 22:56 atomic queue limit updates for stackable devices v3 Christoph Hellwig
` (5 preceding siblings ...)
2024-02-28 22:56 ` [PATCH 06/14] md: add a mddev_is_dm helper Christoph Hellwig
@ 2024-02-28 22:56 ` Christoph Hellwig
2024-02-28 22:56 ` [PATCH 08/14] md/raid0: use the atomic queue limit update APIs Christoph Hellwig
` (8 subsequent siblings)
15 siblings, 0 replies; 18+ messages in thread
From: Christoph Hellwig @ 2024-02-28 22:56 UTC (permalink / raw)
To: Jens Axboe, Mike Snitzer, Mikulas Patocka, Song Liu, Yu Kuai
Cc: dm-devel, linux-block, linux-raid
Add a few helpers that wrap the block queue limits API for use in MD.
Signed-off-by: Christoph Hellwig <hch@lst.de>
---
drivers/md/md.c | 45 +++++++++++++++++++++++++++++++++++++++++++++
drivers/md/md.h | 3 +++
2 files changed, 48 insertions(+)
diff --git a/drivers/md/md.c b/drivers/md/md.c
index 01a219b2559bdb..bfc38cb4b31014 100644
--- a/drivers/md/md.c
+++ b/drivers/md/md.c
@@ -5697,6 +5697,51 @@ static const struct kobj_type md_ktype = {
int mdp_major = 0;
+/* stack the limit for all rdevs into lim */
+void mddev_stack_rdev_limits(struct mddev *mddev, struct queue_limits *lim)
+{
+ struct md_rdev *rdev;
+
+ rdev_for_each(rdev, mddev) {
+ queue_limits_stack_bdev(lim, rdev->bdev, rdev->data_offset,
+ mddev->gendisk->disk_name);
+ }
+}
+EXPORT_SYMBOL_GPL(mddev_stack_rdev_limits);
+
+/* apply the extra stacking limits from a new rdev into mddev */
+int mddev_stack_new_rdev(struct mddev *mddev, struct md_rdev *rdev)
+{
+ struct queue_limits lim;
+
+ if (mddev_is_dm(mddev))
+ return 0;
+
+ lim = queue_limits_start_update(mddev->queue);
+ queue_limits_stack_bdev(&lim, rdev->bdev, rdev->data_offset,
+ mddev->gendisk->disk_name);
+ return queue_limits_commit_update(mddev->queue, &lim);
+}
+EXPORT_SYMBOL_GPL(mddev_stack_new_rdev);
+
+/* update the optimal I/O size after a reshape */
+void mddev_update_io_opt(struct mddev *mddev, unsigned int nr_stripes)
+{
+ struct queue_limits lim;
+
+ if (mddev_is_dm(mddev))
+ return;
+
+ /* don't bother updating io_opt if we can't suspend the array */
+ if (mddev_suspend(mddev, false) < 0)
+ return;
+ lim = queue_limits_start_update(mddev->gendisk->queue);
+ lim.io_opt = lim.io_min * nr_stripes;
+ queue_limits_commit_update(mddev->gendisk->queue, &lim);
+ mddev_resume(mddev);
+}
+EXPORT_SYMBOL_GPL(mddev_update_io_opt);
+
static void mddev_delayed_delete(struct work_struct *ws)
{
struct mddev *mddev = container_of(ws, struct mddev, del_work);
diff --git a/drivers/md/md.h b/drivers/md/md.h
index b08e655f8bec41..5db58d076256d3 100644
--- a/drivers/md/md.h
+++ b/drivers/md/md.h
@@ -861,6 +861,9 @@ void md_autostart_arrays(int part);
int md_set_array_info(struct mddev *mddev, struct mdu_array_info_s *info);
int md_add_new_disk(struct mddev *mddev, struct mdu_disk_info_s *info);
int do_md_run(struct mddev *mddev);
+void mddev_stack_rdev_limits(struct mddev *mddev, struct queue_limits *lim);
+int mddev_stack_new_rdev(struct mddev *mddev, struct md_rdev *rdev);
+void mddev_update_io_opt(struct mddev *mddev, unsigned int nr_stripes);
extern const struct block_device_operations md_fops;
--
2.39.2
^ permalink raw reply related [flat|nested] 18+ messages in thread* [PATCH 08/14] md/raid0: use the atomic queue limit update APIs
2024-02-28 22:56 atomic queue limit updates for stackable devices v3 Christoph Hellwig
` (6 preceding siblings ...)
2024-02-28 22:56 ` [PATCH 07/14] md: add queue limit helpers Christoph Hellwig
@ 2024-02-28 22:56 ` Christoph Hellwig
2024-02-28 22:56 ` [PATCH 09/14] md/raid1: " Christoph Hellwig
` (7 subsequent siblings)
15 siblings, 0 replies; 18+ messages in thread
From: Christoph Hellwig @ 2024-02-28 22:56 UTC (permalink / raw)
To: Jens Axboe, Mike Snitzer, Mikulas Patocka, Song Liu, Yu Kuai
Cc: dm-devel, linux-block, linux-raid
Build the queue limits outside the queue and apply them using
queue_limits_set. To make the code more obvious also split the queue
limits handling into a separate helper function.
Signed-off-by: Christoph Hellwig <hch@lst.de>
---
drivers/md/raid0.c | 35 ++++++++++++++++++++---------------
1 file changed, 20 insertions(+), 15 deletions(-)
diff --git a/drivers/md/raid0.c b/drivers/md/raid0.c
index 9f787ae77ede88..f65aa6ecec0482 100644
--- a/drivers/md/raid0.c
+++ b/drivers/md/raid0.c
@@ -379,6 +379,19 @@ static void raid0_free(struct mddev *mddev, void *priv)
free_conf(mddev, conf);
}
+static int raid0_set_limits(struct mddev *mddev)
+{
+ struct queue_limits lim;
+
+ blk_set_stacking_limits(&lim);
+ lim.max_hw_sectors = mddev->chunk_sectors;
+ lim.max_write_zeroes_sectors = mddev->chunk_sectors;
+ lim.io_min = mddev->chunk_sectors << 9;
+ lim.io_opt = lim.io_min * mddev->raid_disks;
+ mddev_stack_rdev_limits(mddev, &lim);
+ return queue_limits_set(mddev->queue, &lim);
+}
+
static int raid0_run(struct mddev *mddev)
{
struct r0conf *conf;
@@ -400,19 +413,9 @@ static int raid0_run(struct mddev *mddev)
}
conf = mddev->private;
if (!mddev_is_dm(mddev)) {
- struct md_rdev *rdev;
-
- blk_queue_max_hw_sectors(mddev->queue, mddev->chunk_sectors);
- blk_queue_max_write_zeroes_sectors(mddev->queue, mddev->chunk_sectors);
-
- blk_queue_io_min(mddev->queue, mddev->chunk_sectors << 9);
- blk_queue_io_opt(mddev->queue,
- (mddev->chunk_sectors << 9) * mddev->raid_disks);
-
- rdev_for_each(rdev, mddev) {
- disk_stack_limits(mddev->gendisk, rdev->bdev,
- rdev->data_offset << 9);
- }
+ ret = raid0_set_limits(mddev);
+ if (ret)
+ goto out_free_conf;
}
/* calculate array device size */
@@ -426,8 +429,10 @@ static int raid0_run(struct mddev *mddev)
ret = md_integrity_register(mddev);
if (ret)
- free_conf(mddev, conf);
-
+ goto out_free_conf;
+ return 0;
+out_free_conf:
+ free_conf(mddev, conf);
return ret;
}
--
2.39.2
^ permalink raw reply related [flat|nested] 18+ messages in thread* [PATCH 09/14] md/raid1: use the atomic queue limit update APIs
2024-02-28 22:56 atomic queue limit updates for stackable devices v3 Christoph Hellwig
` (7 preceding siblings ...)
2024-02-28 22:56 ` [PATCH 08/14] md/raid0: use the atomic queue limit update APIs Christoph Hellwig
@ 2024-02-28 22:56 ` Christoph Hellwig
2024-02-28 22:56 ` [PATCH 10/14] md/raid5: " Christoph Hellwig
` (6 subsequent siblings)
15 siblings, 0 replies; 18+ messages in thread
From: Christoph Hellwig @ 2024-02-28 22:56 UTC (permalink / raw)
To: Jens Axboe, Mike Snitzer, Mikulas Patocka, Song Liu, Yu Kuai
Cc: dm-devel, linux-block, linux-raid
Build the queue limits outside the queue and apply them using
queue_limits_set. To make the code more obvious also split the queue
limits handling into a separate helper function.
Signed-off-by: Christoph Hellwig <hch@lst.de>
---
drivers/md/raid1.c | 25 ++++++++++++++++---------
1 file changed, 16 insertions(+), 9 deletions(-)
diff --git a/drivers/md/raid1.c b/drivers/md/raid1.c
index 3b1227f67a6d61..75329ab2dbd8de 100644
--- a/drivers/md/raid1.c
+++ b/drivers/md/raid1.c
@@ -1782,10 +1782,9 @@ static int raid1_add_disk(struct mddev *mddev, struct md_rdev *rdev)
for (mirror = first; mirror <= last; mirror++) {
p = conf->mirrors + mirror;
if (!p->rdev) {
- if (!mddev_is_dm(mddev))
- disk_stack_limits(mddev->gendisk, rdev->bdev,
- rdev->data_offset << 9);
-
+ err = mddev_stack_new_rdev(mddev, rdev);
+ if (err)
+ return err;
p->head_position = 0;
rdev->raid_disk = mirror;
err = 0;
@@ -3077,12 +3076,21 @@ static struct r1conf *setup_conf(struct mddev *mddev)
return ERR_PTR(err);
}
+static int raid1_set_limits(struct mddev *mddev)
+{
+ struct queue_limits lim;
+
+ blk_set_stacking_limits(&lim);
+ lim.max_write_zeroes_sectors = 0;
+ mddev_stack_rdev_limits(mddev, &lim);
+ return queue_limits_set(mddev->queue, &lim);
+}
+
static void raid1_free(struct mddev *mddev, void *priv);
static int raid1_run(struct mddev *mddev)
{
struct r1conf *conf;
int i;
- struct md_rdev *rdev;
int ret;
if (mddev->level != 1) {
@@ -3110,10 +3118,9 @@ static int raid1_run(struct mddev *mddev)
return PTR_ERR(conf);
if (!mddev_is_dm(mddev)) {
- blk_queue_max_write_zeroes_sectors(mddev->queue, 0);
- rdev_for_each(rdev, mddev)
- disk_stack_limits(mddev->gendisk, rdev->bdev,
- rdev->data_offset << 9);
+ ret = raid1_set_limits(mddev);
+ if (ret)
+ goto abort;
}
mddev->degraded = 0;
--
2.39.2
^ permalink raw reply related [flat|nested] 18+ messages in thread* [PATCH 10/14] md/raid5: use the atomic queue limit update APIs
2024-02-28 22:56 atomic queue limit updates for stackable devices v3 Christoph Hellwig
` (8 preceding siblings ...)
2024-02-28 22:56 ` [PATCH 09/14] md/raid1: " Christoph Hellwig
@ 2024-02-28 22:56 ` Christoph Hellwig
2024-02-28 22:56 ` [PATCH 11/14] md/raid10: " Christoph Hellwig
` (5 subsequent siblings)
15 siblings, 0 replies; 18+ messages in thread
From: Christoph Hellwig @ 2024-02-28 22:56 UTC (permalink / raw)
To: Jens Axboe, Mike Snitzer, Mikulas Patocka, Song Liu, Yu Kuai
Cc: dm-devel, linux-block, linux-raid
Build the queue limits outside the queue and apply them using
queue_limits_set. To make the code more obvious also split the queue
limits handling into separate helpers.
Signed-off-by: Christoph Hellwig <hch@lst.de>
---
drivers/md/raid5.c | 130 ++++++++++++++++++++++-----------------------
1 file changed, 65 insertions(+), 65 deletions(-)
diff --git a/drivers/md/raid5.c b/drivers/md/raid5.c
index 287fc1540a8d32..8d2e3f9419a7f3 100644
--- a/drivers/md/raid5.c
+++ b/drivers/md/raid5.c
@@ -7673,10 +7673,65 @@ static int only_parity(int raid_disk, int algo, int raid_disks, int max_degraded
return 0;
}
-static void raid5_set_io_opt(struct r5conf *conf)
+static int raid5_set_limits(struct mddev *mddev)
{
- blk_queue_io_opt(conf->mddev->queue, (conf->chunk_sectors << 9) *
- (conf->raid_disks - conf->max_degraded));
+ struct r5conf *conf = mddev->private;
+ struct queue_limits lim;
+ int data_disks, stripe;
+ struct md_rdev *rdev;
+
+ /*
+ * The read-ahead size must cover two whole stripes, which is
+ * 2 * (datadisks) * chunksize where 'n' is the number of raid devices.
+ */
+ data_disks = conf->previous_raid_disks - conf->max_degraded;
+
+ /*
+ * We can only discard a whole stripe. It doesn't make sense to
+ * discard data disk but write parity disk
+ */
+ stripe = roundup_pow_of_two(data_disks * (mddev->chunk_sectors << 9));
+
+ blk_set_stacking_limits(&lim);
+ lim.io_min = mddev->chunk_sectors << 9;
+ lim.io_opt = lim.io_min * (conf->raid_disks - conf->max_degraded);
+ lim.raid_partial_stripes_expensive = 1;
+ lim.discard_granularity = stripe;
+ lim.max_write_zeroes_sectors = 0;
+ mddev_stack_rdev_limits(mddev, &lim);
+ rdev_for_each(rdev, mddev)
+ queue_limits_stack_bdev(&lim, rdev->bdev, rdev->new_data_offset,
+ mddev->gendisk->disk_name);
+
+ /*
+ * Zeroing is required for discard, otherwise data could be lost.
+ *
+ * Consider a scenario: discard a stripe (the stripe could be
+ * inconsistent if discard_zeroes_data is 0); write one disk of the
+ * stripe (the stripe could be inconsistent again depending on which
+ * disks are used to calculate parity); the disk is broken; The stripe
+ * data of this disk is lost.
+ *
+ * We only allow DISCARD if the sysadmin has confirmed that only safe
+ * devices are in use by setting a module parameter. A better idea
+ * might be to turn DISCARD into WRITE_ZEROES requests, as that is
+ * required to be safe.
+ */
+ if (!devices_handle_discard_safely ||
+ lim.max_discard_sectors < (stripe >> 9) ||
+ lim.discard_granularity < stripe)
+ lim.max_hw_discard_sectors = 0;
+
+ /*
+ * Requests require having a bitmap for each stripe.
+ * Limit the max sectors based on this.
+ */
+ lim.max_hw_sectors = RAID5_MAX_REQ_STRIPES << RAID5_STRIPE_SHIFT(conf);
+
+ /* No restrictions on the number of segments in the request */
+ lim.max_segments = USHRT_MAX;
+
+ return queue_limits_set(mddev->queue, &lim);
}
static int raid5_run(struct mddev *mddev)
@@ -7689,6 +7744,7 @@ static int raid5_run(struct mddev *mddev)
int i;
long long min_offset_diff = 0;
int first = 1;
+ int ret = -EIO;
if (mddev->recovery_cp != MaxSector)
pr_notice("md/raid:%s: not clean -- starting background reconstruction\n",
@@ -7942,65 +7998,9 @@ static int raid5_run(struct mddev *mddev)
md_set_array_sectors(mddev, raid5_size(mddev, 0, 0));
if (!mddev_is_dm(mddev)) {
- int chunk_size;
- /* read-ahead size must cover two whole stripes, which
- * is 2 * (datadisks) * chunksize where 'n' is the
- * number of raid devices
- */
- int data_disks = conf->previous_raid_disks - conf->max_degraded;
- int stripe = data_disks *
- ((mddev->chunk_sectors << 9) / PAGE_SIZE);
-
- chunk_size = mddev->chunk_sectors << 9;
- blk_queue_io_min(mddev->queue, chunk_size);
- raid5_set_io_opt(conf);
- mddev->queue->limits.raid_partial_stripes_expensive = 1;
- /*
- * We can only discard a whole stripe. It doesn't make sense to
- * discard data disk but write parity disk
- */
- stripe = stripe * PAGE_SIZE;
- stripe = roundup_pow_of_two(stripe);
- mddev->queue->limits.discard_granularity = stripe;
-
- blk_queue_max_write_zeroes_sectors(mddev->queue, 0);
-
- rdev_for_each(rdev, mddev) {
- disk_stack_limits(mddev->gendisk, rdev->bdev,
- rdev->data_offset << 9);
- disk_stack_limits(mddev->gendisk, rdev->bdev,
- rdev->new_data_offset << 9);
- }
-
- /*
- * zeroing is required, otherwise data
- * could be lost. Consider a scenario: discard a stripe
- * (the stripe could be inconsistent if
- * discard_zeroes_data is 0); write one disk of the
- * stripe (the stripe could be inconsistent again
- * depending on which disks are used to calculate
- * parity); the disk is broken; The stripe data of this
- * disk is lost.
- *
- * We only allow DISCARD if the sysadmin has confirmed that
- * only safe devices are in use by setting a module parameter.
- * A better idea might be to turn DISCARD into WRITE_ZEROES
- * requests, as that is required to be safe.
- */
- if (!devices_handle_discard_safely ||
- mddev->queue->limits.max_discard_sectors < (stripe >> 9) ||
- mddev->queue->limits.discard_granularity < stripe)
- blk_queue_max_discard_sectors(mddev->queue, 0);
-
- /*
- * Requests require having a bitmap for each stripe.
- * Limit the max sectors based on this.
- */
- blk_queue_max_hw_sectors(mddev->queue,
- RAID5_MAX_REQ_STRIPES << RAID5_STRIPE_SHIFT(conf));
-
- /* No restrictions on the number of segments in the request */
- blk_queue_max_segments(mddev->queue, USHRT_MAX);
+ ret = raid5_set_limits(mddev);
+ if (ret)
+ goto abort;
}
if (log_init(conf, journal_dev, raid5_has_ppl(conf)))
@@ -8013,7 +8013,7 @@ static int raid5_run(struct mddev *mddev)
free_conf(conf);
mddev->private = NULL;
pr_warn("md/raid:%s: failed to run raid set.\n", mdname(mddev));
- return -EIO;
+ return ret;
}
static void raid5_free(struct mddev *mddev, void *priv)
@@ -8545,8 +8545,8 @@ static void end_reshape(struct r5conf *conf)
spin_unlock_irq(&conf->device_lock);
wake_up(&conf->wait_for_overlap);
- if (!mddev_is_dm(conf->mddev))
- raid5_set_io_opt(conf);
+ mddev_update_io_opt(conf->mddev,
+ conf->raid_disks - conf->max_degraded);
}
}
--
2.39.2
^ permalink raw reply related [flat|nested] 18+ messages in thread* [PATCH 11/14] md/raid10: use the atomic queue limit update APIs
2024-02-28 22:56 atomic queue limit updates for stackable devices v3 Christoph Hellwig
` (9 preceding siblings ...)
2024-02-28 22:56 ` [PATCH 10/14] md/raid5: " Christoph Hellwig
@ 2024-02-28 22:56 ` Christoph Hellwig
2024-02-28 22:56 ` [PATCH 12/14] md: don't initialize queue limits Christoph Hellwig
` (4 subsequent siblings)
15 siblings, 0 replies; 18+ messages in thread
From: Christoph Hellwig @ 2024-02-28 22:56 UTC (permalink / raw)
To: Jens Axboe, Mike Snitzer, Mikulas Patocka, Song Liu, Yu Kuai
Cc: dm-devel, linux-block, linux-raid
Build the queue limits outside the queue and apply them using
queue_limits_set. To make the code more obvious also split the queue
limits handling into separate helpers.
Signed-off-by: Christoph Hellwig <hch@lst.de>
---
drivers/md/raid10.c | 60 +++++++++++++++++++++++++--------------------
1 file changed, 33 insertions(+), 27 deletions(-)
diff --git a/drivers/md/raid10.c b/drivers/md/raid10.c
index 95fa9e728f95a9..692a3bd94100e2 100644
--- a/drivers/md/raid10.c
+++ b/drivers/md/raid10.c
@@ -2124,10 +2124,9 @@ static int raid10_add_disk(struct mddev *mddev, struct md_rdev *rdev)
continue;
}
- if (!mddev_is_dm(mddev))
- disk_stack_limits(mddev->gendisk, rdev->bdev,
- rdev->data_offset << 9);
-
+ err = mddev_stack_new_rdev(mddev, rdev);
+ if (err)
+ return err;
p->head_position = 0;
p->recovery_disabled = mddev->recovery_disabled - 1;
rdev->raid_disk = mirror;
@@ -2143,10 +2142,9 @@ static int raid10_add_disk(struct mddev *mddev, struct md_rdev *rdev)
clear_bit(In_sync, &rdev->flags);
set_bit(Replacement, &rdev->flags);
rdev->raid_disk = repl_slot;
- err = 0;
- if (!mddev_is_dm(mddev))
- disk_stack_limits(mddev->gendisk, rdev->bdev,
- rdev->data_offset << 9);
+ err = mddev_stack_new_rdev(mddev, rdev);
+ if (err)
+ return err;
conf->fullsync = 1;
WRITE_ONCE(p->replacement, rdev);
}
@@ -3995,14 +3993,26 @@ static struct r10conf *setup_conf(struct mddev *mddev)
return ERR_PTR(err);
}
-static void raid10_set_io_opt(struct r10conf *conf)
+static unsigned int raid10_nr_stripes(struct r10conf *conf)
{
- int raid_disks = conf->geo.raid_disks;
+ unsigned int raid_disks = conf->geo.raid_disks;
+
+ if (conf->geo.raid_disks % conf->geo.near_copies)
+ return raid_disks;
+ return raid_disks / conf->geo.near_copies;
+}
- if (!(conf->geo.raid_disks % conf->geo.near_copies))
- raid_disks /= conf->geo.near_copies;
- blk_queue_io_opt(conf->mddev->queue, (conf->mddev->chunk_sectors << 9) *
- raid_disks);
+static int raid10_set_queue_limits(struct mddev *mddev)
+{
+ struct r10conf *conf = mddev->private;
+ struct queue_limits lim;
+
+ blk_set_stacking_limits(&lim);
+ lim.max_write_zeroes_sectors = 0;
+ lim.io_min = mddev->chunk_sectors << 9;
+ lim.io_opt = lim.io_min * raid10_nr_stripes(conf);
+ mddev_stack_rdev_limits(mddev, &lim);
+ return queue_limits_set(mddev->queue, &lim);
}
static int raid10_run(struct mddev *mddev)
@@ -4014,6 +4024,7 @@ static int raid10_run(struct mddev *mddev)
sector_t size;
sector_t min_offset_diff = 0;
int first = 1;
+ int ret = -EIO;
if (mddev->private == NULL) {
conf = setup_conf(mddev);
@@ -4040,12 +4051,6 @@ static int raid10_run(struct mddev *mddev)
}
}
- if (!mddev_is_dm(conf->mddev)) {
- blk_queue_max_write_zeroes_sectors(mddev->queue, 0);
- blk_queue_io_min(mddev->queue, mddev->chunk_sectors << 9);
- raid10_set_io_opt(conf);
- }
-
rdev_for_each(rdev, mddev) {
long long diff;
@@ -4074,14 +4079,16 @@ static int raid10_run(struct mddev *mddev)
if (first || diff < min_offset_diff)
min_offset_diff = diff;
- if (!mddev_is_dm(mddev))
- disk_stack_limits(mddev->gendisk, rdev->bdev,
- rdev->data_offset << 9);
-
disk->head_position = 0;
first = 0;
}
+ if (!mddev_is_dm(conf->mddev)) {
+ ret = raid10_set_queue_limits(mddev);
+ if (ret)
+ goto out_free_conf;
+ }
+
/* 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",
@@ -4182,7 +4189,7 @@ static int raid10_run(struct mddev *mddev)
raid10_free_conf(conf);
mddev->private = NULL;
out:
- return -EIO;
+ return ret;
}
static void raid10_free(struct mddev *mddev, void *priv)
@@ -4959,8 +4966,7 @@ static void end_reshape(struct r10conf *conf)
conf->reshape_safe = MaxSector;
spin_unlock_irq(&conf->device_lock);
- if (!mddev_is_dm(conf->mddev))
- raid10_set_io_opt(conf);
+ mddev_update_io_opt(conf->mddev, raid10_nr_stripes(conf));
conf->fullsync = 0;
}
--
2.39.2
^ permalink raw reply related [flat|nested] 18+ messages in thread* [PATCH 12/14] md: don't initialize queue limits
2024-02-28 22:56 atomic queue limit updates for stackable devices v3 Christoph Hellwig
` (10 preceding siblings ...)
2024-02-28 22:56 ` [PATCH 11/14] md/raid10: " Christoph Hellwig
@ 2024-02-28 22:56 ` Christoph Hellwig
2024-02-28 22:56 ` [PATCH 13/14] md: remove mddev->queue Christoph Hellwig
` (3 subsequent siblings)
15 siblings, 0 replies; 18+ messages in thread
From: Christoph Hellwig @ 2024-02-28 22:56 UTC (permalink / raw)
To: Jens Axboe, Mike Snitzer, Mikulas Patocka, Song Liu, Yu Kuai
Cc: dm-devel, linux-block, linux-raid
Initial queue limits are now set from ->run. Remove the superfluous
initialization in md_alloc and level_store.
Signed-off-by: Christoph Hellwig <hch@lst.de>
---
drivers/md/md.c | 2 --
1 file changed, 2 deletions(-)
diff --git a/drivers/md/md.c b/drivers/md/md.c
index bfc38cb4b31014..eab1b36c1d02ef 100644
--- a/drivers/md/md.c
+++ b/drivers/md/md.c
@@ -4155,7 +4155,6 @@ level_store(struct mddev *mddev, const char *buf, size_t len)
mddev->in_sync = 1;
del_timer_sync(&mddev->safemode_timer);
}
- blk_set_stacking_limits(&mddev->queue->limits);
pers->run(mddev);
set_bit(MD_SB_CHANGE_DEVS, &mddev->sb_flags);
if (!mddev->thread)
@@ -5825,7 +5824,6 @@ struct mddev *md_alloc(dev_t dev, char *name)
disk->private_data = mddev;
mddev->queue = disk->queue;
- blk_set_stacking_limits(&mddev->queue->limits);
blk_queue_write_cache(mddev->queue, true, true);
disk->events |= DISK_EVENT_MEDIA_CHANGE;
mddev->gendisk = disk;
--
2.39.2
^ permalink raw reply related [flat|nested] 18+ messages in thread* [PATCH 13/14] md: remove mddev->queue
2024-02-28 22:56 atomic queue limit updates for stackable devices v3 Christoph Hellwig
` (11 preceding siblings ...)
2024-02-28 22:56 ` [PATCH 12/14] md: don't initialize queue limits Christoph Hellwig
@ 2024-02-28 22:56 ` Christoph Hellwig
2024-02-28 22:56 ` [PATCH 14/14] block: remove disk_stack_limits Christoph Hellwig
` (2 subsequent siblings)
15 siblings, 0 replies; 18+ messages in thread
From: Christoph Hellwig @ 2024-02-28 22:56 UTC (permalink / raw)
To: Jens Axboe, Mike Snitzer, Mikulas Patocka, Song Liu, Yu Kuai
Cc: dm-devel, linux-block, linux-raid
Just use the request_queue from the gendisk pointer in the relatively
few places that sill need it.
Signed-off-by: Christoph Hellwig <hch@lst.de>
---
drivers/md/md.c | 22 ++++++++++++----------
drivers/md/md.h | 5 ++---
drivers/md/raid0.c | 2 +-
drivers/md/raid1.c | 2 +-
drivers/md/raid10.c | 2 +-
drivers/md/raid5-ppl.c | 3 ++-
drivers/md/raid5.c | 13 +++++++------
7 files changed, 26 insertions(+), 23 deletions(-)
diff --git a/drivers/md/md.c b/drivers/md/md.c
index eab1b36c1d02ef..1cb4a33148aac9 100644
--- a/drivers/md/md.c
+++ b/drivers/md/md.c
@@ -5716,10 +5716,10 @@ int mddev_stack_new_rdev(struct mddev *mddev, struct md_rdev *rdev)
if (mddev_is_dm(mddev))
return 0;
- lim = queue_limits_start_update(mddev->queue);
+ lim = queue_limits_start_update(mddev->gendisk->queue);
queue_limits_stack_bdev(&lim, rdev->bdev, rdev->data_offset,
mddev->gendisk->disk_name);
- return queue_limits_commit_update(mddev->queue, &lim);
+ return queue_limits_commit_update(mddev->gendisk->queue, &lim);
}
EXPORT_SYMBOL_GPL(mddev_stack_new_rdev);
@@ -5823,8 +5823,7 @@ struct mddev *md_alloc(dev_t dev, char *name)
disk->fops = &md_fops;
disk->private_data = mddev;
- mddev->queue = disk->queue;
- blk_queue_write_cache(mddev->queue, true, true);
+ blk_queue_write_cache(disk->queue, true, true);
disk->events |= DISK_EVENT_MEDIA_CHANGE;
mddev->gendisk = disk;
error = add_disk(disk);
@@ -6126,6 +6125,7 @@ int md_run(struct mddev *mddev)
}
if (!mddev_is_dm(mddev)) {
+ struct request_queue *q = mddev->gendisk->queue;
bool nonrot = true;
rdev_for_each(rdev, mddev) {
@@ -6137,14 +6137,14 @@ int md_run(struct mddev *mddev)
if (mddev->degraded)
nonrot = false;
if (nonrot)
- blk_queue_flag_set(QUEUE_FLAG_NONROT, mddev->queue);
+ blk_queue_flag_set(QUEUE_FLAG_NONROT, q);
else
- blk_queue_flag_clear(QUEUE_FLAG_NONROT, mddev->queue);
- blk_queue_flag_set(QUEUE_FLAG_IO_STAT, mddev->queue);
+ blk_queue_flag_clear(QUEUE_FLAG_NONROT, q);
+ blk_queue_flag_set(QUEUE_FLAG_IO_STAT, q);
/* Set the NOWAIT flags if all underlying devices support it */
if (nowait)
- blk_queue_flag_set(QUEUE_FLAG_NOWAIT, mddev->queue);
+ blk_queue_flag_set(QUEUE_FLAG_NOWAIT, q);
}
if (pers->sync_request) {
if (mddev->kobj.sd &&
@@ -6381,8 +6381,10 @@ static void mddev_detach(struct mddev *mddev)
mddev->pers->quiesce(mddev, 0);
}
md_unregister_thread(mddev, &mddev->thread);
+
+ /* the unplug fn references 'conf' */
if (!mddev_is_dm(mddev))
- blk_sync_queue(mddev->queue); /* the unplug fn references 'conf'*/
+ blk_sync_queue(mddev->gendisk->queue);
}
static void __md_stop(struct mddev *mddev)
@@ -7110,7 +7112,7 @@ static int hot_add_disk(struct mddev *mddev, dev_t dev)
if (!bdev_nowait(rdev->bdev)) {
pr_info("%s: Disabling nowait because %pg does not support nowait\n",
mdname(mddev), rdev->bdev);
- blk_queue_flag_clear(QUEUE_FLAG_NOWAIT, mddev->queue);
+ blk_queue_flag_clear(QUEUE_FLAG_NOWAIT, mddev->gendisk->queue);
}
/*
* Kick recovery, maybe this spare has to be added to the
diff --git a/drivers/md/md.h b/drivers/md/md.h
index 5db58d076256d3..dc7d3dc1569934 100644
--- a/drivers/md/md.h
+++ b/drivers/md/md.h
@@ -469,7 +469,6 @@ struct mddev {
struct timer_list safemode_timer;
struct percpu_ref writes_pending;
int sync_checkers; /* # of threads checking writes_pending */
- struct request_queue *queue; /* for plugging ... */
struct bitmap *bitmap; /* the bitmap for the device */
struct {
@@ -822,7 +821,7 @@ static inline void mddev_check_write_zeroes(struct mddev *mddev, struct bio *bio
{
if (bio_op(bio) == REQ_OP_WRITE_ZEROES &&
!bio->bi_bdev->bd_disk->queue->limits.max_write_zeroes_sectors)
- mddev->queue->limits.max_write_zeroes_sectors = 0;
+ mddev->gendisk->queue->limits.max_write_zeroes_sectors = 0;
}
static inline int mddev_suspend_and_lock(struct mddev *mddev)
@@ -885,7 +884,7 @@ static inline void mddev_trace_remap(struct mddev *mddev, struct bio *bio,
#define mddev_add_trace_msg(mddev, fmt, args...) \
do { \
if (!mddev_is_dm(mddev)) \
- blk_add_trace_msg((mddev)->queue, fmt, ##args); \
+ blk_add_trace_msg((mddev)->gendisk->queue, fmt, ##args); \
} while (0)
#endif /* _MD_MD_H */
diff --git a/drivers/md/raid0.c b/drivers/md/raid0.c
index f65aa6ecec0482..c5d4aeb68404c9 100644
--- a/drivers/md/raid0.c
+++ b/drivers/md/raid0.c
@@ -389,7 +389,7 @@ static int raid0_set_limits(struct mddev *mddev)
lim.io_min = mddev->chunk_sectors << 9;
lim.io_opt = lim.io_min * mddev->raid_disks;
mddev_stack_rdev_limits(mddev, &lim);
- return queue_limits_set(mddev->queue, &lim);
+ return queue_limits_set(mddev->gendisk->queue, &lim);
}
static int raid0_run(struct mddev *mddev)
diff --git a/drivers/md/raid1.c b/drivers/md/raid1.c
index 75329ab2dbd8de..445e3d3ff9ff7d 100644
--- a/drivers/md/raid1.c
+++ b/drivers/md/raid1.c
@@ -3083,7 +3083,7 @@ static int raid1_set_limits(struct mddev *mddev)
blk_set_stacking_limits(&lim);
lim.max_write_zeroes_sectors = 0;
mddev_stack_rdev_limits(mddev, &lim);
- return queue_limits_set(mddev->queue, &lim);
+ return queue_limits_set(mddev->gendisk->queue, &lim);
}
static void raid1_free(struct mddev *mddev, void *priv);
diff --git a/drivers/md/raid10.c b/drivers/md/raid10.c
index 692a3bd94100e2..fd960a5b29fe49 100644
--- a/drivers/md/raid10.c
+++ b/drivers/md/raid10.c
@@ -4012,7 +4012,7 @@ static int raid10_set_queue_limits(struct mddev *mddev)
lim.io_min = mddev->chunk_sectors << 9;
lim.io_opt = lim.io_min * raid10_nr_stripes(conf);
mddev_stack_rdev_limits(mddev, &lim);
- return queue_limits_set(mddev->queue, &lim);
+ return queue_limits_set(mddev->gendisk->queue, &lim);
}
static int raid10_run(struct mddev *mddev)
diff --git a/drivers/md/raid5-ppl.c b/drivers/md/raid5-ppl.c
index da4ba736c4f0c9..a70cbec12ed017 100644
--- a/drivers/md/raid5-ppl.c
+++ b/drivers/md/raid5-ppl.c
@@ -1393,7 +1393,8 @@ int ppl_init_log(struct r5conf *conf)
ppl_conf->signature = ~crc32c_le(~0, mddev->uuid, sizeof(mddev->uuid));
ppl_conf->block_size = 512;
} else {
- ppl_conf->block_size = queue_logical_block_size(mddev->queue);
+ ppl_conf->block_size =
+ queue_logical_block_size(mddev->gendisk->queue);
}
for (i = 0; i < ppl_conf->count; i++) {
diff --git a/drivers/md/raid5.c b/drivers/md/raid5.c
index 8d2e3f9419a7f3..651fc4d603dc59 100644
--- a/drivers/md/raid5.c
+++ b/drivers/md/raid5.c
@@ -4279,9 +4279,10 @@ static int handle_stripe_dirtying(struct r5conf *conf,
}
}
if (rcw && !mddev_is_dm(conf->mddev))
- blk_add_trace_msg(conf->mddev->queue, "raid5 rcw %llu %d %d %d",
- (unsigned long long)sh->sector,
- rcw, qread, test_bit(STRIPE_DELAYED, &sh->state));
+ blk_add_trace_msg(conf->mddev->gendisk->queue,
+ "raid5 rcw %llu %d %d %d",
+ (unsigned long long)sh->sector, rcw, qread,
+ test_bit(STRIPE_DELAYED, &sh->state));
}
if (rcw > disks && rmw > disks &&
@@ -5693,7 +5694,7 @@ static void raid5_unplug(struct blk_plug_cb *blk_cb, bool from_schedule)
release_inactive_stripe_list(conf, cb->temp_inactive_list,
NR_STRIPE_HASH_LOCKS);
if (!mddev_is_dm(mddev))
- trace_block_unplug(mddev->queue, cnt, !from_schedule);
+ trace_block_unplug(mddev->gendisk->queue, cnt, !from_schedule);
kfree(cb);
}
@@ -7073,7 +7074,7 @@ raid5_store_skip_copy(struct mddev *mddev, const char *page, size_t len)
if (!conf)
err = -ENODEV;
else if (new != conf->skip_copy) {
- struct request_queue *q = mddev->queue;
+ struct request_queue *q = mddev->gendisk->queue;
conf->skip_copy = new;
if (new)
@@ -7731,7 +7732,7 @@ static int raid5_set_limits(struct mddev *mddev)
/* No restrictions on the number of segments in the request */
lim.max_segments = USHRT_MAX;
- return queue_limits_set(mddev->queue, &lim);
+ return queue_limits_set(mddev->gendisk->queue, &lim);
}
static int raid5_run(struct mddev *mddev)
--
2.39.2
^ permalink raw reply related [flat|nested] 18+ messages in thread* [PATCH 14/14] block: remove disk_stack_limits
2024-02-28 22:56 atomic queue limit updates for stackable devices v3 Christoph Hellwig
` (12 preceding siblings ...)
2024-02-28 22:56 ` [PATCH 13/14] md: remove mddev->queue Christoph Hellwig
@ 2024-02-28 22:56 ` Christoph Hellwig
2024-02-29 19:40 ` atomic queue limit updates for stackable devices v3 Christoph Hellwig
2024-03-01 15:55 ` (subset) " Jens Axboe
15 siblings, 0 replies; 18+ messages in thread
From: Christoph Hellwig @ 2024-02-28 22:56 UTC (permalink / raw)
To: Jens Axboe, Mike Snitzer, Mikulas Patocka, Song Liu, Yu Kuai
Cc: dm-devel, linux-block, linux-raid
disk_stack_limits is unused now, remove it.
Signed-off-by: Christoph Hellwig <hch@lst.de>
---
block/blk-settings.c | 24 ------------------------
include/linux/blkdev.h | 2 --
2 files changed, 26 deletions(-)
diff --git a/block/blk-settings.c b/block/blk-settings.c
index 13865a9f89726c..3c7d8d638ab59d 100644
--- a/block/blk-settings.c
+++ b/block/blk-settings.c
@@ -916,30 +916,6 @@ void queue_limits_stack_bdev(struct queue_limits *t, struct block_device *bdev,
}
EXPORT_SYMBOL_GPL(queue_limits_stack_bdev);
-/**
- * disk_stack_limits - adjust queue limits for stacked drivers
- * @disk: MD/DM gendisk (top)
- * @bdev: the underlying block device (bottom)
- * @offset: offset to beginning of data within component device
- *
- * Description:
- * Merges the limits for a top level gendisk and a bottom level
- * block_device.
- */
-void disk_stack_limits(struct gendisk *disk, struct block_device *bdev,
- sector_t offset)
-{
- struct request_queue *t = disk->queue;
-
- if (blk_stack_limits(&t->limits, &bdev_get_queue(bdev)->limits,
- get_start_sect(bdev) + (offset >> 9)) < 0)
- pr_notice("%s: Warning: Device %pg is misaligned\n",
- disk->disk_name, bdev);
-
- disk_update_readahead(disk);
-}
-EXPORT_SYMBOL(disk_stack_limits);
-
/**
* blk_queue_update_dma_pad - update pad mask
* @q: the request queue for the device
diff --git a/include/linux/blkdev.h b/include/linux/blkdev.h
index 285e82723d641f..75c909865a8b7b 100644
--- a/include/linux/blkdev.h
+++ b/include/linux/blkdev.h
@@ -926,8 +926,6 @@ extern int blk_stack_limits(struct queue_limits *t, struct queue_limits *b,
sector_t offset);
void queue_limits_stack_bdev(struct queue_limits *t, struct block_device *bdev,
sector_t offset, const char *pfx);
-extern void disk_stack_limits(struct gendisk *disk, struct block_device *bdev,
- sector_t offset);
extern void blk_queue_update_dma_pad(struct request_queue *, unsigned int);
extern void blk_queue_segment_boundary(struct request_queue *, unsigned long);
extern void blk_queue_virt_boundary(struct request_queue *, unsigned long);
--
2.39.2
^ permalink raw reply related [flat|nested] 18+ messages in thread* Re: atomic queue limit updates for stackable devices v3
2024-02-28 22:56 atomic queue limit updates for stackable devices v3 Christoph Hellwig
` (13 preceding siblings ...)
2024-02-28 22:56 ` [PATCH 14/14] block: remove disk_stack_limits Christoph Hellwig
@ 2024-02-29 19:40 ` Christoph Hellwig
2024-03-01 15:55 ` (subset) " Jens Axboe
15 siblings, 0 replies; 18+ messages in thread
From: Christoph Hellwig @ 2024-02-29 19:40 UTC (permalink / raw)
To: Jens Axboe, Mike Snitzer, Mikulas Patocka, Song Liu, Yu Kuai
Cc: dm-devel, linux-block, linux-raid
On Wed, Feb 28, 2024 at 02:56:39PM -0800, Christoph Hellwig wrote:
> I've run the mdadm testsuite, and it has the same (rather large) number
> of failures as the baseline, and the lvm2 test suite goes as far as
> the baseline before handing in __md_stop_writes.
When I pull in all the pending fixes, the lvm2 test suite works for
the baseline and this series, and shows no regressions.
^ permalink raw reply [flat|nested] 18+ messages in thread* Re: (subset) atomic queue limit updates for stackable devices v3
2024-02-28 22:56 atomic queue limit updates for stackable devices v3 Christoph Hellwig
` (14 preceding siblings ...)
2024-02-29 19:40 ` atomic queue limit updates for stackable devices v3 Christoph Hellwig
@ 2024-03-01 15:55 ` Jens Axboe
2024-03-02 4:14 ` Song Liu
15 siblings, 1 reply; 18+ messages in thread
From: Jens Axboe @ 2024-03-01 15:55 UTC (permalink / raw)
To: Mike Snitzer, Mikulas Patocka, Song Liu, Yu Kuai,
Christoph Hellwig
Cc: dm-devel, linux-block, linux-raid
On Wed, 28 Feb 2024 14:56:39 -0800, Christoph Hellwig wrote:
> this series adds new helpers for the atomic queue limit update
> functionality and then switches dm and md over to it. The dm switch is
> pretty trivial as it was basically implementing the model by hand
> already, md is a bit more work.
>
> I've run the mdadm testsuite, and it has the same (rather large) number
> of failures as the baseline, and the lvm2 test suite goes as far as
> the baseline before handing in __md_stop_writes.
>
> [...]
Applied, thanks!
[01/14] block: add a queue_limits_set helper
commit: 631d4efb8009df64deae8c1382b8cf43879a4e22
[02/14] block: add a queue_limits_stack_bdev helper
commit: c1373f1cf452e4c7553a9d3bc05d87ec15c4f85f
[03/14] dm: use queue_limits_set
commit: 8e0ef412869430d114158fc3b9b1fb111e247bd3
Best regards,
--
Jens Axboe
^ permalink raw reply [flat|nested] 18+ messages in thread* Re: (subset) atomic queue limit updates for stackable devices v3
2024-03-01 15:55 ` (subset) " Jens Axboe
@ 2024-03-02 4:14 ` Song Liu
0 siblings, 0 replies; 18+ messages in thread
From: Song Liu @ 2024-03-02 4:14 UTC (permalink / raw)
To: Jens Axboe
Cc: Mike Snitzer, Mikulas Patocka, Yu Kuai, Christoph Hellwig,
dm-devel, linux-block, linux-raid
On Fri, Mar 1, 2024 at 7:55 AM Jens Axboe <axboe@kernel.dk> wrote:
>
>
> On Wed, 28 Feb 2024 14:56:39 -0800, Christoph Hellwig wrote:
> > this series adds new helpers for the atomic queue limit update
> > functionality and then switches dm and md over to it. The dm switch is
> > pretty trivial as it was basically implementing the model by hand
> > already, md is a bit more work.
> >
> > I've run the mdadm testsuite, and it has the same (rather large) number
> > of failures as the baseline, and the lvm2 test suite goes as far as
> > the baseline before handing in __md_stop_writes.
> >
> > [...]
>
> Applied, thanks!
>
> [01/14] block: add a queue_limits_set helper
> commit: 631d4efb8009df64deae8c1382b8cf43879a4e22
> [02/14] block: add a queue_limits_stack_bdev helper
> commit: c1373f1cf452e4c7553a9d3bc05d87ec15c4f85f
> [03/14] dm: use queue_limits_set
> commit: 8e0ef412869430d114158fc3b9b1fb111e247bd3
For the set:
Reviewed-and-tested-by: Song Liu <song@kernel.org>
^ permalink raw reply [flat|nested] 18+ messages in thread