Minki/linux
1
0
Fork 1
mirror of https://github.com/torvalds/linux.git synced 2024-11-10 14:11:52 +00:00
Code Issues Packages Projects Releases Wiki Activity

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

Browse Source 
This reverts commit 788691464c.

It's not clear why, but it causes unexplained problems in entirely
unrelated xfs code.  The most likely explanation is some slab
corruption, possibly triggered due to CONFIG_SLUB_DEBUG_ON.  See [1].

It ends up having a few other problems too, like build errors on
arch/arc, and Geert reporting it using much more memory on m68k [3] (it
probably does so elsewhere too, but it is probably just more noticeable
on m68k).

The architecture issues (both build and memory use) are likely just
because this change effectively force-enabled STACKDEPOT (along with a
very bad default value for the stackdepot hash size).  But together with
the xfs issue, this all smells like "this commit was not ready" to me.

Link: https://lore.kernel.org/linux-xfs/YPE3l82acwgI2OiV@infradead.org/ [1]
Link: https://lore.kernel.org/lkml/202107150600.LkGNb4Vb-lkp@intel.com/ [2]
Link: https://lore.kernel.org/lkml/CAMuHMdW=eoVzM1Re5FVoEN87nKfiLmM2+Ah7eNu2KXEhCvbZyA@mail.gmail.com/ [3]
Reported-by: Christoph Hellwig <hch@infradead.org>
Reported-by: kernel test robot <lkp@intel.com>
Reported-by: Geert Uytterhoeven <geert@linux-m68k.org>
Cc: Andrew Morton <akpm@linux-foundation.org>
Cc: Vlastimil Babka <vbabka@suse.cz>
Cc: Randy Dunlap <rdunlap@infradead.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
This commit is contained in:
Linus Torvalds 2021-07-17 13:27:00 -07:00
parent 5d766d55d1
commit ae14c63a9f
2 changed files with 30 additions and 50 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
init/Kconfig
View File

@ -1847,7 +1847,6 @@ config SLUB_DEBUG
default y default y
bool "Enable SLUB debugging support" if EXPERT bool "Enable SLUB debugging support" if EXPERT
depends on SLUB && SYSFS depends on SLUB && SYSFS
select STACKDEPOT if STACKTRACE_SUPPORT
help help
SLUB has extensive debug support features. Disabling these can SLUB has extensive debug support features. Disabling these can
result in significant savings in code size. This also disables result in significant savings in code size. This also disables

79
mm/slub.c
View File

@ -26,7 +26,6 @@
#include <linux/cpuset.h> #include <linux/cpuset.h>
#include <linux/mempolicy.h> #include <linux/mempolicy.h>
#include <linux/ctype.h> #include <linux/ctype.h>
#include <linux/stackdepot.h>
#include <linux/debugobjects.h> #include <linux/debugobjects.h>
#include <linux/kallsyms.h> #include <linux/kallsyms.h>
#include <linux/kfence.h> #include <linux/kfence.h>
@ -207,8 +206,8 @@ static inline bool kmem_cache_has_cpu_partial(struct kmem_cache *s)
#define TRACK_ADDRS_COUNT 16 #define TRACK_ADDRS_COUNT 16
struct track { struct track {
unsigned long addr; /* Called from address */ unsigned long addr; /* Called from address */
#ifdef CONFIG_STACKDEPOT #ifdef CONFIG_STACKTRACE
depot_stack_handle_t handle; unsigned long addrs[TRACK_ADDRS_COUNT]; /* Called from address */
#endif #endif
int cpu; /* Was running on cpu */ int cpu; /* Was running on cpu */
int pid; /* Pid context */ int pid; /* Pid context */
@ -612,27 +611,22 @@ static struct track *get_track(struct kmem_cache *s, void *object,
return kasan_reset_tag(p + alloc); return kasan_reset_tag(p + alloc);
} }
#ifdef CONFIG_STACKDEPOT
static depot_stack_handle_t save_stack_depot_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, static void set_track(struct kmem_cache *s, void *object,
enum track_item alloc, unsigned long addr) enum track_item alloc, unsigned long addr)
{ {
struct track *p = get_track(s, object, alloc); struct track *p = get_track(s, object, alloc);
if (addr) { if (addr) {
#ifdef CONFIG_STACKDEPOT #ifdef CONFIG_STACKTRACE
p->handle = save_stack_depot_trace(GFP_NOWAIT); 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;
#endif #endif
p->addr = addr; p->addr = addr;
p->cpu = smp_processor_id(); p->cpu = smp_processor_id();
@ -659,19 +653,14 @@ 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", pr_err("%s in %pS age=%lu cpu=%u pid=%d\n",
s, (void *)t->addr, pr_time - t->when, t->cpu, t->pid); s, (void *)t->addr, pr_time - t->when, t->cpu, t->pid);
#ifdef CONFIG_STACKDEPOT #ifdef CONFIG_STACKTRACE
{ {
depot_stack_handle_t handle; int i;
unsigned long *entries; for (i = 0; i < TRACK_ADDRS_COUNT; i++)
unsigned int nr_entries; if (t->addrs[i])
pr_err("\t%pS\n", (void *)t->addrs[i]);
handle = READ_ONCE(t->handle); else
if (!handle) { break;
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 #endif
} }
@ -4045,26 +4034,18 @@ void kmem_obj_info(struct kmem_obj_info *kpp, void *object, struct page *page)
objp = fixup_red_left(s, objp); objp = fixup_red_left(s, objp);
trackp = get_track(s, objp, TRACK_ALLOC); trackp = get_track(s, objp, TRACK_ALLOC);
kpp->kp_ret = (void *)trackp->addr; kpp->kp_ret = (void *)trackp->addr;
#ifdef CONFIG_STACKDEPOT #ifdef CONFIG_STACKTRACE
{ for (i = 0; i < KS_ADDRS_COUNT && i < TRACK_ADDRS_COUNT; i++) {
depot_stack_handle_t handle; kpp->kp_stack[i] = (void *)trackp->addrs[i];
unsigned long *entries; if (!kpp->kp_stack[i])
unsigned int nr_entries; break;
}
handle = READ_ONCE(trackp->handle); trackp = get_track(s, objp, TRACK_FREE);
if (handle) { for (i = 0; i < KS_ADDRS_COUNT && i < TRACK_ADDRS_COUNT; i++) {
nr_entries = stack_depot_fetch(handle, &entries); kpp->kp_free_stack[i] = (void *)trackp->addrs[i];
for (i = 0; i < KS_ADDRS_COUNT && i < nr_entries; i++) if (!kpp->kp_free_stack[i])
kpp->kp_stack[i] = (void *)entries[i]; break;
}
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
#endif #endif