// SPDX-License-Identifier: GPL-2.0 /* * Clocksource driver for the synthetic counter and timers * provided by the Hyper-V hypervisor to guest VMs, as described * in the Hyper-V Top Level Functional Spec (TLFS). This driver * is instruction set architecture independent. * * Copyright (C) 2019, Microsoft, Inc. * * Author: Michael Kelley <[email protected]> */ #include <linux/percpu.h> #include <linux/cpumask.h> #include <linux/clockchips.h> #include <linux/clocksource.h> #include <linux/sched_clock.h> #include <linux/mm.h> #include <linux/cpuhotplug.h> #include <linux/interrupt.h> #include <linux/irq.h> #include <linux/acpi.h> #include <linux/hyperv.h> #include <clocksource/hyperv_timer.h> #include <asm/hyperv-tlfs.h> #include <asm/mshyperv.h> static struct clock_event_device __percpu *hv_clock_event; static u64 hv_sched_clock_offset __ro_after_init; /* * If false, we're using the old mechanism for stimer0 interrupts * where it sends a VMbus message when it expires. The old * mechanism is used when running on older versions of Hyper-V * that don't support Direct Mode. While Hyper-V provides * four stimer's per CPU, Linux uses only stimer0. * * Because Direct Mode does not require processing a VMbus * message, stimer interrupts can be enabled earlier in the * process of booting a CPU, and consistent with when timer * interrupts are enabled for other clocksource drivers. * However, for legacy versions of Hyper-V when Direct Mode * is not enabled, setting up stimer interrupts must be * delayed until VMbus is initialized and can process the * interrupt message. */ static bool direct_mode_enabled; static int stimer0_irq = …; static int stimer0_message_sint; static __maybe_unused DEFINE_PER_CPU(long, stimer0_evt); /* * Common code for stimer0 interrupts coming via Direct Mode or * as a VMbus message. */ void hv_stimer0_isr(void) { … } EXPORT_SYMBOL_GPL(…); /* * stimer0 interrupt handler for architectures that support * per-cpu interrupts, which also implies Direct Mode. */ static irqreturn_t __maybe_unused hv_stimer0_percpu_isr(int irq, void *dev_id) { … } static int hv_ce_set_next_event(unsigned long delta, struct clock_event_device *evt) { … } static int hv_ce_shutdown(struct clock_event_device *evt) { … } static int hv_ce_set_oneshot(struct clock_event_device *evt) { … } /* * hv_stimer_init - Per-cpu initialization of the clockevent */ static int hv_stimer_init(unsigned int cpu) { … } /* * hv_stimer_cleanup - Per-cpu cleanup of the clockevent */ int hv_stimer_cleanup(unsigned int cpu) { … } EXPORT_SYMBOL_GPL(…); /* * These placeholders are overridden by arch specific code on * architectures that need special setup of the stimer0 IRQ because * they don't support per-cpu IRQs (such as x86/x64). */ void __weak hv_setup_stimer0_handler(void (*handler)(void)) { }; void __weak hv_remove_stimer0_handler(void) { }; #ifdef CONFIG_ACPI /* Called only on architectures with per-cpu IRQs (i.e., not x86/x64) */ static int hv_setup_stimer0_irq(void) { … } static void hv_remove_stimer0_irq(void) { … } #else static int hv_setup_stimer0_irq(void) { return 0; } static void hv_remove_stimer0_irq(void) { } #endif /* hv_stimer_alloc - Global initialization of the clockevent and stimer0 */ int hv_stimer_alloc(bool have_percpu_irqs) { … } EXPORT_SYMBOL_GPL(…); /* * hv_stimer_legacy_init -- Called from the VMbus driver to handle * the case when Direct Mode is not enabled, and the stimer * must be initialized late in the CPU onlining process. * */ void hv_stimer_legacy_init(unsigned int cpu, int sint) { … } EXPORT_SYMBOL_GPL(…); /* * hv_stimer_legacy_cleanup -- Called from the VMbus driver to * handle the case when Direct Mode is not enabled, and the * stimer must be cleaned up early in the CPU offlining * process. */ void hv_stimer_legacy_cleanup(unsigned int cpu) { … } EXPORT_SYMBOL_GPL(…); /* * Do a global cleanup of clockevents for the cases of kexec and * vmbus exit */ void hv_stimer_global_cleanup(void) { … } EXPORT_SYMBOL_GPL(…); static __always_inline u64 read_hv_clock_msr(void) { … } /* * Code and definitions for the Hyper-V clocksources. Two * clocksources are defined: one that reads the Hyper-V defined MSR, and * the other that uses the TSC reference page feature as defined in the * TLFS. The MSR version is for compatibility with old versions of * Hyper-V and 32-bit x86. The TSC reference page version is preferred. */ static union { … } tsc_pg __bss_decrypted __aligned(…); static struct ms_hyperv_tsc_page *tsc_page = …; static unsigned long tsc_pfn; unsigned long hv_get_tsc_pfn(void) { … } EXPORT_SYMBOL_GPL(…); struct ms_hyperv_tsc_page *hv_get_tsc_page(void) { … } EXPORT_SYMBOL_GPL(…); static __always_inline u64 read_hv_clock_tsc(void) { … } static u64 notrace read_hv_clock_tsc_cs(struct clocksource *arg) { … } static u64 noinstr read_hv_sched_clock_tsc(void) { … } static void suspend_hv_clock_tsc(struct clocksource *arg) { … } static void resume_hv_clock_tsc(struct clocksource *arg) { … } #ifdef HAVE_VDSO_CLOCKMODE_HVCLOCK static int hv_cs_enable(struct clocksource *cs) { … } #endif static struct clocksource hyperv_cs_tsc = …; static u64 notrace read_hv_clock_msr_cs(struct clocksource *arg) { … } static struct clocksource hyperv_cs_msr = …; /* * Reference to pv_ops must be inline so objtool * detection of noinstr violations can work correctly. */ #ifdef CONFIG_GENERIC_SCHED_CLOCK static __always_inline void hv_setup_sched_clock(void *sched_clock) { /* * We're on an architecture with generic sched clock (not x86/x64). * The Hyper-V sched clock read function returns nanoseconds, not * the normal 100ns units of the Hyper-V synthetic clock. */ sched_clock_register(sched_clock, 64, NSEC_PER_SEC); } #elif defined CONFIG_PARAVIRT static __always_inline void hv_setup_sched_clock(void *sched_clock) { … } #else /* !CONFIG_GENERIC_SCHED_CLOCK && !CONFIG_PARAVIRT */ static __always_inline void hv_setup_sched_clock(void *sched_clock) {} #endif /* CONFIG_GENERIC_SCHED_CLOCK */ static void __init hv_init_tsc_clocksource(void) { … } void __init hv_init_clocksource(void) { … } void __init hv_remap_tsc_clocksource(void) { … }
Codebase Browser
linux