1 files changed, 49 insertions, 9 deletions

diff --git a/fs/xfs/xfs_icache.c b/fs/xfs/xfs_icache.c
index d7a490f24ead..adbc1f59969a 100644
--- a/fs/xfs/xfs_icache.c
+++ b/fs/xfs/xfs_icache.c
@@ -210,14 +210,17 @@ xfs_iget_cache_hit(
 
                 error = inode_init_always(mp->m_super, inode);
                 if (error) {
+                        bool wake;
                         /*
                          * Re-initializing the inode failed, and we are in deep
                          * trouble.  Try to re-add it to the reclaim list.
                          */
                         rcu_read_lock();
                         spin_lock(&ip->i_flags_lock);
-
+                        wake = !!__xfs_iflags_test(ip, XFS_INEW);
                         ip->i_flags &= ~(XFS_INEW | XFS_IRECLAIM);
+                        if (wake)
+                                wake_up_bit(&ip->i_flags, __XFS_INEW_BIT);
                         ASSERT(ip->i_flags & XFS_IRECLAIMABLE);
                         trace_xfs_iget_reclaim_fail(ip);
                         goto out_error;
@@ -363,6 +366,22 @@ out_destroy:
         return error;
 }
 
+static void
+xfs_inew_wait(
+        struct xfs_inode        *ip)
+{
+        wait_queue_head_t *wq = bit_waitqueue(&ip->i_flags, __XFS_INEW_BIT);
+        DEFINE_WAIT_BIT(wait, &ip->i_flags, __XFS_INEW_BIT);
+
+        do {
+                prepare_to_wait(wq, &wait.wait, TASK_UNINTERRUPTIBLE);
+                if (!xfs_iflags_test(ip, XFS_INEW))
+                        break;
+                schedule();
+        } while (true);
+        finish_wait(wq, &wait.wait);
+}
+
 /*
  * Look up an inode by number in the given file system.
  * The inode is looked up in the cache held in each AG.
@@ -467,9 +486,11 @@ out_error_or_again:
 
 STATIC int
 xfs_inode_ag_walk_grab(
-        struct xfs_inode        *ip)
+        struct xfs_inode        *ip,
+        int                     flags)
 {
         struct inode            *inode = VFS_I(ip);
+        bool                    newinos = !!(flags & XFS_AGITER_INEW_WAIT);
 
         ASSERT(rcu_read_lock_held());
 
@@ -487,7 +508,8 @@ xfs_inode_ag_walk_grab(
                 goto out_unlock_noent;
 
         /* avoid new or reclaimable inodes. Leave for reclaim code to flush */
-        if (__xfs_iflags_test(ip, XFS_INEW | XFS_IRECLAIMABLE | XFS_IRECLAIM))
+        if ((!newinos && __xfs_iflags_test(ip, XFS_INEW)) ||
+            __xfs_iflags_test(ip, XFS_IRECLAIMABLE | XFS_IRECLAIM))
                 goto out_unlock_noent;
         spin_unlock(&ip->i_flags_lock);
 
@@ -515,7 +537,8 @@ xfs_inode_ag_walk(
                                            void *args),
         int                     flags,
         void                    *args,
-        int                     tag)
+        int                     tag,
+        int                     iter_flags)
 {
         uint32_t                first_index;
         int                     last_error = 0;
@@ -557,7 +580,7 @@ restart:
                 for (i = 0; i < nr_found; i++) {
                         struct xfs_inode *ip = batch[i];
 
-                        if (done || xfs_inode_ag_walk_grab(ip))
+                        if (done || xfs_inode_ag_walk_grab(ip, iter_flags))
                                 batch[i] = NULL;
 
                         /*
@@ -585,6 +608,9 @@ restart:
                 for (i = 0; i < nr_found; i++) {
                         if (!batch[i])
                                 continue;
+                        if ((iter_flags & XFS_AGITER_INEW_WAIT) &&
+                            xfs_iflags_test(batch[i], XFS_INEW))
+                                xfs_inew_wait(batch[i]);
                         error = execute(batch[i], flags, args);
                         IRELE(batch[i]);
                         if (error == -EAGAIN) {
@@ -637,12 +663,13 @@ xfs_eofblocks_worker(
 }
 
 int
-xfs_inode_ag_iterator(
+xfs_inode_ag_iterator_flags(
         struct xfs_mount        *mp,
         int                     (*execute)(struct xfs_inode *ip, int flags,
                                            void *args),
         int                     flags,
-        void                    *args)
+        void                    *args,
+        int                     iter_flags)
 {
         struct xfs_perag        *pag;
         int                     error = 0;
@@ -652,7 +679,8 @@ xfs_inode_ag_iterator(
         ag = 0;
         while ((pag = xfs_perag_get(mp, ag))) {
                 ag = pag->pag_agno + 1;
-                error = xfs_inode_ag_walk(mp, pag, execute, flags, args, -1);
+                error = xfs_inode_ag_walk(mp, pag, execute, flags, args, -1,
+                                          iter_flags);
                 xfs_perag_put(pag);
                 if (error) {
                         last_error = error;
@@ -664,6 +692,17 @@ xfs_inode_ag_iterator(
 }
 
 int
+xfs_inode_ag_iterator(
+        struct xfs_mount        *mp,
+        int                     (*execute)(struct xfs_inode *ip, int flags,
+                                           void *args),
+        int                     flags,
+        void                    *args)
+{
+        return xfs_inode_ag_iterator_flags(mp, execute, flags, args, 0);
+}
+
+int
 xfs_inode_ag_iterator_tag(
         struct xfs_mount        *mp,
         int                     (*execute)(struct xfs_inode *ip, int flags,
@@ -680,7 +719,8 @@ xfs_inode_ag_iterator_tag(
         ag = 0;
         while ((pag = xfs_perag_get_tag(mp, ag, tag))) {
                 ag = pag->pag_agno + 1;
-                error = xfs_inode_ag_walk(mp, pag, execute, flags, args, tag);
+                error = xfs_inode_ag_walk(mp, pag, execute, flags, args, tag,
+                                          0);
                 xfs_perag_put(pag);
                 if (error) {
                         last_error = error;