kSubmit.c@ 2856

Last change on this file since 2856 was 2846, checked in by bird, 9 years ago
fixes
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 51.5 KB

Line
1	/* $Id: kSubmit.c 2846 2016-08-30 12:48:33Z bird $ */
2	/** @file
3	* kMk Builtin command - submit job to a kWorker.
4	*/
5
6	/*
7	* Copyright (c) 2007-2016 knut st. osmundsen <[email protected]>
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	/*******************************************************************************
27	* Header Files *
28	*******************************************************************************/
29	#ifdef __APPLE__
30	# define _POSIX_C_SOURCE 1 /* 10.4 sdk and unsetenv */
31	#endif
32	#include "make.h"
33	#include "job.h"
34	#include "variable.h"
35	#include "pathstuff.h"
36	#include <stdio.h>
37	#include <stdlib.h>
38	#include <string.h>
39	#include <errno.h>
40	#include <assert.h>
41	#ifdef HAVE_ALLOCA_H
42	# include <alloca.h>
43	#endif
44	#if defined(_MSC_VER)
45	# include <ctype.h>
46	# include <io.h>
47	# include <direct.h>
48	# include <process.h>
49	#else
50	# include <unistd.h>
51	#endif
52	#ifdef KBUILD_OS_WINDOWS
53	# include "sub_proc.h"
54	# include "quote_argv.h"
55	#endif
56
57	#include "kbuild.h"
58	#include "kmkbuiltin.h"
59	#include "err.h"
60
61
62	/*********************************************************************************************************************************
63	* Defined Constants And Macros *
64	*********************************************************************************************************************************/
65	/** Hashes a pid. */
66	#define KWORKER_PID_HASH(a_pid) ((size_t)(a_pid) % 61)
67
68
69	/*********************************************************************************************************************************
70	* Structures and Typedefs *
71	*********************************************************************************************************************************/
72	typedef struct WORKERINSTANCE *PWORKERINSTANCE;
73	typedef struct WORKERINSTANCE
74	{
75	/** Pointer to the next worker instance. */
76	PWORKERINSTANCE pNext;
77	/** Pointer to the previous worker instance. */
78	PWORKERINSTANCE pPrev;
79	/** Pointer to the next worker with the same pid hash slot. */
80	PWORKERINSTANCE pNextPidHash;
81	/** 32 or 64. */
82	unsigned cBits;
83	/** The process ID of the kWorker process. */
84	pid_t pid;
85	union
86	{
87	struct
88	{
89	/** The exit code. */
90	int32_t rcExit;
91	/** Set to 1 if the worker is exiting. */
92	uint8_t bWorkerExiting;
93	uint8_t abUnused[3];
94	} s;
95	uint8_t ab[8];
96	} Result;
97	/** Number of result bytes read alread. */
98	size_t cbResultRead;
99
100	#ifdef KBUILD_OS_WINDOWS
101	/** The process handle. */
102	HANDLE hProcess;
103	/** The bi-directional pipe we use to talk to the kWorker process. */
104	HANDLE hPipe;
105	/** For overlapped read (have valid event semaphore). */
106	OVERLAPPED OverlappedRead;
107	#else
108	/** The socket descriptor we use to talk to the kWorker process. */
109	int fdSocket;
110	#endif
111
112	/** What it's busy with. NULL if idle. */
113	struct child *pBusyWith;
114	} WORKERINSTANCE;
115
116
117	typedef struct WORKERLIST
118	{
119	/** The head of the list. NULL if empty. */
120	PWORKERINSTANCE pHead;
121	/** The tail of the list. NULL if empty. */
122	PWORKERINSTANCE pTail;
123	/** Number of list entries. */
124	size_t cEntries;
125	} WORKERLIST;
126	typedef WORKERLIST *PWORKERLIST;
127
128
129	/*********************************************************************************************************************************
130	* Global Variables *
131	*********************************************************************************************************************************/
132	/** List of idle worker.*/
133	static WORKERLIST g_IdleList;
134	/** List of busy workers. */
135	static WORKERLIST g_BusyList;
136	/** PID hash table for the workers.
137	* @sa KWORKER_PID_HASH() */
138	static PWORKERINSTANCE g_apPidHash[61];
139
140	#ifdef KBUILD_OS_WINDOWS
141	/** For naming the pipes.
142	* Also indicates how many worker instances we've spawned. */
143	static unsigned g_uWorkerSeqNo = 0;
144	#endif
145	/** Set if we've registred the atexit handler already. */
146	static int g_fAtExitRegistered = 0;
147
148	/** @var g_cArchBits
149	* The bit count of the architecture this binary is compiled for. */
150	/** @var g_szArch
151	* The name of the architecture this binary is compiled for. */
152	/** @var g_cArchBits
153	* The bit count of the alternative architecture. */
154	/** @var g_szAltArch
155	* The name of the alternative architecture. */
156	#if defined(KBUILD_ARCH_AMD64)
157	static unsigned g_cArchBits = 64;
158	static char const g_szArch[] = "amd64";
159	static unsigned g_cAltArchBits = 32;
160	static char const g_szAltArch[] = "x86";
161	#elif defined(KBUILD_ARCH_X86)
162	static unsigned g_cArchBits = 32;
163	static char const g_szArch[] = "x86";
164	static unsigned g_cAltArchBits = 64;
165	static char const g_szAltArch[] = "amd64";
166	#else
167	# error "Port me!"
168	#endif
169
170
171
172	/**
173	* Unlinks a worker instance from a list.
174	*
175	* @param pList The list.
176	* @param pWorker The worker.
177	*/
178	static void kSubmitListUnlink(PWORKERLIST pList, PWORKERINSTANCE pWorker)
179	{
180	PWORKERINSTANCE pNext = pWorker->pNext;
181	PWORKERINSTANCE pPrev = pWorker->pPrev;
182
183	if (pNext)
184	{
185	assert(pNext->pPrev == pWorker);
186	pNext->pPrev = pPrev;
187	}
188	else
189	{
190	assert(pList->pTail == pWorker);
191	pList->pTail = pPrev;
192	}
193
194	if (pPrev)
195	{
196	assert(pPrev->pNext == pWorker);
197	pPrev->pNext = pNext;
198	}
199	else
200	{
201	assert(pList->pHead == pWorker);
202	pList->pHead = pNext;
203	}
204
205	assert(!pList->pHead \|\| pList->pHead->pPrev == NULL);
206	assert(!pList->pTail \|\| pList->pTail->pNext == NULL);
207
208	assert(pList->cEntries > 0);
209	pList->cEntries--;
210
211	pWorker->pNext = NULL;
212	pWorker->pPrev = NULL;
213	}
214
215
216	/**
217	* Appends a worker instance to the tail of a list.
218	*
219	* @param pList The list.
220	* @param pWorker The worker.
221	*/
222	static void kSubmitListAppend(PWORKERLIST pList, PWORKERINSTANCE pWorker)
223	{
224	PWORKERINSTANCE pTail = pList->pTail;
225
226	assert(pTail != pWorker);
227	assert(pList->pHead != pWorker);
228
229	pWorker->pNext = NULL;
230	pWorker->pPrev = pTail;
231	if (pTail != NULL)
232	{
233	assert(pTail->pNext == NULL);
234	pTail->pNext = pWorker;
235	}
236	else
237	{
238	assert(pList->pHead == NULL);
239	pList->pHead = pWorker;
240	}
241	pList->pTail = pWorker;
242
243	assert(pList->pHead->pPrev == NULL);
244	assert(pList->pTail->pNext == NULL);
245
246	pList->cEntries++;
247	}
248
249
250	/**
251	* Remove worker from the process ID hash table.
252	*
253	* @param pWorker The worker.
254	*/
255	static void kSubmitPidHashRemove(PWORKERINSTANCE pWorker)
256	{
257	size_t idxHash = KWORKER_PID_HASH(pWorker->pid);
258	if (g_apPidHash[idxHash] == pWorker)
259	g_apPidHash[idxHash] = pWorker->pNext;
260	else
261	{
262	PWORKERINSTANCE pPrev = g_apPidHash[idxHash];
263	while (pPrev && pPrev->pNext != pWorker)
264	pPrev = pPrev->pNext;
265	assert(pPrev != NULL);
266	if (pPrev)
267	pPrev->pNext = pWorker->pNext;
268	}
269	pWorker->pid = -1;
270	}
271
272
273	/**
274	* Looks up a worker by its process ID.
275	*
276	* @returns Pointer to the worker instance if found. NULL if not.
277	* @param pid The process ID of the worker.
278	*/
279	static PWORKERINSTANCE kSubmitFindWorkerByPid(pid_t pid)
280	{
281	PWORKERINSTANCE pWorker = g_apPidHash[KWORKER_PID_HASH(pid)];
282	while (pWorker && pWorker->pid != pid)
283	pWorker = pWorker->pNextPidHash;
284	return pWorker;
285	}
286
287
288	/**
289	* Creates a new worker process.
290	*
291	* @returns 0 on success, non-zero value on failure.
292	* @param pWorker The worker structure. Caller does the linking
293	* (as we might be reusing an existing worker
294	* instance because a worker shut itself down due
295	* to high resource leak level).
296	* @param cVerbosity The verbosity level.
297	*/
298	static int kSubmitSpawnWorker(PWORKERINSTANCE pWorker, int cVerbosity)
299	{
300	#if defined(KBUILD_OS_WINDOWS) \|\| defined(KBUILD_OS_OS2)
301	static const char s_szWorkerName[] = "kWorker.exe";
302	#else
303	static const char s_szWorkerName[] = "kWorker";
304	#endif
305	const char *pszBinPath = get_kbuild_bin_path();
306	size_t const cchBinPath = strlen(pszBinPath);
307	size_t cchExectuable;
308	size_t const cbExecutableBuf = GET_PATH_MAX;
309	PATH_VAR(szExecutable);
310
311	/*
312	* Construct the executable path.
313	*/
314	if ( pWorker->cBits == g_cArchBits
315	? cchBinPath + 1 + sizeof(s_szWorkerName) <= cbExecutableBuf
316	: cchBinPath + 1 - sizeof(g_szArch) + sizeof(g_szAltArch) + sizeof(s_szWorkerName) <= cbExecutableBuf )
317	{
318	#ifdef KBUILD_OS_WINDOWS
319	static DWORD s_fDenyRemoteClients = ~(DWORD)0;
320	wchar_t wszPipeName[64];
321	HANDLE hWorkerPipe;
322	SECURITY_ATTRIBUTES SecAttrs = { /nLength:/ sizeof(SecAttrs), /pAttrs:/ NULL, /bInheritHandle:/ TRUE };
323	#else
324	int aiPair[2] = { -1, -1 };
325	#endif
326
327	memcpy(szExecutable, pszBinPath, cchBinPath);
328	cchExectuable = cchBinPath;
329
330	/* Replace the arch bin directory extension with the alternative one if requested. */
331	if (pWorker->cBits != g_cArchBits)
332	{
333	if ( cchBinPath < sizeof(g_szArch)
334	\|\| memcmp(&szExecutable[cchBinPath - sizeof(g_szArch) + 1], g_szArch, sizeof(g_szArch) - 1) != 0)
335	return errx(1, "KBUILD_BIN_PATH does not end with main architecture (%s) as expected: %s", pszBinPath, g_szArch);
336	cchExectuable -= sizeof(g_szArch) - 1;
337	memcpy(&szExecutable[cchExectuable], g_szAltArch, sizeof(g_szAltArch) - 1);
338	cchExectuable += sizeof(g_szAltArch) - 1;
339	}
340
341	/* Append a slash and the worker name. */
342	szExecutable[cchExectuable++] = '/';
343	memcpy(&szExecutable[cchExectuable], s_szWorkerName, sizeof(s_szWorkerName));
344
345	#ifdef KBUILD_OS_WINDOWS
346	/*
347	* Create the bi-directional pipe. Worker end is marked inheritable, our end is not.
348	*/
349	if (s_fDenyRemoteClients == ~(DWORD)0)
350	s_fDenyRemoteClients = GetVersion() >= 0x60000 ? PIPE_REJECT_REMOTE_CLIENTS : 0;
351	_snwprintf(wszPipeName, sizeof(wszPipeName), L"\\\\.\\pipe\\kmk-%u-kWorker-%u", getpid(), g_uWorkerSeqNo++);
352	hWorkerPipe = CreateNamedPipeW(wszPipeName,
353	PIPE_ACCESS_DUPLEX \| FILE_FLAG_OVERLAPPED \| FILE_FLAG_FIRST_PIPE_INSTANCE /* win2k sp2+ */,
354	PIPE_TYPE_BYTE \| PIPE_READMODE_BYTE \| PIPE_WAIT \| s_fDenyRemoteClients,
355	1 /* cMaxInstances */,
356	64 /cbOutBuffer/,
357	65536 /cbInBuffer/,
358	0 /cMsDefaultTimeout -> 50ms/,
359	&SecAttrs /* inherit */);
360	if (hWorkerPipe != INVALID_HANDLE_VALUE)
361	{
362	pWorker->hPipe = CreateFileW(wszPipeName,
363	GENERIC_READ \| GENERIC_WRITE,
364	0 /* dwShareMode - no sharing */,
365	NULL /pSecAttr - no inherit /,
366	OPEN_EXISTING,
367	FILE_FLAG_OVERLAPPED,
368	NULL /hTemplate/);
369	if (pWorker->hPipe != INVALID_HANDLE_VALUE)
370	{
371	pWorker->OverlappedRead.hEvent = CreateEventW(NULL /pSecAttrs - no inherit/, TRUE /bManualReset/,
372	TRUE /bInitialState/, NULL /pwszName/);
373	if (pWorker->OverlappedRead.hEvent != NULL)
374	{
375	char szHandleArg[32];
376	const char *apszArgs[4] = { szExecutable, "--pipe", szHandleArg, NULL };
377	_snprintf(szHandleArg, sizeof(szHandleArg), "%p", hWorkerPipe);
378
379	/*
380	* Create the worker process.
381	*/
382	pWorker->hProcess = (HANDLE) _spawnve(_P_NOWAIT, szExecutable, apszArgs, environ);
383	if ((intptr_t)pWorker->hProcess != -1)
384	{
385	CloseHandle(hWorkerPipe);
386	pWorker->pid = GetProcessId(pWorker->hProcess);
387	if (cVerbosity > 0)
388	fprintf(stderr, "kSubmit: created %d bit worker %d\n", pWorker->cBits, pWorker->pid);
389	return 0;
390	}
391	err(1, "_spawnve(,%s,,)", szExecutable);
392	CloseHandle(pWorker->OverlappedRead.hEvent);
393	pWorker->OverlappedRead.hEvent = INVALID_HANDLE_VALUE;
394	}
395	else
396	errx(1, "CreateEventW failed: %u", GetLastError());
397	CloseHandle(pWorker->hPipe);
398	pWorker->hPipe = INVALID_HANDLE_VALUE;
399	}
400	else
401	errx(1, "Opening named pipe failed: %u", GetLastError());
402	CloseHandle(hWorkerPipe);
403	}
404	else
405	errx(1, "CreateNamedPipeW failed: %u", GetLastError());
406
407	#else
408	/*
409	* Create a socket pair.
410	*/
411	if (socketpair(AF_LOCAL, SOCK_STREAM, 0, aiPair) == 0)
412	{
413	pWorker->fdSocket = aiPair[1];
414	}
415	else
416	err(1, "socketpair");
417	#endif
418	}
419	else
420	errx(1, "KBUILD_BIN_PATH is too long");
421	return -1;
422	}
423
424
425	/**
426	* Selects an idle worker or spawns a new one.
427	*
428	* @returns Pointer to the selected worker instance. NULL on error.
429	* @param pWorker The idle worker instance to respawn.
430	* On failure this will be freed!
431	* @param cBitsWorker The worker bitness - 64 or 32.
432	*/
433	static int kSubmitRespawnWorker(PWORKERINSTANCE pWorker, int cVerbosity)
434	{
435	/*
436	* Clean up after the old worker.
437	*/
438	#ifdef KBUILD_OS_WINDOWS
439	DWORD rcWait;
440
441	/* Close the pipe handle first, breaking the pipe in case it's not already
442	busted up. Close the event semaphore too before waiting for the process. */
443	if (pWorker->hPipe != INVALID_HANDLE_VALUE)
444	{
445	if (!CloseHandle(pWorker->hPipe))
446	warnx("CloseHandle(pWorker->hPipe): %u", GetLastError());
447	pWorker->hPipe = INVALID_HANDLE_VALUE;
448	}
449
450	if (!CloseHandle(pWorker->OverlappedRead.hEvent))
451	warnx("CloseHandle(pWorker->OverlappedRead.hEvent): %u", GetLastError());
452	pWorker->OverlappedRead.hEvent = INVALID_HANDLE_VALUE;
453
454	/* It's probably shutdown already, if not give it 10 milliseconds before
455	we terminate it forcefully. */
456	rcWait = WaitForSingleObject(pWorker->hProcess, 10);
457	if (rcWait != WAIT_OBJECT_0)
458	{
459	BOOL fRc = TerminateProcess(pWorker->hProcess, 127);
460	rcWait = WaitForSingleObject(pWorker->hProcess, 100);
461	if (rcWait != WAIT_OBJECT_0)
462	warnx("WaitForSingleObject returns %u (and TerminateProcess %d)", rcWait, fRc);
463	}
464
465	if (!CloseHandle(pWorker->hProcess))
466	warnx("CloseHandle(pWorker->hProcess): %u", GetLastError());
467	pWorker->hProcess = INVALID_HANDLE_VALUE;
468
469	#else
470	pid_t pidWait;
471	int rc;
472
473	if (pWorker->fdSocket != -1)
474	{
475	if (close(pWorker->fdSocket) != 0)
476	warn("close(pWorker->fdSocket)");
477	pWorker->fdSocket = -1;
478	}
479
480	kill(pWorker->pid, SIGTERM);
481	pidWait = waitpid(pWorker->pid, &rc, 0);
482	if (pidWait != pWorker->pid)
483	warn("waitpid(pWorker->pid,,0)");
484	#endif
485
486	/*
487	* Unlink it from the hash table.
488	*/
489	kSubmitPidHashRemove(pWorker);
490
491	/*
492	* Respawn it.
493	*/
494	if (kSubmitSpawnWorker(pWorker, cVerbosity) == 0)
495	{
496	/*
497	* Insert it into the process ID hash table and idle list.
498	*/
499	size_t idxHash = KWORKER_PID_HASH(pWorker->pid);
500	pWorker->pNextPidHash = g_apPidHash[idxHash];
501	g_apPidHash[idxHash] = pWorker;
502	return 0;
503	}
504
505	kSubmitListUnlink(&g_IdleList, pWorker);
506	free(pWorker);
507	return -1;
508	}
509
510
511	/**
512	* Selects an idle worker or spawns a new one.
513	*
514	* @returns Pointer to the selected worker instance. NULL on error.
515	* @param cBitsWorker The worker bitness - 64 or 32.
516	*/
517	static PWORKERINSTANCE kSubmitSelectWorkSpawnNewIfNecessary(unsigned cBitsWorker, int cVerbosity)
518	{
519	/*
520	* Lookup up an idle worker.
521	*/
522	PWORKERINSTANCE pWorker = g_IdleList.pHead;
523	while (pWorker)
524	{
525	if (pWorker->cBits == cBitsWorker)
526	return pWorker;
527	pWorker = pWorker->pNext;
528	}
529
530	/*
531	* Create a new worker instance.
532	*/
533	pWorker = (PWORKERINSTANCE)xcalloc(sizeof(*pWorker));
534	pWorker->cBits = cBitsWorker;
535	if (kSubmitSpawnWorker(pWorker, cVerbosity) == 0)
536	{
537	/*
538	* Insert it into the process ID hash table and idle list.
539	*/
540	size_t idxHash = KWORKER_PID_HASH(pWorker->pid);
541	pWorker->pNextPidHash = g_apPidHash[idxHash];
542	g_apPidHash[idxHash] = pWorker;
543
544	kSubmitListAppend(&g_IdleList, pWorker);
545	return pWorker;
546	}
547
548	free(pWorker);
549	return NULL;
550	}
551
552
553	/**
554	* Composes a JOB mesage for a worker.
555	*
556	* @returns Pointer to the message.
557	* @param pszExecutable The executable to run.
558	* @param papszArgs The argument vector.
559	* @param papszEnvVars The environment vector.
560	* @param pszCwd The current directory.
561	* @param pcbMsg Where to return the message length.
562	*/
563	static void kSubmitComposeJobMessage(const char pszExecutable, char papszArgs, char papszEnvVars,
564	const char pszCwd, uint32_t pcbMsg)
565	{
566	size_t cbTmp;
567	uint32_t i;
568	uint32_t cbMsg;
569	uint32_t cArgs;
570	uint32_t cEnvVars;
571	uint8_t *pbMsg;
572	uint8_t *pbCursor;
573
574	/*
575	* Adjust input.
576	*/
577	if (!pszExecutable)
578	pszExecutable = papszArgs[0];
579
580	/*
581	* Calculate the message length first.
582	*/
583	cbMsg = sizeof(cbMsg);
584	cbMsg += sizeof("JOB");
585	cbMsg += strlen(pszExecutable) + 1;
586	cbMsg += strlen(pszCwd) + 1;
587
588	cbMsg += sizeof(cArgs);
589	for (i = 0; papszArgs[i] != NULL; i++)
590	cbMsg += 1 + strlen(papszArgs[i]) + 1;
591	cArgs = i;
592
593	cbMsg += sizeof(cArgs);
594	for (i = 0; papszEnvVars[i] != NULL; i++)
595	cbMsg += strlen(papszEnvVars[i]) + 1;
596	cEnvVars = i;
597
598
599	/*
600	* Compose the message.
601	*/
602	pbMsg = pbCursor = xmalloc(cbMsg);
603
604	memcpy(pbCursor, &cbMsg, sizeof(cbMsg));
605	pbCursor += sizeof(cbMsg);
606	memcpy(pbCursor, "JOB", sizeof("JOB"));
607	pbCursor += sizeof("JOB");
608
609	cbTmp = strlen(pszExecutable) + 1;
610	memcpy(pbCursor, pszExecutable, cbTmp);
611	pbCursor += cbTmp;
612
613	cbTmp = strlen(pszCwd) + 1;
614	memcpy(pbCursor, pszCwd, cbTmp);
615	pbCursor += cbTmp;
616
617	memcpy(pbCursor, &cArgs, sizeof(cArgs));
618	pbCursor += sizeof(cArgs);
619	for (i = 0; papszArgs[i] != NULL; i++)
620	{
621	pbCursor++ = 0; / Argument expansion flags (MSC, EMX). */
622	cbTmp = strlen(papszArgs[i]) + 1;
623	memcpy(pbCursor, papszArgs[i], cbTmp);
624	pbCursor += cbTmp;
625	}
626	assert(i == cArgs);
627
628	memcpy(pbCursor, &cEnvVars, sizeof(cEnvVars));
629	pbCursor += sizeof(cEnvVars);
630	for (i = 0; papszEnvVars[i] != NULL; i++)
631	{
632	cbTmp = strlen(papszEnvVars[i]) + 1;
633	memcpy(pbCursor, papszEnvVars[i], cbTmp);
634	pbCursor += cbTmp;
635	}
636	assert(i == cEnvVars);
637
638	assert(pbCursor - pbMsg == (size_t)cbMsg);
639
640	/* done */
641	*pcbMsg = cbMsg;
642	return pbMsg;
643	}
644
645
646	/**
647	* Sends the job message to the given worker, respawning the worker if
648	* necessary.
649	*
650	* @returns 0 on success, non-zero on failure.
651	*
652	* @param pWorker The work to send the request to. The worker is
653	* on the idle list.
654	* @param pvMsg The message to send.
655	* @param cbMsg The size of the message.
656	* @param fNoRespawning Set if
657	* @param cVerbosity The verbosity level.
658	*/
659	static int kSubmitSendJobMessage(PWORKERINSTANCE pWorker, void const *pvMsg, uint32_t cbMsg, int fNoRespawning, int cVerbosity)
660	{
661	int cRetries;
662
663	/*
664	* Respawn the worker if it stopped by itself and we closed the pipe already.
665	*/
666	#ifdef KBUILD_OS_WINDOWS
667	if (pWorker->hPipe == INVALID_HANDLE_VALUE)
668	#else
669	if (pWorker->fdSocket == -1)
670	#endif
671	{
672	if (!fNoRespawning)
673	{
674	if (cVerbosity > 0)
675	fprintf(stderr, "kSubmit: Respawning worker (#1)...\n");
676	if (kSubmitRespawnWorker(pWorker, cVerbosity) != 0)
677	return 2;
678	}
679
680	}
681
682	/*
683	* Restart-on-broken-pipe loop. Necessary?
684	*/
685	for (cRetries = !fNoRespawning ? 1 : 0; ; cRetries--)
686	{
687	/*
688	* Try write the message.
689	*/
690	uint32_t cbLeft = cbMsg;
691	uint8_t const pbLeft = (uint8_t const )pvMsg;
692	#ifdef KBUILD_OS_WINDOWS
693	DWORD dwErr;
694	DWORD cbWritten;
695	while (WriteFile(pWorker->hPipe, pbLeft, cbLeft, &cbWritten, NULL /pOverlapped/))
696	{
697	assert(cbWritten <= cbLeft);
698	cbLeft -= cbWritten;
699	if (!cbLeft)
700	return 0;
701
702	/* This scenario shouldn't really ever happen. But just in case... */
703	pbLeft += cbWritten;
704	}
705	dwErr = GetLastError();
706	if ( ( dwErr != ERROR_BROKEN_PIPE
707	&& dwErr != ERROR_NO_DATA)
708	\|\| cRetries <= 0)
709	return errx(1, "Error writing to worker: %u", dwErr);
710	#else
711	ssize_t cbWritten
712	while ((cbWritten = write(pWorker->fdSocket, pbLeft, cbLeft)) >= 0)
713	{
714	assert(cbWritten <= cbLeft);
715	cbLeft -= cbWritten;
716	if (!cbLeft)
717	return 0;
718
719	pbLeft += cbWritten;
720	}
721	if ( ( errno != EPIPE
722	&& errno != ENOTCONN
723	&& errno != ECONNRESET))
724	\|\| cRetries <= 0)
725	return err(1, "Error writing to worker");
726	# error "later"
727	#endif
728
729	/*
730	* Broken connection. Try respawn the worker.
731	*/
732	if (cVerbosity > 0)
733	fprintf(stderr, "kSubmit: Respawning worker (#2)...\n");
734	if (kSubmitRespawnWorker(pWorker, cVerbosity) != 0)
735	return 2;
736	}
737	}
738
739
740	/**
741	* Closes the connection on a worker that said it is going to exit now.
742	*
743	* This is a way of dealing with imperfect resource management in the worker, it
744	* will monitor it a little and trigger a respawn when it looks bad.
745	*
746	* This function just closes the pipe / socket connection to the worker. The
747	* kSubmitSendJobMessage function will see this a trigger a respawn the next
748	* time the worker is engaged. This will usually mean there's a little delay in
749	* which the process can terminate without us having to actively wait for it.
750	*
751	* @param pWorker The worker instance.
752	*/
753	static void kSubmitCloseConnectOnExitingWorker(PWORKERINSTANCE pWorker)
754	{
755	#ifdef KBUILD_OS_WINDOWS
756	if (!CloseHandle(pWorker->hPipe))
757	warnx("CloseHandle(pWorker->hPipe): %u", GetLastError());
758	pWorker->hPipe = INVALID_HANDLE_VALUE;
759	#else
760	if (close(pWorker->fdSocket) != 0)
761	warn("close(pWorker->fdSocket)");
762	pWorker->fdSocket = -1;
763	#endif
764	}
765
766
767	#ifdef KBUILD_OS_WINDOWS
768
769	/**
770	* Handles read failure.
771	*
772	* @returns Exit code.
773	* @param pWorker The worker instance.
774	* @param dwErr The error code.
775	*/
776	static int kSubmitWinReadFailed(PWORKERINSTANCE pWorker, DWORD dwErr)
777	{
778	DWORD dwExitCode;
779
780	if (pWorker->cbResultRead == 0)
781	errx(1, "ReadFile failed: %u", dwErr);
782	else
783	errx(1, "ReadFile failed: %u (read %u bytes)", dwErr, pWorker->cbResultRead);
784	assert(dwErr != 0);
785
786	/* Complete the result. */
787	pWorker->Result.s.rcExit = 127;
788	pWorker->Result.s.bWorkerExiting = 1;
789	pWorker->cbResultRead = sizeof(pWorker->Result);
790
791	if (GetExitCodeProcess(pWorker->hProcess, &dwExitCode))
792	{
793	if (dwExitCode != 0)
794	pWorker->Result.s.rcExit = dwExitCode;
795	}
796
797	return dwErr != 0 ? (int)(dwErr & 0x7fffffff) : 0x7fffffff;
798
799	}
800
801
802	/**
803	* Used by
804	* @returns 0 if we got the whole result, -1 if I/O is pending, and windows last
805	* error on ReadFile failure.
806	* @param pWorker The worker instance.
807	*/
808	static int kSubmitReadMoreResultWin(PWORKERINSTANCE pWorker)
809	{
810	/*
811	* Set up the result read, telling the sub_proc.c unit about it.
812	*/
813	while (pWorker->cbResultRead < sizeof(pWorker->Result))
814	{
815	DWORD cbRead = 0;
816
817	BOOL fRc = ResetEvent(pWorker->OverlappedRead.hEvent);
818	assert(fRc); (void)fRc;
819
820	pWorker->OverlappedRead.Offset = 0;
821	pWorker->OverlappedRead.OffsetHigh = 0;
822
823	if (!ReadFile(pWorker->hPipe, &pWorker->Result.ab[pWorker->cbResultRead],
824	sizeof(pWorker->Result) - pWorker->cbResultRead,
825	&cbRead,
826	&pWorker->OverlappedRead))
827	{
828	DWORD dwErr = GetLastError();
829	if (dwErr == ERROR_IO_PENDING)
830	return -1;
831	return kSubmitWinReadFailed(pWorker, dwErr);
832	}
833
834	pWorker->cbResultRead += cbRead;
835	assert(pWorker->cbResultRead <= sizeof(pWorker->Result));
836	}
837	return 0;
838	}
839
840	#endif /* KBUILD_OS_WINDOWS */
841
842	/**
843	* Marks the worker active.
844	*
845	* On windows this involves setting up the async result read and telling
846	* sub_proc.c about the process.
847	*
848	* @returns Exit code.
849	* @param pWorker The worker instance to mark as active.
850	* @param cVerbosity The verbosity level.
851	* @param pChild The kmk child to associate the job with.
852	* @param pPidSpawned If @a *pPidSpawned is non-zero if the child is
853	* running, otherwise the worker is already done
854	* and we've returned the exit code of the job.
855	*/
856	static int kSubmitMarkActive(PWORKERINSTANCE pWorker, int cVerbosity, struct child pChild, pid_t pPidSpawned)
857	{
858	#ifdef KBUILD_OS_WINDOWS
859	int rc;
860	#endif
861
862	pWorker->cbResultRead = 0;
863
864	#ifdef KBUILD_OS_WINDOWS
865	/*
866	* Setup the async result read on windows. If we're slow and the worker
867	* very fast, this may actually get the result immediately.
868	*/
869	l_again:
870	rc = kSubmitReadMoreResultWin(pWorker);
871	if (rc == -1)
872	{
873	if (process_kmk_register_submit(pWorker->OverlappedRead.hEvent, (intptr_t)pWorker, pPidSpawned) == 0)
874	{ /* likely */ }
875	else
876	{
877	/* We need to do the waiting here because sub_proc.c has too much to do. */
878	warnx("Too many processes for sub_proc.c to handle!");
879	WaitForSingleObject(pWorker->OverlappedRead.hEvent, INFINITE);
880	goto l_again;
881	}
882	}
883	else
884	{
885	assert(rc == 0 \|\| pWorker->Result.s.rcExit != 0);
886	if (pWorker->Result.s.bWorkerExiting)
887	kSubmitCloseConnectOnExitingWorker(pWorker);
888	*pPidSpawned = 0;
889	return pWorker->Result.s.rcExit;
890	}
891	#endif
892
893	/*
894	* Mark it busy and move it to the active instance.
895	*/
896	pWorker->pBusyWith = pChild;
897	#ifndef KBUILD_OS_WINDOWS
898	*pPidSpawned = pWorker->pid;
899	#endif
900
901	kSubmitListUnlink(&g_IdleList, pWorker);
902	kSubmitListAppend(&g_BusyList, pWorker);
903	return 0;
904	}
905
906
907	#ifdef KBUILD_OS_WINDOWS
908
909	/**
910	* Retrieve the worker child result.
911	*
912	* If incomplete, we restart the ReadFile operation like kSubmitMarkActive does.
913	*
914	* @returns 0 on success, -1 if ReadFile was restarted.
915	* @param pvUser The worker instance.
916	* @param prcExit Where to return the exit code.
917	* @param piSigNo Where to return the signal number.
918	*/
919	int kSubmitSubProcGetResult(intptr_t pvUser, int prcExit, int piSigNo)
920	{
921	PWORKERINSTANCE pWorker = (PWORKERINSTANCE)pvUser;
922
923	/*
924	* Get the overlapped result. There should be one since we're here
925	* because of a satisfied WaitForMultipleObject.
926	*/
927	DWORD cbRead = 0;
928	if (GetOverlappedResult(pWorker->hPipe, &pWorker->OverlappedRead, &cbRead, TRUE))
929	{
930	pWorker->cbResultRead += cbRead;
931	assert(pWorker->cbResultRead <= sizeof(pWorker->Result));
932
933	/* More to be read? */
934	while (pWorker->cbResultRead < sizeof(pWorker->Result))
935	{
936	int rc = kSubmitReadMoreResultWin(pWorker);
937	if (rc == -1)
938	return -1;
939	assert(rc == 0 \|\| pWorker->Result.s.rcExit != 0);
940	}
941	assert(pWorker->cbResultRead == sizeof(pWorker->Result));
942	}
943	else
944	{
945	DWORD dwErr = GetLastError();
946	kSubmitWinReadFailed(pWorker, dwErr);
947	}
948
949	/*
950	* Okay, we've got a result.
951	*/
952	*prcExit = pWorker->Result.s.rcExit;
953	switch (pWorker->Result.s.rcExit)
954	{
955	default: *piSigNo = 0; break;
956	case CONTROL_C_EXIT: *piSigNo = SIGINT; break;
957	case STATUS_INTEGER_DIVIDE_BY_ZERO: *piSigNo = SIGFPE; break;
958	case STATUS_ACCESS_VIOLATION: *piSigNo = SIGSEGV; break;
959	case STATUS_PRIVILEGED_INSTRUCTION:
960	case STATUS_ILLEGAL_INSTRUCTION: *piSigNo = SIGILL; break;
961	}
962
963	return 0;
964	}
965
966
967	int kSubmitSubProcKill(intptr_t pvUser, int iSignal)
968	{
969	return -1;
970	}
971
972
973	/**
974	* Called by process_cleanup when it's done with the worker.
975	*
976	* @param pvUser The worker instance.
977	*/
978	void kSubmitSubProcCleanup(intptr_t pvUser)
979	{
980	PWORKERINSTANCE pWorker = (PWORKERINSTANCE)pvUser;
981	kSubmitListUnlink(&g_BusyList, pWorker);
982	kSubmitListAppend(&g_IdleList, pWorker);
983	}
984
985	#endif /* KBUILD_OS_WINDOWS */
986
987
988	/**
989	* atexit callback that trigger worker termination.
990	*/
991	static void kSubmitAtExitCallback(void)
992	{
993	PWORKERINSTANCE pWorker;
994	DWORD msStartTick;
995	DWORD cKillRaids = 0;
996
997	/*
998	* Tell all the workers to exit by breaking the connection.
999	*/
1000	for (pWorker = g_IdleList.pHead; pWorker != NULL; pWorker = pWorker->pNext)
1001	kSubmitCloseConnectOnExitingWorker(pWorker);
1002	for (pWorker = g_BusyList.pHead; pWorker != NULL; pWorker = pWorker->pNext)
1003	kSubmitCloseConnectOnExitingWorker(pWorker);
1004
1005	/*
1006	* Wait a little while for them to stop.
1007	*/
1008	Sleep(0);
1009	msStartTick = GetTickCount();
1010	for (;;)
1011	{
1012	/*
1013	* Collect handles of running processes.
1014	*/
1015	PWORKERINSTANCE apWorkers[MAXIMUM_WAIT_OBJECTS];
1016	HANDLE ahHandles[MAXIMUM_WAIT_OBJECTS];
1017	DWORD cHandles = 0;
1018
1019	for (pWorker = g_IdleList.pHead; pWorker != NULL; pWorker = pWorker->pNext)
1020	if (pWorker->hProcess != INVALID_HANDLE_VALUE)
1021	{
1022	if (cHandles < MAXIMUM_WAIT_OBJECTS)
1023	{
1024	apWorkers[cHandles] = pWorker;
1025	ahHandles[cHandles] = pWorker->hProcess;
1026	}
1027	cHandles++;
1028	}
1029	for (pWorker = g_BusyList.pHead; pWorker != NULL; pWorker = pWorker->pNext)
1030	if (pWorker->hProcess != INVALID_HANDLE_VALUE)
1031	{
1032	if (cHandles < MAXIMUM_WAIT_OBJECTS)
1033	{
1034	apWorkers[cHandles] = pWorker;
1035	ahHandles[cHandles] = pWorker->hProcess;
1036	}
1037	cHandles++;
1038	}
1039	if (cHandles == 0)
1040	return;
1041
1042	/*
1043	* Wait for the processes.
1044	*/
1045	for (;;)
1046	{
1047	DWORD cMsElapsed = GetTickCount() - msStartTick;
1048	DWORD dwWait = WaitForMultipleObjects(cHandles <= MAXIMUM_WAIT_OBJECTS ? cHandles : MAXIMUM_WAIT_OBJECTS,
1049	ahHandles, FALSE /bWaitAll/,
1050	cMsElapsed < 1000 ? 1000 - cMsElapsed + 16 : 16);
1051	if ( dwWait >= WAIT_OBJECT_0
1052	&& dwWait <= WAIT_OBJECT_0 + MAXIMUM_WAIT_OBJECTS)
1053	{
1054	size_t idx = dwWait - WAIT_OBJECT_0;
1055	CloseHandle(apWorkers[idx]->hProcess);
1056	apWorkers[idx]->hProcess = INVALID_HANDLE_VALUE;
1057
1058	if (cHandles <= MAXIMUM_WAIT_OBJECTS)
1059	{
1060	/* Restart the wait with the worker removed, or quit if it was the last worker. */
1061	cHandles--;
1062	if (!cHandles)
1063	return;
1064	if (idx != cHandles)
1065	{
1066	apWorkers[idx] = apWorkers[cHandles];
1067	ahHandles[idx] = ahHandles[cHandles];
1068	}
1069	continue;
1070	}
1071	/* else: Reconstruct the wait array so we get maximum coverage. */
1072	}
1073	else if (dwWait == WAIT_TIMEOUT)
1074	{
1075	/* Terminate the whole bunch. */
1076	cKillRaids++;
1077	if (cKillRaids <= 2)
1078	{
1079	fprintf(stderr, "kmk/kSubmit: Killing %u lingering worker processe(s)!\n", cHandles);
1080	for (pWorker = g_IdleList.pHead; pWorker != NULL; pWorker = pWorker->pNext)
1081	if (pWorker->hProcess != INVALID_HANDLE_VALUE)
1082	TerminateProcess(pWorker->hProcess, WAIT_TIMEOUT);
1083	for (pWorker = g_BusyList.pHead; pWorker != NULL; pWorker = pWorker->pNext)
1084	if (pWorker->hProcess != INVALID_HANDLE_VALUE)
1085	TerminateProcess(pWorker->hProcess, WAIT_TIMEOUT);
1086	}
1087	else
1088	{
1089	fprintf(stderr, "kmk/kSubmit: Giving up on the last %u worker processe(s). :-(\n", cHandles);
1090	break;
1091	}
1092	}
1093	else
1094	{
1095	/* Some kind of wait error. Could be a bad handle, check each and remove
1096	bad ones as well as completed ones. */
1097	size_t idx;
1098	fprintf(stderr, "kmk/kSubmit: WaitForMultipleObjects unexpectedly returned %#u (err=%u)\n",
1099	dwWait, GetLastError());
1100	for (idx = 0; idx < cHandles; idx++)
1101	{
1102	dwWait = WaitForSingleObject(ahHandles[idx], 0 /ms/);
1103	if (dwWait != WAIT_TIMEOUT)
1104	{
1105	CloseHandle(apWorkers[idx]->hProcess);
1106	apWorkers[idx]->hProcess = INVALID_HANDLE_VALUE;
1107	}
1108	}
1109	}
1110	break;
1111	} /* wait loop */
1112	} /* outer wait loop */
1113	}
1114
1115
1116
1117	/**
1118	* Handles the --set var=value option.
1119	*
1120	* @returns 0 on success, non-zero exit code on error.
1121	* @param papszEnv The environment vector.
1122	* @param pcEnvVars Pointer to the variable holding the number of
1123	* environment variables held by @a papszEnv.
1124	* @param pcAllocatedEnvVars Pointer to the variable holding max size of the
1125	* environment vector.
1126	* @param cVerbosity The verbosity level.
1127	* @param pszValue The var=value string to apply.
1128	*/
1129	static int kSubmitOptEnvSet(char *papszEnv, unsigned pcEnvVars, unsigned *pcAllocatedEnvVars,
1130	int cVerbosity, const char *pszValue)
1131	{
1132	const char *pszEqual = strchr(pszValue, '=');
1133	if (pszEqual)
1134	{
1135	unsigned iEnvVar;
1136	unsigned cEnvVars = *pcEnvVars;
1137	size_t const cchVar = pszValue - pszEqual;
1138	for (iEnvVar = 0; iEnvVar < cEnvVars; iEnvVar++)
1139	if ( strncmp(papszEnv[iEnvVar], pszValue, cchVar) == 0
1140	&& papszEnv[iEnvVar][cchVar] == '=')
1141	{
1142	if (cVerbosity > 0)
1143	fprintf(stderr, "kSubmit: replacing '%s' with '%s'\n", papszEnv[iEnvVar], pszValue);
1144	free(papszEnv[iEnvVar]);
1145	papszEnv[iEnvVar] = xstrdup(pszValue);
1146	break;
1147	}
1148	if (iEnvVar == cEnvVars)
1149	{
1150	/* Append new variable. We probably need to resize the vector. */
1151	if ((cEnvVars + 2) > *pcAllocatedEnvVars)
1152	{
1153	*pcAllocatedEnvVars = (cEnvVars + 2 + 0xf) & ~(unsigned)0xf;
1154	papszEnv = (char *)xrealloc(papszEnv, pcAllocatedEnvVars * sizeof(papszEnv[0]));
1155	}
1156	papszEnv[cEnvVars++] = xstrdup(pszValue);
1157	papszEnv[cEnvVars] = NULL;
1158	*pcEnvVars = cEnvVars;
1159	if (cVerbosity > 0)
1160	fprintf(stderr, "kSubmit: added '%s'\n", papszEnv[iEnvVar]);
1161	}
1162	else
1163	{
1164	/* Check for duplicates. */
1165	for (iEnvVar++; iEnvVar < cEnvVars; iEnvVar++)
1166	if ( strncmp(papszEnv[iEnvVar], pszValue, cchVar) == 0
1167	&& papszEnv[iEnvVar][cchVar] == '=')
1168	{
1169	if (cVerbosity > 0)
1170	fprintf(stderr, "kSubmit: removing duplicate '%s'\n", papszEnv[iEnvVar]);
1171	free(papszEnv[iEnvVar]);
1172	cEnvVars--;
1173	if (iEnvVar != cEnvVars)
1174	papszEnv[iEnvVar] = papszEnv[cEnvVars];
1175	papszEnv[cEnvVars] = NULL;
1176	iEnvVar--;
1177	}
1178	}
1179	}
1180	else
1181	return errx(1, "Missing '=': -E %s", pszValue);
1182
1183	return 0;
1184	}
1185
1186
1187	/**
1188	* Handles the --unset var option.
1189	*
1190	* @returns 0 on success, non-zero exit code on error.
1191	* @param papszEnv The environment vector.
1192	* @param pcEnvVars Pointer to the variable holding the number of
1193	* environment variables held by @a papszEnv.
1194	* @param cVerbosity The verbosity level.
1195	* @param pszVarToRemove The name of the variable to remove.
1196	*/
1197	static int kSubmitOptEnvUnset(char *papszEnv, unsigned pcEnvVars, int cVerbosity, const char *pszVarToRemove)
1198	{
1199	if (strchr(pszVarToRemove, '=') == NULL)
1200	{
1201	unsigned cRemoved = 0;
1202	size_t const cchVar = strlen(pszVarToRemove);
1203	unsigned cEnvVars = *pcEnvVars;
1204	unsigned iEnvVar;
1205
1206	for (iEnvVar = 0; iEnvVar < cEnvVars; iEnvVar++)
1207	if ( strncmp(papszEnv[iEnvVar], pszVarToRemove, cchVar) == 0
1208	&& papszEnv[iEnvVar][cchVar] == '=')
1209	{
1210	if (cVerbosity > 0)
1211	fprintf(stderr, !cRemoved ? "kSubmit: removing '%s'\n"
1212	: "kSubmit: removing duplicate '%s'\n", papszEnv[iEnvVar]);
1213	free(papszEnv[iEnvVar]);
1214	cEnvVars--;
1215	if (iEnvVar != cEnvVars)
1216	papszEnv[iEnvVar] = papszEnv[cEnvVars];
1217	papszEnv[cEnvVars] = NULL;
1218	cRemoved++;
1219	iEnvVar--;
1220	}
1221	*pcEnvVars = cEnvVars;
1222
1223	if (cVerbosity > 0 && !cRemoved)
1224	fprintf(stderr, "kSubmit: not found '%s'\n", pszVarToRemove);
1225	}
1226	else
1227	return errx(1, "Found invalid variable name character '=' in: -U %s", pszVarToRemove);
1228	return 0;
1229	}
1230
1231
1232
1233	/**
1234	* Handles the --chdir dir option.
1235	*
1236	* @returns 0 on success, non-zero exit code on error.
1237	* @param pszCwd The CWD buffer. Contains current CWD on input,
1238	* modified by @a pszValue on output.
1239	* @param cbCwdBuf The size of the CWD buffer.
1240	* @param pszValue The --chdir value to apply.
1241	*/
1242	static int kSubmitOptChDir(char pszCwd, size_t cbCwdBuf, const char pszValue)
1243	{
1244	size_t cchNewCwd = strlen(pszValue);
1245	size_t offDst;
1246	if (cchNewCwd)
1247	{
1248	#ifdef HAVE_DOS_PATHS
1249	if (pszValue == '/' \|\| pszValue == '\\')
1250	{
1251	if (pszValue[1] == '/' \|\| pszValue[1] == '\\')
1252	offDst = 0; /* UNC */
1253	else if (pszCwd[1] == ':' && isalpha(pszCwd[0]))
1254	offDst = 2; /* Take drive letter from CWD. */
1255	else
1256	return errx(1, "UNC relative CWD not implemented: cur='%s' new='%s'", pszCwd, pszValue);
1257	}
1258	else if ( pszValue[1] == ':'
1259	&& isalpha(pszValue[0]))
1260	{
1261	if (pszValue[2] == '/'\|\| pszValue[2] == '\\')
1262	offDst = 0; /* DOS style absolute path. */
1263	else if ( pszCwd[1] == ':'
1264	&& tolower(pszCwd[0]) == tolower(pszValue[0]) )
1265	{
1266	pszValue += 2; /* Same drive as CWD, append drive relative path from value. */
1267	cchNewCwd -= 2;
1268	offDst = strlen(pszCwd);
1269	}
1270	else
1271	{
1272	/* Get current CWD on the specified drive and append value. */
1273	int iDrive = tolower(pszValue[0]) - 'a' + 1;
1274	if (!_getdcwd(iDrive, pszCwd, cbCwdBuf))
1275	return err(1, "_getdcwd(%d,,) failed", iDrive);
1276	pszValue += 2;
1277	cchNewCwd -= 2;
1278	}
1279	}
1280	#else
1281	if (*pszValue == '/')
1282	offDst = 0;
1283	#endif
1284	else
1285	offDst = strlen(pszCwd); /* Relative path, append to the existing CWD value. */
1286
1287	/* Do the copying. */
1288	#ifdef HAVE_DOS_PATHS
1289	if (offDst > 0 && pszCwd[offDst - 1] != '/' && pszCwd[offDst - 1] != '\\')
1290	#else
1291	if (offDst > 0 && pszCwd[offDst - 1] != '/')
1292	#endif
1293	pszCwd[offDst++] = '/';
1294	if (offDst + cchNewCwd >= cbCwdBuf)
1295	return errx(1, "Too long CWD: %.s%s", offDst, offDst, pszCwd, pszValue);
1296	memcpy(&pszCwd[offDst], pszValue, cchNewCwd + 1);
1297	}
1298	/* else: relative, no change - quitely ignore. */
1299	return 0;
1300	}
1301
1302
1303	static int usage(FILE pOut, const char argv0)
1304	{
1305	fprintf(pOut,
1306	"usage: %s [-Z\|--zap-env] [-E\|--set <var=val>] [-U\|--unset <var=val>]\n"
1307	" [-C\|--chdir <dir>] [--wcc-brain-damage]\n"
1308	" [-3\|--32-bit] [-6\|--64-bit] [-v] -- <program> [args]\n"
1309	" or: %s --help\n"
1310	" or: %s --version\n"
1311	"\n"
1312	"Options:\n"
1313	" -Z, --zap-env, -i, --ignore-environment\n"
1314	" Zaps the environment. Position dependent.\n"
1315	" -E, --set <var>=[value]\n"
1316	" Sets an enviornment variable putenv fashion. Position dependent.\n"
1317	" -U, --unset <var>\n"
1318	" Removes an environment variable. Position dependent.\n"
1319	" -C, --chdir <dir>\n"
1320	" Specifies the current directory for the program. Relative paths\n"
1321	" are relative to the previous -C option. Default is getcwd value.\n"
1322	" -3, --32-bit\n"
1323	" Selects a 32-bit kWorker process. Default: kmk bit count\n"
1324	" -6, --64-bit\n"
1325	" Selects a 64-bit kWorker process. Default: kmk bit count\n"
1326	" --wcc-brain-damage\n"
1327	" Works around wcc and wcc386 (Open Watcom) not following normal\n"
1328	" quoting conventions on Windows, OS/2, and DOS.\n"
1329	" -v,--verbose\n"
1330	" More verbose execution.\n"
1331	" -V,--version\n"
1332	" Show the version number.\n"
1333	" -h,--help\n"
1334	" Show this usage information.\n"
1335	"\n"
1336	,
1337	argv0, argv0, argv0);
1338	return 1;
1339	}
1340
1341
1342	int kmk_builtin_kSubmit(int argc, char argv, char envp, struct child pChild, pid_t pPidSpawned)
1343	{
1344	int rcExit = 0;
1345	int iArg;
1346	unsigned cAllocatedEnvVars;
1347	unsigned iEnvVar;
1348	unsigned cEnvVars;
1349	char **papszEnv = NULL;
1350	const char *pszExecutable = NULL;
1351	const char *pszCwd = NULL;
1352	unsigned cBitsWorker = g_cArchBits;
1353	int fWatcomBrainDamage = 0;
1354	int cVerbosity = 0;
1355	size_t const cbCwdBuf = GET_PATH_MAX;
1356	PATH_VAR(szCwd);
1357
1358	g_progname = argv[0];
1359
1360	/*
1361	* Create default program environment.
1362	*/
1363	if (getcwd_fs(szCwd, cbCwdBuf) != NULL)
1364	{ /* likely */ }
1365	else
1366	return err(1, "getcwd_fs failed\n");
1367
1368	papszEnv = pChild->environment;
1369	if (!papszEnv)
1370	pChild->environment = papszEnv = target_environment(pChild->file);
1371	cEnvVars = 0;
1372	while (papszEnv[cEnvVars] != NULL)
1373	cEnvVars++;
1374	cAllocatedEnvVars = cEnvVars;
1375
1376	/*
1377	* Parse the command line.
1378	*/
1379	for (iArg = 1; iArg < argc; iArg++)
1380	{
1381	const char *pszArg = argv[iArg];
1382	if (*pszArg == '-')
1383	{
1384	char chOpt = *++pszArg;
1385	if (chOpt != '-')
1386	{
1387	if (chOpt != '\0')
1388	{ /* likely */ }
1389	else
1390	{
1391	errx(1, "Incomplete option: '-'");
1392	return usage(stderr, argv[0]);
1393	}
1394	}
1395	else
1396	{
1397	pszArg++;
1398
1399	/* '--' indicates where the bits to execute start. */
1400	if (*pszArg == '\0')
1401	{
1402	iArg++;
1403	break;
1404	}
1405
1406	if (strcmp(pszArg, "watcom-brain-damage") == 0)
1407	{
1408	fWatcomBrainDamage = 1;
1409	continue;
1410	}
1411
1412	/* convert to short. */
1413	if (strcmp(pszArg, "help") == 0)
1414	chOpt = 'h';
1415	else if (strcmp(pszArg, "version") == 0)
1416	chOpt = 'V';
1417	else if (strcmp(pszArg, "set") == 0)
1418	chOpt = 'E';
1419	else if (strcmp(pszArg, "unset") == 0)
1420	chOpt = 'U';
1421	else if ( strcmp(pszArg, "zap-env") == 0
1422	\|\| strcmp(pszArg, "ignore-environment") == 0 /* GNU env compatibility. */ )
1423	chOpt = 'Z';
1424	else if (strcmp(pszArg, "chdir") == 0)
1425	chOpt = 'C';
1426	else if (strcmp(pszArg, "32-bit") == 0)
1427	chOpt = '3';
1428	else if (strcmp(pszArg, "64-bit") == 0)
1429	chOpt = '6';
1430	else if (strcmp(pszArg, "verbose") == 0)
1431	chOpt = 'v';
1432	else if (strcmp(pszArg, "executable") == 0)
1433	chOpt = 'e';
1434	else
1435	{
1436	errx(1, "Unknown option: '%s'", pszArg - 2);
1437	return usage(stderr, argv[0]);
1438	}
1439	pszArg = "";
1440	}
1441
1442	do
1443	{
1444	/* Get option value first, if the option takes one. */
1445	const char *pszValue = NULL;
1446	switch (chOpt)
1447	{
1448	case 'E':
1449	case 'U':
1450	case 'C':
1451	case 'e':
1452	if (*pszArg != '\0')
1453	pszValue = pszArg + (pszArg == ':' \|\| pszArg == '=');
1454	else if (++iArg < argc)
1455	pszValue = argv[iArg];
1456	else
1457	{
1458	errx(1, "Option -%c requires an value!", chOpt);
1459	return usage(stderr, argv[0]);
1460	}
1461	break;
1462	}
1463
1464	switch (chOpt)
1465	{
1466	case 'Z':
1467	case 'i': /* GNU env compatibility. */
1468	for (iEnvVar = 0; iEnvVar < cEnvVars; iEnvVar++)
1469	free(papszEnv[iEnvVar]);
1470	papszEnv[0] = NULL;
1471	cEnvVars = 0;
1472	break;
1473
1474	case 'E':
1475	rcExit = kSubmitOptEnvSet(papszEnv, &cEnvVars, &cAllocatedEnvVars, cVerbosity, pszValue);
1476	pChild->environment = papszEnv;
1477	if (rcExit == 0)
1478	break;
1479	return rcExit;
1480
1481	case 'U':
1482	rcExit = kSubmitOptEnvUnset(papszEnv, &cEnvVars, cVerbosity, pszValue);
1483	if (rcExit == 0)
1484	break;
1485	return rcExit;
1486
1487	case 'C':
1488	rcExit = kSubmitOptChDir(szCwd, cbCwdBuf, pszValue);
1489	if (rcExit == 0)
1490	break;
1491	return rcExit;
1492
1493	case '3':
1494	cBitsWorker = 32;
1495	break;
1496
1497	case '6':
1498	cBitsWorker = 64;
1499	break;
1500
1501	case 'e':
1502	pszExecutable = pszValue;
1503	break;
1504
1505	case 'v':
1506	cVerbosity++;
1507	break;
1508
1509	case 'h':
1510	usage(stdout, argv[0]);
1511	return 0;
1512
1513	case 'V':
1514	return kbuild_version(argv[0]);
1515	}
1516	} while ((chOpt = *pszArg++) != '\0');
1517	}
1518	else
1519	{
1520	errx(1, "Unknown argument: '%s'", pszArg);
1521	return usage(stderr, argv[0]);
1522	}
1523	}
1524
1525	/*
1526	* Check that we've got something to execute.
1527	*/
1528	if (iArg < argc)
1529	{
1530	uint32_t cbMsg;
1531	void *pvMsg = kSubmitComposeJobMessage(pszExecutable, &argv[iArg], papszEnv, szCwd, &cbMsg);
1532	PWORKERINSTANCE pWorker = kSubmitSelectWorkSpawnNewIfNecessary(cBitsWorker, cVerbosity);
1533	if (pWorker)
1534	{
1535	#ifdef KBUILD_OS_WINDOWS
1536	/* Quote the argv elements, but first we need unquoted pszExecute. */
1537	int const cArgs = argc - iArg;
1538	int iArg2;
1539	char papszArgsOrg = (char )xmalloc(sizeof(argv[0]) * cArgs);
1540	if (!pszExecutable)
1541	pszExecutable = argv[iArg];
1542	memcpy(papszArgsOrg, &argv[iArg], sizeof(argv[0]) * cArgs);
1543	quote_argv(cArgs, &argv[iArg], fWatcomBrainDamage, 0 /fFreeOrLeak/);
1544	#endif
1545
1546	rcExit = kSubmitSendJobMessage(pWorker, pvMsg, cbMsg, 0 /fNoRespawning/, cVerbosity);
1547	if (rcExit == 0)
1548	rcExit = kSubmitMarkActive(pWorker, cVerbosity, pChild, pPidSpawned);
1549
1550	if (!g_fAtExitRegistered)
1551	if (atexit(kSubmitAtExitCallback) == 0)
1552	g_fAtExitRegistered = 1;
1553
1554	#ifdef KBUILD_OS_WINDOWS
1555	for (iArg2 = 0; iArg2 < cArgs; iArg2++)
1556	if (argv[iArg2 + iArg] != papszArgsOrg[iArg2])
1557	{
1558	free(argv[iArg2 + iArg]);
1559	argv[iArg2 + iArg] = papszArgsOrg[iArg2];
1560	}
1561	free(papszArgsOrg);
1562	#endif
1563	}
1564	else
1565	rcExit = 1;
1566	free(pvMsg);
1567	}
1568	else
1569	{
1570	errx(1, "Nothing to executed!");
1571	rcExit = usage(stderr, argv[0]);
1572	}
1573
1574	return rcExit;
1575	}
1576
1577
1578

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

source: kBuild/trunk/src/kmk/kmkbuiltin/kSubmit.c@ 2856

Download in other formats: