tools/testing/selftests/kvm/aarch64/hypercalls.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2
   3 /* hypercalls: Check the ARM64's psuedo-firmware bitmap register interface.
   4  *
   5  * The test validates the basic hypercall functionalities that are exposed
   6  * via the psuedo-firmware bitmap register. This includes the registers'
   7  * read/write behavior before and after the VM has started, and if the
   8  * hypercalls are properly masked or unmasked to the guest when disabled or
   9  * enabled from the KVM userspace, respectively.
  10  */
  11 #include <errno.h>
  12 #include <linux/arm-smccc.h>
  13 #include <asm/kvm.h>
  14 #include <kvm_util.h>
  15
  16 #include "processor.h"
  17
  18 #define FW_REG_ULIMIT_VAL(max_feat_bit) (GENMASK(max_feat_bit, 0))
  19
  20 /* Last valid bits of the bitmapped firmware registers */
  21 #define KVM_REG_ARM_STD_BMAP_BIT_MAX            0
  22 #define KVM_REG_ARM_STD_HYP_BMAP_BIT_MAX        0
  23 #define KVM_REG_ARM_VENDOR_HYP_BMAP_BIT_MAX     1
  24
  25 struct kvm_fw_reg_info {
  26         uint64_t reg;           /* Register definition */
  27         uint64_t max_feat_bit;  /* Bit that represents the upper limit of the feature-map */
  28 };
  29
  30 #define FW_REG_INFO(r)                  \
  31         {                                       \
  32                 .reg = r,                       \
  33                 .max_feat_bit = r##_BIT_MAX,    \
  34         }
  35
  36 static const struct kvm_fw_reg_info fw_reg_info[] = {
  37         FW_REG_INFO(KVM_REG_ARM_STD_BMAP),
  38         FW_REG_INFO(KVM_REG_ARM_STD_HYP_BMAP),
  39         FW_REG_INFO(KVM_REG_ARM_VENDOR_HYP_BMAP),
  40 };
  41
  42 enum test_stage {
  43         TEST_STAGE_REG_IFACE,
  44         TEST_STAGE_HVC_IFACE_FEAT_DISABLED,
  45         TEST_STAGE_HVC_IFACE_FEAT_ENABLED,
  46         TEST_STAGE_HVC_IFACE_FALSE_INFO,
  47         TEST_STAGE_END,
  48 };
  49
  50 static int stage = TEST_STAGE_REG_IFACE;
  51
  52 struct test_hvc_info {
  53         uint32_t func_id;
  54         uint64_t arg1;
  55 };
  56
  57 #define TEST_HVC_INFO(f, a1)    \
  58         {                       \
  59                 .func_id = f,   \
  60                 .arg1 = a1,     \
  61         }
  62
  63 static const struct test_hvc_info hvc_info[] = {
  64         /* KVM_REG_ARM_STD_BMAP */
  65         TEST_HVC_INFO(ARM_SMCCC_TRNG_VERSION, 0),
  66         TEST_HVC_INFO(ARM_SMCCC_TRNG_FEATURES, ARM_SMCCC_TRNG_RND64),
  67         TEST_HVC_INFO(ARM_SMCCC_TRNG_GET_UUID, 0),
  68         TEST_HVC_INFO(ARM_SMCCC_TRNG_RND32, 0),
  69         TEST_HVC_INFO(ARM_SMCCC_TRNG_RND64, 0),
  70
  71         /* KVM_REG_ARM_STD_HYP_BMAP */
  72         TEST_HVC_INFO(ARM_SMCCC_ARCH_FEATURES_FUNC_ID, ARM_SMCCC_HV_PV_TIME_FEATURES),
  73         TEST_HVC_INFO(ARM_SMCCC_HV_PV_TIME_FEATURES, ARM_SMCCC_HV_PV_TIME_ST),
  74         TEST_HVC_INFO(ARM_SMCCC_HV_PV_TIME_ST, 0),
  75
  76         /* KVM_REG_ARM_VENDOR_HYP_BMAP */
  77         TEST_HVC_INFO(ARM_SMCCC_VENDOR_HYP_KVM_FEATURES_FUNC_ID,
  78                         ARM_SMCCC_VENDOR_HYP_KVM_PTP_FUNC_ID),
  79         TEST_HVC_INFO(ARM_SMCCC_VENDOR_HYP_CALL_UID_FUNC_ID, 0),
  80         TEST_HVC_INFO(ARM_SMCCC_VENDOR_HYP_KVM_PTP_FUNC_ID, KVM_PTP_VIRT_COUNTER),
  81 };
  82
  83 /* Feed false hypercall info to test the KVM behavior */
  84 static const struct test_hvc_info false_hvc_info[] = {
  85         /* Feature support check against a different family of hypercalls */
  86         TEST_HVC_INFO(ARM_SMCCC_TRNG_FEATURES, ARM_SMCCC_VENDOR_HYP_KVM_PTP_FUNC_ID),
  87         TEST_HVC_INFO(ARM_SMCCC_ARCH_FEATURES_FUNC_ID, ARM_SMCCC_TRNG_RND64),
  88         TEST_HVC_INFO(ARM_SMCCC_HV_PV_TIME_FEATURES, ARM_SMCCC_TRNG_RND64),
  89 };
  90
  91 static void guest_test_hvc(const struct test_hvc_info *hc_info)
  92 {
  93         unsigned int i;
  94         struct arm_smccc_res res;
  95         unsigned int hvc_info_arr_sz;
  96
  97         hvc_info_arr_sz =
  98         hc_info == hvc_info ? ARRAY_SIZE(hvc_info) : ARRAY_SIZE(false_hvc_info);
  99
 100         for (i = 0; i < hvc_info_arr_sz; i++, hc_info++) {
 101                 memset(&res, 0, sizeof(res));
 102                 smccc_hvc(hc_info->func_id, hc_info->arg1, 0, 0, 0, 0, 0, 0, &res);
 103
 104                 switch (stage) {
 105                 case TEST_STAGE_HVC_IFACE_FEAT_DISABLED:
 106                 case TEST_STAGE_HVC_IFACE_FALSE_INFO:
 107                         __GUEST_ASSERT(res.a0 == SMCCC_RET_NOT_SUPPORTED,
 108                                        "a0 = 0x%lx, func_id = 0x%x, arg1 = 0x%lx, stage = %u",
 109                                         res.a0, hc_info->func_id, hc_info->arg1, stage);
 110                         break;
 111                 case TEST_STAGE_HVC_IFACE_FEAT_ENABLED:
 112                         __GUEST_ASSERT(res.a0 != SMCCC_RET_NOT_SUPPORTED,
 113                                        "a0 = 0x%lx, func_id = 0x%x, arg1 = 0x%lx, stage = %u",
 114                                         res.a0, hc_info->func_id, hc_info->arg1, stage);
 115                         break;
 116                 default:
 117                         GUEST_FAIL("Unexpected stage = %u", stage);
 118                 }
 119         }
 120 }
 121
 122 static void guest_code(void)
 123 {
 124         while (stage != TEST_STAGE_END) {
 125                 switch (stage) {
 126                 case TEST_STAGE_REG_IFACE:
 127                         break;
 128                 case TEST_STAGE_HVC_IFACE_FEAT_DISABLED:
 129                 case TEST_STAGE_HVC_IFACE_FEAT_ENABLED:
 130                         guest_test_hvc(hvc_info);
 131                         break;
 132                 case TEST_STAGE_HVC_IFACE_FALSE_INFO:
 133                         guest_test_hvc(false_hvc_info);
 134                         break;
 135                 default:
 136                         GUEST_FAIL("Unexpected stage = %u", stage);
 137                 }
 138
 139                 GUEST_SYNC(stage);
 140         }
 141
 142         GUEST_DONE();
 143 }
 144
 145 struct st_time {
 146         uint32_t rev;
 147         uint32_t attr;
 148         uint64_t st_time;
 149 };
 150
 151 #define STEAL_TIME_SIZE         ((sizeof(struct st_time) + 63) & ~63)
 152 #define ST_GPA_BASE             (1 << 30)
 153
 154 static void steal_time_init(struct kvm_vcpu *vcpu)
 155 {
 156         uint64_t st_ipa = (ulong)ST_GPA_BASE;
 157         unsigned int gpages;
 158
 159         gpages = vm_calc_num_guest_pages(VM_MODE_DEFAULT, STEAL_TIME_SIZE);
 160         vm_userspace_mem_region_add(vcpu->vm, VM_MEM_SRC_ANONYMOUS, ST_GPA_BASE, 1, gpages, 0);
 161
 162         vcpu_device_attr_set(vcpu, KVM_ARM_VCPU_PVTIME_CTRL,
 163                              KVM_ARM_VCPU_PVTIME_IPA, &st_ipa);
 164 }
 165
 166 static void test_fw_regs_before_vm_start(struct kvm_vcpu *vcpu)
 167 {
 168         uint64_t val;
 169         unsigned int i;
 170         int ret;
 171
 172         for (i = 0; i < ARRAY_SIZE(fw_reg_info); i++) {
 173                 const struct kvm_fw_reg_info *reg_info = &fw_reg_info[i];
 174
 175                 /* First 'read' should be an upper limit of the features supported */
 176                 vcpu_get_reg(vcpu, reg_info->reg, &val);
 177                 TEST_ASSERT(val == FW_REG_ULIMIT_VAL(reg_info->max_feat_bit),
 178                         "Expected all the features to be set for reg: 0x%lx; expected: 0x%lx; read: 0x%lx",
 179                         reg_info->reg, FW_REG_ULIMIT_VAL(reg_info->max_feat_bit), val);
 180
 181                 /* Test a 'write' by disabling all the features of the register map */
 182                 ret = __vcpu_set_reg(vcpu, reg_info->reg, 0);
 183                 TEST_ASSERT(ret == 0,
 184                         "Failed to clear all the features of reg: 0x%lx; ret: %d",
 185                         reg_info->reg, errno);
 186
 187                 vcpu_get_reg(vcpu, reg_info->reg, &val);
 188                 TEST_ASSERT(val == 0,
 189                         "Expected all the features to be cleared for reg: 0x%lx", reg_info->reg);
 190
 191                 /*
 192                  * Test enabling a feature that's not supported.
 193                  * Avoid this check if all the bits are occupied.
 194                  */
 195                 if (reg_info->max_feat_bit < 63) {
 196                         ret = __vcpu_set_reg(vcpu, reg_info->reg, BIT(reg_info->max_feat_bit + 1));
 197                         TEST_ASSERT(ret != 0 && errno == EINVAL,
 198                         "Unexpected behavior or return value (%d) while setting an unsupported feature for reg: 0x%lx",
 199                         errno, reg_info->reg);
 200                 }
 201         }
 202 }
 203
 204 static void test_fw_regs_after_vm_start(struct kvm_vcpu *vcpu)
 205 {
 206         uint64_t val;
 207         unsigned int i;
 208         int ret;
 209
 210         for (i = 0; i < ARRAY_SIZE(fw_reg_info); i++) {
 211                 const struct kvm_fw_reg_info *reg_info = &fw_reg_info[i];
 212
 213                 /*
 214                  * Before starting the VM, the test clears all the bits.
 215                  * Check if that's still the case.
 216                  */
 217                 vcpu_get_reg(vcpu, reg_info->reg, &val);
 218                 TEST_ASSERT(val == 0,
 219                         "Expected all the features to be cleared for reg: 0x%lx",
 220                         reg_info->reg);
 221
 222                 /*
 223                  * Since the VM has run at least once, KVM shouldn't allow modification of
 224                  * the registers and should return EBUSY. Set the registers and check for
 225                  * the expected errno.
 226                  */
 227                 ret = __vcpu_set_reg(vcpu, reg_info->reg, FW_REG_ULIMIT_VAL(reg_info->max_feat_bit));
 228                 TEST_ASSERT(ret != 0 && errno == EBUSY,
 229                 "Unexpected behavior or return value (%d) while setting a feature while VM is running for reg: 0x%lx",
 230                 errno, reg_info->reg);
 231         }
 232 }
 233
 234 static struct kvm_vm *test_vm_create(struct kvm_vcpu **vcpu)
 235 {
 236         struct kvm_vm *vm;
 237
 238         vm = vm_create_with_one_vcpu(vcpu, guest_code);
 239
 240         steal_time_init(*vcpu);
 241
 242         return vm;
 243 }
 244
 245 static void test_guest_stage(struct kvm_vm **vm, struct kvm_vcpu **vcpu)
 246 {
 247         int prev_stage = stage;
 248
 249         pr_debug("Stage: %d\n", prev_stage);
 250
 251         /* Sync the stage early, the VM might be freed below. */
 252         stage++;
 253         sync_global_to_guest(*vm, stage);
 254
 255         switch (prev_stage) {
 256         case TEST_STAGE_REG_IFACE:
 257                 test_fw_regs_after_vm_start(*vcpu);
 258                 break;
 259         case TEST_STAGE_HVC_IFACE_FEAT_DISABLED:
 260                 /* Start a new VM so that all the features are now enabled by default */
 261                 kvm_vm_free(*vm);
 262                 *vm = test_vm_create(vcpu);
 263                 break;
 264         case TEST_STAGE_HVC_IFACE_FEAT_ENABLED:
 265         case TEST_STAGE_HVC_IFACE_FALSE_INFO:
 266                 break;
 267         default:
 268                 TEST_FAIL("Unknown test stage: %d", prev_stage);
 269         }
 270 }
 271
 272 static void test_run(void)
 273 {
 274         struct kvm_vcpu *vcpu;
 275         struct kvm_vm *vm;
 276         struct ucall uc;
 277         bool guest_done = false;
 278
 279         vm = test_vm_create(&vcpu);
 280
 281         test_fw_regs_before_vm_start(vcpu);
 282
 283         while (!guest_done) {
 284                 vcpu_run(vcpu);
 285
 286                 switch (get_ucall(vcpu, &uc)) {
 287                 case UCALL_SYNC:
 288                         test_guest_stage(&vm, &vcpu);
 289                         break;
 290                 case UCALL_DONE:
 291                         guest_done = true;
 292                         break;
 293                 case UCALL_ABORT:
 294                         REPORT_GUEST_ASSERT(uc);
 295                         break;
 296                 default:
 297                         TEST_FAIL("Unexpected guest exit");
 298                 }
 299         }
 300
 301         kvm_vm_free(vm);
 302 }
 303
 304 int main(void)
 305 {
 306         test_run();
 307         return 0;
 308 }