usb-bsd: convert to QOM
[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 ICPT_INSTRUCTION 0x04
53 #define ICPT_WAITPSW 0x1c
54 #define ICPT_SOFT_INTERCEPT 0x24
55 #define ICPT_CPU_STOP 0x28
56 #define ICPT_IO 0x40
57
58 #define SIGP_RESTART 0x06
59 #define SIGP_INITIAL_CPU_RESET 0x0b
60 #define SIGP_STORE_STATUS_ADDR 0x0e
61 #define SIGP_SET_ARCH 0x12
62
63 #define SCLP_CMDW_READ_SCP_INFO 0x00020001
64 #define SCLP_CMDW_READ_SCP_INFO_FORCED 0x00120001
65
66 const KVMCapabilityInfo kvm_arch_required_capabilities[] = {
67 KVM_CAP_LAST_INFO
68 };
69
70 int kvm_arch_init(KVMState *s)
71 {
72 return 0;
73 }
74
75 int kvm_arch_init_vcpu(CPUState *env)
76 {
77 int ret = 0;
78
79 if (kvm_vcpu_ioctl(env, KVM_S390_INITIAL_RESET, NULL) < 0) {
80 perror("cannot init reset vcpu");
81 }
82
83 return ret;
84 }
85
86 void kvm_arch_reset_vcpu(CPUState *env)
87 {
88 /* FIXME: add code to reset vcpu. */
89 }
90
91 int kvm_arch_put_registers(CPUState *env, int level)
92 {
93 struct kvm_regs regs;
94 int ret;
95 int i;
96
97 ret = kvm_vcpu_ioctl(env, KVM_GET_REGS, &regs);
98 if (ret < 0) {
99 return ret;
100 }
101
102 for (i = 0; i < 16; i++) {
103 regs.gprs[i] = env->regs[i];
104 }
105
106 ret = kvm_vcpu_ioctl(env, KVM_SET_REGS, &regs);
107 if (ret < 0) {
108 return ret;
109 }
110
111 env->kvm_run->psw_addr = env->psw.addr;
112 env->kvm_run->psw_mask = env->psw.mask;
113
114 return ret;
115 }
116
117 int kvm_arch_get_registers(CPUState *env)
118 {
119 int ret;
120 struct kvm_regs regs;
121 int i;
122
123 ret = kvm_vcpu_ioctl(env, KVM_GET_REGS, &regs);
124 if (ret < 0) {
125 return ret;
126 }
127
128 for (i = 0; i < 16; i++) {
129 env->regs[i] = regs.gprs[i];
130 }
131
132 env->psw.addr = env->kvm_run->psw_addr;
133 env->psw.mask = env->kvm_run->psw_mask;
134
135 return 0;
136 }
137
138 int kvm_arch_insert_sw_breakpoint(CPUState *env, struct kvm_sw_breakpoint *bp)
139 {
140 static const uint8_t diag_501[] = {0x83, 0x24, 0x05, 0x01};
141
142 if (cpu_memory_rw_debug(env, bp->pc, (uint8_t *)&bp->saved_insn, 4, 0) ||
143 cpu_memory_rw_debug(env, bp->pc, (uint8_t *)diag_501, 4, 1)) {
144 return -EINVAL;
145 }
146 return 0;
147 }
148
149 int kvm_arch_remove_sw_breakpoint(CPUState *env, struct kvm_sw_breakpoint *bp)
150 {
151 uint8_t t[4];
152 static const uint8_t diag_501[] = {0x83, 0x24, 0x05, 0x01};
153
154 if (cpu_memory_rw_debug(env, bp->pc, t, 4, 0)) {
155 return -EINVAL;
156 } else if (memcmp(t, diag_501, 4)) {
157 return -EINVAL;
158 } else if (cpu_memory_rw_debug(env, bp->pc, (uint8_t *)&bp->saved_insn, 1, 1)) {
159 return -EINVAL;
160 }
161
162 return 0;
163 }
164
165 void kvm_arch_pre_run(CPUState *env, struct kvm_run *run)
166 {
167 }
168
169 void kvm_arch_post_run(CPUState *env, struct kvm_run *run)
170 {
171 }
172
173 int kvm_arch_process_async_events(CPUState *env)
174 {
175 return env->halted;
176 }
177
178 void kvm_s390_interrupt_internal(CPUState *env, int type, uint32_t parm,
179 uint64_t parm64, int vm)
180 {
181 struct kvm_s390_interrupt kvmint;
182 int r;
183
184 if (!env->kvm_state) {
185 return;
186 }
187
188 kvmint.type = type;
189 kvmint.parm = parm;
190 kvmint.parm64 = parm64;
191
192 if (vm) {
193 r = kvm_vm_ioctl(env->kvm_state, KVM_S390_INTERRUPT, &kvmint);
194 } else {
195 r = kvm_vcpu_ioctl(env, KVM_S390_INTERRUPT, &kvmint);
196 }
197
198 if (r < 0) {
199 fprintf(stderr, "KVM failed to inject interrupt\n");
200 exit(1);
201 }
202 }
203
204 void kvm_s390_virtio_irq(CPUState *env, int config_change, uint64_t token)
205 {
206 kvm_s390_interrupt_internal(env, KVM_S390_INT_VIRTIO, config_change,
207 token, 1);
208 }
209
210 void kvm_s390_interrupt(CPUState *env, int type, uint32_t code)
211 {
212 kvm_s390_interrupt_internal(env, type, code, 0, 0);
213 }
214
215 static void enter_pgmcheck(CPUState *env, uint16_t code)
216 {
217 kvm_s390_interrupt(env, KVM_S390_PROGRAM_INT, code);
218 }
219
220 static inline void setcc(CPUState *env, uint64_t cc)
221 {
222 env->kvm_run->psw_mask &= ~(3ull << 44);
223 env->kvm_run->psw_mask |= (cc & 3) << 44;
224
225 env->psw.mask &= ~(3ul << 44);
226 env->psw.mask |= (cc & 3) << 44;
227 }
228
229 static int kvm_sclp_service_call(CPUState *env, struct kvm_run *run,
230 uint16_t ipbh0)
231 {
232 uint32_t sccb;
233 uint64_t code;
234 int r = 0;
235
236 cpu_synchronize_state(env);
237 sccb = env->regs[ipbh0 & 0xf];
238 code = env->regs[(ipbh0 & 0xf0) >> 4];
239
240 r = sclp_service_call(env, sccb, code);
241 if (r) {
242 setcc(env, 3);
243 }
244
245 return 0;
246 }
247
248 static int handle_priv(CPUState *env, struct kvm_run *run, uint8_t ipa1)
249 {
250 int r = 0;
251 uint16_t ipbh0 = (run->s390_sieic.ipb & 0xffff0000) >> 16;
252
253 dprintf("KVM: PRIV: %d\n", ipa1);
254 switch (ipa1) {
255 case PRIV_SCLP_CALL:
256 r = kvm_sclp_service_call(env, run, ipbh0);
257 break;
258 default:
259 dprintf("KVM: unknown PRIV: 0x%x\n", ipa1);
260 r = -1;
261 break;
262 }
263
264 return r;
265 }
266
267 static int handle_hypercall(CPUState *env, struct kvm_run *run)
268 {
269 cpu_synchronize_state(env);
270 env->regs[2] = s390_virtio_hypercall(env, env->regs[2], env->regs[1]);
271
272 return 0;
273 }
274
275 static int handle_diag(CPUState *env, struct kvm_run *run, int ipb_code)
276 {
277 int r = 0;
278
279 switch (ipb_code) {
280 case DIAG_KVM_HYPERCALL:
281 r = handle_hypercall(env, run);
282 break;
283 case DIAG_KVM_BREAKPOINT:
284 sleep(10);
285 break;
286 default:
287 dprintf("KVM: unknown DIAG: 0x%x\n", ipb_code);
288 r = -1;
289 break;
290 }
291
292 return r;
293 }
294
295 static int s390_cpu_restart(CPUState *env)
296 {
297 kvm_s390_interrupt(env, KVM_S390_RESTART, 0);
298 s390_add_running_cpu(env);
299 qemu_cpu_kick(env);
300 dprintf("DONE: SIGP cpu restart: %p\n", env);
301 return 0;
302 }
303
304 static int s390_store_status(CPUState *env, uint32_t parameter)
305 {
306 /* XXX */
307 fprintf(stderr, "XXX SIGP store status\n");
308 return -1;
309 }
310
311 static int s390_cpu_initial_reset(CPUState *env)
312 {
313 int i;
314
315 if (kvm_vcpu_ioctl(env, KVM_S390_INITIAL_RESET, NULL) < 0) {
316 perror("cannot init reset vcpu");
317 }
318
319 /* Manually zero out all registers */
320 cpu_synchronize_state(env);
321 for (i = 0; i < 16; i++) {
322 env->regs[i] = 0;
323 }
324
325 dprintf("DONE: SIGP initial reset: %p\n", env);
326 return 0;
327 }
328
329 static int handle_sigp(CPUState *env, struct kvm_run *run, uint8_t ipa1)
330 {
331 uint8_t order_code;
332 uint32_t parameter;
333 uint16_t cpu_addr;
334 uint8_t t;
335 int r = -1;
336 CPUState *target_env;
337
338 cpu_synchronize_state(env);
339
340 /* get order code */
341 order_code = run->s390_sieic.ipb >> 28;
342 if (order_code > 0) {
343 order_code = env->regs[order_code];
344 }
345 order_code += (run->s390_sieic.ipb & 0x0fff0000) >> 16;
346
347 /* get parameters */
348 t = (ipa1 & 0xf0) >> 4;
349 if (!(t % 2)) {
350 t++;
351 }
352
353 parameter = env->regs[t] & 0x7ffffe00;
354 cpu_addr = env->regs[ipa1 & 0x0f];
355
356 target_env = s390_cpu_addr2state(cpu_addr);
357 if (!target_env) {
358 goto out;
359 }
360
361 switch (order_code) {
362 case SIGP_RESTART:
363 r = s390_cpu_restart(target_env);
364 break;
365 case SIGP_STORE_STATUS_ADDR:
366 r = s390_store_status(target_env, parameter);
367 break;
368 case SIGP_SET_ARCH:
369 /* make the caller panic */
370 return -1;
371 case SIGP_INITIAL_CPU_RESET:
372 r = s390_cpu_initial_reset(target_env);
373 break;
374 default:
375 fprintf(stderr, "KVM: unknown SIGP: 0x%x\n", order_code);
376 break;
377 }
378
379 out:
380 setcc(env, r ? 3 : 0);
381 return 0;
382 }
383
384 static int handle_instruction(CPUState *env, struct kvm_run *run)
385 {
386 unsigned int ipa0 = (run->s390_sieic.ipa & 0xff00);
387 uint8_t ipa1 = run->s390_sieic.ipa & 0x00ff;
388 int ipb_code = (run->s390_sieic.ipb & 0x0fff0000) >> 16;
389 int r = -1;
390
391 dprintf("handle_instruction 0x%x 0x%x\n", run->s390_sieic.ipa, run->s390_sieic.ipb);
392 switch (ipa0) {
393 case IPA0_PRIV:
394 r = handle_priv(env, run, ipa1);
395 break;
396 case IPA0_DIAG:
397 r = handle_diag(env, run, ipb_code);
398 break;
399 case IPA0_SIGP:
400 r = handle_sigp(env, run, ipa1);
401 break;
402 }
403
404 if (r < 0) {
405 enter_pgmcheck(env, 0x0001);
406 }
407 return 0;
408 }
409
410 static int handle_intercept(CPUState *env)
411 {
412 struct kvm_run *run = env->kvm_run;
413 int icpt_code = run->s390_sieic.icptcode;
414 int r = 0;
415
416 dprintf("intercept: 0x%x (at 0x%lx)\n", icpt_code,
417 (long)env->kvm_run->psw_addr);
418 switch (icpt_code) {
419 case ICPT_INSTRUCTION:
420 r = handle_instruction(env, run);
421 break;
422 case ICPT_WAITPSW:
423 case ICPT_CPU_STOP:
424 if (s390_del_running_cpu(env) == 0) {
425 qemu_system_shutdown_request();
426 }
427 r = EXCP_HALTED;
428 break;
429 case ICPT_SOFT_INTERCEPT:
430 fprintf(stderr, "KVM unimplemented icpt SOFT\n");
431 exit(1);
432 break;
433 case ICPT_IO:
434 fprintf(stderr, "KVM unimplemented icpt IO\n");
435 exit(1);
436 break;
437 default:
438 fprintf(stderr, "Unknown intercept code: %d\n", icpt_code);
439 exit(1);
440 break;
441 }
442
443 return r;
444 }
445
446 int kvm_arch_handle_exit(CPUState *env, struct kvm_run *run)
447 {
448 int ret = 0;
449
450 switch (run->exit_reason) {
451 case KVM_EXIT_S390_SIEIC:
452 ret = handle_intercept(env);
453 break;
454 case KVM_EXIT_S390_RESET:
455 fprintf(stderr, "RESET not implemented\n");
456 exit(1);
457 break;
458 default:
459 fprintf(stderr, "Unknown KVM exit: %d\n", run->exit_reason);
460 break;
461 }
462
463 if (ret == 0) {
464 ret = EXCP_INTERRUPT;
465 }
466 return ret;
467 }
468
469 bool kvm_arch_stop_on_emulation_error(CPUState *env)
470 {
471 return true;
472 }
473
474 int kvm_arch_on_sigbus_vcpu(CPUState *env, int code, void *addr)
475 {
476 return 1;
477 }
478
479 int kvm_arch_on_sigbus(int code, void *addr)
480 {
481 return 1;
482 }