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