1:32 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.
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"
Huang Shijie (3):
add folio_order function
xarray: add large folio support
add "files -n" command for an inode
defs.h | 13 +++++++
filesys.c | 108 +++++++++++++++++++++++++++++++++++++++++++++++++-----
help.c | 24 +++++++++++-
memory.c | 84 +++++++++++++++++++++++++++++++++++++++++-
symbols.c | 6 +++
tools.c | 23 +++++++++---
6 files changed, 240 insertions(+), 18 deletions(-)
--
2.53.0
1:32 a.m.
New subject: [PATCH v7 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 | 80 +++++++++++++++++++++++++++++++++++++++++++++++++++++++
symbols.c | 6 +++++
3 files changed, 94 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..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 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
9:47 p.m.
New subject: [PATCH v7 1/3] add folio_order function
On Thu, May 14, 2026 at 6:33 PM Huang Shijie <huangsj(a)hygon.cn> wrote:
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 | 80 +++++++++++++++++++++++++++++++++++++++++++++++++++++++
symbols.c | 6 +++++
3 files changed, 94 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..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))
I think the "free_huge_folio" check is enough, THIS_KERNEL_VERSION >=
LINUX(6,6,0) is not needed. Again, we should avoid the macro as much
as possible.
+ 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 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
2:10 a.m.
New subject: [PATCH v7 1/3] add folio_order function
On Mon, May 18, 2026 at 02:47:52PM +1200, Tao Liu wrote:
On Thu, May 14, 2026 at 6:33 PM Huang Shijie <huangsj(a)hygon.cn>
wrote:
>
> 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 | 80 +++++++++++++++++++++++++++++++++++++++++++++++++++++++
> symbols.c | 6 +++++
> 3 files changed, 94 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..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))
I think the "free_huge_folio" check is enough, THIS_KERNEL_VERSION >=
LINUX(6,6,0) is not needed. Again, we should avoid the macro as much
as possible.
If the "free_huge_folio" is changed in future while the
folio_order()
is still workable, we will lose the indicator for folio_order().
Anyway, if you insist we should not use THIS_KERNEL_VERSION, I am okay.
I can remove it in next version.
Thanks
Huang Shijie
3:35 a.m.
New subject: [PATCH v7 1/3] add folio_order function
On Mon, May 18, 2026 at 7:10 PM Huang Shijie <huangsj(a)hygon.cn> wrote:
On Mon, May 18, 2026 at 02:47:52PM +1200, Tao Liu wrote:
> On Thu, May 14, 2026 at 6:33 PM Huang Shijie <huangsj(a)hygon.cn> wrote:
> >
> > 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 | 80 +++++++++++++++++++++++++++++++++++++++++++++++++++++++
> > symbols.c | 6 +++++
> > 3 files changed, 94 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..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))
>
> I think the "free_huge_folio" check is enough, THIS_KERNEL_VERSION >=
> LINUX(6,6,0) is not needed. Again, we should avoid the macro as much
> as possible.
If the "free_huge_folio" is changed in future while the folio_order()
is still workable, we will lose the indicator for folio_order().
If "free_huge_folio" is changed in the future, a new(maybe a better)
indicator should be used instead, we shouldn't hide this issue by
version number macro.
Anyway, if you insist we should not use THIS_KERNEL_VERSION, I am okay.
I can remove it in next version.
Please do, thanks!
Thanks
Huang Shijie
1:32 a.m.
New subject: [PATCH v7 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 places (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 | 4 ++++
filesys.c | 48 +++++++++++++++++++++++++++++++++++++++++++-----
tools.c | 23 ++++++++++++++++++-----
3 files changed, 65 insertions(+), 10 deletions(-)
diff --git a/defs.h b/defs.h
index bd996ef..5c823f8 100644
--- a/defs.h
+++ b/defs.h
@@ -5689,6 +5689,8 @@ 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);
uint radix;
void *private;
};
@@ -6003,6 +6005,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..cc6176a 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,43 @@ 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)
+{
+ uint order;
+
+ if (height > 1) {
+ if ((slot & XARRAY_TAG_MASK) == 0) {
+ ops->entry(node, slot, path, index | off, ops->private);
+ order = folio_order(slot) % XA_CHUNK_SHIFT;
+ return 1 << order;
+ }
+ return 0;
+ }
+
+ /* The height == 1 */
+ order = folio_order(slot) % XA_CHUNK_SHIFT;
+ return 1 << order;
+}
+
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 +4270,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 +4306,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 +4351,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..0302cec 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,27 +4737,40 @@ do_xarray_iter(ulong node, uint height, char *path,
ulong index, struct xarray_ops *ops)
{
uint off;
+ uint update_off;
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 ((slot & XARRAY_TAG_MASK) == XARRAY_TAG_INTERNAL)
+ if ((slot & XARRAY_TAG_MASK) == XARRAY_TAG_INTERNAL) {
slot &= ~XARRAY_TAG_INTERNAL;
+ } else if (ops->update_off && height > 1) {
+ update_off = ops->update_off(node, height, path, index,
+ slot, off, shift, ops);
+ if (update_off)
+ continue;
+ update_off = 1;
+ }
- if (height == 1)
+ if (height == 1) {
ops->entry(node, slot, path, index | off, ops->private);
- else {
+ if (ops->update_off)
+ update_off = ops->update_off(node, height, path, index,
+ slot, off, shift, ops);
+ } else {
ulong child_index = index | (off << shift);
char child_path[BUFSIZE];
sprintf(child_path, "%s/%d", path, off);
--
2.53.0
9:44 p.m.
New subject: [PATCH v7 2/3] xarray: add large folio support
Hi Huang,
I made some modification upon your v7, could you please check if this
works for you?
I guess this will make folio_xarray_update_off() cleaner, and
less-code-change on do_xarray_iter().
Thanks,
Tao Liu
diff --git a/filesys.c b/filesys.c
index fc672ad..2f2e872 100644
--- a/filesys.c
+++ b/filesys.c
@@ -4277,22 +4277,22 @@ folio_update_count(ulong 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)
+ ulong slot, uint off, ulong shift, struct xarray_ops
*ops)
{
- uint order;
-
- if (height > 1) {
- if ((slot & XARRAY_TAG_MASK) == 0) {
- ops->entry(node, slot, path, index | off, ops->private);
- order = folio_order(slot) % XA_CHUNK_SHIFT;
- return 1 << order;
- }
- return 0;
- }
-
- /* The height == 1 */
- order = folio_order(slot) % XA_CHUNK_SHIFT;
- return 1 << order;
+ uint order;
+
+ if (height == 1) {
+ order = folio_order(slot) % XA_CHUNK_SHIFT;
+ return 1 << order;
+ }
+
+ if ((slot & XARRAY_TAG_MASK) == 0) {
+ ops->entry(node, slot, path, index | off, ops->private);
+ order = folio_order(slot) % XA_CHUNK_SHIFT;
+ return 1 << order;
+ }
+
+ return 1;
}
static void do_xarray_count(ulong node, ulong slot, const char *path,
diff --git a/tools.c b/tools.c
index 0302cec..4558e58 100644
--- a/tools.c
+++ b/tools.c
@@ -4755,21 +4755,16 @@ do_xarray_iter(ulong node, uint height, char *path,
if (!slot)
continue;
+ if (ops->update_off)
+ update_off = ops->update_off(node, height, path, index,
+ slot, off, shift, ops);
+
if ((slot & XARRAY_TAG_MASK) == XARRAY_TAG_INTERNAL) {
slot &= ~XARRAY_TAG_INTERNAL;
- } else if (ops->update_off && height > 1) {
- update_off = ops->update_off(node, height, path, index,
- slot, off, shift, ops);
- if (update_off)
- continue;
- update_off = 1;
}
if (height == 1) {
ops->entry(node, slot, path, index | off, ops->private);
- if (ops->update_off)
- update_off = ops->update_off(node, height, path,
index,
- slot, off, shift, ops);
} else {
ulong child_index = index | (off << shift);
char child_path[BUFSIZE];
2 a.m.
New subject: [PATCH v7 2/3] xarray: add large folio support
On Mon, May 18, 2026 at 02:44:10PM +1200, Tao Liu wrote:
Hi Huang,
I made some modification upon your v7, could you please check if this
works for you?
I test this code, it does not work.
I met the error log like this:
-------------------------------------------
crash> files -p ffff8de2bbc36f38
INODE NRPAGES
ffff8de2bbc36f38 103356
PAGE PHYSICAL MAPPING INDEX CNT FLAGS
fffffa7284983ac0 61260eb000 ffff8de2bbc370a8 0 1 197ffffc000092c
referenced,uptodate,lru,active,owner_2
fffffa7284983b00 61260ec000 ffff8de2bbc370a8 1 1 197ffffc000092c
referenced,uptodate,lru,active,owner_2
fffffa7284983b40 61260ed000 ffff8de2bbc370a8 2 1 197ffffc000092c
referenced,uptodate,lru,active,owner_2
fffffa7284983b80 61260ee000 ffff8de2bbc370a8 3 1 197ffffc000092c
referenced,uptodate,lru,active,owner_2
fffffa728382e000 60e0b80000 ffff8de2bbc370a8 4 4 197ffffc000096c
referenced,uptodate,lru,active,owner_2,head
fffffa728382e100 60e0b84000 ffff8de2bbc370a8 8 4 197ffffc000096c
referenced,uptodate,lru,active,owner_2,head
fffffa728382e200 60e0b88000 ffff8de2bbc370a8 c 4 197ffffc000096c
referenced,uptodate,lru,active,owner_2,head
fffffa728382e300 60e0b8c000 ffff8de2bbc370a8 10 4 197ffffc000096c
referenced,uptodate,lru,active,owner_2,head
fffffa728382e400 60e0b90000 ffff8de2bbc370a8 14 4 197ffffc000096c
referenced,uptodate,lru,active,owner_2,head
fffffa7282ffd200 60bff48000 ffff8de2bbc370a8 18 8 197ffffc000096c
referenced,uptodate,lru,active,owner_2,head
fffffa7283a1a000 60e8680000 ffff8de2bbc370a8 20 16 197ffffc000096c
referenced,uptodate,lru,active,owner_2,head
fffffa7283a1a400 60e8690000 ffff8de2bbc370a8 30 16 197ffffc000096c
referenced,uptodate,lru,active,owner_2,head
fffffa7283d8b800 60f62e0000 ffff8de2bbc370a8 40 16 197ffffc000096c
referenced,uptodate,lru,active,owner_2,head
fffffa7283d8bc00 60f62f0000 ffff8de2bbc370a8 50 16 197ffffc000096c
referenced,uptodate,lru,active,owner_2,head
fffffa72839fe000 60e7f80000 ffff8de2bbc370a8 60 32 197ffffc000096c
referenced,uptodate,lru,active,owner_2,head
fffffa7283598000 60d6600000 ffff8de2bbc370a8 80 64 197ffffc000096c
referenced,uptodate,lru,active,owner_2,head
files: invalid kernel virtual address: 40ffffffff type: "folio.page.flags"
crash>
-------------------------------------------
I guess this will make folio_xarray_update_off() cleaner, and
less-code-change on do_xarray_iter().
Thanks,
Tao Liu
diff --git a/filesys.c b/filesys.c
index fc672ad..2f2e872 100644
--- a/filesys.c
+++ b/filesys.c
@@ -4277,22 +4277,22 @@ folio_update_count(ulong 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)
+ ulong slot, uint off, ulong shift, struct xarray_ops
*ops)
{
- uint order;
-
- if (height > 1) {
- if ((slot & XARRAY_TAG_MASK) == 0) {
- ops->entry(node, slot, path, index | off, ops->private);
- order = folio_order(slot) % XA_CHUNK_SHIFT;
- return 1 << order;
- }
- return 0;
- }
-
- /* The height == 1 */
- order = folio_order(slot) % XA_CHUNK_SHIFT;
- return 1 << order;
+ uint order;
+
+ if (height == 1) {
+ order = folio_order(slot) % XA_CHUNK_SHIFT;
+ return 1 << order;
+ }
+
+ if ((slot & XARRAY_TAG_MASK) == 0) {
+ ops->entry(node, slot, path, index | off, ops->private);
+ order = folio_order(slot) % XA_CHUNK_SHIFT;
+ return 1 << order;
+ }
+
+ return 1;
}
static void do_xarray_count(ulong node, ulong slot, const char *path,
diff --git a/tools.c b/tools.c
index 0302cec..4558e58 100644
--- a/tools.c
+++ b/tools.c
@@ -4755,21 +4755,16 @@ do_xarray_iter(ulong node, uint height, char *path,
if (!slot)
continue;
+ if (ops->update_off)
+ update_off = ops->update_off(node, height, path, index,
+ slot, off, shift, ops);
+
The issue is here:
If the "height > 1" and we meet a large folio, we should not do the
do_xarray_iter()
later.
I created a patch based on your code:
---
filesys.c | 2 +-
tools.c | 8 +++++++-
2 files changed, 8 insertions(+), 2 deletions(-)
diff --git a/filesys.c b/filesys.c
index a361596..de3cdf4 100644
--- a/filesys.c
+++ b/filesys.c
@@ -4292,7 +4292,7 @@ static uint folio_xarray_update_off(ulong node, uint height, char
*path, ulong i
return 1 << order;
}
- return 1;
+ return 0;
}
static void do_xarray_count(ulong node, ulong slot, const char *path,
diff --git a/tools.c b/tools.c
index b3650c0..fc55c99 100644
--- a/tools.c
+++ b/tools.c
@@ -4755,9 +4755,15 @@ do_xarray_iter(ulong node, uint height, char *path,
if (!slot)
continue;
- if (ops->update_off)
+ if (ops->update_off) {
update_off = ops->update_off(node, height, path, index,
slot, off, shift, ops);
+ if (height > 1) {
+ if (update_off)
+ continue;
+ update_off = 1;
+ }
+ }
if ((slot & XARRAY_TAG_MASK) == XARRAY_TAG_INTERNAL) {
slot &= ~XARRAY_TAG_INTERNAL;
--
If you think it is okay, I can create a formal patch.
Thanks
Huang Shijie
if ((slot & XARRAY_TAG_MASK) ==
XARRAY_TAG_INTERNAL) {
slot &= ~XARRAY_TAG_INTERNAL;
- } else if (ops->update_off && height > 1) {
- update_off = ops->update_off(node, height, path, index,
- slot, off, shift, ops);
- if (update_off)
- continue;
- update_off = 1;
}
if (height == 1) {
ops->entry(node, slot, path, index | off, ops->private);
- if (ops->update_off)
- update_off = ops->update_off(node, height, path,
index,
- slot, off, shift, ops);
} else {
ulong child_index = index | (off << shift);
char child_path[BUFSIZE];
3:21 a.m.
New subject: [PATCH v7 2/3] xarray: add large folio support
On Mon, May 18, 2026 at 03:00:25PM +0800, Huang Shijie wrote:
On Mon, May 18, 2026 at 02:44:10PM +1200, Tao Liu wrote:
> Hi Huang,
>
> I made some modification upon your v7, could you please check if this
> works for you?
I test this code, it does not work.
I met the error log like this:
-------------------------------------------
crash> files -p ffff8de2bbc36f38
INODE NRPAGES
ffff8de2bbc36f38 103356
PAGE PHYSICAL MAPPING INDEX CNT FLAGS
fffffa7284983ac0 61260eb000 ffff8de2bbc370a8 0 1 197ffffc000092c
referenced,uptodate,lru,active,owner_2
fffffa7284983b00 61260ec000 ffff8de2bbc370a8 1 1 197ffffc000092c
referenced,uptodate,lru,active,owner_2
fffffa7284983b40 61260ed000 ffff8de2bbc370a8 2 1 197ffffc000092c
referenced,uptodate,lru,active,owner_2
fffffa7284983b80 61260ee000 ffff8de2bbc370a8 3 1 197ffffc000092c
referenced,uptodate,lru,active,owner_2
fffffa728382e000 60e0b80000 ffff8de2bbc370a8 4 4 197ffffc000096c
referenced,uptodate,lru,active,owner_2,head
fffffa728382e100 60e0b84000 ffff8de2bbc370a8 8 4 197ffffc000096c
referenced,uptodate,lru,active,owner_2,head
fffffa728382e200 60e0b88000 ffff8de2bbc370a8 c 4 197ffffc000096c
referenced,uptodate,lru,active,owner_2,head
fffffa728382e300 60e0b8c000 ffff8de2bbc370a8 10 4 197ffffc000096c
referenced,uptodate,lru,active,owner_2,head
fffffa728382e400 60e0b90000 ffff8de2bbc370a8 14 4 197ffffc000096c
referenced,uptodate,lru,active,owner_2,head
fffffa7282ffd200 60bff48000 ffff8de2bbc370a8 18 8 197ffffc000096c
referenced,uptodate,lru,active,owner_2,head
fffffa7283a1a000 60e8680000 ffff8de2bbc370a8 20 16 197ffffc000096c
referenced,uptodate,lru,active,owner_2,head
fffffa7283a1a400 60e8690000 ffff8de2bbc370a8 30 16 197ffffc000096c
referenced,uptodate,lru,active,owner_2,head
fffffa7283d8b800 60f62e0000 ffff8de2bbc370a8 40 16 197ffffc000096c
referenced,uptodate,lru,active,owner_2,head
fffffa7283d8bc00 60f62f0000 ffff8de2bbc370a8 50 16 197ffffc000096c
referenced,uptodate,lru,active,owner_2,head
fffffa72839fe000 60e7f80000 ffff8de2bbc370a8 60 32 197ffffc000096c
referenced,uptodate,lru,active,owner_2,head
fffffa7283598000 60d6600000 ffff8de2bbc370a8 80 64 197ffffc000096c
referenced,uptodate,lru,active,owner_2,head
files: invalid kernel virtual address: 40ffffffff type: "folio.page.flags"
crash>
-------------------------------------------
Thanks for the feedback.
>
> I guess this will make folio_xarray_update_off() cleaner, and
> less-code-change on do_xarray_iter().
>
> Thanks,
> Tao Liu
>
> diff --git a/filesys.c b/filesys.c
> index fc672ad..2f2e872 100644
> --- a/filesys.c
> +++ b/filesys.c
> @@ -4277,22 +4277,22 @@ folio_update_count(ulong 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)
> + ulong slot, uint off, ulong shift, struct xarray_ops
*ops)
> {
> - uint order;
> -
> - if (height > 1) {
> - if ((slot & XARRAY_TAG_MASK) == 0) {
> - ops->entry(node, slot, path, index | off,
ops->private);
> - order = folio_order(slot) % XA_CHUNK_SHIFT;
> - return 1 << order;
> - }
> - return 0;
> - }
> -
> - /* The height == 1 */
> - order = folio_order(slot) % XA_CHUNK_SHIFT;
> - return 1 << order;
> + uint order;
> +
> + if (height == 1) {
> + order = folio_order(slot) % XA_CHUNK_SHIFT;
> + return 1 << order;
> + }
> +
> + if ((slot & XARRAY_TAG_MASK) == 0) {
> + ops->entry(node, slot, path, index | off, ops->private);
> + order = folio_order(slot) % XA_CHUNK_SHIFT;
> + return 1 << order;
> + }
> +
> + return 1;
> }
>
> static void do_xarray_count(ulong node, ulong slot, const char *path,
> diff --git a/tools.c b/tools.c
> index 0302cec..4558e58 100644
> --- a/tools.c
> +++ b/tools.c
> @@ -4755,21 +4755,16 @@ do_xarray_iter(ulong node, uint height, char *path,
> if (!slot)
> continue;
>
> + if (ops->update_off)
> + update_off = ops->update_off(node, height, path, index,
> + slot, off, shift, ops);
> +
The issue is here:
If the "height > 1" and we meet a large folio, we should not do the
do_xarray_iter()
later.
I created a patch based on your code:
---
filesys.c | 2 +-
tools.c | 8 +++++++-
2 files changed, 8 insertions(+), 2 deletions(-)
diff --git a/filesys.c b/filesys.c
index a361596..de3cdf4 100644
--- a/filesys.c
+++ b/filesys.c
@@ -4292,7 +4292,7 @@ static uint folio_xarray_update_off(ulong node, uint height, char
*path, ulong i
return 1 << order;
}
- return 1;
+ return 0;
}
static void do_xarray_count(ulong node, ulong slot, const char *path,
diff --git a/tools.c b/tools.c
index b3650c0..fc55c99 100644
--- a/tools.c
+++ b/tools.c
@@ -4755,9 +4755,15 @@ do_xarray_iter(ulong node, uint height, char *path,
if (!slot)
continue;
- if (ops->update_off)
+ if (ops->update_off) {
update_off = ops->update_off(node, height, path, index,
slot, off, shift, ops);
+ if (height > 1) {
+ if (update_off)
+ continue;
+ update_off = 1;
+ }
+ }
Sorry to be picky, I still think the height > 1 and continue thing is folio's
stuff.
Please checkout my updated modification on your v7.
if ((slot & XARRAY_TAG_MASK) == XARRAY_TAG_INTERNAL) {
slot &= ~XARRAY_TAG_INTERNAL;
--
If you think it is okay, I can create a formal patch.
Thanks
Huang Shijie
> if ((slot & XARRAY_TAG_MASK) == XARRAY_TAG_INTERNAL) {
> slot &= ~XARRAY_TAG_INTERNAL;
> - } else if (ops->update_off && height > 1) {
> - update_off = ops->update_off(node, height, path, index,
> - slot, off, shift, ops);
> - if (update_off)
> - continue;
> - update_off = 1;
> }
>
> if (height == 1) {
> ops->entry(node, slot, path, index | off,
ops->private);
> - if (ops->update_off)
> - update_off = ops->update_off(node, height, path,
index,
> - slot, off, shift,
ops);
> } else {
> ulong child_index = index | (off << shift);
> char child_path[BUFSIZE];
>
>
diff --git a/defs.h b/defs.h
index 52f8ce9..ccc2d93 100644
--- a/defs.h
+++ b/defs.h
@@ -5690,7 +5690,8 @@ 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);
+ ulong slot, uint off, ulong shift, struct xarray_ops *ops,
+ bool *should_continue);
uint radix;
void *private;
};
diff --git a/filesys.c b/filesys.c
index fc672ad..8a073e0 100644
--- a/filesys.c
+++ b/filesys.c
@@ -4277,22 +4277,25 @@ folio_update_count(ulong 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)
+ ulong slot, uint off, ulong shift, struct xarray_ops
*ops,
+ bool *should_continue)
{
- uint order;
-
- if (height > 1) {
- if ((slot & XARRAY_TAG_MASK) == 0) {
- ops->entry(node, slot, path, index | off, ops->private);
- order = folio_order(slot) % XA_CHUNK_SHIFT;
- return 1 << order;
- }
- return 0;
- }
-
- /* The height == 1 */
- order = folio_order(slot) % XA_CHUNK_SHIFT;
- return 1 << order;
+ uint order;
+
+ if (height == 1) {
+ order = folio_order(slot) % XA_CHUNK_SHIFT;
+ return 1 << order;
+ }
+
+ if ((slot & XARRAY_TAG_MASK) == 0) {
+ if (height > 1)
+ *should_continue = true;
+ ops->entry(node, slot, path, index | off, ops->private);
+ order = folio_order(slot) % XA_CHUNK_SHIFT;
+ return 1 << order;
+ }
+
+ return 1;
}
static void do_xarray_count(ulong node, ulong slot, const char *path,
diff --git a/tools.c b/tools.c
index 0302cec..3729648 100644
--- a/tools.c
+++ b/tools.c
@@ -4738,6 +4738,7 @@ do_xarray_iter(ulong node, uint height, char *path,
{
uint off;
uint update_off;
+ bool should_continue;
if (!hq_enter(node))
error(FATAL,
@@ -4748,6 +4749,7 @@ do_xarray_iter(ulong node, uint height, char *path,
if (!slot)
continue;
- if ((slot & XARRAY_TAG_MASK) == XARRAY_TAG_INTERNAL) {
- slot &= ~XARRAY_TAG_INTERNAL;
- } else if (ops->update_off && height > 1) {
+ if (ops->update_off) {
update_off = ops->update_off(node, height, path, index,
- slot, off, shift, ops);
- if (update_off)
+ slot, off, shift, ops, &should_continue);
+ if (should_continue)
continue;
- update_off = 1;
+ }
+
+ if ((slot & XARRAY_TAG_MASK) == XARRAY_TAG_INTERNAL) {
+ slot &= ~XARRAY_TAG_INTERNAL;
}
if (height == 1) {
ops->entry(node, slot, path, index | off, ops->private);
- if (ops->update_off)
- update_off = ops->update_off(node, height, path,
index,
- slot, off, shift, ops);
} else {
ulong child_index = index | (off << shift);
char child_path[BUFSIZE];
3:36 a.m.
New subject: [PATCH v7 2/3] xarray: add large folio support
On Mon, May 18, 2026 at 08:21:09PM +1200, Tao Liu wrote:
> index b3650c0..fc55c99 100644
> --- a/tools.c
> +++ b/tools.c
> @@ -4755,9 +4755,15 @@ do_xarray_iter(ulong node, uint height, char *path,
> if (!slot)
> continue;
>
> - if (ops->update_off)
> + if (ops->update_off) {
> update_off = ops->update_off(node, height, path, index,
> slot, off, shift, ops);
> + if (height > 1) {
> + if (update_off)
> + continue;
> + update_off = 1;
> + }
> + }
Sorry to be picky, I still think the height > 1 and continue thing is folio's
stuff.
Okay, no problem.
Please checkout my updated modification on your v7.
>
> if ((slot & XARRAY_TAG_MASK) == XARRAY_TAG_INTERNAL) {
> slot &= ~XARRAY_TAG_INTERNAL;
> --
>
> If you think it is okay, I can create a formal patch.
>
>
> Thanks
> Huang Shijie
>
>
> > if ((slot & XARRAY_TAG_MASK) == XARRAY_TAG_INTERNAL) {
> > slot &= ~XARRAY_TAG_INTERNAL;
> > - } else if (ops->update_off && height > 1) {
> > - update_off = ops->update_off(node, height, path,
index,
> > - slot, off, shift,
ops);
> > - if (update_off)
> > - continue;
> > - update_off = 1;
> > }
> >
> > if (height == 1) {
> > ops->entry(node, slot, path, index | off,
ops->private);
> > - if (ops->update_off)
> > - update_off = ops->update_off(node, height,
path, index,
> > - slot, off,
shift, ops);
> > } else {
> > ulong child_index = index | (off << shift);
> > char child_path[BUFSIZE];
> >
> >
>
>
>
diff --git a/defs.h b/defs.h
index 52f8ce9..ccc2d93 100644
--- a/defs.h
+++ b/defs.h
@@ -5690,7 +5690,8 @@ 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);
+ ulong slot, uint off, ulong shift, struct xarray_ops *ops,
+ bool *should_continue);
uint radix;
void *private;
};
diff --git a/filesys.c b/filesys.c
index fc672ad..8a073e0 100644
--- a/filesys.c
+++ b/filesys.c
@@ -4277,22 +4277,25 @@ folio_update_count(ulong 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)
+ ulong slot, uint off, ulong shift, struct xarray_ops
*ops,
+ bool *should_continue)
{
- uint order;
-
- if (height > 1) {
- if ((slot & XARRAY_TAG_MASK) == 0) {
- ops->entry(node, slot, path, index | off, ops->private);
- order = folio_order(slot) % XA_CHUNK_SHIFT;
- return 1 << order;
- }
- return 0;
- }
-
- /* The height == 1 */
- order = folio_order(slot) % XA_CHUNK_SHIFT;
- return 1 << order;
+ uint order;
+
+ if (height == 1) {
+ order = folio_order(slot) % XA_CHUNK_SHIFT;
+ return 1 << order;
+ }
+
+ if ((slot & XARRAY_TAG_MASK) == 0) {
+ if (height > 1)
+ *should_continue = true;
okay. I will change the code like this.
Thanks
Huang Shijie
1:32 a.m.
New subject: [PATCH v7 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 5c823f8..52f8ce9 100644
--- a/defs.h
+++ b/defs.h
@@ -5947,6 +5947,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 cc6176a..fc672ad 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.53.0
15
days inactive
19
days old
devel@lists.crash-utility.osci.io
10 comments
2 participants
participants (2)
-
Huang Shijie -
Tao Liu