The folio_order() has three versions: 1.) In verion 1, folio_order() uses page[1].compound_order to get the folio order. We use "folio_batch" as the indicator. Please refer to patch set: https://lore.kernel.org/all/20211208042256.1923824-1-willy@infradead.org/ 2.) In version 2, the following patch introduces _folio_order: c3a15bff46cb5149 "mm: reimplement folio_order() and folio_nr_pages()" We use "_folio_order" as the indicator. Please refer to patch set: https://lore.kernel.org/all/20220808193430.3378317-1-willy@infradead.org/ 3.) In version 3, the following patch replaces the _folio_order with _flags_1: ebc1baf5c9b46c22 "mm: free up a word in the first tail page" folio_order() uses _flags_1 to get the folio order. We use "free_huge_folio" as the indicator. Please refer to patch set: https://lore.kernel.org/linux-mm/20230816151201.3655946-1-willy@infradead... (Note, we do not use the struct modifications within the patch set as the indicator, since they have been removed in later kernel.) This patch will be used in later patches. Signed-off-by: Huang Shijie <huangsj(a)hygon.cn&gt; --- defs.h | 8 ++++++ memory.c | 80 +++++++++++++++++++++++++++++++++++++++++++++++++++++++ symbols.c | 6 +++++ 3 files changed, 94 insertions(+) diff --git a/defs.h b/defs.h index 8f6784e..e832ea6 100644 --- a/defs.h +++ b/defs.h @@ -2290,6 +2290,9 @@ struct offset_table { /* stash of commonly-used offsets */ long bpf_ringbuf_nr_pages; long hrtimer_clock_base_index; long klp_patch_list; + long page_compound_order; + long folio__folio_order; + long folio__flags_1; }; struct size_table { /* stash of commonly-used sizes */ @@ -2469,6 +2472,9 @@ struct size_table { /* stash of commonly-used sizes */ long cpumask_t; long task_struct_exit_state; long bpf_ringbuf_map; + long page_compound_order; + long folio__folio_order; + long folio__flags_1; }; struct array_table { @@ -6008,6 +6014,8 @@ ulong do_xarray(ulong, int, struct list_pair *, int); #define XARRAY_TAG_MASK (3UL) #define XARRAY_TAG_INTERNAL (2UL) +int folio_order(ulong folio); + int file_dump(ulong, ulong, ulong, int, int); #define DUMP_FULL_NAME 0x1 #define DUMP_INODE_ONLY 0x2 diff --git a/memory.c b/memory.c index 17423a5..3deae36 100644 --- a/memory.c +++ b/memory.c @@ -410,6 +410,10 @@ mem_init(void) DISPLAY_DEFAULT = (sizeof(long) == 8) ? DISPLAY_64 : DISPLAY_32; } +#define FOLIO_ORDER_V1 1 +#define FOLIO_ORDER_V2 2 +#define FOLIO_ORDER_V3 3 +static int folio_order_version; /* * Stash a few popular offsets and some basic kernel virtual memory @@ -547,6 +551,38 @@ vm_init(void) MEMBER_OFFSET_INIT(page_freelist, "page", "freelist"); MEMBER_OFFSET_INIT(page_page_type, "page", "page_type"); + /* + * The "folio_batch" was introduced at patch set: + * https://lore.kernel.org/all/20211208042256.1923824-1-willy@infradead.org/ + * Use it as the indicator for folio_order() version 1. + */ + if (STRUCT_EXISTS("folio_batch")) + folio_order_version = FOLIO_ORDER_V1; + + MEMBER_OFFSET_INIT(page_compound_order, "page", "compound_order"); + MEMBER_SIZE_INIT(page_compound_order, "page", "compound_order"); + + /* + * The "_folio_order" was introduced at patch set: + * https://lore.kernel.org/all/20220808193430.3378317-1-willy@infradead.org/ + * Use it as the indicator for folio_order() version 2. + */ + MEMBER_SIZE_INIT(folio__folio_order, "folio", "_folio_order"); + MEMBER_OFFSET_INIT(folio__folio_order, "folio", "_folio_order"); + if (VALID_MEMBER(folio__folio_order)) + folio_order_version = FOLIO_ORDER_V2; + + /* + * The "free_huge_folio()" was introduced at patch set: + * https://lore.kernel.org/linux-mm/20230816151201.3655946-1-willy@infradead... + * Use it as the indicator for folio_order() version 3. + */ + MEMBER_OFFSET_INIT(folio__flags_1, "folio", "_flags_1"); + MEMBER_SIZE_INIT(folio__flags_1, "folio", "_flags_1"); + if (kernel_symbol_exists("free_huge_folio") || + THIS_KERNEL_VERSION >= LINUX(6,6,0)) + folio_order_version = FOLIO_ORDER_V3; + MEMBER_OFFSET_INIT(mm_struct_pgd, "mm_struct", "pgd"); MEMBER_OFFSET_INIT(swap_info_struct_swap_file, @@ -20426,6 +20462,50 @@ static unsigned int oo_objects(ulong oo) return (oo & ((1 << 16) - 1)); } +int +folio_order(ulong folio) +{ + ulong v = 0; + int PG_head = 16; + + if (folio_order_version == FOLIO_ORDER_V1) { + readmem(folio + OFFSET(page_flags), KVADDR, &v, sizeof(ulong), + "folio.page.flags", FAULT_ON_ERROR); + if (!(v & (1 << PG_head))) + return 0; + + readmem(folio + SIZE(page) + OFFSET(page_compound_order), KVADDR, &v, + SIZE(page_compound_order), "page[1].compound_order", FAULT_ON_ERROR); + + return v; + } else if (folio_order_version == FOLIO_ORDER_V2) { + readmem(folio + OFFSET(page_flags), KVADDR, &v, sizeof(ulong), + "folio.page.flags", FAULT_ON_ERROR); + if (!(v & (1 << PG_head))) + return 0; + + readmem(folio + OFFSET(folio__folio_order), KVADDR, &v, + SIZE(folio__folio_order), "folio->_folio_order", FAULT_ON_ERROR); + + return v; + } else if (folio_order_version == FOLIO_ORDER_V3) { + /* The PG_head changes to bit 6 in this version */ + PG_head = 6; + + readmem(folio + OFFSET(page_flags), KVADDR, &v, sizeof(ulong), + "folio.page.flags", FAULT_ON_ERROR); + if (!(v & (1 << PG_head))) + return 0; + + readmem(folio + OFFSET(folio__flags_1), KVADDR, &v, + SIZE(folio__flags_1), "folio->_flags_1", FAULT_ON_ERROR); + + return v & 0xff; + } else { + return 0; + } +} + #ifdef NOT_USED ulong slab_to_kmem_cache_node(struct meminfo *si, ulong slab_page) diff --git a/symbols.c b/symbols.c index e6865ca..08c07e9 100644 --- a/symbols.c +++ b/symbols.c @@ -10451,6 +10451,9 @@ dump_offset_table(char *spec, ulong makestruct) fprintf(fp, " page_private: %ld\n", OFFSET(page_private)); fprintf(fp, " page_page_type: %ld\n", OFFSET(page_page_type)); + fprintf(fp, " page_compound_order: %ld\n", OFFSET(page_compound_order)); + fprintf(fp, " folio__folio_order: %ld\n", OFFSET(folio__folio_order)); + fprintf(fp, " folio__flags_1: %ld\n", OFFSET(folio__flags_1)); fprintf(fp, " trace_print_flags_mask: %ld\n", OFFSET(trace_print_flags_mask)); @@ -11961,6 +11964,9 @@ dump_offset_table(char *spec, ulong makestruct) fprintf(fp, "\n size_table:\n"); fprintf(fp, " page: %ld\n", SIZE(page)); fprintf(fp, " page_flags: %ld\n", SIZE(page_flags)); + fprintf(fp, " page_compound_order: %ld\n", SIZE(page_compound_order)); + fprintf(fp, " folio__folio_order: %ld\n", SIZE(folio__folio_order)); + fprintf(fp, " folio__flags_1: %ld\n", SIZE(folio__flags_1)); fprintf(fp, " trace_print_flags: %ld\n", SIZE(trace_print_flags)); fprintf(fp, " free_area_struct: %ld\n", SIZE(free_area_struct)); -- 2.34.1

Hi Huang, Please check the following code change upon your v6, please note I haven't have the code tested, just to illustrate my thoughts: diff --git a/defs.h b/defs.h index a2c2dcd..1b905df 100644 --- a/defs.h +++ b/defs.h @@ -5692,6 +5692,8 @@ struct xarray_ops { uint radix; uint type; void *private; + uint (*update_off)(ulong node, uint height, char *path, ulong index, + ulong slot, uint off, ulong XA_CHUNK_SHIFT, struct xarray_ops *ops); }; int do_xarray_traverse(ulong ptr, int is_root, struct xarray_ops *ops); int do_rdtree(struct tree_data *); @@ -5998,7 +6000,6 @@ ulong do_radix_tree(ulong, int, struct list_pair *); #define RADIX_TREE_EXCEPTIONAL_ENTRY 2 ulong do_xarray(ulong, int, struct list_pair *, int); -#define XARRAY_TYPE_PAGE_CACHE 1 #define XARRAY_COUNT (1) #define XARRAY_SEARCH (2) @@ -6007,6 +6008,7 @@ ulong do_xarray(ulong, int, struct list_pair *, int); #define XARRAY_DUMP_CB (5) #define XARRAY_TAG_MASK (3UL) #define XARRAY_TAG_INTERNAL (2UL) +#define XARRAY_TYPE_PAGE_CACHE 0x8 int folio_order(ulong folio); diff --git a/filesys.c b/filesys.c index 08d7b1f..717fb85 100644 --- a/filesys.c +++ b/filesys.c @@ -2319,7 +2319,7 @@ dump_inode_page_cache_info(ulong inode, void *callback) if (root_rnode) count = do_radix_tree(root_rnode, RADIX_TREE_DUMP_CB, &lp); else if (xarray) - count = do_xarray(xarray, XARRAY_DUMP_CB, &lp, XARRAY_TYPE_PAGE_CACHE); + count = do_xarray(xarray, XARRAY_DUMP_CB | XARRAY_TYPE_PAGE_CACHE, &lp); if (count != nrpages) error(INFO, "%s page count: %ld nrpages: %ld\n", @@ -4341,6 +4341,19 @@ static void do_xarray_dump_cb(ulong node, ulong slot, const char *path, do_xarray_count(node, slot, path, index, private); } +uint folio_xarray_update_off(ulong node, uint height, char *path, ulong index, + ulong slot, uint off, ulong shift, struct xarray_ops *ops) +{ + uint order = 1; + + if ((slot & XARRAY_TAG_MASK) == 0) { + if (height != 1) + ops->entry(node, slot, path, index | off, ops->private); + order = folio_order(slot) % shift; + } + return order; +} + /* * do_xarray argument usage: * @@ -4373,7 +4386,7 @@ static void do_xarray_dump_cb(ulong node, ulong slot, const char *path, * type: different xarray use types. */ ulong -do_xarray(ulong root, int flag, struct list_pair *xp, int type) +do_xarray(ulong root, int flag, struct list_pair *xp) { struct do_xarray_info info = { .count = 0, @@ -4385,10 +4398,7 @@ do_xarray(ulong root, int flag, struct list_pair *xp, int type) .private = &info, }; - if (type == XARRAY_TYPE_PAGE_CACHE) - info.update_count = folio_update_count; - - switch (flag) + switch (flag & 0x7) { case XARRAY_COUNT: ops.entry = do_xarray_count; @@ -4421,6 +4431,11 @@ do_xarray(ulong root, int flag, struct list_pair *xp, int type) error(FATAL, "do_xarray: invalid flag: %lx\n", flag); } + if (flag & XARRAY_TYPE_PAGE_CACHE) { + ops.update_off = folio_xarray_update_off; + info.update_count = folio_update_count; + } + do_xarray_traverse(root, 1, &ops); return info.count; } diff --git a/tools.c b/tools.c index 6b51423..82d3ed8 100644 --- a/tools.c +++ b/tools.c @@ -4737,19 +4737,16 @@ do_xarray_iter(ulong node, uint height, char *path, ulong index, struct xarray_ops *ops) { uint off; - uint order, is_folio; + uint update_off = 1; if (!hq_enter(node)) error(FATAL, "\nduplicate tree node: %lx\n", node); - for (off = 0; off < XA_CHUNK_SIZE; off += 1 << order) { + for (off = 0; off < XA_CHUNK_SIZE; off += update_off) { ulong slot; ulong shift = (height - 1) * XA_CHUNK_SHIFT; - order = 0; - is_folio = 0; - readmem(node + OFFSET(xa_node_slots) + sizeof(void *) * off, KVADDR, &slot, sizeof(void *), "xa_node.slots[off]", FAULT_ON_ERROR); @@ -4758,16 +4755,16 @@ do_xarray_iter(ulong node, uint height, char *path, if ((slot & XARRAY_TAG_MASK) == XARRAY_TAG_INTERNAL) slot &= ~XARRAY_TAG_INTERNAL; - else if ((slot & XARRAY_TAG_MASK) == 0) { - if (ops->type == XARRAY_TYPE_PAGE_CACHE) - is_folio = 1; + + if (ops->update_off) { + update_off = ops->update_off(node, height, path, + index, slot, off, + XA_CHUNK_SHIFT, ops); } - if (height == 1 || is_folio) { + if (height == 1) ops->entry(node, slot, path, index | off, ops->private); - if (ops->type == XARRAY_TYPE_PAGE_CACHE) - order = folio_order(slot) % XA_CHUNK_SHIFT; - } else { + else { ulong child_index = index | (off << shift); char child_path[BUFSIZE]; sprintf(child_path, "%s/%d", path, off); 1) XARRAY_TYPE_PAGE_CACHE can be put into do_xarray() flags argument, so we don't need to introduce an extra "type" argument for do_xarray(), and the function signature can stay unchanged. 2) do_xarray_iter() shouldn't contain folio information, it is supposed to concern nothing but the xarray itself. The ops->update_off() is a callback for every xarray nodes, used as the off variable updator, within which, you can deal with your folio case. Like I said previously, we'd better decouple xarray iteration with folio, any special cases are better to be handled within a callback, rather than hard code the special cases into xarray iteration directly. 3) To be honest, I'd rather keep the base data/functions least changed than introduce new features for crash, because that would make the maintenance work easier. Thanks, Tao Liu

On Thu, May 7, 2026 at 11:40 PM Huang Shijie <huangsj(a)hygon.cn&gt; wrote: Don't we need to iterate into the internal node in order to find their leaf nodes? BTW, could you send me a vmcore with the folio data? When reviewing the patch, I can use the vmcore as a reference to better understand this case.

In the NUMA machine, it is useful to know the memory distribution of an inode page cache: How many pages in the node 0? How many pages in the node 1? Add "files -n" command to get the memory distribution information: 1.) Add new argument for dump_inode_page_cache_info() 2.) make page_to_nid() a global function. 3.) Add summary_inode_page() to check each page's node information. 4.) Use print_inode_summary_info() to print the memory distribution information of an inode. Signed-off-by: Huang Shijie <huangsj(a)hygon.cn&gt; --- defs.h | 1 + filesys.c | 60 ++++++++++++++++++++++++++++++++++++++++++++++++++----- help.c | 24 +++++++++++++++++++++- memory.c | 4 ++-- 4 files changed, 81 insertions(+), 8 deletions(-) diff --git a/defs.h b/defs.h index e832ea6..6abc359 100644 --- a/defs.h +++ b/defs.h @@ -5953,6 +5953,7 @@ int dump_inode_page(ulong); ulong valid_section_nr(ulong); void display_memory_from_file_offset(ulonglong, long, void *); void swap_info_init(void); +int page_to_nid(ulong); /* * filesys.c diff --git a/filesys.c b/filesys.c index d30aa6e..08d7b1f 100644 --- a/filesys.c +++ b/filesys.c @@ -49,7 +49,7 @@ static int match_file_string(char *, char *, char *); static ulong get_root_vfsmount(char *); static void check_live_arch_mismatch(void); static long get_inode_nrpages(ulong); -static void dump_inode_page_cache_info(ulong); +static void dump_inode_page_cache_info(ulong, void *callback); #define DENTRY_CACHE (20) #define INODE_CACHE (20) @@ -2240,8 +2240,38 @@ get_inode_nrpages(ulong i_mapping) return nrpages; } +/* Used to collect the numa information for an inode */ +static ulong *numa_node; + static void -dump_inode_page_cache_info(ulong inode) +print_inode_summary_info(void) +{ + int i; + + fprintf(fp, " NODE PAGES\n"); + for (i = 0; i < vt->numnodes; i++) + fprintf(fp, " %2d %8ld\n", i, numa_node[i]); +} + +static int +summary_inode_page(ulong page) +{ + int node; + + if (!is_page_ptr(page, NULL)) + error(FATAL, "Invalid inode page(0x%lx)\n", page); + + node = page_to_nid(page); + if (node < 0 || node >= vt->numnodes) + error(FATAL, "Invalid node(%d) for page(0x%lx)\n", node, page); + + numa_node[node] += 1 << folio_order(page); + + return 1; +} + +static void +dump_inode_page_cache_info(ulong inode, void *callback) { char *inode_buf; ulong i_mapping, nrpages, root_rnode, xarray, count; @@ -2284,7 +2314,7 @@ dump_inode_page_cache_info(ulong inode) root_rnode = i_mapping + OFFSET(address_space_page_tree); lp.index = 0; - lp.value = (void *)&dump_inode_page; + lp.value = callback; if (root_rnode) count = do_radix_tree(root_rnode, RADIX_TREE_DUMP_CB, &lp); @@ -2324,7 +2354,7 @@ cmd_files(void) ref = NULL; refarg = NULL; - while ((c = getopt(argcnt, args, "d:R:p:c")) != EOF) { + while ((c = getopt(argcnt, args, "d:n:R:p:c")) != EOF) { switch(c) { case 'R': @@ -2343,11 +2373,31 @@ cmd_files(void) display_dentry_info(value); return; + case 'n': + if (VALID_MEMBER(address_space_page_tree) && + VALID_MEMBER(inode_i_mapping)) { + value = htol(optarg, FAULT_ON_ERROR, NULL); + + /* Allocate the array for this inode */ + numa_node = (ulong *)GETBUF(sizeof(ulong) * vt->numnodes); + BZERO(numa_node, sizeof(ulong) * vt->numnodes); + + dump_inode_page_cache_info(value, (void *)&summary_inode_page); + + /* Print out the NUMA node information for this inode */ + print_inode_summary_info(); + + FREEBUF(numa_node); + numa_node = NULL; + } else + option_not_supported('n'); + return; + case 'p': if (VALID_MEMBER(address_space_page_tree) && VALID_MEMBER(inode_i_mapping)) { value = htol(optarg, FAULT_ON_ERROR, NULL); - dump_inode_page_cache_info(value); + dump_inode_page_cache_info(value, (void *)&dump_inode_page); } else option_not_supported('p'); return; diff --git a/help.c b/help.c index 810075b..5cd5c30 100644 --- a/help.c +++ b/help.c @@ -7900,7 +7900,7 @@ NULL char *help_files[] = { "files", "open files", -"[-d dentry] | [-p inode] | [-c] [-R reference] [pid | taskp] ... ", +"[-d dentry] | [-p inode] | [-n inode]|[-c] [-R reference] [pid | taskp] ... ", " This command displays information about open files of a context.", " It prints the context's current root directory and current working", " directory, and then for each open file descriptor it prints a pointer", @@ -7915,6 +7915,8 @@ char *help_files[] = { " super block, file type, and full pathname.", " -p inode given a hexadecimal inode address, dump all of its pages", " that are in the page cache.", +" -n inode given a hexadecimal inode address, check all the pages", +" in the page cache, and display a NUMA node distribution.", " -c for each open file descriptor, prints a pointer to its", " inode, a pointer to the inode's i_mapping address_space", " structure, the number of pages of the inode that are in", @@ -8024,6 +8026,26 @@ char *help_files[] = { " ca1ddde0 2eeef000 f59b91ac 3 2 82c referenced,uptodate,lru,private", " ca36b300 3b598000 f59b91ac 4 2 82c referenced,uptodate,lru,private", " ca202680 30134000 f59b91ac 5 2 82c referenced,uptodate,lru,private", +" ", +" For the inode at address ffff8898857c55a8, display the NUMA node", +" distribution of its pages that are in the page cache:", +" %s> files -n ffff8898857c55a8", +" INODE NRPAGES", +" ffff8898857c55a8 51748", +" ", +" NODE PAGES", +" 0 51536", +" 1 0", +" 2 0", +" 3 0", +" 4 0", +" 5 212", +" 6 0", +" 7 0", +" 8 0", +" 9 0", +" 10 0", +" 11 0", " ", NULL }; diff --git a/memory.c b/memory.c index 3deae36..9f1cfda 100644 --- a/memory.c +++ b/memory.c @@ -301,7 +301,7 @@ static int dump_vm_event_state(void); static int dump_page_states(void); static int generic_read_dumpfile(ulonglong, void *, long, char *, ulong); static int generic_write_dumpfile(ulonglong, void *, long, char *, ulong); -static int page_to_nid(ulong); +int page_to_nid(ulong); static int get_kmem_cache_list(ulong **); static int get_kmem_cache_root_list(ulong **); static int get_kmem_cache_child_list(ulong **, ulong); @@ -20094,7 +20094,7 @@ is_kmem_cache_addr_common(ulong vaddr, char *kbuf) /* * Kernel-config-neutral page-to-node evaluator. */ -static int +int page_to_nid(ulong page) { int i; -- 2.34.1