//

// Copyright (c) Microsoft. All rights reserved.

// Licensed under the MIT license. See LICENSE file in the project root for full license information.

//

/*++

Module Name:

process.cpp

Abstract:

Implementation of process object and functions related to processes.

--*/

#include "pal/procobj.hpp"

#include "pal/thread.hpp"

#include "pal/file.hpp"

#include "pal/handlemgr.hpp"

#include "pal/module.h"

#include "procprivate.hpp"

#include "pal/palinternal.h"

#include "pal/process.h"

#include "pal/init.h"

#include "pal/critsect.h"

#include "pal/dbgmsg.h"

#include "pal/utils.h"

#include "pal/misc.h"

#include "pal/virtual.h"

#include "pal/stackstring.hpp"

#include <errno.h>

#if HAVE_POLL

#include <poll.h>

#else

#include "pal/fakepoll.h"

#endif // HAVE_POLL

#include <sys/mman.h>

#include <sys/types.h>

#include <signal.h>

#include <sys/wait.h>

#include <sys/time.h>

#include <sys/resource.h>

#include <debugmacrosext.h>

using namespace CorUnix;

SET_DEFAULT_DEBUG_CHANNEL(THREAD);

void

ProcessCleanupRoutine(

CPalThread *pThread,

IPalObject *pObjectToCleanup,

bool fShutdown,

bool fCleanupSharedState

);

PAL_ERROR

ProcessInitializationRoutine(

CPalThread *pThread,

CObjectType *pObjectType,

void *pImmutableData,

void *pSharedData,

void *pProcessLocalData

);

CObjectType CorUnix::otProcess PAL_GLOBAL (

otiProcess,

ProcessCleanupRoutine,

ProcessInitializationRoutine,

0,

sizeof(CProcProcessLocalData),

sizeof(CProcSharedData),

PROCESS_ALL_ACCESS,

CObjectType::SecuritySupported,

CObjectType::SecurityInfoNotPersisted,

CObjectType::UnnamedObject,

CObjectType::CrossProcessDuplicationAllowed,

CObjectType::WaitableObject,

CObjectType::SingleTransitionObject,

CObjectType::ThreadReleaseHasNoSideEffects,

CObjectType::NoOwner

);

//

// Helper memory page used by the FlushProcessWriteBuffers

//

static int s_helperPage[VIRTUAL_PAGE_SIZE / sizeof(int)] __attribute__((aligned(VIRTUAL_PAGE_SIZE)));

//

// Mutex to make the FlushProcessWriteBuffersMutex thread safe

//

pthread_mutex_t flushProcessWriteBuffersMutex PAL_GLOBAL;

CAllowedObjectTypes aotProcess PAL_GLOBAL (otiProcess);

//

// The representative IPalObject for this process

//

IPalObject* CorUnix::g_pobjProcess;

//

// Critical section that protects process data (e.g., the

// list of active threads)/

//

CRITICAL_SECTION g_csProcess PAL_GLOBAL;

//

// List and count of active threads

//

CPalThread* CorUnix::pGThreadList;

DWORD g_dwThreadCount;

//

// The command line and app name for the process

//

LPWSTR g_lpwstrCmdLine = NULL;

LPWSTR g_lpwstrAppDir = NULL;

// Thread ID of thread that has started the ExitProcess process

Volatile<LONG> terminator PAL_GLOBAL = 0;

// Process ID of this process.

DWORD gPID = (DWORD) -1;

//

// Key used for associating CPalThread's with the underlying pthread

// (through pthread_setspecific)

//

pthread_key_t CorUnix::thObjKey;

#define PROCESS_PELOADER_FILENAME "clix"

static WCHAR W16_WHITESPACE[] = {0x0020, 0x0009, 0x000D, 0};

static WCHAR W16_WHITESPACE_DQUOTE[] = {0x0020, 0x0009, 0x000D, '"', 0};

enum FILETYPE

{

FILE_ERROR,/*ERROR*/

FILE_PE, /*PE/COFF file*/

FILE_UNIX, /*Unix Executable*/

FILE_DIR /*Directory*/

};

PAL_ERROR

PROCGetProcessStatus(

CPalThread *pThread,

HANDLE hProcess,

PROCESS_STATE *pps,

DWORD *pdwExitCode

);

static BOOL getFileName(LPCWSTR lpApplicationName, LPWSTR lpCommandLine,

char *lpFileName);

static char ** buildArgv(LPCWSTR lpCommandLine, LPSTR lpAppPath,

UINT *pnArg, BOOL prependLoader);

static BOOL getPath(LPCSTR lpFileName, UINT iLen, LPSTR lpPathFileName);

static int checkFileType(char *lpFileName);

static BOOL PROCEndProcess(HANDLE hProcess, UINT uExitCode,

BOOL bTerminateUnconditionally);

ProcessModules *CreateProcessModules(IN HANDLE hProcess, OUT LPDWORD lpCount);

void DestroyProcessModules(IN ProcessModules *listHead);

/*++

Function:

GetCurrentProcessId

See MSDN doc.

--*/

DWORD

PALAPI

GetCurrentProcessId(

VOID)

{

PERF_ENTRY(GetCurrentProcessId);

ENTRY("GetCurrentProcessId()\n" );

LOGEXIT("GetCurrentProcessId returns DWORD %#x\n", gPID);

PERF_EXIT(GetCurrentProcessId);

return gPID;

}

/*++

Function:

GetCurrentProcess

See MSDN doc.

--*/

HANDLE

PALAPI

GetCurrentProcess(

VOID)

{

PERF_ENTRY(GetCurrentProcess);

ENTRY("GetCurrentProcess()\n" );

LOGEXIT("GetCurrentProcess returns HANDLE %p\n", hPseudoCurrentProcess);

PERF_EXIT(GetCurrentProcess);

/* return a pseudo handle */

return hPseudoCurrentProcess;

}

/*++

Function:

CreateProcessA

Note:

Only Standard handles need to be inherited.

Security attributes parameters are not used.

See MSDN doc.

--*/

BOOL

PALAPI

CreateProcessA(

IN LPCSTR lpApplicationName,

IN LPSTR lpCommandLine,

IN LPSECURITY_ATTRIBUTES lpProcessAttributes,

IN LPSECURITY_ATTRIBUTES lpThreadAttributes,

IN BOOL bInheritHandles,

IN DWORD dwCreationFlags,

IN LPVOID lpEnvironment,

IN LPCSTR lpCurrentDirectory,

IN LPSTARTUPINFOA lpStartupInfo,

OUT LPPROCESS_INFORMATION lpProcessInformation)

{

PAL_ERROR palError = NO_ERROR;

CPalThread *pThread;

STARTUPINFOW StartupInfoW;

LPWSTR CommandLineW = NULL;

LPWSTR ApplicationNameW = NULL;

LPWSTR CurrentDirectoryW = NULL;

int n;

PERF_ENTRY(CreateProcessA);

ENTRY("CreateProcessA(lpAppName=%p (%s), lpCmdLine=%p (%s), lpProcessAttr=%p, "

"lpThreadAttr=%p, bInherit=%d, dwFlags=%#x, lpEnv=%p, "

"lpCurrentDir=%p (%s), lpStartupInfo=%p, lpProcessInfo=%p)\n",

lpApplicationName?lpApplicationName:"NULL",

lpApplicationName?lpApplicationName:"NULL",

lpCommandLine?lpCommandLine:"NULL",

lpCommandLine?lpCommandLine:"NULL",

lpProcessAttributes, lpThreadAttributes, bInheritHandles,

dwCreationFlags, lpEnvironment,

lpCurrentDirectory?lpCurrentDirectory:"NULL",

lpCurrentDirectory?lpCurrentDirectory:"NULL",

lpStartupInfo, lpProcessInformation);

pThread = InternalGetCurrentThread();

if(lpStartupInfo == NULL)

{

ASSERT("lpStartupInfo is NULL!\n");

palError = ERROR_INVALID_PARAMETER;

goto done;

}

/* convert parameters to Unicode */

if(lpApplicationName)

{

n = MultiByteToWideChar(CP_ACP, 0, lpApplicationName, -1, NULL, 0);

if(0 == n)

{

ASSERT("MultiByteToWideChar failed!\n");

palError = ERROR_INTERNAL_ERROR;

goto done;

}

ApplicationNameW = (LPWSTR)InternalMalloc(sizeof(WCHAR)*n);

if(!ApplicationNameW)

{

ERROR("malloc() failed!\n");

palError = ERROR_NOT_ENOUGH_MEMORY;

goto done;

}

MultiByteToWideChar(CP_ACP, 0, lpApplicationName, -1, ApplicationNameW,

n);

}

if(lpCommandLine)

{

n = MultiByteToWideChar(CP_ACP, 0, lpCommandLine, -1, NULL, 0);

if(0 == n)

{

ASSERT("MultiByteToWideChar failed!\n");

palError = ERROR_INTERNAL_ERROR;

goto done;

}

CommandLineW = (LPWSTR)InternalMalloc(sizeof(WCHAR)*n);

if(!CommandLineW)

{

ERROR("malloc() failed!\n");

palError = ERROR_NOT_ENOUGH_MEMORY;

goto done;

}

MultiByteToWideChar(CP_ACP, 0, lpCommandLine, -1, CommandLineW, n);

}

if(lpCurrentDirectory)

{

n = MultiByteToWideChar(CP_ACP, 0, lpCurrentDirectory, -1, NULL, 0);

if(0 == n)

{

ASSERT("MultiByteToWideChar failed!\n");

palError = ERROR_INTERNAL_ERROR;

goto done;

}

CurrentDirectoryW = (LPWSTR)InternalMalloc(sizeof(WCHAR)*n);

if(!CurrentDirectoryW)

{

ERROR("malloc() failed!\n");

palError = ERROR_NOT_ENOUGH_MEMORY;

goto done;

}

MultiByteToWideChar(CP_ACP, 0, lpCurrentDirectory, -1,

CurrentDirectoryW, n);

}

// lpEnvironment should remain ansi on the call to CreateProcessW

StartupInfoW.cb = sizeof StartupInfoW;

StartupInfoW.dwFlags = lpStartupInfo->dwFlags;

StartupInfoW.hStdError = lpStartupInfo->hStdError;

StartupInfoW.hStdInput = lpStartupInfo->hStdInput;

StartupInfoW.hStdOutput = lpStartupInfo->hStdOutput;

/* all other members are PAL_Undefined, we can ignore them */

palError = InternalCreateProcess(

pThread,

ApplicationNameW,

CommandLineW,

lpProcessAttributes,

lpThreadAttributes,

bInheritHandles,

dwCreationFlags,

lpEnvironment,

CurrentDirectoryW,

&StartupInfoW,

lpProcessInformation

);

done:

InternalFree(ApplicationNameW);

InternalFree(CommandLineW);

InternalFree(CurrentDirectoryW);

if (NO_ERROR != palError)

{

pThread->SetLastError(palError);

}

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

PERF_EXIT(CreateProcessA);

return NO_ERROR == palError;

}

/*++

Function:

CreateProcessW

Note:

Only Standard handles need to be inherited.

Security attributes parameters are not used.

See MSDN doc.

--*/

BOOL

PALAPI

CreateProcessW(

IN LPCWSTR lpApplicationName,

IN LPWSTR lpCommandLine,

IN LPSECURITY_ATTRIBUTES lpProcessAttributes,

IN LPSECURITY_ATTRIBUTES lpThreadAttributes,

IN BOOL bInheritHandles,

IN DWORD dwCreationFlags,

IN LPVOID lpEnvironment,

IN LPCWSTR lpCurrentDirectory,

IN LPSTARTUPINFOW lpStartupInfo,

OUT LPPROCESS_INFORMATION lpProcessInformation)

{

PAL_ERROR palError = NO_ERROR;

CPalThread *pThread;

PERF_ENTRY(CreateProcessW);

ENTRY("CreateProcessW(lpAppName=%p (%S), lpCmdLine=%p (%S), lpProcessAttr=%p,"

"lpThreadAttr=%p, bInherit=%d, dwFlags=%#x, lpEnv=%p,"

"lpCurrentDir=%p (%S), lpStartupInfo=%p, lpProcessInfo=%p)\n",

lpApplicationName?lpApplicationName:W16_NULLSTRING,

lpApplicationName?lpApplicationName:W16_NULLSTRING,

lpCommandLine?lpCommandLine:W16_NULLSTRING,

lpCommandLine?lpCommandLine:W16_NULLSTRING,lpProcessAttributes,

lpThreadAttributes, bInheritHandles, dwCreationFlags,lpEnvironment,

lpCurrentDirectory?lpCurrentDirectory:W16_NULLSTRING,

lpCurrentDirectory?lpCurrentDirectory:W16_NULLSTRING,

lpStartupInfo, lpProcessInformation);

pThread = InternalGetCurrentThread();

palError = InternalCreateProcess(

pThread,

lpApplicationName,

lpCommandLine,

lpProcessAttributes,

lpThreadAttributes,

bInheritHandles,

dwCreationFlags,

lpEnvironment,

lpCurrentDirectory,

lpStartupInfo,

lpProcessInformation

);

if (NO_ERROR != palError)

{

pThread->SetLastError(palError);

}

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

PERF_EXIT(CreateProcessW);

return NO_ERROR == palError;

}

PAL_ERROR

PrepareStandardHandle(

CPalThread *pThread,

HANDLE hFile,

IPalObject **ppobjFile,

int *piFd

)

{

PAL_ERROR palError = NO_ERROR;

IPalObject *pobjFile = NULL;

IDataLock *pDataLock = NULL;

CFileProcessLocalData *pLocalData = NULL;

int iError = 0;

palError = g_pObjectManager->ReferenceObjectByHandle(

pThread,

hFile,

&aotFile,

0,

&pobjFile

);

if (NO_ERROR != palError)

{

ERROR("Bad handle passed through CreateProcess\n");

goto PrepareStandardHandleExit;

}

palError = pobjFile->GetProcessLocalData(

pThread,

ReadLock,

&pDataLock,

reinterpret_cast<void **>(&pLocalData)

);

if (NO_ERROR != palError)

{

ASSERT("Unable to access file data\n");

goto PrepareStandardHandleExit;

}

//

// The passed in file needs to be inheritable

//

if (!pLocalData->inheritable)

{

ERROR("Non-inheritable handle passed through CreateProcess\n");

palError = ERROR_INVALID_HANDLE;

goto PrepareStandardHandleExit;

}

iError = fcntl(pLocalData->unix_fd, F_SETFD, 0);

if (-1 == iError)

{

ERROR("Unable to remove close-on-exec for file (errno %i)\n", errno);

palError = ERROR_INVALID_HANDLE;

goto PrepareStandardHandleExit;

}

*piFd = pLocalData->unix_fd;

pDataLock->ReleaseLock(pThread, FALSE);

pDataLock = NULL;

//

// Transfer pobjFile reference to out parameter

//

*ppobjFile = pobjFile;

pobjFile = NULL;

PrepareStandardHandleExit:

if (NULL != pDataLock)

{

pDataLock->ReleaseLock(pThread, FALSE);

}

if (NULL != pobjFile)

{

pobjFile->ReleaseReference(pThread);

}

return palError;

}

PAL_ERROR

CorUnix::InternalCreateProcess(

CPalThread *pThread,

LPCWSTR lpApplicationName,

LPWSTR lpCommandLine,

LPSECURITY_ATTRIBUTES lpProcessAttributes,

LPSECURITY_ATTRIBUTES lpThreadAttributes,

BOOL bInheritHandles,

DWORD dwCreationFlags,

LPVOID lpEnvironment,

LPCWSTR lpCurrentDirectory,

LPSTARTUPINFOW lpStartupInfo,

LPPROCESS_INFORMATION lpProcessInformation

)

{

PAL_ERROR palError = NO_ERROR;

IPalObject *pobjProcess = NULL;

IPalObject *pobjProcessRegistered = NULL;

IDataLock *pLocalDataLock = NULL;

CProcProcessLocalData *pLocalData;

IDataLock *pSharedDataLock = NULL;

CProcSharedData *pSharedData;

CPalThread *pDummyThread = NULL;

HANDLE hDummyThread = NULL;

HANDLE hProcess = NULL;

CObjectAttributes oa(NULL, lpProcessAttributes);

IPalObject *pobjFileIn = NULL;

int iFdIn = -1;

IPalObject *pobjFileOut = NULL;

int iFdOut = -1;

IPalObject *pobjFileErr = NULL;

int iFdErr = -1;

pid_t processId;

char * lpFileName;

PathCharString lpFileNamePS;

char **lppArgv = NULL;

UINT nArg;

int iRet;

char **EnvironmentArray=NULL;

int child_blocking_pipe = -1;

int parent_blocking_pipe = -1;

/* Validate parameters */

/* note : specs indicate lpApplicationName should always

be NULL; however support for it is already implemented. Leaving the code

in, specs can change; but rejecting non-NULL for now to conform to the

spec. */

if( NULL != lpApplicationName )

{

ASSERT("lpApplicationName should be NULL, but is %S instead\n",

lpApplicationName);

palError = ERROR_INVALID_PARAMETER;

goto InternalCreateProcessExit;

}

if (0 != (dwCreationFlags & ~(CREATE_SUSPENDED|CREATE_NEW_CONSOLE)))

{

ASSERT("Unexpected creation flags (%#x)\n", dwCreationFlags);

palError = ERROR_INVALID_PARAMETER;

goto InternalCreateProcessExit;

}

/* Security attributes parameters are ignored */

if (lpProcessAttributes != NULL &&

(lpProcessAttributes->lpSecurityDescriptor != NULL ||

lpProcessAttributes->bInheritHandle != TRUE))

{

ASSERT("lpProcessAttributes is invalid, parameter ignored (%p)\n",

lpProcessAttributes);

palError = ERROR_INVALID_PARAMETER;

goto InternalCreateProcessExit;

}

if (lpThreadAttributes != NULL)

{

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

lpThreadAttributes);

palError = ERROR_INVALID_PARAMETER;

goto InternalCreateProcessExit;

}

/* note : Win32 crashes in this case */

if(NULL == lpStartupInfo)

{

ERROR("lpStartupInfo is NULL\n");

palError = ERROR_INVALID_PARAMETER;

goto InternalCreateProcessExit;

}

/* Validate lpStartupInfo.cb field */

if (lpStartupInfo->cb < sizeof(STARTUPINFOW))

{

ASSERT("lpStartupInfo parameter structure size is invalid (%u)\n",

lpStartupInfo->cb);

palError = ERROR_INVALID_PARAMETER;

goto InternalCreateProcessExit;

}

/* lpStartupInfo should be either zero or STARTF_USESTDHANDLES */

if (lpStartupInfo->dwFlags & ~STARTF_USESTDHANDLES)

{

ASSERT("lpStartupInfo parameter invalid flags (%#x)\n",

lpStartupInfo->dwFlags);

palError = ERROR_INVALID_PARAMETER;

goto InternalCreateProcessExit;

}

/* validate given standard handles if we have any */

if (lpStartupInfo->dwFlags & STARTF_USESTDHANDLES)

{

palError = PrepareStandardHandle(

pThread,

lpStartupInfo->hStdInput,

&pobjFileIn,

&iFdIn

);

if (NO_ERROR != palError)

{

goto InternalCreateProcessExit;

}

palError = PrepareStandardHandle(

pThread,

lpStartupInfo->hStdOutput,

&pobjFileOut,

&iFdOut

);

if (NO_ERROR != palError)

{

goto InternalCreateProcessExit;

}

palError = PrepareStandardHandle(

pThread,

lpStartupInfo->hStdError,

&pobjFileErr,

&iFdErr

);

if (NO_ERROR != palError)

{

goto InternalCreateProcessExit;

}

}

lpFileName = lpFileNamePS.OpenStringBuffer(MAX_LONGPATH-1);

if (NULL == lpFileName)

{

palError = ERROR_NOT_ENOUGH_MEMORY;

goto InternalCreateProcessExit;

}

if (!getFileName(lpApplicationName, lpCommandLine, lpFileName))

{

ERROR("Can't find executable!\n");

palError = ERROR_FILE_NOT_FOUND;

goto InternalCreateProcessExit;

}

lpFileNamePS.CloseBuffer(MAX_LONGPATH-1);

/* check type of file */

iRet = checkFileType(lpFileName);

switch (iRet)

{

case FILE_ERROR: /* file not found, or not an executable */

WARN ("File is not valid (%s)", lpFileName);

palError = ERROR_FILE_NOT_FOUND;

goto InternalCreateProcessExit;

case FILE_UNIX: /* Unix binary file */

break; /* nothing to do */

case FILE_DIR:/*Directory*/

WARN ("File is a Directory (%s)", lpFileName);

palError = ERROR_ACCESS_DENIED;

goto InternalCreateProcessExit;

break;

default: /* not supposed to get here */

ASSERT ("Invalid return type from checkFileType");

palError = ERROR_FILE_NOT_FOUND;

goto InternalCreateProcessExit;

}

/* build Argument list, lppArgv is allocated in buildArgv function and

requires to be freed */

lppArgv = buildArgv(lpCommandLine, lpFileName, &nArg, iRet==1);

/* set the Environment variable */

if (lpEnvironment != NULL)

{

unsigned i;

// Since CREATE_UNICODE_ENVIRONMENT isn't supported we know the string is ansi

unsigned EnvironmentEntries = 0;

// Convert the environment block to array of strings

// Count the number of entries

// Is it a string that contains null terminated string, the end is delimited

// by two null in a row.

for (i = 0; ((char *)lpEnvironment)[i]!='\0'; i++)

{

EnvironmentEntries ++;

for (;((char *)lpEnvironment)[i]!='\0'; i++)

{

}

}

EnvironmentEntries++;

EnvironmentArray = (char **)InternalMalloc(EnvironmentEntries * sizeof(char *));

EnvironmentEntries = 0;

// Convert the environment block to array of strings

// Count the number of entries

// Is it a string that contains null terminated string, the end is delimited

// by two null in a row.

for (i = 0; ((char *)lpEnvironment)[i]!='\0'; i++)

{

EnvironmentArray[EnvironmentEntries] = &((char *)lpEnvironment)[i];

EnvironmentEntries ++;

for (;((char *)lpEnvironment)[i]!='\0'; i++)

{

}

}

EnvironmentArray[EnvironmentEntries] = NULL;

}

//

// Allocate and register the process object for the new process

//

palError = g_pObjectManager->AllocateObject(

pThread,

&otProcess,

&oa,

&pobjProcess

);

if (NO_ERROR != palError)

{

ERROR("Unable to allocate object for new proccess\n");

goto InternalCreateProcessExit;

}

palError = g_pObjectManager->RegisterObject(

pThread,

pobjProcess,

&aotProcess,

PROCESS_ALL_ACCESS,

&hProcess,

&pobjProcessRegistered

);

//

// pobjProcess is invalidated by the above call, so

// NULL it out here

//

pobjProcess = NULL;

if (NO_ERROR != palError)

{

ERROR("Unable to register new process object\n");

goto InternalCreateProcessExit;

}

//

// Create a new "dummy" thread object

//

palError = InternalCreateDummyThread(

pThread,

lpThreadAttributes,

&pDummyThread,

&hDummyThread

);

if (dwCreationFlags & CREATE_SUSPENDED)

{

int pipe_descs[2];

if (-1 == pipe(pipe_descs))

{

ERROR("pipe() failed! error is %d (%s)\n", errno, strerror(errno));

palError = ERROR_NOT_ENOUGH_MEMORY;

goto InternalCreateProcessExit;

}

/* [0] is read end, [1] is write end */

pDummyThread->suspensionInfo.SetBlockingPipe(pipe_descs[1]);

parent_blocking_pipe = pipe_descs[1];

child_blocking_pipe = pipe_descs[0];

}

//

// Get the data pointers for the new process object

//

palError = pobjProcessRegistered->GetSharedData(

pThread,

WriteLock,

&pSharedDataLock,

reinterpret_cast<void **>(&pSharedData)

);

if (NO_ERROR != palError)

{

ASSERT("Unable to obtain shared data for new process object\n");

goto InternalCreateProcessExit;

}

palError = pobjProcessRegistered->GetProcessLocalData(

pThread,

WriteLock,

&pLocalDataLock,

reinterpret_cast<void **>(&pLocalData)

);

if (NO_ERROR != palError)

{

ASSERT("Unable to obtain local data for new process object\n");

goto InternalCreateProcessExit;

}

/* fork the new process */

processId = fork();

if (processId == -1)

{

ASSERT("Unable to create a new process with fork()\n");

if (-1 != child_blocking_pipe)

{

close(child_blocking_pipe);

close(parent_blocking_pipe);

}

palError = ERROR_INTERNAL_ERROR;

goto InternalCreateProcessExit;

}

/* From the time the child process begins running, to when it reaches execve,

the child process is not a real PAL process and does not own any PAL

resources, although it has access to the PAL resources of its parent process.

Thus, while the child process is in this window, it is dangerous for it to affect

its parent's PAL resources. As a consequence, no PAL code should be used

in this window; all code should make unix calls. Note the use of _exit

instead of exit to avoid calling PAL_Terminate and the lack of TRACE's and

ASSERT's. */

if (processId == 0) /* child process */

{

// At this point, the PAL should be considered uninitialized for this child process.

// Don't want to enter the init_critsec here since we're trying to avoid

// calling PAL functions. Furthermore, nothing should be changing

// the init_count in the child process at this point since this is the only

// thread executing.

init_count = 0;

sigset_t sm;

//

// Clear out the signal mask for the new process.

//

sigemptyset(&sm);

iRet = sigprocmask(SIG_SETMASK, &sm, NULL);

if (iRet != 0)

{

_exit(EXIT_FAILURE);

}

if (dwCreationFlags & CREATE_SUSPENDED)

{

BYTE resume_code = 0;

ssize_t read_ret;

/* close the write end of the pipe, the child doesn't need it */

close(parent_blocking_pipe);

read_again:

/* block until ResumeThread writes something to the pipe */

read_ret = read(child_blocking_pipe, &resume_code, sizeof(resume_code));

if (sizeof(resume_code) != read_ret)

{

if (read_ret == -1 && EINTR == errno)

{

goto read_again;

}

else

{

/* note : read might return 0 (and return EAGAIN) if the other

end of the pipe gets closed - for example because the parent

process dies (very) abruptly */

_exit(EXIT_FAILURE);

}

}

if (WAKEUPCODE != resume_code)

{

// resume_code should always equal WAKEUPCODE.

_exit(EXIT_FAILURE);

}

close(child_blocking_pipe);

}

/* Set the current directory */

if (lpCurrentDirectory)

{

SetCurrentDirectoryW(lpCurrentDirectory);

}

/* Set the standard handles to the incoming values */

if (lpStartupInfo->dwFlags & STARTF_USESTDHANDLES)

{

/* For each handle, we need to duplicate the incoming unix

fd to the corresponding standard one. The API that I use,

dup2, will copy the source to the destination, automatically

closing the existing destination, in an atomic way */

if (dup2(iFdIn, STDIN_FILENO) == -1)

{

// Didn't duplicate standard in.

_exit(EXIT_FAILURE);

}

if (dup2(iFdOut, STDOUT_FILENO) == -1)

{

// Didn't duplicate standard out.

_exit(EXIT_FAILURE);

}

if (dup2(iFdErr, STDERR_FILENO) == -1)

{

// Didn't duplicate standard error.

_exit(EXIT_FAILURE);

}

/* now close the original FDs, we don't need them anymore */

close(iFdIn);

close(iFdOut);

close(iFdErr);

}

/* execute the new process */

if (EnvironmentArray)

{

execve(lpFileName, lppArgv, EnvironmentArray);

}

else

{

execve(lpFileName, lppArgv, palEnvironment);

}

/* if we get here, it means the execve function call failed so just exit */

_exit(EXIT_FAILURE);

}

/* parent process */

/* close the read end of the pipe, the parent doesn't need it */

close(child_blocking_pipe);

/* Set the process ID */

pLocalData->dwProcessId = processId;

pLocalDataLock->ReleaseLock(pThread, TRUE);

pLocalDataLock = NULL;

pSharedData->dwProcessId = processId;

pSharedDataLock->ReleaseLock(pThread, TRUE);

pSharedDataLock = NULL;

//

// Release file handle info; we don't need them anymore. Note that

// this must happen after we've released the data locks, as