Fix some issues

libc/thread/pthread_cancel.c

@@ -46,7 +46,9 @@ extern const char systemfive_cancellable[];
 extern const char systemfive_cancellable_end[];
 
 long _pthread_cancel_ack(void) {
-  struct PosixThread *pt = _pthread_self();
+  struct PosixThread *pt;
+  STRACE("_pthread_cancel_ack()");
+  pt = _pthread_self();
   if (!(pt->pt_flags & (PT_NOCANCEL | PT_MASKED)) ||
       (pt->pt_flags & PT_ASYNC)) {
     pthread_exit(PTHREAD_CANCELED);
@@ -58,6 +60,7 @@ long _pthread_cancel_ack(void) {
   return ecanceled();
 }
 
+// the purpose of this routine is to force a blocking system call to end
 static void _pthread_cancel_sig(int sig, siginfo_t *si, void *arg) {
   ucontext_t *ctx = arg;
 
@@ -231,6 +234,7 @@ static errno_t _pthread_cancel_everyone(void) {
  * - `nsync_cv_wait`
  * - `opendir`
  * - `openatemp`, 'mkstemp', etc.
+ * - `sleep`, `usleep`, `nanosleep`, `timespec_sleep`, etc.
  * - `pclose`
  * - `popen`
  * - `fwrite`, `printf`, `fprintf`, `putc`, etc.
@@ -344,15 +348,12 @@ static errno_t _pthread_cancel_everyone(void) {
  * @raise ESRCH if system thread wasn't alive or we lost a race
  */
 errno_t pthread_cancel(pthread_t thread) {
-  errno_t err;
   struct PosixThread *arg;
   if ((arg = (struct PosixThread *)thread)) {
-    err = _pthread_cancel_single(arg);
+    return _pthread_cancel_single(arg);
   } else {
-    err = _pthread_cancel_everyone();
+    return _pthread_cancel_everyone();
   }
-  STRACE("pthread_cancel(%d) → %s", _pthread_tid(arg), DescribeErrno(err));
-  return err;
 }
 
 /**

libc/thread/sem_open.c

@@ -20,6 +20,7 @@
 #include "libc/calls/blockcancel.internal.h"
 #include "libc/calls/calls.h"
 #include "libc/calls/struct/stat.h"
+#include "libc/calls/syscall-sysv.internal.h"
 #include "libc/dce.h"
 #include "libc/errno.h"
 #include "libc/intrin/atomic.h"
@@ -27,6 +28,7 @@
 #include "libc/limits.h"
 #include "libc/mem/mem.h"
 #include "libc/runtime/runtime.h"
+#include "libc/runtime/syslib.internal.h"
 #include "libc/str/str.h"
 #include "libc/sysv/consts/at.h"
 #include "libc/sysv/consts/map.h"
@@ -173,15 +175,32 @@ sem_t *sem_open(const char *name, int oflag, ...) {
   struct Semaphore *s;
   char pathbuf[PATH_MAX];
   unsigned mode = 0, value = 0;
+
+  va_start(va, oflag);
+  mode = va_arg(va, unsigned);
+  value = va_arg(va, unsigned);
+  va_end(va);
+
+#if 0
+  if (IsXnuSilicon()) {
+    long kernel;
+    if (!(sem = calloc(1, sizeof(sem_t)))) return SEM_FAILED;
+    sem->sem_magic = SEM_MAGIC_KERNEL;
+    kernel = _sysret(__syslib->__sem_open(name, oflag, mode, value));
+    if (kernel == -1) {
+      free(sem);
+      return SEM_FAILED;
+    }
+    sem->sem_magic = SEM_MAGIC_KERNEL;
+    sem->sem_kernel = (int *)kernel;
+  }
+#endif
+
   if (oflag & ~(O_CREAT | O_EXCL)) {
     einval();
     return SEM_FAILED;
   }
   if (oflag & O_CREAT) {
-    va_start(va, oflag);
-    mode = va_arg(va, unsigned);
-    value = va_arg(va, unsigned);
-    va_end(va);
     if (value > SEM_VALUE_MAX) {
       einval();
       return SEM_FAILED;
@@ -250,6 +269,14 @@ int sem_close(sem_t *sem) {
   int prefs;
   bool unmap, delete;
   struct Semaphore *s, **p;
+
+#if 0
+  if (IsXnuSilicon()) {
+    npassert(sem->sem_magic == SEM_MAGIC_KERNEL);
+    return _sysret(__syslib->__sem_close(sem->sem_kernel));
+  }
+#endif
+
   npassert(sem->sem_magic == SEM_MAGIC_NAMED);
   sem_open_init();
   sem_open_lock();
@@ -298,6 +325,13 @@ int sem_unlink(const char *name) {
   int rc, e = errno;
   struct Semaphore *s;
   char pathbuf[PATH_MAX];
+
+#if 0
+  if (IsXnuSilicon()) {
+    return _sysret(__syslib->__sem_unlink(name));
+  }
+#endif
+
   if (!(path = sem_path_np(name, pathbuf, sizeof(pathbuf)))) return -1;
   if ((rc = unlink(path)) == -1 && IsWindows() && errno == EACCES) {
     sem_open_init();

libc/thread/sem_post.c

@@ -18,9 +18,12 @@
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/assert.h"
 #include "libc/calls/calls.h"
+#include "libc/calls/syscall-sysv.internal.h"
+#include "libc/dce.h"
 #include "libc/errno.h"
 #include "libc/intrin/atomic.h"
 #include "libc/limits.h"
+#include "libc/runtime/syslib.internal.h"
 #include "libc/sysv/errfuns.h"
 #include "libc/thread/semaphore.h"
 #include "third_party/nsync/futex.internal.h"
@@ -33,6 +36,13 @@
  */
 int sem_post(sem_t *sem) {
   int rc, old, wakeups;
+
+#if 0
+  if (IsXnuSilicon() && sem->sem_magic == SEM_MAGIC_KERNEL) {
+    return _sysret(__syslib->__sem_post(sem->sem_kernel));
+  }
+#endif
+
   old = atomic_fetch_add_explicit(&sem->sem_value, 1, memory_order_acq_rel);
   unassert(old > INT_MIN);
   if (old >= 0) {

libc/thread/sem_timedwait.c

@@ -17,12 +17,17 @@
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/assert.h"
+#include "libc/calls/calls.h"
 #include "libc/calls/cp.internal.h"
 #include "libc/calls/struct/timespec.h"
 #include "libc/calls/struct/timespec.internal.h"
+#include "libc/calls/syscall-sysv.internal.h"
+#include "libc/dce.h"
 #include "libc/errno.h"
 #include "libc/intrin/atomic.h"
+#include "libc/intrin/weaken.h"
 #include "libc/limits.h"
+#include "libc/runtime/syslib.internal.h"
 #include "libc/sysv/errfuns.h"
 #include "libc/thread/semaphore.h"
 #include "libc/thread/thread.h"
@@ -52,9 +57,48 @@ static void sem_timedwait_cleanup(void *arg) {
  * @cancelationpoint
  */
 int sem_timedwait(sem_t *sem, const struct timespec *abstime) {
-  int e, i, v, rc;
+  int i, v, rc, e = errno;
+
+#if 0
+  if (IsXnuSilicon() && sem->sem_magic == SEM_MAGIC_KERNEL) {
+    if (!abstime) {
+      if (_weaken(pthread_testcancel_np) &&  //
+          _weaken(pthread_testcancel_np)()) {
+        return ecanceled();
+      }
+      rc = _sysret(__syslib->__sem_wait(sem->sem_kernel));
+      if (rc == -1 && errno == EINTR &&      //
+          _weaken(pthread_testcancel_np) &&  //
+          _weaken(pthread_testcancel_np)()) {
+        return ecanceled();
+      }
+      return rc;
+    }
+    for (;;) {
+      if (_weaken(pthread_testcancel_np) &&  //
+          _weaken(pthread_testcancel_np)()) {
+        return ecanceled();
+      }
+      rc = _sysret(__syslib->__sem_trywait(sem->sem_kernel));
+      if (!rc) return 0;
+      if (errno == EINTR &&                  //
+          _weaken(pthread_testcancel_np) &&  //
+          _weaken(pthread_testcancel_np)()) {
+        return ecanceled();
+      }
+      if (errno != EAGAIN) return -1;
+      errno = e;
+      struct timespec now = timespec_real();
+      if (timespec_cmp(*abstime, now) >= 0) {
+        return etimedout();
+      }
+      if (usleep(10 * 1000) == -1) {
+        return -1;
+      }
+    }
+  }
+#endif
 
-  e = errno;
   for (i = 0; i < 7; ++i) {
     rc = sem_trywait(sem);
     if (!rc) {

libc/thread/sem_trywait.c

@@ -18,9 +18,12 @@
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/assert.h"
 #include "libc/calls/calls.h"
+#include "libc/calls/syscall-sysv.internal.h"
+#include "libc/dce.h"
 #include "libc/errno.h"
 #include "libc/intrin/atomic.h"
 #include "libc/limits.h"
+#include "libc/runtime/syslib.internal.h"
 #include "libc/sysv/errfuns.h"
 #include "libc/thread/semaphore.h"
 
@@ -34,6 +37,13 @@
  */
 int sem_trywait(sem_t *sem) {
   int v;
+
+#if 0
+  if (IsXnuSilicon() && sem->sem_magic == SEM_MAGIC_KERNEL) {
+    return _sysret(__syslib->__sem_trywait(sem->sem_kernel));
+  }
+#endif
+
   v = atomic_load_explicit(&sem->sem_value, memory_order_relaxed);
   do {
     unassert(v > INT_MIN);

libc/thread/semaphore.h

@@ -8,6 +8,7 @@ COSMOPOLITAN_C_START_
 #define SEM_FAILED        ((sem_t *)0)
 #define SEM_MAGIC_NAMED   0xDEADBEEFu
 #define SEM_MAGIC_UNNAMED 0xFEEDABEEu
+#define SEM_MAGIC_KERNEL  0xCAFEBABEu
 
 typedef struct {
   union {
@@ -21,6 +22,7 @@ typedef struct {
       int sem_pid;         /* unnamed only */
       bool sem_lazydelete; /* named only */
       bool sem_pshared;
+      int *sem_kernel;
     };
     void *sem_space[32];
   };