Linux kernel mirror (for testing)
git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel
os
linux
1// SPDX-License-Identifier: GPL-2.0-or-later
2/*
3 * Test for s390x CPU resets
4 *
5 * Copyright (C) 2020, IBM
6 */
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 32
18
19#define ARBITRARY_NON_ZERO_VCPU_ID 3
20
21struct kvm_s390_irq buf[ARBITRARY_NON_ZERO_VCPU_ID + LOCAL_IRQS];
22
23static u8 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, u64 id, u64 value)
61{
62 u64 eval_reg;
63
64 eval_reg = vcpu_get_reg(vcpu, id);
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 interrupt
78 * (notably, the emergency call interrupt we have injected) should
79 * 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}