2 * QEMU S/390 CPU - System Emulation-only code
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 "qemu/error-report.h"
25 #include "qapi/error.h"
27 #include "s390x-internal.h"
28 #include "kvm/kvm_s390x.h"
29 #include "sysemu/kvm.h"
30 #include "sysemu/reset.h"
31 #include "qemu/timer.h"
33 #include "qapi/qapi-visit-run-state.h"
34 #include "sysemu/hw_accel.h"
36 #include "hw/s390x/pv.h"
37 #include "hw/boards.h"
38 #include "sysemu/sysemu.h"
39 #include "sysemu/tcg.h"
40 #include "hw/core/sysemu-cpu-ops.h"
42 /* S390CPUClass::load_normal() */
43 static void s390_cpu_load_normal(CPUState
*s
)
45 S390CPU
*cpu
= S390_CPU(s
);
49 spsw
= ldq_phys(s
->as
, 0);
50 cpu
->env
.psw
.mask
= spsw
& PSW_MASK_SHORT_CTRL
;
52 * Invert short psw indication, so SIE will report a specification
53 * exception if it was not set.
55 cpu
->env
.psw
.mask
^= PSW_MASK_SHORTPSW
;
56 cpu
->env
.psw
.addr
= spsw
& PSW_MASK_SHORT_ADDR
;
59 * Firmware requires us to set the load state before we set
60 * the cpu to operating on protected guests.
62 s390_cpu_set_state(S390_CPU_STATE_LOAD
, cpu
);
64 s390_cpu_set_state(S390_CPU_STATE_OPERATING
, cpu
);
67 void s390_cpu_machine_reset_cb(void *opaque
)
69 S390CPU
*cpu
= opaque
;
71 run_on_cpu(CPU(cpu
), s390_do_cpu_full_reset
, RUN_ON_CPU_NULL
);
74 static GuestPanicInformation
*s390_cpu_get_crash_info(CPUState
*cs
)
76 GuestPanicInformation
*panic_info
;
77 S390CPU
*cpu
= S390_CPU(cs
);
79 cpu_synchronize_state(cs
);
80 panic_info
= g_new0(GuestPanicInformation
, 1);
82 panic_info
->type
= GUEST_PANIC_INFORMATION_TYPE_S390
;
83 panic_info
->u
.s390
.core
= cpu
->env
.core_id
;
84 panic_info
->u
.s390
.psw_mask
= cpu
->env
.psw
.mask
;
85 panic_info
->u
.s390
.psw_addr
= cpu
->env
.psw
.addr
;
86 panic_info
->u
.s390
.reason
= cpu
->env
.crash_reason
;
91 static void s390_cpu_get_crash_info_qom(Object
*obj
, Visitor
*v
,
92 const char *name
, void *opaque
,
95 CPUState
*cs
= CPU(obj
);
96 GuestPanicInformation
*panic_info
;
98 if (!cs
->crash_occurred
) {
99 error_setg(errp
, "No crash occurred");
103 panic_info
= s390_cpu_get_crash_info(cs
);
105 visit_type_GuestPanicInformation(v
, "crash-information", &panic_info
,
107 qapi_free_GuestPanicInformation(panic_info
);
110 void s390_cpu_init_sysemu(Object
*obj
)
112 CPUState
*cs
= CPU(obj
);
113 S390CPU
*cpu
= S390_CPU(obj
);
115 cs
->start_powered_off
= true;
116 object_property_add(obj
, "crash-information", "GuestPanicInformation",
117 s390_cpu_get_crash_info_qom
, NULL
, NULL
, NULL
);
119 timer_new_ns(QEMU_CLOCK_VIRTUAL
, s390x_tod_timer
, cpu
);
121 timer_new_ns(QEMU_CLOCK_VIRTUAL
, s390x_cpu_timer
, cpu
);
122 s390_cpu_set_state(S390_CPU_STATE_STOPPED
, cpu
);
125 bool s390_cpu_realize_sysemu(DeviceState
*dev
, Error
**errp
)
127 S390CPU
*cpu
= S390_CPU(dev
);
128 MachineState
*ms
= MACHINE(qdev_get_machine());
129 unsigned int max_cpus
= ms
->smp
.max_cpus
;
131 if (cpu
->env
.core_id
>= max_cpus
) {
132 error_setg(errp
, "Unable to add CPU with core-id: %" PRIu32
133 ", maximum core-id: %d", cpu
->env
.core_id
,
138 if (cpu_exists(cpu
->env
.core_id
)) {
139 error_setg(errp
, "Unable to add CPU with core-id: %" PRIu32
140 ", it already exists", cpu
->env
.core_id
);
144 /* sync cs->cpu_index and env->core_id. The latter is needed for TCG. */
145 CPU(cpu
)->cpu_index
= cpu
->env
.core_id
;
149 void s390_cpu_finalize(Object
*obj
)
151 S390CPU
*cpu
= S390_CPU(obj
);
153 timer_free(cpu
->env
.tod_timer
);
154 timer_free(cpu
->env
.cpu_timer
);
156 qemu_unregister_reset(s390_cpu_machine_reset_cb
, cpu
);
157 g_free(cpu
->irqstate
);
160 static const struct SysemuCPUOps s390_sysemu_ops
= {
161 .get_phys_page_debug
= s390_cpu_get_phys_page_debug
,
162 .get_crash_info
= s390_cpu_get_crash_info
,
163 .write_elf64_note
= s390_cpu_write_elf64_note
,
164 .legacy_vmsd
= &vmstate_s390_cpu
,
167 void s390_cpu_class_init_sysemu(CPUClass
*cc
)
169 S390CPUClass
*scc
= S390_CPU_CLASS(cc
);
171 scc
->load_normal
= s390_cpu_load_normal
;
172 cc
->sysemu_ops
= &s390_sysemu_ops
;
175 static bool disabled_wait(CPUState
*cpu
)
177 return cpu
->halted
&& !(S390_CPU(cpu
)->env
.psw
.mask
&
178 (PSW_MASK_IO
| PSW_MASK_EXT
| PSW_MASK_MCHECK
));
181 static unsigned s390_count_running_cpus(void)
187 uint8_t state
= S390_CPU(cpu
)->env
.cpu_state
;
188 if (state
== S390_CPU_STATE_OPERATING
||
189 state
== S390_CPU_STATE_LOAD
) {
190 if (!disabled_wait(cpu
)) {
199 unsigned int s390_cpu_halt(S390CPU
*cpu
)
201 CPUState
*cs
= CPU(cpu
);
202 trace_cpu_halt(cs
->cpu_index
);
206 cs
->exception_index
= EXCP_HLT
;
209 return s390_count_running_cpus();
212 void s390_cpu_unhalt(S390CPU
*cpu
)
214 CPUState
*cs
= CPU(cpu
);
215 trace_cpu_unhalt(cs
->cpu_index
);
219 cs
->exception_index
= -1;
223 unsigned int s390_cpu_set_state(uint8_t cpu_state
, S390CPU
*cpu
)
225 trace_cpu_set_state(CPU(cpu
)->cpu_index
, cpu_state
);
228 case S390_CPU_STATE_STOPPED
:
229 case S390_CPU_STATE_CHECK_STOP
:
230 /* halt the cpu for common infrastructure */
233 case S390_CPU_STATE_OPERATING
:
234 case S390_CPU_STATE_LOAD
:
236 * Starting a CPU with a PSW WAIT bit set:
237 * KVM: handles this internally and triggers another WAIT exit.
238 * TCG: will actually try to continue to run. Don't unhalt, will
239 * be done when the CPU actually has work (an interrupt).
241 if (!tcg_enabled() || !(cpu
->env
.psw
.mask
& PSW_MASK_WAIT
)) {
242 s390_cpu_unhalt(cpu
);
246 error_report("Requested CPU state is not a valid S390 CPU state: %u",
250 if (kvm_enabled() && cpu
->env
.cpu_state
!= cpu_state
) {
251 kvm_s390_set_cpu_state(cpu
, cpu_state
);
253 cpu
->env
.cpu_state
= cpu_state
;
255 return s390_count_running_cpus();
258 int s390_set_memory_limit(uint64_t new_limit
, uint64_t *hw_limit
)
261 return kvm_s390_set_mem_limit(new_limit
, hw_limit
);
266 void s390_set_max_pagesize(uint64_t pagesize
, Error
**errp
)
269 kvm_s390_set_max_pagesize(pagesize
, errp
);
273 void s390_cmma_reset(void)
276 kvm_s390_cmma_reset();
280 int s390_assign_subch_ioeventfd(EventNotifier
*notifier
, uint32_t sch_id
,
284 return kvm_s390_assign_subch_ioeventfd(notifier
, sch_id
, vq
, assign
);
290 void s390_crypto_reset(void)
293 kvm_s390_crypto_reset();
297 void s390_enable_css_support(S390CPU
*cpu
)
300 kvm_s390_enable_css_support(cpu
);
304 void s390_do_cpu_set_diag318(CPUState
*cs
, run_on_cpu_data arg
)
307 kvm_s390_set_diag318(cs
, arg
.host_ulong
);