[1271] | 1 | /* $Id: kSubmit.c 3642 2024-11-02 23:40:35Z bird $ */
|
---|
| 2 | /** @file
|
---|
[2840] | 3 | * kMk Builtin command - submit job to a kWorker.
|
---|
[1527] | 4 | */
|
---|
| 5 |
|
---|
| 6 | /*
|
---|
[2812] | 7 | * Copyright (c) 2007-2016 knut st. osmundsen <bird-kBuild-spamx@anduin.net>
|
---|
[1271] | 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
|
---|
[2019] | 13 | * the Free Software Foundation; either version 3 of the License, or
|
---|
[1271] | 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
|
---|
[2019] | 22 | * along with kBuild. If not, see <http://www.gnu.org/licenses/>
|
---|
[1271] | 23 | *
|
---|
| 24 | */
|
---|
| 25 |
|
---|
| 26 | /*******************************************************************************
|
---|
| 27 | * Header Files *
|
---|
| 28 | *******************************************************************************/
|
---|
[2822] | 29 | #ifdef __APPLE__
|
---|
| 30 | # define _POSIX_C_SOURCE 1 /* 10.4 sdk and unsetenv */
|
---|
| 31 | #endif
|
---|
[3140] | 32 | #include "makeint.h"
|
---|
[2840] | 33 | #include "job.h"
|
---|
| 34 | #include "variable.h"
|
---|
| 35 | #include "pathstuff.h"
|
---|
[1271] | 36 | #include <stdio.h>
|
---|
| 37 | #include <stdlib.h>
|
---|
| 38 | #include <string.h>
|
---|
| 39 | #include <errno.h>
|
---|
[2841] | 40 | #include <assert.h>
|
---|
[2840] | 41 | #ifdef HAVE_ALLOCA_H
|
---|
| 42 | # include <alloca.h>
|
---|
| 43 | #endif
|
---|
[1271] | 44 | #if defined(_MSC_VER)
|
---|
[2812] | 45 | # include <ctype.h>
|
---|
[1271] | 46 | # include <io.h>
|
---|
| 47 | # include <direct.h>
|
---|
| 48 | # include <process.h>
|
---|
| 49 | #else
|
---|
| 50 | # include <unistd.h>
|
---|
| 51 | #endif
|
---|
[2843] | 52 | #ifdef KBUILD_OS_WINDOWS
|
---|
[3156] | 53 | # ifndef CONFIG_NEW_WIN_CHILDREN
|
---|
| 54 | # include "sub_proc.h"
|
---|
| 55 | # else
|
---|
| 56 | # include "../w32/winchildren.h"
|
---|
| 57 | # endif
|
---|
[3198] | 58 | # include "nt/nt_child_inject_standard_handles.h"
|
---|
[2843] | 59 | #endif
|
---|
[1271] | 60 |
|
---|
[2841] | 61 | #include "kbuild.h"
|
---|
[2840] | 62 | #include "kmkbuiltin.h"
|
---|
| 63 | #include "err.h"
|
---|
| 64 |
|
---|
[1271] | 65 |
|
---|
[2812] | 66 | /*********************************************************************************************************************************
|
---|
[2841] | 67 | * Defined Constants And Macros *
|
---|
| 68 | *********************************************************************************************************************************/
|
---|
| 69 | /** Hashes a pid. */
|
---|
| 70 | #define KWORKER_PID_HASH(a_pid) ((size_t)(a_pid) % 61)
|
---|
| 71 |
|
---|
[3198] | 72 | #define TUPLE(a_sz) a_sz, sizeof(a_sz) - 1
|
---|
[2841] | 73 |
|
---|
[3200] | 74 |
|
---|
[2841] | 75 | /*********************************************************************************************************************************
|
---|
[2840] | 76 | * Structures and Typedefs *
|
---|
[2812] | 77 | *********************************************************************************************************************************/
|
---|
[2840] | 78 | typedef struct WORKERINSTANCE *PWORKERINSTANCE;
|
---|
| 79 | typedef struct WORKERINSTANCE
|
---|
[2812] | 80 | {
|
---|
[2840] | 81 | /** Pointer to the next worker instance. */
|
---|
| 82 | PWORKERINSTANCE pNext;
|
---|
| 83 | /** Pointer to the previous worker instance. */
|
---|
| 84 | PWORKERINSTANCE pPrev;
|
---|
[2841] | 85 | /** Pointer to the next worker with the same pid hash slot. */
|
---|
| 86 | PWORKERINSTANCE pNextPidHash;
|
---|
[2840] | 87 | /** 32 or 64. */
|
---|
| 88 | unsigned cBits;
|
---|
[2841] | 89 | /** The process ID of the kWorker process. */
|
---|
| 90 | pid_t pid;
|
---|
[2843] | 91 | union
|
---|
| 92 | {
|
---|
| 93 | struct
|
---|
| 94 | {
|
---|
| 95 | /** The exit code. */
|
---|
| 96 | int32_t rcExit;
|
---|
| 97 | /** Set to 1 if the worker is exiting. */
|
---|
| 98 | uint8_t bWorkerExiting;
|
---|
| 99 | uint8_t abUnused[3];
|
---|
| 100 | } s;
|
---|
| 101 | uint8_t ab[8];
|
---|
| 102 | } Result;
|
---|
| 103 | /** Number of result bytes read alread. */
|
---|
| 104 | size_t cbResultRead;
|
---|
| 105 |
|
---|
[2841] | 106 | #ifdef KBUILD_OS_WINDOWS
|
---|
[2840] | 107 | /** The process handle. */
|
---|
| 108 | HANDLE hProcess;
|
---|
[2841] | 109 | /** The bi-directional pipe we use to talk to the kWorker process. */
|
---|
| 110 | HANDLE hPipe;
|
---|
| 111 | /** For overlapped read (have valid event semaphore). */
|
---|
| 112 | OVERLAPPED OverlappedRead;
|
---|
[3199] | 113 | # ifdef CONFIG_NEW_WIN_CHILDREN
|
---|
| 114 | /** Standard output catcher (reused). */
|
---|
| 115 | PWINCCWPIPE pStdOut;
|
---|
| 116 | /** Standard error catcher (reused). */
|
---|
| 117 | PWINCCWPIPE pStdErr;
|
---|
| 118 | # endif
|
---|
[2841] | 119 | #else
|
---|
| 120 | /** The socket descriptor we use to talk to the kWorker process. */
|
---|
| 121 | int fdSocket;
|
---|
| 122 | #endif
|
---|
[2812] | 123 |
|
---|
[3413] | 124 | /** --debug-dump-history-on-failure. */
|
---|
| 125 | int fDebugDumpHistoryOnFailure;
|
---|
[3313] | 126 | /** Current history index (must mod with aHistory element count). */
|
---|
| 127 | unsigned iHistory;
|
---|
| 128 | /** History. */
|
---|
| 129 | struct
|
---|
| 130 | {
|
---|
| 131 | /** Pointer to the message, NULL if none. */
|
---|
| 132 | void *pvMsg;
|
---|
| 133 | /** The message size, zero if not present. */
|
---|
| 134 | size_t cbMsg;
|
---|
| 135 | } aHistory[4];
|
---|
| 136 |
|
---|
[2841] | 137 | /** What it's busy with. NULL if idle. */
|
---|
| 138 | struct child *pBusyWith;
|
---|
[2840] | 139 | } WORKERINSTANCE;
|
---|
[2812] | 140 |
|
---|
| 141 |
|
---|
[2841] | 142 | typedef struct WORKERLIST
|
---|
| 143 | {
|
---|
| 144 | /** The head of the list. NULL if empty. */
|
---|
| 145 | PWORKERINSTANCE pHead;
|
---|
| 146 | /** The tail of the list. NULL if empty. */
|
---|
| 147 | PWORKERINSTANCE pTail;
|
---|
| 148 | /** Number of list entries. */
|
---|
| 149 | size_t cEntries;
|
---|
| 150 | } WORKERLIST;
|
---|
| 151 | typedef WORKERLIST *PWORKERLIST;
|
---|
| 152 |
|
---|
| 153 |
|
---|
[2840] | 154 | /*********************************************************************************************************************************
|
---|
| 155 | * Global Variables *
|
---|
| 156 | *********************************************************************************************************************************/
|
---|
[2841] | 157 | /** List of idle worker.*/
|
---|
| 158 | static WORKERLIST g_IdleList;
|
---|
| 159 | /** List of busy workers. */
|
---|
| 160 | static WORKERLIST g_BusyList;
|
---|
| 161 | /** PID hash table for the workers.
|
---|
| 162 | * @sa KWORKER_PID_HASH() */
|
---|
| 163 | static PWORKERINSTANCE g_apPidHash[61];
|
---|
[2667] | 164 |
|
---|
[2841] | 165 | #ifdef KBUILD_OS_WINDOWS
|
---|
| 166 | /** For naming the pipes.
|
---|
| 167 | * Also indicates how many worker instances we've spawned. */
|
---|
| 168 | static unsigned g_uWorkerSeqNo = 0;
|
---|
| 169 | #endif
|
---|
[2843] | 170 | /** Set if we've registred the atexit handler already. */
|
---|
| 171 | static int g_fAtExitRegistered = 0;
|
---|
[2667] | 172 |
|
---|
[2841] | 173 | /** @var g_cArchBits
|
---|
| 174 | * The bit count of the architecture this binary is compiled for. */
|
---|
| 175 | /** @var g_szArch
|
---|
| 176 | * The name of the architecture this binary is compiled for. */
|
---|
| 177 | /** @var g_cArchBits
|
---|
| 178 | * The bit count of the alternative architecture. */
|
---|
| 179 | /** @var g_szAltArch
|
---|
| 180 | * The name of the alternative architecture. */
|
---|
| 181 | #if defined(KBUILD_ARCH_AMD64)
|
---|
| 182 | static unsigned g_cArchBits = 64;
|
---|
| 183 | static char const g_szArch[] = "amd64";
|
---|
| 184 | static unsigned g_cAltArchBits = 32;
|
---|
| 185 | static char const g_szAltArch[] = "x86";
|
---|
| 186 | #elif defined(KBUILD_ARCH_X86)
|
---|
| 187 | static unsigned g_cArchBits = 32;
|
---|
| 188 | static char const g_szArch[] = "x86";
|
---|
| 189 | static unsigned g_cAltArchBits = 64;
|
---|
| 190 | static char const g_szAltArch[] = "amd64";
|
---|
[3642] | 191 | #elif defined(KBUILD_ARCH_ARM64)
|
---|
| 192 | static unsigned g_cArchBits = 64;
|
---|
| 193 | static char const g_szArch[] = "arm64";
|
---|
| 194 | static unsigned g_cAltArchBits = 64;
|
---|
| 195 | static char const g_szAltArch[] = "arm64"; /* not used */
|
---|
[2841] | 196 | #else
|
---|
| 197 | # error "Port me!"
|
---|
| 198 | #endif
|
---|
[2747] | 199 |
|
---|
[3198] | 200 | #ifdef KBUILD_OS_WINDOWS
|
---|
[3313] | 201 | /** The processor group allocator state. */
|
---|
| 202 | static MKWINCHILDCPUGROUPALLOCSTATE g_SubmitProcessorGroupAllocator;
|
---|
| 203 | # if K_ARCH_BITS == 64
|
---|
| 204 | /** The processor group allocator state for 32-bit processes. */
|
---|
| 205 | static MKWINCHILDCPUGROUPALLOCSTATE g_SubmitProcessorGroupAllocator32;
|
---|
| 206 | # endif
|
---|
| 207 | #endif
|
---|
| 208 |
|
---|
| 209 | #ifdef KBUILD_OS_WINDOWS
|
---|
[3198] | 210 | /** Pointer to kernel32!SetThreadGroupAffinity. */
|
---|
| 211 | static BOOL (WINAPI *g_pfnSetThreadGroupAffinity)(HANDLE, const GROUP_AFFINITY*, GROUP_AFFINITY *);
|
---|
| 212 | #endif
|
---|
[2841] | 213 |
|
---|
[2843] | 214 |
|
---|
[3198] | 215 |
|
---|
[2841] | 216 | /**
|
---|
| 217 | * Unlinks a worker instance from a list.
|
---|
| 218 | *
|
---|
| 219 | * @param pList The list.
|
---|
| 220 | * @param pWorker The worker.
|
---|
| 221 | */
|
---|
| 222 | static void kSubmitListUnlink(PWORKERLIST pList, PWORKERINSTANCE pWorker)
|
---|
| 223 | {
|
---|
| 224 | PWORKERINSTANCE pNext = pWorker->pNext;
|
---|
| 225 | PWORKERINSTANCE pPrev = pWorker->pPrev;
|
---|
| 226 |
|
---|
| 227 | if (pNext)
|
---|
| 228 | {
|
---|
| 229 | assert(pNext->pPrev == pWorker);
|
---|
| 230 | pNext->pPrev = pPrev;
|
---|
| 231 | }
|
---|
| 232 | else
|
---|
| 233 | {
|
---|
[2846] | 234 | assert(pList->pTail == pWorker);
|
---|
| 235 | pList->pTail = pPrev;
|
---|
[2841] | 236 | }
|
---|
| 237 |
|
---|
| 238 | if (pPrev)
|
---|
| 239 | {
|
---|
| 240 | assert(pPrev->pNext == pWorker);
|
---|
| 241 | pPrev->pNext = pNext;
|
---|
| 242 | }
|
---|
| 243 | else
|
---|
| 244 | {
|
---|
[2846] | 245 | assert(pList->pHead == pWorker);
|
---|
| 246 | pList->pHead = pNext;
|
---|
[2841] | 247 | }
|
---|
| 248 |
|
---|
[2846] | 249 | assert(!pList->pHead || pList->pHead->pPrev == NULL);
|
---|
| 250 | assert(!pList->pTail || pList->pTail->pNext == NULL);
|
---|
| 251 |
|
---|
[2841] | 252 | assert(pList->cEntries > 0);
|
---|
| 253 | pList->cEntries--;
|
---|
| 254 |
|
---|
| 255 | pWorker->pNext = NULL;
|
---|
| 256 | pWorker->pPrev = NULL;
|
---|
| 257 | }
|
---|
| 258 |
|
---|
| 259 |
|
---|
| 260 | /**
|
---|
| 261 | * Appends a worker instance to the tail of a list.
|
---|
| 262 | *
|
---|
| 263 | * @param pList The list.
|
---|
| 264 | * @param pWorker The worker.
|
---|
| 265 | */
|
---|
| 266 | static void kSubmitListAppend(PWORKERLIST pList, PWORKERINSTANCE pWorker)
|
---|
| 267 | {
|
---|
| 268 | PWORKERINSTANCE pTail = pList->pTail;
|
---|
| 269 |
|
---|
| 270 | assert(pTail != pWorker);
|
---|
| 271 | assert(pList->pHead != pWorker);
|
---|
| 272 |
|
---|
| 273 | pWorker->pNext = NULL;
|
---|
| 274 | pWorker->pPrev = pTail;
|
---|
| 275 | if (pTail != NULL)
|
---|
| 276 | {
|
---|
| 277 | assert(pTail->pNext == NULL);
|
---|
| 278 | pTail->pNext = pWorker;
|
---|
| 279 | }
|
---|
| 280 | else
|
---|
| 281 | {
|
---|
| 282 | assert(pList->pHead == NULL);
|
---|
| 283 | pList->pHead = pWorker;
|
---|
| 284 | }
|
---|
[2846] | 285 | pList->pTail = pWorker;
|
---|
[2841] | 286 |
|
---|
[2846] | 287 | assert(pList->pHead->pPrev == NULL);
|
---|
| 288 | assert(pList->pTail->pNext == NULL);
|
---|
| 289 |
|
---|
[2841] | 290 | pList->cEntries++;
|
---|
| 291 | }
|
---|
| 292 |
|
---|
| 293 |
|
---|
| 294 | /**
|
---|
[2843] | 295 | * Remove worker from the process ID hash table.
|
---|
| 296 | *
|
---|
| 297 | * @param pWorker The worker.
|
---|
| 298 | */
|
---|
| 299 | static void kSubmitPidHashRemove(PWORKERINSTANCE pWorker)
|
---|
| 300 | {
|
---|
| 301 | size_t idxHash = KWORKER_PID_HASH(pWorker->pid);
|
---|
| 302 | if (g_apPidHash[idxHash] == pWorker)
|
---|
| 303 | g_apPidHash[idxHash] = pWorker->pNext;
|
---|
| 304 | else
|
---|
| 305 | {
|
---|
| 306 | PWORKERINSTANCE pPrev = g_apPidHash[idxHash];
|
---|
| 307 | while (pPrev && pPrev->pNext != pWorker)
|
---|
| 308 | pPrev = pPrev->pNext;
|
---|
| 309 | assert(pPrev != NULL);
|
---|
| 310 | if (pPrev)
|
---|
| 311 | pPrev->pNext = pWorker->pNext;
|
---|
| 312 | }
|
---|
| 313 | pWorker->pid = -1;
|
---|
| 314 | }
|
---|
| 315 |
|
---|
| 316 |
|
---|
| 317 | /**
|
---|
[2841] | 318 | * Looks up a worker by its process ID.
|
---|
| 319 | *
|
---|
| 320 | * @returns Pointer to the worker instance if found. NULL if not.
|
---|
| 321 | * @param pid The process ID of the worker.
|
---|
| 322 | */
|
---|
| 323 | static PWORKERINSTANCE kSubmitFindWorkerByPid(pid_t pid)
|
---|
| 324 | {
|
---|
| 325 | PWORKERINSTANCE pWorker = g_apPidHash[KWORKER_PID_HASH(pid)];
|
---|
| 326 | while (pWorker && pWorker->pid != pid)
|
---|
| 327 | pWorker = pWorker->pNextPidHash;
|
---|
| 328 | return pWorker;
|
---|
| 329 | }
|
---|
| 330 |
|
---|
| 331 |
|
---|
| 332 | /**
|
---|
[3198] | 333 | * Calcs the path to the kWorker binary for the worker.
|
---|
| 334 | *
|
---|
| 335 | * @returns
|
---|
| 336 | * @param pCtx The command execution context.
|
---|
| 337 | * @param pWorker The worker (for its bitcount).
|
---|
| 338 | * @param pszExecutable The output buffer.
|
---|
| 339 | * @param cbExecutable The output buffer size.
|
---|
| 340 | */
|
---|
| 341 | static int kSubmitCalcExecutablePath(PKMKBUILTINCTX pCtx, PWORKERINSTANCE pWorker, char *pszExecutable, size_t cbExecutable)
|
---|
| 342 | {
|
---|
| 343 | #if defined(KBUILD_OS_WINDOWS) || defined(KBUILD_OS_OS2)
|
---|
| 344 | static const char s_szWorkerName[] = "kWorker.exe";
|
---|
| 345 | #else
|
---|
| 346 | static const char s_szWorkerName[] = "kWorker";
|
---|
| 347 | #endif
|
---|
| 348 | const char *pszBinPath = get_kbuild_bin_path();
|
---|
| 349 | size_t const cchBinPath = strlen(pszBinPath);
|
---|
| 350 | size_t cchExecutable;
|
---|
| 351 | if ( pWorker->cBits == g_cArchBits
|
---|
| 352 | ? cchBinPath + 1 + sizeof(s_szWorkerName) <= cbExecutable
|
---|
| 353 | : cchBinPath + 1 - sizeof(g_szArch) + sizeof(g_szAltArch) + sizeof(s_szWorkerName) <= cbExecutable )
|
---|
| 354 | {
|
---|
| 355 | memcpy(pszExecutable, pszBinPath, cchBinPath);
|
---|
| 356 | cchExecutable = cchBinPath;
|
---|
| 357 |
|
---|
| 358 | /* Replace the arch bin directory extension with the alternative one if requested. */
|
---|
| 359 | if (pWorker->cBits != g_cArchBits)
|
---|
| 360 | {
|
---|
| 361 | if ( cchBinPath < sizeof(g_szArch)
|
---|
| 362 | || memcmp(&pszExecutable[cchBinPath - sizeof(g_szArch) + 1], g_szArch, sizeof(g_szArch) - 1) != 0)
|
---|
| 363 | return errx(pCtx, 1, "KBUILD_BIN_PATH does not end with main architecture (%s) as expected: %s",
|
---|
| 364 | pszBinPath, g_szArch);
|
---|
| 365 | cchExecutable -= sizeof(g_szArch) - 1;
|
---|
| 366 | memcpy(&pszExecutable[cchExecutable], g_szAltArch, sizeof(g_szAltArch) - 1);
|
---|
| 367 | cchExecutable += sizeof(g_szAltArch) - 1;
|
---|
| 368 | }
|
---|
| 369 |
|
---|
| 370 | /* Append a slash and the worker name. */
|
---|
| 371 | pszExecutable[cchExecutable++] = '/';
|
---|
| 372 | memcpy(&pszExecutable[cchExecutable], s_szWorkerName, sizeof(s_szWorkerName));
|
---|
| 373 | return 0;
|
---|
| 374 | }
|
---|
| 375 | return errx(pCtx, 1, "KBUILD_BIN_PATH is too long");
|
---|
| 376 | }
|
---|
| 377 |
|
---|
| 378 |
|
---|
| 379 | #ifdef KBUILD_OS_WINDOWS
|
---|
| 380 | /**
|
---|
| 381 | * Calcs the UTF-16 path to the kWorker binary for the worker.
|
---|
| 382 | *
|
---|
| 383 | * @returns
|
---|
| 384 | * @param pCtx The command execution context.
|
---|
| 385 | * @param pWorker The worker (for its bitcount).
|
---|
| 386 | * @param pwszExecutable The output buffer.
|
---|
| 387 | * @param cwcExecutable The output buffer size.
|
---|
| 388 | */
|
---|
| 389 | static int kSubmitCalcExecutablePathW(PKMKBUILTINCTX pCtx, PWORKERINSTANCE pWorker, wchar_t *pwszExecutable, size_t cwcExecutable)
|
---|
| 390 | {
|
---|
| 391 | char szExecutable[MAX_PATH];
|
---|
| 392 | int rc = kSubmitCalcExecutablePath(pCtx, pWorker, szExecutable, sizeof(szExecutable));
|
---|
| 393 | if (rc == 0)
|
---|
| 394 | {
|
---|
| 395 | int cwc = MultiByteToWideChar(CP_ACP, 0 /*fFlags*/, szExecutable, strlen(szExecutable) + 1,
|
---|
| 396 | pwszExecutable, cwcExecutable);
|
---|
| 397 | if (cwc > 0)
|
---|
| 398 | return 0;
|
---|
| 399 | return errx(pCtx, 1, "MultiByteToWideChar failed on '%s': %u", szExecutable, GetLastError());
|
---|
| 400 | }
|
---|
| 401 | return rc;
|
---|
| 402 | }
|
---|
| 403 | #endif
|
---|
| 404 |
|
---|
| 405 |
|
---|
| 406 | /**
|
---|
[2841] | 407 | * Creates a new worker process.
|
---|
| 408 | *
|
---|
| 409 | * @returns 0 on success, non-zero value on failure.
|
---|
[3192] | 410 | * @param pCtx The command execution context.
|
---|
[2841] | 411 | * @param pWorker The worker structure. Caller does the linking
|
---|
| 412 | * (as we might be reusing an existing worker
|
---|
| 413 | * instance because a worker shut itself down due
|
---|
| 414 | * to high resource leak level).
|
---|
| 415 | * @param cVerbosity The verbosity level.
|
---|
| 416 | */
|
---|
[3192] | 417 | static int kSubmitSpawnWorker(PKMKBUILTINCTX pCtx, PWORKERINSTANCE pWorker, int cVerbosity)
|
---|
[2841] | 418 | {
|
---|
[3198] | 419 | int rc;
|
---|
| 420 | #ifdef KBUILD_OS_WINDOWS
|
---|
| 421 | wchar_t wszExecutable[MAX_PATH];
|
---|
[2841] | 422 | #else
|
---|
[3198] | 423 | PATH_VAR(szExecutable);
|
---|
[2841] | 424 | #endif
|
---|
[3198] | 425 |
|
---|
| 426 | /*
|
---|
| 427 | * Get the output path so it can be passed on as a volatile.
|
---|
| 428 | */
|
---|
| 429 | const char *pszVarVolatile;
|
---|
[2868] | 430 | struct variable *pVarVolatile = lookup_variable(TUPLE("PATH_OUT"));
|
---|
| 431 | if (pVarVolatile)
|
---|
[3198] | 432 | pszVarVolatile = "PATH_OUT";
|
---|
[2868] | 433 | else
|
---|
| 434 | {
|
---|
| 435 | pVarVolatile = lookup_variable(TUPLE("PATH_OUT_BASE"));
|
---|
[3198] | 436 | if (pVarVolatile)
|
---|
| 437 | pszVarVolatile = "PATH_OUT_BASE";
|
---|
| 438 | else
|
---|
[3192] | 439 | warn(pCtx, "Neither PATH_OUT_BASE nor PATH_OUT was found.");
|
---|
[2868] | 440 | }
|
---|
[3198] | 441 | if (pVarVolatile && strchr(pVarVolatile->value, '"'))
|
---|
| 442 | return errx(pCtx, -1, "%s contains double quotes.", pszVarVolatile);
|
---|
| 443 | if (pVarVolatile && strlen(pVarVolatile->value) >= GET_PATH_MAX)
|
---|
| 444 | return errx(pCtx, -1, "%s is too long (max %u)", pszVarVolatile, GET_PATH_MAX);
|
---|
[2841] | 445 |
|
---|
| 446 | /*
|
---|
| 447 | * Construct the executable path.
|
---|
| 448 | */
|
---|
[3198] | 449 | #ifdef KBUILD_OS_WINDOWS
|
---|
| 450 | rc = kSubmitCalcExecutablePathW(pCtx, pWorker, wszExecutable, K_ELEMENTS(wszExecutable));
|
---|
| 451 | #else
|
---|
| 452 | rc = kSubmitCalcExecutablePath(pCtx, pWorker, szExecutable, GET_PATH_MAX);
|
---|
| 453 | #endif
|
---|
| 454 | if (rc == 0)
|
---|
[2841] | 455 | {
|
---|
| 456 | #ifdef KBUILD_OS_WINDOWS
|
---|
[3313] | 457 | static DWORD s_fDenyRemoteClients = ~(DWORD)0;
|
---|
| 458 | wchar_t wszPipeName[128];
|
---|
| 459 | HANDLE hWorkerPipe;
|
---|
| 460 | int iProcessorGroup;
|
---|
[2841] | 461 |
|
---|
[3313] | 462 | # if K_ARCH_BITS == 64
|
---|
| 463 | /** @todo make it return -1 if not applicable (e.g only one group). */
|
---|
| 464 | if (pWorker->cBits != 32)
|
---|
| 465 | iProcessorGroup = MkWinChildAllocateCpuGroup(&g_SubmitProcessorGroupAllocator);
|
---|
| 466 | else
|
---|
| 467 | iProcessorGroup = MkWinChildAllocateCpuGroup(&g_SubmitProcessorGroupAllocator32);
|
---|
| 468 | # else
|
---|
| 469 | iProcessorGroup = MkWinChildAllocateCpuGroup(&g_SubmitProcessorGroupAllocator);
|
---|
| 470 | # endif
|
---|
| 471 |
|
---|
[2841] | 472 | /*
|
---|
[3199] | 473 | * Create the bi-directional pipe with overlapping I/O enabled.
|
---|
[2841] | 474 | */
|
---|
| 475 | if (s_fDenyRemoteClients == ~(DWORD)0)
|
---|
| 476 | s_fDenyRemoteClients = GetVersion() >= 0x60000 ? PIPE_REJECT_REMOTE_CLIENTS : 0;
|
---|
[3198] | 477 | _snwprintf(wszPipeName, sizeof(wszPipeName), L"\\\\.\\pipe\\kmk-%u-kWorker-%u-%u",
|
---|
| 478 | GetCurrentProcessId(), g_uWorkerSeqNo++, GetTickCount());
|
---|
[2841] | 479 | hWorkerPipe = CreateNamedPipeW(wszPipeName,
|
---|
| 480 | PIPE_ACCESS_DUPLEX | FILE_FLAG_OVERLAPPED | FILE_FLAG_FIRST_PIPE_INSTANCE /* win2k sp2+ */,
|
---|
| 481 | PIPE_TYPE_BYTE | PIPE_READMODE_BYTE | PIPE_WAIT | s_fDenyRemoteClients,
|
---|
| 482 | 1 /* cMaxInstances */,
|
---|
| 483 | 64 /*cbOutBuffer*/,
|
---|
| 484 | 65536 /*cbInBuffer*/,
|
---|
| 485 | 0 /*cMsDefaultTimeout -> 50ms*/,
|
---|
[3199] | 486 | NULL /* pSecAttr - no inherit */);
|
---|
[2841] | 487 | if (hWorkerPipe != INVALID_HANDLE_VALUE)
|
---|
| 488 | {
|
---|
| 489 | pWorker->hPipe = CreateFileW(wszPipeName,
|
---|
| 490 | GENERIC_READ | GENERIC_WRITE,
|
---|
| 491 | 0 /* dwShareMode - no sharing */,
|
---|
| 492 | NULL /*pSecAttr - no inherit */,
|
---|
| 493 | OPEN_EXISTING,
|
---|
| 494 | FILE_FLAG_OVERLAPPED,
|
---|
| 495 | NULL /*hTemplate*/);
|
---|
| 496 | if (pWorker->hPipe != INVALID_HANDLE_VALUE)
|
---|
| 497 | {
|
---|
| 498 | pWorker->OverlappedRead.hEvent = CreateEventW(NULL /*pSecAttrs - no inherit*/, TRUE /*bManualReset*/,
|
---|
| 499 | TRUE /*bInitialState*/, NULL /*pwszName*/);
|
---|
| 500 | if (pWorker->OverlappedRead.hEvent != NULL)
|
---|
| 501 | {
|
---|
[3198] | 502 | extern int process_priority; /* main.c */
|
---|
[3313] | 503 | wchar_t wszCommandLine[MAX_PATH * 3 + 32];
|
---|
[3198] | 504 | wchar_t *pwszDst = wszCommandLine;
|
---|
| 505 | size_t cwcDst = K_ELEMENTS(wszCommandLine);
|
---|
| 506 | int cwc;
|
---|
| 507 | DWORD fFlags;
|
---|
| 508 | STARTUPINFOW StartupInfo;
|
---|
| 509 | PROCESS_INFORMATION ProcInfo = { NULL, NULL, 0, 0 };
|
---|
| 510 |
|
---|
| 511 | /*
|
---|
| 512 | * Compose the command line.
|
---|
| 513 | */
|
---|
| 514 | cwc = _snwprintf(pwszDst, cwcDst, L"\"%s\" ", wszExecutable);
|
---|
| 515 | assert(cwc > 0 && cwc < cwcDst);
|
---|
| 516 | pwszDst += cwc;
|
---|
| 517 | cwcDst -= cwc;
|
---|
| 518 | if (pVarVolatile && *pVarVolatile->value)
|
---|
[2868] | 519 | {
|
---|
[3198] | 520 | char chEnd = strchr(pVarVolatile->value, '\0')[-1];
|
---|
| 521 | if (chEnd == '\\')
|
---|
| 522 | cwc = _snwprintf(pwszDst, cwcDst, L" --volatile \"%S.\"", pVarVolatile->value);
|
---|
| 523 | else
|
---|
| 524 | cwc = _snwprintf(pwszDst, cwcDst, L" --volatile \"%S\"", pVarVolatile->value);
|
---|
| 525 | assert(cwc > 0 && cwc < cwcDst);
|
---|
| 526 | pwszDst += cwc;
|
---|
| 527 | cwcDst -= cwc;
|
---|
[3051] | 528 | }
|
---|
[3313] | 529 | if (iProcessorGroup >= 0)
|
---|
| 530 | {
|
---|
| 531 | cwc = _snwprintf(pwszDst, cwcDst, L" --group %d", iProcessorGroup);
|
---|
| 532 | assert(cwc > 0 && cwc < cwcDst);
|
---|
| 533 | pwszDst += cwc;
|
---|
| 534 | cwcDst -= cwc;
|
---|
| 535 | }
|
---|
[3198] | 536 | *pwszDst = '\0';
|
---|
| 537 |
|
---|
| 538 | /*
|
---|
| 539 | * Fill in the startup information.
|
---|
| 540 | */
|
---|
| 541 | memset(&StartupInfo, 0, sizeof(StartupInfo));
|
---|
| 542 | StartupInfo.cb = sizeof(StartupInfo);
|
---|
| 543 | GetStartupInfoW(&StartupInfo);
|
---|
| 544 | StartupInfo.dwFlags &= ~STARTF_USESTDHANDLES;
|
---|
| 545 | StartupInfo.lpReserved2 = NULL;
|
---|
| 546 | StartupInfo.cbReserved2 = 0;
|
---|
| 547 |
|
---|
| 548 | /*
|
---|
| 549 | * Flags and such.
|
---|
| 550 | */
|
---|
| 551 | fFlags = CREATE_SUSPENDED;
|
---|
| 552 | switch (process_priority)
|
---|
[3051] | 553 | {
|
---|
[3198] | 554 | case 1: fFlags |= CREATE_SUSPENDED | IDLE_PRIORITY_CLASS; break;
|
---|
| 555 | case 2: fFlags |= CREATE_SUSPENDED | BELOW_NORMAL_PRIORITY_CLASS; break;
|
---|
| 556 | case 3: fFlags |= CREATE_SUSPENDED | NORMAL_PRIORITY_CLASS; break;
|
---|
| 557 | case 4: fFlags |= CREATE_SUSPENDED | HIGH_PRIORITY_CLASS; break;
|
---|
| 558 | case 5: fFlags |= CREATE_SUSPENDED | REALTIME_PRIORITY_CLASS; break;
|
---|
[3051] | 559 | }
|
---|
[2841] | 560 |
|
---|
| 561 | /*
|
---|
| 562 | * Create the worker process.
|
---|
| 563 | */
|
---|
[3198] | 564 | if (CreateProcessW(wszExecutable, wszCommandLine, NULL /*pProcSecAttr*/, NULL /*pThreadSecAttr*/,
|
---|
| 565 | FALSE /*fInheritHandles*/, fFlags, NULL /*pwszzEnvironment*/,
|
---|
| 566 | NULL /*pwszCwd*/, &StartupInfo, &ProcInfo))
|
---|
[2841] | 567 | {
|
---|
[3198] | 568 | char szErrMsg[256];
|
---|
| 569 | BOOL afReplace[3] = { TRUE, FALSE, FALSE };
|
---|
| 570 | HANDLE ahReplace[3] = { hWorkerPipe, INVALID_HANDLE_VALUE, INVALID_HANDLE_VALUE };
|
---|
[3199] | 571 | if (pWorker->pStdOut)
|
---|
| 572 | {
|
---|
| 573 | afReplace[1] = TRUE;
|
---|
| 574 | afReplace[2] = TRUE;
|
---|
| 575 | ahReplace[1] = pWorker->pStdOut->hPipeChild;
|
---|
| 576 | ahReplace[2] = pWorker->pStdErr->hPipeChild;
|
---|
| 577 | }
|
---|
| 578 |
|
---|
[3198] | 579 | rc = nt_child_inject_standard_handles(ProcInfo.hProcess, afReplace, ahReplace, szErrMsg, sizeof(szErrMsg));
|
---|
| 580 | if (rc == 0)
|
---|
| 581 | {
|
---|
| 582 | BOOL fRet;
|
---|
| 583 | switch (process_priority)
|
---|
| 584 | {
|
---|
| 585 | case 1: fRet = SetThreadPriority(ProcInfo.hThread, THREAD_PRIORITY_IDLE); break;
|
---|
| 586 | case 2: fRet = SetThreadPriority(ProcInfo.hThread, THREAD_PRIORITY_BELOW_NORMAL); break;
|
---|
| 587 | case 3: fRet = SetThreadPriority(ProcInfo.hThread, THREAD_PRIORITY_NORMAL); break;
|
---|
| 588 | case 4: fRet = SetThreadPriority(ProcInfo.hThread, THREAD_PRIORITY_HIGHEST); break;
|
---|
| 589 | case 5: fRet = SetThreadPriority(ProcInfo.hThread, THREAD_PRIORITY_TIME_CRITICAL); break;
|
---|
| 590 | default: fRet = TRUE;
|
---|
| 591 | }
|
---|
| 592 | if (!fRet)
|
---|
| 593 | warnx(pCtx, "warning: failed to set kWorker thread priority: %u\n", GetLastError());
|
---|
| 594 |
|
---|
[3313] | 595 | if (iProcessorGroup >= 0 && g_pfnSetThreadGroupAffinity)
|
---|
[3198] | 596 | {
|
---|
[3355] | 597 | GROUP_AFFINITY OldAff = { 0, 0, 0, 0, 0 };
|
---|
| 598 | GROUP_AFFINITY NewAff = { 0 /* == all active apparently */, (WORD)iProcessorGroup, 0, 0, 0 };
|
---|
[3198] | 599 | if (!g_pfnSetThreadGroupAffinity(ProcInfo.hThread, &NewAff, &OldAff))
|
---|
| 600 | warnx(pCtx, "warning: Failed to set processor group to %d: %u\n",
|
---|
| 601 | iProcessorGroup, GetLastError());
|
---|
| 602 | }
|
---|
| 603 |
|
---|
| 604 | /*
|
---|
| 605 | * Now, we just need to resume the thread.
|
---|
| 606 | */
|
---|
| 607 | if (ResumeThread(ProcInfo.hThread))
|
---|
| 608 | {
|
---|
| 609 | CloseHandle(hWorkerPipe);
|
---|
| 610 | CloseHandle(ProcInfo.hThread);
|
---|
| 611 | pWorker->pid = ProcInfo.dwProcessId;
|
---|
| 612 | pWorker->hProcess = ProcInfo.hProcess;
|
---|
| 613 | if (cVerbosity > 0)
|
---|
| 614 | warnx(pCtx, "created %d bit worker %d\n", pWorker->cBits, pWorker->pid);
|
---|
| 615 | return 0;
|
---|
| 616 | }
|
---|
| 617 |
|
---|
| 618 | /*
|
---|
| 619 | * Failed, bail out.
|
---|
| 620 | */
|
---|
| 621 | rc = errx(pCtx, -3, "ResumeThread failed: %u", GetLastError());
|
---|
| 622 | }
|
---|
| 623 | else
|
---|
| 624 | rc = errx(pCtx, -3, "%s", szErrMsg);
|
---|
| 625 | TerminateProcess(ProcInfo.hProcess, 1234);
|
---|
| 626 | CloseHandle(ProcInfo.hThread);
|
---|
| 627 | CloseHandle(ProcInfo.hProcess);
|
---|
[2841] | 628 | }
|
---|
[3198] | 629 | else
|
---|
[3199] | 630 | rc = errx(pCtx, -2, "CreateProcessW failed: %u (exe=%S cmdline=%S)",
|
---|
[3198] | 631 | GetLastError(), wszExecutable, wszCommandLine);
|
---|
[2841] | 632 | CloseHandle(pWorker->OverlappedRead.hEvent);
|
---|
| 633 | pWorker->OverlappedRead.hEvent = INVALID_HANDLE_VALUE;
|
---|
| 634 | }
|
---|
| 635 | else
|
---|
[3198] | 636 | rc = errx(pCtx, -1, "CreateEventW failed: %u", GetLastError());
|
---|
[2841] | 637 | CloseHandle(pWorker->hPipe);
|
---|
| 638 | pWorker->hPipe = INVALID_HANDLE_VALUE;
|
---|
| 639 | }
|
---|
| 640 | else
|
---|
[3198] | 641 | rc = errx(pCtx, -1, "Opening named pipe failed: %u", GetLastError());
|
---|
[2841] | 642 | CloseHandle(hWorkerPipe);
|
---|
| 643 | }
|
---|
| 644 | else
|
---|
[3198] | 645 | rc = errx(pCtx, -1, "CreateNamedPipeW failed: %u", GetLastError());
|
---|
[2841] | 646 |
|
---|
| 647 | #else
|
---|
| 648 | /*
|
---|
| 649 | * Create a socket pair.
|
---|
| 650 | */
|
---|
[3198] | 651 | int aiPair[2] = { -1, -1 };
|
---|
[2841] | 652 | if (socketpair(AF_LOCAL, SOCK_STREAM, 0, aiPair) == 0)
|
---|
[3198] | 653 | {
|
---|
[2841] | 654 | pWorker->fdSocket = aiPair[1];
|
---|
[3198] | 655 |
|
---|
| 656 | rc = -1;
|
---|
| 657 | }
|
---|
[2841] | 658 | else
|
---|
[3198] | 659 | rc = err(pCtx, -1, "socketpair");
|
---|
[2841] | 660 | #endif
|
---|
| 661 | }
|
---|
| 662 | else
|
---|
[3198] | 663 | rc = errx(pCtx, -1, "KBUILD_BIN_PATH is too long");
|
---|
| 664 | return rc;
|
---|
[2841] | 665 | }
|
---|
| 666 |
|
---|
| 667 |
|
---|
| 668 | /**
|
---|
| 669 | * Selects an idle worker or spawns a new one.
|
---|
| 670 | *
|
---|
| 671 | * @returns Pointer to the selected worker instance. NULL on error.
|
---|
[3192] | 672 | * @param pCtx The command execution context.
|
---|
[2841] | 673 | * @param pWorker The idle worker instance to respawn.
|
---|
| 674 | * On failure this will be freed!
|
---|
| 675 | * @param cBitsWorker The worker bitness - 64 or 32.
|
---|
| 676 | */
|
---|
[3192] | 677 | static int kSubmitRespawnWorker(PKMKBUILTINCTX pCtx, PWORKERINSTANCE pWorker, int cVerbosity)
|
---|
[2841] | 678 | {
|
---|
| 679 | /*
|
---|
| 680 | * Clean up after the old worker.
|
---|
| 681 | */
|
---|
| 682 | #ifdef KBUILD_OS_WINDOWS
|
---|
| 683 | DWORD rcWait;
|
---|
| 684 |
|
---|
| 685 | /* Close the pipe handle first, breaking the pipe in case it's not already
|
---|
| 686 | busted up. Close the event semaphore too before waiting for the process. */
|
---|
[2843] | 687 | if (pWorker->hPipe != INVALID_HANDLE_VALUE)
|
---|
| 688 | {
|
---|
| 689 | if (!CloseHandle(pWorker->hPipe))
|
---|
[3192] | 690 | warnx(pCtx, "CloseHandle(pWorker->hPipe): %u", GetLastError());
|
---|
[2843] | 691 | pWorker->hPipe = INVALID_HANDLE_VALUE;
|
---|
| 692 | }
|
---|
[2841] | 693 |
|
---|
| 694 | if (!CloseHandle(pWorker->OverlappedRead.hEvent))
|
---|
[3192] | 695 | warnx(pCtx, "CloseHandle(pWorker->OverlappedRead.hEvent): %u", GetLastError());
|
---|
[2841] | 696 | pWorker->OverlappedRead.hEvent = INVALID_HANDLE_VALUE;
|
---|
| 697 |
|
---|
[3199] | 698 | if (pWorker->pStdOut)
|
---|
| 699 | MkWinChildcareWorkerDrainPipes(NULL, pWorker->pStdOut, pWorker->pStdErr);
|
---|
| 700 |
|
---|
[2841] | 701 | /* It's probably shutdown already, if not give it 10 milliseconds before
|
---|
| 702 | we terminate it forcefully. */
|
---|
| 703 | rcWait = WaitForSingleObject(pWorker->hProcess, 10);
|
---|
| 704 | if (rcWait != WAIT_OBJECT_0)
|
---|
| 705 | {
|
---|
| 706 | BOOL fRc = TerminateProcess(pWorker->hProcess, 127);
|
---|
[3199] | 707 |
|
---|
| 708 | if (pWorker->pStdOut)
|
---|
| 709 | MkWinChildcareWorkerDrainPipes(NULL, pWorker->pStdOut, pWorker->pStdErr);
|
---|
| 710 |
|
---|
[2841] | 711 | rcWait = WaitForSingleObject(pWorker->hProcess, 100);
|
---|
| 712 | if (rcWait != WAIT_OBJECT_0)
|
---|
[3192] | 713 | warnx(pCtx, "WaitForSingleObject returns %u (and TerminateProcess %d)", rcWait, fRc);
|
---|
[2841] | 714 | }
|
---|
| 715 |
|
---|
[3199] | 716 | if (pWorker->pStdOut)
|
---|
| 717 | MkWinChildcareWorkerDrainPipes(NULL, pWorker->pStdOut, pWorker->pStdErr);
|
---|
| 718 |
|
---|
[2841] | 719 | if (!CloseHandle(pWorker->hProcess))
|
---|
[3192] | 720 | warnx(pCtx, "CloseHandle(pWorker->hProcess): %u", GetLastError());
|
---|
[2841] | 721 | pWorker->hProcess = INVALID_HANDLE_VALUE;
|
---|
| 722 |
|
---|
| 723 | #else
|
---|
| 724 | pid_t pidWait;
|
---|
| 725 | int rc;
|
---|
| 726 |
|
---|
[2843] | 727 | if (pWorker->fdSocket != -1)
|
---|
| 728 | {
|
---|
| 729 | if (close(pWorker->fdSocket) != 0)
|
---|
[3192] | 730 | warn(pCtx, "close(pWorker->fdSocket)");
|
---|
[2843] | 731 | pWorker->fdSocket = -1;
|
---|
| 732 | }
|
---|
[2841] | 733 |
|
---|
| 734 | kill(pWorker->pid, SIGTERM);
|
---|
| 735 | pidWait = waitpid(pWorker->pid, &rc, 0);
|
---|
| 736 | if (pidWait != pWorker->pid)
|
---|
[3192] | 737 | warn(pCtx, "waitpid(pWorker->pid,,0)");
|
---|
[2841] | 738 | #endif
|
---|
| 739 |
|
---|
| 740 | /*
|
---|
| 741 | * Unlink it from the hash table.
|
---|
| 742 | */
|
---|
[2843] | 743 | kSubmitPidHashRemove(pWorker);
|
---|
[2841] | 744 |
|
---|
| 745 | /*
|
---|
| 746 | * Respawn it.
|
---|
| 747 | */
|
---|
[3192] | 748 | if (kSubmitSpawnWorker(pCtx, pWorker, cVerbosity) == 0)
|
---|
[2841] | 749 | {
|
---|
| 750 | /*
|
---|
| 751 | * Insert it into the process ID hash table and idle list.
|
---|
| 752 | */
|
---|
| 753 | size_t idxHash = KWORKER_PID_HASH(pWorker->pid);
|
---|
| 754 | pWorker->pNextPidHash = g_apPidHash[idxHash];
|
---|
| 755 | g_apPidHash[idxHash] = pWorker;
|
---|
| 756 | return 0;
|
---|
| 757 | }
|
---|
| 758 |
|
---|
| 759 | kSubmitListUnlink(&g_IdleList, pWorker);
|
---|
| 760 | free(pWorker);
|
---|
| 761 | return -1;
|
---|
| 762 | }
|
---|
| 763 |
|
---|
| 764 |
|
---|
| 765 | /**
|
---|
| 766 | * Selects an idle worker or spawns a new one.
|
---|
| 767 | *
|
---|
| 768 | * @returns Pointer to the selected worker instance. NULL on error.
|
---|
| 769 | * @param cBitsWorker The worker bitness - 64 or 32.
|
---|
| 770 | */
|
---|
[3192] | 771 | static PWORKERINSTANCE kSubmitSelectWorkSpawnNewIfNecessary(PKMKBUILTINCTX pCtx, unsigned cBitsWorker, int cVerbosity)
|
---|
[2841] | 772 | {
|
---|
| 773 | /*
|
---|
| 774 | * Lookup up an idle worker.
|
---|
| 775 | */
|
---|
| 776 | PWORKERINSTANCE pWorker = g_IdleList.pHead;
|
---|
| 777 | while (pWorker)
|
---|
| 778 | {
|
---|
| 779 | if (pWorker->cBits == cBitsWorker)
|
---|
| 780 | return pWorker;
|
---|
| 781 | pWorker = pWorker->pNext;
|
---|
| 782 | }
|
---|
| 783 |
|
---|
| 784 | /*
|
---|
| 785 | * Create a new worker instance.
|
---|
| 786 | */
|
---|
| 787 | pWorker = (PWORKERINSTANCE)xcalloc(sizeof(*pWorker));
|
---|
| 788 | pWorker->cBits = cBitsWorker;
|
---|
[3199] | 789 | #if defined(CONFIG_NEW_WIN_CHILDREN) && defined(KBUILD_OS_WINDOWS)
|
---|
| 790 | if (output_sync != OUTPUT_SYNC_NONE)
|
---|
[2841] | 791 | {
|
---|
[3199] | 792 | pWorker->pStdOut = MkWinChildcareCreateWorkerPipe(1, g_uWorkerSeqNo << 1);
|
---|
| 793 | pWorker->pStdErr = MkWinChildcareCreateWorkerPipe(2, g_uWorkerSeqNo << 1);
|
---|
| 794 | }
|
---|
| 795 | if ( output_sync == OUTPUT_SYNC_NONE
|
---|
| 796 | || ( pWorker->pStdOut != NULL
|
---|
| 797 | && pWorker->pStdErr != NULL))
|
---|
| 798 | #endif
|
---|
| 799 | {
|
---|
| 800 | if (kSubmitSpawnWorker(pCtx, pWorker, cVerbosity) == 0)
|
---|
| 801 | {
|
---|
| 802 | /*
|
---|
| 803 | * Insert it into the process ID hash table and idle list.
|
---|
| 804 | */
|
---|
| 805 | size_t idxHash = KWORKER_PID_HASH(pWorker->pid);
|
---|
| 806 | pWorker->pNextPidHash = g_apPidHash[idxHash];
|
---|
| 807 | g_apPidHash[idxHash] = pWorker;
|
---|
[2841] | 808 |
|
---|
[3199] | 809 | kSubmitListAppend(&g_IdleList, pWorker);
|
---|
| 810 | return pWorker;
|
---|
| 811 | }
|
---|
[2841] | 812 | }
|
---|
[3199] | 813 | #if defined(CONFIG_NEW_WIN_CHILDREN) && defined(KBUILD_OS_WINDOWS)
|
---|
| 814 | if (pWorker->pStdErr)
|
---|
| 815 | MkWinChildcareDeleteWorkerPipe(pWorker->pStdErr);
|
---|
| 816 | if (pWorker->pStdOut)
|
---|
| 817 | MkWinChildcareDeleteWorkerPipe(pWorker->pStdOut);
|
---|
| 818 | #endif
|
---|
[2841] | 819 |
|
---|
| 820 | free(pWorker);
|
---|
| 821 | return NULL;
|
---|
| 822 | }
|
---|
| 823 |
|
---|
| 824 |
|
---|
| 825 | /**
|
---|
| 826 | * Composes a JOB mesage for a worker.
|
---|
| 827 | *
|
---|
| 828 | * @returns Pointer to the message.
|
---|
[2876] | 829 | * @param pszExecutable The executable to run.
|
---|
| 830 | * @param papszArgs The argument vector.
|
---|
| 831 | * @param papszEnvVars The environment vector.
|
---|
| 832 | * @param pszCwd The current directory.
|
---|
| 833 | * @param fWatcomBrainDamage The wcc/wcc386 workaround.
|
---|
[2959] | 834 | * @param fNoPchCaching Whether to disable precompiled header caching.
|
---|
[3313] | 835 | * @param pszSpecialEnv Environment variable (name=value) subject to
|
---|
| 836 | * special expansion in kWorker. NULL if none.
|
---|
[2894] | 837 | * @param papszPostCmdArgs The post command and it's arguments.
|
---|
| 838 | * @param cPostCmdArgs Number of post command argument, including the
|
---|
| 839 | * command. Zero if no post command scheduled.
|
---|
[2876] | 840 | * @param pcbMsg Where to return the message length.
|
---|
[2841] | 841 | */
|
---|
| 842 | static void *kSubmitComposeJobMessage(const char *pszExecutable, char **papszArgs, char **papszEnvVars,
|
---|
[3313] | 843 | const char *pszCwd, int fWatcomBrainDamage, int fNoPchCaching, const char *pszSpecialEnv,
|
---|
[2894] | 844 | char **papszPostCmdArgs, uint32_t cPostCmdArgs, uint32_t *pcbMsg)
|
---|
[2841] | 845 | {
|
---|
| 846 | size_t cbTmp;
|
---|
[3313] | 847 | size_t cbSpecialEnv;
|
---|
[2844] | 848 | uint32_t i;
|
---|
[2841] | 849 | uint32_t cbMsg;
|
---|
[2844] | 850 | uint32_t cArgs;
|
---|
| 851 | uint32_t cEnvVars;
|
---|
[2841] | 852 | uint8_t *pbMsg;
|
---|
| 853 | uint8_t *pbCursor;
|
---|
| 854 |
|
---|
| 855 | /*
|
---|
[2844] | 856 | * Adjust input.
|
---|
| 857 | */
|
---|
| 858 | if (!pszExecutable)
|
---|
| 859 | pszExecutable = papszArgs[0];
|
---|
| 860 |
|
---|
| 861 | /*
|
---|
[2841] | 862 | * Calculate the message length first.
|
---|
| 863 | */
|
---|
| 864 | cbMsg = sizeof(cbMsg);
|
---|
| 865 | cbMsg += sizeof("JOB");
|
---|
| 866 | cbMsg += strlen(pszExecutable) + 1;
|
---|
[2844] | 867 | cbMsg += strlen(pszCwd) + 1;
|
---|
[2841] | 868 |
|
---|
[2844] | 869 | cbMsg += sizeof(cArgs);
|
---|
[2841] | 870 | for (i = 0; papszArgs[i] != NULL; i++)
|
---|
[2844] | 871 | cbMsg += 1 + strlen(papszArgs[i]) + 1;
|
---|
| 872 | cArgs = i;
|
---|
[2841] | 873 |
|
---|
[2844] | 874 | cbMsg += sizeof(cArgs);
|
---|
[2841] | 875 | for (i = 0; papszEnvVars[i] != NULL; i++)
|
---|
| 876 | cbMsg += strlen(papszEnvVars[i]) + 1;
|
---|
[2844] | 877 | cEnvVars = i;
|
---|
[2841] | 878 |
|
---|
[2959] | 879 | cbMsg += 1; /* fWatcomBrainDamage */
|
---|
| 880 | cbMsg += 1; /* fNoPchCaching */
|
---|
[2841] | 881 |
|
---|
[3313] | 882 | cbSpecialEnv = pszSpecialEnv ? strchr(pszSpecialEnv, '=') - pszSpecialEnv : 0;
|
---|
| 883 | cbMsg += cbSpecialEnv + 1;
|
---|
| 884 |
|
---|
[2894] | 885 | cbMsg += sizeof(cPostCmdArgs);
|
---|
| 886 | for (i = 0; i < cPostCmdArgs; i++)
|
---|
| 887 | cbMsg += strlen(papszPostCmdArgs[i]) + 1;
|
---|
| 888 |
|
---|
[2841] | 889 | /*
|
---|
| 890 | * Compose the message.
|
---|
| 891 | */
|
---|
| 892 | pbMsg = pbCursor = xmalloc(cbMsg);
|
---|
| 893 |
|
---|
[2894] | 894 | /* header */
|
---|
[2841] | 895 | memcpy(pbCursor, &cbMsg, sizeof(cbMsg));
|
---|
| 896 | pbCursor += sizeof(cbMsg);
|
---|
| 897 | memcpy(pbCursor, "JOB", sizeof("JOB"));
|
---|
| 898 | pbCursor += sizeof("JOB");
|
---|
| 899 |
|
---|
[2894] | 900 | /* executable. */
|
---|
[2841] | 901 | cbTmp = strlen(pszExecutable) + 1;
|
---|
| 902 | memcpy(pbCursor, pszExecutable, cbTmp);
|
---|
| 903 | pbCursor += cbTmp;
|
---|
| 904 |
|
---|
[2894] | 905 | /* cwd */
|
---|
[2844] | 906 | cbTmp = strlen(pszCwd) + 1;
|
---|
| 907 | memcpy(pbCursor, pszCwd, cbTmp);
|
---|
| 908 | pbCursor += cbTmp;
|
---|
| 909 |
|
---|
[3313] | 910 | /* arguments */
|
---|
[2844] | 911 | memcpy(pbCursor, &cArgs, sizeof(cArgs));
|
---|
| 912 | pbCursor += sizeof(cArgs);
|
---|
[2841] | 913 | for (i = 0; papszArgs[i] != NULL; i++)
|
---|
| 914 | {
|
---|
[2844] | 915 | *pbCursor++ = 0; /* Argument expansion flags (MSC, EMX). */
|
---|
[2841] | 916 | cbTmp = strlen(papszArgs[i]) + 1;
|
---|
| 917 | memcpy(pbCursor, papszArgs[i], cbTmp);
|
---|
| 918 | pbCursor += cbTmp;
|
---|
| 919 | }
|
---|
[2844] | 920 | assert(i == cArgs);
|
---|
[2841] | 921 |
|
---|
[2894] | 922 | /* environment */
|
---|
[2844] | 923 | memcpy(pbCursor, &cEnvVars, sizeof(cEnvVars));
|
---|
| 924 | pbCursor += sizeof(cEnvVars);
|
---|
[2841] | 925 | for (i = 0; papszEnvVars[i] != NULL; i++)
|
---|
| 926 | {
|
---|
| 927 | cbTmp = strlen(papszEnvVars[i]) + 1;
|
---|
| 928 | memcpy(pbCursor, papszEnvVars[i], cbTmp);
|
---|
| 929 | pbCursor += cbTmp;
|
---|
| 930 | }
|
---|
[2844] | 931 | assert(i == cEnvVars);
|
---|
[2841] | 932 |
|
---|
[2894] | 933 | /* flags */
|
---|
[2876] | 934 | *pbCursor++ = fWatcomBrainDamage != 0;
|
---|
[2959] | 935 | *pbCursor++ = fNoPchCaching != 0;
|
---|
[2876] | 936 |
|
---|
[3313] | 937 | /* Special environment variable name. */
|
---|
| 938 | memcpy(pbCursor, pszSpecialEnv, cbSpecialEnv);
|
---|
| 939 | pbCursor += cbSpecialEnv;
|
---|
| 940 | *pbCursor++ = '\0';
|
---|
| 941 |
|
---|
[2894] | 942 | /* post command */
|
---|
| 943 | memcpy(pbCursor, &cPostCmdArgs, sizeof(cPostCmdArgs));
|
---|
| 944 | pbCursor += sizeof(cPostCmdArgs);
|
---|
| 945 | for (i = 0; i < cPostCmdArgs; i++)
|
---|
| 946 | {
|
---|
| 947 | cbTmp = strlen(papszPostCmdArgs[i]) + 1;
|
---|
| 948 | memcpy(pbCursor, papszPostCmdArgs[i], cbTmp);
|
---|
| 949 | pbCursor += cbTmp;
|
---|
| 950 | }
|
---|
| 951 | assert(i == cPostCmdArgs);
|
---|
| 952 |
|
---|
[2841] | 953 | assert(pbCursor - pbMsg == (size_t)cbMsg);
|
---|
| 954 |
|
---|
[2894] | 955 | /*
|
---|
| 956 | * Done.
|
---|
| 957 | */
|
---|
[2841] | 958 | *pcbMsg = cbMsg;
|
---|
| 959 | return pbMsg;
|
---|
| 960 | }
|
---|
| 961 |
|
---|
| 962 |
|
---|
| 963 | /**
|
---|
| 964 | * Sends the job message to the given worker, respawning the worker if
|
---|
| 965 | * necessary.
|
---|
| 966 | *
|
---|
| 967 | * @returns 0 on success, non-zero on failure.
|
---|
| 968 | *
|
---|
[3192] | 969 | * @param pCtx The command execution context.
|
---|
[2841] | 970 | * @param pWorker The work to send the request to. The worker is
|
---|
| 971 | * on the idle list.
|
---|
| 972 | * @param pvMsg The message to send.
|
---|
| 973 | * @param cbMsg The size of the message.
|
---|
[2843] | 974 | * @param fNoRespawning Set if
|
---|
[2841] | 975 | * @param cVerbosity The verbosity level.
|
---|
| 976 | */
|
---|
[3192] | 977 | static int kSubmitSendJobMessage(PKMKBUILTINCTX pCtx, PWORKERINSTANCE pWorker, void const *pvMsg, uint32_t cbMsg,
|
---|
| 978 | int fNoRespawning, int cVerbosity)
|
---|
[2841] | 979 | {
|
---|
[2843] | 980 | int cRetries;
|
---|
| 981 |
|
---|
| 982 | /*
|
---|
| 983 | * Respawn the worker if it stopped by itself and we closed the pipe already.
|
---|
| 984 | */
|
---|
| 985 | #ifdef KBUILD_OS_WINDOWS
|
---|
| 986 | if (pWorker->hPipe == INVALID_HANDLE_VALUE)
|
---|
| 987 | #else
|
---|
| 988 | if (pWorker->fdSocket == -1)
|
---|
| 989 | #endif
|
---|
[2841] | 990 | {
|
---|
[2843] | 991 | if (!fNoRespawning)
|
---|
| 992 | {
|
---|
| 993 | if (cVerbosity > 0)
|
---|
[3192] | 994 | warnx(pCtx, "Respawning worker (#1)...\n");
|
---|
| 995 | if (kSubmitRespawnWorker(pCtx, pWorker, cVerbosity) != 0)
|
---|
[2843] | 996 | return 2;
|
---|
| 997 | }
|
---|
| 998 |
|
---|
| 999 | }
|
---|
| 1000 |
|
---|
| 1001 | /*
|
---|
| 1002 | * Restart-on-broken-pipe loop. Necessary?
|
---|
| 1003 | */
|
---|
| 1004 | for (cRetries = !fNoRespawning ? 1 : 0; ; cRetries--)
|
---|
| 1005 | {
|
---|
[2841] | 1006 | /*
|
---|
| 1007 | * Try write the message.
|
---|
| 1008 | */
|
---|
| 1009 | uint32_t cbLeft = cbMsg;
|
---|
| 1010 | uint8_t const *pbLeft = (uint8_t const *)pvMsg;
|
---|
| 1011 | #ifdef KBUILD_OS_WINDOWS
|
---|
| 1012 | DWORD dwErr;
|
---|
| 1013 | DWORD cbWritten;
|
---|
| 1014 | while (WriteFile(pWorker->hPipe, pbLeft, cbLeft, &cbWritten, NULL /*pOverlapped*/))
|
---|
| 1015 | {
|
---|
| 1016 | assert(cbWritten <= cbLeft);
|
---|
| 1017 | cbLeft -= cbWritten;
|
---|
| 1018 | if (!cbLeft)
|
---|
| 1019 | return 0;
|
---|
| 1020 |
|
---|
| 1021 | /* This scenario shouldn't really ever happen. But just in case... */
|
---|
| 1022 | pbLeft += cbWritten;
|
---|
| 1023 | }
|
---|
| 1024 | dwErr = GetLastError();
|
---|
| 1025 | if ( ( dwErr != ERROR_BROKEN_PIPE
|
---|
| 1026 | && dwErr != ERROR_NO_DATA)
|
---|
| 1027 | || cRetries <= 0)
|
---|
[3192] | 1028 | return errx(pCtx, 1, "Error writing to worker: %u", dwErr);
|
---|
[2841] | 1029 | #else
|
---|
| 1030 | ssize_t cbWritten
|
---|
| 1031 | while ((cbWritten = write(pWorker->fdSocket, pbLeft, cbLeft)) >= 0)
|
---|
| 1032 | {
|
---|
| 1033 | assert(cbWritten <= cbLeft);
|
---|
| 1034 | cbLeft -= cbWritten;
|
---|
| 1035 | if (!cbLeft)
|
---|
| 1036 | return 0;
|
---|
| 1037 |
|
---|
| 1038 | pbLeft += cbWritten;
|
---|
| 1039 | }
|
---|
| 1040 | if ( ( errno != EPIPE
|
---|
| 1041 | && errno != ENOTCONN
|
---|
| 1042 | && errno != ECONNRESET))
|
---|
| 1043 | || cRetries <= 0)
|
---|
[3192] | 1044 | return err(pCtx, 1, "Error writing to worker");
|
---|
[2841] | 1045 | # error "later"
|
---|
| 1046 | #endif
|
---|
| 1047 |
|
---|
| 1048 | /*
|
---|
| 1049 | * Broken connection. Try respawn the worker.
|
---|
| 1050 | */
|
---|
[2843] | 1051 | if (cVerbosity > 0)
|
---|
[3192] | 1052 | warnx(pCtx, "Respawning worker (#2)...\n");
|
---|
| 1053 | if (kSubmitRespawnWorker(pCtx, pWorker, cVerbosity) != 0)
|
---|
[2841] | 1054 | return 2;
|
---|
| 1055 | }
|
---|
| 1056 | }
|
---|
| 1057 |
|
---|
| 1058 |
|
---|
| 1059 | /**
|
---|
[2843] | 1060 | * Closes the connection on a worker that said it is going to exit now.
|
---|
| 1061 | *
|
---|
| 1062 | * This is a way of dealing with imperfect resource management in the worker, it
|
---|
| 1063 | * will monitor it a little and trigger a respawn when it looks bad.
|
---|
| 1064 | *
|
---|
| 1065 | * This function just closes the pipe / socket connection to the worker. The
|
---|
| 1066 | * kSubmitSendJobMessage function will see this a trigger a respawn the next
|
---|
| 1067 | * time the worker is engaged. This will usually mean there's a little delay in
|
---|
| 1068 | * which the process can terminate without us having to actively wait for it.
|
---|
| 1069 | *
|
---|
[3192] | 1070 | * @param pCtx The command execution context.
|
---|
[2843] | 1071 | * @param pWorker The worker instance.
|
---|
| 1072 | */
|
---|
[3192] | 1073 | static void kSubmitCloseConnectOnExitingWorker(PKMKBUILTINCTX pCtx, PWORKERINSTANCE pWorker)
|
---|
[2843] | 1074 | {
|
---|
| 1075 | #ifdef KBUILD_OS_WINDOWS
|
---|
| 1076 | if (!CloseHandle(pWorker->hPipe))
|
---|
[3192] | 1077 | warnx(pCtx, "CloseHandle(pWorker->hPipe): %u", GetLastError());
|
---|
[2843] | 1078 | pWorker->hPipe = INVALID_HANDLE_VALUE;
|
---|
| 1079 | #else
|
---|
| 1080 | if (close(pWorker->fdSocket) != 0)
|
---|
[3192] | 1081 | warn(pCtx, "close(pWorker->fdSocket)");
|
---|
[2843] | 1082 | pWorker->fdSocket = -1;
|
---|
| 1083 | #endif
|
---|
| 1084 | }
|
---|
| 1085 |
|
---|
| 1086 |
|
---|
| 1087 | #ifdef KBUILD_OS_WINDOWS
|
---|
| 1088 |
|
---|
| 1089 | /**
|
---|
| 1090 | * Handles read failure.
|
---|
| 1091 | *
|
---|
| 1092 | * @returns Exit code.
|
---|
[3192] | 1093 | * @param pCtx The command execution context.
|
---|
[2843] | 1094 | * @param pWorker The worker instance.
|
---|
| 1095 | * @param dwErr The error code.
|
---|
[2879] | 1096 | * @param pszWhere Where it failed.
|
---|
[2843] | 1097 | */
|
---|
[3192] | 1098 | static int kSubmitWinReadFailed(PKMKBUILTINCTX pCtx, PWORKERINSTANCE pWorker, DWORD dwErr, const char *pszWhere)
|
---|
[2843] | 1099 | {
|
---|
| 1100 | DWORD dwExitCode;
|
---|
| 1101 |
|
---|
| 1102 | if (pWorker->cbResultRead == 0)
|
---|
[3192] | 1103 | errx(pCtx, 1, "%s/ReadFile failed: %u", pszWhere, dwErr);
|
---|
[2843] | 1104 | else
|
---|
[3192] | 1105 | errx(pCtx, 1, "%s/ReadFile failed: %u (read %u bytes)", pszWhere, dwErr, pWorker->cbResultRead);
|
---|
[2843] | 1106 | assert(dwErr != 0);
|
---|
| 1107 |
|
---|
| 1108 | /* Complete the result. */
|
---|
| 1109 | pWorker->Result.s.rcExit = 127;
|
---|
| 1110 | pWorker->Result.s.bWorkerExiting = 1;
|
---|
| 1111 | pWorker->cbResultRead = sizeof(pWorker->Result);
|
---|
| 1112 |
|
---|
| 1113 | if (GetExitCodeProcess(pWorker->hProcess, &dwExitCode))
|
---|
| 1114 | {
|
---|
| 1115 | if (dwExitCode != 0)
|
---|
| 1116 | pWorker->Result.s.rcExit = dwExitCode;
|
---|
| 1117 | }
|
---|
| 1118 |
|
---|
| 1119 | return dwErr != 0 ? (int)(dwErr & 0x7fffffff) : 0x7fffffff;
|
---|
| 1120 |
|
---|
| 1121 | }
|
---|
| 1122 |
|
---|
| 1123 |
|
---|
| 1124 | /**
|
---|
| 1125 | * Used by
|
---|
[2844] | 1126 | * @returns 0 if we got the whole result, -1 if I/O is pending, and windows last
|
---|
[2843] | 1127 | * error on ReadFile failure.
|
---|
[3192] | 1128 | * @param pCtx The command execution context.
|
---|
[2843] | 1129 | * @param pWorker The worker instance.
|
---|
| 1130 | */
|
---|
[3192] | 1131 | static int kSubmitReadMoreResultWin(PKMKBUILTINCTX pCtx, PWORKERINSTANCE pWorker, const char *pszWhere)
|
---|
[2843] | 1132 | {
|
---|
| 1133 | /*
|
---|
| 1134 | * Set up the result read, telling the sub_proc.c unit about it.
|
---|
| 1135 | */
|
---|
| 1136 | while (pWorker->cbResultRead < sizeof(pWorker->Result))
|
---|
| 1137 | {
|
---|
| 1138 | DWORD cbRead = 0;
|
---|
| 1139 |
|
---|
| 1140 | BOOL fRc = ResetEvent(pWorker->OverlappedRead.hEvent);
|
---|
| 1141 | assert(fRc); (void)fRc;
|
---|
| 1142 |
|
---|
| 1143 | pWorker->OverlappedRead.Offset = 0;
|
---|
| 1144 | pWorker->OverlappedRead.OffsetHigh = 0;
|
---|
| 1145 |
|
---|
| 1146 | if (!ReadFile(pWorker->hPipe, &pWorker->Result.ab[pWorker->cbResultRead],
|
---|
| 1147 | sizeof(pWorker->Result) - pWorker->cbResultRead,
|
---|
| 1148 | &cbRead,
|
---|
| 1149 | &pWorker->OverlappedRead))
|
---|
| 1150 | {
|
---|
| 1151 | DWORD dwErr = GetLastError();
|
---|
| 1152 | if (dwErr == ERROR_IO_PENDING)
|
---|
[2844] | 1153 | return -1;
|
---|
[3192] | 1154 | return kSubmitWinReadFailed(pCtx, pWorker, dwErr, pszWhere);
|
---|
[2843] | 1155 | }
|
---|
| 1156 |
|
---|
| 1157 | pWorker->cbResultRead += cbRead;
|
---|
| 1158 | assert(pWorker->cbResultRead <= sizeof(pWorker->Result));
|
---|
| 1159 | }
|
---|
| 1160 | return 0;
|
---|
| 1161 | }
|
---|
| 1162 |
|
---|
| 1163 | #endif /* KBUILD_OS_WINDOWS */
|
---|
| 1164 |
|
---|
[3313] | 1165 |
|
---|
[2843] | 1166 | /**
|
---|
[3313] | 1167 | * Adds the given message to the history.
|
---|
| 1168 | *
|
---|
| 1169 | * @returns Pointer to old message, or NULL if no old msg to free.
|
---|
| 1170 | * @param pWorker The worker instance.
|
---|
| 1171 | * @param pvMsg The message.
|
---|
| 1172 | * @param cbMsg The message size.
|
---|
| 1173 | */
|
---|
| 1174 | static void *kSubmitUpdateHistory(PWORKERINSTANCE pWorker, void *pvMsg, size_t cbMsg)
|
---|
| 1175 | {
|
---|
| 1176 | unsigned iHistory = pWorker->iHistory % K_ELEMENTS(pWorker->aHistory);
|
---|
| 1177 | void *pvRet;
|
---|
| 1178 | pWorker->iHistory++;
|
---|
| 1179 | pvRet = pWorker->aHistory[iHistory].pvMsg;
|
---|
| 1180 | pWorker->aHistory[iHistory].pvMsg = pvMsg;
|
---|
| 1181 | pWorker->aHistory[iHistory].cbMsg = cbMsg;
|
---|
| 1182 | return pvRet;
|
---|
| 1183 | }
|
---|
| 1184 |
|
---|
| 1185 | typedef struct HISTORYDUMPBUF
|
---|
| 1186 | {
|
---|
| 1187 | char *pszBuf;
|
---|
| 1188 | size_t cbBuf;
|
---|
| 1189 | size_t off;
|
---|
| 1190 | PKMKBUILTINCTX pCtx;
|
---|
| 1191 | } HISTORYDUMPBUF;
|
---|
| 1192 |
|
---|
| 1193 |
|
---|
| 1194 | static void kSubmitDumpHistoryWrite(HISTORYDUMPBUF *pBuf, const char *pch, size_t cch)
|
---|
| 1195 | {
|
---|
| 1196 | if (pBuf->off + cch >= pBuf->cbBuf)
|
---|
| 1197 | {
|
---|
| 1198 | size_t cbNew = pBuf->cbBuf ? pBuf->cbBuf * 2 : 65536;
|
---|
| 1199 | while (pBuf->off + cch >= cbNew)
|
---|
| 1200 | cbNew *= 2;
|
---|
| 1201 | pBuf->pszBuf = (char *)xrealloc(pBuf->pszBuf, cbNew);
|
---|
| 1202 | pBuf->cbBuf = cbNew;
|
---|
| 1203 | }
|
---|
| 1204 |
|
---|
| 1205 | memcpy(&pBuf->pszBuf[pBuf->off], pch, cch);
|
---|
| 1206 | pBuf->off += cch;
|
---|
| 1207 | pBuf->pszBuf[pBuf->off] = '\0';
|
---|
| 1208 | }
|
---|
| 1209 |
|
---|
| 1210 | static void kSubmitDumpHistoryPrintf(HISTORYDUMPBUF *pBuf, const char *pszFormat, ...)
|
---|
| 1211 | {
|
---|
| 1212 | char szTmp[32];
|
---|
| 1213 | va_list va;
|
---|
| 1214 | va_start(va, pszFormat);
|
---|
| 1215 | for (;;)
|
---|
| 1216 | {
|
---|
| 1217 | const char *pszPct = strchr(pszFormat, '%');
|
---|
| 1218 | if (!pszPct)
|
---|
| 1219 | {
|
---|
| 1220 | kSubmitDumpHistoryWrite(pBuf, pszFormat, strlen(pszFormat));
|
---|
| 1221 | return;
|
---|
| 1222 | }
|
---|
| 1223 | if (pszPct != pszFormat)
|
---|
| 1224 | {
|
---|
| 1225 | kSubmitDumpHistoryWrite(pBuf, pszFormat, pszPct - pszFormat);
|
---|
| 1226 | pszFormat = pszPct;
|
---|
| 1227 | }
|
---|
| 1228 | pszFormat++;
|
---|
| 1229 | switch (*pszFormat++)
|
---|
| 1230 | {
|
---|
| 1231 | case 's':
|
---|
| 1232 | {
|
---|
| 1233 | const char * const psz = va_arg(va, const char *);
|
---|
| 1234 | size_t const cch = strlen(psz);
|
---|
[3363] | 1235 | if (cch == 0 || memchr(psz, '\'', cch))
|
---|
[3313] | 1236 | {
|
---|
| 1237 | kSubmitDumpHistoryWrite(pBuf, TUPLE("\"")); /** @todo what if there are '"' in the string? */
|
---|
| 1238 | kSubmitDumpHistoryWrite(pBuf, psz, cch);
|
---|
| 1239 | kSubmitDumpHistoryWrite(pBuf, TUPLE("\""));
|
---|
| 1240 | }
|
---|
| 1241 | else if ( !memchr(psz, ' ', cch)
|
---|
[3363] | 1242 | && !memchr(psz, '\\', cch)
|
---|
[3313] | 1243 | && !memchr(psz, '\t', cch)
|
---|
| 1244 | && !memchr(psz, '\n', cch)
|
---|
| 1245 | && !memchr(psz, '\r', cch)
|
---|
| 1246 | && !memchr(psz, '&', cch)
|
---|
| 1247 | && !memchr(psz, ';', cch)
|
---|
| 1248 | && !memchr(psz, '|', cch))
|
---|
| 1249 | kSubmitDumpHistoryWrite(pBuf, psz, cch);
|
---|
| 1250 | else
|
---|
| 1251 | {
|
---|
| 1252 | kSubmitDumpHistoryWrite(pBuf, TUPLE("'"));
|
---|
| 1253 | kSubmitDumpHistoryWrite(pBuf, psz, strlen(psz));
|
---|
| 1254 | kSubmitDumpHistoryWrite(pBuf, TUPLE("'"));
|
---|
| 1255 | }
|
---|
| 1256 | break;
|
---|
| 1257 | }
|
---|
| 1258 |
|
---|
| 1259 | case 'd':
|
---|
| 1260 | {
|
---|
| 1261 | int iValue = va_arg(va, int);
|
---|
| 1262 | kSubmitDumpHistoryWrite(pBuf, szTmp, snprintf(szTmp, sizeof(szTmp), "%d", iValue));
|
---|
| 1263 | break;
|
---|
| 1264 | }
|
---|
| 1265 |
|
---|
| 1266 | case 'u':
|
---|
| 1267 | {
|
---|
| 1268 | unsigned uValue = va_arg(va, unsigned);
|
---|
| 1269 | kSubmitDumpHistoryWrite(pBuf, szTmp, snprintf(szTmp, sizeof(szTmp), "%u", uValue));
|
---|
| 1270 | break;
|
---|
| 1271 | }
|
---|
| 1272 |
|
---|
| 1273 | case '%':
|
---|
| 1274 | kSubmitDumpHistoryWrite(pBuf, "%s", 1);
|
---|
| 1275 | break;
|
---|
| 1276 |
|
---|
| 1277 | default:
|
---|
| 1278 | assert(0);
|
---|
| 1279 | }
|
---|
| 1280 | }
|
---|
| 1281 | va_end(va);
|
---|
| 1282 | }
|
---|
| 1283 |
|
---|
| 1284 | static void kSubmitDumpHistoryFlush(HISTORYDUMPBUF *pBuf)
|
---|
| 1285 | {
|
---|
| 1286 | if (pBuf->off > 0)
|
---|
| 1287 | output_write_text(pBuf->pCtx->pOut, 1, pBuf->pszBuf, pBuf->off);
|
---|
| 1288 | pBuf->off = 0;
|
---|
| 1289 | }
|
---|
| 1290 |
|
---|
| 1291 | /**
|
---|
| 1292 | * Dumps the history for this worker to stderr in the given context.
|
---|
| 1293 | *
|
---|
| 1294 | * @param pCtx The command execution context. (Typically not a
|
---|
| 1295 | * real context.)
|
---|
| 1296 | * @param pWorker The worker instance.
|
---|
| 1297 | */
|
---|
| 1298 | static void kSubmitDumpHistory(PKMKBUILTINCTX pCtx, PWORKERINSTANCE pWorker)
|
---|
| 1299 | {
|
---|
| 1300 | HISTORYDUMPBUF Buf = { NULL, 0, 0, pCtx };
|
---|
| 1301 | int iHistory = pWorker->iHistory;
|
---|
| 1302 | unsigned cDumped = 0;
|
---|
| 1303 |
|
---|
| 1304 | while (cDumped < K_ELEMENTS(pWorker->aHistory) && iHistory > 0)
|
---|
| 1305 | {
|
---|
| 1306 | unsigned const idx = (unsigned)--iHistory % K_ELEMENTS(pWorker->aHistory);
|
---|
| 1307 | const char *pszMsg = (const char *)pWorker->aHistory[idx].pvMsg;
|
---|
| 1308 | ssize_t cbMsg = pWorker->aHistory[idx].cbMsg;
|
---|
| 1309 | const char *pszExe;
|
---|
| 1310 | const char *pszCwd;
|
---|
| 1311 | uint32_t i;
|
---|
| 1312 | uint32_t cArgs;
|
---|
| 1313 | const char *pszArgs;
|
---|
| 1314 | size_t cbArgs;
|
---|
| 1315 | uint32_t cEnvVars;
|
---|
| 1316 | const char *pszEnvVars;
|
---|
| 1317 | size_t cbEnvVars;
|
---|
| 1318 | const char *pszSpecialEnv;
|
---|
| 1319 | char fNoPchCaching;
|
---|
| 1320 | char fWatcomBrainDamage;
|
---|
| 1321 | uint32_t cPostArgs;
|
---|
| 1322 | const char *pszPostArgs;
|
---|
| 1323 | size_t cbPostArgs;
|
---|
| 1324 |
|
---|
| 1325 | cDumped++;
|
---|
| 1326 | if (!pszMsg || !cbMsg)
|
---|
| 1327 | break;
|
---|
| 1328 |
|
---|
| 1329 | #define SKIP_BYTES(a_cbSkip) do { pszMsg += (a_cbSkip); cbMsg -= (a_cbSkip); } while (0)
|
---|
| 1330 | #define SKIP_STR() do { size_t const cbToSkip = strlen(pszMsg) + 1; SKIP_BYTES(cbToSkip); } while (0)
|
---|
| 1331 | #define SKIP_STRING_ARRAY(a_cStrings, a_cbPreable) do { \
|
---|
| 1332 | for (i = 0; i < (a_cStrings) && cbMsg > 0; i++) { \
|
---|
| 1333 | size_t const cbToSkip = (a_cbPreable) + strlen(pszMsg + (a_cbPreable)) + 1; \
|
---|
| 1334 | SKIP_BYTES(cbToSkip); \
|
---|
| 1335 | } } while (0)
|
---|
| 1336 |
|
---|
| 1337 | /* Decode it: */
|
---|
| 1338 | SKIP_BYTES(sizeof(uint32_t) + sizeof("JOB"));
|
---|
| 1339 | pszExe = pszMsg;
|
---|
| 1340 | SKIP_STR();
|
---|
| 1341 | pszCwd = pszMsg;
|
---|
| 1342 | SKIP_STR();
|
---|
| 1343 |
|
---|
| 1344 | cArgs = *(uint32_t *)pszMsg;
|
---|
| 1345 | SKIP_BYTES(sizeof(uint32_t));
|
---|
| 1346 | pszArgs = pszMsg;
|
---|
| 1347 | SKIP_STRING_ARRAY(cArgs, 1 /*fbFlags*/);
|
---|
| 1348 | cbArgs = pszMsg - pszArgs;
|
---|
| 1349 |
|
---|
| 1350 | cEnvVars = *(uint32_t *)pszMsg;
|
---|
| 1351 | SKIP_BYTES(sizeof(uint32_t));
|
---|
| 1352 | pszEnvVars = pszMsg;
|
---|
| 1353 | SKIP_STRING_ARRAY(cEnvVars, 0);
|
---|
| 1354 | cbEnvVars = pszMsg - pszEnvVars;
|
---|
| 1355 |
|
---|
| 1356 | fWatcomBrainDamage = pszMsg[0] != '\0';
|
---|
| 1357 | fNoPchCaching = pszMsg[1] != '\0';
|
---|
| 1358 | SKIP_BYTES(2);
|
---|
| 1359 |
|
---|
| 1360 | pszSpecialEnv = pszMsg;
|
---|
| 1361 | SKIP_STR();
|
---|
| 1362 |
|
---|
| 1363 | cPostArgs = *(uint32_t *)pszMsg;
|
---|
| 1364 | SKIP_BYTES(sizeof(uint32_t));
|
---|
| 1365 | pszPostArgs = pszMsg;
|
---|
| 1366 | SKIP_STRING_ARRAY(cPostArgs, 0);
|
---|
| 1367 | cbPostArgs = pszMsg - pszPostArgs;
|
---|
| 1368 |
|
---|
| 1369 | /* Produce parseable output: */
|
---|
| 1370 | kSubmitDumpHistoryPrintf(&Buf, "kWorker %u/%u:\n\tkSubmit", (long)pWorker->pid, iHistory, pszExe);
|
---|
| 1371 | if (fNoPchCaching)
|
---|
| 1372 | kSubmitDumpHistoryWrite(&Buf, TUPLE(" --no-pch-caching"));
|
---|
| 1373 | if (fWatcomBrainDamage)
|
---|
| 1374 | kSubmitDumpHistoryWrite(&Buf, TUPLE(" --watcom-brain-damage"));
|
---|
| 1375 | if (pszSpecialEnv)
|
---|
| 1376 | kSubmitDumpHistoryPrintf(&Buf, " --special-env %s", pszSpecialEnv);
|
---|
| 1377 | kSubmitDumpHistoryPrintf(&Buf, " --chdir %s \\\n", pszCwd);
|
---|
| 1378 |
|
---|
| 1379 | pszMsg = pszEnvVars;
|
---|
| 1380 | cbMsg = cbEnvVars;
|
---|
| 1381 | for (i = 0; i < cEnvVars && cbMsg > 0; i++)
|
---|
| 1382 | {
|
---|
| 1383 | kSubmitDumpHistoryPrintf(&Buf, "\t--putenv %s \\\n", pszMsg);
|
---|
| 1384 | SKIP_STR();
|
---|
| 1385 | }
|
---|
| 1386 |
|
---|
| 1387 | if (cPostArgs > 0)
|
---|
| 1388 | {
|
---|
| 1389 | kSubmitDumpHistoryWrite(&Buf, TUPLE("\t--post-cmd "));
|
---|
| 1390 | pszMsg = pszPostArgs;
|
---|
| 1391 | cbMsg = cbPostArgs;
|
---|
| 1392 | for (i = 0; i < cPostArgs && cbMsg > 0; i++)
|
---|
| 1393 | {
|
---|
| 1394 | kSubmitDumpHistoryPrintf(&Buf, " %s", pszMsg);
|
---|
| 1395 | SKIP_STR();
|
---|
| 1396 | }
|
---|
| 1397 | kSubmitDumpHistoryWrite(&Buf, TUPLE(" \\\n"));
|
---|
| 1398 | }
|
---|
| 1399 | kSubmitDumpHistoryWrite(&Buf, TUPLE("\t-- \\\n"));
|
---|
| 1400 |
|
---|
| 1401 | pszMsg = pszArgs;
|
---|
| 1402 | cbMsg = cbArgs;
|
---|
| 1403 | for (i = 0; i < cArgs && cbMsg > 0; i++)
|
---|
| 1404 | {
|
---|
| 1405 | SKIP_BYTES(1);
|
---|
| 1406 | kSubmitDumpHistoryPrintf(&Buf, i + 1 < cArgs ? "\t%s \\\n" : "\t%s\n", pszMsg);
|
---|
| 1407 | SKIP_STR();
|
---|
| 1408 | }
|
---|
| 1409 |
|
---|
| 1410 | #undef SKIP_BYTES
|
---|
| 1411 | #undef SKIP_STR
|
---|
| 1412 | #undef SKIP_STRING_ARRAY
|
---|
| 1413 | }
|
---|
| 1414 |
|
---|
| 1415 | kSubmitDumpHistoryFlush(&Buf);
|
---|
| 1416 | free(Buf.pszBuf);
|
---|
| 1417 | }
|
---|
| 1418 |
|
---|
| 1419 |
|
---|
| 1420 | /**
|
---|
[2843] | 1421 | * Marks the worker active.
|
---|
| 1422 | *
|
---|
| 1423 | * On windows this involves setting up the async result read and telling
|
---|
| 1424 | * sub_proc.c about the process.
|
---|
| 1425 | *
|
---|
| 1426 | * @returns Exit code.
|
---|
[3192] | 1427 | * @param pCtx The command execution context.
|
---|
[2843] | 1428 | * @param pWorker The worker instance to mark as active.
|
---|
| 1429 | * @param cVerbosity The verbosity level.
|
---|
| 1430 | * @param pChild The kmk child to associate the job with.
|
---|
| 1431 | * @param pPidSpawned If @a *pPidSpawned is non-zero if the child is
|
---|
| 1432 | * running, otherwise the worker is already done
|
---|
| 1433 | * and we've returned the exit code of the job.
|
---|
| 1434 | */
|
---|
[3192] | 1435 | static int kSubmitMarkActive(PKMKBUILTINCTX pCtx, PWORKERINSTANCE pWorker, int cVerbosity, struct child *pChild, pid_t *pPidSpawned)
|
---|
[2843] | 1436 | {
|
---|
| 1437 | #ifdef KBUILD_OS_WINDOWS
|
---|
| 1438 | int rc;
|
---|
| 1439 | #endif
|
---|
| 1440 |
|
---|
| 1441 | pWorker->cbResultRead = 0;
|
---|
| 1442 |
|
---|
| 1443 | #ifdef KBUILD_OS_WINDOWS
|
---|
| 1444 | /*
|
---|
| 1445 | * Setup the async result read on windows. If we're slow and the worker
|
---|
| 1446 | * very fast, this may actually get the result immediately.
|
---|
| 1447 | */
|
---|
| 1448 | l_again:
|
---|
[3192] | 1449 | rc = kSubmitReadMoreResultWin(pCtx, pWorker, "kSubmitMarkActive");
|
---|
[2843] | 1450 | if (rc == -1)
|
---|
| 1451 | {
|
---|
[3156] | 1452 | # ifndef CONFIG_NEW_WIN_CHILDREN
|
---|
[2844] | 1453 | if (process_kmk_register_submit(pWorker->OverlappedRead.hEvent, (intptr_t)pWorker, pPidSpawned) == 0)
|
---|
[2843] | 1454 | { /* likely */ }
|
---|
| 1455 | else
|
---|
| 1456 | {
|
---|
| 1457 | /* We need to do the waiting here because sub_proc.c has too much to do. */
|
---|
[3192] | 1458 | warnx(pCtx, "Too many processes for sub_proc.c to handle!");
|
---|
[2843] | 1459 | WaitForSingleObject(pWorker->OverlappedRead.hEvent, INFINITE);
|
---|
| 1460 | goto l_again;
|
---|
| 1461 | }
|
---|
[3156] | 1462 | # else
|
---|
[3199] | 1463 | if (MkWinChildCreateSubmit((intptr_t)pWorker->OverlappedRead.hEvent, pWorker,
|
---|
[3200] | 1464 | pWorker->pStdOut, pWorker->pStdErr, pChild, pPidSpawned) == 0)
|
---|
[3156] | 1465 | { /* likely */ }
|
---|
| 1466 | else
|
---|
| 1467 | {
|
---|
| 1468 | /* We need to do the waiting here because sub_proc.c has too much to do. */
|
---|
[3192] | 1469 | warnx(pCtx, "MkWinChildCreateSubmit failed!");
|
---|
[3156] | 1470 | WaitForSingleObject(pWorker->OverlappedRead.hEvent, INFINITE);
|
---|
| 1471 | goto l_again;
|
---|
| 1472 | }
|
---|
| 1473 | # endif
|
---|
[2843] | 1474 | }
|
---|
| 1475 | else
|
---|
| 1476 | {
|
---|
| 1477 | assert(rc == 0 || pWorker->Result.s.rcExit != 0);
|
---|
| 1478 | if (pWorker->Result.s.bWorkerExiting)
|
---|
[3192] | 1479 | kSubmitCloseConnectOnExitingWorker(pCtx, pWorker);
|
---|
[3313] | 1480 | if (pWorker->Result.s.rcExit && 1)
|
---|
| 1481 | kSubmitDumpHistory(pCtx, pWorker);
|
---|
[2843] | 1482 | *pPidSpawned = 0;
|
---|
| 1483 | return pWorker->Result.s.rcExit;
|
---|
| 1484 | }
|
---|
| 1485 | #endif
|
---|
| 1486 |
|
---|
| 1487 | /*
|
---|
| 1488 | * Mark it busy and move it to the active instance.
|
---|
| 1489 | */
|
---|
| 1490 | pWorker->pBusyWith = pChild;
|
---|
[2844] | 1491 | #ifndef KBUILD_OS_WINDOWS
|
---|
[2843] | 1492 | *pPidSpawned = pWorker->pid;
|
---|
[2844] | 1493 | #endif
|
---|
[2843] | 1494 |
|
---|
| 1495 | kSubmitListUnlink(&g_IdleList, pWorker);
|
---|
| 1496 | kSubmitListAppend(&g_BusyList, pWorker);
|
---|
| 1497 | return 0;
|
---|
| 1498 | }
|
---|
| 1499 |
|
---|
| 1500 |
|
---|
| 1501 | #ifdef KBUILD_OS_WINDOWS
|
---|
| 1502 |
|
---|
| 1503 | /**
|
---|
| 1504 | * Retrieve the worker child result.
|
---|
| 1505 | *
|
---|
| 1506 | * If incomplete, we restart the ReadFile operation like kSubmitMarkActive does.
|
---|
| 1507 | *
|
---|
| 1508 | * @returns 0 on success, -1 if ReadFile was restarted.
|
---|
| 1509 | * @param pvUser The worker instance.
|
---|
[3224] | 1510 | * @param fBlock if we're to block waiting for the result or not.
|
---|
[2843] | 1511 | * @param prcExit Where to return the exit code.
|
---|
| 1512 | * @param piSigNo Where to return the signal number.
|
---|
| 1513 | */
|
---|
[3224] | 1514 | int kSubmitSubProcGetResult(intptr_t pvUser, int fBlock, int *prcExit, int *piSigNo)
|
---|
[2843] | 1515 | {
|
---|
| 1516 | PWORKERINSTANCE pWorker = (PWORKERINSTANCE)pvUser;
|
---|
[3192] | 1517 | KMKBUILTINCTX FakeCtx = { "kSubmit/GetResult", NULL };
|
---|
| 1518 | PKMKBUILTINCTX pCtx = &FakeCtx;
|
---|
[2843] | 1519 |
|
---|
| 1520 | /*
|
---|
| 1521 | * Get the overlapped result. There should be one since we're here
|
---|
| 1522 | * because of a satisfied WaitForMultipleObject.
|
---|
| 1523 | */
|
---|
| 1524 | DWORD cbRead = 0;
|
---|
[3224] | 1525 | if (GetOverlappedResult(pWorker->hPipe, &pWorker->OverlappedRead, &cbRead, fBlock ? TRUE : FALSE))
|
---|
[2843] | 1526 | {
|
---|
| 1527 | pWorker->cbResultRead += cbRead;
|
---|
| 1528 | assert(pWorker->cbResultRead <= sizeof(pWorker->Result));
|
---|
| 1529 |
|
---|
| 1530 | /* More to be read? */
|
---|
| 1531 | while (pWorker->cbResultRead < sizeof(pWorker->Result))
|
---|
| 1532 | {
|
---|
[3192] | 1533 | int rc = kSubmitReadMoreResultWin(pCtx, pWorker, "kSubmitSubProcGetResult/more");
|
---|
[2843] | 1534 | if (rc == -1)
|
---|
| 1535 | return -1;
|
---|
| 1536 | assert(rc == 0 || pWorker->Result.s.rcExit != 0);
|
---|
| 1537 | }
|
---|
| 1538 | assert(pWorker->cbResultRead == sizeof(pWorker->Result));
|
---|
| 1539 | }
|
---|
| 1540 | else
|
---|
| 1541 | {
|
---|
| 1542 | DWORD dwErr = GetLastError();
|
---|
[3224] | 1543 | if (dwErr == ERROR_IO_INCOMPLETE && !fBlock)
|
---|
| 1544 | return -1;
|
---|
[3192] | 1545 | kSubmitWinReadFailed(pCtx, pWorker, dwErr, "kSubmitSubProcGetResult/result");
|
---|
[2843] | 1546 | }
|
---|
| 1547 |
|
---|
| 1548 | /*
|
---|
| 1549 | * Okay, we've got a result.
|
---|
| 1550 | */
|
---|
| 1551 | *prcExit = pWorker->Result.s.rcExit;
|
---|
| 1552 | switch (pWorker->Result.s.rcExit)
|
---|
| 1553 | {
|
---|
| 1554 | default: *piSigNo = 0; break;
|
---|
| 1555 | case CONTROL_C_EXIT: *piSigNo = SIGINT; break;
|
---|
| 1556 | case STATUS_INTEGER_DIVIDE_BY_ZERO: *piSigNo = SIGFPE; break;
|
---|
| 1557 | case STATUS_ACCESS_VIOLATION: *piSigNo = SIGSEGV; break;
|
---|
| 1558 | case STATUS_PRIVILEGED_INSTRUCTION:
|
---|
| 1559 | case STATUS_ILLEGAL_INSTRUCTION: *piSigNo = SIGILL; break;
|
---|
| 1560 | }
|
---|
[3413] | 1561 | if (pWorker->Result.s.rcExit && pWorker->fDebugDumpHistoryOnFailure)
|
---|
[3313] | 1562 | kSubmitDumpHistory(pCtx, pWorker);
|
---|
[2884] | 1563 | if (pWorker->Result.s.bWorkerExiting)
|
---|
[3192] | 1564 | kSubmitCloseConnectOnExitingWorker(pCtx, pWorker);
|
---|
[2846] | 1565 |
|
---|
[2843] | 1566 | return 0;
|
---|
| 1567 | }
|
---|
| 1568 |
|
---|
| 1569 |
|
---|
| 1570 | int kSubmitSubProcKill(intptr_t pvUser, int iSignal)
|
---|
| 1571 | {
|
---|
| 1572 | return -1;
|
---|
| 1573 | }
|
---|
| 1574 |
|
---|
[2846] | 1575 |
|
---|
| 1576 | /**
|
---|
| 1577 | * Called by process_cleanup when it's done with the worker.
|
---|
| 1578 | *
|
---|
| 1579 | * @param pvUser The worker instance.
|
---|
| 1580 | */
|
---|
| 1581 | void kSubmitSubProcCleanup(intptr_t pvUser)
|
---|
| 1582 | {
|
---|
| 1583 | PWORKERINSTANCE pWorker = (PWORKERINSTANCE)pvUser;
|
---|
| 1584 | kSubmitListUnlink(&g_BusyList, pWorker);
|
---|
| 1585 | kSubmitListAppend(&g_IdleList, pWorker);
|
---|
| 1586 | }
|
---|
| 1587 |
|
---|
[2843] | 1588 | #endif /* KBUILD_OS_WINDOWS */
|
---|
| 1589 |
|
---|
| 1590 |
|
---|
| 1591 | /**
|
---|
| 1592 | * atexit callback that trigger worker termination.
|
---|
| 1593 | */
|
---|
| 1594 | static void kSubmitAtExitCallback(void)
|
---|
| 1595 | {
|
---|
| 1596 | PWORKERINSTANCE pWorker;
|
---|
| 1597 | DWORD msStartTick;
|
---|
| 1598 | DWORD cKillRaids = 0;
|
---|
[3192] | 1599 | KMKBUILTINCTX FakeCtx = { "kSubmit/atexit", NULL };
|
---|
| 1600 | PKMKBUILTINCTX pCtx = &FakeCtx;
|
---|
[2843] | 1601 |
|
---|
| 1602 | /*
|
---|
| 1603 | * Tell all the workers to exit by breaking the connection.
|
---|
| 1604 | */
|
---|
| 1605 | for (pWorker = g_IdleList.pHead; pWorker != NULL; pWorker = pWorker->pNext)
|
---|
[3192] | 1606 | kSubmitCloseConnectOnExitingWorker(pCtx, pWorker);
|
---|
[2843] | 1607 | for (pWorker = g_BusyList.pHead; pWorker != NULL; pWorker = pWorker->pNext)
|
---|
[3192] | 1608 | kSubmitCloseConnectOnExitingWorker(pCtx, pWorker);
|
---|
[2843] | 1609 |
|
---|
| 1610 | /*
|
---|
| 1611 | * Wait a little while for them to stop.
|
---|
| 1612 | */
|
---|
| 1613 | Sleep(0);
|
---|
| 1614 | msStartTick = GetTickCount();
|
---|
| 1615 | for (;;)
|
---|
| 1616 | {
|
---|
| 1617 | /*
|
---|
| 1618 | * Collect handles of running processes.
|
---|
| 1619 | */
|
---|
| 1620 | PWORKERINSTANCE apWorkers[MAXIMUM_WAIT_OBJECTS];
|
---|
| 1621 | HANDLE ahHandles[MAXIMUM_WAIT_OBJECTS];
|
---|
[2844] | 1622 | DWORD cHandles = 0;
|
---|
[2843] | 1623 |
|
---|
| 1624 | for (pWorker = g_IdleList.pHead; pWorker != NULL; pWorker = pWorker->pNext)
|
---|
| 1625 | if (pWorker->hProcess != INVALID_HANDLE_VALUE)
|
---|
| 1626 | {
|
---|
| 1627 | if (cHandles < MAXIMUM_WAIT_OBJECTS)
|
---|
| 1628 | {
|
---|
| 1629 | apWorkers[cHandles] = pWorker;
|
---|
| 1630 | ahHandles[cHandles] = pWorker->hProcess;
|
---|
| 1631 | }
|
---|
| 1632 | cHandles++;
|
---|
| 1633 | }
|
---|
| 1634 | for (pWorker = g_BusyList.pHead; pWorker != NULL; pWorker = pWorker->pNext)
|
---|
| 1635 | if (pWorker->hProcess != INVALID_HANDLE_VALUE)
|
---|
| 1636 | {
|
---|
| 1637 | if (cHandles < MAXIMUM_WAIT_OBJECTS)
|
---|
| 1638 | {
|
---|
| 1639 | apWorkers[cHandles] = pWorker;
|
---|
| 1640 | ahHandles[cHandles] = pWorker->hProcess;
|
---|
| 1641 | }
|
---|
| 1642 | cHandles++;
|
---|
| 1643 | }
|
---|
| 1644 | if (cHandles == 0)
|
---|
| 1645 | return;
|
---|
| 1646 |
|
---|
| 1647 | /*
|
---|
| 1648 | * Wait for the processes.
|
---|
| 1649 | */
|
---|
| 1650 | for (;;)
|
---|
| 1651 | {
|
---|
| 1652 | DWORD cMsElapsed = GetTickCount() - msStartTick;
|
---|
| 1653 | DWORD dwWait = WaitForMultipleObjects(cHandles <= MAXIMUM_WAIT_OBJECTS ? cHandles : MAXIMUM_WAIT_OBJECTS,
|
---|
| 1654 | ahHandles, FALSE /*bWaitAll*/,
|
---|
[2917] | 1655 | cMsElapsed < 5000 ? 5000 - cMsElapsed + 16 : 16);
|
---|
[2843] | 1656 | if ( dwWait >= WAIT_OBJECT_0
|
---|
| 1657 | && dwWait <= WAIT_OBJECT_0 + MAXIMUM_WAIT_OBJECTS)
|
---|
| 1658 | {
|
---|
| 1659 | size_t idx = dwWait - WAIT_OBJECT_0;
|
---|
| 1660 | CloseHandle(apWorkers[idx]->hProcess);
|
---|
| 1661 | apWorkers[idx]->hProcess = INVALID_HANDLE_VALUE;
|
---|
| 1662 |
|
---|
| 1663 | if (cHandles <= MAXIMUM_WAIT_OBJECTS)
|
---|
| 1664 | {
|
---|
| 1665 | /* Restart the wait with the worker removed, or quit if it was the last worker. */
|
---|
| 1666 | cHandles--;
|
---|
| 1667 | if (!cHandles)
|
---|
| 1668 | return;
|
---|
| 1669 | if (idx != cHandles)
|
---|
| 1670 | {
|
---|
| 1671 | apWorkers[idx] = apWorkers[cHandles];
|
---|
| 1672 | ahHandles[idx] = ahHandles[cHandles];
|
---|
| 1673 | }
|
---|
| 1674 | continue;
|
---|
| 1675 | }
|
---|
| 1676 | /* else: Reconstruct the wait array so we get maximum coverage. */
|
---|
| 1677 | }
|
---|
| 1678 | else if (dwWait == WAIT_TIMEOUT)
|
---|
| 1679 | {
|
---|
| 1680 | /* Terminate the whole bunch. */
|
---|
| 1681 | cKillRaids++;
|
---|
[2918] | 1682 | if (cKillRaids == 1 && getenv("KMK_KSUBMIT_NO_KILL") == NULL)
|
---|
[2843] | 1683 | {
|
---|
[3192] | 1684 | warnx(pCtx, "Killing %u lingering worker processe(s)!\n", cHandles);
|
---|
[2843] | 1685 | for (pWorker = g_IdleList.pHead; pWorker != NULL; pWorker = pWorker->pNext)
|
---|
| 1686 | if (pWorker->hProcess != INVALID_HANDLE_VALUE)
|
---|
| 1687 | TerminateProcess(pWorker->hProcess, WAIT_TIMEOUT);
|
---|
| 1688 | for (pWorker = g_BusyList.pHead; pWorker != NULL; pWorker = pWorker->pNext)
|
---|
| 1689 | if (pWorker->hProcess != INVALID_HANDLE_VALUE)
|
---|
| 1690 | TerminateProcess(pWorker->hProcess, WAIT_TIMEOUT);
|
---|
| 1691 | }
|
---|
| 1692 | else
|
---|
| 1693 | {
|
---|
[3192] | 1694 | warnx(pCtx, "Giving up on the last %u worker processe(s). :-(\n", cHandles);
|
---|
[2917] | 1695 | return;
|
---|
[2843] | 1696 | }
|
---|
| 1697 | }
|
---|
| 1698 | else
|
---|
| 1699 | {
|
---|
| 1700 | /* Some kind of wait error. Could be a bad handle, check each and remove
|
---|
| 1701 | bad ones as well as completed ones. */
|
---|
| 1702 | size_t idx;
|
---|
[3192] | 1703 | warnx(pCtx, "WaitForMultipleObjects unexpectedly returned %#u (err=%u)\n",
|
---|
| 1704 | dwWait, GetLastError());
|
---|
[2843] | 1705 | for (idx = 0; idx < cHandles; idx++)
|
---|
| 1706 | {
|
---|
| 1707 | dwWait = WaitForSingleObject(ahHandles[idx], 0 /*ms*/);
|
---|
| 1708 | if (dwWait != WAIT_TIMEOUT)
|
---|
| 1709 | {
|
---|
| 1710 | CloseHandle(apWorkers[idx]->hProcess);
|
---|
| 1711 | apWorkers[idx]->hProcess = INVALID_HANDLE_VALUE;
|
---|
| 1712 | }
|
---|
| 1713 | }
|
---|
| 1714 | }
|
---|
| 1715 | break;
|
---|
| 1716 | } /* wait loop */
|
---|
| 1717 | } /* outer wait loop */
|
---|
| 1718 | }
|
---|
| 1719 |
|
---|
| 1720 |
|
---|
[3192] | 1721 | static int kmk_builtin_kSubmit_usage(PKMKBUILTINCTX pCtx, int fIsErr)
|
---|
[1271] | 1722 | {
|
---|
[3192] | 1723 | kmk_builtin_ctx_printf(pCtx, fIsErr,
|
---|
| 1724 | "usage: %s [-Z|--zap-env] [-E|--set <var=val>] [-U|--unset <var=val>]\n"
|
---|
| 1725 | " [-A|--append <var=val>] [-D|--prepend <var=val>]\n"
|
---|
[3313] | 1726 | " [-s|--special-env <var=val>] [-C|--chdir <dir>]\n"
|
---|
| 1727 | " [--wcc-brain-damage] [--no-pch-caching]\n"
|
---|
| 1728 | " [-3|--32-bit] [-6|--64-bit] [-v] [--debug-dump-history]\n"
|
---|
[3192] | 1729 | " [-P|--post-cmd <cmd> [args]] -- <program> [args]\n"
|
---|
| 1730 | " or: %s --help\n"
|
---|
| 1731 | " or: %s --version\n"
|
---|
| 1732 | "\n"
|
---|
| 1733 | "Options:\n"
|
---|
| 1734 | " -Z, --zap-env, -i, --ignore-environment\n"
|
---|
| 1735 | " Zaps the environment. Position dependent.\n"
|
---|
| 1736 | " -E, --set <var>=[value]\n"
|
---|
[3313] | 1737 | " Sets an environment variable putenv fashion. Position dependent.\n"
|
---|
[3192] | 1738 | " -U, --unset <var>\n"
|
---|
| 1739 | " Removes an environment variable. Position dependent.\n"
|
---|
| 1740 | " -A, --append <var>=<value>\n"
|
---|
| 1741 | " Appends the given value to the environment variable.\n"
|
---|
| 1742 | " -D,--prepend <var>=<value>\n"
|
---|
| 1743 | " Prepends the given value to the environment variable.\n"
|
---|
[3313] | 1744 | " -s,--special-env <var>=<value>\n"
|
---|
| 1745 | " Same as --set, but flags the variable for further expansion\n"
|
---|
| 1746 | " within kWorker. Replacements:\n"
|
---|
| 1747 | " @@PROCESSOR_GROUP@@ - The processor group number.\n"
|
---|
| 1748 | " @@AUTHENTICATION_ID@@ - The authentication ID from the process token.\n"
|
---|
| 1749 | " @@PID@@ - The kWorker process ID.\n"
|
---|
| 1750 | " @@@@ - Escaped \"@@\".\n"
|
---|
| 1751 | " @@DEBUG_COUNTER@@ - An ever increasing counter (starts at zero).\n"
|
---|
[3192] | 1752 | " -C, --chdir <dir>\n"
|
---|
| 1753 | " Specifies the current directory for the program. Relative paths\n"
|
---|
| 1754 | " are relative to the previous -C option. Default is getcwd value.\n"
|
---|
| 1755 | " -3, --32-bit\n"
|
---|
| 1756 | " Selects a 32-bit kWorker process. Default: kmk bit count\n"
|
---|
| 1757 | " -6, --64-bit\n"
|
---|
| 1758 | " Selects a 64-bit kWorker process. Default: kmk bit count\n"
|
---|
| 1759 | " --wcc-brain-damage\n"
|
---|
| 1760 | " Works around wcc and wcc386 (Open Watcom) not following normal\n"
|
---|
| 1761 | " quoting conventions on Windows, OS/2, and DOS.\n"
|
---|
| 1762 | " --no-pch-caching\n"
|
---|
| 1763 | " Do not cache precompiled header files because they're being created.\n"
|
---|
| 1764 | " -v,--verbose\n"
|
---|
| 1765 | " More verbose execution.\n"
|
---|
[3313] | 1766 | " --debug-dump-history\n"
|
---|
[3413] | 1767 | " Dump the history as of the submitted command. Handy for debugging\n"
|
---|
[3313] | 1768 | " trouble caused by a previous job.\n"
|
---|
[3413] | 1769 | " --debug-dump-history-on-failure, --no-debug-dump-history-on-failure\n"
|
---|
| 1770 | " Dump the history on failure. Can also be enabled by a non-empty\n"
|
---|
| 1771 | " KMK_KSUBMIT_DUMP_HISTORY_ON_FAILURE variable (first invocation only).\n"
|
---|
[3192] | 1772 | " -P|--post-cmd <cmd> ...\n"
|
---|
| 1773 | " For running a built-in command on the output, specifying the command\n"
|
---|
| 1774 | " and all it's parameters. Currently supported commands:\n"
|
---|
| 1775 | " kDepObj\n"
|
---|
| 1776 | " -V,--version\n"
|
---|
| 1777 | " Show the version number.\n"
|
---|
| 1778 | " -h,--help\n"
|
---|
| 1779 | " Show this usage information.\n"
|
---|
| 1780 | "\n"
|
---|
| 1781 | ,
|
---|
| 1782 | pCtx->pszProgName, pCtx->pszProgName, pCtx->pszProgName);
|
---|
[2912] | 1783 | return 2;
|
---|
[1271] | 1784 | }
|
---|
| 1785 |
|
---|
| 1786 |
|
---|
[3192] | 1787 | int kmk_builtin_kSubmit(int argc, char **argv, char **envp, PKMKBUILTINCTX pCtx, struct child *pChild, pid_t *pPidSpawned)
|
---|
[1271] | 1788 | {
|
---|
[3313] | 1789 | #ifdef KBUILD_OS_WINDOWS
|
---|
| 1790 | static int s_fInitialized = 0;
|
---|
| 1791 | #endif
|
---|
[2840] | 1792 | int rcExit = 0;
|
---|
| 1793 | int iArg;
|
---|
| 1794 | unsigned cAllocatedEnvVars;
|
---|
| 1795 | unsigned cEnvVars;
|
---|
[3173] | 1796 | char **papszEnvVars;
|
---|
[2841] | 1797 | const char *pszExecutable = NULL;
|
---|
[3313] | 1798 | const char *pszSpecialEnv = NULL;
|
---|
[2894] | 1799 | int iPostCmd = argc;
|
---|
| 1800 | int cPostCmdArgs = 0;
|
---|
[2841] | 1801 | unsigned cBitsWorker = g_cArchBits;
|
---|
| 1802 | int fWatcomBrainDamage = 0;
|
---|
[2959] | 1803 | int fNoPchCaching = 0;
|
---|
[3313] | 1804 | int fDebugDumpHistory = 0;
|
---|
[3413] | 1805 | static int s_fDebugDumpHistoryOnFailure = -1;
|
---|
| 1806 | int fDebugDumpHistoryOnFailure = s_fDebugDumpHistoryOnFailure;
|
---|
[2841] | 1807 | int cVerbosity = 0;
|
---|
| 1808 | size_t const cbCwdBuf = GET_PATH_MAX;
|
---|
[2840] | 1809 | PATH_VAR(szCwd);
|
---|
[1271] | 1810 |
|
---|
[3313] | 1811 | #ifdef KBUILD_OS_WINDOWS
|
---|
[1271] | 1812 | /*
|
---|
[3313] | 1813 | * First time thru we must perform some initializations.
|
---|
| 1814 | */
|
---|
| 1815 | if (s_fInitialized)
|
---|
| 1816 | { }
|
---|
| 1817 | else
|
---|
| 1818 | {
|
---|
| 1819 | MkWinChildInitCpuGroupAllocator(&g_SubmitProcessorGroupAllocator);
|
---|
| 1820 | # if K_ARCH_BITS == 64
|
---|
| 1821 | MkWinChildInitCpuGroupAllocator(&g_SubmitProcessorGroupAllocator32);
|
---|
| 1822 | # endif
|
---|
| 1823 | *(FARPROC *)&g_pfnSetThreadGroupAffinity = GetProcAddress(GetModuleHandleW(L"KERNEL32.DLL"), "SetThreadGroupAffinity");
|
---|
| 1824 | s_fInitialized = 1;
|
---|
| 1825 | }
|
---|
| 1826 | #endif
|
---|
[3413] | 1827 | if (fDebugDumpHistoryOnFailure != -1)
|
---|
| 1828 | { /* likely */ }
|
---|
| 1829 | else
|
---|
| 1830 | {
|
---|
| 1831 | struct variable *pVar = lookup_variable(TUPLE("KMK_KSUBMIT_DUMP_HISTORY_ON_FAILURE"));
|
---|
| 1832 | fDebugDumpHistoryOnFailure = pVar && *pVar->value != '\0';
|
---|
| 1833 | s_fDebugDumpHistoryOnFailure = fDebugDumpHistoryOnFailure;
|
---|
| 1834 | }
|
---|
[3313] | 1835 |
|
---|
| 1836 | /*
|
---|
[2840] | 1837 | * Create default program environment.
|
---|
[3173] | 1838 | *
|
---|
| 1839 | * Note! We only clean up the environment on successful return, assuming
|
---|
| 1840 | * make will stop after that.
|
---|
[1271] | 1841 | */
|
---|
[2840] | 1842 | if (getcwd_fs(szCwd, cbCwdBuf) != NULL)
|
---|
| 1843 | { /* likely */ }
|
---|
| 1844 | else
|
---|
[3192] | 1845 | return err(pCtx, 1, "getcwd_fs failed\n");
|
---|
[2840] | 1846 |
|
---|
[3173] | 1847 | /* The environment starts out in read-only mode and will be duplicated if modified. */
|
---|
| 1848 | cAllocatedEnvVars = 0;
|
---|
| 1849 | papszEnvVars = envp;
|
---|
[2840] | 1850 | cEnvVars = 0;
|
---|
[3173] | 1851 | while (papszEnvVars[cEnvVars] != NULL)
|
---|
[2840] | 1852 | cEnvVars++;
|
---|
| 1853 |
|
---|
| 1854 | /*
|
---|
| 1855 | * Parse the command line.
|
---|
| 1856 | */
|
---|
| 1857 | for (iArg = 1; iArg < argc; iArg++)
|
---|
[1271] | 1858 | {
|
---|
[2840] | 1859 | const char *pszArg = argv[iArg];
|
---|
| 1860 | if (*pszArg == '-')
|
---|
[1271] | 1861 | {
|
---|
[2840] | 1862 | char chOpt = *++pszArg;
|
---|
[2875] | 1863 | pszArg++;
|
---|
[2840] | 1864 | if (chOpt != '-')
|
---|
[1271] | 1865 | {
|
---|
[2840] | 1866 | if (chOpt != '\0')
|
---|
| 1867 | { /* likely */ }
|
---|
| 1868 | else
|
---|
[1271] | 1869 | {
|
---|
[3192] | 1870 | errx(pCtx, 1, "Incomplete option: '-'");
|
---|
| 1871 | return kmk_builtin_kSubmit_usage(pCtx, 1);
|
---|
[1271] | 1872 | }
|
---|
| 1873 | }
|
---|
[2840] | 1874 | else
|
---|
[1271] | 1875 | {
|
---|
[2840] | 1876 | /* '--' indicates where the bits to execute start. */
|
---|
| 1877 | if (*pszArg == '\0')
|
---|
[1308] | 1878 | {
|
---|
[2840] | 1879 | iArg++;
|
---|
| 1880 | break;
|
---|
[1308] | 1881 | }
|
---|
[2699] | 1882 |
|
---|
[2875] | 1883 | if ( strcmp(pszArg, "wcc-brain-damage") == 0
|
---|
| 1884 | || strcmp(pszArg, "watcom-brain-damage") == 0)
|
---|
[1308] | 1885 | {
|
---|
[2840] | 1886 | fWatcomBrainDamage = 1;
|
---|
[1308] | 1887 | continue;
|
---|
| 1888 | }
|
---|
| 1889 |
|
---|
[2959] | 1890 | if (strcmp(pszArg, "no-pch-caching") == 0)
|
---|
| 1891 | {
|
---|
| 1892 | fNoPchCaching = 1;
|
---|
| 1893 | continue;
|
---|
| 1894 | }
|
---|
| 1895 |
|
---|
[3313] | 1896 | if (strcmp(pszArg, "debug-dump-history") == 0)
|
---|
| 1897 | {
|
---|
| 1898 | fDebugDumpHistory = 1;
|
---|
| 1899 | continue;
|
---|
| 1900 | }
|
---|
| 1901 |
|
---|
[3413] | 1902 | if (strcmp(pszArg, "debug-dump-history-on-failure") == 0)
|
---|
| 1903 | {
|
---|
| 1904 | fDebugDumpHistoryOnFailure = 1;
|
---|
| 1905 | continue;
|
---|
| 1906 | }
|
---|
[3313] | 1907 |
|
---|
[3413] | 1908 | if (strcmp(pszArg, "no-debug-dump-history-on-failure") == 0)
|
---|
| 1909 | {
|
---|
| 1910 | fDebugDumpHistoryOnFailure = 0;
|
---|
| 1911 | continue;
|
---|
| 1912 | }
|
---|
| 1913 |
|
---|
[2840] | 1914 | /* convert to short. */
|
---|
| 1915 | if (strcmp(pszArg, "help") == 0)
|
---|
| 1916 | chOpt = 'h';
|
---|
| 1917 | else if (strcmp(pszArg, "version") == 0)
|
---|
| 1918 | chOpt = 'V';
|
---|
| 1919 | else if (strcmp(pszArg, "set") == 0)
|
---|
| 1920 | chOpt = 'E';
|
---|
[3039] | 1921 | else if (strcmp(pszArg, "append") == 0)
|
---|
| 1922 | chOpt = 'A';
|
---|
| 1923 | else if (strcmp(pszArg, "prepend") == 0)
|
---|
| 1924 | chOpt = 'D';
|
---|
[2840] | 1925 | else if (strcmp(pszArg, "unset") == 0)
|
---|
| 1926 | chOpt = 'U';
|
---|
| 1927 | else if ( strcmp(pszArg, "zap-env") == 0
|
---|
| 1928 | || strcmp(pszArg, "ignore-environment") == 0 /* GNU env compatibility. */ )
|
---|
| 1929 | chOpt = 'Z';
|
---|
| 1930 | else if (strcmp(pszArg, "chdir") == 0)
|
---|
| 1931 | chOpt = 'C';
|
---|
[3313] | 1932 | else if (strcmp(pszArg, "set-special") == 0)
|
---|
| 1933 | chOpt = 's';
|
---|
[2894] | 1934 | else if (strcmp(pszArg, "post-cmd") == 0)
|
---|
| 1935 | chOpt = 'P';
|
---|
[2840] | 1936 | else if (strcmp(pszArg, "32-bit") == 0)
|
---|
| 1937 | chOpt = '3';
|
---|
| 1938 | else if (strcmp(pszArg, "64-bit") == 0)
|
---|
| 1939 | chOpt = '6';
|
---|
| 1940 | else if (strcmp(pszArg, "verbose") == 0)
|
---|
| 1941 | chOpt = 'v';
|
---|
[2841] | 1942 | else if (strcmp(pszArg, "executable") == 0)
|
---|
| 1943 | chOpt = 'e';
|
---|
[2840] | 1944 | else
|
---|
[2074] | 1945 | {
|
---|
[3192] | 1946 | errx(pCtx, 2, "Unknown option: '%s'", pszArg - 2);
|
---|
| 1947 | return kmk_builtin_kSubmit_usage(pCtx, 1);
|
---|
[2074] | 1948 | }
|
---|
[2840] | 1949 | pszArg = "";
|
---|
[2074] | 1950 | }
|
---|
| 1951 |
|
---|
[2840] | 1952 | do
|
---|
[2812] | 1953 | {
|
---|
[2840] | 1954 | /* Get option value first, if the option takes one. */
|
---|
| 1955 | const char *pszValue = NULL;
|
---|
| 1956 | switch (chOpt)
|
---|
[2074] | 1957 | {
|
---|
[3039] | 1958 | case 'A':
|
---|
| 1959 | case 'C':
|
---|
[2840] | 1960 | case 'E':
|
---|
| 1961 | case 'U':
|
---|
[3039] | 1962 | case 'D':
|
---|
[2841] | 1963 | case 'e':
|
---|
[3313] | 1964 | case 's':
|
---|
[2840] | 1965 | if (*pszArg != '\0')
|
---|
| 1966 | pszValue = pszArg + (*pszArg == ':' || *pszArg == '=');
|
---|
| 1967 | else if (++iArg < argc)
|
---|
| 1968 | pszValue = argv[iArg];
|
---|
| 1969 | else
|
---|
| 1970 | {
|
---|
[3192] | 1971 | errx(pCtx, 1, "Option -%c requires a value!", chOpt);
|
---|
| 1972 | return kmk_builtin_kSubmit_usage(pCtx, 1);
|
---|
[2840] | 1973 | }
|
---|
| 1974 | break;
|
---|
[2074] | 1975 | }
|
---|
| 1976 |
|
---|
[2840] | 1977 | switch (chOpt)
|
---|
[2074] | 1978 | {
|
---|
[2840] | 1979 | case 'Z':
|
---|
| 1980 | case 'i': /* GNU env compatibility. */
|
---|
[3192] | 1981 | rcExit = kBuiltinOptEnvZap(pCtx, &papszEnvVars, &cEnvVars, &cAllocatedEnvVars, cVerbosity);
|
---|
[3173] | 1982 | if (rcExit == 0)
|
---|
| 1983 | break;
|
---|
| 1984 | return rcExit;
|
---|
[2074] | 1985 |
|
---|
[2840] | 1986 | case 'E':
|
---|
[3192] | 1987 | rcExit = kBuiltinOptEnvSet(pCtx, &papszEnvVars, &cEnvVars, &cAllocatedEnvVars, cVerbosity, pszValue);
|
---|
[2841] | 1988 | if (rcExit == 0)
|
---|
| 1989 | break;
|
---|
| 1990 | return rcExit;
|
---|
[1271] | 1991 |
|
---|
[3039] | 1992 | case 'A':
|
---|
[3192] | 1993 | rcExit = kBuiltinOptEnvAppend(pCtx, &papszEnvVars, &cEnvVars, &cAllocatedEnvVars, cVerbosity, pszValue);
|
---|
[3039] | 1994 | if (rcExit == 0)
|
---|
| 1995 | break;
|
---|
| 1996 | return rcExit;
|
---|
| 1997 |
|
---|
| 1998 | case 'D':
|
---|
[3192] | 1999 | rcExit = kBuiltinOptEnvPrepend(pCtx, &papszEnvVars, &cEnvVars, &cAllocatedEnvVars, cVerbosity, pszValue);
|
---|
[3039] | 2000 | if (rcExit == 0)
|
---|
| 2001 | break;
|
---|
| 2002 | return rcExit;
|
---|
| 2003 |
|
---|
[2840] | 2004 | case 'U':
|
---|
[3192] | 2005 | rcExit = kBuiltinOptEnvUnset(pCtx, &papszEnvVars, &cEnvVars, &cAllocatedEnvVars, cVerbosity, pszValue);
|
---|
[2841] | 2006 | if (rcExit == 0)
|
---|
| 2007 | break;
|
---|
| 2008 | return rcExit;
|
---|
[1271] | 2009 |
|
---|
[2840] | 2010 | case 'C':
|
---|
[3192] | 2011 | rcExit = kBuiltinOptChDir(pCtx, szCwd, cbCwdBuf, pszValue);
|
---|
[2841] | 2012 | if (rcExit == 0)
|
---|
| 2013 | break;
|
---|
| 2014 | return rcExit;
|
---|
[1271] | 2015 |
|
---|
[3313] | 2016 | case 's':
|
---|
| 2017 | if (pszSpecialEnv)
|
---|
| 2018 | return errx(pCtx, 1, "The -s option can only be used once!");
|
---|
| 2019 | pszSpecialEnv = pszValue;
|
---|
| 2020 | rcExit = kBuiltinOptEnvSet(pCtx, &papszEnvVars, &cEnvVars, &cAllocatedEnvVars, cVerbosity, pszValue);
|
---|
| 2021 | if (rcExit == 0)
|
---|
| 2022 | break;
|
---|
| 2023 | return rcExit;
|
---|
| 2024 |
|
---|
[2894] | 2025 | case 'P':
|
---|
| 2026 | if (cPostCmdArgs > 0)
|
---|
[3192] | 2027 | return errx(pCtx, 1, "The -P option can only be used once!");
|
---|
[2894] | 2028 | if (*pszArg != '\0')
|
---|
[3192] | 2029 | return errx(pCtx, 1, "The cmd part of the -P needs to be a separate argument!");
|
---|
[2894] | 2030 | iPostCmd = ++iArg;
|
---|
| 2031 | if (iArg >= argc)
|
---|
[3192] | 2032 | return errx(pCtx, 1, "The -P option requires a command following it!");
|
---|
[2894] | 2033 | while (iArg < argc && strcmp(argv[iArg], "--") != 0)
|
---|
| 2034 | iArg++;
|
---|
| 2035 | cPostCmdArgs = iArg - iPostCmd;
|
---|
| 2036 | iArg--;
|
---|
| 2037 | break;
|
---|
| 2038 |
|
---|
[3642] | 2039 | #if !defined(KBUILD_ARCH_ARM64)
|
---|
[2840] | 2040 | case '3':
|
---|
| 2041 | cBitsWorker = 32;
|
---|
| 2042 | break;
|
---|
[3642] | 2043 | #endif
|
---|
[2840] | 2044 | case '6':
|
---|
| 2045 | cBitsWorker = 64;
|
---|
| 2046 | break;
|
---|
[1271] | 2047 |
|
---|
[2841] | 2048 | case 'e':
|
---|
| 2049 | pszExecutable = pszValue;
|
---|
| 2050 | break;
|
---|
| 2051 |
|
---|
[2840] | 2052 | case 'v':
|
---|
| 2053 | cVerbosity++;
|
---|
| 2054 | break;
|
---|
[1271] | 2055 |
|
---|
[2840] | 2056 | case 'h':
|
---|
[3192] | 2057 | kmk_builtin_kSubmit_usage(pCtx, 0);
|
---|
[3173] | 2058 | kBuiltinOptEnvCleanup(&papszEnvVars, cEnvVars, &cAllocatedEnvVars);
|
---|
[2840] | 2059 | return 0;
|
---|
[1271] | 2060 |
|
---|
[2840] | 2061 | case 'V':
|
---|
[3173] | 2062 | kBuiltinOptEnvCleanup(&papszEnvVars, cEnvVars, &cAllocatedEnvVars);
|
---|
[2843] | 2063 | return kbuild_version(argv[0]);
|
---|
[1271] | 2064 | }
|
---|
[2840] | 2065 | } while ((chOpt = *pszArg++) != '\0');
|
---|
[1271] | 2066 | }
|
---|
| 2067 | else
|
---|
| 2068 | {
|
---|
[3192] | 2069 | errx(pCtx, 1, "Unknown argument: '%s'", pszArg);
|
---|
| 2070 | return kmk_builtin_kSubmit_usage(pCtx, 1);
|
---|
[1271] | 2071 | }
|
---|
| 2072 | }
|
---|
| 2073 |
|
---|
| 2074 | /*
|
---|
[2840] | 2075 | * Check that we've got something to execute.
|
---|
[1271] | 2076 | */
|
---|
[2840] | 2077 | if (iArg < argc)
|
---|
[1271] | 2078 | {
|
---|
[2841] | 2079 | uint32_t cbMsg;
|
---|
[3173] | 2080 | void *pvMsg = kSubmitComposeJobMessage(pszExecutable, &argv[iArg], papszEnvVars, szCwd,
|
---|
[3313] | 2081 | fWatcomBrainDamage, fNoPchCaching, pszSpecialEnv,
|
---|
[2959] | 2082 | &argv[iPostCmd], cPostCmdArgs, &cbMsg);
|
---|
[3192] | 2083 | PWORKERINSTANCE pWorker = kSubmitSelectWorkSpawnNewIfNecessary(pCtx, cBitsWorker, cVerbosity);
|
---|
[2841] | 2084 | if (pWorker)
|
---|
| 2085 | {
|
---|
[3194] | 2086 | /* Before we send off the job, we should dump pending output, since
|
---|
| 2087 | the kWorker process currently does not coordinate its output with
|
---|
| 2088 | the output.c mechanics. */
|
---|
[3200] | 2089 | #ifdef CONFIG_NEW_WIN_CHILDREN
|
---|
| 2090 | if (pCtx->pOut && !pWorker->pStdOut)
|
---|
| 2091 | #else
|
---|
[3194] | 2092 | if (pCtx->pOut)
|
---|
[3200] | 2093 | #endif
|
---|
[3194] | 2094 | output_dump(pCtx->pOut);
|
---|
[3413] | 2095 | pWorker->fDebugDumpHistoryOnFailure = fDebugDumpHistoryOnFailure;
|
---|
[3192] | 2096 | rcExit = kSubmitSendJobMessage(pCtx, pWorker, pvMsg, cbMsg, 0 /*fNoRespawning*/, cVerbosity);
|
---|
[2841] | 2097 | if (rcExit == 0)
|
---|
[3313] | 2098 | {
|
---|
| 2099 | pvMsg = kSubmitUpdateHistory(pWorker, pvMsg, cbMsg);
|
---|
| 2100 | if (fDebugDumpHistory)
|
---|
| 2101 | kSubmitDumpHistory(pCtx, pWorker);
|
---|
[3192] | 2102 | rcExit = kSubmitMarkActive(pCtx, pWorker, cVerbosity, pChild, pPidSpawned);
|
---|
[3313] | 2103 | }
|
---|
[2843] | 2104 |
|
---|
| 2105 | if (!g_fAtExitRegistered)
|
---|
| 2106 | if (atexit(kSubmitAtExitCallback) == 0)
|
---|
| 2107 | g_fAtExitRegistered = 1;
|
---|
[2841] | 2108 | }
|
---|
| 2109 | else
|
---|
| 2110 | rcExit = 1;
|
---|
| 2111 | free(pvMsg);
|
---|
[1271] | 2112 | }
|
---|
[2840] | 2113 | else
|
---|
[1674] | 2114 | {
|
---|
[3192] | 2115 | errx(pCtx, 1, "Nothing to executed!");
|
---|
| 2116 | rcExit = kmk_builtin_kSubmit_usage(pCtx, 1);
|
---|
[1674] | 2117 | }
|
---|
| 2118 |
|
---|
[3173] | 2119 | kBuiltinOptEnvCleanup(&papszEnvVars, cEnvVars, &cAllocatedEnvVars);
|
---|
[2840] | 2120 | return rcExit;
|
---|
[1271] | 2121 | }
|
---|
| 2122 |
|
---|