Changeset 3353 for trunk/src

Timestamp:

Jun 5, 2020, 2:57:13 AM (5 years ago)

Author:

bird

Message:

kmk/winchildren: Use windows job objects to terminate all orphaned children when the topmost kmk process terminates. There are a couple of command line options to disable/tweak this behaviour.

Location:

trunk/src/kmk

Files:

• main.c (modified) (6 diffs)
• w32/winchildren.c (modified) (2 diffs)

trunk/src/kmk/main.c

@@ -416 +416 @@
 
 int make_expensive_statistics = 0;
+#endif
+
+#if defined (WINDOWS32) && defined (CONFIG_NEW_WIN_CHILDREN)
+/* --job-object[=mode]. */
+char *win_job_object_mode = NULL;
+
+/* --job-object-name=name */
+char *win_job_object_name = NULL;
 #endif
 
@@ -552 +560 @@
   --statistics                Gather extra statistics for $(make-stats ).\n"),
 #endif
+#if defined (WINDOWS32) && defined (CONFIG_NEW_WIN_CHILDREN)
+    N_("\
+  --job-object=mode           Windows job object mode:\n\
+                                root-kill   = Root make instance only, kill all\n\
+                                              process when root exits. (def)\n\
+                                root-nokill = Root make instance only.\n\
+                                              No killing.\n\
+                                each-kill   = Each make instances, kill all\n\
+                                              children when an instance exits.\n\
+                                each-nokill = Each make instances, no killing.\n\
+                                none        = No job objects.\n"),
+    N_("\
+  --job-object-name=name      Name of windows job object to open or create.\n\
+                              The default name is 'kmk-job-obj-<date>Z<pid>'.\n"),
+#endif
     NULL
   };
@@ -577 +600 @@
     { 'p', flag, &print_data_base_flag, 1, 1, 0, 0, 0, "print-data-base" },
 #ifdef CONFIG_PRETTY_COMMAND_PRINTING
-    { CHAR_MAX+10, flag, (char *) &pretty_command_printing, 1, 1, 1, 0, 0,
+    { CHAR_MAX+50, flag, (char *) &pretty_command_printing, 1, 1, 1, 0, 0,
        "pretty-command-printing" },
 #endif
 #ifdef CONFIG_WITH_PRINT_STATS_SWITCH
-    { CHAR_MAX+11, flag, (char *) &print_stats_flag, 1, 1, 1, 0, 0,
+    { CHAR_MAX+51, flag, (char *) &print_stats_flag, 1, 1, 1, 0, 0,
        "print-stats" },
 #endif
 #ifdef CONFIG_WITH_PRINT_TIME_SWITCH
-    { CHAR_MAX+12, positive_int, (char *) &print_time_min, 1, 1, 0,
+    { CHAR_MAX+52, positive_int, (char *) &print_time_min, 1, 1, 0,
       (char *) &no_val_print_time_min, (char *) &default_print_time_min,
       "print-time" },
 #endif
 #ifdef KMK
-    { CHAR_MAX+14, positive_int, (char *) &process_priority, 1, 1, 0,
+    { CHAR_MAX+54, positive_int, (char *) &process_priority, 1, 1, 0,
       (char *) &process_priority, (char *) &process_priority, "priority" },
-    { CHAR_MAX+15, positive_int, (char *) &process_affinity, 1, 1, 0,
+    { CHAR_MAX+55, positive_int, (char *) &process_affinity, 1, 1, 0,
       (char *) &process_affinity, (char *) &process_affinity, "affinity" },
-    { CHAR_MAX+17, flag, (char *) &process_priority, 1, 1, 0, 0, 0, "nice" },
+    { CHAR_MAX+56, flag, (char *) &process_priority, 1, 1, 0, 0, 0, "nice" },
 #endif
     { 'q', flag, &question_flag, 1, 1, 1, 0, 0, "question" },
@@ -604 +627 @@
       "no-keep-going" },
 #if defined (CONFIG_WITH_MAKE_STATS) || defined (CONFIG_WITH_MINIMAL_STATS)
-    { CHAR_MAX+16, flag, (char *) &make_expensive_statistics, 1, 1, 1, 0, 0,
+    { CHAR_MAX+57, flag, (char *) &make_expensive_statistics, 1, 1, 1, 0, 0,
        "statistics" },
 #endif
@@ -639 +662 @@
     { CHAR_MAX+6, strlist, &eval_strings, 1, 0, 0, 0, 0, "eval" },
     { CHAR_MAX+7, string, &sync_mutex, 1, 1, 0, 0, 0, "sync-mutex" },
+#if defined (WINDOWS32) && defined (CONFIG_NEW_WIN_CHILDREN)
+    { CHAR_MAX+58, string, &win_job_object_mode, 1, 1, 1, 0, 0, "job-object" },
+    { CHAR_MAX+59, string, &win_job_object_name,  1, 1, 1, 0, 0,
+      "job-object-name" },
+#endif
     { 0, 0, 0, 0, 0, 0, 0, 0, 0 }
   };
@@ -3728 +3756 @@
   decode_debug_flags ();
   decode_output_sync_flags ();
+
+#if defined (WINDOWS32) && defined (CONFIG_NEW_WIN_CHILDREN)
+  /* validate the job object mode value . */
+  if (win_job_object_mode == NULL)
+    win_job_object_mode = xstrdup("root-kill");
+  else if (   strcmp (win_job_object_mode, "none") != 0
+           && strcmp (win_job_object_mode, "root-kill") != 0
+           && strcmp (win_job_object_mode, "root-nokill") != 0
+           && strcmp (win_job_object_mode, "each-kill") != 0
+           && strcmp (win_job_object_mode, "each-nokill") != 0)
+    OS (fatal, NILF, _("unknown job object mode '%s'"), win_job_object_mode);
+#endif
 }
 

trunk/src/kmk/w32/winchildren.c

@@ -107 +107 @@
 extern void kmk_cache_exec_image_w(const wchar_t *); /* imagecache.c */
 #endif
+
+/* Option values from main.c: */
+extern const char *win_job_object_mode;
+extern const char *win_job_object_name;
 
 
@@ -481 +485 @@
     InitializeSRWLock(&g_RWLock);
 #endif
+
+    /*
+     * Depending on the --job-object=mode value, we typically create a job
+     * object here if we're the root make instance.  The job object is then
+     * typically configured to kill all remaining processes when the root make
+     * terminates, so that there aren't any stuck processes around messing up
+     * subsequent builds.  This is very handy on build servers, provided of
+     * course that, there aren't parallel kmk instance that wants to share
+     * mspdbsrv.exe or something like that.
+     *
+     * If we're not in a -kill mode, the job object is pretty pointless for
+     * manual cleanup as the job object becomes invisible (or something) when
+     * the last handle to it closes, i.e. hJob below.  On windows 8 and later
+     * it looks like any orphaned children are immediately assigned to the
+     * parent job object. Too bad for kmk_kill and such.
+     *
+     * win_job_object_mode values: none, root-kill, root-nokill, all-kill, all-nokill
+     */
+    if (   strcmp(win_job_object_mode, "none") != 0
+        && (   makelevel == 0
+            || strstr(win_job_object_mode, "root") == NULL))
+    {
+        HANDLE      hJob = NULL;
+        BOOL        fCreate = TRUE;
+        const char *pszJobName = win_job_object_name;
+        if (pszJobName)
+        {
+            /* Try open it first, in case it already exists. If it doesn't we'll try create it. */
+            fCreate = FALSE;
+            hJob = OpenJobObjectA(JOB_OBJECT_ASSIGN_PROCESS, FALSE /*bInheritHandle*/, pszJobName);
+            if (hJob)
+            {
+                DWORD dwErr = GetLastError();
+                if (dwErr == ERROR_PATH_NOT_FOUND || dwErr == ERROR_FILE_NOT_FOUND)
+                    fCreate = TRUE;
+                else
+                    OSN(message, 0, _("OpenJobObjectA(,,%s) failed: %u"), pszJobName, GetLastError());
+            }
+        }
+
+        if (fCreate)
+        {
+            char       szJobName[128];
+            SYSTEMTIME Now = {0};
+            GetSystemTime(&Now);
+            snprintf(szJobName, sizeof(szJobName) / 2, "kmk-job-obj-%04u-%02u-%02uT%02u-%02u-%02uZ%u",
+                     Now.wYear, Now.wMonth, Now.wDay, Now.wHour, Now.wMinute, Now.wSecond, getpid());
+            if (!pszJobName)
+                pszJobName = szJobName;
+
+            hJob = CreateJobObjectA(NULL, pszJobName);
+            if (hJob)
+            {
+                /* We need to set the BREAKAWAY_OK flag, as we don't want make CreateProcess fail if
+                   someone tries to break way.  Also set KILL_ON_JOB_CLOSE unless 'nokill' is given. */
+                JOBOBJECT_EXTENDED_LIMIT_INFORMATION Info;
+                DWORD cbActual = 0;
+                memset(&Info, 0, sizeof(Info));
+                if (QueryInformationJobObject(hJob, JobObjectExtendedLimitInformation, &Info, sizeof(Info), &cbActual))
+                {
+                    Info.BasicLimitInformation.LimitFlags |= JOB_OBJECT_LIMIT_BREAKAWAY_OK;
+                    if (strstr(win_job_object_mode, "nokill") == NULL)
+                        Info.BasicLimitInformation.LimitFlags |= JOB_OBJECT_LIMIT_KILL_ON_JOB_CLOSE;
+                    else
+                        Info.BasicLimitInformation.LimitFlags &= ~JOB_OBJECT_LIMIT_KILL_ON_JOB_CLOSE;
+                    if (!SetInformationJobObject(hJob, JobObjectExtendedLimitInformation, &Info, sizeof(Info)))
+                        OSN(message, 0, _("SetInformationJobObject(%s,JobObjectExtendedLimitInformation,{%s},) failed: %u"),
+                            pszJobName, win_job_object_mode, GetLastError());
+                }
+                else
+                    OSN(message, 0, _("QueryInformationJobObject(%s,JobObjectExtendedLimitInformation,,,) failed: %u"),
+                        pszJobName, GetLastError());
+            }
+            else
+                OSN(message, 0, _("CreateJobObjectA(NULL,%s) failed: %u"), pszJobName, GetLastError());
+        }
+
+        if (hJob)
+        {
+            if (!(AssignProcessToJobObject(hJob, GetCurrentProcess())))
+                OSN(message, 0, _("AssignProcessToJobObject(%s, me) failed: %u"), pszJobName, GetLastError());
+        }
+    }
 
     /*