History

writeback: remove bdi->congested_fn

Except for pktdvd, the only places setting congested bits are file systems that allocate their own backing_dev_info structures. And pktdvd is a deprecated driver that isn't useful in stack setup either. So remove the dead congested_fn stacking infrastructure.

Christoph Hellwig committed 6 years ago

Commit 21cf8661 parent 8c911f323 files · +1 −468Browse files

Unified · Split

23 files
  1. drivers/block/drbd/drbd_main.c +0 −59
  2. drivers/md/bcache/request.c +0 −47
  3. drivers/md/bcache/super.c +0 −1
  4. drivers/md/dm-cache-target.c +0 −19
  5. drivers/md/dm-clone-target.c +0 −15
  6. drivers/md/dm-era-target.c +0 −15
  7. drivers/md/dm-raid.c +0 −12
  8. drivers/md/dm-table.c +1 −36
  9. drivers/md/dm-thin.c +0 −16
  10. drivers/md/dm.c +0 −33
  11. drivers/md/dm.h +0 −1
  12. drivers/md/md-linear.c +0 −24
  13. drivers/md/md-multipath.c +0 −23
  14. drivers/md/md.c +0 −23
  15. drivers/md/md.h +0 −4
  16. drivers/md/raid0.c +0 −16
  17. drivers/md/raid1.c +0 −31
  18. drivers/md/raid10.c +0 −26
  19. drivers/md/raid5.c +0 −25
  20. fs/btrfs/disk-io.c +0 −23
  21. include/linux/backing-dev-defs.h +0 −4
  22. include/linux/backing-dev.h +0 −4
  23. include/linux/device-mapper.h +0 −11
drivers/block/drbd/drbd_main.c+0−59
@@ -2415,62 +2415,6 @@ static void drbd_cleanup(void) · 2414 unmodified lines
24152415 pr_info("module cleanup done.\n");
24162416 }
24172417
2418−/**
2419− * drbd_congested() - Callback for the flusher thread
2420− * @congested_data: User data
2421− * @bdi_bits: Bits the BDI flusher thread is currently interested in
2422− *
2423− * Returns 1<<WB_async_congested and/or 1<<WB_sync_congested if we are congested.
2424− */
2425−static int drbd_congested(void *congested_data, int bdi_bits)
2426−{
2427− struct drbd_device *device = congested_data;
2428− struct request_queue *q;
2429− char reason = '-';
2430− int r = 0;
2431−
2432− if (!may_inc_ap_bio(device)) {
2433− /* DRBD has frozen IO */
2434− r = bdi_bits;
2435− reason = 'd';
2436− goto out;
2437− }
2438−
2439− if (test_bit(CALLBACK_PENDING, &first_peer_device(device)->connection->flags)) {
2440− r |= (1 << WB_async_congested);
2441− /* Without good local data, we would need to read from remote,
2442− * and that would need the worker thread as well, which is
2443− * currently blocked waiting for that usermode helper to
2444− * finish.
2445− */
2446− if (!get_ldev_if_state(device, D_UP_TO_DATE))
2447− r |= (1 << WB_sync_congested);
2448− else
2449− put_ldev(device);
2450− r &= bdi_bits;
2451− reason = 'c';
2452− goto out;
2453− }
2454−
2455− if (get_ldev(device)) {
2456− q = bdev_get_queue(device->ldev->backing_bdev);
2457− r = bdi_congested(q->backing_dev_info, bdi_bits);
2458− put_ldev(device);
2459− if (r)
2460− reason = 'b';
2461− }
2462−
2463− if (bdi_bits & (1 << WB_async_congested) &&
2464− test_bit(NET_CONGESTED, &first_peer_device(device)->connection->flags)) {
2465− r |= (1 << WB_async_congested);
2466− reason = reason == 'b' ? 'a' : 'n';
2467− }
2468−
2469−out:
2470− device->congestion_reason = reason;
2471− return r;
2472−}
2473−
24742418 static void drbd_init_workqueue(struct drbd_work_queue* wq)
24752419 {
24762420 spin_lock_init(&wq->q_lock);
@@ -2825,9 +2769,6 @@ enum drbd_ret_code drbd_create_device(struct drbd_config_context *adm_ctx, unsig · 348 unmodified lines
28252769 /* we have no partitions. we contain only ourselves. */
28262770 device->this_bdev->bd_contains = device->this_bdev;
28272771
2828− q->backing_dev_info->congested_fn = drbd_congested;
2829− q->backing_dev_info->congested_data = device;
2830−
28312772 blk_queue_write_cache(q, true, true);
28322773 /* Setting the max_hw_sectors to an odd value of 8kibyte here
28332774 This triggers a max_bio_size message upon first attach or connect */
drivers/md/bcache/request.c+0−47
@@ -1228,36 +1228,8 @@ static int cached_dev_ioctl(struct bcache_device *d, fmode_t mode, · 1227 unmodified lines
12281228 return __blkdev_driver_ioctl(dc->bdev, mode, cmd, arg);
12291229 }
12301230
1231−static int cached_dev_congested(void *data, int bits)
1232−{
1233− struct bcache_device *d = data;
1234− struct cached_dev *dc = container_of(d, struct cached_dev, disk);
1235− struct request_queue *q = bdev_get_queue(dc->bdev);
1236− int ret = 0;
1237−
1238− if (bdi_congested(q->backing_dev_info, bits))
1239− return 1;
1240−
1241− if (cached_dev_get(dc)) {
1242− unsigned int i;
1243− struct cache *ca;
1244−
1245− for_each_cache(ca, d->c, i) {
1246− q = bdev_get_queue(ca->bdev);
1247− ret |= bdi_congested(q->backing_dev_info, bits);
1248− }
1249−
1250− cached_dev_put(dc);
1251− }
1252−
1253− return ret;
1254−}
1255−
12561231 void bch_cached_dev_request_init(struct cached_dev *dc)
12571232 {
1258− struct gendisk *g = dc->disk.disk;
1259−
1260− g->queue->backing_dev_info->congested_fn = cached_dev_congested;
12611233 dc->disk.cache_miss = cached_dev_cache_miss;
12621234 dc->disk.ioctl = cached_dev_ioctl;
12631235 }
@@ -1341,27 +1313,8 @@ static int flash_dev_ioctl(struct bcache_device *d, fmode_t mode, · 77 unmodified lines
13411313 return -ENOTTY;
13421314 }
13431315
1344−static int flash_dev_congested(void *data, int bits)
1345−{
1346− struct bcache_device *d = data;
1347− struct request_queue *q;
1348− struct cache *ca;
1349− unsigned int i;
1350− int ret = 0;
1351−
1352− for_each_cache(ca, d->c, i) {
1353− q = bdev_get_queue(ca->bdev);
1354− ret |= bdi_congested(q->backing_dev_info, bits);
1355− }
1356−
1357− return ret;
1358−}
1359−
13601316 void bch_flash_dev_request_init(struct bcache_device *d)
13611317 {
1362− struct gendisk *g = d->disk;
1363−
1364− g->queue->backing_dev_info->congested_fn = flash_dev_congested;
13651318 d->cache_miss = flash_dev_cache_miss;
13661319 d->ioctl = flash_dev_ioctl;
13671320 }
drivers/md/bcache/super.c+0−1
@@ -885,7 +885,6 @@ static int bcache_device_init(struct bcache_device *d, unsigned int block_size, · 884 unmodified lines
885885 return -ENOMEM;
886886
887887 d->disk->queue = q;
888− q->backing_dev_info->congested_data = d;
889888 q->limits.max_hw_sectors = UINT_MAX;
890889 q->limits.max_sectors = UINT_MAX;
891890 q->limits.max_segment_size = UINT_MAX;
drivers/md/dm-cache-target.c+0−19
@@ -421,8 +421,6 @@ struct cache { · 420 unmodified lines
421421
422422 struct rw_semaphore quiesce_lock;
423423
424− struct dm_target_callbacks callbacks;
425−
426424 /*
427425 * origin_blocks entries, discarded if set.
428426 */
@@ -2423,20 +2421,6 @@ static void set_cache_size(struct cache *cache, dm_cblock_t size) · 1994 unmodified lines
24232421 cache->cache_size = size;
24242422 }
24252423
2426−static int is_congested(struct dm_dev *dev, int bdi_bits)
2427−{
2428− struct request_queue *q = bdev_get_queue(dev->bdev);
2429− return bdi_congested(q->backing_dev_info, bdi_bits);
2430−}
2431−
2432−static int cache_is_congested(struct dm_target_callbacks *cb, int bdi_bits)
2433−{
2434− struct cache *cache = container_of(cb, struct cache, callbacks);
2435−
2436− return is_congested(cache->origin_dev, bdi_bits) ||
2437− is_congested(cache->cache_dev, bdi_bits);
2438−}
2439−
24402424 #define DEFAULT_MIGRATION_THRESHOLD 2048
24412425
24422426 static int cache_create(struct cache_args *ca, struct cache **result)
@@ -2471,9 +2455,6 @@ static int cache_create(struct cache_args *ca, struct cache **result) · 28 unmodified lines
24712455 goto bad;
24722456 }
24732457
2474− cache->callbacks.congested_fn = cache_is_congested;
2475− dm_table_add_target_callbacks(ti->table, &cache->callbacks);
2476−
24772458 cache->metadata_dev = ca->metadata_dev;
24782459 cache->origin_dev = ca->origin_dev;
24792460 cache->cache_dev = ca->cache_dev;
drivers/md/dm-clone-target.c+0−15
@@ -68,7 +68,6 @@ struct hash_table_bucket; · 67 unmodified lines
6868
6969 struct clone {
7070 struct dm_target *ti;
71− struct dm_target_callbacks callbacks;
7271
7372 struct dm_dev *metadata_dev;
7473 struct dm_dev *dest_dev;
@@ -1518,18 +1517,6 @@ error: · 1443 unmodified lines
15181517 DMEMIT("Error");
15191518 }
15201519
1521−static int clone_is_congested(struct dm_target_callbacks *cb, int bdi_bits)
1522−{
1523− struct request_queue *dest_q, *source_q;
1524− struct clone *clone = container_of(cb, struct clone, callbacks);
1525−
1526− source_q = bdev_get_queue(clone->source_dev->bdev);
1527− dest_q = bdev_get_queue(clone->dest_dev->bdev);
1528−
1529− return (bdi_congested(dest_q->backing_dev_info, bdi_bits) |
1530− bdi_congested(source_q->backing_dev_info, bdi_bits));
1531−}
1532−
15331520 static sector_t get_dev_size(struct dm_dev *dev)
15341521 {
15351522 return i_size_read(dev->bdev->bd_inode) >> SECTOR_SHIFT;
@@ -1930,8 +1917,6 @@ static int clone_ctr(struct dm_target *ti, unsigned int argc, char **argv) · 394 unmodified lines
19301917 goto out_with_mempool;
19311918
19321919 mutex_init(&clone->commit_lock);
1933− clone->callbacks.congested_fn = clone_is_congested;
1934− dm_table_add_target_callbacks(ti->table, &clone->callbacks);
19351920
19361921 /* Enable flushes */
19371922 ti->num_flush_bios = 1;
drivers/md/dm-era-target.c+0−15
@@ -1137,7 +1137,6 @@ static int metadata_get_stats(struct era_metadata *md, void *ptr) · 1136 unmodified lines
11371137
11381138 struct era {
11391139 struct dm_target *ti;
1140− struct dm_target_callbacks callbacks;
11411140
11421141 struct dm_dev *metadata_dev;
11431142 struct dm_dev *origin_dev;
@@ -1375,18 +1374,6 @@ static void stop_worker(struct era *era) · 231 unmodified lines
13751374 /*----------------------------------------------------------------
13761375 * Target methods
13771376 *--------------------------------------------------------------*/
1378−static int dev_is_congested(struct dm_dev *dev, int bdi_bits)
1379−{
1380− struct request_queue *q = bdev_get_queue(dev->bdev);
1381− return bdi_congested(q->backing_dev_info, bdi_bits);
1382−}
1383−
1384−static int era_is_congested(struct dm_target_callbacks *cb, int bdi_bits)
1385−{
1386− struct era *era = container_of(cb, struct era, callbacks);
1387− return dev_is_congested(era->origin_dev, bdi_bits);
1388−}
1389−
13901377 static void era_destroy(struct era *era)
13911378 {
13921379 if (era->md)
@@ -1514,8 +1501,6 @@ static int era_ctr(struct dm_target *ti, unsigned argc, char **argv) · 121 unmodified lines
15141501 ti->flush_supported = true;
15151502
15161503 ti->num_discard_bios = 1;
1517− era->callbacks.congested_fn = era_is_congested;
1518− dm_table_add_target_callbacks(ti->table, &era->callbacks);
15191504
15201505 return 0;
15211506 }
drivers/md/dm-raid.c+0−12
@@ -242,7 +242,6 @@ struct raid_set { · 241 unmodified lines
242242
243243 struct mddev md;
244244 struct raid_type *raid_type;
245− struct dm_target_callbacks callbacks;
246245
247246 sector_t array_sectors;
248247 sector_t dev_sectors;
@@ -1705,13 +1704,6 @@ static void do_table_event(struct work_struct *ws) · 1456 unmodified lines
17051704 dm_table_event(rs->ti->table);
17061705 }
17071706
1708−static int raid_is_congested(struct dm_target_callbacks *cb, int bits)
1709−{
1710− struct raid_set *rs = container_of(cb, struct raid_set, callbacks);
1711−
1712− return mddev_congested(&rs->md, bits);
1713−}
1714−
17151707 /*
17161708 * Make sure a valid takover (level switch) is being requested on @rs
17171709 *
@@ -3248,9 +3240,6 @@ size_check: · 1530 unmodified lines
32483240 goto bad_md_start;
32493241 }
32503242
3251− rs->callbacks.congested_fn = raid_is_congested;
3252− dm_table_add_target_callbacks(ti->table, &rs->callbacks);
3253−
32543243 /* If raid4/5/6 journal mode explicitly requested (only possible with journal dev) -> set it */
32553244 if (test_bit(__CTR_FLAG_JOURNAL_MODE, &rs->ctr_flags)) {
32563245 r = r5c_journal_mode_set(&rs->md, rs->journal_dev.mode);
@@ -3310,7 +3299,6 @@ static void raid_dtr(struct dm_target *ti) · 53 unmodified lines
33103299 {
33113300 struct raid_set *rs = ti->private;
33123301
3313− list_del_init(&rs->callbacks.list);
33143302 md_stop(&rs->md);
33153303 raid_set_free(rs);
33163304 }
drivers/md/dm-table.c+1−36
@@ -64,8 +64,6 @@ struct dm_table { · 63 unmodified lines
6464 void *event_context;
6565
6666 struct dm_md_mempools *mempools;
67−
68− struct list_head target_callbacks;
6967 };
7068
7169 /*
@@ -190,7 +188,6 @@ int dm_table_create(struct dm_table **result, fmode_t mode, · 118 unmodified lines
190188 return -ENOMEM;
191189
192190 INIT_LIST_HEAD(&t->devices);
193− INIT_LIST_HEAD(&t->target_callbacks);
194191
195192 if (!num_targets)
196193 num_targets = KEYS_PER_NODE;
@@ -361,7 +358,7 @@ static int device_area_is_invalid(struct dm_target *ti, struct dm_dev *dev, · 164 unmodified lines
361358 * This upgrades the mode on an already open dm_dev, being
362359 * careful to leave things as they were if we fail to reopen the
363360 * device and not to touch the existing bdev field in case
364− * it is accessed concurrently inside dm_table_any_congested().
361+ * it is accessed concurrently.
365362 */
366363 static int upgrade_mode(struct dm_dev_internal *dd, fmode_t new_mode,
367364 struct mapped_device *md)
@@ -2052,38 +2049,6 @@ int dm_table_resume_targets(struct dm_table *t) · 1684 unmodified lines
20522049 return 0;
20532050 }
20542051
2055−void dm_table_add_target_callbacks(struct dm_table *t, struct dm_target_callbacks *cb)
2056−{
2057− list_add(&cb->list, &t->target_callbacks);
2058−}
2059−EXPORT_SYMBOL_GPL(dm_table_add_target_callbacks);
2060−
2061−int dm_table_any_congested(struct dm_table *t, int bdi_bits)
2062−{
2063− struct dm_dev_internal *dd;
2064− struct list_head *devices = dm_table_get_devices(t);
2065− struct dm_target_callbacks *cb;
2066− int r = 0;
2067−
2068− list_for_each_entry(dd, devices, list) {
2069− struct request_queue *q = bdev_get_queue(dd->dm_dev->bdev);
2070− char b[BDEVNAME_SIZE];
2071−
2072− if (likely(q))
2073− r |= bdi_congested(q->backing_dev_info, bdi_bits);
2074− else
2075− DMWARN_LIMIT("%s: any_congested: nonexistent device %s",
2076− dm_device_name(t->md),
2077− bdevname(dd->dm_dev->bdev, b));
2078− }
2079−
2080− list_for_each_entry(cb, &t->target_callbacks, list)
2081− if (cb->congested_fn)
2082− r |= cb->congested_fn(cb, bdi_bits);
2083−
2084− return r;
2085−}
2086−
20872052 struct mapped_device *dm_table_get_md(struct dm_table *t)
20882053 {
20892054 return t->md;
drivers/md/dm-thin.c+0−16
@@ -326,7 +326,6 @@ struct pool_c { · 325 unmodified lines
326326 struct pool *pool;
327327 struct dm_dev *data_dev;
328328 struct dm_dev *metadata_dev;
329− struct dm_target_callbacks callbacks;
330329
331330 dm_block_t low_water_blocks;
332331 struct pool_features requested_pf; /* Features requested during table load */
@@ -2796,18 +2795,6 @@ static int thin_bio_map(struct dm_target *ti, struct bio *bio) · 2463 unmodified lines
27962795 }
27972796 }
27982797
2799−static int pool_is_congested(struct dm_target_callbacks *cb, int bdi_bits)
2800−{
2801− struct pool_c *pt = container_of(cb, struct pool_c, callbacks);
2802− struct request_queue *q;
2803−
2804− if (get_pool_mode(pt->pool) == PM_OUT_OF_DATA_SPACE)
2805− return 1;
2806−
2807− q = bdev_get_queue(pt->data_dev->bdev);
2808− return bdi_congested(q->backing_dev_info, bdi_bits);
2809−}
2810−
28112798 static void requeue_bios(struct pool *pool)
28122799 {
28132800 struct thin_c *tc;
@@ -3420,9 +3407,6 @@ static int pool_ctr(struct dm_target *ti, unsigned argc, char **argv) · 606 unmodified lines
34203407 dm_pool_register_pre_commit_callback(pool->pmd,
34213408 metadata_pre_commit_callback, pool);
34223409
3423− pt->callbacks.congested_fn = pool_is_congested;
3424− dm_table_add_target_callbacks(ti->table, &pt->callbacks);
3425−
34263410 mutex_unlock(&dm_thin_pool_table.mutex);
34273411
34283412 return 0;
drivers/md/dm.c+0−33
@@ -1821,31 +1821,6 @@ static blk_qc_t dm_submit_bio(struct bio *bio) · 1820 unmodified lines
18211821 return ret;
18221822 }
18231823
1824−static int dm_any_congested(void *congested_data, int bdi_bits)
1825−{
1826− int r = bdi_bits;
1827− struct mapped_device *md = congested_data;
1828− struct dm_table *map;
1829−
1830− if (!test_bit(DMF_BLOCK_IO_FOR_SUSPEND, &md->flags)) {
1831− if (dm_request_based(md)) {
1832− /*
1833− * With request-based DM we only need to check the
1834− * top-level queue for congestion.
1835− */
1836− struct backing_dev_info *bdi = md->queue->backing_dev_info;
1837− r = bdi->wb.congested & bdi_bits;
1838− } else {
1839− map = dm_get_live_table_fast(md);
1840− if (map)
1841− r = dm_table_any_congested(map, bdi_bits);
1842− dm_put_live_table_fast(md);
1843− }
1844− }
1845−
1846− return r;
1847−}
1848−
18491824 /*-----------------------------------------------------------------
18501825 * An IDR is used to keep track of allocated minor numbers.
18511826 *---------------------------------------------------------------*/
@@ -2284,12 +2259,6 @@ struct queue_limits *dm_get_queue_limits(struct mapped_device *md) · 432 unmodified lines
22842259 }
22852260 EXPORT_SYMBOL_GPL(dm_get_queue_limits);
22862261
2287−static void dm_init_congested_fn(struct mapped_device *md)
2288−{
2289− md->queue->backing_dev_info->congested_data = md;
2290− md->queue->backing_dev_info->congested_fn = dm_any_congested;
2291−}
2292−
22932262 /*
22942263 * Setup the DM device's queue based on md's type
22952264 */
@@ -2306,12 +2275,10 @@ int dm_setup_md_queue(struct mapped_device *md, struct dm_table *t) · 10 unmodified lines
23062275 DMERR("Cannot initialize queue for request-based dm-mq mapped device");
23072276 return r;
23082277 }
2309− dm_init_congested_fn(md);
23102278 break;
23112279 case DM_TYPE_BIO_BASED:
23122280 case DM_TYPE_DAX_BIO_BASED:
23132281 case DM_TYPE_NVME_BIO_BASED:
2314− dm_init_congested_fn(md);
23152282 break;
23162283 case DM_TYPE_NONE:
23172284 WARN_ON_ONCE(true);
drivers/md/dm.h+0−1
@@ -63,7 +63,6 @@ void dm_table_presuspend_targets(struct dm_table *t); · 62 unmodified lines
6363 void dm_table_presuspend_undo_targets(struct dm_table *t);
6464 void dm_table_postsuspend_targets(struct dm_table *t);
6565 int dm_table_resume_targets(struct dm_table *t);
66−int dm_table_any_congested(struct dm_table *t, int bdi_bits);
6766 enum dm_queue_mode dm_table_get_type(struct dm_table *t);
6867 struct target_type *dm_table_get_immutable_target_type(struct dm_table *t);
6968 struct dm_target *dm_table_get_immutable_target(struct dm_table *t);
drivers/md/md-linear.c+0−24
@@ -46,29 +46,6 @@ static inline struct dev_info *which_dev(struct mddev *mddev, sector_t sector) · 45 unmodified lines
4646 return conf->disks + lo;
4747 }
4848
49−/*
50− * In linear_congested() conf->raid_disks is used as a copy of
51− * mddev->raid_disks to iterate conf->disks[], because conf->raid_disks
52− * and conf->disks[] are created in linear_conf(), they are always
53− * consitent with each other, but mddev->raid_disks does not.
54− */
55−static int linear_congested(struct mddev *mddev, int bits)
56−{
57− struct linear_conf *conf;
58− int i, ret = 0;
59−
60− rcu_read_lock();
61− conf = rcu_dereference(mddev->private);
62−
63− for (i = 0; i < conf->raid_disks && !ret ; i++) {
64− struct request_queue *q = bdev_get_queue(conf->disks[i].rdev->bdev);
65− ret |= bdi_congested(q->backing_dev_info, bits);
66− }
67−
68− rcu_read_unlock();
69− return ret;
70−}
71−
7249 static sector_t linear_size(struct mddev *mddev, sector_t sectors, int raid_disks)
7350 {
7451 struct linear_conf *conf;
@@ -322,7 +299,6 @@ static struct md_personality linear_personality = · 247 unmodified lines
322299 .hot_add_disk = linear_add,
323300 .size = linear_size,
324301 .quiesce = linear_quiesce,
325− .congested = linear_congested,
326302 };
327303
328304 static int __init linear_init (void)
drivers/md/md-multipath.c+0−23
@@ -151,28 +151,6 @@ static void multipath_status(struct seq_file *seq, struct mddev *mddev) · 150 unmodified lines
151151 seq_putc(seq, ']');
152152 }
153153
154−static int multipath_congested(struct mddev *mddev, int bits)
155−{
156− struct mpconf *conf = mddev->private;
157− int i, ret = 0;
158−
159− rcu_read_lock();
160− for (i = 0; i < mddev->raid_disks ; i++) {
161− struct md_rdev *rdev = rcu_dereference(conf->multipaths[i].rdev);
162− if (rdev && !test_bit(Faulty, &rdev->flags)) {
163− struct request_queue *q = bdev_get_queue(rdev->bdev);
164−
165− ret |= bdi_congested(q->backing_dev_info, bits);
166− /* Just like multipath_map, we just check the
167− * first available device
168− */
169− break;
170− }
171− }
172− rcu_read_unlock();
173− return ret;
174−}
175−
176154 /*
177155 * Careful, this can execute in IRQ contexts as well!
178156 */
@@ -478,7 +456,6 @@ static struct md_personality multipath_personality = · 299 unmodified lines
478456 .hot_add_disk = multipath_add_disk,
479457 .hot_remove_disk= multipath_remove_disk,
480458 .size = multipath_size,
481− .congested = multipath_congested,
482459 };
483460
484461 static int __init multipath_init (void)
drivers/md/md.c+0−23
@@ -549,26 +549,6 @@ void mddev_resume(struct mddev *mddev) · 548 unmodified lines
549549 }
550550 EXPORT_SYMBOL_GPL(mddev_resume);
551551
552−int mddev_congested(struct mddev *mddev, int bits)
553−{
554− struct md_personality *pers = mddev->pers;
555− int ret = 0;
556−
557− rcu_read_lock();
558− if (mddev->suspended)
559− ret = 1;
560− else if (pers && pers->congested)
561− ret = pers->congested(mddev, bits);
562− rcu_read_unlock();
563− return ret;
564−}
565−EXPORT_SYMBOL_GPL(mddev_congested);
566−static int md_congested(void *data, int bits)
567−{
568− struct mddev *mddev = data;
569− return mddev_congested(mddev, bits);
570−}
571−
572552 /*
573553 * Generic flush handling for md
574554 */
@@ -5965,8 +5945,6 @@ int md_run(struct mddev *mddev) · 5390 unmodified lines
59655945 blk_queue_flag_set(QUEUE_FLAG_NONROT, mddev->queue);
59665946 else
59675947 blk_queue_flag_clear(QUEUE_FLAG_NONROT, mddev->queue);
5968− mddev->queue->backing_dev_info->congested_data = mddev;
5969− mddev->queue->backing_dev_info->congested_fn = md_congested;
59705948 }
59715949 if (pers->sync_request) {
59725950 if (mddev->kobj.sd &&
@@ -6351,7 +6329,6 @@ static int do_md_stop(struct mddev *mddev, int mode, · 378 unmodified lines
63516329
63526330 __md_stop_writes(mddev);
63536331 __md_stop(mddev);
6354− mddev->queue->backing_dev_info->congested_fn = NULL;
63556332
63566333 /* tell userspace to handle 'inactive' */
63576334 sysfs_notify_dirent_safe(mddev->sysfs_state);
drivers/md/md.h+0−4
@@ -597,9 +597,6 @@ struct md_personality · 596 unmodified lines
597597 * array.
598598 */
599599 void *(*takeover) (struct mddev *mddev);
600− /* congested implements bdi.congested_fn().
601− * Will not be called while array is 'suspended' */
602− int (*congested)(struct mddev *mddev, int bits);
603600 /* Changes the consistency policy of an active array. */
604601 int (*change_consistency_policy)(struct mddev *mddev, const char *buf);
605602 };
@@ -710,7 +707,6 @@ extern void md_done_sync(struct mddev *mddev, int blocks, int ok); · 104 unmodified lines
710707 extern void md_error(struct mddev *mddev, struct md_rdev *rdev);
711708 extern void md_finish_reshape(struct mddev *mddev);
712709
713−extern int mddev_congested(struct mddev *mddev, int bits);
714710 extern bool __must_check md_flush_request(struct mddev *mddev, struct bio *bio);
715711 extern void md_super_write(struct mddev *mddev, struct md_rdev *rdev,
716712 sector_t sector, int size, struct page *page);
drivers/md/raid0.c+0−16
@@ -29,21 +29,6 @@ module_param(default_layout, int, 0644); · 28 unmodified lines
2929 (1L << MD_HAS_PPL) | \
3030 (1L << MD_HAS_MULTIPLE_PPLS))
3131
32−static int raid0_congested(struct mddev *mddev, int bits)
33−{
34− struct r0conf *conf = mddev->private;
35− struct md_rdev **devlist = conf->devlist;
36− int raid_disks = conf->strip_zone[0].nb_dev;
37− int i, ret = 0;
38−
39− for (i = 0; i < raid_disks && !ret ; i++) {
40− struct request_queue *q = bdev_get_queue(devlist[i]->bdev);
41−
42− ret |= bdi_congested(q->backing_dev_info, bits);
43− }
44− return ret;
45−}
46−
4732 /*
4833 * inform the user of the raid configuration
4934 */
@@ -818,7 +803,6 @@ static struct md_personality raid0_personality= · 768 unmodified lines
818803 .size = raid0_size,
819804 .takeover = raid0_takeover,
820805 .quiesce = raid0_quiesce,
821− .congested = raid0_congested,
822806 };
823807
824808 static int __init raid0_init (void)
drivers/md/raid1.c+0−31
@@ -786,36 +786,6 @@ static int read_balance(struct r1conf *conf, struct r1bio *r1_bio, int *max_sect · 785 unmodified lines
786786 return best_disk;
787787 }
788788
789−static int raid1_congested(struct mddev *mddev, int bits)
790−{
791− struct r1conf *conf = mddev->private;
792− int i, ret = 0;
793−
794− if ((bits & (1 << WB_async_congested)) &&
795− conf->pending_count >= max_queued_requests)
796− return 1;
797−
798− rcu_read_lock();
799− for (i = 0; i < conf->raid_disks * 2; i++) {
800− struct md_rdev *rdev = rcu_dereference(conf->mirrors[i].rdev);
801− if (rdev && !test_bit(Faulty, &rdev->flags)) {
802− struct request_queue *q = bdev_get_queue(rdev->bdev);
803−
804− BUG_ON(!q);
805−
806− /* Note the '|| 1' - when read_balance prefers
807− * non-congested targets, it can be removed
808− */
809− if ((bits & (1 << WB_async_congested)) || 1)
810− ret |= bdi_congested(q->backing_dev_info, bits);
811− else
812− ret &= bdi_congested(q->backing_dev_info, bits);
813− }
814− }
815− rcu_read_unlock();
816− return ret;
817−}
818−
819789 static void flush_bio_list(struct r1conf *conf, struct bio *bio)
820790 {
821791 /* flush any pending bitmap writes to disk before proceeding w/ I/O */
@@ -3396,7 +3366,6 @@ static struct md_personality raid1_personality = · 2574 unmodified lines
33963366 .check_reshape = raid1_reshape,
33973367 .quiesce = raid1_quiesce,
33983368 .takeover = raid1_takeover,
3399− .congested = raid1_congested,
34003369 };
34013370
34023371 static int __init raid_init(void)
drivers/md/raid10.c+0−26
@@ -848,31 +848,6 @@ static struct md_rdev *read_balance(struct r10conf *conf, · 847 unmodified lines
848848 return rdev;
849849 }
850850
851−static int raid10_congested(struct mddev *mddev, int bits)
852−{
853− struct r10conf *conf = mddev->private;
854− int i, ret = 0;
855−
856− if ((bits & (1 << WB_async_congested)) &&
857− conf->pending_count >= max_queued_requests)
858− return 1;
859−
860− rcu_read_lock();
861− for (i = 0;
862− (i < conf->geo.raid_disks || i < conf->prev.raid_disks)
863− && ret == 0;
864− i++) {
865− struct md_rdev *rdev = rcu_dereference(conf->mirrors[i].rdev);
866− if (rdev && !test_bit(Faulty, &rdev->flags)) {
867− struct request_queue *q = bdev_get_queue(rdev->bdev);
868−
869− ret |= bdi_congested(q->backing_dev_info, bits);
870− }
871− }
872− rcu_read_unlock();
873− return ret;
874−}
875−
876851 static void flush_pending_writes(struct r10conf *conf)
877852 {
878853 /* Any writes that have been queued but are awaiting
@@ -4929,7 +4904,6 @@ static struct md_personality raid10_personality = · 4050 unmodified lines
49294904 .start_reshape = raid10_start_reshape,
49304905 .finish_reshape = raid10_finish_reshape,
49314906 .update_reshape_pos = raid10_update_reshape_pos,
4932− .congested = raid10_congested,
49334907 };
49344908
49354909 static int __init raid_init(void)
drivers/md/raid5.c+0−25
@@ -5099,28 +5099,6 @@ static void activate_bit_delay(struct r5conf *conf, · 5098 unmodified lines
50995099 }
51005100 }
51015101
5102−static int raid5_congested(struct mddev *mddev, int bits)
5103−{
5104− struct r5conf *conf = mddev->private;
5105−
5106− /* No difference between reads and writes. Just check
5107− * how busy the stripe_cache is
5108− */
5109−
5110− if (test_bit(R5_INACTIVE_BLOCKED, &conf->cache_state))
5111− return 1;
5112−
5113− /* Also checks whether there is pressure on r5cache log space */
5114− if (test_bit(R5C_LOG_TIGHT, &conf->cache_state))
5115− return 1;
5116− if (conf->quiesce)
5117− return 1;
5118− if (atomic_read(&conf->empty_inactive_list_nr))
5119− return 1;
5120−
5121− return 0;
5122−}
5123−
51245102 static int in_chunk_boundary(struct mddev *mddev, struct bio *bio)
51255103 {
51265104 struct r5conf *conf = mddev->private;
@@ -8427,7 +8405,6 @@ static struct md_personality raid6_personality = · 3300 unmodified lines
84278405 .finish_reshape = raid5_finish_reshape,
84288406 .quiesce = raid5_quiesce,
84298407 .takeover = raid6_takeover,
8430− .congested = raid5_congested,
84318408 .change_consistency_policy = raid5_change_consistency_policy,
84328409 };
84338410 static struct md_personality raid5_personality =
@@ -8452,7 +8429,6 @@ static struct md_personality raid5_personality = · 18 unmodified lines
84528429 .finish_reshape = raid5_finish_reshape,
84538430 .quiesce = raid5_quiesce,
84548431 .takeover = raid5_takeover,
8455− .congested = raid5_congested,
84568432 .change_consistency_policy = raid5_change_consistency_policy,
84578433 };
84588434
@@ -8478,7 +8454,6 @@ static struct md_personality raid4_personality = · 19 unmodified lines
84788454 .finish_reshape = raid5_finish_reshape,
84798455 .quiesce = raid5_quiesce,
84808456 .takeover = raid4_takeover,
8481− .congested = raid5_congested,
84828457 .change_consistency_policy = raid5_change_consistency_policy,
84838458 };
84848459
fs/btrfs/disk-io.c+0−23
@@ -1616,27 +1616,6 @@ fail: · 1615 unmodified lines
16161616 return ERR_PTR(ret);
16171617 }
16181618
1619−static int btrfs_congested_fn(void *congested_data, int bdi_bits)
1620−{
1621− struct btrfs_fs_info *info = (struct btrfs_fs_info *)congested_data;
1622− int ret = 0;
1623− struct btrfs_device *device;
1624− struct backing_dev_info *bdi;
1625−
1626− rcu_read_lock();
1627− list_for_each_entry_rcu(device, &info->fs_devices->devices, dev_list) {
1628− if (!device->bdev)
1629− continue;
1630− bdi = device->bdev->bd_bdi;
1631− if (bdi_congested(bdi, bdi_bits)) {
1632− ret = 1;
1633− break;
1634− }
1635− }
1636− rcu_read_unlock();
1637− return ret;
1638−}
1639−
16401619 /*
16411620 * called by the kthread helper functions to finally call the bio end_io
16421621 * functions. This is where read checksum verification actually happens
@@ -3051,8 +3030,6 @@ int __cold open_ctree(struct super_block *sb, struct btrfs_fs_devices *fs_device · 1408 unmodified lines
30513030 goto fail_sb_buffer;
30523031 }
30533032
3054− sb->s_bdi->congested_fn = btrfs_congested_fn;
3055− sb->s_bdi->congested_data = fs_info;
30563033 sb->s_bdi->capabilities |= BDI_CAP_CGROUP_WRITEBACK;
30573034 sb->s_bdi->ra_pages = VM_READAHEAD_PAGES;
30583035 sb->s_bdi->ra_pages *= btrfs_super_num_devices(disk_super);
include/linux/backing-dev-defs.h+0−4
@@ -33,8 +33,6 @@ enum wb_congested_state { · 32 unmodified lines
3333 WB_sync_congested, /* The sync queue is getting full */
3434 };
3535
36−typedef int (congested_fn)(void *, int);
37−
3836 enum wb_stat_item {
3937 WB_RECLAIMABLE,
4038 WB_WRITEBACK,
@@ -170,8 +168,6 @@ struct backing_dev_info { · 129 unmodified lines
170168 struct list_head bdi_list;
171169 unsigned long ra_pages; /* max readahead in PAGE_SIZE units */
172170 unsigned long io_pages; /* max allowed IO size */
173− congested_fn *congested_fn; /* Function pointer if device is md/dm */
174− void *congested_data; /* Pointer to aux data for congested func */
175171
176172 struct kref refcnt; /* Reference counter for the structure */
177173 unsigned int capabilities; /* Device capabilities */
include/linux/backing-dev.h+0−4
@@ -169,10 +169,6 @@ static inline struct backing_dev_info *inode_to_bdi(struct inode *inode) · 168 unmodified lines
169169
170170 static inline int wb_congested(struct bdi_writeback *wb, int cong_bits)
171171 {
172− struct backing_dev_info *bdi = wb->bdi;
173−
174− if (bdi->congested_fn)
175− return bdi->congested_fn(bdi->congested_data, cong_bits);
176172 return wb->congested & cong_bits;
177173 }
178174
include/linux/device-mapper.h+0−11
@@ -322,12 +322,6 @@ struct dm_target { · 321 unmodified lines
322322 bool discards_supported:1;
323323 };
324324
325−/* Each target can link one of these into the table */
326−struct dm_target_callbacks {
327− struct list_head list;
328− int (*congested_fn) (struct dm_target_callbacks *, int);
329−};
330−
331325 void *dm_per_bio_data(struct bio *bio, size_t data_size);
332326 struct bio *dm_bio_from_per_bio_data(void *data, size_t data_size);
333327 unsigned dm_bio_get_target_bio_nr(const struct bio *bio);
@@ -477,11 +471,6 @@ int dm_table_create(struct dm_table **result, fmode_t mode, · 143 unmodified lines
477471 int dm_table_add_target(struct dm_table *t, const char *type,
478472 sector_t start, sector_t len, char *params);
479473
480−/*
481− * Target_ctr should call this if it needs to add any callbacks.
482− */
483−void dm_table_add_target_callbacks(struct dm_table *t, struct dm_target_callbacks *cb);
484−
485474 /*
486475 * Target can use this to set the table's type.
487476 * Can only ever be called from a target's ctr.