Merge branch 'master' into s-dash-stdin

5 files changed, 35 insertions, 23 deletions

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/loop.c b/src/nvim/event/loop.c
index 5adf16c0f3..d92464f17b 100644
--- a/src/nvim/event/loop.c
+++ b/src/nvim/event/loop.c
@@ -30,19 +30,25 @@ void loop_init(Loop *loop, void *data)
   uv_signal_init(&loop->uv, &loop->children_watcher);
   uv_timer_init(&loop->uv, &loop->children_kill_timer);
   uv_timer_init(&loop->uv, &loop->poll_timer);
+  loop->poll_timer.data = xmalloc(sizeof(bool));  // "timeout expired" flag
 }
 
-void loop_poll_events(Loop *loop, int ms)
+/// Processes one `Loop.uv` event (at most).
+/// Processes all `Loop.fast_events` events.
+///
+/// @returns true if `ms` timeout was reached
+bool loop_poll_events(Loop *loop, int ms)
 {
   if (loop->recursive++) {
     abort();  // Should not re-enter uv_run
   }
 
   uv_run_mode mode = UV_RUN_ONCE;
+  bool timeout_expired = false;
 
   if (ms > 0) {
-    // Use a repeating timeout of ms milliseconds to make sure
-    // we do not block indefinitely for I/O.
+    *((bool *)loop->poll_timer.data) = false;  // reset "timeout expired" flag
+    // Dummy timer to ensure UV_RUN_ONCE does not block indefinitely for I/O.
     uv_timer_start(&loop->poll_timer, timer_cb, (uint64_t)ms, (uint64_t)ms);
   } else if (ms == 0) {
     // For ms == 0, do a non-blocking event poll.
@@ -52,11 +58,13 @@ void loop_poll_events(Loop *loop, int ms)
   uv_run(&loop->uv, mode);
 
   if (ms > 0) {
+    timeout_expired = *((bool *)loop->poll_timer.data);
     uv_timer_stop(&loop->poll_timer);
   }
 
   loop->recursive--;  // Can re-enter uv_run now
   multiqueue_process_events(loop->fast_events);
+  return timeout_expired;
 }
 
 /// Schedules an event from another thread.
@@ -111,7 +119,7 @@ bool loop_close(Loop *loop, bool wait)
   uv_mutex_destroy(&loop->mutex);
   uv_close((uv_handle_t *)&loop->children_watcher, NULL);
   uv_close((uv_handle_t *)&loop->children_kill_timer, NULL);
-  uv_close((uv_handle_t *)&loop->poll_timer, NULL);
+  uv_close((uv_handle_t *)&loop->poll_timer, timer_close_cb);
   uv_close((uv_handle_t *)&loop->async, NULL);
   uint64_t start = wait ? os_hrtime() : 0;
   while (true) {
@@ -163,5 +171,11 @@ static void async_cb(uv_async_t *handle)
 
 static void timer_cb(uv_timer_t *handle)
 {
+  bool *timeout_expired = handle->data;
+  *timeout_expired = true;
 }
 
+static void timer_close_cb(uv_handle_t *handle)
+{
+  xfree(handle->data);
+}
diff --git a/src/nvim/event/process.c b/src/nvim/event/process.c
index 4eb2dd0baf..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"
@@ -151,7 +152,6 @@ void process_close_streams(Process *proc) FUNC_ATTR_NONNULL_ALL
 int process_wait(Process *proc, int ms, MultiQueue *events)
   FUNC_ATTR_NONNULL_ARG(1)
 {
-  bool interrupted = false;
   if (!proc->refcount) {
     int status = proc->status;
     LOOP_PROCESS_EVENTS(proc->loop, proc->events, 0);
@@ -173,7 +173,6 @@ int process_wait(Process *proc, int ms, MultiQueue *events)
   // we'll assume that a user frantically hitting interrupt doesn't like
   // the current job. Signal that it has to be killed.
   if (got_int) {
-    interrupted = true;
     got_int = false;
     process_stop(proc);
     if (ms == -1) {
@@ -184,14 +183,13 @@ int process_wait(Process *proc, int ms, MultiQueue *events)
     } else {
       LOOP_PROCESS_EVENTS(proc->loop, events, 0);
     }
+
+    proc->status = -2;
   }
 
   if (proc->refcount == 1) {
     // Job exited, collect status and manually invoke close_cb to free the job
     // resources
-    if (interrupted) {
-      proc->status = -2;
-    }
     decref(proc);
     if (events) {
       // the decref call created an exit event, process it now
@@ -218,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
@@ -234,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);
   }
@@ -256,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/event/rstream.c b/src/nvim/event/rstream.c
index e0500ba828..2fbe7f6773 100644
--- a/src/nvim/event/rstream.c
+++ b/src/nvim/event/rstream.c
@@ -95,7 +95,7 @@ static void alloc_cb(uv_handle_t *handle, size_t suggested, uv_buf_t *buf)
   // `uv_buf_t.len` happens to have different size on Windows.
   size_t write_count;
   buf->base = rbuffer_write_ptr(stream->buffer, &write_count);
-  buf->len = write_count;
+  buf->len = UV_BUF_LEN(write_count);
 }
 
 // Callback invoked by libuv after it copies the data into the buffer provided
@@ -146,7 +146,7 @@ static void fread_idle_cb(uv_idle_t *handle)
   // `uv_buf_t.len` happens to have different size on Windows.
   size_t write_count;
   stream->uvbuf.base = rbuffer_write_ptr(stream->buffer, &write_count);
-  stream->uvbuf.len = write_count;
+  stream->uvbuf.len = UV_BUF_LEN(write_count);
 
   // the offset argument to uv_fs_read is int64_t, could someone really try
   // to read more than 9 quintillion (9e18) bytes?
diff --git a/src/nvim/event/wstream.c b/src/nvim/event/wstream.c
index 320006890d..d2fb52243c 100644
--- a/src/nvim/event/wstream.c
+++ b/src/nvim/event/wstream.c
@@ -90,7 +90,7 @@ bool wstream_write(Stream *stream, WBuffer *buffer)
 
   uv_buf_t uvbuf;
   uvbuf.base = buffer->data;
-  uvbuf.len = buffer->size;
+  uvbuf.len = UV_BUF_LEN(buffer->size);
 
   if (uv_write(&data->uv_req, stream->uvstream, &uvbuf, 1, write_cb)) {
     xfree(data);