[PATCH v2] kmem: fix the determination for slab page
by qiwu.chen＠transsion.com
The determination for a slab page has changed due to changing
PG_slab from a page flag to a page type since kernel commit
46df8e73a4a3.
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 | 7 ++++++
memory.c | 65 +++++++++++++++++++++++++++++++++++++++++++++++---------
2 files changed, 62 insertions(+), 10 deletions(-)
diff --git a/defs.h b/defs.h
index 2231cb6..e2a9278 100644
--- a/defs.h
+++ b/defs.h
@@ -2243,6 +2243,7 @@ struct offset_table { /* stash of commonly-used offsets */
long vmap_node_busy;
long rb_list_head;
long file_f_inode;
+ long page_page_type;
};
struct size_table { /* stash of commonly-used sizes */
@@ -2651,6 +2652,7 @@ struct vm_table { /* kernel VM-related data */
ulong max_mem_section_nr;
ulong zero_paddr;
ulong huge_zero_paddr;
+ uint page_type_base;
};
#define NODES (0x1)
@@ -2684,6 +2686,11 @@ struct vm_table { /* kernel VM-related data */
#define SLAB_CPU_CACHE (0x10000000)
#define SLAB_ROOT_CACHES (0x20000000)
#define USE_VMAP_NODES (0x40000000)
+/*
+ * The SLAB_PAGEFLAGS flag is introduced to detect the change of
+ * PG_slab's type from a page flag to a page type.
+ */
+#define SLAB_PAGEFLAGS (0x80000000)
#define IS_FLATMEM() (vt->flags & FLATMEM)
#define IS_DISCONTIGMEM() (vt->flags & DISCONTIGMEM)
diff --git a/memory.c b/memory.c
index 967a9cf..48ac627 100644
--- a/memory.c
+++ b/memory.c
@@ -351,6 +351,43 @@ static ulong handle_each_vm_area(struct handle_each_vm_area_args *);
static ulong DISPLAY_DEFAULT;
+/*
+ * Before kernel commit ff202303c398e, the value is defined as a macro, so copy it here;
+ * After this commit, the value is defined as an enum, which can be evaluated at runtime.
+ */
+#define PAGE_TYPE_BASE 0xf0000000
+#define PageType(page_type, flag) \
+ ((page_type & (vt->page_type_base | flag)) == vt->page_type_base)
+
+static void page_type_init(void)
+{
+ if (!enumerator_value("PAGE_TYPE_BASE", (long *)&vt->page_type_base))
+ vt->page_type_base = PAGE_TYPE_BASE;
+}
+
+/*
+ * The PG_slab's type has changed from a page flag to a page type
+ * since kernel commit 46df8e73a4a3.
+ */
+static bool page_slab(ulong page, ulong flags)
+{
+ if (vt->flags & SLAB_PAGEFLAGS) {
+ if ((flags >> vt->PG_slab) & 1)
+ return TRUE;
+ }
+
+ if (VALID_MEMBER(page_page_type)) {
+ uint page_type;
+
+ readmem(page+OFFSET(page_page_type), KVADDR, &page_type,
+ sizeof(page_type), "page_type", FAULT_ON_ERROR);
+ if (PageType(page_type, (uint)vt->PG_slab))
+ return TRUE;
+ }
+
+ return FALSE;
+}
+
/*
* Verify that the sizeof the primitive types are reasonable.
*/
@@ -504,6 +541,10 @@ 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");
+ page_type_init();
+ }
MEMBER_OFFSET_INIT(mm_struct_pgd, "mm_struct", "pgd");
@@ -5931,7 +5972,7 @@ dump_mem_map_SPARSEMEM(struct meminfo *mi)
if ((flags >> v22_PG_Slab) & 1)
slabs++;
} else if (vt->PG_slab) {
- if ((flags >> vt->PG_slab) & 1)
+ if (page_slab(pp, flags))
slabs++;
} else {
if ((flags >> v24_PG_slab) & 1)
@@ -6381,7 +6422,7 @@ dump_mem_map(struct meminfo *mi)
if ((flags >> v22_PG_Slab) & 1)
slabs++;
} else if (vt->PG_slab) {
- if ((flags >> vt->PG_slab) & 1)
+ if (page_slab(pp, flags))
slabs++;
} else {
if ((flags >> v24_PG_slab) & 1)
@@ -6775,6 +6816,9 @@ page_flags_init_from_pageflag_names(void)
vt->pageflags_data[i].name = nameptr;
vt->pageflags_data[i].mask = mask;
+ if (!strncmp(nameptr, "slab", 4))
+ vt->flags |= SLAB_PAGEFLAGS;
+
if (CRASHDEBUG(1)) {
fprintf(fp, " %08lx %s\n",
vt->pageflags_data[i].mask,
@@ -6836,7 +6880,8 @@ page_flags_init_from_pageflags_enum(void)
strcpy(nameptr, arglist[0] + strlen("PG_"));
vt->pageflags_data[p].name = nameptr;
vt->pageflags_data[p].mask = 1 << atoi(arglist[2]);
-
+ if (!strncmp(nameptr, "slab", 4))
+ vt->flags |= SLAB_PAGEFLAGS;
p++;
}
} else
@@ -9736,14 +9781,14 @@ vaddr_to_kmem_cache(ulong vaddr, char *buf, int verbose)
readmem(page+OFFSET(page_flags), KVADDR,
&page_flags, sizeof(ulong), "page.flags",
FAULT_ON_ERROR);
- if (!(page_flags & (1 << vt->PG_slab))) {
+ if (!page_slab(page, page_flags)) {
if (((vt->flags & KMALLOC_SLUB) || VALID_MEMBER(page_compound_head)) ||
((vt->flags & KMALLOC_COMMON) &&
VALID_MEMBER(page_slab) && VALID_MEMBER(page_first_page))) {
readmem(compound_head(page)+OFFSET(page_flags), KVADDR,
&page_flags, sizeof(ulong), "page.flags",
FAULT_ON_ERROR);
- if (!(page_flags & (1 << vt->PG_slab)))
+ if (!page_slab(compound_head(page), page_flags))
return NULL;
} else
return NULL;
@@ -20195,7 +20240,7 @@ char *
is_slab_page(struct meminfo *si, char *buf)
{
int i, cnt;
- ulong page_slab, page_flags, name;
+ ulong pg_slab, page_flags, name;
ulong *cache_list;
char *retval;
@@ -20210,11 +20255,11 @@ is_slab_page(struct meminfo *si, char *buf)
RETURN_ON_ERROR|QUIET))
return NULL;
- if (!(page_flags & (1 << vt->PG_slab)))
+ if (!page_slab(si->spec_addr, page_flags))
return NULL;
- if (!readmem(si->spec_addr + OFFSET(page_slab), KVADDR,
- &page_slab, sizeof(ulong), "page.slab",
+ if (!readmem(si->spec_addr + OFFSET(page_slab), KVADDR,
+ &pg_slab, sizeof(ulong), "page.slab",
RETURN_ON_ERROR|QUIET))
return NULL;
@@ -20222,7 +20267,7 @@ is_slab_page(struct meminfo *si, char *buf)
cnt = get_kmem_cache_list(&cache_list);
for (i = 0; i < cnt; i++) {
- if (page_slab == cache_list[i]) {
+ if (pg_slab == cache_list[i]) {
if (!readmem(cache_list[i] + OFFSET(kmem_cache_name),
KVADDR, &name, sizeof(char *),
"kmem_cache.name", QUIET|RETURN_ON_ERROR))
--
2.25.1
1 week
- 2
- 1
[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
1 week, 1 day
- 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
1 week, 1 day
- 2
- 2
Re: [PATCH v2 0/4] arm64: Introduction of support 16K page with 4-level table
by lijiang
On Tue, Sep 3, 2024 at 3:53 PM <devel-request(a)lists.crash-utility.osci.io>
wrote:
> Date: Tue, 3 Sep 2024 15:51:25 +0800
> From: Kuan-Ying Lee <kuan-ying.lee(a)canonical.com>
> Subject: [Crash-utility] [PATCH v2 0/4] arm64: Introduction of support
> 16K page with 4-level table
> To: kuan-ying.lee(a)canonical.com,
> devel(a)lists.crash-utility.osci.io
> Message-ID: <20240903075140.37728-1-kuan-ying.lee(a)canonical.com>
>
> 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.
>
>
Thank you for the update, Kuan-Ying.
For the v2: Ack
Lianbo
> V1->V2:
> - Simplify the PTE_TO_PHYS macro. Thanks Lianbo.
>
> 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 | 274 +++++++++++++++++++++++++++++++++++++++++---------------
> defs.h | 33 ++++++-
> 2 files changed, 231 insertions(+), 76 deletions(-)
>
> --
> 2.43.0
>
1 week, 5 days
- 2
- 2
[PATCH v7 00/15] 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 3 parts:
1) part1: preparations before stack unwinding support, some
bugs/regressions found when drafting this patchset.
2) part2: common part for all CPU archs, mainly dealing with
crash_target.c/gdb_interface.c files, in order to
support different archs.
3) part3: arch specific, for each ppc64/x86_64/arm64/vmware
stack unwinding support.
=== part 3
arm64: Add gdb stack unwinding support
vmware_guestdump: Various format versions support
x86_64: Add gdb stack unwinding support
ppc64: correct gdb passthroughs by implementing machdep->get_current_task_reg
=== part 2
Conditionally output gdb stack unwinding stop reasons
Stop stack unwinding at non-kernel address
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
=== part 1
Fix gdb_interface: restore gdb's output streams at end of gdb_interface
x86_64: Fix invalid input "=>" for bt command
Fix cpumask_t recursive dependence issue
Fix the regression of cpumask_t for xen hyper
===
v7 -> v6:
1) Reorganise the patchset, re-divided them into 3 part against the
previous 2 parts.
2) Re-dealed with the cpumask_t part, which solved the comment No.4
pointed out by lianbo in [4].
3) Add conditional output for the failing message of gdb stack unwinding.
see [PATCH 11/15] Conditionally output gdb stack unwinding stop reasons
4) Redraft the commit messages, updated some outdated info.
5) Merged "Let crash change gdb context" and "set_context(): check if
context is already current" into one.
[4]: https://www.mail-archive.com/devel@lists.crash-utility.osci.io/msg01067.html
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):
Fix gdb_interface: restore gdb's output streams at end of
gdb_interface
Remove 'frame' from prohibited commands list
ppc64: correct gdb passthroughs by implementing
machdep->get_current_task_reg
Alexey Makhalov (1):
vmware_guestdump: Various format versions support
Tao Liu (11):
Fix the regression of cpumask_t for xen hyper
Fix cpumask_t recursive dependence issue
x86_64: Fix invalid input "=>" for bt command
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
Conditionally output gdb stack unwinding stop reasons
x86_64: Add gdb stack unwinding support
arm64: Add gdb stack unwinding support
arm64.c | 120 +++++++++++++++--
crash_target.c | 71 ++++++----
defs.h | 194 ++++++++++++++++++++++++++-
gdb-10.2.patch | 96 ++++++++++++++
gdb_interface.c | 39 ++----
kernel.c | 63 +++++++--
ppc64.c | 174 +++++++++++++++++++++++-
symbols.c | 15 +++
task.c | 34 +++--
tools.c | 16 ++-
unwind_x86_64.h | 4 -
vmware_guestdump.c | 321 +++++++++++++++++++++++++++++++-------------
x86_64.c | 323 ++++++++++++++++++++++++++++++++++++++++-----
13 files changed, 1247 insertions(+), 223 deletions(-)
--
2.40.1
1 week, 6 days
- 2
- 19
Re: [PATCH] “kmem address” not working properly when redzone is enabled
by lijiang
On Fri, Aug 30, 2024 at 10:08 AM <devel-request(a)lists.crash-utility.osci.io>
wrote:
> Date: Fri, 30 Aug 2024 10:59:44 +1200
> From: Tao Liu <ltao(a)redhat.com>
> Subject: [Crash-utility] Re: [Crash-utility][PATCH] “kmem address” not
> working properly when redzone is enabled
> To: "Aureau, Georges (Kernel Tools ERT)" <georges.aureau(a)hpe.com>
> Cc: "devel(a)lists.crash-utility.osci.io"
> <devel(a)lists.crash-utility.osci.io>
> Message-ID:
> <
> CAO7dBbV96Ys8sQ1u00b2x1L9SCyEuAGqKaN6Gb4UDX-XbnZXdQ(a)mail.gmail.com>
> Content-Type: text/plain; charset="UTF-8"
>
> Hi Georges
>
> On Thu, Aug 29, 2024 at 9:55 PM Aureau, Georges (Kernel Tools ERT)
> <georges.aureau(a)hpe.com> wrote:
> >
> > 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".
> >
> Thanks for the fix, LGTM, so ack.
>
>
Applied:
https://github.com/crash-utility/crash/commit/f20a94016148dce397cded5b4ac...
Thanks
Lianbo
> Thanks,
> Tao Liu
>
> > 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) {
> > --
>
1 week, 6 days
- 1
- 0
Re: [PATCH] “kmem address” not working properly when redzone is enabled
by lijiang
Hi, Aureau
Thank you for the fix.
On Thu, Aug 29, 2024 at 5:56 PM <devel-request(a)lists.crash-utility.osci.io>
wrote:
> Date: Thu, 29 Aug 2024 09:15:36 +0000
> From: "Aureau, Georges (Kernel Tools ERT)" <georges.aureau(a)hpe.com>
> Subject: [Crash-utility][PATCH] “kmem address” not working properly
> when redzone is enabled
> To: "devel(a)lists.crash-utility.osci.io"
> <devel(a)lists.crash-utility.osci.io>
> Message-ID: <SJ0PR84MB1482E72F9E168B3B0CE885C89F962(a)SJ0PR84MB1482.NAMP
> RD84.PROD.OUTLOOK.COM>
> Content-Type: text/plain; charset="Windows-1252"
>
> 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".
>
>
Can you help add the result of the 'kmem address' command here? We can
clearly see what error it is.
And also please add the kernel commit to patch log:
kernel commit 2ca6d39b3102 ("slub: make ->red_left_pad unsigned int")
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));
> }
>
>
This change looks good to me, but I still have a question:
I can not reproduce the current issue, how did you reproduce this one? Can
you help list the steps to reproduce?
Thanks
Lianbo
> for (p = vaddr; p < vaddr + objects * si->size; p += si->size) {
>
> ------------------------------
>
1 week, 6 days
- 2
- 2
Re: [PATCH] kmem: fix the determination for slab page
by lijiang
On Fri, Aug 30, 2024 at 7:39 PM <devel-request(a)lists.crash-utility.osci.io>
wrote:
> Date: Fri, 30 Aug 2024 10:33:03 -0000
> From: qiwu.chen(a)transsion.com
> Subject: [Crash-utility] [PATCH] kmem: fix the determination for slab
> page
> To: devel(a)lists.crash-utility.osci.io
> Message-ID: <20240830103303.2824.23557(a)lists.crash-utility.osci.io>
> Content-Type: text/plain; charset="utf-8"
>
> 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.
>
>
Thank you for the fix, qiwu.
Can you help double check if the code related to PG_* flags in the crash
tool needs to be changed accordingly?
Thanks
Lianbo
> 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
>
1 week, 6 days
- 2
- 1
[PATCH v2 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.
V1->V2:
- Simplify the PTE_TO_PHYS macro. Thanks Lianbo.
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 | 274 +++++++++++++++++++++++++++++++++++++++++---------------
defs.h | 33 ++++++-
2 files changed, 231 insertions(+), 76 deletions(-)
--
2.43.0
2 weeks, 1 day
- 1
- 4
Re: [PATCH 1/4] arm64: fix indent issue and refactor PTE_TO_PHYS
by lijiang
Hi, Kuan Ying
Thank you for the patch set.
On Thu, Aug 22, 2024 at 3:50 PM <devel-request(a)lists.crash-utility.osci.io>
wrote:
> Date: Thu, 22 Aug 2024 15:43:16 +0800
> From: Kuan-Ying Lee <kuan-ying.lee(a)canonical.com>
> Subject: [Crash-utility] [PATCH 1/4] arm64: fix indent issue and
> refactor PTE_TO_PHYS
> To: kuan-ying.lee(a)canonical.com,
> devel(a)lists.crash-utility.osci.io
> Message-ID: <20240822074333.249243-2-kuan-ying.lee(a)canonical.com>
>
> 1. Fix indent issue.
> 2. Use PTE_TO_PHYS() to translate PTE to physical address instead of
> using open-coded to mask.
>
> Signed-off-by: Kuan-Ying Lee <kuan-ying.lee(a)canonical.com>
> ---
> arm64.c | 118 ++++++++++++++++++++++++++++----------------------------
> defs.h | 1 +
> 2 files changed, 61 insertions(+), 58 deletions(-)
>
> diff --git a/arm64.c b/arm64.c
> index 06e7451e0629..8812110fb950 100644
> --- a/arm64.c
> +++ b/arm64.c
> @@ -1881,8 +1881,11 @@ arm64_uvtop(struct task_context *tc, ulong uvaddr,
> physaddr_t *paddr, int verbos
>
> #define PTE_ADDR_LOW ((((1UL) << (48 - machdep->pageshift)) - 1) <<
> machdep->pageshift)
> #define PTE_ADDR_HIGH ((0xfUL) << 12)
> +#define PTE_ADDR_MASK (machdep->max_physmem_bits == 52 ? \
> + (PTE_ADDR_LOW | PTE_ADDR_HIGH) : PTE_ADDR_LOW)
> +#define PTE_ADDR_HIGH_SHIFT 36
> #define PTE_TO_PHYS(pteval) (machdep->max_physmem_bits == 52 ? \
> - (((pteval & PTE_ADDR_LOW) | ((pteval & PTE_ADDR_HIGH) << 36))) :
> (pteval & PTE_ADDR_LOW))
> + (((pteval & PTE_ADDR_LOW) | ((pteval & PTE_ADDR_HIGH) <<
> PTE_ADDR_HIGH_SHIFT))) : (pteval & PTE_ADDR_MASK))
>
Other changes are fine to me, only one question:
The macro PTE_ADDR_MASK looks redundant? And no need to use it in the macro
definition PTE_TO_PHYS, because only when the condition
'machdep->max_physmem_bits == 52' is false, the (pteval & PTE_ADDR_MASK)
gets executed, it is redundant to check the same condition again in the
macro PTE_ADDR_MASK.
Maybe it is good enough like this? And remove the macro definition
PTE_ADDR_MASK.
#define PTE_TO_PHYS(pteval) (machdep->max_physmem_bits == 52 ? \
- (((pteval & PTE_ADDR_LOW) | ((pteval & PTE_ADDR_HIGH) << 36))) :
(pteval & PTE_ADDR_LOW))
+ (((pteval & PTE_ADDR_LOW) | ((pteval & PTE_ADDR_HIGH) <<
PTE_ADDR_HIGH_SHIFT))) : (pteval & PTE_ADDR_LOW))
Just want to confirm with you.
Thanks
Lianbo
> #define PUD_TYPE_MASK 3
> #define PUD_TYPE_SECT 1
> @@ -1906,9 +1909,9 @@ arm64_vtop_2level_64k(ulong pgd, ulong vaddr,
> physaddr_t *paddr, int verbose)
> pgd_base = (ulong *)pgd;
> FILL_PGD(pgd_base, KVADDR, machdep->ptrs_per_pgd * sizeof(ulong));
> pgd_ptr = pgd_base + (((vaddr) >> PGDIR_SHIFT_L2_64K) &
> (machdep->ptrs_per_pgd - 1));
> - pgd_val = ULONG(machdep->pgd + PAGEOFFSET(pgd_ptr));
> - if (verbose)
> - fprintf(fp, " PGD: %lx => %lx\n", (ulong)pgd_ptr,
> pgd_val);
> + pgd_val = ULONG(machdep->pgd + PAGEOFFSET(pgd_ptr));
> + if (verbose)
> + fprintf(fp, " PGD: %lx => %lx\n", (ulong)pgd_ptr,
> pgd_val);
> if (!pgd_val)
> goto no_page;
>
> @@ -1918,7 +1921,7 @@ arm64_vtop_2level_64k(ulong pgd, ulong vaddr,
> physaddr_t *paddr, int verbose)
> */
>
> if ((pgd_val & PMD_TYPE_MASK) == PMD_TYPE_SECT) {
> - ulong sectionbase = (pgd_val & SECTION_PAGE_MASK_512MB) &
> PHYS_MASK;
> + ulong sectionbase = PTE_TO_PHYS(pgd_val &
> SECTION_PAGE_MASK_512MB);
> if (verbose) {
> fprintf(fp, " PAGE: %lx (512MB%s)\n\n",
> sectionbase,
> IS_ZEROPAGE(sectionbase) ? ", ZERO PAGE" :
> "");
> @@ -1928,17 +1931,17 @@ arm64_vtop_2level_64k(ulong pgd, ulong vaddr,
> physaddr_t *paddr, int verbose)
> return TRUE;
> }
>
> - pte_base = (ulong *)PTOV(pgd_val & PHYS_MASK &
> (s32)machdep->pagemask);
> + pte_base = (ulong *)PTOV(PTE_TO_PHYS(pgd_val));
> FILL_PTBL(pte_base, KVADDR, PTRS_PER_PTE_L2_64K * sizeof(ulong));
> pte_ptr = pte_base + (((vaddr) >> machdep->pageshift) &
> (PTRS_PER_PTE_L2_64K - 1));
> - pte_val = ULONG(machdep->ptbl + PAGEOFFSET(pte_ptr));
> - if (verbose)
> - fprintf(fp, " PTE: %lx => %lx\n", (ulong)pte_ptr,
> pte_val);
> + pte_val = ULONG(machdep->ptbl + PAGEOFFSET(pte_ptr));
> + if (verbose)
> + fprintf(fp, " PTE: %lx => %lx\n", (ulong)pte_ptr,
> pte_val);
> if (!pte_val)
> goto no_page;
>
> if (pte_val & PTE_VALID) {
> - *paddr = (PAGEBASE(pte_val) & PHYS_MASK) +
> PAGEOFFSET(vaddr);
> + *paddr = PTE_TO_PHYS(pte_val) + PAGEOFFSET(vaddr);
> if (verbose) {
> fprintf(fp, " PAGE: %lx %s\n\n",
> PAGEBASE(*paddr),
> IS_ZEROPAGE(PAGEBASE(*paddr)) ? "(ZERO
> PAGE)" : "");
> @@ -1972,9 +1975,9 @@ arm64_vtop_3level_64k(ulong pgd, ulong vaddr,
> physaddr_t *paddr, int verbose)
> pgd_base = (ulong *)pgd;
> FILL_PGD(pgd_base, KVADDR, machdep->ptrs_per_pgd * sizeof(ulong));
> pgd_ptr = pgd_base + (((vaddr) >> PGDIR_SHIFT_L3_64K) &
> (machdep->ptrs_per_pgd - 1));
> - pgd_val = ULONG(machdep->pgd + PGDIR_OFFSET_L3_64K(pgd_ptr));
> - if (verbose)
> - fprintf(fp, " PGD: %lx => %lx\n", (ulong)pgd_ptr,
> pgd_val);
> + pgd_val = ULONG(machdep->pgd + PGDIR_OFFSET_L3_64K(pgd_ptr));
> + if (verbose)
> + fprintf(fp, " PGD: %lx => %lx\n", (ulong)pgd_ptr,
> pgd_val);
> if (!pgd_val)
> goto no_page;
>
> @@ -1985,14 +1988,14 @@ arm64_vtop_3level_64k(ulong pgd, ulong vaddr,
> physaddr_t *paddr, int verbose)
> pmd_base = (ulong *)PTOV(PTE_TO_PHYS(pgd_val));
> FILL_PMD(pmd_base, KVADDR, PTRS_PER_PMD_L3_64K * sizeof(ulong));
> pmd_ptr = pmd_base + (((vaddr) >> PMD_SHIFT_L3_64K) &
> (PTRS_PER_PMD_L3_64K - 1));
> - pmd_val = ULONG(machdep->pmd + PAGEOFFSET(pmd_ptr));
> - if (verbose)
> - fprintf(fp, " PMD: %lx => %lx\n", (ulong)pmd_ptr,
> pmd_val);
> + pmd_val = ULONG(machdep->pmd + PAGEOFFSET(pmd_ptr));
> + if (verbose)
> + fprintf(fp, " PMD: %lx => %lx\n", (ulong)pmd_ptr,
> pmd_val);
> if (!pmd_val)
> goto no_page;
>
> if ((pmd_val & PMD_TYPE_MASK) == PMD_TYPE_SECT) {
> - ulong sectionbase = PTE_TO_PHYS(pmd_val) &
> SECTION_PAGE_MASK_512MB;
> + ulong sectionbase = PTE_TO_PHYS(pmd_val &
> SECTION_PAGE_MASK_512MB);
> if (verbose) {
> fprintf(fp, " PAGE: %lx (512MB%s)\n\n",
> sectionbase,
> IS_ZEROPAGE(sectionbase) ? ", ZERO PAGE" :
> "");
> @@ -2005,9 +2008,9 @@ arm64_vtop_3level_64k(ulong pgd, ulong vaddr,
> physaddr_t *paddr, int verbose)
> pte_base = (ulong *)PTOV(PTE_TO_PHYS(pmd_val));
> FILL_PTBL(pte_base, KVADDR, PTRS_PER_PTE_L3_64K * sizeof(ulong));
> pte_ptr = pte_base + (((vaddr) >> machdep->pageshift) &
> (PTRS_PER_PTE_L3_64K - 1));
> - pte_val = ULONG(machdep->ptbl + PAGEOFFSET(pte_ptr));
> - if (verbose)
> - fprintf(fp, " PTE: %lx => %lx\n", (ulong)pte_ptr,
> pte_val);
> + pte_val = ULONG(machdep->ptbl + PAGEOFFSET(pte_ptr));
> + if (verbose)
> + fprintf(fp, " PTE: %lx => %lx\n", (ulong)pte_ptr,
> pte_val);
> if (!pte_val)
> goto no_page;
>
> @@ -2045,7 +2048,7 @@ arm64_vtop_2level_16k(ulong pgd, ulong vaddr,
> physaddr_t *paddr, int verbose)
> pgd_base = (ulong *)pgd;
> FILL_PGD(pgd_base, KVADDR, machdep->ptrs_per_pgd * sizeof(ulong));
> pgd_ptr = pgd_base + (((vaddr) >> PGDIR_SHIFT_L2_16K) &
> (machdep->ptrs_per_pgd - 1));
> - pgd_val = ULONG(machdep->pgd + PAGEOFFSET(pgd_ptr));
> + pgd_val = ULONG(machdep->pgd + PGDIR_OFFSET_L2_16K(pgd_ptr));
> if (verbose)
> fprintf(fp, " PGD: %lx => %lx\n", (ulong)pgd_ptr,
> pgd_val);
> if (!pgd_val)
> @@ -2057,7 +2060,7 @@ arm64_vtop_2level_16k(ulong pgd, ulong vaddr,
> physaddr_t *paddr, int verbose)
> */
>
> if ((pgd_val & PMD_TYPE_MASK) == PMD_TYPE_SECT) {
> - ulong sectionbase = (pgd_val & SECTION_PAGE_MASK_32MB) &
> PHYS_MASK;
> + ulong sectionbase = PTE_TO_PHYS(pgd_val &
> SECTION_PAGE_MASK_32MB);
> if (verbose) {
> fprintf(fp, " PAGE: %lx (32MB%s)\n\n",
> sectionbase,
> IS_ZEROPAGE(sectionbase) ? ", ZERO PAGE" :
> "");
> @@ -2067,7 +2070,7 @@ arm64_vtop_2level_16k(ulong pgd, ulong vaddr,
> physaddr_t *paddr, int verbose)
> return TRUE;
> }
>
> - pte_base = (ulong *)PTOV(pgd_val & PHYS_MASK &
> (s32)machdep->pagemask);
> + pte_base = (ulong *)PTOV(PTE_TO_PHYS(pgd_val));
> FILL_PTBL(pte_base, KVADDR, PTRS_PER_PTE_L2_16K * sizeof(ulong));
> pte_ptr = pte_base + (((vaddr) >> machdep->pageshift) &
> (PTRS_PER_PTE_L2_16K - 1));
> pte_val = ULONG(machdep->ptbl + PAGEOFFSET(pte_ptr));
> @@ -2077,7 +2080,7 @@ arm64_vtop_2level_16k(ulong pgd, ulong vaddr,
> physaddr_t *paddr, int verbose)
> goto no_page;
>
> if (pte_val & PTE_VALID) {
> - *paddr = (PAGEBASE(pte_val) & PHYS_MASK) +
> PAGEOFFSET(vaddr);
> + *paddr = PTE_TO_PHYS(pte_val) + PAGEOFFSET(vaddr);
> if (verbose) {
> fprintf(fp, " PAGE: %lx %s\n\n",
> PAGEBASE(*paddr),
> IS_ZEROPAGE(PAGEBASE(*paddr)) ? "(ZERO
> PAGE)" : "");
> @@ -2130,7 +2133,7 @@ arm64_vtop_3level_16k(ulong pgd, ulong vaddr,
> physaddr_t *paddr, int verbose)
> goto no_page;
>
> if ((pmd_val & PMD_TYPE_MASK) == PMD_TYPE_SECT) {
> - ulong sectionbase = PTE_TO_PHYS(pmd_val) &
> SECTION_PAGE_MASK_32MB;
> + ulong sectionbase = PTE_TO_PHYS(pmd_val &
> SECTION_PAGE_MASK_32MB);
> if (verbose) {
> fprintf(fp, " PAGE: %lx (32MB%s)\n\n",
> sectionbase,
> IS_ZEROPAGE(sectionbase) ? ", ZERO PAGE" :
> "");
> @@ -2184,14 +2187,14 @@ arm64_vtop_3level_4k(ulong pgd, ulong vaddr,
> physaddr_t *paddr, int verbose)
> pgd_base = (ulong *)pgd;
> FILL_PGD(pgd_base, KVADDR, PTRS_PER_PGD_L3_4K * sizeof(ulong));
> pgd_ptr = pgd_base + (((vaddr) >> PGDIR_SHIFT_L3_4K) &
> (PTRS_PER_PGD_L3_4K - 1));
> - pgd_val = ULONG(machdep->pgd + PAGEOFFSET(pgd_ptr));
> - if (verbose)
> - fprintf(fp, " PGD: %lx => %lx\n", (ulong)pgd_ptr,
> pgd_val);
> + pgd_val = ULONG(machdep->pgd + PAGEOFFSET(pgd_ptr));
> + if (verbose)
> + fprintf(fp, " PGD: %lx => %lx\n", (ulong)pgd_ptr,
> pgd_val);
> if (!pgd_val)
> goto no_page;
>
> if ((pgd_val & PUD_TYPE_MASK) == PUD_TYPE_SECT) {
> - ulong sectionbase = (pgd_val & SECTION_PAGE_MASK_1GB) &
> PHYS_MASK;
> + ulong sectionbase = PTE_TO_PHYS(pgd_val &
> SECTION_PAGE_MASK_1GB);
> if (verbose) {
> fprintf(fp, " PAGE: %lx (1GB)\n\n", sectionbase);
> arm64_translate_pte(pgd_val, 0, 0);
> @@ -2203,17 +2206,17 @@ arm64_vtop_3level_4k(ulong pgd, ulong vaddr,
> physaddr_t *paddr, int verbose)
> * #define __PAGETABLE_PUD_FOLDED
> */
>
> - pmd_base = (ulong *)PTOV(pgd_val & PHYS_MASK &
> (s32)machdep->pagemask);
> + pmd_base = (ulong *)PTOV(PTE_TO_PHYS(pgd_val));
> FILL_PMD(pmd_base, KVADDR, PTRS_PER_PMD_L3_4K * sizeof(ulong));
> pmd_ptr = pmd_base + (((vaddr) >> PMD_SHIFT_L3_4K) &
> (PTRS_PER_PMD_L3_4K - 1));
> - pmd_val = ULONG(machdep->pmd + PAGEOFFSET(pmd_ptr));
> - if (verbose)
> - fprintf(fp, " PMD: %lx => %lx\n", (ulong)pmd_ptr,
> pmd_val);
> + pmd_val = ULONG(machdep->pmd + PAGEOFFSET(pmd_ptr));
> + if (verbose)
> + fprintf(fp, " PMD: %lx => %lx\n", (ulong)pmd_ptr,
> pmd_val);
> if (!pmd_val)
> goto no_page;
>
> if ((pmd_val & PMD_TYPE_MASK) == PMD_TYPE_SECT) {
> - ulong sectionbase = (pmd_val & SECTION_PAGE_MASK_2MB) &
> PHYS_MASK;
> + ulong sectionbase = PTE_TO_PHYS(pmd_val &
> SECTION_PAGE_MASK_2MB);
> if (verbose) {
> fprintf(fp, " PAGE: %lx (2MB%s)\n\n",
> sectionbase,
> IS_ZEROPAGE(sectionbase) ? ", ZERO PAGE" :
> "");
> @@ -2223,17 +2226,17 @@ arm64_vtop_3level_4k(ulong pgd, ulong vaddr,
> physaddr_t *paddr, int verbose)
> return TRUE;
> }
>
> - pte_base = (ulong *)PTOV(pmd_val & PHYS_MASK &
> (s32)machdep->pagemask);
> + pte_base = (ulong *)PTOV(PTE_TO_PHYS(pmd_val));
> FILL_PTBL(pte_base, KVADDR, PTRS_PER_PTE_L3_4K * sizeof(ulong));
> pte_ptr = pte_base + (((vaddr) >> machdep->pageshift) &
> (PTRS_PER_PTE_L3_4K - 1));
> - pte_val = ULONG(machdep->ptbl + PAGEOFFSET(pte_ptr));
> - if (verbose)
> - fprintf(fp, " PTE: %lx => %lx\n", (ulong)pte_ptr,
> pte_val);
> + pte_val = ULONG(machdep->ptbl + PAGEOFFSET(pte_ptr));
> + if (verbose)
> + fprintf(fp, " PTE: %lx => %lx\n", (ulong)pte_ptr,
> pte_val);
> if (!pte_val)
> goto no_page;
>
> if (pte_val & PTE_VALID) {
> - *paddr = (PAGEBASE(pte_val) & PHYS_MASK) +
> PAGEOFFSET(vaddr);
> + *paddr = PTE_TO_PHYS(pte_val) + PAGEOFFSET(vaddr);
> if (verbose) {
> fprintf(fp, " PAGE: %lx %s\n\n",
> PAGEBASE(*paddr),
> IS_ZEROPAGE(PAGEBASE(*paddr)) ? "(ZERO
> PAGE)" : "");
> @@ -2268,24 +2271,23 @@ arm64_vtop_4level_4k(ulong pgd, ulong vaddr,
> physaddr_t *paddr, int verbose)
> pgd_base = (ulong *)pgd;
> FILL_PGD(pgd_base, KVADDR, PTRS_PER_PGD_L4_4K * sizeof(ulong));
> pgd_ptr = pgd_base + (((vaddr) >> PGDIR_SHIFT_L4_4K) &
> (PTRS_PER_PGD_L4_4K - 1));
> - pgd_val = ULONG(machdep->pgd + PGDIR_OFFSET_48VA(pgd_ptr));
> - if (verbose)
> - fprintf(fp, " PGD: %lx => %lx\n", (ulong)pgd_ptr,
> pgd_val);
> + pgd_val = ULONG(machdep->pgd + PGDIR_OFFSET_48VA(pgd_ptr));
> + if (verbose)
> + fprintf(fp, " PGD: %lx => %lx\n", (ulong)pgd_ptr,
> pgd_val);
> if (!pgd_val)
> goto no_page;
>
> - pud_base = (ulong *)PTOV(pgd_val & PHYS_MASK & PGDIR_MASK_48VA);
> -
> + pud_base = (ulong *)PTOV(PTE_TO_PHYS(pgd_val));
> FILL_PUD(pud_base, KVADDR, PTRS_PER_PUD_L4_4K * sizeof(ulong));
> pud_ptr = pud_base + (((vaddr) >> PUD_SHIFT_L4_4K) &
> (PTRS_PER_PUD_L4_4K - 1));
> - pud_val = ULONG(machdep->pud + PAGEOFFSET(pud_ptr));
> - if (verbose)
> - fprintf(fp, " PUD: %lx => %lx\n", (ulong)pud_ptr,
> pud_val);
> + pud_val = ULONG(machdep->pud + PAGEOFFSET(pud_ptr));
> + if (verbose)
> + fprintf(fp, " PUD: %lx => %lx\n", (ulong)pud_ptr,
> pud_val);
> if (!pud_val)
> goto no_page;
>
> if ((pud_val & PUD_TYPE_MASK) == PUD_TYPE_SECT) {
> - ulong sectionbase = (pud_val & SECTION_PAGE_MASK_1GB) &
> PHYS_MASK;
> + ulong sectionbase = PTE_TO_PHYS(pud_val &
> SECTION_PAGE_MASK_1GB);
> if (verbose) {
> fprintf(fp, " PAGE: %lx (1GB)\n\n", sectionbase);
> arm64_translate_pte(pud_val, 0, 0);
> @@ -2294,17 +2296,17 @@ arm64_vtop_4level_4k(ulong pgd, ulong vaddr,
> physaddr_t *paddr, int verbose)
> return TRUE;
> }
>
> - pmd_base = (ulong *)PTOV(pud_val & PHYS_MASK &
> (s32)machdep->pagemask);
> + pmd_base = (ulong *)PTOV(PTE_TO_PHYS(pud_val));
> FILL_PMD(pmd_base, KVADDR, PTRS_PER_PMD_L4_4K * sizeof(ulong));
> pmd_ptr = pmd_base + (((vaddr) >> PMD_SHIFT_L4_4K) &
> (PTRS_PER_PMD_L4_4K - 1));
> - pmd_val = ULONG(machdep->pmd + PAGEOFFSET(pmd_ptr));
> - if (verbose)
> - fprintf(fp, " PMD: %lx => %lx\n", (ulong)pmd_ptr,
> pmd_val);
> + pmd_val = ULONG(machdep->pmd + PAGEOFFSET(pmd_ptr));
> + if (verbose)
> + fprintf(fp, " PMD: %lx => %lx\n", (ulong)pmd_ptr,
> pmd_val);
> if (!pmd_val)
> goto no_page;
>
> if ((pmd_val & PMD_TYPE_MASK) == PMD_TYPE_SECT) {
> - ulong sectionbase = (pmd_val & SECTION_PAGE_MASK_2MB) &
> PHYS_MASK;
> + ulong sectionbase = PTE_TO_PHYS(pmd_val &
> SECTION_PAGE_MASK_2MB);
> if (verbose) {
> fprintf(fp, " PAGE: %lx (2MB%s)\n\n",
> sectionbase,
> IS_ZEROPAGE(sectionbase) ? ", ZERO PAGE" :
> "");
> @@ -2314,17 +2316,17 @@ arm64_vtop_4level_4k(ulong pgd, ulong vaddr,
> physaddr_t *paddr, int verbose)
> return TRUE;
> }
>
> - pte_base = (ulong *)PTOV(pmd_val & PHYS_MASK &
> (s32)machdep->pagemask);
> + pte_base = (ulong *)PTOV(PTE_TO_PHYS(pmd_val));
> FILL_PTBL(pte_base, KVADDR, PTRS_PER_PTE_L4_4K * sizeof(ulong));
> pte_ptr = pte_base + (((vaddr) >> machdep->pageshift) &
> (PTRS_PER_PTE_L4_4K - 1));
> - pte_val = ULONG(machdep->ptbl + PAGEOFFSET(pte_ptr));
> - if (verbose)
> - fprintf(fp, " PTE: %lx => %lx\n", (ulong)pte_ptr,
> pte_val);
> + pte_val = ULONG(machdep->ptbl + PAGEOFFSET(pte_ptr));
> + if (verbose)
> + fprintf(fp, " PTE: %lx => %lx\n", (ulong)pte_ptr,
> pte_val);
> if (!pte_val)
> goto no_page;
>
> if (pte_val & PTE_VALID) {
> - *paddr = (PAGEBASE(pte_val) & PHYS_MASK) +
> PAGEOFFSET(vaddr);
> + *paddr = PTE_TO_PHYS(pte_val) + PAGEOFFSET(vaddr);
> if (verbose) {
> fprintf(fp, " PAGE: %lx %s\n\n",
> PAGEBASE(*paddr),
> IS_ZEROPAGE(PAGEBASE(*paddr)) ? "(ZERO
> PAGE)" : "");
> diff --git a/defs.h b/defs.h
> index dfbd2419f969..92e8708367d1 100644
> --- a/defs.h
> +++ b/defs.h
> @@ -3311,6 +3311,7 @@ typedef signed int s32;
> #define PGDIR_SHIFT_L2_16K (25)
> #define PGDIR_SIZE_L2_16K ((1UL) << PGDIR_SHIFT_L2_16K)
> #define PGDIR_MASK_L2_16K (~(PGDIR_SIZE_L2_16K-1))
> +#define PGDIR_OFFSET_L2_16K(X) (((ulong)(X)) & ((machdep->ptrs_per_pgd *
> 8) - 1))
>
> /*
> * 3-levels / 16K pages
> --
> 2.43.0
>
2 weeks, 1 day
- 2
- 1