1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23#include "qemu/osdep.h"
24#include "qapi/error.h"
25#include "cpu.h"
26#include "s390x-internal.h"
27#include "kvm/kvm_s390x.h"
28#include "sysemu/kvm.h"
29#include "sysemu/reset.h"
30#include "qemu/module.h"
31#include "trace.h"
32#include "qapi/qapi-types-machine.h"
33#include "sysemu/hw_accel.h"
34#include "hw/qdev-properties.h"
35#include "fpu/softfloat-helpers.h"
36#include "disas/capstone.h"
37#include "sysemu/tcg.h"
38
39#define CR0_RESET 0xE0UL
40#define CR14_RESET 0xC2000000UL;
41
42void s390_cpu_set_psw(CPUS390XState *env, uint64_t mask, uint64_t addr)
43{
44#ifndef CONFIG_USER_ONLY
45 uint64_t old_mask = env->psw.mask;
46#endif
47
48 env->psw.addr = addr;
49 env->psw.mask = mask;
50
51
52 if (!tcg_enabled()) {
53 return;
54 }
55 env->cc_op = (mask >> 44) & 3;
56
57#ifndef CONFIG_USER_ONLY
58 if ((old_mask ^ mask) & PSW_MASK_PER) {
59 s390_cpu_recompute_watchpoints(env_cpu(env));
60 }
61
62 if (mask & PSW_MASK_WAIT) {
63 s390_handle_wait(env_archcpu(env));
64 }
65#endif
66}
67
68uint64_t s390_cpu_get_psw_mask(CPUS390XState *env)
69{
70 uint64_t r = env->psw.mask;
71
72 if (tcg_enabled()) {
73 uint64_t cc = calc_cc(env, env->cc_op, env->cc_src,
74 env->cc_dst, env->cc_vr);
75
76 assert(cc <= 3);
77 r &= ~PSW_MASK_CC;
78 r |= cc << 44;
79 }
80
81 return r;
82}
83
84static void s390_cpu_set_pc(CPUState *cs, vaddr value)
85{
86 S390CPU *cpu = S390_CPU(cs);
87
88 cpu->env.psw.addr = value;
89}
90
91static bool s390_cpu_has_work(CPUState *cs)
92{
93 S390CPU *cpu = S390_CPU(cs);
94
95
96 if (s390_cpu_get_state(cpu) != S390_CPU_STATE_LOAD &&
97 s390_cpu_get_state(cpu) != S390_CPU_STATE_OPERATING) {
98 return false;
99 }
100
101 if (!(cs->interrupt_request & CPU_INTERRUPT_HARD)) {
102 return false;
103 }
104
105 return s390_cpu_has_int(cpu);
106}
107
108
109static void s390_cpu_reset(CPUState *s, cpu_reset_type type)
110{
111 S390CPU *cpu = S390_CPU(s);
112 S390CPUClass *scc = S390_CPU_GET_CLASS(cpu);
113 CPUS390XState *env = &cpu->env;
114 DeviceState *dev = DEVICE(s);
115
116 scc->parent_reset(dev);
117 cpu->env.sigp_order = 0;
118 s390_cpu_set_state(S390_CPU_STATE_STOPPED, cpu);
119
120 switch (type) {
121 case S390_CPU_RESET_CLEAR:
122 memset(env, 0, offsetof(CPUS390XState, start_initial_reset_fields));
123
124 case S390_CPU_RESET_INITIAL:
125
126 memset(&env->start_initial_reset_fields, 0,
127 offsetof(CPUS390XState, start_normal_reset_fields) -
128 offsetof(CPUS390XState, start_initial_reset_fields));
129
130
131 env->gbea = 1;
132
133
134 env->cregs[0] = CR0_RESET;
135 env->cregs[14] = CR14_RESET;
136
137#if defined(CONFIG_USER_ONLY)
138
139 env->cregs[0] |= CR0_AFP;
140 if (s390_has_feat(S390_FEAT_VECTOR)) {
141 env->cregs[0] |= CR0_VECTOR;
142 }
143#endif
144
145
146 set_float_detect_tininess(float_tininess_before_rounding,
147 &env->fpu_status);
148
149 case S390_CPU_RESET_NORMAL:
150 env->psw.mask &= ~PSW_MASK_RI;
151 memset(&env->start_normal_reset_fields, 0,
152 offsetof(CPUS390XState, end_reset_fields) -
153 offsetof(CPUS390XState, start_normal_reset_fields));
154
155 env->pfault_token = -1UL;
156 env->bpbc = false;
157 break;
158 default:
159 g_assert_not_reached();
160 }
161
162
163 if (kvm_enabled()) {
164 switch (type) {
165 case S390_CPU_RESET_CLEAR:
166 kvm_s390_reset_vcpu_clear(cpu);
167 break;
168 case S390_CPU_RESET_INITIAL:
169 kvm_s390_reset_vcpu_initial(cpu);
170 break;
171 case S390_CPU_RESET_NORMAL:
172 kvm_s390_reset_vcpu_normal(cpu);
173 break;
174 }
175 }
176}
177
178static void s390_cpu_disas_set_info(CPUState *cpu, disassemble_info *info)
179{
180 info->mach = bfd_mach_s390_64;
181 info->cap_arch = CS_ARCH_SYSZ;
182 info->cap_insn_unit = 2;
183 info->cap_insn_split = 6;
184}
185
186static void s390_cpu_realizefn(DeviceState *dev, Error **errp)
187{
188 CPUState *cs = CPU(dev);
189 S390CPUClass *scc = S390_CPU_GET_CLASS(dev);
190 Error *err = NULL;
191
192
193 s390_realize_cpu_model(cs, &err);
194 if (err) {
195 goto out;
196 }
197
198#if !defined(CONFIG_USER_ONLY)
199 if (!s390_cpu_realize_sysemu(dev, &err)) {
200 goto out;
201 }
202#endif
203
204 cpu_exec_realizefn(cs, &err);
205 if (err != NULL) {
206 goto out;
207 }
208
209#if !defined(CONFIG_USER_ONLY)
210 qemu_register_reset(s390_cpu_machine_reset_cb, S390_CPU(dev));
211#endif
212 s390_cpu_gdb_init(cs);
213 qemu_init_vcpu(cs);
214
215
216
217
218
219
220
221 if (kvm_enabled()) {
222 run_on_cpu(cs, s390_do_cpu_full_reset, RUN_ON_CPU_NULL);
223 } else {
224 cpu_reset(cs);
225 }
226
227 scc->parent_realize(dev, &err);
228out:
229 error_propagate(errp, err);
230}
231
232static void s390_cpu_initfn(Object *obj)
233{
234 CPUState *cs = CPU(obj);
235 S390CPU *cpu = S390_CPU(obj);
236
237 cpu_set_cpustate_pointers(cpu);
238 cs->exception_index = EXCP_HLT;
239
240#if !defined(CONFIG_USER_ONLY)
241 s390_cpu_init_sysemu(obj);
242#endif
243}
244
245static gchar *s390_gdb_arch_name(CPUState *cs)
246{
247 return g_strdup("s390:64-bit");
248}
249
250static Property s390x_cpu_properties[] = {
251#if !defined(CONFIG_USER_ONLY)
252 DEFINE_PROP_UINT32("core-id", S390CPU, env.core_id, 0),
253#endif
254 DEFINE_PROP_END_OF_LIST()
255};
256
257static void s390_cpu_reset_full(DeviceState *dev)
258{
259 CPUState *s = CPU(dev);
260 return s390_cpu_reset(s, S390_CPU_RESET_CLEAR);
261}
262
263#ifdef CONFIG_TCG
264#include "hw/core/tcg-cpu-ops.h"
265
266static const struct TCGCPUOps s390_tcg_ops = {
267 .initialize = s390x_translate_init,
268
269#ifdef CONFIG_USER_ONLY
270 .record_sigsegv = s390_cpu_record_sigsegv,
271 .record_sigbus = s390_cpu_record_sigbus,
272#else
273 .tlb_fill = s390_cpu_tlb_fill,
274 .cpu_exec_interrupt = s390_cpu_exec_interrupt,
275 .do_interrupt = s390_cpu_do_interrupt,
276 .debug_excp_handler = s390x_cpu_debug_excp_handler,
277 .do_unaligned_access = s390x_cpu_do_unaligned_access,
278#endif
279};
280#endif
281
282static void s390_cpu_class_init(ObjectClass *oc, void *data)
283{
284 S390CPUClass *scc = S390_CPU_CLASS(oc);
285 CPUClass *cc = CPU_CLASS(scc);
286 DeviceClass *dc = DEVICE_CLASS(oc);
287
288 device_class_set_parent_realize(dc, s390_cpu_realizefn,
289 &scc->parent_realize);
290 device_class_set_props(dc, s390x_cpu_properties);
291 dc->user_creatable = true;
292
293 device_class_set_parent_reset(dc, s390_cpu_reset_full, &scc->parent_reset);
294
295 scc->reset = s390_cpu_reset;
296 cc->class_by_name = s390_cpu_class_by_name,
297 cc->has_work = s390_cpu_has_work;
298 cc->dump_state = s390_cpu_dump_state;
299 cc->set_pc = s390_cpu_set_pc;
300 cc->gdb_read_register = s390_cpu_gdb_read_register;
301 cc->gdb_write_register = s390_cpu_gdb_write_register;
302#ifndef CONFIG_USER_ONLY
303 s390_cpu_class_init_sysemu(cc);
304#endif
305 cc->disas_set_info = s390_cpu_disas_set_info;
306 cc->gdb_num_core_regs = S390_NUM_CORE_REGS;
307 cc->gdb_core_xml_file = "s390x-core64.xml";
308 cc->gdb_arch_name = s390_gdb_arch_name;
309
310 s390_cpu_model_class_register_props(oc);
311
312#ifdef CONFIG_TCG
313 cc->tcg_ops = &s390_tcg_ops;
314#endif
315}
316
317static const TypeInfo s390_cpu_type_info = {
318 .name = TYPE_S390_CPU,
319 .parent = TYPE_CPU,
320 .instance_size = sizeof(S390CPU),
321 .instance_align = __alignof__(S390CPU),
322 .instance_init = s390_cpu_initfn,
323
324#ifndef CONFIG_USER_ONLY
325 .instance_finalize = s390_cpu_finalize,
326#endif
327
328 .abstract = true,
329 .class_size = sizeof(S390CPUClass),
330 .class_init = s390_cpu_class_init,
331};
332
333static void s390_cpu_register_types(void)
334{
335 type_register_static(&s390_cpu_type_info);
336}
337
338type_init(s390_cpu_register_types)
339