7 files changed, 47 insertions, 19 deletions

diff --git a/fs/xfs/kmem.h b/fs/xfs/kmem.h
index a6c8da40c70d..d6ea520162b2 100644
--- a/fs/xfs/kmem.h
+++ b/fs/xfs/kmem.h
@@ -50,7 +50,7 @@ kmem_flags_convert(xfs_km_flags_t flags)
                 lflags = GFP_ATOMIC | __GFP_NOWARN;
         } else {
                 lflags = GFP_KERNEL | __GFP_NOWARN;
-                if ((current->flags & PF_MEMALLOC_NOFS) || (flags & KM_NOFS))
+                if (flags & KM_NOFS)
                         lflags &= ~__GFP_FS;
         }
 
diff --git a/include/linux/gfp.h b/include/linux/gfp.h
index 978232a3b4ae..2bfcfd33e476 100644
--- a/include/linux/gfp.h
+++ b/include/linux/gfp.h
@@ -210,8 +210,16 @@ struct vm_area_struct;
  *
  * GFP_NOIO will use direct reclaim to discard clean pages or slab pages
  *   that do not require the starting of any physical IO.
+ *   Please try to avoid using this flag directly and instead use
+ *   memalloc_noio_{save,restore} to mark the whole scope which cannot
+ *   perform any IO with a short explanation why. All allocation requests
+ *   will inherit GFP_NOIO implicitly.
  *
  * GFP_NOFS will use direct reclaim but will not use any filesystem interfaces.
+ *   Please try to avoid using this flag directly and instead use
+ *   memalloc_nofs_{save,restore} to mark the whole scope which cannot/shouldn't
+ *   recurse into the FS layer with a short explanation why. All allocation
+ *   requests will inherit GFP_NOFS implicitly.
  *
  * GFP_USER is for userspace allocations that also need to be directly
  *   accessibly by the kernel or hardware. It is typically used by hardware
diff --git a/include/linux/sched.h b/include/linux/sched.h
index 8ac11465ac5b..993e7e25a3a5 100644
--- a/include/linux/sched.h
+++ b/include/linux/sched.h
@@ -1224,9 +1224,9 @@ extern struct pid *cad_pid;
 #define PF_USED_ASYNC           0x00004000      /* Used async_schedule*(), used by module init */
 #define PF_NOFREEZE             0x00008000      /* This thread should not be frozen */
 #define PF_FROZEN               0x00010000      /* Frozen for system suspend */
-#define PF_FSTRANS              0x00020000      /* Inside a filesystem transaction */
-#define PF_KSWAPD               0x00040000      /* I am kswapd */
-#define PF_MEMALLOC_NOIO        0x00080000      /* Allocating memory without IO involved */
+#define PF_KSWAPD               0x00020000      /* I am kswapd */
+#define PF_MEMALLOC_NOFS        0x00040000      /* All allocation requests will inherit GFP_NOFS */
+#define PF_MEMALLOC_NOIO        0x00080000      /* All allocation requests will inherit GFP_NOIO */
 #define PF_LESS_THROTTLE        0x00100000      /* Throttle me less: I clean memory */
 #define PF_KTHREAD              0x00200000      /* I am a kernel thread */
 #define PF_RANDOMIZE            0x00400000      /* Randomize virtual address space */
@@ -1237,8 +1237,6 @@ extern struct pid *cad_pid;
 #define PF_FREEZER_SKIP         0x40000000      /* Freezer should not count it as freezable */
 #define PF_SUSPEND_TASK         0x80000000      /* This thread called freeze_processes() and should not be frozen */
 
-#define PF_MEMALLOC_NOFS PF_FSTRANS     /* Transition to a more generic GFP_NOFS scope semantic */
-
 /*
  * Only the _current_ task can read/write to tsk->flags, but other
  * tasks can access tsk->flags in readonly mode for example
diff --git a/include/linux/sched/mm.h b/include/linux/sched/mm.h
index 830953ebb391..9daabe138c99 100644
--- a/include/linux/sched/mm.h
+++ b/include/linux/sched/mm.h
@@ -149,13 +149,21 @@ static inline bool in_vfork(struct task_struct *tsk)
         return ret;
 }
 
-/* __GFP_IO isn't allowed if PF_MEMALLOC_NOIO is set in current->flags
- * __GFP_FS is also cleared as it implies __GFP_IO.
+/*
+ * Applies per-task gfp context to the given allocation flags.
+ * PF_MEMALLOC_NOIO implies GFP_NOIO
+ * PF_MEMALLOC_NOFS implies GFP_NOFS
  */
-static inline gfp_t memalloc_noio_flags(gfp_t flags)
+static inline gfp_t current_gfp_context(gfp_t flags)
 {
+        /*
+         * NOIO implies both NOIO and NOFS and it is a weaker context
+         * so always make sure it makes precendence
+         */
         if (unlikely(current->flags & PF_MEMALLOC_NOIO))
                 flags &= ~(__GFP_IO | __GFP_FS);
+        else if (unlikely(current->flags & PF_MEMALLOC_NOFS))
+                flags &= ~__GFP_FS;
         return flags;
 }
 
@@ -171,4 +179,16 @@ static inline void memalloc_noio_restore(unsigned int flags)
         current->flags = (current->flags & ~PF_MEMALLOC_NOIO) | flags;
 }
 
+static inline unsigned int memalloc_nofs_save(void)
+{
+        unsigned int flags = current->flags & PF_MEMALLOC_NOFS;
+        current->flags |= PF_MEMALLOC_NOFS;
+        return flags;
+}
+
+static inline void memalloc_nofs_restore(unsigned int flags)
+{
+        current->flags = (current->flags & ~PF_MEMALLOC_NOFS) | flags;
+}
+
 #endif /* _LINUX_SCHED_MM_H */
diff --git a/kernel/locking/lockdep.c b/kernel/locking/lockdep.c
index f84294c9a018..fd440b5a3c75 100644
--- a/kernel/locking/lockdep.c
+++ b/kernel/locking/lockdep.c
@@ -2877,7 +2877,7 @@ static void __lockdep_trace_alloc(gfp_t gfp_mask, unsigned long flags)
         if (unlikely(!debug_locks))
                 return;
 
-        gfp_mask = memalloc_noio_flags(gfp_mask);
+        gfp_mask = current_gfp_context(gfp_mask);
 
         /* no reclaim without waiting on it */
         if (!(gfp_mask & __GFP_DIRECT_RECLAIM))
@@ -2888,7 +2888,7 @@ static void __lockdep_trace_alloc(gfp_t gfp_mask, unsigned long flags)
                 return;
 
         /* We're only interested __GFP_FS allocations for now */
-        if (!(gfp_mask & __GFP_FS))
+        if (!(gfp_mask & __GFP_FS) || (curr->flags & PF_MEMALLOC_NOFS))
                 return;
 
         /*
@@ -3954,7 +3954,7 @@ EXPORT_SYMBOL_GPL(lock_unpin_lock);
 
 void lockdep_set_current_reclaim_state(gfp_t gfp_mask)
 {
-        current->lockdep_reclaim_gfp = memalloc_noio_flags(gfp_mask);
+        current->lockdep_reclaim_gfp = current_gfp_context(gfp_mask);
 }
 
 void lockdep_clear_current_reclaim_state(void)
diff --git a/mm/page_alloc.c b/mm/page_alloc.c
index 34ac32428de8..7a3751e53f91 100644
--- a/mm/page_alloc.c
+++ b/mm/page_alloc.c
@@ -3951,10 +3951,12 @@ __alloc_pages_nodemask(gfp_t gfp_mask, unsigned int order,
                 goto out;
 
         /*
-         * Runtime PM, block IO and its error handling path can deadlock
-         * because I/O on the device might not complete.
+         * Apply scoped allocation constraints. This is mainly about GFP_NOFS
+         * resp. GFP_NOIO which has to be inherited for all allocation requests
+         * from a particular context which has been marked by
+         * memalloc_no{fs,io}_{save,restore}.
          */
-        alloc_mask = memalloc_noio_flags(gfp_mask);
+        alloc_mask = current_gfp_context(gfp_mask);
         ac.spread_dirty_pages = false;
 
         /*
@@ -7408,7 +7410,7 @@ int alloc_contig_range(unsigned long start, unsigned long end,
                 .zone = page_zone(pfn_to_page(start)),
                 .mode = MIGRATE_SYNC,
                 .ignore_skip_hint = true,
-                .gfp_mask = memalloc_noio_flags(gfp_mask),
+                .gfp_mask = current_gfp_context(gfp_mask),
         };
         INIT_LIST_HEAD(&cc.migratepages);
 
diff --git a/mm/vmscan.c b/mm/vmscan.c
index ec4555369e17..3ad66580b8b4 100644
--- a/mm/vmscan.c
+++ b/mm/vmscan.c
@@ -2915,7 +2915,7 @@ unsigned long try_to_free_pages(struct zonelist *zonelist, int order,
         unsigned long nr_reclaimed;
         struct scan_control sc = {
                 .nr_to_reclaim = SWAP_CLUSTER_MAX,
-                .gfp_mask = (gfp_mask = memalloc_noio_flags(gfp_mask)),
+                .gfp_mask = (gfp_mask = current_gfp_context(gfp_mask)),
                 .reclaim_idx = gfp_zone(gfp_mask),
                 .order = order,
                 .nodemask = nodemask,
@@ -2995,7 +2995,7 @@ unsigned long try_to_free_mem_cgroup_pages(struct mem_cgroup *memcg,
         int nid;
         struct scan_control sc = {
                 .nr_to_reclaim = max(nr_pages, SWAP_CLUSTER_MAX),
-                .gfp_mask = (gfp_mask & GFP_RECLAIM_MASK) |
+                .gfp_mask = (current_gfp_context(gfp_mask) & GFP_RECLAIM_MASK) |
                                 (GFP_HIGHUSER_MOVABLE & ~GFP_RECLAIM_MASK),
                 .reclaim_idx = MAX_NR_ZONES - 1,
                 .target_mem_cgroup = memcg,
@@ -3702,7 +3702,7 @@ static int __node_reclaim(struct pglist_data *pgdat, gfp_t gfp_mask, unsigned in
         int classzone_idx = gfp_zone(gfp_mask);
         struct scan_control sc = {
                 .nr_to_reclaim = max(nr_pages, SWAP_CLUSTER_MAX),
-                .gfp_mask = (gfp_mask = memalloc_noio_flags(gfp_mask)),
+                .gfp_mask = (gfp_mask = current_gfp_context(gfp_mask)),
                 .order = order,
                 .priority = NODE_RECLAIM_PRIORITY,
                 .may_writepage = !!(node_reclaim_mode & RECLAIM_WRITE),