The xarray can be used in many kernel subsystems. For the page cache, it can support the large folio which needs special operations. So this patch adds a new parameter for do_xarray, and adds a new type field in xarray_ops to distinguish them. Also adds macro XARRAY_TYPE_PAGE_CACHE for page cache case. Signed-off-by: Huang Shijie <huangsj(a)hygon.cn&gt; --- bpf.c | 8 ++++---- defs.h | 5 ++++- dev.c | 4 ++-- diskdump.c | 10 ++++++++-- filesys.c | 7 +++++-- ipcs.c | 4 ++-- kernel.c | 4 ++-- task.c | 4 ++-- 8 files changed, 29 insertions(+), 17 deletions(-) diff --git a/bpf.c b/bpf.c index 2840c7d..8702596 100644 --- a/bpf.c +++ b/bpf.c @@ -344,7 +344,7 @@ bpf_init(struct bpf_info *bpf) break; case IDR_XARRAY: bpf->progs = do_xarray(symbol_value("prog_idr") + OFFSET(idr_idr_rt), - XARRAY_COUNT, NULL); + XARRAY_COUNT, NULL, 0); break; } @@ -364,7 +364,7 @@ bpf_init(struct bpf_info *bpf) break; case IDR_XARRAY: bpf->progs = do_xarray(symbol_value("prog_idr") + OFFSET(idr_idr_rt), - XARRAY_GATHER, bpf->proglist); + XARRAY_GATHER, bpf->proglist, 0); break; } } @@ -380,7 +380,7 @@ bpf_init(struct bpf_info *bpf) break; case IDR_XARRAY: bpf->maps = do_xarray(symbol_value("map_idr") + OFFSET(idr_idr_rt), - XARRAY_COUNT, NULL); + XARRAY_COUNT, NULL, 0); break; } @@ -400,7 +400,7 @@ bpf_init(struct bpf_info *bpf) break; case IDR_XARRAY: bpf->maps = do_xarray(symbol_value("map_idr") + OFFSET(idr_idr_rt), - XARRAY_GATHER, bpf->maplist); + XARRAY_GATHER, bpf->maplist, 0); break; } } diff --git a/defs.h b/defs.h index a6f4372..8f6784e 100644 --- a/defs.h +++ b/defs.h @@ -5691,6 +5691,7 @@ struct xarray_ops { void (*entry)(ulong node, ulong slot, const char *path, ulong index, void *private); uint radix; + uint type; void *private; }; int do_xarray_traverse(ulong ptr, int is_root, struct xarray_ops *ops); @@ -5996,7 +5997,9 @@ ulong do_radix_tree(ulong, int, struct list_pair *); #define RADIX_TREE_ENTRY_MASK 3UL #define RADIX_TREE_EXCEPTIONAL_ENTRY 2 -ulong do_xarray(ulong, int, struct list_pair *); +ulong do_xarray(ulong, int, struct list_pair *, int); +#define XARRAY_TYPE_PAGE_CACHE 1 + #define XARRAY_COUNT (1) #define XARRAY_SEARCH (2) #define XARRAY_DUMP (3) diff --git a/dev.c b/dev.c index 1332b0e..23f3219 100644 --- a/dev.c +++ b/dev.c @@ -4487,12 +4487,12 @@ static void get_mq_diskio_from_hw_queues(ulong q, struct diskio *dio) if (VALID_MEMBER(request_queue_hctx_table)) { addr = q + OFFSET(request_queue_hctx_table); - cnt = do_xarray(addr, XARRAY_COUNT, NULL); + cnt = do_xarray(addr, XARRAY_COUNT, NULL, 0); lp = (struct list_pair *)GETBUF(sizeof(struct list_pair) * (cnt + 1)); if (!lp) error(FATAL, "fail to get memory for list_pair.\n"); lp[0].index = cnt; - cnt = do_xarray(addr, XARRAY_GATHER, lp); + cnt = do_xarray(addr, XARRAY_GATHER, lp, 0); } else { addr = q + OFFSET(request_queue_nr_hw_queues); readmem(addr, KVADDR, &cnt, sizeof(uint), diff --git a/diskdump.c b/diskdump.c index 20f8b19..456e5cf 100644 --- a/diskdump.c +++ b/diskdump.c @@ -2947,6 +2947,7 @@ lookup_swap_cache(ulonglong pte_val, unsigned char *zram_buf) struct list_pair lp; physaddr_t paddr; static int is_xarray = -1; + ulong ret; if (is_xarray < 0) { is_xarray = STREQ(MEMBER_TYPE_NAME("address_space", "i_pages"), "xarray"); @@ -2969,8 +2970,13 @@ lookup_swap_cache(ulonglong pte_val, unsigned char *zram_buf) swp_space += (swp_offset >> SWAP_ADDRESS_SPACE_SHIFT) * SIZE(address_space); lp.index = swp_offset; - if ((is_xarray ? do_xarray : do_radix_tree) - (swp_space+OFFSET(address_space_page_tree), RADIX_TREE_SEARCH, &lp)) { + + if (is_xarray) + ret = do_xarray(swp_space+OFFSET(address_space_page_tree), RADIX_TREE_SEARCH, &lp, 0); + else + ret = do_radix_tree(swp_space+OFFSET(address_space_page_tree), RADIX_TREE_SEARCH, &lp); + + if (ret) { if ((is_xarray ? xa_is_value : radix_tree_exceptional_entry)((ulong)lp.value)) { /* ignore shadow values */ return NULL; diff --git a/filesys.c b/filesys.c index 34944e2..1e070a3 100644 --- a/filesys.c +++ b/filesys.c @@ -2289,7 +2289,7 @@ dump_inode_page_cache_info(ulong inode) 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); + count = do_xarray(xarray, XARRAY_DUMP_CB, &lp, XARRAY_TYPE_PAGE_CACHE); if (count != nrpages) error(INFO, "%s page count: %ld nrpages: %ld\n", @@ -4305,9 +4305,11 @@ static void do_xarray_dump_cb(ulong node, ulong slot, const char *path, * any chance of an overrun. * For XARRAY_DUMP_CB, the rtp->value must be initialized as a * callback function. The callback prototype must be: int (*)(ulong); + * + * type: different xarray use types. */ ulong -do_xarray(ulong root, int flag, struct list_pair *xp) +do_xarray(ulong root, int flag, struct list_pair *xp, int type) { struct do_xarray_info info = { .count = 0, @@ -4315,6 +4317,7 @@ do_xarray(ulong root, int flag, struct list_pair *xp) }; struct xarray_ops ops = { .radix = 16, + .type = type, .private = &info, }; diff --git a/ipcs.c b/ipcs.c index 59dc9b6..9cf2418 100644 --- a/ipcs.c +++ b/ipcs.c @@ -1150,13 +1150,13 @@ gather_xarray_entries(ulong ipcs_idr_p) { long len; - ipcs_table.cnt = do_xarray(ipcs_idr_p, XARRAY_COUNT, NULL); + ipcs_table.cnt = do_xarray(ipcs_idr_p, XARRAY_COUNT, NULL, 0); if (ipcs_table.cnt) { len = sizeof(struct list_pair) * (ipcs_table.cnt+1); ipcs_table.lp = (struct list_pair *)GETBUF(len); ipcs_table.lp[0].index = ipcs_table.cnt; - ipcs_table.cnt = do_xarray(ipcs_idr_p, XARRAY_GATHER, ipcs_table.lp); + ipcs_table.cnt = do_xarray(ipcs_idr_p, XARRAY_GATHER, ipcs_table.lp, 0); } else ipcs_table.lp = NULL; } diff --git a/kernel.c b/kernel.c index 8781d6a..870fb3b 100644 --- a/kernel.c +++ b/kernel.c @@ -6883,7 +6883,7 @@ get_irq_desc_addr(int irq) break; case IRQ_DESC_TREE_XARRAY: cnt = do_xarray(symbol_value("irq_desc_tree"), - XARRAY_COUNT, NULL); + XARRAY_COUNT, NULL, 0); break; } len = sizeof(struct list_pair) * (cnt+1); @@ -6898,7 +6898,7 @@ get_irq_desc_addr(int irq) break; case IRQ_DESC_TREE_XARRAY: cnt = do_xarray(symbol_value("irq_desc_tree"), - XARRAY_GATHER, lp); + XARRAY_GATHER, lp, 0); break; } diff --git a/task.c b/task.c index ec04b55..2d9c4e4 100644 --- a/task.c +++ b/task.c @@ -2610,7 +2610,7 @@ refresh_xarray_task_table(void) curpid = CURRENT_PID(); } - count = do_xarray(tt->pid_xarray, XARRAY_COUNT, NULL); + count = do_xarray(tt->pid_xarray, XARRAY_COUNT, NULL, 0); if (CRASHDEBUG(1)) console("xarray: count: %ld\n", count); @@ -2641,7 +2641,7 @@ retry_xarray: tt->callbacks = 0; xp.index = 0; xp.value = (void *)&xarray_task_callback; - count = do_xarray(tt->pid_xarray, XARRAY_DUMP_CB, &xp); + count = do_xarray(tt->pid_xarray, XARRAY_DUMP_CB, &xp, 0); if (CRASHDEBUG(1)) console("do_xarray: count: %ld tt->callbacks: %d\n", count, tt->callbacks); -- 2.43.0

We may meet a large folio at two cases: 1.) when height is 1, the real data layout may looks like this: -------------------------------------------- crash> p *(struct xa_node*)0xffff889883a6a910 $5 = { shift = 0 '\000', offset = 0 '\000', count = 64 '@', nr_values = 0 '\000', ................. slots = { 0xffffea0061d21000, 0x2, 0x2, 0x2, 0xffffea0121d85c00, 0x12, 0x12, 0x12, 0xffffea0121d9f400, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0xffffea0121583800, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0xffffea0121833e00, 0x62, 0x62, 0x62, 0x62, 0x62, 0x62, 0x62, 0xffffea0121eb3800, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82 }, ................. } -------------------------------------------- The page orders for above folios: 0xffffea0061d21000 --> order 2 0xffffea0121d85c00 --> order 2 0xffffea0121d9f400 --> order 3 0xffffea0121583800 --> order 3 0xffffea0121833e00 --> order 3 0xffffea0121eb3800 --> order 5 2.) when height is not 1, the real data layout may looks like this: -------------------------------------------- slot: { 0xffff8a2c866b745a, 0xffff8a2c866b16d2, 0xfffff9fcc4ea4000, 0xfffff9fcc4eb9000, ..} -------------------------------------------- The 0xffff8a2c866b745a and 0xffff8a2c866b16d2 is a internal node, not a folio. The page orders for above folios: 0xfffff9fcc4ea4000 --> order 6 Current code does not work correctly with large folio page cache. This patch adds the large folio support with following: 1.) changed the do_xarray_iter() to detect the order of a folio, and skip the proper dummy slots for a large folio. 2.) updated do_xarray_count/do_xarray_dump/do_xarray_dump_cb with correct page number if we meet a large folio. Signed-off-by: Huang Shijie <huangsj(a)hygon.cn&gt; --- filesys.c | 10 ++++++---- tools.c | 16 +++++++++++++--- 2 files changed, 19 insertions(+), 7 deletions(-) diff --git a/filesys.c b/filesys.c index 1e070a3..b6dab55 100644 --- a/filesys.c +++ b/filesys.c @@ -4222,7 +4222,7 @@ static void do_xarray_count(ulong node, ulong slot, const char *path, ulong index, void *private) { struct do_xarray_info *info = private; - info->count++; + info->count += 1 << folio_order(slot); } static void do_xarray_search(ulong node, ulong slot, const char *path, ulong index, void *private) @@ -4239,8 +4239,10 @@ static void do_xarray_dump(ulong node, ulong slot, const char *path, ulong index, void *private) { struct do_xarray_info *info = private; - fprintf(fp, "[%ld] %lx\n", index, slot); - info->count++; + int order = folio_order(slot); + + fprintf(fp, "[%ld] %lx, order:%d\n", index, slot, order); + info->count += 1 << order; } static void do_xarray_gather(ulong node, ulong slot, const char *path, ulong index, void *private) @@ -4274,7 +4276,7 @@ static void do_xarray_dump_cb(ulong node, ulong slot, const char *path, "operation failed: entry: %ld item: %lx\n", info->count, slot); } - info->count++; + info->count += 1 << folio_order(slot); } /* diff --git a/tools.c b/tools.c index 69250c4..6b51423 100644 --- a/tools.c +++ b/tools.c @@ -4737,15 +4737,19 @@ do_xarray_iter(ulong node, uint height, char *path, ulong index, struct xarray_ops *ops) { uint off; + uint order, is_folio; if (!hq_enter(node)) error(FATAL, "\nduplicate tree node: %lx\n", node); - for (off = 0; off < XA_CHUNK_SIZE; off++) { + for (off = 0; off < XA_CHUNK_SIZE; off += 1 << order) { 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); @@ -4754,10 +4758,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 (height == 1) + if (height == 1 || is_folio) { ops->entry(node, slot, path, index | off, ops->private); - else { + if (ops->type == XARRAY_TYPE_PAGE_CACHE) + order = folio_order(slot) % XA_CHUNK_SHIFT; + } else { ulong child_index = index | (off << shift); char child_path[BUFSIZE]; sprintf(child_path, "%s/%d", path, off); -- 2.43.0

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; Signed-off-by: Huang Shijie <shijie8(a)gmail.com&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 b6dab55..ae75221 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 = malloc(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(); + + free(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 91d1550..6f97289 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 3b272ad..a8da5b1 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); @@ -20065,7 +20065,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.43.0