314 lines · c
1// SPDX-License-Identifier: GPL-2.0-or-later2/*3 * Test for s390x CPU resets4 *5 * Copyright (C) 2020, IBM6 */7 8#include <stdio.h>9#include <stdlib.h>10#include <string.h>11#include <sys/ioctl.h>12 13#include "test_util.h"14#include "kvm_util.h"15#include "kselftest.h"16 17#define LOCAL_IRQS 3218 19#define ARBITRARY_NON_ZERO_VCPU_ID 320 21struct kvm_s390_irq buf[ARBITRARY_NON_ZERO_VCPU_ID + LOCAL_IRQS];22 23static uint8_t regs_null[512];24 25static void guest_code_initial(void)26{27 /* set several CRs to "safe" value */28 unsigned long cr2_59 = 0x10; /* enable guarded storage */29 unsigned long cr8_63 = 0x1; /* monitor mask = 1 */30 unsigned long cr10 = 1; /* PER START */31 unsigned long cr11 = -1; /* PER END */32 33 34 /* Dirty registers */35 asm volatile (36 " lghi 2,0x11\n" /* Round toward 0 */37 " sfpc 2\n" /* set fpc to !=0 */38 " lctlg 2,2,%0\n"39 " lctlg 8,8,%1\n"40 " lctlg 10,10,%2\n"41 " lctlg 11,11,%3\n"42 /* now clobber some general purpose regs */43 " llihh 0,0xffff\n"44 " llihl 1,0x5555\n"45 " llilh 2,0xaaaa\n"46 " llill 3,0x0000\n"47 /* now clobber a floating point reg */48 " lghi 4,0x1\n"49 " cdgbr 0,4\n"50 /* now clobber an access reg */51 " sar 9,4\n"52 /* We embed diag 501 here to control register content */53 " diag 0,0,0x501\n"54 :55 : "m" (cr2_59), "m" (cr8_63), "m" (cr10), "m" (cr11)56 /* no clobber list as this should not return */57 );58}59 60static void test_one_reg(struct kvm_vcpu *vcpu, uint64_t id, uint64_t value)61{62 uint64_t eval_reg;63 64 vcpu_get_reg(vcpu, id, &eval_reg);65 TEST_ASSERT(eval_reg == value, "value == 0x%lx", value);66}67 68static void assert_noirq(struct kvm_vcpu *vcpu)69{70 struct kvm_s390_irq_state irq_state;71 int irqs;72 73 irq_state.len = sizeof(buf);74 irq_state.buf = (unsigned long)buf;75 irqs = __vcpu_ioctl(vcpu, KVM_S390_GET_IRQ_STATE, &irq_state);76 /*77 * irqs contains the number of retrieved interrupts. Any interrupt78 * (notably, the emergency call interrupt we have injected) should79 * be cleared by the resets, so this should be 0.80 */81 TEST_ASSERT(irqs >= 0, "Could not fetch IRQs: errno %d", errno);82 TEST_ASSERT(!irqs, "IRQ pending");83}84 85static void assert_clear(struct kvm_vcpu *vcpu)86{87 struct kvm_sync_regs *sync_regs = &vcpu->run->s.regs;88 struct kvm_sregs sregs;89 struct kvm_regs regs;90 struct kvm_fpu fpu;91 92 vcpu_regs_get(vcpu, ®s);93 TEST_ASSERT(!memcmp(®s.gprs, regs_null, sizeof(regs.gprs)), "grs == 0");94 95 vcpu_sregs_get(vcpu, &sregs);96 TEST_ASSERT(!memcmp(&sregs.acrs, regs_null, sizeof(sregs.acrs)), "acrs == 0");97 98 vcpu_fpu_get(vcpu, &fpu);99 TEST_ASSERT(!memcmp(&fpu.fprs, regs_null, sizeof(fpu.fprs)), "fprs == 0");100 101 /* sync regs */102 TEST_ASSERT(!memcmp(sync_regs->gprs, regs_null, sizeof(sync_regs->gprs)),103 "gprs0-15 == 0 (sync_regs)");104 105 TEST_ASSERT(!memcmp(sync_regs->acrs, regs_null, sizeof(sync_regs->acrs)),106 "acrs0-15 == 0 (sync_regs)");107 108 TEST_ASSERT(!memcmp(sync_regs->vrs, regs_null, sizeof(sync_regs->vrs)),109 "vrs0-15 == 0 (sync_regs)");110}111 112static void assert_initial_noclear(struct kvm_vcpu *vcpu)113{114 struct kvm_sync_regs *sync_regs = &vcpu->run->s.regs;115 116 TEST_ASSERT(sync_regs->gprs[0] == 0xffff000000000000UL,117 "gpr0 == 0xffff000000000000 (sync_regs)");118 TEST_ASSERT(sync_regs->gprs[1] == 0x0000555500000000UL,119 "gpr1 == 0x0000555500000000 (sync_regs)");120 TEST_ASSERT(sync_regs->gprs[2] == 0x00000000aaaa0000UL,121 "gpr2 == 0x00000000aaaa0000 (sync_regs)");122 TEST_ASSERT(sync_regs->gprs[3] == 0x0000000000000000UL,123 "gpr3 == 0x0000000000000000 (sync_regs)");124 TEST_ASSERT(sync_regs->fprs[0] == 0x3ff0000000000000UL,125 "fpr0 == 0f1 (sync_regs)");126 TEST_ASSERT(sync_regs->acrs[9] == 1, "ar9 == 1 (sync_regs)");127}128 129static void assert_initial(struct kvm_vcpu *vcpu)130{131 struct kvm_sync_regs *sync_regs = &vcpu->run->s.regs;132 struct kvm_sregs sregs;133 struct kvm_fpu fpu;134 135 /* KVM_GET_SREGS */136 vcpu_sregs_get(vcpu, &sregs);137 TEST_ASSERT(sregs.crs[0] == 0xE0UL, "cr0 == 0xE0 (KVM_GET_SREGS)");138 TEST_ASSERT(sregs.crs[14] == 0xC2000000UL,139 "cr14 == 0xC2000000 (KVM_GET_SREGS)");140 TEST_ASSERT(!memcmp(&sregs.crs[1], regs_null, sizeof(sregs.crs[1]) * 12),141 "cr1-13 == 0 (KVM_GET_SREGS)");142 TEST_ASSERT(sregs.crs[15] == 0, "cr15 == 0 (KVM_GET_SREGS)");143 144 /* sync regs */145 TEST_ASSERT(sync_regs->crs[0] == 0xE0UL, "cr0 == 0xE0 (sync_regs)");146 TEST_ASSERT(sync_regs->crs[14] == 0xC2000000UL,147 "cr14 == 0xC2000000 (sync_regs)");148 TEST_ASSERT(!memcmp(&sync_regs->crs[1], regs_null, 8 * 12),149 "cr1-13 == 0 (sync_regs)");150 TEST_ASSERT(sync_regs->crs[15] == 0, "cr15 == 0 (sync_regs)");151 TEST_ASSERT(sync_regs->fpc == 0, "fpc == 0 (sync_regs)");152 TEST_ASSERT(sync_regs->todpr == 0, "todpr == 0 (sync_regs)");153 TEST_ASSERT(sync_regs->cputm == 0, "cputm == 0 (sync_regs)");154 TEST_ASSERT(sync_regs->ckc == 0, "ckc == 0 (sync_regs)");155 TEST_ASSERT(sync_regs->pp == 0, "pp == 0 (sync_regs)");156 TEST_ASSERT(sync_regs->gbea == 1, "gbea == 1 (sync_regs)");157 158 /* kvm_run */159 TEST_ASSERT(vcpu->run->psw_addr == 0, "psw_addr == 0 (kvm_run)");160 TEST_ASSERT(vcpu->run->psw_mask == 0, "psw_mask == 0 (kvm_run)");161 162 vcpu_fpu_get(vcpu, &fpu);163 TEST_ASSERT(!fpu.fpc, "fpc == 0");164 165 test_one_reg(vcpu, KVM_REG_S390_GBEA, 1);166 test_one_reg(vcpu, KVM_REG_S390_PP, 0);167 test_one_reg(vcpu, KVM_REG_S390_TODPR, 0);168 test_one_reg(vcpu, KVM_REG_S390_CPU_TIMER, 0);169 test_one_reg(vcpu, KVM_REG_S390_CLOCK_COMP, 0);170}171 172static void assert_normal_noclear(struct kvm_vcpu *vcpu)173{174 struct kvm_sync_regs *sync_regs = &vcpu->run->s.regs;175 176 TEST_ASSERT(sync_regs->crs[2] == 0x10, "cr2 == 10 (sync_regs)");177 TEST_ASSERT(sync_regs->crs[8] == 1, "cr10 == 1 (sync_regs)");178 TEST_ASSERT(sync_regs->crs[10] == 1, "cr10 == 1 (sync_regs)");179 TEST_ASSERT(sync_regs->crs[11] == -1, "cr11 == -1 (sync_regs)");180}181 182static void assert_normal(struct kvm_vcpu *vcpu)183{184 test_one_reg(vcpu, KVM_REG_S390_PFTOKEN, KVM_S390_PFAULT_TOKEN_INVALID);185 TEST_ASSERT(vcpu->run->s.regs.pft == KVM_S390_PFAULT_TOKEN_INVALID,186 "pft == 0xff..... (sync_regs)");187 assert_noirq(vcpu);188}189 190static void inject_irq(struct kvm_vcpu *vcpu)191{192 struct kvm_s390_irq_state irq_state;193 struct kvm_s390_irq *irq = &buf[0];194 int irqs;195 196 /* Inject IRQ */197 irq_state.len = sizeof(struct kvm_s390_irq);198 irq_state.buf = (unsigned long)buf;199 irq->type = KVM_S390_INT_EMERGENCY;200 irq->u.emerg.code = vcpu->id;201 irqs = __vcpu_ioctl(vcpu, KVM_S390_SET_IRQ_STATE, &irq_state);202 TEST_ASSERT(irqs >= 0, "Error injecting EMERGENCY IRQ errno %d", errno);203}204 205static struct kvm_vm *create_vm(struct kvm_vcpu **vcpu)206{207 struct kvm_vm *vm;208 209 vm = vm_create(1);210 211 *vcpu = vm_vcpu_add(vm, ARBITRARY_NON_ZERO_VCPU_ID, guest_code_initial);212 213 return vm;214}215 216static void test_normal(void)217{218 struct kvm_vcpu *vcpu;219 struct kvm_vm *vm;220 221 ksft_print_msg("Testing normal reset\n");222 vm = create_vm(&vcpu);223 224 vcpu_run(vcpu);225 226 inject_irq(vcpu);227 228 vcpu_ioctl(vcpu, KVM_S390_NORMAL_RESET, NULL);229 230 /* must clears */231 assert_normal(vcpu);232 /* must not clears */233 assert_normal_noclear(vcpu);234 assert_initial_noclear(vcpu);235 236 kvm_vm_free(vm);237}238 239static void test_initial(void)240{241 struct kvm_vcpu *vcpu;242 struct kvm_vm *vm;243 244 ksft_print_msg("Testing initial reset\n");245 vm = create_vm(&vcpu);246 247 vcpu_run(vcpu);248 249 inject_irq(vcpu);250 251 vcpu_ioctl(vcpu, KVM_S390_INITIAL_RESET, NULL);252 253 /* must clears */254 assert_normal(vcpu);255 assert_initial(vcpu);256 /* must not clears */257 assert_initial_noclear(vcpu);258 259 kvm_vm_free(vm);260}261 262static void test_clear(void)263{264 struct kvm_vcpu *vcpu;265 struct kvm_vm *vm;266 267 ksft_print_msg("Testing clear reset\n");268 vm = create_vm(&vcpu);269 270 vcpu_run(vcpu);271 272 inject_irq(vcpu);273 274 vcpu_ioctl(vcpu, KVM_S390_CLEAR_RESET, NULL);275 276 /* must clears */277 assert_normal(vcpu);278 assert_initial(vcpu);279 assert_clear(vcpu);280 281 kvm_vm_free(vm);282}283 284struct testdef {285 const char *name;286 void (*test)(void);287 bool needs_cap;288} testlist[] = {289 { "initial", test_initial, false },290 { "normal", test_normal, true },291 { "clear", test_clear, true },292};293 294int main(int argc, char *argv[])295{296 bool has_s390_vcpu_resets = kvm_check_cap(KVM_CAP_S390_VCPU_RESETS);297 int idx;298 299 ksft_print_header();300 ksft_set_plan(ARRAY_SIZE(testlist));301 302 for (idx = 0; idx < ARRAY_SIZE(testlist); idx++) {303 if (!testlist[idx].needs_cap || has_s390_vcpu_resets) {304 testlist[idx].test();305 ksft_test_result_pass("%s\n", testlist[idx].name);306 } else {307 ksft_test_result_skip("%s - no VCPU_RESETS capability\n",308 testlist[idx].name);309 }310 }311 312 ksft_finished(); /* Print results and exit() accordingly */313}314