Release Cosmopolitan v2.2

- Clean up sigaction() code
- Add a port scanner example
- Introduce a ParseCidr() API
- Clean up our futex abstraction code
- Fix a harmless integer overflow in ParseIp()
- Use kernel semaphores on NetBSD to make threads much faster

Makefile

@@ -61,7 +61,7 @@
 
 SHELL      = build/bootstrap/cocmd.com
 HOSTS     ?= freebsd openbsd netbsd rhel7 rhel5 xnu win10 win10:31336
-MAKEFLAGS += -j --no-builtin-rules
+MAKEFLAGS += --no-builtin-rules
 
 .SUFFIXES:
 .DELETE_ON_ERROR:

README.md

@@ -23,8 +23,8 @@ If you're doing your development work on Linux or BSD then you need just
 five files to get started. Here's what you do on Linux:
 
 ```sh
-wget https://justine.lol/cosmopolitan/cosmopolitan-amalgamation-2.1.1.zip
-unzip cosmopolitan-amalgamation-2.1.1.zip
+wget https://justine.lol/cosmopolitan/cosmopolitan-amalgamation-2.2.zip
+unzip cosmopolitan-amalgamation-2.2.zip
 printf 'main() { printf("hello world\\n"); }\n' >hello.c
 gcc -g -Os -static -nostdlib -nostdinc -fno-pie -no-pie -mno-red-zone \
   -fno-omit-frame-pointer -pg -mnop-mcount -mno-tls-direct-seg-refs -gdwarf-4 \

ape/ape.S

@@ -35,6 +35,7 @@
 #include "ape/macros.internal.h"
 #include "ape/notice.inc"
 #include "ape/relocations.h"
+#include "libc/calls/metalfile.internal.h"
 #include "libc/dce.h"
 #include "libc/elf/def.h"
 #include "libc/macho.internal.h"
@@ -1565,19 +1566,19 @@ kernel:	movabs	$ape_stack_vaddr,%rsp
 #endif
 	push	$_HOSTMETAL			# sets __hostos in crt.S
 	pop	%rcx
-	push	$0
+	pushq	.Lenv0(%rip)			# envp[0][0]
 	mov	%rsp,%rbp
-	mov	.Lenv0(%rip),%rax
-	mov	%rax,(%rbp)			# envp[0][0]
-	push	$0				# argv[0][0]
+	pushq	.Largv0+8(%rip)			# argv[0][8]
+	pushq	.Largv0(%rip)			# argv[0][0]
+	mov	%rsp,%rax
 	push	$0				# auxv[1][1]
 	push	$0				# auxv[1][0]
-	push	%rbp				# auxv[0][1]
+	push	%rax				# auxv[0][1]
 	push	$31				# auxv[0][0] AT_EXECFN
 	push	$0				# envp[1]
-	push	$.Lenv0				# envp[0]
+	push	%rbp				# envp[0]
 	push	$0				# argv[1]
-	push	%rbp				# argv[0]
+	push	%rax				# argv[0]
 	push	$1				# argc
 	xor	%ebp,%ebp
 	xor	%eax,%eax
@@ -1593,6 +1594,9 @@ kernel:	movabs	$ape_stack_vaddr,%rsp
 
 	.rodata
 .Lenv0:	.asciz	"METAL=1"
+.Largv0:
+	.asciz	APE_COM_NAME
+	.org	.Largv0+16
 	.previous
 
 #endif /* SupportsMetal() */

ape/ape.lds

@@ -565,10 +565,10 @@ SHSTUB2(ape_loader_dd_count,
 #if SupportsMetal()
 HIDDEN(v_ape_realsectors =
            MIN(0x70000 - IMAGE_BASE_REAL,
-               ROUNDUP(RVA(_edata), 512)) / 512);
+               ROUNDUP(RVA(_tdata_end), 512)) / 512);
 HIDDEN(v_ape_realpages = v_ape_realsectors / (4096 / 512));
 HIDDEN(v_ape_highsectors =
-           (ROUNDUP(RVA(_edata), 512) / 512) - v_ape_realsectors);
+           (ROUNDUP(RVA(_tdata_end), 512) / 512) - v_ape_realsectors);
 TSSDESCSTUB2(_tss, _tss, _tss_end ? _tss_end - _tss - 1 : 0);
 #endif
 

ape/ape.mk

@@ -107,6 +107,7 @@ o/$(MODE)/ape/ape-no-modify-self.o:		\
 		libc/macho.internal.h		\
 		libc/macros.internal.h		\
 		libc/nexgen32e/uart.internal.h	\
+		libc/calls/metalfile.internal.h	\
 		libc/nexgen32e/vidya.internal.h	\
 		libc/nt/pedef.internal.h	\
 		libc/runtime/e820.internal.h	\
@@ -133,6 +134,7 @@ o/$(MODE)/ape/ape-copy-self.o:			\
 		libc/macho.internal.h		\
 		libc/macros.internal.h		\
 		libc/nexgen32e/uart.internal.h	\
+		libc/calls/metalfile.internal.h	\
 		libc/nexgen32e/vidya.internal.h	\
 		libc/nt/pedef.internal.h	\
 		libc/runtime/e820.internal.h	\

ape/sections.internal.h

@@ -10,6 +10,10 @@ extern unsigned char _edata[];
 extern unsigned char _ezip[];
 extern unsigned char _end[];
 extern unsigned char _ereal[];
+extern unsigned char _tdata_start[];
+extern unsigned char _tdata_end[];
+extern unsigned char _tbss_start[];
+extern unsigned char _tbss_end[];
 extern unsigned char __privileged_start[];
 extern unsigned char __privileged_addr[];
 extern unsigned char __privileged_size[];

examples/clock.c

@@ -20,22 +20,22 @@ int main(int argc, char *argv[]) {
   volatile unsigned long x;
   struct timespec now, start, next, interval;
   printf("hammering the cpu...\n");
-  next = start = _timespec_mono();
-  interval = _timespec_frommillis(500);
-  next = _timespec_add(next, interval);
+  next = start = timespec_mono();
+  interval = timespec_frommillis(500);
+  next = timespec_add(next, interval);
   for (;;) {
     for (i = 0;; ++i) {
       x *= 7;
       if (!(i % 256)) {
-        now = _timespec_mono();
-        if (_timespec_gte(now, next)) {
+        now = timespec_mono();
+        if (timespec_cmp(now, next) >= 0) {
           break;
         }
       }
     }
-    next = _timespec_add(next, interval);
+    next = timespec_add(next, interval);
     printf("consumed %10g seconds monotonic time and %10g seconds cpu time\n",
-           _timespec_tonanos(_timespec_sub(now, start)) / 1000000000.,
+           timespec_tonanos(timespec_sub(now, start)) / 1000000000.,
            (double)clock() / CLOCKS_PER_SEC);
   }
 }

examples/clock_getres.c

@@ -28,7 +28,7 @@ void show(int clock) {
   }
   shown[n++] = clock;
   if (clock_getres(clock, &ts) != -1) {
-    kprintf("%s %'ld ns\n", DescribeClockName(clock), _timespec_tonanos(ts));
+    kprintf("%s %'ld ns\n", DescribeClockName(clock), timespec_tonanos(ts));
   } else {
     kprintf("%s %s\n", DescribeClockName(clock), _strerrno(errno));
   }

examples/portscan.c

@@ -0,0 +1,127 @@
+#if 0
+/*─────────────────────────────────────────────────────────────────╗
+│ To the extent possible under law, Justine Tunney has waived      │
+│ all copyright and related or neighboring rights to this file,    │
+│ as it is written in the following disclaimers:                   │
+│   • http://unlicense.org/                                        │
+│   • http://creativecommons.org/publicdomain/zero/1.0/            │
+╚─────────────────────────────────────────────────────────────────*/
+#endif
+#include "libc/assert.h"
+#include "libc/calls/calls.h"
+#include "libc/calls/struct/timeval.h"
+#include "libc/errno.h"
+#include "libc/fmt/conv.h"
+#include "libc/fmt/fmt.h"
+#include "libc/mem/alloca.h"
+#include "libc/runtime/runtime.h"
+#include "libc/sock/sock.h"
+#include "libc/sock/struct/sockaddr.h"
+#include "libc/stdio/stdio.h"
+#include "libc/str/str.h"
+#include "libc/sysv/consts/af.h"
+#include "libc/sysv/consts/ipproto.h"
+#include "libc/sysv/consts/so.h"
+#include "libc/sysv/consts/sock.h"
+#include "libc/sysv/consts/sol.h"
+#include "net/http/ip.h"
+
+/**
+ * @fileoverview fast local network port scanner, e.g.
+ *
+ *     make -j8 o//examples/portscan.com
+ *     o//examples/portscan.com 10.10.10.0/24 22
+ */
+
+const char *FormatIp(char buf[16], uint32_t ip) {
+  snprintf(buf, 16, "%hhu.%hhu.%hhu.%hhu", ip >> 24, ip >> 16, ip >> 8, ip);
+  return buf;
+}
+
+#define FormatIp(x) FormatIp(alloca(16), x)
+
+int main(int argc, char *argv[]) {
+  int port;
+  struct Cidr in;
+  uint32_t netmask;
+  const char *status;
+  struct timeval timeout;
+  uint32_t network_address;
+  uint32_t last_host_address;
+  uint32_t first_host_address;
+
+  if (argc != 3) {
+  PrintUsage:
+    fprintf(stderr,
+            "usage:   %s IP/CIDR PORT\n"
+            "example: %s 192.168.0.0/24 22\n",
+            argv[0], argv[0]);
+    return 1;
+  }
+
+  in = ParseCidr(argv[1], -1);
+  if (in.addr == -1) {
+    fprintf(stderr, "error: bad ip/cidr\n");
+    goto PrintUsage;
+  }
+
+  port = atoi(argv[2]);
+  if (!(1 <= port && port <= 65535)) {
+    fprintf(stderr, "error: bad port\n");
+    goto PrintUsage;
+  }
+
+  if (in.cidr > 30) {
+    fprintf(stderr, "error: maximum supported cidr is 30\n");
+    goto PrintUsage;
+  }
+
+  if (in.cidr < 22) {
+    fprintf(stderr, "error: minimum cidr support right now is 22\n");
+    goto PrintUsage;
+  }
+
+  netmask = -1u << (32 - in.cidr);
+  network_address = in.addr & netmask;
+  first_host_address = network_address + 1;
+  last_host_address = (network_address | ~netmask) - 1;
+
+  assert(last_host_address > first_host_address);
+  assert(last_host_address - first_host_address < 1024);
+
+  fprintf(stderr, "scanning %s through %s\n", FormatIp(first_host_address),
+          FormatIp(last_host_address));
+
+  timeout = timeval_frommillis(100);
+  for (int64_t ip = first_host_address; ip <= last_host_address; ++ip) {
+    if (!fork()) {
+      socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
+      setsockopt(3, SOL_SOCKET, SO_RCVTIMEO, &timeout, sizeof(timeout));
+      setsockopt(3, SOL_SOCKET, SO_SNDTIMEO, &timeout, sizeof(timeout));
+      if (!connect(3,
+                   (struct sockaddr *)&(struct sockaddr_in){
+                       .sin_family = AF_INET,
+                       .sin_addr.s_addr = htonl(ip),
+                       .sin_port = htons(port),
+                   },
+                   sizeof(struct sockaddr_in))) {
+        status = "open";
+      } else if (errno == ECONNREFUSED) {
+        status = "closed";
+      } else if (errno != EINPROGRESS) {
+        status = _strerrno(errno);
+      } else {
+        status = 0;
+      }
+      if (status) {
+        printf("%-15s %s\n", FormatIp(ip), status);
+      }
+      _Exit(0);
+    }
+  }
+  for (;;) {
+    if (wait(0) == -1 && errno == ECHILD) {
+      break;
+    }
+  }
+}

examples/reboot.c

@@ -0,0 +1,39 @@
+#if 0
+/*─────────────────────────────────────────────────────────────────╗
+│ To the extent possible under law, Justine Tunney has waived      │
+│ all copyright and related or neighboring rights to this file,    │
+│ as it is written in the following disclaimers:                   │
+│   • http://unlicense.org/                                        │
+│   • http://creativecommons.org/publicdomain/zero/1.0/            │
+╚─────────────────────────────────────────────────────────────────*/
+#endif
+#include "libc/calls/calls.h"
+#include "libc/runtime/runtime.h"
+#include "libc/stdio/stdio.h"
+#include "libc/str/str.h"
+#include "libc/sysv/consts/reboot.h"
+
+int main(int argc, char *argv[]) {
+  char line[8] = {0};
+  if (argc > 1 && !strcmp(argv[1], "-y")) {
+    line[0] = 'y';
+  } else {
+    printf("reboot your computer? yes or no [no] ");
+    fflush(stdout);
+    fgets(line, sizeof(line), stdin);
+  }
+  if (line[0] == 'y' || line[0] == 'Y') {
+    if (reboot(RB_AUTOBOOT)) {
+      printf("system is rebooting...\n");
+      exit(0);
+    } else {
+      perror("reboot");
+      exit(1);
+    }
+  } else if (line[0] == 'n' || line[0] == 'N') {
+    exit(0);
+  } else {
+    printf("error: unrecognized response\n");
+    exit(2);
+  }
+}

examples/shutdown.c

@@ -0,0 +1,39 @@
+#if 0
+/*─────────────────────────────────────────────────────────────────╗
+│ To the extent possible under law, Justine Tunney has waived      │
+│ all copyright and related or neighboring rights to this file,    │
+│ as it is written in the following disclaimers:                   │
+│   • http://unlicense.org/                                        │
+│   • http://creativecommons.org/publicdomain/zero/1.0/            │
+╚─────────────────────────────────────────────────────────────────*/
+#endif
+#include "libc/calls/calls.h"
+#include "libc/runtime/runtime.h"
+#include "libc/stdio/stdio.h"
+#include "libc/str/str.h"
+#include "libc/sysv/consts/reboot.h"
+
+int main(int argc, char *argv[]) {
+  char line[8] = {0};
+  if (argc > 1 && !strcmp(argv[1], "-y")) {
+    line[0] = 'y';
+  } else {
+    printf("shutdown your computer? yes or no [no] ");
+    fflush(stdout);
+    fgets(line, sizeof(line), stdin);
+  }
+  if (line[0] == 'y' || line[0] == 'Y') {
+    if (reboot(RB_POWER_OFF)) {
+      printf("system is shutting down...\n");
+      exit(0);
+    } else {
+      perror("reboot");
+      exit(1);
+    }
+  } else if (line[0] == 'n' || line[0] == 'N') {
+    exit(0);
+  } else {
+    printf("error: unrecognized response\n");
+    exit(2);
+  }
+}

libc/assert.h

@@ -36,7 +36,7 @@ void __assert_fail(const char *, const char *, int) hidden relegated;
  * In `MODE=tiny` these assertions are redefined as undefined behavior.
  */
 #define _npassert(x)                 \
-  __extension__({                    \
+  ({                                 \
     if (__builtin_expect(!(x), 0)) { \
       notpossible;                   \
     }                                \
@@ -63,7 +63,7 @@ void __assert_fail(const char *, const char *, int) hidden relegated;
  * that's capable of debugging this macro.
  */
 #define _unassert(x)                 \
-  __extension__({                    \
+  ({                                 \
     if (__builtin_expect(!(x), 0)) { \
       unreachable;                   \
     }                                \

libc/calls/__sig2.c

@@ -204,6 +204,7 @@ textwindows int __sig_raise(int sig, int si_code) {
   if (1 <= sig && sig <= 64) {
     if (!__sig_is_masked(sig)) {
       ++__sig_count;
+      // TODO(jart): ucontext_t support
       __sig_handle(false, sig, si_code, 0);
       return 0;
     } else {

libc/calls/_timespec_gte.c

@@ -1,28 +0,0 @@
-/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│
-│vi: set net ft=c ts=2 sts=2 sw=2 fenc=utf-8                                :vi│
-╞══════════════════════════════════════════════════════════════════════════════╡
-│ Copyright 2022 Justine Alexandra Roberts Tunney                              │
-│                                                                              │
-│ Permission to use, copy, modify, and/or distribute this software for         │
-│ any purpose with or without fee is hereby granted, provided that the         │
-│ above copyright notice and this permission notice appear in all copies.      │
-│                                                                              │
-│ THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL                │
-│ WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED                │
-│ WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE             │
-│ AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL         │
-│ DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR        │
-│ PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER               │
-│ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
-│ PERFORMANCE OF THIS SOFTWARE.                                                │
-╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/calls/struct/timespec.h"
-
-/**
- * Checks if 𝑥 ≥ 𝑦.
- */
-bool _timespec_gte(struct timespec x, struct timespec y) {
-  if (x.tv_sec > y.tv_sec) return true;
-  if (x.tv_sec < y.tv_sec) return false;
-  return x.tv_nsec >= y.tv_nsec;
-}

libc/calls/blockcancel.internal.h

@@ -0,0 +1,22 @@
+#ifndef COSMOPOLITAN_LIBC_CALLS_BLOCKCANCEL_H_
+#define COSMOPOLITAN_LIBC_CALLS_BLOCKCANCEL_H_
+#include "libc/thread/thread.h"
+#if !(__ASSEMBLER__ + __LINKER__ + 0)
+COSMOPOLITAN_C_START_
+
+#define BLOCK_CANCELLATIONS \
+  do {                      \
+    int _CancelState;       \
+  _CancelState = _pthread_block_cancellations()
+
+#define ALLOW_CANCELLATIONS                   \
+  _pthread_allow_cancellations(_CancelState); \
+  }                                           \
+  while (0)
+
+int _pthread_block_cancellations(void);
+void _pthread_allow_cancellations(int);
+
+COSMOPOLITAN_C_END_
+#endif /* !(__ASSEMBLER__ + __LINKER__ + 0) */
+#endif /* COSMOPOLITAN_LIBC_CALLS_BLOCKCANCEL_H_ */

libc/calls/blocksigs.internal.h

@@ -1,5 +1,5 @@
-#ifndef COSMOPOLITAN_LIBC_CALLS_BLOCKSIGS_INTERNAL_H_
-#define COSMOPOLITAN_LIBC_CALLS_BLOCKSIGS_INTERNAL_H_
+#ifndef COSMOPOLITAN_LIBC_CALLS_BLOCKSIGS_H_
+#define COSMOPOLITAN_LIBC_CALLS_BLOCKSIGS_H_
 #include "libc/calls/struct/sigset.h"
 #if !(__ASSEMBLER__ + __LINKER__ + 0)
 COSMOPOLITAN_C_START_
@@ -16,4 +16,4 @@ COSMOPOLITAN_C_START_
 
 COSMOPOLITAN_C_END_
 #endif /* !(__ASSEMBLER__ + __LINKER__ + 0) */
-#endif /* COSMOPOLITAN_LIBC_CALLS_BLOCKSIGS_INTERNAL_H_ */
+#endif /* COSMOPOLITAN_LIBC_CALLS_BLOCKSIGS_H_ */

libc/calls/calls.mk

@@ -179,12 +179,15 @@ o//libc/calls/statfs2cosmo.o: private			\
 # we always want -O2 because:
 #   division is expensive if not optimized
 o/$(MODE)/libc/calls/clock.o				\
-o/$(MODE)/libc/calls/_timespec_tomillis.o		\
-o/$(MODE)/libc/calls/_timespec_tomicros.o		\
-o/$(MODE)/libc/calls/_timespec_totimeval.o		\
-o/$(MODE)/libc/calls/_timespec_fromnanos.o		\
-o/$(MODE)/libc/calls/_timespec_frommillis.o		\
-o/$(MODE)/libc/calls/_timespec_frommicros.o: private	\
+o/$(MODE)/libc/calls/timespec_tomillis.o		\
+o/$(MODE)/libc/calls/timespec_tomicros.o		\
+o/$(MODE)/libc/calls/timespec_totimeval.o		\
+o/$(MODE)/libc/calls/timespec_fromnanos.o		\
+o/$(MODE)/libc/calls/timespec_frommillis.o		\
+o/$(MODE)/libc/calls/timespec_frommicros.o		\
+o/$(MODE)/libc/calls/timeval_tomillis.o			\
+o/$(MODE)/libc/calls/timeval_frommillis.o		\
+o/$(MODE)/libc/calls/timeval_frommicros.o: private	\
 		OVERRIDE_CFLAGS +=			\
 			-O2
 

libc/calls/clock.c

@@ -55,7 +55,7 @@ int64_t clock(void) {
   if (clock_gettime(CLOCK_PROCESS_CPUTIME_ID, &ts) == -1) {
     errno = e;
     if (getrusage(RUSAGE_SELF, &ru) != -1) {
-      ts = _timeval_totimespec(_timeval_add(ru.ru_utime, ru.ru_stime));
+      ts = timeval_totimespec(timeval_add(ru.ru_utime, ru.ru_stime));
     } else {
       return -1;
     }

libc/calls/clock_gettime-mono.c

@@ -17,11 +17,11 @@
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/calls/struct/timespec.h"
-#include "libc/thread/thread.h"
 #include "libc/nexgen32e/rdtsc.h"
 #include "libc/nexgen32e/x86feature.h"
 #include "libc/sysv/consts/clock.h"
 #include "libc/sysv/errfuns.h"
+#include "libc/thread/thread.h"
 
 static struct {
   pthread_once_t once;
@@ -30,7 +30,7 @@ static struct {
 } g_mono;
 
 static void sys_clock_gettime_mono_init(void) {
-  g_mono.base_wall = _timespec_real();
+  g_mono.base_wall = timespec_real();
   g_mono.base_tick = rdtsc();
 }
 
@@ -42,7 +42,7 @@ int sys_clock_gettime_mono(struct timespec *time) {
     pthread_once(&g_mono.once, sys_clock_gettime_mono_init);
     cycles = rdtsc() - g_mono.base_tick;
     nanos = cycles / 3;
-    *time = _timespec_add(g_mono.base_wall, _timespec_fromnanos(nanos));
+    *time = timespec_add(g_mono.base_wall, timespec_fromnanos(nanos));
     return 0;
   } else {
     return einval();

libc/calls/clock_nanosleep-nt.c

@@ -33,24 +33,24 @@ textwindows int sys_clock_nanosleep_nt(int clock, int flags,
     abs = *req;
     for (;;) {
       if (sys_clock_gettime_nt(clock, &now)) return -1;
-      if (_timespec_gte(now, abs)) return 0;
-      if (_check_interrupts(false, g_fds.p)) return eintr();
+      if (timespec_cmp(now, abs) >= 0) return 0;
+      if (_check_interrupts(false, g_fds.p)) return -1;
       SleepEx(MIN(__SIG_POLLING_INTERVAL_MS,
-                  _timespec_tomillis(_timespec_sub(abs, now))),
+                  timespec_tomillis(timespec_sub(abs, now))),
               false);
     }
   } else {
     if (sys_clock_gettime_nt(clock, &now)) return -1;
-    abs = _timespec_add(now, *req);
+    abs = timespec_add(now, *req);
     for (;;) {
       sys_clock_gettime_nt(clock, &now);
-      if (_timespec_gte(now, abs)) return 0;
+      if (timespec_cmp(now, abs) >= 0) return 0;
       if (_check_interrupts(false, g_fds.p)) {
-        if (rem) *rem = _timespec_sub(abs, now);
-        return eintr();
+        if (rem) *rem = timespec_sub(abs, now);
+        return -1;
       }
       SleepEx(MIN(__SIG_POLLING_INTERVAL_MS,
-                  _timespec_tomillis(_timespec_sub(abs, now))),
+                  timespec_tomillis(timespec_sub(abs, now))),
               false);
     }
   }

libc/calls/clock_nanosleep-openbsd.c

@@ -31,8 +31,8 @@ int sys_clock_nanosleep_openbsd(int clock, int flags,
       res = sys_nanosleep(req, rem);
     } else {
       sys_clock_gettime(clock, &now);
-      if (_timespec_gt(*req, now)) {
-        rel = _timespec_sub(*req, now);
+      if (timespec_cmp(*req, now) > 0) {
+        rel = timespec_sub(*req, now);
         res = sys_nanosleep(&rel, 0);
       } else {
         res = 0;

libc/calls/clock_nanosleep-xnu.c

@@ -31,10 +31,10 @@ int sys_clock_nanosleep_xnu(int clock, int flags, const struct timespec *req,
   struct timeval now, abs, rel;
   if (clock == CLOCK_REALTIME) {
     if (flags & TIMER_ABSTIME) {
-      abs = _timespec_totimeval(*req);
+      abs = timespec_totimeval(*req);
       sys_gettimeofday_xnu(&now, 0, 0);
-      if (_timeval_gt(abs, now)) {
-        rel = _timeval_sub(abs, now);
+      if (timeval_cmp(abs, now) > 0) {
+        rel = timeval_sub(abs, now);
         res = sys_select(0, 0, 0, 0, &rel);
       } else {
         res = 0;

libc/calls/clock_nanosleep.c

@@ -17,6 +17,7 @@
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/calls/asan.internal.h"
+#include "libc/calls/cp.internal.h"
 #include "libc/calls/state.internal.h"
 #include "libc/calls/struct/timespec.h"
 #include "libc/calls/struct/timespec.internal.h"
@@ -55,8 +56,8 @@
  *
  *     struct timespec rel, now, abs;
  *     clock_gettime(CLOCK_REALTIME, &now);
- *     rel = _timespec_frommillis(100);
- *     abs = _timespec_add(now, rel);
+ *     rel = timespec_frommillis(100);
+ *     abs = timespec_add(now, rel);
  *     while (clock_nanosleep(CLOCK_REALTIME, TIMER_ABSTIME, &abs, 0));
  *
  * will accurately spin on `EINTR` errors. That way you're not impeding
@@ -74,18 +75,21 @@
  *     if flags is `TIMER_ABSTIME` then `rem` is ignored
  * @return 0 on success, or errno on error
  * @raise EINTR when a signal got delivered while we were waiting
+ * @raise ECANCELED if thread was cancelled in masked mode
  * @raise ENOTSUP if `clock` is known but we can't use it here
  * @raise EFAULT if `req` or null or bad memory was passed
  * @raise EINVAL if `clock` is unknown to current platform
  * @raise EINVAL if `flags` has an unrecognized value
  * @raise EINVAL if `req->tv_nsec ∉ [0,1000000000)`
  * @raise ENOSYS on bare metal
+ * @cancellationpoint
  * @returnserrno
  * @norestart
  */
 errno_t clock_nanosleep(int clock, int flags, const struct timespec *req,
                         struct timespec *rem) {
   int rc, e = errno;
+  BEGIN_CANCELLATION_POINT;
 
   if (!req || (IsAsan() && (!__asan_is_valid_timespec(req) ||
                             (rem && !__asan_is_valid_timespec(rem))))) {
@@ -112,6 +116,8 @@ errno_t clock_nanosleep(int clock, int flags, const struct timespec *req,
     errno = e;
   }
 
+  END_CANCELLATION_POINT;
+
 #if SYSDEBUG
   if (__tls_enabled && !(__get_tls()->tib_flags & TIB_FLAG_TIME_CRITICAL)) {
     STRACE("clock_nanosleep(%s, %s, %s, [%s]) → %s", DescribeClockName(clock),

libc/calls/closefrom.c

@@ -37,6 +37,7 @@
  * @raise EBADF on OpenBSD if `first` is greater than highest fd
  * @raise EINVAL if flags are bad or first is greater than last
  * @raise EMFILE if a weird race condition happens on Linux
+ * @raise ECANCELED if thread was cancelled in masked mode
  * @raise EINTR possibly on OpenBSD
  * @raise ENOMEM on Linux maybe
  */

libc/calls/copy_file_range.c

@@ -16,7 +16,9 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
+#include "libc/calls/blockcancel.internal.h"
 #include "libc/calls/calls.h"
+#include "libc/calls/cp.internal.h"
 #include "libc/calls/internal.h"
 #include "libc/calls/struct/sigset.h"
 #include "libc/calls/struct/sigset.internal.h"
@@ -39,6 +41,7 @@ static bool HasCopyFileRange(void) {
   bool ok;
   int e, rc;
   e = errno;
+  BLOCK_CANCELLATIONS;
   if (IsLinux()) {
     // We modernize our detection by a few years for simplicity.
     // This system call is chosen since it's listed by pledge().
@@ -49,6 +52,7 @@ static bool HasCopyFileRange(void) {
   } else {
     ok = false;
   }
+  ALLOW_CANCELLATIONS;
   errno = e;
   return ok;
 }
@@ -81,6 +85,7 @@ static void copy_file_range_init(void) {
  * @raise EBADF if `infd` or `outfd` aren't open files or append-only
  * @raise EPERM if `fdout` refers to an immutable file on Linux
  * @raise ENOTSUP if `infd` or `outfd` is a zip file descriptor
+ * @raise ECANCELED if thread was cancelled in masked mode
  * @raise EINVAL if ranges overlap or `flags` is non-zero
  * @raise EFBIG if `setrlimit(RLIMIT_FSIZE)` is exceeded
  * @raise EFAULT if one of the pointers memory is bad
@@ -93,12 +98,15 @@ static void copy_file_range_init(void) {
  * @raise EIO if a low-level i/o error happens
  * @see sendfile() for seekable → socket
  * @see splice() for fd ↔ pipe
+ * @cancellationpoint
  */
 ssize_t copy_file_range(int infd, int64_t *opt_in_out_inoffset, int outfd,
                         int64_t *opt_in_out_outoffset, size_t uptobytes,
                         uint32_t flags) {
   ssize_t rc;
   pthread_once(&g_copy_file_range.once, copy_file_range_init);
+  BEGIN_CANCELLATION_POINT;
+
   if (!g_copy_file_range.ok) {
     rc = enosys();
   } else if (IsAsan() && ((opt_in_out_inoffset &&
@@ -112,6 +120,8 @@ ssize_t copy_file_range(int infd, int64_t *opt_in_out_inoffset, int outfd,
     rc = sys_copy_file_range(infd, opt_in_out_inoffset, outfd,
                              opt_in_out_outoffset, uptobytes, flags);
   }
+
+  END_CANCELLATION_POINT;
   STRACE("copy_file_range(%d, %s, %d, %s, %'zu, %#x) → %'ld% m", infd,
          DescribeInOutInt64(rc, opt_in_out_inoffset), outfd,
          DescribeInOutInt64(rc, opt_in_out_outoffset), uptobytes, flags);

libc/calls/cp.c

@@ -16,32 +16,44 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/errno.h"
+#include "libc/calls/blockcancel.internal.h"
+#include "libc/calls/cp.internal.h"
+#include "libc/runtime/internal.h"
+#include "libc/runtime/runtime.h"
 #include "libc/thread/posixthread.internal.h"
-#include "libc/thread/thread.h"
 #include "libc/thread/tls.h"
+#ifdef MODE_DBG
 
-/**
- * Sets cancelability state.
- *
- * @param state may be one of:
- *     - `PTHREAD_CANCEL_ENABLE` (default)
- *     - `PTHREAD_CANCEL_DISABLE`
- * @param oldstate optionally receives old value
- * @return 0 on success, or errno on error
- * @raise EINVAL if `state` has bad value
- * @see pthread_cancel() for docs
- */
-int pthread_setcancelstate(int state, int *oldstate) {
+int begin_cancellation_point(void) {
+  int state = 0;
+  struct CosmoTib *tib;
   struct PosixThread *pt;
-  switch (state) {
-    case PTHREAD_CANCEL_ENABLE:
-    case PTHREAD_CANCEL_DISABLE:
-      pt = (struct PosixThread *)__get_tls()->tib_pthread;
-      if (oldstate) *oldstate = pt->canceldisable;
-      pt->canceldisable = state;
-      return 0;
-    default:
-      return EINVAL;
+  if (__enable_tls) {
+    tib = __get_tls();
+    if ((pt = (struct PosixThread *)tib->tib_pthread)) {
+      state = pt->flags & PT_INCANCEL;
+      pt->flags |= PT_INCANCEL;
+    }
+  }
+  return state;
+}
+
+void end_cancellation_point(int state) {
+  struct CosmoTib *tib;
+  struct PosixThread *pt;
+  if (__enable_tls) {
+    tib = __get_tls();
+    if ((pt = (struct PosixThread *)tib->tib_pthread)) {
+      pt->flags &= ~PT_INCANCEL;
+      pt->flags |= state;
+    }
   }
 }
+
+void report_cancellation_point(void) {
+  BLOCK_CANCELLATIONS;
+  _bt("error: need BEGIN/END_CANCELLATION_POINT\n");
+  ALLOW_CANCELLATIONS;
+}
+
+#endif /* MODE_DBG */

libc/calls/cp.internal.h

@@ -0,0 +1,25 @@
+#ifndef COSMOPOLITAN_LIBC_CALLS_CP_INTERNAL_H_
+#define COSMOPOLITAN_LIBC_CALLS_CP_INTERNAL_H_
+#if !(__ASSEMBLER__ + __LINKER__ + 0)
+COSMOPOLITAN_C_START_
+
+int begin_cancellation_point(void);
+void end_cancellation_point(int);
+
+#ifndef MODE_DBG
+#define BEGIN_CANCELLATION_POINT (void)0
+#define END_CANCELLATION_POINT   (void)0
+#else
+#define BEGIN_CANCELLATION_POINT \
+  do {                           \
+    int _Cp;                     \
+  _Cp = begin_cancellation_point()
+#define END_CANCELLATION_POINT \
+  end_cancellation_point(_Cp); \
+  }                            \
+  while (0)
+#endif
+
+COSMOPOLITAN_C_END_
+#endif /* !(__ASSEMBLER__ + __LINKER__ + 0) */
+#endif /* COSMOPOLITAN_LIBC_CALLS_CP_INTERNAL_H_ */

libc/calls/creat.c

@@ -31,6 +31,7 @@
  * @param mode is octal bits, e.g. 0644 usually
  * @return file descriptor, or -1 w/ errno
  * @see openat() for further documentation
+ * @cancellationpoint
  * @asyncsignalsafe
  * @restartable
  * @threadsafe

libc/calls/dup-nt.c

@@ -31,13 +31,11 @@
 // Implements dup(), dup2(), dup3(), and F_DUPFD for Windows.
 textwindows int sys_dup_nt(int oldfd, int newfd, int flags, int start) {
   int64_t rc, proc, handle;
-  _unassert(oldfd >= 0);
-  _unassert(newfd >= -1);
   _unassert(!(flags & ~O_CLOEXEC));
 
   __fds_lock();
 
-  if (oldfd >= g_fds.n ||
+  if (!__isfdopen(oldfd) || newfd < -1 ||
       (g_fds.p[oldfd].kind != kFdFile && g_fds.p[oldfd].kind != kFdSocket &&
        g_fds.p[oldfd].kind != kFdConsole)) {
     __fds_unlock();

libc/calls/execve-sysv.c

@@ -16,6 +16,7 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
+#include "libc/calls/blockcancel.internal.h"
 #include "libc/calls/blocksigs.internal.h"
 #include "libc/calls/calls.h"
 #include "libc/calls/syscall-sysv.internal.h"
@@ -40,6 +41,8 @@ static bool IsApeBinary(const char *path) {
   int fd;
   char buf[8];
   bool res = false;
+  // TODO(jart): Should we block signals too?
+  BLOCK_CANCELLATIONS;
   if ((fd = sys_open(path, O_RDONLY, 0)) != -1) {
     if (sys_read(fd, buf, 8) == 8 &&  //
         (READ64LE(buf) == READ64LE("MZqFpD='") ||
@@ -48,6 +51,7 @@ static bool IsApeBinary(const char *path) {
     }
     sys_close(fd);
   }
+  ALLOW_CANCELLATIONS;
   return res;
 }
 

libc/calls/fcntl-sysv.c

@@ -26,7 +26,7 @@
 #include "libc/sysv/consts/o.h"
 #include "libc/sysv/errfuns.h"
 
-int sys_fcntl(int fd, int cmd, uintptr_t arg) {
+int sys_fcntl(int fd, int cmd, uintptr_t arg, int impl(int, int, ...)) {
   int e, rc;
   bool islock;
   if ((islock = cmd == F_GETLK ||  //
@@ -40,12 +40,12 @@ int sys_fcntl(int fd, int cmd, uintptr_t arg) {
     cosmo2flock(arg);
   }
   e = errno;
-  rc = __sys_fcntl(fd, cmd, arg);
+  rc = impl(fd, cmd, arg);
   if (islock) {
     flock2cosmo(arg);
   } else if (rc == -1 && cmd == F_DUPFD_CLOEXEC && errno == EINVAL) {
     errno = e;
-    rc = __fixupnewfd(__sys_fcntl(fd, F_DUPFD, arg), O_CLOEXEC);
+    rc = __fixupnewfd(impl(fd, F_DUPFD, arg), O_CLOEXEC);
   }
   return rc;
 }

libc/calls/fcntl.c

@@ -17,6 +17,7 @@
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/calls/calls.h"
+#include "libc/calls/cp.internal.h"
 #include "libc/calls/internal.h"
 #include "libc/calls/struct/flock.h"
 #include "libc/calls/struct/flock.internal.h"
@@ -94,6 +95,7 @@
  * @raise EDEADLK if `cmd` was `F_SETLKW` and waiting would deadlock
  * @raise EMFILE if `cmd` is `F_DUPFD` or `F_DUPFD_CLOEXEC` and
  *     `RLIMIT_NOFILE` would be exceeded
+ * @cancellationpoint when `cmd` is `F_SETLKW` or `F_OFD_SETLKW`
  * @asyncsignalsafe
  * @restartable
  */
@@ -111,7 +113,13 @@ int fcntl(int fd, int cmd, ...) {
       if (fd < g_fds.n && g_fds.p[fd].kind == kFdZip) {
         rc = _weaken(__zipos_fcntl)(fd, cmd, arg);
       } else if (!IsWindows()) {
-        rc = sys_fcntl(fd, cmd, arg);
+        if (cmd == F_SETLKW || cmd == F_OFD_SETLKW) {
+          BEGIN_CANCELLATION_POINT;
+          rc = sys_fcntl(fd, cmd, arg, __sys_fcntl_cp);
+          END_CANCELLATION_POINT;
+        } else {
+          rc = sys_fcntl(fd, cmd, arg, __sys_fcntl);
+        }
       } else {
         rc = sys_fcntl_nt(fd, cmd, arg);
       }

libc/calls/fdatasync-nt.c

@@ -23,5 +23,6 @@
 textwindows int sys_fdatasync_nt(int fd) {
   // TODO(jart): what should we do with worker pipes?
   if (!__isfdkind(fd, kFdFile)) return ebadf();
+  if (_check_interrupts(false, 0)) return -1;
   return FlushFileBuffers(g_fds.p[fd].handle) ? 0 : -1;
 }

libc/calls/fdatasync.c

@@ -17,6 +17,7 @@
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/calls/calls.h"
+#include "libc/calls/cp.internal.h"
 #include "libc/calls/struct/stat.h"
 #include "libc/calls/syscall-nt.internal.h"
 #include "libc/calls/syscall-sysv.internal.h"
@@ -30,17 +31,22 @@
  * @return 0 on success, or -1 w/ errno
  * @see sync(), fsync(), sync_file_range()
  * @see __nosync to secretly disable
+ * @raise ECANCELED if thread was cancelled in masked mode
+ * @raise EINTR if signal was delivered
+ * @cancellationpoint
  * @asyncsignalsafe
  */
 int fdatasync(int fd) {
   int rc;
   struct stat st;
   if (__nosync != 0x5453455454534146) {
+    BEGIN_CANCELLATION_POINT;
     if (!IsWindows()) {
       rc = sys_fdatasync(fd);
     } else {
       rc = sys_fdatasync_nt(fd);
     }
+    END_CANCELLATION_POINT;
     STRACE("fdatasync(%d) → %d% m", fd, rc);
   } else {
     rc = fstat(fd, &st);

libc/calls/flock.c

@@ -17,10 +17,11 @@
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/calls/calls.h"
-#include "libc/intrin/strace.internal.h"
+#include "libc/calls/cp.internal.h"
 #include "libc/calls/syscall-nt.internal.h"
 #include "libc/calls/syscall-sysv.internal.h"
 #include "libc/dce.h"
+#include "libc/intrin/strace.internal.h"
 
 /**
  * Acquires lock on file.
@@ -30,15 +31,20 @@
  * @param op can have LOCK_{SH,EX,NB,UN} for shared, exclusive,
  *     non-blocking, and unlocking
  * @return 0 on success, or -1 w/ errno
+ * @cancellationpoint
  * @restartable
  */
 int flock(int fd, int op) {
   int rc;
+  BEGIN_CANCELLATION_POINT;
+
   if (!IsWindows()) {
     rc = sys_flock(fd, op);
   } else {
     rc = sys_flock_nt(fd, op);
   }
+
+  END_CANCELLATION_POINT;
   STRACE("flock(%d, %d) → %d% m", fd, op, rc);
   return rc;
 }

libc/calls/fstatfs.c

@@ -17,22 +17,26 @@
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/calls/calls.h"
+#include "libc/calls/cp.internal.h"
 #include "libc/calls/internal.h"
-#include "libc/intrin/strace.internal.h"
 #include "libc/calls/struct/statfs-meta.internal.h"
 #include "libc/calls/struct/statfs.internal.h"
 #include "libc/dce.h"
+#include "libc/intrin/strace.internal.h"
 #include "libc/runtime/stack.h"
 #include "libc/sysv/errfuns.h"
 
 /**
  * Returns information about filesystem.
  * @return 0 on success, or -1 w/ errno
+ * @cancellationpoint
  */
 int fstatfs(int fd, struct statfs *sf) {
   int rc;
   union statfs_meta m;
+  BEGIN_CANCELLATION_POINT;
   CheckLargeStackAllocation(&m, sizeof(m));
+
   if (!IsWindows()) {
     if ((rc = sys_fstatfs(fd, &m)) != -1) {
       statfs2cosmo(sf, &m);
@@ -42,6 +46,8 @@ int fstatfs(int fd, struct statfs *sf) {
   } else {
     rc = ebadf();
   }
+
+  END_CANCELLATION_POINT;
   STRACE("fstatfs(%d, [%s]) → %d% m", fd, DescribeStatfs(rc, sf));
   return rc;
 }

libc/calls/fsync.c

@@ -17,6 +17,7 @@
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/calls/calls.h"
+#include "libc/calls/cp.internal.h"
 #include "libc/calls/struct/stat.h"
 #include "libc/calls/syscall-nt.internal.h"
 #include "libc/calls/syscall-sysv.internal.h"
@@ -28,19 +29,24 @@
  * Blocks until kernel flushes buffers for fd to disk.
  *
  * @return 0 on success, or -1 w/ errno
+ * @raise ECANCELED if thread was cancelled in masked mode
+ * @raise EINTR if signal was delivered
  * @see fdatasync(), sync_file_range()
  * @see __nosync to secretly disable
+ * @cancellationpoint
  * @asyncsignalsafe
  */
 int fsync(int fd) {
   int rc;
   struct stat st;
   if (__nosync != 0x5453455454534146) {
+    BEGIN_CANCELLATION_POINT;
     if (!IsWindows()) {
       rc = sys_fsync(fd);
     } else {
       rc = sys_fdatasync_nt(fd);
     }
+    END_CANCELLATION_POINT;
     STRACE("fysnc(%d) → %d% m", fd, rc);
   } else {
     rc = fstat(fd, &st);

libc/calls/ftruncate.c

@@ -17,6 +17,7 @@
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/calls/calls.h"
+#include "libc/calls/cp.internal.h"
 #include "libc/calls/internal.h"
 #include "libc/calls/syscall-nt.internal.h"
 #include "libc/calls/syscall-sysv.internal.h"
@@ -49,6 +50,7 @@
  * @return 0 on success, or -1 w/ errno
  * @raise EINVAL if `length` is negative
  * @raise EINTR if signal was delivered instead
+ * @raise ECANCELED if thread was cancelled in masked mode
  * @raise EIO if a low-level i/o error happened
  * @raise EFBIG or EINVAL if `length` is too huge
  * @raise ENOTSUP if `fd` is a zip file descriptor
@@ -56,12 +58,14 @@
  * @raise EINVAL if `fd` is a non-file, e.g. pipe, socket
  * @raise EINVAL if `fd` wasn't opened in a writeable mode
  * @raise ENOSYS on bare metal
- * @see truncate()
+ * @cancellationpoint
  * @asyncsignalsafe
  * @threadsafe
  */
 int ftruncate(int fd, int64_t length) {
   int rc;
+  BEGIN_CANCELLATION_POINT;
+
   if (fd < 0) {
     rc = ebadf();
   } else if (__isfdkind(fd, kFdZip)) {
@@ -78,6 +82,8 @@ int ftruncate(int fd, int64_t length) {
   } else {
     rc = ebadf();
   }
+
+  END_CANCELLATION_POINT;
   STRACE("ftruncate(%d, %'ld) → %d% m", fd, length, rc);
   return rc;
 }

libc/calls/getcwd-xnu.greg.c

@@ -42,7 +42,7 @@ char *sys_getcwd_xnu(char *res, size_t size) {
   int fd;
   union metastat st[2];
   char buf[XNU_MAXPATHLEN], *ret = NULL;
-  if ((fd = sys_openat(AT_FDCWD, ".", O_RDONLY | O_DIRECTORY, 0)) != -1) {
+  if ((fd = __sys_openat_nc(AT_FDCWD, ".", O_RDONLY | O_DIRECTORY, 0)) != -1) {
     if (__sys_fstat(fd, &st[0]) != -1) {
       if (st[0].xnu.st_dev && st[0].xnu.st_ino) {
         if (__sys_fcntl(fd, XNU_F_GETPATH, (uintptr_t)buf) != -1) {

libc/calls/getfiledescriptorsize.c

@@ -18,6 +18,7 @@
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/calls/calls.h"
 #include "libc/calls/internal.h"
+#include "libc/calls/metalfile.internal.h"
 #include "libc/calls/struct/metastat.internal.h"
 #include "libc/calls/struct/stat.h"
 #include "libc/calls/syscall-sysv.internal.h"
@@ -60,7 +61,14 @@ ssize_t getfiledescriptorsize(int fd) {
       rc = -1;
     }
   } else if (IsMetal()) {
-    rc = -1;
+    if (fd < 0 || fd >= g_fds.n) {
+      rc = ebadf();
+    } else if (g_fds.p[fd].kind != kFdFile) {
+      rc = eacces();
+    } else {
+      struct MetalFile *state = (struct MetalFile *)g_fds.p[fd].handle;
+      rc = state->size;
+    }
   } else if (!IsWindows()) {
     if (!__sys_fstat(fd, &st)) {
       rc = METASTAT(st, st_size);

libc/calls/getprogramexecutablename.greg.c

@@ -17,6 +17,7 @@
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/calls/calls.h"
+#include "libc/calls/metalfile.internal.h"
 #include "libc/calls/syscall-sysv.internal.h"
 #include "libc/dce.h"
 #include "libc/errno.h"
@@ -76,6 +77,11 @@ static inline void GetProgramExecutableNameImpl(char *p, char *e) {
     return;
   }
 
+  if (IsMetal()) {
+    if (!memccpy(p, APE_COM_NAME, 0, e - p - 1)) e[-1] = 0;
+    return;
+  }
+
   // if argv[0] exists then turn it into an absolute path. we also try
   // adding a .com suffix since the ape auto-appends it when resolving
   if (__argc && (((q = __argv[0]) && !sys_faccessat(AT_FDCWD, q, F_OK, 0)) ||

libc/calls/internal.h

@@ -43,7 +43,7 @@ forceinline size_t _clampio(size_t size) {
 }
 
 int sys_close_nt(struct Fd *, int) hidden;
-bool _check_interrupts(bool, struct Fd *) hidden;
+int _check_interrupts(bool, struct Fd *) hidden;
 int sys_openat_metal(int, const char *, int, unsigned);
 
 COSMOPOLITAN_C_END_

libc/calls/interrupts-nt.c

@@ -18,24 +18,33 @@
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/assert.h"
 #include "libc/calls/calls.h"
+#include "libc/calls/internal.h"
 #include "libc/calls/sig.internal.h"
 #include "libc/calls/state.internal.h"
 #include "libc/calls/struct/fd.internal.h"
 #include "libc/calls/struct/sigaction.h"
 #include "libc/calls/syscall_support-nt.internal.h"
 #include "libc/dce.h"
+#include "libc/errno.h"
 #include "libc/intrin/lockcmpxchgp.h"
 #include "libc/intrin/strace.internal.h"
 #include "libc/intrin/weaken.h"
+#include "libc/sysv/errfuns.h"
+#include "libc/thread/thread.h"
 #include "libc/thread/tls.h"
 
-textwindows bool _check_interrupts(bool restartable, struct Fd *fd) {
-  bool res;
+textwindows int _check_interrupts(bool restartable, struct Fd *fd) {
+  int rc;
+  if (_weaken(pthread_testcancel_np) &&
+      (rc = _weaken(pthread_testcancel_np)())) {
+    errno = rc;
+    return -1;
+  }
   if (_weaken(_check_sigalrm)) _weaken(_check_sigalrm)();
   if (!__tls_enabled || !(__get_tls()->tib_flags & TIB_FLAG_TIME_CRITICAL)) {
     if (_weaken(_check_sigchld)) _weaken(_check_sigchld)();
     if (fd && _weaken(_check_sigwinch)) _weaken(_check_sigwinch)(fd);
   }
-  res = _weaken(__sig_check) && _weaken(__sig_check)(restartable);
-  return res;
+  if (_weaken(__sig_check) && _weaken(__sig_check)(restartable)) return eintr();
+  return 0;
 }

libc/calls/metalfile.c

@@ -0,0 +1,75 @@
+/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│
+│vi: set net ft=c ts=2 sts=2 sw=2 fenc=utf-8                                :vi│
+╞══════════════════════════════════════════════════════════════════════════════╡
+│ This is free and unencumbered software released into the public domain.      │
+│                                                                              │
+│ Anyone is free to copy, modify, publish, use, compile, sell, or              │
+│ distribute this software, either in source code form or as a compiled        │
+│ binary, for any purpose, commercial or non-commercial, and by any            │
+│ means.                                                                       │
+│                                                                              │
+│ In jurisdictions that recognize copyright laws, the author or authors        │
+│ of this software dedicate any and all copyright interest in the              │
+│ software to the public domain. We make this dedication for the benefit       │
+│ of the public at large and to the detriment of our heirs and                 │
+│ successors. We intend this dedication to be an overt act of                  │
+│ relinquishment in perpetuity of all present and future rights to this        │
+│ software under copyright law.                                                │
+│                                                                              │
+│ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,              │
+│ EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF           │
+│ MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.       │
+│ IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR            │
+│ OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,        │
+│ ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR        │
+│ OTHER DEALINGS IN THE SOFTWARE.                                              │
+╚─────────────────────────────────────────────────────────────────────────────*/
+#include "ape/relocations.h"
+#include "ape/sections.internal.h"
+#include "libc/assert.h"
+#include "libc/calls/internal.h"
+#include "libc/calls/metalfile.internal.h"
+#include "libc/intrin/directmap.internal.h"
+#include "libc/intrin/weaken.h"
+#include "libc/macros.internal.h"
+#include "libc/mem/mem.h"
+#include "libc/runtime/pc.internal.h"
+#include "libc/runtime/runtime.h"
+#include "libc/str/str.h"
+#include "libc/sysv/consts/at.h"
+#include "libc/sysv/consts/o.h"
+#include "libc/sysv/consts/prot.h"
+#include "libc/sysv/errfuns.h"
+
+#define MAP_ANONYMOUS_linux 0x00000020
+#define MAP_FIXED_linux     0x00000010
+#define MAP_SHARED_linux    0x00000001
+
+STATIC_YOINK("_init_metalfile");
+
+void *__ape_com_base;
+size_t __ape_com_size = 0;
+
+textstartup noasan void InitializeMetalFile(void) {
+  if (IsMetal()) {
+    /*
+     * Copy out a pristine image of the program — before the program might
+     * decide to modify its own .data section.
+     *
+     * This code is included if a symbol "file:/proc/self/exe" is defined
+     * (see libc/calls/metalfile.internal.h & libc/calls/metalfile_init.S).
+     * The zipos code will automatically arrange to do this.  Alternatively,
+     * user code can STATIC_YOINK this symbol.
+     */
+    size_t size = ROUNDUP(_tdata_end - _base, 4096);
+    void *copied_base;
+    struct DirectMap dm;
+    dm = sys_mmap_metal(NULL, size, PROT_READ | PROT_WRITE,
+                        MAP_SHARED_linux | MAP_ANONYMOUS_linux, -1, 0);
+    copied_base = dm.addr;
+    _npassert(copied_base != (void *)-1);
+    memcpy(copied_base, (void *)(BANE + IMAGE_BASE_REAL), size);
+    __ape_com_base = copied_base;
+    __ape_com_size = size;
+  }
+}

libc/calls/metalfile.internal.h

@@ -9,6 +9,12 @@ struct MetalFile {
   size_t pos;
 };
 
+extern void *__ape_com_base;
+extern size_t __ape_com_size;
+
 COSMOPOLITAN_C_END_
 #endif /* !(__ASSEMBLER__ + __LINKER__ + 0) */
+
+#define APE_COM_NAME "/proc/self/exe"
+
 #endif /* COSMOPOLITAN_LIBC_CALLS_METALFILE_INTERNAL_H_ */

libc/calls/metalfile_init.S

@@ -0,0 +1,38 @@
+/*-*- mode:unix-assembly; indent-tabs-mode:t; tab-width:8; coding:utf-8     -*-│
+│vi: set et ft=asm ts=8 tw=8 fenc=utf-8                                     :vi│
+╞══════════════════════════════════════════════════════════════════════════════╡
+│ This is free and unencumbered software released into the public domain.      │
+│                                                                              │
+│ Anyone is free to copy, modify, publish, use, compile, sell, or              │
+│ distribute this software, either in source code form or as a compiled        │
+│ binary, for any purpose, commercial or non-commercial, and by any            │
+│ means.                                                                       │
+│                                                                              │
+│ In jurisdictions that recognize copyright laws, the author or authors        │
+│ of this software dedicate any and all copyright interest in the              │
+│ software to the public domain. We make this dedication for the benefit       │
+│ of the public at large and to the detriment of our heirs and                 │
+│ successors. We intend this dedication to be an overt act of                  │
+│ relinquishment in perpetuity of all present and future rights to this        │
+│ software under copyright law.                                                │
+│                                                                              │
+│ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,              │
+│ EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF           │
+│ MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.       │
+│ IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR            │
+│ OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,        │
+│ ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR        │
+│ OTHER DEALINGS IN THE SOFTWARE.                                              │
+╚─────────────────────────────────────────────────────────────────────────────*/
+#include "libc/macros.internal.h"
+#include "libc/calls/metalfile.internal.h"
+
+	.init.start 101,_init_metalfile
+	push	%rdi
+	push	%rsi
+	call	InitializeMetalFile
+	pop	%rsi
+	pop	%rdi
+	.init.end 101,_init_metalfile
+APE_COM_NAME:
+	.endobj	APE_COM_NAME,globl,hidden

libc/calls/munmap-metal.c

@@ -26,8 +26,8 @@ noasan int sys_munmap_metal(void *addr, size_t size) {
   mm = (struct mman *)(BANE + 0x0500);
   for (i = 0; i < size; i += 4096) {
     e = __get_virtual(mm, __get_pml4t(), (uint64_t)addr + i, false);
-    if (e) *e = ~PAGE_V;
-    invlpg(e);
+    if (e) *e = ~(PAGE_V | PAGE_RSRV);
+    invlpg((uint64_t)addr + i);
   }
   return 0;
 }

libc/calls/nanosleep-xnu.c

@@ -29,7 +29,7 @@ int sys_nanosleep_xnu(const struct timespec *req, struct timespec *rem) {
   int rc;
   struct timeval wt, t1, t2, td;
   if (rem) sys_gettimeofday_xnu(&t1, 0, 0);
-  wt = _timespec_totimeval(*req);  // rounds up
+  wt = timespec_totimeval(*req);  // rounds up
   rc = sys_select(0, 0, 0, 0, &wt);
   if (rem) {
     if (!rc) {
@@ -39,12 +39,12 @@ int sys_nanosleep_xnu(const struct timespec *req, struct timespec *rem) {
       // xnu select() doesn't modify timeout
       // so we need, yet another system call
       sys_gettimeofday_xnu(&t2, 0, 0);
-      td = _timeval_sub(t2, t1);
-      if (_timeval_gte(td, wt)) {
+      td = timeval_sub(t2, t1);
+      if (timeval_cmp(td, wt) >= 0) {
         rem->tv_sec = 0;
         rem->tv_nsec = 0;
       } else {
-        *rem = _timeval_totimespec(_timeval_sub(wt, td));
+        *rem = timeval_totimespec(timeval_sub(wt, td));
       }
     }
   }

libc/calls/nanosleep.c

@@ -28,10 +28,12 @@
  *     time when -1 w/ `EINTR` is returned otherwise `rem` is undefined
  * @return 0 on success, or -1 w/ errno
  * @raise EINVAL if `req->tv_nsec ∉ [0,1000000000)`
+ * @raise ECANCELED if thread was cancelled in masked mode
  * @raise EINTR if a signal was delivered and `rem` is updated
  * @raise EFAULT if `req` is NULL or `req` / `rem` is a bad pointer
  * @raise ENOSYS on bare metal
  * @see clock_nanosleep()
+ * @cancellationpoint
  * @norestart
  */
 int nanosleep(const struct timespec *req, struct timespec *rem) {

libc/calls/ntcontext2linux.c

@@ -21,6 +21,8 @@
 #include "libc/nt/struct/context.h"
 #include "libc/str/str.h"
 
+// TODO(jart): uc_sigmask support
+
 privileged void _ntcontext2linux(ucontext_t *ctx, const struct NtContext *cr) {
   if (!cr) return;
   ctx->uc_mcontext.eflags = cr->EFlags;

libc/calls/open.c

@@ -29,6 +29,7 @@
  * @param file specifies filesystem path to open
  * @return file descriptor, or -1 w/ errno
  * @see openat() for further documentation
+ * @cancellationpoint
  * @asyncsignalsafe
  * @restartable
  * @threadsafe

libc/calls/openat-metal.c

@@ -16,24 +16,46 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
+#include "ape/relocations.h"
 #include "ape/sections.internal.h"
+#include "libc/assert.h"
 #include "libc/calls/internal.h"
 #include "libc/calls/metalfile.internal.h"
+#include "libc/intrin/directmap.internal.h"
 #include "libc/intrin/weaken.h"
+#include "libc/macros.internal.h"
 #include "libc/mem/mem.h"
+#include "libc/runtime/pc.internal.h"
 #include "libc/runtime/runtime.h"
 #include "libc/str/str.h"
+#include "libc/sysv/consts/at.h"
+#include "libc/sysv/consts/map.h"
+#include "libc/sysv/consts/o.h"
+#include "libc/sysv/consts/prot.h"
 #include "libc/sysv/errfuns.h"
+#include "libc/zipos/zipos.internal.h"
 
 int sys_openat_metal(int dirfd, const char *file, int flags, unsigned mode) {
   int fd;
   struct MetalFile *state;
-  if (strcmp(file, "ape.com")) return enoent();
-  if (!_weaken(calloc)) return enomem();
+  if (dirfd != AT_FDCWD || strcmp(file, APE_COM_NAME)) return enoent();
+  if (flags != O_RDONLY) return eacces();
+  if (!_weaken(__ape_com_base) || !_weaken(__ape_com_size))
+    return eopnotsupp();
   if ((fd = __reservefd(-1)) == -1) return -1;
-  state = _weaken(calloc)(1, sizeof(struct MetalFile));
-  state->base = (char *)_base;
-  state->size = _end - _base;
+  if (!_weaken(calloc) || !_weaken(free)) {
+    struct DirectMap dm;
+    dm = sys_mmap_metal(NULL, ROUNDUP(sizeof(struct MetalFile), 4096),
+                        PROT_READ | PROT_WRITE, MAP_SHARED | MAP_ANONYMOUS,
+                        -1, 0);
+    state = dm.addr;
+    if (state == (void *)-1) return -1;
+  } else {
+    state = _weaken(calloc)(1, sizeof(struct MetalFile));
+    if (!state) return -1;
+  }
+  state->base = (char *)__ape_com_base;
+  state->size = __ape_com_size;
   g_fds.p[fd].kind = kFdFile;
   g_fds.p[fd].flags = flags;
   g_fds.p[fd].mode = mode;

libc/calls/openat.c

@@ -17,6 +17,7 @@
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/calls/calls.h"
+#include "libc/calls/cp.internal.h"
 #include "libc/calls/internal.h"
 #include "libc/calls/state.internal.h"
 #include "libc/calls/syscall-nt.internal.h"
@@ -130,6 +131,7 @@
  * @raise ENOTSUP if `file` is on zip file system and process is vfork()'d
  * @raise ENOSPC if file system is full when `file` would be `O_CREAT`ed
  * @raise EINTR if we needed to block and a signal was delivered instead
+ * @raise ECANCELED if thread was cancelled in masked mode
  * @raise ENOENT if `file` doesn't exist when `O_CREAT` isn't in `flags`
  * @raise ENOENT if `file` points to a string that's empty
  * @raise ENOMEM if insufficient memory was available
@@ -141,6 +143,7 @@
  * @raise ELOOP if `flags` had `O_NOFOLLOW` and `file` is a symbolic link
  * @raise ELOOP if a loop was detected resolving components of `file`
  * @raise EISDIR if writing is requested and `file` names a directory
+ * @cancellationpoint
  * @asyncsignalsafe
  * @restartable
  * @threadsafe
@@ -154,6 +157,8 @@ int openat(int dirfd, const char *file, int flags, ...) {
   va_start(va, flags);
   mode = va_arg(va, unsigned);
   va_end(va);
+  BEGIN_CANCELLATION_POINT;
+
   if (file && (!IsAsan() || __asan_is_valid_str(file))) {
     if (!__isfdkind(dirfd, kFdZip)) {
       if (_weaken(__zipos_open) &&
@@ -176,6 +181,8 @@ int openat(int dirfd, const char *file, int flags, ...) {
   } else {
     rc = efault();
   }
+
+  END_CANCELLATION_POINT;
   STRACE("openat(%s, %#s, %s, %#o) → %d% m", DescribeDirfd(dirfd), file,
          DescribeOpenFlags(flags), (flags & (O_CREAT | O_TMPFILE)) ? mode : 0,
          rc);

libc/calls/openpty.c

@@ -17,6 +17,7 @@
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/assert.h"
+#include "libc/calls/blockcancel.internal.h"
 #include "libc/calls/calls.h"
 #include "libc/calls/ioctl.h"
 #include "libc/calls/struct/metatermios.internal.h"
@@ -43,31 +44,12 @@ struct IoctlPtmGet {
   char sname[16];
 };
 
-/**
- * Opens new pseudo teletypewriter.
- *
- * @param mfd receives controlling tty rw fd on success
- * @param sfd receives subordinate tty rw fd on success
- * @param tio may be passed to tune a century of legacy behaviors
- * @param wsz may be passed to set terminal display dimensions
- * @params flags is usually O_RDWR|O_NOCTTY
- * @return 0 on success, or -1 w/ errno
- */
-int openpty(int *mfd, int *sfd, char *name, const struct termios *tio,
-            const struct winsize *wsz) {
+static int openpty_impl(int *mfd, int *sfd, char *name,
+                        const struct termios *tio,  //
+                        const struct winsize *wsz) {
   int m, s, p;
   union metatermios mt;
   struct IoctlPtmGet t;
-  if (IsWindows() || IsMetal()) {
-    return enosys();
-  }
-  if (IsAsan() && (!__asan_is_valid(mfd, sizeof(int)) ||
-                   !__asan_is_valid(sfd, sizeof(int)) ||
-                   (name && !__asan_is_valid(name, 16)) ||
-                   (tio && !__asan_is_valid(tio, sizeof(*tio))) ||
-                   (wsz && !__asan_is_valid(wsz, sizeof(*wsz))))) {
-    return efault();
-  }
   RETURN_ON_ERROR((m = posix_openpt(O_RDWR | O_NOCTTY)));
   if (!IsOpenbsd()) {
     RETURN_ON_ERROR(grantpt(m));
@@ -90,3 +72,33 @@ OnError:
   if (m != -1) sys_close(m);
   return -1;
 }
+
+/**
+ * Opens new pseudo teletypewriter.
+ *
+ * @param mfd receives controlling tty rw fd on success
+ * @param sfd receives subordinate tty rw fd on success
+ * @param tio may be passed to tune a century of legacy behaviors
+ * @param wsz may be passed to set terminal display dimensions
+ * @params flags is usually O_RDWR|O_NOCTTY
+ * @return 0 on success, or -1 w/ errno
+ */
+int openpty(int *mfd, int *sfd, char *name,  //
+            const struct termios *tio,       //
+            const struct winsize *wsz) {
+  int rc;
+  if (IsWindows() || IsMetal()) {
+    return enosys();
+  }
+  if (IsAsan() && (!__asan_is_valid(mfd, sizeof(int)) ||
+                   !__asan_is_valid(sfd, sizeof(int)) ||
+                   (name && !__asan_is_valid(name, 16)) ||
+                   (tio && !__asan_is_valid(tio, sizeof(*tio))) ||
+                   (wsz && !__asan_is_valid(wsz, sizeof(*wsz))))) {
+    return efault();
+  }
+  BLOCK_CANCELLATIONS;
+  rc = openpty(mfd, sfd, name, tio, wsz);
+  ALLOW_CANCELLATIONS;
+  return rc;
+}

libc/calls/pause-nt.c

@@ -18,8 +18,9 @@
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/calls/internal.h"
 #include "libc/calls/sig.internal.h"
-#include "libc/intrin/strace.internal.h"
 #include "libc/calls/syscall_support-nt.internal.h"
+#include "libc/errno.h"
+#include "libc/intrin/strace.internal.h"
 #include "libc/nt/errors.h"
 #include "libc/nt/synchronization.h"
 #include "libc/sysv/errfuns.h"
@@ -31,7 +32,7 @@ textwindows int sys_pause_nt(void) {
   for (;;) {
 
     if (_check_interrupts(false, g_fds.p)) {
-      return eintr();
+      return -1;
     }
 
     if (SleepEx(__SIG_POLLING_INTERVAL_MS, true) == kNtWaitIoCompletion) {

libc/calls/pause.c

@@ -17,9 +17,10 @@
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/calls/calls.h"
-#include "libc/intrin/strace.internal.h"
+#include "libc/calls/cp.internal.h"
 #include "libc/calls/syscall_support-nt.internal.h"
 #include "libc/dce.h"
+#include "libc/intrin/strace.internal.h"
 #include "libc/sock/internal.h"
 
 /**
@@ -37,12 +38,14 @@
  * However this has a tinier footprint and better logging.
  *
  * @return -1 w/ errno set to EINTR
+ * @cancellationpoint
  * @see sigsuspend()
  * @norestart
  */
 int pause(void) {
   int rc;
   STRACE("pause() → [...]");
+  BEGIN_CANCELLATION_POINT;
 
   if (!IsWindows()) {
     // We'll polyfill pause() using select() with a null timeout, which
@@ -63,6 +66,7 @@ int pause(void) {
     rc = sys_pause_nt();
   }
 
+  END_CANCELLATION_POINT;
   STRACE("[...] pause → %d% m", rc);
   return rc;
 }

libc/calls/pipe2.c

@@ -16,17 +16,19 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/intrin/strace.internal.h"
 #include "libc/calls/syscall-nt.internal.h"
 #include "libc/calls/syscall-sysv.internal.h"
 #include "libc/dce.h"
 #include "libc/intrin/asan.internal.h"
+#include "libc/intrin/strace.internal.h"
 #include "libc/sysv/consts/o.h"
 #include "libc/sysv/errfuns.h"
 
 /**
  * Creates file-less file descriptors for interprocess communication.
  *
+ * @raise EMFILE if process `RLIMIT_NOFILE` has been reached
+ * @raise ENFILE if system-wide file limit has been reached
  * @param pipefd is used to return (reader, writer) file descriptors
  * @param flags can have O_CLOEXEC or O_DIRECT or O_NONBLOCK
  * @return 0 on success, or -1 w/ errno and pipefd isn't modified

libc/calls/poll-nt.c

@@ -21,7 +21,6 @@
 #include "libc/calls/sig.internal.h"
 #include "libc/calls/state.internal.h"
 #include "libc/calls/struct/sigaction.h"
-#include "libc/errno.h"
 #include "libc/intrin/bits.h"
 #include "libc/intrin/strace.internal.h"
 #include "libc/macros.internal.h"
@@ -64,8 +63,7 @@ textwindows int sys_poll_nt(struct pollfd *fds, uint64_t nfds, uint64_t *ms,
   if (sigmask) {
     __sig_mask(SIG_SETMASK, sigmask, &oldmask);
   }
-  if (_check_interrupts(false, g_fds.p)) {
-    rc = eintr();
+  if ((rc = _check_interrupts(false, g_fds.p))) {
     goto ReturnPath;
   }
 
@@ -190,8 +188,7 @@ textwindows int sys_poll_nt(struct pollfd *fds, uint64_t nfds, uint64_t *ms,
     }
     // otherwise loop limitlessly for timeout to elapse while
     // checking for signal delivery interrupts, along the way
-    if (_check_interrupts(false, g_fds.p)) {
-      rc = eintr();
+    if ((rc = _check_interrupts(false, g_fds.p))) {
       goto ReturnPath;
     }
   }

libc/calls/poll.c

@@ -16,6 +16,7 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
+#include "libc/calls/cp.internal.h"
 #include "libc/dce.h"
 #include "libc/intrin/asan.internal.h"
 #include "libc/intrin/strace.internal.h"
@@ -55,6 +56,9 @@
  * @return fds[𝑖].revents is always zero initializaed and then will
  *     be populated with POLL{IN,OUT,PRI,HUP,ERR,NVAL} if something
  *     was determined about the file descriptor
+ * @raise ECANCELED if thread was cancelled in masked mode
+ * @raise EINTR if signal was delivered
+ * @cancellationpoint
  * @asyncsignalsafe
  * @threadsafe
  * @norestart
@@ -63,6 +67,7 @@ int poll(struct pollfd *fds, size_t nfds, int timeout_ms) {
   int rc;
   size_t n;
   uint64_t millis;
+  BEGIN_CANCELLATION_POINT;
 
   if (IsAsan() && (__builtin_mul_overflow(nfds, sizeof(struct pollfd), &n) ||
                    !__asan_is_valid(fds, n))) {
@@ -78,6 +83,7 @@ int poll(struct pollfd *fds, size_t nfds, int timeout_ms) {
     rc = sys_poll_nt(fds, nfds, &millis, 0);
   }
 
+  END_CANCELLATION_POINT;
   STRACE("poll(%s, %'zu, %'d) → %d% lm", DescribePollFds(rc, fds, nfds), nfds,
          timeout_ms, rc);
   return rc;

libc/calls/ppoll.c

@@ -16,6 +16,7 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
+#include "libc/calls/cp.internal.h"
 #include "libc/calls/struct/sigset.h"
 #include "libc/calls/struct/sigset.internal.h"
 #include "libc/calls/struct/timespec.h"
@@ -50,6 +51,9 @@
  *
  * @param timeout if null will block indefinitely
  * @param sigmask may be null in which case no mask change happens
+ * @raise ECANCELED if thread was cancelled in masked mode
+ * @raise EINTR if signal was delivered
+ * @cancellationpoint
  * @asyncsignalsafe
  * @threadsafe
  * @norestart
@@ -61,6 +65,7 @@ int ppoll(struct pollfd *fds, size_t nfds, const struct timespec *timeout,
   uint64_t millis;
   sigset_t oldmask;
   struct timespec ts, *tsp;
+  BEGIN_CANCELLATION_POINT;
 
   if (IsAsan() && (__builtin_mul_overflow(nfds, sizeof(struct pollfd), &n) ||
                    !__asan_is_valid(fds, n) ||
@@ -95,6 +100,7 @@ int ppoll(struct pollfd *fds, size_t nfds, const struct timespec *timeout,
     rc = sys_poll_nt(fds, nfds, &millis, sigmask);
   }
 
+  END_CANCELLATION_POINT;
   STRACE("ppoll(%s, %'zu, %s, %s) → %d% lm", DescribePollFds(rc, fds, nfds),
          nfds, DescribeTimespec(0, timeout), DescribeSigset(0, sigmask), rc);
   return rc;

libc/calls/pread.c

@@ -18,6 +18,7 @@
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/assert.h"
 #include "libc/calls/calls.h"
+#include "libc/calls/cp.internal.h"
 #include "libc/calls/internal.h"
 #include "libc/calls/struct/iovec.h"
 #include "libc/calls/struct/iovec.internal.h"
@@ -47,13 +48,17 @@
  * @raise EBADF if `fd` isn't an open file descriptor
  * @raise EIO if a complicated i/o error happened
  * @raise EINTR if signal was delivered instead
+ * @raise ECANCELED if thread was cancelled in masked mode
  * @see pwrite(), write()
+ * @cancellationpoint
  * @asyncsignalsafe
  * @threadsafe
  * @vforksafe
  */
 ssize_t pread(int fd, void *buf, size_t size, int64_t offset) {
   ssize_t rc;
+  BEGIN_CANCELLATION_POINT;
+
   if (offset < 0) {
     rc = einval();
   } else if (fd < 0) {
@@ -72,6 +77,8 @@ ssize_t pread(int fd, void *buf, size_t size, int64_t offset) {
     rc = ebadf();
   }
   _npassert(rc == -1 || (size_t)rc <= size);
+
+  END_CANCELLATION_POINT;
   DATATRACE("pread(%d, [%#.*hhs%s], %'zu, %'zd) → %'zd% m", fd,
             MAX(0, MIN(40, rc)), buf, rc > 40 ? "..." : "", size, offset, rc);
   return rc;

libc/calls/preadv.c

@@ -16,6 +16,7 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
+#include "libc/calls/cp.internal.h"
 #include "libc/calls/internal.h"
 #include "libc/calls/struct/iovec.h"
 #include "libc/calls/struct/iovec.internal.h"
@@ -108,12 +109,15 @@ static ssize_t Preadv(int fd, struct iovec *iov, int iovlen, int64_t off) {
  * Reads with maximum generality.
  *
  * @return number of bytes actually read, or -1 w/ errno
+ * @cancellationpoint
  * @asyncsignalsafe
  * @vforksafe
  */
 ssize_t preadv(int fd, struct iovec *iov, int iovlen, int64_t off) {
   ssize_t rc;
+  BEGIN_CANCELLATION_POINT;
   rc = Preadv(fd, iov, iovlen, off);
+  END_CANCELLATION_POINT;
   STRACE("preadv(%d, [%s], %d, %'ld) → %'ld% m", fd,
          DescribeIovec(rc, iov, iovlen), iovlen, off, rc);
   return rc;

libc/calls/pwrite.c

@@ -18,6 +18,7 @@
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/assert.h"
 #include "libc/calls/calls.h"
+#include "libc/calls/cp.internal.h"
 #include "libc/calls/internal.h"
 #include "libc/calls/struct/iovec.h"
 #include "libc/calls/struct/iovec.internal.h"
@@ -42,6 +43,7 @@
  * @return [1..size] bytes on success, or -1 w/ errno; noting zero is
  *     impossible unless size was passed as zero to do an error check
  * @see pread(), write()
+ * @cancellationpoint
  * @asyncsignalsafe
  * @threadsafe
  * @vforksafe
@@ -49,6 +51,8 @@
 ssize_t pwrite(int fd, const void *buf, size_t size, int64_t offset) {
   ssize_t rc;
   size_t wrote;
+  BEGIN_CANCELLATION_POINT;
+
   if (offset < 0) {
     rc = einval();
   } else if (fd == -1) {
@@ -70,6 +74,8 @@ ssize_t pwrite(int fd, const void *buf, size_t size, int64_t offset) {
       _npassert(wrote <= size);
     }
   }
+
+  END_CANCELLATION_POINT;
   DATATRACE("pwrite(%d, %#.*hhs%s, %'zu, %'zd) → %'zd% m", fd,
             MAX(0, MIN(40, rc)), buf, rc > 40 ? "..." : "", size, offset, rc);
   return rc;

libc/calls/pwritev.c

@@ -16,6 +16,7 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
+#include "libc/calls/cp.internal.h"
 #include "libc/calls/internal.h"
 #include "libc/calls/struct/iovec.h"
 #include "libc/calls/struct/iovec.internal.h"
@@ -114,12 +115,15 @@ static ssize_t Pwritev(int fd, const struct iovec *iov, int iovlen,
  * call using pwrite().
  *
  * @return number of bytes actually sent, or -1 w/ errno
+ * @cancellationpoint
  * @asyncsignalsafe
  * @vforksafe
  */
 ssize_t pwritev(int fd, const struct iovec *iov, int iovlen, int64_t off) {
   ssize_t rc;
+  BEGIN_CANCELLATION_POINT;
   rc = Pwritev(fd, iov, iovlen, off);
+  END_CANCELLATION_POINT;
   STRACE("pwritev(%d, %s, %d, %'ld) → %'ld% m", fd,
          DescribeIovec(rc != -1 ? rc : -2, iov, iovlen), iovlen, off, rc);
   return rc;

libc/calls/read-nt.c

@@ -53,7 +53,7 @@ static textwindows ssize_t sys_read_nt_impl(struct Fd *fd, void *data,
       }
       if (_check_interrupts(true, g_fds.p)) {
         POLLTRACE("sys_read_nt interrupted");
-        return eintr();
+        return -1;
       }
     }
     POLLTRACE("sys_read_nt ready to read");
@@ -94,7 +94,7 @@ textwindows ssize_t sys_read_nt(struct Fd *fd, const struct iovec *iov,
   uint32_t size;
   size_t i, total;
   if (opt_offset < -1) return einval();
-  if (_check_interrupts(true, fd)) return eintr();
+  if (_check_interrupts(true, fd)) return -1;
   while (iovlen && !iov[0].iov_len) iov++, iovlen--;
   if (iovlen) {
     for (total = i = 0; i < iovlen; ++i) {

libc/calls/read.c

@@ -17,6 +17,7 @@
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/calls/calls.h"
+#include "libc/calls/cp.internal.h"
 #include "libc/calls/internal.h"
 #include "libc/calls/struct/iovec.h"
 #include "libc/calls/struct/iovec.internal.h"
@@ -49,6 +50,7 @@
  * @raise EPERM if pledge() is in play without the stdio promise
  * @raise EIO if low-level i/o error happened
  * @raise EINTR if signal was delivered instead
+ * @raise ECANCELED if thread was cancelled in masked mode
  * @raise ENOTCONN if `fd` is a socket and it isn't connected
  * @raise ECONNRESET if socket peer forcibly closed connection
  * @raise ETIMEDOUT if socket transmission timeout occurred
@@ -56,12 +58,14 @@
  *     or `SO_RCVTIMEO` is in play and the time interval elapsed
  * @raise ENOBUFS is specified by POSIX
  * @raise ENXIO is specified by POSIX
+ * @cancellationpoint
  * @asyncsignalsafe
  * @restartable
  * @vforksafe
  */
 ssize_t read(int fd, void *buf, size_t size) {
   ssize_t rc;
+  BEGIN_CANCELLATION_POINT;
   if (fd >= 0) {
     if ((!buf && size) || (IsAsan() && !__asan_is_valid(buf, size))) {
       rc = efault();
@@ -81,6 +85,7 @@ ssize_t read(int fd, void *buf, size_t size) {
   } else {
     rc = ebadf();
   }
+  END_CANCELLATION_POINT;
   DATATRACE("read(%d, [%#.*hhs%s], %'zu) → %'zd% m", fd, MAX(0, MIN(40, rc)),
             buf, rc > 40 ? "..." : "", size, rc);
   return rc;

libc/calls/readv.c

@@ -17,6 +17,7 @@
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/calls/calls.h"
+#include "libc/calls/cp.internal.h"
 #include "libc/calls/internal.h"
 #include "libc/calls/struct/iovec.h"
 #include "libc/calls/struct/iovec.internal.h"
@@ -43,10 +44,12 @@
  * performance boost in the case of a single small iovec.
  *
  * @return number of bytes actually read, or -1 w/ errno
+ * @cancellationpoint
  * @restartable
  */
 ssize_t readv(int fd, const struct iovec *iov, int iovlen) {
   ssize_t rc;
+  BEGIN_CANCELLATION_POINT;
 
   if (fd >= 0 && iovlen >= 0) {
     if (IsAsan() && !__asan_is_valid_iov(iov, iovlen)) {
@@ -73,6 +76,7 @@ ssize_t readv(int fd, const struct iovec *iov, int iovlen) {
     rc = einval();
   }
 
+  END_CANCELLATION_POINT;
   STRACE("readv(%d, [%s], %d) → %'ld% m", fd, DescribeIovec(rc, iov, iovlen),
          iovlen, rc);
   return rc;

libc/calls/rusage_add.c

@@ -22,9 +22,9 @@
 /**
  * Accumulates resource statistics in `y` to `x`.
  */
-void _addrusage(struct rusage *x, const struct rusage *y) {
-  x->ru_utime = _timeval_add(x->ru_utime, y->ru_utime);
-  x->ru_stime = _timeval_add(x->ru_stime, y->ru_stime);
+void rusage_add(struct rusage *x, const struct rusage *y) {
+  x->ru_utime = timeval_add(x->ru_utime, y->ru_utime);
+  x->ru_stime = timeval_add(x->ru_stime, y->ru_stime);
   x->ru_maxrss = MAX(x->ru_maxrss, y->ru_maxrss);
   x->ru_ixrss += y->ru_ixrss;
   x->ru_idrss += y->ru_idrss;

libc/calls/sigaction.c

@@ -22,11 +22,6 @@
 #include "libc/calls/internal.h"
 #include "libc/calls/sig.internal.h"
 #include "libc/calls/state.internal.h"
-#include "libc/calls/struct/sigaction-freebsd.internal.h"
-#include "libc/calls/struct/sigaction-linux.internal.h"
-#include "libc/calls/struct/sigaction-netbsd.h"
-#include "libc/calls/struct/sigaction-openbsd.internal.h"
-#include "libc/calls/struct/sigaction-xnu.internal.h"
 #include "libc/calls/struct/sigaction.h"
 #include "libc/calls/struct/sigaction.internal.h"
 #include "libc/calls/struct/siginfo.internal.h"
@@ -46,6 +41,7 @@
 #include "libc/mem/mem.h"
 #include "libc/runtime/runtime.h"
 #include "libc/str/str.h"
+#include "libc/sysv/consts/limits.h"
 #include "libc/sysv/consts/sa.h"
 #include "libc/sysv/consts/sig.h"
 #include "libc/sysv/errfuns.h"
@@ -58,110 +54,111 @@ STATIC_YOINK("strsignal");  // for kprintf()
 
 #define SA_RESTORER 0x04000000
 
-#ifndef SWITCHEROO
-#define SWITCHEROO(S1, S2, A, B, C, D)                     \
-  do {                                                     \
-    autotype((S2).A) a = (typeof((S2).A))(S1).A;           \
-    autotype((S2).B) b = (typeof((S2).B))(S1).B;           \
-    autotype((S2).C) c = (typeof((S2).C))(S1).C;           \
-    typeof((S2).D) d;                                      \
-    bzero(&d, sizeof(d));                                  \
-    memcpy(&d, &((S1).D), MIN(sizeof(d), sizeof((S1).D))); \
-    (S2).A = a;                                            \
-    (S2).B = b;                                            \
-    (S2).C = c;                                            \
-    bzero(&((S2).D), sizeof((S2).D));                      \
-    memcpy(&((S2).D), &d, MIN(sizeof(d), sizeof((S2).D))); \
-  } while (0);
-#endif
-
-union metasigaction {
-  struct sigaction cosmo;
-  struct sigaction_linux linux;
-  struct sigaction_freebsd freebsd;
-  struct sigaction_openbsd openbsd;
-  struct sigaction_netbsd netbsd;
-  struct sigaction_xnu_in xnu_in;
-  struct sigaction_xnu_out xnu_out;
-};
-
-void __sigenter_xnu(int, struct siginfo *, void *) hidden;
-void __sigenter_linux(int, struct siginfo *, void *) hidden;
-void __sigenter_netbsd(int, struct siginfo *, void *) hidden;
-void __sigenter_freebsd(int, struct siginfo *, void *) hidden;
-void __sigenter_openbsd(int, struct siginfo *, void *) hidden;
-
 static void sigaction_cosmo2native(union metasigaction *sa) {
+  void *handler;
+  uint64_t flags;
+  void *restorer;
+  uint32_t mask[4];
   if (!sa) return;
-  switch (__hostos) {
-    case _HOSTLINUX:
-      SWITCHEROO(sa->cosmo, sa->linux, sa_handler, sa_flags, sa_restorer,
-                 sa_mask);
-      break;
-    case _HOSTXNU:
-      SWITCHEROO(sa->cosmo, sa->xnu_in, sa_handler, sa_flags, sa_restorer,
-                 sa_mask);
-      break;
-    case _HOSTFREEBSD:
-      SWITCHEROO(sa->cosmo, sa->freebsd, sa_handler, sa_flags, sa_flags,
-                 sa_mask);
-      break;
-    case _HOSTOPENBSD:
-      SWITCHEROO(sa->cosmo, sa->openbsd, sa_handler, sa_flags, sa_flags,
-                 sa_mask);
-      break;
-    case _HOSTNETBSD:
-      SWITCHEROO(sa->cosmo, sa->netbsd, sa_handler, sa_flags, sa_flags,
-                 sa_mask);
-      break;
-    default:
-      break;
+  flags = sa->cosmo.sa_flags;
+  handler = sa->cosmo.sa_handler;
+  restorer = sa->cosmo.sa_restorer;
+  mask[0] = sa->cosmo.sa_mask.__bits[0];
+  mask[1] = sa->cosmo.sa_mask.__bits[0] >> 32;
+  mask[2] = sa->cosmo.sa_mask.__bits[1];
+  mask[3] = sa->cosmo.sa_mask.__bits[1] >> 32;
+  if (IsLinux()) {
+    sa->linux.sa_flags = flags;
+    sa->linux.sa_handler = handler;
+    sa->linux.sa_restorer = restorer;
+    sa->linux.sa_mask[0] = mask[0];
+    sa->linux.sa_mask[1] = mask[1];
+  } else if (IsXnu()) {
+    sa->xnu_in.sa_flags = flags;
+    sa->xnu_in.sa_handler = handler;
+    sa->xnu_in.sa_restorer = restorer;
+    sa->xnu_in.sa_mask[0] = mask[0];
+  } else if (IsFreebsd()) {
+    sa->freebsd.sa_flags = flags;
+    sa->freebsd.sa_handler = handler;
+    sa->freebsd.sa_mask[0] = mask[0];
+    sa->freebsd.sa_mask[1] = mask[1];
+    sa->freebsd.sa_mask[2] = mask[2];
+    sa->freebsd.sa_mask[3] = mask[3];
+  } else if (IsOpenbsd()) {
+    sa->openbsd.sa_flags = flags;
+    sa->openbsd.sa_handler = handler;
+    sa->openbsd.sa_mask[0] = mask[0];
+  } else if (IsNetbsd()) {
+    sa->netbsd.sa_flags = flags;
+    sa->netbsd.sa_handler = handler;
+    sa->netbsd.sa_mask[0] = mask[0];
+    sa->netbsd.sa_mask[1] = mask[1];
+    sa->netbsd.sa_mask[2] = mask[2];
+    sa->netbsd.sa_mask[3] = mask[3];
   }
 }
 
 static void sigaction_native2cosmo(union metasigaction *sa) {
+  void *handler;
+  uint64_t flags;
+  void *restorer = 0;
+  uint32_t mask[4] = {0};
   if (!sa) return;
-  switch (__hostos) {
-    case _HOSTLINUX:
-      SWITCHEROO(sa->linux, sa->cosmo, sa_handler, sa_flags, sa_restorer,
-                 sa_mask);
-      break;
-    case _HOSTXNU:
-      SWITCHEROO(sa->xnu_out, sa->cosmo, sa_handler, sa_flags, sa_flags,
-                 sa_mask);
-      break;
-    case _HOSTFREEBSD:
-      SWITCHEROO(sa->freebsd, sa->cosmo, sa_handler, sa_flags, sa_flags,
-                 sa_mask);
-      break;
-    case _HOSTOPENBSD:
-      SWITCHEROO(sa->openbsd, sa->cosmo, sa_handler, sa_flags, sa_flags,
-                 sa_mask);
-      break;
-    case _HOSTNETBSD:
-      SWITCHEROO(sa->netbsd, sa->cosmo, sa_handler, sa_flags, sa_flags,
-                 sa_mask);
-      break;
-    default:
-      break;
+  if (IsLinux()) {
+    flags = sa->linux.sa_flags;
+    handler = sa->linux.sa_handler;
+    restorer = sa->linux.sa_restorer;
+    mask[0] = sa->linux.sa_mask[0];
+    mask[1] = sa->linux.sa_mask[1];
+  } else if (IsXnu()) {
+    flags = sa->xnu_out.sa_flags;
+    handler = sa->xnu_out.sa_handler;
+    mask[0] = sa->xnu_out.sa_mask[0];
+  } else if (IsFreebsd()) {
+    flags = sa->freebsd.sa_flags;
+    handler = sa->freebsd.sa_handler;
+    mask[0] = sa->freebsd.sa_mask[0];
+    mask[1] = sa->freebsd.sa_mask[1];
+    mask[2] = sa->freebsd.sa_mask[2];
+    mask[3] = sa->freebsd.sa_mask[3];
+  } else if (IsOpenbsd()) {
+    flags = sa->openbsd.sa_flags;
+    handler = sa->openbsd.sa_handler;
+    mask[0] = sa->openbsd.sa_mask[0];
+  } else if (IsNetbsd()) {
+    flags = sa->netbsd.sa_flags;
+    handler = sa->netbsd.sa_handler;
+    mask[0] = sa->netbsd.sa_mask[0];
+    mask[1] = sa->netbsd.sa_mask[1];
+    mask[2] = sa->netbsd.sa_mask[2];
+    mask[3] = sa->netbsd.sa_mask[3];
+  } else {
+    return;
   }
+  sa->cosmo.sa_flags = flags;
+  sa->cosmo.sa_handler = handler;
+  sa->cosmo.sa_restorer = restorer;
+  sa->cosmo.sa_mask.__bits[0] = mask[0] | (uint64_t)mask[1] << 32;
+  sa->cosmo.sa_mask.__bits[1] = mask[2] | (uint64_t)mask[3] << 32;
 }
 
 static int __sigaction(int sig, const struct sigaction *act,
                        struct sigaction *oldact) {
-  _Static_assert((sizeof(struct sigaction) > sizeof(struct sigaction_linux) &&
-                  sizeof(struct sigaction) > sizeof(struct sigaction_xnu_in) &&
-                  sizeof(struct sigaction) > sizeof(struct sigaction_xnu_out) &&
-                  sizeof(struct sigaction) > sizeof(struct sigaction_freebsd) &&
-                  sizeof(struct sigaction) > sizeof(struct sigaction_openbsd) &&
-                  sizeof(struct sigaction) > sizeof(struct sigaction_netbsd)),
-                 "sigaction cosmo abi needs tuning");
+  _Static_assert(
+      (sizeof(struct sigaction) >= sizeof(struct sigaction_linux) &&
+       sizeof(struct sigaction) >= sizeof(struct sigaction_xnu_in) &&
+       sizeof(struct sigaction) >= sizeof(struct sigaction_xnu_out) &&
+       sizeof(struct sigaction) >= sizeof(struct sigaction_freebsd) &&
+       sizeof(struct sigaction) >= sizeof(struct sigaction_openbsd) &&
+       sizeof(struct sigaction) >= sizeof(struct sigaction_netbsd)),
+      "sigaction cosmo abi needs tuning");
   int64_t arg4, arg5;
   int rc, rva, oldrva;
   sigaction_f sigenter;
   struct sigaction *ap, copy;
   if (IsMetal()) return enosys(); /* TODO: Signals on Metal */
-  if (!(0 < sig && sig < NSIG)) return einval();
+  if (!(1 <= sig && sig <= _NSIG)) return einval();
   if (sig == SIGKILL || sig == SIGSTOP) return einval();
   if (IsAsan() && ((act && !__asan_is_valid(act, sizeof(*act))) ||
                    (oldact && !__asan_is_valid(oldact, sizeof(*oldact))))) {
@@ -184,18 +181,23 @@ static int __sigaction(int sig, const struct sigaction *act,
     if (act) {
       memcpy(&copy, act, sizeof(copy));
       ap = &copy;
-      if (IsXnu()) {
+
+      if (IsLinux()) {
+        if (!(ap->sa_flags & SA_RESTORER)) {
+          ap->sa_flags |= SA_RESTORER;
+          ap->sa_restorer = &__restore_rt;
+        }
+        if (IsWsl1()) {
+          sigenter = __sigenter_wsl;
+        } else {
+          sigenter = ap->sa_sigaction;
+        }
+      } else if (IsXnu()) {
         ap->sa_restorer = (void *)&__sigenter_xnu;
         sigenter = __sigenter_xnu;
         // mitigate Rosetta signal handling strangeness
         // https://github.com/jart/cosmopolitan/issues/455
         ap->sa_flags |= SA_SIGINFO;
-      } else if (IsLinux()) {
-        if (!(ap->sa_flags & SA_RESTORER)) {
-          ap->sa_flags |= SA_RESTORER;
-          ap->sa_restorer = &__restore_rt;
-        }
-        sigenter = __sigenter_linux;
       } else if (IsNetbsd()) {
         sigenter = __sigenter_netbsd;
       } else if (IsFreebsd()) {

libc/calls/sigblockall.c

@@ -17,15 +17,10 @@
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/calls/struct/sigset.h"
+#include "libc/str/str.h"
 
-/**
- * Blocks all signals without strace logging.
- *
- * @param neu is new signal mask for process
- * @return old signal mask
- */
 sigset_t _sigblockall(void) {
   sigset_t ss;
-  sigfillset(&ss);
+  memset(&ss, -1, sizeof(ss));
   return _sigsetmask(ss);
 }

libc/calls/sigenter-freebsd.c

@@ -20,7 +20,6 @@
 #include "libc/calls/calls.h"
 #include "libc/calls/internal.h"
 #include "libc/calls/state.internal.h"
-#include "libc/calls/struct/sigaction-freebsd.internal.h"
 #include "libc/calls/struct/sigaction.h"
 #include "libc/calls/struct/siginfo-freebsd.internal.h"
 #include "libc/calls/struct/siginfo-meta.internal.h"
@@ -51,7 +50,7 @@ privileged void __sigenter_freebsd(int sig, struct siginfo_freebsd *freebsdinfo,
       g.uc.uc_stack.ss_sp = ctx->uc_stack.ss_sp;
       g.uc.uc_stack.ss_size = ctx->uc_stack.ss_size;
       g.uc.uc_stack.ss_flags = ctx->uc_stack.ss_flags;
-      __repmovsb(&g.uc.uc_sigmask, &ctx->uc_sigmask,
+      __repmovsb(&g.uc.uc_sigmask, ctx->uc_sigmask,
                  MIN(sizeof(g.uc.uc_sigmask), sizeof(ctx->uc_sigmask)));
       g.uc.uc_mcontext.r8 = ctx->uc_mcontext.mc_r8;
       g.uc.uc_mcontext.r9 = ctx->uc_mcontext.mc_r9;
@@ -82,7 +81,7 @@ privileged void __sigenter_freebsd(int sig, struct siginfo_freebsd *freebsdinfo,
       ctx->uc_stack.ss_size = g.uc.uc_stack.ss_size;
       ctx->uc_stack.ss_flags = g.uc.uc_stack.ss_flags;
       ctx->uc_flags = g.uc.uc_flags;
-      __repmovsb(&ctx->uc_sigmask, &g.uc.uc_sigmask,
+      __repmovsb(ctx->uc_sigmask, &g.uc.uc_sigmask,
                  MIN(sizeof(g.uc.uc_sigmask), sizeof(ctx->uc_sigmask)));
       ctx->uc_mcontext.mc_rdi = g.uc.uc_mcontext.rdi;
       ctx->uc_mcontext.mc_rsi = g.uc.uc_mcontext.rsi;

libc/calls/sigenter-linux.c

@@ -28,8 +28,7 @@
 #include "libc/str/str.h"
 #include "libc/sysv/consts/sa.h"
 
-privileged void __sigenter_linux(int sig, struct siginfo *info,
-                                 ucontext_t *ctx) {
+privileged void __sigenter_wsl(int sig, struct siginfo *info, ucontext_t *ctx) {
   int i, rva, flags;
   rva = __sighandrvas[sig & (NSIG - 1)];
   if (rva >= kSigactionMinRva) {

libc/calls/sigenter-netbsd.c

@@ -20,7 +20,6 @@
 #include "libc/calls/calls.h"
 #include "libc/calls/internal.h"
 #include "libc/calls/state.internal.h"
-#include "libc/calls/struct/sigaction-freebsd.internal.h"
 #include "libc/calls/struct/sigaction.h"
 #include "libc/calls/struct/siginfo-meta.internal.h"
 #include "libc/calls/struct/siginfo-netbsd.internal.h"
@@ -75,6 +74,11 @@ privileged void __sigenter_netbsd(int sig, struct siginfo_netbsd *si,
       uc.uc_mcontext.rsp = ctx->uc_mcontext.rsp;
       *uc.uc_mcontext.fpregs = ctx->uc_mcontext.__fpregs;
       ((sigaction_f)(_base + rva))(sig, &si2, &uc);
+      ctx->uc_stack.ss_sp = uc.uc_stack.ss_sp;
+      ctx->uc_stack.ss_size = uc.uc_stack.ss_size;
+      ctx->uc_stack.ss_flags = uc.uc_stack.ss_flags;
+      __repmovsb(&ctx->uc_sigmask, &uc.uc_sigmask,
+                 MIN(sizeof(uc.uc_sigmask), sizeof(ctx->uc_sigmask)));
       ctx->uc_mcontext.rdi = uc.uc_mcontext.rdi;
       ctx->uc_mcontext.rsi = uc.uc_mcontext.rsi;
       ctx->uc_mcontext.rdx = uc.uc_mcontext.rdx;

libc/calls/sigenter-openbsd.c

@@ -20,7 +20,6 @@
 #include "libc/calls/calls.h"
 #include "libc/calls/internal.h"
 #include "libc/calls/state.internal.h"
-#include "libc/calls/struct/sigaction-freebsd.internal.h"
 #include "libc/calls/struct/sigaction.h"
 #include "libc/calls/struct/siginfo-meta.internal.h"
 #include "libc/calls/struct/siginfo-openbsd.internal.h"
@@ -76,6 +75,7 @@ privileged void __sigenter_openbsd(int sig, struct siginfo_openbsd *openbsdinfo,
         *g.uc.uc_mcontext.fpregs = *ctx->sc_fpstate;
       }
       ((sigaction_f)(_base + rva))(sig, &g.si, &g.uc);
+      ctx->sc_mask = g.uc.uc_sigmask.__bits[0];
       ctx->sc_rdi = g.uc.uc_mcontext.rdi;
       ctx->sc_rsi = g.uc.uc_mcontext.rsi;
       ctx->sc_rdx = g.uc.uc_mcontext.rdx;

libc/calls/sigenter-xnu.c

@@ -501,6 +501,7 @@ privileged void __sigenter_xnu(void *fn, int infostyle, int sig,
         xnuctx->uc_stack.ss_sp = g.uc.uc_stack.ss_sp;
         xnuctx->uc_stack.ss_flags = g.uc.uc_stack.ss_flags;
         xnuctx->uc_stack.ss_size = g.uc.uc_stack.ss_size;
+        xnuctx->uc_sigmask = g.uc.uc_sigmask.__bits[0];
         if (xnuctx->uc_mcontext) {
           if (xnuctx->uc_mcsize >=
               sizeof(struct __darwin_x86_exception_state64)) {

libc/calls/sigprocmask.c

@@ -26,6 +26,7 @@
 #include "libc/intrin/asan.internal.h"
 #include "libc/intrin/describeflags.internal.h"
 #include "libc/intrin/strace.internal.h"
+#include "libc/intrin/weaken.h"
 #include "libc/str/str.h"
 #include "libc/sysv/consts/sig.h"
 #include "libc/sysv/errfuns.h"
@@ -59,7 +60,9 @@ int sigprocmask(int how, const sigset_t *opt_set, sigset_t *opt_out_oldset) {
     rc = efault();
   } else if (IsMetal() || IsWindows()) {
     rc = __sig_mask(how, opt_set, &old);
-    _check_interrupts(false, 0);
+    if (_weaken(__sig_check)) {
+      _weaken(__sig_check)(true);
+    }
   } else {
     rc = sys_sigprocmask(how, opt_set, opt_out_oldset ? &old : 0);
   }

libc/calls/sigsetmask.c

@@ -23,12 +23,6 @@
 #include "libc/dce.h"
 #include "libc/sysv/consts/sig.h"
 
-/**
- * Sets signal mask without strace logging.
- *
- * @param neu is new signal mask for process
- * @return old signal mask
- */
 sigset_t _sigsetmask(sigset_t neu) {
   sigset_t res;
   if (IsMetal() || IsWindows()) {

libc/calls/sigsuspend.c

@@ -17,6 +17,7 @@
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/calls/calls.h"
+#include "libc/calls/cp.internal.h"
 #include "libc/calls/internal.h"
 #include "libc/calls/sig.internal.h"
 #include "libc/calls/struct/sigset.h"
@@ -40,6 +41,7 @@
  * @param ignore is a bitset of signals to block temporarily, which if
  *     NULL is equivalent to passing an empty signal set
  * @return -1 w/ EINTR (or possibly EFAULT)
+ * @cancellationpoint
  * @asyncsignalsafe
  * @norestart
  */
@@ -48,6 +50,8 @@ int sigsuspend(const sigset_t *ignore) {
   long ms, totoms;
   sigset_t save, *arg, mask = {0};
   STRACE("sigsuspend(%s) → ...", DescribeSigset(0, ignore));
+  BEGIN_CANCELLATION_POINT;
+
   if (IsAsan() && ignore && !__asan_is_valid(ignore, sizeof(*ignore))) {
     rc = efault();
   } else if (IsXnu() || IsOpenbsd()) {
@@ -72,8 +76,7 @@ int sigsuspend(const sigset_t *ignore) {
       ms = 0;
       totoms = 0;
       do {
-        if (_check_interrupts(false, g_fds.p)) {
-          rc = eintr();
+        if ((rc = _check_interrupts(false, g_fds.p))) {
           break;
         }
         if (SleepEx(__SIG_POLLING_INTERVAL_MS, true) == kNtWaitIoCompletion) {
@@ -94,6 +97,8 @@ int sigsuspend(const sigset_t *ignore) {
     // TODO(jart): sigsuspend metal support
     rc = enosys();
   }
+
+  END_CANCELLATION_POINT;
   STRACE("...sigsuspend → %d% m", rc);
   return rc;
 }

libc/calls/sigtimedwait.c

@@ -17,6 +17,7 @@
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/calls/asan.internal.h"
+#include "libc/calls/cp.internal.h"
 #include "libc/calls/sigtimedwait.h"
 #include "libc/calls/sigtimedwait.internal.h"
 #include "libc/calls/struct/siginfo.internal.h"
@@ -36,10 +37,12 @@
  * @param timeout is relative deadline and null means wait forever
  * @return signal number on success, or -1 w/ errno
  * @raise EINTR if an asynchronous signal was delivered instead
+ * @raise ECANCELED if thread was cancelled in masked mode
  * @raise EINVAL if nanoseconds parameter was out of range
  * @raise EAGAIN if deadline expired
  * @raise ENOSYS on Windows, XNU, OpenBSD, Metal
  * @raise EFAULT if invalid memory was supplied
+ * @cancellationpoint
  */
 int sigtimedwait(const sigset_t *set, siginfo_t *info,
                  const struct timespec *timeout) {
@@ -47,6 +50,7 @@ int sigtimedwait(const sigset_t *set, siginfo_t *info,
   char strsig[15];
   struct timespec ts;
   union siginfo_meta si = {0};
+  BEGIN_CANCELLATION_POINT;
 
   if (IsAsan() && (!__asan_is_valid(set, sizeof(*set)) ||
                    (info && !__asan_is_valid(info, sizeof(*info))) ||
@@ -68,6 +72,7 @@ int sigtimedwait(const sigset_t *set, siginfo_t *info,
     rc = enosys();
   }
 
+  END_CANCELLATION_POINT;
   STRACE("sigtimedwait(%s, [%s], %s) → %s% m", DescribeSigset(0, set),
          DescribeSiginfo(rc, info), DescribeTimespec(0, timeout),
          strsignal_r(rc, strsig));

libc/calls/sigwaitinfo.c

@@ -25,8 +25,10 @@
  * @param info if not null shall receive info about signal
  * @return signal number on success, or -1 w/ errno
  * @raise EINTR if an asynchronous signal was delivered instead
+ * @raise ECANCELED if thread was cancelled in masked mode
  * @raise ENOSYS on OpenBSD, XNU, and Windows
  * @see sigtimedwait()
+ * @cancellationpoint
  */
 int sigwaitinfo(const sigset_t *mask, siginfo_t *si) {
   return sigtimedwait(mask, si, 0);

libc/calls/sleep.c

@@ -16,7 +16,9 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
+#include "libc/assert.h"
 #include "libc/calls/struct/timespec.h"
+#include "libc/errno.h"
 #include "libc/limits.h"
 #include "libc/sysv/consts/clock.h"
 #include "libc/time/time.h"
@@ -27,15 +29,20 @@
  * @return 0 if the full time elapsed, otherwise we assume an interrupt
  *     was delivered, in which case the errno condition is ignored, and
  *     this function shall return the number of unslept seconds rounded
- *     using the ceiling function
+ *     using the ceiling function, and finally `-1u` may be returned if
+ *     thread was cancelled with `PTHREAD_CANCEL_MASKED` in play
  * @see clock_nanosleep()
+ * @cancellationpoint
  * @asyncsignalsafe
  * @norestart
  */
 unsigned sleep(unsigned seconds) {
+  errno_t rc;
   unsigned unslept;
   struct timespec tv = {seconds};
-  if (!clock_nanosleep(CLOCK_REALTIME, 0, &tv, &tv)) return 0;
+  if (!(rc = clock_nanosleep(CLOCK_REALTIME, 0, &tv, &tv))) return 0;
+  if (rc == ECANCELED) return -1u;
+  _npassert(rc == EINTR);
   unslept = tv.tv_sec;
   if (tv.tv_nsec && unslept < UINT_MAX) {
     ++unslept;

libc/calls/statfs.c

@@ -17,22 +17,28 @@
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/calls/calls.h"
+#include "libc/calls/cp.internal.h"
 #include "libc/calls/state.internal.h"
-#include "libc/intrin/strace.internal.h"
 #include "libc/calls/struct/statfs-meta.internal.h"
 #include "libc/calls/struct/statfs.internal.h"
 #include "libc/calls/syscall_support-nt.internal.h"
 #include "libc/dce.h"
+#include "libc/intrin/strace.internal.h"
 #include "libc/runtime/stack.h"
 #include "libc/sysv/consts/at.h"
 
 /**
  * Returns information about filesystem.
  * @return 0 on success, or -1 w/ errno
+ * @raise ECANCELED if thread was cancelled in masked mode
+ * @raise EINTR if signal was delivered
+ * @cancellationpoint
  */
 int statfs(const char *path, struct statfs *sf) {
   int rc;
   union statfs_meta m;
+  BEGIN_CANCELLATION_POINT;
+
   CheckLargeStackAllocation(&m, sizeof(m));
   if (!IsWindows()) {
     if ((rc = sys_statfs(path, &m)) != -1) {
@@ -41,6 +47,8 @@ int statfs(const char *path, struct statfs *sf) {
   } else {
     rc = sys_statfs_nt(path, sf);
   }
+
+  END_CANCELLATION_POINT;
   STRACE("statfs(%#s, [%s]) → %d% m", path, DescribeStatfs(rc, sf));
   return rc;
 }

libc/calls/struct/rusage.h

@@ -26,7 +26,7 @@ struct rusage {
 int getrusage(int, struct rusage *);
 int wait3(int *, int, struct rusage *);
 int wait4(int, int *, int, struct rusage *);
-void _addrusage(struct rusage *, const struct rusage *);
+void rusage_add(struct rusage *, const struct rusage *);
 
 COSMOPOLITAN_C_END_
 #endif /* !(__ASSEMBLER__ + __LINKER__ + 0) */

libc/calls/struct/sigaction-freebsd.internal.h

@@ -1,16 +0,0 @@
-#ifndef COSMOPOLITAN_LIBC_CALLS_STRUCT_SIGACTION_FREEBSD_H_
-#define COSMOPOLITAN_LIBC_CALLS_STRUCT_SIGACTION_FREEBSD_H_
-#if !(__ASSEMBLER__ + __LINKER__ + 0)
-
-struct sigset_freebsd {
-  uint32_t sig[4];
-};
-
-struct sigaction_freebsd {
-  intptr_t sa_handler;
-  uint32_t sa_flags;
-  struct sigset_freebsd sa_mask;
-};
-
-#endif /* !(__ASSEMBLER__ + __LINKER__ + 0) */
-#endif /* COSMOPOLITAN_LIBC_CALLS_STRUCT_SIGACTION_FREEBSD_H_ */

libc/calls/struct/sigaction-linux.internal.h

@@ -1,17 +0,0 @@
-#ifndef COSMOPOLITAN_LIBC_CALLS_STRUCT_SIGACTION_LINUX_H_
-#define COSMOPOLITAN_LIBC_CALLS_STRUCT_SIGACTION_LINUX_H_
-#if !(__ASSEMBLER__ + __LINKER__ + 0)
-
-struct sigset_linux {
-  uint32_t sig[2];
-};
-
-struct sigaction_linux {
-  intptr_t sa_handler;
-  uint64_t sa_flags;
-  void (*sa_restorer)(void);
-  struct sigset_linux sa_mask;
-};
-
-#endif /* !(__ASSEMBLER__ + __LINKER__ + 0) */
-#endif /* COSMOPOLITAN_LIBC_CALLS_STRUCT_SIGACTION_LINUX_H_ */

libc/calls/struct/sigaction-netbsd.h

@@ -1,18 +0,0 @@
-#ifndef COSMOPOLITAN_LIBC_CALLS_STRUCT_SIGACTION_NETBSD_H_
-#define COSMOPOLITAN_LIBC_CALLS_STRUCT_SIGACTION_NETBSD_H_
-#if !(__ASSEMBLER__ + __LINKER__ + 0)
-COSMOPOLITAN_C_START_
-
-struct sigset_netbsd {
-  uint32_t sig[4];
-};
-
-struct sigaction_netbsd {
-  intptr_t sa_handler;
-  struct sigset_netbsd sa_mask;
-  uint32_t sa_flags;
-};
-
-COSMOPOLITAN_C_END_
-#endif /* !(__ASSEMBLER__ + __LINKER__ + 0) */
-#endif /* COSMOPOLITAN_LIBC_CALLS_STRUCT_SIGACTION_NETBSD_H_ */

libc/calls/struct/sigaction-openbsd.internal.h

@@ -1,16 +0,0 @@
-#ifndef COSMOPOLITAN_LIBC_CALLS_STRUCT_SIGACTION_OPENBSD_H_
-#define COSMOPOLITAN_LIBC_CALLS_STRUCT_SIGACTION_OPENBSD_H_
-#if !(__ASSEMBLER__ + __LINKER__ + 0)
-
-struct sigset_openbsd {
-  uint32_t sig[1];
-};
-
-struct sigaction_openbsd {
-  intptr_t sa_handler;
-  struct sigset_openbsd sa_mask;
-  int32_t sa_flags;
-};
-
-#endif /* !(__ASSEMBLER__ + __LINKER__ + 0) */
-#endif /* COSMOPOLITAN_LIBC_CALLS_STRUCT_SIGACTION_OPENBSD_H_ */

libc/calls/struct/sigaction-xnu.internal.h

@@ -1,27 +0,0 @@
-#ifndef COSMOPOLITAN_LIBC_CALLS_STRUCT_SIGACTION_XNU_H_
-#define COSMOPOLITAN_LIBC_CALLS_STRUCT_SIGACTION_XNU_H_
-#if !(__ASSEMBLER__ + __LINKER__ + 0)
-
-struct __darwin_ucontext;
-struct __darwin_siginfo;
-
-struct sigset_xnu {
-  uint32_t sig[1];
-};
-
-struct sigaction_xnu_in {
-  intptr_t sa_handler;
-  void (*sa_restorer)(void *, int, int, const struct __darwin_siginfo *,
-                      const struct __darwin_ucontext *);
-  struct sigset_xnu sa_mask;
-  int32_t sa_flags;
-};
-
-struct sigaction_xnu_out {
-  intptr_t sa_handler;
-  struct sigset_xnu sa_mask;
-  int32_t sa_flags;
-};
-
-#endif /* !(__ASSEMBLER__ + __LINKER__ + 0) */
-#endif /* COSMOPOLITAN_LIBC_CALLS_STRUCT_SIGACTION_XNU_H_ */

libc/calls/struct/sigaction.h

@@ -20,7 +20,6 @@ struct sigaction { /* cosmo abi */
   uint64_t sa_flags;
   void (*sa_restorer)(void);
   struct sigset sa_mask;
-  int64_t __pad;
 };
 
 sighandler_t signal(int, sighandler_t);

libc/calls/struct/sigaction.internal.h

@@ -1,10 +1,65 @@
 #ifndef COSMOPOLITAN_LIBC_CALLS_STRUCT_SIGACTION_INTERNAL_H_
 #define COSMOPOLITAN_LIBC_CALLS_STRUCT_SIGACTION_INTERNAL_H_
 #include "libc/calls/struct/sigaction.h"
+#include "libc/calls/struct/siginfo.h"
 #include "libc/mem/alloca.h"
 #if !(__ASSEMBLER__ + __LINKER__ + 0)
 COSMOPOLITAN_C_START_
 
+struct sigaction_linux {
+  void *sa_handler;
+  uint64_t sa_flags;
+  void *sa_restorer;
+  uint32_t sa_mask[2];
+};
+
+struct sigaction_freebsd {
+  void *sa_handler;
+  uint32_t sa_flags;
+  uint32_t sa_mask[4];
+};
+
+struct sigaction_openbsd {
+  void *sa_handler;
+  uint32_t sa_mask[1];
+  uint32_t sa_flags;
+};
+
+struct sigaction_netbsd {
+  void *sa_handler;
+  uint32_t sa_mask[4];
+  uint32_t sa_flags;
+};
+
+struct sigaction_xnu_in {
+  void *sa_handler;
+  void *sa_restorer;
+  uint32_t sa_mask[1];
+  uint32_t sa_flags;
+};
+
+struct sigaction_xnu_out {
+  void *sa_handler;
+  uint32_t sa_mask[1];
+  uint32_t sa_flags;
+};
+
+union metasigaction {
+  struct sigaction cosmo;
+  struct sigaction_linux linux;
+  struct sigaction_freebsd freebsd;
+  struct sigaction_openbsd openbsd;
+  struct sigaction_netbsd netbsd;
+  struct sigaction_xnu_in xnu_in;
+  struct sigaction_xnu_out xnu_out;
+};
+
+void __sigenter_xnu(int, struct siginfo *, void *) hidden;
+void __sigenter_wsl(int, struct siginfo *, void *) hidden;
+void __sigenter_netbsd(int, struct siginfo *, void *) hidden;
+void __sigenter_freebsd(int, struct siginfo *, void *) hidden;
+void __sigenter_openbsd(int, struct siginfo *, void *) hidden;
+
 const char *DescribeSigaction(char[256], int, const struct sigaction *);
 #define DescribeSigaction(rc, sa) DescribeSigaction(alloca(256), rc, sa)
 

libc/calls/struct/siginfo.internal.h

@@ -1,7 +1,5 @@
 #ifndef COSMOPOLITAN_LIBC_CALLS_STRUCT_SIGINFO_INTERNAL_H_
 #define COSMOPOLITAN_LIBC_CALLS_STRUCT_SIGINFO_INTERNAL_H_
-#include "libc/calls/struct/sigaction-xnu.internal.h"
-#include "libc/calls/struct/siginfo-xnu.internal.h"
 #include "libc/calls/struct/siginfo.h"
 #include "libc/mem/alloca.h"
 #if !(__ASSEMBLER__ + __LINKER__ + 0)

libc/calls/struct/timespec.h

@@ -3,8 +3,8 @@
 #if !(__ASSEMBLER__ + __LINKER__ + 0)
 COSMOPOLITAN_C_START_
 
-#define _timespec_zero ((struct timespec){0})
-#define _timespec_max  ((struct timespec){0x7fffffffffffffff, 999999999})
+#define timespec_zero ((struct timespec){0})
+#define timespec_max  ((struct timespec){0x7fffffffffffffff, 999999999})
 
 struct timespec {
   int64_t tv_sec;
@@ -21,22 +21,19 @@ int utimensat(int, const char *, const struct timespec[2], int);
 int timespec_get(struct timespec *, int);
 int timespec_getres(struct timespec *, int);
 
-int _timespec_cmp(struct timespec, struct timespec) pureconst;
-bool _timespec_eq(struct timespec, struct timespec) pureconst;
-bool _timespec_gt(struct timespec, struct timespec) pureconst;
-bool _timespec_gte(struct timespec, struct timespec) pureconst;
-int64_t _timespec_tomicros(struct timespec) pureconst;
-int64_t _timespec_tomillis(struct timespec) pureconst;
-int64_t _timespec_tonanos(struct timespec) pureconst;
-struct timespec _timespec_add(struct timespec, struct timespec) pureconst;
-struct timespec _timespec_fromnanos(int64_t) pureconst;
-struct timespec _timespec_frommicros(int64_t) pureconst;
-struct timespec _timespec_frommillis(int64_t) pureconst;
-struct timespec _timespec_real(void);
-struct timespec _timespec_mono(void);
-struct timespec _timespec_sleep(struct timespec);
-int _timespec_sleep_until(struct timespec);
-struct timespec _timespec_sub(struct timespec, struct timespec) pureconst;
+int timespec_cmp(struct timespec, struct timespec) pureconst;
+int64_t timespec_tomicros(struct timespec) pureconst;
+int64_t timespec_tomillis(struct timespec) pureconst;
+int64_t timespec_tonanos(struct timespec) pureconst;
+struct timespec timespec_add(struct timespec, struct timespec) pureconst;
+struct timespec timespec_fromnanos(int64_t) pureconst;
+struct timespec timespec_frommicros(int64_t) pureconst;
+struct timespec timespec_frommillis(int64_t) pureconst;
+struct timespec timespec_real(void);
+struct timespec timespec_mono(void);
+struct timespec timespec_sleep(struct timespec);
+int timespec_sleep_until(struct timespec);
+struct timespec timespec_sub(struct timespec, struct timespec) pureconst;
 
 COSMOPOLITAN_C_END_
 #endif /* !(__ASSEMBLER__ + __LINKER__ + 0) */

libc/calls/struct/timespec.internal.h

@@ -14,12 +14,13 @@ int sys_clock_gettime_nt(int, struct timespec *) hidden;
 int sys_clock_gettime_xnu(int, struct timespec *) hidden;
 int sys_clock_nanosleep(int, int, const struct timespec *, struct timespec *) hidden;
 int sys_clock_nanosleep_nt(int, int, const struct timespec *, struct timespec *) hidden;
-int sys_clock_nanosleep_xnu(int, int, const struct timespec *, struct timespec *) hidden;
 int sys_clock_nanosleep_openbsd(int, int, const struct timespec *, struct timespec *) hidden;
+int sys_clock_nanosleep_xnu(int, int, const struct timespec *, struct timespec *) hidden;
 int sys_futimens(int, const struct timespec[2]) hidden;
 int sys_nanosleep(const struct timespec *, struct timespec *) hidden;
 int sys_nanosleep_nt(const struct timespec *, struct timespec *) hidden;
 int sys_nanosleep_xnu(const struct timespec *, struct timespec *) hidden;
+int sys_sem_timedwait(int64_t, const struct timespec *) hidden;
 int sys_utimensat(int, const char *, const struct timespec[2], int) hidden;
 int sys_utimensat_nt(int, const char *, const struct timespec[2], int) hidden;
 int sys_utimensat_xnu(int, const char *, const struct timespec[2], int) hidden;

libc/calls/struct/timeval.h

@@ -16,14 +16,13 @@ int gettimeofday(struct timeval *, struct timezone *);
 int lutimes(const char *, const struct timeval[2]);
 int utimes(const char *, const struct timeval[2]);
 
-int _timeval_cmp(struct timeval, struct timeval) pureconst;
-bool _timeval_eq(struct timeval, struct timeval) pureconst;
-bool _timeval_gt(struct timeval, struct timeval) pureconst;
-bool _timeval_gte(struct timeval, struct timeval) pureconst;
-struct timeval _timeval_add(struct timeval, struct timeval) pureconst;
-struct timeval _timeval_sub(struct timeval, struct timeval) pureconst;
-struct timeval _timespec_totimeval(struct timespec) pureconst;
-struct timespec _timeval_totimespec(struct timeval) pureconst;
+int timeval_cmp(struct timeval, struct timeval) pureconst;
+struct timeval timeval_frommicros(int64_t) pureconst;
+struct timeval timeval_frommillis(int64_t) pureconst;
+struct timeval timeval_add(struct timeval, struct timeval) pureconst;
+struct timeval timeval_sub(struct timeval, struct timeval) pureconst;
+struct timeval timespec_totimeval(struct timespec) pureconst;
+struct timespec timeval_totimespec(struct timeval) pureconst;
 
 COSMOPOLITAN_C_END_
 #endif /* !(__ASSEMBLER__ + __LINKER__ + 0) */

libc/calls/struct/ucontext-freebsd.internal.h

@@ -1,6 +1,5 @@
 #ifndef COSMOPOLITAN_LIBC_CALLS_STRUCT_UCONTEXT_FREEBSD_INTERNAL_H_
 #define COSMOPOLITAN_LIBC_CALLS_STRUCT_UCONTEXT_FREEBSD_INTERNAL_H_
-#include "libc/calls/struct/sigaction-freebsd.internal.h"
 #if !(__ASSEMBLER__ + __LINKER__ + 0)
 COSMOPOLITAN_C_START_
 
@@ -52,7 +51,7 @@ struct mcontext_freebsd {
 };
 
 struct ucontext_freebsd {
-  struct sigset_freebsd uc_sigmask;
+  uint32_t uc_sigmask[4];
   struct mcontext_freebsd uc_mcontext;
   struct ucontext_freebsd *uc_link;
   struct stack_freebsd uc_stack;

libc/calls/syscall-sysv.internal.h

@@ -18,11 +18,13 @@ char *sys_getcwd_xnu(char *, u64) hidden;
 i32 __sys_dup3(i32, i32, i32) hidden;
 i32 __sys_execve(const char *, char *const[], char *const[]) hidden;
 i32 __sys_fcntl(i32, i32, ...) hidden;
+i32 __sys_fcntl_cp(i32, i32, ...) hidden;
 i32 __sys_fstat(i32, void *) hidden;
 i32 __sys_fstatat(i32, const char *, void *, i32) hidden;
 i32 __sys_gettid(i64 *) hidden;
 i32 __sys_munmap(void *, u64) hidden;
 i32 __sys_openat(i32, const char *, i32, u32) hidden;
+i32 __sys_openat_nc(i32, const char *, i32, u32) hidden;
 i32 __sys_pipe2(i32[hasatleast 2], u32) hidden;
 i32 sys_arch_prctl(i32, i64) hidden;
 i32 sys_chdir(const char *) hidden;
@@ -43,7 +45,7 @@ i32 sys_fchmod(i32, u32) hidden;
 i32 sys_fchmodat(i32, const char *, u32, u32) hidden;
 i32 sys_fchown(i64, u32, u32) hidden;
 i32 sys_fchownat(i32, const char *, u32, u32, u32) hidden;
-i32 sys_fcntl(i32, i32, u64) hidden;
+i32 sys_fcntl(i32, i32, u64, i32 (*)(i32, i32, ...)) hidden;
 i32 sys_fdatasync(i32) hidden;
 i32 sys_flock(i32, i32) hidden;
 i32 sys_fork(void) hidden;
@@ -59,6 +61,7 @@ i32 sys_getresuid(u32 *, u32 *, u32 *) hidden;
 i32 sys_getsid(i32) hidden;
 i32 sys_gettid(void) hidden;
 i32 sys_ioctl(i32, u64, ...) hidden;
+i32 sys_ioctl_cp(i32, u64, ...) hidden;
 i32 sys_issetugid(void) hidden;
 i32 sys_kill(i32, i32, i32) hidden;
 i32 sys_linkat(i32, const char *, i32, const char *, i32) hidden;
@@ -80,6 +83,15 @@ i32 sys_pivot_root(const char *, const char *) hidden;
 i32 sys_pledge(const char *, const char *) hidden;
 i32 sys_posix_openpt(i32) hidden;
 i32 sys_renameat(i32, const char *, i32, const char *) hidden;
+i32 sys_sem_close(i64) hidden;
+i32 sys_sem_destroy(i64) hidden;
+i32 sys_sem_getvalue(i64, u32 *) hidden;
+i32 sys_sem_init(u32, i64 *) hidden;
+i32 sys_sem_open(const char *, int, u32, i64 *) hidden;
+i32 sys_sem_post(i64) hidden;
+i32 sys_sem_trywait(i64) hidden;
+i32 sys_sem_unlink(const char *) hidden;
+i32 sys_sem_wait(i64) hidden;
 i32 sys_setfsgid(i32) hidden;
 i32 sys_setfsuid(i32) hidden;
 i32 sys_setgid(i32) hidden;

libc/calls/syscall_support-sysv.internal.h

@@ -10,21 +10,23 @@ bool __is_linux_2_6_23(void) hidden;
 bool32 sys_isatty_metal(int);
 int __fixupnewfd(int, int) hidden;
 int __notziposat(int, const char *);
+int __tkill(int, int, void *) hidden;
+int _fork(uint32_t) hidden;
+int _isptmaster(int) hidden;
+int _ptsname(int, char *, size_t) hidden;
 int getdomainname_linux(char *, size_t) hidden;
 int gethostname_bsd(char *, size_t, int) hidden;
 int gethostname_linux(char *, size_t) hidden;
 int gethostname_nt(char *, size_t, int) hidden;
 int sys_msyscall(void *, size_t);
 long sys_bogus(void);
+ssize_t __getrandom(void *, size_t, unsigned) hidden;
 void *__vdsosym(const char *, const char *) hidden;
 void __onfork(void) hidden;
 void __restore_rt() hidden;
 void __restore_rt_netbsd(void) hidden;
 void cosmo2flock(uintptr_t) hidden;
 void flock2cosmo(uintptr_t) hidden;
-int _ptsname(int, char *, size_t) hidden;
-int _isptmaster(int) hidden;
-int _fork(uint32_t) hidden;
 
 COSMOPOLITAN_C_END_
 #endif /* !(__ASSEMBLER__ + __LINKER__ + 0) */

libc/calls/sysinfo.c

@@ -40,7 +40,7 @@ static int64_t GetUptime(void) {
   size_t n = sizeof(x);
   int mib[] = {CTL_KERN, KERN_BOOTTIME};
   if (sys_sysctl(mib, ARRAYLEN(mib), &x, &n, 0, 0) == -1) return 0;
-  return _timespec_real().tv_sec - x.tv_sec;
+  return timespec_real().tv_sec - x.tv_sec;
 }
 
 static int64_t GetPhysmem(void) {

libc/calls/tcdrain.c

@@ -16,6 +16,7 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
+#include "libc/calls/cp.internal.h"
 #include "libc/calls/internal.h"
 #include "libc/calls/syscall-sysv.internal.h"
 #include "libc/calls/syscall_support-nt.internal.h"
@@ -27,6 +28,7 @@
 
 static textwindows int sys_tcdrain_nt(int fd) {
   if (!__isfdopen(fd)) return ebadf();
+  if (_check_interrupts(false, g_fds.p)) return -1;
   if (!FlushFileBuffers(g_fds.p[fd].handle)) return __winerr();
   return 0;
 }
@@ -39,18 +41,23 @@ static textwindows int sys_tcdrain_nt(int fd) {
  * @raise ENOTTY if `fd` is open but not a teletypewriter
  * @raise EIO if process group of writer is orphoned, calling thread is
  *     not blocking `SIGTTOU`, and process isn't ignoring `SIGTTOU`
+ * @raise ECANCELED if thread was cancelled in masked mode
+ * @raise EINTR if signal was delivered
  * @raise ENOSYS on bare metal
+ * @cancellationpoint
  * @asyncsignalsafe
  */
 int tcdrain(int fd) {
   int rc;
+  BEGIN_CANCELLATION_POINT;
   if (IsMetal()) {
     rc = enosys();
   } else if (!IsWindows()) {
-    rc = sys_ioctl(fd, TCSBRK, (void *)(intptr_t)1);
+    rc = sys_ioctl_cp(fd, TCSBRK, (void *)(intptr_t)1);
   } else {
     rc = sys_tcdrain_nt(fd);
   }
+  END_CANCELLATION_POINT;
   STRACE("tcdrain(%d) → %d% m", fd, rc);
   return rc;
 }

libc/calls/timespec_add.c

@@ -21,7 +21,7 @@
 /**
  * Adds two nanosecond timestamps.
  */
-struct timespec _timespec_add(struct timespec x, struct timespec y) {
+struct timespec timespec_add(struct timespec x, struct timespec y) {
   x.tv_sec += y.tv_sec;
   x.tv_nsec += y.tv_nsec;
   if (x.tv_nsec >= 1000000000) {