kvm/s390x/resets.c

0001 // SPDX-License-Identifier: GPL-2.0-or-later
0002 /*
0003  * Test for s390x CPU resets
0004  *
0005  * Copyright (C) 2020, IBM
0006  */
0007
0008 #include <stdio.h>
0009 #include <stdlib.h>
0010 #include <string.h>
0011 #include <sys/ioctl.h>
0012
0013 #include "test_util.h"
0014 #include "kvm_util.h"
0015 #include "kselftest.h"
0016
0017 #define LOCAL_IRQS 32
0018
0019 #define ARBITRARY_NON_ZERO_VCPU_ID 3
0020
0021 struct kvm_s390_irq buf[ARBITRARY_NON_ZERO_VCPU_ID + LOCAL_IRQS];
0022
0023 static uint8_t regs_null[512];
0024
0025 static void guest_code_initial(void)
0026 {
0027     /* set several CRs to "safe" value */
0028     unsigned long cr2_59 = 0x10;    /* enable guarded storage */
0029     unsigned long cr8_63 = 0x1; /* monitor mask = 1 */
0030     unsigned long cr10 = 1;     /* PER START */
0031     unsigned long cr11 = -1;    /* PER END */
0032
0033
0034     /* Dirty registers */
0035     asm volatile (
0036         "   lghi    2,0x11\n"   /* Round toward 0 */
0037         "   sfpc    2\n"        /* set fpc to !=0 */
0038         "   lctlg   2,2,%0\n"
0039         "   lctlg   8,8,%1\n"
0040         "   lctlg   10,10,%2\n"
0041         "   lctlg   11,11,%3\n"
0042         /* now clobber some general purpose regs */
0043         "   llihh   0,0xffff\n"
0044         "   llihl   1,0x5555\n"
0045         "   llilh   2,0xaaaa\n"
0046         "   llill   3,0x0000\n"
0047         /* now clobber a floating point reg */
0048         "   lghi    4,0x1\n"
0049         "   cdgbr   0,4\n"
0050         /* now clobber an access reg */
0051         "   sar 9,4\n"
0052         /* We embed diag 501 here to control register content */
0053         "   diag 0,0,0x501\n"
0054         :
0055         : "m" (cr2_59), "m" (cr8_63), "m" (cr10), "m" (cr11)
0056         /* no clobber list as this should not return */
0057         );
0058 }
0059
0060 static void test_one_reg(struct kvm_vcpu *vcpu, uint64_t id, uint64_t value)
0061 {
0062     uint64_t eval_reg;
0063
0064     vcpu_get_reg(vcpu, id, &eval_reg);
0065     TEST_ASSERT(eval_reg == value, "value == 0x%lx", value);
0066 }
0067
0068 static void assert_noirq(struct kvm_vcpu *vcpu)
0069 {
0070     struct kvm_s390_irq_state irq_state;
0071     int irqs;
0072
0073     irq_state.len = sizeof(buf);
0074     irq_state.buf = (unsigned long)buf;
0075     irqs = __vcpu_ioctl(vcpu, KVM_S390_GET_IRQ_STATE, &irq_state);
0076     /*
0077      * irqs contains the number of retrieved interrupts. Any interrupt
0078      * (notably, the emergency call interrupt we have injected) should
0079      * be cleared by the resets, so this should be 0.
0080      */
0081     TEST_ASSERT(irqs >= 0, "Could not fetch IRQs: errno %d\n", errno);
0082     TEST_ASSERT(!irqs, "IRQ pending");
0083 }
0084
0085 static void assert_clear(struct kvm_vcpu *vcpu)
0086 {
0087     struct kvm_sync_regs *sync_regs = &vcpu->run->s.regs;
0088     struct kvm_sregs sregs;
0089     struct kvm_regs regs;
0090     struct kvm_fpu fpu;
0091
0092     vcpu_regs_get(vcpu, &regs);
0093     TEST_ASSERT(!memcmp(&regs.gprs, regs_null, sizeof(regs.gprs)), "grs == 0");
0094
0095     vcpu_sregs_get(vcpu, &sregs);
0096     TEST_ASSERT(!memcmp(&sregs.acrs, regs_null, sizeof(sregs.acrs)), "acrs == 0");
0097
0098     vcpu_fpu_get(vcpu, &fpu);
0099     TEST_ASSERT(!memcmp(&fpu.fprs, regs_null, sizeof(fpu.fprs)), "fprs == 0");
0100
0101     /* sync regs */
0102     TEST_ASSERT(!memcmp(sync_regs->gprs, regs_null, sizeof(sync_regs->gprs)),
0103             "gprs0-15 == 0 (sync_regs)");
0104
0105     TEST_ASSERT(!memcmp(sync_regs->acrs, regs_null, sizeof(sync_regs->acrs)),
0106             "acrs0-15 == 0 (sync_regs)");
0107
0108     TEST_ASSERT(!memcmp(sync_regs->vrs, regs_null, sizeof(sync_regs->vrs)),
0109             "vrs0-15 == 0 (sync_regs)");
0110 }
0111
0112 static void assert_initial_noclear(struct kvm_vcpu *vcpu)
0113 {
0114     struct kvm_sync_regs *sync_regs = &vcpu->run->s.regs;
0115
0116     TEST_ASSERT(sync_regs->gprs[0] == 0xffff000000000000UL,
0117             "gpr0 == 0xffff000000000000 (sync_regs)");
0118     TEST_ASSERT(sync_regs->gprs[1] == 0x0000555500000000UL,
0119             "gpr1 == 0x0000555500000000 (sync_regs)");
0120     TEST_ASSERT(sync_regs->gprs[2] == 0x00000000aaaa0000UL,
0121             "gpr2 == 0x00000000aaaa0000 (sync_regs)");
0122     TEST_ASSERT(sync_regs->gprs[3] == 0x0000000000000000UL,
0123             "gpr3 == 0x0000000000000000 (sync_regs)");
0124     TEST_ASSERT(sync_regs->fprs[0] == 0x3ff0000000000000UL,
0125             "fpr0 == 0f1 (sync_regs)");
0126     TEST_ASSERT(sync_regs->acrs[9] == 1, "ar9 == 1 (sync_regs)");
0127 }
0128
0129 static void assert_initial(struct kvm_vcpu *vcpu)
0130 {
0131     struct kvm_sync_regs *sync_regs = &vcpu->run->s.regs;
0132     struct kvm_sregs sregs;
0133     struct kvm_fpu fpu;
0134
0135     /* KVM_GET_SREGS */
0136     vcpu_sregs_get(vcpu, &sregs);
0137     TEST_ASSERT(sregs.crs[0] == 0xE0UL, "cr0 == 0xE0 (KVM_GET_SREGS)");
0138     TEST_ASSERT(sregs.crs[14] == 0xC2000000UL,
0139             "cr14 == 0xC2000000 (KVM_GET_SREGS)");
0140     TEST_ASSERT(!memcmp(&sregs.crs[1], regs_null, sizeof(sregs.crs[1]) * 12),
0141             "cr1-13 == 0 (KVM_GET_SREGS)");
0142     TEST_ASSERT(sregs.crs[15] == 0, "cr15 == 0 (KVM_GET_SREGS)");
0143
0144     /* sync regs */
0145     TEST_ASSERT(sync_regs->crs[0] == 0xE0UL, "cr0 == 0xE0 (sync_regs)");
0146     TEST_ASSERT(sync_regs->crs[14] == 0xC2000000UL,
0147             "cr14 == 0xC2000000 (sync_regs)");
0148     TEST_ASSERT(!memcmp(&sync_regs->crs[1], regs_null, 8 * 12),
0149             "cr1-13 == 0 (sync_regs)");
0150     TEST_ASSERT(sync_regs->crs[15] == 0, "cr15 == 0 (sync_regs)");
0151     TEST_ASSERT(sync_regs->fpc == 0, "fpc == 0 (sync_regs)");
0152     TEST_ASSERT(sync_regs->todpr == 0, "todpr == 0 (sync_regs)");
0153     TEST_ASSERT(sync_regs->cputm == 0, "cputm == 0 (sync_regs)");
0154     TEST_ASSERT(sync_regs->ckc == 0, "ckc == 0 (sync_regs)");
0155     TEST_ASSERT(sync_regs->pp == 0, "pp == 0 (sync_regs)");
0156     TEST_ASSERT(sync_regs->gbea == 1, "gbea == 1 (sync_regs)");
0157
0158     /* kvm_run */
0159     TEST_ASSERT(vcpu->run->psw_addr == 0, "psw_addr == 0 (kvm_run)");
0160     TEST_ASSERT(vcpu->run->psw_mask == 0, "psw_mask == 0 (kvm_run)");
0161
0162     vcpu_fpu_get(vcpu, &fpu);
0163     TEST_ASSERT(!fpu.fpc, "fpc == 0");
0164
0165     test_one_reg(vcpu, KVM_REG_S390_GBEA, 1);
0166     test_one_reg(vcpu, KVM_REG_S390_PP, 0);
0167     test_one_reg(vcpu, KVM_REG_S390_TODPR, 0);
0168     test_one_reg(vcpu, KVM_REG_S390_CPU_TIMER, 0);
0169     test_one_reg(vcpu, KVM_REG_S390_CLOCK_COMP, 0);
0170 }
0171
0172 static void assert_normal_noclear(struct kvm_vcpu *vcpu)
0173 {
0174     struct kvm_sync_regs *sync_regs = &vcpu->run->s.regs;
0175
0176     TEST_ASSERT(sync_regs->crs[2] == 0x10, "cr2 == 10 (sync_regs)");
0177     TEST_ASSERT(sync_regs->crs[8] == 1, "cr10 == 1 (sync_regs)");
0178     TEST_ASSERT(sync_regs->crs[10] == 1, "cr10 == 1 (sync_regs)");
0179     TEST_ASSERT(sync_regs->crs[11] == -1, "cr11 == -1 (sync_regs)");
0180 }
0181
0182 static void assert_normal(struct kvm_vcpu *vcpu)
0183 {
0184     test_one_reg(vcpu, KVM_REG_S390_PFTOKEN, KVM_S390_PFAULT_TOKEN_INVALID);
0185     TEST_ASSERT(vcpu->run->s.regs.pft == KVM_S390_PFAULT_TOKEN_INVALID,
0186             "pft == 0xff.....  (sync_regs)");
0187     assert_noirq(vcpu);
0188 }
0189
0190 static void inject_irq(struct kvm_vcpu *vcpu)
0191 {
0192     struct kvm_s390_irq_state irq_state;
0193     struct kvm_s390_irq *irq = &buf[0];
0194     int irqs;
0195
0196     /* Inject IRQ */
0197     irq_state.len = sizeof(struct kvm_s390_irq);
0198     irq_state.buf = (unsigned long)buf;
0199     irq->type = KVM_S390_INT_EMERGENCY;
0200     irq->u.emerg.code = vcpu->id;
0201     irqs = __vcpu_ioctl(vcpu, KVM_S390_SET_IRQ_STATE, &irq_state);
0202     TEST_ASSERT(irqs >= 0, "Error injecting EMERGENCY IRQ errno %d\n", errno);
0203 }
0204
0205 static struct kvm_vm *create_vm(struct kvm_vcpu **vcpu)
0206 {
0207     struct kvm_vm *vm;
0208
0209     vm = vm_create(1);
0210
0211     *vcpu = vm_vcpu_add(vm, ARBITRARY_NON_ZERO_VCPU_ID, guest_code_initial);
0212
0213     return vm;
0214 }
0215
0216 static void test_normal(void)
0217 {
0218     struct kvm_vcpu *vcpu;
0219     struct kvm_vm *vm;
0220
0221     ksft_print_msg("Testing normal reset\n");
0222     vm = create_vm(&vcpu);
0223
0224     vcpu_run(vcpu);
0225
0226     inject_irq(vcpu);
0227
0228     vcpu_ioctl(vcpu, KVM_S390_NORMAL_RESET, NULL);
0229
0230     /* must clears */
0231     assert_normal(vcpu);
0232     /* must not clears */
0233     assert_normal_noclear(vcpu);
0234     assert_initial_noclear(vcpu);
0235
0236     kvm_vm_free(vm);
0237 }
0238
0239 static void test_initial(void)
0240 {
0241     struct kvm_vcpu *vcpu;
0242     struct kvm_vm *vm;
0243
0244     ksft_print_msg("Testing initial reset\n");
0245     vm = create_vm(&vcpu);
0246
0247     vcpu_run(vcpu);
0248
0249     inject_irq(vcpu);
0250
0251     vcpu_ioctl(vcpu, KVM_S390_INITIAL_RESET, NULL);
0252
0253     /* must clears */
0254     assert_normal(vcpu);
0255     assert_initial(vcpu);
0256     /* must not clears */
0257     assert_initial_noclear(vcpu);
0258
0259     kvm_vm_free(vm);
0260 }
0261
0262 static void test_clear(void)
0263 {
0264     struct kvm_vcpu *vcpu;
0265     struct kvm_vm *vm;
0266
0267     ksft_print_msg("Testing clear reset\n");
0268     vm = create_vm(&vcpu);
0269
0270     vcpu_run(vcpu);
0271
0272     inject_irq(vcpu);
0273
0274     vcpu_ioctl(vcpu, KVM_S390_CLEAR_RESET, NULL);
0275
0276     /* must clears */
0277     assert_normal(vcpu);
0278     assert_initial(vcpu);
0279     assert_clear(vcpu);
0280
0281     kvm_vm_free(vm);
0282 }
0283
0284 struct testdef {
0285     const char *name;
0286     void (*test)(void);
0287     bool needs_cap;
0288 } testlist[] = {
0289     { "initial", test_initial, false },
0290     { "normal", test_normal, true },
0291     { "clear", test_clear, true },
0292 };
0293
0294 int main(int argc, char *argv[])
0295 {
0296     bool has_s390_vcpu_resets = kvm_check_cap(KVM_CAP_S390_VCPU_RESETS);
0297     int idx;
0298
0299     setbuf(stdout, NULL);   /* Tell stdout not to buffer its content */
0300
0301     ksft_print_header();
0302     ksft_set_plan(ARRAY_SIZE(testlist));
0303
0304     for (idx = 0; idx < ARRAY_SIZE(testlist); idx++) {
0305         if (!testlist[idx].needs_cap || has_s390_vcpu_resets) {
0306             testlist[idx].test();
0307             ksft_test_result_pass("%s\n", testlist[idx].name);
0308         } else {
0309             ksft_test_result_skip("%s - no VCPU_RESETS capability\n",
0310                           testlist[idx].name);
0311         }
0312     }
0313
0314     ksft_finished();    /* Print results and exit() accordingly */
0315 }