Put more thought into i/o polyfills

wait4() is now solid enough to run `make -j100` on Windows. You can now
use MSG_DONTWAIT on Windows. There was a handle leak in accept() that's
been fixed. Our WIN32 overlapped i/o code has been simplified. Priority
class now inherits into subprocesses, so the verynice command will work
and the signal mask will now be inherited by execve() and posix_spawn()

libc/calls/getcwd.greg.c

@@ -164,6 +164,6 @@ int __getcwd(char *buf, size_t size) {
   } else {
     rc = sys_getcwd_metal(buf, size);
   }
-  STRACE("__getcwd([%#hhs], %'zu) → %d% m", rc != -1 ? buf : "n/a", size, rc);
+  STRACE("getcwd([%#hhs], %'zu) → %d% m", rc != -1 ? buf : "n/a", size, rc);
   return rc;
 }

libc/calls/ntspawn.c

@@ -126,7 +126,8 @@ textwindows int ntspawn(
           if (CreateProcess(sb->path, sb->cmdline, 0, 0, true,
                             dwCreationFlags | kNtCreateUnicodeEnvironment |
                                 kNtExtendedStartupinfoPresent |
-                                kNtInheritParentAffinity,
+                                kNtInheritParentAffinity |
+                                GetPriorityClass(GetCurrentProcess()),
                             sb->envblock, opt_lpCurrentDirectory,
                             &info.StartupInfo, opt_out_lpProcessInformation)) {
             rc = 0;

libc/calls/park.c

@@ -32,11 +32,7 @@ static textwindows int _park_thread(uint32_t msdelay, sigset_t waitmask,
                                     bool restartable) {
   int sig;
   if (_check_cancel() == -1) return -1;
-  if ((sig = __sig_get(waitmask))) {
-    int handler_was_called = __sig_relay(sig, SI_KERNEL, waitmask);
-    if (_check_cancel() == -1) return -1;
-    if (!restartable || handler_was_called == 1) return eintr();
-  }
+  if ((sig = __sig_get(waitmask))) goto HandleSignal;
   int expect = 0;
   atomic_int futex = 0;
   struct PosixThread *pt = _pthread_self();
@@ -45,9 +41,12 @@ static textwindows int _park_thread(uint32_t msdelay, sigset_t waitmask,
   bool32 ok = WaitOnAddress(&futex, &expect, sizeof(int), msdelay);
   atomic_store_explicit(&pt->pt_blocker, 0, memory_order_release);
   if (ok && (sig = __sig_get(waitmask))) {
+  HandleSignal:
     int handler_was_called = __sig_relay(sig, SI_KERNEL, waitmask);
     if (_check_cancel() == -1) return -1;
-    if (!restartable || handler_was_called == 1) return eintr();
+    if (!restartable || (handler_was_called & SIG_HANDLED_NO_RESTART)) {
+      return eintr();
+    }
   }
   return 0;
 }

libc/calls/poll-nt.c

@@ -55,6 +55,8 @@
 #include "libc/thread/tls.h"
 #ifdef __x86_64__
 
+#define POLL_INTERVAL_MS 10
+
 // Polls on the New Technology.
 //
 // This function is used to implement poll() and select(). You may poll
@@ -184,7 +186,7 @@ static textwindows int sys_poll_nt_impl(struct pollfd *fds, uint64_t nfds,
         remain = timespec_sub(deadline, now);
         millis = timespec_tomillis(remain);
         waitfor = MIN(millis, 0xffffffffu);
-        waitfor = MIN(waitfor, __SIG_POLL_INTERVAL_MS);
+        waitfor = MIN(waitfor, POLL_INTERVAL_MS);
         if (waitfor) {
           POLLTRACE("poll() sleeping for %'d out of %'lu ms", waitfor,
                     timespec_tomillis(remain));

libc/calls/read-nt.c

@@ -723,8 +723,6 @@ static textwindows int WaitForConsole(struct Fd *f, sigset_t waitmask) {
   int sig;
   int64_t sem;
   uint32_t wi, ms = -1;
-  int handler_was_called;
-  struct PosixThread *pt;
   if (!__ttyconf.vmin) {
     if (!__ttyconf.vtime) {
       return 0;  // non-blocking w/o raising eagain
@@ -732,31 +730,24 @@ static textwindows int WaitForConsole(struct Fd *f, sigset_t waitmask) {
       ms = __ttyconf.vtime * 100;
     }
   }
-  if (f->flags & _O_NONBLOCK) {
-    return eagain();  // standard unix non-blocking
-  }
   if (_check_cancel() == -1) return -1;
-  if ((sig = __sig_get(waitmask))) {
-    handler_was_called = __sig_relay(sig, SI_KERNEL, waitmask);
-    if (_check_cancel() == -1) return -1;
-    if (handler_was_called != 1) return -2;
-    return eintr();
-  }
-  pt = _pthread_self();
-  pt->pt_semaphore = sem = CreateSemaphore(0, 0, 1, 0);
-  pthread_cleanup_push((void *)CloseHandle, (void *)sem);
+  if (f->flags & _O_NONBLOCK) return eagain();
+  if ((sig = __sig_get(waitmask))) goto DeliverSignal;
+  struct PosixThread *pt = _pthread_self();
   pt->pt_blkmask = waitmask;
+  pt->pt_semaphore = sem = CreateSemaphore(0, 0, 1, 0);
   atomic_store_explicit(&pt->pt_blocker, PT_BLOCKER_SEM, memory_order_release);
   wi = WaitForMultipleObjects(2, (int64_t[2]){__keystroke.cin, sem}, 0, ms);
   atomic_store_explicit(&pt->pt_blocker, 0, memory_order_release);
-  pthread_cleanup_pop(true);
+  CloseHandle(sem);
   if (wi == kNtWaitTimeout) return 0;  // vtime elapsed
   if (wi == 0) return -2;              // console data
   if (wi != 1) return __winerr();      // wait failed
   if (!(sig = __sig_get(waitmask))) return eintr();
-  handler_was_called = __sig_relay(sig, SI_KERNEL, waitmask);
+DeliverSignal:
+  int handler_was_called = __sig_relay(sig, SI_KERNEL, waitmask);
   if (_check_cancel() == -1) return -1;
-  if (handler_was_called != 1) return -2;
+  if (!(handler_was_called & SIG_HANDLED_NO_RESTART)) return -2;
   return eintr();
 }
 

libc/calls/readwrite-nt.c

@@ -16,15 +16,12 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/calls/calls.h"
 #include "libc/calls/createfileflags.internal.h"
 #include "libc/calls/internal.h"
 #include "libc/calls/sig.internal.h"
 #include "libc/calls/struct/fd.internal.h"
-#include "libc/calls/struct/sigset.internal.h"
+#include "libc/calls/struct/sigset.h"
 #include "libc/calls/syscall_support-nt.internal.h"
-#include "libc/errno.h"
-#include "libc/intrin/atomic.h"
 #include "libc/nt/enum/filetype.h"
 #include "libc/nt/errors.h"
 #include "libc/nt/events.h"
@@ -34,28 +31,10 @@
 #include "libc/nt/synchronization.h"
 #include "libc/nt/thread.h"
 #include "libc/stdio/sysparam.h"
-#include "libc/str/str.h"
-#include "libc/sysv/consts/o.h"
 #include "libc/sysv/consts/sicode.h"
 #include "libc/sysv/errfuns.h"
-#include "libc/thread/posixthread.internal.h"
-#include "libc/thread/thread.h"
-#include "libc/thread/tls.h"
 #ifdef __x86_64__
 
-struct ReadwriteResources {
-  int64_t handle;
-  struct NtOverlapped *overlap;
-};
-
-static void UnwindReadwrite(void *arg) {
-  uint32_t got;
-  struct ReadwriteResources *rwc = arg;
-  CancelIoEx(rwc->handle, rwc->overlap);
-  GetOverlappedResult(rwc->handle, rwc->overlap, &got, true);
-  CloseHandle(rwc->overlap->hEvent);
-}
-
 /**
  * Runs code that's common to read/write/pread/pwrite/etc on Windows.
  *
@@ -64,17 +43,11 @@ static void UnwindReadwrite(void *arg) {
  */
 textwindows ssize_t
 sys_readwrite_nt(int fd, void *data, size_t size, ssize_t offset,
-                 int64_t handle, uint64_t waitmask,
+                 int64_t handle, sigset_t waitmask,
                  bool32 ReadOrWriteFile(int64_t, void *, uint32_t, uint32_t *,
                                         struct NtOverlapped *)) {
-  bool32 ok;
-  int sig = 0;
+  int sig;
   uint32_t exchanged;
-  int olderror = errno;
-  bool eagained = false;
-  bool canceled = false;
-  int handler_was_called;
-  struct PosixThread *pt;
   struct Fd *f = g_fds.p + fd;
 
   // win32 i/o apis generally take 32-bit values thus we implicitly
@@ -106,33 +79,26 @@ sys_readwrite_nt(int fd, void *data, size_t size, ssize_t offset,
   }
 
 RestartOperation:
+  bool eagained = false;
+  // check for signals and cancelation
+  if (_check_cancel() == -1) return -1;  // ECANCELED
+  if ((sig = __sig_get(waitmask))) goto HandleInterrupt;
+
   // signals have already been fully blocked by caller
   // perform i/o operation with atomic signal/cancel checking
   struct NtOverlapped overlap = {.hEvent = CreateEvent(0, 1, 0, 0),
                                  .Pointer = offset};
-  struct ReadwriteResources rwc = {handle, &overlap};
-  pthread_cleanup_push(UnwindReadwrite, &rwc);
-  ok = ReadOrWriteFile(handle, data, size, 0, &overlap);
+  bool32 ok = ReadOrWriteFile(handle, data, size, 0, &overlap);
   if (!ok && GetLastError() == kNtErrorIoPending) {
     // win32 says this i/o operation needs to block
     if (f->flags & _O_NONBLOCK) {
       // abort the i/o operation if file descriptor is in non-blocking mode
       CancelIoEx(handle, &overlap);
       eagained = true;
-    } else if (_check_cancel()) {
-      // _check_cancel() can go three ways:
-      // 1. it'll return 0 if we're fine and no thread cancelation happened
-      // 2. it'll pthread_exit() and cleanup, when cancelation was deferred
-      // 3. it'll return -1 and raise ECANCELED if a cancelation was masked
-      CancelIoEx(handle, &overlap);
-      canceled = true;
-    } else if ((sig = __sig_get(waitmask))) {
-      // we've dequeued a signal that was pending per caller's old sigmask
-      // we can't call the signal handler until we release win32 resources
-      CancelIoEx(handle, &overlap);
     } else {
       // wait until i/o either completes or is canceled by another thread
       // we avoid a race condition by having a second mask for unblocking
+      struct PosixThread *pt;
       pt = _pthread_self();
       pt->pt_blkmask = waitmask;
       pt->pt_iohandle = handle;
@@ -147,30 +113,13 @@ RestartOperation:
   if (ok) {
     ok = GetOverlappedResult(handle, &overlap, &exchanged, true);
   }
-  pthread_cleanup_pop(false);
   CloseHandle(overlap.hEvent);
 
-  // if we acknowledged a pending masked mode cancelation request then
-  // we must pass it to the caller immediately now that cleanup's done
-  if (canceled) {
-    return ecanceled();
-  }
-
-  // if we removed a pending signal then we must raise it
-  // it's now safe to call a signal handler that longjmps
-  if (sig) {
-    handler_was_called = __sig_relay(sig, SI_KERNEL, waitmask);
-    if (_check_cancel() == -1) return -1;
-  } else {
-    handler_was_called = 0;
-  }
-
   // if i/o succeeded then return its result
   if (ok) {
     if (!pwriting && seekable) {
       f->pointer = offset + exchanged;
     }
-    errno = olderror;
     return exchanged;
   }
 
@@ -180,17 +129,15 @@ RestartOperation:
     if (eagained) {
       return eagain();
     }
-    // at this point the i/o must have been canceled due to a signal.
-    // this could be because we found the signal earlier and canceled
-    // ourself. otherwise it's due to a kill from another thread that
-    // added something to our mask and canceled our i/o, so we check.
-    if (!handler_was_called && (sig = __sig_get(waitmask))) {
-      handler_was_called = __sig_relay(sig, SI_KERNEL, waitmask);
-      if (_check_cancel() == -1) return -1;
-    }
-    // read() is @restartable unless non-SA_RESTART hands were called
-    if (handler_was_called != 1) {
-      goto RestartOperation;
+    // otherwise it must be due to a kill() via __sig_cancel()
+    if ((sig = __sig_get(waitmask))) {
+    HandleInterrupt:
+      int handler_was_called = __sig_relay(sig, SI_KERNEL, waitmask);
+      if (_check_cancel() == -1) return -1;  // possible if we SIGTHR'd
+      // read() is @restartable unless non-SA_RESTART hands were called
+      if (!(handler_was_called & SIG_HANDLED_NO_RESTART)) {
+        goto RestartOperation;
+      }
     }
     return eintr();
   }

libc/calls/sig.c

@@ -18,8 +18,6 @@
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/sysv/consts/sig.h"
 #include "ape/sections.internal.h"
-#include "libc/assert.h"
-#include "libc/atomic.h"
 #include "libc/calls/calls.h"
 #include "libc/calls/sig.internal.h"
 #include "libc/calls/state.internal.h"
@@ -30,34 +28,26 @@
 #include "libc/calls/ucontext.h"
 #include "libc/dce.h"
 #include "libc/errno.h"
-#include "libc/fmt/itoa.h"
 #include "libc/intrin/atomic.h"
 #include "libc/intrin/bsf.h"
 #include "libc/intrin/describebacktrace.internal.h"
-#include "libc/intrin/kprintf.h"
-#include "libc/intrin/popcnt.h"
+#include "libc/intrin/dll.h"
 #include "libc/intrin/strace.internal.h"
-#include "libc/intrin/weaken.h"
 #include "libc/nt/console.h"
 #include "libc/nt/enum/context.h"
 #include "libc/nt/enum/exceptionhandleractions.h"
 #include "libc/nt/enum/signal.h"
 #include "libc/nt/enum/status.h"
-#include "libc/nt/errors.h"
 #include "libc/nt/runtime.h"
 #include "libc/nt/signals.h"
-#include "libc/nt/struct/context.h"
 #include "libc/nt/struct/ntexceptionpointers.h"
 #include "libc/nt/synchronization.h"
 #include "libc/nt/thread.h"
-#include "libc/runtime/runtime.h"
 #include "libc/str/str.h"
 #include "libc/sysv/consts/sa.h"
 #include "libc/sysv/consts/sicode.h"
 #include "libc/sysv/consts/ss.h"
 #include "libc/thread/posixthread.internal.h"
-#include "libc/thread/thread.h"
-#include "libc/thread/tls.h"
 #ifdef __x86_64__
 
 /**
@@ -206,16 +196,19 @@ textwindows int __sig_raise(volatile int sig, int sic) {
                                               memory_order_acquire);
 
     // call the user's signal handler
-    char ssbuf[2][128];
+    char ssbuf[128];
     siginfo_t si = {.si_signo = sig, .si_code = sic};
-    STRACE("__sig_raise(%G, %t) mask %s → %s", sig, __sig_handler(rva),
-           (DescribeSigset)(ssbuf[0], 0, &ctx.uc_sigmask),
-           (DescribeSigset)(ssbuf[1], 0, (sigset_t *)&pt->tib->tib_sigmask));
+    STRACE("__sig_raise(%G, %t) mask %s", sig, __sig_handler(rva),
+           (DescribeSigset)(ssbuf, 0, (sigset_t *)&pt->tib->tib_sigmask));
     __sig_handler(rva)(sig, &si, &ctx);
     (void)ssbuf;
 
     // record this handler
-    handler_was_called |= (flags & SA_RESTART) ? 2 : 1;
+    if (flags & SA_RESTART) {
+      handler_was_called |= SIG_HANDLED_SA_RESTART;
+    } else {
+      handler_was_called |= SIG_HANDLED_NO_RESTART;
+    }
   }
 
   // restore sigmask
@@ -320,12 +313,18 @@ static int __sig_killer(struct PosixThread *pt, int sig, int sic) {
     __sig_terminate(sig);
   }
 
+  // ignore signals already pending
+  uintptr_t th = _pthread_syshand(pt);
+  if (atomic_load_explicit(&pt->tib->tib_sigpending, memory_order_acquire) &
+      (1ull << (sig - 1))) {
+    return 0;
+  }
+
   // take control of thread
   // suspending the thread happens asynchronously
   // however getting the context blocks until it's frozen
   static pthread_spinlock_t killer_lock;
   pthread_spin_lock(&killer_lock);
-  uintptr_t th = _pthread_syshand(pt);
   if (SuspendThread(th) == -1u) {
     STRACE("SuspendThread failed w/ %d", GetLastError());
     pthread_spin_unlock(&killer_lock);
@@ -414,6 +413,10 @@ textwindows void __sig_generate(int sig, int sic) {
     STRACE("terminating on %G due to no handler", sig);
     __sig_terminate(sig);
   }
+  if (atomic_load_explicit(&__sig.pending, memory_order_acquire) &
+      (1ull << (sig - 1))) {
+    return;
+  }
   BLOCK_SIGNALS;
   _pthread_lock();
   for (e = dll_first(_pthread_list); e; e = dll_next(_pthread_list, e)) {
@@ -428,7 +431,6 @@ textwindows void __sig_generate(int sig, int sic) {
     // choose this thread if it isn't masking sig
     if (!(atomic_load_explicit(&pt->tib->tib_sigmask, memory_order_acquire) &
           (1ull << (sig - 1)))) {
-      STRACE("generating %G by killing %d", sig, _pthread_tid(pt));
       _pthread_ref(pt);
       mark = pt;
       break;
@@ -439,7 +441,6 @@ textwindows void __sig_generate(int sig, int sic) {
     if (atomic_load_explicit(&pt->pt_blocker, memory_order_acquire) &&
         !(atomic_load_explicit(&pt->pt_blkmask, memory_order_relaxed) &
           (1ull << (sig - 1)))) {
-      STRACE("generating %G by unblocking %d", sig, _pthread_tid(pt));
       _pthread_ref(pt);
       mark = pt;
       break;
@@ -450,7 +451,6 @@ textwindows void __sig_generate(int sig, int sic) {
     __sig_killer(mark, sig, sic);
     _pthread_unref(mark);
   } else {
-    STRACE("all threads block %G so adding to pending signals of process", sig);
     atomic_fetch_or_explicit(&__sig.pending, 1ull << (sig - 1),
                              memory_order_relaxed);
   }

libc/calls/sig.internal.h

@@ -3,13 +3,8 @@
 #include "libc/calls/struct/sigset.h"
 #include "libc/thread/posixthread.internal.h"
 
-#define __SIG_LOCK_INTERVAL_MS    1000 /* semaphore synchronization: solid */
-#define __SIG_SIG_INTERVAL_MS     1000 /* posix signal polyfill also solid */
-#define __SIG_PROC_INTERVAL_MS    1000 /* process waiting also pretty good */
-#define __SIG_IO_INTERVAL_MS      1000 /* read/write cancel/notify is good */
-#define __SIG_POLL_INTERVAL_MS    20   /* poll on windows is dumpster fire */
-#define __SIG_LOGGING_INTERVAL_MS 1700
-#define __SIG_QUEUE_LENGTH        32
+#define SIG_HANDLED_NO_RESTART 1
+#define SIG_HANDLED_SA_RESTART 2
 
 #if !(__ASSEMBLER__ + __LINKER__ + 0)
 COSMOPOLITAN_C_START_

libc/calls/struct/timespec.h

@@ -41,10 +41,10 @@ int sys_futex(int *, int, int, const struct timespec *, int *);
 static inline struct timespec timespec_fromseconds(int64_t __x) {
   return (struct timespec){__x};
 }
-static inline bool timespec_iszero(struct timespec __ts) {
+static inline int timespec_iszero(struct timespec __ts) {
   return !(__ts.tv_sec | __ts.tv_nsec);
 }
-static inline bool timespec_isvalid(struct timespec __ts) {
+static inline int timespec_isvalid(struct timespec __ts) {
   return __ts.tv_sec >= 0 && __ts.tv_nsec + 0ull < 1000000000ull;
 }
 #endif /* _COSMO_SOURCE */

libc/calls/struct/timeval.h

@@ -39,10 +39,10 @@ static inline struct timeval timeval_fromseconds(int64_t __x) {
 static inline struct timespec timeval_totimespec(struct timeval __tv) {
   return (struct timespec){__tv.tv_sec, __tv.tv_usec * 1000};
 }
-static inline bool timeval_iszero(struct timeval __tv) {
+static inline int timeval_iszero(struct timeval __tv) {
   return !(__tv.tv_sec | __tv.tv_usec);
 }
-static inline bool timeval_isvalid(struct timeval __tv) {
+static inline int timeval_isvalid(struct timeval __tv) {
   return __tv.tv_sec >= 0 && __tv.tv_usec + 0ull < 1000000ull;
 }
 #endif /* _COSMO_SOURCE */

libc/calls/ucontext.c

@@ -17,17 +17,14 @@
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/calls/ucontext.h"
-#include "libc/calls/struct/sigset.h"
-#include "libc/runtime/runtime.h"
+#include "libc/calls/struct/sigset.internal.h"
+#include "libc/dce.h"
+#include "libc/intrin/atomic.h"
 #include "libc/sysv/consts/sig.h"
+#include "libc/thread/tls.h"
 
 int __tailcontext(const ucontext_t *);
 
-static int __contextmask(const sigset_t *opt_set, sigset_t *opt_out_oldset) {
-  // now context switching needs to go 14x slower
-  return sigprocmask(SIG_SETMASK, opt_set, opt_out_oldset);
-}
-
 /**
  * Sets machine context.
  *
@@ -37,14 +34,31 @@ static int __contextmask(const sigset_t *opt_set, sigset_t *opt_out_oldset) {
  * @see getcontext()
  */
 int setcontext(const ucontext_t *uc) {
-  if (__contextmask(&uc->uc_sigmask, 0)) return -1;
+  if (IsWindows()) {
+    atomic_store_explicit(&__get_tls()->tib_sigmask, uc->uc_sigmask,
+                          memory_order_release);
+  } else {
+    sys_sigprocmask(SIG_SETMASK, &uc->uc_sigmask, 0);
+  }
   return __tailcontext(uc);
 }
 
 int __getcontextsig(ucontext_t *uc) {
-  return __contextmask(0, &uc->uc_sigmask);
+  if (IsWindows()) {
+    uc->uc_sigmask =
+        atomic_load_explicit(&__get_tls()->tib_sigmask, memory_order_acquire);
+    return 0;
+  } else {
+    return sys_sigprocmask(SIG_SETMASK, 0, &uc->uc_sigmask);
+  }
 }
 
 int __swapcontextsig(ucontext_t *x, const ucontext_t *y) {
-  return __contextmask(&y->uc_sigmask, &x->uc_sigmask);
+  if (IsWindows()) {
+    x->uc_sigmask = atomic_exchange_explicit(
+        &__get_tls()->tib_sigmask, y->uc_sigmask, memory_order_acquire);
+    return 0;
+  } else {
+    return sys_sigprocmask(SIG_SETMASK, &y->uc_sigmask, &x->uc_sigmask);
+  }
 }