unify len and addr type for memory/address APIs

[qemu.git] / exec.c

diff --git a/exec.c b/exec.c
index ebadc0e302ad8da3235d4371577f80b6f01ba8ed..518064530bd924b2e4b7bc34de5466707af9a23d 100644 (file)
--- a/exec.c
+++ b/exec.c
@@ -87,26 +87,6 @@ AddressSpace address_space_memory;
 
 MemoryRegion io_mem_rom, io_mem_notdirty;
 static MemoryRegion io_mem_unassigned;
 
 MemoryRegion io_mem_rom, io_mem_notdirty;
 static MemoryRegion io_mem_unassigned;

-
-/* RAM is pre-allocated and passed into qemu_ram_alloc_from_ptr */
-#define RAM_PREALLOC   (1 << 0)
-
-/* RAM is mmap-ed with MAP_SHARED */
-#define RAM_SHARED     (1 << 1)
-
-/* Only a portion of RAM (used_length) is actually used, and migrated.
- * This used_length size can change across reboots.
- */
-#define RAM_RESIZEABLE (1 << 2)
-
-/* UFFDIO_ZEROPAGE is available on this RAMBlock to atomically
- * zero the page and wake waiting processes.
- * (Set during postcopy)
- */
-#define RAM_UF_ZEROPAGE (1 << 3)
-
-/* RAM can be migrated */
-#define RAM_MIGRATABLE (1 << 4)

 #endif
 
 #ifdef TARGET_PAGE_BITS_VARY
 #endif
 
 #ifdef TARGET_PAGE_BITS_VARY


@@ -114,7 +94,8 @@ int target_page_bits;
 bool target_page_bits_decided;
 #endif
 
 bool target_page_bits_decided;
 #endif
 

-struct CPUTailQ cpus = QTAILQ_HEAD_INITIALIZER(cpus);
+CPUTailQ cpus = QTAILQ_HEAD_INITIALIZER(cpus);
+

 /* current CPU in the current thread. It is only valid inside
    cpu_exec() */
 __thread CPUState *current_cpu;
 /* current CPU in the current thread. It is only valid inside
    cpu_exec() */
 __thread CPUState *current_cpu;


@@ -402,12 +383,6 @@ static MemoryRegionSection *phys_page_find(AddressSpaceDispatch *d, hwaddr addr)
     }
 }
 
     }
 }
 

-bool memory_region_is_unassigned(MemoryRegion *mr)
-{
-    return mr != &io_mem_rom && mr != &io_mem_notdirty && !mr->rom_device
-        && mr != &io_mem_watch;
-}
-

 /* Called from RCU critical section */
 static MemoryRegionSection *address_space_lookup_region(AddressSpaceDispatch *d,
                                                         hwaddr addr,
 /* Called from RCU critical section */
 static MemoryRegionSection *address_space_lookup_region(AddressSpaceDispatch *d,
                                                         hwaddr addr,


@@ -690,7 +665,7 @@ static void tcg_register_iommu_notifier(CPUState *cpu,
     int i;
 
     for (i = 0; i < cpu->iommu_notifiers->len; i++) {
     int i;
 
     for (i = 0; i < cpu->iommu_notifiers->len; i++) {

-        notifier = &g_array_index(cpu->iommu_notifiers, TCGIOMMUNotifier, i);
+        notifier = g_array_index(cpu->iommu_notifiers, TCGIOMMUNotifier *, i);

         if (notifier->mr == mr && notifier->iommu_idx == iommu_idx) {
             break;
         }
         if (notifier->mr == mr && notifier->iommu_idx == iommu_idx) {
             break;
         }


@@ -698,7 +673,8 @@ static void tcg_register_iommu_notifier(CPUState *cpu,
     if (i == cpu->iommu_notifiers->len) {
         /* Not found, add a new entry at the end of the array */
         cpu->iommu_notifiers = g_array_set_size(cpu->iommu_notifiers, i + 1);
     if (i == cpu->iommu_notifiers->len) {
         /* Not found, add a new entry at the end of the array */
         cpu->iommu_notifiers = g_array_set_size(cpu->iommu_notifiers, i + 1);

-        notifier = &g_array_index(cpu->iommu_notifiers, TCGIOMMUNotifier, i);
+        notifier = g_new0(TCGIOMMUNotifier, 1);
+        g_array_index(cpu->iommu_notifiers, TCGIOMMUNotifier *, i) = notifier;

 
         notifier->mr = mr;
         notifier->iommu_idx = iommu_idx;
 
         notifier->mr = mr;
         notifier->iommu_idx = iommu_idx;


@@ -730,8 +706,9 @@ static void tcg_iommu_free_notifier_list(CPUState *cpu)
     TCGIOMMUNotifier *notifier;
 
     for (i = 0; i < cpu->iommu_notifiers->len; i++) {
     TCGIOMMUNotifier *notifier;
 
     for (i = 0; i < cpu->iommu_notifiers->len; i++) {

-        notifier = &g_array_index(cpu->iommu_notifiers, TCGIOMMUNotifier, i);
+        notifier = g_array_index(cpu->iommu_notifiers, TCGIOMMUNotifier *, i);

         memory_region_unregister_iommu_notifier(notifier->mr, &notifier->n);
         memory_region_unregister_iommu_notifier(notifier->mr, &notifier->n);

+        g_free(notifier);

     }
     g_array_free(cpu->iommu_notifiers, true);
 }
     }
     g_array_free(cpu->iommu_notifiers, true);
 }


@@ -991,6 +968,7 @@ void cpu_exec_realizefn(CPUState *cpu, Error **errp)
         tcg_target_initialized = true;
         cc->tcg_initialize();
     }
         tcg_target_initialized = true;
         cc->tcg_initialize();
     }

+    tlb_init(cpu);

 
 #ifndef CONFIG_USER_ONLY
     if (qdev_get_vmsd(DEVICE(cpu)) == NULL) {
 
 #ifndef CONFIG_USER_ONLY
     if (qdev_get_vmsd(DEVICE(cpu)) == NULL) {


@@ -1000,7 +978,7 @@ void cpu_exec_realizefn(CPUState *cpu, Error **errp)
         vmstate_register(NULL, cpu->cpu_index, cc->vmsd, cpu);
     }
 
         vmstate_register(NULL, cpu->cpu_index, cc->vmsd, cpu);
     }
 

-    cpu->iommu_notifiers = g_array_new(false, true, sizeof(TCGIOMMUNotifier));
+    cpu->iommu_notifiers = g_array_new(false, true, sizeof(TCGIOMMUNotifier *));

 #endif
 }
 
 #endif
 }
 


@@ -1028,15 +1006,40 @@ const char *parse_cpu_model(const char *cpu_model)
 }
 
 #if defined(CONFIG_USER_ONLY)
 }
 
 #if defined(CONFIG_USER_ONLY)

-static void breakpoint_invalidate(CPUState *cpu, target_ulong pc)
+void tb_invalidate_phys_addr(target_ulong addr)

 {
     mmap_lock();
 {
     mmap_lock();

-    tb_lock();
-    tb_invalidate_phys_page_range(pc, pc + 1, 0);
-    tb_unlock();
+    tb_invalidate_phys_page_range(addr, addr + 1, 0);

     mmap_unlock();
 }
     mmap_unlock();
 }

+
+static void breakpoint_invalidate(CPUState *cpu, target_ulong pc)
+{
+    tb_invalidate_phys_addr(pc);
+}

 #else
 #else

+void tb_invalidate_phys_addr(AddressSpace *as, hwaddr addr, MemTxAttrs attrs)
+{
+    ram_addr_t ram_addr;
+    MemoryRegion *mr;
+    hwaddr l = 1;
+
+    if (!tcg_enabled()) {
+        return;
+    }
+
+    rcu_read_lock();
+    mr = address_space_translate(as, addr, &addr, &l, false, attrs);
+    if (!(memory_region_is_ram(mr)
+          || memory_region_is_romd(mr))) {
+        rcu_read_unlock();
+        return;
+    }
+    ram_addr = memory_region_get_ram_addr(mr) + addr;
+    tb_invalidate_phys_page_range(ram_addr, ram_addr + 1, 0);
+    rcu_read_unlock();
+}
+

 static void breakpoint_invalidate(CPUState *cpu, target_ulong pc)
 {
     MemTxAttrs attrs;
 static void breakpoint_invalidate(CPUState *cpu, target_ulong pc)
 {
     MemTxAttrs attrs;


@@ -1325,6 +1328,7 @@ static void tlb_reset_dirty_range_all(ram_addr_t start, ram_addr_t length)
     RAMBlock *block;
     ram_addr_t end;
 
     RAMBlock *block;
     ram_addr_t end;
 

+    assert(tcg_enabled());

     end = TARGET_PAGE_ALIGN(start + length);
     start &= TARGET_PAGE_MASK;
 
     end = TARGET_PAGE_ALIGN(start + length);
     start &= TARGET_PAGE_MASK;
 


@@ -1734,7 +1738,7 @@ long qemu_getrampagesize(void)
 }
 #endif
 
 }
 #endif
 

-#ifdef __linux__
+#ifdef CONFIG_POSIX

 static int64_t get_file_size(int fd)
 {
     int64_t size = lseek(fd, 0, SEEK_END);
 static int64_t get_file_size(int fd)
 {
     int64_t size = lseek(fd, 0, SEEK_END);


@@ -1819,6 +1823,10 @@ static void *file_ram_alloc(RAMBlock *block,
                    " must be multiples of page size 0x%zx",
                    block->mr->align, block->page_size);
         return NULL;
                    " must be multiples of page size 0x%zx",
                    block->mr->align, block->page_size);
         return NULL;

+    } else if (block->mr->align && !is_power_of_2(block->mr->align)) {
+        error_setg(errp, "alignment 0x%" PRIx64
+                   " must be a power of two", block->mr->align);
+        return NULL;

     }
     block->mr->align = MAX(block->page_size, block->mr->align);
 #if defined(__s390x__)
     }
     block->mr->align = MAX(block->page_size, block->mr->align);
 #if defined(__s390x__)


@@ -1865,7 +1873,7 @@ static void *file_ram_alloc(RAMBlock *block,
     if (mem_prealloc) {
         os_mem_prealloc(fd, area, memory, smp_cpus, errp);
         if (errp && *errp) {
     if (mem_prealloc) {
         os_mem_prealloc(fd, area, memory, smp_cpus, errp);
         if (errp && *errp) {

-            qemu_ram_munmap(area, memory);
+            qemu_ram_munmap(fd, area, memory);

             return NULL;
         }
     }
             return NULL;
         }
     }


@@ -1931,7 +1939,7 @@ static ram_addr_t find_ram_offset(ram_addr_t size)
     return offset;
 }
 
     return offset;
 }
 

-unsigned long last_ram_page(void)
+static unsigned long last_ram_page(void)

 {
     RAMBlock *block;
     ram_addr_t last = 0;
 {
     RAMBlock *block;
     ram_addr_t last = 0;


@@ -2226,15 +2234,18 @@ static void ram_block_add(RAMBlock *new_block, Error **errp, bool shared)
     }
 }
 
     }
 }
 

-#ifdef __linux__
+#ifdef CONFIG_POSIX

 RAMBlock *qemu_ram_alloc_from_fd(ram_addr_t size, MemoryRegion *mr,
 RAMBlock *qemu_ram_alloc_from_fd(ram_addr_t size, MemoryRegion *mr,

-                                 bool share, int fd,
+                                 uint32_t ram_flags, int fd,

                                  Error **errp)
 {
     RAMBlock *new_block;
     Error *local_err = NULL;
     int64_t file_size;
 
                                  Error **errp)
 {
     RAMBlock *new_block;
     Error *local_err = NULL;
     int64_t file_size;
 

+    /* Just support these ram flags by now. */
+    assert((ram_flags & ~(RAM_SHARED | RAM_PMEM)) == 0);
+

     if (xen_enabled()) {
         error_setg(errp, "-mem-path not supported with Xen");
         return NULL;
     if (xen_enabled()) {
         error_setg(errp, "-mem-path not supported with Xen");
         return NULL;


@@ -2270,14 +2281,14 @@ RAMBlock *qemu_ram_alloc_from_fd(ram_addr_t size, MemoryRegion *mr,
     new_block->mr = mr;
     new_block->used_length = size;
     new_block->max_length = size;
     new_block->mr = mr;
     new_block->used_length = size;
     new_block->max_length = size;

-    new_block->flags = share ? RAM_SHARED : 0;
+    new_block->flags = ram_flags;

     new_block->host = file_ram_alloc(new_block, size, fd, !file_size, errp);
     if (!new_block->host) {
         g_free(new_block);
         return NULL;
     }
 
     new_block->host = file_ram_alloc(new_block, size, fd, !file_size, errp);
     if (!new_block->host) {
         g_free(new_block);
         return NULL;
     }
 

-    ram_block_add(new_block, &local_err, share);
+    ram_block_add(new_block, &local_err, ram_flags & RAM_SHARED);

     if (local_err) {
         g_free(new_block);
         error_propagate(errp, local_err);
     if (local_err) {
         g_free(new_block);
         error_propagate(errp, local_err);


@@ -2289,7 +2300,7 @@ RAMBlock *qemu_ram_alloc_from_fd(ram_addr_t size, MemoryRegion *mr,
 
 
 RAMBlock *qemu_ram_alloc_from_file(ram_addr_t size, MemoryRegion *mr,
 
 
 RAMBlock *qemu_ram_alloc_from_file(ram_addr_t size, MemoryRegion *mr,

-                                   bool share, const char *mem_path,
+                                   uint32_t ram_flags, const char *mem_path,

                                    Error **errp)
 {
     int fd;
                                    Error **errp)
 {
     int fd;


@@ -2301,7 +2312,7 @@ RAMBlock *qemu_ram_alloc_from_file(ram_addr_t size, MemoryRegion *mr,
         return NULL;
     }
 
         return NULL;
     }
 

-    block = qemu_ram_alloc_from_fd(size, mr, share, fd, errp);
+    block = qemu_ram_alloc_from_fd(size, mr, ram_flags, fd, errp);

     if (!block) {
         if (created) {
             unlink(mem_path);
     if (!block) {
         if (created) {
             unlink(mem_path);


@@ -2383,7 +2394,7 @@ static void reclaim_ramblock(RAMBlock *block)
         xen_invalidate_map_cache_entry(block->host);
 #ifndef _WIN32
     } else if (block->fd >= 0) {
         xen_invalidate_map_cache_entry(block->host);
 #ifndef _WIN32
     } else if (block->fd >= 0) {

-        qemu_ram_munmap(block->host, block->max_length);
+        qemu_ram_munmap(block->fd, block->host, block->max_length);

         close(block->fd);
 #endif
     } else {
         close(block->fd);
 #endif
     } else {


@@ -2644,21 +2655,22 @@ void memory_notdirty_write_prepare(NotDirtyInfo *ndi,
     ndi->ram_addr = ram_addr;
     ndi->mem_vaddr = mem_vaddr;
     ndi->size = size;
     ndi->ram_addr = ram_addr;
     ndi->mem_vaddr = mem_vaddr;
     ndi->size = size;

-    ndi->locked = false;
+    ndi->pages = NULL;

 
     assert(tcg_enabled());
     if (!cpu_physical_memory_get_dirty_flag(ram_addr, DIRTY_MEMORY_CODE)) {
 
     assert(tcg_enabled());
     if (!cpu_physical_memory_get_dirty_flag(ram_addr, DIRTY_MEMORY_CODE)) {

-        ndi->locked = true;
-        tb_lock();
-        tb_invalidate_phys_page_fast(ram_addr, size);
+        ndi->pages = page_collection_lock(ram_addr, ram_addr + size);
+        tb_invalidate_phys_page_fast(ndi->pages, ram_addr, size);

     }
 }
 
 /* Called within RCU critical section. */
 void memory_notdirty_write_complete(NotDirtyInfo *ndi)
 {
     }
 }
 
 /* Called within RCU critical section. */
 void memory_notdirty_write_complete(NotDirtyInfo *ndi)
 {

-    if (ndi->locked) {
-        tb_unlock();
+    if (ndi->pages) {
+        assert(tcg_enabled());
+        page_collection_unlock(ndi->pages);
+        ndi->pages = NULL;

     }
 
     /* Set both VGA and migration bits for simplicity and to remove
     }
 
     /* Set both VGA and migration bits for simplicity and to remove


@@ -2745,18 +2757,16 @@ static void check_watchpoint(int offset, int len, MemTxAttrs attrs, int flags)
                 }
                 cpu->watchpoint_hit = wp;
 
                 }
                 cpu->watchpoint_hit = wp;
 

-                /* Both tb_lock and iothread_mutex will be reset when
-                 * cpu_loop_exit or cpu_loop_exit_noexc longjmp
-                 * back into the cpu_exec main loop.
-                 */
-                tb_lock();
+                mmap_lock();

                 tb_check_watchpoint(cpu);
                 if (wp->flags & BP_STOP_BEFORE_ACCESS) {
                     cpu->exception_index = EXCP_DEBUG;
                 tb_check_watchpoint(cpu);
                 if (wp->flags & BP_STOP_BEFORE_ACCESS) {
                     cpu->exception_index = EXCP_DEBUG;

+                    mmap_unlock();

                     cpu_loop_exit(cpu);
                 } else {
                     /* Force execution of one insn next time.  */
                     cpu->cflags_next_tb = 1 | curr_cflags();
                     cpu_loop_exit(cpu);
                 } else {
                     /* Force execution of one insn next time.  */
                     cpu->cflags_next_tb = 1 | curr_cflags();

+                    mmap_unlock();

                     cpu_loop_exit_noexc(cpu);
                 }
             }
                     cpu_loop_exit_noexc(cpu);
                 }
             }


@@ -2841,10 +2851,10 @@ static const MemoryRegionOps watch_mem_ops = {
 };
 
 static MemTxResult flatview_read(FlatView *fv, hwaddr addr,
 };
 
 static MemTxResult flatview_read(FlatView *fv, hwaddr addr,

-                                      MemTxAttrs attrs, uint8_t *buf, int len);
+                                 MemTxAttrs attrs, uint8_t *buf, hwaddr len);

 static MemTxResult flatview_write(FlatView *fv, hwaddr addr, MemTxAttrs attrs,
 static MemTxResult flatview_write(FlatView *fv, hwaddr addr, MemTxAttrs attrs,

-                                  const uint8_t *buf, int len);
-static bool flatview_access_valid(FlatView *fv, hwaddr addr, int len,
+                                  const uint8_t *buf, hwaddr len);
+static bool flatview_access_valid(FlatView *fv, hwaddr addr, hwaddr len,

                                   bool is_write, MemTxAttrs attrs);
 
 static MemTxResult subpage_read(void *opaque, hwaddr addr, uint64_t *data,
                                   bool is_write, MemTxAttrs attrs);
 
 static MemTxResult subpage_read(void *opaque, hwaddr addr, uint64_t *data,


@@ -3050,6 +3060,7 @@ static void tcg_commit(MemoryListener *listener)
     CPUAddressSpace *cpuas;
     AddressSpaceDispatch *d;
 
     CPUAddressSpace *cpuas;
     AddressSpaceDispatch *d;
 

+    assert(tcg_enabled());

     /* since each CPU stores ram addresses in its TLB cache, we must
        reset the modified entries */
     cpuas = container_of(listener, CPUAddressSpace, tcg_as_listener);
     /* since each CPU stores ram addresses in its TLB cache, we must
        reset the modified entries */
     cpuas = container_of(listener, CPUAddressSpace, tcg_as_listener);


@@ -3091,10 +3102,10 @@ MemoryRegion *get_system_io(void)
 /* physical memory access (slow version, mainly for debug) */
 #if defined(CONFIG_USER_ONLY)
 int cpu_memory_rw_debug(CPUState *cpu, target_ulong addr,
 /* physical memory access (slow version, mainly for debug) */
 #if defined(CONFIG_USER_ONLY)
 int cpu_memory_rw_debug(CPUState *cpu, target_ulong addr,

-                        uint8_t *buf, int len, int is_write)
+                        uint8_t *buf, target_ulong len, int is_write)

 {
 {

-    int l, flags;
-    target_ulong page;
+    int flags;
+    target_ulong l, page;

     void * p;
 
     while (len > 0) {
     void * p;
 
     while (len > 0) {


@@ -3147,14 +3158,25 @@ static void invalidate_and_set_dirty(MemoryRegion *mr, hwaddr addr,
     }
     if (dirty_log_mask & (1 << DIRTY_MEMORY_CODE)) {
         assert(tcg_enabled());
     }
     if (dirty_log_mask & (1 << DIRTY_MEMORY_CODE)) {
         assert(tcg_enabled());

-        tb_lock();

         tb_invalidate_phys_range(addr, addr + length);
         tb_invalidate_phys_range(addr, addr + length);

-        tb_unlock();

         dirty_log_mask &= ~(1 << DIRTY_MEMORY_CODE);
     }
     cpu_physical_memory_set_dirty_range(addr, length, dirty_log_mask);
 }
 
         dirty_log_mask &= ~(1 << DIRTY_MEMORY_CODE);
     }
     cpu_physical_memory_set_dirty_range(addr, length, dirty_log_mask);
 }
 

+void memory_region_flush_rom_device(MemoryRegion *mr, hwaddr addr, hwaddr size)
+{
+    /*
+     * In principle this function would work on other memory region types too,
+     * but the ROM device use case is the only one where this operation is
+     * necessary.  Other memory regions should use the
+     * address_space_read/write() APIs.
+     */
+    assert(memory_region_is_romd(mr));
+
+    invalidate_and_set_dirty(mr, addr, size);
+}
+

 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;


@@ -3209,7 +3231,7 @@ static bool prepare_mmio_access(MemoryRegion *mr)
 static MemTxResult flatview_write_continue(FlatView *fv, hwaddr addr,
                                            MemTxAttrs attrs,
                                            const uint8_t *buf,
 static MemTxResult flatview_write_continue(FlatView *fv, hwaddr addr,
                                            MemTxAttrs attrs,
                                            const uint8_t *buf,

-                                           int len, hwaddr addr1,
+                                           hwaddr len, hwaddr addr1,

                                            hwaddr l, MemoryRegion *mr)
 {
     uint8_t *ptr;
                                            hwaddr l, MemoryRegion *mr)
 {
     uint8_t *ptr;


@@ -3254,7 +3276,7 @@ static MemTxResult flatview_write_continue(FlatView *fv, hwaddr addr,
 
 /* Called from RCU critical section.  */
 static MemTxResult flatview_write(FlatView *fv, hwaddr addr, MemTxAttrs attrs,
 
 /* Called from RCU critical section.  */
 static MemTxResult flatview_write(FlatView *fv, hwaddr addr, MemTxAttrs attrs,

-                                  const uint8_t *buf, int len)
+                                  const uint8_t *buf, hwaddr len)

 {
     hwaddr l;
     hwaddr addr1;
 {
     hwaddr l;
     hwaddr addr1;


@@ -3272,7 +3294,7 @@ static MemTxResult flatview_write(FlatView *fv, hwaddr addr, MemTxAttrs attrs,
 /* Called within RCU critical section.  */
 MemTxResult flatview_read_continue(FlatView *fv, hwaddr addr,
                                    MemTxAttrs attrs, uint8_t *buf,
 /* Called within RCU critical section.  */
 MemTxResult flatview_read_continue(FlatView *fv, hwaddr addr,
                                    MemTxAttrs attrs, uint8_t *buf,

-                                   int len, hwaddr addr1, hwaddr l,
+                                   hwaddr len, hwaddr addr1, hwaddr l,

                                    MemoryRegion *mr)
 {
     uint8_t *ptr;
                                    MemoryRegion *mr)
 {
     uint8_t *ptr;


@@ -3315,7 +3337,7 @@ MemTxResult flatview_read_continue(FlatView *fv, hwaddr addr,
 
 /* Called from RCU critical section.  */
 static MemTxResult flatview_read(FlatView *fv, hwaddr addr,
 
 /* Called from RCU critical section.  */
 static MemTxResult flatview_read(FlatView *fv, hwaddr addr,

-                                 MemTxAttrs attrs, uint8_t *buf, int len)
+                                 MemTxAttrs attrs, uint8_t *buf, hwaddr len)

 {
     hwaddr l;
     hwaddr addr1;
 {
     hwaddr l;
     hwaddr addr1;


@@ -3328,7 +3350,7 @@ static MemTxResult flatview_read(FlatView *fv, hwaddr addr,
 }
 
 MemTxResult address_space_read_full(AddressSpace *as, hwaddr addr,
 }
 
 MemTxResult address_space_read_full(AddressSpace *as, hwaddr addr,

-                                    MemTxAttrs attrs, uint8_t *buf, int len)
+                                    MemTxAttrs attrs, uint8_t *buf, hwaddr len)

 {
     MemTxResult result = MEMTX_OK;
     FlatView *fv;
 {
     MemTxResult result = MEMTX_OK;
     FlatView *fv;


@@ -3345,7 +3367,7 @@ MemTxResult address_space_read_full(AddressSpace *as, hwaddr addr,
 
 MemTxResult address_space_write(AddressSpace *as, hwaddr addr,
                                 MemTxAttrs attrs,
 
 MemTxResult address_space_write(AddressSpace *as, hwaddr addr,
                                 MemTxAttrs attrs,

-                                const uint8_t *buf, int len)
+                                const uint8_t *buf, hwaddr len)

 {
     MemTxResult result = MEMTX_OK;
     FlatView *fv;
 {
     MemTxResult result = MEMTX_OK;
     FlatView *fv;


@@ -3361,7 +3383,7 @@ MemTxResult address_space_write(AddressSpace *as, hwaddr addr,
 }
 
 MemTxResult address_space_rw(AddressSpace *as, hwaddr addr, MemTxAttrs attrs,
 }
 
 MemTxResult address_space_rw(AddressSpace *as, hwaddr addr, MemTxAttrs attrs,

-                             uint8_t *buf, int len, bool is_write)
+                             uint8_t *buf, hwaddr len, bool is_write)

 {
     if (is_write) {
         return address_space_write(as, addr, attrs, buf, len);
 {
     if (is_write) {
         return address_space_write(as, addr, attrs, buf, len);


@@ -3371,7 +3393,7 @@ MemTxResult address_space_rw(AddressSpace *as, hwaddr addr, MemTxAttrs attrs,
 }
 
 void cpu_physical_memory_rw(hwaddr addr, uint8_t *buf,
 }
 
 void cpu_physical_memory_rw(hwaddr addr, uint8_t *buf,

-                            int len, int is_write)
+                            hwaddr len, int is_write)

 {
     address_space_rw(&address_space_memory, addr, MEMTXATTRS_UNSPECIFIED,
                      buf, len, is_write);
 {
     address_space_rw(&address_space_memory, addr, MEMTXATTRS_UNSPECIFIED,
                      buf, len, is_write);


@@ -3382,8 +3404,12 @@ enum write_rom_type {
     FLUSH_CACHE,
 };
 
     FLUSH_CACHE,
 };
 

-static inline void cpu_physical_memory_write_rom_internal(AddressSpace *as,
-    hwaddr addr, const uint8_t *buf, int len, enum write_rom_type type)
+static inline MemTxResult address_space_write_rom_internal(AddressSpace *as,
+                                                           hwaddr addr,
+                                                           MemTxAttrs attrs,
+                                                           const uint8_t *buf,
+                                                           hwaddr len,
+                                                           enum write_rom_type type)

 {
     hwaddr l;
     uint8_t *ptr;
 {
     hwaddr l;
     uint8_t *ptr;


@@ -3393,8 +3419,7 @@ static inline void cpu_physical_memory_write_rom_internal(AddressSpace *as,
     rcu_read_lock();
     while (len > 0) {
         l = len;
     rcu_read_lock();
     while (len > 0) {
         l = len;

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

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


@@ -3417,16 +3442,19 @@ static inline void cpu_physical_memory_write_rom_internal(AddressSpace *as,
         addr += l;
     }
     rcu_read_unlock();
         addr += l;
     }
     rcu_read_unlock();

+    return MEMTX_OK;

 }
 
 /* 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(AddressSpace *as, hwaddr addr,
-                                   const uint8_t *buf, int len)
+MemTxResult address_space_write_rom(AddressSpace *as, hwaddr addr,
+                                    MemTxAttrs attrs,
+                                    const uint8_t *buf, hwaddr len)

 {
 {

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

 }
 
 }
 

-void cpu_flush_icache_range(hwaddr start, int len)
+void cpu_flush_icache_range(hwaddr start, hwaddr len)

 {
     /*
      * This function should do the same thing as an icache flush that was
 {
     /*
      * This function should do the same thing as an icache flush that was


@@ -3438,8 +3466,9 @@ void cpu_flush_icache_range(hwaddr start, int len)
         return;
     }
 
         return;
     }
 

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

 }
 
 typedef struct {
 }
 
 typedef struct {


@@ -3458,7 +3487,7 @@ typedef struct MapClient {
 } MapClient;
 
 QemuMutex map_client_list_lock;
 } MapClient;
 
 QemuMutex map_client_list_lock;

-static QLIST_HEAD(map_client_list, MapClient) map_client_list
+static QLIST_HEAD(, MapClient) map_client_list

     = QLIST_HEAD_INITIALIZER(map_client_list);
 
 static void cpu_unregister_map_client_do(MapClient *client)
     = QLIST_HEAD_INITIALIZER(map_client_list);
 
 static void cpu_unregister_map_client_do(MapClient *client)


@@ -3528,7 +3557,7 @@ static void cpu_notify_map_clients(void)
     qemu_mutex_unlock(&map_client_list_lock);
 }
 
     qemu_mutex_unlock(&map_client_list_lock);
 }
 

-static bool flatview_access_valid(FlatView *fv, hwaddr addr, int len,
+static bool flatview_access_valid(FlatView *fv, hwaddr addr, hwaddr len,

                                   bool is_write, MemTxAttrs attrs)
 {
     MemoryRegion *mr;
                                   bool is_write, MemTxAttrs attrs)
 {
     MemoryRegion *mr;


@@ -3551,7 +3580,7 @@ static bool flatview_access_valid(FlatView *fv, hwaddr addr, int len,
 }
 
 bool address_space_access_valid(AddressSpace *as, hwaddr addr,
 }
 
 bool address_space_access_valid(AddressSpace *as, hwaddr addr,

-                                int len, bool is_write,
+                                hwaddr len, bool is_write,

                                 MemTxAttrs attrs)
 {
     FlatView *fv;
                                 MemTxAttrs attrs)
 {
     FlatView *fv;


@@ -3703,9 +3732,6 @@ void cpu_physical_memory_unmap(void *buffer, hwaddr len,
 #define ARG1                     as
 #define SUFFIX
 #define TRANSLATE(...)           address_space_translate(as, __VA_ARGS__)
 #define ARG1                     as
 #define SUFFIX
 #define TRANSLATE(...)           address_space_translate(as, __VA_ARGS__)

-#define IS_DIRECT(mr, is_write)  memory_access_is_direct(mr, is_write)
-#define MAP_RAM(mr, ofs)         qemu_map_ram_ptr((mr)->ram_block, ofs)
-#define INVALIDATE(mr, ofs, len) invalidate_and_set_dirty(mr, ofs, len)

 #define RCU_READ_LOCK(...)       rcu_read_lock()
 #define RCU_READ_UNLOCK(...)     rcu_read_unlock()
 #include "memory_ldst.inc.c"
 #define RCU_READ_LOCK(...)       rcu_read_lock()
 #define RCU_READ_UNLOCK(...)     rcu_read_unlock()
 #include "memory_ldst.inc.c"


@@ -3807,7 +3833,7 @@ static inline MemoryRegion *address_space_translate_cached(
  */
 void
 address_space_read_cached_slow(MemoryRegionCache *cache, hwaddr addr,
  */
 void
 address_space_read_cached_slow(MemoryRegionCache *cache, hwaddr addr,

-                                   void *buf, int len)
+                                   void *buf, hwaddr len)

 {
     hwaddr addr1, l;
     MemoryRegion *mr;
 {
     hwaddr addr1, l;
     MemoryRegion *mr;


@@ -3825,7 +3851,7 @@ address_space_read_cached_slow(MemoryRegionCache *cache, hwaddr addr,
  */
 void
 address_space_write_cached_slow(MemoryRegionCache *cache, hwaddr addr,
  */
 void
 address_space_write_cached_slow(MemoryRegionCache *cache, hwaddr addr,

-                                    const void *buf, int len)
+                                    const void *buf, hwaddr len)

 {
     hwaddr addr1, l;
     MemoryRegion *mr;
 {
     hwaddr addr1, l;
     MemoryRegion *mr;


@@ -3842,20 +3868,16 @@ address_space_write_cached_slow(MemoryRegionCache *cache, hwaddr addr,
 #define ARG1                     cache
 #define SUFFIX                   _cached_slow
 #define TRANSLATE(...)           address_space_translate_cached(cache, __VA_ARGS__)
 #define ARG1                     cache
 #define SUFFIX                   _cached_slow
 #define TRANSLATE(...)           address_space_translate_cached(cache, __VA_ARGS__)

-#define IS_DIRECT(mr, is_write)  memory_access_is_direct(mr, is_write)
-#define MAP_RAM(mr, ofs)         (cache->ptr + (ofs - cache->xlat))
-#define INVALIDATE(mr, ofs, len) invalidate_and_set_dirty(mr, ofs, len)

 #define RCU_READ_LOCK()          ((void)0)
 #define RCU_READ_UNLOCK()        ((void)0)
 #include "memory_ldst.inc.c"
 
 /* virtual memory access for debug (includes writing to ROM) */
 int cpu_memory_rw_debug(CPUState *cpu, target_ulong addr,
 #define RCU_READ_LOCK()          ((void)0)
 #define RCU_READ_UNLOCK()        ((void)0)
 #include "memory_ldst.inc.c"
 
 /* virtual memory access for debug (includes writing to ROM) */
 int cpu_memory_rw_debug(CPUState *cpu, target_ulong addr,

-                        uint8_t *buf, int len, int is_write)
+                        uint8_t *buf, target_ulong len, int is_write)

 {
 {

-    int l;

     hwaddr phys_addr;
     hwaddr phys_addr;

-    target_ulong page;
+    target_ulong l, page;

 
     cpu_synchronize_state(cpu);
     while (len > 0) {
 
     cpu_synchronize_state(cpu);
     while (len > 0) {


@@ -3873,12 +3895,11 @@ int cpu_memory_rw_debug(CPUState *cpu, target_ulong addr,
             l = len;
         phys_addr += (addr & ~TARGET_PAGE_MASK);
         if (is_write) {
             l = len;
         phys_addr += (addr & ~TARGET_PAGE_MASK);
         if (is_write) {

-            cpu_physical_memory_write_rom(cpu->cpu_ases[asidx].as,
-                                          phys_addr, buf, l);
+            address_space_write_rom(cpu->cpu_ases[asidx].as, phys_addr,
+                                    attrs, buf, l);

         } else {
             address_space_rw(cpu->cpu_ases[asidx].as, phys_addr,
         } else {
             address_space_rw(cpu->cpu_ases[asidx].as, phys_addr,

-                             MEMTXATTRS_UNSPECIFIED,
-                             buf, l, 0);
+                             attrs, buf, l, 0);

         }
         len -= l;
         buf += l;
         }
         len -= l;
         buf += l;


@@ -3907,11 +3928,6 @@ int qemu_target_page_bits_min(void)
 }
 #endif
 
 }
 #endif
 

-/*
- * A helper function for the _utterly broken_ virtio device model to find out if
- * it's running on a big endian machine. Don't do this at home kids!
- */
-bool target_words_bigendian(void);

 bool target_words_bigendian(void)
 {
 #if defined(TARGET_WORDS_BIGENDIAN)
 bool target_words_bigendian(void)
 {
 #if defined(TARGET_WORDS_BIGENDIAN)


@@ -4070,6 +4086,11 @@ err:
     return ret;
 }
 
     return ret;
 }
 

+bool ramblock_is_pmem(RAMBlock *rb)
+{
+    return rb->flags & RAM_PMEM;
+}
+

 #endif
 
 void page_size_init(void)
 #endif
 
 void page_size_init(void)