Merge #8107 'jobs: separate process-group'
This commit is contained in:
commit
4e02f1ab87
|
@ -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;
|
||||
}
|
||||
|
|
|
@ -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;
|
||||
|
|
|
@ -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);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
|
@ -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
|
||||
|
|
|
@ -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.
|
||||
|
|
|
@ -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
|
|
@ -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
|
|
@ -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");
|
||||
|
|
|
@ -0,0 +1,81 @@
|
|||
local helpers = require('test.functional.helpers')(after_each)
|
||||
|
||||
local clear = helpers.clear
|
||||
local eq = helpers.eq
|
||||
local funcs = helpers.funcs
|
||||
local iswin = helpers.iswin
|
||||
local nvim_argv = helpers.nvim_argv
|
||||
local ok = helpers.ok
|
||||
local request = helpers.request
|
||||
local retry = helpers.retry
|
||||
local NIL = helpers.NIL
|
||||
|
||||
describe('api', function()
|
||||
before_each(clear)
|
||||
|
||||
describe('nvim_get_proc_children', function()
|
||||
it('returns child process ids', function()
|
||||
local this_pid = funcs.getpid()
|
||||
|
||||
local job1 = funcs.jobstart(nvim_argv)
|
||||
retry(nil, nil, function()
|
||||
eq(1, #request('nvim_get_proc_children', this_pid))
|
||||
end)
|
||||
|
||||
local job2 = funcs.jobstart(nvim_argv)
|
||||
retry(nil, nil, function()
|
||||
eq(2, #request('nvim_get_proc_children', this_pid))
|
||||
end)
|
||||
|
||||
funcs.jobstop(job1)
|
||||
retry(nil, nil, function()
|
||||
eq(1, #request('nvim_get_proc_children', this_pid))
|
||||
end)
|
||||
|
||||
funcs.jobstop(job2)
|
||||
retry(nil, nil, function()
|
||||
eq(0, #request('nvim_get_proc_children', this_pid))
|
||||
end)
|
||||
end)
|
||||
|
||||
it('validates input', function()
|
||||
local status, rv = pcall(request, "nvim_get_proc_children", -1)
|
||||
eq(false, status)
|
||||
eq("Invalid pid: -1", string.match(rv, "Invalid.*"))
|
||||
|
||||
status, rv = pcall(request, "nvim_get_proc_children", 0)
|
||||
eq(false, status)
|
||||
eq("Invalid pid: 0", string.match(rv, "Invalid.*"))
|
||||
|
||||
-- Assume PID 99999 does not exist.
|
||||
status, rv = pcall(request, "nvim_get_proc_children", 99999)
|
||||
eq(true, status)
|
||||
eq({}, rv)
|
||||
end)
|
||||
end)
|
||||
|
||||
describe('nvim_get_proc', function()
|
||||
it('returns process info', function()
|
||||
local pid = funcs.getpid()
|
||||
local pinfo = request('nvim_get_proc', pid)
|
||||
eq((iswin() and 'nvim.exe' or 'nvim'), pinfo.name)
|
||||
ok(pinfo.pid == pid)
|
||||
ok(type(pinfo.ppid) == 'number' and pinfo.ppid ~= pid)
|
||||
end)
|
||||
|
||||
it('validates input', function()
|
||||
local status, rv = pcall(request, "nvim_get_proc", -1)
|
||||
eq(false, status)
|
||||
eq("Invalid pid: -1", string.match(rv, "Invalid.*"))
|
||||
|
||||
status, rv = pcall(request, "nvim_get_proc", 0)
|
||||
eq(false, status)
|
||||
eq("Invalid pid: 0", string.match(rv, "Invalid.*"))
|
||||
|
||||
-- Assume PID 99999 does not exist.
|
||||
status, rv = pcall(request, "nvim_get_proc", 99999)
|
||||
eq(true, status)
|
||||
eq(NIL, rv)
|
||||
end)
|
||||
end)
|
||||
end)
|
|
@ -1,3 +1,4 @@
|
|||
local luv = require('luv')
|
||||
local helpers = require('test.functional.helpers')(after_each)
|
||||
|
||||
local clear, command, nvim, nvim_dir =
|
||||
|
@ -39,13 +40,15 @@ describe('TermClose event', function()
|
|||
.. [[ 'on_exit': {-> execute('let g:test_job_exited = 1')}}) ]])
|
||||
retry(nil, nil, function() eq(1, eval('get(g:, "test_job_started", 0)')) end)
|
||||
|
||||
local start = os.time()
|
||||
luv.update_time()
|
||||
local start = luv.now()
|
||||
command('call jobstop(g:test_job)')
|
||||
retry(nil, nil, function() eq(1, eval('get(g:, "test_job_exited", 0)')) end)
|
||||
local duration = os.time() - start
|
||||
-- nvim starts sending SIGTERM after KILL_TIMEOUT_MS
|
||||
ok(duration >= 2)
|
||||
ok(duration <= 4) -- <= 2 + delta because of slow CI
|
||||
luv.update_time()
|
||||
local duration = luv.now() - start
|
||||
-- Nvim begins SIGTERM after KILL_TIMEOUT_MS.
|
||||
ok(duration >= 2000)
|
||||
ok(duration <= 4000) -- Epsilon for slow CI
|
||||
end)
|
||||
|
||||
it('kills pty job trapping SIGHUP and SIGTERM', function()
|
||||
|
@ -58,13 +61,15 @@ describe('TermClose event', function()
|
|||
.. [[ 'on_exit': {-> execute('let g:test_job_exited = 1')}}) ]])
|
||||
retry(nil, nil, function() eq(1, eval('get(g:, "test_job_started", 0)')) end)
|
||||
|
||||
local start = os.time()
|
||||
luv.update_time()
|
||||
local start = luv.now()
|
||||
command('call jobstop(g:test_job)')
|
||||
retry(nil, nil, function() eq(1, eval('get(g:, "test_job_exited", 0)')) end)
|
||||
local duration = os.time() - start
|
||||
-- nvim starts sending kill after 2*KILL_TIMEOUT_MS
|
||||
ok(duration >= 4)
|
||||
ok(duration <= 7) -- <= 4 + delta because of slow CI
|
||||
luv.update_time()
|
||||
local duration = luv.now() - start
|
||||
-- Nvim begins SIGKILL after (2 * KILL_TIMEOUT_MS).
|
||||
ok(duration >= 4000)
|
||||
ok(duration <= 7000) -- Epsilon for slow CI
|
||||
end)
|
||||
|
||||
it('reports the correct <abuf>', function()
|
||||
|
|
|
@ -6,6 +6,10 @@ local clear, eq, eval, exc_exec, feed_command, feed, insert, neq, next_msg, nvim
|
|||
helpers.nvim_dir, helpers.ok, helpers.source,
|
||||
helpers.write_file, helpers.mkdir, helpers.rmdir
|
||||
local command = helpers.command
|
||||
local funcs = helpers.funcs
|
||||
local retry = helpers.retry
|
||||
local meths = helpers.meths
|
||||
local NIL = helpers.NIL
|
||||
local wait = helpers.wait
|
||||
local iswin = helpers.iswin
|
||||
local get_pathsep = helpers.get_pathsep
|
||||
|
@ -636,6 +640,42 @@ describe('jobs', function()
|
|||
ok(string.find(err, "E475: Invalid argument: job cannot have both 'pty' and 'rpc' options set") ~= nil)
|
||||
end)
|
||||
|
||||
it('jobstop() kills entire process tree #6530', function()
|
||||
command('set shell& shellcmdflag& shellquote& shellpipe& shellredir& shellxquote&')
|
||||
|
||||
-- XXX: Using `nvim` isn't a good test, it reaps its children on exit.
|
||||
-- local c = 'call jobstart([v:progpath, "-u", "NONE", "-i", "NONE", "--headless"])'
|
||||
-- local j = eval("jobstart([v:progpath, '-u', 'NONE', '-i', 'NONE', '--headless', '-c', '"
|
||||
-- ..c.."', '-c', '"..c.."'])")
|
||||
|
||||
-- Create child with several descendants.
|
||||
local j = (iswin()
|
||||
and eval([=[jobstart('start /b cmd /c "ping 127.0.0.1 -n 1 -w 30000 > NUL"]=]
|
||||
..[=[ & start /b cmd /c "ping 127.0.0.1 -n 1 -w 40000 > NUL"]=]
|
||||
..[=[ & start /b cmd /c "ping 127.0.0.1 -n 1 -w 50000 > NUL"')]=])
|
||||
or eval("jobstart('sleep 30 | sleep 30 | sleep 30')"))
|
||||
local ppid = funcs.jobpid(j)
|
||||
local children
|
||||
retry(nil, nil, function()
|
||||
children = meths.get_proc_children(ppid)
|
||||
eq(3, #children)
|
||||
end)
|
||||
-- Assert that nvim_get_proc() sees the children.
|
||||
for _, child_pid in ipairs(children) do
|
||||
local info = meths.get_proc(child_pid)
|
||||
-- eq((iswin() and 'nvim.exe' or 'nvim'), info.name)
|
||||
eq(ppid, info.ppid)
|
||||
end
|
||||
-- Kill the root of the tree.
|
||||
funcs.jobstop(j)
|
||||
-- Assert that the children were killed.
|
||||
retry(nil, nil, function()
|
||||
for _, child_pid in ipairs(children) do
|
||||
eq(NIL, meths.get_proc(child_pid))
|
||||
end
|
||||
end)
|
||||
end)
|
||||
|
||||
describe('running tty-test program', function()
|
||||
if helpers.pending_win32(pending) then return end
|
||||
local function next_chunk()
|
||||
|
|
Loading…
Reference in New Issue