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
Signed-off-by: Masayuki Hamaguchi
---
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 *);
--
To unsubscribe from this list: send the line "unsubscribe linux-kernel" in
the body of a message to majordomo@vger.kernel.org
More majordomo info at http://vger.kernel.org/majordomo-info.html
Please read the FAQ at http://www.tux.org/lkml/