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