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 library is free software; you can redistribute it and/or
10 * modify it under the terms of the GNU Lesser General Public
11 * License as published by the Free Software Foundation; either
12 * version 2.1 of the License, or (at your option) any later version.
14 * This library 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 * Lesser General Public License for more details.
19 * You should have received a copy of the GNU Lesser General Public
20 * License along with this library; if not, see
21 * <http://www.gnu.org/licenses/lgpl-2.1.html>
22 * Contributions after 2012-12-11 are licensed under the terms of the
23 * GNU GPL, version 2 or (at your option) any later version.
26 #include "qemu/osdep.h"
27 #include "qapi/error.h"
30 #include "kvm_s390x.h"
31 #include "sysemu/kvm.h"
32 #include "qemu-common.h"
33 #include "qemu/cutils.h"
34 #include "qemu/timer.h"
35 #include "qemu/error-report.h"
37 #include "qapi/visitor.h"
38 #include "exec/exec-all.h"
39 #include "hw/qdev-properties.h"
40 #ifndef CONFIG_USER_ONLY
42 #include "sysemu/arch_init.h"
43 #include "sysemu/sysemu.h"
44 #include "hw/s390x/sclp.h"
47 #define CR0_RESET 0xE0UL
48 #define CR14_RESET 0xC2000000UL;
50 static void s390_cpu_set_pc(CPUState
*cs
, vaddr value
)
52 S390CPU
*cpu
= S390_CPU(cs
);
54 cpu
->env
.psw
.addr
= value
;
57 static bool s390_cpu_has_work(CPUState
*cs
)
59 S390CPU
*cpu
= S390_CPU(cs
);
60 CPUS390XState
*env
= &cpu
->env
;
62 return (cs
->interrupt_request
& CPU_INTERRUPT_HARD
) &&
63 (env
->psw
.mask
& PSW_MASK_EXT
);
66 #if !defined(CONFIG_USER_ONLY)
67 /* S390CPUClass::load_normal() */
68 static void s390_cpu_load_normal(CPUState
*s
)
70 S390CPU
*cpu
= S390_CPU(s
);
71 cpu
->env
.psw
.addr
= ldl_phys(s
->as
, 4) & PSW_MASK_ESA_ADDR
;
72 cpu
->env
.psw
.mask
= PSW_MASK_32
| PSW_MASK_64
;
73 s390_cpu_set_state(CPU_STATE_OPERATING
, cpu
);
77 /* S390CPUClass::cpu_reset() */
78 static void s390_cpu_reset(CPUState
*s
)
80 S390CPU
*cpu
= S390_CPU(s
);
81 S390CPUClass
*scc
= S390_CPU_GET_CLASS(cpu
);
82 CPUS390XState
*env
= &cpu
->env
;
84 env
->pfault_token
= -1UL;
86 cpu
->env
.sigp_order
= 0;
87 s390_cpu_set_state(CPU_STATE_STOPPED
, cpu
);
90 /* S390CPUClass::initial_reset() */
91 static void s390_cpu_initial_reset(CPUState
*s
)
93 S390CPU
*cpu
= S390_CPU(s
);
94 CPUS390XState
*env
= &cpu
->env
;
98 /* initial reset does not clear everything! */
99 memset(&env
->start_initial_reset_fields
, 0,
100 offsetof(CPUS390XState
, end_reset_fields
) -
101 offsetof(CPUS390XState
, start_initial_reset_fields
));
103 /* architectured initial values for CR 0 and 14 */
104 env
->cregs
[0] = CR0_RESET
;
105 env
->cregs
[14] = CR14_RESET
;
107 /* architectured initial value for Breaking-Event-Address register */
110 env
->pfault_token
= -1UL;
112 for (i
= 0; i
< ARRAY_SIZE(env
->io_index
); i
++) {
113 env
->io_index
[i
] = -1;
116 /* tininess for underflow is detected before rounding */
117 set_float_detect_tininess(float_tininess_before_rounding
,
120 /* Reset state inside the kernel that we cannot access yet from QEMU. */
122 kvm_s390_reset_vcpu(cpu
);
126 /* CPUClass:reset() */
127 static void s390_cpu_full_reset(CPUState
*s
)
129 S390CPU
*cpu
= S390_CPU(s
);
130 S390CPUClass
*scc
= S390_CPU_GET_CLASS(cpu
);
131 CPUS390XState
*env
= &cpu
->env
;
134 scc
->parent_reset(s
);
135 cpu
->env
.sigp_order
= 0;
136 s390_cpu_set_state(CPU_STATE_STOPPED
, cpu
);
138 memset(env
, 0, offsetof(CPUS390XState
, end_reset_fields
));
140 /* architectured initial values for CR 0 and 14 */
141 env
->cregs
[0] = CR0_RESET
;
142 env
->cregs
[14] = CR14_RESET
;
144 /* architectured initial value for Breaking-Event-Address register */
147 env
->pfault_token
= -1UL;
149 for (i
= 0; i
< ARRAY_SIZE(env
->io_index
); i
++) {
150 env
->io_index
[i
] = -1;
153 /* tininess for underflow is detected before rounding */
154 set_float_detect_tininess(float_tininess_before_rounding
,
157 /* Reset state inside the kernel that we cannot access yet from QEMU. */
159 kvm_s390_reset_vcpu(cpu
);
163 #if !defined(CONFIG_USER_ONLY)
164 static void s390_cpu_machine_reset_cb(void *opaque
)
166 S390CPU
*cpu
= opaque
;
168 run_on_cpu(CPU(cpu
), s390_do_cpu_full_reset
, RUN_ON_CPU_NULL
);
172 static void s390_cpu_disas_set_info(CPUState
*cpu
, disassemble_info
*info
)
174 info
->mach
= bfd_mach_s390_64
;
175 info
->print_insn
= print_insn_s390
;
178 static void s390_cpu_realizefn(DeviceState
*dev
, Error
**errp
)
180 CPUState
*cs
= CPU(dev
);
181 S390CPUClass
*scc
= S390_CPU_GET_CLASS(dev
);
182 S390CPU
*cpu
= S390_CPU(dev
);
183 CPUS390XState
*env
= &cpu
->env
;
186 /* the model has to be realized before qemu_init_vcpu() due to kvm */
187 s390_realize_cpu_model(cs
, &err
);
192 #if !defined(CONFIG_USER_ONLY)
193 if (cpu
->env
.core_id
>= max_cpus
) {
194 error_setg(&err
, "Unable to add CPU with core-id: %" PRIu32
195 ", maximum core-id: %d", cpu
->env
.core_id
,
200 /* implicitly set for linux-user only */
201 cpu
->env
.core_id
= scc
->next_cpu_id
;
204 if (cpu_exists(cpu
->env
.core_id
)) {
205 error_setg(&err
, "Unable to add CPU with core-id: %" PRIu32
206 ", it already exists", cpu
->env
.core_id
);
209 if (cpu
->env
.core_id
!= scc
->next_cpu_id
) {
210 error_setg(&err
, "Unable to add CPU with core-id: %" PRIu32
211 ", the next available core-id is %" PRIi64
, cpu
->env
.core_id
,
216 /* sync cs->cpu_index and env->core_id. The latter is needed for TCG. */
217 cs
->cpu_index
= env
->core_id
;
218 cpu_exec_realizefn(cs
, &err
);
224 #if !defined(CONFIG_USER_ONLY)
225 qemu_register_reset(s390_cpu_machine_reset_cb
, cpu
);
227 s390_cpu_gdb_init(cs
);
229 #if !defined(CONFIG_USER_ONLY)
230 run_on_cpu(cs
, s390_do_cpu_full_reset
, RUN_ON_CPU_NULL
);
235 scc
->parent_realize(dev
, &err
);
237 #if !defined(CONFIG_USER_ONLY)
238 if (dev
->hotplugged
) {
239 raise_irq_cpu_hotplug();
244 error_propagate(errp
, err
);
247 static void s390_cpu_initfn(Object
*obj
)
249 CPUState
*cs
= CPU(obj
);
250 S390CPU
*cpu
= S390_CPU(obj
);
251 CPUS390XState
*env
= &cpu
->env
;
253 #if !defined(CONFIG_USER_ONLY)
259 cs
->exception_index
= EXCP_HLT
;
260 s390_cpu_model_register_props(obj
);
261 #if !defined(CONFIG_USER_ONLY)
262 qemu_get_timedate(&tm
, 0);
263 env
->tod_offset
= TOD_UNIX_EPOCH
+
264 (time2tod(mktimegm(&tm
)) * 1000000000ULL);
265 env
->tod_basetime
= 0;
266 env
->tod_timer
= timer_new_ns(QEMU_CLOCK_VIRTUAL
, s390x_tod_timer
, cpu
);
267 env
->cpu_timer
= timer_new_ns(QEMU_CLOCK_VIRTUAL
, s390x_cpu_timer
, cpu
);
268 s390_cpu_set_state(CPU_STATE_STOPPED
, cpu
);
271 if (tcg_enabled() && !inited
) {
273 s390x_translate_init();
277 static void s390_cpu_finalize(Object
*obj
)
279 #if !defined(CONFIG_USER_ONLY)
280 S390CPU
*cpu
= S390_CPU(obj
);
282 qemu_unregister_reset(s390_cpu_machine_reset_cb
, cpu
);
283 g_free(cpu
->irqstate
);
287 #if !defined(CONFIG_USER_ONLY)
288 static bool disabled_wait(CPUState
*cpu
)
290 return cpu
->halted
&& !(S390_CPU(cpu
)->env
.psw
.mask
&
291 (PSW_MASK_IO
| PSW_MASK_EXT
| PSW_MASK_MCHECK
));
294 static unsigned s390_count_running_cpus(void)
300 uint8_t state
= S390_CPU(cpu
)->env
.cpu_state
;
301 if (state
== CPU_STATE_OPERATING
||
302 state
== CPU_STATE_LOAD
) {
303 if (!disabled_wait(cpu
)) {
312 unsigned int s390_cpu_halt(S390CPU
*cpu
)
314 CPUState
*cs
= CPU(cpu
);
315 trace_cpu_halt(cs
->cpu_index
);
319 cs
->exception_index
= EXCP_HLT
;
322 return s390_count_running_cpus();
325 void s390_cpu_unhalt(S390CPU
*cpu
)
327 CPUState
*cs
= CPU(cpu
);
328 trace_cpu_unhalt(cs
->cpu_index
);
332 cs
->exception_index
= -1;
336 unsigned int s390_cpu_set_state(uint8_t cpu_state
, S390CPU
*cpu
)
338 trace_cpu_set_state(CPU(cpu
)->cpu_index
, cpu_state
);
341 case CPU_STATE_STOPPED
:
342 case CPU_STATE_CHECK_STOP
:
343 /* halt the cpu for common infrastructure */
346 case CPU_STATE_OPERATING
:
348 /* unhalt the cpu for common infrastructure */
349 s390_cpu_unhalt(cpu
);
352 error_report("Requested CPU state is not a valid S390 CPU state: %u",
356 if (kvm_enabled() && cpu
->env
.cpu_state
!= cpu_state
) {
357 kvm_s390_set_cpu_state(cpu
, cpu_state
);
359 cpu
->env
.cpu_state
= cpu_state
;
361 return s390_count_running_cpus();
364 int s390_get_clock(uint8_t *tod_high
, uint64_t *tod_low
)
367 return kvm_s390_get_clock(tod_high
, tod_low
);
375 int s390_set_clock(uint8_t *tod_high
, uint64_t *tod_low
)
378 return kvm_s390_set_clock(tod_high
, tod_low
);
384 int s390_set_memory_limit(uint64_t new_limit
, uint64_t *hw_limit
)
387 return kvm_s390_set_mem_limit(new_limit
, hw_limit
);
392 void s390_cmma_reset(void)
395 kvm_s390_cmma_reset();
399 int s390_cpu_restart(S390CPU
*cpu
)
402 return kvm_s390_cpu_restart(cpu
);
407 int s390_get_memslot_count(void)
410 return kvm_s390_get_memslot_count();
412 return MAX_AVAIL_SLOTS
;
416 int s390_assign_subch_ioeventfd(EventNotifier
*notifier
, uint32_t sch_id
,
420 return kvm_s390_assign_subch_ioeventfd(notifier
, sch_id
, vq
, assign
);
426 void s390_crypto_reset(void)
429 kvm_s390_crypto_reset();
433 bool s390_get_squash_mcss(void)
435 if (object_property_get_bool(OBJECT(qdev_get_machine()), "s390-squash-mcss",
443 void s390_enable_css_support(S390CPU
*cpu
)
446 kvm_s390_enable_css_support(cpu
);
451 static gchar
*s390_gdb_arch_name(CPUState
*cs
)
453 return g_strdup("s390:64-bit");
456 static Property s390x_cpu_properties
[] = {
457 DEFINE_PROP_UINT32("core-id", S390CPU
, env
.core_id
, 0),
458 DEFINE_PROP_END_OF_LIST()
461 static void s390_cpu_class_init(ObjectClass
*oc
, void *data
)
463 S390CPUClass
*scc
= S390_CPU_CLASS(oc
);
464 CPUClass
*cc
= CPU_CLASS(scc
);
465 DeviceClass
*dc
= DEVICE_CLASS(oc
);
467 scc
->next_cpu_id
= 0;
468 scc
->parent_realize
= dc
->realize
;
469 dc
->realize
= s390_cpu_realizefn
;
470 dc
->props
= s390x_cpu_properties
;
472 scc
->parent_reset
= cc
->reset
;
473 #if !defined(CONFIG_USER_ONLY)
474 scc
->load_normal
= s390_cpu_load_normal
;
476 scc
->cpu_reset
= s390_cpu_reset
;
477 scc
->initial_cpu_reset
= s390_cpu_initial_reset
;
478 cc
->reset
= s390_cpu_full_reset
;
479 cc
->class_by_name
= s390_cpu_class_by_name
,
480 cc
->has_work
= s390_cpu_has_work
;
482 cc
->do_interrupt
= s390_cpu_do_interrupt
;
484 cc
->dump_state
= s390_cpu_dump_state
;
485 cc
->set_pc
= s390_cpu_set_pc
;
486 cc
->gdb_read_register
= s390_cpu_gdb_read_register
;
487 cc
->gdb_write_register
= s390_cpu_gdb_write_register
;
488 #ifdef CONFIG_USER_ONLY
489 cc
->handle_mmu_fault
= s390_cpu_handle_mmu_fault
;
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
;
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
;
500 cc
->disas_set_info
= s390_cpu_disas_set_info
;
502 cc
->gdb_num_core_regs
= S390_NUM_CORE_REGS
;
503 cc
->gdb_core_xml_file
= "s390x-core64.xml";
504 cc
->gdb_arch_name
= s390_gdb_arch_name
;
506 s390_cpu_model_class_register_props(oc
);
509 static const TypeInfo s390_cpu_type_info
= {
510 .name
= TYPE_S390_CPU
,
512 .instance_size
= sizeof(S390CPU
),
513 .instance_init
= s390_cpu_initfn
,
514 .instance_finalize
= s390_cpu_finalize
,
516 .class_size
= sizeof(S390CPUClass
),
517 .class_init
= s390_cpu_class_init
,
520 static void s390_cpu_register_types(void)
522 type_register_static(&s390_cpu_type_info
);
525 type_init(s390_cpu_register_types
)