From 804405e7d10525e41720216137b2551f62a0663f Mon Sep 17 00:00:00 2001 From: eric_tian Date: Mon, 30 Jun 2008 05:08:49 +0000 Subject: Port EdkUnixPkg to UnixPkg. The changes are listed as follows: 1. change *.msa to *.inf, and create platform configuration files .dec&.dsc&.fdf to comply with Edk2 build process 2. using PCD mechanism to replace macro. 3. change Sec code to cowork with PI1.0 Pei Core and produce temparory memory ppi. git-svn-id: https://edk2.svn.sourceforge.net/svnroot/edk2/trunk/edk2@5380 6f19259b-4bc3-4df7-8a09-765794883524 --- UnixPkg/Sec/FwVol.c | 314 ++++++++++++++ UnixPkg/Sec/SecMain.c | 1048 +++++++++++++++++++++++++++++++++++++++++++++++ UnixPkg/Sec/SecMain.h | 548 +++++++++++++++++++++++++ UnixPkg/Sec/SecMain.inf | 76 ++++ UnixPkg/Sec/SecMain.msa | 113 +++++ UnixPkg/Sec/Stack.S | 92 +++++ UnixPkg/Sec/UgaX11.c | 595 +++++++++++++++++++++++++++ UnixPkg/Sec/UnixThunk.c | 197 +++++++++ 8 files changed, 2983 insertions(+) create mode 100644 UnixPkg/Sec/FwVol.c create mode 100644 UnixPkg/Sec/SecMain.c create mode 100644 UnixPkg/Sec/SecMain.h create mode 100644 UnixPkg/Sec/SecMain.inf create mode 100644 UnixPkg/Sec/SecMain.msa create mode 100644 UnixPkg/Sec/Stack.S create mode 100644 UnixPkg/Sec/UgaX11.c create mode 100644 UnixPkg/Sec/UnixThunk.c (limited to 'UnixPkg/Sec') diff --git a/UnixPkg/Sec/FwVol.c b/UnixPkg/Sec/FwVol.c new file mode 100644 index 0000000000..7206e00fbe --- /dev/null +++ b/UnixPkg/Sec/FwVol.c @@ -0,0 +1,314 @@ +/*++ + +Copyright (c) 2006, Intel Corporation +All rights reserved. This program and the accompanying materials +are licensed and made available under the terms and conditions of the BSD License +which accompanies this distribution. The full text of the license may be found at +http://opensource.org/licenses/bsd-license.php + +THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS, +WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED. + +Module Name: + FwVol.c + +Abstract: + A simple FV stack so the SEC can extract the SEC Core from an + FV. + +--*/ + +#include "SecMain.h" + +#define GET_OCCUPIED_SIZE(ActualSize, Alignment) \ + (ActualSize) + (((Alignment) - ((ActualSize) & ((Alignment) - 1))) & ((Alignment) - 1)) + +EFI_FFS_FILE_STATE +GetFileState ( + IN UINT8 ErasePolarity, + IN EFI_FFS_FILE_HEADER *FfsHeader + ) +/*++ + +Routine Description: + Returns the highest bit set of the State field + +Arguments: + ErasePolarity - Erase Polarity as defined by EFI_FVB2_ERASE_POLARITY + in the Attributes field. + FfsHeader - Pointer to FFS File Header. + +Returns: + Returns the highest bit in the State field + +--*/ +{ + EFI_FFS_FILE_STATE FileState; + EFI_FFS_FILE_STATE HighestBit; + + FileState = FfsHeader->State; + + if (ErasePolarity != 0) { + FileState = (EFI_FFS_FILE_STATE)~FileState; + } + + HighestBit = 0x80; + while (HighestBit != 0 && (HighestBit & FileState) == 0) { + HighestBit >>= 1; + } + + return HighestBit; +} + +UINT8 +CalculateHeaderChecksum ( + IN EFI_FFS_FILE_HEADER *FileHeader + ) +/*++ + +Routine Description: + Calculates the checksum of the header of a file. + +Arguments: + FileHeader - Pointer to FFS File Header. + +Returns: + Checksum of the header. + +--*/ +{ + UINT8 *ptr; + UINTN Index; + UINT8 Sum; + + Sum = 0; + ptr = (UINT8 *) FileHeader; + + for (Index = 0; Index < sizeof (EFI_FFS_FILE_HEADER) - 3; Index += 4) { + Sum = (UINT8) (Sum + ptr[Index]); + Sum = (UINT8) (Sum + ptr[Index + 1]); + Sum = (UINT8) (Sum + ptr[Index + 2]); + Sum = (UINT8) (Sum + ptr[Index + 3]); + } + + for (; Index < sizeof (EFI_FFS_FILE_HEADER); Index++) { + Sum = (UINT8) (Sum + ptr[Index]); + } + // + // State field (since this indicates the different state of file). + // + Sum = (UINT8) (Sum - FileHeader->State); + // + // Checksum field of the file is not part of the header checksum. + // + Sum = (UINT8) (Sum - FileHeader->IntegrityCheck.Checksum.File); + + return Sum; +} + +EFI_STATUS +SecFfsFindNextFile ( + IN EFI_FV_FILETYPE SearchType, + IN EFI_FIRMWARE_VOLUME_HEADER *FwVolHeader, + IN OUT EFI_FFS_FILE_HEADER **FileHeader + ) +/*++ + +Routine Description: + Given the input file pointer, search for the next matching file in the + FFS volume as defined by SearchType. The search starts from FileHeader inside + the Firmware Volume defined by FwVolHeader. + +Arguments: + SearchType - Filter to find only files of this type. + Type EFI_FV_FILETYPE_ALL causes no filtering to be done. + FwVolHeader - Pointer to the FV header of the volume to search. + This parameter must point to a valid FFS volume. + FileHeader - Pointer to the current file from which to begin searching. + This pointer will be updated upon return to reflect the file + found. + +Returns: + EFI_NOT_FOUND - No files matching the search criteria were found + EFI_SUCCESS + +--*/ +{ + EFI_FFS_FILE_HEADER *FfsFileHeader; + UINT32 FileLength; + UINT32 FileOccupiedSize; + UINT32 FileOffset; + UINT64 FvLength; + UINT8 ErasePolarity; + UINT8 FileState; + + FvLength = FwVolHeader->FvLength; + if (FwVolHeader->Attributes & EFI_FVB2_ERASE_POLARITY) { + ErasePolarity = 1; + } else { + ErasePolarity = 0; + } + // + // If FileHeader is not specified (NULL) start with the first file in the + // firmware volume. Otherwise, start from the FileHeader. + // + if (*FileHeader == NULL) { + FfsFileHeader = (EFI_FFS_FILE_HEADER *) ((UINT8 *) FwVolHeader + FwVolHeader->HeaderLength); + } else { + // + // Length is 24 bits wide so mask upper 8 bits + // FileLength is adjusted to FileOccupiedSize as it is 8 byte aligned. + // + FileLength = *(UINT32 *) (*FileHeader)->Size & 0x00FFFFFF; + FileOccupiedSize = GET_OCCUPIED_SIZE (FileLength, 8); + FfsFileHeader = (EFI_FFS_FILE_HEADER *) ((UINT8 *) *FileHeader + FileOccupiedSize); + } + + FileOffset = (UINT32) ((UINT8 *) FfsFileHeader - (UINT8 *) FwVolHeader); + + while (FileOffset < (FvLength - sizeof (EFI_FFS_FILE_HEADER))) { + // + // Get FileState which is the highest bit of the State + // + FileState = GetFileState (ErasePolarity, FfsFileHeader); + + switch (FileState) { + + case EFI_FILE_HEADER_INVALID: + FileOffset += sizeof (EFI_FFS_FILE_HEADER); + FfsFileHeader = (EFI_FFS_FILE_HEADER *) ((UINT8 *) FfsFileHeader + sizeof (EFI_FFS_FILE_HEADER)); + break; + + case EFI_FILE_DATA_VALID: + case EFI_FILE_MARKED_FOR_UPDATE: + if (CalculateHeaderChecksum (FfsFileHeader) == 0) { + FileLength = *(UINT32 *) (FfsFileHeader->Size) & 0x00FFFFFF; + FileOccupiedSize = GET_OCCUPIED_SIZE (FileLength, 8); + + if ((SearchType == FfsFileHeader->Type) || (SearchType == EFI_FV_FILETYPE_ALL)) { + + *FileHeader = FfsFileHeader; + + return EFI_SUCCESS; + } + + FileOffset += FileOccupiedSize; + FfsFileHeader = (EFI_FFS_FILE_HEADER *) ((UINT8 *) FfsFileHeader + FileOccupiedSize); + } else { + return EFI_NOT_FOUND; + } + break; + + case EFI_FILE_DELETED: + FileLength = *(UINT32 *) (FfsFileHeader->Size) & 0x00FFFFFF; + FileOccupiedSize = GET_OCCUPIED_SIZE (FileLength, 8); + FileOffset += FileOccupiedSize; + FfsFileHeader = (EFI_FFS_FILE_HEADER *) ((UINT8 *) FfsFileHeader + FileOccupiedSize); + break; + + default: + return EFI_NOT_FOUND; + + } + } + + return EFI_NOT_FOUND; +} + +EFI_STATUS +SecFfsFindSectionData ( + IN EFI_SECTION_TYPE SectionType, + IN EFI_FFS_FILE_HEADER *FfsFileHeader, + IN OUT VOID **SectionData + ) +/*++ + +Routine Description: + Given the input file pointer, search for the next matching section in the + FFS volume. + +Arguments: + SearchType - Filter to find only sections of this type. + FfsFileHeader - Pointer to the current file to search. + SectionData - Pointer to the Section matching SectionType in FfsFileHeader. + NULL if section not found + +Returns: + EFI_NOT_FOUND - No files matching the search criteria were found + EFI_SUCCESS + +--*/ +{ + UINT32 FileSize; + EFI_COMMON_SECTION_HEADER *Section; + UINT32 SectionLength; + UINT32 ParsedLength; + + // + // Size is 24 bits wide so mask upper 8 bits. + // Does not include FfsFileHeader header size + // FileSize is adjusted to FileOccupiedSize as it is 8 byte aligned. + // + Section = (EFI_COMMON_SECTION_HEADER *) (FfsFileHeader + 1); + FileSize = *(UINT32 *) (FfsFileHeader->Size) & 0x00FFFFFF; + FileSize -= sizeof (EFI_FFS_FILE_HEADER); + + *SectionData = NULL; + ParsedLength = 0; + while (ParsedLength < FileSize) { + if (Section->Type == SectionType) { + *SectionData = (VOID *) (Section + 1); + return EFI_SUCCESS; + } + // + // Size is 24 bits wide so mask upper 8 bits. + // SectionLength is adjusted it is 4 byte aligned. + // Go to the next section + // + SectionLength = *(UINT32 *) Section->Size & 0x00FFFFFF; + SectionLength = GET_OCCUPIED_SIZE (SectionLength, 4); + + ParsedLength += SectionLength; + Section = (EFI_COMMON_SECTION_HEADER *) ((UINT8 *) Section + SectionLength); + } + + return EFI_NOT_FOUND; +} + +EFI_STATUS +SecFfsFindPeiCore ( + IN EFI_FIRMWARE_VOLUME_HEADER *FwVolHeader, + OUT VOID **Pe32Data + ) +/*++ + +Routine Description: + Given the pointer to the Firmware Volume Header find the SEC + core and return it's PE32 image. + +Arguments: + FwVolHeader - Pointer to memory mapped FV + Pe32Data - Pointer to SEC PE32 iamge. + +Returns: + EFI_SUCCESS - Pe32Data is valid + other - Failure + +--*/ +{ + EFI_STATUS Status; + EFI_FFS_FILE_HEADER *FileHeader; + EFI_FV_FILETYPE SearchType; + + SearchType = EFI_FV_FILETYPE_PEI_CORE; + FileHeader = NULL; + do { + Status = SecFfsFindNextFile (SearchType, FwVolHeader, &FileHeader); + if (!EFI_ERROR (Status)) { + Status = SecFfsFindSectionData (EFI_SECTION_PE32, FileHeader, Pe32Data); + return Status; + } + } while (!EFI_ERROR (Status)); + + return Status; +} diff --git a/UnixPkg/Sec/SecMain.c b/UnixPkg/Sec/SecMain.c new file mode 100644 index 0000000000..a6da20b135 --- /dev/null +++ b/UnixPkg/Sec/SecMain.c @@ -0,0 +1,1048 @@ +/*++ + +Copyright (c) 2006 - 2007 Intel Corporation. +All rights reserved. This program and the accompanying materials +are licensed and made available under the terms and conditions of the BSD License +which accompanies this distribution. The full text of the license may be found at +http://opensource.org/licenses/bsd-license.php + +THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS, +WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED. + +Module Name: + + SecMain.c + +Abstract: + WinNt emulator of SEC phase. It's really a Posix application, but this is + Ok since all the other modules for NT32 are NOT Posix applications. + + This program processes host environment variables and figures out + what the memory layout will be, how may FD's will be loaded and also + what the boot mode is. + + The SEC registers a set of services with the SEC core. gPrivateDispatchTable + is a list of PPI's produced by the SEC that are availble for usage in PEI. + + This code produces 128 K of temporary memory for the PEI stack by opening a + host file and mapping it directly to memory addresses. + + The system.cmd script is used to set host environment variables that drive + the configuration opitons of the SEC. + +--*/ + +#include "SecMain.h" +#include +#include +#include +#include +#include +// +// Globals +// +EFI_PEI_PE_COFF_LOADER_PROTOCOL_INSTANCE mPeiEfiPeiPeCoffLoaderInstance = { + { + SecNt32PeCoffGetImageInfo, + SecNt32PeCoffLoadImage, + SecNt32PeCoffRelocateImage, + SecNt32PeCoffUnloadimage + }, + NULL +}; + + + +EFI_PEI_PE_COFF_LOADER_PROTOCOL *gPeiEfiPeiPeCoffLoader = &mPeiEfiPeiPeCoffLoaderInstance.PeCoff; + +UNIX_PEI_LOAD_FILE_PPI mSecNtLoadFilePpi = { SecWinNtPeiLoadFile }; + +PEI_UNIX_AUTOSCAN_PPI mSecNtAutoScanPpi = { SecWinNtPeiAutoScan }; + +PEI_UNIX_THUNK_PPI mSecWinNtThunkPpi = { SecWinNtWinNtThunkAddress }; + +EFI_PEI_PROGRESS_CODE_PPI mSecStatusCodePpi = { SecPeiReportStatusCode }; + +UNIX_FWH_PPI mSecFwhInformationPpi = { SecWinNtFdAddress }; + +TEMPORARY_RAM_SUPPORT_PPI mSecTemporaryRamSupportPpi = {SecTemporaryRamSupport}; + +EFI_PEI_PPI_DESCRIPTOR gPrivateDispatchTable[] = { + { + EFI_PEI_PPI_DESCRIPTOR_PPI, + &gEfiPeiPeCoffLoaderGuid, + NULL + }, + { + EFI_PEI_PPI_DESCRIPTOR_PPI, + &gUnixPeiLoadFilePpiGuid, + &mSecNtLoadFilePpi + }, + { + EFI_PEI_PPI_DESCRIPTOR_PPI, + &gPeiUnixAutoScanPpiGuid, + &mSecNtAutoScanPpi + }, + { + EFI_PEI_PPI_DESCRIPTOR_PPI, + &gPeiUnixThunkPpiGuid, + &mSecWinNtThunkPpi + }, + { + EFI_PEI_PPI_DESCRIPTOR_PPI, + &gEfiPeiStatusCodePpiGuid, + &mSecStatusCodePpi + }, + { + EFI_PEI_PPI_DESCRIPTOR_PPI, + &gEfiTemporaryRamSupportPpiGuid, + &mSecTemporaryRamSupportPpi + }, + { + + EFI_PEI_PPI_DESCRIPTOR_PPI | EFI_PEI_PPI_DESCRIPTOR_TERMINATE_LIST, + &gUnixFwhPpiGuid, + &mSecFwhInformationPpi + } +}; + + +// +// Default information about where the FD is located. +// This array gets filled in with information from EFI_FIRMWARE_VOLUMES +// EFI_FIRMWARE_VOLUMES is a host environment variable set by system.cmd. +// The number of array elements is allocated base on parsing +// EFI_FIRMWARE_VOLUMES and the memory is never freed. +// +UINTN gFdInfoCount = 0; +UNIX_FD_INFO *gFdInfo; + +// +// Array that supports seperate memory rantes. +// The memory ranges are set in system.cmd via the EFI_MEMORY_SIZE variable. +// The number of array elements is allocated base on parsing +// EFI_MEMORY_SIZE and the memory is never freed. +// +UINTN gSystemMemoryCount = 0; +UNIX_SYSTEM_MEMORY *gSystemMemory; + +VOID +EFIAPI +SecSwitchStack ( + UINT32 TemporaryMemoryBase, + UINT32 PermenentMemoryBase + ); + +STATIC +EFI_PHYSICAL_ADDRESS * +MapMemory ( + INTN fd, + UINT64 length, + INTN prot, + INTN flags); + +STATIC +EFI_STATUS +MapFile ( + IN CHAR8 *FileName, + IN OUT EFI_PHYSICAL_ADDRESS *BaseAddress, + OUT UINT64 *Length + ); + + +INTN +EFIAPI +main ( + IN INTN Argc, + IN CHAR8 **Argv, + IN CHAR8 **Envp + ) +/*++ + +Routine Description: + Main entry point to SEC for WinNt. This is a unix program + +Arguments: + Argc - Number of command line arguments + Argv - Array of command line argument strings + Envp - Array of environmemt variable strings + +Returns: + 0 - Normal exit + 1 - Abnormal exit + +--*/ +{ + EFI_STATUS Status; + EFI_PHYSICAL_ADDRESS InitialStackMemory; + UINT64 InitialStackMemorySize; + UINTN Index; + UINTN Index1; + UINTN Index2; + UINTN PeiIndex; + CHAR8 *FileName; + BOOLEAN Done; + VOID *PeiCoreFile; + CHAR16 *MemorySizeStr; + CHAR16 *FirmwareVolumesStr; + UINTN *StackPointer; + + setbuf(stdout, 0); + setbuf(stderr, 0); + + MemorySizeStr = (CHAR16 *) FixedPcdGetPtr (PcdUnixMemorySizeForSecMain); + FirmwareVolumesStr = (CHAR16 *) FixedPcdGetPtr (PcdUnixFirmwareVolume); + + printf ("\nEDK SEC Main UNIX Emulation Environment from www.TianoCore.org\n"); + + // + // Allocate space for gSystemMemory Array + // + gSystemMemoryCount = CountSeperatorsInString (MemorySizeStr, '!') + 1; + gSystemMemory = calloc (gSystemMemoryCount, sizeof (UNIX_SYSTEM_MEMORY)); + if (gSystemMemory == NULL) { + printf ("ERROR : Can not allocate memory for system. Exiting.\n"); + exit (1); + } + // + // Allocate space for gSystemMemory Array + // + gFdInfoCount = CountSeperatorsInString (FirmwareVolumesStr, '!') + 1; + gFdInfo = calloc (gFdInfoCount, sizeof (UNIX_FD_INFO)); + if (gFdInfo == NULL) { + printf ("ERROR : Can not allocate memory for fd info. Exiting.\n"); + exit (1); + } + // + // Setup Boot Mode. If BootModeStr == "" then BootMode = 0 (BOOT_WITH_FULL_CONFIGURATION) + // + printf (" BootMode 0x%02x\n", FixedPcdGet32 (PcdUnixBootMode)); + + // + // Open up a 128K file to emulate temp memory for PEI. + // on a real platform this would be SRAM, or using the cache as RAM. + // Set InitialStackMemory to zero so WinNtOpenFile will allocate a new mapping + // + InitialStackMemorySize = STACK_SIZE; + InitialStackMemory = (UINTN)MapMemory(0, + (UINT32) InitialStackMemorySize, + PROT_READ | PROT_WRITE, + MAP_ANONYMOUS | MAP_PRIVATE); + if (InitialStackMemory == 0) { + printf ("ERROR : Can not open SecStack Exiting\n"); + exit (1); + } + + printf (" SEC passing in %u KB of temp RAM at 0x%08lx to PEI\n", + (UINTN)(InitialStackMemorySize / 1024), + (unsigned long)InitialStackMemory); + + for (StackPointer = (UINTN*) (UINTN) InitialStackMemory; + StackPointer < (UINTN*) ((UINTN) InitialStackMemory + (UINT64) InitialStackMemorySize); + StackPointer ++) { + *StackPointer = 0x5AA55AA5; + } + + // + // Open All the firmware volumes and remember the info in the gFdInfo global + // + FileName = (CHAR8 *)malloc (StrLen (FirmwareVolumesStr) + 1); + if (FileName == NULL) { + printf ("ERROR : Can not allocate memory for firmware volume string\n"); + exit (1); + } + + Index2 = 0; + for (Done = FALSE, Index = 0, PeiIndex = 0, PeiCoreFile = NULL; + FirmwareVolumesStr[Index2] != 0; + Index++) { + for (Index1 = 0; (FirmwareVolumesStr[Index2] != '!') && (FirmwareVolumesStr[Index2] != 0); Index2++) + FileName[Index1++] = FirmwareVolumesStr[Index2]; + if (FirmwareVolumesStr[Index2] == '!') + Index2++; + FileName[Index1] = '\0'; + + // + // Open the FD and remmeber where it got mapped into our processes address space + // + Status = MapFile ( + FileName, + &gFdInfo[Index].Address, + &gFdInfo[Index].Size + ); + if (EFI_ERROR (Status)) { + printf ("ERROR : Can not open Firmware Device File %s (%x). Exiting.\n", FileName, Status); + exit (1); + } + + printf (" FD loaded from %s at 0x%08lx", + FileName, (unsigned long)gFdInfo[Index].Address); + + if (PeiCoreFile == NULL) { + // + // Assume the beginning of the FD is an FV and look for the PEI Core. + // Load the first one we find. + // + Status = SecFfsFindPeiCore ((EFI_FIRMWARE_VOLUME_HEADER *) (UINTN) gFdInfo[Index].Address, &PeiCoreFile); + if (!EFI_ERROR (Status)) { + PeiIndex = Index; + printf (" contains SEC Core"); + } + } + + printf ("\n"); + } + // + // Calculate memory regions and store the information in the gSystemMemory + // global for later use. The autosizing code will use this data to + // map this memory into the SEC process memory space. + // + Index1 = 0; + Index = 0; + while (1) { + UINTN val = 0; + // + // Save the size of the memory. + // + while (MemorySizeStr[Index1] >= '0' && MemorySizeStr[Index1] <= '9') { + val = val * 10 + MemorySizeStr[Index1] - '0'; + Index1++; + } + gSystemMemory[Index++].Size = val * 0x100000; + if (MemorySizeStr[Index1] == 0) + break; + Index1++; + } + + printf ("\n"); + + // + // Hand off to PEI Core + // + SecLoadFromCore ((UINTN) InitialStackMemory, (UINTN) InitialStackMemorySize, (UINTN) gFdInfo[0].Address, PeiCoreFile); + + // + // If we get here, then the PEI Core returned. This is an error as PEI should + // always hand off to DXE. + // + printf ("ERROR : PEI Core returned\n"); + exit (1); +} + +EFI_PHYSICAL_ADDRESS * +MapMemory ( + INTN fd, + UINT64 length, + INTN prot, + INTN flags) +{ + STATIC UINTN base = 0x40000000; + CONST UINTN align = (1 << 24); + VOID *res = NULL; + BOOLEAN isAligned = 0; + + // + // Try to get an aligned block somewhere in the address space of this + // process. + // + while((!isAligned) && (base != 0)) { + res = mmap ((void *)base, length, prot, flags, fd, 0); + if (res == MAP_FAILED) { + return NULL; + } + if ((((UINTN)res) & ~(align-1)) == (UINTN)res) { + isAligned=1; + } + else { + munmap(res, length); + base += align; + } + } + return res; +} + +EFI_STATUS +MapFile ( + IN CHAR8 *FileName, + IN OUT EFI_PHYSICAL_ADDRESS *BaseAddress, + OUT UINT64 *Length + ) +/*++ + +Routine Description: + Opens and memory maps a file using WinNt services. If BaseAddress is non zero + the process will try and allocate the memory starting at BaseAddress. + +Arguments: + FileName - The name of the file to open and map + MapSize - The amount of the file to map in bytes + CreationDisposition - The flags to pass to CreateFile(). Use to create new files for + memory emulation, and exiting files for firmware volume emulation + BaseAddress - The base address of the mapped file in the user address space. + If passed in as NULL the a new memory region is used. + If passed in as non NULL the request memory region is used for + the mapping of the file into the process space. + Length - The size of the mapped region in bytes + +Returns: + EFI_SUCCESS - The file was opened and mapped. + EFI_NOT_FOUND - FileName was not found in the current directory + EFI_DEVICE_ERROR - An error occured attempting to map the opened file + +--*/ +{ + int fd; + VOID *res; + UINTN FileSize; + + fd = open (FileName, O_RDONLY); + if (fd < 0) + return EFI_NOT_FOUND; + FileSize = lseek (fd, 0, SEEK_END); + +#if 0 + if (IsMain) + { + /* Read entry address. */ + lseek (fd, FileSize - 0x20, SEEK_SET); + if (read (fd, &EntryAddress, 4) != 4) + { + close (fd); + return EFI_DEVICE_ERROR; + } + } +#endif + + res = MapMemory(fd, FileSize, PROT_READ | PROT_WRITE | PROT_EXEC, MAP_PRIVATE); + + close (fd); + + if (res == MAP_FAILED) + return EFI_DEVICE_ERROR; + + *Length = (UINT64) FileSize; + *BaseAddress = (EFI_PHYSICAL_ADDRESS) (UINTN) res; + + return EFI_SUCCESS; +} + +#define BYTES_PER_RECORD 512 + +EFI_STATUS +EFIAPI +SecPeiReportStatusCode ( + IN EFI_PEI_SERVICES **PeiServices, + IN EFI_STATUS_CODE_TYPE CodeType, + IN EFI_STATUS_CODE_VALUE Value, + IN UINT32 Instance, + IN EFI_GUID * CallerId, + IN EFI_STATUS_CODE_DATA * Data OPTIONAL + ) +/*++ + +Routine Description: + + This routine produces the ReportStatusCode PEI service. It's passed + up to the PEI Core via a PPI. T + + This code currently uses the UNIX clib printf. This does not work the same way + as the EFI Print (), as %t, %g, %s as Unicode are not supported. + +Arguments: + (see EFI_PEI_REPORT_STATUS_CODE) + +Returns: + EFI_SUCCESS - Always return success + +--*/ +// TODO: PeiServices - add argument and description to function comment +// TODO: CodeType - add argument and description to function comment +// TODO: Value - add argument and description to function comment +// TODO: Instance - add argument and description to function comment +// TODO: CallerId - add argument and description to function comment +// TODO: Data - add argument and description to function comment +{ + CHAR8 *Format; + VA_LIST Marker; + CHAR8 PrintBuffer[BYTES_PER_RECORD * 2]; + CHAR8 *Filename; + CHAR8 *Description; + UINT32 LineNumber; + UINT32 ErrorLevel; + + + if (Data == NULL) { + } else if (ReportStatusCodeExtractAssertInfo (CodeType, Value, Data, &Filename, &Description, &LineNumber)) { + // + // Processes ASSERT () + // + printf ("ASSERT %s(%d): %s\n", Filename, LineNumber, Description); + + } else if (ReportStatusCodeExtractDebugInfo (Data, &ErrorLevel, &Marker, &Format)) { + // + // Process DEBUG () macro + // + AsciiVSPrint (PrintBuffer, BYTES_PER_RECORD, Format, Marker); + printf (PrintBuffer); + } + + return EFI_SUCCESS; +} + +/** + Transfers control to a function starting with a new stack. + + Transfers control to the function specified by EntryPoint using the new stack + specified by NewStack and passing in the parameters specified by Context1 and + Context2. Context1 and Context2 are optional and may be NULL. The function + EntryPoint must never return. + + If EntryPoint is NULL, then ASSERT(). + If NewStack is NULL, then ASSERT(). + + @param EntryPoint A pointer to function to call with the new stack. + @param Context1 A pointer to the context to pass into the EntryPoint + function. + @param Context2 A pointer to the context to pass into the EntryPoint + function. + @param NewStack A pointer to the new stack to use for the EntryPoint + function. + @param NewBsp A pointer to the new BSP for the EntryPoint on IPF. It's + Reserved on other architectures. + +**/ +VOID +EFIAPI +PeiSwitchStacks ( + IN SWITCH_STACK_ENTRY_POINT EntryPoint, + IN VOID *Context1, OPTIONAL + IN VOID *Context2, OPTIONAL + IN VOID *Context3, OPTIONAL + IN VOID *NewStack + ) +{ + BASE_LIBRARY_JUMP_BUFFER JumpBuffer; + + ASSERT (EntryPoint != NULL); + ASSERT (NewStack != NULL); + + // + // Stack should be aligned with CPU_STACK_ALIGNMENT + // + ASSERT (((UINTN)NewStack & (CPU_STACK_ALIGNMENT - 1)) == 0); + + JumpBuffer.Eip = (UINTN)EntryPoint; + JumpBuffer.Esp = (UINTN)NewStack - sizeof (VOID*); + JumpBuffer.Esp -= sizeof (Context1) + sizeof (Context2) + sizeof(Context3); + ((VOID**)JumpBuffer.Esp)[1] = Context1; + ((VOID**)JumpBuffer.Esp)[2] = Context2; + ((VOID**)JumpBuffer.Esp)[3] = Context3; + + LongJump (&JumpBuffer, (UINTN)-1); + + + // + // InternalSwitchStack () will never return + // + ASSERT (FALSE); +} + +VOID +SecLoadFromCore ( + IN UINTN LargestRegion, + IN UINTN LargestRegionSize, + IN UINTN BootFirmwareVolumeBase, + IN VOID *PeiCorePe32File + ) +/*++ + +Routine Description: + This is the service to load the PEI Core from the Firmware Volume + +Arguments: + LargestRegion - Memory to use for PEI. + LargestRegionSize - Size of Memory to use for PEI + BootFirmwareVolumeBase - Start of the Boot FV + PeiCorePe32File - PEI Core PE32 + +Returns: + Success means control is transfered and thus we should never return + +--*/ +{ + EFI_STATUS Status; + EFI_PHYSICAL_ADDRESS TopOfMemory; + VOID *TopOfStack; + UINT64 PeiCoreSize; + EFI_PHYSICAL_ADDRESS PeiCoreEntryPoint; + EFI_PHYSICAL_ADDRESS PeiImageAddress; + EFI_SEC_PEI_HAND_OFF *SecCoreData; + UINTN PeiStackSize; + + // + // Compute Top Of Memory for Stack and PEI Core Allocations + // + TopOfMemory = LargestRegion + LargestRegionSize; + PeiStackSize = (UINTN)RShiftU64((UINT64)STACK_SIZE,1); + + // + // |-----------| <---- TemporaryRamBase + TemporaryRamSize + // | Heap | + // | | + // |-----------| <---- StackBase / PeiTemporaryMemoryBase + // | | + // | Stack | + // |-----------| <---- TemporaryRamBase + // + TopOfStack = (VOID *)(LargestRegion + PeiStackSize); + TopOfMemory = LargestRegion + PeiStackSize; + + // + // Reservet space for storing PeiCore's parament in stack. + // + TopOfStack = (VOID *)((UINTN)TopOfStack - sizeof (EFI_SEC_PEI_HAND_OFF) - CPU_STACK_ALIGNMENT); + TopOfStack = ALIGN_POINTER (TopOfStack, CPU_STACK_ALIGNMENT); + + // + // Patch value in dispatch table values + // + gPrivateDispatchTable[0].Ppi = gPeiEfiPeiPeCoffLoader; + + // + // Bind this information into the SEC hand-off state + // + SecCoreData = (EFI_SEC_PEI_HAND_OFF*)(UINTN) TopOfStack; + SecCoreData->DataSize = sizeof(EFI_SEC_PEI_HAND_OFF); + SecCoreData->BootFirmwareVolumeBase = (VOID*)BootFirmwareVolumeBase; + SecCoreData->BootFirmwareVolumeSize = FixedPcdGet32(PcdUnixFirmwareFdSize); + SecCoreData->TemporaryRamBase = (VOID*)(UINTN)LargestRegion; + SecCoreData->TemporaryRamSize = STACK_SIZE; + SecCoreData->StackBase = SecCoreData->TemporaryRamBase; + SecCoreData->StackSize = PeiStackSize; + SecCoreData->PeiTemporaryRamBase = (VOID*) ((UINTN) SecCoreData->TemporaryRamBase + PeiStackSize); + SecCoreData->PeiTemporaryRamSize = STACK_SIZE - PeiStackSize; + + // + // Load the PEI Core from a Firmware Volume + // + Status = SecWinNtPeiLoadFile ( + PeiCorePe32File, + &PeiImageAddress, + &PeiCoreSize, + &PeiCoreEntryPoint + ); + if (EFI_ERROR (Status)) { + return ; + } + + // + // Transfer control to the PEI Core + // + PeiSwitchStacks ( + (SWITCH_STACK_ENTRY_POINT) (UINTN) PeiCoreEntryPoint, + SecCoreData, + (VOID *) (UINTN) ((EFI_PEI_PPI_DESCRIPTOR *) &gPrivateDispatchTable), + NULL, + TopOfStack + ); + // + // If we get here, then the PEI Core returned. This is an error + // + return ; +} + +EFI_STATUS +EFIAPI +SecWinNtPeiAutoScan ( + IN UINTN Index, + OUT EFI_PHYSICAL_ADDRESS *MemoryBase, + OUT UINT64 *MemorySize + ) +/*++ + +Routine Description: + This service is called from Index == 0 until it returns EFI_UNSUPPORTED. + It allows discontiguous memory regions to be supported by the emulator. + It uses gSystemMemory[] and gSystemMemoryCount that were created by + parsing the host environment variable EFI_MEMORY_SIZE. + The size comes from the varaible and the address comes from the call to + WinNtOpenFile. + +Arguments: + Index - Which memory region to use + MemoryBase - Return Base address of memory region + MemorySize - Return size in bytes of the memory region + +Returns: + EFI_SUCCESS - If memory region was mapped + EFI_UNSUPPORTED - If Index is not supported + +--*/ +{ + void *res; + + if (Index >= gSystemMemoryCount) { + return EFI_UNSUPPORTED; + } + + *MemoryBase = 0; + res = MapMemory(0, gSystemMemory[Index].Size, + PROT_READ | PROT_WRITE | PROT_EXEC, + MAP_PRIVATE | MAP_ANONYMOUS); + if (res == MAP_FAILED) + return EFI_DEVICE_ERROR; + *MemorySize = gSystemMemory[Index].Size; + *MemoryBase = (UINTN)res; + gSystemMemory[Index].Memory = *MemoryBase; + + return EFI_SUCCESS; +} + +VOID * +EFIAPI +SecWinNtWinNtThunkAddress ( + VOID + ) +/*++ + +Routine Description: + Since the SEC is the only Unix program in stack it must export + an interface to do Win API calls. That's what the WinNtThunk address + is for. gWinNt is initailized in WinNtThunk.c. + +Arguments: + InterfaceSize - sizeof (EFI_WIN_NT_THUNK_PROTOCOL); + InterfaceBase - Address of the gWinNt global + +Returns: + EFI_SUCCESS - Data returned + +--*/ +{ + return gUnix; +} + + +EFI_STATUS +EFIAPI +SecWinNtPeiLoadFile ( + IN VOID *Pe32Data, + IN EFI_PHYSICAL_ADDRESS *ImageAddress, + IN UINT64 *ImageSize, + IN EFI_PHYSICAL_ADDRESS *EntryPoint + ) +/*++ + +Routine Description: + Loads and relocates a PE/COFF image into memory. + +Arguments: + Pe32Data - The base address of the PE/COFF file that is to be loaded and relocated + ImageAddress - The base address of the relocated PE/COFF image + ImageSize - The size of the relocated PE/COFF image + EntryPoint - The entry point of the relocated PE/COFF image + +Returns: + EFI_SUCCESS - The file was loaded and relocated + EFI_OUT_OF_RESOURCES - There was not enough memory to load and relocate the PE/COFF file + +--*/ +{ + EFI_STATUS Status; + PE_COFF_LOADER_IMAGE_CONTEXT ImageContext; + + ZeroMem (&ImageContext, sizeof (ImageContext)); + ImageContext.Handle = Pe32Data; + + ImageContext.ImageRead = (PE_COFF_LOADER_READ_FILE) SecImageRead; + + Status = gPeiEfiPeiPeCoffLoader->GetImageInfo (gPeiEfiPeiPeCoffLoader, &ImageContext); + if (EFI_ERROR (Status)) { + return Status; + } + // + // Allocate space in UNIX (not emulator) memory. Extra space is for alignment + // + ImageContext.ImageAddress = (EFI_PHYSICAL_ADDRESS) (UINTN) malloc ((UINTN) (ImageContext.ImageSize + (ImageContext.SectionAlignment * 2))); + if (ImageContext.ImageAddress == 0) { + return EFI_OUT_OF_RESOURCES; + } + // + // Align buffer on section boundry + // + ImageContext.ImageAddress += ImageContext.SectionAlignment; + ImageContext.ImageAddress &= ~(ImageContext.SectionAlignment - 1); + + + Status = gPeiEfiPeiPeCoffLoader->LoadImage (gPeiEfiPeiPeCoffLoader, &ImageContext); + if (EFI_ERROR (Status)) { + return Status; + } + + Status = gPeiEfiPeiPeCoffLoader->RelocateImage (gPeiEfiPeiPeCoffLoader, &ImageContext); + if (EFI_ERROR (Status)) { + return Status; + } + + // + // BugBug: Flush Instruction Cache Here when CPU Lib is ready + // + + *ImageAddress = ImageContext.ImageAddress; + *ImageSize = ImageContext.ImageSize; + *EntryPoint = ImageContext.EntryPoint; + + return EFI_SUCCESS; +} + +EFI_STATUS +EFIAPI +SecWinNtFdAddress ( + IN UINTN Index, + IN OUT EFI_PHYSICAL_ADDRESS *FdBase, + IN OUT UINT64 *FdSize + ) +/*++ + +Routine Description: + Return the FD Size and base address. Since the FD is loaded from a + file into host memory only the SEC will know it's address. + +Arguments: + Index - Which FD, starts at zero. + FdSize - Size of the FD in bytes + FdBase - Start address of the FD. Assume it points to an FV Header + +Returns: + EFI_SUCCESS - Return the Base address and size of the FV + EFI_UNSUPPORTED - Index does nto map to an FD in the system + +--*/ +{ + if (Index >= gFdInfoCount) { + return EFI_UNSUPPORTED; + } + + *FdBase = gFdInfo[Index].Address; + *FdSize = gFdInfo[Index].Size; + + if (*FdBase == 0 && *FdSize == 0) { + return EFI_UNSUPPORTED; + } + + return EFI_SUCCESS; +} + +EFI_STATUS +EFIAPI +SecImageRead ( + IN VOID *FileHandle, + IN UINTN FileOffset, + IN OUT UINTN *ReadSize, + OUT VOID *Buffer + ) +/*++ + +Routine Description: + Support routine for the PE/COFF Loader that reads a buffer from a PE/COFF file + +Arguments: + FileHandle - The handle to the PE/COFF file + FileOffset - The offset, in bytes, into the file to read + ReadSize - The number of bytes to read from the file starting at FileOffset + Buffer - A pointer to the buffer to read the data into. + +Returns: + EFI_SUCCESS - ReadSize bytes of data were read into Buffer from the PE/COFF file starting at FileOffset + +--*/ +{ + CHAR8 *Destination8; + CHAR8 *Source8; + UINTN Length; + + Destination8 = Buffer; + Source8 = (CHAR8 *) ((UINTN) FileHandle + FileOffset); + Length = *ReadSize; + while (Length--) { + *(Destination8++) = *(Source8++); + } + + return EFI_SUCCESS; +} + +UINTN +CountSeperatorsInString ( + IN const CHAR16 *String, + IN CHAR16 Seperator + ) +/*++ + +Routine Description: + Count the number of seperators in String + +Arguments: + String - String to process + Seperator - Item to count + +Returns: + Number of Seperator in String + +--*/ +{ + UINTN Count; + + for (Count = 0; *String != '\0'; String++) { + if (*String == Seperator) { + Count++; + } + } + + return Count; +} + + + +EFI_STATUS +EFIAPI +SecNt32PeCoffGetImageInfo ( + IN EFI_PEI_PE_COFF_LOADER_PROTOCOL *This, + IN OUT PE_COFF_LOADER_IMAGE_CONTEXT *ImageContext + ) +{ + EFI_STATUS Status; + + Status = PeCoffLoaderGetImageInfo (ImageContext); + if (EFI_ERROR (Status)) { + return Status; + } + + switch (ImageContext->ImageType) { + + case EFI_IMAGE_SUBSYSTEM_EFI_APPLICATION: + ImageContext->ImageCodeMemoryType = EfiLoaderCode; + ImageContext->ImageDataMemoryType = EfiLoaderData; + break; + + case EFI_IMAGE_SUBSYSTEM_EFI_BOOT_SERVICE_DRIVER: + ImageContext->ImageCodeMemoryType = EfiBootServicesCode; + ImageContext->ImageDataMemoryType = EfiBootServicesData; + break; + + case EFI_IMAGE_SUBSYSTEM_EFI_RUNTIME_DRIVER: + case EFI_IMAGE_SUBSYSTEM_SAL_RUNTIME_DRIVER: + ImageContext->ImageCodeMemoryType = EfiRuntimeServicesCode; + ImageContext->ImageDataMemoryType = EfiRuntimeServicesData; + break; + + default: + ImageContext->ImageError = IMAGE_ERROR_INVALID_SUBSYSTEM; + return RETURN_UNSUPPORTED; + } + + return Status; +} + +EFI_STATUS +EFIAPI +SecNt32PeCoffLoadImage ( + IN EFI_PEI_PE_COFF_LOADER_PROTOCOL *This, + IN OUT PE_COFF_LOADER_IMAGE_CONTEXT *ImageContext + ) +{ + EFI_STATUS Status; + + Status = PeCoffLoaderLoadImage (ImageContext); + return Status; +} + +VOID +SecUnixLoaderBreak ( + VOID + ) +{ +} + +EFI_STATUS +EFIAPI +SecNt32PeCoffRelocateImage ( + IN EFI_PEI_PE_COFF_LOADER_PROTOCOL *This, + IN OUT PE_COFF_LOADER_IMAGE_CONTEXT *ImageContext + ) +{ + void * Handle; + void * Entry; + EFI_STATUS Status; + + Handle = NULL; + Entry = NULL; + Status = PeCoffLoaderRelocateImage (ImageContext); + fprintf (stderr, + "Loading %s 0x%08lx - entry point 0x%08lx\n", + ImageContext->PdbPointer, + (unsigned long)ImageContext->ImageAddress, + (unsigned long)ImageContext->EntryPoint); + + SecUnixLoaderBreak (); + + return Status; +} + + +EFI_STATUS +EFIAPI +SecNt32PeCoffUnloadimage ( + IN EFI_PEI_PE_COFF_LOADER_PROTOCOL *This, + IN PE_COFF_LOADER_IMAGE_CONTEXT *ImageContext + ) +{ + return EFI_SUCCESS; +} + +VOID +ModuleEntryPoint ( + VOID + ) +{ +} + +EFI_STATUS +EFIAPI +SecTemporaryRamSupport ( + IN CONST EFI_PEI_SERVICES **PeiServices, + IN EFI_PHYSICAL_ADDRESS TemporaryMemoryBase, + IN EFI_PHYSICAL_ADDRESS PermanentMemoryBase, + IN UINTN CopySize + ) +{ + // + // Migrate the whole temporary memory to permenent memory. + // + CopyMem ( + (VOID*)(UINTN)PermanentMemoryBase, + (VOID*)(UINTN)TemporaryMemoryBase, + CopySize + ); + + // + // SecSwitchStack function must be invoked after the memory migration + // immediatly, also we need fixup the stack change caused by new call into + // permenent memory. + // + SecSwitchStack ( + (UINT32) TemporaryMemoryBase, + (UINT32) PermanentMemoryBase + ); + + // + // We need *not* fix the return address because currently, + // The PeiCore is excuted in flash. + // + + // + // Simulate to invalid CAR, terminate CAR + // + //ZeroMem ((VOID*)(UINTN)TemporaryMemoryBase, CopySize); + + return EFI_SUCCESS; +} diff --git a/UnixPkg/Sec/SecMain.h b/UnixPkg/Sec/SecMain.h new file mode 100644 index 0000000000..9714b5a4b9 --- /dev/null +++ b/UnixPkg/Sec/SecMain.h @@ -0,0 +1,548 @@ +/*++ + +Copyright (c) 2006 - 2008, Intel Corporation +All rights reserved. This program and the accompanying materials +are licensed and made available under the terms and conditions of the BSD License +which accompanies this distribution. The full text of the license may be found at +http://opensource.org/licenses/bsd-license.php + +THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS, +WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED. + + +Module Name: + SecMain.h + +Abstract: + Include file for host API based SEC + +--*/ +#include "PiPei.h" +#include "Uefi/UefiSpec.h" + +#include +#include +#include +#include + +#include +#include +#include +#include +#include +#include + +#define STACK_SIZE 0x20000 + +typedef struct { + EFI_PHYSICAL_ADDRESS Address; + UINT64 Size; +} UNIX_FD_INFO; + +typedef struct { + EFI_PHYSICAL_ADDRESS Memory; + UINT64 Size; +} UNIX_SYSTEM_MEMORY; + + + +EFI_STATUS +EFIAPI +SecWinNtPeiLoadFile ( + VOID *Pe32Data, // TODO: add IN/OUT modifier to Pe32Data + EFI_PHYSICAL_ADDRESS *ImageAddress, // TODO: add IN/OUT modifier to ImageAddress + UINT64 *ImageSize, // TODO: add IN/OUT modifier to ImageSize + EFI_PHYSICAL_ADDRESS *EntryPoint // TODO: add IN/OUT modifier to EntryPoint + ) +/*++ + +Routine Description: + + TODO: Add function description + +Arguments: + + Pe32Data - TODO: add argument description + ImageAddress - TODO: add argument description + ImageSize - TODO: add argument description + EntryPoint - TODO: add argument description + +Returns: + + TODO: add return values + +--*/ +; + +EFI_STATUS +EFIAPI +SecWinNtPeiAutoScan ( + IN UINTN Index, + OUT EFI_PHYSICAL_ADDRESS *MemoryBase, + OUT UINT64 *MemorySize + ) +/*++ + +Routine Description: + + TODO: Add function description + +Arguments: + + Index - TODO: add argument description + MemoryBase - TODO: add argument description + MemorySize - TODO: add argument description + +Returns: + + TODO: add return values + +--*/ +; + +VOID * +EFIAPI +SecWinNtWinNtThunkAddress ( + VOID + ) +/*++ + +Routine Description: + + TODO: Add function description + +Arguments: + + InterfaceSize - TODO: add argument description + InterfaceBase - TODO: add argument description + +Returns: + + TODO: add return values + +--*/ +; + +EFI_STATUS +EFIAPI +SecWinNtWinNtFwhAddress ( + IN OUT UINT64 *FwhSize, + IN OUT EFI_PHYSICAL_ADDRESS *FwhBase + ) +/*++ + +Routine Description: + + TODO: Add function description + +Arguments: + + FwhSize - TODO: add argument description + FwhBase - TODO: add argument description + +Returns: + + TODO: add return values + +--*/ +; + +EFI_STATUS +EFIAPI +SecPeiReportStatusCode ( + IN EFI_PEI_SERVICES **PeiServices, + IN EFI_STATUS_CODE_TYPE CodeType, + IN EFI_STATUS_CODE_VALUE Value, + IN UINT32 Instance, + IN EFI_GUID * CallerId, + IN EFI_STATUS_CODE_DATA * Data OPTIONAL + ) +/*++ + +Routine Description: + + TODO: Add function description + +Arguments: + + PeiServices - TODO: add argument description + CodeType - TODO: add argument description + Value - TODO: add argument description + Instance - TODO: add argument description + CallerId - TODO: add argument description + Data - TODO: add argument description + +Returns: + + TODO: add return values + +--*/ +; + +INTN +EFIAPI +main ( + IN INTN Argc, + IN CHAR8 **Argv, + IN CHAR8 **Envp + ) +/*++ + +Routine Description: + + TODO: Add function description + +Arguments: + + Argc - TODO: add argument description + Argv - TODO: add argument description + Envp - TODO: add argument description + +Returns: + + TODO: add return values + +--*/ +; + +VOID +SecLoadFromCore ( + IN UINTN LargestRegion, + IN UINTN LargestRegionSize, + IN UINTN BootFirmwareVolumeBase, + IN VOID *PeiCoreFile + ) +/*++ + +Routine Description: + + TODO: Add function description + +Arguments: + + LargestRegion - TODO: add argument description + LargestRegionSize - TODO: add argument description + BootFirmwareVolumeBase - TODO: add argument description + PeiCoreFile - TODO: add argument description + +Returns: + + TODO: add return values + +--*/ +; + +EFI_STATUS +SecLoadFile ( + IN VOID *Pe32Data, + IN EFI_PHYSICAL_ADDRESS *ImageAddress, + IN UINT64 *ImageSize, + IN EFI_PHYSICAL_ADDRESS *EntryPoint + ) +/*++ + +Routine Description: + + TODO: Add function description + +Arguments: + + Pe32Data - TODO: add argument description + ImageAddress - TODO: add argument description + ImageSize - TODO: add argument description + EntryPoint - TODO: add argument description + +Returns: + + TODO: add return values + +--*/ +; + +EFI_STATUS +SecFfsFindPeiCore ( + IN EFI_FIRMWARE_VOLUME_HEADER *FwVolHeader, + OUT VOID **Pe32Data + ) +/*++ + +Routine Description: + + TODO: Add function description + +Arguments: + + FwVolHeader - TODO: add argument description + Pe32Data - TODO: add argument description + +Returns: + + TODO: add return values + +--*/ +; + +EFI_STATUS +SecFfsFindNextFile ( + IN EFI_FV_FILETYPE SearchType, + IN EFI_FIRMWARE_VOLUME_HEADER *FwVolHeader, + IN OUT EFI_FFS_FILE_HEADER **FileHeader + ) +/*++ + +Routine Description: + + TODO: Add function description + +Arguments: + + SearchType - TODO: add argument description + FwVolHeader - TODO: add argument description + FileHeader - TODO: add argument description + +Returns: + + TODO: add return values + +--*/ +; + +EFI_STATUS +SecFfsFindSectionData ( + IN EFI_SECTION_TYPE SectionType, + IN EFI_FFS_FILE_HEADER *FfsFileHeader, + IN OUT VOID **SectionData + ) +/*++ + +Routine Description: + + TODO: Add function description + +Arguments: + + SectionType - TODO: add argument description + FfsFileHeader - TODO: add argument description + SectionData - TODO: add argument description + +Returns: + + TODO: add return values + +--*/ +; + +EFI_STATUS +EFIAPI +SecWinNtPeCoffLoaderLoadAsDll ( + IN CHAR8 *PdbFileName, + IN VOID **ImageEntryPoint, + OUT VOID **ModHandle + ) +/*++ + +Routine Description: + + TODO: Add function description + +Arguments: + + PdbFileName - TODO: add argument description + ImageEntryPoint - TODO: add argument description + ModHandle - TODO: add argument description + +Returns: + + TODO: add return values + +--*/ +; + +EFI_STATUS +EFIAPI +SecWinNtPeCoffLoaderFreeLibrary ( + OUT VOID *ModHandle + ) +/*++ + +Routine Description: + + TODO: Add function description + +Arguments: + + ModHandle - TODO: add argument description + +Returns: + + TODO: add return values + +--*/ +; + +EFI_STATUS +EFIAPI +SecWinNtFdAddress ( + IN UINTN Index, + IN OUT EFI_PHYSICAL_ADDRESS *FdBase, + IN OUT UINT64 *FdSize + ) +/*++ + +Routine Description: + + TODO: Add function description + +Arguments: + + Index - TODO: add argument description + FdBase - TODO: add argument description + FdSize - TODO: add argument description + +Returns: + + TODO: add return values + +--*/ +; + +EFI_STATUS +GetImageReadFunction ( + IN PE_COFF_LOADER_IMAGE_CONTEXT *ImageContext, + IN EFI_PHYSICAL_ADDRESS *TopOfMemory + ) +/*++ + +Routine Description: + + TODO: Add function description + +Arguments: + + ImageContext - TODO: add argument description + TopOfMemory - TODO: add argument description + +Returns: + + TODO: add return values + +--*/ +; + +EFI_STATUS +EFIAPI +SecImageRead ( + IN VOID *FileHandle, + IN UINTN FileOffset, + IN OUT UINTN *ReadSize, + OUT VOID *Buffer + ) +/*++ + +Routine Description: + + TODO: Add function description + +Arguments: + + FileHandle - TODO: add argument description + FileOffset - TODO: add argument description + ReadSize - TODO: add argument description + Buffer - TODO: add argument description + +Returns: + + TODO: add return values + +--*/ +; + +CHAR16 * +AsciiToUnicode ( + IN CHAR8 *Ascii, + IN UINTN *StrLen OPTIONAL + ) +/*++ + +Routine Description: + + TODO: Add function description + +Arguments: + + Ascii - TODO: add argument description + StrLen - TODO: add argument description + +Returns: + + TODO: add return values + +--*/ +; + +UINTN +CountSeperatorsInString ( + IN const CHAR16 *String, + IN CHAR16 Seperator + ) +/*++ + +Routine Description: + + TODO: Add function description + +Arguments: + + String - TODO: add argument description + Seperator - TODO: add argument description + +Returns: + + TODO: add return values + +--*/ +; + +EFI_STATUS +EFIAPI +SecNt32PeCoffGetImageInfo ( + IN EFI_PEI_PE_COFF_LOADER_PROTOCOL *This, + IN OUT PE_COFF_LOADER_IMAGE_CONTEXT *ImageContext + ); + +EFI_STATUS +EFIAPI +SecNt32PeCoffLoadImage ( + IN EFI_PEI_PE_COFF_LOADER_PROTOCOL *This, + IN OUT PE_COFF_LOADER_IMAGE_CONTEXT *ImageContext + ); + +EFI_STATUS +EFIAPI +SecNt32PeCoffRelocateImage ( + IN EFI_PEI_PE_COFF_LOADER_PROTOCOL *This, + IN OUT PE_COFF_LOADER_IMAGE_CONTEXT *ImageContext + ); + +EFI_STATUS +EFIAPI +SecNt32PeCoffUnloadimage ( + IN EFI_PEI_PE_COFF_LOADER_PROTOCOL *This, + IN PE_COFF_LOADER_IMAGE_CONTEXT *ImageContext + ); + +EFI_STATUS +EFIAPI +SecTemporaryRamSupport ( + IN CONST EFI_PEI_SERVICES **PeiServices, + IN EFI_PHYSICAL_ADDRESS TemporaryMemoryBase, + IN EFI_PHYSICAL_ADDRESS PermanentMemoryBase, + IN UINTN CopySize + ); + +typedef struct { + EFI_PEI_PE_COFF_LOADER_PROTOCOL PeCoff; + VOID *ModHandle; +} EFI_PEI_PE_COFF_LOADER_PROTOCOL_INSTANCE; + +extern EFI_UNIX_THUNK_PROTOCOL *gUnix; diff --git a/UnixPkg/Sec/SecMain.inf b/UnixPkg/Sec/SecMain.inf new file mode 100644 index 0000000000..37152b08e7 --- /dev/null +++ b/UnixPkg/Sec/SecMain.inf @@ -0,0 +1,76 @@ +#/** @file +# Entry Point of Unix Emulator +# +# Main executable file of Unix Emulator that loads PEI core after initialization finished. +# Copyright (c) 2008, Intel Corporation +# +# All rights reserved. This program and the accompanying materials +# are licensed and made available under the terms and conditions of the BSD License +# which accompanies this distribution. The full text of the license may be found at +# http://opensource.org/licenses/bsd-license.php +# THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS, +# WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED. +# +# +#**/ + +[Defines] + INF_VERSION = 0x00010005 + BASE_NAME = SecMain + FILE_GUID = f43be88c-8985-11db-8f78-0040d02b1835 + MODULE_TYPE = SEC + VERSION_STRING = 1.0 + EDK_RELEASE_VERSION = 0x00020000 + EFI_SPECIFICATION_VERSION = 0x00020000 + ENTRY_POINT = main + +# +# The following information is for reference only and not required by the build tools. +# +# VALID_ARCHITECTURES = IA32 X64 IPF EBC +# + +[Sources.common] + UgaX11.c + UnixThunk.c + FwVol.c + SecMain.c + Stack.S + +[Packages] + MdePkg/MdePkg.dec + MdeModulePkg/MdeModulePkg.dec + IntelFrameworkPkg/IntelFrameworkPkg.dec + UnixPkg/UnixPkg.dec + +[LibraryClasses] + DebugLib + PcdLib + PrintLib + BaseMemoryLib + BaseLib + PeCoffLib + ReportStatusCodeLib + + +[Guids] + gEfiPeiPeCoffLoaderGuid # ALWAYS_PRODUCED + + +[Ppis] + gUnixPeiLoadFilePpiGuid # PPI ALWAYS_PRODUCED + gEfiPeiStatusCodePpiGuid # PPI ALWAYS_PRODUCED + gUnixFwhPpiGuid # PPI ALWAYS_PRODUCED + gPeiUnixAutoScanPpiGuid # PPI ALWAYS_PRODUCED + gPeiUnixThunkPpiGuid # PPI ALWAYS_PRODUCED + gEfiTemporaryRamSupportPpiGuid + + +[Pcd.common] + gEfiUnixPkgTokenSpaceGuid.PcdUnixBootMode + gEfiUnixPkgTokenSpaceGuid.PcdUnixFirmwareVolume + gEfiUnixPkgTokenSpaceGuid.PcdUnixMemorySizeForSecMain + gEfiUnixPkgTokenSpaceGuid.PcdUnixFirmwareFdSize + +[BuildOptions.common] + GCC:*_*_IA32_DLINK_FLAGS = diff --git a/UnixPkg/Sec/SecMain.msa b/UnixPkg/Sec/SecMain.msa new file mode 100644 index 0000000000..2629982571 --- /dev/null +++ b/UnixPkg/Sec/SecMain.msa @@ -0,0 +1,113 @@ + + + + SecMain + SEC + f43be88c-8985-11db-8f78-0040d02b1835 + 1.0 + Entry Point of Unix Emulator + Main executable file of Unix Emulator that loads PEI core after initialization finished. + Copyright (c) 2006, Intel Corporation + All rights reserved. This program and the accompanying materials + are licensed and made available under the terms and conditions of the BSD License + which accompanies this distribution. The full text of the license may be found at + http://opensource.org/licenses/bsd-license.php + THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS, + WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED. + FRAMEWORK_BUILD_PACKAGING_SPECIFICATION 0x00000052 + + + IA32 X64 IPF EBC + false + SecMain + + + + PeCoffLib + + + BaseLib + + + BaseMemoryLib + + + PrintLib + + + PcdLib + + + DebugLib + + + + SecMain_build.xml + SecMain.c + FwVol.c + UnixThunk.c + UgaX11.c + SecMain.h + + + + + + + + + gPeiUnixThunkPpiGuid + + + gPeiUnixAutoScanPpiGuid + + + gUnixFwhPpiGuid + + + gEfiPeiStatusCodePpiGuid + + + gUnixPeiLoadFilePpiGuid + + + + + gEfiPeiPeCoffLoaderGuid + + + + EFI_SPECIFICATION_VERSION 0x00020000 + EDK_RELEASE_VERSION 0x00020000 + + + + PcdUnixMemorySizeForSecMain + gEfiEdkUnixPkgTokenSpaceGuid + This PCD defines the memory size of simulated machine. Simulator will allocate + the size of PcdUnixMemorySizeForSecMain in host platform. + + + PcdUnixFirmwareVolume + gEfiEdkUnixPkgTokenSpaceGuid + This PCD defines the FD file windows path string. Simulator will load the FD file and execute. + + + PcdUnixBootMode + gEfiEdkUnixPkgTokenSpaceGuid + This PCD defines the boot mode for simualtor. + The boot mode can be set as following value: + 0x0: Boot with full configuration. + 0x1: Boot with minimal configuration. + 0x2: Boot assume no configuration changes. + 0x3: Boot with full configuration plus diagnostics. + 0x4: Boot with default settings. + 0x5: Boot on S4 resume. + 0x6: Boot on S5 resume. + 0x10: Boot on S2 resume. + 0x11: Boot on S3 resume. + 0x12: Boot on flash update. + 0x20: Boot in reovery mode. + + + diff --git a/UnixPkg/Sec/Stack.S b/UnixPkg/Sec/Stack.S new file mode 100644 index 0000000000..50f07b0894 --- /dev/null +++ b/UnixPkg/Sec/Stack.S @@ -0,0 +1,92 @@ +#------------------------------------------------------------------------------ +# +# Copyright (c) 2008, Intel Corporation +# All rights reserved. This program and the accompanying materials +# are licensed and made available under the terms and conditions of the BSD License +# which accompanies this distribution. The full text of the license may be found at +# http://opensource.org/licenses/bsd-license.php +# +# THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS, +# WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED. +# +# Module Name: +# +# Stack.asm +# +# Abstract: +# +# Switch the stack from temporary memory to permenent memory. +# +#------------------------------------------------------------------------------ + +#------------------------------------------------------------------------------ +# VOID +# EFIAPI +# SecSwitchStack ( +# UINT32 TemporaryMemoryBase, +# UINT32 PermenentMemoryBase +# ); +#------------------------------------------------------------------------------ + +#include + +.globl ASM_PFX(SecSwitchStack) +ASM_PFX(SecSwitchStack): +# +# Save three register: eax, ebx, ecx +# + push %eax + push %ebx + push %ecx + push %edx + +# +# !!CAUTION!! this function address's is pushed into stack after +# migration of whole temporary memory, so need save it to permenent +# memory at first! +# + + movl 20(%esp), %ebx # Save the first parameter + movl 24(%esp), %ecx # Save the second parameter + +# +# Save this function's return address into permenent memory at first. +# Then, Fixup the esp point to permenent memory +# + + movl %esp, %eax + subl %ebx, %eax + addl %ecx, %eax + movl (%esp), %edx # copy pushed register's value to permenent memory + movl %edx, (%eax) + movl 4(%esp), %edx + movl %edx, 4(%eax) + movl 8(%esp), %edx + movl %edx, 8(%eax) + movl 12(%esp), %edx + movl %edx, 12(%eax) + movl 16(%esp), %edx + movl %edx, 16(%eax) + movl %eax, %esp # From now, esp is pointed to permenent memory + +# +# Fixup the ebp point to permenent memory +# + movl %ebp, %eax + subl %ebx, %eax + addl %ecx, %eax + movl %eax, %ebp # From now, ebp is pointed to permenent memory + +# +# Fixup callee's ebp point for PeiDispatch +# + movl (%ebp), %eax + subl %ebx, %eax + addl %ecx, %eax + movl %eax, (%ebp) # From now, Temporary's PPI caller's stack is in permenent memory + + pop %edx + pop %ecx + pop %ebx + pop %eax + ret diff --git a/UnixPkg/Sec/UgaX11.c b/UnixPkg/Sec/UgaX11.c new file mode 100644 index 0000000000..b096dc660d --- /dev/null +++ b/UnixPkg/Sec/UgaX11.c @@ -0,0 +1,595 @@ +#include +#include +#include +#include +#include + +#include "PiPei.h" +#include "Protocol/UnixThunk.h" +#include "Protocol/SimpleTextIn.h" +#include "Protocol/UgaDraw.h" +#include "Protocol/UnixUgaIo.h" +#include +#include +#include +#include +#include + +#include +#include + +#include +#include +#include +#include +#include +#include + +extern void msSleep (unsigned long Milliseconds); + +/* XQueryPointer */ + +struct uga_drv_shift_mask +{ + unsigned char shift; + unsigned char size; + unsigned char csize; +}; + +#define NBR_KEYS 32 +typedef struct +{ + EFI_UNIX_UGA_IO_PROTOCOL UgaIo; + + Display *display; + int screen; /* values for window_size in main */ + Window win; + GC gc; + Visual *visual; + + int depth; + unsigned int width; + unsigned int height; + unsigned int line_bytes; + unsigned int pixel_shift; + unsigned char *image_data; + + struct uga_drv_shift_mask r, g, b; + + int use_shm; + XShmSegmentInfo xshm_info; + XImage *image; + + unsigned int key_rd; + unsigned int key_wr; + unsigned int key_count; + EFI_INPUT_KEY keys[NBR_KEYS]; +} UGA_IO_PRIVATE; + +static void +HandleEvents(UGA_IO_PRIVATE *drv); + +static void +fill_shift_mask (struct uga_drv_shift_mask *sm, unsigned long mask) +{ + sm->shift = 0; + sm->size = 0; + while ((mask & 1) == 0) + { + mask >>= 1; + sm->shift++; + } + while (mask & 1) + { + sm->size++; + mask >>= 1; + } + sm->csize = 8 - sm->size; +} + +static int +TryCreateShmImage(UGA_IO_PRIVATE *drv) +{ + drv->image = XShmCreateImage (drv->display, drv->visual, + drv->depth, ZPixmap, NULL, &drv->xshm_info, + drv->width, drv->height); + if (drv->image == NULL) + return 0; + + switch (drv->image->bitmap_unit) { + case 32: + drv->pixel_shift = 2; + break; + case 16: + drv->pixel_shift = 1; + break; + case 8: + drv->pixel_shift = 0; + break; + } + + drv->xshm_info.shmid = shmget + (IPC_PRIVATE, drv->image->bytes_per_line * drv->image->height, + IPC_CREAT | 0777); + if (drv->xshm_info.shmid < 0) + { + XDestroyImage(drv->image); + return 0; + } + + drv->image_data = shmat (drv->xshm_info.shmid, NULL, 0); + if(!drv->image_data) + { + shmctl (drv->xshm_info.shmid, IPC_RMID, NULL); + XDestroyImage(drv->image); + return 0; + } + /* Can this fail ? */ + shmctl (drv->xshm_info.shmid, IPC_RMID, NULL); + + drv->xshm_info.shmaddr = (char*)drv->image_data; + drv->image->data = (char*)drv->image_data; + + if (!XShmAttach (drv->display, &drv->xshm_info)) + { + shmdt (drv->image_data); + XDestroyImage(drv->image); + return 0; + } + return 1; +} + +static +EFI_STATUS +UgaClose (EFI_UNIX_UGA_IO_PROTOCOL *UgaIo) +{ + UGA_IO_PRIVATE *drv = (UGA_IO_PRIVATE *)UgaIo; + + if (drv == NULL) + return EFI_SUCCESS; + if (drv->image != NULL) + { + XDestroyImage(drv->image); + + if (drv->use_shm) + shmdt (drv->image_data); + + drv->image_data = NULL; + drv->image = NULL; + } + XDestroyWindow(drv->display, drv->win); + XCloseDisplay(drv->display); + free(drv); + return EFI_SUCCESS; +} + +static +EFI_STATUS +UgaSize(EFI_UNIX_UGA_IO_PROTOCOL *UgaIo, UINT32 Width, UINT32 Height) +{ + UGA_IO_PRIVATE *drv = (UGA_IO_PRIVATE *)UgaIo; + XSizeHints size_hints; + + /* Destroy current buffer if created. */ + if (drv->image != NULL) + { + XDestroyImage(drv->image); + + if (drv->use_shm) + shmdt (drv->image_data); + + drv->image_data = NULL; + drv->image = NULL; + } + + drv->width = Width; + drv->height = Height; + XResizeWindow (drv->display, drv->win, Width, Height); + + /* Allocate image. */ + if (XShmQueryExtension(drv->display) && TryCreateShmImage(drv)) + { + drv->use_shm = 1; + } + else + { + drv->use_shm = 0; + if (drv->depth > 16) + drv->pixel_shift = 2; + else if (drv->depth > 8) + drv->pixel_shift = 1; + else + drv->pixel_shift = 0; + + drv->image_data = malloc((drv->width * drv->height) << drv->pixel_shift); + drv->image = XCreateImage (drv->display, drv->visual, drv->depth, + ZPixmap, 0, (char *)drv->image_data, + drv->width, drv->height, + 8 << drv->pixel_shift, 0); + } + drv->line_bytes = drv->image->bytes_per_line; + fill_shift_mask (&drv->r, drv->image->red_mask); + fill_shift_mask (&drv->g, drv->image->green_mask); + fill_shift_mask (&drv->b, drv->image->blue_mask); + + /* Set WM hints. */ + size_hints.flags = PSize | PMinSize | PMaxSize; + size_hints.min_width = size_hints.max_width = size_hints.base_width = Width; + size_hints.min_height = size_hints.max_height = size_hints.base_height = Height; + XSetWMNormalHints (drv->display, drv->win, &size_hints); + + XMapWindow (drv->display, drv->win); + HandleEvents(drv); + return EFI_SUCCESS; +} + +static void +handleKeyEvent(UGA_IO_PRIVATE *drv, XEvent *ev) +{ + KeySym keysym; + char str[4]; + EFI_INPUT_KEY Key; + int res; + + if (drv->key_count == NBR_KEYS) + return; + + res = XLookupString(&ev->xkey, str, sizeof(str), &keysym, NULL); + Key.ScanCode = 0; + Key.UnicodeChar = 0; + switch (keysym) { + case XK_Home: Key.ScanCode = SCAN_HOME; break; + case XK_End: Key.ScanCode = SCAN_END; break; + case XK_Left: Key.ScanCode = SCAN_LEFT; break; + case XK_Right: Key.ScanCode = SCAN_RIGHT; break; + case XK_Up: Key.ScanCode = SCAN_UP; break; + case XK_Down: Key.ScanCode = SCAN_DOWN; break; + case XK_Delete: Key.ScanCode = SCAN_DELETE; break; + case XK_Insert: Key.ScanCode = SCAN_INSERT; break; + case XK_Page_Up: Key.ScanCode = SCAN_PAGE_UP; break; + case XK_Page_Down: Key.ScanCode = SCAN_PAGE_DOWN; break; + case XK_Escape: Key.ScanCode = SCAN_ESC; break; + + case XK_F1: Key.ScanCode = SCAN_F1; break; + case XK_F2: Key.ScanCode = SCAN_F2; break; + case XK_F3: Key.ScanCode = SCAN_F3; break; + case XK_F4: Key.ScanCode = SCAN_F4; break; + case XK_F5: Key.ScanCode = SCAN_F5; break; + case XK_F6: Key.ScanCode = SCAN_F6; break; + case XK_F7: Key.ScanCode = SCAN_F7; break; + case XK_F8: Key.ScanCode = SCAN_F8; break; + case XK_F9: Key.ScanCode = SCAN_F9; break; + + default: + if (res == 1) { + Key.UnicodeChar = str[0]; + } else { + return; + } + } + + drv->keys[drv->key_wr] = Key; + drv->key_wr = (drv->key_wr + 1) % NBR_KEYS; + drv->key_count++; +} + +static void +Redraw(UGA_IO_PRIVATE *drv, UINTN X, UINTN Y, UINTN Width, UINTN Height) +{ + if (drv->use_shm) + XShmPutImage (drv->display, drv->win, drv->gc, drv->image, + X, Y, X, Y, Width, Height, False); + else + XPutImage (drv->display, drv->win, drv->gc, drv->image, + X, Y, X, Y, Width, Height); +} + +static void +HandleEvent(UGA_IO_PRIVATE *drv, XEvent *ev) +{ + switch (ev->type) + { + case Expose: + Redraw(drv, ev->xexpose.x, ev->xexpose.y, + ev->xexpose.width, ev->xexpose.height); + break; + case GraphicsExpose: + Redraw(drv, ev->xgraphicsexpose.x, ev->xgraphicsexpose.y, + ev->xgraphicsexpose.width, ev->xgraphicsexpose.height); + break; + case KeyPress: + handleKeyEvent(drv, ev); + break; + case MappingNotify: + XRefreshKeyboardMapping(&ev->xmapping); + break; +#if 0 + case DestroyNotify: + XCloseDisplay (drv->display); + exit (1); + break; +#endif + case NoExpose: + default: + break; + } +} + +static void +HandleEvents(UGA_IO_PRIVATE *drv) +{ + while (XPending(drv->display) != 0) + { + XEvent ev; + + XNextEvent (drv->display, &ev); + HandleEvent(drv, &ev); + } +} + +static +unsigned long +UgaPixelToColor (UGA_IO_PRIVATE *drv, EFI_UGA_PIXEL pixel) +{ + return ((pixel.Red >> drv->r.csize) << drv->r.shift) + | ((pixel.Green >> drv->g.csize) << drv->g.shift) + | ((pixel.Blue >> drv->b.csize) << drv->b.shift); +} + +static +EFI_UGA_PIXEL +UgaColorToPixel (UGA_IO_PRIVATE *drv, unsigned long val) +{ + EFI_UGA_PIXEL res; + + memset (&res, 0, sizeof (EFI_UGA_PIXEL)); + /* FIXME: should round instead of truncate. */ + res.Red = (val >> drv->r.shift) << drv->r.csize; + res.Green = (val >> drv->g.shift) << drv->g.csize; + res.Blue = (val >> drv->b.shift) << drv->b.csize; + + return res; +} + +static +EFI_STATUS +UgaCheckKey(EFI_UNIX_UGA_IO_PROTOCOL *UgaIo) +{ + UGA_IO_PRIVATE *drv = (UGA_IO_PRIVATE *)UgaIo; + HandleEvents(drv); + if (drv->key_count != 0) + return EFI_SUCCESS; + else { + /* EFI is certainly polling. Be CPU-friendly. */ + msSleep (20); + return EFI_NOT_READY; + } +} + +static +EFI_STATUS +UgaGetKey(EFI_UNIX_UGA_IO_PROTOCOL *UgaIo, EFI_INPUT_KEY *key) +{ + UGA_IO_PRIVATE *drv = (UGA_IO_PRIVATE *)UgaIo; + EFI_STATUS status; + + status = UgaCheckKey(UgaIo); + if (status != EFI_SUCCESS) + return status; + + *key = drv->keys[drv->key_rd]; + drv->key_rd = (drv->key_rd + 1) % NBR_KEYS; + drv->key_count--; + return EFI_SUCCESS; +} + +EFI_STATUS +UgaBlt(EFI_UNIX_UGA_IO_PROTOCOL *UgaIo, + IN EFI_UGA_PIXEL *BltBuffer OPTIONAL, + IN EFI_UGA_BLT_OPERATION BltOperation, + IN UINTN SourceX, + IN UINTN SourceY, + IN UINTN DestinationX, + IN UINTN DestinationY, + IN UINTN Width, + IN UINTN Height, + IN UINTN Delta OPTIONAL + ) +{ + UGA_IO_PRIVATE *Private = (UGA_IO_PRIVATE *)UgaIo; + UINTN DstY; + UINTN SrcY; + UINTN DstX; + UINTN SrcX; + UINTN Index; + EFI_UGA_PIXEL *Blt; + UINT8 *Dst; + UINT8 *Src; + UINTN Nbr; + unsigned long Color; + + // + // Check bounds + // + if (BltOperation == EfiUgaVideoToBltBuffer + || BltOperation == EfiUgaVideoToVideo) { + // + // Source is Video. + // + if (SourceY + Height > Private->height) { + return EFI_INVALID_PARAMETER; + } + + if (SourceX + Width > Private->width) { + return EFI_INVALID_PARAMETER; + } + } + + if (BltOperation == EfiUgaBltBufferToVideo + || BltOperation == EfiUgaVideoToVideo + || BltOperation == EfiUgaVideoFill) { + // + // Destination is Video + // + if (DestinationY + Height > Private->height) { + return EFI_INVALID_PARAMETER; + } + + if (DestinationX + Width > Private->width) { + return EFI_INVALID_PARAMETER; + } + } + + switch (BltOperation) { + case EfiUgaVideoToBltBuffer: + Blt = BltBuffer; + Delta -= Width * sizeof (EFI_UGA_PIXEL); + for (SrcY = SourceY; SrcY < (Height + SourceY); SrcY++) { + for (SrcX = SourceX; SrcX < (Width + SourceX); SrcX++) { + *Blt++ = UgaColorToPixel(Private, + XGetPixel(Private->image, SrcX, SrcY)); + } + Blt = (EFI_UGA_PIXEL *) ((UINT8 *) Blt + Delta); + } + break; + case EfiUgaBltBufferToVideo: + Blt = BltBuffer; + Delta -= Width * sizeof (EFI_UGA_PIXEL); + for (DstY = DestinationY; DstY < (Height + DestinationY); DstY++) { + for (DstX = DestinationX; DstX < (Width + DestinationX); DstX++) { + XPutPixel(Private->image, DstX, DstY, UgaPixelToColor(Private, *Blt)); + Blt++; + } + Blt = (EFI_UGA_PIXEL *) ((UINT8 *) Blt + Delta); + } + break; + case EfiUgaVideoToVideo: + Dst = Private->image_data + (DestinationX << Private->pixel_shift) + + DestinationY * Private->line_bytes; + Src = Private->image_data + (SourceX << Private->pixel_shift) + + SourceY * Private->line_bytes; + Nbr = Width << Private->pixel_shift; + if (DestinationY < SourceY) { + for (Index = 0; Index < Height; Index++) { + memcpy (Dst, Src, Nbr); + Dst += Private->line_bytes; + Src += Private->line_bytes; + } + } + else { + Dst += (Height - 1) * Private->line_bytes; + Src += (Height - 1) * Private->line_bytes; + for (Index = 0; Index < Height; Index++) { + // + // Source and Destination Y may be equal, therefore Dst and Src may + // overlap. + // + memmove (Dst, Src, Nbr); + Dst -= Private->line_bytes; + Src -= Private->line_bytes; + } + } + break; + case EfiUgaVideoFill: + Color = UgaPixelToColor(Private, *BltBuffer); + for (DstY = DestinationY; DstY < (Height + DestinationY); DstY++) { + for (DstX = DestinationX; DstX < (Width + DestinationX); DstX++) { + XPutPixel(Private->image, DstX, DstY, Color); + } + } + break; + default: + return EFI_INVALID_PARAMETER; + } + + // + // Refresh screen. + // + switch (BltOperation) { + case EfiUgaVideoToVideo: + XCopyArea(Private->display, Private->win, Private->win, Private->gc, + SourceX, SourceY, Width, Height, DestinationX, DestinationY); + while (1) { + XEvent ev; + + XNextEvent (Private->display, &ev); + HandleEvent(Private, &ev); + if (ev.type == NoExpose || ev.type == GraphicsExpose) + break; + } + break; + case EfiUgaVideoFill: + Color = UgaPixelToColor(Private, *BltBuffer); + XSetForeground(Private->display, Private->gc, Color); + XFillRectangle(Private->display, Private->win, Private->gc, + DestinationX, DestinationY, Width, Height); + break; + case EfiUgaBltBufferToVideo: + Redraw(Private, DestinationX, DestinationY, Width, Height); + break; + default: + break; + } + return EFI_SUCCESS; +} + +EFI_STATUS +UgaCreate (EFI_UNIX_UGA_IO_PROTOCOL **Uga, CONST CHAR16 *Title) +{ + UGA_IO_PRIVATE *drv; + unsigned int border_width = 0; + char *display_name = NULL; + int title_len; + + drv = (UGA_IO_PRIVATE *) + calloc (1, sizeof (UGA_IO_PRIVATE)); + if (drv == NULL) + return EFI_OUT_OF_RESOURCES; + + drv->UgaIo.UgaClose = UgaClose; + drv->UgaIo.UgaSize = UgaSize; + drv->UgaIo.UgaCheckKey = UgaCheckKey; + drv->UgaIo.UgaGetKey = UgaGetKey; + drv->UgaIo.UgaBlt = UgaBlt; + + drv->key_count = 0; + drv->key_rd = 0; + drv->key_wr = 0; + drv->display = XOpenDisplay (display_name); + if (drv->display == NULL) + { + fprintf (stderr, "uga: cannot connect to X server %s\n", + XDisplayName (display_name)); + free (drv); + return EFI_DEVICE_ERROR; + } + drv->screen = DefaultScreen (drv->display); + drv->visual = DefaultVisual (drv->display, drv->screen); + drv->win = XCreateSimpleWindow + (drv->display, RootWindow (drv->display, drv->screen), + 0, 0, 4, 4, border_width, + BlackPixel (drv->display, drv->screen), + WhitePixel (drv->display, drv->screen)); + + drv->depth = DefaultDepth (drv->display, drv->screen); + + /* Compute title len and convert to Ascii. */ + for (title_len = 0; Title[title_len] != 0; title_len++) + ; + { + char title[title_len + 1]; + int i; + for (i = 0; i < title_len; i++) + title[i] = Title[i]; + title[i] = 0; + + XStoreName (drv->display, drv->win, title); + } + + XSelectInput (drv->display, drv->win, + ExposureMask | KeyPressMask); + drv->gc = DefaultGC (drv->display, drv->screen); + + *Uga = (EFI_UNIX_UGA_IO_PROTOCOL *)drv; + return EFI_SUCCESS; +} diff --git a/UnixPkg/Sec/UnixThunk.c b/UnixPkg/Sec/UnixThunk.c new file mode 100644 index 0000000000..500568ad52 --- /dev/null +++ b/UnixPkg/Sec/UnixThunk.c @@ -0,0 +1,197 @@ +/*++ + +Copyright (c) 2004 - 2006, Intel Corporation +All rights reserved. This program and the accompanying materials +are licensed and made available under the terms and conditions of the BSD License +which accompanies this distribution. The full text of the license may be found at +http://opensource.org/licenses/bsd-license.php + +THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS, +WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED. + +Module Name: + + UnixThunk.c + +Abstract: + + Since the SEC is the only program in our emulation we + must use a Tiano mechanism to export APIs to other modules. + This is the role of the EFI_UNIX_THUNK_PROTOCOL. + + The mUnixThunkTable exists so that a change to EFI_UNIX_THUNK_PROTOCOL + will cause an error in initializing the array if all the member functions + are not added. It looks like adding a element to end and not initializing + it may cause the table to be initaliized with the members at the end being + set to zero. This is bad as jumping to zero will crash. + + + gUnix is a a public exported global that contains the initialized + data. + +--*/ + +#include "SecMain.h" +#include "Library/UnixLib.h" + +static int settimer_initialized; +static struct timeval settimer_timeval; +static void (*settimer_callback)(UINT64 delta); + +static void +settimer_handler (int sig) +{ + struct timeval timeval; + UINT64 delta; + + gettimeofday (&timeval, NULL); + delta = ((UINT64)timeval.tv_sec * 1000) + (timeval.tv_usec / 1000) + - ((UINT64)settimer_timeval.tv_sec * 1000) + - (settimer_timeval.tv_usec / 1000); + settimer_timeval = timeval; + if (settimer_callback) + (*settimer_callback)(delta); +} + +static +VOID +SetTimer (UINT64 PeriodMs, VOID (*CallBack)(UINT64 DeltaMs)) +{ + struct itimerval timerval; + + if (!settimer_initialized) { + struct sigaction act; + + settimer_initialized = 1; + act.sa_handler = settimer_handler; + act.sa_flags = 0; + sigemptyset (&act.sa_mask); + if (sigaction (SIGALRM, &act, NULL) != 0) { + printf ("SetTimer: sigaction error %s\n", strerror (errno)); + } + if (gettimeofday (&settimer_timeval, NULL) != 0) { + printf ("SetTimer: gettimeofday error %s\n", strerror (errno)); + } + } + timerval.it_value.tv_sec = PeriodMs / 1000; + timerval.it_value.tv_usec = (PeriodMs % 1000) * 1000; + timerval.it_value.tv_sec = PeriodMs / 1000; + timerval.it_interval = timerval.it_value; + + if (setitimer (ITIMER_REAL, &timerval, NULL) != 0) { + printf ("SetTimer: setitimer error %s\n", strerror (errno)); + } + settimer_callback = CallBack; +} + +void +msSleep (unsigned long Milliseconds) +{ + struct timespec ts; + + ts.tv_sec = Milliseconds / 1000; + ts.tv_nsec = (Milliseconds % 1000) * 1000000; + + while (nanosleep (&ts, &ts) != 0 && errno == EINTR) + ; +} + +void +GetLocalTime (EFI_TIME *Time) +{ + struct tm *tm; + time_t t; + + t = time (NULL); + tm = localtime (&t); + + Time->Year = 1900 + tm->tm_year; + Time->Month = tm->tm_mon; + Time->Day = tm->tm_mday; + Time->Hour = tm->tm_hour; + Time->Minute = tm->tm_min; + Time->Second = tm->tm_sec; + Time->Nanosecond = 0; + Time->TimeZone = timezone; + Time->Daylight = (daylight ? EFI_TIME_ADJUST_DAYLIGHT : 0) + | (tm->tm_isdst > 0 ? EFI_TIME_IN_DAYLIGHT : 0); +} + +static void +TzSet (void) +{ + static int done = 0; + if (!done) { + tzset (); + done = 1; + } +} + +long +GetTimeZone(void) +{ + TzSet (); + return timezone; +} + +int +GetDayLight(void) +{ + TzSet (); + return daylight; +} + +int +GetErrno(void) +{ + return errno; +} + +extern EFI_STATUS +UgaCreate(struct _EFI_UNIX_UGA_IO_PROTOCOL **UgaIo, CONST CHAR16 *Title); + +EFI_UNIX_THUNK_PROTOCOL mUnixThunkTable = { + EFI_UNIX_THUNK_PROTOCOL_SIGNATURE, + msSleep, /* Sleep */ + exit, /* Exit */ + SetTimer, + GetLocalTime, + gmtime, + GetTimeZone, + GetDayLight, + (UnixPoll)poll, + (UnixRead)read, + (UnixWrite)write, + getenv, + (UnixOpen)open, + lseek, + ftruncate, + close, + mkdir, + rmdir, + unlink, + GetErrno, + opendir, + rewinddir, + readdir, + closedir, + stat, + statfs, + rename, + mktime, + fsync, + chmod, + utime, + tcflush, + UgaCreate, + perror, + ioctl, + fcntl, + cfsetispeed, + cfsetospeed, + tcgetattr, + tcsetattr +}; + + +EFI_UNIX_THUNK_PROTOCOL *gUnix = &mUnixThunkTable; -- cgit v1.2.3