signal/all: remove return value from setup_sigcontext

[qemu.git] / exec.c

diff --git a/exec.c b/exec.c
index 7e49e8e555e5e63ec4db6d36738e7c422b7128d7..4e179a6f66e736e7d8741ee3b568945dd02cd04c 100644 (file)
--- a/exec.c
+++ b/exec.c
@@ -17,9 +17,7 @@
  * License along with this library; if not, see <http://www.gnu.org/licenses/>.
  */
 #include "config.h"
  * License along with this library; if not, see <http://www.gnu.org/licenses/>.
  */
 #include "config.h"

-#ifdef _WIN32
-#include <windows.h>
-#else
+#ifndef _WIN32

 #include <sys/types.h>
 #include <sys/mman.h>
 #endif
 #include <sys/types.h>
 #include <sys/mman.h>
 #endif


@@ -35,6 +33,7 @@
 #include "hw/xen/xen.h"
 #include "qemu/timer.h"
 #include "qemu/config-file.h"
 #include "hw/xen/xen.h"
 #include "qemu/timer.h"
 #include "qemu/config-file.h"

+#include "qemu/error-report.h"

 #include "exec/memory.h"
 #include "sysemu/dma.h"
 #include "exec/address-spaces.h"
 #include "exec/memory.h"
 #include "sysemu/dma.h"
 #include "exec/address-spaces.h"


@@ -50,6 +49,7 @@
 #include "translate-all.h"
 
 #include "exec/memory-internal.h"
 #include "translate-all.h"
 
 #include "exec/memory-internal.h"

+#include "exec/ram_addr.h"

 #include "qemu/cache-utils.h"
 
 #include "qemu/range.h"
 #include "qemu/cache-utils.h"
 
 #include "qemu/range.h"


@@ -57,7 +57,7 @@
 //#define DEBUG_SUBPAGE
 
 #if !defined(CONFIG_USER_ONLY)
 //#define DEBUG_SUBPAGE
 
 #if !defined(CONFIG_USER_ONLY)

-static int in_migration;
+static bool in_migration;

 
 RAMList ram_list = { .blocks = QTAILQ_HEAD_INITIALIZER(ram_list.blocks) };
 
 
 RAMList ram_list = { .blocks = QTAILQ_HEAD_INITIALIZER(ram_list.blocks) };
 


@@ -137,6 +137,7 @@ typedef struct subpage_t {
 
 static void io_mem_init(void);
 static void memory_map_init(void);
 
 static void io_mem_init(void);
 static void memory_map_init(void);

+static void tcg_commit(MemoryListener *listener);

 
 static MemoryRegion io_mem_watch;
 #endif
 
 static MemoryRegion io_mem_watch;
 #endif


@@ -338,6 +339,18 @@ address_space_translate_internal(AddressSpaceDispatch *d, hwaddr addr, hwaddr *x
     return section;
 }
 
     return section;
 }
 

+static inline bool memory_access_is_direct(MemoryRegion *mr, bool is_write)
+{
+    if (memory_region_is_ram(mr)) {
+        return !(is_write && mr->readonly);
+    }
+    if (memory_region_is_romd(mr)) {
+        return !is_write;
+    }
+
+    return false;
+}
+

 MemoryRegion *address_space_translate(AddressSpace *as, hwaddr addr,
                                       hwaddr *xlat, hwaddr *plen,
                                       bool is_write)
 MemoryRegion *address_space_translate(AddressSpace *as, hwaddr addr,
                                       hwaddr *xlat, hwaddr *plen,
                                       bool is_write)


@@ -367,6 +380,11 @@ MemoryRegion *address_space_translate(AddressSpace *as, hwaddr addr,
         as = iotlb.target_as;
     }
 
         as = iotlb.target_as;
     }
 

+    if (xen_enabled() && memory_access_is_direct(mr, is_write)) {
+        hwaddr page = ((addr & TARGET_PAGE_MASK) + TARGET_PAGE_SIZE) - addr;
+        len = MIN(page, len);
+    }
+

     *plen = len;
     *xlat = addr;
     return mr;
     *plen = len;
     *xlat = addr;
     return mr;


@@ -402,7 +420,7 @@ static int cpu_common_post_load(void *opaque, int version_id)
     /* 0x01 was CPU_INTERRUPT_EXIT. This line can be removed when the
        version_id is increased. */
     cpu->interrupt_request &= ~0x01;
     /* 0x01 was CPU_INTERRUPT_EXIT. This line can be removed when the
        version_id is increased. */
     cpu->interrupt_request &= ~0x01;

-    tlb_flush(cpu->env_ptr, 1);
+    tlb_flush(cpu, 1);

 
     return 0;
 }
 
     return 0;
 }


@@ -411,9 +429,8 @@ const VMStateDescription vmstate_cpu_common = {
     .name = "cpu_common",
     .version_id = 1,
     .minimum_version_id = 1,
     .name = "cpu_common",
     .version_id = 1,
     .minimum_version_id = 1,

-    .minimum_version_id_old = 1,

     .post_load = cpu_common_post_load,
     .post_load = cpu_common_post_load,

-    .fields      = (VMStateField []) {
+    .fields = (VMStateField[]) {

         VMSTATE_UINT32(halted, CPUState),
         VMSTATE_UINT32(interrupt_request, CPUState),
         VMSTATE_END_OF_LIST()
         VMSTATE_UINT32(halted, CPUState),
         VMSTATE_UINT32(interrupt_request, CPUState),
         VMSTATE_END_OF_LIST()


@@ -435,6 +452,22 @@ CPUState *qemu_get_cpu(int index)
     return NULL;
 }
 
     return NULL;
 }
 

+#if !defined(CONFIG_USER_ONLY)
+void tcg_cpu_address_space_init(CPUState *cpu, AddressSpace *as)
+{
+    /* We only support one address space per cpu at the moment.  */
+    assert(cpu->as == as);
+
+    if (cpu->tcg_as_listener) {
+        memory_listener_unregister(cpu->tcg_as_listener);
+    } else {
+        cpu->tcg_as_listener = g_new0(MemoryListener, 1);
+    }
+    cpu->tcg_as_listener->commit = tcg_commit;
+    memory_listener_register(cpu->tcg_as_listener, as);
+}
+#endif
+

 void cpu_exec_init(CPUArchState *env)
 {
     CPUState *cpu = ENV_GET_CPU(env);
 void cpu_exec_init(CPUArchState *env)
 {
     CPUState *cpu = ENV_GET_CPU(env);


@@ -451,9 +484,10 @@ void cpu_exec_init(CPUArchState *env)
     }
     cpu->cpu_index = cpu_index;
     cpu->numa_node = 0;
     }
     cpu->cpu_index = cpu_index;
     cpu->numa_node = 0;

-    QTAILQ_INIT(&env->breakpoints);
-    QTAILQ_INIT(&env->watchpoints);
+    QTAILQ_INIT(&cpu->breakpoints);
+    QTAILQ_INIT(&cpu->watchpoints);

 #ifndef CONFIG_USER_ONLY
 #ifndef CONFIG_USER_ONLY

+    cpu->as = &address_space_memory;

     cpu->thread_id = qemu_get_thread_id();
 #endif
     QTAILQ_INSERT_TAIL(&cpus, cpu, node);
     cpu->thread_id = qemu_get_thread_id();
 #endif
     QTAILQ_INSERT_TAIL(&cpus, cpu, node);


@@ -485,36 +519,37 @@ static void breakpoint_invalidate(CPUState *cpu, target_ulong pc)
 {
     hwaddr phys = cpu_get_phys_page_debug(cpu, pc);
     if (phys != -1) {
 {
     hwaddr phys = cpu_get_phys_page_debug(cpu, pc);
     if (phys != -1) {

-        tb_invalidate_phys_addr(phys | (pc & ~TARGET_PAGE_MASK));
+        tb_invalidate_phys_addr(cpu->as,
+                                phys | (pc & ~TARGET_PAGE_MASK));

     }
 }
 #endif
 #endif /* TARGET_HAS_ICE */
 
 #if defined(CONFIG_USER_ONLY)
     }
 }
 #endif
 #endif /* TARGET_HAS_ICE */
 
 #if defined(CONFIG_USER_ONLY)

-void cpu_watchpoint_remove_all(CPUArchState *env, int mask)
+void cpu_watchpoint_remove_all(CPUState *cpu, int mask)

 
 {
 }
 
 
 {
 }
 

-int cpu_watchpoint_insert(CPUArchState *env, target_ulong addr, target_ulong len,
+int cpu_watchpoint_insert(CPUState *cpu, vaddr addr, vaddr len,

                           int flags, CPUWatchpoint **watchpoint)
 {
     return -ENOSYS;
 }
 #else
 /* Add a watchpoint.  */
                           int flags, CPUWatchpoint **watchpoint)
 {
     return -ENOSYS;
 }
 #else
 /* Add a watchpoint.  */

-int cpu_watchpoint_insert(CPUArchState *env, target_ulong addr, target_ulong len,
+int cpu_watchpoint_insert(CPUState *cpu, vaddr addr, vaddr len,

                           int flags, CPUWatchpoint **watchpoint)
 {
                           int flags, CPUWatchpoint **watchpoint)
 {

-    target_ulong len_mask = ~(len - 1);
+    vaddr len_mask = ~(len - 1);

     CPUWatchpoint *wp;
 
     /* sanity checks: allow power-of-2 lengths, deny unaligned watchpoints */
     if ((len & (len - 1)) || (addr & ~len_mask) ||
             len == 0 || len > TARGET_PAGE_SIZE) {
     CPUWatchpoint *wp;
 
     /* sanity checks: allow power-of-2 lengths, deny unaligned watchpoints */
     if ((len & (len - 1)) || (addr & ~len_mask) ||
             len == 0 || len > TARGET_PAGE_SIZE) {

-        fprintf(stderr, "qemu: tried to set invalid watchpoint at "
-                TARGET_FMT_lx ", len=" TARGET_FMT_lu "\n", addr, len);
+        error_report("tried to set invalid watchpoint at %"
+                     VADDR_PRIx ", len=%" VADDR_PRIu, addr, len);

         return -EINVAL;
     }
     wp = g_malloc(sizeof(*wp));
         return -EINVAL;
     }
     wp = g_malloc(sizeof(*wp));


@@ -524,12 +559,13 @@ int cpu_watchpoint_insert(CPUArchState *env, target_ulong addr, target_ulong len
     wp->flags = flags;
 
     /* keep all GDB-injected watchpoints in front */
     wp->flags = flags;
 
     /* keep all GDB-injected watchpoints in front */

-    if (flags & BP_GDB)
-        QTAILQ_INSERT_HEAD(&env->watchpoints, wp, entry);
-    else
-        QTAILQ_INSERT_TAIL(&env->watchpoints, wp, entry);
+    if (flags & BP_GDB) {
+        QTAILQ_INSERT_HEAD(&cpu->watchpoints, wp, entry);
+    } else {
+        QTAILQ_INSERT_TAIL(&cpu->watchpoints, wp, entry);
+    }

 
 

-    tlb_flush_page(env, addr);
+    tlb_flush_page(cpu, addr);

 
     if (watchpoint)
         *watchpoint = wp;
 
     if (watchpoint)
         *watchpoint = wp;


@@ -537,16 +573,16 @@ int cpu_watchpoint_insert(CPUArchState *env, target_ulong addr, target_ulong len
 }
 
 /* Remove a specific watchpoint.  */
 }
 
 /* Remove a specific watchpoint.  */

-int cpu_watchpoint_remove(CPUArchState *env, target_ulong addr, target_ulong len,
+int cpu_watchpoint_remove(CPUState *cpu, vaddr addr, vaddr len,

                           int flags)
 {
                           int flags)
 {

-    target_ulong len_mask = ~(len - 1);
+    vaddr len_mask = ~(len - 1);

     CPUWatchpoint *wp;
 
     CPUWatchpoint *wp;
 

-    QTAILQ_FOREACH(wp, &env->watchpoints, entry) {
+    QTAILQ_FOREACH(wp, &cpu->watchpoints, entry) {

         if (addr == wp->vaddr && len_mask == wp->len_mask
                 && flags == (wp->flags & ~BP_WATCHPOINT_HIT)) {
         if (addr == wp->vaddr && len_mask == wp->len_mask
                 && flags == (wp->flags & ~BP_WATCHPOINT_HIT)) {

-            cpu_watchpoint_remove_by_ref(env, wp);
+            cpu_watchpoint_remove_by_ref(cpu, wp);

             return 0;
         }
     }
             return 0;
         }
     }


@@ -554,29 +590,30 @@ int cpu_watchpoint_remove(CPUArchState *env, target_ulong addr, target_ulong len
 }
 
 /* Remove a specific watchpoint by reference.  */
 }
 
 /* Remove a specific watchpoint by reference.  */

-void cpu_watchpoint_remove_by_ref(CPUArchState *env, CPUWatchpoint *watchpoint)
+void cpu_watchpoint_remove_by_ref(CPUState *cpu, CPUWatchpoint *watchpoint)

 {
 {

-    QTAILQ_REMOVE(&env->watchpoints, watchpoint, entry);
+    QTAILQ_REMOVE(&cpu->watchpoints, watchpoint, entry);

 
 

-    tlb_flush_page(env, watchpoint->vaddr);
+    tlb_flush_page(cpu, watchpoint->vaddr);

 
     g_free(watchpoint);
 }
 
 /* Remove all matching watchpoints.  */
 
     g_free(watchpoint);
 }
 
 /* Remove all matching watchpoints.  */

-void cpu_watchpoint_remove_all(CPUArchState *env, int mask)
+void cpu_watchpoint_remove_all(CPUState *cpu, int mask)

 {
     CPUWatchpoint *wp, *next;
 
 {
     CPUWatchpoint *wp, *next;
 

-    QTAILQ_FOREACH_SAFE(wp, &env->watchpoints, entry, next) {
-        if (wp->flags & mask)
-            cpu_watchpoint_remove_by_ref(env, wp);
+    QTAILQ_FOREACH_SAFE(wp, &cpu->watchpoints, entry, next) {
+        if (wp->flags & mask) {
+            cpu_watchpoint_remove_by_ref(cpu, wp);
+        }

     }
 }
 #endif
 
 /* Add a breakpoint.  */
     }
 }
 #endif
 
 /* Add a breakpoint.  */

-int cpu_breakpoint_insert(CPUArchState *env, target_ulong pc, int flags,
+int cpu_breakpoint_insert(CPUState *cpu, vaddr pc, int flags,

                           CPUBreakpoint **breakpoint)
 {
 #if defined(TARGET_HAS_ICE)
                           CPUBreakpoint **breakpoint)
 {
 #if defined(TARGET_HAS_ICE)


@@ -589,12 +626,12 @@ int cpu_breakpoint_insert(CPUArchState *env, target_ulong pc, int flags,
 
     /* keep all GDB-injected breakpoints in front */
     if (flags & BP_GDB) {
 
     /* keep all GDB-injected breakpoints in front */
     if (flags & BP_GDB) {

-        QTAILQ_INSERT_HEAD(&env->breakpoints, bp, entry);
+        QTAILQ_INSERT_HEAD(&cpu->breakpoints, bp, entry);

     } else {
     } else {

-        QTAILQ_INSERT_TAIL(&env->breakpoints, bp, entry);
+        QTAILQ_INSERT_TAIL(&cpu->breakpoints, bp, entry);

     }
 
     }
 

-    breakpoint_invalidate(ENV_GET_CPU(env), pc);
+    breakpoint_invalidate(cpu, pc);

 
     if (breakpoint) {
         *breakpoint = bp;
 
     if (breakpoint) {
         *breakpoint = bp;


@@ -606,14 +643,14 @@ int cpu_breakpoint_insert(CPUArchState *env, target_ulong pc, int flags,
 }
 
 /* Remove a specific breakpoint.  */
 }
 
 /* Remove a specific breakpoint.  */

-int cpu_breakpoint_remove(CPUArchState *env, target_ulong pc, int flags)
+int cpu_breakpoint_remove(CPUState *cpu, vaddr pc, int flags)

 {
 #if defined(TARGET_HAS_ICE)
     CPUBreakpoint *bp;
 
 {
 #if defined(TARGET_HAS_ICE)
     CPUBreakpoint *bp;
 

-    QTAILQ_FOREACH(bp, &env->breakpoints, entry) {
+    QTAILQ_FOREACH(bp, &cpu->breakpoints, entry) {

         if (bp->pc == pc && bp->flags == flags) {
         if (bp->pc == pc && bp->flags == flags) {

-            cpu_breakpoint_remove_by_ref(env, bp);
+            cpu_breakpoint_remove_by_ref(cpu, bp);

             return 0;
         }
     }
             return 0;
         }
     }


@@ -624,26 +661,27 @@ int cpu_breakpoint_remove(CPUArchState *env, target_ulong pc, int flags)
 }
 
 /* Remove a specific breakpoint by reference.  */
 }
 
 /* Remove a specific breakpoint by reference.  */

-void cpu_breakpoint_remove_by_ref(CPUArchState *env, CPUBreakpoint *breakpoint)
+void cpu_breakpoint_remove_by_ref(CPUState *cpu, CPUBreakpoint *breakpoint)

 {
 #if defined(TARGET_HAS_ICE)
 {
 #if defined(TARGET_HAS_ICE)

-    QTAILQ_REMOVE(&env->breakpoints, breakpoint, entry);
+    QTAILQ_REMOVE(&cpu->breakpoints, breakpoint, entry);

 
 

-    breakpoint_invalidate(ENV_GET_CPU(env), breakpoint->pc);
+    breakpoint_invalidate(cpu, breakpoint->pc);

 
     g_free(breakpoint);
 #endif
 }
 
 /* Remove all matching breakpoints. */
 
     g_free(breakpoint);
 #endif
 }
 
 /* Remove all matching breakpoints. */

-void cpu_breakpoint_remove_all(CPUArchState *env, int mask)
+void cpu_breakpoint_remove_all(CPUState *cpu, int mask)

 {
 #if defined(TARGET_HAS_ICE)
     CPUBreakpoint *bp, *next;
 
 {
 #if defined(TARGET_HAS_ICE)
     CPUBreakpoint *bp, *next;
 

-    QTAILQ_FOREACH_SAFE(bp, &env->breakpoints, entry, next) {
-        if (bp->flags & mask)
-            cpu_breakpoint_remove_by_ref(env, bp);
+    QTAILQ_FOREACH_SAFE(bp, &cpu->breakpoints, entry, next) {
+        if (bp->flags & mask) {
+            cpu_breakpoint_remove_by_ref(cpu, bp);
+        }

     }
 #endif
 }
     }
 #endif
 }


@@ -667,9 +705,8 @@ void cpu_single_step(CPUState *cpu, int enabled)
 #endif
 }
 
 #endif
 }
 

-void cpu_abort(CPUArchState *env, const char *fmt, ...)
+void cpu_abort(CPUState *cpu, const char *fmt, ...)

 {
 {

-    CPUState *cpu = ENV_GET_CPU(env);

     va_list ap;
     va_list ap2;
 
     va_list ap;
     va_list ap2;
 


@@ -724,11 +761,14 @@ found:
     return block;
 }
 
     return block;
 }
 

-static void tlb_reset_dirty_range_all(ram_addr_t start, ram_addr_t end,
-                                      uintptr_t length)
+static void tlb_reset_dirty_range_all(ram_addr_t start, ram_addr_t length)

 {
 {

-    RAMBlock *block;

     ram_addr_t start1;
     ram_addr_t start1;

+    RAMBlock *block;
+    ram_addr_t end;
+
+    end = TARGET_PAGE_ALIGN(start + length);
+    start &= TARGET_PAGE_MASK;

 
     block = qemu_get_ram_block(start);
     assert(block == qemu_get_ram_block(end - 1));
 
     block = qemu_get_ram_block(start);
     assert(block == qemu_get_ram_block(end - 1));


@@ -737,32 +777,24 @@ static void tlb_reset_dirty_range_all(ram_addr_t start, ram_addr_t end,
 }
 
 /* Note: start and end must be within the same ram block.  */
 }
 
 /* Note: start and end must be within the same ram block.  */

-void cpu_physical_memory_reset_dirty(ram_addr_t start, ram_addr_t end,
-                                     int dirty_flags)
+void cpu_physical_memory_reset_dirty(ram_addr_t start, ram_addr_t length,
+                                     unsigned client)

 {
 {

-    uintptr_t length;
-
-    start &= TARGET_PAGE_MASK;
-    end = TARGET_PAGE_ALIGN(end);
-
-    length = end - start;

     if (length == 0)
         return;
     if (length == 0)
         return;

-    cpu_physical_memory_mask_dirty_range(start, length, dirty_flags);
+    cpu_physical_memory_clear_dirty_range(start, length, client);

 
     if (tcg_enabled()) {
 
     if (tcg_enabled()) {

-        tlb_reset_dirty_range_all(start, end, length);
+        tlb_reset_dirty_range_all(start, length);

     }
 }
 
     }
 }
 

-static int cpu_physical_memory_set_dirty_tracking(int enable)
+static void cpu_physical_memory_set_dirty_tracking(bool enable)

 {
 {

-    int ret = 0;

     in_migration = enable;
     in_migration = enable;

-    return ret;

 }
 
 }
 

-hwaddr memory_region_section_get_iotlb(CPUArchState *env,
+hwaddr memory_region_section_get_iotlb(CPUState *cpu,

                                        MemoryRegionSection *section,
                                        target_ulong vaddr,
                                        hwaddr paddr, hwaddr xlat,
                                        MemoryRegionSection *section,
                                        target_ulong vaddr,
                                        hwaddr paddr, hwaddr xlat,


@@ -782,13 +814,13 @@ hwaddr memory_region_section_get_iotlb(CPUArchState *env,
             iotlb |= PHYS_SECTION_ROM;
         }
     } else {
             iotlb |= PHYS_SECTION_ROM;
         }
     } else {

-        iotlb = section - address_space_memory.dispatch->map.sections;
+        iotlb = section - section->address_space->dispatch->map.sections;

         iotlb += xlat;
     }
 
     /* Make accesses to pages with watchpoints go via the
        watchpoint trap routines.  */
         iotlb += xlat;
     }
 
     /* Make accesses to pages with watchpoints go via the
        watchpoint trap routines.  */

-    QTAILQ_FOREACH(wp, &env->watchpoints, entry) {
+    QTAILQ_FOREACH(wp, &cpu->watchpoints, entry) {

         if (vaddr == (wp->vaddr & TARGET_PAGE_MASK)) {
             /* Avoid trapping reads of pages with a write breakpoint. */
             if ((prot & PAGE_WRITE) || (wp->flags & BP_MEM_READ)) {
         if (vaddr == (wp->vaddr & TARGET_PAGE_MASK)) {
             /* Avoid trapping reads of pages with a write breakpoint. */
             if ((prot & PAGE_WRITE) || (wp->flags & BP_MEM_READ)) {


@@ -878,6 +910,7 @@ static void register_subpage(AddressSpaceDispatch *d, MemoryRegionSection *secti
 
     if (!(existing->mr->subpage)) {
         subpage = subpage_init(d->as, base);
 
     if (!(existing->mr->subpage)) {
         subpage = subpage_init(d->as, base);

+        subsection.address_space = d->as;

         subsection.mr = &subpage->iomem;
         phys_page_set(d, base >> TARGET_PAGE_BITS, 1,
                       phys_section_add(&d->map, &subsection));
         subsection.mr = &subpage->iomem;
         phys_page_set(d, base >> TARGET_PAGE_BITS, 1,
                       phys_section_add(&d->map, &subsection));


@@ -998,7 +1031,7 @@ static void *file_ram_alloc(RAMBlock *block,
 
     hpagesize = gethugepagesize(path);
     if (!hpagesize) {
 
     hpagesize = gethugepagesize(path);
     if (!hpagesize) {

-        return NULL;
+        goto error;

     }
 
     if (memory < hpagesize) {
     }
 
     if (memory < hpagesize) {


@@ -1007,7 +1040,7 @@ static void *file_ram_alloc(RAMBlock *block,
 
     if (kvm_enabled() && !kvm_has_sync_mmu()) {
         fprintf(stderr, "host lacks kvm mmu notifiers, -mem-path unsupported\n");
 
     if (kvm_enabled() && !kvm_has_sync_mmu()) {
         fprintf(stderr, "host lacks kvm mmu notifiers, -mem-path unsupported\n");

-        return NULL;
+        goto error;

     }
 
     /* Make name safe to use with mkstemp by replacing '/' with '_'. */
     }
 
     /* Make name safe to use with mkstemp by replacing '/' with '_'. */


@@ -1025,7 +1058,7 @@ static void *file_ram_alloc(RAMBlock *block,
     if (fd < 0) {
         perror("unable to create backing store for hugepages");
         g_free(filename);
     if (fd < 0) {
         perror("unable to create backing store for hugepages");
         g_free(filename);

-        return NULL;
+        goto error;

     }
     unlink(filename);
     g_free(filename);
     }
     unlink(filename);
     g_free(filename);


@@ -1045,7 +1078,7 @@ static void *file_ram_alloc(RAMBlock *block,
     if (area == MAP_FAILED) {
         perror("file_ram_alloc: can't mmap RAM pages");
         close(fd);
     if (area == MAP_FAILED) {
         perror("file_ram_alloc: can't mmap RAM pages");
         close(fd);

-        return (NULL);
+        goto error;

     }
 
     if (mem_prealloc) {
     }
 
     if (mem_prealloc) {


@@ -1074,7 +1107,7 @@ static void *file_ram_alloc(RAMBlock *block,
         }
 
         /* MAP_POPULATE silently ignores failures */
         }
 
         /* MAP_POPULATE silently ignores failures */

-        for (i = 0; i < (memory/hpagesize)-1; i++) {
+        for (i = 0; i < (memory/hpagesize); i++) {

             memset(area + (hpagesize*i), 0, 1);
         }
 
             memset(area + (hpagesize*i), 0, 1);
         }
 


@@ -1089,6 +1122,12 @@ static void *file_ram_alloc(RAMBlock *block,
 
     block->fd = fd;
     return area;
 
     block->fd = fd;
     return area;

+
+error:
+    if (mem_prealloc) {
+        exit(1);
+    }
+    return NULL;

 }
 #else
 static void *file_ram_alloc(RAMBlock *block,
 }
 #else
 static void *file_ram_alloc(RAMBlock *block,


@@ -1211,6 +1250,9 @@ ram_addr_t qemu_ram_alloc_from_ptr(ram_addr_t size, void *host,
                                    MemoryRegion *mr)
 {
     RAMBlock *block, *new_block;
                                    MemoryRegion *mr)
 {
     RAMBlock *block, *new_block;

+    ram_addr_t old_ram_size, new_ram_size;
+
+    old_ram_size = last_ram_offset() >> TARGET_PAGE_BITS;

 
     size = TARGET_PAGE_ALIGN(size);
     new_block = g_malloc0(sizeof(*new_block));
 
     size = TARGET_PAGE_ALIGN(size);
     new_block = g_malloc0(sizeof(*new_block));


@@ -1271,11 +1313,17 @@ ram_addr_t qemu_ram_alloc_from_ptr(ram_addr_t size, void *host,
     ram_list.version++;
     qemu_mutex_unlock_ramlist();
 
     ram_list.version++;
     qemu_mutex_unlock_ramlist();
 

-    ram_list.phys_dirty = g_realloc(ram_list.phys_dirty,
-                                       last_ram_offset() >> TARGET_PAGE_BITS);
-    memset(ram_list.phys_dirty + (new_block->offset >> TARGET_PAGE_BITS),
-           0, size >> TARGET_PAGE_BITS);
-    cpu_physical_memory_set_dirty_range(new_block->offset, size, 0xff);
+    new_ram_size = last_ram_offset() >> TARGET_PAGE_BITS;
+
+    if (new_ram_size > old_ram_size) {
+        int i;
+        for (i = 0; i < DIRTY_MEMORY_NUM; i++) {
+            ram_list.dirty_memory[i] =
+                bitmap_zero_extend(ram_list.dirty_memory[i],
+                                   old_ram_size, new_ram_size);
+       }
+    }
+    cpu_physical_memory_set_dirty_range(new_block->offset, size);

 
     qemu_ram_setup_dump(new_block->host, size);
     qemu_madvise(new_block->host, size, QEMU_MADV_HUGEPAGE);
 
     qemu_ram_setup_dump(new_block->host, size);
     qemu_madvise(new_block->host, size, QEMU_MADV_HUGEPAGE);


@@ -1485,11 +1533,8 @@ found:
 static void notdirty_mem_write(void *opaque, hwaddr ram_addr,
                                uint64_t val, unsigned size)
 {
 static void notdirty_mem_write(void *opaque, hwaddr ram_addr,
                                uint64_t val, unsigned size)
 {

-    int dirty_flags;
-    dirty_flags = cpu_physical_memory_get_dirty_flags(ram_addr);
-    if (!(dirty_flags & CODE_DIRTY_FLAG)) {
+    if (!cpu_physical_memory_get_dirty_flag(ram_addr, DIRTY_MEMORY_CODE)) {

         tb_invalidate_phys_page_fast(ram_addr, size);
         tb_invalidate_phys_page_fast(ram_addr, size);

-        dirty_flags = cpu_physical_memory_get_dirty_flags(ram_addr);

     }
     switch (size) {
     case 1:
     }
     switch (size) {
     case 1:


@@ -1504,13 +1549,13 @@ static void notdirty_mem_write(void *opaque, hwaddr ram_addr,
     default:
         abort();
     }
     default:
         abort();
     }

-    dirty_flags |= (0xff & ~CODE_DIRTY_FLAG);
-    cpu_physical_memory_set_dirty_flags(ram_addr, dirty_flags);
+    cpu_physical_memory_set_dirty_flag(ram_addr, DIRTY_MEMORY_MIGRATION);
+    cpu_physical_memory_set_dirty_flag(ram_addr, DIRTY_MEMORY_VGA);

     /* we remove the notdirty callback only if the code has been
        flushed */
     /* we remove the notdirty callback only if the code has been
        flushed */

-    if (dirty_flags == 0xff) {
+    if (!cpu_physical_memory_is_clean(ram_addr)) {

         CPUArchState *env = current_cpu->env_ptr;
         CPUArchState *env = current_cpu->env_ptr;

-        tlb_set_dirty(env, env->mem_io_vaddr);
+        tlb_set_dirty(env, current_cpu->mem_io_vaddr);

     }
 }
 
     }
 }
 


@@ -1529,34 +1574,35 @@ static const MemoryRegionOps notdirty_mem_ops = {
 /* Generate a debug exception if a watchpoint has been hit.  */
 static void check_watchpoint(int offset, int len_mask, int flags)
 {
 /* Generate a debug exception if a watchpoint has been hit.  */
 static void check_watchpoint(int offset, int len_mask, int flags)
 {

-    CPUArchState *env = current_cpu->env_ptr;
+    CPUState *cpu = current_cpu;
+    CPUArchState *env = cpu->env_ptr;

     target_ulong pc, cs_base;
     target_ulong vaddr;
     CPUWatchpoint *wp;
     int cpu_flags;
 
     target_ulong pc, cs_base;
     target_ulong vaddr;
     CPUWatchpoint *wp;
     int cpu_flags;
 

-    if (env->watchpoint_hit) {
+    if (cpu->watchpoint_hit) {

         /* We re-entered the check after replacing the TB. Now raise
          * the debug interrupt so that is will trigger after the
          * current instruction. */
         /* We re-entered the check after replacing the TB. Now raise
          * the debug interrupt so that is will trigger after the
          * current instruction. */

-        cpu_interrupt(ENV_GET_CPU(env), CPU_INTERRUPT_DEBUG);
+        cpu_interrupt(cpu, CPU_INTERRUPT_DEBUG);

         return;
     }
         return;
     }

-    vaddr = (env->mem_io_vaddr & TARGET_PAGE_MASK) + offset;
-    QTAILQ_FOREACH(wp, &env->watchpoints, entry) {
+    vaddr = (cpu->mem_io_vaddr & TARGET_PAGE_MASK) + offset;
+    QTAILQ_FOREACH(wp, &cpu->watchpoints, entry) {

         if ((vaddr == (wp->vaddr & len_mask) ||
              (vaddr & wp->len_mask) == wp->vaddr) && (wp->flags & flags)) {
             wp->flags |= BP_WATCHPOINT_HIT;
         if ((vaddr == (wp->vaddr & len_mask) ||
              (vaddr & wp->len_mask) == wp->vaddr) && (wp->flags & flags)) {
             wp->flags |= BP_WATCHPOINT_HIT;

-            if (!env->watchpoint_hit) {
-                env->watchpoint_hit = wp;
-                tb_check_watchpoint(env);
+            if (!cpu->watchpoint_hit) {
+                cpu->watchpoint_hit = wp;
+                tb_check_watchpoint(cpu);

                 if (wp->flags & BP_STOP_BEFORE_ACCESS) {
                 if (wp->flags & BP_STOP_BEFORE_ACCESS) {

-                    env->exception_index = EXCP_DEBUG;
-                    cpu_loop_exit(env);
+                    cpu->exception_index = EXCP_DEBUG;
+                    cpu_loop_exit(cpu);

                 } else {
                     cpu_get_tb_cpu_state(env, &pc, &cs_base, &cpu_flags);
                 } else {
                     cpu_get_tb_cpu_state(env, &pc, &cs_base, &cpu_flags);

-                    tb_gen_code(env, pc, cs_base, cpu_flags, 1);
-                    cpu_resume_from_signal(env, NULL);
+                    tb_gen_code(cpu, pc, cs_base, cpu_flags, 1);
+                    cpu_resume_from_signal(cpu, NULL);

                 }
             }
         } else {
                 }
             }
         } else {


@@ -1573,9 +1619,9 @@ static uint64_t watch_mem_read(void *opaque, hwaddr addr,
 {
     check_watchpoint(addr & ~TARGET_PAGE_MASK, ~(size - 1), BP_MEM_READ);
     switch (size) {
 {
     check_watchpoint(addr & ~TARGET_PAGE_MASK, ~(size - 1), BP_MEM_READ);
     switch (size) {

-    case 1: return ldub_phys(addr);
-    case 2: return lduw_phys(addr);
-    case 4: return ldl_phys(addr);
+    case 1: return ldub_phys(&address_space_memory, addr);
+    case 2: return lduw_phys(&address_space_memory, addr);
+    case 4: return ldl_phys(&address_space_memory, addr);

     default: abort();
     }
 }
     default: abort();
     }
 }


@@ -1586,13 +1632,13 @@ static void watch_mem_write(void *opaque, hwaddr addr,
     check_watchpoint(addr & ~TARGET_PAGE_MASK, ~(size - 1), BP_MEM_WRITE);
     switch (size) {
     case 1:
     check_watchpoint(addr & ~TARGET_PAGE_MASK, ~(size - 1), BP_MEM_WRITE);
     switch (size) {
     case 1:

-        stb_phys(addr, val);
+        stb_phys(&address_space_memory, addr, val);

         break;
     case 2:
         break;
     case 2:

-        stw_phys(addr, val);
+        stw_phys(&address_space_memory, addr, val);

         break;
     case 4:
         break;
     case 4:

-        stl_phys(addr, val);
+        stl_phys(&address_space_memory, addr, val);

         break;
     default: abort();
     }
         break;
     default: abort();
     }


@@ -1717,6 +1763,7 @@ static subpage_t *subpage_init(AddressSpace *as, hwaddr base)
 static uint16_t dummy_section(PhysPageMap *map, MemoryRegion *mr)
 {
     MemoryRegionSection section = {
 static uint16_t dummy_section(PhysPageMap *map, MemoryRegion *mr)
 {
     MemoryRegionSection section = {

+        .address_space = &address_space_memory,

         .mr = mr,
         .offset_within_address_space = 0,
         .offset_within_region = 0,
         .mr = mr,
         .offset_within_address_space = 0,
         .offset_within_region = 0,


@@ -1726,10 +1773,9 @@ static uint16_t dummy_section(PhysPageMap *map, MemoryRegion *mr)
     return phys_section_add(map, &section);
 }
 
     return phys_section_add(map, &section);
 }
 

-MemoryRegion *iotlb_to_region(hwaddr index)
+MemoryRegion *iotlb_to_region(AddressSpace *as, hwaddr index)

 {
 {

-    return address_space_memory.dispatch->map.sections[
-           index & ~TARGET_PAGE_MASK].mr;
+    return as->dispatch->map.sections[index & ~TARGET_PAGE_MASK].mr;

 }
 
 static void io_mem_init(void)
 }
 
 static void io_mem_init(void)


@@ -1787,20 +1833,23 @@ static void tcg_commit(MemoryListener *listener)
        reset the modified entries */
     /* XXX: slow ! */
     CPU_FOREACH(cpu) {
        reset the modified entries */
     /* XXX: slow ! */
     CPU_FOREACH(cpu) {

-        CPUArchState *env = cpu->env_ptr;
-
-        tlb_flush(env, 1);
+        /* FIXME: Disentangle the cpu.h circular files deps so we can
+           directly get the right CPU from listener.  */
+        if (cpu->tcg_as_listener != listener) {
+            continue;
+        }
+        tlb_flush(cpu, 1);

     }
 }
 
 static void core_log_global_start(MemoryListener *listener)
 {
     }
 }
 
 static void core_log_global_start(MemoryListener *listener)
 {

-    cpu_physical_memory_set_dirty_tracking(1);
+    cpu_physical_memory_set_dirty_tracking(true);

 }
 
 static void core_log_global_stop(MemoryListener *listener)
 {
 }
 
 static void core_log_global_stop(MemoryListener *listener)
 {

-    cpu_physical_memory_set_dirty_tracking(0);
+    cpu_physical_memory_set_dirty_tracking(false);

 }
 
 static MemoryListener core_memory_listener = {
 }
 
 static MemoryListener core_memory_listener = {


@@ -1809,10 +1858,6 @@ static MemoryListener core_memory_listener = {
     .priority = 1,
 };
 
     .priority = 1,
 };
 

-static MemoryListener tcg_memory_listener = {
-    .commit = tcg_commit,
-};
-

 void address_space_init_dispatch(AddressSpace *as)
 {
     as->dispatch = NULL;
 void address_space_init_dispatch(AddressSpace *as)
 {
     as->dispatch = NULL;


@@ -1848,9 +1893,6 @@ static void memory_map_init(void)
     address_space_init(&address_space_io, system_io, "I/O");
 
     memory_listener_register(&core_memory_listener, &address_space_memory);
     address_space_init(&address_space_io, system_io, "I/O");
 
     memory_listener_register(&core_memory_listener, &address_space_memory);

-    if (tcg_enabled()) {
-        memory_listener_register(&tcg_memory_listener, &address_space_memory);
-    }

 }
 
 MemoryRegion *get_system_memory(void)
 }
 
 MemoryRegion *get_system_memory(void)


@@ -1911,27 +1953,16 @@ int cpu_memory_rw_debug(CPUState *cpu, target_ulong addr,
 static void invalidate_and_set_dirty(hwaddr addr,
                                      hwaddr length)
 {
 static void invalidate_and_set_dirty(hwaddr addr,
                                      hwaddr length)
 {

-    if (!cpu_physical_memory_is_dirty(addr)) {
+    if (cpu_physical_memory_is_clean(addr)) {

         /* invalidate code */
         tb_invalidate_phys_page_range(addr, addr + length, 0);
         /* set dirty bit */
         /* invalidate code */
         tb_invalidate_phys_page_range(addr, addr + length, 0);
         /* set dirty bit */

-        cpu_physical_memory_set_dirty_flags(addr, (0xff & ~CODE_DIRTY_FLAG));
+        cpu_physical_memory_set_dirty_flag(addr, DIRTY_MEMORY_VGA);
+        cpu_physical_memory_set_dirty_flag(addr, DIRTY_MEMORY_MIGRATION);

     }
     xen_modified_memory(addr, length);
 }
 
     }
     xen_modified_memory(addr, length);
 }
 

-static inline bool memory_access_is_direct(MemoryRegion *mr, bool is_write)
-{
-    if (memory_region_is_ram(mr)) {
-        return !(is_write && mr->readonly);
-    }
-    if (memory_region_is_romd(mr)) {
-        return !is_write;
-    }
-
-    return false;
-}
-

 static int memory_access_size(MemoryRegion *mr, unsigned l, hwaddr addr)
 {
     unsigned access_size_max = mr->ops->valid.max_access_size;
 static int memory_access_size(MemoryRegion *mr, unsigned l, hwaddr addr)
 {
     unsigned access_size_max = mr->ops->valid.max_access_size;


@@ -2076,7 +2107,7 @@ enum write_rom_type {
     FLUSH_CACHE,
 };
 
     FLUSH_CACHE,
 };
 

-static inline void cpu_physical_memory_write_rom_internal(
+static inline void cpu_physical_memory_write_rom_internal(AddressSpace *as,

     hwaddr addr, const uint8_t *buf, int len, enum write_rom_type type)
 {
     hwaddr l;
     hwaddr addr, const uint8_t *buf, int len, enum write_rom_type type)
 {
     hwaddr l;


@@ -2086,8 +2117,7 @@ static inline void cpu_physical_memory_write_rom_internal(
 
     while (len > 0) {
         l = len;
 
     while (len > 0) {
         l = len;

-        mr = address_space_translate(&address_space_memory,
-                                     addr, &addr1, &l, true);
+        mr = address_space_translate(as, addr, &addr1, &l, true);

 
         if (!(memory_region_is_ram(mr) ||
               memory_region_is_romd(mr))) {
 
         if (!(memory_region_is_ram(mr) ||
               memory_region_is_romd(mr))) {


@@ -2113,10 +2143,10 @@ static inline void cpu_physical_memory_write_rom_internal(
 }
 
 /* used for ROM loading : can write in RAM and ROM */
 }
 
 /* used for ROM loading : can write in RAM and ROM */

-void cpu_physical_memory_write_rom(hwaddr addr,
+void cpu_physical_memory_write_rom(AddressSpace *as, hwaddr addr,

                                    const uint8_t *buf, int len)
 {
                                    const uint8_t *buf, int len)
 {

-    cpu_physical_memory_write_rom_internal(addr, buf, len, WRITE_DATA);
+    cpu_physical_memory_write_rom_internal(as, addr, buf, len, WRITE_DATA);

 }
 
 void cpu_flush_icache_range(hwaddr start, int len)
 }
 
 void cpu_flush_icache_range(hwaddr start, int len)


@@ -2131,7 +2161,8 @@ void cpu_flush_icache_range(hwaddr start, int len)
         return;
     }
 
         return;
     }
 

-    cpu_physical_memory_write_rom_internal(start, NULL, len, FLUSH_CACHE);
+    cpu_physical_memory_write_rom_internal(&address_space_memory,
+                                           start, NULL, len, FLUSH_CACHE);

 }
 
 typedef struct {
 }
 
 typedef struct {


@@ -2322,7 +2353,7 @@ void cpu_physical_memory_unmap(void *buffer, hwaddr len,
 }
 
 /* warning: addr must be aligned */
 }
 
 /* warning: addr must be aligned */

-static inline uint32_t ldl_phys_internal(hwaddr addr,
+static inline uint32_t ldl_phys_internal(AddressSpace *as, hwaddr addr,

                                          enum device_endian endian)
 {
     uint8_t *ptr;
                                          enum device_endian endian)
 {
     uint8_t *ptr;


@@ -2331,8 +2362,7 @@ static inline uint32_t ldl_phys_internal(hwaddr addr,
     hwaddr l = 4;
     hwaddr addr1;
 
     hwaddr l = 4;
     hwaddr addr1;
 

-    mr = address_space_translate(&address_space_memory, addr, &addr1, &l,
-                                 false);
+    mr = address_space_translate(as, addr, &addr1, &l, false);

     if (l < 4 || !memory_access_is_direct(mr, false)) {
         /* I/O case */
         io_mem_read(mr, addr1, &val, 4);
     if (l < 4 || !memory_access_is_direct(mr, false)) {
         /* I/O case */
         io_mem_read(mr, addr1, &val, 4);


@@ -2365,23 +2395,23 @@ static inline uint32_t ldl_phys_internal(hwaddr addr,
     return val;
 }
 
     return val;
 }
 

-uint32_t ldl_phys(hwaddr addr)
+uint32_t ldl_phys(AddressSpace *as, hwaddr addr)

 {
 {

-    return ldl_phys_internal(addr, DEVICE_NATIVE_ENDIAN);
+    return ldl_phys_internal(as, addr, DEVICE_NATIVE_ENDIAN);

 }
 
 }
 

-uint32_t ldl_le_phys(hwaddr addr)
+uint32_t ldl_le_phys(AddressSpace *as, hwaddr addr)

 {
 {

-    return ldl_phys_internal(addr, DEVICE_LITTLE_ENDIAN);
+    return ldl_phys_internal(as, addr, DEVICE_LITTLE_ENDIAN);

 }
 
 }
 

-uint32_t ldl_be_phys(hwaddr addr)
+uint32_t ldl_be_phys(AddressSpace *as, hwaddr addr)

 {
 {

-    return ldl_phys_internal(addr, DEVICE_BIG_ENDIAN);
+    return ldl_phys_internal(as, addr, DEVICE_BIG_ENDIAN);

 }
 
 /* warning: addr must be aligned */
 }
 
 /* warning: addr must be aligned */

-static inline uint64_t ldq_phys_internal(hwaddr addr,
+static inline uint64_t ldq_phys_internal(AddressSpace *as, hwaddr addr,

                                          enum device_endian endian)
 {
     uint8_t *ptr;
                                          enum device_endian endian)
 {
     uint8_t *ptr;


@@ -2390,7 +2420,7 @@ static inline uint64_t ldq_phys_internal(hwaddr addr,
     hwaddr l = 8;
     hwaddr addr1;
 
     hwaddr l = 8;
     hwaddr addr1;
 

-    mr = address_space_translate(&address_space_memory, addr, &addr1, &l,
+    mr = address_space_translate(as, addr, &addr1, &l,

                                  false);
     if (l < 8 || !memory_access_is_direct(mr, false)) {
         /* I/O case */
                                  false);
     if (l < 8 || !memory_access_is_direct(mr, false)) {
         /* I/O case */


@@ -2424,31 +2454,31 @@ static inline uint64_t ldq_phys_internal(hwaddr addr,
     return val;
 }
 
     return val;
 }
 

-uint64_t ldq_phys(hwaddr addr)
+uint64_t ldq_phys(AddressSpace *as, hwaddr addr)

 {
 {

-    return ldq_phys_internal(addr, DEVICE_NATIVE_ENDIAN);
+    return ldq_phys_internal(as, addr, DEVICE_NATIVE_ENDIAN);

 }
 
 }
 

-uint64_t ldq_le_phys(hwaddr addr)
+uint64_t ldq_le_phys(AddressSpace *as, hwaddr addr)

 {
 {

-    return ldq_phys_internal(addr, DEVICE_LITTLE_ENDIAN);
+    return ldq_phys_internal(as, addr, DEVICE_LITTLE_ENDIAN);

 }
 
 }
 

-uint64_t ldq_be_phys(hwaddr addr)
+uint64_t ldq_be_phys(AddressSpace *as, hwaddr addr)

 {
 {

-    return ldq_phys_internal(addr, DEVICE_BIG_ENDIAN);
+    return ldq_phys_internal(as, addr, DEVICE_BIG_ENDIAN);

 }
 
 /* XXX: optimize */
 }
 
 /* XXX: optimize */

-uint32_t ldub_phys(hwaddr addr)
+uint32_t ldub_phys(AddressSpace *as, hwaddr addr)

 {
     uint8_t val;
 {
     uint8_t val;

-    cpu_physical_memory_read(addr, &val, 1);
+    address_space_rw(as, addr, &val, 1, 0);

     return val;
 }
 
 /* warning: addr must be aligned */
     return val;
 }
 
 /* warning: addr must be aligned */

-static inline uint32_t lduw_phys_internal(hwaddr addr,
+static inline uint32_t lduw_phys_internal(AddressSpace *as, hwaddr addr,

                                           enum device_endian endian)
 {
     uint8_t *ptr;
                                           enum device_endian endian)
 {
     uint8_t *ptr;


@@ -2457,7 +2487,7 @@ static inline uint32_t lduw_phys_internal(hwaddr addr,
     hwaddr l = 2;
     hwaddr addr1;
 
     hwaddr l = 2;
     hwaddr addr1;
 

-    mr = address_space_translate(&address_space_memory, addr, &addr1, &l,
+    mr = address_space_translate(as, addr, &addr1, &l,

                                  false);
     if (l < 2 || !memory_access_is_direct(mr, false)) {
         /* I/O case */
                                  false);
     if (l < 2 || !memory_access_is_direct(mr, false)) {
         /* I/O case */


@@ -2491,32 +2521,32 @@ static inline uint32_t lduw_phys_internal(hwaddr addr,
     return val;
 }
 
     return val;
 }
 

-uint32_t lduw_phys(hwaddr addr)
+uint32_t lduw_phys(AddressSpace *as, hwaddr addr)

 {
 {

-    return lduw_phys_internal(addr, DEVICE_NATIVE_ENDIAN);
+    return lduw_phys_internal(as, addr, DEVICE_NATIVE_ENDIAN);

 }
 
 }
 

-uint32_t lduw_le_phys(hwaddr addr)
+uint32_t lduw_le_phys(AddressSpace *as, hwaddr addr)

 {
 {

-    return lduw_phys_internal(addr, DEVICE_LITTLE_ENDIAN);
+    return lduw_phys_internal(as, addr, DEVICE_LITTLE_ENDIAN);

 }
 
 }
 

-uint32_t lduw_be_phys(hwaddr addr)
+uint32_t lduw_be_phys(AddressSpace *as, hwaddr addr)

 {
 {

-    return lduw_phys_internal(addr, DEVICE_BIG_ENDIAN);
+    return lduw_phys_internal(as, addr, DEVICE_BIG_ENDIAN);

 }
 
 /* warning: addr must be aligned. The ram page is not masked as dirty
    and the code inside is not invalidated. It is useful if the dirty
    bits are used to track modified PTEs */
 }
 
 /* warning: addr must be aligned. The ram page is not masked as dirty
    and the code inside is not invalidated. It is useful if the dirty
    bits are used to track modified PTEs */

-void stl_phys_notdirty(hwaddr addr, uint32_t val)
+void stl_phys_notdirty(AddressSpace *as, hwaddr addr, uint32_t val)

 {
     uint8_t *ptr;
     MemoryRegion *mr;
     hwaddr l = 4;
     hwaddr addr1;
 
 {
     uint8_t *ptr;
     MemoryRegion *mr;
     hwaddr l = 4;
     hwaddr addr1;
 

-    mr = address_space_translate(&address_space_memory, addr, &addr1, &l,
+    mr = address_space_translate(as, addr, &addr1, &l,

                                  true);
     if (l < 4 || !memory_access_is_direct(mr, true)) {
         io_mem_write(mr, addr1, val, 4);
                                  true);
     if (l < 4 || !memory_access_is_direct(mr, true)) {
         io_mem_write(mr, addr1, val, 4);


@@ -2526,19 +2556,21 @@ void stl_phys_notdirty(hwaddr addr, uint32_t val)
         stl_p(ptr, val);
 
         if (unlikely(in_migration)) {
         stl_p(ptr, val);
 
         if (unlikely(in_migration)) {

-            if (!cpu_physical_memory_is_dirty(addr1)) {
+            if (cpu_physical_memory_is_clean(addr1)) {

                 /* invalidate code */
                 tb_invalidate_phys_page_range(addr1, addr1 + 4, 0);
                 /* set dirty bit */
                 /* invalidate code */
                 tb_invalidate_phys_page_range(addr1, addr1 + 4, 0);
                 /* set dirty bit */

-                cpu_physical_memory_set_dirty_flags(
-                    addr1, (0xff & ~CODE_DIRTY_FLAG));
+                cpu_physical_memory_set_dirty_flag(addr1,
+                                                   DIRTY_MEMORY_MIGRATION);
+                cpu_physical_memory_set_dirty_flag(addr1, DIRTY_MEMORY_VGA);

             }
         }
     }
 }
 
 /* warning: addr must be aligned */
             }
         }
     }
 }
 
 /* warning: addr must be aligned */

-static inline void stl_phys_internal(hwaddr addr, uint32_t val,
+static inline void stl_phys_internal(AddressSpace *as,
+                                     hwaddr addr, uint32_t val,

                                      enum device_endian endian)
 {
     uint8_t *ptr;
                                      enum device_endian endian)
 {
     uint8_t *ptr;


@@ -2546,7 +2578,7 @@ static inline void stl_phys_internal(hwaddr addr, uint32_t val,
     hwaddr l = 4;
     hwaddr addr1;
 
     hwaddr l = 4;
     hwaddr addr1;
 

-    mr = address_space_translate(&address_space_memory, addr, &addr1, &l,
+    mr = address_space_translate(as, addr, &addr1, &l,

                                  true);
     if (l < 4 || !memory_access_is_direct(mr, true)) {
 #if defined(TARGET_WORDS_BIGENDIAN)
                                  true);
     if (l < 4 || !memory_access_is_direct(mr, true)) {
 #if defined(TARGET_WORDS_BIGENDIAN)


@@ -2578,30 +2610,31 @@ static inline void stl_phys_internal(hwaddr addr, uint32_t val,
     }
 }
 
     }
 }
 

-void stl_phys(hwaddr addr, uint32_t val)
+void stl_phys(AddressSpace *as, hwaddr addr, uint32_t val)

 {
 {

-    stl_phys_internal(addr, val, DEVICE_NATIVE_ENDIAN);
+    stl_phys_internal(as, addr, val, DEVICE_NATIVE_ENDIAN);

 }
 
 }
 

-void stl_le_phys(hwaddr addr, uint32_t val)
+void stl_le_phys(AddressSpace *as, hwaddr addr, uint32_t val)

 {
 {

-    stl_phys_internal(addr, val, DEVICE_LITTLE_ENDIAN);
+    stl_phys_internal(as, addr, val, DEVICE_LITTLE_ENDIAN);

 }
 
 }
 

-void stl_be_phys(hwaddr addr, uint32_t val)
+void stl_be_phys(AddressSpace *as, hwaddr addr, uint32_t val)

 {
 {

-    stl_phys_internal(addr, val, DEVICE_BIG_ENDIAN);
+    stl_phys_internal(as, addr, val, DEVICE_BIG_ENDIAN);

 }
 
 /* XXX: optimize */
 }
 
 /* XXX: optimize */

-void stb_phys(hwaddr addr, uint32_t val)
+void stb_phys(AddressSpace *as, hwaddr addr, uint32_t val)

 {
     uint8_t v = val;
 {
     uint8_t v = val;

-    cpu_physical_memory_write(addr, &v, 1);
+    address_space_rw(as, addr, &v, 1, 1);

 }
 
 /* warning: addr must be aligned */
 }
 
 /* warning: addr must be aligned */

-static inline void stw_phys_internal(hwaddr addr, uint32_t val,
+static inline void stw_phys_internal(AddressSpace *as,
+                                     hwaddr addr, uint32_t val,

                                      enum device_endian endian)
 {
     uint8_t *ptr;
                                      enum device_endian endian)
 {
     uint8_t *ptr;


@@ -2609,8 +2642,7 @@ static inline void stw_phys_internal(hwaddr addr, uint32_t val,
     hwaddr l = 2;
     hwaddr addr1;
 
     hwaddr l = 2;
     hwaddr addr1;
 

-    mr = address_space_translate(&address_space_memory, addr, &addr1, &l,
-                                 true);
+    mr = address_space_translate(as, addr, &addr1, &l, true);

     if (l < 2 || !memory_access_is_direct(mr, true)) {
 #if defined(TARGET_WORDS_BIGENDIAN)
         if (endian == DEVICE_LITTLE_ENDIAN) {
     if (l < 2 || !memory_access_is_direct(mr, true)) {
 #if defined(TARGET_WORDS_BIGENDIAN)
         if (endian == DEVICE_LITTLE_ENDIAN) {


@@ -2641,38 +2673,38 @@ static inline void stw_phys_internal(hwaddr addr, uint32_t val,
     }
 }
 
     }
 }
 

-void stw_phys(hwaddr addr, uint32_t val)
+void stw_phys(AddressSpace *as, hwaddr addr, uint32_t val)

 {
 {

-    stw_phys_internal(addr, val, DEVICE_NATIVE_ENDIAN);
+    stw_phys_internal(as, addr, val, DEVICE_NATIVE_ENDIAN);

 }
 
 }
 

-void stw_le_phys(hwaddr addr, uint32_t val)
+void stw_le_phys(AddressSpace *as, hwaddr addr, uint32_t val)

 {
 {

-    stw_phys_internal(addr, val, DEVICE_LITTLE_ENDIAN);
+    stw_phys_internal(as, addr, val, DEVICE_LITTLE_ENDIAN);

 }
 
 }
 

-void stw_be_phys(hwaddr addr, uint32_t val)
+void stw_be_phys(AddressSpace *as, hwaddr addr, uint32_t val)

 {
 {

-    stw_phys_internal(addr, val, DEVICE_BIG_ENDIAN);
+    stw_phys_internal(as, addr, val, DEVICE_BIG_ENDIAN);

 }
 
 /* XXX: optimize */
 }
 
 /* XXX: optimize */

-void stq_phys(hwaddr addr, uint64_t val)
+void stq_phys(AddressSpace *as, hwaddr addr, uint64_t val)

 {
     val = tswap64(val);
 {
     val = tswap64(val);

-    cpu_physical_memory_write(addr, &val, 8);
+    address_space_rw(as, addr, (void *) &val, 8, 1);

 }
 
 }
 

-void stq_le_phys(hwaddr addr, uint64_t val)
+void stq_le_phys(AddressSpace *as, hwaddr addr, uint64_t val)

 {
     val = cpu_to_le64(val);
 {
     val = cpu_to_le64(val);

-    cpu_physical_memory_write(addr, &val, 8);
+    address_space_rw(as, addr, (void *) &val, 8, 1);

 }
 
 }
 

-void stq_be_phys(hwaddr addr, uint64_t val)
+void stq_be_phys(AddressSpace *as, hwaddr addr, uint64_t val)

 {
     val = cpu_to_be64(val);
 {
     val = cpu_to_be64(val);

-    cpu_physical_memory_write(addr, &val, 8);
+    address_space_rw(as, addr, (void *) &val, 8, 1);

 }
 
 /* virtual memory access for debug (includes writing to ROM) */
 }
 
 /* virtual memory access for debug (includes writing to ROM) */


@@ -2693,10 +2725,11 @@ int cpu_memory_rw_debug(CPUState *cpu, target_ulong addr,
         if (l > len)
             l = len;
         phys_addr += (addr & ~TARGET_PAGE_MASK);
         if (l > len)
             l = len;
         phys_addr += (addr & ~TARGET_PAGE_MASK);

-        if (is_write)
-            cpu_physical_memory_write_rom(phys_addr, buf, l);
-        else
-            cpu_physical_memory_rw(phys_addr, buf, l, is_write);
+        if (is_write) {
+            cpu_physical_memory_write_rom(cpu->as, phys_addr, buf, l);
+        } else {
+            address_space_rw(cpu->as, phys_addr, buf, l, 0);
+        }

         len -= l;
         buf += l;
         addr += l;
         len -= l;
         buf += l;
         addr += l;