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