Hyper-V: kexec fixes for L1VH (mshv)
Subsystems (4)
v2 cover Hyper-V: kexec fixes for L1VH (mshv)
This series fixes kexec support when Linux runs as an L1 Virtual Host (L1VH) under Hyper-V, using the MSHV driver to manage child VMs.
1. A variable shadowing bug in vmbus that hides the cpuhp state used for teardown.
2. Move hv_stimer_global_cleanup() from vmbus's hv_kexec_handler() to hv_machine_shutdown(). This ensures stimer cleanup happens before the vmbus unload.
3. LP/VP re-creation: after kexec, logical processors and virtual processors already exist in the hypervisor. Detect this and skip re-adding them.
4-5. SynIC cleanup: the MSHV driver manages its own SynIC resources
separately from vmbus. Add proper teardown of MSHV-owned SINTs, SIMP, and SIEFP on kexec, scoped to only the resources MSHV owns.
6. Debugfs stats pages: unmap the VP statistics overlay pages before kexec to avoid stale mappings in the new kernel.
Changes since v1:
- Patch 4: account for nested root partitions where VMBus is also active (not just L1VH); use a vmbus_active local variable; allocate SIRBP L1VH allocation path for when the hypervisor doesn't pre-provision the page
Jork Loeser (6):
Drivers: hv: vmbus: fix hyperv_cpuhp_online variable shadowing x86/hyperv: move stimer cleanup to hv_machine_shutdown() x86/hyperv: Skip LP/VP creation on kexec
mshv: limit SynIC management to MSHV-owned resources
mshv: clean up SynIC state on kexec for L1VH
mshv: unmap debugfs stats pages on kexec
arch/x86/kernel/cpu/mshyperv.c | 15 +++- drivers/hv/hv_proc.c | 47 +++++++++++ drivers/hv/mshv_debugfs.c | 7 +- drivers/hv/mshv_root_main.c | 22 ++--- drivers/hv/mshv_synic.c | 142 ++++++++++++++++++++++----------- drivers/hv/vmbus_drv.c | 2 - include/asm-generic/mshyperv.h | 10 +++ include/hyperv/hvgdk_mini.h | 1 + include/hyperv/hvhdk_mini.h | 12 +++ 9 files changed, 188 insertions(+), 70 deletions(-)
--
2.43.0
PATCH v2 1/6 Drivers: hv: vmbus: fix hyperv_cpuhp_online variable shadowing
vmbus_alloc_synic_and_connect() declares a local 'int hyperv_cpuhp_online' that shadows the file-scope global of the same name. The cpuhp state returned by cpuhp_setup_state() is stored in the local, leaving the global at 0 (CPUHP_OFFLINE). When hv_kexec_handler() or hv_machine_shutdown() later call cpuhp_remove_state(hyperv_cpuhp_online) they pass 0, which hits the BUG_ON in __cpuhp_remove_state_cpuslocked().
Remove the local declaration so the cpuhp state is stored in the file-scope global where hv_kexec_handler() and hv_machine_shutdown() expect it.
--- drivers/hv/vmbus_drv.c | 1 - 1 file changed, 1 deletion(-)
drivers/hv/vmbus_drv.c +0 -1
@@ -1430,7 +1430,6 @@ static int vmbus_alloc_synic_and_connect(void) {int ret, cpu;struct work_struct __percpu *works; -int hyperv_cpuhp_online; ret =hv_synic_alloc ();if (ret <0 )
Signature · 1 line
2.43.0
PATCH v2 2/6 x86/hyperv: move stimer cleanup to hv_machine_shutdown()
In reply to Jork LoeserMove hv_stimer_global_cleanup() from vmbus's hv_kexec_handler() to hv_machine_shutdown() in the platform code. This ensures stimer cleanup happens before the vmbus unload, which is required for root partition kexec to work correctly.
--- arch/x86/kernel/cpu/mshyperv.c | 8 ++++++-- drivers/hv/vmbus_drv.c | 1 - 2 files changed, 6 insertions(+), 3 deletions(-)
arch/x86/kernel/cpu/mshyperv.c +6 -2
@@ -235,8 +235,12 @@ void hv_remove_crash_handler(void)#ifdef CONFIG_KEXEC_CORE static void hv_machine_shutdown (void ) { -if (kexec_in_progress && hv_kexec_handler) -hv_kexec_handler (); +if (kexec_in_progress) { +hv_stimer_global_cleanup (); + +if (hv_kexec_handler) +hv_kexec_handler (); + }/* * Call hv_cpu_die() on all the CPUs, otherwise later the hypervisor
drivers/hv/vmbus_drv.c +0 -1
@@ -2892,7 +2892,6 @@ static struct platform_driver vmbus_platform_driver = {static void hv_kexec_handler (void ) { -hv_stimer_global_cleanup ();vmbus_initiate_unload (false);/* Make sure conn_state is set as hv_synic_cleanup checks for it */ mb ();
Signature · 1 line
2.43.0
PATCH v2 3/6 x86/hyperv: Skip LP/VP creation on kexec
In reply to Jork LoeserAfter a kexec the logical processors and virtual processors already exist in the hypervisor because they were created by the previous kernel. Attempting to add them again causes either a BUG_ON or corrupted VP state leading to MCEs in the new kernel.
Add hv_lp_exists() to probe whether an LP is already present by calling HVCALL_GET_LOGICAL_PROCESSOR_RUN_TIME. When it succeeds the LP exists and we skip the add-LP and create-VP loops entirely.
Also add hv_call_notify_all_processors_started() which informs the hypervisor that all processors are online. This is required after adding LPs (fresh boot) and is a no-op on kexec since we skip that path.
--- arch/x86/kernel/cpu/mshyperv.c | 7 +++++ drivers/hv/hv_proc.c | 47 ++++++++++++++++++++++++++++++++++ include/asm-generic/mshyperv.h | 10 ++++++++ include/hyperv/hvgdk_mini.h | 1 + include/hyperv/hvhdk_mini.h | 12 +++++++++ 5 files changed, 77 insertions(+)
arch/x86/kernel/cpu/mshyperv.c +7 -0
@@ -429,6 +429,10 @@ static void __init hv_smp_prepare_cpus(unsigned int max_cpus) }#ifdef CONFIG_X86_64 +/* If AP LPs exist, we are in a kexec'd kernel and VPs already exist */ +if (num_present_cpus () ==1 ||hv_lp_exists (1 )) +return ; +for_each_present_cpu (i) {if (i ==0 )continue ;
@@ -436,6 +440,9 @@ static void __init hv_smp_prepare_cpus(unsigned int max_cpus)BUG_ON (ret); } + ret =hv_call_notify_all_processors_started (); +WARN_ON (ret); +for_each_present_cpu (i) {if (i ==0 )continue ;
drivers/hv/hv_proc.c +47 -0
50 lines not on this page · raw message
include/asm-generic/mshyperv.h +10 -0
@@ -347,6 +347,8 @@ bool hv_result_needs_memory(u64 status);int hv_deposit_memory_node (int node,u64 partition_id,u64 status);int hv_call_deposit_pages (int node,u64 partition_id,u32 num_pages);int hv_call_add_logical_proc (int node,u32 lp_index,u32 acpi_id); +int hv_call_notify_all_processors_started (void ); +bool hv_lp_exists (u32 lp_index);int hv_call_create_vp (int node,u64 partition_id,u32 vp_index,u32 flags);#else /* CONFIG_MSHV_ROOT */
@@ -366,6 +368,14 @@ static inline int hv_call_add_logical_proc(int node, u32 lp_index, u32 acpi_id) {return -EOPNOTSUPP ; } +static inline int hv_call_notify_all_processors_started (void ) +{ +return -EOPNOTSUPP ; +} +static inline bool hv_lp_exists (u32 lp_index) +{ +return false; +}static inline int hv_call_create_vp (int node,u64 partition_id,u32 vp_index,u32 flags) {return -EOPNOTSUPP ;
include/hyperv/hvgdk_mini.h +1 -0
@@ -435,6 +435,7 @@ union hv_vp_assist_msr_contents { /* HV_REGISTER_VP_ASSIST_PAGE *//* HV_CALL_CODE */ #define HVCALL_FLUSH_VIRTUAL_ADDRESS_SPACE 0x0002#define HVCALL_FLUSH_VIRTUAL_ADDRESS_LIST 0x0003 +#define HVCALL_GET_LOGICAL_PROCESSOR_RUN_TIME 0x0004#define HVCALL_NOTIFY_LONG_SPIN_WAIT 0x0008#define HVCALL_SEND_IPI 0x000b#define HVCALL_ENABLE_VP_VTL 0x000f
include/hyperv/hvhdk_mini.h +12 -0
@@ -362,6 +362,7 @@ union hv_partition_event_input {enum hv_partition_event {HV_PARTITION_EVENT_ROOT_CRASHDUMP =2 , +HV_PARTITION_ALL_LOGICAL_PROCESSORS_STARTED =4 , };struct hv_input_notify_partition_event {
@@ -369,6 +370,17 @@ struct hv_input_notify_partition_event {union hv_partition_event_input input; } __packed; +struct hv_input_get_logical_processor_run_time { +u32 lp_index; +} __packed; + +struct hv_output_get_logical_processor_run_time { +u64 global_time; +u64 local_run_time; +u64 rsvdz0; +u64 hypervisor_time; +} __packed; +struct hv_lp_startup_status {u64 hv_status;u64 substatus1;
Signature · 1 line
2.43.0
PATCH v2 4/6 mshv: limit SynIC management to MSHV-owned resources
In reply to Jork LoeserThe SynIC is shared between VMBus and MSHV. VMBus owns the message page (SIMP), event flags page (SIEFP), global enable (SCONTROL), and SINT2. MSHV adds SINT0, SINT5, and the event ring page (SIRBP).
Currently mshv_synic_init() redundantly enables SIMP, SIEFP, and SCONTROL that VMBus already configured, and mshv_synic_cleanup() disables all of them. This is wrong because MSHV can be torn down while VMBus is still active. In particular, a kexec reboot notifier tears down MSHV first. Disabling SCONTROL, SIMP, and SIEFP out from under VMBus causes its later cleanup to write SynIC MSRs while SynIC is disabled, which the hypervisor does not tolerate.
Restrict MSHV to managing only the resources it owns:
- SINT0, SINT5: mask on cleanup, unmask on init
- SIRBP: enable/disable as before
- SIMP, SIEFP, SCONTROL: leave to VMBus when it is active (L1VH and nested root partition); on a non-nested root partition VMBus doesn't run, so MSHV must enable/disable them
--- drivers/hv/mshv_synic.c | 142 ++++++++++++++++++++++++++-------------- 1 file changed, 94 insertions(+), 48 deletions(-)
drivers/hv/mshv_synic.c +94 -48
@@ -454,46 +454,72 @@ int mshv_synic_init(unsigned int cpu)#ifdef HYPERVISOR_CALLBACK_VECTOR union hv_synic_sint sint;#endif -union hv_synic_scontrol sctrl;struct hv_synic_pages *spages =this_cpu_ptr (mshv_root.synic_pages);struct hv_message_page **msg_page = &spages->hyp_synic_message_page;struct hv_synic_event_flags_page **event_flags_page = &spages->synic_event_flags_page;struct hv_synic_event_ring_page **event_ring_page = &spages->synic_event_ring_page; +/* VMBus runs on L1VH and nested root; it owns SIMP/SIEFP/SCONTROL */ +bool vmbus_active = !hv_root_partition () || hv_nested; -/* Setup the Synic's message page */ +/* +* Map the SYNIC message page. When VMBus is not active the +* hypervisor pre-provisions the SIMP GPA but may not set +* simp_enabled — enable it here. +*/ simp.as_uint64 =hv_get_non_nested_msr (HV_MSR_SIMP ); - simp.simp_enabled = true; +if (!vmbus_active) { + simp.simp_enabled = true; +hv_set_non_nested_msr (HV_MSR_SIMP , simp.as_uint64); + } *msg_page =memremap (simp.base_simp_gpa <<HV_HYP_PAGE_SHIFT ,HV_HYP_PAGE_SIZE ,MEMREMAP_WB );if (!(*msg_page)) -return -EFAULT ; + goto cleanup_simp; -hv_set_non_nested_msr (HV_MSR_SIMP , simp.as_uint64); - -/* Setup the Synic's event flags page */ +/* +* Map the event flags page. Same as SIMP: enable when +* VMBus is not active, already enabled by VMBus otherwise. +*/ siefp.as_uint64 =hv_get_non_nested_msr (HV_MSR_SIEFP ); - siefp.siefp_enabled = true; +if (!vmbus_active) { + siefp.siefp_enabled = true; +hv_set_non_nested_msr (HV_MSR_SIEFP , siefp.as_uint64); + } *event_flags_page =memremap (siefp.base_siefp_gpa <<PAGE_SHIFT ,PAGE_SIZE ,MEMREMAP_WB );if (!(*event_flags_page)) - goto cleanup; - -hv_set_non_nested_msr (HV_MSR_SIEFP , siefp.as_uint64); + goto cleanup_siefp;/* Setup the Synic's event ring page */ sirbp.as_uint64 =hv_get_non_nested_msr (HV_MSR_SIRBP ); - sirbp.sirbp_enabled = true; - *event_ring_page =memremap (sirbp.base_sirbp_gpa <<PAGE_SHIFT , -PAGE_SIZE ,MEMREMAP_WB ); -if (!(*event_ring_page)) - goto cleanup; +if (hv_root_partition ()) { + *event_ring_page =memremap (sirbp.base_sirbp_gpa <<PAGE_SHIFT , +PAGE_SIZE ,MEMREMAP_WB ); +if (!(*event_ring_page)) + goto cleanup_siefp; + }else { +/* +* On L1VH the hypervisor does not provide a SIRBP page. +* Allocate one and program its GPA into the MSR. +*/ + *event_ring_page = (struct hv_synic_event_ring_page *) +get_zeroed_page (GFP_KERNEL ); + +if (!(*event_ring_page)) + goto cleanup_siefp; + + sirbp.base_sirbp_gpa =virt_to_phys (*event_ring_page) + >>PAGE_SHIFT ; + } + + sirbp.sirbp_enabled = true;hv_set_non_nested_msr (HV_MSR_SIRBP , sirbp.as_uint64);#ifdef HYPERVISOR_CALLBACK_VECTOR
@@ -515,28 +541,30 @@ int mshv_synic_init(unsigned int cpu) sint.as_uint64);#endif -/* Enable global synic bit */ - sctrl.as_uint64 =hv_get_non_nested_msr (HV_MSR_SCONTROL ); - sctrl.enable =1 ; -hv_set_non_nested_msr (HV_MSR_SCONTROL , sctrl.as_uint64); +/* When VMBus is active it already enabled SCONTROL. */ +if (!vmbus_active) { +union hv_synic_scontrol sctrl; + + sctrl.as_uint64 =hv_get_non_nested_msr (HV_MSR_SCONTROL ); + sctrl.enable =1 ; +hv_set_non_nested_msr (HV_MSR_SCONTROL , sctrl.as_uint64); + }return 0 ; -cleanup: -if (*event_ring_page) { - sirbp.sirbp_enabled = false; -hv_set_non_nested_msr (HV_MSR_SIRBP , sirbp.as_uint64); -memunmap (*event_ring_page); - } -if (*event_flags_page) { +cleanup_siefp: +if (*event_flags_page) +memunmap (*event_flags_page); +if (!vmbus_active) { siefp.siefp_enabled = false;hv_set_non_nested_msr (HV_MSR_SIEFP , siefp.as_uint64); -memunmap (*event_flags_page); } -if (*msg_page) { +cleanup_simp: +if (*msg_page) +memunmap (*msg_page); +if (!vmbus_active) { simp.simp_enabled = false;hv_set_non_nested_msr (HV_MSR_SIMP , simp.as_uint64); -memunmap (*msg_page); }return -EFAULT ;
@@ -545,16 +573,15 @@ int mshv_synic_init(unsigned int cpu)int mshv_synic_cleanup (unsigned int cpu) {union hv_synic_sint sint; -union hv_synic_simp simp; -union hv_synic_siefp siefp;union hv_synic_sirbp sirbp; -union hv_synic_scontrol sctrl;struct hv_synic_pages *spages =this_cpu_ptr (mshv_root.synic_pages);struct hv_message_page **msg_page = &spages->hyp_synic_message_page;struct hv_synic_event_flags_page **event_flags_page = &spages->synic_event_flags_page;struct hv_synic_event_ring_page **event_ring_page = &spages->synic_event_ring_page; +/* VMBus runs on L1VH and nested root; it owns SIMP/SIEFP/SCONTROL */ +bool vmbus_active = !hv_root_partition () || hv_nested;/* Disable the interrupt */ sint.as_uint64 =hv_get_non_nested_msr (HV_MSR_SINT0 +HV_SYNIC_INTERCEPTION_SINT_INDEX );
@@ -568,28 +595,47 @@ int mshv_synic_cleanup(unsigned int cpu)hv_set_non_nested_msr (HV_MSR_SINT0 +HV_SYNIC_DOORBELL_SINT_INDEX , sint.as_uint64); -/* Disable Synic's event ring page */ +/* Disable SYNIC event ring page owned by MSHV */ sirbp.as_uint64 =hv_get_non_nested_msr (HV_MSR_SIRBP ); sirbp.sirbp_enabled = false; -hv_set_non_nested_msr (HV_MSR_SIRBP , sirbp.as_uint64); -memunmap (*event_ring_page); -/* Disable Synic's event flags page */ - siefp.as_uint64 =hv_get_non_nested_msr (HV_MSR_SIEFP ); - siefp.siefp_enabled = false; -hv_set_non_nested_msr (HV_MSR_SIEFP , siefp.as_uint64); +if (hv_root_partition ()) { +hv_set_non_nested_msr (HV_MSR_SIRBP , sirbp.as_uint64); +memunmap (*event_ring_page); + }else { + sirbp.base_sirbp_gpa =0 ; +hv_set_non_nested_msr (HV_MSR_SIRBP , sirbp.as_uint64); +free_page ((unsigned long )*event_ring_page); + } + +/* +* Release our mappings of the message and event flags pages. +* When VMBus is not active, we enabled SIMP/SIEFP — disable +* them. Otherwise VMBus owns the MSRs — leave them. +*/ memunmap (*event_flags_page); +if (!vmbus_active) { +union hv_synic_simp simp; +union hv_synic_siefp siefp; -/* Disable Synic's message page */ - simp.as_uint64 =hv_get_non_nested_msr (HV_MSR_SIMP ); - simp.simp_enabled = false; -hv_set_non_nested_msr (HV_MSR_SIMP , simp.as_uint64); + siefp.as_uint64 =hv_get_non_nested_msr (HV_MSR_SIEFP ); + siefp.siefp_enabled = false; +hv_set_non_nested_msr (HV_MSR_SIEFP , siefp.as_uint64); + + simp.as_uint64 =hv_get_non_nested_msr (HV_MSR_SIMP ); + simp.simp_enabled = false; +hv_set_non_nested_msr (HV_MSR_SIMP , simp.as_uint64); + }memunmap (*msg_page); -/* Disable global synic bit */ - sctrl.as_uint64 =hv_get_non_nested_msr (HV_MSR_SCONTROL ); - sctrl.enable =0 ; -hv_set_non_nested_msr (HV_MSR_SCONTROL , sctrl.as_uint64); +/* When VMBus is active it owns SCONTROL — leave it. */ +if (!vmbus_active) { +union hv_synic_scontrol sctrl; + + sctrl.as_uint64 =hv_get_non_nested_msr (HV_MSR_SCONTROL ); + sctrl.enable =0 ; +hv_set_non_nested_msr (HV_MSR_SCONTROL , sctrl.as_uint64); + }return 0 ; }
Signature · 1 line
2.43.0
Re: [PATCH v2 4/6] mshv: limit SynIC management to MSHV-owned resources
Quoted 5 lines · Jork Loeser
The SynIC is shared between VMBus and MSHV. VMBus owns the message page (SIMP), event flags page (SIEFP), global enable (SCONTROL), and SINT2. MSHV adds SINT0, SINT5, and the event ring page (SIRBP).
Currently
mshv_synic_init()redundantly enables SIMP, SIEFP, and
The redundant enable is probably a no-op from the hypervisor side so it probably doesn't hurt us. The main problem is with the tear down.
Quoted 26 lines
SCONTROL that VMBus already configured, and
mshv_synic_cleanup()disables all of them. This is wrong because MSHV can be torn down while VMBus is still active. In particular, a kexec reboot notifier tears down MSHV first. Disabling SCONTROL, SIMP, and SIEFP out from under VMBus causes its later cleanup to write SynIC MSRs while SynIC is disabled, which the hypervisor does not tolerate.Restrict MSHV to managing only the resources it owns:
- SINT0, SINT5: mask on cleanup, unmask on init
- SIRBP: enable/disable as before
- SIMP, SIEFP, SCONTROL: leave to VMBus when it is active (L1VH and nested root partition); on a non-nested root partition VMBus doesn't run, so MSHV must enable/disable themSigned-off-by Jork Loeser <[email protected]>--- drivers/hv/mshv_synic.c | 142 ++++++++++++++++++++++++++-------------- 1 file changed, 94 insertions(+), 48 deletions(-)drivers/hv/mshv_synic.c +0
-0@@ -454,46 +454,72 @@ int mshv_synic_init(unsigned int cpu)#ifdef HYPERVISOR_CALLBACK_VECTOR union hv_synic_sint sint;
drivers/hv/mshv_synic.c int mshv_synic_init(unsigned int cpu) · line 464
Quoted 10 lines
drivers/hv/mshv_synic.c +2
-1#endif -union hv_synic_scontrol sctrl;struct hv_synic_pages *spages =this_cpu_ptr (mshv_root.synic_pages);struct hv_message_page **msg_page = &spages->hyp_synic_message_page;struct hv_synic_event_flags_page **event_flags_page = &spages->synic_event_flags_page;struct hv_synic_event_ring_page **event_ring_page = &spages->synic_event_ring_page; +/* VMBus runs on L1VH and nested root; it owns SIMP/SIEFP/SCONTROL */ +bool vmbus_active = !hv_root_partition () || hv_nested;
An alternative approach could be: check if SIMP/SIEFP/SCONTROL is already enabled. If so, don't enable it again. If not enabled, enable it and keep track of what all stuf we have enabled. Then disable all of them during cleanup. This approach makes less assumptions about the behavior of the VMBUS driver and what stuff it does or doesn't use.
Thanks,
Anirudh.
Re: [PATCH v2 4/6] mshv: limit SynIC management to MSHV-owned resources
Quoted 9 lines · Anirudh Rayabharam
Quoted 5 lines · Jork Loeser
The SynIC is shared between VMBus and MSHV. VMBus owns the message page (SIMP), event flags page (SIEFP), global enable (SCONTROL), and SINT2. MSHV adds SINT0, SINT5, and the event ring page (SIRBP).
Currently
mshv_synic_init()redundantly enables SIMP, SIEFP, andThe redundant enable is probably a no-op from the hypervisor side so it probably doesn't hurt us. The main problem is with the tear down.
It's an MSR intercept. If we can replace this by an "if()" we shave a few cycles.
Quoted 5 lines
An alternative approach could be: check if SIMP/SIEFP/SCONTROL is already enabled. If so, don't enable it again. If not enabled, enable it and keep track of what all stuf we have enabled. Then disable all of them during cleanup. This approach makes less assumptions about the behavior of the VMBUS driver and what stuff it does or doesn't use.
It would, yes. Then again, we drag yet more state and make debugging more complicated / less clear to reason what happens dynamically. I had been debating this briefly myself, and ultimately decided against it for that very reason.
Best,
Jork
Re: [PATCH v2 4/6] mshv: limit SynIC management to MSHV-owned resources
Quoted 21 lines · Jork Loeser
Quoted 9 lines · Anirudh Rayabharam
Quoted 5 lines · Jork Loeser
The SynIC is shared between VMBus and MSHV. VMBus owns the message page (SIMP), event flags page (SIEFP), global enable (SCONTROL), and SINT2. MSHV adds SINT0, SINT5, and the event ring page (SIRBP).
Currently
mshv_synic_init()redundantly enables SIMP, SIEFP, andThe redundant enable is probably a no-op from the hypervisor side so it probably doesn't hurt us. The main problem is with the tear down.
It's an MSR intercept. If we can replace this by an "
if()" we shave a few cycles.Quoted 5 lines
An alternative approach could be: check if SIMP/SIEFP/SCONTROL is already enabled. If so, don't enable it again. If not enabled, enable it and keep track of what all stuf we have enabled. Then disable all of them during cleanup. This approach makes less assumptions about the behavior of the VMBUS driver and what stuff it does or doesn't use.
Quoted 4 lines
It would, yes. Then again, we drag yet more state and make debugging more complicated / less clear to reason what happens dynamically. I had been debating this briefly myself, and ultimately decided against it for that very reason.
Ultimately, both approaches are fragile in their own ways because the contract that "VMBus owns SIMP, SIEFP, SCONTROL, SINT2 and MSHV owns SIRBP and SINT0 and SINT5" are not enforced anywhere in code and are just assumptions that everyone will play nice. To do that, we'll need to refactor the code such that there is a common component that sort of facilitates access to SynIC for both VMBus and MSHV.
I would say that checking the state dynamically and then deciding whether or not to enable SIMP/SIEFP/SCONTROL would be less fragile because we make lesser assumptions about what VMBus does or doesn't do.
Also, do you know of any cases where the VMBus stuff can get initialized after MSHV? Maybe if VMBus is a module (if that is even possible)? That would really mess up our logic here.
Thanks,
Anirudh.
Quoted 3 lines
Best,
Jork
Wei Liu
maintainerRe: [PATCH v2 4/6] mshv: limit SynIC management to MSHV-owned resources
Quoted 34 lines · Anirudh Rayabharam
Quoted 21 lines · Jork Loeser
Quoted 9 lines · Anirudh Rayabharam
Quoted 5 lines · Jork Loeser
The SynIC is shared between VMBus and MSHV. VMBus owns the message page (SIMP), event flags page (SIEFP), global enable (SCONTROL), and SINT2. MSHV adds SINT0, SINT5, and the event ring page (SIRBP).
Currently
mshv_synic_init()redundantly enables SIMP, SIEFP, andThe redundant enable is probably a no-op from the hypervisor side so it probably doesn't hurt us. The main problem is with the tear down.
It's an MSR intercept. If we can replace this by an "
if()" we shave a few cycles.Quoted 5 lines
An alternative approach could be: check if SIMP/SIEFP/SCONTROL is already enabled. If so, don't enable it again. If not enabled, enable it and keep track of what all stuf we have enabled. Then disable all of them during cleanup. This approach makes less assumptions about the behavior of the VMBUS driver and what stuff it does or doesn't use.
Quoted 4 lines
It would, yes. Then again, we drag yet more state and make debugging more complicated / less clear to reason what happens dynamically. I had been debating this briefly myself, and ultimately decided against it for that very reason.
Ultimately, both approaches are fragile in their own ways because the contract that "VMBus owns SIMP, SIEFP, SCONTROL, SINT2 and MSHV owns SIRBP and SINT0 and SINT5" are not enforced anywhere in code and are just assumptions that everyone will play nice. To do that, we'll need to refactor the code such that there is a common component that sort of facilitates access to SynIC for both VMBus and MSHV.
Quoted 4 lines
I would say that checking the state dynamically and then deciding whether or not to enable SIMP/SIEFP/SCONTROL would be less fragile because we make lesser assumptions about what VMBus does or doesn't do.
I think it is important to keep the changes as small as possible for ease of backporting.
Quoted 4 lines
Also, do you know of any cases where the VMBus stuff can get initialized after MSHV? Maybe if VMBus is a module (if that is even possible)? That would really mess up our logic here.
It is possible to configure Vmbus as a module today. We should think of a way to resolve what you say. Designing a new component is one way. The other way is to find a working build configuration and enforce it via Kconfig.
Wei
Quoted 6 lines
Thanks,
Anirudh.Quoted 3 lines
Best,
Jork
Re: [PATCH v2 4/6] mshv: limit SynIC management to MSHV-owned resources
In reply to Jork LoeserQuoted 93 lines · Jork Loeser
The SynIC is shared between VMBus and MSHV. VMBus owns the message page (SIMP), event flags page (SIEFP), global enable (SCONTROL), and SINT2. MSHV adds SINT0, SINT5, and the event ring page (SIRBP).
Currently
mshv_synic_init()redundantly enables SIMP, SIEFP, and SCONTROL that VMBus already configured, andmshv_synic_cleanup()disables all of them. This is wrong because MSHV can be torn down while VMBus is still active. In particular, a kexec reboot notifier tears down MSHV first. Disabling SCONTROL, SIMP, and SIEFP out from under VMBus causes its later cleanup to write SynIC MSRs while SynIC is disabled, which the hypervisor does not tolerate.Restrict MSHV to managing only the resources it owns:
- SINT0, SINT5: mask on cleanup, unmask on init
- SIRBP: enable/disable as before
- SIMP, SIEFP, SCONTROL: leave to VMBus when it is active (L1VH and nested root partition); on a non-nested root partition VMBus doesn't run, so MSHV must enable/disable themSigned-off-by Jork Loeser <[email protected]>--- drivers/hv/mshv_synic.c | 142 ++++++++++++++++++++++++++-------------- 1 file changed, 94 insertions(+), 48 deletions(-)drivers/hv/mshv_synic.c +22
-16@@ -454,46 +454,72 @@ int mshv_synic_init(unsigned int cpu)#ifdef HYPERVISOR_CALLBACK_VECTOR union hv_synic_sint sint;#endif -union hv_synic_scontrol sctrl;struct hv_synic_pages *spages =this_cpu_ptr (mshv_root.synic_pages);struct hv_message_page **msg_page = &spages->hyp_synic_message_page;struct hv_synic_event_flags_page **event_flags_page = &spages->synic_event_flags_page;struct hv_synic_event_ring_page **event_ring_page = &spages->synic_event_ring_page; +/* VMBus runs on L1VH and nested root; it owns SIMP/SIEFP/SCONTROL */ +bool vmbus_active = !hv_root_partition () || hv_nested; -/* Setup the Synic's message page */ +/* +* Map the SYNIC message page. When VMBus is not active the +* hypervisor pre-provisions the SIMP GPA but may not set +* simp_enabled — enable it here. +*/ simp.as_uint64 =hv_get_non_nested_msr (HV_MSR_SIMP ); - simp.simp_enabled = true; +if (!vmbus_active) { + simp.simp_enabled = true; +hv_set_non_nested_msr (HV_MSR_SIMP , simp.as_uint64); + } *msg_page =memremap (simp.base_simp_gpa <<HV_HYP_PAGE_SHIFT ,HV_HYP_PAGE_SIZE ,MEMREMAP_WB );if (!(*msg_page)) -return -EFAULT ; + goto cleanup_simp; -hv_set_non_nested_msr (HV_MSR_SIMP , simp.as_uint64); - -/* Setup the Synic's event flags page */ +/* +* Map the event flags page. Same as SIMP: enable when +* VMBus is not active, already enabled by VMBus otherwise. +*/ siefp.as_uint64 =hv_get_non_nested_msr (HV_MSR_SIEFP ); - siefp.siefp_enabled = true; +if (!vmbus_active) { + siefp.siefp_enabled = true; +hv_set_non_nested_msr (HV_MSR_SIEFP , siefp.as_uint64); + } *event_flags_page =memremap (siefp.base_siefp_gpa <<PAGE_SHIFT ,PAGE_SIZE ,MEMREMAP_WB );if (!(*event_flags_page)) - goto cleanup; - -hv_set_non_nested_msr (HV_MSR_SIEFP , siefp.as_uint64); + goto cleanup_siefp;/* Setup the Synic's event ring page */ sirbp.as_uint64 =hv_get_non_nested_msr (HV_MSR_SIRBP ); - sirbp.sirbp_enabled = true; - *event_ring_page =memremap (sirbp.base_sirbp_gpa <<PAGE_SHIFT , -PAGE_SIZE ,MEMREMAP_WB ); -if (!(*event_ring_page)) - goto cleanup; +if (hv_root_partition ()) {
drivers/hv/mshv_synic.c int mshv_synic_init(unsigned int cpu) · line 511
Quoted 10 lines
drivers/hv/mshv_synic.c +9
-0+ *event_ring_page =memremap (sirbp.base_sirbp_gpa <<PAGE_SHIFT , +PAGE_SIZE ,MEMREMAP_WB ); +if (!(*event_ring_page)) + goto cleanup_siefp; + }else { +/* +* On L1VH the hypervisor does not provide a SIRBP page. +* Allocate one and program its GPA into the MSR. +*/
How were things working before this?
Thanks,
Anirudh.
Quoted 144 lines
drivers/hv/mshv_synic.c +63
-32+ *event_ring_page = (struct hv_synic_event_ring_page *) +get_zeroed_page (GFP_KERNEL ); + +if (!(*event_ring_page)) + goto cleanup_siefp; + + sirbp.base_sirbp_gpa =virt_to_phys (*event_ring_page) + >>PAGE_SHIFT ; + } + + sirbp.sirbp_enabled = true;hv_set_non_nested_msr (HV_MSR_SIRBP , sirbp.as_uint64);#ifdef HYPERVISOR_CALLBACK_VECTOR @@ -515,28 +541,30 @@ int mshv_synic_init(unsigned int cpu) sint.as_uint64);#endif -/* Enable global synic bit */ - sctrl.as_uint64 =hv_get_non_nested_msr (HV_MSR_SCONTROL ); - sctrl.enable =1 ; -hv_set_non_nested_msr (HV_MSR_SCONTROL , sctrl.as_uint64); +/* When VMBus is active it already enabled SCONTROL. */ +if (!vmbus_active) { +union hv_synic_scontrol sctrl; + + sctrl.as_uint64 =hv_get_non_nested_msr (HV_MSR_SCONTROL ); + sctrl.enable =1 ; +hv_set_non_nested_msr (HV_MSR_SCONTROL , sctrl.as_uint64); + }return 0 ; -cleanup: -if (*event_ring_page) { - sirbp.sirbp_enabled = false; -hv_set_non_nested_msr (HV_MSR_SIRBP , sirbp.as_uint64); -memunmap (*event_ring_page); - } -if (*event_flags_page) { +cleanup_siefp: +if (*event_flags_page) +memunmap (*event_flags_page); +if (!vmbus_active) { siefp.siefp_enabled = false;hv_set_non_nested_msr (HV_MSR_SIEFP , siefp.as_uint64); -memunmap (*event_flags_page); } -if (*msg_page) { +cleanup_simp: +if (*msg_page) +memunmap (*msg_page); +if (!vmbus_active) { simp.simp_enabled = false;hv_set_non_nested_msr (HV_MSR_SIMP , simp.as_uint64); -memunmap (*msg_page); }return -EFAULT ;@@ -545,16 +573,15 @@ int mshv_synic_init(unsigned int cpu)int mshv_synic_cleanup (unsigned int cpu) {union hv_synic_sint sint; -union hv_synic_simp simp; -union hv_synic_siefp siefp;union hv_synic_sirbp sirbp; -union hv_synic_scontrol sctrl;struct hv_synic_pages *spages =this_cpu_ptr (mshv_root.synic_pages);struct hv_message_page **msg_page = &spages->hyp_synic_message_page;struct hv_synic_event_flags_page **event_flags_page = &spages->synic_event_flags_page;struct hv_synic_event_ring_page **event_ring_page = &spages->synic_event_ring_page; +/* VMBus runs on L1VH and nested root; it owns SIMP/SIEFP/SCONTROL */ +bool vmbus_active = !hv_root_partition () || hv_nested;/* Disable the interrupt */ sint.as_uint64 =hv_get_non_nested_msr (HV_MSR_SINT0 +HV_SYNIC_INTERCEPTION_SINT_INDEX );@@ -568,28 +595,47 @@ int mshv_synic_cleanup(unsigned int cpu)hv_set_non_nested_msr (HV_MSR_SINT0 +HV_SYNIC_DOORBELL_SINT_INDEX , sint.as_uint64); -/* Disable Synic's event ring page */ +/* Disable SYNIC event ring page owned by MSHV */ sirbp.as_uint64 =hv_get_non_nested_msr (HV_MSR_SIRBP ); sirbp.sirbp_enabled = false; -hv_set_non_nested_msr (HV_MSR_SIRBP , sirbp.as_uint64); -memunmap (*event_ring_page); -/* Disable Synic's event flags page */ - siefp.as_uint64 =hv_get_non_nested_msr (HV_MSR_SIEFP ); - siefp.siefp_enabled = false; -hv_set_non_nested_msr (HV_MSR_SIEFP , siefp.as_uint64); +if (hv_root_partition ()) { +hv_set_non_nested_msr (HV_MSR_SIRBP , sirbp.as_uint64); +memunmap (*event_ring_page); + }else { + sirbp.base_sirbp_gpa =0 ; +hv_set_non_nested_msr (HV_MSR_SIRBP , sirbp.as_uint64); +free_page ((unsigned long )*event_ring_page); + } + +/* +* Release our mappings of the message and event flags pages. +* When VMBus is not active, we enabled SIMP/SIEFP — disable +* them. Otherwise VMBus owns the MSRs — leave them. +*/ memunmap (*event_flags_page); +if (!vmbus_active) { +union hv_synic_simp simp; +union hv_synic_siefp siefp; -/* Disable Synic's message page */ - simp.as_uint64 =hv_get_non_nested_msr (HV_MSR_SIMP ); - simp.simp_enabled = false; -hv_set_non_nested_msr (HV_MSR_SIMP , simp.as_uint64); + siefp.as_uint64 =hv_get_non_nested_msr (HV_MSR_SIEFP ); + siefp.siefp_enabled = false; +hv_set_non_nested_msr (HV_MSR_SIEFP , siefp.as_uint64); + + simp.as_uint64 =hv_get_non_nested_msr (HV_MSR_SIMP ); + simp.simp_enabled = false; +hv_set_non_nested_msr (HV_MSR_SIMP , simp.as_uint64); + }memunmap (*msg_page); -/* Disable global synic bit */ - sctrl.as_uint64 =hv_get_non_nested_msr (HV_MSR_SCONTROL ); - sctrl.enable =0 ; -hv_set_non_nested_msr (HV_MSR_SCONTROL , sctrl.as_uint64); +/* When VMBus is active it owns SCONTROL — leave it. */ +if (!vmbus_active) { +union hv_synic_scontrol sctrl; + + sctrl.as_uint64 =hv_get_non_nested_msr (HV_MSR_SCONTROL ); + sctrl.enable =0 ; +hv_set_non_nested_msr (HV_MSR_SCONTROL , sctrl.as_uint64); + }return 0 ; }Signature · 1 line
2.43.0
PATCH v2 5/6 mshv: clean up SynIC state on kexec for L1VH
In reply to Jork LoeserRegister the mshv reboot notifier for all parent partitions, not just root. Previously the notifier was gated on hv_root_partition(), so on L1VH (where hv_root_partition() is false) SINT0, SINT5, and SIRBP were never cleaned up before kexec. The kexec'd kernel then inherited stale unmasked SINTs and an enabled SIRBP pointing to freed memory.
The L1VH SIRBP also needs special handling: unlike the root partition where the hypervisor provides the SIRBP page, L1VH must allocate its own page and program the GPA into the MSR. Add this allocation to mshv_synic_init() and the corresponding free to mshv_synic_cleanup().
Remove the unnecessary mshv_root_partition_init/exit wrappers and register the reboot notifier directly in mshv_parent_partition_init(). Make mshv_reboot_nb static since it no longer needs external linkage.
--- drivers/hv/mshv_root_main.c | 21 ++++----------------- 1 file changed, 4 insertions(+), 17 deletions(-)
drivers/hv/mshv_root_main.c +4 -17
@@ -2256,20 +2256,10 @@ static int mshv_reboot_notify(struct notifier_block *nb,return 0 ; } -struct notifier_block mshv_reboot_nb = { +static struct notifier_block mshv_reboot_nb = { .notifier_call = mshv_reboot_notify, }; -static void mshv_root_partition_exit (void ) -{ -unregister_reboot_notifier (&mshv_reboot_nb); -} - -static int __init mshv_root_partition_init (struct device *dev) -{ -return register_reboot_notifier (&mshv_reboot_nb); -} -static int __init mshv_init_vmm_caps (struct device *dev) {int ret;
@@ -2339,8 +2329,7 @@ static int __init mshv_parent_partition_init(void)if (ret) goto remove_cpu_state; -if (hv_root_partition ()) - ret =mshv_root_partition_init (dev); + ret =register_reboot_notifier (&mshv_reboot_nb);if (ret) goto remove_cpu_state;
@@ -2368,8 +2357,7 @@ static int __init mshv_parent_partition_init(void) deinit_root_scheduler:root_scheduler_deinit (); exit_partition: -if (hv_root_partition ()) -mshv_root_partition_exit (); +unregister_reboot_notifier (&mshv_reboot_nb); remove_cpu_state:cpuhp_remove_state (mshv_cpuhp_online); free_synic_pages:
@@ -2387,8 +2375,7 @@ static void __exit mshv_parent_partition_exit(void)misc_deregister (&mshv_dev);mshv_irqfd_wq_cleanup ();root_scheduler_deinit (); -if (hv_root_partition ()) -mshv_root_partition_exit (); +unregister_reboot_notifier (&mshv_reboot_nb);cpuhp_remove_state (mshv_cpuhp_online);free_percpu (mshv_root.synic_pages); }
Signature · 1 line
2.43.0
Re: [PATCH v2 5/6] mshv: clean up SynIC state on kexec for L1VH
Quoted 25 lines · Jork Loeser
Register the mshv reboot notifier for all parent partitions, not just root. Previously the notifier was gated on
hv_root_partition(), so on L1VH (wherehv_root_partition()is false) SINT0, SINT5, and SIRBP were never cleaned up before kexec. The kexec'd kernel then inherited stale unmasked SINTs and an enabled SIRBP pointing to freed memory.The L1VH SIRBP also needs special handling: unlike the root partition where the hypervisor provides the SIRBP page, L1VH must allocate its own page and program the GPA into the MSR. Add this allocation to
mshv_synic_init()and the corresponding free tomshv_synic_cleanup().Remove the unnecessary mshv_root_partition_init/exit wrappers and register the reboot notifier directly in
mshv_parent_partition_init(). Makemshv_reboot_nbstatic since it no longer needs external linkage.Signed-off-by Jork Loeser <[email protected]>--- drivers/hv/mshv_root_main.c | 21 ++++----------------- 1 file changed, 4 insertions(+), 17 deletions(-)drivers/hv/mshv_root_main.c +0
-0
drivers/hv/mshv_root_main.c static int mshv_reboot_notify(struct notifier_block *nb, · line 2259
Quoted 4 lines
drivers/hv/mshv_root_main.c +0
-1@@ -2256,20 +2256,10 @@ static int mshv_reboot_notify(struct notifier_block *nb,return 0 ; } -struct notifier_block mshv_reboot_nb = {
I believe this code has moved to mshv_synic.c in hyperv-fixes. So, this probably won't apply.
Thanks,
Anirudh.
Re: [PATCH v2 5/6] mshv: clean up SynIC state on kexec for L1VH
Quoted 2 lines · Anirudh Rayabharam
I believe this code has moved to
mshv_synic.cin hyperv-fixes. So, this probably won't apply.
Right, this needs a fix.
Best,
Jork
PATCH v2 6/6 mshv: unmap debugfs stats pages on kexec
In reply to Jork LoeserOn L1VH, debugfs stats pages are overlay pages: the kernel allocates them and registers the GPAs with the hypervisor via HVCALL_MAP_STATS_PAGE2. These overlay mappings persist in the hypervisor across kexec. If the kexec'd kernel reuses those physical pages, the hypervisor's overlay semantics cause a machine check exception.
Fix this by calling mshv_debugfs_exit() from the reboot notifier, which issues HVCALL_UNMAP_STATS_PAGE for each mapped stats page before kexec. This releases the overlay bindings so the physical pages can be safely reused. Guard mshv_debugfs_exit() against being called when init failed.
--- drivers/hv/mshv_debugfs.c | 7 ++++++- drivers/hv/mshv_root_main.c | 1 + 2 files changed, 7 insertions(+), 1 deletion(-)
drivers/hv/mshv_debugfs.c +6 -1
@@ -676,8 +676,10 @@ int __init mshv_debugfs_init(void) mshv_debugfs =debugfs_create_dir ("mshv" ,NULL );if (IS_ERR (mshv_debugfs)) { + err =PTR_ERR (mshv_debugfs); + mshv_debugfs =NULL ;pr_err ("%s: failed to create debugfs directory\n" , __func__); -return PTR_ERR (mshv_debugfs); +return err; }if (hv_root_partition ()) {
@@ -712,6 +714,9 @@ int __init mshv_debugfs_init(void)void mshv_debugfs_exit (void ) { +if (!mshv_debugfs) +return ; +mshv_debugfs_parent_partition_remove ();if (hv_root_partition ()) {
drivers/hv/mshv_root_main.c +1 -0
@@ -2252,6 +2252,7 @@ root_scheduler_deinit(void)static int mshv_reboot_notify (struct notifier_block *nb,unsigned long code,void *unused) { +mshv_debugfs_exit ();cpuhp_remove_state (mshv_cpuhp_online);return 0 ; }
Signature · 1 line
2.43.0
Re: [PATCH v2 6/6] mshv: unmap debugfs stats pages on kexec
Quoted 13 lines · Jork Loeser
On L1VH, debugfs stats pages are overlay pages: the kernel allocates them and registers the GPAs with the hypervisor via
HVCALL_MAP_STATS_PAGE2. These overlay mappings persist in the hypervisor across kexec. If the kexec'd kernel reuses those physical pages, the hypervisor's overlay semantics cause a machine check exception.Fix this by calling
mshv_debugfs_exit()from the reboot notifier, which issuesHVCALL_UNMAP_STATS_PAGEfor each mapped stats page before kexec. This releases the overlay bindings so the physical pages can be safely reused. Guardmshv_debugfs_exit()against being called when init failed.
Quoted 5 lines
Signed-off-by Jork Loeser <[email protected]>--- drivers/hv/mshv_debugfs.c | 7 ++++++- drivers/hv/mshv_root_main.c | 1 + 2 files changed, 7 insertions(+), 1 deletion(-)