[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index] [Xen-devel] [PATCH RFC 14/18] OvmfPkg/XenbusDxe: Indroduce XenBus support itself.
This is a bus-like on top of Xenstore. It will look for advertised ParaVirtualized devices and initialize them by producing XenBus protocol. Origin: FreeBSD 10.0 Contributed-under: TianoCore Contribution Agreement 1.0 Signed-off-by: Anthony PERARD <anthony.perard@xxxxxxxxxx> --- OvmfPkg/Include/Protocol/Xenbus.h | 9 + OvmfPkg/XenbusDxe/XenBus.c | 360 ++++++++++++++++++++++++++++++++++++++ OvmfPkg/XenbusDxe/XenBus.h | 76 ++++++++ OvmfPkg/XenbusDxe/XenbusDxe.c | 61 +++++++ OvmfPkg/XenbusDxe/XenbusDxe.h | 18 ++ OvmfPkg/XenbusDxe/XenbusDxe.inf | 3 + 6 files changed, 527 insertions(+) create mode 100644 OvmfPkg/XenbusDxe/XenBus.c create mode 100644 OvmfPkg/XenbusDxe/XenBus.h diff --git a/OvmfPkg/Include/Protocol/Xenbus.h b/OvmfPkg/Include/Protocol/Xenbus.h index ef4d0c2..25408c1 100644 --- a/OvmfPkg/Include/Protocol/Xenbus.h +++ b/OvmfPkg/Include/Protocol/Xenbus.h @@ -113,6 +113,14 @@ XENSTORE_STATUS ); typedef +XENSTORE_STATUS +(EFIAPI *XENBUS_SET_STATE)( + IN XENBUS_PROTOCOL *This, + IN XENSTORE_TRANSACTION Transaction, + IN XenbusState State + ); + +typedef EFI_STATUS (EFIAPI *XENBUS_GRANT_ACCESS)( IN XENBUS_PROTOCOL *This, @@ -171,6 +179,7 @@ struct _XENBUS_PROTOCOL { XENBUS_XS_REMOVE XsRemove; XENBUS_XS_TRANSACTION_START XsTransactionStart; XENBUS_XS_TRANSACTION_END XsTransactionEnd; + XENBUS_SET_STATE SetState; XENBUS_GRANT_ACCESS GrantAccess; XENBUS_GRANT_END_ACCESS GrantEndAccess; diff --git a/OvmfPkg/XenbusDxe/XenBus.c b/OvmfPkg/XenbusDxe/XenBus.c new file mode 100644 index 0000000..b0cf1ba --- /dev/null +++ b/OvmfPkg/XenbusDxe/XenBus.c @@ -0,0 +1,360 @@ +/****************************************************************************** + * Copyright (C) 2010 Spectra Logic Corporation + * Copyright (C) 2008 Doug Rabson + * Copyright (C) 2005 Rusty Russell, IBM Corporation + * Copyright (C) 2005 Mike Wray, Hewlett-Packard + * Copyright (C) 2005 XenSource Ltd + * + * This file may be distributed separately from the Linux kernel, or + * incorporated into other software packages, subject to the following license: + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this source file (the "Software"), to deal in the Software without + * restriction, including without limitation the rights to use, copy, modify, + * merge, publish, distribute, sublicense, and/or sell copies of the Software, + * and to permit persons to whom the Software is furnished to do so, subject to + * the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING + * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS + * IN THE SOFTWARE. + */ + +#include "XenbusDxe.h" + +#include <Library/PrintLib.h> + +#include "XenBus.h" +#include "GrantTable.h" +#include "Xenstore.h" +#include "EventChannel.h" + +#include <IndustryStandard/Xen/io/xenbus.h> + +STATIC XENBUS_PRIVATE_DATA gXenbusPrivateData; + +STATIC XENBUS_DEVICE_PATH gXenbusDevicePathTemplate = { + .Vendor.Header.Type = HARDWARE_DEVICE_PATH, + .Vendor.Header.SubType = HW_VENDOR_DP, + .Vendor.Header.Length[0] = (UINT8) sizeof (XENBUS_DEVICE_PATH), + .Vendor.Header.Length[1] = (UINT8) (sizeof (XENBUS_DEVICE_PATH) >> 8), + .Vendor.Guid = XENBUS_PROTOCOL_GUID, + .Type = 0, + .DeviceId = 0 +}; + + +/** + * Search our internal record of configured devices (not the XenStore) + * to determine if the XenBus device indicated by \a node is known to + * the system. + * + * \param Dev The XenBus bus instance to search for device children. + * \param node The XenStore node path for the device to find. + * + * \return The device_t of the found device if any, or NULL. + * + * \note device_t is a pointer type, so it can be compared against + * NULL for validity. + */ +STATIC +XENBUS_PRIVATE_DATA * +XenbusDeviceInitialized ( + IN XENBUS_DEVICE *Dev, + IN CONST CHAR8 *Node + ) +{ + LIST_ENTRY *Entry; + XENBUS_PRIVATE_DATA *Child; + XENBUS_PRIVATE_DATA *Result; + + if (IsListEmpty (&Dev->ChildList)) { + return NULL; + } + + Result = NULL; + for (Entry = GetFirstNode (&Dev->ChildList); + !IsNodeAtEnd (&Dev->ChildList, Entry); + Entry = GetNextNode (&Dev->ChildList, Entry)) { + Child = XENBUS_PRIVATE_DATA_FROM_LINK (Entry); + if (!AsciiStrCmp (Child->XenbusIo.Node, Node)) { + Result = Child; + break; + } + } + + return (Result); +} + +STATIC +XenbusState +XenbusReadDriverState ( + IN CONST CHAR8 *Path + ) +{ + XenbusState State; + CHAR8 *Ptr; + XENSTORE_STATUS Status; + + Status = XenstoreRead (XST_NIL, Path, "state", NULL, (VOID **)&Ptr); + if (Status != XENSTORE_STATUS_SUCCESS) { + State = XenbusStateClosed; + } else { + State = AsciiStrDecimalToUintn (Ptr); + FreePool (Ptr); + } + + return State; +} + +STATIC +EFI_STATUS +XenbusAddDevice ( + XENBUS_DEVICE *Dev, + CONST CHAR8 *Type, + CONST CHAR8 *Id) +{ + CHAR8 DevicePath[XENSTORE_ABS_PATH_MAX]; + XENSTORE_STATUS StatusXenstore; + XENBUS_PRIVATE_DATA *Private; + EFI_STATUS Status; + XENBUS_DEVICE_PATH *TempXenbusPath; + VOID *ChildPciIo; + + AsciiSPrint (DevicePath, sizeof (DevicePath), + XENBUS_XENSTORE_NODE "/%a/%a", Type, Id); + + Status = EFI_NOT_STARTED; //ENXIO; // Device not configured + + if (XenstorePathExists (XST_NIL, DevicePath, "")) { + XENBUS_PRIVATE_DATA *Child; + enum xenbus_state State; + CHAR8 *BackendPath; + + Child = XenbusDeviceInitialized (Dev, DevicePath); + if (Child != NULL) { + /* + * We are already tracking this node + */ + Status = EFI_SUCCESS; + goto out; + } + + State = XenbusReadDriverState (DevicePath); + if (State != XenbusStateInitialising) { + /* + * Device is not new, so ignore it. This can + * happen if a device is going away after + * switching to Closed. + */ + DEBUG ((EFI_D_INFO, "Xenbus: Device %a ignored. " + "State %d\n", DevicePath, State)); + Status = EFI_SUCCESS; + goto out; + } + + StatusXenstore = XenstoreRead (XST_NIL, DevicePath, "backend", + NULL, (VOID **) &BackendPath); + if (StatusXenstore != XENSTORE_STATUS_SUCCESS) { + DEBUG ((EFI_D_ERROR, "xenbus: %a no backend path.\n", DevicePath)); + Status = EFI_NOT_FOUND; + goto out; + } + + Private = AllocateCopyPool (sizeof *Private, &gXenbusPrivateData); + InsertTailList (&Dev->ChildList, &Private->Link); + + Private->XenbusIo.Type = AsciiStrDup (Type); + Private->XenbusIo.Node = AsciiStrDup (DevicePath); + Private->XenbusIo.Backend = BackendPath; + Private->XenbusIo.DeviceId = AsciiStrDecimalToUintn (Id); + Private->Dev = Dev; + + TempXenbusPath = AllocateCopyPool (sizeof (XENBUS_DEVICE_PATH), + &gXenbusDevicePathTemplate); + if (!AsciiStrCmp (Private->XenbusIo.Type, "vbd")) { + TempXenbusPath->Type = XENBUS_DEVICE_PATH_TYPE_VBD; + } + TempXenbusPath->DeviceId = Private->XenbusIo.DeviceId; + Private->DevicePath = (XENBUS_DEVICE_PATH *)AppendDevicePathNode ( + Dev->DevicePath, + &TempXenbusPath->Vendor.Header); + FreePool (TempXenbusPath); + + Status = gBS->InstallMultipleProtocolInterfaces ( + &Private->Handle, + &gEfiDevicePathProtocolGuid, Private->DevicePath, + &gXenbusProtocolGuid, &Private->XenbusIo, + NULL); + if (EFI_ERROR (Status)) { + return Status; + } + + Status = gBS->OpenProtocol (Dev->ControllerHandle, + &gEfiPciIoProtocolGuid, + &ChildPciIo, Dev->This->DriverBindingHandle, + Private->Handle, + EFI_OPEN_PROTOCOL_BY_CHILD_CONTROLLER); + if (EFI_ERROR (Status)) { + DEBUG ((EFI_D_ERROR, "open by child controller fail (%r)\n", + Status)); + } + } else { + DEBUG ((EFI_D_INFO, "Xenbus: does not exist: %a\n", DevicePath)); + } + +out: + return Status; +} + +/** + * \brief Enumerate all devices of the given type on this bus. + * + * \param Dev NewBus device_t for this XenBus front bus instance. + * \param type String indicating the device sub-tree (e.g. "vfb", "vif") + * to enumerate. + * + * Devices that are found are entered into the NewBus hierarchy via + * xenbusb_add_device(). xenbusb_add_device() ignores duplicate detects + * and ignores duplicate devices, so it can be called unconditionally + * for any device found in the XenStore. + */ +STATIC +VOID +XenbusEnumerateDeviceType ( + XENBUS_DEVICE *Dev, + CONST CHAR8 *Type + ) +{ + CONST CHAR8 **Directory; + UINTN Index; + UINT32 Count; + XENSTORE_STATUS Status; + + Status = XenstoreListDirectory (XST_NIL, + XENBUS_XENSTORE_NODE, Type, + &Count, &Directory); + if (Status != XENSTORE_STATUS_SUCCESS) { + return; + } + for (Index = 0; Index < Count; Index++) { + XenbusAddDevice (Dev, Type, Directory[Index]); + } + + FreePool (Directory); +} + + +/** + * \brief Enumerate the devices on a XenBus bus and register them with + * the NewBus device tree. + * + * xenbusb_enumerate_bus() will create entries (in state DS_NOTPRESENT) + * for nodes that appear in the XenStore, but will not invoke probe/attach + * operations on drivers. Probe/Attach processing must be separately + * performed via an invocation of xenbusb_probe_children(). This is usually + * done via the xbs_probe_children task. + * + * \param Dev XenBus Bus device softc of the owner of the bus to enumerate. + * + * \return On success, 0. Otherwise an errno value indicating the + * type of failure. + */ +XENSTORE_STATUS +XenbusEnumerateBus ( + XENBUS_DEVICE *Dev + ) +{ + CONST CHAR8 **Types; + UINTN Index; + UINT32 Count; + XENSTORE_STATUS Status; + + Status = XenstoreListDirectory (XST_NIL, + XENBUS_XENSTORE_NODE, "", + &Count, &Types); + if (Status != XENSTORE_STATUS_SUCCESS) { + return Status; + } + + for (Index = 0; Index < Count; Index++) { + XenbusEnumerateDeviceType (Dev, Types[Index]); + } + + FreePool (Types); + + return XENSTORE_STATUS_SUCCESS; +} + +STATIC +XENSTORE_STATUS +EFIAPI +XenbusSetState ( + IN XENBUS_PROTOCOL *This, + IN XENSTORE_TRANSACTION Transaction, + IN enum xenbus_state NewState + ) +{ + XENBUS_PRIVATE_DATA *Private; + enum xenbus_state CurrentState; + XENSTORE_STATUS Status; + CHAR8 *Temp; + + DEBUG ((EFI_D_INFO, "Xenbus: Set state to %d\n", NewState)); + + Private = XENBUS_PRIVATE_DATA_FROM_THIS (This); + + Status = XenstoreRead (Transaction, This->Node, "state", NULL, (VOID **)&Temp); + if (Status != XENSTORE_STATUS_SUCCESS) { + goto Error; + } + CurrentState = AsciiStrDecimalToUintn (Temp); + FreePool (Temp); + if (CurrentState == NewState) { + DEBUG ((EFI_D_INFO, "%a %d, same state\n", __func__, __LINE__)); + goto Error; + } + + do { + Status = XenstoreSPrint (Transaction, This->Node, "state", "%d", NewState); + } while (Status == XENSTORE_STATUS_EAGAIN); + if (Status != XENSTORE_STATUS_SUCCESS) { + DEBUG ((EFI_D_ERROR, "Xenbus: fail to writing new state\n")); + goto Error; + } + DEBUG ((EFI_D_INFO, "Xenbus: Set state to %d, done\n", NewState)); + +Error: + return Status; +} + +STATIC XENBUS_PRIVATE_DATA gXenbusPrivateData = { + .Signature = XENBUS_PRIVATE_DATA_SIGNATURE, + + .XenbusIo.XsRead = XenbusXenstoreRead, + .XenbusIo.XsBackendRead = XenbusXenstoreBackendRead, + .XenbusIo.XsPrintf = XenbusXenstoreSPrint, + .XenbusIo.XsRemove = XenbusXenstoreRemove, + .XenbusIo.XsTransactionStart = XenbusXenstoreTransactionStart, + .XenbusIo.XsTransactionEnd = XenbusXenstoreTransactionEnd, + .XenbusIo.SetState = XenbusSetState, + .XenbusIo.GrantAccess = XenbusGrantAccess, + .XenbusIo.GrantEndAccess = XenbusGrantEndAccess, + .XenbusIo.RegisterWatch = XenbusRegisterWatch, + .XenbusIo.RegisterWatchBackend = XenbusRegisterWatchBackend, + .XenbusIo.UnregisterWatch = XenbusUnregisterWatch, + .XenbusIo.WaitForWatch = XenbusWaitForWatch, + + .XenbusIo.Type = NULL, + .XenbusIo.Node = NULL, + .XenbusIo.Backend = NULL, + + .Dev = NULL +}; diff --git a/OvmfPkg/XenbusDxe/XenBus.h b/OvmfPkg/XenbusDxe/XenBus.h new file mode 100644 index 0000000..63d0815 --- /dev/null +++ b/OvmfPkg/XenbusDxe/XenBus.h @@ -0,0 +1,76 @@ +/*- + * Core definitions and data structures shareable across OS platforms. + * + * Copyright (c) 2010 Spectra Logic Corporation + * Copyright (C) 2008 Doug Rabson + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions, and the following disclaimer, + * without modification. + * 2. Redistributions in binary form must reproduce at minimum a disclaimer + * substantially similar to the "NO WARRANTY" disclaimer below + * ("Disclaimer") and any redistribution must be conditioned upon + * including a substantially similar Disclaimer requirement for further + * binary redistribution. + * + * NO WARRANTY + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * HOLDERS OR CONTRIBUTORS BE LIABLE FOR SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, + * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING + * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + * POSSIBILITY OF SUCH DAMAGES. + * + * $FreeBSD: release/10.0.0/sys/xen/xenbus/xenbusb.h 222975 2011-06-11 04:59:01Z gibbs $ + */ +#ifndef _XEN_XENBUS_XENBUSB_H +#define _XEN_XENBUS_XENBUSB_H + +#include "XenbusDxe.h" + +#define XENBUS_DEVICE_PATH_TYPE_VBD 0x1 +struct _XENBUS_DEVICE_PATH { + VENDOR_DEVICE_PATH Vendor; + UINT8 Type; + UINT16 DeviceId; +}; + +/** + * The VM relative path to the XenStore subtree this + * bus attachment manages. + * + * OR + * + * The XenStore path to the XenStore subtree for this XenBus bus. + */ +#define XENBUS_XENSTORE_NODE "device" + + +/** + * \brief Perform common XenBus bus attach processing. + * + * \param Dev The NewBus device representing this XenBus bus. + * + * \return On success, 0. Otherwise an errno value indicating the + * type of failure. + * + * Intiailizes the softc for this bus, installs an interrupt driven + * configuration hook to block boot processing until XenBus devices fully + * configure, performs an initial probe/attach of the bus, and registers + * a XenStore watch so we are notified when the bus topology changes. + */ +XENSTORE_STATUS +XenbusEnumerateBus ( + XENBUS_DEVICE *Dev + ); + +#endif /* _XEN_XENBUS_XENBUSB_H */ diff --git a/OvmfPkg/XenbusDxe/XenbusDxe.c b/OvmfPkg/XenbusDxe/XenbusDxe.c index 2c85d5e..56225c4 100644 --- a/OvmfPkg/XenbusDxe/XenbusDxe.c +++ b/OvmfPkg/XenbusDxe/XenbusDxe.c @@ -19,6 +19,7 @@ #include "XenHypercall.h" #include "GrantTable.h" #include "Xenstore.h" +#include "XenBus.h" /// /// Driver Binding Protocol instance @@ -295,6 +296,7 @@ XenbusDxeDriverBindingStart ( EFI_PCI_IO_PROTOCOL *PciIo; EFI_ACPI_ADDRESS_SPACE_DESCRIPTOR *BarDesc; UINT64 MmioAddr; + EFI_DEVICE_PATH_PROTOCOL *DevicePath; Status = gBS->OpenProtocol ( ControllerHandle, @@ -308,11 +310,26 @@ XenbusDxeDriverBindingStart ( return Status; } + Status = gBS->OpenProtocol ( + ControllerHandle, + &gEfiDevicePathProtocolGuid, + (VOID **) &DevicePath, + This->DriverBindingHandle, + ControllerHandle, + EFI_OPEN_PROTOCOL_BY_DRIVER + ); + + if (EFI_ERROR (Status)) { + return Status; + } + Dev = AllocateZeroPool (sizeof (*Dev)); Dev->Signature = XENBUS_DEVICE_SIGNATURE; Dev->This = This; Dev->ControllerHandle = ControllerHandle; Dev->PciIo = PciIo; + Dev->DevicePath = DevicePath; + InitializeListHead (&Dev->ChildList); Status = PciIo->GetBarAttributes (PciIo, PCI_BAR_IDX1, NULL, (VOID**) &BarDesc); ASSERT_EFI_ERROR (Status); @@ -334,6 +351,8 @@ XenbusDxeDriverBindingStart ( Status = XenstoreInit (Dev); ASSERT_EFI_ERROR (Status); + XenbusEnumerateBus (Dev); + Status = gBS->CreateEvent (EVT_SIGNAL_EXIT_BOOT_SERVICES, TPL_CALLBACK, NotifyExitBoot, (VOID*) Dev, @@ -379,12 +398,54 @@ XenbusDxeDriverBindingStop ( 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 ((EFI_D_ERROR, "XenbusDxe: get childre proto: %r\n", Status)); + continue; + } + ChildData = XENBUS_PRIVATE_DATA_FROM_THIS(XenbusIo); + Status = gBS->DisconnectController(ChildData->Handle, NULL, NULL); + if (EFI_ERROR (Status)) { + DEBUG ((EFI_D_ERROR, "XenbusDxe: error disconnecting child: %r\n", + Status)); + continue; + } + + 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); + } + gBS->CloseEvent (Dev->ExitBootEvent); + // XXX xenbus cleanup // XXX xenstore cleanup XenGrantTableDeinit (Dev); + gBS->CloseProtocol(ControllerHandle, &gEfiDevicePathProtocolGuid, + This->DriverBindingHandle, ControllerHandle); gBS->CloseProtocol(ControllerHandle, &gEfiPciIoProtocolGuid, This->DriverBindingHandle, ControllerHandle); return EFI_SUCCESS; diff --git a/OvmfPkg/XenbusDxe/XenbusDxe.h b/OvmfPkg/XenbusDxe/XenbusDxe.h index 4d9db72..3ff08dd 100644 --- a/OvmfPkg/XenbusDxe/XenbusDxe.h +++ b/OvmfPkg/XenbusDxe/XenbusDxe.h @@ -80,6 +80,7 @@ extern EFI_COMPONENT_NAME_PROTOCOL gXenbusDxeComponentName; #define PCI_DEVICE_ID_XEN_PLATFORM 0x0001 +typedef struct _XENBUS_DEVICE_PATH XENBUS_DEVICE_PATH; typedef struct _XENBUS_DEVICE XENBUS_DEVICE; #define XENBUS_DEVICE_SIGNATURE SIGNATURE_32 ('X','B','b','d') @@ -89,11 +90,28 @@ struct _XENBUS_DEVICE { EFI_HANDLE ControllerHandle; EFI_PCI_IO_PROTOCOL *PciIo; EFI_EVENT ExitBootEvent; + EFI_DEVICE_PATH_PROTOCOL *DevicePath; + LIST_ENTRY ChildList; VOID *Hyperpage; shared_info_t *SharedInfo; }; +#define XENBUS_PRIVATE_DATA_SIGNATURE SIGNATURE_32 ('X', 'B', 'u', 's') +typedef struct { + UINTN Signature; + LIST_ENTRY Link; + EFI_HANDLE Handle; + XENBUS_PROTOCOL XenbusIo; + XENBUS_DEVICE *Dev; + XENBUS_DEVICE_PATH *DevicePath; +} XENBUS_PRIVATE_DATA; + +#define XENBUS_PRIVATE_DATA_FROM_THIS(a) \ + CR (a, XENBUS_PRIVATE_DATA, XenbusIo, XENBUS_PRIVATE_DATA_SIGNATURE) +#define XENBUS_PRIVATE_DATA_FROM_LINK(a) \ + CR (a, XENBUS_PRIVATE_DATA, Link, XENBUS_PRIVATE_DATA_SIGNATURE) + /* * Helpers */ diff --git a/OvmfPkg/XenbusDxe/XenbusDxe.inf b/OvmfPkg/XenbusDxe/XenbusDxe.inf index 6c8260f..708fae6 100644 --- a/OvmfPkg/XenbusDxe/XenbusDxe.inf +++ b/OvmfPkg/XenbusDxe/XenbusDxe.inf @@ -40,6 +40,9 @@ EventChannel.h Xenstore.c Xenstore.h + XenBus.c + XenBus.h + Helpers.c [Sources.X64] X64/hypercall.S -- Anthony PERARD _______________________________________________ Xen-devel mailing list Xen-devel@xxxxxxxxxxxxx http://lists.xen.org/xen-devel
|
Lists.xenproject.org is hosted with RackSpace, monitoring our |