11 files changed, 173 insertions, 149 deletions

diff --git a/fs/xfs/linux-2.6/xfs_aops.c b/fs/xfs/linux-2.6/xfs_aops.c
index aecf2519db76..c2e30eea74dc 100644
--- a/fs/xfs/linux-2.6/xfs_aops.c
+++ b/fs/xfs/linux-2.6/xfs_aops.c
@@ -186,19 +186,37 @@ xfs_destroy_ioend(
 }
 
 /*
+ * If the end of the current ioend is beyond the current EOF,
+ * return the new EOF value, otherwise zero.
+ */
+STATIC xfs_fsize_t
+xfs_ioend_new_eof(
+        xfs_ioend_t             *ioend)
+{
+        xfs_inode_t             *ip = XFS_I(ioend->io_inode);
+        xfs_fsize_t             isize;
+        xfs_fsize_t             bsize;
+
+        bsize = ioend->io_offset + ioend->io_size;
+        isize = MAX(ip->i_size, ip->i_new_size);
+        isize = MIN(isize, bsize);
+        return isize > ip->i_d.di_size ? isize : 0;
+}
+
+/*
  * Update on-disk file size now that data has been written to disk.
  * The current in-memory file size is i_size.  If a write is beyond
  * eof i_new_size will be the intended file size until i_size is
  * updated.  If this write does not extend all the way to the valid
  * file size then restrict this update to the end of the write.
  */
+
 STATIC void
 xfs_setfilesize(
         xfs_ioend_t             *ioend)
 {
         xfs_inode_t             *ip = XFS_I(ioend->io_inode);
         xfs_fsize_t             isize;
-        xfs_fsize_t             bsize;
 
         ASSERT((ip->i_d.di_mode & S_IFMT) == S_IFREG);
         ASSERT(ioend->io_type != IOMAP_READ);
@@ -206,17 +224,10 @@ xfs_setfilesize(
         if (unlikely(ioend->io_error))
                 return;
 
-        bsize = ioend->io_offset + ioend->io_size;
-
         xfs_ilock(ip, XFS_ILOCK_EXCL);
-
-        isize = MAX(ip->i_size, ip->i_new_size);
-        isize = MIN(isize, bsize);
-
-        if (ip->i_d.di_size < isize) {
+        isize = xfs_ioend_new_eof(ioend);
+        if (isize) {
                 ip->i_d.di_size = isize;
-                ip->i_update_core = 1;
-                ip->i_update_size = 1;
                 xfs_mark_inode_dirty_sync(ip);
         }
 
@@ -405,10 +416,16 @@ xfs_submit_ioend_bio(
         struct bio      *bio)
 {
         atomic_inc(&ioend->io_remaining);
-
         bio->bi_private = ioend;
         bio->bi_end_io = xfs_end_bio;
 
+        /*
+         * If the I/O is beyond EOF we mark the inode dirty immediately
+         * but don't update the inode size until I/O completion.
+         */
+        if (xfs_ioend_new_eof(ioend))
+                xfs_mark_inode_dirty_sync(XFS_I(ioend->io_inode));
+
         submit_bio(WRITE, bio);
         ASSERT(!bio_flagged(bio, BIO_EOPNOTSUPP));
         bio_put(bio);
@@ -1636,4 +1653,5 @@ const struct address_space_operations xfs_address_space_operations = {
         .direct_IO              = xfs_vm_direct_IO,
         .migratepage            = buffer_migrate_page,
         .is_partially_uptodate  = block_is_partially_uptodate,
+        .error_remove_page      = generic_error_remove_page,
 };
diff --git a/fs/xfs/linux-2.6/xfs_file.c b/fs/xfs/linux-2.6/xfs_file.c
index 0542fd507649..eff61e2732af 100644
--- a/fs/xfs/linux-2.6/xfs_file.c
+++ b/fs/xfs/linux-2.6/xfs_file.c
@@ -42,7 +42,7 @@
 
 #include <linux/dcache.h>
 
-static struct vm_operations_struct xfs_file_vm_ops;
+static const struct vm_operations_struct xfs_file_vm_ops;
 
 STATIC ssize_t
 xfs_file_aio_read(
@@ -172,12 +172,14 @@ xfs_file_release(
  */
 STATIC int
 xfs_file_fsync(
-        struct file     *filp,
-        struct dentry   *dentry,
-        int             datasync)
+        struct file             *file,
+        struct dentry           *dentry,
+        int                     datasync)
 {
-        xfs_iflags_clear(XFS_I(dentry->d_inode), XFS_ITRUNCATED);
-        return -xfs_fsync(XFS_I(dentry->d_inode));
+        struct xfs_inode        *ip = XFS_I(dentry->d_inode);
+
+        xfs_iflags_clear(ip, XFS_ITRUNCATED);
+        return -xfs_fsync(ip);
 }
 
 STATIC int
@@ -271,7 +273,7 @@ const struct file_operations xfs_dir_file_operations = {
         .fsync          = xfs_file_fsync,
 };
 
-static struct vm_operations_struct xfs_file_vm_ops = {
+static const struct vm_operations_struct xfs_file_vm_ops = {
         .fault          = filemap_fault,
         .page_mkwrite   = xfs_vm_page_mkwrite,
 };
diff --git a/fs/xfs/linux-2.6/xfs_iops.c b/fs/xfs/linux-2.6/xfs_iops.c
index 8070b34cc287..cd42ef78f6b5 100644
--- a/fs/xfs/linux-2.6/xfs_iops.c
+++ b/fs/xfs/linux-2.6/xfs_iops.c
@@ -43,7 +43,6 @@
 #include "xfs_error.h"
 #include "xfs_itable.h"
 #include "xfs_rw.h"
-#include "xfs_acl.h"
 #include "xfs_attr.h"
 #include "xfs_buf_item.h"
 #include "xfs_utils.h"
@@ -58,19 +57,22 @@
 #include <linux/fiemap.h>
 
 /*
- * Bring the atime in the XFS inode uptodate.
- * Used before logging the inode to disk or when the Linux inode goes away.
+ * Bring the timestamps in the XFS inode uptodate.
+ *
+ * Used before writing the inode to disk.
  */
 void
-xfs_synchronize_atime(
+xfs_synchronize_times(
         xfs_inode_t     *ip)
 {
         struct inode    *inode = VFS_I(ip);
 
-        if (!(inode->i_state & I_CLEAR)) {
-                ip->i_d.di_atime.t_sec = (__int32_t)inode->i_atime.tv_sec;
-                ip->i_d.di_atime.t_nsec = (__int32_t)inode->i_atime.tv_nsec;
-        }
+        ip->i_d.di_atime.t_sec = (__int32_t)inode->i_atime.tv_sec;
+        ip->i_d.di_atime.t_nsec = (__int32_t)inode->i_atime.tv_nsec;
+        ip->i_d.di_ctime.t_sec = (__int32_t)inode->i_ctime.tv_sec;
+        ip->i_d.di_ctime.t_nsec = (__int32_t)inode->i_ctime.tv_nsec;
+        ip->i_d.di_mtime.t_sec = (__int32_t)inode->i_mtime.tv_sec;
+        ip->i_d.di_mtime.t_nsec = (__int32_t)inode->i_mtime.tv_nsec;
 }
 
 /*
@@ -107,32 +109,20 @@ xfs_ichgtime(
         if ((flags & XFS_ICHGTIME_MOD) &&
             !timespec_equal(&inode->i_mtime, &tv)) {
                 inode->i_mtime = tv;
-                ip->i_d.di_mtime.t_sec = (__int32_t)tv.tv_sec;
-                ip->i_d.di_mtime.t_nsec = (__int32_t)tv.tv_nsec;
                 sync_it = 1;
         }
         if ((flags & XFS_ICHGTIME_CHG) &&
             !timespec_equal(&inode->i_ctime, &tv)) {
                 inode->i_ctime = tv;
-                ip->i_d.di_ctime.t_sec = (__int32_t)tv.tv_sec;
-                ip->i_d.di_ctime.t_nsec = (__int32_t)tv.tv_nsec;
                 sync_it = 1;
         }
 
         /*
-         * We update the i_update_core field _after_ changing
-         * the timestamps in order to coordinate properly with
-         * xfs_iflush() so that we don't lose timestamp updates.
-         * This keeps us from having to hold the inode lock
-         * while doing this.  We use the SYNCHRONIZE macro to
-         * ensure that the compiler does not reorder the update
-         * of i_update_core above the timestamp updates above.
+         * Update complete - now make sure everyone knows that the inode
+         * is dirty.
          */
-        if (sync_it) {
-                SYNCHRONIZE();
-                ip->i_update_core = 1;
+        if (sync_it)
                 xfs_mark_inode_dirty_sync(ip);
-        }
 }
 
 /*
@@ -485,14 +475,6 @@ xfs_vn_put_link(
 }
 
 STATIC int
-xfs_vn_permission(
-        struct inode            *inode,
-        int                     mask)
-{
-        return generic_permission(inode, mask, xfs_check_acl);
-}
-
-STATIC int
 xfs_vn_getattr(
         struct vfsmount         *mnt,
         struct dentry           *dentry,
@@ -515,10 +497,8 @@ xfs_vn_getattr(
         stat->gid = ip->i_d.di_gid;
         stat->ino = ip->i_ino;
         stat->atime = inode->i_atime;
-        stat->mtime.tv_sec = ip->i_d.di_mtime.t_sec;
-        stat->mtime.tv_nsec = ip->i_d.di_mtime.t_nsec;
-        stat->ctime.tv_sec = ip->i_d.di_ctime.t_sec;
-        stat->ctime.tv_nsec = ip->i_d.di_ctime.t_nsec;
+        stat->mtime = inode->i_mtime;
+        stat->ctime = inode->i_ctime;
         stat->blocks =
                 XFS_FSB_TO_BB(mp, ip->i_d.di_nblocks + ip->i_delayed_blks);
 
@@ -696,7 +676,7 @@ xfs_vn_fiemap(
 }
 
 static const struct inode_operations xfs_inode_operations = {
-        .permission             = xfs_vn_permission,
+        .check_acl              = xfs_check_acl,
         .truncate               = xfs_vn_truncate,
         .getattr                = xfs_vn_getattr,
         .setattr                = xfs_vn_setattr,
@@ -724,7 +704,7 @@ static const struct inode_operations xfs_dir_inode_operations = {
         .rmdir                  = xfs_vn_unlink,
         .mknod                  = xfs_vn_mknod,
         .rename                 = xfs_vn_rename,
-        .permission             = xfs_vn_permission,
+        .check_acl              = xfs_check_acl,
         .getattr                = xfs_vn_getattr,
         .setattr                = xfs_vn_setattr,
         .setxattr               = generic_setxattr,
@@ -749,7 +729,7 @@ static const struct inode_operations xfs_dir_ci_inode_operations = {
         .rmdir                  = xfs_vn_unlink,
         .mknod                  = xfs_vn_mknod,
         .rename                 = xfs_vn_rename,
-        .permission             = xfs_vn_permission,
+        .check_acl              = xfs_check_acl,
         .getattr                = xfs_vn_getattr,
         .setattr                = xfs_vn_setattr,
         .setxattr               = generic_setxattr,
@@ -762,7 +742,7 @@ static const struct inode_operations xfs_symlink_inode_operations = {
         .readlink               = generic_readlink,
         .follow_link            = xfs_vn_follow_link,
         .put_link               = xfs_vn_put_link,
-        .permission             = xfs_vn_permission,
+        .check_acl              = xfs_check_acl,
         .getattr                = xfs_vn_getattr,
         .setattr                = xfs_vn_setattr,
         .setxattr               = generic_setxattr,
diff --git a/fs/xfs/linux-2.6/xfs_lrw.c b/fs/xfs/linux-2.6/xfs_lrw.c
index 7078974a6eee..072050f8d346 100644
--- a/fs/xfs/linux-2.6/xfs_lrw.c
+++ b/fs/xfs/linux-2.6/xfs_lrw.c
@@ -667,7 +667,7 @@ start:
                 xip->i_new_size = new_size;
 
         if (likely(!(ioflags & IO_INVIS)))
-                xfs_ichgtime(xip, XFS_ICHGTIME_MOD | XFS_ICHGTIME_CHG);
+                file_update_time(file);
 
         /*
          * If the offset is beyond the size of the file, we have a couple
@@ -812,18 +812,21 @@ write_retry:
 
         /* Handle various SYNC-type writes */
         if ((file->f_flags & O_SYNC) || IS_SYNC(inode)) {
+                loff_t end = pos + ret - 1;
                 int error2;
 
                 xfs_iunlock(xip, iolock);
                 if (need_i_mutex)
                         mutex_unlock(&inode->i_mutex);
-                error2 = sync_page_range(inode, mapping, pos, ret);
+
+                error2 = filemap_write_and_wait_range(mapping, pos, end);
                 if (!error)
                         error = error2;
                 if (need_i_mutex)
                         mutex_lock(&inode->i_mutex);
                 xfs_ilock(xip, iolock);
-                error2 = xfs_write_sync_logforce(mp, xip);
+
+                error2 = xfs_fsync(xip);
                 if (!error)
                         error = error2;
         }
diff --git a/fs/xfs/linux-2.6/xfs_quotaops.c b/fs/xfs/linux-2.6/xfs_quotaops.c
index cb6e2cca214f..3d4a0c84d634 100644
--- a/fs/xfs/linux-2.6/xfs_quotaops.c
+++ b/fs/xfs/linux-2.6/xfs_quotaops.c
@@ -80,7 +80,7 @@ xfs_fs_set_xstate(
 
         if (sb->s_flags & MS_RDONLY)
                 return -EROFS;
-        if (!XFS_IS_QUOTA_RUNNING(mp))
+        if (op != Q_XQUOTARM && !XFS_IS_QUOTA_RUNNING(mp))
                 return -ENOSYS;
         if (!capable(CAP_SYS_ADMIN))
                 return -EPERM;
@@ -150,7 +150,7 @@ xfs_fs_set_xquota(
         return -xfs_qm_scall_setqlim(mp, id, xfs_quota_type(type), fdq);
 }
 
-struct quotactl_ops xfs_quotactl_operations = {
+const struct quotactl_ops xfs_quotactl_operations = {
         .quota_sync             = xfs_fs_quota_sync,
         .get_xstate             = xfs_fs_get_xstate,
         .set_xstate             = xfs_fs_set_xstate,
diff --git a/fs/xfs/linux-2.6/xfs_stats.c b/fs/xfs/linux-2.6/xfs_stats.c
index c3526d445f6a..76fdc5861932 100644
--- a/fs/xfs/linux-2.6/xfs_stats.c
+++ b/fs/xfs/linux-2.6/xfs_stats.c
@@ -20,16 +20,9 @@
 
 DEFINE_PER_CPU(struct xfsstats, xfsstats);
 
-STATIC int
-xfs_read_xfsstats(
-        char            *buffer,
-        char            **start,
-        off_t           offset,
-        int             count,
-        int             *eof,
-        void            *data)
+static int xfs_stat_proc_show(struct seq_file *m, void *v)
 {
-        int             c, i, j, len, val;
+        int             c, i, j, val;
         __uint64_t      xs_xstrat_bytes = 0;
         __uint64_t      xs_write_bytes = 0;
         __uint64_t      xs_read_bytes = 0;
@@ -60,18 +53,18 @@ xfs_read_xfsstats(
         };
 
         /* Loop over all stats groups */
-        for (i=j=len = 0; i < ARRAY_SIZE(xstats); i++) {
-                len += sprintf(buffer + len, "%s", xstats[i].desc);
+        for (i=j = 0; i < ARRAY_SIZE(xstats); i++) {
+                seq_printf(m, "%s", xstats[i].desc);
                 /* inner loop does each group */
                 while (j < xstats[i].endpoint) {
                         val = 0;
                         /* sum over all cpus */
                         for_each_possible_cpu(c)
                                 val += *(((__u32*)&per_cpu(xfsstats, c) + j));
-                        len += sprintf(buffer + len, " %u", val);
+                        seq_printf(m, " %u", val);
                         j++;
                 }
-                buffer[len++] = '\n';
+                seq_putc(m, '\n');
         }
         /* extra precision counters */
         for_each_possible_cpu(i) {
@@ -80,36 +73,38 @@ xfs_read_xfsstats(
                 xs_read_bytes += per_cpu(xfsstats, i).xs_read_bytes;
         }
 
-        len += sprintf(buffer + len, "xpc %Lu %Lu %Lu\n",
+        seq_printf(m, "xpc %Lu %Lu %Lu\n",
                         xs_xstrat_bytes, xs_write_bytes, xs_read_bytes);
-        len += sprintf(buffer + len, "debug %u\n",
+        seq_printf(m, "debug %u\n",
 #if defined(DEBUG)
                 1);
 #else
                 0);
 #endif
+        return 0;
+}
 
-        if (offset >= len) {
-                *start = buffer;
-                *eof = 1;
-                return 0;
-        }
-        *start = buffer + offset;
-        if ((len -= offset) > count)
-                return count;
-        *eof = 1;
-
-        return len;
+static int xfs_stat_proc_open(struct inode *inode, struct file *file)
+{
+        return single_open(file, xfs_stat_proc_show, NULL);
 }
 
+static const struct file_operations xfs_stat_proc_fops = {
+        .owner          = THIS_MODULE,
+        .open           = xfs_stat_proc_open,
+        .read           = seq_read,
+        .llseek         = seq_lseek,
+        .release        = single_release,
+};
+
 int
 xfs_init_procfs(void)
 {
         if (!proc_mkdir("fs/xfs", NULL))
                 goto out;
 
-        if (!create_proc_read_entry("fs/xfs/stat", 0, NULL,
-                        xfs_read_xfsstats, NULL))
+        if (!proc_create("fs/xfs/stat", 0, NULL,
+                         &xfs_stat_proc_fops))
                 goto out_remove_entry;
         return 0;
 
diff --git a/fs/xfs/linux-2.6/xfs_super.c b/fs/xfs/linux-2.6/xfs_super.c
index a220d36f789b..18a4b8e11df2 100644
--- a/fs/xfs/linux-2.6/xfs_super.c
+++ b/fs/xfs/linux-2.6/xfs_super.c
@@ -67,7 +67,7 @@
 #include <linux/freezer.h>
 #include <linux/parser.h>
 
-static struct super_operations xfs_super_operations;
+static const struct super_operations xfs_super_operations;
 static kmem_zone_t *xfs_ioend_zone;
 mempool_t *xfs_ioend_pool;
 
@@ -579,15 +579,19 @@ xfs_showargs(
         else if (mp->m_qflags & XFS_UQUOTA_ACCT)
                 seq_puts(m, "," MNTOPT_UQUOTANOENF);
 
-        if (mp->m_qflags & (XFS_PQUOTA_ACCT|XFS_OQUOTA_ENFD))
-                seq_puts(m, "," MNTOPT_PRJQUOTA);
-        else if (mp->m_qflags & XFS_PQUOTA_ACCT)
-                seq_puts(m, "," MNTOPT_PQUOTANOENF);
-
-        if (mp->m_qflags & (XFS_GQUOTA_ACCT|XFS_OQUOTA_ENFD))
-                seq_puts(m, "," MNTOPT_GRPQUOTA);
-        else if (mp->m_qflags & XFS_GQUOTA_ACCT)
-                seq_puts(m, "," MNTOPT_GQUOTANOENF);
+        /* Either project or group quotas can be active, not both */
+
+        if (mp->m_qflags & XFS_PQUOTA_ACCT) {
+                if (mp->m_qflags & XFS_OQUOTA_ENFD)
+                        seq_puts(m, "," MNTOPT_PRJQUOTA);
+                else
+                        seq_puts(m, "," MNTOPT_PQUOTANOENF);
+        } else if (mp->m_qflags & XFS_GQUOTA_ACCT) {
+                if (mp->m_qflags & XFS_OQUOTA_ENFD)
+                        seq_puts(m, "," MNTOPT_GRPQUOTA);
+                else
+                        seq_puts(m, "," MNTOPT_GQUOTANOENF);
+        }
 
         if (!(mp->m_qflags & XFS_ALL_QUOTA_ACCT))
                 seq_puts(m, "," MNTOPT_NOQUOTA);
@@ -687,7 +691,7 @@ xfs_barrier_test(
         return error;
 }
 
-void
+STATIC void
 xfs_mountfs_check_barriers(xfs_mount_t *mp)
 {
         int error;
@@ -973,6 +977,28 @@ xfs_fs_inode_init_once(
 }
 
 /*
+ * Dirty the XFS inode when mark_inode_dirty_sync() is called so that
+ * we catch unlogged VFS level updates to the inode. Care must be taken
+ * here - the transaction code calls mark_inode_dirty_sync() to mark the
+ * VFS inode dirty in a transaction and clears the i_update_core field;
+ * it must clear the field after calling mark_inode_dirty_sync() to
+ * correctly indicate that the dirty state has been propagated into the
+ * inode log item.
+ *
+ * We need the barrier() to maintain correct ordering between unlogged
+ * updates and the transaction commit code that clears the i_update_core
+ * field. This requires all updates to be completed before marking the
+ * inode dirty.
+ */
+STATIC void
+xfs_fs_dirty_inode(
+        struct inode    *inode)
+{
+        barrier();
+        XFS_I(inode)->i_update_core = 1;
+}
+
+/*
  * Attempt to flush the inode, this will actually fail
  * if the inode is pinned, but we dirty the inode again
  * at the point when it is unpinned after a log write,
@@ -1122,7 +1148,7 @@ xfs_fs_put_super(
 }
 
 STATIC int
-xfs_fs_sync_super(
+xfs_fs_sync_fs(
         struct super_block      *sb,
         int                     wait)
 {
@@ -1130,23 +1156,23 @@ xfs_fs_sync_super(
         int                     error;
 
         /*
-         * Treat a sync operation like a freeze.  This is to work
-         * around a race in sync_inodes() which works in two phases
-         * - an asynchronous flush, which can write out an inode
-         * without waiting for file size updates to complete, and a
-         * synchronous flush, which wont do anything because the
-         * async flush removed the inode's dirty flag.  Also
-         * sync_inodes() will not see any files that just have
-         * outstanding transactions to be flushed because we don't
-         * dirty the Linux inode until after the transaction I/O
-         * completes.
+         * Not much we can do for the first async pass.  Writing out the
+         * superblock would be counter-productive as we are going to redirty
+         * when writing out other data and metadata (and writing out a single
+         * block is quite fast anyway).
+         *
+         * Try to asynchronously kick off quota syncing at least.
          */
-        if (wait || unlikely(sb->s_frozen == SB_FREEZE_WRITE))
-                error = xfs_quiesce_data(mp);
-        else
-                error = xfs_sync_fsdata(mp, 0);
+        if (!wait) {
+                xfs_qm_sync(mp, SYNC_TRYLOCK);
+                return 0;
+        }
 
-        if (unlikely(laptop_mode)) {
+        error = xfs_quiesce_data(mp);
+        if (error)
+                return -error;
+
+        if (laptop_mode) {
                 int     prev_sync_seq = mp->m_sync_seq;
 
                 /*
@@ -1165,7 +1191,7 @@ xfs_fs_sync_super(
                                 mp->m_sync_seq != prev_sync_seq);
         }
 
-        return -error;
+        return 0;
 }
 
 STATIC int
@@ -1532,13 +1558,14 @@ xfs_fs_get_sb(
                            mnt);
 }
 
-static struct super_operations xfs_super_operations = {
+static const struct super_operations xfs_super_operations = {
         .alloc_inode            = xfs_fs_alloc_inode,
         .destroy_inode          = xfs_fs_destroy_inode,
+        .dirty_inode            = xfs_fs_dirty_inode,
         .write_inode            = xfs_fs_write_inode,
         .clear_inode            = xfs_fs_clear_inode,
         .put_super              = xfs_fs_put_super,
-        .sync_fs                = xfs_fs_sync_super,
+        .sync_fs                = xfs_fs_sync_fs,
         .freeze_fs              = xfs_fs_freeze,
         .statfs                 = xfs_fs_statfs,
         .remount_fs             = xfs_fs_remount,
diff --git a/fs/xfs/linux-2.6/xfs_super.h b/fs/xfs/linux-2.6/xfs_super.h
index 5a2ea3a21781..18175ebd58ed 100644
--- a/fs/xfs/linux-2.6/xfs_super.h
+++ b/fs/xfs/linux-2.6/xfs_super.h
@@ -93,7 +93,7 @@ extern void xfs_blkdev_issue_flush(struct xfs_buftarg *);
 
 extern const struct export_operations xfs_export_operations;
 extern struct xattr_handler *xfs_xattr_handlers[];
-extern struct quotactl_ops xfs_quotactl_operations;
+extern const struct quotactl_ops xfs_quotactl_operations;
 
 #define XFS_M(sb)               ((struct xfs_mount *)((sb)->s_fs_info))
 
diff --git a/fs/xfs/linux-2.6/xfs_sync.c b/fs/xfs/linux-2.6/xfs_sync.c
index 98ef624d9baf..961df0a22c78 100644
--- a/fs/xfs/linux-2.6/xfs_sync.c
+++ b/fs/xfs/linux-2.6/xfs_sync.c
@@ -309,11 +309,15 @@ xfs_sync_attr(
 STATIC int
 xfs_commit_dummy_trans(
         struct xfs_mount        *mp,
-        uint                    log_flags)
+        uint                    flags)
 {
         struct xfs_inode        *ip = mp->m_rootip;
         struct xfs_trans        *tp;
         int                     error;
+        int                     log_flags = XFS_LOG_FORCE;
+
+        if (flags & SYNC_WAIT)
+                log_flags |= XFS_LOG_SYNC;
 
         /*
          * Put a dummy transaction in the log to tell recovery
@@ -331,13 +335,12 @@ xfs_commit_dummy_trans(
         xfs_trans_ijoin(tp, ip, XFS_ILOCK_EXCL);
         xfs_trans_ihold(tp, ip);
         xfs_trans_log_inode(tp, ip, XFS_ILOG_CORE);
-        /* XXX(hch): ignoring the error here.. */
         error = xfs_trans_commit(tp, 0);
-
         xfs_iunlock(ip, XFS_ILOCK_EXCL);
 
+        /* the log force ensures this transaction is pushed to disk */
         xfs_log_force(mp, 0, log_flags);
-        return 0;
+        return error;
 }
 
 int
@@ -385,7 +388,20 @@ xfs_sync_fsdata(
         else
                 XFS_BUF_ASYNC(bp);
 
-        return xfs_bwrite(mp, bp);
+        error = xfs_bwrite(mp, bp);
+        if (error)
+                return error;
+
+        /*
+         * If this is a data integrity sync make sure all pending buffers
+         * are flushed out for the log coverage check below.
+         */
+        if (flags & SYNC_WAIT)
+                xfs_flush_buftarg(mp->m_ddev_targp, 1);
+
+        if (xfs_log_need_covered(mp))
+                error = xfs_commit_dummy_trans(mp, flags);
+        return error;
 
  out_brelse:
         xfs_buf_relse(bp);
@@ -419,14 +435,16 @@ xfs_quiesce_data(
         /* push non-blocking */
         xfs_sync_data(mp, 0);
         xfs_qm_sync(mp, SYNC_TRYLOCK);
-        xfs_filestream_flush(mp);
 
-        /* push and block */
+        /* push and block till complete */
         xfs_sync_data(mp, SYNC_WAIT);
         xfs_qm_sync(mp, SYNC_WAIT);
 
+        /* drop inode references pinned by filestreams */
+        xfs_filestream_flush(mp);
+
         /* write superblock and hoover up shutdown errors */
-        error = xfs_sync_fsdata(mp, 0);
+        error = xfs_sync_fsdata(mp, SYNC_WAIT);
 
         /* flush data-only devices */
         if (mp->m_rtdev_targp)
@@ -570,8 +588,6 @@ xfs_sync_worker(
                 /* dgc: errors ignored here */
                 error = xfs_qm_sync(mp, SYNC_TRYLOCK);
                 error = xfs_sync_fsdata(mp, SYNC_TRYLOCK);
-                if (xfs_log_need_covered(mp))
-                        error = xfs_commit_dummy_trans(mp, XFS_LOG_FORCE);
         }
         mp->m_sync_seq++;
         wake_up(&mp->m_wait_single_sync_task);
@@ -749,21 +765,6 @@ __xfs_inode_clear_reclaim_tag(
                         XFS_INO_TO_AGINO(mp, ip->i_ino), XFS_ICI_RECLAIM_TAG);
 }
 
-void
-xfs_inode_clear_reclaim_tag(
-        xfs_inode_t     *ip)
-{
-        xfs_mount_t     *mp = ip->i_mount;
-        xfs_perag_t     *pag = xfs_get_perag(mp, ip->i_ino);
-
-        read_lock(&pag->pag_ici_lock);
-        spin_lock(&ip->i_flags_lock);
-        __xfs_inode_clear_reclaim_tag(mp, pag, ip);
-        spin_unlock(&ip->i_flags_lock);
-        read_unlock(&pag->pag_ici_lock);
-        xfs_put_perag(mp, pag);
-}
-
 STATIC int
 xfs_reclaim_inode_now(
         struct xfs_inode        *ip,
diff --git a/fs/xfs/linux-2.6/xfs_sync.h b/fs/xfs/linux-2.6/xfs_sync.h
index 59120602588a..27920eb7a820 100644
--- a/fs/xfs/linux-2.6/xfs_sync.h
+++ b/fs/xfs/linux-2.6/xfs_sync.h
@@ -49,7 +49,6 @@ int xfs_reclaim_inodes(struct xfs_mount *mp, int mode);
 
 void xfs_inode_set_reclaim_tag(struct xfs_inode *ip);
 void __xfs_inode_set_reclaim_tag(struct xfs_perag *pag, struct xfs_inode *ip);
-void xfs_inode_clear_reclaim_tag(struct xfs_inode *ip);
 void __xfs_inode_clear_reclaim_tag(struct xfs_mount *mp, struct xfs_perag *pag,
                                 struct xfs_inode *ip);
 
diff --git a/fs/xfs/linux-2.6/xfs_sysctl.c b/fs/xfs/linux-2.6/xfs_sysctl.c
index 916c0ffb6083..c5bc67c4e3bb 100644
--- a/fs/xfs/linux-2.6/xfs_sysctl.c
+++ b/fs/xfs/linux-2.6/xfs_sysctl.c
@@ -26,7 +26,6 @@ STATIC int
 xfs_stats_clear_proc_handler(
         ctl_table       *ctl,
         int             write,
-        struct file     *filp,
         void            __user *buffer,
         size_t          *lenp,
         loff_t          *ppos)
@@ -34,7 +33,7 @@ xfs_stats_clear_proc_handler(
         int             c, ret, *valp = ctl->data;
         __uint32_t      vn_active;
 
-        ret = proc_dointvec_minmax(ctl, write, filp, buffer, lenp, ppos);
+        ret = proc_dointvec_minmax(ctl, write, buffer, lenp, ppos);
 
         if (!ret && write && *valp) {
                 printk("XFS Clearing xfsstats\n");