xref: /linux/tools/testing/selftests/kvm/riscv/get-reg-list.c (revision c4bb3a2d641c02ac2c7aa45534b4cefdf9bf416b)
1 // SPDX-License-Identifier: GPL-2.0
2 /*
3  * Check for KVM_GET_REG_LIST regressions.
4  *
5  * Copyright (c) 2023 Intel Corporation
6  *
7  */
8 #include <stdio.h>
9 #include "kvm_util.h"
10 #include "test_util.h"
11 #include "processor.h"
12 
13 #define REG_MASK (KVM_REG_ARCH_MASK | KVM_REG_SIZE_MASK)
14 
15 enum {
16 	VCPU_FEATURE_ISA_EXT = 0,
17 	VCPU_FEATURE_SBI_EXT,
18 };
19 
20 static bool isa_ext_cant_disable[KVM_RISCV_ISA_EXT_MAX];
21 
filter_reg(__u64 reg)22 bool filter_reg(__u64 reg)
23 {
24 	switch (reg & ~REG_MASK) {
25 	/*
26 	 * Same set of ISA_EXT registers are not present on all host because
27 	 * ISA_EXT registers are visible to the KVM user space based on the
28 	 * ISA extensions available on the host. Also, disabling an ISA
29 	 * extension using corresponding ISA_EXT register does not affect
30 	 * the visibility of the ISA_EXT register itself.
31 	 *
32 	 * Based on above, we should filter-out all ISA_EXT registers.
33 	 *
34 	 * Note: The below list is alphabetically sorted.
35 	 */
36 	case KVM_REG_RISCV_ISA_EXT | KVM_REG_RISCV_ISA_SINGLE | KVM_RISCV_ISA_EXT_A:
37 	case KVM_REG_RISCV_ISA_EXT | KVM_REG_RISCV_ISA_SINGLE | KVM_RISCV_ISA_EXT_C:
38 	case KVM_REG_RISCV_ISA_EXT | KVM_REG_RISCV_ISA_SINGLE | KVM_RISCV_ISA_EXT_D:
39 	case KVM_REG_RISCV_ISA_EXT | KVM_REG_RISCV_ISA_SINGLE | KVM_RISCV_ISA_EXT_F:
40 	case KVM_REG_RISCV_ISA_EXT | KVM_REG_RISCV_ISA_SINGLE | KVM_RISCV_ISA_EXT_H:
41 	case KVM_REG_RISCV_ISA_EXT | KVM_REG_RISCV_ISA_SINGLE | KVM_RISCV_ISA_EXT_I:
42 	case KVM_REG_RISCV_ISA_EXT | KVM_REG_RISCV_ISA_SINGLE | KVM_RISCV_ISA_EXT_M:
43 	case KVM_REG_RISCV_ISA_EXT | KVM_REG_RISCV_ISA_SINGLE | KVM_RISCV_ISA_EXT_V:
44 	case KVM_REG_RISCV_ISA_EXT | KVM_REG_RISCV_ISA_SINGLE | KVM_RISCV_ISA_EXT_SMNPM:
45 	case KVM_REG_RISCV_ISA_EXT | KVM_REG_RISCV_ISA_SINGLE | KVM_RISCV_ISA_EXT_SMSTATEEN:
46 	case KVM_REG_RISCV_ISA_EXT | KVM_REG_RISCV_ISA_SINGLE | KVM_RISCV_ISA_EXT_SSAIA:
47 	case KVM_REG_RISCV_ISA_EXT | KVM_REG_RISCV_ISA_SINGLE | KVM_RISCV_ISA_EXT_SSCOFPMF:
48 	case KVM_REG_RISCV_ISA_EXT | KVM_REG_RISCV_ISA_SINGLE | KVM_RISCV_ISA_EXT_SSNPM:
49 	case KVM_REG_RISCV_ISA_EXT | KVM_REG_RISCV_ISA_SINGLE | KVM_RISCV_ISA_EXT_SSTC:
50 	case KVM_REG_RISCV_ISA_EXT | KVM_REG_RISCV_ISA_SINGLE | KVM_RISCV_ISA_EXT_SVADE:
51 	case KVM_REG_RISCV_ISA_EXT | KVM_REG_RISCV_ISA_SINGLE | KVM_RISCV_ISA_EXT_SVADU:
52 	case KVM_REG_RISCV_ISA_EXT | KVM_REG_RISCV_ISA_SINGLE | KVM_RISCV_ISA_EXT_SVINVAL:
53 	case KVM_REG_RISCV_ISA_EXT | KVM_REG_RISCV_ISA_SINGLE | KVM_RISCV_ISA_EXT_SVNAPOT:
54 	case KVM_REG_RISCV_ISA_EXT | KVM_REG_RISCV_ISA_SINGLE | KVM_RISCV_ISA_EXT_SVPBMT:
55 	case KVM_REG_RISCV_ISA_EXT | KVM_REG_RISCV_ISA_SINGLE | KVM_RISCV_ISA_EXT_ZACAS:
56 	case KVM_REG_RISCV_ISA_EXT | KVM_REG_RISCV_ISA_SINGLE | KVM_RISCV_ISA_EXT_ZAWRS:
57 	case KVM_REG_RISCV_ISA_EXT | KVM_REG_RISCV_ISA_SINGLE | KVM_RISCV_ISA_EXT_ZBA:
58 	case KVM_REG_RISCV_ISA_EXT | KVM_REG_RISCV_ISA_SINGLE | KVM_RISCV_ISA_EXT_ZBB:
59 	case KVM_REG_RISCV_ISA_EXT | KVM_REG_RISCV_ISA_SINGLE | KVM_RISCV_ISA_EXT_ZBC:
60 	case KVM_REG_RISCV_ISA_EXT | KVM_REG_RISCV_ISA_SINGLE | KVM_RISCV_ISA_EXT_ZBKB:
61 	case KVM_REG_RISCV_ISA_EXT | KVM_REG_RISCV_ISA_SINGLE | KVM_RISCV_ISA_EXT_ZBKC:
62 	case KVM_REG_RISCV_ISA_EXT | KVM_REG_RISCV_ISA_SINGLE | KVM_RISCV_ISA_EXT_ZBKX:
63 	case KVM_REG_RISCV_ISA_EXT | KVM_REG_RISCV_ISA_SINGLE | KVM_RISCV_ISA_EXT_ZBS:
64 	case KVM_REG_RISCV_ISA_EXT | KVM_REG_RISCV_ISA_SINGLE | KVM_RISCV_ISA_EXT_ZCA:
65 	case KVM_REG_RISCV_ISA_EXT | KVM_REG_RISCV_ISA_SINGLE | KVM_RISCV_ISA_EXT_ZCB:
66 	case KVM_REG_RISCV_ISA_EXT | KVM_REG_RISCV_ISA_SINGLE | KVM_RISCV_ISA_EXT_ZCD:
67 	case KVM_REG_RISCV_ISA_EXT | KVM_REG_RISCV_ISA_SINGLE | KVM_RISCV_ISA_EXT_ZCF:
68 	case KVM_REG_RISCV_ISA_EXT | KVM_REG_RISCV_ISA_SINGLE | KVM_RISCV_ISA_EXT_ZCMOP:
69 	case KVM_REG_RISCV_ISA_EXT | KVM_REG_RISCV_ISA_SINGLE | KVM_RISCV_ISA_EXT_ZFA:
70 	case KVM_REG_RISCV_ISA_EXT | KVM_REG_RISCV_ISA_SINGLE | KVM_RISCV_ISA_EXT_ZFH:
71 	case KVM_REG_RISCV_ISA_EXT | KVM_REG_RISCV_ISA_SINGLE | KVM_RISCV_ISA_EXT_ZFHMIN:
72 	case KVM_REG_RISCV_ISA_EXT | KVM_REG_RISCV_ISA_SINGLE | KVM_RISCV_ISA_EXT_ZICBOM:
73 	case KVM_REG_RISCV_ISA_EXT | KVM_REG_RISCV_ISA_SINGLE | KVM_RISCV_ISA_EXT_ZICBOZ:
74 	case KVM_REG_RISCV_ISA_EXT | KVM_REG_RISCV_ISA_SINGLE | KVM_RISCV_ISA_EXT_ZICNTR:
75 	case KVM_REG_RISCV_ISA_EXT | KVM_REG_RISCV_ISA_SINGLE | KVM_RISCV_ISA_EXT_ZICOND:
76 	case KVM_REG_RISCV_ISA_EXT | KVM_REG_RISCV_ISA_SINGLE | KVM_RISCV_ISA_EXT_ZICSR:
77 	case KVM_REG_RISCV_ISA_EXT | KVM_REG_RISCV_ISA_SINGLE | KVM_RISCV_ISA_EXT_ZIFENCEI:
78 	case KVM_REG_RISCV_ISA_EXT | KVM_REG_RISCV_ISA_SINGLE | KVM_RISCV_ISA_EXT_ZIHINTNTL:
79 	case KVM_REG_RISCV_ISA_EXT | KVM_REG_RISCV_ISA_SINGLE | KVM_RISCV_ISA_EXT_ZIHINTPAUSE:
80 	case KVM_REG_RISCV_ISA_EXT | KVM_REG_RISCV_ISA_SINGLE | KVM_RISCV_ISA_EXT_ZIHPM:
81 	case KVM_REG_RISCV_ISA_EXT | KVM_REG_RISCV_ISA_SINGLE | KVM_RISCV_ISA_EXT_ZIMOP:
82 	case KVM_REG_RISCV_ISA_EXT | KVM_REG_RISCV_ISA_SINGLE | KVM_RISCV_ISA_EXT_ZKND:
83 	case KVM_REG_RISCV_ISA_EXT | KVM_REG_RISCV_ISA_SINGLE | KVM_RISCV_ISA_EXT_ZKNE:
84 	case KVM_REG_RISCV_ISA_EXT | KVM_REG_RISCV_ISA_SINGLE | KVM_RISCV_ISA_EXT_ZKNH:
85 	case KVM_REG_RISCV_ISA_EXT | KVM_REG_RISCV_ISA_SINGLE | KVM_RISCV_ISA_EXT_ZKR:
86 	case KVM_REG_RISCV_ISA_EXT | KVM_REG_RISCV_ISA_SINGLE | KVM_RISCV_ISA_EXT_ZKSED:
87 	case KVM_REG_RISCV_ISA_EXT | KVM_REG_RISCV_ISA_SINGLE | KVM_RISCV_ISA_EXT_ZKSH:
88 	case KVM_REG_RISCV_ISA_EXT | KVM_REG_RISCV_ISA_SINGLE | KVM_RISCV_ISA_EXT_ZKT:
89 	case KVM_REG_RISCV_ISA_EXT | KVM_REG_RISCV_ISA_SINGLE | KVM_RISCV_ISA_EXT_ZTSO:
90 	case KVM_REG_RISCV_ISA_EXT | KVM_REG_RISCV_ISA_SINGLE | KVM_RISCV_ISA_EXT_ZVBB:
91 	case KVM_REG_RISCV_ISA_EXT | KVM_REG_RISCV_ISA_SINGLE | KVM_RISCV_ISA_EXT_ZVBC:
92 	case KVM_REG_RISCV_ISA_EXT | KVM_REG_RISCV_ISA_SINGLE | KVM_RISCV_ISA_EXT_ZVFH:
93 	case KVM_REG_RISCV_ISA_EXT | KVM_REG_RISCV_ISA_SINGLE | KVM_RISCV_ISA_EXT_ZVFHMIN:
94 	case KVM_REG_RISCV_ISA_EXT | KVM_REG_RISCV_ISA_SINGLE | KVM_RISCV_ISA_EXT_ZVKB:
95 	case KVM_REG_RISCV_ISA_EXT | KVM_REG_RISCV_ISA_SINGLE | KVM_RISCV_ISA_EXT_ZVKG:
96 	case KVM_REG_RISCV_ISA_EXT | KVM_REG_RISCV_ISA_SINGLE | KVM_RISCV_ISA_EXT_ZVKNED:
97 	case KVM_REG_RISCV_ISA_EXT | KVM_REG_RISCV_ISA_SINGLE | KVM_RISCV_ISA_EXT_ZVKNHA:
98 	case KVM_REG_RISCV_ISA_EXT | KVM_REG_RISCV_ISA_SINGLE | KVM_RISCV_ISA_EXT_ZVKNHB:
99 	case KVM_REG_RISCV_ISA_EXT | KVM_REG_RISCV_ISA_SINGLE | KVM_RISCV_ISA_EXT_ZVKSED:
100 	case KVM_REG_RISCV_ISA_EXT | KVM_REG_RISCV_ISA_SINGLE | KVM_RISCV_ISA_EXT_ZVKSH:
101 	case KVM_REG_RISCV_ISA_EXT | KVM_REG_RISCV_ISA_SINGLE | KVM_RISCV_ISA_EXT_ZVKT:
102 	/*
103 	 * Like ISA_EXT registers, SBI_EXT registers are only visible when the
104 	 * host supports them and disabling them does not affect the visibility
105 	 * of the SBI_EXT register itself.
106 	 */
107 	case KVM_REG_RISCV_SBI_EXT | KVM_REG_RISCV_SBI_SINGLE | KVM_RISCV_SBI_EXT_V01:
108 	case KVM_REG_RISCV_SBI_EXT | KVM_REG_RISCV_SBI_SINGLE | KVM_RISCV_SBI_EXT_TIME:
109 	case KVM_REG_RISCV_SBI_EXT | KVM_REG_RISCV_SBI_SINGLE | KVM_RISCV_SBI_EXT_IPI:
110 	case KVM_REG_RISCV_SBI_EXT | KVM_REG_RISCV_SBI_SINGLE | KVM_RISCV_SBI_EXT_RFENCE:
111 	case KVM_REG_RISCV_SBI_EXT | KVM_REG_RISCV_SBI_SINGLE | KVM_RISCV_SBI_EXT_SRST:
112 	case KVM_REG_RISCV_SBI_EXT | KVM_REG_RISCV_SBI_SINGLE | KVM_RISCV_SBI_EXT_HSM:
113 	case KVM_REG_RISCV_SBI_EXT | KVM_REG_RISCV_SBI_SINGLE | KVM_RISCV_SBI_EXT_PMU:
114 	case KVM_REG_RISCV_SBI_EXT | KVM_REG_RISCV_SBI_SINGLE | KVM_RISCV_SBI_EXT_DBCN:
115 	case KVM_REG_RISCV_SBI_EXT | KVM_REG_RISCV_SBI_SINGLE | KVM_RISCV_SBI_EXT_STA:
116 	case KVM_REG_RISCV_SBI_EXT | KVM_REG_RISCV_SBI_SINGLE | KVM_RISCV_SBI_EXT_EXPERIMENTAL:
117 	case KVM_REG_RISCV_SBI_EXT | KVM_REG_RISCV_SBI_SINGLE | KVM_RISCV_SBI_EXT_VENDOR:
118 		return true;
119 	/* AIA registers are always available when Ssaia can't be disabled */
120 	case KVM_REG_RISCV_CSR | KVM_REG_RISCV_CSR_AIA | KVM_REG_RISCV_CSR_AIA_REG(siselect):
121 	case KVM_REG_RISCV_CSR | KVM_REG_RISCV_CSR_AIA | KVM_REG_RISCV_CSR_AIA_REG(iprio1):
122 	case KVM_REG_RISCV_CSR | KVM_REG_RISCV_CSR_AIA | KVM_REG_RISCV_CSR_AIA_REG(iprio2):
123 	case KVM_REG_RISCV_CSR | KVM_REG_RISCV_CSR_AIA | KVM_REG_RISCV_CSR_AIA_REG(sieh):
124 	case KVM_REG_RISCV_CSR | KVM_REG_RISCV_CSR_AIA | KVM_REG_RISCV_CSR_AIA_REG(siph):
125 	case KVM_REG_RISCV_CSR | KVM_REG_RISCV_CSR_AIA | KVM_REG_RISCV_CSR_AIA_REG(iprio1h):
126 	case KVM_REG_RISCV_CSR | KVM_REG_RISCV_CSR_AIA | KVM_REG_RISCV_CSR_AIA_REG(iprio2h):
127 		return isa_ext_cant_disable[KVM_RISCV_ISA_EXT_SSAIA];
128 	default:
129 		break;
130 	}
131 
132 	return false;
133 }
134 
check_reject_set(int err)135 bool check_reject_set(int err)
136 {
137 	return err == EINVAL;
138 }
139 
finalize_vcpu(struct kvm_vcpu * vcpu,struct vcpu_reg_list * c)140 void finalize_vcpu(struct kvm_vcpu *vcpu, struct vcpu_reg_list *c)
141 {
142 	unsigned long isa_ext_state[KVM_RISCV_ISA_EXT_MAX] = { 0 };
143 	struct vcpu_reg_sublist *s;
144 	uint64_t feature;
145 	int rc;
146 
147 	for (int i = 0; i < KVM_RISCV_ISA_EXT_MAX; i++)
148 		__vcpu_get_reg(vcpu, RISCV_ISA_EXT_REG(i), &isa_ext_state[i]);
149 
150 	/*
151 	 * Disable all extensions which were enabled by default
152 	 * if they were available in the risc-v host.
153 	 */
154 	for (int i = 0; i < KVM_RISCV_ISA_EXT_MAX; i++) {
155 		rc = __vcpu_set_reg(vcpu, RISCV_ISA_EXT_REG(i), 0);
156 		if (rc && isa_ext_state[i])
157 			isa_ext_cant_disable[i] = true;
158 	}
159 
160 	for (int i = 0; i < KVM_RISCV_SBI_EXT_MAX; i++) {
161 		rc = __vcpu_set_reg(vcpu, RISCV_SBI_EXT_REG(i), 0);
162 		TEST_ASSERT(!rc || (rc == -1 && errno == ENOENT), "Unexpected error");
163 	}
164 
165 	for_each_sublist(c, s) {
166 		if (!s->feature)
167 			continue;
168 
169 		switch (s->feature_type) {
170 		case VCPU_FEATURE_ISA_EXT:
171 			feature = RISCV_ISA_EXT_REG(s->feature);
172 			break;
173 		case VCPU_FEATURE_SBI_EXT:
174 			feature = RISCV_SBI_EXT_REG(s->feature);
175 			break;
176 		default:
177 			TEST_FAIL("Unknown feature type");
178 		}
179 
180 		/* Try to enable the desired extension */
181 		__vcpu_set_reg(vcpu, feature, 1);
182 
183 		/* Double check whether the desired extension was enabled */
184 		__TEST_REQUIRE(__vcpu_has_ext(vcpu, feature),
185 			       "%s not available, skipping tests", s->name);
186 	}
187 }
188 
config_id_to_str(const char * prefix,__u64 id)189 static const char *config_id_to_str(const char *prefix, __u64 id)
190 {
191 	/* reg_off is the offset into struct kvm_riscv_config */
192 	__u64 reg_off = id & ~(REG_MASK | KVM_REG_RISCV_CONFIG);
193 
194 	assert((id & KVM_REG_RISCV_TYPE_MASK) == KVM_REG_RISCV_CONFIG);
195 
196 	switch (reg_off) {
197 	case KVM_REG_RISCV_CONFIG_REG(isa):
198 		return "KVM_REG_RISCV_CONFIG_REG(isa)";
199 	case KVM_REG_RISCV_CONFIG_REG(zicbom_block_size):
200 		return "KVM_REG_RISCV_CONFIG_REG(zicbom_block_size)";
201 	case KVM_REG_RISCV_CONFIG_REG(zicboz_block_size):
202 		return "KVM_REG_RISCV_CONFIG_REG(zicboz_block_size)";
203 	case KVM_REG_RISCV_CONFIG_REG(mvendorid):
204 		return "KVM_REG_RISCV_CONFIG_REG(mvendorid)";
205 	case KVM_REG_RISCV_CONFIG_REG(marchid):
206 		return "KVM_REG_RISCV_CONFIG_REG(marchid)";
207 	case KVM_REG_RISCV_CONFIG_REG(mimpid):
208 		return "KVM_REG_RISCV_CONFIG_REG(mimpid)";
209 	case KVM_REG_RISCV_CONFIG_REG(satp_mode):
210 		return "KVM_REG_RISCV_CONFIG_REG(satp_mode)";
211 	}
212 
213 	return strdup_printf("%lld /* UNKNOWN */", reg_off);
214 }
215 
core_id_to_str(const char * prefix,__u64 id)216 static const char *core_id_to_str(const char *prefix, __u64 id)
217 {
218 	/* reg_off is the offset into struct kvm_riscv_core */
219 	__u64 reg_off = id & ~(REG_MASK | KVM_REG_RISCV_CORE);
220 
221 	assert((id & KVM_REG_RISCV_TYPE_MASK) == KVM_REG_RISCV_CORE);
222 
223 	switch (reg_off) {
224 	case KVM_REG_RISCV_CORE_REG(regs.pc):
225 		return "KVM_REG_RISCV_CORE_REG(regs.pc)";
226 	case KVM_REG_RISCV_CORE_REG(regs.ra):
227 		return "KVM_REG_RISCV_CORE_REG(regs.ra)";
228 	case KVM_REG_RISCV_CORE_REG(regs.sp):
229 		return "KVM_REG_RISCV_CORE_REG(regs.sp)";
230 	case KVM_REG_RISCV_CORE_REG(regs.gp):
231 		return "KVM_REG_RISCV_CORE_REG(regs.gp)";
232 	case KVM_REG_RISCV_CORE_REG(regs.tp):
233 		return "KVM_REG_RISCV_CORE_REG(regs.tp)";
234 	case KVM_REG_RISCV_CORE_REG(regs.t0) ... KVM_REG_RISCV_CORE_REG(regs.t2):
235 		return strdup_printf("KVM_REG_RISCV_CORE_REG(regs.t%lld)",
236 			   reg_off - KVM_REG_RISCV_CORE_REG(regs.t0));
237 	case KVM_REG_RISCV_CORE_REG(regs.s0) ... KVM_REG_RISCV_CORE_REG(regs.s1):
238 		return strdup_printf("KVM_REG_RISCV_CORE_REG(regs.s%lld)",
239 			   reg_off - KVM_REG_RISCV_CORE_REG(regs.s0));
240 	case KVM_REG_RISCV_CORE_REG(regs.a0) ... KVM_REG_RISCV_CORE_REG(regs.a7):
241 		return strdup_printf("KVM_REG_RISCV_CORE_REG(regs.a%lld)",
242 			   reg_off - KVM_REG_RISCV_CORE_REG(regs.a0));
243 	case KVM_REG_RISCV_CORE_REG(regs.s2) ... KVM_REG_RISCV_CORE_REG(regs.s11):
244 		return strdup_printf("KVM_REG_RISCV_CORE_REG(regs.s%lld)",
245 			   reg_off - KVM_REG_RISCV_CORE_REG(regs.s2) + 2);
246 	case KVM_REG_RISCV_CORE_REG(regs.t3) ... KVM_REG_RISCV_CORE_REG(regs.t6):
247 		return strdup_printf("KVM_REG_RISCV_CORE_REG(regs.t%lld)",
248 			   reg_off - KVM_REG_RISCV_CORE_REG(regs.t3) + 3);
249 	case KVM_REG_RISCV_CORE_REG(mode):
250 		return "KVM_REG_RISCV_CORE_REG(mode)";
251 	}
252 
253 	return strdup_printf("%lld /* UNKNOWN */", reg_off);
254 }
255 
256 #define RISCV_CSR_GENERAL(csr) \
257 	"KVM_REG_RISCV_CSR_GENERAL | KVM_REG_RISCV_CSR_REG(" #csr ")"
258 #define RISCV_CSR_AIA(csr) \
259 	"KVM_REG_RISCV_CSR_AIA | KVM_REG_RISCV_CSR_REG(" #csr ")"
260 #define RISCV_CSR_SMSTATEEN(csr) \
261 	"KVM_REG_RISCV_CSR_SMSTATEEN | KVM_REG_RISCV_CSR_REG(" #csr ")"
262 
general_csr_id_to_str(__u64 reg_off)263 static const char *general_csr_id_to_str(__u64 reg_off)
264 {
265 	/* reg_off is the offset into struct kvm_riscv_csr */
266 	switch (reg_off) {
267 	case KVM_REG_RISCV_CSR_REG(sstatus):
268 		return RISCV_CSR_GENERAL(sstatus);
269 	case KVM_REG_RISCV_CSR_REG(sie):
270 		return RISCV_CSR_GENERAL(sie);
271 	case KVM_REG_RISCV_CSR_REG(stvec):
272 		return RISCV_CSR_GENERAL(stvec);
273 	case KVM_REG_RISCV_CSR_REG(sscratch):
274 		return RISCV_CSR_GENERAL(sscratch);
275 	case KVM_REG_RISCV_CSR_REG(sepc):
276 		return RISCV_CSR_GENERAL(sepc);
277 	case KVM_REG_RISCV_CSR_REG(scause):
278 		return RISCV_CSR_GENERAL(scause);
279 	case KVM_REG_RISCV_CSR_REG(stval):
280 		return RISCV_CSR_GENERAL(stval);
281 	case KVM_REG_RISCV_CSR_REG(sip):
282 		return RISCV_CSR_GENERAL(sip);
283 	case KVM_REG_RISCV_CSR_REG(satp):
284 		return RISCV_CSR_GENERAL(satp);
285 	case KVM_REG_RISCV_CSR_REG(scounteren):
286 		return RISCV_CSR_GENERAL(scounteren);
287 	case KVM_REG_RISCV_CSR_REG(senvcfg):
288 		return RISCV_CSR_GENERAL(senvcfg);
289 	}
290 
291 	return strdup_printf("KVM_REG_RISCV_CSR_GENERAL | %lld /* UNKNOWN */", reg_off);
292 }
293 
aia_csr_id_to_str(__u64 reg_off)294 static const char *aia_csr_id_to_str(__u64 reg_off)
295 {
296 	/* reg_off is the offset into struct kvm_riscv_aia_csr */
297 	switch (reg_off) {
298 	case KVM_REG_RISCV_CSR_AIA_REG(siselect):
299 		return RISCV_CSR_AIA(siselect);
300 	case KVM_REG_RISCV_CSR_AIA_REG(iprio1):
301 		return RISCV_CSR_AIA(iprio1);
302 	case KVM_REG_RISCV_CSR_AIA_REG(iprio2):
303 		return RISCV_CSR_AIA(iprio2);
304 	case KVM_REG_RISCV_CSR_AIA_REG(sieh):
305 		return RISCV_CSR_AIA(sieh);
306 	case KVM_REG_RISCV_CSR_AIA_REG(siph):
307 		return RISCV_CSR_AIA(siph);
308 	case KVM_REG_RISCV_CSR_AIA_REG(iprio1h):
309 		return RISCV_CSR_AIA(iprio1h);
310 	case KVM_REG_RISCV_CSR_AIA_REG(iprio2h):
311 		return RISCV_CSR_AIA(iprio2h);
312 	}
313 
314 	return strdup_printf("KVM_REG_RISCV_CSR_AIA | %lld /* UNKNOWN */", reg_off);
315 }
316 
smstateen_csr_id_to_str(__u64 reg_off)317 static const char *smstateen_csr_id_to_str(__u64 reg_off)
318 {
319 	/* reg_off is the offset into struct kvm_riscv_smstateen_csr */
320 	switch (reg_off) {
321 	case KVM_REG_RISCV_CSR_SMSTATEEN_REG(sstateen0):
322 		return RISCV_CSR_SMSTATEEN(sstateen0);
323 	}
324 
325 	TEST_FAIL("Unknown smstateen csr reg: 0x%llx", reg_off);
326 	return NULL;
327 }
328 
csr_id_to_str(const char * prefix,__u64 id)329 static const char *csr_id_to_str(const char *prefix, __u64 id)
330 {
331 	__u64 reg_off = id & ~(REG_MASK | KVM_REG_RISCV_CSR);
332 	__u64 reg_subtype = reg_off & KVM_REG_RISCV_SUBTYPE_MASK;
333 
334 	assert((id & KVM_REG_RISCV_TYPE_MASK) == KVM_REG_RISCV_CSR);
335 
336 	reg_off &= ~KVM_REG_RISCV_SUBTYPE_MASK;
337 
338 	switch (reg_subtype) {
339 	case KVM_REG_RISCV_CSR_GENERAL:
340 		return general_csr_id_to_str(reg_off);
341 	case KVM_REG_RISCV_CSR_AIA:
342 		return aia_csr_id_to_str(reg_off);
343 	case KVM_REG_RISCV_CSR_SMSTATEEN:
344 		return smstateen_csr_id_to_str(reg_off);
345 	}
346 
347 	return strdup_printf("%lld | %lld /* UNKNOWN */", reg_subtype, reg_off);
348 }
349 
timer_id_to_str(const char * prefix,__u64 id)350 static const char *timer_id_to_str(const char *prefix, __u64 id)
351 {
352 	/* reg_off is the offset into struct kvm_riscv_timer */
353 	__u64 reg_off = id & ~(REG_MASK | KVM_REG_RISCV_TIMER);
354 
355 	assert((id & KVM_REG_RISCV_TYPE_MASK) == KVM_REG_RISCV_TIMER);
356 
357 	switch (reg_off) {
358 	case KVM_REG_RISCV_TIMER_REG(frequency):
359 		return "KVM_REG_RISCV_TIMER_REG(frequency)";
360 	case KVM_REG_RISCV_TIMER_REG(time):
361 		return "KVM_REG_RISCV_TIMER_REG(time)";
362 	case KVM_REG_RISCV_TIMER_REG(compare):
363 		return "KVM_REG_RISCV_TIMER_REG(compare)";
364 	case KVM_REG_RISCV_TIMER_REG(state):
365 		return "KVM_REG_RISCV_TIMER_REG(state)";
366 	}
367 
368 	return strdup_printf("%lld /* UNKNOWN */", reg_off);
369 }
370 
fp_f_id_to_str(const char * prefix,__u64 id)371 static const char *fp_f_id_to_str(const char *prefix, __u64 id)
372 {
373 	/* reg_off is the offset into struct __riscv_f_ext_state */
374 	__u64 reg_off = id & ~(REG_MASK | KVM_REG_RISCV_FP_F);
375 
376 	assert((id & KVM_REG_RISCV_TYPE_MASK) == KVM_REG_RISCV_FP_F);
377 
378 	switch (reg_off) {
379 	case KVM_REG_RISCV_FP_F_REG(f[0]) ...
380 	     KVM_REG_RISCV_FP_F_REG(f[31]):
381 		return strdup_printf("KVM_REG_RISCV_FP_F_REG(f[%lld])", reg_off);
382 	case KVM_REG_RISCV_FP_F_REG(fcsr):
383 		return "KVM_REG_RISCV_FP_F_REG(fcsr)";
384 	}
385 
386 	return strdup_printf("%lld /* UNKNOWN */", reg_off);
387 }
388 
fp_d_id_to_str(const char * prefix,__u64 id)389 static const char *fp_d_id_to_str(const char *prefix, __u64 id)
390 {
391 	/* reg_off is the offset into struct __riscv_d_ext_state */
392 	__u64 reg_off = id & ~(REG_MASK | KVM_REG_RISCV_FP_D);
393 
394 	assert((id & KVM_REG_RISCV_TYPE_MASK) == KVM_REG_RISCV_FP_D);
395 
396 	switch (reg_off) {
397 	case KVM_REG_RISCV_FP_D_REG(f[0]) ...
398 	     KVM_REG_RISCV_FP_D_REG(f[31]):
399 		return strdup_printf("KVM_REG_RISCV_FP_D_REG(f[%lld])", reg_off);
400 	case KVM_REG_RISCV_FP_D_REG(fcsr):
401 		return "KVM_REG_RISCV_FP_D_REG(fcsr)";
402 	}
403 
404 	return strdup_printf("%lld /* UNKNOWN */", reg_off);
405 }
406 
407 #define KVM_ISA_EXT_ARR(ext)		\
408 [KVM_RISCV_ISA_EXT_##ext] = "KVM_REG_RISCV_ISA_SINGLE | KVM_RISCV_ISA_EXT_" #ext
409 
isa_ext_single_id_to_str(__u64 reg_off)410 static const char *isa_ext_single_id_to_str(__u64 reg_off)
411 {
412 	static const char * const kvm_isa_ext_reg_name[] = {
413 		KVM_ISA_EXT_ARR(A),
414 		KVM_ISA_EXT_ARR(C),
415 		KVM_ISA_EXT_ARR(D),
416 		KVM_ISA_EXT_ARR(F),
417 		KVM_ISA_EXT_ARR(H),
418 		KVM_ISA_EXT_ARR(I),
419 		KVM_ISA_EXT_ARR(M),
420 		KVM_ISA_EXT_ARR(V),
421 		KVM_ISA_EXT_ARR(SMNPM),
422 		KVM_ISA_EXT_ARR(SMSTATEEN),
423 		KVM_ISA_EXT_ARR(SSAIA),
424 		KVM_ISA_EXT_ARR(SSCOFPMF),
425 		KVM_ISA_EXT_ARR(SSNPM),
426 		KVM_ISA_EXT_ARR(SSTC),
427 		KVM_ISA_EXT_ARR(SVADE),
428 		KVM_ISA_EXT_ARR(SVADU),
429 		KVM_ISA_EXT_ARR(SVINVAL),
430 		KVM_ISA_EXT_ARR(SVNAPOT),
431 		KVM_ISA_EXT_ARR(SVPBMT),
432 		KVM_ISA_EXT_ARR(ZACAS),
433 		KVM_ISA_EXT_ARR(ZAWRS),
434 		KVM_ISA_EXT_ARR(ZBA),
435 		KVM_ISA_EXT_ARR(ZBB),
436 		KVM_ISA_EXT_ARR(ZBC),
437 		KVM_ISA_EXT_ARR(ZBKB),
438 		KVM_ISA_EXT_ARR(ZBKC),
439 		KVM_ISA_EXT_ARR(ZBKX),
440 		KVM_ISA_EXT_ARR(ZBS),
441 		KVM_ISA_EXT_ARR(ZCA),
442 		KVM_ISA_EXT_ARR(ZCB),
443 		KVM_ISA_EXT_ARR(ZCD),
444 		KVM_ISA_EXT_ARR(ZCF),
445 		KVM_ISA_EXT_ARR(ZCMOP),
446 		KVM_ISA_EXT_ARR(ZFA),
447 		KVM_ISA_EXT_ARR(ZFH),
448 		KVM_ISA_EXT_ARR(ZFHMIN),
449 		KVM_ISA_EXT_ARR(ZICBOM),
450 		KVM_ISA_EXT_ARR(ZICBOZ),
451 		KVM_ISA_EXT_ARR(ZICNTR),
452 		KVM_ISA_EXT_ARR(ZICOND),
453 		KVM_ISA_EXT_ARR(ZICSR),
454 		KVM_ISA_EXT_ARR(ZIFENCEI),
455 		KVM_ISA_EXT_ARR(ZIHINTNTL),
456 		KVM_ISA_EXT_ARR(ZIHINTPAUSE),
457 		KVM_ISA_EXT_ARR(ZIHPM),
458 		KVM_ISA_EXT_ARR(ZIMOP),
459 		KVM_ISA_EXT_ARR(ZKND),
460 		KVM_ISA_EXT_ARR(ZKNE),
461 		KVM_ISA_EXT_ARR(ZKNH),
462 		KVM_ISA_EXT_ARR(ZKR),
463 		KVM_ISA_EXT_ARR(ZKSED),
464 		KVM_ISA_EXT_ARR(ZKSH),
465 		KVM_ISA_EXT_ARR(ZKT),
466 		KVM_ISA_EXT_ARR(ZTSO),
467 		KVM_ISA_EXT_ARR(ZVBB),
468 		KVM_ISA_EXT_ARR(ZVBC),
469 		KVM_ISA_EXT_ARR(ZVFH),
470 		KVM_ISA_EXT_ARR(ZVFHMIN),
471 		KVM_ISA_EXT_ARR(ZVKB),
472 		KVM_ISA_EXT_ARR(ZVKG),
473 		KVM_ISA_EXT_ARR(ZVKNED),
474 		KVM_ISA_EXT_ARR(ZVKNHA),
475 		KVM_ISA_EXT_ARR(ZVKNHB),
476 		KVM_ISA_EXT_ARR(ZVKSED),
477 		KVM_ISA_EXT_ARR(ZVKSH),
478 		KVM_ISA_EXT_ARR(ZVKT),
479 	};
480 
481 	if (reg_off >= ARRAY_SIZE(kvm_isa_ext_reg_name))
482 		return strdup_printf("KVM_REG_RISCV_ISA_SINGLE | %lld /* UNKNOWN */", reg_off);
483 
484 	return kvm_isa_ext_reg_name[reg_off];
485 }
486 
isa_ext_multi_id_to_str(__u64 reg_subtype,__u64 reg_off)487 static const char *isa_ext_multi_id_to_str(__u64 reg_subtype, __u64 reg_off)
488 {
489 	const char *unknown = "";
490 
491 	if (reg_off > KVM_REG_RISCV_ISA_MULTI_REG_LAST)
492 		unknown = " /* UNKNOWN */";
493 
494 	switch (reg_subtype) {
495 	case KVM_REG_RISCV_ISA_MULTI_EN:
496 		return strdup_printf("KVM_REG_RISCV_ISA_MULTI_EN | %lld%s", reg_off, unknown);
497 	case KVM_REG_RISCV_ISA_MULTI_DIS:
498 		return strdup_printf("KVM_REG_RISCV_ISA_MULTI_DIS | %lld%s", reg_off, unknown);
499 	}
500 
501 	return strdup_printf("%lld | %lld /* UNKNOWN */", reg_subtype, reg_off);
502 }
503 
isa_ext_id_to_str(const char * prefix,__u64 id)504 static const char *isa_ext_id_to_str(const char *prefix, __u64 id)
505 {
506 	__u64 reg_off = id & ~(REG_MASK | KVM_REG_RISCV_ISA_EXT);
507 	__u64 reg_subtype = reg_off & KVM_REG_RISCV_SUBTYPE_MASK;
508 
509 	assert((id & KVM_REG_RISCV_TYPE_MASK) == KVM_REG_RISCV_ISA_EXT);
510 
511 	reg_off &= ~KVM_REG_RISCV_SUBTYPE_MASK;
512 
513 	switch (reg_subtype) {
514 	case KVM_REG_RISCV_ISA_SINGLE:
515 		return isa_ext_single_id_to_str(reg_off);
516 	case KVM_REG_RISCV_ISA_MULTI_EN:
517 	case KVM_REG_RISCV_ISA_MULTI_DIS:
518 		return isa_ext_multi_id_to_str(reg_subtype, reg_off);
519 	}
520 
521 	return strdup_printf("%lld | %lld /* UNKNOWN */", reg_subtype, reg_off);
522 }
523 
524 #define KVM_SBI_EXT_ARR(ext)		\
525 [ext] = "KVM_REG_RISCV_SBI_SINGLE | " #ext
526 
sbi_ext_single_id_to_str(__u64 reg_off)527 static const char *sbi_ext_single_id_to_str(__u64 reg_off)
528 {
529 	/* reg_off is KVM_RISCV_SBI_EXT_ID */
530 	static const char * const kvm_sbi_ext_reg_name[] = {
531 		KVM_SBI_EXT_ARR(KVM_RISCV_SBI_EXT_V01),
532 		KVM_SBI_EXT_ARR(KVM_RISCV_SBI_EXT_TIME),
533 		KVM_SBI_EXT_ARR(KVM_RISCV_SBI_EXT_IPI),
534 		KVM_SBI_EXT_ARR(KVM_RISCV_SBI_EXT_RFENCE),
535 		KVM_SBI_EXT_ARR(KVM_RISCV_SBI_EXT_SRST),
536 		KVM_SBI_EXT_ARR(KVM_RISCV_SBI_EXT_HSM),
537 		KVM_SBI_EXT_ARR(KVM_RISCV_SBI_EXT_PMU),
538 		KVM_SBI_EXT_ARR(KVM_RISCV_SBI_EXT_STA),
539 		KVM_SBI_EXT_ARR(KVM_RISCV_SBI_EXT_EXPERIMENTAL),
540 		KVM_SBI_EXT_ARR(KVM_RISCV_SBI_EXT_VENDOR),
541 		KVM_SBI_EXT_ARR(KVM_RISCV_SBI_EXT_DBCN),
542 	};
543 
544 	if (reg_off >= ARRAY_SIZE(kvm_sbi_ext_reg_name))
545 		return strdup_printf("KVM_REG_RISCV_SBI_SINGLE | %lld /* UNKNOWN */", reg_off);
546 
547 	return kvm_sbi_ext_reg_name[reg_off];
548 }
549 
sbi_ext_multi_id_to_str(__u64 reg_subtype,__u64 reg_off)550 static const char *sbi_ext_multi_id_to_str(__u64 reg_subtype, __u64 reg_off)
551 {
552 	const char *unknown = "";
553 
554 	if (reg_off > KVM_REG_RISCV_SBI_MULTI_REG_LAST)
555 		unknown = " /* UNKNOWN */";
556 
557 	switch (reg_subtype) {
558 	case KVM_REG_RISCV_SBI_MULTI_EN:
559 		return strdup_printf("KVM_REG_RISCV_SBI_MULTI_EN | %lld%s", reg_off, unknown);
560 	case KVM_REG_RISCV_SBI_MULTI_DIS:
561 		return strdup_printf("KVM_REG_RISCV_SBI_MULTI_DIS | %lld%s", reg_off, unknown);
562 	}
563 
564 	return strdup_printf("%lld | %lld /* UNKNOWN */", reg_subtype, reg_off);
565 }
566 
sbi_ext_id_to_str(const char * prefix,__u64 id)567 static const char *sbi_ext_id_to_str(const char *prefix, __u64 id)
568 {
569 	__u64 reg_off = id & ~(REG_MASK | KVM_REG_RISCV_SBI_EXT);
570 	__u64 reg_subtype = reg_off & KVM_REG_RISCV_SUBTYPE_MASK;
571 
572 	assert((id & KVM_REG_RISCV_TYPE_MASK) == KVM_REG_RISCV_SBI_EXT);
573 
574 	reg_off &= ~KVM_REG_RISCV_SUBTYPE_MASK;
575 
576 	switch (reg_subtype) {
577 	case KVM_REG_RISCV_SBI_SINGLE:
578 		return sbi_ext_single_id_to_str(reg_off);
579 	case KVM_REG_RISCV_SBI_MULTI_EN:
580 	case KVM_REG_RISCV_SBI_MULTI_DIS:
581 		return sbi_ext_multi_id_to_str(reg_subtype, reg_off);
582 	}
583 
584 	return strdup_printf("%lld | %lld /* UNKNOWN */", reg_subtype, reg_off);
585 }
586 
sbi_sta_id_to_str(__u64 reg_off)587 static const char *sbi_sta_id_to_str(__u64 reg_off)
588 {
589 	switch (reg_off) {
590 	case 0: return "KVM_REG_RISCV_SBI_STA | KVM_REG_RISCV_SBI_STA_REG(shmem_lo)";
591 	case 1: return "KVM_REG_RISCV_SBI_STA | KVM_REG_RISCV_SBI_STA_REG(shmem_hi)";
592 	}
593 	return strdup_printf("KVM_REG_RISCV_SBI_STA | %lld /* UNKNOWN */", reg_off);
594 }
595 
sbi_id_to_str(const char * prefix,__u64 id)596 static const char *sbi_id_to_str(const char *prefix, __u64 id)
597 {
598 	__u64 reg_off = id & ~(REG_MASK | KVM_REG_RISCV_SBI_STATE);
599 	__u64 reg_subtype = reg_off & KVM_REG_RISCV_SUBTYPE_MASK;
600 
601 	assert((id & KVM_REG_RISCV_TYPE_MASK) == KVM_REG_RISCV_SBI_STATE);
602 
603 	reg_off &= ~KVM_REG_RISCV_SUBTYPE_MASK;
604 
605 	switch (reg_subtype) {
606 	case KVM_REG_RISCV_SBI_STA:
607 		return sbi_sta_id_to_str(reg_off);
608 	}
609 
610 	return strdup_printf("%lld | %lld /* UNKNOWN */", reg_subtype, reg_off);
611 }
612 
print_reg(const char * prefix,__u64 id)613 void print_reg(const char *prefix, __u64 id)
614 {
615 	const char *reg_size = NULL;
616 
617 	TEST_ASSERT((id & KVM_REG_ARCH_MASK) == KVM_REG_RISCV,
618 		    "%s: KVM_REG_RISCV missing in reg id: 0x%llx", prefix, id);
619 
620 	switch (id & KVM_REG_SIZE_MASK) {
621 	case KVM_REG_SIZE_U32:
622 		reg_size = "KVM_REG_SIZE_U32";
623 		break;
624 	case KVM_REG_SIZE_U64:
625 		reg_size = "KVM_REG_SIZE_U64";
626 		break;
627 	case KVM_REG_SIZE_U128:
628 		reg_size = "KVM_REG_SIZE_U128";
629 		break;
630 	default:
631 		printf("\tKVM_REG_RISCV | (%lld << KVM_REG_SIZE_SHIFT) | 0x%llx /* UNKNOWN */,\n",
632 		       (id & KVM_REG_SIZE_MASK) >> KVM_REG_SIZE_SHIFT, id & ~REG_MASK);
633 		return;
634 	}
635 
636 	switch (id & KVM_REG_RISCV_TYPE_MASK) {
637 	case KVM_REG_RISCV_CONFIG:
638 		printf("\tKVM_REG_RISCV | %s | KVM_REG_RISCV_CONFIG | %s,\n",
639 				reg_size, config_id_to_str(prefix, id));
640 		break;
641 	case KVM_REG_RISCV_CORE:
642 		printf("\tKVM_REG_RISCV | %s | KVM_REG_RISCV_CORE | %s,\n",
643 				reg_size, core_id_to_str(prefix, id));
644 		break;
645 	case KVM_REG_RISCV_CSR:
646 		printf("\tKVM_REG_RISCV | %s | KVM_REG_RISCV_CSR | %s,\n",
647 				reg_size, csr_id_to_str(prefix, id));
648 		break;
649 	case KVM_REG_RISCV_TIMER:
650 		printf("\tKVM_REG_RISCV | %s | KVM_REG_RISCV_TIMER | %s,\n",
651 				reg_size, timer_id_to_str(prefix, id));
652 		break;
653 	case KVM_REG_RISCV_FP_F:
654 		printf("\tKVM_REG_RISCV | %s | KVM_REG_RISCV_FP_F | %s,\n",
655 				reg_size, fp_f_id_to_str(prefix, id));
656 		break;
657 	case KVM_REG_RISCV_FP_D:
658 		printf("\tKVM_REG_RISCV | %s | KVM_REG_RISCV_FP_D | %s,\n",
659 				reg_size, fp_d_id_to_str(prefix, id));
660 		break;
661 	case KVM_REG_RISCV_ISA_EXT:
662 		printf("\tKVM_REG_RISCV | %s | KVM_REG_RISCV_ISA_EXT | %s,\n",
663 				reg_size, isa_ext_id_to_str(prefix, id));
664 		break;
665 	case KVM_REG_RISCV_SBI_EXT:
666 		printf("\tKVM_REG_RISCV | %s | KVM_REG_RISCV_SBI_EXT | %s,\n",
667 				reg_size, sbi_ext_id_to_str(prefix, id));
668 		break;
669 	case KVM_REG_RISCV_SBI_STATE:
670 		printf("\tKVM_REG_RISCV | %s | KVM_REG_RISCV_SBI_STATE | %s,\n",
671 				reg_size, sbi_id_to_str(prefix, id));
672 		break;
673 	default:
674 		printf("\tKVM_REG_RISCV | %s | 0x%llx /* UNKNOWN */,\n",
675 				reg_size, id & ~REG_MASK);
676 		return;
677 	}
678 }
679 
680 /*
681  * The current blessed list was primed with the output of kernel version
682  * v6.5-rc3 and then later updated with new registers.
683  */
684 static __u64 base_regs[] = {
685 	KVM_REG_RISCV | KVM_REG_SIZE_ULONG | KVM_REG_RISCV_CONFIG | KVM_REG_RISCV_CONFIG_REG(isa),
686 	KVM_REG_RISCV | KVM_REG_SIZE_ULONG | KVM_REG_RISCV_CONFIG | KVM_REG_RISCV_CONFIG_REG(mvendorid),
687 	KVM_REG_RISCV | KVM_REG_SIZE_ULONG | KVM_REG_RISCV_CONFIG | KVM_REG_RISCV_CONFIG_REG(marchid),
688 	KVM_REG_RISCV | KVM_REG_SIZE_ULONG | KVM_REG_RISCV_CONFIG | KVM_REG_RISCV_CONFIG_REG(mimpid),
689 	KVM_REG_RISCV | KVM_REG_SIZE_ULONG | KVM_REG_RISCV_CONFIG | KVM_REG_RISCV_CONFIG_REG(satp_mode),
690 	KVM_REG_RISCV | KVM_REG_SIZE_ULONG | KVM_REG_RISCV_CORE | KVM_REG_RISCV_CORE_REG(regs.pc),
691 	KVM_REG_RISCV | KVM_REG_SIZE_ULONG | KVM_REG_RISCV_CORE | KVM_REG_RISCV_CORE_REG(regs.ra),
692 	KVM_REG_RISCV | KVM_REG_SIZE_ULONG | KVM_REG_RISCV_CORE | KVM_REG_RISCV_CORE_REG(regs.sp),
693 	KVM_REG_RISCV | KVM_REG_SIZE_ULONG | KVM_REG_RISCV_CORE | KVM_REG_RISCV_CORE_REG(regs.gp),
694 	KVM_REG_RISCV | KVM_REG_SIZE_ULONG | KVM_REG_RISCV_CORE | KVM_REG_RISCV_CORE_REG(regs.tp),
695 	KVM_REG_RISCV | KVM_REG_SIZE_ULONG | KVM_REG_RISCV_CORE | KVM_REG_RISCV_CORE_REG(regs.t0),
696 	KVM_REG_RISCV | KVM_REG_SIZE_ULONG | KVM_REG_RISCV_CORE | KVM_REG_RISCV_CORE_REG(regs.t1),
697 	KVM_REG_RISCV | KVM_REG_SIZE_ULONG | KVM_REG_RISCV_CORE | KVM_REG_RISCV_CORE_REG(regs.t2),
698 	KVM_REG_RISCV | KVM_REG_SIZE_ULONG | KVM_REG_RISCV_CORE | KVM_REG_RISCV_CORE_REG(regs.s0),
699 	KVM_REG_RISCV | KVM_REG_SIZE_ULONG | KVM_REG_RISCV_CORE | KVM_REG_RISCV_CORE_REG(regs.s1),
700 	KVM_REG_RISCV | KVM_REG_SIZE_ULONG | KVM_REG_RISCV_CORE | KVM_REG_RISCV_CORE_REG(regs.a0),
701 	KVM_REG_RISCV | KVM_REG_SIZE_ULONG | KVM_REG_RISCV_CORE | KVM_REG_RISCV_CORE_REG(regs.a1),
702 	KVM_REG_RISCV | KVM_REG_SIZE_ULONG | KVM_REG_RISCV_CORE | KVM_REG_RISCV_CORE_REG(regs.a2),
703 	KVM_REG_RISCV | KVM_REG_SIZE_ULONG | KVM_REG_RISCV_CORE | KVM_REG_RISCV_CORE_REG(regs.a3),
704 	KVM_REG_RISCV | KVM_REG_SIZE_ULONG | KVM_REG_RISCV_CORE | KVM_REG_RISCV_CORE_REG(regs.a4),
705 	KVM_REG_RISCV | KVM_REG_SIZE_ULONG | KVM_REG_RISCV_CORE | KVM_REG_RISCV_CORE_REG(regs.a5),
706 	KVM_REG_RISCV | KVM_REG_SIZE_ULONG | KVM_REG_RISCV_CORE | KVM_REG_RISCV_CORE_REG(regs.a6),
707 	KVM_REG_RISCV | KVM_REG_SIZE_ULONG | KVM_REG_RISCV_CORE | KVM_REG_RISCV_CORE_REG(regs.a7),
708 	KVM_REG_RISCV | KVM_REG_SIZE_ULONG | KVM_REG_RISCV_CORE | KVM_REG_RISCV_CORE_REG(regs.s2),
709 	KVM_REG_RISCV | KVM_REG_SIZE_ULONG | KVM_REG_RISCV_CORE | KVM_REG_RISCV_CORE_REG(regs.s3),
710 	KVM_REG_RISCV | KVM_REG_SIZE_ULONG | KVM_REG_RISCV_CORE | KVM_REG_RISCV_CORE_REG(regs.s4),
711 	KVM_REG_RISCV | KVM_REG_SIZE_ULONG | KVM_REG_RISCV_CORE | KVM_REG_RISCV_CORE_REG(regs.s5),
712 	KVM_REG_RISCV | KVM_REG_SIZE_ULONG | KVM_REG_RISCV_CORE | KVM_REG_RISCV_CORE_REG(regs.s6),
713 	KVM_REG_RISCV | KVM_REG_SIZE_ULONG | KVM_REG_RISCV_CORE | KVM_REG_RISCV_CORE_REG(regs.s7),
714 	KVM_REG_RISCV | KVM_REG_SIZE_ULONG | KVM_REG_RISCV_CORE | KVM_REG_RISCV_CORE_REG(regs.s8),
715 	KVM_REG_RISCV | KVM_REG_SIZE_ULONG | KVM_REG_RISCV_CORE | KVM_REG_RISCV_CORE_REG(regs.s9),
716 	KVM_REG_RISCV | KVM_REG_SIZE_ULONG | KVM_REG_RISCV_CORE | KVM_REG_RISCV_CORE_REG(regs.s10),
717 	KVM_REG_RISCV | KVM_REG_SIZE_ULONG | KVM_REG_RISCV_CORE | KVM_REG_RISCV_CORE_REG(regs.s11),
718 	KVM_REG_RISCV | KVM_REG_SIZE_ULONG | KVM_REG_RISCV_CORE | KVM_REG_RISCV_CORE_REG(regs.t3),
719 	KVM_REG_RISCV | KVM_REG_SIZE_ULONG | KVM_REG_RISCV_CORE | KVM_REG_RISCV_CORE_REG(regs.t4),
720 	KVM_REG_RISCV | KVM_REG_SIZE_ULONG | KVM_REG_RISCV_CORE | KVM_REG_RISCV_CORE_REG(regs.t5),
721 	KVM_REG_RISCV | KVM_REG_SIZE_ULONG | KVM_REG_RISCV_CORE | KVM_REG_RISCV_CORE_REG(regs.t6),
722 	KVM_REG_RISCV | KVM_REG_SIZE_ULONG | KVM_REG_RISCV_CORE | KVM_REG_RISCV_CORE_REG(mode),
723 	KVM_REG_RISCV | KVM_REG_SIZE_ULONG | KVM_REG_RISCV_CSR | KVM_REG_RISCV_CSR_GENERAL | KVM_REG_RISCV_CSR_REG(sstatus),
724 	KVM_REG_RISCV | KVM_REG_SIZE_ULONG | KVM_REG_RISCV_CSR | KVM_REG_RISCV_CSR_GENERAL | KVM_REG_RISCV_CSR_REG(sie),
725 	KVM_REG_RISCV | KVM_REG_SIZE_ULONG | KVM_REG_RISCV_CSR | KVM_REG_RISCV_CSR_GENERAL | KVM_REG_RISCV_CSR_REG(stvec),
726 	KVM_REG_RISCV | KVM_REG_SIZE_ULONG | KVM_REG_RISCV_CSR | KVM_REG_RISCV_CSR_GENERAL | KVM_REG_RISCV_CSR_REG(sscratch),
727 	KVM_REG_RISCV | KVM_REG_SIZE_ULONG | KVM_REG_RISCV_CSR | KVM_REG_RISCV_CSR_GENERAL | KVM_REG_RISCV_CSR_REG(sepc),
728 	KVM_REG_RISCV | KVM_REG_SIZE_ULONG | KVM_REG_RISCV_CSR | KVM_REG_RISCV_CSR_GENERAL | KVM_REG_RISCV_CSR_REG(scause),
729 	KVM_REG_RISCV | KVM_REG_SIZE_ULONG | KVM_REG_RISCV_CSR | KVM_REG_RISCV_CSR_GENERAL | KVM_REG_RISCV_CSR_REG(stval),
730 	KVM_REG_RISCV | KVM_REG_SIZE_ULONG | KVM_REG_RISCV_CSR | KVM_REG_RISCV_CSR_GENERAL | KVM_REG_RISCV_CSR_REG(sip),
731 	KVM_REG_RISCV | KVM_REG_SIZE_ULONG | KVM_REG_RISCV_CSR | KVM_REG_RISCV_CSR_GENERAL | KVM_REG_RISCV_CSR_REG(satp),
732 	KVM_REG_RISCV | KVM_REG_SIZE_ULONG | KVM_REG_RISCV_CSR | KVM_REG_RISCV_CSR_GENERAL | KVM_REG_RISCV_CSR_REG(scounteren),
733 	KVM_REG_RISCV | KVM_REG_SIZE_ULONG | KVM_REG_RISCV_CSR | KVM_REG_RISCV_CSR_GENERAL | KVM_REG_RISCV_CSR_REG(senvcfg),
734 	KVM_REG_RISCV | KVM_REG_SIZE_U64 | KVM_REG_RISCV_TIMER | KVM_REG_RISCV_TIMER_REG(frequency),
735 	KVM_REG_RISCV | KVM_REG_SIZE_U64 | KVM_REG_RISCV_TIMER | KVM_REG_RISCV_TIMER_REG(time),
736 	KVM_REG_RISCV | KVM_REG_SIZE_U64 | KVM_REG_RISCV_TIMER | KVM_REG_RISCV_TIMER_REG(compare),
737 	KVM_REG_RISCV | KVM_REG_SIZE_U64 | KVM_REG_RISCV_TIMER | KVM_REG_RISCV_TIMER_REG(state),
738 };
739 
740 /*
741  * The skips_set list registers that should skip set test.
742  *  - KVM_REG_RISCV_TIMER_REG(state): set would fail if it was not initialized properly.
743  */
744 static __u64 base_skips_set[] = {
745 	KVM_REG_RISCV | KVM_REG_SIZE_U64 | KVM_REG_RISCV_TIMER | KVM_REG_RISCV_TIMER_REG(state),
746 };
747 
748 static __u64 sbi_base_regs[] = {
749 	KVM_REG_RISCV | KVM_REG_SIZE_ULONG | KVM_REG_RISCV_SBI_EXT | KVM_REG_RISCV_SBI_SINGLE | KVM_RISCV_SBI_EXT_V01,
750 	KVM_REG_RISCV | KVM_REG_SIZE_ULONG | KVM_REG_RISCV_SBI_EXT | KVM_REG_RISCV_SBI_SINGLE | KVM_RISCV_SBI_EXT_TIME,
751 	KVM_REG_RISCV | KVM_REG_SIZE_ULONG | KVM_REG_RISCV_SBI_EXT | KVM_REG_RISCV_SBI_SINGLE | KVM_RISCV_SBI_EXT_IPI,
752 	KVM_REG_RISCV | KVM_REG_SIZE_ULONG | KVM_REG_RISCV_SBI_EXT | KVM_REG_RISCV_SBI_SINGLE | KVM_RISCV_SBI_EXT_RFENCE,
753 	KVM_REG_RISCV | KVM_REG_SIZE_ULONG | KVM_REG_RISCV_SBI_EXT | KVM_REG_RISCV_SBI_SINGLE | KVM_RISCV_SBI_EXT_SRST,
754 	KVM_REG_RISCV | KVM_REG_SIZE_ULONG | KVM_REG_RISCV_SBI_EXT | KVM_REG_RISCV_SBI_SINGLE | KVM_RISCV_SBI_EXT_HSM,
755 	KVM_REG_RISCV | KVM_REG_SIZE_ULONG | KVM_REG_RISCV_SBI_EXT | KVM_REG_RISCV_SBI_SINGLE | KVM_RISCV_SBI_EXT_EXPERIMENTAL,
756 	KVM_REG_RISCV | KVM_REG_SIZE_ULONG | KVM_REG_RISCV_SBI_EXT | KVM_REG_RISCV_SBI_SINGLE | KVM_RISCV_SBI_EXT_VENDOR,
757 };
758 
759 static __u64 sbi_sta_regs[] = {
760 	KVM_REG_RISCV | KVM_REG_SIZE_ULONG | KVM_REG_RISCV_SBI_EXT | KVM_REG_RISCV_SBI_SINGLE | KVM_RISCV_SBI_EXT_STA,
761 	KVM_REG_RISCV | KVM_REG_SIZE_ULONG | KVM_REG_RISCV_SBI_STATE | KVM_REG_RISCV_SBI_STA | KVM_REG_RISCV_SBI_STA_REG(shmem_lo),
762 	KVM_REG_RISCV | KVM_REG_SIZE_ULONG | KVM_REG_RISCV_SBI_STATE | KVM_REG_RISCV_SBI_STA | KVM_REG_RISCV_SBI_STA_REG(shmem_hi),
763 };
764 
765 static __u64 zicbom_regs[] = {
766 	KVM_REG_RISCV | KVM_REG_SIZE_ULONG | KVM_REG_RISCV_CONFIG | KVM_REG_RISCV_CONFIG_REG(zicbom_block_size),
767 	KVM_REG_RISCV | KVM_REG_SIZE_ULONG | KVM_REG_RISCV_ISA_EXT | KVM_REG_RISCV_ISA_SINGLE | KVM_RISCV_ISA_EXT_ZICBOM,
768 };
769 
770 static __u64 zicboz_regs[] = {
771 	KVM_REG_RISCV | KVM_REG_SIZE_ULONG | KVM_REG_RISCV_CONFIG | KVM_REG_RISCV_CONFIG_REG(zicboz_block_size),
772 	KVM_REG_RISCV | KVM_REG_SIZE_ULONG | KVM_REG_RISCV_ISA_EXT | KVM_REG_RISCV_ISA_SINGLE | KVM_RISCV_ISA_EXT_ZICBOZ,
773 };
774 
775 static __u64 aia_regs[] = {
776 	KVM_REG_RISCV | KVM_REG_SIZE_ULONG | KVM_REG_RISCV_CSR | KVM_REG_RISCV_CSR_AIA | KVM_REG_RISCV_CSR_AIA_REG(siselect),
777 	KVM_REG_RISCV | KVM_REG_SIZE_ULONG | KVM_REG_RISCV_CSR | KVM_REG_RISCV_CSR_AIA | KVM_REG_RISCV_CSR_AIA_REG(iprio1),
778 	KVM_REG_RISCV | KVM_REG_SIZE_ULONG | KVM_REG_RISCV_CSR | KVM_REG_RISCV_CSR_AIA | KVM_REG_RISCV_CSR_AIA_REG(iprio2),
779 	KVM_REG_RISCV | KVM_REG_SIZE_ULONG | KVM_REG_RISCV_CSR | KVM_REG_RISCV_CSR_AIA | KVM_REG_RISCV_CSR_AIA_REG(sieh),
780 	KVM_REG_RISCV | KVM_REG_SIZE_ULONG | KVM_REG_RISCV_CSR | KVM_REG_RISCV_CSR_AIA | KVM_REG_RISCV_CSR_AIA_REG(siph),
781 	KVM_REG_RISCV | KVM_REG_SIZE_ULONG | KVM_REG_RISCV_CSR | KVM_REG_RISCV_CSR_AIA | KVM_REG_RISCV_CSR_AIA_REG(iprio1h),
782 	KVM_REG_RISCV | KVM_REG_SIZE_ULONG | KVM_REG_RISCV_CSR | KVM_REG_RISCV_CSR_AIA | KVM_REG_RISCV_CSR_AIA_REG(iprio2h),
783 	KVM_REG_RISCV | KVM_REG_SIZE_ULONG | KVM_REG_RISCV_ISA_EXT | KVM_REG_RISCV_ISA_SINGLE | KVM_RISCV_ISA_EXT_SSAIA,
784 };
785 
786 static __u64 smstateen_regs[] = {
787 	KVM_REG_RISCV | KVM_REG_SIZE_ULONG | KVM_REG_RISCV_CSR | KVM_REG_RISCV_CSR_SMSTATEEN | KVM_REG_RISCV_CSR_SMSTATEEN_REG(sstateen0),
788 	KVM_REG_RISCV | KVM_REG_SIZE_ULONG | KVM_REG_RISCV_ISA_EXT | KVM_REG_RISCV_ISA_SINGLE | KVM_RISCV_ISA_EXT_SMSTATEEN,
789 };
790 
791 static __u64 fp_f_regs[] = {
792 	KVM_REG_RISCV | KVM_REG_SIZE_U32 | KVM_REG_RISCV_FP_F | KVM_REG_RISCV_FP_F_REG(f[0]),
793 	KVM_REG_RISCV | KVM_REG_SIZE_U32 | KVM_REG_RISCV_FP_F | KVM_REG_RISCV_FP_F_REG(f[1]),
794 	KVM_REG_RISCV | KVM_REG_SIZE_U32 | KVM_REG_RISCV_FP_F | KVM_REG_RISCV_FP_F_REG(f[2]),
795 	KVM_REG_RISCV | KVM_REG_SIZE_U32 | KVM_REG_RISCV_FP_F | KVM_REG_RISCV_FP_F_REG(f[3]),
796 	KVM_REG_RISCV | KVM_REG_SIZE_U32 | KVM_REG_RISCV_FP_F | KVM_REG_RISCV_FP_F_REG(f[4]),
797 	KVM_REG_RISCV | KVM_REG_SIZE_U32 | KVM_REG_RISCV_FP_F | KVM_REG_RISCV_FP_F_REG(f[5]),
798 	KVM_REG_RISCV | KVM_REG_SIZE_U32 | KVM_REG_RISCV_FP_F | KVM_REG_RISCV_FP_F_REG(f[6]),
799 	KVM_REG_RISCV | KVM_REG_SIZE_U32 | KVM_REG_RISCV_FP_F | KVM_REG_RISCV_FP_F_REG(f[7]),
800 	KVM_REG_RISCV | KVM_REG_SIZE_U32 | KVM_REG_RISCV_FP_F | KVM_REG_RISCV_FP_F_REG(f[8]),
801 	KVM_REG_RISCV | KVM_REG_SIZE_U32 | KVM_REG_RISCV_FP_F | KVM_REG_RISCV_FP_F_REG(f[9]),
802 	KVM_REG_RISCV | KVM_REG_SIZE_U32 | KVM_REG_RISCV_FP_F | KVM_REG_RISCV_FP_F_REG(f[10]),
803 	KVM_REG_RISCV | KVM_REG_SIZE_U32 | KVM_REG_RISCV_FP_F | KVM_REG_RISCV_FP_F_REG(f[11]),
804 	KVM_REG_RISCV | KVM_REG_SIZE_U32 | KVM_REG_RISCV_FP_F | KVM_REG_RISCV_FP_F_REG(f[12]),
805 	KVM_REG_RISCV | KVM_REG_SIZE_U32 | KVM_REG_RISCV_FP_F | KVM_REG_RISCV_FP_F_REG(f[13]),
806 	KVM_REG_RISCV | KVM_REG_SIZE_U32 | KVM_REG_RISCV_FP_F | KVM_REG_RISCV_FP_F_REG(f[14]),
807 	KVM_REG_RISCV | KVM_REG_SIZE_U32 | KVM_REG_RISCV_FP_F | KVM_REG_RISCV_FP_F_REG(f[15]),
808 	KVM_REG_RISCV | KVM_REG_SIZE_U32 | KVM_REG_RISCV_FP_F | KVM_REG_RISCV_FP_F_REG(f[16]),
809 	KVM_REG_RISCV | KVM_REG_SIZE_U32 | KVM_REG_RISCV_FP_F | KVM_REG_RISCV_FP_F_REG(f[17]),
810 	KVM_REG_RISCV | KVM_REG_SIZE_U32 | KVM_REG_RISCV_FP_F | KVM_REG_RISCV_FP_F_REG(f[18]),
811 	KVM_REG_RISCV | KVM_REG_SIZE_U32 | KVM_REG_RISCV_FP_F | KVM_REG_RISCV_FP_F_REG(f[19]),
812 	KVM_REG_RISCV | KVM_REG_SIZE_U32 | KVM_REG_RISCV_FP_F | KVM_REG_RISCV_FP_F_REG(f[20]),
813 	KVM_REG_RISCV | KVM_REG_SIZE_U32 | KVM_REG_RISCV_FP_F | KVM_REG_RISCV_FP_F_REG(f[21]),
814 	KVM_REG_RISCV | KVM_REG_SIZE_U32 | KVM_REG_RISCV_FP_F | KVM_REG_RISCV_FP_F_REG(f[22]),
815 	KVM_REG_RISCV | KVM_REG_SIZE_U32 | KVM_REG_RISCV_FP_F | KVM_REG_RISCV_FP_F_REG(f[23]),
816 	KVM_REG_RISCV | KVM_REG_SIZE_U32 | KVM_REG_RISCV_FP_F | KVM_REG_RISCV_FP_F_REG(f[24]),
817 	KVM_REG_RISCV | KVM_REG_SIZE_U32 | KVM_REG_RISCV_FP_F | KVM_REG_RISCV_FP_F_REG(f[25]),
818 	KVM_REG_RISCV | KVM_REG_SIZE_U32 | KVM_REG_RISCV_FP_F | KVM_REG_RISCV_FP_F_REG(f[26]),
819 	KVM_REG_RISCV | KVM_REG_SIZE_U32 | KVM_REG_RISCV_FP_F | KVM_REG_RISCV_FP_F_REG(f[27]),
820 	KVM_REG_RISCV | KVM_REG_SIZE_U32 | KVM_REG_RISCV_FP_F | KVM_REG_RISCV_FP_F_REG(f[28]),
821 	KVM_REG_RISCV | KVM_REG_SIZE_U32 | KVM_REG_RISCV_FP_F | KVM_REG_RISCV_FP_F_REG(f[29]),
822 	KVM_REG_RISCV | KVM_REG_SIZE_U32 | KVM_REG_RISCV_FP_F | KVM_REG_RISCV_FP_F_REG(f[30]),
823 	KVM_REG_RISCV | KVM_REG_SIZE_U32 | KVM_REG_RISCV_FP_F | KVM_REG_RISCV_FP_F_REG(f[31]),
824 	KVM_REG_RISCV | KVM_REG_SIZE_U32 | KVM_REG_RISCV_FP_F | KVM_REG_RISCV_FP_F_REG(fcsr),
825 	KVM_REG_RISCV | KVM_REG_SIZE_ULONG | KVM_REG_RISCV_ISA_EXT | KVM_REG_RISCV_ISA_SINGLE | KVM_RISCV_ISA_EXT_F,
826 };
827 
828 static __u64 fp_d_regs[] = {
829 	KVM_REG_RISCV | KVM_REG_SIZE_U64 | KVM_REG_RISCV_FP_D | KVM_REG_RISCV_FP_D_REG(f[0]),
830 	KVM_REG_RISCV | KVM_REG_SIZE_U64 | KVM_REG_RISCV_FP_D | KVM_REG_RISCV_FP_D_REG(f[1]),
831 	KVM_REG_RISCV | KVM_REG_SIZE_U64 | KVM_REG_RISCV_FP_D | KVM_REG_RISCV_FP_D_REG(f[2]),
832 	KVM_REG_RISCV | KVM_REG_SIZE_U64 | KVM_REG_RISCV_FP_D | KVM_REG_RISCV_FP_D_REG(f[3]),
833 	KVM_REG_RISCV | KVM_REG_SIZE_U64 | KVM_REG_RISCV_FP_D | KVM_REG_RISCV_FP_D_REG(f[4]),
834 	KVM_REG_RISCV | KVM_REG_SIZE_U64 | KVM_REG_RISCV_FP_D | KVM_REG_RISCV_FP_D_REG(f[5]),
835 	KVM_REG_RISCV | KVM_REG_SIZE_U64 | KVM_REG_RISCV_FP_D | KVM_REG_RISCV_FP_D_REG(f[6]),
836 	KVM_REG_RISCV | KVM_REG_SIZE_U64 | KVM_REG_RISCV_FP_D | KVM_REG_RISCV_FP_D_REG(f[7]),
837 	KVM_REG_RISCV | KVM_REG_SIZE_U64 | KVM_REG_RISCV_FP_D | KVM_REG_RISCV_FP_D_REG(f[8]),
838 	KVM_REG_RISCV | KVM_REG_SIZE_U64 | KVM_REG_RISCV_FP_D | KVM_REG_RISCV_FP_D_REG(f[9]),
839 	KVM_REG_RISCV | KVM_REG_SIZE_U64 | KVM_REG_RISCV_FP_D | KVM_REG_RISCV_FP_D_REG(f[10]),
840 	KVM_REG_RISCV | KVM_REG_SIZE_U64 | KVM_REG_RISCV_FP_D | KVM_REG_RISCV_FP_D_REG(f[11]),
841 	KVM_REG_RISCV | KVM_REG_SIZE_U64 | KVM_REG_RISCV_FP_D | KVM_REG_RISCV_FP_D_REG(f[12]),
842 	KVM_REG_RISCV | KVM_REG_SIZE_U64 | KVM_REG_RISCV_FP_D | KVM_REG_RISCV_FP_D_REG(f[13]),
843 	KVM_REG_RISCV | KVM_REG_SIZE_U64 | KVM_REG_RISCV_FP_D | KVM_REG_RISCV_FP_D_REG(f[14]),
844 	KVM_REG_RISCV | KVM_REG_SIZE_U64 | KVM_REG_RISCV_FP_D | KVM_REG_RISCV_FP_D_REG(f[15]),
845 	KVM_REG_RISCV | KVM_REG_SIZE_U64 | KVM_REG_RISCV_FP_D | KVM_REG_RISCV_FP_D_REG(f[16]),
846 	KVM_REG_RISCV | KVM_REG_SIZE_U64 | KVM_REG_RISCV_FP_D | KVM_REG_RISCV_FP_D_REG(f[17]),
847 	KVM_REG_RISCV | KVM_REG_SIZE_U64 | KVM_REG_RISCV_FP_D | KVM_REG_RISCV_FP_D_REG(f[18]),
848 	KVM_REG_RISCV | KVM_REG_SIZE_U64 | KVM_REG_RISCV_FP_D | KVM_REG_RISCV_FP_D_REG(f[19]),
849 	KVM_REG_RISCV | KVM_REG_SIZE_U64 | KVM_REG_RISCV_FP_D | KVM_REG_RISCV_FP_D_REG(f[20]),
850 	KVM_REG_RISCV | KVM_REG_SIZE_U64 | KVM_REG_RISCV_FP_D | KVM_REG_RISCV_FP_D_REG(f[21]),
851 	KVM_REG_RISCV | KVM_REG_SIZE_U64 | KVM_REG_RISCV_FP_D | KVM_REG_RISCV_FP_D_REG(f[22]),
852 	KVM_REG_RISCV | KVM_REG_SIZE_U64 | KVM_REG_RISCV_FP_D | KVM_REG_RISCV_FP_D_REG(f[23]),
853 	KVM_REG_RISCV | KVM_REG_SIZE_U64 | KVM_REG_RISCV_FP_D | KVM_REG_RISCV_FP_D_REG(f[24]),
854 	KVM_REG_RISCV | KVM_REG_SIZE_U64 | KVM_REG_RISCV_FP_D | KVM_REG_RISCV_FP_D_REG(f[25]),
855 	KVM_REG_RISCV | KVM_REG_SIZE_U64 | KVM_REG_RISCV_FP_D | KVM_REG_RISCV_FP_D_REG(f[26]),
856 	KVM_REG_RISCV | KVM_REG_SIZE_U64 | KVM_REG_RISCV_FP_D | KVM_REG_RISCV_FP_D_REG(f[27]),
857 	KVM_REG_RISCV | KVM_REG_SIZE_U64 | KVM_REG_RISCV_FP_D | KVM_REG_RISCV_FP_D_REG(f[28]),
858 	KVM_REG_RISCV | KVM_REG_SIZE_U64 | KVM_REG_RISCV_FP_D | KVM_REG_RISCV_FP_D_REG(f[29]),
859 	KVM_REG_RISCV | KVM_REG_SIZE_U64 | KVM_REG_RISCV_FP_D | KVM_REG_RISCV_FP_D_REG(f[30]),
860 	KVM_REG_RISCV | KVM_REG_SIZE_U64 | KVM_REG_RISCV_FP_D | KVM_REG_RISCV_FP_D_REG(f[31]),
861 	KVM_REG_RISCV | KVM_REG_SIZE_U32 | KVM_REG_RISCV_FP_D | KVM_REG_RISCV_FP_D_REG(fcsr),
862 	KVM_REG_RISCV | KVM_REG_SIZE_ULONG | KVM_REG_RISCV_ISA_EXT | KVM_REG_RISCV_ISA_SINGLE | KVM_RISCV_ISA_EXT_D,
863 };
864 
865 #define SUBLIST_BASE \
866 	{"base", .regs = base_regs, .regs_n = ARRAY_SIZE(base_regs), \
867 	 .skips_set = base_skips_set, .skips_set_n = ARRAY_SIZE(base_skips_set),}
868 #define SUBLIST_SBI_BASE \
869 	{"sbi-base", .feature_type = VCPU_FEATURE_SBI_EXT, .feature = KVM_RISCV_SBI_EXT_V01, \
870 	 .regs = sbi_base_regs, .regs_n = ARRAY_SIZE(sbi_base_regs),}
871 #define SUBLIST_SBI_STA \
872 	{"sbi-sta", .feature_type = VCPU_FEATURE_SBI_EXT, .feature = KVM_RISCV_SBI_EXT_STA, \
873 	 .regs = sbi_sta_regs, .regs_n = ARRAY_SIZE(sbi_sta_regs),}
874 #define SUBLIST_ZICBOM \
875 	{"zicbom", .feature = KVM_RISCV_ISA_EXT_ZICBOM, .regs = zicbom_regs, .regs_n = ARRAY_SIZE(zicbom_regs),}
876 #define SUBLIST_ZICBOZ \
877 	{"zicboz", .feature = KVM_RISCV_ISA_EXT_ZICBOZ, .regs = zicboz_regs, .regs_n = ARRAY_SIZE(zicboz_regs),}
878 #define SUBLIST_AIA \
879 	{"aia", .feature = KVM_RISCV_ISA_EXT_SSAIA, .regs = aia_regs, .regs_n = ARRAY_SIZE(aia_regs),}
880 #define SUBLIST_SMSTATEEN \
881 	{"smstateen", .feature = KVM_RISCV_ISA_EXT_SMSTATEEN, .regs = smstateen_regs, .regs_n = ARRAY_SIZE(smstateen_regs),}
882 #define SUBLIST_FP_F \
883 	{"fp_f", .feature = KVM_RISCV_ISA_EXT_F, .regs = fp_f_regs, \
884 		.regs_n = ARRAY_SIZE(fp_f_regs),}
885 #define SUBLIST_FP_D \
886 	{"fp_d", .feature = KVM_RISCV_ISA_EXT_D, .regs = fp_d_regs, \
887 		.regs_n = ARRAY_SIZE(fp_d_regs),}
888 
889 #define KVM_ISA_EXT_SIMPLE_CONFIG(ext, extu)			\
890 static __u64 regs_##ext[] = {					\
891 	KVM_REG_RISCV | KVM_REG_SIZE_ULONG |			\
892 	KVM_REG_RISCV_ISA_EXT | KVM_REG_RISCV_ISA_SINGLE |	\
893 	KVM_RISCV_ISA_EXT_##extu,				\
894 };								\
895 static struct vcpu_reg_list config_##ext = {			\
896 	.sublists = {						\
897 		SUBLIST_BASE,					\
898 		{						\
899 			.name = #ext,				\
900 			.feature = KVM_RISCV_ISA_EXT_##extu,	\
901 			.regs = regs_##ext,			\
902 			.regs_n = ARRAY_SIZE(regs_##ext),	\
903 		},						\
904 		{0},						\
905 	},							\
906 }								\
907 
908 #define KVM_SBI_EXT_SIMPLE_CONFIG(ext, extu)			\
909 static __u64 regs_sbi_##ext[] = {				\
910 	KVM_REG_RISCV | KVM_REG_SIZE_ULONG |			\
911 	KVM_REG_RISCV_SBI_EXT | KVM_REG_RISCV_SBI_SINGLE |	\
912 	KVM_RISCV_SBI_EXT_##extu,				\
913 };								\
914 static struct vcpu_reg_list config_sbi_##ext = {		\
915 	.sublists = {						\
916 		SUBLIST_BASE,					\
917 		{						\
918 			.name = "sbi-"#ext,			\
919 			.feature_type = VCPU_FEATURE_SBI_EXT,	\
920 			.feature = KVM_RISCV_SBI_EXT_##extu,	\
921 			.regs = regs_sbi_##ext,			\
922 			.regs_n = ARRAY_SIZE(regs_sbi_##ext),	\
923 		},						\
924 		{0},						\
925 	},							\
926 }								\
927 
928 #define KVM_ISA_EXT_SUBLIST_CONFIG(ext, extu)			\
929 static struct vcpu_reg_list config_##ext = {			\
930 	.sublists = {						\
931 		SUBLIST_BASE,					\
932 		SUBLIST_##extu,					\
933 		{0},						\
934 	},							\
935 }								\
936 
937 #define KVM_SBI_EXT_SUBLIST_CONFIG(ext, extu)			\
938 static struct vcpu_reg_list config_sbi_##ext = {		\
939 	.sublists = {						\
940 		SUBLIST_BASE,					\
941 		SUBLIST_SBI_##extu,				\
942 		{0},						\
943 	},							\
944 }								\
945 
946 /* Note: The below list is alphabetically sorted. */
947 
948 KVM_SBI_EXT_SUBLIST_CONFIG(base, BASE);
949 KVM_SBI_EXT_SUBLIST_CONFIG(sta, STA);
950 KVM_SBI_EXT_SIMPLE_CONFIG(pmu, PMU);
951 KVM_SBI_EXT_SIMPLE_CONFIG(dbcn, DBCN);
952 
953 KVM_ISA_EXT_SUBLIST_CONFIG(aia, AIA);
954 KVM_ISA_EXT_SUBLIST_CONFIG(fp_f, FP_F);
955 KVM_ISA_EXT_SUBLIST_CONFIG(fp_d, FP_D);
956 KVM_ISA_EXT_SIMPLE_CONFIG(h, H);
957 KVM_ISA_EXT_SIMPLE_CONFIG(smnpm, SMNPM);
958 KVM_ISA_EXT_SUBLIST_CONFIG(smstateen, SMSTATEEN);
959 KVM_ISA_EXT_SIMPLE_CONFIG(sscofpmf, SSCOFPMF);
960 KVM_ISA_EXT_SIMPLE_CONFIG(ssnpm, SSNPM);
961 KVM_ISA_EXT_SIMPLE_CONFIG(sstc, SSTC);
962 KVM_ISA_EXT_SIMPLE_CONFIG(svade, SVADE);
963 KVM_ISA_EXT_SIMPLE_CONFIG(svadu, SVADU);
964 KVM_ISA_EXT_SIMPLE_CONFIG(svinval, SVINVAL);
965 KVM_ISA_EXT_SIMPLE_CONFIG(svnapot, SVNAPOT);
966 KVM_ISA_EXT_SIMPLE_CONFIG(svpbmt, SVPBMT);
967 KVM_ISA_EXT_SIMPLE_CONFIG(zacas, ZACAS);
968 KVM_ISA_EXT_SIMPLE_CONFIG(zawrs, ZAWRS);
969 KVM_ISA_EXT_SIMPLE_CONFIG(zba, ZBA);
970 KVM_ISA_EXT_SIMPLE_CONFIG(zbb, ZBB);
971 KVM_ISA_EXT_SIMPLE_CONFIG(zbc, ZBC);
972 KVM_ISA_EXT_SIMPLE_CONFIG(zbkb, ZBKB);
973 KVM_ISA_EXT_SIMPLE_CONFIG(zbkc, ZBKC);
974 KVM_ISA_EXT_SIMPLE_CONFIG(zbkx, ZBKX);
975 KVM_ISA_EXT_SIMPLE_CONFIG(zbs, ZBS);
976 KVM_ISA_EXT_SIMPLE_CONFIG(zca, ZCA);
977 KVM_ISA_EXT_SIMPLE_CONFIG(zcb, ZCB);
978 KVM_ISA_EXT_SIMPLE_CONFIG(zcd, ZCD);
979 KVM_ISA_EXT_SIMPLE_CONFIG(zcf, ZCF);
980 KVM_ISA_EXT_SIMPLE_CONFIG(zcmop, ZCMOP);
981 KVM_ISA_EXT_SIMPLE_CONFIG(zfa, ZFA);
982 KVM_ISA_EXT_SIMPLE_CONFIG(zfh, ZFH);
983 KVM_ISA_EXT_SIMPLE_CONFIG(zfhmin, ZFHMIN);
984 KVM_ISA_EXT_SUBLIST_CONFIG(zicbom, ZICBOM);
985 KVM_ISA_EXT_SUBLIST_CONFIG(zicboz, ZICBOZ);
986 KVM_ISA_EXT_SIMPLE_CONFIG(zicntr, ZICNTR);
987 KVM_ISA_EXT_SIMPLE_CONFIG(zicond, ZICOND);
988 KVM_ISA_EXT_SIMPLE_CONFIG(zicsr, ZICSR);
989 KVM_ISA_EXT_SIMPLE_CONFIG(zifencei, ZIFENCEI);
990 KVM_ISA_EXT_SIMPLE_CONFIG(zihintntl, ZIHINTNTL);
991 KVM_ISA_EXT_SIMPLE_CONFIG(zihintpause, ZIHINTPAUSE);
992 KVM_ISA_EXT_SIMPLE_CONFIG(zihpm, ZIHPM);
993 KVM_ISA_EXT_SIMPLE_CONFIG(zimop, ZIMOP);
994 KVM_ISA_EXT_SIMPLE_CONFIG(zknd, ZKND);
995 KVM_ISA_EXT_SIMPLE_CONFIG(zkne, ZKNE);
996 KVM_ISA_EXT_SIMPLE_CONFIG(zknh, ZKNH);
997 KVM_ISA_EXT_SIMPLE_CONFIG(zkr, ZKR);
998 KVM_ISA_EXT_SIMPLE_CONFIG(zksed, ZKSED);
999 KVM_ISA_EXT_SIMPLE_CONFIG(zksh, ZKSH);
1000 KVM_ISA_EXT_SIMPLE_CONFIG(zkt, ZKT);
1001 KVM_ISA_EXT_SIMPLE_CONFIG(ztso, ZTSO);
1002 KVM_ISA_EXT_SIMPLE_CONFIG(zvbb, ZVBB);
1003 KVM_ISA_EXT_SIMPLE_CONFIG(zvbc, ZVBC);
1004 KVM_ISA_EXT_SIMPLE_CONFIG(zvfh, ZVFH);
1005 KVM_ISA_EXT_SIMPLE_CONFIG(zvfhmin, ZVFHMIN);
1006 KVM_ISA_EXT_SIMPLE_CONFIG(zvkb, ZVKB);
1007 KVM_ISA_EXT_SIMPLE_CONFIG(zvkg, ZVKG);
1008 KVM_ISA_EXT_SIMPLE_CONFIG(zvkned, ZVKNED);
1009 KVM_ISA_EXT_SIMPLE_CONFIG(zvknha, ZVKNHA);
1010 KVM_ISA_EXT_SIMPLE_CONFIG(zvknhb, ZVKNHB);
1011 KVM_ISA_EXT_SIMPLE_CONFIG(zvksed, ZVKSED);
1012 KVM_ISA_EXT_SIMPLE_CONFIG(zvksh, ZVKSH);
1013 KVM_ISA_EXT_SIMPLE_CONFIG(zvkt, ZVKT);
1014 
1015 struct vcpu_reg_list *vcpu_configs[] = {
1016 	&config_sbi_base,
1017 	&config_sbi_sta,
1018 	&config_sbi_pmu,
1019 	&config_sbi_dbcn,
1020 	&config_aia,
1021 	&config_fp_f,
1022 	&config_fp_d,
1023 	&config_h,
1024 	&config_smnpm,
1025 	&config_smstateen,
1026 	&config_sscofpmf,
1027 	&config_ssnpm,
1028 	&config_sstc,
1029 	&config_svade,
1030 	&config_svadu,
1031 	&config_svinval,
1032 	&config_svnapot,
1033 	&config_svpbmt,
1034 	&config_zacas,
1035 	&config_zawrs,
1036 	&config_zba,
1037 	&config_zbb,
1038 	&config_zbc,
1039 	&config_zbkb,
1040 	&config_zbkc,
1041 	&config_zbkx,
1042 	&config_zbs,
1043 	&config_zca,
1044 	&config_zcb,
1045 	&config_zcd,
1046 	&config_zcf,
1047 	&config_zcmop,
1048 	&config_zfa,
1049 	&config_zfh,
1050 	&config_zfhmin,
1051 	&config_zicbom,
1052 	&config_zicboz,
1053 	&config_zicntr,
1054 	&config_zicond,
1055 	&config_zicsr,
1056 	&config_zifencei,
1057 	&config_zihintntl,
1058 	&config_zihintpause,
1059 	&config_zihpm,
1060 	&config_zimop,
1061 	&config_zknd,
1062 	&config_zkne,
1063 	&config_zknh,
1064 	&config_zkr,
1065 	&config_zksed,
1066 	&config_zksh,
1067 	&config_zkt,
1068 	&config_ztso,
1069 	&config_zvbb,
1070 	&config_zvbc,
1071 	&config_zvfh,
1072 	&config_zvfhmin,
1073 	&config_zvkb,
1074 	&config_zvkg,
1075 	&config_zvkned,
1076 	&config_zvknha,
1077 	&config_zvknhb,
1078 	&config_zvksed,
1079 	&config_zvksh,
1080 	&config_zvkt,
1081 };
1082 int vcpu_configs_n = ARRAY_SIZE(vcpu_configs);
1083