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