Revert "arm64: section_size_bits compatible with macro definitions"
by Guanyou Chen
Hi tao
crash load 5.12 before vmcore, parse section_size_bits equals 27,
but it should be equals 30. because defined "CONFIG_ARM64_4K_PAGES",
The commit "568c6f04" for compat android gki, so we should cleanup.
Exp:
Before:
crash vmcore vmlinux -d1
...
xtime timespec.tv_sec: 603549d0: Wed Feb 24 02:30:40 CST 2021
utsname:
sysname: Linux
nodename: localhost
release: 4.14.180-perf-g4483caa8ae80-dirty
version: #1 SMP PREEMPT Wed Feb 24 03:16:01 CST 2021
machine: aarch64
domainname: localdomain
...
SECTION_SIZE_BITS: 27
...
After:
crash vmcore vmlinux -d1
...
xtime timespec.tv_sec: 603549d0: Wed Feb 24 02:30:40 CST 2021
utsname:
sysname: Linux
nodename: localhost
release: 4.14.180-perf-g4483caa8ae80-dirty
version: #1 SMP PREEMPT Wed Feb 24 03:16:01 CST 2021
machine: aarch64
domainname: localdomain
...
SECTION_SIZE_BITS: 30
...
diff --git a/arm64.c b/arm64.c
index 06e7451..05ffdb3 100644
--- a/arm64.c
+++ b/arm64.c
@@ -1698,14 +1698,7 @@ arm64_get_section_size_bits(void)
if ((ret = get_kernel_config("CONFIG_MEMORY_HOTPLUG",
NULL)) == IKCONFIG_Y) {
if ((ret =
get_kernel_config("CONFIG_HOTPLUG_SIZE_BITS", &string)) == IKCONFIG_STR)
machdep->section_size_bits = atol(string);
- }
-
- /* arm64: reduce section size for sparsemem */
- if ((ret = get_kernel_config("CONFIG_ARM64_4K_PAGES",
NULL)) == IKCONFIG_Y
- || (ret =
get_kernel_config("CONFIG_ARM64_16K_PAGES", NULL)) == IKCONFIG_Y)
- machdep->section_size_bits =
_SECTION_SIZE_BITS_5_12;
- else if ((ret = get_kernel_config("CONFIG_ARM64_64K_PAGES",
NULL)) == IKCONFIG_Y)
- machdep->section_size_bits =
_SECTION_SIZE_BITS_5_12_64K;
+ }
}
if (CRASHDEBUG(1))
Thanks,
Guanyou.
2 months, 2 weeks
- 3
- 7
[PATCH] kmem: fix the determination for slab page
by qiwu.chen＠transsion.com
The determination for a slab page is changed since kernel commit
8db00ad564617 which migrates PG_slab flag from page flags to the
lower 16 bit of the page type.
Before apply this patch:
crash> kmem -s ffff000002aa4100
kmem: address is not allocated in slab subsystem: ffff000002aa4100
After apply this patch:
crash> kmem -s ffff000002aa4100
CACHE OBJSIZE ALLOCATED TOTAL SLABS SSIZE NAME
ffff00000140f900 4096 94 126 18 32k task_struct
SLAB MEMORY NODE TOTAL ALLOCATED FREE
fffffdffc00aa800 ffff000002aa0000 0 7 5 2
FREE / [ALLOCATED]
[ffff000002aa4100]
Signed-off-by: qiwu.chen <qiwu.chen(a)transsion.com>
---
defs.h | 1 +
memory.c | 23 +++++++++++++++++++----
2 files changed, 20 insertions(+), 4 deletions(-)
diff --git a/defs.h b/defs.h
index e9eb9e3..9ef7f97 100644
--- a/defs.h
+++ b/defs.h
@@ -2289,6 +2289,7 @@ struct offset_table { /* stash of commonly-used offsets */
long track_cpu;
long track_when;
long track_handle;
+ long page_page_type;
};
struct size_table { /* stash of commonly-used sizes */
diff --git a/memory.c b/memory.c
index 7bf8f86..f9ad6e4 100644
--- a/memory.c
+++ b/memory.c
@@ -509,6 +509,8 @@ vm_init(void)
ANON_MEMBER_OFFSET_INIT(page_compound_head, "page", "compound_head");
MEMBER_OFFSET_INIT(page_private, "page", "private");
MEMBER_OFFSET_INIT(page_freelist, "page", "freelist");
+ if (MEMBER_EXISTS("page", "page_type"))
+ MEMBER_OFFSET_INIT(page_page_type, "page", "page_type");
MEMBER_OFFSET_INIT(mm_struct_pgd, "mm_struct", "pgd");
@@ -10114,7 +10116,7 @@ static char *
vaddr_to_kmem_cache(ulong vaddr, char *buf, int verbose)
{
physaddr_t paddr;
- ulong page, cache, page_flags;
+ ulong page, cache, page_flags, page_type;
if (!kvtop(NULL, vaddr, &paddr, 0)) {
if (verbose)
@@ -10143,7 +10145,10 @@ vaddr_to_kmem_cache(ulong vaddr, char *buf, int verbose)
readmem(compound_head(page)+OFFSET(page_flags), KVADDR,
&page_flags, sizeof(ulong), "page.flags",
FAULT_ON_ERROR);
- if (!(page_flags & (1 << vt->PG_slab)))
+ readmem(page + OFFSET(page_page_type), KVADDR, &page_type,
+ sizeof(ulong), "page type", FAULT_ON_ERROR);
+ if (!(page_flags & (1 << vt->PG_slab)) &&
+ !(page_type & (1 << vt->PG_slab)))
return NULL;
} else
return NULL;
@@ -20688,7 +20693,7 @@ char *
is_slab_page(struct meminfo *si, char *buf)
{
int i, cnt;
- ulong page_slab, page_flags, name;
+ ulong page_slab, page_flags, page_type, name;
ulong *cache_list;
char *retval;
@@ -20703,7 +20708,17 @@ is_slab_page(struct meminfo *si, char *buf)
RETURN_ON_ERROR|QUIET))
return NULL;
- if (!(page_flags & (1 << vt->PG_slab)))
+ if (!readmem(si->spec_addr + OFFSET(page_page_type), KVADDR,
+ &page_type, sizeof(ulong), "page.page_type",
+ RETURN_ON_ERROR|QUIET))
+ return NULL;
+
+ /*
+ * PG_slab is migrated from the page flags to the lower 16 bit
+ * of the page type since linux commit 8db00ad564617.
+ */
+ if (!(page_flags & (1 << vt->PG_slab)) &&
+ !(page_type & (1 << vt->PG_slab)))
return NULL;
if (!readmem(si->spec_addr + OFFSET(page_slab), KVADDR,
--
2.25.1
3 months, 2 weeks
- 2
- 7
[PATCH] kmem: introduce -t flag to get page owner or slab debug trace
by qiwu.chen＠transsion.com
Introduce -t flag for kmem command to support getting page owner and
slab debug trace. Here is the user help manual:
1. Dump page_owner allocated stack trace for each allocated page in
buddy system when used with "kmem -pt":
crash> kmem -pt
Page allocated via order 0, mask 0x1112c4a, pid 1, ts 16155269152 ns
PFN 0x40000, type Movable, Flags 0xffff00000020836
set_page_owner+84
post_alloc_hook+308
prep_new_page+48
get_page_from_freelist+736
__alloc_pages+348
alloc_pages+280
__page_cache_alloc+120
page_cache_ra_unbounded+272
do_page_cache_ra+172
do_sync_mmap_readahead+492
filemap_fault+340
__do_fault+64
__handle_mm_fault+528
handle_mm_fault+208
__do_page_fault+232
do_page_fault+1264
......
2. Dump page_owner allocated/freed trace for an allocated page when used
"kmem -pt" with a page address.
3. Dump slab debug trace when used "-st" with an allocated slab object address:
crash> kmem -st ffff000007e79d00
CACHE OBJSIZE ALLOCATED TOTAL SLABS SSIZE NAME
ffff000001c0ed00 3392 93 104 13 32k task_struct
SLAB MEMORY NODE TOTAL ALLOCATED FREE
fffffc00001f9e00 ffff000007e78000 0 8 6 2
FREE / [ALLOCATED]
[ffff000007e79d00]
object ffff000007e79d00 allocated in alloc_task_struct_node+36 age=8431 cpu=2 pid=415
__slab_alloc+60
kmem_cache_alloc_node+528
alloc_task_struct_node+36
dup_task_struct+56
copy_process+724
kernel_clone+276
__do_sys_clone+152
__se_sys_clone+60
__arm64_sys_clone+88
__invoke_syscall+36
invoke_syscall+284
el0_svc_common+248
do_el0_svc+56
el0_svc+248
el0t_64_sync_handler+92
el0t_64_sync+344
object ffff000007e79d00 freed in free_task_struct+32 age=12132 cpu=1 pid=0
kmem_cache_free+780
free_task_struct+32
free_task+164
__put_task_struct+328
put_task_struct+44
delayed_put_task_struct+64
rcu_do_batch+972
rcu_core+592
rcu_core_si+24
__softirqentry_text_start+388
do_softirq_own_stack+12
invoke_softirq+216
__irq_exit_rcu+164
irq_exit+20
handle_domain_irq+120
4. Dump slab debug trace for each allocated object belongs to this slab
when used "-st" with an slab page address.
5. Dump slab debug trace for each allocated object belongs to slab cache
when used "-S -t" with a slab cache address.
With this patch, the page allocation times can be sorted by page_owner_sort
tool easily, and the slab allocation/free times can be sorted by a script.
Signed-off-by: qiwu.chen <qiwu.chen(a)transsion.com>
---
defs.h | 50 ++++++
help.c | 8 +-
memory.c | 538 ++++++++++++++++++++++++++++++++++++++++++++++++++++---
3 files changed, 572 insertions(+), 24 deletions(-)
diff --git a/defs.h b/defs.h
index dfbd241..e9eb9e3 100644
--- a/defs.h
+++ b/defs.h
@@ -206,6 +206,34 @@ static inline int string_exists(char *s) { return (s ? TRUE : FALSE); }
#undef roundup
#endif
#define roundup(x, y) ((((x)+((y)-1))/(y))*(y))
+#define __round_mask(x, y) ((__typeof__(x))((y)-1))
+#define rounddown(x, y) ((x) & ~__round_mask(x, y))
+#define IS_ALIGNED(x, y) (((x) & ((typeof(x))(y) - 1)) == 0)
+
+/* stack depot macros before kernel commit 8151c7a35d8bd */
+#define STACK_ALLOC_ALIGN 4
+#define STACK_ALLOC_NULL_PROTECTION_BITS 1
+#define STACK_ALLOC_ORDER 2 /* 'Slab' size order for stack depot, 4 pages */
+#define STACK_ALLOC_OFFSET_BITS (STACK_ALLOC_ORDER + PAGESHIFT() - STACK_ALLOC_ALIGN)
+#define DEPOT_STACK_BITS (sizeof(uint) * 8)
+#define STACK_ALLOC_INDEX_BITS (DEPOT_STACK_BITS - \
+ STACK_ALLOC_NULL_PROTECTION_BITS - STACK_ALLOC_OFFSET_BITS)
+
+/* stack depot macros since kernel commit 8151c7a35d8bd */
+#define STACK_DEPOT_EXTRA_BITS 5
+#define DEPOT_HANDLE_BITS (sizeof(uint) * 8)
+#define DEPOT_POOL_ORDER 2 /* Pool size order, 4 pages */
+#define DEPOT_POOL_SIZE (1LL << (PAGESHIFT() + DEPOT_POOL_ORDER))
+#define DEPOT_STACK_ALIGN 4
+#define DEPOT_OFFSET_BITS (DEPOT_POOL_ORDER + PAGESHIFT() - DEPOT_STACK_ALIGN)
+#define DEPOT_POOL_INDEX_BITS (DEPOT_HANDLE_BITS - DEPOT_OFFSET_BITS - \
+ STACK_DEPOT_EXTRA_BITS)
+
+/* GFP flags */
+#define __GFP_RECLAIMABLE 0x10u
+#define __GFP_MOVABLE 0x08u
+#define GFP_MOVABLE_MASK (__GFP_RECLAIMABLE|__GFP_MOVABLE)
+#define GFP_MOVABLE_SHIFT 3
typedef uint64_t physaddr_t;
@@ -1626,6 +1654,7 @@ struct offset_table { /* stash of commonly-used offsets */
long pglist_data_node_present_pages;
long pglist_data_node_spanned_pages;
long pglist_data_bdata;
+ long pglist_data_node_page_ext;
long page_cache_bucket_chain;
long zone_struct_free_pages;
long zone_struct_free_area;
@@ -2243,6 +2272,23 @@ struct offset_table { /* stash of commonly-used offsets */
long vmap_node_busy;
long rb_list_head;
long file_f_inode;
+ long stack_record_size;
+ long stack_record_entries;
+ long stack_record_count;
+ long page_owner_order;
+ long page_owner_gfp_mask;
+ long page_owner_ts_nsec;
+ long page_owner_free_ts_nsec;
+ long page_owner_pid;
+ long page_owner_handle;
+ long page_owner_free_handle;
+ long mem_section_page_ext;
+ long track_addr;
+ long track_addrs;
+ long track_pid;
+ long track_cpu;
+ long track_when;
+ long track_handle;
};
struct size_table { /* stash of commonly-used sizes */
@@ -2419,6 +2465,10 @@ struct size_table { /* stash of commonly-used sizes */
long module_memory;
long fred_frame;
long vmap_node;
+ long page_ext;
+ long page_owner;
+ long stack_record;
+ long track;
};
struct array_table {
diff --git a/help.c b/help.c
index e95ac1d..6a59064 100644
--- a/help.c
+++ b/help.c
@@ -6815,8 +6815,8 @@ NULL
char *help_kmem[] = {
"kmem",
"kernel memory",
-"[-f|-F|-c|-C|-i|-v|-V|-n|-z|-o|-h] [-p | -m member[,member]]\n"
-" [[-s|-S|-S=cpu[s]|-r] [slab] [-I slab[,slab]]] [-g [flags]] [[-P] address]]",
+"[-f|-F|-c|-C|-i|-v|-V|-n|-z|-o|-h] [-p|-t | -m member[,member]]\n"
+" [[-s|-S|-S=cpu[s]|-r|-t] [slab] [-I slab[,slab]]] [-g [flags]] [[-P] address]]",
" This command displays information about the use of kernel memory.\n",
" -f displays the contents of the system free memory headers.",
" also verifies that the page count equals nr_free_pages.",
@@ -6845,6 +6845,7 @@ char *help_kmem[] = {
" mem_map[] array, made up of the page struct address, its associated",
" physical address, the page.mapping, page.index, page._count and",
" page.flags fields.",
+" -t displays page_owner allocated stack trace for each allocated page in buddy system.",
" -m member similar to -p, but displays page structure contents specified by",
" a comma-separated list of one or more struct page members. The",
" \"flags\" member will always be expressed in hexadecimal format, and",
@@ -6893,12 +6894,15 @@ char *help_kmem[] = {
" address when used with -s or -S, searches the kmalloc() slab subsystem",
" for the slab containing of this virtual address, showing whether",
" it is in use or free.",
+" when added extra -t, displays the slab debug trace for the allocated",
+" object belongs to this slab",
" address when used with -f, the address can be either a page pointer,",
" a physical address, or a kernel virtual address; the free_area",
" header containing the page (if any) is displayed.",
" address when used with -p, the address can be either a page pointer, a",
" physical address, or a kernel virtual address; its basic mem_map",
" page information is displayed.",
+" when added extra -t, display the page_owner traces for this page",
" address when used with -m, the address can be either a page pointer, a",
" physical address, or a kernel virtual address; the specified",
" members of the associated page struct are displayed.",
diff --git a/memory.c b/memory.c
index a74ebaf..7bf8f86 100644
--- a/memory.c
+++ b/memory.c
@@ -323,6 +323,11 @@ static ulong kmem_cache_nodelists(ulong);
static void dump_hstates(void);
static ulong freelist_ptr(struct meminfo *, ulong, ulong);
static ulong handle_each_vm_area(struct handle_each_vm_area_args *);
+static void page_owner_init(void);
+static int page_owner_enabled(void);
+static void stack_depot_init(void);
+static void dump_page_owner(struct meminfo *, ulong, physaddr_t);
+enum track_item { TRACK_ALLOC, TRACK_FREE, TRACK_ALL };
/*
* Memory display modes specific to this file.
@@ -860,6 +865,16 @@ vm_init(void)
"kmem_cache_node", "partial");
MEMBER_OFFSET_INIT(kmem_cache_node_full,
"kmem_cache_node", "full");
+
+ STRUCT_SIZE_INIT(track, "track");
+ MEMBER_OFFSET_INIT(track_addr, "track", "addr");
+ if (MEMBER_EXISTS("track", "addrs"))
+ MEMBER_OFFSET_INIT(track_addrs, "track", "addrs");
+ if (MEMBER_EXISTS("track", "handle"))
+ MEMBER_OFFSET_INIT(track_handle, "track", "handle");
+ MEMBER_OFFSET_INIT(track_when, "track", "when");
+ MEMBER_OFFSET_INIT(track_cpu, "track", "cpu");
+ MEMBER_OFFSET_INIT(track_pid, "track", "pid");
} else {
MEMBER_OFFSET_INIT(kmem_cache_s_c_nextp,
"kmem_cache_s", "c_nextp");
@@ -983,6 +998,8 @@ vm_init(void)
vt->flags |= DISCONTIGMEM;
sparse_mem_init();
+ page_owner_init();
+ stack_depot_init();
vt->vmalloc_start = machdep->vmalloc_start();
if (IS_VMALLOC_ADDR(vt->mem_map))
@@ -1099,6 +1116,8 @@ vm_init(void)
MEMBER_OFFSET_INIT(pglist_data_bdata, "pglist_data", "bdata");
MEMBER_OFFSET_INIT(pglist_data_nr_zones, "pglist_data",
"nr_zones");
+ MEMBER_OFFSET_INIT(pglist_data_node_page_ext, "pglist_data",
+ "node_page_ext");
MEMBER_OFFSET_INIT(pglist_data_node_start_pfn, "pglist_data",
"node_start_pfn");
MEMBER_OFFSET_INIT(pglist_data_pgdat_next, "pglist_data",
@@ -5037,6 +5056,8 @@ get_task_mem_usage(ulong task, struct task_mem_usage *tm)
#define SLAB_BITFIELD (ADDRESS_SPECIFIED << 25)
#define SLAB_GATHER_FAILURE (ADDRESS_SPECIFIED << 26)
#define GET_SLAB_ROOT_CACHES (ADDRESS_SPECIFIED << 27)
+#define GET_SLAB_DEBUG_TRACE (ADDRESS_SPECIFIED << 28)
+#define GET_PAGE_OWNER (ADDRESS_SPECIFIED << 29)
#define GET_ALL \
(GET_SHARED_PAGES|GET_TOTALRAM_PAGES|GET_BUFFERS_PAGES|GET_SLAB_PAGES)
@@ -5048,7 +5069,7 @@ cmd_kmem(void)
int c;
int sflag, Sflag, pflag, fflag, Fflag, vflag, zflag, oflag, gflag;
int nflag, cflag, Cflag, iflag, lflag, Lflag, Pflag, Vflag, hflag;
- int rflag;
+ int rflag, tflag;
struct meminfo meminfo;
ulonglong value[MAXARGS];
char buf[BUFSIZE];
@@ -5061,13 +5082,13 @@ cmd_kmem(void)
spec_addr = choose_cpu = 0;
sflag = Sflag = pflag = fflag = Fflag = Pflag = zflag = oflag = 0;
vflag = Cflag = cflag = iflag = nflag = lflag = Lflag = Vflag = 0;
- gflag = hflag = rflag = 0;
+ gflag = hflag = rflag = tflag = 0;
escape = FALSE;
BZERO(&meminfo, sizeof(struct meminfo));
BZERO(&value[0], sizeof(ulonglong)*MAXARGS);
pc->curcmd_flags &= ~HEADER_PRINTED;
- while ((c = getopt(argcnt, args, "gI:sS::rFfm:pvczCinl:L:PVoh")) != EOF) {
+ while ((c = getopt(argcnt, args, "gI:sS::rFfm:pvczCinl:L:PVoht")) != EOF) {
switch(c)
{
case 'V':
@@ -5204,6 +5225,10 @@ cmd_kmem(void)
gflag = 1;
break;
+ case 't':
+ tflag = 1;
+ break;
+
default:
argerrs++;
break;
@@ -5213,7 +5238,7 @@ cmd_kmem(void)
if (argerrs)
cmd_usage(pc->curcmd, SYNOPSIS);
- if ((sflag + Sflag + pflag + fflag + Fflag + Vflag + oflag +
+ if ((fflag + Fflag + Vflag + oflag +
vflag + Cflag + cflag + iflag + lflag + Lflag + gflag +
hflag + rflag) > 1) {
error(INFO, "only one flag allowed!\n");
@@ -5264,10 +5289,13 @@ cmd_kmem(void)
if (pflag) {
meminfo.spec_addr = value[i];
meminfo.flags = ADDRESS_SPECIFIED;
+ if (tflag)
+ meminfo.flags |= GET_PAGE_OWNER;
dump_mem_map(&meminfo);
pflag++;
}
+
if (sflag || Sflag) {
if (vt->flags & KMEM_CACHE_UNAVAIL)
error(FATAL,
@@ -5292,6 +5320,8 @@ cmd_kmem(void)
meminfo.reqname = p1;
meminfo.cache = value[i];
meminfo.flags |= CACHE_SET;
+ if (tflag)
+ meminfo.flags |= GET_SLAB_DEBUG_TRACE;
if ((i+1) == spec_addr) { /* done? */
if (meminfo.calls++)
fprintf(fp, "\n");
@@ -5301,6 +5331,8 @@ cmd_kmem(void)
} else {
meminfo.spec_addr = value[i];
meminfo.flags = ADDRESS_SPECIFIED;
+ if (tflag)
+ meminfo.flags |= GET_SLAB_DEBUG_TRACE;
if (Sflag && (vt->flags & KMALLOC_SLUB))
meminfo.flags |= VERBOSE;
if (meminfo.calls++)
@@ -5346,25 +5378,28 @@ cmd_kmem(void)
gflag++;
}
- /*
- * no value arguments allowed!
- */
- if (zflag || nflag || iflag || Fflag || Cflag || Lflag ||
+ if (tflag)
+ tflag++;
+
+ /*
+ * no value arguments allowed!
+ */
+ if (zflag || nflag || iflag || Fflag || Cflag || Lflag ||
Vflag || oflag || hflag || rflag) {
error(INFO,
"no address arguments allowed with this option\n");
cmd_usage(pc->curcmd, SYNOPSIS);
}
- if (!(sflag + Sflag + pflag + fflag + vflag + cflag +
- lflag + Lflag + gflag)) {
+ if (!(sflag + Sflag + pflag + fflag + vflag + cflag +
+ lflag + Lflag + gflag + tflag)) {
meminfo.spec_addr = value[i];
- meminfo.flags = ADDRESS_SPECIFIED;
- if (meminfo.calls++)
- fprintf(fp, "\n");
+ meminfo.flags = ADDRESS_SPECIFIED;
+ if (meminfo.calls++)
+ fprintf(fp, "\n");
else
kmem_cache_init();
- kmem_search(&meminfo);
+ kmem_search(&meminfo);
}
}
@@ -5372,8 +5407,11 @@ cmd_kmem(void)
if (iflag == 1)
dump_kmeminfo();
- if (pflag == 1)
+ if (pflag == 1) {
+ if (tflag)
+ meminfo.flags = GET_PAGE_OWNER;
dump_mem_map(&meminfo);
+ }
if (fflag == 1)
vt->dump_free_pages(&meminfo);
@@ -5457,7 +5495,7 @@ cmd_kmem(void)
if (!(sflag + Sflag + pflag + fflag + Fflag + vflag +
Vflag + zflag + oflag + cflag + Cflag + iflag +
nflag + lflag + Lflag + gflag + hflag + rflag +
- meminfo.calls))
+ tflag + meminfo.calls))
cmd_usage(pc->curcmd, SYNOPSIS);
}
@@ -5749,7 +5787,8 @@ dump_mem_map_SPARSEMEM(struct meminfo *mi)
switch (mi->flags)
{
- case ADDRESS_SPECIFIED:
+ case ADDRESS_SPECIFIED:
+ case ADDRESS_SPECIFIED|GET_PAGE_OWNER:
switch (mi->memtype)
{
case KVADDR:
@@ -5774,6 +5813,10 @@ dump_mem_map_SPARSEMEM(struct meminfo *mi)
print_hdr = TRUE;
break;
+ case GET_PAGE_OWNER:
+ print_hdr = FALSE;
+ break;
+
case GET_ALL:
shared = 0;
reserved = 0;
@@ -5926,6 +5969,10 @@ dump_mem_map_SPARSEMEM(struct meminfo *mi)
/* FALLTHROUGH */
+ case GET_PAGE_OWNER:
+ dump_page_owner(mi, pp, phys);
+ break;
+
case GET_SLAB_PAGES:
if (v22) {
if ((flags >> v22_PG_Slab) & 1)
@@ -6083,6 +6130,7 @@ display_members:
if (done)
break;
+
}
if (done)
@@ -6119,7 +6167,10 @@ display_members:
break;
case ADDRESS_SPECIFIED:
+ case ADDRESS_SPECIFIED|GET_PAGE_OWNER:
mi->retval = done;
+ if (mi->flags & GET_PAGE_OWNER)
+ dump_page_owner(mi, pp, phys);
break;
}
@@ -6129,6 +6180,331 @@ display_members:
FREEBUF(page_cache);
}
+static int stack_depot_enabled(void)
+{
+ struct syment *sp;
+ int disable = TRUE;
+
+ if ((sp = symbol_search("stack_depot_disable")))
+ readmem(sp->value, KVADDR, &disable, sizeof(int),
+ "stack_depot_disable", RETURN_ON_ERROR);
+ else if ((sp = symbol_search("stack_depot_disabled")))
+ readmem(sp->value, KVADDR, &disable, sizeof(int),
+ "stack_depot_disabled", RETURN_ON_ERROR);
+ else if ((sp = symbol_search("stack_slabs")))
+ return sp->value ? FALSE : TRUE;
+
+ return !disable;
+}
+
+static void stack_depot_init(void)
+{
+ if (stack_depot_enabled()) {
+ STRUCT_SIZE_INIT(stack_record, "stack_record");
+ MEMBER_OFFSET_INIT(stack_record_size, "stack_record", "size");
+ MEMBER_OFFSET_INIT(stack_record_entries, "stack_record", "entries");
+ if (MEMBER_EXISTS("stack_record", "count"))
+ MEMBER_OFFSET_INIT(stack_record_count, "stack_record", "count");
+ }
+}
+
+/* Fetch stack entries from a depot. */
+static unsigned int stack_depot_fetch(uint handle, ulong *entries)
+{
+ struct syment *sp;
+ uint valid, offset, slabindex, poolindex, pools_num, stack_record_count, stack_size = 0;
+ ulong stack_record_addr, sym_value;
+
+ if (!handle)
+ return 0;
+
+ if ((sp = symbol_search("stack_slabs"))) {
+ valid = (handle >> (STACK_ALLOC_INDEX_BITS + STACK_ALLOC_OFFSET_BITS)) & STACK_ALLOC_NULL_PROTECTION_BITS;
+ if (!valid)
+ return 0;
+
+ slabindex = handle & ((1 << STACK_ALLOC_INDEX_BITS) - 1);
+ if (!readmem(sp->value + slabindex * sizeof(void *), KVADDR, &stack_record_addr,
+ sizeof(void *), "stack_record_addr", FAULT_ON_ERROR))
+ return 0;
+
+ offset = (handle >> STACK_ALLOC_INDEX_BITS) & ((1 << STACK_ALLOC_OFFSET_BITS) - 1);
+ stack_record_addr += (offset << STACK_ALLOC_ALIGN);
+ *entries = stack_record_addr + OFFSET(stack_record_entries);
+ if (!readmem(stack_record_addr + OFFSET(stack_record_size), KVADDR, &stack_size, sizeof(stack_size),
+ "stack_record_entries", FAULT_ON_ERROR))
+ return 0;
+ } else if ((sp = symbol_search("stack_pools")) && (sym_value = symbol_value("pools_num"))) {
+ poolindex = handle & ((1 << DEPOT_POOL_INDEX_BITS) - 1);
+ readmem(sym_value, KVADDR, &pools_num, sizeof(int), "pools_num", RETURN_ON_ERROR);
+ if (poolindex >= pools_num) {
+ error(INFO, "pool index %d out of bounds (%d) for stack id %08x\n", poolindex, pools_num, handle);
+ return 0;
+ }
+
+ readmem(sp->value + (poolindex-1) * sizeof(void *), KVADDR, &stack_record_addr,
+ sizeof(void *), "stack_record_addr", FAULT_ON_ERROR);
+ if (!stack_record_addr)
+ return 0;
+
+ offset = (handle >> DEPOT_POOL_INDEX_BITS) & ((1 << DEPOT_OFFSET_BITS) - 1);
+ stack_record_addr += (offset << DEPOT_STACK_ALIGN);
+ if (!readmem(stack_record_addr + OFFSET(stack_record_count), KVADDR, &stack_record_count,
+ sizeof(stack_record_count), "stack_record_count", FAULT_ON_ERROR) || !stack_record_count)
+ return 0;
+
+ *entries = stack_record_addr + OFFSET(stack_record_entries);
+ if (!readmem(stack_record_addr + OFFSET(stack_record_size), KVADDR, &stack_size, sizeof(stack_size),
+ "stack_record_entries", FAULT_ON_ERROR))
+ return 0;
+ }
+
+ return stack_size;
+}
+
+static void stack_trace_print(ulong entries, uint nr_entries)
+{
+ int i;
+ struct syment *sp;
+ ulong value, offset;
+ char buf[BUFSIZE];
+
+ if (!nr_entries)
+ return;
+
+ for (i = 0; i < nr_entries; i++) {
+ if (!readmem(entries, KVADDR, &value, sizeof(value), "stack_trace", FAULT_ON_ERROR))
+ break;
+
+ entries += sizeof(ulong);
+ sp = value_search(value, &offset);
+ if (!sp)
+ break;
+
+ fprintf(fp, "%s\n", value_to_symstr(sp->value+offset, buf, 0));
+ }
+ fprintf(fp, "\n");
+}
+
+static ulong gfp_migratetype(ulong gfp_flags)
+{
+ struct syment *sp;
+ int page_group_by_mobility_disabled;
+
+ if ((sp = symbol_search("page_group_by_mobility_disabled"))) {
+ readmem(sp->value, KVADDR, &page_group_by_mobility_disabled, sizeof(int),
+ "page_group_by_mobility_disabled", RETURN_ON_ERROR);
+ if (page_group_by_mobility_disabled) {
+ ulong migrate_unmovable;
+
+ enumerator_value("MIGRATE_UNMOVABLE", &migrate_unmovable);
+ return migrate_unmovable;
+ }
+ }
+
+ return (gfp_flags & GFP_MOVABLE_MASK) >> GFP_MOVABLE_SHIFT;
+}
+
+static void migratetype_name(ulong migratetype, char *buf)
+{
+ struct syment *sp;
+ ulong migratetype_name_addr;
+
+ sp = symbol_search("migratetype_names");
+ if (!sp)
+ return;
+
+ readmem(sp->value + migratetype * sizeof(ulong), KVADDR, &migratetype_name_addr,
+ sizeof(ulong), "migratetype_name", RETURN_ON_ERROR);
+ read_string(migratetype_name_addr, buf, BUFSIZE-1);
+}
+
+static void print_page_owner(ulong pfn, ulong page, char *page_owner, enum track_item alloc)
+{
+ int i, pid;
+ ushort order;
+ uint handle, free_handle, gfp_mask, nr_entries;
+ u64 ts_nsec, free_ts_nsec;
+ ulong entries, offset, page_flags;
+ struct syment *sp;
+ char buf[BUFSIZE];
+
+ order = USHORT(page_owner + OFFSET(page_owner_order));
+ gfp_mask = UINT(page_owner + OFFSET(page_owner_gfp_mask));
+ handle = UINT(page_owner + OFFSET(page_owner_handle));
+ free_handle = UINT(page_owner + OFFSET(page_owner_free_handle));
+ ts_nsec = ULONGLONG(page_owner + OFFSET(page_owner_ts_nsec));
+ free_ts_nsec = ULONGLONG(page_owner + OFFSET(page_owner_free_ts_nsec));
+ pid = INT(page_owner + OFFSET(page_owner_pid));
+
+ if (handle && (alloc != TRACK_FREE)) {
+ fprintf(fp, "Page allocated via order %u, mask %#x, pid %d, ts %llu ns\n",
+ order, gfp_mask, pid, ts_nsec);
+ migratetype_name(gfp_migratetype(gfp_mask), buf);
+ readmem(page+OFFSET(page_flags), KVADDR, &page_flags, sizeof(ulong),
+ "page.flags", FAULT_ON_ERROR);
+ fprintf(fp, "PFN %#lx, type %s, Flags %#lx\n", pfn, buf, page_flags);
+ nr_entries = stack_depot_fetch(handle, &entries);
+ stack_trace_print(entries, nr_entries);
+ }
+
+ if (alloc != TRACK_ALLOC &&
+ (free_handle = UINT(page_owner + OFFSET(page_owner_free_handle)))) {
+ nr_entries = stack_depot_fetch(handle, &entries);
+ fprintf(fp, "page last free ts %llu ns, stack trace:\n", free_ts_nsec);
+ stack_trace_print(entries, nr_entries);
+ }
+}
+
+/* Get the max order for zoned buddy allocator */
+static inline ulong get_max_order(void)
+{
+ char *string;
+
+ if ((kt->ikconfig_flags & IKCONFIG_AVAIL) &&
+ get_kernel_config("CONFIG_FORCE_MAX_ZONEORDER", &string) == IKCONFIG_STR)
+ return atol(string);
+
+ return 11;
+}
+
+#define MAX_ORDER get_max_order()
+#define MAX_ORDER_NR_PAGES (1 << (MAX_ORDER - 1))
+
+static int lookup_page_ext(ulong pfn, ulong pp, ulong *page_ext)
+{
+ int node;
+ ulong page_ext_size, section, section_nr, pgdat, node_page_ext, node_start_pfn, page_ext_idx;
+
+ if (!kernel_symbol_exists("page_ext_size") ||
+ !readmem(symbol_value("page_ext_size"), KVADDR, &page_ext_size, sizeof(page_ext_size),
+ "page_ext_size", QUIET|RETURN_ON_ERROR))
+ return FALSE;
+
+ if (IS_SPARSEMEM()) {
+ section_nr = pfn_to_section_nr(pfn);
+ if (!(section = valid_section_nr(section_nr)))
+ return FALSE;
+
+ if (!readmem(section + OFFSET(mem_section_page_ext), KVADDR, &node_page_ext, sizeof(ulong),
+ "mem_section page_ext", FAULT_ON_ERROR) || !node_page_ext)
+ return FALSE;
+
+ *page_ext = node_page_ext + pfn * page_ext_size;
+ return TRUE;
+ }
+
+ if ((node = page_to_nid(pp) >= 0)) {
+ pgdat = vt->node_table[node].pgdat;
+ if (!VALID_MEMBER(pglist_data_node_page_ext) ||
+ !readmem(pgdat + OFFSET(pglist_data_node_page_ext), KVADDR, &node_page_ext,
+ sizeof(ulong), "pglist node_page_ext", FAULT_ON_ERROR) || !node_page_ext)
+ return FALSE;
+
+ if (!VALID_MEMBER(pglist_data_node_start_pfn) ||
+ !readmem(pgdat + OFFSET(pglist_data_node_start_pfn), KVADDR, &node_start_pfn,
+ sizeof(ulong), "pglist node_start_pfn", FAULT_ON_ERROR) || !node_start_pfn)
+ return FALSE;
+
+ page_ext_idx = pfn - rounddown(node_start_pfn, MAX_ORDER_NR_PAGES);
+ *page_ext = node_page_ext + pfn * page_ext_size;
+ return TRUE;
+ }
+
+ return FALSE;
+}
+
+static ulong get_page_owner(ulong page_ext)
+{
+ struct syment *sp;
+ ulong page_owner_ops_offset;
+
+ sp = symbol_search("page_owner_ops");
+ if (!sp)
+ return FALSE;
+
+ if (!readmem(sp->value, KVADDR, &page_owner_ops_offset, sizeof(ulong),
+ "page_owner_ops_offset", RETURN_ON_ERROR))
+ return FALSE;
+
+ return page_ext + page_owner_ops_offset;
+}
+
+static int page_owner_enabled(void)
+{
+ struct syment *sp;
+ int enabled;
+
+ if ((sp = symbol_search("page_owner_enabled")) &&
+ readmem(sp->value, KVADDR, &enabled, sizeof(int), "page_owner_enabled", RETURN_ON_ERROR))
+ return enabled;
+
+ if ((sp = symbol_search("page_owner_inited")) &&
+ readmem(sp->value, KVADDR, &enabled, sizeof(int), "page_owner_inited", RETURN_ON_ERROR))
+ return enabled;
+
+ return FALSE;
+}
+
+static void page_owner_init(void)
+{
+ if (page_owner_enabled()) {
+ STRUCT_SIZE_INIT(page_ext, "page_ext");
+ STRUCT_SIZE_INIT(page_owner, "page_owner");
+ MEMBER_OFFSET_INIT(mem_section_page_ext, "mem_section", "page_ext");
+ MEMBER_OFFSET_INIT(page_owner_handle, "page_owner", "handle");
+ MEMBER_OFFSET_INIT(page_owner_free_handle, "page_owner", "free_handle");
+ MEMBER_OFFSET_INIT(page_owner_order, "page_owner", "order");
+ MEMBER_OFFSET_INIT(page_owner_gfp_mask, "page_owner", "gfp_mask");
+ MEMBER_OFFSET_INIT(page_owner_ts_nsec, "page_owner", "ts_nsec");
+ MEMBER_OFFSET_INIT(page_owner_free_ts_nsec, "page_owner", "free_ts_nsec");
+ MEMBER_OFFSET_INIT(page_owner_pid, "page_owner", "pid");
+ }
+}
+
+static void dump_page_owner(struct meminfo *mi, ulong pp, physaddr_t phys)
+{
+ ulong pfn, page_ext_addr, page_owner_addr, page_ext;
+ long page_ext_owner, page_ext_owner_allocated;
+ char *page_owner;
+
+ pfn = BTOP(phys);
+ if (!lookup_page_ext(pfn, pp, &page_ext_addr))
+ return;
+
+ page_owner_addr = get_page_owner(page_ext_addr);
+ if (!page_owner_addr)
+ return;
+
+ page_owner = (char *)GETBUF(SIZE(page_owner));
+ if (!readmem(page_owner_addr, KVADDR, page_owner, SIZE(page_owner), "page_owner", FAULT_ON_ERROR))
+ goto exit;
+
+ enumerator_value("PAGE_EXT_OWNER", &page_ext_owner);
+ if (!readmem(page_ext_addr, KVADDR, &page_ext, sizeof(ulong), "page_ext", FAULT_ON_ERROR)
+ || !(page_ext & (1 << page_ext_owner)))
+ goto exit;
+
+ enumerator_value("PAGE_EXT_OWNER_ALLOCATED", &page_ext_owner_allocated);
+ if (mi->flags == GET_PAGE_OWNER) {
+ if (!(page_ext & (1 << page_ext_owner_allocated)) ||
+ !IS_ALIGNED(pfn, 1 << USHORT(page_owner + OFFSET(page_owner_order))))
+ goto exit;
+
+ /* dump allocated page owner for current memory usage */
+ print_page_owner(pfn, pp, page_owner, TRACK_ALLOC);
+ } else {
+ if (page_ext & (1 << page_ext_owner_allocated))
+ fprintf(fp, "page_owner tracks the page 0x%lx as allocated\n", pp);
+ else
+ fprintf(fp, "page_owner tracks the page 0x%lx as freed\n", pp);
+ print_page_owner(pfn, pp, page_owner, TRACK_ALL);
+ }
+
+exit:
+ FREEBUF(page_owner);
+}
+
static void
dump_mem_map(struct meminfo *mi)
{
@@ -6161,6 +6537,18 @@ dump_mem_map(struct meminfo *mi)
char style3[100];
char style4[100];
+ if (mi->flags & GET_PAGE_OWNER) {
+ if (!page_owner_enabled()) {
+ error(INFO, "page_owner is disabled\n");
+ return;
+ }
+
+ if (!stack_depot_enabled()) {
+ error(INFO, "stack_depot is disabled\n");
+ return;
+ }
+ }
+
if (IS_SPARSEMEM()) {
dump_mem_map_SPARSEMEM(mi);
return;
@@ -6238,7 +6626,8 @@ dump_mem_map(struct meminfo *mi)
switch (mi->flags)
{
- case ADDRESS_SPECIFIED:
+ case ADDRESS_SPECIFIED:
+ case ADDRESS_SPECIFIED|GET_PAGE_OWNER:
switch (mi->memtype)
{
case KVADDR:
@@ -6263,6 +6652,10 @@ dump_mem_map(struct meminfo *mi)
print_hdr = TRUE;
break;
+ case GET_PAGE_OWNER:
+ print_hdr = FALSE;
+ break;
+
case GET_ALL:
shared = 0;
reserved = 0;
@@ -6376,6 +6769,10 @@ dump_mem_map(struct meminfo *mi)
/* FALLTHROUGH */
+ case GET_PAGE_OWNER:
+ dump_page_owner(mi, pp, phys);
+ break;
+
case GET_SLAB_PAGES:
if (v22) {
if ((flags >> v22_PG_Slab) & 1)
@@ -6570,7 +6967,10 @@ display_members:
break;
case ADDRESS_SPECIFIED:
+ case ADDRESS_SPECIFIED|GET_PAGE_OWNER:
mi->retval = done;
+ if (mi->flags & GET_PAGE_OWNER)
+ dump_page_owner(mi, pp, phys);
break;
}
@@ -19618,6 +20018,99 @@ do_kmem_cache_slub(struct meminfo *si)
FREEBUF(per_cpu);
}
+/*
+ * Return offset of the end of info block which is inuse + free pointer if
+ * not overlapping with object.
+ */
+static inline uint get_info_end(struct meminfo *si)
+{
+ uint inuse = UINT(si->cache_buf + OFFSET(kmem_cache_inuse));
+ uint offset = UINT(si->cache_buf + OFFSET(kmem_cache_offset));
+
+ if (offset >= inuse)
+ return inuse + sizeof(void *);
+ else
+ return inuse;
+}
+
+static inline u64 get_jiffies(void)
+{
+ ulong jiffies;
+ u64 jiffies_64;
+
+ if (symbol_exists("jiffies_64")) {
+ get_symbol_data("jiffies_64", sizeof(u64), &jiffies_64);
+ return jiffies_64;
+ } else {
+ get_symbol_data("jiffies", sizeof(ulong), &jiffies);
+ return (u64)jiffies;
+ }
+}
+
+#define TRACK_ADDRS_COUNT 16
+void print_track(struct meminfo *si, char *track, ulong object, enum track_item alloc)
+{
+ ulong track_addr, addr, addrs, when, entries, nr_entries;
+ uint i, cpu, pid, handle;
+ char buf[BUFSIZE];
+
+ track_addr = object + get_info_end(si) + alloc * STRUCT_SIZE("track");
+ if (!readmem(track_addr, KVADDR, track, SIZE(track), "track", FAULT_ON_ERROR))
+ return;
+
+ addr = ULONG(track + OFFSET(track_addr));
+ if (addr) {
+ when = ULONG(track + OFFSET(track_when));
+ cpu = UINT(track + OFFSET(track_cpu));
+ pid = UINT(track + OFFSET(track_pid));
+ fprintf(fp, "object %lx %s in %s age=%llu cpu=%u pid=%d\n",
+ object, alloc ? "freed" : "allocated", value_to_symstr(addr, buf, 0),
+ get_jiffies() - (u64)when, cpu, pid);
+ if (VALID_MEMBER(track_addrs)) {
+ addrs = track_addr + OFFSET(track_addrs);
+ stack_trace_print(addrs, TRACK_ADDRS_COUNT);
+ } else if (VALID_MEMBER(track_handle)) {
+ handle = UINT(track + OFFSET(track_handle));
+ nr_entries = stack_depot_fetch(handle, &entries);
+ stack_trace_print(entries, nr_entries);
+ } else {
+ fprintf(fp, "stack trace missing\n");
+ handle = track_addr + OFFSET(track_handle);
+ nr_entries = stack_depot_fetch(handle, &entries);
+ stack_trace_print(entries, nr_entries);
+ }
+ }
+}
+
+#define SLAB_STORE_USER (0x00010000UL)
+static ulong get_slab_store_user_flag(void)
+{
+ ulong slab_store_user_flag;
+
+ if (enumerator_value("_SLAB_STORE_USER", &slab_store_user_flag))
+ return (1 << slab_store_user_flag);
+ else
+ return SLAB_STORE_USER;
+}
+
+static void slab_debug_trace_show(struct meminfo *si, ulong object)
+{
+ ulong flags;
+ char *track;
+
+ if (!(si->flags & GET_SLAB_DEBUG_TRACE))
+ return;
+
+ flags = ULONG(si->cache_buf + OFFSET(kmem_cache_flags));
+ if (!(flags & get_slab_store_user_flag()))
+ return;
+
+ track = (char *)GETBUF(SIZE(track));
+ print_track(si, track, object, TRACK_ALLOC);
+ print_track(si, track, object, TRACK_FREE);
+ FREEBUF(track);
+}
+
#define DUMP_SLAB_INFO_SLUB() \
{ \
char b1[BUFSIZE], b2[BUFSIZE]; \
@@ -19672,7 +20165,8 @@ do_slab_slub(struct meminfo *si, int verbose)
if (!verbose) {
DUMP_SLAB_INFO_SLUB();
- return TRUE;
+ if (!(si->flags & GET_SLAB_DEBUG_TRACE))
+ return TRUE;
}
cpu_freelist = 0;
@@ -19775,7 +20269,8 @@ do_slab_slub(struct meminfo *si, int verbose)
if (is_free && (cpu_slab >= 0))
fprintf(fp, "(cpu %d cache)", cpu_slab);
fprintf(fp, "\n");
-
+ if (!is_free)
+ slab_debug_trace_show(si, p + red_left_pad);
}
return TRUE;
@@ -19886,11 +20381,10 @@ do_node_lists_slub(struct meminfo *si, ulong node_ptr, int node)
}
-#define SLAB_STORE_USER (0x00010000UL)
flags = ULONG(si->cache_buf + OFFSET(kmem_cache_flags));
if (INVALID_MEMBER(kmem_cache_node_full) ||
- !(flags & SLAB_STORE_USER)) {
+ !(flags & get_slab_store_user_flag())) {
fprintf(fp, "NODE %d FULL:\n (not tracked)\n", node);
return;
}
--
2.25.1
3 months, 2 weeks
- 2
- 2
Re: [PATCH v6 00/14] gdb stack unwinding support for crash utility
by lijiang
On Mon, Aug 26, 2024 at 11:55 AM <devel-request(a)lists.crash-utility.osci.io>
wrote:
> Date: Mon, 26 Aug 2024 15:52:26 +1200
> From: Tao Liu <ltao(a)redhat.com>
> Subject: [Crash-utility] [PATCH v6 00/14] gdb stack unwinding support
> for crash utility
> To: devel(a)lists.crash-utility.osci.io
> Cc: Tao Liu <ltao(a)redhat.com>
> Message-ID: <20240826035240.14781-1-ltao(a)redhat.com>
> Content-Type: text/plain; charset=UTF-8
>
> This patchset is a rebase/merged version of the following 3 patchsets:
>
> 1): [PATCH v10 0/5] Improve stack unwind on ppc64 [1]
> 2): [PATCH 0/5] x86_64 gdb stack unwinding support [2]
> 3): Clean up on top of one-thread-v2 [3]
>
> A complete description of gdb stack unwinding support for crash can be
> found in [1].
>
> This patchset can be divided into the following 2 parts:
>
> 1) part1: arch independent, mainly modify on the
> crash_target.c/gdb_interface.c files, in preparation of the
> gdb side.
> 2) part2: arch specific part, for implementing ppc64/x86_64/arm64/vmware
> gdb stack unwinding support.
>
> === part 2
>
> - arm64:
> arm64: Add gdb stack unwinding support
>
> - vmware:
> vmware_guestdump: Various format versions support
> set_context(): check if context is already current
>
> - x86_64:
> x86_64: Fix invalid input "=>" for bt command
> Fix cpumask_t recursive dependence issue
> x86_64: Add gdb stack unwinding support
>
> - ppc64:
> ppc64: correct gdb passthroughs by implementing machdep->get_cpu_reg
>
> === part 1
>
> Stop stack unwinding at non-kernel address
> Fix gdb_interface: restore gdb's output streams at end of gdb_interface
> Print task pid/command instead of CPU index
> Rename get_cpu_reg to get_current_task_reg
> Let crash change gdb context
> Leave only one gdb thread for crash
> Remove 'frame' from prohibited commands list
> ===
>
> v6 -> v5:
> 1) Refactor patch 4 & 9, which changed the function signature of struct
> get_cpu_reg/get_current_task_reg, and let each patch compile with no
> error when added on.
> 2) Rebased the patchset on top of latest upstream:
> ("79b93ecb2e72ec Fix a "Bus error" issue caused by 'crash --osrelease'
> or
> crash loading")
>
>
Thank you for the update, Tao.
I have a few more comments here:
[1] [PATCH v6 04/14]:
+ * Task is active, grab CPU's registers
+ */
+ if (is_task_active(tc->task) && VMSS_DUMPFILE())
+ return vmware_vmss_get_cpu_reg(tc->processor, regno, name,
size, value);
Can you help confirm that it only works for the active task? Is this
expected behavior?
[2] [PATCH v6 07/14]
#ifdef CRASH_MERGE
CORE_ADDR pc = 0;
get_frame_pc_if_available (fi, &pc);
if (!is_kvaddr(pc)) {
printf_filtered (_("Backtrace stopped due to non-kernel addr:
%lx\n"),pc);
fi = NULL;
break;
}
#endif
I would suggest removing the above printf_filtered(...), otherwise it will
be always displayed.
[3] [PATCH v6 08/14]
a. warning
cc -c -g -DPPC64 -m64 -DLZO -DGDB_10_2 ppc64.c -Wall -O2
-Wstrict-prototypes -Wmissing-prototypes -fstack-protector
-Wformat-security
ppc64.c: In function ‘ppc64_get_current_task_reg’:
ppc64.c:2519:15: warning: unused variable ‘task’ [-Wunused-variable]
2519 | ulong task;
| ^~~~
b. There are different results between 'bt' and 'gdb bt' commands. Can you
help double check?
crash> bt
PID: 6298 TASK: c000000050bbcb00 CPU: 2 COMMAND: "bash"
R0: c0000000002be63c R1: c00000005102b710 R2: c000000001bf8f00
R3: c00000005102b728 R4: 0000000000000000 R5: 0000000000000000
R6: c00000005102b8d8 R7: c00000000f5d0000 R8: 0000000000000000
R9: c0000000557d3c00 R10: 0000000000000001 R11: 0000000000002000
R12: c0000000027634a8 R13: c00000000f6cdf00 R14: 0000000000000000
R15: 0000000000000000 R16: 0000000000000000 R17: 0000000000000000
R18: 0000000000000000 R19: 0000000000000000 R20: 0000000000000000
R21: 0000000000000000 R22: 0000000000000000 R23: 0000000000000000
R24: 0000000000000007 R25: 0000000000000000 R26: 0000000000000000
R27: c00000000274d898 R28: c000000002d0a8d0 R29: c000000002e23df0
R30: 0000000000000000 R31: c000000002e23ddc
NIP: c0000000002bdf64 MSR: 8000000000009033 OR3: 0000000000000000
CTR: 0000000000000000 LR: c0000000002be63c XER: 0000000020040004
CCR: 0000000024222280 MQ: 0000000000000001 DAR: 0000000000000000
DSISR: 0000000000000000 Syscall Result: 0000000000000000
[NIP : crash_setup_regs+68]
[LR : __crash_kexec+156]
#0 [c00000005102b710] crash_setup_regs at c0000000002bdf64
crash> gdb bt
#0 0xc0000000002bdf64 in crash_setup_regs (newregs=0xc00000005102b728,
oldregs=0x0) at ./arch/powerpc/include/asm/kexec.h:133
#1 0xc0000000002be658 in __crash_kexec (regs=0x0) at
kernel/crash_core.c:122
#2 0xc00000000016c284 in panic (fmt=0xc0000000015dd018 "sysrq triggered
crash\n") at kernel/panic.c:367
#3 0xc000000000a66e78 in sysrq_handle_crash (key=<optimized out>) at
drivers/tty/sysrq.c:154
#4 0xc000000000a67994 in __handle_sysrq (key=key@entry=99 'c',
check_mask=check_mask@entry=false) at drivers/tty/sysrq.c:612
#5 0xc000000000a68454 in write_sysrq_trigger (file=<optimized out>,
buf=<optimized out>, count=2, ppos=<optimized out>) at
drivers/tty/sysrq.c:1181
#6 0xc00000000072868c in pde_write (pde=0xc000000003671f80,
file=<optimized out>, buf=<optimized out>, count=<optimized out>,
ppos=<optimized out>) at fs/proc/inode.c:334
#7 proc_reg_write (file=<optimized out>, buf=<optimized out>,
count=<optimized out>, ppos=<optimized out>) at fs/proc/inode.c:346
#8 0xc00000000063bf20 in vfs_write (file=0xc000000009cb5b00,
buf=0x100123a71a0 <error: Cannot access memory at address 0x100123a71a0>,
count=2, pos=0xc00000005102bc00) at fs/read_write.c:588
#9 vfs_write (file=0xc000000009cb5b00, buf=0x100123a71a0 <error: Cannot
access memory at address 0x100123a71a0>, count=<optimized out>,
pos=0xc00000005102bc00) at fs/read_write.c:570
#10 0xc00000000063c4d0 in ksys_write (fd=<optimized out>, buf=0x100123a71a0
<error: Cannot access memory at address 0x100123a71a0>, count=2) at
fs/read_write.c:643
#11 0xc000000000031a28 in system_call_exception (regs=0xc00000005102be80,
r0=<optimized out>) at arch/powerpc/kernel/syscall.c:153
#12 0xc00000000000d05c in system_call_vectored_common () at
arch/powerpc/kernel/interrupt_64.S:198
Backtrace stopped: previous frame inner to this frame (corrupt stack?)
crash>
[4] [PATCH v6 10/14]
diff --git a/xen_hyper.c b/xen_hyper.c
index 32e56fa..54c7f57 100644
--- a/xen_hyper.c
+++ b/xen_hyper.c
@@ -52,7 +52,7 @@ xen_hyper_init(void)
*/
xht->xen_virt_start &= 0xffffffffc0000000;
#endif
-
+ STRUCT_SIZE_INIT(cpumask_t, "cpumask_t");
if (machine_type("X86_64") &&
symbol_exists("xen_phys_start") && !xen_phys_start())
error(WARNING,
Could you please explain why the above changes are needed?
[5] [PATCH v6 14/14]
a. warning
cc -c -g -DARM64 -DLZO -DGDB_10_2 arm64.c -Wall -O2 -Wstrict-prototypes
-Wmissing-prototypes -fstack-protector -Wformat-security
arm64.c: In function ‘arm64_get_stack_frame’:
arm64.c:4138:13: warning: variable ‘ret’ set but not used
[-Wunused-but-set-variable]
4138 | int ret;
| ^~~
b. indentation issue
- bt->task);
+ ur_bitmap = (struct user_regs_bitmap_struct
*)GETBUF(sizeof(*ur_bitmap));
+ memset(ur_bitmap, 0, sizeof(*ur_bitmap));
+ ur_bitmap->ur.pc = stackframe.pc;
[6] The 'info threads' command only displays the current task, not all
known tasks. And this looks different behavior from the gdb
gdb> info threads
Id Target Id Frame
* 1 6298 bash 0xc0000000002bdf64 in crash_setup_regs
(newregs=0xc00000005102b728, oldregs=0x0) at
./arch/powerpc/include/asm/kexec.h:133
[7] the 'thread' command can not switch to another task.
crash> ps
...
6297 6287 0 c000000057517e80 IN 0.0 22784 11776
sshd-session
> 6298 6297 2 c000000050bbcb00 RU 0.0 9664 6272 bash
...
gdb> thread 6297
gdb: gdb request failed: thread 6297
gdb>
Finally I have to do it with 'set' command as below:
crash> set 6297
PID: 6297
COMMAND: "sshd-session"
TASK: c000000057517e80 [THREAD_INFO: c000000057517e80]
CPU: 0
STATE: TASK_INTERRUPTIBLE
crash> set gdb on
gdb: on
gdb> bt
#0 0xc00000009cd57650 in ?? ()
gdb: gdb request failed: bt
gdb>
In addition, the code is changed, but its patch log is not updated
accordingly. Could you please double check? I won't list them here.
Thanks.
Lianbo
v5 -> v4:
> 1) Plenty of code refactoring based on Lianbo's comments on v4.
> 2) Removed the magic number when dealing with regs bitmap, see [6].
> 3) Rebased the patchset on top of latest upstream:
> ("1c6da3eaff8207 arm64: Fix bt command show wrong stacktrace on ramdump
> source")
>
> v4 -> v3:
> Fixed the author issue in [PATCH v3 06/16] Fix gdb_interface: restore gdb's
> output streams at end of gdb_interface.
>
> v3 -> v2:
> 1) Updated CC list as pointed out in [4]
> 2) Compiling issues as in [5]
>
> v2 -> v1:
> 1) Added the patch: x86_64: Fix invalid input "=>" for bt command,
> thanks for Kazu's testing.
> 2) Modify the patch: x86_64: Add gdb stack unwinding support, added the
> pcp_save, spp_save and sp, for restoring the value in match of the
> original
> code logic.
>
> [1]:
> https://www.mail-archive.com/devel@lists.crash-utility.osci.io/msg00469.html
> [2]:
> https://www.mail-archive.com/devel@lists.crash-utility.osci.io/msg00488.html
> [3]:
> https://www.mail-archive.com/devel@lists.crash-utility.osci.io/msg00554.html
> [4]:
> https://www.mail-archive.com/devel@lists.crash-utility.osci.io/msg00681.html
> [5]:
> https://www.mail-archive.com/devel@lists.crash-utility.osci.io/msg00715.html
> [6]:
> https://www.mail-archive.com/devel@lists.crash-utility.osci.io/msg00819.html
>
> Aditya Gupta (3):
> Remove 'frame' from prohibited commands list
> Fix gdb_interface: restore gdb's output streams at end of
> gdb_interface
> ppc64: correct gdb passthroughs by implementing machdep->get_cpu_reg
>
> Alexey Makhalov (2):
> set_context(): check if context is already current
> vmware_guestdump: Various format versions support
>
> Tao Liu (9):
> Leave only one gdb thread for crash
> Let crash change gdb context
> Rename get_cpu_reg to get_current_task_reg
> Print task pid/command instead of CPU index
> Stop stack unwinding at non-kernel address
> x86_64: Add gdb stack unwinding support
> Fix cpumask_t recursive dependence issue
> x86_64: Fix invalid input "=>" for bt command
> arm64: Add gdb stack unwinding support
>
> arm64.c | 115 +++++++++++++++-
> crash_target.c | 71 ++++++----
> defs.h | 194 ++++++++++++++++++++++++++-
> gdb-10.2.patch | 82 ++++++++++++
> gdb_interface.c | 35 ++---
> kernel.c | 63 +++++++--
> ppc64.c | 175 +++++++++++++++++++++++-
> symbols.c | 15 +++
> task.c | 34 +++--
> tools.c | 10 +-
> unwind_x86_64.h | 4 -
> vmware_guestdump.c | 321 +++++++++++++++++++++++++++++++-------------
> x86_64.c | 323 ++++++++++++++++++++++++++++++++++++++++-----
> xen_hyper.c | 2 +-
> 14 files changed, 1225 insertions(+), 219 deletions(-)
>
> --
> 2.40.1
>
3 months, 3 weeks
- 2
- 1
[PATCH] “kmem address” not working properly when redzone is enabled
by Aureau, Georges (Kernel Tools ERT)
Crash “kmem address” not working properly when redzone is enabled.
When "slub_debug" is enabled with redzoning, "kmem address" does not work properly.
The "red_left_pad" member within "struct kmem_cache" is currently an "unsigned int",
it used to be an "int", but it never was a "long", hence "red_left_pad" in do_slab_slub()
was not initialized properly. This "red_left_pad" issue resulted in reporting free objects
as "[ALLOCATED]", and in reporting bogus object addresses when using "set redzone off".
Signed-off-by: Georges Aureau <georges.aureau(a)hpe.com>
--
diff --git a/memory.c b/memory.c
index a74ebaf..967a9cf 100644
--- a/memory.c
+++ b/memory.c
@@ -19637,7 +19637,8 @@ do_slab_slub(struct meminfo *si, int verbose)
int i, free_objects, cpu_slab, is_free, node;
ulong p, q;
#define SLAB_RED_ZONE 0x00000400UL
- ulong flags, red_left_pad;
+ ulong flags;
+ uint red_left_pad;
if (!si->slab) {
if (CRASHDEBUG(1))
@@ -19727,7 +19728,7 @@ do_slab_slub(struct meminfo *si, int verbose)
if (VALID_MEMBER(kmem_cache_red_left_pad)) {
flags = ULONG(si->cache_buf + OFFSET(kmem_cache_flags));
if (flags & SLAB_RED_ZONE)
- red_left_pad = ULONG(si->cache_buf + OFFSET(kmem_cache_red_left_pad));
+ red_left_pad = UINT(si->cache_buf + OFFSET(kmem_cache_red_left_pad));
}
for (p = vaddr; p < vaddr + objects * si->size; p += si->size) {
3 months, 4 weeks
- 2
- 1
Re: [PATCH v2] arm64: fix regression for the determination of section_size_bits
by lijiang
On Tue, Aug 20, 2024 at 11:54 AM <devel-request(a)lists.crash-utility.osci.io>
wrote:
> Date: Tue, 20 Aug 2024 03:53:16 -0000
> From: chenguanyou9338(a)gmail.com
> Subject: [Crash-utility] Re: [PATCH v2] arm64: fix regression for the
> determination of section_size_bits
> To: devel(a)lists.crash-utility.osci.io
> Message-ID: <20240820035316.8055.4425(a)lists.crash-utility.osci.io>
> Content-Type: text/plain; charset="utf-8"
>
> Hi lianbo
>
> Base on qiwu's patch, is this attached patch OK ?
>
>
Sorry for the late reply.
I'm worried that there will be more and more similar patches in the future,
how should we handle them by then?
Or leave it there for the time being until we find a better solution. Any
thoughts from other reviewers?
Thanks
Lianbo
>From 08d4af144b981daf292473303e08546ef1e81a04 Mon Sep 17 00:00:00 2001
> From: chenguanyou <chenguanyou(a)xiaomi.com>
> Date: Thu, 8 Aug 2024 17:35:07 +0800
> Subject: [PATCH] arm64: fix regression for the determination of
> section_size_bits
>
> The commit 568c6f04 will cause a regression issue for the determination of
> section_size_bits on kernel version before android12-5.10 or Linux-v5.12.
> The section_size_bits is supposed to be compatible with linux upstream and
> android GKI version:
> Before android12-5.10 or Linux-v5.12:
> SECTION_SIZE_BITS = 30
>
> After android12-5.10 or Linux-v5.12:
> SECTION_SIZE_BITS = 27 when defined 4K_PAGES or 16K_PAGES.
> SECTION_SIZE_BITS = 29 when defined 64K_PAGES.
>
> Fixes: 568c6f04 ("arm64: section_size_bits compatible with macro
> definitions")
> Change-Id: Ib6ec610753aabb52dfbafab65e1e6c04cbe65f72
>
> Signed-off-by: qiwu.chen <qiwu.chen(a)transsion.com>
> Signed-off-by: chenguanyou <chenguanyou(a)xiaomi.com>
> ---
> arm64.c | 22 ++++++++++------------
> defs.h | 10 ++++++++++
> global_data.c | 7 +++++++
> kernel.c | 23 +++++++++++++++++++++++
> 4 files changed, 50 insertions(+), 12 deletions(-)
>
> diff --git a/arm64.c b/arm64.c
> index 8ed1aaf..f0721b7 100644
> --- a/arm64.c
> +++ b/arm64.c
> @@ -1667,30 +1667,28 @@ arm64_get_section_size_bits(void)
> int ret;
> char *string;
>
> - if (THIS_KERNEL_VERSION >= LINUX(5,12,0)) {
> + if (arm64_get_vmcoreinfo(&machdep->section_size_bits,
> "NUMBER(SECTION_SIZE_BITS)", NUM_DEC))
> + goto exit;
> +
> + if (THIS_KERNEL_VERSION >= LINUX(5,12,0)
> + || (IS_ANDROID_KERNEL_REL
> + && THIS_KERNEL_VERSION >= LINUX(5,10,0)
> + && THIS_ANDROID_VERSION >= ANDROID(12,0)))
> if (machdep->pagesize == 65536)
> machdep->section_size_bits = _SECTION_SIZE_BITS_5_12_64K;
> else
> machdep->section_size_bits = _SECTION_SIZE_BITS_5_12;
> - } else
> + else
> machdep->section_size_bits = _SECTION_SIZE_BITS;
>
> - if (arm64_get_vmcoreinfo(&machdep->section_size_bits,
> "NUMBER(SECTION_SIZE_BITS)", NUM_DEC)) {
> - /* nothing */
> - } else if (kt->ikconfig_flags & IKCONFIG_AVAIL) {
> + if (kt->ikconfig_flags & IKCONFIG_AVAIL) {
> if ((ret = get_kernel_config("CONFIG_MEMORY_HOTPLUG", NULL)) ==
> IKCONFIG_Y) {
> if ((ret = get_kernel_config("CONFIG_HOTPLUG_SIZE_BITS",
> &string)) == IKCONFIG_STR)
> machdep->section_size_bits = atol(string);
> }
> -
> - /* arm64: reduce section size for sparsemem */
> - if ((ret = get_kernel_config("CONFIG_ARM64_4K_PAGES", NULL)) ==
> IKCONFIG_Y
> - || (ret = get_kernel_config("CONFIG_ARM64_16K_PAGES", NULL))
> == IKCONFIG_Y)
> - machdep->section_size_bits = _SECTION_SIZE_BITS_5_12;
> - else if ((ret = get_kernel_config("CONFIG_ARM64_64K_PAGES", NULL))
> == IKCONFIG_Y)
> - machdep->section_size_bits = _SECTION_SIZE_BITS_5_12_64K;
> }
>
> +exit:
> if (CRASHDEBUG(1))
> fprintf(fp, "SECTION_SIZE_BITS: %ld\n",
> machdep->section_size_bits);
> }
> diff --git a/defs.h b/defs.h
> index 1b7649d..b0d3f8f 100644
> --- a/defs.h
> +++ b/defs.h
> @@ -829,6 +829,15 @@ struct kernel_table { /* kernel
> data */
> #define IS_KERNEL_STATIC_TEXT(x) (((ulong)(x) >= kt->stext) && \
> ((ulong)(x) < kt->etext))
>
> +#define THIS_KERNEL_RELEASE (kt->utsname.release)
> +
> +struct android_table {
> + uint android_version[2];
> +};
> +#define IS_ANDROID_KERNEL_REL (at->android_version[0] > 0)
> +#define THIS_ANDROID_VERSION ((at->android_version[0] << 16) +
> (at->android_version[1]))
> +#define ANDROID(x,y) (((uint)(x) << 16) + (uint)(y))
> +
> #define TASK_COMM_LEN 16 /* task command name length including NULL */
>
> struct task_context { /* context stored for each task
> */
> @@ -5353,6 +5362,7 @@ extern struct vm_table vm_table, *vt;
> extern struct machdep_table *machdep;
> extern struct symbol_table_data symbol_table_data, *st;
> extern struct extension_table *extension_table;
> +extern struct android_table android_table, *at;
>
> /*
> * Generated in build_data.c
> diff --git a/global_data.c b/global_data.c
> index f9bb7d0..dddde96 100644
> --- a/global_data.c
> +++ b/global_data.c
> @@ -55,6 +55,13 @@ struct symbol_table_data *st = &symbol_table_data;
> struct machdep_table machdep_table = { 0 };
> struct machdep_table *machdep = &machdep_table;
>
> +/*
> + * The same thing goes for accesses to the frequently-accessed
> android_table,
> + * making the "at" pointers globally available.
> + */
> +struct android_table android_table = { 0, 0 };
> +struct android_table *at = &android_table;
> +
> /*
> * Command functions are entered with the args[] array and argcnt value
> * pre-set for issuance to getopt().
> diff --git a/kernel.c b/kernel.c
> index adb19ad..814418c 100644
> --- a/kernel.c
> +++ b/kernel.c
> @@ -104,6 +104,26 @@ static void check_vmcoreinfo(void);
> static int is_pvops_xen(void);
> static int get_linux_banner_from_vmlinux(char *, size_t);
>
> +/*
> + * Determine Andriod GKI vmcore by reading "android" from ut->release.
> + * The prefix of Andriod GKI release version is:
> + * Kernel Version - Android release version
> + * For example:
> + * 5.10.209-android12, 5.10.209-android12.1, 5.15.148-android13
> + */
> +void
> +parse_android_table(void)
> +{
> + char *p;
> + if ((p = strstr(THIS_KERNEL_RELEASE, "android"))) {
> + sscanf(p, "android%d.%d", &at->android_version[0],
> &at->android_version[1]);
> +
> + if (CRASHDEBUG(1))
> + fprintf(fp, "andriod_version: andriod-%d.%d\n",
> + at->android_version[0], at->android_version[1]);
> + }
> +}
> +
> /*
> * popuplate the global kernel table (kt) with kernel version
> * information parsed from UTSNAME/OSRELEASE string
> @@ -298,6 +318,9 @@ kernel_init()
> kt->utsname.domainname : "(not printable)");
> }
>
> + // non-upstream rel
> + parse_android_table();
> +
> strncpy(buf, kt->utsname.release, 65);
> if (buf[64])
> buf[64] = NULLCHAR;
> --
> 2.39.0
>
3 months, 4 weeks
- 4
- 7
[PATCH] arm64: fix regression for the determination of VA_BITS and section_size_bits
by qiwu.chen＠transsion.com
1. The commit f02c8e87 will cause a regression issue for the determination of VA_BITS
on Linux 4.19 and earlier kernels, the crash session fails during initialization with
the error message due to get a wrong vabits_actual:
vmcoreinfo : vabits_actual: 27
crash: invalid kernel virtual address: ffffffa890a41318 type: "kernel_config_data"
WARNING: cannot read kernel_config_data
crash: invalid kernel virtual address: ffffffa89106db50 type: "possible"
WARNING: cannot read cpu_possible_map
crash: invalid kernel virtual address: ffffffa89106db48 type: "present"
WARNING: cannot read cpu_present_map
crash: invalid kernel virtual address: ffffffa89106db40 type: "online"
WARNING: cannot read cpu_online_map
crash: invalid kernel virtual address: ffffffa89106db58 type: "active"
WARNING: cannot read cpu_active_map
crash: invalid kernel virtual address: ffffffa89143cb80 type: "shadow_timekeeper xtime_sec"
crash: invalid kernel virtual address: ffffffa89107b76c type: "init_uts_ns"
WARNING: invalid linux_banner pointer: ffffffa890a30018
crash: vmlinux and SYS_COREDUMP do not match!
Fix it by remove arm64_set_va_bits_by_tcr() if vabits_actual is missing.
2. The commit 568c6f04 will cause a regression issue for the determination of section_size_bits
on Linux 5.12 and earlier kernels. The section_size_bits compatible with linux upstream and
android GKI changes should be:
Before android-12-GKI or Linux 5.12:
SECTION_SIZE_BITS = 30
After android-12-gki:
SECTION_SIZE_BITS = 27 when defined 4K_PAGES or 16K_PAGES.
SECTION_SIZE_BITS = 29 when defined 64K_PAGES.
Fixes: f02c8e87 ("arm64: use TCR_EL1_T1SZ to get the correct info if vabits_actual is missing")
Fixes: 568c6f04 ("arm64: section_size_bits compatible with macro definitions")
Signed-off-by: qiwu.chen <qiwu.chen(a)transsion.com>
---
arm64.c | 37 ++++++++++++++++++-------------------
1 file changed, 18 insertions(+), 19 deletions(-)
diff --git a/arm64.c b/arm64.c
index b3040d7..176c465 100644
--- a/arm64.c
+++ b/arm64.c
@@ -1613,8 +1613,15 @@ arm64_get_section_size_bits(void)
{
int ret;
char *string;
+ bool is_ikconfig_avail;
- if (THIS_KERNEL_VERSION >= LINUX(5,12,0)) {
+ if (arm64_get_vmcoreinfo(&machdep->section_size_bits, "NUMBER(SECTION_SIZE_BITS)", NUM_DEC))
+ goto exit;
+
+ is_ikconfig_avail = kt->ikconfig_flags & IKCONFIG_AVAIL ? TRUE : FALSE;
+ /* The commit reduce section size for arm64 sparsemem is introduced on linux-v5.12 and android-12-GKI */
+ if (THIS_KERNEL_VERSION >= LINUX(5,12,0) || (is_ikconfig_avail &&
+ get_kernel_config("CONFIG_ANDROID_KABI_RESERVE", NULL) == IKCONFIG_Y)) {
if (machdep->pagesize == 65536)
machdep->section_size_bits = _SECTION_SIZE_BITS_5_12_64K;
else
@@ -1622,24 +1629,18 @@ arm64_get_section_size_bits(void)
} else
machdep->section_size_bits = _SECTION_SIZE_BITS;
- if (arm64_get_vmcoreinfo(&machdep->section_size_bits, "NUMBER(SECTION_SIZE_BITS)", NUM_DEC)) {
- /* nothing */
- } else if (kt->ikconfig_flags & IKCONFIG_AVAIL) {
- if ((ret = get_kernel_config("CONFIG_MEMORY_HOTPLUG", NULL)) == IKCONFIG_Y) {
- if ((ret = get_kernel_config("CONFIG_HOTPLUG_SIZE_BITS", &string)) == IKCONFIG_STR)
- machdep->section_size_bits = atol(string);
- }
-
- /* arm64: reduce section size for sparsemem */
- if ((ret = get_kernel_config("CONFIG_ARM64_4K_PAGES", NULL)) == IKCONFIG_Y
- || (ret = get_kernel_config("CONFIG_ARM64_16K_PAGES", NULL)) == IKCONFIG_Y)
- machdep->section_size_bits = _SECTION_SIZE_BITS_5_12;
- else if ((ret = get_kernel_config("CONFIG_ARM64_64K_PAGES", NULL)) == IKCONFIG_Y)
- machdep->section_size_bits = _SECTION_SIZE_BITS_5_12_64K;
+ /* section_size_bits for arm64 vendor special case */
+ if (is_ikconfig_avail && get_kernel_config("CONFIG_MEMORY_HOTPLUG", NULL) == IKCONFIG_Y) {
+ if (get_kernel_config("CONFIG_HOTPLUG_SIZE_BITS", &string) == IKCONFIG_STR)
+ machdep->section_size_bits = atol(string);
}
- if (CRASHDEBUG(1))
- fprintf(fp, "SECTION_SIZE_BITS: %ld\n", machdep->section_size_bits);
+exit:
+ if (machdep->section_size_bits) {
+ if (CRASHDEBUG(1))
+ fprintf(fp, "SECTION_SIZE_BITS: %ld\n", machdep->section_size_bits);
+ } else
+ error(FATAL, "cannot determine SECTION_SIZE_BITS\n");
}
/*
@@ -4733,8 +4734,6 @@ arm64_calc_VA_BITS(void)
*/
machdep->flags |= FLIPPED_VM;
return;
- } else if (arm64_set_va_bits_by_tcr()) {
- return;
} else if (machdep->machspec->VA_BITS_ACTUAL) {
machdep->machspec->VA_BITS = machdep->machspec->VA_BITS_ACTUAL;
machdep->machspec->VA_START = _VA_START(machdep->machspec->VA_BITS_ACTUAL);
--
2.25.1
4 months
- 4
- 8
[PATCH v6 00/14] gdb stack unwinding support for crash utility
by Tao Liu
This patchset is a rebase/merged version of the following 3 patchsets:
1): [PATCH v10 0/5] Improve stack unwind on ppc64 [1]
2): [PATCH 0/5] x86_64 gdb stack unwinding support [2]
3): Clean up on top of one-thread-v2 [3]
A complete description of gdb stack unwinding support for crash can be
found in [1].
This patchset can be divided into the following 2 parts:
1) part1: arch independent, mainly modify on the
crash_target.c/gdb_interface.c files, in preparation of the
gdb side.
2) part2: arch specific part, for implementing ppc64/x86_64/arm64/vmware
gdb stack unwinding support.
=== part 2
- arm64:
arm64: Add gdb stack unwinding support
- vmware:
vmware_guestdump: Various format versions support
set_context(): check if context is already current
- x86_64:
x86_64: Fix invalid input "=>" for bt command
Fix cpumask_t recursive dependence issue
x86_64: Add gdb stack unwinding support
- ppc64:
ppc64: correct gdb passthroughs by implementing machdep->get_cpu_reg
=== part 1
Stop stack unwinding at non-kernel address
Fix gdb_interface: restore gdb's output streams at end of gdb_interface
Print task pid/command instead of CPU index
Rename get_cpu_reg to get_current_task_reg
Let crash change gdb context
Leave only one gdb thread for crash
Remove 'frame' from prohibited commands list
===
v6 -> v5:
1) Refactor patch 4 & 9, which changed the function signature of struct
get_cpu_reg/get_current_task_reg, and let each patch compile with no
error when added on.
2) Rebased the patchset on top of latest upstream:
("79b93ecb2e72ec Fix a "Bus error" issue caused by 'crash --osrelease' or
crash loading")
v5 -> v4:
1) Plenty of code refactoring based on Lianbo's comments on v4.
2) Removed the magic number when dealing with regs bitmap, see [6].
3) Rebased the patchset on top of latest upstream:
("1c6da3eaff8207 arm64: Fix bt command show wrong stacktrace on ramdump source")
v4 -> v3:
Fixed the author issue in [PATCH v3 06/16] Fix gdb_interface: restore gdb's
output streams at end of gdb_interface.
v3 -> v2:
1) Updated CC list as pointed out in [4]
2) Compiling issues as in [5]
v2 -> v1:
1) Added the patch: x86_64: Fix invalid input "=>" for bt command,
thanks for Kazu's testing.
2) Modify the patch: x86_64: Add gdb stack unwinding support, added the
pcp_save, spp_save and sp, for restoring the value in match of the original
code logic.
[1]: https://www.mail-archive.com/devel@lists.crash-utility.osci.io/msg00469.html
[2]: https://www.mail-archive.com/devel@lists.crash-utility.osci.io/msg00488.html
[3]: https://www.mail-archive.com/devel@lists.crash-utility.osci.io/msg00554.html
[4]: https://www.mail-archive.com/devel@lists.crash-utility.osci.io/msg00681.html
[5]: https://www.mail-archive.com/devel@lists.crash-utility.osci.io/msg00715.html
[6]: https://www.mail-archive.com/devel@lists.crash-utility.osci.io/msg00819.html
Aditya Gupta (3):
Remove 'frame' from prohibited commands list
Fix gdb_interface: restore gdb's output streams at end of
gdb_interface
ppc64: correct gdb passthroughs by implementing machdep->get_cpu_reg
Alexey Makhalov (2):
set_context(): check if context is already current
vmware_guestdump: Various format versions support
Tao Liu (9):
Leave only one gdb thread for crash
Let crash change gdb context
Rename get_cpu_reg to get_current_task_reg
Print task pid/command instead of CPU index
Stop stack unwinding at non-kernel address
x86_64: Add gdb stack unwinding support
Fix cpumask_t recursive dependence issue
x86_64: Fix invalid input "=>" for bt command
arm64: Add gdb stack unwinding support
arm64.c | 115 +++++++++++++++-
crash_target.c | 71 ++++++----
defs.h | 194 ++++++++++++++++++++++++++-
gdb-10.2.patch | 82 ++++++++++++
gdb_interface.c | 35 ++---
kernel.c | 63 +++++++--
ppc64.c | 175 +++++++++++++++++++++++-
symbols.c | 15 +++
task.c | 34 +++--
tools.c | 10 +-
unwind_x86_64.h | 4 -
vmware_guestdump.c | 321 +++++++++++++++++++++++++++++++-------------
x86_64.c | 323 ++++++++++++++++++++++++++++++++++++++++-----
xen_hyper.c | 2 +-
14 files changed, 1225 insertions(+), 219 deletions(-)
--
2.40.1
4 months
- 2
- 16
[PATCH 0/4] arm64: Introduction of support 16K page with 4-level table
by Kuan-Ying Lee
1. Add support to 16K page size and 4-level page table with 48 VA bits.
2. Fix 64K page size with 52 VA bits issue.
Becuase we cannot use idmap_ptrs_per_pgd to know the size of
ptrs_per_pgd.
3. Refactor the translation of PTE to physical address and fix
indent issue.
Kuan-Ying Lee (4):
arm64: fix indent issue and refactor PTE_TO_PHYS
arm64: use the same expression to indicate ptrs_per_pgd
arm64: fix 64K page and 52-bits VA support
arm64: Support 16K page, 48 VA bits and 4 level page table
arm64.c | 264 ++++++++++++++++++++++++++++++++++++++++++--------------
defs.h | 33 ++++++-
2 files changed, 227 insertions(+), 70 deletions(-)
--
2.43.0
4 months
- 2
- 5
Re: [PATCH v5 04/14] Rename get_cpu_reg to get_current_task_reg
by lijiang
Hi, Tao
Thank you for the update.
On Mon, Jul 29, 2024 at 6:53 PM <devel-request(a)lists.crash-utility.osci.io>
wrote:
> Date: Mon, 29 Jul 2024 22:44:26 +1200
> From: Tao Liu <ltao(a)redhat.com>
> Subject: [Crash-utility] [PATCH v5 04/14] Rename get_cpu_reg to
> get_current_task_reg
> To: devel(a)lists.crash-utility.osci.io
> Cc: Alexey Makhalov <alexey.makhalov(a)broadcom.com>, Mahesh J
> Salgaonkar <mahesh(a)linux.ibm.com>, "Naveen N . Rao"
> <naveen.n.rao(a)linux.vnet.ibm.com>, Lianbo Jiang <
> lijiang(a)redhat.com>
> Message-ID: <20240729104436.67685-5-ltao(a)redhat.com>
> Content-Type: text/plain; charset=UTF-8
>
> Since we only leave one gdb thread, or 1 cpu thread, and can use cmd "set"
> to switch task context by reusing the thread. So the word "get_cpu_reg",
> which stands for "fetch registers' value for cpu thread x", is no longer
> appropriate, better using "get_current_task_reg", which stands for "fetch
> registers' value for the current task", and makes more sense.
>
> Note: the function signature was changed by this patch, and there is one
> usage in x86_64.c:machdep->get_current_task_reg = x86_64_get_cpu_reg,
> which doesn't matter because it will be updated later in patch
> "x86_64: Add gdb stack unwinding support".
>
The current compilation error will break the bisecting in the future.
As we discussed, we need to make sure it doesn't have any compilation
failures, and try our best to not introduce new regression issues.
>
> Co-developed-by: Aditya Gupta <adityag(a)linux.ibm.com>
> Co-developed-by: Alexey Makhalov <alexey.makhalov(a)broadcom.com>
> Co-developed-by: Tao Liu <ltao(a)redhat.com>
> Cc: Sourabh Jain <sourabhjain(a)linux.ibm.com>
> Cc: Hari Bathini <hbathini(a)linux.ibm.com>
> Cc: Mahesh J Salgaonkar <mahesh(a)linux.ibm.com>
> Cc: Naveen N. Rao <naveen.n.rao(a)linux.vnet.ibm.com>
> Cc: Lianbo Jiang <lijiang(a)redhat.com>
> Cc: HAGIO KAZUHITO(萩尾 一仁) <k-hagio-ab(a)nec.com>
> Cc: Tao Liu <ltao(a)redhat.com>
> Cc: Alexey Makhalov <alexey.makhalov(a)broadcom.com>
> Signed-off-by: Tao Liu <ltao(a)redhat.com>
> ---
> crash_target.c | 5 ++---
> defs.h | 2 +-
> gdb_interface.c | 10 +++++-----
> x86_64.c | 2 +-
> 4 files changed, 9 insertions(+), 10 deletions(-)
>
> diff --git a/crash_target.c b/crash_target.c
> index 41f0f3a..6ee12d2 100644
> --- a/crash_target.c
> +++ b/crash_target.c
> @@ -26,7 +26,7 @@
> void crash_target_init (void);
>
> extern "C" int gdb_readmem_callback(unsigned long, void *, int, int);
> -extern "C" int crash_get_cpu_reg (int cpu, int regno, const char *regname,
> +extern "C" int crash_get_current_task_reg (int regno, const char *regname,
> int regsize, void *val);
> extern "C" int gdb_change_thread_context (void);
>
> @@ -66,7 +66,6 @@ public:
> static void supply_registers(struct regcache *regcache, int regno)
> {
> gdb_byte regval[16];
> - int cpu = inferior_ptid.tid();
> struct gdbarch *arch = regcache->arch ();
> const char *regname = gdbarch_register_name(arch, regno);
> int regsize = register_size(arch, regno);
> @@ -74,7 +73,7 @@ static void supply_registers(struct regcache *regcache,
> int regno)
> if (regsize > sizeof (regval))
> error (_("fatal error: buffer size is not enough to fit register
> value"));
>
> - if (crash_get_cpu_reg (cpu, regno, regname, regsize, (void *)®val))
> + if (crash_get_current_task_reg (regno, regname, regsize, (void
> *)®val))
> regcache->raw_supply (regno, regval);
> else
> regcache->raw_supply (regno, NULL);
> diff --git a/defs.h b/defs.h
> index 9ffe7c9..82c2af8 100644
> --- a/defs.h
> +++ b/defs.h
> @@ -1080,7 +1080,7 @@ struct machdep_table {
> void (*get_irq_affinity)(int);
> void (*show_interrupts)(int, ulong *);
> int (*is_page_ptr)(ulong, physaddr_t *);
> - int (*get_cpu_reg)(int, int, const char *, int, void *);
> + int (*get_current_task_reg)(int, const char *, int, void *);
> int (*is_cpu_prstatus_valid)(int cpu);
> };
>
> diff --git a/gdb_interface.c b/gdb_interface.c
> index 8e95e9e..7399fd0 100644
> --- a/gdb_interface.c
> +++ b/gdb_interface.c
> @@ -1067,13 +1067,13 @@ unsigned long crash_get_kaslr_offset(void)
> }
>
> /* Callbacks for crash_target */
> -int crash_get_cpu_reg (int cpu, int regno, const char *regname,
> - int regsize, void *val);
> -int crash_get_cpu_reg (int cpu, int regno, const char *regname,
> +int crash_get_current_task_reg (int regno, const char *regname,
> + int regsize, void *value);
> +int crash_get_current_task_reg (int regno, const char *regname,
> int regsize, void *value)
> {
> - if (!machdep->get_cpu_reg)
> + if (!machdep->get_current_task_reg)
> return FALSE;
> - return machdep->get_cpu_reg(cpu, regno, regname, regsize, value);
> + return machdep->get_current_task_reg(regno, regname, regsize,
> value);
> }
>
> diff --git a/x86_64.c b/x86_64.c
> index 469d26b..24a7040 100644
> --- a/x86_64.c
> +++ b/x86_64.c
> @@ -195,7 +195,7 @@ x86_64_init(int when)
> machdep->machspec->irq_eframe_link = UNINITIALIZED;
> machdep->machspec->irq_stack_gap = UNINITIALIZED;
> machdep->get_kvaddr_ranges = x86_64_get_kvaddr_ranges;
> - machdep->get_cpu_reg = x86_64_get_cpu_reg;
> + machdep->get_current_task_reg = x86_64_get_cpu_reg;
>
Still getting an error again, not fix it in this patch:
cc -c -g -DX86_64 -DLZO -DGDB_10_2 x86_64.c
x86_64.c: In function ‘x86_64_init’:
x86_64.c:198:47: error: assignment to ‘int (*)(int, const char *, int,
void *)’ from incompatible pointer type ‘int (*)(int, int, const char *,
int, void *)’ [-Wincompatible-pointer-types]
198 | machdep->get_current_task_reg = x86_64_get_cpu_reg;
| ^
make[4]: *** [Makefile:432: x86_64.o] Error 1
make[3]: *** [Makefile:1877: gdb] Error 2
make[2]: *** [Makefile:278: rebuild] Error 2
make[1]: *** [Makefile:266: gdb_merge] Error 2
make: *** [Makefile:258: all] Error 2
please refer to the same error(see the link):
https://www.mail-archive.com/devel@lists.crash-utility.osci.io/msg00812.html
Thanks
Lianbo
if (machdep->cmdline_args[0])
> parse_cmdline_args();
> if ((string = pc->read_vmcoreinfo("relocate"))) {
> --
> 2.40.1
>
4 months, 1 week
- 1
- 0