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.
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.
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.
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/>.
23 #include "qemu/osdep.h"
24 #include "qapi/error.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"
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/s390x/pv.h"
41 #include "hw/boards.h"
42 #include "sysemu/arch_init.h"
43 #include "sysemu/tcg.h"
45 #include "fpu/softfloat-helpers.h"
46 #include "disas/capstone.h"
48 #define CR0_RESET 0xE0UL
49 #define CR14_RESET 0xC2000000UL;
51 static void s390_cpu_set_pc(CPUState
*cs
, vaddr value
)
53 S390CPU
*cpu
= S390_CPU(cs
);
55 cpu
->env
.psw
.addr
= value
;
58 static bool s390_cpu_has_work(CPUState
*cs
)
60 S390CPU
*cpu
= S390_CPU(cs
);
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
) {
68 if (!(cs
->interrupt_request
& CPU_INTERRUPT_HARD
)) {
72 return s390_cpu_has_int(cpu
);
75 #if !defined(CONFIG_USER_ONLY)
76 /* S390CPUClass::load_normal() */
77 static void s390_cpu_load_normal(CPUState
*s
)
79 S390CPU
*cpu
= S390_CPU(s
);
83 spsw
= ldq_phys(s
->as
, 0);
84 cpu
->env
.psw
.mask
= spsw
& PSW_MASK_SHORT_CTRL
;
86 * Invert short psw indication, so SIE will report a specification
87 * exception if it was not set.
89 cpu
->env
.psw
.mask
^= PSW_MASK_SHORTPSW
;
90 cpu
->env
.psw
.addr
= spsw
& PSW_MASK_SHORT_ADDR
;
93 * Firmware requires us to set the load state before we set
94 * the cpu to operating on protected guests.
96 s390_cpu_set_state(S390_CPU_STATE_LOAD
, cpu
);
98 s390_cpu_set_state(S390_CPU_STATE_OPERATING
, cpu
);
102 /* S390CPUClass::reset() */
103 static void s390_cpu_reset(CPUState
*s
, cpu_reset_type type
)
105 S390CPU
*cpu
= S390_CPU(s
);
106 S390CPUClass
*scc
= S390_CPU_GET_CLASS(cpu
);
107 CPUS390XState
*env
= &cpu
->env
;
108 DeviceState
*dev
= DEVICE(s
);
110 scc
->parent_reset(dev
);
111 cpu
->env
.sigp_order
= 0;
112 s390_cpu_set_state(S390_CPU_STATE_STOPPED
, cpu
);
115 case S390_CPU_RESET_CLEAR
:
116 memset(env
, 0, offsetof(CPUS390XState
, start_initial_reset_fields
));
118 case S390_CPU_RESET_INITIAL
:
119 /* initial reset does not clear everything! */
120 memset(&env
->start_initial_reset_fields
, 0,
121 offsetof(CPUS390XState
, start_normal_reset_fields
) -
122 offsetof(CPUS390XState
, start_initial_reset_fields
));
124 /* architectured initial value for Breaking-Event-Address register */
127 /* architectured initial values for CR 0 and 14 */
128 env
->cregs
[0] = CR0_RESET
;
129 env
->cregs
[14] = CR14_RESET
;
131 #if defined(CONFIG_USER_ONLY)
132 /* user mode should always be allowed to use the full FPU */
133 env
->cregs
[0] |= CR0_AFP
;
134 if (s390_has_feat(S390_FEAT_VECTOR
)) {
135 env
->cregs
[0] |= CR0_VECTOR
;
139 /* tininess for underflow is detected before rounding */
140 set_float_detect_tininess(float_tininess_before_rounding
,
143 case S390_CPU_RESET_NORMAL
:
144 env
->psw
.mask
&= ~PSW_MASK_RI
;
145 memset(&env
->start_normal_reset_fields
, 0,
146 offsetof(CPUS390XState
, end_reset_fields
) -
147 offsetof(CPUS390XState
, start_normal_reset_fields
));
149 env
->pfault_token
= -1UL;
153 g_assert_not_reached();
156 /* Reset state inside the kernel that we cannot access yet from QEMU. */
159 case S390_CPU_RESET_CLEAR
:
160 kvm_s390_reset_vcpu_clear(cpu
);
162 case S390_CPU_RESET_INITIAL
:
163 kvm_s390_reset_vcpu_initial(cpu
);
165 case S390_CPU_RESET_NORMAL
:
166 kvm_s390_reset_vcpu_normal(cpu
);
172 #if !defined(CONFIG_USER_ONLY)
173 static void s390_cpu_machine_reset_cb(void *opaque
)
175 S390CPU
*cpu
= opaque
;
177 run_on_cpu(CPU(cpu
), s390_do_cpu_full_reset
, RUN_ON_CPU_NULL
);
181 static void s390_cpu_disas_set_info(CPUState
*cpu
, disassemble_info
*info
)
183 info
->mach
= bfd_mach_s390_64
;
184 info
->print_insn
= print_insn_s390
;
185 info
->cap_arch
= CS_ARCH_SYSZ
;
186 info
->cap_insn_unit
= 2;
187 info
->cap_insn_split
= 6;
190 static void s390_cpu_realizefn(DeviceState
*dev
, Error
**errp
)
192 CPUState
*cs
= CPU(dev
);
193 S390CPUClass
*scc
= S390_CPU_GET_CLASS(dev
);
194 #if !defined(CONFIG_USER_ONLY)
195 S390CPU
*cpu
= S390_CPU(dev
);
199 /* the model has to be realized before qemu_init_vcpu() due to kvm */
200 s390_realize_cpu_model(cs
, &err
);
205 #if !defined(CONFIG_USER_ONLY)
206 MachineState
*ms
= MACHINE(qdev_get_machine());
207 unsigned int max_cpus
= ms
->smp
.max_cpus
;
208 if (cpu
->env
.core_id
>= max_cpus
) {
209 error_setg(&err
, "Unable to add CPU with core-id: %" PRIu32
210 ", maximum core-id: %d", cpu
->env
.core_id
,
215 if (cpu_exists(cpu
->env
.core_id
)) {
216 error_setg(&err
, "Unable to add CPU with core-id: %" PRIu32
217 ", it already exists", cpu
->env
.core_id
);
221 /* sync cs->cpu_index and env->core_id. The latter is needed for TCG. */
222 cs
->cpu_index
= cpu
->env
.core_id
;
225 cpu_exec_realizefn(cs
, &err
);
230 #if !defined(CONFIG_USER_ONLY)
231 qemu_register_reset(s390_cpu_machine_reset_cb
, cpu
);
233 s390_cpu_gdb_init(cs
);
237 * KVM requires the initial CPU reset ioctl to be executed on the target
238 * CPU thread. CPU hotplug under single-threaded TCG will not work with
239 * run_on_cpu(), as run_on_cpu() will not work properly if called while
240 * the main thread is already running but the CPU hasn't been realized.
243 run_on_cpu(cs
, s390_do_cpu_full_reset
, RUN_ON_CPU_NULL
);
248 scc
->parent_realize(dev
, &err
);
250 error_propagate(errp
, err
);
253 #if !defined(CONFIG_USER_ONLY)
254 static GuestPanicInformation
*s390_cpu_get_crash_info(CPUState
*cs
)
256 GuestPanicInformation
*panic_info
;
257 S390CPU
*cpu
= S390_CPU(cs
);
259 cpu_synchronize_state(cs
);
260 panic_info
= g_malloc0(sizeof(GuestPanicInformation
));
262 panic_info
->type
= GUEST_PANIC_INFORMATION_TYPE_S390
;
263 panic_info
->u
.s390
.core
= cpu
->env
.core_id
;
264 panic_info
->u
.s390
.psw_mask
= cpu
->env
.psw
.mask
;
265 panic_info
->u
.s390
.psw_addr
= cpu
->env
.psw
.addr
;
266 panic_info
->u
.s390
.reason
= cpu
->env
.crash_reason
;
271 static void s390_cpu_get_crash_info_qom(Object
*obj
, Visitor
*v
,
272 const char *name
, void *opaque
,
275 CPUState
*cs
= CPU(obj
);
276 GuestPanicInformation
*panic_info
;
278 if (!cs
->crash_occurred
) {
279 error_setg(errp
, "No crash occurred");
283 panic_info
= s390_cpu_get_crash_info(cs
);
285 visit_type_GuestPanicInformation(v
, "crash-information", &panic_info
,
287 qapi_free_GuestPanicInformation(panic_info
);
291 static void s390_cpu_initfn(Object
*obj
)
293 CPUState
*cs
= CPU(obj
);
294 S390CPU
*cpu
= S390_CPU(obj
);
296 cpu_set_cpustate_pointers(cpu
);
297 cs
->exception_index
= EXCP_HLT
;
298 #if !defined(CONFIG_USER_ONLY)
299 cs
->start_powered_off
= true;
300 object_property_add(obj
, "crash-information", "GuestPanicInformation",
301 s390_cpu_get_crash_info_qom
, NULL
, NULL
, NULL
);
303 timer_new_ns(QEMU_CLOCK_VIRTUAL
, s390x_tod_timer
, cpu
);
305 timer_new_ns(QEMU_CLOCK_VIRTUAL
, s390x_cpu_timer
, cpu
);
306 s390_cpu_set_state(S390_CPU_STATE_STOPPED
, cpu
);
310 static void s390_cpu_finalize(Object
*obj
)
312 #if !defined(CONFIG_USER_ONLY)
313 S390CPU
*cpu
= S390_CPU(obj
);
315 timer_free(cpu
->env
.tod_timer
);
316 timer_free(cpu
->env
.cpu_timer
);
318 qemu_unregister_reset(s390_cpu_machine_reset_cb
, cpu
);
319 g_free(cpu
->irqstate
);
323 #if !defined(CONFIG_USER_ONLY)
324 static bool disabled_wait(CPUState
*cpu
)
326 return cpu
->halted
&& !(S390_CPU(cpu
)->env
.psw
.mask
&
327 (PSW_MASK_IO
| PSW_MASK_EXT
| PSW_MASK_MCHECK
));
330 static unsigned s390_count_running_cpus(void)
336 uint8_t state
= S390_CPU(cpu
)->env
.cpu_state
;
337 if (state
== S390_CPU_STATE_OPERATING
||
338 state
== S390_CPU_STATE_LOAD
) {
339 if (!disabled_wait(cpu
)) {
348 unsigned int s390_cpu_halt(S390CPU
*cpu
)
350 CPUState
*cs
= CPU(cpu
);
351 trace_cpu_halt(cs
->cpu_index
);
355 cs
->exception_index
= EXCP_HLT
;
358 return s390_count_running_cpus();
361 void s390_cpu_unhalt(S390CPU
*cpu
)
363 CPUState
*cs
= CPU(cpu
);
364 trace_cpu_unhalt(cs
->cpu_index
);
368 cs
->exception_index
= -1;
372 unsigned int s390_cpu_set_state(uint8_t cpu_state
, S390CPU
*cpu
)
374 trace_cpu_set_state(CPU(cpu
)->cpu_index
, cpu_state
);
377 case S390_CPU_STATE_STOPPED
:
378 case S390_CPU_STATE_CHECK_STOP
:
379 /* halt the cpu for common infrastructure */
382 case S390_CPU_STATE_OPERATING
:
383 case S390_CPU_STATE_LOAD
:
385 * Starting a CPU with a PSW WAIT bit set:
386 * KVM: handles this internally and triggers another WAIT exit.
387 * TCG: will actually try to continue to run. Don't unhalt, will
388 * be done when the CPU actually has work (an interrupt).
390 if (!tcg_enabled() || !(cpu
->env
.psw
.mask
& PSW_MASK_WAIT
)) {
391 s390_cpu_unhalt(cpu
);
395 error_report("Requested CPU state is not a valid S390 CPU state: %u",
399 if (kvm_enabled() && cpu
->env
.cpu_state
!= cpu_state
) {
400 kvm_s390_set_cpu_state(cpu
, cpu_state
);
402 cpu
->env
.cpu_state
= cpu_state
;
404 return s390_count_running_cpus();
407 int s390_set_memory_limit(uint64_t new_limit
, uint64_t *hw_limit
)
410 return kvm_s390_set_mem_limit(new_limit
, hw_limit
);
415 void s390_set_max_pagesize(uint64_t pagesize
, Error
**errp
)
418 kvm_s390_set_max_pagesize(pagesize
, errp
);
422 void s390_cmma_reset(void)
425 kvm_s390_cmma_reset();
429 int s390_assign_subch_ioeventfd(EventNotifier
*notifier
, uint32_t sch_id
,
433 return kvm_s390_assign_subch_ioeventfd(notifier
, sch_id
, vq
, assign
);
439 void s390_crypto_reset(void)
442 kvm_s390_crypto_reset();
446 void s390_enable_css_support(S390CPU
*cpu
)
449 kvm_s390_enable_css_support(cpu
);
453 void s390_do_cpu_set_diag318(CPUState
*cs
, run_on_cpu_data arg
)
456 kvm_s390_set_diag318(cs
, arg
.host_ulong
);
461 static gchar
*s390_gdb_arch_name(CPUState
*cs
)
463 return g_strdup("s390:64-bit");
466 static Property s390x_cpu_properties
[] = {
467 #if !defined(CONFIG_USER_ONLY)
468 DEFINE_PROP_UINT32("core-id", S390CPU
, env
.core_id
, 0),
470 DEFINE_PROP_END_OF_LIST()
473 static void s390_cpu_reset_full(DeviceState
*dev
)
475 CPUState
*s
= CPU(dev
);
476 return s390_cpu_reset(s
, S390_CPU_RESET_CLEAR
);
479 #ifndef CONFIG_USER_ONLY
480 #include "hw/core/sysemu-cpu-ops.h"
482 static const struct SysemuCPUOps s390_sysemu_ops
= {
483 .get_phys_page_debug
= s390_cpu_get_phys_page_debug
,
484 .get_crash_info
= s390_cpu_get_crash_info
,
485 .write_elf64_note
= s390_cpu_write_elf64_note
,
486 .legacy_vmsd
= &vmstate_s390_cpu
,
491 #include "hw/core/tcg-cpu-ops.h"
493 static const struct TCGCPUOps s390_tcg_ops
= {
494 .initialize
= s390x_translate_init
,
495 .tlb_fill
= s390_cpu_tlb_fill
,
497 #if !defined(CONFIG_USER_ONLY)
498 .cpu_exec_interrupt
= s390_cpu_exec_interrupt
,
499 .do_interrupt
= s390_cpu_do_interrupt
,
500 .debug_excp_handler
= s390x_cpu_debug_excp_handler
,
501 .do_unaligned_access
= s390x_cpu_do_unaligned_access
,
502 #endif /* !CONFIG_USER_ONLY */
504 #endif /* CONFIG_TCG */
506 static void s390_cpu_class_init(ObjectClass
*oc
, void *data
)
508 S390CPUClass
*scc
= S390_CPU_CLASS(oc
);
509 CPUClass
*cc
= CPU_CLASS(scc
);
510 DeviceClass
*dc
= DEVICE_CLASS(oc
);
512 device_class_set_parent_realize(dc
, s390_cpu_realizefn
,
513 &scc
->parent_realize
);
514 device_class_set_props(dc
, s390x_cpu_properties
);
515 dc
->user_creatable
= true;
517 device_class_set_parent_reset(dc
, s390_cpu_reset_full
, &scc
->parent_reset
);
518 #if !defined(CONFIG_USER_ONLY)
519 scc
->load_normal
= s390_cpu_load_normal
;
521 scc
->reset
= s390_cpu_reset
;
522 cc
->class_by_name
= s390_cpu_class_by_name
,
523 cc
->has_work
= s390_cpu_has_work
;
524 cc
->dump_state
= s390_cpu_dump_state
;
525 cc
->set_pc
= s390_cpu_set_pc
;
526 cc
->gdb_read_register
= s390_cpu_gdb_read_register
;
527 cc
->gdb_write_register
= s390_cpu_gdb_write_register
;
528 #ifndef CONFIG_USER_ONLY
529 cc
->sysemu_ops
= &s390_sysemu_ops
;
531 cc
->disas_set_info
= s390_cpu_disas_set_info
;
532 cc
->gdb_num_core_regs
= S390_NUM_CORE_REGS
;
533 cc
->gdb_core_xml_file
= "s390x-core64.xml";
534 cc
->gdb_arch_name
= s390_gdb_arch_name
;
536 s390_cpu_model_class_register_props(oc
);
539 cc
->tcg_ops
= &s390_tcg_ops
;
540 #endif /* CONFIG_TCG */
543 static const TypeInfo s390_cpu_type_info
= {
544 .name
= TYPE_S390_CPU
,
546 .instance_size
= sizeof(S390CPU
),
547 .instance_align
= __alignof__(S390CPU
),
548 .instance_init
= s390_cpu_initfn
,
549 .instance_finalize
= s390_cpu_finalize
,
551 .class_size
= sizeof(S390CPUClass
),
552 .class_init
= s390_cpu_class_init
,
555 static void s390_cpu_register_types(void)
557 type_register_static(&s390_cpu_type_info
);
560 type_init(s390_cpu_register_types
)