[PATCH v1 0/8] do not use s_dirt in ext2

[PATCH v1 0/8] do not use s_dirt in ext2

[Artem Bityutskiy]

This patch-set makes ext2 independent of the VFS superblock management
services. Namely, ext2 does not require to register the 'write_super()' VFS
call-back.

The reason of this exercises is to get rid of the 'sync_supers()' kernel thread
which wakes up every 5 seconds (by default) even if all superblocks are clean.
This is wasteful from power management POW (unnecessary wake-ups).

Note, I tried to optimize 'sync_supers()' instead in 2010, but Al wanted me
to get rid of it instead. See https://lkml.org/lkml/2010/6/6/87
And I think this is right because many file-systems do not need this, for
example btrfs does not use VFS superblock management services at all, so on a
btrfs-based system we currently end-up useless periodic wake-ups source.

I have sent a similar patch-set for ext4 recently to Ted, see:
http://lkml.org/lkml/2012/3/20/220

Changes for other file-systems are coming later.

The patch-set structure.
1. patch 1 exports 'dirty_writeback_interval' and I also sent it as part of the
   ext4 patch-set
2. patch 2 is also and independent VFS clean-up and I also sent it as part of
   the ext4 patch-set
3. patch 3 is an independent ext2 clean-up patch
4. patches 4-8 actually make ext2 independent on the 'sync_supers()' thread.

Thanks,
Artem.

[PATCH 1/8] mm: export dirty_writeback_interval

[Artem Bityutskiy]

From: Artem Bityutskiy <artem.bityutskiy@linux.intel.com>

Export 'dirty_writeback_interval' to make it visible to file-systems. We are
going to push superblock management down to file-systems and get rid of the
'sync_supers' kernel thread completly.

Signed-off-by: Artem Bityutskiy <artem.bityutskiy@linux.intel.com>
---
 mm/page-writeback.c |    2 ++
 1 files changed, 2 insertions(+), 0 deletions(-)

diff --git a/mm/page-writeback.c b/mm/page-writeback.c
index 363ba70..5e39858 100644
--- a/mm/page-writeback.c
+++ b/mm/page-writeback.c
@@ -95,6 +95,8 @@ unsigned long vm_dirty_bytes;
  */
 unsigned int dirty_writeback_interval = 5 * 100; /* centiseconds */
 
+EXPORT_SYMBOL_GPL(dirty_writeback_interval);
+
 /*
  * The longest time for which data is allowed to remain dirty
  */
-- 
1.7.7.6

[PATCH 2/8] VFS: remove unused superblock helpers

[Artem Bityutskiy]

From: Artem Bityutskiy <artem.bityutskiy@linux.intel.com>

Remove the 'sb_mark_dirty()', 'sb_mark_clean()' and 'sb_is_dirty()' helpers
which are not used. I introduced them 2 years and the intention was to make
all file-systems use them in order to be able to optimize 'sync_supers()'.
However, Al Viro vetoed my patches at the end and asked me to push superblock
management down to file-systems and get rid of the 's_dirt' flag completely,
as well as kill 'sync_supers()' altogether. Thus, remove the helpers.

Signed-off-by: Artem Bityutskiy <artem.bityutskiy@linux.intel.com>
---
 include/linux/fs.h |   13 -------------
 1 files changed, 0 insertions(+), 13 deletions(-)

diff --git a/include/linux/fs.h b/include/linux/fs.h
index 69cd5bb..68387e9 100644
--- a/include/linux/fs.h
+++ b/include/linux/fs.h
@@ -1870,19 +1870,6 @@ extern struct dentry *mount_pseudo(struct file_system_type *, char *,
 	const struct dentry_operations *dops,
 	unsigned long);
 
-static inline void sb_mark_dirty(struct super_block *sb)
-{
-	sb->s_dirt = 1;
-}
-static inline void sb_mark_clean(struct super_block *sb)
-{
-	sb->s_dirt = 0;
-}
-static inline int sb_is_dirty(struct super_block *sb)
-{
-	return sb->s_dirt;
-}

[PATCH 3/8] ext2: write superblock only once on unmount

[Artem Bityutskiy]

From: Artem Bityutskiy <artem.bityutskiy@linux.intel.com>

Currently on unmount if we are mounted R/W, we first write the superblock to
the media if it is dirty, and then write it again, which is not optimal. This
patch makes ext2 write the superblock on unmount less times.

Signed-off-by: Artem Bityutskiy <artem.bityutskiy@linux.intel.com>
---
 fs/ext2/super.c |    3 ---
 1 files changed, 0 insertions(+), 3 deletions(-)

diff --git a/fs/ext2/super.c b/fs/ext2/super.c
index 0090595..d141758 100644
--- a/fs/ext2/super.c
+++ b/fs/ext2/super.c
@@ -130,9 +130,6 @@ static void ext2_put_super (struct super_block * sb)
 
 	dquot_disable(sb, -1, DQUOT_USAGE_ENABLED | DQUOT_LIMITS_ENABLED);
 
-	if (sb->s_dirt)
-		ext2_write_super(sb);
-
 	ext2_xattr_put_super(sb);
 	if (!(sb->s_flags & MS_RDONLY)) {
 		struct ext2_super_block *es = sbi->s_es;
-- 
1.7.7.6

Re: [PATCH 3/8] ext2: write superblock only once on unmount

[Jan Kara]

On Wed 21-03-12 18:14:30, Artem Bityutskiy wrote:
> From: Artem Bityutskiy <artem.bityutskiy@linux.intel.com>
> 
> Currently on unmount if we are mounted R/W, we first write the superblock to
> the media if it is dirty, and then write it again, which is not optimal. This
> patch makes ext2 write the superblock on unmount less times.
  Looks good. I've added the patch to my tree.

									Honza
> 
> Signed-off-by: Artem Bityutskiy <artem.bityutskiy@linux.intel.com>
> ---
>  fs/ext2/super.c |    3 ---
>  1 files changed, 0 insertions(+), 3 deletions(-)
> 
> diff --git a/fs/ext2/super.c b/fs/ext2/super.c
> index 0090595..d141758 100644
> --- a/fs/ext2/super.c
> +++ b/fs/ext2/super.c
> @@ -130,9 +130,6 @@ static void ext2_put_super (struct super_block * sb)
>  
>  	dquot_disable(sb, -1, DQUOT_USAGE_ENABLED | DQUOT_LIMITS_ENABLED);
>  
> -	if (sb->s_dirt)
> -		ext2_write_super(sb);
> -
>  	ext2_xattr_put_super(sb);
>  	if (!(sb->s_flags & MS_RDONLY)) {
>  		struct ext2_super_block *es = sbi->s_es;
> -- 
> 1.7.7.6
> 
-- 
Jan Kara <jack@suse.cz>
SUSE Labs, CR

Re: [PATCH 3/8] ext2: write superblock only once on unmount

[Artem Bityutskiy]

[-- Attachment #1: Type: text/plain, Size: 760 bytes --]

On Sat, 2012-03-31 at 13:53 +0200, Jan Kara wrote:
> On Wed 21-03-12 18:14:30, Artem Bityutskiy wrote:
> > From: Artem Bityutskiy <artem.bityutskiy@linux.intel.com>
> > 
> > Currently on unmount if we are mounted R/W, we first write the superblock to
> > the media if it is dirty, and then write it again, which is not optimal. This
> > patch makes ext2 write the superblock on unmount less times.
>   Looks good. I've added the patch to my tree.

I would like to test v2 against your tree, I found this one:

git://git.kernel.org/pub/scm/linux/kernel/git/jack/linux-fs.git

but I do not see this patch there - is that the right tree, or may be
you did not push out? Which branch should I use?

Thanks!

-- 
Best Regards,
Artem Bityutskiy

[-- Attachment #2: This is a digitally signed message part --]
[-- Type: application/pgp-signature, Size: 836 bytes --]

Re: [PATCH 3/8] ext2: write superblock only once on unmount

[Jan Kara]

On Mon 02-04-12 16:44:09, Artem Bityutskiy wrote:
> On Sat, 2012-03-31 at 13:53 +0200, Jan Kara wrote:
> > On Wed 21-03-12 18:14:30, Artem Bityutskiy wrote:
> > > From: Artem Bityutskiy <artem.bityutskiy@linux.intel.com>
> > > 
> > > Currently on unmount if we are mounted R/W, we first write the superblock to
> > > the media if it is dirty, and then write it again, which is not optimal. This
> > > patch makes ext2 write the superblock on unmount less times.
> >   Looks good. I've added the patch to my tree.
> 
> I would like to test v2 against your tree, I found this one:
> 
> git://git.kernel.org/pub/scm/linux/kernel/git/jack/linux-fs.git
> 
> but I do not see this patch there - is that the right tree, or may be
> you did not push out? Which branch should I use?
  Yeah, I didn't push out the changes. Now they are out (for_next /
for_testing) branch.

								Honza

-- 
Jan Kara <jack@suse.cz>
SUSE Labs, CR

[PATCH 4/8] ext2: intruduce ext2_mark_super_dirty

[Artem Bityutskiy]

From: Artem Bityutskiy <artem.bityutskiy@linux.intel.com>

Introduce a helper function for marking the superblock as dirty. This is just a
preparation for further changes which will make ext2 fully manage its own
superblock and not rely on VFS services like periodic '->write_super()'
callback invocations.

Note: the final goal is to get rid of the 'sync_supers()' kernel thread which
wakes up every 5 seconds and even if there is nothing to do. Thus, we are
pushing superblock management from VFS down to file-systems.

Signed-off-by: Artem Bityutskiy <artem.bityutskiy@linux.intel.com>
---
 fs/ext2/balloc.c |    4 ++--
 fs/ext2/ext2.h   |    1 +
 fs/ext2/ialloc.c |    4 ++--
 fs/ext2/super.c  |    5 +++++
 fs/ext2/xattr.c  |    2 +-
 5 files changed, 11 insertions(+), 5 deletions(-)

diff --git a/fs/ext2/balloc.c b/fs/ext2/balloc.c
index a8cbe1b..dc9ee12 100644
--- a/fs/ext2/balloc.c
+++ b/fs/ext2/balloc.c
@@ -165,7 +165,7 @@ static void release_blocks(struct super_block *sb, int count)
 		struct ext2_sb_info *sbi = EXT2_SB(sb);
 
 		percpu_counter_add(&sbi->s_freeblocks_counter, count);
-		sb->s_dirt = 1;
+		ext2_mark_super_dirty(sb);
 	}
 }
 
@@ -180,7 +180,7 @@ static void group_adjust_blocks(struct super_block *sb, int group_no,
 		free_blocks = le16_to_cpu(desc->bg_free_blocks_count);
 		desc->bg_free_blocks_count = cpu_to_le16(free_blocks + count);
 		spin_unlock(sb_bgl_lock(sbi, group_no));
-		sb->s_dirt = 1;
+		ext2_mark_super_dirty(sb);
 		mark_buffer_dirty(bh);
 	}
 }
diff --git a/fs/ext2/ext2.h b/fs/ext2/ext2.h
index 75ad433..4dc8e55 100644
--- a/fs/ext2/ext2.h
+++ b/fs/ext2/ext2.h
@@ -135,6 +135,7 @@ extern long ext2_compat_ioctl(struct file *, unsigned int, unsigned long);
 struct dentry *ext2_get_parent(struct dentry *child);
 
 /* super.c */
+extern void ext2_mark_super_dirty(struct super_block *sb);
 extern __printf(3, 4)
 void ext2_error(struct super_block *, const char *, const char *, ...);
 extern __printf(3, 4)
diff --git a/fs/ext2/ialloc.c b/fs/ext2/ialloc.c
index 8b15cf8..9688749 100644
--- a/fs/ext2/ialloc.c
+++ b/fs/ext2/ialloc.c
@@ -81,7 +81,7 @@ static void ext2_release_inode(struct super_block *sb, int group, int dir)
 	spin_unlock(sb_bgl_lock(EXT2_SB(sb), group));
 	if (dir)
 		percpu_counter_dec(&EXT2_SB(sb)->s_dirs_counter);
-	sb->s_dirt = 1;
+	ext2_mark_super_dirty(sb);
 	mark_buffer_dirty(bh);
 }
 
@@ -543,7 +543,7 @@ got:
 	}
 	spin_unlock(sb_bgl_lock(sbi, group));
 
-	sb->s_dirt = 1;
+	ext2_mark_super_dirty(sb);
 	mark_buffer_dirty(bh2);
 	if (test_opt(sb, GRPID)) {
 		inode->i_mode = mode;
diff --git a/fs/ext2/super.c b/fs/ext2/super.c
index d141758..134c750 100644
--- a/fs/ext2/super.c
+++ b/fs/ext2/super.c
@@ -1195,6 +1195,11 @@ void ext2_write_super(struct super_block *sb)
 		sb->s_dirt = 0;
 }
 
+void ext2_mark_super_dirty(struct super_block *sb)
+{
+	sb->s_dirt = 1;
+}
+
 static int ext2_remount (struct super_block * sb, int * flags, char * data)
 {
 	struct ext2_sb_info * sbi = EXT2_SB(sb);
diff --git a/fs/ext2/xattr.c b/fs/ext2/xattr.c
index 6dcafc7..a04d280 100644
--- a/fs/ext2/xattr.c
+++ b/fs/ext2/xattr.c
@@ -339,7 +339,7 @@ static void ext2_xattr_update_super_block(struct super_block *sb)
 	spin_lock(&EXT2_SB(sb)->s_lock);
 	EXT2_SET_COMPAT_FEATURE(sb, EXT2_FEATURE_COMPAT_EXT_ATTR);
 	spin_unlock(&EXT2_SB(sb)->s_lock);
-	sb->s_dirt = 1;
+	ext2_mark_super_dirty(sb);
 	mark_buffer_dirty(EXT2_SB(sb)->s_sbh);
 }
 
-- 
1.7.7.6

[PATCH 5/8] ext2: introduce workqueue for superblock synchronization

[Artem Bityutskiy]

From: Artem Bityutskiy <artem.bityutskiy@linux.intel.com>

Introduce a workqueue which will be used for delayed superblock
synchronization in the next patch. So this is just a preparation.

Signed-off-by: Artem Bityutskiy <artem.bityutskiy@linux.intel.com>
---
 fs/ext2/super.c            |   21 ++++++++++++++++++---
 include/linux/ext2_fs_sb.h |    3 +++
 2 files changed, 21 insertions(+), 3 deletions(-)

diff --git a/fs/ext2/super.c b/fs/ext2/super.c
index 134c750..80ffd22 100644
--- a/fs/ext2/super.c
+++ b/fs/ext2/super.c
@@ -130,6 +130,9 @@ static void ext2_put_super (struct super_block * sb)
 
 	dquot_disable(sb, -1, DQUOT_USAGE_ENABLED | DQUOT_LIMITS_ENABLED);
 
+	flush_workqueue(sbi->sync_super_wq);
+	destroy_workqueue(sbi->sync_super_wq);
+
 	ext2_xattr_put_super(sb);
 	if (!(sb->s_flags & MS_RDONLY)) {
 		struct ext2_super_block *es = sbi->s_es;
@@ -1073,15 +1076,23 @@ static int ext2_fill_super(struct super_block *sb, void *data, int silent)
 	sb->s_qcop = &dquot_quotactl_ops;
 #endif
 
+	sbi->sync_super_wq = alloc_workqueue("ext2-sync-super",
+					WQ_MEM_RECLAIM | WQ_UNBOUND, 1);
+	if (!sbi->sync_super_wq) {
+		ext2_msg(sb, KERN_ERR,
+			"error: failed to create sync_super workqueue");
+		goto failed_mount3;
+	}
+
 	root = ext2_iget(sb, EXT2_ROOT_INO);
 	if (IS_ERR(root)) {
 		ret = PTR_ERR(root);
-		goto failed_mount3;
+		goto failed_mount4;
 	}
 	if (!S_ISDIR(root->i_mode) || !root->i_blocks || !root->i_size) {
 		iput(root);
 		ext2_msg(sb, KERN_ERR, "error: corrupt root inode, run e2fsck");
-		goto failed_mount3;
+		goto failed_mount4;
 	}
 
 	sb->s_root = d_alloc_root(root);
@@ -1089,7 +1100,7 @@ static int ext2_fill_super(struct super_block *sb, void *data, int silent)
 		iput(root);
 		ext2_msg(sb, KERN_ERR, "error: get root inode failed");
 		ret = -ENOMEM;
-		goto failed_mount3;
+		goto failed_mount4;
 	}
 	if (EXT2_HAS_COMPAT_FEATURE(sb, EXT3_FEATURE_COMPAT_HAS_JOURNAL))
 		ext2_msg(sb, KERN_WARNING,
@@ -1105,6 +1116,8 @@ cantfind_ext2:
 			"error: can't find an ext2 filesystem on dev %s.",
 			sb->s_id);
 	goto failed_mount;
+failed_mount4:
+	destroy_workqueue(sbi->sync_super_wq);
 failed_mount3:
 	percpu_counter_destroy(&sbi->s_freeblocks_counter);
 	percpu_counter_destroy(&sbi->s_freeinodes_counter);
@@ -1176,6 +1189,8 @@ static int ext2_sync_fs(struct super_block *sb, int wait)
 	struct ext2_sb_info *sbi = EXT2_SB(sb);
 	struct ext2_super_block *es = EXT2_SB(sb)->s_es;
 
+	flush_workqueue(sbi->sync_super_wq);
+
 	spin_lock(&sbi->s_lock);
 	if (es->s_state & cpu_to_le16(EXT2_VALID_FS)) {
 		ext2_debug("setting valid to 0\n");
diff --git a/include/linux/ext2_fs_sb.h b/include/linux/ext2_fs_sb.h
index db4d9f5..75aa40e 100644
--- a/include/linux/ext2_fs_sb.h
+++ b/include/linux/ext2_fs_sb.h
@@ -19,6 +19,7 @@
 #include <linux/blockgroup_lock.h>
 #include <linux/percpu_counter.h>
 #include <linux/rbtree.h>
+#include <linux/workqueue.h>
 
 /* XXX Here for now... not interested in restructing headers JUST now */
 
@@ -98,6 +99,8 @@ struct ext2_sb_info {
 	u32 s_next_generation;
 	unsigned long s_dir_count;
 	u8 *s_debts;
+	/* workqueue for synchronizing the superblock */
+	struct workqueue_struct *sync_super_wq;
 	struct percpu_counter s_freeblocks_counter;
 	struct percpu_counter s_freeinodes_counter;
 	struct percpu_counter s_dirs_counter;
-- 
1.7.7.6

[PATCH 6/8] ext2: stop using VFS for dirty superblock management

[Artem Bityutskiy]

From: Artem Bityutskiy <artem.bityutskiy@linux.intel.com>

Do not use VFS for managing dirty superblock but do it inside ext2. Remove the
'->write_super()' VFS callback and instead, schedule a delayed work when the
superblock is marked as dirty.

We add memory barriers to make sure the 's_dirt' flag changes are visible to
other CPUs as soon as possible to avoid queuing unnecessary works.

Note: the final goal is to get rid of the 'sync_supers()' kernel thread which
wakes up every 5 seconds and even if there is nothing to do. Thus, we are
pushing superblock management from VFS down to file-systems.

Signed-off-by: Artem Bityutskiy <artem.bityutskiy@linux.intel.com>
---
 fs/ext2/super.c |   67 +++++++++++++++++++++++++++++++++++++++++++++++++++---
 1 files changed, 63 insertions(+), 4 deletions(-)

diff --git a/fs/ext2/super.c b/fs/ext2/super.c
index 80ffd22..95dc25f 100644
--- a/fs/ext2/super.c
+++ b/fs/ext2/super.c
@@ -305,7 +305,6 @@ static const struct super_operations ext2_sops = {
 	.write_inode	= ext2_write_inode,
 	.evict_inode	= ext2_evict_inode,
 	.put_super	= ext2_put_super,
-	.write_super	= ext2_write_super,
 	.sync_fs	= ext2_sync_fs,
 	.statfs		= ext2_statfs,
 	.remount_fs	= ext2_remount,
@@ -1161,6 +1160,13 @@ static void ext2_clear_super_error(struct super_block *sb)
 static void ext2_sync_super(struct super_block *sb, struct ext2_super_block *es,
 			    int wait)
 {
+	sb->s_dirt = 0;
+	/*
+	 * Make sure we first mark the superblock as clean and then start
+	 * writing it out.
+	 */
+	smp_wmb();
+
 	ext2_clear_super_error(sb);
 	spin_lock(&EXT2_SB(sb)->s_lock);
 	es->s_free_blocks_count = cpu_to_le32(ext2_count_free_blocks(sb));
@@ -1171,7 +1177,6 @@ static void ext2_sync_super(struct super_block *sb, struct ext2_super_block *es,
 	mark_buffer_dirty(EXT2_SB(sb)->s_sbh);
 	if (wait)
 		sync_dirty_buffer(EXT2_SB(sb)->s_sbh);
-	sb->s_dirt = 0;
 }
 
 /*
@@ -1201,18 +1206,72 @@ static int ext2_sync_fs(struct super_block *sb, int wait)
 	return 0;
 }
 
-
 void ext2_write_super(struct super_block *sb)
 {
 	if (!(sb->s_flags & MS_RDONLY))
 		ext2_sync_fs(sb, 1);
-	else
+	else {
 		sb->s_dirt = 0;
+		smp_wmb();
+	}
+}
+
+struct sb_delayed_work {
+	struct delayed_work dwork;
+	struct super_block *sb;
+};
+
+static struct sb_delayed_work *work_to_sbwork(struct work_struct *work)
+{
+	struct delayed_work *dwork;
+
+	dwork = container_of(work, struct delayed_work, work);
+	return container_of(dwork, struct sb_delayed_work, dwork);
+}
+
+static void write_super(struct work_struct *work)
+{
+	struct sb_delayed_work *sbwork = work_to_sbwork(work);
+	struct super_block *sb = sbwork->sb;
+
+	kfree(sbwork);
+
+	smp_rmb();
+	if (sb->s_dirt)
+		return;
+
+	ext2_write_super(sb);
 }
 
 void ext2_mark_super_dirty(struct super_block *sb)
 {
+	struct ext2_sb_info *sbi = EXT2_SB(sb);
+	struct sb_delayed_work *sbwork;
+	unsigned long delay;
+
+	/* Make sure we see 's_dirt' changes ASAP */
+	smp_rmb();
+	if (sb->s_dirt == 1)
+		return;
 	sb->s_dirt = 1;
+	/* Make other CPUs see the 's_dirt' change as soon as possible */
+	smp_wmb();
+
+	sbwork = kmalloc(sizeof(struct sb_delayed_work), GFP_NOFS);
+	if (!sbwork) {
+		/*
+		 * Well, should not be a big deal - the system must be in
+		 * trouble anyway, and the SB will be written out on unmount or
+		 * we may be luckier next time it is marked as dirty.
+		 */
+		sb->s_dirt = 2;
+		return;
+	}
+
+	INIT_DELAYED_WORK(&sbwork->dwork, write_super);
+	sbwork->sb = sb;
+	delay = msecs_to_jiffies(dirty_writeback_interval * 10);
+	queue_delayed_work(sbi->sync_super_wq, &sbwork->dwork, delay);
 }
 
 static int ext2_remount (struct super_block * sb, int * flags, char * data)
-- 
1.7.7.6

[PATCH 7/8] ext2: cleanup ext2_sync_super a bit

[Artem Bityutskiy]

From: Artem Bityutskiy <artem.bityutskiy@linux.intel.com>

We have many 'EXT2_SB()' in 'ext2_sync_super()' and I am going to introduce a
new one. The code will be a bit nicer if I introduce an 'sbi' pointer instead.
So this patch is just a tiny preparational cleanup.

Signed-off-by: Artem Bityutskiy <artem.bityutskiy@linux.intel.com>
---
 fs/ext2/super.c |   10 ++++++----
 1 files changed, 6 insertions(+), 4 deletions(-)

diff --git a/fs/ext2/super.c b/fs/ext2/super.c
index 95dc25f..4eee017 100644
--- a/fs/ext2/super.c
+++ b/fs/ext2/super.c
@@ -1160,6 +1160,8 @@ static void ext2_clear_super_error(struct super_block *sb)
 static void ext2_sync_super(struct super_block *sb, struct ext2_super_block *es,
 			    int wait)
 {
+	struct ext2_sb_info *sbi = EXT2_SB(sb);
+
 	sb->s_dirt = 0;
 	/*
 	 * Make sure we first mark the superblock as clean and then start
@@ -1168,15 +1170,15 @@ static void ext2_sync_super(struct super_block *sb, struct ext2_super_block *es,
 	smp_wmb();
 
 	ext2_clear_super_error(sb);
-	spin_lock(&EXT2_SB(sb)->s_lock);
+	spin_lock(&sbi->s_lock);
 	es->s_free_blocks_count = cpu_to_le32(ext2_count_free_blocks(sb));
 	es->s_free_inodes_count = cpu_to_le32(ext2_count_free_inodes(sb));
 	es->s_wtime = cpu_to_le32(get_seconds());
 	/* unlock before we do IO */
-	spin_unlock(&EXT2_SB(sb)->s_lock);
-	mark_buffer_dirty(EXT2_SB(sb)->s_sbh);
+	spin_unlock(&sbi->s_lock);
+	mark_buffer_dirty(sbi->s_sbh);
 	if (wait)
-		sync_dirty_buffer(EXT2_SB(sb)->s_sbh);
+		sync_dirty_buffer(sbi->s_sbh);
 }
 
 /*
-- 
1.7.7.6

[PATCH 8/8] ext2: introduce own superblock dirty flag

[Artem Bityutskiy]

From: Artem Bityutskiy <artem.bityutskiy@linux.intel.com>

We finally do not need VFS's 's_dirt' flag in ext2 - introduce our own
's_dirty' flag instead.

Note: the final goal is to get rid of the 'sync_supers()' kernel thread which
wakes up every 5 seconds and even if there is nothing to do. Thus, we are
pushing superblock management from VFS down to file-systems.

Signed-off-by: Artem Bityutskiy <artem.bityutskiy@linux.intel.com>
---
 fs/ext2/super.c            |   16 ++++++++--------
 include/linux/ext2_fs_sb.h |    1 +
 2 files changed, 9 insertions(+), 8 deletions(-)

diff --git a/fs/ext2/super.c b/fs/ext2/super.c
index 4eee017..bb12634 100644
--- a/fs/ext2/super.c
+++ b/fs/ext2/super.c
@@ -1162,7 +1162,7 @@ static void ext2_sync_super(struct super_block *sb, struct ext2_super_block *es,
 {
 	struct ext2_sb_info *sbi = EXT2_SB(sb);
 
-	sb->s_dirt = 0;
+	sbi->s_dirty = 0;
 	/*
 	 * Make sure we first mark the superblock as clean and then start
 	 * writing it out.
@@ -1213,7 +1213,7 @@ void ext2_write_super(struct super_block *sb)
 	if (!(sb->s_flags & MS_RDONLY))
 		ext2_sync_fs(sb, 1);
 	else {
-		sb->s_dirt = 0;
+		EXT2_SB(sb)->s_dirty = 0;
 		smp_wmb();
 	}
 }
@@ -1239,7 +1239,7 @@ static void write_super(struct work_struct *work)
 	kfree(sbwork);
 
 	smp_rmb();
-	if (sb->s_dirt)
+	if (EXT2_SB(sb)->s_dirty)
 		return;
 
 	ext2_write_super(sb);
@@ -1251,12 +1251,12 @@ void ext2_mark_super_dirty(struct super_block *sb)
 	struct sb_delayed_work *sbwork;
 	unsigned long delay;
 
-	/* Make sure we see 's_dirt' changes ASAP */
+	/* Make sure we see 's_dirty' changes ASAP */
 	smp_rmb();
-	if (sb->s_dirt == 1)
+	if (sbi->s_dirty == 1)
 		return;
-	sb->s_dirt = 1;
-	/* Make other CPUs see the 's_dirt' change as soon as possible */
+	sbi->s_dirty = 1;
+	/* Make other CPUs see the 's_dirty' change as soon as possible */
 	smp_wmb();
 
 	sbwork = kmalloc(sizeof(struct sb_delayed_work), GFP_NOFS);
@@ -1266,7 +1266,7 @@ void ext2_mark_super_dirty(struct super_block *sb)
 		 * trouble anyway, and the SB will be written out on unmount or
 		 * we may be luckier next time it is marked as dirty.
 		 */
-		sb->s_dirt = 2;
+		sbi->s_dirty = 2;
 		return;
 	}
 
diff --git a/include/linux/ext2_fs_sb.h b/include/linux/ext2_fs_sb.h
index 75aa40e..5938744 100644
--- a/include/linux/ext2_fs_sb.h
+++ b/include/linux/ext2_fs_sb.h
@@ -99,6 +99,7 @@ struct ext2_sb_info {
 	u32 s_next_generation;
 	unsigned long s_dir_count;
 	u8 *s_debts;
+	int s_dirty;
 	/* workqueue for synchronizing the superblock */
 	struct workqueue_struct *sync_super_wq;
 	struct percpu_counter s_freeblocks_counter;
-- 
1.7.7.6