Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 18df2d2d authored by Jaegeuk Kim's avatar Jaegeuk Kim
Browse files

Merge remote-tracking branch 'aosp/upstream-f2fs-stable-linux-5.4.y' into android-5.4-stable 



* aosp/upstream-f2fs-stable-linux-5.4.y:
  writeback: Drop I_DIRTY_TIME_EXPIRE
  writeback: Fix sync livelock due to b_dirty_time processing
  writeback: Avoid skipping inode writeback
  writeback: Protect inode->i_io_list with inode->i_lock
  Revert "writeback: Avoid skipping inode writeback"

 Conflicts:
	include/trace/events/writeback.h

Bug: 154542664
Change-Id: I98a6258cb60227e6ca02e57bf7adf28ab7816cbf
Signed-off-by: default avatarJaegeuk Kim <jaegeuk@google.com>
parents 754986db e4f1e0bd

fs/ext4/inode.c

+1 −1
Original line number Diff line number Diff line
@@ -5249,7 +5249,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

+32 −48
Original line number Diff line number Diff line
@@ -42,7 +42,6 @@ 
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;
@@ -1176,9 +1175,10 @@ void sb_clear_inode_writeback(struct inode *inode) 
 * the case then the inode must have been redirtied while it was being written

 * out and we don't reset its dirtied_when.

 */

static void __redirty_tail(struct inode *inode, struct bdi_writeback *wb)

static void redirty_tail_locked(struct inode *inode, struct bdi_writeback *wb)

{

	assert_spin_locked(&inode->i_lock);



	if (!list_empty(&wb->b_dirty)) {

		struct inode *tail;
@@ -1193,7 +1193,7 @@ static void __redirty_tail(struct inode *inode, struct bdi_writeback *wb) 
static void redirty_tail(struct inode *inode, struct bdi_writeback *wb)

{

	spin_lock(&inode->i_lock);

	__redirty_tail(inode, wb);

	redirty_tail_locked(inode, wb);

	spin_unlock(&inode->i_lock);

}
@@ -1233,16 +1233,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;
@@ -1250,22 +1247,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))
@@ -1305,18 +1293,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)
@@ -1410,7 +1402,7 @@ static void requeue_inode(struct inode *inode, struct bdi_writeback *wb, 
		 * writeback is not making progress due to locked

		 * buffers. Skip this inode for now.

		 */

		__redirty_tail(inode, wb);

		redirty_tail_locked(inode, wb);

		return;

	}
@@ -1430,7 +1422,7 @@ static void requeue_inode(struct inode *inode, struct bdi_writeback *wb, 
			 * retrying writeback of the dirty page/inode

			 * that cannot be performed immediately.

			 */

			__redirty_tail(inode, wb);

			redirty_tail_locked(inode, wb);

		}

	} else if (inode->i_state & I_DIRTY) {

		/*
@@ -1438,7 +1430,7 @@ static void requeue_inode(struct inode *inode, struct bdi_writeback *wb, 
		 * such as delayed allocation during submission or metadata

		 * updates after data IO completion.

		 */

		__redirty_tail(inode, wb);

		redirty_tail_locked(inode, wb);

	} else if (inode->i_state & I_DIRTY_TIME) {

		inode->dirtied_when = jiffies;

		inode_io_list_move_locked(inode, wb, &wb->b_dirty_time);
@@ -1489,18 +1481,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_INODE) ||

		    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_INODE) ||

	     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;



	/*
@@ -1686,8 +1674,7 @@ static long writeback_sb_inodes(struct super_block *sb, 
		 */

		spin_lock(&inode->i_lock);

		if (inode->i_state & (I_NEW | I_FREEING | I_WILL_FREE)) {

			inode->i_state &= ~I_SYNC_QUEUED;

			__redirty_tail(inode, wb);

			redirty_tail_locked(inode, wb);

			spin_unlock(&inode->i_lock);

			continue;

		}
@@ -1829,7 +1816,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);
@@ -1849,7 +1836,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,
@@ -1857,14 +1844,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 (;;) {
@@ -1898,14 +1882,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

fs/xfs/libxfs/xfs_trans_inode.c

+2 −2
Original line number Diff line number Diff line
@@ -98,9 +98,9 @@ xfs_trans_log_inode( 
	 * to log the timestamps, or will clear already cleared fields in the

	 * worst case.

	 */

	if (inode->i_state & (I_DIRTY_TIME | I_DIRTY_TIME_EXPIRED)) {

	if (inode->i_state & I_DIRTY_TIME) {

		spin_lock(&inode->i_lock);

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

		inode->i_state &= ~I_DIRTY_TIME;

		spin_unlock(&inode->i_lock);

	}

include/linux/fs.h

+1 −2
Original line number Diff line number Diff line
@@ -2224,11 +2224,10 @@ 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_CREATING		(1 << 15)

#define I_SYNC_QUEUED		(1 << 16)

#define I_SYNC_QUEUED		(1 << 17)



#define I_DIRTY_INODE (I_DIRTY_SYNC | I_DIRTY_DATASYNC)

#define I_DIRTY (I_DIRTY_INODE | I_DIRTY_PAGES)

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"}		\

	)
@@ -499,8 +498,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)
@@ -510,19 +510,17 @@ TRACE_EVENT(writeback_queue_io, 
		__field(unsigned int,	cgroup_ino)

	),

	TP_fast_assign(

		unsigned long *older_than_this = work->older_than_this;

		strscpy_pad(__entry->name, bdi_dev_name(wb->bdi), 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