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