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