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