Many improvements to HVF memory-related codes
PATCH v2 8/9 hvf: only consider directly writeable memory regions for dirty-tracking
In reply to Yan-Jie WangIt is no need to dirty-track MMIO regions or other readonly regions.
Before we start or stop to dirty-track a memory region, check the type of the memory region. The region must be a writeable ram to be dirty-tracked.
--- accel/hvf/hvf-mem.c | 5 +++++ 1 file changed, 5 insertions(+)
accel/hvf/hvf-mem.c +5 -0
@@ -180,6 +180,11 @@ static void hvf_set_dirty_tracking(MemoryRegionSection *section, bool on) {HVFSlot *slot; +if (!memory_region_is_ram (section->mr) ||memory_region_is_rom (section)) { +/* do not consider memory regions which are not directly writeable */ +return ; + } +qemu_mutex_lock (&memlock); slot = hvf_find_overlap_slot(
Signature · 1 line
2.32.0 (Apple Git-132)
PATCH v2 2/9 hvf: simplify data structures and codes of memory related functions
In reply to Yan-Jie Wang* Remove mac_slot and use hvf_slot only. The function of the two structures are similar.
* Refactor function hvf_set_phys_mem():
- Remove unnecessary checks because any modified memory sections will be removed first (region_del called first) before being added. Therefore, new sections do not overlap with existing sections.
- Try to align memory sections first before giving up sections that are not aligned to host page size.
--- accel/hvf/hvf-accel-ops.c | 1 - accel/hvf/hvf-mem.c | 211 +++++++++++++++++++------------------- include/sysemu/hvf_int.h | 8 +- 3 files changed, 107 insertions(+), 113 deletions(-)
accel/hvf/hvf-accel-ops.c +0 -1
@@ -49,7 +49,6 @@#include "qemu/osdep.h" #include "qemu/main-loop.h" -#include "exec/address-spaces.h" #include "exec/exec-all.h" #include "sysemu/cpus.h" #include "sysemu/hvf.h"
accel/hvf/hvf-mem.c +104 -107
258 lines not on this page · raw message
include/sysemu/hvf_int.h +3 -5
@@ -19,12 +19,12 @@/* hvf_slot flags */ #define HVF_SLOT_LOG (1 << 0) +#define HVF_SLOT_READONLY (1 << 1)typedef struct hvf_slot {uint64_t start; -uint64_t size; -uint8_t *mem; -int slot_id; +uint64_t size;/* 0 if the slot is free */ +uint64_t offset;/* offset within memory region */ uint32_t flags;MemoryRegion *region; }hvf_slot ;
@@ -40,8 +40,6 @@ typedef struct hvf_vcpu_caps {struct HVFState {AccelState parent; -hvf_slot slots[32 ]; -int num_slots;hvf_vcpu_caps *hvf_caps;uint64_t vtimer_offset;
Signature · 1 line
2.32.0 (Apple Git-132)
PATCH v2 4/9 hvf: rename struct hvf_slot to HVFSlot
In reply to Yan-Jie WangFollow the QEMU coding style. Structured type names are in CamelCase.
--- accel/hvf/hvf-mem.c | 14 +++++++------- include/sysemu/hvf_int.h | 8 ++++---- target/i386/hvf/hvf.c | 4 ++-- 3 files changed, 13 insertions(+), 13 deletions(-)
accel/hvf/hvf-mem.c +7 -7
@@ -30,11 +30,11 @@#define HVF_NUM_SLOTS 32 -static hvf_slot memslots[HVF_NUM_SLOTS ]; +static HVFSlot memslots[HVF_NUM_SLOTS ]; -hvf_slot *hvf_find_overlap_slot (hwaddr start,hwaddr size) +HVFSlot *hvf_find_overlap_slot (hwaddr start,hwaddr size) { -hvf_slot *slot; +HVFSlot *slot;int x;for (x =0 ; x <HVF_NUM_SLOTS ; ++x) { slot = &memslots[x];
@@ -46,9 +46,9 @@ hvf_slot *hvf_find_overlap_slot(hwaddr start, hwaddr size)return NULL ; } -static hvf_slot *hvf_find_free_slot (void ) +static HVFSlot *hvf_find_free_slot (void ) { -hvf_slot *slot; +HVFSlot *slot;int x;for (x =0 ; x <HVF_NUM_SLOTS ; x++) { slot = &memslots[x];
@@ -91,7 +91,7 @@ static hwaddr hvf_align_section(MemoryRegionSection *section,static void hvf_set_phys_mem (MemoryRegionSection *section,bool add) { -hvf_slot *slot; +HVFSlot *slot;hwaddr start, size, offset, delta;uint8_t *host_addr;MemoryRegion *area = section->mr;
@@ -172,7 +172,7 @@ static void hvf_set_phys_mem(MemoryRegionSection *section, bool add)static void hvf_set_dirty_tracking (MemoryRegionSection *section,bool on) { -hvf_slot *slot; +HVFSlot *slot; slot = hvf_find_overlap_slot( section->offset_within_address_space,
include/sysemu/hvf_int.h +4 -4
@@ -17,17 +17,17 @@#include <Hypervisor/hv.h> #endif -/* hvf_slot flags */ +/* HVFSlot flags */ #define HVF_SLOT_LOG (1 << 0)#define HVF_SLOT_READONLY (1 << 1) -typedef struct hvf_slot { +typedef struct HVFSlot {hwaddr start;hwaddr size;/* 0 if the slot is free */ hwaddr offset;/* offset within memory region */ uint32_t flags;MemoryRegion *region; -}hvf_slot ; +}HVFSlot ; typedef struct hvf_vcpu_caps { uint64_t vmx_cap_pinbased;
@@ -58,7 +58,7 @@ int hvf_arch_init(void);int hvf_arch_init_vcpu (CPUState *cpu);void hvf_arch_vcpu_destroy (CPUState *cpu);int hvf_vcpu_exec (CPUState *); -hvf_slot *hvf_find_overlap_slot (hwaddr ,hwaddr ); +HVFSlot *hvf_find_overlap_slot (hwaddr ,hwaddr );int hvf_put_registers (CPUState *);int hvf_get_registers (CPUState *);void hvf_kick_vcpu_thread (CPUState *cpu);
target/i386/hvf/hvf.c +2 -2
@@ -113,7 +113,7 @@ void hvf_handle_io(CPUArchState *env, uint16_t port, void *buffer, } } -static bool ept_emulation_fault (hvf_slot *slot,uint64_t gpa,uint64_t ept_qual) +static bool ept_emulation_fault (HVFSlot *slot,uint64_t gpa,uint64_t ept_qual) {int read, write;
@@ -469,7 +469,7 @@ int hvf_vcpu_exec(CPUState *cpu)/* Need to check if MMIO or unmapped fault */ case EXIT_REASON_EPT_FAULT : { -hvf_slot *slot; +HVFSlot *slot;uint64_t gpa =rvmcs (cpu->hvf->fd,VMCS_GUEST_PHYSICAL_ADDRESS ); if (((idtvec_info & VMCS_IDT_VEC_VALID) == 0) &&
Signature · 1 line
2.32.0 (Apple Git-132)
PATCH v2 6/9 hvf: add a lock for memory related functions
In reply to Yan-Jie WangWe follow how KVM accel does in its memory listener (kvm-all.c) and add a lock for the memory related functions.
--- accel/hvf/hvf-mem.c | 18 ++++++++++++++++++ 1 file changed, 18 insertions(+)
accel/hvf/hvf-mem.c +18 -0
@@ -43,6 +43,7 @@ typedef struct HVFSlot { } HVFSlot;static HVFSlot memslots[HVF_NUM_SLOTS ]; +static QemuMutex memlock;static HVFSlot *hvf_find_overlap_slot (hwaddr start,hwaddr size) {
@@ -140,6 +141,8 @@ static void hvf_set_phys_mem(MemoryRegionSection *section, bool add) readonly =memory_region_is_rom (area) ||memory_region_is_romd (area);/* setup a slot */ +qemu_mutex_lock (&memlock); + slot =hvf_find_free_slot ();if (!slot) {error_report ("No free slots" );
@@ -169,8 +172,12 @@ static void hvf_set_phys_mem(MemoryRegionSection *section, bool add) ret =hv_vm_map (host_addr, start, size, flags);assert_hvf_ok (ret); + +qemu_mutex_unlock (&memlock); }else {/* remove memory region */ +qemu_mutex_lock (&memlock); + slot =hvf_find_overlap_slot (start, size);if (slot) {
@@ -179,6 +186,8 @@ static void hvf_set_phys_mem(MemoryRegionSection *section, bool add) slot->size =0 ; } + +qemu_mutex_unlock (&memlock); } }
@@ -186,6 +195,8 @@ static void hvf_set_dirty_tracking(MemoryRegionSection *section, bool on) {HVFSlot *slot; +qemu_mutex_lock (&memlock); + slot =hvf_find_overlap_slot ( section->offset_within_address_space,int128_get64 (section->size));
@@ -201,6 +212,8 @@ static void hvf_set_dirty_tracking(MemoryRegionSection *section, bool on)hv_vm_protect ((uintptr_t )slot->start, (size_t )slot->size,HV_MEMORY_READ |HV_MEMORY_WRITE |HV_MEMORY_EXEC ); } + +qemu_mutex_unlock (&memlock); } static void hvf_log_start(MemoryListener *listener,
@@ -271,10 +284,13 @@ bool hvf_access_memory(hwaddr address, bool write)hv_return_t ret;hwaddr start, size; +qemu_mutex_lock (&memlock); + slot =hvf_find_overlap_slot (address,1 );if (!slot || (write && slot->flags &HVF_SLOT_READONLY )) {/* MMIO or unmapped area, return false */ +qemu_mutex_unlock (&memlock);return false; }
@@ -290,10 +306,12 @@ bool hvf_access_memory(hwaddr address, bool write)assert_hvf_ok (ret); } +qemu_mutex_unlock (&memlock);return true; }void hvf_init_memslots (void ) { +qemu_mutex_init (&memlock);memory_listener_register (&hvf_memory_listener, &address_space_memory); }
Signature · 1 line
2.32.0 (Apple Git-132)
PATCH v2 7/9 hvf: use GTree to store memory slots instead of fixed-size array
In reply to Yan-Jie WangCurrently, there are only 32 memory slots in the fixed size array. It is not scalable. Instead of using fixed size array, use GTree (from glib library) and dynamically-allocated structures to store memory slots.
--- accel/hvf/hvf-mem.c | 63 +++++++++++++++++++++++---------------------- 1 file changed, 32 insertions(+), 31 deletions(-)
accel/hvf/hvf-mem.c +32 -31
@@ -28,8 +28,6 @@/* Memory slots */ -#define HVF_NUM_SLOTS 32 -/* HVFSlot flags */ #define HVF_SLOT_LOG (1 << 0)#define HVF_SLOT_READONLY (1 << 1)
@@ -42,35 +40,24 @@ typedef struct HVFSlot {MemoryRegion *region; } HVFSlot; -static HVFSlot memslots[HVF_NUM_SLOTS ]; +static GTree *memslots;static QemuMutex memlock;static HVFSlot *hvf_find_overlap_slot (hwaddr start,hwaddr size) { -HVFSlot *slot; -int x; -for (x =0 ; x <HVF_NUM_SLOTS ; ++x) { - slot = &memslots[x]; -if (slot->size && start < (slot->start + slot->size) && - (start + size) > slot->start) { -return slot; - } - } -return NULL ; +HVFSlot key = {.start = start, .size =1 }; +return g_tree_lookup (memslots, &key); } -static HVFSlot *hvf_find_free_slot (void ) +static void hvf_insert_slot (HVFSlot *slot) { -HVFSlot *slot; -int x; -for (x =0 ; x <HVF_NUM_SLOTS ; x++) { - slot = &memslots[x]; -if (!slot->size) { -return slot; - } - } +g_tree_insert (memslots, slot, slot); +} -return NULL ; +static bool hvf_remove_slot (hwaddr start) +{ +HVFSlot key = {.start = start, .size =1 }; +return g_tree_remove (memslots, &key); }/*
@@ -141,9 +128,7 @@ static void hvf_set_phys_mem(MemoryRegionSection *section, bool add) readonly =memory_region_is_rom (area) ||memory_region_is_romd (area);/* setup a slot */ -qemu_mutex_lock (&memlock); - - slot =hvf_find_free_slot (); + slot =g_new0 (HVFSlot,1 );if (!slot) {error_report ("No free slots" );abort ();
@@ -170,6 +155,10 @@ static void hvf_set_phys_mem(MemoryRegionSection *section, bool add) flags =HV_MEMORY_READ |HV_MEMORY_WRITE |HV_MEMORY_EXEC ; } +qemu_mutex_lock (&memlock); + +hvf_insert_slot (slot); + ret =hv_vm_map (host_addr, start, size, flags);assert_hvf_ok (ret);
@@ -178,13 +167,9 @@ static void hvf_set_phys_mem(MemoryRegionSection *section, bool add)/* remove memory region */ qemu_mutex_lock (&memlock); - slot =hvf_find_overlap_slot (start, size); - -if (slot) { +if (hvf_remove_slot (start)) { ret =hv_vm_unmap (start, size);assert_hvf_ok (ret); - - slot->size =0 ; }qemu_mutex_unlock (&memlock);
@@ -310,8 +295,24 @@ bool hvf_access_memory(hwaddr address, bool write)return true; } +/* compare function for GTree */ +static gint _hvf_slot_compare (gconstpointer a,gconstpointer b,gpointer data) +{ +const HVFSlot *m1 = (const HVFSlot *)a; +const HVFSlot *m2 = (const HVFSlot *)b; + +if (m2->start >= m1->start + m1->size) { +return -1 ; + }else if (m1->start >= m2->start + m2->size) { +return 1 ; + } + +return 0 ; +} +void hvf_init_memslots (void ) {qemu_mutex_init (&memlock); + memslots =g_tree_new_full (_hvf_slot_compare,NULL , g_free,NULL );memory_listener_register (&hvf_memory_listener, &address_space_memory); }
Signature · 1 line
2.32.0 (Apple Git-132)
PATCH v2 1/9 hvf: move memory related functions from hvf-accel-ops.c to hvf-mem.c
In reply to Yan-Jie Wang--- accel/hvf/hvf-accel-ops.c | 220 +-------------------------------- accel/hvf/hvf-mem.c | 252 ++++++++++++++++++++++++++++++++++++++ accel/hvf/meson.build | 1 + include/sysemu/hvf_int.h | 2 + 4 files changed, 256 insertions(+), 219 deletions(-) create mode 100644 accel/hvf/hvf-mem.c
accel/hvf/hvf-accel-ops.c +1 -219
@@ -48,7 +48,6 @@*/ #include "qemu/osdep.h" -#include "qemu/error-report.h" #include "qemu/main-loop.h" #include "exec/address-spaces.h" #include "exec/exec-all.h"
@@ -64,143 +63,6 @@ HVFState *hvf_state;#define HV_VM_DEFAULT NULL#endif -/* Memory slots */ - -hvf_slot *hvf_find_overlap_slot (uint64_t start,uint64_t size) -{ -hvf_slot *slot; -int x; -for (x =0 ; x < hvf_state->num_slots; ++x) { - slot = &hvf_state->slots[x]; -if (slot->size && start < (slot->start + slot->size) && - (start + size) > slot->start) { -return slot; - } - } -return NULL ; -} - -struct mac_slot { -int present; -uint64_t size; -uint64_t gpa_start; -uint64_t gva; -}; - -struct mac_slot mac_slots[32 ]; - -static int do_hvf_set_memory (hvf_slot *slot,hv_memory_flags_t flags) -{ -struct mac_slot *macslot; -hv_return_t ret; - - macslot = &mac_slots[slot->slot_id]; - -if (macslot->present) { -if (macslot->size != slot->size) { - macslot->present =0 ; - ret =hv_vm_unmap (macslot->gpa_start, macslot->size); -assert_hvf_ok (ret); - } - } - -if (!slot->size) { -return 0 ; - } - - macslot->present =1 ; - macslot->gpa_start = slot->start; - macslot->size = slot->size; - ret =hv_vm_map (slot->mem, slot->start, slot->size, flags); -assert_hvf_ok (ret); -return 0 ; -} - -static void hvf_set_phys_mem (MemoryRegionSection *section,bool add) -{ -hvf_slot *mem; -MemoryRegion *area = section->mr; -bool writeable = !area->readonly && !area->rom_device; -hv_memory_flags_t flags; -uint64_t page_size = qemu_real_host_page_size; - -if (!memory_region_is_ram (area)) { -if (writeable) { -return ; - }else if (!memory_region_is_romd (area)) { -/* -* If the memory device is not in romd_mode, then we actually want -* to remove the hvf memory slot so all accesses will trap. -*/ - add = false; - } - } - -if (!QEMU_IS_ALIGNED (int128_get64 (section->size), page_size) || - !QEMU_IS_ALIGNED (section->offset_within_address_space, page_size)) { -/* Not page aligned, so we can not map as RAM */ - add = false; - } - - mem =hvf_find_overlap_slot ( - section->offset_within_address_space, -int128_get64 (section->size)); - -if (mem && add) { -if (mem->size ==int128_get64 (section->size) && - mem->start == section->offset_within_address_space && - mem->mem == (memory_region_get_ram_ptr (area) + - section->offset_within_region)) { -return ;/* Same region was attempted to register, go away. */ - } - } - -/* Region needs to be reset. set the size to 0 and remap it. */ -if (mem) { - mem->size =0 ; -if (do_hvf_set_memory (mem,0 )) { -error_report ("Failed to reset overlapping slot" ); -abort (); - } - } - -if (!add) { -return ; - } - -if (area->readonly || - (!memory_region_is_ram (area) &&memory_region_is_romd (area))) { - flags =HV_MEMORY_READ |HV_MEMORY_EXEC ; - }else { - flags =HV_MEMORY_READ |HV_MEMORY_WRITE |HV_MEMORY_EXEC ; - } - -/* Now make a new slot. */ -int x; - -for (x =0 ; x < hvf_state->num_slots; ++x) { - mem = &hvf_state->slots[x]; -if (!mem->size) { -break ; - } - } - -if (x == hvf_state->num_slots) { -error_report ("No free slots" ); -abort (); - } - - mem->size =int128_get64 (section->size); - mem->mem =memory_region_get_ram_ptr (area) + section->offset_within_region; - mem->start = section->offset_within_address_space; - mem->region = area; - -if (do_hvf_set_memory (mem, flags)) { -error_report ("Error registering new memory slot" ); -abort (); - } -} -static void do_hvf_cpu_synchronize_state (CPUState *cpu,run_on_cpu_data arg) {if (!cpu->vcpu_dirty) {
@@ -238,79 +100,6 @@ static void hvf_cpu_synchronize_pre_loadvm(CPUState *cpu)run_on_cpu (cpu, do_hvf_cpu_synchronize_set_dirty,RUN_ON_CPU_NULL ); } -static void hvf_set_dirty_tracking (MemoryRegionSection *section,bool on) -{ -hvf_slot *slot; - - slot =hvf_find_overlap_slot ( - section->offset_within_address_space, -int128_get64 (section->size)); - -/* protect region against writes; begin tracking it */ -if (on) { - slot->flags |=HVF_SLOT_LOG ; -hv_vm_protect ((uintptr_t )slot->start, (size_t )slot->size, -HV_MEMORY_READ |HV_MEMORY_EXEC ); -/* stop tracking region*/ - }else { - slot->flags &= ~HVF_SLOT_LOG ; -hv_vm_protect ((uintptr_t )slot->start, (size_t )slot->size, -HV_MEMORY_READ |HV_MEMORY_WRITE |HV_MEMORY_EXEC ); - } -} - -static void hvf_log_start (MemoryListener *listener, -MemoryRegionSection *section,int old,int new) -{ -if (old !=0 ) { -return ; - } - -hvf_set_dirty_tracking (section,1 ); -} - -static void hvf_log_stop (MemoryListener *listener, -MemoryRegionSection *section,int old,int new) -{ -if (new !=0 ) { -return ; - } - -hvf_set_dirty_tracking (section,0 ); -} - -static void hvf_log_sync (MemoryListener *listener, -MemoryRegionSection *section) -{ -/* -* sync of dirty pages is handled elsewhere; just make sure we keep -* tracking the region. -*/ -hvf_set_dirty_tracking (section,1 ); -} - -static void hvf_region_add (MemoryListener *listener, -MemoryRegionSection *section) -{ -hvf_set_phys_mem (section, true); -} - -static void hvf_region_del (MemoryListener *listener, -MemoryRegionSection *section) -{ -hvf_set_phys_mem (section, false); -} - -static MemoryListener hvf_memory_listener = { - .name ="hvf" , - .priority =10 , - .region_add = hvf_region_add, - .region_del = hvf_region_del, - .log_start = hvf_log_start, - .log_stop = hvf_log_stop, - .log_sync = hvf_log_sync, -}; -static void dummy_signal (int sig) { }
@@ -319,7 +108,6 @@ bool hvf_allowed;static int hvf_accel_init (MachineState *ms) { -int x;hv_return_t ret;HVFState *s;
@@ -328,14 +116,8 @@ static int hvf_accel_init(MachineState *ms) s =g_new0 (HVFState,1 ); - s->num_slots =ARRAY_SIZE (s->slots); -for (x =0 ; x < s->num_slots; ++x) { - s->slots[x].size =0 ; - s->slots[x].slot_id = x; - } - hvf_state = s; -memory_listener_register (&hvf_memory_listener, &address_space_memory); +hvf_init_memslots ();return hvf_arch_init (); }
accel/hvf/hvf-mem.c new file +252 -0
252 lines not on this page · raw message
accel/hvf/meson.build +1 -0
@@ -2,6 +2,7 @@ hvf_ss = ss.source_set() hvf_ss.add(files( 'hvf-all.c', 'hvf-accel-ops.c', + 'hvf-mem.c', )) specific_ss.add_all(when: 'CONFIG_HVF', if_true: hvf_ss)
include/sysemu/hvf_int.h +2 -0
@@ -65,4 +65,6 @@ int hvf_put_registers(CPUState *);int hvf_get_registers (CPUState *);void hvf_kick_vcpu_thread (CPUState *cpu); +void hvf_init_memslots (void ); +#endif
Signature · 1 line
2.32.0 (Apple Git-132)
PATCH v2 3/9 hvf: use correct data types for addresses in memory related functions
In reply to Yan-Jie WangFollow the QEMU coding style. Use hwaddr for guest physical address.
--- accel/hvf/hvf-mem.c | 2 +- include/sysemu/hvf_int.h | 8 ++++---- 2 files changed, 5 insertions(+), 5 deletions(-)
accel/hvf/hvf-mem.c +1 -1
@@ -32,7 +32,7 @@static hvf_slot memslots[HVF_NUM_SLOTS ]; -hvf_slot *hvf_find_overlap_slot (uint64_t start,uint64_t size) +hvf_slot *hvf_find_overlap_slot (hwaddr start,hwaddr size) {hvf_slot *slot;int x;
include/sysemu/hvf_int.h +4 -4
@@ -22,9 +22,9 @@#define HVF_SLOT_READONLY (1 << 1)typedef struct hvf_slot { -uint64_t start; -uint64_t size;/* 0 if the slot is free */ -uint64_t offset;/* offset within memory region */ +hwaddr start; +hwaddr size;/* 0 if the slot is free */ +hwaddr offset;/* offset within memory region */ uint32_t flags;MemoryRegion *region; }hvf_slot ;
@@ -58,7 +58,7 @@ int hvf_arch_init(void);int hvf_arch_init_vcpu (CPUState *cpu);void hvf_arch_vcpu_destroy (CPUState *cpu);int hvf_vcpu_exec (CPUState *); -hvf_slot *hvf_find_overlap_slot (uint64_t ,uint64_t ); +hvf_slot *hvf_find_overlap_slot (hwaddr ,hwaddr );int hvf_put_registers (CPUState *);int hvf_get_registers (CPUState *);void hvf_kick_vcpu_thread (CPUState *cpu);
Signature · 1 line
2.32.0 (Apple Git-132)
v2 cover Many improvements to HVF memory-related codes
changes in v2:
* Rebase to the current master.
* Correct a mistake in "hvf: simplify data structures and codes of memory related functions" patch
* add two patches for HVF memory listener. The changes are
- only consider directly writeable memory regions for dirty-tracking
- in hvf_log_clear, use provided section (MemoryRegionSection) from the caller to determine the pages that need to write-protected instead of calling hvf_set_dirty_tracking to write-protect the memory slots that contains the pages whose dirty-bits are cleared.
----------
I recently bought a Mac with M1 Pro chip, and use QEMU to setup a Linux virtual machine. QEMU crashed when I started a VM with HVF accelerator enabled and with the device, bochs-display, added.
After digging into the source code, I found that dirty-tracking in HVF did not work properly, which made QEMU crashed. Therefore I made this series of patches to fix the problem.
Followings are the summary of the changes that these patches make:
1. Move HVF memory-related functions and codes into a new file hvf-mem.c
2. Simplify the logics of adding and removing memory regions in HVF memory listener
3. Fix HVF dirty-tracking logics for both Intel and Apple Silicon Macs
4. Use GTree and dynamically-allocated structures to store HVF memory slots instead of fixed-size arrays. This makes memory slots more scalable. It is inspired by the recent changes in Linux kernel (v5.17) that use red-black trees instead of arrays to store in-kernel KVM memory slots.
5. Add a lock to protect the data structures of HVF memory slots
Patches have been tested on Apple Silicon Macs and Intel Macs.
Yan-Jie Wang (9):
hvf: move memory related functions from hvf-accel-ops.c to hvf-mem.c
hvf: simplify data structures and codes of memory related functions
hvf: use correct data types for addresses in memory related functions
hvf: rename struct hvf_slot to HVFSlot
hvf: fix memory dirty-tracking
hvf: add a lock for memory related functions
hvf: use GTree to store memory slots instead of fixed-size array
hvf: only consider directly writeable memory regions for
dirty-tracking
hvf: remove the need to lookup memory slots when clearing dirty-bits
accel/hvf/hvf-accel-ops.c | 221 +------------------------ accel/hvf/hvf-mem.c | 336 ++++++++++++++++++++++++++++++++++++++ accel/hvf/meson.build | 1 + include/sysemu/hvf_int.h | 18 +- target/arm/hvf/hvf.c | 5 + target/i386/hvf/hvf.c | 25 +-- 6 files changed, 352 insertions(+), 254 deletions(-) create mode 100644 accel/hvf/hvf-mem.c
Signature · 1 line
2.32.0 (Apple Git-132)
PATCH v2 9/9 hvf: remove the need to lookup memory slots when clearing dirty-bits
Originally, when log_clear gets called, log_clear calls hvf_set_dirty_tracking to write-protect memory slots whose dirty-bits are cleared.
Calling hvf_set_dirty_tracking means that memory slots will be look up and the lock for memory slots will be held during the call.
We can use the parameter section passed by the caller to determine the pages that need to be write-protected. Compared to the original method, this saves time.
Moreover, this makes only pages whose dirty-bits
are cleared write-protected instead of making the whole memory slot write-protected.
--- accel/hvf/hvf-mem.c | 17 +++++++++++++++-- 1 file changed, 15 insertions(+), 2 deletions(-)
accel/hvf/hvf-mem.c +15 -2
@@ -84,7 +84,10 @@ static hwaddr hvf_align_section(MemoryRegionSection *section, size = (size - _delta) & qemu_real_host_page_mask; *start = _start; - *delta = _delta; + +if (delta) { + *delta = _delta; + }return size; }
@@ -229,11 +232,21 @@ static void hvf_log_stop(MemoryListener *listener,static void hvf_log_clear (MemoryListener *listener,MemoryRegionSection *section) { +hwaddr start, size; + +if (!memory_region_is_ram (section->mr) ||memory_region_is_rom (section)) { +/* do not consider memory regions which are not directly writeable */ +return ; + } +/* * The dirty bits are being cleared. * Make the section write-protected again. */ -hvf_set_dirty_tracking (section,1 ); + size =hvf_align_section (section, &start,NULL ); +if (size) { +hv_vm_protect (start, size,HV_MEMORY_READ |HV_MEMORY_EXEC ); + } } static void hvf_region_add(MemoryListener *listener,
Signature · 1 line
2.32.0 (Apple Git-132)
PATCH v2 5/9 hvf: fix memory dirty-tracking
In reply to Yan-Jie WangDirty-tracking in HVF is not properly implemented.
On Intel Macs, Ubuntu ISO boot menu does not show properly.
On Apple Silicon, using bochs-display may cause the guest crashes because the guest may uses load/store instructions on framebuffer which causes vmexits and the exception register does not contain enough information (ESR_EL2.ISV = 0) for QEMU to emulate the memory operation.
The strategy to log the dirty pages is to write-protect the memory regions that are being dirty-tracked.
When the guest is trapped to the host because of memory write, check whether the address being written is being dirty-tracked.
If it is being dirty-tracked, restore the write permission of the page and mark the accessed page dirty, and resume the guest without increasing program counter, and then the same instruction will be execute again.
This patch fixes the problem and make the dirty-tracking work properly.
--- accel/hvf/hvf-mem.c | 62 ++++++++++++++++++++++++++++++++++++---- include/sysemu/hvf_int.h | 14 +-------- target/arm/hvf/hvf.c | 5 ++++ target/i386/hvf/hvf.c | 25 ++++------------ 4 files changed, 68 insertions(+), 38 deletions(-)
accel/hvf/hvf-mem.c +56 -6
@@ -30,9 +30,21 @@#define HVF_NUM_SLOTS 32 +/* HVFSlot flags */ +#define HVF_SLOT_LOG (1 << 0) +#define HVF_SLOT_READONLY (1 << 1) + +typedef struct HVFSlot { +hwaddr start; +hwaddr size;/* 0 if the slot is free */ +hwaddr offset;/* offset within memory region */ +uint32_t flags; +MemoryRegion *region; +}HVFSlot ; +static HVFSlot memslots[HVF_NUM_SLOTS ]; -HVFSlot *hvf_find_overlap_slot (hwaddr start,hwaddr size) +static HVFSlot *hvf_find_overlap_slot (hwaddr start,hwaddr size) {HVFSlot *slot;int x;
@@ -194,7 +206,7 @@ static void hvf_set_dirty_tracking(MemoryRegionSection *section, bool on)static void hvf_log_start (MemoryListener *listener,MemoryRegionSection *section,int old,int new) { -if (old !=0 ) { +if (old == new) {return ; }
@@ -211,12 +223,12 @@ static void hvf_log_stop(MemoryListener *listener,hvf_set_dirty_tracking (section,0 ); } -static void hvf_log_sync (MemoryListener *listener, +static void hvf_log_clear (MemoryListener *listener,MemoryRegionSection *section) {/* -* sync of dirty pages is handled elsewhere; just make sure we keep -* tracking the region. +* The dirty bits are being cleared. +* Make the section write-protected again. */ hvf_set_dirty_tracking (section,1 ); }
@@ -240,9 +252,47 @@ static MemoryListener hvf_memory_listener = { .region_del = hvf_region_del, .log_start = hvf_log_start, .log_stop = hvf_log_stop, - .log_sync = hvf_log_sync, + .log_clear = hvf_log_clear, }; + +/* +* The function is called when the guest is accessing memory causing vmexit. +* Check whether the guest can access the memory directly and +* also mark the accessed page being written dirty +* if the page is being dirty-tracked. +* +* Return true if the access is within the mapped region, +* otherwise return false. +*/ +bool hvf_access_memory (hwaddr address,bool write) +{ +HVFSlot *slot; +hv_return_t ret; +hwaddr start, size; + + slot =hvf_find_overlap_slot (address,1 ); + +if (!slot || (write && slot->flags &HVF_SLOT_READONLY )) { +/* MMIO or unmapped area, return false */ +return false; + } + +if (write && (slot->flags &HVF_SLOT_LOG )) { +/* The slot is being dirty-tracked. Mark the accessed page dirty. */ + start = address & qemu_real_host_page_mask; + size = qemu_real_host_page_size; + +memory_region_set_dirty (slot->region, + start - slot->start + slot->offset, size); + ret =hv_vm_protect (start, size, +HV_MEMORY_READ |HV_MEMORY_WRITE |HV_MEMORY_EXEC ); +assert_hvf_ok (ret); + } + +return true; +} +void hvf_init_memslots (void ) {memory_listener_register (&hvf_memory_listener, &address_space_memory);
include/sysemu/hvf_int.h +1 -13
@@ -17,18 +17,6 @@#include <Hypervisor/hv.h> #endif -/* HVFSlot flags */ -#define HVF_SLOT_LOG (1 << 0) -#define HVF_SLOT_READONLY (1 << 1) - -typedef struct HVFSlot { -hwaddr start; -hwaddr size;/* 0 if the slot is free */ -hwaddr offset;/* offset within memory region */ -uint32_t flags; -MemoryRegion *region; -}HVFSlot ; - typedef struct hvf_vcpu_caps { uint64_t vmx_cap_pinbased; uint64_t vmx_cap_procbased;
@@ -58,11 +46,11 @@ int hvf_arch_init(void);int hvf_arch_init_vcpu (CPUState *cpu);void hvf_arch_vcpu_destroy (CPUState *cpu);int hvf_vcpu_exec (CPUState *); -HVFSlot *hvf_find_overlap_slot (hwaddr ,hwaddr );int hvf_put_registers (CPUState *);int hvf_get_registers (CPUState *);void hvf_kick_vcpu_thread (CPUState *cpu); +bool hvf_access_memory (hwaddr address,bool write);void hvf_init_memslots (void );#endif
target/arm/hvf/hvf.c +5 -0
@@ -1202,6 +1202,11 @@ int hvf_vcpu_exec(CPUState *cpu)break ; } +if (iswrite && +hvf_access_memory (hvf_exit->exception.physical_address,1 )) { +break ; + } +assert (isv);if (iswrite) {
target/i386/hvf/hvf.c +6 -19
@@ -113,7 +113,7 @@ void hvf_handle_io(CPUArchState *env, uint16_t port, void *buffer, } } -static bool ept_emulation_fault (HVFSlot *slot,uint64_t gpa,uint64_t ept_qual) +static bool ept_emulation_fault (uint64_t gpa,uint64_t ept_qual) {int read, write;
@@ -129,14 +129,6 @@ static bool ept_emulation_fault(HVFSlot *slot, uint64_t gpa, uint64_t ept_qual)return false; } -if (write && slot) { -if (slot->flags &HVF_SLOT_LOG ) { -memory_region_set_dirty (slot->region, gpa - slot->start,1 ); -hv_vm_protect ((hv_gpaddr_t )slot->start, (size_t )slot->size, -HV_MEMORY_READ |HV_MEMORY_WRITE ); - } - } -/* * The EPT violation must have been caused by accessing a * guest-physical address that is a translation of a guest-linear
@@ -147,14 +139,11 @@ static bool ept_emulation_fault(HVFSlot *slot, uint64_t gpa, uint64_t ept_qual)return false; } -if (!slot) { -return true; +if (hvf_access_memory (gpa, write)) { +return false; } -if (!memory_region_is_ram (slot->region) && - !(read &&memory_region_is_romd (slot->region))) { -return true; - } -return false; + +return true; }void hvf_arch_vcpu_destroy (CPUState *cpu)
@@ -469,7 +458,6 @@ int hvf_vcpu_exec(CPUState *cpu)/* Need to check if MMIO or unmapped fault */ case EXIT_REASON_EPT_FAULT : { -HVFSlot *slot;uint64_t gpa =rvmcs (cpu->hvf->fd,VMCS_GUEST_PHYSICAL_ADDRESS ); if (((idtvec_info & VMCS_IDT_VEC_VALID) == 0) &&
@@ -477,9 +465,8 @@ int hvf_vcpu_exec(CPUState *cpu)vmx_set_nmi_blocking (cpu); } - slot =hvf_find_overlap_slot (gpa,1 );/* mmio */ -if (ept_emulation_fault (slot, gpa, exit_qual)) { +if (ept_emulation_fault (gpa, exit_qual)) {struct x86_decode decode;load_regs (cpu);
Signature · 1 line
2.32.0 (Apple Git-132)