EFI_STATUS EFIAPI efi_main(EFI_HANDLE image_handle, EFI_SYSTEM_TABLE *systab) {
InitializeLib(image_handle, systab);
EFI_STATUS Status;
systab->ConOut->ClearScreen(systab->ConOut); // CLEAR!
EFI_GUID simplefs_guid = SIMPLE_FILE_SYSTEM_PROTOCOL; // a simple file system protocol in efi
// (different from UEFI specification. In specification, this is called EFI_SIMPLE_FILE_SYSTEM_PROTOCOL_GUID )
EFI_FILE_IO_INTERFACE *simplefs; // the simple file system's interface
// (different from UEFI specification. In specification, this is called EFI_SIMPLE_FILE_SYSTEM_PROTOCOL)
EFI_FILE *root; // root directory
EFI_FILE *dir;
CHAR16 *dirname=L"\\stories"; // name of the directory where bmp pictures are put
status=systab->BootServices->LocateProtocol(&simplefs_guid, NULL, (VOID **)&simplefs);
if(EFI_ERROR(status)) Print(L"locate protocol failed \n");
status=simplefs->OpenVolume(simplefs, &root);
if(EFI_ERROR(status)) Print(L"open volume failed\n");
status=root->Open(root, &dir, dirname, EFI_FILE_MODE_READ, EFI_FILE_READ_ONLY);
if(EFI_ERROR(status)) Print(L"open directory failed\n");
VOID *buf;
INT32 index=1;
status = readFile(dir, index, systab, buf); // Put the contents of 1.story into buf
Print(L"%s", buf);
WaitForSingleEvent(ST->ConIn->WaitForKey, 0);
uefi_call_wrapper(ST->ConIn->ReadKeyStroke, 2, ST->ConIn, &Key);
return Status;
}
static void init(EFI_HANDLE image_handle, EFI_SYSTEM_TABLE* system_table)
{
InitializeLib(image_handle, system_table);
IH = image_handle;
EFI_STATUS status = EFI_SUCCESS;
if ((NULL == ST->ConIn) || (EFI_SUCCESS != (status = ST->ConIn->Reset(ST->ConIn, 0)))){
error_print(L"Input device unavailable.\n", ST->ConIn ? &status : NULL);
}
status = BS->OpenProtocol(
image_handle, &LoadedImageProtocol, &loaded_image,
image_handle, NULL, EFI_OPEN_PROTOCOL_GET_PROTOCOL
);
if (EFI_ERROR(status)){
error_print(L"OpenProtocol() LoadedImageProtocol failed.\n", &status);
}
set_uefi_handle_if(image_handle, loaded_image);
}
/**
* Image entry point. Installs the Driver Binding and Component Name protocols
* on the image's handle. Actually mounting a file system is initiated through
* the Driver Binding protocol at the firmware's request.
*/
EFI_STATUS EFIAPI fsw_efi_main(IN EFI_HANDLE ImageHandle,
IN EFI_SYSTEM_TABLE *SystemTable)
{
EFI_STATUS Status;
#ifndef VBOX
InitializeLib(ImageHandle, SystemTable);
#endif
// complete Driver Binding protocol instance
fsw_efi_DriverBinding_table.ImageHandle = ImageHandle;
fsw_efi_DriverBinding_table.DriverBindingHandle = ImageHandle;
// install Driver Binding protocol
Status = BS->InstallProtocolInterface(&fsw_efi_DriverBinding_table.DriverBindingHandle,
&PROTO_NAME(DriverBindingProtocol),
EFI_NATIVE_INTERFACE,
&fsw_efi_DriverBinding_table);
if (EFI_ERROR (Status)) {
return Status;
}
// install Component Name protocol
Status = BS->InstallProtocolInterface(&fsw_efi_DriverBinding_table.DriverBindingHandle,
&PROTO_NAME(ComponentNameProtocol),
EFI_NATIVE_INTERFACE,
&fsw_efi_ComponentName_table);
if (EFI_ERROR (Status)) {
return Status;
}
return EFI_SUCCESS;
}
; ןונגוירא� ןנמדנאללא הכ� UEFI
EFI_STATUS efi_main (EFI_HANDLE image, EFI_SYSTEM_TABLE *systab)
{
InitializeLib(image, systab);
UINTN mms=65536;
int i;
int s;
EFI_MEMORY_DESCRIPTOR *mm;
uefi_call_wrapper(systab->BootServices->AllocatePool,
3,
EfiLoaderData,
sizeof(EFI_MEMORY_DESCRIPTOR)*65536,
((void*)&mm));
UINTN mk,ds,dv;
uefi_call_wrapper(systab->BootServices->GetMemoryMap,
5,
&mms,
mm,
&mk,
&ds,
&dv);
s=0;
for (i=0;i<mms;i++)
if((mm[i].Type == EfiBootServicesCode)
||(mm[i].Type == EfiBootServicesData)
||(mm[i].Type == EfiConventionalMemory)
||(mm[i].Type == EfiACPIReclaimMemory)
)s+=mm[i].NumberOfPages;
Print(L"%d\r\n",s);
return EFI_SUCCESS;
}
/**
* UGA Draw Protocol Test Driver Entry point.
* @param ImageHandle the driver image handle.
* @param SystemTable the system table.
* @return EFI_SUCCESS the driver is loaded successfully.
*/
EFI_STATUS
InitializeBBTestUgaDraw (
IN EFI_HANDLE ImageHandle,
IN EFI_SYSTEM_TABLE *SystemTable
)
{
EfiInitializeTestLib (ImageHandle, SystemTable);
InitializeLib (ImageHandle, SystemTable);
EfiInitializeDriverLib (ImageHandle, SystemTable);
//
// Initialize Demo Data
//
DemoResolutionMax = sizeof (DemoResolution) / sizeof (DEMO_RESOLUTION_TYPE);
DemoRefreshRateMax = sizeof (DemoRefreshRate) / sizeof (DEMO_REFRESH_RATE_TYPE);
DemoColorDepthMax = sizeof (DemoColorDepth) / sizeof (DEMO_COLOR_DEPTH_TYPE);
gtBS->CreateEvent (EFI_EVENT_TIMER, 0, NULL, NULL, &TimerEvent);
return EfiInitAndInstallBBTestInterface (
&ImageHandle,
&gBBTestProtocolField,
gBBTestEntryField,
BBTestUgaDrawProtocolUnload,
&gBBTestProtocolInterface
);
}
EFI_STATUS
InitializeGraphicsOutputBBTest (
IN EFI_HANDLE ImageHandle,
IN EFI_SYSTEM_TABLE *SystemTable
)
/*++
Routine Description:
GraphicsOutput Protocol Test Driver Entry point.
Arguments:
ImageHandle - The driver image handle
SystemTable - The system table
Returns:
EFI_SUCCESS - The driver is loaded successfully.
--*/
{
EfiInitializeTestLib (ImageHandle, SystemTable);
InitializeLib (ImageHandle, SystemTable);
EfiInitializeDriverLib (ImageHandle, SystemTable);
return EfiInitAndInstallIHVBBTestInterface (
&ImageHandle,
&gBBTestProtocolField,
gBBTestEntryField,
UnloadEfiGraphicsOutputBBTest,
&gBBTestProtocolInterface
);
}
EFI_STATUS
efi_main(EFI_HANDLE image, EFI_SYSTEM_TABLE *systab)
{
EFI_STATUS rc;
InitializeLib(image, systab);
rc = uefi_call_wrapper(BS->HandleProtocol, 3, image, &LoadedImageProtocol, (void *)&this_image);
if (EFI_ERROR(rc)) {
Print(L"Error: could not find loaded image: %d\n", rc);
return rc;
}
Print(L"System BootOrder not found. Initializing defaults.\n");
set_boot_order();
rc = find_boot_options(this_image->DeviceHandle);
if (EFI_ERROR(rc)) {
Print(L"Error: could not find boot options: %d\n", rc);
return rc;
}
try_start_first_option(image);
Print(L"Reset System\n");
uefi_call_wrapper(RT->ResetSystem, 4, EfiResetCold,
EFI_SUCCESS, 0, NULL);
return EFI_SUCCESS;
}
EFI_STATUS
InitializeBBTestDeviceIo (
IN EFI_HANDLE ImageHandle,
IN EFI_SYSTEM_TABLE *SystemTable
)
/*++
Routine Description:
Creates/installs the BlackBox Interface and eminating Entry Point node list.
Arguments:
ImageHandle: NULL
*SystemTable: Pointer to System Table
Returns:
EFI_SUCCESS: Indicates the interface was installed.
EFI_OUT_OF_RESOURCES: Indicates space for the new handle could not be allocated
EFI_INVALID_PARAMETER: One of the parameters has an invalid value.
--*/
{
EfiInitializeTestLib (ImageHandle, SystemTable);
InitializeLib (ImageHandle, SystemTable);
GetSystemDevicePathAndFilePath (ImageHandle);
return EfiInitAndInstallIHVBBTestInterface (
&ImageHandle,
&gBBTestProtocolField,
gBBTestEntryField,
BBTestDeviceIoUnload,
&gBBTestProtocolInterface
);
}
EFI_STATUS
efi_main(EFI_HANDLE image_handle, EFI_SYSTEM_TABLE *systab)
{
EFI_STATUS status;
UINT64 MaximumVariableStorageSize,
RemainingVariableStorageSize,
MaximumVariableSize;
InitializeLib(image_handle, systab);
status = systab->RuntimeServices->QueryVariableInfo(
EFI_VARIABLE_NON_VOLATILE |
EFI_VARIABLE_BOOTSERVICE_ACCESS |
EFI_VARIABLE_RUNTIME_ACCESS,
&MaximumVariableStorageSize,
&RemainingVariableStorageSize,
&MaximumVariableSize);
Print(L"Maximum Variable Storage Size: %lld\r\n",
MaximumVariableStorageSize);
Print(L"Remaining Variable Storage Size: %lld\r\n",
RemainingVariableStorageSize);
Print(L"Maximum Variable Size: %lld\r\n",
MaximumVariableSize);
return status;
}
EFI_STATUS
efi_main (EFI_HANDLE image, EFI_SYSTEM_TABLE *systab)
{
InitializeLib(image, systab);
DebugHook();
return EFI_SUCCESS;
}
EFI_STATUS
efi_main (EFI_HANDLE image, EFI_SYSTEM_TABLE *systab)
{
EFI_STATUS status;
CHAR16 name[256], *val, fmt[20];
EFI_GUID vendor;
UINTN size;
InitializeLib(image, systab);
name[0] = 0;
vendor = NullGuid;
Print(L"GUID Variable Name Value\n");
Print(L"=================================== ==================== ========\n");
StrCpy(fmt, L"%.-35g %.-20s %s\n");
while (1) {
size = sizeof(name);
status = uefi_call_wrapper(RT->GetNextVariableName, 3, &size, name, &vendor);
if (status != EFI_SUCCESS)
break;
val = LibGetVariable(name, &vendor);
Print(fmt, &vendor, name, val);
FreePool(val);
}
return EFI_SUCCESS;
}
/**
* Creates/installs the BlackBox Interface and eminating Entry Point
* node list.
* @param ImageHandle The test driver image handle
* @param SystemTable Pointer to System Table
* @return EFI_SUCCESS Indicates the interface was installed
* @return EFI_OUT_OF_RESOURCES Indicates space for the new handle could not be allocated
* @return EFI_INVALID_PARAMETER: One of the parameters has an invalid value.
*/
EFI_STATUS
InitializeBBTestProtocolHandlerBootServices (
IN EFI_HANDLE ImageHandle,
IN EFI_SYSTEM_TABLE *SystemTable
)
{
EFI_STATUS Status;
EfiInitializeTestLib (ImageHandle, SystemTable);
//
// initialize test utility lib
//
InitializeLib (ImageHandle, SystemTable);
mImageHandle = ImageHandle;
Status = InitializeGlobalData ();
if (EFI_ERROR (Status)) {
return Status;
}
return EfiInitAndInstallBBTestInterface (
&ImageHandle,
&gBBTestProtocolField,
gBBTestEntryField,
BBTestProtocolHandlerBootServicesUnload,
&gBBTestProtocolInterface
);
}
EFI_STATUS
efi_main (EFI_HANDLE image, EFI_SYSTEM_TABLE *systab)
{
EFI_STATUS rc = EFI_SUCCESS;
UINT32 Attr;
UINT64 MaxStoreSize = 0;
UINT64 RemainStoreSize = 0;
UINT64 MaxSize = 0;
InitializeLib(image, systab);
Attr = EFI_VARIABLE_NON_VOLATILE | EFI_VARIABLE_HARDWARE_ERROR_RECORD;
rc = uefi_call_wrapper(RT->QueryVariableInfo, 4,
Attr, &MaxStoreSize, &RemainStoreSize, &MaxSize);
if (rc != EFI_SUCCESS) {
Print(L"ERROR: Failed to get store sizes: %d\n", rc);
} else {
Print(L"Max Storage Size: %ld\n", MaxStoreSize);
Print(L"Remaining Storage Size: %ld\n", RemainStoreSize);
Print(L"Max Variable Size: %ld\n", MaxSize);
}
return rc;
}
EFI_STATUS
efi_main (EFI_HANDLE image, EFI_SYSTEM_TABLE *systab)
{
EFI_LOADED_IMAGE *loaded_image = NULL;
#if 0
EFI_DEVICE_PATH *dev_path;
#endif
EFI_STATUS status;
InitializeLib(image, systab);
status = uefi_call_wrapper(systab->BootServices->HandleProtocol,
3,
image,
&LoadedImageProtocol,
(void **) &loaded_image);
if (EFI_ERROR(status)) {
Print(L"handleprotocol: %r\n", status);
}
#if 0
BS->HandleProtocol(loaded_image->DeviceHandle, &DevicePathProtocol, (void **) &dev_path);
Print(L"Image device : %s\n", DevicePathToStr(dev_path));
Print(L"Image file : %s\n", DevicePathToStr(loaded_image->FilePath));
#endif
Print(L"Image base : %lx\n", loaded_image->ImageBase);
Print(L"Image size : %lx\n", loaded_image->ImageSize);
Print(L"Load options size : %lx\n", loaded_image->LoadOptionsSize);
Print(L"Load options : %s\n", loaded_image->LoadOptions);
return EFI_SUCCESS;
}
/**
* Creates/installs the BlackBox Interface and eminating Entry Point node list.
* @param ImageHandle The test driver image handle
* @param SystemTable Pointer to System Table
* @return EFI_SUCCESS Indicates the interface was installed
* @return EFI_OUT_OF_RESOURCES Indicates space for the new handle could not be allocated
* @return EFI_INVALID_PARAMETER: One of the parameters has an invalid value.
*/
EFI_STATUS
InitializeBBTestPxeBCProtocol (
IN EFI_HANDLE ImageHandle,
IN EFI_SYSTEM_TABLE *SystemTable
)
{
EFI_STATUS Status;
EfiInitializeTestLib (ImageHandle, SystemTable);
InitializeLib (ImageHandle, SystemTable);
EfiInitializeDriverLib (ImageHandle, SystemTable);
Status = gtBS->CreateEvent (EFI_EVENT_TIMER, 0, NULL, NULL, &TimerEvent);
if (EFI_ERROR(Status)) {
return Status;
}
Status = GetSystemDevicePathAndFilePath (ImageHandle);
if (EFI_ERROR(Status)) {
return Status;
}
return EfiInitAndInstallBBTestInterface (
&ImageHandle,
&gEfiPxeBcTestProtField,
gPxeTestEntryField,
BBTestPxeBcUnload,
&gBBTestProtocolInterface
);
}
EFI_STATUS
efi_main (EFI_HANDLE image, EFI_SYSTEM_TABLE *systab)
{
EFI_STATUS status;
int argc, i;
CHAR16 **ARGV;
CHAR16 descr[64];
InitializeLib(image, systab);
status = argsplit(image, &argc, &ARGV);
if (status != EFI_SUCCESS) {
StatusToString (descr, status);
Print (L"error %s\n", descr);
}
Print (L"argc %d\n", argc);
for (i = 0; i < argc; i++)
Print (L"argv[%d]: %s\n", i, ARGV[i]);
Print (L"\nPress any key to continue\n");
efi_pause();
return EFI_SUCCESS;
}
/*********************************************************************************
* Creates/installs the BlackBox Interface and eminating Entry Point node list.
* @param ImageHandle The test driver image handle
* @param SystemTable Pointer to System Table
* @return EFI_SUCCESS Indicates the interface was installed
* @return EFI_OUT_OF_RESOURCES Indicates space for the new handle could not be allocated
* @return EFI_INVALID_PARAMETER: One of the parameters has an invalid value.
********************************************************************************/
EFI_STATUS
InitializeTapeTest (
IN EFI_HANDLE ImageHandle,
IN EFI_SYSTEM_TABLE *SystemTable
)
{
EFI_STATUS Status;
EfiInitializeTestLib (ImageHandle, SystemTable);
InitializeLib (ImageHandle, SystemTable);
EfiInitializeDriverLib (ImageHandle, SystemTable);
//
// Make sure the Protocol is not already installed in the system
//
//ASSERT_PROTOCOL_ALREADY_INSTALLED (NULL, &gEfiTapeIoProtocolGuid);
Status = gtBS->CreateEvent (EFI_EVENT_TIMER, 0, NULL, NULL, &TimerEvent);
if (EFI_ERROR(Status)) {
return Status;
}
Status = EfiInitAndInstallBBTestInterface (
&ImageHandle,
&gEfiTapeTestProtField,
gTapeTestEntryField,
UnloadTapeTest,
&gTapeTestProtocol
);
return Status;
}
EFI_STATUS
EFIAPI
efi_main (EFI_HANDLE ImageHandle, EFI_SYSTEM_TABLE *SystemTable)
{
InitializeLib(ImageHandle, SystemTable);
Print(L"Hello, world!\n");
return EFI_SUCCESS;
}
EFI_STATUS
efi_main(EFI_HANDLE image, EFI_SYSTEM_TABLE *systab)
{
InitializeLib(image, systab);
print_memory_map();
return EFI_SUCCESS;
}
EFI_STATUS
efi_main (EFI_HANDLE image, EFI_SYSTEM_TABLE *systab)
{
InitializeLib(image, systab);
Print(L"HelloLib application started\n");
Print(L"\n\n\nHit any key to exit this image\n");
WaitForSingleEvent(ST->ConIn->WaitForKey, 0);
uefi_call_wrapper(ST->ConOut->OutputString, 2, ST->ConOut, L"\n\n");
return EFI_SUCCESS;
}
EFI_expressionUS
efi_main(EFI_HANDLE image_handle, EFI_SYSTEM_TABLE *systab )
{
InitializeLib(image_handle, systab);
EFI_expressionUS err;
UINTN memorymapsize, mapkey, descriptorsize;;
UINT32 descriptorversion;
EFI_MEMORY_DESCRIPTOR *memorymap;
int i,z;
long long int memtouse=0;
err=uefi_call_wrapper(systab->BootServices->GetMemoryMap,5,&memorymapsize, memorymap, &mapkey, &descriptorsize, &descriptorversion);
if(err!=EFI_BUFFER_TOO_SMALL)
{
Print(L"Error in getting memory map\n");
return EFI_SUCCESS;
}
err=uefi_call_wrapper(systab->BootServices->AllocatePool,3, EfiLoaderData,memorymapsize, ((void*)&memorymap));
if(err!=EFI_SUCCESS)
{
Print(L"Error in allocating memory\n");
return EFI_SUCCESS;
}
err=uefi_call_wrapper(systab->BootServices->GetMemoryMap, 5, &memorymapsize, memorymap, &mapkey, &descriptorsize, &descriptorversion);
if(err!=EFI_SUCCESS)
{
Print(L"Error in getting memory map\n");
return EFI_SUCCESS;
}
z=memorymapsize/(sizeof(EFI_MEMORY_DESCRIPTOR));
for(i=0;i<z;i++){
if((memorymap[i].Type==EfiBootServicesCode)|| (memorymap[i].Type==EfiBootServicesData) ||(memorymap[i].Type==EfiConventionalMemory))
{memtouse+=memorymap[i].NumberOfPages;}
}
memtouse=memtouse*4096;
err=uefi_call_wrapper(systab->BootServices->FreePool, 1, ((void*)memorymap));
if(err!=EFI_SUCCESS)
{
Print(L"Error in free pool fuction\n");
return err;
}
Print(L"%d bytes of memory is avaliable for general use\n",memtouse);
return EFI_SUCCESS;
}
EFI_STATUS
EFIAPI
efi_main (EFI_HANDLE ImageHandle, EFI_SYSTEM_TABLE *SystemTable)
{
EFI_INPUT_KEY efi_input_key;
int a = 10, b = 20;
InitializeLib(ImageHandle, SystemTable);
//Print(L"Hello, world!\n");
terra_main(L"Hello, Terra from C!\n");
Print(L"%d + %d = %d\n", a, b, terra_add(a,b));
Print(L"%s\n", SystemTable->FirmwareVendor);
EFI_STATUS status;
EFI_GRAPHICS_OUTPUT_PROTOCOL *gop;
status = LibLocateProtocol(&GraphicsOutputProtocol, (void **)&gop);
if(EFI_ERROR(status))
return status;
status = uefi_call_wrapper(SystemTable->BootServices->LocateProtocol, 3, &GraphicsOutputProtocol, NULL, &gop);
Print(L"Framebuffer base is at %lx\n", gop->Mode->FrameBufferBase);
print_modes(gop);
Print(L"\n\n\nHit any key\n");
WaitForSingleEvent(SystemTable->ConIn->WaitForKey, 0);
status = uefi_call_wrapper(SystemTable->ConIn->ReadKeyStroke, 2, SystemTable->ConIn, &efi_input_key);
paint_screen(gop, (UINT32)0x00FF0000);
uefi_call_wrapper(BS->Stall, 1, 2 * 1000 * 1000);
paint_screen(gop, (UINT32)0x0000FF00);
uefi_call_wrapper(BS->Stall, 1, 2 * 1000 * 1000);
paint_screen(gop, (UINT32)0x000000FF0);
// FROM: https://github.com/vathpela/gnu-efi/blob/master/apps/t7.c
Print(L"\n\n\nHit any key to exit this image\n");
WaitForSingleEvent(SystemTable->ConIn->WaitForKey, 0);
uefi_call_wrapper(SystemTable->ConOut->OutputString, 2, SystemTable->ConOut, L"\n\n");
status = uefi_call_wrapper(SystemTable->ConIn->ReadKeyStroke, 2, SystemTable->ConIn, &efi_input_key);
Print(L"ScanCode: %xh UnicodeChar: %xh\n", efi_input_key.ScanCode, efi_input_key.UnicodeChar);
return EFI_SUCCESS;
}
EFI_STATUS
efi_main (EFI_HANDLE *image, EFI_SYSTEM_TABLE *systab)
{
UINTN index;
InitializeLib(image, systab);
uefi_call_wrapper(systab->ConOut->OutputString, 2, systab->ConOut, L"Hello application started\r\n");
uefi_call_wrapper(systab->ConOut->OutputString, 2, systab->ConOut, L"\r\n\r\n\r\nHit any key to exit\r\n");
uefi_call_wrapper(systab->BootServices->WaitForEvent, 3, 1, &systab->ConIn->WaitForKey, &index);
return EFI_SUCCESS;
}
EFI_STATUS efi_main(EFI_HANDLE ImageHandle, EFI_SYSTEM_TABLE *SystemTable)
{
EFI_MEMORY_DESCRIPTOR *descriptors;
EFI_STATUS status;
UINTN neededMemory = 0, actualSize, descriptors_size;
UINT64 totalMemory = 0;
InitializeLib(ImageHandle, SystemTable);
status = uefi_call_wrapper(SystemTable->BootServices->GetMemoryMap,
5,
&neededMemory, NULL, NULL, NULL, NULL);
if ( status != EFI_BUFFER_TOO_SMALL )
{
Print(L"Something going wrong\n");
return EFI_SUCCESS;
}
status = uefi_call_wrapper(SystemTable->BootServices->AllocatePool,
3,
EfiLoaderData, neededMemory, &descriptors);
if (status != EFI_SUCCESS)
{
Print (L"AllocatePool failed\n");
return EFI_SUCCESS;
}
status = uefi_call_wrapper(
SystemTable->BootServices->GetMemoryMap,
5,
&descriptors_size, descriptors, NULL, &actualSize, NULL);
if ( status == EFI_SUCCESS )
{
UINTN count = descriptors_size / actualSize;
UINTN i;
for ( i = 0; i < count; ++i )
{
if ( descriptors[i].Type == EfiLoaderData ||
descriptors[i].Type == EfiBootServicesData ||
descriptors[i].Type == EfiRuntimeServicesData ||
descriptors[i].Type == EfiConventionalMemory)
{
totalMemory += descriptors[i].NumberOfPages * 4096;
}
}
Print(L"%d\n", totalMemory);
}
uefi_call_wrapper(SystemTable->BootServices->FreePool, 1, descriptors);
return EFI_SUCCESS;
}
EFI_STATUS
efi_main (EFI_HANDLE image_handle, EFI_SYSTEM_TABLE *systab)
{
INT32 i;
InitializeLib(image_handle, systab);
for (i = 0; i < ST->ConOut->Mode->MaxMode; i++) {
set_console_mode (i);
Print (L"\nPress any key to continue...\n");
efi_pause ();
}
return EFI_SUCCESS;
}
EFI_STATUS efi_main(EFI_HANDLE image, EFI_SYSTEM_TABLE *systab) {
// Initialize the library
InitializeLib(image, systab);
// Get how much space is needed for the memory map
UINTN mapBytes = 0;
EFI_STATUS retstat;
retstat = uefi_call_wrapper(BS->GetMemoryMap, 5, &mapBytes, NULL, NULL, NULL,
NULL);
if (retstat == EFI_BUFFER_TOO_SMALL) {
Print(L"The memory map requires %d bytes\n\r", mapBytes);
}
// Convert bytes to 4KiB pages (rounded up), plus a little extra to be safe
mapBytes += 512;
UINTN numPages = EFI_SIZE_TO_PAGES(mapBytes);
// Allocate
EFI_PHYSICAL_ADDRESS mapDescPages = 0;
retstat = uefi_call_wrapper(BS->AllocatePages, 4, AllocateAnyPages,
EfiLoaderData, numPages, &mapDescPages);
if (retstat != EFI_SUCCESS) {
Print(L"Something went wrong allocating %d pages: %r\r\n", numPages, retstat);
Print(L"Descs: %x\r\n", mapDescPages);
goto exit0;
} else {
Print(L"Allocation succeeded: 0x%lx\r\n", mapDescPages);
}
// Get the memory map
UINTN descSize;
UINT8 *mapDescBuffer = (UINT8 *)mapDescPages;
retstat = uefi_call_wrapper(BS->GetMemoryMap, 5, &mapBytes, mapDescBuffer,
NULL, &descSize, NULL);
if (retstat != EFI_SUCCESS) {
Print(L"BS->GetMemoryMap(...): %r\n\r", retstat);
goto exit1;
}
// Dump the memory map
printMemoryMap(mapDescBuffer, mapBytes, descSize);
exit1:
uefi_call_wrapper(BS->FreePages, 2, mapDescPages, numPages);
exit0:
return EFI_SUCCESS;
}
EFI_STATUS
efi_main(EFI_HANDLE image, EFI_SYSTEM_TABLE *systab)
{
EFI_STATUS rc = EFI_SUCCESS;
int i;
InitializeLib(image, systab);
rc = show_signature_support(systab);
dumpvar(systab, &EfiGlobalVariable, L"SetupMode");
dumpvar(systab, &EfiGlobalVariable, L"SecureBoot");
dumpvar(systab, &EfiGlobalVariable, EFI_PLATFORM_KEY_NAME);
dumpvar(systab, &EfiGlobalVariable, EFI_KEY_EXCHANGE_KEY_NAME);
dumpvar(systab, &gEfiImageSecurityDatabaseGuid, EFI_IMAGE_SECURITY_DATABASE);
dumpvar(systab, &gEfiImageSecurityDatabaseGuid, EFI_IMAGE_SECURITY_DATABASE1);
return rc;
}
EFI_STATUS
InitializeEfiCompliantBbTest (
IN EFI_HANDLE ImageHandle,
IN EFI_SYSTEM_TABLE *SystemTable
)
{
EfiInitializeTestLib (ImageHandle, SystemTable);
InitializeLib (ImageHandle, SystemTable);
return EfiInitAndInstallBBTestInterface (
&ImageHandle,
&gBBTestProtocolField,
gBBTestEntryField,
EfiCompliantBbTestUnload,
&gBBTestProtocolInterface
);
}
// Application entrypoint
EFI_STATUS EfiMain(EFI_HANDLE ImageHandle, EFI_SYSTEM_TABLE *SystemTable)
{
EFI_INPUT_KEY Key;
InitializeLib(ImageHandle, SystemTable);
Print(L"\n*** UEFI:SIMPLE ***\n\n");
Print(L"\nPress any key to exit.\n");
SystemTable->ConIn->Reset(SystemTable->ConIn, FALSE);
while (SystemTable->ConIn->ReadKeyStroke(SystemTable->ConIn, &Key) == EFI_NOT_READY);
#if defined(_DEBUG)
// If running in debug mode, use the EFI shut down call to close QEMU
RT->ResetSystem(EfiResetShutdown, EFI_SUCCESS, 0, NULL);
#endif
return EFI_SUCCESS;
}
/**
* Scsi Pass Through Protocol Test Driver Entry point.
* @param ImageHandle the driver image handle.
* @param SystemTable the system table.
* @return EFI_SUCCESS the driver is loaded successfully.
*/
EFI_STATUS
InitializeBBTestScsiPassThru (
IN EFI_HANDLE ImageHandle,
IN EFI_SYSTEM_TABLE *SystemTable
)
{
EfiInitializeTestLib (ImageHandle, SystemTable);
InitializeLib (ImageHandle, SystemTable);
return EfiInitAndInstallBBTestInterface (
&ImageHandle,
&gBBTestProtocolField,
gBBTestEntryField,
BBTestScsiPassThruProtocolUnload,
&gBBTestProtocolInterface
);
}