2 files changed, 27 insertions, 20 deletions

diff --git a/fs/xfs/xfs_inode.c b/fs/xfs/xfs_inode.c
index 6d5641ff08f6..597e0ed4d2b6 100644
--- a/fs/xfs/xfs_inode.c
+++ b/fs/xfs/xfs_inode.c
@@ -1953,24 +1953,6 @@ xfs_iunlink(
         ASSERT(agi->agi_unlinked[bucket_index]);
         ASSERT(be32_to_cpu(agi->agi_unlinked[bucket_index]) != agino);
 
-        error = xfs_itobp(mp, tp, ip, &dip, &ibp, 0, 0);
-        if (error)
-                return error;
-
-        /*
-         * Clear the on-disk di_nlink. This is to prevent xfs_bulkstat
-         * from picking up this inode when it is reclaimed (its incore state
-         * initialzed but not flushed to disk yet). The in-core di_nlink is
-         * already cleared in xfs_droplink() and a corresponding transaction
-         * logged. The hack here just synchronizes the in-core to on-disk
-         * di_nlink value in advance before the actual inode sync to disk.
-         * This is OK because the inode is already unlinked and would never
-         * change its di_nlink again for this inode generation.
-         * This is a temporary hack that would require a proper fix
-         * in the future.
-         */
-        dip->di_core.di_nlink = 0;
-
         if (be32_to_cpu(agi->agi_unlinked[bucket_index]) != NULLAGINO) {
                 /*
                  * There is already another inode in the bucket we need
@@ -1978,6 +1960,10 @@ xfs_iunlink(
                  * Here we put the head pointer into our next pointer,
                  * and then we fall through to point the head at us.
                  */
+                error = xfs_itobp(mp, tp, ip, &dip, &ibp, 0, 0);
+                if (error)
+                        return error;
+
                 ASSERT(be32_to_cpu(dip->di_next_unlinked) == NULLAGINO);
                 /* both on-disk, don't endian flip twice */
                 dip->di_next_unlinked = agi->agi_unlinked[bucket_index];
@@ -2367,6 +2353,8 @@ xfs_ifree(
         int                     error;
         int                     delete;
         xfs_ino_t               first_ino;
+        xfs_dinode_t            *dip;
+        xfs_buf_t               *ibp;
 
         ASSERT(ismrlocked(&ip->i_lock, MR_UPDATE));
         ASSERT(ip->i_transp == tp);
@@ -2402,8 +2390,27 @@ xfs_ifree(
          * by reincarnations of this inode.
          */
         ip->i_d.di_gen++;
+
         xfs_trans_log_inode(tp, ip, XFS_ILOG_CORE);
 
+        error = xfs_itobp(ip->i_mount, tp, ip, &dip, &ibp, 0, 0);
+        if (error)
+                return error;
+
+        /*
+        * Clear the on-disk di_mode. This is to prevent xfs_bulkstat
+        * from picking up this inode when it is reclaimed (its incore state
+        * initialzed but not flushed to disk yet). The in-core di_mode is
+        * already cleared  and a corresponding transaction logged.
+        * The hack here just synchronizes the in-core to on-disk
+        * di_mode value in advance before the actual inode sync to disk.
+        * This is OK because the inode is already unlinked and would never
+        * change its di_mode again for this inode generation.
+        * This is a temporary hack that would require a proper fix
+        * in the future.
+        */
+        dip->di_core.di_mode = 0;
+
         if (delete) {
                 xfs_ifree_cluster(ip, tp, first_ino);
         }
diff --git a/fs/xfs/xfs_itable.c b/fs/xfs/xfs_itable.c
index 9fc4c2886529..d9ca3c0eb8cc 100644
--- a/fs/xfs/xfs_itable.c
+++ b/fs/xfs/xfs_itable.c
@@ -291,7 +291,7 @@ xfs_bulkstat_use_dinode(
         dip = (xfs_dinode_t *)
                         xfs_buf_offset(bp, clustidx << mp->m_sb.sb_inodelog);
         /*
-         * Check the buffer containing the on-disk inode for di_nlink == 0.
+         * Check the buffer containing the on-disk inode for di_mode == 0.
          * This is to prevent xfs_bulkstat from picking up just reclaimed
          * inodes that have their in-core state initialized but not flushed
          * to disk yet. This is a temporary hack that would require a proper
@@ -299,7 +299,7 @@ xfs_bulkstat_use_dinode(
          */
         if (be16_to_cpu(dip->di_core.di_magic) != XFS_DINODE_MAGIC ||
             !XFS_DINODE_GOOD_VERSION(dip->di_core.di_version) ||
-            !dip->di_core.di_nlink)
+            !dip->di_core.di_mode)
                 return 0;
         if (flags & BULKSTAT_FG_QUICK) {
                 *dipp = dip;