Merge "writeback: Drop I_DIRTY_TIME_EXPIRE" (f49a073b) · Commits · e / devices / android_kernel_xiaomi_sm6125

fs/ext4/inode.c

+1 −1

Original line number	Diff line number	Diff line
		@@ -5135,7 +5135,7 @@ static int other_inode_match(struct inode * inode, unsigned long ino,
		(inode->i_state & I_DIRTY_TIME)) {
		struct ext4_inode_info *ei = EXT4_I(inode);

		inode->i_state &= ~(I_DIRTY_TIME \| I_DIRTY_TIME_EXPIRED);
		inode->i_state &= ~I_DIRTY_TIME;
		spin_unlock(&inode->i_lock);

		spin_lock(&ei->i_raw_lock);

fs/fs-writeback.c

+25 −41

Original line number	Diff line number	Diff line
		@@ -45,7 +45,6 @@ struct wb_completion {
		struct wb_writeback_work {
		long nr_pages;
		struct super_block *sb;
		unsigned long *older_than_this;
		enum writeback_sync_modes sync_mode;
		unsigned int tagged_writepages:1;
		unsigned int for_kupdate:1;
		@@ -1149,16 +1148,13 @@ static bool inode_dirtied_after(struct inode *inode, unsigned long t)
		#define EXPIRE_DIRTY_ATIME 0x0001

		/*
		* Move expired (dirtied before work->older_than_this) dirty inodes from
		* Move expired (dirtied before dirtied_before) dirty inodes from
		* @delaying_queue to @dispatch_queue.
		*/
		static int move_expired_inodes(struct list_head *delaying_queue,
		struct list_head *dispatch_queue,
		int flags,
		struct wb_writeback_work *work)
		unsigned long dirtied_before)
		{
		unsigned long *older_than_this = NULL;
		unsigned long expire_time;
		LIST_HEAD(tmp);
		struct list_head pos, node;
		struct super_block *sb = NULL;
		@@ -1166,22 +1162,13 @@ static int move_expired_inodes(struct list_head *delaying_queue,
		int do_sb_sort = 0;
		int moved = 0;

		if ((flags & EXPIRE_DIRTY_ATIME) == 0)
		older_than_this = work->older_than_this;
		else if (!work->for_sync) {
		expire_time = jiffies - (dirtytime_expire_interval * HZ);
		older_than_this = &expire_time;
		}
		while (!list_empty(delaying_queue)) {
		inode = wb_inode(delaying_queue->prev);
		if (older_than_this &&
		inode_dirtied_after(inode, *older_than_this))
		if (inode_dirtied_after(inode, dirtied_before))
		break;
		list_move(&inode->i_io_list, &tmp);
		moved++;
		spin_lock(&inode->i_lock);
		if (flags & EXPIRE_DIRTY_ATIME)
		inode->i_state \|= I_DIRTY_TIME_EXPIRED;
		inode->i_state \|= I_SYNC_QUEUED;
		spin_unlock(&inode->i_lock);
		if (sb_is_blkdev_sb(inode->i_sb))
		@@ -1221,18 +1208,22 @@ static int move_expired_inodes(struct list_head *delaying_queue,
		* \|
		* +--> dequeue for IO
		*/
		static void queue_io(struct bdi_writeback wb, struct wb_writeback_work work)
		static void queue_io(struct bdi_writeback wb, struct wb_writeback_work work,
		unsigned long dirtied_before)
		{
		int moved;
		unsigned long time_expire_jif = dirtied_before;

		assert_spin_locked(&wb->list_lock);
		list_splice_init(&wb->b_more_io, &wb->b_io);
		moved = move_expired_inodes(&wb->b_dirty, &wb->b_io, 0, work);
		moved = move_expired_inodes(&wb->b_dirty, &wb->b_io, dirtied_before);
		if (!work->for_sync)
		time_expire_jif = jiffies - dirtytime_expire_interval * HZ;
		moved += move_expired_inodes(&wb->b_dirty_time, &wb->b_io,
		EXPIRE_DIRTY_ATIME, work);
		time_expire_jif);
		if (moved)
		wb_io_lists_populated(wb);
		trace_writeback_queue_io(wb, work, moved);
		trace_writeback_queue_io(wb, work, dirtied_before, moved);
		}

		static int write_inode(struct inode inode, struct writeback_control wbc)
		@@ -1405,18 +1396,14 @@ __writeback_single_inode(struct inode inode, struct writeback_control wbc)
		spin_lock(&inode->i_lock);

		dirty = inode->i_state & I_DIRTY;
		if (inode->i_state & I_DIRTY_TIME) {
		if ((dirty & (I_DIRTY_SYNC \| I_DIRTY_DATASYNC)) \|\|
		wbc->sync_mode == WB_SYNC_ALL \|\|
		unlikely(inode->i_state & I_DIRTY_TIME_EXPIRED) \|\|
		unlikely(time_after(jiffies,
		(inode->dirtied_time_when +
		dirtytime_expire_interval * HZ)))) {
		dirty \|= I_DIRTY_TIME \| I_DIRTY_TIME_EXPIRED;
		if ((inode->i_state & I_DIRTY_TIME) &&
		((dirty & (I_DIRTY_SYNC \| I_DIRTY_DATASYNC)) \|\|
		wbc->sync_mode == WB_SYNC_ALL \|\| wbc->for_sync \|\|
		time_after(jiffies, inode->dirtied_time_when +
		dirtytime_expire_interval * HZ))) {
		dirty \|= I_DIRTY_TIME;
		trace_writeback_lazytime(inode);
		}
		} else
		inode->i_state &= ~I_DIRTY_TIME_EXPIRED;
		inode->i_state &= ~dirty;

		/*
		@@ -1744,7 +1731,7 @@ static long writeback_inodes_wb(struct bdi_writeback *wb, long nr_pages,
		blk_start_plug(&plug);
		spin_lock(&wb->list_lock);
		if (list_empty(&wb->b_io))
		queue_io(wb, &work);
		queue_io(wb, &work, jiffies);
		__writeback_inodes_wb(wb, &work);
		spin_unlock(&wb->list_lock);
		blk_finish_plug(&plug);
		@@ -1764,7 +1751,7 @@ static long writeback_inodes_wb(struct bdi_writeback *wb, long nr_pages,
		* takes longer than a dirty_writeback_interval interval, then leave a
		* one-second gap.
		*
		* older_than_this takes precedence over nr_to_write. So we'll only write back
		* dirtied_before takes precedence over nr_to_write. So we'll only write back
		* all dirty pages if they are all attached to "old" mappings.
		*/
		static long wb_writeback(struct bdi_writeback *wb,
		@@ -1772,14 +1759,11 @@ static long wb_writeback(struct bdi_writeback *wb,
		{
		unsigned long wb_start = jiffies;
		long nr_pages = work->nr_pages;
		unsigned long oldest_jif;
		unsigned long dirtied_before = jiffies;
		struct inode *inode;
		long progress;
		struct blk_plug plug;

		oldest_jif = jiffies;
		work->older_than_this = &oldest_jif;

		blk_start_plug(&plug);
		spin_lock(&wb->list_lock);
		for (;;) {
		@@ -1813,14 +1797,14 @@ static long wb_writeback(struct bdi_writeback *wb,
		* safe.
		*/
		if (work->for_kupdate) {
		oldest_jif = jiffies -
		dirtied_before = jiffies -
		msecs_to_jiffies(dirty_expire_interval * 10);
		} else if (work->for_background)
		oldest_jif = jiffies;
		dirtied_before = jiffies;

		trace_writeback_start(wb, work);
		if (list_empty(&wb->b_io))
		queue_io(wb, work);
		queue_io(wb, work, dirtied_before);
		if (work->sb)
		progress = writeback_sb_inodes(work->sb, wb, work);
		else

include/linux/fs.h

+0 −1

Original line number	Diff line number	Diff line
		@@ -2056,7 +2056,6 @@ static inline void init_sync_kiocb(struct kiocb kiocb, struct file filp)
		#define I_DIO_WAKEUP (1 << __I_DIO_WAKEUP)
		#define I_LINKABLE (1 << 10)
		#define I_DIRTY_TIME (1 << 11)
		#define I_DIRTY_TIME_EXPIRED (1 << 12)
		#define I_WB_SWITCH (1 << 13)
		#define I_OVL_INUSE (1 << 14)
		#define I_SYNC_QUEUED (1 << 17)

include/trace/events/writeback.h

+6 −8

Original line number	Diff line number	Diff line
		@@ -20,7 +20,6 @@
		{I_CLEAR, "I_CLEAR"}, \
		{I_SYNC, "I_SYNC"}, \
		{I_DIRTY_TIME, "I_DIRTY_TIME"}, \
		{I_DIRTY_TIME_EXPIRED, "I_DIRTY_TIME_EXPIRED"}, \
		{I_REFERENCED, "I_REFERENCED"} \
		)

		@@ -361,8 +360,9 @@ DEFINE_WBC_EVENT(wbc_writepage);
		TRACE_EVENT(writeback_queue_io,
		TP_PROTO(struct bdi_writeback *wb,
		struct wb_writeback_work *work,
		unsigned long dirtied_before,
		int moved),
		TP_ARGS(wb, work, moved),
		TP_ARGS(wb, work, dirtied_before, moved),
		TP_STRUCT__entry(
		__array(char, name, 32)
		__field(unsigned long, older)
		@@ -372,19 +372,17 @@ TRACE_EVENT(writeback_queue_io,
		__field(unsigned int, cgroup_ino)
		),
		TP_fast_assign(
		unsigned long *older_than_this = work->older_than_this;
		strncpy(__entry->name, dev_name(wb->bdi->dev), 32);
		__entry->older = older_than_this ? *older_than_this : 0;
		__entry->age = older_than_this ?
		(jiffies - older_than_this) 1000 / HZ : -1;
		__entry->older = dirtied_before;
		__entry->age = (jiffies - dirtied_before) * 1000 / HZ;
		__entry->moved = moved;
		__entry->reason = work->reason;
		__entry->cgroup_ino = __trace_wb_assign_cgroup(wb);
		),
		TP_printk("bdi %s: older=%lu age=%ld enqueue=%d reason=%s cgroup_ino=%u",
		__entry->name,
		__entry->older, /* older_than_this in jiffies */
		__entry->age, /* older_than_this in relative milliseconds */
		__entry->older, /* dirtied_before in jiffies */
		__entry->age, /* dirtied_before in relative milliseconds */
		__entry->moved,
		__print_symbolic(__entry->reason, WB_WORK_REASON),
		__entry->cgroup_ino