xfs: standardize GFP flags usage in online scrub

Memory allocation usage is the same throughout online fsck -- we want
kernel memory, we have to be able to back out if we can't allocate
memory, and we don't want to spray dmesg with memory allocation failure
reports.  Standardize the GFP flag usage and document these requirements.

Signed-off-by: Darrick J. Wong <djwong@kernel.org>
Reviewed-by: Dave Chinner <dchinner@redhat.com>

diff --git a/fs/xfs/scrub/agheader.c b/fs/xfs/scrub/agheader.c
index af284baa6f4cb9de8fc5fb7b5b550d90a89ea1d0..4dd52b15f09c64b00a8834d71a275f5ec6d0ab94 100644 (file)
--- a/fs/xfs/scrub/agheader.c
+++ b/fs/xfs/scrub/agheader.c
@@ -737,7 +737,7 @@ xchk_agfl(
                goto out;
        }
        sai.entries = kvcalloc(sai.agflcount, sizeof(xfs_agblock_t),
-                       GFP_KERNEL | __GFP_RETRY_MAYFAIL);
+                              XCHK_GFP_FLAGS);
        if (!sai.entries) {
                error = -ENOMEM;
                goto out;

diff --git a/fs/xfs/scrub/attr.c b/fs/xfs/scrub/attr.c
index b6f0c9f3f1245ef9dd5a6e68755e65ea689847f0..11b2593a2be792d7afa9206d9dda27b5f8701142 100644 (file)
--- a/fs/xfs/scrub/attr.c
+++ b/fs/xfs/scrub/attr.c
@@ -79,7 +79,8 @@ xchk_setup_xattr(
         * without the inode lock held, which means we can sleep.
         */
        if (sc->flags & XCHK_TRY_HARDER) {
-               error = xchk_setup_xattr_buf(sc, XATTR_SIZE_MAX, GFP_KERNEL);
+               error = xchk_setup_xattr_buf(sc, XATTR_SIZE_MAX,
+                               XCHK_GFP_FLAGS);
                if (error)
                        return error;
        }
@@ -138,8 +139,7 @@ xchk_xattr_listent(
         * doesn't work, we overload the seen_enough variable to convey
         * the error message back to the main scrub function.
         */
-       error = xchk_setup_xattr_buf(sx->sc, valuelen,
-                       GFP_KERNEL | __GFP_RETRY_MAYFAIL);
+       error = xchk_setup_xattr_buf(sx->sc, valuelen, XCHK_GFP_FLAGS);
        if (error == -ENOMEM)
                error = -EDEADLOCK;
        if (error) {
@@ -324,8 +324,7 @@ xchk_xattr_block(
                return 0;
 
        /* Allocate memory for block usage checking. */
-       error = xchk_setup_xattr_buf(ds->sc, 0,
-                       GFP_KERNEL | __GFP_RETRY_MAYFAIL);
+       error = xchk_setup_xattr_buf(ds->sc, 0, XCHK_GFP_FLAGS);
        if (error == -ENOMEM)
                return -EDEADLOCK;
        if (error)

diff --git a/fs/xfs/scrub/scrub.h b/fs/xfs/scrub/scrub.h
index 151567f88366588a870612a5df90a6ccffd436d7..a0f097b8acb0a2f970abe5fd5a239d91b03e20a1 100644 (file)
--- a/fs/xfs/scrub/scrub.h
+++ b/fs/xfs/scrub/scrub.h
@@ -8,6 +8,15 @@
 
 struct xfs_scrub;
 
+/*
+ * Standard flags for allocating memory within scrub.  NOFS context is
+ * configured by the process allocation scope.  Scrub and repair must be able
+ * to back out gracefully if there isn't enough memory.  Force-cast to avoid
+ * complaints from static checkers.
+ */
+#define XCHK_GFP_FLAGS ((__force gfp_t)(GFP_KERNEL | __GFP_NOWARN | \
+                                        __GFP_RETRY_MAYFAIL))
+
 /* Type info and names for the scrub types. */
 enum xchk_type {
        ST_NONE = 1,    /* disabled */

diff --git a/fs/xfs/scrub/symlink.c b/fs/xfs/scrub/symlink.c
index 75311f8daeeb8245cc052e67ed55dab3fda850d8..c1c99ffe7408ab54d22f44f91baeac66223a9538 100644 (file)
--- a/fs/xfs/scrub/symlink.c
+++ b/fs/xfs/scrub/symlink.c
@@ -21,7 +21,7 @@ xchk_setup_symlink(
        struct xfs_scrub        *sc)
 {
        /* Allocate the buffer without the inode lock held. */
-       sc->buf = kvzalloc(XFS_SYMLINK_MAXLEN + 1, GFP_KERNEL);
+       sc->buf = kvzalloc(XFS_SYMLINK_MAXLEN + 1, XCHK_GFP_FLAGS);
        if (!sc->buf)
                return -ENOMEM;