OvmfPkg/XenBusDxe/XenBusDxe.c

   1 /** @file
   2   This driver produces XenBus Protocol instances for each Xen PV devices.
   3
   4   This XenBus bus driver will first initialize different services in order to
   5   enumerate the ParaVirtualized devices available.
   6
   7   Those services are:
   8     - HyperCall
   9     - Event Channel
  10     - Grant Table
  11     - XenStore
  12     - XenBus
  13
  14   Copyright (C) 2014, Citrix Ltd.
  15
  16   SPDX-License-Identifier: BSD-2-Clause-Patent
  17
  18 **/
  19
  20 #include <Library/DebugLib.h>
  21 #include <Library/XenHypercallLib.h>
  22
  23 #include "XenBusDxe.h"
  24
  25 #include "GrantTable.h"
  26 #include "XenStore.h"
  27 #include "XenBus.h"
  28
  29 #include <IndustryStandard/Xen/hvm/params.h>
  30 #include <IndustryStandard/Xen/memory.h>
  31
  32 ///
  33 /// Driver Binding Protocol instance
  34 ///
  35 EFI_DRIVER_BINDING_PROTOCOL  gXenBusDxeDriverBinding = {
  36   XenBusDxeDriverBindingSupported,
  37   XenBusDxeDriverBindingStart,
  38   XenBusDxeDriverBindingStop,
  39   XENBUS_DXE_VERSION,
  40   NULL,
  41   NULL
  42 };
  43
  44 STATIC EFI_LOCK       mMyDeviceLock = EFI_INITIALIZE_LOCK_VARIABLE (TPL_CALLBACK);
  45 STATIC XENBUS_DEVICE  *mMyDevice    = NULL;
  46
  47 /**
  48   Map the shared_info_t page into memory.
  49
  50   @param Dev    A XENBUS_DEVICE instance.
  51
  52   @retval EFI_SUCCESS     Dev->SharedInfo whill contain a pointer to
  53                           the shared info page
  54   @retval EFI_LOAD_ERROR  The shared info page could not be mapped. The
  55                           hypercall returned an error.
  56 **/
  57 STATIC
  58 EFI_STATUS
  59 XenGetSharedInfoPage (
  60   IN OUT XENBUS_DEVICE  *Dev
  61   )
  62 {
  63   xen_add_to_physmap_t  Parameter;
  64
  65   ASSERT (Dev->SharedInfo == NULL);
  66
  67   Parameter.domid = DOMID_SELF;
  68   Parameter.space = XENMAPSPACE_shared_info;
  69   Parameter.idx   = 0;
  70
  71   //
  72   // using reserved page because the page is not released when Linux is
  73   // starting because of the add_to_physmap. QEMU might try to access the
  74   // page, and fail because it have no right to do so (segv).
  75   //
  76   Dev->SharedInfo = AllocateReservedPages (1);
  77   Parameter.gpfn  = (UINTN)Dev->SharedInfo >> EFI_PAGE_SHIFT;
  78   if (XenHypercallMemoryOp (XENMEM_add_to_physmap, &Parameter) != 0) {
  79     FreePages (Dev->SharedInfo, 1);
  80     Dev->SharedInfo = NULL;
  81     return EFI_LOAD_ERROR;
  82   }
  83
  84   return EFI_SUCCESS;
  85 }
  86
  87 /**
  88   Unloads an image.
  89
  90   @param  ImageHandle           Handle that identifies the image to be unloaded.
  91
  92   @retval EFI_SUCCESS           The image has been unloaded.
  93   @retval EFI_INVALID_PARAMETER ImageHandle is not a valid image handle.
  94
  95 **/
  96 EFI_STATUS
  97 EFIAPI
  98 XenBusDxeUnload (
  99   IN EFI_HANDLE  ImageHandle
 100   )
 101 {
 102   EFI_STATUS  Status;
 103
 104   EFI_HANDLE  *HandleBuffer;
 105   UINTN       HandleCount;
 106   UINTN       Index;
 107
 108   //
 109   // Retrieve array of all handles in the handle database
 110   //
 111   Status = gBS->LocateHandleBuffer (
 112                   AllHandles,
 113                   NULL,
 114                   NULL,
 115                   &HandleCount,
 116                   &HandleBuffer
 117                   );
 118   if (EFI_ERROR (Status)) {
 119     return Status;
 120   }
 121
 122   //
 123   // Disconnect the current driver from handles in the handle database
 124   //
 125   for (Index = 0; Index < HandleCount; Index++) {
 126     gBS->DisconnectController (HandleBuffer[Index], gImageHandle, NULL);
 127   }
 128
 129   //
 130   // Free the array of handles
 131   //
 132   FreePool (HandleBuffer);
 133
 134   //
 135   // Uninstall protocols installed in the driver entry point
 136   //
 137   Status = gBS->UninstallMultipleProtocolInterfaces (
 138                   ImageHandle,
 139                   &gEfiDriverBindingProtocolGuid,
 140                   &gXenBusDxeDriverBinding,
 141                   &gEfiComponentNameProtocolGuid,
 142                   &gXenBusDxeComponentName,
 143                   &gEfiComponentName2ProtocolGuid,
 144                   &gXenBusDxeComponentName2,
 145                   NULL
 146                   );
 147   if (EFI_ERROR (Status)) {
 148     return Status;
 149   }
 150
 151   return EFI_SUCCESS;
 152 }
 153
 154 /**
 155   This is the declaration of an EFI image entry point. This entry point is
 156   the same for UEFI Applications, UEFI OS Loaders, and UEFI Drivers including
 157   both device drivers and bus drivers.
 158
 159   @param  ImageHandle           The firmware allocated handle for the UEFI image.
 160   @param  SystemTable           A pointer to the EFI System Table.
 161
 162   @retval EFI_SUCCESS           The operation completed successfully.
 163   @retval EFI_ABORTED           Xen hypercalls are not available.
 164   @retval Others                An unexpected error occurred.
 165 **/
 166 EFI_STATUS
 167 EFIAPI
 168 XenBusDxeDriverEntryPoint (
 169   IN EFI_HANDLE        ImageHandle,
 170   IN EFI_SYSTEM_TABLE  *SystemTable
 171   )
 172 {
 173   EFI_STATUS  Status;
 174
 175   if (!XenHypercallIsAvailable ()) {
 176     return EFI_ABORTED;
 177   }
 178
 179   //
 180   // Install UEFI Driver Model protocol(s).
 181   //
 182   Status = EfiLibInstallDriverBindingComponentName2 (
 183              ImageHandle,
 184              SystemTable,
 185              &gXenBusDxeDriverBinding,
 186              ImageHandle,
 187              &gXenBusDxeComponentName,
 188              &gXenBusDxeComponentName2
 189              );
 190   ASSERT_EFI_ERROR (Status);
 191
 192   return Status;
 193 }
 194
 195 /**
 196   Tests to see if this driver supports a given controller. If a child device is provided,
 197   it further tests to see if this driver supports creating a handle for the specified child device.
 198
 199   @param[in]  This                 A pointer to the EFI_DRIVER_BINDING_PROTOCOL instance.
 200   @param[in]  ControllerHandle     The handle of the controller to test. This handle
 201                                    must support a protocol interface that supplies
 202                                    an I/O abstraction to the driver.
 203   @param[in]  RemainingDevicePath  A pointer to the remaining portion of a device path.  This
 204                                    parameter is ignored by device drivers, and is optional for bus
 205                                    drivers. For bus drivers, if this parameter is not NULL, then
 206                                    the bus driver must determine if the bus controller specified
 207                                    by ControllerHandle and the child controller specified
 208                                    by RemainingDevicePath are both supported by this
 209                                    bus driver.
 210
 211   @retval EFI_SUCCESS              The device specified by ControllerHandle and
 212                                    RemainingDevicePath is supported by the driver specified by This.
 213   @retval EFI_ALREADY_STARTED      The device specified by ControllerHandle and
 214                                    RemainingDevicePath is already being managed by the driver
 215                                    specified by This.
 216   @retval EFI_ACCESS_DENIED        The device specified by ControllerHandle and
 217                                    RemainingDevicePath is already being managed by a different
 218                                    driver or an application that requires exclusive access.
 219                                    Currently not implemented.
 220   @retval EFI_UNSUPPORTED          The device specified by ControllerHandle and
 221                                    RemainingDevicePath is not supported by the driver specified by This.
 222 **/
 223 EFI_STATUS
 224 EFIAPI
 225 XenBusDxeDriverBindingSupported (
 226   IN EFI_DRIVER_BINDING_PROTOCOL  *This,
 227   IN EFI_HANDLE                   ControllerHandle,
 228   IN EFI_DEVICE_PATH_PROTOCOL     *RemainingDevicePath OPTIONAL
 229   )
 230 {
 231   EFI_STATUS      Status;
 232   XENIO_PROTOCOL  *XenIo;
 233
 234   Status = gBS->OpenProtocol (
 235                   ControllerHandle,
 236                   &gXenIoProtocolGuid,
 237                   (VOID **)&XenIo,
 238                   This->DriverBindingHandle,
 239                   ControllerHandle,
 240                   EFI_OPEN_PROTOCOL_BY_DRIVER
 241                   );
 242
 243   if (EFI_ERROR (Status)) {
 244     return Status;
 245   }
 246
 247   gBS->CloseProtocol (
 248          ControllerHandle,
 249          &gXenIoProtocolGuid,
 250          This->DriverBindingHandle,
 251          ControllerHandle
 252          );
 253
 254   return Status;
 255 }
 256
 257 VOID
 258 EFIAPI
 259 NotifyExitBoot (
 260   IN EFI_EVENT  Event,
 261   IN VOID       *Context
 262   )
 263 {
 264   XENBUS_DEVICE  *Dev = Context;
 265
 266   gBS->DisconnectController (
 267          Dev->ControllerHandle,
 268          Dev->This->DriverBindingHandle,
 269          NULL
 270          );
 271 }
 272
 273 /**
 274   Starts a bus controller.
 275
 276   The Start() function is designed to be invoked from the EFI boot service ConnectController().
 277   As a result, much of the error checking on the parameters to Start() has been moved into this
 278   common boot service. It is legal to call Start() from other locations,
 279   but the following calling restrictions must be followed, or the system behavior will not be deterministic.
 280   1. ControllerHandle must be a valid EFI_HANDLE.
 281   2. If RemainingDevicePath is not NULL, then it must be a pointer to a naturally aligned
 282      EFI_DEVICE_PATH_PROTOCOL.
 283   3. Prior to calling Start(), the Supported() function for the driver specified by This must
 284      have been called with the same calling parameters, and Supported() must have returned EFI_SUCCESS.
 285
 286   @param[in]  This                 A pointer to the EFI_DRIVER_BINDING_PROTOCOL instance.
 287   @param[in]  ControllerHandle     The handle of the controller to start. This handle
 288                                    must support a protocol interface that supplies
 289                                    an I/O abstraction to the driver.
 290   @param[in]  RemainingDevicePath  A pointer to the remaining portion of a device path.  This
 291                                    parameter is ignored by device drivers, and is optional for bus
 292                                    drivers. For a bus driver, if this parameter is NULL, then handles
 293                                    for all the children of Controller are created by this driver.
 294                                    If this parameter is not NULL and the first Device Path Node is
 295                                    not the End of Device Path Node, then only the handle for the
 296                                    child device specified by the first Device Path Node of
 297                                    RemainingDevicePath is created by this driver.
 298                                    If the first Device Path Node of RemainingDevicePath is
 299                                    the End of Device Path Node, no child handle is created by this
 300                                    driver.
 301
 302   @retval EFI_SUCCESS              The device was started.
 303   @retval EFI_DEVICE_ERROR         The device could not be started due to a device error.Currently not implemented.
 304   @retval EFI_OUT_OF_RESOURCES     The request could not be completed due to a lack of resources.
 305   @retval EFI_UNSUPPORTED          Something is missing on the system that
 306                                    prevent to start the device.
 307   @retval Others                   The driver failed to start the device.
 308
 309 **/
 310 EFI_STATUS
 311 EFIAPI
 312 XenBusDxeDriverBindingStart (
 313   IN EFI_DRIVER_BINDING_PROTOCOL  *This,
 314   IN EFI_HANDLE                   ControllerHandle,
 315   IN EFI_DEVICE_PATH_PROTOCOL     *RemainingDevicePath OPTIONAL
 316   )
 317 {
 318   EFI_STATUS                Status;
 319   XENBUS_DEVICE             *Dev;
 320   XENIO_PROTOCOL            *XenIo;
 321   EFI_DEVICE_PATH_PROTOCOL  *DevicePath;
 322
 323   Status = gBS->OpenProtocol (
 324                   ControllerHandle,
 325                   &gXenIoProtocolGuid,
 326                   (VOID **)&XenIo,
 327                   This->DriverBindingHandle,
 328                   ControllerHandle,
 329                   EFI_OPEN_PROTOCOL_BY_DRIVER
 330                   );
 331
 332   if (EFI_ERROR (Status)) {
 333     return Status;
 334   }
 335
 336   Status = gBS->OpenProtocol (
 337                   ControllerHandle,
 338                   &gEfiDevicePathProtocolGuid,
 339                   (VOID **)&DevicePath,
 340                   This->DriverBindingHandle,
 341                   ControllerHandle,
 342                   EFI_OPEN_PROTOCOL_BY_DRIVER
 343                   );
 344
 345   if (EFI_ERROR (Status)) {
 346     goto ErrorOpenningProtocol;
 347   }
 348
 349   Dev                   = AllocateZeroPool (sizeof (*Dev));
 350   Dev->Signature        = XENBUS_DEVICE_SIGNATURE;
 351   Dev->This             = This;
 352   Dev->ControllerHandle = ControllerHandle;
 353   Dev->XenIo            = XenIo;
 354   Dev->DevicePath       = DevicePath;
 355   InitializeListHead (&Dev->ChildList);
 356
 357   EfiAcquireLock (&mMyDeviceLock);
 358   if (mMyDevice != NULL) {
 359     EfiReleaseLock (&mMyDeviceLock);
 360     //
 361     // There is already a XenBus running, only one can be used at a time.
 362     //
 363     Status = EFI_ALREADY_STARTED;
 364     goto ErrorAllocated;
 365   }
 366
 367   mMyDevice = Dev;
 368   EfiReleaseLock (&mMyDeviceLock);
 369
 370   Status = XenGetSharedInfoPage (Dev);
 371   if (EFI_ERROR (Status)) {
 372     DEBUG ((DEBUG_ERROR, "XenBus: Unable to get the shared info page.\n"));
 373     Status = EFI_UNSUPPORTED;
 374     goto ErrorAllocated;
 375   }
 376
 377   XenGrantTableInit (Dev);
 378
 379   Status = XenStoreInit (Dev);
 380   ASSERT_EFI_ERROR (Status);
 381
 382   XenBusEnumerateBus (Dev);
 383
 384   Status = gBS->CreateEvent (
 385                   EVT_SIGNAL_EXIT_BOOT_SERVICES,
 386                   TPL_CALLBACK,
 387                   NotifyExitBoot,
 388                   (VOID *)Dev,
 389                   &Dev->ExitBootEvent
 390                   );
 391   ASSERT_EFI_ERROR (Status);
 392
 393   return EFI_SUCCESS;
 394
 395 ErrorAllocated:
 396   FreePool (Dev);
 397   gBS->CloseProtocol (
 398          ControllerHandle,
 399          &gEfiDevicePathProtocolGuid,
 400          This->DriverBindingHandle,
 401          ControllerHandle
 402          );
 403 ErrorOpenningProtocol:
 404   gBS->CloseProtocol (
 405          ControllerHandle,
 406          &gXenIoProtocolGuid,
 407          This->DriverBindingHandle,
 408          ControllerHandle
 409          );
 410   return Status;
 411 }
 412
 413 /**
 414   Stops a bus controller.
 415
 416   The Stop() function is designed to be invoked from the EFI boot service DisconnectController().
 417   As a result, much of the error checking on the parameters to Stop() has been moved
 418   into this common boot service. It is legal to call Stop() from other locations,
 419   but the following calling restrictions must be followed, or the system behavior will not be deterministic.
 420   1. ControllerHandle must be a valid EFI_HANDLE that was used on a previous call to this
 421      same driver's Start() function.
 422   2. The first NumberOfChildren handles of ChildHandleBuffer must all be a valid
 423      EFI_HANDLE. In addition, all of these handles must have been created in this driver's
 424      Start() function, and the Start() function must have called OpenProtocol() on
 425      ControllerHandle with an Attribute of EFI_OPEN_PROTOCOL_BY_CHILD_CONTROLLER.
 426
 427   @param[in]  This              A pointer to the EFI_DRIVER_BINDING_PROTOCOL instance.
 428   @param[in]  ControllerHandle  A handle to the device being stopped. The handle must
 429                                 support a bus specific I/O protocol for the driver
 430                                 to use to stop the device.
 431   @param[in]  NumberOfChildren  The number of child device handles in ChildHandleBuffer.
 432   @param[in]  ChildHandleBuffer An array of child handles to be freed. May be NULL
 433                                 if NumberOfChildren is 0.
 434
 435   @retval EFI_SUCCESS           The device was stopped.
 436   @retval EFI_DEVICE_ERROR      The device could not be stopped due to a device error.
 437
 438 **/
 439 EFI_STATUS
 440 EFIAPI
 441 XenBusDxeDriverBindingStop (
 442   IN EFI_DRIVER_BINDING_PROTOCOL  *This,
 443   IN EFI_HANDLE                   ControllerHandle,
 444   IN UINTN                        NumberOfChildren,
 445   IN EFI_HANDLE                   *ChildHandleBuffer OPTIONAL
 446   )
 447 {
 448   UINTN                Index;
 449   XENBUS_PROTOCOL      *XenBusIo;
 450   XENBUS_PRIVATE_DATA  *ChildData;
 451   EFI_STATUS           Status;
 452   XENBUS_DEVICE        *Dev = mMyDevice;
 453
 454   for (Index = 0; Index < NumberOfChildren; Index++) {
 455     Status = gBS->OpenProtocol (
 456                     ChildHandleBuffer[Index],
 457                     &gXenBusProtocolGuid,
 458                     (VOID **)&XenBusIo,
 459                     This->DriverBindingHandle,
 460                     ControllerHandle,
 461                     EFI_OPEN_PROTOCOL_GET_PROTOCOL
 462                     );
 463     if (EFI_ERROR (Status)) {
 464       DEBUG ((DEBUG_ERROR, "XenBusDxe: get children protocol failed: %r\n", Status));
 465       continue;
 466     }
 467
 468     ChildData = XENBUS_PRIVATE_DATA_FROM_THIS (XenBusIo);
 469
 470     Status = gBS->CloseProtocol (
 471                     Dev->ControllerHandle,
 472                     &gXenIoProtocolGuid,
 473                     Dev->This->DriverBindingHandle,
 474                     ChildData->Handle
 475                     );
 476     ASSERT_EFI_ERROR (Status);
 477
 478     Status = gBS->UninstallMultipleProtocolInterfaces (
 479                     ChildData->Handle,
 480                     &gEfiDevicePathProtocolGuid,
 481                     ChildData->DevicePath,
 482                     &gXenBusProtocolGuid,
 483                     &ChildData->XenBusIo,
 484                     NULL
 485                     );
 486     ASSERT_EFI_ERROR (Status);
 487
 488     FreePool ((VOID *)ChildData->XenBusIo.Type);
 489     FreePool ((VOID *)ChildData->XenBusIo.Node);
 490     FreePool ((VOID *)ChildData->XenBusIo.Backend);
 491     FreePool (ChildData->DevicePath);
 492     RemoveEntryList (&ChildData->Link);
 493     FreePool (ChildData);
 494   }
 495
 496   if (NumberOfChildren > 0) {
 497     return EFI_SUCCESS;
 498   }
 499
 500   gBS->CloseEvent (Dev->ExitBootEvent);
 501   XenStoreDeinit (Dev);
 502   XenGrantTableDeinit (Dev);
 503
 504   gBS->CloseProtocol (
 505          ControllerHandle,
 506          &gEfiDevicePathProtocolGuid,
 507          This->DriverBindingHandle,
 508          ControllerHandle
 509          );
 510   gBS->CloseProtocol (
 511          ControllerHandle,
 512          &gXenIoProtocolGuid,
 513          This->DriverBindingHandle,
 514          ControllerHandle
 515          );
 516
 517   mMyDevice = NULL;
 518   FreePool (Dev);
 519   return EFI_SUCCESS;
 520 }