locking/lockdep: Rework FS_RECLAIM annotation

A while ago someone, and I cannot find the email just now, asked if we
could not implement the RECLAIM_FS inversion stuff with a 'fake' lock
like we use for other things like workqueues etc. I think this should
be possible which allows reducing the 'irq' states and will reduce the
amount of __bfs() lookups we do.

Removing the 1 IRQ state results in 4 less __bfs() walks per
dependency, improving lockdep performance. And by moving this
annotation out of the lockdep code it becomes easier for the mm people
to extend.

Signed-off-by: Peter Zijlstra (Intel) <peterz@infradead.org>
Cc: Byungchul Park <byungchul.park@lge.com>
Cc: Linus Torvalds <torvalds@linux-foundation.org>
Cc: Mel Gorman <mgorman@suse.de>
Cc: Michal Hocko <mhocko@kernel.org>
Cc: Nikolay Borisov <nborisov@suse.com>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Thomas Gleixner <tglx@linutronix.de>
Cc: akpm@linux-foundation.org
Cc: boqun.feng@gmail.com
Cc: iamjoonsoo.kim@lge.com
Cc: kernel-team@lge.com
Cc: kirill@shutemov.name
Cc: npiggin@gmail.com
Cc: walken@google.com
Signed-off-by: Ingo Molnar <mingo@kernel.org>

1 files changed, 46 insertions, 3 deletions

diff --git a/mm/page_alloc.c b/mm/page_alloc.c
index fc32aa81f359..c20d89601802 100644
--- a/mm/page_alloc.c
+++ b/mm/page_alloc.c
@@ -66,6 +66,7 @@
 #include <linux/kthread.h>
 #include <linux/memcontrol.h>
 #include <linux/ftrace.h>
+#include <linux/lockdep.h>
 
 #include <asm/sections.h>
 #include <asm/tlbflush.h>
@@ -3490,6 +3491,47 @@ should_compact_retry(struct alloc_context *ac, unsigned int order, int alloc_fla
 }
 #endif /* CONFIG_COMPACTION */
 
+#ifdef CONFIG_LOCKDEP
+struct lockdep_map __fs_reclaim_map =
+        STATIC_LOCKDEP_MAP_INIT("fs_reclaim", &__fs_reclaim_map);
+
+static bool __need_fs_reclaim(gfp_t gfp_mask)
+{
+        gfp_mask = current_gfp_context(gfp_mask);
+
+        /* no reclaim without waiting on it */
+        if (!(gfp_mask & __GFP_DIRECT_RECLAIM))
+                return false;
+
+        /* this guy won't enter reclaim */
+        if ((current->flags & PF_MEMALLOC) && !(gfp_mask & __GFP_NOMEMALLOC))
+                return false;
+
+        /* We're only interested __GFP_FS allocations for now */
+        if (!(gfp_mask & __GFP_FS))
+                return false;
+
+        if (gfp_mask & __GFP_NOLOCKDEP)
+                return false;
+
+        return true;
+}
+
+void fs_reclaim_acquire(gfp_t gfp_mask)
+{
+        if (__need_fs_reclaim(gfp_mask))
+                lock_map_acquire(&__fs_reclaim_map);
+}
+EXPORT_SYMBOL_GPL(fs_reclaim_acquire);
+
+void fs_reclaim_release(gfp_t gfp_mask)
+{
+        if (__need_fs_reclaim(gfp_mask))
+                lock_map_release(&__fs_reclaim_map);
+}
+EXPORT_SYMBOL_GPL(fs_reclaim_release);
+#endif
+
 /* Perform direct synchronous page reclaim */
 static int
 __perform_reclaim(gfp_t gfp_mask, unsigned int order,
@@ -3504,7 +3546,7 @@ __perform_reclaim(gfp_t gfp_mask, unsigned int order,
         /* We now go into synchronous reclaim */
         cpuset_memory_pressure_bump();
         noreclaim_flag = memalloc_noreclaim_save();
-        lockdep_set_current_reclaim_state(gfp_mask);
+        fs_reclaim_acquire(gfp_mask);
         reclaim_state.reclaimed_slab = 0;
         current->reclaim_state = &reclaim_state;
 
@@ -3512,7 +3554,7 @@ __perform_reclaim(gfp_t gfp_mask, unsigned int order,
                                                                 ac->nodemask);
 
         current->reclaim_state = NULL;
-        lockdep_clear_current_reclaim_state();
+        fs_reclaim_release(gfp_mask);
         memalloc_noreclaim_restore(noreclaim_flag);
 
         cond_resched();
@@ -4041,7 +4083,8 @@ static inline bool prepare_alloc_pages(gfp_t gfp_mask, unsigned int order,
                         *alloc_flags |= ALLOC_CPUSET;
         }
 
-        lockdep_trace_alloc(gfp_mask);
+        fs_reclaim_acquire(gfp_mask);
+        fs_reclaim_release(gfp_mask);
 
         might_sleep_if(gfp_mask & __GFP_DIRECT_RECLAIM);