xref: /illumos-kvm-cmd/target-s390x/kvm.c (revision 68396ea9)
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 
kvm_arch_init(KVMState * s)77 int kvm_arch_init(KVMState *s)
78 {
79     return 0;
80 }
81 
kvm_arch_init_vcpu(CPUState * env)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 
kvm_arch_reset_vcpu(CPUState * env)93 void kvm_arch_reset_vcpu(CPUState *env)
94 {
95     /* FIXME: add code to reset vcpu. */
96 }
97 
kvm_arch_put_registers(CPUState * env,int level)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 
kvm_arch_get_registers(CPUState * env)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 
kvm_arch_insert_sw_breakpoint(CPUState * env,struct kvm_sw_breakpoint * bp)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 
kvm_arch_remove_sw_breakpoint(CPUState * env,struct kvm_sw_breakpoint * bp)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 
kvm_arch_pre_run(CPUState * env,struct kvm_run * run)172 int kvm_arch_pre_run(CPUState *env, struct kvm_run *run)
173 {
174     return 0;
175 }
176 
kvm_arch_post_run(CPUState * env,struct kvm_run * run)177 int kvm_arch_post_run(CPUState *env, struct kvm_run *run)
178 {
179     return 0;
180 }
181 
kvm_arch_process_irqchip_events(CPUState * env)182 int kvm_arch_process_irqchip_events(CPUState *env)
183 {
184     return 0;
185 }
186 
kvm_s390_interrupt_internal(CPUState * env,int type,uint32_t parm,uint64_t parm64,int vm)187 static void kvm_s390_interrupt_internal(CPUState *env, int type, uint32_t parm,
188                                         uint64_t parm64, int vm)
189 {
190     struct kvm_s390_interrupt kvmint;
191     int r;
192 
193     if (!env->kvm_state) {
194         return;
195     }
196 
197     env->halted = 0;
198     env->exception_index = -1;
199 
200     kvmint.type = type;
201     kvmint.parm = parm;
202     kvmint.parm64 = parm64;
203 
204     if (vm) {
205         r = kvm_vm_ioctl(env->kvm_state, KVM_S390_INTERRUPT, &kvmint);
206     } else {
207         r = kvm_vcpu_ioctl(env, KVM_S390_INTERRUPT, &kvmint);
208     }
209 
210     if (r < 0) {
211         fprintf(stderr, "KVM failed to inject interrupt\n");
212         exit(1);
213     }
214 }
215 
kvm_s390_virtio_irq(CPUState * env,int config_change,uint64_t token)216 void kvm_s390_virtio_irq(CPUState *env, int config_change, uint64_t token)
217 {
218     kvm_s390_interrupt_internal(env, KVM_S390_INT_VIRTIO, config_change,
219                                 token, 1);
220 }
221 
kvm_s390_interrupt(CPUState * env,int type,uint32_t code)222 static void kvm_s390_interrupt(CPUState *env, int type, uint32_t code)
223 {
224     kvm_s390_interrupt_internal(env, type, code, 0, 0);
225 }
226 
enter_pgmcheck(CPUState * env,uint16_t code)227 static void enter_pgmcheck(CPUState *env, uint16_t code)
228 {
229     kvm_s390_interrupt(env, KVM_S390_PROGRAM_INT, code);
230 }
231 
setcc(CPUState * env,uint64_t cc)232 static void setcc(CPUState *env, uint64_t cc)
233 {
234     env->kvm_run->psw_mask &= ~(3ul << 44);
235     env->kvm_run->psw_mask |= (cc & 3) << 44;
236 
237     env->psw.mask &= ~(3ul << 44);
238     env->psw.mask |= (cc & 3) << 44;
239 }
240 
sclp_service_call(CPUState * env,struct kvm_run * run,uint16_t ipbh0)241 static int sclp_service_call(CPUState *env, struct kvm_run *run, 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 
handle_priv(CPUState * env,struct kvm_run * run,uint8_t ipa1)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 = 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 
handle_hypercall(CPUState * env,struct kvm_run * run)302 static int handle_hypercall(CPUState *env, struct kvm_run *run)
303 {
304     int r;
305 
306     cpu_synchronize_state(env);
307     r = s390_virtio_hypercall(env);
308 
309     return r;
310 }
311 
handle_diag(CPUState * env,struct kvm_run * run,int ipb_code)312 static int handle_diag(CPUState *env, struct kvm_run *run, int ipb_code)
313 {
314     int r = 0;
315 
316     switch (ipb_code) {
317         case DIAG_KVM_HYPERCALL:
318             r = handle_hypercall(env, run);
319             break;
320         case DIAG_KVM_BREAKPOINT:
321             sleep(10);
322             break;
323         default:
324             dprintf("KVM: unknown DIAG: 0x%x\n", ipb_code);
325             r = -1;
326             break;
327     }
328 
329     return r;
330 }
331 
s390_cpu_restart(CPUState * env)332 static int s390_cpu_restart(CPUState *env)
333 {
334     kvm_s390_interrupt(env, KVM_S390_RESTART, 0);
335     env->halted = 0;
336     env->exception_index = -1;
337     qemu_cpu_kick(env);
338     dprintf("DONE: SIGP cpu restart: %p\n", env);
339     return 0;
340 }
341 
s390_store_status(CPUState * env,uint32_t parameter)342 static int s390_store_status(CPUState *env, uint32_t parameter)
343 {
344     /* XXX */
345     fprintf(stderr, "XXX SIGP store status\n");
346     return -1;
347 }
348 
s390_cpu_initial_reset(CPUState * env)349 static int s390_cpu_initial_reset(CPUState *env)
350 {
351     int i;
352 
353     if (kvm_vcpu_ioctl(env, KVM_S390_INITIAL_RESET, NULL) < 0) {
354         perror("cannot init reset vcpu");
355     }
356 
357     /* Manually zero out all registers */
358     cpu_synchronize_state(env);
359     for (i = 0; i < 16; i++) {
360         env->regs[i] = 0;
361     }
362 
363     dprintf("DONE: SIGP initial reset: %p\n", env);
364     return 0;
365 }
366 
handle_sigp(CPUState * env,struct kvm_run * run,uint8_t ipa1)367 static int handle_sigp(CPUState *env, struct kvm_run *run, uint8_t ipa1)
368 {
369     uint8_t order_code;
370     uint32_t parameter;
371     uint16_t cpu_addr;
372     uint8_t t;
373     int r = -1;
374     CPUState *target_env;
375 
376     cpu_synchronize_state(env);
377 
378     /* get order code */
379     order_code = run->s390_sieic.ipb >> 28;
380     if (order_code > 0) {
381         order_code = env->regs[order_code];
382     }
383     order_code += (run->s390_sieic.ipb & 0x0fff0000) >> 16;
384 
385     /* get parameters */
386     t = (ipa1 & 0xf0) >> 4;
387     if (!(t % 2)) {
388         t++;
389     }
390 
391     parameter = env->regs[t] & 0x7ffffe00;
392     cpu_addr = env->regs[ipa1 & 0x0f];
393 
394     target_env = s390_cpu_addr2state(cpu_addr);
395     if (!target_env) {
396         goto out;
397     }
398 
399     switch (order_code) {
400         case SIGP_RESTART:
401             r = s390_cpu_restart(target_env);
402             break;
403         case SIGP_STORE_STATUS_ADDR:
404             r = s390_store_status(target_env, parameter);
405             break;
406         case SIGP_SET_ARCH:
407             /* make the caller panic */
408             return -1;
409         case SIGP_INITIAL_CPU_RESET:
410             r = s390_cpu_initial_reset(target_env);
411             break;
412         default:
413             fprintf(stderr, "KVM: unknown SIGP: 0x%x\n", ipa1);
414             break;
415     }
416 
417 out:
418     setcc(env, r ? 3 : 0);
419     return 0;
420 }
421 
handle_instruction(CPUState * env,struct kvm_run * run)422 static int handle_instruction(CPUState *env, struct kvm_run *run)
423 {
424     unsigned int ipa0 = (run->s390_sieic.ipa & 0xff00);
425     uint8_t ipa1 = run->s390_sieic.ipa & 0x00ff;
426     int ipb_code = (run->s390_sieic.ipb & 0x0fff0000) >> 16;
427     int r = -1;
428 
429     dprintf("handle_instruction 0x%x 0x%x\n", run->s390_sieic.ipa, run->s390_sieic.ipb);
430     switch (ipa0) {
431         case IPA0_PRIV:
432             r = handle_priv(env, run, ipa1);
433             break;
434         case IPA0_DIAG:
435             r = handle_diag(env, run, ipb_code);
436             break;
437         case IPA0_SIGP:
438             r = handle_sigp(env, run, ipa1);
439             break;
440     }
441 
442     if (r < 0) {
443         enter_pgmcheck(env, 0x0001);
444     }
445     return r;
446 }
447 
handle_intercept(CPUState * env)448 static int handle_intercept(CPUState *env)
449 {
450     struct kvm_run *run = env->kvm_run;
451     int icpt_code = run->s390_sieic.icptcode;
452     int r = 0;
453 
454     dprintf("intercept: 0x%x (at 0x%lx)\n", icpt_code, env->kvm_run->psw_addr);
455     switch (icpt_code) {
456         case ICPT_INSTRUCTION:
457             r = handle_instruction(env, run);
458             break;
459         case ICPT_WAITPSW:
460             /* XXX What to do on system shutdown? */
461             env->halted = 1;
462             env->exception_index = EXCP_HLT;
463             break;
464         case ICPT_SOFT_INTERCEPT:
465             fprintf(stderr, "KVM unimplemented icpt SOFT\n");
466             exit(1);
467             break;
468         case ICPT_CPU_STOP:
469             qemu_system_shutdown_request();
470             break;
471         case ICPT_IO:
472             fprintf(stderr, "KVM unimplemented icpt IO\n");
473             exit(1);
474             break;
475         default:
476             fprintf(stderr, "Unknown intercept code: %d\n", icpt_code);
477             exit(1);
478             break;
479     }
480 
481     return r;
482 }
483 
kvm_arch_handle_exit(CPUState * env,struct kvm_run * run)484 int kvm_arch_handle_exit(CPUState *env, struct kvm_run *run)
485 {
486     int ret = 0;
487 
488     switch (run->exit_reason) {
489         case KVM_EXIT_S390_SIEIC:
490             ret = handle_intercept(env);
491             break;
492         case KVM_EXIT_S390_RESET:
493             fprintf(stderr, "RESET not implemented\n");
494             exit(1);
495             break;
496         default:
497             fprintf(stderr, "Unknown KVM exit: %d\n", run->exit_reason);
498             break;
499     }
500 
501     return ret;
502 }
503 
kvm_arch_stop_on_emulation_error(CPUState * env)504 bool kvm_arch_stop_on_emulation_error(CPUState *env)
505 {
506     return true;
507 }
508