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
1932     return l;
1933 }
1934
1935 bool address_space_rw(AddressSpace *as, hwaddr addr, uint8_t *buf,
1936                       int len, bool is_write)
1937 {
1938     hwaddr l;
1939     uint8_t *ptr;
1940     uint64_t val;
1941     hwaddr addr1;
1942     MemoryRegion *mr;
1943     bool error = false;
1944
1945     while (len > 0) {
1946         l = len;
1947         mr = address_space_translate(as, addr, &addr1, &l, is_write);
1948
1949         if (is_write) {
1950             if (!memory_access_is_direct(mr, is_write)) {
1951                 l = memory_access_size(mr, l, addr1);
1952                 /* XXX: could force current_cpu to NULL to avoid
1953                    potential bugs */
1954                 switch (l) {
1955                 case 8:
1956                     /* 64 bit write access */
1957                     val = ldq_p(buf);
1958                     error |= io_mem_write(mr, addr1, val, 8);
1959                     break;
1960                 case 4:
1961                     /* 32 bit write access */
1962                     val = ldl_p(buf);
1963                     error |= io_mem_write(mr, addr1, val, 4);
1964                     break;
1965                 case 2:
1966                     /* 16 bit write access */
1967                     val = lduw_p(buf);
1968                     error |= io_mem_write(mr, addr1, val, 2);
1969                     break;
1970                 case 1:
1971                     /* 8 bit write access */
1972                     val = ldub_p(buf);
1973                     error |= io_mem_write(mr, addr1, val, 1);
1974                     break;
1975                 default:
1976                     abort();
1977                 }
1978             } else {
1979                 addr1 += memory_region_get_ram_addr(mr);
1980                 /* RAM case */
1981                 ptr = qemu_get_ram_ptr(addr1);
1982                 memcpy(ptr, buf, l);
1983                 invalidate_and_set_dirty(addr1, l);
1984             }
1985         } else {
1986             if (!memory_access_is_direct(mr, is_write)) {
1987                 /* I/O case */
1988                 l = memory_access_size(mr, l, addr1);
1989                 switch (l) {
1990                 case 8:
1991                     /* 64 bit read access */
1992                     error |= io_mem_read(mr, addr1, &val, 8);
1993                     stq_p(buf, val);
1994                     break;
1995                 case 4:
1996                     /* 32 bit read access */
1997                     error |= io_mem_read(mr, addr1, &val, 4);
1998                     stl_p(buf, val);
1999                     break;
2000                 case 2:
2001                     /* 16 bit read access */
2002                     error |= io_mem_read(mr, addr1, &val, 2);
2003                     stw_p(buf, val);
2004                     break;
2005                 case 1:
2006                     /* 8 bit read access */
2007                     error |= io_mem_read(mr, addr1, &val, 1);
2008                     stb_p(buf, val);
2009                     break;
2010                 default:
2011                     abort();
2012                 }
2013             } else {
2014                 /* RAM case */
2015                 ptr = qemu_get_ram_ptr(mr->ram_addr + addr1);
2016                 memcpy(buf, ptr, l);
2017             }
2018         }
2019         len -= l;
2020         buf += l;
2021         addr += l;
2022     }
2023
2024     return error;
2025 }
2026
2027 bool address_space_write(AddressSpace *as, hwaddr addr,
2028                          const uint8_t *buf, int len)
2029 {
2030     return address_space_rw(as, addr, (uint8_t *)buf, len, true);
2031 }
2032
2033 bool address_space_read(AddressSpace *as, hwaddr addr, uint8_t *buf, int len)
2034 {
2035     return address_space_rw(as, addr, buf, len, false);
2036 }
2037
2038
2039 void cpu_physical_memory_rw(hwaddr addr, uint8_t *buf,
2040                             int len, int is_write)
2041 {
2042     address_space_rw(&address_space_memory, addr, buf, len, is_write);
2043 }
2044
2045 /* used for ROM loading : can write in RAM and ROM */
2046 void cpu_physical_memory_write_rom(hwaddr addr,
2047                                    const uint8_t *buf, int len)
2048 {
2049     hwaddr l;
2050     uint8_t *ptr;
2051     hwaddr addr1;
2052     MemoryRegion *mr;
2053
2054     while (len > 0) {
2055         l = len;
2056         mr = address_space_translate(&address_space_memory,
2057                                      addr, &addr1, &l, true);
2058
2059         if (!(memory_region_is_ram(mr) ||
2060               memory_region_is_romd(mr))) {
2061             /* do nothing */
2062         } else {
2063             addr1 += memory_region_get_ram_addr(mr);
2064             /* ROM/RAM case */
2065             ptr = qemu_get_ram_ptr(addr1);
2066             memcpy(ptr, buf, l);
2067             invalidate_and_set_dirty(addr1, l);
2068         }
2069         len -= l;
2070         buf += l;
2071         addr += l;
2072     }
2073 }
2074
2075 typedef struct {
2076     MemoryRegion *mr;
2077     void *buffer;
2078     hwaddr addr;
2079     hwaddr len;
2080 } BounceBuffer;
2081
2082 static BounceBuffer bounce;
2083
2084 typedef struct MapClient {
2085     void *opaque;
2086     void (*callback)(void *opaque);
2087     QLIST_ENTRY(MapClient) link;
2088 } MapClient;
2089
2090 static QLIST_HEAD(map_client_list, MapClient) map_client_list
2091     = QLIST_HEAD_INITIALIZER(map_client_list);
2092
2093 void *cpu_register_map_client(void *opaque, void (*callback)(void *opaque))
2094 {
2095     MapClient *client = g_malloc(sizeof(*client));
2096
2097     client->opaque = opaque;
2098     client->callback = callback;
2099     QLIST_INSERT_HEAD(&map_client_list, client, link);
2100     return client;
2101 }
2102
2103 static void cpu_unregister_map_client(void *_client)
2104 {
2105     MapClient *client = (MapClient *)_client;
2106
2107     QLIST_REMOVE(client, link);
2108     g_free(client);
2109 }
2110
2111 static void cpu_notify_map_clients(void)
2112 {
2113     MapClient *client;
2114
2115     while (!QLIST_EMPTY(&map_client_list)) {
2116         client = QLIST_FIRST(&map_client_list);
2117         client->callback(client->opaque);
2118         cpu_unregister_map_client(client);
2119     }
2120 }
2121
2122 bool address_space_access_valid(AddressSpace *as, hwaddr addr, int len, bool is_write)
2123 {
2124     MemoryRegion *mr;
2125     hwaddr l, xlat;
2126
2127     while (len > 0) {
2128         l = len;
2129         mr = address_space_translate(as, addr, &xlat, &l, is_write);
2130         if (!memory_access_is_direct(mr, is_write)) {
2131             l = memory_access_size(mr, l, addr);
2132             if (!memory_region_access_valid(mr, xlat, l, is_write)) {
2133                 return false;
2134             }
2135         }
2136
2137         len -= l;
2138         addr += l;
2139     }
2140     return true;
2141 }
2142
2143 /* Map a physical memory region into a host virtual address.
2144  * May map a subset of the requested range, given by and returned in *plen.
2145  * May return NULL if resources needed to perform the mapping are exhausted.
2146  * Use only for reads OR writes - not for read-modify-write operations.
2147  * Use cpu_register_map_client() to know when retrying the map operation is
2148  * likely to succeed.
2149  */
2150 void *address_space_map(AddressSpace *as,
2151                         hwaddr addr,
2152                         hwaddr *plen,
2153                         bool is_write)
2154 {
2155     hwaddr len = *plen;
2156     hwaddr done = 0;
2157     hwaddr l, xlat, base;
2158     MemoryRegion *mr, *this_mr;
2159     ram_addr_t raddr;
2160
2161     if (len == 0) {
2162         return NULL;
2163     }
2164
2165     l = len;
2166     mr = address_space_translate(as, addr, &xlat, &l, is_write);
2167     if (!memory_access_is_direct(mr, is_write)) {
2168         if (bounce.buffer) {
2169             return NULL;
2170         }
2171         bounce.buffer = qemu_memalign(TARGET_PAGE_SIZE, TARGET_PAGE_SIZE);
2172         bounce.addr = addr;
2173         bounce.len = l;
2174
2175         memory_region_ref(mr);
2176         bounce.mr = mr;
2177         if (!is_write) {
2178             address_space_read(as, addr, bounce.buffer, l);
2179         }
2180
2181         *plen = l;
2182         return bounce.buffer;
2183     }
2184
2185     base = xlat;
2186     raddr = memory_region_get_ram_addr(mr);
2187
2188     for (;;) {
2189         len -= l;
2190         addr += l;
2191         done += l;
2192         if (len == 0) {
2193             break;
2194         }
2195
2196         l = len;
2197         this_mr = address_space_translate(as, addr, &xlat, &l, is_write);
2198         if (this_mr != mr || xlat != base + done) {
2199             break;
2200         }
2201     }
2202
2203     memory_region_ref(mr);
2204     *plen = done;
2205     return qemu_ram_ptr_length(raddr + base, plen);
2206 }
2207
2208 /* Unmaps a memory region previously mapped by address_space_map().
2209  * Will also mark the memory as dirty if is_write == 1.  access_len gives
2210  * the amount of memory that was actually read or written by the caller.
2211  */
2212 void address_space_unmap(AddressSpace *as, void *buffer, hwaddr len,
2213                          int is_write, hwaddr access_len)
2214 {
2215     if (buffer != bounce.buffer) {
2216         MemoryRegion *mr;
2217         ram_addr_t addr1;
2218
2219         mr = qemu_ram_addr_from_host(buffer, &addr1);
2220         assert(mr != NULL);
2221         if (is_write) {
2222             while (access_len) {
2223                 unsigned l;
2224                 l = TARGET_PAGE_SIZE;
2225                 if (l > access_len)
2226                     l = access_len;
2227                 invalidate_and_set_dirty(addr1, l);
2228                 addr1 += l;
2229                 access_len -= l;
2230             }
2231         }
2232         if (xen_enabled()) {
2233             xen_invalidate_map_cache_entry(buffer);
2234         }
2235         memory_region_unref(mr);
2236         return;
2237     }
2238     if (is_write) {
2239         address_space_write(as, bounce.addr, bounce.buffer, access_len);
2240     }
2241     qemu_vfree(bounce.buffer);
2242     bounce.buffer = NULL;
2243     memory_region_unref(bounce.mr);
2244     cpu_notify_map_clients();
2245 }
2246
2247 void *cpu_physical_memory_map(hwaddr addr,
2248                               hwaddr *plen,
2249                               int is_write)
2250 {
2251     return address_space_map(&address_space_memory, addr, plen, is_write);
2252 }
2253
2254 void cpu_physical_memory_unmap(void *buffer, hwaddr len,
2255                                int is_write, hwaddr access_len)
2256 {
2257     return address_space_unmap(&address_space_memory, buffer, len, is_write, access_len);
2258 }
2259
2260 /* warning: addr must be aligned */
2261 static inline uint32_t ldl_phys_internal(hwaddr addr,
2262                                          enum device_endian endian)
2263 {
2264     uint8_t *ptr;
2265     uint64_t val;
2266     MemoryRegion *mr;
2267     hwaddr l = 4;
2268     hwaddr addr1;
2269
2270     mr = address_space_translate(&address_space_memory, addr, &addr1, &l,
2271                                  false);
2272     if (l < 4 || !memory_access_is_direct(mr, false)) {
2273         /* I/O case */
2274         io_mem_read(mr, addr1, &val, 4);
2275 #if defined(TARGET_WORDS_BIGENDIAN)
2276         if (endian == DEVICE_LITTLE_ENDIAN) {
2277             val = bswap32(val);
2278         }
2279 #else
2280         if (endian == DEVICE_BIG_ENDIAN) {
2281             val = bswap32(val);
2282         }
2283 #endif
2284     } else {
2285         /* RAM case */
2286         ptr = qemu_get_ram_ptr((memory_region_get_ram_addr(mr)
2287                                 & TARGET_PAGE_MASK)
2288                                + addr1);
2289         switch (endian) {
2290         case DEVICE_LITTLE_ENDIAN:
2291             val = ldl_le_p(ptr);
2292             break;
2293         case DEVICE_BIG_ENDIAN:
2294             val = ldl_be_p(ptr);
2295             break;
2296         default:
2297             val = ldl_p(ptr);
2298             break;
2299         }
2300     }
2301     return val;
2302 }
2303
2304 uint32_t ldl_phys(hwaddr addr)
2305 {
2306     return ldl_phys_internal(addr, DEVICE_NATIVE_ENDIAN);
2307 }
2308
2309 uint32_t ldl_le_phys(hwaddr addr)
2310 {
2311     return ldl_phys_internal(addr, DEVICE_LITTLE_ENDIAN);
2312 }
2313
2314 uint32_t ldl_be_phys(hwaddr addr)
2315 {
2316     return ldl_phys_internal(addr, DEVICE_BIG_ENDIAN);
2317 }
2318
2319 /* warning: addr must be aligned */
2320 static inline uint64_t ldq_phys_internal(hwaddr addr,
2321                                          enum device_endian endian)
2322 {
2323     uint8_t *ptr;
2324     uint64_t val;
2325     MemoryRegion *mr;
2326     hwaddr l = 8;
2327     hwaddr addr1;
2328
2329     mr = address_space_translate(&address_space_memory, addr, &addr1, &l,
2330                                  false);
2331     if (l < 8 || !memory_access_is_direct(mr, false)) {
2332         /* I/O case */
2333         io_mem_read(mr, addr1, &val, 8);
2334 #if defined(TARGET_WORDS_BIGENDIAN)
2335         if (endian == DEVICE_LITTLE_ENDIAN) {
2336             val = bswap64(val);
2337         }
2338 #else
2339         if (endian == DEVICE_BIG_ENDIAN) {
2340             val = bswap64(val);
2341         }
2342 #endif
2343     } else {
2344         /* RAM case */
2345         ptr = qemu_get_ram_ptr((memory_region_get_ram_addr(mr)
2346                                 & TARGET_PAGE_MASK)
2347                                + addr1);
2348         switch (endian) {
2349         case DEVICE_LITTLE_ENDIAN:
2350             val = ldq_le_p(ptr);
2351             break;
2352         case DEVICE_BIG_ENDIAN:
2353             val = ldq_be_p(ptr);
2354             break;
2355         default:
2356             val = ldq_p(ptr);
2357             break;
2358         }
2359     }
2360     return val;
2361 }
2362
2363 uint64_t ldq_phys(hwaddr addr)
2364 {
2365     return ldq_phys_internal(addr, DEVICE_NATIVE_ENDIAN);
2366 }
2367
2368 uint64_t ldq_le_phys(hwaddr addr)
2369 {
2370     return ldq_phys_internal(addr, DEVICE_LITTLE_ENDIAN);
2371 }
2372
2373 uint64_t ldq_be_phys(hwaddr addr)
2374 {
2375     return ldq_phys_internal(addr, DEVICE_BIG_ENDIAN);
2376 }
2377
2378 /* XXX: optimize */
2379 uint32_t ldub_phys(hwaddr addr)
2380 {
2381     uint8_t val;
2382     cpu_physical_memory_read(addr, &val, 1);
2383     return val;
2384 }
2385
2386 /* warning: addr must be aligned */
2387 static inline uint32_t lduw_phys_internal(hwaddr addr,
2388                                           enum device_endian endian)
2389 {
2390     uint8_t *ptr;
2391     uint64_t val;
2392     MemoryRegion *mr;
2393     hwaddr l = 2;
2394     hwaddr addr1;
2395
2396     mr = address_space_translate(&address_space_memory, addr, &addr1, &l,
2397                                  false);
2398     if (l < 2 || !memory_access_is_direct(mr, false)) {
2399         /* I/O case */
2400         io_mem_read(mr, addr1, &val, 2);
2401 #if defined(TARGET_WORDS_BIGENDIAN)
2402         if (endian == DEVICE_LITTLE_ENDIAN) {
2403             val = bswap16(val);
2404         }
2405 #else
2406         if (endian == DEVICE_BIG_ENDIAN) {
2407             val = bswap16(val);
2408         }
2409 #endif
2410     } else {
2411         /* RAM case */
2412         ptr = qemu_get_ram_ptr((memory_region_get_ram_addr(mr)
2413                                 & TARGET_PAGE_MASK)
2414                                + addr1);
2415         switch (endian) {
2416         case DEVICE_LITTLE_ENDIAN:
2417             val = lduw_le_p(ptr);
2418             break;
2419         case DEVICE_BIG_ENDIAN:
2420             val = lduw_be_p(ptr);
2421             break;
2422         default:
2423             val = lduw_p(ptr);
2424             break;
2425         }
2426     }
2427     return val;
2428 }
2429
2430 uint32_t lduw_phys(hwaddr addr)
2431 {
2432     return lduw_phys_internal(addr, DEVICE_NATIVE_ENDIAN);
2433 }
2434
2435 uint32_t lduw_le_phys(hwaddr addr)
2436 {
2437     return lduw_phys_internal(addr, DEVICE_LITTLE_ENDIAN);
2438 }
2439
2440 uint32_t lduw_be_phys(hwaddr addr)
2441 {
2442     return lduw_phys_internal(addr, DEVICE_BIG_ENDIAN);
2443 }
2444
2445 /* warning: addr must be aligned. The ram page is not masked as dirty
2446    and the code inside is not invalidated. It is useful if the dirty
2447    bits are used to track modified PTEs */
2448 void stl_phys_notdirty(hwaddr addr, uint32_t val)
2449 {
2450     uint8_t *ptr;
2451     MemoryRegion *mr;
2452     hwaddr l = 4;
2453     hwaddr addr1;
2454
2455     mr = address_space_translate(&address_space_memory, addr, &addr1, &l,
2456                                  true);
2457     if (l < 4 || !memory_access_is_direct(mr, true)) {
2458         io_mem_write(mr, addr1, val, 4);
2459     } else {
2460         addr1 += memory_region_get_ram_addr(mr) & TARGET_PAGE_MASK;
2461         ptr = qemu_get_ram_ptr(addr1);
2462         stl_p(ptr, val);
2463
2464         if (unlikely(in_migration)) {
2465             if (!cpu_physical_memory_is_dirty(addr1)) {
2466                 /* invalidate code */
2467                 tb_invalidate_phys_page_range(addr1, addr1 + 4, 0);
2468                 /* set dirty bit */
2469                 cpu_physical_memory_set_dirty_flags(
2470                     addr1, (0xff & ~CODE_DIRTY_FLAG));
2471             }
2472         }
2473     }
2474 }
2475
2476 /* warning: addr must be aligned */
2477 static inline void stl_phys_internal(hwaddr addr, uint32_t val,
2478                                      enum device_endian endian)
2479 {
2480     uint8_t *ptr;
2481     MemoryRegion *mr;
2482     hwaddr l = 4;
2483     hwaddr addr1;
2484
2485     mr = address_space_translate(&address_space_memory, addr, &addr1, &l,
2486                                  true);
2487     if (l < 4 || !memory_access_is_direct(mr, true)) {
2488 #if defined(TARGET_WORDS_BIGENDIAN)
2489         if (endian == DEVICE_LITTLE_ENDIAN) {
2490             val = bswap32(val);
2491         }
2492 #else
2493         if (endian == DEVICE_BIG_ENDIAN) {
2494             val = bswap32(val);
2495         }
2496 #endif
2497         io_mem_write(mr, addr1, val, 4);
2498     } else {
2499         /* RAM case */
2500         addr1 += memory_region_get_ram_addr(mr) & TARGET_PAGE_MASK;
2501         ptr = qemu_get_ram_ptr(addr1);
2502         switch (endian) {
2503         case DEVICE_LITTLE_ENDIAN:
2504             stl_le_p(ptr, val);
2505             break;
2506         case DEVICE_BIG_ENDIAN:
2507             stl_be_p(ptr, val);
2508             break;
2509         default:
2510             stl_p(ptr, val);
2511             break;
2512         }
2513         invalidate_and_set_dirty(addr1, 4);
2514     }
2515 }
2516
2517 void stl_phys(hwaddr addr, uint32_t val)
2518 {
2519     stl_phys_internal(addr, val, DEVICE_NATIVE_ENDIAN);
2520 }
2521
2522 void stl_le_phys(hwaddr addr, uint32_t val)
2523 {
2524     stl_phys_internal(addr, val, DEVICE_LITTLE_ENDIAN);
2525 }
2526
2527 void stl_be_phys(hwaddr addr, uint32_t val)
2528 {
2529     stl_phys_internal(addr, val, DEVICE_BIG_ENDIAN);
2530 }
2531
2532 /* XXX: optimize */
2533 void stb_phys(hwaddr addr, uint32_t val)
2534 {
2535     uint8_t v = val;
2536     cpu_physical_memory_write(addr, &v, 1);
2537 }
2538
2539 /* warning: addr must be aligned */
2540 static inline void stw_phys_internal(hwaddr addr, uint32_t val,
2541                                      enum device_endian endian)
2542 {
2543     uint8_t *ptr;
2544     MemoryRegion *mr;
2545     hwaddr l = 2;
2546     hwaddr addr1;
2547
2548     mr = address_space_translate(&address_space_memory, addr, &addr1, &l,
2549                                  true);
2550     if (l < 2 || !memory_access_is_direct(mr, true)) {
2551 #if defined(TARGET_WORDS_BIGENDIAN)
2552         if (endian == DEVICE_LITTLE_ENDIAN) {
2553             val = bswap16(val);
2554         }
2555 #else
2556         if (endian == DEVICE_BIG_ENDIAN) {
2557             val = bswap16(val);
2558         }
2559 #endif
2560         io_mem_write(mr, addr1, val, 2);
2561     } else {
2562         /* RAM case */
2563         addr1 += memory_region_get_ram_addr(mr) & TARGET_PAGE_MASK;
2564         ptr = qemu_get_ram_ptr(addr1);
2565         switch (endian) {
2566         case DEVICE_LITTLE_ENDIAN:
2567             stw_le_p(ptr, val);
2568             break;
2569         case DEVICE_BIG_ENDIAN:
2570             stw_be_p(ptr, val);
2571             break;
2572         default:
2573             stw_p(ptr, val);
2574             break;
2575         }
2576         invalidate_and_set_dirty(addr1, 2);
2577     }
2578 }
2579
2580 void stw_phys(hwaddr addr, uint32_t val)
2581 {
2582     stw_phys_internal(addr, val, DEVICE_NATIVE_ENDIAN);
2583 }
2584
2585 void stw_le_phys(hwaddr addr, uint32_t val)
2586 {
2587     stw_phys_internal(addr, val, DEVICE_LITTLE_ENDIAN);
2588 }
2589
2590 void stw_be_phys(hwaddr addr, uint32_t val)
2591 {
2592     stw_phys_internal(addr, val, DEVICE_BIG_ENDIAN);
2593 }
2594
2595 /* XXX: optimize */
2596 void stq_phys(hwaddr addr, uint64_t val)
2597 {
2598     val = tswap64(val);
2599     cpu_physical_memory_write(addr, &val, 8);
2600 }
2601
2602 void stq_le_phys(hwaddr addr, uint64_t val)
2603 {
2604     val = cpu_to_le64(val);
2605     cpu_physical_memory_write(addr, &val, 8);
2606 }
2607
2608 void stq_be_phys(hwaddr addr, uint64_t val)
2609 {
2610     val = cpu_to_be64(val);
2611     cpu_physical_memory_write(addr, &val, 8);
2612 }
2613
2614 /* virtual memory access for debug (includes writing to ROM) */
2615 int cpu_memory_rw_debug(CPUState *cpu, target_ulong addr,
2616                         uint8_t *buf, int len, int is_write)
2617 {
2618     int l;
2619     hwaddr phys_addr;
2620     target_ulong page;
2621
2622     while (len > 0) {
2623         page = addr & TARGET_PAGE_MASK;
2624         phys_addr = cpu_get_phys_page_debug(cpu, page);
2625         /* if no physical page mapped, return an error */
2626         if (phys_addr == -1)
2627             return -1;
2628         l = (page + TARGET_PAGE_SIZE) - addr;
2629         if (l > len)
2630             l = len;
2631         phys_addr += (addr & ~TARGET_PAGE_MASK);
2632         if (is_write)
2633             cpu_physical_memory_write_rom(phys_addr, buf, l);
2634         else
2635             cpu_physical_memory_rw(phys_addr, buf, l, is_write);
2636         len -= l;
2637         buf += l;
2638         addr += l;
2639     }
2640     return 0;
2641 }
2642 #endif
2643
2644 #if !defined(CONFIG_USER_ONLY)
2645
2646 /*
2647  * A helper function for the _utterly broken_ virtio device model to find out if
2648  * it's running on a big endian machine. Don't do this at home kids!
2649  */
2650 bool virtio_is_big_endian(void);
2651 bool virtio_is_big_endian(void)
2652 {
2653 #if defined(TARGET_WORDS_BIGENDIAN)
2654     return true;
2655 #else
2656     return false;
2657 #endif
2658 }
2659
2660 #endif
2661
2662 #ifndef CONFIG_USER_ONLY
2663 bool cpu_physical_memory_is_io(hwaddr phys_addr)
2664 {
2665     MemoryRegion*mr;
2666     hwaddr l = 1;
2667
2668     mr = address_space_translate(&address_space_memory,
2669                                  phys_addr, &phys_addr, &l, false);
2670
2671     return !(memory_region_is_ram(mr) ||
2672              memory_region_is_romd(mr));
2673 }
2674
2675 void qemu_ram_foreach_block(RAMBlockIterFunc func, void *opaque)
2676 {
2677     RAMBlock *block;
2678
2679     QTAILQ_FOREACH(block, &ram_list.blocks, next) {
2680         func(block->host, block->offset, block->length, opaque);
2681     }
2682 }
2683 #endif