Add InOsEmuPkg. Like UnixPkg and Nt32Pkg, but EFI code can be common and does not require including system include files. Currently only Unix 64-bit is supported and it has only been tested on Mac OS X. Not all features are ported over, but GOP, via X11, and access to local file systems are supported and you can boot to the shell.

git-svn-id: https://edk2.svn.sourceforge.net/svnroot/edk2/trunk/edk2@11641 6f19259b-4bc3-4df7-8a09-765794883524

InOsEmuPkg/Unix/.gdbinit

@@ -0,0 +1,8 @@
+set confirm off
+set output-radix 16
+b SecGdbScriptBreak
+command
+silent
+source SecMain.gdb
+c
+end

InOsEmuPkg/Unix/Sec/EmuThunk.c

@@ -0,0 +1,314 @@
+/*++ @file
+  Since the SEC is the only program in our emulation we 
+  must use a UEFI/PI mechanism to export APIs to other modules.
+  This is the role of the EFI_EMU_THUNK_PROTOCOL.
+
+  The mUnixThunkTable exists so that a change to EFI_EMU_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.
+
+Copyright (c) 2004 - 2009, Intel Corporation. All rights reserved.<BR>
+Portions copyright (c) 2008 - 2011, Apple Inc. All rights reserved.<BR>
+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.             
+
+**/
+
+#include "SecMain.h"
+
+#ifdef __APPLE__
+#define DebugAssert _Mangle__DebugAssert
+
+#include <assert.h>
+#include <CoreServices/CoreServices.h>
+#include <mach/mach.h>
+#include <mach/mach_time.h>
+
+#undef DebugAssert
+#endif
+
+int settimer_initialized;
+struct timeval settimer_timeval;
+void (*settimer_callback)(UINT64 delta);
+
+BOOLEAN gEmulatorInterruptEnabled = FALSE;
+
+
+UINTN
+SecWriteStdErr (
+  IN UINT8     *Buffer,
+  IN UINTN     NumberOfBytes
+  )
+{
+  ssize_t Return;
+  
+  Return = write (1, (const void *)Buffer, (size_t)NumberOfBytes);
+  
+  return (Return == -1) ? 0 : Return;
+}
+
+
+
+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) {
+    ReverseGasketUint64 (settimer_callback, delta);
+  }
+}
+
+VOID
+SecSetTimer (
+  IN  UINT64                  PeriodMs,
+  IN  EMU_SET_TIMER_CALLBACK  CallBack
+  )
+{
+  struct itimerval timerval;
+  UINT32 remainder;
+
+  if (!settimer_initialized) {
+    struct sigaction act;
+
+    settimer_initialized = 1;
+    act.sa_handler = settimer_handler;
+    act.sa_flags = 0;
+    sigemptyset (&act.sa_mask);
+    gEmulatorInterruptEnabled = TRUE;
+    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 = DivU64x32(PeriodMs, 1000);
+  DivU64x32Remainder(PeriodMs, 1000, &remainder);
+  timerval.it_value.tv_usec = remainder * 1000;
+  timerval.it_value.tv_sec = DivU64x32(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
+SecEnableInterrupt (
+  VOID
+  )
+{
+  sigset_t  sigset;
+
+  gEmulatorInterruptEnabled = TRUE;
+  // Since SetTimer() uses SIGALRM we emulate turning on and off interrupts 
+  // by enabling/disabling SIGALRM.
+  sigemptyset (&sigset);
+  sigaddset (&sigset, SIGALRM);
+  pthread_sigmask (SIG_UNBLOCK, &sigset, NULL);
+}
+
+
+VOID
+SecDisableInterrupt (
+  VOID
+  )
+{
+  sigset_t  sigset;
+
+  // Since SetTimer() uses SIGALRM we emulate turning on and off interrupts 
+  // by enabling/disabling SIGALRM.
+  sigemptyset (&sigset);
+  sigaddset (&sigset, SIGALRM);
+  pthread_sigmask (SIG_BLOCK, &sigset, NULL);
+  gEmulatorInterruptEnabled = FALSE;
+}
+
+
+BOOLEAN
+SecInterruptEanbled (void)
+{
+  return gEmulatorInterruptEnabled;
+}
+
+
+UINT64
+QueryPerformanceFrequency (
+  VOID
+  )
+{
+  // Hard code to nanoseconds
+  return 1000000000ULL;
+}
+
+UINT64
+QueryPerformanceCounter (
+  VOID
+  )
+{
+#if __APPLE__
+  UINT64          Start;
+  Nanoseconds     elapsedNano;
+
+  Start = mach_absolute_time ();
+  
+  // Convert to nanoseconds.
+
+  // Have to do some pointer fun because AbsoluteToNanoseconds 
+  // works in terms of UnsignedWide, which is a structure rather 
+    // than a proper 64-bit integer.
+  elapsedNano = AbsoluteToNanoseconds (*(AbsoluteTime *) &Start);
+
+  return *(uint64_t *) &elapsedNano;
+#else
+  // Need to figure out what to do for Linux?
+  return 0;
+#endif
+}
+  
+
+
+VOID
+SecSleep (
+  IN  UINT64 Milliseconds
+  )
+{
+  struct timespec rq, rm;
+  struct timeval  start, end;
+  unsigned long  MicroSec;
+  
+  rq.tv_sec = Milliseconds / 1000;
+  rq.tv_nsec = (Milliseconds % 1000) * 1000000;
+
+  //
+  // nanosleep gets interrupted by our timer tic. 
+  // we need to track wall clock time or we will stall for way too long
+  //
+  gettimeofday (&start, NULL);
+  end.tv_sec  = start.tv_sec + rq.tv_sec;
+  MicroSec = (start.tv_usec + rq.tv_nsec/1000);
+  end.tv_usec = MicroSec % 1000000;
+  if (MicroSec > 1000000) {
+    end.tv_sec++;
+  }
+
+  while (nanosleep (&rq, &rm) == -1) {
+    if (errno != EINTR) {
+      break;
+    }
+    gettimeofday (&start, NULL);
+    if (start.tv_sec > end.tv_sec) {
+      break;
+    } if ((start.tv_sec == end.tv_sec) && (start.tv_usec > end.tv_usec)) {
+      break;
+    }
+    rq = rm;
+  } 
+}
+
+VOID
+SecExit (
+  UINTN   Status
+  )
+{
+  exit (Status);
+}
+
+
+VOID
+SecGetTime (
+  OUT  EFI_TIME               *Time,
+  OUT EFI_TIME_CAPABILITIES   *Capabilities OPTIONAL
+  )
+{
+  struct tm *tm;
+  time_t t;
+
+  t = time (NULL);
+  tm = localtime (&t);
+
+  Time->Year = 1900 + tm->tm_year;
+  Time->Month = tm->tm_mon + 1;
+  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);
+    
+  if (Capabilities != NULL) {
+    Capabilities->Resolution  = 1;
+    Capabilities->Accuracy    = 50000000;
+    Capabilities->SetsToZero  = FALSE;
+  }
+}
+
+
+
+VOID
+SecSetTime (
+  IN  EFI_TIME               *Time
+  )
+{
+  // Don't change the time on the system
+  // We could save delta to localtime() and have SecGetTime adjust return values?
+  return;
+}
+
+
+EFI_STATUS
+SecGetNextProtocol (
+  IN  BOOLEAN                 EmuBusDriver,
+  OUT EMU_IO_THUNK_PROTOCOL   **Instance   OPTIONAL
+  )
+{
+  return GetNextThunkProtocol (EmuBusDriver, Instance);
+}
+
+
+EMU_THUNK_PROTOCOL gEmuThunkProtocol = {
+  GasketSecWriteStdErr,
+  GasketSecPeCoffGetEntryPoint,
+  GasketSecPeCoffRelocateImageExtraAction,
+  GasketSecPeCoffUnloadImageExtraAction,
+  GasketSecEnableInterrupt,
+  GasketSecDisableInterrupt,
+  GasketQueryPerformanceFrequency,
+  GasketQueryPerformanceCounter,
+  GasketSecSleep,
+  GasketSecExit,
+  GasketSecGetTime,                
+  GasketSecSetTime,
+  GasketSecSetTimer,  
+  GasketSecGetNextProtocol
+};
+
+
+VOID
+SecInitThunkProtocol (
+  VOID
+  )
+{
+  // timezone and daylight lib globals depend on tzset be called 1st.
+  tzset ();
+}
+

InOsEmuPkg/Unix/Sec/FwVol.c

@@ -0,0 +1,309 @@
+/*++ @file
+  A simple FV stack so the SEC can extract the SEC Core from an
+  FV.
+
+Copyright (c) 2006, Intel Corporation. All rights reserved.<BR>
+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.             
+
+**/
+
+#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;
+}

InOsEmuPkg/Unix/Sec/Gasket.h

@@ -0,0 +1,420 @@
+/** @file
+
+  Copyright (c) 2008 - 2011, Apple Inc. All rights reserved.<BR>
+
+  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.
+
+**/
+
+#ifndef _GASKET_H_
+#define _GASKET_H_
+
+//
+// EMU_THUNK_PROTOCOL gaskets (EFIAPI to UNIX ABI)
+//
+
+UINTN
+GasketSecWriteStdErr (
+  IN UINT8     *Buffer,
+  IN UINTN     NumberOfBytes
+  );
+
+RETURN_STATUS
+EFIAPI
+GasketSecPeCoffGetEntryPoint (
+  IN     VOID  *Pe32Data,
+  IN OUT VOID  **EntryPoint
+  );
+
+VOID
+EFIAPI
+GasketSecPeCoffRelocateImageExtraAction (
+  IN OUT PE_COFF_LOADER_IMAGE_CONTEXT  *ImageContext
+  );
+
+VOID
+EFIAPI
+GasketSecPeCoffUnloadImageExtraAction (
+  IN OUT PE_COFF_LOADER_IMAGE_CONTEXT  *ImageContext
+  );
+
+VOID
+EFIAPI
+GasketSecSetTimer (
+  IN  UINT64                  PeriodMs,
+  IN  EMU_SET_TIMER_CALLBACK  CallBack
+  );
+
+VOID
+EFIAPI
+GasketSecEnableInterrupt (
+  VOID
+  );
+
+VOID
+EFIAPI
+GasketSecDisableInterrupt (
+  VOID
+  );
+  
+UINT64  
+GasketQueryPerformanceFrequency (
+  VOID
+  );
+
+UINT64
+GasketQueryPerformanceCounter (
+  VOID
+  );
+
+
+VOID
+EFIAPI
+GasketSecSleep (
+  IN  UINT64 Milliseconds
+  );
+
+VOID
+EFIAPI
+GasketSecExit (
+  UINTN   Status
+  );
+
+VOID
+EFIAPI
+GasketSecGetTime (
+  OUT  EFI_TIME               *Time,
+  OUT EFI_TIME_CAPABILITIES   *Capabilities OPTIONAL
+  );
+
+VOID
+EFIAPI
+GasketSecSetTime (
+  IN  EFI_TIME               *Time
+  );
+
+EFI_STATUS
+EFIAPI
+GasketSecGetNextProtocol (
+  IN  BOOLEAN                 EmuBusDriver,
+  OUT EMU_IO_THUNK_PROTOCOL   **Instance  OPTIONAL
+  );
+
+
+// PPIs produced by SEC  
+
+
+EFI_STATUS
+EFIAPI
+GasketSecUnixPeiLoadFile (
+  IN  VOID                  *Pe32Data,  
+  IN  EFI_PHYSICAL_ADDRESS  *ImageAddress,  
+  IN  UINT64                *ImageSize,  
+  OUT EFI_PHYSICAL_ADDRESS  *EntryPoint  
+  );
+  
+EFI_STATUS
+EFIAPI
+GasketSecUnixPeiAutoScan (
+  IN  UINTN                 Index,
+  OUT EFI_PHYSICAL_ADDRESS  *MemoryBase,
+  OUT UINT64                *MemorySize
+  );
+  
+VOID *
+EFIAPI
+GasketSecEmuThunkAddress (
+  VOID
+  );
+
+ 
+EFI_STATUS
+EFIAPI
+GasketSecUnixUnixFwhAddress (
+  IN OUT UINT64                *FwhSize,
+  IN OUT EFI_PHYSICAL_ADDRESS  *FwhBase
+  );
+  
+
+
+//
+// Reverse (UNIX to EFIAPI) gaskets
+//
+
+typedef
+void
+(*CALL_BACK) (
+  UINT64 Delta
+  );
+
+UINTN
+ReverseGasketUint64 (
+  CALL_BACK CallBack,
+  UINT64 a
+  );
+
+UINTN
+ReverseGasketUint64Uint64 (
+  VOID      *CallBack,
+  VOID      *Context,
+  VOID      *Key
+  );
+
+//
+// Gasket functions for EFI_EMU_UGA_IO_PROTOCOL
+//
+
+
+EFI_STATUS
+EFIAPI
+GasketX11Size (
+  EMU_GRAPHICS_WINDOW_PROTOCOL *GraphicsWindowsIo,
+  UINT32 Width,
+  UINT32 Height
+  );
+
+EFI_STATUS
+EFIAPI
+GasketX11CheckKey (
+  EMU_GRAPHICS_WINDOW_PROTOCOL *GraphicsWindowsIo
+  );
+
+EFI_STATUS
+EFIAPI
+GasketX11GetKey (
+  EMU_GRAPHICS_WINDOW_PROTOCOL *GraphicsWindowsIo,
+  EFI_KEY_DATA                 *key
+  );
+
+EFI_STATUS
+EFIAPI
+GasketX11KeySetState (
+  EMU_GRAPHICS_WINDOW_PROTOCOL  *GraphicsWindowsIo,
+  EFI_KEY_TOGGLE_STATE          *KeyToggleState
+  );
+  
+EFI_STATUS
+EFIAPI  
+GasketX11RegisterKeyNotify ( 
+  IN EMU_GRAPHICS_WINDOW_PROTOCOL                         *GraphicsWindowsIo, 
+  IN EMU_GRAPHICS_WINDOW_REGISTER_KEY_NOTIFY_CALLBACK     MakeCallBack,
+  IN EMU_GRAPHICS_WINDOW_REGISTER_KEY_NOTIFY_CALLBACK     BreakCallBack,
+  IN VOID                                                 *Context
+  );
+
+  
+EFI_STATUS
+EFIAPI
+GasketX11Blt (
+  IN  EMU_GRAPHICS_WINDOW_PROTOCOL            *GraphicsWindows,
+  IN  EFI_UGA_PIXEL                           *BltBuffer OPTIONAL,
+  IN  EFI_UGA_BLT_OPERATION                   BltOperation,
+  IN  EMU_GRAPHICS_WINDOWS__BLT_ARGS          *Args
+  );
+
+EFI_STATUS
+EFIAPI
+GasketX11CheckPointer (
+  EMU_GRAPHICS_WINDOW_PROTOCOL *GraphicsWindowsIo
+  );
+
+EFI_STATUS 
+EFIAPI 
+GasketX11GetPointerState (
+  EMU_GRAPHICS_WINDOW_PROTOCOL *GraphicsWindowsIo, 
+  EFI_SIMPLE_POINTER_STATE *state
+  );
+
+EFI_STATUS
+EFIAPI
+GasketX11GraphicsWindowOpen (
+  IN  EMU_IO_THUNK_PROTOCOL   *This
+  );
+ 
+EFI_STATUS
+EFIAPI
+GasketX11GraphicsWindowClose (
+  IN  EMU_IO_THUNK_PROTOCOL   *This
+  );
+
+// Pthreads
+
+UINTN
+EFIAPI
+GasketPthreadMutexLock (
+  IN VOID *Mutex
+  );            
+
+
+
+UINTN
+EFIAPI
+GasketPthreadMutexUnLock (
+  IN VOID *Mutex
+  );                        
+
+ 
+UINTN
+EFIAPI
+GasketPthreadMutexTryLock (
+  IN VOID *Mutex
+  );                      
+
+ 
+VOID *
+EFIAPI
+GasketPthreadMutexInit (
+  IN VOID
+  );                     
+
+ 
+UINTN
+EFIAPI
+GasketPthreadMutexDestroy (
+  IN VOID *Mutex
+  );                            
+
+ 
+UINTN
+EFIAPI
+GasketPthreadCreate (
+  IN  VOID                      *Thread,
+  IN  VOID                      *Attribute,
+  IN  PTREAD_THUNK_THEAD_ENTRY  Start,
+  IN  VOID                      *Context
+  );
+ 
+VOID
+EFIAPI
+GasketPthreadExit (
+  IN VOID *ValuePtr
+  );                            
+
+   
+UINTN
+EFIAPI
+GasketPthreadSelf (
+  VOID
+  );                              
+
+EFI_STATUS
+EFIAPI
+GasketPthreadOpen (
+  IN  EMU_IO_THUNK_PROTOCOL   *This
+  );
+
+EFI_STATUS
+EFIAPI
+GasketPthreadClose (
+  IN  EMU_IO_THUNK_PROTOCOL   *This
+  );
+
+
+// PosixFileSystem
+
+EFI_STATUS
+EFIAPI
+GasketPosixOpenVolume (
+  IN EFI_SIMPLE_FILE_SYSTEM_PROTOCOL    *This,
+  OUT EFI_FILE_PROTOCOL                 **Root
+  );
+  
+EFI_STATUS
+EFIAPI
+GasketPosixFileOpen (
+  IN EFI_FILE_PROTOCOL        *This,
+  OUT EFI_FILE_PROTOCOL       **NewHandle,
+  IN CHAR16                   *FileName,
+  IN UINT64                   OpenMode,
+  IN UINT64                   Attributes
+  );
+
+EFI_STATUS
+EFIAPI
+GasketPosixFileCLose (
+  IN EFI_FILE_PROTOCOL  *This
+  );
+  
+EFI_STATUS
+EFIAPI
+GasketPosixFileDelete (
+  IN EFI_FILE_PROTOCOL  *This
+  );
+
+EFI_STATUS
+EFIAPI
+GasketPosixFileRead (
+  IN EFI_FILE_PROTOCOL        *This,
+  IN OUT UINTN                *BufferSize,
+  OUT VOID                    *Buffer
+  );
+  
+EFI_STATUS
+EFIAPI
+GasketPosixFileWrite (
+  IN EFI_FILE_PROTOCOL        *This,
+  IN OUT UINTN                *BufferSize,
+  IN VOID                     *Buffer
+  );
+
+EFI_STATUS
+EFIAPI
+GasketPosixFileSetPossition (
+  IN EFI_FILE_PROTOCOL        *This,
+  IN UINT64                   Position
+  );
+
+EFI_STATUS
+EFIAPI
+GasketPosixFileGetPossition (
+  IN EFI_FILE_PROTOCOL        *This,
+  OUT UINT64                  *Position
+  );
+
+EFI_STATUS
+EFIAPI
+GasketPosixFileGetInfo (
+  IN EFI_FILE_PROTOCOL        *This,
+  IN EFI_GUID                 *InformationType,
+  IN OUT UINTN                *BufferSize,
+  OUT VOID                    *Buffer
+  );
+
+EFI_STATUS
+EFIAPI
+GasketPosixFileSetInfo (
+  IN EFI_FILE_PROTOCOL        *This,
+  IN EFI_GUID                 *InformationType,
+  IN UINTN                    BufferSize,
+  IN VOID                     *Buffer
+  );
+
+EFI_STATUS
+EFIAPI
+GasketPosixFileFlush (
+  IN EFI_FILE_PROTOCOL  *This
+  );
+
+EFI_STATUS
+EFIAPI
+GasketPosixFileSystmeThunkOpen (
+  IN  EMU_IO_THUNK_PROTOCOL   *This
+  );
+
+EFI_STATUS
+EFIAPI
+GasketPosixFileSystmeThunkClose (
+  IN  EMU_IO_THUNK_PROTOCOL   *This
+  );
+
+
+
+#endif
+
+

InOsEmuPkg/Unix/Sec/Pthreads.c

@@ -0,0 +1,233 @@
+/*++ @file
+ POSIX Pthreads to emulate APs and implement threads
+
+Copyright (c) 2011, Apple Inc. 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.
+
+
+**/
+
+#include "SecMain.h"
+#include <pthread.h>
+
+
+UINTN
+EFIAPI
+PthreadMutexLock (
+  IN VOID *Mutex
+  )
+{
+  return (UINTN)pthread_mutex_lock ((pthread_mutex_t *)Mutex);
+}
+
+
+
+UINTN
+EFIAPI
+PthreadMutexUnLock (
+  IN VOID *Mutex
+  )                        
+{
+  return (UINTN)pthread_mutex_unlock ((pthread_mutex_t *)Mutex);
+}
+
+ 
+UINTN
+EFIAPI
+PthreadMutexTryLock (
+  IN VOID *Mutex
+  )                      
+{
+  return (UINTN)pthread_mutex_trylock ((pthread_mutex_t *)Mutex);
+}
+
+
+VOID *
+PthreadMutexInit (
+  IN VOID
+  )
+{
+  pthread_mutex_t *Mutex;
+  int             err;
+  
+  Mutex = malloc (sizeof (pthread_mutex_t));
+  err = pthread_mutex_init (Mutex, NULL);
+  if (err == 0) {
+    return Mutex;
+  }
+  
+  return NULL;
+}
+
+
+UINTN
+PthreadMutexDestroy (
+  IN VOID *Mutex
+  )
+{
+  if (Mutex != NULL) {
+    return pthread_mutex_destroy ((pthread_mutex_t *)Mutex);
+  }
+  
+  return -1;
+}
+
+// Can't store this data on PthreadCreate stack so we need a global
+typedef struct {
+  pthread_mutex_t             Mutex;
+  PTREAD_THUNK_THEAD_ENTRY    Start;
+} THREAD_MANGLE;
+
+THREAD_MANGLE mThreadMangle = {
+  PTHREAD_MUTEX_INITIALIZER,
+  NULL
+};
+
+VOID *
+SecFakePthreadStart (
+  VOID  *Context
+  )
+{
+  PTREAD_THUNK_THEAD_ENTRY  Start;
+  sigset_t                  SigMask;
+  
+  // Save global on the stack before we unlock
+  Start   = mThreadMangle.Start;
+  pthread_mutex_unlock (&mThreadMangle.Mutex);
+  
+  // Mask all signals to the APs
+  sigfillset (&SigMask); 
+  pthread_sigmask (SIG_BLOCK, &SigMask, NULL);
+  
+  //
+  // We have to start the thread in SEC as we need to follow
+  // OS X calling conventions. We can then call back into 
+  // to the callers Start.
+  //
+  // This is a great example of how all problems in computer 
+  // science can be solved by adding another level of indirection
+  //
+ return  (VOID *)ReverseGasketUint64 ((CALL_BACK)Start, (UINTN)Context);
+}
+  
+UINTN
+PthreadCreate (
+  IN  VOID                      *Thread,
+  IN  VOID                      *Attribute,
+  IN  PTREAD_THUNK_THEAD_ENTRY  Start,
+  IN  VOID                      *Context
+  )
+{
+  int         err;
+  BOOLEAN     EnabledOnEntry;    
+  
+  //
+  // Threads inherit interrupt state so disable interrupts before we start thread
+  //
+  if (SecInterruptEanbled ()) {
+    SecDisableInterrupt ();
+    EnabledOnEntry = TRUE;
+  } else {
+    EnabledOnEntry = FALSE;
+  }
+  
+  // Aquire lock for global, SecFakePthreadStart runs in a different thread.
+  pthread_mutex_lock (&mThreadMangle.Mutex);
+  mThreadMangle.Start   = Start;
+  
+  err = pthread_create (Thread, Attribute, SecFakePthreadStart, Context);
+  if (err != 0) {
+    // Thread failed to launch so release the lock;
+    pthread_mutex_unlock (&mThreadMangle.Mutex);
+  }
+  
+  if (EnabledOnEntry) {
+    // Restore interrupt state
+    SecEnableInterrupt ();
+  }    
+
+  return err;
+}
+
+
+VOID
+PthreadExit (
+  IN VOID *ValuePtr
+  )
+{ 
+  pthread_exit (ValuePtr);
+  return;
+}
+
+   
+UINTN
+PthreadSelf (
+  VOID
+  )
+{
+  // POSIX currently allows pthread_t to be a structure or arithmetic type.
+  // Check out sys/types.h to make sure this will work if you are porting. 
+  // On OS X (Darwin) pthread_t is a pointer to a structure so this code works.
+  return (UINTN)pthread_self (); 
+}
+
+
+EMU_PTREAD_THUNK_PROTOCOL gPthreadThunk = {
+  GasketPthreadMutexLock,
+  GasketPthreadMutexUnLock,
+  GasketPthreadMutexTryLock,
+  GasketPthreadMutexInit,
+  GasketPthreadMutexDestroy,
+  GasketPthreadCreate,
+  GasketPthreadExit,
+  GasketPthreadSelf
+};
+
+
+EFI_STATUS
+PthreadOpen (
+  IN  EMU_IO_THUNK_PROTOCOL   *This
+  )
+{
+  if (This->Instance != 0) {
+    // Only single instance is supported
+    return EFI_NOT_FOUND;
+  }
+  
+  if (This->ConfigString[0] == L'0') {
+    // If AP count is zero no need for threads
+    return EFI_NOT_FOUND;
+  }
+  
+  This->Interface = &gPthreadThunk;
+  
+  return EFI_SUCCESS;
+}
+
+
+EFI_STATUS
+PthreadClose (
+  IN  EMU_IO_THUNK_PROTOCOL   *This
+  )
+{
+  return EFI_SUCCESS;
+}
+
+
+EMU_IO_THUNK_PROTOCOL gPthreadThunkIo = {
+  &gEmuPthreadThunkProtocolGuid,
+  NULL,
+  NULL,
+  0,
+  GasketPthreadOpen,
+  GasketPthreadClose,
+  NULL
+};
+
+

InOsEmuPkg/Unix/Sec/SecMain.h

@@ -0,0 +1,306 @@
+/*++ @file
+
+Copyright (c) 2006 - 2010, Intel Corporation. All rights reserved.<BR>
+Portions copyright (c) 2008 - 2011, Apple Inc. All rights reserved.<BR>
+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.             
+
+**/
+
+#ifndef _SEC_MAIN_H__
+#define _SEC_MAIN_H__
+
+#include <PiPei.h>
+#include <Uefi.h>
+
+#include <Library/PeCoffLib.h>
+#include <Library/BaseLib.h>
+#include <Library/BaseMemoryLib.h>
+#include <Library/PrintLib.h>
+#include <Library/PcdLib.h>
+#include <Library/DebugLib.h>
+#include <Library/ReportStatusCodeLib.h>
+
+#include <Library/ThunkPpiList.h>
+#include <Library/ThunkProtocolList.h>
+
+#include <Ppi/EmuThunk.h>
+#include <Ppi/StatusCode.h>
+#include <Ppi/TemporaryRamSupport.h>
+#include <Ppi/EmuPeiServicesTableUpdate.h>
+
+#include <Protocol/SimplePointer.h>
+#include <Protocol/SimpleTextIn.h>
+#include <Protocol/SimpleTextInEx.h>
+#include <Protocol/UgaDraw.h>
+#include <Protocol/SimpleFileSystem.h>
+
+#include <Protocol/EmuThunk.h>
+#include <Protocol/EmuIoThunk.h>
+#include <Protocol/EmuGraphicsWindow.h>
+#include <Protocol/EmuPthreadThunk.h>
+
+#include <Guid/FileInfo.h>
+#include <Guid/FileSystemInfo.h>
+#include <Guid/FileSystemVolumeLabelInfo.h>
+
+#include <stdio.h>
+#include <stdlib.h>
+
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <sys/termios.h>
+#include <sys/time.h>
+
+#if __CYGWIN__
+#include <sys/dirent.h>
+#else
+#include <sys/dir.h>
+#endif
+
+#include <sys/mman.h>
+#include <dlfcn.h>
+
+#include <unistd.h>
+#include <poll.h>
+#include <fcntl.h>
+#include <time.h>
+#include <signal.h>
+#include <errno.h>
+#include <string.h>
+#include <stdlib.h>
+#include <sys/ioctl.h>
+
+#include <sys/socket.h>
+#include <netdb.h>
+#include <netinet/in.h>
+#include <net/if.h>
+#include <ifaddrs.h>
+
+#ifdef __APPLE__
+#include <net/if_dl.h>
+#include <net/bpf.h>
+#include <sys/param.h>
+#include <sys/mount.h>
+#define _XOPEN_SOURCE
+#ifndef _Bool
+  #define _Bool char // for clang debug
+#endif
+#else
+#include <termio.h>
+#include <sys/vfs.h>
+#endif 
+
+#include <utime.h>
+
+#include "Gasket.h"
+
+
+#define STACK_SIZE                0x20000      
+
+typedef struct {
+  EFI_PHYSICAL_ADDRESS  Address;
+  UINT64                Size;
+} EMU_FD_INFO;
+
+typedef struct {
+  EFI_PHYSICAL_ADDRESS  Memory;
+  UINT64                Size;
+} EMU_SYSTEM_MEMORY;
+
+
+#define MAX_IMAGE_CONTEXT_TO_MOD_HANDLE_ARRAY_SIZE 0x100
+
+typedef struct {
+  PE_COFF_LOADER_IMAGE_CONTEXT   *ImageContext;
+  VOID                           *ModHandle;
+} IMAGE_CONTEXT_TO_MOD_HANDLE;
+
+
+EFI_STATUS
+EFIAPI
+SecUnixPeiLoadFile (
+  VOID                  *Pe32Data,  
+  EFI_PHYSICAL_ADDRESS  *ImageAddress,  
+  UINT64                *ImageSize,  
+  EFI_PHYSICAL_ADDRESS  *EntryPoint  
+  );
+
+int
+main (
+  IN  int   Argc,
+  IN  char  **Argv,
+  IN  char  **Envp
+  );
+
+VOID
+SecLoadFromCore (
+  IN  UINTN   LargestRegion,
+  IN  UINTN   LargestRegionSize,
+  IN  UINTN   BootFirmwareVolumeBase,
+  IN  VOID    *PeiCoreFile
+  );
+
+EFI_STATUS
+SecLoadFile (
+  IN  VOID                    *Pe32Data,
+  IN  EFI_PHYSICAL_ADDRESS    *ImageAddress,
+  IN  UINT64                  *ImageSize,
+  IN  EFI_PHYSICAL_ADDRESS    *EntryPoint
+  );
+
+EFI_STATUS
+SecFfsFindPeiCore (
+  IN  EFI_FIRMWARE_VOLUME_HEADER  *FwVolHeader,
+  OUT VOID                        **Pe32Data
+  );
+
+EFI_STATUS
+SecFfsFindNextFile (
+  IN EFI_FV_FILETYPE             SearchType,
+  IN EFI_FIRMWARE_VOLUME_HEADER  *FwVolHeader,
+  IN OUT EFI_FFS_FILE_HEADER     **FileHeader
+  );
+
+EFI_STATUS
+SecFfsFindSectionData (
+  IN EFI_SECTION_TYPE      SectionType,
+  IN EFI_FFS_FILE_HEADER   *FfsFileHeader,
+  IN OUT VOID              **SectionData
+  );
+
+EFI_STATUS
+EFIAPI
+SecUnixPeCoffLoaderLoadAsDll (
+  IN CHAR8    *PdbFileName,
+  IN VOID     **ImageEntryPoint,
+  OUT VOID    **ModHandle
+  );
+
+EFI_STATUS
+EFIAPI
+SecUnixPeCoffLoaderFreeLibrary (
+  OUT VOID    *ModHandle
+  );
+
+EFI_STATUS
+EFIAPI
+SecUnixFdAddress (
+  IN     UINTN                 Index,
+  IN OUT EFI_PHYSICAL_ADDRESS  *FdBase,
+  IN OUT UINT64                *FdSize,
+  IN OUT EFI_PHYSICAL_ADDRESS  *FixUp
+  )
+;
+
+EFI_STATUS
+EFIAPI
+GasketSecUnixFdAddress (
+  IN     UINTN                 Index,
+  IN OUT EFI_PHYSICAL_ADDRESS  *FdBase,
+  IN OUT UINT64                *FdSize,
+  IN OUT EFI_PHYSICAL_ADDRESS  *FixUp
+  )
+;
+
+
+EFI_STATUS
+GetImageReadFunction (
+  IN PE_COFF_LOADER_IMAGE_CONTEXT          *ImageContext,
+  IN EFI_PHYSICAL_ADDRESS                  *TopOfMemory
+  );
+
+EFI_STATUS
+EFIAPI
+SecImageRead (
+  IN     VOID    *FileHandle,
+  IN     UINTN   FileOffset,
+  IN OUT UINTN   *ReadSize,
+  OUT    VOID    *Buffer
+  );
+
+CHAR16                            *
+AsciiToUnicode (
+  IN  CHAR8   *Ascii,
+  IN  UINTN   *StrLen OPTIONAL
+  );
+
+UINTN
+CountSeperatorsInString (
+  IN  const CHAR16   *String,
+  IN  CHAR16   Seperator
+  );
+
+EFI_STATUS
+EFIAPI
+SecTemporaryRamSupport (
+  IN CONST EFI_PEI_SERVICES   **PeiServices,
+  IN EFI_PHYSICAL_ADDRESS     TemporaryMemoryBase,
+  IN EFI_PHYSICAL_ADDRESS     PermanentMemoryBase,
+  IN UINTN                    CopySize
+  );
+  
+EFI_STATUS
+EFIAPI
+GasketSecTemporaryRamSupport (
+  IN CONST EFI_PEI_SERVICES   **PeiServices,
+  IN EFI_PHYSICAL_ADDRESS     TemporaryMemoryBase,
+  IN EFI_PHYSICAL_ADDRESS     PermanentMemoryBase,
+  IN UINTN                    CopySize
+  );
+
+
+RETURN_STATUS
+EFIAPI
+SecPeCoffGetEntryPoint (
+  IN     VOID  *Pe32Data,
+  IN OUT VOID  **EntryPoint
+  );
+
+VOID
+EFIAPI
+SecPeCoffRelocateImageExtraAction (
+  IN OUT PE_COFF_LOADER_IMAGE_CONTEXT  *ImageContext
+  );
+
+VOID
+EFIAPI
+SecPeCoffLoaderUnloadImageExtraAction (
+  IN OUT PE_COFF_LOADER_IMAGE_CONTEXT  *ImageContext
+  );
+
+
+VOID
+EFIAPI
+PeiSwitchStacks (
+  IN      SWITCH_STACK_ENTRY_POINT  EntryPoint,
+  IN      VOID                      *Context1,  OPTIONAL
+  IN      VOID                      *Context2,  OPTIONAL
+  IN      VOID                      *Context3,  OPTIONAL
+  IN      VOID                      *NewStack
+  );
+
+VOID
+SecInitThunkProtocol (
+  VOID
+  );
+  
+
+VOID SecSleep (UINT64 Milliseconds);
+VOID SecEnableInterrupt (VOID);
+VOID SecDisableInterrupt (VOID);
+BOOLEAN SecInterruptEanbled (VOID);
+
+
+extern EMU_THUNK_PROTOCOL    gEmuThunkProtocol;
+extern EMU_IO_THUNK_PROTOCOL gX11ThunkIo;
+extern EMU_IO_THUNK_PROTOCOL gPosixFileSystemThunkIo;
+extern EMU_IO_THUNK_PROTOCOL gPthreadThunkIo;
+
+
+#endif

InOsEmuPkg/Unix/Sec/SecMain.inf

@@ -0,0 +1,118 @@
+## @file
+# Entry Point of Emu Emulator
+#
+# Main executable file of Unix Emulator that loads PEI core after initialization finished.
+# Copyright (c) 2008 - 2010, Intel Corporation. All rights reserved.<BR>
+# Portions copyright (c) 2008 - 2011, Apple Inc. All rights reserved.<BR>
+#
+#  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                      = 8863C0AD-7724-C84B-88E5-A33B116D1485
+  MODULE_TYPE                    = USER_DEFINED
+#  MODULE_TYPE                    = BASE
+  VERSION_STRING                 = 1.0
+
+#
+# The following information is for reference only and not required by the build tools.
+#
+#  VALID_ARCHITECTURES           = IA32 X64 IPF EBC
+#
+
+[Sources]
+  SecMain.c
+  EmuThunk.c
+  FwVol.c
+  X11GraphicsWindow.c
+  Pthreads.c
+  PosixFileSystem.c
+
+[Sources.X64]
+  X64/Gasket.S        # convert between Emu x86_64 ABI and EFI X64 ABI
+  X64/SwitchStack.S
+
+
+[Packages]
+  MdePkg/MdePkg.dec
+  MdeModulePkg/MdeModulePkg.dec
+  InOsEmuPkg/InOsEmuPkg.dec
+  InOsEmuPkg/InOsEmuPkg.dec
+
+[LibraryClasses]
+  DebugLib
+  PcdLib
+  PrintLib
+  BaseMemoryLib
+  BaseLib
+  PeCoffLib
+  ThunkPpiList
+  ThunkProtocolList
+
+
+[Ppis]
+  gEfiPeiStatusCodePpiGuid                      # PPI ALWAYS_PRODUCED
+  gEfiTemporaryRamSupportPpiGuid
+  gEmuThunkPpiGuid
+  gEmuPeiServicesTableUpdatePpiGuid
+
+[Protocols]
+  gEmuIoThunkProtocolGuid
+  gEmuIoThunkProtocolGuid
+  gEmuGraphicsWindowProtocolGuid
+  gEmuPthreadThunkProtocolGuid
+  gEfiSimpleFileSystemProtocolGuid
+  
+
+[Guids]
+  gEfiFileSystemVolumeLabelInfoIdGuid           # SOMETIMES_CONSUMED
+  gEfiFileInfoGuid                              # SOMETIMES_CONSUMED
+  gEfiFileSystemInfoGuid                        # SOMETIMES_CONSUMED
+
+[Pcd]
+  gInOsEmuPkgTokenSpaceGuid.PcdEmuBootMode
+  gInOsEmuPkgTokenSpaceGuid.PcdEmuFirmwareVolume
+  gInOsEmuPkgTokenSpaceGuid.PcdEmuMemorySize
+  gInOsEmuPkgTokenSpaceGuid.PcdEmuFdBaseAddress
+  gInOsEmuPkgTokenSpaceGuid.PcdEmuFirmwareFdSize
+  gInOsEmuPkgTokenSpaceGuid.PcdEmuFirmwareBlockSize
+  gInOsEmuPkgTokenSpaceGuid.PcdEmuApCount
+  gInOsEmuPkgTokenSpaceGuid.PcdEmuPhysicalDisk
+  gInOsEmuPkgTokenSpaceGuid.PcdEmuVirtualDisk
+  gInOsEmuPkgTokenSpaceGuid.PcdEmuGop|L"GOP Window"
+  gInOsEmuPkgTokenSpaceGuid.PcdEmuFileSystem
+  gInOsEmuPkgTokenSpaceGuid.PcdEmuSerialPort
+  gInOsEmuPkgTokenSpaceGuid.PcdEmuNetworkInterface
+
+
+[BuildOptions]
+   GCC:*_*_IA32_DLINK_FLAGS == -o $(BIN_DIR)/SecMain -m elf_i386 -dynamic-linker /lib/ld-linux.so.2 /usr/lib/crt1.o /usr/lib/crti.o -L/usr/X11R6/lib -lXext -lX11 /usr/lib/crtn.o
+   GCC:*_*_*_DLINK2_FLAGS == -lc
+   GCC:*_*_IA32_CC_FLAGS == -m32 -g -fshort-wchar -fno-strict-aliasing -Wall -malign-double -idirafter/usr/include -c -include $(DEST_DIR_DEBUG)/AutoGen.h -DSTRING_ARRAY_NAME=$(BASE_NAME)Strings
+   GCC:*_*_IA32_PP_FLAGS == -m32 -E -x assembler-with-cpp -include $(DEST_DIR_DEBUG)/AutoGen.h
+   GCC:*_*_IA32_ASM_FLAGS == -m32 -c -x assembler -imacros $(DEST_DIR_DEBUG)/AutoGen.h
+
+   GCC:*_*_X64_DLINK_FLAGS == -o $(BIN_DIR)/SecMain -m elf_x86_64 -dynamic-linker /lib64/ld-linux-x86-64.so.2 /usr/lib/crt1.o /usr/lib/crti.o -L/usr/X11R6/lib -lXext -lX11 /usr/lib/crtn.o
+   GCC:*_*_X64_CC_FLAGS == -m64 -g -fshort-wchar -fno-strict-aliasing -Wall -malign-double -idirafter/usr/include -c -include $(DEST_DIR_DEBUG)/AutoGen.h -DSTRING_ARRAY_NAME=$(BASE_NAME)Strings
+   GCC:*_*_X64_PP_FLAGS == -m64 -E -x assembler-with-cpp -include $(DEST_DIR_DEBUG)/AutoGen.h
+   GCC:*_*_X64_ASM_FLAGS == -m64 -c -x assembler -imacros $(DEST_DIR_DEBUG)/AutoGen.h
+
+#
+# Need to do this link via gcc and not ld as the pathing to libraries changes from OS version to OS version
+#
+   XCODE:*_*_IA32_DLINK_PATH == gcc
+   XCODE:*_*_IA32_DLINK_FLAGS == -arch i386 -o $(BIN_DIR)/SecMain -L/usr/X11R6/lib -lXext -lX11 -framework IOKit -framework Carbon
+   XCODE:*_*_IA32_ASM_FLAGS == -arch i386 -g
+
+   XCODE:*_*_X64_DLINK_PATH == gcc
+   XCODE:*_*_X64_DLINK_FLAGS == -o $(BIN_DIR)/SecMain -L/usr/X11R6/lib -lXext -lX11 -lIOKit -framework Carbon
+   XCODE:*_*_X64_ASM_FLAGS == -g

InOsEmuPkg/Unix/Sec/X11GraphicsWindow.c

@@ -0,0 +1,976 @@
+/*++ @file
+
+Copyright (c) 2004 - 2009, Intel Corporation. All rights reserved.<BR>
+Portions copyright (c) 2008 - 2011, Apple Inc. All rights reserved.<BR>
+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.             
+
+**/
+
+#include "SecMain.h"
+
+#include <sys/ipc.h>
+#include <sys/shm.h>
+
+#include <X11/Xlib.h>
+#include <X11/Xutil.h>
+#include <X11/Xos.h>
+#include <X11/extensions/XShm.h>
+#include <X11/keysym.h>
+#include <X11/cursorfont.h>
+
+#define KEYSYM_LOWER  0
+#define KEYSYM_UPPER  1
+
+/* XQueryPointer  */
+
+struct uga_drv_shift_mask {
+  unsigned char shift;
+  unsigned char size;
+  unsigned char csize;
+};
+
+#define NBR_KEYS 32
+typedef struct {
+  EMU_GRAPHICS_WINDOW_PROTOCOL GraphicsIo;
+
+  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_KEY_DATA keys[NBR_KEYS];
+
+  EFI_KEY_STATE KeyState;
+  
+  EMU_GRAPHICS_WINDOW_REGISTER_KEY_NOTIFY_CALLBACK    MakeRegisterdKeyCallback;
+  EMU_GRAPHICS_WINDOW_REGISTER_KEY_NOTIFY_CALLBACK    BreakRegisterdKeyCallback;
+  VOID                                                *RegisterdKeyCallbackContext;
+  
+  int                        previous_x;
+  int                        previous_y;
+  EFI_SIMPLE_POINTER_STATE   pointer_state;
+  int                        pointer_state_changed;
+} GRAPHICS_IO_PRIVATE;
+
+void
+HandleEvents(GRAPHICS_IO_PRIVATE *drv);
+
+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;
+}
+
+int
+TryCreateShmImage (
+  IN  GRAPHICS_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;
+  }
+  
+#ifndef __APPLE__  
+  //
+  // This closes shared memory in real time on OS X. Only closes after folks quit using
+  // it on Linux. 
+  //
+  /* Can this fail ?  */
+  shmctl (drv->xshm_info.shmid, IPC_RMID, NULL);
+#endif
+
+  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;
+}
+
+
+EFI_STATUS
+X11Size(
+  IN  EMU_GRAPHICS_WINDOW_PROTOCOL  *GraphicsIo, 
+  IN  UINT32                        Width, 
+  IN  UINT32                        Height
+  )
+{
+  GRAPHICS_IO_PRIVATE *drv = (GRAPHICS_IO_PRIVATE *)GraphicsIo;
+  XSizeHints size_hints;
+
+  /* Destroy current buffer if created.  */
+  if (drv->image != NULL)
+    {
+      /* Before destroy buffer, need to make sure the buffer available for access. */
+      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;
+}
+
+void
+handleKeyEvent(GRAPHICS_IO_PRIVATE *drv, XEvent *ev, BOOLEAN Make)
+{
+  KeySym        *KeySym;
+  EFI_KEY_DATA  KeyData;
+  int           KeySymArraySize;
+ 
+  if (Make) {
+    if (drv->key_count == NBR_KEYS) {
+      return;
+    }
+  }
+
+  // keycode is a physical key on the keyboard
+  // KeySym is a mapping of a physical key
+  // KeyboardMapping is the array of KeySym for a given keycode. key, shifted key, option key, command key, ...
+  //
+  // Returns an array of KeySymArraySize of KeySym for the keycode. [0] is lower case, [1] is upper case,
+  // [2] and [3] are based on option and command modifiers. The problem we have is command V
+  // could be mapped to a crazy Unicode character so the old scheme of returning a string. 
+  //
+  KeySym = XGetKeyboardMapping (drv->display, ev->xkey.keycode, 1, &KeySymArraySize);
+   
+  KeyData.Key.ScanCode = 0;
+  KeyData.Key.UnicodeChar = 0;
+  KeyData.KeyState.KeyShiftState = 0;
+
+  //
+  // Skipping EFI_SCROLL_LOCK_ACTIVE & EFI_NUM_LOCK_ACTIVE since they are not on Macs  
+  //
+  if ((ev->xkey.state & LockMask) == 0) {
+    drv->KeyState.KeyToggleState &= ~EFI_CAPS_LOCK_ACTIVE;
+  } else {
+    if (Make) {
+      drv->KeyState.KeyToggleState |= EFI_CAPS_LOCK_ACTIVE;
+    }
+  }
+  
+  // Skipping EFI_MENU_KEY_PRESSED and EFI_SYS_REQ_PRESSED
+  
+  switch (*KeySym) {
+  case XK_Control_R:
+    if (Make) {
+      drv->KeyState.KeyShiftState |=  EFI_RIGHT_CONTROL_PRESSED;
+    } else {
+      drv->KeyState.KeyShiftState &= ~EFI_RIGHT_CONTROL_PRESSED;
+    }
+   break;
+  case XK_Control_L:
+    if (Make) {    
+      drv->KeyState.KeyShiftState |=  EFI_LEFT_CONTROL_PRESSED;
+    } else {
+      drv->KeyState.KeyShiftState &= ~EFI_LEFT_CONTROL_PRESSED;
+    }
+    break;
+
+  case XK_Shift_R:
+    if (Make) {
+      drv->KeyState.KeyShiftState |=  EFI_RIGHT_SHIFT_PRESSED;
+    } else {
+      drv->KeyState.KeyShiftState &= ~EFI_RIGHT_SHIFT_PRESSED;
+    }
+    break;
+  case XK_Shift_L:
+    if (Make) {
+      drv->KeyState.KeyShiftState |=  EFI_LEFT_SHIFT_PRESSED;
+    } else {
+      drv->KeyState.KeyShiftState &= ~EFI_LEFT_SHIFT_PRESSED;
+    }
+    break;
+  
+  case XK_Mode_switch:
+    if (Make) {
+      drv->KeyState.KeyShiftState |=  EFI_LEFT_ALT_PRESSED;
+    } else {
+      drv->KeyState.KeyShiftState &= ~EFI_LEFT_ALT_PRESSED;
+    }
+    break;
+
+  case XK_Meta_R:
+    if (Make) {
+      drv->KeyState.KeyShiftState |=  EFI_RIGHT_LOGO_PRESSED;
+    } else {
+      drv->KeyState.KeyShiftState &= ~EFI_RIGHT_LOGO_PRESSED;
+    }
+    break;
+  case XK_Meta_L:
+    if (Make) {
+      drv->KeyState.KeyShiftState |=  EFI_LEFT_LOGO_PRESSED;
+    } else {
+      drv->KeyState.KeyShiftState &= ~EFI_LEFT_LOGO_PRESSED;
+    }
+    break;
+  
+  case XK_KP_Home:
+  case XK_Home:       KeyData.Key.ScanCode = SCAN_HOME;       break;
+  
+  case XK_KP_End:
+  case XK_End:        KeyData.Key.ScanCode = SCAN_END;        break;
+  
+  case XK_KP_Left: 
+  case XK_Left:       KeyData.Key.ScanCode = SCAN_LEFT;       break;
+  
+  case XK_KP_Right:
+  case XK_Right:      KeyData.Key.ScanCode = SCAN_RIGHT;      break;
+  
+  case XK_KP_Up:
+  case XK_Up:         KeyData.Key.ScanCode = SCAN_UP;         break;
+  
+  case XK_KP_Down:
+  case XK_Down:       KeyData.Key.ScanCode = SCAN_DOWN;       break;
+  
+  case XK_KP_Delete:
+  case XK_Delete:       KeyData.Key.ScanCode = SCAN_DELETE;     break;
+  
+  case XK_KP_Insert:  
+  case XK_Insert:     KeyData.Key.ScanCode = SCAN_INSERT;     break;
+  
+  case XK_KP_Page_Up:
+  case XK_Page_Up:    KeyData.Key.ScanCode = SCAN_PAGE_UP;    break;
+  
+  case XK_KP_Page_Down:
+  case XK_Page_Down:  KeyData.Key.ScanCode = SCAN_PAGE_DOWN;  break;
+  
+  case XK_Escape:     KeyData.Key.ScanCode = SCAN_ESC;        break;
+
+  
+  case XK_KP_F1:
+  case XK_F1:   KeyData.Key.ScanCode = SCAN_F1;   break;
+  
+  case XK_KP_F2:
+  case XK_F2:   KeyData.Key.ScanCode = SCAN_F2;   break;
+
+  case XK_KP_F3:
+  case XK_F3:   KeyData.Key.ScanCode = SCAN_F3;   break;
+
+  case XK_KP_F4:
+  case XK_F4:   KeyData.Key.ScanCode = SCAN_F4;   break;
+
+  case XK_F5:   KeyData.Key.ScanCode = SCAN_F5;   break;
+  case XK_F6:   KeyData.Key.ScanCode = SCAN_F6;   break;
+  case XK_F7:   KeyData.Key.ScanCode = SCAN_F7;   break;
+  
+  // Don't map into X11 by default on a Mac
+  // System Preferences->Keyboard->Keyboard Shortcuts can be configured 
+  // to not use higher function keys as shortcuts and the will show up
+  // in X11. 
+  case XK_F8:   KeyData.Key.ScanCode = SCAN_F8;   break;
+  case XK_F9:   KeyData.Key.ScanCode = SCAN_F9;   break;
+  case XK_F10:  KeyData.Key.ScanCode = SCAN_F10;  break;
+  
+  case XK_F11:  KeyData.Key.ScanCode = SCAN_F11;  break;
+  case XK_F12:  KeyData.Key.ScanCode = SCAN_F12;  break;
+  
+  case XK_F13:  KeyData.Key.ScanCode = SCAN_F13;  break;
+  case XK_F14:  KeyData.Key.ScanCode = SCAN_F14;  break;
+  case XK_F15:  KeyData.Key.ScanCode = SCAN_F15;  break;
+  case XK_F16:  KeyData.Key.ScanCode = SCAN_F16;  break;
+  case XK_F17:  KeyData.Key.ScanCode = SCAN_F17;  break;
+  case XK_F18:  KeyData.Key.ScanCode = SCAN_F18;  break;
+  case XK_F19:  KeyData.Key.ScanCode = SCAN_F19;  break;
+  case XK_F20:  KeyData.Key.ScanCode = SCAN_F20;  break;
+  case XK_F21:  KeyData.Key.ScanCode = SCAN_F21;  break;
+  case XK_F22:  KeyData.Key.ScanCode = SCAN_F22;  break;
+  case XK_F23:  KeyData.Key.ScanCode = SCAN_F23;  break;
+  case XK_F24:  KeyData.Key.ScanCode = SCAN_F24;  break;
+
+  // No mapping in X11
+  //case XK_:   KeyData.Key.ScanCode = SCAN_MUTE;            break;             
+  //case XK_:   KeyData.Key.ScanCode = SCAN_VOLUME_UP;       break;            
+  //case XK_:   KeyData.Key.ScanCode = SCAN_VOLUME_DOWN;     break;       
+  //case XK_:   KeyData.Key.ScanCode = SCAN_BRIGHTNESS_UP;   break;      
+  //case XK_:   KeyData.Key.ScanCode = SCAN_BRIGHTNESS_DOWN; break;    
+  //case XK_:   KeyData.Key.ScanCode = SCAN_SUSPEND;         break; 
+  //case XK_:   KeyData.Key.ScanCode = SCAN_HIBERNATE;       break; 
+  //case XK_:   KeyData.Key.ScanCode = SCAN_TOGGLE_DISPLAY;  break;       
+  //case XK_:   KeyData.Key.ScanCode = SCAN_RECOVERY;        break;      
+  //case XK_:   KeyData.Key.ScanCode = SCAN_EJECT;           break;     
+
+  case XK_BackSpace:  KeyData.Key.UnicodeChar = 0x0008; break;
+
+  case XK_KP_Tab:
+  case XK_Tab:        KeyData.Key.UnicodeChar = 0x0009; break;
+
+  case XK_Linefeed:   KeyData.Key.UnicodeChar = 0x000a; break;
+  
+  case XK_KP_Enter:
+  case XK_Return:     KeyData.Key.UnicodeChar = 0x000d; break;
+
+  case XK_KP_Equal      : KeyData.Key.UnicodeChar = L'='; break;                     
+  case XK_KP_Multiply   : KeyData.Key.UnicodeChar = L'*'; break;                  
+  case XK_KP_Add        : KeyData.Key.UnicodeChar = L'+'; break;                       
+  case XK_KP_Separator  : KeyData.Key.UnicodeChar = L'~'; break;                  
+  case XK_KP_Subtract   : KeyData.Key.UnicodeChar = L'-'; break;                  
+  case XK_KP_Decimal    : KeyData.Key.UnicodeChar = L'.'; break;                   
+  case XK_KP_Divide     : KeyData.Key.UnicodeChar = L'/'; break;                    
+
+  case XK_KP_0    : KeyData.Key.UnicodeChar = L'0'; break;                         
+  case XK_KP_1    : KeyData.Key.UnicodeChar = L'1'; break;                         
+  case XK_KP_2    : KeyData.Key.UnicodeChar = L'2'; break;                         
+  case XK_KP_3    : KeyData.Key.UnicodeChar = L'3'; break;                         
+  case XK_KP_4    : KeyData.Key.UnicodeChar = L'4'; break;                        
+  case XK_KP_5    : KeyData.Key.UnicodeChar = L'5'; break;                         
+  case XK_KP_6    : KeyData.Key.UnicodeChar = L'6'; break;                         
+  case XK_KP_7    : KeyData.Key.UnicodeChar = L'7'; break;                         
+  case XK_KP_8    : KeyData.Key.UnicodeChar = L'8'; break;                        
+  case XK_KP_9    : KeyData.Key.UnicodeChar = L'9'; break;                         
+
+  default:
+    ;
+  }
+
+  // The global state is our state
+  KeyData.KeyState.KeyShiftState = drv->KeyState.KeyShiftState;
+  KeyData.KeyState.KeyToggleState = drv->KeyState.KeyToggleState;
+
+  if (*KeySym < XK_BackSpace) {
+    if (((drv->KeyState.KeyShiftState & (EFI_LEFT_SHIFT_PRESSED | EFI_RIGHT_SHIFT_PRESSED)) != 0) ||
+        ((drv->KeyState.KeyToggleState & EFI_CAPS_LOCK_ACTIVE) != 0) ) {
+      
+      KeyData.Key.UnicodeChar = (CHAR16)KeySym[KEYSYM_UPPER];
+
+      // Per UEFI spec since we converted the Unicode clear the shift bits we pass up 
+      KeyData.KeyState.KeyShiftState &= ~(EFI_LEFT_SHIFT_PRESSED | EFI_RIGHT_SHIFT_PRESSED);
+    } else {
+      KeyData.Key.UnicodeChar = (CHAR16)KeySym[KEYSYM_LOWER];
+    }
+  } else {
+    // XK_BackSpace is the start of XK_MISCELLANY. These are the XK_? keys we process in this file 
+    ; 
+  }
+  
+  if (Make) {
+    memcpy (&drv->keys[drv->key_wr], &KeyData, sizeof (EFI_KEY_DATA));
+    drv->key_wr = (drv->key_wr + 1) % NBR_KEYS;
+    drv->key_count++; 
+    if (drv->MakeRegisterdKeyCallback != NULL) {
+      ReverseGasketUint64Uint64 (drv->MakeRegisterdKeyCallback ,drv->RegisterdKeyCallbackContext, &KeyData);
+    }
+  } else {
+    if (drv->BreakRegisterdKeyCallback != NULL) {
+      ReverseGasketUint64Uint64 (drv->BreakRegisterdKeyCallback ,drv->RegisterdKeyCallbackContext, &KeyData);
+    }
+  }
+}
+
+
+void
+handleMouseMoved(GRAPHICS_IO_PRIVATE *drv, XEvent *ev)
+{
+  if ( ev->xmotion.x != drv->previous_x )
+  {
+    drv->pointer_state.RelativeMovementX += ( ev->xmotion.x - drv->previous_x );
+  drv->previous_x = ev->xmotion.x;
+  drv->pointer_state_changed = 1;
+  }
+
+  if ( ev->xmotion.y != drv->previous_y )
+  {
+    drv->pointer_state.RelativeMovementY += ( ev->xmotion.y - drv->previous_y );
+    drv->previous_y = ev->xmotion.y;
+  drv->pointer_state_changed = 1;
+  }
+
+  drv->pointer_state.RelativeMovementZ = 0;
+}
+
+void
+handleMouseDown(GRAPHICS_IO_PRIVATE *drv, XEvent *ev, BOOLEAN Pressed)
+{
+  if ( ev->xbutton.button == Button1 )
+  {
+    drv->pointer_state_changed = ( drv->pointer_state.LeftButton != Pressed );
+  drv->pointer_state.LeftButton = Pressed;
+  }
+  if ( ev->xbutton.button == Button2 )
+  {
+    drv->pointer_state_changed = ( drv->pointer_state.RightButton != Pressed );
+  drv->pointer_state.RightButton = Pressed;
+  }
+}
+
+void
+Redraw(GRAPHICS_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);
+  XFlush(drv->display);
+}
+
+void
+HandleEvent(GRAPHICS_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, TRUE);
+      break;
+    case KeyRelease:
+      handleKeyEvent(drv, ev, FALSE);
+      break;
+    case MappingNotify:
+      XRefreshKeyboardMapping(&ev->xmapping);
+      break;
+    case MotionNotify:
+      handleMouseMoved(drv, ev);
+      break;
+    case ButtonPress:
+      handleMouseDown(drv, ev, TRUE);
+    break;
+    case ButtonRelease:
+      handleMouseDown(drv, ev, FALSE);
+    break;
+#if 0
+    case DestroyNotify:
+      XCloseDisplay (drv->display);
+      exit (1);
+      break;
+#endif
+    case NoExpose:
+    default:
+      break;
+    }
+}
+
+void
+HandleEvents(GRAPHICS_IO_PRIVATE *drv)
+{
+  while (XPending(drv->display) != 0)
+    {
+      XEvent ev;
+
+      XNextEvent (drv->display, &ev);
+      HandleEvent(drv, &ev);
+    }
+}
+
+unsigned long
+X11PixelToColor (GRAPHICS_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);
+}
+
+EFI_UGA_PIXEL
+X11ColorToPixel (GRAPHICS_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
+CheckKeyInternal( GRAPHICS_IO_PRIVATE *drv, BOOLEAN delay )
+{
+  HandleEvents(drv);
+  if (drv->key_count != 0)
+    return EFI_SUCCESS;
+  if ( delay )
+    /* EFI is polling.  Be CPU-friendly.  */
+    SecSleep (20);
+    return EFI_NOT_READY;
+  }
+
+EFI_STATUS
+X11CheckKey(EMU_GRAPHICS_WINDOW_PROTOCOL *GraphicsIo)
+{
+  GRAPHICS_IO_PRIVATE  *drv = (GRAPHICS_IO_PRIVATE *)GraphicsIo;
+  return CheckKeyInternal(drv, TRUE);
+}
+
+EFI_STATUS
+EFIAPI
+X11GetKey (
+  IN  EMU_GRAPHICS_WINDOW_PROTOCOL  *GraphicsIo, 
+  IN  EFI_KEY_DATA                   *KeyData
+  )
+{
+  GRAPHICS_IO_PRIVATE *drv = (GRAPHICS_IO_PRIVATE *)GraphicsIo;
+  EFI_STATUS status;
+
+  status = CheckKeyInternal(drv, FALSE);
+  if (status != EFI_SUCCESS)
+    return status;
+
+  CopyMem (KeyData, &drv->keys[drv->key_rd], sizeof (EFI_KEY_DATA));
+  drv->key_rd = (drv->key_rd + 1) % NBR_KEYS;
+  drv->key_count--;
+  return EFI_SUCCESS;
+}
+
+
+EFI_STATUS
+EFIAPI
+X11KeySetState (
+  IN EMU_GRAPHICS_WINDOW_PROTOCOL   *GraphicsIo, 
+  IN EFI_KEY_TOGGLE_STATE       *KeyToggleState
+  )
+{
+  GRAPHICS_IO_PRIVATE  *drv = (GRAPHICS_IO_PRIVATE *)GraphicsIo;
+//  XKeyEvent       event;
+  
+  if (*KeyToggleState & EFI_CAPS_LOCK_ACTIVE) {
+    if ((drv->KeyState.KeyToggleState & EFI_CAPS_LOCK_ACTIVE) == 0) {
+      //
+      // We could create an XKeyEvent and send a XK_Caps_Lock to
+      // the UGA/GOP Window
+      //
+    }
+  }
+    
+  drv->KeyState.KeyToggleState = *KeyToggleState;
+  return EFI_SUCCESS;
+}
+
+
+EFI_STATUS
+EFIAPI
+X11RegisterKeyNotify (
+  IN EMU_GRAPHICS_WINDOW_PROTOCOL                       *GraphicsIo, 
+  IN EMU_GRAPHICS_WINDOW_REGISTER_KEY_NOTIFY_CALLBACK    MakeCallBack,
+  IN EMU_GRAPHICS_WINDOW_REGISTER_KEY_NOTIFY_CALLBACK    BreakCallBack,
+  IN VOID                                                *Context
+  )
+{
+  GRAPHICS_IO_PRIVATE  *drv = (GRAPHICS_IO_PRIVATE *)GraphicsIo;
+
+  drv->MakeRegisterdKeyCallback         = MakeCallBack;
+  drv->BreakRegisterdKeyCallback        = BreakCallBack;
+  drv->RegisterdKeyCallbackContext = Context;
+
+  return EFI_SUCCESS;
+}
+
+
+EFI_STATUS
+X11Blt (
+  IN EMU_GRAPHICS_WINDOW_PROTOCOL             *GraphicsIo,
+  IN  EFI_UGA_PIXEL                           *BltBuffer OPTIONAL,
+  IN  EFI_UGA_BLT_OPERATION                   BltOperation,
+  IN  EMU_GRAPHICS_WINDOWS__BLT_ARGS          *Args
+  )
+{
+  GRAPHICS_IO_PRIVATE *Private = (GRAPHICS_IO_PRIVATE *)GraphicsIo;
+  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 (Args->SourceY + Args->Height > Private->height) {
+      return EFI_INVALID_PARAMETER;
+    }
+
+    if (Args->SourceX + Args->Width > Private->width) {
+      return EFI_INVALID_PARAMETER;
+    }
+  }
+
+  if (BltOperation == EfiUgaBltBufferToVideo
+      || BltOperation == EfiUgaVideoToVideo
+      || BltOperation == EfiUgaVideoFill) {
+    //
+    // Destination is Video
+    //
+    if (Args->DestinationY + Args->Height > Private->height) {
+      return EFI_INVALID_PARAMETER;
+    }
+
+    if (Args->DestinationX + Args->Width > Private->width) {
+      return EFI_INVALID_PARAMETER;
+    }
+  }
+
+  switch (BltOperation) {
+  case EfiUgaVideoToBltBuffer:
+    Blt = (EFI_UGA_PIXEL *)((UINT8 *)BltBuffer + (Args->DestinationY * Args->Delta) + Args->DestinationX * sizeof (EFI_UGA_PIXEL));
+    Args->Delta -= Args->Width * sizeof (EFI_UGA_PIXEL);
+    for (SrcY = Args->SourceY; SrcY < (Args->Height + Args->SourceY); SrcY++) {
+      for (SrcX = Args->SourceX; SrcX < (Args->Width + Args->SourceX); SrcX++) {
+        *Blt++ = X11ColorToPixel(Private,
+                                  XGetPixel(Private->image, SrcX, SrcY));
+      }
+      Blt = (EFI_UGA_PIXEL *) ((UINT8 *) Blt + Args->Delta);
+    }
+    break;
+  case EfiUgaBltBufferToVideo:
+    Blt = (EFI_UGA_PIXEL *)((UINT8 *)BltBuffer + (Args->SourceY * Args->Delta) + Args->SourceX * sizeof (EFI_UGA_PIXEL));
+    Args->Delta -= Args->Width * sizeof (EFI_UGA_PIXEL);
+    for (DstY = Args->DestinationY; DstY < (Args->Height + Args->DestinationY); DstY++) {
+      for (DstX = Args->DestinationX; DstX < (Args->Width + Args->DestinationX); DstX++) {
+        XPutPixel(Private->image, DstX, DstY, X11PixelToColor(Private, *Blt));
+        Blt++;
+      }
+      Blt = (EFI_UGA_PIXEL *) ((UINT8 *) Blt + Args->Delta);
+    }
+    break;
+  case EfiUgaVideoToVideo:
+    Dst = Private->image_data + (Args->DestinationX << Private->pixel_shift)
+      + Args->DestinationY * Private->line_bytes;
+    Src = Private->image_data + (Args->SourceX << Private->pixel_shift)
+      + Args->SourceY * Private->line_bytes;
+    Nbr = Args->Width << Private->pixel_shift;
+    if (Args->DestinationY < Args->SourceY) {
+      for (Index = 0; Index < Args->Height; Index++) {
+        memcpy (Dst, Src, Nbr);
+        Dst += Private->line_bytes;
+        Src += Private->line_bytes;
+      }
+    }
+    else {
+      Dst += (Args->Height - 1) * Private->line_bytes;
+      Src += (Args->Height - 1) * Private->line_bytes;
+      for (Index = 0; Index < Args->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 = X11PixelToColor(Private, *BltBuffer);
+    for (DstY = Args->DestinationY; DstY < (Args->Height + Args->DestinationY); DstY++) {
+      for (DstX = Args->DestinationX; DstX < (Args->Width + Args->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,
+               Args->SourceX, Args->SourceY, Args->Width, Args->Height, Args->DestinationX, Args->DestinationY);
+    while (1) {
+      XEvent ev;
+
+      XNextEvent (Private->display, &ev);
+      HandleEvent(Private, &ev);
+      if (ev.type == NoExpose || ev.type == GraphicsExpose)
+        break;
+    }
+    break;
+  case EfiUgaVideoFill:
+    Color = X11PixelToColor(Private, *BltBuffer);
+    XSetForeground(Private->display, Private->gc, Color);
+    XFillRectangle(Private->display, Private->win, Private->gc,
+                    Args->DestinationX, Args->DestinationY, Args->Width, Args->Height);
+    XFlush(Private->display);
+    break;
+  case EfiUgaBltBufferToVideo:
+    Redraw(Private, Args->DestinationX, Args->DestinationY, Args->Width, Args->Height);
+    break;
+  default:
+    break;
+  }
+  return EFI_SUCCESS;
+}
+
+STATIC EFI_STATUS
+CheckPointerInternal( GRAPHICS_IO_PRIVATE *drv, BOOLEAN delay )
+{
+  HandleEvents(drv);
+  if (drv->pointer_state_changed != 0)
+    return EFI_SUCCESS;
+  if ( delay )
+    /* EFI is polling.  Be CPU-friendly.  */
+    SecSleep (20);
+  return EFI_NOT_READY;
+}
+
+EFI_STATUS
+X11CheckPointer(EMU_GRAPHICS_WINDOW_PROTOCOL *GraphicsIo)
+{
+  GRAPHICS_IO_PRIVATE  *drv = (GRAPHICS_IO_PRIVATE *)GraphicsIo;
+  return( CheckPointerInternal( drv, TRUE ) );
+}
+
+EFI_STATUS
+X11GetPointerState (EMU_GRAPHICS_WINDOW_PROTOCOL *GraphicsIo, EFI_SIMPLE_POINTER_STATE *state)
+{
+  GRAPHICS_IO_PRIVATE *drv = (GRAPHICS_IO_PRIVATE *)GraphicsIo;
+  EFI_STATUS status;
+
+  status = CheckPointerInternal( drv, FALSE );
+  if (status != EFI_SUCCESS)
+    return status;
+  
+  memcpy( state, &drv->pointer_state, sizeof( EFI_SIMPLE_POINTER_STATE ) );
+
+  drv->pointer_state.RelativeMovementX = 0;
+  drv->pointer_state.RelativeMovementY = 0;
+  drv->pointer_state.RelativeMovementZ = 0;
+  drv->pointer_state_changed = 0;
+  return EFI_SUCCESS;
+}
+
+
+
+EFI_STATUS
+X11GraphicsWindowOpen (
+  IN  EMU_IO_THUNK_PROTOCOL   *This
+  )
+{
+  GRAPHICS_IO_PRIVATE *drv;
+  unsigned int border_width = 0;
+  char *display_name = NULL;
+  int title_len;
+
+  drv = (GRAPHICS_IO_PRIVATE *)calloc (1, sizeof (GRAPHICS_IO_PRIVATE));
+  if (drv == NULL)
+    return EFI_OUT_OF_RESOURCES;
+
+  drv->GraphicsIo.Size                = GasketX11Size;
+  drv->GraphicsIo.CheckKey            = GasketX11CheckKey;
+  drv->GraphicsIo.GetKey              = GasketX11GetKey;
+  drv->GraphicsIo.KeySetState         = GasketX11KeySetState;
+  drv->GraphicsIo.RegisterKeyNotify   = GasketX11RegisterKeyNotify;
+  drv->GraphicsIo.Blt                 = GasketX11Blt;
+  drv->GraphicsIo.CheckPointer        = GasketX11CheckPointer;
+  drv->GraphicsIo.GetPointerState     = GasketX11GetPointerState;
+  
+
+  drv->key_count = 0;
+  drv->key_rd = 0;
+  drv->key_wr = 0;
+  drv->KeyState.KeyShiftState      = EFI_SHIFT_STATE_VALID;
+  drv->KeyState.KeyToggleState     = EFI_TOGGLE_STATE_VALID;
+  drv->MakeRegisterdKeyCallback    = NULL;
+  drv->BreakRegisterdKeyCallback   = NULL;
+  drv->RegisterdKeyCallbackContext = NULL;
+  
+  
+  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,
+                WhitePixel (drv->display, drv->screen),
+                BlackPixel (drv->display, drv->screen));
+
+  drv->depth = DefaultDepth (drv->display, drv->screen);
+  XDefineCursor (drv->display, drv->win, XCreateFontCursor (drv->display, XC_pirate)); 
+
+  /* Compute title len and convert to Ascii.  */
+  for (title_len = 0; This->ConfigString[title_len] != 0; title_len++)
+    ;
+  {
+    char title[title_len + 1];
+    int i;
+    for (i = 0; i < title_len; i++)
+      title[i] = This->ConfigString[i];
+    title[i] = 0;
+    
+    XStoreName (drv->display, drv->win, title);
+  }
+
+//  XAutoRepeatOff (drv->display);
+  XSelectInput (drv->display, drv->win,
+                 ExposureMask | KeyPressMask | KeyReleaseMask | PointerMotionMask | ButtonPressMask | ButtonReleaseMask );
+  drv->gc = DefaultGC (drv->display, drv->screen);
+
+  This->Private   = (VOID *)drv;
+  This->Interface = (VOID *)drv;
+  return EFI_SUCCESS;
+}
+
+
+EFI_STATUS
+X11GraphicsWindowClose (
+  IN  EMU_IO_THUNK_PROTOCOL   *This
+  )
+{
+  GRAPHICS_IO_PRIVATE *drv = (GRAPHICS_IO_PRIVATE *)This->Private;
+
+  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);
+  
+#ifdef __APPLE__
+  // Free up the shared memory
+  shmctl (drv->xshm_info.shmid, IPC_RMID, NULL);
+#endif
+  
+  free(drv);
+  return EFI_SUCCESS;
+}
+
+
+EMU_IO_THUNK_PROTOCOL gX11ThunkIo = {
+  &gEmuGraphicsWindowProtocolGuid,
+  NULL,
+  NULL,
+  0,
+  GasketX11GraphicsWindowOpen,
+  GasketX11GraphicsWindowClose,
+  NULL
+};
+
+

InOsEmuPkg/Unix/Sec/X64/SwitchStack.S

@@ -0,0 +1,112 @@
+#------------------------------------------------------------------------------
+#
+# Copyright (c) 2006 - 2008, Intel Corporation. All rights reserved.<BR>
+# Portitions copyright (c) 2011, Apple Inc. 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.
+#
+#------------------------------------------------------------------------------
+
+
+#------------------------------------------------------------------------------
+# Routine Description:
+#
+#   Routine for switching stacks with 3 parameters EFI ABI
+#   Convert UNIX to EFI ABI
+#
+# Arguments:
+#
+#   (rdi) EntryPoint    - Entry point with new stack.
+#   (rsi) Context1      - Parameter1 for entry point. (rcx)
+#   (rdx) Context2      - Parameter2 for entry point. (rdx) 
+#   (rcx) Context3      - Parameter3 for entry point. (r8)
+#   (r8)  NewStack      - The pointer to new stack.
+#
+# Returns:
+#
+#   None
+#
+#------------------------------------------------------------------------------
+ASM_GLOBAL ASM_PFX(PeiSwitchStacks)
+ASM_PFX(PeiSwitchStacks):
+    pushq   $0            // tells gdb to stop unwinding frame
+    movq    %rsp, %rbp
+
+    movq    %r8,  %rsp
+    
+    movq    %rdi, %rax
+    movq    %rsi, %rcx
+    movq    %rcx, %r8    
+    
+    #
+    # Reserve space for register parameters (rcx, rdx, r8 & r9) on the stack,
+    # in case the callee wishes to spill them.
+    #
+    subq    $32, %rsp  // 32-byte shadow space plus alignment pad
+    call    *%rax
+
+  
+
+//  EFI_STATUS
+//  EFIAPI
+//  SecTemporaryRamSupport (
+//    IN CONST EFI_PEI_SERVICES   **PeiServices,         // %rcx
+//    IN EFI_PHYSICAL_ADDRESS     TemporaryMemoryBase,   // %rdx
+//    IN EFI_PHYSICAL_ADDRESS     PermanentMemoryBase,   // %r8 
+//    IN UINTN                    CopySize               // %r9
+//    )
+//
+ASM_GLOBAL ASM_PFX(GasketSecTemporaryRamSupport)
+ASM_PFX(GasketSecTemporaryRamSupport):
+  // Adjust callers %rbp to account for stack move
+  subq    %rdx, %rbp     // Calc offset of %rbp in Temp Memory
+  addq    %r8,  %rbp     // add in permanent base to offset
+  
+  pushq   %rbp           // stack frame is for the debugger
+  movq    %rsp, %rbp
+
+  pushq   %rsi          // %rsi & %rdi are volatile in Unix and callee-save in EFI ABI
+  pushq   %rdi
+
+  pushq   %rdx          // Save TemporaryMemoryBase
+  pushq   %r8           // Save PermanentMemoryBase
+  pushq   %r9           // Save CopySize
+  
+  //
+  // Copy all of temp RAM to permanent memory, including stack
+  //
+  // CopyMem (PermanentMemoryBase, TemporaryMemoryBase, CopySize);
+  //          %rdi,                %rsi,                %rdx
+  movq    %r8,  %rdi    // Swizzle args  
+  movq    %rdx, %rsi
+  movq    %r9,  %rdx
+  call    ASM_PFX(CopyMem)
+  // Temp mem stack now copied to permanent location. %esp still in temp memory
+  
+  popq    %r9           // CopySize (old stack)
+  popq    %r8           // PermanentMemoryBase (old stack)
+  popq    %rdx          // TemporaryMemoryBase (old stack)
+    
+  movq    %rsp, %rcx    // Move to new stack
+  subq    %rdx, %rcx    // Calc offset of stack in Temp Memory
+  addq    %r8,  %rcx    // Calc PermanentMemoryBase address
+  movq    %rcx, %rsp    // Update stack 
+  // Stack now points to permanent memory
+  
+  // ZeroMem (TemporaryMemoryBase /* rdi */, CopySize /* rsi */);
+  movq    %rdx, %rdi
+  movq    %r9,  %rsi
+  call    ASM_PFX(ZeroMem)
+
+  // This data comes off the NEW stack
+  popq    %rdi   
+  popq    %rsi
+  popq    %rbp
+  ret
+
+

InOsEmuPkg/Unix/UnixX64.dsc

@@ -0,0 +1,377 @@
+## @file
+#
+# EFI/Framework Emulation Platform with UEFI HII interface supported.
+#
+# The Emulation Platform can be used to debug individual modules, prior to creating
+#       a real platform. This also provides an example for how an DSC is created.
+# Copyright (c) 2006 - 2011, Intel Corporation. All rights reserved.<BR>
+# Portions copyright (c) 2010 - 2011, Apple Inc. All rights reserved.<BR>
+#
+#    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 Section - statements that will be processed to create a Makefile.
+#
+################################################################################
+[Defines]
+  PLATFORM_NAME                  = EmuUnix
+  PLATFORM_GUID                  = 05FD064D-1073-E844-936C-A0E16317107D
+  PLATFORM_VERSION               = 0.3
+  DSC_ SPECIFICATION             = 0x00010005
+  OUTPUT_DIRECTORY               = Build/EmuUnixX64
+  SUPPORTED_ARCHITECTURES        = X64
+  BUILD_TARGETS                  = DEBUG|RELEASE
+  SKUID_IDENTIFIER               = DEFAULT
+  FLASH_DEFINITION               = InOsEmuPkg/Unix/UnixX64.fdf
+
+################################################################################
+#
+# SKU Identification section - list of all SKU IDs supported by this Platform.
+#
+################################################################################
+[SkuIds]
+  0|DEFAULT
+
+################################################################################
+#
+# Library Class section - list of all Library Classes needed by this Platform.
+#
+################################################################################
+[LibraryClasses]
+  #
+  # Entry point
+  #
+  PeiCoreEntryPoint|MdePkg/Library/PeiCoreEntryPoint/PeiCoreEntryPoint.inf
+  PeimEntryPoint|MdePkg/Library/PeimEntryPoint/PeimEntryPoint.inf
+  DxeCoreEntryPoint|MdePkg/Library/DxeCoreEntryPoint/DxeCoreEntryPoint.inf
+  UefiDriverEntryPoint|MdePkg/Library/UefiDriverEntryPoint/UefiDriverEntryPoint.inf
+  UefiApplicationEntryPoint|MdePkg/Library/UefiApplicationEntryPoint/UefiApplicationEntryPoint.inf
+  #
+  # Basic
+  #
+  BaseLib|MdePkg/Library/BaseLib/BaseLib.inf
+  SynchronizationLib|MdePkg/Library/BaseSynchronizationLib/BaseSynchronizationLib.inf
+  PrintLib|MdePkg/Library/BasePrintLib/BasePrintLib.inf
+  CacheMaintenanceLib|MdePkg/Library/BaseCacheMaintenanceLib/BaseCacheMaintenanceLib.inf
+  PeCoffLib|MdePkg/Library/BasePeCoffLib/BasePeCoffLib.inf
+  PeCoffGetEntryPointLib|MdePkg/Library/BasePeCoffGetEntryPointLib/BasePeCoffGetEntryPointLib.inf
+  BaseMemoryLib|MdePkg/Library/BaseMemoryLib/BaseMemoryLib.inf
+
+  #
+  # UEFI & PI
+  #
+  UefiBootServicesTableLib|MdePkg/Library/UefiBootServicesTableLib/UefiBootServicesTableLib.inf
+  UefiRuntimeServicesTableLib|MdePkg/Library/UefiRuntimeServicesTableLib/UefiRuntimeServicesTableLib.inf
+  UefiRuntimeLib|MdePkg/Library/UefiRuntimeLib/UefiRuntimeLib.inf
+  UefiLib|MdePkg/Library/UefiLib/UefiLib.inf
+  UefiHiiServicesLib|MdeModulePkg/Library/UefiHiiServicesLib/UefiHiiServicesLib.inf
+  HiiLib|MdeModulePkg/Library/UefiHiiLib/UefiHiiLib.inf
+  DevicePathLib|MdePkg/Library/UefiDevicePathLib/UefiDevicePathLib.inf
+  UefiDecompressLib|IntelFrameworkModulePkg/Library/BaseUefiTianoCustomDecompressLib/BaseUefiTianoCustomDecompressLib.inf
+
+  PeiServicesLib|MdePkg/Library/PeiServicesLib/PeiServicesLib.inf
+  DxeServicesLib|MdePkg/Library/DxeServicesLib/DxeServicesLib.inf
+  DxeServicesTableLib|MdePkg/Library/DxeServicesTableLib/DxeServicesTableLib.inf
+  #
+  # Generic Modules
+  #
+  UefiScsiLib|MdePkg/Library/UefiScsiLib/UefiScsiLib.inf
+  NetLib|MdeModulePkg/Library/DxeNetLib/DxeNetLib.inf
+  IpIoLib|MdeModulePkg/Library/DxeIpIoLib/DxeIpIoLib.inf
+  UdpIoLib|MdeModulePkg/Library/DxeUdpIoLib/DxeUdpIoLib.inf
+  DpcLib|MdeModulePkg/Library/DxeDpcLib/DxeDpcLib.inf
+  OemHookStatusCodeLib|MdeModulePkg/Library/OemHookStatusCodeLibNull/OemHookStatusCodeLibNull.inf
+  GenericBdsLib|IntelFrameworkModulePkg/Library/GenericBdsLib/GenericBdsLib.inf
+  SecurityManagementLib|MdeModulePkg/Library/DxeSecurityManagementLib/DxeSecurityManagementLib.inf
+  TimerLib|MdePkg/Library/BaseTimerLibNullTemplate/BaseTimerLibNullTemplate.inf
+  SerialPortLib|MdePkg/Library/BaseSerialPortLibNull/BaseSerialPortLibNull.inf
+  CapsuleLib|MdeModulePkg/Library/DxeCapsuleLibNull/DxeCapsuleLibNull.inf
+  #
+  # Platform
+  #
+  PlatformBdsLib|InOsEmuPkg/Library/EmuBdsLib/EmuBdsLib.inf
+  KeyMapLib|InOsEmuPkg/Library/KeyMapLibNull/KeyMapLibNull.inf
+  
+  #
+  # Misc
+  #
+  DebugPrintErrorLevelLib|MdePkg/Library/BaseDebugPrintErrorLevelLib/BaseDebugPrintErrorLevelLib.inf
+  PerformanceLib|MdePkg/Library/BasePerformanceLibNull/BasePerformanceLibNull.inf
+  DebugAgentLib|MdeModulePkg/Library/DebugAgentLibNull/DebugAgentLibNull.inf
+  DebugLib|MdePkg/Library/BaseDebugLibSerialPort/BaseDebugLibSerialPort.inf
+
+
+[LibraryClasses.common.USER_DEFINED, LibraryClasses.common.BASE]
+  DebugLib|MdePkg/Library/BaseDebugLibNull/BaseDebugLibNull.inf
+  PeCoffExtraActionLib|MdePkg/Library/BasePeCoffExtraActionLibNull/BasePeCoffExtraActionLibNull.inf
+  MemoryAllocationLib|MdePkg/Library/PeiMemoryAllocationLib/PeiMemoryAllocationLib.inf
+  PcdLib|MdePkg/Library/BasePcdLibNull/BasePcdLibNull.inf
+  PeiServicesTablePointerLib|MdePkg/Library/PeiServicesTablePointerLib/PeiServicesTablePointerLib.inf
+
+  ThunkPpiList|InOsEmuPkg/Library/ThunkPpiList/ThunkPpiList.inf
+  ThunkProtocolList|InOsEmuPkg/Library/ThunkProtocolList/ThunkProtocolList.inf
+
+
+[LibraryClasses.common.PEIM, LibraryClasses.common.PEI_CORE]
+  HobLib|MdePkg/Library/PeiHobLib/PeiHobLib.inf
+  MemoryAllocationLib|MdePkg/Library/PeiMemoryAllocationLib/PeiMemoryAllocationLib.inf
+  ReportStatusCodeLib|MdeModulePkg/Library/PeiReportStatusCodeLib/PeiReportStatusCodeLib.inf
+  PeCoffGetEntryPointLib|InOsEmuPkg/Library/PeiEmuPeCoffGetEntryPointLib/PeiEmuPeCoffGetEntryPointLib.inf
+  PeCoffExtraActionLib|InOsEmuPkg/Library/PeiEmuPeCoffExtraActionLib/PeiEmuPeCoffExtraActionLib.inf
+  ExtractGuidedSectionLib|MdePkg/Library/PeiExtractGuidedSectionLib/PeiExtractGuidedSectionLib.inf
+
+[LibraryClasses.common.PEI_CORE]
+  PcdLib|MdePkg/Library/BasePcdLibNull/BasePcdLibNull.inf
+  PeiServicesTablePointerLib|InOsEmuPkg/Library/PeiCoreServicesTablePointerLib/PeiCoreServicesTablePointerLib.inf
+  SerialPortLib|InOsEmuPkg/Library/PeiEmuSerialPortLib/PeiEmuSerialPortLib.inf
+
+[LibraryClasses.common.PEIM]
+  PcdLib|MdePkg/Library/PeiPcdLib/PeiPcdLib.inf
+  PeiServicesTablePointerLib|InOsEmuPkg/Library/PeiServicesTablePointerLib/PeiServicesTablePointerLib.inf
+
+[LibraryClasses.common.DXE_CORE]
+  HobLib|MdePkg/Library/DxeCoreHobLib/DxeCoreHobLib.inf
+  MemoryAllocationLib|MdeModulePkg/Library/DxeCoreMemoryAllocationLib/DxeCoreMemoryAllocationLib.inf
+  ReportStatusCodeLib|MdeModulePkg/Library/DxeReportStatusCodeLib/DxeReportStatusCodeLib.inf
+  PeCoffExtraActionLib|InOsEmuPkg/Library/DxeEmuPeCoffExtraActionLib/DxeEmuPeCoffExtraActionLib.inf
+  ExtractGuidedSectionLib|MdePkg/Library/DxeExtractGuidedSectionLib/DxeExtractGuidedSectionLib.inf
+  PcdLib|MdePkg/Library/BasePcdLibNull/BasePcdLibNull.inf
+
+[LibraryClasses.common.DXE_RUNTIME_DRIVER, LibraryClasses.common.UEFI_DRIVER, LibraryClasses.common.DXE_DRIVER, LibraryClasses.common.UEFI_APPLICATION]
+  HobLib|MdePkg/Library/DxeHobLib/DxeHobLib.inf
+  PcdLib|MdePkg/Library/DxePcdLib/DxePcdLib.inf
+  MemoryAllocationLib|MdePkg/Library/UefiMemoryAllocationLib/UefiMemoryAllocationLib.inf
+  ReportStatusCodeLib|MdeModulePkg/Library/DxeReportStatusCodeLib/DxeReportStatusCodeLib.inf
+  EmuThunkLib|InOsEmuPkg/Library/DxeEmuLib/DxeEmuLib.inf
+  PeCoffExtraActionLib|InOsEmuPkg/Library/DxeEmuPeCoffExtraActionLib/DxeEmuPeCoffExtraActionLib.inf
+
+[LibraryClasses.common.UEFI_DRIVER]
+  PcdLib|MdePkg/Library/DxePcdLib/DxePcdLib.inf
+ 
+[LibraryClasses.common.UEFI_APPLICATION]
+  PcdLib|MdePkg/Library/BasePcdLibNull/BasePcdLibNull.inf
+
+
+################################################################################
+#
+# Pcd Section - list of all EDK II PCD Entries defined by this Platform.
+#
+################################################################################
+[PcdsFeatureFlag]
+  gEfiMdeModulePkgTokenSpaceGuid.PcdDxeIplSwitchToLongMode|FALSE
+  gEfiMdeModulePkgTokenSpaceGuid.PcdStatusCodeUseSerial|TRUE
+  gEfiMdeModulePkgTokenSpaceGuid.PcdPeiCoreImageLoaderSearchTeSectionFirst|FALSE
+  gEfiMdeModulePkgTokenSpaceGuid.PcdResetOnMemoryTypeInformationChange|FALSE
+
+[PcdsFixedAtBuild]
+  gEfiMdePkgTokenSpaceGuid.PcdDebugPrintErrorLevel|0x80000040
+  gEfiMdePkgTokenSpaceGuid.PcdReportStatusCodePropertyMask|0x0f
+  gEfiMdePkgTokenSpaceGuid.PcdDebugPropertyMask|0x1f
+  gEfiMdeModulePkgTokenSpaceGuid.PcdMaxSizeNonPopulateCapsule|0x0
+  gEfiMdeModulePkgTokenSpaceGuid.PcdMaxSizePopulateCapsule|0x0
+
+  gInOsEmuPkgTokenSpaceGuid.PcdEmuFirmwareFdSize|0x002a0000
+  gInOsEmuPkgTokenSpaceGuid.PcdEmuFirmwareBlockSize|0x10000
+  gInOsEmuPkgTokenSpaceGuid.PcdEmuFirmwareVolume|L"../Fv/Fv_Recovery.fd"
+  
+  gInOsEmuPkgTokenSpaceGuid.PcdEmuMemorySizeForSecMain|L"64!64"
+  
+#define BOOT_WITH_FULL_CONFIGURATION                  0x00
+#define BOOT_WITH_MINIMAL_CONFIGURATION               0x01
+#define BOOT_ASSUMING_NO_CONFIGURATION_CHANGES        0x02
+#define BOOT_WITH_FULL_CONFIGURATION_PLUS_DIAGNOSTICS 0x03
+#define BOOT_WITH_DEFAULT_SETTINGS                    0x04
+#define BOOT_ON_S4_RESUME                             0x05
+#define BOOT_ON_S5_RESUME                             0x06
+#define BOOT_ON_S2_RESUME                             0x10
+#define BOOT_ON_S3_RESUME                             0x11
+#define BOOT_ON_FLASH_UPDATE                          0x12
+#define BOOT_IN_RECOVERY_MODE                         0x20
+  gInOsEmuPkgTokenSpaceGuid.PcdEmuBootMode|0
+  
+  gInOsEmuPkgTokenSpaceGuid.PcdEmuApCount|L"0"
+
+  gInOsEmuPkgTokenSpaceGuid.PcdEmuPhysicalDisk|L"E:RW;245760;512"
+  gInOsEmuPkgTokenSpaceGuid.PcdEmuVirtualDisk|L"FW;40960;512"
+  gInOsEmuPkgTokenSpaceGuid.PcdEmuGop|L"GOP Window"
+  gInOsEmuPkgTokenSpaceGuid.PcdEmuFileSystem|L".!../../../../ShellBinPkg/UefiShell/X64!../../../../Build/Shell/DEBUG_XCLANG"
+  gInOsEmuPkgTokenSpaceGuid.PcdEmuSerialPort|L"/dev/ttyS0"
+  gInOsEmuPkgTokenSpaceGuid.PcdEmuNetworkInterface|L"en0"
+
+  gInOsEmuPkgTokenSpaceGuid.PcdEmuCpuModel|L"Intel(R) Processor Model"
+  gInOsEmuPkgTokenSpaceGuid.PcdEmuCpuSpeed|L"3000"
+
+################################################################################
+#
+# Pcd Dynamic Section - list of all EDK II PCD Entries defined by this Platform
+#
+################################################################################
+
+[PcdsDynamicDefault.common.DEFAULT]
+  gEfiMdeModulePkgTokenSpaceGuid.PcdFlashNvStorageFtwSpareBase64|0
+  gEfiMdeModulePkgTokenSpaceGuid.PcdFlashNvStorageFtwWorkingBase64|0
+  gEfiMdeModulePkgTokenSpaceGuid.PcdFlashNvStorageVariableBase64|0
+
+[PcdsDynamicHii.common.DEFAULT]
+  gEfiMdeModulePkgTokenSpaceGuid.PcdConOutColumn|L"Setup"|gEmuSystemConfigGuid|0x0|80
+  gEfiMdeModulePkgTokenSpaceGuid.PcdConOutRow|L"Setup"|gEmuSystemConfigGuid|0x4|25
+  gEfiIntelFrameworkModulePkgTokenSpaceGuid.PcdPlatformBootTimeOut|L"Timeout"|gEfiGlobalVariableGuid|0x0|10
+
+
+###################################################################################################
+#
+# Components Section - list of the modules and components that will be processed by compilation
+#                      tools and the EDK II tools to generate PE32/PE32+/Coff image files.
+#
+# Note: The EDK II DSC file is not used to specify how compiled binary images get placed
+#       into firmware volume images. This section is just a list of modules to compile from
+#       source into UEFI-compliant binaries.
+#       It is the FDF file that contains information on combining binary files into firmware
+#       volume images, whose concept is beyond UEFI and is described in PI specification.
+#       Binary modules do not need to be listed in this section, as they should be
+#       specified in the FDF file. For example: Shell binary (Shell_Full.efi), FAT binary (Fat.efi),
+#       Logo (Logo.bmp), and etc.
+#       There may also be modules listed in this section that are not required in the FDF file,
+#       When a module listed here is excluded from FDF file, then UEFI-compliant binary will be
+#       generated for it, but the binary will not be put into any firmware volume.
+#
+###################################################################################################
+[Components]
+!if $(SEC_ONLY)
+  ##
+  #  SEC Phase modules
+  ##
+  InOsEmuPkg/Unix/Sec/SecMain.inf
+!else
+  ##
+  #  PEI Phase modules
+  ##
+  MdeModulePkg/Core/Pei/PeiMain.inf
+  MdeModulePkg/Universal/PCD/Pei/Pcd.inf  {
+   <LibraryClasses>
+      PcdLib|MdePkg/Library/BasePcdLibNull/BasePcdLibNull.inf
+  }
+  MdeModulePkg/Universal/ReportStatusCodeRouter/Pei/ReportStatusCodeRouterPei.inf
+  MdeModulePkg/Universal/StatusCodeHandler/Pei/StatusCodeHandlerPei.inf {
+   <LibraryClasses>
+      SerialPortLib|InOsEmuPkg/Library/PeiEmuSerialPortLib/PeiEmuSerialPortLib.inf
+  }
+  
+  IntelFrameworkModulePkg/Universal/StatusCode/Pei/StatusCodePei.inf
+  InOsEmuPkg/BootModePei/BootModePei.inf
+  MdeModulePkg/Universal/Variable/Pei/VariablePei.inf
+  InOsEmuPkg/AutoScanPei/AutoScanPei.inf
+  InOsEmuPkg/FirmwareVolumePei/FirmwareVolumePei.inf
+  InOsEmuPkg/FlashMapPei/FlashMapPei.inf
+  InOsEmuPkg/ThunkPpiToProtocolPei/ThunkPpiToProtocolPei.inf
+  MdeModulePkg/Core/DxeIplPeim/DxeIpl.inf {
+    <LibraryClasses>
+      # turn off CR3 write so that DXE IPL will not crash emulator
+      BaseLib|UnixPkg/Library/UnixBaseLib/UnixBaseLib.inf
+  }
+
+  ##
+  #  DXE Phase modules
+  ##
+  MdeModulePkg/Core/Dxe/DxeMain.inf {
+    <LibraryClasses>
+      NULL|MdeModulePkg/Library/DxeCrc32GuidedSectionExtractLib/DxeCrc32GuidedSectionExtractLib.inf
+      NULL|IntelFrameworkModulePkg/Library/LzmaCustomDecompressLib/LzmaCustomDecompressLib.inf
+  }
+  MdeModulePkg/Universal/PCD/Dxe/Pcd.inf {
+    <LibraryClasses>
+      PcdLib|MdePkg/Library/BasePcdLibNull/BasePcdLibNull.inf
+  }
+
+  MdeModulePkg/Universal/ReportStatusCodeRouter/RuntimeDxe/ReportStatusCodeRouterRuntimeDxe.inf
+  MdeModulePkg/Universal/StatusCodeHandler/RuntimeDxe/StatusCodeHandlerRuntimeDxe.inf {
+   <LibraryClasses>
+      SerialPortLib|InOsEmuPkg/Library/DxeEmuSerialPortLib/DxeEmuSerialPortLib.inf    
+  }
+
+  InOsEmuPkg/MetronomeDxe/Metronome.inf
+  InOsEmuPkg/RealTimeClockRuntimeDxe/RealTimeClock.inf
+  InOsEmuPkg/ResetRuntimeDxe/Reset.inf
+  MdeModulePkg/Core/RuntimeDxe/RuntimeDxe.inf
+  InOsEmuPkg/FvbServicesRuntimeDxe/FvbServicesRuntimeDxe.inf
+  MdeModulePkg/Universal/SecurityStubDxe/SecurityStubDxe.inf
+  MdeModulePkg/Universal/EbcDxe/EbcDxe.inf
+  MdeModulePkg/Universal/MemoryTest/NullMemoryTestDxe/NullMemoryTestDxe.inf
+  InOsEmuPkg/EmuThunkDxe/EmuThunk.inf
+  InOsEmuPkg/CpuRuntimeDxe/Cpu.inf
+  MdeModulePkg/Universal/FaultTolerantWriteDxe/FaultTolerantWriteDxe.inf
+  InOsEmuPkg/MiscSubClassPlatformDxe/MiscSubClassDriver.inf
+  InOsEmuPkg/TimerDxe/Timer.inf
+
+
+  MdeModulePkg/Universal/Variable/RuntimeDxe/VariableRuntimeDxe.inf
+  MdeModulePkg/Universal/WatchdogTimerDxe/WatchdogTimer.inf
+  MdeModulePkg/Universal/MonotonicCounterRuntimeDxe/MonotonicCounterRuntimeDxe.inf
+  MdeModulePkg/Universal/CapsuleRuntimeDxe/CapsuleRuntimeDxe.inf
+  MdeModulePkg/Universal/Console/ConPlatformDxe/ConPlatformDxe.inf
+  MdeModulePkg/Universal/Console/ConSplitterDxe/ConSplitterDxe.inf
+  MdeModulePkg/Universal/Console/GraphicsConsoleDxe/GraphicsConsoleDxe.inf
+  MdeModulePkg/Universal/Console/TerminalDxe/TerminalDxe.inf
+  IntelFrameworkModulePkg/Universal/BdsDxe/BdsDxe.inf
+  MdeModulePkg/Universal/DevicePathDxe/DevicePathDxe.inf
+  MdeModulePkg/Universal/Disk/DiskIoDxe/DiskIoDxe.inf
+  MdeModulePkg/Universal/Disk/PartitionDxe/PartitionDxe.inf
+  MdeModulePkg/Universal/Disk/UnicodeCollation/EnglishDxe/EnglishDxe.inf
+  MdeModulePkg/Bus/Pci/PciBusDxe/PciBusDxe.inf
+  MdeModulePkg/Bus/Scsi/ScsiBusDxe/ScsiBusDxe.inf
+  MdeModulePkg/Bus/Scsi/ScsiDiskDxe/ScsiDiskDxe.inf
+  IntelFrameworkModulePkg/Bus/Pci/IdeBusDxe/IdeBusDxe.inf
+
+  InOsEmuPkg/EmuBusDriverDxe/EmuBusDriverDxe.inf
+  InOsEmuPkg/EmuGopDxe/EmuGopDxe.inf
+  InOsEmuPkg/EmuSimpleFileSystemDxe/EmuSimpleFileSystemDxe.inf
+
+!if $(0)
+  UnixPkg/UnixBlockIoDxe/UnixBlockIo.inf
+  UnixPkg/UnixSerialIoDxe/UnixSerialIo.inf
+  UnixPkg/UnixConsoleDxe/UnixConsole.inf
+  UnixPkg/UnixSimpleFileSystemDxe/UnixSimpleFileSystem.inf
+!endif
+
+  MdeModulePkg/Application/HelloWorld/HelloWorld.inf
+
+  #
+  # Network stack drivers
+  #
+##!if $(NETWORK_SUPPORT) & $(0)
+!if $(0)
+  UnixPkg/UnixSnpDxe/UnixSnpDxe.inf
+!endif
+  MdeModulePkg/Universal/Network/DpcDxe/DpcDxe.inf
+  MdeModulePkg/Universal/Network/ArpDxe/ArpDxe.inf
+  MdeModulePkg/Universal/Network/Dhcp4Dxe/Dhcp4Dxe.inf
+  MdeModulePkg/Universal/Network/Ip4ConfigDxe/Ip4ConfigDxe.inf
+  MdeModulePkg/Universal/Network/Ip4Dxe/Ip4Dxe.inf
+  MdeModulePkg/Universal/Network/MnpDxe/MnpDxe.inf
+  MdeModulePkg/Universal/Network/VlanConfigDxe/VlanConfigDxe.inf
+  MdeModulePkg/Universal/Network/Mtftp4Dxe/Mtftp4Dxe.inf
+  MdeModulePkg/Universal/Network/Tcp4Dxe/Tcp4Dxe.inf
+  MdeModulePkg/Universal/Network/Udp4Dxe/Udp4Dxe.inf
+
+  MdeModulePkg/Universal/SmbiosDxe/SmbiosDxe.inf
+  MdeModulePkg/Universal/HiiDatabaseDxe/HiiDatabaseDxe.inf
+  MdeModulePkg/Universal/SetupBrowserDxe/SetupBrowserDxe.inf
+  MdeModulePkg/Universal/PrintDxe/PrintDxe.inf
+  MdeModulePkg/Universal/DriverSampleDxe/DriverSampleDxe.inf {
+    <LibraryClasses>
+      PcdLib|MdePkg/Library/BasePcdLibNull/BasePcdLibNull.inf
+  }
+
+!if $(COMPILE_BINS)
+  FatPkg/EnhancedFatDxe/Fat.inf
+!endif
+!endif  

InOsEmuPkg/Unix/UnixX64.fdf

@@ -0,0 +1,382 @@
+## @file
+# This is Unix FDF file with UEFI HII features enabled
+#
+# Copyright (c) 2008 - 2010, Intel Corporation. All rights reserved.<BR>
+# Portions copyright (c) 2009 - 2011, Apple Inc. All rights reserved.<BR>
+#
+#    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.
+#
+
+################################################################################
+#
+# FD Section
+# The [FD] Section is made up of the definition statements and a
+# description of what goes into  the Flash Device Image.  Each FD section
+# defines one flash "device" image.  A flash device image may be one of
+# the following: Removable media bootable image (like a boot floppy
+# image,) an Option ROM image (that would be "flashed" into an add-in
+# card,) a System "Flash"  image (that would be burned into a system's
+# flash) or an Update ("Capsule") image that will be used to update and
+# existing system flash.
+#
+################################################################################
+[FD.Fv_Recovery]
+#
+# In OS X PEIMs are really XIP, so we need to make this address match the malloced 
+# buffer for the FD (0x41000000). If this address does not match the FV will get
+# relocated in place (works, but not a great idea).
+#
+BaseAddress   = 0x102000000|gInOsEmuPkgTokenSpaceGuid.PcdEmuFdBaseAddress   #The base address of the FLASH Device.
+Size          = 0x005a0000|gInOsEmuPkgTokenSpaceGuid.PcdEmuFirmwareFdSize  #The size in bytes of the FLASH Device
+ErasePolarity = 1
+BlockSize     = 0x10000
+NumBlocks     = 0x5a
+
+################################################################################
+#
+# Following are lists of FD Region layout which correspond to the locations of different
+# images within the flash device.
+#
+# Regions must be defined in ascending order and may not overlap.
+#
+# A Layout Region start with a eight digit hex offset (leading "0x" required) followed by
+# the pipe "|" character, followed by the size of the region, also in hex with the leading
+# "0x" characters. Like:
+# Offset|Size
+# PcdOffsetCName|PcdSizeCName
+# RegionType <FV, DATA, or FILE>
+#
+################################################################################
+0x00000000|0x00580000
+gInOsEmuPkgTokenSpaceGuid.PcdEmuFlashFvRecoveryBase|gInOsEmuPkgTokenSpaceGuid.PcdEmuFlashFvRecoverySize
+FV = FvRecovery
+
+0x00580000|0x0000c000
+gInOsEmuPkgTokenSpaceGuid.PcdEmuFlashNvStorageVariableBase|gEfiMdeModulePkgTokenSpaceGuid.PcdFlashNvStorageVariableSize
+#NV_VARIABLE_STORE
+DATA = {
+  ## This is the EFI_FIRMWARE_VOLUME_HEADER
+  # ZeroVector []
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  # FileSystemGuid: gEfiSystemNvDataFvGuid         =
+  #  { 0xFFF12B8D, 0x7696, 0x4C8B, { 0xA9, 0x85, 0x27, 0x47, 0x07, 0x5B, 0x4F, 0x50 }}
+  0x8D, 0x2B, 0xF1, 0xFF, 0x96, 0x76, 0x8B, 0x4C,
+  0xA9, 0x85, 0x27, 0x47, 0x07, 0x5B, 0x4F, 0x50,
+  # FvLength: 0x20000
+  0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00,
+  # Signature "_FVH"       #Attributes
+  0x5f, 0x46, 0x56, 0x48, 0xff, 0xfe, 0x04, 0x00,
+  # HeaderLength #CheckSum #ExtHeaderOffset #Reserved #Revision
+  0x48, 0x00, 0x36, 0x09, 0x00, 0x00, 0x00, 0x02,
+  # Blockmap[0]: 2 Blocks * 0x10000 Bytes / Block
+  0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00,
+  # Blockmap[1]: End
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  ## This is the VARIABLE_STORE_HEADER
+  #Signature: gEfiVariableGuid =
+  #  { 0xddcf3616, 0x3275, 0x4164, { 0x98, 0xb6, 0xfe, 0x85, 0x70, 0x7f, 0xfe, 0x7d }}
+  0x16, 0x36, 0xcf, 0xdd, 0x75, 0x32, 0x64, 0x41,
+  0x98, 0xb6, 0xfe, 0x85, 0x70, 0x7f, 0xfe, 0x7d,
+  #Size: 0xc000 (gEfiMdeModulePkgTokenSpaceGuid.PcdFlashNvStorageVariableSize) - 0x48 (size of EFI_FIRMWARE_VOLUME_HEADER) = 0xBFB8
+  # This can speed up the Variable Dispatch a bit.
+  0xB8, 0xBF, 0x00, 0x00,
+  #FORMATTED: 0x5A #HEALTHY: 0xFE #Reserved: UINT16 #Reserved1: UINT32
+  0x5A, 0xFE, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
+}
+
+0x0058c000|0x00002000
+#NV_EVENT_LOG
+gInOsEmuPkgTokenSpaceGuid.PcdEmuFlashNvStorageEventLogBase|gInOsEmuPkgTokenSpaceGuid.PcdEmuFlashNvStorageEventLogSize
+
+0x0058e000|0x00002000
+gInOsEmuPkgTokenSpaceGuid.PcdEmuFlashNvStorageFtwWorkingBase|gEfiMdeModulePkgTokenSpaceGuid.PcdFlashNvStorageFtwWorkingSize
+#NV_FTW_WORKING
+DATA = {
+  # EFI_FAULT_TOLERANT_WORKING_BLOCK_HEADER->Signature = gEfiSystemNvDataFvGuid         =
+  #  { 0xFFF12B8D, 0x7696, 0x4C8B, { 0xA9, 0x85, 0x27, 0x47, 0x07, 0x5B, 0x4F, 0x50 }}
+  0x8D, 0x2B, 0xF1, 0xFF, 0x96, 0x76, 0x8B, 0x4C,
+  0xA9, 0x85, 0x27, 0x47, 0x07, 0x5B, 0x4F, 0x50,
+  # Crc:UINT32            #WorkingBlockValid:1, WorkingBlockInvalid:1, Reserved
+  0x77, 0x13, 0x9B, 0xD7, 0xFE, 0xFF, 0xFF, 0xFF,
+  # WriteQueueSize: UINT64
+  0xE0, 0x1F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
+}
+
+0x00590000|0x00010000
+#NV_FTW_SPARE
+gInOsEmuPkgTokenSpaceGuid.PcdEmuFlashNvStorageFtwSpareBase|gEfiMdeModulePkgTokenSpaceGuid.PcdFlashNvStorageFtwSpareSize
+
+################################################################################
+#
+# FV Section
+#
+# [FV] section is used to define what components or modules are placed within a flash
+# device file.  This section also defines order the components and modules are positioned
+# within the image.  The [FV] section consists of define statements, set statements and
+# module statements.
+#
+################################################################################
+[FV.FvRecovery]
+FvAlignment        = 16         #FV alignment and FV attributes setting.
+ERASE_POLARITY     = 1
+MEMORY_MAPPED      = TRUE
+STICKY_WRITE       = TRUE
+LOCK_CAP           = TRUE
+LOCK_STATUS        = TRUE
+WRITE_DISABLED_CAP = TRUE
+WRITE_ENABLED_CAP  = TRUE
+WRITE_STATUS       = TRUE
+WRITE_LOCK_CAP     = TRUE
+WRITE_LOCK_STATUS  = TRUE
+READ_DISABLED_CAP  = TRUE
+READ_ENABLED_CAP   = TRUE
+READ_STATUS        = TRUE
+READ_LOCK_CAP      = TRUE
+READ_LOCK_STATUS   = TRUE
+
+################################################################################
+#
+# The INF statements point to EDK component and EDK II module INF files, which will be placed into this FV image.
+# Parsing tools will scan the INF file to determine the type of component or module.
+# The component or module type is used to reference the standard rules
+# defined elsewhere in the FDF file.
+#
+# The format for INF statements is:
+# INF $(PathAndInfFileName)
+#
+################################################################################
+##
+#  PEI Phase modules
+##
+##
+#  PEI Apriori file example, more PEIM module added later.
+##
+APRIORI PEI {
+  INF  MdeModulePkg/Universal/ReportStatusCodeRouter/Pei/ReportStatusCodeRouterPei.inf
+  INF  MdeModulePkg/Universal/StatusCodeHandler/Pei/StatusCodeHandlerPei.inf
+  INF  MdeModulePkg/Universal/PCD/Pei/Pcd.inf
+  }
+APRIORI DXE {
+  INF  MdeModulePkg/Universal/PCD/Dxe/Pcd.inf
+  INF  InOsEmuPkg/MetronomeDxe/Metronome.inf
+  }
+INF  MdeModulePkg/Core/Pei/PeiMain.inf
+INF  MdeModulePkg/Universal/PCD/Pei/Pcd.inf
+INF  MdeModulePkg/Universal/ReportStatusCodeRouter/Pei/ReportStatusCodeRouterPei.inf
+INF  MdeModulePkg/Universal/StatusCodeHandler/Pei/StatusCodeHandlerPei.inf
+INF  InOsEmuPkg/BootModePei/BootModePei.inf
+INF  InOsEmuPkg/AutoScanPei/AutoScanPei.inf
+INF  InOsEmuPkg/FirmwareVolumePei/FirmwareVolumePei.inf
+INF  InOsEmuPkg/FlashMapPei/FlashMapPei.inf
+INF  InOsEmuPkg/ThunkPpiToProtocolPei/ThunkPpiToProtocolPei.inf
+INF  MdeModulePkg/Universal/Variable/Pei/VariablePei.inf
+INF  MdeModulePkg/Core/DxeIplPeim/DxeIpl.inf
+
+##
+#  DXE Phase modules
+##
+INF  MdeModulePkg/Core/Dxe/DxeMain.inf
+INF  MdeModulePkg/Universal/PCD/Dxe/Pcd.inf  
+INF  MdeModulePkg/Universal/ReportStatusCodeRouter/RuntimeDxe/ReportStatusCodeRouterRuntimeDxe.inf
+INF  MdeModulePkg/Universal/StatusCodeHandler/RuntimeDxe/StatusCodeHandlerRuntimeDxe.inf
+INF  InOsEmuPkg/MetronomeDxe/Metronome.inf
+INF  InOsEmuPkg/RealTimeClockRuntimeDxe/RealTimeClock.inf
+INF  InOsEmuPkg/ResetRuntimeDxe/Reset.inf
+INF  MdeModulePkg/Core/RuntimeDxe/RuntimeDxe.inf
+INF  InOsEmuPkg/FvbServicesRuntimeDxe/FvbServicesRuntimeDxe.inf
+INF  MdeModulePkg/Universal/SecurityStubDxe/SecurityStubDxe.inf
+INF  MdeModulePkg/Universal/EbcDxe/EbcDxe.inf
+INF  MdeModulePkg/Universal/MemoryTest/NullMemoryTestDxe/NullMemoryTestDxe.inf
+INF  InOsEmuPkg/EmuThunkDxe/EmuThunk.inf
+INF  InOsEmuPkg/CpuRuntimeDxe/Cpu.inf
+INF  MdeModulePkg/Universal/FaultTolerantWriteDxe/FaultTolerantWriteDxe.inf
+INF  InOsEmuPkg/MiscSubClassPlatformDxe/MiscSubClassDriver.inf
+INF  InOsEmuPkg/TimerDxe/Timer.inf
+INF  MdeModulePkg/Universal/Variable/RuntimeDxe/VariableRuntimeDxe.inf
+INF  MdeModulePkg/Universal/WatchdogTimerDxe/WatchdogTimer.inf
+INF  MdeModulePkg/Universal/MonotonicCounterRuntimeDxe/MonotonicCounterRuntimeDxe.inf
+INF  MdeModulePkg/Universal/CapsuleRuntimeDxe/CapsuleRuntimeDxe.inf
+INF  MdeModulePkg/Universal/Console/ConPlatformDxe/ConPlatformDxe.inf
+INF  MdeModulePkg/Universal/Console/ConSplitterDxe/ConSplitterDxe.inf
+INF  MdeModulePkg/Universal/Console/GraphicsConsoleDxe/GraphicsConsoleDxe.inf
+INF  MdeModulePkg/Universal/Console/TerminalDxe/TerminalDxe.inf
+INF  MdeModulePkg/Universal/DevicePathDxe/DevicePathDxe.inf
+INF  MdeModulePkg/Universal/Disk/DiskIoDxe/DiskIoDxe.inf
+INF  MdeModulePkg/Universal/Disk/PartitionDxe/PartitionDxe.inf
+INF  MdeModulePkg/Universal/Disk/UnicodeCollation/EnglishDxe/EnglishDxe.inf
+INF  MdeModulePkg/Bus/Pci/PciBusDxe/PciBusDxe.inf
+INF  MdeModulePkg/Bus/Scsi/ScsiBusDxe/ScsiBusDxe.inf
+INF  MdeModulePkg/Bus/Scsi/ScsiDiskDxe/ScsiDiskDxe.inf
+INF  IntelFrameworkModulePkg/Bus/Pci/IdeBusDxe/IdeBusDxe.inf
+INF  MdeModulePkg/Universal/SmbiosDxe/SmbiosDxe.inf
+
+INF  InOsEmuPkg/EmuBusDriverDxe/EmuBusDriverDxe.inf 
+INF  InOsEmuPkg/EmuGopDxe/EmuGopDxe.inf
+INF  InOsEmuPkg/EmuSimpleFileSystemDxe/EmuSimpleFileSystemDxe.inf
+
+#INF  UnixPkg/UnixBlockIoDxe/UnixBlockIo.inf
+#INF  UnixPkg/UnixSerialIoDxe/UnixSerialIo.inf
+INF  MdeModulePkg/Universal/HiiDatabaseDxe/HiiDatabaseDxe.inf
+INF  MdeModulePkg/Universal/SetupBrowserDxe/SetupBrowserDxe.inf
+INF  MdeModulePkg/Universal/PrintDxe/PrintDxe.inf
+INF  IntelFrameworkModulePkg/Universal/BdsDxe/BdsDxe.inf 
+INF  MdeModulePkg/Universal/DriverSampleDxe/DriverSampleDxe.inf
+INF  MdeModulePkg/Application/HelloWorld/HelloWorld.inf
+
+#
+# Network stack drivers
+#
+!if $(NETWORK_SUPPORT)
+#INF  UnixPkg/UnixSnpDxe/UnixSnpDxe.inf
+!endif
+INF  MdeModulePkg/Universal/Network/DpcDxe/DpcDxe.inf
+INF  MdeModulePkg/Universal/Network/ArpDxe/ArpDxe.inf
+INF  MdeModulePkg/Universal/Network/Dhcp4Dxe/Dhcp4Dxe.inf
+INF  MdeModulePkg/Universal/Network/Ip4ConfigDxe/Ip4ConfigDxe.inf
+INF  MdeModulePkg/Universal/Network/Ip4Dxe/Ip4Dxe.inf
+INF  MdeModulePkg/Universal/Network/MnpDxe/MnpDxe.inf
+INF  MdeModulePkg/Universal/Network/VlanConfigDxe/VlanConfigDxe.inf
+INF  MdeModulePkg/Universal/Network/Mtftp4Dxe/Mtftp4Dxe.inf
+INF  MdeModulePkg/Universal/Network/Tcp4Dxe/Tcp4Dxe.inf
+INF  MdeModulePkg/Universal/Network/Udp4Dxe/Udp4Dxe.inf
+
+ 
+!if $(COMPILE_BINS)
+INF FatPkg/EnhancedFatDxe/Fat.inf
+!else
+# Used checked in Visual Studio binaries
+INF  RuleOverride = BINARY USE = X64 FatBinPkg/EnhancedFatDxe/Fat.inf
+!endif
+
+ FILE APPLICATION = PCD(gEfiIntelFrameworkModulePkgTokenSpaceGuid.PcdShellFile) {
+#  SECTION PE32 = ShellBinPkg/UefiShell/X64/Shell.efi
+  SECTION PE32 = Build/GccShellPkg/DEBUG_XCLANG/X64/ShellFull.efi
+  SECTION UI = "Shell"
+ }
+
+FILE FREEFORM = PCD(gEfiIntelFrameworkModulePkgTokenSpaceGuid.PcdLogoFile) {
+  SECTION RAW = MdeModulePkg/Logo/Logo.bmp
+}
+   
+   
+################################################################################
+#  
+# Rules are use with the [FV] section's module INF type to define
+# how an FFS file is created for a given INF file. The following Rule are the default
+# rules for the different module type. User can add the customized rules to define the
+# content of the FFS file.
+#  
+################################################################################
+   
+   
+############################################################################
+# Example of a DXE_DRIVER FFS file with a Checksum encapsulation section   # 
+############################################################################
+#  
+#[Rule.Common.DXE_DRIVER]
+#  FILE DRIVER = $(NAMED_GUID) {
+#    DXE_DEPEX    DXE_DEPEX Optional      $(INF_OUTPUT)/$(MODULE_NAME).depex
+#    COMPRESS PI_STD {
+#      GUIDED {
+#        PE32     PE32                    $(INF_OUTPUT)/$(MODULE_NAME).efi
+#        UI       STRING="$(MODULE_NAME)" Optional
+#        VERSION  STRING="$(INF_VERSION)" Optional BUILD_NUM=$(BUILD_NUMBER)
+#      }
+#    }
+#  }
+#
+############################################################################
+
+[Rule.Common.PEI_CORE]
+  FILE PEI_CORE = $(NAMED_GUID) {
+    PE32     PE32    Align=32       $(INF_OUTPUT)/$(MODULE_NAME).efi
+    UI       STRING ="$(MODULE_NAME)" Optional         
+    VERSION  STRING ="$(INF_VERSION)" Optional BUILD_NUM=$(BUILD_NUMBER)    
+  }
+
+[Rule.Common.PEIM]
+  FILE PEIM = $(NAMED_GUID) {
+     PEI_DEPEX PEI_DEPEX Optional        $(INF_OUTPUT)/$(MODULE_NAME).depex
+     PE32      PE32   Align=32       $(INF_OUTPUT)/$(MODULE_NAME).efi
+     UI       STRING="$(MODULE_NAME)" Optional         
+     VERSION  STRING="$(INF_VERSION)" Optional BUILD_NUM=$(BUILD_NUMBER)   
+  }
+
+[Rule.Common.DXE_CORE]
+  FILE DXE_CORE = $(NAMED_GUID) {
+    COMPRESS PI_STD {
+      PE32     PE32           $(INF_OUTPUT)/$(MODULE_NAME).efi
+      UI       STRING="$(MODULE_NAME)" Optional
+      VERSION  STRING="$(INF_VERSION)" Optional BUILD_NUM=$(BUILD_NUMBER)
+    }
+  }
+
+[Rule.Common.UEFI_DRIVER]
+  FILE DRIVER = $(NAMED_GUID) {
+    DXE_DEPEX    DXE_DEPEX Optional      $(INF_OUTPUT)/$(MODULE_NAME).depex
+    COMPRESS PI_STD {
+      GUIDED {
+        PE32     PE32                    $(INF_OUTPUT)/$(MODULE_NAME).efi
+        UI       STRING="$(MODULE_NAME)" Optional
+        VERSION  STRING="$(INF_VERSION)" Optional BUILD_NUM=$(BUILD_NUMBER)
+      }
+    }
+  }
+
+[Rule.Common.DXE_DRIVER]
+  FILE DRIVER = $(NAMED_GUID) {
+    DXE_DEPEX    DXE_DEPEX Optional      $(INF_OUTPUT)/$(MODULE_NAME).depex
+    COMPRESS PI_STD {
+      GUIDED {
+        PE32     PE32                    $(INF_OUTPUT)/$(MODULE_NAME).efi
+        UI       STRING="$(MODULE_NAME)" Optional
+        VERSION  STRING="$(INF_VERSION)" Optional BUILD_NUM=$(BUILD_NUMBER)
+      }
+    }
+  }
+
+[Rule.Common.DXE_RUNTIME_DRIVER]
+  FILE DRIVER = $(NAMED_GUID) {
+    DXE_DEPEX    DXE_DEPEX Optional      $(INF_OUTPUT)/$(MODULE_NAME).depex
+    COMPRESS PI_STD {
+      GUIDED {
+        PE32     PE32                    $(INF_OUTPUT)/$(MODULE_NAME).efi
+        UI       STRING="$(MODULE_NAME)" Optional
+        VERSION  STRING="$(INF_VERSION)" Optional BUILD_NUM=$(BUILD_NUMBER)
+      }
+    }
+  }
+
+[Rule.Common.UEFI_APPLICATION]
+  FILE APPLICATION = $(NAMED_GUID) {
+    COMPRESS PI_STD {
+      GUIDED {
+        PE32     PE32                    $(INF_OUTPUT)/$(MODULE_NAME).efi
+        UI       STRING="$(MODULE_NAME)" Optional
+        VERSION  STRING="$(INF_VERSION)" Optional BUILD_NUM=$(BUILD_NUMBER)
+      }
+    }
+  }
+
+[Rule.Common.UEFI_DRIVER.BINARY]
+  FILE DRIVER = $(NAMED_GUID) {
+    DXE_DEPEX DXE_DEPEX Optional      |.depex
+    PE32      PE32                    |.efi
+    UI        STRING="$(MODULE_NAME)" Optional
+    VERSION   STRING="$(INF_VERSION)" Optional BUILD_NUM=$(BUILD_NUMBER)
+  }
+
+[Rule.Common.UEFI_APPLICATION.BINARY]
+  FILE APPLICATION = $(NAMED_GUID) {
+    PE32      PE32                    |.efi
+    UI        STRING="$(MODULE_NAME)" Optional
+    VERSION   STRING="$(INF_VERSION)" Optional BUILD_NUM=$(BUILD_NUMBER)
+  }
+

InOsEmuPkg/Unix/Xcode/xcode_project64/XcodeBuild.sh

@@ -0,0 +1,24 @@
+#!/bin/bash
+#
+# External makefile Xcode project project uses this script to build and clean from the Xcode GUI
+#
+# Copyright (c) 2008 - 2011, Apple Inc. All rights reserved.<BR>
+#
+# 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.
+#
+
+# force exit on error
+set -e
+
+#
+# Source the workspace and set up the environment variables we need
+#
+cd ../..
+echo `pwd`
+./build64.sh $1 $2 $3 $4 $5 $6 $8

InOsEmuPkg/Unix/Xcode/xcode_project64/xcode_project.xcodeproj/default.pbxuser

@@ -0,0 +1,191 @@
+// !$*UTF8*$!
+{
+	08FB7793FE84155DC02AAC07 /* Project object */ = {
+		activeBuildConfigurationName = Debug;
+		activeExecutable = BA11A1010FB10BCE00D06FEC /* SecMain.dll */;
+		activeTarget = D28A88AD04BDD90700651E21 /* xcode_project */;
+		breakpoints = (
+			BA11A11A0FB10E0700D06FEC /* SecGdbScriptBreak */,
+		);
+		codeSenseManager = BA11A0FE0FB10B4800D06FEC /* Code sense */;
+		executables = (
+			BA11A1010FB10BCE00D06FEC /* SecMain.dll */,
+		);
+		perUserDictionary = {
+			"PBXConfiguration.PBXBreakpointsDataSource.v1:1CA1AED706398EBD00589147" = {
+				PBXFileTableDataSourceColumnSortingDirectionKey = "-1";
+				PBXFileTableDataSourceColumnSortingKey = PBXBreakpointsDataSource_BreakpointID;
+				PBXFileTableDataSourceColumnWidthsKey = (
+					20,
+					20,
+					198,
+					20,
+					99,
+					99,
+					29,
+					20,
+				);
+				PBXFileTableDataSourceColumnsKey = (
+					PBXBreakpointsDataSource_ActionID,
+					PBXBreakpointsDataSource_TypeID,
+					PBXBreakpointsDataSource_BreakpointID,
+					PBXBreakpointsDataSource_UseID,
+					PBXBreakpointsDataSource_LocationID,
+					PBXBreakpointsDataSource_ConditionID,
+					PBXBreakpointsDataSource_IgnoreCountID,
+					PBXBreakpointsDataSource_ContinueID,
+				);
+			};
+			PBXConfiguration.PBXFileTableDataSource3.PBXExecutablesDataSource = {
+				PBXFileTableDataSourceColumnSortingDirectionKey = "-1";
+				PBXFileTableDataSourceColumnSortingKey = PBXExecutablesDataSource_NameID;
+				PBXFileTableDataSourceColumnWidthsKey = (
+					22,
+					300,
+					229,
+				);
+				PBXFileTableDataSourceColumnsKey = (
+					PBXExecutablesDataSource_ActiveFlagID,
+					PBXExecutablesDataSource_NameID,
+					PBXExecutablesDataSource_CommentsID,
+				);
+			};
+			PBXConfiguration.PBXFileTableDataSource3.PBXFileTableDataSource = {
+				PBXFileTableDataSourceColumnSortingDirectionKey = "-1";
+				PBXFileTableDataSourceColumnSortingKey = PBXFileDataSource_Filename_ColumnID;
+				PBXFileTableDataSourceColumnWidthsKey = (
+					20,
+					341,
+					20,
+					48,
+					43,
+					43,
+					20,
+				);
+				PBXFileTableDataSourceColumnsKey = (
+					PBXFileDataSource_FiletypeID,
+					PBXFileDataSource_Filename_ColumnID,
+					PBXFileDataSource_Built_ColumnID,
+					PBXFileDataSource_ObjectSize_ColumnID,
+					PBXFileDataSource_Errors_ColumnID,
+					PBXFileDataSource_Warnings_ColumnID,
+					PBXFileDataSource_Target_ColumnID,
+				);
+			};
+			PBXPerProjectTemplateStateSaveDate = 263260969;
+			PBXWorkspaceStateSaveDate = 263260969;
+		};
+		sourceControlManager = BA11A0FD0FB10B4800D06FEC /* Source Control */;
+		userBuildSettings = {
+		};
+	};
+	BA11A0FD0FB10B4800D06FEC /* Source Control */ = {
+		isa = PBXSourceControlManager;
+		fallbackIsa = XCSourceControlManager;
+		isSCMEnabled = 0;
+		repositoryNamesForRoots = {
+		};
+		scmConfiguration = {
+		};
+	};
+	BA11A0FE0FB10B4800D06FEC /* Code sense */ = {
+		isa = PBXCodeSenseManager;
+		indexTemplatePath = "";
+	};
+	BA11A1010FB10BCE00D06FEC /* SecMain.dll */ = {
+		isa = PBXExecutable;
+		activeArgIndices = (
+		);
+		argumentStrings = (
+		);
+		autoAttachOnCrash = 1;
+		breakpointsEnabled = 1;
+		configStateDict = {
+			"PBXLSLaunchAction-0" = {
+				PBXLSLaunchAction = 0;
+				PBXLSLaunchStartAction = 1;
+				PBXLSLaunchStdioStyle = 2;
+				PBXLSLaunchStyle = 0;
+				class = PBXLSRunLaunchConfig;
+				commandLineArgs = (
+				);
+				displayName = "Executable Runner";
+				environment = {
+				};
+				identifier = com.apple.Xcode.launch.runConfig;
+				remoteHostInfo = "";
+				startActionInfo = "";
+			};
+			"PBXLSLaunchAction-1" = {
+				PBXLSLaunchAction = 1;
+				PBXLSLaunchStartAction = 1;
+				PBXLSLaunchStdioStyle = 2;
+				PBXLSLaunchStyle = 0;
+				class = PBXGDB_LaunchConfig;
+				commandLineArgs = (
+				);
+				displayName = GDB;
+				environment = {
+				};
+				identifier = com.apple.Xcode.launch.GDBMI_Config;
+				remoteHostInfo = "";
+				startActionInfo = "";
+			};
+		};
+		customDataFormattersEnabled = 0;
+		dataTipCustomDataFormattersEnabled = 1;
+		dataTipShowTypeColumn = 1;
+		dataTipSortType = 0;
+		debuggerPlugin = GDBDebugging;
+		disassemblyDisplayState = 0;
+		dylibVariantSuffix = "";
+		enableDebugStr = 1;
+		environmentEntries = (
+		);
+		executableSystemSymbolLevel = 0;
+		executableUserSymbolLevel = 0;
+		launchableReference = BA11A1020FB10BCE00D06FEC /* SecMain.dll */;
+		libgmallocEnabled = 0;
+		name = SecMain.dll;
+		savedGlobals = {
+		};
+		showTypeColumn = 0;
+		sourceDirectories = (
+		);
+		startupPath = ../../../Build/UnixX64/DEBUG_UNIXPKG/X64;
+	};
+	BA11A1020FB10BCE00D06FEC /* SecMain.dll */ = {
+		isa = PBXFileReference;
+		lastKnownFileType = "compiled.mach-o.executable";
+		name = SecMain.dll;
+		path = ../../../Build/UnixX64/DEBUG_UNIXPKG/X64/SecMain;
+		sourceTree = SOURCE_ROOT;
+	};
+	BA11A11A0FB10E0700D06FEC /* SecGdbScriptBreak */ = {
+		isa = PBXSymbolicBreakpoint;
+		actions = (
+			BA11A11E0FB10E2200D06FEC /* XCBreakpointCommandAction */,
+		);
+		breakpointStyle = 1;
+		continueAfterActions = 1;
+		countType = 0;
+		delayBeforeContinue = 0;
+		hitCount = 0;
+		ignoreCount = 0;
+		location = SecMain;
+		modificationTime = 263261853.260195;
+		originalNumberOfMultipleMatches = 1;
+		state = 1;
+		symbolName = SecGdbScriptBreak;
+	};
+	BA11A11E0FB10E2200D06FEC /* XCBreakpointCommandAction */ = {
+		isa = XCBreakpointCommandAction;
+		command = "source SecMain.gdb";
+		fallbackIsa = XCBreakpointAction;
+		logCommand = 0;
+		useDebuggerSideImplementation = 1;
+	};
+	D28A88AD04BDD90700651E21 /* xcode_project */ = {
+		activeExec = 0;
+	};
+}

InOsEmuPkg/Unix/Xcode/xcode_project64/xcode_project.xcodeproj/project.pbxproj

@@ -0,0 +1,124 @@
+// !$*UTF8*$!
+{
+	archiveVersion = 1;
+	classes = {
+	};
+	objectVersion = 45;
+	objects = {
+
+/* Begin PBXGroup section */
+		08FB7794FE84155DC02AAC07 /* xcode_project */ = {
+			isa = PBXGroup;
+			children = (
+			);
+			name = xcode_project;
+			sourceTree = "<group>";
+		};
+/* End PBXGroup section */
+
+/* Begin PBXLegacyTarget section */
+		D28A88AD04BDD90700651E21 /* xcode_project */ = {
+			isa = PBXLegacyTarget;
+			buildArgumentsString = "$(ACTION)";
+			buildConfigurationList = 1DEB918F08733D9F0010E9CD /* Build configuration list for PBXLegacyTarget "xcode_project" */;
+			buildPhases = (
+			);
+			buildToolPath = ./XcodeBuild.sh;
+			buildWorkingDirectory = "";
+			dependencies = (
+			);
+			name = xcode_project;
+			passBuildSettingsInEnvironment = 1;
+			productName = xcode_project;
+		};
+/* End PBXLegacyTarget section */
+
+/* Begin PBXProject section */
+		08FB7793FE84155DC02AAC07 /* Project object */ = {
+			isa = PBXProject;
+			buildConfigurationList = 1DEB919308733D9F0010E9CD /* Build configuration list for PBXProject "xcode_project" */;
+			compatibilityVersion = "Xcode 3.1";
+			developmentRegion = English;
+			hasScannedForEncodings = 1;
+			knownRegions = (
+				English,
+				Japanese,
+				French,
+				German,
+			);
+			mainGroup = 08FB7794FE84155DC02AAC07 /* xcode_project */;
+			projectDirPath = "";
+			projectRoot = "";
+			targets = (
+				D28A88AD04BDD90700651E21 /* xcode_project */,
+			);
+		};
+/* End PBXProject section */
+
+/* Begin XCBuildConfiguration section */
+		1DEB919008733D9F0010E9CD /* Debug */ = {
+			isa = XCBuildConfiguration;
+			buildSettings = {
+				PRODUCT_NAME = xcode_project;
+			};
+			name = Debug;
+		};
+		1DEB919108733D9F0010E9CD /* Release */ = {
+			isa = XCBuildConfiguration;
+			buildSettings = {
+				COPY_PHASE_STRIP = YES;
+				GCC_ENABLE_FIX_AND_CONTINUE = NO;
+				OTHER_CFLAGS = "";
+				OTHER_LDFLAGS = "";
+				PRODUCT_NAME = xcode_project;
+			};
+			name = Release;
+		};
+		1DEB919408733D9F0010E9CD /* Debug */ = {
+			isa = XCBuildConfiguration;
+			buildSettings = {
+				ARCHS = "$(ARCHS_STANDARD_64_BIT)";
+				GCC_WARN_ABOUT_RETURN_TYPE = YES;
+				GCC_WARN_UNUSED_VARIABLE = YES;
+				ONLY_ACTIVE_ARCH = YES;
+				PREBINDING = NO;
+				SDKROOT = macosx10.6;
+			};
+			name = Debug;
+		};
+		1DEB919508733D9F0010E9CD /* Release */ = {
+			isa = XCBuildConfiguration;
+			buildSettings = {
+				ARCHS = "$(ARCHS_STANDARD_64_BIT)";
+				GCC_WARN_ABOUT_RETURN_TYPE = YES;
+				GCC_WARN_UNUSED_VARIABLE = YES;
+				PREBINDING = NO;
+				SDKROOT = macosx10.6;
+			};
+			name = Release;
+		};
+/* End XCBuildConfiguration section */
+
+/* Begin XCConfigurationList section */
+		1DEB918F08733D9F0010E9CD /* Build configuration list for PBXLegacyTarget "xcode_project" */ = {
+			isa = XCConfigurationList;
+			buildConfigurations = (
+				1DEB919008733D9F0010E9CD /* Debug */,
+				1DEB919108733D9F0010E9CD /* Release */,
+			);
+			defaultConfigurationIsVisible = 0;
+			defaultConfigurationName = Release;
+		};
+		1DEB919308733D9F0010E9CD /* Build configuration list for PBXProject "xcode_project" */ = {
+			isa = XCConfigurationList;
+			buildConfigurations = (
+				1DEB919408733D9F0010E9CD /* Debug */,
+				1DEB919508733D9F0010E9CD /* Release */,
+			);
+			defaultConfigurationIsVisible = 0;
+			defaultConfigurationName = Release;
+		};
+/* End XCConfigurationList section */
+	};
+	rootObject = 08FB7793FE84155DC02AAC07 /* Project object */;
+}

InOsEmuPkg/Unix/build64.sh

@@ -0,0 +1,132 @@
+#!/bin/bash
+#
+# Copyright (c) 2008 - 2011, Apple Inc. All rights reserved.<BR>
+# Copyright (c) 2010, Intel Corporation. All rights reserved.<BR>
+#
+# 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.
+#
+
+set -e
+shopt -s nocasematch
+
+
+#
+# Setup workspace if it is not set
+#
+if [ -z "$WORKSPACE" ]
+then
+  echo Initializing workspace
+  if [ ! -e `pwd`/edksetup.sh ]
+  then
+    cd ../..
+  fi
+# This version is for the tools in the BaseTools project.
+# this assumes svn pulls have the same root dir
+#  export EDK_TOOLS_PATH=`pwd`/../BaseTools
+# This version is for the tools source in edk2
+  export EDK_TOOLS_PATH=`pwd`/BaseTools
+  echo $EDK_TOOLS_PATH
+  source edksetup.sh BaseTools
+else
+  echo Building from: $WORKSPACE
+fi
+
+#
+# Pick a default tool type for a given OS
+#
+TARGET_TOOLS=MYTOOLS
+UNIXPKG_TOOLS=GCC44
+NETWORK_SUPPORT=
+COMPILE_BINS=
+case `uname` in
+  CYGWIN*) echo Cygwin not fully supported yet. ;;
+  Darwin*)
+      Major=$(uname -r | cut -f 1 -d '.')
+      if [[ $Major == 9 ]]
+      then
+        echo UnixPkg requires Snow Leopard or later OS
+        exit 1
+      else
+        TARGET_TOOLS=XCODE32
+        UNIXPKG_TOOLS=XCLANG
+      fi
+      NETWORK_SUPPORT="-D NETWORK_SUPPORT"
+      COMPILE_BINS="-D COMPILE_BINS"
+      ;;
+  Linux*) TARGET_TOOLS=ELFGCC ;;
+
+esac
+
+BUILD_ROOT_ARCH=$WORKSPACE/Build/EmuUnixX64/DEBUG_"$UNIXPKG_TOOLS"/X64
+
+if  [[ ! -f `which build` || ! -f `which GenFv` ]];
+then
+  # build the tools if they don't yet exist. Bin scheme
+  echo Building tools as they are not in the path
+  make -C $WORKSPACE/BaseTools
+elif [[ ( -f `which build` ||  -f `which GenFv` )  && ! -d  $EDK_TOOLS_PATH/Source/C/bin ]];
+then
+  # build the tools if they don't yet exist. BinWrapper scheme
+  echo Building tools no $EDK_TOOLS_PATH/Source/C/bin directory
+  make -C $WORKSPACE/BaseTools
+else
+  echo using prebuilt tools
+fi
+
+
+for arg in "$@"
+do
+  if [[ $arg == run ]]; then
+    case `uname` in
+      Darwin*)
+        #
+        # On Darwin we can't use dlopen, so we have to load the real PE/COFF images.
+        # This .gdbinit script sets a breakpoint that loads symbols for the PE/COFFEE
+        # images that get loaded in SecMain
+        #
+        cp $WORKSPACE/InOsEmuPkg/Unix/.gdbinit $WORKSPACE/Build/EmuUnixX64/DEBUG_"$UNIXPKG_TOOLS"/X64
+        ;;
+    esac
+
+    /usr/bin/gdb $BUILD_ROOT_ARCH/SecMain -q -cd=$BUILD_ROOT_ARCH
+    exit
+  fi
+
+  if [[ $arg == cleanall ]]; then
+    make -C $WORKSPACE/BaseTools clean
+    build -p $WORKSPACE/InOsEmuPkg/Unix/UnixX64.dsc -a X64 -t $TARGET_TOOLS -D SEC_ONLY -n 3 clean
+    build -p $WORKSPACE/InOsEmuPkg/Unix/UnixX64.dsc -a X64 -t $UNIXPKG_TOOLS -n 3 clean
+    build -p $WORKSPACE/ShellPkg/ShellPkg.dsc -a X64 -t $UNIXPKG_TOOLS -n 3 clean
+    exit $?
+  fi
+
+  if [[ $arg == clean ]]; then
+    build -p $WORKSPACE/InOsEmuPkg/Unix/UnixX64.dsc -a X64 -t $TARGET_TOOLS -D SEC_ONLY -n 3 clean
+    build -p $WORKSPACE/InOsEmuPkg/Unix/UnixX64.dsc -a X64 -t $UNIXPKG_TOOLS -n 3 clean
+    exit $?
+  fi
+
+  if [[ $arg == shell ]]; then
+    build -p $WORKSPACE/ShellPkg/ShellPkg.dsc -a X64 -t $UNIXPKG_TOOLS -n 3 $2 $3 $4 $5 $6 $7 $8
+    cp Build/Shell/DEBUG_$UNIXPKG_TOOLS/X64/Shell.efi ShellBinPkg/UefiShell/X64/Shell.efi
+    exit $?
+  fi
+done
+
+
+#
+# Build the edk2 UnixPkg
+#
+echo $PATH
+echo `which build`
+build -p $WORKSPACE/InOsEmuPkg/Unix/UnixX64.dsc      -a X64 -t $TARGET_TOOLS -D SEC_ONLY -n 3 $1 $2 $3 $4 $5 $6 $7 $8  modules
+build -p $WORKSPACE/InOsEmuPkg/Unix/UnixX64.dsc      -a X64 -t $UNIXPKG_TOOLS $NETWORK_SUPPORT -n 3 $1 $2 $3 $4 $5 $6 $7 $8
+cp $WORKSPACE/Build/EmuUnixX64/DEBUG_"$TARGET_TOOLS"/X64/SecMain $WORKSPACE/Build/EmuUnixX64/DEBUG_"$UNIXPKG_TOOLS"/X64
+exit $?
+