Skip to contentSkip to conversation

->write_super lock_super pushdown

PATCH In review Christoph Hellwig 3 participants 5 messages May 11, 2009 – May 12, 2009

Subsystems (7)
lore
Share & tools
lore
#0 lore raw

PATCH 2/2 ->write_super lock_super pushdown

Push down lock_super into ->write_super instances and remove it from the caller.

Following filesystem don't need ->s_lock in ->write_super and are skipped:

* bfs, nilfs2 - no other uses of s_lock and have internal locks in

	->write_super
 * ext2 - uses BKL in ext2_write_super and has internal calls without s_lock
 * reiserfs - no other uses of s_lock as has reiserfs_write_lock (BKL) in
 	->write_super
 * xfs - no other uses of s_lock and uses internal lock (buffer lock on
	superblock buffer) to serialize ->write_super.  Also xfs_fs_write_super 
	is superflous and will go away in the next merge window
fs/ext4/super.c +10 -2
Index: vfs-2.6/fs/ext4/super.c
===================================================================
@@ -66,6 +66,7 @@ static int ext4_remount(struct super_blo
 static int ext4_statfs(struct dentry *dentry, struct kstatfs *buf);
 static int ext4_unfreeze(struct super_block *sb);
 static void ext4_write_super(struct super_block *sb);
+static void ext4_write_super_locked(struct super_block *sb);
 static int ext4_freeze(struct super_block *sb);
 
 
@@ -566,7 +567,7 @@ static void ext4_put_super(struct super_
 	lock_super(sb);
 	lock_kernel();
 	if (sb->s_dirt)
-		ext4_write_super(sb);
+		ext4_write_super_locked(sb);
 
 	ext4_mb_release(sb);
 	ext4_ext_release(sb);
@@ -3273,7 +3274,7 @@ int ext4_force_commit(struct super_block
  * point.  (We can probably nuke this function altogether, and remove
  * any mention to sb->s_dirt in all of fs/ext4; eventual cleanup...)
  */
-static void ext4_write_super(struct super_block *sb)
+static void ext4_write_super_locked(struct super_block *sb)
 {
 	if (EXT4_SB(sb)->s_journal) {
 		if (mutex_trylock(&sb->s_lock) != 0)
@@ -3284,6 +3285,13 @@ static void ext4_write_super(struct supe
 	}
 }
 
+static void ext4_write_super(struct super_block *sb)
+{
+	lock_super(sb);
+	ext4_write_super_locked(sb);
+	unlock_super(sb);
+}
+
 static int ext4_sync_fs(struct super_block *sb, int wait)
 {
 	int ret = 0;
fs/fat/inode.c +2 -0
Index: vfs-2.6/fs/fat/inode.c
===================================================================
@@ -441,10 +441,12 @@ static void fat_clear_inode(struct inode
 
 static void fat_write_super(struct super_block *sb)
 {
+	lock_super(sb);
 	sb->s_dirt = 0;
 
 	if (!(sb->s_flags & MS_RDONLY))
 		fat_clusters_flush(sb);
+	unlock_super(sb);
 }
 
 static void fat_put_super(struct super_block *sb)
fs/super.c +0 -2
Index: vfs-2.6/fs/super.c
===================================================================
@@ -420,10 +420,8 @@ restart:
 			spin_unlock(&sb_lock);
 
 			down_read(&sb->s_umount);
-			lock_super(sb);
 			if (sb->s_root && sb->s_dirt)
 				sb->s_op->write_super(sb);
-			unlock_super(sb);
 			up_read(&sb->s_umount);
 
 			spin_lock(&sb_lock);
fs/sysv/inode.c +2 -0
Index: vfs-2.6/fs/sysv/inode.c
===================================================================
@@ -37,6 +37,7 @@ static void sysv_write_super(struct supe
 	struct sysv_sb_info *sbi = SYSV_SB(sb);
 	unsigned long time = get_seconds(), old_time;
 
+	lock_super(sb);
 	lock_kernel();
 	if (sb->s_flags & MS_RDONLY)
 		goto clean;
@@ -56,6 +57,7 @@ static void sysv_write_super(struct supe
 clean:
 	sb->s_dirt = 0;
 	unlock_kernel();
+	unlock_super(sb);
 }
 
 static int sysv_remount(struct super_block *sb, int *flags, char *data)
fs/ufs/super.c +2 -0
Index: vfs-2.6/fs/ufs/super.c
===================================================================
@@ -1131,6 +1131,7 @@ static void ufs_write_super(struct super
 	struct ufs_super_block_third * usb3;
 	unsigned flags;
 
+	lock_super(sb);
 	lock_kernel();
 	UFSD("ENTER\n");
 	flags = UFS_SB(sb)->s_flags;
@@ -1150,6 +1151,7 @@ static void ufs_write_super(struct super
 	sb->s_dirt = 0;
 	UFSD("EXIT\n");
 	unlock_kernel();
+	unlock_super(sb);
 }
 
 static void ufs_put_super(struct super_block *sb)
fs/affs/super.c +2 -0
Index: vfs-2.6/fs/affs/super.c
===================================================================
@@ -54,6 +54,7 @@ affs_write_super(struct super_block *sb)
 	int clean = 2;
 	struct affs_sb_info *sbi = AFFS_SB(sb);
 
+	lock_super(sb);
 	if (!(sb->s_flags & MS_RDONLY)) {
 		//	if (sbi->s_bitmap[i].bm_bh) {
 		//		if (buffer_dirty(sbi->s_bitmap[i].bm_bh)) {
@@ -66,6 +67,7 @@ affs_write_super(struct super_block *sb)
 		sb->s_dirt = !clean;	/* redo until bitmap synced */
 	} else
 		sb->s_dirt = 0;
+	unlock_super(sb);
 
 	pr_debug("AFFS: write_super() at %lu, clean=%d\n", get_seconds(), clean);
 }
fs/exofs/super.c +2 -0
Index: vfs-2.6/fs/exofs/super.c
===================================================================
@@ -214,6 +214,7 @@ static void exofs_write_super(struct sup
 		return;
 	}
 
+	lock_super(sb);
 	lock_kernel();
 	sbi = sb->s_fs_info;
 	fscb->s_nextid = cpu_to_le64(sbi->s_nextid);
@@ -246,6 +247,7 @@ out:
 	if (or)
 		osd_end_request(or);
 	unlock_kernel();
+	unlock_super(sb);
 	kfree(fscb);
 }
 
fs/hfs/super.c +5 -3
Index: vfs-2.6/fs/hfs/super.c
===================================================================
@@ -49,11 +49,13 @@ MODULE_LICENSE("GPL");
  */
 static void hfs_write_super(struct super_block *sb)
 {
+	lock_super(sb);
 	sb->s_dirt = 0;
-	if (sb->s_flags & MS_RDONLY)
-		return;
+
 	/* sync everything to the buffers */
-	hfs_mdb_commit(sb);
+	if (!(sb->s_flags & MS_RDONLY))
+		hfs_mdb_commit(sb);
+	unlock_super(sb);
 }
 
 /*
fs/hfsplus/super.c +5 -1
Index: vfs-2.6/fs/hfsplus/super.c
===================================================================
@@ -157,10 +157,12 @@ static void hfsplus_write_super(struct s
 	struct hfsplus_vh *vhdr = HFSPLUS_SB(sb).s_vhdr;
 
 	dprint(DBG_SUPER, "hfsplus_write_super\n");
+
+	lock_super(sb);
 	sb->s_dirt = 0;
 	if (sb->s_flags & MS_RDONLY)
 		/* warn? */
-		return;
+		goto out;
 
 	vhdr->free_blocks = cpu_to_be32(HFSPLUS_SB(sb).free_blocks);
 	vhdr->next_alloc = cpu_to_be32(HFSPLUS_SB(sb).next_alloc);
@@ -192,6 +194,8 @@ static void hfsplus_write_super(struct s
 		}
 		HFSPLUS_SB(sb).flags &= ~HFSPLUS_SB_WRITEBACKUP;
 	}
+ out:
+	unlock_super(sb);
 }
 
 static void hfsplus_put_super(struct super_block *sb)
fs/jffs2/super.c +9 -6
Index: vfs-2.6/fs/jffs2/super.c
===================================================================
@@ -56,15 +56,18 @@ static void jffs2_i_init_once(void *foo)
 static void jffs2_write_super(struct super_block *sb)
 {
 	struct jffs2_sb_info *c = JFFS2_SB_INFO(sb);
+
+	lock_super(sb);
 	sb->s_dirt = 0;
 
-	if (sb->s_flags & MS_RDONLY)
-		return;
+	if (!(sb->s_flags & MS_RDONLY)) {
+		D1(printk(KERN_DEBUG "jffs2_write_super()\n"));
+		jffs2_garbage_collect_trigger(c);
+		jffs2_erase_pending_blocks(c, 0);
+		jffs2_flush_wbuf_gc(c, 0);
+	}
 
-	D1(printk(KERN_DEBUG "jffs2_write_super()\n"));
-	jffs2_garbage_collect_trigger(c);
-	jffs2_erase_pending_blocks(c, 0);
-	jffs2_flush_wbuf_gc(c, 0);
+	unlock_super(sb);
 }
 
 static int jffs2_sync_fs(struct super_block *sb, int wait)
fs/sync.c +0 -4
Index: vfs-2.6/fs/sync.c
===================================================================
@@ -33,10 +33,8 @@ static int __sync_filesystem(struct supe
 	else
 		sync_quota_sb(sb, -1);
 	sync_inodes_sb(sb, wait);
-	lock_super(sb);
 	if (sb->s_dirt && sb->s_op->write_super)
 		sb->s_op->write_super(sb);
-	unlock_super(sb);
 	if (sb->s_op->sync_fs)
 		sb->s_op->sync_fs(sb, wait);
 	return __sync_blockdev(sb->s_bdev, wait);
@@ -164,10 +162,8 @@ int file_fsync(struct file *filp, struct
 
 	/* sync the superblock to buffers */
 	sb = inode->i_sb;
-	lock_super(sb);
 	if (sb->s_dirt && sb->s_op->write_super)
 		sb->s_op->write_super(sb);
-	unlock_super(sb);
 
 	/* .. finally sync the buffers to disk */
 	err = sync_blockdev(sb->s_bdev);
maintainer
#1 lore raw
Quoted 11 lines · Christoph Hellwig

Push down lock_super into ->write_super instances and remove it from the caller.

Following filesystem don't need ->s_lock in ->write_super and are skipped:

* bfs, nilfs2 - no other uses of s_lock and have internal locks in

	->write_super

* ext2 - uses BKL in ext2_write_super and has internal calls without s_lock
* reiserfs - no other uses of s_lock as has reiserfs_write_lock (BKL) in ->write_super

Ehh... I'm not at all sure that reiserfs one is OK, but we are not exposing any races that didn't exist before ;-/

#2 lore raw
In reply to Christoph Hellwig
Quoted 15 lines · Christoph Hellwig

Push down lock_super into ->write_super instances and remove it from the caller.

Following filesystem don't need ->s_lock in ->write_super and are skipped:

* bfs, nilfs2 - no other uses of s_lock and have internal locks in

	->write_super
 * ext2 - uses BKL in ext2_write_super and has internal calls without s_lock
 * reiserfs - no other uses of s_lock as has reiserfs_write_lock (BKL) in
 	->write_super
 * xfs - no other uses of s_lock and uses internal lock (buffer lock on
	superblock buffer) to serialize ->write_super.  Also xfs_fs_write_super 
	is superflous and will go away in the next merge window
Quoted 2 lines

Ack-by Boaz Harrosh <[email protected]>

<snip>

Quoted 12 lines

===================================================================

fs/exofs/super.c +1 -0
@@ -214,6 +214,7 @@ static void exofs_write_super(struct sup
 		return;
 	}
 
+	lock_super(sb);
 	lock_kernel();
 	sbi = sb->s_fs_info;
 	fscb->s_nextid = cpu_to_le64(sbi->s_nextid);

fs/exofs/super.c out: · line 253

Quoted 7 lines
fs/exofs/super.c +1 -0
@@ -246,6 +247,7 @@ out:
 	if (or)
 		osd_end_request(or);
 	unlock_kernel();
+	unlock_super(sb);
 	kfree(fscb);
 }
 

Please I have a question about this?

lock_super():
I do not see any other lock_super() in exofs, so all this might "lock" is race against itself, right? Should I make sure that concurrent exofs_write_super are protected some other way and remove this?

lock_kernel();
What is that used for? What should I check so this can be removed?

Sorry for the novice-ness ;-)

Thanks
Boaz

#3 lore raw
Quoted 5 lines · Boaz Harrosh

Please I have a question about this?

lock_super():
I do not see any other lock_super() in exofs, so all this might "lock" is race against itself, right?

Yes.

Quoted 2 lines

Should I make sure that concurrent
exofs_write_super are protected some other way and remove this?

Yes.

Quoted 3 lines

lock_kernel();
What is that used for? What should I check so this can be removed?

lock kernel is the big kernel lock as in the very first lock that was added when Linux grew SMP support. If you filesystem does internal locking you most likely don't need this one at all. The only superblock method still called with the BKL in the vfs tree is remount, but it will most likely be gone before 2.6.31, too. After that you can do a quick audit if there was anything it protected against and remove it.

maintainer
#4 lore raw
Quoted 6 lines · Christoph Hellwig

lock kernel is the big kernel lock as in the very first lock that was added when Linux grew SMP support. If you filesystem does internal locking you most likely don't need this one at all. The only superblock method still called with the BKL in the vfs tree is remount, but it will most likely be gone before 2.6.31, too. After that you can do a quick audit if there was anything it protected against and remove it.

Don't forget that ->get_sb() on mount(2) is also under BKL. Not a superblock method, for obvious reasons.