mm/slub: use stackdepot to save stack trace in objects

Many stack traces are similar so there are many similar arrays.
Stackdepot saves each unique stack only once.

Replace field addrs in struct track with depot_stack_handle_t handle.  Use
stackdepot to save stack trace.

The benefits are smaller memory overhead and possibility to aggregate
per-cache statistics in the future using the stackdepot handle instead of
matching stacks manually.

Link: https://lkml.kernel.org/r/20210414163434.4376-1-glittao@gmail.com
Signed-off-by: Oliver Glitta <glittao@gmail.com>
Reviewed-by: Vlastimil Babka <vbabka@suse.cz>
Acked-by: David Rientjes <rientjes@google.com>
Cc: Christoph Lameter <cl@linux.com>
Cc: Pekka Enberg <penberg@kernel.org>
Cc: Joonsoo Kim <iamjoonsoo.kim@lge.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Stephen Rothwell <sfr@canb.auug.org.au>

diff --git a/init/Kconfig b/init/Kconfig
index b075234001a36ffb6cb60defda990dcac9e9eb73..173a474012d7f4a610b1b1dd8dfaf5f95420b21b 100644 (file)
--- a/init/Kconfig
+++ b/init/Kconfig
@@ -1853,6 +1853,7 @@ config SLUB_DEBUG
        default y
        bool "Enable SLUB debugging support" if EXPERT
        depends on SLUB && SYSFS
+       select STACKDEPOT if STACKTRACE_SUPPORT
        help
          SLUB has extensive debug support features. Disabling these can
          result in significant savings in code size. This also disables

diff --git a/mm/slub.c b/mm/slub.c
index 77c8bb5eca1e1b6cd67000374952cdca6050bc92..d800edb25d3ec2aa1ffe5b8a278e98f4871e70c0 100644 (file)
--- a/mm/slub.c
+++ b/mm/slub.c
@@ -25,6 +25,7 @@
 #include <linux/cpuset.h>
 #include <linux/mempolicy.h>
 #include <linux/ctype.h>
+#include <linux/stackdepot.h>
 #include <linux/debugobjects.h>
 #include <linux/kallsyms.h>
 #include <linux/kfence.h>
@@ -218,8 +219,8 @@ static inline bool kmem_cache_has_cpu_partial(struct kmem_cache *s)
 #define TRACK_ADDRS_COUNT 16
 struct track {
        unsigned long addr;     /* Called from address */
-#ifdef CONFIG_STACKTRACE
-       unsigned long addrs[TRACK_ADDRS_COUNT]; /* Called from address */
+#ifdef CONFIG_STACKDEPOT
+       depot_stack_handle_t handle;
 #endif
        int cpu;                /* Was running on cpu */
        int pid;                /* Pid context */
@@ -617,22 +618,27 @@ static struct track *get_track(struct kmem_cache *s, void *object,
        return kasan_reset_tag(p + alloc);
 }
 
+#ifdef CONFIG_STACKDEPOT
+static depot_stack_handle_t save_stack_trace(gfp_t flags)
+{
+       unsigned long entries[TRACK_ADDRS_COUNT];
+       depot_stack_handle_t handle;
+       unsigned int nr_entries;
+
+       nr_entries = stack_trace_save(entries, ARRAY_SIZE(entries), 4);
+       handle = stack_depot_save(entries, nr_entries, flags);
+       return handle;
+}
+#endif
+
 static void set_track(struct kmem_cache *s, void *object,
                        enum track_item alloc, unsigned long addr)
 {
        struct track *p = get_track(s, object, alloc);
 
        if (addr) {
-#ifdef CONFIG_STACKTRACE
-               unsigned int nr_entries;
-
-               metadata_access_enable();
-               nr_entries = stack_trace_save(kasan_reset_tag(p->addrs),
-                                             TRACK_ADDRS_COUNT, 3);
-               metadata_access_disable();
-
-               if (nr_entries < TRACK_ADDRS_COUNT)
-                       p->addrs[nr_entries] = 0;
+#ifdef CONFIG_STACKDEPOT
+               p->handle = save_stack_trace(GFP_KERNEL);
 #endif
                p->addr = addr;
                p->cpu = smp_processor_id();
@@ -659,14 +665,19 @@ static void print_track(const char *s, struct track *t, unsigned long pr_time)
 
        pr_err("%s in %pS age=%lu cpu=%u pid=%d\n",
               s, (void *)t->addr, pr_time - t->when, t->cpu, t->pid);
-#ifdef CONFIG_STACKTRACE
+#ifdef CONFIG_STACKDEPOT
        {
-               int i;
-               for (i = 0; i < TRACK_ADDRS_COUNT; i++)
-                       if (t->addrs[i])
-                               pr_err("\t%pS\n", (void *)t->addrs[i]);
-                       else
-                               break;
+               depot_stack_handle_t handle;
+               unsigned long *entries;
+               unsigned int nr_entries;
+
+               handle = READ_ONCE(t->handle);
+               if (!handle) {
+                       pr_err("object allocation/free stack trace missing\n");
+               } else {
+                       nr_entries = stack_depot_fetch(handle, &entries);
+                       stack_trace_print(entries, nr_entries, 0);
+               }
        }
 #endif
 }
@@ -4045,18 +4056,26 @@ void kmem_obj_info(struct kmem_obj_info *kpp, void *object, struct page *page)
        objp = fixup_red_left(s, objp);
        trackp = get_track(s, objp, TRACK_ALLOC);
        kpp->kp_ret = (void *)trackp->addr;
-#ifdef CONFIG_STACKTRACE
-       for (i = 0; i < KS_ADDRS_COUNT && i < TRACK_ADDRS_COUNT; i++) {
-               kpp->kp_stack[i] = (void *)trackp->addrs[i];
-               if (!kpp->kp_stack[i])
-                       break;
-       }
+#ifdef CONFIG_STACKDEPOT
+       {
+               depot_stack_handle_t handle;
+               unsigned long *entries;
+               unsigned int nr_entries;
 
-       trackp = get_track(s, objp, TRACK_FREE);
-       for (i = 0; i < KS_ADDRS_COUNT && i < TRACK_ADDRS_COUNT; i++) {
-               kpp->kp_free_stack[i] = (void *)trackp->addrs[i];
-               if (!kpp->kp_free_stack[i])
-                       break;
+               handle = READ_ONCE(trackp->handle);
+               if (handle) {
+                       nr_entries = stack_depot_fetch(handle, &entries);
+                       for (i = 0; i < KS_ADDRS_COUNT && i < nr_entries; i++)
+                               kpp->kp_stack[i] = (void *)entries[i];
+               }
+
+               trackp = get_track(s, objp, TRACK_FREE);
+               handle = READ_ONCE(trackp->handle);
+               if (handle) {
+                       nr_entries = stack_depot_fetch(handle, &entries);
+                       for (i = 0; i < KS_ADDRS_COUNT && i < nr_entries; i++)
+                               kpp->kp_free_stack[i] = (void *)entries[i];
+               }
        }
 #endif
 #endif