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