# Component description file for Cpu module.\r
#\r
# This CPU module abstracts the interrupt subsystem of a platform and the CPU-specific setjump-long pair.\r
-# Copyright (c) 2006 - 2010, Intel Corporation. All rights reserved.<BR>\r
+#\r
+# Copyright (c) 2006 - 2011, Intel Corporation. All rights reserved.<BR>\r
#\r
# This program and the accompanying materials\r
# are licensed and made available under the terms and conditions of the BSD License\r
# which accompanies this distribution. The full text of the license may be found at\r
# http://opensource.org/licenses/bsd-license.php\r
+#\r
# THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,\r
# WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.\r
#\r
-#\r
##\r
\r
[Defines]\r
gEfiHiiProtocolGuid # PROTOCOL SOMETIMES_CONSUMED\r
gEfiCpuIo2ProtocolGuid # PROTOCOL ALWAYS_PRODUCED\r
gEfiCpuArchProtocolGuid # PROTOCOL ALWAYS_PRODUCED\r
- gEmuPthreadThunkProtocolGuid\r
+ gEmuThreadThunkProtocolGuid\r
gEfiMpServiceProtocolGuid\r
\r
[Pcd]\r
/*++ @file\r
\r
-Copyright (c) 2006, Intel Corporation. All rights reserved.<BR>\r
+Copyright (c) 2006 - 2011, Intel Corporation. All rights reserved.<BR>\r
Portions copyright (c) 2011, Apple Inc. All rights reserved.\r
+\r
This program and the accompanying materials \r
are licensed and made available under the terms and conditions of the BSD License \r
which accompanies this distribution. The full text of the license may be found at \r
#include <Protocol/Smbios.h>\r
#include <Protocol/FrameworkHii.h>\r
#include <Protocol/MpService.h>\r
-#include <Protocol/EmuPthreadThunk.h>\r
+#include <Protocol/EmuThread.h>\r
#include <Protocol/CpuIo2.h>\r
\r
#include <Guid/DataHubRecords.h>\r
/** @file\r
- Construct MP Services Protocol on top of pthreads. This code makes APs show up \r
- in the emulator. PcdEmuApCount is the number of APs the emulator should produce.\r
+ Construct MP Services Protocol on top of the EMU Thread protocol.\r
+ This code makes APs show up in the emulator. PcdEmuApCount is the\r
+ number of APs the emulator should produce.\r
\r
The MP Services Protocol provides a generalized way of performing following tasks:\r
- Retrieving information of multi-processor environment and MP-related status of\r
\r
\r
MP_SYSTEM_DATA gMPSystem;\r
-EMU_PTREAD_THUNK_PROTOCOL *gPthread = NULL; \r
+EMU_THREAD_THUNK_PROTOCOL *gThread = NULL; \r
EFI_EVENT gReadToBootEvent;\r
BOOLEAN gReadToBoot = FALSE;\r
UINTN gPollInterval;\r
IN VOID *ProcedureArgument\r
)\r
{\r
- gPthread->MutextLock (Processor->ProcedureLock);\r
+ gThread->MutexLock (Processor->ProcedureLock);\r
Processor->Parameter = ProcedureArgument;\r
Processor->Procedure = Procedure;\r
- gPthread->MutexUnlock (Processor->ProcedureLock);\r
+ gThread->MutexUnlock (Processor->ProcedureLock);\r
}\r
\r
\r
continue;\r
}\r
\r
- gPthread->MutextLock (Data->StateLock);\r
+ gThread->MutexLock (Data->StateLock);\r
ProcessorState = Data->State;\r
- gPthread->MutexUnlock (Data->StateLock);\r
+ gThread->MutexUnlock (Data->StateLock);\r
\r
if (ProcessorState == CPU_STATE_BLOCKED) {\r
*NextNumber = Number;\r
if (ProcessorData->State == CPU_STATE_IDLE) {\r
gMPSystem.StartCount++;\r
\r
- gPthread->MutextLock (&ProcessorData->StateLock);\r
+ gThread->MutexLock (&ProcessorData->StateLock);\r
ProcessorData->State = APInitialState;\r
- gPthread->MutexUnlock (&ProcessorData->StateLock);\r
+ gThread->MutexUnlock (&ProcessorData->StateLock);\r
\r
if (SingleThread) {\r
APInitialState = CPU_STATE_BLOCKED;\r
continue;\r
}\r
\r
- gPthread->MutextLock (ProcessorData->StateLock);\r
+ gThread->MutexLock (ProcessorData->StateLock);\r
ProcessorState = ProcessorData->State;\r
- gPthread->MutexUnlock (ProcessorData->StateLock);\r
+ gThread->MutexUnlock (ProcessorData->StateLock);\r
\r
switch (ProcessorState) {\r
case CPU_STATE_READY:\r
SetApProcedure (&gMPSystem.ProcessorData[ProcessorNumber], Procedure, ProcedureArgument);\r
\r
while (TRUE) {\r
- gPthread->MutextLock (&gMPSystem.ProcessorData[ProcessorNumber].StateLock);\r
+ gThread->MutexLock (&gMPSystem.ProcessorData[ProcessorNumber].StateLock);\r
if (gMPSystem.ProcessorData[ProcessorNumber].State == CPU_STATE_FINISHED) {\r
gMPSystem.ProcessorData[ProcessorNumber].State = CPU_STATE_IDLE;\r
- gPthread->MutexUnlock (&gMPSystem.ProcessorData[ProcessorNumber].StateLock);\r
+ gThread->MutexUnlock (&gMPSystem.ProcessorData[ProcessorNumber].StateLock);\r
break;\r
}\r
\r
- gPthread->MutexUnlock (&gMPSystem.ProcessorData[ProcessorNumber].StateLock);\r
+ gThread->MutexUnlock (&gMPSystem.ProcessorData[ProcessorNumber].StateLock);\r
\r
if ((TimeoutInMicroseconds != 0) && (Timeout < 0)) {\r
gMPSystem.WaitEvent = WaitEvent;\r
return EFI_UNSUPPORTED;\r
}\r
\r
- gPthread->MutextLock (&gMPSystem.ProcessorData[ProcessorNumber].StateLock);\r
+ gThread->MutexLock (&gMPSystem.ProcessorData[ProcessorNumber].StateLock);\r
\r
if (EnableAP) {\r
if ((gMPSystem.ProcessorData[ProcessorNumber].Info.StatusFlag & PROCESSOR_ENABLED_BIT) == 0 ) {\r
gMPSystem.ProcessorData[ProcessorNumber].Info.StatusFlag |= (*HealthFlag & PROCESSOR_HEALTH_STATUS_BIT);\r
}\r
\r
- gPthread->MutexUnlock (&gMPSystem.ProcessorData[ProcessorNumber].StateLock);\r
+ gThread->MutexUnlock (&gMPSystem.ProcessorData[ProcessorNumber].StateLock);\r
\r
return EFI_SUCCESS;\r
}\r
return EFI_INVALID_PARAMETER;\r
}\r
\r
- ProcessorId = gPthread->Self ();\r
+ ProcessorId = gThread->Self ();\r
for (Index = 0; Index < gMPSystem.NumberOfProcessors; Index++) {\r
if (gMPSystem.ProcessorData[Index].Info.ProcessorId == ProcessorId) {\r
break;\r
// context. Meaning deadlock. Which is a bad thing.\r
// So, try lock it. If we can get it, cool, do our thing.\r
// otherwise, just dump out & try again on the next iteration.\r
- Status = gPthread->MutexTryLock (gMPSystem.ProcessorData[ProcessorNumber].StateLock);\r
+ Status = gThread->MutexTryLock (gMPSystem.ProcessorData[ProcessorNumber].StateLock);\r
if (EFI_ERROR(Status)) {\r
return;\r
}\r
ProcessorState = gMPSystem.ProcessorData[ProcessorNumber].State;\r
- gPthread->MutexUnlock (gMPSystem.ProcessorData[ProcessorNumber].StateLock);\r
+ gThread->MutexUnlock (gMPSystem.ProcessorData[ProcessorNumber].StateLock);\r
\r
switch (ProcessorState) {\r
case CPU_STATE_READY:\r
if (!EFI_ERROR (Status)) {\r
NextData = &gMPSystem.ProcessorData[NextNumber];\r
\r
- gPthread->MutextLock (&NextData->ProcedureLock);\r
+ gThread->MutexLock (&NextData->ProcedureLock);\r
NextData->State = CPU_STATE_READY;\r
- gPthread->MutexUnlock (&NextData->ProcedureLock);\r
+ gThread->MutexUnlock (&NextData->ProcedureLock);\r
\r
SetApProcedure (NextData, gMPSystem.Procedure, gMPSystem.ProcedureArgument);\r
}\r
// So, try lock it. If we can get it, cool, do our thing.\r
// otherwise, just dump out & try again on the next iteration.\r
//\r
- Status = gPthread->MutexTryLock (ProcessorData->StateLock);\r
+ Status = gThread->MutexTryLock (ProcessorData->StateLock);\r
if (EFI_ERROR(Status)) {\r
return;\r
}\r
ProcessorState = ProcessorData->State;\r
- gPthread->MutexUnlock (ProcessorData->StateLock);\r
+ gThread->MutexUnlock (ProcessorData->StateLock);\r
\r
if (ProcessorState == CPU_STATE_FINISHED) {\r
Status = gBS->SetTimer (ProcessorData->CheckThisAPEvent, TimerCancel, 0);\r
Status = gBS->SignalEvent (gMPSystem.WaitEvent);\r
ASSERT_EFI_ERROR (Status);\r
\r
- gPthread->MutextLock (ProcessorData->StateLock);\r
+ gThread->MutexLock (ProcessorData->StateLock);\r
ProcessorData->State = CPU_STATE_IDLE;\r
- gPthread->MutexUnlock (ProcessorData->StateLock);\r
+ gThread->MutexUnlock (ProcessorData->StateLock);\r
}\r
\r
return ;\r
\r
ProcessorData = &gMPSystem.ProcessorData[ProcessorNumber];\r
\r
- gMPSystem.ProcessorData[ProcessorNumber].Info.ProcessorId = gPthread->Self ();\r
+ gMPSystem.ProcessorData[ProcessorNumber].Info.ProcessorId = gThread->Self ();\r
gMPSystem.ProcessorData[ProcessorNumber].Info.StatusFlag = PROCESSOR_ENABLED_BIT | PROCESSOR_HEALTH_STATUS_BIT;\r
if (BSP) {\r
gMPSystem.ProcessorData[ProcessorNumber].Info.StatusFlag |= PROCESSOR_AS_BSP_BIT;\r
\r
gMPSystem.ProcessorData[ProcessorNumber].Procedure = NULL;\r
gMPSystem.ProcessorData[ProcessorNumber].Parameter = NULL;\r
- gMPSystem.ProcessorData[ProcessorNumber].StateLock = gPthread->MutexInit ();\r
- gMPSystem.ProcessorData[ProcessorNumber].ProcedureLock = gPthread->MutexInit ();\r
+ gMPSystem.ProcessorData[ProcessorNumber].StateLock = gThread->MutexInit ();\r
+ gMPSystem.ProcessorData[ProcessorNumber].ProcedureLock = gThread->MutexInit ();\r
\r
return EFI_SUCCESS;\r
}\r
ProcessorNumber = (UINTN)Context;\r
ProcessorData = &gMPSystem.ProcessorData[ProcessorNumber];\r
\r
- ProcessorData->Info.ProcessorId = gPthread->Self ();\r
+ ProcessorData->Info.ProcessorId = gThread->Self ();\r
\r
while (TRUE) {\r
//\r
// Make a local copy on the stack to be extra safe\r
//\r
- gPthread->MutextLock (ProcessorData->ProcedureLock);\r
+ gThread->MutexLock (ProcessorData->ProcedureLock);\r
Procedure = ProcessorData->Procedure;\r
Parameter = ProcessorData->Parameter;\r
- gPthread->MutexUnlock (ProcessorData->ProcedureLock);\r
+ gThread->MutexUnlock (ProcessorData->ProcedureLock);\r
\r
if (Procedure != NULL) {\r
- gPthread->MutextLock (ProcessorData->StateLock);\r
+ gThread->MutexLock (ProcessorData->StateLock);\r
ProcessorData->State = CPU_STATE_BUSY;\r
- gPthread->MutexUnlock (ProcessorData->StateLock);\r
+ gThread->MutexUnlock (ProcessorData->StateLock);\r
\r
Procedure (Parameter);\r
\r
- gPthread->MutextLock (ProcessorData->ProcedureLock);\r
+ gThread->MutexLock (ProcessorData->ProcedureLock);\r
ProcessorData->Procedure = NULL;\r
- gPthread->MutexUnlock (ProcessorData->ProcedureLock);\r
+ gThread->MutexUnlock (ProcessorData->ProcedureLock);\r
\r
- gPthread->MutextLock (ProcessorData->StateLock);\r
+ gThread->MutexLock (ProcessorData->StateLock);\r
ProcessorData->State = CPU_STATE_FINISHED;\r
- gPthread->MutexUnlock (ProcessorData->StateLock); \r
+ gThread->MutexUnlock (ProcessorData->StateLock); \r
}\r
\r
// Poll 5 times a seconds, 200ms\r
\r
FillInProcessorInformation (FALSE, Index);\r
\r
- Status = gPthread->CreateThread (\r
+ Status = gThread->CreateThread (\r
(VOID *)&gMPSystem.ProcessorData[Index].Info.ProcessorId, \r
NULL,\r
CpuDriverApIdolLoop,\r
\r
MaxCpus = 1; // BSP\r
\r
- IoThunk = GetIoThunkInstance (&gEmuPthreadThunkProtocolGuid, 0);\r
+ IoThunk = GetIoThunkInstance (&gEmuThreadThunkProtocolGuid, 0);\r
if (IoThunk != NULL) {\r
Status = IoThunk->Open (IoThunk);\r
if (!EFI_ERROR (Status)) {\r
if (IoThunk->ConfigString != NULL) {\r
MaxCpus += StrDecimalToUintn (IoThunk->ConfigString);\r
- gPthread = IoThunk->Interface;\r
+ gThread = IoThunk->Interface;\r
}\r
}\r
}\r
#\r
# This is the Emu Emulation Environment Platform\r
#\r
-# Copyright (c) 2008 - 2010, Intel Corporation. All rights reserved.<BR>\r
+# Copyright (c) 2008 - 2011, Intel Corporation. All rights reserved.<BR>\r
# Portions copyright (c) 2011, Apple Inc. All rights reserved. \r
#\r
# This program and the accompanying materials are licensed and made available \r
gEmuThunkProtocolGuid = { 0x398DCA31, 0x3505, 0xDB47, { 0xBD, 0x93, 0x1D, 0x38, 0x5F, 0x79, 0x13, 0x15 } }\r
gEmuIoThunkProtocolGuid = { 0x453368F6, 0x7C85, 0x434A, { 0xA9, 0x8A, 0x72, 0xD1, 0xB7, 0xFF, 0xA9, 0x26 } }\r
gEmuGraphicsWindowProtocolGuid = { 0x30FD316A, 0x6728, 0x2E41, { 0xA6, 0x90, 0x0D, 0x13, 0x33, 0xD8, 0xCA, 0xC1 } }\r
- gEmuPthreadThunkProtocolGuid = { 0x3B1E4B7C, 0x09D8, 0x944F, { 0xA4, 0x08, 0x13, 0x09, 0xEB, 0x8B, 0x44, 0x27 } }\r
+ gEmuThreadThunkProtocolGuid = { 0x3B1E4B7C, 0x09D8, 0x944F, { 0xA4, 0x08, 0x13, 0x09, 0xEB, 0x8B, 0x44, 0x27 } }\r
\r
[Ppis]\r
gEmuThunkPpiGuid = { 0xE113F896, 0x75CF, 0xF640, { 0x81, 0x7F, 0xC8, 0x5A, 0x79, 0xE8, 0xAE, 0x67 } }\r
+++ /dev/null
-/** @file\r
- Emulator Thunk to abstract OS services from pure EFI code\r
-\r
- Copyright (c) 2010 - 2011, Apple Inc. All rights reserved.<BR>\r
- Copyright (c) 2011, Intel Corporation. All rights reserved.<BR>\r
-\r
- This program and the accompanying materials\r
- are licensed and made available under the terms and conditions of the BSD License\r
- which accompanies this distribution. The full text of the license may be found at\r
- http://opensource.org/licenses/bsd-license.php\r
-\r
- THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,\r
- WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.\r
-\r
-**/\r
-\r
-#ifndef __EMU_PTHREAD_THUNK__ \r
-#define __EMU_PTHREAD_THUNK__\r
-\r
-#define EMU_PTHREAD_THUNK_PROTOCO_GUID \\r
- { 0x3B1E4B7C, 0x09D8, 0x944F, { 0xA4, 0x08, 0x13, 0x09, 0xEB, 0x8B, 0x44, 0x27 } }\r
-\r
-\r
-typedef struct _EMU_PTREAD_THUNK_PROTOCOL EMU_PTREAD_THUNK_PROTOCOL;\r
-\r
-\r
-typedef \r
-UINTN\r
-(EFIAPI *PTREAD_THUNK_MUTEXT_LOCK) (\r
- IN VOID *Mutex\r
- ); \r
-\r
-\r
-typedef \r
-UINTN\r
-(EFIAPI *PTREAD_THUNK_MUTEXT_UNLOCK) (\r
- IN VOID *Mutex\r
- ); \r
-\r
-\r
-typedef \r
-UINTN\r
-(EFIAPI *PTREAD_THUNK_MUTEX_TRY_LOCK) (\r
- IN VOID *Mutex\r
- ); \r
-\r
-\r
-typedef \r
-VOID *\r
-(EFIAPI *PTREAD_THUNK_MUTEX_INIT) (\r
- IN VOID\r
- ); \r
-\r
-\r
-typedef \r
-UINTN\r
-(EFIAPI *PTREAD_THUNK_MUTEX_DISTROY) (\r
- IN VOID *Mutex\r
- ); \r
-\r
-\r
-\r
-typedef \r
-VOID *\r
-(EFIAPI *PTREAD_THUNK_THEAD_ENTRY) (\r
- IN VOID *Context\r
- );\r
-\r
-typedef \r
-UINTN\r
-(EFIAPI *PTREAD_THUNK_CREATE_THREAD) (\r
- IN VOID *Thread,\r
- IN VOID *Attribute,\r
- IN PTREAD_THUNK_THEAD_ENTRY Start,\r
- IN VOID *Context\r
- );\r
-\r
-typedef \r
-VOID\r
-(EFIAPI *PTREAD_THUNK_EXIT_THREAD) (\r
- IN VOID *ValuePtr\r
- ); \r
-\r
- \r
-typedef \r
-UINTN\r
-(EFIAPI *PTREAD_THUNK_SELF) (\r
- VOID\r
- ); \r
-\r
-\r
-struct _EMU_PTREAD_THUNK_PROTOCOL {\r
- PTREAD_THUNK_MUTEXT_LOCK MutextLock;\r
- PTREAD_THUNK_MUTEXT_UNLOCK MutexUnlock;\r
- PTREAD_THUNK_MUTEX_TRY_LOCK MutexTryLock;\r
- PTREAD_THUNK_MUTEX_INIT MutexInit;\r
- PTREAD_THUNK_MUTEX_DISTROY MutexDistroy;\r
- PTREAD_THUNK_CREATE_THREAD CreateThread;\r
- PTREAD_THUNK_EXIT_THREAD ExitThread;\r
- PTREAD_THUNK_SELF Self;\r
-};\r
-\r
-extern EFI_GUID gEmuPthreadThunkProtocolGuid;\r
-\r
-#endif\r
-\r
--- /dev/null
+/** @file\r
+ Emulator Thunk to abstract OS services from pure EFI code\r
+\r
+ Copyright (c) 2010 - 2011, Apple Inc. All rights reserved.<BR>\r
+ Copyright (c) 2011, Intel Corporation. All rights reserved.<BR>\r
+\r
+ This program and the accompanying materials\r
+ are licensed and made available under the terms and conditions of the BSD License\r
+ which accompanies this distribution. The full text of the license may be found at\r
+ http://opensource.org/licenses/bsd-license.php\r
+\r
+ THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,\r
+ WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.\r
+\r
+**/\r
+\r
+#ifndef __EMU_THREAD_THUNK__\r
+#define __EMU_THREAD_THUNK__\r
+\r
+\r
+typedef struct _EMU_THREAD_THUNK_PROTOCOL EMU_THREAD_THUNK_PROTOCOL;\r
+\r
+\r
+typedef\r
+UINTN\r
+(EFIAPI *THREAD_THUNK_MUTEX_LOCK) (\r
+ IN VOID *Mutex\r
+ );\r
+\r
+\r
+typedef\r
+UINTN\r
+(EFIAPI *THREAD_THUNK_MUTEX_UNLOCK) (\r
+ IN VOID *Mutex\r
+ );\r
+\r
+\r
+typedef\r
+UINTN\r
+(EFIAPI *THREAD_THUNK_MUTEX_TRY_LOCK) (\r
+ IN VOID *Mutex\r
+ );\r
+\r
+\r
+typedef\r
+VOID *\r
+(EFIAPI *THREAD_THUNK_MUTEX_INIT) (\r
+ IN VOID\r
+ );\r
+\r
+\r
+typedef\r
+UINTN\r
+(EFIAPI *THREAD_THUNK_MUTEX_DISTROY) (\r
+ IN VOID *Mutex\r
+ );\r
+\r
+\r
+\r
+typedef\r
+VOID *\r
+(EFIAPI *THREAD_THUNK_THREAD_ENTRY) (\r
+ IN VOID *Context\r
+ );\r
+\r
+typedef\r
+UINTN\r
+(EFIAPI *THREAD_THUNK_CREATE_THREAD) (\r
+ IN VOID *Thread,\r
+ IN VOID *Attribute,\r
+ IN THREAD_THUNK_THREAD_ENTRY Start,\r
+ IN VOID *Context\r
+ );\r
+\r
+typedef\r
+VOID\r
+(EFIAPI *THREAD_THUNK_EXIT_THREAD) (\r
+ IN VOID *ValuePtr\r
+ );\r
+\r
+\r
+typedef\r
+UINTN\r
+(EFIAPI *THREAD_THUNK_SELF) (\r
+ VOID\r
+ );\r
+\r
+\r
+struct _EMU_THREAD_THUNK_PROTOCOL {\r
+ THREAD_THUNK_MUTEX_LOCK MutexLock;\r
+ THREAD_THUNK_MUTEX_UNLOCK MutexUnlock;\r
+ THREAD_THUNK_MUTEX_TRY_LOCK MutexTryLock;\r
+ THREAD_THUNK_MUTEX_INIT MutexInit;\r
+ THREAD_THUNK_MUTEX_DISTROY MutexDistroy;\r
+ THREAD_THUNK_CREATE_THREAD CreateThread;\r
+ THREAD_THUNK_EXIT_THREAD ExitThread;\r
+ THREAD_THUNK_SELF Self;\r
+};\r
+\r
+extern EFI_GUID gEmuThreadThunkProtocolGuid;\r
+\r
+#endif\r
+\r
/** @file\r
\r
Copyright (c) 2008 - 2011, Apple Inc. All rights reserved.<BR>\r
+ Copyright (c) 2011, Intel Corporation. All rights reserved.<BR>\r
\r
This program and the accompanying materials\r
are licensed and made available under the terms and conditions of the BSD License\r
GasketPthreadCreate (\r
IN VOID *Thread,\r
IN VOID *Attribute,\r
- IN PTREAD_THUNK_THEAD_ENTRY Start,\r
+ IN THREAD_THUNK_THREAD_ENTRY Start,\r
IN VOID *Context\r
);\r
\r
POSIX Pthreads to emulate APs and implement threads
Copyright (c) 2011, Apple Inc. All rights reserved.
+Copyright (c) 2011, Intel Corporation. All rights reserved.<BR>
+
This program and the accompanying materials
are licensed and made available under the terms and conditions of the BSD License
which accompanies this distribution. The full text of the license may be found at
// Can't store this data on PthreadCreate stack so we need a global
typedef struct {
pthread_mutex_t Mutex;
- PTREAD_THUNK_THEAD_ENTRY Start;
+ THREAD_THUNK_THREAD_ENTRY Start;
} THREAD_MANGLE;
THREAD_MANGLE mThreadMangle = {
VOID *Context
)
{
- PTREAD_THUNK_THEAD_ENTRY Start;
+ THREAD_THUNK_THREAD_ENTRY Start;
sigset_t SigMask;
// Save global on the stack before we unlock
PthreadCreate (
IN VOID *Thread,
IN VOID *Attribute,
- IN PTREAD_THUNK_THEAD_ENTRY Start,
+ IN THREAD_THUNK_THREAD_ENTRY Start,
IN VOID *Context
)
{
}
-EMU_PTREAD_THUNK_PROTOCOL gPthreadThunk = {
+EMU_THREAD_THUNK_PROTOCOL gPthreadThunk = {
GasketPthreadMutexLock,
GasketPthreadMutexUnLock,
GasketPthreadMutexTryLock,
EMU_IO_THUNK_PROTOCOL gPthreadThunkIo = {
- &gEmuPthreadThunkProtocolGuid,
+ &gEmuThreadThunkProtocolGuid,
NULL,
NULL,
0,
/*++ @file\r
\r
-Copyright (c) 2006 - 2010, Intel Corporation. All rights reserved.<BR>\r
+Copyright (c) 2006 - 2011, Intel Corporation. All rights reserved.<BR>\r
Portions copyright (c) 2008 - 2011, Apple Inc. All rights reserved.<BR>\r
-This program and the accompanying materials \r
-are licensed and made available under the terms and conditions of the BSD License \r
-which accompanies this distribution. The full text of the license may be found at \r
-http://opensource.org/licenses/bsd-license.php \r
- \r
-THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS, \r
-WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED. \r
+\r
+This program and the accompanying materials\r
+are licensed and made available under the terms and conditions of the BSD License\r
+which accompanies this distribution. The full text of the license may be found at\r
+http://opensource.org/licenses/bsd-license.php\r
+\r
+THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,\r
+WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.\r
\r
**/\r
\r
#include <Protocol/EmuThunk.h>\r
#include <Protocol/EmuIoThunk.h>\r
#include <Protocol/EmuGraphicsWindow.h>\r
-#include <Protocol/EmuPthreadThunk.h>\r
+#include <Protocol/EmuThread.h>\r
\r
#include <Guid/FileInfo.h>\r
#include <Guid/FileSystemInfo.h>\r
gEmuIoThunkProtocolGuid\r
gEmuIoThunkProtocolGuid\r
gEmuGraphicsWindowProtocolGuid\r
- gEmuPthreadThunkProtocolGuid\r
+ gEmuThreadThunkProtocolGuid\r
gEfiSimpleFileSystemProtocolGuid\r
\r
\r
projects / mirror_edk2.git / commitdiff