Message ID | 20200507173958.25894-11-philmd@redhat.com (mailing list archive) |
---|---|
State | New, archived |
Headers | show |
Series | exec: Shear 'exec/ram_addr.h' and make NVMe device target-agnostic | expand |
Philippe Mathieu-Daudé <philmd@redhat.com> wrote:
> Signed-off-by: Philippe Mathieu-Daudé <philmd@redhat.com>
Once here, can someone give a test that meassures if it makes sense that
this functions are inline?
They are relatively big, and I would preffer them to be in a .c file,
but I have no clue about how performance critical they are.
Again, this include was another of the reasons that migration/ram.c
can't be make target agnostic.
Later, Juan.
On Thu, May 07, 2020 at 07:39:58PM +0200, Philippe Mathieu-Daudé wrote: > Signed-off-by: Philippe Mathieu-Daudé <philmd@redhat.com> ppc parts Acked-by: David Gibson <david@gibson.dropbear.id.au> > --- > include/exec/memory-internal.h | 305 ++++++++++++++++++++++++++++++++- > include/exec/ram_addr.h | 303 +------------------------------- > accel/tcg/cputlb.c | 1 - > hw/ppc/spapr.c | 1 - > hw/ppc/spapr_pci.c | 1 - > memory.c | 1 - > 6 files changed, 305 insertions(+), 307 deletions(-) > > diff --git a/include/exec/memory-internal.h b/include/exec/memory-internal.h > index b2b7c1e78a..4abb3bbd85 100644 > --- a/include/exec/memory-internal.h > +++ b/include/exec/memory-internal.h > @@ -21,8 +21,13 @@ > #define MEMORY_INTERNAL_H > > #include "cpu.h" > +#include "sysemu/tcg.h" > +#include "sysemu/xen.h" > +#include "exec/ramlist.h" > +#include "exec/ramblock.h" > > #ifdef CONFIG_SOFTMMU > + > static inline AddressSpaceDispatch *flatview_to_dispatch(FlatView *fv) > { > return fv->dispatch; > @@ -49,5 +54,303 @@ void address_space_dispatch_free(AddressSpaceDispatch *d); > > void mtree_print_dispatch(struct AddressSpaceDispatch *d, > MemoryRegion *root); > -#endif > + > +#define DIRTY_CLIENTS_ALL ((1 << DIRTY_MEMORY_NUM) - 1) > +#define DIRTY_CLIENTS_NOCODE (DIRTY_CLIENTS_ALL & ~(1 << DIRTY_MEMORY_CODE)) > + > +static inline bool cpu_physical_memory_get_dirty(ram_addr_t start, > + ram_addr_t length, > + unsigned client) > +{ > + DirtyMemoryBlocks *blocks; > + unsigned long end, page; > + unsigned long idx, offset, base; > + bool dirty = false; > + > + assert(client < DIRTY_MEMORY_NUM); > + > + end = TARGET_PAGE_ALIGN(start + length) >> TARGET_PAGE_BITS; > + page = start >> TARGET_PAGE_BITS; > + > + WITH_RCU_READ_LOCK_GUARD() { > + blocks = atomic_rcu_read(&ram_list.dirty_memory[client]); > + > + idx = page / DIRTY_MEMORY_BLOCK_SIZE; > + offset = page % DIRTY_MEMORY_BLOCK_SIZE; > + base = page - offset; > + while (page < end) { > + unsigned long next = MIN(end, base + DIRTY_MEMORY_BLOCK_SIZE); > + unsigned long num = next - base; > + unsigned long found = find_next_bit(blocks->blocks[idx], > + num, offset); > + if (found < num) { > + dirty = true; > + break; > + } > + > + page = next; > + idx++; > + offset = 0; > + base += DIRTY_MEMORY_BLOCK_SIZE; > + } > + } > + > + return dirty; > +} > + > +static inline bool cpu_physical_memory_all_dirty(ram_addr_t start, > + ram_addr_t length, > + unsigned client) > +{ > + DirtyMemoryBlocks *blocks; > + unsigned long end, page; > + unsigned long idx, offset, base; > + bool dirty = true; > + > + assert(client < DIRTY_MEMORY_NUM); > + > + end = TARGET_PAGE_ALIGN(start + length) >> TARGET_PAGE_BITS; > + page = start >> TARGET_PAGE_BITS; > + > + RCU_READ_LOCK_GUARD(); > + > + blocks = atomic_rcu_read(&ram_list.dirty_memory[client]); > + > + idx = page / DIRTY_MEMORY_BLOCK_SIZE; > + offset = page % DIRTY_MEMORY_BLOCK_SIZE; > + base = page - offset; > + while (page < end) { > + unsigned long next = MIN(end, base + DIRTY_MEMORY_BLOCK_SIZE); > + unsigned long num = next - base; > + unsigned long found = find_next_zero_bit(blocks->blocks[idx], > + num, offset); > + if (found < num) { > + dirty = false; > + break; > + } > + > + page = next; > + idx++; > + offset = 0; > + base += DIRTY_MEMORY_BLOCK_SIZE; > + } > + > + return dirty; > +} > + > +static inline bool cpu_physical_memory_get_dirty_flag(ram_addr_t addr, > + unsigned client) > +{ > + return cpu_physical_memory_get_dirty(addr, 1, client); > +} > + > +static inline bool cpu_physical_memory_is_clean(ram_addr_t addr) > +{ > + bool vga = cpu_physical_memory_get_dirty_flag(addr, DIRTY_MEMORY_VGA); > + bool code = cpu_physical_memory_get_dirty_flag(addr, DIRTY_MEMORY_CODE); > + bool migration = cpu_physical_memory_get_dirty_flag(addr, > + DIRTY_MEMORY_MIGRATION); > + return !(vga && code && migration); > +} > + > +static inline uint8_t cpu_physical_memory_range_includes_clean(ram_addr_t start, > + ram_addr_t length, > + uint8_t mask) > +{ > + uint8_t ret = 0; > + > + if (mask & (1 << DIRTY_MEMORY_VGA) && > + !cpu_physical_memory_all_dirty(start, length, DIRTY_MEMORY_VGA)) { > + ret |= (1 << DIRTY_MEMORY_VGA); > + } > + if (mask & (1 << DIRTY_MEMORY_CODE) && > + !cpu_physical_memory_all_dirty(start, length, DIRTY_MEMORY_CODE)) { > + ret |= (1 << DIRTY_MEMORY_CODE); > + } > + if (mask & (1 << DIRTY_MEMORY_MIGRATION) && > + !cpu_physical_memory_all_dirty(start, length, DIRTY_MEMORY_MIGRATION)) { > + ret |= (1 << DIRTY_MEMORY_MIGRATION); > + } > + return ret; > +} > + > +static inline void cpu_physical_memory_set_dirty_flag(ram_addr_t addr, > + unsigned client) > +{ > + unsigned long page, idx, offset; > + DirtyMemoryBlocks *blocks; > + > + assert(client < DIRTY_MEMORY_NUM); > + > + page = addr >> TARGET_PAGE_BITS; > + idx = page / DIRTY_MEMORY_BLOCK_SIZE; > + offset = page % DIRTY_MEMORY_BLOCK_SIZE; > + > + RCU_READ_LOCK_GUARD(); > + > + blocks = atomic_rcu_read(&ram_list.dirty_memory[client]); > + > + set_bit_atomic(offset, blocks->blocks[idx]); > +} > + > +static inline void cpu_physical_memory_set_dirty_range(ram_addr_t start, > + ram_addr_t length, > + uint8_t mask) > +{ > + DirtyMemoryBlocks *blocks[DIRTY_MEMORY_NUM]; > + unsigned long end, page; > + unsigned long idx, offset, base; > + int i; > + > + if (!mask && !xen_enabled()) { > + return; > + } > + > + end = TARGET_PAGE_ALIGN(start + length) >> TARGET_PAGE_BITS; > + page = start >> TARGET_PAGE_BITS; > + > + WITH_RCU_READ_LOCK_GUARD() { > + for (i = 0; i < DIRTY_MEMORY_NUM; i++) { > + blocks[i] = atomic_rcu_read(&ram_list.dirty_memory[i]); > + } > + > + idx = page / DIRTY_MEMORY_BLOCK_SIZE; > + offset = page % DIRTY_MEMORY_BLOCK_SIZE; > + base = page - offset; > + while (page < end) { > + unsigned long next = MIN(end, base + DIRTY_MEMORY_BLOCK_SIZE); > + > + if (likely(mask & (1 << DIRTY_MEMORY_MIGRATION))) { > + bitmap_set_atomic(blocks[DIRTY_MEMORY_MIGRATION]->blocks[idx], > + offset, next - page); > + } > + if (unlikely(mask & (1 << DIRTY_MEMORY_VGA))) { > + bitmap_set_atomic(blocks[DIRTY_MEMORY_VGA]->blocks[idx], > + offset, next - page); > + } > + if (unlikely(mask & (1 << DIRTY_MEMORY_CODE))) { > + bitmap_set_atomic(blocks[DIRTY_MEMORY_CODE]->blocks[idx], > + offset, next - page); > + } > + > + page = next; > + idx++; > + offset = 0; > + base += DIRTY_MEMORY_BLOCK_SIZE; > + } > + } > + > + xen_hvm_modified_memory(start, length); > +} > + > +#if !defined(_WIN32) > +static inline void cpu_physical_memory_set_dirty_lebitmap(unsigned long *bitmap, > + ram_addr_t start, > + ram_addr_t pages) > +{ > + unsigned long i, j; > + unsigned long page_number, c; > + hwaddr addr; > + ram_addr_t ram_addr; > + unsigned long len = (pages + HOST_LONG_BITS - 1) / HOST_LONG_BITS; > + unsigned long hpratio = qemu_real_host_page_size / TARGET_PAGE_SIZE; > + unsigned long page = BIT_WORD(start >> TARGET_PAGE_BITS); > + > + /* start address is aligned at the start of a word? */ > + if ((((page * BITS_PER_LONG) << TARGET_PAGE_BITS) == start) && > + (hpratio == 1)) { > + unsigned long **blocks[DIRTY_MEMORY_NUM]; > + unsigned long idx; > + unsigned long offset; > + long k; > + long nr = BITS_TO_LONGS(pages); > + > + idx = (start >> TARGET_PAGE_BITS) / DIRTY_MEMORY_BLOCK_SIZE; > + offset = BIT_WORD((start >> TARGET_PAGE_BITS) % > + DIRTY_MEMORY_BLOCK_SIZE); > + > + WITH_RCU_READ_LOCK_GUARD() { > + for (i = 0; i < DIRTY_MEMORY_NUM; i++) { > + blocks[i] = atomic_rcu_read(&ram_list.dirty_memory[i])->blocks; > + } > + > + for (k = 0; k < nr; k++) { > + if (bitmap[k]) { > + unsigned long temp = leul_to_cpu(bitmap[k]); > + > + atomic_or(&blocks[DIRTY_MEMORY_VGA][idx][offset], temp); > + > + if (global_dirty_log) { > + atomic_or(&blocks[DIRTY_MEMORY_MIGRATION][idx][offset], > + temp); > + } > + > + if (tcg_enabled()) { > + atomic_or(&blocks[DIRTY_MEMORY_CODE][idx][offset], > + temp); > + } > + } > + > + if (++offset >= BITS_TO_LONGS(DIRTY_MEMORY_BLOCK_SIZE)) { > + offset = 0; > + idx++; > + } > + } > + } > + > + xen_hvm_modified_memory(start, pages << TARGET_PAGE_BITS); > + } else { > + uint8_t clients = tcg_enabled() ? DIRTY_CLIENTS_ALL > + : DIRTY_CLIENTS_NOCODE; > + > + if (!global_dirty_log) { > + clients &= ~(1 << DIRTY_MEMORY_MIGRATION); > + } > + > + /* > + * bitmap-traveling is faster than memory-traveling (for addr...) > + * especially when most of the memory is not dirty. > + */ > + for (i = 0; i < len; i++) { > + if (bitmap[i] != 0) { > + c = leul_to_cpu(bitmap[i]); > + do { > + j = ctzl(c); > + c &= ~(1ul << j); > + page_number = (i * HOST_LONG_BITS + j) * hpratio; > + addr = page_number * TARGET_PAGE_SIZE; > + ram_addr = start + addr; > + cpu_physical_memory_set_dirty_range(ram_addr, > + TARGET_PAGE_SIZE * hpratio, clients); > + } while (c != 0); > + } > + } > + } > +} > +#endif /* not _WIN32 */ > + > +bool cpu_physical_memory_test_and_clear_dirty(ram_addr_t start, > + ram_addr_t length, > + unsigned client); > + > +DirtyBitmapSnapshot *cpu_physical_memory_snapshot_and_clear_dirty( > + MemoryRegion *mr, > + hwaddr offset, > + hwaddr length, > + unsigned client); > + > +bool cpu_physical_memory_snapshot_get_dirty(DirtyBitmapSnapshot *snap, > + ram_addr_t start, > + ram_addr_t length); > + > +static inline void cpu_physical_memory_clear_dirty_range(ram_addr_t start, > + ram_addr_t length) > +{ > + cpu_physical_memory_test_and_clear_dirty(start, length, > + DIRTY_MEMORY_MIGRATION); > + cpu_physical_memory_test_and_clear_dirty(start, length, DIRTY_MEMORY_VGA); > + cpu_physical_memory_test_and_clear_dirty(start, length, DIRTY_MEMORY_CODE); > +} > + > +#endif /* CONFIG_SOFTMMU */ > #endif > diff --git a/include/exec/ram_addr.h b/include/exec/ram_addr.h > index 6acde47a0f..64bf28a332 100644 > --- a/include/exec/ram_addr.h > +++ b/include/exec/ram_addr.h > @@ -21,310 +21,9 @@ > > #ifndef CONFIG_USER_ONLY > #include "cpu.h" > -#include "sysemu/xen.h" > -#include "sysemu/tcg.h" > #include "exec/ramlist.h" > #include "exec/ramblock.h" > - > - > - > -#define DIRTY_CLIENTS_ALL ((1 << DIRTY_MEMORY_NUM) - 1) > -#define DIRTY_CLIENTS_NOCODE (DIRTY_CLIENTS_ALL & ~(1 << DIRTY_MEMORY_CODE)) > - > -static inline bool cpu_physical_memory_get_dirty(ram_addr_t start, > - ram_addr_t length, > - unsigned client) > -{ > - DirtyMemoryBlocks *blocks; > - unsigned long end, page; > - unsigned long idx, offset, base; > - bool dirty = false; > - > - assert(client < DIRTY_MEMORY_NUM); > - > - end = TARGET_PAGE_ALIGN(start + length) >> TARGET_PAGE_BITS; > - page = start >> TARGET_PAGE_BITS; > - > - WITH_RCU_READ_LOCK_GUARD() { > - blocks = atomic_rcu_read(&ram_list.dirty_memory[client]); > - > - idx = page / DIRTY_MEMORY_BLOCK_SIZE; > - offset = page % DIRTY_MEMORY_BLOCK_SIZE; > - base = page - offset; > - while (page < end) { > - unsigned long next = MIN(end, base + DIRTY_MEMORY_BLOCK_SIZE); > - unsigned long num = next - base; > - unsigned long found = find_next_bit(blocks->blocks[idx], > - num, offset); > - if (found < num) { > - dirty = true; > - break; > - } > - > - page = next; > - idx++; > - offset = 0; > - base += DIRTY_MEMORY_BLOCK_SIZE; > - } > - } > - > - return dirty; > -} > - > -static inline bool cpu_physical_memory_all_dirty(ram_addr_t start, > - ram_addr_t length, > - unsigned client) > -{ > - DirtyMemoryBlocks *blocks; > - unsigned long end, page; > - unsigned long idx, offset, base; > - bool dirty = true; > - > - assert(client < DIRTY_MEMORY_NUM); > - > - end = TARGET_PAGE_ALIGN(start + length) >> TARGET_PAGE_BITS; > - page = start >> TARGET_PAGE_BITS; > - > - RCU_READ_LOCK_GUARD(); > - > - blocks = atomic_rcu_read(&ram_list.dirty_memory[client]); > - > - idx = page / DIRTY_MEMORY_BLOCK_SIZE; > - offset = page % DIRTY_MEMORY_BLOCK_SIZE; > - base = page - offset; > - while (page < end) { > - unsigned long next = MIN(end, base + DIRTY_MEMORY_BLOCK_SIZE); > - unsigned long num = next - base; > - unsigned long found = find_next_zero_bit(blocks->blocks[idx], > - num, offset); > - if (found < num) { > - dirty = false; > - break; > - } > - > - page = next; > - idx++; > - offset = 0; > - base += DIRTY_MEMORY_BLOCK_SIZE; > - } > - > - return dirty; > -} > - > -static inline bool cpu_physical_memory_get_dirty_flag(ram_addr_t addr, > - unsigned client) > -{ > - return cpu_physical_memory_get_dirty(addr, 1, client); > -} > - > -static inline bool cpu_physical_memory_is_clean(ram_addr_t addr) > -{ > - bool vga = cpu_physical_memory_get_dirty_flag(addr, DIRTY_MEMORY_VGA); > - bool code = cpu_physical_memory_get_dirty_flag(addr, DIRTY_MEMORY_CODE); > - bool migration = cpu_physical_memory_get_dirty_flag(addr, > - DIRTY_MEMORY_MIGRATION); > - return !(vga && code && migration); > -} > - > -static inline uint8_t cpu_physical_memory_range_includes_clean(ram_addr_t start, > - ram_addr_t length, > - uint8_t mask) > -{ > - uint8_t ret = 0; > - > - if (mask & (1 << DIRTY_MEMORY_VGA) && > - !cpu_physical_memory_all_dirty(start, length, DIRTY_MEMORY_VGA)) { > - ret |= (1 << DIRTY_MEMORY_VGA); > - } > - if (mask & (1 << DIRTY_MEMORY_CODE) && > - !cpu_physical_memory_all_dirty(start, length, DIRTY_MEMORY_CODE)) { > - ret |= (1 << DIRTY_MEMORY_CODE); > - } > - if (mask & (1 << DIRTY_MEMORY_MIGRATION) && > - !cpu_physical_memory_all_dirty(start, length, DIRTY_MEMORY_MIGRATION)) { > - ret |= (1 << DIRTY_MEMORY_MIGRATION); > - } > - return ret; > -} > - > -static inline void cpu_physical_memory_set_dirty_flag(ram_addr_t addr, > - unsigned client) > -{ > - unsigned long page, idx, offset; > - DirtyMemoryBlocks *blocks; > - > - assert(client < DIRTY_MEMORY_NUM); > - > - page = addr >> TARGET_PAGE_BITS; > - idx = page / DIRTY_MEMORY_BLOCK_SIZE; > - offset = page % DIRTY_MEMORY_BLOCK_SIZE; > - > - RCU_READ_LOCK_GUARD(); > - > - blocks = atomic_rcu_read(&ram_list.dirty_memory[client]); > - > - set_bit_atomic(offset, blocks->blocks[idx]); > -} > - > -static inline void cpu_physical_memory_set_dirty_range(ram_addr_t start, > - ram_addr_t length, > - uint8_t mask) > -{ > - DirtyMemoryBlocks *blocks[DIRTY_MEMORY_NUM]; > - unsigned long end, page; > - unsigned long idx, offset, base; > - int i; > - > - if (!mask && !xen_enabled()) { > - return; > - } > - > - end = TARGET_PAGE_ALIGN(start + length) >> TARGET_PAGE_BITS; > - page = start >> TARGET_PAGE_BITS; > - > - WITH_RCU_READ_LOCK_GUARD() { > - for (i = 0; i < DIRTY_MEMORY_NUM; i++) { > - blocks[i] = atomic_rcu_read(&ram_list.dirty_memory[i]); > - } > - > - idx = page / DIRTY_MEMORY_BLOCK_SIZE; > - offset = page % DIRTY_MEMORY_BLOCK_SIZE; > - base = page - offset; > - while (page < end) { > - unsigned long next = MIN(end, base + DIRTY_MEMORY_BLOCK_SIZE); > - > - if (likely(mask & (1 << DIRTY_MEMORY_MIGRATION))) { > - bitmap_set_atomic(blocks[DIRTY_MEMORY_MIGRATION]->blocks[idx], > - offset, next - page); > - } > - if (unlikely(mask & (1 << DIRTY_MEMORY_VGA))) { > - bitmap_set_atomic(blocks[DIRTY_MEMORY_VGA]->blocks[idx], > - offset, next - page); > - } > - if (unlikely(mask & (1 << DIRTY_MEMORY_CODE))) { > - bitmap_set_atomic(blocks[DIRTY_MEMORY_CODE]->blocks[idx], > - offset, next - page); > - } > - > - page = next; > - idx++; > - offset = 0; > - base += DIRTY_MEMORY_BLOCK_SIZE; > - } > - } > - > - xen_hvm_modified_memory(start, length); > -} > - > -#if !defined(_WIN32) > -static inline void cpu_physical_memory_set_dirty_lebitmap(unsigned long *bitmap, > - ram_addr_t start, > - ram_addr_t pages) > -{ > - unsigned long i, j; > - unsigned long page_number, c; > - hwaddr addr; > - ram_addr_t ram_addr; > - unsigned long len = (pages + HOST_LONG_BITS - 1) / HOST_LONG_BITS; > - unsigned long hpratio = qemu_real_host_page_size / TARGET_PAGE_SIZE; > - unsigned long page = BIT_WORD(start >> TARGET_PAGE_BITS); > - > - /* start address is aligned at the start of a word? */ > - if ((((page * BITS_PER_LONG) << TARGET_PAGE_BITS) == start) && > - (hpratio == 1)) { > - unsigned long **blocks[DIRTY_MEMORY_NUM]; > - unsigned long idx; > - unsigned long offset; > - long k; > - long nr = BITS_TO_LONGS(pages); > - > - idx = (start >> TARGET_PAGE_BITS) / DIRTY_MEMORY_BLOCK_SIZE; > - offset = BIT_WORD((start >> TARGET_PAGE_BITS) % > - DIRTY_MEMORY_BLOCK_SIZE); > - > - WITH_RCU_READ_LOCK_GUARD() { > - for (i = 0; i < DIRTY_MEMORY_NUM; i++) { > - blocks[i] = atomic_rcu_read(&ram_list.dirty_memory[i])->blocks; > - } > - > - for (k = 0; k < nr; k++) { > - if (bitmap[k]) { > - unsigned long temp = leul_to_cpu(bitmap[k]); > - > - atomic_or(&blocks[DIRTY_MEMORY_VGA][idx][offset], temp); > - > - if (global_dirty_log) { > - atomic_or(&blocks[DIRTY_MEMORY_MIGRATION][idx][offset], > - temp); > - } > - > - if (tcg_enabled()) { > - atomic_or(&blocks[DIRTY_MEMORY_CODE][idx][offset], > - temp); > - } > - } > - > - if (++offset >= BITS_TO_LONGS(DIRTY_MEMORY_BLOCK_SIZE)) { > - offset = 0; > - idx++; > - } > - } > - } > - > - xen_hvm_modified_memory(start, pages << TARGET_PAGE_BITS); > - } else { > - uint8_t clients = tcg_enabled() > - ? DIRTY_CLIENTS_ALL : DIRTY_CLIENTS_NOCODE; > - > - if (!global_dirty_log) { > - clients &= ~(1 << DIRTY_MEMORY_MIGRATION); > - } > - > - /* > - * bitmap-traveling is faster than memory-traveling (for addr...) > - * especially when most of the memory is not dirty. > - */ > - for (i = 0; i < len; i++) { > - if (bitmap[i] != 0) { > - c = leul_to_cpu(bitmap[i]); > - do { > - j = ctzl(c); > - c &= ~(1ul << j); > - page_number = (i * HOST_LONG_BITS + j) * hpratio; > - addr = page_number * TARGET_PAGE_SIZE; > - ram_addr = start + addr; > - cpu_physical_memory_set_dirty_range(ram_addr, > - TARGET_PAGE_SIZE * hpratio, clients); > - } while (c != 0); > - } > - } > - } > -} > -#endif /* not _WIN32 */ > - > -bool cpu_physical_memory_test_and_clear_dirty(ram_addr_t start, > - ram_addr_t length, > - unsigned client); > - > -DirtyBitmapSnapshot *cpu_physical_memory_snapshot_and_clear_dirty( > - MemoryRegion *mr, > - hwaddr offset, > - hwaddr length, > - unsigned client); > - > -bool cpu_physical_memory_snapshot_get_dirty(DirtyBitmapSnapshot *snap, > - ram_addr_t start, > - ram_addr_t length); > - > -static inline void cpu_physical_memory_clear_dirty_range(ram_addr_t start, > - ram_addr_t length) > -{ > - cpu_physical_memory_test_and_clear_dirty(start, length, > - DIRTY_MEMORY_MIGRATION); > - cpu_physical_memory_test_and_clear_dirty(start, length, DIRTY_MEMORY_VGA); > - cpu_physical_memory_test_and_clear_dirty(start, length, DIRTY_MEMORY_CODE); > -} > - > +#include "exec/memory-internal.h" > > /* Called with RCU critical section */ > static inline > diff --git a/accel/tcg/cputlb.c b/accel/tcg/cputlb.c > index e3b5750c3b..922671f246 100644 > --- a/accel/tcg/cputlb.c > +++ b/accel/tcg/cputlb.c > @@ -26,7 +26,6 @@ > #include "exec/cpu_ldst.h" > #include "exec/cputlb.h" > #include "exec/memory-internal.h" > -#include "exec/ram_addr.h" > #include "tcg/tcg.h" > #include "qemu/error-report.h" > #include "exec/log.h" > diff --git a/hw/ppc/spapr.c b/hw/ppc/spapr.c > index c18eab0a23..d7c3bf3932 100644 > --- a/hw/ppc/spapr.c > +++ b/hw/ppc/spapr.c > @@ -69,7 +69,6 @@ > #include "hw/virtio/vhost-scsi-common.h" > > #include "exec/address-spaces.h" > -#include "exec/ram_addr.h" > #include "hw/usb.h" > #include "qemu/config-file.h" > #include "qemu/error-report.h" > diff --git a/hw/ppc/spapr_pci.c b/hw/ppc/spapr_pci.c > index 61b84a392d..8d9aeba6e6 100644 > --- a/hw/ppc/spapr_pci.c > +++ b/hw/ppc/spapr_pci.c > @@ -36,7 +36,6 @@ > #include "hw/ppc/spapr.h" > #include "hw/pci-host/spapr.h" > #include "exec/address-spaces.h" > -#include "exec/ram_addr.h" > #include <libfdt.h> > #include "trace.h" > #include "qemu/error-report.h" > diff --git a/memory.c b/memory.c > index e8e7bcd6c7..4e1d19c5fc 100644 > --- a/memory.c > +++ b/memory.c > @@ -27,7 +27,6 @@ > #include "trace-root.h" > > #include "exec/memory-internal.h" > -#include "exec/ram_addr.h" > #include "exec/ramblock.h" > #include "sysemu/kvm.h" > #include "sysemu/runstate.h"
diff --git a/include/exec/memory-internal.h b/include/exec/memory-internal.h index b2b7c1e78a..4abb3bbd85 100644 --- a/include/exec/memory-internal.h +++ b/include/exec/memory-internal.h @@ -21,8 +21,13 @@ #define MEMORY_INTERNAL_H #include "cpu.h" +#include "sysemu/tcg.h" +#include "sysemu/xen.h" +#include "exec/ramlist.h" +#include "exec/ramblock.h" #ifdef CONFIG_SOFTMMU + static inline AddressSpaceDispatch *flatview_to_dispatch(FlatView *fv) { return fv->dispatch; @@ -49,5 +54,303 @@ void address_space_dispatch_free(AddressSpaceDispatch *d); void mtree_print_dispatch(struct AddressSpaceDispatch *d, MemoryRegion *root); -#endif + +#define DIRTY_CLIENTS_ALL ((1 << DIRTY_MEMORY_NUM) - 1) +#define DIRTY_CLIENTS_NOCODE (DIRTY_CLIENTS_ALL & ~(1 << DIRTY_MEMORY_CODE)) + +static inline bool cpu_physical_memory_get_dirty(ram_addr_t start, + ram_addr_t length, + unsigned client) +{ + DirtyMemoryBlocks *blocks; + unsigned long end, page; + unsigned long idx, offset, base; + bool dirty = false; + + assert(client < DIRTY_MEMORY_NUM); + + end = TARGET_PAGE_ALIGN(start + length) >> TARGET_PAGE_BITS; + page = start >> TARGET_PAGE_BITS; + + WITH_RCU_READ_LOCK_GUARD() { + blocks = atomic_rcu_read(&ram_list.dirty_memory[client]); + + idx = page / DIRTY_MEMORY_BLOCK_SIZE; + offset = page % DIRTY_MEMORY_BLOCK_SIZE; + base = page - offset; + while (page < end) { + unsigned long next = MIN(end, base + DIRTY_MEMORY_BLOCK_SIZE); + unsigned long num = next - base; + unsigned long found = find_next_bit(blocks->blocks[idx], + num, offset); + if (found < num) { + dirty = true; + break; + } + + page = next; + idx++; + offset = 0; + base += DIRTY_MEMORY_BLOCK_SIZE; + } + } + + return dirty; +} + +static inline bool cpu_physical_memory_all_dirty(ram_addr_t start, + ram_addr_t length, + unsigned client) +{ + DirtyMemoryBlocks *blocks; + unsigned long end, page; + unsigned long idx, offset, base; + bool dirty = true; + + assert(client < DIRTY_MEMORY_NUM); + + end = TARGET_PAGE_ALIGN(start + length) >> TARGET_PAGE_BITS; + page = start >> TARGET_PAGE_BITS; + + RCU_READ_LOCK_GUARD(); + + blocks = atomic_rcu_read(&ram_list.dirty_memory[client]); + + idx = page / DIRTY_MEMORY_BLOCK_SIZE; + offset = page % DIRTY_MEMORY_BLOCK_SIZE; + base = page - offset; + while (page < end) { + unsigned long next = MIN(end, base + DIRTY_MEMORY_BLOCK_SIZE); + unsigned long num = next - base; + unsigned long found = find_next_zero_bit(blocks->blocks[idx], + num, offset); + if (found < num) { + dirty = false; + break; + } + + page = next; + idx++; + offset = 0; + base += DIRTY_MEMORY_BLOCK_SIZE; + } + + return dirty; +} + +static inline bool cpu_physical_memory_get_dirty_flag(ram_addr_t addr, + unsigned client) +{ + return cpu_physical_memory_get_dirty(addr, 1, client); +} + +static inline bool cpu_physical_memory_is_clean(ram_addr_t addr) +{ + bool vga = cpu_physical_memory_get_dirty_flag(addr, DIRTY_MEMORY_VGA); + bool code = cpu_physical_memory_get_dirty_flag(addr, DIRTY_MEMORY_CODE); + bool migration = cpu_physical_memory_get_dirty_flag(addr, + DIRTY_MEMORY_MIGRATION); + return !(vga && code && migration); +} + +static inline uint8_t cpu_physical_memory_range_includes_clean(ram_addr_t start, + ram_addr_t length, + uint8_t mask) +{ + uint8_t ret = 0; + + if (mask & (1 << DIRTY_MEMORY_VGA) && + !cpu_physical_memory_all_dirty(start, length, DIRTY_MEMORY_VGA)) { + ret |= (1 << DIRTY_MEMORY_VGA); + } + if (mask & (1 << DIRTY_MEMORY_CODE) && + !cpu_physical_memory_all_dirty(start, length, DIRTY_MEMORY_CODE)) { + ret |= (1 << DIRTY_MEMORY_CODE); + } + if (mask & (1 << DIRTY_MEMORY_MIGRATION) && + !cpu_physical_memory_all_dirty(start, length, DIRTY_MEMORY_MIGRATION)) { + ret |= (1 << DIRTY_MEMORY_MIGRATION); + } + return ret; +} + +static inline void cpu_physical_memory_set_dirty_flag(ram_addr_t addr, + unsigned client) +{ + unsigned long page, idx, offset; + DirtyMemoryBlocks *blocks; + + assert(client < DIRTY_MEMORY_NUM); + + page = addr >> TARGET_PAGE_BITS; + idx = page / DIRTY_MEMORY_BLOCK_SIZE; + offset = page % DIRTY_MEMORY_BLOCK_SIZE; + + RCU_READ_LOCK_GUARD(); + + blocks = atomic_rcu_read(&ram_list.dirty_memory[client]); + + set_bit_atomic(offset, blocks->blocks[idx]); +} + +static inline void cpu_physical_memory_set_dirty_range(ram_addr_t start, + ram_addr_t length, + uint8_t mask) +{ + DirtyMemoryBlocks *blocks[DIRTY_MEMORY_NUM]; + unsigned long end, page; + unsigned long idx, offset, base; + int i; + + if (!mask && !xen_enabled()) { + return; + } + + end = TARGET_PAGE_ALIGN(start + length) >> TARGET_PAGE_BITS; + page = start >> TARGET_PAGE_BITS; + + WITH_RCU_READ_LOCK_GUARD() { + for (i = 0; i < DIRTY_MEMORY_NUM; i++) { + blocks[i] = atomic_rcu_read(&ram_list.dirty_memory[i]); + } + + idx = page / DIRTY_MEMORY_BLOCK_SIZE; + offset = page % DIRTY_MEMORY_BLOCK_SIZE; + base = page - offset; + while (page < end) { + unsigned long next = MIN(end, base + DIRTY_MEMORY_BLOCK_SIZE); + + if (likely(mask & (1 << DIRTY_MEMORY_MIGRATION))) { + bitmap_set_atomic(blocks[DIRTY_MEMORY_MIGRATION]->blocks[idx], + offset, next - page); + } + if (unlikely(mask & (1 << DIRTY_MEMORY_VGA))) { + bitmap_set_atomic(blocks[DIRTY_MEMORY_VGA]->blocks[idx], + offset, next - page); + } + if (unlikely(mask & (1 << DIRTY_MEMORY_CODE))) { + bitmap_set_atomic(blocks[DIRTY_MEMORY_CODE]->blocks[idx], + offset, next - page); + } + + page = next; + idx++; + offset = 0; + base += DIRTY_MEMORY_BLOCK_SIZE; + } + } + + xen_hvm_modified_memory(start, length); +} + +#if !defined(_WIN32) +static inline void cpu_physical_memory_set_dirty_lebitmap(unsigned long *bitmap, + ram_addr_t start, + ram_addr_t pages) +{ + unsigned long i, j; + unsigned long page_number, c; + hwaddr addr; + ram_addr_t ram_addr; + unsigned long len = (pages + HOST_LONG_BITS - 1) / HOST_LONG_BITS; + unsigned long hpratio = qemu_real_host_page_size / TARGET_PAGE_SIZE; + unsigned long page = BIT_WORD(start >> TARGET_PAGE_BITS); + + /* start address is aligned at the start of a word? */ + if ((((page * BITS_PER_LONG) << TARGET_PAGE_BITS) == start) && + (hpratio == 1)) { + unsigned long **blocks[DIRTY_MEMORY_NUM]; + unsigned long idx; + unsigned long offset; + long k; + long nr = BITS_TO_LONGS(pages); + + idx = (start >> TARGET_PAGE_BITS) / DIRTY_MEMORY_BLOCK_SIZE; + offset = BIT_WORD((start >> TARGET_PAGE_BITS) % + DIRTY_MEMORY_BLOCK_SIZE); + + WITH_RCU_READ_LOCK_GUARD() { + for (i = 0; i < DIRTY_MEMORY_NUM; i++) { + blocks[i] = atomic_rcu_read(&ram_list.dirty_memory[i])->blocks; + } + + for (k = 0; k < nr; k++) { + if (bitmap[k]) { + unsigned long temp = leul_to_cpu(bitmap[k]); + + atomic_or(&blocks[DIRTY_MEMORY_VGA][idx][offset], temp); + + if (global_dirty_log) { + atomic_or(&blocks[DIRTY_MEMORY_MIGRATION][idx][offset], + temp); + } + + if (tcg_enabled()) { + atomic_or(&blocks[DIRTY_MEMORY_CODE][idx][offset], + temp); + } + } + + if (++offset >= BITS_TO_LONGS(DIRTY_MEMORY_BLOCK_SIZE)) { + offset = 0; + idx++; + } + } + } + + xen_hvm_modified_memory(start, pages << TARGET_PAGE_BITS); + } else { + uint8_t clients = tcg_enabled() ? DIRTY_CLIENTS_ALL + : DIRTY_CLIENTS_NOCODE; + + if (!global_dirty_log) { + clients &= ~(1 << DIRTY_MEMORY_MIGRATION); + } + + /* + * bitmap-traveling is faster than memory-traveling (for addr...) + * especially when most of the memory is not dirty. + */ + for (i = 0; i < len; i++) { + if (bitmap[i] != 0) { + c = leul_to_cpu(bitmap[i]); + do { + j = ctzl(c); + c &= ~(1ul << j); + page_number = (i * HOST_LONG_BITS + j) * hpratio; + addr = page_number * TARGET_PAGE_SIZE; + ram_addr = start + addr; + cpu_physical_memory_set_dirty_range(ram_addr, + TARGET_PAGE_SIZE * hpratio, clients); + } while (c != 0); + } + } + } +} +#endif /* not _WIN32 */ + +bool cpu_physical_memory_test_and_clear_dirty(ram_addr_t start, + ram_addr_t length, + unsigned client); + +DirtyBitmapSnapshot *cpu_physical_memory_snapshot_and_clear_dirty( + MemoryRegion *mr, + hwaddr offset, + hwaddr length, + unsigned client); + +bool cpu_physical_memory_snapshot_get_dirty(DirtyBitmapSnapshot *snap, + ram_addr_t start, + ram_addr_t length); + +static inline void cpu_physical_memory_clear_dirty_range(ram_addr_t start, + ram_addr_t length) +{ + cpu_physical_memory_test_and_clear_dirty(start, length, + DIRTY_MEMORY_MIGRATION); + cpu_physical_memory_test_and_clear_dirty(start, length, DIRTY_MEMORY_VGA); + cpu_physical_memory_test_and_clear_dirty(start, length, DIRTY_MEMORY_CODE); +} + +#endif /* CONFIG_SOFTMMU */ #endif diff --git a/include/exec/ram_addr.h b/include/exec/ram_addr.h index 6acde47a0f..64bf28a332 100644 --- a/include/exec/ram_addr.h +++ b/include/exec/ram_addr.h @@ -21,310 +21,9 @@ #ifndef CONFIG_USER_ONLY #include "cpu.h" -#include "sysemu/xen.h" -#include "sysemu/tcg.h" #include "exec/ramlist.h" #include "exec/ramblock.h" - - - -#define DIRTY_CLIENTS_ALL ((1 << DIRTY_MEMORY_NUM) - 1) -#define DIRTY_CLIENTS_NOCODE (DIRTY_CLIENTS_ALL & ~(1 << DIRTY_MEMORY_CODE)) - -static inline bool cpu_physical_memory_get_dirty(ram_addr_t start, - ram_addr_t length, - unsigned client) -{ - DirtyMemoryBlocks *blocks; - unsigned long end, page; - unsigned long idx, offset, base; - bool dirty = false; - - assert(client < DIRTY_MEMORY_NUM); - - end = TARGET_PAGE_ALIGN(start + length) >> TARGET_PAGE_BITS; - page = start >> TARGET_PAGE_BITS; - - WITH_RCU_READ_LOCK_GUARD() { - blocks = atomic_rcu_read(&ram_list.dirty_memory[client]); - - idx = page / DIRTY_MEMORY_BLOCK_SIZE; - offset = page % DIRTY_MEMORY_BLOCK_SIZE; - base = page - offset; - while (page < end) { - unsigned long next = MIN(end, base + DIRTY_MEMORY_BLOCK_SIZE); - unsigned long num = next - base; - unsigned long found = find_next_bit(blocks->blocks[idx], - num, offset); - if (found < num) { - dirty = true; - break; - } - - page = next; - idx++; - offset = 0; - base += DIRTY_MEMORY_BLOCK_SIZE; - } - } - - return dirty; -} - -static inline bool cpu_physical_memory_all_dirty(ram_addr_t start, - ram_addr_t length, - unsigned client) -{ - DirtyMemoryBlocks *blocks; - unsigned long end, page; - unsigned long idx, offset, base; - bool dirty = true; - - assert(client < DIRTY_MEMORY_NUM); - - end = TARGET_PAGE_ALIGN(start + length) >> TARGET_PAGE_BITS; - page = start >> TARGET_PAGE_BITS; - - RCU_READ_LOCK_GUARD(); - - blocks = atomic_rcu_read(&ram_list.dirty_memory[client]); - - idx = page / DIRTY_MEMORY_BLOCK_SIZE; - offset = page % DIRTY_MEMORY_BLOCK_SIZE; - base = page - offset; - while (page < end) { - unsigned long next = MIN(end, base + DIRTY_MEMORY_BLOCK_SIZE); - unsigned long num = next - base; - unsigned long found = find_next_zero_bit(blocks->blocks[idx], - num, offset); - if (found < num) { - dirty = false; - break; - } - - page = next; - idx++; - offset = 0; - base += DIRTY_MEMORY_BLOCK_SIZE; - } - - return dirty; -} - -static inline bool cpu_physical_memory_get_dirty_flag(ram_addr_t addr, - unsigned client) -{ - return cpu_physical_memory_get_dirty(addr, 1, client); -} - -static inline bool cpu_physical_memory_is_clean(ram_addr_t addr) -{ - bool vga = cpu_physical_memory_get_dirty_flag(addr, DIRTY_MEMORY_VGA); - bool code = cpu_physical_memory_get_dirty_flag(addr, DIRTY_MEMORY_CODE); - bool migration = cpu_physical_memory_get_dirty_flag(addr, - DIRTY_MEMORY_MIGRATION); - return !(vga && code && migration); -} - -static inline uint8_t cpu_physical_memory_range_includes_clean(ram_addr_t start, - ram_addr_t length, - uint8_t mask) -{ - uint8_t ret = 0; - - if (mask & (1 << DIRTY_MEMORY_VGA) && - !cpu_physical_memory_all_dirty(start, length, DIRTY_MEMORY_VGA)) { - ret |= (1 << DIRTY_MEMORY_VGA); - } - if (mask & (1 << DIRTY_MEMORY_CODE) && - !cpu_physical_memory_all_dirty(start, length, DIRTY_MEMORY_CODE)) { - ret |= (1 << DIRTY_MEMORY_CODE); - } - if (mask & (1 << DIRTY_MEMORY_MIGRATION) && - !cpu_physical_memory_all_dirty(start, length, DIRTY_MEMORY_MIGRATION)) { - ret |= (1 << DIRTY_MEMORY_MIGRATION); - } - return ret; -} - -static inline void cpu_physical_memory_set_dirty_flag(ram_addr_t addr, - unsigned client) -{ - unsigned long page, idx, offset; - DirtyMemoryBlocks *blocks; - - assert(client < DIRTY_MEMORY_NUM); - - page = addr >> TARGET_PAGE_BITS; - idx = page / DIRTY_MEMORY_BLOCK_SIZE; - offset = page % DIRTY_MEMORY_BLOCK_SIZE; - - RCU_READ_LOCK_GUARD(); - - blocks = atomic_rcu_read(&ram_list.dirty_memory[client]); - - set_bit_atomic(offset, blocks->blocks[idx]); -} - -static inline void cpu_physical_memory_set_dirty_range(ram_addr_t start, - ram_addr_t length, - uint8_t mask) -{ - DirtyMemoryBlocks *blocks[DIRTY_MEMORY_NUM]; - unsigned long end, page; - unsigned long idx, offset, base; - int i; - - if (!mask && !xen_enabled()) { - return; - } - - end = TARGET_PAGE_ALIGN(start + length) >> TARGET_PAGE_BITS; - page = start >> TARGET_PAGE_BITS; - - WITH_RCU_READ_LOCK_GUARD() { - for (i = 0; i < DIRTY_MEMORY_NUM; i++) { - blocks[i] = atomic_rcu_read(&ram_list.dirty_memory[i]); - } - - idx = page / DIRTY_MEMORY_BLOCK_SIZE; - offset = page % DIRTY_MEMORY_BLOCK_SIZE; - base = page - offset; - while (page < end) { - unsigned long next = MIN(end, base + DIRTY_MEMORY_BLOCK_SIZE); - - if (likely(mask & (1 << DIRTY_MEMORY_MIGRATION))) { - bitmap_set_atomic(blocks[DIRTY_MEMORY_MIGRATION]->blocks[idx], - offset, next - page); - } - if (unlikely(mask & (1 << DIRTY_MEMORY_VGA))) { - bitmap_set_atomic(blocks[DIRTY_MEMORY_VGA]->blocks[idx], - offset, next - page); - } - if (unlikely(mask & (1 << DIRTY_MEMORY_CODE))) { - bitmap_set_atomic(blocks[DIRTY_MEMORY_CODE]->blocks[idx], - offset, next - page); - } - - page = next; - idx++; - offset = 0; - base += DIRTY_MEMORY_BLOCK_SIZE; - } - } - - xen_hvm_modified_memory(start, length); -} - -#if !defined(_WIN32) -static inline void cpu_physical_memory_set_dirty_lebitmap(unsigned long *bitmap, - ram_addr_t start, - ram_addr_t pages) -{ - unsigned long i, j; - unsigned long page_number, c; - hwaddr addr; - ram_addr_t ram_addr; - unsigned long len = (pages + HOST_LONG_BITS - 1) / HOST_LONG_BITS; - unsigned long hpratio = qemu_real_host_page_size / TARGET_PAGE_SIZE; - unsigned long page = BIT_WORD(start >> TARGET_PAGE_BITS); - - /* start address is aligned at the start of a word? */ - if ((((page * BITS_PER_LONG) << TARGET_PAGE_BITS) == start) && - (hpratio == 1)) { - unsigned long **blocks[DIRTY_MEMORY_NUM]; - unsigned long idx; - unsigned long offset; - long k; - long nr = BITS_TO_LONGS(pages); - - idx = (start >> TARGET_PAGE_BITS) / DIRTY_MEMORY_BLOCK_SIZE; - offset = BIT_WORD((start >> TARGET_PAGE_BITS) % - DIRTY_MEMORY_BLOCK_SIZE); - - WITH_RCU_READ_LOCK_GUARD() { - for (i = 0; i < DIRTY_MEMORY_NUM; i++) { - blocks[i] = atomic_rcu_read(&ram_list.dirty_memory[i])->blocks; - } - - for (k = 0; k < nr; k++) { - if (bitmap[k]) { - unsigned long temp = leul_to_cpu(bitmap[k]); - - atomic_or(&blocks[DIRTY_MEMORY_VGA][idx][offset], temp); - - if (global_dirty_log) { - atomic_or(&blocks[DIRTY_MEMORY_MIGRATION][idx][offset], - temp); - } - - if (tcg_enabled()) { - atomic_or(&blocks[DIRTY_MEMORY_CODE][idx][offset], - temp); - } - } - - if (++offset >= BITS_TO_LONGS(DIRTY_MEMORY_BLOCK_SIZE)) { - offset = 0; - idx++; - } - } - } - - xen_hvm_modified_memory(start, pages << TARGET_PAGE_BITS); - } else { - uint8_t clients = tcg_enabled() - ? DIRTY_CLIENTS_ALL : DIRTY_CLIENTS_NOCODE; - - if (!global_dirty_log) { - clients &= ~(1 << DIRTY_MEMORY_MIGRATION); - } - - /* - * bitmap-traveling is faster than memory-traveling (for addr...) - * especially when most of the memory is not dirty. - */ - for (i = 0; i < len; i++) { - if (bitmap[i] != 0) { - c = leul_to_cpu(bitmap[i]); - do { - j = ctzl(c); - c &= ~(1ul << j); - page_number = (i * HOST_LONG_BITS + j) * hpratio; - addr = page_number * TARGET_PAGE_SIZE; - ram_addr = start + addr; - cpu_physical_memory_set_dirty_range(ram_addr, - TARGET_PAGE_SIZE * hpratio, clients); - } while (c != 0); - } - } - } -} -#endif /* not _WIN32 */ - -bool cpu_physical_memory_test_and_clear_dirty(ram_addr_t start, - ram_addr_t length, - unsigned client); - -DirtyBitmapSnapshot *cpu_physical_memory_snapshot_and_clear_dirty( - MemoryRegion *mr, - hwaddr offset, - hwaddr length, - unsigned client); - -bool cpu_physical_memory_snapshot_get_dirty(DirtyBitmapSnapshot *snap, - ram_addr_t start, - ram_addr_t length); - -static inline void cpu_physical_memory_clear_dirty_range(ram_addr_t start, - ram_addr_t length) -{ - cpu_physical_memory_test_and_clear_dirty(start, length, - DIRTY_MEMORY_MIGRATION); - cpu_physical_memory_test_and_clear_dirty(start, length, DIRTY_MEMORY_VGA); - cpu_physical_memory_test_and_clear_dirty(start, length, DIRTY_MEMORY_CODE); -} - +#include "exec/memory-internal.h" /* Called with RCU critical section */ static inline diff --git a/accel/tcg/cputlb.c b/accel/tcg/cputlb.c index e3b5750c3b..922671f246 100644 --- a/accel/tcg/cputlb.c +++ b/accel/tcg/cputlb.c @@ -26,7 +26,6 @@ #include "exec/cpu_ldst.h" #include "exec/cputlb.h" #include "exec/memory-internal.h" -#include "exec/ram_addr.h" #include "tcg/tcg.h" #include "qemu/error-report.h" #include "exec/log.h" diff --git a/hw/ppc/spapr.c b/hw/ppc/spapr.c index c18eab0a23..d7c3bf3932 100644 --- a/hw/ppc/spapr.c +++ b/hw/ppc/spapr.c @@ -69,7 +69,6 @@ #include "hw/virtio/vhost-scsi-common.h" #include "exec/address-spaces.h" -#include "exec/ram_addr.h" #include "hw/usb.h" #include "qemu/config-file.h" #include "qemu/error-report.h" diff --git a/hw/ppc/spapr_pci.c b/hw/ppc/spapr_pci.c index 61b84a392d..8d9aeba6e6 100644 --- a/hw/ppc/spapr_pci.c +++ b/hw/ppc/spapr_pci.c @@ -36,7 +36,6 @@ #include "hw/ppc/spapr.h" #include "hw/pci-host/spapr.h" #include "exec/address-spaces.h" -#include "exec/ram_addr.h" #include <libfdt.h> #include "trace.h" #include "qemu/error-report.h" diff --git a/memory.c b/memory.c index e8e7bcd6c7..4e1d19c5fc 100644 --- a/memory.c +++ b/memory.c @@ -27,7 +27,6 @@ #include "trace-root.h" #include "exec/memory-internal.h" -#include "exec/ram_addr.h" #include "exec/ramblock.h" #include "sysemu/kvm.h" #include "sysemu/runstate.h"
Signed-off-by: Philippe Mathieu-Daudé <philmd@redhat.com> --- include/exec/memory-internal.h | 305 ++++++++++++++++++++++++++++++++- include/exec/ram_addr.h | 303 +------------------------------- accel/tcg/cputlb.c | 1 - hw/ppc/spapr.c | 1 - hw/ppc/spapr_pci.c | 1 - memory.c | 1 - 6 files changed, 305 insertions(+), 307 deletions(-)