kvm/x86_64/kvm_clock_test.c

0001 // SPDX-License-Identifier: GPL-2.0-only
0002 /*
0003  * Copyright (C) 2021, Google LLC.
0004  *
0005  * Tests for adjusting the KVM clock from userspace
0006  */
0007 #include <asm/kvm_para.h>
0008 #include <asm/pvclock.h>
0009 #include <asm/pvclock-abi.h>
0010 #include <stdint.h>
0011 #include <string.h>
0012 #include <sys/stat.h>
0013 #include <time.h>
0014
0015 #include "test_util.h"
0016 #include "kvm_util.h"
0017 #include "processor.h"
0018
0019 struct test_case {
0020     uint64_t kvmclock_base;
0021     int64_t realtime_offset;
0022 };
0023
0024 static struct test_case test_cases[] = {
0025     { .kvmclock_base = 0 },
0026     { .kvmclock_base = 180 * NSEC_PER_SEC },
0027     { .kvmclock_base = 0, .realtime_offset = -180 * NSEC_PER_SEC },
0028     { .kvmclock_base = 0, .realtime_offset = 180 * NSEC_PER_SEC },
0029 };
0030
0031 #define GUEST_SYNC_CLOCK(__stage, __val)            \
0032         GUEST_SYNC_ARGS(__stage, __val, 0, 0, 0)
0033
0034 static void guest_main(vm_paddr_t pvti_pa, struct pvclock_vcpu_time_info *pvti)
0035 {
0036     int i;
0037
0038     wrmsr(MSR_KVM_SYSTEM_TIME_NEW, pvti_pa | KVM_MSR_ENABLED);
0039     for (i = 0; i < ARRAY_SIZE(test_cases); i++)
0040         GUEST_SYNC_CLOCK(i, __pvclock_read_cycles(pvti, rdtsc()));
0041 }
0042
0043 #define EXPECTED_FLAGS (KVM_CLOCK_REALTIME | KVM_CLOCK_HOST_TSC)
0044
0045 static inline void assert_flags(struct kvm_clock_data *data)
0046 {
0047     TEST_ASSERT((data->flags & EXPECTED_FLAGS) == EXPECTED_FLAGS,
0048             "unexpected clock data flags: %x (want set: %x)",
0049             data->flags, EXPECTED_FLAGS);
0050 }
0051
0052 static void handle_sync(struct ucall *uc, struct kvm_clock_data *start,
0053             struct kvm_clock_data *end)
0054 {
0055     uint64_t obs, exp_lo, exp_hi;
0056
0057     obs = uc->args[2];
0058     exp_lo = start->clock;
0059     exp_hi = end->clock;
0060
0061     assert_flags(start);
0062     assert_flags(end);
0063
0064     TEST_ASSERT(exp_lo <= obs && obs <= exp_hi,
0065             "unexpected kvm-clock value: %"PRIu64" expected range: [%"PRIu64", %"PRIu64"]",
0066             obs, exp_lo, exp_hi);
0067
0068     pr_info("kvm-clock value: %"PRIu64" expected range [%"PRIu64", %"PRIu64"]\n",
0069         obs, exp_lo, exp_hi);
0070 }
0071
0072 static void handle_abort(struct ucall *uc)
0073 {
0074     REPORT_GUEST_ASSERT(*uc);
0075 }
0076
0077 static void setup_clock(struct kvm_vm *vm, struct test_case *test_case)
0078 {
0079     struct kvm_clock_data data;
0080
0081     memset(&data, 0, sizeof(data));
0082
0083     data.clock = test_case->kvmclock_base;
0084     if (test_case->realtime_offset) {
0085         struct timespec ts;
0086         int r;
0087
0088         data.flags |= KVM_CLOCK_REALTIME;
0089         do {
0090             r = clock_gettime(CLOCK_REALTIME, &ts);
0091             if (!r)
0092                 break;
0093         } while (errno == EINTR);
0094
0095         TEST_ASSERT(!r, "clock_gettime() failed: %d\n", r);
0096
0097         data.realtime = ts.tv_sec * NSEC_PER_SEC;
0098         data.realtime += ts.tv_nsec;
0099         data.realtime += test_case->realtime_offset;
0100     }
0101
0102     vm_ioctl(vm, KVM_SET_CLOCK, &data);
0103 }
0104
0105 static void enter_guest(struct kvm_vcpu *vcpu)
0106 {
0107     struct kvm_clock_data start, end;
0108     struct kvm_run *run = vcpu->run;
0109     struct kvm_vm *vm = vcpu->vm;
0110     struct ucall uc;
0111     int i;
0112
0113     for (i = 0; i < ARRAY_SIZE(test_cases); i++) {
0114         setup_clock(vm, &test_cases[i]);
0115
0116         vm_ioctl(vm, KVM_GET_CLOCK, &start);
0117
0118         vcpu_run(vcpu);
0119         vm_ioctl(vm, KVM_GET_CLOCK, &end);
0120
0121         TEST_ASSERT(run->exit_reason == KVM_EXIT_IO,
0122                 "unexpected exit reason: %u (%s)",
0123                 run->exit_reason, exit_reason_str(run->exit_reason));
0124
0125         switch (get_ucall(vcpu, &uc)) {
0126         case UCALL_SYNC:
0127             handle_sync(&uc, &start, &end);
0128             break;
0129         case UCALL_ABORT:
0130             handle_abort(&uc);
0131             return;
0132         default:
0133             TEST_ASSERT(0, "unhandled ucall: %ld\n", uc.cmd);
0134         }
0135     }
0136 }
0137
0138 #define CLOCKSOURCE_PATH "/sys/devices/system/clocksource/clocksource0/current_clocksource"
0139
0140 static void check_clocksource(void)
0141 {
0142     char *clk_name;
0143     struct stat st;
0144     FILE *fp;
0145
0146     fp = fopen(CLOCKSOURCE_PATH, "r");
0147     if (!fp) {
0148         pr_info("failed to open clocksource file: %d; assuming TSC.\n",
0149             errno);
0150         return;
0151     }
0152
0153     if (fstat(fileno(fp), &st)) {
0154         pr_info("failed to stat clocksource file: %d; assuming TSC.\n",
0155             errno);
0156         goto out;
0157     }
0158
0159     clk_name = malloc(st.st_size);
0160     TEST_ASSERT(clk_name, "failed to allocate buffer to read file\n");
0161
0162     if (!fgets(clk_name, st.st_size, fp)) {
0163         pr_info("failed to read clocksource file: %d; assuming TSC.\n",
0164             ferror(fp));
0165         goto out;
0166     }
0167
0168     TEST_ASSERT(!strncmp(clk_name, "tsc\n", st.st_size),
0169             "clocksource not supported: %s", clk_name);
0170 out:
0171     fclose(fp);
0172 }
0173
0174 int main(void)
0175 {
0176     struct kvm_vcpu *vcpu;
0177     vm_vaddr_t pvti_gva;
0178     vm_paddr_t pvti_gpa;
0179     struct kvm_vm *vm;
0180     int flags;
0181
0182     flags = kvm_check_cap(KVM_CAP_ADJUST_CLOCK);
0183     TEST_REQUIRE(flags & KVM_CLOCK_REALTIME);
0184
0185     check_clocksource();
0186
0187     vm = vm_create_with_one_vcpu(&vcpu, guest_main);
0188
0189     pvti_gva = vm_vaddr_alloc(vm, getpagesize(), 0x10000);
0190     pvti_gpa = addr_gva2gpa(vm, pvti_gva);
0191     vcpu_args_set(vcpu, 2, pvti_gpa, pvti_gva);
0192
0193     enter_guest(vcpu);
0194     kvm_vm_free(vm);
0195 }