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