xfs: check for race with xfs_reclaim_inode() in xfs_ifree_cluster()

After xfs_ifree_cluster() finds an inode in the radix tree and verifies
that the inode number is what it expected, xfs_reclaim_inode() can swoop
in and free it. xfs_ifree_cluster() will then happily continue working
on the freed inode. Most importantly, it will mark the inode stale,
which will probably be overwritten when the inode slab object is
reallocated, but if it has already been reallocated then we can end up
with an inode spuriously marked stale.

In 8a17d7ddedb4 ("xfs: mark reclaimed inodes invalid earlier") we added
a second check to xfs_iflush_cluster() to detect this race, but the
similar RCU lookup in xfs_ifree_cluster() needs the same treatment.

Signed-off-by: Omar Sandoval <osandov@fb.com>
Reviewed-by: Brian Foster <bfoster@redhat.com>
Reviewed-by: Darrick J. Wong <darrick.wong@oracle.com>
Signed-off-by: Darrick J. Wong <darrick.wong@oracle.com>

diff --git a/fs/xfs/xfs_icache.c b/fs/xfs/xfs_icache.c
index 0a9e6985a0d092ff8493347c597b1b509c9048ef..34227115a5d6e7c22ee05ce8c90a70bec1701762 100644 (file)
--- a/fs/xfs/xfs_icache.c
+++ b/fs/xfs/xfs_icache.c
@@ -1124,11 +1124,11 @@ reclaim:
         * Because we use RCU freeing we need to ensure the inode always appears
         * to be reclaimed with an invalid inode number when in the free state.
         * We do this as early as possible under the ILOCK so that
-        * xfs_iflush_cluster() can be guaranteed to detect races with us here.
-        * By doing this, we guarantee that once xfs_iflush_cluster has locked
-        * XFS_ILOCK that it will see either a valid, flushable inode that will
-        * serialise correctly, or it will see a clean (and invalid) inode that
-        * it can skip.
+        * xfs_iflush_cluster() and xfs_ifree_cluster() can be guaranteed to
+        * detect races with us here. By doing this, we guarantee that once
+        * xfs_iflush_cluster() or xfs_ifree_cluster() has locked XFS_ILOCK that
+        * it will see either a valid inode that will serialise correctly, or it
+        * will see an invalid inode that it can skip.
         */
        spin_lock(&ip->i_flags_lock);
        ip->i_flags = XFS_IRECLAIM;

diff --git a/fs/xfs/xfs_inode.c b/fs/xfs/xfs_inode.c
index ff48f00968100df0de830892f0c9aed7bca6d74d..97045e8dfed5f9529931ffc72b9bec5442cfc5de 100644 (file)
--- a/fs/xfs/xfs_inode.c
+++ b/fs/xfs/xfs_inode.c
@@ -2359,11 +2359,24 @@ retry:
                         * already marked stale. If we can't lock it, back off
                         * and retry.
                         */
-                       if (ip != free_ip &&
-                           !xfs_ilock_nowait(ip, XFS_ILOCK_EXCL)) {
-                               rcu_read_unlock();
-                               delay(1);
-                               goto retry;
+                       if (ip != free_ip) {
+                               if (!xfs_ilock_nowait(ip, XFS_ILOCK_EXCL)) {
+                                       rcu_read_unlock();
+                                       delay(1);
+                                       goto retry;
+                               }
+
+                               /*
+                                * Check the inode number again in case we're
+                                * racing with freeing in xfs_reclaim_inode().
+                                * See the comments in that function for more
+                                * information as to why the initial check is
+                                * not sufficient.
+                                */
+                               if (ip->i_ino != inum + i) {
+                                       xfs_iunlock(ip, XFS_ILOCK_EXCL);
+                                       continue;
+                               }
                        }
                        rcu_read_unlock();