XenBusDxe.c

Go to the documentation of this file.

 
#include <Library/DebugLib.h>
#include <Library/XenHypercallLib.h>
 
#include "XenBusDxe.h"
 
#include "GrantTable.h"
#include "XenStore.h"
#include "XenBus.h"
 
#include <IndustryStandard/Xen/hvm/params.h>
#include <IndustryStandard/Xen/memory.h>
 
EFI_DRIVER_BINDING_PROTOCOL  gXenBusDxeDriverBinding = {
  XenBusDxeDriverBindingSupported,
  XenBusDxeDriverBindingStart,
  XenBusDxeDriverBindingStop,
  XENBUS_DXE_VERSION,
  NULL,
  NULL
};
 
STATIC EFI_LOCK       mMyDeviceLock = EFI_INITIALIZE_LOCK_VARIABLE (TPL_CALLBACK);
STATIC XENBUS_DEVICE  *mMyDevice    = NULL;
 
STATIC
EFI_STATUS
XenGetSharedInfoPage (
  IN OUT XENBUS_DEVICE  *Dev
  )
{
  xen_add_to_physmap_t  Parameter;
 
  ASSERT (Dev->SharedInfo == NULL);
 
  Parameter.domid = DOMID_SELF;
  Parameter.space = XENMAPSPACE_shared_info;
  Parameter.idx   = 0;
 
  //
  // using reserved page because the page is not released when Linux is
  // starting because of the add_to_physmap. QEMU might try to access the
  // page, and fail because it have no right to do so (segv).
  //
  Dev->SharedInfo = AllocateReservedPages (1);
  Parameter.gpfn  = (UINTN)Dev->SharedInfo >> EFI_PAGE_SHIFT;
  if (XenHypercallMemoryOp (XENMEM_add_to_physmap, &Parameter) != 0) {
    FreePages (Dev->SharedInfo, 1);
    Dev->SharedInfo = NULL;
    return EFI_LOAD_ERROR;
  }
 
  return EFI_SUCCESS;
}
 
EFI_STATUS
EFIAPI
XenBusDxeUnload (
  IN EFI_HANDLE  ImageHandle
  )
{
  EFI_STATUS  Status;
 
  EFI_HANDLE  *HandleBuffer;
  UINTN       HandleCount;
  UINTN       Index;
 
  //
  // Retrieve array of all handles in the handle database
  //
  Status = gBS->LocateHandleBuffer (
                  AllHandles,
                  NULL,
                  NULL,
                  &HandleCount,
                  &HandleBuffer
                  );
  if (EFI_ERROR (Status)) {
    return Status;
  }
 
  //
  // Disconnect the current driver from handles in the handle database
  //
  for (Index = 0; Index < HandleCount; Index++) {
    gBS->DisconnectController (HandleBuffer[Index], gImageHandle, NULL);
  }
 
  //
  // Free the array of handles
  //
  FreePool (HandleBuffer);
 
  //
  // Uninstall protocols installed in the driver entry point
  //
  Status = gBS->UninstallMultipleProtocolInterfaces (
                  ImageHandle,
                  &gEfiDriverBindingProtocolGuid,
                  &gXenBusDxeDriverBinding,
                  &gEfiComponentNameProtocolGuid,
                  &gXenBusDxeComponentName,
                  &gEfiComponentName2ProtocolGuid,
                  &gXenBusDxeComponentName2,
                  NULL
                  );
  if (EFI_ERROR (Status)) {
    return Status;
  }
 
  return EFI_SUCCESS;
}
 
EFI_STATUS
EFIAPI
XenBusDxeDriverEntryPoint (
  IN EFI_HANDLE        ImageHandle,
  IN EFI_SYSTEM_TABLE  *SystemTable
  )
{
  EFI_STATUS  Status;
 
  if (!XenHypercallIsAvailable ()) {
    return EFI_ABORTED;
  }
 
  //
  // Install UEFI Driver Model protocol(s).
  //
  Status = EfiLibInstallDriverBindingComponentName2 (
             ImageHandle,
             SystemTable,
             &gXenBusDxeDriverBinding,
             ImageHandle,
             &gXenBusDxeComponentName,
             &gXenBusDxeComponentName2
             );
  ASSERT_EFI_ERROR (Status);
 
  return Status;
}
 
EFI_STATUS
EFIAPI
XenBusDxeDriverBindingSupported (
  IN EFI_DRIVER_BINDING_PROTOCOL  *This,
  IN EFI_HANDLE                   ControllerHandle,
  IN EFI_DEVICE_PATH_PROTOCOL     *RemainingDevicePath OPTIONAL
  )
{
  EFI_STATUS      Status;
  XENIO_PROTOCOL  *XenIo;
 
  Status = gBS->OpenProtocol (
                  ControllerHandle,
                  &gXenIoProtocolGuid,
                  (VOID **)&XenIo,
                  This->DriverBindingHandle,
                  ControllerHandle,
                  EFI_OPEN_PROTOCOL_BY_DRIVER
                  );
 
  if (EFI_ERROR (Status)) {
    return Status;
  }
 
  gBS->CloseProtocol (
         ControllerHandle,
         &gXenIoProtocolGuid,
         This->DriverBindingHandle,
         ControllerHandle
         );
 
  return Status;
}
 
VOID
EFIAPI
NotifyExitBoot (
  IN EFI_EVENT  Event,
  IN VOID       *Context
  )
{
  XENBUS_DEVICE  *Dev = Context;
 
  gBS->DisconnectController (
         Dev->ControllerHandle,
         Dev->This->DriverBindingHandle,
         NULL
         );
}
 
EFI_STATUS
EFIAPI
XenBusDxeDriverBindingStart (
  IN EFI_DRIVER_BINDING_PROTOCOL  *This,
  IN EFI_HANDLE                   ControllerHandle,
  IN EFI_DEVICE_PATH_PROTOCOL     *RemainingDevicePath OPTIONAL
  )
{
  EFI_STATUS                Status;
  XENBUS_DEVICE             *Dev;
  XENIO_PROTOCOL            *XenIo;
  EFI_DEVICE_PATH_PROTOCOL  *DevicePath;
 
  Status = gBS->OpenProtocol (
                  ControllerHandle,
                  &gXenIoProtocolGuid,
                  (VOID **)&XenIo,
                  This->DriverBindingHandle,
                  ControllerHandle,
                  EFI_OPEN_PROTOCOL_BY_DRIVER
                  );
 
  if (EFI_ERROR (Status)) {
    return Status;
  }
 
  Status = gBS->OpenProtocol (
                  ControllerHandle,
                  &gEfiDevicePathProtocolGuid,
                  (VOID **)&DevicePath,
                  This->DriverBindingHandle,
                  ControllerHandle,
                  EFI_OPEN_PROTOCOL_BY_DRIVER
                  );
 
  if (EFI_ERROR (Status)) {
    goto ErrorOpenningProtocol;
  }
 
  Dev                   = AllocateZeroPool (sizeof (*Dev));
  Dev->Signature        = XENBUS_DEVICE_SIGNATURE;
  Dev->This             = This;
  Dev->ControllerHandle = ControllerHandle;
  Dev->XenIo            = XenIo;
  Dev->DevicePath       = DevicePath;
  InitializeListHead (&Dev->ChildList);
 
  EfiAcquireLock (&mMyDeviceLock);
  if (mMyDevice != NULL) {
    EfiReleaseLock (&mMyDeviceLock);
    //
    // There is already a XenBus running, only one can be used at a time.
    //
    Status = EFI_ALREADY_STARTED;
    goto ErrorAllocated;
  }
 
  mMyDevice = Dev;
  EfiReleaseLock (&mMyDeviceLock);
 
  Status = XenGetSharedInfoPage (Dev);
  if (EFI_ERROR (Status)) {
    DEBUG ((DEBUG_ERROR, "XenBus: Unable to get the shared info page.\n"));
    Status = EFI_UNSUPPORTED;
    goto ErrorAllocated;
  }
 
  XenGrantTableInit (Dev);
 
  Status = XenStoreInit (Dev);
  ASSERT_EFI_ERROR (Status);
 
  XenBusEnumerateBus (Dev);
 
  Status = gBS->CreateEvent (
                  EVT_SIGNAL_EXIT_BOOT_SERVICES,
                  TPL_CALLBACK,
                  NotifyExitBoot,
                  (VOID *)Dev,
                  &Dev->ExitBootEvent
                  );
  ASSERT_EFI_ERROR (Status);
 
  return EFI_SUCCESS;
 
ErrorAllocated:
  FreePool (Dev);
  gBS->CloseProtocol (
         ControllerHandle,
         &gEfiDevicePathProtocolGuid,
         This->DriverBindingHandle,
         ControllerHandle
         );
ErrorOpenningProtocol:
  gBS->CloseProtocol (
         ControllerHandle,
         &gXenIoProtocolGuid,
         This->DriverBindingHandle,
         ControllerHandle
         );
  return Status;
}
 
EFI_STATUS
EFIAPI
XenBusDxeDriverBindingStop (
  IN EFI_DRIVER_BINDING_PROTOCOL  *This,
  IN EFI_HANDLE                   ControllerHandle,
  IN UINTN                        NumberOfChildren,
  IN EFI_HANDLE                   *ChildHandleBuffer OPTIONAL
  )
{
  UINTN                Index;
  XENBUS_PROTOCOL      *XenBusIo;
  XENBUS_PRIVATE_DATA  *ChildData;
  EFI_STATUS           Status;
  XENBUS_DEVICE        *Dev = mMyDevice;
 
  for (Index = 0; Index < NumberOfChildren; Index++) {
    Status = gBS->OpenProtocol (
                    ChildHandleBuffer[Index],
                    &gXenBusProtocolGuid,
                    (VOID **)&XenBusIo,
                    This->DriverBindingHandle,
                    ControllerHandle,
                    EFI_OPEN_PROTOCOL_GET_PROTOCOL
                    );
    if (EFI_ERROR (Status)) {
      DEBUG ((DEBUG_ERROR, "XenBusDxe: get children protocol failed: %r\n", Status));
      continue;
    }
 
    ChildData = XENBUS_PRIVATE_DATA_FROM_THIS (XenBusIo);
 
    Status = gBS->CloseProtocol (
                    Dev->ControllerHandle,
                    &gXenIoProtocolGuid,
                    Dev->This->DriverBindingHandle,
                    ChildData->Handle
                    );
    ASSERT_EFI_ERROR (Status);
 
    Status = gBS->UninstallMultipleProtocolInterfaces (
                    ChildData->Handle,
                    &gEfiDevicePathProtocolGuid,
                    ChildData->DevicePath,
                    &gXenBusProtocolGuid,
                    &ChildData->XenBusIo,
                    NULL
                    );
    ASSERT_EFI_ERROR (Status);
 
    FreePool ((VOID *)ChildData->XenBusIo.Type);
    FreePool ((VOID *)ChildData->XenBusIo.Node);
    FreePool ((VOID *)ChildData->XenBusIo.Backend);
    FreePool (ChildData->DevicePath);
    RemoveEntryList (&ChildData->Link);
    FreePool (ChildData);
  }
 
  if (NumberOfChildren > 0) {
    return EFI_SUCCESS;
  }
 
  gBS->CloseEvent (Dev->ExitBootEvent);
  XenStoreDeinit (Dev);
  XenGrantTableDeinit (Dev);
 
  gBS->CloseProtocol (
         ControllerHandle,
         &gEfiDevicePathProtocolGuid,
         This->DriverBindingHandle,
         ControllerHandle
         );
  gBS->CloseProtocol (
         ControllerHandle,
         &gXenIoProtocolGuid,
         This->DriverBindingHandle,
         ControllerHandle
         );
 
  mMyDevice = NULL;
  FreePool (Dev);
  return EFI_SUCCESS;
}