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
16 #define VCPU_ID 3
17 #define LOCAL_IRQS 32
18
19 struct kvm_s390_irq buf[VCPU_ID + LOCAL_IRQS];
20
21 struct kvm_vm *vm;
22 struct kvm_run *run;
23 struct kvm_sync_regs *sync_regs;
24 static uint8_t regs_null[512];
25
guest_code_initial(void)26 static void guest_code_initial(void)
27 {
28 /* set several CRs to "safe" value */
29 unsigned long cr2_59 = 0x10; /* enable guarded storage */
30 unsigned long cr8_63 = 0x1; /* monitor mask = 1 */
31 unsigned long cr10 = 1; /* PER START */
32 unsigned long cr11 = -1; /* PER END */
33
34
35 /* Dirty registers */
36 asm volatile (
37 " lghi 2,0x11\n" /* Round toward 0 */
38 " sfpc 2\n" /* set fpc to !=0 */
39 " lctlg 2,2,%0\n"
40 " lctlg 8,8,%1\n"
41 " lctlg 10,10,%2\n"
42 " lctlg 11,11,%3\n"
43 /* now clobber some general purpose regs */
44 " llihh 0,0xffff\n"
45 " llihl 1,0x5555\n"
46 " llilh 2,0xaaaa\n"
47 " llill 3,0x0000\n"
48 /* now clobber a floating point reg */
49 " lghi 4,0x1\n"
50 " cdgbr 0,4\n"
51 /* now clobber an access reg */
52 " sar 9,4\n"
53 /* We embed diag 501 here to control register content */
54 " diag 0,0,0x501\n"
55 :
56 : "m" (cr2_59), "m" (cr8_63), "m" (cr10), "m" (cr11)
57 /* no clobber list as this should not return */
58 );
59 }
60
test_one_reg(uint64_t id,uint64_t value)61 static void test_one_reg(uint64_t id, uint64_t value)
62 {
63 struct kvm_one_reg reg;
64 uint64_t eval_reg;
65
66 reg.addr = (uintptr_t)&eval_reg;
67 reg.id = id;
68 vcpu_get_reg(vm, VCPU_ID, ®);
69 TEST_ASSERT(eval_reg == value, "value == 0x%lx", value);
70 }
71
assert_noirq(void)72 static void assert_noirq(void)
73 {
74 struct kvm_s390_irq_state irq_state;
75 int irqs;
76
77 irq_state.len = sizeof(buf);
78 irq_state.buf = (unsigned long)buf;
79 irqs = _vcpu_ioctl(vm, VCPU_ID, KVM_S390_GET_IRQ_STATE, &irq_state);
80 /*
81 * irqs contains the number of retrieved interrupts. Any interrupt
82 * (notably, the emergency call interrupt we have injected) should
83 * be cleared by the resets, so this should be 0.
84 */
85 TEST_ASSERT(irqs >= 0, "Could not fetch IRQs: errno %d\n", errno);
86 TEST_ASSERT(!irqs, "IRQ pending");
87 }
88
assert_clear(void)89 static void assert_clear(void)
90 {
91 struct kvm_sregs sregs;
92 struct kvm_regs regs;
93 struct kvm_fpu fpu;
94
95 vcpu_regs_get(vm, VCPU_ID, ®s);
96 TEST_ASSERT(!memcmp(®s.gprs, regs_null, sizeof(regs.gprs)), "grs == 0");
97
98 vcpu_sregs_get(vm, VCPU_ID, &sregs);
99 TEST_ASSERT(!memcmp(&sregs.acrs, regs_null, sizeof(sregs.acrs)), "acrs == 0");
100
101 vcpu_fpu_get(vm, VCPU_ID, &fpu);
102 TEST_ASSERT(!memcmp(&fpu.fprs, regs_null, sizeof(fpu.fprs)), "fprs == 0");
103
104 /* sync regs */
105 TEST_ASSERT(!memcmp(sync_regs->gprs, regs_null, sizeof(sync_regs->gprs)),
106 "gprs0-15 == 0 (sync_regs)");
107
108 TEST_ASSERT(!memcmp(sync_regs->acrs, regs_null, sizeof(sync_regs->acrs)),
109 "acrs0-15 == 0 (sync_regs)");
110
111 TEST_ASSERT(!memcmp(sync_regs->vrs, regs_null, sizeof(sync_regs->vrs)),
112 "vrs0-15 == 0 (sync_regs)");
113 }
114
assert_initial_noclear(void)115 static void assert_initial_noclear(void)
116 {
117 TEST_ASSERT(sync_regs->gprs[0] == 0xffff000000000000UL,
118 "gpr0 == 0xffff000000000000 (sync_regs)");
119 TEST_ASSERT(sync_regs->gprs[1] == 0x0000555500000000UL,
120 "gpr1 == 0x0000555500000000 (sync_regs)");
121 TEST_ASSERT(sync_regs->gprs[2] == 0x00000000aaaa0000UL,
122 "gpr2 == 0x00000000aaaa0000 (sync_regs)");
123 TEST_ASSERT(sync_regs->gprs[3] == 0x0000000000000000UL,
124 "gpr3 == 0x0000000000000000 (sync_regs)");
125 TEST_ASSERT(sync_regs->fprs[0] == 0x3ff0000000000000UL,
126 "fpr0 == 0f1 (sync_regs)");
127 TEST_ASSERT(sync_regs->acrs[9] == 1, "ar9 == 1 (sync_regs)");
128 }
129
assert_initial(void)130 static void assert_initial(void)
131 {
132 struct kvm_sregs sregs;
133 struct kvm_fpu fpu;
134
135 /* KVM_GET_SREGS */
136 vcpu_sregs_get(vm, VCPU_ID, &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(run->psw_addr == 0, "psw_addr == 0 (kvm_run)");
160 TEST_ASSERT(run->psw_mask == 0, "psw_mask == 0 (kvm_run)");
161
162 vcpu_fpu_get(vm, VCPU_ID, &fpu);
163 TEST_ASSERT(!fpu.fpc, "fpc == 0");
164
165 test_one_reg(KVM_REG_S390_GBEA, 1);
166 test_one_reg(KVM_REG_S390_PP, 0);
167 test_one_reg(KVM_REG_S390_TODPR, 0);
168 test_one_reg(KVM_REG_S390_CPU_TIMER, 0);
169 test_one_reg(KVM_REG_S390_CLOCK_COMP, 0);
170 }
171
assert_normal_noclear(void)172 static void assert_normal_noclear(void)
173 {
174 TEST_ASSERT(sync_regs->crs[2] == 0x10, "cr2 == 10 (sync_regs)");
175 TEST_ASSERT(sync_regs->crs[8] == 1, "cr10 == 1 (sync_regs)");
176 TEST_ASSERT(sync_regs->crs[10] == 1, "cr10 == 1 (sync_regs)");
177 TEST_ASSERT(sync_regs->crs[11] == -1, "cr11 == -1 (sync_regs)");
178 }
179
assert_normal(void)180 static void assert_normal(void)
181 {
182 test_one_reg(KVM_REG_S390_PFTOKEN, KVM_S390_PFAULT_TOKEN_INVALID);
183 TEST_ASSERT(sync_regs->pft == KVM_S390_PFAULT_TOKEN_INVALID,
184 "pft == 0xff..... (sync_regs)");
185 assert_noirq();
186 }
187
inject_irq(int cpu_id)188 static void inject_irq(int cpu_id)
189 {
190 struct kvm_s390_irq_state irq_state;
191 struct kvm_s390_irq *irq = &buf[0];
192 int irqs;
193
194 /* Inject IRQ */
195 irq_state.len = sizeof(struct kvm_s390_irq);
196 irq_state.buf = (unsigned long)buf;
197 irq->type = KVM_S390_INT_EMERGENCY;
198 irq->u.emerg.code = cpu_id;
199 irqs = _vcpu_ioctl(vm, cpu_id, KVM_S390_SET_IRQ_STATE, &irq_state);
200 TEST_ASSERT(irqs >= 0, "Error injecting EMERGENCY IRQ errno %d\n", errno);
201 }
202
test_normal(void)203 static void test_normal(void)
204 {
205 pr_info("Testing normal reset\n");
206 /* Create VM */
207 vm = vm_create_default(VCPU_ID, 0, guest_code_initial);
208 run = vcpu_state(vm, VCPU_ID);
209 sync_regs = &run->s.regs;
210
211 vcpu_run(vm, VCPU_ID);
212
213 inject_irq(VCPU_ID);
214
215 vcpu_ioctl(vm, VCPU_ID, KVM_S390_NORMAL_RESET, 0);
216
217 /* must clears */
218 assert_normal();
219 /* must not clears */
220 assert_normal_noclear();
221 assert_initial_noclear();
222
223 kvm_vm_free(vm);
224 }
225
test_initial(void)226 static void test_initial(void)
227 {
228 pr_info("Testing initial reset\n");
229 vm = vm_create_default(VCPU_ID, 0, guest_code_initial);
230 run = vcpu_state(vm, VCPU_ID);
231 sync_regs = &run->s.regs;
232
233 vcpu_run(vm, VCPU_ID);
234
235 inject_irq(VCPU_ID);
236
237 vcpu_ioctl(vm, VCPU_ID, KVM_S390_INITIAL_RESET, 0);
238
239 /* must clears */
240 assert_normal();
241 assert_initial();
242 /* must not clears */
243 assert_initial_noclear();
244
245 kvm_vm_free(vm);
246 }
247
test_clear(void)248 static void test_clear(void)
249 {
250 pr_info("Testing clear reset\n");
251 vm = vm_create_default(VCPU_ID, 0, guest_code_initial);
252 run = vcpu_state(vm, VCPU_ID);
253 sync_regs = &run->s.regs;
254
255 vcpu_run(vm, VCPU_ID);
256
257 inject_irq(VCPU_ID);
258
259 vcpu_ioctl(vm, VCPU_ID, KVM_S390_CLEAR_RESET, 0);
260
261 /* must clears */
262 assert_normal();
263 assert_initial();
264 assert_clear();
265
266 kvm_vm_free(vm);
267 }
268
main(int argc,char * argv[])269 int main(int argc, char *argv[])
270 {
271 setbuf(stdout, NULL); /* Tell stdout not to buffer its content */
272
273 test_initial();
274 if (kvm_check_cap(KVM_CAP_S390_VCPU_RESETS)) {
275 test_normal();
276 test_clear();
277 }
278 return 0;
279 }
280