vfs: add support for a lazytime mount option (0ae45f63) · Commits · 戴 / test

fs/ext4/inode.c

+6 −0

Original line number	Original line	Diff line number	Diff line
	@@ -4840,11 +4840,17 @@ int ext4_mark_inode_dirty(handle_t handle, struct inode inode)
	* If the inode is marked synchronous, we don't honour that here - doing		* If the inode is marked synchronous, we don't honour that here - doing
	* so would cause a commit on atime updates, which we don't bother doing.		* so would cause a commit on atime updates, which we don't bother doing.
	* We handle synchronous inodes at the highest possible level.		* We handle synchronous inodes at the highest possible level.
			*
			* If only the I_DIRTY_TIME flag is set, we can skip everything. If
			* I_DIRTY_TIME and I_DIRTY_SYNC is set, the only inode fields we need
			* to copy into the on-disk inode structure are the timestamp files.
	*/		*/
	void ext4_dirty_inode(struct inode *inode, int flags)		void ext4_dirty_inode(struct inode *inode, int flags)
	{		{
	handle_t *handle;		handle_t *handle;

			if (flags == I_DIRTY_TIME)
			return;
	handle = ext4_journal_start(inode, EXT4_HT_INODE, 2);		handle = ext4_journal_start(inode, EXT4_HT_INODE, 2);
	if (IS_ERR(handle))		if (IS_ERR(handle))
	goto out;		goto out;

fs/fs-writeback.c

+51 −11

Original line number	Original line	Diff line number	Diff line
	@@ -247,14 +247,19 @@ static bool inode_dirtied_after(struct inode *inode, unsigned long t)
	return ret;		return ret;
	}		}

			#define EXPIRE_DIRTY_ATIME 0x0001

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

			if ((flags & EXPIRE_DIRTY_ATIME) == 0)
			older_than_this = work->older_than_this;
			else if ((work->reason == WB_REASON_SYNC) == 0) {
			expire_time = jiffies - (HZ * 86400);
			older_than_this = &expire_time;
			}
	while (!list_empty(delaying_queue)) {		while (!list_empty(delaying_queue)) {
	inode = wb_inode(delaying_queue->prev);		inode = wb_inode(delaying_queue->prev);
	if (work->older_than_this &&		if (older_than_this &&
	inode_dirtied_after(inode, *work->older_than_this))		inode_dirtied_after(inode, *older_than_this))
	break;		break;
	list_move(&inode->i_wb_list, &tmp);		list_move(&inode->i_wb_list, &tmp);
	moved++;		moved++;
			if (flags & EXPIRE_DIRTY_ATIME)
			set_bit(__I_DIRTY_TIME_EXPIRED, &inode->i_state);
	if (sb_is_blkdev_sb(inode->i_sb))		if (sb_is_blkdev_sb(inode->i_sb))
	continue;		continue;
	if (sb && sb != inode->i_sb)		if (sb && sb != inode->i_sb)
	@@ -309,9 +322,12 @@ out:
	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)
	{		{
	int moved;		int moved;

	assert_spin_locked(&wb->list_lock);		assert_spin_locked(&wb->list_lock);
	list_splice_init(&wb->b_more_io, &wb->b_io);		list_splice_init(&wb->b_more_io, &wb->b_io);
	moved = move_expired_inodes(&wb->b_dirty, &wb->b_io, work);		moved = move_expired_inodes(&wb->b_dirty, &wb->b_io, 0, work);
			moved += move_expired_inodes(&wb->b_dirty_time, &wb->b_io,
			EXPIRE_DIRTY_ATIME, work);
	trace_writeback_queue_io(wb, work, moved);		trace_writeback_queue_io(wb, work, moved);
	}		}

	@@ -435,6 +451,8 @@ static void requeue_inode(struct inode inode, struct bdi_writeback wb,
	* updates after data IO completion.		* updates after data IO completion.
	*/		*/
	redirty_tail(inode, wb);		redirty_tail(inode, wb);
			} else if (inode->i_state & I_DIRTY_TIME) {
			list_move(&inode->i_wb_list, &wb->b_dirty_time);
	} else {		} else {
	/* The inode is clean. Remove from writeback lists. */		/* The inode is clean. Remove from writeback lists. */
	list_del_init(&inode->i_wb_list);		list_del_init(&inode->i_wb_list);
	@@ -481,7 +499,13 @@ __writeback_single_inode(struct inode inode, struct writeback_control wbc)
	spin_lock(&inode->i_lock);		spin_lock(&inode->i_lock);

	dirty = inode->i_state & I_DIRTY;		dirty = inode->i_state & I_DIRTY;
	inode->i_state &= ~I_DIRTY;		if (((dirty & (I_DIRTY_SYNC \| I_DIRTY_DATASYNC)) &&
			(inode->i_state & I_DIRTY_TIME)) \|\|
			(inode->i_state & I_DIRTY_TIME_EXPIRED)) {
			dirty \|= I_DIRTY_TIME \| I_DIRTY_TIME_EXPIRED;
			trace_writeback_lazytime(inode);
			}
			inode->i_state &= ~dirty;

	/*		/*
	* Paired with smp_mb() in __mark_inode_dirty(). This allows		* Paired with smp_mb() in __mark_inode_dirty(). This allows
	@@ -501,8 +525,10 @@ __writeback_single_inode(struct inode inode, struct writeback_control wbc)

	spin_unlock(&inode->i_lock);		spin_unlock(&inode->i_lock);

			if (dirty & I_DIRTY_TIME)
			mark_inode_dirty_sync(inode);
	/* Don't write the inode if only I_DIRTY_PAGES was set */		/* Don't write the inode if only I_DIRTY_PAGES was set */
	if (dirty & (I_DIRTY_SYNC \| I_DIRTY_DATASYNC)) {		if (dirty & ~I_DIRTY_PAGES) {
	int err = write_inode(inode, wbc);		int err = write_inode(inode, wbc);
	if (ret == 0)		if (ret == 0)
	ret = err;		ret = err;
	@@ -550,7 +576,7 @@ writeback_single_inode(struct inode inode, struct bdi_writeback wb,
	* make sure inode is on some writeback list and leave it there unless		* make sure inode is on some writeback list and leave it there unless
	* we have completely cleaned the inode.		* we have completely cleaned the inode.
	*/		*/
	if (!(inode->i_state & I_DIRTY) &&		if (!(inode->i_state & I_DIRTY_ALL) &&
	(wbc->sync_mode != WB_SYNC_ALL \|\|		(wbc->sync_mode != WB_SYNC_ALL \|\|
	!mapping_tagged(inode->i_mapping, PAGECACHE_TAG_WRITEBACK)))		!mapping_tagged(inode->i_mapping, PAGECACHE_TAG_WRITEBACK)))
	goto out;		goto out;
	@@ -565,7 +591,7 @@ writeback_single_inode(struct inode inode, struct bdi_writeback wb,
	* If inode is clean, remove it from writeback lists. Otherwise don't		* If inode is clean, remove it from writeback lists. Otherwise don't
	* touch it. See comment above for explanation.		* touch it. See comment above for explanation.
	*/		*/
	if (!(inode->i_state & I_DIRTY))		if (!(inode->i_state & I_DIRTY_ALL))
	list_del_init(&inode->i_wb_list);		list_del_init(&inode->i_wb_list);
	spin_unlock(&wb->list_lock);		spin_unlock(&wb->list_lock);
	inode_sync_complete(inode);		inode_sync_complete(inode);
	@@ -707,7 +733,7 @@ static long writeback_sb_inodes(struct super_block *sb,
	wrote += write_chunk - wbc.nr_to_write;		wrote += write_chunk - wbc.nr_to_write;
	spin_lock(&wb->list_lock);		spin_lock(&wb->list_lock);
	spin_lock(&inode->i_lock);		spin_lock(&inode->i_lock);
	if (!(inode->i_state & I_DIRTY))		if (!(inode->i_state & I_DIRTY_ALL))
	wrote++;		wrote++;
	requeue_inode(inode, wb, &wbc);		requeue_inode(inode, wb, &wbc);
	inode_sync_complete(inode);		inode_sync_complete(inode);
	@@ -1145,16 +1171,20 @@ static noinline void block_dump___mark_inode_dirty(struct inode *inode)
	* page->mapping->host, so the page-dirtying time is recorded in the internal		* page->mapping->host, so the page-dirtying time is recorded in the internal
	* blockdev inode.		* blockdev inode.
	*/		*/
			#define I_DIRTY_INODE (I_DIRTY_SYNC \| I_DIRTY_DATASYNC)
	void __mark_inode_dirty(struct inode *inode, int flags)		void __mark_inode_dirty(struct inode *inode, int flags)
	{		{
	struct super_block *sb = inode->i_sb;		struct super_block *sb = inode->i_sb;
	struct backing_dev_info *bdi = NULL;		struct backing_dev_info *bdi = NULL;
			int dirtytime;

			trace_writeback_mark_inode_dirty(inode, flags);

	/*		/*
	* Don't do this for I_DIRTY_PAGES - that doesn't actually		* Don't do this for I_DIRTY_PAGES - that doesn't actually
	* dirty the inode itself		* dirty the inode itself
	*/		*/
	if (flags & (I_DIRTY_SYNC \| I_DIRTY_DATASYNC)) {		if (flags & (I_DIRTY_SYNC \| I_DIRTY_DATASYNC \| I_DIRTY_TIME)) {
	trace_writeback_dirty_inode_start(inode, flags);		trace_writeback_dirty_inode_start(inode, flags);

	if (sb->s_op->dirty_inode)		if (sb->s_op->dirty_inode)
	@@ -1162,6 +1192,9 @@ void __mark_inode_dirty(struct inode *inode, int flags)

	trace_writeback_dirty_inode(inode, flags);		trace_writeback_dirty_inode(inode, flags);
	}		}
			if (flags & I_DIRTY_INODE)
			flags &= ~I_DIRTY_TIME;
			dirtytime = flags & I_DIRTY_TIME;

	/*		/*
	* Paired with smp_mb() in __writeback_single_inode() for the		* Paired with smp_mb() in __writeback_single_inode() for the
	@@ -1169,16 +1202,21 @@ void __mark_inode_dirty(struct inode *inode, int flags)
	*/		*/
	smp_mb();		smp_mb();

	if ((inode->i_state & flags) == flags)		if (((inode->i_state & flags) == flags) \|\|
			(dirtytime && (inode->i_state & I_DIRTY_INODE)))
	return;		return;

	if (unlikely(block_dump))		if (unlikely(block_dump))
	block_dump___mark_inode_dirty(inode);		block_dump___mark_inode_dirty(inode);

	spin_lock(&inode->i_lock);		spin_lock(&inode->i_lock);
			if (dirtytime && (inode->i_state & I_DIRTY_INODE))
			goto out_unlock_inode;
	if ((inode->i_state & flags) != flags) {		if ((inode->i_state & flags) != flags) {
	const int was_dirty = inode->i_state & I_DIRTY;		const int was_dirty = inode->i_state & I_DIRTY;

			if (flags & I_DIRTY_INODE)
			inode->i_state &= ~I_DIRTY_TIME;
	inode->i_state \|= flags;		inode->i_state \|= flags;

	/*		/*
	@@ -1225,8 +1263,10 @@ void __mark_inode_dirty(struct inode *inode, int flags)
	}		}

	inode->dirtied_when = jiffies;		inode->dirtied_when = jiffies;
	list_move(&inode->i_wb_list, &bdi->wb.b_dirty);		list_move(&inode->i_wb_list, dirtytime ?
			&bdi->wb.b_dirty_time : &bdi->wb.b_dirty);
	spin_unlock(&bdi->wb.list_lock);		spin_unlock(&bdi->wb.list_lock);
			trace_writeback_dirty_inode_enqueue(inode);

	if (wakeup_bdi)		if (wakeup_bdi)
	bdi_wakeup_thread_delayed(bdi);		bdi_wakeup_thread_delayed(bdi);

fs/gfs2/file.c

+2 −2

Original line number	Original line	Diff line number	Diff line
	@@ -655,7 +655,7 @@ static int gfs2_fsync(struct file *file, loff_t start, loff_t end,
	{		{
	struct address_space *mapping = file->f_mapping;		struct address_space *mapping = file->f_mapping;
	struct inode *inode = mapping->host;		struct inode *inode = mapping->host;
	int sync_state = inode->i_state & I_DIRTY;		int sync_state = inode->i_state & I_DIRTY_ALL;
	struct gfs2_inode *ip = GFS2_I(inode);		struct gfs2_inode *ip = GFS2_I(inode);
	int ret = 0, ret1 = 0;		int ret = 0, ret1 = 0;

	@@ -668,7 +668,7 @@ static int gfs2_fsync(struct file *file, loff_t start, loff_t end,
	if (!gfs2_is_jdata(ip))		if (!gfs2_is_jdata(ip))
	sync_state &= ~I_DIRTY_PAGES;		sync_state &= ~I_DIRTY_PAGES;
	if (datasync)		if (datasync)
	sync_state &= ~I_DIRTY_SYNC;		sync_state &= ~(I_DIRTY_SYNC \| I_DIRTY_TIME);

	if (sync_state) {		if (sync_state) {
	ret = sync_inode_metadata(inode, 1);		ret = sync_inode_metadata(inode, 1);

fs/inode.c

+40 −16

Original line number	Original line	Diff line number	Diff line
	@@ -18,6 +18,7 @@
	#include <linux/buffer_head.h> /* for inode_has_buffers */		#include <linux/buffer_head.h> /* for inode_has_buffers */
	#include <linux/ratelimit.h>		#include <linux/ratelimit.h>
	#include <linux/list_lru.h>		#include <linux/list_lru.h>
			#include <trace/events/writeback.h>
	#include "internal.h"		#include "internal.h"

	/*		/*
	@@ -30,7 +31,7 @@
	* inode_sb_list_lock protects:		* inode_sb_list_lock protects:
	* sb->s_inodes, inode->i_sb_list		* sb->s_inodes, inode->i_sb_list
	* bdi->wb.list_lock protects:		* bdi->wb.list_lock protects:
	* bdi->wb.b_{dirty,io,more_io}, inode->i_wb_list		* bdi->wb.b_{dirty,io,more_io,dirty_time}, inode->i_wb_list
	* inode_hash_lock protects:		* inode_hash_lock protects:
	* inode_hashtable, inode->i_hash		* inode_hashtable, inode->i_hash
	*		*
	@@ -416,7 +417,8 @@ static void inode_lru_list_add(struct inode *inode)
	*/		*/
	void inode_add_lru(struct inode *inode)		void inode_add_lru(struct inode *inode)
	{		{
	if (!(inode->i_state & (I_DIRTY \| I_SYNC \| I_FREEING \| I_WILL_FREE)) &&		if (!(inode->i_state & (I_DIRTY_ALL \| I_SYNC \|
			I_FREEING \| I_WILL_FREE)) &&
	!atomic_read(&inode->i_count) && inode->i_sb->s_flags & MS_ACTIVE)		!atomic_read(&inode->i_count) && inode->i_sb->s_flags & MS_ACTIVE)
	inode_lru_list_add(inode);		inode_lru_list_add(inode);
	}		}
	@@ -647,7 +649,7 @@ int invalidate_inodes(struct super_block *sb, bool kill_dirty)
	spin_unlock(&inode->i_lock);		spin_unlock(&inode->i_lock);
	continue;		continue;
	}		}
	if (inode->i_state & I_DIRTY && !kill_dirty) {		if (inode->i_state & I_DIRTY_ALL && !kill_dirty) {
	spin_unlock(&inode->i_lock);		spin_unlock(&inode->i_lock);
	busy = 1;		busy = 1;
	continue;		continue;
	@@ -1432,10 +1434,19 @@ static void iput_final(struct inode *inode)
	*/		*/
	void iput(struct inode *inode)		void iput(struct inode *inode)
	{		{
	if (inode) {		if (!inode)
			return;
	BUG_ON(inode->i_state & I_CLEAR);		BUG_ON(inode->i_state & I_CLEAR);
			retry:
	if (atomic_dec_and_lock(&inode->i_count, &inode->i_lock))		if (atomic_dec_and_lock(&inode->i_count, &inode->i_lock)) {
			if (inode->i_nlink && (inode->i_state & I_DIRTY_TIME)) {
			atomic_inc(&inode->i_count);
			inode->i_state &= ~I_DIRTY_TIME;
			spin_unlock(&inode->i_lock);
			trace_writeback_lazytime_iput(inode);
			mark_inode_dirty_sync(inode);
			goto retry;
			}
	iput_final(inode);		iput_final(inode);
	}		}
	}		}
	@@ -1495,14 +1506,9 @@ static int relatime_need_update(struct vfsmount mnt, struct inode inode,
	return 0;		return 0;
	}		}

	/*		int generic_update_time(struct inode inode, struct timespec time, int flags)
	* This does the actual work of updating an inodes time or version. Must have
	* had called mnt_want_write() before calling this.
	*/
	static int update_time(struct inode inode, struct timespec time, int flags)
	{		{
	if (inode->i_op->update_time)		int iflags = I_DIRTY_TIME;
	return inode->i_op->update_time(inode, time, flags);

	if (flags & S_ATIME)		if (flags & S_ATIME)
	inode->i_atime = *time;		inode->i_atime = *time;
	@@ -1512,9 +1518,27 @@ static int update_time(struct inode inode, struct timespec time, int flags)
	inode->i_ctime = *time;		inode->i_ctime = *time;
	if (flags & S_MTIME)		if (flags & S_MTIME)
	inode->i_mtime = *time;		inode->i_mtime = *time;
	mark_inode_dirty_sync(inode);
			if (!(inode->i_sb->s_flags & MS_LAZYTIME) \|\| (flags & S_VERSION))
			iflags \|= I_DIRTY_SYNC;
			__mark_inode_dirty(inode, iflags);
	return 0;		return 0;
	}		}
			EXPORT_SYMBOL(generic_update_time);

			/*
			* This does the actual work of updating an inodes time or version. Must have
			* had called mnt_want_write() before calling this.
			*/
			static int update_time(struct inode inode, struct timespec time, int flags)
			{
			int (update_time)(struct inode , struct timespec *, int);

			update_time = inode->i_op->update_time ? inode->i_op->update_time :
			generic_update_time;

			return update_time(inode, time, flags);
			}

	/**		/**
	* touch_atime - update the access time		* touch_atime - update the access time

fs/jfs/file.c

+1 −1

Original line number	Original line	Diff line number	Diff line
	@@ -39,7 +39,7 @@ int jfs_fsync(struct file *file, loff_t start, loff_t end, int datasync)
	return rc;		return rc;

	mutex_lock(&inode->i_mutex);		mutex_lock(&inode->i_mutex);
	if (!(inode->i_state & I_DIRTY) \|\|		if (!(inode->i_state & I_DIRTY_ALL) \|\|
	(datasync && !(inode->i_state & I_DIRTY_DATASYNC))) {		(datasync && !(inode->i_state & I_DIRTY_DATASYNC))) {
	/* Make sure committed changes hit the disk */		/* Make sure committed changes hit the disk */
	jfs_flush_journal(JFS_SBI(inode->i_sb)->log, 1);		jfs_flush_journal(JFS_SBI(inode->i_sb)->log, 1);

Admin message