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