Skip to contentSkip to conversation

Support runtime configuration for per-VM's HGATP mode

PATCH Superseded [email protected] 3 participants 14 messages Feb 4 – Mar 27

Subsystems (4)

v5 of 8 Superseded Latest is v8 →

lore
Share & tools
lore
#0 lore raw

v5 cover Support runtime configuration for per-VM's HGATP mode

From: Fangyu Yu <[email protected]>

Currently, RISC-V KVM hardcodes the G-stage page table format (HGATP mode) to the maximum mode detected at boot time (e.g., SV57x4 if supported). but often such a wide GPA is unnecessary, just as a host sometimes doesn't need sv57.

This patch introduces per-VM configurability of the G-stage mode via a new KVM capability: KVM_CAP_RISCV_SET_HGATP_MODE. User-space can now explicitly request a specific HGATP mode (SV39x4, SV48x4, SV57x4 or SV32x4) during VM creation.

---
Changes in v5:
- Use architectural HGATP.MODE encodings as the bit index for the supported-mode bitmap and for the VM-mode selection UAPI; no new UAPI mode/bit defines are introduced(per Radim).
- Allow KVM_CAP_RISCV_SET_HGATP_MODE on RV32 as well(per Drew).
- Link to v4:
https://lore.kernel.org/linux-riscv/[email protected]/
---
Changes in v4:
- Extend kvm_riscv_gstage_mode_detect() to probe all HGATP.MODE values supported by the host and record them in a bitmask.
- Treat unexpected pgd_levels in kvm_riscv_gstage_mode() as an internal error (e.g. WARN_ON_ONCE())(per Radim).
- Move kvm_riscv_gstage_gpa_bits() and kvm_riscv_gstage_gpa_size() to header as static inline helpers(per Radim).
- Drop gstage_mode_user_initialized and Remove the kvm_debug() message from KVM_CAP_RISCV_SET_HGATP_MODE(per Radim).
- Link to v3:
https://lore.kernel.org/linux-riscv/[email protected]/
---
Changes in v3:
- Reworked the patch formatting (per Drew).
- Dropped kvm->arch.kvm_riscv_gstage_mode and derive HGATP.MODE from kvm_riscv_gstage_pgd_levels via a helper, avoiding redundant per-VM state(per Drew).
- Removed kvm_riscv_gstage_max_mode and keep only kvm_riscv_gstage_max_pgd_levels for host capability detection(per Drew).
- Other initialization and return value issues(per Drew).
- Enforce that KVM_CAP_RISCV_SET_HGATP_MODE can only be enabled before any vCPUs are created by rejecting the ioctl once kvm->created_vcpus is non-zero(per Radim).
- Add a memslot safety check and reject the capability unless kvm_are_all_memslots_empty(kvm) is true, ensuring the G-stage format is not changed after any memslots have been installed(per Radim).
- Link to v2:
https://lore.kernel.org/linux-riscv/[email protected]/

Fangyu Yu (3):
RISC-V: KVM: Support runtime configuration for per-VM's HGATP mode
RISC-V: KVM: Detect and expose supported HGATP G-stage modes
RISC-V: KVM: add KVM_CAP_RISCV_SET_HGATP_MODE

 Documentation/virt/kvm/api.rst      |  27 ++++++++
 arch/riscv/include/asm/kvm_gstage.h |  31 +++++++--
 arch/riscv/include/asm/kvm_host.h   |  19 ++++++
 arch/riscv/kvm/gstage.c             | 102 ++++++++++++++--------------
 arch/riscv/kvm/main.c               |  12 ++--
 arch/riscv/kvm/mmu.c                |  20 +++---
 arch/riscv/kvm/vm.c                 |  21 +++++-
 arch/riscv/kvm/vmid.c               |   3 +-
 include/uapi/linux/kvm.h            |   1 +
 9 files changed, 160 insertions(+), 76 deletions(-)
Signature · 1 line
2.50.1
#1 lore raw

PATCH v5 1/3 RISC-V: KVM: Support runtime configuration for per-VM's HGATP mode

From: Fangyu Yu <[email protected]>

Introduces one per-VM architecture-specific fields to support runtime configuration of the G-stage page table format:

- kvm->arch.kvm_riscv_gstage_pgd_levels: the corresponding number of page table levels for the selected mode.

These fields replace the previous global variables kvm_riscv_gstage_mode and kvm_riscv_gstage_pgd_levels, enabling different virtual machines to independently select their G-stage page table format instead of being forced to share the maximum mode detected by the kernel at boot time.

---
 arch/riscv/include/asm/kvm_gstage.h | 20 +++++----
 arch/riscv/include/asm/kvm_host.h   | 19 +++++++++
 arch/riscv/kvm/gstage.c             | 65 ++++++++++++++---------------
 arch/riscv/kvm/main.c               | 12 +++---
 arch/riscv/kvm/mmu.c                | 20 +++++----
 arch/riscv/kvm/vm.c                 |  2 +-
 arch/riscv/kvm/vmid.c               |  3 +-
 7 files changed, 84 insertions(+), 57 deletions(-)
arch/riscv/include/asm/kvm_gstage.h +13 -7
index 595e2183173e..b12605fbca44 100644
@@ -29,16 +29,22 @@ struct kvm_gstage_mapping {
 #define kvm_riscv_gstage_index_bits	10
 #endif
 
-extern unsigned long kvm_riscv_gstage_mode;
-extern unsigned long kvm_riscv_gstage_pgd_levels;
+extern unsigned long kvm_riscv_gstage_max_pgd_levels;
 
 #define kvm_riscv_gstage_pgd_xbits	2
 #define kvm_riscv_gstage_pgd_size	(1UL << (HGATP_PAGE_SHIFT + kvm_riscv_gstage_pgd_xbits))
-#define kvm_riscv_gstage_gpa_bits	(HGATP_PAGE_SHIFT + \
-					 (kvm_riscv_gstage_pgd_levels * \
-					  kvm_riscv_gstage_index_bits) + \
-					 kvm_riscv_gstage_pgd_xbits)
-#define kvm_riscv_gstage_gpa_size	((gpa_t)(1ULL << kvm_riscv_gstage_gpa_bits))
+
+static inline unsigned long kvm_riscv_gstage_gpa_bits(struct kvm_arch *ka)
+{
+	return (HGATP_PAGE_SHIFT +
+		ka->kvm_riscv_gstage_pgd_levels * kvm_riscv_gstage_index_bits +
+		kvm_riscv_gstage_pgd_xbits);
+}
+
+static inline gpa_t kvm_riscv_gstage_gpa_size(struct kvm_arch *ka)
+{
+	return BIT_ULL(kvm_riscv_gstage_gpa_bits(ka));
+}
 
 bool kvm_riscv_gstage_get_leaf(struct kvm_gstage *gstage, gpa_t addr,
 			       pte_t **ptepp, u32 *ptep_level);
arch/riscv/include/asm/kvm_host.h +19 -0
index 24585304c02b..0ace5e98c133 100644
@@ -87,6 +87,23 @@ struct kvm_vcpu_stat {
 struct kvm_arch_memory_slot {
 };
 
+static inline unsigned long kvm_riscv_gstage_mode(unsigned long pgd_levels)
+{
+	switch (pgd_levels) {
+	case 2:
+		return HGATP_MODE_SV32X4;
+	case 3:
+		return HGATP_MODE_SV39X4;
+	case 4:
+		return HGATP_MODE_SV48X4;
+	case 5:
+		return HGATP_MODE_SV57X4;
+	default:
+		WARN_ON_ONCE(1);
+		return HGATP_MODE_OFF;
+	}
+}
+
 struct kvm_arch {
 	/* G-stage vmid */
 	struct kvm_vmid vmid;
@@ -103,6 +120,8 @@ struct kvm_arch {
 
 	/* KVM_CAP_RISCV_MP_STATE_RESET */
 	bool mp_state_reset;
+
+	unsigned long kvm_riscv_gstage_pgd_levels;
 };
 
 struct kvm_cpu_trap {
arch/riscv/kvm/gstage.c +31 -34

201 lines not on this page · raw message

arch/riscv/kvm/main.c +6 -6
index 45536af521f0..786c0025e2c3 100644
@@ -105,17 +105,17 @@ static int __init riscv_kvm_init(void)
 		return rc;
 
 	kvm_riscv_gstage_mode_detect();
-	switch (kvm_riscv_gstage_mode) {
-	case HGATP_MODE_SV32X4:
+	switch (kvm_riscv_gstage_max_pgd_levels) {
+	case 2:
 		str = "Sv32x4";
 		break;
-	case HGATP_MODE_SV39X4:
+	case 3:
 		str = "Sv39x4";
 		break;
-	case HGATP_MODE_SV48X4:
+	case 4:
 		str = "Sv48x4";
 		break;
-	case HGATP_MODE_SV57X4:
+	case 5:
 		str = "Sv57x4";
 		break;
 	default:
@@ -164,7 +164,7 @@ static int __init riscv_kvm_init(void)
 			 (rc) ? slist : "no features");
 	}
 
-	kvm_info("using %s G-stage page table format\n", str);
+	kvm_info("Max G-stage page table format %s\n", str);
 
 	kvm_info("VMID %ld bits available\n", kvm_riscv_gstage_vmid_bits());
 
arch/riscv/kvm/mmu.c +12 -8
index 4ab06697bfc0..458a2ed98818 100644
@@ -67,7 +67,7 @@ int kvm_riscv_mmu_ioremap(struct kvm *kvm, gpa_t gpa, phys_addr_t hpa,
 		if (!writable)
 			map.pte = pte_wrprotect(map.pte);
 
-		ret = kvm_mmu_topup_memory_cache(&pcache, kvm_riscv_gstage_pgd_levels);
+		ret = kvm_mmu_topup_memory_cache(&pcache, kvm->arch.kvm_riscv_gstage_pgd_levels);
 		if (ret)
 			goto out;
 
@@ -186,7 +186,7 @@ int kvm_arch_prepare_memory_region(struct kvm *kvm,
 	 * space addressable by the KVM guest GPA space.
 	 */
 	if ((new->base_gfn + new->npages) >=
-	    (kvm_riscv_gstage_gpa_size >> PAGE_SHIFT))
+	     kvm_riscv_gstage_gpa_size(&kvm->arch) >> PAGE_SHIFT)
 		return -EFAULT;
 
 	hva = new->userspace_addr;
@@ -332,7 +332,7 @@ int kvm_riscv_mmu_map(struct kvm_vcpu *vcpu, struct kvm_memory_slot *memslot,
 	memset(out_map, 0, sizeof(*out_map));
 
 	/* We need minimum second+third level pages */
-	ret = kvm_mmu_topup_memory_cache(pcache, kvm_riscv_gstage_pgd_levels);
+	ret = kvm_mmu_topup_memory_cache(pcache, kvm->arch.kvm_riscv_gstage_pgd_levels);
 	if (ret) {
 		kvm_err("Failed to topup G-stage cache\n");
 		return ret;
@@ -431,6 +431,7 @@ int kvm_riscv_mmu_alloc_pgd(struct kvm *kvm)
 		return -ENOMEM;
 	kvm->arch.pgd = page_to_virt(pgd_page);
 	kvm->arch.pgd_phys = page_to_phys(pgd_page);
+	kvm->arch.kvm_riscv_gstage_pgd_levels = kvm_riscv_gstage_max_pgd_levels;
 
 	return 0;
 }
@@ -446,10 +447,12 @@ void kvm_riscv_mmu_free_pgd(struct kvm *kvm)
 		gstage.flags = 0;
 		gstage.vmid = READ_ONCE(kvm->arch.vmid.vmid);
 		gstage.pgd = kvm->arch.pgd;
-		kvm_riscv_gstage_unmap_range(&gstage, 0UL, kvm_riscv_gstage_gpa_size, false);
+		kvm_riscv_gstage_unmap_range(&gstage, 0UL,
+			kvm_riscv_gstage_gpa_size(&kvm->arch), false);
 		pgd = READ_ONCE(kvm->arch.pgd);
 		kvm->arch.pgd = NULL;
 		kvm->arch.pgd_phys = 0;
+		kvm->arch.kvm_riscv_gstage_pgd_levels = 0;
 	}
 	spin_unlock(&kvm->mmu_lock);
 
@@ -459,11 +462,12 @@ void kvm_riscv_mmu_free_pgd(struct kvm *kvm)
 
 void kvm_riscv_mmu_update_hgatp(struct kvm_vcpu *vcpu)
 {
-	unsigned long hgatp = kvm_riscv_gstage_mode << HGATP_MODE_SHIFT;
-	struct kvm_arch *k = &vcpu->kvm->arch;
+	struct kvm_arch *ka = &vcpu->kvm->arch;
+	unsigned long hgatp = kvm_riscv_gstage_mode(ka->kvm_riscv_gstage_pgd_levels)
+			      << HGATP_MODE_SHIFT;
 
-	hgatp |= (READ_ONCE(k->vmid.vmid) << HGATP_VMID_SHIFT) & HGATP_VMID;
-	hgatp |= (k->pgd_phys >> PAGE_SHIFT) & HGATP_PPN;
+	hgatp |= (READ_ONCE(ka->vmid.vmid) << HGATP_VMID_SHIFT) & HGATP_VMID;
+	hgatp |= (ka->pgd_phys >> PAGE_SHIFT) & HGATP_PPN;
 
 	ncsr_write(CSR_HGATP, hgatp);
 
arch/riscv/kvm/vm.c +1 -1
index 66d91ae6e9b2..4b2156df40fc 100644
@@ -200,7 +200,7 @@ int kvm_vm_ioctl_check_extension(struct kvm *kvm, long ext)
 		r = KVM_USER_MEM_SLOTS;
 		break;
 	case KVM_CAP_VM_GPA_BITS:
-		r = kvm_riscv_gstage_gpa_bits;
+		r = kvm_riscv_gstage_gpa_bits(&kvm->arch);
 		break;
 	default:
 		r = 0;
arch/riscv/kvm/vmid.c +2 -1
index cf34d448289d..c15bdb1dd8be 100644
@@ -26,7 +26,8 @@ static DEFINE_SPINLOCK(vmid_lock);
 void __init kvm_riscv_gstage_vmid_detect(void)
 {
 	/* Figure-out number of VMID bits in HW */
-	csr_write(CSR_HGATP, (kvm_riscv_gstage_mode << HGATP_MODE_SHIFT) | HGATP_VMID);
+	csr_write(CSR_HGATP, (kvm_riscv_gstage_mode(kvm_riscv_gstage_max_pgd_levels) <<
+			      HGATP_MODE_SHIFT) | HGATP_VMID);
 	vmid_bits = csr_read(CSR_HGATP);
 	vmid_bits = (vmid_bits & HGATP_VMID) >> HGATP_VMID_SHIFT;
 	vmid_bits = fls_long(vmid_bits);
Signature · 1 line
2.50.1
maintainer
#2 lore raw

Re: [PATCH v5 1/3] RISC-V: KVM: Support runtime configuration for per-VM's HGATP mode

Quoted 37 lines · On Wed, Feb 4, 2026 at 7:16 PM <[email protected]> wrote:

From: Fangyu Yu <[email protected]>

Introduces one per-VM architecture-specific fields to support runtime configuration of the G-stage page table format:

- kvm->arch.kvm_riscv_gstage_pgd_levels: the corresponding number of page table levels for the selected mode.

These fields replace the previous global variables kvm_riscv_gstage_mode and kvm_riscv_gstage_pgd_levels, enabling different virtual machines to independently select their G-stage page table format instead of being forced to share the maximum mode detected by the kernel at boot time.

---
 arch/riscv/include/asm/kvm_gstage.h | 20 +++++----
 arch/riscv/include/asm/kvm_host.h   | 19 +++++++++
 arch/riscv/kvm/gstage.c             | 65 ++++++++++++++---------------
 arch/riscv/kvm/main.c               | 12 +++---
 arch/riscv/kvm/mmu.c                | 20 +++++----
 arch/riscv/kvm/vm.c                 |  2 +-
 arch/riscv/kvm/vmid.c               |  3 +-
 7 files changed, 84 insertions(+), 57 deletions(-)
arch/riscv/include/asm/kvm_gstage.h +1 -2
index 595e2183173e..b12605fbca44 100644
@@ -29,16 +29,22 @@ struct kvm_gstage_mapping {
 #define kvm_riscv_gstage_index_bits    10
 #endif
 
-extern unsigned long kvm_riscv_gstage_mode;
-extern unsigned long kvm_riscv_gstage_pgd_levels;
+extern unsigned long kvm_riscv_gstage_max_pgd_levels;

arch/riscv/include/asm/kvm_gstage.h struct kvm_gstage_mapping { · line 37

Quoted 10 lines
arch/riscv/include/asm/kvm_gstage.h +2 -5
 
 #define kvm_riscv_gstage_pgd_xbits     2
 #define kvm_riscv_gstage_pgd_size      (1UL << (HGATP_PAGE_SHIFT + kvm_riscv_gstage_pgd_xbits))
-#define kvm_riscv_gstage_gpa_bits      (HGATP_PAGE_SHIFT + \
-                                        (kvm_riscv_gstage_pgd_levels * \
-                                         kvm_riscv_gstage_index_bits) + \
-                                        kvm_riscv_gstage_pgd_xbits)
-#define kvm_riscv_gstage_gpa_size      ((gpa_t)(1ULL << kvm_riscv_gstage_gpa_bits))
+
+static inline unsigned long kvm_riscv_gstage_gpa_bits(struct kvm_arch *ka)

Use "unsigned long pgd_levels" as parameter here.

arch/riscv/include/asm/kvm_gstage.h struct kvm_gstage_mapping { · line 44

Quoted 7 lines
arch/riscv/include/asm/kvm_gstage.h +7 -0
+{
+       return (HGATP_PAGE_SHIFT +
+               ka->kvm_riscv_gstage_pgd_levels * kvm_riscv_gstage_index_bits +
+               kvm_riscv_gstage_pgd_xbits);
+}
+
+static inline gpa_t kvm_riscv_gstage_gpa_size(struct kvm_arch *ka)

Same comment as above.

Quoted 21 lines
arch/riscv/include/asm/kvm_gstage.h +3 -0
+{
+       return BIT_ULL(kvm_riscv_gstage_gpa_bits(ka));
+}
 
 bool kvm_riscv_gstage_get_leaf(struct kvm_gstage *gstage, gpa_t addr,
                               pte_t **ptepp, u32 *ptep_level);
arch/riscv/include/asm/kvm_host.h +7 -0
index 24585304c02b..0ace5e98c133 100644
@@ -87,6 +87,23 @@ struct kvm_vcpu_stat {
 struct kvm_arch_memory_slot {
 };
 
+static inline unsigned long kvm_riscv_gstage_mode(unsigned long pgd_levels)
+{
+       switch (pgd_levels) {
+       case 2:
+               return HGATP_MODE_SV32X4;
+       case 3:
+               return HGATP_MODE_SV39X4;

arch/riscv/include/asm/kvm_host.h struct kvm_vcpu_stat { · line 106

Quoted 10 lines
arch/riscv/include/asm/kvm_host.h +10 -0
+       case 4:
+               return HGATP_MODE_SV48X4;
+       case 5:
+               return HGATP_MODE_SV57X4;
+       default:
+               WARN_ON_ONCE(1);
+               return HGATP_MODE_OFF;
+       }
+}
+

Move this function to kvm_gstage.h

arch/riscv/include/asm/kvm_host.h struct kvm_arch { · line 124

Quoted 9 lines
arch/riscv/include/asm/kvm_host.h +2 -0
 struct kvm_arch {
        /* G-stage vmid */
        struct kvm_vmid vmid;
@@ -103,6 +120,8 @@ struct kvm_arch {
 
        /* KVM_CAP_RISCV_MP_STATE_RESET */
        bool mp_state_reset;
+
+       unsigned long kvm_riscv_gstage_pgd_levels;

s/kvm_riscv_gstage_pgd_levels/pgd_levels/

Also define it right after pgd_phys.

Quoted 22 lines
arch/riscv/include/asm/kvm_host.h +0 -0
 };
 
 struct kvm_cpu_trap {
arch/riscv/kvm/gstage.c +2 -4
index b67d60d722c2..2d0045f502d1 100644
@@ -12,22 +12,21 @@
 #include <asm/kvm_gstage.h>
 
 #ifdef CONFIG_64BIT
-unsigned long kvm_riscv_gstage_mode __ro_after_init = HGATP_MODE_SV39X4;
-unsigned long kvm_riscv_gstage_pgd_levels __ro_after_init = 3;
+unsigned long kvm_riscv_gstage_max_pgd_levels __ro_after_init = 3;
 #else
-unsigned long kvm_riscv_gstage_mode __ro_after_init = HGATP_MODE_SV32X4;
-unsigned long kvm_riscv_gstage_pgd_levels __ro_after_init = 2;
+unsigned long kvm_riscv_gstage_max_pgd_levels __ro_after_init = 2;
 #endif
 
 #define gstage_pte_leaf(__ptep)        \
        (pte_val(*(__ptep)) & (_PAGE_READ | _PAGE_WRITE | _PAGE_EXEC))

arch/riscv/kvm/gstage.c line 29

Quoted 10 lines
arch/riscv/kvm/gstage.c +3 -2
 
-static inline unsigned long gstage_pte_index(gpa_t addr, u32 level)
+static inline unsigned long gstage_pte_index(struct kvm_gstage *gstage,
+                                            gpa_t addr, u32 level)
 {
        unsigned long mask;
        unsigned long shift = HGATP_PAGE_SHIFT + (kvm_riscv_gstage_index_bits * level);
 
-       if (level == (kvm_riscv_gstage_pgd_levels - 1))
+       if (level == gstage->kvm->arch.kvm_riscv_gstage_pgd_levels - 1)

This pointer chasing over here and every below is inefficient. It is better to add "pgd_levels" in "struct kvm_gstage" which is set with value from "pgd_levels" in "struct kvm_arch".

Quoted 218 lines
arch/riscv/kvm/gstage.c +26 -28
                mask = (PTRS_PER_PTE * (1UL << kvm_riscv_gstage_pgd_xbits)) - 1;
        else
                mask = PTRS_PER_PTE - 1;
@@ -40,12 +39,13 @@ static inline unsigned long gstage_pte_page_vaddr(pte_t pte)
        return (unsigned long)pfn_to_virt(__page_val_to_pfn(pte_val(pte)));
 }
 
-static int gstage_page_size_to_level(unsigned long page_size, u32 *out_level)
+static int gstage_page_size_to_level(struct kvm_gstage *gstage, unsigned long page_size,
+                                    u32 *out_level)
 {
        u32 i;
        unsigned long psz = 1UL << 12;
 
-       for (i = 0; i < kvm_riscv_gstage_pgd_levels; i++) {
+       for (i = 0; i < gstage->kvm->arch.kvm_riscv_gstage_pgd_levels; i++) {
                if (page_size == (psz << (i * kvm_riscv_gstage_index_bits))) {
                        *out_level = i;
                        return 0;
@@ -55,21 +55,23 @@ static int gstage_page_size_to_level(unsigned long page_size, u32 *out_level)
        return -EINVAL;
 }
 
-static int gstage_level_to_page_order(u32 level, unsigned long *out_pgorder)
+static int gstage_level_to_page_order(struct kvm_gstage *gstage, u32 level,
+                                     unsigned long *out_pgorder)
 {
-       if (kvm_riscv_gstage_pgd_levels < level)
+       if (gstage->kvm->arch.kvm_riscv_gstage_pgd_levels < level)
                return -EINVAL;
 
        *out_pgorder = 12 + (level * kvm_riscv_gstage_index_bits);
        return 0;
 }
 
-static int gstage_level_to_page_size(u32 level, unsigned long *out_pgsize)
+static int gstage_level_to_page_size(struct kvm_gstage *gstage, u32 level,
+                                    unsigned long *out_pgsize)
 {
        int rc;
        unsigned long page_order = PAGE_SHIFT;
 
-       rc = gstage_level_to_page_order(level, &page_order);
+       rc = gstage_level_to_page_order(gstage, level, &page_order);
        if (rc)
                return rc;
 
@@ -81,11 +83,11 @@ bool kvm_riscv_gstage_get_leaf(struct kvm_gstage *gstage, gpa_t addr,
                               pte_t **ptepp, u32 *ptep_level)
 {
        pte_t *ptep;
-       u32 current_level = kvm_riscv_gstage_pgd_levels - 1;
+       u32 current_level = gstage->kvm->arch.kvm_riscv_gstage_pgd_levels - 1;
 
        *ptep_level = current_level;
        ptep = (pte_t *)gstage->pgd;
-       ptep = &ptep[gstage_pte_index(addr, current_level)];
+       ptep = &ptep[gstage_pte_index(gstage, addr, current_level)];
        while (ptep && pte_val(ptep_get(ptep))) {
                if (gstage_pte_leaf(ptep)) {
                        *ptep_level = current_level;
@@ -97,7 +99,7 @@ bool kvm_riscv_gstage_get_leaf(struct kvm_gstage *gstage, gpa_t addr,
                        current_level--;
                        *ptep_level = current_level;
                        ptep = (pte_t *)gstage_pte_page_vaddr(ptep_get(ptep));
-                       ptep = &ptep[gstage_pte_index(addr, current_level)];
+                       ptep = &ptep[gstage_pte_index(gstage, addr, current_level)];
                } else {
                        ptep = NULL;
                }
@@ -110,7 +112,7 @@ static void gstage_tlb_flush(struct kvm_gstage *gstage, u32 level, gpa_t addr)
 {
        unsigned long order = PAGE_SHIFT;
 
-       if (gstage_level_to_page_order(level, &order))
+       if (gstage_level_to_page_order(gstage, level, &order))
                return;
        addr &= ~(BIT(order) - 1);
 
@@ -125,9 +127,9 @@ int kvm_riscv_gstage_set_pte(struct kvm_gstage *gstage,
                             struct kvm_mmu_memory_cache *pcache,
                             const struct kvm_gstage_mapping *map)
 {
-       u32 current_level = kvm_riscv_gstage_pgd_levels - 1;
+       u32 current_level = gstage->kvm->arch.kvm_riscv_gstage_pgd_levels - 1;
        pte_t *next_ptep = (pte_t *)gstage->pgd;
-       pte_t *ptep = &next_ptep[gstage_pte_index(map->addr, current_level)];
+       pte_t *ptep = &next_ptep[gstage_pte_index(gstage, map->addr, current_level)];
 
        if (current_level < map->level)
                return -EINVAL;
@@ -151,7 +153,7 @@ int kvm_riscv_gstage_set_pte(struct kvm_gstage *gstage,
                }
 
                current_level--;
-               ptep = &next_ptep[gstage_pte_index(map->addr, current_level)];
+               ptep = &next_ptep[gstage_pte_index(gstage, map->addr, current_level)];
        }
 
        if (pte_val(*ptep) != pte_val(map->pte)) {
@@ -175,7 +177,7 @@ int kvm_riscv_gstage_map_page(struct kvm_gstage *gstage,
        out_map->addr = gpa;
        out_map->level = 0;
 
-       ret = gstage_page_size_to_level(page_size, &out_map->level);
+       ret = gstage_page_size_to_level(gstage, page_size, &out_map->level);
        if (ret)
                return ret;
 
@@ -217,7 +219,7 @@ void kvm_riscv_gstage_op_pte(struct kvm_gstage *gstage, gpa_t addr,
        u32 next_ptep_level;
        unsigned long next_page_size, page_size;
 
-       ret = gstage_level_to_page_size(ptep_level, &page_size);
+       ret = gstage_level_to_page_size(gstage, ptep_level, &page_size);
        if (ret)
                return;
 
@@ -229,7 +231,7 @@ void kvm_riscv_gstage_op_pte(struct kvm_gstage *gstage, gpa_t addr,
        if (ptep_level && !gstage_pte_leaf(ptep)) {
                next_ptep = (pte_t *)gstage_pte_page_vaddr(ptep_get(ptep));
                next_ptep_level = ptep_level - 1;
-               ret = gstage_level_to_page_size(next_ptep_level, &next_page_size);
+               ret = gstage_level_to_page_size(gstage, next_ptep_level, &next_page_size);
                if (ret)
                        return;
 
@@ -263,7 +265,7 @@ void kvm_riscv_gstage_unmap_range(struct kvm_gstage *gstage,
 
        while (addr < end) {
                found_leaf = kvm_riscv_gstage_get_leaf(gstage, addr, &ptep, &ptep_level);
-               ret = gstage_level_to_page_size(ptep_level, &page_size);
+               ret = gstage_level_to_page_size(gstage, ptep_level, &page_size);
                if (ret)
                        break;
 
@@ -297,7 +299,7 @@ void kvm_riscv_gstage_wp_range(struct kvm_gstage *gstage, gpa_t start, gpa_t end
 
        while (addr < end) {
                found_leaf = kvm_riscv_gstage_get_leaf(gstage, addr, &ptep, &ptep_level);
-               ret = gstage_level_to_page_size(ptep_level, &page_size);
+               ret = gstage_level_to_page_size(gstage, ptep_level, &page_size);
                if (ret)
                        break;
 
@@ -319,39 +321,34 @@ void __init kvm_riscv_gstage_mode_detect(void)
        /* Try Sv57x4 G-stage mode */
        csr_write(CSR_HGATP, HGATP_MODE_SV57X4 << HGATP_MODE_SHIFT);
        if ((csr_read(CSR_HGATP) >> HGATP_MODE_SHIFT) == HGATP_MODE_SV57X4) {
-               kvm_riscv_gstage_mode = HGATP_MODE_SV57X4;
-               kvm_riscv_gstage_pgd_levels = 5;
+               kvm_riscv_gstage_max_pgd_levels = 5;
                goto done;
        }
 
        /* Try Sv48x4 G-stage mode */
        csr_write(CSR_HGATP, HGATP_MODE_SV48X4 << HGATP_MODE_SHIFT);
        if ((csr_read(CSR_HGATP) >> HGATP_MODE_SHIFT) == HGATP_MODE_SV48X4) {
-               kvm_riscv_gstage_mode = HGATP_MODE_SV48X4;
-               kvm_riscv_gstage_pgd_levels = 4;
+               kvm_riscv_gstage_max_pgd_levels = 4;
                goto done;
        }
 
        /* Try Sv39x4 G-stage mode */
        csr_write(CSR_HGATP, HGATP_MODE_SV39X4 << HGATP_MODE_SHIFT);
        if ((csr_read(CSR_HGATP) >> HGATP_MODE_SHIFT) == HGATP_MODE_SV39X4) {
-               kvm_riscv_gstage_mode = HGATP_MODE_SV39X4;
-               kvm_riscv_gstage_pgd_levels = 3;
+               kvm_riscv_gstage_max_pgd_levels = 3;
                goto done;
        }
 #else /* CONFIG_32BIT */
        /* Try Sv32x4 G-stage mode */
        csr_write(CSR_HGATP, HGATP_MODE_SV32X4 << HGATP_MODE_SHIFT);
        if ((csr_read(CSR_HGATP) >> HGATP_MODE_SHIFT) == HGATP_MODE_SV32X4) {
-               kvm_riscv_gstage_mode = HGATP_MODE_SV32X4;
-               kvm_riscv_gstage_pgd_levels = 2;
+               kvm_riscv_gstage_max_pgd_levels = 2;
                goto done;
        }
 #endif
 
        /* KVM depends on !HGATP_MODE_OFF */
-       kvm_riscv_gstage_mode = HGATP_MODE_OFF;
-       kvm_riscv_gstage_pgd_levels = 0;
+       kvm_riscv_gstage_max_pgd_levels = 0;
 
 done:
        csr_write(CSR_HGATP, 0);
arch/riscv/kvm/main.c +5 -5
index 45536af521f0..786c0025e2c3 100644
@@ -105,17 +105,17 @@ static int __init riscv_kvm_init(void)
                return rc;
 
        kvm_riscv_gstage_mode_detect();
-       switch (kvm_riscv_gstage_mode) {
-       case HGATP_MODE_SV32X4:
+       switch (kvm_riscv_gstage_max_pgd_levels) {
+       case 2:
                str = "Sv32x4";
                break;
-       case HGATP_MODE_SV39X4:
+       case 3:
                str = "Sv39x4";
                break;
-       case HGATP_MODE_SV48X4:
+       case 4:
                str = "Sv48x4";
                break;
-       case HGATP_MODE_SV57X4:
+       case 5:
                str = "Sv57x4";
                break;
        default:

arch/riscv/kvm/main.c static int __init riscv_kvm_init(void) · line 167

Quoted 5 lines
arch/riscv/kvm/main.c +1 -1
@@ -164,7 +164,7 @@ static int __init riscv_kvm_init(void)
                         (rc) ? slist : "no features");
        }
 
-       kvm_info("using %s G-stage page table format\n", str);
+       kvm_info("Max G-stage page table format %s\n", str);

s/Max G-stage page table format/highest G-stage page table mode is/

Quoted 101 lines
arch/riscv/kvm/main.c +0 -0
        kvm_info("VMID %ld bits available\n", kvm_riscv_gstage_vmid_bits());
 
arch/riscv/kvm/mmu.c +12 -8
index 4ab06697bfc0..458a2ed98818 100644
@@ -67,7 +67,7 @@ int kvm_riscv_mmu_ioremap(struct kvm *kvm, gpa_t gpa, phys_addr_t hpa,
                if (!writable)
                        map.pte = pte_wrprotect(map.pte);
 
-               ret = kvm_mmu_topup_memory_cache(&pcache, kvm_riscv_gstage_pgd_levels);
+               ret = kvm_mmu_topup_memory_cache(&pcache, kvm->arch.kvm_riscv_gstage_pgd_levels);
                if (ret)
                        goto out;
 
@@ -186,7 +186,7 @@ int kvm_arch_prepare_memory_region(struct kvm *kvm,
         * space addressable by the KVM guest GPA space.
         */
        if ((new->base_gfn + new->npages) >=
-           (kvm_riscv_gstage_gpa_size >> PAGE_SHIFT))
+            kvm_riscv_gstage_gpa_size(&kvm->arch) >> PAGE_SHIFT)
                return -EFAULT;
 
        hva = new->userspace_addr;
@@ -332,7 +332,7 @@ int kvm_riscv_mmu_map(struct kvm_vcpu *vcpu, struct kvm_memory_slot *memslot,
        memset(out_map, 0, sizeof(*out_map));
 
        /* We need minimum second+third level pages */
-       ret = kvm_mmu_topup_memory_cache(pcache, kvm_riscv_gstage_pgd_levels);
+       ret = kvm_mmu_topup_memory_cache(pcache, kvm->arch.kvm_riscv_gstage_pgd_levels);
        if (ret) {
                kvm_err("Failed to topup G-stage cache\n");
                return ret;
@@ -431,6 +431,7 @@ int kvm_riscv_mmu_alloc_pgd(struct kvm *kvm)
                return -ENOMEM;
        kvm->arch.pgd = page_to_virt(pgd_page);
        kvm->arch.pgd_phys = page_to_phys(pgd_page);
+       kvm->arch.kvm_riscv_gstage_pgd_levels = kvm_riscv_gstage_max_pgd_levels;
 
        return 0;
 }
@@ -446,10 +447,12 @@ void kvm_riscv_mmu_free_pgd(struct kvm *kvm)
                gstage.flags = 0;
                gstage.vmid = READ_ONCE(kvm->arch.vmid.vmid);
                gstage.pgd = kvm->arch.pgd;
-               kvm_riscv_gstage_unmap_range(&gstage, 0UL, kvm_riscv_gstage_gpa_size, false);
+               kvm_riscv_gstage_unmap_range(&gstage, 0UL,
+                       kvm_riscv_gstage_gpa_size(&kvm->arch), false);
                pgd = READ_ONCE(kvm->arch.pgd);
                kvm->arch.pgd = NULL;
                kvm->arch.pgd_phys = 0;
+               kvm->arch.kvm_riscv_gstage_pgd_levels = 0;
        }
        spin_unlock(&kvm->mmu_lock);
 
@@ -459,11 +462,12 @@ void kvm_riscv_mmu_free_pgd(struct kvm *kvm)
 
 void kvm_riscv_mmu_update_hgatp(struct kvm_vcpu *vcpu)
 {
-       unsigned long hgatp = kvm_riscv_gstage_mode << HGATP_MODE_SHIFT;
-       struct kvm_arch *k = &vcpu->kvm->arch;
+       struct kvm_arch *ka = &vcpu->kvm->arch;
+       unsigned long hgatp = kvm_riscv_gstage_mode(ka->kvm_riscv_gstage_pgd_levels)
+                             << HGATP_MODE_SHIFT;
 
-       hgatp |= (READ_ONCE(k->vmid.vmid) << HGATP_VMID_SHIFT) & HGATP_VMID;
-       hgatp |= (k->pgd_phys >> PAGE_SHIFT) & HGATP_PPN;
+       hgatp |= (READ_ONCE(ka->vmid.vmid) << HGATP_VMID_SHIFT) & HGATP_VMID;
+       hgatp |= (ka->pgd_phys >> PAGE_SHIFT) & HGATP_PPN;
 
        ncsr_write(CSR_HGATP, hgatp);
 
arch/riscv/kvm/vm.c +1 -1
index 66d91ae6e9b2..4b2156df40fc 100644
@@ -200,7 +200,7 @@ int kvm_vm_ioctl_check_extension(struct kvm *kvm, long ext)
                r = KVM_USER_MEM_SLOTS;
                break;
        case KVM_CAP_VM_GPA_BITS:
-               r = kvm_riscv_gstage_gpa_bits;
+               r = kvm_riscv_gstage_gpa_bits(&kvm->arch);
                break;
        default:
                r = 0;
arch/riscv/kvm/vmid.c +2 -2
index cf34d448289d..c15bdb1dd8be 100644
@@ -26,7 +26,8 @@ static DEFINE_SPINLOCK(vmid_lock);
 void __init kvm_riscv_gstage_vmid_detect(void)
 {
        /* Figure-out number of VMID bits in HW */
-       csr_write(CSR_HGATP, (kvm_riscv_gstage_mode << HGATP_MODE_SHIFT) | HGATP_VMID);
+       csr_write(CSR_HGATP, (kvm_riscv_gstage_mode(kvm_riscv_gstage_max_pgd_levels) <<
+                             HGATP_MODE_SHIFT) | HGATP_VMID);
        vmid_bits = csr_read(CSR_HGATP);
        vmid_bits = (vmid_bits & HGATP_VMID) >> HGATP_VMID_SHIFT;
        vmid_bits = fls_long(vmid_bits);
--
Quoted 3 lines

2.50.1

Regards,
Anup

#3 lore raw

Re: Re: [PATCH v5 1/3] RISC-V: KVM: Support runtime configuration for per-VM's HGATP mode

Quoted 13 lines
Quoted 13 lines
arch/riscv/kvm/vmid.c +2 -1
index cf34d448289d..c15bdb1dd8be 100644
@@ -26,7 +26,8 @@ static DEFINE_SPINLOCK(vmid_lock);
 void __init kvm_riscv_gstage_vmid_detect(void)
 {
        /* Figure-out number of VMID bits in HW */
-       csr_write(CSR_HGATP, (kvm_riscv_gstage_mode << HGATP_MODE_SHIFT) | HGATP_VMID);
+       csr_write(CSR_HGATP, (kvm_riscv_gstage_mode(kvm_riscv_gstage_max_pgd_levels) <<
+                             HGATP_MODE_SHIFT) | HGATP_VMID);
        vmid_bits = csr_read(CSR_HGATP);
        vmid_bits = (vmid_bits & HGATP_VMID) >> HGATP_VMID_SHIFT;
Quoted 8 lines
Quoted 5 lines
arch/riscv/kvm/vmid.c +0 -1
        vmid_bits = fls_long(vmid_bits);
--

2.50.1

Regards,
Anup

Hi Anup:

Thanks for the review.

I'll incorporate all of the above changes and post an updated version (v6) shortly.

Thanks,
Fangyu

#4 lore raw

PATCH v5 2/3 RISC-V: KVM: Detect and expose supported HGATP G-stage modes

In reply to [email protected]

From: Fangyu Yu <[email protected]>

Extend kvm_riscv_gstage_mode_detect() to probe all HGATP.MODE values supported by the host and record them in a bitmask. Keep tracking the maximum supported G-stage page table level for existing internal users.

Also provide lightweight helpers to retrieve the supported-mode bitmask and validate a requested HGATP.MODE against it.

---
 arch/riscv/include/asm/kvm_gstage.h | 11 ++++++++
 arch/riscv/kvm/gstage.c             | 43 +++++++++++++++--------------
 2 files changed, 34 insertions(+), 20 deletions(-)
arch/riscv/include/asm/kvm_gstage.h +11 -0
index b12605fbca44..76c37b5dc02d 100644
@@ -30,6 +30,7 @@ struct kvm_gstage_mapping {
 #endif
 
 extern unsigned long kvm_riscv_gstage_max_pgd_levels;
+extern u32 kvm_riscv_gstage_mode_mask;
 
 #define kvm_riscv_gstage_pgd_xbits	2
 #define kvm_riscv_gstage_pgd_size	(1UL << (HGATP_PAGE_SHIFT + kvm_riscv_gstage_pgd_xbits))
@@ -75,4 +76,14 @@ void kvm_riscv_gstage_wp_range(struct kvm_gstage *gstage, gpa_t start, gpa_t end
 
 void kvm_riscv_gstage_mode_detect(void);
 
+static inline u32 kvm_riscv_get_hgatp_mode_mask(void)
+{
+	return kvm_riscv_gstage_mode_mask;
+}
+
+static inline bool kvm_riscv_hgatp_mode_is_valid(unsigned long mode)
+{
+	return kvm_riscv_gstage_mode_mask & BIT(mode);
+}
+
 #endif
arch/riscv/kvm/gstage.c +23 -20

71 lines not on this page · raw message

Signature · 1 line
2.50.1
maintainer
#5 lore raw

Re: [PATCH v5 2/3] RISC-V: KVM: Detect and expose supported HGATP G-stage modes

Quoted 21 lines · On Wed, Feb 4, 2026 at 7:15 PM <[email protected]> wrote:

From: Fangyu Yu <[email protected]>

Extend kvm_riscv_gstage_mode_detect() to probe all HGATP.MODE values supported by the host and record them in a bitmask. Keep tracking the maximum supported G-stage page table level for existing internal users.

Also provide lightweight helpers to retrieve the supported-mode bitmask and validate a requested HGATP.MODE against it.

---
 arch/riscv/include/asm/kvm_gstage.h | 11 ++++++++
 arch/riscv/kvm/gstage.c             | 43 +++++++++++++++--------------
 2 files changed, 34 insertions(+), 20 deletions(-)
arch/riscv/include/asm/kvm_gstage.h +0 -0
index b12605fbca44..76c37b5dc02d 100644

arch/riscv/include/asm/kvm_gstage.h struct kvm_gstage_mapping { · line 33

Quoted 4 lines
arch/riscv/include/asm/kvm_gstage.h +1 -0
@@ -30,6 +30,7 @@ struct kvm_gstage_mapping {
 #endif
 
 extern unsigned long kvm_riscv_gstage_max_pgd_levels;
+extern u32 kvm_riscv_gstage_mode_mask;

s/u32/unsigned long/ s/kvm_riscv_gstage_mode_mask/kvm_riscv_gstage_supported_mode_mask/

Quoted 82 lines
arch/riscv/include/asm/kvm_gstage.h +10 -0
 #define kvm_riscv_gstage_pgd_xbits     2
 #define kvm_riscv_gstage_pgd_size      (1UL << (HGATP_PAGE_SHIFT + kvm_riscv_gstage_pgd_xbits))
@@ -75,4 +76,14 @@ void kvm_riscv_gstage_wp_range(struct kvm_gstage *gstage, gpa_t start, gpa_t end
 
 void kvm_riscv_gstage_mode_detect(void);
 
+static inline u32 kvm_riscv_get_hgatp_mode_mask(void)
+{
+       return kvm_riscv_gstage_mode_mask;
+}
+
+static inline bool kvm_riscv_hgatp_mode_is_valid(unsigned long mode)
+{
+       return kvm_riscv_gstage_mode_mask & BIT(mode);
+}
+
 #endif
arch/riscv/kvm/gstage.c +22 -15
index 2d0045f502d1..328d4138f162 100644
@@ -16,6 +16,8 @@ unsigned long kvm_riscv_gstage_max_pgd_levels __ro_after_init = 3;
 #else
 unsigned long kvm_riscv_gstage_max_pgd_levels __ro_after_init = 2;
 #endif
+/* Bitmask of supported HGATP.MODE encodings (BIT(HGATP_MODE_*)). */
+u32 kvm_riscv_gstage_mode_mask __ro_after_init;
 
 #define gstage_pte_leaf(__ptep)        \
        (pte_val(*(__ptep)) & (_PAGE_READ | _PAGE_WRITE | _PAGE_EXEC))
@@ -315,42 +317,43 @@ void kvm_riscv_gstage_wp_range(struct kvm_gstage *gstage, gpa_t start, gpa_t end
        }
 }
 
+static bool __init kvm_riscv_hgatp_mode_supported(unsigned long mode)
+{
+       csr_write(CSR_HGATP, mode << HGATP_MODE_SHIFT);
+       return ((csr_read(CSR_HGATP) >> HGATP_MODE_SHIFT) == mode);
+}
+
 void __init kvm_riscv_gstage_mode_detect(void)
 {
+       kvm_riscv_gstage_mode_mask = 0;
+       kvm_riscv_gstage_max_pgd_levels = 0;
+
 #ifdef CONFIG_64BIT
-       /* Try Sv57x4 G-stage mode */
-       csr_write(CSR_HGATP, HGATP_MODE_SV57X4 << HGATP_MODE_SHIFT);
-       if ((csr_read(CSR_HGATP) >> HGATP_MODE_SHIFT) == HGATP_MODE_SV57X4) {
-               kvm_riscv_gstage_max_pgd_levels = 5;
-               goto done;
+       /* Try Sv39x4 G-stage mode */
+       if (kvm_riscv_hgatp_mode_supported(HGATP_MODE_SV39X4)) {
+               kvm_riscv_gstage_mode_mask |= BIT(HGATP_MODE_SV39X4);
+               kvm_riscv_gstage_max_pgd_levels = 3;
        }
 
        /* Try Sv48x4 G-stage mode */
-       csr_write(CSR_HGATP, HGATP_MODE_SV48X4 << HGATP_MODE_SHIFT);
-       if ((csr_read(CSR_HGATP) >> HGATP_MODE_SHIFT) == HGATP_MODE_SV48X4) {
+       if (kvm_riscv_hgatp_mode_supported(HGATP_MODE_SV48X4)) {
+               kvm_riscv_gstage_mode_mask |= BIT(HGATP_MODE_SV48X4);
                kvm_riscv_gstage_max_pgd_levels = 4;
-               goto done;
        }
 
-       /* Try Sv39x4 G-stage mode */
-       csr_write(CSR_HGATP, HGATP_MODE_SV39X4 << HGATP_MODE_SHIFT);
-       if ((csr_read(CSR_HGATP) >> HGATP_MODE_SHIFT) == HGATP_MODE_SV39X4) {
-               kvm_riscv_gstage_max_pgd_levels = 3;
-               goto done;
+       /* Try Sv57x4 G-stage mode */
+       if (kvm_riscv_hgatp_mode_supported(HGATP_MODE_SV57X4)) {
+               kvm_riscv_gstage_mode_mask |= BIT(HGATP_MODE_SV57X4);
+               kvm_riscv_gstage_max_pgd_levels = 5;
        }
 #else /* CONFIG_32BIT */
        /* Try Sv32x4 G-stage mode */
-       csr_write(CSR_HGATP, HGATP_MODE_SV32X4 << HGATP_MODE_SHIFT);
-       if ((csr_read(CSR_HGATP) >> HGATP_MODE_SHIFT) == HGATP_MODE_SV32X4) {
+       if (kvm_riscv_hgatp_mode_supported(HGATP_MODE_SV32X4)) {

arch/riscv/kvm/gstage.c void kvm_riscv_gstage_wp_range(struct kvm_gstage *gstage, gpa_t start, gpa_t end · line 353

Quoted 10 lines
arch/riscv/kvm/gstage.c +1 -5
+               kvm_riscv_gstage_mode_mask |= BIT(HGATP_MODE_SV32X4);
                kvm_riscv_gstage_max_pgd_levels = 2;
-               goto done;
        }
 #endif
 
-       /* KVM depends on !HGATP_MODE_OFF */
-       kvm_riscv_gstage_max_pgd_levels = 0;
-
-done:

Here are some statements from RISC-V privilege specification:
"Implementations that support Sv48 must also support Sv39." "Implementations that support Sv57 must also support Sv48." "The conversion of an Sv32x4, Sv39x4, Sv48x4, or Sv57x4 guest physical address is accomplished with the
same algorithm used for Sv32, Sv39, Sv48, or Sv57, as presented in Section 12.3.2, except that:"
"hgatp substitutes for the usual satp;"

Based on above it is a waste to try each and every mode.
For example: if mode Sv48x4 is supported then Sv39x4 is also supported.

Regards,
Anup

#6 lore raw

Re: Re: [PATCH v5 2/3] RISC-V: KVM: Detect and expose supported HGATP G-stage modes

Quoted 22 lines
Quoted 22 lines

From: Fangyu Yu <[email protected]>

Extend kvm_riscv_gstage_mode_detect() to probe all HGATP.MODE values supported by the host and record them in a bitmask. Keep tracking the maximum supported G-stage page table level for existing internal users.

Also provide lightweight helpers to retrieve the supported-mode bitmask and validate a requested HGATP.MODE against it.

---
 arch/riscv/include/asm/kvm_gstage.h | 11 ++++++++
 arch/riscv/kvm/gstage.c             | 43 +++++++++++++++--------------
 2 files changed, 34 insertions(+), 20 deletions(-)
arch/riscv/include/asm/kvm_gstage.h +0 -0
index b12605fbca44..76c37b5dc02d 100644
@@ -30,6 +30,7 @@ struct kvm_gstage_mapping {
 #endif
 
Quoted 6 lines

arch/riscv/include/asm/kvm_gstage.h struct kvm_gstage_mapping { · line 33

Quoted 2 lines
arch/riscv/include/asm/kvm_gstage.h +1 -0
 extern unsigned long kvm_riscv_gstage_max_pgd_levels;
+extern u32 kvm_riscv_gstage_mode_mask;

s/u32/unsigned long/ s/kvm_riscv_gstage_mode_mask/kvm_riscv_gstage_supported_mode_mask/

Ack, will switch the type to unsigned long and rename it to kvm_riscv_gstage_supported_mode_mask in the next revision.

Quoted 102 lines
Quoted 82 lines
arch/riscv/include/asm/kvm_gstage.h +10 -0
 #define kvm_riscv_gstage_pgd_xbits     2
 #define kvm_riscv_gstage_pgd_size      (1UL << (HGATP_PAGE_SHIFT + kvm_riscv_gstage_pgd_xbits))
@@ -75,4 +76,14 @@ void kvm_riscv_gstage_wp_range(struct kvm_gstage *gstage, gpa_t start, gpa_t end
 
 void kvm_riscv_gstage_mode_detect(void);
 
+static inline u32 kvm_riscv_get_hgatp_mode_mask(void)
+{
+       return kvm_riscv_gstage_mode_mask;
+}
+
+static inline bool kvm_riscv_hgatp_mode_is_valid(unsigned long mode)
+{
+       return kvm_riscv_gstage_mode_mask & BIT(mode);
+}
+
 #endif
arch/riscv/kvm/gstage.c +22 -15
index 2d0045f502d1..328d4138f162 100644
@@ -16,6 +16,8 @@ unsigned long kvm_riscv_gstage_max_pgd_levels __ro_after_init = 3;
 #else
 unsigned long kvm_riscv_gstage_max_pgd_levels __ro_after_init = 2;
 #endif
+/* Bitmask of supported HGATP.MODE encodings (BIT(HGATP_MODE_*)). */
+u32 kvm_riscv_gstage_mode_mask __ro_after_init;
 
 #define gstage_pte_leaf(__ptep)        \
        (pte_val(*(__ptep)) & (_PAGE_READ | _PAGE_WRITE | _PAGE_EXEC))
@@ -315,42 +317,43 @@ void kvm_riscv_gstage_wp_range(struct kvm_gstage *gstage, gpa_t start, gpa_t end
        }
 }
 
+static bool __init kvm_riscv_hgatp_mode_supported(unsigned long mode)
+{
+       csr_write(CSR_HGATP, mode << HGATP_MODE_SHIFT);
+       return ((csr_read(CSR_HGATP) >> HGATP_MODE_SHIFT) == mode);
+}
+
 void __init kvm_riscv_gstage_mode_detect(void)
 {
+       kvm_riscv_gstage_mode_mask = 0;
+       kvm_riscv_gstage_max_pgd_levels = 0;
+
 #ifdef CONFIG_64BIT
-       /* Try Sv57x4 G-stage mode */
-       csr_write(CSR_HGATP, HGATP_MODE_SV57X4 << HGATP_MODE_SHIFT);
-       if ((csr_read(CSR_HGATP) >> HGATP_MODE_SHIFT) == HGATP_MODE_SV57X4) {
-               kvm_riscv_gstage_max_pgd_levels = 5;
-               goto done;
+       /* Try Sv39x4 G-stage mode */
+       if (kvm_riscv_hgatp_mode_supported(HGATP_MODE_SV39X4)) {
+               kvm_riscv_gstage_mode_mask |= BIT(HGATP_MODE_SV39X4);
+               kvm_riscv_gstage_max_pgd_levels = 3;
        }
 
        /* Try Sv48x4 G-stage mode */
-       csr_write(CSR_HGATP, HGATP_MODE_SV48X4 << HGATP_MODE_SHIFT);
-       if ((csr_read(CSR_HGATP) >> HGATP_MODE_SHIFT) == HGATP_MODE_SV48X4) {
+       if (kvm_riscv_hgatp_mode_supported(HGATP_MODE_SV48X4)) {
+               kvm_riscv_gstage_mode_mask |= BIT(HGATP_MODE_SV48X4);
                kvm_riscv_gstage_max_pgd_levels = 4;
-               goto done;
        }
 
-       /* Try Sv39x4 G-stage mode */
-       csr_write(CSR_HGATP, HGATP_MODE_SV39X4 << HGATP_MODE_SHIFT);
-       if ((csr_read(CSR_HGATP) >> HGATP_MODE_SHIFT) == HGATP_MODE_SV39X4) {
-               kvm_riscv_gstage_max_pgd_levels = 3;
-               goto done;
+       /* Try Sv57x4 G-stage mode */
+       if (kvm_riscv_hgatp_mode_supported(HGATP_MODE_SV57X4)) {
+               kvm_riscv_gstage_mode_mask |= BIT(HGATP_MODE_SV57X4);
+               kvm_riscv_gstage_max_pgd_levels = 5;
        }
 #else /* CONFIG_32BIT */
        /* Try Sv32x4 G-stage mode */
-       csr_write(CSR_HGATP, HGATP_MODE_SV32X4 << HGATP_MODE_SHIFT);
-       if ((csr_read(CSR_HGATP) >> HGATP_MODE_SHIFT) == HGATP_MODE_SV32X4) {
+       if (kvm_riscv_hgatp_mode_supported(HGATP_MODE_SV32X4)) {

arch/riscv/kvm/gstage.c void kvm_riscv_gstage_wp_range(struct kvm_gstage *gstage, gpa_t start, gpa_t end · line 353

Quoted 10 lines
arch/riscv/kvm/gstage.c +1 -5
+               kvm_riscv_gstage_mode_mask |= BIT(HGATP_MODE_SV32X4);
                kvm_riscv_gstage_max_pgd_levels = 2;
-               goto done;
        }
 #endif
 
-       /* KVM depends on !HGATP_MODE_OFF */
-       kvm_riscv_gstage_max_pgd_levels = 0;
-
-done:

Here are some statements from RISC-V privilege specification:
"Implementations that support Sv48 must also support Sv39." "Implementations that support Sv57 must also support Sv48." "The conversion of an Sv32x4, Sv39x4, Sv48x4, or Sv57x4 guest physical address is accomplished with the
same algorithm used for Sv32, Sv39, Sv48, or Sv57, as presented in Section 12.3.2, except that:"
"hgatp substitutes for the usual satp;"

Quoted 3 lines

Based on above it is a waste to try each and every mode.
For example: if mode Sv48x4 is supported then Sv39x4 is also supported.

Radmi and I discussed this topic before; please refer to the following link:
https://lore.kernel.org/linux-riscv/[email protected]/

Quoted 2 lines

Regards,
Anup

Thanks,
Fangyu

Signature · 3 lines
kvm-riscv mailing list
[email protected]
http://lists.infradead.org/mailman/listinfo/kvm-riscv
maintainer
#7 lore raw

Re: Re: [PATCH v5 2/3] RISC-V: KVM: Detect and expose supported HGATP G-stage modes

Quoted 135 lines · On Fri, Mar 27, 2026 at 7:26 AM <[email protected]> wrote:
Quoted 23 lines
Quoted 23 lines

From: Fangyu Yu <[email protected]>

Extend kvm_riscv_gstage_mode_detect() to probe all HGATP.MODE values supported by the host and record them in a bitmask. Keep tracking the maximum supported G-stage page table level for existing internal users.

Also provide lightweight helpers to retrieve the supported-mode bitmask and validate a requested HGATP.MODE against it.

---
 arch/riscv/include/asm/kvm_gstage.h | 11 ++++++++
 arch/riscv/kvm/gstage.c             | 43 +++++++++++++++--------------
 2 files changed, 34 insertions(+), 20 deletions(-)
arch/riscv/include/asm/kvm_gstage.h +0 -0
index b12605fbca44..76c37b5dc02d 100644
@@ -30,6 +30,7 @@ struct kvm_gstage_mapping {
 #endif
 
Quoted 6 lines

arch/riscv/include/asm/kvm_gstage.h struct kvm_gstage_mapping { · line 33

Quoted 2 lines
arch/riscv/include/asm/kvm_gstage.h +1 -0
 extern unsigned long kvm_riscv_gstage_max_pgd_levels;
+extern u32 kvm_riscv_gstage_mode_mask;

s/u32/unsigned long/ s/kvm_riscv_gstage_mode_mask/kvm_riscv_gstage_supported_mode_mask/

Ack, will switch the type to unsigned long and rename it to kvm_riscv_gstage_supported_mode_mask in the next revision.

Quoted 102 lines
Quoted 82 lines
arch/riscv/include/asm/kvm_gstage.h +10 -0
 #define kvm_riscv_gstage_pgd_xbits     2
 #define kvm_riscv_gstage_pgd_size      (1UL << (HGATP_PAGE_SHIFT + kvm_riscv_gstage_pgd_xbits))
@@ -75,4 +76,14 @@ void kvm_riscv_gstage_wp_range(struct kvm_gstage *gstage, gpa_t start, gpa_t end
 
 void kvm_riscv_gstage_mode_detect(void);
 
+static inline u32 kvm_riscv_get_hgatp_mode_mask(void)
+{
+       return kvm_riscv_gstage_mode_mask;
+}
+
+static inline bool kvm_riscv_hgatp_mode_is_valid(unsigned long mode)
+{
+       return kvm_riscv_gstage_mode_mask & BIT(mode);
+}
+
 #endif
arch/riscv/kvm/gstage.c +22 -15
index 2d0045f502d1..328d4138f162 100644
@@ -16,6 +16,8 @@ unsigned long kvm_riscv_gstage_max_pgd_levels __ro_after_init = 3;
 #else
 unsigned long kvm_riscv_gstage_max_pgd_levels __ro_after_init = 2;
 #endif
+/* Bitmask of supported HGATP.MODE encodings (BIT(HGATP_MODE_*)). */
+u32 kvm_riscv_gstage_mode_mask __ro_after_init;
 
 #define gstage_pte_leaf(__ptep)        \
        (pte_val(*(__ptep)) & (_PAGE_READ | _PAGE_WRITE | _PAGE_EXEC))
@@ -315,42 +317,43 @@ void kvm_riscv_gstage_wp_range(struct kvm_gstage *gstage, gpa_t start, gpa_t end
        }
 }
 
+static bool __init kvm_riscv_hgatp_mode_supported(unsigned long mode)
+{
+       csr_write(CSR_HGATP, mode << HGATP_MODE_SHIFT);
+       return ((csr_read(CSR_HGATP) >> HGATP_MODE_SHIFT) == mode);
+}
+
 void __init kvm_riscv_gstage_mode_detect(void)
 {
+       kvm_riscv_gstage_mode_mask = 0;
+       kvm_riscv_gstage_max_pgd_levels = 0;
+
 #ifdef CONFIG_64BIT
-       /* Try Sv57x4 G-stage mode */
-       csr_write(CSR_HGATP, HGATP_MODE_SV57X4 << HGATP_MODE_SHIFT);
-       if ((csr_read(CSR_HGATP) >> HGATP_MODE_SHIFT) == HGATP_MODE_SV57X4) {
-               kvm_riscv_gstage_max_pgd_levels = 5;
-               goto done;
+       /* Try Sv39x4 G-stage mode */
+       if (kvm_riscv_hgatp_mode_supported(HGATP_MODE_SV39X4)) {
+               kvm_riscv_gstage_mode_mask |= BIT(HGATP_MODE_SV39X4);
+               kvm_riscv_gstage_max_pgd_levels = 3;
        }
 
        /* Try Sv48x4 G-stage mode */
-       csr_write(CSR_HGATP, HGATP_MODE_SV48X4 << HGATP_MODE_SHIFT);
-       if ((csr_read(CSR_HGATP) >> HGATP_MODE_SHIFT) == HGATP_MODE_SV48X4) {
+       if (kvm_riscv_hgatp_mode_supported(HGATP_MODE_SV48X4)) {
+               kvm_riscv_gstage_mode_mask |= BIT(HGATP_MODE_SV48X4);
                kvm_riscv_gstage_max_pgd_levels = 4;
-               goto done;
        }
 
-       /* Try Sv39x4 G-stage mode */
-       csr_write(CSR_HGATP, HGATP_MODE_SV39X4 << HGATP_MODE_SHIFT);
-       if ((csr_read(CSR_HGATP) >> HGATP_MODE_SHIFT) == HGATP_MODE_SV39X4) {
-               kvm_riscv_gstage_max_pgd_levels = 3;
-               goto done;
+       /* Try Sv57x4 G-stage mode */
+       if (kvm_riscv_hgatp_mode_supported(HGATP_MODE_SV57X4)) {
+               kvm_riscv_gstage_mode_mask |= BIT(HGATP_MODE_SV57X4);
+               kvm_riscv_gstage_max_pgd_levels = 5;
        }
 #else /* CONFIG_32BIT */
        /* Try Sv32x4 G-stage mode */
-       csr_write(CSR_HGATP, HGATP_MODE_SV32X4 << HGATP_MODE_SHIFT);
-       if ((csr_read(CSR_HGATP) >> HGATP_MODE_SHIFT) == HGATP_MODE_SV32X4) {
+       if (kvm_riscv_hgatp_mode_supported(HGATP_MODE_SV32X4)) {

arch/riscv/kvm/gstage.c void kvm_riscv_gstage_wp_range(struct kvm_gstage *gstage, gpa_t start, gpa_t end · line 353

Quoted 10 lines
arch/riscv/kvm/gstage.c +1 -5
+               kvm_riscv_gstage_mode_mask |= BIT(HGATP_MODE_SV32X4);
                kvm_riscv_gstage_max_pgd_levels = 2;
-               goto done;
        }
 #endif
 
-       /* KVM depends on !HGATP_MODE_OFF */
-       kvm_riscv_gstage_max_pgd_levels = 0;
-
-done:

Here are some statements from RISC-V privilege specification:
"Implementations that support Sv48 must also support Sv39." "Implementations that support Sv57 must also support Sv48." "The conversion of an Sv32x4, Sv39x4, Sv48x4, or Sv57x4 guest physical address is accomplished with the
same algorithm used for Sv32, Sv39, Sv48, or Sv57, as presented in Section 12.3.2, except that:"
"hgatp substitutes for the usual satp;"

Quoted 6 lines
Quoted 3 lines

Based on above it is a waste to try each and every mode.
For example: if mode Sv48x4 is supported then Sv39x4 is also supported.

Radmi and I discussed this topic before; please refer to the following link:
https://lore.kernel.org/linux-riscv/[email protected]/

Privilege spec mandates Sv48 and Sv39 when Sv57 is supported so the current approach is not based on any assumption.

Regards,
Anup

#8 lore raw

Re: Re: Re: [PATCH v5 2/3] RISC-V: KVM: Detect and expose supported HGATP G-stage modes

Quoted 138 lines
Quoted 138 lines
Quoted 22 lines
Quoted 22 lines

From: Fangyu Yu <[email protected]>

Extend kvm_riscv_gstage_mode_detect() to probe all HGATP.MODE values supported by the host and record them in a bitmask. Keep tracking the maximum supported G-stage page table level for existing internal users.

Also provide lightweight helpers to retrieve the supported-mode bitmask and validate a requested HGATP.MODE against it.

---
 arch/riscv/include/asm/kvm_gstage.h | 11 ++++++++
 arch/riscv/kvm/gstage.c             | 43 +++++++++++++++--------------
 2 files changed, 34 insertions(+), 20 deletions(-)
arch/riscv/include/asm/kvm_gstage.h +0 -0
index b12605fbca44..76c37b5dc02d 100644
@@ -30,6 +30,7 @@ struct kvm_gstage_mapping {
 #endif
 
Quoted 6 lines

arch/riscv/include/asm/kvm_gstage.h struct kvm_gstage_mapping { · line 33

Quoted 2 lines
arch/riscv/include/asm/kvm_gstage.h +1 -0
 extern unsigned long kvm_riscv_gstage_max_pgd_levels;
+extern u32 kvm_riscv_gstage_mode_mask;

s/u32/unsigned long/ s/kvm_riscv_gstage_mode_mask/kvm_riscv_gstage_supported_mode_mask/

Ack, will switch the type to unsigned long and rename it to kvm_riscv_gstage_supported_mode_mask in the next revision.

Quoted 105 lines
Quoted 82 lines
arch/riscv/include/asm/kvm_gstage.h +10 -0
 #define kvm_riscv_gstage_pgd_xbits     2
 #define kvm_riscv_gstage_pgd_size      (1UL << (HGATP_PAGE_SHIFT + kvm_riscv_gstage_pgd_xbits))
@@ -75,4 +76,14 @@ void kvm_riscv_gstage_wp_range(struct kvm_gstage *gstage, gpa_t start, gpa_t end
 
 void kvm_riscv_gstage_mode_detect(void);
 
+static inline u32 kvm_riscv_get_hgatp_mode_mask(void)
+{
+       return kvm_riscv_gstage_mode_mask;
+}
+
+static inline bool kvm_riscv_hgatp_mode_is_valid(unsigned long mode)
+{
+       return kvm_riscv_gstage_mode_mask & BIT(mode);
+}
+
 #endif
arch/riscv/kvm/gstage.c +22 -15
index 2d0045f502d1..328d4138f162 100644
@@ -16,6 +16,8 @@ unsigned long kvm_riscv_gstage_max_pgd_levels __ro_after_init = 3;
 #else
 unsigned long kvm_riscv_gstage_max_pgd_levels __ro_after_init = 2;
 #endif
+/* Bitmask of supported HGATP.MODE encodings (BIT(HGATP_MODE_*)). */
+u32 kvm_riscv_gstage_mode_mask __ro_after_init;
 
 #define gstage_pte_leaf(__ptep)        \
        (pte_val(*(__ptep)) & (_PAGE_READ | _PAGE_WRITE | _PAGE_EXEC))
@@ -315,42 +317,43 @@ void kvm_riscv_gstage_wp_range(struct kvm_gstage *gstage, gpa_t start, gpa_t end
        }
 }
 
+static bool __init kvm_riscv_hgatp_mode_supported(unsigned long mode)
+{
+       csr_write(CSR_HGATP, mode << HGATP_MODE_SHIFT);
+       return ((csr_read(CSR_HGATP) >> HGATP_MODE_SHIFT) == mode);
+}
+
 void __init kvm_riscv_gstage_mode_detect(void)
 {
+       kvm_riscv_gstage_mode_mask = 0;
+       kvm_riscv_gstage_max_pgd_levels = 0;
+
 #ifdef CONFIG_64BIT
-       /* Try Sv57x4 G-stage mode */
-       csr_write(CSR_HGATP, HGATP_MODE_SV57X4 << HGATP_MODE_SHIFT);
-       if ((csr_read(CSR_HGATP) >> HGATP_MODE_SHIFT) == HGATP_MODE_SV57X4) {
-               kvm_riscv_gstage_max_pgd_levels = 5;
-               goto done;
+       /* Try Sv39x4 G-stage mode */
+       if (kvm_riscv_hgatp_mode_supported(HGATP_MODE_SV39X4)) {
+               kvm_riscv_gstage_mode_mask |= BIT(HGATP_MODE_SV39X4);
+               kvm_riscv_gstage_max_pgd_levels = 3;
        }
 
        /* Try Sv48x4 G-stage mode */
-       csr_write(CSR_HGATP, HGATP_MODE_SV48X4 << HGATP_MODE_SHIFT);
-       if ((csr_read(CSR_HGATP) >> HGATP_MODE_SHIFT) == HGATP_MODE_SV48X4) {
+       if (kvm_riscv_hgatp_mode_supported(HGATP_MODE_SV48X4)) {
+               kvm_riscv_gstage_mode_mask |= BIT(HGATP_MODE_SV48X4);
                kvm_riscv_gstage_max_pgd_levels = 4;
-               goto done;
        }
 
-       /* Try Sv39x4 G-stage mode */
-       csr_write(CSR_HGATP, HGATP_MODE_SV39X4 << HGATP_MODE_SHIFT);
-       if ((csr_read(CSR_HGATP) >> HGATP_MODE_SHIFT) == HGATP_MODE_SV39X4) {
-               kvm_riscv_gstage_max_pgd_levels = 3;
-               goto done;
+       /* Try Sv57x4 G-stage mode */
+       if (kvm_riscv_hgatp_mode_supported(HGATP_MODE_SV57X4)) {
+               kvm_riscv_gstage_mode_mask |= BIT(HGATP_MODE_SV57X4);
+               kvm_riscv_gstage_max_pgd_levels = 5;
        }
 #else /* CONFIG_32BIT */
        /* Try Sv32x4 G-stage mode */
-       csr_write(CSR_HGATP, HGATP_MODE_SV32X4 << HGATP_MODE_SHIFT);
-       if ((csr_read(CSR_HGATP) >> HGATP_MODE_SHIFT) == HGATP_MODE_SV32X4) {
+       if (kvm_riscv_hgatp_mode_supported(HGATP_MODE_SV32X4)) {

arch/riscv/kvm/gstage.c void kvm_riscv_gstage_wp_range(struct kvm_gstage *gstage, gpa_t start, gpa_t end · line 353

Quoted 10 lines
arch/riscv/kvm/gstage.c +1 -5
+               kvm_riscv_gstage_mode_mask |= BIT(HGATP_MODE_SV32X4);
                kvm_riscv_gstage_max_pgd_levels = 2;
-               goto done;
        }
 #endif
 
-       /* KVM depends on !HGATP_MODE_OFF */
-       kvm_riscv_gstage_max_pgd_levels = 0;
-
-done:

Here are some statements from RISC-V privilege specification:
"Implementations that support Sv48 must also support Sv39." "Implementations that support Sv57 must also support Sv48." "The conversion of an Sv32x4, Sv39x4, Sv48x4, or Sv57x4 guest physical address is accomplished with the
same algorithm used for Sv32, Sv39, Sv48, or Sv57, as presented in Section 12.3.2, except that:"
"hgatp substitutes for the usual satp;"

Based on above it is a waste to try each and every mode.
For example: if mode Sv48x4 is supported then Sv39x4 is also supported.

Quoted 5 lines
Quoted 2 lines

Radmi and I discussed this topic before; please refer to the following link:
https://lore.kernel.org/linux-riscv/[email protected]/

Privilege spec mandates Sv48 and Sv39 when Sv57 is supported so the current approach is not based on any assumption.

Thanks for the pointers from the priv spec. I agree that for selecting a working G-stage mode (e.g. picking the highest supported mode), it’s sufficient to probe from Sv57x4 downwards.

Now, I want to build an explicit capability mask of all HGATP.MODE encodings that the hardware actually accepts, so that if the userspace config forces a specific mode (e.g. Sv48x4), KVM can validate it directly and reject/ fallback when that exact mode is not supported.

As an alternative, we could also do the probing lazily: i.e. when userspace requests a specific HGATP mode, we try programming that mode and fail the request if it is not accepted.

Quoted 2 lines

Regards,
Anup

Thanks,
Fangyu

#9 lore raw

PATCH v5 3/3 RISC-V: KVM: add KVM_CAP_RISCV_SET_HGATP_MODE

In reply to [email protected]

From: Fangyu Yu <[email protected]>

Add a VM capability that allows userspace to select the G-stage page table format by setting HGATP.MODE on a per-VM basis.

Userspace enables the capability via KVM_ENABLE_CAP, passing the requested HGATP.MODE in args[0]. The request is rejected with -EINVAL if the mode is not supported by the host, and with -EBUSY if the VM has already been committed (e.g. vCPUs have been created or any memslot is populated).

KVM_CHECK_EXTENSION(KVM_CAP_RISCV_SET_HGATP_MODE) returns a bitmask of the HGATP.MODE formats supported by the host.

---
 Documentation/virt/kvm/api.rst | 27 +++++++++++++++++++++++++++
 arch/riscv/kvm/vm.c            | 19 +++++++++++++++++--
 include/uapi/linux/kvm.h       |  1 +
 3 files changed, 45 insertions(+), 2 deletions(-)
Documentation/virt/kvm/api.rst +27 -0
index 01a3abef8abb..62dc120857c1 100644
@@ -8765,6 +8765,33 @@ helpful if user space wants to emulate instructions which are not
 This capability can be enabled dynamically even if VCPUs were already
 created and are running.
 
+7.47 KVM_CAP_RISCV_SET_HGATP_MODE
+---------------------------------
+
+:Architectures: riscv
+:Type: VM
+:Parameters: args[0] contains the requested HGATP mode
+:Returns:
+  - 0 on success.
+  - -EINVAL if args[0] is outside the range of HGATP modes supported by the
+    hardware.
+  - -EBUSY if vCPUs have already been created for the VM, if the VM has any
+    non-empty memslots.
+
+This capability allows userspace to explicitly select the HGATP mode for
+the VM. The selected mode must be supported by both KVM and hardware. This
+capability must be enabled before creating any vCPUs or memslots.
+
+If this capability is not enabled, KVM will select the default HGATP mode
+automatically. The default is the highest HGATP.MODE value supported by
+hardware.
+
+``KVM_CHECK_EXTENSION(KVM_CAP_RISCV_SET_HGATP_MODE)`` returns a bitmask of
+HGATP.MODE values supported by the host. A return value of 0 indicates that
+the capability is not supported. Supported-mode bitmask use HGATP.MODE
+encodings as defined by the RISC-V privileged specification, such as Sv39x4
+corresponds to HGATP.MODE=8, so userspace should test bitmask & BIT(8).
+
 8. Other capabilities.
 ======================
 
arch/riscv/kvm/vm.c +17 -2
index 4b2156df40fc..7d1e1d257df5 100644
@@ -202,6 +202,9 @@ int kvm_vm_ioctl_check_extension(struct kvm *kvm, long ext)
 	case KVM_CAP_VM_GPA_BITS:
 		r = kvm_riscv_gstage_gpa_bits(&kvm->arch);
 		break;
+	case KVM_CAP_RISCV_SET_HGATP_MODE:
+		r = kvm_riscv_get_hgatp_mode_mask();
+		break;
 	default:
 		r = 0;
 		break;
@@ -212,12 +215,24 @@ int kvm_vm_ioctl_check_extension(struct kvm *kvm, long ext)
 
 int kvm_vm_ioctl_enable_cap(struct kvm *kvm, struct kvm_enable_cap *cap)
 {
+	if (cap->flags)
+		return -EINVAL;
+
 	switch (cap->cap) {
 	case KVM_CAP_RISCV_MP_STATE_RESET:
-		if (cap->flags)
-			return -EINVAL;
 		kvm->arch.mp_state_reset = true;
 		return 0;
+	case KVM_CAP_RISCV_SET_HGATP_MODE:
+		if (!kvm_riscv_hgatp_mode_is_valid(cap->args[0]))
+			return -EINVAL;
+
+		if (kvm->created_vcpus || !kvm_are_all_memslots_empty(kvm))
+			return -EBUSY;
+#ifdef CONFIG_64BIT
+		kvm->arch.kvm_riscv_gstage_pgd_levels =
+				3 + cap->args[0] - HGATP_MODE_SV39X4;
+#endif
+		return 0;
 	default:
 		return -EINVAL;
 	}
include/uapi/linux/kvm.h +1 -0
index dddb781b0507..00c02a880518 100644
@@ -974,6 +974,7 @@ struct kvm_enable_cap {
 #define KVM_CAP_GUEST_MEMFD_FLAGS 244
 #define KVM_CAP_ARM_SEA_TO_USER 245
 #define KVM_CAP_S390_USER_OPEREXEC 246
+#define KVM_CAP_RISCV_SET_HGATP_MODE 247
 
 struct kvm_irq_routing_irqchip {
 	__u32 irqchip;
Signature · 7 lines
2.50.1


-- 
kvm-riscv mailing list
[email protected]
http://lists.infradead.org/mailman/listinfo/kvm-riscv
#10 lore raw

Re: [PATCH v5 3/3] RISC-V: KVM: add KVM_CAP_RISCV_SET_HGATP_MODE

Quoted 31 lines · On Wed, Feb 04, 2026 at 09:45:07PM +0800, [email protected] wrote:

From: Fangyu Yu <[email protected]>

Add a VM capability that allows userspace to select the G-stage page table format by setting HGATP.MODE on a per-VM basis.

Userspace enables the capability via KVM_ENABLE_CAP, passing the requested HGATP.MODE in args[0]. The request is rejected with -EINVAL if the mode is not supported by the host, and with -EBUSY if the VM has already been committed (e.g. vCPUs have been created or any memslot is populated).

KVM_CHECK_EXTENSION(KVM_CAP_RISCV_SET_HGATP_MODE) returns a bitmask of the HGATP.MODE formats supported by the host.

---
 Documentation/virt/kvm/api.rst | 27 +++++++++++++++++++++++++++
 arch/riscv/kvm/vm.c            | 19 +++++++++++++++++--
 include/uapi/linux/kvm.h       |  1 +
 3 files changed, 45 insertions(+), 2 deletions(-)
Documentation/virt/kvm/api.rst +3 -0
index 01a3abef8abb..62dc120857c1 100644
@@ -8765,6 +8765,33 @@ helpful if user space wants to emulate instructions which are not
 This capability can be enabled dynamically even if VCPUs were already
 created and are running.
 
+7.47 KVM_CAP_RISCV_SET_HGATP_MODE
+---------------------------------
+

Documentation/virt/kvm/api.rst helpful if user space wants to emulate instructions which are not · line 8780

Quoted 10 lines
Documentation/virt/kvm/api.rst +10 -0
+:Architectures: riscv
+:Type: VM
+:Parameters: args[0] contains the requested HGATP mode
+:Returns:
+  - 0 on success.
+  - -EINVAL if args[0] is outside the range of HGATP modes supported by the
+    hardware.
+  - -EBUSY if vCPUs have already been created for the VM, if the VM has any
+    non-empty memslots.
+

Currently the documentation for KVM_SET_ONE_REG has this for EBUSY

EBUSY (riscv) changing register value not allowed after the vcpu
has run at least once

I suggest we update the KVM_SET_ONE_REG EBUSY description to say

(riscv) changing register value not allowed. This may occur after the vcpu has run at least once or when other setup has completed which depends on the value of the register.

Quoted 44 lines
Documentation/virt/kvm/api.rst +14 -0
+This capability allows userspace to explicitly select the HGATP mode for
+the VM. The selected mode must be supported by both KVM and hardware. This
+capability must be enabled before creating any vCPUs or memslots.
+
+If this capability is not enabled, KVM will select the default HGATP mode
+automatically. The default is the highest HGATP.MODE value supported by
+hardware.
+
+``KVM_CHECK_EXTENSION(KVM_CAP_RISCV_SET_HGATP_MODE)`` returns a bitmask of
+HGATP.MODE values supported by the host. A return value of 0 indicates that
+the capability is not supported. Supported-mode bitmask use HGATP.MODE
+encodings as defined by the RISC-V privileged specification, such as Sv39x4
+corresponds to HGATP.MODE=8, so userspace should test bitmask & BIT(8).
+
 8. Other capabilities.
 ======================
 
arch/riscv/kvm/vm.c +6 -2
index 4b2156df40fc..7d1e1d257df5 100644
@@ -202,6 +202,9 @@ int kvm_vm_ioctl_check_extension(struct kvm *kvm, long ext)
 	case KVM_CAP_VM_GPA_BITS:
 		r = kvm_riscv_gstage_gpa_bits(&kvm->arch);
 		break;
+	case KVM_CAP_RISCV_SET_HGATP_MODE:
+		r = kvm_riscv_get_hgatp_mode_mask();
+		break;
 	default:
 		r = 0;
 		break;
@@ -212,12 +215,24 @@ int kvm_vm_ioctl_check_extension(struct kvm *kvm, long ext)
 
 int kvm_vm_ioctl_enable_cap(struct kvm *kvm, struct kvm_enable_cap *cap)
 {
+	if (cap->flags)
+		return -EINVAL;
+
 	switch (cap->cap) {
 	case KVM_CAP_RISCV_MP_STATE_RESET:
-		if (cap->flags)
-			return -EINVAL;
 		kvm->arch.mp_state_reset = true;
 		return 0;

arch/riscv/kvm/vm.c int kvm_vm_ioctl_check_extension(struct kvm *kvm, long ext) · line 234

Quoted 10 lines
arch/riscv/kvm/vm.c +10 -0
+	case KVM_CAP_RISCV_SET_HGATP_MODE:
+		if (!kvm_riscv_hgatp_mode_is_valid(cap->args[0]))
+			return -EINVAL;
+
+		if (kvm->created_vcpus || !kvm_are_all_memslots_empty(kvm))
+			return -EBUSY;
+#ifdef CONFIG_64BIT
+		kvm->arch.kvm_riscv_gstage_pgd_levels =
+				3 + cap->args[0] - HGATP_MODE_SV39X4;
+#endif

'if (IS_ENABLED(CONFIG_64BIT))' is preferred to the #ifdef.

Quoted 19 lines
arch/riscv/kvm/vm.c +1 -0
+		return 0;
 	default:
 		return -EINVAL;
 	}
include/uapi/linux/kvm.h +1 -0
index dddb781b0507..00c02a880518 100644
@@ -974,6 +974,7 @@ struct kvm_enable_cap {
 #define KVM_CAP_GUEST_MEMFD_FLAGS 244
 #define KVM_CAP_ARM_SEA_TO_USER 245
 #define KVM_CAP_S390_USER_OPEREXEC 246
+#define KVM_CAP_RISCV_SET_HGATP_MODE 247
 
 struct kvm_irq_routing_irqchip {
 	__u32 irqchip;
Signature · 1 line
2.50.1

Thanks,
drew

#11 lore raw

Re: Re: [PATCH v5 3/3] RISC-V: KVM: add KVM_CAP_RISCV_SET_HGATP_MODE

Quoted 44 lines
Quoted 31 lines

From: Fangyu Yu <[email protected]>

Add a VM capability that allows userspace to select the G-stage page table format by setting HGATP.MODE on a per-VM basis.

Userspace enables the capability via KVM_ENABLE_CAP, passing the requested HGATP.MODE in args[0]. The request is rejected with -EINVAL if the mode is not supported by the host, and with -EBUSY if the VM has already been committed (e.g. vCPUs have been created or any memslot is populated).

KVM_CHECK_EXTENSION(KVM_CAP_RISCV_SET_HGATP_MODE) returns a bitmask of the HGATP.MODE formats supported by the host.

---
 Documentation/virt/kvm/api.rst | 27 +++++++++++++++++++++++++++
 arch/riscv/kvm/vm.c            | 19 +++++++++++++++++--
 include/uapi/linux/kvm.h       |  1 +
 3 files changed, 45 insertions(+), 2 deletions(-)
Documentation/virt/kvm/api.rst +3 -0
index 01a3abef8abb..62dc120857c1 100644
@@ -8765,6 +8765,33 @@ helpful if user space wants to emulate instructions which are not
 This capability can be enabled dynamically even if VCPUs were already
 created and are running.
 
+7.47 KVM_CAP_RISCV_SET_HGATP_MODE
+---------------------------------
+

Documentation/virt/kvm/api.rst helpful if user space wants to emulate instructions which are not · line 8780

Quoted 10 lines
Documentation/virt/kvm/api.rst +10 -0
+:Architectures: riscv
+:Type: VM
+:Parameters: args[0] contains the requested HGATP mode
+:Returns:
+  - 0 on success.
+  - -EINVAL if args[0] is outside the range of HGATP modes supported by the
+    hardware.
+  - -EBUSY if vCPUs have already been created for the VM, if the VM has any
+    non-empty memslots.
+

Currently the documentation for KVM_SET_ONE_REG has this for EBUSY

Quoted 8 lines

EBUSY (riscv) changing register value not allowed after the vcpu
has run at least once

I suggest we update the KVM_SET_ONE_REG EBUSY description to say

(riscv) changing register value not allowed. This may occur after the vcpu has run at least once or when other setup has completed which depends on the value of the register.

Thanks for the suggestion.

In this series the HGATP mode is configured via KVM_ENABLE_CAP at the VM level (kvm_vm_ioctl_enable_cap), not via KVM_SET_ONE_REG. Updating the KVM_SET_ONE_REG -EBUSY description might be misleading since it is vCPU one-reg specific and not directly related to this series.

Quoted 71 lines
Quoted 44 lines
Documentation/virt/kvm/api.rst +14 -0
+This capability allows userspace to explicitly select the HGATP mode for
+the VM. The selected mode must be supported by both KVM and hardware. This
+capability must be enabled before creating any vCPUs or memslots.
+
+If this capability is not enabled, KVM will select the default HGATP mode
+automatically. The default is the highest HGATP.MODE value supported by
+hardware.
+
+``KVM_CHECK_EXTENSION(KVM_CAP_RISCV_SET_HGATP_MODE)`` returns a bitmask of
+HGATP.MODE values supported by the host. A return value of 0 indicates that
+the capability is not supported. Supported-mode bitmask use HGATP.MODE
+encodings as defined by the RISC-V privileged specification, such as Sv39x4
+corresponds to HGATP.MODE=8, so userspace should test bitmask & BIT(8).
+
 8. Other capabilities.
 ======================
 
arch/riscv/kvm/vm.c +6 -2
index 4b2156df40fc..7d1e1d257df5 100644
@@ -202,6 +202,9 @@ int kvm_vm_ioctl_check_extension(struct kvm *kvm, long ext)
 	case KVM_CAP_VM_GPA_BITS:
 		r = kvm_riscv_gstage_gpa_bits(&kvm->arch);
 		break;
+	case KVM_CAP_RISCV_SET_HGATP_MODE:
+		r = kvm_riscv_get_hgatp_mode_mask();
+		break;
 	default:
 		r = 0;
 		break;
@@ -212,12 +215,24 @@ int kvm_vm_ioctl_check_extension(struct kvm *kvm, long ext)
 
 int kvm_vm_ioctl_enable_cap(struct kvm *kvm, struct kvm_enable_cap *cap)
 {
+	if (cap->flags)
+		return -EINVAL;
+
 	switch (cap->cap) {
 	case KVM_CAP_RISCV_MP_STATE_RESET:
-		if (cap->flags)
-			return -EINVAL;
 		kvm->arch.mp_state_reset = true;
 		return 0;

arch/riscv/kvm/vm.c int kvm_vm_ioctl_check_extension(struct kvm *kvm, long ext) · line 234

Quoted 10 lines
arch/riscv/kvm/vm.c +10 -0
+	case KVM_CAP_RISCV_SET_HGATP_MODE:
+		if (!kvm_riscv_hgatp_mode_is_valid(cap->args[0]))
+			return -EINVAL;
+
+		if (kvm->created_vcpus || !kvm_are_all_memslots_empty(kvm))
+			return -EBUSY;
+#ifdef CONFIG_64BIT
+		kvm->arch.kvm_riscv_gstage_pgd_levels =
+				3 + cap->args[0] - HGATP_MODE_SV39X4;
+#endif

'if (IS_ENABLED(CONFIG_64BIT))' is preferred to the #ifdef.

Quoted 14 lines
arch/riscv/kvm/vm.c +1 -0
+		return 0;
 	default:
 		return -EINVAL;
 	}
include/uapi/linux/kvm.h +1 -0
index dddb781b0507..00c02a880518 100644
@@ -974,6 +974,7 @@ struct kvm_enable_cap {
 #define KVM_CAP_GUEST_MEMFD_FLAGS 244
 #define KVM_CAP_ARM_SEA_TO_USER 245
 #define KVM_CAP_S390_USER_OPEREXEC 246
+#define KVM_CAP_RISCV_SET_HGATP_MODE 247
 
Quoted 8 lines
Quoted 5 lines
include/uapi/linux/kvm.h +0 -0
 struct kvm_irq_routing_irqchip {
 	__u32 irqchip;
Signature · 1 line
2.50.1

Thanks,
drew

Thanks,
Fangyu

#12 lore raw

Re: [PATCH v5 3/3] RISC-V: KVM: add KVM_CAP_RISCV_SET_HGATP_MODE

Quoted 53 lines · On Thu, Feb 05, 2026 at 09:28:08AM +0800, [email protected] wrote:
Quoted 44 lines
Quoted 31 lines

From: Fangyu Yu <[email protected]>

Add a VM capability that allows userspace to select the G-stage page table format by setting HGATP.MODE on a per-VM basis.

Userspace enables the capability via KVM_ENABLE_CAP, passing the requested HGATP.MODE in args[0]. The request is rejected with -EINVAL if the mode is not supported by the host, and with -EBUSY if the VM has already been committed (e.g. vCPUs have been created or any memslot is populated).

KVM_CHECK_EXTENSION(KVM_CAP_RISCV_SET_HGATP_MODE) returns a bitmask of the HGATP.MODE formats supported by the host.

---
 Documentation/virt/kvm/api.rst | 27 +++++++++++++++++++++++++++
 arch/riscv/kvm/vm.c            | 19 +++++++++++++++++--
 include/uapi/linux/kvm.h       |  1 +
 3 files changed, 45 insertions(+), 2 deletions(-)
Documentation/virt/kvm/api.rst +3 -0
index 01a3abef8abb..62dc120857c1 100644
@@ -8765,6 +8765,33 @@ helpful if user space wants to emulate instructions which are not
 This capability can be enabled dynamically even if VCPUs were already
 created and are running.
 
+7.47 KVM_CAP_RISCV_SET_HGATP_MODE
+---------------------------------
+

Documentation/virt/kvm/api.rst helpful if user space wants to emulate instructions which are not · line 8780

Quoted 10 lines
Documentation/virt/kvm/api.rst +10 -0
+:Architectures: riscv
+:Type: VM
+:Parameters: args[0] contains the requested HGATP mode
+:Returns:
+  - 0 on success.
+  - -EINVAL if args[0] is outside the range of HGATP modes supported by the
+    hardware.
+  - -EBUSY if vCPUs have already been created for the VM, if the VM has any
+    non-empty memslots.
+

Currently the documentation for KVM_SET_ONE_REG has this for EBUSY

Quoted 8 lines

EBUSY (riscv) changing register value not allowed after the vcpu
has run at least once

I suggest we update the KVM_SET_ONE_REG EBUSY description to say

(riscv) changing register value not allowed. This may occur after the vcpu has run at least once or when other setup has completed which depends on the value of the register.

Quoted 6 lines

Thanks for the suggestion.

In this series the HGATP mode is configured via KVM_ENABLE_CAP at the VM level (kvm_vm_ioctl_enable_cap), not via KVM_SET_ONE_REG. Updating the KVM_SET_ONE_REG -EBUSY description might be misleading since it is vCPU one-reg specific and not directly related to this series.

Oh, right. I'm so used to adding registers I forgot we're only adding a cap...

Thanks,
drew

Reviewed-by on the v5 series
#13 lore raw
In reply to [email protected]
Quoted 7 lines · On Wed, Feb 04, 2026 at 09:45:04PM +0800, [email protected] wrote:

From: Fangyu Yu <[email protected]>

Currently, RISC-V KVM hardcodes the G-stage page table format (HGATP mode) to the maximum mode detected at boot time (e.g., SV57x4 if supported). but often such a wide GPA is unnecessary, just as a host sometimes doesn't need sv57.

Quoted 5 lines

This patch introduces per-VM configurability of the G-stage mode via a new KVM capability: KVM_CAP_RISCV_SET_HGATP_MODE. User-space can now explicitly request a specific HGATP mode (SV39x4, SV48x4, SV57x4 or SV32x4) during VM creation.

For the series,