{

size_t stack = pthread_get_stacksize_np(thread);

// osx 10.9(+ ?) pthread_get_stacksize_np bug

if (pthread_main_np())

{

#ifndef __IOS__

// https://developer.apple.com/library/mac/documentation/Cocoa/Conceptual/Multithreading/CreatingThreads/CreatingThreads.html

stack = max(8 * 1024 * 1024, stack);

#else

pthread_attr_t pat;

pthread_attr_init(&pat);

size_t gs = 0;

pthread_attr_getguardsize(&pat, &gs);

stack = max((1024 * 1024) - gs, stack);

#endif

}

*highLimit = (ULONG_PTR)pthread_get_stackaddr_np(thread);

stack = *highLimit - stack;

*lowLimit = ((stack + (EXPECTED_ALIGNMENT - 1)) & ~(EXPECTED_ALIGNMENT - 1));

CPalThread *pThread,

IPalObject *pObjectToCleanup,

bool fShutdown,

bool fCleanupSharedState

CPalThread *pThread,

CObjectType *pObjectType,

void *pImmutableData,

void *pSharedData,

void *pProcessLocalData

{

CPalThread *pThread = (CPalThread *) arg;

// When pthread_exit calls us, it has already removed the PAL thread

// from TLS. Since InternalEndCurrentThread calls functions that assert

// that the current thread is known to this PAL, and that pThread

// actually is the current PAL thread, put it back in TLS temporarily.

pthread_setspecific(thObjKey, pThread);

(void)PAL_Enter(PAL_BoundaryTop);

/* Call entry point functions of every attached modules to

/* note : no need to enter a critical section for serialization, the loader

LOADCallDllMain(DLL_THREAD_DETACH, NULL);

// PAL_Leave will be called just before we release the thread reference

// in InternalEndCurrentThread.

InternalEndCurrentThread(pThread);

pthread_setspecific(thObjKey, NULL);

{

/* Create the pthread key for thread objects, which we use

if (pthread_key_create(&thObjKey, InternalEndCurrentThreadWrapper))

{

ERROR("Couldn't create the thread object key\n");

return FALSE;

}

SPINLOCKInit(&free_threads_spinlock);

return TRUE;

{

//

// Run the destructors for this object

//

pThread->~CPalThread();

#ifdef _DEBUG

// Fill value so we can find code re-using threads after they're dead. We

// check against pThread->dwGuard when getting the current thread's data.

memset((void*)pThread, 0xcc, sizeof(*pThread));

#endif

// We SHOULD be doing the following, but it causes massive problems. See the

// comment below.

//pthread_setspecific(thObjKey, NULL); // Make sure any TLS entry is removed.

//

// Never actually free the THREAD structure to make the TLS lookaside cache work.

// THREAD* for terminated thread can be stuck in the lookaside cache code for an

// arbitrary amount of time. The unused THREAD* structures has to remain in a

// valid memory and thus can't be returned to the heap.

//

// TODO: is this really true? Why would the entry remain in the cache for

// an indefinite period of time after we've flushed it?

//

/* NOTE: can't use a CRITICAL_SECTION here: EnterCriticalSection(&cs,TRUE) and

/* Get the lock */

SPINLOCKAcquire(&free_threads_spinlock, 0);

pThread->SetNext(free_threads_list);

free_threads_list = pThread;

/* Release the lock */

SPINLOCKRelease(&free_threads_spinlock);

HANDLE hThread

// UNIXTODO Should take pThread parameter here (modify callers)

)

{

CPalThread *pThread;

CPalThread *pTargetThread;

IPalObject *pobjThread = NULL;

PAL_ERROR palError = NO_ERROR;

DWORD dwProcessId = 0;

pThread = InternalGetCurrentThread();

palError = InternalGetThreadDataFromHandle(

pThread,

hThread,

0,

&pTargetThread,

&pobjThread

);

if (NO_ERROR != palError)

{

if (!pThread->IsDummy())

{

dwProcessId = GetCurrentProcessId();

}

else

{

ASSERT("Dummy thread passed to THREADGetProcessId\n");

}

if (NULL != pobjThread)

{

pobjThread->ReleaseReference(pThread);

}

}

else

{

ERROR("Couldn't retreive the hThread:%p pid owner !\n", hThread);

}

return dwProcessId;

HANDLE hThread

// UNIXTODO Should take pThread parameter here (modify callers)

)

{

DWORD dwThreadId = 0;

CPalThread *pThread;

PAL_ERROR palError = NO_ERROR;

IPalObject *pobjThread = 0;

// TODO: not sure if this could be done in a more efficient way.

PERF_ENTRY(GetThreadId);

ENTRY("GetThreadId()\n");

pThread = InternalGetCurrentThread();

palError = InternalGetThreadDataFromHandle(

pThread,

hThread,

0,

0,

&pobjThread

);

if (NO_ERROR != palError)

{

dwThreadId = (DWORD)pThread->GetThreadId();

}

if (NULL != pobjThread)

{

pobjThread->ReleaseReference(pThread);

}

LOGEXIT("GetThreadId returns DWORD %#x\n", dwThreadId);

PERF_EXIT(GetThreadId);

return dwThreadId;

VOID)

{

DWORD dwThreadId;

PERF_ENTRY(GetCurrentThreadId);

ENTRY("GetCurrentThreadId()\n");

//

// TODO: should do perf test to see how this compares

// with calling InternalGetCurrentThread (i.e., is our lookaside

// cache faster on average than pthread_self?)

//

dwThreadId = (DWORD)THREADSilentGetCurrentThreadId();

LOGEXIT("GetCurrentThreadId returns DWORD %#x\n", dwThreadId);

PERF_EXIT(GetCurrentThreadId);

return dwThreadId;

VOID)

{

PERF_ENTRY(GetCurrentThread);

ENTRY("GetCurrentThread()\n");

LOGEXIT("GetCurrentThread returns HANDLE %p\n", hPseudoCurrentThread);

PERF_EXIT(GetCurrentThread);

/* return a pseudo handle */

return (HANDLE) hPseudoCurrentThread;

VOID)

{

BOOL ret;

PERF_ENTRY(SwitchToThread);

ENTRY("SwitchToThread(VOID)\n");

/* sched_yield yields to another thread in the current process. This implementation

ret = (sched_yield() == 0);

LOGEXIT("SwitchToThread returns BOOL %d\n", ret);

PERF_EXIT(SwitchToThread);

return ret;

IN LPSECURITY_ATTRIBUTES lpThreadAttributes,

IN DWORD dwStackSize,

IN LPTHREAD_START_ROUTINE lpStartAddress,

IN LPVOID lpParameter,

IN DWORD dwCreationFlags,

OUT LPDWORD lpThreadId)

{

PAL_ERROR palError;

CPalThread *pThread;

HANDLE hNewThread = NULL;

PERF_ENTRY(CreateThread);

ENTRY("CreateThread(lpThreadAttr=%p, dwStackSize=%u, lpStartAddress=%p, "

"lpParameter=%p, dwFlags=%#x, lpThreadId=%#x)\n",

lpThreadAttributes, dwStackSize, lpStartAddress, lpParameter,

dwCreationFlags, lpThreadId);

pThread = InternalGetCurrentThread();

palError = InternalCreateThread(

pThread,

lpThreadAttributes,

dwStackSize,

lpStartAddress,

lpParameter,

dwCreationFlags,

UserCreatedThread,

lpThreadId,

&hNewThread

);

if (NO_ERROR != palError)

{

pThread->SetLastError(palError);

}

LOGEXIT("CreateThread returns HANDLE %p\n", hNewThread);

PERF_EXIT(CreateThread);

return hNewThread;

CPalThread *pThread,

LPSECURITY_ATTRIBUTES lpThreadAttributes,

DWORD dwStackSize,

LPTHREAD_START_ROUTINE lpStartAddress,

LPVOID lpParameter,

DWORD dwCreationFlags,

PalThreadType eThreadType,

LPDWORD lpThreadId,

HANDLE *phThread

)

{

PAL_ERROR palError;

CPalThread *pNewThread = NULL;

CObjectAttributes oa;

bool fAttributesInitialized = FALSE;

bool fThreadDataAddedToProcessList = FALSE;

HANDLE hNewThread = NULL;

pthread_t pthread;

pthread_attr_t pthreadAttr;

size_t pthreadStackSize;

#if PTHREAD_CREATE_MODIFIES_ERRNO

int storedErrno;

#endif // PTHREAD_CREATE_MODIFIES_ERRNO

BOOL fHoldingProcessLock = FALSE;

int iError = 0;

if (0 != terminator)

{

//

// Since the PAL is in the middle of shutting down we don't want to

// create any new threads (since it's possible for that new thread

// to create another thread before the shutdown thread gets around

// to suspending it, and so on). We don't want to return an error

// here, though, as some programs (in particular, build) do not

// handle CreateThread errors properly -- instead, we just put

// the calling thread to sleep (unless it is the shutdown thread,

// which could occur if a DllMain PROCESS_DETACH handler tried to

// create a new thread for some odd reason).

//

ERROR("process is terminating, can't create new thread.\n");

if (pThread->GetThreadId() != static_cast<DWORD>(terminator))

{

while (true)

{

poll(NULL, 0, INFTIM);

sched_yield();

}

}

else

{

//

// This is the shutdown thread, so just return an error

//

palError = ERROR_PROCESS_ABORTED;

goto EXIT;

}

}

/* Validate parameters */

if (lpThreadAttributes != NULL)

{

ASSERT("lpThreadAttributes parameter must be NULL (%p)\n",

lpThreadAttributes);

palError = ERROR_INVALID_PARAMETER;

goto EXIT;

}

// Ignore the STACK_SIZE_PARAM_IS_A_RESERVATION flag

dwCreationFlags &= ~STACK_SIZE_PARAM_IS_A_RESERVATION;

if ((dwCreationFlags != 0) && (dwCreationFlags != CREATE_SUSPENDED))

{

ASSERT("dwCreationFlags parameter is invalid (%#x)\n", dwCreationFlags);

palError = ERROR_INVALID_PARAMETER;

goto EXIT;

}

//

// Create the CPalThread for the thread

//

pNewThread = AllocTHREAD();

if (NULL == pNewThread)

{

palError = ERROR_OUTOFMEMORY;

goto EXIT;

}

palError = pNewThread->RunPreCreateInitializers();

if (NO_ERROR != palError)

{

goto EXIT;

}

pNewThread->m_lpStartAddress = lpStartAddress;

pNewThread->m_lpStartParameter = lpParameter;

pNewThread->m_bCreateSuspended = (dwCreationFlags & CREATE_SUSPENDED) == CREATE_SUSPENDED;

pNewThread->m_eThreadType = eThreadType;

if (0 != pthread_attr_init(&pthreadAttr))

{

ERROR("couldn't initialize pthread attributes\n");

palError = ERROR_INTERNAL_ERROR;

goto EXIT;

}

fAttributesInitialized = TRUE;

/* adjust the stack size if necessary */

if (0 != pthread_attr_getstacksize(&pthreadAttr, &pthreadStackSize))

{

ERROR("couldn't set thread stack size\n");

palError = ERROR_INTERNAL_ERROR;

goto EXIT;

}

TRACE("default pthread stack size is %d, caller requested %d (default is %d)\n",

pthreadStackSize, dwStackSize, CPalThread::s_dwDefaultThreadStackSize);

if (0 == dwStackSize)

{

dwStackSize = CPalThread::s_dwDefaultThreadStackSize;

}

if (PTHREAD_STACK_MIN > pthreadStackSize)

{

WARN("default stack size is reported as %d, but PTHREAD_STACK_MIN is "

"%d\n", pthreadStackSize, PTHREAD_STACK_MIN);

}

if (pthreadStackSize < dwStackSize)

{

TRACE("setting thread stack size to %d\n", dwStackSize);

if (0 != pthread_attr_setstacksize(&pthreadAttr, dwStackSize))

{

ERROR("couldn't set pthread stack size to %d\n", dwStackSize);

palError = ERROR_INTERNAL_ERROR;

goto EXIT;

}

}

else

{

TRACE("using the system default thread stack size of %d\n", pthreadStackSize);

}

#if HAVE_THREAD_SELF || HAVE__LWP_SELF

/* Create new threads as "bound", so each pthread is permanently bound

pthread_attr_setscope(&pthreadAttr, PTHREAD_SCOPE_SYSTEM);

#endif // HAVE_THREAD_SELF || HAVE__LWP_SELF

//

// We never call pthread_join, so create the new thread as detached

//

iError = pthread_attr_setdetachstate(&pthreadAttr, PTHREAD_CREATE_DETACHED);

_ASSERTE(0 == iError);

//

// Create the IPalObject for the thread and store it in the object

//

palError = CreateThreadObject(

pThread,

pNewThread,

&hNewThread);

if (NO_ERROR != palError)

{

goto EXIT;

}

//

// Add the thread to the process list

//

//

// We use the process lock to ensure that we're not interrupted

// during the creation process. After adding the CPalThread reference

// to the process list, we want to make sure the actual thread has been

// started. Otherwise, there's a window where the thread can be found

// in the process list but doesn't yet exist in the system.

//

PROCProcessLock();

fHoldingProcessLock = TRUE;

PROCAddThread(pThread, pNewThread);

fThreadDataAddedToProcessList = TRUE;

//

// Spawn the new pthread

//

#if PTHREAD_CREATE_MODIFIES_ERRNO

storedErrno = errno;

#endif // PTHREAD_CREATE_MODIFIES_ERRNO

#ifdef FEATURE_PAL_SXS

_ASSERT_MSG(pNewThread->IsInPal(), "New threads we're about to spawn should always be in the PAL.\n");

#endif // FEATURE_PAL_SXS

iError = pthread_create(&pthread, &pthreadAttr, CPalThread::ThreadEntry, pNewThread);

#if PTHREAD_CREATE_MODIFIES_ERRNO

if (iError == 0)

{

// Restore errno if pthread_create succeeded.

errno = storedErrno;

}

#endif // PTHREAD_CREATE_MODIFIES_ERRNO

if (0 != iError)

{

ERROR("pthread_create failed, error is %d (%s)\n", iError, strerror(iError));

palError = ERROR_NOT_ENOUGH_MEMORY;

goto EXIT;

}

//

// Wait for the new thread to finish its initial startup tasks

// (i.e., the ones that might fail)

//

if (pNewThread->WaitForStartStatus())

{

//

// Everything succeeded. Store the handle for the new thread and

// the thread's ID in the out params

//

*phThread = hNewThread;

if (NULL != lpThreadId)

{

*lpThreadId = pNewThread->GetThreadId();

}

}

else

{

ERROR("error occurred in THREADEntry, thread creation failed.\n");

palError = ERROR_INTERNAL_ERROR;

goto EXIT;

}

//

// If we're here, then we've locked the process list and both pthread_create

// and WaitForStartStatus succeeded. Thus, we can now unlock the process list.

// Since palError == NO_ERROR, we won't call this again in the exit block.

//

PROCProcessUnlock();

fHoldingProcessLock = FALSE;

EXIT:

if (fAttributesInitialized)

{

if (0 != pthread_attr_destroy(&pthreadAttr))

{

WARN("pthread_attr_destroy() failed\n");

}

}

if (NO_ERROR != palError)

{

//

// We either were not able to create the new thread, or a failure

// occurred in the new thread's entry routine. Free up the associated

// resources here

//

if (fThreadDataAddedToProcessList)

{

PROCRemoveThread(pThread, pNewThread);

}

//

// Once we remove the thread from the process list, we can call

// PROCProcessUnlock.

//

if (fHoldingProcessLock)

{

PROCProcessUnlock();

}

fHoldingProcessLock = FALSE;

}

_ASSERT_MSG(!fHoldingProcessLock, "Exiting InternalCreateThread while still holding the process critical section.\n");

return palError;

IN DWORD dwExitCode)

{

CPalThread *pThread;

ENTRY("ExitThread(dwExitCode=%u)\n", dwExitCode);

PERF_ENTRY_ONLY(ExitThread);

pThread = InternalGetCurrentThread();

/* store the exit code */

pThread->SetExitCode(dwExitCode);

/* pthread_exit runs TLS destructors and cleanup routines,

PAL_Leave(PAL_BoundaryTop);

/* kill the thread (itself), resulting in a call to InternalEndCurrentThread */

pthread_exit(NULL);

ASSERT("pthread_exit should not return!\n");

for (;;);

IN HANDLE hThread,

IN LPDWORD lpExitCode)

{

PAL_ERROR palError = NO_ERROR;

CPalThread *pthrCurrent = NULL;

CPalThread *pthrTarget = NULL;

IPalObject *pobjThread = NULL;

BOOL fExitCodeSet;

PERF_ENTRY(GetExitCodeThread);

ENTRY("GetExitCodeThread(hThread = %p, lpExitCode = %p)\n",

hThread, lpExitCode);

if (NULL == lpExitCode)

{

WARN("Got NULL lpExitCode\n");

palError = ERROR_INVALID_PARAMETER;

goto done;

}

pthrCurrent = InternalGetCurrentThread();

palError = InternalGetThreadDataFromHandle(

pthrCurrent,

hThread,

0,

&pthrTarget,

&pobjThread

);

pthrTarget->Lock(pthrCurrent);

fExitCodeSet = pthrTarget->GetExitCode(lpExitCode);

if (!fExitCodeSet)

{

if (TS_DONE == pthrTarget->synchronizationInfo.GetThreadState())

{

#ifdef FEATURE_PAL_SXS

// The thread exited without ever calling ExitThread.

// It must have wandered in.

*lpExitCode = 0;

#else // FEATURE_PAL_SXS

ASSERT("exit code not set but thread is dead\n");

#endif // FEATURE_PAL_SXS

}

else

{

*lpExitCode = STILL_ACTIVE;

}

}

pthrTarget->Unlock(pthrCurrent);

done:

if (NULL != pobjThread)

{

pobjThread->ReleaseReference(pthrCurrent);

}

LOGEXIT("GetExitCodeThread returns BOOL %d\n", NO_ERROR == palError);

PERF_EXIT(GetExitCodeThread);

return NO_ERROR == palError;

CPalThread *pThread

)

{

PAL_ERROR palError = NO_ERROR;

ISynchStateController *pSynchStateController = NULL;

#ifdef PAL_PERF

PERFDisableThreadProfile(UserCreatedThread != pThread->GetThreadType());

#endif

//

// Abandon any objects owned by this thread

//

palError = g_pSynchronizationManager->AbandonObjectsOwnedByThread(

pThread,

pThread

);

if (NO_ERROR != palError)

{

ERROR("Failure abandoning owned objects");

}

//

// Need to synchronize setting the thread state to TS_DONE since

// this is checked for in InternalSuspendThreadFromData.

// TODO: Is this still needed after removing InternalSuspendThreadFromData?

//

pThread->suspensionInfo.AcquireSuspensionLock(pThread);

IncrementEndingThreadCount();

pThread->synchronizationInfo.SetThreadState(TS_DONE);

pThread->suspensionInfo.ReleaseSuspensionLock(pThread);

//

// Mark the thread object as signaled