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