| Message ID | 20230930001933.2660-9-salil.mehta@huawei.com (mailing list archive) |
|---|---|
| State | New, archived |
| Headers | show |
| Series | Add architecture agnostic code to support vCPU Hotplug | expand |
On Sat, 30 Sep 2023 01:19:31 +0100 Salil Mehta <salil.mehta@huawei.com> wrote: > Virtual CPU Hot-unplug leads to unrealization of a CPU object. This also > involves destruction of the CPU AddressSpace. Add common function to help > destroy the CPU AddressSpace. > > Signed-off-by: Salil Mehta <salil.mehta@huawei.com> I'm not that familiar with this bit of the code, so no tag, but as far as I can tell from a fairly superficial look, this is good. > --- > include/exec/cpu-common.h | 8 ++++++++ > include/hw/core/cpu.h | 1 + > softmmu/physmem.c | 25 +++++++++++++++++++++++++ > 3 files changed, 34 insertions(+) > > diff --git a/include/exec/cpu-common.h b/include/exec/cpu-common.h > index 41788c0bdd..eb56a228a2 100644 > --- a/include/exec/cpu-common.h > +++ b/include/exec/cpu-common.h > @@ -120,6 +120,14 @@ size_t qemu_ram_pagesize_largest(void); > */ > void cpu_address_space_init(CPUState *cpu, int asidx, > const char *prefix, MemoryRegion *mr); > +/** > + * cpu_address_space_destroy: > + * @cpu: CPU for which address space needs to be destroyed > + * @asidx: integer index of this address space > + * > + * Note that with KVM only one address space is supported. > + */ > +void cpu_address_space_destroy(CPUState *cpu, int asidx); > > void cpu_physical_memory_rw(hwaddr addr, void *buf, > hwaddr len, bool is_write); > diff --git a/include/hw/core/cpu.h b/include/hw/core/cpu.h > index 648b5b3586..65d2ae4581 100644 > --- a/include/hw/core/cpu.h > +++ b/include/hw/core/cpu.h > @@ -355,6 +355,7 @@ struct CPUState { > QSIMPLEQ_HEAD(, qemu_work_item) work_list; > > CPUAddressSpace *cpu_ases; > + int cpu_ases_count; > int num_ases; > AddressSpace *as; > MemoryRegion *memory; > diff --git a/softmmu/physmem.c b/softmmu/physmem.c > index 4f6ca653b3..4dfa0ca66f 100644 > --- a/softmmu/physmem.c > +++ b/softmmu/physmem.c > @@ -761,6 +761,7 @@ void cpu_address_space_init(CPUState *cpu, int asidx, > > if (!cpu->cpu_ases) { > cpu->cpu_ases = g_new0(CPUAddressSpace, cpu->num_ases); > + cpu->cpu_ases_count = cpu->num_ases; > } > > newas = &cpu->cpu_ases[asidx]; > @@ -774,6 +775,30 @@ void cpu_address_space_init(CPUState *cpu, int asidx, > } > } > > +void cpu_address_space_destroy(CPUState *cpu, int asidx) > +{ > + CPUAddressSpace *cpuas; > + > + assert(asidx < cpu->num_ases); > + assert(asidx == 0 || !kvm_enabled()); > + assert(cpu->cpu_ases); > + > + cpuas = &cpu->cpu_ases[asidx]; > + if (tcg_enabled()) { > + memory_listener_unregister(&cpuas->tcg_as_listener); > + } > + > + address_space_destroy(cpuas->as); > + g_free_rcu(cpuas->as, rcu); > + > + if (cpu->cpu_ases_count == 1) { > + g_free(cpu->cpu_ases); > + cpu->cpu_ases = NULL; > + } > + > + cpu->cpu_ases_count--; > +} > + > AddressSpace *cpu_get_address_space(CPUState *cpu, int asidx) > { > /* Return the AddressSpace corresponding to the specified index */
On 9/30/23 10:19, Salil Mehta wrote: > Virtual CPU Hot-unplug leads to unrealization of a CPU object. This also > involves destruction of the CPU AddressSpace. Add common function to help > destroy the CPU AddressSpace. > > Signed-off-by: Salil Mehta <salil.mehta@huawei.com> > --- > include/exec/cpu-common.h | 8 ++++++++ > include/hw/core/cpu.h | 1 + > softmmu/physmem.c | 25 +++++++++++++++++++++++++ > 3 files changed, 34 insertions(+) > > diff --git a/include/exec/cpu-common.h b/include/exec/cpu-common.h > index 41788c0bdd..eb56a228a2 100644 > --- a/include/exec/cpu-common.h > +++ b/include/exec/cpu-common.h > @@ -120,6 +120,14 @@ size_t qemu_ram_pagesize_largest(void); > */ > void cpu_address_space_init(CPUState *cpu, int asidx, > const char *prefix, MemoryRegion *mr); > +/** > + * cpu_address_space_destroy: > + * @cpu: CPU for which address space needs to be destroyed > + * @asidx: integer index of this address space > + * > + * Note that with KVM only one address space is supported. > + */ > +void cpu_address_space_destroy(CPUState *cpu, int asidx); > > void cpu_physical_memory_rw(hwaddr addr, void *buf, > hwaddr len, bool is_write); > diff --git a/include/hw/core/cpu.h b/include/hw/core/cpu.h > index 648b5b3586..65d2ae4581 100644 > --- a/include/hw/core/cpu.h > +++ b/include/hw/core/cpu.h > @@ -355,6 +355,7 @@ struct CPUState { > QSIMPLEQ_HEAD(, qemu_work_item) work_list; > > CPUAddressSpace *cpu_ases; > + int cpu_ases_count; > int num_ases; > AddressSpace *as; > MemoryRegion *memory; @num_ases and @cpu_ases_count are duplicate to each other to some extent. The real problem is @cpu_ases is allocated at once and we need to make the allocation sparse. In that way, each CPU address space is independent and can be destroyed independently. The sparse allocation for the CPU address space can be done in cpu_address_space_init() like below: #define CPU_ADDRESS_SPACE_MAX 8 struct CPUState { CPUAddressSpace *cpu_ases[CPU_ADDRESS_SPACE_MAX]; } void cpu_address_space_init(CPUState *cpu, int asidx, const char *prefix, MemoryRegion *mr) { assert(asidx < CPU_ADDRESS_SPACE_MAX); /* The address space has been initialized ? */ if (cpu->cpu_ases[asidx]) { return; } cpu->cpu_ases[asidx] = g_new0(CPUAddressSpace, 1); } void cpu_address_destroy(CPUState *cpu, int asidx) { assert(asidx < CPU_ADDRESS_SPACE_MAX); /* The address space isn't initialized? */ if (!cpu->cpu_ases[asidx]) { return; } : g_free(cpu->cpu_ases[asidx]); cpu->cpu_ases[asidx] = NULL; } > diff --git a/softmmu/physmem.c b/softmmu/physmem.c > index 4f6ca653b3..4dfa0ca66f 100644 > --- a/softmmu/physmem.c > +++ b/softmmu/physmem.c > @@ -761,6 +761,7 @@ void cpu_address_space_init(CPUState *cpu, int asidx, > > if (!cpu->cpu_ases) { > cpu->cpu_ases = g_new0(CPUAddressSpace, cpu->num_ases); > + cpu->cpu_ases_count = cpu->num_ases; > } > > newas = &cpu->cpu_ases[asidx]; > @@ -774,6 +775,30 @@ void cpu_address_space_init(CPUState *cpu, int asidx, > } > } > > +void cpu_address_space_destroy(CPUState *cpu, int asidx) > +{ > + CPUAddressSpace *cpuas; > + > + assert(asidx < cpu->num_ases); > + assert(asidx == 0 || !kvm_enabled()); > + assert(cpu->cpu_ases); > + > + cpuas = &cpu->cpu_ases[asidx]; > + if (tcg_enabled()) { > + memory_listener_unregister(&cpuas->tcg_as_listener); > + } > + > + address_space_destroy(cpuas->as); > + g_free_rcu(cpuas->as, rcu); > + > + if (cpu->cpu_ases_count == 1) { > + g_free(cpu->cpu_ases); > + cpu->cpu_ases = NULL; > + } > + > + cpu->cpu_ases_count--; > +} > + > AddressSpace *cpu_get_address_space(CPUState *cpu, int asidx) > { > /* Return the AddressSpace corresponding to the specified index */ Thanks, Gavin
Hi Jonathan, > From: Jonathan Cameron <jonathan.cameron@huawei.com> > Sent: Monday, October 2, 2023 5:20 PM > To: Salil Mehta <salil.mehta@huawei.com> > Cc: qemu-devel@nongnu.org; qemu-arm@nongnu.org; maz@kernel.org; jean- > philippe@linaro.org; lpieralisi@kernel.org; peter.maydell@linaro.org; > richard.henderson@linaro.org; imammedo@redhat.com; andrew.jones@linux.dev; > david@redhat.com; philmd@linaro.org; eric.auger@redhat.com; > oliver.upton@linux.dev; pbonzini@redhat.com; mst@redhat.com; > will@kernel.org; gshan@redhat.com; rafael@kernel.org; > alex.bennee@linaro.org; linux@armlinux.org.uk; > darren@os.amperecomputing.com; ilkka@os.amperecomputing.com; > vishnu@os.amperecomputing.com; karl.heubaum@oracle.com; > miguel.luis@oracle.com; salil.mehta@opnsrc.net; zhukeqian > <zhukeqian1@huawei.com>; wangxiongfeng (C) <wangxiongfeng2@huawei.com>; > wangyanan (Y) <wangyanan55@huawei.com>; jiakernel2@gmail.com; > maobibo@loongson.cn; lixianglai@loongson.cn; Linuxarm <linuxarm@huawei.com> > Subject: Re: [PATCH V2 08/10] physmem: Add helper function to destroy CPU > AddressSpace > > On Sat, 30 Sep 2023 01:19:31 +0100 > Salil Mehta <salil.mehta@huawei.com> wrote: > > > Virtual CPU Hot-unplug leads to unrealization of a CPU object. This also > > involves destruction of the CPU AddressSpace. Add common function to help > > destroy the CPU AddressSpace. > > > > Signed-off-by: Salil Mehta <salil.mehta@huawei.com> > > I'm not that familiar with this bit of the code, so no tag, but > as far as I can tell from a fairly superficial look, this is good. Ok no problem. Thanks. Salil. > > include/exec/cpu-common.h | 8 ++++++++ > > include/hw/core/cpu.h | 1 + > > softmmu/physmem.c | 25 +++++++++++++++++++++++++ > > 3 files changed, 34 insertions(+) > > > > diff --git a/include/exec/cpu-common.h b/include/exec/cpu-common.h > > index 41788c0bdd..eb56a228a2 100644 > > --- a/include/exec/cpu-common.h > > +++ b/include/exec/cpu-common.h > > @@ -120,6 +120,14 @@ size_t qemu_ram_pagesize_largest(void); > > */ > > void cpu_address_space_init(CPUState *cpu, int asidx, > > const char *prefix, MemoryRegion *mr); > > +/** > > + * cpu_address_space_destroy: > > + * @cpu: CPU for which address space needs to be destroyed > > + * @asidx: integer index of this address space > > + * > > + * Note that with KVM only one address space is supported. > > + */ > > +void cpu_address_space_destroy(CPUState *cpu, int asidx); > > > > void cpu_physical_memory_rw(hwaddr addr, void *buf, > > hwaddr len, bool is_write); > > diff --git a/include/hw/core/cpu.h b/include/hw/core/cpu.h > > index 648b5b3586..65d2ae4581 100644 > > --- a/include/hw/core/cpu.h > > +++ b/include/hw/core/cpu.h > > @@ -355,6 +355,7 @@ struct CPUState { > > QSIMPLEQ_HEAD(, qemu_work_item) work_list; > > > > CPUAddressSpace *cpu_ases; > > + int cpu_ases_count; > > int num_ases; > > AddressSpace *as; > > MemoryRegion *memory; > > diff --git a/softmmu/physmem.c b/softmmu/physmem.c > > index 4f6ca653b3..4dfa0ca66f 100644 > > --- a/softmmu/physmem.c > > +++ b/softmmu/physmem.c > > @@ -761,6 +761,7 @@ void cpu_address_space_init(CPUState *cpu, int asidx, > > > > if (!cpu->cpu_ases) { > > cpu->cpu_ases = g_new0(CPUAddressSpace, cpu->num_ases); > > + cpu->cpu_ases_count = cpu->num_ases; > > } > > > > newas = &cpu->cpu_ases[asidx]; > > @@ -774,6 +775,30 @@ void cpu_address_space_init(CPUState *cpu, int > asidx, > > } > > } > > > > +void cpu_address_space_destroy(CPUState *cpu, int asidx) > > +{ > > + CPUAddressSpace *cpuas; > > + > > + assert(asidx < cpu->num_ases); > > + assert(asidx == 0 || !kvm_enabled()); > > + assert(cpu->cpu_ases); > > + > > + cpuas = &cpu->cpu_ases[asidx]; > > + if (tcg_enabled()) { > > + memory_listener_unregister(&cpuas->tcg_as_listener); > > + } > > + > > + address_space_destroy(cpuas->as); > > + g_free_rcu(cpuas->as, rcu); > > + > > + if (cpu->cpu_ases_count == 1) { > > + g_free(cpu->cpu_ases); > > + cpu->cpu_ases = NULL; > > + } > > + > > + cpu->cpu_ases_count--; > > +} > > + > > AddressSpace *cpu_get_address_space(CPUState *cpu, int asidx) > > { > > /* Return the AddressSpace corresponding to the specified index */
Hi Gavin, > From: Gavin Shan <gshan@redhat.com> > Sent: Tuesday, October 3, 2023 2:37 AM > To: Salil Mehta <salil.mehta@huawei.com>; qemu-devel@nongnu.org; qemu- > arm@nongnu.org > Cc: maz@kernel.org; jean-philippe@linaro.org; Jonathan Cameron > <jonathan.cameron@huawei.com>; lpieralisi@kernel.org; > peter.maydell@linaro.org; richard.henderson@linaro.org; > imammedo@redhat.com; andrew.jones@linux.dev; david@redhat.com; > philmd@linaro.org; eric.auger@redhat.com; oliver.upton@linux.dev; > pbonzini@redhat.com; mst@redhat.com; will@kernel.org; rafael@kernel.org; > alex.bennee@linaro.org; linux@armlinux.org.uk; > darren@os.amperecomputing.com; ilkka@os.amperecomputing.com; > vishnu@os.amperecomputing.com; karl.heubaum@oracle.com; > miguel.luis@oracle.com; salil.mehta@opnsrc.net; zhukeqian > <zhukeqian1@huawei.com>; wangxiongfeng (C) <wangxiongfeng2@huawei.com>; > wangyanan (Y) <wangyanan55@huawei.com>; jiakernel2@gmail.com; > maobibo@loongson.cn; lixianglai@loongson.cn; Linuxarm <linuxarm@huawei.com> > Subject: Re: [PATCH V2 08/10] physmem: Add helper function to destroy CPU > AddressSpace > > On 9/30/23 10:19, Salil Mehta wrote: > > Virtual CPU Hot-unplug leads to unrealization of a CPU object. This also > > involves destruction of the CPU AddressSpace. Add common function to help > > destroy the CPU AddressSpace. > > > > Signed-off-by: Salil Mehta <salil.mehta@huawei.com> > > --- > > include/exec/cpu-common.h | 8 ++++++++ > > include/hw/core/cpu.h | 1 + > > softmmu/physmem.c | 25 +++++++++++++++++++++++++ > > 3 files changed, 34 insertions(+) > > > > diff --git a/include/exec/cpu-common.h b/include/exec/cpu-common.h > > index 41788c0bdd..eb56a228a2 100644 > > --- a/include/exec/cpu-common.h > > +++ b/include/exec/cpu-common.h > > @@ -120,6 +120,14 @@ size_t qemu_ram_pagesize_largest(void); > > */ > > void cpu_address_space_init(CPUState *cpu, int asidx, > > const char *prefix, MemoryRegion *mr); > > +/** > > + * cpu_address_space_destroy: > > + * @cpu: CPU for which address space needs to be destroyed > > + * @asidx: integer index of this address space > > + * > > + * Note that with KVM only one address space is supported. > > + */ > > +void cpu_address_space_destroy(CPUState *cpu, int asidx); > > > > void cpu_physical_memory_rw(hwaddr addr, void *buf, > > hwaddr len, bool is_write); > > diff --git a/include/hw/core/cpu.h b/include/hw/core/cpu.h > > index 648b5b3586..65d2ae4581 100644 > > --- a/include/hw/core/cpu.h > > +++ b/include/hw/core/cpu.h > > @@ -355,6 +355,7 @@ struct CPUState { > > QSIMPLEQ_HEAD(, qemu_work_item) work_list; > > > > CPUAddressSpace *cpu_ases; > > + int cpu_ases_count; > > int num_ases; > > AddressSpace *as; > > MemoryRegion *memory; > > @num_ases and @cpu_ases_count are duplicate to each other to some extent. > The real problem is @cpu_ases is allocated at once and we need to make the > allocation sparse. In that way, each CPU address space is independent and can be > destroyed independently. The sparse allocation for the CPU address space can be done > in cpu_address_space_init() like below: Well, I think Phil/Richard are pointing to something else here i.e. destroy at once. https://lore.kernel.org/qemu-devel/594b2550-9a73-684f-6e54-29401dc6cd7a@linaro.org/ I used reference counter because I was not sure if it is safe to assume that AddressSpace will always be destroyed at once. BTW, there is no functional problem with above patch. Just that we do not have to maintain the reference counter. You can use below command to check CPU memory address spaces are getting destroyed properly and get re-created again with CPU hot(un)plug: Qemu> info mtree Thanks Salil.
Hi Gavin, Revisited your comments again. > From: Gavin Shan <gshan@redhat.com> > Sent: Tuesday, October 3, 2023 2:37 AM > To: Salil Mehta <salil.mehta@huawei.com>; qemu-devel@nongnu.org; qemu- > arm@nongnu.org > Cc: maz@kernel.org; jean-philippe@linaro.org; Jonathan Cameron > <jonathan.cameron@huawei.com>; lpieralisi@kernel.org; > peter.maydell@linaro.org; richard.henderson@linaro.org; > imammedo@redhat.com; andrew.jones@linux.dev; david@redhat.com; > philmd@linaro.org; eric.auger@redhat.com; oliver.upton@linux.dev; > pbonzini@redhat.com; mst@redhat.com; will@kernel.org; rafael@kernel.org; > alex.bennee@linaro.org; linux@armlinux.org.uk; > darren@os.amperecomputing.com; ilkka@os.amperecomputing.com; > vishnu@os.amperecomputing.com; karl.heubaum@oracle.com; > miguel.luis@oracle.com; salil.mehta@opnsrc.net; zhukeqian > <zhukeqian1@huawei.com>; wangxiongfeng (C) <wangxiongfeng2@huawei.com>; > wangyanan (Y) <wangyanan55@huawei.com>; jiakernel2@gmail.com; > maobibo@loongson.cn; lixianglai@loongson.cn; Linuxarm <linuxarm@huawei.com> > Subject: Re: [PATCH V2 08/10] physmem: Add helper function to destroy CPU > AddressSpace > > On 9/30/23 10:19, Salil Mehta wrote: > > Virtual CPU Hot-unplug leads to unrealization of a CPU object. This also > > involves destruction of the CPU AddressSpace. Add common function to help > > destroy the CPU AddressSpace. > > > > Signed-off-by: Salil Mehta <salil.mehta@huawei.com> > > --- > > include/exec/cpu-common.h | 8 ++++++++ > > include/hw/core/cpu.h | 1 + > > softmmu/physmem.c | 25 +++++++++++++++++++++++++ > > 3 files changed, 34 insertions(+) > > > > diff --git a/include/exec/cpu-common.h b/include/exec/cpu-common.h > > index 41788c0bdd..eb56a228a2 100644 > > --- a/include/exec/cpu-common.h > > +++ b/include/exec/cpu-common.h > > @@ -120,6 +120,14 @@ size_t qemu_ram_pagesize_largest(void); > > */ > > void cpu_address_space_init(CPUState *cpu, int asidx, > > const char *prefix, MemoryRegion *mr); > > +/** > > + * cpu_address_space_destroy: > > + * @cpu: CPU for which address space needs to be destroyed > > + * @asidx: integer index of this address space > > + * > > + * Note that with KVM only one address space is supported. > > + */ > > +void cpu_address_space_destroy(CPUState *cpu, int asidx); > > > > void cpu_physical_memory_rw(hwaddr addr, void *buf, > > hwaddr len, bool is_write); > > diff --git a/include/hw/core/cpu.h b/include/hw/core/cpu.h > > index 648b5b3586..65d2ae4581 100644 > > --- a/include/hw/core/cpu.h > > +++ b/include/hw/core/cpu.h > > @@ -355,6 +355,7 @@ struct CPUState { > > QSIMPLEQ_HEAD(, qemu_work_item) work_list; > > > > CPUAddressSpace *cpu_ases; > > + int cpu_ases_count; > > int num_ases; > > AddressSpace *as; > > MemoryRegion *memory; > > @num_ases and @cpu_ases_count are duplicate to each other to some extent. > The > real problem is @cpu_ases is allocated at once and we need to make the > allocation > sparse. In that way, each CPU address space is independent and can be > destroyed > independently. (revisiting this comment i.e. 'sparse') If you meant, the order of initialization and destruction might not be same then yes, AddressSpace can be *conditionally* allocated during CPU realization phase and should be *conditionally* destroyed as well during CPU un-realization phase. Later means, it is not safe to assume that indexes to the array of AddressSpace might be consecutive. Hence, their destruction at once can create problems. https://lore.kernel.org/qemu-devel/20230926100436.28284-1-salil.mehta@huawei.com/T/#m44b81fbbba33a346dd2292256012f86ef7c8e761 The sparse allocation for the CPU address space can be done > in > cpu_address_space_init() like below: > > #define CPU_ADDRESS_SPACE_MAX 8 > > struct CPUState { > CPUAddressSpace *cpu_ases[CPU_ADDRESS_SPACE_MAX]; > } Yes, this will also work but we will end up refactoring existing initialization interface. Do we require all of this when counter based approach also works without changing anything? Thanks Salil.
diff --git a/include/exec/cpu-common.h b/include/exec/cpu-common.h index 41788c0bdd..eb56a228a2 100644 --- a/include/exec/cpu-common.h +++ b/include/exec/cpu-common.h @@ -120,6 +120,14 @@ size_t qemu_ram_pagesize_largest(void); */ void cpu_address_space_init(CPUState *cpu, int asidx, const char *prefix, MemoryRegion *mr); +/** + * cpu_address_space_destroy: + * @cpu: CPU for which address space needs to be destroyed + * @asidx: integer index of this address space + * + * Note that with KVM only one address space is supported. + */ +void cpu_address_space_destroy(CPUState *cpu, int asidx); void cpu_physical_memory_rw(hwaddr addr, void *buf, hwaddr len, bool is_write); diff --git a/include/hw/core/cpu.h b/include/hw/core/cpu.h index 648b5b3586..65d2ae4581 100644 --- a/include/hw/core/cpu.h +++ b/include/hw/core/cpu.h @@ -355,6 +355,7 @@ struct CPUState { QSIMPLEQ_HEAD(, qemu_work_item) work_list; CPUAddressSpace *cpu_ases; + int cpu_ases_count; int num_ases; AddressSpace *as; MemoryRegion *memory; diff --git a/softmmu/physmem.c b/softmmu/physmem.c index 4f6ca653b3..4dfa0ca66f 100644 --- a/softmmu/physmem.c +++ b/softmmu/physmem.c @@ -761,6 +761,7 @@ void cpu_address_space_init(CPUState *cpu, int asidx, if (!cpu->cpu_ases) { cpu->cpu_ases = g_new0(CPUAddressSpace, cpu->num_ases); + cpu->cpu_ases_count = cpu->num_ases; } newas = &cpu->cpu_ases[asidx]; @@ -774,6 +775,30 @@ void cpu_address_space_init(CPUState *cpu, int asidx, } } +void cpu_address_space_destroy(CPUState *cpu, int asidx) +{ + CPUAddressSpace *cpuas; + + assert(asidx < cpu->num_ases); + assert(asidx == 0 || !kvm_enabled()); + assert(cpu->cpu_ases); + + cpuas = &cpu->cpu_ases[asidx]; + if (tcg_enabled()) { + memory_listener_unregister(&cpuas->tcg_as_listener); + } + + address_space_destroy(cpuas->as); + g_free_rcu(cpuas->as, rcu); + + if (cpu->cpu_ases_count == 1) { + g_free(cpu->cpu_ases); + cpu->cpu_ases = NULL; + } + + cpu->cpu_ases_count--; +} + AddressSpace *cpu_get_address_space(CPUState *cpu, int asidx) { /* Return the AddressSpace corresponding to the specified index */
Virtual CPU Hot-unplug leads to unrealization of a CPU object. This also involves destruction of the CPU AddressSpace. Add common function to help destroy the CPU AddressSpace. Signed-off-by: Salil Mehta <salil.mehta@huawei.com> --- include/exec/cpu-common.h | 8 ++++++++ include/hw/core/cpu.h | 1 + softmmu/physmem.c | 25 +++++++++++++++++++++++++ 3 files changed, 34 insertions(+)