Paolo Bonzini | d9f24bf | 2020-10-06 09:05:29 +0200 | [diff] [blame] | 1 | /* |
| 2 | * Target-specific parts of the CPU object |
| 3 | * |
| 4 | * Copyright (c) 2003 Fabrice Bellard |
| 5 | * |
| 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. |
| 10 | * |
| 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. |
| 15 | * |
| 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/>. |
| 18 | */ |
| 19 | |
| 20 | #include "qemu/osdep.h" |
Paolo Bonzini | d9f24bf | 2020-10-06 09:05:29 +0200 | [diff] [blame] | 21 | #include "qapi/error.h" |
| 22 | |
| 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 |
Philippe Mathieu-Daudé | 8b80bd2 | 2021-05-17 12:51:31 +0200 | [diff] [blame] | 31 | #include "hw/core/sysemu-cpu-ops.h" |
Paolo Bonzini | d9f24bf | 2020-10-06 09:05:29 +0200 | [diff] [blame] | 32 | #include "exec/address-spaces.h" |
| 33 | #endif |
Mads Ynddal | 412ae12 | 2023-03-02 18:58:05 -0800 | [diff] [blame] | 34 | #include "sysemu/cpus.h" |
Paolo Bonzini | d9f24bf | 2020-10-06 09:05:29 +0200 | [diff] [blame] | 35 | #include "sysemu/tcg.h" |
Philippe Mathieu-Daudé | 5b5968c | 2022-12-19 18:09:43 +0100 | [diff] [blame] | 36 | #include "exec/replay-core.h" |
Philippe Mathieu-Daudé | 377bf6f | 2022-03-14 15:01:08 +0100 | [diff] [blame] | 37 | #include "exec/cpu-common.h" |
Philippe Mathieu-Daudé | 3b04508 | 2022-02-07 15:28:56 +0100 | [diff] [blame] | 38 | #include "exec/exec-all.h" |
Alex Bennée | 548c960 | 2023-03-02 18:57:43 -0800 | [diff] [blame] | 39 | #include "exec/tb-flush.h" |
Paolo Bonzini | 3b9bd3f | 2020-12-16 13:27:58 +0100 | [diff] [blame] | 40 | #include "exec/translate-all.h" |
Paolo Bonzini | d9f24bf | 2020-10-06 09:05:29 +0200 | [diff] [blame] | 41 | #include "exec/log.h" |
Claudio Fontana | 30565f1 | 2021-03-22 14:27:41 +0100 | [diff] [blame] | 42 | #include "hw/core/accel-cpu.h" |
Richard Henderson | ad1a706 | 2021-07-01 08:10:53 -0700 | [diff] [blame] | 43 | #include "trace/trace-root.h" |
Philippe Mathieu-Daudé | 3b04508 | 2022-02-07 15:28:56 +0100 | [diff] [blame] | 44 | #include "qemu/accel.h" |
Richard Henderson | 720ace2 | 2023-03-15 17:43:14 +0000 | [diff] [blame] | 45 | #include "qemu/plugin.h" |
Paolo Bonzini | d9f24bf | 2020-10-06 09:05:29 +0200 | [diff] [blame] | 46 | |
| 47 | uintptr_t qemu_host_page_size; |
| 48 | intptr_t qemu_host_page_mask; |
| 49 | |
| 50 | #ifndef CONFIG_USER_ONLY |
| 51 | static int cpu_common_post_load(void *opaque, int version_id) |
| 52 | { |
| 53 | CPUState *cpu = opaque; |
| 54 | |
| 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); |
| 59 | |
| 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. |
| 64 | */ |
| 65 | tb_flush(cpu); |
| 66 | |
| 67 | return 0; |
| 68 | } |
| 69 | |
| 70 | static int cpu_common_pre_load(void *opaque) |
| 71 | { |
| 72 | CPUState *cpu = opaque; |
| 73 | |
| 74 | cpu->exception_index = -1; |
| 75 | |
| 76 | return 0; |
| 77 | } |
| 78 | |
| 79 | static bool cpu_common_exception_index_needed(void *opaque) |
| 80 | { |
| 81 | CPUState *cpu = opaque; |
| 82 | |
| 83 | return tcg_enabled() && cpu->exception_index != -1; |
| 84 | } |
| 85 | |
| 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() |
| 94 | } |
| 95 | }; |
| 96 | |
| 97 | static bool cpu_common_crash_occurred_needed(void *opaque) |
| 98 | { |
| 99 | CPUState *cpu = opaque; |
| 100 | |
| 101 | return cpu->crash_occurred; |
| 102 | } |
| 103 | |
| 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() |
| 112 | } |
| 113 | }; |
| 114 | |
| 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() |
| 125 | }, |
| 126 | .subsections = (const VMStateDescription*[]) { |
| 127 | &vmstate_cpu_common_exception_index, |
| 128 | &vmstate_cpu_common_crash_occurred, |
| 129 | NULL |
| 130 | } |
| 131 | }; |
| 132 | #endif |
| 133 | |
Claudio Fontana | 7df5e3d | 2021-02-04 17:39:11 +0100 | [diff] [blame] | 134 | void cpu_exec_realizefn(CPUState *cpu, Error **errp) |
Paolo Bonzini | d9f24bf | 2020-10-06 09:05:29 +0200 | [diff] [blame] | 135 | { |
Alex Bennée | 6fbdff8 | 2022-09-23 10:47:59 +0200 | [diff] [blame] | 136 | /* cache the cpu class for the hotpath */ |
| 137 | cpu->cc = CPU_GET_CLASS(cpu); |
Paolo Bonzini | d9f24bf | 2020-10-06 09:05:29 +0200 | [diff] [blame] | 138 | |
Claudio Fontana | 9ea057d | 2021-03-22 14:27:44 +0100 | [diff] [blame] | 139 | if (!accel_cpu_realizefn(cpu, errp)) { |
| 140 | return; |
| 141 | } |
Richard Henderson | 4e4fa6c | 2022-10-31 13:26:36 +1100 | [diff] [blame] | 142 | |
Claudio Fontana | 7df5e3d | 2021-02-04 17:39:11 +0100 | [diff] [blame] | 143 | /* NB: errp parameter is unused currently */ |
| 144 | if (tcg_enabled()) { |
| 145 | tcg_exec_realizefn(cpu, errp); |
| 146 | } |
Claudio Fontana | 7df5e3d | 2021-02-04 17:39:11 +0100 | [diff] [blame] | 147 | |
Richard Henderson | 4e4fa6c | 2022-10-31 13:26:36 +1100 | [diff] [blame] | 148 | /* Wait until cpu initialization complete before exposing cpu. */ |
| 149 | cpu_list_add(cpu); |
| 150 | |
| 151 | /* Plugin initialization must wait until cpu_index assigned. */ |
| 152 | if (tcg_enabled()) { |
| 153 | qemu_plugin_vcpu_init_hook(cpu); |
| 154 | } |
| 155 | |
Claudio Fontana | 7df5e3d | 2021-02-04 17:39:11 +0100 | [diff] [blame] | 156 | #ifdef CONFIG_USER_ONLY |
Philippe Mathieu-Daudé | 4336073 | 2021-05-17 12:51:28 +0200 | [diff] [blame] | 157 | assert(qdev_get_vmsd(DEVICE(cpu)) == NULL || |
| 158 | qdev_get_vmsd(DEVICE(cpu))->unmigratable); |
Claudio Fontana | 7df5e3d | 2021-02-04 17:39:11 +0100 | [diff] [blame] | 159 | #else |
| 160 | if (qdev_get_vmsd(DEVICE(cpu)) == NULL) { |
| 161 | vmstate_register(NULL, cpu->cpu_index, &vmstate_cpu_common, cpu); |
| 162 | } |
Alex Bennée | 6fbdff8 | 2022-09-23 10:47:59 +0200 | [diff] [blame] | 163 | if (cpu->cc->sysemu_ops->legacy_vmsd != NULL) { |
| 164 | vmstate_register(NULL, cpu->cpu_index, cpu->cc->sysemu_ops->legacy_vmsd, cpu); |
Claudio Fontana | 7df5e3d | 2021-02-04 17:39:11 +0100 | [diff] [blame] | 165 | } |
| 166 | #endif /* CONFIG_USER_ONLY */ |
| 167 | } |
| 168 | |
| 169 | void cpu_exec_unrealizefn(CPUState *cpu) |
| 170 | { |
Philippe Mathieu-Daudé | feece4d | 2021-05-17 12:51:32 +0200 | [diff] [blame] | 171 | #ifndef CONFIG_USER_ONLY |
Claudio Fontana | 7df5e3d | 2021-02-04 17:39:11 +0100 | [diff] [blame] | 172 | CPUClass *cc = CPU_GET_CLASS(cpu); |
Paolo Bonzini | d9f24bf | 2020-10-06 09:05:29 +0200 | [diff] [blame] | 173 | |
Philippe Mathieu-Daudé | feece4d | 2021-05-17 12:51:32 +0200 | [diff] [blame] | 174 | if (cc->sysemu_ops->legacy_vmsd != NULL) { |
| 175 | vmstate_unregister(NULL, cc->sysemu_ops->legacy_vmsd, cpu); |
Paolo Bonzini | d9f24bf | 2020-10-06 09:05:29 +0200 | [diff] [blame] | 176 | } |
| 177 | if (qdev_get_vmsd(DEVICE(cpu)) == NULL) { |
| 178 | vmstate_unregister(NULL, &vmstate_cpu_common, cpu); |
| 179 | } |
Paolo Bonzini | d9f24bf | 2020-10-06 09:05:29 +0200 | [diff] [blame] | 180 | #endif |
Emilio Cota | 4731f89 | 2023-01-24 18:01:18 +0000 | [diff] [blame] | 181 | |
| 182 | /* Call the plugin hook before clearing cpu->cpu_index in cpu_list_remove */ |
Claudio Fontana | 7df5e3d | 2021-02-04 17:39:11 +0100 | [diff] [blame] | 183 | if (tcg_enabled()) { |
Emilio Cota | 4731f89 | 2023-01-24 18:01:18 +0000 | [diff] [blame] | 184 | qemu_plugin_vcpu_exit_hook(cpu); |
Claudio Fontana | 7df5e3d | 2021-02-04 17:39:11 +0100 | [diff] [blame] | 185 | } |
Claudio Fontana | 7df5e3d | 2021-02-04 17:39:11 +0100 | [diff] [blame] | 186 | |
| 187 | cpu_list_remove(cpu); |
Emilio Cota | 4731f89 | 2023-01-24 18:01:18 +0000 | [diff] [blame] | 188 | /* |
| 189 | * Now that the vCPU has been removed from the RCU list, we can call |
| 190 | * tcg_exec_unrealizefn, which may free fields using call_rcu. |
| 191 | */ |
| 192 | if (tcg_enabled()) { |
| 193 | tcg_exec_unrealizefn(cpu); |
| 194 | } |
Paolo Bonzini | d9f24bf | 2020-10-06 09:05:29 +0200 | [diff] [blame] | 195 | } |
| 196 | |
Richard Henderson | 6e8dcac | 2021-12-27 07:01:24 -0800 | [diff] [blame] | 197 | /* |
| 198 | * This can't go in hw/core/cpu.c because that file is compiled only |
| 199 | * once for both user-mode and system builds. |
| 200 | */ |
Richard Henderson | 995b87d | 2021-08-22 00:25:28 -0700 | [diff] [blame] | 201 | static Property cpu_common_props[] = { |
Richard Henderson | 6e8dcac | 2021-12-27 07:01:24 -0800 | [diff] [blame] | 202 | #ifdef CONFIG_USER_ONLY |
Richard Henderson | 995b87d | 2021-08-22 00:25:28 -0700 | [diff] [blame] | 203 | /* |
Richard Henderson | 6e8dcac | 2021-12-27 07:01:24 -0800 | [diff] [blame] | 204 | * Create a property for the user-only object, so users can |
| 205 | * adjust prctl(PR_SET_UNALIGN) from the command-line. |
| 206 | * Has no effect if the target does not support the feature. |
| 207 | */ |
| 208 | DEFINE_PROP_BOOL("prctl-unalign-sigbus", CPUState, |
| 209 | prctl_unalign_sigbus, false), |
| 210 | #else |
| 211 | /* |
| 212 | * Create a memory property for softmmu CPU object, so users can |
| 213 | * wire up its memory. The default if no link is set up is to use |
Richard Henderson | 995b87d | 2021-08-22 00:25:28 -0700 | [diff] [blame] | 214 | * the system address space. |
| 215 | */ |
| 216 | DEFINE_PROP_LINK("memory", CPUState, memory, TYPE_MEMORY_REGION, |
| 217 | MemoryRegion *), |
| 218 | #endif |
Richard Henderson | 995b87d | 2021-08-22 00:25:28 -0700 | [diff] [blame] | 219 | DEFINE_PROP_END_OF_LIST(), |
| 220 | }; |
| 221 | |
Peter Maydell | 0c3c25f | 2022-01-27 15:46:25 +0000 | [diff] [blame] | 222 | static bool cpu_get_start_powered_off(Object *obj, Error **errp) |
| 223 | { |
| 224 | CPUState *cpu = CPU(obj); |
| 225 | return cpu->start_powered_off; |
| 226 | } |
| 227 | |
| 228 | static void cpu_set_start_powered_off(Object *obj, bool value, Error **errp) |
| 229 | { |
| 230 | CPUState *cpu = CPU(obj); |
| 231 | cpu->start_powered_off = value; |
| 232 | } |
| 233 | |
Richard Henderson | 995b87d | 2021-08-22 00:25:28 -0700 | [diff] [blame] | 234 | void cpu_class_init_props(DeviceClass *dc) |
| 235 | { |
Peter Maydell | 0c3c25f | 2022-01-27 15:46:25 +0000 | [diff] [blame] | 236 | ObjectClass *oc = OBJECT_CLASS(dc); |
| 237 | |
Richard Henderson | 995b87d | 2021-08-22 00:25:28 -0700 | [diff] [blame] | 238 | device_class_set_props(dc, cpu_common_props); |
Peter Maydell | 0c3c25f | 2022-01-27 15:46:25 +0000 | [diff] [blame] | 239 | /* |
| 240 | * We can't use DEFINE_PROP_BOOL in the Property array for this |
| 241 | * property, because we want this to be settable after realize. |
| 242 | */ |
| 243 | object_class_property_add_bool(oc, "start-powered-off", |
| 244 | cpu_get_start_powered_off, |
| 245 | cpu_set_start_powered_off); |
Richard Henderson | 995b87d | 2021-08-22 00:25:28 -0700 | [diff] [blame] | 246 | } |
| 247 | |
Paolo Bonzini | d9f24bf | 2020-10-06 09:05:29 +0200 | [diff] [blame] | 248 | void cpu_exec_initfn(CPUState *cpu) |
| 249 | { |
| 250 | cpu->as = NULL; |
| 251 | cpu->num_ases = 0; |
| 252 | |
| 253 | #ifndef CONFIG_USER_ONLY |
| 254 | cpu->thread_id = qemu_get_thread_id(); |
| 255 | cpu->memory = get_system_memory(); |
| 256 | object_ref(OBJECT(cpu->memory)); |
| 257 | #endif |
| 258 | } |
| 259 | |
Paolo Bonzini | d9f24bf | 2020-10-06 09:05:29 +0200 | [diff] [blame] | 260 | const char *parse_cpu_option(const char *cpu_option) |
| 261 | { |
| 262 | ObjectClass *oc; |
| 263 | CPUClass *cc; |
| 264 | gchar **model_pieces; |
| 265 | const char *cpu_type; |
| 266 | |
| 267 | model_pieces = g_strsplit(cpu_option, ",", 2); |
| 268 | if (!model_pieces[0]) { |
| 269 | error_report("-cpu option cannot be empty"); |
| 270 | exit(1); |
| 271 | } |
| 272 | |
| 273 | oc = cpu_class_by_name(CPU_RESOLVING_TYPE, model_pieces[0]); |
| 274 | if (oc == NULL) { |
| 275 | error_report("unable to find CPU model '%s'", model_pieces[0]); |
| 276 | g_strfreev(model_pieces); |
| 277 | exit(EXIT_FAILURE); |
| 278 | } |
| 279 | |
| 280 | cpu_type = object_class_get_name(oc); |
| 281 | cc = CPU_CLASS(oc); |
| 282 | cc->parse_features(cpu_type, model_pieces[1], &error_fatal); |
| 283 | g_strfreev(model_pieces); |
| 284 | return cpu_type; |
| 285 | } |
| 286 | |
Thomas Huth | c138c3b | 2023-04-19 14:48:31 +0200 | [diff] [blame] | 287 | void list_cpus(void) |
Philippe Mathieu-Daudé | 377bf6f | 2022-03-14 15:01:08 +0100 | [diff] [blame] | 288 | { |
| 289 | /* XXX: implement xxx_cpu_list for targets that still miss it */ |
| 290 | #if defined(cpu_list) |
| 291 | cpu_list(); |
| 292 | #endif |
| 293 | } |
| 294 | |
Paolo Bonzini | d9f24bf | 2020-10-06 09:05:29 +0200 | [diff] [blame] | 295 | #if defined(CONFIG_USER_ONLY) |
Anton Johansson | c814c89 | 2023-06-21 15:56:33 +0200 | [diff] [blame] | 296 | void tb_invalidate_phys_addr(hwaddr addr) |
Paolo Bonzini | d9f24bf | 2020-10-06 09:05:29 +0200 | [diff] [blame] | 297 | { |
| 298 | mmap_lock(); |
Richard Henderson | d6d1fd2 | 2022-10-05 09:26:26 -0700 | [diff] [blame] | 299 | tb_invalidate_phys_page(addr); |
Paolo Bonzini | d9f24bf | 2020-10-06 09:05:29 +0200 | [diff] [blame] | 300 | mmap_unlock(); |
| 301 | } |
Paolo Bonzini | d9f24bf | 2020-10-06 09:05:29 +0200 | [diff] [blame] | 302 | #else |
| 303 | void tb_invalidate_phys_addr(AddressSpace *as, hwaddr addr, MemTxAttrs attrs) |
| 304 | { |
| 305 | ram_addr_t ram_addr; |
| 306 | MemoryRegion *mr; |
| 307 | hwaddr l = 1; |
| 308 | |
| 309 | if (!tcg_enabled()) { |
| 310 | return; |
| 311 | } |
| 312 | |
| 313 | RCU_READ_LOCK_GUARD(); |
| 314 | mr = address_space_translate(as, addr, &addr, &l, false, attrs); |
| 315 | if (!(memory_region_is_ram(mr) |
| 316 | || memory_region_is_romd(mr))) { |
| 317 | return; |
| 318 | } |
| 319 | ram_addr = memory_region_get_ram_addr(mr) + addr; |
Richard Henderson | d6d1fd2 | 2022-10-05 09:26:26 -0700 | [diff] [blame] | 320 | tb_invalidate_phys_page(ram_addr); |
Paolo Bonzini | d9f24bf | 2020-10-06 09:05:29 +0200 | [diff] [blame] | 321 | } |
Paolo Bonzini | d9f24bf | 2020-10-06 09:05:29 +0200 | [diff] [blame] | 322 | #endif |
| 323 | |
Paolo Bonzini | d9f24bf | 2020-10-06 09:05:29 +0200 | [diff] [blame] | 324 | /* enable or disable single step mode. EXCP_DEBUG is returned by the |
| 325 | CPU loop after each instruction */ |
| 326 | void cpu_single_step(CPUState *cpu, int enabled) |
| 327 | { |
| 328 | if (cpu->singlestep_enabled != enabled) { |
| 329 | cpu->singlestep_enabled = enabled; |
Mads Ynddal | 412ae12 | 2023-03-02 18:58:05 -0800 | [diff] [blame] | 330 | |
| 331 | #if !defined(CONFIG_USER_ONLY) |
| 332 | const AccelOpsClass *ops = cpus_get_accel(); |
| 333 | if (ops->update_guest_debug) { |
| 334 | ops->update_guest_debug(cpu); |
Paolo Bonzini | d9f24bf | 2020-10-06 09:05:29 +0200 | [diff] [blame] | 335 | } |
Mads Ynddal | 412ae12 | 2023-03-02 18:58:05 -0800 | [diff] [blame] | 336 | #endif |
| 337 | |
Richard Henderson | ad1a706 | 2021-07-01 08:10:53 -0700 | [diff] [blame] | 338 | trace_breakpoint_singlestep(cpu->cpu_index, enabled); |
Paolo Bonzini | d9f24bf | 2020-10-06 09:05:29 +0200 | [diff] [blame] | 339 | } |
| 340 | } |
| 341 | |
| 342 | void cpu_abort(CPUState *cpu, const char *fmt, ...) |
| 343 | { |
| 344 | va_list ap; |
| 345 | va_list ap2; |
| 346 | |
| 347 | va_start(ap, fmt); |
| 348 | va_copy(ap2, ap); |
| 349 | fprintf(stderr, "qemu: fatal: "); |
| 350 | vfprintf(stderr, fmt, ap); |
| 351 | fprintf(stderr, "\n"); |
| 352 | cpu_dump_state(cpu, stderr, CPU_DUMP_FPU | CPU_DUMP_CCOP); |
| 353 | if (qemu_log_separate()) { |
Richard Henderson | c60f599 | 2022-04-17 11:29:47 -0700 | [diff] [blame] | 354 | FILE *logfile = qemu_log_trylock(); |
Richard Henderson | 78b5485 | 2022-04-17 11:29:49 -0700 | [diff] [blame] | 355 | if (logfile) { |
| 356 | fprintf(logfile, "qemu: fatal: "); |
| 357 | vfprintf(logfile, fmt, ap2); |
| 358 | fprintf(logfile, "\n"); |
| 359 | cpu_dump_state(cpu, logfile, CPU_DUMP_FPU | CPU_DUMP_CCOP); |
Richard Henderson | 78b5485 | 2022-04-17 11:29:49 -0700 | [diff] [blame] | 360 | qemu_log_unlock(logfile); |
| 361 | } |
Paolo Bonzini | d9f24bf | 2020-10-06 09:05:29 +0200 | [diff] [blame] | 362 | } |
| 363 | va_end(ap2); |
| 364 | va_end(ap); |
| 365 | replay_finish(); |
| 366 | #if defined(CONFIG_USER_ONLY) |
| 367 | { |
| 368 | struct sigaction act; |
| 369 | sigfillset(&act.sa_mask); |
| 370 | act.sa_handler = SIG_DFL; |
| 371 | act.sa_flags = 0; |
| 372 | sigaction(SIGABRT, &act, NULL); |
| 373 | } |
| 374 | #endif |
| 375 | abort(); |
| 376 | } |
| 377 | |
| 378 | /* physical memory access (slow version, mainly for debug) */ |
| 379 | #if defined(CONFIG_USER_ONLY) |
Philippe Mathieu-Daudé | 73842ef | 2022-02-03 02:13:28 +0100 | [diff] [blame] | 380 | int cpu_memory_rw_debug(CPUState *cpu, vaddr addr, |
| 381 | void *ptr, size_t len, bool is_write) |
Paolo Bonzini | d9f24bf | 2020-10-06 09:05:29 +0200 | [diff] [blame] | 382 | { |
| 383 | int flags; |
Philippe Mathieu-Daudé | 73842ef | 2022-02-03 02:13:28 +0100 | [diff] [blame] | 384 | vaddr l, page; |
Paolo Bonzini | d9f24bf | 2020-10-06 09:05:29 +0200 | [diff] [blame] | 385 | void * p; |
| 386 | uint8_t *buf = ptr; |
| 387 | |
| 388 | while (len > 0) { |
| 389 | page = addr & TARGET_PAGE_MASK; |
| 390 | l = (page + TARGET_PAGE_SIZE) - addr; |
| 391 | if (l > len) |
| 392 | l = len; |
| 393 | flags = page_get_flags(page); |
| 394 | if (!(flags & PAGE_VALID)) |
| 395 | return -1; |
| 396 | if (is_write) { |
| 397 | if (!(flags & PAGE_WRITE)) |
| 398 | return -1; |
| 399 | /* XXX: this code should not depend on lock_user */ |
| 400 | if (!(p = lock_user(VERIFY_WRITE, addr, l, 0))) |
| 401 | return -1; |
| 402 | memcpy(p, buf, l); |
| 403 | unlock_user(p, addr, l); |
| 404 | } else { |
| 405 | if (!(flags & PAGE_READ)) |
| 406 | return -1; |
| 407 | /* XXX: this code should not depend on lock_user */ |
| 408 | if (!(p = lock_user(VERIFY_READ, addr, l, 1))) |
| 409 | return -1; |
| 410 | memcpy(buf, p, l); |
| 411 | unlock_user(p, addr, 0); |
| 412 | } |
| 413 | len -= l; |
| 414 | buf += l; |
| 415 | addr += l; |
| 416 | } |
| 417 | return 0; |
| 418 | } |
| 419 | #endif |
| 420 | |
| 421 | bool target_words_bigendian(void) |
| 422 | { |
Thomas Huth | ded625e | 2023-09-07 13:35:00 +0200 | [diff] [blame] | 423 | return TARGET_BIG_ENDIAN; |
Paolo Bonzini | d9f24bf | 2020-10-06 09:05:29 +0200 | [diff] [blame] | 424 | } |
| 425 | |
Thomas Huth | 1077f50 | 2023-04-24 18:04:33 +0200 | [diff] [blame] | 426 | const char *target_name(void) |
| 427 | { |
| 428 | return TARGET_NAME; |
| 429 | } |
| 430 | |
Paolo Bonzini | d9f24bf | 2020-10-06 09:05:29 +0200 | [diff] [blame] | 431 | void page_size_init(void) |
| 432 | { |
| 433 | /* NOTE: we can always suppose that qemu_host_page_size >= |
| 434 | TARGET_PAGE_SIZE */ |
| 435 | if (qemu_host_page_size == 0) { |
Marc-André Lureau | 8e3b0cb | 2022-03-23 19:57:22 +0400 | [diff] [blame] | 436 | qemu_host_page_size = qemu_real_host_page_size(); |
Paolo Bonzini | d9f24bf | 2020-10-06 09:05:29 +0200 | [diff] [blame] | 437 | } |
| 438 | if (qemu_host_page_size < TARGET_PAGE_SIZE) { |
| 439 | qemu_host_page_size = TARGET_PAGE_SIZE; |
| 440 | } |
| 441 | qemu_host_page_mask = -(intptr_t)qemu_host_page_size; |
| 442 | } |