xfs
[Top] [All Lists]

[PATCH 1/3] Add error handling of write_super_lockfs/unlockfs

To: Andrew Morton <akpm@xxxxxxxxxxxxxxxxxxxx>, Christoph Hellwig <hch@xxxxxxxxxxxxx>, "linux-fsdevel@xxxxxxxxxxxxxxx" <linux-fsdevel@xxxxxxxxxxxxxxx>, "dm-devel@xxxxxxxxxx" <dm-devel@xxxxxxxxxx>, "viro@xxxxxxxxxxxxxxxxxx" <viro@xxxxxxxxxxxxxxxxxx>, "linux-ext4@xxxxxxxxxxxxxxx" <linux-ext4@xxxxxxxxxxxxxxx>, "xfs@xxxxxxxxxxx" <xfs@xxxxxxxxxxx>, "mtk.manpages@xxxxxxxxxxxxxx" <mtk.manpages@xxxxxxxxxxxxxx>, "axboe@xxxxxxxxx" <axboe@xxxxxxxxx>
Subject: [PATCH 1/3] Add error handling of write_super_lockfs/unlockfs
From: Takashi Sato <t-sato@xxxxxxxxxxxxx>
Date: Mon, 27 Oct 2008 21:58:32 +0900
Cc: "linux-kernel@xxxxxxxxxxxxxxx" <linux-kernel@xxxxxxxxxxxxxxx>
VFS:
Changed the type of write_super_lockfs and unlockfs from "void"
to "int" so that they can return an error. 
Rename write_super_lockfs and unlockfs of the super block operation
freeze_fs and unfreeze_fs to avoid a confusion.

ext3, ext4, xfs, gfs2, jfs:
Changed the type of write_super_lockfs and unlockfs from "void"
to "int" so that write_super_lockfs returns an error if needed,
and unlockfs always returns 0.

reiserfs:
Changed the type of write_super_lockfs and unlockfs from "void"
to "int" so that they always return 0 (success) to keep a current behavior.

Signed-off-by: Takashi Sato <t-sato@xxxxxxxxxxxxx>
Signed-off-by: Masayuki Hamaguchi <m-hamaguchi@xxxxxxxxxxxxx>
---
 Documentation/filesystems/Locking |    8 +++---
 Documentation/filesystems/vfs.txt |    8 +++---
 fs/buffer.c                       |    8 +++---
 fs/ext3/super.c                   |   45 +++++++++++++++++++++++-------------
 fs/ext4/super.c                   |   47 +++++++++++++++++++++++++-------------
 fs/gfs2/ops_super.c               |   16 +++++++-----
 fs/jfs/super.c                    |   10 ++++----
 fs/reiserfs/super.c               |   10 ++++----
 fs/xfs/linux-2.6/xfs_super.c      |    8 +++---
 fs/xfs/xfs_fsops.c                |   11 +++++---
 fs/xfs/xfs_fsops.h                |    2 -
 include/linux/fs.h                |    4 +--
 12 files changed, 108 insertions(+), 69 deletions(-)

diff -uprN -X linux-2.6.28-rc2.org/Documentation/dontdiff 
linux-2.6.28-rc2.org/Documentation/filesystems/Locking linux-2
.6.28-rc2-lockfs/Documentation/filesystems/Locking
--- linux-2.6.28-rc2.org/Documentation/filesystems/Locking      2008-10-27 
04:13:29.000000000 +0900
+++ linux-2.6.28-rc2-lockfs/Documentation/filesystems/Locking   2008-10-27 
08:58:36.000000000 +0900
@@ -97,8 +97,8 @@ prototypes:
        void (*put_super) (struct super_block *);
        void (*write_super) (struct super_block *);
        int (*sync_fs)(struct super_block *sb, int wait);
-       void (*write_super_lockfs) (struct super_block *);
-       void (*unlockfs) (struct super_block *);
+       int (*freeze_fs) (struct super_block *);
+       int (*unfreeze_fs) (struct super_block *);
        int (*statfs) (struct dentry *, struct kstatfs *);
        int (*remount_fs) (struct super_block *, int *, char *);
        void (*clear_inode) (struct inode *);
@@ -119,8 +119,8 @@ delete_inode:               no
 put_super:             yes     yes     no
 write_super:           no      yes     read
 sync_fs:               no      no      read
-write_super_lockfs:    ?
-unlockfs:              ?
+freeze_fs:             ?
+unfreeze_fs:           ?
 statfs:                        no      no      no
 remount_fs:            yes     yes     maybe           (see below)
 clear_inode:           no
diff -uprN -X linux-2.6.28-rc2.org/Documentation/dontdiff 
linux-2.6.28-rc2.org/Documentation/filesystems/vfs.txt linux-2
.6.28-rc2-lockfs/Documentation/filesystems/vfs.txt
--- linux-2.6.28-rc2.org/Documentation/filesystems/vfs.txt      2008-10-27 
04:13:29.000000000 +0900
+++ linux-2.6.28-rc2-lockfs/Documentation/filesystems/vfs.txt   2008-10-27 
08:58:36.000000000 +0900
@@ -210,8 +210,8 @@ struct super_operations {
         void (*put_super) (struct super_block *);
         void (*write_super) (struct super_block *);
         int (*sync_fs)(struct super_block *sb, int wait);
-        void (*write_super_lockfs) (struct super_block *);
-        void (*unlockfs) (struct super_block *);
+        int (*freeze_fs) (struct super_block *);
+        int (*unfreeze_fs) (struct super_block *);
         int (*statfs) (struct dentry *, struct kstatfs *);
         int (*remount_fs) (struct super_block *, int *, char *);
         void (*clear_inode) (struct inode *);
@@ -270,11 +270,11 @@ or bottom half).
        a superblock. The second parameter indicates whether the method
        should wait until the write out has been completed. Optional.
 
-  write_super_lockfs: called when VFS is locking a filesystem and
+  freeze_fs: called when VFS is locking a filesystem and
        forcing it into a consistent state.  This method is currently
        used by the Logical Volume Manager (LVM).
 
-  unlockfs: called when VFS is unlocking a filesystem and making it writable
+  unfreeze_fs: called when VFS is unlocking a filesystem and making it writable
        again.
 
   statfs: called when the VFS needs to get filesystem statistics. This
diff -uprN -X linux-2.6.28-rc2.org/Documentation/dontdiff 
linux-2.6.28-rc2.org/fs/buffer.c linux-2.6.28-rc2-lockfs/fs/bu
ffer.c
--- linux-2.6.28-rc2.org/fs/buffer.c    2008-10-27 04:13:29.000000000 +0900
+++ linux-2.6.28-rc2-lockfs/fs/buffer.c 2008-10-27 08:58:36.000000000 +0900
@@ -213,8 +213,8 @@ struct super_block *freeze_bdev(struct b
 
                sync_blockdev(sb->s_bdev);
 
-               if (sb->s_op->write_super_lockfs)
-                       sb->s_op->write_super_lockfs(sb);
+               if (sb->s_op->freeze_fs)
+                       sb->s_op->freeze_fs(sb);
        }
 
        sync_blockdev(bdev);
@@ -234,8 +234,8 @@ void thaw_bdev(struct block_device *bdev
        if (sb) {
                BUG_ON(sb->s_bdev != bdev);
 
-               if (sb->s_op->unlockfs)
-                       sb->s_op->unlockfs(sb);
+               if (sb->s_op->unfreeze_fs)
+                       sb->s_op->unfreeze_fs(sb);
                sb->s_frozen = SB_UNFROZEN;
                smp_wmb();
                wake_up(&sb->s_wait_unfrozen);
diff -uprN -X linux-2.6.28-rc2.org/Documentation/dontdiff 
linux-2.6.28-rc2.org/fs/ext3/super.c linux-2.6.28-rc2-lockfs/f
s/ext3/super.c
--- linux-2.6.28-rc2.org/fs/ext3/super.c        2008-10-27 04:13:29.000000000 
+0900
+++ linux-2.6.28-rc2-lockfs/fs/ext3/super.c     2008-10-27 09:27:57.000000000 
+0900
@@ -48,8 +48,8 @@ static int ext3_load_journal(struct supe
                             unsigned long journal_devnum);
 static int ext3_create_journal(struct super_block *, struct ext3_super_block *,
                               unsigned int);
-static void ext3_commit_super (struct super_block * sb,
-                              struct ext3_super_block * es,
+static int ext3_commit_super(struct super_block *sb,
+                              struct ext3_super_block *es,
                               int sync);
 static void ext3_mark_recovery_complete(struct super_block * sb,
                                        struct ext3_super_block * es);
@@ -60,9 +60,9 @@ static const char *ext3_decode_error(str
                                     char nbuf[16]);
 static int ext3_remount (struct super_block * sb, int * flags, char * data);
 static int ext3_statfs (struct dentry * dentry, struct kstatfs * buf);
-static void ext3_unlockfs(struct super_block *sb);
+static int ext3_unfreeze(struct super_block *sb);
 static void ext3_write_super (struct super_block * sb);
-static void ext3_write_super_lockfs(struct super_block *sb);
+static int ext3_freeze(struct super_block *sb);
 
 /*
  * Wrappers for journal_start/end.
@@ -732,8 +732,8 @@ static const struct super_operations ext
        .put_super      = ext3_put_super,
        .write_super    = ext3_write_super,
        .sync_fs        = ext3_sync_fs,
-       .write_super_lockfs = ext3_write_super_lockfs,
-       .unlockfs       = ext3_unlockfs,
+       .freeze_fs      = ext3_freeze,
+       .unfreeze_fs    = ext3_unfreeze,
        .statfs         = ext3_statfs,
        .remount_fs     = ext3_remount,
        .clear_inode    = ext3_clear_inode,
@@ -2268,21 +2268,23 @@ static int ext3_create_journal(struct su
        return 0;
 }
 
-static void ext3_commit_super (struct super_block * sb,
-                              struct ext3_super_block * es,
+static int ext3_commit_super(struct super_block *sb,
+                              struct ext3_super_block *es,
                               int sync)
 {
        struct buffer_head *sbh = EXT3_SB(sb)->s_sbh;
+       int error = 0;
 
        if (!sbh)
-               return;
+               return error;
        es->s_wtime = cpu_to_le32(get_seconds());
        es->s_free_blocks_count = cpu_to_le32(ext3_count_free_blocks(sb));
        es->s_free_inodes_count = cpu_to_le32(ext3_count_free_inodes(sb));
        BUFFER_TRACE(sbh, "marking dirty");
        mark_buffer_dirty(sbh);
        if (sync)
-               sync_dirty_buffer(sbh);
+               error = sync_dirty_buffer(sbh);
+       return error;
 }
 
 
@@ -2400,12 +2402,14 @@ static int ext3_sync_fs(struct super_blo
  * LVM calls this function before a (read-only) snapshot is created.  This
  * gives us a chance to flush the journal completely and mark the fs clean.
  */
-static void ext3_write_super_lockfs(struct super_block *sb)
+static int ext3_freeze(struct super_block *sb)
 {
+       int error = 0;
+       journal_t *journal;
        sb->s_dirt = 0;
 
        if (!(sb->s_flags & MS_RDONLY)) {
-               journal_t *journal = EXT3_SB(sb)->s_journal;
+               journal = EXT3_SB(sb)->s_journal;
 
                /* Now we set up the journal barrier. */
                journal_lock_updates(journal);
@@ -2414,20 +2418,28 @@ static void ext3_write_super_lockfs(stru
                 * We don't want to clear needs_recovery flag when we failed
                 * to flush the journal.
                 */
-               if (journal_flush(journal) < 0)
-                       return;
+               error = journal_flush(journal);
+               if (error < 0)
+                       goto out;
 
                /* Journal blocked and flushed, clear needs_recovery flag. */
                EXT3_CLEAR_INCOMPAT_FEATURE(sb, EXT3_FEATURE_INCOMPAT_RECOVER);
-               ext3_commit_super(sb, EXT3_SB(sb)->s_es, 1);
+               error = ext3_commit_super(sb, EXT3_SB(sb)->s_es, 1);
+               if (error)
+                       goto out;
        }
+       return 0;
+
+out:
+       journal_unlock_updates(journal);
+       return error;
 }
 
 /*
  * Called by LVM after the snapshot is done.  We need to reset the RECOVER
  * flag here, even though the filesystem is not technically dirty yet.
  */
-static void ext3_unlockfs(struct super_block *sb)
+static int ext3_unfreeze(struct super_block *sb)
 {
        if (!(sb->s_flags & MS_RDONLY)) {
                lock_super(sb);
@@ -2437,6 +2449,7 @@ static void ext3_unlockfs(struct super_b
                unlock_super(sb);
                journal_unlock_updates(EXT3_SB(sb)->s_journal);
        }
+       return 0;
 }
 
 static int ext3_remount (struct super_block * sb, int * flags, char * data)
diff -uprN -X linux-2.6.28-rc2.org/Documentation/dontdiff 
linux-2.6.28-rc2.org/fs/ext4/super.c linux-2.6.28-rc2-lockfs/f
s/ext4/super.c
--- linux-2.6.28-rc2.org/fs/ext4/super.c        2008-10-27 04:13:29.000000000 
+0900
+++ linux-2.6.28-rc2-lockfs/fs/ext4/super.c     2008-10-27 09:56:11.000000000 
+0900
@@ -53,7 +53,7 @@ static int ext4_load_journal(struct supe
                             unsigned long journal_devnum);
 static int ext4_create_journal(struct super_block *, struct ext4_super_block *,
                               unsigned int);
-static void ext4_commit_super(struct super_block *sb,
+static int ext4_commit_super(struct super_block *sb,
                              struct ext4_super_block *es, int sync);
 static void ext4_mark_recovery_complete(struct super_block *sb,
                                        struct ext4_super_block *es);
@@ -64,9 +64,9 @@ static const char *ext4_decode_error(str
                                     char nbuf[16]);
 static int ext4_remount(struct super_block *sb, int *flags, char *data);
 static int ext4_statfs(struct dentry *dentry, struct kstatfs *buf);
-static void ext4_unlockfs(struct super_block *sb);
+static int ext4_unfreeze(struct super_block *sb);
 static void ext4_write_super(struct super_block *sb);
-static void ext4_write_super_lockfs(struct super_block *sb);
+static int ext4_freeze(struct super_block *sb);
 
 
 ext4_fsblk_t ext4_block_bitmap(struct super_block *sb,
@@ -823,8 +823,8 @@ static const struct super_operations ext
        .put_super      = ext4_put_super,
        .write_super    = ext4_write_super,
        .sync_fs        = ext4_sync_fs,
-       .write_super_lockfs = ext4_write_super_lockfs,
-       .unlockfs       = ext4_unlockfs,
+       .freeze_fs      = ext4_freeze,
+       .unfreeze_fs    = ext4_unfreeze,
        .statfs         = ext4_statfs,
        .remount_fs     = ext4_remount,
        .clear_inode    = ext4_clear_inode,
@@ -2759,13 +2759,14 @@ static int ext4_create_journal(struct su
        return 0;
 }
 
-static void ext4_commit_super(struct super_block *sb,
+static int ext4_commit_super(struct super_block *sb,
                              struct ext4_super_block *es, int sync)
 {
        struct buffer_head *sbh = EXT4_SB(sb)->s_sbh;
+       int error = 0;
 
        if (!sbh)
-               return;
+               return error;
        if (buffer_write_io_error(sbh)) {
                /*
                 * Oh, dear.  A previous attempt to write the
@@ -2786,14 +2787,19 @@ static void ext4_commit_super(struct sup
        BUFFER_TRACE(sbh, "marking dirty");
        mark_buffer_dirty(sbh);
        if (sync) {
-               sync_dirty_buffer(sbh);
-               if (buffer_write_io_error(sbh)) {
+               error = sync_dirty_buffer(sbh);
+               if (error)
+                       return error;
+
+               error = buffer_write_io_error(sbh);
+               if (error) {
                        printk(KERN_ERR "ext4: I/O error while writing "
                               "superblock for %s.\n", sb->s_id);
                        clear_buffer_write_io_error(sbh);
                        set_buffer_uptodate(sbh);
                }
        }
+       return error;
 }
 
 
@@ -2912,12 +2918,14 @@ static int ext4_sync_fs(struct super_blo
  * LVM calls this function before a (read-only) snapshot is created.  This
  * gives us a chance to flush the journal completely and mark the fs clean.
  */
-static void ext4_write_super_lockfs(struct super_block *sb)
+static int ext4_freeze(struct super_block *sb)
 {
+       int error = 0;
+       journal_t *journal;
        sb->s_dirt = 0;
 
        if (!(sb->s_flags & MS_RDONLY)) {
-               journal_t *journal = EXT4_SB(sb)->s_journal;
+               journal = EXT4_SB(sb)->s_journal;
 
                /* Now we set up the journal barrier. */
                jbd2_journal_lock_updates(journal);
@@ -2926,20 +2934,28 @@ static void ext4_write_super_lockfs(stru
                 * We don't want to clear needs_recovery flag when we failed
                 * to flush the journal.
                 */
-               if (jbd2_journal_flush(journal) < 0)
-                       return;
+               error = jbd2_journal_flush(journal);
+               if (error < 0)
+                       goto out;
 
                /* Journal blocked and flushed, clear needs_recovery flag. */
                EXT4_CLEAR_INCOMPAT_FEATURE(sb, EXT4_FEATURE_INCOMPAT_RECOVER);
-               ext4_commit_super(sb, EXT4_SB(sb)->s_es, 1);
+               error = ext4_commit_super(sb, EXT4_SB(sb)->s_es, 1);
+               if (error)
+                       goto out;
        }
+       return 0;
+
+out:
+       jbd2_journal_unlock_updates(journal);
+       return error;
 }
 
 /*
  * Called by LVM after the snapshot is done.  We need to reset the RECOVER
  * flag here, even though the filesystem is not technically dirty yet.
  */
-static void ext4_unlockfs(struct super_block *sb)
+static int ext4_unfreeze(struct super_block *sb)
 {
        if (!(sb->s_flags & MS_RDONLY)) {
                lock_super(sb);
@@ -2949,6 +2965,7 @@ static void ext4_unlockfs(struct super_b
                unlock_super(sb);
                jbd2_journal_unlock_updates(EXT4_SB(sb)->s_journal);
        }
+       return 0;
 }
 
 static int ext4_remount(struct super_block *sb, int *flags, char *data)
diff -uprN -X linux-2.6.28-rc2.org/Documentation/dontdiff 
linux-2.6.28-rc2.org/fs/gfs2/ops_super.c linux-2.6.28-rc2-lock
fs/fs/gfs2/ops_super.c
--- linux-2.6.28-rc2.org/fs/gfs2/ops_super.c    2008-10-27 04:13:29.000000000 
+0900
+++ linux-2.6.28-rc2-lockfs/fs/gfs2/ops_super.c 2008-10-27 08:58:36.000000000 
+0900
@@ -215,18 +215,18 @@ static int gfs2_sync_fs(struct super_blo
 }
 
 /**
- * gfs2_write_super_lockfs - prevent further writes to the filesystem
+ * gfs2_freeze - prevent further writes to the filesystem
  * @sb: the VFS structure for the filesystem
  *
  */
 
-static void gfs2_write_super_lockfs(struct super_block *sb)
+static int gfs2_freeze(struct super_block *sb)
 {
        struct gfs2_sbd *sdp = sb->s_fs_info;
        int error;
 
        if (test_bit(SDF_SHUTDOWN, &sdp->sd_flags))
-               return;
+               return -EINVAL;
 
        for (;;) {
                error = gfs2_freeze_fs(sdp);
@@ -246,17 +246,19 @@ static void gfs2_write_super_lockfs(stru
                fs_err(sdp, "retrying...\n");
                msleep(1000);
        }
+       return 0;
 }
 
 /**
- * gfs2_unlockfs - reallow writes to the filesystem
+ * gfs2_unfreeze - reallow writes to the filesystem
  * @sb: the VFS structure for the filesystem
  *
  */
 
-static void gfs2_unlockfs(struct super_block *sb)
+static int gfs2_unfreeze(struct super_block *sb)
 {
        gfs2_unfreeze_fs(sb->s_fs_info);
+       return 0;
 }
 
 /**
@@ -563,8 +565,8 @@ const struct super_operations gfs2_super
        .put_super              = gfs2_put_super,
        .write_super            = gfs2_write_super,
        .sync_fs                = gfs2_sync_fs,
-       .write_super_lockfs     = gfs2_write_super_lockfs,
-       .unlockfs               = gfs2_unlockfs,
+       .freeze_fs              = gfs2_freeze,
+       .unfreeze_fs            = gfs2_unfreeze,
        .statfs                 = gfs2_statfs,
        .remount_fs             = gfs2_remount_fs,
        .clear_inode            = gfs2_clear_inode,
diff -uprN -X linux-2.6.28-rc2.org/Documentation/dontdiff 
linux-2.6.28-rc2.org/fs/jfs/super.c linux-2.6.28-rc2-lockfs/fs
/jfs/super.c
--- linux-2.6.28-rc2.org/fs/jfs/super.c 2008-10-27 04:13:29.000000000 +0900
+++ linux-2.6.28-rc2-lockfs/fs/jfs/super.c      2008-10-27 08:58:36.000000000 
+0900
@@ -543,7 +543,7 @@ out_kfree:
        return ret;
 }
 
-static void jfs_write_super_lockfs(struct super_block *sb)
+static int jfs_freeze(struct super_block *sb)
 {
        struct jfs_sb_info *sbi = JFS_SBI(sb);
        struct jfs_log *log = sbi->log;
@@ -553,9 +553,10 @@ static void jfs_write_super_lockfs(struc
                lmLogShutdown(log);
                updateSuper(sb, FM_CLEAN);
        }
+       return 0;
 }
 
-static void jfs_unlockfs(struct super_block *sb)
+static int jfs_unfreeze(struct super_block *sb)
 {
        struct jfs_sb_info *sbi = JFS_SBI(sb);
        struct jfs_log *log = sbi->log;
@@ -568,6 +569,7 @@ static void jfs_unlockfs(struct super_bl
                else
                        txResume(sb);
        }
+       return 0;
 }
 
 static int jfs_get_sb(struct file_system_type *fs_type,
@@ -735,8 +737,8 @@ static const struct super_operations jfs
        .delete_inode   = jfs_delete_inode,
        .put_super      = jfs_put_super,
        .sync_fs        = jfs_sync_fs,
-       .write_super_lockfs = jfs_write_super_lockfs,
-       .unlockfs       = jfs_unlockfs,
+       .freeze_fs      = jfs_freeze,
+       .unfreeze_fs    = jfs_unfreeze,
        .statfs         = jfs_statfs,
        .remount_fs     = jfs_remount,
        .show_options   = jfs_show_options,
diff -uprN -X linux-2.6.28-rc2.org/Documentation/dontdiff 
linux-2.6.28-rc2.org/fs/reiserfs/super.c linux-2.6.28-rc2-lock
fs/fs/reiserfs/super.c
--- linux-2.6.28-rc2.org/fs/reiserfs/super.c    2008-10-27 04:13:29.000000000 
+0900
+++ linux-2.6.28-rc2-lockfs/fs/reiserfs/super.c 2008-10-27 08:58:36.000000000 
+0900
@@ -83,7 +83,7 @@ static void reiserfs_write_super(struct 
        reiserfs_sync_fs(s, 1);
 }
 
-static void reiserfs_write_super_lockfs(struct super_block *s)
+static int reiserfs_freeze(struct super_block *s)
 {
        struct reiserfs_transaction_handle th;
        reiserfs_write_lock(s);
@@ -101,11 +101,13 @@ static void reiserfs_write_super_lockfs(
        }
        s->s_dirt = 0;
        reiserfs_write_unlock(s);
+       return 0;
 }
 
-static void reiserfs_unlockfs(struct super_block *s)
+static int reiserfs_unfreeze(struct super_block *s)
 {
        reiserfs_allow_writes(s);
+       return 0;
 }
 
 extern const struct in_core_key MAX_IN_CORE_KEY;
@@ -613,8 +615,8 @@ static const struct super_operations rei
        .put_super = reiserfs_put_super,
        .write_super = reiserfs_write_super,
        .sync_fs = reiserfs_sync_fs,
-       .write_super_lockfs = reiserfs_write_super_lockfs,
-       .unlockfs = reiserfs_unlockfs,
+       .freeze_fs = reiserfs_freeze,
+       .unfreeze_fs = reiserfs_unfreeze,
        .statfs = reiserfs_statfs,
        .remount_fs = reiserfs_remount,
        .show_options = generic_show_options,
diff -uprN -X linux-2.6.28-rc2.org/Documentation/dontdiff 
linux-2.6.28-rc2.org/fs/xfs/linux-2.6/xfs_super.c linux-2.6.28
-rc2-lockfs/fs/xfs/linux-2.6/xfs_super.c
--- linux-2.6.28-rc2.org/fs/xfs/linux-2.6/xfs_super.c   2008-10-27 
04:13:29.000000000 +0900
+++ linux-2.6.28-rc2-lockfs/fs/xfs/linux-2.6/xfs_super.c        2008-10-27 
08:58:36.000000000 +0900
@@ -1351,14 +1351,14 @@ xfs_fs_remount(
  * need to take care of themetadata. Once that's done write a dummy
  * record to dirty the log in case of a crash while frozen.
  */
-STATIC void
-xfs_fs_lockfs(
+STATIC int
+xfs_fs_freeze(
        struct super_block      *sb)
 {
        struct xfs_mount        *mp = XFS_M(sb);
 
        xfs_attr_quiesce(mp);
-       xfs_fs_log_dummy(mp);
+       return -xfs_fs_log_dummy(mp);
 }
 
 STATIC int
@@ -1847,7 +1847,7 @@ static struct super_operations xfs_super
        .put_super              = xfs_fs_put_super,
        .write_super            = xfs_fs_write_super,
        .sync_fs                = xfs_fs_sync_super,
-       .write_super_lockfs     = xfs_fs_lockfs,
+       .freeze_fs              = xfs_fs_freeze,
        .statfs                 = xfs_fs_statfs,
        .remount_fs             = xfs_fs_remount,
        .show_options           = xfs_fs_show_options,
diff -uprN -X linux-2.6.28-rc2.org/Documentation/dontdiff 
linux-2.6.28-rc2.org/fs/xfs/xfs_fsops.c linux-2.6.28-rc2-lockf
s/fs/xfs/xfs_fsops.c
--- linux-2.6.28-rc2.org/fs/xfs/xfs_fsops.c     2008-10-27 04:13:29.000000000 
+0900
+++ linux-2.6.28-rc2-lockfs/fs/xfs/xfs_fsops.c  2008-10-27 08:58:36.000000000 
+0900
@@ -589,17 +589,19 @@ out:
        return 0;
 }
 
-void
+int
 xfs_fs_log_dummy(
        xfs_mount_t     *mp)
 {
        xfs_trans_t     *tp;
        xfs_inode_t     *ip;
+       int             error;
 
        tp = _xfs_trans_alloc(mp, XFS_TRANS_DUMMY1);
-       if (xfs_trans_reserve(tp, 0, XFS_ICHANGE_LOG_RES(mp), 0, 0, 0)) {
+       error = xfs_trans_reserve(tp, 0, XFS_ICHANGE_LOG_RES(mp), 0, 0, 0);
+       if (error) {
                xfs_trans_cancel(tp, 0);
-               return;
+               return error;
        }
 
        ip = mp->m_rootip;
@@ -609,9 +611,10 @@ xfs_fs_log_dummy(
        xfs_trans_ihold(tp, ip);
        xfs_trans_log_inode(tp, ip, XFS_ILOG_CORE);
        xfs_trans_set_sync(tp);
-       xfs_trans_commit(tp, 0);
+       error = xfs_trans_commit(tp, 0);
 
        xfs_iunlock(ip, XFS_ILOCK_EXCL);
+       return error;
 }
 
 int
diff -uprN -X linux-2.6.28-rc2.org/Documentation/dontdiff 
linux-2.6.28-rc2.org/fs/xfs/xfs_fsops.h linux-2.6.28-rc2-lockf
s/fs/xfs/xfs_fsops.h
--- linux-2.6.28-rc2.org/fs/xfs/xfs_fsops.h     2008-10-27 04:13:29.000000000 
+0900
+++ linux-2.6.28-rc2-lockfs/fs/xfs/xfs_fsops.h  2008-10-27 08:58:36.000000000 
+0900
@@ -25,6 +25,6 @@ extern int xfs_fs_counts(xfs_mount_t *mp
 extern int xfs_reserve_blocks(xfs_mount_t *mp, __uint64_t *inval,
                                xfs_fsop_resblks_t *outval);
 extern int xfs_fs_goingdown(xfs_mount_t *mp, __uint32_t inflags);
-extern void xfs_fs_log_dummy(xfs_mount_t *mp);
+extern int xfs_fs_log_dummy(xfs_mount_t *mp);
 
 #endif /* __XFS_FSOPS_H__ */
diff -uprN -X linux-2.6.28-rc2.org/Documentation/dontdiff 
linux-2.6.28-rc2.org/include/linux/fs.h linux-2.6.28-rc2-lockf
s/include/linux/fs.h
--- linux-2.6.28-rc2.org/include/linux/fs.h     2008-10-27 04:13:29.000000000 
+0900
+++ linux-2.6.28-rc2-lockfs/include/linux/fs.h  2008-10-27 08:58:36.000000000 
+0900
@@ -1368,8 +1368,8 @@ struct super_operations {
        void (*put_super) (struct super_block *);
        void (*write_super) (struct super_block *);
        int (*sync_fs)(struct super_block *sb, int wait);
-       void (*write_super_lockfs) (struct super_block *);
-       void (*unlockfs) (struct super_block *);
+       int (*freeze_fs) (struct super_block *);
+       int (*unfreeze_fs) (struct super_block *);
        int (*statfs) (struct dentry *, struct kstatfs *);
        int (*remount_fs) (struct super_block *, int *, char *);
        void (*clear_inode) (struct inode *);

<Prev in Thread] Current Thread [Next in Thread>