gfs2: Prevent recursive memory reclaim

Function new_inode() returns a new inode with inode->i_mapping->gfp_mask
set to GFP_HIGHUSER_MOVABLE.  This value includes the __GFP_FS flag, so
allocations in that address space can recurse into filesystem memory
reclaim.  We don't want that to happen because it can consume a
significant amount of stack memory.

Worse than that is that it can also deadlock: for example, in several
places, gfs2_unstuff_dinode() is called inside filesystem transactions.
This calls filemap_grab_folio(), which can allocate a new folio, which
can trigger memory reclaim.  If memory reclaim recurses into the
filesystem and starts another transaction, a deadlock will ensue.

To fix these kinds of problems, prevent memory reclaim from recursing
into filesystem code by making sure that the gfp_mask of inode address
spaces doesn't include __GFP_FS.

The "meta" and resource group address spaces were already using GFP_NOFS
as their gfp_mask (which doesn't include __GFP_FS).  The default value
of GFP_HIGHUSER_MOVABLE is less restrictive than GFP_NOFS, though.  To
avoid being overly limiting, use the default value and only knock off
the __GFP_FS flag.  I'm not sure if this will actually make a
difference, but it also shouldn't hurt.

This patch is loosely based on commit ad22c7a043c2 ("xfs: prevent stack
overflows from page cache allocation").

Fixes xfstest generic/273.

Fixes: dc0b9435238c ("gfs: Don't use GFP_NOFS in gfs2_unstuff_dinode")
Reviewed-by: Andrew Price <anprice@redhat.com>
Signed-off-by: Andreas Gruenbacher <agruenba@redhat.com>

diff --git a/fs/gfs2/glock.c b/fs/gfs2/glock.c
index 938bda75a338ec8aee0899824ab0cc4d5b50324a..aeeef9c3a6b7e7c27cc8bb65d2e78793f07db051 100644 (file)
--- a/fs/gfs2/glock.c
+++ b/fs/gfs2/glock.c
@@ -1211,10 +1211,13 @@ int gfs2_glock_get(struct gfs2_sbd *sdp, u64 number,
 
        mapping = gfs2_glock2aspace(gl);
        if (mapping) {
+               gfp_t gfp_mask;
+
                 mapping->a_ops = &gfs2_meta_aops;
                mapping->host = sdp->sd_inode;
                mapping->flags = 0;
-               mapping_set_gfp_mask(mapping, GFP_NOFS);
+               gfp_mask = mapping_gfp_mask(sdp->sd_inode->i_mapping);
+               mapping_set_gfp_mask(mapping, gfp_mask);
                mapping->i_private_data = NULL;
                mapping->writeback_index = 0;
        }

diff --git a/fs/gfs2/inode.c b/fs/gfs2/inode.c
index 8a7ed80d9f2d6e829b240629bdd18b5e0d30b5fc..d7e35a05c1610cebef8becefb6e3ac8a4ccd0ed3 100644 (file)
--- a/fs/gfs2/inode.c
+++ b/fs/gfs2/inode.c
@@ -89,6 +89,19 @@ static int iget_set(struct inode *inode, void *opaque)
        return 0;
 }
 
+void gfs2_setup_inode(struct inode *inode)
+{
+       gfp_t gfp_mask;
+
+       /*
+        * Ensure all page cache allocations are done from GFP_NOFS context to
+        * prevent direct reclaim recursion back into the filesystem and blowing
+        * stacks or deadlocking.
+        */
+       gfp_mask = mapping_gfp_mask(inode->i_mapping);
+       mapping_set_gfp_mask(inode->i_mapping, gfp_mask & ~__GFP_FS);
+}
+
 /**
  * gfs2_inode_lookup - Lookup an inode
  * @sb: The super block
@@ -132,6 +145,7 @@ struct inode *gfs2_inode_lookup(struct super_block *sb, unsigned int type,
                struct gfs2_glock *io_gl;
                int extra_flags = 0;
 
+               gfs2_setup_inode(inode);
                error = gfs2_glock_get(sdp, no_addr, &gfs2_inode_glops, CREATE,
                                       &ip->i_gl);
                if (unlikely(error))
@@ -752,6 +766,7 @@ static int gfs2_create_inode(struct inode *dir, struct dentry *dentry,
        error = -ENOMEM;
        if (!inode)
                goto fail_gunlock;
+       gfs2_setup_inode(inode);
        ip = GFS2_I(inode);
 
        error = posix_acl_create(dir, &mode, &default_acl, &acl);

diff --git a/fs/gfs2/inode.h b/fs/gfs2/inode.h
index e43f08eb26e7299a864eaf69c1430d2d5df11971..2fcd96dd13613900afc702e0ebdcf960f33d5068 100644 (file)
--- a/fs/gfs2/inode.h
+++ b/fs/gfs2/inode.h
@@ -86,6 +86,7 @@ err:
        return -EIO;
 }
 
+void gfs2_setup_inode(struct inode *inode);
 struct inode *gfs2_inode_lookup(struct super_block *sb, unsigned type,
                                u64 no_addr, u64 no_formal_ino,
                                unsigned int blktype);

diff --git a/fs/gfs2/ops_fstype.c b/fs/gfs2/ops_fstype.c
index aa15183f9a168e7c4404d8ae41fad3910dc02be9..1a2db8053da04c6587bf7e753e70c3708f6dfa18 100644 (file)
--- a/fs/gfs2/ops_fstype.c
+++ b/fs/gfs2/ops_fstype.c
@@ -1183,7 +1183,7 @@ static int gfs2_fill_super(struct super_block *sb, struct fs_context *fc)
 
        mapping = gfs2_aspace(sdp);
        mapping->a_ops = &gfs2_rgrp_aops;
-       mapping_set_gfp_mask(mapping, GFP_NOFS);
+       gfs2_setup_inode(sdp->sd_inode);
 
        error = init_names(sdp, silent);
        if (error)