EmulatorPkg: Replace BSD License with BSD+Patent License

[mirror_edk2.git] / EmulatorPkg / Win / Host / WinThunk.c

/**@file\r
\r
Copyright (c) 2006 - 2018, Intel Corporation. All rights reserved.<BR>\r
SPDX-License-Identifier: BSD-2-Clause-Patent\r
\r
Module Name:\r
\r
  WinNtThunk.c\r
\r
Abstract:\r
\r
  Since the SEC is the only windows program in our emulation we\r
  must use a Tiano mechanism to export Win32 APIs to other modules.\r
  This is the role of the EFI_WIN_NT_THUNK_PROTOCOL.\r
\r
  The mWinNtThunkTable exists so that a change to EFI_WIN_NT_THUNK_PROTOCOL\r
  will cause an error in initializing the array if all the member functions\r
  are not added. It looks like adding a element to end and not initializing\r
  it may cause the table to be initaliized with the members at the end being\r
  set to zero. This is bad as jumping to zero will case the NT32 to crash.\r
\r
  All the member functions in mWinNtThunkTable are Win32\r
  API calls, so please reference Microsoft documentation.\r
\r
\r
  gWinNt is a a public exported global that contains the initialized\r
  data.\r
\r
**/\r
\r
#include "WinHost.h"\r
\r
UINTN\r
SecWriteStdErr (\r
  IN UINT8     *Buffer,\r
  IN UINTN     NumberOfBytes\r
  )\r
{\r
  BOOL  Success;\r
  DWORD CharCount;\r
\r
  CharCount = (DWORD)NumberOfBytes;\r
  Success = WriteFile (\r
    GetStdHandle (STD_ERROR_HANDLE),\r
    Buffer,\r
    CharCount,\r
    &CharCount,\r
    NULL\r
    );\r
\r
  return Success ? CharCount : 0;\r
}\r
\r
\r
EFI_STATUS\r
SecConfigStdIn (\r
  VOID\r
  )\r
{\r
  BOOL     Success;\r
  DWORD    Mode;\r
\r
  Success = GetConsoleMode (GetStdHandle (STD_INPUT_HANDLE), &Mode);\r
  if (Success) {\r
    //\r
    // Disable buffer (line input), echo, mouse, window\r
    //\r
    Mode &= ~(ENABLE_LINE_INPUT | ENABLE_ECHO_INPUT | ENABLE_MOUSE_INPUT | ENABLE_WINDOW_INPUT);\r
\r
#if defined(NTDDI_VERSION) && defined (NTDDI_WIN10_TH2) && (NTDDI_VERSION > NTDDI_WIN10_TH2)\r
    //\r
    // Enable virtual terminal input for Win10 above TH2\r
    //\r
    Mode |= ENABLE_VIRTUAL_TERMINAL_INPUT;\r
#endif\r
\r
    Success = SetConsoleMode (GetStdHandle (STD_INPUT_HANDLE), Mode);\r
  }\r
\r
#if defined(NTDDI_VERSION) && defined (NTDDI_WIN10_TH2) && (NTDDI_VERSION > NTDDI_WIN10_TH2)\r
  //\r
  // Enable terminal mode for Win10 above TH2\r
  //\r
  if (Success) {\r
    Success = GetConsoleMode (GetStdHandle (STD_OUTPUT_HANDLE), &Mode);\r
    if (Success) {\r
      Success = SetConsoleMode (\r
        GetStdHandle (STD_OUTPUT_HANDLE),\r
        Mode | ENABLE_VIRTUAL_TERMINAL_PROCESSING | DISABLE_NEWLINE_AUTO_RETURN\r
      );\r
    }\r
  }\r
#endif\r
  return Success ? EFI_SUCCESS : EFI_DEVICE_ERROR;\r
}\r
\r
UINTN\r
SecWriteStdOut (\r
  IN UINT8     *Buffer,\r
  IN UINTN     NumberOfBytes\r
  )\r
{\r
  BOOL  Success;\r
  DWORD CharCount;\r
\r
  CharCount = (DWORD)NumberOfBytes;\r
  Success = WriteFile (\r
    GetStdHandle (STD_OUTPUT_HANDLE),\r
    Buffer,\r
    CharCount,\r
    &CharCount,\r
    NULL\r
    );\r
\r
  return Success ? CharCount : 0;\r
}\r
\r
BOOLEAN\r
SecPollStdIn (\r
  VOID\r
  )\r
{\r
  BOOL           Success;\r
  INPUT_RECORD   Record;\r
  DWORD          RecordNum;\r
\r
  do {\r
    Success = GetNumberOfConsoleInputEvents (GetStdHandle (STD_INPUT_HANDLE), &RecordNum);\r
    if (!Success || (RecordNum == 0)) {\r
      break;\r
    }\r
    Success = PeekConsoleInput (\r
      GetStdHandle (STD_INPUT_HANDLE),\r
      &Record,\r
      1,\r
      &RecordNum\r
    );\r
    if (Success && (RecordNum == 1)) {\r
      if (Record.EventType == KEY_EVENT && Record.Event.KeyEvent.bKeyDown) {\r
        return TRUE;\r
      } else {\r
        //\r
        // Consume the non-key event.\r
        //\r
        Success = ReadConsoleInput (\r
          GetStdHandle (STD_INPUT_HANDLE),\r
          &Record,\r
          1,\r
          &RecordNum\r
        );\r
      }\r
    }\r
  } while (Success);\r
\r
  return FALSE;\r
}\r
\r
UINTN\r
SecReadStdIn (\r
  IN UINT8     *Buffer,\r
  IN UINTN     NumberOfBytes\r
  )\r
{\r
  BOOL           Success;\r
  INPUT_RECORD   Record;\r
  DWORD          RecordNum;\r
  UINTN          BytesReturn;\r
\r
  if (!SecPollStdIn ()) {\r
    return 0;\r
  }\r
  Success = ReadConsoleInput (\r
    GetStdHandle (STD_INPUT_HANDLE),\r
    &Record,\r
    1,\r
    &RecordNum\r
  );\r
  ASSERT (Success && (RecordNum == 1) && (Record.EventType == KEY_EVENT) && (Record.Event.KeyEvent.bKeyDown));\r
  NumberOfBytes = MIN (Record.Event.KeyEvent.wRepeatCount, NumberOfBytes);\r
  BytesReturn   = NumberOfBytes;\r
  while (NumberOfBytes-- != 0) {\r
    Buffer[NumberOfBytes] = Record.Event.KeyEvent.uChar.AsciiChar;\r
  }\r
  return BytesReturn;\r
}\r
\r
\r
VOID *\r
SecAlloc (\r
  IN  UINTN Size\r
  )\r
{\r
  return malloc ((size_t)Size);\r
}\r
\r
BOOLEAN\r
SecFree (\r
  IN  VOID *Ptr\r
  )\r
{\r
  if (EfiSystemMemoryRange (Ptr)) {\r
    // If an address range is in the EFI memory map it was alloced via EFI.\r
    // So don't free those ranges and let the caller know.\r
    return FALSE;\r
  }\r
\r
  free (Ptr);\r
  return TRUE;\r
}\r
\r
\r
\r
//\r
// Define a global that we can use to shut down the NT timer thread when\r
// the timer is canceled.\r
//\r
BOOLEAN                 mCancelTimerThread = FALSE;\r
\r
//\r
// The notification function to call on every timer interrupt\r
//\r
EMU_SET_TIMER_CALLBACK  *mTimerNotifyFunction = NULL;\r
\r
//\r
// The thread handle for this driver\r
//\r
HANDLE                  mNtMainThreadHandle;\r
\r
//\r
// The timer value from the last timer interrupt\r
//\r
UINT32                  mNtLastTick;\r
\r
//\r
// Critical section used to update varibles shared between the main thread and\r
// the timer interrupt thread.\r
//\r
CRITICAL_SECTION        mNtCriticalSection;\r
\r
//\r
// Worker Functions\r
//\r
UINT                    mMMTimerThreadID = 0;\r
\r
volatile BOOLEAN        mInterruptEnabled = FALSE;\r
\r
VOID\r
CALLBACK\r
MMTimerThread (\r
  UINT  wTimerID,\r
  UINT  msg,\r
  DWORD dwUser,\r
  DWORD dw1,\r
  DWORD dw2\r
)\r
{\r
  UINT32            CurrentTick;\r
  UINT32            Delta;\r
\r
  if (!mCancelTimerThread) {\r
\r
    //\r
    // Suspend the main thread until we are done.\r
    // Enter the critical section before suspending\r
    // and leave the critical section after resuming\r
    // to avoid deadlock between main and timer thread.\r
    //\r
    EnterCriticalSection (&mNtCriticalSection);\r
    SuspendThread (mNtMainThreadHandle);\r
\r
    //\r
    // If the timer thread is being canceled, then bail immediately.\r
    // We check again here because there's a small window of time from when\r
    // this thread was kicked off and when we suspended the main thread above.\r
    //\r
    if (mCancelTimerThread) {\r
      ResumeThread (mNtMainThreadHandle);\r
      LeaveCriticalSection (&mNtCriticalSection);\r
      timeKillEvent (wTimerID);\r
      mMMTimerThreadID = 0;\r
      return;\r
    }\r
\r
    while (!mInterruptEnabled) {\r
      //\r
      //  Resume the main thread\r
      //\r
      ResumeThread (mNtMainThreadHandle);\r
      LeaveCriticalSection (&mNtCriticalSection);\r
\r
      //\r
      //  Wait for interrupts to be enabled.\r
      //\r
      while (!mInterruptEnabled) {\r
        Sleep (1);\r
      }\r
\r
      //\r
      //  Suspend the main thread until we are done\r
      //\r
      EnterCriticalSection (&mNtCriticalSection);\r
      SuspendThread (mNtMainThreadHandle);\r
    }\r
\r
    //\r
    //  Get the current system tick\r
    //\r
    CurrentTick = GetTickCount ();\r
    Delta = CurrentTick - mNtLastTick;\r
    mNtLastTick = CurrentTick;\r
\r
    //\r
    //  If delay was more then 1 second, ignore it (probably debugging case)\r
    //\r
    if (Delta < 1000) {\r
\r
      //\r
      // Only invoke the callback function if a Non-NULL handler has been\r
      // registered. Assume all other handlers are legal.\r
      //\r
      if (mTimerNotifyFunction != NULL) {\r
        mTimerNotifyFunction (Delta);\r
      }\r
    }\r
\r
    //\r
    //  Resume the main thread\r
    //\r
    ResumeThread (mNtMainThreadHandle);\r
    LeaveCriticalSection (&mNtCriticalSection);\r
  } else {\r
    timeKillEvent (wTimerID);\r
    mMMTimerThreadID = 0;\r
  }\r
\r
}\r
\r
VOID\r
SecSetTimer (\r
  IN  UINT64                  TimerPeriod,\r
  IN  EMU_SET_TIMER_CALLBACK  Callback\r
)\r
{\r
  //\r
// If TimerPeriod is 0, then the timer thread should be canceled\r
//\r
  if (TimerPeriod == 0) {\r
    //\r
    // Cancel the timer thread\r
    //\r
    EnterCriticalSection (&mNtCriticalSection);\r
\r
    mCancelTimerThread = TRUE;\r
\r
    LeaveCriticalSection (&mNtCriticalSection);\r
\r
    //\r
    // Wait for the timer thread to exit\r
    //\r
\r
    if (mMMTimerThreadID != 0) {\r
      timeKillEvent (mMMTimerThreadID);\r
      mMMTimerThreadID = 0;\r
    }\r
  } else {\r
    //\r
    // If the TimerPeriod is valid, then create and/or adjust the period of the timer thread\r
    //\r
    EnterCriticalSection (&mNtCriticalSection);\r
\r
    mCancelTimerThread = FALSE;\r
\r
    LeaveCriticalSection (&mNtCriticalSection);\r
\r
    //\r
    //  Get the starting tick location if we are just starting the timer thread\r
    //\r
    mNtLastTick = GetTickCount ();\r
\r
    if (mMMTimerThreadID) {\r
      timeKillEvent (mMMTimerThreadID);\r
    }\r
\r
    SetThreadPriority (\r
      GetCurrentThread (),\r
      THREAD_PRIORITY_HIGHEST\r
    );\r
\r
    mMMTimerThreadID = timeSetEvent (\r
      (UINT)TimerPeriod,\r
      0,\r
      MMTimerThread,\r
      (DWORD_PTR)NULL,\r
      TIME_PERIODIC | TIME_KILL_SYNCHRONOUS | TIME_CALLBACK_FUNCTION\r
    );\r
  }\r
  mTimerNotifyFunction = Callback;\r
}\r
\r
VOID\r
SecInitializeThunk (\r
  VOID\r
)\r
{\r
  InitializeCriticalSection (&mNtCriticalSection);\r
\r
  DuplicateHandle (\r
    GetCurrentProcess (),\r
    GetCurrentThread (),\r
    GetCurrentProcess (),\r
    &mNtMainThreadHandle,\r
    0,\r
    FALSE,\r
    DUPLICATE_SAME_ACCESS\r
  );\r
}\r
\r
VOID\r
SecEnableInterrupt (\r
  VOID\r
  )\r
{\r
  mInterruptEnabled = TRUE;\r
}\r
\r
\r
VOID\r
SecDisableInterrupt (\r
  VOID\r
  )\r
{\r
  mInterruptEnabled = FALSE;\r
}\r
\r
\r
UINT64\r
SecQueryPerformanceFrequency (\r
  VOID\r
  )\r
{\r
  // Hard code to nanoseconds\r
  return 1000000000ULL;\r
}\r
\r
UINT64\r
SecQueryPerformanceCounter (\r
  VOID\r
  )\r
{\r
  return 0;\r
}\r
\r
\r
\r
VOID\r
SecSleep (\r
  IN  UINT64 Nanoseconds\r
  )\r
{\r
  Sleep ((DWORD)DivU64x32 (Nanoseconds, 1000000));\r
}\r
\r
\r
VOID\r
SecCpuSleep (\r
  VOID\r
  )\r
{\r
  Sleep (1);\r
}\r
\r
\r
VOID\r
SecExit (\r
  UINTN   Status\r
  )\r
{\r
  exit ((int)Status);\r
}\r
\r
\r
VOID\r
SecGetTime (\r
  OUT  EFI_TIME               *Time,\r
  OUT EFI_TIME_CAPABILITIES   *Capabilities OPTIONAL\r
  )\r
{\r
  SYSTEMTIME            SystemTime;\r
  TIME_ZONE_INFORMATION TimeZone;\r
\r
  GetLocalTime (&SystemTime);\r
  GetTimeZoneInformation (&TimeZone);\r
\r
  Time->Year = (UINT16)SystemTime.wYear;\r
  Time->Month = (UINT8)SystemTime.wMonth;\r
  Time->Day = (UINT8)SystemTime.wDay;\r
  Time->Hour = (UINT8)SystemTime.wHour;\r
  Time->Minute = (UINT8)SystemTime.wMinute;\r
  Time->Second = (UINT8)SystemTime.wSecond;\r
  Time->Nanosecond = (UINT32)(SystemTime.wMilliseconds * 1000000);\r
  Time->TimeZone = (INT16)TimeZone.Bias;\r
\r
  if (Capabilities != NULL) {\r
    Capabilities->Resolution = 1;\r
    Capabilities->Accuracy = 50000000;\r
    Capabilities->SetsToZero = FALSE;\r
  }\r
\r
  Time->Daylight = 0;\r
  if (TimeZone.StandardDate.wMonth) {\r
    Time->Daylight = (UINT8)TimeZone.StandardDate.wMonth;\r
  }\r
}\r
\r
EFI_STATUS\r
SecSetTime (\r
  IN  EFI_TIME               *Time\r
  )\r
{\r
  TIME_ZONE_INFORMATION TimeZone;\r
  SYSTEMTIME            SystemTime;\r
  BOOL                  Flag;\r
\r
  //\r
  // Set Daylight savings time information and Time Zone\r
  //\r
  GetTimeZoneInformation (&TimeZone);\r
  TimeZone.StandardDate.wMonth = Time->Daylight;\r
  TimeZone.Bias = Time->TimeZone;\r
  Flag = SetTimeZoneInformation (&TimeZone);\r
  if (!Flag) {\r
    return EFI_DEVICE_ERROR;\r
  }\r
\r
  SystemTime.wYear = Time->Year;\r
  SystemTime.wMonth = Time->Month;\r
  SystemTime.wDay = Time->Day;\r
  SystemTime.wHour = Time->Hour;\r
  SystemTime.wMinute = Time->Minute;\r
  SystemTime.wSecond = Time->Second;\r
  SystemTime.wMilliseconds = (INT16)(Time->Nanosecond / 1000000);\r
\r
  Flag = SetLocalTime (&SystemTime);\r
\r
  if (!Flag) {\r
    return EFI_DEVICE_ERROR;\r
  } else {\r
    return EFI_SUCCESS;\r
  }\r
}\r
\r
EMU_THUNK_PROTOCOL gEmuThunkProtocol = {\r
  SecWriteStdErr,\r
  SecConfigStdIn,\r
  SecWriteStdOut,\r
  SecReadStdIn,\r
  SecPollStdIn,\r
  SecAlloc,\r
  NULL,\r
  SecFree,\r
  SecPeCoffGetEntryPoint,\r
  PeCoffLoaderRelocateImageExtraAction,\r
  PeCoffLoaderUnloadImageExtraAction,\r
  SecEnableInterrupt,\r
  SecDisableInterrupt,\r
  SecQueryPerformanceFrequency,\r
  SecQueryPerformanceCounter,\r
  SecSleep,\r
  SecCpuSleep,\r
  SecExit,\r
  SecGetTime,\r
  SecSetTime,\r
  SecSetTimer,\r
  GetNextThunkProtocol\r
};\r
\r
\r
#pragma warning(default : 4996)\r
#pragma warning(default : 4232)\r
\r