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 #ifndef _WIN32
  21 #include <sys/types.h>
  22 #include <sys/mman.h>
  23 #endif
  24
  25 #include "qemu-common.h"
  26 #include "cpu.h"
  27 #include "tcg.h"
  28 #include "hw/hw.h"
  29 #include "hw/qdev.h"
  30 #include "qemu/osdep.h"
  31 #include "sysemu/kvm.h"
  32 #include "sysemu/sysemu.h"
  33 #include "hw/xen/xen.h"
  34 #include "qemu/timer.h"
  35 #include "qemu/config-file.h"
  36 #include "qemu/error-report.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 #include "qemu/rcu_queue.h"
  48 #include "exec/cputlb.h"
  49 #include "translate-all.h"
  50
  51 #include "exec/memory-internal.h"
  52 #include "exec/ram_addr.h"
  53
  54 #include "qemu/range.h"
  55
  56 //#define DEBUG_SUBPAGE
  57
  58 #if !defined(CONFIG_USER_ONLY)
  59 static bool in_migration;
  60
  61 /* ram_list is read under rcu_read_lock()/rcu_read_unlock().  Writes
  62  * are protected by the ramlist lock.
  63  */
  64 RAMList ram_list = { .blocks = QLIST_HEAD_INITIALIZER(ram_list.blocks) };
  65
  66 static MemoryRegion *system_memory;
  67 static MemoryRegion *system_io;
  68
  69 AddressSpace address_space_io;
  70 AddressSpace address_space_memory;
  71
  72 MemoryRegion io_mem_rom, io_mem_notdirty;
  73 static MemoryRegion io_mem_unassigned;
  74
  75 /* RAM is pre-allocated and passed into qemu_ram_alloc_from_ptr */
  76 #define RAM_PREALLOC   (1 << 0)
  77
  78 /* RAM is mmap-ed with MAP_SHARED */
  79 #define RAM_SHARED     (1 << 1)
  80
  81 /* Only a portion of RAM (used_length) is actually used, and migrated.
  82  * This used_length size can change across reboots.
  83  */
  84 #define RAM_RESIZEABLE (1 << 2)
  85
  86 #endif
  87
  88 struct CPUTailQ cpus = QTAILQ_HEAD_INITIALIZER(cpus);
  89 /* current CPU in the current thread. It is only valid inside
  90    cpu_exec() */
  91 DEFINE_TLS(CPUState *, current_cpu);
  92 /* 0 = Do not count executed instructions.
  93    1 = Precise instruction counting.
  94    2 = Adaptive rate instruction counting.  */
  95 int use_icount;
  96
  97 #if !defined(CONFIG_USER_ONLY)
  98
  99 typedef struct PhysPageEntry PhysPageEntry;
 100
 101 struct PhysPageEntry {
 102     /* How many bits skip to next level (in units of L2_SIZE). 0 for a leaf. */
 103     uint32_t skip : 6;
 104      /* index into phys_sections (!skip) or phys_map_nodes (skip) */
 105     uint32_t ptr : 26;
 106 };
 107
 108 #define PHYS_MAP_NODE_NIL (((uint32_t)~0) >> 6)
 109
 110 /* Size of the L2 (and L3, etc) page tables.  */
 111 #define ADDR_SPACE_BITS 64
 112
 113 #define P_L2_BITS 9
 114 #define P_L2_SIZE (1 << P_L2_BITS)
 115
 116 #define P_L2_LEVELS (((ADDR_SPACE_BITS - TARGET_PAGE_BITS - 1) / P_L2_BITS) + 1)
 117
 118 typedef PhysPageEntry Node[P_L2_SIZE];
 119
 120 typedef struct PhysPageMap {
 121     struct rcu_head rcu;
 122
 123     unsigned sections_nb;
 124     unsigned sections_nb_alloc;
 125     unsigned nodes_nb;
 126     unsigned nodes_nb_alloc;
 127     Node *nodes;
 128     MemoryRegionSection *sections;
 129 } PhysPageMap;
 130
 131 struct AddressSpaceDispatch {
 132     struct rcu_head rcu;
 133
 134     /* This is a multi-level map on the physical address space.
 135      * The bottom level has pointers to MemoryRegionSections.
 136      */
 137     PhysPageEntry phys_map;
 138     PhysPageMap map;
 139     AddressSpace *as;
 140 };
 141
 142 #define SUBPAGE_IDX(addr) ((addr) & ~TARGET_PAGE_MASK)
 143 typedef struct subpage_t {
 144     MemoryRegion iomem;
 145     AddressSpace *as;
 146     hwaddr base;
 147     uint16_t sub_section[TARGET_PAGE_SIZE];
 148 } subpage_t;
 149
 150 #define PHYS_SECTION_UNASSIGNED 0
 151 #define PHYS_SECTION_NOTDIRTY 1
 152 #define PHYS_SECTION_ROM 2
 153 #define PHYS_SECTION_WATCH 3
 154
 155 static void io_mem_init(void);
 156 static void memory_map_init(void);
 157 static void tcg_commit(MemoryListener *listener);
 158
 159 static MemoryRegion io_mem_watch;
 160 #endif
 161
 162 #if !defined(CONFIG_USER_ONLY)
 163
 164 static void phys_map_node_reserve(PhysPageMap *map, unsigned nodes)
 165 {
 166     if (map->nodes_nb + nodes > map->nodes_nb_alloc) {
 167         map->nodes_nb_alloc = MAX(map->nodes_nb_alloc * 2, 16);
 168         map->nodes_nb_alloc = MAX(map->nodes_nb_alloc, map->nodes_nb + nodes);
 169         map->nodes = g_renew(Node, map->nodes, map->nodes_nb_alloc);
 170     }
 171 }
 172
 173 static uint32_t phys_map_node_alloc(PhysPageMap *map)
 174 {
 175     unsigned i;
 176     uint32_t ret;
 177
 178     ret = map->nodes_nb++;
 179     assert(ret != PHYS_MAP_NODE_NIL);
 180     assert(ret != map->nodes_nb_alloc);
 181     for (i = 0; i < P_L2_SIZE; ++i) {
 182         map->nodes[ret][i].skip = 1;
 183         map->nodes[ret][i].ptr = PHYS_MAP_NODE_NIL;
 184     }
 185     return ret;
 186 }
 187
 188 static void phys_page_set_level(PhysPageMap *map, PhysPageEntry *lp,
 189                                 hwaddr *index, hwaddr *nb, uint16_t leaf,
 190                                 int level)
 191 {
 192     PhysPageEntry *p;
 193     int i;
 194     hwaddr step = (hwaddr)1 << (level * P_L2_BITS);
 195
 196     if (lp->skip && lp->ptr == PHYS_MAP_NODE_NIL) {
 197         lp->ptr = phys_map_node_alloc(map);
 198         p = map->nodes[lp->ptr];
 199         if (level == 0) {
 200             for (i = 0; i < P_L2_SIZE; i++) {
 201                 p[i].skip = 0;
 202                 p[i].ptr = PHYS_SECTION_UNASSIGNED;
 203             }
 204         }
 205     } else {
 206         p = map->nodes[lp->ptr];
 207     }
 208     lp = &p[(*index >> (level * P_L2_BITS)) & (P_L2_SIZE - 1)];
 209
 210     while (*nb && lp < &p[P_L2_SIZE]) {
 211         if ((*index & (step - 1)) == 0 && *nb >= step) {
 212             lp->skip = 0;
 213             lp->ptr = leaf;
 214             *index += step;
 215             *nb -= step;
 216         } else {
 217             phys_page_set_level(map, lp, index, nb, leaf, level - 1);
 218         }
 219         ++lp;
 220     }
 221 }
 222
 223 static void phys_page_set(AddressSpaceDispatch *d,
 224                           hwaddr index, hwaddr nb,
 225                           uint16_t leaf)
 226 {
 227     /* Wildly overreserve - it doesn't matter much. */
 228     phys_map_node_reserve(&d->map, 3 * P_L2_LEVELS);
 229
 230     phys_page_set_level(&d->map, &d->phys_map, &index, &nb, leaf, P_L2_LEVELS - 1);
 231 }
 232
 233 /* Compact a non leaf page entry. Simply detect that the entry has a single child,
 234  * and update our entry so we can skip it and go directly to the destination.
 235  */
 236 static void phys_page_compact(PhysPageEntry *lp, Node *nodes, unsigned long *compacted)
 237 {
 238     unsigned valid_ptr = P_L2_SIZE;
 239     int valid = 0;
 240     PhysPageEntry *p;
 241     int i;
 242
 243     if (lp->ptr == PHYS_MAP_NODE_NIL) {
 244         return;
 245     }
 246
 247     p = nodes[lp->ptr];
 248     for (i = 0; i < P_L2_SIZE; i++) {
 249         if (p[i].ptr == PHYS_MAP_NODE_NIL) {
 250             continue;
 251         }
 252
 253         valid_ptr = i;
 254         valid++;
 255         if (p[i].skip) {
 256             phys_page_compact(&p[i], nodes, compacted);
 257         }
 258     }
 259
 260     /* We can only compress if there's only one child. */
 261     if (valid != 1) {
 262         return;
 263     }
 264
 265     assert(valid_ptr < P_L2_SIZE);
 266
 267     /* Don't compress if it won't fit in the # of bits we have. */
 268     if (lp->skip + p[valid_ptr].skip >= (1 << 3)) {
 269         return;
 270     }
 271
 272     lp->ptr = p[valid_ptr].ptr;
 273     if (!p[valid_ptr].skip) {
 274         /* If our only child is a leaf, make this a leaf. */
 275         /* By design, we should have made this node a leaf to begin with so we
 276          * should never reach here.
 277          * But since it's so simple to handle this, let's do it just in case we
 278          * change this rule.
 279          */
 280         lp->skip = 0;
 281     } else {
 282         lp->skip += p[valid_ptr].skip;
 283     }
 284 }
 285
 286 static void phys_page_compact_all(AddressSpaceDispatch *d, int nodes_nb)
 287 {
 288     DECLARE_BITMAP(compacted, nodes_nb);
 289
 290     if (d->phys_map.skip) {
 291         phys_page_compact(&d->phys_map, d->map.nodes, compacted);
 292     }
 293 }
 294
 295 static MemoryRegionSection *phys_page_find(PhysPageEntry lp, hwaddr addr,
 296                                            Node *nodes, MemoryRegionSection *sections)
 297 {
 298     PhysPageEntry *p;
 299     hwaddr index = addr >> TARGET_PAGE_BITS;
 300     int i;
 301
 302     for (i = P_L2_LEVELS; lp.skip && (i -= lp.skip) >= 0;) {
 303         if (lp.ptr == PHYS_MAP_NODE_NIL) {
 304             return &sections[PHYS_SECTION_UNASSIGNED];
 305         }
 306         p = nodes[lp.ptr];
 307         lp = p[(index >> (i * P_L2_BITS)) & (P_L2_SIZE - 1)];
 308     }
 309
 310     if (sections[lp.ptr].size.hi ||
 311         range_covers_byte(sections[lp.ptr].offset_within_address_space,
 312                           sections[lp.ptr].size.lo, addr)) {
 313         return &sections[lp.ptr];
 314     } else {
 315         return &sections[PHYS_SECTION_UNASSIGNED];
 316     }
 317 }
 318
 319 bool memory_region_is_unassigned(MemoryRegion *mr)
 320 {
 321     return mr != &io_mem_rom && mr != &io_mem_notdirty && !mr->rom_device
 322         && mr != &io_mem_watch;
 323 }
 324
 325 /* Called from RCU critical section */
 326 static MemoryRegionSection *address_space_lookup_region(AddressSpaceDispatch *d,
 327                                                         hwaddr addr,
 328                                                         bool resolve_subpage)
 329 {
 330     MemoryRegionSection *section;
 331     subpage_t *subpage;
 332
 333     section = phys_page_find(d->phys_map, addr, d->map.nodes, d->map.sections);
 334     if (resolve_subpage && section->mr->subpage) {
 335         subpage = container_of(section->mr, subpage_t, iomem);
 336         section = &d->map.sections[subpage->sub_section[SUBPAGE_IDX(addr)]];
 337     }
 338     return section;
 339 }
 340
 341 /* Called from RCU critical section */
 342 static MemoryRegionSection *
 343 address_space_translate_internal(AddressSpaceDispatch *d, hwaddr addr, hwaddr *xlat,
 344                                  hwaddr *plen, bool resolve_subpage)
 345 {
 346     MemoryRegionSection *section;
 347     Int128 diff;
 348
 349     section = address_space_lookup_region(d, addr, resolve_subpage);
 350     /* Compute offset within MemoryRegionSection */
 351     addr -= section->offset_within_address_space;
 352
 353     /* Compute offset within MemoryRegion */
 354     *xlat = addr + section->offset_within_region;
 355
 356     diff = int128_sub(section->mr->size, int128_make64(addr));
 357     *plen = int128_get64(int128_min(diff, int128_make64(*plen)));
 358     return section;
 359 }
 360
 361 static inline bool memory_access_is_direct(MemoryRegion *mr, bool is_write)
 362 {
 363     if (memory_region_is_ram(mr)) {
 364         return !(is_write && mr->readonly);
 365     }
 366     if (memory_region_is_romd(mr)) {
 367         return !is_write;
 368     }
 369
 370     return false;
 371 }
 372
 373 MemoryRegion *address_space_translate(AddressSpace *as, hwaddr addr,
 374                                       hwaddr *xlat, hwaddr *plen,
 375                                       bool is_write)
 376 {
 377     IOMMUTLBEntry iotlb;
 378     MemoryRegionSection *section;
 379     MemoryRegion *mr;
 380     hwaddr len = *plen;
 381
 382     rcu_read_lock();
 383     for (;;) {
 384         AddressSpaceDispatch *d = atomic_rcu_read(&as->dispatch);
 385         section = address_space_translate_internal(d, addr, &addr, plen, true);
 386         mr = section->mr;
 387
 388         if (!mr->iommu_ops) {
 389             break;
 390         }
 391
 392         iotlb = mr->iommu_ops->translate(mr, addr, is_write);
 393         addr = ((iotlb.translated_addr & ~iotlb.addr_mask)
 394                 | (addr & iotlb.addr_mask));
 395         len = MIN(len, (addr | iotlb.addr_mask) - addr + 1);
 396         if (!(iotlb.perm & (1 << is_write))) {
 397             mr = &io_mem_unassigned;
 398             break;
 399         }
 400
 401         as = iotlb.target_as;
 402     }
 403
 404     if (xen_enabled() && memory_access_is_direct(mr, is_write)) {
 405         hwaddr page = ((addr & TARGET_PAGE_MASK) + TARGET_PAGE_SIZE) - addr;
 406         len = MIN(page, len);
 407     }
 408
 409     *plen = len;
 410     *xlat = addr;
 411     rcu_read_unlock();
 412     return mr;
 413 }
 414
 415 /* Called from RCU critical section */
 416 MemoryRegionSection *
 417 address_space_translate_for_iotlb(CPUState *cpu, hwaddr addr,
 418                                   hwaddr *xlat, hwaddr *plen)
 419 {
 420     MemoryRegionSection *section;
 421     section = address_space_translate_internal(cpu->memory_dispatch,
 422                                                addr, xlat, plen, false);
 423
 424     assert(!section->mr->iommu_ops);
 425     return section;
 426 }
 427 #endif
 428
 429 void cpu_exec_init_all(void)
 430 {
 431 #if !defined(CONFIG_USER_ONLY)
 432     qemu_mutex_init(&ram_list.mutex);
 433     memory_map_init();
 434     io_mem_init();
 435 #endif
 436 }
 437
 438 #if !defined(CONFIG_USER_ONLY)
 439
 440 static int cpu_common_post_load(void *opaque, int version_id)
 441 {
 442     CPUState *cpu = opaque;
 443
 444     /* 0x01 was CPU_INTERRUPT_EXIT. This line can be removed when the
 445        version_id is increased. */
 446     cpu->interrupt_request &= ~0x01;
 447     tlb_flush(cpu, 1);
 448
 449     return 0;
 450 }
 451
 452 static int cpu_common_pre_load(void *opaque)
 453 {
 454     CPUState *cpu = opaque;
 455
 456     cpu->exception_index = -1;
 457
 458     return 0;
 459 }
 460
 461 static bool cpu_common_exception_index_needed(void *opaque)
 462 {
 463     CPUState *cpu = opaque;
 464
 465     return tcg_enabled() && cpu->exception_index != -1;
 466 }
 467
 468 static const VMStateDescription vmstate_cpu_common_exception_index = {
 469     .name = "cpu_common/exception_index",
 470     .version_id = 1,
 471     .minimum_version_id = 1,
 472     .fields = (VMStateField[]) {
 473         VMSTATE_INT32(exception_index, CPUState),
 474         VMSTATE_END_OF_LIST()
 475     }
 476 };
 477
 478 const VMStateDescription vmstate_cpu_common = {
 479     .name = "cpu_common",
 480     .version_id = 1,
 481     .minimum_version_id = 1,
 482     .pre_load = cpu_common_pre_load,
 483     .post_load = cpu_common_post_load,
 484     .fields = (VMStateField[]) {
 485         VMSTATE_UINT32(halted, CPUState),
 486         VMSTATE_UINT32(interrupt_request, CPUState),
 487         VMSTATE_END_OF_LIST()
 488     },
 489     .subsections = (VMStateSubsection[]) {
 490         {
 491             .vmsd = &vmstate_cpu_common_exception_index,
 492             .needed = cpu_common_exception_index_needed,
 493         } , {
 494             /* empty */
 495         }
 496     }
 497 };
 498
 499 #endif
 500
 501 CPUState *qemu_get_cpu(int index)
 502 {
 503     CPUState *cpu;
 504
 505     CPU_FOREACH(cpu) {
 506         if (cpu->cpu_index == index) {
 507             return cpu;
 508         }
 509     }
 510
 511     return NULL;
 512 }
 513
 514 #if !defined(CONFIG_USER_ONLY)
 515 void tcg_cpu_address_space_init(CPUState *cpu, AddressSpace *as)
 516 {
 517     /* We only support one address space per cpu at the moment.  */
 518     assert(cpu->as == as);
 519
 520     if (cpu->tcg_as_listener) {
 521         memory_listener_unregister(cpu->tcg_as_listener);
 522     } else {
 523         cpu->tcg_as_listener = g_new0(MemoryListener, 1);
 524     }
 525     cpu->tcg_as_listener->commit = tcg_commit;
 526     memory_listener_register(cpu->tcg_as_listener, as);
 527 }
 528 #endif
 529
 530 void cpu_exec_init(CPUArchState *env)
 531 {
 532     CPUState *cpu = ENV_GET_CPU(env);
 533     CPUClass *cc = CPU_GET_CLASS(cpu);
 534     CPUState *some_cpu;
 535     int cpu_index;
 536
 537 #if defined(CONFIG_USER_ONLY)
 538     cpu_list_lock();
 539 #endif
 540     cpu_index = 0;
 541     CPU_FOREACH(some_cpu) {
 542         cpu_index++;
 543     }
 544     cpu->cpu_index = cpu_index;
 545     cpu->numa_node = 0;
 546     QTAILQ_INIT(&cpu->breakpoints);
 547     QTAILQ_INIT(&cpu->watchpoints);
 548 #ifndef CONFIG_USER_ONLY
 549     cpu->as = &address_space_memory;
 550     cpu->thread_id = qemu_get_thread_id();
 551 #endif
 552     QTAILQ_INSERT_TAIL(&cpus, cpu, node);
 553 #if defined(CONFIG_USER_ONLY)
 554     cpu_list_unlock();
 555 #endif
 556     if (qdev_get_vmsd(DEVICE(cpu)) == NULL) {
 557         vmstate_register(NULL, cpu_index, &vmstate_cpu_common, cpu);
 558     }
 559 #if defined(CPU_SAVE_VERSION) && !defined(CONFIG_USER_ONLY)
 560     register_savevm(NULL, "cpu", cpu_index, CPU_SAVE_VERSION,
 561                     cpu_save, cpu_load, env);
 562     assert(cc->vmsd == NULL);
 563     assert(qdev_get_vmsd(DEVICE(cpu)) == NULL);
 564 #endif
 565     if (cc->vmsd != NULL) {
 566         vmstate_register(NULL, cpu_index, cc->vmsd, cpu);
 567     }
 568 }
 569
 570 #if defined(CONFIG_USER_ONLY)
 571 static void breakpoint_invalidate(CPUState *cpu, target_ulong pc)
 572 {
 573     tb_invalidate_phys_page_range(pc, pc + 1, 0);
 574 }
 575 #else
 576 static void breakpoint_invalidate(CPUState *cpu, target_ulong pc)
 577 {
 578     hwaddr phys = cpu_get_phys_page_debug(cpu, pc);
 579     if (phys != -1) {
 580         tb_invalidate_phys_addr(cpu->as,
 581                                 phys | (pc & ~TARGET_PAGE_MASK));
 582     }
 583 }
 584 #endif
 585
 586 #if defined(CONFIG_USER_ONLY)
 587 void cpu_watchpoint_remove_all(CPUState *cpu, int mask)
 588
 589 {
 590 }
 591
 592 int cpu_watchpoint_remove(CPUState *cpu, vaddr addr, vaddr len,
 593                           int flags)
 594 {
 595     return -ENOSYS;
 596 }
 597
 598 void cpu_watchpoint_remove_by_ref(CPUState *cpu, CPUWatchpoint *watchpoint)
 599 {
 600 }
 601
 602 int cpu_watchpoint_insert(CPUState *cpu, vaddr addr, vaddr len,
 603                           int flags, CPUWatchpoint **watchpoint)
 604 {
 605     return -ENOSYS;
 606 }
 607 #else
 608 /* Add a watchpoint.  */
 609 int cpu_watchpoint_insert(CPUState *cpu, vaddr addr, vaddr len,
 610                           int flags, CPUWatchpoint **watchpoint)
 611 {
 612     CPUWatchpoint *wp;
 613
 614     /* forbid ranges which are empty or run off the end of the address space */
 615     if (len == 0 || (addr + len - 1) < addr) {
 616         error_report("tried to set invalid watchpoint at %"
 617                      VADDR_PRIx ", len=%" VADDR_PRIu, addr, len);
 618         return -EINVAL;
 619     }
 620     wp = g_malloc(sizeof(*wp));
 621
 622     wp->vaddr = addr;
 623     wp->len = len;
 624     wp->flags = flags;
 625
 626     /* keep all GDB-injected watchpoints in front */
 627     if (flags & BP_GDB) {
 628         QTAILQ_INSERT_HEAD(&cpu->watchpoints, wp, entry);
 629     } else {
 630         QTAILQ_INSERT_TAIL(&cpu->watchpoints, wp, entry);
 631     }
 632
 633     tlb_flush_page(cpu, addr);
 634
 635     if (watchpoint)
 636         *watchpoint = wp;
 637     return 0;
 638 }
 639
 640 /* Remove a specific watchpoint.  */
 641 int cpu_watchpoint_remove(CPUState *cpu, vaddr addr, vaddr len,
 642                           int flags)
 643 {
 644     CPUWatchpoint *wp;
 645
 646     QTAILQ_FOREACH(wp, &cpu->watchpoints, entry) {
 647         if (addr == wp->vaddr && len == wp->len
 648                 && flags == (wp->flags & ~BP_WATCHPOINT_HIT)) {
 649             cpu_watchpoint_remove_by_ref(cpu, wp);
 650             return 0;
 651         }
 652     }
 653     return -ENOENT;
 654 }
 655
 656 /* Remove a specific watchpoint by reference.  */
 657 void cpu_watchpoint_remove_by_ref(CPUState *cpu, CPUWatchpoint *watchpoint)
 658 {
 659     QTAILQ_REMOVE(&cpu->watchpoints, watchpoint, entry);
 660
 661     tlb_flush_page(cpu, watchpoint->vaddr);
 662
 663     g_free(watchpoint);
 664 }
 665
 666 /* Remove all matching watchpoints.  */
 667 void cpu_watchpoint_remove_all(CPUState *cpu, int mask)
 668 {
 669     CPUWatchpoint *wp, *next;
 670
 671     QTAILQ_FOREACH_SAFE(wp, &cpu->watchpoints, entry, next) {
 672         if (wp->flags & mask) {
 673             cpu_watchpoint_remove_by_ref(cpu, wp);
 674         }
 675     }
 676 }
 677
 678 /* Return true if this watchpoint address matches the specified
 679  * access (ie the address range covered by the watchpoint overlaps
 680  * partially or completely with the address range covered by the
 681  * access).
 682  */
 683 static inline bool cpu_watchpoint_address_matches(CPUWatchpoint *wp,
 684                                                   vaddr addr,
 685                                                   vaddr len)
 686 {
 687     /* We know the lengths are non-zero, but a little caution is
 688      * required to avoid errors in the case where the range ends
 689      * exactly at the top of the address space and so addr + len
 690      * wraps round to zero.
 691      */
 692     vaddr wpend = wp->vaddr + wp->len - 1;
 693     vaddr addrend = addr + len - 1;
 694
 695     return !(addr > wpend || wp->vaddr > addrend);
 696 }
 697
 698 #endif
 699
 700 /* Add a breakpoint.  */
 701 int cpu_breakpoint_insert(CPUState *cpu, vaddr pc, int flags,
 702                           CPUBreakpoint **breakpoint)
 703 {
 704     CPUBreakpoint *bp;
 705
 706     bp = g_malloc(sizeof(*bp));
 707
 708     bp->pc = pc;
 709     bp->flags = flags;
 710
 711     /* keep all GDB-injected breakpoints in front */
 712     if (flags & BP_GDB) {
 713         QTAILQ_INSERT_HEAD(&cpu->breakpoints, bp, entry);
 714     } else {
 715         QTAILQ_INSERT_TAIL(&cpu->breakpoints, bp, entry);
 716     }
 717
 718     breakpoint_invalidate(cpu, pc);
 719
 720     if (breakpoint) {
 721         *breakpoint = bp;
 722     }
 723     return 0;
 724 }
 725
 726 /* Remove a specific breakpoint.  */
 727 int cpu_breakpoint_remove(CPUState *cpu, vaddr pc, int flags)
 728 {
 729     CPUBreakpoint *bp;
 730
 731     QTAILQ_FOREACH(bp, &cpu->breakpoints, entry) {
 732         if (bp->pc == pc && bp->flags == flags) {
 733             cpu_breakpoint_remove_by_ref(cpu, bp);
 734             return 0;
 735         }
 736     }
 737     return -ENOENT;
 738 }
 739
 740 /* Remove a specific breakpoint by reference.  */
 741 void cpu_breakpoint_remove_by_ref(CPUState *cpu, CPUBreakpoint *breakpoint)
 742 {
 743     QTAILQ_REMOVE(&cpu->breakpoints, breakpoint, entry);
 744
 745     breakpoint_invalidate(cpu, breakpoint->pc);
 746
 747     g_free(breakpoint);
 748 }
 749
 750 /* Remove all matching breakpoints. */
 751 void cpu_breakpoint_remove_all(CPUState *cpu, int mask)
 752 {
 753     CPUBreakpoint *bp, *next;
 754
 755     QTAILQ_FOREACH_SAFE(bp, &cpu->breakpoints, entry, next) {
 756         if (bp->flags & mask) {
 757             cpu_breakpoint_remove_by_ref(cpu, bp);
 758         }
 759     }
 760 }
 761
 762 /* enable or disable single step mode. EXCP_DEBUG is returned by the
 763    CPU loop after each instruction */
 764 void cpu_single_step(CPUState *cpu, int enabled)
 765 {
 766     if (cpu->singlestep_enabled != enabled) {
 767         cpu->singlestep_enabled = enabled;
 768         if (kvm_enabled()) {
 769             kvm_update_guest_debug(cpu, 0);
 770         } else {
 771             /* must flush all the translated code to avoid inconsistencies */
 772             /* XXX: only flush what is necessary */
 773             CPUArchState *env = cpu->env_ptr;
 774             tb_flush(env);
 775         }
 776     }
 777 }
 778
 779 void cpu_abort(CPUState *cpu, const char *fmt, ...)
 780 {
 781     va_list ap;
 782     va_list ap2;
 783
 784     va_start(ap, fmt);
 785     va_copy(ap2, ap);
 786     fprintf(stderr, "qemu: fatal: ");
 787     vfprintf(stderr, fmt, ap);
 788     fprintf(stderr, "\n");
 789     cpu_dump_state(cpu, stderr, fprintf, CPU_DUMP_FPU | CPU_DUMP_CCOP);
 790     if (qemu_log_enabled()) {
 791         qemu_log("qemu: fatal: ");
 792         qemu_log_vprintf(fmt, ap2);
 793         qemu_log("\n");
 794         log_cpu_state(cpu, CPU_DUMP_FPU | CPU_DUMP_CCOP);
 795         qemu_log_flush();
 796         qemu_log_close();
 797     }
 798     va_end(ap2);
 799     va_end(ap);
 800 #if defined(CONFIG_USER_ONLY)
 801     {
 802         struct sigaction act;
 803         sigfillset(&act.sa_mask);
 804         act.sa_handler = SIG_DFL;
 805         sigaction(SIGABRT, &act, NULL);
 806     }
 807 #endif
 808     abort();
 809 }
 810
 811 #if !defined(CONFIG_USER_ONLY)
 812 /* Called from RCU critical section */
 813 static RAMBlock *qemu_get_ram_block(ram_addr_t addr)
 814 {
 815     RAMBlock *block;
 816
 817     block = atomic_rcu_read(&ram_list.mru_block);
 818     if (block && addr - block->offset < block->max_length) {
 819         goto found;
 820     }
 821     QLIST_FOREACH_RCU(block, &ram_list.blocks, next) {
 822         if (addr - block->offset < block->max_length) {
 823             goto found;
 824         }
 825     }
 826
 827     fprintf(stderr, "Bad ram offset %" PRIx64 "\n", (uint64_t)addr);
 828     abort();
 829
 830 found:
 831     /* It is safe to write mru_block outside the iothread lock.  This
 832      * is what happens:
 833      *
 834      *     mru_block = xxx
 835      *     rcu_read_unlock()
 836      *                                        xxx removed from list
 837      *                  rcu_read_lock()
 838      *                  read mru_block
 839      *                                        mru_block = NULL;
 840      *                                        call_rcu(reclaim_ramblock, xxx);
 841      *                  rcu_read_unlock()
 842      *
 843      * atomic_rcu_set is not needed here.  The block was already published
 844      * when it was placed into the list.  Here we're just making an extra
 845      * copy of the pointer.
 846      */
 847     ram_list.mru_block = block;
 848     return block;
 849 }
 850
 851 static void tlb_reset_dirty_range_all(ram_addr_t start, ram_addr_t length)
 852 {
 853     ram_addr_t start1;
 854     RAMBlock *block;
 855     ram_addr_t end;
 856
 857     end = TARGET_PAGE_ALIGN(start + length);
 858     start &= TARGET_PAGE_MASK;
 859
 860     rcu_read_lock();
 861     block = qemu_get_ram_block(start);
 862     assert(block == qemu_get_ram_block(end - 1));
 863     start1 = (uintptr_t)ramblock_ptr(block, start - block->offset);
 864     cpu_tlb_reset_dirty_all(start1, length);
 865     rcu_read_unlock();
 866 }
 867
 868 /* Note: start and end must be within the same ram block.  */
 869 void cpu_physical_memory_reset_dirty(ram_addr_t start, ram_addr_t length,
 870                                      unsigned client)
 871 {
 872     if (length == 0)
 873         return;
 874     cpu_physical_memory_clear_dirty_range_type(start, length, client);
 875
 876     if (tcg_enabled()) {
 877         tlb_reset_dirty_range_all(start, length);
 878     }
 879 }
 880
 881 static void cpu_physical_memory_set_dirty_tracking(bool enable)
 882 {
 883     in_migration = enable;
 884 }
 885
 886 /* Called from RCU critical section */
 887 hwaddr memory_region_section_get_iotlb(CPUState *cpu,
 888                                        MemoryRegionSection *section,
 889                                        target_ulong vaddr,
 890                                        hwaddr paddr, hwaddr xlat,
 891                                        int prot,
 892                                        target_ulong *address)
 893 {
 894     hwaddr iotlb;
 895     CPUWatchpoint *wp;
 896
 897     if (memory_region_is_ram(section->mr)) {
 898         /* Normal RAM.  */
 899         iotlb = (memory_region_get_ram_addr(section->mr) & TARGET_PAGE_MASK)
 900             + xlat;
 901         if (!section->readonly) {
 902             iotlb |= PHYS_SECTION_NOTDIRTY;
 903         } else {
 904             iotlb |= PHYS_SECTION_ROM;
 905         }
 906     } else {
 907         iotlb = section - section->address_space->dispatch->map.sections;
 908         iotlb += xlat;
 909     }
 910
 911     /* Make accesses to pages with watchpoints go via the
 912        watchpoint trap routines.  */
 913     QTAILQ_FOREACH(wp, &cpu->watchpoints, entry) {
 914         if (cpu_watchpoint_address_matches(wp, vaddr, TARGET_PAGE_SIZE)) {
 915             /* Avoid trapping reads of pages with a write breakpoint. */
 916             if ((prot & PAGE_WRITE) || (wp->flags & BP_MEM_READ)) {
 917                 iotlb = PHYS_SECTION_WATCH + paddr;
 918                 *address |= TLB_MMIO;
 919                 break;
 920             }
 921         }
 922     }
 923
 924     return iotlb;
 925 }
 926 #endif /* defined(CONFIG_USER_ONLY) */
 927
 928 #if !defined(CONFIG_USER_ONLY)
 929
 930 static int subpage_register (subpage_t *mmio, uint32_t start, uint32_t end,
 931                              uint16_t section);
 932 static subpage_t *subpage_init(AddressSpace *as, hwaddr base);
 933
 934 static void *(*phys_mem_alloc)(size_t size, uint64_t *align) =
 935                                qemu_anon_ram_alloc;
 936
 937 /*
 938  * Set a custom physical guest memory alloator.
 939  * Accelerators with unusual needs may need this.  Hopefully, we can
 940  * get rid of it eventually.
 941  */
 942 void phys_mem_set_alloc(void *(*alloc)(size_t, uint64_t *align))
 943 {
 944     phys_mem_alloc = alloc;
 945 }
 946
 947 static uint16_t phys_section_add(PhysPageMap *map,
 948                                  MemoryRegionSection *section)
 949 {
 950     /* The physical section number is ORed with a page-aligned
 951      * pointer to produce the iotlb entries.  Thus it should
 952      * never overflow into the page-aligned value.
 953      */
 954     assert(map->sections_nb < TARGET_PAGE_SIZE);
 955
 956     if (map->sections_nb == map->sections_nb_alloc) {
 957         map->sections_nb_alloc = MAX(map->sections_nb_alloc * 2, 16);
 958         map->sections = g_renew(MemoryRegionSection, map->sections,
 959                                 map->sections_nb_alloc);
 960     }
 961     map->sections[map->sections_nb] = *section;
 962     memory_region_ref(section->mr);
 963     return map->sections_nb++;
 964 }
 965
 966 static void phys_section_destroy(MemoryRegion *mr)
 967 {
 968     memory_region_unref(mr);
 969
 970     if (mr->subpage) {
 971         subpage_t *subpage = container_of(mr, subpage_t, iomem);
 972         object_unref(OBJECT(&subpage->iomem));
 973         g_free(subpage);
 974     }
 975 }
 976
 977 static void phys_sections_free(PhysPageMap *map)
 978 {
 979     while (map->sections_nb > 0) {
 980         MemoryRegionSection *section = &map->sections[--map->sections_nb];
 981         phys_section_destroy(section->mr);
 982     }
 983     g_free(map->sections);
 984     g_free(map->nodes);
 985 }
 986
 987 static void register_subpage(AddressSpaceDispatch *d, MemoryRegionSection *section)
 988 {
 989     subpage_t *subpage;
 990     hwaddr base = section->offset_within_address_space
 991         & TARGET_PAGE_MASK;
 992     MemoryRegionSection *existing = phys_page_find(d->phys_map, base,
 993                                                    d->map.nodes, d->map.sections);
 994     MemoryRegionSection subsection = {
 995         .offset_within_address_space = base,
 996         .size = int128_make64(TARGET_PAGE_SIZE),
 997     };
 998     hwaddr start, end;
 999
1000     assert(existing->mr->subpage || existing->mr == &io_mem_unassigned);
1001
1002     if (!(existing->mr->subpage)) {
1003         subpage = subpage_init(d->as, base);
1004         subsection.address_space = d->as;
1005         subsection.mr = &subpage->iomem;
1006         phys_page_set(d, base >> TARGET_PAGE_BITS, 1,
1007                       phys_section_add(&d->map, &subsection));
1008     } else {
1009         subpage = container_of(existing->mr, subpage_t, iomem);
1010     }
1011     start = section->offset_within_address_space & ~TARGET_PAGE_MASK;
1012     end = start + int128_get64(section->size) - 1;
1013     subpage_register(subpage, start, end,
1014                      phys_section_add(&d->map, section));
1015 }
1016
1017
1018 static void register_multipage(AddressSpaceDispatch *d,
1019                                MemoryRegionSection *section)
1020 {
1021     hwaddr start_addr = section->offset_within_address_space;
1022     uint16_t section_index = phys_section_add(&d->map, section);
1023     uint64_t num_pages = int128_get64(int128_rshift(section->size,
1024                                                     TARGET_PAGE_BITS));
1025
1026     assert(num_pages);
1027     phys_page_set(d, start_addr >> TARGET_PAGE_BITS, num_pages, section_index);
1028 }
1029
1030 static void mem_add(MemoryListener *listener, MemoryRegionSection *section)
1031 {
1032     AddressSpace *as = container_of(listener, AddressSpace, dispatch_listener);
1033     AddressSpaceDispatch *d = as->next_dispatch;
1034     MemoryRegionSection now = *section, remain = *section;
1035     Int128 page_size = int128_make64(TARGET_PAGE_SIZE);
1036
1037     if (now.offset_within_address_space & ~TARGET_PAGE_MASK) {
1038         uint64_t left = TARGET_PAGE_ALIGN(now.offset_within_address_space)
1039                        - now.offset_within_address_space;
1040
1041         now.size = int128_min(int128_make64(left), now.size);
1042         register_subpage(d, &now);
1043     } else {
1044         now.size = int128_zero();
1045     }
1046     while (int128_ne(remain.size, now.size)) {
1047         remain.size = int128_sub(remain.size, now.size);
1048         remain.offset_within_address_space += int128_get64(now.size);
1049         remain.offset_within_region += int128_get64(now.size);
1050         now = remain;
1051         if (int128_lt(remain.size, page_size)) {
1052             register_subpage(d, &now);
1053         } else if (remain.offset_within_address_space & ~TARGET_PAGE_MASK) {
1054             now.size = page_size;
1055             register_subpage(d, &now);
1056         } else {
1057             now.size = int128_and(now.size, int128_neg(page_size));
1058             register_multipage(d, &now);
1059         }
1060     }
1061 }
1062
1063 void qemu_flush_coalesced_mmio_buffer(void)
1064 {
1065     if (kvm_enabled())
1066         kvm_flush_coalesced_mmio_buffer();
1067 }
1068
1069 void qemu_mutex_lock_ramlist(void)
1070 {
1071     qemu_mutex_lock(&ram_list.mutex);
1072 }
1073
1074 void qemu_mutex_unlock_ramlist(void)
1075 {
1076     qemu_mutex_unlock(&ram_list.mutex);
1077 }
1078
1079 #ifdef __linux__
1080
1081 #include <sys/vfs.h>
1082
1083 #define HUGETLBFS_MAGIC       0x958458f6
1084
1085 static long gethugepagesize(const char *path, Error **errp)
1086 {
1087     struct statfs fs;
1088     int ret;
1089
1090     do {
1091         ret = statfs(path, &fs);
1092     } while (ret != 0 && errno == EINTR);
1093
1094     if (ret != 0) {
1095         error_setg_errno(errp, errno, "failed to get page size of file %s",
1096                          path);
1097         return 0;
1098     }
1099
1100     if (fs.f_type != HUGETLBFS_MAGIC)
1101         fprintf(stderr, "Warning: path not on HugeTLBFS: %s\n", path);
1102
1103     return fs.f_bsize;
1104 }
1105
1106 static void *file_ram_alloc(RAMBlock *block,
1107                             ram_addr_t memory,
1108                             const char *path,
1109                             Error **errp)
1110 {
1111     char *filename;
1112     char *sanitized_name;
1113     char *c;
1114     void *area = NULL;
1115     int fd;
1116     uint64_t hpagesize;
1117     Error *local_err = NULL;
1118
1119     hpagesize = gethugepagesize(path, &local_err);
1120     if (local_err) {
1121         error_propagate(errp, local_err);
1122         goto error;
1123     }
1124     block->mr->align = hpagesize;
1125
1126     if (memory < hpagesize) {
1127         error_setg(errp, "memory size 0x" RAM_ADDR_FMT " must be equal to "
1128                    "or larger than huge page size 0x%" PRIx64,
1129                    memory, hpagesize);
1130         goto error;
1131     }
1132
1133     if (kvm_enabled() && !kvm_has_sync_mmu()) {
1134         error_setg(errp,
1135                    "host lacks kvm mmu notifiers, -mem-path unsupported");
1136         goto error;
1137     }
1138
1139     /* Make name safe to use with mkstemp by replacing '/' with '_'. */
1140     sanitized_name = g_strdup(memory_region_name(block->mr));
1141     for (c = sanitized_name; *c != '\0'; c++) {
1142         if (*c == '/')
1143             *c = '_';
1144     }
1145
1146     filename = g_strdup_printf("%s/qemu_back_mem.%s.XXXXXX", path,
1147                                sanitized_name);
1148     g_free(sanitized_name);
1149
1150     fd = mkstemp(filename);
1151     if (fd < 0) {
1152         error_setg_errno(errp, errno,
1153                          "unable to create backing store for hugepages");
1154         g_free(filename);
1155         goto error;
1156     }
1157     unlink(filename);
1158     g_free(filename);
1159
1160     memory = (memory+hpagesize-1) & ~(hpagesize-1);
1161
1162     /*
1163      * ftruncate is not supported by hugetlbfs in older
1164      * hosts, so don't bother bailing out on errors.
1165      * If anything goes wrong with it under other filesystems,
1166      * mmap will fail.
1167      */
1168     if (ftruncate(fd, memory)) {
1169         perror("ftruncate");
1170     }
1171
1172     area = mmap(0, memory, PROT_READ | PROT_WRITE,
1173                 (block->flags & RAM_SHARED ? MAP_SHARED : MAP_PRIVATE),
1174                 fd, 0);
1175     if (area == MAP_FAILED) {
1176         error_setg_errno(errp, errno,
1177                          "unable to map backing store for hugepages");
1178         close(fd);
1179         goto error;
1180     }
1181
1182     if (mem_prealloc) {
1183         os_mem_prealloc(fd, area, memory);
1184     }
1185
1186     block->fd = fd;
1187     return area;
1188
1189 error:
1190     if (mem_prealloc) {
1191         error_report("%s", error_get_pretty(*errp));
1192         exit(1);
1193     }
1194     return NULL;
1195 }
1196 #endif
1197
1198 /* Called with the ramlist lock held.  */
1199 static ram_addr_t find_ram_offset(ram_addr_t size)
1200 {
1201     RAMBlock *block, *next_block;
1202     ram_addr_t offset = RAM_ADDR_MAX, mingap = RAM_ADDR_MAX;
1203
1204     assert(size != 0); /* it would hand out same offset multiple times */
1205
1206     if (QLIST_EMPTY_RCU(&ram_list.blocks)) {
1207         return 0;
1208     }
1209
1210     QLIST_FOREACH_RCU(block, &ram_list.blocks, next) {
1211         ram_addr_t end, next = RAM_ADDR_MAX;
1212
1213         end = block->offset + block->max_length;
1214
1215         QLIST_FOREACH_RCU(next_block, &ram_list.blocks, next) {
1216             if (next_block->offset >= end) {
1217                 next = MIN(next, next_block->offset);
1218             }
1219         }
1220         if (next - end >= size && next - end < mingap) {
1221             offset = end;
1222             mingap = next - end;
1223         }
1224     }
1225
1226     if (offset == RAM_ADDR_MAX) {
1227         fprintf(stderr, "Failed to find gap of requested size: %" PRIu64 "\n",
1228                 (uint64_t)size);
1229         abort();
1230     }
1231
1232     return offset;
1233 }
1234
1235 ram_addr_t last_ram_offset(void)
1236 {
1237     RAMBlock *block;
1238     ram_addr_t last = 0;
1239
1240     rcu_read_lock();
1241     QLIST_FOREACH_RCU(block, &ram_list.blocks, next) {
1242         last = MAX(last, block->offset + block->max_length);
1243     }
1244     rcu_read_unlock();
1245     return last;
1246 }
1247
1248 static void qemu_ram_setup_dump(void *addr, ram_addr_t size)
1249 {
1250     int ret;
1251
1252     /* Use MADV_DONTDUMP, if user doesn't want the guest memory in the core */
1253     if (!qemu_opt_get_bool(qemu_get_machine_opts(),
1254                            "dump-guest-core", true)) {
1255         ret = qemu_madvise(addr, size, QEMU_MADV_DONTDUMP);
1256         if (ret) {
1257             perror("qemu_madvise");
1258             fprintf(stderr, "madvise doesn't support MADV_DONTDUMP, "
1259                             "but dump_guest_core=off specified\n");
1260         }
1261     }
1262 }
1263
1264 /* Called within an RCU critical section, or while the ramlist lock
1265  * is held.
1266  */
1267 static RAMBlock *find_ram_block(ram_addr_t addr)
1268 {
1269     RAMBlock *block;
1270
1271     QLIST_FOREACH_RCU(block, &ram_list.blocks, next) {
1272         if (block->offset == addr) {
1273             return block;
1274         }
1275     }
1276
1277     return NULL;
1278 }
1279
1280 /* Called with iothread lock held.  */
1281 void qemu_ram_set_idstr(ram_addr_t addr, const char *name, DeviceState *dev)
1282 {
1283     RAMBlock *new_block, *block;
1284
1285     rcu_read_lock();
1286     new_block = find_ram_block(addr);
1287     assert(new_block);
1288     assert(!new_block->idstr[0]);
1289
1290     if (dev) {
1291         char *id = qdev_get_dev_path(dev);
1292         if (id) {
1293             snprintf(new_block->idstr, sizeof(new_block->idstr), "%s/", id);
1294             g_free(id);
1295         }
1296     }
1297     pstrcat(new_block->idstr, sizeof(new_block->idstr), name);
1298
1299     QLIST_FOREACH_RCU(block, &ram_list.blocks, next) {
1300         if (block != new_block && !strcmp(block->idstr, new_block->idstr)) {
1301             fprintf(stderr, "RAMBlock \"%s\" already registered, abort!\n",
1302                     new_block->idstr);
1303             abort();
1304         }
1305     }
1306     rcu_read_unlock();
1307 }
1308
1309 /* Called with iothread lock held.  */
1310 void qemu_ram_unset_idstr(ram_addr_t addr)
1311 {
1312     RAMBlock *block;
1313
1314     /* FIXME: arch_init.c assumes that this is not called throughout
1315      * migration.  Ignore the problem since hot-unplug during migration
1316      * does not work anyway.
1317      */
1318
1319     rcu_read_lock();
1320     block = find_ram_block(addr);
1321     if (block) {
1322         memset(block->idstr, 0, sizeof(block->idstr));
1323     }
1324     rcu_read_unlock();
1325 }
1326
1327 static int memory_try_enable_merging(void *addr, size_t len)
1328 {
1329     if (!qemu_opt_get_bool(qemu_get_machine_opts(), "mem-merge", true)) {
1330         /* disabled by the user */
1331         return 0;
1332     }
1333
1334     return qemu_madvise(addr, len, QEMU_MADV_MERGEABLE);
1335 }
1336
1337 /* Only legal before guest might have detected the memory size: e.g. on
1338  * incoming migration, or right after reset.
1339  *
1340  * As memory core doesn't know how is memory accessed, it is up to
1341  * resize callback to update device state and/or add assertions to detect
1342  * misuse, if necessary.
1343  */
1344 int qemu_ram_resize(ram_addr_t base, ram_addr_t newsize, Error **errp)
1345 {
1346     RAMBlock *block = find_ram_block(base);
1347
1348     assert(block);
1349
1350     newsize = TARGET_PAGE_ALIGN(newsize);
1351
1352     if (block->used_length == newsize) {
1353         return 0;
1354     }
1355
1356     if (!(block->flags & RAM_RESIZEABLE)) {
1357         error_setg_errno(errp, EINVAL,
1358                          "Length mismatch: %s: 0x" RAM_ADDR_FMT
1359                          " in != 0x" RAM_ADDR_FMT, block->idstr,
1360                          newsize, block->used_length);
1361         return -EINVAL;
1362     }
1363
1364     if (block->max_length < newsize) {
1365         error_setg_errno(errp, EINVAL,
1366                          "Length too large: %s: 0x" RAM_ADDR_FMT
1367                          " > 0x" RAM_ADDR_FMT, block->idstr,
1368                          newsize, block->max_length);
1369         return -EINVAL;
1370     }
1371
1372     cpu_physical_memory_clear_dirty_range(block->offset, block->used_length);
1373     block->used_length = newsize;
1374     cpu_physical_memory_set_dirty_range(block->offset, block->used_length);
1375     memory_region_set_size(block->mr, newsize);
1376     if (block->resized) {
1377         block->resized(block->idstr, newsize, block->host);
1378     }
1379     return 0;
1380 }
1381
1382 static ram_addr_t ram_block_add(RAMBlock *new_block, Error **errp)
1383 {
1384     RAMBlock *block;
1385     RAMBlock *last_block = NULL;
1386     ram_addr_t old_ram_size, new_ram_size;
1387
1388     old_ram_size = last_ram_offset() >> TARGET_PAGE_BITS;
1389
1390     qemu_mutex_lock_ramlist();
1391     new_block->offset = find_ram_offset(new_block->max_length);
1392
1393     if (!new_block->host) {
1394         if (xen_enabled()) {
1395             xen_ram_alloc(new_block->offset, new_block->max_length,
1396                           new_block->mr);
1397         } else {
1398             new_block->host = phys_mem_alloc(new_block->max_length,
1399                                              &new_block->mr->align);
1400             if (!new_block->host) {
1401                 error_setg_errno(errp, errno,
1402                                  "cannot set up guest memory '%s'",
1403                                  memory_region_name(new_block->mr));
1404                 qemu_mutex_unlock_ramlist();
1405                 return -1;
1406             }
1407             memory_try_enable_merging(new_block->host, new_block->max_length);
1408         }
1409     }
1410
1411     /* Keep the list sorted from biggest to smallest block.  Unlike QTAILQ,
1412      * QLIST (which has an RCU-friendly variant) does not have insertion at
1413      * tail, so save the last element in last_block.
1414      */
1415     QLIST_FOREACH_RCU(block, &ram_list.blocks, next) {
1416         last_block = block;
1417         if (block->max_length < new_block->max_length) {
1418             break;
1419         }
1420     }
1421     if (block) {
1422         QLIST_INSERT_BEFORE_RCU(block, new_block, next);
1423     } else if (last_block) {
1424         QLIST_INSERT_AFTER_RCU(last_block, new_block, next);
1425     } else { /* list is empty */
1426         QLIST_INSERT_HEAD_RCU(&ram_list.blocks, new_block, next);
1427     }
1428     ram_list.mru_block = NULL;
1429
1430     /* Write list before version */
1431     smp_wmb();
1432     ram_list.version++;
1433     qemu_mutex_unlock_ramlist();
1434
1435     new_ram_size = last_ram_offset() >> TARGET_PAGE_BITS;
1436
1437     if (new_ram_size > old_ram_size) {
1438         int i;
1439
1440         /* ram_list.dirty_memory[] is protected by the iothread lock.  */
1441         for (i = 0; i < DIRTY_MEMORY_NUM; i++) {
1442             ram_list.dirty_memory[i] =
1443                 bitmap_zero_extend(ram_list.dirty_memory[i],
1444                                    old_ram_size, new_ram_size);
1445        }
1446     }
1447     cpu_physical_memory_set_dirty_range(new_block->offset,
1448                                         new_block->used_length);
1449
1450     if (new_block->host) {
1451         qemu_ram_setup_dump(new_block->host, new_block->max_length);
1452         qemu_madvise(new_block->host, new_block->max_length, QEMU_MADV_HUGEPAGE);
1453         qemu_madvise(new_block->host, new_block->max_length, QEMU_MADV_DONTFORK);
1454         if (kvm_enabled()) {
1455             kvm_setup_guest_memory(new_block->host, new_block->max_length);
1456         }
1457     }
1458
1459     return new_block->offset;
1460 }
1461
1462 #ifdef __linux__
1463 ram_addr_t qemu_ram_alloc_from_file(ram_addr_t size, MemoryRegion *mr,
1464                                     bool share, const char *mem_path,
1465                                     Error **errp)
1466 {
1467     RAMBlock *new_block;
1468     ram_addr_t addr;
1469     Error *local_err = NULL;
1470
1471     if (xen_enabled()) {
1472         error_setg(errp, "-mem-path not supported with Xen");
1473         return -1;
1474     }
1475
1476     if (phys_mem_alloc != qemu_anon_ram_alloc) {
1477         /*
1478          * file_ram_alloc() needs to allocate just like
1479          * phys_mem_alloc, but we haven't bothered to provide
1480          * a hook there.
1481          */
1482         error_setg(errp,
1483                    "-mem-path not supported with this accelerator");
1484         return -1;
1485     }
1486
1487     size = TARGET_PAGE_ALIGN(size);
1488     new_block = g_malloc0(sizeof(*new_block));
1489     new_block->mr = mr;
1490     new_block->used_length = size;
1491     new_block->max_length = size;
1492     new_block->flags = share ? RAM_SHARED : 0;
1493     new_block->host = file_ram_alloc(new_block, size,
1494                                      mem_path, errp);
1495     if (!new_block->host) {
1496         g_free(new_block);
1497         return -1;
1498     }
1499
1500     addr = ram_block_add(new_block, &local_err);
1501     if (local_err) {
1502         g_free(new_block);
1503         error_propagate(errp, local_err);
1504         return -1;
1505     }
1506     return addr;
1507 }
1508 #endif
1509
1510 static
1511 ram_addr_t qemu_ram_alloc_internal(ram_addr_t size, ram_addr_t max_size,
1512                                    void (*resized)(const char*,
1513                                                    uint64_t length,
1514                                                    void *host),
1515                                    void *host, bool resizeable,
1516                                    MemoryRegion *mr, Error **errp)
1517 {
1518     RAMBlock *new_block;
1519     ram_addr_t addr;
1520     Error *local_err = NULL;
1521
1522     size = TARGET_PAGE_ALIGN(size);
1523     max_size = TARGET_PAGE_ALIGN(max_size);
1524     new_block = g_malloc0(sizeof(*new_block));
1525     new_block->mr = mr;
1526     new_block->resized = resized;
1527     new_block->used_length = size;
1528     new_block->max_length = max_size;
1529     assert(max_size >= size);
1530     new_block->fd = -1;
1531     new_block->host = host;
1532     if (host) {
1533         new_block->flags |= RAM_PREALLOC;
1534     }
1535     if (resizeable) {
1536         new_block->flags |= RAM_RESIZEABLE;
1537     }
1538     addr = ram_block_add(new_block, &local_err);
1539     if (local_err) {
1540         g_free(new_block);
1541         error_propagate(errp, local_err);
1542         return -1;
1543     }
1544     return addr;
1545 }
1546
1547 ram_addr_t qemu_ram_alloc_from_ptr(ram_addr_t size, void *host,
1548                                    MemoryRegion *mr, Error **errp)
1549 {
1550     return qemu_ram_alloc_internal(size, size, NULL, host, false, mr, errp);
1551 }
1552
1553 ram_addr_t qemu_ram_alloc(ram_addr_t size, MemoryRegion *mr, Error **errp)
1554 {
1555     return qemu_ram_alloc_internal(size, size, NULL, NULL, false, mr, errp);
1556 }
1557
1558 ram_addr_t qemu_ram_alloc_resizeable(ram_addr_t size, ram_addr_t maxsz,
1559                                      void (*resized)(const char*,
1560                                                      uint64_t length,
1561                                                      void *host),
1562                                      MemoryRegion *mr, Error **errp)
1563 {
1564     return qemu_ram_alloc_internal(size, maxsz, resized, NULL, true, mr, errp);
1565 }
1566
1567 void qemu_ram_free_from_ptr(ram_addr_t addr)
1568 {
1569     RAMBlock *block;
1570
1571     qemu_mutex_lock_ramlist();
1572     QLIST_FOREACH_RCU(block, &ram_list.blocks, next) {
1573         if (addr == block->offset) {
1574             QLIST_REMOVE_RCU(block, next);
1575             ram_list.mru_block = NULL;
1576             /* Write list before version */
1577             smp_wmb();
1578             ram_list.version++;
1579             g_free_rcu(block, rcu);
1580             break;
1581         }
1582     }
1583     qemu_mutex_unlock_ramlist();
1584 }
1585
1586 static void reclaim_ramblock(RAMBlock *block)
1587 {
1588     if (block->flags & RAM_PREALLOC) {
1589         ;
1590     } else if (xen_enabled()) {
1591         xen_invalidate_map_cache_entry(block->host);
1592 #ifndef _WIN32
1593     } else if (block->fd >= 0) {
1594         munmap(block->host, block->max_length);
1595         close(block->fd);
1596 #endif
1597     } else {
1598         qemu_anon_ram_free(block->host, block->max_length);
1599     }
1600     g_free(block);
1601 }
1602
1603 void qemu_ram_free(ram_addr_t addr)
1604 {
1605     RAMBlock *block;
1606
1607     qemu_mutex_lock_ramlist();
1608     QLIST_FOREACH_RCU(block, &ram_list.blocks, next) {
1609         if (addr == block->offset) {
1610             QLIST_REMOVE_RCU(block, next);
1611             ram_list.mru_block = NULL;
1612             /* Write list before version */
1613             smp_wmb();
1614             ram_list.version++;
1615             call_rcu(block, reclaim_ramblock, rcu);
1616             break;
1617         }
1618     }
1619     qemu_mutex_unlock_ramlist();
1620 }
1621
1622 #ifndef _WIN32
1623 void qemu_ram_remap(ram_addr_t addr, ram_addr_t length)
1624 {
1625     RAMBlock *block;
1626     ram_addr_t offset;
1627     int flags;
1628     void *area, *vaddr;
1629
1630     QLIST_FOREACH_RCU(block, &ram_list.blocks, next) {
1631         offset = addr - block->offset;
1632         if (offset < block->max_length) {
1633             vaddr = ramblock_ptr(block, offset);
1634             if (block->flags & RAM_PREALLOC) {
1635                 ;
1636             } else if (xen_enabled()) {
1637                 abort();
1638             } else {
1639                 flags = MAP_FIXED;
1640                 munmap(vaddr, length);
1641                 if (block->fd >= 0) {
1642                     flags |= (block->flags & RAM_SHARED ?
1643                               MAP_SHARED : MAP_PRIVATE);
1644                     area = mmap(vaddr, length, PROT_READ | PROT_WRITE,
1645                                 flags, block->fd, offset);
1646                 } else {
1647                     /*
1648                      * Remap needs to match alloc.  Accelerators that
1649                      * set phys_mem_alloc never remap.  If they did,
1650                      * we'd need a remap hook here.
1651                      */
1652                     assert(phys_mem_alloc == qemu_anon_ram_alloc);
1653
1654                     flags |= MAP_PRIVATE | MAP_ANONYMOUS;
1655                     area = mmap(vaddr, length, PROT_READ | PROT_WRITE,
1656                                 flags, -1, 0);
1657                 }
1658                 if (area != vaddr) {
1659                     fprintf(stderr, "Could not remap addr: "
1660                             RAM_ADDR_FMT "@" RAM_ADDR_FMT "\n",
1661                             length, addr);
1662                     exit(1);
1663                 }
1664                 memory_try_enable_merging(vaddr, length);
1665                 qemu_ram_setup_dump(vaddr, length);
1666             }
1667         }
1668     }
1669 }
1670 #endif /* !_WIN32 */
1671
1672 int qemu_get_ram_fd(ram_addr_t addr)
1673 {
1674     RAMBlock *block;
1675     int fd;
1676
1677     rcu_read_lock();
1678     block = qemu_get_ram_block(addr);
1679     fd = block->fd;
1680     rcu_read_unlock();
1681     return fd;
1682 }
1683
1684 void *qemu_get_ram_block_host_ptr(ram_addr_t addr)
1685 {
1686     RAMBlock *block;
1687     void *ptr;
1688
1689     rcu_read_lock();
1690     block = qemu_get_ram_block(addr);
1691     ptr = ramblock_ptr(block, 0);
1692     rcu_read_unlock();
1693     return ptr;
1694 }
1695
1696 /* Return a host pointer to ram allocated with qemu_ram_alloc.
1697  * This should not be used for general purpose DMA.  Use address_space_map
1698  * or address_space_rw instead. For local memory (e.g. video ram) that the
1699  * device owns, use memory_region_get_ram_ptr.
1700  *
1701  * By the time this function returns, the returned pointer is not protected
1702  * by RCU anymore.  If the caller is not within an RCU critical section and
1703  * does not hold the iothread lock, it must have other means of protecting the
1704  * pointer, such as a reference to the region that includes the incoming
1705  * ram_addr_t.
1706  */
1707 void *qemu_get_ram_ptr(ram_addr_t addr)
1708 {
1709     RAMBlock *block;
1710     void *ptr;
1711
1712     rcu_read_lock();
1713     block = qemu_get_ram_block(addr);
1714
1715     if (xen_enabled() && block->host == NULL) {
1716         /* We need to check if the requested address is in the RAM
1717          * because we don't want to map the entire memory in QEMU.
1718          * In that case just map until the end of the page.
1719          */
1720         if (block->offset == 0) {
1721             ptr = xen_map_cache(addr, 0, 0);
1722             goto unlock;
1723         }
1724
1725         block->host = xen_map_cache(block->offset, block->max_length, 1);
1726     }
1727     ptr = ramblock_ptr(block, addr - block->offset);
1728
1729 unlock:
1730     rcu_read_unlock();
1731     return ptr;
1732 }
1733
1734 /* Return a host pointer to guest's ram. Similar to qemu_get_ram_ptr
1735  * but takes a size argument.
1736  *
1737  * By the time this function returns, the returned pointer is not protected
1738  * by RCU anymore.  If the caller is not within an RCU critical section and
1739  * does not hold the iothread lock, it must have other means of protecting the
1740  * pointer, such as a reference to the region that includes the incoming
1741  * ram_addr_t.
1742  */
1743 static void *qemu_ram_ptr_length(ram_addr_t addr, hwaddr *size)
1744 {
1745     void *ptr;
1746     if (*size == 0) {
1747         return NULL;
1748     }
1749     if (xen_enabled()) {
1750         return xen_map_cache(addr, *size, 1);
1751     } else {
1752         RAMBlock *block;
1753         rcu_read_lock();
1754         QLIST_FOREACH_RCU(block, &ram_list.blocks, next) {
1755             if (addr - block->offset < block->max_length) {
1756                 if (addr - block->offset + *size > block->max_length)
1757                     *size = block->max_length - addr + block->offset;
1758                 ptr = ramblock_ptr(block, addr - block->offset);
1759                 rcu_read_unlock();
1760                 return ptr;
1761             }
1762         }
1763
1764         fprintf(stderr, "Bad ram offset %" PRIx64 "\n", (uint64_t)addr);
1765         abort();
1766     }
1767 }
1768
1769 /* Some of the softmmu routines need to translate from a host pointer
1770  * (typically a TLB entry) back to a ram offset.
1771  *
1772  * By the time this function returns, the returned pointer is not protected
1773  * by RCU anymore.  If the caller is not within an RCU critical section and
1774  * does not hold the iothread lock, it must have other means of protecting the
1775  * pointer, such as a reference to the region that includes the incoming
1776  * ram_addr_t.
1777  */
1778 MemoryRegion *qemu_ram_addr_from_host(void *ptr, ram_addr_t *ram_addr)
1779 {
1780     RAMBlock *block;
1781     uint8_t *host = ptr;
1782     MemoryRegion *mr;
1783
1784     if (xen_enabled()) {
1785         rcu_read_lock();
1786         *ram_addr = xen_ram_addr_from_mapcache(ptr);
1787         mr = qemu_get_ram_block(*ram_addr)->mr;
1788         rcu_read_unlock();
1789         return mr;
1790     }
1791
1792     rcu_read_lock();
1793     block = atomic_rcu_read(&ram_list.mru_block);
1794     if (block && block->host && host - block->host < block->max_length) {
1795         goto found;
1796     }
1797
1798     QLIST_FOREACH_RCU(block, &ram_list.blocks, next) {
1799         /* This case append when the block is not mapped. */
1800         if (block->host == NULL) {
1801             continue;
1802         }
1803         if (host - block->host < block->max_length) {
1804             goto found;
1805         }
1806     }
1807
1808     rcu_read_unlock();
1809     return NULL;
1810
1811 found:
1812     *ram_addr = block->offset + (host - block->host);
1813     mr = block->mr;
1814     rcu_read_unlock();
1815     return mr;
1816 }
1817
1818 static void notdirty_mem_write(void *opaque, hwaddr ram_addr,
1819                                uint64_t val, unsigned size)
1820 {
1821     if (!cpu_physical_memory_get_dirty_flag(ram_addr, DIRTY_MEMORY_CODE)) {
1822         tb_invalidate_phys_page_fast(ram_addr, size);
1823     }
1824     switch (size) {
1825     case 1:
1826         stb_p(qemu_get_ram_ptr(ram_addr), val);
1827         break;
1828     case 2:
1829         stw_p(qemu_get_ram_ptr(ram_addr), val);
1830         break;
1831     case 4:
1832         stl_p(qemu_get_ram_ptr(ram_addr), val);
1833         break;
1834     default:
1835         abort();
1836     }
1837     cpu_physical_memory_set_dirty_range_nocode(ram_addr, size);
1838     /* we remove the notdirty callback only if the code has been
1839        flushed */
1840     if (!cpu_physical_memory_is_clean(ram_addr)) {
1841         CPUArchState *env = current_cpu->env_ptr;
1842         tlb_set_dirty(env, current_cpu->mem_io_vaddr);
1843     }
1844 }
1845
1846 static bool notdirty_mem_accepts(void *opaque, hwaddr addr,
1847                                  unsigned size, bool is_write)
1848 {
1849     return is_write;
1850 }
1851
1852 static const MemoryRegionOps notdirty_mem_ops = {
1853     .write = notdirty_mem_write,
1854     .valid.accepts = notdirty_mem_accepts,
1855     .endianness = DEVICE_NATIVE_ENDIAN,
1856 };
1857
1858 /* Generate a debug exception if a watchpoint has been hit.  */
1859 static void check_watchpoint(int offset, int len, int flags)
1860 {
1861     CPUState *cpu = current_cpu;
1862     CPUArchState *env = cpu->env_ptr;
1863     target_ulong pc, cs_base;
1864     target_ulong vaddr;
1865     CPUWatchpoint *wp;
1866     int cpu_flags;
1867
1868     if (cpu->watchpoint_hit) {
1869         /* We re-entered the check after replacing the TB. Now raise
1870          * the debug interrupt so that is will trigger after the
1871          * current instruction. */
1872         cpu_interrupt(cpu, CPU_INTERRUPT_DEBUG);
1873         return;
1874     }
1875     vaddr = (cpu->mem_io_vaddr & TARGET_PAGE_MASK) + offset;
1876     QTAILQ_FOREACH(wp, &cpu->watchpoints, entry) {
1877         if (cpu_watchpoint_address_matches(wp, vaddr, len)
1878             && (wp->flags & flags)) {
1879             if (flags == BP_MEM_READ) {
1880                 wp->flags |= BP_WATCHPOINT_HIT_READ;
1881             } else {
1882                 wp->flags |= BP_WATCHPOINT_HIT_WRITE;
1883             }
1884             wp->hitaddr = vaddr;
1885             if (!cpu->watchpoint_hit) {
1886                 cpu->watchpoint_hit = wp;
1887                 tb_check_watchpoint(cpu);
1888                 if (wp->flags & BP_STOP_BEFORE_ACCESS) {
1889                     cpu->exception_index = EXCP_DEBUG;
1890                     cpu_loop_exit(cpu);
1891                 } else {
1892                     cpu_get_tb_cpu_state(env, &pc, &cs_base, &cpu_flags);
1893                     tb_gen_code(cpu, pc, cs_base, cpu_flags, 1);
1894                     cpu_resume_from_signal(cpu, NULL);
1895                 }
1896             }
1897         } else {
1898             wp->flags &= ~BP_WATCHPOINT_HIT;
1899         }
1900     }
1901 }
1902
1903 /* Watchpoint access routines.  Watchpoints are inserted using TLB tricks,
1904    so these check for a hit then pass through to the normal out-of-line
1905    phys routines.  */
1906 static uint64_t watch_mem_read(void *opaque, hwaddr addr,
1907                                unsigned size)
1908 {
1909     check_watchpoint(addr & ~TARGET_PAGE_MASK, size, BP_MEM_READ);
1910     switch (size) {
1911     case 1: return ldub_phys(&address_space_memory, addr);
1912     case 2: return lduw_phys(&address_space_memory, addr);
1913     case 4: return ldl_phys(&address_space_memory, addr);
1914     default: abort();
1915     }
1916 }
1917
1918 static void watch_mem_write(void *opaque, hwaddr addr,
1919                             uint64_t val, unsigned size)
1920 {
1921     check_watchpoint(addr & ~TARGET_PAGE_MASK, size, BP_MEM_WRITE);
1922     switch (size) {
1923     case 1:
1924         stb_phys(&address_space_memory, addr, val);
1925         break;
1926     case 2:
1927         stw_phys(&address_space_memory, addr, val);
1928         break;
1929     case 4:
1930         stl_phys(&address_space_memory, addr, val);
1931         break;
1932     default: abort();
1933     }
1934 }
1935
1936 static const MemoryRegionOps watch_mem_ops = {
1937     .read = watch_mem_read,
1938     .write = watch_mem_write,
1939     .endianness = DEVICE_NATIVE_ENDIAN,
1940 };
1941
1942 static uint64_t subpage_read(void *opaque, hwaddr addr,
1943                              unsigned len)
1944 {
1945     subpage_t *subpage = opaque;
1946     uint8_t buf[8];
1947
1948 #if defined(DEBUG_SUBPAGE)
1949     printf("%s: subpage %p len %u addr " TARGET_FMT_plx "\n", __func__,
1950            subpage, len, addr);
1951 #endif
1952     address_space_read(subpage->as, addr + subpage->base, buf, len);
1953     switch (len) {
1954     case 1:
1955         return ldub_p(buf);
1956     case 2:
1957         return lduw_p(buf);
1958     case 4:
1959         return ldl_p(buf);
1960     case 8:
1961         return ldq_p(buf);
1962     default:
1963         abort();
1964     }
1965 }
1966
1967 static void subpage_write(void *opaque, hwaddr addr,
1968                           uint64_t value, unsigned len)
1969 {
1970     subpage_t *subpage = opaque;
1971     uint8_t buf[8];
1972
1973 #if defined(DEBUG_SUBPAGE)
1974     printf("%s: subpage %p len %u addr " TARGET_FMT_plx
1975            " value %"PRIx64"\n",
1976            __func__, subpage, len, addr, value);
1977 #endif
1978     switch (len) {
1979     case 1:
1980         stb_p(buf, value);
1981         break;
1982     case 2:
1983         stw_p(buf, value);
1984         break;
1985     case 4:
1986         stl_p(buf, value);
1987         break;
1988     case 8:
1989         stq_p(buf, value);
1990         break;
1991     default:
1992         abort();
1993     }
1994     address_space_write(subpage->as, addr + subpage->base, buf, len);
1995 }
1996
1997 static bool subpage_accepts(void *opaque, hwaddr addr,
1998                             unsigned len, bool is_write)
1999 {
2000     subpage_t *subpage = opaque;
2001 #if defined(DEBUG_SUBPAGE)
2002     printf("%s: subpage %p %c len %u addr " TARGET_FMT_plx "\n",
2003            __func__, subpage, is_write ? 'w' : 'r', len, addr);
2004 #endif
2005
2006     return address_space_access_valid(subpage->as, addr + subpage->base,
2007                                       len, is_write);
2008 }
2009
2010 static const MemoryRegionOps subpage_ops = {
2011     .read = subpage_read,
2012     .write = subpage_write,
2013     .impl.min_access_size = 1,
2014     .impl.max_access_size = 8,
2015     .valid.min_access_size = 1,
2016     .valid.max_access_size = 8,
2017     .valid.accepts = subpage_accepts,
2018     .endianness = DEVICE_NATIVE_ENDIAN,
2019 };
2020
2021 static int subpage_register (subpage_t *mmio, uint32_t start, uint32_t end,
2022                              uint16_t section)
2023 {
2024     int idx, eidx;
2025
2026     if (start >= TARGET_PAGE_SIZE || end >= TARGET_PAGE_SIZE)
2027         return -1;
2028     idx = SUBPAGE_IDX(start);
2029     eidx = SUBPAGE_IDX(end);
2030 #if defined(DEBUG_SUBPAGE)
2031     printf("%s: %p start %08x end %08x idx %08x eidx %08x section %d\n",
2032            __func__, mmio, start, end, idx, eidx, section);
2033 #endif
2034     for (; idx <= eidx; idx++) {
2035         mmio->sub_section[idx] = section;
2036     }
2037
2038     return 0;
2039 }
2040
2041 static subpage_t *subpage_init(AddressSpace *as, hwaddr base)
2042 {
2043     subpage_t *mmio;
2044
2045     mmio = g_malloc0(sizeof(subpage_t));
2046
2047     mmio->as = as;
2048     mmio->base = base;
2049     memory_region_init_io(&mmio->iomem, NULL, &subpage_ops, mmio,
2050                           NULL, TARGET_PAGE_SIZE);
2051     mmio->iomem.subpage = true;
2052 #if defined(DEBUG_SUBPAGE)
2053     printf("%s: %p base " TARGET_FMT_plx " len %08x\n", __func__,
2054            mmio, base, TARGET_PAGE_SIZE);
2055 #endif
2056     subpage_register(mmio, 0, TARGET_PAGE_SIZE-1, PHYS_SECTION_UNASSIGNED);
2057
2058     return mmio;
2059 }
2060
2061 static uint16_t dummy_section(PhysPageMap *map, AddressSpace *as,
2062                               MemoryRegion *mr)
2063 {
2064     assert(as);
2065     MemoryRegionSection section = {
2066         .address_space = as,
2067         .mr = mr,
2068         .offset_within_address_space = 0,
2069         .offset_within_region = 0,
2070         .size = int128_2_64(),
2071     };
2072
2073     return phys_section_add(map, &section);
2074 }
2075
2076 MemoryRegion *iotlb_to_region(CPUState *cpu, hwaddr index)
2077 {
2078     AddressSpaceDispatch *d = atomic_rcu_read(&cpu->memory_dispatch);
2079     MemoryRegionSection *sections = d->map.sections;
2080
2081     return sections[index & ~TARGET_PAGE_MASK].mr;
2082 }
2083
2084 static void io_mem_init(void)
2085 {
2086     memory_region_init_io(&io_mem_rom, NULL, &unassigned_mem_ops, NULL, NULL, UINT64_MAX);
2087     memory_region_init_io(&io_mem_unassigned, NULL, &unassigned_mem_ops, NULL,
2088                           NULL, UINT64_MAX);
2089     memory_region_init_io(&io_mem_notdirty, NULL, &notdirty_mem_ops, NULL,
2090                           NULL, UINT64_MAX);
2091     memory_region_init_io(&io_mem_watch, NULL, &watch_mem_ops, NULL,
2092                           NULL, UINT64_MAX);
2093 }
2094
2095 static void mem_begin(MemoryListener *listener)
2096 {
2097     AddressSpace *as = container_of(listener, AddressSpace, dispatch_listener);
2098     AddressSpaceDispatch *d = g_new0(AddressSpaceDispatch, 1);
2099     uint16_t n;
2100
2101     n = dummy_section(&d->map, as, &io_mem_unassigned);
2102     assert(n == PHYS_SECTION_UNASSIGNED);
2103     n = dummy_section(&d->map, as, &io_mem_notdirty);
2104     assert(n == PHYS_SECTION_NOTDIRTY);
2105     n = dummy_section(&d->map, as, &io_mem_rom);
2106     assert(n == PHYS_SECTION_ROM);
2107     n = dummy_section(&d->map, as, &io_mem_watch);
2108     assert(n == PHYS_SECTION_WATCH);
2109
2110     d->phys_map  = (PhysPageEntry) { .ptr = PHYS_MAP_NODE_NIL, .skip = 1 };
2111     d->as = as;
2112     as->next_dispatch = d;
2113 }
2114
2115 static void address_space_dispatch_free(AddressSpaceDispatch *d)
2116 {
2117     phys_sections_free(&d->map);
2118     g_free(d);
2119 }
2120
2121 static void mem_commit(MemoryListener *listener)
2122 {
2123     AddressSpace *as = container_of(listener, AddressSpace, dispatch_listener);
2124     AddressSpaceDispatch *cur = as->dispatch;
2125     AddressSpaceDispatch *next = as->next_dispatch;
2126
2127     phys_page_compact_all(next, next->map.nodes_nb);
2128
2129     atomic_rcu_set(&as->dispatch, next);
2130     if (cur) {
2131         call_rcu(cur, address_space_dispatch_free, rcu);
2132     }
2133 }
2134
2135 static void tcg_commit(MemoryListener *listener)
2136 {
2137     CPUState *cpu;
2138
2139     /* since each CPU stores ram addresses in its TLB cache, we must
2140        reset the modified entries */
2141     /* XXX: slow ! */
2142     CPU_FOREACH(cpu) {
2143         /* FIXME: Disentangle the cpu.h circular files deps so we can
2144            directly get the right CPU from listener.  */
2145         if (cpu->tcg_as_listener != listener) {
2146             continue;
2147         }
2148         cpu_reload_memory_map(cpu);
2149     }
2150 }
2151
2152 static void core_log_global_start(MemoryListener *listener)
2153 {
2154     cpu_physical_memory_set_dirty_tracking(true);
2155 }
2156
2157 static void core_log_global_stop(MemoryListener *listener)
2158 {
2159     cpu_physical_memory_set_dirty_tracking(false);
2160 }
2161
2162 static MemoryListener core_memory_listener = {
2163     .log_global_start = core_log_global_start,
2164     .log_global_stop = core_log_global_stop,
2165     .priority = 1,
2166 };
2167
2168 void address_space_init_dispatch(AddressSpace *as)
2169 {
2170     as->dispatch = NULL;
2171     as->dispatch_listener = (MemoryListener) {
2172         .begin = mem_begin,
2173         .commit = mem_commit,
2174         .region_add = mem_add,
2175         .region_nop = mem_add,
2176         .priority = 0,
2177     };
2178     memory_listener_register(&as->dispatch_listener, as);
2179 }
2180
2181 void address_space_unregister(AddressSpace *as)
2182 {
2183     memory_listener_unregister(&as->dispatch_listener);
2184 }
2185
2186 void address_space_destroy_dispatch(AddressSpace *as)
2187 {
2188     AddressSpaceDispatch *d = as->dispatch;
2189
2190     atomic_rcu_set(&as->dispatch, NULL);
2191     if (d) {
2192         call_rcu(d, address_space_dispatch_free, rcu);
2193     }
2194 }
2195
2196 static void memory_map_init(void)
2197 {
2198     system_memory = g_malloc(sizeof(*system_memory));
2199
2200     memory_region_init(system_memory, NULL, "system", UINT64_MAX);
2201     address_space_init(&address_space_memory, system_memory, "memory");
2202
2203     system_io = g_malloc(sizeof(*system_io));
2204     memory_region_init_io(system_io, NULL, &unassigned_io_ops, NULL, "io",
2205                           65536);
2206     address_space_init(&address_space_io, system_io, "I/O");
2207
2208     memory_listener_register(&core_memory_listener, &address_space_memory);
2209 }
2210
2211 MemoryRegion *get_system_memory(void)
2212 {
2213     return system_memory;
2214 }
2215
2216 MemoryRegion *get_system_io(void)
2217 {
2218     return system_io;
2219 }
2220
2221 #endif /* !defined(CONFIG_USER_ONLY) */
2222
2223 /* physical memory access (slow version, mainly for debug) */
2224 #if defined(CONFIG_USER_ONLY)
2225 int cpu_memory_rw_debug(CPUState *cpu, target_ulong addr,
2226                         uint8_t *buf, int len, int is_write)
2227 {
2228     int l, flags;
2229     target_ulong page;
2230     void * p;
2231
2232     while (len > 0) {
2233         page = addr & TARGET_PAGE_MASK;
2234         l = (page + TARGET_PAGE_SIZE) - addr;
2235         if (l > len)
2236             l = len;
2237         flags = page_get_flags(page);
2238         if (!(flags & PAGE_VALID))
2239             return -1;
2240         if (is_write) {
2241             if (!(flags & PAGE_WRITE))
2242                 return -1;
2243             /* XXX: this code should not depend on lock_user */
2244             if (!(p = lock_user(VERIFY_WRITE, addr, l, 0)))
2245                 return -1;
2246             memcpy(p, buf, l);
2247             unlock_user(p, addr, l);
2248         } else {
2249             if (!(flags & PAGE_READ))
2250                 return -1;
2251             /* XXX: this code should not depend on lock_user */
2252             if (!(p = lock_user(VERIFY_READ, addr, l, 1)))
2253                 return -1;
2254             memcpy(buf, p, l);
2255             unlock_user(p, addr, 0);
2256         }
2257         len -= l;
2258         buf += l;
2259         addr += l;
2260     }
2261     return 0;
2262 }
2263
2264 #else
2265
2266 static void invalidate_and_set_dirty(hwaddr addr,
2267                                      hwaddr length)
2268 {
2269     if (cpu_physical_memory_range_includes_clean(addr, length)) {
2270         tb_invalidate_phys_range(addr, addr + length, 0);
2271         cpu_physical_memory_set_dirty_range_nocode(addr, length);
2272     }
2273     xen_modified_memory(addr, length);
2274 }
2275
2276 static int memory_access_size(MemoryRegion *mr, unsigned l, hwaddr addr)
2277 {
2278     unsigned access_size_max = mr->ops->valid.max_access_size;
2279
2280     /* Regions are assumed to support 1-4 byte accesses unless
2281        otherwise specified.  */
2282     if (access_size_max == 0) {
2283         access_size_max = 4;
2284     }
2285
2286     /* Bound the maximum access by the alignment of the address.  */
2287     if (!mr->ops->impl.unaligned) {
2288         unsigned align_size_max = addr & -addr;
2289         if (align_size_max != 0 && align_size_max < access_size_max) {
2290             access_size_max = align_size_max;
2291         }
2292     }
2293
2294     /* Don't attempt accesses larger than the maximum.  */
2295     if (l > access_size_max) {
2296         l = access_size_max;
2297     }
2298     if (l & (l - 1)) {
2299         l = 1 << (qemu_fls(l) - 1);
2300     }
2301
2302     return l;
2303 }
2304
2305 bool address_space_rw(AddressSpace *as, hwaddr addr, uint8_t *buf,
2306                       int len, bool is_write)
2307 {
2308     hwaddr l;
2309     uint8_t *ptr;
2310     uint64_t val;
2311     hwaddr addr1;
2312     MemoryRegion *mr;
2313     bool error = false;
2314
2315     while (len > 0) {
2316         l = len;
2317         mr = address_space_translate(as, addr, &addr1, &l, is_write);
2318
2319         if (is_write) {
2320             if (!memory_access_is_direct(mr, is_write)) {
2321                 l = memory_access_size(mr, l, addr1);
2322                 /* XXX: could force current_cpu to NULL to avoid
2323                    potential bugs */
2324                 switch (l) {
2325                 case 8:
2326                     /* 64 bit write access */
2327                     val = ldq_p(buf);
2328                     error |= io_mem_write(mr, addr1, val, 8);
2329                     break;
2330                 case 4:
2331                     /* 32 bit write access */
2332                     val = ldl_p(buf);
2333                     error |= io_mem_write(mr, addr1, val, 4);
2334                     break;
2335                 case 2:
2336                     /* 16 bit write access */
2337                     val = lduw_p(buf);
2338                     error |= io_mem_write(mr, addr1, val, 2);
2339                     break;
2340                 case 1:
2341                     /* 8 bit write access */
2342                     val = ldub_p(buf);
2343                     error |= io_mem_write(mr, addr1, val, 1);
2344                     break;
2345                 default:
2346                     abort();
2347                 }
2348             } else {
2349                 addr1 += memory_region_get_ram_addr(mr);
2350                 /* RAM case */
2351                 ptr = qemu_get_ram_ptr(addr1);
2352                 memcpy(ptr, buf, l);
2353                 invalidate_and_set_dirty(addr1, l);
2354             }
2355         } else {
2356             if (!memory_access_is_direct(mr, is_write)) {
2357                 /* I/O case */
2358                 l = memory_access_size(mr, l, addr1);
2359                 switch (l) {
2360                 case 8:
2361                     /* 64 bit read access */
2362                     error |= io_mem_read(mr, addr1, &val, 8);
2363                     stq_p(buf, val);
2364                     break;
2365                 case 4:
2366                     /* 32 bit read access */
2367                     error |= io_mem_read(mr, addr1, &val, 4);
2368                     stl_p(buf, val);
2369                     break;
2370                 case 2:
2371                     /* 16 bit read access */
2372                     error |= io_mem_read(mr, addr1, &val, 2);
2373                     stw_p(buf, val);
2374                     break;
2375                 case 1:
2376                     /* 8 bit read access */
2377                     error |= io_mem_read(mr, addr1, &val, 1);
2378                     stb_p(buf, val);
2379                     break;
2380                 default:
2381                     abort();
2382                 }
2383             } else {
2384                 /* RAM case */
2385                 ptr = qemu_get_ram_ptr(mr->ram_addr + addr1);
2386                 memcpy(buf, ptr, l);
2387             }
2388         }
2389         len -= l;
2390         buf += l;
2391         addr += l;
2392     }
2393
2394     return error;
2395 }
2396
2397 bool address_space_write(AddressSpace *as, hwaddr addr,
2398                          const uint8_t *buf, int len)
2399 {
2400     return address_space_rw(as, addr, (uint8_t *)buf, len, true);
2401 }
2402
2403 bool address_space_read(AddressSpace *as, hwaddr addr, uint8_t *buf, int len)
2404 {
2405     return address_space_rw(as, addr, buf, len, false);
2406 }
2407
2408
2409 void cpu_physical_memory_rw(hwaddr addr, uint8_t *buf,
2410                             int len, int is_write)
2411 {
2412     address_space_rw(&address_space_memory, addr, buf, len, is_write);
2413 }
2414
2415 enum write_rom_type {
2416     WRITE_DATA,
2417     FLUSH_CACHE,
2418 };
2419
2420 static inline void cpu_physical_memory_write_rom_internal(AddressSpace *as,
2421     hwaddr addr, const uint8_t *buf, int len, enum write_rom_type type)
2422 {
2423     hwaddr l;
2424     uint8_t *ptr;
2425     hwaddr addr1;
2426     MemoryRegion *mr;
2427
2428     while (len > 0) {
2429         l = len;
2430         mr = address_space_translate(as, addr, &addr1, &l, true);
2431
2432         if (!(memory_region_is_ram(mr) ||
2433               memory_region_is_romd(mr))) {
2434             /* do nothing */
2435         } else {
2436             addr1 += memory_region_get_ram_addr(mr);
2437             /* ROM/RAM case */
2438             ptr = qemu_get_ram_ptr(addr1);
2439             switch (type) {
2440             case WRITE_DATA:
2441                 memcpy(ptr, buf, l);
2442                 invalidate_and_set_dirty(addr1, l);
2443                 break;
2444             case FLUSH_CACHE:
2445                 flush_icache_range((uintptr_t)ptr, (uintptr_t)ptr + l);
2446                 break;
2447             }
2448         }
2449         len -= l;
2450         buf += l;
2451         addr += l;
2452     }
2453 }
2454
2455 /* used for ROM loading : can write in RAM and ROM */
2456 void cpu_physical_memory_write_rom(AddressSpace *as, hwaddr addr,
2457                                    const uint8_t *buf, int len)
2458 {
2459     cpu_physical_memory_write_rom_internal(as, addr, buf, len, WRITE_DATA);
2460 }
2461
2462 void cpu_flush_icache_range(hwaddr start, int len)
2463 {
2464     /*
2465      * This function should do the same thing as an icache flush that was
2466      * triggered from within the guest. For TCG we are always cache coherent,
2467      * so there is no need to flush anything. For KVM / Xen we need to flush
2468      * the host's instruction cache at least.
2469      */
2470     if (tcg_enabled()) {
2471         return;
2472     }
2473
2474     cpu_physical_memory_write_rom_internal(&address_space_memory,
2475                                            start, NULL, len, FLUSH_CACHE);
2476 }
2477
2478 typedef struct {
2479     MemoryRegion *mr;
2480     void *buffer;
2481     hwaddr addr;
2482     hwaddr len;
2483 } BounceBuffer;
2484
2485 static BounceBuffer bounce;
2486
2487 typedef struct MapClient {
2488     void *opaque;
2489     void (*callback)(void *opaque);
2490     QLIST_ENTRY(MapClient) link;
2491 } MapClient;
2492
2493 static QLIST_HEAD(map_client_list, MapClient) map_client_list
2494     = QLIST_HEAD_INITIALIZER(map_client_list);
2495
2496 void *cpu_register_map_client(void *opaque, void (*callback)(void *opaque))
2497 {
2498     MapClient *client = g_malloc(sizeof(*client));
2499
2500     client->opaque = opaque;
2501     client->callback = callback;
2502     QLIST_INSERT_HEAD(&map_client_list, client, link);
2503     return client;
2504 }
2505
2506 static void cpu_unregister_map_client(void *_client)
2507 {
2508     MapClient *client = (MapClient *)_client;
2509
2510     QLIST_REMOVE(client, link);
2511     g_free(client);
2512 }
2513
2514 static void cpu_notify_map_clients(void)
2515 {
2516     MapClient *client;
2517
2518     while (!QLIST_EMPTY(&map_client_list)) {
2519         client = QLIST_FIRST(&map_client_list);
2520         client->callback(client->opaque);
2521         cpu_unregister_map_client(client);
2522     }
2523 }
2524
2525 bool address_space_access_valid(AddressSpace *as, hwaddr addr, int len, bool is_write)
2526 {
2527     MemoryRegion *mr;
2528     hwaddr l, xlat;
2529
2530     while (len > 0) {
2531         l = len;
2532         mr = address_space_translate(as, addr, &xlat, &l, is_write);
2533         if (!memory_access_is_direct(mr, is_write)) {
2534             l = memory_access_size(mr, l, addr);
2535             if (!memory_region_access_valid(mr, xlat, l, is_write)) {
2536                 return false;
2537             }
2538         }
2539
2540         len -= l;
2541         addr += l;
2542     }
2543     return true;
2544 }
2545
2546 /* Map a physical memory region into a host virtual address.
2547  * May map a subset of the requested range, given by and returned in *plen.
2548  * May return NULL if resources needed to perform the mapping are exhausted.
2549  * Use only for reads OR writes - not for read-modify-write operations.
2550  * Use cpu_register_map_client() to know when retrying the map operation is
2551  * likely to succeed.
2552  */
2553 void *address_space_map(AddressSpace *as,
2554                         hwaddr addr,
2555                         hwaddr *plen,
2556                         bool is_write)
2557 {
2558     hwaddr len = *plen;
2559     hwaddr done = 0;
2560     hwaddr l, xlat, base;
2561     MemoryRegion *mr, *this_mr;
2562     ram_addr_t raddr;
2563
2564     if (len == 0) {
2565         return NULL;
2566     }
2567
2568     l = len;
2569     mr = address_space_translate(as, addr, &xlat, &l, is_write);
2570     if (!memory_access_is_direct(mr, is_write)) {
2571         if (bounce.buffer) {
2572             return NULL;
2573         }
2574         /* Avoid unbounded allocations */
2575         l = MIN(l, TARGET_PAGE_SIZE);
2576         bounce.buffer = qemu_memalign(TARGET_PAGE_SIZE, l);
2577         bounce.addr = addr;
2578         bounce.len = l;
2579
2580         memory_region_ref(mr);
2581         bounce.mr = mr;
2582         if (!is_write) {
2583             address_space_read(as, addr, bounce.buffer, l);
2584         }
2585
2586         *plen = l;
2587         return bounce.buffer;
2588     }
2589
2590     base = xlat;
2591     raddr = memory_region_get_ram_addr(mr);
2592
2593     for (;;) {
2594         len -= l;
2595         addr += l;
2596         done += l;
2597         if (len == 0) {
2598             break;
2599         }
2600
2601         l = len;
2602         this_mr = address_space_translate(as, addr, &xlat, &l, is_write);
2603         if (this_mr != mr || xlat != base + done) {
2604             break;
2605         }
2606     }
2607
2608     memory_region_ref(mr);
2609     *plen = done;
2610     return qemu_ram_ptr_length(raddr + base, plen);
2611 }
2612
2613 /* Unmaps a memory region previously mapped by address_space_map().
2614  * Will also mark the memory as dirty if is_write == 1.  access_len gives
2615  * the amount of memory that was actually read or written by the caller.
2616  */
2617 void address_space_unmap(AddressSpace *as, void *buffer, hwaddr len,
2618                          int is_write, hwaddr access_len)
2619 {
2620     if (buffer != bounce.buffer) {
2621         MemoryRegion *mr;
2622         ram_addr_t addr1;
2623
2624         mr = qemu_ram_addr_from_host(buffer, &addr1);
2625         assert(mr != NULL);
2626         if (is_write) {
2627             invalidate_and_set_dirty(addr1, access_len);
2628         }
2629         if (xen_enabled()) {
2630             xen_invalidate_map_cache_entry(buffer);
2631         }
2632         memory_region_unref(mr);
2633         return;
2634     }
2635     if (is_write) {
2636         address_space_write(as, bounce.addr, bounce.buffer, access_len);
2637     }
2638     qemu_vfree(bounce.buffer);
2639     bounce.buffer = NULL;
2640     memory_region_unref(bounce.mr);
2641     cpu_notify_map_clients();
2642 }
2643
2644 void *cpu_physical_memory_map(hwaddr addr,
2645                               hwaddr *plen,
2646                               int is_write)
2647 {
2648     return address_space_map(&address_space_memory, addr, plen, is_write);
2649 }
2650
2651 void cpu_physical_memory_unmap(void *buffer, hwaddr len,
2652                                int is_write, hwaddr access_len)
2653 {
2654     return address_space_unmap(&address_space_memory, buffer, len, is_write, access_len);
2655 }
2656
2657 /* warning: addr must be aligned */
2658 static inline uint32_t ldl_phys_internal(AddressSpace *as, hwaddr addr,
2659                                          enum device_endian endian)
2660 {
2661     uint8_t *ptr;
2662     uint64_t val;
2663     MemoryRegion *mr;
2664     hwaddr l = 4;
2665     hwaddr addr1;
2666
2667     mr = address_space_translate(as, addr, &addr1, &l, false);
2668     if (l < 4 || !memory_access_is_direct(mr, false)) {
2669         /* I/O case */
2670         io_mem_read(mr, addr1, &val, 4);
2671 #if defined(TARGET_WORDS_BIGENDIAN)
2672         if (endian == DEVICE_LITTLE_ENDIAN) {
2673             val = bswap32(val);
2674         }
2675 #else
2676         if (endian == DEVICE_BIG_ENDIAN) {
2677             val = bswap32(val);
2678         }
2679 #endif
2680     } else {
2681         /* RAM case */
2682         ptr = qemu_get_ram_ptr((memory_region_get_ram_addr(mr)
2683                                 & TARGET_PAGE_MASK)
2684                                + addr1);
2685         switch (endian) {
2686         case DEVICE_LITTLE_ENDIAN:
2687             val = ldl_le_p(ptr);
2688             break;
2689         case DEVICE_BIG_ENDIAN:
2690             val = ldl_be_p(ptr);
2691             break;
2692         default:
2693             val = ldl_p(ptr);
2694             break;
2695         }
2696     }
2697     return val;
2698 }
2699
2700 uint32_t ldl_phys(AddressSpace *as, hwaddr addr)
2701 {
2702     return ldl_phys_internal(as, addr, DEVICE_NATIVE_ENDIAN);
2703 }
2704
2705 uint32_t ldl_le_phys(AddressSpace *as, hwaddr addr)
2706 {
2707     return ldl_phys_internal(as, addr, DEVICE_LITTLE_ENDIAN);
2708 }
2709
2710 uint32_t ldl_be_phys(AddressSpace *as, hwaddr addr)
2711 {
2712     return ldl_phys_internal(as, addr, DEVICE_BIG_ENDIAN);
2713 }
2714
2715 /* warning: addr must be aligned */
2716 static inline uint64_t ldq_phys_internal(AddressSpace *as, hwaddr addr,
2717                                          enum device_endian endian)
2718 {
2719     uint8_t *ptr;
2720     uint64_t val;
2721     MemoryRegion *mr;
2722     hwaddr l = 8;
2723     hwaddr addr1;
2724
2725     mr = address_space_translate(as, addr, &addr1, &l,
2726                                  false);
2727     if (l < 8 || !memory_access_is_direct(mr, false)) {
2728         /* I/O case */
2729         io_mem_read(mr, addr1, &val, 8);
2730 #if defined(TARGET_WORDS_BIGENDIAN)
2731         if (endian == DEVICE_LITTLE_ENDIAN) {
2732             val = bswap64(val);
2733         }
2734 #else
2735         if (endian == DEVICE_BIG_ENDIAN) {
2736             val = bswap64(val);
2737         }
2738 #endif
2739     } else {
2740         /* RAM case */
2741         ptr = qemu_get_ram_ptr((memory_region_get_ram_addr(mr)
2742                                 & TARGET_PAGE_MASK)
2743                                + addr1);
2744         switch (endian) {
2745         case DEVICE_LITTLE_ENDIAN:
2746             val = ldq_le_p(ptr);
2747             break;
2748         case DEVICE_BIG_ENDIAN:
2749             val = ldq_be_p(ptr);
2750             break;
2751         default:
2752             val = ldq_p(ptr);
2753             break;
2754         }
2755     }
2756     return val;
2757 }
2758
2759 uint64_t ldq_phys(AddressSpace *as, hwaddr addr)
2760 {
2761     return ldq_phys_internal(as, addr, DEVICE_NATIVE_ENDIAN);
2762 }
2763
2764 uint64_t ldq_le_phys(AddressSpace *as, hwaddr addr)
2765 {
2766     return ldq_phys_internal(as, addr, DEVICE_LITTLE_ENDIAN);
2767 }
2768
2769 uint64_t ldq_be_phys(AddressSpace *as, hwaddr addr)
2770 {
2771     return ldq_phys_internal(as, addr, DEVICE_BIG_ENDIAN);
2772 }
2773
2774 /* XXX: optimize */
2775 uint32_t ldub_phys(AddressSpace *as, hwaddr addr)
2776 {
2777     uint8_t val;
2778     address_space_rw(as, addr, &val, 1, 0);
2779     return val;
2780 }
2781
2782 /* warning: addr must be aligned */
2783 static inline uint32_t lduw_phys_internal(AddressSpace *as, hwaddr addr,
2784                                           enum device_endian endian)
2785 {
2786     uint8_t *ptr;
2787     uint64_t val;
2788     MemoryRegion *mr;
2789     hwaddr l = 2;
2790     hwaddr addr1;
2791
2792     mr = address_space_translate(as, addr, &addr1, &l,
2793                                  false);
2794     if (l < 2 || !memory_access_is_direct(mr, false)) {
2795         /* I/O case */
2796         io_mem_read(mr, addr1, &val, 2);
2797 #if defined(TARGET_WORDS_BIGENDIAN)
2798         if (endian == DEVICE_LITTLE_ENDIAN) {
2799             val = bswap16(val);
2800         }
2801 #else
2802         if (endian == DEVICE_BIG_ENDIAN) {
2803             val = bswap16(val);
2804         }
2805 #endif
2806     } else {
2807         /* RAM case */
2808         ptr = qemu_get_ram_ptr((memory_region_get_ram_addr(mr)
2809                                 & TARGET_PAGE_MASK)
2810                                + addr1);
2811         switch (endian) {
2812         case DEVICE_LITTLE_ENDIAN:
2813             val = lduw_le_p(ptr);
2814             break;
2815         case DEVICE_BIG_ENDIAN:
2816             val = lduw_be_p(ptr);
2817             break;
2818         default:
2819             val = lduw_p(ptr);
2820             break;
2821         }
2822     }
2823     return val;
2824 }
2825
2826 uint32_t lduw_phys(AddressSpace *as, hwaddr addr)
2827 {
2828     return lduw_phys_internal(as, addr, DEVICE_NATIVE_ENDIAN);
2829 }
2830
2831 uint32_t lduw_le_phys(AddressSpace *as, hwaddr addr)
2832 {
2833     return lduw_phys_internal(as, addr, DEVICE_LITTLE_ENDIAN);
2834 }
2835
2836 uint32_t lduw_be_phys(AddressSpace *as, hwaddr addr)
2837 {
2838     return lduw_phys_internal(as, addr, DEVICE_BIG_ENDIAN);
2839 }
2840
2841 /* warning: addr must be aligned. The ram page is not masked as dirty
2842    and the code inside is not invalidated. It is useful if the dirty
2843    bits are used to track modified PTEs */
2844 void stl_phys_notdirty(AddressSpace *as, hwaddr addr, uint32_t val)
2845 {
2846     uint8_t *ptr;
2847     MemoryRegion *mr;
2848     hwaddr l = 4;
2849     hwaddr addr1;
2850
2851     mr = address_space_translate(as, addr, &addr1, &l,
2852                                  true);
2853     if (l < 4 || !memory_access_is_direct(mr, true)) {
2854         io_mem_write(mr, addr1, val, 4);
2855     } else {
2856         addr1 += memory_region_get_ram_addr(mr) & TARGET_PAGE_MASK;
2857         ptr = qemu_get_ram_ptr(addr1);
2858         stl_p(ptr, val);
2859
2860         if (unlikely(in_migration)) {
2861             if (cpu_physical_memory_is_clean(addr1)) {
2862                 /* invalidate code */
2863                 tb_invalidate_phys_page_range(addr1, addr1 + 4, 0);
2864                 /* set dirty bit */
2865                 cpu_physical_memory_set_dirty_range_nocode(addr1, 4);
2866             }
2867         }
2868     }
2869 }
2870
2871 /* warning: addr must be aligned */
2872 static inline void stl_phys_internal(AddressSpace *as,
2873                                      hwaddr addr, uint32_t val,
2874                                      enum device_endian endian)
2875 {
2876     uint8_t *ptr;
2877     MemoryRegion *mr;
2878     hwaddr l = 4;
2879     hwaddr addr1;
2880
2881     mr = address_space_translate(as, addr, &addr1, &l,
2882                                  true);
2883     if (l < 4 || !memory_access_is_direct(mr, true)) {
2884 #if defined(TARGET_WORDS_BIGENDIAN)
2885         if (endian == DEVICE_LITTLE_ENDIAN) {
2886             val = bswap32(val);
2887         }
2888 #else
2889         if (endian == DEVICE_BIG_ENDIAN) {
2890             val = bswap32(val);
2891         }
2892 #endif
2893         io_mem_write(mr, addr1, val, 4);
2894     } else {
2895         /* RAM case */
2896         addr1 += memory_region_get_ram_addr(mr) & TARGET_PAGE_MASK;
2897         ptr = qemu_get_ram_ptr(addr1);
2898         switch (endian) {
2899         case DEVICE_LITTLE_ENDIAN:
2900             stl_le_p(ptr, val);
2901             break;
2902         case DEVICE_BIG_ENDIAN:
2903             stl_be_p(ptr, val);
2904             break;
2905         default:
2906             stl_p(ptr, val);
2907             break;
2908         }
2909         invalidate_and_set_dirty(addr1, 4);
2910     }
2911 }
2912
2913 void stl_phys(AddressSpace *as, hwaddr addr, uint32_t val)
2914 {
2915     stl_phys_internal(as, addr, val, DEVICE_NATIVE_ENDIAN);
2916 }
2917
2918 void stl_le_phys(AddressSpace *as, hwaddr addr, uint32_t val)
2919 {
2920     stl_phys_internal(as, addr, val, DEVICE_LITTLE_ENDIAN);
2921 }
2922
2923 void stl_be_phys(AddressSpace *as, hwaddr addr, uint32_t val)
2924 {
2925     stl_phys_internal(as, addr, val, DEVICE_BIG_ENDIAN);
2926 }
2927
2928 /* XXX: optimize */
2929 void stb_phys(AddressSpace *as, hwaddr addr, uint32_t val)
2930 {
2931     uint8_t v = val;
2932     address_space_rw(as, addr, &v, 1, 1);
2933 }
2934
2935 /* warning: addr must be aligned */
2936 static inline void stw_phys_internal(AddressSpace *as,
2937                                      hwaddr addr, uint32_t val,
2938                                      enum device_endian endian)
2939 {
2940     uint8_t *ptr;
2941     MemoryRegion *mr;
2942     hwaddr l = 2;
2943     hwaddr addr1;
2944
2945     mr = address_space_translate(as, addr, &addr1, &l, true);
2946     if (l < 2 || !memory_access_is_direct(mr, true)) {
2947 #if defined(TARGET_WORDS_BIGENDIAN)
2948         if (endian == DEVICE_LITTLE_ENDIAN) {
2949             val = bswap16(val);
2950         }
2951 #else
2952         if (endian == DEVICE_BIG_ENDIAN) {
2953             val = bswap16(val);
2954         }
2955 #endif
2956         io_mem_write(mr, addr1, val, 2);
2957     } else {
2958         /* RAM case */
2959         addr1 += memory_region_get_ram_addr(mr) & TARGET_PAGE_MASK;
2960         ptr = qemu_get_ram_ptr(addr1);
2961         switch (endian) {
2962         case DEVICE_LITTLE_ENDIAN:
2963             stw_le_p(ptr, val);
2964             break;
2965         case DEVICE_BIG_ENDIAN:
2966             stw_be_p(ptr, val);
2967             break;
2968         default:
2969             stw_p(ptr, val);
2970             break;
2971         }
2972         invalidate_and_set_dirty(addr1, 2);
2973     }
2974 }
2975
2976 void stw_phys(AddressSpace *as, hwaddr addr, uint32_t val)
2977 {
2978     stw_phys_internal(as, addr, val, DEVICE_NATIVE_ENDIAN);
2979 }
2980
2981 void stw_le_phys(AddressSpace *as, hwaddr addr, uint32_t val)
2982 {
2983     stw_phys_internal(as, addr, val, DEVICE_LITTLE_ENDIAN);
2984 }
2985
2986 void stw_be_phys(AddressSpace *as, hwaddr addr, uint32_t val)
2987 {
2988     stw_phys_internal(as, addr, val, DEVICE_BIG_ENDIAN);
2989 }
2990
2991 /* XXX: optimize */
2992 void stq_phys(AddressSpace *as, hwaddr addr, uint64_t val)
2993 {
2994     val = tswap64(val);
2995     address_space_rw(as, addr, (void *) &val, 8, 1);
2996 }
2997
2998 void stq_le_phys(AddressSpace *as, hwaddr addr, uint64_t val)
2999 {
3000     val = cpu_to_le64(val);
3001     address_space_rw(as, addr, (void *) &val, 8, 1);
3002 }
3003
3004 void stq_be_phys(AddressSpace *as, hwaddr addr, uint64_t val)
3005 {
3006     val = cpu_to_be64(val);
3007     address_space_rw(as, addr, (void *) &val, 8, 1);
3008 }
3009
3010 /* virtual memory access for debug (includes writing to ROM) */
3011 int cpu_memory_rw_debug(CPUState *cpu, target_ulong addr,
3012                         uint8_t *buf, int len, int is_write)
3013 {
3014     int l;
3015     hwaddr phys_addr;
3016     target_ulong page;
3017
3018     while (len > 0) {
3019         page = addr & TARGET_PAGE_MASK;
3020         phys_addr = cpu_get_phys_page_debug(cpu, page);
3021         /* if no physical page mapped, return an error */
3022         if (phys_addr == -1)
3023             return -1;
3024         l = (page + TARGET_PAGE_SIZE) - addr;
3025         if (l > len)
3026             l = len;
3027         phys_addr += (addr & ~TARGET_PAGE_MASK);
3028         if (is_write) {
3029             cpu_physical_memory_write_rom(cpu->as, phys_addr, buf, l);
3030         } else {
3031             address_space_rw(cpu->as, phys_addr, buf, l, 0);
3032         }
3033         len -= l;
3034         buf += l;
3035         addr += l;
3036     }
3037     return 0;
3038 }
3039 #endif
3040
3041 /*
3042  * A helper function for the _utterly broken_ virtio device model to find out if
3043  * it's running on a big endian machine. Don't do this at home kids!
3044  */
3045 bool target_words_bigendian(void);
3046 bool target_words_bigendian(void)
3047 {
3048 #if defined(TARGET_WORDS_BIGENDIAN)
3049     return true;
3050 #else
3051     return false;
3052 #endif
3053 }
3054
3055 #ifndef CONFIG_USER_ONLY
3056 bool cpu_physical_memory_is_io(hwaddr phys_addr)
3057 {
3058     MemoryRegion*mr;
3059     hwaddr l = 1;
3060
3061     mr = address_space_translate(&address_space_memory,
3062                                  phys_addr, &phys_addr, &l, false);
3063
3064     return !(memory_region_is_ram(mr) ||
3065              memory_region_is_romd(mr));
3066 }
3067
3068 void qemu_ram_foreach_block(RAMBlockIterFunc func, void *opaque)
3069 {
3070     RAMBlock *block;
3071
3072     rcu_read_lock();
3073     QLIST_FOREACH_RCU(block, &ram_list.blocks, next) {
3074         func(block->host, block->offset, block->used_length, opaque);
3075     }
3076     rcu_read_unlock();
3077 }
3078 #endif