Commit a88f2096 authored by NeilBrown's avatar NeilBrown Committed by Linus Torvalds
Browse files

remove congestion tracking framework 

This framework is no longer used - so discard it.

Link: https://lkml.kernel.org/r/164549983747.9187.6171768583526866601.stgit@noble.brown


Signed-off-by: default avatarNeilBrown <neilb@suse.de>
Cc: Anna Schumaker <Anna.Schumaker@Netapp.com>
Cc: Chao Yu <chao@kernel.org>
Cc: Darrick J. Wong <djwong@kernel.org>
Cc: Ilya Dryomov <idryomov@gmail.com>
Cc: Jaegeuk Kim <jaegeuk@kernel.org>
Cc: Jan Kara <jack@suse.cz>
Cc: Jeff Layton <jlayton@kernel.org>
Cc: Jens Axboe <axboe@kernel.dk>
Cc: Lars Ellenberg <lars.ellenberg@linbit.com>
Cc: Miklos Szeredi <miklos@szeredi.hu>
Cc: Paolo Valente <paolo.valente@linaro.org>
Cc: Philipp Reisner <philipp.reisner@linbit.com>
Cc: Ryusuke Konishi <konishi.ryusuke@gmail.com>
Cc: Trond Myklebust <trond.myklebust@hammerspace.com>
Cc: Wu Fengguang <fengguang.wu@intel.com>
Signed-off-by: default avatarAndrew Morton <akpm@linux-foundation.org>
Signed-off-by: default avatarLinus Torvalds <torvalds@linux-foundation.org>
parent f6bad159

include/linux/backing-dev-defs.h

+0 −8
Original line number Diff line number Diff line
@@ -207,14 +207,6 @@ struct backing_dev_info { 
#endif

};



enum {

	BLK_RW_ASYNC	= 0,

	BLK_RW_SYNC	= 1,

};



void clear_bdi_congested(struct backing_dev_info *bdi, int sync);

void set_bdi_congested(struct backing_dev_info *bdi, int sync);



struct wb_lock_cookie {

	bool locked;

	unsigned long flags;

include/linux/backing-dev.h

+0 −2
Original line number Diff line number Diff line
@@ -135,8 +135,6 @@ static inline bool writeback_in_progress(struct bdi_writeback *wb) 


struct backing_dev_info *inode_to_bdi(struct inode *inode);



long congestion_wait(int sync, long timeout);



static inline bool mapping_can_writeback(struct address_space *mapping)

{

	return inode_to_bdi(mapping->host)->capabilities & BDI_CAP_WRITEBACK;

include/trace/events/writeback.h

+0 −28
Original line number Diff line number Diff line
@@ -735,34 +735,6 @@ TRACE_EVENT(writeback_sb_inodes_requeue, 
	)

);



DECLARE_EVENT_CLASS(writeback_congest_waited_template,



	TP_PROTO(unsigned int usec_timeout, unsigned int usec_delayed),



	TP_ARGS(usec_timeout, usec_delayed),



	TP_STRUCT__entry(

		__field(	unsigned int,	usec_timeout	)

		__field(	unsigned int,	usec_delayed	)

	),



	TP_fast_assign(

		__entry->usec_timeout	= usec_timeout;

		__entry->usec_delayed	= usec_delayed;

	),



	TP_printk("usec_timeout=%u usec_delayed=%u",

			__entry->usec_timeout,

			__entry->usec_delayed)

);



DEFINE_EVENT(writeback_congest_waited_template, writeback_congestion_wait,



	TP_PROTO(unsigned int usec_timeout, unsigned int usec_delayed),



	TP_ARGS(usec_timeout, usec_delayed)

);



DECLARE_EVENT_CLASS(writeback_single_inode_template,



	TP_PROTO(struct inode *inode,

mm/backing-dev.c

+0 −57
Original line number Diff line number Diff line
@@ -1005,60 +1005,3 @@ const char *bdi_dev_name(struct backing_dev_info *bdi) 
	return bdi->dev_name;

}

EXPORT_SYMBOL_GPL(bdi_dev_name);
 


static wait_queue_head_t congestion_wqh[2] = {

		__WAIT_QUEUE_HEAD_INITIALIZER(congestion_wqh[0]),

		__WAIT_QUEUE_HEAD_INITIALIZER(congestion_wqh[1])

	};

static atomic_t nr_wb_congested[2];



void clear_bdi_congested(struct backing_dev_info *bdi, int sync)

{

	wait_queue_head_t *wqh = &congestion_wqh[sync];

	enum wb_congested_state bit;



	bit = sync ? WB_sync_congested : WB_async_congested;

	if (test_and_clear_bit(bit, &bdi->wb.congested))

		atomic_dec(&nr_wb_congested[sync]);

	smp_mb__after_atomic();

	if (waitqueue_active(wqh))

		wake_up(wqh);

}

EXPORT_SYMBOL(clear_bdi_congested);



void set_bdi_congested(struct backing_dev_info *bdi, int sync)

{

	enum wb_congested_state bit;



	bit = sync ? WB_sync_congested : WB_async_congested;

	if (!test_and_set_bit(bit, &bdi->wb.congested))

		atomic_inc(&nr_wb_congested[sync]);

}

EXPORT_SYMBOL(set_bdi_congested);



/**

 * congestion_wait - wait for a backing_dev to become uncongested

 * @sync: SYNC or ASYNC IO

 * @timeout: timeout in jiffies

 *

 * Waits for up to @timeout jiffies for a backing_dev (any backing_dev) to exit

 * write congestion.  If no backing_devs are congested then just wait for the

 * next write to be completed.

 */

long congestion_wait(int sync, long timeout)

{

	long ret;

	unsigned long start = jiffies;

	DEFINE_WAIT(wait);

	wait_queue_head_t *wqh = &congestion_wqh[sync];



	prepare_to_wait(wqh, &wait, TASK_UNINTERRUPTIBLE);

	ret = io_schedule_timeout(timeout);

	finish_wait(wqh, &wait);



	trace_writeback_congestion_wait(jiffies_to_usecs(timeout),

					jiffies_to_usecs(jiffies - start));



	return ret;

}

EXPORT_SYMBOL(congestion_wait);