kSubmit.c@ 2868

Last change on this file since 2868 was 2868, checked in by bird, 9 years ago
Only invalidate the PATH_OUT and TEMP in kWorker.
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 51.3 KB

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

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

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

Download in other formats: