Merge #8107 'jobs: separate process-group'

8 files changed, 435 insertions, 20 deletions

diff --git a/src/nvim/api/vim.c b/src/nvim/api/vim.c
index dad67c5e4b..962081cc23 100644
--- a/src/nvim/api/vim.c
+++ b/src/nvim/api/vim.c
@@ -33,6 +33,7 @@
 #include "nvim/syntax.h"
 #include "nvim/getchar.h"
 #include "nvim/os/input.h"
+#include "nvim/os/process.h"
 #include "nvim/viml/parser/expressions.h"
 #include "nvim/viml/parser/parser.h"
 #include "nvim/ui.h"
@@ -1478,3 +1479,86 @@ Array nvim_list_uis(void)
 {
   return ui_array();
 }
+
+/// Gets the immediate children of process `pid`.
+///
+/// @return Array of child process ids, empty if process not found.
+Array nvim_get_proc_children(Integer pid, Error *err)
+  FUNC_API_SINCE(4)
+{
+  Array rvobj = ARRAY_DICT_INIT;
+  int *proc_list = NULL;
+
+  if (pid <= 0 || pid > INT_MAX) {
+    api_set_error(err, kErrorTypeException, "Invalid pid: %" PRId64, pid);
+    goto end;
+  }
+
+  size_t proc_count;
+  int rv = os_proc_children((int)pid, &proc_list, &proc_count);
+  if (rv != 0) {
+    // syscall failed (possibly because of kernel options), try shelling out.
+    DLOG("fallback to vim._os_proc_children()");
+    Array a = ARRAY_DICT_INIT;
+    ADD(a, INTEGER_OBJ(pid));
+    String s = cstr_to_string("return vim._os_proc_children(select(1, ...))");
+    Object o = nvim_execute_lua(s, a, err);
+    api_free_string(s);
+    api_free_array(a);
+    if (o.type == kObjectTypeArray) {
+      rvobj = o.data.array;
+    } else if (!ERROR_SET(err)) {
+      api_set_error(err, kErrorTypeException,
+                    "Failed to get process children. pid=%" PRId64 " error=%d",
+                    pid, rv);
+    }
+    goto end;
+  }
+
+  for (size_t i = 0; i < proc_count; i++) {
+    ADD(rvobj, INTEGER_OBJ(proc_list[i]));
+  }
+
+end:
+  xfree(proc_list);
+  return rvobj;
+}
+
+/// Gets info describing process `pid`.
+///
+/// @return Map of process properties, or NIL if process not found.
+Object nvim_get_proc(Integer pid, Error *err)
+  FUNC_API_SINCE(4)
+{
+  Object rvobj = OBJECT_INIT;
+  rvobj.data.dictionary = (Dictionary)ARRAY_DICT_INIT;
+  rvobj.type = kObjectTypeDictionary;
+
+  if (pid <= 0 || pid > INT_MAX) {
+    api_set_error(err, kErrorTypeException, "Invalid pid: %" PRId64, pid);
+    return NIL;
+  }
+#ifdef WIN32
+  rvobj.data.dictionary = os_proc_info((int)pid);
+  if (rvobj.data.dictionary.size == 0) {  // Process not found.
+    return NIL;
+  }
+#else
+  // Cross-platform process info APIs are miserable, so use `ps` instead.
+  Array a = ARRAY_DICT_INIT;
+  ADD(a, INTEGER_OBJ(pid));
+  String s = cstr_to_string("return vim._os_proc_info(select(1, ...))");
+  Object o = nvim_execute_lua(s, a, err);
+  api_free_string(s);
+  api_free_array(a);
+  if (o.type == kObjectTypeArray && o.data.array.size == 0) {
+    return NIL;  // Process not found.
+  } else if (o.type == kObjectTypeDictionary) {
+    rvobj.data.dictionary = o.data.dictionary;
+  } else if (!ERROR_SET(err)) {
+    api_set_error(err, kErrorTypeException,
+                  "Failed to get process info. pid=%" PRId64, pid);
+  }
+#endif
+  return rvobj;
+}
diff --git a/src/nvim/event/libuv_process.c b/src/nvim/event/libuv_process.c
index c101cb1bb9..0c2bf397e5 100644
--- a/src/nvim/event/libuv_process.c
+++ b/src/nvim/event/libuv_process.c
@@ -26,15 +26,18 @@ int libuv_process_spawn(LibuvProcess *uvproc)
   uvproc->uvopts.file = proc->argv[0];
   uvproc->uvopts.args = proc->argv;
   uvproc->uvopts.flags = UV_PROCESS_WINDOWS_HIDE;
-  if (proc->detach) {
-      uvproc->uvopts.flags |= UV_PROCESS_DETACHED;
-  }
 #ifdef WIN32
   // libuv collapses the argv to a CommandLineToArgvW()-style string. cmd.exe
   // expects a different syntax (must be prepared by the caller before now).
   if (os_shell_is_cmdexe(proc->argv[0])) {
     uvproc->uvopts.flags |= UV_PROCESS_WINDOWS_VERBATIM_ARGUMENTS;
   }
+  if (proc->detach) {
+    uvproc->uvopts.flags |= UV_PROCESS_DETACHED;
+  }
+#else
+  // Always setsid() on unix-likes. #8107
+  uvproc->uvopts.flags |= UV_PROCESS_DETACHED;
 #endif
   uvproc->uvopts.exit_cb = exit_cb;
   uvproc->uvopts.cwd = proc->cwd;
diff --git a/src/nvim/event/process.c b/src/nvim/event/process.c
index a06f5f4ff3..60650344ce 100644
--- a/src/nvim/event/process.c
+++ b/src/nvim/event/process.c
@@ -12,6 +12,7 @@
 #include "nvim/event/wstream.h"
 #include "nvim/event/process.h"
 #include "nvim/event/libuv_process.h"
+#include "nvim/os/process.h"
 #include "nvim/os/pty_process.h"
 #include "nvim/globals.h"
 #include "nvim/macros.h"
@@ -215,8 +216,7 @@ void process_stop(Process *proc) FUNC_ATTR_NONNULL_ALL
       // stdout/stderr, they will be closed when it exits(possibly due to being
       // terminated after a timeout)
       stream_may_close(&proc->in);
-      ILOG("Sending SIGTERM to pid %d", proc->pid);
-      uv_kill(proc->pid, SIGTERM);
+      os_proc_tree_kill(proc->pid, SIGTERM);
       break;
     case kProcessTypePty:
       // close all streams for pty processes to send SIGHUP to the process
@@ -231,7 +231,7 @@ void process_stop(Process *proc) FUNC_ATTR_NONNULL_ALL
   if (!loop->children_stop_requests++) {
     // When there's at least one stop request pending, start a timer that
     // will periodically check if a signal should be send to the job.
-    ILOG("Starting job kill timer");
+    ILOG("starting job kill timer");
     uv_timer_start(&loop->children_kill_timer, children_kill_cb,
                    KILL_TIMEOUT_MS, KILL_TIMEOUT_MS);
   }
@@ -253,11 +253,9 @@ static void children_kill_cb(uv_timer_t *handle)
 
     if (elapsed >= KILL_TIMEOUT_MS) {
       int sig = proc->type == kProcessTypePty && elapsed < KILL_TIMEOUT_MS * 2
-                    ? SIGTERM
-                    : SIGKILL;
-      ILOG("Sending %s to pid %d", sig == SIGTERM ? "SIGTERM" : "SIGKILL",
-           proc->pid);
-      uv_kill(proc->pid, sig);
+                ? SIGTERM
+                : SIGKILL;
+      os_proc_tree_kill(proc->pid, sig);
     }
   }
 }
diff --git a/src/nvim/lua/vim.lua b/src/nvim/lua/vim.lua
index c7952520b0..e1bbb03d3f 100644
--- a/src/nvim/lua/vim.lua
+++ b/src/nvim/lua/vim.lua
@@ -1,3 +1,62 @@
+-- Internal-only until comments in #8107 are addressed.
+-- Returns:
+--    {errcode}, {output}
+local function _system(cmd)
+  local out = vim.api.nvim_call_function('system', { cmd })
+  local err = vim.api.nvim_get_vvar('shell_error')
+  return err, out
+end
+
+-- Gets process info from the `ps` command.
+-- Used by nvim_get_proc() as a fallback.
+local function _os_proc_info(pid)
+  if pid == nil or pid <= 0 or type(pid) ~= 'number' then
+    error('invalid pid')
+  end
+  local cmd = { 'ps', '-p', pid, '-o', 'ucomm=', }
+  local err, name = _system(cmd)
+  if 1 == err and string.gsub(name, '%s*', '') == '' then
+    return {}  -- Process not found.
+  elseif 0 ~= err then
+    local args_str = vim.api.nvim_call_function('string', { cmd })
+    error('command failed: '..args_str)
+  end
+  local _, ppid = _system({ 'ps', '-p', pid, '-o', 'ppid=', })
+  -- Remove trailing whitespace.
+  name = string.gsub(name, '%s+$', '')
+  ppid = string.gsub(ppid, '%s+$', '')
+  ppid = tonumber(ppid) == nil and -1 or tonumber(ppid)
+  return {
+    name = name,
+    pid = pid,
+    ppid = ppid,
+  }
+end
+
+-- Gets process children from the `pgrep` command.
+-- Used by nvim_get_proc_children() as a fallback.
+local function _os_proc_children(ppid)
+  if ppid == nil or ppid <= 0 or type(ppid) ~= 'number' then
+    error('invalid ppid')
+  end
+  local cmd = { 'pgrep', '-P', ppid, }
+  local err, rv = _system(cmd)
+  if 1 == err and string.gsub(rv, '%s*', '') == '' then
+    return {}  -- Process not found.
+  elseif 0 ~= err then
+    local args_str = vim.api.nvim_call_function('string', { cmd })
+    error('command failed: '..args_str)
+  end
+  local children = {}
+  for s in string.gmatch(rv, '%S+') do
+    local i = tonumber(s)
+    if i ~= nil then
+      table.insert(children, i)
+    end
+  end
+  return children
+end
+
 -- TODO(ZyX-I): Create compatibility layer.
 --{{{1 package.path updater function
 -- Last inserted paths. Used to clear out items from package.[c]path when they
@@ -58,7 +117,12 @@ local function _update_package_paths()
   end
   last_nvim_paths = cur_nvim_paths
 end
---{{{1 Module definition
-return {
+
+local module = {
   _update_package_paths = _update_package_paths,
+  _os_proc_children = _os_proc_children,
+  _os_proc_info = _os_proc_info,
+  _system = _system,
 }
+
+return module
diff --git a/src/nvim/os/fileio.c b/src/nvim/os/fileio.c
index d294f9139b..a95adc86b6 100644
--- a/src/nvim/os/fileio.c
+++ b/src/nvim/os/fileio.c
@@ -4,7 +4,7 @@
 /// @file fileio.c
 ///
 /// Buffered reading/writing to a file. Unlike fileio.c this is not dealing with
-/// Neovim stuctures for buffer, with autocommands, etc: just fopen/fread/fwrite
+/// Nvim stuctures for buffer, with autocommands, etc: just fopen/fread/fwrite
 /// replacement.
 
 #include <assert.h>
@@ -43,7 +43,7 @@
 /// @param[in]  mode  Permissions for the newly created file (ignored if flags
 ///                   does not have kFileCreate\*).
 ///
-/// @return Error code (@see os_strerror()) or 0.
+/// @return Error code, or 0 on success. @see os_strerror()
 int file_open(FileDescriptor *const ret_fp, const char *const fname,
               const int flags, const int mode)
   FUNC_ATTR_NONNULL_ALL FUNC_ATTR_WARN_UNUSED_RESULT
@@ -115,8 +115,7 @@ int file_open_fd(FileDescriptor *const ret_fp, const int fd, const bool wr)
 
 /// Like file_open(), but allocate and return ret_fp
 ///
-/// @param[out]  error  Error code, @see os_strerror(). Is set to zero on
-///                     success.
+/// @param[out]  error  Error code, or 0 on success. @see os_strerror()
 /// @param[in]  fname  File name to open.
 /// @param[in]  flags  Flags, @see FileOpenFlags.
 /// @param[in]  mode  Permissions for the newly created file (ignored if flags
@@ -137,8 +136,7 @@ FileDescriptor *file_open_new(int *const error, const char *const fname,
 
 /// Like file_open_fd(), but allocate and return ret_fp
 ///
-/// @param[out]  error  Error code, @see os_strerror(). Is set to zero on
-///                     success.
+/// @param[out]  error  Error code, or 0 on success. @see os_strerror()
 /// @param[in]  fd  File descriptor to wrap.
 /// @param[in]  wr  True if fd is opened for writing only, false if it is read
 ///                 only.
diff --git a/src/nvim/os/process.c b/src/nvim/os/process.c
new file mode 100644
index 0000000000..e23ba8a4ee
--- /dev/null
+++ b/src/nvim/os/process.c
@@ -0,0 +1,253 @@
+// This is an open source non-commercial project. Dear PVS-Studio, please check
+// it. PVS-Studio Static Code Analyzer for C, C++ and C#: http://www.viva64.com
+
+/// OS process functions
+///
+/// psutil is a good reference for cross-platform syscall voodoo:
+/// https://github.com/giampaolo/psutil/tree/master/psutil/arch
+
+#include <uv.h>  // for HANDLE (win32)
+
+#ifdef WIN32
+# include <tlhelp32.h>  // for CreateToolhelp32Snapshot
+#endif
+
+#if defined(__FreeBSD__)  // XXX: OpenBSD, NetBSD ?
+# include <string.h>
+# include <sys/types.h>
+# include <sys/user.h>
+#endif
+
+#if defined(__APPLE__) || defined(BSD)
+# include <sys/sysctl.h>
+# include <pwd.h>
+#endif
+
+#include "nvim/globals.h"
+#include "nvim/log.h"
+#include "nvim/os/process.h"
+#include "nvim/os/os.h"
+#include "nvim/os/os_defs.h"
+#include "nvim/api/private/helpers.h"
+
+#ifdef INCLUDE_GENERATED_DECLARATIONS
+# include "os/process.c.generated.h"
+#endif
+
+#ifdef WIN32
+static bool os_proc_tree_kill_rec(HANDLE process, int sig)
+{
+  if (process == NULL) {
+    return false;
+  }
+  PROCESSENTRY32 pe;
+  DWORD pid = GetProcessId(process);
+
+  if (pid != 0) {
+    HANDLE h = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);
+    if (h != INVALID_HANDLE_VALUE) {
+      pe.dwSize = sizeof(PROCESSENTRY32);
+      if (!Process32First(h, &pe)) {
+        goto theend;
+      }
+      do {
+        if (pe.th32ParentProcessID == pid) {
+          HANDLE ph = OpenProcess(PROCESS_ALL_ACCESS, false, pe.th32ProcessID);
+          if (ph != NULL) {
+            os_proc_tree_kill_rec(ph, sig);
+            CloseHandle(ph);
+          }
+        }
+      } while (Process32Next(h, &pe));
+      CloseHandle(h);
+    }
+  }
+
+theend:
+  return (bool)TerminateProcess(process, (unsigned int)sig);
+}
+/// Kills process `pid` and its descendants recursively.
+bool os_proc_tree_kill(int pid, int sig)
+{
+  assert(sig >= 0);
+  assert(sig == SIGTERM || sig == SIGKILL);
+  if (pid > 0) {
+    ILOG("terminating process tree: %d", pid);
+    HANDLE h = OpenProcess(PROCESS_ALL_ACCESS, false, (DWORD)pid);
+    return os_proc_tree_kill_rec(h, sig);
+  } else {
+    ELOG("invalid pid: %d", pid);
+  }
+  return false;
+}
+#else
+/// Kills process group where `pid` is the process group leader.
+bool os_proc_tree_kill(int pid, int sig)
+{
+  assert(sig == SIGTERM || sig == SIGKILL);
+  int pgid = getpgid(pid);
+  if (pgid > 0) {  // Ignore error. Never kill self (pid=0).
+    if (pgid == pid) {
+      ILOG("sending %s to process group: -%d",
+           sig == SIGTERM ? "SIGTERM" : "SIGKILL", pgid);
+      int rv = uv_kill(-pgid, sig);
+      return rv == 0;
+    } else {
+      // Should never happen, because process_spawn() did setsid() in the child.
+      ELOG("pgid %d != pid %d", pgid, pid);
+    }
+  } else {
+    ELOG("getpgid(%d) returned %d", pid, pgid);
+  }
+  return false;
+}
+#endif
+
+/// Gets the process ids of the immediate children of process `ppid`.
+///
+/// @param ppid Process to inspect.
+/// @param[out,allocated] proc_list Child process ids.
+/// @param[out] proc_count Number of child processes.
+/// @return 0 on success, 1 if process not found, 2 on other error.
+int os_proc_children(int ppid, int **proc_list, size_t *proc_count)
+{
+  if (ppid < 0) {
+    return 2;
+  }
+
+  int *temp = NULL;
+  *proc_list = NULL;
+  *proc_count = 0;
+
+#ifdef WIN32
+  PROCESSENTRY32 pe;
+
+  // Snapshot of all processes.
+  HANDLE h = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);
+  if (h == INVALID_HANDLE_VALUE) {
+    return 2;
+  }
+
+  pe.dwSize = sizeof(PROCESSENTRY32);
+  // Get root process.
+  if (!Process32First(h, &pe)) {
+    CloseHandle(h);
+    return 2;
+  }
+  // Collect processes whose parent matches `ppid`.
+  do {
+    if (pe.th32ParentProcessID == (DWORD)ppid) {
+      temp = xrealloc(temp, (*proc_count + 1) * sizeof(*temp));
+      temp[*proc_count] = (int)pe.th32ProcessID;
+      (*proc_count)++;
+    }
+  } while (Process32Next(h, &pe));
+  CloseHandle(h);
+
+#elif defined(__APPLE__) || defined(BSD)
+# if defined(__APPLE__)
+#  define KP_PID(o) o.kp_proc.p_pid
+#  define KP_PPID(o) o.kp_eproc.e_ppid
+# elif defined(__FreeBSD__)
+#  define KP_PID(o) o.ki_pid
+#  define KP_PPID(o) o.ki_ppid
+# else
+#  define KP_PID(o) o.p_pid
+#  define KP_PPID(o) o.p_ppid
+# endif
+  static int name[] = { CTL_KERN, KERN_PROC, KERN_PROC_ALL, 0 };
+
+  // Get total process count.
+  size_t len = 0;
+  int rv = sysctl(name, ARRAY_SIZE(name) - 1, NULL, &len, NULL, 0);
+  if (rv) {
+    return 2;
+  }
+
+  // Get ALL processes.
+  struct kinfo_proc *p_list = xmalloc(len);
+  rv = sysctl(name, ARRAY_SIZE(name) - 1, p_list, &len, NULL, 0);
+  if (rv) {
+    xfree(p_list);
+    return 2;
+  }
+
+  // Collect processes whose parent matches `ppid`.
+  bool exists = false;
+  size_t p_count = len / sizeof(*p_list);
+  for (size_t i = 0; i < p_count; i++) {
+    exists = exists || KP_PID(p_list[i]) == ppid;
+    if (KP_PPID(p_list[i]) == ppid) {
+      temp = xrealloc(temp, (*proc_count + 1) * sizeof(*temp));
+      temp[*proc_count] = KP_PID(p_list[i]);
+      (*proc_count)++;
+    }
+  }
+  xfree(p_list);
+  if (!exists) {
+    return 1;  // Process not found.
+  }
+
+#elif defined(__linux__)
+  char proc_p[256] = { 0 };
+  // Collect processes whose parent matches `ppid`.
+  // Rationale: children are defined in thread with same ID of process.
+  snprintf(proc_p, sizeof(proc_p), "/proc/%d/task/%d/children", ppid, ppid);
+  FILE *fp = fopen(proc_p, "r");
+  if (fp == NULL) {
+    return 2;  // Process not found, or /proc/…/children not supported.
+  }
+  int match_pid;
+  while (fscanf(fp, "%d", &match_pid) > 0) {
+    temp = xrealloc(temp, (*proc_count + 1) * sizeof(*temp));
+    temp[*proc_count] = match_pid;
+    (*proc_count)++;
+  }
+  fclose(fp);
+#endif
+
+  *proc_list = temp;
+  return 0;
+}
+
+#ifdef WIN32
+/// Gets various properties of the process identified by `pid`.
+///
+/// @param pid Process to inspect.
+/// @return Map of process properties, empty on error.
+Dictionary os_proc_info(int pid)
+{
+  Dictionary pinfo = ARRAY_DICT_INIT;
+  PROCESSENTRY32 pe;
+
+  // Snapshot of all processes.  This is used instead of:
+  //    OpenProcess(PROCESS_QUERY_INFORMATION | PROCESS_VM_READ, …)
+  // to avoid ERROR_PARTIAL_COPY.  https://stackoverflow.com/a/29942376
+  HANDLE h = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);
+  if (h == INVALID_HANDLE_VALUE) {
+    return pinfo;  // Return empty.
+  }
+
+  pe.dwSize = sizeof(PROCESSENTRY32);
+  // Get root process.
+  if (!Process32First(h, &pe)) {
+    CloseHandle(h);
+    return pinfo;  // Return empty.
+  }
+  // Find the process.
+  do {
+    if (pe.th32ProcessID == (DWORD)pid) {
+      break;
+    }
+  } while (Process32Next(h, &pe));
+  CloseHandle(h);
+
+  if (pe.th32ProcessID == (DWORD)pid) {
+    PUT(pinfo, "pid", INTEGER_OBJ(pid));
+    PUT(pinfo, "ppid", INTEGER_OBJ((int)pe.th32ParentProcessID));
+    PUT(pinfo, "name", STRING_OBJ(cstr_to_string(pe.szExeFile)));
+  }
+
+  return pinfo;
+}
+#endif
diff --git a/src/nvim/os/process.h b/src/nvim/os/process.h
new file mode 100644
index 0000000000..1722d56bd3
--- /dev/null
+++ b/src/nvim/os/process.h
@@ -0,0 +1,11 @@
+#ifndef NVIM_OS_PROCESS_H
+#define NVIM_OS_PROCESS_H
+
+#include <stddef.h>
+#include "nvim/api/private/defs.h"
+
+#ifdef INCLUDE_GENERATED_DECLARATIONS
+# include "os/process.h.generated.h"
+#endif
+
+#endif  // NVIM_OS_PROCESS_H
diff --git a/src/nvim/os/pty_process_unix.c b/src/nvim/os/pty_process_unix.c
index 855ca2ae47..dfe2cfbb8d 100644
--- a/src/nvim/os/pty_process_unix.c
+++ b/src/nvim/os/pty_process_unix.c
@@ -145,8 +145,12 @@ void pty_process_teardown(Loop *loop)
   uv_signal_stop(&loop->children_watcher);
 }
 
-static void init_child(PtyProcess *ptyproc) FUNC_ATTR_NONNULL_ALL
+static void init_child(PtyProcess *ptyproc)
+  FUNC_ATTR_NONNULL_ALL
 {
+  // New session/process-group. #6530
+  setsid();
+
   unsetenv("COLUMNS");
   unsetenv("LINES");
   unsetenv("TERMCAP");