?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
gtk: Fix accelerator filtering
[qemu-kvm.git] / exec.c
blobc8658c6f9d5b84a2320e02d091102b96d42cc2b0
1 /*
2 * Virtual page mapping
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 #include "config.h"
20 #ifdef _WIN32
21 #include <windows.h>
22 #else
23 #include <sys/types.h>
24 #include <sys/mman.h>
25 #endif
26
27 #include "qemu-common.h"
28 #include "cpu.h"
29 #include "tcg.h"
30 #include "hw/hw.h"
31 #include "hw/qdev.h"
32 #include "qemu/osdep.h"
33 #include "sysemu/kvm.h"
34 #include "sysemu/sysemu.h"
35 #include "hw/xen/xen.h"
36 #include "qemu/timer.h"
37 #include "qemu/config-file.h"
38 #include "exec/memory.h"
39 #include "sysemu/dma.h"
40 #include "exec/address-spaces.h"
41 #if defined(CONFIG_USER_ONLY)
42 #include <qemu.h>
43 #else /* !CONFIG_USER_ONLY */
44 #include "sysemu/xen-mapcache.h"
45 #include "trace.h"
46 #endif
47 #include "exec/cpu-all.h"
48
49 #include "exec/cputlb.h"
50 #include "translate-all.h"
51
52 #include "exec/memory-internal.h"
53
54 //#define DEBUG_SUBPAGE
55
56 #if !defined(CONFIG_USER_ONLY)
57 static int in_migration;
58
59 RAMList ram_list = { .blocks = QTAILQ_HEAD_INITIALIZER(ram_list.blocks) };
60
61 static MemoryRegion *system_memory;
62 static MemoryRegion *system_io;
63
64 AddressSpace address_space_io;
65 AddressSpace address_space_memory;
66
67 MemoryRegion io_mem_rom, io_mem_notdirty;
68 static MemoryRegion io_mem_unassigned;
69
70 #endif
71
72 CPUState *first_cpu;
73 /* current CPU in the current thread. It is only valid inside
74 cpu_exec() */
75 DEFINE_TLS(CPUState *, current_cpu);
76 /* 0 = Do not count executed instructions.
77 1 = Precise instruction counting.
78 2 = Adaptive rate instruction counting. */
79 int use_icount;
80
81 #if !defined(CONFIG_USER_ONLY)
82
83 typedef struct PhysPageEntry PhysPageEntry;
84
85 struct PhysPageEntry {
86 uint16_t is_leaf : 1;
87 /* index into phys_sections (is_leaf) or phys_map_nodes (!is_leaf) */
88 uint16_t ptr : 15;
89 };
90
91 typedef PhysPageEntry Node[L2_SIZE];
92
93 struct AddressSpaceDispatch {
94 /* This is a multi-level map on the physical address space.
95 * The bottom level has pointers to MemoryRegionSections.
96 */
97 PhysPageEntry phys_map;
98 Node *nodes;
99 MemoryRegionSection *sections;
100 AddressSpace *as;
101 };
102
103 #define SUBPAGE_IDX(addr) ((addr) & ~TARGET_PAGE_MASK)
104 typedef struct subpage_t {
105 MemoryRegion iomem;
106 AddressSpace *as;
107 hwaddr base;
108 uint16_t sub_section[TARGET_PAGE_SIZE];
109 } subpage_t;
110
111 #define PHYS_SECTION_UNASSIGNED 0
112 #define PHYS_SECTION_NOTDIRTY 1
113 #define PHYS_SECTION_ROM 2
114 #define PHYS_SECTION_WATCH 3
115
116 typedef struct PhysPageMap {
117 unsigned sections_nb;
118 unsigned sections_nb_alloc;
119 unsigned nodes_nb;
120 unsigned nodes_nb_alloc;
121 Node *nodes;
122 MemoryRegionSection *sections;
123 } PhysPageMap;
124
125 static PhysPageMap *prev_map;
126 static PhysPageMap next_map;
127
128 #define PHYS_MAP_NODE_NIL (((uint16_t)~0) >> 1)
129
130 static void io_mem_init(void);
131 static void memory_map_init(void);
132 static void *qemu_safe_ram_ptr(ram_addr_t addr);
133
134 static MemoryRegion io_mem_watch;
135 #endif
136
137 #if !defined(CONFIG_USER_ONLY)
138
139 static void phys_map_node_reserve(unsigned nodes)
140 {
141 if (next_map.nodes_nb + nodes > next_map.nodes_nb_alloc) {
142 next_map.nodes_nb_alloc = MAX(next_map.nodes_nb_alloc * 2,
143 16);
144 next_map.nodes_nb_alloc = MAX(next_map.nodes_nb_alloc,
145 next_map.nodes_nb + nodes);
146 next_map.nodes = g_renew(Node, next_map.nodes,
147 next_map.nodes_nb_alloc);
148 }
149 }
150
151 static uint16_t phys_map_node_alloc(void)
152 {
153 unsigned i;
154 uint16_t ret;
155
156 ret = next_map.nodes_nb++;
157 assert(ret != PHYS_MAP_NODE_NIL);
158 assert(ret != next_map.nodes_nb_alloc);
159 for (i = 0; i < L2_SIZE; ++i) {
160 next_map.nodes[ret][i].is_leaf = 0;
161 next_map.nodes[ret][i].ptr = PHYS_MAP_NODE_NIL;
162 }
163 return ret;
164 }
165
166 static void phys_page_set_level(PhysPageEntry *lp, hwaddr *index,
167 hwaddr *nb, uint16_t leaf,
168 int level)
169 {
170 PhysPageEntry *p;
171 int i;
172 hwaddr step = (hwaddr)1 << (level * L2_BITS);
173
174 if (!lp->is_leaf && lp->ptr == PHYS_MAP_NODE_NIL) {
175 lp->ptr = phys_map_node_alloc();
176 p = next_map.nodes[lp->ptr];
177 if (level == 0) {
178 for (i = 0; i < L2_SIZE; i++) {
179 p[i].is_leaf = 1;
180 p[i].ptr = PHYS_SECTION_UNASSIGNED;
181 }
182 }
183 } else {
184 p = next_map.nodes[lp->ptr];
185 }
186 lp = &p[(*index >> (level * L2_BITS)) & (L2_SIZE - 1)];
187
188 while (*nb && lp < &p[L2_SIZE]) {
189 if ((*index & (step - 1)) == 0 && *nb >= step) {
190 lp->is_leaf = true;
191 lp->ptr = leaf;
192 *index += step;
193 *nb -= step;
194 } else {
195 phys_page_set_level(lp, index, nb, leaf, level - 1);
196 }
197 ++lp;
198 }
199 }
200
201 static void phys_page_set(AddressSpaceDispatch *d,
202 hwaddr index, hwaddr nb,
203 uint16_t leaf)
204 {
205 /* Wildly overreserve - it doesn't matter much. */
206 phys_map_node_reserve(3 * P_L2_LEVELS);
207
208 phys_page_set_level(&d->phys_map, &index, &nb, leaf, P_L2_LEVELS - 1);
209 }
210
211 static MemoryRegionSection *phys_page_find(PhysPageEntry lp, hwaddr index,
212 Node *nodes, MemoryRegionSection *sections)
213 {
214 PhysPageEntry *p;
215 int i;
216
217 for (i = P_L2_LEVELS - 1; i >= 0 && !lp.is_leaf; i--) {
218 if (lp.ptr == PHYS_MAP_NODE_NIL) {
219 return &sections[PHYS_SECTION_UNASSIGNED];
220 }
221 p = nodes[lp.ptr];
222 lp = p[(index >> (i * L2_BITS)) & (L2_SIZE - 1)];
223 }
224 return &sections[lp.ptr];
225 }
226
227 bool memory_region_is_unassigned(MemoryRegion *mr)
228 {
229 return mr != &io_mem_rom && mr != &io_mem_notdirty && !mr->rom_device
230 && mr != &io_mem_watch;
231 }
232
233 static MemoryRegionSection *address_space_lookup_region(AddressSpaceDispatch *d,
234 hwaddr addr,
235 bool resolve_subpage)
236 {
237 MemoryRegionSection *section;
238 subpage_t *subpage;
239
240 section = phys_page_find(d->phys_map, addr >> TARGET_PAGE_BITS,
241 d->nodes, d->sections);
242 if (resolve_subpage && section->mr->subpage) {
243 subpage = container_of(section->mr, subpage_t, iomem);
244 section = &d->sections[subpage->sub_section[SUBPAGE_IDX(addr)]];
245 }
246 return section;
247 }
248
249 static MemoryRegionSection *
250 address_space_translate_internal(AddressSpaceDispatch *d, hwaddr addr, hwaddr *xlat,
251 hwaddr *plen, bool resolve_subpage)
252 {
253 MemoryRegionSection *section;
254 Int128 diff;
255
256 section = address_space_lookup_region(d, addr, resolve_subpage);
257 /* Compute offset within MemoryRegionSection */
258 addr -= section->offset_within_address_space;
259
260 /* Compute offset within MemoryRegion */
261 *xlat = addr + section->offset_within_region;
262
263 diff = int128_sub(section->mr->size, int128_make64(addr));
264 *plen = int128_get64(int128_min(diff, int128_make64(*plen)));
265 return section;
266 }
267
268 MemoryRegion *address_space_translate(AddressSpace *as, hwaddr addr,
269 hwaddr *xlat, hwaddr *plen,
270 bool is_write)
271 {
272 IOMMUTLBEntry iotlb;
273 MemoryRegionSection *section;
274 MemoryRegion *mr;
275 hwaddr len = *plen;
276
277 for (;;) {
278 section = address_space_translate_internal(as->dispatch, addr, &addr, plen, true);
279 mr = section->mr;
280
281 if (!mr->iommu_ops) {
282 break;
283 }
284
285 iotlb = mr->iommu_ops->translate(mr, addr);
286 addr = ((iotlb.translated_addr & ~iotlb.addr_mask)
287 | (addr & iotlb.addr_mask));
288 len = MIN(len, (addr | iotlb.addr_mask) - addr + 1);
289 if (!(iotlb.perm & (1 << is_write))) {
290 mr = &io_mem_unassigned;
291 break;
292 }
293
294 as = iotlb.target_as;
295 }
296
297 *plen = len;
298 *xlat = addr;
299 return mr;
300 }
301
302 MemoryRegionSection *
303 address_space_translate_for_iotlb(AddressSpace *as, hwaddr addr, hwaddr *xlat,
304 hwaddr *plen)
305 {
306 MemoryRegionSection *section;
307 section = address_space_translate_internal(as->dispatch, addr, xlat, plen, false);
308
309 assert(!section->mr->iommu_ops);
310 return section;
311 }
312 #endif
313
314 void cpu_exec_init_all(void)
315 {
316 #if !defined(CONFIG_USER_ONLY)
317 qemu_mutex_init(&ram_list.mutex);
318 memory_map_init();
319 io_mem_init();
320 #endif
321 }
322
323 #if !defined(CONFIG_USER_ONLY)
324
325 static int cpu_common_post_load(void *opaque, int version_id)
326 {
327 CPUState *cpu = opaque;
328
329 /* 0x01 was CPU_INTERRUPT_EXIT. This line can be removed when the
330 version_id is increased. */
331 cpu->interrupt_request &= ~0x01;
332 tlb_flush(cpu->env_ptr, 1);
333
334 return 0;
335 }
336
337 const VMStateDescription vmstate_cpu_common = {
338 .name = "cpu_common",
339 .version_id = 1,
340 .minimum_version_id = 1,
341 .minimum_version_id_old = 1,
342 .post_load = cpu_common_post_load,
343 .fields = (VMStateField []) {
344 VMSTATE_UINT32(halted, CPUState),
345 VMSTATE_UINT32(interrupt_request, CPUState),
346 VMSTATE_END_OF_LIST()
347 }
348 };
349
350 #endif
351
352 CPUState *qemu_get_cpu(int index)
353 {
354 CPUState *cpu = first_cpu;
355
356 while (cpu) {
357 if (cpu->cpu_index == index) {
358 break;
359 }
360 cpu = cpu->next_cpu;
361 }
362
363 return cpu;
364 }
365
366 void qemu_for_each_cpu(void (*func)(CPUState *cpu, void *data), void *data)
367 {
368 CPUState *cpu;
369
370 cpu = first_cpu;
371 while (cpu) {
372 func(cpu, data);
373 cpu = cpu->next_cpu;
374 }
375 }
376
377 void cpu_exec_init(CPUArchState *env)
378 {
379 CPUState *cpu = ENV_GET_CPU(env);
380 CPUClass *cc = CPU_GET_CLASS(cpu);
381 CPUState **pcpu;
382 int cpu_index;
383
384 #if defined(CONFIG_USER_ONLY)
385 cpu_list_lock();
386 #endif
387 cpu->next_cpu = NULL;
388 pcpu = &first_cpu;
389 cpu_index = 0;
390 while (*pcpu != NULL) {
391 pcpu = &(*pcpu)->next_cpu;
392 cpu_index++;
393 }
394 cpu->cpu_index = cpu_index;
395 cpu->numa_node = 0;
396 QTAILQ_INIT(&env->breakpoints);
397 QTAILQ_INIT(&env->watchpoints);
398 #ifndef CONFIG_USER_ONLY
399 cpu->thread_id = qemu_get_thread_id();
400 #endif
401 *pcpu = cpu;
402 #if defined(CONFIG_USER_ONLY)
403 cpu_list_unlock();
404 #endif
405 vmstate_register(NULL, cpu_index, &vmstate_cpu_common, cpu);
406 #if defined(CPU_SAVE_VERSION) && !defined(CONFIG_USER_ONLY)
407 register_savevm(NULL, "cpu", cpu_index, CPU_SAVE_VERSION,
408 cpu_save, cpu_load, env);
409 assert(cc->vmsd == NULL);
410 #endif
411 if (cc->vmsd != NULL) {
412 vmstate_register(NULL, cpu_index, cc->vmsd, cpu);
413 }
414 }
415
416 #if defined(TARGET_HAS_ICE)
417 #if defined(CONFIG_USER_ONLY)
418 static void breakpoint_invalidate(CPUArchState *env, target_ulong pc)
419 {
420 tb_invalidate_phys_page_range(pc, pc + 1, 0);
421 }
422 #else
423 static void breakpoint_invalidate(CPUArchState *env, target_ulong pc)
424 {
425 tb_invalidate_phys_addr(cpu_get_phys_page_debug(env, pc) |
426 (pc & ~TARGET_PAGE_MASK));
427 }
428 #endif
429 #endif /* TARGET_HAS_ICE */
430
431 #if defined(CONFIG_USER_ONLY)
432 void cpu_watchpoint_remove_all(CPUArchState *env, int mask)
433
434 {
435 }
436
437 int cpu_watchpoint_insert(CPUArchState *env, target_ulong addr, target_ulong len,
438 int flags, CPUWatchpoint **watchpoint)
439 {
440 return -ENOSYS;
441 }
442 #else
443 /* Add a watchpoint. */
444 int cpu_watchpoint_insert(CPUArchState *env, target_ulong addr, target_ulong len,
445 int flags, CPUWatchpoint **watchpoint)
446 {
447 target_ulong len_mask = ~(len - 1);
448 CPUWatchpoint *wp;
449
450 /* sanity checks: allow power-of-2 lengths, deny unaligned watchpoints */
451 if ((len & (len - 1)) || (addr & ~len_mask) ||
452 len == 0 || len > TARGET_PAGE_SIZE) {
453 fprintf(stderr, "qemu: tried to set invalid watchpoint at "
454 TARGET_FMT_lx ", len=" TARGET_FMT_lu "\n", addr, len);
455 return -EINVAL;
456 }
457 wp = g_malloc(sizeof(*wp));
458
459 wp->vaddr = addr;
460 wp->len_mask = len_mask;
461 wp->flags = flags;
462
463 /* keep all GDB-injected watchpoints in front */
464 if (flags & BP_GDB)
465 QTAILQ_INSERT_HEAD(&env->watchpoints, wp, entry);
466 else
467 QTAILQ_INSERT_TAIL(&env->watchpoints, wp, entry);
468
469 tlb_flush_page(env, addr);
470
471 if (watchpoint)
472 *watchpoint = wp;
473 return 0;
474 }
475
476 /* Remove a specific watchpoint. */
477 int cpu_watchpoint_remove(CPUArchState *env, target_ulong addr, target_ulong len,
478 int flags)
479 {
480 target_ulong len_mask = ~(len - 1);
481 CPUWatchpoint *wp;
482
483 QTAILQ_FOREACH(wp, &env->watchpoints, entry) {
484 if (addr == wp->vaddr && len_mask == wp->len_mask
485 && flags == (wp->flags & ~BP_WATCHPOINT_HIT)) {
486 cpu_watchpoint_remove_by_ref(env, wp);
487 return 0;
488 }
489 }
490 return -ENOENT;
491 }
492
493 /* Remove a specific watchpoint by reference. */
494 void cpu_watchpoint_remove_by_ref(CPUArchState *env, CPUWatchpoint *watchpoint)
495 {
496 QTAILQ_REMOVE(&env->watchpoints, watchpoint, entry);
497
498 tlb_flush_page(env, watchpoint->vaddr);
499
500 g_free(watchpoint);
501 }
502
503 /* Remove all matching watchpoints. */
504 void cpu_watchpoint_remove_all(CPUArchState *env, int mask)
505 {
506 CPUWatchpoint *wp, *next;
507
508 QTAILQ_FOREACH_SAFE(wp, &env->watchpoints, entry, next) {
509 if (wp->flags & mask)
510 cpu_watchpoint_remove_by_ref(env, wp);
511 }
512 }
513 #endif
514
515 /* Add a breakpoint. */
516 int cpu_breakpoint_insert(CPUArchState *env, target_ulong pc, int flags,
517 CPUBreakpoint **breakpoint)
518 {
519 #if defined(TARGET_HAS_ICE)
520 CPUBreakpoint *bp;
521
522 bp = g_malloc(sizeof(*bp));
523
524 bp->pc = pc;
525 bp->flags = flags;
526
527 /* keep all GDB-injected breakpoints in front */
528 if (flags & BP_GDB)
529 QTAILQ_INSERT_HEAD(&env->breakpoints, bp, entry);
530 else
531 QTAILQ_INSERT_TAIL(&env->breakpoints, bp, entry);
532
533 breakpoint_invalidate(env, pc);
534
535 if (breakpoint)
536 *breakpoint = bp;
537 return 0;
538 #else
539 return -ENOSYS;
540 #endif
541 }
542
543 /* Remove a specific breakpoint. */
544 int cpu_breakpoint_remove(CPUArchState *env, target_ulong pc, int flags)
545 {
546 #if defined(TARGET_HAS_ICE)
547 CPUBreakpoint *bp;
548
549 QTAILQ_FOREACH(bp, &env->breakpoints, entry) {
550 if (bp->pc == pc && bp->flags == flags) {
551 cpu_breakpoint_remove_by_ref(env, bp);
552 return 0;
553 }
554 }
555 return -ENOENT;
556 #else
557 return -ENOSYS;
558 #endif
559 }
560
561 /* Remove a specific breakpoint by reference. */
562 void cpu_breakpoint_remove_by_ref(CPUArchState *env, CPUBreakpoint *breakpoint)
563 {
564 #if defined(TARGET_HAS_ICE)
565 QTAILQ_REMOVE(&env->breakpoints, breakpoint, entry);
566
567 breakpoint_invalidate(env, breakpoint->pc);
568
569 g_free(breakpoint);
570 #endif
571 }
572
573 /* Remove all matching breakpoints. */
574 void cpu_breakpoint_remove_all(CPUArchState *env, int mask)
575 {
576 #if defined(TARGET_HAS_ICE)
577 CPUBreakpoint *bp, *next;
578
579 QTAILQ_FOREACH_SAFE(bp, &env->breakpoints, entry, next) {
580 if (bp->flags & mask)
581 cpu_breakpoint_remove_by_ref(env, bp);
582 }
583 #endif
584 }
585
586 /* enable or disable single step mode. EXCP_DEBUG is returned by the
587 CPU loop after each instruction */
588 void cpu_single_step(CPUArchState *env, int enabled)
589 {
590 #if defined(TARGET_HAS_ICE)
591 if (env->singlestep_enabled != enabled) {
592 env->singlestep_enabled = enabled;
593 if (kvm_enabled())
594 kvm_update_guest_debug(env, 0);
595 else {
596 /* must flush all the translated code to avoid inconsistencies */
597 /* XXX: only flush what is necessary */
598 tb_flush(env);
599 }
600 }
601 #endif
602 }
603
604 void cpu_abort(CPUArchState *env, const char *fmt, ...)
605 {
606 CPUState *cpu = ENV_GET_CPU(env);
607 va_list ap;
608 va_list ap2;
609
610 va_start(ap, fmt);
611 va_copy(ap2, ap);
612 fprintf(stderr, "qemu: fatal: ");
613 vfprintf(stderr, fmt, ap);
614 fprintf(stderr, "\n");
615 cpu_dump_state(cpu, stderr, fprintf, CPU_DUMP_FPU | CPU_DUMP_CCOP);
616 if (qemu_log_enabled()) {
617 qemu_log("qemu: fatal: ");
618 qemu_log_vprintf(fmt, ap2);
619 qemu_log("\n");
620 log_cpu_state(cpu, CPU_DUMP_FPU | CPU_DUMP_CCOP);
621 qemu_log_flush();
622 qemu_log_close();
623 }
624 va_end(ap2);
625 va_end(ap);
626 #if defined(CONFIG_USER_ONLY)
627 {
628 struct sigaction act;
629 sigfillset(&act.sa_mask);
630 act.sa_handler = SIG_DFL;
631 sigaction(SIGABRT, &act, NULL);
632 }
633 #endif
634 abort();
635 }
636
637 CPUArchState *cpu_copy(CPUArchState *env)
638 {
639 CPUArchState *new_env = cpu_init(env->cpu_model_str);
640 #if defined(TARGET_HAS_ICE)
641 CPUBreakpoint *bp;
642 CPUWatchpoint *wp;
643 #endif
644
645 memcpy(new_env, env, sizeof(CPUArchState));
646
647 /* Clone all break/watchpoints.
648 Note: Once we support ptrace with hw-debug register access, make sure
649 BP_CPU break/watchpoints are handled correctly on clone. */
650 QTAILQ_INIT(&env->breakpoints);
651 QTAILQ_INIT(&env->watchpoints);
652 #if defined(TARGET_HAS_ICE)
653 QTAILQ_FOREACH(bp, &env->breakpoints, entry) {
654 cpu_breakpoint_insert(new_env, bp->pc, bp->flags, NULL);
655 }
656 QTAILQ_FOREACH(wp, &env->watchpoints, entry) {
657 cpu_watchpoint_insert(new_env, wp->vaddr, (~wp->len_mask) + 1,
658 wp->flags, NULL);
659 }
660 #endif
661
662 return new_env;
663 }
664
665 #if !defined(CONFIG_USER_ONLY)
666 static void tlb_reset_dirty_range_all(ram_addr_t start, ram_addr_t end,
667 uintptr_t length)
668 {
669 uintptr_t start1;
670
671 /* we modify the TLB cache so that the dirty bit will be set again
672 when accessing the range */
673 start1 = (uintptr_t)qemu_safe_ram_ptr(start);
674 /* Check that we don't span multiple blocks - this breaks the
675 address comparisons below. */
676 if ((uintptr_t)qemu_safe_ram_ptr(end - 1) - start1
677 != (end - 1) - start) {
678 abort();
679 }
680 cpu_tlb_reset_dirty_all(start1, length);
681
682 }
683
684 /* Note: start and end must be within the same ram block. */
685 void cpu_physical_memory_reset_dirty(ram_addr_t start, ram_addr_t end,
686 int dirty_flags)
687 {
688 uintptr_t length;
689
690 start &= TARGET_PAGE_MASK;
691 end = TARGET_PAGE_ALIGN(end);
692
693 length = end - start;
694 if (length == 0)
695 return;
696 cpu_physical_memory_mask_dirty_range(start, length, dirty_flags);
697
698 if (tcg_enabled()) {
699 tlb_reset_dirty_range_all(start, end, length);
700 }
701 }
702
703 static int cpu_physical_memory_set_dirty_tracking(int enable)
704 {
705 int ret = 0;
706 in_migration = enable;
707 return ret;
708 }
709
710 hwaddr memory_region_section_get_iotlb(CPUArchState *env,
711 MemoryRegionSection *section,
712 target_ulong vaddr,
713 hwaddr paddr, hwaddr xlat,
714 int prot,
715 target_ulong *address)
716 {
717 hwaddr iotlb;
718 CPUWatchpoint *wp;
719
720 if (memory_region_is_ram(section->mr)) {
721 /* Normal RAM. */
722 iotlb = (memory_region_get_ram_addr(section->mr) & TARGET_PAGE_MASK)
723 + xlat;
724 if (!section->readonly) {
725 iotlb |= PHYS_SECTION_NOTDIRTY;
726 } else {
727 iotlb |= PHYS_SECTION_ROM;
728 }
729 } else {
730 iotlb = section - address_space_memory.dispatch->sections;
731 iotlb += xlat;
732 }
733
734 /* Make accesses to pages with watchpoints go via the
735 watchpoint trap routines. */
736 QTAILQ_FOREACH(wp, &env->watchpoints, entry) {
737 if (vaddr == (wp->vaddr & TARGET_PAGE_MASK)) {
738 /* Avoid trapping reads of pages with a write breakpoint. */
739 if ((prot & PAGE_WRITE) || (wp->flags & BP_MEM_READ)) {
740 iotlb = PHYS_SECTION_WATCH + paddr;
741 *address |= TLB_MMIO;
742 break;
743 }
744 }
745 }
746
747 return iotlb;
748 }
749 #endif /* defined(CONFIG_USER_ONLY) */
750
751 #if !defined(CONFIG_USER_ONLY)
752
753 static int subpage_register (subpage_t *mmio, uint32_t start, uint32_t end,
754 uint16_t section);
755 static subpage_t *subpage_init(AddressSpace *as, hwaddr base);
756
757 static uint16_t phys_section_add(MemoryRegionSection *section)
758 {
759 /* The physical section number is ORed with a page-aligned
760 * pointer to produce the iotlb entries. Thus it should
761 * never overflow into the page-aligned value.
762 */
763 assert(next_map.sections_nb < TARGET_PAGE_SIZE);
764
765 if (next_map.sections_nb == next_map.sections_nb_alloc) {
766 next_map.sections_nb_alloc = MAX(next_map.sections_nb_alloc * 2,
767 16);
768 next_map.sections = g_renew(MemoryRegionSection, next_map.sections,
769 next_map.sections_nb_alloc);
770 }
771 next_map.sections[next_map.sections_nb] = *section;
772 memory_region_ref(section->mr);
773 return next_map.sections_nb++;
774 }
775
776 static void phys_section_destroy(MemoryRegion *mr)
777 {
778 memory_region_unref(mr);
779
780 if (mr->subpage) {
781 subpage_t *subpage = container_of(mr, subpage_t, iomem);
782 memory_region_destroy(&subpage->iomem);
783 g_free(subpage);
784 }
785 }
786
787 static void phys_sections_free(PhysPageMap *map)
788 {
789 while (map->sections_nb > 0) {
790 MemoryRegionSection *section = &map->sections[--map->sections_nb];
791 phys_section_destroy(section->mr);
792 }
793 g_free(map->sections);
794 g_free(map->nodes);
795 g_free(map);
796 }
797
798 static void register_subpage(AddressSpaceDispatch *d, MemoryRegionSection *section)
799 {
800 subpage_t *subpage;
801 hwaddr base = section->offset_within_address_space
802 & TARGET_PAGE_MASK;
803 MemoryRegionSection *existing = phys_page_find(d->phys_map, base >> TARGET_PAGE_BITS,
804 next_map.nodes, next_map.sections);
805 MemoryRegionSection subsection = {
806 .offset_within_address_space = base,
807 .size = int128_make64(TARGET_PAGE_SIZE),
808 };
809 hwaddr start, end;
810
811 assert(existing->mr->subpage || existing->mr == &io_mem_unassigned);
812
813 if (!(existing->mr->subpage)) {
814 subpage = subpage_init(d->as, base);
815 subsection.mr = &subpage->iomem;
816 phys_page_set(d, base >> TARGET_PAGE_BITS, 1,
817 phys_section_add(&subsection));
818 } else {
819 subpage = container_of(existing->mr, subpage_t, iomem);
820 }
821 start = section->offset_within_address_space & ~TARGET_PAGE_MASK;
822 end = start + int128_get64(section->size) - 1;
823 subpage_register(subpage, start, end, phys_section_add(section));
824 }
825
826
827 static void register_multipage(AddressSpaceDispatch *d,
828 MemoryRegionSection *section)
829 {
830 hwaddr start_addr = section->offset_within_address_space;
831 uint16_t section_index = phys_section_add(section);
832 uint64_t num_pages = int128_get64(int128_rshift(section->size,
833 TARGET_PAGE_BITS));
834
835 assert(num_pages);
836 phys_page_set(d, start_addr >> TARGET_PAGE_BITS, num_pages, section_index);
837 }
838
839 static void mem_add(MemoryListener *listener, MemoryRegionSection *section)
840 {
841 AddressSpace *as = container_of(listener, AddressSpace, dispatch_listener);
842 AddressSpaceDispatch *d = as->next_dispatch;
843 MemoryRegionSection now = *section, remain = *section;
844 Int128 page_size = int128_make64(TARGET_PAGE_SIZE);
845
846 if (now.offset_within_address_space & ~TARGET_PAGE_MASK) {
847 uint64_t left = TARGET_PAGE_ALIGN(now.offset_within_address_space)
848 - now.offset_within_address_space;
849
850 now.size = int128_min(int128_make64(left), now.size);
851 register_subpage(d, &now);
852 } else {
853 now.size = int128_zero();
854 }
855 while (int128_ne(remain.size, now.size)) {
856 remain.size = int128_sub(remain.size, now.size);
857 remain.offset_within_address_space += int128_get64(now.size);
858 remain.offset_within_region += int128_get64(now.size);
859 now = remain;
860 if (int128_lt(remain.size, page_size)) {
861 register_subpage(d, &now);
862 } else if (remain.offset_within_region & ~TARGET_PAGE_MASK) {
863 now.size = page_size;
864 register_subpage(d, &now);
865 } else {
866 now.size = int128_and(now.size, int128_neg(page_size));
867 register_multipage(d, &now);
868 }
869 }
870 }
871
872 void qemu_flush_coalesced_mmio_buffer(void)
873 {
874 if (kvm_enabled())
875 kvm_flush_coalesced_mmio_buffer();
876 }
877
878 void qemu_mutex_lock_ramlist(void)
879 {
880 qemu_mutex_lock(&ram_list.mutex);
881 }
882
883 void qemu_mutex_unlock_ramlist(void)
884 {
885 qemu_mutex_unlock(&ram_list.mutex);
886 }
887
888 #if defined(__linux__) && !defined(TARGET_S390X)
889
890 #include <sys/vfs.h>
891
892 #define HUGETLBFS_MAGIC 0x958458f6
893
894 static long gethugepagesize(const char *path)
895 {
896 struct statfs fs;
897 int ret;
898
899 do {
900 ret = statfs(path, &fs);
901 } while (ret != 0 && errno == EINTR);
902
903 if (ret != 0) {
904 perror(path);
905 return 0;
906 }
907
908 if (fs.f_type != HUGETLBFS_MAGIC)
909 fprintf(stderr, "Warning: path not on HugeTLBFS: %s\n", path);
910
911 return fs.f_bsize;
912 }
913
914 static void *file_ram_alloc(RAMBlock *block,
915 ram_addr_t memory,
916 const char *path)
917 {
918 char *filename;
919 char *sanitized_name;
920 char *c;
921 void *area;
922 int fd;
923 #ifdef MAP_POPULATE
924 int flags;
925 #endif
926 unsigned long hpagesize;
927
928 hpagesize = gethugepagesize(path);
929 if (!hpagesize) {
930 return NULL;
931 }
932
933 if (memory < hpagesize) {
934 return NULL;
935 }
936
937 if (kvm_enabled() && !kvm_has_sync_mmu()) {
938 fprintf(stderr, "host lacks kvm mmu notifiers, -mem-path unsupported\n");
939 return NULL;
940 }
941
942 /* Make name safe to use with mkstemp by replacing '/' with '_'. */
943 sanitized_name = g_strdup(block->mr->name);
944 for (c = sanitized_name; *c != '\0'; c++) {
945 if (*c == '/')
946 *c = '_';
947 }
948
949 filename = g_strdup_printf("%s/qemu_back_mem.%s.XXXXXX", path,
950 sanitized_name);
951 g_free(sanitized_name);
952
953 fd = mkstemp(filename);
954 if (fd < 0) {
955 perror("unable to create backing store for hugepages");
956 g_free(filename);
957 return NULL;
958 }
959 unlink(filename);
960 g_free(filename);
961
962 memory = (memory+hpagesize-1) & ~(hpagesize-1);
963
964 /*
965 * ftruncate is not supported by hugetlbfs in older
966 * hosts, so don't bother bailing out on errors.
967 * If anything goes wrong with it under other filesystems,
968 * mmap will fail.
969 */
970 if (ftruncate(fd, memory))
971 perror("ftruncate");
972
973 #ifdef MAP_POPULATE
974 /* NB: MAP_POPULATE won't exhaustively alloc all phys pages in the case
975 * MAP_PRIVATE is requested. For mem_prealloc we mmap as MAP_SHARED
976 * to sidestep this quirk.
977 */
978 flags = mem_prealloc ? MAP_POPULATE | MAP_SHARED : MAP_PRIVATE;
979 area = mmap(0, memory, PROT_READ | PROT_WRITE, flags, fd, 0);
980 #else
981 area = mmap(0, memory, PROT_READ | PROT_WRITE, MAP_PRIVATE, fd, 0);
982 #endif
983 if (area == MAP_FAILED) {
984 perror("file_ram_alloc: can't mmap RAM pages");
985 close(fd);
986 return (NULL);
987 }
988 block->fd = fd;
989 return area;
990 }
991 #endif
992
993 static ram_addr_t find_ram_offset(ram_addr_t size)
994 {
995 RAMBlock *block, *next_block;
996 ram_addr_t offset = RAM_ADDR_MAX, mingap = RAM_ADDR_MAX;
997
998 assert(size != 0); /* it would hand out same offset multiple times */
999
1000 if (QTAILQ_EMPTY(&ram_list.blocks))
1001 return 0;
1002
1003 QTAILQ_FOREACH(block, &ram_list.blocks, next) {
1004 ram_addr_t end, next = RAM_ADDR_MAX;
1005
1006 end = block->offset + block->length;
1007
1008 QTAILQ_FOREACH(next_block, &ram_list.blocks, next) {
1009 if (next_block->offset >= end) {
1010 next = MIN(next, next_block->offset);
1011 }
1012 }
1013 if (next - end >= size && next - end < mingap) {
1014 offset = end;
1015 mingap = next - end;
1016 }
1017 }
1018
1019 if (offset == RAM_ADDR_MAX) {
1020 fprintf(stderr, "Failed to find gap of requested size: %" PRIu64 "\n",
1021 (uint64_t)size);
1022 abort();
1023 }
1024
1025 return offset;
1026 }
1027
1028 ram_addr_t last_ram_offset(void)
1029 {
1030 RAMBlock *block;
1031 ram_addr_t last = 0;
1032
1033 QTAILQ_FOREACH(block, &ram_list.blocks, next)
1034 last = MAX(last, block->offset + block->length);
1035
1036 return last;
1037 }
1038
1039 static void qemu_ram_setup_dump(void *addr, ram_addr_t size)
1040 {
1041 int ret;
1042
1043 /* Use MADV_DONTDUMP, if user doesn't want the guest memory in the core */
1044 if (!qemu_opt_get_bool(qemu_get_machine_opts(),
1045 "dump-guest-core", true)) {
1046 ret = qemu_madvise(addr, size, QEMU_MADV_DONTDUMP);
1047 if (ret) {
1048 perror("qemu_madvise");
1049 fprintf(stderr, "madvise doesn't support MADV_DONTDUMP, "
1050 "but dump_guest_core=off specified\n");
1051 }
1052 }
1053 }
1054
1055 void qemu_ram_set_idstr(ram_addr_t addr, const char *name, DeviceState *dev)
1056 {
1057 RAMBlock *new_block, *block;
1058
1059 new_block = NULL;
1060 QTAILQ_FOREACH(block, &ram_list.blocks, next) {
1061 if (block->offset == addr) {
1062 new_block = block;
1063 break;
1064 }
1065 }
1066 assert(new_block);
1067 assert(!new_block->idstr[0]);
1068
1069 if (dev) {
1070 char *id = qdev_get_dev_path(dev);
1071 if (id) {
1072 snprintf(new_block->idstr, sizeof(new_block->idstr), "%s/", id);
1073 g_free(id);
1074 }
1075 }
1076 pstrcat(new_block->idstr, sizeof(new_block->idstr), name);
1077
1078 /* This assumes the iothread lock is taken here too. */
1079 qemu_mutex_lock_ramlist();
1080 QTAILQ_FOREACH(block, &ram_list.blocks, next) {
1081 if (block != new_block && !strcmp(block->idstr, new_block->idstr)) {
1082 fprintf(stderr, "RAMBlock \"%s\" already registered, abort!\n",
1083 new_block->idstr);
1084 abort();
1085 }
1086 }
1087 qemu_mutex_unlock_ramlist();
1088 }
1089
1090 static int memory_try_enable_merging(void *addr, size_t len)
1091 {
1092 if (!qemu_opt_get_bool(qemu_get_machine_opts(), "mem-merge", true)) {
1093 /* disabled by the user */
1094 return 0;
1095 }
1096
1097 return qemu_madvise(addr, len, QEMU_MADV_MERGEABLE);
1098 }
1099
1100 ram_addr_t qemu_ram_alloc_from_ptr(ram_addr_t size, void *host,
1101 MemoryRegion *mr)
1102 {
1103 RAMBlock *block, *new_block;
1104
1105 size = TARGET_PAGE_ALIGN(size);
1106 new_block = g_malloc0(sizeof(*new_block));
1107
1108 /* This assumes the iothread lock is taken here too. */
1109 qemu_mutex_lock_ramlist();
1110 new_block->mr = mr;
1111 new_block->offset = find_ram_offset(size);
1112 if (host) {
1113 new_block->host = host;
1114 new_block->flags |= RAM_PREALLOC_MASK;
1115 } else {
1116 if (mem_path) {
1117 #if defined (__linux__) && !defined(TARGET_S390X)
1118 new_block->host = file_ram_alloc(new_block, size, mem_path);
1119 if (!new_block->host) {
1120 new_block->host = qemu_anon_ram_alloc(size);
1121 memory_try_enable_merging(new_block->host, size);
1122 }
1123 #else
1124 fprintf(stderr, "-mem-path option unsupported\n");
1125 exit(1);
1126 #endif
1127 } else {
1128 if (xen_enabled()) {
1129 xen_ram_alloc(new_block->offset, size, mr);
1130 } else if (kvm_enabled()) {
1131 /* some s390/kvm configurations have special constraints */
1132 new_block->host = kvm_ram_alloc(size);
1133 } else {
1134 new_block->host = qemu_anon_ram_alloc(size);
1135 }
1136 memory_try_enable_merging(new_block->host, size);
1137 }
1138 }
1139 new_block->length = size;
1140
1141 /* Keep the list sorted from biggest to smallest block. */
1142 QTAILQ_FOREACH(block, &ram_list.blocks, next) {
1143 if (block->length < new_block->length) {
1144 break;
1145 }
1146 }
1147 if (block) {
1148 QTAILQ_INSERT_BEFORE(block, new_block, next);
1149 } else {
1150 QTAILQ_INSERT_TAIL(&ram_list.blocks, new_block, next);
1151 }
1152 ram_list.mru_block = NULL;
1153
1154 ram_list.version++;
1155 qemu_mutex_unlock_ramlist();
1156
1157 ram_list.phys_dirty = g_realloc(ram_list.phys_dirty,
1158 last_ram_offset() >> TARGET_PAGE_BITS);
1159 memset(ram_list.phys_dirty + (new_block->offset >> TARGET_PAGE_BITS),
1160 0, size >> TARGET_PAGE_BITS);
1161 cpu_physical_memory_set_dirty_range(new_block->offset, size, 0xff);
1162
1163 qemu_ram_setup_dump(new_block->host, size);
1164 qemu_madvise(new_block->host, size, QEMU_MADV_HUGEPAGE);
1165
1166 if (kvm_enabled())
1167 kvm_setup_guest_memory(new_block->host, size);
1168
1169 return new_block->offset;
1170 }
1171
1172 ram_addr_t qemu_ram_alloc(ram_addr_t size, MemoryRegion *mr)
1173 {
1174 return qemu_ram_alloc_from_ptr(size, NULL, mr);
1175 }
1176
1177 void qemu_ram_free_from_ptr(ram_addr_t addr)
1178 {
1179 RAMBlock *block;
1180
1181 /* This assumes the iothread lock is taken here too. */
1182 qemu_mutex_lock_ramlist();
1183 QTAILQ_FOREACH(block, &ram_list.blocks, next) {
1184 if (addr == block->offset) {
1185 QTAILQ_REMOVE(&ram_list.blocks, block, next);
1186 ram_list.mru_block = NULL;
1187 ram_list.version++;
1188 g_free(block);
1189 break;
1190 }
1191 }
1192 qemu_mutex_unlock_ramlist();
1193 }
1194
1195 void qemu_ram_free(ram_addr_t addr)
1196 {
1197 RAMBlock *block;
1198
1199 /* This assumes the iothread lock is taken here too. */
1200 qemu_mutex_lock_ramlist();
1201 QTAILQ_FOREACH(block, &ram_list.blocks, next) {
1202 if (addr == block->offset) {
1203 QTAILQ_REMOVE(&ram_list.blocks, block, next);
1204 ram_list.mru_block = NULL;
1205 ram_list.version++;
1206 if (block->flags & RAM_PREALLOC_MASK) {
1207 ;
1208 } else if (mem_path) {
1209 #if defined (__linux__) && !defined(TARGET_S390X)
1210 if (block->fd) {
1211 munmap(block->host, block->length);
1212 close(block->fd);
1213 } else {
1214 qemu_anon_ram_free(block->host, block->length);
1215 }
1216 #else
1217 abort();
1218 #endif
1219 } else {
1220 if (xen_enabled()) {
1221 xen_invalidate_map_cache_entry(block->host);
1222 } else {
1223 qemu_anon_ram_free(block->host, block->length);
1224 }
1225 }
1226 g_free(block);
1227 break;
1228 }
1229 }
1230 qemu_mutex_unlock_ramlist();
1231
1232 }
1233
1234 #ifndef _WIN32
1235 void qemu_ram_remap(ram_addr_t addr, ram_addr_t length)
1236 {
1237 RAMBlock *block;
1238 ram_addr_t offset;
1239 int flags;
1240 void *area, *vaddr;
1241
1242 QTAILQ_FOREACH(block, &ram_list.blocks, next) {
1243 offset = addr - block->offset;
1244 if (offset < block->length) {
1245 vaddr = block->host + offset;
1246 if (block->flags & RAM_PREALLOC_MASK) {
1247 ;
1248 } else {
1249 flags = MAP_FIXED;
1250 munmap(vaddr, length);
1251 if (mem_path) {
1252 #if defined(__linux__) && !defined(TARGET_S390X)
1253 if (block->fd) {
1254 #ifdef MAP_POPULATE
1255 flags |= mem_prealloc ? MAP_POPULATE | MAP_SHARED :
1256 MAP_PRIVATE;
1257 #else
1258 flags |= MAP_PRIVATE;
1259 #endif
1260 area = mmap(vaddr, length, PROT_READ | PROT_WRITE,
1261 flags, block->fd, offset);
1262 } else {
1263 flags |= MAP_PRIVATE | MAP_ANONYMOUS;
1264 area = mmap(vaddr, length, PROT_READ | PROT_WRITE,
1265 flags, -1, 0);
1266 }
1267 #else
1268 abort();
1269 #endif
1270 } else {
1271 #if defined(TARGET_S390X) && defined(CONFIG_KVM)
1272 flags |= MAP_SHARED | MAP_ANONYMOUS;
1273 area = mmap(vaddr, length, PROT_EXEC|PROT_READ|PROT_WRITE,
1274 flags, -1, 0);
1275 #else
1276 flags |= MAP_PRIVATE | MAP_ANONYMOUS;
1277 area = mmap(vaddr, length, PROT_READ | PROT_WRITE,
1278 flags, -1, 0);
1279 #endif
1280 }
1281 if (area != vaddr) {
1282 fprintf(stderr, "Could not remap addr: "
1283 RAM_ADDR_FMT "@" RAM_ADDR_FMT "\n",
1284 length, addr);
1285 exit(1);
1286 }
1287 memory_try_enable_merging(vaddr, length);
1288 qemu_ram_setup_dump(vaddr, length);
1289 }
1290 return;
1291 }
1292 }
1293 }
1294 #endif /* !_WIN32 */
1295
1296 static RAMBlock *qemu_get_ram_block(ram_addr_t addr)
1297 {
1298 RAMBlock *block;
1299
1300 /* The list is protected by the iothread lock here. */
1301 block = ram_list.mru_block;
1302 if (block && addr - block->offset < block->length) {
1303 goto found;
1304 }
1305 QTAILQ_FOREACH(block, &ram_list.blocks, next) {
1306 if (addr - block->offset < block->length) {
1307 goto found;
1308 }
1309 }
1310
1311 fprintf(stderr, "Bad ram offset %" PRIx64 "\n", (uint64_t)addr);
1312 abort();
1313
1314 found:
1315 ram_list.mru_block = block;
1316 return block;
1317 }
1318
1319 /* Return a host pointer to ram allocated with qemu_ram_alloc.
1320 With the exception of the softmmu code in this file, this should
1321 only be used for local memory (e.g. video ram) that the device owns,
1322 and knows it isn't going to access beyond the end of the block.
1323
1324 It should not be used for general purpose DMA.
1325 Use cpu_physical_memory_map/cpu_physical_memory_rw instead.
1326 */
1327 void *qemu_get_ram_ptr(ram_addr_t addr)
1328 {
1329 RAMBlock *block = qemu_get_ram_block(addr);
1330
1331 if (xen_enabled()) {
1332 /* We need to check if the requested address is in the RAM
1333 * because we don't want to map the entire memory in QEMU.
1334 * In that case just map until the end of the page.
1335 */
1336 if (block->offset == 0) {
1337 return xen_map_cache(addr, 0, 0);
1338 } else if (block->host == NULL) {
1339 block->host =
1340 xen_map_cache(block->offset, block->length, 1);
1341 }
1342 }
1343 return block->host + (addr - block->offset);
1344 }
1345
1346 /* Return a host pointer to ram allocated with qemu_ram_alloc. Same as
1347 * qemu_get_ram_ptr but do not touch ram_list.mru_block.
1348 *
1349 * ??? Is this still necessary?
1350 */
1351 static void *qemu_safe_ram_ptr(ram_addr_t addr)
1352 {
1353 RAMBlock *block;
1354
1355 /* The list is protected by the iothread lock here. */
1356 QTAILQ_FOREACH(block, &ram_list.blocks, next) {
1357 if (addr - block->offset < block->length) {
1358 if (xen_enabled()) {
1359 /* We need to check if the requested address is in the RAM
1360 * because we don't want to map the entire memory in QEMU.
1361 * In that case just map until the end of the page.
1362 */
1363 if (block->offset == 0) {
1364 return xen_map_cache(addr, 0, 0);
1365 } else if (block->host == NULL) {
1366 block->host =
1367 xen_map_cache(block->offset, block->length, 1);
1368 }
1369 }
1370 return block->host + (addr - block->offset);
1371 }
1372 }
1373
1374 fprintf(stderr, "Bad ram offset %" PRIx64 "\n", (uint64_t)addr);
1375 abort();
1376
1377 return NULL;
1378 }
1379
1380 /* Return a host pointer to guest's ram. Similar to qemu_get_ram_ptr
1381 * but takes a size argument */
1382 static void *qemu_ram_ptr_length(ram_addr_t addr, hwaddr *size)
1383 {
1384 if (*size == 0) {
1385 return NULL;
1386 }
1387 if (xen_enabled()) {
1388 return xen_map_cache(addr, *size, 1);
1389 } else {
1390 RAMBlock *block;
1391
1392 QTAILQ_FOREACH(block, &ram_list.blocks, next) {
1393 if (addr - block->offset < block->length) {
1394 if (addr - block->offset + *size > block->length)
1395 *size = block->length - addr + block->offset;
1396 return block->host + (addr - block->offset);
1397 }
1398 }
1399
1400 fprintf(stderr, "Bad ram offset %" PRIx64 "\n", (uint64_t)addr);
1401 abort();
1402 }
1403 }
1404
1405 /* Some of the softmmu routines need to translate from a host pointer
1406 (typically a TLB entry) back to a ram offset. */
1407 MemoryRegion *qemu_ram_addr_from_host(void *ptr, ram_addr_t *ram_addr)
1408 {
1409 RAMBlock *block;
1410 uint8_t *host = ptr;
1411
1412 if (xen_enabled()) {
1413 *ram_addr = xen_ram_addr_from_mapcache(ptr);
1414 return qemu_get_ram_block(*ram_addr)->mr;
1415 }
1416
1417 block = ram_list.mru_block;
1418 if (block && block->host && host - block->host < block->length) {
1419 goto found;
1420 }
1421
1422 QTAILQ_FOREACH(block, &ram_list.blocks, next) {
1423 /* This case append when the block is not mapped. */
1424 if (block->host == NULL) {
1425 continue;
1426 }
1427 if (host - block->host < block->length) {
1428 goto found;
1429 }
1430 }
1431
1432 return NULL;
1433
1434 found:
1435 *ram_addr = block->offset + (host - block->host);
1436 return block->mr;
1437 }
1438
1439 static void notdirty_mem_write(void *opaque, hwaddr ram_addr,
1440 uint64_t val, unsigned size)
1441 {
1442 int dirty_flags;
1443 dirty_flags = cpu_physical_memory_get_dirty_flags(ram_addr);
1444 if (!(dirty_flags & CODE_DIRTY_FLAG)) {
1445 tb_invalidate_phys_page_fast(ram_addr, size);
1446 dirty_flags = cpu_physical_memory_get_dirty_flags(ram_addr);
1447 }
1448 switch (size) {
1449 case 1:
1450 stb_p(qemu_get_ram_ptr(ram_addr), val);
1451 break;
1452 case 2:
1453 stw_p(qemu_get_ram_ptr(ram_addr), val);
1454 break;
1455 case 4:
1456 stl_p(qemu_get_ram_ptr(ram_addr), val);
1457 break;
1458 default:
1459 abort();
1460 }
1461 dirty_flags |= (0xff & ~CODE_DIRTY_FLAG);
1462 cpu_physical_memory_set_dirty_flags(ram_addr, dirty_flags);
1463 /* we remove the notdirty callback only if the code has been
1464 flushed */
1465 if (dirty_flags == 0xff) {
1466 CPUArchState *env = current_cpu->env_ptr;
1467 tlb_set_dirty(env, env->mem_io_vaddr);
1468 }
1469 }
1470
1471 static bool notdirty_mem_accepts(void *opaque, hwaddr addr,
1472 unsigned size, bool is_write)
1473 {
1474 return is_write;
1475 }
1476
1477 static const MemoryRegionOps notdirty_mem_ops = {
1478 .write = notdirty_mem_write,
1479 .valid.accepts = notdirty_mem_accepts,
1480 .endianness = DEVICE_NATIVE_ENDIAN,
1481 };
1482
1483 /* Generate a debug exception if a watchpoint has been hit. */
1484 static void check_watchpoint(int offset, int len_mask, int flags)
1485 {
1486 CPUArchState *env = current_cpu->env_ptr;
1487 target_ulong pc, cs_base;
1488 target_ulong vaddr;
1489 CPUWatchpoint *wp;
1490 int cpu_flags;
1491
1492 if (env->watchpoint_hit) {
1493 /* We re-entered the check after replacing the TB. Now raise
1494 * the debug interrupt so that is will trigger after the
1495 * current instruction. */
1496 cpu_interrupt(ENV_GET_CPU(env), CPU_INTERRUPT_DEBUG);
1497 return;
1498 }
1499 vaddr = (env->mem_io_vaddr & TARGET_PAGE_MASK) + offset;
1500 QTAILQ_FOREACH(wp, &env->watchpoints, entry) {
1501 if ((vaddr == (wp->vaddr & len_mask) ||
1502 (vaddr & wp->len_mask) == wp->vaddr) && (wp->flags & flags)) {
1503 wp->flags |= BP_WATCHPOINT_HIT;
1504 if (!env->watchpoint_hit) {
1505 env->watchpoint_hit = wp;
1506 tb_check_watchpoint(env);
1507 if (wp->flags & BP_STOP_BEFORE_ACCESS) {
1508 env->exception_index = EXCP_DEBUG;
1509 cpu_loop_exit(env);
1510 } else {
1511 cpu_get_tb_cpu_state(env, &pc, &cs_base, &cpu_flags);
1512 tb_gen_code(env, pc, cs_base, cpu_flags, 1);
1513 cpu_resume_from_signal(env, NULL);
1514 }
1515 }
1516 } else {
1517 wp->flags &= ~BP_WATCHPOINT_HIT;
1518 }
1519 }
1520 }
1521
1522 /* Watchpoint access routines. Watchpoints are inserted using TLB tricks,
1523 so these check for a hit then pass through to the normal out-of-line
1524 phys routines. */
1525 static uint64_t watch_mem_read(void *opaque, hwaddr addr,
1526 unsigned size)
1527 {
1528 check_watchpoint(addr & ~TARGET_PAGE_MASK, ~(size - 1), BP_MEM_READ);
1529 switch (size) {
1530 case 1: return ldub_phys(addr);
1531 case 2: return lduw_phys(addr);
1532 case 4: return ldl_phys(addr);
1533 default: abort();
1534 }
1535 }
1536
1537 static void watch_mem_write(void *opaque, hwaddr addr,
1538 uint64_t val, unsigned size)
1539 {
1540 check_watchpoint(addr & ~TARGET_PAGE_MASK, ~(size - 1), BP_MEM_WRITE);
1541 switch (size) {
1542 case 1:
1543 stb_phys(addr, val);
1544 break;
1545 case 2:
1546 stw_phys(addr, val);
1547 break;
1548 case 4:
1549 stl_phys(addr, val);
1550 break;
1551 default: abort();
1552 }
1553 }
1554
1555 static const MemoryRegionOps watch_mem_ops = {
1556 .read = watch_mem_read,
1557 .write = watch_mem_write,
1558 .endianness = DEVICE_NATIVE_ENDIAN,
1559 };
1560
1561 static uint64_t subpage_read(void *opaque, hwaddr addr,
1562 unsigned len)
1563 {
1564 subpage_t *subpage = opaque;
1565 uint8_t buf[4];
1566
1567 #if defined(DEBUG_SUBPAGE)
1568 printf("%s: subpage %p len %d addr " TARGET_FMT_plx "\n", __func__,
1569 subpage, len, addr);
1570 #endif
1571 address_space_read(subpage->as, addr + subpage->base, buf, len);
1572 switch (len) {
1573 case 1:
1574 return ldub_p(buf);
1575 case 2:
1576 return lduw_p(buf);
1577 case 4:
1578 return ldl_p(buf);
1579 default:
1580 abort();
1581 }
1582 }
1583
1584 static void subpage_write(void *opaque, hwaddr addr,
1585 uint64_t value, unsigned len)
1586 {
1587 subpage_t *subpage = opaque;
1588 uint8_t buf[4];
1589
1590 #if defined(DEBUG_SUBPAGE)
1591 printf("%s: subpage %p len %d addr " TARGET_FMT_plx
1592 " value %"PRIx64"\n",
1593 __func__, subpage, len, addr, value);
1594 #endif
1595 switch (len) {
1596 case 1:
1597 stb_p(buf, value);
1598 break;
1599 case 2:
1600 stw_p(buf, value);
1601 break;
1602 case 4:
1603 stl_p(buf, value);
1604 break;
1605 default:
1606 abort();
1607 }
1608 address_space_write(subpage->as, addr + subpage->base, buf, len);
1609 }
1610
1611 static bool subpage_accepts(void *opaque, hwaddr addr,
1612 unsigned size, bool is_write)
1613 {
1614 subpage_t *subpage = opaque;
1615 #if defined(DEBUG_SUBPAGE)
1616 printf("%s: subpage %p %c len %d addr " TARGET_FMT_plx "\n",
1617 __func__, subpage, is_write ? 'w' : 'r', len, addr);
1618 #endif
1619
1620 return address_space_access_valid(subpage->as, addr + subpage->base,
1621 size, is_write);
1622 }
1623
1624 static const MemoryRegionOps subpage_ops = {
1625 .read = subpage_read,
1626 .write = subpage_write,
1627 .valid.accepts = subpage_accepts,
1628 .endianness = DEVICE_NATIVE_ENDIAN,
1629 };
1630
1631 static int subpage_register (subpage_t *mmio, uint32_t start, uint32_t end,
1632 uint16_t section)
1633 {
1634 int idx, eidx;
1635
1636 if (start >= TARGET_PAGE_SIZE || end >= TARGET_PAGE_SIZE)
1637 return -1;
1638 idx = SUBPAGE_IDX(start);
1639 eidx = SUBPAGE_IDX(end);
1640 #if defined(DEBUG_SUBPAGE)
1641 printf("%s: %p start %08x end %08x idx %08x eidx %08x mem %ld\n", __func__,
1642 mmio, start, end, idx, eidx, memory);
1643 #endif
1644 for (; idx <= eidx; idx++) {
1645 mmio->sub_section[idx] = section;
1646 }
1647
1648 return 0;
1649 }
1650
1651 static subpage_t *subpage_init(AddressSpace *as, hwaddr base)
1652 {
1653 subpage_t *mmio;
1654
1655 mmio = g_malloc0(sizeof(subpage_t));
1656
1657 mmio->as = as;
1658 mmio->base = base;
1659 memory_region_init_io(&mmio->iomem, NULL, &subpage_ops, mmio,
1660 "subpage", TARGET_PAGE_SIZE);
1661 mmio->iomem.subpage = true;
1662 #if defined(DEBUG_SUBPAGE)
1663 printf("%s: %p base " TARGET_FMT_plx " len %08x %d\n", __func__,
1664 mmio, base, TARGET_PAGE_SIZE, subpage_memory);
1665 #endif
1666 subpage_register(mmio, 0, TARGET_PAGE_SIZE-1, PHYS_SECTION_UNASSIGNED);
1667
1668 return mmio;
1669 }
1670
1671 static uint16_t dummy_section(MemoryRegion *mr)
1672 {
1673 MemoryRegionSection section = {
1674 .mr = mr,
1675 .offset_within_address_space = 0,
1676 .offset_within_region = 0,
1677 .size = int128_2_64(),
1678 };
1679
1680 return phys_section_add(&section);
1681 }
1682
1683 MemoryRegion *iotlb_to_region(hwaddr index)
1684 {
1685 return address_space_memory.dispatch->sections[index & ~TARGET_PAGE_MASK].mr;
1686 }
1687
1688 static void io_mem_init(void)
1689 {
1690 memory_region_init_io(&io_mem_rom, NULL, &unassigned_mem_ops, NULL, "rom", UINT64_MAX);
1691 memory_region_init_io(&io_mem_unassigned, NULL, &unassigned_mem_ops, NULL,
1692 "unassigned", UINT64_MAX);
1693 memory_region_init_io(&io_mem_notdirty, NULL, &notdirty_mem_ops, NULL,
1694 "notdirty", UINT64_MAX);
1695 memory_region_init_io(&io_mem_watch, NULL, &watch_mem_ops, NULL,
1696 "watch", UINT64_MAX);
1697 }
1698
1699 static void mem_begin(MemoryListener *listener)
1700 {
1701 AddressSpace *as = container_of(listener, AddressSpace, dispatch_listener);
1702 AddressSpaceDispatch *d = g_new(AddressSpaceDispatch, 1);
1703
1704 d->phys_map = (PhysPageEntry) { .ptr = PHYS_MAP_NODE_NIL, .is_leaf = 0 };
1705 d->as = as;
1706 as->next_dispatch = d;
1707 }
1708
1709 static void mem_commit(MemoryListener *listener)
1710 {
1711 AddressSpace *as = container_of(listener, AddressSpace, dispatch_listener);
1712 AddressSpaceDispatch *cur = as->dispatch;
1713 AddressSpaceDispatch *next = as->next_dispatch;
1714
1715 next->nodes = next_map.nodes;
1716 next->sections = next_map.sections;
1717
1718 as->dispatch = next;
1719 g_free(cur);
1720 }
1721
1722 static void core_begin(MemoryListener *listener)
1723 {
1724 uint16_t n;
1725
1726 prev_map = g_new(PhysPageMap, 1);
1727 *prev_map = next_map;
1728
1729 memset(&next_map, 0, sizeof(next_map));
1730 n = dummy_section(&io_mem_unassigned);
1731 assert(n == PHYS_SECTION_UNASSIGNED);
1732 n = dummy_section(&io_mem_notdirty);
1733 assert(n == PHYS_SECTION_NOTDIRTY);
1734 n = dummy_section(&io_mem_rom);
1735 assert(n == PHYS_SECTION_ROM);
1736 n = dummy_section(&io_mem_watch);
1737 assert(n == PHYS_SECTION_WATCH);
1738 }
1739
1740 /* This listener's commit run after the other AddressSpaceDispatch listeners'.
1741 * All AddressSpaceDispatch instances have switched to the next map.
1742 */
1743 static void core_commit(MemoryListener *listener)
1744 {
1745 phys_sections_free(prev_map);
1746 }
1747
1748 static void tcg_commit(MemoryListener *listener)
1749 {
1750 CPUState *cpu;
1751
1752 /* since each CPU stores ram addresses in its TLB cache, we must
1753 reset the modified entries */
1754 /* XXX: slow ! */
1755 for (cpu = first_cpu; cpu != NULL; cpu = cpu->next_cpu) {
1756 CPUArchState *env = cpu->env_ptr;
1757
1758 tlb_flush(env, 1);
1759 }
1760 }
1761
1762 static void core_log_global_start(MemoryListener *listener)
1763 {
1764 cpu_physical_memory_set_dirty_tracking(1);
1765 }
1766
1767 static void core_log_global_stop(MemoryListener *listener)
1768 {
1769 cpu_physical_memory_set_dirty_tracking(0);
1770 }
1771
1772 static MemoryListener core_memory_listener = {
1773 .begin = core_begin,
1774 .commit = core_commit,
1775 .log_global_start = core_log_global_start,
1776 .log_global_stop = core_log_global_stop,
1777 .priority = 1,
1778 };
1779
1780 static MemoryListener tcg_memory_listener = {
1781 .commit = tcg_commit,
1782 };
1783
1784 void address_space_init_dispatch(AddressSpace *as)
1785 {
1786 as->dispatch = NULL;
1787 as->dispatch_listener = (MemoryListener) {
1788 .begin = mem_begin,
1789 .commit = mem_commit,
1790 .region_add = mem_add,
1791 .region_nop = mem_add,
1792 .priority = 0,
1793 };
1794 memory_listener_register(&as->dispatch_listener, as);
1795 }
1796
1797 void address_space_destroy_dispatch(AddressSpace *as)
1798 {
1799 AddressSpaceDispatch *d = as->dispatch;
1800
1801 memory_listener_unregister(&as->dispatch_listener);
1802 g_free(d);
1803 as->dispatch = NULL;
1804 }
1805
1806 static void memory_map_init(void)
1807 {
1808 system_memory = g_malloc(sizeof(*system_memory));
1809 memory_region_init(system_memory, NULL, "system", INT64_MAX);
1810 address_space_init(&address_space_memory, system_memory, "memory");
1811
1812 system_io = g_malloc(sizeof(*system_io));
1813 memory_region_init(system_io, NULL, "io", 65536);
1814 address_space_init(&address_space_io, system_io, "I/O");
1815
1816 memory_listener_register(&core_memory_listener, &address_space_memory);
1817 memory_listener_register(&tcg_memory_listener, &address_space_memory);
1818 }
1819
1820 MemoryRegion *get_system_memory(void)
1821 {
1822 return system_memory;
1823 }
1824
1825 MemoryRegion *get_system_io(void)
1826 {
1827 return system_io;
1828 }
1829
1830 #endif /* !defined(CONFIG_USER_ONLY) */
1831
1832 /* physical memory access (slow version, mainly for debug) */
1833 #if defined(CONFIG_USER_ONLY)
1834 int cpu_memory_rw_debug(CPUArchState *env, target_ulong addr,
1835 uint8_t *buf, int len, int is_write)
1836 {
1837 int l, flags;
1838 target_ulong page;
1839 void * p;
1840
1841 while (len > 0) {
1842 page = addr & TARGET_PAGE_MASK;
1843 l = (page + TARGET_PAGE_SIZE) - addr;
1844 if (l > len)
1845 l = len;
1846 flags = page_get_flags(page);
1847 if (!(flags & PAGE_VALID))
1848 return -1;
1849 if (is_write) {
1850 if (!(flags & PAGE_WRITE))
1851 return -1;
1852 /* XXX: this code should not depend on lock_user */
1853 if (!(p = lock_user(VERIFY_WRITE, addr, l, 0)))
1854 return -1;
1855 memcpy(p, buf, l);
1856 unlock_user(p, addr, l);
1857 } else {
1858 if (!(flags & PAGE_READ))
1859 return -1;
1860 /* XXX: this code should not depend on lock_user */
1861 if (!(p = lock_user(VERIFY_READ, addr, l, 1)))
1862 return -1;
1863 memcpy(buf, p, l);
1864 unlock_user(p, addr, 0);
1865 }
1866 len -= l;
1867 buf += l;
1868 addr += l;
1869 }
1870 return 0;
1871 }
1872
1873 #else
1874
1875 static void invalidate_and_set_dirty(hwaddr addr,
1876 hwaddr length)
1877 {
1878 if (!cpu_physical_memory_is_dirty(addr)) {
1879 /* invalidate code */
1880 tb_invalidate_phys_page_range(addr, addr + length, 0);
1881 /* set dirty bit */
1882 cpu_physical_memory_set_dirty_flags(addr, (0xff & ~CODE_DIRTY_FLAG));
1883 }
1884 xen_modified_memory(addr, length);
1885 }
1886
1887 static inline bool memory_access_is_direct(MemoryRegion *mr, bool is_write)
1888 {
1889 if (memory_region_is_ram(mr)) {
1890 return !(is_write && mr->readonly);
1891 }
1892 if (memory_region_is_romd(mr)) {
1893 return !is_write;
1894 }
1895
1896 return false;
1897 }
1898
1899 static int memory_access_size(MemoryRegion *mr, unsigned l, hwaddr addr)
1900 {
1901 unsigned access_size_max = mr->ops->valid.max_access_size;
1902
1903 /* Regions are assumed to support 1-4 byte accesses unless
1904 otherwise specified. */
1905 if (access_size_max == 0) {
1906 access_size_max = 4;
1907 }
1908
1909 /* Bound the maximum access by the alignment of the address. */
1910 if (!mr->ops->impl.unaligned) {
1911 unsigned align_size_max = addr & -addr;
1912 if (align_size_max != 0 && align_size_max < access_size_max) {
1913 access_size_max = align_size_max;
1914 }
1915 }
1916
1917 /* Don't attempt accesses larger than the maximum. */
1918 if (l > access_size_max) {
1919 l = access_size_max;
1920 }
1921
1922 return l;
1923 }
1924
1925 bool address_space_rw(AddressSpace *as, hwaddr addr, uint8_t *buf,
1926 int len, bool is_write)
1927 {
1928 hwaddr l;
1929 uint8_t *ptr;
1930 uint64_t val;
1931 hwaddr addr1;
1932 MemoryRegion *mr;
1933 bool error = false;
1934
1935 while (len > 0) {
1936 l = len;
1937 mr = address_space_translate(as, addr, &addr1, &l, is_write);
1938
1939 if (is_write) {
1940 if (!memory_access_is_direct(mr, is_write)) {
1941 l = memory_access_size(mr, l, addr1);
1942 /* XXX: could force current_cpu to NULL to avoid
1943 potential bugs */
1944 switch (l) {
1945 case 8:
1946 /* 64 bit write access */
1947 val = ldq_p(buf);
1948 error |= io_mem_write(mr, addr1, val, 8);
1949 break;
1950 case 4:
1951 /* 32 bit write access */
1952 val = ldl_p(buf);
1953 error |= io_mem_write(mr, addr1, val, 4);
1954 break;
1955 case 2:
1956 /* 16 bit write access */
1957 val = lduw_p(buf);
1958 error |= io_mem_write(mr, addr1, val, 2);
1959 break;
1960 case 1:
1961 /* 8 bit write access */
1962 val = ldub_p(buf);
1963 error |= io_mem_write(mr, addr1, val, 1);
1964 break;
1965 default:
1966 abort();
1967 }
1968 } else {
1969 addr1 += memory_region_get_ram_addr(mr);
1970 /* RAM case */
1971 ptr = qemu_get_ram_ptr(addr1);
1972 memcpy(ptr, buf, l);
1973 invalidate_and_set_dirty(addr1, l);
1974 }
1975 } else {
1976 if (!memory_access_is_direct(mr, is_write)) {
1977 /* I/O case */
1978 l = memory_access_size(mr, l, addr1);
1979 switch (l) {
1980 case 8:
1981 /* 64 bit read access */
1982 error |= io_mem_read(mr, addr1, &val, 8);
1983 stq_p(buf, val);
1984 break;
1985 case 4:
1986 /* 32 bit read access */
1987 error |= io_mem_read(mr, addr1, &val, 4);
1988 stl_p(buf, val);
1989 break;
1990 case 2:
1991 /* 16 bit read access */
1992 error |= io_mem_read(mr, addr1, &val, 2);
1993 stw_p(buf, val);
1994 break;
1995 case 1:
1996 /* 8 bit read access */
1997 error |= io_mem_read(mr, addr1, &val, 1);
1998 stb_p(buf, val);
1999 break;
2000 default:
2001 abort();
2002 }
2003 } else {
2004 /* RAM case */
2005 ptr = qemu_get_ram_ptr(mr->ram_addr + addr1);
2006 memcpy(buf, ptr, l);
2007 }
2008 }
2009 len -= l;
2010 buf += l;
2011 addr += l;
2012 }
2013
2014 return error;
2015 }
2016
2017 bool address_space_write(AddressSpace *as, hwaddr addr,
2018 const uint8_t *buf, int len)
2019 {
2020 return address_space_rw(as, addr, (uint8_t *)buf, len, true);
2021 }
2022
2023 bool address_space_read(AddressSpace *as, hwaddr addr, uint8_t *buf, int len)
2024 {
2025 return address_space_rw(as, addr, buf, len, false);
2026 }
2027
2028
2029 void cpu_physical_memory_rw(hwaddr addr, uint8_t *buf,
2030 int len, int is_write)
2031 {
2032 address_space_rw(&address_space_memory, addr, buf, len, is_write);
2033 }
2034
2035 /* used for ROM loading : can write in RAM and ROM */
2036 void cpu_physical_memory_write_rom(hwaddr addr,
2037 const uint8_t *buf, int len)
2038 {
2039 hwaddr l;
2040 uint8_t *ptr;
2041 hwaddr addr1;
2042 MemoryRegion *mr;
2043
2044 while (len > 0) {
2045 l = len;
2046 mr = address_space_translate(&address_space_memory,
2047 addr, &addr1, &l, true);
2048
2049 if (!(memory_region_is_ram(mr) ||
2050 memory_region_is_romd(mr))) {
2051 /* do nothing */
2052 } else {
2053 addr1 += memory_region_get_ram_addr(mr);
2054 /* ROM/RAM case */
2055 ptr = qemu_get_ram_ptr(addr1);
2056 memcpy(ptr, buf, l);
2057 invalidate_and_set_dirty(addr1, l);
2058 }
2059 len -= l;
2060 buf += l;
2061 addr += l;
2062 }
2063 }
2064
2065 typedef struct {
2066 MemoryRegion *mr;
2067 void *buffer;
2068 hwaddr addr;
2069 hwaddr len;
2070 } BounceBuffer;
2071
2072 static BounceBuffer bounce;
2073
2074 typedef struct MapClient {
2075 void *opaque;
2076 void (*callback)(void *opaque);
2077 QLIST_ENTRY(MapClient) link;
2078 } MapClient;
2079
2080 static QLIST_HEAD(map_client_list, MapClient) map_client_list
2081 = QLIST_HEAD_INITIALIZER(map_client_list);
2082
2083 void *cpu_register_map_client(void *opaque, void (*callback)(void *opaque))
2084 {
2085 MapClient *client = g_malloc(sizeof(*client));
2086
2087 client->opaque = opaque;
2088 client->callback = callback;
2089 QLIST_INSERT_HEAD(&map_client_list, client, link);
2090 return client;
2091 }
2092
2093 static void cpu_unregister_map_client(void *_client)
2094 {
2095 MapClient *client = (MapClient *)_client;
2096
2097 QLIST_REMOVE(client, link);
2098 g_free(client);
2099 }
2100
2101 static void cpu_notify_map_clients(void)
2102 {
2103 MapClient *client;
2104
2105 while (!QLIST_EMPTY(&map_client_list)) {
2106 client = QLIST_FIRST(&map_client_list);
2107 client->callback(client->opaque);
2108 cpu_unregister_map_client(client);
2109 }
2110 }
2111
2112 bool address_space_access_valid(AddressSpace *as, hwaddr addr, int len, bool is_write)
2113 {
2114 MemoryRegion *mr;
2115 hwaddr l, xlat;
2116
2117 while (len > 0) {
2118 l = len;
2119 mr = address_space_translate(as, addr, &xlat, &l, is_write);
2120 if (!memory_access_is_direct(mr, is_write)) {
2121 l = memory_access_size(mr, l, addr);
2122 if (!memory_region_access_valid(mr, xlat, l, is_write)) {
2123 return false;
2124 }
2125 }
2126
2127 len -= l;
2128 addr += l;
2129 }
2130 return true;
2131 }
2132
2133 /* Map a physical memory region into a host virtual address.
2134 * May map a subset of the requested range, given by and returned in *plen.
2135 * May return NULL if resources needed to perform the mapping are exhausted.
2136 * Use only for reads OR writes - not for read-modify-write operations.
2137 * Use cpu_register_map_client() to know when retrying the map operation is
2138 * likely to succeed.
2139 */
2140 void *address_space_map(AddressSpace *as,
2141 hwaddr addr,
2142 hwaddr *plen,
2143 bool is_write)
2144 {
2145 hwaddr len = *plen;
2146 hwaddr done = 0;
2147 hwaddr l, xlat, base;
2148 MemoryRegion *mr, *this_mr;
2149 ram_addr_t raddr;
2150
2151 if (len == 0) {
2152 return NULL;
2153 }
2154
2155 l = len;
2156 mr = address_space_translate(as, addr, &xlat, &l, is_write);
2157 if (!memory_access_is_direct(mr, is_write)) {
2158 if (bounce.buffer) {
2159 return NULL;
2160 }
2161 bounce.buffer = qemu_memalign(TARGET_PAGE_SIZE, TARGET_PAGE_SIZE);
2162 bounce.addr = addr;
2163 bounce.len = l;
2164
2165 memory_region_ref(mr);
2166 bounce.mr = mr;
2167 if (!is_write) {
2168 address_space_read(as, addr, bounce.buffer, l);
2169 }
2170
2171 *plen = l;
2172 return bounce.buffer;
2173 }
2174
2175 base = xlat;
2176 raddr = memory_region_get_ram_addr(mr);
2177
2178 for (;;) {
2179 len -= l;
2180 addr += l;
2181 done += l;
2182 if (len == 0) {
2183 break;
2184 }
2185
2186 l = len;
2187 this_mr = address_space_translate(as, addr, &xlat, &l, is_write);
2188 if (this_mr != mr || xlat != base + done) {
2189 break;
2190 }
2191 }
2192
2193 memory_region_ref(mr);
2194 *plen = done;
2195 return qemu_ram_ptr_length(raddr + base, plen);
2196 }
2197
2198 /* Unmaps a memory region previously mapped by address_space_map().
2199 * Will also mark the memory as dirty if is_write == 1. access_len gives
2200 * the amount of memory that was actually read or written by the caller.
2201 */
2202 void address_space_unmap(AddressSpace *as, void *buffer, hwaddr len,
2203 int is_write, hwaddr access_len)
2204 {
2205 if (buffer != bounce.buffer) {
2206 MemoryRegion *mr;
2207 ram_addr_t addr1;
2208
2209 mr = qemu_ram_addr_from_host(buffer, &addr1);
2210 assert(mr != NULL);
2211 if (is_write) {
2212 while (access_len) {
2213 unsigned l;
2214 l = TARGET_PAGE_SIZE;
2215 if (l > access_len)
2216 l = access_len;
2217 invalidate_and_set_dirty(addr1, l);
2218 addr1 += l;
2219 access_len -= l;
2220 }
2221 }
2222 if (xen_enabled()) {
2223 xen_invalidate_map_cache_entry(buffer);
2224 }
2225 memory_region_unref(mr);
2226 return;
2227 }
2228 if (is_write) {
2229 address_space_write(as, bounce.addr, bounce.buffer, access_len);
2230 }
2231 qemu_vfree(bounce.buffer);
2232 bounce.buffer = NULL;
2233 memory_region_unref(bounce.mr);
2234 cpu_notify_map_clients();
2235 }
2236
2237 void *cpu_physical_memory_map(hwaddr addr,
2238 hwaddr *plen,
2239 int is_write)
2240 {
2241 return address_space_map(&address_space_memory, addr, plen, is_write);
2242 }
2243
2244 void cpu_physical_memory_unmap(void *buffer, hwaddr len,
2245 int is_write, hwaddr access_len)
2246 {
2247 return address_space_unmap(&address_space_memory, buffer, len, is_write, access_len);
2248 }
2249
2250 /* warning: addr must be aligned */
2251 static inline uint32_t ldl_phys_internal(hwaddr addr,
2252 enum device_endian endian)
2253 {
2254 uint8_t *ptr;
2255 uint64_t val;
2256 MemoryRegion *mr;
2257 hwaddr l = 4;
2258 hwaddr addr1;
2259
2260 mr = address_space_translate(&address_space_memory, addr, &addr1, &l,
2261 false);
2262 if (l < 4 || !memory_access_is_direct(mr, false)) {
2263 /* I/O case */
2264 io_mem_read(mr, addr1, &val, 4);
2265 #if defined(TARGET_WORDS_BIGENDIAN)
2266 if (endian == DEVICE_LITTLE_ENDIAN) {
2267 val = bswap32(val);
2268 }
2269 #else
2270 if (endian == DEVICE_BIG_ENDIAN) {
2271 val = bswap32(val);
2272 }
2273 #endif
2274 } else {
2275 /* RAM case */
2276 ptr = qemu_get_ram_ptr((memory_region_get_ram_addr(mr)
2277 & TARGET_PAGE_MASK)
2278 + addr1);
2279 switch (endian) {
2280 case DEVICE_LITTLE_ENDIAN:
2281 val = ldl_le_p(ptr);
2282 break;
2283 case DEVICE_BIG_ENDIAN:
2284 val = ldl_be_p(ptr);
2285 break;
2286 default:
2287 val = ldl_p(ptr);
2288 break;
2289 }
2290 }
2291 return val;
2292 }
2293
2294 uint32_t ldl_phys(hwaddr addr)
2295 {
2296 return ldl_phys_internal(addr, DEVICE_NATIVE_ENDIAN);
2297 }
2298
2299 uint32_t ldl_le_phys(hwaddr addr)
2300 {
2301 return ldl_phys_internal(addr, DEVICE_LITTLE_ENDIAN);
2302 }
2303
2304 uint32_t ldl_be_phys(hwaddr addr)
2305 {
2306 return ldl_phys_internal(addr, DEVICE_BIG_ENDIAN);
2307 }
2308
2309 /* warning: addr must be aligned */
2310 static inline uint64_t ldq_phys_internal(hwaddr addr,
2311 enum device_endian endian)
2312 {
2313 uint8_t *ptr;
2314 uint64_t val;
2315 MemoryRegion *mr;
2316 hwaddr l = 8;
2317 hwaddr addr1;
2318
2319 mr = address_space_translate(&address_space_memory, addr, &addr1, &l,
2320 false);
2321 if (l < 8 || !memory_access_is_direct(mr, false)) {
2322 /* I/O case */
2323 io_mem_read(mr, addr1, &val, 8);
2324 #if defined(TARGET_WORDS_BIGENDIAN)
2325 if (endian == DEVICE_LITTLE_ENDIAN) {
2326 val = bswap64(val);
2327 }
2328 #else
2329 if (endian == DEVICE_BIG_ENDIAN) {
2330 val = bswap64(val);
2331 }
2332 #endif
2333 } else {
2334 /* RAM case */
2335 ptr = qemu_get_ram_ptr((memory_region_get_ram_addr(mr)
2336 & TARGET_PAGE_MASK)
2337 + addr1);
2338 switch (endian) {
2339 case DEVICE_LITTLE_ENDIAN:
2340 val = ldq_le_p(ptr);
2341 break;
2342 case DEVICE_BIG_ENDIAN:
2343 val = ldq_be_p(ptr);
2344 break;
2345 default:
2346 val = ldq_p(ptr);
2347 break;
2348 }
2349 }
2350 return val;
2351 }
2352
2353 uint64_t ldq_phys(hwaddr addr)
2354 {
2355 return ldq_phys_internal(addr, DEVICE_NATIVE_ENDIAN);
2356 }
2357
2358 uint64_t ldq_le_phys(hwaddr addr)
2359 {
2360 return ldq_phys_internal(addr, DEVICE_LITTLE_ENDIAN);
2361 }
2362
2363 uint64_t ldq_be_phys(hwaddr addr)
2364 {
2365 return ldq_phys_internal(addr, DEVICE_BIG_ENDIAN);
2366 }
2367
2368 /* XXX: optimize */
2369 uint32_t ldub_phys(hwaddr addr)
2370 {
2371 uint8_t val;
2372 cpu_physical_memory_read(addr, &val, 1);
2373 return val;
2374 }
2375
2376 /* warning: addr must be aligned */
2377 static inline uint32_t lduw_phys_internal(hwaddr addr,
2378 enum device_endian endian)
2379 {
2380 uint8_t *ptr;
2381 uint64_t val;
2382 MemoryRegion *mr;
2383 hwaddr l = 2;
2384 hwaddr addr1;
2385
2386 mr = address_space_translate(&address_space_memory, addr, &addr1, &l,
2387 false);
2388 if (l < 2 || !memory_access_is_direct(mr, false)) {
2389 /* I/O case */
2390 io_mem_read(mr, addr1, &val, 2);
2391 #if defined(TARGET_WORDS_BIGENDIAN)
2392 if (endian == DEVICE_LITTLE_ENDIAN) {
2393 val = bswap16(val);
2394 }
2395 #else
2396 if (endian == DEVICE_BIG_ENDIAN) {
2397 val = bswap16(val);
2398 }
2399 #endif
2400 } else {
2401 /* RAM case */
2402 ptr = qemu_get_ram_ptr((memory_region_get_ram_addr(mr)
2403 & TARGET_PAGE_MASK)
2404 + addr1);
2405 switch (endian) {
2406 case DEVICE_LITTLE_ENDIAN:
2407 val = lduw_le_p(ptr);
2408 break;
2409 case DEVICE_BIG_ENDIAN:
2410 val = lduw_be_p(ptr);
2411 break;
2412 default:
2413 val = lduw_p(ptr);
2414 break;
2415 }
2416 }
2417 return val;
2418 }
2419
2420 uint32_t lduw_phys(hwaddr addr)
2421 {
2422 return lduw_phys_internal(addr, DEVICE_NATIVE_ENDIAN);
2423 }
2424
2425 uint32_t lduw_le_phys(hwaddr addr)
2426 {
2427 return lduw_phys_internal(addr, DEVICE_LITTLE_ENDIAN);
2428 }
2429
2430 uint32_t lduw_be_phys(hwaddr addr)
2431 {
2432 return lduw_phys_internal(addr, DEVICE_BIG_ENDIAN);
2433 }
2434
2435 /* warning: addr must be aligned. The ram page is not masked as dirty
2436 and the code inside is not invalidated. It is useful if the dirty
2437 bits are used to track modified PTEs */
2438 void stl_phys_notdirty(hwaddr addr, uint32_t val)
2439 {
2440 uint8_t *ptr;
2441 MemoryRegion *mr;
2442 hwaddr l = 4;
2443 hwaddr addr1;
2444
2445 mr = address_space_translate(&address_space_memory, addr, &addr1, &l,
2446 true);
2447 if (l < 4 || !memory_access_is_direct(mr, true)) {
2448 io_mem_write(mr, addr1, val, 4);
2449 } else {
2450 addr1 += memory_region_get_ram_addr(mr) & TARGET_PAGE_MASK;
2451 ptr = qemu_get_ram_ptr(addr1);
2452 stl_p(ptr, val);
2453
2454 if (unlikely(in_migration)) {
2455 if (!cpu_physical_memory_is_dirty(addr1)) {
2456 /* invalidate code */
2457 tb_invalidate_phys_page_range(addr1, addr1 + 4, 0);
2458 /* set dirty bit */
2459 cpu_physical_memory_set_dirty_flags(
2460 addr1, (0xff & ~CODE_DIRTY_FLAG));
2461 }
2462 }
2463 }
2464 }
2465
2466 /* warning: addr must be aligned */
2467 static inline void stl_phys_internal(hwaddr addr, uint32_t val,
2468 enum device_endian endian)
2469 {
2470 uint8_t *ptr;
2471 MemoryRegion *mr;
2472 hwaddr l = 4;
2473 hwaddr addr1;
2474
2475 mr = address_space_translate(&address_space_memory, addr, &addr1, &l,
2476 true);
2477 if (l < 4 || !memory_access_is_direct(mr, true)) {
2478 #if defined(TARGET_WORDS_BIGENDIAN)
2479 if (endian == DEVICE_LITTLE_ENDIAN) {
2480 val = bswap32(val);
2481 }
2482 #else
2483 if (endian == DEVICE_BIG_ENDIAN) {
2484 val = bswap32(val);
2485 }
2486 #endif
2487 io_mem_write(mr, addr1, val, 4);
2488 } else {
2489 /* RAM case */
2490 addr1 += memory_region_get_ram_addr(mr) & TARGET_PAGE_MASK;
2491 ptr = qemu_get_ram_ptr(addr1);
2492 switch (endian) {
2493 case DEVICE_LITTLE_ENDIAN:
2494 stl_le_p(ptr, val);
2495 break;
2496 case DEVICE_BIG_ENDIAN:
2497 stl_be_p(ptr, val);
2498 break;
2499 default:
2500 stl_p(ptr, val);
2501 break;
2502 }
2503 invalidate_and_set_dirty(addr1, 4);
2504 }
2505 }
2506
2507 void stl_phys(hwaddr addr, uint32_t val)
2508 {
2509 stl_phys_internal(addr, val, DEVICE_NATIVE_ENDIAN);
2510 }
2511
2512 void stl_le_phys(hwaddr addr, uint32_t val)
2513 {
2514 stl_phys_internal(addr, val, DEVICE_LITTLE_ENDIAN);
2515 }
2516
2517 void stl_be_phys(hwaddr addr, uint32_t val)
2518 {
2519 stl_phys_internal(addr, val, DEVICE_BIG_ENDIAN);
2520 }
2521
2522 /* XXX: optimize */
2523 void stb_phys(hwaddr addr, uint32_t val)
2524 {
2525 uint8_t v = val;
2526 cpu_physical_memory_write(addr, &v, 1);
2527 }
2528
2529 /* warning: addr must be aligned */
2530 static inline void stw_phys_internal(hwaddr addr, uint32_t val,
2531 enum device_endian endian)
2532 {
2533 uint8_t *ptr;
2534 MemoryRegion *mr;
2535 hwaddr l = 2;
2536 hwaddr addr1;
2537
2538 mr = address_space_translate(&address_space_memory, addr, &addr1, &l,
2539 true);
2540 if (l < 2 || !memory_access_is_direct(mr, true)) {
2541 #if defined(TARGET_WORDS_BIGENDIAN)
2542 if (endian == DEVICE_LITTLE_ENDIAN) {
2543 val = bswap16(val);
2544 }
2545 #else
2546 if (endian == DEVICE_BIG_ENDIAN) {
2547 val = bswap16(val);
2548 }
2549 #endif
2550 io_mem_write(mr, addr1, val, 2);
2551 } else {
2552 /* RAM case */
2553 addr1 += memory_region_get_ram_addr(mr) & TARGET_PAGE_MASK;
2554 ptr = qemu_get_ram_ptr(addr1);
2555 switch (endian) {
2556 case DEVICE_LITTLE_ENDIAN:
2557 stw_le_p(ptr, val);
2558 break;
2559 case DEVICE_BIG_ENDIAN:
2560 stw_be_p(ptr, val);
2561 break;
2562 default:
2563 stw_p(ptr, val);
2564 break;
2565 }
2566 invalidate_and_set_dirty(addr1, 2);
2567 }
2568 }
2569
2570 void stw_phys(hwaddr addr, uint32_t val)
2571 {
2572 stw_phys_internal(addr, val, DEVICE_NATIVE_ENDIAN);
2573 }
2574
2575 void stw_le_phys(hwaddr addr, uint32_t val)
2576 {
2577 stw_phys_internal(addr, val, DEVICE_LITTLE_ENDIAN);
2578 }
2579
2580 void stw_be_phys(hwaddr addr, uint32_t val)
2581 {
2582 stw_phys_internal(addr, val, DEVICE_BIG_ENDIAN);
2583 }
2584
2585 /* XXX: optimize */
2586 void stq_phys(hwaddr addr, uint64_t val)
2587 {
2588 val = tswap64(val);
2589 cpu_physical_memory_write(addr, &val, 8);
2590 }
2591
2592 void stq_le_phys(hwaddr addr, uint64_t val)
2593 {
2594 val = cpu_to_le64(val);
2595 cpu_physical_memory_write(addr, &val, 8);
2596 }
2597
2598 void stq_be_phys(hwaddr addr, uint64_t val)
2599 {
2600 val = cpu_to_be64(val);
2601 cpu_physical_memory_write(addr, &val, 8);
2602 }
2603
2604 /* virtual memory access for debug (includes writing to ROM) */
2605 int cpu_memory_rw_debug(CPUArchState *env, target_ulong addr,
2606 uint8_t *buf, int len, int is_write)
2607 {
2608 int l;
2609 hwaddr phys_addr;
2610 target_ulong page;
2611
2612 while (len > 0) {
2613 page = addr & TARGET_PAGE_MASK;
2614 phys_addr = cpu_get_phys_page_debug(env, page);
2615 /* if no physical page mapped, return an error */
2616 if (phys_addr == -1)
2617 return -1;
2618 l = (page + TARGET_PAGE_SIZE) - addr;
2619 if (l > len)
2620 l = len;
2621 phys_addr += (addr & ~TARGET_PAGE_MASK);
2622 if (is_write)
2623 cpu_physical_memory_write_rom(phys_addr, buf, l);
2624 else
2625 cpu_physical_memory_rw(phys_addr, buf, l, is_write);
2626 len -= l;
2627 buf += l;
2628 addr += l;
2629 }
2630 return 0;
2631 }
2632 #endif
2633
2634 #if !defined(CONFIG_USER_ONLY)
2635
2636 /*
2637 * A helper function for the _utterly broken_ virtio device model to find out if
2638 * it's running on a big endian machine. Don't do this at home kids!
2639 */
2640 bool virtio_is_big_endian(void);
2641 bool virtio_is_big_endian(void)
2642 {
2643 #if defined(TARGET_WORDS_BIGENDIAN)
2644 return true;
2645 #else
2646 return false;
2647 #endif
2648 }
2649
2650 #endif
2651
2652 #ifndef CONFIG_USER_ONLY
2653 bool cpu_physical_memory_is_io(hwaddr phys_addr)
2654 {
2655 MemoryRegion*mr;
2656 hwaddr l = 1;
2657
2658 mr = address_space_translate(&address_space_memory,
2659 phys_addr, &phys_addr, &l, false);
2660
2661 return !(memory_region_is_ram(mr) ||
2662 memory_region_is_romd(mr));
2663 }
2664
2665 void qemu_ram_foreach_block(RAMBlockIterFunc func, void *opaque)
2666 {
2667 RAMBlock *block;
2668
2669 QTAILQ_FOREACH(block, &ram_list.blocks, next) {
2670 func(block->host, block->offset, block->length, opaque);
2671 }
2672 }
2673 #endif
QEMU modified to work with kvm