sravan/system76-edk2
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

EmulatorPkg: Apply uncrustify changes

Browse Source 
REF: https://bugzilla.tianocore.org/show_bug.cgi?id=3737

Apply uncrustify changes to .c/.h files in the EmulatorPkg package

Cc: Andrew Fish <afish@apple.com>
Cc: Leif Lindholm <leif@nuviainc.com>
Cc: Michael D Kinney <michael.d.kinney@intel.com>
Signed-off-by: Michael Kubacki <michael.kubacki@microsoft.com>
Reviewed-by: Ray Ni <ray.ni@intel.com>
This commit is contained in:
Michael Kubacki
2021-12-05 14:53:57 -08:00
committed by mergify[bot]
parent e7108d0e96
commit a550d468a6
111 changed files with 6170 additions and 6345 deletions
Download Patch File Download Diff File Expand all files Collapse all files

218
EmulatorPkg/Win/Host/WinBlockIo.c
View File

@@ -7,63 +7,60 @@ SPDX-License-Identifier: BSD-2-Clause-Patent
#include "WinHost.h"
#define WIN_NT_BLOCK_IO_PRIVATE_SIGNATURE SIGNATURE_32 ('N', 'T', 'b', 'k')
#define WIN_NT_BLOCK_IO_PRIVATE_SIGNATURE SIGNATURE_32 ('N', 'T', 'b', 'k')
typedef struct {
UINTN Signature;
UINTN Signature;
EMU_IO_THUNK_PROTOCOL *Thunk;
EMU_IO_THUNK_PROTOCOL *Thunk;
CHAR16 *FileName;
BOOLEAN Removable;
BOOLEAN Readonly;
CHAR16 *FileName;
BOOLEAN Removable;
BOOLEAN Readonly;
HANDLE NtHandle;
UINT32 BlockSize;
HANDLE NtHandle;
UINT32 BlockSize;
EFI_BLOCK_IO_MEDIA *Media;
EMU_BLOCK_IO_PROTOCOL EmuBlockIo;
EFI_BLOCK_IO_MEDIA *Media;
EMU_BLOCK_IO_PROTOCOL EmuBlockIo;
} WIN_NT_BLOCK_IO_PRIVATE;
#define WIN_NT_BLOCK_IO_PRIVATE_DATA_FROM_THIS(a) \
CR(a, WIN_NT_BLOCK_IO_PRIVATE, EmuBlockIo, WIN_NT_BLOCK_IO_PRIVATE_SIGNATURE)
EFI_STATUS
WinNtBlockIoReset (
IN EMU_BLOCK_IO_PROTOCOL *This,
IN BOOLEAN ExtendedVerification
IN EMU_BLOCK_IO_PROTOCOL *This,
IN BOOLEAN ExtendedVerification
);
EFI_STATUS
SetFilePointer64 (
IN WIN_NT_BLOCK_IO_PRIVATE *Private,
IN INT64 DistanceToMove,
OUT UINT64 *NewFilePointer,
IN DWORD MoveMethod
)
IN WIN_NT_BLOCK_IO_PRIVATE *Private,
IN INT64 DistanceToMove,
OUT UINT64 *NewFilePointer,
IN DWORD MoveMethod
)
/*++
This function extends the capability of SetFilePointer to accept 64 bit parameters
--*/
{
EFI_STATUS Status;
LARGE_INTEGER LargeInt;
EFI_STATUS Status;
LARGE_INTEGER LargeInt;
LargeInt.QuadPart = DistanceToMove;
Status = EFI_SUCCESS;
Status = EFI_SUCCESS;
LargeInt.LowPart = SetFilePointer (
Private->NtHandle,
LargeInt.LowPart,
&LargeInt.HighPart,
MoveMethod
);
Private->NtHandle,
LargeInt.LowPart,
&LargeInt.HighPart,
MoveMethod
);
if (LargeInt.LowPart == -1 && GetLastError () != NO_ERROR) {
if ((LargeInt.LowPart == -1) && (GetLastError () != NO_ERROR)) {
Status = EFI_INVALID_PARAMETER;
}
@@ -74,16 +71,14 @@ This function extends the capability of SetFilePointer to accept 64 bit paramete
return Status;
}
EFI_STATUS
WinNtBlockIoOpenDevice (
IN WIN_NT_BLOCK_IO_PRIVATE *Private,
IN EFI_BLOCK_IO_MEDIA *Media
IN WIN_NT_BLOCK_IO_PRIVATE *Private,
IN EFI_BLOCK_IO_MEDIA *Media
)
{
EFI_STATUS Status;
UINT64 FileSize;
EFI_STATUS Status;
UINT64 FileSize;
//
// If the device is already opened, close it
@@ -96,19 +91,19 @@ WinNtBlockIoOpenDevice (
// Open the device
//
Private->NtHandle = CreateFile (
Private->FileName,
GENERIC_READ | (Private->Readonly ? 0 : GENERIC_WRITE),
FILE_SHARE_READ | FILE_SHARE_WRITE,
NULL,
OPEN_ALWAYS, // Create if it doesn't exist
0,
NULL
);
Private->FileName,
GENERIC_READ | (Private->Readonly ? 0 : GENERIC_WRITE),
FILE_SHARE_READ | FILE_SHARE_WRITE,
NULL,
OPEN_ALWAYS, // Create if it doesn't exist
0,
NULL
);
if (Private->NtHandle == INVALID_HANDLE_VALUE) {
DEBUG ((DEBUG_INFO, "OpenBlock: Could not open %S, %x\n", Private->FileName, GetLastError ()));
Media->MediaPresent = FALSE;
Status = EFI_NO_MEDIA;
Status = EFI_NO_MEDIA;
goto Done;
}
@@ -138,15 +133,14 @@ Done:
return Status;
}
EFI_STATUS
EFIAPI
WinNtBlockIoCreateMapping (
IN EMU_BLOCK_IO_PROTOCOL *This,
IN EFI_BLOCK_IO_MEDIA *Media
IN EMU_BLOCK_IO_PROTOCOL *This,
IN EFI_BLOCK_IO_MEDIA *Media
)
{
WIN_NT_BLOCK_IO_PRIVATE *Private;
WIN_NT_BLOCK_IO_PRIVATE *Private;
Private = WIN_NT_BLOCK_IO_PRIVATE_DATA_FROM_THIS (This);
@@ -164,7 +158,6 @@ WinNtBlockIoCreateMapping (
Media->LowestAlignedLba = 0;
Media->LogicalBlocksPerPhysicalBlock = 0;
// EFI_BLOCK_IO_PROTOCOL_REVISION3
Media->OptimalTransferLengthGranularity = 0;
@@ -175,12 +168,11 @@ WinNtBlockIoCreateMapping (
return WinNtBlockIoOpenDevice (Private, Media);
}
EFI_STATUS
WinNtBlockIoError (
IN WIN_NT_BLOCK_IO_PRIVATE *Private
)
IN WIN_NT_BLOCK_IO_PRIVATE *Private
)
/*++
Routine Description:
@@ -197,49 +189,47 @@ Returns:
--*/
{
EFI_BLOCK_IO_MEDIA *Media;
EFI_STATUS Status;
EFI_BLOCK_IO_MEDIA *Media;
EFI_STATUS Status;
Media = Private->Media;
switch (GetLastError ()) {
case ERROR_NOT_READY:
Media->ReadOnly = FALSE;
Media->MediaPresent = FALSE;
Status = EFI_NO_MEDIA;
break;
case ERROR_NOT_READY:
Media->ReadOnly = FALSE;
Media->MediaPresent = FALSE;
Status = EFI_NO_MEDIA;
break;
case ERROR_WRONG_DISK:
Media->ReadOnly = FALSE;
Media->MediaPresent = TRUE;
Media->MediaId++;
Status = EFI_MEDIA_CHANGED;
break;
case ERROR_WRONG_DISK:
Media->ReadOnly = FALSE;
Media->MediaPresent = TRUE;
Media->MediaId++;
Status = EFI_MEDIA_CHANGED;
break;
case ERROR_WRITE_PROTECT:
Media->ReadOnly = TRUE;
Status = EFI_WRITE_PROTECTED;
break;
case ERROR_WRITE_PROTECT:
Media->ReadOnly = TRUE;
Status = EFI_WRITE_PROTECTED;
break;
default:
Status = EFI_DEVICE_ERROR;
break;
default:
Status = EFI_DEVICE_ERROR;
break;
}
if (Status == EFI_NO_MEDIA || Status == EFI_MEDIA_CHANGED) {
if ((Status == EFI_NO_MEDIA) || (Status == EFI_MEDIA_CHANGED)) {
WinNtBlockIoReset (&Private->EmuBlockIo, FALSE);
}
return Status;
}
EFI_STATUS
WinNtSignalToken (
IN OUT EFI_BLOCK_IO2_TOKEN *Token,
IN EFI_STATUS Status
)
IN OUT EFI_BLOCK_IO2_TOKEN *Token,
IN EFI_STATUS Status
)
{
if (Token != NULL) {
if (Token->Event != NULL) {
@@ -248,6 +238,7 @@ WinNtSignalToken (
return EFI_SUCCESS;
}
}
return Status;
}
@@ -291,15 +282,15 @@ WinNtBlockIoReadBlocks (
IN EFI_LBA Lba,
IN OUT EFI_BLOCK_IO2_TOKEN *Token,
IN UINTN BufferSize,
OUT VOID *Buffer
OUT VOID *Buffer
)
{
WIN_NT_BLOCK_IO_PRIVATE *Private;
BOOL Flag;
EFI_STATUS Status;
DWORD BytesRead;
UINT64 DistanceToMove;
UINT64 DistanceMoved;
WIN_NT_BLOCK_IO_PRIVATE *Private;
BOOL Flag;
EFI_STATUS Status;
DWORD BytesRead;
UINT64 DistanceToMove;
UINT64 DistanceMoved;
Private = WIN_NT_BLOCK_IO_PRIVATE_DATA_FROM_THIS (This);
@@ -307,7 +298,7 @@ WinNtBlockIoReadBlocks (
// Seek to proper position
//
DistanceToMove = MultU64x32 (Lba, (UINT32)Private->BlockSize);
Status = SetFilePointer64 (Private, DistanceToMove, &DistanceMoved, FILE_BEGIN);
Status = SetFilePointer64 (Private, DistanceToMove, &DistanceMoved, FILE_BEGIN);
if (EFI_ERROR (Status) || (DistanceToMove != DistanceMoved)) {
DEBUG ((DEBUG_INIT, "ReadBlocks: SetFilePointer failed\n"));
@@ -323,7 +314,6 @@ WinNtBlockIoReadBlocks (
return WinNtSignalToken (Token, EFI_SUCCESS);
}
/**
Write BufferSize bytes from Lba into Buffer.
@@ -365,12 +355,12 @@ WinNtBlockIoWriteBlocks (
IN VOID *Buffer
)
{
WIN_NT_BLOCK_IO_PRIVATE *Private;
UINTN BytesWritten;
BOOL Success;
EFI_STATUS Status;
UINT64 DistanceToMove;
UINT64 DistanceMoved;
WIN_NT_BLOCK_IO_PRIVATE *Private;
UINTN BytesWritten;
BOOL Success;
EFI_STATUS Status;
UINT64 DistanceToMove;
UINT64 DistanceMoved;
Private = WIN_NT_BLOCK_IO_PRIVATE_DATA_FROM_THIS (This);
@@ -378,7 +368,7 @@ WinNtBlockIoWriteBlocks (
// Seek to proper position
//
DistanceToMove = MultU64x32 (Lba, (UINT32)Private->BlockSize);
Status = SetFilePointer64 (Private, DistanceToMove, &DistanceMoved, FILE_BEGIN);
Status = SetFilePointer64 (Private, DistanceToMove, &DistanceMoved, FILE_BEGIN);
if (EFI_ERROR (Status) || (DistanceToMove != DistanceMoved)) {
DEBUG ((DEBUG_INIT, "WriteBlocks: SetFilePointer failed\n"));
@@ -422,14 +412,13 @@ WinNtBlockIoWriteBlocks (
**/
EFI_STATUS
WinNtBlockIoFlushBlocks (
IN EMU_BLOCK_IO_PROTOCOL *This,
IN OUT EFI_BLOCK_IO2_TOKEN *Token
IN EMU_BLOCK_IO_PROTOCOL *This,
IN OUT EFI_BLOCK_IO2_TOKEN *Token
)
{
return WinNtSignalToken (Token, EFI_SUCCESS);
}
/**
Reset the block device hardware.
@@ -445,11 +434,11 @@ WinNtBlockIoFlushBlocks (
**/
EFI_STATUS
WinNtBlockIoReset (
IN EMU_BLOCK_IO_PROTOCOL *This,
IN BOOLEAN ExtendedVerification
IN EMU_BLOCK_IO_PROTOCOL *This,
IN BOOLEAN ExtendedVerification
)
{
WIN_NT_BLOCK_IO_PRIVATE *Private;
WIN_NT_BLOCK_IO_PRIVATE *Private;
Private = WIN_NT_BLOCK_IO_PRIVATE_DATA_FROM_THIS (This);
@@ -461,7 +450,7 @@ WinNtBlockIoReset (
return EFI_SUCCESS;
}
EMU_BLOCK_IO_PROTOCOL gEmuBlockIoProtocol = {
EMU_BLOCK_IO_PROTOCOL gEmuBlockIoProtocol = {
WinNtBlockIoReset,
WinNtBlockIoReadBlocks,
WinNtBlockIoWriteBlocks,
@@ -472,7 +461,7 @@ EMU_BLOCK_IO_PROTOCOL gEmuBlockIoProtocol = {
EFI_STATUS
EFIAPI
WinNtBlockIoThunkOpen (
IN EMU_IO_THUNK_PROTOCOL *This
IN EMU_IO_THUNK_PROTOCOL *This
)
{
WIN_NT_BLOCK_IO_PRIVATE *Private;
@@ -487,12 +476,13 @@ WinNtBlockIoThunkOpen (
Private->Thunk = This;
CopyMem (&Private->EmuBlockIo, &gEmuBlockIoProtocol, sizeof (gEmuBlockIoProtocol));
Private->BlockSize = 512;
Private->NtHandle = INVALID_HANDLE_VALUE;
Private->NtHandle = INVALID_HANDLE_VALUE;
Private->FileName = AllocateCopyPool (StrSize (This->ConfigString), This->ConfigString);
if (Private->FileName == NULL) {
return EFI_OUT_OF_RESOURCES;
}
//
// Parse ConfigString
// <ConfigString> := <FileName> ':' [RF][OW] ':' <BlockSize>
@@ -503,12 +493,14 @@ WinNtBlockIoThunkOpen (
Private->Readonly = FALSE;
} else {
for (*Str++ = L'\0'; *Str != L'\0'; Str++) {
if (*Str == 'R' || *Str == 'F') {
Private->Removable = (BOOLEAN) (*Str == L'R');
if ((*Str == 'R') || (*Str == 'F')) {
Private->Removable = (BOOLEAN)(*Str == L'R');
}
if (*Str == 'O' || *Str == 'W') {
Private->Readonly = (BOOLEAN) (*Str == L'O');
if ((*Str == 'O') || (*Str == 'W')) {
Private->Readonly = (BOOLEAN)(*Str == L'O');
}
if (*Str == ':') {
Private->BlockSize = wcstol (++Str, NULL, 0);
break;
@@ -521,11 +513,10 @@ WinNtBlockIoThunkOpen (
return EFI_SUCCESS;
}
EFI_STATUS
EFIAPI
WinNtBlockIoThunkClose (
IN EMU_IO_THUNK_PROTOCOL *This
IN EMU_IO_THUNK_PROTOCOL *This
)
{
WIN_NT_BLOCK_IO_PRIVATE *Private;
@@ -536,15 +527,14 @@ WinNtBlockIoThunkClose (
if (Private->FileName != NULL) {
FreePool (Private->FileName);
}
FreePool (Private);
}
return EFI_SUCCESS;
}
EMU_IO_THUNK_PROTOCOL mWinNtBlockIoThunkIo = {
EMU_IO_THUNK_PROTOCOL mWinNtBlockIoThunkIo = {
&gEmuBlockIoProtocolGuid,
NULL,
NULL,

981
EmulatorPkg/Win/Host/WinFileSystem.c
View File

File diff suppressed because it is too large Load Diff

121
EmulatorPkg/Win/Host/WinGop.h
View File

@@ -17,7 +17,6 @@ Abstract:
#ifndef _WIN_GOP_H_
#define _WIN_GOP_H_
#include "WinHost.h"
#include <Protocol/EmuIoThunk.h>
@@ -39,87 +38,85 @@ Abstract:
// The value is 1 if the ALT key is down while the key is pressed/released;
// it is 0 if the WM_SYSKEYDOWN message is posted to the active window
// because no window has the keyboard focus.
#define GOP_EXTENDED_KEY (0x1 << 24)
#define GOP_ALT_KEY_PRESSED (0x1 << 29)
#define GOP_EXTENDED_KEY (0x1 << 24)
#define GOP_ALT_KEY_PRESSED (0x1 << 29)
#define KEYBOARD_TIMER_INTERVAL 200000 // 0.02s
#define KEYBOARD_TIMER_INTERVAL 200000 // 0.02s
#define MAX_Q 256
#define MAX_Q 256
typedef struct {
UINTN Front;
UINTN Rear;
EFI_KEY_DATA Q[MAX_Q];
CRITICAL_SECTION Cs;
UINTN Front;
UINTN Rear;
EFI_KEY_DATA Q[MAX_Q];
CRITICAL_SECTION Cs;
} GOP_QUEUE_FIXED;
#define WIN_NT_GOP_CLASS_NAME L"WinNtGopWindow"
#define WIN_NT_GOP_CLASS_NAME L"WinNtGopWindow"
typedef struct {
UINT64 Signature;
EMU_GRAPHICS_WINDOW_PROTOCOL GraphicsWindowIo;
UINT64 Signature;
EMU_GRAPHICS_WINDOW_PROTOCOL GraphicsWindowIo;
//
// GOP Private Data knowing when to start hardware
//
BOOLEAN HardwareNeedsStarting;
BOOLEAN HardwareNeedsStarting;
CHAR16 *WindowName;
CHAR16 Buffer[160];
CHAR16 *WindowName;
CHAR16 Buffer[160];
HANDLE ThreadInited; // Semaphore
HANDLE ThreadHandle; // Thread
DWORD ThreadId;
HANDLE ThreadInited; // Semaphore
HANDLE ThreadHandle; // Thread
DWORD ThreadId;
HWND WindowHandle;
WNDCLASSEX WindowsClass;
HWND WindowHandle;
WNDCLASSEX WindowsClass;
UINT32 Width;
UINT32 Height;
UINT32 Width;
UINT32 Height;
//
// This screen is used to redraw the screen when windows events happen. It's
// updated in the main thread and displayed in the windows thread.
//
BITMAPV4HEADER *VirtualScreenInfo;
BITMAPV4HEADER *VirtualScreenInfo;
FRAME_BUFFER_CONFIGURE *FrameBufferConfigure;
FRAME_BUFFER_CONFIGURE *FrameBufferConfigure;
//
// Keyboard Queue used by Simple Text In.
// QueueForRead: WinProc thread adds, and main thread removes.
//
GOP_QUEUE_FIXED QueueForRead;
GOP_QUEUE_FIXED QueueForRead;
EMU_GRAPHICS_WINDOW_REGISTER_KEY_NOTIFY_CALLBACK MakeRegisterdKeyCallback;
EMU_GRAPHICS_WINDOW_REGISTER_KEY_NOTIFY_CALLBACK BreakRegisterdKeyCallback;
VOID *RegisterdKeyCallbackContext;
EFI_KEY_STATE KeyState;
BOOLEAN LeftShift;
BOOLEAN RightShift;
BOOLEAN LeftAlt;
BOOLEAN RightAlt;
BOOLEAN LeftCtrl;
BOOLEAN RightCtrl;
BOOLEAN LeftLogo;
BOOLEAN RightLogo;
BOOLEAN Menu;
BOOLEAN SysReq;
BOOLEAN NumLock;
BOOLEAN ScrollLock;
BOOLEAN CapsLock;
BOOLEAN IsPartialKeySupport;
INT32 PointerPreviousX;
INT32 PointerPreviousY;
BOOLEAN PointerStateChanged;
EFI_SIMPLE_POINTER_STATE PointerState;
EFI_KEY_STATE KeyState;
BOOLEAN LeftShift;
BOOLEAN RightShift;
BOOLEAN LeftAlt;
BOOLEAN RightAlt;
BOOLEAN LeftCtrl;
BOOLEAN RightCtrl;
BOOLEAN LeftLogo;
BOOLEAN RightLogo;
BOOLEAN Menu;
BOOLEAN SysReq;
BOOLEAN NumLock;
BOOLEAN ScrollLock;
BOOLEAN CapsLock;
BOOLEAN IsPartialKeySupport;
INT32 PointerPreviousX;
INT32 PointerPreviousY;
BOOLEAN PointerStateChanged;
EFI_SIMPLE_POINTER_STATE PointerState;
} GRAPHICS_PRIVATE_DATA;
#define GRAPHICS_PRIVATE_DATA_SIGNATURE SIGNATURE_32 ('g', 'f', 'x', 'd')
#define GRAPHICS_PRIVATE_DATA_FROM_THIS(a) \
CR(a, GRAPHICS_PRIVATE_DATA, GraphicsWindowIo, GRAPHICS_PRIVATE_DATA_SIGNATURE)
//
// Gop Hardware abstraction internal worker functions
//
@@ -135,8 +132,8 @@ typedef struct {
**/
EFI_STATUS
GopPrivateAddKey (
IN GRAPHICS_PRIVATE_DATA *Private,
IN EFI_INPUT_KEY Key
IN GRAPHICS_PRIVATE_DATA *Private,
IN EFI_INPUT_KEY Key
);
EFI_STATUS
@@ -149,29 +146,29 @@ WinNtWndGetKey (
EFI_STATUS
EFIAPI
WinNtWndCheckKey (
IN EMU_GRAPHICS_WINDOW_PROTOCOL *GraphicsIo
IN EMU_GRAPHICS_WINDOW_PROTOCOL *GraphicsIo
);
EFI_STATUS
EFIAPI
WinNtWndKeySetState (
IN EMU_GRAPHICS_WINDOW_PROTOCOL *GraphicsIo,
IN EFI_KEY_TOGGLE_STATE *KeyToggleState
IN EMU_GRAPHICS_WINDOW_PROTOCOL *GraphicsIo,
IN EFI_KEY_TOGGLE_STATE *KeyToggleState
);
EFI_STATUS
EFIAPI
WinNtWndRegisterKeyNotify (
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
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
);
EFI_STATUS
EFIAPI
WinNtWndCheckPointer (
IN EMU_GRAPHICS_WINDOW_PROTOCOL *GraphicsIo
IN EMU_GRAPHICS_WINDOW_PROTOCOL *GraphicsIo
);
EFI_STATUS
@@ -180,13 +177,13 @@ WinNtWndGetPointerState (
IN EMU_GRAPHICS_WINDOW_PROTOCOL *GraphicsIo,
IN EFI_SIMPLE_POINTER_STATE *State
);
EFI_STATUS
GopPrivateCreateQ (
IN GRAPHICS_PRIVATE_DATA *Private,
IN GOP_QUEUE_FIXED *Queue
IN GRAPHICS_PRIVATE_DATA *Private,
IN GOP_QUEUE_FIXED *Queue
);
/**
TODO: Add function description
@@ -197,8 +194,8 @@ GopPrivateCreateQ (
**/
EFI_STATUS
GopPrivateDestroyQ (
IN GRAPHICS_PRIVATE_DATA *Private,
IN GOP_QUEUE_FIXED *Queue
IN GRAPHICS_PRIVATE_DATA *Private,
IN GOP_QUEUE_FIXED *Queue
);
#endif
#endif

132
EmulatorPkg/Win/Host/WinGopInput.c
View File

@@ -22,10 +22,8 @@ Abstract:
**/
#include "WinGop.h"
/**
TODO: Add function description
@@ -36,8 +34,8 @@ Abstract:
**/
EFI_STATUS
GopPrivateCreateQ (
IN GRAPHICS_PRIVATE_DATA *Private,
IN GOP_QUEUE_FIXED *Queue
IN GRAPHICS_PRIVATE_DATA *Private,
IN GOP_QUEUE_FIXED *Queue
)
{
InitializeCriticalSection (&Queue->Cs);
@@ -46,7 +44,6 @@ GopPrivateCreateQ (
return EFI_SUCCESS;
}
/**
TODO: Add function description
@@ -57,8 +54,8 @@ GopPrivateCreateQ (
**/
EFI_STATUS
GopPrivateDestroyQ (
IN GRAPHICS_PRIVATE_DATA *Private,
IN GOP_QUEUE_FIXED *Queue
IN GRAPHICS_PRIVATE_DATA *Private,
IN GOP_QUEUE_FIXED *Queue
)
{
Queue->Front = 0;
@@ -67,7 +64,6 @@ GopPrivateDestroyQ (
return EFI_SUCCESS;
}
/**
TODO: Add function description
@@ -80,9 +76,9 @@ GopPrivateDestroyQ (
**/
EFI_STATUS
GopPrivateAddQ (
IN GRAPHICS_PRIVATE_DATA *Private,
IN GOP_QUEUE_FIXED *Queue,
IN EFI_KEY_DATA *KeyData
IN GRAPHICS_PRIVATE_DATA *Private,
IN GOP_QUEUE_FIXED *Queue,
IN EFI_KEY_DATA *KeyData
)
{
EnterCriticalSection (&Queue->Cs);
@@ -93,13 +89,12 @@ GopPrivateAddQ (
}
CopyMem (&Queue->Q[Queue->Rear], KeyData, sizeof (EFI_KEY_DATA));
Queue->Rear = (Queue->Rear + 1) % MAX_Q;
Queue->Rear = (Queue->Rear + 1) % MAX_Q;
LeaveCriticalSection (&Queue->Cs);
return EFI_SUCCESS;
}
/**
TODO: Add function description
@@ -112,9 +107,9 @@ GopPrivateAddQ (
**/
EFI_STATUS
GopPrivateDeleteQ (
IN GRAPHICS_PRIVATE_DATA *Private,
IN GOP_QUEUE_FIXED *Queue,
OUT EFI_KEY_DATA *Key
IN GRAPHICS_PRIVATE_DATA *Private,
IN GOP_QUEUE_FIXED *Queue,
OUT EFI_KEY_DATA *Key
)
{
EnterCriticalSection (&Queue->Cs);
@@ -125,9 +120,9 @@ GopPrivateDeleteQ (
}
CopyMem (Key, &Queue->Q[Queue->Front], sizeof (EFI_KEY_DATA));
Queue->Front = (Queue->Front + 1) % MAX_Q;
Queue->Front = (Queue->Front + 1) % MAX_Q;
if (Key->Key.ScanCode == SCAN_NULL && Key->Key.UnicodeChar == CHAR_NULL) {
if ((Key->Key.ScanCode == SCAN_NULL) && (Key->Key.UnicodeChar == CHAR_NULL)) {
if (!Private->IsPartialKeySupport) {
//
// If partial keystrok is not enabled, don't return the partial keystroke.
@@ -137,11 +132,11 @@ GopPrivateDeleteQ (
return EFI_NOT_READY;
}
}
LeaveCriticalSection (&Queue->Cs);
return EFI_SUCCESS;
}
/**
TODO: Add function description
@@ -153,7 +148,7 @@ GopPrivateDeleteQ (
**/
EFI_STATUS
GopPrivateCheckQ (
IN GOP_QUEUE_FIXED *Queue
IN GOP_QUEUE_FIXED *Queue
)
{
if (Queue->Front == Queue->Rear) {
@@ -171,8 +166,8 @@ GopPrivateCheckQ (
**/
VOID
InitializeKeyState (
IN GRAPHICS_PRIVATE_DATA *Private,
IN EFI_KEY_STATE *KeyState
IN GRAPHICS_PRIVATE_DATA *Private,
IN EFI_KEY_STATE *KeyState
)
{
KeyState->KeyShiftState = EFI_SHIFT_STATE_VALID;
@@ -182,44 +177,57 @@ InitializeKeyState (
// Record Key shift state and toggle state
//
if (Private->LeftCtrl) {
KeyState->KeyShiftState |= EFI_LEFT_CONTROL_PRESSED;
KeyState->KeyShiftState |= EFI_LEFT_CONTROL_PRESSED;
}
if (Private->RightCtrl) {
KeyState->KeyShiftState |= EFI_RIGHT_CONTROL_PRESSED;
KeyState->KeyShiftState |= EFI_RIGHT_CONTROL_PRESSED;
}
if (Private->LeftAlt) {
KeyState->KeyShiftState |= EFI_LEFT_ALT_PRESSED;
KeyState->KeyShiftState |= EFI_LEFT_ALT_PRESSED;
}
if (Private->RightAlt) {
KeyState->KeyShiftState |= EFI_RIGHT_ALT_PRESSED;
KeyState->KeyShiftState |= EFI_RIGHT_ALT_PRESSED;
}
if (Private->LeftShift) {
KeyState->KeyShiftState |= EFI_LEFT_SHIFT_PRESSED;
KeyState->KeyShiftState |= EFI_LEFT_SHIFT_PRESSED;
}
if (Private->RightShift) {
KeyState->KeyShiftState |= EFI_RIGHT_SHIFT_PRESSED;
KeyState->KeyShiftState |= EFI_RIGHT_SHIFT_PRESSED;
}
if (Private->LeftLogo) {
KeyState->KeyShiftState |= EFI_LEFT_LOGO_PRESSED;
KeyState->KeyShiftState |= EFI_LEFT_LOGO_PRESSED;
}
if (Private->RightLogo) {
KeyState->KeyShiftState |= EFI_RIGHT_LOGO_PRESSED;
KeyState->KeyShiftState |= EFI_RIGHT_LOGO_PRESSED;
}
if (Private->Menu) {
KeyState->KeyShiftState |= EFI_MENU_KEY_PRESSED;
KeyState->KeyShiftState |= EFI_MENU_KEY_PRESSED;
}
if (Private->SysReq) {
KeyState->KeyShiftState |= EFI_SYS_REQ_PRESSED;
KeyState->KeyShiftState |= EFI_SYS_REQ_PRESSED;
}
if (Private->CapsLock) {
KeyState->KeyToggleState |= EFI_CAPS_LOCK_ACTIVE;
}
if (Private->NumLock) {
KeyState->KeyToggleState |= EFI_NUM_LOCK_ACTIVE;
}
if (Private->ScrollLock) {
KeyState->KeyToggleState |= EFI_SCROLL_LOCK_ACTIVE;
}
if (Private->IsPartialKeySupport) {
KeyState->KeyToggleState |= EFI_KEY_STATE_EXPOSED;
}
@@ -241,7 +249,7 @@ GopPrivateAddKey (
IN EFI_INPUT_KEY Key
)
{
EFI_KEY_DATA KeyData;
EFI_KEY_DATA KeyData;
KeyData.Key = Key;
InitializeKeyState (Private, &KeyData.KeyState);
@@ -251,7 +259,8 @@ GopPrivateAddKey (
//
if ((Private->LeftCtrl || Private->RightCtrl) &&
(KeyData.Key.UnicodeChar >= 1) && (KeyData.Key.UnicodeChar <= 26)
) {
)
{
if ((Private->LeftShift || Private->RightShift) == Private->CapsLock) {
KeyData.Key.UnicodeChar = (CHAR16)(KeyData.Key.UnicodeChar + L'a' - 1);
} else {
@@ -264,7 +273,8 @@ GopPrivateAddKey (
//
if (((KeyData.Key.UnicodeChar >= L'a') && (KeyData.Key.UnicodeChar <= L'z')) ||
((KeyData.Key.UnicodeChar >= L'A') && (KeyData.Key.UnicodeChar <= L'Z'))
) {
)
{
KeyData.KeyState.KeyShiftState &= ~(EFI_LEFT_SHIFT_PRESSED | EFI_RIGHT_SHIFT_PRESSED);
}
@@ -276,26 +286,26 @@ GopPrivateAddKey (
return EFI_SUCCESS;
}
EFI_STATUS
EFIAPI
WinNtWndCheckKey (
IN EMU_GRAPHICS_WINDOW_PROTOCOL *GraphicsIo
IN EMU_GRAPHICS_WINDOW_PROTOCOL *GraphicsIo
)
{
GRAPHICS_PRIVATE_DATA *Private;
GRAPHICS_PRIVATE_DATA *Private;
Private = GRAPHICS_PRIVATE_DATA_FROM_THIS (GraphicsIo);
return GopPrivateCheckQ (&Private->QueueForRead);
}
EFI_STATUS
EFIAPI
WinNtWndGetKey (
IN EMU_GRAPHICS_WINDOW_PROTOCOL *GraphicsIo,
IN EFI_KEY_DATA *KeyData
)
/*++
Routine Description:
@@ -316,15 +326,15 @@ WinNtWndGetKey (
--*/
{
EFI_STATUS Status;
GRAPHICS_PRIVATE_DATA *Private;
EFI_STATUS Status;
GRAPHICS_PRIVATE_DATA *Private;
Private = GRAPHICS_PRIVATE_DATA_FROM_THIS (GraphicsIo);
ZeroMem (&KeyData->Key, sizeof (KeyData->Key));
InitializeKeyState (Private, &KeyData->KeyState);
Status = GopPrivateCheckQ (&Private->QueueForRead);
Status = GopPrivateCheckQ (&Private->QueueForRead);
if (!EFI_ERROR (Status)) {
//
// If a Key press exists try and read it.
@@ -336,7 +346,7 @@ WinNtWndGetKey (
// EFI_NOT_READY.
//
if (!Private->IsPartialKeySupport) {
if (KeyData->Key.ScanCode == SCAN_NULL && KeyData->Key.UnicodeChar == CHAR_NULL) {
if ((KeyData->Key.ScanCode == SCAN_NULL) && (KeyData->Key.UnicodeChar == CHAR_NULL)) {
Status = EFI_NOT_READY;
}
}
@@ -344,51 +354,53 @@ WinNtWndGetKey (
}
return Status;
}
EFI_STATUS
EFIAPI
WinNtWndKeySetState (
IN EMU_GRAPHICS_WINDOW_PROTOCOL *GraphicsIo,
IN EFI_KEY_TOGGLE_STATE *KeyToggleState
IN EMU_GRAPHICS_WINDOW_PROTOCOL *GraphicsIo,
IN EFI_KEY_TOGGLE_STATE *KeyToggleState
)
{
GRAPHICS_PRIVATE_DATA *Private;
GRAPHICS_PRIVATE_DATA *Private;
Private = GRAPHICS_PRIVATE_DATA_FROM_THIS (GraphicsIo);
Private->ScrollLock = FALSE;
Private->NumLock = FALSE;
Private->CapsLock = FALSE;
Private = GRAPHICS_PRIVATE_DATA_FROM_THIS (GraphicsIo);
Private->ScrollLock = FALSE;
Private->NumLock = FALSE;
Private->CapsLock = FALSE;
Private->IsPartialKeySupport = FALSE;
if ((*KeyToggleState & EFI_SCROLL_LOCK_ACTIVE) == EFI_SCROLL_LOCK_ACTIVE) {
Private->ScrollLock = TRUE;
}
if ((*KeyToggleState & EFI_NUM_LOCK_ACTIVE) == EFI_NUM_LOCK_ACTIVE) {
Private->NumLock = TRUE;
}
if ((*KeyToggleState & EFI_CAPS_LOCK_ACTIVE) == EFI_CAPS_LOCK_ACTIVE) {
Private->CapsLock = TRUE;
}
if ((*KeyToggleState & EFI_KEY_STATE_EXPOSED) == EFI_KEY_STATE_EXPOSED) {
Private->IsPartialKeySupport = TRUE;
}
Private->KeyState.KeyToggleState = *KeyToggleState;
return EFI_SUCCESS;
}
EFI_STATUS
EFIAPI
WinNtWndRegisterKeyNotify (
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
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_PRIVATE_DATA *Private;
GRAPHICS_PRIVATE_DATA *Private;
Private = GRAPHICS_PRIVATE_DATA_FROM_THIS (GraphicsIo);
@@ -402,10 +414,10 @@ WinNtWndRegisterKeyNotify (
EFI_STATUS
EFIAPI
WinNtWndCheckPointer (
IN EMU_GRAPHICS_WINDOW_PROTOCOL *GraphicsIo
IN EMU_GRAPHICS_WINDOW_PROTOCOL *GraphicsIo
)
{
GRAPHICS_PRIVATE_DATA *Private;
GRAPHICS_PRIVATE_DATA *Private;
Private = GRAPHICS_PRIVATE_DATA_FROM_THIS (GraphicsIo);
@@ -423,7 +435,7 @@ WinNtWndGetPointerState (
IN EFI_SIMPLE_POINTER_STATE *State
)
{
GRAPHICS_PRIVATE_DATA *Private;
GRAPHICS_PRIVATE_DATA *Private;
Private = GRAPHICS_PRIVATE_DATA_FROM_THIS (GraphicsIo);

705
EmulatorPkg/Win/Host/WinGopScreen.c
View File

@@ -18,8 +18,8 @@ Abstract:
#include "WinGop.h"
DWORD mTlsIndex = TLS_OUT_OF_INDEXES;
DWORD mTlsIndexUseCount = 0; // lets us know when we can free mTlsIndex.
DWORD mTlsIndex = TLS_OUT_OF_INDEXES;
DWORD mTlsIndexUseCount = 0; // lets us know when we can free mTlsIndex.
BOOLEAN
WinNtGopConvertParamToEfiKeyShiftState (
@@ -30,75 +30,78 @@ WinNtGopConvertParamToEfiKeyShiftState (
)
{
switch (*wParam) {
//
// BUGBUG: Only GetAsyncKeyState() and GetKeyState() can distinguish
// left and right Ctrl, and Shift key.
// Neither of the two is defined in EFI_WIN_NT_THUNK_PROTOCOL.
// Therefor, we can not set the correct Shift state here.
//
case VK_SHIFT:
if ((*lParam & GOP_EXTENDED_KEY) == GOP_EXTENDED_KEY) {
//
// BUGBUG: Only GetAsyncKeyState() and GetKeyState() can distinguish
// left and right Ctrl, and Shift key.
// Neither of the two is defined in EFI_WIN_NT_THUNK_PROTOCOL.
// Therefor, we can not set the correct Shift state here.
//
case VK_SHIFT:
if ((*lParam & GOP_EXTENDED_KEY) == GOP_EXTENDED_KEY) {
Private->RightShift = Flag;
} else {
Private->LeftShift = Flag;
}
return TRUE;
case VK_LSHIFT:
Private->LeftShift = Flag;
return TRUE;
return TRUE;
case VK_RSHIFT:
Private->RightShift = Flag;
return TRUE;
case VK_LSHIFT:
Private->LeftShift = Flag;
return TRUE;
case VK_CONTROL:
if ((*lParam & GOP_EXTENDED_KEY) == GOP_EXTENDED_KEY) {
Private->RightCtrl= Flag;
case VK_RSHIFT:
Private->RightShift = Flag;
return TRUE;
case VK_CONTROL:
if ((*lParam & GOP_EXTENDED_KEY) == GOP_EXTENDED_KEY) {
Private->RightCtrl = Flag;
} else {
Private->LeftCtrl = Flag;
}
return TRUE;
case VK_LCONTROL:
Private->LeftCtrl = Flag;
return TRUE;
return TRUE;
case VK_RCONTROL:
Private->RightCtrl = Flag;
return TRUE;
case VK_LCONTROL:
Private->LeftCtrl = Flag;
return TRUE;
case VK_LWIN:
Private->LeftLogo = Flag;
return TRUE;
case VK_RCONTROL:
Private->RightCtrl = Flag;
return TRUE;
case VK_RWIN:
Private->RightLogo = Flag;
return TRUE;
case VK_LWIN:
Private->LeftLogo = Flag;
return TRUE;
case VK_APPS:
Private->Menu = Flag;
return TRUE;
//
// BUGBUG: PrintScreen/SysRq can not trigger WM_KEYDOWN message,
// so SySReq shift state is not supported here.
//
case VK_PRINT:
Private->SysReq = Flag;
return TRUE;
//
// For Alt Keystroke.
//
case VK_MENU:
if ((*lParam & GOP_EXTENDED_KEY) == GOP_EXTENDED_KEY) {
case VK_RWIN:
Private->RightLogo = Flag;
return TRUE;
case VK_APPS:
Private->Menu = Flag;
return TRUE;
//
// BUGBUG: PrintScreen/SysRq can not trigger WM_KEYDOWN message,
// so SySReq shift state is not supported here.
//
case VK_PRINT:
Private->SysReq = Flag;
return TRUE;
//
// For Alt Keystroke.
//
case VK_MENU:
if ((*lParam & GOP_EXTENDED_KEY) == GOP_EXTENDED_KEY) {
Private->RightAlt = Flag;
} else {
Private->LeftAlt = Flag;
}
return TRUE;
default:
return FALSE;
return TRUE;
default:
return FALSE;
}
}
@@ -110,68 +113,138 @@ WinNtGopConvertParamToEfiKey (
IN EFI_INPUT_KEY *Key
)
{
BOOLEAN Flag;
BOOLEAN Flag;
Flag = FALSE;
switch (*wParam) {
case VK_HOME: Key->ScanCode = SCAN_HOME; Flag = TRUE; break;
case VK_END: Key->ScanCode = SCAN_END; Flag = TRUE; break;
case VK_LEFT: Key->ScanCode = SCAN_LEFT; Flag = TRUE; break;
case VK_RIGHT: Key->ScanCode = SCAN_RIGHT; Flag = TRUE; break;
case VK_UP: Key->ScanCode = SCAN_UP; Flag = TRUE; break;
case VK_DOWN: Key->ScanCode = SCAN_DOWN; Flag = TRUE; break;
case VK_DELETE: Key->ScanCode = SCAN_DELETE; Flag = TRUE; break;
case VK_INSERT: Key->ScanCode = SCAN_INSERT; Flag = TRUE; break;
case VK_PRIOR: Key->ScanCode = SCAN_PAGE_UP; Flag = TRUE; break;
case VK_NEXT: Key->ScanCode = SCAN_PAGE_DOWN; Flag = TRUE; break;
case VK_ESCAPE: Key->ScanCode = SCAN_ESC; Flag = TRUE; break;
case VK_HOME: Key->ScanCode = SCAN_HOME;
Flag = TRUE;
break;
case VK_END: Key->ScanCode = SCAN_END;
Flag = TRUE;
break;
case VK_LEFT: Key->ScanCode = SCAN_LEFT;
Flag = TRUE;
break;
case VK_RIGHT: Key->ScanCode = SCAN_RIGHT;
Flag = TRUE;
break;
case VK_UP: Key->ScanCode = SCAN_UP;
Flag = TRUE;
break;
case VK_DOWN: Key->ScanCode = SCAN_DOWN;
Flag = TRUE;
break;
case VK_DELETE: Key->ScanCode = SCAN_DELETE;
Flag = TRUE;
break;
case VK_INSERT: Key->ScanCode = SCAN_INSERT;
Flag = TRUE;
break;
case VK_PRIOR: Key->ScanCode = SCAN_PAGE_UP;
Flag = TRUE;
break;
case VK_NEXT: Key->ScanCode = SCAN_PAGE_DOWN;
Flag = TRUE;
break;
case VK_ESCAPE: Key->ScanCode = SCAN_ESC;
Flag = TRUE;
break;
case VK_F1: Key->ScanCode = SCAN_F1; Flag = TRUE; break;
case VK_F2: Key->ScanCode = SCAN_F2; Flag = TRUE; break;
case VK_F3: Key->ScanCode = SCAN_F3; Flag = TRUE; break;
case VK_F4: Key->ScanCode = SCAN_F4; Flag = TRUE; break;
case VK_F5: Key->ScanCode = SCAN_F5; Flag = TRUE; break;
case VK_F6: Key->ScanCode = SCAN_F6; Flag = TRUE; break;
case VK_F7: Key->ScanCode = SCAN_F7; Flag = TRUE; break;
case VK_F8: Key->ScanCode = SCAN_F8; Flag = TRUE; break;
case VK_F9: Key->ScanCode = SCAN_F9; Flag = TRUE; break;
case VK_F11: Key->ScanCode = SCAN_F11; Flag = TRUE; break;
case VK_F12: Key->ScanCode = SCAN_F12; Flag = TRUE; break;
case VK_F1: Key->ScanCode = SCAN_F1;
Flag = TRUE;
break;
case VK_F2: Key->ScanCode = SCAN_F2;
Flag = TRUE;
break;
case VK_F3: Key->ScanCode = SCAN_F3;
Flag = TRUE;
break;
case VK_F4: Key->ScanCode = SCAN_F4;
Flag = TRUE;
break;
case VK_F5: Key->ScanCode = SCAN_F5;
Flag = TRUE;
break;
case VK_F6: Key->ScanCode = SCAN_F6;
Flag = TRUE;
break;
case VK_F7: Key->ScanCode = SCAN_F7;
Flag = TRUE;
break;
case VK_F8: Key->ScanCode = SCAN_F8;
Flag = TRUE;
break;
case VK_F9: Key->ScanCode = SCAN_F9;
Flag = TRUE;
break;
case VK_F11: Key->ScanCode = SCAN_F11;
Flag = TRUE;
break;
case VK_F12: Key->ScanCode = SCAN_F12;
Flag = TRUE;
break;
case VK_F13: Key->ScanCode = SCAN_F13; Flag = TRUE; break;
case VK_F14: Key->ScanCode = SCAN_F14; Flag = TRUE; break;
case VK_F15: Key->ScanCode = SCAN_F15; Flag = TRUE; break;
case VK_F16: Key->ScanCode = SCAN_F16; Flag = TRUE; break;
case VK_F17: Key->ScanCode = SCAN_F17; Flag = TRUE; break;
case VK_F18: Key->ScanCode = SCAN_F18; Flag = TRUE; break;
case VK_F19: Key->ScanCode = SCAN_F19; Flag = TRUE; break;
case VK_F20: Key->ScanCode = SCAN_F20; Flag = TRUE; break;
case VK_F21: Key->ScanCode = SCAN_F21; Flag = TRUE; break;
case VK_F22: Key->ScanCode = SCAN_F22; Flag = TRUE; break;
case VK_F23: Key->ScanCode = SCAN_F23; Flag = TRUE; break;
case VK_F24: Key->ScanCode = SCAN_F24; Flag = TRUE; break;
case VK_PAUSE: Key->ScanCode = SCAN_PAUSE; Flag = TRUE; break;
case VK_F13: Key->ScanCode = SCAN_F13;
Flag = TRUE;
break;
case VK_F14: Key->ScanCode = SCAN_F14;
Flag = TRUE;
break;
case VK_F15: Key->ScanCode = SCAN_F15;
Flag = TRUE;
break;
case VK_F16: Key->ScanCode = SCAN_F16;
Flag = TRUE;
break;
case VK_F17: Key->ScanCode = SCAN_F17;
Flag = TRUE;
break;
case VK_F18: Key->ScanCode = SCAN_F18;
Flag = TRUE;
break;
case VK_F19: Key->ScanCode = SCAN_F19;
Flag = TRUE;
break;
case VK_F20: Key->ScanCode = SCAN_F20;
Flag = TRUE;
break;
case VK_F21: Key->ScanCode = SCAN_F21;
Flag = TRUE;
break;
case VK_F22: Key->ScanCode = SCAN_F22;
Flag = TRUE;
break;
case VK_F23: Key->ScanCode = SCAN_F23;
Flag = TRUE;
break;
case VK_F24: Key->ScanCode = SCAN_F24;
Flag = TRUE;
break;
case VK_PAUSE: Key->ScanCode = SCAN_PAUSE;
Flag = TRUE;
break;
//
// Set toggle state
//
case VK_NUMLOCK:
Private->NumLock = (BOOLEAN)(!Private->NumLock);
Flag = TRUE;
break;
case VK_SCROLL:
Private->ScrollLock = (BOOLEAN)(!Private->ScrollLock);
Flag = TRUE;
break;
case VK_CAPITAL:
Private->CapsLock = (BOOLEAN)(!Private->CapsLock);
Flag = TRUE;
break;
//
// Set toggle state
//
case VK_NUMLOCK:
Private->NumLock = (BOOLEAN)(!Private->NumLock);
Flag = TRUE;
break;
case VK_SCROLL:
Private->ScrollLock = (BOOLEAN)(!Private->ScrollLock);
Flag = TRUE;
break;
case VK_CAPITAL:
Private->CapsLock = (BOOLEAN)(!Private->CapsLock);
Flag = TRUE;
break;
}
return (WinNtGopConvertParamToEfiKeyShiftState (Private, wParam, lParam, TRUE)) == TRUE ? TRUE : Flag;
}
//
// GOP Protocol Member Functions
//
@@ -185,15 +258,15 @@ WinNtWndSize (
IN EMU_GRAPHICS_WINDOW_PROTOCOL *GraphicsIo,
IN UINT32 Width,
IN UINT32 Height
)
)
{
RETURN_STATUS RStatus;
EFI_GRAPHICS_OUTPUT_MODE_INFORMATION Info;
GRAPHICS_PRIVATE_DATA *Private;
RECT Rect;
BITMAPV4HEADER *VirtualScreenInfo;
FRAME_BUFFER_CONFIGURE *FrameBufferConfigure;
UINTN FrameBufferConfigureSize;
RETURN_STATUS RStatus;
EFI_GRAPHICS_OUTPUT_MODE_INFORMATION Info;
GRAPHICS_PRIVATE_DATA *Private;
RECT Rect;
BITMAPV4HEADER *VirtualScreenInfo;
FRAME_BUFFER_CONFIGURE *FrameBufferConfigure;
UINTN FrameBufferConfigureSize;
Private = GRAPHICS_PRIVATE_DATA_FROM_THIS (GraphicsIo);
@@ -202,10 +275,10 @@ WinNtWndSize (
// This buffer is the virtual screen/frame buffer.
//
VirtualScreenInfo = HeapAlloc (
GetProcessHeap (),
HEAP_ZERO_MEMORY,
Width * Height * sizeof (RGBQUAD) + sizeof (BITMAPV4HEADER)
);
GetProcessHeap (),
HEAP_ZERO_MEMORY,
Width * Height * sizeof (RGBQUAD) + sizeof (BITMAPV4HEADER)
);
if (VirtualScreenInfo == NULL) {
return EFI_OUT_OF_RESOURCES;
}
@@ -214,10 +287,10 @@ WinNtWndSize (
// Update the virtual screen info data structure
// Use negative Height to make sure screen/buffer are using the same coordinate.
//
VirtualScreenInfo->bV4Size = sizeof (BITMAPV4HEADER);
VirtualScreenInfo->bV4Width = Width;
VirtualScreenInfo->bV4Height = -(LONG)Height;
VirtualScreenInfo->bV4Planes = 1;
VirtualScreenInfo->bV4Size = sizeof (BITMAPV4HEADER);
VirtualScreenInfo->bV4Width = Width;
VirtualScreenInfo->bV4Height = -(LONG)Height;
VirtualScreenInfo->bV4Planes = 1;
VirtualScreenInfo->bV4BitCount = 32;
//
// uncompressed
@@ -229,20 +302,21 @@ WinNtWndSize (
Info.PixelFormat = PixelBlueGreenRedReserved8BitPerColor;
Info.PixelsPerScanLine = Width;
FrameBufferConfigureSize = 0;
RStatus = FrameBufferBltConfigure (VirtualScreenInfo + 1, &Info, NULL, &FrameBufferConfigureSize);
RStatus = FrameBufferBltConfigure (VirtualScreenInfo + 1, &Info, NULL, &FrameBufferConfigureSize);
ASSERT (RStatus == EFI_BUFFER_TOO_SMALL);
FrameBufferConfigure = AllocatePool (FrameBufferConfigureSize);
if (FrameBufferConfigure == NULL) {
HeapFree (GetProcessHeap (), 0, VirtualScreenInfo);
return EFI_OUT_OF_RESOURCES;
}
RStatus = FrameBufferBltConfigure (VirtualScreenInfo + 1, &Info, FrameBufferConfigure, &FrameBufferConfigureSize);
ASSERT_RETURN_ERROR (RStatus);
if (Private->FrameBufferConfigure != NULL) {
FreePool (Private->FrameBufferConfigure);
}
Private->FrameBufferConfigure = FrameBufferConfigure;
//
@@ -253,6 +327,7 @@ WinNtWndSize (
if (Private->VirtualScreenInfo != NULL) {
HeapFree (GetProcessHeap (), 0, Private->VirtualScreenInfo);
}
Private->VirtualScreenInfo = VirtualScreenInfo;
Private->Width = Width;
@@ -321,24 +396,27 @@ WinNtWndSize (
// TODO: Delta - add argument and description to function comment
EFI_STATUS
WinNtWndBlt (
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
)
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
)
{
RETURN_STATUS RStatus;
GRAPHICS_PRIVATE_DATA *Private;
RECT Rect;
RETURN_STATUS RStatus;
GRAPHICS_PRIVATE_DATA *Private;
RECT Rect;
Private = GRAPHICS_PRIVATE_DATA_FROM_THIS (GraphicsIo);
RStatus = FrameBufferBlt (
Private->FrameBufferConfigure,
BltBuffer,
BltOperation,
Args->SourceX, Args->SourceY,
Args->DestinationX, Args->DestinationY,
Args->Width, Args->Height,
Args->SourceX,
Args->SourceY,
Args->DestinationX,
Args->DestinationY,
Args->Width,
Args->Height,
Args->Delta
);
if (RETURN_ERROR (RStatus)) {
@@ -370,8 +448,6 @@ WinNtWndBlt (
return EFI_SUCCESS;
}
/**
Win32 Windows event handler.
@@ -393,14 +469,14 @@ WinNtGopThreadWindowProc (
IN LPARAM lParam
)
{
GRAPHICS_PRIVATE_DATA *Private;
HDC Handle;
PAINTSTRUCT PaintStruct;
LPARAM Index;
EFI_INPUT_KEY Key;
BOOLEAN AltIsPress;
INT32 PosX;
INT32 PosY;
GRAPHICS_PRIVATE_DATA *Private;
HDC Handle;
PAINTSTRUCT PaintStruct;
LPARAM Index;
EFI_INPUT_KEY Key;
BOOLEAN AltIsPress;
INT32 PosX;
INT32 PosY;
//
// Use mTlsIndex global to get a Thread Local Storage version of Private.
@@ -408,190 +484,195 @@ WinNtGopThreadWindowProc (
// a unique thread.
//
AltIsPress = FALSE;
Private = TlsGetValue (mTlsIndex);
Private = TlsGetValue (mTlsIndex);
ASSERT (NULL != Private);
switch (iMsg) {
case WM_PAINT:
Handle = BeginPaint (hwnd, &PaintStruct);
case WM_PAINT:
Handle = BeginPaint (hwnd, &PaintStruct);
SetDIBitsToDevice (
Handle, // Destination Device Context
0, // Destination X - 0
0, // Destination Y - 0
Private->Width, // Width
Private->Height, // Height
0, // Source X
0, // Source Y
0, // DIB Start Scan Line
Private->Height, // Number of scan lines
Private->VirtualScreenInfo + 1, // Address of array of DIB bits
(BITMAPINFO *) Private->VirtualScreenInfo, // Address of structure with bitmap info
DIB_RGB_COLORS // RGB or palette indexes
);
SetDIBitsToDevice (
Handle, // Destination Device Context
0, // Destination X - 0
0, // Destination Y - 0
Private->Width, // Width
Private->Height, // Height
0, // Source X
0, // Source Y
0, // DIB Start Scan Line
Private->Height, // Number of scan lines
Private->VirtualScreenInfo + 1, // Address of array of DIB bits
(BITMAPINFO *)Private->VirtualScreenInfo, // Address of structure with bitmap info
DIB_RGB_COLORS // RGB or palette indexes
);
EndPaint (hwnd, &PaintStruct);
return 0;
//
// F10 and the ALT key do not create a WM_KEYDOWN message, thus this special case
// WM_SYSKEYDOWN is posted when F10 is pressed or
// holds down ALT key and then presses another key.
//
case WM_SYSKEYDOWN:
Key.ScanCode = 0;
Key.UnicodeChar = CHAR_NULL;
switch (wParam) {
case VK_F10:
Key.ScanCode = SCAN_F10;
Key.UnicodeChar = CHAR_NULL;
GopPrivateAddKey (Private, Key);
EndPaint (hwnd, &PaintStruct);
return 0;
}
//
// If ALT or ALT + modifier key is pressed.
// F10 and the ALT key do not create a WM_KEYDOWN message, thus this special case
// WM_SYSKEYDOWN is posted when F10 is pressed or
// holds down ALT key and then presses another key.
//
if (WinNtGopConvertParamToEfiKey (Private, &wParam, &lParam, &Key)) {
if (Key.ScanCode != 0){
case WM_SYSKEYDOWN:
Key.ScanCode = 0;
Key.UnicodeChar = CHAR_NULL;
switch (wParam) {
case VK_F10:
Key.ScanCode = SCAN_F10;
Key.UnicodeChar = CHAR_NULL;
GopPrivateAddKey (Private, Key);
return 0;
}
//
// If ALT or ALT + modifier key is pressed.
//
if (WinNtGopConvertParamToEfiKey (Private, &wParam, &lParam, &Key)) {
if (Key.ScanCode != 0) {
//
// If ALT is pressed with other ScanCode.
// Always revers the left Alt for simple.
//
Private->LeftAlt = TRUE;
}
GopPrivateAddKey (Private, Key);
//
// If ALT is pressed with other ScanCode.
// Always revers the left Alt for simple.
// When Alt is released there is no windoes message, so
// clean it after using it.
//
Private->RightAlt = FALSE;
Private->LeftAlt = FALSE;
return 0;
}
AltIsPress = TRUE;
case WM_CHAR:
//
// The ESC key also generate WM_CHAR.
//
if (wParam == 0x1B) {
return 0;
}
if (AltIsPress == TRUE) {
//
// If AltIsPress is true that means the Alt key is pressed.
//
Private->LeftAlt = TRUE;
}
GopPrivateAddKey (Private, Key);
//
// When Alt is released there is no windoes message, so
// clean it after using it.
//
Private->RightAlt = FALSE;
Private->LeftAlt = FALSE;
return 0;
}
AltIsPress = TRUE;
case WM_CHAR:
//
// The ESC key also generate WM_CHAR.
//
if (wParam == 0x1B) {
return 0;
}
for (Index = 0; Index < (lParam & 0xffff); Index++) {
if (wParam != 0) {
Key.UnicodeChar = (CHAR16)wParam;
Key.ScanCode = SCAN_NULL;
GopPrivateAddKey (Private, Key);
}
}
if (AltIsPress == TRUE) {
if (AltIsPress == TRUE) {
//
// When Alt is released there is no windoes message, so
// clean it after using it.
//
Private->LeftAlt = FALSE;
Private->RightAlt = FALSE;
}
return 0;
case WM_SYSKEYUP:
//
// If AltIsPress is true that means the Alt key is pressed.
// ALT is pressed with another key released
//
Private->LeftAlt = TRUE;
}
for (Index = 0; Index < (lParam & 0xffff); Index++) {
if (wParam != 0) {
Key.UnicodeChar = (CHAR16) wParam;
Key.ScanCode = SCAN_NULL;
WinNtGopConvertParamToEfiKeyShiftState (Private, &wParam, &lParam, FALSE);
return 0;
case WM_KEYDOWN:
Key.ScanCode = SCAN_NULL;
Key.UnicodeChar = CHAR_NULL;
//
// A value key press will cause a WM_KEYDOWN first, then cause a WM_CHAR
// So if there is no modifier key updated, skip the WM_KEYDOWN even.
//
if (WinNtGopConvertParamToEfiKey (Private, &wParam, &lParam, &Key)) {
//
// Support the partial keystroke, add all keydown event into the queue.
//
GopPrivateAddKey (Private, Key);
}
}
if (AltIsPress == TRUE) {
return 0;
case WM_KEYUP:
WinNtGopConvertParamToEfiKeyShiftState (Private, &wParam, &lParam, FALSE);
return 0;
case WM_MOUSEMOVE:
PosX = GET_X_LPARAM (lParam);
PosY = GET_Y_LPARAM (lParam);
if (Private->PointerPreviousX != PosX) {
Private->PointerState.RelativeMovementX += (PosX - Private->PointerPreviousX);
Private->PointerPreviousX = PosX;
Private->PointerStateChanged = TRUE;
}
if (Private->PointerPreviousY != PosY) {
Private->PointerState.RelativeMovementY += (PosY - Private->PointerPreviousY);
Private->PointerPreviousY = PosY;
Private->PointerStateChanged = TRUE;
}
Private->PointerState.RelativeMovementZ = 0;
return 0;
case WM_LBUTTONDOWN:
Private->PointerState.LeftButton = TRUE;
Private->PointerStateChanged = TRUE;
return 0;
case WM_LBUTTONUP:
Private->PointerState.LeftButton = FALSE;
Private->PointerStateChanged = TRUE;
return 0;
case WM_RBUTTONDOWN:
Private->PointerState.RightButton = TRUE;
Private->PointerStateChanged = TRUE;
return 0;
case WM_RBUTTONUP:
Private->PointerState.RightButton = FALSE;
Private->PointerStateChanged = TRUE;
return 0;
case WM_CLOSE:
//
// When Alt is released there is no windoes message, so
// clean it after using it.
// This close message is issued by user, core is not aware of this,
// so don't release the window display resource, just hide the window.
//
Private->LeftAlt = FALSE;
Private->RightAlt = FALSE;
}
return 0;
ShowWindow (Private->WindowHandle, SW_HIDE);
return 0;
case WM_SYSKEYUP:
//
// ALT is pressed with another key released
//
WinNtGopConvertParamToEfiKeyShiftState (Private, &wParam, &lParam, FALSE);
return 0;
case WM_DESTROY:
DestroyWindow (hwnd);
PostQuitMessage (0);
case WM_KEYDOWN:
Key.ScanCode = SCAN_NULL;
Key.UnicodeChar = CHAR_NULL;
//
// A value key press will cause a WM_KEYDOWN first, then cause a WM_CHAR
// So if there is no modifier key updated, skip the WM_KEYDOWN even.
//
if (WinNtGopConvertParamToEfiKey (Private, &wParam, &lParam, &Key)) {
//
// Support the partial keystroke, add all keydown event into the queue.
//
GopPrivateAddKey (Private, Key);
}
return 0;
HeapFree (GetProcessHeap (), 0, Private->VirtualScreenInfo);
case WM_KEYUP:
WinNtGopConvertParamToEfiKeyShiftState (Private, &wParam, &lParam, FALSE);
return 0;
ExitThread (0);
case WM_MOUSEMOVE:
PosX = GET_X_LPARAM (lParam);
PosY = GET_Y_LPARAM (lParam);
if (Private->PointerPreviousX != PosX) {
Private->PointerState.RelativeMovementX += (PosX - Private->PointerPreviousX);
Private->PointerPreviousX = PosX;
Private->PointerStateChanged = TRUE;
}
if (Private->PointerPreviousY != PosY) {
Private->PointerState.RelativeMovementY += (PosY - Private->PointerPreviousY);
Private->PointerPreviousY = PosY;
Private->PointerStateChanged = TRUE;
}
Private->PointerState.RelativeMovementZ = 0;
return 0;
case WM_LBUTTONDOWN:
Private->PointerState.LeftButton = TRUE;
Private->PointerStateChanged = TRUE;
return 0;
case WM_LBUTTONUP:
Private->PointerState.LeftButton = FALSE;
Private->PointerStateChanged = TRUE;
return 0;
case WM_RBUTTONDOWN:
Private->PointerState.RightButton = TRUE;
Private->PointerStateChanged = TRUE;
return 0;
case WM_RBUTTONUP:
Private->PointerState.RightButton = FALSE;
Private->PointerStateChanged = TRUE;
return 0;
case WM_CLOSE:
//
// This close message is issued by user, core is not aware of this,
// so don't release the window display resource, just hide the window.
//
ShowWindow (Private->WindowHandle, SW_HIDE);
return 0;
case WM_DESTROY:
DestroyWindow (hwnd);
PostQuitMessage (0);
HeapFree (GetProcessHeap (), 0, Private->VirtualScreenInfo);
ExitThread (0);
default:
break;
};
default:
break;
}
return DefWindowProc (hwnd, iMsg, wParam, lParam);
}
/**
This thread simulates the end of WinMain () application. Each Window needs
to process its events. The messages are dispatched to
@@ -607,14 +688,14 @@ WinNtGopThreadWindowProc (
DWORD
WINAPI
WinNtGopThreadWinMain (
LPVOID lpParameter
LPVOID lpParameter
)
{
MSG Message;
GRAPHICS_PRIVATE_DATA *Private;
RECT Rect;
Private = (GRAPHICS_PRIVATE_DATA *) lpParameter;
Private = (GRAPHICS_PRIVATE_DATA *)lpParameter;
ASSERT (NULL != Private);
//
@@ -624,7 +705,7 @@ WinNtGopThreadWinMain (
//
TlsSetValue (mTlsIndex, Private);
Private->ThreadId = GetCurrentThreadId ();
Private->ThreadId = GetCurrentThreadId ();
Private->WindowsClass.cbSize = sizeof (WNDCLASSEX);
Private->WindowsClass.style = CS_HREDRAW | CS_VREDRAW | CS_OWNDC;
@@ -645,7 +726,6 @@ WinNtGopThreadWinMain (
Private->Width = 100;
Private->Height = 100;
//
// This call will fail after the first time, but thats O.K. since we only need
// WIN_NT_GOP_CLASS_NAME to exist to create the window.
@@ -703,7 +783,6 @@ WinNtGopThreadWinMain (
return (DWORD)Message.wParam;
}
/**
TODO: Add function description
@@ -719,11 +798,11 @@ WinNtGopThreadWinMain (
EFI_STATUS
EFIAPI
WinNtGraphicsWindowOpen (
IN EMU_IO_THUNK_PROTOCOL *This
IN EMU_IO_THUNK_PROTOCOL *This
)
{
DWORD NewThreadId;
GRAPHICS_PRIVATE_DATA *Private;
DWORD NewThreadId;
GRAPHICS_PRIVATE_DATA *Private;
Private = AllocateZeroPool (sizeof (*Private));
@@ -758,7 +837,7 @@ WinNtGraphicsWindowOpen (
NULL,
0,
WinNtGopThreadWinMain,
(VOID *) Private,
(VOID *)Private,
0,
&NewThreadId
);
@@ -770,7 +849,7 @@ WinNtGraphicsWindowOpen (
WaitForSingleObject (Private->ThreadInited, INFINITE);
CloseHandle (Private->ThreadInited);
This->Private = Private;
This->Private = Private;
This->Interface = &Private->GraphicsWindowIo;
return EFI_SUCCESS;
@@ -779,10 +858,10 @@ WinNtGraphicsWindowOpen (
EFI_STATUS
EFIAPI
WinNtGraphicsWindowClose (
IN EMU_IO_THUNK_PROTOCOL *This
)
IN EMU_IO_THUNK_PROTOCOL *This
)
{
GRAPHICS_PRIVATE_DATA *Private;
GRAPHICS_PRIVATE_DATA *Private;
Private = (GRAPHICS_PRIVATE_DATA *)This->Private;
@@ -807,16 +886,14 @@ WinNtGraphicsWindowClose (
UnregisterClass (
Private->WindowsClass.lpszClassName,
Private->WindowsClass.hInstance
);
);
}
GopPrivateDestroyQ (Private, &Private->QueueForRead);
return EFI_SUCCESS;
}
EMU_IO_THUNK_PROTOCOL mWinNtWndThunkIo = {
EMU_IO_THUNK_PROTOCOL mWinNtWndThunkIo = {
&gEmuGraphicsWindowProtocolGuid,
NULL,
NULL,

347
EmulatorPkg/Win/Host/WinHost.c
View File

@@ -16,26 +16,26 @@ SPDX-License-Identifier: BSD-2-Clause-Patent
#include "WinHost.h"
#ifndef SE_TIME_ZONE_NAME
#define SE_TIME_ZONE_NAME TEXT("SeTimeZonePrivilege")
#define SE_TIME_ZONE_NAME TEXT("SeTimeZonePrivilege")
#endif
//
// The growth size for array of module handle entries
//
#define MAX_PDB_NAME_TO_MOD_HANDLE_ARRAY_SIZE 0x100
#define MAX_PDB_NAME_TO_MOD_HANDLE_ARRAY_SIZE 0x100
//
// Module handle entry structure
//
typedef struct {
CHAR8 *PdbPointer;
VOID *ModHandle;
CHAR8 *PdbPointer;
VOID *ModHandle;
} PDB_NAME_TO_MOD_HANDLE;
//
// An Array to hold the module handles
//
PDB_NAME_TO_MOD_HANDLE *mPdbNameModHandleArray = NULL;
PDB_NAME_TO_MOD_HANDLE *mPdbNameModHandleArray = NULL;
UINTN mPdbNameModHandleArraySize = 0;
//
@@ -44,8 +44,8 @@ UINTN mPdbNameModHandleArraySize = 0;
// The number of array elements is allocated base on parsing
// PcdWinNtFirmwareVolume and the memory is never freed.
//
UINTN gFdInfoCount = 0;
NT_FD_INFO *gFdInfo;
UINTN gFdInfoCount = 0;
NT_FD_INFO *gFdInfo;
//
// Array that supports separate memory ranges.
@@ -53,8 +53,8 @@ NT_FD_INFO *gFdInfo;
// The number of array elements is allocated base on parsing
// PcdWinNtMemorySizeForSecMain value and the memory is never freed.
//
UINTN gSystemMemoryCount = 0;
NT_SYSTEM_MEMORY *gSystemMemory;
UINTN gSystemMemoryCount = 0;
NT_SYSTEM_MEMORY *gSystemMemory;
/*++
@@ -90,7 +90,7 @@ WinPeiAutoScan (
//
// Allocate enough memory space for emulator
//
gSystemMemory[Index].Memory = (EFI_PHYSICAL_ADDRESS) (UINTN) VirtualAlloc (NULL, (SIZE_T) (gSystemMemory[Index].Size), MEM_COMMIT, PAGE_EXECUTE_READWRITE);
gSystemMemory[Index].Memory = (EFI_PHYSICAL_ADDRESS)(UINTN)VirtualAlloc (NULL, (SIZE_T)(gSystemMemory[Index].Size), MEM_COMMIT, PAGE_EXECUTE_READWRITE);
if (gSystemMemory[Index].Memory == 0) {
return EFI_OUT_OF_RESOURCES;
}
@@ -130,12 +130,11 @@ WinFdAddress (
return EFI_UNSUPPORTED;
}
*FdBase = (EFI_PHYSICAL_ADDRESS)(UINTN)gFdInfo[Index].Address;
*FdSize = (UINT64)gFdInfo[Index].Size;
*FixUp = 0;
if (*FdBase == 0 && *FdSize == 0) {
if ((*FdBase == 0) && (*FdSize == 0)) {
return EFI_UNSUPPORTED;
}
@@ -173,8 +172,7 @@ WinThunk (
return &gEmuThunkProtocol;
}
EMU_THUNK_PPI mSecEmuThunkPpi = {
EMU_THUNK_PPI mSecEmuThunkPpi = {
WinPeiAutoScan,
WinFdAddress,
WinThunk
@@ -227,7 +225,7 @@ Returns:
**/
BOOLEAN
EfiSystemMemoryRange (
IN VOID *MemoryAddress
IN VOID *MemoryAddress
)
{
UINTN Index;
@@ -236,7 +234,8 @@ EfiSystemMemoryRange (
MemoryBase = (EFI_PHYSICAL_ADDRESS)(UINTN)MemoryAddress;
for (Index = 0; Index < gSystemMemoryCount; Index++) {
if ((MemoryBase >= gSystemMemory[Index].Memory) &&
(MemoryBase < (gSystemMemory[Index].Memory + gSystemMemory[Index].Size)) ) {
(MemoryBase < (gSystemMemory[Index].Memory + gSystemMemory[Index].Size)))
{
return TRUE;
}
}
@@ -244,15 +243,15 @@ EfiSystemMemoryRange (
return FALSE;
}
EFI_STATUS
WinNtOpenFile (
IN CHAR16 *FileName OPTIONAL,
IN UINT32 MapSize,
IN DWORD CreationDisposition,
IN OUT VOID **BaseAddress,
OUT UINTN *Length
IN CHAR16 *FileName OPTIONAL,
IN UINT32 MapSize,
IN DWORD CreationDisposition,
IN OUT VOID **BaseAddress,
OUT UINTN *Length
)
/*++
Routine Description:
@@ -300,6 +299,7 @@ Returns:
return EFI_NOT_FOUND;
}
}
//
// Map the open file into a memory range
//
@@ -314,17 +314,18 @@ Returns:
if (NtMapHandle == NULL) {
return EFI_DEVICE_ERROR;
}
//
// Get the virtual address (address in the emulator) of the mapped file
//
VirtualAddress = MapViewOfFileEx (
NtMapHandle,
FILE_MAP_EXECUTE | FILE_MAP_ALL_ACCESS,
0,
0,
MapSize,
*BaseAddress
);
NtMapHandle,
FILE_MAP_EXECUTE | FILE_MAP_ALL_ACCESS,
0,
0,
MapSize,
*BaseAddress
);
if (VirtualAddress == NULL) {
return EFI_DEVICE_ERROR;
}
@@ -334,11 +335,11 @@ Returns:
// Seek to the end of the file to figure out the true file size.
//
FileSize = SetFilePointer (
NtFileHandle,
0,
NULL,
FILE_END
);
NtFileHandle,
0,
NULL,
FILE_END
);
if (FileSize == -1) {
return EFI_DEVICE_ERROR;
}
@@ -356,10 +357,11 @@ Returns:
INTN
EFIAPI
main (
IN INT Argc,
IN CHAR8 **Argv,
IN CHAR8 **Envp
IN INT Argc,
IN CHAR8 **Argv,
IN CHAR8 **Envp
)
/*++
Routine Description:
@@ -376,37 +378,37 @@ Returns:
--*/
{
EFI_STATUS Status;
HANDLE Token;
TOKEN_PRIVILEGES TokenPrivileges;
VOID *TemporaryRam;
UINT32 TemporaryRamSize;
VOID *EmuMagicPage;
UINTN Index;
UINTN Index1;
CHAR16 *FileName;
CHAR16 *FileNamePtr;
BOOLEAN Done;
EFI_PEI_FILE_HANDLE FileHandle;
VOID *SecFile;
CHAR16 *MemorySizeStr;
CHAR16 *FirmwareVolumesStr;
UINTN ProcessAffinityMask;
UINTN SystemAffinityMask;
INT32 LowBit;
EFI_STATUS Status;
HANDLE Token;
TOKEN_PRIVILEGES TokenPrivileges;
VOID *TemporaryRam;
UINT32 TemporaryRamSize;
VOID *EmuMagicPage;
UINTN Index;
UINTN Index1;
CHAR16 *FileName;
CHAR16 *FileNamePtr;
BOOLEAN Done;
EFI_PEI_FILE_HANDLE FileHandle;
VOID *SecFile;
CHAR16 *MemorySizeStr;
CHAR16 *FirmwareVolumesStr;
UINTN ProcessAffinityMask;
UINTN SystemAffinityMask;
INT32 LowBit;
//
// Enable the privilege so that RTC driver can successfully run SetTime()
//
OpenProcessToken (GetCurrentProcess(), TOKEN_ADJUST_PRIVILEGES|TOKEN_QUERY, &Token);
if (LookupPrivilegeValue(NULL, SE_TIME_ZONE_NAME, &TokenPrivileges.Privileges[0].Luid)) {
TokenPrivileges.PrivilegeCount = 1;
OpenProcessToken (GetCurrentProcess (), TOKEN_ADJUST_PRIVILEGES|TOKEN_QUERY, &Token);
if (LookupPrivilegeValue (NULL, SE_TIME_ZONE_NAME, &TokenPrivileges.Privileges[0].Luid)) {
TokenPrivileges.PrivilegeCount = 1;
TokenPrivileges.Privileges[0].Attributes = SE_PRIVILEGE_ENABLED;
AdjustTokenPrivileges(Token, FALSE, &TokenPrivileges, 0, (PTOKEN_PRIVILEGES) NULL, 0);
AdjustTokenPrivileges (Token, FALSE, &TokenPrivileges, 0, (PTOKEN_PRIVILEGES)NULL, 0);
}
MemorySizeStr = (CHAR16 *) PcdGetPtr (PcdEmuMemorySize);
FirmwareVolumesStr = (CHAR16 *) PcdGetPtr (PcdEmuFirmwareVolume);
MemorySizeStr = (CHAR16 *)PcdGetPtr (PcdEmuMemorySize);
FirmwareVolumesStr = (CHAR16 *)PcdGetPtr (PcdEmuFirmwareVolume);
SecPrint ("\n\rEDK II WIN Host Emulation Environment from http://www.tianocore.org/edk2/\n\r");
@@ -448,8 +450,8 @@ Returns:
//
// Allocate space for gSystemMemory Array
//
gSystemMemoryCount = CountSeparatorsInString (MemorySizeStr, '!') + 1;
gSystemMemory = calloc (gSystemMemoryCount, sizeof (NT_SYSTEM_MEMORY));
gSystemMemoryCount = CountSeparatorsInString (MemorySizeStr, '!') + 1;
gSystemMemory = calloc (gSystemMemoryCount, sizeof (NT_SYSTEM_MEMORY));
if (gSystemMemory == NULL) {
SecPrint ("ERROR : Can not allocate memory for %S. Exiting.\n\r", MemorySizeStr);
exit (1);
@@ -458,12 +460,13 @@ Returns:
//
// Allocate space for gSystemMemory Array
//
gFdInfoCount = CountSeparatorsInString (FirmwareVolumesStr, '!') + 1;
gFdInfo = calloc (gFdInfoCount, sizeof (NT_FD_INFO));
gFdInfoCount = CountSeparatorsInString (FirmwareVolumesStr, '!') + 1;
gFdInfo = calloc (gFdInfoCount, sizeof (NT_FD_INFO));
if (gFdInfo == NULL) {
SecPrint ("ERROR : Can not allocate memory for %S. Exiting.\n\r", FirmwareVolumesStr);
exit (1);
}
//
// Setup Boot Mode.
//
@@ -475,14 +478,16 @@ Returns:
// Set TemporaryRam to zero so WinNtOpenFile will allocate a new mapping
//
TemporaryRamSize = TEMPORARY_RAM_SIZE;
TemporaryRam = VirtualAlloc (NULL, (SIZE_T) (TemporaryRamSize), MEM_COMMIT, PAGE_EXECUTE_READWRITE);
TemporaryRam = VirtualAlloc (NULL, (SIZE_T)(TemporaryRamSize), MEM_COMMIT, PAGE_EXECUTE_READWRITE);
if (TemporaryRam == NULL) {
SecPrint ("ERROR : Can not allocate enough space for SecStack\n\r");
exit (1);
}
SetMem32 (TemporaryRam, TemporaryRamSize, PcdGet32 (PcdInitValueInTempStack));
SecPrint (" OS Emulator passing in %u KB of temp RAM at 0x%08lx to SEC\n\r",
SecPrint (
" OS Emulator passing in %u KB of temp RAM at 0x%08lx to SEC\n\r",
TemporaryRamSize / SIZE_1KB,
TemporaryRam
);
@@ -497,12 +502,12 @@ Returns:
if (EmuMagicPage != NULL) {
UINT64 Size;
Status = WinNtOpenFile (
NULL,
SIZE_4KB,
0,
&EmuMagicPage,
&Size
);
NULL,
SIZE_4KB,
0,
&EmuMagicPage,
&Size
);
if (EFI_ERROR (Status)) {
SecPrint ("ERROR : Could not allocate PeiServicesTablePage @ %p\n\r", EmuMagicPage);
return EFI_DEVICE_ERROR;
@@ -521,25 +526,26 @@ Returns:
for (Done = FALSE, Index = 0, SecFile = NULL; !Done; Index++) {
FileName = FileNamePtr;
for (Index1 = 0; (FileNamePtr[Index1] != '!') && (FileNamePtr[Index1] != 0); Index1++)
;
for (Index1 = 0; (FileNamePtr[Index1] != '!') && (FileNamePtr[Index1] != 0); Index1++) {
}
if (FileNamePtr[Index1] == 0) {
Done = TRUE;
} else {
FileNamePtr[Index1] = '\0';
FileNamePtr = &FileNamePtr[Index1 + 1];
FileNamePtr[Index1] = '\0';
FileNamePtr = &FileNamePtr[Index1 + 1];
}
//
// Open the FD and remember where it got mapped into our processes address space
//
Status = WinNtOpenFile (
FileName,
0,
OPEN_EXISTING,
&gFdInfo[Index].Address,
&gFdInfo[Index].Size
);
FileName,
0,
OPEN_EXISTING,
&gFdInfo[Index].Address,
&gFdInfo[Index].Size
);
if (EFI_ERROR (Status)) {
SecPrint ("ERROR : Can not open Firmware Device File %S (0x%X). Exiting.\n\r", FileName, Status);
exit (1);
@@ -553,11 +559,11 @@ Returns:
// Load the first one we find.
//
FileHandle = NULL;
Status = PeiServicesFfsFindNextFile (
EFI_FV_FILETYPE_SECURITY_CORE,
(EFI_PEI_FV_HANDLE)gFdInfo[Index].Address,
&FileHandle
);
Status = PeiServicesFfsFindNextFile (
EFI_FV_FILETYPE_SECURITY_CORE,
(EFI_PEI_FV_HANDLE)gFdInfo[Index].Address,
&FileHandle
);
if (!EFI_ERROR (Status)) {
Status = PeiServicesFfsFindSectionData (EFI_SECTION_PE32, FileHandle, &SecFile);
if (!EFI_ERROR (Status)) {
@@ -568,6 +574,7 @@ Returns:
SecPrint ("\n\r");
}
//
// Calculate memory regions and store the information in the gSystemMemory
// global for later use. The autosizing code will use this data to
@@ -582,8 +589,9 @@ Returns:
//
// Find the next region
//
for (Index1 = 0; MemorySizeStr[Index1] != '!' && MemorySizeStr[Index1] != 0; Index1++)
;
for (Index1 = 0; MemorySizeStr[Index1] != '!' && MemorySizeStr[Index1] != 0; Index1++) {
}
if (MemorySizeStr[Index1] == 0) {
Done = TRUE;
}
@@ -608,12 +616,13 @@ Returns:
VOID
SecLoadSecCore (
IN UINTN TemporaryRam,
IN UINTN TemporaryRamSize,
IN VOID *BootFirmwareVolumeBase,
IN UINTN BootFirmwareVolumeSize,
IN VOID *SecCorePe32File
IN UINTN TemporaryRam,
IN UINTN TemporaryRamSize,
IN VOID *BootFirmwareVolumeBase,
IN UINTN BootFirmwareVolumeSize,
IN VOID *SecCorePe32File
)
/*++
Routine Description:
@@ -630,11 +639,11 @@ Returns:
--*/
{
EFI_STATUS Status;
VOID *TopOfStack;
VOID *SecCoreEntryPoint;
EFI_SEC_PEI_HAND_OFF *SecCoreData;
UINTN SecStackSize;
EFI_STATUS Status;
VOID *TopOfStack;
VOID *SecCoreEntryPoint;
EFI_SEC_PEI_HAND_OFF *SecCoreData;
UINTN SecStackSize;
//
// Compute Top Of Memory for Stack and PEI Core Allocations
@@ -650,37 +659,37 @@ Returns:
// | Stack |
// |-----------| <---- TemporaryRamBase
//
TopOfStack = (VOID *)(TemporaryRam + SecStackSize);
TopOfStack = (VOID *)(TemporaryRam + SecStackSize);
//
// Reservet space for storing PeiCore's parament in stack.
//
TopOfStack = (VOID *)((UINTN)TopOfStack - sizeof (EFI_SEC_PEI_HAND_OFF) - CPU_STACK_ALIGNMENT);
TopOfStack = ALIGN_POINTER (TopOfStack, CPU_STACK_ALIGNMENT);
TopOfStack = (VOID *)((UINTN)TopOfStack - sizeof (EFI_SEC_PEI_HAND_OFF) - CPU_STACK_ALIGNMENT);
TopOfStack = ALIGN_POINTER (TopOfStack, CPU_STACK_ALIGNMENT);
//
// Bind this information into the SEC hand-off state
//
SecCoreData = (EFI_SEC_PEI_HAND_OFF*)(UINTN)TopOfStack;
SecCoreData = (EFI_SEC_PEI_HAND_OFF *)(UINTN)TopOfStack;
SecCoreData->DataSize = sizeof (EFI_SEC_PEI_HAND_OFF);
SecCoreData->BootFirmwareVolumeBase = BootFirmwareVolumeBase;
SecCoreData->BootFirmwareVolumeSize = BootFirmwareVolumeSize;
SecCoreData->TemporaryRamBase = (VOID*)TemporaryRam;
SecCoreData->TemporaryRamBase = (VOID *)TemporaryRam;
SecCoreData->TemporaryRamSize = TemporaryRamSize;
SecCoreData->StackBase = SecCoreData->TemporaryRamBase;
SecCoreData->StackSize = SecStackSize;
SecCoreData->PeiTemporaryRamBase = (VOID*) ((UINTN) SecCoreData->TemporaryRamBase + SecStackSize);
SecCoreData->PeiTemporaryRamBase = (VOID *)((UINTN)SecCoreData->TemporaryRamBase + SecStackSize);
SecCoreData->PeiTemporaryRamSize = TemporaryRamSize - SecStackSize;
//
// Load the PEI Core from a Firmware Volume
//
Status = SecPeCoffGetEntryPoint (
SecCorePe32File,
&SecCoreEntryPoint
);
SecCorePe32File,
&SecCoreEntryPoint
);
if (EFI_ERROR (Status)) {
return ;
return;
}
//
@@ -695,7 +704,7 @@ Returns:
//
// If we get here, then the SEC Core returned. This is an error
//
return ;
return;
}
RETURN_STATUS
@@ -705,26 +714,28 @@ SecPeCoffGetEntryPoint (
IN OUT VOID **EntryPoint
)
{
EFI_STATUS Status;
PE_COFF_LOADER_IMAGE_CONTEXT ImageContext;
EFI_STATUS Status;
PE_COFF_LOADER_IMAGE_CONTEXT ImageContext;
ZeroMem (&ImageContext, sizeof (ImageContext));
ImageContext.Handle = Pe32Data;
ImageContext.Handle = Pe32Data;
ImageContext.ImageRead = (PE_COFF_LOADER_READ_FILE) SecImageRead;
ImageContext.ImageRead = (PE_COFF_LOADER_READ_FILE)SecImageRead;
Status = PeCoffLoaderGetImageInfo (&ImageContext);
Status = PeCoffLoaderGetImageInfo (&ImageContext);
if (EFI_ERROR (Status)) {
return Status;
}
//
// Allocate space in NT (not emulator) memory with ReadWrite and Execute attribute.
// Extra space is for alignment
//
ImageContext.ImageAddress = (EFI_PHYSICAL_ADDRESS) (UINTN) VirtualAlloc (NULL, (SIZE_T) (ImageContext.ImageSize + (ImageContext.SectionAlignment * 2)), MEM_COMMIT, PAGE_EXECUTE_READWRITE);
ImageContext.ImageAddress = (EFI_PHYSICAL_ADDRESS)(UINTN)VirtualAlloc (NULL, (SIZE_T)(ImageContext.ImageSize + (ImageContext.SectionAlignment * 2)), MEM_COMMIT, PAGE_EXECUTE_READWRITE);
if (ImageContext.ImageAddress == 0) {
return EFI_OUT_OF_RESOURCES;
}
//
// Align buffer on section boundary
//
@@ -741,7 +752,7 @@ SecPeCoffGetEntryPoint (
return Status;
}
*EntryPoint = (VOID *)(UINTN)ImageContext.EntryPoint;
*EntryPoint = (VOID *)(UINTN)ImageContext.EntryPoint;
return EFI_SUCCESS;
}
@@ -749,11 +760,12 @@ SecPeCoffGetEntryPoint (
EFI_STATUS
EFIAPI
SecImageRead (
IN VOID *FileHandle,
IN UINTN FileOffset,
IN OUT UINTN *ReadSize,
OUT VOID *Buffer
IN VOID *FileHandle,
IN UINTN FileOffset,
IN OUT UINTN *ReadSize,
OUT VOID *Buffer
)
/*++
Routine Description:
@@ -770,13 +782,13 @@ Returns:
--*/
{
CHAR8 *Destination8;
CHAR8 *Source8;
UINTN Length;
CHAR8 *Destination8;
CHAR8 *Source8;
UINTN Length;
Destination8 = Buffer;
Source8 = (CHAR8 *) ((UINTN) FileHandle + FileOffset);
Length = *ReadSize;
Destination8 = Buffer;
Source8 = (CHAR8 *)((UINTN)FileHandle + FileOffset);
Length = *ReadSize;
while (Length--) {
*(Destination8++) = *(Source8++);
}
@@ -786,9 +798,10 @@ Returns:
CHAR16 *
AsciiToUnicode (
IN CHAR8 *Ascii,
IN UINTN *StrLen OPTIONAL
IN CHAR8 *Ascii,
IN UINTN *StrLen OPTIONAL
)
/*++
Routine Description:
@@ -810,15 +823,16 @@ Returns:
//
// Allocate a buffer for unicode string
//
for (Index = 0; Ascii[Index] != '\0'; Index++)
;
for (Index = 0; Ascii[Index] != '\0'; Index++) {
}
Unicode = malloc ((Index + 1) * sizeof (CHAR16));
if (Unicode == NULL) {
return NULL;
}
for (Index = 0; Ascii[Index] != '\0'; Index++) {
Unicode[Index] = (CHAR16) Ascii[Index];
Unicode[Index] = (CHAR16)Ascii[Index];
}
Unicode[Index] = '\0';
@@ -832,9 +846,10 @@ Returns:
UINTN
CountSeparatorsInString (
IN CONST CHAR16 *String,
IN CHAR16 Separator
IN CONST CHAR16 *String,
IN CHAR16 Separator
)
/*++
Routine Description:
@@ -849,7 +864,7 @@ Returns:
--*/
{
UINTN Count;
UINTN Count;
for (Count = 0; *String != '\0'; String++) {
if (*String == Separator) {
@@ -871,8 +886,8 @@ Returns:
--*/
EFI_STATUS
AddModHandle (
IN PE_COFF_LOADER_IMAGE_CONTEXT *ImageContext,
IN VOID *ModHandle
IN PE_COFF_LOADER_IMAGE_CONTEXT *ImageContext,
IN VOID *ModHandle
)
{
@@ -888,7 +903,7 @@ AddModHandle (
//
Array = mPdbNameModHandleArray;
for (Index = 0; Index < mPdbNameModHandleArraySize; Index++, Array++) {
if (Array->PdbPointer != NULL && Array->ModHandle == ModHandle) {
if ((Array->PdbPointer != NULL) && (Array->ModHandle == ModHandle)) {
return EFI_ALREADY_STARTED;
}
}
@@ -899,9 +914,9 @@ AddModHandle (
//
// Make a copy of the stirng and store the ModHandle
//
Handle = GetProcessHeap ();
Size = AsciiStrLen (ImageContext->PdbPointer) + 1;
Array->PdbPointer = HeapAlloc ( Handle, HEAP_ZERO_MEMORY, Size);
Handle = GetProcessHeap ();
Size = AsciiStrLen (ImageContext->PdbPointer) + 1;
Array->PdbPointer = HeapAlloc (Handle, HEAP_ZERO_MEMORY, Size);
ASSERT (Array->PdbPointer != NULL);
AsciiStrCpyS (Array->PdbPointer, Size, ImageContext->PdbPointer);
@@ -914,17 +929,18 @@ AddModHandle (
// No free space in mPdbNameModHandleArray so grow it by
// MAX_PDB_NAME_TO_MOD_HANDLE_ARRAY_SIZE entires.
//
PreviousSize = mPdbNameModHandleArraySize * sizeof (PDB_NAME_TO_MOD_HANDLE);
PreviousSize = mPdbNameModHandleArraySize * sizeof (PDB_NAME_TO_MOD_HANDLE);
mPdbNameModHandleArraySize += MAX_PDB_NAME_TO_MOD_HANDLE_ARRAY_SIZE;
//
// re-allocate a new buffer and copy the old values to the new locaiton.
//
TempArray = HeapAlloc (GetProcessHeap (),
HEAP_ZERO_MEMORY,
mPdbNameModHandleArraySize * sizeof (PDB_NAME_TO_MOD_HANDLE)
);
TempArray = HeapAlloc (
GetProcessHeap (),
HEAP_ZERO_MEMORY,
mPdbNameModHandleArraySize * sizeof (PDB_NAME_TO_MOD_HANDLE)
);
CopyMem ((VOID *) (UINTN) TempArray, (VOID *) (UINTN)mPdbNameModHandleArray, PreviousSize);
CopyMem ((VOID *)(UINTN)TempArray, (VOID *)(UINTN)mPdbNameModHandleArray, PreviousSize);
HeapFree (GetProcessHeap (), 0, mPdbNameModHandleArray);
@@ -947,7 +963,7 @@ AddModHandle (
**/
VOID *
RemoveModHandle (
IN PE_COFF_LOADER_IMAGE_CONTEXT *ImageContext
IN PE_COFF_LOADER_IMAGE_CONTEXT *ImageContext
)
{
UINTN Index;
@@ -962,7 +978,7 @@ RemoveModHandle (
Array = mPdbNameModHandleArray;
for (Index = 0; Index < mPdbNameModHandleArraySize; Index++, Array++) {
if ((Array->PdbPointer != NULL) && (AsciiStrCmp(Array->PdbPointer, ImageContext->PdbPointer) == 0)) {
if ((Array->PdbPointer != NULL) && (AsciiStrCmp (Array->PdbPointer, ImageContext->PdbPointer) == 0)) {
//
// If you find a match return it and delete the entry
//
@@ -978,14 +994,14 @@ RemoveModHandle (
VOID
EFIAPI
PeCoffLoaderRelocateImageExtraAction (
IN OUT PE_COFF_LOADER_IMAGE_CONTEXT *ImageContext
IN OUT PE_COFF_LOADER_IMAGE_CONTEXT *ImageContext
)
{
EFI_STATUS Status;
VOID *DllEntryPoint;
CHAR16 *DllFileName;
HMODULE Library;
UINTN Index;
EFI_STATUS Status;
VOID *DllEntryPoint;
CHAR16 *DllFileName;
HMODULE Library;
UINTN Index;
ASSERT (ImageContext != NULL);
//
@@ -1003,7 +1019,8 @@ PeCoffLoaderRelocateImageExtraAction (
// Load the DLL if it's not an EBC image.
//
if ((ImageContext->PdbPointer != NULL) &&
(ImageContext->Machine != EFI_IMAGE_MACHINE_EBC)) {
(ImageContext->Machine != EFI_IMAGE_MACHINE_EBC))
{
//
// Convert filename from ASCII to Unicode
//
@@ -1012,7 +1029,7 @@ PeCoffLoaderRelocateImageExtraAction (
//
// Check that we have a valid filename
//
if (Index < 5 || DllFileName[Index - 4] != '.') {
if ((Index < 5) || (DllFileName[Index - 4] != '.')) {
free (DllFileName);
//
@@ -1022,12 +1039,13 @@ PeCoffLoaderRelocateImageExtraAction (
//
return;
}
//
// Replace .PDB with .DLL on the filename
//
DllFileName[Index - 3] = 'D';
DllFileName[Index - 2] = 'L';
DllFileName[Index - 1] = 'L';
DllFileName[Index - 3] = 'D';
DllFileName[Index - 2] = 'L';
DllFileName[Index - 1] = 'L';
//
// Load the .DLL file into the user process's address space for source
@@ -1043,8 +1061,7 @@ PeCoffLoaderRelocateImageExtraAction (
// checking as the we can point to the PE32 image loaded by Tiano. This
// step is only needed for source level debugging
//
DllEntryPoint = (VOID *) (UINTN) GetProcAddress (Library, "InitializeDriver");
DllEntryPoint = (VOID *)(UINTN)GetProcAddress (Library, "InitializeDriver");
}
if ((Library != NULL) && (DllEntryPoint != NULL)) {
@@ -1059,7 +1076,7 @@ PeCoffLoaderRelocateImageExtraAction (
//
// This DLL is not already loaded, so source level debugging is supported.
//
ImageContext->EntryPoint = (EFI_PHYSICAL_ADDRESS) (UINTN) DllEntryPoint;
ImageContext->EntryPoint = (EFI_PHYSICAL_ADDRESS)(UINTN)DllEntryPoint;
SecPrint ("LoadLibraryEx (\n\r %S,\n\r NULL, DONT_RESOLVE_DLL_REFERENCES)\n\r", DllFileName);
}
} else {
@@ -1074,7 +1091,7 @@ VOID
EFIAPI
PeCoffLoaderUnloadImageExtraAction (
IN PE_COFF_LOADER_IMAGE_CONTEXT *ImageContext
)
)
{
VOID *ModHandle;

64
EmulatorPkg/Win/Host/WinHost.h
View File

@@ -12,6 +12,7 @@ Abstract:
Include file for Windows Host
**/
#ifndef _HOST_H_
#define _HOST_H_
@@ -45,17 +46,16 @@ Abstract:
#include <Library/PeCoffExtraActionLib.h>
#include <Library/NetLib.h>
#define TEMPORARY_RAM_SIZE 0x20000
#define TEMPORARY_RAM_SIZE 0x20000
typedef struct {
VOID *Address;
UINTN Size;
VOID *Address;
UINTN Size;
} NT_FD_INFO;
typedef struct {
EFI_PHYSICAL_ADDRESS Memory;
UINT64 Size;
EFI_PHYSICAL_ADDRESS Memory;
UINT64 Size;
} NT_SYSTEM_MEMORY;
RETURN_STATUS
@@ -63,16 +63,17 @@ EFIAPI
SecPeCoffGetEntryPoint (
IN VOID *Pe32Data,
IN OUT VOID **EntryPoint
);
);
VOID
SecLoadSecCore (
IN UINTN TemporaryRam,
IN UINTN TemporaryRamSize,
IN VOID *BootFirmwareVolumeBase,
IN UINTN BootFirmwareVolumeSize,
IN VOID *SecCorePe32File
)
IN UINTN TemporaryRam,
IN UINTN TemporaryRamSize,
IN VOID *BootFirmwareVolumeBase,
IN UINTN BootFirmwareVolumeSize,
IN VOID *SecCorePe32File
)
/*++
Routine Description:
@@ -97,6 +98,7 @@ SecWinNtFdAddress (
IN OUT EFI_PHYSICAL_ADDRESS *FdBase,
IN OUT UINT64 *FdSize
)
/*++
Routine Description:
@@ -116,15 +118,15 @@ Returns:
--*/
;
EFI_STATUS
EFIAPI
SecImageRead (
IN VOID *FileHandle,
IN UINTN FileOffset,
IN OUT UINTN *ReadSize,
OUT VOID *Buffer
IN VOID *FileHandle,
IN UINTN FileOffset,
IN OUT UINTN *ReadSize,
OUT VOID *Buffer
)
/*++
Routine Description:
@@ -147,9 +149,10 @@ Returns:
CHAR16 *
AsciiToUnicode (
IN CHAR8 *Ascii,
IN UINTN *StrLen OPTIONAL
IN CHAR8 *Ascii,
IN UINTN *StrLen OPTIONAL
)
/*++
Routine Description:
@@ -170,9 +173,10 @@ Returns:
UINTN
CountSeparatorsInString (
IN CONST CHAR16 *String,
IN CHAR16 Separator
IN CONST CHAR16 *String,
IN CHAR16 Separator
)
/*++
Routine Description:
@@ -193,16 +197,18 @@ Returns:
BOOLEAN
EfiSystemMemoryRange (
IN VOID *MemoryAddress
IN VOID *MemoryAddress
);
VOID
SecInitializeThunk (
VOID
);
extern EMU_THUNK_PROTOCOL gEmuThunkProtocol;
extern EMU_IO_THUNK_PROTOCOL mWinNtWndThunkIo;
extern EMU_IO_THUNK_PROTOCOL mWinNtFileSystemThunkIo;
extern EMU_IO_THUNK_PROTOCOL mWinNtBlockIoThunkIo;
extern EMU_IO_THUNK_PROTOCOL mWinNtSnpThunkIo;
);
extern EMU_THUNK_PROTOCOL gEmuThunkProtocol;
extern EMU_IO_THUNK_PROTOCOL mWinNtWndThunkIo;
extern EMU_IO_THUNK_PROTOCOL mWinNtFileSystemThunkIo;
extern EMU_IO_THUNK_PROTOCOL mWinNtBlockIoThunkIo;
extern EMU_IO_THUNK_PROTOCOL mWinNtSnpThunkIo;
#endif

13
EmulatorPkg/Win/Host/WinInclude.h
View File

@@ -19,13 +19,13 @@ SPDX-License-Identifier: BSD-2-Clause-Patent
#pragma warning(disable : 4028)
#pragma warning(disable : 4133)
#define GUID _WINNT_DUP_GUID_____
#define GUID _WINNT_DUP_GUID_____
#define _LIST_ENTRY _WINNT_DUP_LIST_ENTRY_FORWARD
#define LIST_ENTRY _WINNT_DUP_LIST_ENTRY
#if defined (MDE_CPU_IA32) && (_MSC_VER < 1800)
#define InterlockedIncrement _WINNT_DUP_InterlockedIncrement
#define InterlockedDecrement _WINNT_DUP_InterlockedDecrement
#define InterlockedCompareExchange64 _WINNT_DUP_InterlockedCompareExchange64
#define InterlockedIncrement _WINNT_DUP_InterlockedIncrement
#define InterlockedDecrement _WINNT_DUP_InterlockedDecrement
#define InterlockedCompareExchange64 _WINNT_DUP_InterlockedCompareExchange64
#endif
#undef UNALIGNED
#undef CONST
@@ -36,7 +36,7 @@ SPDX-License-Identifier: BSD-2-Clause-Patent
// It should be removed after the root cause why
// size_t is undefined when go into the line below is found.
#if defined (MDE_CPU_IA32)
typedef UINT32 size_t ;
typedef UINT32 size_t;
#endif
#include "windows.h"
@@ -51,7 +51,7 @@ typedef UINT32 size_t ;
#undef InterlockedCompareExchangePointer
#undef CreateEventEx
#define VOID void
#define VOID void
//
// Prevent collisions with Windows API name macros that deal with Unicode/Not issues
@@ -66,5 +66,4 @@ typedef UINT32 size_t ;
#pragma warning(default : 4115)
#pragma warning(default : 4201)
#endif

15
EmulatorPkg/Win/Host/WinMemoryAllocationLib.c
View File

@@ -30,10 +30,9 @@ AllocatePool (
IN UINTN AllocationSize
)
{
return (VOID*) malloc (AllocationSize);
return (VOID *)malloc (AllocationSize);
}
/**
Allocates and zeros a buffer of type EfiBootServicesData.
@@ -53,7 +52,7 @@ AllocateZeroPool (
IN UINTN AllocationSize
)
{
VOID *Buffer;
VOID *Buffer;
Buffer = AllocatePool (AllocationSize);
if (Buffer == NULL) {
@@ -65,7 +64,6 @@ AllocateZeroPool (
return Buffer;
}
/**
Reallocates a buffer of type EfiBootServicesData.
@@ -95,7 +93,7 @@ ReallocatePool (
IN VOID *OldBuffer OPTIONAL
)
{
VOID *NewBuffer;
VOID *NewBuffer;
NewBuffer = AllocatePool (NewSize);
if (NewBuffer == NULL) {
@@ -143,10 +141,10 @@ AllocateCopyPool (
if (Memory != NULL) {
Memory = CopyMem (Memory, Buffer, AllocationSize);
}
return Memory;
}
/**
Frees a buffer that was previously allocated with one of the pool allocation functions in the
Memory Allocation Library.
@@ -164,9 +162,8 @@ AllocateCopyPool (
VOID
EFIAPI
FreePool (
IN VOID *Buffer
IN VOID *Buffer
)
{
free ((void *) Buffer);
free ((void *)Buffer);
}

349
EmulatorPkg/Win/Host/WinPacketFilter.c
View File

@@ -20,16 +20,16 @@ SPDX-License-Identifier: BSD-2-Clause-Patent
#pragma pack(1)
typedef struct _NT_NET_INTERFACE_INFO {
UINT32 InterfaceIndex;
EFI_MAC_ADDRESS MacAddr;
UINT32 InterfaceIndex;
EFI_MAC_ADDRESS MacAddr;
} NT_NET_INTERFACE_INFO;
#pragma pack()
#define NET_ETHER_HEADER_SIZE 14
#define MAX_INTERFACE_INFO_NUMBER 16
#define SNP_MAX_TX_BUFFER_NUM 65536
#define SNP_TX_BUFFER_INCREASEMENT 32
#define DEFAULT_SELECTED_NIC_INDEX 0
#define NET_ETHER_HEADER_SIZE 14
#define MAX_INTERFACE_INFO_NUMBER 16
#define SNP_MAX_TX_BUFFER_NUM 65536
#define SNP_TX_BUFFER_INCREASEMENT 32
#define DEFAULT_SELECTED_NIC_INDEX 0
//
// Functions in Net Library
@@ -37,8 +37,8 @@ typedef struct _NT_NET_INTERFACE_INFO {
typedef
INT32
(*NT_NET_INITIALIZE) (
IN OUT UINT32 *InterfaceCount,
IN OUT NT_NET_INTERFACE_INFO * InterfaceInfoBuffer
IN OUT UINT32 *InterfaceCount,
IN OUT NT_NET_INTERFACE_INFO *InterfaceInfoBuffer
);
typedef
@@ -50,85 +50,84 @@ INT32
typedef
INT32
(*NT_NET_SET_RECEIVE_FILTER) (
IN UINT32 Index,
IN UINT32 EnableFilter,
IN UINT32 MCastFilterCnt,
IN EFI_MAC_ADDRESS * MCastFilter
IN UINT32 Index,
IN UINT32 EnableFilter,
IN UINT32 MCastFilterCnt,
IN EFI_MAC_ADDRESS *MCastFilter
);
typedef
INT32
(*NT_NET_RECEIVE) (
IN UINT32 Index,
IN OUT UINT32 *BufferSize,
OUT VOID *Buffer
IN UINT32 Index,
IN OUT UINT32 *BufferSize,
OUT VOID *Buffer
);
typedef
INT32
(*NT_NET_TRANSMIT) (
IN UINT32 Index,
IN UINT32 HeaderSize,
IN UINT32 BufferSize,
IN VOID *Buffer,
IN EFI_MAC_ADDRESS * SrcAddr,
IN EFI_MAC_ADDRESS * DestAddr,
IN UINT16 *Protocol
IN UINT32 Index,
IN UINT32 HeaderSize,
IN UINT32 BufferSize,
IN VOID *Buffer,
IN EFI_MAC_ADDRESS *SrcAddr,
IN EFI_MAC_ADDRESS *DestAddr,
IN UINT16 *Protocol
);
typedef struct _NT_NET_UTILITY_TABLE {
NT_NET_INITIALIZE Initialize;
NT_NET_FINALIZE Finalize;
NT_NET_SET_RECEIVE_FILTER SetReceiveFilter;
NT_NET_RECEIVE Receive;
NT_NET_TRANSMIT Transmit;
NT_NET_INITIALIZE Initialize;
NT_NET_FINALIZE Finalize;
NT_NET_SET_RECEIVE_FILTER SetReceiveFilter;
NT_NET_RECEIVE Receive;
NT_NET_TRANSMIT Transmit;
} NT_NET_UTILITY_TABLE;
//
// Instance data for each fake SNP instance
//
#define WIN_NT_INSTANCE_SIGNATURE SIGNATURE_32 ('N', 'T', 'I', 'S')
#define WIN_NT_INSTANCE_SIGNATURE SIGNATURE_32 ('N', 'T', 'I', 'S')
typedef struct {
UINT32 Signature;
UINT32 Signature;
//
// Array of the recycled transmit buffer address.
//
UINT64 *RecycledTxBuf;
UINT64 *RecycledTxBuf;
//
// Current number of recycled buffer pointers in RecycledTxBuf.
//
UINT32 RecycledTxBufCount;
UINT32 RecycledTxBufCount;
//
// The maximum number of recycled buffer pointers in RecycledTxBuf.
//
UINT32 MaxRecycledTxBuf;
EFI_SIMPLE_NETWORK_MODE Mode;
NT_NET_INTERFACE_INFO InterfaceInfo;
UINT32 MaxRecycledTxBuf;
EFI_SIMPLE_NETWORK_MODE Mode;
NT_NET_INTERFACE_INFO InterfaceInfo;
} WIN_NT_INSTANCE_DATA;
//
// Instance data for each SNP private instance
//
#define WIN_NT_SIMPLE_NETWORK_PRIVATE_SIGNATURE SIGNATURE_32 ('N', 'T', 's', 'n')
#define WIN_NT_SIMPLE_NETWORK_PRIVATE_SIGNATURE SIGNATURE_32 ('N', 'T', 's', 'n')
typedef struct {
UINTN Signature;
EMU_IO_THUNK_PROTOCOL *Thunk;
EMU_SNP_PROTOCOL EmuSnp;
EFI_SIMPLE_NETWORK_MODE *Mode;
HMODULE NetworkLibraryHandle;
NT_NET_UTILITY_TABLE NtNetUtilityTable;
WIN_NT_INSTANCE_DATA Instance;
UINTN Signature;
EMU_IO_THUNK_PROTOCOL *Thunk;
EMU_SNP_PROTOCOL EmuSnp;
EFI_SIMPLE_NETWORK_MODE *Mode;
HMODULE NetworkLibraryHandle;
NT_NET_UTILITY_TABLE NtNetUtilityTable;
WIN_NT_INSTANCE_DATA Instance;
} WIN_NT_SNP_PRIVATE;
#define WIN_NT_SNP_PRIVATE_DATA_FROM_THIS(a) \
CR(a, WIN_NT_SNP_PRIVATE, EmuSnp, WIN_NT_SIMPLE_NETWORK_PRIVATE_SIGNATURE)
/**
Register storage for SNP Mode.
@@ -145,7 +144,7 @@ WinNtSnpCreateMapping (
IN EFI_SIMPLE_NETWORK_MODE *Mode
)
{
WIN_NT_SNP_PRIVATE *Private;
WIN_NT_SNP_PRIVATE *Private;
Private = WIN_NT_SNP_PRIVATE_DATA_FROM_THIS (This);
@@ -181,7 +180,7 @@ WinNtSnpStart (
IN EMU_SNP_PROTOCOL *This
)
{
WIN_NT_SNP_PRIVATE *Private;
WIN_NT_SNP_PRIVATE *Private;
Private = WIN_NT_SNP_PRIVATE_DATA_FROM_THIS (This);
@@ -221,7 +220,7 @@ WinNtSnpStop (
IN EMU_SNP_PROTOCOL *This
)
{
WIN_NT_SNP_PRIVATE *Private;
WIN_NT_SNP_PRIVATE *Private;
Private = WIN_NT_SNP_PRIVATE_DATA_FROM_THIS (This);
@@ -271,12 +270,12 @@ WinNtSnpStop (
**/
EFI_STATUS
WinNtSnpInitialize (
IN EMU_SNP_PROTOCOL *This,
IN UINTN ExtraRxBufferSize OPTIONAL,
IN UINTN ExtraTxBufferSize OPTIONAL
IN EMU_SNP_PROTOCOL *This,
IN UINTN ExtraRxBufferSize OPTIONAL,
IN UINTN ExtraTxBufferSize OPTIONAL
)
{
WIN_NT_SNP_PRIVATE *Private;
WIN_NT_SNP_PRIVATE *Private;
Private = WIN_NT_SNP_PRIVATE_DATA_FROM_THIS (This);
@@ -293,7 +292,7 @@ WinNtSnpInitialize (
break;
}
Private->Mode->MCastFilterCount = 0;
Private->Mode->MCastFilterCount = 0;
Private->Mode->ReceiveFilterSetting = 0;
ZeroMem (Private->Mode->MCastFilter, sizeof (Private->Mode->MCastFilter));
@@ -320,11 +319,11 @@ WinNtSnpInitialize (
**/
EFI_STATUS
WinNtSnpReset (
IN EMU_SNP_PROTOCOL *This,
IN BOOLEAN ExtendedVerification
IN EMU_SNP_PROTOCOL *This,
IN BOOLEAN ExtendedVerification
)
{
WIN_NT_SNP_PRIVATE *Private;
WIN_NT_SNP_PRIVATE *Private;
Private = WIN_NT_SNP_PRIVATE_DATA_FROM_THIS (This);
@@ -362,7 +361,7 @@ WinNtSnpShutdown (
IN EMU_SNP_PROTOCOL *This
)
{
WIN_NT_SNP_PRIVATE *Private;
WIN_NT_SNP_PRIVATE *Private;
Private = WIN_NT_SNP_PRIVATE_DATA_FROM_THIS (This);
@@ -382,7 +381,7 @@ WinNtSnpShutdown (
Private->Mode->State = EfiSimpleNetworkStarted;
Private->Mode->ReceiveFilterSetting = 0;
Private->Mode->MCastFilterCount = 0;
Private->Mode->MCastFilterCount = 0;
ZeroMem (Private->Mode->MCastFilter, sizeof (Private->Mode->MCastFilter));
return EFI_SUCCESS;
@@ -414,25 +413,25 @@ WinNtSnpShutdown (
**/
EFI_STATUS
WinNtSnpReceiveFilters (
IN EMU_SNP_PROTOCOL *This,
IN UINT32 Enable,
IN UINT32 Disable,
IN BOOLEAN ResetMCastFilter,
IN UINTN MCastFilterCnt OPTIONAL,
IN EFI_MAC_ADDRESS *MCastFilter OPTIONAL
IN EMU_SNP_PROTOCOL *This,
IN UINT32 Enable,
IN UINT32 Disable,
IN BOOLEAN ResetMCastFilter,
IN UINTN MCastFilterCnt OPTIONAL,
IN EFI_MAC_ADDRESS *MCastFilter OPTIONAL
)
{
WIN_NT_SNP_PRIVATE *Private;
INT32 ReturnValue;
WIN_NT_SNP_PRIVATE *Private;
INT32 ReturnValue;
Private = WIN_NT_SNP_PRIVATE_DATA_FROM_THIS (This);
ReturnValue = Private->NtNetUtilityTable.SetReceiveFilter (
Private->Instance.InterfaceInfo.InterfaceIndex,
Enable,
(UINT32)MCastFilterCnt,
MCastFilter
);
Private->Instance.InterfaceInfo.InterfaceIndex,
Enable,
(UINT32)MCastFilterCnt,
MCastFilter
);
if (ReturnValue <= 0) {
return EFI_DEVICE_ERROR;
@@ -458,12 +457,12 @@ WinNtSnpReceiveFilters (
**/
EFI_STATUS
WinNtSnpStationAddress (
IN EMU_SNP_PROTOCOL *This,
IN BOOLEAN Reset,
IN EFI_MAC_ADDRESS *New OPTIONAL
IN EMU_SNP_PROTOCOL *This,
IN BOOLEAN Reset,
IN EFI_MAC_ADDRESS *New OPTIONAL
)
{
WIN_NT_SNP_PRIVATE *Private;
WIN_NT_SNP_PRIVATE *Private;
Private = WIN_NT_SNP_PRIVATE_DATA_FROM_THIS (This);
@@ -493,13 +492,13 @@ WinNtSnpStationAddress (
**/
EFI_STATUS
WinNtSnpStatistics (
IN EMU_SNP_PROTOCOL *This,
IN BOOLEAN Reset,
IN OUT UINTN *StatisticsSize OPTIONAL,
OUT EFI_NETWORK_STATISTICS *StatisticsTable OPTIONAL
IN EMU_SNP_PROTOCOL *This,
IN BOOLEAN Reset,
IN OUT UINTN *StatisticsSize OPTIONAL,
OUT EFI_NETWORK_STATISTICS *StatisticsTable OPTIONAL
)
{
WIN_NT_SNP_PRIVATE *Private;
WIN_NT_SNP_PRIVATE *Private;
Private = WIN_NT_SNP_PRIVATE_DATA_FROM_THIS (This);
@@ -529,13 +528,13 @@ WinNtSnpStatistics (
**/
EFI_STATUS
WinNtSnpMCastIpToMac (
IN EMU_SNP_PROTOCOL *This,
IN BOOLEAN IPv6,
IN EFI_IP_ADDRESS *IP,
OUT EFI_MAC_ADDRESS *MAC
IN EMU_SNP_PROTOCOL *This,
IN BOOLEAN IPv6,
IN EFI_IP_ADDRESS *IP,
OUT EFI_MAC_ADDRESS *MAC
)
{
WIN_NT_SNP_PRIVATE *Private;
WIN_NT_SNP_PRIVATE *Private;
Private = WIN_NT_SNP_PRIVATE_DATA_FROM_THIS (This);
@@ -564,14 +563,14 @@ WinNtSnpMCastIpToMac (
**/
EFI_STATUS
WinNtSnpNvData (
IN EMU_SNP_PROTOCOL *This,
IN BOOLEAN ReadWrite,
IN UINTN Offset,
IN UINTN BufferSize,
IN OUT VOID *Buffer
IN EMU_SNP_PROTOCOL *This,
IN BOOLEAN ReadWrite,
IN UINTN Offset,
IN UINTN BufferSize,
IN OUT VOID *Buffer
)
{
WIN_NT_SNP_PRIVATE *Private;
WIN_NT_SNP_PRIVATE *Private;
Private = WIN_NT_SNP_PRIVATE_DATA_FROM_THIS (This);
@@ -605,21 +604,21 @@ WinNtSnpNvData (
**/
EFI_STATUS
WinNtSnpGetStatus (
IN EMU_SNP_PROTOCOL *This,
OUT UINT32 *InterruptStatus OPTIONAL,
OUT VOID **TxBuf OPTIONAL
IN EMU_SNP_PROTOCOL *This,
OUT UINT32 *InterruptStatus OPTIONAL,
OUT VOID **TxBuf OPTIONAL
)
{
WIN_NT_SNP_PRIVATE *Private;
WIN_NT_SNP_PRIVATE *Private;
Private = WIN_NT_SNP_PRIVATE_DATA_FROM_THIS (This);
if (TxBuf != NULL) {
if (Private->Instance.RecycledTxBufCount != 0) {
Private->Instance.RecycledTxBufCount --;
*((UINT8 **) TxBuf) = (UINT8 *) (UINTN)Private->Instance.RecycledTxBuf[Private->Instance.RecycledTxBufCount];
Private->Instance.RecycledTxBufCount--;
*((UINT8 **)TxBuf) = (UINT8 *)(UINTN)Private->Instance.RecycledTxBuf[Private->Instance.RecycledTxBufCount];
} else {
*((UINT8 **) TxBuf) = NULL;
*((UINT8 **)TxBuf) = NULL;
}
}
@@ -665,18 +664,18 @@ WinNtSnpGetStatus (
**/
EFI_STATUS
WinNtSnpTransmit (
IN EMU_SNP_PROTOCOL *This,
IN UINTN HeaderSize,
IN UINTN BufferSize,
IN VOID *Buffer,
IN EFI_MAC_ADDRESS *SrcAddr OPTIONAL,
IN EFI_MAC_ADDRESS *DestAddr OPTIONAL,
IN UINT16 *Protocol OPTIONAL
IN EMU_SNP_PROTOCOL *This,
IN UINTN HeaderSize,
IN UINTN BufferSize,
IN VOID *Buffer,
IN EFI_MAC_ADDRESS *SrcAddr OPTIONAL,
IN EFI_MAC_ADDRESS *DestAddr OPTIONAL,
IN UINT16 *Protocol OPTIONAL
)
{
WIN_NT_SNP_PRIVATE *Private;
INT32 ReturnValue;
UINT64 *Tmp;
WIN_NT_SNP_PRIVATE *Private;
INT32 ReturnValue;
UINT64 *Tmp;
Private = WIN_NT_SNP_PRIVATE_DATA_FROM_THIS (This);
@@ -685,14 +684,14 @@ WinNtSnpTransmit (
}
ReturnValue = Private->NtNetUtilityTable.Transmit (
Private->Instance.InterfaceInfo.InterfaceIndex,
(UINT32)HeaderSize,
(UINT32)BufferSize,
Buffer,
SrcAddr,
DestAddr,
Protocol
);
Private->Instance.InterfaceInfo.InterfaceIndex,
(UINT32)HeaderSize,
(UINT32)BufferSize,
Buffer,
SrcAddr,
DestAddr,
Protocol
);
if (ReturnValue < 0) {
return EFI_DEVICE_ERROR;
@@ -702,16 +701,17 @@ WinNtSnpTransmit (
}
if (Private->Instance.RecycledTxBufCount < Private->Instance.MaxRecycledTxBuf) {
Private->Instance.RecycledTxBuf[Private->Instance.RecycledTxBufCount] = (UINT64) Buffer;
Private->Instance.RecycledTxBufCount ++;
Private->Instance.RecycledTxBuf[Private->Instance.RecycledTxBufCount] = (UINT64)Buffer;
Private->Instance.RecycledTxBufCount++;
} else {
Tmp = malloc (sizeof (UINT64) * (Private->Instance.MaxRecycledTxBuf + SNP_TX_BUFFER_INCREASEMENT));
if (Tmp == NULL) {
return EFI_DEVICE_ERROR;
}
CopyMem (Tmp, Private->Instance.RecycledTxBuf, sizeof (UINT64) * Private->Instance.RecycledTxBufCount);
free (Private->Instance.RecycledTxBuf);
Private->Instance.RecycledTxBuf = Tmp;
Private->Instance.RecycledTxBuf = Tmp;
Private->Instance.MaxRecycledTxBuf += SNP_TX_BUFFER_INCREASEMENT;
}
}
@@ -753,30 +753,30 @@ WinNtSnpTransmit (
**/
EFI_STATUS
WinNtSnpReceive (
IN EMU_SNP_PROTOCOL *This,
OUT UINTN *HeaderSize OPTIONAL,
IN OUT UINTN *BufferSize,
OUT VOID *Buffer,
OUT EFI_MAC_ADDRESS *SrcAddr OPTIONAL,
OUT EFI_MAC_ADDRESS *DestAddr OPTIONAL,
OUT UINT16 *Protocol OPTIONAL
IN EMU_SNP_PROTOCOL *This,
OUT UINTN *HeaderSize OPTIONAL,
IN OUT UINTN *BufferSize,
OUT VOID *Buffer,
OUT EFI_MAC_ADDRESS *SrcAddr OPTIONAL,
OUT EFI_MAC_ADDRESS *DestAddr OPTIONAL,
OUT UINT16 *Protocol OPTIONAL
)
{
WIN_NT_SNP_PRIVATE *Private;
INT32 ReturnValue;
UINTN BufSize;
WIN_NT_SNP_PRIVATE *Private;
INT32 ReturnValue;
UINTN BufSize;
Private = WIN_NT_SNP_PRIVATE_DATA_FROM_THIS (This);
BufSize = *BufferSize;
BufSize = *BufferSize;
ASSERT (Private->NtNetUtilityTable.Receive != NULL);
ReturnValue = Private->NtNetUtilityTable.Receive (
Private->Instance.InterfaceInfo.InterfaceIndex,
BufferSize,
Buffer
);
Private->Instance.InterfaceInfo.InterfaceIndex,
BufferSize,
Buffer
);
if (ReturnValue < 0) {
if (ReturnValue == -100) {
@@ -794,16 +794,16 @@ WinNtSnpReceive (
if (SrcAddr != NULL) {
ZeroMem (SrcAddr, sizeof (EFI_MAC_ADDRESS));
CopyMem (SrcAddr, ((UINT8 *) Buffer) + 6, 6);
CopyMem (SrcAddr, ((UINT8 *)Buffer) + 6, 6);
}
if (DestAddr != NULL) {
ZeroMem (DestAddr, sizeof (EFI_MAC_ADDRESS));
CopyMem (DestAddr, ((UINT8 *) Buffer), 6);
CopyMem (DestAddr, ((UINT8 *)Buffer), 6);
}
if (Protocol != NULL) {
*Protocol = NTOHS (*((UINT16 *) (((UINT8 *) Buffer) + 12)));
*Protocol = NTOHS (*((UINT16 *)(((UINT8 *)Buffer) + 12)));
}
return (*BufferSize <= BufSize) ? EFI_SUCCESS : EFI_BUFFER_TOO_SMALL;
@@ -821,27 +821,27 @@ WinNtSnpReceive (
**/
EFI_STATUS
WinNtInitializeInstanceData (
IN OUT WIN_NT_INSTANCE_DATA *Instance,
IN NT_NET_INTERFACE_INFO *NetInfo
IN OUT WIN_NT_INSTANCE_DATA *Instance,
IN NT_NET_INTERFACE_INFO *NetInfo
)
{
if (Instance == NULL || NetInfo == NULL) {
if ((Instance == NULL) || (NetInfo == NULL)) {
return EFI_INVALID_PARAMETER;
}
ZeroMem (Instance, sizeof (WIN_NT_INSTANCE_DATA));
Instance->Signature = WIN_NT_INSTANCE_SIGNATURE;
Instance->RecycledTxBufCount = 0;
Instance->MaxRecycledTxBuf = 32;
Instance->Mode.State = EfiSimpleNetworkInitialized;
Instance->Mode.HwAddressSize = NET_ETHER_ADDR_LEN;
Instance->Mode.MediaHeaderSize = NET_ETHER_HEADER_SIZE;
Instance->Mode.MaxPacketSize = 1500;
Instance->Mode.MaxMCastFilterCount = MAX_MCAST_FILTER_CNT;
Instance->Mode.IfType = NET_IFTYPE_ETHERNET;
Instance->Signature = WIN_NT_INSTANCE_SIGNATURE;
Instance->RecycledTxBufCount = 0;
Instance->MaxRecycledTxBuf = 32;
Instance->Mode.State = EfiSimpleNetworkInitialized;
Instance->Mode.HwAddressSize = NET_ETHER_ADDR_LEN;
Instance->Mode.MediaHeaderSize = NET_ETHER_HEADER_SIZE;
Instance->Mode.MaxPacketSize = 1500;
Instance->Mode.MaxMCastFilterCount = MAX_MCAST_FILTER_CNT;
Instance->Mode.IfType = NET_IFTYPE_ETHERNET;
Instance->Mode.MediaPresentSupported = TRUE;
Instance->Mode.MediaPresent = TRUE;
Instance->Mode.MediaPresent = TRUE;
//
// Allocate the RecycledTxBuf.
@@ -856,7 +856,6 @@ WinNtInitializeInstanceData (
//
CopyMem (&Instance->InterfaceInfo, NetInfo, sizeof (Instance->InterfaceInfo));
//
// Set broadcast address
//
@@ -865,8 +864,8 @@ WinNtInitializeInstanceData (
//
// Copy Current/PermanentAddress MAC address
//
CopyMem (&Instance->Mode.CurrentAddress, &Instance->InterfaceInfo.MacAddr, sizeof(Instance->Mode.CurrentAddress));
CopyMem (&Instance->Mode.PermanentAddress, &Instance->InterfaceInfo.MacAddr, sizeof(Instance->Mode.PermanentAddress));
CopyMem (&Instance->Mode.CurrentAddress, &Instance->InterfaceInfo.MacAddr, sizeof (Instance->Mode.CurrentAddress));
CopyMem (&Instance->Mode.PermanentAddress, &Instance->InterfaceInfo.MacAddr, sizeof (Instance->Mode.PermanentAddress));
//
// Since the fake SNP is based on a real NIC, to avoid conflict with the host
@@ -892,20 +891,20 @@ WinNtInitializeInstanceData (
**/
EFI_STATUS
WintNtInitializeNetUtilityData (
IN OUT WIN_NT_SNP_PRIVATE *Private,
IN OUT WIN_NT_SNP_PRIVATE *Private,
IN UINT8 ActiveInstance
)
{
EFI_STATUS Status;
CHAR16 *DllFileNameU;
INT32 ReturnValue;
BOOLEAN NetUtilityLibInitDone;
NT_NET_INTERFACE_INFO NetInterfaceInfoBuffer[MAX_INTERFACE_INFO_NUMBER];
UINT32 InterfaceCount;
UINT8 ActiveInterfaceIndex;
EFI_STATUS Status;
CHAR16 *DllFileNameU;
INT32 ReturnValue;
BOOLEAN NetUtilityLibInitDone;
NT_NET_INTERFACE_INFO NetInterfaceInfoBuffer[MAX_INTERFACE_INFO_NUMBER];
UINT32 InterfaceCount;
UINT8 ActiveInterfaceIndex;
if (Private == NULL) {
return EFI_INVALID_PARAMETER;
return EFI_INVALID_PARAMETER;
}
NetUtilityLibInitDone = FALSE;
@@ -920,31 +919,31 @@ WintNtInitializeNetUtilityData (
return EFI_NOT_FOUND;
}
Private->NtNetUtilityTable.Initialize = (NT_NET_INITIALIZE) GetProcAddress (Private->NetworkLibraryHandle, NETWORK_LIBRARY_INITIALIZE);
Private->NtNetUtilityTable.Initialize = (NT_NET_INITIALIZE)GetProcAddress (Private->NetworkLibraryHandle, NETWORK_LIBRARY_INITIALIZE);
if (NULL == Private->NtNetUtilityTable.Initialize) {
Status = EFI_NOT_FOUND;
goto ErrorReturn;
}
Private->NtNetUtilityTable.Finalize = (NT_NET_FINALIZE) GetProcAddress (Private->NetworkLibraryHandle, NETWORK_LIBRARY_FINALIZE);
Private->NtNetUtilityTable.Finalize = (NT_NET_FINALIZE)GetProcAddress (Private->NetworkLibraryHandle, NETWORK_LIBRARY_FINALIZE);
if (NULL == Private->NtNetUtilityTable.Finalize) {
Status = EFI_NOT_FOUND;
goto ErrorReturn;
}
Private->NtNetUtilityTable.SetReceiveFilter = (NT_NET_SET_RECEIVE_FILTER) GetProcAddress (Private->NetworkLibraryHandle, NETWORK_LIBRARY_SET_RCV_FILTER);
Private->NtNetUtilityTable.SetReceiveFilter = (NT_NET_SET_RECEIVE_FILTER)GetProcAddress (Private->NetworkLibraryHandle, NETWORK_LIBRARY_SET_RCV_FILTER);
if (NULL == Private->NtNetUtilityTable.SetReceiveFilter) {
Status = EFI_NOT_FOUND;
goto ErrorReturn;
}
Private->NtNetUtilityTable.Receive = (NT_NET_RECEIVE) GetProcAddress (Private->NetworkLibraryHandle, NETWORK_LIBRARY_RECEIVE);
Private->NtNetUtilityTable.Receive = (NT_NET_RECEIVE)GetProcAddress (Private->NetworkLibraryHandle, NETWORK_LIBRARY_RECEIVE);
if (NULL == Private->NtNetUtilityTable.Receive) {
Status = EFI_NOT_FOUND;
goto ErrorReturn;
}
Private->NtNetUtilityTable.Transmit = (NT_NET_TRANSMIT) GetProcAddress (Private->NetworkLibraryHandle, NETWORK_LIBRARY_TRANSMIT);
Private->NtNetUtilityTable.Transmit = (NT_NET_TRANSMIT)GetProcAddress (Private->NetworkLibraryHandle, NETWORK_LIBRARY_TRANSMIT);
if (NULL == Private->NtNetUtilityTable.Transmit) {
Status = EFI_NOT_FOUND;
goto ErrorReturn;
@@ -979,7 +978,7 @@ WintNtInitializeNetUtilityData (
//
Status = WinNtInitializeInstanceData (&Private->Instance, &NetInterfaceInfoBuffer[ActiveInterfaceIndex]);
if (EFI_ERROR (Status)) {
goto ErrorReturn;
goto ErrorReturn;
}
return EFI_SUCCESS;
@@ -987,7 +986,7 @@ WintNtInitializeNetUtilityData (
ErrorReturn:
if (Private->Instance.RecycledTxBuf != NULL) {
free (Private->Instance.RecycledTxBuf);
free (Private->Instance.RecycledTxBuf);
}
if (NetUtilityLibInitDone) {
@@ -1011,7 +1010,7 @@ ErrorReturn:
**/
EFI_STATUS
WintNtReleaseNetUtilityData (
IN OUT WIN_NT_SNP_PRIVATE *Private
IN OUT WIN_NT_SNP_PRIVATE *Private
)
{
if (Private == NULL) {
@@ -1019,7 +1018,7 @@ WintNtReleaseNetUtilityData (
}
if (Private->Instance.RecycledTxBuf != NULL) {
free (Private->Instance.RecycledTxBuf);
free (Private->Instance.RecycledTxBuf);
}
if (Private->NtNetUtilityTable.Finalize != NULL) {
@@ -1031,7 +1030,7 @@ WintNtReleaseNetUtilityData (
return EFI_SUCCESS;
}
EMU_SNP_PROTOCOL mWinNtSnpProtocol = {
EMU_SNP_PROTOCOL mWinNtSnpProtocol = {
WinNtSnpCreateMapping,
WinNtSnpStart,
WinNtSnpStop,
@@ -1061,7 +1060,7 @@ EMU_SNP_PROTOCOL mWinNtSnpProtocol = {
**/
EFI_STATUS
WinNtSnpThunkOpen (
IN EMU_IO_THUNK_PROTOCOL *This
IN EMU_IO_THUNK_PROTOCOL *This
)
{
WIN_NT_SNP_PRIVATE *Private;
@@ -1089,7 +1088,7 @@ WinNtSnpThunkOpen (
This->Interface = &Private->EmuSnp;
This->Private = Private;
if (This->ConfigString != NULL && This->ConfigString[0] != '\0') {
if ((This->ConfigString != NULL) && (This->ConfigString[0] != '\0')) {
HostInterfaceIndex = (UINT8)StrDecimalToUintn (This->ConfigString);
}
@@ -1108,7 +1107,7 @@ WinNtSnpThunkOpen (
**/
EFI_STATUS
WinNtSnpThunkClose (
IN EMU_IO_THUNK_PROTOCOL *This
IN EMU_IO_THUNK_PROTOCOL *This
)
{
WIN_NT_SNP_PRIVATE *Private;
@@ -1124,7 +1123,7 @@ WinNtSnpThunkClose (
return EFI_SUCCESS;
}
EMU_IO_THUNK_PROTOCOL mWinNtSnpThunkIo = {
EMU_IO_THUNK_PROTOCOL mWinNtSnpThunkIo = {
&gEmuSnpProtocolGuid,
NULL,
NULL,

245
EmulatorPkg/Win/Host/WinThunk.c
View File

@@ -32,33 +32,32 @@ Abstract:
UINTN
SecWriteStdErr (
IN UINT8 *Buffer,
IN UINTN NumberOfBytes
IN UINT8 *Buffer,
IN UINTN NumberOfBytes
)
{
BOOL Success;
DWORD CharCount;
BOOL Success;
DWORD CharCount;
CharCount = (DWORD)NumberOfBytes;
Success = WriteFile (
GetStdHandle (STD_ERROR_HANDLE),
Buffer,
CharCount,
&CharCount,
NULL
);
Success = WriteFile (
GetStdHandle (STD_ERROR_HANDLE),
Buffer,
CharCount,
&CharCount,
NULL
);
return Success ? CharCount : 0;
}
EFI_STATUS
SecConfigStdIn (
VOID
)
{
BOOL Success;
DWORD Mode;
BOOL Success;
DWORD Mode;
Success = GetConsoleMode (GetStdHandle (STD_INPUT_HANDLE), &Mode);
if (Success) {
@@ -67,17 +66,17 @@ SecConfigStdIn (
//
Mode &= ~(ENABLE_LINE_INPUT | ENABLE_ECHO_INPUT | ENABLE_MOUSE_INPUT | ENABLE_WINDOW_INPUT);
#if defined(NTDDI_VERSION) && defined (NTDDI_WIN10_TH2) && (NTDDI_VERSION > NTDDI_WIN10_TH2)
#if defined (NTDDI_VERSION) && defined (NTDDI_WIN10_TH2) && (NTDDI_VERSION > NTDDI_WIN10_TH2)
//
// Enable virtual terminal input for Win10 above TH2
//
Mode |= ENABLE_VIRTUAL_TERMINAL_INPUT;
#endif
#endif
Success = SetConsoleMode (GetStdHandle (STD_INPUT_HANDLE), Mode);
}
#if defined(NTDDI_VERSION) && defined (NTDDI_WIN10_TH2) && (NTDDI_VERSION > NTDDI_WIN10_TH2)
#if defined (NTDDI_VERSION) && defined (NTDDI_WIN10_TH2) && (NTDDI_VERSION > NTDDI_WIN10_TH2)
//
// Enable terminal mode for Win10 above TH2
//
@@ -85,32 +84,33 @@ SecConfigStdIn (
Success = GetConsoleMode (GetStdHandle (STD_OUTPUT_HANDLE), &Mode);
if (Success) {
Success = SetConsoleMode (
GetStdHandle (STD_OUTPUT_HANDLE),
Mode | ENABLE_VIRTUAL_TERMINAL_PROCESSING | DISABLE_NEWLINE_AUTO_RETURN
);
GetStdHandle (STD_OUTPUT_HANDLE),
Mode | ENABLE_VIRTUAL_TERMINAL_PROCESSING | DISABLE_NEWLINE_AUTO_RETURN
);
}
}
#endif
#endif
return Success ? EFI_SUCCESS : EFI_DEVICE_ERROR;
}
UINTN
SecWriteStdOut (
IN UINT8 *Buffer,
IN UINTN NumberOfBytes
IN UINT8 *Buffer,
IN UINTN NumberOfBytes
)
{
BOOL Success;
DWORD CharCount;
BOOL Success;
DWORD CharCount;
CharCount = (DWORD)NumberOfBytes;
Success = WriteFile (
GetStdHandle (STD_OUTPUT_HANDLE),
Buffer,
CharCount,
&CharCount,
NULL
);
Success = WriteFile (
GetStdHandle (STD_OUTPUT_HANDLE),
Buffer,
CharCount,
&CharCount,
NULL
);
return Success ? CharCount : 0;
}
@@ -120,34 +120,35 @@ SecPollStdIn (
VOID
)
{
BOOL Success;
INPUT_RECORD Record;
DWORD RecordNum;
BOOL Success;
INPUT_RECORD Record;
DWORD RecordNum;
do {
Success = GetNumberOfConsoleInputEvents (GetStdHandle (STD_INPUT_HANDLE), &RecordNum);
if (!Success || (RecordNum == 0)) {
break;
}
Success = PeekConsoleInput (
GetStdHandle (STD_INPUT_HANDLE),
&Record,
1,
&RecordNum
);
GetStdHandle (STD_INPUT_HANDLE),
&Record,
1,
&RecordNum
);
if (Success && (RecordNum == 1)) {
if (Record.EventType == KEY_EVENT && Record.Event.KeyEvent.bKeyDown) {
if ((Record.EventType == KEY_EVENT) && Record.Event.KeyEvent.bKeyDown) {
return TRUE;
} else {
//
// Consume the non-key event.
//
Success = ReadConsoleInput (
GetStdHandle (STD_INPUT_HANDLE),
&Record,
1,
&RecordNum
);
GetStdHandle (STD_INPUT_HANDLE),
&Record,
1,
&RecordNum
);
}
}
} while (Success);
@@ -157,37 +158,38 @@ SecPollStdIn (
UINTN
SecReadStdIn (
IN UINT8 *Buffer,
IN UINTN NumberOfBytes
IN UINT8 *Buffer,
IN UINTN NumberOfBytes
)
{
BOOL Success;
INPUT_RECORD Record;
DWORD RecordNum;
UINTN BytesReturn;
BOOL Success;
INPUT_RECORD Record;
DWORD RecordNum;
UINTN BytesReturn;
if (!SecPollStdIn ()) {
return 0;
}
Success = ReadConsoleInput (
GetStdHandle (STD_INPUT_HANDLE),
&Record,
1,
&RecordNum
);
GetStdHandle (STD_INPUT_HANDLE),
&Record,
1,
&RecordNum
);
ASSERT (Success && (RecordNum == 1) && (Record.EventType == KEY_EVENT) && (Record.Event.KeyEvent.bKeyDown));
NumberOfBytes = MIN (Record.Event.KeyEvent.wRepeatCount, NumberOfBytes);
BytesReturn = NumberOfBytes;
while (NumberOfBytes-- != 0) {
Buffer[NumberOfBytes] = Record.Event.KeyEvent.uChar.AsciiChar;
}
return BytesReturn;
}
VOID *
SecAlloc (
IN UINTN Size
IN UINTN Size
)
{
return malloc ((size_t)Size);
@@ -195,7 +197,7 @@ SecAlloc (
BOOLEAN
SecFree (
IN VOID *Ptr
IN VOID *Ptr
)
{
if (EfiSystemMemoryRange (Ptr)) {
@@ -208,13 +210,11 @@ SecFree (
return TRUE;
}
//
// Define a global that we can use to shut down the NT timer thread when
// the timer is canceled.
//
BOOLEAN mCancelTimerThread = FALSE;
BOOLEAN mCancelTimerThread = FALSE;
//
// The notification function to call on every timer interrupt
@@ -224,41 +224,40 @@ EMU_SET_TIMER_CALLBACK *mTimerNotifyFunction = NULL;
//
// The thread handle for this driver
//
HANDLE mNtMainThreadHandle;
HANDLE mNtMainThreadHandle;
//
// The timer value from the last timer interrupt
//
UINT32 mNtLastTick;
UINT32 mNtLastTick;
//
// Critical section used to update varibles shared between the main thread and
// the timer interrupt thread.
//
CRITICAL_SECTION mNtCriticalSection;
CRITICAL_SECTION mNtCriticalSection;
//
// Worker Functions
//
UINT mMMTimerThreadID = 0;
UINT mMMTimerThreadID = 0;
volatile BOOLEAN mInterruptEnabled = FALSE;
volatile BOOLEAN mInterruptEnabled = FALSE;
VOID
CALLBACK
MMTimerThread (
UINT wTimerID,
UINT msg,
DWORD dwUser,
DWORD dw1,
DWORD dw2
)
UINT wTimerID,
UINT msg,
DWORD dwUser,
DWORD dw1,
DWORD dw2
)
{
UINT32 CurrentTick;
UINT32 Delta;
UINT32 CurrentTick;
UINT32 Delta;
if (!mCancelTimerThread) {
//
// Suspend the main thread until we are done.
// Enter the critical section before suspending
@@ -306,14 +305,13 @@ MMTimerThread (
// Get the current system tick
//
CurrentTick = GetTickCount ();
Delta = CurrentTick - mNtLastTick;
Delta = CurrentTick - mNtLastTick;
mNtLastTick = CurrentTick;
//
// If delay was more then 1 second, ignore it (probably debugging case)
//
if (Delta < 1000) {
//
// Only invoke the callback function if a Non-NULL handler has been
// registered. Assume all other handlers are legal.
@@ -332,18 +330,17 @@ MMTimerThread (
timeKillEvent (wTimerID);
mMMTimerThreadID = 0;
}
}
VOID
SecSetTimer (
IN UINT64 TimerPeriod,
IN EMU_SET_TIMER_CALLBACK Callback
)
)
{
//
// If TimerPeriod is 0, then the timer thread should be canceled
//
// If TimerPeriod is 0, then the timer thread should be canceled
//
if (TimerPeriod == 0) {
//
// Cancel the timer thread
@@ -384,23 +381,24 @@ SecSetTimer (
SetThreadPriority (
GetCurrentThread (),
THREAD_PRIORITY_HIGHEST
);
);
mMMTimerThreadID = timeSetEvent (
(UINT)TimerPeriod,
0,
MMTimerThread,
(DWORD_PTR)NULL,
TIME_PERIODIC | TIME_KILL_SYNCHRONOUS | TIME_CALLBACK_FUNCTION
);
(UINT)TimerPeriod,
0,
MMTimerThread,
(DWORD_PTR)NULL,
TIME_PERIODIC | TIME_KILL_SYNCHRONOUS | TIME_CALLBACK_FUNCTION
);
}
mTimerNotifyFunction = Callback;
}
VOID
SecInitializeThunk (
VOID
)
)
{
InitializeCriticalSection (&mNtCriticalSection);
@@ -412,7 +410,7 @@ SecInitializeThunk (
0,
FALSE,
DUPLICATE_SAME_ACCESS
);
);
}
VOID
@@ -423,7 +421,6 @@ SecEnableInterrupt (
mInterruptEnabled = TRUE;
}
VOID
SecDisableInterrupt (
VOID
@@ -432,7 +429,6 @@ SecDisableInterrupt (
mInterruptEnabled = FALSE;
}
UINT64
SecQueryPerformanceFrequency (
VOID
@@ -450,17 +446,14 @@ SecQueryPerformanceCounter (
return 0;
}
VOID
SecSleep (
IN UINT64 Nanoseconds
IN UINT64 Nanoseconds
)
{
Sleep ((DWORD)DivU64x32 (Nanoseconds, 1000000));
}
VOID
SecCpuSleep (
VOID
@@ -469,40 +462,38 @@ SecCpuSleep (
Sleep (1);
}
VOID
SecExit (
UINTN Status
UINTN Status
)
{
exit ((int)Status);
}
VOID
SecGetTime (
OUT EFI_TIME *Time,
OUT EFI_TIME_CAPABILITIES *Capabilities OPTIONAL
OUT EFI_TIME *Time,
OUT EFI_TIME_CAPABILITIES *Capabilities OPTIONAL
)
{
SYSTEMTIME SystemTime;
TIME_ZONE_INFORMATION TimeZone;
SYSTEMTIME SystemTime;
TIME_ZONE_INFORMATION TimeZone;
GetLocalTime (&SystemTime);
GetTimeZoneInformation (&TimeZone);
Time->Year = (UINT16)SystemTime.wYear;
Time->Month = (UINT8)SystemTime.wMonth;
Time->Day = (UINT8)SystemTime.wDay;
Time->Hour = (UINT8)SystemTime.wHour;
Time->Minute = (UINT8)SystemTime.wMinute;
Time->Second = (UINT8)SystemTime.wSecond;
Time->Year = (UINT16)SystemTime.wYear;
Time->Month = (UINT8)SystemTime.wMonth;
Time->Day = (UINT8)SystemTime.wDay;
Time->Hour = (UINT8)SystemTime.wHour;
Time->Minute = (UINT8)SystemTime.wMinute;
Time->Second = (UINT8)SystemTime.wSecond;
Time->Nanosecond = (UINT32)(SystemTime.wMilliseconds * 1000000);
Time->TimeZone = (INT16)TimeZone.Bias;
Time->TimeZone = (INT16)TimeZone.Bias;
if (Capabilities != NULL) {
Capabilities->Resolution = 1;
Capabilities->Accuracy = 50000000;
Capabilities->Accuracy = 50000000;
Capabilities->SetsToZero = FALSE;
}
@@ -514,30 +505,30 @@ SecGetTime (
EFI_STATUS
SecSetTime (
IN EFI_TIME *Time
IN EFI_TIME *Time
)
{
TIME_ZONE_INFORMATION TimeZone;
SYSTEMTIME SystemTime;
BOOL Flag;
TIME_ZONE_INFORMATION TimeZone;
SYSTEMTIME SystemTime;
BOOL Flag;
//
// Set Daylight savings time information and Time Zone
//
GetTimeZoneInformation (&TimeZone);
TimeZone.StandardDate.wMonth = Time->Daylight;
TimeZone.Bias = Time->TimeZone;
Flag = SetTimeZoneInformation (&TimeZone);
TimeZone.Bias = Time->TimeZone;
Flag = SetTimeZoneInformation (&TimeZone);
if (!Flag) {
return EFI_DEVICE_ERROR;
}
SystemTime.wYear = Time->Year;
SystemTime.wMonth = Time->Month;
SystemTime.wDay = Time->Day;
SystemTime.wHour = Time->Hour;
SystemTime.wMinute = Time->Minute;
SystemTime.wSecond = Time->Second;
SystemTime.wYear = Time->Year;
SystemTime.wMonth = Time->Month;
SystemTime.wDay = Time->Day;
SystemTime.wHour = Time->Hour;
SystemTime.wMinute = Time->Minute;
SystemTime.wSecond = Time->Second;
SystemTime.wMilliseconds = (INT16)(Time->Nanosecond / 1000000);
Flag = SetLocalTime (&SystemTime);
@@ -549,7 +540,7 @@ SecSetTime (
}
}
EMU_THUNK_PROTOCOL gEmuThunkProtocol = {
EMU_THUNK_PROTOCOL gEmuThunkProtocol = {
SecWriteStdErr,
SecConfigStdIn,
SecWriteStdOut,
@@ -574,7 +565,5 @@ EMU_THUNK_PROTOCOL gEmuThunkProtocol = {
GetNextThunkProtocol
};
#pragma warning(default : 4996)
#pragma warning(default : 4232)