1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21#include "qemu/osdep.h"
22#include "qapi/error.h"
23#include "qemu-common.h"
24#include "qom/cpu.h"
25#include "sysemu/hw_accel.h"
26#include "qemu/notify.h"
27#include "qemu/log.h"
28#include "exec/log.h"
29#include "exec/cpu-common.h"
30#include "qemu/error-report.h"
31#include "sysemu/sysemu.h"
32#include "hw/qdev-properties.h"
33#include "trace-root.h"
34
35CPUInterruptHandler cpu_interrupt_handler;
36
37bool cpu_exists(int64_t id)
38{
39 CPUState *cpu;
40
41 CPU_FOREACH(cpu) {
42 CPUClass *cc = CPU_GET_CLASS(cpu);
43
44 if (cc->get_arch_id(cpu) == id) {
45 return true;
46 }
47 }
48 return false;
49}
50
51CPUState *cpu_generic_init(const char *typename, const char *cpu_model)
52{
53 char *str, *name, *featurestr;
54 CPUState *cpu = NULL;
55 ObjectClass *oc;
56 CPUClass *cc;
57 Error *err = NULL;
58
59 str = g_strdup(cpu_model);
60 name = strtok(str, ",");
61
62 oc = cpu_class_by_name(typename, name);
63 if (oc == NULL) {
64 g_free(str);
65 return NULL;
66 }
67
68 cc = CPU_CLASS(oc);
69 featurestr = strtok(NULL, ",");
70
71
72
73 cc->parse_features(object_class_get_name(oc), featurestr, &err);
74 g_free(str);
75 if (err != NULL) {
76 goto out;
77 }
78
79 cpu = CPU(object_new(object_class_get_name(oc)));
80 object_property_set_bool(OBJECT(cpu), true, "realized", &err);
81
82out:
83 if (err != NULL) {
84 error_report_err(err);
85 object_unref(OBJECT(cpu));
86 return NULL;
87 }
88
89 return cpu;
90}
91
92bool cpu_paging_enabled(const CPUState *cpu)
93{
94 CPUClass *cc = CPU_GET_CLASS(cpu);
95
96 return cc->get_paging_enabled(cpu);
97}
98
99static bool cpu_common_get_paging_enabled(const CPUState *cpu)
100{
101 return false;
102}
103
104void cpu_get_memory_mapping(CPUState *cpu, MemoryMappingList *list,
105 Error **errp)
106{
107 CPUClass *cc = CPU_GET_CLASS(cpu);
108
109 cc->get_memory_mapping(cpu, list, errp);
110}
111
112static void cpu_common_get_memory_mapping(CPUState *cpu,
113 MemoryMappingList *list,
114 Error **errp)
115{
116 error_setg(errp, "Obtaining memory mappings is unsupported on this CPU.");
117}
118
119
120
121void cpu_reset_interrupt(CPUState *cpu, int mask)
122{
123 bool need_lock = !qemu_mutex_iothread_locked();
124
125 if (need_lock) {
126 qemu_mutex_lock_iothread();
127 }
128 cpu->interrupt_request &= ~mask;
129 if (need_lock) {
130 qemu_mutex_unlock_iothread();
131 }
132}
133
134void cpu_exit(CPUState *cpu)
135{
136 atomic_set(&cpu->exit_request, 1);
137
138 smp_wmb();
139 atomic_set(&cpu->icount_decr.u16.high, -1);
140}
141
142int cpu_write_elf32_qemunote(WriteCoreDumpFunction f, CPUState *cpu,
143 void *opaque)
144{
145 CPUClass *cc = CPU_GET_CLASS(cpu);
146
147 return (*cc->write_elf32_qemunote)(f, cpu, opaque);
148}
149
150static int cpu_common_write_elf32_qemunote(WriteCoreDumpFunction f,
151 CPUState *cpu, void *opaque)
152{
153 return 0;
154}
155
156int cpu_write_elf32_note(WriteCoreDumpFunction f, CPUState *cpu,
157 int cpuid, void *opaque)
158{
159 CPUClass *cc = CPU_GET_CLASS(cpu);
160
161 return (*cc->write_elf32_note)(f, cpu, cpuid, opaque);
162}
163
164static int cpu_common_write_elf32_note(WriteCoreDumpFunction f,
165 CPUState *cpu, int cpuid,
166 void *opaque)
167{
168 return -1;
169}
170
171int cpu_write_elf64_qemunote(WriteCoreDumpFunction f, CPUState *cpu,
172 void *opaque)
173{
174 CPUClass *cc = CPU_GET_CLASS(cpu);
175
176 return (*cc->write_elf64_qemunote)(f, cpu, opaque);
177}
178
179static int cpu_common_write_elf64_qemunote(WriteCoreDumpFunction f,
180 CPUState *cpu, void *opaque)
181{
182 return 0;
183}
184
185int cpu_write_elf64_note(WriteCoreDumpFunction f, CPUState *cpu,
186 int cpuid, void *opaque)
187{
188 CPUClass *cc = CPU_GET_CLASS(cpu);
189
190 return (*cc->write_elf64_note)(f, cpu, cpuid, opaque);
191}
192
193static int cpu_common_write_elf64_note(WriteCoreDumpFunction f,
194 CPUState *cpu, int cpuid,
195 void *opaque)
196{
197 return -1;
198}
199
200
201static int cpu_common_gdb_read_register(CPUState *cpu, uint8_t *buf, int reg)
202{
203 return 0;
204}
205
206static int cpu_common_gdb_write_register(CPUState *cpu, uint8_t *buf, int reg)
207{
208 return 0;
209}
210
211static bool cpu_common_debug_check_watchpoint(CPUState *cpu, CPUWatchpoint *wp)
212{
213
214
215
216 return true;
217}
218
219bool target_words_bigendian(void);
220static bool cpu_common_virtio_is_big_endian(CPUState *cpu)
221{
222 return target_words_bigendian();
223}
224
225static void cpu_common_noop(CPUState *cpu)
226{
227}
228
229static bool cpu_common_exec_interrupt(CPUState *cpu, int int_req)
230{
231 return false;
232}
233
234GuestPanicInformation *cpu_get_crash_info(CPUState *cpu)
235{
236 CPUClass *cc = CPU_GET_CLASS(cpu);
237 GuestPanicInformation *res = NULL;
238
239 if (cc->get_crash_info) {
240 res = cc->get_crash_info(cpu);
241 }
242 return res;
243}
244
245void cpu_dump_state(CPUState *cpu, FILE *f, fprintf_function cpu_fprintf,
246 int flags)
247{
248 CPUClass *cc = CPU_GET_CLASS(cpu);
249
250 if (cc->dump_state) {
251 cpu_synchronize_state(cpu);
252 cc->dump_state(cpu, f, cpu_fprintf, flags);
253 }
254}
255
256void cpu_dump_statistics(CPUState *cpu, FILE *f, fprintf_function cpu_fprintf,
257 int flags)
258{
259 CPUClass *cc = CPU_GET_CLASS(cpu);
260
261 if (cc->dump_statistics) {
262 cc->dump_statistics(cpu, f, cpu_fprintf, flags);
263 }
264}
265
266void cpu_reset(CPUState *cpu)
267{
268 CPUClass *klass = CPU_GET_CLASS(cpu);
269
270 if (klass->reset != NULL) {
271 (*klass->reset)(cpu);
272 }
273
274 trace_guest_cpu_reset(cpu);
275}
276
277static void cpu_common_reset(CPUState *cpu)
278{
279 CPUClass *cc = CPU_GET_CLASS(cpu);
280
281 if (qemu_loglevel_mask(CPU_LOG_RESET)) {
282 qemu_log("CPU Reset (CPU %d)\n", cpu->cpu_index);
283 log_cpu_state(cpu, cc->reset_dump_flags);
284 }
285
286 cpu->interrupt_request = 0;
287 cpu->halted = 0;
288 cpu->mem_io_pc = 0;
289 cpu->mem_io_vaddr = 0;
290 cpu->icount_extra = 0;
291 cpu->icount_decr.u32 = 0;
292 cpu->can_do_io = 1;
293 cpu->exception_index = -1;
294 cpu->crash_occurred = false;
295
296 if (tcg_enabled()) {
297 cpu_tb_jmp_cache_clear(cpu);
298
299 tcg_flush_softmmu_tlb(cpu);
300 }
301}
302
303static bool cpu_common_has_work(CPUState *cs)
304{
305 return false;
306}
307
308ObjectClass *cpu_class_by_name(const char *typename, const char *cpu_model)
309{
310 CPUClass *cc = CPU_CLASS(object_class_by_name(typename));
311
312 return cc->class_by_name(cpu_model);
313}
314
315static ObjectClass *cpu_common_class_by_name(const char *cpu_model)
316{
317 return NULL;
318}
319
320static void cpu_common_parse_features(const char *typename, char *features,
321 Error **errp)
322{
323 char *featurestr;
324 char *val;
325 static bool cpu_globals_initialized;
326
327
328
329
330
331
332
333 if (cpu_globals_initialized) {
334 return;
335 }
336 cpu_globals_initialized = true;
337
338 featurestr = features ? strtok(features, ",") : NULL;
339
340 while (featurestr) {
341 val = strchr(featurestr, '=');
342 if (val) {
343 GlobalProperty *prop = g_new0(typeof(*prop), 1);
344 *val = 0;
345 val++;
346 prop->driver = typename;
347 prop->property = g_strdup(featurestr);
348 prop->value = g_strdup(val);
349 prop->errp = &error_fatal;
350 qdev_prop_register_global(prop);
351 } else {
352 error_setg(errp, "Expected key=value format, found %s.",
353 featurestr);
354 return;
355 }
356 featurestr = strtok(NULL, ",");
357 }
358}
359
360static void cpu_common_realizefn(DeviceState *dev, Error **errp)
361{
362 CPUState *cpu = CPU(dev);
363
364 if (dev->hotplugged) {
365 cpu_synchronize_post_init(cpu);
366 cpu_resume(cpu);
367 }
368
369
370 trace_init_vcpu(cpu);
371}
372
373static void cpu_common_unrealizefn(DeviceState *dev, Error **errp)
374{
375 CPUState *cpu = CPU(dev);
376
377 trace_fini_vcpu(cpu);
378 cpu_exec_unrealizefn(cpu);
379}
380
381static void cpu_common_initfn(Object *obj)
382{
383 CPUState *cpu = CPU(obj);
384 CPUClass *cc = CPU_GET_CLASS(obj);
385
386 cpu->cpu_index = UNASSIGNED_CPU_INDEX;
387 cpu->gdb_num_regs = cpu->gdb_num_g_regs = cc->gdb_num_core_regs;
388
389
390 cpu->nr_cores = 1;
391 cpu->nr_threads = 1;
392
393 qemu_mutex_init(&cpu->work_mutex);
394 QTAILQ_INIT(&cpu->breakpoints);
395 QTAILQ_INIT(&cpu->watchpoints);
396
397 cpu_exec_initfn(cpu);
398}
399
400static void cpu_common_finalize(Object *obj)
401{
402}
403
404static int64_t cpu_common_get_arch_id(CPUState *cpu)
405{
406 return cpu->cpu_index;
407}
408
409static vaddr cpu_adjust_watchpoint_address(CPUState *cpu, vaddr addr, int len)
410{
411 return addr;
412}
413
414static void generic_handle_interrupt(CPUState *cpu, int mask)
415{
416 cpu->interrupt_request |= mask;
417
418 if (!qemu_cpu_is_self(cpu)) {
419 qemu_cpu_kick(cpu);
420 }
421}
422
423CPUInterruptHandler cpu_interrupt_handler = generic_handle_interrupt;
424
425static void cpu_class_init(ObjectClass *klass, void *data)
426{
427 DeviceClass *dc = DEVICE_CLASS(klass);
428 CPUClass *k = CPU_CLASS(klass);
429
430 k->class_by_name = cpu_common_class_by_name;
431 k->parse_features = cpu_common_parse_features;
432 k->reset = cpu_common_reset;
433 k->get_arch_id = cpu_common_get_arch_id;
434 k->has_work = cpu_common_has_work;
435 k->get_paging_enabled = cpu_common_get_paging_enabled;
436 k->get_memory_mapping = cpu_common_get_memory_mapping;
437 k->write_elf32_qemunote = cpu_common_write_elf32_qemunote;
438 k->write_elf32_note = cpu_common_write_elf32_note;
439 k->write_elf64_qemunote = cpu_common_write_elf64_qemunote;
440 k->write_elf64_note = cpu_common_write_elf64_note;
441 k->gdb_read_register = cpu_common_gdb_read_register;
442 k->gdb_write_register = cpu_common_gdb_write_register;
443 k->virtio_is_big_endian = cpu_common_virtio_is_big_endian;
444 k->debug_excp_handler = cpu_common_noop;
445 k->debug_check_watchpoint = cpu_common_debug_check_watchpoint;
446 k->cpu_exec_enter = cpu_common_noop;
447 k->cpu_exec_exit = cpu_common_noop;
448 k->cpu_exec_interrupt = cpu_common_exec_interrupt;
449 k->adjust_watchpoint_address = cpu_adjust_watchpoint_address;
450 set_bit(DEVICE_CATEGORY_CPU, dc->categories);
451 dc->realize = cpu_common_realizefn;
452 dc->unrealize = cpu_common_unrealizefn;
453 dc->props = cpu_common_props;
454
455
456
457
458 dc->user_creatable = false;
459}
460
461static const TypeInfo cpu_type_info = {
462 .name = TYPE_CPU,
463 .parent = TYPE_DEVICE,
464 .instance_size = sizeof(CPUState),
465 .instance_init = cpu_common_initfn,
466 .instance_finalize = cpu_common_finalize,
467 .abstract = true,
468 .class_size = sizeof(CPUClass),
469 .class_init = cpu_class_init,
470};
471
472static void cpu_register_types(void)
473{
474 type_register_static(&cpu_type_info);
475}
476
477type_init(cpu_register_types)
478