Merge pull request #6 from dscho/ctrl-c

When interrupting Win32 processes, kill their child processes, too

Author: dscho

winsup/cygwin/exceptions.cc

@@ -27,6 +27,7 @@ details. */
 #include "child_info.h"
 #include "ntdll.h"
 #include "exception.h"
+#include "cygwin/exit_process.h"
 
 /* Definitions for code simplification */
 #ifdef __x86_64__
@@ -1546,8 +1547,23 @@ sigpacket::process ()
 dosig:
   if (have_execed)
     {
-      sigproc_printf ("terminating captive process");
-      TerminateProcess (ch_spawn, sigExeced = si.si_signo);
+      switch (si.si_signo)
+        {
+        case SIGUSR1:
+        case SIGUSR2:
+        case SIGCONT:
+        case SIGSTOP:
+        case SIGTSTP:
+        case SIGTTIN:
+        case SIGTTOU:
+          system_printf ("Suppressing signal %d to win32 process (pid %u)",
+              (int)si.si_signo, (unsigned int)GetProcessId(ch_spawn));
+          goto done;
+        default:
+          sigproc_printf ("terminating captive process");
+          exit_process (ch_spawn, 128 + (sigExeced = si.si_signo), 0);
+          break;
+        }
     }
   /* Dispatch to the appropriate function. */
   sigproc_printf ("signal %d, signal handler %p", si.si_signo, handler);

winsup/cygwin/include/cygwin/exit_process.h

@@ -0,0 +1,169 @@
+#ifndef EXIT_PROCESS_H
+#define EXIT_PROCESS_H
+
+/*
+ * This file contains functions to terminate a Win32 process, as gently as
+ * possible.
+ *
+ * If appropriate, we will attempt to generate a console Ctrl event.
+ * Otherwise we will fall back to terminating the entire process tree.
+ *
+ * As we do not want to export this function in the MSYS2 runtime, these
+ * functions are marked as file-local.
+ */
+
+#include <tlhelp32.h>
+
+/**
+ * Terminates the process corresponding to the process ID
+ *
+ * This way of terminating the processes is not gentle: the process gets
+ * no chance of cleaning up after itself (closing file handles, removing
+ * .lock files, terminating spawned processes (if any), etc).
+ */
+static int
+terminate_process(HANDLE process, int exit_code)
+{
+  return int(TerminateProcess (process, exit_code));
+}
+
+/**
+ * Terminates the process corresponding to the process ID and all of its
+ * directly and indirectly spawned subprocesses using the provided
+ * terminate callback function
+ */
+static int
+terminate_process_tree(HANDLE main_process, int exit_code, int (*terminate)(HANDLE, int))
+{
+  HANDLE snapshot = CreateToolhelp32Snapshot (TH32CS_SNAPPROCESS, 0);
+  PROCESSENTRY32 entry;
+  DWORD pids[16384];
+  int max_len = sizeof (pids) / sizeof (*pids), i, len, ret = 0;
+  pid_t pid = GetProcessId (main_process);
+
+  pids[0] = (DWORD) pid;
+  len = 1;
+
+  /*
+   * Even if Process32First()/Process32Next() seem to traverse the
+   * processes in topological order (i.e. parent processes before
+   * child processes), there is nothing in the Win32 API documentation
+   * suggesting that this is guaranteed.
+   *
+   * Therefore, run through them at least twice and stop when no more
+   * process IDs were added to the list.
+   */
+  for (;;)
+    {
+      int orig_len = len;
+      pid_t cyg_pid;
+
+      memset (&entry, 0, sizeof (entry));
+      entry.dwSize = sizeof (entry);
+
+      if (!Process32First (snapshot, &entry))
+        break;
+
+      do
+        {
+          for (i = len - 1; i >= 0; i--)
+            {
+              cyg_pid = cygwin_winpid_to_pid(entry.th32ProcessID);
+              if (cyg_pid > -1)
+                {
+                  kill(cyg_pid, exit_code);
+                  continue;
+                }
+              if (pids[i] == entry.th32ProcessID)
+                break;
+              if (pids[i] == entry.th32ParentProcessID)
+                pids[len++] = entry.th32ProcessID;
+            }
+        }
+      while (len < max_len && Process32Next (snapshot, &entry));
+
+      if (orig_len == len || len >= max_len)
+        break;
+    }
+
+  for (i = len - 1; i >= 0; i--)
+    {
+      HANDLE process = i == 0 ? main_process :
+        OpenProcess (PROCESS_TERMINATE, FALSE, pids[i]);
+
+      if (process)
+        {
+          if (!(*terminate) (process, exit_code))
+            ret = -1;
+          CloseHandle (process);
+        }
+    }
+
+  return ret;
+}
+
+/**
+ * For SIGINT/SIGTERM, call GenerateConsoleCtrlEven(). Otherwise fall back to
+ * running terminate_process_tree().
+ */
+static int
+exit_process(HANDLE process, int exit_code, int okay_to_kill_this_process)
+{
+  DWORD code;
+
+  if (GetExitCodeProcess (process, &code) && code == STILL_ACTIVE)
+    {
+      int signal = exit_code & 0x7f;
+      if (signal == SIGINT || signal == SIGTERM)
+        {
+#ifndef __INSIDE_CYGWIN__
+          if (!okay_to_kill_this_process)
+            return -1;
+          FreeConsole();
+          if (!AttachConsole(GetProcessId(process)))
+            return -1;
+          if (GenerateConsoleCtrlEvent(signal == SIGINT ? CTRL_C_EVENT : CTRL_BREAK_EVENT, 0))
+            return 0;
+#else
+          path_conv helper ("/bin/kill.exe");
+          if (helper.exists ())
+            {
+              STARTUPINFOW si = {};
+              PROCESS_INFORMATION pi;
+              size_t len = helper.get_wide_win32_path_len ();
+              WCHAR cmd[len + (2 * strlen (" -f -32 0xffffffff")) + 1];
+              WCHAR title[] = L"kill";
+
+              helper.get_wide_win32_path (cmd);
+              __small_swprintf (cmd + len, L" -f -%d %d", signal, (int)GetProcessId(ch_spawn));
+
+              si.cb = sizeof (si);
+              si.dwFlags = STARTF_USESHOWWINDOW;
+              si.wShowWindow = SW_HIDE;
+              si.lpTitle = title;
+
+              /* Create a new hidden process.  Use the two event handles as
+                 argv[1] and argv[2]. */
+              BOOL x = CreateProcessW (NULL, cmd, &sec_none_nih, &sec_none_nih,
+                  true, CREATE_NO_WINDOW, NULL, NULL, &si, &pi);
+              if (x)
+                {
+                  CloseHandle (pi.hThread);
+                  if (WaitForSingleObject (pi.hProcess, 10000) == WAIT_OBJECT_0)
+                    {
+                      CloseHandle (pi.hProcess);
+                      return 0;
+                    }
+                  CloseHandle (pi.hProcess);
+                }
+            }
+#endif
+        }
+
+      return terminate_process_tree (process, exit_code, terminate_process);
+    }
+
+  return -1;
+}
+
+#endif

winsup/cygwin/include/cygwin/signal.h

@@ -441,6 +441,7 @@ extern const char *sys_siglist[];
 extern const char __declspec(dllimport) *sys_sigabbrev[];
 extern const char __declspec(dllimport) *sys_siglist[];
 #endif
+void kill_process_tree(pid_t pid, int sig);
 
 #ifdef __cplusplus
 }

winsup/utils/kill.cc

@@ -17,6 +17,7 @@ details. */
 #include <cygwin/version.h>
 #include <getopt.h>
 #include <limits.h>
+#include <cygwin/exit_process.h>
 
 static char *prog_name;
 
@@ -171,10 +172,20 @@ forcekill (int pid, int sig, int wait)
       return;
     }
   if (!wait || WaitForSingleObject (h, 200) != WAIT_OBJECT_0)
-    if (sig && !TerminateProcess (h, sig << 8)
-	&& WaitForSingleObject (h, 200) != WAIT_OBJECT_0)
-      fprintf (stderr, "%s: couldn't kill pid %u, %u\n",
-	       prog_name, (unsigned) dwpid, (unsigned int) GetLastError ());
+    {
+      HANDLE cur = GetCurrentProcess (), h2;
+      /* duplicate handle with access rights required for exit_process() */
+      if (DuplicateHandle (cur, h, cur, &h2, PROCESS_CREATE_THREAD |
+			      PROCESS_QUERY_INFORMATION |
+			      PROCESS_VM_OPERATION |
+			      PROCESS_VM_WRITE | PROCESS_VM_READ |
+			      PROCESS_TERMINATE, FALSE, 0))
+      {
+        CloseHandle(h);
+        h = h2;
+      }
+      exit_process (h2, 128 + sig, 1);
+    }
   CloseHandle (h);
 }