tools/testing/selftests/kvm/riscv/get-reg-list.c

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