Context Navigation

source: trunk/src/kmk/w32/winchildren.c@ 3184

Last change on this file since 3184 was 3182, checked in by bird, 8 years ago
kmk/winchildren: PATH searching fixes.
Property svn:eol-style set to `native` Property svn:keywords set to `Id`
File size: 93.0 KB

Line
1	/* $Id: winchildren.c 3182 2018-03-23 00:41:55Z bird $ */
2	/** @file
3	* Child process creation and management for kmk.
4	*/
5
6	/*
7	* Copyright (c) 2018 knut st. osmundsen <bird-kBuild-spamx@anduin.net>
8	*
9	* This file is part of kBuild.
10	*
11	* kBuild is free software; you can redistribute it and/or modify
12	* it under the terms of the GNU General Public License as published by
13	* the Free Software Foundation; either version 3 of the License, or
14	* (at your option) any later version.
15	*
16	* kBuild is distributed in the hope that it will be useful,
17	* but WITHOUT ANY WARRANTY; without even the implied warranty of
18	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
19	* GNU General Public License for more details.
20	*
21	* You should have received a copy of the GNU General Public License
22	* along with kBuild. If not, see <http://www.gnu.org/licenses/>
23	*
24	*/
25
26	/* No GNU coding style here atm, convert if upstreamed. */
27
28	/** @page pg_win_children Windows child process creation and managment
29	*
30	* This new implementation aims at addressing the following:
31	*
32	* 1. Speed up process creation by doing the expensive CreateProcess call
33	* in a worker thread.
34	*
35	* 2. No 64 process limit imposed by WaitForMultipleObjects.
36	*
37	* 3. Better distribute jobs among processor groups.
38	*
39	* 4. Offloading more expensive kmkbuiltin operations to worker threads,
40	* making the main thread focus on managing child processes.
41	*
42	* 5. Output synchronization using reusable pipes [not yet implemented].
43	*
44	*
45	* To be quite honest, the first item (CreateProcess expense) didn't occur to me
46	* at first and was more of a sideeffect discovered along the way. A test
47	* rebuilding IPRT went from 4m52s to 3m19s on a 8 thread system.
48	*
49	* The 2nd and 3rd goals are related to newer build servers that have lots of
50	* CPU threads and various Windows NT (aka NT OS/2 at the time) design choices
51	* made in the late 1980ies.
52	*
53	* WaitForMultipleObjects does not support waiting for more than 64 objects,
54	* unlike poll and select. This is just something everyone ends up having to
55	* work around in the end.
56	*
57	* Affinity masks are uintptr_t sized, so 64-bit hosts can only manage 64
58	* processors and 32-bit only 32. Workaround was introduced with Windows 7
59	* (IIRC) and is called processor groups. The CPU threads are grouped into 1 or
60	* more groups of up to 64 processors. Processes are generally scheduled to a
61	* signle processor group at first, but threads may be changed to be scheduled
62	* on different groups. This code will try distribute children evenly among the
63	* processor groups, using a very simple algorithm (see details in code).
64	*
65	*/
66
67
68	/*********************************************************************************************************************************
69	* Header Files *
70	*********************************************************************************************************************************/
71	#include "../makeint.h"
72	#include "../job.h"
73	#include "../debug.h"
74	#include "../kmkbuiltin.h"
75	#include "winchildren.h"
76
77	#include <Windows.h>
78	#include <Winternl.h>
79	#include <assert.h>
80	#include <process.h>
81	#include <intrin.h>
82
83	#include "nt/nt_child_inject_standard_handles.h"
84
85
86	/*********************************************************************************************************************************
87	* Defined Constants And Macros *
88	*********************************************************************************************************************************/
89	#define MKWINCHILD_MAX_PATH 1024
90
91	/** Checks the UTF-16 environment variable pointed to is the PATH. */
92	#define IS_PATH_ENV_VAR(a_cwcVar, a_pwszVar) \
93	( (a_cwcVar) >= 5 \
94	&& (a_pwszVar)[4] == L'=' \
95	&& ((a_pwszVar)[0] == L'P' \|\| (a_pwszVar)[0] == L'p') \
96	&& ((a_pwszVar)[1] == L'A' \|\| (a_pwszVar)[1] == L'a') \
97	&& ((a_pwszVar)[2] == L'T' \|\| (a_pwszVar)[2] == L't') \
98	&& ((a_pwszVar)[3] == L'H' \|\| (a_pwszVar)[3] == L'h') )
99
100
101	/*********************************************************************************************************************************
102	* Structures and Typedefs *
103	*********************************************************************************************************************************/
104	/**
105	* Child process type.
106	*/
107	typedef enum WINCHILDTYPE
108	{
109	WINCHILDTYPE_INVALID = 0,
110	/** Normal child process. */
111	WINCHILDTYPE_PROCESS,
112	#ifdef KMK
113	/** kmkbuiltin command. */
114	WINCHILDTYPE_BUILT_IN,
115	/** kmkbuiltin_append result write out. */
116	WINCHILDTYPE_APPEND,
117	/** kSubmit job. */
118	WINCHILDTYPE_SUBMIT,
119	/** kmk_redirect job. */
120	WINCHILDTYPE_REDIRECT,
121	#endif
122	/** End of valid child types. */
123	WINCHILDTYPE_END
124	} WINCHILDTYPE;
125
126
127	/** Pointer to a windows child process. */
128	typedef struct WINCHILD *PWINCHILD;
129	/**
130	* Windows child process.
131	*/
132	typedef struct WINCHILD
133	{
134	/** Magic / eyecatcher (WINCHILD_MAGIC). */
135	ULONG uMagic;
136	/** Child type. */
137	WINCHILDTYPE enmType;
138	/** Pointer to the next child process. */
139	PWINCHILD pNext;
140	/** The pid for this child. */
141	pid_t pid;
142	/** The make child structure associated with this child. */
143	struct child *pMkChild;
144
145	/** The process exit code. */
146	int iExitCode;
147	/** Kill signal, in case we or someone else killed it. */
148	int iSignal;
149	/** Set if core was dumped. */
150	int fCoreDumped;
151
152	/** Type specific data. */
153	union
154	{
155	/** Data for WINCHILDTYPE_PROCESS. */
156	struct
157	{
158	/** Argument vector (single allocation, strings following array). */
159	char **papszArgs;
160	/** Length of the argument strings. */
161	size_t cbArgsStrings;
162	/** Environment vector. Only a copy if fEnvIsCopy is set. */
163	char **papszEnv;
164	/** If we made a copy of the environment, this is the size of the
165	* strings and terminator string (not in array). This is done to
166	* speed up conversion, since MultiByteToWideChar can handle '\0'. */
167	size_t cbEnvStrings;
168	/** The make shell to use (copy). */
169	char *pszShell;
170	/** Handle to use for standard out. */
171	HANDLE hStdOut;
172	/** Handle to use for standard out. */
173	HANDLE hStdErr;
174	/** Whether to close hStdOut after creating the process. */
175	BOOL fCloseStdOut;
176	/** Whether to close hStdErr after creating the process. */
177	BOOL fCloseStdErr;
178
179	/** Child process handle. */
180	HANDLE hProcess;
181	} Process;
182
183	/** Data for WINCHILDTYPE_BUILT_IN. */
184	struct
185	{
186	/** The built-in command. */
187	PCKMKBUILTINENTRY pBuiltIn;
188	/** Number of arguments. */
189	int cArgs;
190	/** Argument vector (single allocation, strings following array). */
191	char **papszArgs;
192	/** Environment vector. Only a copy if fEnvIsCopy is set. */
193	char **papszEnv;
194	} BuiltIn;
195
196	/** Data for WINCHILDTYPE_APPEND. */
197	struct
198	{
199	/** The filename. */
200	char *pszFilename;
201	/** How much to append. */
202	size_t cbAppend;
203	/** What to append. */
204	char *pszAppend;
205	/** Whether to truncate the file. */
206	int fTruncate;
207	} Append;
208
209	/** Data for WINCHILDTYPE_SUBMIT. */
210	struct
211	{
212	/** The event we're to wait on (hooked up to a pipe) */
213	HANDLE hEvent;
214	/** Parameter for the cleanup callback. */
215	void *pvSubmitWorker;
216	} Submit;
217
218	/** Data for WINCHILDTYPE_REDIRECT. */
219	struct
220	{
221	/** Child process handle. */
222	HANDLE hProcess;
223	} Redirect;
224	} u;
225
226	} WINCHILD;
227	/** WINCHILD::uMagic value. */
228	#define WINCHILD_MAGIC 0xbabebabeU
229
230
231	/**
232	* Data for a windows childcare worker thread.
233	*
234	* We use one worker thread per child, reusing the threads when possible.
235	*
236	* This setup helps avoid the 64-bit handle with the WaitForMultipleObject API.
237	*
238	* It also helps using all CPUs on systems with more than one CPU group
239	* (typically systems with more than 64 CPU threads or/and multiple sockets, or
240	* special configs).
241	*
242	* This helps facilitates using pipes for collecting output child rather
243	* than temporary files. Pipes doesn't involve NTFS and can easily be reused.
244	*
245	* Finally, kBuild specific, this allows running kmkbuiltin_xxxx commands in
246	* threads.
247	*/
248	typedef struct WINCHILDCAREWORKER
249	{
250	/** Magic / eyecatcher (WINCHILDCAREWORKER_MAGIC). */
251	ULONG uMagic;
252	/** The processor group for this worker. */
253	unsigned int iProcessorGroup;
254	/** The thread ID. */
255	unsigned int tid;
256	/** The thread handle. */
257	HANDLE hThread;
258	/** The event the thread is idling on. */
259	HANDLE hEvtIdle;
260	/** Pointer to the current child. */
261	PWINCHILD volatile pCurChild;
262	/** List of children pending execution on this worker.
263	* This is updated atomitically just like g_pTailCompletedChildren. */
264	PWINCHILD volatile pTailTodoChildren;
265	/** TRUE if idle, FALSE if not. */
266	long volatile fIdle;
267	} WINCHILDCAREWORKER;
268	/** Pointer to a childcare worker thread. */
269	typedef WINCHILDCAREWORKER *PWINCHILDCAREWORKER;
270	/** WINCHILD::uMagic value. */
271	#define WINCHILDCAREWORKER_MAGIC 0xdad0dad0U
272
273
274	/*********************************************************************************************************************************
275	* Global Variables *
276	*********************************************************************************************************************************/
277	/** Whether it's initialized or not. */
278	static BOOL g_fInitialized = FALSE;
279	/** Set when we're shutting down everything. */
280	static BOOL volatile g_fShutdown = FALSE;
281	/** Event used to wait for children. */
282	static HANDLE g_hEvtWaitChildren = INVALID_HANDLE_VALUE;
283	/** Number of childcare workers currently in g_papChildCareworkers. */
284	static unsigned g_cChildCareworkers = 0;
285	/** Maximum number of childcare workers in g_papChildCareworkers. */
286	static unsigned g_cChildCareworkersMax = 0;
287	/** Pointer to childcare workers. */
288	static PWINCHILDCAREWORKER *g_papChildCareworkers = NULL;
289	/** The group index for the worker allocator.
290	* This is ever increasing and must be modded by g_cProcessorGroups. */
291	static unsigned g_idxProcessorGroupAllocator = 0;
292	/** The processor in group index for the worker allocator. */
293	static unsigned g_idxProcessorInGroupAllocator = 0;
294	/** Number of processor groups in the system. */
295	static unsigned g_cProcessorGroups = 1;
296	/** Array detailing how many active processors there are in each group. */
297	static unsigned const *g_pacProcessorsInGroup = &g_cProcessorGroups;
298	/** Kernel32!GetActiveProcessorGroupCount */
299	static WORD (WINAPI *g_pfnGetActiveProcessorGroupCount)(VOID);
300	/** Kernel32!GetActiveProcessorCount */
301	static DWORD (WINAPI *g_pfnGetActiveProcessorCount)(WORD);
302	/** Kernel32!SetThreadGroupAffinity */
303	static BOOL (WINAPI g_pfnSetThreadGroupAffinity)(HANDLE, CONST GROUP_AFFINITY , GROUP_AFFINITY *);
304	/** NTDLL!NtQueryInformationProcess */
305	static NTSTATUS (NTAPI *g_pfnNtQueryInformationProcess)(HANDLE, PROCESSINFOCLASS, PVOID, ULONG, PULONG);
306	/** Set if the windows host is 64-bit. */
307	static BOOL g_f64BitHost = (K_ARCH_BITS == 64);
308	/** Windows version info.
309	* @note Putting this before the volatile stuff, hoping to keep it in a
310	* different cache line than the static bits above. */
311	static OSVERSIONINFOA g_VersionInfo = { sizeof(g_VersionInfo), 4, 0, 1381, VER_PLATFORM_WIN32_NT, {0} };
312
313	/** Children that has been completed.
314	* This is updated atomically, pushing completed children in LIFO fashion
315	* (thus 'tail'), then hitting g_hEvtWaitChildren if head. */
316	static PWINCHILD volatile g_pTailCompletedChildren = NULL;
317
318	/** Number of idle pending children.
319	* This is updated before g_hEvtWaitChildren is signalled. */
320	static unsigned volatile g_cPendingChildren = 0;
321
322	/** Number of idle childcare worker threads. */
323	static unsigned volatile g_cIdleChildcareWorkers = 0;
324	/** Index of the last idle child careworker (just a hint). */
325	static unsigned volatile g_idxLastChildcareWorker = 0;
326
327	#ifdef WITH_RW_LOCK
328	/** RW lock for serializing kmkbuiltin_redirect and CreateProcess. */
329	static SRWLOCK g_RWLock;
330	#endif
331
332
333	#if K_ARCH_BITS == 32 && !defined(_InterlockedCompareExchangePointer)
334	/** _InterlockedCompareExchangePointer is missing? (VS2010) */
335	K_INLINE void _InterlockedCompareExchangePointer(void volatile ppvDst, void pvNew, void *pvOld)
336	{
337	return (void )_InterlockedCompareExchange((long volatile )ppvDst, (intptr_t)pvNew, (intptr_t)pvOld);
338	}
339	#endif
340
341
342	/**
343	* Initializes the windows child module.
344	*
345	* @param cJobSlots The number of job slots.
346	*/
347	void MkWinChildInit(unsigned int cJobSlots)
348	{
349	HMODULE hmod;
350
351	/*
352	* Figure out how many childcare workers first.
353	*/
354	static unsigned int const s_cMaxWorkers = 4096;
355	unsigned cWorkers;
356	if (cJobSlots >= 1 && cJobSlots < s_cMaxWorkers)
357	cWorkers = cJobSlots;
358	else
359	cWorkers = s_cMaxWorkers;
360
361	/*
362	* Allocate the array and the child completed event object.
363	*/
364	g_papChildCareworkers = (PWINCHILDCAREWORKER )xcalloc(cWorkers sizeof(g_papChildCareworkers[0]));
365	g_cChildCareworkersMax = cWorkers;
366
367	g_hEvtWaitChildren = CreateEvent(NULL, FALSE /fManualReset/, FALSE /fInitialState/, NULL /pszName/);
368	if (!g_hEvtWaitChildren)
369	fatal(NILF, INTSTR_LENGTH, _("MkWinChildInit: CreateEvent failed: %u"), GetLastError());
370
371	/*
372	* NTDLL imports that we need.
373	*/
374	hmod = GetModuleHandleA("NTDLL.DLL");
375	(FARPROC )&g_pfnNtQueryInformationProcess = GetProcAddress(hmod, "NtQueryInformationProcess");
376	if (!g_pfnNtQueryInformationProcess)
377	fatal(NILF, 0, _("MkWinChildInit: NtQueryInformationProcess not found"));
378
379	#if K_ARCH_BITS == 32
380	/*
381	* Initialize g_f64BitHost.
382	*/
383	if (!IsWow64Process(GetCurrentProcess(), &g_f64BitHost))
384	fatal(NILF, INTSTR_LENGTH, _("MkWinChildInit: IsWow64Process failed: %u"), GetLastError());
385	#elif K_ARCH_BITS == 64
386	assert(g_f64BitHost);
387	#else
388	# error "K_ARCH_BITS is bad/missing"
389	#endif
390
391	/*
392	* Figure out how many processor groups there are.
393	* For that we need to first figure the windows version.
394	*/
395	if (!GetVersionExA(&g_VersionInfo))
396	{
397	DWORD uRawVer = GetVersion();
398	g_VersionInfo.dwMajorVersion = uRawVer & 0xff;
399	g_VersionInfo.dwMinorVersion = (uRawVer >> 8) & 0xff;
400	g_VersionInfo.dwBuildNumber = (uRawVer >> 16) & 0x7fff;
401	}
402	if (g_VersionInfo.dwMajorVersion >= 6)
403	{
404	hmod = GetModuleHandleA("KERNEL32.DLL");
405	(FARPROC )&g_pfnGetActiveProcessorGroupCount = GetProcAddress(hmod, "GetActiveProcessorGroupCount");
406	(FARPROC )&g_pfnGetActiveProcessorCount = GetProcAddress(hmod, "GetActiveProcessorCount");
407	(FARPROC )&g_pfnSetThreadGroupAffinity = GetProcAddress(hmod, "SetThreadGroupAffinity");
408	if ( g_pfnSetThreadGroupAffinity
409	&& g_pfnGetActiveProcessorCount
410	&& g_pfnGetActiveProcessorGroupCount)
411	{
412	unsigned int *pacProcessorsInGroup;
413	unsigned iGroup;
414	g_cProcessorGroups = g_pfnGetActiveProcessorGroupCount();
415	if (g_cProcessorGroups == 0)
416	g_cProcessorGroups = 1;
417
418	pacProcessorsInGroup = (unsigned int )xmalloc(sizeof(g_pacProcessorsInGroup[0]) g_cProcessorGroups);
419	g_pacProcessorsInGroup = pacProcessorsInGroup;
420	for (iGroup = 0; iGroup < g_cProcessorGroups; iGroup++)
421	pacProcessorsInGroup[iGroup] = g_pfnGetActiveProcessorCount(iGroup);
422
423	/* We shift the starting group with the make nesting level as part of
424	our very simple distribution strategy. */
425	g_idxProcessorGroupAllocator = makelevel;
426	}
427	else
428	{
429	g_pfnSetThreadGroupAffinity = NULL;
430	g_pfnGetActiveProcessorCount = NULL;
431	g_pfnGetActiveProcessorGroupCount = NULL;
432	}
433	}
434
435	#ifdef WITH_RW_LOCK
436	/*
437	* For serializing with standard file handle manipulation (kmkbuiltin_redirect).
438	*/
439	InitializeSRWLock(&g_RWLock);
440	#endif
441
442	/*
443	* This is dead code that was thought to fix a problem observed doing
444	* `tcc.exe /c "kmk \|& tee bld.log"` and leading to a crash in cl.exe
445	* when spawned with fInheritHandles = FALSE, see hStdErr=NULL in the
446	* child. However, it turns out this was probably caused by not clearing
447	* the CRT file descriptor and handle table in the startup info.
448	* Leaving the code here in case it comes in handy after all.
449	*/
450	#if 0
451	{
452	struct
453	{
454	DWORD uStdHandle;
455	HANDLE hHandle;
456	} aHandles[3] = { { STD_INPUT_HANDLE, NULL }, { STD_OUTPUT_HANDLE, NULL }, { STD_ERROR_HANDLE, NULL } };
457	int i;
458
459	for (i = 0; i < 3; i++)
460	aHandles[i].hHandle = GetStdHandle(aHandles[i].uStdHandle);
461
462	for (i = 0; i < 3; i++)
463	if ( aHandles[i].hHandle == NULL
464	\|\| aHandles[i].hHandle == INVALID_HANDLE_VALUE)
465	{
466	int fd = open("nul", _O_RDWR);
467	if (fd >= 0)
468	{
469	if (_dup2(fd, i) >= 0)
470	{
471	assert((HANDLE)_get_osfhandle(i) != aHandles[i].hHandle);
472	assert((HANDLE)_get_osfhandle(i) == GetStdHandle(aHandles[i].uStdHandle));
473	}
474	else
475	ONNNS(fatal, NILF, "_dup2(%d('nul'), %d) failed: %u (%s)", fd, i, errno, strerror(errno));
476	if (fd != i)
477	close(fd);
478	}
479	else
480	ONNS(fatal, NILF, "open(nul,RW) failed: %u (%s)", i, errno, strerror(errno));
481	}
482	else
483	{
484	int j;
485	for (j = i + 1; j < 3; j++)
486	if (aHandles[j].hHandle == aHandles[i].hHandle)
487	{
488	int fd = _dup(j);
489	if (fd >= 0)
490	{
491	if (_dup2(fd, j) >= 0)
492	{
493	aHandles[j].hHandle = (HANDLE)_get_osfhandle(j);
494	assert(aHandles[j].hHandle != aHandles[i].hHandle);
495	assert(aHandles[j].hHandle == GetStdHandle(aHandles[j].uStdHandle));
496	}
497	else
498	ONNNS(fatal, NILF, "_dup2(%d, %d) failed: %u (%s)", fd, j, errno, strerror(errno));
499	if (fd != j)
500	close(fd);
501	}
502	else
503	ONNS(fatal, NILF, "_dup(%d) failed: %u (%s)", j, errno, strerror(errno));
504	}
505	}
506	}
507	#endif
508	}
509
510	/**
511	* Used by mkWinChildcareWorkerThread() and MkWinChildWait() to get the head
512	* child from a lifo (g_pTailCompletedChildren, pTailTodoChildren).
513	*
514	* @returns Head child.
515	* @param ppTail Pointer to the child variable.
516	* @param pChild Tail child.
517	*/
518	static PWINCHILD mkWinChildDequeFromLifo(PWINCHILD volatile *ppTail, PWINCHILD pChild)
519	{
520	if (pChild->pNext)
521	{
522	PWINCHILD pPrev;
523	do
524	{
525	pPrev = pChild;
526	pChild = pChild->pNext;
527	} while (pChild->pNext);
528	pPrev->pNext = NULL;
529	}
530	else
531	{
532	PWINCHILD const pWantedChild = pChild;
533	pChild = _InterlockedCompareExchangePointer(ppTail, NULL, pWantedChild);
534	if (pChild != pWantedChild)
535	{
536	PWINCHILD pPrev;
537	do
538	{
539	pPrev = pChild;
540	pChild = pChild->pNext;
541	} while (pChild->pNext);
542	pPrev->pNext = NULL;
543	assert(pChild == pWantedChild);
544	}
545	}
546	return pChild;
547	}
548
549	/**
550	* Duplicates the given UTF-16 string.
551	*
552	* @returns 0
553	* @param pwszSrc The UTF-16 string to duplicate.
554	* @param cwcSrc Length, may include the terminator.
555	* @param ppwszDst Where to return the duplicate.
556	*/
557	static int mkWinChildDuplicateUtf16String(const WCHAR pwszSrc, size_t cwcSrc, WCHAR *ppwszDst)
558	{
559	size_t cb = sizeof(WCHAR) * cwcSrc;
560	if (cwcSrc > 0 && pwszSrc[cwcSrc - 1] == L'\0')
561	ppwszDst = (WCHAR )memcpy(xmalloc(cb), pwszSrc, cb);
562	else
563	{
564	WCHAR pwszDst = (WCHAR )xmalloc(cb + sizeof(WCHAR));
565	memcpy(pwszDst, pwszSrc, cb);
566	pwszDst[cwcSrc] = L'\0';
567	*ppwszDst = pwszDst;
568	}
569	return 0;
570	}
571
572	/**
573	* Commmon worker for waiting on a child process and retrieving the exit code.
574	*
575	* @param pWorker The worker.
576	* @param pChild The child.
577	* @param hProcess The process handle.
578	*/
579	static void mkWinChildcareWorkerWaitForProcess(PWINCHILDCAREWORKER pWorker, PWINCHILD pChild, HANDLE hProcess)
580	{
581	for (;;)
582	{
583	DWORD dwExitCode = -42;
584	DWORD dwStatus = WaitForSingleObject(hProcess, INFINITE);
585	assert(dwStatus != WAIT_FAILED);
586	if (dwStatus == WAIT_OBJECT_0)
587	{
588	DWORD dwExitCode = -42;
589	if (GetExitCodeProcess(hProcess, &dwExitCode))
590	{
591	pChild->iExitCode = (int)dwExitCode;
592	return;
593	}
594	}
595	else if ( dwStatus == WAIT_IO_COMPLETION
596	\|\| dwStatus == WAIT_TIMEOUT /* whatever */)
597	continue; /* however unlikely, these aren't fatal. */
598
599	/* Something failed. */
600	pChild->iExitCode = GetLastError();
601	if (pChild->iExitCode == 0)
602	pChild->iExitCode = -4242;
603	return;
604	}
605	}
606
607
608	/**
609	* Closes standard handles that need closing before destruction.
610	*
611	* @param pChild The child (WINCHILDTYPE_PROCESS).
612	*/
613	static void mkWinChildcareWorkerCloseStandardHandles(PWINCHILD pChild)
614	{
615	if ( pChild->u.Process.fCloseStdOut
616	&& pChild->u.Process.hStdOut != INVALID_HANDLE_VALUE)
617	{
618	CloseHandle(pChild->u.Process.hStdOut);
619	pChild->u.Process.hStdOut = INVALID_HANDLE_VALUE;
620	pChild->u.Process.fCloseStdOut = FALSE;
621	}
622	if ( pChild->u.Process.fCloseStdErr
623	&& pChild->u.Process.hStdErr != INVALID_HANDLE_VALUE)
624	{
625	CloseHandle(pChild->u.Process.hStdErr);
626	pChild->u.Process.hStdErr = INVALID_HANDLE_VALUE;
627	pChild->u.Process.fCloseStdErr = FALSE;
628	}
629	}
630
631
632	/**
633	* Does the actual process creation given.
634	*
635	* @returns 0 if there is anything to wait on, otherwise non-zero windows error.
636	* @param pWorker The childcare worker.
637	* @param pChild The child.
638	* @param pwszImageName The image path.
639	* @param pwszCommandLine The command line.
640	* @param pwszzEnvironment The enviornment block.
641	*/
642	static int mkWinChildcareWorkerCreateProcess(PWINCHILDCAREWORKER pWorker, PWINCHILD pChild, WCHAR const *pwszImageName,
643	WCHAR const pwszCommandLine, WCHAR const pwszzEnvironment)
644	{
645	PROCESS_INFORMATION ProcInfo;
646	STARTUPINFOW StartupInfo;
647	DWORD fFlags = CREATE_UNICODE_ENVIRONMENT;
648	BOOL const fHaveHandles = pChild->u.Process.hStdErr != INVALID_HANDLE_VALUE
649	\|\| pChild->u.Process.hStdOut != INVALID_HANDLE_VALUE;
650	BOOL fRet;
651	DWORD dwErr;
652	#ifdef KMK
653	extern int process_priority;
654	#endif
655
656	/*
657	* Populate startup info.
658	*
659	* Turns out we can get away without passing TRUE for the inherit handles
660	* parameter to CreateProcess when we're not using STARTF_USESTDHANDLES.
661	* At least on NT, which is all worth caring about at this point + context IMO.
662	*
663	* Not inherting the handles is a good thing because it means we won't
664	* accidentally end up with a pipe handle or such intended for a different
665	* child process, potentially causing the EOF/HUP event to be delayed.
666	*
667	* Since the present handle inhertiance requirements only involves standard
668	* output and error, we'll never set the inherit handles flag and instead
669	* do manual handle duplication and planting.
670	*/
671	memset(&StartupInfo, 0, sizeof(StartupInfo));
672	StartupInfo.cb = sizeof(StartupInfo);
673	GetStartupInfoW(&StartupInfo);
674	StartupInfo.lpReserved2 = 0; /* No CRT file handle + descriptor info possible, sorry. */
675	StartupInfo.cbReserved2 = 0;
676	if (!fHaveHandles)
677	StartupInfo.dwFlags &= ~STARTF_USESTDHANDLES;
678	else
679	{
680	fFlags \|= CREATE_SUSPENDED;
681	StartupInfo.dwFlags &= ~STARTF_USESTDHANDLES;
682	}
683
684	/*
685	* Flags.
686	*/
687	#ifdef KMK
688	switch (process_priority)
689	{
690	case 1: fFlags \|= CREATE_SUSPENDED \| IDLE_PRIORITY_CLASS; break;
691	case 2: fFlags \|= CREATE_SUSPENDED \| BELOW_NORMAL_PRIORITY_CLASS; break;
692	case 3: fFlags \|= CREATE_SUSPENDED \| NORMAL_PRIORITY_CLASS; break;
693	case 4: fFlags \|= CREATE_SUSPENDED \| HIGH_PRIORITY_CLASS; break;
694	case 5: fFlags \|= CREATE_SUSPENDED \| REALTIME_PRIORITY_CLASS; break;
695	}
696	#endif
697	if (g_cProcessorGroups > 1)
698	fFlags \|= CREATE_SUSPENDED;
699
700	/*
701	* Try create the process.
702	*/
703	DB(DB_JOBS, ("CreateProcessW(%ls, %ls,,, TRUE, %#x...)\n", pwszImageName, pwszCommandLine, fFlags));
704	memset(&ProcInfo, 0, sizeof(ProcInfo));
705	#ifdef WITH_RW_LOCK
706	AcquireSRWLockShared(&g_RWLock);
707	#endif
708
709	fRet = CreateProcessW((WCHAR )pwszImageName, (WCHAR )pwszCommandLine, NULL /pProcSecAttr/, NULL /pThreadSecAttr/,
710	FALSE /fInheritHandles/, fFlags, (WCHAR )pwszzEnvironment, NULL /pwsz*/, &StartupInfo, &ProcInfo);
711	dwErr = GetLastError();
712
713	#ifdef WITH_RW_LOCK
714	ReleaseSRWLockShared(&g_RWLock);
715	#endif
716	if (fRet)
717	pChild->u.Process.hProcess = ProcInfo.hProcess;
718	else
719	{
720	fprintf(stderr, "CreateProcess(%ls) failed: %u\n", pwszImageName, dwErr);
721	return pChild->iExitCode = (int)dwErr;
722	}
723
724	/*
725	* If the child is suspended, we've got some adjustment work to be done.
726	*/
727	dwErr = ERROR_SUCCESS;
728	if (fFlags & CREATE_SUSPENDED)
729	{
730	/*
731	* First do handle inhertiance as that's the most complicated.
732	*/
733	if (fHaveHandles)
734	{
735	char szErrMsg[128];
736	BOOL afReplace[3] =
737	{ FALSE, pChild->u.Process.hStdOut != INVALID_HANDLE_VALUE, pChild->u.Process.hStdErr != INVALID_HANDLE_VALUE };
738	HANDLE ahChild[3] =
739	{ NULL, pChild->u.Process.hStdOut, pChild->u.Process.hStdErr };
740
741	dwErr = nt_child_inject_standard_handles(ProcInfo.hProcess, afReplace, ahChild, szErrMsg, sizeof(szErrMsg));
742	if (dwErr != 0)
743	fprintf(stderr, "%s\n", szErrMsg);
744	}
745
746	/*
747	* Assign processor group (ignore failure).
748	*/
749	if (g_cProcessorGroups > 1)
750	{
751	GROUP_AFFINITY Affinity = { ~(ULONG_PTR)0, pWorker->iProcessorGroup, { 0, 0, 0 } };
752	fRet = g_pfnSetThreadGroupAffinity(ProcInfo.hThread, &Affinity, NULL);
753	assert(fRet);
754	}
755
756	#ifdef KMK
757	/*
758	* Set priority (ignore failure).
759	*/
760	switch (process_priority)
761	{
762	case 1: fRet = SetThreadPriority(ProcInfo.hThread, THREAD_PRIORITY_IDLE); break;
763	case 2: fRet = SetThreadPriority(ProcInfo.hThread, THREAD_PRIORITY_BELOW_NORMAL); break;
764	case 3: fRet = SetThreadPriority(ProcInfo.hThread, THREAD_PRIORITY_NORMAL); break;
765	case 4: fRet = SetThreadPriority(ProcInfo.hThread, THREAD_PRIORITY_HIGHEST); break;
766	case 5: fRet = SetThreadPriority(ProcInfo.hThread, THREAD_PRIORITY_TIME_CRITICAL); break;
767	default: fRet = TRUE;
768	}
769	assert(fRet);
770	#endif
771
772	/*
773	* Resume the thread if the adjustments succeeded, otherwise kill it.
774	*/
775	if (dwErr == ERROR_SUCCESS)
776	{
777	fRet = ResumeThread(ProcInfo.hThread);
778	assert(fRet);
779	if (!fRet)
780	{
781	dwErr = GetLastError();
782	fprintf(stderr, "ResumeThread failed on child process: %u\n", dwErr);
783	}
784	}
785	if (dwErr != ERROR_SUCCESS)
786	TerminateProcess(ProcInfo.hProcess, dwErr);
787	}
788
789	/*
790	* Close unnecessary handles.
791	*/
792	mkWinChildcareWorkerCloseStandardHandles(pChild);
793	CloseHandle(ProcInfo.hThread);
794	return 0;
795	}
796
797
798	#define MKWCCWCMD_F_CYGWIN_SHELL 1
799	#define MKWCCWCMD_F_MKS_SHELL 2
800	#define MKWCCWCMD_F_HAVE_SH 4
801	#define MKWCCWCMD_F_HAVE_KASH_C 8 /*< kmk_ash -c "..." /
802
803	static int mkWinChildcareWorkerConvertCommandline(char papszArgs, unsigned fFlags, WCHAR ppwszCommandLine)
804	{
805	struct ARGINFO
806	{
807	size_t cchSrc;
808	size_t cwcDst; /*< converted size w/o terminator. /
809	size_t cwcDstExtra : 24; /*< Only set with fSlowly. /
810	size_t fSlowly : 1;
811	size_t fQuoteIt : 1;
812	size_t fEndSlashes : 1; /*< if escapes needed for trailing backslashes. /
813	size_t fExtraSpace : 1; /*< if kash -c "" needs an extra space before the quote. /
814	} *paArgInfo;
815	size_t cArgs;
816	size_t i;
817	size_t cwcNeeded;
818	WCHAR *pwszDst;
819	WCHAR *pwszCmdLine;
820
821	/*
822	* Count them first so we can allocate an info array of the stack.
823	*/
824	cArgs = 0;
825	while (papszArgs[cArgs] != NULL)
826	cArgs++;
827	paArgInfo = (struct ARGINFO )alloca(sizeof(paArgInfo[0]) cArgs);
828
829	/*
830	* Preprocess them and calculate the exact command line length.
831	*/
832	cwcNeeded = 1;
833	for (i = 0; i < cArgs; i++)
834	{
835	char *pszSrc = papszArgs[i];
836	size_t cchSrc = strlen(pszSrc);
837	paArgInfo[i].cchSrc = cchSrc;
838	if (cchSrc == 0)
839	{
840	/* empty needs quoting. */
841	paArgInfo[i].cwcDst = 2;
842	paArgInfo[i].cwcDstExtra = 0;
843	paArgInfo[i].fSlowly = 0;
844	paArgInfo[i].fQuoteIt = 1;
845	paArgInfo[i].fExtraSpace = 0;
846	paArgInfo[i].fEndSlashes = 0;
847	}
848	else
849	{
850	const char *pszSpace = memchr(pszSrc, ' ', cchSrc);
851	const char *pszTab = memchr(pszSrc, '\t', cchSrc);
852	const char *pszDQuote = memchr(pszSrc, '"', cchSrc);
853	const char *pszEscape = memchr(pszSrc, '\\', cchSrc);
854	int cwcDst = MultiByteToWideChar(CP_ACP, 0 /fFlags/, pszSrc, cchSrc + 1, NULL, 0);
855	if (cwcDst >= 0)
856	--cwcDst;
857	else
858	{
859	DWORD dwErr = GetLastError();
860	fprintf(stderr, _("MultiByteToWideChar failed to convert argv[%u] (%s): %u\n"), i, pszSrc, dwErr);
861	return dwErr;
862	}
863	#if 0
864	if (!pszSpace && !pszTab && !pszDQuote && !pszEscape)
865	{
866	/* no special handling needed. */
867	paArgInfo[i].cwcDst = cwcDst;
868	paArgInfo[i].cwcDstExtra = 0;
869	paArgInfo[i].fSlowly = 0;
870	paArgInfo[i].fQuoteIt = 0;
871	paArgInfo[i].fExtraSpace = 0;
872	paArgInfo[i].fEndSlashes = 0;
873	}
874	else if (!pszDQuote && !pszEscape)
875	{
876	/* Just double quote it. */
877	paArgInfo[i].cwcDst = cwcDst + 2;
878	paArgInfo[i].cwcDstExtra = 0;
879	paArgInfo[i].fSlowly = 0;
880	paArgInfo[i].fQuoteIt = 1;
881	paArgInfo[i].fExtraSpace = 0;
882	paArgInfo[i].fEndSlashes = 0;
883	}
884	else
885	#endif
886	{
887	/* Complicated, need to scan the string to figure out what to do. */
888	size_t cwcDstExtra;
889	int cBackslashes;
890	char ch;
891
892	paArgInfo[i].fQuoteIt = 0;
893	paArgInfo[i].fSlowly = 1;
894	paArgInfo[i].fExtraSpace = 0;
895	paArgInfo[i].fEndSlashes = 0;
896
897	cwcDstExtra = 0;
898	cBackslashes = 0;
899	while ((ch = *pszSrc++) != '\0')
900	{
901	switch (ch)
902	{
903	default:
904	cBackslashes = 0;
905	break;
906
907	case '\\':
908	cBackslashes++;
909	break;
910
911	case '"':
912	if (fFlags & (MKWCCWCMD_F_CYGWIN_SHELL \| MKWCCWCMD_F_MKS_SHELL))
913	cwcDstExtra += 1;
914	else
915	cwcDstExtra += 1 + cBackslashes;
916	break;
917
918	case ' ':
919	case '\t':
920	if (!paArgInfo[i].fQuoteIt)
921	{
922	paArgInfo[i].fQuoteIt = 1;
923	cwcDstExtra += 2;
924	}
925	cBackslashes = 0;
926	break;
927	}
928	}
929
930	if ( cBackslashes > 0
931	&& paArgInfo[i].fQuoteIt
932	&& !(fFlags & (MKWCCWCMD_F_CYGWIN_SHELL \| MKWCCWCMD_F_MKS_SHELL)))
933	{
934	cwcDstExtra += cBackslashes;
935	paArgInfo[i].fEndSlashes = 1;
936	}
937
938	paArgInfo[i].cwcDst = cwcDst + cwcDstExtra;
939	paArgInfo[i].cwcDstExtra = cwcDstExtra;
940	}
941	}
942
943	if ( (fFlags & MKWCCWCMD_F_HAVE_KASH_C)
944	&& paArgInfo[i].fQuoteIt)
945	{
946	paArgInfo[i].fExtraSpace = 1;
947	paArgInfo[i].cwcDst++;
948	paArgInfo[i].cwcDstExtra++;
949	}
950
951	cwcNeeded += (i != 0) + paArgInfo[i].cwcDst;
952	}
953
954	/*
955	* Allocate the result buffer and do the actual conversion.
956	*/
957	pwszDst = pwszCmdLine = (WCHAR )xmalloc(sizeof(WCHAR) cwcNeeded);
958	for (i = 0; i < cArgs; i++)
959	{
960	char *pszSrc = papszArgs[i];
961	size_t cwcDst = paArgInfo[i].cwcDst;
962
963	if (i != 0)
964	*pwszDst++ = L' ';
965
966	if (paArgInfo[i].fQuoteIt)
967	{
968	*pwszDst++ = L'"';
969	cwcDst -= 2;
970	}
971
972	if (!paArgInfo[i].fSlowly)
973	{
974	int cwcDst2 = MultiByteToWideChar(CP_ACP, 0 /fFlags/, pszSrc, paArgInfo[i].cchSrc, pwszDst, cwcDst + 1);
975	assert(cwcDst2 >= 0);
976	pwszDst += cwcDst;
977	}
978	else
979	{
980	/* Do the conversion into the end of the output buffer, then move
981	it up to where it should be char by char. */
982	size_t cBackslashes;
983	size_t cwcLeft = paArgInfo[i].cwcDst - paArgInfo[i].cwcDstExtra;
984	WCHAR volatile *pwchSlowSrc = pwszDst + paArgInfo[i].cwcDstExtra;
985	WCHAR volatile *pwchSlowDst = pwszDst;
986	int cwcDst2 = MultiByteToWideChar(CP_ACP, 0 /fFlags/, pszSrc, paArgInfo[i].cchSrc,
987	(WCHAR *)pwchSlowSrc, cwcLeft + 1);
988	assert(cwcDst2 >= 0);
989
990	cBackslashes = 0;
991	while (cwcLeft-- > 0)
992	{
993	WCHAR wcSrc = *pwchSlowSrc++;
994	if (wcSrc != L'\\' && wcSrc != L'"')
995	cBackslashes = 0;
996	else if (wcSrc == L'\\')
997	cBackslashes++;
998	else if ( (fFlags & (MKWCCWCMD_F_CYGWIN_SHELL \| MKWCCWCMD_F_HAVE_SH))
999	== (MKWCCWCMD_F_CYGWIN_SHELL \| MKWCCWCMD_F_HAVE_SH))
1000	pwchSlowDst++ = L'"'; / cygwin: '"' instead of '\\', no escaped slashes. */
1001	else
1002	{
1003	if (!(fFlags & (MKWCCWCMD_F_CYGWIN_SHELL \| MKWCCWCMD_F_MKS_SHELL)))
1004	cBackslashes = 1;
1005	while (cBackslashes-- > 0)
1006	*pwchSlowDst++ = L'\\';
1007	}
1008	*pwchSlowDst++ = wcSrc;
1009	}
1010
1011	if (paArgInfo[i].fEndSlashes)
1012	while (cBackslashes-- > 0)
1013	*pwchSlowDst++ = L'\\';
1014
1015	pwszDst += cwcDst;
1016	assert(pwszDst == (WCHAR *)pwchSlowDst);
1017	}
1018
1019	if (paArgInfo[i].fExtraSpace)
1020	*pwszDst++ = L' ';
1021	if (paArgInfo[i].fQuoteIt)
1022	*pwszDst++ = L'"';
1023	}
1024	*pwszDst = L'\0';
1025	*ppwszCommandLine = pwszCmdLine;
1026	return 0;
1027	}
1028
1029	static int mkWinChildcareWorkerConvertCommandlineWithShell(const WCHAR pwszShell, char papszArgs, WCHAR *ppwszCommandLine)
1030	{
1031	fprintf(stderr, "%s: not found!\n", papszArgs[0]);
1032	return ERROR_FILE_NOT_FOUND;
1033	}
1034
1035	/**
1036	* Searches the environment block for the PATH variable.
1037	*
1038	* @returns Pointer to the path in the block or "." in pwszPathFallback.
1039	* @param pwszzEnv The UTF-16 environment block to search.
1040	* @param pwszPathFallback Fallback.
1041	*/
1042	static const WCHAR mkWinChildcareWorkerFindPathValue(const WCHAR pwszzEnv, WCHAR pwszPathFallback[4])
1043	{
1044	while (*pwszzEnv)
1045	{
1046	size_t cwcVar = wcslen(pwszzEnv);
1047	if (!IS_PATH_ENV_VAR(cwcVar, pwszzEnv))
1048	pwszzEnv += cwcVar + 1;
1049	else if (cwcVar > 5)
1050	return &pwszzEnv[5];
1051	else
1052	break;
1053	}
1054	pwszPathFallback[0] = L'.';
1055	pwszPathFallback[1] = L'\0';
1056	return pwszPathFallback;
1057	}
1058
1059	/**
1060	* Checks if we need to had this executable file to the shell.
1061	*
1062	* @returns TRUE if it's shell fooder, FALSE if we think windows can handle it.
1063	* @param hFile Handle to the file in question
1064	*/
1065	static BOOL mkWinChildcareWorkerCheckIfNeedShell(HANDLE hFile)
1066	{
1067	/*
1068	* Read the first 512 bytes and check for an executable image header.
1069	*/
1070	union
1071	{
1072	DWORD dwSignature;
1073	WORD wSignature;
1074	BYTE ab[128];
1075	} uBuf;
1076	DWORD cbRead;
1077	uBuf.dwSignature = 0;
1078	if ( ReadFile(hFile, &uBuf, sizeof(uBuf), &cbRead, NULL /pOverlapped/)
1079	&& cbRead == sizeof(uBuf))
1080	{
1081	if (uBuf.wSignature == IMAGE_DOS_SIGNATURE)
1082	return FALSE;
1083	if (uBuf.dwSignature == IMAGE_NT_SIGNATURE)
1084	return FALSE;
1085	if ( uBuf.wSignature == IMAGE_OS2_SIGNATURE /* NE */
1086	\|\| uBuf.wSignature == 0x5d4c /* LX */
1087	\|\| uBuf.wSignature == IMAGE_OS2_SIGNATURE_LE /* LE */)
1088	return FALSE;
1089	}
1090	return TRUE;
1091	}
1092
1093
1094	/**
1095	* Tries to locate the image file, searching the path and maybe falling back on
1096	* the shell in case it knows more (think cygwin with its own view of the file
1097	* system).
1098	*
1099	* This will also check for shell script, falling back on the shell too to
1100	* handle those.
1101	*
1102	* @returns 0 on success, windows error code on failure.
1103	* @param pszArg0 The first argument.
1104	* @param pwszSearchPath In case mkWinChildcareWorkerConvertEnvironment
1105	* had a chance of locating the search path already.
1106	* @param pwszzEnv The environment block, in case we need to look for
1107	* the path.
1108	* @param pszShell The shell.
1109	* @param ppwszImagePath Where to return the pointer to the image path. This
1110	* could be the shell.
1111	* @param pfNeedShell Where to return shell vs direct execution indicator.
1112	*/
1113	static int mkWinChildcareWorkerFindImage(char const pszArg0, WCHAR pwszSearchPath, WCHAR const *pwszzEnv,
1114	const char pszShell, WCHAR ppwszImagePath, BOOL pfNeedShell)
1115	{
1116	/** @todo Slap a cache on this code. We usually end up executing the same
1117	* stuff over and over again (e.g. compilers, linkers, etc).
1118	* Hitting the file system is slow on windows. */
1119
1120	/*
1121	* Convert pszArg0 to unicode so we can work directly on that.
1122	*/
1123	WCHAR wszArg0[MKWINCHILD_MAX_PATH + 4]; /* +4 for painless '.exe' appending */
1124	DWORD dwErr;
1125	size_t cbArg0 = strlen(pszArg0) + 1;
1126	int const cwcArg0 = MultiByteToWideChar(CP_ACP, 0 /fFlags/, pszArg0, cbArg0, wszArg0, MKWINCHILD_MAX_PATH);
1127	if (cwcArg0 > 0)
1128	{
1129	HANDLE hFile = INVALID_HANDLE_VALUE;
1130	WCHAR wszPathBuf[MKWINCHILD_MAX_PATH + 4]; /* +4 for painless '.exe' appending */
1131	int cwc;
1132
1133	/*
1134	* If there isn't an .exe suffix, we may have to add one.
1135	* Also we ASSUME that .exe suffixes means no hash bang detection needed.
1136	*/
1137	int const fHasExeSuffix = cwcArg0 > CSTRLEN(".exe")
1138	&& wszArg0[cwcArg0 - 4] == '.'
1139	&& (wszArg0[cwcArg0 - 3] == L'e' \|\| wszArg0[cwcArg0 - 3] == L'E')
1140	&& (wszArg0[cwcArg0 - 2] == L'x' \|\| wszArg0[cwcArg0 - 2] == L'X')
1141	&& (wszArg0[cwcArg0 - 1] == L'e' \|\| wszArg0[cwcArg0 - 1] == L'E');
1142
1143	/*
1144	* If there isn't any path specified, we need to search the PATH env.var.
1145	*/
1146	int const fHasPath = wszArg0[1] == L':'
1147	\|\| wszArg0[0] == L'\\'
1148	\|\| wszArg0[0] == L'/'
1149	\|\| wmemchr(wszArg0, L'/', cwcArg0)
1150	\|\| wmemchr(wszArg0, L'\\', cwcArg0);
1151
1152	/* Before we do anything, flip UNIX slashes to DOS ones. */
1153	WCHAR *pwc = wszArg0;
1154	while ((pwc = wcschr(pwc, L'/')) != NULL)
1155	*pwc++ = L'\\';
1156
1157	/* Don't need to set this all the time... */
1158	*pfNeedShell = FALSE;
1159
1160	/*
1161	* If any kind of path is specified in arg0, we will not search the
1162	* PATH env.var and can limit ourselves to maybe slapping a .exe on to it.
1163	*/
1164	if (fHasPath)
1165	{
1166	/*
1167	* If relative to a CWD, turn it into an absolute one.
1168	*/
1169	unsigned cwcPath = cwcArg0;
1170	WCHAR *pwszPath = wszArg0;
1171	if ( *pwszPath != L'\\'
1172	&& (pwszPath[1] != ':' \|\| pwszPath[2] != L'\\') )
1173	{
1174	DWORD cwcAbsPath = GetFullPathNameW(wszArg0, MKWINCHILD_MAX_PATH, wszPathBuf, NULL);
1175	if (cwcAbsPath > 0)
1176	{
1177	cwcAbsPath = cwcPath + 1; /* include terminator, like MultiByteToWideChar does. */
1178	pwszPath = wszPathBuf;
1179	}
1180	}
1181
1182	/*
1183	* If there is an exectuable path, we only need to check that it exists.
1184	*/
1185	if (fHasExeSuffix)
1186	{
1187	DWORD dwAttribs = GetFileAttributesW(pwszPath);
1188	if (dwAttribs != INVALID_FILE_ATTRIBUTES)
1189	return mkWinChildDuplicateUtf16String(pwszPath, cwcPath + 4, ppwszImagePath);
1190	}
1191	else
1192	{
1193	/*
1194	* No suffix, so try open it first to see if it's shell fooder.
1195	* Otherwise, append a .exe suffix and check if it exists.
1196	*/
1197	hFile = CreateFileW(pwszPath, GENERIC_READ, FILE_SHARE_READ \| FILE_SHARE_DELETE \| FILE_SHARE_WRITE,
1198	NULL /pSecAttr/, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
1199	if (hFile != INVALID_HANDLE_VALUE)
1200	{
1201	*pfNeedShell = mkWinChildcareWorkerCheckIfNeedShell(hFile);
1202	CloseHandle(hFile);
1203	if (!*pfNeedShell)
1204	return mkWinChildDuplicateUtf16String(pwszPath, cwcPath, ppwszImagePath);
1205	}
1206	/* Append the .exe suffix and check if it exists. */
1207	else
1208	{
1209	DWORD dwAttribs;
1210	pwszPath[cwcPath - 1] = L'.';
1211	pwszPath[cwcPath ] = L'e';
1212	pwszPath[cwcPath + 1] = L'x';
1213	pwszPath[cwcPath + 2] = L'e';
1214	pwszPath[cwcPath + 3] = L'\0';
1215	dwAttribs = GetFileAttributesW(pwszPath);
1216	if (dwAttribs != INVALID_FILE_ATTRIBUTES)
1217	return mkWinChildDuplicateUtf16String(pwszPath, cwcPath + 4, ppwszImagePath);
1218	}
1219	}
1220	}
1221	/*
1222	* No path, need to search the PATH env.var. for the executable, maybe
1223	* adding an .exe suffix while do so if that is missing.
1224	*/
1225	else
1226	{
1227	BOOL fSearchedCwd = FALSE;
1228	WCHAR wszPathFallback[4];
1229	if (!pwszSearchPath)
1230	pwszSearchPath = (WCHAR *)mkWinChildcareWorkerFindPathValue(pwszzEnv, wszPathFallback);
1231
1232	for (;;)
1233	{
1234	size_t cwcCombined;
1235
1236	/*
1237	* Find the end of the current PATH component.
1238	*/
1239	size_t cwcSkip;
1240	WCHAR wcEnd;
1241	size_t cwcComponent = 0;
1242	WCHAR wc;
1243	while ((wc = pwszSearchPath[cwcComponent]) != L'\0')
1244	{
1245	if (wc != ';' && wc != ':')
1246	{ /* likely */ }
1247	else if (wc == ';')
1248	break;
1249	else if (cwcComponent != (pwszSearchPath[cwcComponent] != L'"' ? 1 : 2))
1250	break;
1251	cwcComponent++;
1252	}
1253	wcEnd = wc;
1254
1255	/* Trim leading spaces and double quotes. */
1256	while ( cwcComponent > 0
1257	&& ((wc = *pwszSearchPath) == L'"' \|\| wc == L' ' \|\| wc == L'\t'))
1258	{
1259	pwszSearchPath++;
1260	cwcComponent--;
1261	}
1262	cwcSkip = cwcComponent;
1263
1264	/* Trim trailing spaces & double quotes. */
1265	while ( cwcComponent > 0
1266	&& ((wc = pwszSearchPath[cwcComponent - 1]) == L'"' \|\| wc == L' ' \|\| wc == L'\t'))
1267	cwcComponent--;
1268
1269	/*
1270	* Skip empty components. Join the component and the filename, making sure to
1271	* resolve any CWD relative stuff first.
1272	*/
1273	cwcCombined = cwcComponent + 1 + cwcArg0;
1274	if (cwcComponent > 0 && cwcCombined <= MKWINCHILD_MAX_PATH)
1275	{
1276	DWORD dwAttribs;
1277
1278	/* Copy the component into wszPathBuf, maybe abspath'ing it. */
1279	DWORD cwcAbsPath = 0;
1280	if ( *pwszSearchPath != L'\\'
1281	&& (pwszSearchPath[1] != ':' \|\| pwszSearchPath[2] != L'\\') )
1282	{
1283	/* To save an extra buffer + copying, we'll temporarily modify the PATH
1284	value in our converted UTF-16 environment block. */
1285	WCHAR const wcSaved = pwszSearchPath[cwcComponent];
1286	pwszSearchPath[cwcComponent] = L'\0';
1287	cwcAbsPath = GetFullPathNameW(pwszSearchPath, MKWINCHILD_MAX_PATH, wszPathBuf, NULL);
1288	pwszSearchPath[cwcComponent] = wcSaved;
1289	if (cwcAbsPath > 0 && cwcAbsPath + 1 + cwcArg0 <= MKWINCHILD_MAX_PATH)
1290	cwcCombined = cwcAbsPath + 1 + cwcArg0;
1291	else
1292	cwcAbsPath = 0;
1293	}
1294	if (cwcAbsPath == 0)
1295	{
1296	memcpy(wszPathBuf, pwszSearchPath, cwcComponent * sizeof(WCHAR));
1297	cwcAbsPath = cwcComponent;
1298	}
1299
1300	/* Append the filename. */
1301	if ((wc = wszPathBuf[cwcAbsPath - 1]) == L'\\' \|\| wc == L'/' \|\| wc == L':')
1302	{
1303	memcpy(&wszPathBuf[cwcAbsPath], wszArg0, cwcArg0 * sizeof(WCHAR));
1304	cwcCombined--;
1305	}
1306	else
1307	{
1308	wszPathBuf[cwcAbsPath] = L'\\';
1309	memcpy(&wszPathBuf[cwcAbsPath + 1], wszArg0, cwcArg0 * sizeof(WCHAR));
1310	}
1311	assert(wszPathBuf[cwcCombined - 1] == L'\0');
1312
1313	/* DOS slash conversion */
1314	pwc = wszPathBuf;
1315	while ((pwc = wcschr(pwc, L'/')) != NULL)
1316	*pwc++ = L'\\';
1317
1318	/*
1319	* Search with exe suffix first.
1320	*/
1321	if (!fHasExeSuffix)
1322	{
1323	wszPathBuf[cwcCombined - 1] = L'.';
1324	wszPathBuf[cwcCombined ] = L'e';
1325	wszPathBuf[cwcCombined + 1] = L'x';
1326	wszPathBuf[cwcCombined + 2] = L'e';
1327	wszPathBuf[cwcCombined + 3] = L'\0';
1328	}
1329	dwAttribs = GetFileAttributesW(wszPathBuf);
1330	if ( dwAttribs != INVALID_FILE_ATTRIBUTES
1331	&& !(dwAttribs & FILE_ATTRIBUTE_DIRECTORY))
1332	return mkWinChildDuplicateUtf16String(wszPathBuf, cwcCombined + (fHasExeSuffix ? 0 : 4), ppwszImagePath);
1333	if (!fHasExeSuffix)
1334	{
1335	wszPathBuf[cwcCombined - 1] = L'\0';
1336
1337	/*
1338	* Check if the file exists w/o the added '.exe' suffix. If it does,
1339	* we need to check if we can pass it to CreateProcess or need the shell.
1340	*/
1341	hFile = CreateFileW(wszPathBuf, GENERIC_READ, FILE_SHARE_READ \| FILE_SHARE_DELETE \| FILE_SHARE_WRITE,
1342	NULL /pSecAttr/, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
1343	if (hFile != INVALID_HANDLE_VALUE)
1344	{
1345	*pfNeedShell = mkWinChildcareWorkerCheckIfNeedShell(hFile);
1346	CloseHandle(hFile);
1347	if (!*pfNeedShell)
1348	return mkWinChildDuplicateUtf16String(wszPathBuf, cwcCombined, ppwszImagePath);
1349	break;
1350	}
1351	}
1352	}
1353
1354	/*
1355	* Advance to the next component.
1356	*/
1357	if (wcEnd != '\0')
1358	pwszSearchPath += cwcSkip + 1;
1359	else if (fSearchedCwd)
1360	break;
1361	else
1362	{
1363	fSearchedCwd = TRUE;
1364	wszPathFallback[0] = L'.';
1365	wszPathFallback[1] = L'\0';
1366	pwszSearchPath = wszPathFallback;
1367	}
1368	}
1369	}
1370
1371	/*
1372	* We need the shell. It will take care of finding/reporting missing
1373	* image files and such.
1374	*/
1375	*pfNeedShell = TRUE;
1376	if (pszShell)
1377	{
1378	cwc = MultiByteToWideChar(CP_ACP, 0 /fFlags/, pszShell, strlen(pszShell) + 1, wszPathBuf, MKWINCHILD_MAX_PATH);
1379	if (cwc > 0)
1380	return mkWinChildDuplicateUtf16String(wszPathBuf, cwc, ppwszImagePath);
1381	dwErr = GetLastError();
1382	fprintf(stderr, _("MultiByteToWideChar failed to convert shell (%s): %u\n"), pszShell, dwErr);
1383	}
1384	else
1385	{
1386	fprintf(stderr, "%s: not found!\n", pszArg0);
1387	dwErr = ERROR_FILE_NOT_FOUND;
1388	}
1389	}
1390	else
1391	{
1392	dwErr = GetLastError();
1393	fprintf(stderr, _("MultiByteToWideChar failed to convert argv[0] (%s): %u\n"), pszArg0, dwErr);
1394	}
1395	return dwErr == ERROR_INSUFFICIENT_BUFFER ? ERROR_FILENAME_EXCED_RANGE : dwErr;
1396	}
1397
1398	/**
1399	* Creates the environment block.
1400	*
1401	* @returns 0 on success, windows error code on failure.
1402	* @param papszEnv The environment vector to convert.
1403	* @param cbEnvStrings The size of the environment strings, iff they are
1404	* sequential in a block. Otherwise, zero.
1405	* @param ppwszEnv Where to return the pointer to the environment
1406	* block.
1407	* @param ppwszSearchPath Where to return the pointer to the path value
1408	* within the environment block. This will not be set
1409	* if cbEnvStrings is non-zero, more efficient to let
1410	* mkWinChildcareWorkerFindImage() search when needed.
1411	*/
1412	static int mkWinChildcareWorkerConvertEnvironment(char **papszEnv, size_t cbEnvStrings,
1413	WCHAR ppwszEnv, WCHAR const ppwszSearchPath)
1414	{
1415	DWORD dwErr;
1416	int cwcRc;
1417	int cwcDst;
1418	WCHAR *pwszzDst;
1419
1420	*ppwszSearchPath = NULL;
1421
1422	/*
1423	* We've got a little optimization here with help from mkWinChildCopyStringArray.
1424	*/
1425	if (cbEnvStrings)
1426	{
1427	cwcDst = cbEnvStrings + 32;
1428	pwszzDst = (WCHAR )xmalloc(cwcDst sizeof(WCHAR));
1429	cwcRc = MultiByteToWideChar(CP_ACP, 0 /fFlags/, papszEnv[0], cbEnvStrings, pwszzDst, cwcDst);
1430	if (cwcRc != 0)
1431	{
1432	*ppwszEnv = pwszzDst;
1433	return 0;
1434	}
1435
1436	/* Resize the allocation and try again. */
1437	dwErr = GetLastError();
1438	if (dwErr == ERROR_INSUFFICIENT_BUFFER)
1439	{
1440	cwcRc = MultiByteToWideChar(CP_ACP, 0 /fFlags/, papszEnv[0], cbEnvStrings, NULL, 0);
1441	if (cwcRc > 0)
1442	cwcDst = cwcRc + 32;
1443	else
1444	cwcDst *= 2;
1445	pwszzDst = (WCHAR *)xrealloc(pwszzDst, cwcDst);
1446	cwcRc = MultiByteToWideChar(CP_ACP, 0 /fFlags/, papszEnv[0], cbEnvStrings, pwszzDst, cwcDst);
1447	if (cwcRc != 0)
1448	{
1449	*ppwszEnv = pwszzDst;
1450	return 0;
1451	}
1452	dwErr = GetLastError();
1453	}
1454	fprintf(stderr, _("MultiByteToWideChar failed to convert environment block: %u\n"), dwErr);
1455	}
1456	/*
1457	* Need to convert it string by string.
1458	*/
1459	else
1460	{
1461	size_t offPathValue = ~(size_t)0;
1462	size_t offDst;
1463
1464	/*
1465	* Estimate the size first.
1466	*/
1467	size_t cEnvVars;
1468	size_t cwcDst = 32;
1469	size_t iVar = 0;
1470	const char *pszSrc;
1471	while ((pszSrc = papszEnv[iVar]) != NULL)
1472	{
1473	cwcDst += strlen(pszSrc) + 1;
1474	iVar++;
1475	}
1476	cEnvVars = iVar;
1477
1478	/* Allocate estimated WCHARs and convert the variables one by one, reallocating
1479	the block as needed. */
1480	pwszzDst = (WCHAR )xmalloc(cwcDst sizeof(WCHAR));
1481	cwcDst--; /* save one wchar for the terminating empty string. */
1482	offDst = 0;
1483	for (iVar = 0; iVar < cEnvVars; iVar++)
1484	{
1485	size_t cwcLeft = cwcDst - offDst;
1486	size_t const cbSrc = strlen(pszSrc = papszEnv[iVar]) + 1;
1487	assert(cwcDst >= offDst);
1488
1489
1490	cwcRc = MultiByteToWideChar(CP_ACP, 0 /fFlags/, pszSrc, cbSrc, &pwszzDst[offDst], cwcLeft);
1491	if (cwcRc > 0)
1492	{ /* likely */ }
1493	else
1494	{
1495	dwErr = GetLastError();
1496	if (dwErr == ERROR_INSUFFICIENT_BUFFER)
1497	{
1498	/* Need more space. So, calc exacly how much and resize the block accordingly. */
1499	size_t cbSrc2 = cbSrc;
1500	size_t iVar2 = iVar;
1501	cwcLeft = 1;
1502	for (;;)
1503	{
1504	size_t cwcRc2 = MultiByteToWideChar(CP_ACP, 0 /fFlags/, pszSrc, cbSrc, NULL, 0);
1505	if (cwcRc2 > 0)
1506	cwcLeft += cwcRc2;
1507	else
1508	cwcLeft += cbSrc * 4;
1509
1510	/* advance */
1511	iVar2++;
1512	if (iVar2 >= cEnvVars)
1513	break;
1514	pszSrc = papszEnv[iVar2];
1515	cbSrc2 = strlen(pszSrc) + 1;
1516	}
1517	pszSrc = papszEnv[iVar];
1518
1519	/* Grow the allocation and repeat the conversion. */
1520	if (offDst + cwcLeft > cwcDst + 1)
1521	{
1522	cwcDst = offDst + cwcLeft;
1523	pwszzDst = (WCHAR )xrealloc(pwszzDst, cwcDst sizeof(WCHAR));
1524	cwcDst--; /* save one wchar for the terminating empty string. */
1525	cwcRc = MultiByteToWideChar(CP_ACP, 0 /fFlags/, pszSrc, cbSrc, &pwszzDst[offDst], cwcLeft - 1);
1526	if (cwcRc <= 0)
1527	dwErr = GetLastError();
1528	}
1529	}
1530	if (cwcRc <= 0)
1531	{
1532	fprintf(stderr, _("MultiByteToWideChar failed to convert environment string #%u (%s): %u\n"),
1533	iVar, pszSrc, dwErr);
1534	free(pwszzDst);
1535	return dwErr;
1536	}
1537	}
1538
1539	/* Look for the PATH. */
1540	if ( offPathValue == ~(size_t)0
1541	&& IS_PATH_ENV_VAR(cwcRc, &pwszzDst[offDst]) )
1542	offPathValue = offDst + 4 + 1;
1543
1544	/* Advance. */
1545	offDst += cwcRc;
1546	}
1547	pwszzDst[offDst++] = '\0';
1548
1549	if (offPathValue != ~(size_t)0)
1550	*ppwszSearchPath = &pwszzDst[offPathValue];
1551	*ppwszEnv = pwszzDst;
1552	return 0;
1553	}
1554	free(pwszzDst);
1555	return dwErr;
1556	}
1557
1558	/**
1559	* Childcare worker: handle regular process.
1560	*
1561	* @param pWorker The worker.
1562	* @param pChild The kSubmit child.
1563	*/
1564	static void mkWinChildcareWorkerThreadHandleProcess(PWINCHILDCAREWORKER pWorker, PWINCHILD pChild)
1565	{
1566	WCHAR *pwszSearchPath = NULL;
1567	WCHAR *pwszzEnvironment = NULL;
1568	WCHAR *pwszCommandLine = NULL;
1569	WCHAR *pwszImageName = NULL;
1570	BOOL fNeedShell = FALSE;
1571	int rc;
1572
1573	/*
1574	* First we convert the environment so we get the PATH we need to
1575	* search for the executable.
1576	*/
1577	rc = mkWinChildcareWorkerConvertEnvironment(pChild->u.Process.papszEnv ? pChild->u.Process.papszEnv : environ,
1578	pChild->u.Process.cbEnvStrings,
1579	&pwszzEnvironment, &pwszSearchPath);
1580	/*
1581	* Find the executable and maybe checking if it's a shell script, then
1582	* convert it to a command line.
1583	*/
1584	if (rc == 0)
1585	rc = mkWinChildcareWorkerFindImage(pChild->u.Process.papszArgs[0], pwszSearchPath, pwszzEnvironment,
1586	pChild->u.Process.pszShell, &pwszImageName, &fNeedShell);
1587	if (rc == 0)
1588	{
1589	if (!fNeedShell)
1590	rc = mkWinChildcareWorkerConvertCommandline(pChild->u.Process.papszArgs, 0 /fFlags/, &pwszCommandLine);
1591	else
1592	rc = mkWinChildcareWorkerConvertCommandlineWithShell(pwszImageName, pChild->u.Process.papszArgs, &pwszCommandLine);
1593
1594	/*
1595	* Create the child process.
1596	*/
1597	if (rc == 0)
1598	{
1599	rc = mkWinChildcareWorkerCreateProcess(pWorker, pChild, pwszImageName, pwszCommandLine, pwszzEnvironment);
1600	if (rc == 0)
1601	{
1602	/*
1603	* Wait for the child to complete.
1604	*/
1605	mkWinChildcareWorkerWaitForProcess(pWorker, pChild, pChild->u.Process.hProcess);
1606	}
1607	else
1608	pChild->iExitCode = rc;
1609	}
1610	else
1611	pChild->iExitCode = rc;
1612	}
1613	else
1614	pChild->iExitCode = rc;
1615	free(pwszCommandLine);
1616	free(pwszImageName);
1617	free(pwszzEnvironment);
1618
1619	/* In case we failed, we must make sure the child end of pipes
1620	used by $(shell no_such_command.exe) are closed, otherwise
1621	the main thread will be stuck reading the parent end. */
1622	mkWinChildcareWorkerCloseStandardHandles(pChild);
1623	}
1624
1625	#ifdef KMK
1626
1627	/**
1628	* Childcare worker: handle builtin command.
1629	*
1630	* @param pWorker The worker.
1631	* @param pChild The kSubmit child.
1632	*/
1633	static void mkWinChildcareWorkerThreadHandleBuiltIn(PWINCHILDCAREWORKER pWorker, PWINCHILD pChild)
1634	{
1635	PCKMKBUILTINENTRY pBuiltIn = pChild->u.BuiltIn.pBuiltIn;
1636	if (pBuiltIn->uFnSignature == FN_SIG_MAIN)
1637	pChild->iExitCode = pBuiltIn->u.pfnMain(pChild->u.BuiltIn.cArgs, pChild->u.BuiltIn.papszArgs, pChild->u.BuiltIn.papszEnv);
1638	else if (pBuiltIn->uFnSignature == FN_SIG_MAIN_SPAWNS)
1639	pChild->iExitCode = pBuiltIn->u.pfnMainSpawns(pChild->u.BuiltIn.cArgs, pChild->u.BuiltIn.papszArgs,
1640	pChild->u.BuiltIn.papszEnv, pChild->pMkChild, NULL);
1641	else
1642	{
1643	assert(0);
1644	pChild->iExitCode = 98;
1645	}
1646	}
1647
1648	/**
1649	* Childcare worker: handle append write-out.
1650	*
1651	* @param pWorker The worker.
1652	* @param pChild The kSubmit child.
1653	*/
1654	static void mkWinChildcareWorkerThreadHandleAppend(PWINCHILDCAREWORKER pWorker, PWINCHILD pChild)
1655	{
1656	int fd = open(pChild->u.Append.pszFilename,
1657	pChild->u.Append.fTruncate
1658	? O_WRONLY \| O_TRUNC \| O_CREAT \| _O_NOINHERIT \| _O_BINARY
1659	: O_WRONLY \| O_APPEND \| O_CREAT \| _O_NOINHERIT \| _O_BINARY,
1660	0666);
1661	if (fd >= 0)
1662	{
1663	ssize_t cbWritten = write(fd, pChild->u.Append.pszAppend, pChild->u.Append.cbAppend);
1664	if (cbWritten == (ssize_t)pChild->u.Append.cbAppend)
1665	{
1666	if (close(fd) >= 0)
1667	{
1668	pChild->iExitCode = 0;
1669	return;
1670	}
1671	fprintf(stderr, "kmk_builtin_append: close failed on '%s': %u (%s)\n",
1672	pChild->u.Append.pszFilename, errno, strerror(errno));
1673	}
1674	else
1675	fprintf(stderr, "kmk_builtin_append: error writing %lu bytes to on '%s': %u (%s)\n",
1676	pChild->u.Append.cbAppend, pChild->u.Append.pszFilename, errno, strerror(errno));
1677	close(fd);
1678	}
1679	else
1680	fprintf(stderr, "kmk_builtin_append: error opening '%s': %u (%s)\n",
1681	pChild->u.Append.pszFilename, errno, strerror(errno));
1682	pChild->iExitCode = 1;
1683	}
1684
1685	/**
1686	* Childcare worker: handle kSubmit job.
1687	*
1688	* @param pWorker The worker.
1689	* @param pChild The kSubmit child.
1690	*/
1691	static void mkWinChildcareWorkerThreadHandleSubmit(PWINCHILDCAREWORKER pWorker, PWINCHILD pChild)
1692	{
1693	void *pvSubmitWorker = pChild->u.Submit.pvSubmitWorker;
1694	for (;;)
1695	{
1696	int iExitCode = -42;
1697	int iSignal = -1;
1698	DWORD dwStatus = WaitForSingleObject(pChild->u.Submit.hEvent, INFINITE);
1699	assert(dwStatus != WAIT_FAILED);
1700
1701	if (kSubmitSubProcGetResult((intptr_t)pvSubmitWorker, &iExitCode, &iSignal) == 0)
1702	{
1703	pChild->iExitCode = iExitCode;
1704	pChild->iSignal = iSignal;
1705	/* Cleanup must be done on the main thread. */
1706	return;
1707	}
1708
1709	if (pChild->iSignal != 0)
1710	kSubmitSubProcKill((intptr_t)pvSubmitWorker, pChild->iSignal);
1711	}
1712	}
1713
1714	/**
1715	* Childcare worker: handle kmk_redirect process.
1716	*
1717	* @param pWorker The worker.
1718	* @param pChild The redirect child.
1719	*/
1720	static void mkWinChildcareWorkerThreadHandleRedirect(PWINCHILDCAREWORKER pWorker, PWINCHILD pChild)
1721	{
1722	mkWinChildcareWorkerWaitForProcess(pWorker, pChild, pChild->u.Redirect.hProcess);
1723	}
1724
1725	#endif /* KMK */
1726
1727	/**
1728	* Childcare worker thread.
1729	*
1730	* @returns 0
1731	* @param pvUser The worker instance.
1732	*/
1733	static unsigned int __stdcall mkWinChildcareWorkerThread(void *pvUser)
1734	{
1735	PWINCHILDCAREWORKER pWorker = (PWINCHILDCAREWORKER)pvUser;
1736	assert(pWorker->uMagic == WINCHILDCAREWORKER_MAGIC);
1737
1738	/*
1739	* Adjust process group if necessary.
1740	*/
1741	if (g_cProcessorGroups > 1)
1742	{
1743	GROUP_AFFINITY Affinity = { ~(ULONG_PTR)0, pWorker->iProcessorGroup, { 0, 0, 0 } };
1744	BOOL fRet = g_pfnSetThreadGroupAffinity(GetCurrentThread(), &Affinity, NULL);
1745	assert(fRet); (void)fRet;
1746	}
1747
1748	/*
1749	* Work loop.
1750	*/
1751	while (!g_fShutdown)
1752	{
1753	/*
1754	* Try go idle.
1755	*/
1756	PWINCHILD pChild = pWorker->pTailTodoChildren;
1757	if (!pChild)
1758	{
1759	_InterlockedExchange(&pWorker->fIdle, TRUE);
1760	pChild = pWorker->pTailTodoChildren;
1761	if (!pChild)
1762	{
1763	DWORD dwStatus;
1764
1765	_InterlockedIncrement((long *)&g_cIdleChildcareWorkers);
1766	dwStatus = WaitForSingleObject(pWorker->hEvtIdle, INFINITE);
1767	_InterlockedExchange(&pWorker->fIdle, FALSE);
1768	_InterlockedDecrement((long *)&g_cIdleChildcareWorkers);
1769
1770	assert(dwStatus != WAIT_FAILED);
1771	if (dwStatus == WAIT_FAILED)
1772	Sleep(20);
1773
1774	pChild = pWorker->pTailTodoChildren;
1775	}
1776	else
1777	_InterlockedExchange(&pWorker->fIdle, FALSE);
1778	}
1779	if (pChild)
1780	{
1781	/*
1782	* We got work to do. First job is to deque the job.
1783	*/
1784	pChild = mkWinChildDequeFromLifo(&pWorker->pTailTodoChildren, pChild);
1785	assert(pChild);
1786	if (pChild)
1787	{
1788	PWINCHILD pTailExpect;
1789
1790	switch (pChild->enmType)
1791	{
1792	case WINCHILDTYPE_PROCESS:
1793	mkWinChildcareWorkerThreadHandleProcess(pWorker, pChild);
1794	break;
1795	#ifdef KMK
1796	case WINCHILDTYPE_BUILT_IN:
1797	mkWinChildcareWorkerThreadHandleBuiltIn(pWorker, pChild);
1798	break;
1799	case WINCHILDTYPE_APPEND:
1800	mkWinChildcareWorkerThreadHandleAppend(pWorker, pChild);
1801	break;
1802	case WINCHILDTYPE_SUBMIT:
1803	mkWinChildcareWorkerThreadHandleSubmit(pWorker, pChild);
1804	break;
1805	case WINCHILDTYPE_REDIRECT:
1806	mkWinChildcareWorkerThreadHandleRedirect(pWorker, pChild);
1807	break;
1808	#endif
1809	default:
1810	assert(0);
1811	}
1812
1813	/*
1814	* Move the child to the completed list.
1815	*/
1816	pTailExpect = NULL;
1817	for (;;)
1818	{
1819	PWINCHILD pTailActual;
1820	pChild->pNext = pTailExpect;
1821	pTailActual = _InterlockedCompareExchangePointer(&g_pTailCompletedChildren, pChild, pTailExpect);
1822	if (pTailActual != pTailExpect)
1823	pTailExpect = pTailActual;
1824	else
1825	{
1826	_InterlockedDecrement(&g_cPendingChildren);
1827	if (pTailExpect)
1828	break;
1829	if (SetEvent(g_hEvtWaitChildren))
1830	break;
1831	fprintf(stderr, "SetEvent(g_hEvtWaitChildren=%p) failed: %u\n", g_hEvtWaitChildren, GetLastError());
1832	break;
1833	}
1834	}
1835	}
1836	}
1837	}
1838
1839	_endthreadex(0);
1840	return 0;
1841	}
1842
1843	/**
1844	* Creates another childcare worker.
1845	*
1846	* @returns The new worker, if we succeeded.
1847	*/
1848	static PWINCHILDCAREWORKER mkWinChildcareCreateWorker(void)
1849	{
1850	PWINCHILDCAREWORKER pWorker = (PWINCHILDCAREWORKER)xcalloc(sizeof(*pWorker));
1851	pWorker->uMagic = WINCHILDCAREWORKER_MAGIC;
1852	pWorker->hEvtIdle = CreateEvent(NULL, FALSE /fManualReset/, FALSE /fInitialState/, NULL /pszName/);
1853	if (pWorker->hEvtIdle)
1854	{
1855	/* Before we start the thread, assign it to a processor group. */
1856	if (g_cProcessorGroups > 1)
1857	{
1858	unsigned int cMaxInGroup;
1859	unsigned int cInGroup;
1860	unsigned int iGroup = g_idxProcessorGroupAllocator % g_cProcessorGroups;
1861	pWorker->iProcessorGroup = iGroup;
1862
1863	/* Advance. We employ a very simple strategy that does 50% in
1864	each group for each group cycle. Odd processor counts are
1865	caught in odd group cycles. The init function selects the
1866	starting group based on make nesting level to avoid stressing
1867	out the first group. */
1868	cInGroup = ++g_idxProcessorInGroupAllocator;
1869	cMaxInGroup = g_pacProcessorsInGroup[iGroup];
1870	if ( !(cMaxInGroup & 1)
1871	\|\| !((g_idxProcessorGroupAllocator / g_cProcessorGroups) & 1))
1872	cMaxInGroup /= 2;
1873	else
1874	cMaxInGroup = cMaxInGroup / 2 + 1;
1875	if (cInGroup >= cMaxInGroup)
1876	{
1877	g_idxProcessorInGroupAllocator = 0;
1878	g_idxProcessorGroupAllocator++;
1879	}
1880	}
1881
1882	/* Try start the thread. */
1883	pWorker->hThread = (HANDLE)_beginthreadex(NULL, 0 /cbStack/, mkWinChildcareWorkerThread, pWorker,
1884	0, &pWorker->tid);
1885	if (pWorker->hThread != NULL)
1886	{
1887	g_papChildCareworkers[g_cChildCareworkers++] = pWorker;
1888	return pWorker;
1889	}
1890	CloseHandle(pWorker->hEvtIdle);
1891	}
1892	pWorker->uMagic = ~WINCHILDCAREWORKER_MAGIC;
1893	free(pWorker);
1894	return NULL;
1895	}
1896
1897	/**
1898	* Helper for copying argument and environment vectors.
1899	*
1900	* @returns Single alloc block copy.
1901	* @param papszSrc The source vector.
1902	* @param pcbStrings Where to return the size of the strings & terminator.
1903	*/
1904	static char mkWinChildCopyStringArray(char papszSrc, size_t *pcbStrings)
1905	{
1906	const char *psz;
1907	char **papszDstArray;
1908	char *pszDstStr;
1909	size_t i;
1910
1911	/* Calc sizes first. */
1912	size_t cbStrings = 1; /* (one extra for terminator string) */
1913	size_t cStrings = 0;
1914	while ((psz = papszSrc[cStrings]) != NULL)
1915	{
1916	cbStrings += strlen(psz) + 1;
1917	cStrings++;
1918	}
1919	*pcbStrings = cbStrings;
1920
1921	/* Allocate destination. */
1922	papszDstArray = (char *)xmalloc(cbStrings + (cStrings + 1) sizeof(papszDstArray[0]));
1923	pszDstStr = (char *)&papszDstArray[cStrings + 1];
1924
1925	/* Copy it. */
1926	for (i = 0; i < cStrings; i++)
1927	{
1928	size_t cbString = strlen(papszSrc[i]) + 1;
1929	papszDstArray[i] = (char *)memcpy(pszDstStr, papszSrc[i], cbString);
1930	pszDstStr += cbString;
1931	}
1932	*pszDstStr = '\0';
1933	assert(&pszDstStr[1] - papszDstArray[0] == cbStrings);
1934	papszDstArray[i] = NULL;
1935	return papszDstArray;
1936	}
1937
1938	/**
1939	* Allocate and init a WINCHILD.
1940	*
1941	* @returns The new windows child structure.
1942	* @param enmType The child type.
1943	*/
1944	static PWINCHILD mkWinChildNew(WINCHILDTYPE enmType)
1945	{
1946	PWINCHILD pChild = xcalloc(sizeof(*pChild));
1947	pChild->enmType = enmType;
1948	pChild->fCoreDumped = 0;
1949	pChild->iSignal = 0;
1950	pChild->iExitCode = 222222;
1951	pChild->uMagic = WINCHILD_MAGIC;
1952	pChild->pid = (intptr_t)pChild;
1953	return pChild;
1954	}
1955
1956	/**
1957	* Destructor for WINCHILD.
1958	*
1959	* @param pChild The child structure to destroy.
1960	*/
1961	static void mkWinChildDelete(PWINCHILD pChild)
1962	{
1963	assert(pChild->uMagic == WINCHILD_MAGIC);
1964	pChild->uMagic = ~WINCHILD_MAGIC;
1965
1966	switch (pChild->enmType)
1967	{
1968	case WINCHILDTYPE_PROCESS:
1969	{
1970	if (pChild->u.Process.papszArgs)
1971	{
1972	free(pChild->u.Process.papszArgs);
1973	pChild->u.Process.papszArgs = NULL;
1974	}
1975	if (pChild->u.Process.cbEnvStrings && pChild->u.Process.papszEnv)
1976	{
1977	free(pChild->u.Process.papszEnv);
1978	pChild->u.Process.papszEnv = NULL;
1979	}
1980	if (pChild->u.Process.pszShell)
1981	{
1982	free(pChild->u.Process.pszShell);
1983	pChild->u.Process.pszShell = NULL;
1984	}
1985	if (pChild->u.Process.hProcess)
1986	{
1987	CloseHandle(pChild->u.Process.hProcess);
1988	pChild->u.Process.hProcess = NULL;
1989	}
1990	mkWinChildcareWorkerCloseStandardHandles(pChild);
1991	break;
1992	}
1993
1994	#ifdef KMK
1995	case WINCHILDTYPE_BUILT_IN:
1996	if (pChild->u.BuiltIn.papszArgs)
1997	{
1998	free(pChild->u.BuiltIn.papszArgs);
1999	pChild->u.BuiltIn.papszArgs = NULL;
2000	}
2001	if (pChild->u.BuiltIn.papszEnv)
2002	{
2003	free(pChild->u.BuiltIn.papszEnv);
2004	pChild->u.BuiltIn.papszEnv = NULL;
2005	}
2006	break;
2007
2008	case WINCHILDTYPE_APPEND:
2009	if (pChild->u.Append.pszFilename)
2010	{
2011	free(pChild->u.Append.pszFilename);
2012	pChild->u.Append.pszFilename = NULL;
2013	}
2014	if (pChild->u.Append.pszAppend)
2015	{
2016	free(pChild->u.Append.pszAppend);
2017	pChild->u.Append.pszAppend = NULL;
2018	}
2019	break;
2020
2021	case WINCHILDTYPE_SUBMIT:
2022	if (pChild->u.Submit.pvSubmitWorker)
2023	{
2024	kSubmitSubProcCleanup((intptr_t)pChild->u.Submit.pvSubmitWorker);
2025	pChild->u.Submit.pvSubmitWorker = NULL;
2026	}
2027	break;
2028
2029	case WINCHILDTYPE_REDIRECT:
2030	if (pChild->u.Redirect.hProcess)
2031	{
2032	CloseHandle(pChild->u.Redirect.hProcess);
2033	pChild->u.Redirect.hProcess = NULL;
2034	}
2035	break;
2036	#endif /* KMK */
2037
2038	default:
2039	assert(0);
2040	}
2041
2042	free(pChild);
2043	}
2044
2045	/**
2046	* Queues the child with a worker, creating new workers if necessary.
2047	*
2048	* @returns 0 on success, windows error code on failure (child destroyed).
2049	* @param pChild The child.
2050	* @param pPid Where to return the PID (optional).
2051	*/
2052	static int mkWinChildPushToCareWorker(PWINCHILD pChild, pid_t *pPid)
2053	{
2054	PWINCHILDCAREWORKER pWorker = NULL;
2055	PWINCHILD pOldChild;
2056	PWINCHILD pCurChild;
2057
2058	/*
2059	* There are usually idle workers around, except for at the start.
2060	*/
2061	if (g_cIdleChildcareWorkers > 0)
2062	{
2063	/*
2064	* Try the idle hint first and move forward from it.
2065	*/
2066	unsigned int const cWorkers = g_cChildCareworkers;
2067	unsigned int iHint = g_idxLastChildcareWorker;
2068	unsigned int i;
2069	for (i = iHint; i < cWorkers; i++)
2070	{
2071	PWINCHILDCAREWORKER pPossibleWorker = g_papChildCareworkers[i];
2072	if (pPossibleWorker->fIdle)
2073	{
2074	pWorker = pPossibleWorker;
2075	break;
2076	}
2077	}
2078	if (!pWorker)
2079	{
2080	/* Scan from the start. */
2081	if (iHint > cWorkers)
2082	iHint = cWorkers;
2083	for (i = 0; i < iHint; i++)
2084	{
2085	PWINCHILDCAREWORKER pPossibleWorker = g_papChildCareworkers[i];
2086	if (pPossibleWorker->fIdle)
2087	{
2088	pWorker = pPossibleWorker;
2089	break;
2090	}
2091	}
2092	}
2093	}
2094	if (!pWorker)
2095	{
2096	/*
2097	* Try create more workers if we haven't reached the max yet.
2098	*/
2099	if (g_cChildCareworkers < g_cChildCareworkersMax)
2100	pWorker = mkWinChildcareCreateWorker();
2101
2102	/*
2103	* Queue it with an existing worker. Look for one without anthing extra scheduled.
2104	*/
2105	if (!pWorker)
2106	{
2107	unsigned int i = g_cChildCareworkers;
2108	if (i == 0)
2109	fatal(NILF, 0, _("Failed to create worker threads for managing child processes!\n"));
2110	pWorker = g_papChildCareworkers[--i];
2111	if (pWorker->pTailTodoChildren)
2112	while (i-- > 0)
2113	{
2114	PWINCHILDCAREWORKER pPossibleWorker = g_papChildCareworkers[i];
2115	if (!pPossibleWorker->pTailTodoChildren)
2116	{
2117	pWorker = pPossibleWorker;
2118	break;
2119	}
2120	}
2121	}
2122	}
2123
2124	/*
2125	* Do the queueing.
2126	*/
2127	pOldChild = NULL;
2128	for (;;)
2129	{
2130	pChild->pNext = pOldChild;
2131	pCurChild = _InterlockedCompareExchangePointer((void **)&pWorker->pTailTodoChildren, pChild, pOldChild);
2132	if (pCurChild == pOldChild)
2133	{
2134	DWORD volatile dwErr;
2135	_InterlockedIncrement(&g_cPendingChildren);
2136	if ( !pWorker->fIdle
2137	\|\| SetEvent(pWorker->hEvtIdle))
2138	{
2139	*pPid = pChild->pid;
2140	return 0;
2141	}
2142
2143	_InterlockedDecrement(&g_cPendingChildren);
2144	dwErr = GetLastError();
2145	assert(0);
2146	mkWinChildDelete(pChild);
2147	return dwErr ? dwErr : -1;
2148	}
2149	pOldChild = pCurChild;
2150	}
2151	}
2152
2153	/**
2154	* Creates a regular child process (job.c).
2155	*
2156	* Will copy the information and push it to a childcare thread that does the
2157	* actual process creation.
2158	*
2159	* @returns 0 on success, windows status code on failure.
2160	* @param papszArgs The arguments.
2161	* @param papszEnv The environment (optional).
2162	* @param pszShell The SHELL variable value (optional).
2163	* @param pMkChild The make child structure (optional).
2164	* @param pPid Where to return the pid.
2165	*/
2166	int MkWinChildCreate(char papszArgs, char papszEnv, const char pszShell, struct child pMkChild, pid_t *pPid)
2167	{
2168	PWINCHILD pChild = mkWinChildNew(WINCHILDTYPE_PROCESS);
2169	pChild->pMkChild = pMkChild;
2170
2171	pChild->u.Process.papszArgs = mkWinChildCopyStringArray(papszArgs, &pChild->u.Process.cbArgsStrings);
2172	if ( !papszEnv
2173	\|\| !pMkChild
2174	\|\| pMkChild->environment == papszEnv)
2175	{
2176	pChild->u.Process.cbEnvStrings = 0;
2177	pChild->u.Process.papszEnv = papszEnv;
2178	}
2179	else
2180	pChild->u.Process.papszEnv = mkWinChildCopyStringArray(papszEnv, &pChild->u.Process.cbEnvStrings);
2181	if (pszShell)
2182	pChild->u.Process.pszShell = xstrdup(pszShell);
2183	pChild->u.Process.hStdOut = INVALID_HANDLE_VALUE;
2184	pChild->u.Process.hStdErr = INVALID_HANDLE_VALUE;
2185
2186	return mkWinChildPushToCareWorker(pChild, pPid);
2187	}
2188
2189	/**
2190	* Creates a chile process with a pipe hooked up to stdout.
2191	*
2192	* @returns 0 on success, non-zero on failure.
2193	* @param papszArgs The argument vector.
2194	* @param papszEnv The environment vector (optional).
2195	* @param fdErr File descriptor to hook up to stderr.
2196	* @param pPid Where to return the pid.
2197	* @param pfdReadPipe Where to return the read end of the pipe.
2198	*/
2199	int MkWinChildCreateWithStdOutPipe(char papszArgs, char papszEnv, int fdErr, pid_t pPid, int pfdReadPipe)
2200	{
2201	/*
2202	* Create the pipe.
2203	*/
2204	HANDLE hReadPipe;
2205	HANDLE hWritePipe;
2206	if (CreatePipe(&hReadPipe, &hWritePipe, NULL, 0 /* default size */))
2207	{
2208	if (SetHandleInformation(hWritePipe, HANDLE_FLAG_INHERIT /* clear / , HANDLE_FLAG_INHERIT /set*/))
2209	{
2210	int fdReadPipe = _open_osfhandle((intptr_t)hReadPipe, O_RDONLY);
2211	if (fdReadPipe >= 0)
2212	{
2213	PWINCHILD pChild;
2214	int rc;
2215
2216	/*
2217	* Get a handle for fdErr. Ignore failure.
2218	*/
2219	HANDLE hStdErr = INVALID_HANDLE_VALUE;
2220	if (fdErr >= 0)
2221	{
2222	HANDLE hNative = (HANDLE)_get_osfhandle(fdErr);
2223	if (!DuplicateHandle(GetCurrentProcess(), hNative, GetCurrentProcess(),
2224	&hStdErr, 0 /DesiredAccess/, TRUE /fInherit/, DUPLICATE_SAME_ACCESS))
2225	{
2226	ONN(error, NILF, _("DuplicateHandle failed on stderr descriptor (%u): %u\n"), fdErr, GetLastError());
2227	hStdErr = INVALID_HANDLE_VALUE;
2228	}
2229	}
2230
2231	/*
2232	* Push it off to the worker thread.
2233	*/
2234	pChild = mkWinChildNew(WINCHILDTYPE_PROCESS);
2235	pChild->u.Process.papszArgs = mkWinChildCopyStringArray(papszArgs, &pChild->u.Process.cbArgsStrings);
2236	pChild->u.Process.papszEnv = mkWinChildCopyStringArray(papszEnv ? papszEnv : environ,
2237	&pChild->u.Process.cbEnvStrings);
2238	//if (pszShell)
2239	// pChild->u.Process.pszShell = xstrdup(pszShell);
2240	pChild->u.Process.hStdOut = hWritePipe;
2241	pChild->u.Process.hStdErr = hStdErr;
2242	pChild->u.Process.fCloseStdErr = TRUE;
2243	pChild->u.Process.fCloseStdOut = TRUE;
2244
2245	rc = mkWinChildPushToCareWorker(pChild, pPid);
2246	if (rc == 0)
2247	*pfdReadPipe = fdReadPipe;
2248	else
2249	{
2250	ON(error, NILF, _("mkWinChildPushToCareWorker failed on pipe: %d\n"), rc);
2251	close(fdReadPipe);
2252	*pfdReadPipe = -1;
2253	*pPid = -1;
2254	}
2255	return rc;
2256	}
2257
2258	ON(error, NILF, _("_open_osfhandle failed on pipe: %u\n"), errno);
2259	}
2260	else
2261	ON(error, NILF, _("SetHandleInformation failed on pipe: %u\n"), GetLastError());
2262	if (hReadPipe != INVALID_HANDLE_VALUE)
2263	CloseHandle(hReadPipe);
2264	CloseHandle(hWritePipe);
2265	}
2266	else
2267	ON(error, NILF, _("CreatePipe failed: %u\n"), GetLastError());
2268	*pfdReadPipe = -1;
2269	*pPid = -1;
2270	return -1;
2271	}
2272
2273	#ifdef KMK
2274
2275	/**
2276	* Interface used by kmkbuiltin.c for executing builtin commands on threads.
2277	*
2278	* @returns 0 on success, windows status code on failure.
2279	* @param pBuiltIn The kmk built-in command entry.
2280	* @param cArgs The number of arguments in papszArgs.
2281	* @param papszArgs The argument vector.
2282	* @param papszEnv The environment vector, optional.
2283	* @param pMkChild The make child structure.
2284	* @param pPid Where to return the pid.
2285	*/
2286	int MkWinChildCreateBuiltIn(PCKMKBUILTINENTRY pBuiltIn, int cArgs, char papszArgs, char papszEnv,
2287	struct child pMkChild, pid_t pPid)
2288	{
2289	size_t cbIgnored;
2290	PWINCHILD pChild = mkWinChildNew(WINCHILDTYPE_BUILT_IN);
2291	pChild->pMkChild = pMkChild;
2292	pChild->u.BuiltIn.pBuiltIn = pBuiltIn;
2293	pChild->u.BuiltIn.cArgs = cArgs;
2294	pChild->u.BuiltIn.papszArgs = mkWinChildCopyStringArray(papszArgs, &cbIgnored);
2295	pChild->u.BuiltIn.papszEnv = papszEnv ? mkWinChildCopyStringArray(papszEnv, &cbIgnored) : NULL;
2296	return mkWinChildPushToCareWorker(pChild, pPid);
2297	}
2298
2299	/**
2300	* Interface used by append.c for do the slow file system part.
2301	*
2302	* This will append the given buffer to the specified file and free the buffer.
2303	*
2304	* @returns 0 on success, windows status code on failure.
2305	*
2306	* @param pszFilename The name of the file to append to.
2307	* @param ppszAppend What to append. The pointer pointed to is set to
2308	* NULL once we've taken ownership of the buffer and
2309	* promise to free it.
2310	* @param cbAppend How much to append.
2311	* @param fTruncate Whether to truncate the file before appending to it.
2312	* @param pMkChild The make child structure.
2313	* @param pPid Where to return the pid.
2314	*/
2315	int MkWinChildCreateAppend(const char pszFilename, char *ppszAppend, size_t cbAppend, int fTruncate,
2316	struct child pMkChild, pid_t pPid)
2317	{
2318	size_t cbFilename = strlen(pszFilename) + 1;
2319	PWINCHILD pChild = mkWinChildNew(WINCHILDTYPE_APPEND);
2320	pChild->pMkChild = pMkChild;
2321	pChild->u.Append.fTruncate = fTruncate;
2322	pChild->u.Append.pszAppend = *ppszAppend;
2323	pChild->u.Append.cbAppend = cbAppend;
2324	pChild->u.Append.pszFilename = (char *)memcpy(xmalloc(cbFilename), pszFilename, cbFilename);
2325	*ppszAppend = NULL;
2326	return mkWinChildPushToCareWorker(pChild, pPid);
2327	}
2328
2329	/**
2330	* Interface used by kSubmit.c for registering stuff to wait on.
2331	*
2332	* @returns 0 on success, windows status code on failure.
2333	* @param hEvent The event object handle to wait on.
2334	* @param pvSubmitWorker The argument to pass back to kSubmit to clean up.
2335	* @param pPid Where to return the pid.
2336	*/
2337	int MkWinChildCreateSubmit(intptr_t hEvent, void pvSubmitWorker, pid_t pPid)
2338	{
2339	PWINCHILD pChild = mkWinChildNew(WINCHILDTYPE_SUBMIT);
2340	pChild->u.Submit.hEvent = (HANDLE)hEvent;
2341	pChild->u.Submit.pvSubmitWorker = pvSubmitWorker;
2342	return mkWinChildPushToCareWorker(pChild, pPid);
2343	}
2344
2345	/**
2346	* Interface used by redirect.c for registering stuff to wait on.
2347	*
2348	* @returns 0 on success, windows status code on failure.
2349	* @param hProcess The process object to wait on.
2350	* @param pPid Where to return the pid.
2351	*/
2352	int MkWinChildCreateRedirect(intptr_t hProcess, pid_t *pPid)
2353	{
2354	PWINCHILD pChild = mkWinChildNew(WINCHILDTYPE_REDIRECT);
2355	pChild->u.Redirect.hProcess = (HANDLE)hProcess;
2356	return mkWinChildPushToCareWorker(pChild, pPid);
2357	}
2358
2359	#endif /* CONFIG_NEW_WIN_CHILDREN */
2360
2361	/**
2362	* Interface used to kill process when processing Ctrl-C and fatal errors.
2363	*
2364	* @returns 0 on success, -1+errno on error.
2365	* @param pid The process to kill (PWINCHILD).
2366	* @param iSignal What to kill it with.
2367	* @param pMkChild The make child structure for validation.
2368	*/
2369	int MkWinChildKill(pid_t pid, int iSignal, struct child *pMkChild)
2370	{
2371	PWINCHILD pChild = (PWINCHILD)pid;
2372	if (pChild)
2373	{
2374	assert(pChild->uMagic == WINCHILD_MAGIC);
2375	if (pChild->uMagic == WINCHILD_MAGIC)
2376	{
2377	switch (pChild->enmType)
2378	{
2379	case WINCHILDTYPE_PROCESS:
2380	assert(pChild->pMkChild == pMkChild);
2381	TerminateProcess(pChild->u.Process.hProcess, DBG_TERMINATE_PROCESS);
2382	pChild->iSignal = iSignal;
2383	break;
2384	#ifdef KMK
2385	case WINCHILDTYPE_SUBMIT:
2386	{
2387	pChild->iSignal = iSignal;
2388	SetEvent(pChild->u.Submit.hEvent);
2389	break;
2390	}
2391
2392	case WINCHILDTYPE_REDIRECT:
2393	TerminateProcess(pChild->u.Redirect.hProcess, DBG_TERMINATE_PROCESS);
2394	pChild->iSignal = iSignal;
2395	break;
2396
2397	case WINCHILDTYPE_BUILT_IN:
2398	break;
2399
2400	#endif /* KMK */
2401	default:
2402	assert(0);
2403	}
2404	}
2405	}
2406	return -1;
2407	}
2408
2409	/**
2410	* Wait for a child process to complete
2411	*
2412	* @returns 0 on success, windows error code on failure.
2413	* @param fBlock Whether to block.
2414	* @param pPid Where to return the pid if a child process
2415	* completed. This is set to zero if none.
2416	* @param piExitCode Where to return the exit code.
2417	* @param piSignal Where to return the exit signal number.
2418	* @param pfCoreDumped Where to return the core dumped indicator.
2419	* @param ppMkChild Where to return the associated struct child pointer.
2420	*/
2421	int MkWinChildWait(int fBlock, pid_t pPid, int piExitCode, int piSignal, int pfCoreDumped, struct child **ppMkChild)
2422	{
2423	PWINCHILD pChild;
2424
2425	*pPid = 0;
2426	*piExitCode = -222222;
2427	*pfCoreDumped = 0;
2428	*ppMkChild = NULL;
2429
2430	/*
2431	* Wait if necessary.
2432	*/
2433	if (fBlock && !g_pTailCompletedChildren && g_cPendingChildren > 0)
2434	{
2435	DWORD dwStatus = WaitForSingleObject(g_hEvtWaitChildren, INFINITE);
2436	if (dwStatus == WAIT_FAILED)
2437	return (int)GetLastError();
2438	}
2439
2440	/*
2441	* Try unlink the last child in the LIFO.
2442	*/
2443	pChild = g_pTailCompletedChildren;
2444	if (!pChild)
2445	return 0;
2446	pChild = mkWinChildDequeFromLifo(&g_pTailCompletedChildren, pChild);
2447	assert(pChild);
2448
2449	/*
2450	* Set return values and ditch the child structure.
2451	*/
2452	*pPid = pChild->pid;
2453	*piExitCode = pChild->iExitCode;
2454	*pfCoreDumped = pChild->fCoreDumped;
2455	*ppMkChild = pChild->pMkChild;
2456	switch (pChild->enmType)
2457	{
2458	case WINCHILDTYPE_PROCESS:
2459	break;
2460	#ifdef KMK
2461	case WINCHILDTYPE_BUILT_IN:
2462	case WINCHILDTYPE_APPEND:
2463	case WINCHILDTYPE_SUBMIT:
2464	case WINCHILDTYPE_REDIRECT:
2465	break;
2466	#endif /* KMK */
2467	default:
2468	assert(0);
2469	}
2470	mkWinChildDelete(pChild);
2471
2472	#ifdef KMK
2473	/* Flush the volatile directory cache. */
2474	dir_cache_invalid_after_job();
2475	#endif
2476	return 0;
2477	}
2478
2479	/**
2480	* Get the child completed event handle.
2481	*
2482	* Needed when w32os.c is waiting for a job token to become available, given
2483	* that completed children is the typical source of these tokens (esp. for kmk).
2484	*
2485	* @returns Zero if completed children, event handle if waiting is required.
2486	*/
2487	intptr_t MkWinChildGetCompleteEventHandle(void)
2488	{
2489	/* We don't return the handle if we've got completed children. This
2490	is a safe guard against being called twice in a row without any
2491	MkWinChildWait call inbetween. */
2492	if (!g_pTailCompletedChildren)
2493	return (intptr_t)g_hEvtWaitChildren;
2494	return 0;
2495	}
2496
2497	/**
2498	* Emulate execv() for restarting kmk after one ore more makefiles has been
2499	* made.
2500	*
2501	* Does not return.
2502	*
2503	* @param papszArgs The arguments.
2504	* @param papszEnv The environment.
2505	*/
2506	void MkWinChildReExecMake(char papszArgs, char papszEnv)
2507	{
2508	PROCESS_INFORMATION ProcInfo;
2509	STARTUPINFOW StartupInfo;
2510	WCHAR *pwszCommandLine;
2511	WCHAR *pwszzEnvironment;
2512	WCHAR *pwszPathIgnored;
2513	int rc;
2514
2515	/*
2516	* Get the executable name.
2517	*/
2518	WCHAR wszImageName[MKWINCHILD_MAX_PATH];
2519	DWORD cwcImageName = GetModuleFileNameW(GetModuleHandle(NULL), wszImageName, MKWINCHILD_MAX_PATH);
2520	if (cwcImageName == 0)
2521	ON(fatal, NILF, _("MkWinChildReExecMake: GetModuleFileName failed: %u\n"), GetLastError());
2522
2523	/*
2524	* Create the command line and environment.
2525	*/
2526	rc = mkWinChildcareWorkerConvertCommandline(papszArgs, 0 /fFlags/, &pwszCommandLine);
2527	if (rc != 0)
2528	ON(fatal, NILF, _("MkWinChildReExecMake: mkWinChildcareWorkerConvertCommandline failed: %u\n"), rc);
2529
2530	rc = mkWinChildcareWorkerConvertEnvironment(papszEnv ? papszEnv : environ, 0 /cbEnvStrings/,
2531	&pwszzEnvironment, &pwszPathIgnored);
2532	if (rc != 0)
2533	ON(fatal, NILF, _("MkWinChildReExecMake: mkWinChildcareWorkerConvertEnvironment failed: %u\n"), rc);
2534
2535
2536	/*
2537	* Fill out the startup info and try create the process.
2538	*/
2539	memset(&ProcInfo, 0, sizeof(ProcInfo));
2540	memset(&StartupInfo, 0, sizeof(StartupInfo));
2541	StartupInfo.cb = sizeof(StartupInfo);
2542	GetStartupInfoW(&StartupInfo);
2543	if (!CreateProcessW(wszImageName, pwszCommandLine, NULL /pProcSecAttr/, NULL /pThreadSecAttr/,
2544	TRUE /fInheritHandles/, CREATE_UNICODE_ENVIRONMENT, pwszzEnvironment, NULL /pwsz/,
2545	&StartupInfo, &ProcInfo))
2546	ON(fatal, NILF, _("MkWinChildReExecMake: CreateProcessW failed: %u\n"), GetLastError());
2547	CloseHandle(ProcInfo.hThread);
2548
2549	/*
2550	* Wait for it to complete and forward the status code to our parent.
2551	*/
2552	for (;;)
2553	{
2554	DWORD dwExitCode = -2222;
2555	DWORD dwStatus = WaitForSingleObject(ProcInfo.hProcess, INFINITE);
2556	if ( dwStatus == WAIT_IO_COMPLETION
2557	\|\| dwStatus == WAIT_TIMEOUT /* whatever */)
2558	continue; /* however unlikely, these aren't fatal. */
2559
2560	/* Get the status code and terminate. */
2561	if (dwStatus == WAIT_OBJECT_0)
2562	{
2563	if (!GetExitCodeProcess(ProcInfo.hProcess, &dwExitCode))
2564	{
2565	ON(fatal, NILF, _("MkWinChildReExecMake: GetExitCodeProcess failed: %u\n"), GetLastError());
2566	dwExitCode = -2222;
2567	}
2568	}
2569	else if (dwStatus)
2570	dwExitCode = dwStatus;
2571
2572	CloseHandle(ProcInfo.hProcess);
2573	for (;;)
2574	exit(dwExitCode);
2575	}
2576	}
2577
2578	#ifdef WITH_RW_LOCK
2579	/** Serialization with kmkbuiltin_redirect. */
2580	void MkWinChildExclusiveAcquire(void)
2581	{
2582	AcquireSRWLockExclusive(&g_RWLock);
2583	}
2584
2585	/** Serialization with kmkbuiltin_redirect. */
2586	void MkWinChildExclusiveRelease(void)
2587	{
2588	ReleaseSRWLockExclusive(&g_RWLock);
2589	}
2590	#endif /* WITH_RW_LOCK */
2591
2592	/**
2593	* Implementation of the CLOSE_ON_EXEC macro.
2594	*
2595	* @returns errno value.
2596	* @param fd The file descriptor to hide from children.
2597	*/
2598	int MkWinChildUnrelatedCloseOnExec(int fd)
2599	{
2600	if (fd >= 0)
2601	{
2602	HANDLE hNative = (HANDLE)_get_osfhandle(fd);
2603	if (hNative != INVALID_HANDLE_VALUE && hNative != NULL)
2604	{
2605	if (SetHandleInformation(hNative, HANDLE_FLAG_INHERIT /clear/ , 0 /set/))
2606	return 0;
2607	}
2608	return errno;
2609	}
2610	return EINVAL;
2611	}
2612

Note: See TracBrowser for help on using the repository browser.

Download in other formats: