xref: /openbmc/qemu/target/s390x/cpu.c (revision 64552b6b)
1 /*
2  * QEMU S/390 CPU
3  *
4  * Copyright (c) 2009 Ulrich Hecht
5  * Copyright (c) 2011 Alexander Graf
6  * Copyright (c) 2012 SUSE LINUX Products GmbH
7  * Copyright (c) 2012 IBM Corp.
8  *
9  * This program is free software; you can redistribute it and/or modify
10  * it under the terms of the GNU General Public License as published by
11  * the Free Software Foundation; either version 2 of the License, or
12  * (at your option) any later version.
13  *
14  * This program is distributed in the hope that it will be useful,
15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
17  * General Public License for more details.
18  *
19  * You should have received a copy of the GNU General Public License
20  * along with this program; if not, see <http://www.gnu.org/licenses/>.
21  */
22 
23 #include "qemu/osdep.h"
24 #include "qapi/error.h"
25 #include "cpu.h"
26 #include "internal.h"
27 #include "kvm_s390x.h"
28 #include "sysemu/kvm.h"
29 #include "sysemu/reset.h"
30 #include "qemu/timer.h"
31 #include "qemu/error-report.h"
32 #include "qemu/module.h"
33 #include "trace.h"
34 #include "qapi/visitor.h"
35 #include "qapi/qapi-types-machine.h"
36 #include "qapi/qapi-visit-run-state.h"
37 #include "sysemu/hw_accel.h"
38 #include "hw/qdev-properties.h"
39 #ifndef CONFIG_USER_ONLY
40 #include "hw/hw.h"
41 #include "hw/boards.h"
42 #include "sysemu/arch_init.h"
43 #include "sysemu/sysemu.h"
44 #include "sysemu/tcg.h"
45 #endif
46 #include "fpu/softfloat.h"
47 
48 #define CR0_RESET       0xE0UL
49 #define CR14_RESET      0xC2000000UL;
50 
51 static void s390_cpu_set_pc(CPUState *cs, vaddr value)
52 {
53     S390CPU *cpu = S390_CPU(cs);
54 
55     cpu->env.psw.addr = value;
56 }
57 
58 static bool s390_cpu_has_work(CPUState *cs)
59 {
60     S390CPU *cpu = S390_CPU(cs);
61 
62     /* STOPPED cpus can never wake up */
63     if (s390_cpu_get_state(cpu) != S390_CPU_STATE_LOAD &&
64         s390_cpu_get_state(cpu) != S390_CPU_STATE_OPERATING) {
65         return false;
66     }
67 
68     if (!(cs->interrupt_request & CPU_INTERRUPT_HARD)) {
69         return false;
70     }
71 
72     return s390_cpu_has_int(cpu);
73 }
74 
75 #if !defined(CONFIG_USER_ONLY)
76 /* S390CPUClass::load_normal() */
77 static void s390_cpu_load_normal(CPUState *s)
78 {
79     S390CPU *cpu = S390_CPU(s);
80     cpu->env.psw.addr = ldl_phys(s->as, 4) & PSW_MASK_ESA_ADDR;
81     cpu->env.psw.mask = PSW_MASK_32 | PSW_MASK_64;
82     s390_cpu_set_state(S390_CPU_STATE_OPERATING, cpu);
83 }
84 #endif
85 
86 /* S390CPUClass::cpu_reset() */
87 static void s390_cpu_reset(CPUState *s)
88 {
89     S390CPU *cpu = S390_CPU(s);
90     S390CPUClass *scc = S390_CPU_GET_CLASS(cpu);
91     CPUS390XState *env = &cpu->env;
92 
93     env->pfault_token = -1UL;
94     env->bpbc = false;
95     scc->parent_reset(s);
96     cpu->env.sigp_order = 0;
97     s390_cpu_set_state(S390_CPU_STATE_STOPPED, cpu);
98 }
99 
100 /* S390CPUClass::initial_reset() */
101 static void s390_cpu_initial_reset(CPUState *s)
102 {
103     S390CPU *cpu = S390_CPU(s);
104     CPUS390XState *env = &cpu->env;
105 
106     s390_cpu_reset(s);
107     /* initial reset does not clear everything! */
108     memset(&env->start_initial_reset_fields, 0,
109         offsetof(CPUS390XState, end_reset_fields) -
110         offsetof(CPUS390XState, start_initial_reset_fields));
111 
112     /* architectured initial values for CR 0 and 14 */
113     env->cregs[0] = CR0_RESET;
114     env->cregs[14] = CR14_RESET;
115 
116     /* architectured initial value for Breaking-Event-Address register */
117     env->gbea = 1;
118 
119     env->pfault_token = -1UL;
120 
121     /* tininess for underflow is detected before rounding */
122     set_float_detect_tininess(float_tininess_before_rounding,
123                               &env->fpu_status);
124 
125     /* Reset state inside the kernel that we cannot access yet from QEMU. */
126     if (kvm_enabled()) {
127         kvm_s390_reset_vcpu(cpu);
128     }
129 }
130 
131 /* CPUClass:reset() */
132 static void s390_cpu_full_reset(CPUState *s)
133 {
134     S390CPU *cpu = S390_CPU(s);
135     S390CPUClass *scc = S390_CPU_GET_CLASS(cpu);
136     CPUS390XState *env = &cpu->env;
137 
138     scc->parent_reset(s);
139     cpu->env.sigp_order = 0;
140     s390_cpu_set_state(S390_CPU_STATE_STOPPED, cpu);
141 
142     memset(env, 0, offsetof(CPUS390XState, end_reset_fields));
143 
144     /* architectured initial values for CR 0 and 14 */
145     env->cregs[0] = CR0_RESET;
146     env->cregs[14] = CR14_RESET;
147 
148 #if defined(CONFIG_USER_ONLY)
149     /* user mode should always be allowed to use the full FPU */
150     env->cregs[0] |= CR0_AFP;
151     if (s390_has_feat(S390_FEAT_VECTOR)) {
152         env->cregs[0] |= CR0_VECTOR;
153     }
154 #endif
155 
156     /* architectured initial value for Breaking-Event-Address register */
157     env->gbea = 1;
158 
159     env->pfault_token = -1UL;
160 
161     /* tininess for underflow is detected before rounding */
162     set_float_detect_tininess(float_tininess_before_rounding,
163                               &env->fpu_status);
164 
165     /* Reset state inside the kernel that we cannot access yet from QEMU. */
166     if (kvm_enabled()) {
167         kvm_s390_reset_vcpu(cpu);
168     }
169 }
170 
171 #if !defined(CONFIG_USER_ONLY)
172 static void s390_cpu_machine_reset_cb(void *opaque)
173 {
174     S390CPU *cpu = opaque;
175 
176     run_on_cpu(CPU(cpu), s390_do_cpu_full_reset, RUN_ON_CPU_NULL);
177 }
178 #endif
179 
180 static void s390_cpu_disas_set_info(CPUState *cpu, disassemble_info *info)
181 {
182     info->mach = bfd_mach_s390_64;
183     info->print_insn = print_insn_s390;
184 }
185 
186 static void s390_cpu_realizefn(DeviceState *dev, Error **errp)
187 {
188     CPUState *cs = CPU(dev);
189     S390CPUClass *scc = S390_CPU_GET_CLASS(dev);
190 #if !defined(CONFIG_USER_ONLY)
191     S390CPU *cpu = S390_CPU(dev);
192 #endif
193     Error *err = NULL;
194 
195     /* the model has to be realized before qemu_init_vcpu() due to kvm */
196     s390_realize_cpu_model(cs, &err);
197     if (err) {
198         goto out;
199     }
200 
201 #if !defined(CONFIG_USER_ONLY)
202     MachineState *ms = MACHINE(qdev_get_machine());
203     unsigned int max_cpus = ms->smp.max_cpus;
204     if (cpu->env.core_id >= max_cpus) {
205         error_setg(&err, "Unable to add CPU with core-id: %" PRIu32
206                    ", maximum core-id: %d", cpu->env.core_id,
207                    max_cpus - 1);
208         goto out;
209     }
210 
211     if (cpu_exists(cpu->env.core_id)) {
212         error_setg(&err, "Unable to add CPU with core-id: %" PRIu32
213                    ", it already exists", cpu->env.core_id);
214         goto out;
215     }
216 
217     /* sync cs->cpu_index and env->core_id. The latter is needed for TCG. */
218     cs->cpu_index = cpu->env.core_id;
219 #endif
220 
221     cpu_exec_realizefn(cs, &err);
222     if (err != NULL) {
223         goto out;
224     }
225 
226 #if !defined(CONFIG_USER_ONLY)
227     qemu_register_reset(s390_cpu_machine_reset_cb, cpu);
228 #endif
229     s390_cpu_gdb_init(cs);
230     qemu_init_vcpu(cs);
231 
232     /*
233      * KVM requires the initial CPU reset ioctl to be executed on the target
234      * CPU thread. CPU hotplug under single-threaded TCG will not work with
235      * run_on_cpu(), as run_on_cpu() will not work properly if called while
236      * the main thread is already running but the CPU hasn't been realized.
237      */
238     if (kvm_enabled()) {
239         run_on_cpu(cs, s390_do_cpu_full_reset, RUN_ON_CPU_NULL);
240     } else {
241         cpu_reset(cs);
242     }
243 
244     scc->parent_realize(dev, &err);
245 out:
246     error_propagate(errp, err);
247 }
248 
249 static GuestPanicInformation *s390_cpu_get_crash_info(CPUState *cs)
250 {
251     GuestPanicInformation *panic_info;
252     S390CPU *cpu = S390_CPU(cs);
253 
254     cpu_synchronize_state(cs);
255     panic_info = g_malloc0(sizeof(GuestPanicInformation));
256 
257     panic_info->type = GUEST_PANIC_INFORMATION_TYPE_S390;
258 #if !defined(CONFIG_USER_ONLY)
259     panic_info->u.s390.core = cpu->env.core_id;
260 #else
261     panic_info->u.s390.core = 0; /* sane default for non system emulation */
262 #endif
263     panic_info->u.s390.psw_mask = cpu->env.psw.mask;
264     panic_info->u.s390.psw_addr = cpu->env.psw.addr;
265     panic_info->u.s390.reason = cpu->env.crash_reason;
266 
267     return panic_info;
268 }
269 
270 static void s390_cpu_get_crash_info_qom(Object *obj, Visitor *v,
271                                         const char *name, void *opaque,
272                                         Error **errp)
273 {
274     CPUState *cs = CPU(obj);
275     GuestPanicInformation *panic_info;
276 
277     if (!cs->crash_occurred) {
278         error_setg(errp, "No crash occurred");
279         return;
280     }
281 
282     panic_info = s390_cpu_get_crash_info(cs);
283 
284     visit_type_GuestPanicInformation(v, "crash-information", &panic_info,
285                                      errp);
286     qapi_free_GuestPanicInformation(panic_info);
287 }
288 
289 static void s390_cpu_initfn(Object *obj)
290 {
291     CPUState *cs = CPU(obj);
292     S390CPU *cpu = S390_CPU(obj);
293 
294     cpu_set_cpustate_pointers(cpu);
295     cs->halted = 1;
296     cs->exception_index = EXCP_HLT;
297     object_property_add(obj, "crash-information", "GuestPanicInformation",
298                         s390_cpu_get_crash_info_qom, NULL, NULL, NULL, NULL);
299     s390_cpu_model_register_props(obj);
300 #if !defined(CONFIG_USER_ONLY)
301     cpu->env.tod_timer =
302         timer_new_ns(QEMU_CLOCK_VIRTUAL, s390x_tod_timer, cpu);
303     cpu->env.cpu_timer =
304         timer_new_ns(QEMU_CLOCK_VIRTUAL, s390x_cpu_timer, cpu);
305     s390_cpu_set_state(S390_CPU_STATE_STOPPED, cpu);
306 #endif
307 }
308 
309 static void s390_cpu_finalize(Object *obj)
310 {
311 #if !defined(CONFIG_USER_ONLY)
312     S390CPU *cpu = S390_CPU(obj);
313 
314     qemu_unregister_reset(s390_cpu_machine_reset_cb, cpu);
315     g_free(cpu->irqstate);
316 #endif
317 }
318 
319 #if !defined(CONFIG_USER_ONLY)
320 static bool disabled_wait(CPUState *cpu)
321 {
322     return cpu->halted && !(S390_CPU(cpu)->env.psw.mask &
323                             (PSW_MASK_IO | PSW_MASK_EXT | PSW_MASK_MCHECK));
324 }
325 
326 static unsigned s390_count_running_cpus(void)
327 {
328     CPUState *cpu;
329     int nr_running = 0;
330 
331     CPU_FOREACH(cpu) {
332         uint8_t state = S390_CPU(cpu)->env.cpu_state;
333         if (state == S390_CPU_STATE_OPERATING ||
334             state == S390_CPU_STATE_LOAD) {
335             if (!disabled_wait(cpu)) {
336                 nr_running++;
337             }
338         }
339     }
340 
341     return nr_running;
342 }
343 
344 unsigned int s390_cpu_halt(S390CPU *cpu)
345 {
346     CPUState *cs = CPU(cpu);
347     trace_cpu_halt(cs->cpu_index);
348 
349     if (!cs->halted) {
350         cs->halted = 1;
351         cs->exception_index = EXCP_HLT;
352     }
353 
354     return s390_count_running_cpus();
355 }
356 
357 void s390_cpu_unhalt(S390CPU *cpu)
358 {
359     CPUState *cs = CPU(cpu);
360     trace_cpu_unhalt(cs->cpu_index);
361 
362     if (cs->halted) {
363         cs->halted = 0;
364         cs->exception_index = -1;
365     }
366 }
367 
368 unsigned int s390_cpu_set_state(uint8_t cpu_state, S390CPU *cpu)
369  {
370     trace_cpu_set_state(CPU(cpu)->cpu_index, cpu_state);
371 
372     switch (cpu_state) {
373     case S390_CPU_STATE_STOPPED:
374     case S390_CPU_STATE_CHECK_STOP:
375         /* halt the cpu for common infrastructure */
376         s390_cpu_halt(cpu);
377         break;
378     case S390_CPU_STATE_OPERATING:
379     case S390_CPU_STATE_LOAD:
380         /*
381          * Starting a CPU with a PSW WAIT bit set:
382          * KVM: handles this internally and triggers another WAIT exit.
383          * TCG: will actually try to continue to run. Don't unhalt, will
384          *      be done when the CPU actually has work (an interrupt).
385          */
386         if (!tcg_enabled() || !(cpu->env.psw.mask & PSW_MASK_WAIT)) {
387             s390_cpu_unhalt(cpu);
388         }
389         break;
390     default:
391         error_report("Requested CPU state is not a valid S390 CPU state: %u",
392                      cpu_state);
393         exit(1);
394     }
395     if (kvm_enabled() && cpu->env.cpu_state != cpu_state) {
396         kvm_s390_set_cpu_state(cpu, cpu_state);
397     }
398     cpu->env.cpu_state = cpu_state;
399 
400     return s390_count_running_cpus();
401 }
402 
403 int s390_set_memory_limit(uint64_t new_limit, uint64_t *hw_limit)
404 {
405     if (kvm_enabled()) {
406         return kvm_s390_set_mem_limit(new_limit, hw_limit);
407     }
408     return 0;
409 }
410 
411 void s390_set_max_pagesize(uint64_t pagesize, Error **errp)
412 {
413     if (kvm_enabled()) {
414         kvm_s390_set_max_pagesize(pagesize, errp);
415     }
416 }
417 
418 void s390_cmma_reset(void)
419 {
420     if (kvm_enabled()) {
421         kvm_s390_cmma_reset();
422     }
423 }
424 
425 int s390_assign_subch_ioeventfd(EventNotifier *notifier, uint32_t sch_id,
426                                 int vq, bool assign)
427 {
428     if (kvm_enabled()) {
429         return kvm_s390_assign_subch_ioeventfd(notifier, sch_id, vq, assign);
430     } else {
431         return 0;
432     }
433 }
434 
435 void s390_crypto_reset(void)
436 {
437     if (kvm_enabled()) {
438         kvm_s390_crypto_reset();
439     }
440 }
441 
442 void s390_enable_css_support(S390CPU *cpu)
443 {
444     if (kvm_enabled()) {
445         kvm_s390_enable_css_support(cpu);
446     }
447 }
448 #endif
449 
450 static gchar *s390_gdb_arch_name(CPUState *cs)
451 {
452     return g_strdup("s390:64-bit");
453 }
454 
455 static Property s390x_cpu_properties[] = {
456 #if !defined(CONFIG_USER_ONLY)
457     DEFINE_PROP_UINT32("core-id", S390CPU, env.core_id, 0),
458 #endif
459     DEFINE_PROP_END_OF_LIST()
460 };
461 
462 static void s390_cpu_class_init(ObjectClass *oc, void *data)
463 {
464     S390CPUClass *scc = S390_CPU_CLASS(oc);
465     CPUClass *cc = CPU_CLASS(scc);
466     DeviceClass *dc = DEVICE_CLASS(oc);
467 
468     device_class_set_parent_realize(dc, s390_cpu_realizefn,
469                                     &scc->parent_realize);
470     dc->props = s390x_cpu_properties;
471     dc->user_creatable = true;
472 
473     scc->parent_reset = cc->reset;
474 #if !defined(CONFIG_USER_ONLY)
475     scc->load_normal = s390_cpu_load_normal;
476 #endif
477     scc->cpu_reset = s390_cpu_reset;
478     scc->initial_cpu_reset = s390_cpu_initial_reset;
479     cc->reset = s390_cpu_full_reset;
480     cc->class_by_name = s390_cpu_class_by_name,
481     cc->has_work = s390_cpu_has_work;
482 #ifdef CONFIG_TCG
483     cc->do_interrupt = s390_cpu_do_interrupt;
484 #endif
485     cc->dump_state = s390_cpu_dump_state;
486     cc->get_crash_info = s390_cpu_get_crash_info;
487     cc->set_pc = s390_cpu_set_pc;
488     cc->gdb_read_register = s390_cpu_gdb_read_register;
489     cc->gdb_write_register = s390_cpu_gdb_write_register;
490 #ifndef CONFIG_USER_ONLY
491     cc->get_phys_page_debug = s390_cpu_get_phys_page_debug;
492     cc->vmsd = &vmstate_s390_cpu;
493     cc->write_elf64_note = s390_cpu_write_elf64_note;
494 #ifdef CONFIG_TCG
495     cc->cpu_exec_interrupt = s390_cpu_exec_interrupt;
496     cc->debug_excp_handler = s390x_cpu_debug_excp_handler;
497     cc->do_unaligned_access = s390x_cpu_do_unaligned_access;
498 #endif
499 #endif
500     cc->disas_set_info = s390_cpu_disas_set_info;
501 #ifdef CONFIG_TCG
502     cc->tcg_initialize = s390x_translate_init;
503     cc->tlb_fill = s390_cpu_tlb_fill;
504 #endif
505 
506     cc->gdb_num_core_regs = S390_NUM_CORE_REGS;
507     cc->gdb_core_xml_file = "s390x-core64.xml";
508     cc->gdb_arch_name = s390_gdb_arch_name;
509 
510     s390_cpu_model_class_register_props(oc);
511 }
512 
513 static const TypeInfo s390_cpu_type_info = {
514     .name = TYPE_S390_CPU,
515     .parent = TYPE_CPU,
516     .instance_size = sizeof(S390CPU),
517     .instance_init = s390_cpu_initfn,
518     .instance_finalize = s390_cpu_finalize,
519     .abstract = true,
520     .class_size = sizeof(S390CPUClass),
521     .class_init = s390_cpu_class_init,
522 };
523 
524 static void s390_cpu_register_types(void)
525 {
526     type_register_static(&s390_cpu_type_info);
527 }
528 
529 type_init(s390_cpu_register_types)
530