Enable Linux guests on Hyper-V on ARM64
v4 cover Enable Linux guests on Hyper-V on ARM64
This series enables Linux guests running on Hyper-V on ARM64 hardware. New ARM64-specific code in arch/arm64/hyperv initializes Hyper-V, including its interrupts and hypercall mechanism. Existing architecture independent drivers for Hyper-V's VMbus and synthetic devices just work when built for ARM64. Hyper-V code is built and included in the image and modules only if CONFIG_HYPERV is enabled.
The eight patches are organized as follows:
1) Add include files that define the Hyper-V interface as described in the Hyper-V Top Level Functional Spec (TLFS), plus additional definitions specific to Linux running on Hyper-V.
2 thru 6) Add core Hyper-V support on ARM64, including hypercalls,
interrupt handlers, kexec & panic handlers, and core hypervisor initialization.
7) Update the existing VMbus driver to generalize interrupt management across x86/x64 and ARM64.
8) Make CONFIG_HYPERV selectable on ARM64 in addition to x86/x64.
Some areas of Linux guests on Hyper-V on ARM64 are a work- in-progress:
* Hyper-V on ARM64 currently runs with a 4 Kbyte page size, but allows guests with 16K/64K page size. However, the Linux drivers for Hyper-V synthetic devices assume the guest page size is 4K. This patch set lays the groundwork for larger guest page sizes, but the main changes are in a different patch stream that is underway to update these drivers.
* The Hyper-V vPCI driver at drivers/pci/host/pci-hyperv.c has x86/x64-specific code and is not being built for ARM64. Fixing this driver to enable vPCI devices on ARM64 will be done later.
In a few cases, terminology from the x86/x64 world has been carried over into the ARM64 code ("MSR", "TSC"). Hyper-V still uses the x86/x64 terminology and has not replaced it with something more generic, so the code uses the Hyper-V terminology. This will be fixed when Hyper-V updates the usage in the TLFS.
This patch set is built against a 5.3.0-rc2-next-20190731 tree.
Changes in v4:
* Moved clock-related code into an architecture independent Hyper-V clocksource driver that is already upstream. Clock related code is removed from this patch set except for the ARM64 specific interrupt handler. [Marc Zyngier]
* Separately upstreamed the split of mshyperv.h into arch independent and arch dependent portions. The arch independent portion has been removed from this patch set.
* Divided patch #2 of the series into multiple smaller patches [Marc Zyngier]
* Changed a dozen or so smaller things based on feedback [Marc Zyngier, Will Deacon]
* Added functions to alloc/free Hyper-V size pages. These are for use by drivers for Hyper-V synthetic devices when they are updated to handle guest page size != Hyper-V page size
Changes in v3:
* Added initialization of hv_vp_index array like was recently added on x86 branch [KY Srinivasan]
* Changed Hyper-V ARM64 register symbols to be all uppercase instead of mixed case [KY Srinivasan]
* Separated mshyperv.h into two files, one architecture independent and one architecture dependent. After this code is upstream, will make changes to the x86 code to use the architecture independent file and remove duplication. And once we have a multi-architecture Hyper-V TLFS, will do a separate patch to split hyperv-tlfs.h in the same way. [KY Srinivasan]
* Minor tweaks to rebase to latest linux-next code
Changes in v2:
* Removed patch to implement slow_virt_to_phys() on ARM64. Use of slow_virt_to_phys() in arch independent Hyper-V drivers has been eliminated by commit 6ba34171bcbd ("Drivers: hv: vmbus: Remove use of slow_virt_to_phys()")
* Minor tweaks to rebase to latest linux-next code
Michael Kelley (8):
arm64: hyperv: Add core Hyper-V include files
arm64: hyperv: Add hypercall and register access functions
arm64: hyperv: Add memory alloc/free functions for Hyper-V size pages
arm64: hyperv: Add interrupt handlers for VMbus and stimer
arm64: hyperv: Add kexec and panic handlers
arm64: hyperv: Initialize hypervisor on boot
Drivers: hv: vmbus: Add hooks for per-CPU IRQ
Drivers: hv: Enable Hyper-V code to be built on ARM64
MAINTAINERS | 3 + arch/arm64/Makefile | 1 + arch/arm64/hyperv/Makefile | 2 + arch/arm64/hyperv/hv_hvc.S | 44 ++++ arch/arm64/hyperv/hv_init.c | 404 ++++++++++++++++++++++++++++++++++ arch/arm64/hyperv/mshyperv.c | 165 ++++++++++++++ arch/arm64/include/asm/hyperv-tlfs.h | 408 +++++++++++++++++++++++++++++++++++ arch/arm64/include/asm/mshyperv.h | 105 +++++++++ arch/x86/include/asm/mshyperv.h | 4 + drivers/hv/Kconfig | 5 +- drivers/hv/hv.c | 2 + include/asm-generic/mshyperv.h | 5 + 12 files changed, 1146 insertions(+), 2 deletions(-) create mode 100644 arch/arm64/hyperv/Makefile create mode 100644 arch/arm64/hyperv/hv_hvc.S create mode 100644 arch/arm64/hyperv/hv_init.c create mode 100644 arch/arm64/hyperv/mshyperv.c create mode 100644 arch/arm64/include/asm/hyperv-tlfs.h create mode 100644 arch/arm64/include/asm/mshyperv.h
Signature · 7 lines
1.8.3.1 _______________________________________________ linux-arm-kernel mailing list [email protected] http://lists.infradead.org/mailman/listinfo/linux-arm-kernel
PATCH v4 1/8 arm64: hyperv: Add core Hyper-V include files
hyperv-tlfs.h defines Hyper-V interfaces from the Hyper-V Top Level Functional Spec (TLFS). The TLFS is distinctly oriented to x86/x64, and Hyper-V has not separated out the architecture-dependent parts into x86/x64 vs. ARM64. So hyperv-tlfs.h includes information for ARM64 that is not yet formally published. The TLFS is available here:
docs.microsoft.com/en-us/virtualization/hyper-v-on-windows/reference/tlfs
mshyperv.h defines Linux-specific structures and routines for interacting with Hyper-V on ARM64, and #includes the architecture- independent part of mshyperv.h in include/asm-generic.
--- MAINTAINERS | 2 + arch/arm64/include/asm/hyperv-tlfs.h | 408 +++++++++++++++++++++++++++++++++++ arch/arm64/include/asm/mshyperv.h | 105 +++++++++ 3 files changed, 515 insertions(+) create mode 100644 arch/arm64/include/asm/hyperv-tlfs.h create mode 100644 arch/arm64/include/asm/mshyperv.h
MAINTAINERS +2 -0
@@ -7486,6 +7486,8 @@ F: arch/x86/include/asm/trace/hyperv.h F: arch/x86/include/asm/hyperv-tlfs.h F: arch/x86/kernel/cpu/mshyperv.c F: arch/x86/hyperv +F: arch/arm64/include/asm/hyperv-tlfs.h +F: arch/arm64/include/asm/mshyperv.h F: drivers/clocksource/hyperv_timer.c F: drivers/hid/hid-hyperv.c F: drivers/hv/
arch/arm64/include/asm/hyperv-tlfs.h new file +408 -0
408 lines not on this page · raw message
arch/arm64/include/asm/mshyperv.h new file +105 -0
105 lines not on this page · raw message
Signature · 7 lines
1.8.3.1 _______________________________________________ linux-arm-kernel mailing list [email protected] http://lists.infradead.org/mailman/listinfo/linux-arm-kernel
PATCH v4 2/8 arm64: hyperv: Add hypercall and register access functions
In reply to Michael KelleyAdd ARM64-specific code to make Hyper-V hypercalls and to access virtual processor synthetic registers via hypercalls. Hypercalls use a Hyper-V specific calling sequence with a non-zero immediate value per Section 2.9 of the SMC Calling Convention spec.
This code is architecture dependent and is mostly driven by architecture independent code in the VMbus driver and the Hyper-V timer clocksource driver.
This code is built only when CONFIG_HYPERV is enabled.
--- MAINTAINERS | 1 + arch/arm64/Makefile | 1 + arch/arm64/hyperv/Makefile | 2 + arch/arm64/hyperv/hv_hvc.S | 44 +++++++++++++++ arch/arm64/hyperv/hv_init.c | 133 ++++++++++++++++++++++++++++++++++++++++++++ 5 files changed, 181 insertions(+) create mode 100644 arch/arm64/hyperv/Makefile create mode 100644 arch/arm64/hyperv/hv_hvc.S create mode 100644 arch/arm64/hyperv/hv_init.c
MAINTAINERS +1 -0
@@ -7488,6 +7488,7 @@ F: arch/x86/kernel/cpu/mshyperv.c F: arch/x86/hyperv F: arch/arm64/include/asm/hyperv-tlfs.h F: arch/arm64/include/asm/mshyperv.h +F: arch/arm64/hyperv F: drivers/clocksource/hyperv_timer.c F: drivers/hid/hid-hyperv.c F: drivers/hv/
arch/arm64/Makefile +1 -0
@@ -140,6 +140,7 @@ core-y += arch/arm64/kernel/ arch/arm64/mm/ core-$(CONFIG_NET) += arch/arm64/net/ core-$(CONFIG_KVM) += arch/arm64/kvm/ core-$(CONFIG_XEN) += arch/arm64/xen/ +core-$(CONFIG_HYPERV) += arch/arm64/hyperv/ core-$(CONFIG_CRYPTO) += arch/arm64/crypto/ libs-y := arch/arm64/lib/ $(libs-y) core-$(CONFIG_EFI_STUB) += $(objtree)/drivers/firmware/efi/libstub/lib.a
arch/arm64/hyperv/Makefile new file +2 -0
@@ -0,0 +1,2 @@ +# SPDX-License-Identifier: GPL-2.0 +obj-y := hv_init.o hv_hvc.o
arch/arm64/hyperv/hv_hvc.S new file +44 -0
44 lines not on this page · raw message
arch/arm64/hyperv/hv_init.c new file +133 -0
133 lines not on this page · raw message
Signature · 7 lines
1.8.3.1 _______________________________________________ linux-arm-kernel mailing list [email protected] http://lists.infradead.org/mailman/listinfo/linux-arm-kernel
PATCH v4 3/8 arm64: hyperv: Add memory alloc/free functions for Hyper-V size pages
In reply to Michael KelleyAdd ARM64-specific code to allocate memory with HV_HYP_PAGE_SIZE size and alignment. These are for use when pages need to be shared with Hyper-V. Separate functions are needed as the page size used by Hyper-V may not be the same as the guest page size. Free operations are rarely done, so no attempt is made to combine freed pages into larger chunks.
This code is built only when CONFIG_HYPERV is enabled.
--- arch/arm64/hyperv/hv_init.c | 68 ++++++++++++++++++++++++++++++++++++++++++ include/asm-generic/mshyperv.h | 5 ++++ 2 files changed, 73 insertions(+)
arch/arm64/hyperv/hv_init.c +68 -0
@@ -15,10 +15,78 @@#include <linux/export.h> #include <linux/mm.h> #include <linux/hyperv.h> +#include <linux/spinlock.h> +#include <linux/list.h> +#include <linux/string.h> #include <asm-generic/bug.h> #include <asm/hyperv-tlfs.h> #include <asm/mshyperv.h> + +/* +* Functions for allocating and freeing memory with size and +* alignment HV_HYP_PAGE_SIZE. These functions are needed because +* the guest page size may not be the same as the Hyper-V page +* size. And while kalloc() could allocate the memory, it does not +* guarantee the required alignment. So a separate small memory +* allocator is needed. The free function is rarely used, so it +* does not try to combine freed pages into larger chunks. +* +* These functions are used by arm64 specific code as well as +* arch independent Hyper-V drivers. +*/ + +static DEFINE_SPINLOCK (free_list_lock); +static struct list_head free_list =LIST_HEAD_INIT (free_list); + +void *hv_alloc_hyperv_page (void ) +{ +int i; +struct list_head *hv_page; +unsigned long addr; + +BUILD_BUG_ON (HV_HYP_PAGE_SIZE >PAGE_SIZE ); + +spin_lock (&free_list_lock); +if (list_empty (&free_list)) { +spin_unlock (&free_list_lock); + addr =__get_free_page (GFP_KERNEL ); +spin_lock (&free_list_lock); +for (i =0 ; i <PAGE_SIZE ; i +=HV_HYP_PAGE_SIZE ) +list_add_tail ((struct list_head *)(addr + i), + &free_list); + } + hv_page = free_list.next; +list_del (hv_page); +spin_unlock (&free_list_lock); + +return hv_page; +} +EXPORT_SYMBOL_GPL (hv_alloc_hyperv_page); + +void *hv_alloc_hyperv_zeroed_page (void ) +{ +void *memp; + + memp =hv_alloc_hyperv_page (); +memset (memp,0 ,HV_HYP_PAGE_SIZE ); + +return memp; +} +EXPORT_SYMBOL_GPL (hv_alloc_hyperv_zeroed_page); + + +void hv_free_hyperv_page (unsigned long addr) +{ +if (!addr) +return ; +spin_lock (&free_list_lock); +list_add ((struct list_head *)addr, &free_list); +spin_unlock (&free_list_lock); +} +EXPORT_SYMBOL_GPL (hv_free_hyperv_page); + +/* * hv_do_hypercall- Invoke the specified hypercall */
include/asm-generic/mshyperv.h +5 -0
@@ -99,6 +99,11 @@ static inline void vmbus_signal_eom(struct hv_message *msg, u32 old_msg_type)void hv_setup_crash_handler (void (*handler)(struct pt_regs *regs));void hv_remove_crash_handler (void ); +void *hv_alloc_hyperv_page (void ); +void *hv_alloc_hyperv_zeroed_page (void ); +void hv_free_hyperv_page (unsigned long addr); + +#if IS_ENABLED (CONFIG_HYPERV )/* * Hypervisor's notion of virtual processor ID is different from
Signature · 7 lines
1.8.3.1 _______________________________________________ linux-arm-kernel mailing list [email protected] http://lists.infradead.org/mailman/listinfo/linux-arm-kernel
PATCH v4 4/8 arm64: hyperv: Add interrupt handlers for VMbus and stimer
In reply to Michael KelleyAdd ARM64-specific code to set up and handle the interrupts generated by Hyper-V for VMbus messages and for stimer expiration.
This code is architecture dependent and is mostly driven by architecture independent code in the VMbus driver and the Hyper-V timer clocksource driver.
This code is built only when CONFIG_HYPERV is enabled.
--- arch/arm64/hyperv/Makefile | 2 +- arch/arm64/hyperv/mshyperv.c | 139 +++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 140 insertions(+), 1 deletion(-) create mode 100644 arch/arm64/hyperv/mshyperv.c
arch/arm64/hyperv/Makefile +1 -1
@@ -1,2 +1,2 @@ # SPDX-License-Identifier: GPL-2.0 -obj-y := hv_init.o hv_hvc.o +obj-y := hv_init.o hv_hvc.o mshyperv.o
arch/arm64/hyperv/mshyperv.c new file +139 -0
139 lines not on this page · raw message
Signature · 7 lines
1.8.3.1 _______________________________________________ linux-arm-kernel mailing list [email protected] http://lists.infradead.org/mailman/listinfo/linux-arm-kernel
PATCH v4 5/8 arm64: hyperv: Add kexec and panic handlers
In reply to Michael KelleyAdd functions to set up and remove kexec and panic handlers, and to inform Hyper-V about a guest panic. These functions are called from architecture independent code in the VMbus driver.
This code is built only when CONFIG_HYPERV is enabled.
--- arch/arm64/hyperv/hv_init.c | 61 ++++++++++++++++++++++++++++++++++++++++++++ arch/arm64/hyperv/mshyperv.c | 26 +++++++++++++++++++ 2 files changed, 87 insertions(+)
arch/arm64/hyperv/hv_init.c +61 -0
@@ -199,3 +199,64 @@ void hv_get_vpreg_128(u32 msr, struct hv_get_vp_register_output *result) }EXPORT_SYMBOL_GPL (hv_get_vpreg_128); + +void hyperv_report_panic (struct pt_regs *regs,long err) +{ +static bool panic_reported; +u64 guest_id; + +/* +* We prefer to report panic on 'die' chain as we have proper +* registers to report, but if we miss it (e.g. on BUG()) we need +* to report it on 'panic'. +*/ +if (panic_reported) +return ; + panic_reported = true; + + guest_id =hv_get_vpreg (HV_REGISTER_GUEST_OSID ); + +/* +* Hyper-V provides the ability to store only 5 values. +* Pick the passed in error value, the guest_id, and the PC. +* The first two general registers are added arbitrarily. +*/ +hv_set_vpreg (HV_REGISTER_CRASH_P0 , err); +hv_set_vpreg (HV_REGISTER_CRASH_P1 , guest_id); +hv_set_vpreg (HV_REGISTER_CRASH_P2 , regs->pc); +hv_set_vpreg (HV_REGISTER_CRASH_P3 , regs->regs[0 ]); +hv_set_vpreg (HV_REGISTER_CRASH_P4 , regs->regs[1 ]); + +/* +* Let Hyper-V know there is crash data available +*/ +hv_set_vpreg (HV_REGISTER_CRASH_CTL ,HV_CRASH_CTL_CRASH_NOTIFY ); +} +EXPORT_SYMBOL_GPL (hyperv_report_panic); + +/* +* hyperv_report_panic_msg - report panic message to Hyper-V +* @pa: physical address of the panic page containing the message +* @size: size of the message in the page +*/ +void hyperv_report_panic_msg (phys_addr_t pa,size_t size) +{ +/* +* P3 to contain the physical address of the panic page & P4 to +* contain the size of the panic data in that page. Rest of the +* registers are no-op when the NOTIFY_MSG flag is set. +*/ +hv_set_vpreg (HV_REGISTER_CRASH_P0 ,0 ); +hv_set_vpreg (HV_REGISTER_CRASH_P1 ,0 ); +hv_set_vpreg (HV_REGISTER_CRASH_P2 ,0 ); +hv_set_vpreg (HV_REGISTER_CRASH_P3 , pa); +hv_set_vpreg (HV_REGISTER_CRASH_P4 , size); + +/* +* Let Hyper-V know there is crash data available along with +* the panic message. +*/ +hv_set_vpreg (HV_REGISTER_CRASH_CTL , + (HV_CRASH_CTL_CRASH_NOTIFY |HV_CRASH_CTL_CRASH_NOTIFY_MSG )); +} +EXPORT_SYMBOL_GPL (hyperv_report_panic_msg);
arch/arm64/hyperv/mshyperv.c +26 -0
@@ -23,6 +23,8 @@static void (*vmbus_handler)(void );static void (*hv_stimer0_handler)(void ); +static void (*hv_kexec_handler)(void ); +static void (*hv_crash_handler)(struct pt_regs *regs);static int vmbus_irq;static long __percpu *vmbus_evt;
@@ -137,3 +139,27 @@ void hv_remove_stimer0_irq(int irq) } }EXPORT_SYMBOL_GPL (hv_remove_stimer0_irq); + +void hv_setup_kexec_handler (void (*handler)(void )) +{ + hv_kexec_handler = handler; +} +EXPORT_SYMBOL_GPL (hv_setup_kexec_handler); + +void hv_remove_kexec_handler (void ) +{ + hv_kexec_handler =NULL ; +} +EXPORT_SYMBOL_GPL (hv_remove_kexec_handler); + +void hv_setup_crash_handler (void (*handler)(struct pt_regs *regs)) +{ + hv_crash_handler = handler; +} +EXPORT_SYMBOL_GPL (hv_setup_crash_handler); + +void hv_remove_crash_handler (void ) +{ + hv_crash_handler =NULL ; +} +EXPORT_SYMBOL_GPL (hv_remove_crash_handler);
Signature · 7 lines
1.8.3.1 _______________________________________________ linux-arm-kernel mailing list [email protected] http://lists.infradead.org/mailman/listinfo/linux-arm-kernel
PATCH v4 6/8 arm64: hyperv: Initialize hypervisor on boot
In reply to Michael KelleyAdd ARM64-specific code to initialize the Hyper-V hypervisor when booting as a guest VM. Provide functions and data structures indicating hypervisor status that are needed by VMbus driver.
This code is built only when CONFIG_HYPERV is enabled.
--- arch/arm64/hyperv/hv_init.c | 142 ++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 142 insertions(+)
arch/arm64/hyperv/hv_init.c +142 -0
@@ -13,15 +13,47 @@#include <linux/types.h> #include <linux/version.h> #include <linux/export.h> +#include <linux/vmalloc.h> #include <linux/mm.h> +#include <linux/acpi.h> +#include <linux/module.h> #include <linux/hyperv.h> #include <linux/spinlock.h> #include <linux/list.h> #include <linux/string.h> +#include <linux/slab.h> +#include <linux/cpuhotplug.h> +#include <linux/psci.h> #include <asm-generic/bug.h> #include <asm/hyperv-tlfs.h> #include <asm/mshyperv.h> +#include <asm/sysreg.h> +#include <clocksource/hyperv_timer.h> +static bool hyperv_initialized; + +struct ms_hyperv_info ms_hyperv__ro_after_init ; +EXPORT_SYMBOL_GPL (ms_hyperv); + +u32 *hv_vp_index; +EXPORT_SYMBOL_GPL (hv_vp_index); + +u32 hv_max_vp_index; +EXPORT_SYMBOL_GPL (hv_max_vp_index); + +static int hv_cpu_init (unsigned int cpu) +{ +u64 msr_vp_index; + +hv_get_vp_index (msr_vp_index); + + hv_vp_index[smp_processor_id ()] = msr_vp_index; + +if (msr_vp_index > hv_max_vp_index) + hv_max_vp_index = msr_vp_index; + +return 0 ; +}/* * Functions for allocating and freeing memory with size and
@@ -88,6 +120,110 @@ void hv_free_hyperv_page(unsigned long addr)/* +* This function is invoked via the ACPI clocksource probe mechanism. We +* don't actually use any values from the ACPI GTDT table, but we set up +* the Hyper-V synthetic clocksource and do other initialization for +* interacting with Hyper-V the first time. Using early_initcall to invoke +* this function is too late because interrupts are already enabled at that +* point, and hv_init_clocksource() must run before interrupts are enabled. +* +* 1. Setup the guest ID. +* 2. Get features and hints info from Hyper-V +* 3. Setup per-cpu VP indices. +* 4. Initialize the Hyper-V clocksource. +*/ + +static int __init hyperv_init (struct acpi_table_header *table) +{ +struct hv_get_vp_register_output result; +u32 a, b, c, d; +u64 guest_id; +int i; + +/* +* If we're in a VM on Hyper-V, the ACPI hypervisor_id field will +* have the string "MsHyperV". +*/ +if (strncmp ((char *)&acpi_gbl_FADT.hypervisor_id,"MsHyperV" ,8 )) +return -EINVAL ; + +/* Setup the guest ID */ + guest_id =generate_guest_id (0 ,LINUX_VERSION_CODE ,0 ); +hv_set_vpreg (HV_REGISTER_GUEST_OSID , guest_id); + +/* Get the features and hints from Hyper-V */ +hv_get_vpreg_128 (HV_REGISTER_PRIVILEGES_AND_FEATURES , &result); + ms_hyperv.features =lower_32_bits (result.registervaluelow); + ms_hyperv.misc_features =upper_32_bits (result.registervaluehigh); + +hv_get_vpreg_128 (HV_REGISTER_FEATURES , &result); + ms_hyperv.hints =lower_32_bits (result.registervaluelow); + +pr_info ("Hyper-V: Features 0x%x, hints 0x%x\n" , + ms_hyperv.features, ms_hyperv.hints); + +/* +* Direct mode is the only option for STIMERs provided Hyper-V +* on ARM64, so Hyper-V doesn't actually set the flag. But add +* the flag so the architecture independent code in +* drivers/clocksource/hyperv_timer.c will correctly use that mode. +*/ + ms_hyperv.misc_features |=HV_STIMER_DIRECT_MODE_AVAILABLE ; + +/* +* Hyper-V on ARM64 doesn't support AutoEOI. Add the hint +* that tells architecture independent code not to use this +* feature. +*/ + ms_hyperv.hints |=HV_DEPRECATING_AEOI_RECOMMENDED ; + +/* Get information about the Hyper-V host version */ +hv_get_vpreg_128 (HV_REGISTER_HYPERVISOR_VERSION , &result); + a =lower_32_bits (result.registervaluelow); + b =upper_32_bits (result.registervaluelow); + c =lower_32_bits (result.registervaluehigh); + d =upper_32_bits (result.registervaluehigh); +pr_info ("Hyper-V: Host Build %d.%d.%d.%d-%d-%d\n" , + b >>16 , b &0xFFFF , a, d &0xFFFFFF , c, d >>24 ); + +/* Allocate and initialize percpu VP index array */ + hv_vp_index =kmalloc_array (num_possible_cpus (),sizeof (*hv_vp_index), +GFP_KERNEL ); +if (!hv_vp_index) +return -ENOMEM ; + +for (i =0 ; i <num_possible_cpus (); i++) + hv_vp_index[i] =VP_INVAL ; + +if (cpuhp_setup_state (CPUHP_AP_ONLINE_DYN ,"arm64/hyperv_init:online" , + hv_cpu_init,NULL ) <0 ) + goto free_vp_index; + +hv_init_clocksource (); + + hyperv_initialized = true; +return 0 ; + +free_vp_index: +kfree (hv_vp_index); + hv_vp_index =NULL ; +return -EINVAL ; +} +TIMER_ACPI_DECLARE (hyperv,ACPI_SIG_GTDT , hyperv_init); + +/* +* This routine is called before kexec/kdump, it does the required cleanup. +*/ +void hyperv_cleanup (void ) +{ +/* Reset our OS id */ +hv_set_vpreg (HV_REGISTER_GUEST_OSID ,0 ); + +} +EXPORT_SYMBOL_GPL (hyperv_cleanup); + + +/* * hv_do_hypercall- Invoke the specified hypercall */ u64 hv_do_hypercall (u64 control,void *input,void *output)
@@ -260,3 +396,9 @@ void hyperv_report_panic_msg(phys_addr_t pa, size_t size) (HV_CRASH_CTL_CRASH_NOTIFY | HV_CRASH_CTL_CRASH_NOTIFY_MSG)); }EXPORT_SYMBOL_GPL (hyperv_report_panic_msg); + +bool hv_is_hyperv_initialized (void ) +{ +return hyperv_initialized; +} +EXPORT_SYMBOL_GPL (hv_is_hyperv_initialized);
Signature · 7 lines
1.8.3.1 _______________________________________________ linux-arm-kernel mailing list [email protected] http://lists.infradead.org/mailman/listinfo/linux-arm-kernel
PATCH v4 7/8 Drivers: hv: vmbus: Add hooks for per-CPU IRQ
In reply to Michael KelleyAdd hooks to enable/disable a per-CPU IRQ for VMbus. These hooks are in the architecture independent setup and shutdown paths for Hyper-V, and are needed by Linux guests on Hyper-V on ARM64. The x86/x64 implementation is null because VMbus interrupts on x86/x64 don't use an IRQ.
--- arch/x86/include/asm/mshyperv.h | 4 ++++ drivers/hv/hv.c | 2 ++ 2 files changed, 6 insertions(+)
arch/x86/include/asm/mshyperv.h +4 -0
@@ -56,6 +56,10 @@ typedef int (*hyperv_fill_flush_list_func)(#endif void hyperv_vector_handler (struct pt_regs *regs); +/* On x86/x64, there isn't a real IRQ to be enabled/disable */ +static inline void hv_enable_vmbus_irq (void ) {} +static inline void hv_disable_vmbus_irq (void ) {} +/* * Routines for stimer0 Direct Mode handling. * On x86/x64, there are no percpu actions to take.
drivers/hv/hv.c +2 -0
@@ -180,6 +180,7 @@ int hv_synic_init(unsigned int cpu)hv_set_siefp (siefp.as_uint64);/* Setup the shared SINT. */ +hv_enable_vmbus_irq ();hv_get_synint_state (VMBUS_MESSAGE_SINT , shared_sint.as_uint64); shared_sint.vector =HYPERVISOR_CALLBACK_VECTOR ;
@@ -272,6 +273,7 @@ int hv_synic_cleanup(unsigned int cpu)/* Disable the global synic bit */ sctrl.enable =0 ;hv_set_synic_state (sctrl.as_uint64); +hv_disable_vmbus_irq ();return 0 ; }
Signature · 7 lines
1.8.3.1 _______________________________________________ linux-arm-kernel mailing list [email protected] http://lists.infradead.org/mailman/listinfo/linux-arm-kernel
PATCH v4 8/8 Drivers: hv: Enable Hyper-V code to be built on ARM64
In reply to Michael KelleyUpdate drivers/hv/Kconfig so CONFIG_HYPERV and CONFIG_HYPERV_TSCPAGE can be selected on ARM64, causing the Hyper-V specific code to be built.
--- drivers/hv/Kconfig | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-)
drivers/hv/Kconfig +3 -2
@@ -4,7 +4,8 @@ menu "Microsoft Hyper-V guest support" config HYPERV tristate "Microsoft Hyper-V client drivers" - depends on X86 && ACPI && X86_LOCAL_APIC && HYPERVISOR_GUEST + depends on ACPI && \ + ((X86 && X86_LOCAL_APIC && HYPERVISOR_GUEST) || ARM64) select PARAVIRT select X86_HV_CALLBACK_VECTOR help
@@ -15,7 +16,7 @@ config HYPERV_TIMER def_bool HYPERV config HYPERV_TSCPAGE - def_bool HYPERV && X86_64 + def_bool HYPERV && (X86_64 || ARM64) config HYPERV_UTILS tristate "Microsoft Hyper-V Utilities driver"
Signature · 7 lines
1.8.3.1 _______________________________________________ linux-arm-kernel mailing list [email protected] http://lists.infradead.org/mailman/listinfo/linux-arm-kernel
From: Michael Kelley <[email protected]> Sent: Tuesday, August 6, 2019 1:31 PM
Quoted 14 lines
This series enables Linux guests running on Hyper-V on ARM64 hardware. New ARM64-specific code in
arch/arm64/hypervinitializes Hyper-V, including its interrupts and hypercall mechanism. Existing architecture independent drivers for Hyper-V's VMbus and synthetic devices just work when built for ARM64. Hyper-V code is built and included in the image and modules only ifCONFIG_HYPERVis enabled.The eight patches are organized as follows:
1) Add include files that define the Hyper-V interface as described in the Hyper-V Top Level Functional Spec (TLFS), plus additional definitions specific to Linux running on Hyper-V.
Quoted 9 lines
2 thru 6) Add core Hyper-V support on ARM64, including hypercalls,
interrupt handlers, kexec & panic handlers, and core hypervisor initialization.7) Update the existing VMbus driver to generalize interrupt management across x86/x64 and ARM64.
8) Make
CONFIG_HYPERVselectable on ARM64 in addition to x86/x64.
I'm hoping to get some feedback from the ARM64 maintainers on this series. Previous feedback has been incorporated, so it should be close to being able to go in.
Michael
_______________________________________________
linux-arm-kernel mailing list
[email protected]
http://lists.infradead.org/mailman/listinfo/linux-arm-kernel