7 files changed, 282 insertions, 108 deletions

diff --git a/fs/xfs/linux-2.6/xfs_super.c b/fs/xfs/linux-2.6/xfs_super.c
index 70024a24692d..156a1a7da16b 100644
--- a/fs/xfs/linux-2.6/xfs_super.c
+++ b/fs/xfs/linux-2.6/xfs_super.c
@@ -51,6 +51,7 @@
 #include "xfs_vfsops.h"
 #include "xfs_version.h"
 #include "xfs_log_priv.h"
+#include "xfs_trans_priv.h"
 
 #include <linux/namei.h>
 #include <linux/init.h>
@@ -765,6 +766,64 @@ xfs_blkdev_issue_flush(
         blkdev_issue_flush(buftarg->bt_bdev, NULL);
 }
 
+/*
+ * XFS AIL push thread support
+ */
+void
+xfsaild_wakeup(
+        xfs_mount_t             *mp,
+        xfs_lsn_t               threshold_lsn)
+{
+        mp->m_ail.xa_target = threshold_lsn;
+        wake_up_process(mp->m_ail.xa_task);
+}
+
+int
+xfsaild(
+        void    *data)
+{
+        xfs_mount_t     *mp = (xfs_mount_t *)data;
+        xfs_lsn_t       last_pushed_lsn = 0;
+        long            tout = 0;
+
+        while (!kthread_should_stop()) {
+                if (tout)
+                        schedule_timeout_interruptible(msecs_to_jiffies(tout));
+                tout = 1000;
+
+                /* swsusp */
+                try_to_freeze();
+
+                ASSERT(mp->m_log);
+                if (XFS_FORCED_SHUTDOWN(mp))
+                        continue;
+
+                tout = xfsaild_push(mp, &last_pushed_lsn);
+        }
+
+        return 0;
+}       /* xfsaild */
+
+int
+xfsaild_start(
+        xfs_mount_t     *mp)
+{
+        mp->m_ail.xa_target = 0;
+        mp->m_ail.xa_task = kthread_run(xfsaild, mp, "xfsaild");
+        if (IS_ERR(mp->m_ail.xa_task))
+                return -PTR_ERR(mp->m_ail.xa_task);
+        return 0;
+}
+
+void
+xfsaild_stop(
+        xfs_mount_t     *mp)
+{
+        kthread_stop(mp->m_ail.xa_task);
+}
+
+
+
 STATIC struct inode *
 xfs_fs_alloc_inode(
         struct super_block      *sb)
diff --git a/fs/xfs/xfs_log.c b/fs/xfs/xfs_log.c
index 4c86a26330a0..b3ac3805d3c4 100644
--- a/fs/xfs/xfs_log.c
+++ b/fs/xfs/xfs_log.c
@@ -498,11 +498,14 @@ xfs_log_reserve(xfs_mount_t	 *mp,
  * Return error or zero.
  */
 int
-xfs_log_mount(xfs_mount_t       *mp,
-              xfs_buftarg_t     *log_target,
-              xfs_daddr_t       blk_offset,
-              int               num_bblks)
+xfs_log_mount(
+        xfs_mount_t     *mp,
+        xfs_buftarg_t   *log_target,
+        xfs_daddr_t     blk_offset,
+        int             num_bblks)
 {
+        int             error;
+
         if (!(mp->m_flags & XFS_MOUNT_NORECOVERY))
                 cmn_err(CE_NOTE, "XFS mounting filesystem %s", mp->m_fsname);
         else {
@@ -515,11 +518,21 @@ xfs_log_mount(xfs_mount_t	*mp,
         mp->m_log = xlog_alloc_log(mp, log_target, blk_offset, num_bblks);
 
         /*
+         * Initialize the AIL now we have a log.
+         */
+        spin_lock_init(&mp->m_ail_lock);
+        error = xfs_trans_ail_init(mp);
+        if (error) {
+                cmn_err(CE_WARN, "XFS: AIL initialisation failed: error %d", error);
+                goto error;
+        }
+
+        /*
          * skip log recovery on a norecovery mount.  pretend it all
          * just worked.
          */
         if (!(mp->m_flags & XFS_MOUNT_NORECOVERY)) {
-                int             error, readonly = (mp->m_flags & XFS_MOUNT_RDONLY);
+                int     readonly = (mp->m_flags & XFS_MOUNT_RDONLY);
 
                 if (readonly)
                         mp->m_flags &= ~XFS_MOUNT_RDONLY;
@@ -530,8 +543,7 @@ xfs_log_mount(xfs_mount_t	*mp,
                         mp->m_flags |= XFS_MOUNT_RDONLY;
                 if (error) {
                         cmn_err(CE_WARN, "XFS: log mount/recovery failed: error %d", error);
-                        xlog_dealloc_log(mp->m_log);
-                        return error;
+                        goto error;
                 }
         }
 
@@ -540,6 +552,9 @@ xfs_log_mount(xfs_mount_t	*mp,
 
         /* End mounting message in xfs_log_mount_finish */
         return 0;
+error:
+        xfs_log_unmount_dealloc(mp);
+        return error;
 }       /* xfs_log_mount */
 
 /*
@@ -722,10 +737,14 @@ xfs_log_unmount_write(xfs_mount_t *mp)
 
 /*
  * Deallocate log structures for unmount/relocation.
+ *
+ * We need to stop the aild from running before we destroy
+ * and deallocate the log as the aild references the log.
  */
 void
 xfs_log_unmount_dealloc(xfs_mount_t *mp)
 {
+        xfs_trans_ail_destroy(mp);
         xlog_dealloc_log(mp->m_log);
 }
 
diff --git a/fs/xfs/xfs_mount.c b/fs/xfs/xfs_mount.c
index 766c01670b2c..6409b3762995 100644
--- a/fs/xfs/xfs_mount.c
+++ b/fs/xfs/xfs_mount.c
@@ -136,15 +136,9 @@ xfs_mount_init(void)
                 mp->m_flags |= XFS_MOUNT_NO_PERCPU_SB;
         }
 
-        spin_lock_init(&mp->m_ail_lock);
         spin_lock_init(&mp->m_sb_lock);
         mutex_init(&mp->m_ilock);
         mutex_init(&mp->m_growlock);
-        /*
-         * Initialize the AIL.
-         */
-        xfs_trans_ail_init(mp);
-
         atomic_set(&mp->m_active_trans, 0);
 
         return mp;
diff --git a/fs/xfs/xfs_mount.h b/fs/xfs/xfs_mount.h
index 15025e01300a..f7c620ec6e69 100644
--- a/fs/xfs/xfs_mount.h
+++ b/fs/xfs/xfs_mount.h
@@ -219,12 +219,18 @@ extern void	xfs_icsb_sync_counters_flags(struct xfs_mount *, int);
 #define xfs_icsb_sync_counters_flags(mp, flags) do { } while (0)
 #endif
 
+typedef struct xfs_ail {
+        xfs_ail_entry_t         xa_ail;
+        uint                    xa_gen;
+        struct task_struct      *xa_task;
+        xfs_lsn_t               xa_target;
+} xfs_ail_t;
+
 typedef struct xfs_mount {
         struct super_block      *m_super;
         xfs_tid_t               m_tid;          /* next unused tid for fs */
         spinlock_t              m_ail_lock;     /* fs AIL mutex */
-        xfs_ail_entry_t         m_ail;          /* fs active log item list */
-        uint                    m_ail_gen;      /* fs AIL generation count */
+        xfs_ail_t               m_ail;          /* fs active log item list */
         xfs_sb_t                m_sb;           /* copy of fs superblock */
         spinlock_t              m_sb_lock;      /* sb counter lock */
         struct xfs_buf          *m_sb_bp;       /* buffer for superblock */
diff --git a/fs/xfs/xfs_trans.h b/fs/xfs/xfs_trans.h
index bea6e2b95a90..7f40628d85c7 100644
--- a/fs/xfs/xfs_trans.h
+++ b/fs/xfs/xfs_trans.h
@@ -992,8 +992,9 @@ int		_xfs_trans_commit(xfs_trans_t *,
                                   int *);
 #define xfs_trans_commit(tp, flags)     _xfs_trans_commit(tp, flags, NULL)
 void            xfs_trans_cancel(xfs_trans_t *, int);
-void            xfs_trans_ail_init(struct xfs_mount *);
-xfs_lsn_t       xfs_trans_push_ail(struct xfs_mount *, xfs_lsn_t);
+int             xfs_trans_ail_init(struct xfs_mount *);
+void            xfs_trans_ail_destroy(struct xfs_mount *);
+void            xfs_trans_push_ail(struct xfs_mount *, xfs_lsn_t);
 xfs_lsn_t       xfs_trans_tail_ail(struct xfs_mount *);
 void            xfs_trans_unlocked_item(struct xfs_mount *,
                                         xfs_log_item_t *);
diff --git a/fs/xfs/xfs_trans_ail.c b/fs/xfs/xfs_trans_ail.c
index 2d3c297259c2..7ed7425478de 100644
--- a/fs/xfs/xfs_trans_ail.c
+++ b/fs/xfs/xfs_trans_ail.c
@@ -57,7 +57,7 @@ xfs_trans_tail_ail(
         xfs_log_item_t  *lip;
 
         spin_lock(&mp->m_ail_lock);
-        lip = xfs_ail_min(&(mp->m_ail));
+        lip = xfs_ail_min(&(mp->m_ail.xa_ail));
         if (lip == NULL) {
                 lsn = (xfs_lsn_t)0;
         } else {
@@ -71,119 +71,185 @@ xfs_trans_tail_ail(
 /*
  * xfs_trans_push_ail
  *
- * This routine is called to move the tail of the AIL
- * forward.  It does this by trying to flush items in the AIL
- * whose lsns are below the given threshold_lsn.
+ * This routine is called to move the tail of the AIL forward.  It does this by
+ * trying to flush items in the AIL whose lsns are below the given
+ * threshold_lsn.
  *
- * The routine returns the lsn of the tail of the log.
+ * the push is run asynchronously in a separate thread, so we return the tail
+ * of the log right now instead of the tail after the push. This means we will
+ * either continue right away, or we will sleep waiting on the async thread to
+ * do it's work.
+ *
+ * We do this unlocked - we only need to know whether there is anything in the
+ * AIL at the time we are called. We don't need to access the contents of
+ * any of the objects, so the lock is not needed.
  */
-xfs_lsn_t
+void
 xfs_trans_push_ail(
         xfs_mount_t             *mp,
         xfs_lsn_t               threshold_lsn)
 {
-        xfs_lsn_t               lsn;
         xfs_log_item_t          *lip;
-        int                     gen;
-        int                     restarts;
-        int                     lock_result;
-        int                     flush_log;
 
-#define XFS_TRANS_PUSH_AIL_RESTARTS     1000
+        lip = xfs_ail_min(&mp->m_ail.xa_ail);
+        if (lip && !XFS_FORCED_SHUTDOWN(mp)) {
+                if (XFS_LSN_CMP(threshold_lsn, mp->m_ail.xa_target) > 0)
+                        xfsaild_wakeup(mp, threshold_lsn);
+        }
+}
+
+/*
+ * Return the item in the AIL with the current lsn.
+ * Return the current tree generation number for use
+ * in calls to xfs_trans_next_ail().
+ */
+STATIC xfs_log_item_t *
+xfs_trans_first_push_ail(
+        xfs_mount_t     *mp,
+        int             *gen,
+        xfs_lsn_t       lsn)
+{
+        xfs_log_item_t  *lip;
+
+        lip = xfs_ail_min(&(mp->m_ail.xa_ail));
+        *gen = (int)mp->m_ail.xa_gen;
+        if (lsn == 0)
+                return lip;
+
+        while (lip && (XFS_LSN_CMP(lip->li_lsn, lsn) < 0))
+                lip = lip->li_ail.ail_forw;
+
+        return lip;
+}
+
+/*
+ * Function that does the work of pushing on the AIL
+ */
+long
+xfsaild_push(
+        xfs_mount_t     *mp,
+        xfs_lsn_t       *last_lsn)
+{
+        long            tout = 1000; /* milliseconds */
+        xfs_lsn_t       last_pushed_lsn = *last_lsn;
+        xfs_lsn_t       target =  mp->m_ail.xa_target;
+        xfs_lsn_t       lsn;
+        xfs_log_item_t  *lip;
+        int             gen;
+        int             restarts;
+        int             flush_log, count, stuck;
+
+#define XFS_TRANS_PUSH_AIL_RESTARTS     10
 
         spin_lock(&mp->m_ail_lock);
-        lip = xfs_trans_first_ail(mp, &gen);
-        if (lip == NULL || XFS_FORCED_SHUTDOWN(mp)) {
+        lip = xfs_trans_first_push_ail(mp, &gen, *last_lsn);
+        if (!lip || XFS_FORCED_SHUTDOWN(mp)) {
                 /*
-                 * Just return if the AIL is empty.
+                 * AIL is empty or our push has reached the end.
                  */
                 spin_unlock(&mp->m_ail_lock);
-                return (xfs_lsn_t)0;
+                last_pushed_lsn = 0;
+                goto out;
         }
 
         XFS_STATS_INC(xs_push_ail);
 
         /*
          * While the item we are looking at is below the given threshold
-         * try to flush it out.  Make sure to limit the number of times
-         * we allow xfs_trans_next_ail() to restart scanning from the
-         * beginning of the list.  We'd like not to stop until we've at least
+         * try to flush it out. We'd like not to stop until we've at least
          * tried to push on everything in the AIL with an LSN less than
-         * the given threshold. However, we may give up before that if
-         * we realize that we've been holding the AIL lock for 'too long',
-         * blocking interrupts. Currently, too long is < 500us roughly.
+         * the given threshold.
+         *
+         * However, we will stop after a certain number of pushes and wait
+         * for a reduced timeout to fire before pushing further. This
+         * prevents use from spinning when we can't do anything or there is
+         * lots of contention on the AIL lists.
          */
-        flush_log = 0;
-        restarts = 0;
-        while (((restarts < XFS_TRANS_PUSH_AIL_RESTARTS) &&
-                (XFS_LSN_CMP(lip->li_lsn, threshold_lsn) < 0))) {
+        tout = 10;
+        lsn = lip->li_lsn;
+        flush_log = stuck = count = restarts = 0;
+        while ((XFS_LSN_CMP(lip->li_lsn, target) < 0)) {
+                int     lock_result;
                 /*
-                 * If we can lock the item without sleeping, unlock
-                 * the AIL lock and flush the item.  Then re-grab the
-                 * AIL lock so we can look for the next item on the
-                 * AIL.  Since we unlock the AIL while we flush the
-                 * item, the next routine may start over again at the
-                 * the beginning of the list if anything has changed.
-                 * That is what the generation count is for.
+                 * If we can lock the item without sleeping, unlock the AIL
+                 * lock and flush the item.  Then re-grab the AIL lock so we
+                 * can look for the next item on the AIL. List changes are
+                 * handled by the AIL lookup functions internally
                  *
-                 * If we can't lock the item, either its holder will flush
-                 * it or it is already being flushed or it is being relogged.
-                 * In any of these case it is being taken care of and we
-                 * can just skip to the next item in the list.
+                 * If we can't lock the item, either its holder will flush it
+                 * or it is already being flushed or it is being relogged.  In
+                 * any of these case it is being taken care of and we can just
+                 * skip to the next item in the list.
                  */
                 lock_result = IOP_TRYLOCK(lip);
+                spin_unlock(&mp->m_ail_lock);
                 switch (lock_result) {
-                      case XFS_ITEM_SUCCESS:
-                        spin_unlock(&mp->m_ail_lock);
+                case XFS_ITEM_SUCCESS:
                         XFS_STATS_INC(xs_push_ail_success);
                         IOP_PUSH(lip);
-                        spin_lock(&mp->m_ail_lock);
+                        last_pushed_lsn = lsn;
                         break;
 
-                      case XFS_ITEM_PUSHBUF:
-                        spin_unlock(&mp->m_ail_lock);
+                case XFS_ITEM_PUSHBUF:
                         XFS_STATS_INC(xs_push_ail_pushbuf);
-#ifdef XFSRACEDEBUG
-                        delay_for_intr();
-                        delay(300);
-#endif
-                        ASSERT(lip->li_ops->iop_pushbuf);
-                        ASSERT(lip);
                         IOP_PUSHBUF(lip);
-                        spin_lock(&mp->m_ail_lock);
+                        last_pushed_lsn = lsn;
                         break;
 
-                      case XFS_ITEM_PINNED:
+                case XFS_ITEM_PINNED:
                         XFS_STATS_INC(xs_push_ail_pinned);
+                        stuck++;
                         flush_log = 1;
                         break;
 
-                      case XFS_ITEM_LOCKED:
+                case XFS_ITEM_LOCKED:
                         XFS_STATS_INC(xs_push_ail_locked);
+                        last_pushed_lsn = lsn;
+                        stuck++;
                         break;
 
-                      case XFS_ITEM_FLUSHING:
+                case XFS_ITEM_FLUSHING:
                         XFS_STATS_INC(xs_push_ail_flushing);
+                        last_pushed_lsn = lsn;
+                        stuck++;
                         break;
 
-                      default:
+                default:
                         ASSERT(0);
                         break;
                 }
 
-                lip = xfs_trans_next_ail(mp, lip, &gen, &restarts);
-                if (lip == NULL) {
+                spin_lock(&mp->m_ail_lock);
+                /* should we bother continuing? */
+                if (XFS_FORCED_SHUTDOWN(mp))
+                        break;
+                ASSERT(mp->m_log);
+
+                count++;
+
+                /*
+                 * Are there too many items we can't do anything with?
+                 * If we we are skipping too many items because we can't flush
+                 * them or they are already being flushed, we back off and
+                 * given them time to complete whatever operation is being
+                 * done. i.e. remove pressure from the AIL while we can't make
+                 * progress so traversals don't slow down further inserts and
+                 * removals to/from the AIL.
+                 *
+                 * The value of 100 is an arbitrary magic number based on
+                 * observation.
+                 */
+                if (stuck > 100)
                         break;
-                }
-                if (XFS_FORCED_SHUTDOWN(mp)) {
-                        /*
-                         * Just return if we shut down during the last try.
-                         */
-                        spin_unlock(&mp->m_ail_lock);
-                        return (xfs_lsn_t)0;
-                }
 
+                lip = xfs_trans_next_ail(mp, lip, &gen, &restarts);
+                if (lip == NULL)
+                        break;
+                if (restarts > XFS_TRANS_PUSH_AIL_RESTARTS)
+                        break;
+                lsn = lip->li_lsn;
         }
+        spin_unlock(&mp->m_ail_lock);
 
         if (flush_log) {
                 /*
@@ -191,22 +257,35 @@ xfs_trans_push_ail(
                  * push out the log so it will become unpinned and
                  * move forward in the AIL.
                  */
-                spin_unlock(&mp->m_ail_lock);
                 XFS_STATS_INC(xs_push_ail_flush);
                 xfs_log_force(mp, (xfs_lsn_t)0, XFS_LOG_FORCE);
-                spin_lock(&mp->m_ail_lock);
         }
 
-        lip = xfs_ail_min(&(mp->m_ail));
-        if (lip == NULL) {
-                lsn = (xfs_lsn_t)0;
-        } else {
-                lsn = lip->li_lsn;
+        /*
+         * We reached the target so wait a bit longer for I/O to complete and
+         * remove pushed items from the AIL before we start the next scan from
+         * the start of the AIL.
+         */
+        if ((XFS_LSN_CMP(lsn, target) >= 0)) {
+                tout += 20;
+                last_pushed_lsn = 0;
+        } else if ((restarts > XFS_TRANS_PUSH_AIL_RESTARTS) ||
+                   (count && ((stuck * 100) / count > 90))) {
+                /*
+                 * Either there is a lot of contention on the AIL or we
+                 * are stuck due to operations in progress. "Stuck" in this
+                 * case is defined as >90% of the items we tried to push
+                 * were stuck.
+                 *
+                 * Backoff a bit more to allow some I/O to complete before
+                 * continuing from where we were.
+                 */
+                tout += 10;
         }
-
-        spin_unlock(&mp->m_ail_lock);
-        return lsn;
-}       /* xfs_trans_push_ail */
+out:
+        *last_lsn = last_pushed_lsn;
+        return tout;
+}       /* xfsaild_push */
 
 
 /*
@@ -247,7 +326,7 @@ xfs_trans_unlocked_item(
          * the call to xfs_log_move_tail() doesn't do anything if there's
          * not enough free space to wake people up so we're safe calling it.
          */
-        min_lip = xfs_ail_min(&mp->m_ail);
+        min_lip = xfs_ail_min(&mp->m_ail.xa_ail);
 
         if (min_lip == lip)
                 xfs_log_move_tail(mp, 1);
@@ -279,7 +358,7 @@ xfs_trans_update_ail(
         xfs_log_item_t          *dlip=NULL;
         xfs_log_item_t          *mlip;  /* ptr to minimum lip */
 
-        ailp = &(mp->m_ail);
+        ailp = &(mp->m_ail.xa_ail);
         mlip = xfs_ail_min(ailp);
 
         if (lip->li_flags & XFS_LI_IN_AIL) {
@@ -292,10 +371,10 @@ xfs_trans_update_ail(
         lip->li_lsn = lsn;
 
         xfs_ail_insert(ailp, lip);
-        mp->m_ail_gen++;
+        mp->m_ail.xa_gen++;
 
         if (mlip == dlip) {
-                mlip = xfs_ail_min(&(mp->m_ail));
+                mlip = xfs_ail_min(&(mp->m_ail.xa_ail));
                 spin_unlock(&mp->m_ail_lock);
                 xfs_log_move_tail(mp, mlip->li_lsn);
         } else {
@@ -330,7 +409,7 @@ xfs_trans_delete_ail(
         xfs_log_item_t          *mlip;
 
         if (lip->li_flags & XFS_LI_IN_AIL) {
-                ailp = &(mp->m_ail);
+                ailp = &(mp->m_ail.xa_ail);
                 mlip = xfs_ail_min(ailp);
                 dlip = xfs_ail_delete(ailp, lip);
                 ASSERT(dlip == lip);
@@ -338,10 +417,10 @@ xfs_trans_delete_ail(
 
                 lip->li_flags &= ~XFS_LI_IN_AIL;
                 lip->li_lsn = 0;
-                mp->m_ail_gen++;
+                mp->m_ail.xa_gen++;
 
                 if (mlip == dlip) {
-                        mlip = xfs_ail_min(&(mp->m_ail));
+                        mlip = xfs_ail_min(&(mp->m_ail.xa_ail));
                         spin_unlock(&mp->m_ail_lock);
                         xfs_log_move_tail(mp, (mlip ? mlip->li_lsn : 0));
                 } else {
@@ -379,10 +458,10 @@ xfs_trans_first_ail(
 {
         xfs_log_item_t  *lip;
 
-        lip = xfs_ail_min(&(mp->m_ail));
-        *gen = (int)mp->m_ail_gen;
+        lip = xfs_ail_min(&(mp->m_ail.xa_ail));
+        *gen = (int)mp->m_ail.xa_gen;
 
-        return (lip);
+        return lip;
 }
 
 /*
@@ -402,11 +481,11 @@ xfs_trans_next_ail(
         xfs_log_item_t  *nlip;
 
         ASSERT(mp && lip && gen);
-        if (mp->m_ail_gen == *gen) {
-                nlip = xfs_ail_next(&(mp->m_ail), lip);
+        if (mp->m_ail.xa_gen == *gen) {
+                nlip = xfs_ail_next(&(mp->m_ail.xa_ail), lip);
         } else {
-                nlip = xfs_ail_min(&(mp->m_ail));
-                *gen = (int)mp->m_ail_gen;
+                nlip = xfs_ail_min(&(mp->m_ail).xa_ail);
+                *gen = (int)mp->m_ail.xa_gen;
                 if (restarts != NULL) {
                         XFS_STATS_INC(xs_push_ail_restarts);
                         (*restarts)++;
@@ -431,12 +510,20 @@ xfs_trans_next_ail(
 /*
  * Initialize the doubly linked list to point only to itself.
  */
-void
+int
 xfs_trans_ail_init(
         xfs_mount_t     *mp)
 {
-        mp->m_ail.ail_forw = (xfs_log_item_t*)&(mp->m_ail);
-        mp->m_ail.ail_back = (xfs_log_item_t*)&(mp->m_ail);
+        mp->m_ail.xa_ail.ail_forw = (xfs_log_item_t*)&mp->m_ail.xa_ail;
+        mp->m_ail.xa_ail.ail_back = (xfs_log_item_t*)&mp->m_ail.xa_ail;
+        return xfsaild_start(mp);
+}
+
+void
+xfs_trans_ail_destroy(
+        xfs_mount_t     *mp)
+{
+        xfsaild_stop(mp);
 }
 
 /*
diff --git a/fs/xfs/xfs_trans_priv.h b/fs/xfs/xfs_trans_priv.h
index c40f0512097a..3c748c456ed4 100644
--- a/fs/xfs/xfs_trans_priv.h
+++ b/fs/xfs/xfs_trans_priv.h
@@ -57,4 +57,12 @@ struct xfs_log_item	*xfs_trans_next_ail(struct xfs_mount *,
                                      struct xfs_log_item *, int *, int *);
 
 
+/*
+ * AIL push thread support
+ */
+long    xfsaild_push(struct xfs_mount *, xfs_lsn_t *);
+void    xfsaild_wakeup(struct xfs_mount *, xfs_lsn_t);
+int     xfsaild_start(struct xfs_mount *);
+void    xfsaild_stop(struct xfs_mount *);
+
 #endif  /* __XFS_TRANS_PRIV_H__ */