6:31 a.m.
The linux kernel supports the large folio for page cache by default.
But the current CRASH does not support the large folio.
So we may meet the errors when we detected the large folio sometimes,
such as in the email:
https://www.spinics.net/linux/fedora/redhat-crash-utility/msg11238.html
------------------------------
files: page_to_nid: invalid page: 0
files: page_to_nid: invalid page: 0
files: page_to_nid: invalid page: 0
files: page_to_nid: invalid page: 10
files: page_to_nid: invalid page: 10
files: page_to_nid: invalid page: 10
files: page_to_nid: invalid page: 20
files: page_to_nid: invalid page: 20
files: page_to_nid: invalid page: 20
files: page_to_nid: invalid page: 30
files: page_to_nid: invalid page: 30
files: page_to_nid: invalid page: 30
files: page_to_nid: invalid page: 40
files: page_to_nid: invalid page: 40
files: page_to_nid: invalid page: 40
files: page_to_nid: invalid page: 50
files: page_to_nid: invalid page: 50
files: page_to_nid: invalid page: 50
files: page_to_nid: invalid page: 60
files: page_to_nid: invalid page: 60
------------------------------
The patches(1,2) are used to add large folio support for CRASH.
The patch 3 is newly version of an old patch:
it add "files -n" command.
v7-->v8:
1.) changed the code in hook ->update_off
2.) Do not use the LINUX version macro.
v6-->v7:
1.) Drop the old patch 1.
2.) For patch "xarray: add large folio support":
add XARRAY_TYPE_PAGE_CACHE flag for do_xarray()
add update_off hook for xarray_ops{}
v5-->v6:
1.) Removed the patch for converting ipcs to unix format.
2.) Rewrote the folio_order()
3.) Add hook ->update_count() for do_xarray_info{}
4.) others.
v4-->v5:
Add a new patch to convert ipcs.c to unix format.
Rebased the patch set again.
v3-->v4:
Fixes the BPF bug by:
1.) patch 1: Add a new type for do_xarray_info
2.) patch 3: Check XARRAY_TYPE_PAGE_CACHE for
do_xarray_count()/do_xarray_dump()/do_xarray_dump_cb()
v2-->v3:
Rewrited the folio_order() in patch 2 to work with different
kernel versions.
v1-->v2:
1.) Rebase the kernel to later 7.0-rc1(merge window)
2.) Fixed a bug in the patch 3, the latest kernel supports folios
whose page order is bigger then 5:
"xarray: add large folio support"
*** BLURB HERE ***
Huang Shijie (3):
add folio_order function
xarray: add large folio support
add "files -n" command for an inode
defs.h | 14 +++++++
filesys.c | 111 +++++++++++++++++++++++++++++++++++++++++++++++++-----
help.c | 24 +++++++++++-
memory.c | 83 +++++++++++++++++++++++++++++++++++++++-
symbols.c | 6 +++
tools.c | 15 +++++++-
6 files changed, 238 insertions(+), 15 deletions(-)
--
2.53.0
6:31 a.m.
New subject: [PATCH v8 1/3] add folio_order function
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>
---
defs.h | 8 ++++++
memory.c | 79 +++++++++++++++++++++++++++++++++++++++++++++++++++++++
symbols.c | 6 +++++
3 files changed, 93 insertions(+)
diff --git a/defs.h b/defs.h
index 89044b1..bd996ef 100644
--- a/defs.h
+++ b/defs.h
@@ -2291,6 +2291,9 @@ struct offset_table { /* stash of commonly-used
offsets */
long hrtimer_clock_base_index;
long klp_patch_list;
long tk_data_timekeeper;
+ long page_compound_order;
+ long folio__folio_order;
+ long folio__flags_1;
};
struct size_table { /* stash of commonly-used sizes */
@@ -2470,6 +2473,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 {
@@ -5998,6 +6004,8 @@ ulong do_xarray(ulong, int, struct list_pair *);
#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..502f8fd 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,37 @@ 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"))
+ 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 +20461,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 3c62f54..c028505 100644
--- a/symbols.c
+++ b/symbols.c
@@ -10462,6 +10462,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));
@@ -11972,6 +11975,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.53.0
6:31 a.m.
New subject: [PATCH v8 2/3] xarray: add large folio support
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.) Add XARRAY_TYPE_PAGE_CACHE flag for do_xarray().
2.) Add update_count hook for do_xarray_info{},
add update_off hook for xarray_ops{}.
3.) changed the do_xarray_iter() to check the update_off
at proper place (height == 1 and height > 1).
4.) Implement the folio_update_count/folio_xarray_update_off
hooks for large folio page cache.
Signed-off-by: Huang Shijie <huangsj(a)hygon.cn>
---
defs.h | 5 +++++
filesys.c | 51 ++++++++++++++++++++++++++++++++++++++++++++++-----
tools.c | 15 +++++++++++++--
3 files changed, 64 insertions(+), 7 deletions(-)
diff --git a/defs.h b/defs.h
index bd996ef..e7e97e7 100644
--- a/defs.h
+++ b/defs.h
@@ -5689,6 +5689,9 @@ int do_radix_tree_traverse(ulong ptr, int is_root, struct
radix_tree_ops *ops);
struct xarray_ops {
void (*entry)(ulong node, ulong slot, const char *path,
ulong index, void *private);
+ uint (*update_off)(ulong node, uint height, char *path, ulong index,
+ ulong slot, uint off, ulong shift, struct xarray_ops *ops,
+ bool *should_continue);
uint radix;
void *private;
};
@@ -6003,6 +6006,8 @@ ulong do_xarray(ulong, int, struct list_pair *);
#define XARRAY_DUMP_CB (5)
#define XARRAY_TAG_MASK (3UL)
#define XARRAY_TAG_INTERNAL (2UL)
+#define XARRAY_TYPE_PAGE_CACHE 0x8
+extern ulong XA_CHUNK_SHIFT;
int folio_order(ulong folio);
diff --git a/filesys.c b/filesys.c
index 34944e2..35d55a5 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 | XARRAY_TYPE_PAGE_CACHE, &lp);
if (count != nrpages)
error(INFO, "%s page count: %ld nrpages: %ld\n",
@@ -4217,12 +4217,46 @@ struct do_xarray_info {
ulong maxcount;
ulong count;
void *data;
+ ulong (*update_count)(ulong);
};
+
+static ulong
+folio_update_count(ulong slot)
+{
+ return 1 << folio_order(slot);
+}
+
+static uint folio_xarray_update_off(ulong node, uint height, char *path, ulong index,
+ ulong slot, uint off, ulong shift, struct xarray_ops *ops, bool *should_continue)
+{
+ uint order;
+
+ *should_continue = false;
+
+ if (height == 1) {
+ order = folio_order(slot) % XA_CHUNK_SHIFT;
+ return 1 << order;
+ }
+
+ /* height > 1 */
+ if ((slot & XARRAY_TAG_MASK) == 0) {
+ ops->entry(node, slot, path, index | off, ops->private);
+ *should_continue = true;
+ order = folio_order(slot) % XA_CHUNK_SHIFT;
+ return 1 << order;
+ }
+ return 1;
+}
+
static void do_xarray_count(ulong node, ulong slot, const char *path,
ulong index, void *private)
{
struct do_xarray_info *info = private;
- info->count++;
+
+ if (info->update_count)
+ info->count += info->update_count(slot);
+ else
+ info->count++;
}
static void do_xarray_search(ulong node, ulong slot, const char *path,
ulong index, void *private)
@@ -4239,8 +4273,9 @@ 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++;
+ do_xarray_count(node, slot, path, index, private);
}
static void do_xarray_gather(ulong node, ulong slot, const char *path,
ulong index, void *private)
@@ -4274,7 +4309,8 @@ 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++;
+
+ do_xarray_count(node, slot, path, index, private);
}
/*
@@ -4318,7 +4354,12 @@ do_xarray(ulong root, int flag, struct list_pair *xp)
.private = &info,
};
- switch (flag)
+ if (flag & XARRAY_TYPE_PAGE_CACHE) {
+ info.update_count = folio_update_count;
+ ops.update_off = folio_xarray_update_off;
+ }
+
+ switch (flag & 0x7)
{
case XARRAY_COUNT:
ops.entry = do_xarray_count;
diff --git a/tools.c b/tools.c
index 69250c4..7dc11ae 100644
--- a/tools.c
+++ b/tools.c
@@ -4728,7 +4728,7 @@ error_height:
return -1;
}
-static ulong XA_CHUNK_SHIFT = UNINITIALIZED;
+ulong XA_CHUNK_SHIFT = UNINITIALIZED;
static ulong XA_CHUNK_SIZE = UNINITIALIZED;
static ulong XA_CHUNK_MASK = UNINITIALIZED;
@@ -4737,21 +4737,32 @@ do_xarray_iter(ulong node, uint height, char *path,
ulong index, struct xarray_ops *ops)
{
uint off;
+ uint update_off;
+ bool should_continue;
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 += update_off) {
ulong slot;
ulong shift = (height - 1) * XA_CHUNK_SHIFT;
+ update_off = 1;
+
readmem(node + OFFSET(xa_node_slots) +
sizeof(void *) * off, KVADDR, &slot, sizeof(void *),
"xa_node.slots[off]", FAULT_ON_ERROR);
if (!slot)
continue;
+ if (ops->update_off) {
+ update_off = ops->update_off(node, height, path, index,
+ slot, off, shift, ops, &should_continue);
+ if (should_continue)
+ continue;
+ }
+
if ((slot & XARRAY_TAG_MASK) == XARRAY_TAG_INTERNAL)
slot &= ~XARRAY_TAG_INTERNAL;
--
2.53.0
5:23 p.m.
New subject: [PATCH v8 2/3] xarray: add large folio support
Thanks for all the improvements. LGTM, ack for the patchset.
Thanks,
Tao Liu
On Mon, May 18, 2026 at 11:38 PM Huang Shijie <huangsj(a)hygon.cn> wrote:
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.) Add XARRAY_TYPE_PAGE_CACHE flag for do_xarray().
2.) Add update_count hook for do_xarray_info{},
add update_off hook for xarray_ops{}.
3.) changed the do_xarray_iter() to check the update_off
at proper place (height == 1 and height > 1).
4.) Implement the folio_update_count/folio_xarray_update_off
hooks for large folio page cache.
Signed-off-by: Huang Shijie <huangsj(a)hygon.cn>
---
defs.h | 5 +++++
filesys.c | 51 ++++++++++++++++++++++++++++++++++++++++++++++-----
tools.c | 15 +++++++++++++--
3 files changed, 64 insertions(+), 7 deletions(-)
diff --git a/defs.h b/defs.h
index bd996ef..e7e97e7 100644
--- a/defs.h
+++ b/defs.h
@@ -5689,6 +5689,9 @@ int do_radix_tree_traverse(ulong ptr, int is_root, struct
radix_tree_ops *ops);
struct xarray_ops {
void (*entry)(ulong node, ulong slot, const char *path,
ulong index, void *private);
+ uint (*update_off)(ulong node, uint height, char *path, ulong index,
+ ulong slot, uint off, ulong shift, struct xarray_ops *ops,
+ bool *should_continue);
uint radix;
void *private;
};
@@ -6003,6 +6006,8 @@ ulong do_xarray(ulong, int, struct list_pair *);
#define XARRAY_DUMP_CB (5)
#define XARRAY_TAG_MASK (3UL)
#define XARRAY_TAG_INTERNAL (2UL)
+#define XARRAY_TYPE_PAGE_CACHE 0x8
+extern ulong XA_CHUNK_SHIFT;
int folio_order(ulong folio);
diff --git a/filesys.c b/filesys.c
index 34944e2..35d55a5 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 | XARRAY_TYPE_PAGE_CACHE,
&lp);
if (count != nrpages)
error(INFO, "%s page count: %ld nrpages: %ld\n",
@@ -4217,12 +4217,46 @@ struct do_xarray_info {
ulong maxcount;
ulong count;
void *data;
+ ulong (*update_count)(ulong);
};
+
+static ulong
+folio_update_count(ulong slot)
+{
+ return 1 << folio_order(slot);
+}
+
+static uint folio_xarray_update_off(ulong node, uint height, char *path, ulong index,
+ ulong slot, uint off, ulong shift, struct xarray_ops *ops, bool
*should_continue)
+{
+ uint order;
+
+ *should_continue = false;
+
+ if (height == 1) {
+ order = folio_order(slot) % XA_CHUNK_SHIFT;
+ return 1 << order;
+ }
+
+ /* height > 1 */
+ if ((slot & XARRAY_TAG_MASK) == 0) {
+ ops->entry(node, slot, path, index | off, ops->private);
+ *should_continue = true;
+ order = folio_order(slot) % XA_CHUNK_SHIFT;
+ return 1 << order;
+ }
+ return 1;
+}
+
static void do_xarray_count(ulong node, ulong slot, const char *path,
ulong index, void *private)
{
struct do_xarray_info *info = private;
- info->count++;
+
+ if (info->update_count)
+ info->count += info->update_count(slot);
+ else
+ info->count++;
}
static void do_xarray_search(ulong node, ulong slot, const char *path,
ulong index, void *private)
@@ -4239,8 +4273,9 @@ 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++;
+ do_xarray_count(node, slot, path, index, private);
}
static void do_xarray_gather(ulong node, ulong slot, const char *path,
ulong index, void *private)
@@ -4274,7 +4309,8 @@ 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++;
+
+ do_xarray_count(node, slot, path, index, private);
}
/*
@@ -4318,7 +4354,12 @@ do_xarray(ulong root, int flag, struct list_pair *xp)
.private = &info,
};
- switch (flag)
+ if (flag & XARRAY_TYPE_PAGE_CACHE) {
+ info.update_count = folio_update_count;
+ ops.update_off = folio_xarray_update_off;
+ }
+
+ switch (flag & 0x7)
{
case XARRAY_COUNT:
ops.entry = do_xarray_count;
diff --git a/tools.c b/tools.c
index 69250c4..7dc11ae 100644
--- a/tools.c
+++ b/tools.c
@@ -4728,7 +4728,7 @@ error_height:
return -1;
}
-static ulong XA_CHUNK_SHIFT = UNINITIALIZED;
+ulong XA_CHUNK_SHIFT = UNINITIALIZED;
static ulong XA_CHUNK_SIZE = UNINITIALIZED;
static ulong XA_CHUNK_MASK = UNINITIALIZED;
@@ -4737,21 +4737,32 @@ do_xarray_iter(ulong node, uint height, char *path,
ulong index, struct xarray_ops *ops)
{
uint off;
+ uint update_off;
+ bool should_continue;
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 += update_off) {
ulong slot;
ulong shift = (height - 1) * XA_CHUNK_SHIFT;
+ update_off = 1;
+
readmem(node + OFFSET(xa_node_slots) +
sizeof(void *) * off, KVADDR, &slot, sizeof(void *),
"xa_node.slots[off]", FAULT_ON_ERROR);
if (!slot)
continue;
+ if (ops->update_off) {
+ update_off = ops->update_off(node, height, path, index,
+ slot, off, shift, ops, &should_continue);
+ if (should_continue)
+ continue;
+ }
+
if ((slot & XARRAY_TAG_MASK) == XARRAY_TAG_INTERNAL)
slot &= ~XARRAY_TAG_INTERNAL;
--
2.53.0
9:24 p.m.
New subject: [PATCH v8 2/3] xarray: add large folio support
applied:
https://github.com/crash-utility/crash/commit/28889183d3f55c581b0810aa8bd...
On Tue, May 19, 2026 at 10:23 AM Tao Liu <ltao(a)redhat.com> wrote:
Thanks for all the improvements. LGTM, ack for the patchset.
Thanks,
Tao Liu
On Mon, May 18, 2026 at 11:38 PM Huang Shijie <huangsj(a)hygon.cn> wrote:
>
> 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.) Add XARRAY_TYPE_PAGE_CACHE flag for do_xarray().
> 2.) Add update_count hook for do_xarray_info{},
> add update_off hook for xarray_ops{}.
> 3.) changed the do_xarray_iter() to check the update_off
> at proper place (height == 1 and height > 1).
> 4.) Implement the folio_update_count/folio_xarray_update_off
> hooks for large folio page cache.
>
> Signed-off-by: Huang Shijie <huangsj(a)hygon.cn>
> ---
> defs.h | 5 +++++
> filesys.c | 51 ++++++++++++++++++++++++++++++++++++++++++++++-----
> tools.c | 15 +++++++++++++--
> 3 files changed, 64 insertions(+), 7 deletions(-)
>
> diff --git a/defs.h b/defs.h
> index bd996ef..e7e97e7 100644
> --- a/defs.h
> +++ b/defs.h
> @@ -5689,6 +5689,9 @@ int do_radix_tree_traverse(ulong ptr, int is_root, struct
radix_tree_ops *ops);
> struct xarray_ops {
> void (*entry)(ulong node, ulong slot, const char *path,
> ulong index, void *private);
> + uint (*update_off)(ulong node, uint height, char *path, ulong index,
> + ulong slot, uint off, ulong shift, struct xarray_ops *ops,
> + bool *should_continue);
> uint radix;
> void *private;
> };
> @@ -6003,6 +6006,8 @@ ulong do_xarray(ulong, int, struct list_pair *);
> #define XARRAY_DUMP_CB (5)
> #define XARRAY_TAG_MASK (3UL)
> #define XARRAY_TAG_INTERNAL (2UL)
> +#define XARRAY_TYPE_PAGE_CACHE 0x8
> +extern ulong XA_CHUNK_SHIFT;
>
> int folio_order(ulong folio);
>
> diff --git a/filesys.c b/filesys.c
> index 34944e2..35d55a5 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 | XARRAY_TYPE_PAGE_CACHE,
&lp);
>
> if (count != nrpages)
> error(INFO, "%s page count: %ld nrpages: %ld\n",
> @@ -4217,12 +4217,46 @@ struct do_xarray_info {
> ulong maxcount;
> ulong count;
> void *data;
> + ulong (*update_count)(ulong);
> };
> +
> +static ulong
> +folio_update_count(ulong slot)
> +{
> + return 1 << folio_order(slot);
> +}
> +
> +static uint folio_xarray_update_off(ulong node, uint height, char *path, ulong
index,
> + ulong slot, uint off, ulong shift, struct xarray_ops *ops, bool
*should_continue)
> +{
> + uint order;
> +
> + *should_continue = false;
> +
> + if (height == 1) {
> + order = folio_order(slot) % XA_CHUNK_SHIFT;
> + return 1 << order;
> + }
> +
> + /* height > 1 */
> + if ((slot & XARRAY_TAG_MASK) == 0) {
> + ops->entry(node, slot, path, index | off, ops->private);
> + *should_continue = true;
> + order = folio_order(slot) % XA_CHUNK_SHIFT;
> + return 1 << order;
> + }
> + return 1;
> +}
> +
> static void do_xarray_count(ulong node, ulong slot, const char *path,
> ulong index, void *private)
> {
> struct do_xarray_info *info = private;
> - info->count++;
> +
> + if (info->update_count)
> + info->count += info->update_count(slot);
> + else
> + info->count++;
> }
> static void do_xarray_search(ulong node, ulong slot, const char *path,
> ulong index, void *private)
> @@ -4239,8 +4273,9 @@ 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++;
> + do_xarray_count(node, slot, path, index, private);
> }
> static void do_xarray_gather(ulong node, ulong slot, const char *path,
> ulong index, void *private)
> @@ -4274,7 +4309,8 @@ 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++;
> +
> + do_xarray_count(node, slot, path, index, private);
> }
>
> /*
> @@ -4318,7 +4354,12 @@ do_xarray(ulong root, int flag, struct list_pair *xp)
> .private = &info,
> };
>
> - switch (flag)
> + if (flag & XARRAY_TYPE_PAGE_CACHE) {
> + info.update_count = folio_update_count;
> + ops.update_off = folio_xarray_update_off;
> + }
> +
> + switch (flag & 0x7)
> {
> case XARRAY_COUNT:
> ops.entry = do_xarray_count;
> diff --git a/tools.c b/tools.c
> index 69250c4..7dc11ae 100644
> --- a/tools.c
> +++ b/tools.c
> @@ -4728,7 +4728,7 @@ error_height:
> return -1;
> }
>
> -static ulong XA_CHUNK_SHIFT = UNINITIALIZED;
> +ulong XA_CHUNK_SHIFT = UNINITIALIZED;
> static ulong XA_CHUNK_SIZE = UNINITIALIZED;
> static ulong XA_CHUNK_MASK = UNINITIALIZED;
>
> @@ -4737,21 +4737,32 @@ do_xarray_iter(ulong node, uint height, char *path,
> ulong index, struct xarray_ops *ops)
> {
> uint off;
> + uint update_off;
> + bool should_continue;
>
> 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 += update_off) {
> ulong slot;
> ulong shift = (height - 1) * XA_CHUNK_SHIFT;
>
> + update_off = 1;
> +
> readmem(node + OFFSET(xa_node_slots) +
> sizeof(void *) * off, KVADDR, &slot, sizeof(void *),
> "xa_node.slots[off]", FAULT_ON_ERROR);
> if (!slot)
> continue;
>
> + if (ops->update_off) {
> + update_off = ops->update_off(node, height, path, index,
> + slot, off, shift, ops,
&should_continue);
> + if (should_continue)
> + continue;
> + }
> +
> if ((slot & XARRAY_TAG_MASK) == XARRAY_TAG_INTERNAL)
> slot &= ~XARRAY_TAG_INTERNAL;
>
> --
> 2.53.0
>
>
>
>
6:31 a.m.
New subject: [PATCH v8 3/3] add "files -n" command for an inode
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>
---
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 e7e97e7..6373ee1 100644
--- a/defs.h
+++ b/defs.h
@@ -5948,6 +5948,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 35d55a5..7ff4787 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 502f8fd..38c6a13 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);
@@ -20093,7 +20093,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.53.0
8
days inactive
15
days old
devel@lists.crash-utility.osci.io
5 comments
2 participants
participants (2)
-
Huang Shijie -
Tao Liu