3:06 p.m.
search:
-f struct-page.flags-mask
When searching kernel memory, crash walks through all identity
mapping space which includes all physical memory. Nowadays we
have machines that equipped with more than 256G memory, it takes
a long time to go through all pages, especially most of them
are used by user space programs (e.g. LRU pages). This option
allows us to skip pages with certain struct page flags.
-g
Allow us to skip whole compound pages instead of only skipping
head pages when using -f, because some flags are only set to
head pages which tails pages share same properties with their
head pages.
kmem:
-k
Verify compound page order. Useful when debugging memory leak
caused by freeing compound pages with wrong order.
-r
Only print used pages (i.e. the page count is not zero). Makes
the output smaller (and faster to grep/vim/emacs).
Yu Zhao (5):
memory: better compound page support
memory: struct page.flags based filter
memory: skip compound pages when using search filter
memory: display and verify compound page order
memory: kmem option to skip free pages
defs.h | 4 +
help.c | 24 +++-
memory.c | 418 ++++++++++++++++++++++++++++++++++++++++++++++++---------------
3 files changed, 345 insertions(+), 101 deletions(-)
--
2.2.0.rc0.207.ga3a616c
3:06 p.m.
New subject: [PATCH 1/5] memory: better compound page support
---
defs.h | 4 ++
memory.c | 157 +++++++++++++++++++++++++++++++++++++++++++++++----------------
2 files changed, 121 insertions(+), 40 deletions(-)
diff --git a/defs.h b/defs.h
index 8fc5121..ede0830 100644
--- a/defs.h
+++ b/defs.h
@@ -2214,7 +2214,11 @@ struct vm_table { /* kernel VM-related data */
ulong kmem_cache_len_nodes;
ulong PG_reserved;
ulong PG_slab;
+ ulong PG_head;
+ ulong PG_tail;
+ ulong PG_head_mask;
ulong PG_head_tail_mask;
+ int is_pageflags_extended; /* CONFIG_PAGEFLAGS_EXTENDED */
int kmem_cache_namelen;
ulong page_hash_table;
int page_hash_table_len;
diff --git a/memory.c b/memory.c
index 051800f..2208553 100644
--- a/memory.c
+++ b/memory.c
@@ -268,6 +268,13 @@ static int generic_write_dumpfile(ulonglong, void *, long, char *,
ulong);
static int page_to_nid(ulong);
static int get_kmem_cache_list(ulong **);
static int get_kmem_cache_slub_data(long, struct meminfo *);
+static int __is_page_head(const char *);
+static int is_page_head(ulong);
+static int __is_page_tail(const char *);
+static int is_page_tail(ulong);
+static int __compound_order(const char *);
+static int compound_order(ulong);
+static ulong __compound_head(const char *);
static ulong compound_head(ulong);
static long count_partial(ulong, struct meminfo *);
static ulong get_freepointer(struct meminfo *, void *);
@@ -4866,34 +4873,32 @@ PG_slab_flag_init(void)
}
}
- if (vt->flags & KMALLOC_SLUB) {
- /*
- * PG_slab and the following are hardwired for
- * kernels prior to the pageflags enumerator.
+ if (enumerator_value("PG_head", &flags) &&
+ enumerator_value("PG_tail", &flags2)) {
+ vt->PG_head = 1L << flags;
+ vt->PG_tail = 1L << flags2;
+ vt->is_pageflags_extended = 1;
+ if (CRASHDEBUG(2))
+ fprintf(fp, "PG_head: %lx, PG_tail: %lx\n",
+ vt->PG_head, vt->PG_tail);
+ } else if (enumerator_value("PG_compound", &flags) &&
+ enumerator_value("PG_reclaim", &flags2)) {
+ vt->PG_head_mask = 1L << flags;
+ vt->PG_head_tail_mask = (1L << flags) | (1L << flags2);
+ if (CRASHDEBUG(2))
+ fprintf(fp, "PG_head_mask: %lx, PG_head_tail_mask: %lx\n",
+ vt->PG_head_mask, vt->PG_head_tail_mask);
+ } else if (vt->flags & KMALLOC_SLUB) {
+ /*
+ * PG_slab and the following are hardwired for
+ * kernels prior to the pageflags enumerator.
*/
-#define PG_compound 14 /* Part of a compound page */
-#define PG_reclaim 17 /* To be reclaimed asap */
- vt->PG_head_tail_mask = ((1L << PG_compound) | (1L << PG_reclaim));
-
- if (enumerator_value("PG_tail", (long *)&flags))
- vt->PG_head_tail_mask = (1L << flags);
- else if (enumerator_value("PG_compound", (long *)&flags) &&
- enumerator_value("PG_reclaim", (long *)&flags2)) {
- vt->PG_head_tail_mask = ((1L << flags) | (1L << flags2));
- if (CRASHDEBUG(2))
- fprintf(fp, "PG_head_tail_mask: %lx\n",
- vt->PG_head_tail_mask);
- }
- } else {
- if (enumerator_value("PG_tail", (long *)&flags))
- vt->PG_head_tail_mask = (1L << flags);
- else if (enumerator_value("PG_compound", (long *)&flags) &&
- enumerator_value("PG_reclaim", (long *)&flags2)) {
- vt->PG_head_tail_mask = ((1L << flags) | (1L << flags2));
- if (CRASHDEBUG(2))
- fprintf(fp, "PG_head_tail_mask: %lx (PG_compound|PG_reclaim)\n",
- vt->PG_head_tail_mask);
- }
+#define PG_compound 14 /* Part of a compound page */
+#define PG_reclaim 17 /* To be reclaimed asap */
+ vt->PG_head_mask = 1L << PG_compound;
+ vt->PG_head_tail_mask = (1L << PG_compound) | (1L << PG_reclaim);
+ if (CRASHDEBUG(2))
+ fprintf(fp, "hardwired PG_compound and PG_reclaim\n");
}
if (!vt->PG_slab)
@@ -13213,7 +13218,13 @@ dump_vm_table(int verbose)
fprintf(fp, " PG_reserved: %lx\n", vt->PG_reserved);
fprintf(fp, " PG_slab: %ld (%lx)\n", vt->PG_slab,
(ulong)1 << vt->PG_slab);
- fprintf(fp, " PG_head_tail_mask: %lx\n", vt->PG_head_tail_mask);
+ if (vt->is_pageflags_extended) {
+ fprintf(fp, " PG_head: %lx\n", vt->PG_head);
+ fprintf(fp, " PG_tail: %lx\n", vt->PG_tail);
+ } else {
+ fprintf(fp, " PG_head_mask: %lx\n", vt->PG_head_mask);
+ fprintf(fp, " PG_head_tail_mask: %lx\n", vt->PG_head_tail_mask);
+ }
fprintf(fp, " nr_pageflags: %d\n", vt->nr_pageflags);
fprintf(fp, " pageflags_data: %s\n",
@@ -18179,6 +18190,80 @@ get_kmem_cache_list(ulong **cache_buf)
return cnt;
}
+static int
+__is_page_head(const char *p)
+{
+ ulong flags = ULONG(p + OFFSET(page_flags));
+
+ return vt->is_pageflags_extended ? flags & vt->PG_head :
+ flags & vt->PG_head_tail_mask == vt->PG_head_mask;
+}
+
+static int
+is_page_head(ulong page)
+{
+ ulong flags;
+
+ if (!readmem(page + OFFSET(page_flags), KVADDR, &flags, sizeof(flags),
+ "page.flags", RETURN_ON_ERROR))
+ return 1;
+
+ return vt->is_pageflags_extended ? flags & vt->PG_head :
+ flags & vt->PG_head_tail_mask == vt->PG_head_mask;
+}
+
+static int
+__is_page_tail(const char *p)
+{
+ ulong flags = ULONG(p + OFFSET(page_flags));
+
+ return vt->is_pageflags_extended ? flags & vt->PG_tail :
+ flags & vt->PG_head_tail_mask == vt->PG_head_tail_mask;
+}
+
+static int
+is_page_tail(ulong page)
+{
+ ulong flags;
+
+ if (!readmem(page + OFFSET(page_flags), KVADDR, &flags, sizeof(flags),
+ "page.flags", RETURN_ON_ERROR))
+ return 0;
+
+ return vt->is_pageflags_extended ? flags & vt->PG_tail :
+ flags & vt->PG_head_tail_mask == vt->PG_head_tail_mask;
+}
+
+static int
+__compound_order(const char *p)
+{
+ if (!__is_page_head(p))
+ return 0;
+
+ return ULONG(p + SIZE(page) + OFFSET(page_lru) + OFFSET(list_head_prev));
+}
+
+static int
+compound_order(ulong page)
+{
+
+ ulong order = 0;
+
+ if (is_page_head(page))
+ readmem(page + SIZE(page) + OFFSET(page_lru) + OFFSET(list_head_prev),
+ KVADDR, &order, sizeof(order), "page.lru.prev", FAULT_ON_ERROR);
+
+ return order;
+}
+
+/*
+ * In contrast to compound_head(), this function only can be used on a tail page.
+ */
+static ulong
+__compound_head(const char *p)
+{
+ return ULONG(p + OFFSET(page_first_page));
+}
/*
* Get the address of the head page of a compound page.
@@ -18186,19 +18271,11 @@ get_kmem_cache_list(ulong **cache_buf)
static ulong
compound_head(ulong page)
{
- ulong flags, first_page;;
+ if (is_page_tail(page))
+ readmem(page + OFFSET(page_first_page), KVADDR, &page,
+ sizeof(page), "page.first_page", RETURN_ON_ERROR);
- first_page = page;
-
- if (!readmem(page+OFFSET(page_flags), KVADDR, &flags, sizeof(ulong),
- "page.flags", RETURN_ON_ERROR))
- return first_page;
-
- if ((flags & vt->PG_head_tail_mask) == vt->PG_head_tail_mask)
- readmem(page+OFFSET(page_first_page), KVADDR, &first_page,
- sizeof(ulong), "page.first_page", RETURN_ON_ERROR);
-
- return first_page;
+ return page;
}
long
--
2.2.0.rc0.207.ga3a616c
3:06 p.m.
New subject: [PATCH 2/5] memory: struct page.flags based filter
Command search walks through all pages in identity mapping (i.e. virtual
address space starting at PAGE_OFFSET and ending at high_memory) when
it's used to search kernel memory. The new option -f allows the command
to skip some uninteresting pages (e.g. LRU pages) to speed up the search.
---
help.c | 11 +++++-
memory.c | 123 +++++++++++++++++++++++++++++++++++++++++++++++++--------------
2 files changed, 107 insertions(+), 27 deletions(-)
diff --git a/help.c b/help.c
index b2f4d21..8d45667 100644
--- a/help.c
+++ b/help.c
@@ -2814,7 +2814,8 @@ char *help_search[] = {
"search",
"search memory",
"[-s start] [ -[kKV] | -u | -p | -t ] [-e end | -l length] [-m mask]\n"
-" [-x count] -[cwh] [value | (expression) | symbol | string] ...",
+" [-f struct-page.flags-mask] [-x count] -[cwh] "
+" [value | (expression) | symbol | string] ...",
" This command searches for a given value within a range of user virtual,
kernel",
" virtual, or physical memory space. If no end nor length value is entered,
",
" then the search stops at the end of user virtual, kernel virtual, or
physical",
@@ -2849,6 +2850,11 @@ char *help_search[] = {
" must be appropriate for the memory type specified.",
" -l length Length in bytes of address range to search.",
" -m mask Ignore the bits that are set in the hexadecimal mask value.",
+" -f struct-page.flags-mask",
+" Only search pages when page.flags & mask is true, or not true
when",
+" the mask is preceded by a letter n. When used multiple times,
only",
+" pages that meet all conditions will be searched. Only works
for",
+" virtual address space (either user or kernel).",
" -c Search for character string values instead of unsigned longs.
If",
" the string contains any space(s), it must be encompassed by
double",
" quotes.",
@@ -2986,6 +2992,9 @@ char *help_search[] = {
" ffff8100399565a8: ffffffff80493d60 (anon_inode_inode)",
" ffff81003a278cd0: ffffffff800649d6 (__down_interruptible+191)",
" ffff81003cc23e08: ffffffff800649d6 (__down_interruptible+191)",
+"\n Search kernel virtual address space for all instances of 0xdeadbeef",
+" within compound (PG_head|tail) pages that are not LRU pages:\n",
+" %s> search deadbeef -f c000 -f n20",
NULL
};
diff --git a/memory.c b/memory.c
index 2208553..70649a2 100644
--- a/memory.c
+++ b/memory.c
@@ -77,6 +77,16 @@ struct meminfo { /* general purpose memory information
structure */
};
/*
+ * Memory cache for struct page within range
+ * of kernel virtual address start and end.
+ */
+struct mem_map_cache {
+ ulong start;
+ ulong end;
+ char *cache;
+};
+
+/*
* Search modes
*/
@@ -100,6 +110,9 @@ struct searchinfo {
ulong vaddr_end;
ulonglong paddr_start;
ulonglong paddr_end;
+ int pg_nmasks;
+ char pg_mask_neg[MAXARGS];
+ ulong pg_mask[MAXARGS];
union {
/* default ulong search */
struct {
@@ -136,7 +149,7 @@ static char *memtype_string(int, int);
static char *error_handle_string(ulong);
static void dump_mem_map(struct meminfo *);
static void dump_mem_map_SPARSEMEM(struct meminfo *);
-static void fill_mem_map_cache(ulong, ulong, char *);
+static void fill_mem_map_cache(struct mem_map_cache *);
static void page_flags_init(void);
static int page_flags_init_from_pageflag_names(void);
static int page_flags_init_from_pageflags_enum(void);
@@ -4956,7 +4969,7 @@ dump_mem_map_SPARSEMEM(struct meminfo *mi)
ulong i;
long total_pages;
int others, page_not_mapped, phys_not_mapped, page_mapping;
- ulong pp, ppend;
+ ulong pp;
physaddr_t phys, physend;
ulong tmp, reserved, shared, slabs;
ulong PG_reserved_flag;
@@ -4970,12 +4983,12 @@ dump_mem_map_SPARSEMEM(struct meminfo *mi)
char buf2[BUFSIZE];
char buf3[BUFSIZE];
char buf4[BUFSIZE];
- char *page_cache;
char *pcache;
ulong section, section_nr, nr_mem_sections, section_size;
long buffersize;
char *outputbuffer;
int bufferindex;
+ struct mem_map_cache mmc;
buffersize = 1024 * 1024;
outputbuffer = GETBUF(buffersize + 512);
@@ -5101,7 +5114,7 @@ dump_mem_map_SPARSEMEM(struct meminfo *mi)
break;
}
- page_cache = GETBUF(SIZE(page) * PGMM_CACHED);
+ mmc.cache = GETBUF(SIZE(page) * PGMM_CACHED);
done = FALSE;
total_pages = 0;
@@ -5166,23 +5179,23 @@ dump_mem_map_SPARSEMEM(struct meminfo *mi)
i++, pp += SIZE(page), phys += PAGESIZE()) {
if ((i % PGMM_CACHED) == 0) {
-
- ppend = pp + ((PGMM_CACHED-1) * SIZE(page));
+ mmc.start = pp;
+ mmc.end = pp + ((PGMM_CACHED-1) * SIZE(page));
physend = phys + ((PGMM_CACHED-1) * PAGESIZE());
- if ((pg_spec && (mi->spec_addr > ppend)) ||
+ if ((pg_spec && (mi->spec_addr > mmc.end)) ||
(phys_spec &&
(PHYSPAGEBASE(mi->spec_addr) > physend))) {
i += (PGMM_CACHED-1);
- pp = ppend;
+ pp = mmc.end;
phys = physend;
continue;
}
- fill_mem_map_cache(pp, ppend, page_cache);
+ fill_mem_map_cache(&mmc);
}
- pcache = page_cache + ((i%PGMM_CACHED) * SIZE(page));
+ pcache = mmc.cache + ((i%PGMM_CACHED) * SIZE(page));
if (received_SIGINT())
restart(0);
@@ -5417,7 +5430,7 @@ dump_mem_map_SPARSEMEM(struct meminfo *mi)
}
FREEBUF(outputbuffer);
- FREEBUF(page_cache);
+ FREEBUF(mmc.cache);
}
static void
@@ -5426,7 +5439,7 @@ dump_mem_map(struct meminfo *mi)
long i, n;
long total_pages;
int others, page_not_mapped, phys_not_mapped, page_mapping;
- ulong pp, ppend;
+ ulong pp;
physaddr_t phys, physend;
ulong tmp, reserved, shared, slabs;
ulong PG_reserved_flag;
@@ -5442,11 +5455,11 @@ dump_mem_map(struct meminfo *mi)
char buf2[BUFSIZE];
char buf3[BUFSIZE];
char buf4[BUFSIZE];
- char *page_cache;
char *pcache;
long buffersize;
char *outputbuffer;
int bufferindex;
+ struct mem_map_cache mmc;
buffersize = 1024 * 1024;
outputbuffer = GETBUF(buffersize + 512);
@@ -5577,7 +5590,7 @@ dump_mem_map(struct meminfo *mi)
break;
}
- page_cache = GETBUF(SIZE(page) * PGMM_CACHED);
+ mmc.cache = GETBUF(SIZE(page) * PGMM_CACHED);
done = FALSE;
total_pages = 0;
@@ -5604,22 +5617,23 @@ dump_mem_map(struct meminfo *mi)
i++, pp += SIZE(page), phys += PAGESIZE()) {
if ((i % PGMM_CACHED) == 0) {
- ppend = pp + ((PGMM_CACHED-1) * SIZE(page));
+ mmc.start = pp;
+ mmc.end = pp + ((PGMM_CACHED-1) * SIZE(page));
physend = phys + ((PGMM_CACHED-1) * PAGESIZE());
- if ((pg_spec && (mi->spec_addr > ppend)) ||
+ if ((pg_spec && (mi->spec_addr > mmc.end)) ||
(phys_spec &&
(PHYSPAGEBASE(mi->spec_addr) > physend))) {
i += (PGMM_CACHED-1);
- pp = ppend;
+ pp = mmc.end;
phys = physend;
continue;
}
- fill_mem_map_cache(pp, ppend, page_cache);
+ fill_mem_map_cache(&mmc);
}
- pcache = page_cache + ((i%PGMM_CACHED) * SIZE(page));
+ pcache = mmc.cache + ((i%PGMM_CACHED) * SIZE(page));
if (received_SIGINT())
restart(0);
@@ -5855,7 +5869,7 @@ dump_mem_map(struct meminfo *mi)
}
FREEBUF(outputbuffer);
- FREEBUF(page_cache);
+ FREEBUF(mmc.cache);
}
/*
@@ -5866,7 +5880,7 @@ dump_mem_map(struct meminfo *mi)
* that are currently mapped, leaving the unmapped ones just zeroed out.
*/
static void
-fill_mem_map_cache(ulong pp, ulong ppend, char *page_cache)
+fill_mem_map_cache(struct mem_map_cache *mmc)
{
long size, cnt;
ulong addr;
@@ -5875,7 +5889,7 @@ fill_mem_map_cache(ulong pp, ulong ppend, char *page_cache)
/*
* Try to read it in one fell swoop.
*/
- if (readmem(pp, KVADDR, page_cache, SIZE(page) * PGMM_CACHED,
+ if (readmem(mmc->start, KVADDR, mmc->cache, SIZE(page) * PGMM_CACHED,
"page struct cache", RETURN_ON_ERROR|QUIET))
return;
@@ -5884,8 +5898,8 @@ fill_mem_map_cache(ulong pp, ulong ppend, char *page_cache)
* not a virtual mem_map.
*/
size = SIZE(page) * PGMM_CACHED;
- addr = pp;
- bufptr = page_cache;
+ addr = mmc->start;
+ bufptr = mmc->cache;
while (size > 0) {
/*
@@ -5899,7 +5913,7 @@ fill_mem_map_cache(ulong pp, ulong ppend, char *page_cache)
if (!readmem(addr, KVADDR, bufptr, size,
"virtual page struct cache", RETURN_ON_ERROR|QUIET)) {
BZERO(bufptr, size);
- if (!(vt->flags & V_MEM_MAP) && ((addr+size) < ppend))
+ if (!(vt->flags & V_MEM_MAP) && ((addr+size) < mmc->end))
error(WARNING,
"mem_map[] from %lx to %lx not accessible\n",
addr, addr+size);
@@ -13500,7 +13514,7 @@ cmd_search(void)
searchinfo.mode = SEARCH_ULONG; /* default search */
- while ((c = getopt(argcnt, args, "tl:ukKVps:e:v:m:hwcx:")) != EOF) {
+ while ((c = getopt(argcnt, args, "tl:ukKVps:e:v:m:f:hwcx:")) != EOF) {
switch(c)
{
case 'u':
@@ -13572,6 +13586,17 @@ cmd_search(void)
error(FATAL, "invalid ending address: 0\n");
break;
+ case 'f':
+ if (searchinfo.pg_nmasks == MAXARGS)
+ break;
+
+ c = *optarg == 'n';
+ searchinfo.pg_mask_neg[searchinfo.pg_nmasks] = c;
+ searchinfo.pg_mask[searchinfo.pg_nmasks] =
+ htol(optarg + c, FAULT_ON_ERROR, NULL);
+ searchinfo.pg_nmasks++;
+ break;
+
case 'l':
len = stol(optarg, FAULT_ON_ERROR, NULL);
break;
@@ -14409,6 +14434,42 @@ search_chars_p(ulong *bufptr, ulonglong addr_p, int longcnt,
struct searchinfo *
return addr_p;
}
+static int
+skip_pages(struct searchinfo *si, struct mem_map_cache *mmc, ulong page, ulong *pp)
+{
+ int i;
+ ulong flags;
+
+ if (page < mmc->start || page > mmc->end) {
+ mmc->start = page;
+ mmc->end = page + SIZE(page) * (PGMM_CACHED - 1);
+ fill_mem_map_cache(mmc);
+ }
+
+ flags = ULONG(mmc->cache + page - mmc->start + OFFSET(page_flags));
+
+ for (i = 0; i < si->pg_nmasks; i++) {
+ if ((si->pg_mask_neg[i] && si->pg_mask[i] & flags) ||
+ (!si->pg_mask_neg[i] && !(si->pg_mask[i] & flags)))
+ goto skip;
+ }
+
+ if (CRASHDEBUG(4))
+ fprintf(fp, "search page: struct %lx, vaddr %lx, flags %lx\n",
+ page, *pp, flags);
+
+ return 0;
+
+skip:
+ if (CRASHDEBUG(5))
+ fprintf(fp, "ignore page: struct %lx, vaddr %lx, flags %lx\n",
+ page, *pp, flags);
+
+ *pp += PAGESIZE();
+
+ return 1;
+}
+
static void
search_virtual(struct searchinfo *si)
{
@@ -14420,6 +14481,7 @@ search_virtual(struct searchinfo *si)
char *pagebuf;
ulong pct, pages_read, pages_checked;
time_t begin, finish;
+ struct mem_map_cache mmc;
start = si->vaddr_start;
end = si->vaddr_end;
@@ -14427,6 +14489,10 @@ search_virtual(struct searchinfo *si)
begin = finish = 0;
pagebuf = GETBUF(PAGESIZE());
+ if (si->pg_nmasks) {
+ mmc.start = mmc.end = 0;
+ mmc.cache = GETBUF(SIZE(page) * PGMM_CACHED);
+ }
if (start & (sizeof(long)-1)) {
start &= ~(sizeof(long)-1);
@@ -14482,6 +14548,9 @@ search_virtual(struct searchinfo *si)
break;
}
+ if (si->pg_nmasks && skip_pages(si, &mmc, page, &pp))
+ continue;
+
if (!readmem(paddr, PHYSADDR, pagebuf, PAGESIZE(),
"search page", RETURN_ON_ERROR|QUIET)) {
pp += PAGESIZE();
@@ -14536,6 +14605,8 @@ done:
}
FREEBUF(pagebuf);
+ if (si->pg_nmasks)
+ FREEBUF(mmc.cache);
}
--
2.2.0.rc0.207.ga3a616c
3:06 p.m.
New subject: [PATCH 3/5] memory: skip compound pages when using search filter
By default struct page.flags filter checks flags of every page. For
compound pages, some flags are only set to head page. The -g option
allows search to skip the whole compound page when the flags of head
page match the conditions.
---
help.c | 3 +++
memory.c | 21 +++++++++++++++++----
2 files changed, 20 insertions(+), 4 deletions(-)
diff --git a/help.c b/help.c
index 8d45667..716de33 100644
--- a/help.c
+++ b/help.c
@@ -2855,6 +2855,9 @@ char *help_search[] = {
" the mask is preceded by a letter n. When used multiple times,
only",
" pages that meet all conditions will be searched. Only works
for",
" virtual address space (either user or kernel).",
+" -g",
+" Skip whole compound page instead of only skipping head pages
when",
+" using with -f. Only has effect with -f.",
" -c Search for character string values instead of unsigned longs.
If",
" the string contains any space(s), it must be encompassed by
double",
" quotes.",
diff --git a/memory.c b/memory.c
index 70649a2..db7dddb 100644
--- a/memory.c
+++ b/memory.c
@@ -110,6 +110,7 @@ struct searchinfo {
ulong vaddr_end;
ulonglong paddr_start;
ulonglong paddr_end;
+ char pg_skip_compound_page;
int pg_nmasks;
char pg_mask_neg[MAXARGS];
ulong pg_mask[MAXARGS];
@@ -13514,7 +13515,7 @@ cmd_search(void)
searchinfo.mode = SEARCH_ULONG; /* default search */
- while ((c = getopt(argcnt, args, "tl:ukKVps:e:v:m:f:hwcx:")) != EOF) {
+ while ((c = getopt(argcnt, args, "tl:ukKVps:e:v:m:f:ghwcx:")) != EOF) {
switch(c)
{
case 'u':
@@ -13597,6 +13598,10 @@ cmd_search(void)
searchinfo.pg_nmasks++;
break;
+ case 'g':
+ searchinfo.pg_skip_compound_page = 1;
+ break;
+
case 'l':
len = stol(optarg, FAULT_ON_ERROR, NULL);
break;
@@ -14439,6 +14444,7 @@ skip_pages(struct searchinfo *si, struct mem_map_cache *mmc, ulong
page, ulong *
{
int i;
ulong flags;
+ int order;
if (page < mmc->start || page > mmc->end) {
mmc->start = page;
@@ -14461,11 +14467,18 @@ skip_pages(struct searchinfo *si, struct mem_map_cache *mmc,
ulong page, ulong *
return 0;
skip:
+ if (si->pg_skip_compound_page)
+ order = page + SIZE(page) < mmc->end ?
+ __compound_order(mmc->cache + page - mmc->start) :
+ compound_order(page);
+ else
+ order = 0;
+
if (CRASHDEBUG(5))
- fprintf(fp, "ignore page: struct %lx, vaddr %lx, flags %lx\n",
- page, *pp, flags);
+ fprintf(fp, "ignore page: struct %lx, vaddr %lx, flags %lx, order %d\n",
+ page, *pp, flags, order);
- *pp += PAGESIZE();
+ *pp += PAGESIZE() * (1 << order);
return 1;
}
--
2.2.0.rc0.207.ga3a616c
3:06 p.m.
New subject: [PATCH 4/5] memory: display and verify compound page order
Display compound page order when running command kmem with -p. Also
verifies compound pages based on: for head page, compound order can't
be zero; for tail page, its head page must exist. When verification
fails, display the compound order as -1.
---
help.c | 8 ++++-
memory.c | 114 +++++++++++++++++++++++++++++++++++++++++++++------------------
2 files changed, 88 insertions(+), 34 deletions(-)
diff --git a/help.c b/help.c
index 716de33..ffc8aeb 100644
--- a/help.c
+++ b/help.c
@@ -5541,7 +5541,7 @@ NULL
char *help_kmem[] = {
"kmem",
"kernel memory",
-"[-f|-F|-p|-c|-C|-i|-s|-S|-v|-V|-n|-z|-o|-h] [slab] [[-P] address]\n"
+"[-f|-F|-p|-c|-C|-i|-s|-S|-v|-V|-n|-z|-o|-h|-k] [slab] [[-P] address]\n"
" [-g [flags]] [-I slab[,slab]]",
" This command displays information about the use of kernel memory.\n",
" -f displays the contents of the system free memory headers.",
@@ -5570,6 +5570,12 @@ char *help_kmem[] = {
" \"flags\" field.",
" -h display the address of hugepage hstate array entries, along
with",
" their hugepage size, total and free counts, and name.",
+" -k verify compound page: if a page is head, check its compound
order",
+" which should not be zero; if a page is tail, check its head
page",
+" which should exist. The option is useful when debugging
problems",
+" caused by misuse of compound pages (e.g. free with wrong
order).",
+" When an error is found, the compound order will be shown as -1.",
+" Only works when -p is used without an address.",
" flags when used with -g, translates all bits in this hexadecimal page",
" structure flags value into its enumerator values.",
" slab when used with -s or -S, limits the command to only the slab
cache",
diff --git a/memory.c b/memory.c
index db7dddb..43ceff7 100644
--- a/memory.c
+++ b/memory.c
@@ -40,6 +40,7 @@ struct meminfo { /* general purpose memory information
structure */
ulong objects;
ulonglong spec_addr;
ulong flags;
+ ulong extra_flags;
ulong size;
ulong objsize;
int memtype;
@@ -288,6 +289,7 @@ static int __is_page_tail(const char *);
static int is_page_tail(ulong);
static int __compound_order(const char *);
static int compound_order(ulong);
+static int __check_compound_order(const char *, int);
static ulong __compound_head(const char *);
static ulong compound_head(ulong);
static long count_partial(ulong, struct meminfo *);
@@ -4422,6 +4424,8 @@ get_task_mem_usage(ulong task, struct task_mem_usage *tm)
#define SLAB_OVERLOAD_PAGE_PTR (ADDRESS_SPECIFIED << 24)
#define SLAB_BITFIELD (ADDRESS_SPECIFIED << 25)
+#define VERIFY_COMPOUND_PAGES (1 << 0)
+
#define GET_ALL \
(GET_SHARED_PAGES|GET_TOTALRAM_PAGES|GET_BUFFERS_PAGES|GET_SLAB_PAGES)
@@ -4432,6 +4436,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 kflag;
struct meminfo meminfo;
ulonglong value[MAXARGS];
char buf[BUFSIZE];
@@ -4441,12 +4446,12 @@ cmd_kmem(void)
spec_addr = 0;
sflag = Sflag = pflag = fflag = Fflag = Pflag = zflag = oflag = 0;
vflag = Cflag = cflag = iflag = nflag = lflag = Lflag = Vflag = 0;
- gflag = hflag = 0;
+ gflag = hflag = kflag = 0;
escape = FALSE;
BZERO(&meminfo, sizeof(struct meminfo));
BZERO(&value[0], sizeof(ulonglong)*MAXARGS);
- while ((c = getopt(argcnt, args, "gI:sSFfpvczCinl:L:PVoh")) != EOF) {
+ while ((c = getopt(argcnt, args, "gI:sSFfpkvczCinl:L:PVoh")) != EOF) {
switch(c)
{
case 'V':
@@ -4551,6 +4556,10 @@ cmd_kmem(void)
gflag = 1;
break;
+ case 'k':
+ kflag = 1;
+ break;
+
default:
argerrs++;
break;
@@ -4718,8 +4727,11 @@ cmd_kmem(void)
if (iflag == 1)
dump_kmeminfo();
- if (pflag == 1)
+ if (pflag == 1) {
+ if (kflag)
+ meminfo.extra_flags |= VERIFY_COMPOUND_PAGES;
dump_mem_map(&meminfo);
+ }
if (fflag == 1)
vt->dump_free_pages(&meminfo);
@@ -4984,12 +4996,14 @@ dump_mem_map_SPARSEMEM(struct meminfo *mi)
char buf2[BUFSIZE];
char buf3[BUFSIZE];
char buf4[BUFSIZE];
+ char buf5[BUFSIZE];
char *pcache;
ulong section, section_nr, nr_mem_sections, section_size;
long buffersize;
char *outputbuffer;
int bufferindex;
struct mem_map_cache mmc;
+ int order;
buffersize = 1024 * 1024;
outputbuffer = GETBUF(buffersize + 512);
@@ -5006,7 +5020,7 @@ dump_mem_map_SPARSEMEM(struct meminfo *mi)
VADDR_PRLEN,
space(MINSPACE),
space(MINSPACE));
- sprintf((char *)&style2, "%%-%dlx%s%%%dllx%s%s%s%s %2s ",
+ sprintf((char *)&style2, "%%-%dlx%s%%%dllx%s%s%s%s%%8d %2s ",
VADDR_PRLEN,
space(MINSPACE),
(int)MAX(PADDR_PRLEN, strlen("PHYSICAL")),
@@ -5015,7 +5029,7 @@ dump_mem_map_SPARSEMEM(struct meminfo *mi)
space(MINSPACE),
mkstring(buf4, 8, CENTER|RJUST, " "),
" ");
- sprintf((char *)&style3, "%%-%dlx%s%%%dllx%s%s%s%s %%2d ",
+ sprintf((char *)&style3, "%%-%dlx%s%%%dllx%s%s%s%s%%8d %%2d ",
VADDR_PRLEN,
space(MINSPACE),
(int)MAX(PADDR_PRLEN, strlen("PHYSICAL")),
@@ -5023,7 +5037,7 @@ dump_mem_map_SPARSEMEM(struct meminfo *mi)
mkstring(buf3, VADDR_PRLEN, CENTER|RJUST, "-------"),
space(MINSPACE),
mkstring(buf4, 8, CENTER|RJUST, "-----"));
- sprintf((char *)&style4, "%%-%dlx%s%%%dllx%s%%%dlx%s%%8lx %%2d ",
+ sprintf((char *)&style4, "%%-%dlx%s%%%dllx%s%%8d %%%dlx%s%%8lx %%2d ",
VADDR_PRLEN,
space(MINSPACE),
(int)MAX(PADDR_PRLEN, strlen("PHYSICAL")),
@@ -5045,15 +5059,17 @@ dump_mem_map_SPARSEMEM(struct meminfo *mi)
mkstring(buf4, 8, CENTER|LJUST, "OFFSET"),
space(MINSPACE-1));
} else {
- sprintf(hdr, "%s%s%s%s%s%s%sCNT FLAGS\n",
- mkstring(buf1, VADDR_PRLEN, CENTER, "PAGE"),
- space(MINSPACE),
- mkstring(buf2, MAX(PADDR_PRLEN, strlen("PHYSICAL")),
- RJUST, "PHYSICAL"),
- space(MINSPACE),
- mkstring(buf3, VADDR_PRLEN, CENTER|RJUST, "MAPPING"),
- space(MINSPACE),
- mkstring(buf4, 8, CENTER|RJUST, "INDEX"));
+ sprintf(hdr, "%s%s%s%s%s%s%s%s%sCNT FLAGS\n",
+ mkstring(buf1, VADDR_PRLEN, CENTER, "PAGE"),
+ space(MINSPACE),
+ mkstring(buf2, MAX(PADDR_PRLEN, strlen("PHYSICAL")),
+ RJUST, "PHYSICAL"),
+ space(MINSPACE),
+ mkstring(buf3, 8, CENTER | RJUST, "ORDER"),
+ space(MINSPACE),
+ mkstring(buf4, VADDR_PRLEN, CENTER | RJUST, "MAPPING"),
+ space(MINSPACE),
+ mkstring(buf5, 8, CENTER | RJUST, "INDEX"));
}
mapping = index = 0;
@@ -5281,6 +5297,12 @@ dump_mem_map_SPARSEMEM(struct meminfo *mi)
page_not_mapped = phys_not_mapped = FALSE;
+ order = (i + 1) % PGMM_CACHED ?
+ __compound_order(pcache) : compound_order(pp);
+
+ if (mi->extra_flags & VERIFY_COMPOUND_PAGES)
+ order = __check_compound_order(pcache, order);
+
if (v22) {
bufferindex += sprintf(outputbuffer+bufferindex,
(char *)&style1, pp, phys, inode,
@@ -5294,13 +5316,14 @@ dump_mem_map_SPARSEMEM(struct meminfo *mi)
}
if (page_not_mapped)
bufferindex += sprintf(outputbuffer+bufferindex,
- (char *)&style2, pp, phys);
+ (char *)&style2, pp, phys, order);
else if (!page_mapping)
bufferindex += sprintf(outputbuffer+bufferindex,
- (char *)&style3, pp, phys, count);
+ (char *)&style3, pp, phys, order,
+ count);
else
bufferindex += sprintf(outputbuffer+bufferindex,
- (char *)&style4, pp, phys,
+ (char *)&style4, pp, phys, order,
mapping, index, count);
}
@@ -5456,11 +5479,13 @@ dump_mem_map(struct meminfo *mi)
char buf2[BUFSIZE];
char buf3[BUFSIZE];
char buf4[BUFSIZE];
+ char buf5[BUFSIZE];
char *pcache;
long buffersize;
char *outputbuffer;
int bufferindex;
struct mem_map_cache mmc;
+ int order;
buffersize = 1024 * 1024;
outputbuffer = GETBUF(buffersize + 512);
@@ -5482,7 +5507,7 @@ dump_mem_map(struct meminfo *mi)
VADDR_PRLEN,
space(MINSPACE),
space(MINSPACE));
- sprintf((char *)&style2, "%%-%dlx%s%%%dllx%s%s%s%s %2s ",
+ sprintf((char *)&style2, "%%-%dlx%s%%%dllx%s%s%s%s%%8d %2s ",
VADDR_PRLEN,
space(MINSPACE),
(int)MAX(PADDR_PRLEN, strlen("PHYSICAL")),
@@ -5491,7 +5516,7 @@ dump_mem_map(struct meminfo *mi)
space(MINSPACE),
mkstring(buf4, 8, CENTER|RJUST, " "),
" ");
- sprintf((char *)&style3, "%%-%dlx%s%%%dllx%s%s%s%s %%2d ",
+ sprintf((char *)&style3, "%%-%dlx%s%%%dllx%s%s%s%s%%8d %%2d ",
VADDR_PRLEN,
space(MINSPACE),
(int)MAX(PADDR_PRLEN, strlen("PHYSICAL")),
@@ -5499,7 +5524,7 @@ dump_mem_map(struct meminfo *mi)
mkstring(buf3, VADDR_PRLEN, CENTER|RJUST, "-------"),
space(MINSPACE),
mkstring(buf4, 8, CENTER|RJUST, "-----"));
- sprintf((char *)&style4, "%%-%dlx%s%%%dllx%s%%%dlx%s%%8lx %%2d ",
+ sprintf((char *)&style4, "%%-%dlx%s%%%dllx%s%%8d %%%dlx%s%%8lx %%2d ",
VADDR_PRLEN,
space(MINSPACE),
(int)MAX(PADDR_PRLEN, strlen("PHYSICAL")),
@@ -5521,15 +5546,17 @@ dump_mem_map(struct meminfo *mi)
mkstring(buf4, 8, CENTER|LJUST, "OFFSET"),
space(MINSPACE-1));
} else {
- sprintf(hdr, "%s%s%s%s%s%s%sCNT FLAGS\n",
- mkstring(buf1, VADDR_PRLEN, CENTER, "PAGE"),
- space(MINSPACE),
- mkstring(buf2, MAX(PADDR_PRLEN, strlen("PHYSICAL")),
- RJUST, "PHYSICAL"),
- space(MINSPACE),
- mkstring(buf3, VADDR_PRLEN, CENTER|RJUST, "MAPPING"),
- space(MINSPACE),
- mkstring(buf4, 8, CENTER|RJUST, "INDEX"));
+ sprintf(hdr, "%s%s%s%s%s%s%s%s%sCNT FLAGS\n",
+ mkstring(buf1, VADDR_PRLEN, CENTER, "PAGE"),
+ space(MINSPACE),
+ mkstring(buf2, MAX(PADDR_PRLEN, strlen("PHYSICAL")),
+ RJUST, "PHYSICAL"),
+ space(MINSPACE),
+ mkstring(buf3, 8, CENTER | RJUST, "ORDER"),
+ space(MINSPACE),
+ mkstring(buf4, VADDR_PRLEN, CENTER | RJUST, "MAPPING"),
+ space(MINSPACE),
+ mkstring(buf5, 8, CENTER | RJUST, "INDEX"));
}
mapping = index = 0;
@@ -5720,6 +5747,12 @@ dump_mem_map(struct meminfo *mi)
page_not_mapped = phys_not_mapped = FALSE;
+ order = (i + 1) % PGMM_CACHED ?
+ __compound_order(pcache) : compound_order(pp);
+
+ if (mi->extra_flags & VERIFY_COMPOUND_PAGES)
+ order = __check_compound_order(pcache, order);
+
if (v22) {
bufferindex += sprintf(outputbuffer+bufferindex,
(char *)&style1, pp, phys, inode,
@@ -5733,13 +5766,14 @@ dump_mem_map(struct meminfo *mi)
}
if (page_not_mapped)
bufferindex += sprintf(outputbuffer+bufferindex,
- (char *)&style2, pp, phys);
+ (char *)&style2, pp, phys, order);
else if (!page_mapping)
bufferindex += sprintf(outputbuffer+bufferindex,
- (char *)&style3, pp, phys, count);
+ (char *)&style3, pp, phys, order,
+ count);
else
bufferindex += sprintf(outputbuffer+bufferindex,
- (char *)&style4, pp, phys,
+ (char *)&style4, pp, phys, order,
mapping, index, count);
}
@@ -18340,6 +18374,20 @@ compound_order(ulong page)
return order;
}
+static int
+__check_compound_order(const char *p, int order)
+{
+ /* head page must have non-zero order */
+ if (__is_page_head(p) && !order)
+ return -1;
+
+ /* tail page must have a non-zero order head */
+ if (__is_page_tail(p) && !compound_order(__compound_head(p)))
+ return -1;
+
+ return order;
+}
+
/*
* In contrast to compound_head(), this function only can be used on a tail page.
*/
--
2.2.0.rc0.207.ga3a616c
3:06 p.m.
New subject: [PATCH 5/5] memory: kmem option to skip free pages
---
help.c | 4 +++-
memory.c | 17 ++++++++++++++---
2 files changed, 17 insertions(+), 4 deletions(-)
diff --git a/help.c b/help.c
index ffc8aeb..0f1508d 100644
--- a/help.c
+++ b/help.c
@@ -5541,7 +5541,7 @@ NULL
char *help_kmem[] = {
"kmem",
"kernel memory",
-"[-f|-F|-p|-c|-C|-i|-s|-S|-v|-V|-n|-z|-o|-h|-k] [slab] [[-P] address]\n"
+"[-f|-F|-p|-c|-C|-i|-s|-S|-v|-V|-n|-z|-o|-h|-k|-r] [slab] [[-P] address]\n"
" [-g [flags]] [-I slab[,slab]]",
" This command displays information about the use of kernel memory.\n",
" -f displays the contents of the system free memory headers.",
@@ -5576,6 +5576,8 @@ char *help_kmem[] = {
" caused by misuse of compound pages (e.g. free with wrong
order).",
" When an error is found, the compound order will be shown as -1.",
" Only works when -p is used without an address.",
+" -r only print used pages (i.e. the page count is not zero).",
+" Only works when -p is used without an address.",
" flags when used with -g, translates all bits in this hexadecimal page",
" structure flags value into its enumerator values.",
" slab when used with -s or -S, limits the command to only the slab
cache",
diff --git a/memory.c b/memory.c
index 43ceff7..a1ef59a 100644
--- a/memory.c
+++ b/memory.c
@@ -4425,6 +4425,7 @@ get_task_mem_usage(ulong task, struct task_mem_usage *tm)
#define SLAB_BITFIELD (ADDRESS_SPECIFIED << 25)
#define VERIFY_COMPOUND_PAGES (1 << 0)
+#define SKIP_FREE_PAGES (1 << 1)
#define GET_ALL \
(GET_SHARED_PAGES|GET_TOTALRAM_PAGES|GET_BUFFERS_PAGES|GET_SLAB_PAGES)
@@ -4436,7 +4437,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 kflag;
+ int kflag, rflag;
struct meminfo meminfo;
ulonglong value[MAXARGS];
char buf[BUFSIZE];
@@ -4446,12 +4447,12 @@ cmd_kmem(void)
spec_addr = 0;
sflag = Sflag = pflag = fflag = Fflag = Pflag = zflag = oflag = 0;
vflag = Cflag = cflag = iflag = nflag = lflag = Lflag = Vflag = 0;
- gflag = hflag = kflag = 0;
+ gflag = hflag = kflag = rflag = 0;
escape = FALSE;
BZERO(&meminfo, sizeof(struct meminfo));
BZERO(&value[0], sizeof(ulonglong)*MAXARGS);
- while ((c = getopt(argcnt, args, "gI:sSFfpkvczCinl:L:PVoh")) != EOF) {
+ while ((c = getopt(argcnt, args, "gI:sSFfpkrvczCinl:L:PVoh")) != EOF)
{
switch(c)
{
case 'V':
@@ -4560,6 +4561,10 @@ cmd_kmem(void)
kflag = 1;
break;
+ case 'r':
+ rflag = 1;
+ break;
+
default:
argerrs++;
break;
@@ -4730,6 +4735,8 @@ cmd_kmem(void)
if (pflag == 1) {
if (kflag)
meminfo.extra_flags |= VERIFY_COMPOUND_PAGES;
+ if (rflag)
+ meminfo.extra_flags |= SKIP_FREE_PAGES;
dump_mem_map(&meminfo);
}
@@ -5228,6 +5235,8 @@ dump_mem_map_SPARSEMEM(struct meminfo *mi)
if (SIZE(page_flags) == 4)
flags &= 0xffffffff;
count = UINT(pcache + OFFSET(page_count));
+ if (!count && (mi->extra_flags & SKIP_FREE_PAGES))
+ continue;
switch (mi->flags)
{
@@ -5677,6 +5686,8 @@ dump_mem_map(struct meminfo *mi)
if (SIZE(page_flags) == 4)
flags &= 0xffffffff;
count = UINT(pcache + OFFSET(page_count));
+ if (!count && (mi->extra_flags & SKIP_FREE_PAGES))
+ continue;
switch (mi->flags)
{
--
2.2.0.rc0.207.ga3a616c
3:24 p.m.
Hello Yu,
I am going to defer the review/testing of this patchset until after crash-7.1.0
has been released, which I hopefully will get done tomorrow.
Thanks,
Dave
----- Original Message -----
search:
-f struct-page.flags-mask
When searching kernel memory, crash walks through all identity
mapping space which includes all physical memory. Nowadays we
have machines that equipped with more than 256G memory, it takes
a long time to go through all pages, especially most of them
are used by user space programs (e.g. LRU pages). This option
allows us to skip pages with certain struct page flags.
-g
Allow us to skip whole compound pages instead of only skipping
head pages when using -f, because some flags are only set to
head pages which tails pages share same properties with their
head pages.
kmem:
-k
Verify compound page order. Useful when debugging memory leak
caused by freeing compound pages with wrong order.
-r
Only print used pages (i.e. the page count is not zero). Makes
the output smaller (and faster to grep/vim/emacs).
Yu Zhao (5):
memory: better compound page support
memory: struct page.flags based filter
memory: skip compound pages when using search filter
memory: display and verify compound page order
memory: kmem option to skip free pages
defs.h | 4 +
help.c | 24 +++-
memory.c | 418
++++++++++++++++++++++++++++++++++++++++++++++++---------------
3 files changed, 345 insertions(+), 101 deletions(-)
--
2.2.0.rc0.207.ga3a616c
3:28 p.m.
----- Original Message -----
search:
-f struct-page.flags-mask
When searching kernel memory, crash walks through all identity
mapping space which includes all physical memory. Nowadays we
have machines that equipped with more than 256G memory, it takes
a long time to go through all pages, especially most of them
are used by user space programs (e.g. LRU pages). This option
allows us to skip pages with certain struct page flags.
-g
Allow us to skip whole compound pages instead of only skipping
head pages when using -f, because some flags are only set to
head pages which tails pages share same properties with their
head pages.
kmem:
-k
Verify compound page order. Useful when debugging memory leak
caused by freeing compound pages with wrong order.
-r
Only print used pages (i.e. the page count is not zero). Makes
the output smaller (and faster to grep/vim/emacs).
Yu Zhao (5):
memory: better compound page support
memory: struct page.flags based filter
memory: skip compound pages when using search filter
memory: display and verify compound page order
memory: kmem option to skip free pages
Hello Yu,
OK, initially I have looked at these patches from an end-user perspective,
and will wait on reviewing the technical implementation of your patchset
until some basics below are taken care of.
Also, can you separate this into two separate patchset postings, one for
the kmem command, and the other for the search command? I understand
they both use the compound page flag changes, but the common stuff can
be put in one or the other, and it can be specified that one patch
essentially depends upon the other being in place.
First, please fix these warnings:
$ make warn
... [ cut ] ...
cc -c -g -DX86_64 -DLZO -DSNAPPY -DGDB_7_6 memory.c -Wall -O2 -Wstrict-prototypes
-Wmissing-prototypes -fstack-protector -Wformat-security
memory.c: In function ‘PG_slab_flag_init’:
memory.c:4909:2: warning: pointer targets in passing argument 2 of ‘enumerator_value’
differ in signedness [-Wpointer-sign]
In file included from memory.c:19:0:
defs.h:4645:5: note: expected ‘long int *’ but argument is of type ‘ulong *’
memory.c:4910:6: warning: pointer targets in passing argument 2 of ‘enumerator_value’
differ in signedness [-Wpointer-sign]
In file included from memory.c:19:0:
defs.h:4645:5: note: expected ‘long int *’ but argument is of type ‘ulong *’
memory.c:4917:2: warning: pointer targets in passing argument 2 of ‘enumerator_value’
differ in signedness [-Wpointer-sign]
In file included from memory.c:19:0:
defs.h:4645:5: note: expected ‘long int *’ but argument is of type ‘ulong *’
memory.c:4918:13: warning: pointer targets in passing argument 2 of ‘enumerator_value’
differ in signedness [-Wpointer-sign]
In file included from memory.c:19:0:
defs.h:4645:5: note: expected ‘long int *’ but argument is of type ‘ulong *’
memory.c: In function ‘__is_page_head’:
memory.c:18332:9: warning: suggest parentheses around comparison in operand of ‘&’
[-Wparentheses]
memory.c: In function ‘is_page_head’:
memory.c:18345:9: warning: suggest parentheses around comparison in operand of ‘&’
[-Wparentheses]
memory.c: In function ‘__is_page_tail’:
memory.c:18354:9: warning: suggest parentheses around comparison in operand of ‘&’
[-Wparentheses]
memory.c: In function ‘is_page_tail’:
memory.c:18367:9: warning: suggest parentheses around comparison in operand of ‘&’
[-Wparentheses]
...
Since the kmem -k and -r flags are only relevant when used with -p,
then that should be specified clearly in the help page synopsis,
i.e., something like:
-"[-f|-F|-p|-c|-C|-i|-s|-S|-v|-V|-n|-z|-o|-h] [slab] [[-P] address]\n"
+"[-f|-F|-p [-k][-r]|-c|-C|-i|-s|-S|-v|-V|-n|-z|-o|-h] [slab] [[-P]
address]\n"
And in cmd_kmem(), any attempt to use -k or -r outside of kmem -p
should generate an error message and fail immediately. So in the case
of a specified address, put a check for the kflag and rflag right
after the for(...) line, and error(FATAL, ...) right there:
4607 for (i = 0; i < spec_addr; i++) {
4608
4609 if (Pflag)
4610 meminfo.memtype = PHYSADDR;
4611 else
4612 meminfo.memtype = IS_KVADDR(value[i]) ?
4613 KVADDR : PHYSADDR;
4614
4615 if (fflag) {
4616 meminfo.spec_addr = value[i];
4617 meminfo.flags = ADDRESS_SPECIFIED;
4618 if (meminfo.calls++)
4619 fprintf(fp, "\n");
4620 vt->dump_free_pages(&meminfo);
4621 fflag++;
4622 }
4623
4624 if (pflag) {
4625 meminfo.spec_addr = value[i];
4626 meminfo.flags = ADDRESS_SPECIFIED;
4627 dump_mem_map(&meminfo);
4628 pflag++;
4629 }
4630
And here, you should check for the invalid kflag and rflag if the pflag
is not set:
4735 if (pflag == 1) {
4736 if (kflag)
4737 meminfo.extra_flags |= VERIFY_COMPOUND_PAGES;
4738 if (rflag)
4739 meminfo.extra_flags |= SKIP_FREE_PAGES;
4740 dump_mem_map(&meminfo);
4741 }
i.e., something like:
if (pflag == 1) {
(as above)
} else if (kflag || rflag)
error(FATAL, ...)
Lastly, I'm not all that excited about the -k option. It sounds like you
have had a specific bug where the "freed with the wrong order" bug occurred,
and now you're addressing it from the crash utility after the fact. How
often does that even happen? I don't know -- others may disagree.
With respect to the search command, the new options need better documentation.
First, I don't even see -g in the synopsis? It should be contained inside
the [-f ...] block.
Then, the "-f struct-page.flags-mask" option needs to be simplified in its
name string, maybe "-f page-mask". And the "preceded by the letter n"
business
is something that's never been done by any other command, and it's just kind of
strange. Maybe there could be both an "-f page-mask" and an "-F
page-mask"?
Also, fix this:
SYNOPSIS
search [-s start] [ -[kKV] | -u | -p | -t ] [-e end | -l length] [-m mask]
[-f struct-page.flags-mask] [-x count] -[cwh] [value | (expression) |
symbol | string] ...
so that it does not exceed 80 columns.
The explanation of each option should be on the same line:
-g
Skip whole compound page instead of only skipping head pages when
using with -f. Only has effect with -f.
Is there a good reason for restricting -f to virtual addresses only?
And like cmd_kmem(), cmd_search() should have error checking, and fail if
the -g option is used without -f (or -F).
Thanks,
Dave
7:31 p.m.
On Thu, Feb 12, 2015 at 1:28 PM, Dave Anderson <anderson(a)redhat.com> wrote:
----- Original Message -----
> search:
> -f struct-page.flags-mask
> When searching kernel memory, crash walks through all identity
> mapping space which includes all physical memory. Nowadays we
> have machines that equipped with more than 256G memory, it takes
> a long time to go through all pages, especially most of them
> are used by user space programs (e.g. LRU pages). This option
> allows us to skip pages with certain struct page flags.
> -g
> Allow us to skip whole compound pages instead of only skipping
> head pages when using -f, because some flags are only set to
> head pages which tails pages share same properties with their
> head pages.
>
> kmem:
> -k
> Verify compound page order. Useful when debugging memory leak
> caused by freeing compound pages with wrong order.
>
> -r
> Only print used pages (i.e. the page count is not zero). Makes
> the output smaller (and faster to grep/vim/emacs).
>
> Yu Zhao (5):
> memory: better compound page support
> memory: struct page.flags based filter
> memory: skip compound pages when using search filter
> memory: display and verify compound page order
> memory: kmem option to skip free pages
Hello Yu,
OK, initially I have looked at these patches from an end-user perspective,
and will wait on reviewing the technical implementation of your patchset
until some basics below are taken care of.
Also, can you separate this into two separate patchset postings, one for
the kmem command, and the other for the search command? I understand
they both use the compound page flag changes, but the common stuff can
be put in one or the other, and it can be specified that one patch
essentially depends upon the other being in place.
Thanks for reviewing, Dave.
I'll fix all things you mentioned here and post the updated patches.
First, please fix these warnings:
$ make warn
... [ cut ] ...
cc -c -g -DX86_64 -DLZO -DSNAPPY -DGDB_7_6 memory.c -Wall -O2
-Wstrict-prototypes -Wmissing-prototypes -fstack-protector -Wformat-security
memory.c: In function ‘PG_slab_flag_init’:
memory.c:4909:2: warning: pointer targets in passing argument 2 of
‘enumerator_value’ differ in signedness [-Wpointer-sign]
In file included from memory.c:19:0:
defs.h:4645:5: note: expected ‘long int *’ but argument is of type
‘ulong *’
memory.c:4910:6: warning: pointer targets in passing argument 2 of
‘enumerator_value’ differ in signedness [-Wpointer-sign]
In file included from memory.c:19:0:
defs.h:4645:5: note: expected ‘long int *’ but argument is of type
‘ulong *’
memory.c:4917:2: warning: pointer targets in passing argument 2 of
‘enumerator_value’ differ in signedness [-Wpointer-sign]
In file included from memory.c:19:0:
defs.h:4645:5: note: expected ‘long int *’ but argument is of type
‘ulong *’
memory.c:4918:13: warning: pointer targets in passing argument 2 of
‘enumerator_value’ differ in signedness [-Wpointer-sign]
In file included from memory.c:19:0:
defs.h:4645:5: note: expected ‘long int *’ but argument is of type
‘ulong *’
memory.c: In function ‘__is_page_head’:
memory.c:18332:9: warning: suggest parentheses around comparison in
operand of ‘&’ [-Wparentheses]
memory.c: In function ‘is_page_head’:
memory.c:18345:9: warning: suggest parentheses around comparison in
operand of ‘&’ [-Wparentheses]
memory.c: In function ‘__is_page_tail’:
memory.c:18354:9: warning: suggest parentheses around comparison in
operand of ‘&’ [-Wparentheses]
memory.c: In function ‘is_page_tail’:
memory.c:18367:9: warning: suggest parentheses around comparison in
operand of ‘&’ [-Wparentheses]
...
Since the kmem -k and -r flags are only relevant when used with -p,
then that should be specified clearly in the help page synopsis,
i.e., something like:
-"[-f|-F|-p|-c|-C|-i|-s|-S|-v|-V|-n|-z|-o|-h] [slab] [[-P] address]\n"
+"[-f|-F|-p [-k][-r]|-c|-C|-i|-s|-S|-v|-V|-n|-z|-o|-h] [slab] [[-P]
address]\n"
And in cmd_kmem(), any attempt to use -k or -r outside of kmem -p
should generate an error message and fail immediately. So in the case
of a specified address, put a check for the kflag and rflag right
after the for(...) line, and error(FATAL, ...) right there:
4607 for (i = 0; i < spec_addr; i++) {
4608
4609 if (Pflag)
4610 meminfo.memtype = PHYSADDR;
4611 else
4612 meminfo.memtype = IS_KVADDR(value[i]) ?
4613 KVADDR : PHYSADDR;
4614
4615 if (fflag) {
4616 meminfo.spec_addr = value[i];
4617 meminfo.flags = ADDRESS_SPECIFIED;
4618 if (meminfo.calls++)
4619 fprintf(fp, "\n");
4620 vt->dump_free_pages(&meminfo);
4621 fflag++;
4622 }
4623
4624 if (pflag) {
4625 meminfo.spec_addr = value[i];
4626 meminfo.flags = ADDRESS_SPECIFIED;
4627 dump_mem_map(&meminfo);
4628 pflag++;
4629 }
4630
And here, you should check for the invalid kflag and rflag if the pflag
is not set:
4735 if (pflag == 1) {
4736 if (kflag)
4737 meminfo.extra_flags |=
VERIFY_COMPOUND_PAGES;
4738 if (rflag)
4739 meminfo.extra_flags |= SKIP_FREE_PAGES;
4740 dump_mem_map(&meminfo);
4741 }
i.e., something like:
if (pflag == 1) {
(as above)
} else if (kflag || rflag)
error(FATAL, ...)
Lastly, I'm not all that excited about the -k option. It sounds like you
have had a specific bug where the "freed with the wrong order" bug
occurred,
and now you're addressing it from the crash utility after the fact. How
often does that even happen? I don't know -- others may disagree.
With respect to the search command, the new options need better
documentation.
First, I don't even see -g in the synopsis? It should be contained inside
the [-f ...] block.
Then, the "-f struct-page.flags-mask" option needs to be simplified in its
name string, maybe "-f page-mask". And the "preceded by the letter
n"
business
is something that's never been done by any other command, and it's just
kind of
strange. Maybe there could be both an "-f page-mask" and an "-F
page-mask"?
Also, fix this:
SYNOPSIS
search [-s start] [ -[kKV] | -u | -p | -t ] [-e end | -l length] [-m
mask]
[-f struct-page.flags-mask] [-x count] -[cwh] [value |
(expression) | symbol | string] ...
so that it does not exceed 80 columns.
The explanation of each option should be on the same line:
-g
Skip whole compound page instead of only skipping head pages
when
using with -f. Only has effect with -f.
Is there a good reason for restricting -f to virtual addresses only?
And like cmd_kmem(), cmd_search() should have error checking, and fail if
the -g option is used without -f (or -F).
Thanks,
Dave
3426
days inactive
3434
days old
devel@lists.crash-utility.osci.io
8 comments
2 participants
participants (2)
-
Dave Anderson -
Yu Zhao