drivers/staging/hv/hv.c

   1 /*
   2  * Copyright (c) 2009, Microsoft Corporation.
   3  *
   4  * This program is free software; you can redistribute it and/or modify it
   5  * under the terms and conditions of the GNU General Public License,
   6  * version 2, as published by the Free Software Foundation.
   7  *
   8  * This program is distributed in the hope it will be useful, but WITHOUT
   9  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  10  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
  11  * more details.
  12  *
  13  * You should have received a copy of the GNU General Public License along with
  14  * this program; if not, write to the Free Software Foundation, Inc., 59 Temple
  15  * Place - Suite 330, Boston, MA 02111-1307 USA.
  16  *
  17  * Authors:
  18  *   Haiyang Zhang <haiyangz@microsoft.com>
  19  *   Hank Janssen  <hjanssen@microsoft.com>
  20  *
  21  */
  22 #include <linux/kernel.h>
  23 #include <linux/mm.h>
  24 #include <linux/slab.h>
  25 #include <linux/vmalloc.h>
  26 #include "osd.h"
  27 #include "logging.h"
  28 #include "vmbus_private.h"
  29
  30 /* The one and only */
  31 struct hv_context gHvContext = {
  32         .SynICInitialized       = false,
  33         .HypercallPage          = NULL,
  34         .SignalEventParam       = NULL,
  35         .SignalEventBuffer      = NULL,
  36 };
  37
  38 /*
  39  * HvQueryHypervisorPresence - Query the cpuid for presense of windows hypervisor
  40  */
  41 static int HvQueryHypervisorPresence(void)
  42 {
  43         unsigned int eax;
  44         unsigned int ebx;
  45         unsigned int ecx;
  46         unsigned int edx;
  47         unsigned int op;
  48
  49         eax = 0;
  50         ebx = 0;
  51         ecx = 0;
  52         edx = 0;
  53         op = HvCpuIdFunctionVersionAndFeatures;
  54         cpuid(op, &eax, &ebx, &ecx, &edx);
  55
  56         return ecx & HV_PRESENT_BIT;
  57 }
  58
  59 /*
  60  * HvQueryHypervisorInfo - Get version info of the windows hypervisor
  61  */
  62 static int HvQueryHypervisorInfo(void)
  63 {
  64         unsigned int eax;
  65         unsigned int ebx;
  66         unsigned int ecx;
  67         unsigned int edx;
  68         unsigned int maxLeaf;
  69         unsigned int op;
  70
  71         /*
  72         * Its assumed that this is called after confirming that Viridian
  73         * is present. Query id and revision.
  74         */
  75         eax = 0;
  76         ebx = 0;
  77         ecx = 0;
  78         edx = 0;
  79         op = HvCpuIdFunctionHvVendorAndMaxFunction;
  80         cpuid(op, &eax, &ebx, &ecx, &edx);
  81
  82         DPRINT_INFO(VMBUS, "Vendor ID: %c%c%c%c%c%c%c%c%c%c%c%c",
  83                     (ebx & 0xFF),
  84                     ((ebx >> 8) & 0xFF),
  85                     ((ebx >> 16) & 0xFF),
  86                     ((ebx >> 24) & 0xFF),
  87                     (ecx & 0xFF),
  88                     ((ecx >> 8) & 0xFF),
  89                     ((ecx >> 16) & 0xFF),
  90                     ((ecx >> 24) & 0xFF),
  91                     (edx & 0xFF),
  92                     ((edx >> 8) & 0xFF),
  93                     ((edx >> 16) & 0xFF),
  94                     ((edx >> 24) & 0xFF));
  95
  96         maxLeaf = eax;
  97         eax = 0;
  98         ebx = 0;
  99         ecx = 0;
 100         edx = 0;
 101         op = HvCpuIdFunctionHvInterface;
 102         cpuid(op, &eax, &ebx, &ecx, &edx);
 103
 104         DPRINT_INFO(VMBUS, "Interface ID: %c%c%c%c",
 105                     (eax & 0xFF),
 106                     ((eax >> 8) & 0xFF),
 107                     ((eax >> 16) & 0xFF),
 108                     ((eax >> 24) & 0xFF));
 109
 110         if (maxLeaf >= HvCpuIdFunctionMsHvVersion) {
 111                 eax = 0;
 112                 ebx = 0;
 113                 ecx = 0;
 114                 edx = 0;
 115                 op = HvCpuIdFunctionMsHvVersion;
 116                 cpuid(op, &eax, &ebx, &ecx, &edx);
 117                 DPRINT_INFO(VMBUS, "OS Build:%d-%d.%d-%d-%d.%d",\
 118                             eax,
 119                             ebx >> 16,
 120                             ebx & 0xFFFF,
 121                             ecx,
 122                             edx >> 24,
 123                             edx & 0xFFFFFF);
 124         }
 125         return maxLeaf;
 126 }
 127
 128 /*
 129  * HvDoHypercall - Invoke the specified hypercall
 130  */
 131 static u64 HvDoHypercall(u64 Control, void *Input, void *Output)
 132 {
 133 #ifdef CONFIG_X86_64
 134         u64 hvStatus = 0;
 135         u64 inputAddress = (Input) ? virt_to_phys(Input) : 0;
 136         u64 outputAddress = (Output) ? virt_to_phys(Output) : 0;
 137         volatile void *hypercallPage = gHvContext.HypercallPage;
 138
 139         DPRINT_DBG(VMBUS, "Hypercall <control %llx input phys %llx virt %p "
 140                    "output phys %llx virt %p hypercall %p>",
 141                    Control, inputAddress, Input,
 142                    outputAddress, Output, hypercallPage);
 143
 144         __asm__ __volatile__("mov %0, %%r8" : : "r" (outputAddress) : "r8");
 145         __asm__ __volatile__("call *%3" : "=a" (hvStatus) :
 146                              "c" (Control), "d" (inputAddress),
 147                              "m" (hypercallPage));
 148
 149         DPRINT_DBG(VMBUS, "Hypercall <return %llx>",  hvStatus);
 150
 151         return hvStatus;
 152
 153 #else
 154
 155         u32 controlHi = Control >> 32;
 156         u32 controlLo = Control & 0xFFFFFFFF;
 157         u32 hvStatusHi = 1;
 158         u32 hvStatusLo = 1;
 159         u64 inputAddress = (Input) ? virt_to_phys(Input) : 0;
 160         u32 inputAddressHi = inputAddress >> 32;
 161         u32 inputAddressLo = inputAddress & 0xFFFFFFFF;
 162         u64 outputAddress = (Output) ? virt_to_phys(Output) : 0;
 163         u32 outputAddressHi = outputAddress >> 32;
 164         u32 outputAddressLo = outputAddress & 0xFFFFFFFF;
 165         volatile void *hypercallPage = gHvContext.HypercallPage;
 166
 167         DPRINT_DBG(VMBUS, "Hypercall <control %llx input %p output %p>",
 168                    Control, Input, Output);
 169
 170         __asm__ __volatile__ ("call *%8" : "=d"(hvStatusHi),
 171                               "=a"(hvStatusLo) : "d" (controlHi),
 172                               "a" (controlLo), "b" (inputAddressHi),
 173                               "c" (inputAddressLo), "D"(outputAddressHi),
 174                               "S"(outputAddressLo), "m" (hypercallPage));
 175
 176         DPRINT_DBG(VMBUS, "Hypercall <return %llx>",
 177                    hvStatusLo | ((u64)hvStatusHi << 32));
 178
 179         return hvStatusLo | ((u64)hvStatusHi << 32);
 180 #endif /* !x86_64 */
 181 }
 182
 183 /*
 184  * HvInit - Main initialization routine.
 185  *
 186  * This routine must be called before any other routines in here are called
 187  */
 188 int HvInit(void)
 189 {
 190         int ret = 0;
 191         int maxLeaf;
 192         union hv_x64_msr_hypercall_contents hypercallMsr;
 193         void *virtAddr = NULL;
 194
 195         DPRINT_ENTER(VMBUS);
 196
 197         memset(gHvContext.synICEventPage, 0, sizeof(void *) * MAX_NUM_CPUS);
 198         memset(gHvContext.synICMessagePage, 0, sizeof(void *) * MAX_NUM_CPUS);
 199
 200         if (!HvQueryHypervisorPresence()) {
 201                 DPRINT_ERR(VMBUS, "No Windows hypervisor detected!!");
 202                 goto Cleanup;
 203         }
 204
 205         DPRINT_INFO(VMBUS,
 206                     "Windows hypervisor detected! Retrieving more info...");
 207
 208         maxLeaf = HvQueryHypervisorInfo();
 209         /* HvQueryHypervisorFeatures(maxLeaf); */
 210
 211         /*
 212          * We only support running on top of Hyper-V
 213          */
 214         rdmsrl(HV_X64_MSR_GUEST_OS_ID, gHvContext.GuestId);
 215
 216         if (gHvContext.GuestId != 0) {
 217                 DPRINT_ERR(VMBUS, "Unknown guest id (0x%llx)!!",
 218                                 gHvContext.GuestId);
 219                 goto Cleanup;
 220         }
 221
 222         /* Write our OS info */
 223         wrmsrl(HV_X64_MSR_GUEST_OS_ID, HV_LINUX_GUEST_ID);
 224         gHvContext.GuestId = HV_LINUX_GUEST_ID;
 225
 226         /* See if the hypercall page is already set */
 227         rdmsrl(HV_X64_MSR_HYPERCALL, hypercallMsr.AsUINT64);
 228
 229         /*
 230         * Allocate the hypercall page memory
 231         * virtAddr = osd_PageAlloc(1);
 232         */
 233         virtAddr = osd_VirtualAllocExec(PAGE_SIZE);
 234
 235         if (!virtAddr) {
 236                 DPRINT_ERR(VMBUS,
 237                            "unable to allocate hypercall page!!");
 238                 goto Cleanup;
 239         }
 240
 241         hypercallMsr.Enable = 1;
 242
 243         hypercallMsr.GuestPhysicalAddress = vmalloc_to_pfn(virtAddr);
 244         wrmsrl(HV_X64_MSR_HYPERCALL, hypercallMsr.AsUINT64);
 245
 246         /* Confirm that hypercall page did get setup. */
 247         hypercallMsr.AsUINT64 = 0;
 248         rdmsrl(HV_X64_MSR_HYPERCALL, hypercallMsr.AsUINT64);
 249
 250         if (!hypercallMsr.Enable) {
 251                 DPRINT_ERR(VMBUS, "unable to set hypercall page!!");
 252                 goto Cleanup;
 253         }
 254
 255         gHvContext.HypercallPage = virtAddr;
 256
 257         DPRINT_INFO(VMBUS, "Hypercall page VA=%p, PA=0x%0llx",
 258                     gHvContext.HypercallPage,
 259                     (u64)hypercallMsr.GuestPhysicalAddress << PAGE_SHIFT);
 260
 261         /* Setup the global signal event param for the signal event hypercall */
 262         gHvContext.SignalEventBuffer =
 263                         kmalloc(sizeof(struct hv_input_signal_event_buffer),
 264                                 GFP_KERNEL);
 265         if (!gHvContext.SignalEventBuffer)
 266                 goto Cleanup;
 267
 268         gHvContext.SignalEventParam =
 269                 (struct hv_input_signal_event *)
 270                         (ALIGN_UP((unsigned long)gHvContext.SignalEventBuffer,
 271                                   HV_HYPERCALL_PARAM_ALIGN));
 272         gHvContext.SignalEventParam->ConnectionId.Asu32 = 0;
 273         gHvContext.SignalEventParam->ConnectionId.u.Id =
 274                                                 VMBUS_EVENT_CONNECTION_ID;
 275         gHvContext.SignalEventParam->FlagNumber = 0;
 276         gHvContext.SignalEventParam->RsvdZ = 0;
 277
 278         DPRINT_EXIT(VMBUS);
 279
 280         return ret;
 281
 282 Cleanup:
 283         if (virtAddr) {
 284                 if (hypercallMsr.Enable) {
 285                         hypercallMsr.AsUINT64 = 0;
 286                         wrmsrl(HV_X64_MSR_HYPERCALL, hypercallMsr.AsUINT64);
 287                 }
 288
 289                 vfree(virtAddr);
 290         }
 291         ret = -1;
 292         DPRINT_EXIT(VMBUS);
 293
 294         return ret;
 295 }
 296
 297 /*
 298  * HvCleanup - Cleanup routine.
 299  *
 300  * This routine is called normally during driver unloading or exiting.
 301  */
 302 void HvCleanup(void)
 303 {
 304         union hv_x64_msr_hypercall_contents hypercallMsr;
 305
 306         DPRINT_ENTER(VMBUS);
 307
 308         kfree(gHvContext.SignalEventBuffer);
 309         gHvContext.SignalEventBuffer = NULL;
 310         gHvContext.SignalEventParam = NULL;
 311
 312         if (gHvContext.HypercallPage) {
 313                 hypercallMsr.AsUINT64 = 0;
 314                 wrmsrl(HV_X64_MSR_HYPERCALL, hypercallMsr.AsUINT64);
 315                 vfree(gHvContext.HypercallPage);
 316                 gHvContext.HypercallPage = NULL;
 317         }
 318
 319         DPRINT_EXIT(VMBUS);
 320 }
 321
 322 /*
 323  * HvPostMessage - Post a message using the hypervisor message IPC.
 324  *
 325  * This involves a hypercall.
 326  */
 327 u16 HvPostMessage(union hv_connection_id connectionId,
 328                   enum hv_message_type messageType,
 329                   void *payload, size_t payloadSize)
 330 {
 331         struct alignedInput {
 332                 u64 alignment8;
 333                 struct hv_input_post_message msg;
 334         };
 335
 336         struct hv_input_post_message *alignedMsg;
 337         u16 status;
 338         unsigned long addr;
 339
 340         if (payloadSize > HV_MESSAGE_PAYLOAD_BYTE_COUNT)
 341                 return -1;
 342
 343         addr = (unsigned long)kmalloc(sizeof(struct alignedInput), GFP_ATOMIC);
 344         if (!addr)
 345                 return -1;
 346
 347         alignedMsg = (struct hv_input_post_message *)
 348                         (ALIGN_UP(addr, HV_HYPERCALL_PARAM_ALIGN));
 349
 350         alignedMsg->ConnectionId = connectionId;
 351         alignedMsg->MessageType = messageType;
 352         alignedMsg->PayloadSize = payloadSize;
 353         memcpy((void *)alignedMsg->Payload, payload, payloadSize);
 354
 355         status = HvDoHypercall(HvCallPostMessage, alignedMsg, NULL) & 0xFFFF;
 356
 357         kfree((void *)addr);
 358
 359         return status;
 360 }
 361
 362
 363 /*
 364  * HvSignalEvent - Signal an event on the specified connection using the hypervisor event IPC.
 365  *
 366  * This involves a hypercall.
 367  */
 368 u16 HvSignalEvent(void)
 369 {
 370         u16 status;
 371
 372         status = HvDoHypercall(HvCallSignalEvent, gHvContext.SignalEventParam,
 373                                NULL) & 0xFFFF;
 374         return status;
 375 }
 376
 377 /*
 378  * HvSynicInit - Initialize the Synthethic Interrupt Controller.
 379  *
 380  * If it is already initialized by another entity (ie x2v shim), we need to
 381  * retrieve the initialized message and event pages.  Otherwise, we create and
 382  * initialize the message and event pages.
 383  */
 384 void HvSynicInit(void *irqarg)
 385 {
 386         u64 version;
 387         union hv_synic_simp simp;
 388         union hv_synic_siefp siefp;
 389         union hv_synic_sint sharedSint;
 390         union hv_synic_scontrol sctrl;
 391
 392         u32 irqVector = *((u32 *)(irqarg));
 393         int cpu = smp_processor_id();
 394
 395         DPRINT_ENTER(VMBUS);
 396
 397         if (!gHvContext.HypercallPage) {
 398                 DPRINT_EXIT(VMBUS);
 399                 return;
 400         }
 401
 402         /* Check the version */
 403         rdmsrl(HV_X64_MSR_SVERSION, version);
 404
 405         DPRINT_INFO(VMBUS, "SynIC version: %llx", version);
 406
 407         gHvContext.synICMessagePage[cpu] = (void *)get_zeroed_page(GFP_ATOMIC);
 408
 409         if (gHvContext.synICMessagePage[cpu] == NULL) {
 410                 DPRINT_ERR(VMBUS,
 411                            "unable to allocate SYNIC message page!!");
 412                 goto Cleanup;
 413         }
 414
 415         gHvContext.synICEventPage[cpu] = (void *)get_zeroed_page(GFP_ATOMIC);
 416
 417         if (gHvContext.synICEventPage[cpu] == NULL) {
 418                 DPRINT_ERR(VMBUS,
 419                            "unable to allocate SYNIC event page!!");
 420                 goto Cleanup;
 421         }
 422
 423         /* Setup the Synic's message page */
 424         rdmsrl(HV_X64_MSR_SIMP, simp.AsUINT64);
 425         simp.SimpEnabled = 1;
 426         simp.BaseSimpGpa = virt_to_phys(gHvContext.synICMessagePage[cpu])
 427                 >> PAGE_SHIFT;
 428
 429         DPRINT_DBG(VMBUS, "HV_X64_MSR_SIMP msr set to: %llx", simp.AsUINT64);
 430
 431         wrmsrl(HV_X64_MSR_SIMP, simp.AsUINT64);
 432
 433         /* Setup the Synic's event page */
 434         rdmsrl(HV_X64_MSR_SIEFP, siefp.AsUINT64);
 435         siefp.SiefpEnabled = 1;
 436         siefp.BaseSiefpGpa = virt_to_phys(gHvContext.synICEventPage[cpu])
 437                 >> PAGE_SHIFT;
 438
 439         DPRINT_DBG(VMBUS, "HV_X64_MSR_SIEFP msr set to: %llx", siefp.AsUINT64);
 440
 441         wrmsrl(HV_X64_MSR_SIEFP, siefp.AsUINT64);
 442
 443         /* Setup the interception SINT. */
 444         /* wrmsrl((HV_X64_MSR_SINT0 + HV_SYNIC_INTERCEPTION_SINT_INDEX), */
 445         /*        interceptionSint.AsUINT64); */
 446
 447         /* Setup the shared SINT. */
 448         rdmsrl(HV_X64_MSR_SINT0 + VMBUS_MESSAGE_SINT, sharedSint.AsUINT64);
 449
 450         sharedSint.AsUINT64 = 0;
 451         sharedSint.Vector = irqVector; /* HV_SHARED_SINT_IDT_VECTOR + 0x20; */
 452         sharedSint.Masked = false;
 453         sharedSint.AutoEoi = true;
 454
 455         DPRINT_DBG(VMBUS, "HV_X64_MSR_SINT1 msr set to: %llx",
 456                    sharedSint.AsUINT64);
 457
 458         wrmsrl(HV_X64_MSR_SINT0 + VMBUS_MESSAGE_SINT, sharedSint.AsUINT64);
 459
 460         /* Enable the global synic bit */
 461         rdmsrl(HV_X64_MSR_SCONTROL, sctrl.AsUINT64);
 462         sctrl.Enable = 1;
 463
 464         wrmsrl(HV_X64_MSR_SCONTROL, sctrl.AsUINT64);
 465
 466         gHvContext.SynICInitialized = true;
 467
 468         DPRINT_EXIT(VMBUS);
 469
 470         return;
 471
 472 Cleanup:
 473         if (gHvContext.synICEventPage[cpu])
 474                 osd_PageFree(gHvContext.synICEventPage[cpu], 1);
 475
 476         if (gHvContext.synICMessagePage[cpu])
 477                 osd_PageFree(gHvContext.synICMessagePage[cpu], 1);
 478
 479         DPRINT_EXIT(VMBUS);
 480         return;
 481 }
 482
 483 /*
 484  * HvSynicCleanup - Cleanup routine for HvSynicInit().
 485  */
 486 void HvSynicCleanup(void *arg)
 487 {
 488         union hv_synic_sint sharedSint;
 489         union hv_synic_simp simp;
 490         union hv_synic_siefp siefp;
 491         int cpu = smp_processor_id();
 492
 493         DPRINT_ENTER(VMBUS);
 494
 495         if (!gHvContext.SynICInitialized) {
 496                 DPRINT_EXIT(VMBUS);
 497                 return;
 498         }
 499
 500         rdmsrl(HV_X64_MSR_SINT0 + VMBUS_MESSAGE_SINT, sharedSint.AsUINT64);
 501
 502         sharedSint.Masked = 1;
 503
 504         /* Need to correctly cleanup in the case of SMP!!! */
 505         /* Disable the interrupt */
 506         wrmsrl(HV_X64_MSR_SINT0 + VMBUS_MESSAGE_SINT, sharedSint.AsUINT64);
 507
 508         rdmsrl(HV_X64_MSR_SIMP, simp.AsUINT64);
 509         simp.SimpEnabled = 0;
 510         simp.BaseSimpGpa = 0;
 511
 512         wrmsrl(HV_X64_MSR_SIMP, simp.AsUINT64);
 513
 514         rdmsrl(HV_X64_MSR_SIEFP, siefp.AsUINT64);
 515         siefp.SiefpEnabled = 0;
 516         siefp.BaseSiefpGpa = 0;
 517
 518         wrmsrl(HV_X64_MSR_SIEFP, siefp.AsUINT64);
 519
 520         osd_PageFree(gHvContext.synICMessagePage[cpu], 1);
 521         osd_PageFree(gHvContext.synICEventPage[cpu], 1);
 522
 523         DPRINT_EXIT(VMBUS);
 524 }