s390x: helper functions for system emulation
[qemu.git] / target-s390x / kvm.c
1 /*
2 * QEMU S390x KVM implementation
3 *
4 * Copyright (c) 2009 Alexander Graf <agraf@suse.de>
5 *
6 * This library is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2 of the License, or (at your option) any later version.
10 *
11 * This library is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
15 *
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with this library; if not, see <http://www.gnu.org/licenses/>.
18 */
19
20 #include <sys/types.h>
21 #include <sys/ioctl.h>
22 #include <sys/mman.h>
23
24 #include <linux/kvm.h>
25 #include <asm/ptrace.h>
26
27 #include "qemu-common.h"
28 #include "qemu-timer.h"
29 #include "sysemu.h"
30 #include "kvm.h"
31 #include "cpu.h"
32 #include "device_tree.h"
33
34 /* #define DEBUG_KVM */
35
36 #ifdef DEBUG_KVM
37 #define dprintf(fmt, ...) \
38 do { fprintf(stderr, fmt, ## __VA_ARGS__); } while (0)
39 #else
40 #define dprintf(fmt, ...) \
41 do { } while (0)
42 #endif
43
44 #define IPA0_DIAG 0x8300
45 #define IPA0_SIGP 0xae00
46 #define IPA0_PRIV 0xb200
47
48 #define PRIV_SCLP_CALL 0x20
49 #define DIAG_KVM_HYPERCALL 0x500
50 #define DIAG_KVM_BREAKPOINT 0x501
51
52 #define SCP_LENGTH 0x00
53 #define SCP_FUNCTION_CODE 0x02
54 #define SCP_CONTROL_MASK 0x03
55 #define SCP_RESPONSE_CODE 0x06
56 #define SCP_MEM_CODE 0x08
57 #define SCP_INCREMENT 0x0a
58
59 #define ICPT_INSTRUCTION 0x04
60 #define ICPT_WAITPSW 0x1c
61 #define ICPT_SOFT_INTERCEPT 0x24
62 #define ICPT_CPU_STOP 0x28
63 #define ICPT_IO 0x40
64
65 #define SIGP_RESTART 0x06
66 #define SIGP_INITIAL_CPU_RESET 0x0b
67 #define SIGP_STORE_STATUS_ADDR 0x0e
68 #define SIGP_SET_ARCH 0x12
69
70 #define SCLP_CMDW_READ_SCP_INFO 0x00020001
71 #define SCLP_CMDW_READ_SCP_INFO_FORCED 0x00120001
72
73 const KVMCapabilityInfo kvm_arch_required_capabilities[] = {
74 KVM_CAP_LAST_INFO
75 };
76
77 int kvm_arch_init(KVMState *s)
78 {
79 return 0;
80 }
81
82 int kvm_arch_init_vcpu(CPUState *env)
83 {
84 int ret = 0;
85
86 if (kvm_vcpu_ioctl(env, KVM_S390_INITIAL_RESET, NULL) < 0) {
87 perror("cannot init reset vcpu");
88 }
89
90 return ret;
91 }
92
93 void kvm_arch_reset_vcpu(CPUState *env)
94 {
95 /* FIXME: add code to reset vcpu. */
96 }
97
98 int kvm_arch_put_registers(CPUState *env, int level)
99 {
100 struct kvm_regs regs;
101 int ret;
102 int i;
103
104 ret = kvm_vcpu_ioctl(env, KVM_GET_REGS, &regs);
105 if (ret < 0) {
106 return ret;
107 }
108
109 for (i = 0; i < 16; i++) {
110 regs.gprs[i] = env->regs[i];
111 }
112
113 ret = kvm_vcpu_ioctl(env, KVM_SET_REGS, &regs);
114 if (ret < 0) {
115 return ret;
116 }
117
118 env->kvm_run->psw_addr = env->psw.addr;
119 env->kvm_run->psw_mask = env->psw.mask;
120
121 return ret;
122 }
123
124 int kvm_arch_get_registers(CPUState *env)
125 {
126 int ret;
127 struct kvm_regs regs;
128 int i;
129
130 ret = kvm_vcpu_ioctl(env, KVM_GET_REGS, &regs);
131 if (ret < 0) {
132 return ret;
133 }
134
135 for (i = 0; i < 16; i++) {
136 env->regs[i] = regs.gprs[i];
137 }
138
139 env->psw.addr = env->kvm_run->psw_addr;
140 env->psw.mask = env->kvm_run->psw_mask;
141
142 return 0;
143 }
144
145 int kvm_arch_insert_sw_breakpoint(CPUState *env, struct kvm_sw_breakpoint *bp)
146 {
147 static const uint8_t diag_501[] = {0x83, 0x24, 0x05, 0x01};
148
149 if (cpu_memory_rw_debug(env, bp->pc, (uint8_t *)&bp->saved_insn, 4, 0) ||
150 cpu_memory_rw_debug(env, bp->pc, (uint8_t *)diag_501, 4, 1)) {
151 return -EINVAL;
152 }
153 return 0;
154 }
155
156 int kvm_arch_remove_sw_breakpoint(CPUState *env, struct kvm_sw_breakpoint *bp)
157 {
158 uint8_t t[4];
159 static const uint8_t diag_501[] = {0x83, 0x24, 0x05, 0x01};
160
161 if (cpu_memory_rw_debug(env, bp->pc, t, 4, 0)) {
162 return -EINVAL;
163 } else if (memcmp(t, diag_501, 4)) {
164 return -EINVAL;
165 } else if (cpu_memory_rw_debug(env, bp->pc, (uint8_t *)&bp->saved_insn, 1, 1)) {
166 return -EINVAL;
167 }
168
169 return 0;
170 }
171
172 void kvm_arch_pre_run(CPUState *env, struct kvm_run *run)
173 {
174 }
175
176 void kvm_arch_post_run(CPUState *env, struct kvm_run *run)
177 {
178 }
179
180 int kvm_arch_process_async_events(CPUState *env)
181 {
182 return env->halted;
183 }
184
185 void kvm_s390_interrupt_internal(CPUState *env, int type, uint32_t parm,
186 uint64_t parm64, int vm)
187 {
188 struct kvm_s390_interrupt kvmint;
189 int r;
190
191 if (!env->kvm_state) {
192 return;
193 }
194
195 env->halted = 0;
196 env->exception_index = -1;
197 qemu_cpu_kick(env);
198
199 kvmint.type = type;
200 kvmint.parm = parm;
201 kvmint.parm64 = parm64;
202
203 if (vm) {
204 r = kvm_vm_ioctl(env->kvm_state, KVM_S390_INTERRUPT, &kvmint);
205 } else {
206 r = kvm_vcpu_ioctl(env, KVM_S390_INTERRUPT, &kvmint);
207 }
208
209 if (r < 0) {
210 fprintf(stderr, "KVM failed to inject interrupt\n");
211 exit(1);
212 }
213 }
214
215 void kvm_s390_virtio_irq(CPUState *env, int config_change, uint64_t token)
216 {
217 kvm_s390_interrupt_internal(env, KVM_S390_INT_VIRTIO, config_change,
218 token, 1);
219 }
220
221 void kvm_s390_interrupt(CPUState *env, int type, uint32_t code)
222 {
223 kvm_s390_interrupt_internal(env, type, code, 0, 0);
224 }
225
226 static void enter_pgmcheck(CPUState *env, uint16_t code)
227 {
228 kvm_s390_interrupt(env, KVM_S390_PROGRAM_INT, code);
229 }
230
231 static void setcc(CPUState *env, uint64_t cc)
232 {
233 env->kvm_run->psw_mask &= ~(3ul << 44);
234 env->kvm_run->psw_mask |= (cc & 3) << 44;
235
236 env->psw.mask &= ~(3ul << 44);
237 env->psw.mask |= (cc & 3) << 44;
238 }
239
240 static int kvm_sclp_service_call(CPUState *env, struct kvm_run *run,
241 uint16_t ipbh0)
242 {
243 uint32_t sccb;
244 uint64_t code;
245 int r = 0;
246
247 cpu_synchronize_state(env);
248 sccb = env->regs[ipbh0 & 0xf];
249 code = env->regs[(ipbh0 & 0xf0) >> 4];
250
251 dprintf("sclp(0x%x, 0x%lx)\n", sccb, code);
252
253 if (sccb & ~0x7ffffff8ul) {
254 fprintf(stderr, "KVM: invalid sccb address 0x%x\n", sccb);
255 r = -1;
256 goto out;
257 }
258
259 switch(code) {
260 case SCLP_CMDW_READ_SCP_INFO:
261 case SCLP_CMDW_READ_SCP_INFO_FORCED:
262 stw_phys(sccb + SCP_MEM_CODE, ram_size >> 20);
263 stb_phys(sccb + SCP_INCREMENT, 1);
264 stw_phys(sccb + SCP_RESPONSE_CODE, 0x10);
265 setcc(env, 0);
266
267 kvm_s390_interrupt_internal(env, KVM_S390_INT_SERVICE,
268 sccb & ~3, 0, 1);
269 break;
270 default:
271 dprintf("KVM: invalid sclp call 0x%x / 0x%lx\n", sccb, code);
272 r = -1;
273 break;
274 }
275
276 out:
277 if (r < 0) {
278 setcc(env, 3);
279 }
280 return 0;
281 }
282
283 static int handle_priv(CPUState *env, struct kvm_run *run, uint8_t ipa1)
284 {
285 int r = 0;
286 uint16_t ipbh0 = (run->s390_sieic.ipb & 0xffff0000) >> 16;
287
288 dprintf("KVM: PRIV: %d\n", ipa1);
289 switch (ipa1) {
290 case PRIV_SCLP_CALL:
291 r = kvm_sclp_service_call(env, run, ipbh0);
292 break;
293 default:
294 dprintf("KVM: unknown PRIV: 0x%x\n", ipa1);
295 r = -1;
296 break;
297 }
298
299 return r;
300 }
301
302 static int handle_hypercall(CPUState *env, struct kvm_run *run)
303 {
304 cpu_synchronize_state(env);
305 env->regs[2] = s390_virtio_hypercall(env, env->regs[2], env->regs[1]);
306
307 return 0;
308 }
309
310 static int handle_diag(CPUState *env, struct kvm_run *run, int ipb_code)
311 {
312 int r = 0;
313
314 switch (ipb_code) {
315 case DIAG_KVM_HYPERCALL:
316 r = handle_hypercall(env, run);
317 break;
318 case DIAG_KVM_BREAKPOINT:
319 sleep(10);
320 break;
321 default:
322 dprintf("KVM: unknown DIAG: 0x%x\n", ipb_code);
323 r = -1;
324 break;
325 }
326
327 return r;
328 }
329
330 static int s390_cpu_restart(CPUState *env)
331 {
332 kvm_s390_interrupt(env, KVM_S390_RESTART, 0);
333 env->halted = 0;
334 env->exception_index = -1;
335 qemu_cpu_kick(env);
336 dprintf("DONE: SIGP cpu restart: %p\n", env);
337 return 0;
338 }
339
340 static int s390_store_status(CPUState *env, uint32_t parameter)
341 {
342 /* XXX */
343 fprintf(stderr, "XXX SIGP store status\n");
344 return -1;
345 }
346
347 static int s390_cpu_initial_reset(CPUState *env)
348 {
349 int i;
350
351 if (kvm_vcpu_ioctl(env, KVM_S390_INITIAL_RESET, NULL) < 0) {
352 perror("cannot init reset vcpu");
353 }
354
355 /* Manually zero out all registers */
356 cpu_synchronize_state(env);
357 for (i = 0; i < 16; i++) {
358 env->regs[i] = 0;
359 }
360
361 dprintf("DONE: SIGP initial reset: %p\n", env);
362 return 0;
363 }
364
365 static int handle_sigp(CPUState *env, struct kvm_run *run, uint8_t ipa1)
366 {
367 uint8_t order_code;
368 uint32_t parameter;
369 uint16_t cpu_addr;
370 uint8_t t;
371 int r = -1;
372 CPUState *target_env;
373
374 cpu_synchronize_state(env);
375
376 /* get order code */
377 order_code = run->s390_sieic.ipb >> 28;
378 if (order_code > 0) {
379 order_code = env->regs[order_code];
380 }
381 order_code += (run->s390_sieic.ipb & 0x0fff0000) >> 16;
382
383 /* get parameters */
384 t = (ipa1 & 0xf0) >> 4;
385 if (!(t % 2)) {
386 t++;
387 }
388
389 parameter = env->regs[t] & 0x7ffffe00;
390 cpu_addr = env->regs[ipa1 & 0x0f];
391
392 target_env = s390_cpu_addr2state(cpu_addr);
393 if (!target_env) {
394 goto out;
395 }
396
397 switch (order_code) {
398 case SIGP_RESTART:
399 r = s390_cpu_restart(target_env);
400 break;
401 case SIGP_STORE_STATUS_ADDR:
402 r = s390_store_status(target_env, parameter);
403 break;
404 case SIGP_SET_ARCH:
405 /* make the caller panic */
406 return -1;
407 case SIGP_INITIAL_CPU_RESET:
408 r = s390_cpu_initial_reset(target_env);
409 break;
410 default:
411 fprintf(stderr, "KVM: unknown SIGP: 0x%x\n", ipa1);
412 break;
413 }
414
415 out:
416 setcc(env, r ? 3 : 0);
417 return 0;
418 }
419
420 static int handle_instruction(CPUState *env, struct kvm_run *run)
421 {
422 unsigned int ipa0 = (run->s390_sieic.ipa & 0xff00);
423 uint8_t ipa1 = run->s390_sieic.ipa & 0x00ff;
424 int ipb_code = (run->s390_sieic.ipb & 0x0fff0000) >> 16;
425 int r = -1;
426
427 dprintf("handle_instruction 0x%x 0x%x\n", run->s390_sieic.ipa, run->s390_sieic.ipb);
428 switch (ipa0) {
429 case IPA0_PRIV:
430 r = handle_priv(env, run, ipa1);
431 break;
432 case IPA0_DIAG:
433 r = handle_diag(env, run, ipb_code);
434 break;
435 case IPA0_SIGP:
436 r = handle_sigp(env, run, ipa1);
437 break;
438 }
439
440 if (r < 0) {
441 enter_pgmcheck(env, 0x0001);
442 }
443 return 0;
444 }
445
446 static int handle_intercept(CPUState *env)
447 {
448 struct kvm_run *run = env->kvm_run;
449 int icpt_code = run->s390_sieic.icptcode;
450 int r = 0;
451
452 dprintf("intercept: 0x%x (at 0x%lx)\n", icpt_code, env->kvm_run->psw_addr);
453 switch (icpt_code) {
454 case ICPT_INSTRUCTION:
455 r = handle_instruction(env, run);
456 break;
457 case ICPT_WAITPSW:
458 /* XXX What to do on system shutdown? */
459 env->halted = 1;
460 env->exception_index = EXCP_HLT;
461 break;
462 case ICPT_SOFT_INTERCEPT:
463 fprintf(stderr, "KVM unimplemented icpt SOFT\n");
464 exit(1);
465 break;
466 case ICPT_CPU_STOP:
467 qemu_system_shutdown_request();
468 break;
469 case ICPT_IO:
470 fprintf(stderr, "KVM unimplemented icpt IO\n");
471 exit(1);
472 break;
473 default:
474 fprintf(stderr, "Unknown intercept code: %d\n", icpt_code);
475 exit(1);
476 break;
477 }
478
479 return r;
480 }
481
482 int kvm_arch_handle_exit(CPUState *env, struct kvm_run *run)
483 {
484 int ret = 0;
485
486 switch (run->exit_reason) {
487 case KVM_EXIT_S390_SIEIC:
488 ret = handle_intercept(env);
489 break;
490 case KVM_EXIT_S390_RESET:
491 fprintf(stderr, "RESET not implemented\n");
492 exit(1);
493 break;
494 default:
495 fprintf(stderr, "Unknown KVM exit: %d\n", run->exit_reason);
496 break;
497 }
498
499 if (ret == 0) {
500 ret = EXCP_INTERRUPT;
501 } else if (ret > 0) {
502 ret = 0;
503 }
504 return ret;
505 }
506
507 bool kvm_arch_stop_on_emulation_error(CPUState *env)
508 {
509 return true;
510 }
511
512 int kvm_arch_on_sigbus_vcpu(CPUState *env, int code, void *addr)
513 {
514 return 1;
515 }
516
517 int kvm_arch_on_sigbus(int code, void *addr)
518 {
519 return 1;
520 }