exec.c

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