Skip to contentSkip to conversation

riscv: ptdump: Refactor for KVM gstage ptdump support

PATCH Superseded Dylan.Wu 2 participants 7 messages Jul 27

Subsystems (3)

v2 of 3 Superseded Latest is v3 →

lore
Share & tools
lore

Dylan.Wu

author
#0 lore raw

v2 cover riscv: ptdump: Refactor for KVM gstage ptdump support

This is v2 of the series to add KVM gstage ptdump support for RISC-V.

Changes from v1 (https://lore.kernel.org/linux-riscv/[email protected]/):
- Split patch 1 into two patches as requested by Paul Walmsley:
* Patch 1/3: Create ptdump.h header, move declarations there,
and export note_page()
* Patch 2/3: Make attribute parsing use per-level bits configuration,
and rename local pg_level[] to kernel_pg_levels[]
- Added CONFIG_PTDUMP_GSTAGE_DEBUGFS Kconfig option
- Replaced custom walk logic with ptdump_walk_pgd() reuse
- Removed incorrect copyright headers from arch/riscv/kvm/ptdump.c
- Fixed Makefile ordering (alphabetical, under conditional Kconfig)

Dylan.Wu (3):
riscv: ptdump: Create ptdump.h and move declarations
riscv: ptdump: Use per-level attribute bits for parsing
KVM: riscv: Register ptdump with debugfs on guest creation

 arch/riscv/include/asm/ptdump.h |  42 +++++
 arch/riscv/kvm/Kconfig          |  15 ++
 arch/riscv/kvm/Makefile         |   1 +
 arch/riscv/kvm/ptdump.c         | 276 ++++++++++++++++++++++++++++++++
 arch/riscv/mm/ptdump.c          | 106 +++++-------
 5 files changed, 376 insertions(+), 64 deletions(-)
 create mode 100644 arch/riscv/include/asm/ptdump.h
 create mode 100644 arch/riscv/kvm/ptdump.c
Signature · 1 line
2.34.1
author
#1 lore raw

PATCH v2 1/3 riscv: ptdump: Create ptdump.h and move declarations

Create a new arch/riscv/include/asm/ptdump.h header file and move the pagetable walking state structures and level definitions there. This allows other parts of the kernel (like KVM) to reuse the ptdump data structures.

Also export the note_page() symbol so it can be used by other kernel components.

Assisted-by YuanSheng: deepseek-v4-pro
---
 arch/riscv/include/asm/ptdump.h | 41 ++++++++++++++++++++++
 arch/riscv/mm/ptdump.c          | 60 +++++++--------------------------
 2 files changed, 53 insertions(+), 48 deletions(-)
 create mode 100644 arch/riscv/include/asm/ptdump.h
arch/riscv/include/asm/ptdump.h new file +41 -0
new file mode 100644
index 000000000..eb9d11dab
@@ -0,0 +1,41 @@
+/* SPDX-License-Identifier: GPL-2.0 */
+#ifndef _ASM_RISCV_PTDUMP_H
+#define _ASM_RISCV_PTDUMP_H
+
+#include <linux/ptdump.h>
+#include <linux/seq_file.h>
+
+struct addr_marker {
+	unsigned long start_address;
+	const char *name;
+};
+
+struct ptdump_prot_bits {
+	u64 mask;
+	const char *set;
+	const char *clear;
+};
+
+struct ptdump_pg_level {
+	const struct ptdump_prot_bits *bits;
+	const char *name;
+	u64 mask;
+	int num;
+};
+
+struct ptdump_pg_state {
+	struct ptdump_state ptdump;
+	struct seq_file *seq;
+	const struct addr_marker *marker;
+	unsigned long start_address;
+	unsigned long start_pa;
+	unsigned long last_pa;
+	int level;
+	u64 current_prot;
+	bool check_wx;
+	unsigned long wx_pages;
+};
+
+void note_page(struct ptdump_state *pt_st, unsigned long addr, int level, u64 val);
+
+#endif /* _ASM_RISCV_PTDUMP_H */
arch/riscv/mm/ptdump.c +12 -48

127 lines not on this page · raw message

Signature · 1 line
2.34.1
#2 lore raw

Re: [PATCH v2 1/3] riscv: ptdump: Create ptdump.h and move declarations

Thank you for your contribution! Sashiko AI review found 2 potential issue(s) to consider: - [Medium] The refactoring to make ptdump reusable by other components (like KVM) is incomplete. The newly…

Thank you for your contribution! Sashiko AI review found 2 potential issue(s) to consider:
- [Medium] The refactoring to make ptdump reusable by other components (like KVM) is incomplete. The newly added fields bits and num in struct ptdump_pg_level are dead code, and note_page() hardcodes access to file-local static arrays.
- [Low] The function note_page is exported globally with a highly generic name, polluting the global namespace.
--

--- Patch [1]: [PATCH v2 1/3] riscv: ptdump: Create ptdump.h and move declarations --- commit 7ec3e13f790f5980858ebc9e23a4405735f7e6cf
Author: Dylan.Wu <[email protected]>

riscv: ptdump: Create ptdump.h and move declarations

Create a new arch/riscv/include/asm/ptdump.h header file and move the pagetable walking state structures and level definitions there. This allows other parts of the kernel (like KVM) to reuse the ptdump data structures.

Also export the note_page() symbol so it can be used by other kernel components.

Quoted 6 lines
arch/riscv/include/asm/ptdump.h new file +0 -0
new file mode 100644
index 0000000000000..eb9d11dab6098
@@ -0,0 +1,41 @@

[ ... ]

arch/riscv/include/asm/ptdump.h line 24

Quoted 6 lines
arch/riscv/include/asm/ptdump.h new file +6 -0
+struct ptdump_pg_level {
+	const struct ptdump_prot_bits *bits;
+	const char *name;
+	u64 mask;
+	int num;
+};

[Severity: Medium]
Are the newly added fields bits and num essentially dead code?

The commit message indicates this refactoring allows other parts of the kernel (like KVM) to reuse the ptdump data structures. However, these new fields appear to be unused.

For instance, dump_prot() in arch/riscv/mm/ptdump.c still unconditionally iterates over the file-local pte_bits array rather than utilizing the caller-provided bits. Additionally, note_page() continues to hardcode access to the file-local pg_level array.

Does this incomplete refactoring prevent external components from dumping page tables with custom layouts?

[ ... ]

Quoted 4 lines
arch/riscv/mm/ptdump.c +0 -0
index f4b4a9fcbbd88..63655a9c8df3e 100644

[ ... ]

Quoted 5 lines
arch/riscv/mm/ptdump.c +2 -2
-static void note_page(struct ptdump_state *pt_st, unsigned long addr,
-		      int level, u64 val)
+void note_page(struct ptdump_state *pt_st, unsigned long addr,
+	       int level, u64 val)
 {

[ ... ]

arch/riscv/mm/ptdump.c static void note_page(struct ptdump_state *pt_st, unsigned long addr, · line 283

Quoted 5 lines
arch/riscv/mm/ptdump.c +1 -0
@@ -317,6 +280,7 @@ static void note_page(struct ptdump_state *pt_st, unsigned long addr,
 		st->last_pa = pa;
 	}
 }
+EXPORT_SYMBOL_GPL(note_page);

[Severity: Low]
Does exporting this generically named function pollute the global kernel symbol table?

Using a generic name like note_page() (instead of something specific like riscv_ptdump_note_page) could increase the risk of linker collisions if another subsystem uses the same name.

Signature · 1 line
Sashiko AI review · https://sashiko.dev/#/patchset/[email protected]?part=1
author
#3 lore raw

PATCH v2 2/3 riscv: ptdump: Use per-level attribute bits for parsing

In reply to Dylan.Wu

Instead of using the global pte_bits array in dump_prot(), use the per-level bits and num from the associated pg_level entry passed via ptdump_pg_state. This makes the attribute parsing logic fully driven by the per-level configuration, which allows KVM (and other future users) to plug in their own set of protection bits for their pagetable levels.

Rename the local pg_level[] array to kernel_pg_levels[] to avoid shadowing the pg_level pointer in struct ptdump_pg_state.

Assisted-by YuanSheng: deepseek-v4-pro
---
 arch/riscv/include/asm/ptdump.h |  1 +
 arch/riscv/mm/ptdump.c          | 48 +++++++++++++++++++++------------
 2 files changed, 32 insertions(+), 17 deletions(-)
arch/riscv/include/asm/ptdump.h +1 -0
index eb9d11dab..14a262bd0 100644
@@ -28,6 +28,7 @@ struct ptdump_pg_state {
 	struct seq_file *seq;
 	const struct addr_marker *marker;
 	unsigned long start_address;
+	const struct ptdump_pg_level *pg_level;
 	unsigned long start_pa;
 	unsigned long last_pa;
 	int level;
arch/riscv/mm/ptdump.c +31 -17

115 lines not on this page · raw message

Signature · 1 line
2.34.1
#4 lore raw

Re: [PATCH v2 2/3] riscv: ptdump: Use per-level attribute bits for parsing

Thank you for your contribution! Sashiko AI review found 2 potential issue(s) to consider: - [Medium] The refactoring is incomplete because `note_page()` and `dump_addr()` still hardcode…

Thank you for your contribution! Sashiko AI review found 2 potential issue(s) to consider:
- [Medium] The refactoring is incomplete because note_page() and dump_addr() still hardcode kernel_pg_levels instead of using the caller-provided st->pg_level array.
- [Medium] The dump_prot() function retains hardcoded, architecture-specific logic for specific bitmasks, which is unsafe when processing generic, caller-provided bit arrays. --

--- Patch [2]: [PATCH v2 2/3] riscv: ptdump: Use per-level attribute bits for parsing --- commit 1ffa1d459c45da98aa9b8ff61631b9ce3dc228c8
Author: Dylan.Wu <[email protected]>

riscv: ptdump: Use per-level attribute bits for parsing

This commit updates the RISC-V page table dumper to use per-level attribute bits and names passed via the ptdump_pg_state structure. This refactoring is intended to allow future users, such as KVM, to provide their own protection bits for parsing.

arch/riscv/mm/ptdump.c static void dump_prot(struct ptdump_pg_state *st) · line 192

Quoted 11 lines
arch/riscv/mm/ptdump.c +2 -2
@@ -176,21 +188,21 @@ static void dump_prot(struct ptdump_pg_state *st)
 
 		val = st->current_prot & bits[i].mask;
 		if (val) {
-			if (pte_bits[i].mask == _PAGE_SOFT)
-				snprintf(s, sizeof(s), pte_bits[i].set, val >> 8);
+			if (bits[i].mask == _PAGE_SOFT)
+				snprintf(s, sizeof(s), bits[i].set, val >> 8);

[Severity: Medium]
Since the goal of this patch is to support custom caller-provided bit arrays, is it safe to retain these hardcoded checks for _PAGE_SOFT (and _PAGE_MTMASK_SVPBMT below)?

If a future caller (like KVM) provides a custom bitmask that happens to match the value of _PAGE_SOFT, but provides a format string in bits[i].set that doesn't expect an integer, could this snprintf() cause a crash or output garbage?

[ ... ]

arch/riscv/mm/ptdump.c static void dump_addr(struct ptdump_pg_state *st, unsigned long addr) · line 237

Quoted 7 lines
arch/riscv/mm/ptdump.c +1 -1
@@ -221,7 +233,7 @@ static void dump_addr(struct ptdump_pg_state *st, unsigned long addr)
 	}
 
 	pt_dump_seq_printf(st->seq, "%9lu%c %s", delta, *unit,
-			   pg_level[st->level].name);
+			   kernel_pg_levels[st->level].name);
 }

[Severity: Medium]
Will this ignore the caller's custom level names?

It looks like dump_addr() was updated to hardcode kernel_pg_levels instead of using the caller-provided st->pg_level[st->level].name.

[ ... ]

arch/riscv/mm/ptdump.c void note_page(struct ptdump_state *pt_st, unsigned long addr, · line 262

Quoted 6 lines
arch/riscv/mm/ptdump.c +1 -1
@@ -247,7 +259,7 @@ void note_page(struct ptdump_state *pt_st, unsigned long addr,
 	u64 prot = 0;
 
 	if (level >= 0)
-		prot = val & pg_level[level].mask;
+		prot = val & kernel_pg_levels[level].mask;

[Severity: Medium]
Similar to the issue in dump_addr(), will this ignore the custom bitmasks provided by the caller?

By hardcoding kernel_pg_levels[level].mask instead of using st->pg_level[level].mask, it seems this would cause incorrect page table attribute masking for custom callers.

Additionally, could this cause an out-of-bounds array read if a custom caller uses more levels than the 5 defined in kernel_pg_levels?

Signature · 1 line
Sashiko AI review · https://sashiko.dev/#/patchset/[email protected]?part=2
author
#5 lore raw

PATCH v2 3/3 KVM: riscv: Register ptdump with debugfs on guest creation

In reply to Dylan.Wu

Add a new RISC-V KVM specific ptdump implementation that dumps the guest stage-2 (gstage) pagetables via debugfs. The code reuses the common ptdump data structures and helpers from asm/ptdump.h, and exposes a "gstage_page_tables" file in each guest VM's debugfs directory (kvm->debugfs_dentry).

The gstage uses its own set of pg_level and prot_bits arrays (a simplified set of V/R/W/X/D/A/G/U bits), and plugs these into the generic ptdump_walk_pgd() walker just like the host kernel ptdump.

The kvm_arch_create_vm_debugfs() hook (overriding the weak default) is used to register the debugfs file automatically on each VM creation.

Assisted-by YuanSheng: deepseek-v4-pro
---
 arch/riscv/kvm/Kconfig  |  15 +++
 arch/riscv/kvm/Makefile |   1 +
 arch/riscv/kvm/ptdump.c | 276 ++++++++++++++++++++++++++++++++++++++++
 3 files changed, 292 insertions(+)
 create mode 100644 arch/riscv/kvm/ptdump.c
arch/riscv/kvm/Kconfig +15 -0
index ec2cee0a3..9413110a4 100644
@@ -37,4 +37,19 @@ config KVM
 
 	  If unsure, say N.
 
+config PTDUMP_GSTAGE_DEBUGFS
+	bool "Present the gstage pagetables to debugfs"
+	depends on KVM
+	depends on DEBUG_KERNEL
+	depends on DEBUG_FS
+	depends on PTDUMP_DEBUGFS
+	default n
+	help
+	  Say Y here if you want to show the RISC-V KVM gstage guest page tables
+	  layout in a debugfs file. This information is primarily useful for
+	  architecture-specific kernel developers and KVM maintainers to
+	  investigate memory mapping and permission issues. It is probably
+	  not a good idea to enable this feature in a production kernel.
+	  If in doubt, say N.
+
 endif # VIRTUALIZATION
arch/riscv/kvm/Makefile +1 -0
index 296c2ba05..905593d6f 100644
@@ -19,6 +19,7 @@ kvm-y += isa.o
 kvm-y += main.o
 kvm-y += mmu.o
 kvm-y += nacl.o
+kvm-$(CONFIG_PTDUMP_GSTAGE_DEBUGFS) += ptdump.o
 kvm-y += tlb.o
 kvm-y += vcpu.o
 kvm-y += vcpu_config.o
arch/riscv/kvm/ptdump.c new file +276 -0

276 lines not on this page · raw message

Signature · 1 line
2.34.1
#6 lore raw

Re: [PATCH v2 3/3] KVM: riscv: Register ptdump with debugfs on guest creation

Thank you for your contribution! Sashiko AI review found 5 potential issue(s) to consider: - [High] gstage_ptdump_show traverses KVM guest stage-2 page tables without holding kvm->mmu_lock, creating…

Thank you for your contribution! Sashiko AI review found 5 potential issue(s) to consider:
- [High] gstage_ptdump_show traverses KVM guest stage-2 page tables without holding kvm->mmu_lock, creating a severe use-after-free race condition.
- [High] Using the host's generic page table walker for KVM guest stage-2 page tables causes incorrect parsing and potential kernel panics due to mismatched root page table geometries.
- [Medium] Concurrent accesses to the debugfs file cause a data race and persistent state corruption due to mutation of the static gstage_pg_levels array.
- [Medium] If kvm->arch.pgd is NULL, the walker silently falls back to walking the host process's page tables, leaking the host virtual memory layout.
- [Medium] gstage_note_page_flush triggers an integer underflow, printing an astronomically huge size and an incorrect range boundary.
--

--- Patch [3]: [PATCH v2 3/3] KVM: riscv: Register ptdump with debugfs on guest creation --- commit d69a647519dc99ece115797b207b3ba4248c4915
Author: Dylan.Wu <[email protected]>

KVM: riscv: Register ptdump with debugfs on guest creation

Add a new RISC-V KVM specific ptdump implementation that dumps the guest stage-2 (gstage) pagetables via debugfs. The code reuses the common ptdump data structures and helpers from asm/ptdump.h, and exposes a "gstage_page_tables" file in each guest VM's debugfs directory (kvm->debugfs_dentry).

[ ... ]

Quoted 5 lines
arch/riscv/kvm/ptdump.c new file +0 -0
new file mode 100644
index 0000000000000..83a92969bd419

[ ... ]

arch/riscv/kvm/ptdump.c line 221

Quoted 6 lines
arch/riscv/kvm/ptdump.c new file +6 -0
+static void gstage_note_page_flush(struct ptdump_state *pt_st)
+{
+	pte_t pte_zero = {0};
+
+	gstage_note_page(pt_st, 0, -1, pte_val(pte_zero));
+}

[Severity: Medium]
Will this trigger an integer underflow when calculating the block size?

The generic host code uses 0 to denote ULONG_MAX + 1 for address spaces ending at the top of the 64-bit space, where 0 - start_address gracefully yields the correct distance.

However, the KVM guest physical address space ends at gpa_size (e.g., 2TB). Passing 0 here means addr >= st->marker[1].start_address evaluates to false, skipping the 'Guest Physical Address End' marker. It then calculates the size as (0 - start_address) >> 10, which underflows into a massive unsigned integer.

Should this pass the actual end of the guest physical address space instead of 0?

Quoted 5 lines
arch/riscv/kvm/ptdump.c new file +5 -0
+
+static int gstage_ptdump_show(struct seq_file *m, void *v)
+{
+	struct kvm *kvm = m->private;
+	gpa_t gpa_size = kvm_riscv_gstage_gpa_size(kvm->arch.pgd_levels);

[ ... ]

Quoted 4 lines
arch/riscv/kvm/ptdump.c new file +4 -0
+	unsigned int i, j;
+
+	for (i = 0; i < ARRAY_SIZE(gstage_pg_levels); i++) {
+		gstage_pg_levels[i].mask = 0;

arch/riscv/kvm/ptdump.c line 263

Quoted 10 lines
arch/riscv/kvm/ptdump.c new file +10 -0
+		for (j = 0; j < ARRAY_SIZE(gstage_pte_bits); j++)
+			gstage_pg_levels[i].mask |= gstage_pte_bits[j].mask;
+	}
+
+	if (kvm->arch.pgd_levels < 5)
+		gstage_pg_levels[1].name = "PGD";
+	if (kvm->arch.pgd_levels < 4)
+		gstage_pg_levels[2].name = "PGD";
+	if (kvm->arch.pgd_levels < 3)
+		gstage_pg_levels[3].name = "PGD";

[Severity: Medium]
Is it safe to mutate the static global array gstage_pg_levels here without any synchronization?

Since gstage_pg_levels is a global static array, concurrent reads of the debugfs file for different VMs will race here, which could lead to omitted protection bits.

Additionally, downgrading a level's name to "PGD" permanently modifies the array for subsequent reads of VMs that might have deeper page tables. Could this state be maintained per-VM instead of globally?

arch/riscv/kvm/ptdump.c

Quoted 2 lines
arch/riscv/kvm/ptdump.c new file +2 -0
+
+	ptdump_walk_pgd(&st.ptdump, kvm->mm, kvm->arch.pgd);

[Severity: High]
Does this traversal require kvm->mmu_lock to safely walk the guest page tables?

If a user reads the debugfs file while the VM is concurrently modifying or tearing down its page tables, the walker will traverse these structures locklessly. ptdump_walk_pgd() acquires the host userspace mmap_write_lock for kvm->mm, but does not acquire kvm->mmu_lock, which could lead to dereferencing freed intermediate page table pages (use-after-free).

[Severity: High]
Can the host's generic page table walker safely handle KVM guest stage-2 page tables with different geometries?

KVM RISC-V guest page tables have dynamically configured depth through kvm->arch.pgd_levels, which can differ from the host's compile-time depth in CONFIG_PGTABLE_LEVELS.

If the host uses 4 levels and the guest uses 3 levels, the generic walker will treat the guest's 3-level root as a 4-level root. It will descend one level too deep, extracting a PFN from leaf PTEs, converting it to a kernel virtual address, and dereferencing it. Could this trigger an out-of-bounds direct map access and panic the host kernel?

[Severity: Medium]
What happens if kvm->arch.pgd is NULL when this is called?

If the debugfs file is read while kvm_arch_flush_shadow_all() is executing during process exit, kvm->arch.pgd could be NULL.

Inside the generic walker, it detects a NULL pgd and falls back to pgd_offset(walk->mm, addr). Since walk->mm is the host QEMU process's mm, the walker will format and leak the host process's page table layout as if it were the guest's stage-2 memory. Should we check for a NULL pgd before initiating the walk?

Quoted 3 lines
arch/riscv/kvm/ptdump.c new file +3 -0
+
+	return 0;
+}

[ ... ]

Signature · 1 line
Sashiko AI review · https://sashiko.dev/#/patchset/[email protected]?part=3