Commit 21cf8661 authored by Christoph Hellwig's avatar Christoph Hellwig Committed by Jens Axboe
Browse files

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.

Signed-off-by: default avatarChristoph Hellwig <hch@lst.de>
Acked-by: default avatarSong Liu <song@kernel.org>
Acked-by: default avatarDavid Sterba <dsterba@suse.com>
[axboe: fixup unused variables in bcache/request.c]
Signed-off-by: default avatarJens Axboe <axboe@kernel.dk>
parent 8c911f3d

drivers/block/drbd/drbd_main.c

+0 −59
Original line number Diff line number Diff line
@@ -2415,62 +2415,6 @@ static void drbd_cleanup(void) 
	pr_info("module cleanup done.\n");

}



/**

 * drbd_congested() - Callback for the flusher thread

 * @congested_data:	User data

 * @bdi_bits:		Bits the BDI flusher thread is currently interested in

 *

 * Returns 1<<WB_async_congested and/or 1<<WB_sync_congested if we are congested.

 */

static int drbd_congested(void *congested_data, int bdi_bits)

{

	struct drbd_device *device = congested_data;

	struct request_queue *q;

	char reason = '-';

	int r = 0;



	if (!may_inc_ap_bio(device)) {

		/* DRBD has frozen IO */

		r = bdi_bits;

		reason = 'd';

		goto out;

	}



	if (test_bit(CALLBACK_PENDING, &first_peer_device(device)->connection->flags)) {

		r |= (1 << WB_async_congested);

		/* Without good local data, we would need to read from remote,

		 * and that would need the worker thread as well, which is

		 * currently blocked waiting for that usermode helper to

		 * finish.

		 */

		if (!get_ldev_if_state(device, D_UP_TO_DATE))

			r |= (1 << WB_sync_congested);

		else

			put_ldev(device);

		r &= bdi_bits;

		reason = 'c';

		goto out;

	}



	if (get_ldev(device)) {

		q = bdev_get_queue(device->ldev->backing_bdev);

		r = bdi_congested(q->backing_dev_info, bdi_bits);

		put_ldev(device);

		if (r)

			reason = 'b';

	}



	if (bdi_bits & (1 << WB_async_congested) &&

	    test_bit(NET_CONGESTED, &first_peer_device(device)->connection->flags)) {

		r |= (1 << WB_async_congested);

		reason = reason == 'b' ? 'a' : 'n';

	}



out:

	device->congestion_reason = reason;

	return r;

}



static void drbd_init_workqueue(struct drbd_work_queue* wq)

{

	spin_lock_init(&wq->q_lock);
@@ -2825,9 +2769,6 @@ enum drbd_ret_code drbd_create_device(struct drbd_config_context *adm_ctx, unsig 
	/* we have no partitions. we contain only ourselves. */

	device->this_bdev->bd_contains = device->this_bdev;



	q->backing_dev_info->congested_fn = drbd_congested;

	q->backing_dev_info->congested_data = device;



	blk_queue_write_cache(q, true, true);

	/* Setting the max_hw_sectors to an odd value of 8kibyte here

	   This triggers a max_bio_size message upon first attach or connect */

drivers/md/bcache/request.c

+0 −47
Original line number Diff line number Diff line
@@ -1228,36 +1228,8 @@ static int cached_dev_ioctl(struct bcache_device *d, fmode_t mode, 
	return __blkdev_driver_ioctl(dc->bdev, mode, cmd, arg);

}



static int cached_dev_congested(void *data, int bits)

{

	struct bcache_device *d = data;

	struct cached_dev *dc = container_of(d, struct cached_dev, disk);

	struct request_queue *q = bdev_get_queue(dc->bdev);

	int ret = 0;



	if (bdi_congested(q->backing_dev_info, bits))

		return 1;



	if (cached_dev_get(dc)) {

		unsigned int i;

		struct cache *ca;



		for_each_cache(ca, d->c, i) {

			q = bdev_get_queue(ca->bdev);

			ret |= bdi_congested(q->backing_dev_info, bits);

		}



		cached_dev_put(dc);

	}



	return ret;

}



void bch_cached_dev_request_init(struct cached_dev *dc)

{

	struct gendisk *g = dc->disk.disk;



	g->queue->backing_dev_info->congested_fn = cached_dev_congested;

	dc->disk.cache_miss			= cached_dev_cache_miss;

	dc->disk.ioctl				= cached_dev_ioctl;

}
@@ -1341,27 +1313,8 @@ static int flash_dev_ioctl(struct bcache_device *d, fmode_t mode, 
	return -ENOTTY;

}



static int flash_dev_congested(void *data, int bits)

{

	struct bcache_device *d = data;

	struct request_queue *q;

	struct cache *ca;

	unsigned int i;

	int ret = 0;



	for_each_cache(ca, d->c, i) {

		q = bdev_get_queue(ca->bdev);

		ret |= bdi_congested(q->backing_dev_info, bits);

	}



	return ret;

}



void bch_flash_dev_request_init(struct bcache_device *d)

{

	struct gendisk *g = d->disk;



	g->queue->backing_dev_info->congested_fn = flash_dev_congested;

	d->cache_miss				= flash_dev_cache_miss;

	d->ioctl				= flash_dev_ioctl;

}

drivers/md/bcache/super.c

+0 −1
Original line number Diff line number Diff line
@@ -885,7 +885,6 @@ static int bcache_device_init(struct bcache_device *d, unsigned int block_size, 
		return -ENOMEM;



	d->disk->queue			= q;

	q->backing_dev_info->congested_data = d;

	q->limits.max_hw_sectors	= UINT_MAX;

	q->limits.max_sectors		= UINT_MAX;

	q->limits.max_segment_size	= UINT_MAX;

drivers/md/dm-cache-target.c

+0 −19
Original line number Diff line number Diff line
@@ -421,8 +421,6 @@ struct cache { 


	struct rw_semaphore quiesce_lock;



	struct dm_target_callbacks callbacks;



	/*

	 * origin_blocks entries, discarded if set.

	 */
@@ -2423,20 +2421,6 @@ static void set_cache_size(struct cache *cache, dm_cblock_t size) 
	cache->cache_size = size;

}



static int is_congested(struct dm_dev *dev, int bdi_bits)

{

	struct request_queue *q = bdev_get_queue(dev->bdev);

	return bdi_congested(q->backing_dev_info, bdi_bits);

}



static int cache_is_congested(struct dm_target_callbacks *cb, int bdi_bits)

{

	struct cache *cache = container_of(cb, struct cache, callbacks);



	return is_congested(cache->origin_dev, bdi_bits) ||

		is_congested(cache->cache_dev, bdi_bits);

}



#define DEFAULT_MIGRATION_THRESHOLD 2048



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) 
			goto bad;

	}



	cache->callbacks.congested_fn = cache_is_congested;

	dm_table_add_target_callbacks(ti->table, &cache->callbacks);



	cache->metadata_dev = ca->metadata_dev;

	cache->origin_dev = ca->origin_dev;

	cache->cache_dev = ca->cache_dev;

drivers/md/dm-clone-target.c

+0 −15
Original line number Diff line number Diff line
@@ -68,7 +68,6 @@ struct hash_table_bucket; 


struct clone {

	struct dm_target *ti;

	struct dm_target_callbacks callbacks;



	struct dm_dev *metadata_dev;

	struct dm_dev *dest_dev;
@@ -1518,18 +1517,6 @@ error: 
	DMEMIT("Error");

}



static int clone_is_congested(struct dm_target_callbacks *cb, int bdi_bits)

{

	struct request_queue *dest_q, *source_q;

	struct clone *clone = container_of(cb, struct clone, callbacks);



	source_q = bdev_get_queue(clone->source_dev->bdev);

	dest_q = bdev_get_queue(clone->dest_dev->bdev);



	return (bdi_congested(dest_q->backing_dev_info, bdi_bits) |

		bdi_congested(source_q->backing_dev_info, bdi_bits));

}



static sector_t get_dev_size(struct dm_dev *dev)

{

	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) 
		goto out_with_mempool;



	mutex_init(&clone->commit_lock);

	clone->callbacks.congested_fn = clone_is_congested;

	dm_table_add_target_callbacks(ti->table, &clone->callbacks);



	/* Enable flushes */

	ti->num_flush_bios = 1;

CRA Git | Maintained and supported by SUSTech CRA and CCSE