arch/x86/include/asm/mshyperv.h

   1 #ifndef _ASM_X86_MSHYPER_H
   2 #define _ASM_X86_MSHYPER_H
   3
   4 #include <linux/types.h>
   5 #include <linux/interrupt.h>
   6 #include <linux/clocksource.h>
   7 #include <asm/hyperv.h>
   8
   9 /*
  10  * The below CPUID leaves are present if VersionAndFeatures.HypervisorPresent
  11  * is set by CPUID(HVCPUID_VERSION_FEATURES).
  12  */
  13 enum hv_cpuid_function {
  14         HVCPUID_VERSION_FEATURES                = 0x00000001,
  15         HVCPUID_VENDOR_MAXFUNCTION              = 0x40000000,
  16         HVCPUID_INTERFACE                       = 0x40000001,
  17
  18         /*
  19          * The remaining functions depend on the value of
  20          * HVCPUID_INTERFACE
  21          */
  22         HVCPUID_VERSION                         = 0x40000002,
  23         HVCPUID_FEATURES                        = 0x40000003,
  24         HVCPUID_ENLIGHTENMENT_INFO              = 0x40000004,
  25         HVCPUID_IMPLEMENTATION_LIMITS           = 0x40000005,
  26 };
  27
  28 struct ms_hyperv_info {
  29         u32 features;
  30         u32 misc_features;
  31         u32 hints;
  32 };
  33
  34 extern struct ms_hyperv_info ms_hyperv;
  35
  36 /*
  37  * Declare the MSR used to setup pages used to communicate with the hypervisor.
  38  */
  39 union hv_x64_msr_hypercall_contents {
  40         u64 as_uint64;
  41         struct {
  42                 u64 enable:1;
  43                 u64 reserved:11;
  44                 u64 guest_physical_address:52;
  45         };
  46 };
  47
  48 /*
  49  * TSC page layout.
  50  */
  51
  52 struct ms_hyperv_tsc_page {
  53         volatile u32 tsc_sequence;
  54         u32 reserved1;
  55         volatile u64 tsc_scale;
  56         volatile s64 tsc_offset;
  57         u64 reserved2[509];
  58 };
  59
  60 /*
  61  * The guest OS needs to register the guest ID with the hypervisor.
  62  * The guest ID is a 64 bit entity and the structure of this ID is
  63  * specified in the Hyper-V specification:
  64  *
  65  * msdn.microsoft.com/en-us/library/windows/hardware/ff542653%28v=vs.85%29.aspx
  66  *
  67  * While the current guideline does not specify how Linux guest ID(s)
  68  * need to be generated, our plan is to publish the guidelines for
  69  * Linux and other guest operating systems that currently are hosted
  70  * on Hyper-V. The implementation here conforms to this yet
  71  * unpublished guidelines.
  72  *
  73  *
  74  * Bit(s)
  75  * 63 - Indicates if the OS is Open Source or not; 1 is Open Source
  76  * 62:56 - Os Type; Linux is 0x100
  77  * 55:48 - Distro specific identification
  78  * 47:16 - Linux kernel version number
  79  * 15:0  - Distro specific identification
  80  *
  81  *
  82  */
  83
  84 #define HV_LINUX_VENDOR_ID              0x8100
  85
  86 /*
  87  * Generate the guest ID based on the guideline described above.
  88  */
  89
  90 static inline  __u64 generate_guest_id(__u64 d_info1, __u64 kernel_version,
  91                                        __u64 d_info2)
  92 {
  93         __u64 guest_id = 0;
  94
  95         guest_id = (((__u64)HV_LINUX_VENDOR_ID) << 48);
  96         guest_id |= (d_info1 << 48);
  97         guest_id |= (kernel_version << 16);
  98         guest_id |= d_info2;
  99
 100         return guest_id;
 101 }
 102
 103
 104 /* Free the message slot and signal end-of-message if required */
 105 static inline void vmbus_signal_eom(struct hv_message *msg, u32 old_msg_type)
 106 {
 107         /*
 108          * On crash we're reading some other CPU's message page and we need
 109          * to be careful: this other CPU may already had cleared the header
 110          * and the host may already had delivered some other message there.
 111          * In case we blindly write msg->header.message_type we're going
 112          * to lose it. We can still lose a message of the same type but
 113          * we count on the fact that there can only be one
 114          * CHANNELMSG_UNLOAD_RESPONSE and we don't care about other messages
 115          * on crash.
 116          */
 117         if (cmpxchg(&msg->header.message_type, old_msg_type,
 118                     HVMSG_NONE) != old_msg_type)
 119                 return;
 120
 121         /*
 122          * Make sure the write to MessageType (ie set to
 123          * HVMSG_NONE) happens before we read the
 124          * MessagePending and EOMing. Otherwise, the EOMing
 125          * will not deliver any more messages since there is
 126          * no empty slot
 127          */
 128         mb();
 129
 130         if (msg->header.message_flags.msg_pending) {
 131                 /*
 132                  * This will cause message queue rescan to
 133                  * possibly deliver another msg from the
 134                  * hypervisor
 135                  */
 136                 wrmsrl(HV_X64_MSR_EOM, 0);
 137         }
 138 }
 139
 140 #define hv_get_current_tick(tick) rdmsrl(HV_X64_MSR_TIME_REF_COUNT, tick)
 141 #define hv_init_timer(timer, tick) wrmsrl(timer, tick)
 142 #define hv_init_timer_config(config, val) wrmsrl(config, val)
 143
 144 #define hv_get_simp(val) rdmsrl(HV_X64_MSR_SIMP, val)
 145 #define hv_set_simp(val) wrmsrl(HV_X64_MSR_SIMP, val)
 146
 147 #define hv_get_siefp(val) rdmsrl(HV_X64_MSR_SIEFP, val)
 148 #define hv_set_siefp(val) wrmsrl(HV_X64_MSR_SIEFP, val)
 149
 150 #define hv_get_synic_state(val) rdmsrl(HV_X64_MSR_SCONTROL, val)
 151 #define hv_set_synic_state(val) wrmsrl(HV_X64_MSR_SCONTROL, val)
 152
 153 #define hv_get_vp_index(index) rdmsrl(HV_X64_MSR_VP_INDEX, index)
 154
 155 #define hv_get_synint_state(int_num, val) rdmsrl(int_num, val)
 156 #define hv_set_synint_state(int_num, val) wrmsrl(int_num, val)
 157
 158 void hyperv_callback_vector(void);
 159 #ifdef CONFIG_TRACING
 160 #define trace_hyperv_callback_vector hyperv_callback_vector
 161 #endif
 162 void hyperv_vector_handler(struct pt_regs *regs);
 163 void hv_setup_vmbus_irq(void (*handler)(void));
 164 void hv_remove_vmbus_irq(void);
 165
 166 void hv_setup_kexec_handler(void (*handler)(void));
 167 void hv_remove_kexec_handler(void);
 168 void hv_setup_crash_handler(void (*handler)(struct pt_regs *regs));
 169 void hv_remove_crash_handler(void);
 170
 171 #if IS_ENABLED(CONFIG_HYPERV)
 172 extern struct clocksource *hyperv_cs;
 173
 174 void hyperv_init(void);
 175 void hyperv_report_panic(struct pt_regs *regs);
 176 bool hv_is_hypercall_page_setup(void);
 177 void hyperv_cleanup(void);
 178 #endif
 179 #ifdef CONFIG_HYPERV_TSCPAGE
 180 struct ms_hyperv_tsc_page *hv_get_tsc_page(void);
 181 static inline u64 hv_read_tsc_page(const struct ms_hyperv_tsc_page *tsc_pg)
 182 {
 183         u64 scale, offset, cur_tsc;
 184         u32 sequence;
 185
 186         /*
 187          * The protocol for reading Hyper-V TSC page is specified in Hypervisor
 188          * Top-Level Functional Specification ver. 3.0 and above. To get the
 189          * reference time we must do the following:
 190          * - READ ReferenceTscSequence
 191          *   A special '0' value indicates the time source is unreliable and we
 192          *   need to use something else. The currently published specification
 193          *   versions (up to 4.0b) contain a mistake and wrongly claim '-1'
 194          *   instead of '0' as the special value, see commit c35b82ef0294.
 195          * - ReferenceTime =
 196          *        ((RDTSC() * ReferenceTscScale) >> 64) + ReferenceTscOffset
 197          * - READ ReferenceTscSequence again. In case its value has changed
 198          *   since our first reading we need to discard ReferenceTime and repeat
 199          *   the whole sequence as the hypervisor was updating the page in
 200          *   between.
 201          */
 202         do {
 203                 sequence = READ_ONCE(tsc_pg->tsc_sequence);
 204                 if (!sequence)
 205                         return U64_MAX;
 206                 /*
 207                  * Make sure we read sequence before we read other values from
 208                  * TSC page.
 209                  */
 210                 smp_rmb();
 211
 212                 scale = READ_ONCE(tsc_pg->tsc_scale);
 213                 offset = READ_ONCE(tsc_pg->tsc_offset);
 214                 cur_tsc = rdtsc_ordered();
 215
 216                 /*
 217                  * Make sure we read sequence after we read all other values
 218                  * from TSC page.
 219                  */
 220                 smp_rmb();
 221
 222         } while (READ_ONCE(tsc_pg->tsc_sequence) != sequence);
 223
 224         return mul_u64_u64_shr(cur_tsc, scale, 64) + offset;
 225 }
 226
 227 #else
 228 static inline struct ms_hyperv_tsc_page *hv_get_tsc_page(void)
 229 {
 230         return NULL;
 231 }
 232 #endif
 233 #endif