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