// SPDX-License-Identifier: GPL-2.0-only/* * HyperV  Detection code. * * Copyright (C) 2010, Novell, Inc. * Author : K. Y. Srinivasan <ksrinivasan@novell.com> */ #include <linux/types.h>#include <linux/time.h>#include <linux/clocksource.h>#include <linux/init.h>#include <linux/export.h>#include <linux/hardirq.h>#include <linux/efi.h>#include <linux/interrupt.h>#include <linux/irq.h>#include <linux/kexec.h>#include <linux/random.h>#include <asm/processor.h>#include <asm/hypervisor.h>#include <asm/cpuid/api.h>#include <hyperv/hvhdk.h>#include <asm/mshyperv.h>#include <asm/desc.h>#include <asm/idtentry.h>#include <asm/irq_regs.h>#include <asm/i8259.h>#include <asm/apic.h>#include <asm/timer.h>#include <asm/reboot.h>#include <asm/msr.h>#include <asm/nmi.h>#include <clocksource/hyperv_timer.h>#include <asm/numa.h>#include <asm/svm.h> /* Is Linux running on nested Microsoft Hypervisor */bool hv_nested;struct ms_hyperv_info ms_hyperv; #if IS_ENABLED(CONFIG_HYPERV)/* * When running with the paravisor, controls proxying the synthetic interrupts * from the host */static bool hv_para_sint_proxy; static inline unsigned int hv_get_nested_msr(unsigned int reg){	if (hv_is_sint_msr(reg))		return reg - HV_X64_MSR_SINT0 + HV_X64_MSR_NESTED_SINT0; 	switch (reg) {	case HV_X64_MSR_SIMP:		return HV_X64_MSR_NESTED_SIMP;	case HV_X64_MSR_SIEFP:		return HV_X64_MSR_NESTED_SIEFP;	case HV_X64_MSR_SVERSION:		return HV_X64_MSR_NESTED_SVERSION;	case HV_X64_MSR_SCONTROL:		return HV_X64_MSR_NESTED_SCONTROL;	case HV_X64_MSR_EOM:		return HV_X64_MSR_NESTED_EOM;	default:		return reg;	}} u64 hv_get_non_nested_msr(unsigned int reg){	u64 value; 	if (hv_is_synic_msr(reg) && ms_hyperv.paravisor_present)		hv_ivm_msr_read(reg, &value);	else		rdmsrq(reg, value);	return value;}EXPORT_SYMBOL_GPL(hv_get_non_nested_msr); void hv_set_non_nested_msr(unsigned int reg, u64 value){	if (hv_is_synic_msr(reg) && ms_hyperv.paravisor_present) {		/* The hypervisor will get the intercept. */		hv_ivm_msr_write(reg, value); 		/* Using wrmsrq so the following goes to the paravisor. */		if (hv_is_sint_msr(reg)) {			union hv_synic_sint sint = { .as_uint64 = value }; 			sint.proxy = hv_para_sint_proxy;			native_wrmsrq(reg, sint.as_uint64);		}	} else {		native_wrmsrq(reg, value);	}}EXPORT_SYMBOL_GPL(hv_set_non_nested_msr); /* * Enable or disable proxying synthetic interrupts * to the paravisor. */void hv_para_set_sint_proxy(bool enable){	hv_para_sint_proxy = enable;} /* * Get the SynIC register value from the paravisor. */u64 hv_para_get_synic_register(unsigned int reg){	if (WARN_ON(!ms_hyperv.paravisor_present || !hv_is_synic_msr(reg)))		return ~0ULL;	return native_read_msr(reg);} /* * Set the SynIC register value with the paravisor. */void hv_para_set_synic_register(unsigned int reg, u64 val){	if (WARN_ON(!ms_hyperv.paravisor_present || !hv_is_synic_msr(reg)))		return;	native_write_msr(reg, val);} u64 hv_get_msr(unsigned int reg){	if (hv_nested)		reg = hv_get_nested_msr(reg); 	return hv_get_non_nested_msr(reg);}EXPORT_SYMBOL_GPL(hv_get_msr); void hv_set_msr(unsigned int reg, u64 value){	if (hv_nested)		reg = hv_get_nested_msr(reg); 	hv_set_non_nested_msr(reg, value);}EXPORT_SYMBOL_GPL(hv_set_msr); static void (*mshv_handler)(void);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); DEFINE_IDTENTRY_SYSVEC(sysvec_hyperv_callback){	struct pt_regs *old_regs = set_irq_regs(regs); 	inc_irq_stat(HYPERVISOR_CALLBACK);	if (mshv_handler)		mshv_handler(); 	if (vmbus_handler)		vmbus_handler(); 	add_interrupt_randomness(HYPERVISOR_CALLBACK_VECTOR); 	if (ms_hyperv.hints & HV_DEPRECATING_AEOI_RECOMMENDED)		apic_eoi(); 	set_irq_regs(old_regs);} void hv_setup_mshv_handler(void (*handler)(void)){	mshv_handler = handler;} void hv_setup_vmbus_handler(void (*handler)(void)){	vmbus_handler = handler;} void hv_remove_vmbus_handler(void){	/* We have no way to deallocate the interrupt gate */	vmbus_handler = NULL;} /* * Routines to do per-architecture handling of stimer0 * interrupts when in Direct Mode */DEFINE_IDTENTRY_SYSVEC(sysvec_hyperv_stimer0){	struct pt_regs *old_regs = set_irq_regs(regs); 	inc_irq_stat(HYPERV_STIMER0);	if (hv_stimer0_handler)		hv_stimer0_handler();	add_interrupt_randomness(HYPERV_STIMER0_VECTOR);	apic_eoi(); 	set_irq_regs(old_regs);} /* For x86/x64, override weak placeholders in hyperv_timer.c */void hv_setup_stimer0_handler(void (*handler)(void)){	hv_stimer0_handler = handler;} void hv_remove_stimer0_handler(void){	/* We have no way to deallocate the interrupt gate */	hv_stimer0_handler = NULL;} void hv_setup_kexec_handler(void (*handler)(void)){	hv_kexec_handler = handler;} void hv_remove_kexec_handler(void){	hv_kexec_handler = NULL;} void hv_setup_crash_handler(void (*handler)(struct pt_regs *regs)){	hv_crash_handler = handler;} void hv_remove_crash_handler(void){	hv_crash_handler = NULL;} #ifdef CONFIG_KEXEC_COREstatic void hv_machine_shutdown(void){	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	 * corrupts the old VP Assist Pages and can crash the kexec kernel.	 */	if (kexec_in_progress)		cpuhp_remove_state(CPUHP_AP_HYPERV_ONLINE); 	/* The function calls stop_other_cpus(). */	native_machine_shutdown(); 	/* Disable the hypercall page when there is only 1 active CPU. */	if (kexec_in_progress)		hyperv_cleanup();}#endif /* CONFIG_KEXEC_CORE */ #ifdef CONFIG_CRASH_DUMPstatic void hv_guest_crash_shutdown(struct pt_regs *regs){	if (hv_crash_handler)		hv_crash_handler(regs); 	/* The function calls crash_smp_send_stop(). */	native_machine_crash_shutdown(regs); 	/* Disable the hypercall page when there is only 1 active CPU. */	hyperv_cleanup();}#endif /* CONFIG_CRASH_DUMP */ static u64 hv_ref_counter_at_suspend;static void (*old_save_sched_clock_state)(void);static void (*old_restore_sched_clock_state)(void); /* * Hyper-V clock counter resets during hibernation. Save and restore clock * offset during suspend/resume, while also considering the time passed * before suspend. This is to make sure that sched_clock using hv tsc page * based clocksource, proceeds from where it left off during suspend and * it shows correct time for the timestamps of kernel messages after resume. */static void save_hv_clock_tsc_state(void){	hv_ref_counter_at_suspend = hv_read_reference_counter();} static void restore_hv_clock_tsc_state(void){	/*	 * Adjust the offsets used by hv tsc clocksource to	 * account for the time spent before hibernation.	 * adjusted value = reference counter (time) at suspend	 *                - reference counter (time) now.	 */	hv_adj_sched_clock_offset(hv_ref_counter_at_suspend - hv_read_reference_counter());} /* * Functions to override save_sched_clock_state and restore_sched_clock_state * functions of x86_platform. The Hyper-V clock counter is reset during * suspend-resume and the offset used to measure time needs to be * corrected, post resume. */static void hv_save_sched_clock_state(void){	old_save_sched_clock_state();	save_hv_clock_tsc_state();} static void hv_restore_sched_clock_state(void){	restore_hv_clock_tsc_state();	old_restore_sched_clock_state();} static void __init x86_setup_ops_for_tsc_pg_clock(void){	if (!(ms_hyperv.features & HV_MSR_REFERENCE_TSC_AVAILABLE))		return; 	old_save_sched_clock_state = x86_platform.save_sched_clock_state;	x86_platform.save_sched_clock_state = hv_save_sched_clock_state; 	old_restore_sched_clock_state = x86_platform.restore_sched_clock_state;	x86_platform.restore_sched_clock_state = hv_restore_sched_clock_state;} #ifdef CONFIG_X86_64DEFINE_STATIC_CALL(hv_hypercall, hv_std_hypercall);EXPORT_STATIC_CALL_TRAMP_GPL(hv_hypercall);#define hypercall_update(hc) static_call_update(hv_hypercall, hc)#endif#endif /* CONFIG_HYPERV */ #ifndef hypercall_update#define hypercall_update(hc) (void)hc#endif static uint32_t  __init ms_hyperv_platform(void){	u32 eax;	u32 hyp_signature[3]; 	if (!boot_cpu_has(X86_FEATURE_HYPERVISOR))		return 0; 	cpuid(HYPERV_CPUID_VENDOR_AND_MAX_FUNCTIONS,	      &eax, &hyp_signature[0], &hyp_signature[1], &hyp_signature[2]); 	if (eax < HYPERV_CPUID_MIN || eax > HYPERV_CPUID_MAX ||	    memcmp("Microsoft Hv", hyp_signature, 12))		return 0; 	/* HYPERCALL and VP_INDEX MSRs are mandatory for all features. */	eax = cpuid_eax(HYPERV_CPUID_FEATURES);	if (!(eax & HV_MSR_HYPERCALL_AVAILABLE)) {		pr_warn("x86/hyperv: HYPERCALL MSR not available.\n");		return 0;	}	if (!(eax & HV_MSR_VP_INDEX_AVAILABLE)) {		pr_warn("x86/hyperv: VP_INDEX MSR not available.\n");		return 0;	} 	return HYPERV_CPUID_VENDOR_AND_MAX_FUNCTIONS;} #ifdef CONFIG_X86_LOCAL_APIC/* * Prior to WS2016 Debug-VM sends NMIs to all CPUs which makes * it difficult to process CHANNELMSG_UNLOAD in case of crash. Handle * unknown NMI on the first CPU which gets it. */static int hv_nmi_unknown(unsigned int val, struct pt_regs *regs){	static atomic_t nmi_cpu = ATOMIC_INIT(-1);	unsigned int old_cpu, this_cpu; 	if (!unknown_nmi_panic)		return NMI_DONE; 	old_cpu = -1;	this_cpu = raw_smp_processor_id();	if (!atomic_try_cmpxchg(&nmi_cpu, &old_cpu, this_cpu))		return NMI_HANDLED; 	return NMI_DONE;}#endif static unsigned long hv_get_tsc_khz(void){	unsigned long freq; 	rdmsrq(HV_X64_MSR_TSC_FREQUENCY, freq); 	return freq / 1000;} #if defined(CONFIG_SMP) && IS_ENABLED(CONFIG_HYPERV)static void __init hv_smp_prepare_boot_cpu(void){	native_smp_prepare_boot_cpu();#if defined(CONFIG_X86_64) && defined(CONFIG_PARAVIRT_SPINLOCKS)	hv_init_spinlocks();#endif} static void __init hv_smp_prepare_cpus(unsigned int max_cpus){#ifdef CONFIG_X86_64	int i;	int ret;#endif 	native_smp_prepare_cpus(max_cpus); 	/*	 *  Override wakeup_secondary_cpu_64 callback for SEV-SNP	 *  enlightened guest.	 */	if (!ms_hyperv.paravisor_present && hv_isolation_type_snp()) {		apic->wakeup_secondary_cpu_64 = hv_snp_boot_ap;		return;	} #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;		ret = hv_call_add_logical_proc(numa_cpu_node(i), i, cpu_physical_id(i));		BUG_ON(ret);	} 	ret = hv_call_notify_all_processors_started();	WARN_ON(ret); 	for_each_present_cpu(i) {		if (i == 0)			continue;		ret = hv_call_create_vp(numa_cpu_node(i), hv_current_partition_id, i, i);		BUG_ON(ret);	}#endif}#endif /* * When a fully enlightened TDX VM runs on Hyper-V, the firmware sets the * HW_REDUCED flag: refer to acpi_tb_create_local_fadt(). Consequently ttyS0 * interrupts can't work because request_irq() -> ... -> irq_to_desc() returns * NULL for ttyS0. This happens because mp_config_acpi_legacy_irqs() sees a * nr_legacy_irqs() of 0, so it doesn't initialize the array 'mp_irqs[]', and * later setup_IO_APIC_irqs() -> find_irq_entry() fails to find the legacy irqs * from the array and hence doesn't create the necessary irq description info. * * Clone arch/x86/kernel/acpi/boot.c: acpi_generic_reduced_hw_init() here, * except don't change 'legacy_pic', which keeps its default value * 'default_legacy_pic'. This way, mp_config_acpi_legacy_irqs() sees a non-zero * nr_legacy_irqs() and eventually serial console interrupts works properly. */static void __init reduced_hw_init(void){	x86_init.timers.timer_init	= x86_init_noop;	x86_init.irqs.pre_vector_init	= x86_init_noop;} int hv_get_hypervisor_version(union hv_hypervisor_version_info *info){	unsigned int hv_max_functions; 	hv_max_functions = cpuid_eax(HYPERV_CPUID_VENDOR_AND_MAX_FUNCTIONS);	if (hv_max_functions < HYPERV_CPUID_VERSION) {		pr_err("%s: Could not detect Hyper-V version\n", __func__);		return -ENODEV;	} 	cpuid(HYPERV_CPUID_VERSION, &info->eax, &info->ebx, &info->ecx, &info->edx); 	return 0;}EXPORT_SYMBOL_GPL(hv_get_hypervisor_version); /* * Reserved vectors hard coded in the hypervisor. If used outside, the hypervisor * will either crash or hang or attempt to break into debugger. */static void hv_reserve_irq_vectors(void){

Lines 1–500 of 824. Load more