/* * Copyright (C) 2014 Michael Brown . * * This program is free software; you can redistribute it and/or * modify it under the terms of the GNU General Public License as * published by the Free Software Foundation; either version 2 of the * License, or any later version. * * This program is distributed in the hope that it will be useful, but * WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA * 02110-1301, USA. * * You can also choose to distribute this program under the terms of * the Unmodified Binary Distribution Licence (as given in the file * COPYING.UBDL), provided that you have satisfied its requirements. */ FILE_LICENCE ( GPL2_OR_LATER_OR_UBDL ); /** * @file * * EFI image wrapping * */ #include #include #include #include #include #include /** Colour for debug messages */ #define colour &efi_systab /** * Convert EFI status code to text * * @v efirc EFI status code * @ret text EFI status code text */ static const char * efi_status ( EFI_STATUS efirc ) { static char buf[ 19 /* "0xXXXXXXXXXXXXXXXX" + NUL */ ]; switch ( efirc ) { case EFI_SUCCESS : return "0"; case EFI_LOAD_ERROR : return "LOAD_ERROR"; case EFI_INVALID_PARAMETER : return "INVALID_PARAMETER"; case EFI_UNSUPPORTED : return "UNSUPPORTED"; case EFI_BAD_BUFFER_SIZE : return "BAD_BUFFER_SIZE"; case EFI_BUFFER_TOO_SMALL : return "BUFFER_TOO_SMALL"; case EFI_NOT_READY : return "NOT_READY"; case EFI_DEVICE_ERROR : return "DEVICE_ERROR"; case EFI_WRITE_PROTECTED : return "WRITE_PROTECTED"; case EFI_OUT_OF_RESOURCES : return "OUT_OF_RESOURCES"; case EFI_VOLUME_CORRUPTED : return "VOLUME_CORRUPTED"; case EFI_VOLUME_FULL : return "VOLUME_FULL"; case EFI_NO_MEDIA : return "NO_MEDIA"; case EFI_MEDIA_CHANGED : return "MEDIA_CHANGED"; case EFI_NOT_FOUND : return "NOT_FOUND"; case EFI_ACCESS_DENIED : return "ACCESS_DENIED"; case EFI_NO_RESPONSE : return "NO_RESPONSE"; case EFI_NO_MAPPING : return "NO_MAPPING"; case EFI_TIMEOUT : return "TIMEOUT"; case EFI_NOT_STARTED : return "NOT_STARTED"; case EFI_ALREADY_STARTED : return "ALREADY_STARTED"; case EFI_ABORTED : return "ABORTED"; case EFI_ICMP_ERROR : return "ICMP_ERROR"; case EFI_TFTP_ERROR : return "TFTP_ERROR"; case EFI_PROTOCOL_ERROR : return "PROTOCOL_ERROR"; case EFI_INCOMPATIBLE_VERSION : return "INCOMPATIBLE_VERSION"; case EFI_SECURITY_VIOLATION : return "SECURITY_VIOLATION"; case EFI_CRC_ERROR : return "CRC_ERROR"; case EFI_END_OF_MEDIA : return "END_OF_MEDIA"; case EFI_END_OF_FILE : return "END_OF_FILE"; case EFI_INVALID_LANGUAGE : return "INVALID_LANGUAGE"; case EFI_COMPROMISED_DATA : return "COMPROMISED_DATA"; case EFI_WARN_UNKNOWN_GLYPH : return "WARN_UNKNOWN_GLYPH"; case EFI_WARN_DELETE_FAILURE : return "WARN_DELETE_FAILURE"; case EFI_WARN_WRITE_FAILURE : return "WARN_WRITE_FAILURE"; case EFI_WARN_BUFFER_TOO_SMALL : return "WARN_BUFFER_TOO_SMALL"; case EFI_WARN_STALE_DATA : return "WARN_STALE_DATA"; default: snprintf ( buf, sizeof ( buf ), "%#lx", ( unsigned long ) efirc ); return buf; } } /** * Convert EFI boolean to text * * @v boolean Boolean value * @ret text Boolean value text */ static const char * efi_boolean ( BOOLEAN boolean ) { return ( boolean ? "TRUE" : "FALSE" ); } /** * Convert EFI TPL to text * * @v tpl Task priority level * @ret text Task priority level as text */ static const char * efi_tpl ( EFI_TPL tpl ) { static char buf[ 19 /* "0xXXXXXXXXXXXXXXXX" + NUL */ ]; switch ( tpl ) { case TPL_APPLICATION: return "Application"; case TPL_CALLBACK: return "Callback"; case TPL_NOTIFY: return "Notify"; case TPL_HIGH_LEVEL: return "HighLevel"; default: snprintf ( buf, sizeof ( buf ), "%#lx", ( unsigned long ) tpl ); return buf; } } /** * Convert EFI allocation type to text * * @v type Allocation type * @ret text Allocation type as text */ static const char * efi_allocate_type ( EFI_ALLOCATE_TYPE type ) { static char buf[ 11 /* "0xXXXXXXXX" + NUL */ ]; switch ( type ) { case AllocateAnyPages: return "AnyPages"; case AllocateMaxAddress: return "MaxAddress"; case AllocateAddress: return "Address"; default: snprintf ( buf, sizeof ( buf ), "%#x", type ); return buf; } } /** * Convert EFI memory type to text * * @v type Memory type * @ret text Memory type as text */ static const char * efi_memory_type ( EFI_MEMORY_TYPE type ) { static char buf[ 11 /* "0xXXXXXXXX" + NUL */ ]; switch ( type ) { case EfiReservedMemoryType: return "Reserved"; case EfiLoaderCode: return "LoaderCode"; case EfiLoaderData: return "LoaderData"; case EfiBootServicesCode: return "BootCode"; case EfiBootServicesData: return "BootData"; case EfiRuntimeServicesCode: return "RuntimeCode"; case EfiRuntimeServicesData: return "RuntimeData"; case EfiConventionalMemory: return "Conventional"; case EfiUnusableMemory: return "Unusable"; case EfiACPIReclaimMemory: return "ACPIReclaim"; case EfiACPIMemoryNVS: return "ACPINVS"; case EfiMemoryMappedIO: return "MMIO"; case EfiMemoryMappedIOPortSpace:return "PIO"; case EfiPalCode: return "PalCode"; case EfiPersistentMemory: return "Persistent"; default: snprintf ( buf, sizeof ( buf ), "%#x", type ); return buf; } } /** * Convert EFI timer delay type to text * * @v type Timer delay type * @ret text Timer delay type as text */ static const char * efi_timer_delay ( EFI_TIMER_DELAY type ) { static char buf[ 11 /* "0xXXXXXXXX" + NUL */ ]; switch ( type ) { case TimerCancel: return "Cancel"; case TimerPeriodic: return "Periodic"; case TimerRelative: return "Relative"; default: snprintf ( buf, sizeof ( buf ), "%#x", type ); return buf; } } /** * Dump information about a loaded image * * @v handle Image handle */ static void efi_dump_image ( EFI_HANDLE handle ) { EFI_BOOT_SERVICES *bs = efi_systab->BootServices; union { EFI_LOADED_IMAGE_PROTOCOL *image; void *intf; } loaded; EFI_STATUS efirc; int rc; /* Open loaded image protocol */ if ( ( efirc = bs->OpenProtocol ( handle, &efi_loaded_image_protocol_guid, &loaded.intf, efi_image_handle, NULL, EFI_OPEN_PROTOCOL_GET_PROTOCOL ))!=0){ rc = -EEFI ( efirc ); DBGC ( colour, "WRAP %s could not get loaded image protocol: " "%s\n", efi_handle_name ( handle ), strerror ( rc ) ); return; } /* Dump image information */ DBGC ( colour, "WRAP %s at base %p has protocols:\n", efi_handle_name ( handle ), loaded.image->ImageBase ); DBGC_EFI_PROTOCOLS ( colour, handle ); DBGC ( colour, "WRAP %s parent", efi_handle_name ( handle ) ); DBGC ( colour, " %s\n", efi_handle_name ( loaded.image->ParentHandle )); DBGC ( colour, "WRAP %s device", efi_handle_name ( handle ) ); DBGC ( colour, " %s\n", efi_handle_name ( loaded.image->DeviceHandle )); DBGC ( colour, "WRAP %s file", efi_handle_name ( handle ) ); DBGC ( colour, " %s\n", efi_devpath_text ( loaded.image->FilePath ) ); /* Close loaded image protocol */ bs->CloseProtocol ( handle, &efi_loaded_image_protocol_guid, efi_image_handle, NULL ); } /** * Wrap RaiseTPL() * */ static EFI_TPL EFIAPI efi_raise_tpl_wrapper ( EFI_TPL new_tpl ) { EFI_BOOT_SERVICES *bs = efi_systab->BootServices; void *retaddr = __builtin_return_address ( 0 ); EFI_TPL old_tpl; DBGCP ( colour, "RaiseTPL ( %s ) ", efi_tpl ( new_tpl ) ); old_tpl = bs->RaiseTPL ( new_tpl ); DBGCP ( colour, "= %s -> %p\n", efi_tpl ( old_tpl ), retaddr ); return old_tpl; } /** * Wrap RestoreTPL() * */ static VOID EFIAPI efi_restore_tpl_wrapper ( EFI_TPL old_tpl ) { EFI_BOOT_SERVICES *bs = efi_systab->BootServices; void *retaddr = __builtin_return_address ( 0 ); DBGCP ( colour, "RestoreTPL ( %s ) ", efi_tpl ( old_tpl ) ); bs->RestoreTPL ( old_tpl ); DBGCP ( colour, "-> %p\n", retaddr ); } /** * Wrap AllocatePages() * */ static EFI_STATUS EFIAPI efi_allocate_pages_wrapper ( EFI_ALLOCATE_TYPE type, EFI_MEMORY_TYPE memory_type, UINTN pages, EFI_PHYSICAL_ADDRESS *memory ) { EFI_BOOT_SERVICES *bs = efi_systab->BootServices; void *retaddr = __builtin_return_address ( 0 ); EFI_STATUS efirc; DBGC2 ( colour, "AllocatePages ( %s, %s, %#llx, %#llx ) ", efi_allocate_type ( type ), efi_memory_type ( memory_type ), ( ( unsigned long long ) pages ), ( ( unsigned long long ) *memory ) ); efirc = bs->AllocatePages ( type, memory_type, pages, memory ); DBGC2 ( colour, "= %s ( %#llx ) -> %p\n", efi_status ( efirc ), ( ( unsigned long long ) *memory ), retaddr ); return efirc; } /** * Wrap FreePages() * */ static EFI_STATUS EFIAPI efi_free_pages_wrapper ( EFI_PHYSICAL_ADDRESS memory, UINTN pages ) { EFI_BOOT_SERVICES *bs = efi_systab->BootServices; void *retaddr = __builtin_return_address ( 0 ); EFI_STATUS efirc; DBGC2 ( colour, "FreePages ( %#llx, %#llx ) ", ( ( unsigned long long ) memory ), ( ( unsigned long long ) pages ) ); efirc = bs->FreePages ( memory, pages ); DBGC2 ( colour, "= %s -> %p\n", efi_status ( efirc ), retaddr ); return efirc; } /** * Wrap GetMemoryMap() * */ static EFI_STATUS EFIAPI efi_get_memory_map_wrapper ( UINTN *memory_map_size, EFI_MEMORY_DESCRIPTOR *memory_map, UINTN *map_key, UINTN *descriptor_size, UINT32 *descriptor_version ) { EFI_BOOT_SERVICES *bs = efi_systab->BootServices; void *retaddr = __builtin_return_address ( 0 ); EFI_MEMORY_DESCRIPTOR *desc; size_t remaining; EFI_STATUS efirc; DBGC ( colour, "GetMemoryMap ( %#llx, %p ) ", ( ( unsigned long long ) *memory_map_size ), memory_map ); efirc = bs->GetMemoryMap ( memory_map_size, memory_map, map_key, descriptor_size, descriptor_version ); DBGC ( colour, "= %s ( %#llx, %#llx, %#llx, v%d", efi_status ( efirc ), ( ( unsigned long long ) *memory_map_size ), ( ( unsigned long long ) *map_key ), ( ( unsigned long long ) *descriptor_size ), *descriptor_version ); if ( DBG_EXTRA && ( efirc == 0 ) ) { DBGC2 ( colour, ",\n" ); for ( desc = memory_map, remaining = *memory_map_size ; remaining >= *descriptor_size ; desc = ( ( ( void * ) desc ) + *descriptor_size ), remaining -= *descriptor_size ) { DBGC2 ( colour, "%#016llx+%#08llx %#016llx " "%s\n", desc->PhysicalStart, ( desc->NumberOfPages * EFI_PAGE_SIZE ), desc->Attribute, efi_memory_type ( desc->Type ) ); } } else { DBGC ( colour, " " ); } DBGC ( colour, ") -> %p\n", retaddr ); return efirc; } /** * Wrap AllocatePool() * */ static EFI_STATUS EFIAPI efi_allocate_pool_wrapper ( EFI_MEMORY_TYPE pool_type, UINTN size, VOID **buffer ) { EFI_BOOT_SERVICES *bs = efi_systab->BootServices; void *retaddr = __builtin_return_address ( 0 ); EFI_STATUS efirc; DBGC2 ( colour, "AllocatePool ( %s, %#llx ) ", efi_memory_type ( pool_type ), ( ( unsigned long long ) size ) ); efirc = bs->AllocatePool ( pool_type, size, buffer ); DBGC2 ( colour, "= %s ( %p ) -> %p\n", efi_status ( efirc ), *buffer, retaddr ); return efirc; } /** * Wrap FreePool() * */ static EFI_STATUS EFIAPI efi_free_pool_wrapper ( VOID *buffer ) { EFI_BOOT_SERVICES *bs = efi_systab->BootServices; void *retaddr = __builtin_return_address ( 0 ); EFI_STATUS efirc; DBGC2 ( colour, "FreePool ( %p ) ", buffer ); efirc = bs->FreePool ( buffer ); DBGC2 ( colour, "= %s -> %p\n", efi_status ( efirc ), retaddr ); return efirc; } /** * Wrap CreateEvent() * */ static EFI_STATUS EFIAPI efi_create_event_wrapper ( UINT32 type, EFI_TPL notify_tpl, EFI_EVENT_NOTIFY notify_function, VOID *notify_context, EFI_EVENT *event ) { EFI_BOOT_SERVICES *bs = efi_systab->BootServices; void *retaddr = __builtin_return_address ( 0 ); EFI_STATUS efirc; DBGC ( colour, "CreateEvent ( %#x, %s, %p, %p ) ", type, efi_tpl ( notify_tpl ), notify_function, notify_context ); efirc = bs->CreateEvent ( type, notify_tpl, notify_function, notify_context, event ); DBGC ( colour, "= %s ( %p ) -> %p\n", efi_status ( efirc ), *event, retaddr ); return efirc; } /** * Wrap SetTimer() * */ static EFI_STATUS EFIAPI efi_set_timer_wrapper ( EFI_EVENT event, EFI_TIMER_DELAY type, UINT64 trigger_time ) { EFI_BOOT_SERVICES *bs = efi_systab->BootServices; void *retaddr = __builtin_return_address ( 0 ); EFI_STATUS efirc; DBGC ( colour, "SetTimer ( %p, %s, %ld.%07ld00s ) ", event, efi_timer_delay ( type ), ( ( unsigned long ) ( trigger_time / 10000000 ) ), ( ( unsigned long ) ( trigger_time % 10000000 ) ) ); efirc = bs->SetTimer ( event, type, trigger_time ); DBGC ( colour, "= %s -> %p\n", efi_status ( efirc ), retaddr ); return efirc; } /** * Wrap WaitForEvent() * */ static EFI_STATUS EFIAPI efi_wait_for_event_wrapper ( UINTN number_of_events, EFI_EVENT *event, UINTN *index ) { EFI_BOOT_SERVICES *bs = efi_systab->BootServices; void *retaddr = __builtin_return_address ( 0 ); unsigned int i; EFI_STATUS efirc; DBGC ( colour, "WaitForEvent (" ); for ( i = 0 ; i < number_of_events ; i++ ) DBGC ( colour, " %p", event[i] ); DBGC ( colour, " ) " ); efirc = bs->WaitForEvent ( number_of_events, event, index ); DBGC ( colour, "= %s", efi_status ( efirc ) ); if ( efirc == 0 ) DBGC ( colour, " ( %p )", event[*index] ); DBGC ( colour, " -> %p\n", retaddr ); return efirc; } /** * Wrap SignalEvent() * */ static EFI_STATUS EFIAPI efi_signal_event_wrapper ( EFI_EVENT event ) { EFI_BOOT_SERVICES *bs = efi_systab->BootServices; void *retaddr = __builtin_return_address ( 0 ); EFI_STATUS efirc; DBGC2 ( colour, "SignalEvent ( %p ) ", event ); efirc = bs->SignalEvent ( event ); DBGC2 ( colour, "= %s -> %p\n", efi_status ( efirc ), retaddr ); return efirc; } /** * Wrap CloseEvent() * */ static EFI_STATUS EFIAPI efi_close_event_wrapper ( EFI_EVENT event ) { EFI_BOOT_SERVICES *bs = efi_systab->BootServices; void *retaddr = __builtin_return_address ( 0 ); EFI_STATUS efirc; DBGC ( colour, "CloseEvent ( %p ) ", event ); efirc = bs->SignalEvent ( event ); DBGC ( colour, "= %s -> %p\n", efi_status ( efirc ), retaddr ); return efirc; } /** * Wrap CheckEvent() * */ static EFI_STATUS EFIAPI efi_check_event_wrapper ( EFI_EVENT event ) { EFI_BOOT_SERVICES *bs = efi_systab->BootServices; void *retaddr = __builtin_return_address ( 0 ); EFI_STATUS efirc; DBGCP ( colour, "CheckEvent ( %p ) ", event ); efirc = bs->SignalEvent ( event ); DBGCP ( colour, "= %s -> %p\n", efi_status ( efirc ), retaddr ); return efirc; } /** * Wrap InstallProtocolInterface() * */ static EFI_STATUS EFIAPI efi_install_protocol_interface_wrapper ( EFI_HANDLE *handle, EFI_GUID *protocol, EFI_INTERFACE_TYPE interface_type, VOID *interface ) { EFI_BOOT_SERVICES *bs = efi_systab->BootServices; void *retaddr = __builtin_return_address ( 0 ); EFI_STATUS efirc; DBGC ( colour, "InstallProtocolInterface ( %s, %s, %d, %p ) ", efi_handle_name ( *handle ), efi_guid_ntoa ( protocol ), interface_type, interface ); efirc = bs->InstallProtocolInterface ( handle, protocol, interface_type, interface ); DBGC ( colour, "= %s ( %s ) -> %p\n", efi_status ( efirc ), efi_handle_name ( *handle ), retaddr ); return efirc; } /** * Wrap ReinstallProtocolInterface() * */ static EFI_STATUS EFIAPI efi_reinstall_protocol_interface_wrapper ( EFI_HANDLE handle, EFI_GUID *protocol, VOID *old_interface, VOID *new_interface ) { EFI_BOOT_SERVICES *bs = efi_systab->BootServices; void *retaddr = __builtin_return_address ( 0 ); EFI_STATUS efirc; DBGC ( colour, "ReinstallProtocolInterface ( %s, %s, %p, %p ) ", efi_handle_name ( handle ), efi_guid_ntoa ( protocol ), old_interface, new_interface ); efirc = bs->ReinstallProtocolInterface ( handle, protocol, old_interface, new_interface ); DBGC ( colour, "= %s -> %p\n", efi_status ( efirc ), retaddr ); return efirc; } /** * Wrap UninstallProtocolInterface() * */ static EFI_STATUS EFIAPI efi_uninstall_protocol_interface_wrapper ( EFI_HANDLE handle, EFI_GUID *protocol, VOID *interface ) { EFI_BOOT_SERVICES *bs = efi_systab->BootServices; void *retaddr = __builtin_return_address ( 0 ); EFI_STATUS efirc; DBGC ( colour, "UninstallProtocolInterface ( %s, %s, %p ) ", efi_handle_name ( handle ), efi_guid_ntoa ( protocol ), interface ); efirc = bs->UninstallProtocolInterface ( handle, protocol, interface ); DBGC ( colour, "= %s -> %p\n", efi_status ( efirc ), retaddr ); return efirc; } /** * Wrap HandleProtocol() * */ static EFI_STATUS EFIAPI efi_handle_protocol_wrapper ( EFI_HANDLE handle, EFI_GUID *protocol, VOID **interface ) { EFI_BOOT_SERVICES *bs = efi_systab->BootServices; void *retaddr = __builtin_return_address ( 0 ); EFI_STATUS efirc; DBGC ( colour, "HandleProtocol ( %s, %s ) ", efi_handle_name ( handle ), efi_guid_ntoa ( protocol ) ); efirc = bs->HandleProtocol ( handle, protocol, interface ); DBGC ( colour, "= %s ( %p ) -> %p\n", efi_status ( efirc ), *interface, retaddr ); return efirc; } /** * Wrap RegisterProtocolNotify() * */ static EFI_STATUS EFIAPI efi_register_protocol_notify_wrapper ( EFI_GUID *protocol, EFI_EVENT event, VOID **registration ) { EFI_BOOT_SERVICES *bs = efi_systab->BootServices; void *retaddr = __builtin_return_address ( 0 ); EFI_STATUS efirc; DBGC ( colour, "RegisterProtocolNotify ( %s, %p ) ", efi_guid_ntoa ( protocol ), event ); efirc = bs->RegisterProtocolNotify ( protocol, event, registration ); DBGC ( colour, "= %s ( %p ) -> %p\n", efi_status ( efirc ), *registration, retaddr ); return efirc; } /** * Wrap LocateHandle() * */ static EFI_STATUS EFIAPI efi_locate_handle_wrapper ( EFI_LOCATE_SEARCH_TYPE search_type, EFI_GUID *protocol, VOID *search_key, UINTN *buffer_size, EFI_HANDLE *buffer ) { EFI_BOOT_SERVICES *bs = efi_systab->BootServices; void *retaddr = __builtin_return_address ( 0 ); unsigned int i; EFI_STATUS efirc; DBGC ( colour, "LocateHandle ( %s, %s, %p, %zd ) ", efi_locate_search_type_name ( search_type ), efi_guid_ntoa ( protocol ), search_key, ( ( size_t ) *buffer_size ) ); efirc = bs->LocateHandle ( search_type, protocol, search_key, buffer_size, buffer ); DBGC ( colour, "= %s ( %zd", efi_status ( efirc ), ( ( size_t ) *buffer_size ) ); if ( efirc == 0 ) { DBGC ( colour, ", {" ); for ( i = 0; i < ( *buffer_size / sizeof ( buffer[0] ) ); i++ ){ DBGC ( colour, "%s%s", ( i ? ", " : " " ), efi_handle_name ( buffer[i] ) ); } DBGC ( colour, " }" ); } DBGC ( colour, " ) -> %p\n", retaddr ); return efirc; } /** * Wrap LocateDevicePath() * */ static EFI_STATUS EFIAPI efi_locate_device_path_wrapper ( EFI_GUID *protocol, EFI_DEVICE_PATH_PROTOCOL **device_path, EFI_HANDLE *device ) { EFI_BOOT_SERVICES *bs = efi_systab->BootServices; void *retaddr = __builtin_return_address ( 0 ); EFI_STATUS efirc; DBGC ( colour, "LocateDevicePath ( %s, %s ) ", efi_guid_ntoa ( protocol ), efi_devpath_text ( *device_path ) ); efirc = bs->LocateDevicePath ( protocol, device_path, device ); DBGC ( colour, "= %s ( %s, ", efi_status ( efirc ), efi_devpath_text ( *device_path ) ); DBGC ( colour, "%s ) -> %p\n", efi_handle_name ( *device ), retaddr ); return efirc; } /** * Wrap InstallConfigurationTable() * */ static EFI_STATUS EFIAPI efi_install_configuration_table_wrapper ( EFI_GUID *guid, VOID *table ) { EFI_BOOT_SERVICES *bs = efi_systab->BootServices; void *retaddr = __builtin_return_address ( 0 ); EFI_STATUS efirc; DBGC ( colour, "InstallConfigurationTable ( %s, %p ) ", efi_guid_ntoa ( guid ), table ); efirc = bs->InstallConfigurationTable ( guid, table ); DBGC ( colour, "= %s -> %p\n", efi_status ( efirc ), retaddr ); return efirc; } /** * Wrap LoadImage() * */ static EFI_STATUS EFIAPI efi_load_image_wrapper ( BOOLEAN boot_policy, EFI_HANDLE parent_image_handle, EFI_DEVICE_PATH_PROTOCOL *device_path, VOID *source_buffer, UINTN source_size, EFI_HANDLE *image_handle ) { EFI_BOOT_SERVICES *bs = efi_systab->BootServices; void *retaddr = __builtin_return_address ( 0 ); EFI_STATUS efirc; DBGC ( colour, "LoadImage ( %s, %s, ", efi_boolean ( boot_policy ), efi_handle_name ( parent_image_handle ) ); DBGC ( colour, "%s, %p, %#llx ) ", efi_devpath_text ( device_path ), source_buffer, ( ( unsigned long long ) source_size ) ); efirc = bs->LoadImage ( boot_policy, parent_image_handle, device_path, source_buffer, source_size, image_handle ); DBGC ( colour, "= %s ( ", efi_status ( efirc ) ); if ( efirc == 0 ) DBGC ( colour, "%s ", efi_handle_name ( *image_handle ) ); DBGC ( colour, ") -> %p\n", retaddr ); /* Dump information about loaded image */ if ( efirc == 0 ) efi_dump_image ( *image_handle ); return efirc; } /** * Wrap StartImage() * */ static EFI_STATUS EFIAPI efi_start_image_wrapper ( EFI_HANDLE image_handle, UINTN *exit_data_size, CHAR16 **exit_data ) { EFI_BOOT_SERVICES *bs = efi_systab->BootServices; void *retaddr = __builtin_return_address ( 0 ); EFI_STATUS efirc; DBGC ( colour, "StartImage ( %s ) ", efi_handle_name ( image_handle ) ); efirc = bs->StartImage ( image_handle, exit_data_size, exit_data ); DBGC ( colour, "= %s", efi_status ( efirc ) ); if ( ( efirc != 0 ) && exit_data && *exit_data_size ) DBGC ( colour, " ( \"%ls\" )", *exit_data ); DBGC ( colour, " -> %p\n", retaddr ); if ( ( efirc != 0 ) && exit_data && *exit_data_size ) DBGC_HD ( colour, *exit_data, *exit_data_size ); return efirc; } /** * Wrap Exit() * */ static EFI_STATUS EFIAPI efi_exit_wrapper ( EFI_HANDLE image_handle, EFI_STATUS exit_status, UINTN exit_data_size, CHAR16 *exit_data ) { EFI_BOOT_SERVICES *bs = efi_systab->BootServices; void *retaddr = __builtin_return_address ( 0 ); EFI_STATUS efirc; if ( ( exit_status != 0 ) && exit_data && exit_data_size ) DBGC_HD ( colour, exit_data, exit_data_size ); DBGC ( colour, "Exit ( %s, %s", efi_handle_name ( image_handle ), efi_status ( exit_status ) ); if ( ( exit_status != 0 ) && exit_data && exit_data_size ) DBGC ( colour, ", \"%ls\"", exit_data ); DBGC ( colour, " ) " ); efirc = bs->Exit ( image_handle, exit_status, exit_data_size, exit_data ); DBGC ( colour, "= %s -> %p\n", efi_status ( efirc ), retaddr ); return efirc; } /** * Wrap UnloadImage() * */ static EFI_STATUS EFIAPI efi_unload_image_wrapper ( EFI_HANDLE image_handle ) { EFI_BOOT_SERVICES *bs = efi_systab->BootServices; void *retaddr = __builtin_return_address ( 0 ); EFI_STATUS efirc; DBGC ( colour, "UnloadImage ( %s ) ", efi_handle_name ( image_handle ) ); efirc = bs->UnloadImage ( image_handle ); DBGC ( colour, "= %s -> %p\n", efi_status ( efirc ), retaddr ); return efirc; } /** * Wrap ExitBootServices() * */ static EFI_STATUS EFIAPI efi_exit_boot_services_wrapper ( EFI_HANDLE image_handle, UINTN map_key ) { EFI_BOOT_SERVICES *bs = efi_systab->BootServices; void *retaddr = __builtin_return_address ( 0 ); EFI_STATUS efirc; DBGC ( colour, "ExitBootServices ( %s, %#llx ) -> %p\n", efi_handle_name ( image_handle ), ( ( unsigned long long ) map_key ), retaddr ); efirc = bs->ExitBootServices ( image_handle, map_key ); if ( efirc != 0 ) { DBGC ( colour, "ExitBootServices ( ... ) = %s -> %p\n", efi_status ( efirc ), retaddr ); } return efirc; } /** * Wrap GetNextMonotonicCount() * */ static EFI_STATUS EFIAPI efi_get_next_monotonic_count_wrapper ( UINT64 *count ) { EFI_BOOT_SERVICES *bs = efi_systab->BootServices; void *retaddr = __builtin_return_address ( 0 ); EFI_STATUS efirc; DBGCP ( colour, "GetNextMonotonicCount() " ); efirc = bs->GetNextMonotonicCount ( count ); DBGCP ( colour, "= %s ( %#llx ) -> %p\n", efi_status ( efirc ), *count, retaddr ); return efirc; } /** * Wrap Stall() * */ static EFI_STATUS EFIAPI efi_stall_wrapper ( UINTN microseconds ) { EFI_BOOT_SERVICES *bs = efi_systab->BootServices; void *retaddr = __builtin_return_address ( 0 ); EFI_STATUS efirc; DBGC2 ( colour, "Stall ( %ld.%06lds ) ", ( ( unsigned long ) ( microseconds / 1000000 ) ), ( ( unsigned long ) ( microseconds % 1000000 ) ) ); efirc = bs->Stall ( microseconds ); DBGC2 ( colour, "= %s -> %p\n", efi_status ( efirc ), retaddr ); return efirc; } /** * Wrap SetWatchdogTimer() * */ static EFI_STATUS EFIAPI efi_set_watchdog_timer_wrapper ( UINTN timeout, UINT64 watchdog_code, UINTN data_size, CHAR16 *watchdog_data ) { EFI_BOOT_SERVICES *bs = efi_systab->BootServices; void *retaddr = __builtin_return_address ( 0 ); EFI_STATUS efirc; DBGC ( colour, "SetWatchdogTimer ( %lds, %#llx, %#llx, %p ) ", ( ( unsigned long ) timeout ), watchdog_code, ( ( unsigned long long ) data_size ), watchdog_data ); efirc = bs->SetWatchdogTimer ( timeout, watchdog_code, data_size, watchdog_data ); DBGC ( colour, "= %s -> %p\n", efi_status ( efirc ), retaddr ); return efirc; } /** * Wrap ConnectController() * */ static EFI_STATUS EFIAPI efi_connect_controller_wrapper ( EFI_HANDLE controller_handle, EFI_HANDLE *driver_image_handle, EFI_DEVICE_PATH_PROTOCOL *remaining_path, BOOLEAN recursive ) { EFI_BOOT_SERVICES *bs = efi_systab->BootServices; void *retaddr = __builtin_return_address ( 0 ); EFI_HANDLE *tmp; EFI_STATUS efirc; DBGC ( colour, "ConnectController ( %s, {", efi_handle_name ( controller_handle ) ); if ( driver_image_handle ) { for ( tmp = driver_image_handle ; *tmp ; tmp++ ) { DBGC ( colour, "%s%s", ( ( tmp == driver_image_handle ) ? " " : ", " ), efi_handle_name ( *tmp ) ); } } DBGC ( colour, " }, %s, %s ) ", efi_devpath_text ( remaining_path ), efi_boolean ( recursive ) ); efirc = bs->ConnectController ( controller_handle, driver_image_handle, remaining_path, recursive ); DBGC ( colour, "= %s -> %p\n", efi_status ( efirc ), retaddr ); return efirc; } /** * Wrap DisconnectController() * */ static EFI_STATUS EFIAPI efi_disconnect_controller_wrapper ( EFI_HANDLE controller_handle, EFI_HANDLE driver_image_handle, EFI_HANDLE child_handle ) { EFI_BOOT_SERVICES *bs = efi_systab->BootServices; void *retaddr = __builtin_return_address ( 0 ); EFI_STATUS efirc; DBGC ( colour, "DisconnectController ( %s", efi_handle_name ( controller_handle ) ); DBGC ( colour, ", %s", efi_handle_name ( driver_image_handle ) ); DBGC ( colour, ", %s ) ", efi_handle_name ( child_handle ) ); efirc = bs->DisconnectController ( controller_handle, driver_image_handle, child_handle ); DBGC ( colour, "= %s -> %p\n", efi_status ( efirc ), retaddr ); return efirc; } /** * Wrap OpenProtocol() * */ static EFI_STATUS EFIAPI efi_open_protocol_wrapper ( EFI_HANDLE handle, EFI_GUID *protocol, VOID **interface, EFI_HANDLE agent_handle, EFI_HANDLE controller_handle, UINT32 attributes ) { EFI_BOOT_SERVICES *bs = efi_systab->BootServices; void *retaddr = __builtin_return_address ( 0 ); EFI_STATUS efirc; DBGC ( colour, "OpenProtocol ( %s, %s, ", efi_handle_name ( handle ), efi_guid_ntoa ( protocol ) ); DBGC ( colour, "%s, ", efi_handle_name ( agent_handle ) ); DBGC ( colour, "%s, %s ) ", efi_handle_name ( controller_handle ), efi_open_attributes_name ( attributes ) ); efirc = bs->OpenProtocol ( handle, protocol, interface, agent_handle, controller_handle, attributes ); DBGC ( colour, "= %s ( %p ) -> %p\n", efi_status ( efirc ), *interface, retaddr ); return efirc; } /** * Wrap CloseProtocol() * */ static EFI_STATUS EFIAPI efi_close_protocol_wrapper ( EFI_HANDLE handle, EFI_GUID *protocol, EFI_HANDLE agent_handle, EFI_HANDLE controller_handle ) { EFI_BOOT_SERVICES *bs = efi_systab->BootServices; void *retaddr = __builtin_return_address ( 0 ); EFI_STATUS efirc; DBGC ( colour, "CloseProtocol ( %s, %s, ", efi_handle_name ( handle ), efi_guid_ntoa ( protocol ) ); DBGC ( colour, "%s, ", efi_handle_name ( agent_handle ) ); DBGC ( colour, "%s ) ", efi_handle_name ( controller_handle ) ); efirc = bs->CloseProtocol ( handle, protocol, agent_handle, controller_handle ); DBGC ( colour, "= %s -> %p\n", efi_status ( efirc ), retaddr ); return efirc; } /** * Wrap OpenProtocolInformation() * */ static EFI_STATUS EFIAPI efi_open_protocol_information_wrapper ( EFI_HANDLE handle, EFI_GUID *protocol, EFI_OPEN_PROTOCOL_INFORMATION_ENTRY **entry_buffer, UINTN *entry_count ) { EFI_BOOT_SERVICES *bs = efi_systab->BootServices; void *retaddr = __builtin_return_address ( 0 ); EFI_STATUS efirc; DBGC ( colour, "OpenProtocolInformation ( %s, %s ) ", efi_handle_name ( handle ), efi_guid_ntoa ( protocol ) ); efirc = bs->OpenProtocolInformation ( handle, protocol, entry_buffer, entry_count ); DBGC ( colour, "= %s ( %p, %#llx ) -> %p\n", efi_status ( efirc ), *entry_buffer, ( ( unsigned long long ) *entry_count ), retaddr ); return efirc; } /** * Wrap ProtocolsPerHandle() * */ static EFI_STATUS EFIAPI efi_protocols_per_handle_wrapper ( EFI_HANDLE handle, EFI_GUID ***protocol_buffer, UINTN *protocol_buffer_count ) { EFI_BOOT_SERVICES *bs = efi_systab->BootServices; void *retaddr = __builtin_return_address ( 0 ); unsigned int i; EFI_STATUS efirc; DBGC ( colour, "ProtocolsPerHandle ( %s ) ", efi_handle_name ( handle ) ); efirc = bs->ProtocolsPerHandle ( handle, protocol_buffer, protocol_buffer_count ); DBGC ( colour, "= %s", efi_status ( efirc ) ); if ( efirc == 0 ) { DBGC ( colour, " ( {" ); for ( i = 0 ; i < *protocol_buffer_count ; i++ ) { DBGC ( colour, "%s%s", ( i ? ", " : " " ), efi_guid_ntoa ( (*protocol_buffer)[i] ) ); } DBGC ( colour, " } )" ); } DBGC ( colour, " -> %p\n", retaddr ); return efirc; } /** * Wrap LocateHandleBuffer() * */ static EFI_STATUS EFIAPI efi_locate_handle_buffer_wrapper ( EFI_LOCATE_SEARCH_TYPE search_type, EFI_GUID *protocol, VOID *search_key, UINTN *no_handles, EFI_HANDLE **buffer ) { EFI_BOOT_SERVICES *bs = efi_systab->BootServices; void *retaddr = __builtin_return_address ( 0 ); unsigned int i; EFI_STATUS efirc; DBGC ( colour, "LocateHandleBuffer ( %s, %s, %p ) ", efi_locate_search_type_name ( search_type ), efi_guid_ntoa ( protocol ), search_key ); efirc = bs->LocateHandleBuffer ( search_type, protocol, search_key, no_handles, buffer ); DBGC ( colour, "= %s", efi_status ( efirc ) ); if ( efirc == 0 ) { DBGC ( colour, " ( %d, {", ( ( unsigned int ) *no_handles ) ); for ( i = 0 ; i < *no_handles ; i++ ) { DBGC ( colour, "%s%s", ( i ? ", " : " " ), efi_handle_name ( (*buffer)[i] ) ); } DBGC ( colour, " } )" ); } DBGC ( colour, " -> %p\n", retaddr ); return efirc; } /** * Wrap LocateProtocol() * */ static EFI_STATUS EFIAPI efi_locate_protocol_wrapper ( EFI_GUID *protocol, VOID *registration, VOID **interface ) { EFI_BOOT_SERVICES *bs = efi_systab->BootServices; void *retaddr = __builtin_return_address ( 0 ); EFI_STATUS efirc; DBGC ( colour, "LocateProtocol ( %s, %p ) ", efi_guid_ntoa ( protocol ), registration ); efirc = bs->LocateProtocol ( protocol, registration, interface ); DBGC ( colour, "= %s ( %p ) -> %p\n", efi_status ( efirc ), *interface, retaddr ); return efirc; } /** Maximum number of interfaces for wrapped ...MultipleProtocolInterfaces() */ #define MAX_WRAP_MULTI 20 /** * Wrap InstallMultipleProtocolInterfaces() * */ static EFI_STATUS EFIAPI efi_install_multiple_protocol_interfaces_wrapper ( EFI_HANDLE *handle, ... ) { EFI_BOOT_SERVICES *bs = efi_systab->BootServices; void *retaddr = __builtin_return_address ( 0 ); EFI_GUID *protocol[ MAX_WRAP_MULTI + 1 ]; VOID *interface[MAX_WRAP_MULTI]; VA_LIST ap; unsigned int i; EFI_STATUS efirc; DBGC ( colour, "InstallMultipleProtocolInterfaces ( %s", efi_handle_name ( *handle ) ); memset ( protocol, 0, sizeof ( protocol ) ); memset ( interface, 0, sizeof ( interface ) ); VA_START ( ap, handle ); for ( i = 0 ; ( protocol[i] = VA_ARG ( ap, EFI_GUID * ) ) ; i++ ) { if ( i == MAX_WRAP_MULTI ) { VA_END ( ap ); efirc = EFI_OUT_OF_RESOURCES; DBGC ( colour, " ) = %s " "-> %p\n", efi_status ( efirc ), retaddr ); return efirc; } interface[i] = VA_ARG ( ap, VOID * ); DBGC ( colour, ", %s, %p", efi_guid_ntoa ( protocol[i] ), interface[i] ); } VA_END ( ap ); DBGC ( colour, " ) " ); efirc = bs->InstallMultipleProtocolInterfaces ( handle, protocol[0], interface[0], protocol[1], interface[1], protocol[2], interface[2], protocol[3], interface[3], protocol[4], interface[4], protocol[5], interface[5], protocol[6], interface[6], protocol[7], interface[7], protocol[8], interface[8], protocol[9], interface[9], protocol[10], interface[10], protocol[11], interface[11], protocol[12], interface[12], protocol[13], interface[13], protocol[14], interface[14], protocol[15], interface[15], protocol[16], interface[16], protocol[17], interface[17], protocol[18], interface[18], protocol[19], interface[19], NULL ); DBGC ( colour, "= %s ( %s ) -> %p\n", efi_status ( efirc ), efi_handle_name ( *handle ), retaddr ); return efirc; } /** * Wrap UninstallMultipleProtocolInterfaces() * */ static EFI_STATUS EFIAPI efi_uninstall_multiple_protocol_interfaces_wrapper ( EFI_HANDLE handle, ... ) { EFI_BOOT_SERVICES *bs = efi_systab->BootServices; void *retaddr = __builtin_return_address ( 0 ); EFI_GUID *protocol[ MAX_WRAP_MULTI + 1 ]; VOID *interface[MAX_WRAP_MULTI]; VA_LIST ap; unsigned int i; EFI_STATUS efirc; DBGC ( colour, "UninstallMultipleProtocolInterfaces ( %s", efi_handle_name ( handle ) ); memset ( protocol, 0, sizeof ( protocol ) ); memset ( interface, 0, sizeof ( interface ) ); VA_START ( ap, handle ); for ( i = 0 ; ( protocol[i] = VA_ARG ( ap, EFI_GUID * ) ) ; i++ ) { if ( i == MAX_WRAP_MULTI ) { VA_END ( ap ); efirc = EFI_OUT_OF_RESOURCES; DBGC ( colour, " ) = %s " "-> %p\n", efi_status ( efirc ), retaddr ); return efirc; } interface[i] = VA_ARG ( ap, VOID * ); DBGC ( colour, ", %s, %p", efi_guid_ntoa ( protocol[i] ), interface[i] ); } VA_END ( ap ); DBGC ( colour, " ) " ); efirc = bs->UninstallMultipleProtocolInterfaces ( handle, protocol[0], interface[0], protocol[1], interface[1], protocol[2], interface[2], protocol[3], interface[3], protocol[4], interface[4], protocol[5], interface[5], protocol[6], interface[6], protocol[7], interface[7], protocol[8], interface[8], protocol[9], interface[9], protocol[10], interface[10], protocol[11], interface[11], protocol[12], interface[12], protocol[13], interface[13], protocol[14], interface[14], protocol[15], interface[15], protocol[16], interface[16], protocol[17], interface[17], protocol[18], interface[18], protocol[19], interface[19], NULL ); DBGC ( colour, "= %s -> %p\n", efi_status ( efirc ), retaddr ); return efirc; } /** * Wrap CreateEventEx() * */ static EFI_STATUS EFIAPI efi_create_event_ex_wrapper ( UINT32 type, EFI_TPL notify_tpl, EFI_EVENT_NOTIFY notify_function, CONST VOID *notify_context, CONST EFI_GUID *event_group, EFI_EVENT *event ) { EFI_BOOT_SERVICES *bs = efi_systab->BootServices; void *retaddr = __builtin_return_address ( 0 ); EFI_STATUS efirc; DBGC ( colour, "CreateEventEx ( %#x, %s, %p, %p, %s ) ", type, efi_tpl ( notify_tpl ), notify_function, notify_context, efi_guid_ntoa ( event_group ) ); efirc = bs->CreateEventEx ( type, notify_tpl, notify_function, notify_context, event_group, event ); DBGC ( colour, "= %s ( %p ) -> %p\n", efi_status ( efirc ), *event, retaddr ); return efirc; } /** * Build boot services table wrapper * * @ret bs Wrapped boot services table */ EFI_BOOT_SERVICES * efi_wrap_bs ( void ) { static EFI_BOOT_SERVICES efi_bs_wrapper; EFI_BOOT_SERVICES *bs = efi_systab->BootServices; /* Build boot services table wrapper */ memcpy ( &efi_bs_wrapper, bs, sizeof ( efi_bs_wrapper ) ); efi_bs_wrapper.RaiseTPL = efi_raise_tpl_wrapper; efi_bs_wrapper.RestoreTPL = efi_restore_tpl_wrapper; efi_bs_wrapper.AllocatePages = efi_allocate_pages_wrapper; efi_bs_wrapper.FreePages = efi_free_pages_wrapper; efi_bs_wrapper.GetMemoryMap = efi_get_memory_map_wrapper; efi_bs_wrapper.AllocatePool = efi_allocate_pool_wrapper; efi_bs_wrapper.FreePool = efi_free_pool_wrapper; efi_bs_wrapper.CreateEvent = efi_create_event_wrapper; efi_bs_wrapper.SetTimer = efi_set_timer_wrapper; efi_bs_wrapper.WaitForEvent = efi_wait_for_event_wrapper; efi_bs_wrapper.SignalEvent = efi_signal_event_wrapper; efi_bs_wrapper.CloseEvent = efi_close_event_wrapper; efi_bs_wrapper.CheckEvent = efi_check_event_wrapper; efi_bs_wrapper.InstallProtocolInterface = efi_install_protocol_interface_wrapper; efi_bs_wrapper.ReinstallProtocolInterface = efi_reinstall_protocol_interface_wrapper; efi_bs_wrapper.UninstallProtocolInterface = efi_uninstall_protocol_interface_wrapper; efi_bs_wrapper.HandleProtocol = efi_handle_protocol_wrapper; efi_bs_wrapper.RegisterProtocolNotify = efi_register_protocol_notify_wrapper; efi_bs_wrapper.LocateHandle = efi_locate_handle_wrapper; efi_bs_wrapper.LocateDevicePath = efi_locate_device_path_wrapper; efi_bs_wrapper.InstallConfigurationTable = efi_install_configuration_table_wrapper; efi_bs_wrapper.LoadImage = efi_load_image_wrapper; efi_bs_wrapper.StartImage = efi_start_image_wrapper; efi_bs_wrapper.Exit = efi_exit_wrapper; efi_bs_wrapper.UnloadImage = efi_unload_image_wrapper; efi_bs_wrapper.ExitBootServices = efi_exit_boot_services_wrapper; efi_bs_wrapper.GetNextMonotonicCount = efi_get_next_monotonic_count_wrapper; efi_bs_wrapper.Stall = efi_stall_wrapper; efi_bs_wrapper.SetWatchdogTimer = efi_set_watchdog_timer_wrapper; efi_bs_wrapper.ConnectController = efi_connect_controller_wrapper; efi_bs_wrapper.DisconnectController = efi_disconnect_controller_wrapper; efi_bs_wrapper.OpenProtocol = efi_open_protocol_wrapper; efi_bs_wrapper.CloseProtocol = efi_close_protocol_wrapper; efi_bs_wrapper.OpenProtocolInformation = efi_open_protocol_information_wrapper; efi_bs_wrapper.ProtocolsPerHandle = efi_protocols_per_handle_wrapper; efi_bs_wrapper.LocateHandleBuffer = efi_locate_handle_buffer_wrapper; efi_bs_wrapper.LocateProtocol = efi_locate_protocol_wrapper; efi_bs_wrapper.InstallMultipleProtocolInterfaces = efi_install_multiple_protocol_interfaces_wrapper; efi_bs_wrapper.UninstallMultipleProtocolInterfaces = efi_uninstall_multiple_protocol_interfaces_wrapper; efi_bs_wrapper.CreateEventEx = efi_create_event_ex_wrapper; return &efi_bs_wrapper; } /** * Wrap the calls made by a loaded image * * @v handle Image handle */ void efi_wrap ( EFI_HANDLE handle ) { static EFI_SYSTEM_TABLE efi_systab_copy; /* Do nothing unless debugging is enabled */ if ( ! DBG_LOG ) return; /* Construct modified system table */ if ( efi_systab != &efi_systab_copy ) { memcpy ( &efi_systab_copy, efi_systab, sizeof ( efi_systab_copy ) ); efi_systab->BootServices = efi_wrap_bs(); efi_systab = &efi_systab_copy; } /* Dump image information */ efi_dump_image ( handle ); }