xfs: implement freezing by emptying the AIL

Now that we write back all metadata either synchronously or through
the AIL we can simply implement metadata freezing in terms of
emptying the AIL.

The implementation for this is fairly simply and straight-forward:
A new routine is added that asks the xfsaild to push the AIL to the
end and waits for it to complete and send a wakeup. The routine will
then loop if the AIL is not actually empty, and continue to do so
until the AIL is compeltely empty.

We keep an inode reclaim pass in the freeze process to avoid having
memory pressure have to reclaim inodes that require dirtying the
filesystem to be reclaimed after the freeze has completed. This
means we can also treat unmount in the exact same way as freeze.

As an upside we can now remove the radix tree based inode writeback
and xfs_unmountfs_writesb.

[ Dave Chinner:
	- Cleaned up commit message.
	- Added inode reclaim passes back into freeze.
	- Cleaned up wakeup mechanism to avoid the use of a new
	  sleep counter variable. ]

Signed-off-by: Christoph Hellwig <hch@lst.de>
Signed-off-by: Dave Chinner <dchinner@redhat.com>
Reviewed-by: Mark Tinguely <tinguely@sgi.com>
Signed-off-by: Ben Myers <bpm@sgi.com>

1 files changed, 12 insertions, 44 deletions

diff --git a/fs/xfs/xfs_mount.c b/fs/xfs/xfs_mount.c
index 1ffead4b2296..385a3b11d3dd 100644
--- a/fs/xfs/xfs_mount.c
+++ b/fs/xfs/xfs_mount.c
@@ -22,6 +22,7 @@
 #include "xfs_log.h"
 #include "xfs_inum.h"
 #include "xfs_trans.h"
+#include "xfs_trans_priv.h"
 #include "xfs_sb.h"
 #include "xfs_ag.h"
 #include "xfs_dir2.h"
@@ -1475,15 +1476,15 @@ xfs_unmountfs(
         xfs_log_force(mp, XFS_LOG_SYNC);
 
         /*
-         * Do a delwri reclaim pass first so that as many dirty inodes are
-         * queued up for IO as possible. Then flush the buffers before making
-         * a synchronous path to catch all the remaining inodes are reclaimed.
-         * This makes the reclaim process as quick as possible by avoiding
-         * synchronous writeout and blocking on inodes already in the delwri
-         * state as much as possible.
+         * Flush all pending changes from the AIL.
+         */
+        xfs_ail_push_all_sync(mp->m_ail);
+
+        /*
+         * And reclaim all inodes.  At this point there should be no dirty
+         * inode, and none should be pinned or locked, but use synchronous
+         * reclaim just to be sure.
          */
-        xfs_reclaim_inodes(mp, 0);
-        xfs_flush_buftarg(mp->m_ddev_targp, 1);
         xfs_reclaim_inodes(mp, SYNC_WAIT);
 
         xfs_qm_unmount(mp);
@@ -1519,15 +1520,12 @@ xfs_unmountfs(
         if (error)
                 xfs_warn(mp, "Unable to update superblock counters. "
                                 "Freespace may not be correct on next mount.");
-        xfs_unmountfs_writesb(mp);
 
         /*
-         * Make sure all buffers have been flushed and completed before
-         * unmounting the log.
+         * At this point we might have modified the superblock again and thus
+         * added an item to the AIL, thus flush it again.
          */
-        error = xfs_flush_buftarg(mp->m_ddev_targp, 1);
-        if (error)
-                xfs_warn(mp, "%d busy buffers during unmount.", error);
+        xfs_ail_push_all_sync(mp->m_ail);
         xfs_wait_buftarg(mp->m_ddev_targp);
 
         xfs_log_unmount_write(mp);
@@ -1588,36 +1586,6 @@ xfs_log_sbcount(xfs_mount_t *mp)
         return error;
 }
 
-int
-xfs_unmountfs_writesb(xfs_mount_t *mp)
-{
-        xfs_buf_t       *sbp;
-        int             error = 0;
-
-        /*
-         * skip superblock write if fs is read-only, or
-         * if we are doing a forced umount.
-         */
-        if (!((mp->m_flags & XFS_MOUNT_RDONLY) ||
-                XFS_FORCED_SHUTDOWN(mp))) {
-
-                sbp = xfs_getsb(mp, 0);
-
-                XFS_BUF_UNDONE(sbp);
-                XFS_BUF_UNREAD(sbp);
-                xfs_buf_delwri_dequeue(sbp);
-                XFS_BUF_WRITE(sbp);
-                XFS_BUF_UNASYNC(sbp);
-                ASSERT(sbp->b_target == mp->m_ddev_targp);
-                xfsbdstrat(mp, sbp);
-                error = xfs_buf_iowait(sbp);
-                if (error)
-                        xfs_buf_ioerror_alert(sbp, __func__);
-                xfs_buf_relse(sbp);
-        }
-        return error;
-}
-
 /*
  * xfs_mod_sb() can be used to copy arbitrary changes to the
  * in-core superblock into the superblock buffer to be logged.