vfs: Rename fsync_super() to sync_filesystem() (version 4)

Rename the function so that it better describe what it really does. Also
remove the unnecessary include of buffer_head.h.

Signed-off-by: Jan Kara <jack@suse.cz>
Signed-off-by: Al Viro <viro@zeniv.linux.org.uk>

diff --git a/fs/block_dev.c b/fs/block_dev.c
index 4b6a3b9d01effcbfa7f09a85950c1ccb1e53b99f..3a6d4fb2a329ceb5795bb18eec19ca71f330832b 100644 (file)
--- a/fs/block_dev.c
+++ b/fs/block_dev.c
@@ -204,7 +204,7 @@ int fsync_bdev(struct block_device *bdev)
 {
        struct super_block *sb = get_super(bdev);
        if (sb) {
-               int res = fsync_super(sb);
+               int res = sync_filesystem(sb);
                drop_super(sb);
                return res;
        }
@@ -246,7 +246,7 @@ struct super_block *freeze_bdev(struct block_device *bdev)
                sb->s_frozen = SB_FREEZE_WRITE;
                smp_wmb();
 
-               fsync_super(sb);
+               sync_filesystem(sb);
 
                sb->s_frozen = SB_FREEZE_TRANS;
                smp_wmb();

diff --git a/fs/cachefiles/interface.c b/fs/cachefiles/interface.c
index 1e962348d1114267f85895c7b60870754692ac76..dafd484d7bdac3610f5983c4d86d1bc8bc1cdd66 100644 (file)
--- a/fs/cachefiles/interface.c
+++ b/fs/cachefiles/interface.c
@@ -354,7 +354,7 @@ static void cachefiles_sync_cache(struct fscache_cache *_cache)
        /* make sure all pages pinned by operations on behalf of the netfs are
         * written to disc */
        cachefiles_begin_secure(cache, &saved_cred);
-       ret = fsync_super(cache->mnt->mnt_sb);
+       ret = sync_filesystem(cache->mnt->mnt_sb);
        cachefiles_end_secure(cache, saved_cred);
 
        if (ret == -EIO)

diff --git a/fs/super.c b/fs/super.c
index f822c74f25bee8476832e563c42455e323bac403..721236e6177ac6da67ce7c918c9c8e1f02b97d21 100644 (file)
--- a/fs/super.c
+++ b/fs/super.c
@@ -28,7 +28,6 @@
 #include <linux/blkdev.h>
 #include <linux/quotaops.h>
 #include <linux/namei.h>
-#include <linux/buffer_head.h>         /* for fsync_super() */
 #include <linux/mount.h>
 #include <linux/security.h>
 #include <linux/syscalls.h>
@@ -304,7 +303,7 @@ void generic_shutdown_super(struct super_block *sb)
 
        if (sb->s_root) {
                shrink_dcache_for_umount(sb);
-               fsync_super(sb);
+               sync_filesystem(sb);
                lock_super(sb);
                sb->s_flags &= ~MS_ACTIVE;
 
@@ -543,7 +542,7 @@ int do_remount_sb(struct super_block *sb, int flags, void *data, int force)
        if (flags & MS_RDONLY)
                acct_auto_close(sb);
        shrink_dcache_sb(sb);
-       fsync_super(sb);
+       sync_filesystem(sb);
 
        /* If we are remounting RDONLY and current sb is read/write,
           make sure there are no rw files opened */

diff --git a/fs/sync.c b/fs/sync.c
index d5fa7b79982ed153245b6d5367b06cb13aa364c7..8aa870a4d406dcf837fec58cb944bf0266fb355e 100644 (file)
--- a/fs/sync.c
+++ b/fs/sync.c
@@ -25,7 +25,7 @@
  * case write_inode() functions do sync_dirty_buffer() and thus effectively
  * write one block at a time.
  */
-static int __fsync_super(struct super_block *sb, int wait)
+static int __sync_filesystem(struct super_block *sb, int wait)
 {
        vfs_dq_sync(sb);
        sync_inodes_sb(sb, wait);
@@ -43,16 +43,16 @@ static int __fsync_super(struct super_block *sb, int wait)
  * superblock.  Filesystem data as well as the underlying block
  * device.  Takes the superblock lock.
  */
-int fsync_super(struct super_block *sb)
+int sync_filesystem(struct super_block *sb)
 {
        int ret;
 
-       ret = __fsync_super(sb, 0);
+       ret = __sync_filesystem(sb, 0);
        if (ret < 0)
                return ret;
-       return __fsync_super(sb, 1);
+       return __sync_filesystem(sb, 1);
 }
-EXPORT_SYMBOL_GPL(fsync_super);
+EXPORT_SYMBOL_GPL(sync_filesystem);
 
 /*
  * Sync all the data for all the filesystems (called by sys_sync() and
@@ -92,7 +92,7 @@ restart:
                spin_unlock(&sb_lock);
                down_read(&sb->s_umount);
                if (sb->s_root)
-                       __fsync_super(sb, wait);
+                       __sync_filesystem(sb, wait);
                up_read(&sb->s_umount);
                /* restart only when sb is no longer on the list */
                spin_lock(&sb_lock);

diff --git a/include/linux/fs.h b/include/linux/fs.h
index d3f7159993cf79be471a0de96f9d71141f5e9ccb..fb1822bed7c85d5b075daf9b78f01dbb5b8757ef 100644 (file)
--- a/include/linux/fs.h
+++ b/include/linux/fs.h
@@ -1958,7 +1958,7 @@ static inline int thaw_bdev(struct block_device *bdev, struct super_block *sb)
        return 0;
 }
 #endif
-extern int fsync_super(struct super_block *);
+extern int sync_filesystem(struct super_block *);
 extern const struct file_operations def_blk_fops;
 extern const struct file_operations def_chr_fops;
 extern const struct file_operations bad_sock_fops;