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

@@ -60,8 +60,8 @@
 #   build/config.mk
 
 SHELL      = build/bootstrap/cocmd.com
-HOSTS     ?= freebsd openbsd netbsd rhel7 rhel5 win10 xnu
-MAKEFLAGS += -j --no-builtin-rules
+HOSTS     ?= freebsd openbsd netbsd rhel7 rhel5 xnu win10 win10:31336
+MAKEFLAGS += --no-builtin-rules
 
 .SUFFIXES:
 .DELETE_ON_ERROR:
@@ -92,6 +92,7 @@ o/$(MODE):			\
 .UNVEIL =			\
 	libc/integral		\
 	libc/disclaimer.inc	\
+	rwc:/dev/shm		\
 	rx:build/bootstrap	\
 	rx:o/third_party/gcc	\
 	/proc/stat		\
@@ -127,6 +128,7 @@ include ape/ape.mk				# │
 include libc/fmt/fmt.mk				# │
 include libc/vga/vga.mk				#─┘
 include libc/calls/calls.mk			#─┐
+include third_party/getopt/getopt.mk		# │
 include libc/runtime/runtime.mk			# ├──SYSTEMS RUNTIME
 include libc/crt/crt.mk				# │  You can issue system calls
 include third_party/nsync/nsync.mk		# │
@@ -150,7 +152,6 @@ include dsp/mpeg/mpeg.mk			# │
 include dsp/dsp.mk				# │
 include third_party/zlib/gz/gz.mk		# │
 include third_party/musl/musl.mk		# │
-include third_party/getopt/getopt.mk		# │
 include libc/libc.mk				#─┘
 include libc/sock/sock.mk			#─┐
 include dsp/tty/tty.mk				# ├──ONLINE RUNTIME
@@ -171,6 +172,7 @@ include third_party/maxmind/maxmind.mk
 include net/finger/finger.mk
 include third_party/double-conversion/test/test.mk
 include third_party/lua/lua.mk
+include third_party/tr/tr.mk
 include third_party/sed/sed.mk
 include third_party/awk/awk.mk
 include third_party/make/make.mk

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 \
@@ -246,12 +246,16 @@ gdb foo.com -ex 'add-symbol-file foo.com.dbg 0x401000'
 | AMD             | K8 Venus    | 2005  |
 | Intel           | Core        | 2006  |
 | Linux           | 2.6.18      | 2007  |
-| Windows         | 8           | 2012  |
+| Windows         | 8 [1]       | 2012  |
 | Mac OS X        | 15.6        | 2018  |
 | OpenBSD         | 6.4         | 2018  |
 | FreeBSD         | 13          | 2020  |
 | NetBSD          | 9.2         | 2021  |
 
+[1] See our [vista branch](https://github.com/jart/cosmopolitan/tree/vista)
+    for a community supported version of Cosmopolitan that works on Windows
+    Vista and Windows 7.
+
 ## Special Thanks
 
 Funding for this project is crowdsourced using

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"
@@ -112,7 +113,15 @@ cstr:	.endobj	cstr,globl,hidden		# ←for gdb readability
 //
 //	@param	dl is drive number
 //	@noreturn
-ape_mz:	.asciz	"MZqFpD='\n"		# Mark 'Zibo' Joseph Zbikowski
+ape_mz:
+#if SupportsWindows() || SupportsMetal()
+	.asciz	"MZqFpD='\n"		# Mark 'Zibo' Joseph Zbikowski
+#else
+//	Avoid virus scanner reputation damage when targeting System Five.
+//	WARNING: This prefix is experimental; it may be removed sometime.
+//	TODO(jart): Find another prefix that will work with BIOS loading.
+	.asciz	"JTqFpD='\n"		# Mark 'Zibo' Joseph Zbikowski
+#endif
 	.short	0x1000			# MZ: lowers upper bound load / 16
 	.short	0xf800			# MZ: roll greed on bss
 	.short	0			# MZ: lower bound on stack segment
@@ -1557,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
@@ -1585,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/apeinstall.sh

@@ -1,6 +1,6 @@
 #!/bin/sh
 
-if [ $UID -eq 0 ]; then
+if [ "$(id -u)" -eq 0 ]; then
   SUDO=
 else
   SUDO=sudo
@@ -97,6 +97,8 @@ if [ x"$(uname -s)" = xLinux ]; then
   echo you may need to edit configs to persist across reboot >&2
   echo '$SUDO sh -c "echo '"'"':APE:M::MZqFpD::/usr/bin/ape:'"'"' >/proc/sys/fs/binfmt_misc/register"' >&2
   $SUDO sh -c "echo ':APE:M::MZqFpD::/usr/bin/ape:' >/proc/sys/fs/binfmt_misc/register" || exit
+  echo '$SUDO sh -c "echo '"'"':APE-sysv:M::JTqFpD::/usr/bin/ape:'"'"' >/proc/sys/fs/binfmt_misc/register"' >&2
+  $SUDO sh -c "echo ':APE-sysv:M::JTqFpD::/usr/bin/ape:' >/proc/sys/fs/binfmt_misc/register" || exit
   echo done >&2
 
   if [ x"$(cat /proc/sys/fs/binfmt_misc/status)" = xdisabled ]; then

ape/apeuninstall.sh

@@ -11,6 +11,7 @@ fi
   echo "APE Uninstaller intends to run"
   echo
   echo "    $SUDO sh -c 'echo -1 >/proc/sys/fs/binfmt_misc/APE'"
+  echo "    $SUDO sh -c 'echo -1 >/proc/sys/fs/binfmt_misc/APE-sysv'"
   echo "    $SUDO rm -f /usr/bin/ape ~/.ape o/tmp/.ape /tmp/.ape"
   echo
   echo "You may then use ape/apeinstall.sh to reinstall it"
@@ -21,4 +22,7 @@ set -ex
 if [ -f /proc/sys/fs/binfmt_misc/APE ]; then
   $SUDO sh -c 'echo -1 >/proc/sys/fs/binfmt_misc/APE' || exit
 fi
+if [ -f /proc/sys/fs/binfmt_misc/APE-sysv ]; then
+  $SUDO sh -c 'echo -1 >/proc/sys/fs/binfmt_misc/APE-sysv' || exit
+fi
 $SUDO rm -f /usr/bin/ape ~/.ape o/tmp/.ape o/tmp/ape /tmp/.ape /tmp/ape || exit

ape/sections.internal.h

@@ -0,0 +1,34 @@
+#ifndef COSMOPOLITAN_APE_SECTIONS_INTERNAL_H_
+#define COSMOPOLITAN_APE_SECTIONS_INTERNAL_H_
+#if !(__ASSEMBLER__ + __LINKER__ + 0)
+COSMOPOLITAN_C_START_
+
+extern unsigned char _base[];
+extern unsigned char _ehead[];
+extern unsigned char _etext[];
+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[];
+extern unsigned char __privileged_end[];
+extern unsigned char __test_start[];
+extern unsigned char __ro[];
+extern unsigned char *__relo_start[];
+extern unsigned char *__relo_end[];
+extern uint8_t __zip_start[];
+extern uint8_t __zip_end[];
+extern uint8_t __data_start[];
+extern uint8_t __data_end[];
+extern uint8_t __bss_start[];
+extern uint8_t __bss_end[];
+
+COSMOPOLITAN_C_END_
+#endif /* !(__ASSEMBLER__ + __LINKER__ + 0) */
+#endif /* COSMOPOLITAN_APE_SECTIONS_INTERNAL_H_ */

build/config.mk

@@ -29,7 +29,7 @@ endif
 #
 ifeq ($(MODE),fastbuild)
 CONFIG_CCFLAGS += $(BACKTRACES) $(FTRACE) -O
-CONFIG_CPPFLAGS += -DSYSDEBUG
+CONFIG_CPPFLAGS += -DSYSDEBUG -DDWARFLESS
 CONFIG_OFLAGS += -g0
 CONFIG_LDFLAGS += -S
 TARGET_ARCH ?= -msse3
@@ -125,6 +125,22 @@ TARGET_ARCH ?= -msse3
 OVERRIDE_CCFLAGS += -fno-pie
 endif
 
+# System Five Mode
+#
+#   - `make MODE=sysv`
+#   - Optimized
+#   - Backtraces
+#   - Debuggable
+#   - Syscall tracing
+#   - Function tracing
+#   - No Windows bloat!
+#
+ifeq ($(MODE), sysv)
+CONFIG_CCFLAGS += $(BACKTRACES) $(FTRACE) -O2
+CONFIG_CPPFLAGS += -DSYSDEBUG -DSUPPORT_VECTOR=121
+TARGET_ARCH ?= -msse3
+endif
+
 # Tiny Mode
 #
 #   - `make MODE=tiny`
@@ -151,7 +167,8 @@ CONFIG_CCFLAGS +=			\
 	-fschedule-insns2		\
 	-fomit-frame-pointer		\
 	-momit-leaf-frame-pointer	\
-	-foptimize-sibling-calls
+	-foptimize-sibling-calls	\
+	-DDWARFLESS
 CONFIG_OFLAGS +=			\
 	-g0
 CONFIG_LDFLAGS +=			\
@@ -181,7 +198,8 @@ CONFIG_CPPFLAGS +=			\
 	-DTINY				\
 	-DNDEBUG			\
 	-DTRUSTWORTHY			\
-	-DSUPPORT_VECTOR=1
+	-DSUPPORT_VECTOR=1		\
+	-DDWARFLESS
 DEFAULT_COPTS +=			\
 	-mred-zone
 CONFIG_OFLAGS +=			\
@@ -217,7 +235,8 @@ CONFIG_CPPFLAGS +=		\
 	-DTINY			\
 	-DNDEBUG		\
 	-DTRUSTWORTHY		\
-	-DSUPPORT_VECTOR=113
+	-DSUPPORT_VECTOR=113	\
+	-DDWARFLESS
 DEFAULT_COPTS +=		\
 	-mred-zone
 CONFIG_OFLAGS +=		\
@@ -252,7 +271,8 @@ CONFIG_CPPFLAGS +=		\
 	-DTINY			\
 	-DNDEBUG		\
 	-DTRUSTWORTHY		\
-	-DSUPPORT_VECTOR=121
+	-DSUPPORT_VECTOR=121	\
+	-DDWARFLESS
 DEFAULT_COPTS +=		\
 	-mred-zone
 CONFIG_CCFLAGS +=		\
@@ -287,7 +307,8 @@ CONFIG_CPPFLAGS +=		\
 	-DTINY			\
 	-DNDEBUG		\
 	-DTRUSTWORTHY		\
-	-DSUPPORT_VECTOR=251
+	-DSUPPORT_VECTOR=251	\
+	-DDWARFLESS
 CONFIG_CCFLAGS +=		\
 	-Os			\
 	-fno-align-functions	\

examples/auto-memory-safety-crash2.c

@@ -7,12 +7,12 @@
 │   • http://creativecommons.org/publicdomain/zero/1.0/            │
 ╚─────────────────────────────────────────────────────────────────*/
 #endif
-#include "libc/intrin/bits.h"
 #include "libc/dce.h"
+#include "libc/intrin/bits.h"
+#include "libc/intrin/kprintf.h"
 #include "libc/log/log.h"
 #include "libc/mem/mem.h"
 #include "libc/runtime/runtime.h"
-#include "libc/stdio/stdio.h"
 #include "libc/str/str.h"
 
 /**
@@ -59,9 +59,15 @@
 
 int main(int argc, char *argv[]) {
   if (!IsAsan()) {
-    printf("this example is intended for MODE=asan or MODE=dbg\n");
+    kprintf("this example is intended for MODE=asan or MODE=dbg\n");
     exit(1);
   }
+
+  kprintf("----------------\n");
+  kprintf(" THIS IS A TEST \n");
+  kprintf("SIMULATING CRASH\n");
+  kprintf("----------------\n");
+
   char *buffer;
   ShowCrashReports(); /* not needed but yoinks appropriate symbols */
   buffer = malloc(13);

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/crashreport.c

@@ -7,6 +7,7 @@
 │   • http://creativecommons.org/publicdomain/zero/1.0/            │
 ╚─────────────────────────────────────────────────────────────────*/
 #endif
+#include "libc/intrin/kprintf.h"
 #include "libc/log/log.h"
 #include "libc/runtime/symbols.internal.h"
 
@@ -24,6 +25,12 @@
  */
 
 noubsan int main(int argc, char *argv[]) {
+
+  kprintf("----------------\n");
+  kprintf(" THIS IS A TEST \n");
+  kprintf("SIMULATING CRASH\n");
+  kprintf("----------------\n");
+
   volatile int64_t x;
   ShowCrashReports();
   return 1 / (x = 0);

examples/examples.mk

@@ -49,12 +49,12 @@ EXAMPLES_DIRECTDEPS =								\
 	LIBC_LOG								\
 	LIBC_MEM								\
 	LIBC_NEXGEN32E								\
+	LIBC_NT_ADVAPI32							\
 	LIBC_NT_IPHLPAPI							\
 	LIBC_NT_KERNEL32							\
 	LIBC_NT_NTDLL								\
 	LIBC_NT_USER32								\
 	LIBC_NT_WS2_32								\
-	LIBC_NT_ADVAPI32							\
 	LIBC_RUNTIME								\
 	LIBC_SOCK								\
 	LIBC_STDIO								\
@@ -71,6 +71,7 @@ EXAMPLES_DIRECTDEPS =								\
 	LIBC_ZIPOS								\
 	NET_HTTP								\
 	NET_HTTPS								\
+	THIRD_PARTY_AWK								\
 	THIRD_PARTY_COMPILER_RT							\
 	THIRD_PARTY_DLMALLOC							\
 	THIRD_PARTY_DOUBLECONVERSION						\
@@ -84,7 +85,9 @@ EXAMPLES_DIRECTDEPS =								\
 	THIRD_PARTY_NSYNC							\
 	THIRD_PARTY_NSYNC_MEM							\
 	THIRD_PARTY_QUICKJS							\
+	THIRD_PARTY_SED								\
 	THIRD_PARTY_STB								\
+	THIRD_PARTY_TR								\
 	THIRD_PARTY_XED								\
 	THIRD_PARTY_ZLIB							\
 	TOOL_BUILD_LIB								\
@@ -143,6 +146,25 @@ o/$(MODE)/examples/nesemu1.com.dbg:						\
 		$(EXAMPLES_BOOTLOADER)
 	@$(APELINK)
 
+# # force symtab.com to be a zip file, by pulling a zip asset into linkage
+# # we wouldn't need to do this if we depended on functions like localtime
+# o/$(MODE)/examples/symtab.com.dbg:						\
+# 		$(EXAMPLES_DEPS)						\
+# 		o/$(MODE)/examples/symtab.o					\
+# 		o/$(MODE)/examples/symtab.c.zip.o				\
+# 		o/$(MODE)/examples/examples.pkg					\
+# 		$(EXAMPLES_BOOTLOADER)
+# 	@$(APELINK)
+
+# modify .com so it can read the symbol table without needing the .com.dbg file
+o/$(MODE)/examples/symtab.com:							\
+		o/$(MODE)/examples/symtab.com.dbg				\
+		o/$(MODE)/third_party/zip/zip.com				\
+		o/$(MODE)/tool/build/symtab.com
+	@$(MAKE_OBJCOPY)
+	@$(MAKE_SYMTAB_CREATE)
+	@$(MAKE_SYMTAB_ZIP)
+
 o/$(MODE)/examples/picol.o: private				\
 		OVERRIDE_CPPFLAGS +=				\
 			-DSTACK_FRAME_UNLIMITED

examples/getrandom.c

@@ -7,6 +7,7 @@
 │   • http://creativecommons.org/publicdomain/zero/1.0/            │
 ╚─────────────────────────────────────────────────────────────────*/
 #endif
+#include "ape/sections.internal.h"
 #include "libc/calls/calls.h"
 #include "libc/calls/struct/sigaction.h"
 #include "libc/errno.h"

examples/nesemu1.cc

@@ -47,7 +47,7 @@
 #include "third_party/libcxx/vector"
 #include "tool/viz/lib/knobs.h"
 
-STATIC_YOINK("zip_uri_support");
+STATIC_YOINK("zipos");
 
 #define USAGE \
   " [ROM] [FMV]\n\

examples/nomodifyself.c

@@ -7,6 +7,7 @@
 │   • http://creativecommons.org/publicdomain/zero/1.0/            │
 ╚─────────────────────────────────────────────────────────────────*/
 #endif
+#include "ape/sections.internal.h"
 #include "libc/dce.h"
 #include "libc/runtime/runtime.h"
 #include "libc/stdio/stdio.h"

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);
+  }
+}

examples/symtab.c

@@ -0,0 +1,42 @@
+#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/intrin/kprintf.h"
+#include "libc/log/log.h"
+
+/**
+ * @fileoverview example of how to embed symbol table in .com file
+ *
+ *     # build our binary
+ *     make -j16 o//examples/symtab.com
+ *
+ *     # move binary somewhere else
+ *     # so it can't find the .com.dbg binary
+ *     cp o//examples/symtab.com /tmp
+ *
+ *     # run program
+ *     # notice that it has a symbolic backtrace
+ *     /tmp/symtab.com
+ *
+ * @see examples/examples.mk
+ */
+
+int main(int argc, char *argv[]) {
+
+  // this links all the debugging and zip functionality
+  ShowCrashReports();
+
+  kprintf("----------------\n");
+  kprintf(" THIS IS A TEST \n");
+  kprintf("SIMULATING CRASH\n");
+  kprintf("----------------\n");
+
+  volatile int64_t x;
+  return 1 / (x = 0);
+}

examples/system.c

@@ -7,13 +7,20 @@
 │   • http://creativecommons.org/publicdomain/zero/1.0/            │
 ╚─────────────────────────────────────────────────────────────────*/
 #endif
-#include "libc/dce.h"
+#include "libc/runtime/runtime.h"
 #include "libc/stdio/stdio.h"
 
+/**
+ * @fileoverview Cosmopolitan Command Interpreter Demo
+ * Yes this works on Windows.
+ */
+
+STATIC_YOINK("_tr");
+STATIC_YOINK("_sed");
+
 int main(int argc, char *argv[]) {
-  if (IsWindows()) {
-    system("notepad");
-  } else {
-    system("ls | tr a-z A-Z");
-  }
+  system("x=world\n"
+         "echo hello $x |\n"
+         "  tr a-z A-Z |\n"
+         "  sed 's/\\(.\\)/\\1 /g'");
 }

libc/assert.h

@@ -17,7 +17,7 @@ void __assert_fail(const char *, const char *, int) hidden relegated;
 #endif
 
 #ifdef __GNUC__
-#ifndef TINY
+#if !defined(TINY) && !defined(MODE_DBG)
 /**
  * Specifies expression can't possibly be false.
  *

libc/calls/__sig2.c

@@ -16,6 +16,7 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
+#include "ape/sections.internal.h"
 #include "libc/assert.h"
 #include "libc/calls/calls.h"
 #include "libc/calls/sig.internal.h"
@@ -107,7 +108,6 @@ static bool __sig_deliver(bool restartable, int sig, int si_code,
   STRACE("delivering %G", sig);
 
   // enter the signal
-  __sig_lock();
   rva = __sighandrvas[sig];
   flags = __sighandflags[sig];
   if ((~flags & SA_NODEFER) || (flags & SA_RESETHAND)) {
@@ -118,7 +118,6 @@ static bool __sig_deliver(bool restartable, int sig, int si_code,
     // signal handler. in that case you must use SA_NODEFER.
     __sighandrvas[sig] = (int32_t)(intptr_t)SIG_DFL;
   }
-  __sig_unlock();
 
   // setup the somewhat expensive information args
   // only if they're requested by the user in sigaction()
@@ -140,11 +139,9 @@ static bool __sig_deliver(bool restartable, int sig, int si_code,
     // since sigaction() is @asyncsignalsafe we only restore it if the
     // user didn't change it during the signal handler. we also don't
     // need to do anything if this was a oneshot signal or nodefer.
-    __sig_lock();
     if (__sighandrvas[sig] == (int32_t)(intptr_t)SIG_DFL) {
       __sighandrvas[sig] = rva;
     }
-    __sig_unlock();
   }
 
   if (!restartable) {
@@ -207,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 {
@@ -227,12 +225,12 @@ textwindows int __sig_add(int tid, int sig, int si_code) {
   int rc;
   struct Signal *mem;
   if (1 <= sig && sig <= 64) {
-    __sig_lock();
     if (__sighandrvas[sig] == (unsigned)(intptr_t)SIG_IGN) {
       STRACE("ignoring %G", sig);
       rc = 0;
     } else {
       STRACE("enqueuing %G", sig);
+      __sig_lock();
       ++__sig_count;
       if ((mem = __sig_alloc())) {
         mem->tid = tid;
@@ -244,8 +242,8 @@ textwindows int __sig_add(int tid, int sig, int si_code) {
       } else {
         rc = enomem();
       }
+      __sig_unlock();
     }
-    __sig_unlock();
   } else {
     rc = einval();
   }

libc/calls/__sig_mask.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/sig.internal.h"
+#include "libc/calls/struct/sigset.h"
 #include "libc/sysv/consts/sig.h"
 #include "libc/sysv/errfuns.h"
 #include "libc/thread/tls.h"
@@ -45,7 +47,10 @@ textwindows int __sig_mask(int how, const sigset_t *neu, sigset_t *old) {
       } else {
         x = y;
       }
-      x &= ~(GetSigBit(SIGKILL) | GetSigBit(SIGSTOP) | GetSigBit(SIGABRT));
+      x &= ~(0
+#define M(x) | GetSigBit(x)
+#include "libc/intrin/sigisprecious.inc"
+      );
       *mask = x;
     }
     return 0;

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

@@ -0,0 +1,19 @@
+#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_
+
+#define BLOCK_SIGNALS  \
+  do {                 \
+    sigset_t _SigMask; \
+  _SigMask = _sigblockall()
+
+#define ALLOW_SIGNALS    \
+  _sigsetmask(_SigMask); \
+  }                      \
+  while (0)
+
+COSMOPOLITAN_C_END_
+#endif /* !(__ASSEMBLER__ + __LINKER__ + 0) */
+#endif /* COSMOPOLITAN_LIBC_CALLS_BLOCKSIGS_H_ */

libc/calls/calls.h

@@ -65,13 +65,13 @@ char *ttyname(int);
 int access(const char *, int) dontthrow;
 int arch_prctl();
 int chdir(const char *);
-int chmod(const char *, uint32_t);
-int chown(const char *, uint32_t, uint32_t);
+int chmod(const char *, unsigned);
+int chown(const char *, unsigned, unsigned);
 int chroot(const char *);
 int close(int);
 int close_range(unsigned, unsigned, unsigned);
 int closefrom(int);
-int creat(const char *, uint32_t);
+int creat(const char *, unsigned);
 int dup(int);
 int dup2(int, int);
 int dup3(int, int, int);
@@ -84,25 +84,22 @@ int execv(const char *, char *const[]);
 int execve(const char *, char *const[], char *const[]);
 int execvp(const char *, char *const[]);
 int execvpe(const char *, char *const[], char *const[]);
-int fexecve(int, char *const[], char *const[]);
 int faccessat(int, const char *, int, int);
 int fadvise(int, uint64_t, uint64_t, int);
 int fchdir(int);
-int fchmod(int, uint32_t) dontthrow;
-int fchmodat(int, const char *, uint32_t, int);
-int fchown(int, uint32_t, uint32_t);
-int fchownat(int, const char *, uint32_t, uint32_t, int);
+int fchmod(int, unsigned) dontthrow;
+int fchmodat(int, const char *, unsigned, int);
+int fchown(int, unsigned, unsigned);
+int fchownat(int, const char *, unsigned, unsigned, int);
 int fcntl(int, int, ...);
 int fdatasync(int);
+int fexecve(int, char *const[], char *const[]);
 int flock(int, int);
 int fork(void);
 int fsync(int);
 int ftruncate(int, int64_t);
 int getdomainname(char *, size_t);
-uint32_t getegid(void) nosideeffect;
-uint32_t geteuid(void) nosideeffect;
-uint32_t getgid(void) nosideeffect;
-int getgroups(int size, uint32_t list[]);
+int getgroups(int, unsigned[]);
 int gethostname(char *, size_t);
 int getloadavg(double *, int);
 int getpgid(int) libcesque;
@@ -110,36 +107,29 @@ int getpgrp(void) nosideeffect;
 int getpid(void) nosideeffect libcesque;
 int getppid(void);
 int getpriority(int, unsigned);
-int getresgid(uint32_t *, uint32_t *, uint32_t *);
-int getresuid(uint32_t *, uint32_t *, uint32_t *);
+int getresgid(unsigned *, unsigned *, unsigned *);
+int getresuid(unsigned *, unsigned *, unsigned *);
 int getsid(int) nosideeffect libcesque;
 int gettid(void) libcesque;
-uint32_t getuid(void) libcesque;
-int sys_iopl(int);
 int ioprio_get(int, int);
 int ioprio_set(int, int, int);
 int issetugid(void);
 int kill(int, int);
 int killpg(int, int);
-int lchmod(const char *, uint32_t);
-int lchown(const char *, uint32_t, uint32_t);
+int lchmod(const char *, unsigned);
+int lchown(const char *, unsigned, unsigned);
 int link(const char *, const char *) dontthrow;
 int linkat(int, const char *, int, const char *, int);
 int madvise(void *, uint64_t, int);
+int makedirs(const char *, unsigned);
 int memfd_create(const char *, unsigned int);
 int mincore(void *, size_t, unsigned char *);
 int mkdir(const char *, unsigned);
 int mkdirat(int, const char *, unsigned);
-int makedirs(const char *, unsigned);
-int mkfifo(const char *, uint32_t);
-int mkfifoat(int, const char *, uint32_t);
-int mknod(const char *, uint32_t, uint64_t);
-int mknodat(int, const char *, int32_t, uint64_t);
-int sys_mlock(const void *, size_t);
-int sys_mlock2(const void *, size_t, int);
-int sys_mlockall(int);
-int sys_munlock(const void *, size_t);
-int sys_munlockall(void);
+int mkfifo(const char *, unsigned);
+int mkfifoat(int, const char *, unsigned);
+int mknod(const char *, unsigned, uint64_t);
+int mknodat(int, const char *, int, uint64_t);
 int nice(int);
 int open(const char *, int, ...);
 int openat(int, const char *, int, ...);
@@ -161,19 +151,19 @@ int renameat2(long, const char *, long, const char *, int);
 int rmdir(const char *);
 int sched_yield(void);
 int seccomp(unsigned, unsigned, void *);
-int setegid(uint32_t);
-int seteuid(uint32_t);
+int setegid(unsigned);
+int seteuid(unsigned);
 int setfsgid(unsigned);
 int setfsuid(unsigned);
 int setgid(unsigned);
-int setgroups(size_t, const uint32_t[]);
+int setgroups(size_t, const unsigned[]);
 int setpgid(int, int);
 int setpgrp(void);
 int setpriority(int, unsigned, int);
-int setregid(uint32_t, uint32_t);
-int setresgid(uint32_t, uint32_t, uint32_t);
-int setresuid(uint32_t, uint32_t, uint32_t);
-int setreuid(uint32_t, uint32_t);
+int setregid(unsigned, unsigned);
+int setresgid(unsigned, unsigned, unsigned);
+int setresuid(unsigned, unsigned, unsigned);
+int setreuid(unsigned, unsigned);
 int setsid(void);
 int setuid(unsigned);
 int sigignore(int);
@@ -181,16 +171,22 @@ int siginterrupt(int, int);
 int symlink(const char *, const char *);
 int symlinkat(const char *, int, const char *);
 int sync_file_range(int, int64_t, int64_t, unsigned);
+int sys_iopl(int);
+int sys_mlock(const void *, size_t);
+int sys_mlock2(const void *, size_t, int);
+int sys_mlockall(int);
+int sys_munlock(const void *, size_t);
+int sys_munlockall(void);
 int sys_ptrace(int, ...);
 int sys_sysctl(const int *, unsigned, void *, size_t *, void *, size_t);
-int tcsetpgrp(int, int32_t);
+int tcgetpgrp(int);
+int tcsetpgrp(int, int);
 int tgkill(int, int, int);
 int tkill(int, int);
 int tmpfd(void);
-int touch(const char *, uint32_t);
+int touch(const char *, unsigned);
 int truncate(const char *, int64_t);
 int ttyname_r(int, char *, size_t);
-unsigned umask(unsigned);
 int unlink(const char *);
 int unlink_s(const char **);
 int unlinkat(int, const char *, int);
@@ -199,11 +195,10 @@ int usleep(unsigned);
 int vfork(void) returnstwice;
 int wait(int *);
 int waitpid(int, int *, int);
-int32_t tcgetpgrp(int);
 intptr_t syscall(int, ...);
 long ptrace(int, ...);
-ssize_t copy_file_range(int, long *, int, long *, size_t, uint32_t);
-ssize_t copyfd(int, int64_t *, int, int64_t *, size_t, uint32_t);
+ssize_t copy_file_range(int, long *, int, long *, size_t, unsigned);
+ssize_t copyfd(int, int64_t *, int, int64_t *, size_t, unsigned);
 ssize_t getfiledescriptorsize(int);
 ssize_t lseek(int, int64_t, int);
 ssize_t pread(int, void *, size_t, int64_t);
@@ -212,8 +207,13 @@ ssize_t read(int, void *, size_t);
 ssize_t readansi(int, char *, size_t);
 ssize_t readlink(const char *, char *, size_t);
 ssize_t readlinkat(int, const char *, char *, size_t);
-ssize_t splice(int, int64_t *, int, int64_t *, size_t, uint32_t);
+ssize_t splice(int, int64_t *, int, int64_t *, size_t, unsigned);
 ssize_t write(int, const void *, size_t);
+unsigned getegid(void) nosideeffect;
+unsigned geteuid(void) nosideeffect;
+unsigned getgid(void) nosideeffect;
+unsigned getuid(void) libcesque;
+unsigned umask(unsigned);
 void sync(void);
 
 COSMOPOLITAN_C_END_

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/cfgetispeed.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 2021 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/termios.h"
-#include "libc/sysv/consts/termios.h"
-
-uint32_t cfgetispeed(const struct termios *t) {
-  if (CBAUD) {
-    return t->c_cflag & CBAUD;
-  } else {
-    return t->c_ispeed;
-  }
-}

libc/calls/cfgetospeed.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 2021 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/termios.h"
-#include "libc/sysv/consts/termios.h"
-
-uint32_t cfgetospeed(const struct termios *t) {
-  if (CBAUD) {
-    return t->c_cflag & CBAUD;
-  } else {
-    return t->c_ospeed;
-  }
-}

libc/calls/cfspeed.c

@@ -20,6 +20,58 @@
 #include "libc/sysv/consts/termios.h"
 #include "libc/sysv/errfuns.h"
 
+/**
+ * Returns input baud rate.
+ * @asyncsignalsafe
+ */
+uint32_t cfgetispeed(const struct termios *t) {
+  if (CBAUD) {
+    return t->c_cflag & CBAUD;
+  } else {
+    return t->c_ispeed;
+  }
+}
+
+/**
+ * Returns output baud rate.
+ * @asyncsignalsafe
+ */
+uint32_t cfgetospeed(const struct termios *t) {
+  if (CBAUD) {
+    return t->c_cflag & CBAUD;
+  } else {
+    return t->c_ospeed;
+  }
+}
+
+/**
+ * Sets input baud rate.
+ *
+ * @return 0 on success, or -1 w/ errno
+ * @asyncsignalsafe
+ */
+int cfsetispeed(struct termios *t, unsigned speed) {
+  if (speed) {
+    if (CBAUD) {
+      if (!(speed & ~CBAUD)) {
+        t->c_cflag &= ~CBAUD;
+        t->c_cflag |= speed;
+      } else {
+        return einval();
+      }
+    } else {
+      t->c_ispeed = speed;
+    }
+  }
+  return 0;
+}
+
+/**
+ * Sets output baud rate.
+ *
+ * @return 0 on success, or -1 w/ errno
+ * @asyncsignalsafe
+ */
 int cfsetospeed(struct termios *t, unsigned speed) {
   if (CBAUD) {
     if (!(speed & ~CBAUD)) {

libc/calls/chdir.c

@@ -36,7 +36,7 @@
 int chdir(const char *path) {
   int rc;
   GetProgramExecutableName();  // XXX: ugly workaround
-  if (!path || (IsAsan() && !__asan_is_valid(path, 1))) {
+  if (!path || (IsAsan() && !__asan_is_valid_str(path))) {
     rc = efault();
   } else if (!IsWindows()) {
     rc = sys_chdir(path);

libc/calls/chroot.c

@@ -49,7 +49,7 @@
  */
 int chroot(const char *path) {
   int rc;
-  if (!path || (IsAsan() && !__asan_is_valid(path, 1))) {
+  if (!path || (IsAsan() && !__asan_is_valid_str(path))) {
     rc = efault();
   } else {
     rc = sys_chroot(path);

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_gettime.c

@@ -84,7 +84,7 @@ int clock_gettime(int clock, struct timespec *ts) {
     rc = __clock_gettime(clock, ts);
   }
 #if SYSDEBUG
-  if (!(__get_tls()->tib_flags & TIB_FLAG_TIME_CRITICAL)) {
+  if (__tls_enabled && !(__get_tls()->tib_flags & TIB_FLAG_TIME_CRITICAL)) {
     STRACE("clock_gettime(%s, [%s]) → %d% m", DescribeClockName(clock),
            DescribeTimespec(rc, ts), rc);
   }

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,8 +116,10 @@ errno_t clock_nanosleep(int clock, int flags, const struct timespec *req,
     errno = e;
   }
 
+  END_CANCELLATION_POINT;
+
 #if SYSDEBUG
-  if (!(__get_tls()->tib_flags & TIB_FLAG_TIME_CRITICAL)) {
+  if (__tls_enabled && !(__get_tls()->tib_flags & TIB_FLAG_TIME_CRITICAL)) {
     STRACE("clock_nanosleep(%s, %s, %s, [%s]) → %s", DescribeClockName(clock),
            DescribeSleepFlags(flags), DescribeTimespec(0, req),
            DescribeTimespec(rc, rem), DescribeErrnoResult(rc));

libc/calls/close-nt.c

@@ -18,15 +18,22 @@
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/calls/struct/fd.internal.h"
 #include "libc/errno.h"
+#include "libc/intrin/weaken.h"
 #include "libc/nt/enum/filetype.h"
 #include "libc/nt/files.h"
 #include "libc/nt/runtime.h"
 #include "libc/sysv/consts/o.h"
 
-textwindows int sys_close_nt(struct Fd *fd) {
+void sys_fcntl_nt_lock_cleanup(int) hidden;
+
+textwindows int sys_close_nt(struct Fd *fd, int fildes) {
   int e;
   bool ok = true;
 
+  if (_weaken(sys_fcntl_nt_lock_cleanup)) {
+    _weaken(sys_fcntl_nt_lock_cleanup)(fildes);
+  }
+
   if (fd->kind == kFdFile && ((fd->flags & O_ACCMODE) != O_RDONLY &&
                               GetFileType(fd->handle) == kNtFileTypeDisk)) {
     // Like Linux, closing a file on Windows doesn't guarantee it's

libc/calls/close.c

@@ -16,10 +16,10 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/assert.h"
 #include "libc/calls/calls.h"
 #include "libc/calls/internal.h"
 #include "libc/calls/state.internal.h"
+#include "libc/calls/struct/fd.internal.h"
 #include "libc/calls/syscall-nt.internal.h"
 #include "libc/calls/syscall-sysv.internal.h"
 #include "libc/dce.h"
@@ -81,7 +81,7 @@ int close(int fd) {
         } else if (__isfdkind(fd, kFdFile) ||     //
                    __isfdkind(fd, kFdConsole) ||  //
                    __isfdkind(fd, kFdProcess)) {  //
-          rc = sys_close_nt(g_fds.p + fd);
+          rc = sys_close_nt(g_fds.p + fd, fd);
         } else {
           rc = eio();
         }

libc/calls/closefrom.c

@@ -27,12 +27,9 @@
 /**
  * Closes extra file descriptors, e.g.
  *
- *     // close all non-stdio file descriptors
- *     if (closefrom(3) == -1) {
- *       for (int i = 3; i < 256; ++i) {
+ *     if (closefrom(3))
+ *       for (int i = 3; i < 256; ++i)
  *         close(i);
- *       }
- *     }
  *
  * @return 0 on success, or -1 w/ errno
  * @raise EBADF if `first` is negative
@@ -40,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();
@@ -45,27 +43,18 @@ textwindows int sys_dup_nt(int oldfd, int newfd, int flags, int start) {
   }
 
   // allocate a new file descriptor
-  for (;;) {
-    if (newfd == -1) {
-      if ((newfd = __reservefd_unlocked(start)) == -1) {
-        __fds_unlock();
-        return -1;
-      }
-      break;
-    } else {
-      if (__ensurefds_unlocked(newfd) == -1) {
-        __fds_unlock();
-        return -1;
-      }
-      if (g_fds.p[newfd].kind) {
-        __fds_unlock();
-        close(newfd);
-        __fds_lock();
-      }
-      if (!g_fds.p[newfd].kind) {
-        g_fds.p[newfd].kind = kFdReserved;
-        break;
-      }
+  if (newfd == -1) {
+    if ((newfd = __reservefd_unlocked(start)) == -1) {
+      __fds_unlock();
+      return -1;
+    }
+  } else {
+    if (__ensurefds_unlocked(newfd) == -1) {
+      __fds_unlock();
+      return -1;
+    }
+    if (g_fds.p[newfd].kind) {
+      sys_close_nt(g_fds.p + newfd, newfd);
     }
   }
 
@@ -86,7 +75,7 @@ textwindows int sys_dup_nt(int oldfd, int newfd, int flags, int start) {
     }
     rc = newfd;
   } else {
-    __releasefd_unlocked(newfd);
+    __releasefd(newfd);
     rc = __winerr();
   }
 

libc/calls/execve-sysv.c

@@ -16,6 +16,8 @@
 │ 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"
 #include "libc/dce.h"
@@ -39,12 +41,17 @@ 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='")) {
+    if (sys_read(fd, buf, 8) == 8 &&  //
+        (READ64LE(buf) == READ64LE("MZqFpD='") ||
+         READ64LE(buf) == READ64LE("JTqFpD='"))) {
       res = true;
     }
     sys_close(fd);
   }
+  ALLOW_CANCELLATIONS;
   return res;
 }
 
@@ -61,35 +68,41 @@ static const char *Join(const char *a, const char *b, char buf[PATH_MAX]) {
 }
 
 int sys_execve(const char *prog, char *const argv[], char *const envp[]) {
-  int e;
   size_t i;
+  int e, rc;
   char *buf;
   char **shargs;
   const char *ape;
   e = errno;
   __sys_execve(prog, argv, envp);
-  if (errno != ENOEXEC) return -1;
-  for (i = 0; argv[i];) ++i;
-  buf = alloca(PATH_MAX);
-  shargs = alloca((i + 4) * sizeof(char *));
-  if (IsApeBinary(prog) &&
-      (CanExecute((ape = "/usr/bin/ape")) ||
-       CanExecute((ape = Join(firstnonnull(getenv("TMPDIR"),
-                                           firstnonnull(getenv("HOME"), ".")),
-                              ".ape", buf))) ||
-       CanExecute(
-           (ape = Join(firstnonnull(getenv("HOME"), "."), ".ape", buf))))) {
-    shargs[0] = ape;
-    shargs[1] = "-";
-    shargs[2] = prog;
-    memcpy(shargs + 3, argv, (i + 1) * sizeof(char *));
-  } else if (CanExecute(prog)) {
-    shargs[0] = _PATH_BSHELL;
-    shargs[1] = prog;
-    memcpy(shargs + 2, argv + 1, i * sizeof(char *));
+  if (errno == ENOEXEC) {
+    for (i = 0; argv[i];) ++i;
+    buf = alloca(PATH_MAX);
+    shargs = alloca((i + 4) * sizeof(char *));
+    if (IsApeBinary(prog) &&
+        (CanExecute((ape = "/usr/bin/ape")) ||
+         CanExecute((ape = Join(firstnonnull(getenv("TMPDIR"),
+                                             firstnonnull(getenv("HOME"), ".")),
+                                ".ape", buf))) ||
+         CanExecute(
+             (ape = Join(firstnonnull(getenv("HOME"), "."), ".ape", buf))))) {
+      shargs[0] = ape;
+      shargs[1] = "-";
+      shargs[2] = prog;
+      memcpy(shargs + 3, argv, (i + 1) * sizeof(char *));
+      errno = e;
+      rc = __sys_execve(shargs[0], shargs, envp);
+    } else if (CanExecute(prog)) {
+      shargs[0] = _PATH_BSHELL;
+      shargs[1] = prog;
+      memcpy(shargs + 2, argv + 1, i * sizeof(char *));
+      errno = e;
+      rc = __sys_execve(shargs[0], shargs, envp);
+    } else {
+      rc = enoexec();
+    }
   } else {
-    return enoexec();
+    rc = -1;
   }
-  errno = e;
-  return __sys_execve(shargs[0], shargs, envp);
+  return rc;
 }

libc/calls/execve.c

@@ -23,6 +23,7 @@
 #include "libc/calls/syscall-sysv.internal.h"
 #include "libc/dce.h"
 #include "libc/intrin/asan.internal.h"
+#include "libc/intrin/describeflags.internal.h"
 #include "libc/intrin/kprintf.h"
 #include "libc/intrin/likely.h"
 #include "libc/intrin/promises.internal.h"
@@ -53,26 +54,13 @@ int execve(const char *prog, char *const argv[], char *const envp[]) {
   int rc;
   size_t i;
   if (!prog || !argv || !envp ||
-      (IsAsan() &&
-       (!__asan_is_valid(prog, 1) || !__asan_is_valid_strlist(argv) ||
-        !__asan_is_valid_strlist(envp)))) {
+      (IsAsan() && (!__asan_is_valid_str(prog) ||      //
+                    !__asan_is_valid_strlist(argv) ||  //
+                    !__asan_is_valid_strlist(envp)))) {
     rc = efault();
   } else {
-#ifdef SYSDEBUG
-    if (UNLIKELY(__strace > 0)) {
-      kprintf(STRACE_PROLOGUE "execve(%#s, {", prog);
-      for (i = 0; argv[i]; ++i) {
-        if (i) kprintf(", ");
-        kprintf("%#s", argv[i]);
-      }
-      kprintf("}, {");
-      for (i = 0; envp[i]; ++i) {
-        if (i) kprintf(", ");
-        kprintf("%#s", envp[i]);
-      }
-      kprintf("})\n");
-    }
-#endif
+    STRACE("execve(%#s, %s, %s) → ...", prog, DescribeStringList(argv),
+           DescribeStringList(envp));
     if (!IsWindows()) {
       rc = 0;
       if (IsLinux() && __execpromises && _weaken(sys_pledge_linux)) {

libc/calls/execvpe.c

@@ -37,7 +37,7 @@
 int execvpe(const char *prog, char *const argv[], char *const *envp) {
   char *exe;
   char pathbuf[PATH_MAX];
-  if (IsAsan() && !__asan_is_valid(prog, 1)) return efault();
+  if (IsAsan() && !__asan_is_valid_str(prog)) return efault();
   if (!(exe = commandv(prog, pathbuf, sizeof(pathbuf)))) return -1;
   return execve(exe, argv, envp);
 }

libc/calls/faccessat.c

@@ -51,7 +51,7 @@
 int faccessat(int dirfd, const char *path, int amode, int flags) {
   int e, rc;
   struct ZiposUri zipname;
-  if (!path || (IsAsan() && !__asan_is_valid(path, 1))) {
+  if (!path || (IsAsan() && !__asan_is_valid_str(path))) {
     rc = efault();
   } else if (__isfdkind(dirfd, kFdZip)) {
     rc = enotsup();

libc/calls/fchmodat.c

@@ -44,7 +44,7 @@
  */
 int fchmodat(int dirfd, const char *path, uint32_t mode, int flags) {
   int rc;
-  if (IsAsan() && !__asan_is_valid(path, 1)) {
+  if (IsAsan() && !__asan_is_valid_str(path)) {
     rc = efault();
   } else if (_weaken(__zipos_notat) &&
              (rc = __zipos_notat(dirfd, path)) == -1) {

libc/calls/fchownat.c

@@ -43,7 +43,7 @@
 int fchownat(int dirfd, const char *path, uint32_t uid, uint32_t gid,
              int flags) {
   int rc;
-  if (IsAsan() && !__asan_is_valid(path, 1)) {
+  if (IsAsan() && !__asan_is_valid_str(path)) {
     rc = efault();
   } else if (_weaken(__zipos_notat) &&
              (rc = __zipos_notat(dirfd, path)) == -1) {

libc/calls/fcntl-nt.c

@@ -16,6 +16,7 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
+#include "libc/assert.h"
 #include "libc/calls/calls.h"
 #include "libc/calls/internal.h"
 #include "libc/calls/struct/fd.internal.h"
@@ -24,63 +25,131 @@
 #include "libc/calls/syscall_support-nt.internal.h"
 #include "libc/calls/wincrash.internal.h"
 #include "libc/errno.h"
+#include "libc/intrin/kmalloc.h"
 #include "libc/intrin/weaken.h"
+#include "libc/limits.h"
 #include "libc/log/backtrace.internal.h"
+#include "libc/macros.internal.h"
 #include "libc/nt/enum/filelockflags.h"
 #include "libc/nt/errors.h"
 #include "libc/nt/files.h"
 #include "libc/nt/runtime.h"
 #include "libc/nt/struct/byhandlefileinformation.h"
 #include "libc/nt/struct/overlapped.h"
+#include "libc/str/str.h"
 #include "libc/sysv/consts/f.h"
 #include "libc/sysv/consts/fd.h"
 #include "libc/sysv/consts/o.h"
 #include "libc/sysv/errfuns.h"
+#include "libc/thread/thread.h"
 
-static textwindows int sys_fcntl_nt_dupfd(int fd, int cmd, int start) {
-  if (start < 0) return einval();
-  return sys_dup_nt(fd, -1, (cmd == F_DUPFD_CLOEXEC ? O_CLOEXEC : 0), start);
+struct FileLock {
+  struct FileLock *next;
+  int64_t off;
+  int64_t len;
+  int fd;
+  bool exc;
+};
+
+struct FileLocks {
+  pthread_mutex_t mu;
+  struct FileLock *list;
+  struct FileLock *free;
+};
+
+static struct FileLocks g_locks;
+
+static textwindows struct FileLock *NewFileLock(void) {
+  struct FileLock *fl;
+  if (g_locks.free) {
+    fl = g_locks.free;
+    g_locks.free = fl->next;
+  } else {
+    fl = kmalloc(sizeof(*fl));
+  }
+  bzero(fl, sizeof(*fl));
+  fl->next = g_locks.list;
+  g_locks.list = fl;
+  return fl;
 }
 
-static textwindows int sys_fcntl_nt_lock(struct Fd *f, int cmd, uintptr_t arg) {
+static textwindows void FreeFileLock(struct FileLock *fl) {
+  fl->next = g_locks.free;
+  g_locks.free = fl;
+}
+
+static textwindows bool OverlapsFileLock(struct FileLock *fl, int64_t off,
+                                         int64_t len) {
+  uint64_t BegA, EndA, BegB, EndB;
+  BegA = off;
+  EndA = off + (len - 1);
+  BegB = fl->off;
+  EndB = fl->off + (fl->len - 1);
+  return MAX(BegA, BegB) < MIN(EndA, EndB);
+}
+
+static textwindows bool EncompassesFileLock(struct FileLock *fl, int64_t off,
+                                            int64_t len) {
+  return off <= fl->off && fl->off + fl->len <= off + len;
+}
+
+static textwindows bool EqualsFileLock(struct FileLock *fl, int64_t off,
+                                       int64_t len) {
+  return fl->off == off && off + len == fl->off + fl->len;
+}
+
+hidden textwindows void sys_fcntl_nt_lock_cleanup(int fd) {
+  struct FileLock *fl, *ft, **flp;
+  pthread_mutex_lock(&g_locks.mu);
+  for (flp = &g_locks.list, fl = *flp; fl;) {
+    if (fl->fd == fd) {
+      *flp = fl->next;
+      ft = fl->next;
+      FreeFileLock(fl);
+      fl = ft;
+    } else {
+      flp = &fl->next;
+      fl = *flp;
+    }
+  }
+  pthread_mutex_unlock(&g_locks.mu);
+}
+
+static textwindows int sys_fcntl_nt_lock(struct Fd *f, int fd, int cmd,
+                                         uintptr_t arg) {
   int e;
   struct flock *l;
   uint32_t flags, err;
-  int64_t pos, off, len, size;
-  struct NtByHandleFileInformation info;
-
-  if (!GetFileInformationByHandle(f->handle, &info)) {
-    return __winerr();
-  }
-
-  pos = 0;
-  if (!SetFilePointerEx(f->handle, 0, &pos, SEEK_CUR)) {
-    return __winerr();
-  }
+  struct FileLock *fl, *ft, **flp;
+  int64_t pos, off, len, end, size;
 
   l = (struct flock *)arg;
   len = l->l_len;
   off = l->l_start;
-  size = (uint64_t)info.nFileSizeHigh << 32 | info.nFileSizeLow;
 
   switch (l->l_whence) {
     case SEEK_SET:
       break;
     case SEEK_CUR:
-      off = pos + off;
+      pos = 0;
+      if (SetFilePointerEx(f->handle, 0, &pos, SEEK_CUR)) {
+        off = pos + off;
+      } else {
+        return __winerr();
+      }
       break;
     case SEEK_END:
-      off = size - off;
+      off = INT64_MAX - off;
       break;
     default:
       return einval();
   }
 
   if (!len) {
-    len = size - off;
+    len = INT64_MAX - off;
   }
 
-  if (off < 0 || len < 0) {
+  if (off < 0 || len < 0 || __builtin_add_overflow(off, len, &end)) {
     return einval();
   }
 
@@ -89,8 +158,57 @@ static textwindows int sys_fcntl_nt_lock(struct Fd *f, int cmd, uintptr_t arg) {
                             .Pointer = (void *)(uintptr_t)off};
 
   if (l->l_type == F_RDLCK || l->l_type == F_WRLCK) {
+
+    if (cmd == F_SETLK || cmd == F_SETLKW) {
+      // make it possible to transition read locks to write locks
+      for (flp = &g_locks.list, fl = *flp; fl;) {
+        if (fl->fd == fd) {
+          if (EqualsFileLock(fl, off, len)) {
+            if (fl->exc == l->l_type == F_WRLCK) {
+              // we already have this lock
+              return 0;
+            } else {
+              // unlock our read lock and acquire write lock below
+              if (UnlockFileEx(f->handle, 0, len, len >> 32, &ov)) {
+                *flp = fl->next;
+                ft = fl->next;
+                FreeFileLock(fl);
+                fl = ft;
+                continue;
+              } else {
+                return -1;
+              }
+            }
+            break;
+          } else if (OverlapsFileLock(fl, off, len)) {
+            return enotsup();
+          }
+        }
+        flp = &fl->next;
+        fl = *flp;
+      }
+    }
+
+    // return better information on conflicting locks if possible
+    if (cmd == F_GETLK) {
+      for (fl = g_locks.list; fl; fl = fl->next) {
+        if (fl->fd == fd &&  //
+            OverlapsFileLock(fl, off, len) &&
+            (l->l_type == F_WRLCK || !fl->exc)) {
+          l->l_whence = SEEK_SET;
+          l->l_start = fl->off;
+          l->l_len = fl->len;
+          l->l_type == fl->exc ? F_WRLCK : F_RDLCK;
+          l->l_pid = getpid();
+          return 0;
+        }
+      }
+    }
+
     flags = 0;
     if (cmd != F_SETLKW) {
+      // TODO(jart): we should use expo backoff in wrapper function
+      //             should not matter since sqlite doesn't need it
       flags |= kNtLockfileFailImmediately;
     }
     if (l->l_type == F_WRLCK) {
@@ -101,68 +219,132 @@ static textwindows int sys_fcntl_nt_lock(struct Fd *f, int cmd, uintptr_t arg) {
       if (ok) {
         l->l_type = F_UNLCK;
         if (!UnlockFileEx(f->handle, 0, len, len >> 32, &ov)) {
-          notpossible;
+          return -1;
         }
       } else {
         l->l_pid = -1;
         ok = true;
       }
+    } else if (ok) {
+      fl = NewFileLock();
+      fl->off = off;
+      fl->len = len;
+      fl->exc = l->l_type == F_WRLCK;
+      fl->fd = fd;
     }
     return ok ? 0 : -1;
   }
 
   if (l->l_type == F_UNLCK) {
     if (cmd == F_GETLK) return einval();
-    e = errno;
-    if (UnlockFileEx(f->handle, 0, len, len >> 32, &ov)) {
-      return 0;
-    } else if (errno == ENOLCK) {
-      errno = e;
-      return 0;
-    } else {
-      return 0;
+
+    // allow a big range to unlock many small ranges
+    for (flp = &g_locks.list, fl = *flp; fl;) {
+      if (fl->fd == fd && EncompassesFileLock(fl, off, len)) {
+        struct NtOverlapped ov = {.hEvent = f->handle,
+                                  .Pointer = (void *)(uintptr_t)fl->off};
+        if (UnlockFileEx(f->handle, 0, fl->len, fl->len >> 32, &ov)) {
+          *flp = fl->next;
+          ft = fl->next;
+          FreeFileLock(fl);
+          fl = ft;
+        } else {
+          return -1;
+        }
+      } else {
+        flp = &fl->next;
+        fl = *flp;
+      }
     }
+
+    // win32 won't let us carve up existing locks
+    int overlap_count = 0;
+    for (fl = g_locks.list; fl; fl = fl->next) {
+      if (fl->fd == fd &&  //
+          OverlapsFileLock(fl, off, len)) {
+        ++overlap_count;
+      }
+    }
+
+    // try to handle the carving cases needed by sqlite
+    if (overlap_count == 1) {
+      for (fl = g_locks.list; fl; fl = fl->next) {
+        if (fl->fd == fd &&          //
+            off <= fl->off &&        //
+            off + len >= fl->off &&  //
+            off + len < fl->off + fl->len) {
+          // cleave left side of lock
+          struct NtOverlapped ov = {.hEvent = f->handle,
+                                    .Pointer = (void *)(uintptr_t)fl->off};
+          if (!UnlockFileEx(f->handle, 0, fl->len, fl->len >> 32, &ov)) {
+            return -1;
+          }
+          fl->len = (fl->off + fl->len) - (off + len);
+          fl->off = off + len;
+          ov.Pointer = (void *)(uintptr_t)fl->off;
+          if (!LockFileEx(f->handle, kNtLockfileExclusiveLock, 0, fl->len,
+                          fl->len >> 32, &ov)) {
+            return -1;
+          }
+          return 0;
+        }
+      }
+    }
+
+    if (overlap_count) {
+      return enotsup();
+    }
+
+    return 0;
   }
 
   return einval();
 }
 
+static textwindows int sys_fcntl_nt_dupfd(int fd, int cmd, int start) {
+  if (start < 0) return einval();
+  return sys_dup_nt(fd, -1, (cmd == F_DUPFD_CLOEXEC ? O_CLOEXEC : 0), start);
+}
+
 textwindows int sys_fcntl_nt(int fd, int cmd, uintptr_t arg) {
+  int rc;
   uint32_t flags;
   if (__isfdkind(fd, kFdFile) || __isfdkind(fd, kFdSocket)) {
     if (cmd == F_GETFL) {
-      return g_fds.p[fd].flags &
-             (O_ACCMODE | O_APPEND | O_ASYNC | O_DIRECT | O_NOATIME |
-              O_NONBLOCK | O_RANDOM | O_SEQUENTIAL);
+      rc = g_fds.p[fd].flags &
+           (O_ACCMODE | O_APPEND | O_ASYNC | O_DIRECT | O_NOATIME | O_NONBLOCK |
+            O_RANDOM | O_SEQUENTIAL);
     } else if (cmd == F_SETFL) {
       // O_APPEND doesn't appear to be tunable at cursory glance
       // O_NONBLOCK might require we start doing all i/o in threads
       // O_DSYNC / O_RSYNC / O_SYNC maybe if we fsync() everything
       // O_DIRECT | O_RANDOM | O_SEQUENTIAL | O_NDELAY possible but
       // not worth it.
-      return einval();
+      rc = enosys();
     } else if (cmd == F_GETFD) {
       if (g_fds.p[fd].flags & O_CLOEXEC) {
-        return FD_CLOEXEC;
+        rc = FD_CLOEXEC;
       } else {
-        return 0;
+        rc = 0;
       }
     } else if (cmd == F_SETFD) {
       if (arg & FD_CLOEXEC) {
         g_fds.p[fd].flags |= O_CLOEXEC;
-        return FD_CLOEXEC;
       } else {
         g_fds.p[fd].flags &= ~O_CLOEXEC;
-        return 0;
       }
+      rc = 0;
     } else if (cmd == F_SETLK || cmd == F_SETLKW || cmd == F_GETLK) {
-      return sys_fcntl_nt_lock(g_fds.p + fd, cmd, arg);
+      pthread_mutex_lock(&g_locks.mu);
+      rc = sys_fcntl_nt_lock(g_fds.p + fd, fd, cmd, arg);
+      pthread_mutex_unlock(&g_locks.mu);
     } else if (cmd == F_DUPFD || cmd == F_DUPFD_CLOEXEC) {
-      return sys_fcntl_nt_dupfd(fd, cmd, arg);
+      rc = sys_fcntl_nt_dupfd(fd, cmd, arg);
     } else {
-      return einval();
+      rc = einval();
     }
   } else {
-    return ebadf();
+    rc = ebadf();
   }
+  return rc;
 }

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"
@@ -31,7 +32,7 @@
 #include "libc/zipos/zipos.internal.h"
 
 /**
- * Does things with file descriptor, via re-imagined hourglass api, e.g.
+ * Does things with file descriptor, e.g.
  *
  *     CHECK_NE(-1, fcntl(fd, F_SETFD, FD_CLOEXEC));
  *
@@ -41,12 +42,14 @@
  *     CHECK_GE((newfd = fcntl(oldfd, F_DUPFD,         3)), 3);
  *     CHECK_GE((newfd = fcntl(oldfd, F_DUPFD_CLOEXEC, 3)), 3);
  *
- * This function implements POSIX Advisory Locks, which let independent
- * processes (and on Windows, threads too!) read/write lock byte ranges
- * of files. See `test/libc/calls/lock_test.c` for an example.
+ * This function implements file record locking, which lets independent
+ * processes (and on Linux 3.15+, threads too!) lock arbitrary ranges
+ * associated with a file. See `test/libc/calls/lock_test.c` and other
+ * locking related tests in that folder.
  *
- * Please be warned that locks currently do nothing on Windows since
- * figuring out how to polyfill them correctly is a work in progress.
+ * On Windows, the Cosmopolitan Libc polyfill for POSIX advisory locks
+ * only implements enough of its nuances to support SQLite's needs. Some
+ * possibilities, e.g. punching holes in lock, will raise `ENOTSUP`.
  *
  * @param fd is the file descriptor
  * @param cmd can be one of:
@@ -56,12 +59,12 @@
  *     - `F_SETFL` sets file descriptor status flags
  *     - `F_DUPFD` is like dup() but `arg` is a minimum result, e.g. 3
  *     - `F_DUPFD_CLOEXEC` ditto but sets `O_CLOEXEC` on returned fd
- *     - `F_SETLK` for record locking where `arg` is `struct flock`
- *     - `F_SETLKW` ditto but waits (i.e. blocks) for lock
+ *     - `F_SETLK` for record locking where `arg` is `struct flock *`
+ *     - `F_SETLKW` ditto but waits for lock (SQLite avoids this)
  *     - `F_GETLK` to retrieve information about a record lock
- *     - `F_OFD_SETLK` for better locks on Linux and XNU
- *     - `F_OFD_SETLKW` for better locks on Linux and XNU
- *     - `F_OFD_GETLK` for better locks on Linux and XNU
+ *     - `F_OFD_SETLK` for better non-blocking lock (Linux 3.15+ only)
+ *     - `F_OFD_SETLKW` for better blocking lock (Linux 3.15+ only)
+ *     - `F_OFD_GETLK` for better lock querying (Linux 3.15+ only)
  *     - `F_FULLFSYNC` on MacOS for fsync() with release barrier
  *     - `F_BARRIERFSYNC` on MacOS for fsync() with even more barriers
  *     - `F_SETNOSIGPIPE` on MacOS and NetBSD to control `SIGPIPE`
@@ -71,7 +74,7 @@
  *     - `F_NOCACHE` on MacOS to toggle data caching
  *     - `F_GETPIPE_SZ` on Linux to get pipe size
  *     - `F_SETPIPE_SZ` on Linux to set pipe size
- *     - `F_NOTIFY` raise `SIGIO` upon `fd` events in `arg` on Linux
+ *     - `F_NOTIFY` raise `SIGIO` upon `fd` events in `arg` (Linux only)
  *       - `DN_ACCESS` for file access
  *       - `DN_MODIFY` for file modifications
  *       - `DN_CREATE` for file creations
@@ -88,9 +91,11 @@
  * @raise ENOLCK if `F_SETLKW` would have exceeded `RLIMIT_LOCKS`
  * @raise EPERM if `cmd` is `F_SETOWN` and we weren't authorized
  * @raise ESRCH if `cmd` is `F_SETOWN` and process group not found
+ * @raise ENOTSUP on Windows if locking operation isn't supported yet
  * @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
  */
@@ -108,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/fexecve.c

@@ -21,8 +21,7 @@
 #include "libc/dce.h"
 #include "libc/fmt/itoa.h"
 #include "libc/intrin/asan.internal.h"
-#include "libc/intrin/kprintf.h"
-#include "libc/intrin/likely.h"
+#include "libc/intrin/describeflags.internal.h"
 #include "libc/intrin/strace.internal.h"
 #include "libc/str/str.h"
 #include "libc/sysv/errfuns.h"
@@ -48,21 +47,8 @@ int fexecve(int fd, char *const argv[], char *const envp[]) {
        (!__asan_is_valid_strlist(argv) || !__asan_is_valid_strlist(envp)))) {
     rc = efault();
   } else {
-#ifdef SYSDEBUG
-    if (UNLIKELY(__strace > 0)) {
-      kprintf(STRACE_PROLOGUE "fexecve(%d, {", fd);
-      for (i = 0; argv[i]; ++i) {
-        if (i) kprintf(", ");
-        kprintf("%#s", argv[i]);
-      }
-      kprintf("}, {");
-      for (i = 0; envp[i]; ++i) {
-        if (i) kprintf(", ");
-        kprintf("%#s", envp[i]);
-      }
-      kprintf("})\n");
-    }
-#endif
+    STRACE("fexecve(%d, %s, %s) → ...", fd, DescribeStringList(argv),
+           DescribeStringList(envp));
     if (IsLinux()) {
       char path[14 + 12];
       FormatInt32(stpcpy(path, "/proc/self/fd/"), fd);

libc/calls/fileexists.c

@@ -51,7 +51,7 @@ bool fileexists(const char *path) {
   struct ZiposUri zipname;
   uint16_t path16[PATH_MAX];
   e = errno;
-  if (IsAsan() && !__asan_is_valid(path, 1)) {
+  if (IsAsan() && !__asan_is_valid_str(path)) {
     efault();
     res = false;
   } else if (_weaken(__zipos_open) &&

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/fstatat-sysv.c

@@ -31,7 +31,7 @@ int32_t sys_fstatat(int32_t dirfd, const char *path, struct stat *st,
   int rc;
   void *p;
   union metastat ms;
-  if (IsAsan() && !__asan_is_valid(path, 1)) return efault();
+  if (IsAsan() && !__asan_is_valid_str(path)) return efault();
   if (IsLinux()) {
     _Static_assert(sizeof(*st) == sizeof(ms.linux), "assumption broken");
     if (IsAsan() && (st && !__asan_is_valid(st, sizeof(*st)))) return efault();

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/gettimeofday.c

@@ -63,7 +63,7 @@ int gettimeofday(struct timeval *tv, struct timezone *tz) {
     rc = __gettimeofday(tv, tz, 0).ax;
   }
 #if SYSDEBUG
-  if (!(__get_tls()->tib_flags & TIB_FLAG_TIME_CRITICAL)) {
+  if (__tls_enabled && !(__get_tls()->tib_flags & TIB_FLAG_TIME_CRITICAL)) {
     STRACE("gettimeofday([%s], %p) → %d% m", DescribeTimeval(rc, tv), tz, rc);
   }
 #endif

libc/calls/internal.h

@@ -18,7 +18,6 @@ hidden extern const struct Fd kEmptyFd;
 int __reservefd(int) hidden;
 int __reservefd_unlocked(int) hidden;
 void __releasefd(int) hidden;
-void __releasefd_unlocked(int) hidden;
 int __ensurefds(int) hidden;
 int __ensurefds_unlocked(int) hidden;
 void __printfds(void) hidden;
@@ -43,8 +42,8 @@ forceinline size_t _clampio(size_t size) {
   }
 }
 
-int sys_close_nt(struct Fd *) hidden;
-bool _check_interrupts(bool, struct Fd *) hidden;
+int sys_close_nt(struct Fd *, int) 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/isdirectory.c

@@ -51,7 +51,7 @@ bool isdirectory(const char *path) {
   union metastat st;
   struct ZiposUri zipname;
   e = errno;
-  if (IsAsan() && !__asan_is_valid(path, 1)) {
+  if (IsAsan() && !__asan_is_valid_str(path)) {
     efault();
     res = false;
   } else if (_weaken(__zipos_open) &&

libc/calls/isregularfile.c

@@ -48,7 +48,7 @@ bool isregularfile(const char *path) {
   union metastat st;
   struct ZiposUri zipname;
   e = errno;
-  if (IsAsan() && !__asan_is_valid(path, 1)) {
+  if (IsAsan() && !__asan_is_valid_str(path)) {
     efault();
     res = false;
   } else if (_weaken(__zipos_open) &&

libc/calls/issymlink.c

@@ -51,7 +51,7 @@ bool issymlink(const char *path) {
   union metastat st;
   struct ZiposUri zipname;
   e = errno;
-  if (IsAsan() && !__asan_is_valid(path, 1)) {
+  if (IsAsan() && !__asan_is_valid_str(path)) {
     efault();
     res = false;
   } else if (_weaken(__zipos_open) &&

libc/calls/kill.c

@@ -17,10 +17,10 @@
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/calls/calls.h"
-#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/strace.internal.h"
 #include "libc/str/str.h"
 
 /**
@@ -38,6 +38,10 @@
  *      >0 can be SIGINT, SIGTERM, SIGKILL, SIGUSR1, etc.
  *      =0 checks both if pid exists and we can signal it
  * @return 0 if something was accomplished, or -1 w/ errno
+ * @raise ESRCH if `pid` couldn't be found
+ * @raise EPERM if lacked permission to signal process
+ * @raise EPERM if pledge() is in play without `proc` promised
+ * @raise EINVAL if the provided `sig` is invalid or unsupported
  * @asyncsignalsafe
  */
 int kill(int pid, int sig) {

libc/calls/linkat.c

@@ -41,7 +41,7 @@ int linkat(int olddirfd, const char *oldpath, int newdirfd, const char *newpath,
            int flags) {
   int rc;
   if (IsAsan() &&
-      (!__asan_is_valid(oldpath, 1) || !__asan_is_valid(newpath, 1))) {
+      (!__asan_is_valid_str(oldpath) || !__asan_is_valid_str(newpath))) {
     rc = efault();
   } else if (_weaken(__zipos_notat) &&
              ((rc = __zipos_notat(olddirfd, oldpath)) == -1 ||

libc/calls/lseek-nt.c

@@ -34,6 +34,8 @@ textwindows int64_t sys_lseek_nt(int fd, int64_t offset, int whence) {
     } else {
       return espipe();
     }
+  } else if (__isfdkind(fd, kFdSocket)) {
+    return espipe();
   } else {
     return ebadf();
   }

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/mkdirat.c

@@ -53,7 +53,7 @@
  */
 int mkdirat(int dirfd, const char *path, unsigned mode) {
   int rc;
-  if (IsAsan() && !__asan_is_valid(path, 1)) {
+  if (IsAsan() && !__asan_is_valid_str(path)) {
     rc = efault();
   } else if (_weaken(__zipos_notat) &&
              (rc = __zipos_notat(dirfd, path)) == -1) {

libc/calls/mkfifo.c

@@ -17,10 +17,10 @@
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/calls/calls.h"
-#include "libc/intrin/strace.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/nt/ipc.h"
 #include "libc/sysv/consts/s.h"
 #include "libc/sysv/errfuns.h"
@@ -36,7 +36,7 @@
 int mkfifo(const char *pathname, unsigned mode) {
   // TODO(jart): Windows?
   int rc;
-  if (IsAsan() && !__asan_is_valid(pathname, 1)) {
+  if (IsAsan() && !__asan_is_valid_str(pathname)) {
     rc = efault();
   } else if (IsLinux()) {
     rc = sys_mknod(pathname, mode | S_IFIFO, 0);

libc/calls/mknod.c

@@ -17,10 +17,10 @@
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/calls/calls.h"
-#include "libc/intrin/strace.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/s.h"
 #include "libc/sysv/errfuns.h"
 
@@ -40,7 +40,7 @@
  */
 int mknod(const char *path, uint32_t mode, uint64_t dev) {
   int rc;
-  if (IsAsan() && !__asan_is_valid(path, 1)) return efault();
+  if (IsAsan() && !__asan_is_valid_str(path)) return efault();
   if (mode & S_IFREG) return creat(path, mode & ~S_IFREG);
   if (mode & S_IFDIR) return mkdir(path, mode & ~S_IFDIR);
   if (mode & S_IFIFO) return mkfifo(path, mode & ~S_IFIFO);

libc/calls/mkntpath.c

@@ -21,9 +21,7 @@
 #include "libc/intrin/strace.internal.h"
 #include "libc/macros.internal.h"
 #include "libc/nt/systeminfo.h"
-#include "libc/str/oldutf16.internal.h"
 #include "libc/str/str.h"
-#include "libc/str/tpdecode.internal.h"
 #include "libc/sysv/consts/o.h"
 #include "libc/sysv/errfuns.h"
 
@@ -61,9 +59,13 @@ textwindows int __mkntpath(const char *path,
 /**
  * Copies path for Windows NT.
  *
- * This entails (1) UTF-8 to UTF-16 conversion; (2) replacing
- * forward-slashes with backslashes; and (3) remapping several
- * well-known paths (e.g. /dev/null → NUL) for convenience.
+ * This function does the following chores:
+ *
+ * 1. Converting UTF-8 to UTF-16
+ * 2. Replacing forward-slashes with backslashes
+ * 3. Fixing drive letter paths, e.g. `/c/` → `c:\`
+ * 4. Add `\\?\` prefix for paths exceeding 260 chars
+ * 5. Remapping well-known paths, e.g. `/dev/null` → `NUL`
  *
  * @param flags is used by open()
  * @param path16 is shortened so caller can prefix, e.g. \\.\pipe\, and

libc/calls/munmap-metal.c

@@ -16,7 +16,7 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/runtime/directmap.internal.h"
+#include "libc/intrin/directmap.internal.h"
 #include "libc/runtime/pc.internal.h"
 
 noasan int sys_munmap_metal(void *addr, size_t size) {
@@ -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/munmap-sysv.c

@@ -16,11 +16,11 @@
 │ 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-sysv.internal.h"
+#include "libc/dce.h"
 #include "libc/intrin/describeflags.internal.h"
-#include "libc/runtime/directmap.internal.h"
-#include "libc/runtime/memtrack.internal.h"
+#include "libc/intrin/directmap.internal.h"
+#include "libc/intrin/strace.internal.h"
 
 /**
  * Unmaps memory directly with system.

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/now.c

@@ -56,7 +56,7 @@ static long double GetTimeSample(void) {
 static long double MeasureNanosPerCycle(void) {
   int i, n;
   long double avg, samp;
-  __get_tls()->tib_flags |= TIB_FLAG_TIME_CRITICAL;
+  if (__tls_enabled) __get_tls()->tib_flags |= TIB_FLAG_TIME_CRITICAL;
   if (IsWindows()) {
     n = 10;
   } else {
@@ -66,7 +66,7 @@ static long double MeasureNanosPerCycle(void) {
     samp = GetTimeSample();
     avg += (samp - avg) / i;
   }
-  __get_tls()->tib_flags &= ~TIB_FLAG_TIME_CRITICAL;
+  if (__tls_enabled) __get_tls()->tib_flags &= ~TIB_FLAG_TIME_CRITICAL;
   STRACE("MeasureNanosPerCycle cpn*1000=%d", (long)(avg * 1000));
   return avg;
 }

libc/calls/ntcontext2linux.c

@@ -21,9 +21,10 @@
 #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_flags = cr->EFlags;
   ctx->uc_mcontext.eflags = cr->EFlags;
   ctx->uc_mcontext.rax = cr->Rax;
   ctx->uc_mcontext.rbx = cr->Rbx;
@@ -51,7 +52,6 @@ privileged void _ntcontext2linux(ucontext_t *ctx, const struct NtContext *cr) {
 
 privileged void _ntlinux2context(struct NtContext *cr, const ucontext_t *ctx) {
   if (!cr) return;
-  cr->EFlags = ctx->uc_flags;
   cr->EFlags = ctx->uc_mcontext.eflags;
   cr->Rax = ctx->uc_mcontext.rax;
   cr->Rbx = ctx->uc_mcontext.rbx;

libc/calls/ntspawn.c

@@ -18,9 +18,7 @@
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/calls/ntspawn.h"
 #include "libc/calls/syscall_support-nt.internal.h"
-#include "libc/intrin/kprintf.h"
 #include "libc/intrin/pushpop.h"
-#include "libc/intrin/strace.internal.h"
 #include "libc/macros.internal.h"
 #include "libc/nt/enum/filemapflags.h"
 #include "libc/nt/enum/pageflags.h"
@@ -80,6 +78,8 @@ textwindows int ntspawn(
   rc = -1;
   block = NULL;
   if (__mkntpath(prog, prog16) == -1) return -1;
+  // we can't call malloc() because we're higher in the topological order
+  // we can't call kmalloc() because fork() calls this when kmalloc is locked
   if ((handle = CreateFileMapping(-1, 0, pushpop(kNtPageReadwrite), 0,
                                   sizeof(*block), 0)) &&
       (block = MapViewOfFileEx(handle, kNtFileMapRead | kNtFileMapWrite, 0, 0,

libc/calls/oldbench.c

@@ -53,7 +53,7 @@ static long double GetTimeSample(void) {
 static long double MeasureNanosPerCycle(void) {
   int i, n;
   long double avg, samp;
-  __get_tls()->tib_flags |= TIB_FLAG_TIME_CRITICAL;
+  if (__tls_enabled) __get_tls()->tib_flags |= TIB_FLAG_TIME_CRITICAL;
   if (IsWindows()) {
     n = 30;
   } else {
@@ -63,7 +63,7 @@ static long double MeasureNanosPerCycle(void) {
     samp = GetTimeSample();
     avg += (samp - avg) / i;
   }
-  __get_tls()->tib_flags &= ~TIB_FLAG_TIME_CRITICAL;
+  if (__tls_enabled) __get_tls()->tib_flags &= ~TIB_FLAG_TIME_CRITICAL;
   STRACE("MeasureNanosPerCycle cpn*1000=%d", (long)(avg * 1000));
   return avg;
 }

libc/calls/open-nt.c

@@ -88,7 +88,7 @@ textwindows int sys_open_nt(int dirfd, const char *file, uint32_t flags,
       rc = sys_open_nt_file(dirfd, file, flags, mode, fd);
     }
     if (rc == -1) {
-      __releasefd_unlocked(fd);
+      __releasefd(fd);
     }
     __fds_unlock();
   }

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,23 +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,7 +157,9 @@ int openat(int dirfd, const char *file, int flags, ...) {
   va_start(va, flags);
   mode = va_arg(va, unsigned);
   va_end(va);
-  if (file && (!IsAsan() || __asan_is_valid(file, 1))) {
+  BEGIN_CANCELLATION_POINT;
+
+  if (file && (!IsAsan() || __asan_is_valid_str(file))) {
     if (!__isfdkind(dirfd, kFdZip)) {
       if (_weaken(__zipos_open) &&
           _weaken(__zipos_parseuri)(file, &zipname) != -1) {
@@ -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);