MAINTAINERS: Make sure that gicv3_internal.h is covered, too
[qemu/ar7.git] / cpu-target.c
blob79363ae370e22ca83bc62c170c3cab31ab2ac4f6
1 /*
2 * Target-specific parts of the CPU object
4 * Copyright (c) 2003 Fabrice Bellard
6 * This library is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2 of the License, or (at your option) any later version.
11 * This library is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with this library; if not, see <http://www.gnu.org/licenses/>.
20 #include "qemu/osdep.h"
21 #include "qapi/error.h"
23 #include "exec/target_page.h"
24 #include "hw/qdev-core.h"
25 #include "hw/qdev-properties.h"
26 #include "qemu/error-report.h"
27 #include "migration/vmstate.h"
28 #ifdef CONFIG_USER_ONLY
29 #include "qemu.h"
30 #else
31 #include "hw/core/sysemu-cpu-ops.h"
32 #include "exec/address-spaces.h"
33 #endif
34 #include "sysemu/cpus.h"
35 #include "sysemu/tcg.h"
36 #include "exec/replay-core.h"
37 #include "exec/cpu-common.h"
38 #include "exec/exec-all.h"
39 #include "exec/tb-flush.h"
40 #include "exec/translate-all.h"
41 #include "exec/log.h"
42 #include "hw/core/accel-cpu.h"
43 #include "trace/trace-root.h"
44 #include "qemu/accel.h"
45 #include "qemu/plugin.h"
47 uintptr_t qemu_host_page_size;
48 intptr_t qemu_host_page_mask;
50 #ifndef CONFIG_USER_ONLY
51 static int cpu_common_post_load(void *opaque, int version_id)
53 CPUState *cpu = opaque;
55 /* 0x01 was CPU_INTERRUPT_EXIT. This line can be removed when the
56 version_id is increased. */
57 cpu->interrupt_request &= ~0x01;
58 tlb_flush(cpu);
60 /* loadvm has just updated the content of RAM, bypassing the
61 * usual mechanisms that ensure we flush TBs for writes to
62 * memory we've translated code from. So we must flush all TBs,
63 * which will now be stale.
65 tb_flush(cpu);
67 return 0;
70 static int cpu_common_pre_load(void *opaque)
72 CPUState *cpu = opaque;
74 cpu->exception_index = -1;
76 return 0;
79 static bool cpu_common_exception_index_needed(void *opaque)
81 CPUState *cpu = opaque;
83 return tcg_enabled() && cpu->exception_index != -1;
86 static const VMStateDescription vmstate_cpu_common_exception_index = {
87 .name = "cpu_common/exception_index",
88 .version_id = 1,
89 .minimum_version_id = 1,
90 .needed = cpu_common_exception_index_needed,
91 .fields = (VMStateField[]) {
92 VMSTATE_INT32(exception_index, CPUState),
93 VMSTATE_END_OF_LIST()
97 static bool cpu_common_crash_occurred_needed(void *opaque)
99 CPUState *cpu = opaque;
101 return cpu->crash_occurred;
104 static const VMStateDescription vmstate_cpu_common_crash_occurred = {
105 .name = "cpu_common/crash_occurred",
106 .version_id = 1,
107 .minimum_version_id = 1,
108 .needed = cpu_common_crash_occurred_needed,
109 .fields = (VMStateField[]) {
110 VMSTATE_BOOL(crash_occurred, CPUState),
111 VMSTATE_END_OF_LIST()
115 const VMStateDescription vmstate_cpu_common = {
116 .name = "cpu_common",
117 .version_id = 1,
118 .minimum_version_id = 1,
119 .pre_load = cpu_common_pre_load,
120 .post_load = cpu_common_post_load,
121 .fields = (VMStateField[]) {
122 VMSTATE_UINT32(halted, CPUState),
123 VMSTATE_UINT32(interrupt_request, CPUState),
124 VMSTATE_END_OF_LIST()
126 .subsections = (const VMStateDescription*[]) {
127 &vmstate_cpu_common_exception_index,
128 &vmstate_cpu_common_crash_occurred,
129 NULL
132 #endif
134 void cpu_exec_realizefn(CPUState *cpu, Error **errp)
136 /* cache the cpu class for the hotpath */
137 cpu->cc = CPU_GET_CLASS(cpu);
139 if (!accel_cpu_common_realize(cpu, errp)) {
140 return;
143 /* Wait until cpu initialization complete before exposing cpu. */
144 cpu_list_add(cpu);
146 /* Plugin initialization must wait until cpu_index assigned. */
147 if (tcg_enabled()) {
148 qemu_plugin_vcpu_init_hook(cpu);
151 #ifdef CONFIG_USER_ONLY
152 assert(qdev_get_vmsd(DEVICE(cpu)) == NULL ||
153 qdev_get_vmsd(DEVICE(cpu))->unmigratable);
154 #else
155 if (qdev_get_vmsd(DEVICE(cpu)) == NULL) {
156 vmstate_register(NULL, cpu->cpu_index, &vmstate_cpu_common, cpu);
158 if (cpu->cc->sysemu_ops->legacy_vmsd != NULL) {
159 vmstate_register(NULL, cpu->cpu_index, cpu->cc->sysemu_ops->legacy_vmsd, cpu);
161 #endif /* CONFIG_USER_ONLY */
164 void cpu_exec_unrealizefn(CPUState *cpu)
166 #ifndef CONFIG_USER_ONLY
167 CPUClass *cc = CPU_GET_CLASS(cpu);
169 if (cc->sysemu_ops->legacy_vmsd != NULL) {
170 vmstate_unregister(NULL, cc->sysemu_ops->legacy_vmsd, cpu);
172 if (qdev_get_vmsd(DEVICE(cpu)) == NULL) {
173 vmstate_unregister(NULL, &vmstate_cpu_common, cpu);
175 #endif
177 /* Call the plugin hook before clearing cpu->cpu_index in cpu_list_remove */
178 if (tcg_enabled()) {
179 qemu_plugin_vcpu_exit_hook(cpu);
182 cpu_list_remove(cpu);
184 * Now that the vCPU has been removed from the RCU list, we can call
185 * accel_cpu_common_unrealize, which may free fields using call_rcu.
187 accel_cpu_common_unrealize(cpu);
191 * This can't go in hw/core/cpu.c because that file is compiled only
192 * once for both user-mode and system builds.
194 static Property cpu_common_props[] = {
195 #ifdef CONFIG_USER_ONLY
197 * Create a property for the user-only object, so users can
198 * adjust prctl(PR_SET_UNALIGN) from the command-line.
199 * Has no effect if the target does not support the feature.
201 DEFINE_PROP_BOOL("prctl-unalign-sigbus", CPUState,
202 prctl_unalign_sigbus, false),
203 #else
205 * Create a memory property for system CPU object, so users can
206 * wire up its memory. The default if no link is set up is to use
207 * the system address space.
209 DEFINE_PROP_LINK("memory", CPUState, memory, TYPE_MEMORY_REGION,
210 MemoryRegion *),
211 #endif
212 DEFINE_PROP_END_OF_LIST(),
215 static bool cpu_get_start_powered_off(Object *obj, Error **errp)
217 CPUState *cpu = CPU(obj);
218 return cpu->start_powered_off;
221 static void cpu_set_start_powered_off(Object *obj, bool value, Error **errp)
223 CPUState *cpu = CPU(obj);
224 cpu->start_powered_off = value;
227 void cpu_class_init_props(DeviceClass *dc)
229 ObjectClass *oc = OBJECT_CLASS(dc);
231 device_class_set_props(dc, cpu_common_props);
233 * We can't use DEFINE_PROP_BOOL in the Property array for this
234 * property, because we want this to be settable after realize.
236 object_class_property_add_bool(oc, "start-powered-off",
237 cpu_get_start_powered_off,
238 cpu_set_start_powered_off);
241 void cpu_exec_initfn(CPUState *cpu)
243 cpu->as = NULL;
244 cpu->num_ases = 0;
246 #ifndef CONFIG_USER_ONLY
247 cpu->thread_id = qemu_get_thread_id();
248 cpu->memory = get_system_memory();
249 object_ref(OBJECT(cpu->memory));
250 #endif
253 const char *parse_cpu_option(const char *cpu_option)
255 ObjectClass *oc;
256 CPUClass *cc;
257 gchar **model_pieces;
258 const char *cpu_type;
260 model_pieces = g_strsplit(cpu_option, ",", 2);
261 if (!model_pieces[0]) {
262 error_report("-cpu option cannot be empty");
263 exit(1);
266 oc = cpu_class_by_name(CPU_RESOLVING_TYPE, model_pieces[0]);
267 if (oc == NULL) {
268 error_report("unable to find CPU model '%s'", model_pieces[0]);
269 g_strfreev(model_pieces);
270 exit(EXIT_FAILURE);
273 cpu_type = object_class_get_name(oc);
274 cc = CPU_CLASS(oc);
275 cc->parse_features(cpu_type, model_pieces[1], &error_fatal);
276 g_strfreev(model_pieces);
277 return cpu_type;
280 void list_cpus(void)
282 /* XXX: implement xxx_cpu_list for targets that still miss it */
283 #if defined(cpu_list)
284 cpu_list();
285 #endif
288 #if defined(CONFIG_USER_ONLY)
289 void tb_invalidate_phys_addr(hwaddr addr)
291 mmap_lock();
292 tb_invalidate_phys_page(addr);
293 mmap_unlock();
295 #else
296 void tb_invalidate_phys_addr(AddressSpace *as, hwaddr addr, MemTxAttrs attrs)
298 ram_addr_t ram_addr;
299 MemoryRegion *mr;
300 hwaddr l = 1;
302 if (!tcg_enabled()) {
303 return;
306 RCU_READ_LOCK_GUARD();
307 mr = address_space_translate(as, addr, &addr, &l, false, attrs);
308 if (!(memory_region_is_ram(mr)
309 || memory_region_is_romd(mr))) {
310 return;
312 ram_addr = memory_region_get_ram_addr(mr) + addr;
313 tb_invalidate_phys_page(ram_addr);
315 #endif
317 /* enable or disable single step mode. EXCP_DEBUG is returned by the
318 CPU loop after each instruction */
319 void cpu_single_step(CPUState *cpu, int enabled)
321 if (cpu->singlestep_enabled != enabled) {
322 cpu->singlestep_enabled = enabled;
324 #if !defined(CONFIG_USER_ONLY)
325 const AccelOpsClass *ops = cpus_get_accel();
326 if (ops->update_guest_debug) {
327 ops->update_guest_debug(cpu);
329 #endif
331 trace_breakpoint_singlestep(cpu->cpu_index, enabled);
335 void cpu_abort(CPUState *cpu, const char *fmt, ...)
337 va_list ap;
338 va_list ap2;
340 va_start(ap, fmt);
341 va_copy(ap2, ap);
342 fprintf(stderr, "qemu: fatal: ");
343 vfprintf(stderr, fmt, ap);
344 fprintf(stderr, "\n");
345 cpu_dump_state(cpu, stderr, CPU_DUMP_FPU | CPU_DUMP_CCOP);
346 if (qemu_log_separate()) {
347 FILE *logfile = qemu_log_trylock();
348 if (logfile) {
349 fprintf(logfile, "qemu: fatal: ");
350 vfprintf(logfile, fmt, ap2);
351 fprintf(logfile, "\n");
352 cpu_dump_state(cpu, logfile, CPU_DUMP_FPU | CPU_DUMP_CCOP);
353 qemu_log_unlock(logfile);
356 va_end(ap2);
357 va_end(ap);
358 replay_finish();
359 #if defined(CONFIG_USER_ONLY)
361 struct sigaction act;
362 sigfillset(&act.sa_mask);
363 act.sa_handler = SIG_DFL;
364 act.sa_flags = 0;
365 sigaction(SIGABRT, &act, NULL);
367 #endif
368 abort();
371 /* physical memory access (slow version, mainly for debug) */
372 #if defined(CONFIG_USER_ONLY)
373 int cpu_memory_rw_debug(CPUState *cpu, vaddr addr,
374 void *ptr, size_t len, bool is_write)
376 int flags;
377 vaddr l, page;
378 void * p;
379 uint8_t *buf = ptr;
381 while (len > 0) {
382 page = addr & TARGET_PAGE_MASK;
383 l = (page + TARGET_PAGE_SIZE) - addr;
384 if (l > len)
385 l = len;
386 flags = page_get_flags(page);
387 if (!(flags & PAGE_VALID))
388 return -1;
389 if (is_write) {
390 if (!(flags & PAGE_WRITE))
391 return -1;
392 /* XXX: this code should not depend on lock_user */
393 if (!(p = lock_user(VERIFY_WRITE, addr, l, 0)))
394 return -1;
395 memcpy(p, buf, l);
396 unlock_user(p, addr, l);
397 } else {
398 if (!(flags & PAGE_READ))
399 return -1;
400 /* XXX: this code should not depend on lock_user */
401 if (!(p = lock_user(VERIFY_READ, addr, l, 1)))
402 return -1;
403 memcpy(buf, p, l);
404 unlock_user(p, addr, 0);
406 len -= l;
407 buf += l;
408 addr += l;
410 return 0;
412 #endif
414 bool target_words_bigendian(void)
416 return TARGET_BIG_ENDIAN;
419 const char *target_name(void)
421 return TARGET_NAME;
424 void page_size_init(void)
426 /* NOTE: we can always suppose that qemu_host_page_size >=
427 TARGET_PAGE_SIZE */
428 if (qemu_host_page_size == 0) {
429 qemu_host_page_size = qemu_real_host_page_size();
431 if (qemu_host_page_size < TARGET_PAGE_SIZE) {
432 qemu_host_page_size = TARGET_PAGE_SIZE;
434 qemu_host_page_mask = -(intptr_t)qemu_host_page_size;