xfs: fix inode ag walk predicate function return values

There are a number of predicate functions that help the incore inode
walking code decide if we really want to apply the iteration function to
the inode.  These are boolean decisions, so change the return types to
boolean to match.

Signed-off-by: Darrick J. Wong <darrick.wong@oracle.com>
Reviewed-by: Christoph Hellwig <hch@lst.de>
Reviewed-by: Brian Foster <bfoster@redhat.com>

diff --git a/fs/xfs/xfs_icache.c b/fs/xfs/xfs_icache.c
index d10424a0015a07f54241e10d13d63ea63215e3d9..0f2edda5b08d6ea6e1c4b66f460db26efd07ca3b 100644 (file)
--- a/fs/xfs/xfs_icache.c
+++ b/fs/xfs/xfs_icache.c
@@ -761,7 +761,12 @@ xfs_icache_inode_is_allocated(
  */
 #define XFS_LOOKUP_BATCH       32
 
-STATIC int
+/*
+ * Decide if the given @ip is eligible to be a part of the inode walk, and
+ * grab it if so.  Returns true if it's ready to go or false if we should just
+ * ignore it.
+ */
+STATIC bool
 xfs_inode_ag_walk_grab(
        struct xfs_inode        *ip,
        int                     flags)
@@ -792,18 +797,18 @@ xfs_inode_ag_walk_grab(
 
        /* nothing to sync during shutdown */
        if (XFS_FORCED_SHUTDOWN(ip->i_mount))
-               return -EFSCORRUPTED;
+               return false;
 
        /* If we can't grab the inode, it must on it's way to reclaim. */
        if (!igrab(inode))
-               return -ENOENT;
+               return false;
 
        /* inode is valid */
-       return 0;
+       return true;
 
 out_unlock_noent:
        spin_unlock(&ip->i_flags_lock);
-       return -ENOENT;
+       return false;
 }
 
 STATIC int
@@ -855,7 +860,7 @@ restart:
                for (i = 0; i < nr_found; i++) {
                        struct xfs_inode *ip = batch[i];
 
-                       if (done || xfs_inode_ag_walk_grab(ip, iter_flags))
+                       if (done || !xfs_inode_ag_walk_grab(ip, iter_flags))
                                batch[i] = NULL;
 
                        /*
@@ -1412,48 +1417,48 @@ xfs_reclaim_inodes_count(
        return reclaimable;
 }
 
-STATIC int
+STATIC bool
 xfs_inode_match_id(
        struct xfs_inode        *ip,
        struct xfs_eofblocks    *eofb)
 {
        if ((eofb->eof_flags & XFS_EOF_FLAGS_UID) &&
            !uid_eq(VFS_I(ip)->i_uid, eofb->eof_uid))
-               return 0;
+               return false;
 
        if ((eofb->eof_flags & XFS_EOF_FLAGS_GID) &&
            !gid_eq(VFS_I(ip)->i_gid, eofb->eof_gid))
-               return 0;
+               return false;
 
        if ((eofb->eof_flags & XFS_EOF_FLAGS_PRID) &&
            ip->i_d.di_projid != eofb->eof_prid)
-               return 0;
+               return false;
 
-       return 1;
+       return true;
 }
 
 /*
  * A union-based inode filtering algorithm. Process the inode if any of the
  * criteria match. This is for global/internal scans only.
  */
-STATIC int
+STATIC bool
 xfs_inode_match_id_union(
        struct xfs_inode        *ip,
        struct xfs_eofblocks    *eofb)
 {
        if ((eofb->eof_flags & XFS_EOF_FLAGS_UID) &&
            uid_eq(VFS_I(ip)->i_uid, eofb->eof_uid))
-               return 1;
+               return true;
 
        if ((eofb->eof_flags & XFS_EOF_FLAGS_GID) &&
            gid_eq(VFS_I(ip)->i_gid, eofb->eof_gid))
-               return 1;
+               return true;
 
        if ((eofb->eof_flags & XFS_EOF_FLAGS_PRID) &&
            ip->i_d.di_projid == eofb->eof_prid)
-               return 1;
+               return true;
 
-       return 0;
+       return false;
 }
 
 /*
@@ -1466,7 +1471,7 @@ xfs_inode_matches_eofb(
        struct xfs_inode        *ip,
        struct xfs_eofblocks    *eofb)
 {
-       int                     match;
+       bool                    match;
 
        if (!eofb)
                return true;