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