mirror of
https://github.com/acidanthera/audk.git
synced 2025-08-23 10:38:09 +02:00
862 lines
19 KiB
C
862 lines
19 KiB
C
/** @file
|
|
This driver constructs User space wrappers for the EFI_BOOT_SERVICES.
|
|
|
|
Copyright (c) 2024 - 2025, Mikhail Krichanov. All rights reserved.
|
|
SPDX-License-Identifier: BSD-3-Clause
|
|
|
|
**/
|
|
|
|
#include <Uefi.h>
|
|
|
|
#include <Guid/MemoryProfile.h>
|
|
|
|
#include <Library/BaseMemoryLib.h>
|
|
#include <Library/DebugLib.h>
|
|
#include <Library/MemoryPoolLib.h>
|
|
|
|
#include "UserSpace.h"
|
|
|
|
BOOLEAN mOnGuarding = FALSE;
|
|
|
|
STATIC UINTN mMemoryTypes[MAX_MEMORY_TYPE];
|
|
STATIC UINTN mNumberOfUsers = 0;
|
|
|
|
STATIC
|
|
UINTN
|
|
EFIAPI
|
|
GetMemoryType (
|
|
IN UINTN UserPageTable
|
|
)
|
|
{
|
|
UINTN Index;
|
|
|
|
for (Index = 0; Index < mNumberOfUsers; ++Index) {
|
|
if (mMemoryTypes[Index] == UserPageTable) {
|
|
return Index;
|
|
}
|
|
}
|
|
|
|
ASSERT (mNumberOfUsers < MAX_MEMORY_TYPE);
|
|
|
|
mMemoryTypes[mNumberOfUsers] = UserPageTable;
|
|
++mNumberOfUsers;
|
|
|
|
return (mNumberOfUsers - 1);
|
|
}
|
|
|
|
STATIC
|
|
EFI_STATUS
|
|
EFIAPI
|
|
FixInterface (
|
|
IN EFI_GUID *Protocol,
|
|
IN OUT VOID **Interface
|
|
)
|
|
{
|
|
EFI_LOADED_IMAGE_PROTOCOL *LoadedImage;
|
|
EFI_BLOCK_IO_PROTOCOL *BlockIo;
|
|
EFI_DISK_IO_PROTOCOL *DiskIo;
|
|
EFI_DEVICE_PATH_UTILITIES_PROTOCOL *DevicePath;
|
|
EFI_UNICODE_COLLATION_PROTOCOL *Unicode;
|
|
|
|
ASSERT (Protocol != NULL);
|
|
ASSERT (Interface != NULL);
|
|
|
|
if (CompareGuid (Protocol, &gEfiDevicePathProtocolGuid)) {
|
|
|
|
} else if (CompareGuid (Protocol, &gEfiLoadedImageProtocolGuid)) {
|
|
|
|
LoadedImage = (EFI_LOADED_IMAGE_PROTOCOL *)*Interface;
|
|
|
|
LoadedImage->Unload = NULL;
|
|
|
|
} else if (CompareGuid (Protocol, &gEfiBlockIoProtocolGuid)) {
|
|
|
|
BlockIo = (EFI_BLOCK_IO_PROTOCOL *)*Interface;
|
|
|
|
BlockIo->Reset = UserSpaceBlockIoReset;
|
|
BlockIo->ReadBlocks = UserSpaceBlockIoRead;
|
|
BlockIo->WriteBlocks = UserSpaceBlockIoWrite;
|
|
BlockIo->FlushBlocks = UserSpaceBlockIoFlush;
|
|
|
|
} else if (CompareGuid (Protocol, &gEfiDiskIoProtocolGuid)) {
|
|
|
|
DiskIo = (EFI_DISK_IO_PROTOCOL *)*Interface;
|
|
|
|
DiskIo->ReadDisk = UserSpaceDiskIoRead;
|
|
DiskIo->WriteDisk = UserSpaceDiskIoWrite;
|
|
|
|
} else if (CompareGuid (Protocol, &gEfiDevicePathUtilitiesProtocolGuid)) {
|
|
DevicePath = (EFI_DEVICE_PATH_UTILITIES_PROTOCOL *)*Interface;
|
|
|
|
DevicePath->GetDevicePathSize = NULL;
|
|
DevicePath->DuplicateDevicePath = NULL;
|
|
DevicePath->AppendDevicePath = NULL;
|
|
DevicePath->AppendDeviceNode = NULL;
|
|
DevicePath->AppendDevicePathInstance = NULL;
|
|
DevicePath->GetNextDevicePathInstance = NULL;
|
|
DevicePath->IsDevicePathMultiInstance = NULL;
|
|
DevicePath->CreateDeviceNode = NULL;
|
|
|
|
} else if (CompareGuid (Protocol, &gEfiUnicodeCollationProtocolGuid)) {
|
|
Unicode = (EFI_UNICODE_COLLATION_PROTOCOL *)*Interface;
|
|
|
|
Unicode->StriColl = UserSpaceUnicodeStriColl;
|
|
Unicode->MetaiMatch = UserSpaceUnicodeMetaiMatch;
|
|
Unicode->StrLwr = UserSpaceUnicodeStrLwr;
|
|
Unicode->StrUpr = UserSpaceUnicodeStrUpr;
|
|
Unicode->FatToStr = UserSpaceUnicodeFatToStr;
|
|
Unicode->StrToFat = UserSpaceUnicodeStrToFat;
|
|
|
|
} else {
|
|
return EFI_UNSUPPORTED;
|
|
}
|
|
|
|
return EFI_SUCCESS;
|
|
}
|
|
|
|
EFI_TPL
|
|
EFIAPI
|
|
UserSpaceRaiseTpl (
|
|
IN EFI_TPL NewTpl
|
|
)
|
|
{
|
|
return (EFI_TPL)SysCall (
|
|
SysCallRaiseTpl,
|
|
1,
|
|
NewTpl
|
|
);
|
|
}
|
|
|
|
VOID
|
|
EFIAPI
|
|
UserSpaceRestoreTpl (
|
|
IN EFI_TPL NewTpl
|
|
)
|
|
{
|
|
SysCall (
|
|
SysCallRestoreTpl,
|
|
1,
|
|
NewTpl
|
|
);
|
|
}
|
|
|
|
EFI_STATUS
|
|
EFIAPI
|
|
UserSpaceAllocatePages (
|
|
IN EFI_ALLOCATE_TYPE Type,
|
|
IN EFI_MEMORY_TYPE MemoryType,
|
|
IN UINTN NumberOfPages,
|
|
IN OUT EFI_PHYSICAL_ADDRESS *Memory
|
|
)
|
|
{
|
|
EFI_STATUS Status;
|
|
|
|
Status = SysCall (
|
|
SysCallAllocatePages,
|
|
4,
|
|
Type,
|
|
EfiUserSpaceMemoryType,
|
|
NumberOfPages,
|
|
Memory
|
|
);
|
|
if (EFI_ERROR (Status)) {
|
|
DEBUG ((DEBUG_ERROR, "UserSpace: Failed to allocate %d pages.\n", NumberOfPages));
|
|
}
|
|
|
|
return Status;
|
|
}
|
|
|
|
EFI_STATUS
|
|
EFIAPI
|
|
UserSpaceFreePages (
|
|
IN EFI_PHYSICAL_ADDRESS Memory,
|
|
IN UINTN NumberOfPages
|
|
)
|
|
{
|
|
EFI_STATUS Status;
|
|
|
|
Status = SysCall (
|
|
SysCallFreePages,
|
|
2,
|
|
NumberOfPages,
|
|
Memory
|
|
);
|
|
if (EFI_ERROR (Status)) {
|
|
DEBUG ((DEBUG_ERROR, "UserSpace: Failed to free %d pages.\n", NumberOfPages));
|
|
}
|
|
|
|
return Status;
|
|
}
|
|
|
|
EFI_STATUS
|
|
EFIAPI
|
|
UserSpaceGetMemoryMap (
|
|
IN OUT UINTN *MemoryMapSize,
|
|
IN OUT EFI_MEMORY_DESCRIPTOR *MemoryMap,
|
|
OUT UINTN *MapKey,
|
|
OUT UINTN *DescriptorSize,
|
|
OUT UINT32 *DescriptorVersion
|
|
)
|
|
{
|
|
DEBUG ((DEBUG_ERROR, "UserSpace: GetMemoryMap is not supported\n"));
|
|
|
|
return EFI_UNSUPPORTED;
|
|
}
|
|
|
|
EFI_STATUS
|
|
EFIAPI
|
|
UserSpaceAllocatePool (
|
|
IN EFI_MEMORY_TYPE PoolType,
|
|
IN UINTN Size,
|
|
OUT VOID **Buffer
|
|
)
|
|
{
|
|
UINTN CurrentUser;
|
|
|
|
CurrentUser = (UINTN)SysCall (SysCallGetUserPageTable, 0);
|
|
|
|
PoolType = GetMemoryType (CurrentUser);
|
|
|
|
return CoreAllocatePool (PoolType, Size, Buffer);
|
|
}
|
|
|
|
EFI_STATUS
|
|
EFIAPI
|
|
UserSpaceFreePool (
|
|
IN VOID *Buffer
|
|
)
|
|
{
|
|
return CoreFreePool (Buffer);
|
|
}
|
|
|
|
EFI_STATUS
|
|
EFIAPI
|
|
UserSpaceCreateEvent (
|
|
IN UINT32 Type,
|
|
IN EFI_TPL NotifyTpl,
|
|
IN EFI_EVENT_NOTIFY NotifyFunction OPTIONAL,
|
|
IN VOID *NotifyContext OPTIONAL,
|
|
OUT EFI_EVENT *Event
|
|
)
|
|
{
|
|
DEBUG ((DEBUG_ERROR, "UserSpace: CreateEvent is not supported\n"));
|
|
|
|
return EFI_UNSUPPORTED;
|
|
}
|
|
|
|
EFI_STATUS
|
|
EFIAPI
|
|
UserSpaceSetTimer (
|
|
IN EFI_EVENT UserEvent,
|
|
IN EFI_TIMER_DELAY Type,
|
|
IN UINT64 TriggerTime
|
|
)
|
|
{
|
|
DEBUG ((DEBUG_ERROR, "UserSpace: SetTimer is not supported\n"));
|
|
|
|
return EFI_UNSUPPORTED;
|
|
}
|
|
|
|
EFI_STATUS
|
|
EFIAPI
|
|
UserSpaceWaitForEvent (
|
|
IN UINTN NumberOfEvents,
|
|
IN EFI_EVENT *UserEvents,
|
|
OUT UINTN *UserIndex
|
|
)
|
|
{
|
|
DEBUG ((DEBUG_ERROR, "UserSpace: WaitForEvent is not supported\n"));
|
|
|
|
return EFI_UNSUPPORTED;
|
|
}
|
|
|
|
EFI_STATUS
|
|
EFIAPI
|
|
UserSpaceSignalEvent (
|
|
IN EFI_EVENT UserEvent
|
|
)
|
|
{
|
|
DEBUG ((DEBUG_ERROR, "UserSpace: SignalEvent is not supported\n"));
|
|
|
|
return EFI_UNSUPPORTED;
|
|
}
|
|
|
|
EFI_STATUS
|
|
EFIAPI
|
|
UserSpaceCloseEvent (
|
|
IN EFI_EVENT UserEvent
|
|
)
|
|
{
|
|
DEBUG ((DEBUG_ERROR, "UserSpace: CloseEvent is not supported\n"));
|
|
|
|
return EFI_UNSUPPORTED;
|
|
}
|
|
|
|
EFI_STATUS
|
|
EFIAPI
|
|
UserSpaceCheckEvent (
|
|
IN EFI_EVENT UserEvent
|
|
)
|
|
{
|
|
DEBUG ((DEBUG_ERROR, "UserSpace: CheckEvent is not supported\n"));
|
|
|
|
return EFI_UNSUPPORTED;
|
|
}
|
|
|
|
EFI_STATUS
|
|
EFIAPI
|
|
UserSpaceInstallProtocolInterface (
|
|
IN OUT EFI_HANDLE *UserHandle,
|
|
IN EFI_GUID *Protocol,
|
|
IN EFI_INTERFACE_TYPE InterfaceType,
|
|
IN VOID *Interface
|
|
)
|
|
{
|
|
DEBUG ((DEBUG_ERROR, "UserSpace: InstallProtocolInterface is not supported\n"));
|
|
|
|
return EFI_UNSUPPORTED;
|
|
}
|
|
|
|
EFI_STATUS
|
|
EFIAPI
|
|
UserSpaceReinstallProtocolInterface (
|
|
IN EFI_HANDLE UserHandle,
|
|
IN EFI_GUID *Protocol,
|
|
IN VOID *OldInterface,
|
|
IN VOID *NewInterface
|
|
)
|
|
{
|
|
DEBUG ((DEBUG_ERROR, "UserSpace: ReinstallProtocolInterface is not supported\n"));
|
|
|
|
return EFI_UNSUPPORTED;
|
|
}
|
|
|
|
EFI_STATUS
|
|
EFIAPI
|
|
UserSpaceUninstallProtocolInterface (
|
|
IN EFI_HANDLE UserHandle,
|
|
IN EFI_GUID *Protocol,
|
|
IN VOID *Interface
|
|
)
|
|
{
|
|
DEBUG ((DEBUG_ERROR, "UserSpace: UninstallProtocolInterface is not supported\n"));
|
|
|
|
return EFI_UNSUPPORTED;
|
|
}
|
|
|
|
EFI_STATUS
|
|
EFIAPI
|
|
UserSpaceHandleProtocol (
|
|
IN EFI_HANDLE CoreUserHandle,
|
|
IN EFI_GUID *Protocol,
|
|
OUT VOID **Interface
|
|
)
|
|
{
|
|
EFI_STATUS Status;
|
|
|
|
Status = SysCall (
|
|
SysCallHandleProtocol,
|
|
3,
|
|
CoreUserHandle,
|
|
Protocol,
|
|
Interface
|
|
);
|
|
if (EFI_ERROR (Status)) {
|
|
DEBUG ((DEBUG_ERROR, "UserSpace: Failed to get handle of protocol %g - %r\n", Protocol, Status));
|
|
return Status;
|
|
}
|
|
|
|
return FixInterface (Protocol, Interface);
|
|
}
|
|
|
|
EFI_STATUS
|
|
EFIAPI
|
|
UserSpaceRegisterProtocolNotify (
|
|
IN EFI_GUID *Protocol,
|
|
IN EFI_EVENT Event,
|
|
OUT VOID **Registration
|
|
)
|
|
{
|
|
DEBUG ((DEBUG_ERROR, "UserSpace: RegisterProtocolNotify is not supported\n"));
|
|
|
|
return EFI_UNSUPPORTED;
|
|
}
|
|
|
|
EFI_STATUS
|
|
EFIAPI
|
|
UserSpaceLocateHandle (
|
|
IN EFI_LOCATE_SEARCH_TYPE SearchType,
|
|
IN EFI_GUID *Protocol OPTIONAL,
|
|
IN VOID *SearchKey OPTIONAL,
|
|
IN OUT UINTN *BufferSize,
|
|
OUT EFI_HANDLE *Buffer
|
|
)
|
|
{
|
|
DEBUG ((DEBUG_ERROR, "UserSpace: LocateHandle is not supported\n"));
|
|
|
|
return EFI_UNSUPPORTED;
|
|
}
|
|
|
|
EFI_STATUS
|
|
EFIAPI
|
|
UserSpaceLocateDevicePath (
|
|
IN EFI_GUID *Protocol,
|
|
IN OUT EFI_DEVICE_PATH_PROTOCOL **DevicePath,
|
|
OUT EFI_HANDLE *Device
|
|
)
|
|
{
|
|
DEBUG ((DEBUG_ERROR, "UserSpace: LocateDevicePath is not supported\n"));
|
|
|
|
return EFI_UNSUPPORTED;
|
|
}
|
|
|
|
EFI_STATUS
|
|
EFIAPI
|
|
UserSpaceInstallConfigurationTable (
|
|
IN EFI_GUID *Guid,
|
|
IN VOID *Table
|
|
)
|
|
{
|
|
DEBUG ((DEBUG_ERROR, "UserSpace: InstallConfigurationTable is not supported\n"));
|
|
|
|
return EFI_UNSUPPORTED;
|
|
}
|
|
|
|
EFI_STATUS
|
|
EFIAPI
|
|
UserSpaceLoadImage (
|
|
IN BOOLEAN BootPolicy,
|
|
IN EFI_HANDLE ParentImageHandle,
|
|
IN EFI_DEVICE_PATH_PROTOCOL *FilePath,
|
|
IN VOID *SourceBuffer OPTIONAL,
|
|
IN UINTN SourceSize,
|
|
OUT EFI_HANDLE *ImageHandle
|
|
)
|
|
{
|
|
DEBUG ((DEBUG_ERROR, "UserSpace: LoadImage is not supported\n"));
|
|
|
|
return EFI_UNSUPPORTED;
|
|
}
|
|
|
|
EFI_STATUS
|
|
EFIAPI
|
|
UserSpaceStartImage (
|
|
IN EFI_HANDLE ImageHandle,
|
|
OUT UINTN *ExitDataSize,
|
|
OUT CHAR16 **ExitData OPTIONAL
|
|
)
|
|
{
|
|
DEBUG ((DEBUG_ERROR, "UserSpace: StartImage is not supported\n"));
|
|
|
|
return EFI_UNSUPPORTED;
|
|
}
|
|
|
|
EFI_STATUS
|
|
EFIAPI
|
|
UserSpaceExit (
|
|
IN EFI_HANDLE ImageHandle,
|
|
IN EFI_STATUS Status,
|
|
IN UINTN ExitDataSize,
|
|
IN CHAR16 *ExitData OPTIONAL
|
|
)
|
|
{
|
|
DEBUG ((DEBUG_ERROR, "UserSpace: Exit is not supported\n"));
|
|
|
|
return EFI_UNSUPPORTED;
|
|
}
|
|
|
|
EFI_STATUS
|
|
EFIAPI
|
|
UserSpaceUnloadImage (
|
|
IN EFI_HANDLE ImageHandle
|
|
)
|
|
{
|
|
DEBUG ((DEBUG_ERROR, "UserSpace: UnloadImage is not supported\n"));
|
|
|
|
return EFI_UNSUPPORTED;
|
|
}
|
|
|
|
EFI_STATUS
|
|
EFIAPI
|
|
UserSpaceExitBootServices (
|
|
IN EFI_HANDLE ImageHandle,
|
|
IN UINTN MapKey
|
|
)
|
|
{
|
|
DEBUG ((DEBUG_ERROR, "UserSpace: ExitBootServices is not supported\n"));
|
|
|
|
return EFI_UNSUPPORTED;
|
|
}
|
|
|
|
EFI_STATUS
|
|
EFIAPI
|
|
UserSpaceGetNextMonotonicCount (
|
|
OUT UINT64 *Count
|
|
)
|
|
{
|
|
DEBUG ((DEBUG_ERROR, "UserSpace: GetNextMonotonicCount is not supported\n"));
|
|
|
|
return EFI_UNSUPPORTED;
|
|
}
|
|
|
|
EFI_STATUS
|
|
EFIAPI
|
|
UserSpaceStall (
|
|
IN UINTN Microseconds
|
|
)
|
|
{
|
|
DEBUG ((DEBUG_ERROR, "UserSpace: Stall is not supported\n"));
|
|
|
|
return EFI_UNSUPPORTED;
|
|
}
|
|
|
|
EFI_STATUS
|
|
EFIAPI
|
|
UserSpaceSetWatchdogTimer (
|
|
IN UINTN Timeout,
|
|
IN UINT64 WatchdogCode,
|
|
IN UINTN DataSize,
|
|
IN CHAR16 *WatchdogData OPTIONAL
|
|
)
|
|
{
|
|
DEBUG ((DEBUG_ERROR, "UserSpace: SetWatchdogTimer is not supported\n"));
|
|
|
|
return EFI_UNSUPPORTED;
|
|
}
|
|
|
|
EFI_STATUS
|
|
EFIAPI
|
|
UserSpaceConnectController (
|
|
IN EFI_HANDLE ControllerHandle,
|
|
IN EFI_HANDLE *DriverImageHandle OPTIONAL,
|
|
IN EFI_DEVICE_PATH_PROTOCOL *RemainingDevicePath OPTIONAL,
|
|
IN BOOLEAN Recursive
|
|
)
|
|
{
|
|
DEBUG ((DEBUG_ERROR, "UserSpace: ConnectController is not supported\n"));
|
|
|
|
return EFI_UNSUPPORTED;
|
|
}
|
|
|
|
EFI_STATUS
|
|
EFIAPI
|
|
UserSpaceDisconnectController (
|
|
IN EFI_HANDLE ControllerHandle,
|
|
IN EFI_HANDLE DriverImageHandle OPTIONAL,
|
|
IN EFI_HANDLE ChildHandle OPTIONAL
|
|
)
|
|
{
|
|
DEBUG ((DEBUG_ERROR, "UserSpace: DisconnectController is not supported\n"));
|
|
|
|
return EFI_UNSUPPORTED;
|
|
}
|
|
|
|
EFI_STATUS
|
|
EFIAPI
|
|
UserSpaceOpenProtocol (
|
|
IN EFI_HANDLE CoreUserHandle,
|
|
IN EFI_GUID *Protocol,
|
|
OUT VOID **Interface OPTIONAL,
|
|
IN EFI_HANDLE CoreImageHandle,
|
|
IN EFI_HANDLE CoreControllerHandle,
|
|
IN UINT32 Attributes
|
|
)
|
|
{
|
|
EFI_STATUS Status;
|
|
|
|
Status = SysCall (
|
|
SysCallOpenProtocol,
|
|
6,
|
|
CoreUserHandle,
|
|
Protocol,
|
|
Interface,
|
|
CoreImageHandle,
|
|
CoreControllerHandle,
|
|
Attributes
|
|
);
|
|
if (EFI_ERROR (Status)) {
|
|
return Status;
|
|
}
|
|
|
|
return (Interface != NULL) ? FixInterface (Protocol, Interface) : Status;
|
|
}
|
|
|
|
EFI_STATUS
|
|
EFIAPI
|
|
UserSpaceCloseProtocol (
|
|
IN EFI_HANDLE UserHandle,
|
|
IN EFI_GUID *Protocol,
|
|
IN EFI_HANDLE AgentHandle,
|
|
IN EFI_HANDLE ControllerHandle
|
|
)
|
|
{
|
|
return SysCall (
|
|
SysCallCloseProtocol,
|
|
4,
|
|
UserHandle,
|
|
Protocol,
|
|
AgentHandle,
|
|
ControllerHandle
|
|
);
|
|
}
|
|
|
|
EFI_STATUS
|
|
EFIAPI
|
|
UserSpaceOpenProtocolInformation (
|
|
IN EFI_HANDLE UserHandle,
|
|
IN EFI_GUID *Protocol,
|
|
OUT EFI_OPEN_PROTOCOL_INFORMATION_ENTRY **EntryBuffer,
|
|
OUT UINTN *EntryCount
|
|
)
|
|
{
|
|
DEBUG ((DEBUG_ERROR, "UserSpace: OpenProtocolInformation is not supported\n"));
|
|
|
|
return EFI_UNSUPPORTED;
|
|
}
|
|
|
|
EFI_STATUS
|
|
EFIAPI
|
|
UserSpaceProtocolsPerHandle (
|
|
IN EFI_HANDLE UserHandle,
|
|
OUT EFI_GUID ***ProtocolBuffer,
|
|
OUT UINTN *ProtocolBufferCount
|
|
)
|
|
{
|
|
DEBUG ((DEBUG_ERROR, "UserSpace: ProtocolsPerHandle is not supported\n"));
|
|
|
|
return EFI_UNSUPPORTED;
|
|
}
|
|
|
|
EFI_STATUS
|
|
EFIAPI
|
|
UserSpaceLocateHandleBuffer (
|
|
IN EFI_LOCATE_SEARCH_TYPE SearchType,
|
|
IN EFI_GUID *Protocol OPTIONAL,
|
|
IN VOID *SearchKey OPTIONAL,
|
|
IN OUT UINTN *NumberHandles,
|
|
OUT EFI_HANDLE **Buffer
|
|
)
|
|
{
|
|
EFI_STATUS Status;
|
|
EFI_STATUS StatusBS;
|
|
VOID *Pool;
|
|
UINTN PoolSize;
|
|
|
|
StatusBS = SysCall (
|
|
SysCallLocateHandleBuffer,
|
|
5,
|
|
SearchType,
|
|
Protocol,
|
|
SearchKey,
|
|
NumberHandles,
|
|
Buffer
|
|
);
|
|
|
|
if ((!EFI_ERROR (StatusBS)) && (NumberHandles != NULL) && (*NumberHandles != 0)
|
|
&& (Buffer != NULL) && (*Buffer != NULL)) {
|
|
PoolSize = *NumberHandles * sizeof (EFI_HANDLE *);
|
|
|
|
Status = UserSpaceAllocatePool (EfiUserSpaceMemoryType, PoolSize, &Pool);
|
|
if (EFI_ERROR (Status)) {
|
|
return Status;
|
|
}
|
|
|
|
CopyMem (Pool, *Buffer, PoolSize);
|
|
|
|
Status = UserSpaceFreePages (
|
|
(EFI_PHYSICAL_ADDRESS)(UINTN)*Buffer,
|
|
EFI_SIZE_TO_PAGES (PoolSize)
|
|
);
|
|
if (EFI_ERROR (Status)) {
|
|
return Status;
|
|
}
|
|
|
|
*Buffer = Pool;
|
|
}
|
|
|
|
return StatusBS;
|
|
}
|
|
|
|
EFI_STATUS
|
|
EFIAPI
|
|
UserSpaceLocateProtocol (
|
|
IN EFI_GUID *Protocol,
|
|
IN VOID *CoreRegistration OPTIONAL,
|
|
OUT VOID **Interface
|
|
)
|
|
{
|
|
EFI_STATUS Status;
|
|
|
|
Status = SysCall (
|
|
SysCallLocateProtocol,
|
|
3,
|
|
Protocol,
|
|
CoreRegistration,
|
|
Interface
|
|
);
|
|
if (EFI_ERROR (Status)) {
|
|
DEBUG ((DEBUG_ERROR, "UserSpace: Failed to loacate protocol %g\n", Protocol));
|
|
return Status;
|
|
}
|
|
|
|
return FixInterface (Protocol, Interface);
|
|
}
|
|
|
|
EFI_STATUS
|
|
EFIAPI
|
|
UserSpaceInstallMultipleProtocolInterfaces (
|
|
IN OUT EFI_HANDLE *Handle,
|
|
...
|
|
)
|
|
{
|
|
EFI_STATUS Status;
|
|
VA_LIST Marker;
|
|
VOID **Arguments;
|
|
UINTN NumberOfArguments;
|
|
UINTN Index;
|
|
|
|
VA_START (Marker, Handle);
|
|
NumberOfArguments = 1;
|
|
while (VA_ARG (Marker, VOID *) != NULL) {
|
|
++NumberOfArguments;
|
|
}
|
|
VA_END (Marker);
|
|
|
|
Status = UserSpaceAllocatePool (
|
|
EfiUserSpaceMemoryType,
|
|
NumberOfArguments * sizeof (VOID *),
|
|
(VOID **)&Arguments
|
|
);
|
|
if (EFI_ERROR (Status)) {
|
|
return Status;
|
|
}
|
|
|
|
VA_START (Marker, Handle);
|
|
for (Index = 0; Index < NumberOfArguments; ++Index) {
|
|
Arguments[Index] = VA_ARG (Marker, VOID *);
|
|
}
|
|
VA_END (Marker);
|
|
|
|
Status = SysCall (
|
|
SysCallInstallMultipleProtocolInterfaces,
|
|
3,
|
|
Handle,
|
|
NumberOfArguments,
|
|
Arguments
|
|
);
|
|
|
|
UserSpaceFreePool (Arguments);
|
|
return Status;
|
|
}
|
|
|
|
EFI_STATUS
|
|
EFIAPI
|
|
UserSpaceUninstallMultipleProtocolInterfaces (
|
|
IN EFI_HANDLE Handle,
|
|
...
|
|
)
|
|
{
|
|
DEBUG ((DEBUG_ERROR, "UserSpace: UninstallMultipleProtocolInterfaces is not supported\n"));
|
|
|
|
return EFI_UNSUPPORTED;
|
|
}
|
|
|
|
EFI_STATUS
|
|
EFIAPI
|
|
UserSpaceCalculateCrc32 (
|
|
IN VOID *Data,
|
|
IN UINTN DataSize,
|
|
OUT UINT32 *Crc32
|
|
)
|
|
{
|
|
return SysCall (
|
|
SysCallCalculateCrc32,
|
|
3,
|
|
Data,
|
|
DataSize,
|
|
Crc32
|
|
);
|
|
}
|
|
|
|
EFI_STATUS
|
|
EFIAPI
|
|
UserSpaceCreateEventEx (
|
|
IN UINT32 Type,
|
|
IN EFI_TPL NotifyTpl,
|
|
IN EFI_EVENT_NOTIFY NotifyFunction OPTIONAL,
|
|
IN CONST VOID *NotifyContext OPTIONAL,
|
|
IN CONST EFI_GUID *EventGroup OPTIONAL,
|
|
OUT EFI_EVENT *Event
|
|
)
|
|
{
|
|
DEBUG ((DEBUG_ERROR, "UserSpace: CreateEventEx is not supported\n"));
|
|
|
|
return EFI_UNSUPPORTED;
|
|
}
|
|
|
|
EFI_STATUS
|
|
EFIAPI
|
|
CoreUpdateProfile (
|
|
IN EFI_PHYSICAL_ADDRESS CallerAddress,
|
|
IN MEMORY_PROFILE_ACTION Action,
|
|
IN EFI_MEMORY_TYPE MemoryType,
|
|
IN UINTN Size, // Valid for AllocatePages/FreePages/AllocatePool
|
|
IN VOID *Buffer,
|
|
IN CHAR8 *ActionString OPTIONAL
|
|
)
|
|
{
|
|
return EFI_SUCCESS;
|
|
}
|
|
|
|
VOID
|
|
InstallMemoryAttributesTableOnMemoryAllocation (
|
|
IN EFI_MEMORY_TYPE MemoryType
|
|
)
|
|
{
|
|
return;
|
|
}
|
|
|
|
BOOLEAN
|
|
EFIAPI
|
|
IsMemoryGuarded (
|
|
IN EFI_PHYSICAL_ADDRESS Address
|
|
)
|
|
{
|
|
return FALSE;
|
|
}
|
|
|
|
VOID *
|
|
CoreAllocatePoolPagesI (
|
|
IN EFI_MEMORY_TYPE PoolType,
|
|
IN UINTN NoPages,
|
|
IN UINTN Granularity,
|
|
IN BOOLEAN NeedGuard
|
|
)
|
|
{
|
|
EFI_PHYSICAL_ADDRESS Memory;
|
|
|
|
UserSpaceAllocatePages (AllocateAnyPages, EfiUserSpaceMemoryType, NoPages, &Memory);
|
|
|
|
return (VOID *)(UINTN)Memory;
|
|
}
|
|
|
|
VOID
|
|
CoreFreePoolPagesI (
|
|
IN EFI_MEMORY_TYPE PoolType,
|
|
IN EFI_PHYSICAL_ADDRESS Memory,
|
|
IN UINTN NoPages
|
|
)
|
|
{
|
|
UserSpaceFreePages (Memory, NoPages);
|
|
}
|
|
|
|
VOID
|
|
CoreFreePoolPagesWithGuard (
|
|
IN EFI_MEMORY_TYPE PoolType,
|
|
IN EFI_PHYSICAL_ADDRESS Memory,
|
|
IN UINTN NoPages
|
|
)
|
|
{
|
|
CoreFreePoolPagesI (EfiUserSpaceMemoryType, Memory, NoPages);
|
|
}
|