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

.github/workflows/build.yml

@@ -4,12 +4,10 @@ on:
   push:
     branches:
       - "master"
-      - "vista"
       - "flake"
   pull_request:
     branches:
       - "master"
-      - "vista"
 
   # run workflow manually from the Actions tab
   workflow_dispatch:
@@ -23,8 +21,11 @@ jobs:
     steps:
       - uses: actions/checkout@v3
 
-      - name: support ape bins
-        run: sudo sh -c "echo ':APE:M::MZqFpD::/bin/sh:' >/proc/sys/fs/binfmt_misc/register"
+      - name: support ape bins 1
+        run: sudo cp build/bootstrap/ape.elf /usr/bin/ape
+
+      - name: support ape bins 2
+        run: sudo sh -c "echo ':APE:M::MZqFpD::/usr/bin/ape:' >/proc/sys/fs/binfmt_misc/register"
 
       - name: make matrix
         run: V=0 make -j2 MODE=${{ matrix.mode }}

Makefile

@@ -60,7 +60,7 @@
 #   build/config.mk
 
 SHELL      = build/bootstrap/cocmd.com
-HOSTS     ?= freebsd openbsd netbsd rhel7 rhel5 win10 xnu
+HOSTS     ?= freebsd openbsd netbsd rhel7 rhel5 xnu win10 win10:31336
 MAKEFLAGS += --no-builtin-rules
 
 .SUFFIXES:
@@ -68,6 +68,12 @@ MAKEFLAGS += --no-builtin-rules
 .FEATURES: output-sync
 .PHONY: all o bins check test depend tags
 
+ifneq ($(m),)
+ifeq ($(MODE),)
+MODE := $(m)
+endif
+endif
+
 all:	o
 o:	o/$(MODE)
 
@@ -86,9 +92,10 @@ o/$(MODE):			\
 .UNVEIL =			\
 	libc/integral		\
 	libc/disclaimer.inc	\
+	rwc:/dev/shm		\
 	rx:build/bootstrap	\
 	rx:o/third_party/gcc	\
-	/proc/self/status	\
+	/proc/stat		\
 	rw:/dev/null		\
 	w:o/stack.log		\
 	/etc/hosts		\
@@ -115,11 +122,13 @@ include third_party/compiler_rt/compiler_rt.mk	# │
 include libc/str/str.mk				# │
 include third_party/xed/xed.mk			# │
 include third_party/zlib/zlib.mk		# │
+include third_party/double-conversion/dc.mk	# │
 include libc/elf/elf.mk				# │
 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		# │
@@ -128,6 +137,7 @@ include libc/mem/mem.mk				#─┐
 include libc/zipos/zipos.mk			# ├──DYNAMIC RUNTIME
 include third_party/gdtoa/gdtoa.mk		# │  You can now use stdio
 include libc/time/time.mk			# │  You can finally call malloc()
+include third_party/nsync/mem/mem.mk		# │
 include libc/thread/thread.mk			# │
 include libc/stdio/stdio.mk			# │
 include third_party/libcxx/libcxx.mk		# │
@@ -142,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
@@ -153,6 +162,7 @@ include net/https/https.mk			# │
 include third_party/regex/regex.mk		#─┘
 include third_party/tidy/tidy.mk
 include third_party/third_party.mk
+include third_party/nsync/testing/testing.mk
 include libc/testlib/testlib.mk
 include tool/viz/lib/vizlib.mk
 include tool/args/args.mk
@@ -160,8 +170,9 @@ include test/tool/args/test.mk
 include third_party/linenoise/linenoise.mk
 include third_party/maxmind/maxmind.mk
 include net/finger/finger.mk
-include third_party/double-conversion/double-conversion.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
@@ -195,6 +206,7 @@ include tool/hash/hash.mk
 include tool/net/net.mk
 include tool/viz/viz.mk
 include tool/tool.mk
+include net/turfwar/turfwar.mk
 include test/libc/tinymath/test.mk
 include test/libc/intrin/test.mk
 include test/libc/mem/test.mk
@@ -265,98 +277,102 @@ o/$(MODE)/srcs-old.txt: o/$(MODE)/.x $(MAKEFILES) $(call uniq,$(foreach x,$(SRCS
 o/$(MODE)/hdrs-old.txt: o/$(MODE)/.x $(MAKEFILES) $(call uniq,$(foreach x,$(HDRS) $(INCS),$(dir $(x))))
 	$(file >$@) $(foreach x,$(HDRS) $(INCS),$(file >>$@,$(x)))
 
-TAGS: .UNSANDBOXED = 1
+TAGS: private .UNSANDBOXED = 1
 TAGS:	o/$(MODE)/srcs-old.txt $(SRCS)
 	@$(RM) $@
 	@$(TAGS) $(TAGSFLAGS) -L $< -o $@
 
-HTAGS: .UNSANDBOXED = 1
+HTAGS: private .UNSANDBOXED = 1
 HTAGS:	o/$(MODE)/hdrs-old.txt $(HDRS)
 	@$(RM) $@
 	@build/htags -L $< -o $@
 
-loc: .UNSANDBOXED = 1
+loc: private .UNSANDBOXED = 1
 loc: o/$(MODE)/tool/build/summy.com
 	find -name \*.h -or -name \*.c -or -name \*.S | \
 	$(XARGS) wc -l | grep total | awk '{print $$1}' | $<
 
-COSMOPOLITAN_OBJECTS =		\
-	NET_HTTP		\
-	LIBC_DNS		\
-	LIBC_SOCK		\
-	LIBC_NT_WS2_32		\
-	LIBC_NT_IPHLPAPI	\
-	LIBC_NT_MSWSOCK		\
-	LIBC_X			\
-	THIRD_PARTY_GETOPT	\
-	LIBC_LOG		\
-	LIBC_TIME		\
-	LIBC_ZIPOS		\
-	THIRD_PARTY_ZLIB	\
-	THIRD_PARTY_MUSL	\
-	LIBC_STDIO		\
-	THIRD_PARTY_GDTOA	\
-	THIRD_PARTY_REGEX	\
-	LIBC_MEM		\
-	THIRD_PARTY_DLMALLOC	\
-	LIBC_RUNTIME		\
-	THIRD_PARTY_NSYNC	\
-	LIBC_ELF		\
-	LIBC_CALLS		\
-	LIBC_SYSV_CALLS		\
-	LIBC_NT_PSAPI		\
-	LIBC_NT_POWRPROF	\
-	LIBC_NT_PDH		\
-	LIBC_NT_GDI32		\
-	LIBC_NT_COMDLG32	\
-	LIBC_NT_URL		\
-	LIBC_NT_USER32		\
-	LIBC_NT_NTDLL		\
-	LIBC_NT_ADVAPI32	\
-	LIBC_FMT		\
-	THIRD_PARTY_COMPILER_RT	\
-	LIBC_THREAD		\
-	LIBC_TINYMATH		\
-	THIRD_PARTY_XED		\
-	LIBC_STR		\
-	LIBC_SYSV		\
-	LIBC_INTRIN		\
-	LIBC_NT_KERNEL32	\
-	LIBC_NEXGEN32E		\
-	LIBC_VGA
+# PLEASE: MAINTAIN TOPOLOGICAL ORDER
+# FROM HIGHEST LEVEL TO LOWEST LEVEL
+COSMOPOLITAN_OBJECTS =			\
+	NET_HTTP			\
+	LIBC_DNS			\
+	LIBC_SOCK			\
+	LIBC_NT_WS2_32			\
+	LIBC_NT_IPHLPAPI		\
+	LIBC_NT_MSWSOCK			\
+	LIBC_X				\
+	THIRD_PARTY_GETOPT		\
+	LIBC_LOG			\
+	LIBC_TIME			\
+	LIBC_ZIPOS			\
+	THIRD_PARTY_ZLIB		\
+	THIRD_PARTY_MUSL		\
+	LIBC_STDIO			\
+	THIRD_PARTY_GDTOA		\
+	THIRD_PARTY_REGEX		\
+	LIBC_THREAD			\
+	THIRD_PARTY_NSYNC_MEM		\
+	LIBC_MEM			\
+	THIRD_PARTY_DLMALLOC		\
+	LIBC_RUNTIME			\
+	THIRD_PARTY_NSYNC		\
+	LIBC_ELF			\
+	LIBC_CALLS			\
+	LIBC_SYSV_CALLS			\
+	LIBC_VGA			\
+	LIBC_NT_PSAPI			\
+	LIBC_NT_POWRPROF		\
+	LIBC_NT_PDH			\
+	LIBC_NT_GDI32			\
+	LIBC_NT_COMDLG32		\
+	LIBC_NT_URL			\
+	LIBC_NT_USER32			\
+	LIBC_NT_NTDLL			\
+	LIBC_NT_ADVAPI32		\
+	LIBC_NT_SYNCHRONIZATION		\
+	LIBC_FMT			\
+	THIRD_PARTY_COMPILER_RT		\
+	LIBC_TINYMATH			\
+	THIRD_PARTY_XED			\
+	LIBC_STR			\
+	LIBC_SYSV			\
+	LIBC_INTRIN			\
+	LIBC_NT_KERNEL32		\
+	LIBC_NEXGEN32E
 
-COSMOPOLITAN_HEADERS =		\
-	APE			\
-	LIBC			\
-	LIBC_CALLS		\
-	LIBC_DNS		\
-	LIBC_ELF		\
-	LIBC_FMT		\
-	LIBC_INTRIN		\
-	LIBC_LOG		\
-	LIBC_MEM		\
-	LIBC_NEXGEN32E		\
-	LIBC_NT			\
-	LIBC_RUNTIME		\
-	LIBC_SOCK		\
-	LIBC_STDIO		\
-	THIRD_PARTY_NSYNC	\
-	THIRD_PARTY_XED		\
-	LIBC_STR		\
-	LIBC_SYSV		\
-	LIBC_THREAD		\
-	LIBC_TIME		\
-	LIBC_TINYMATH		\
-	LIBC_X			\
-	LIBC_ZIPOS		\
-	LIBC_VGA		\
-	NET_HTTP		\
-	THIRD_PARTY_DLMALLOC	\
-	THIRD_PARTY_GDTOA	\
-	THIRD_PARTY_GETOPT	\
-	THIRD_PARTY_MUSL	\
-	THIRD_PARTY_ZLIB	\
-	THIRD_PARTY_ZLIB_GZ	\
+COSMOPOLITAN_HEADERS =			\
+	APE				\
+	LIBC				\
+	LIBC_CALLS			\
+	LIBC_DNS			\
+	LIBC_ELF			\
+	LIBC_FMT			\
+	LIBC_INTRIN			\
+	LIBC_LOG			\
+	LIBC_MEM			\
+	LIBC_NEXGEN32E			\
+	LIBC_NT				\
+	LIBC_RUNTIME			\
+	LIBC_SOCK			\
+	LIBC_STDIO			\
+	THIRD_PARTY_NSYNC		\
+	THIRD_PARTY_XED			\
+	LIBC_STR			\
+	LIBC_SYSV			\
+	LIBC_THREAD			\
+	LIBC_TIME			\
+	LIBC_TINYMATH			\
+	LIBC_X				\
+	LIBC_ZIPOS			\
+	LIBC_VGA			\
+	NET_HTTP			\
+	THIRD_PARTY_DLMALLOC		\
+	THIRD_PARTY_GDTOA		\
+	THIRD_PARTY_GETOPT		\
+	THIRD_PARTY_MUSL		\
+	THIRD_PARTY_ZLIB		\
+	THIRD_PARTY_ZLIB_GZ		\
 	THIRD_PARTY_REGEX
 
 o/$(MODE)/cosmopolitan.a:	\
@@ -370,7 +386,7 @@ o/cosmopolitan.h:							\
 	$(file >$(TMPDIR)/$(subst /,_,$@),libc/integral/normalize.inc $(foreach x,$(COSMOPOLITAN_HEADERS),$($(x)_HDRS)))
 	@$(COMPILE) -AROLLUP -T$@ o/$(MODE)/tool/build/rollup.com @$(TMPDIR)/$(subst /,_,$@) >$@
 
-o/cosmopolitan.html: .UNSANDBOXED = 1
+o/cosmopolitan.html: private .UNSANDBOXED = 1
 o/cosmopolitan.html:							\
 		o/$(MODE)/third_party/chibicc/chibicc.com.dbg		\
 		$(filter-out %.s,$(foreach x,$(COSMOPOLITAN_OBJECTS),$($(x)_SRCS)))	\
@@ -389,6 +405,15 @@ $(SRCS):					\
 	libc/integral/lp64arg.inc		\
 	libc/integral/lp64.inc
 
+.PHONY: toolchain
+toolchain:	o/cosmopolitan.h				\
+		o/$(MODE)/ape/public/ape.lds			\
+		o/$(MODE)/libc/crt/crt.o			\
+		o/$(MODE)/ape/ape.o				\
+		o/$(MODE)/ape/ape-copy-self.o			\
+		o/$(MODE)/ape/ape-no-modify-self.o		\
+		o/$(MODE)/cosmopolitan.a
+
 # UNSPECIFIED PREREQUISITES TUTORIAL
 #
 # A build rule must exist for all files that make needs to consider in

README.md

@@ -1,10 +1,7 @@
 ![Cosmopolitan Honeybadger](usr/share/img/honeybadger.png)
 
 [![build](https://github.com/jart/cosmopolitan/actions/workflows/build.yml/badge.svg)](https://github.com/jart/cosmopolitan/actions/workflows/build.yml)
-# Cosmopolitan (Vista Edition)
-
-**This is a community supported legacy branch of Cosmopolitan 2.0 that's
-intended to preserve compatibility with Windows Vista and Windows 7.**
+# Cosmopolitan
 
 [Cosmopolitan Libc](https://justine.lol/cosmopolitan/index.html) makes C
 a build-once run-anywhere language, like Java, except it doesn't need an
@@ -26,11 +23,11 @@ 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.0.1.zip
-unzip cosmopolitan-amalgamation-2.0.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 \
+  -fno-omit-frame-pointer -pg -mnop-mcount -mno-tls-direct-seg-refs -gdwarf-4 \
   -o hello.com.dbg hello.c -fuse-ld=bfd -Wl,-T,ape.lds -Wl,--gc-sections \
   -include cosmopolitan.h crt.o ape-no-modify-self.o cosmopolitan.a
 objcopy -S -O binary hello.com.dbg hello.com
@@ -103,7 +100,7 @@ heavyweight features like tracing to your binaries by default. In that
 case, you may want to consider using our build system:
 
 ```sh
-make -j8 MODE=tiny
+make m=tiny
 ```
 
 Which will cause programs such as `hello.com` and `life.com` to shrink
@@ -158,7 +155,7 @@ cd cosmopolitan
 This will build the entire repository and run all the tests:
 
 ```sh
-build/bootstrap/make.com -j16
+build/bootstrap/make.com
 o//examples/hello.com
 find o -name \*.com | xargs ls -rShal | less
 ```
@@ -177,7 +174,7 @@ having minimal deterministic builds. For example, if you wanted to build
 only hello.com then you could do that as follows:
 
 ```sh
-build/bootstrap/make.com -j16 o//examples/hello.com
+build/bootstrap/make.com o//examples/hello.com
 ```
 
 Sometimes it's desirable to build a subset of targets, without having to
@@ -186,7 +183,7 @@ directory name. For example, if you wanted to build only the targets and
 subtargets of the chibicc package including its tests, you would say:
 
 ```sh
-build/bootstrap/make.com -j16 o//third_party/chibicc
+build/bootstrap/make.com o//third_party/chibicc
 o//third_party/chibicc/chibicc.com --help
 ```
 
@@ -194,18 +191,19 @@ Cosmopolitan provides a variety of build modes. For example, if you want
 really tiny binaries (as small as 12kb in size) then you'd say:
 
 ```sh
-build/bootstrap/make.com -j16 MODE=tiny
+build/bootstrap/make.com m=tiny
 ```
 
 Here's some other build modes you can try:
 
 ```sh
-build/bootstrap/make.com -j16 MODE=dbg       # asan + ubsan + debug
-build/bootstrap/make.com -j16 MODE=asan      # production memory safety
-build/bootstrap/make.com -j16 MODE=opt       # -march=native optimizations
-build/bootstrap/make.com -j16 MODE=rel       # traditional release binaries
-build/bootstrap/make.com -j16 MODE=optlinux  # optimal linux-only performance
-build/bootstrap/make.com -j16 MODE=tinylinux # tiniest linux-only 4kb binaries
+build/bootstrap/make.com m=dbg       # asan + ubsan + debug
+build/bootstrap/make.com m=asan      # production memory safety
+build/bootstrap/make.com m=opt       # -march=native optimizations
+build/bootstrap/make.com m=rel       # traditional release binaries
+build/bootstrap/make.com m=optlinux  # optimal linux-only performance
+build/bootstrap/make.com m=fastbuild # build 28% faster w/o debugging
+build/bootstrap/make.com m=tinylinux # tiniest linux-only 4kb binaries
 ```
 
 For further details, see [//build/config.mk](build/config.mk).
@@ -247,21 +245,27 @@ gdb foo.com -ex 'add-symbol-file foo.com.dbg 0x401000'
 | :---            | ---:        | ---:  |
 | AMD             | K8 Venus    | 2005  |
 | Intel           | Core        | 2006  |
-| Windows         | Vista       | 2006  |
 | Linux           | 2.6.18      | 2007  |
+| Windows         | 8 [1]       | 2012  |
 | Mac OS X        | 15.6        | 2018  |
-| FreeBSD         | 13          | 2020  |
 | 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
 [GitHub Sponsors](https://github.com/sponsors/jart) and
 [Patreon](https://www.patreon.com/jart). Your support is what makes this
 project possible. Thank you! We'd also like to give special thanks to
-the following individuals:
+the following groups and individuals:
 
 - [Joe Drumgoole](https://github.com/jdrumgoole)
+- [Rob Figueiredo](https://github.com/robfig)
+- [Wasmer](https://wasmer.io/)
 
 For publicly sponsoring our work at the highest tier.

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
@@ -125,6 +134,7 @@ ape_mz:	.asciz	"MZqFpD='\n"		# Mark 'Zibo' Joseph Zbikowski
 	.org	0x24			# MZ: bytes reserved for you
 	.ascii	"JT"			# MZ: OEM identifier
 	.short	0			# MZ: OEM information
+	.ascii	"' <<'@'\n"
 	.org	0x40-4			# MZ: bytes reserved for you
 #if SupportsWindows() || SupportsMetal()
 	.long	RVA(ape_pe)		# PE: the new technology
@@ -235,8 +245,9 @@ pc:	cld
 #endif
 	ljmp	$0,$REAL(1f)
 1:	mov	%cx,%ds
-	mov	$IMAGE_BASE_REAL-0x0500,%cx	# clears bss
-	mov	$0x0500>>4,%ax			# struct mman
+	.set	mm,0x0500			# struct mman
+	mov	$IMAGE_BASE_REAL-mm,%cx		# clears bss
+	mov	$mm>>4,%ax
 	mov	%ax,%es
 	xor	%ax,%ax
 	xor	%di,%di
@@ -249,7 +260,6 @@ pc:	cld
 	xor	%cx,%cx				# current cylinder
 	xor	%dh,%dh				# current head
 	mov	$v_ape_realsectors,%di		# total sectors
-	sub	$v_ape_realslacksectors,%di
 3:	call	pcread
 	dec	%di
 	jnz	3b
@@ -328,7 +338,7 @@ dsknfo:	push	%bx
 	movpp	%es,%ds
 	xor	%si,%si
 	mov	%si,%es
-	mov	$0x1d10,%si		# mman::pc_drive_base_table
+	mov	$mm+"struct mman::pc_drive_base_table",%si
 	xchg	%si,%di
 	movsw	#→ headunloadtime, headloadtime
 	movsw	#→ shutofftime, bytespersector
@@ -381,11 +391,11 @@ pcread:	push	%ax
 	add	$512>>4,%si
 	mov	%si,%es
 	inc	%al			# ++sector
-	cmp	0x1d1c,%al		# mman::pc_drive_last_sector
+	cmp	mm+"struct mman::pc_drive_last_sector",%al
 	jbe	2f
 	mov	$1,%al
 	inc	%dh			# ++head
-	cmp	0x1d20,%dh		# mman::pc_drive_last_head
+	cmp	mm+"struct mman::pc_drive_last_head",%dh
 	jbe	2f
 	xor	%dh,%dh
 	inc	%cx			# ++cylinder
@@ -548,7 +558,7 @@ ape_disk:
 	the bourne executable & linkable format */
 
 #if SupportsWindows() || SupportsMetal() || SupportsXnu()
-apesh:	.ascii	"'\n#'\"\n"			# sixth edition shebang
+apesh:	.ascii	"\n@\n#'\"\n"			# sixth edition shebang
 //	Until all operating systems can be updated to support APE,
 //	we have a beautiful, yet imperfect workaround, which is to
 //	modify the binary to follow the local system's convention.
@@ -873,7 +883,7 @@ ape_macho:
 	.long	(520f-510f)/4			# count
 510:	.quad	0				# rax
 	.quad	IMAGE_BASE_VIRTUAL		# rbx
-	.quad	XNU				# rcx
+	.quad	_HOSTXNU			# rcx
 	.quad	0				# rdx
 	.quad	0				# rdi
 	.quad	0				# rsi
@@ -1136,12 +1146,17 @@ sconf:	.short	1843200/*hz*/ / 16/*wut*/ / 9600/*baud*/
 	.endobj	sconf,global,hidden
 
 //	Global Descriptor Table
-//
-//	@note address portion only concern legacy modes
 	.align	8
-gdt:	.short	2f-1f		# table byte length
-	.long	REAL(1f),0	# table address
-	.zero	2
+_gdtrphy:
+	.short	2f-1f-1		# table byte length
+	.long	REAL(1f)	# table address (physical space)
+	.endobj	_gdtrphy,global,hidden
+_gdtr:
+	.short	2f-1f-1		# table byte length
+	.quad	1f		# table address (final virtual space)
+	.endobj	_gdtr,global,hidden
+	.align	8
+_gdt:
 1:
 //	          ┌G:granularity (1 → limit *= 0x1000)
 //	          │┌D/B:default operation size (0 = 16|64bit, 1 = 32-bit)
@@ -1171,7 +1186,9 @@ gdt:	.short	2f-1f		# table byte length
 .quad	0b0000000011001111100100100000000000000000000000001111111111111111 #32
 .quad	0b0000000010101111100110110000000000000000000000001111111111111111 #40
 .quad	0b0000000010101111100100110000000000000000000000001111111111111111 #48
-2:	.endobj	gdt,global,hidden
+.tssdescstub _tss							#56,64
+2:
+	.endobj	_gdt,global,hidden
 
 /*─────────────────────────────────────────────────────────────────────────────╗
 │ αcτµαlly pδrταblε εxεcµταblε § real mode                                     │
@@ -1277,8 +1294,8 @@ lcheck:	pushf				# check for i8086 / i8088 / i80186
 	jl	10f
 	mov	%edi,%eax
 	cpuid
-	mov	$1<<29,%edi		# need nexgen32e long mode support
-	and	%edi,%edx
+	mov	$1<<29|1<<20,%edi	# need nexgen32e long mode support
+	and	%edi,%edx		# & nx support
 	cmp	%edi,%edx
 	jne	10f
 	xor	%ax,%ax
@@ -1288,10 +1305,9 @@ lcheck:	pushf				# check for i8086 / i8088 / i80186
 	.endfn	lcheck
 
 //	Gets memory map from BIOS.
-e820:	mov	$0x0510>>4,%di		# mman::e820
-	mov	%di,%es
-	xor	%di,%di			# es:di is destination buffer
-	xor	%ebx,%ebx		# ebx is an api state tracker
+e820:	xor	%ebx,%ebx		# %ebx is an api state tracker
+	mov	%bx,%es
+	mov	$mm+"struct mman::e820",%di # es:di is destination buffer
 1:	mov	$0xE820,%eax		# magic
 	mov	$8+8+4+4,%ecx		# sizeof(struct SmapEntry)
 	mov	$0x534d4150,%edx	# magic number
@@ -1315,7 +1331,7 @@ e820:	mov	$0x0510>>4,%di		# mman::e820
 4:	add	$8+8+4+4,%di		# keep entry
 5:	test	%ebx,%ebx		# last entry?
 	jz	8f
-	cmp	$(256-1)*(8+8+4+4),%di
+	cmp	$mm+"struct mman::e820_end"-(8+8+4+4),%di
 	jb	1b
 8:	xor	%ax,%ax			# add a blank sentinel entry
 	mov	$(8+8)/2,%cx
@@ -1408,7 +1424,7 @@ pinit:	push	%ds
 	movl	$0x79000+PAGE_V+PAGE_RW,0x7b000-SEG	# PD←PDT     (+)
 	movl	$0x79000+PAGE_V+PAGE_RW,0x7a000-SEG	# PD←PDT     (-)
 	mov	$512,%cx				# PD±2MB
-	mov	$PAGE_V+PAGE_RW,%eax
+	mov	$PAGE_V+PAGE_RSRV+PAGE_RW,%eax
 	xor	%di,%di
 0:	stosl
 	add	$0x1000,%eax
@@ -1425,15 +1441,15 @@ pinit:	push	%ds
 //
 //	@see	Intel Manual V3A §4.1.2
 golong:	cli
-	lidt	0x1d22					# mman::bad_idt
+	lidt	mm+"struct mman::bad_idt"
 	mov	%cr4,%eax
 	or	$CR4_PAE|CR4_PGE|CR4_OSFXSR,%eax
 	mov	%eax,%cr4
 	movl	$EFER,%ecx
 	rdmsr
-	or	$EFER_LME|EFER_SCE,%eax
+	or	$EFER_LME|EFER_SCE|EFER_NXE,%eax
 	wrmsr
-	lgdt	REAL(gdt)
+	lgdt	REAL(_gdtrphy)
 	mov	%cr0,%eax
 	or	$CR0_PE|CR0_PG|CR0_MP,%eax
 	and	$~CR0_EM,%eax
@@ -1451,6 +1467,8 @@ long:	xor	%eax,%eax
 	mov	%eax,%fs
 	mov	%eax,%gs
 	mov	$0x80000,%esp
+	mov	$GDT_LONG_TSS,%al
+	ltr	%ax
 	xor	%r12d,%r12d
 	xor	%r13d,%r13d
 	xor	%r14d,%r14d
@@ -1458,12 +1476,14 @@ long:	xor	%eax,%eax
 	xor	%ebx,%ebx
 	xor	%ebp,%ebp
 	push	%rbp
-	mov	$0x0500,%rdi			# mman
+	mov	$mm,%rdi
 	mov	%cr3,%rsi
 	mov	$IMAGE_BASE_REAL,%edx
 	call	__map_phdrs
 	push	$0x037f
 	fldcw	(%rsp)
+	lgdt	_gdtr					# reload GDTR for
+							# virtual memory space
 	movabs	$kernel,%rax
 	jmp	*%rax
 	.endfn	long
@@ -1544,21 +1564,21 @@ kernel:	movabs	$ape_stack_vaddr,%rsp
 	.byte	0x0f,0x1f,0207			# nop rdi binbase
 	.long	(IMAGE_BASE_VIRTUAL-IMAGE_BASE_REAL)/512
 #endif
-	push	$METAL				# sets __hostos in crt.S
+	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
@@ -1574,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() */
@@ -1586,7 +1609,6 @@ kernel:	movabs	$ape_stack_vaddr,%rsp
 	.ldsvar	_end
 	.ldsvar	_etext
 	.ldsvar	v_ape_realsectors
-	.ldsvar	v_ape_realslacksectors
 	.ldsvar	v_ape_highsectors
 	.ldsvar	ape_idata_ro
 	.ldsvar	ape_pad_rodata

ape/ape.lds

@@ -427,7 +427,7 @@ SECTIONS {
 
     KEEP(*(.bssepilogue))
 /*END: NT FORK COPYING */
-    . = ALIGN(FRAMESIZE); /* for brk()/sbrk() allocation */
+    . = ALIGN(PAGESIZE);
     HIDDEN(_end = .);
     PROVIDE_HIDDEN(end = .);
   } :Bss
@@ -458,6 +458,7 @@ SECTIONS {
   .debug_line        0 : { *(.debug_line .debug_line.* .debug_line_end ) }
   .debug_frame       0 : { *(.debug_frame) }
   .debug_str         0 : { *(.debug_str) }
+  .debug_line_str    0 : { *(.debug_line_str) }
   .debug_loc         0 : { *(.debug_loc) }
   .debug_macinfo     0 : { *(.debug_macinfo) }
   .debug_weaknames   0 : { *(.debug_weaknames) }
@@ -466,6 +467,7 @@ SECTIONS {
   .debug_varnames    0 : { *(.debug_varnames) }
   .debug_pubtypes    0 : { *(.debug_pubtypes) }
   .debug_ranges      0 : { *(.debug_ranges) }
+  .debug_rnglists    0 : { *(.debug_rnglists) }
   .debug_macro       0 : { *(.debug_macro) }
   .debug_addr        0 : { *(.debug_addr) }
   .gnu.attributes    0 : { KEEP(*(.gnu.attributes)) }
@@ -563,13 +565,11 @@ SHSTUB2(ape_loader_dd_count,
 #if SupportsMetal()
 HIDDEN(v_ape_realsectors =
            MIN(0x70000 - IMAGE_BASE_REAL,
-               ROUNDUP(RVA(_edata), 4096)) / 512);
-HIDDEN(v_ape_realslacksectors =
-           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
 
 /* ZIP End of Central Directory header */

ape/ape.mk

@@ -65,6 +65,7 @@ o/$(MODE)/ape/ape.lds:				\
 		libc/intrin/bits.h		\
 		libc/thread/tls.h		\
 		libc/calls/struct/timespec.h	\
+		libc/thread/thread.h		\
 		libc/dce.h			\
 		libc/elf/def.h			\
 		libc/elf/pf2prot.internal.h	\
@@ -82,6 +83,7 @@ o/$(MODE)/ape/public/ape.lds:			\
 		libc/intrin/bits.h		\
 		libc/thread/tls.h		\
 		libc/calls/struct/timespec.h	\
+		libc/thread/thread.h		\
 		libc/dce.h			\
 		libc/elf/def.h			\
 		libc/elf/pf2prot.internal.h	\
@@ -105,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	\
@@ -131,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/idata.internal.h

@@ -32,23 +32,23 @@
 //	@see	ape/ape.lds
 //	@see	winimp
 .macro	.imp	dll:req fn:req actual:req hint
-	.dll	\dll
-	.section .piro.data.sort.iat.2.\dll\().2.\actual,"aw",@progbits
+	.dll	"\dll"
+	.section ".piro.data.sort.iat.2.\dll\().2.\actual","aw",@progbits
 	.type	\fn,@object
 	.align	__SIZEOF_POINTER__
-\fn:	.quad	RVA((\dll\().\actual))
+\fn:	.quad	RVA(("\dll\().\actual"))
 	.size	\fn,.-\fn
 	.globl	\fn
 	.hidden	\fn
 	.previous
-	.section .idata.ro.ilt.\dll\().2.\actual,"a",@progbits
-.Lidata.ilt.\dll\().\actual:
-	.quad	RVA((\dll\().\actual))
-	.type	.Lidata.ilt.\dll\().\actual,@object
-	.size	.Lidata.ilt.\dll\().\actual,.-.Lidata.ilt.\dll\().\actual
+	.section ".idata.ro.ilt.\dll\().2.\actual","a",@progbits
+".Lidata.ilt.\dll\().\actual":
+	.quad	RVA("\dll\().\actual")
+	.type	".Lidata.ilt.\dll\().\actual",@object
+	.size	".Lidata.ilt.\dll\().\actual",.-".Lidata.ilt.\dll\().\actual"
 	.previous
-	.section .idata.ro.hnt.\dll\().2.\actual,"a",@progbits
-\dll\().\actual:
+	.section ".idata.ro.hnt.\dll\().2.\actual","a",@progbits
+"\dll\().\actual":
 	.ifnb	\hint			# hint i.e. guess function ordinal
 	.short	\hint
 	.else
@@ -56,55 +56,55 @@
 	.endif
 	.asciz	"\actual"
 	.align	2			# documented requirement
-	.globl	\dll\().\actual
-	.hidden	\dll\().\actual
-	.type	\dll\().\actual,@object
-	.size	\dll\().\actual,.-\dll\().\actual
+	.globl	"\dll\().\actual"
+	.hidden	"\dll\().\actual"
+	.type	"\dll\().\actual",@object
+	.size	"\dll\().\actual",.-"\dll\().\actual"
 	.previous
 .endm
 
 //	Defines DLL import.
 //	@note	this is an implementation detail of .imp
 .macro	.dll	name:req
-  .section .idata.ro.idt.2.\name,"aG",@progbits,\name,comdat
-	.equ	.Lidata.idt.\name,.
-	.long	RVA(idata.ilt.\name)		# ImportLookupTable
+  .section ".idata.ro.idt.2.\name","aG",@progbits,"\name",comdat
+	.equ	".Lidata.idt.\name",.
+	.long	RVA("idata.ilt.\name")		# ImportLookupTable
 	.long	0				# TimeDateStamp
 	.long	0				# ForwarderChain
-	.long	RVA(.Lidata.str.\name)		# DllNameRva
-	.long	RVA(idata.iat.\name)		# ImportAddressTable
-	.type	.Lidata.idt.\name,@object
-	.size	.Lidata.idt.\name,.-.Lidata.idt.\name
+	.long	RVA(".Lidata.str.\name")	# DllNameRva
+	.long	RVA("idata.iat.\name")		# ImportAddressTable
+	.type	".Lidata.idt.\name",@object
+	.size	".Lidata.idt.\name",.-".Lidata.idt.\name"
   .previous
-  .section .idata.ro.ilt.\name\().1,"aG",@progbits,\name,comdat
+  .section ".idata.ro.ilt.\name\().1","aG",@progbits,"\name",comdat
 	.align	__SIZEOF_POINTER__
-	.type	idata.ilt.\name,@object
-idata.ilt.\name:
+	.type	"idata.ilt.\name",@object
+"idata.ilt.\name":
 	.previous/*
 	...
 	decentralized content
 	...
-	*/.section .idata.ro.ilt.\name\().3,"aG",@progbits,\name,comdat
+	*/.section ".idata.ro.ilt.\name\().3","aG",@progbits,"\name",comdat
 	.quad	0
   .previous
-  .section .idata.ro.hnt.\name\().1,"aG",@progbits,\name,comdat
+  .section ".idata.ro.hnt.\name\().1","aG",@progbits,"\name",comdat
 	.align	__SIZEOF_POINTER__
-	.type	idata.hnt.\name,@object
-	.equ	idata.hnt.\name,.
+	.type	"idata.hnt.\name",@object
+	.equ	"idata.hnt.\name",.
   .previous
-  .section .piro.data.sort.iat.2.\name\().1,"awG",@progbits,\name,comdat
+  .section ".piro.data.sort.iat.2.\name\().1","awG",@progbits,"\name",comdat
 	.align	__SIZEOF_POINTER__
-	.type	idata.iat.\name,@object
-idata.iat.\name:
+	.type	"idata.iat.\name",@object
+"idata.iat.\name":
 	.previous/*
 	...
 	decentralized content
 	...
-	*/.section .piro.data.sort.iat.2.\name\().3,"awG",@progbits,\name,comdat
+	*/.section ".piro.data.sort.iat.2.\name\().3","awG",@progbits,"\name",comdat
 	.quad	0
   .previous
   .section .rodata.str1.1,"aSM",@progbits,1
-.Lidata.str.\name:
+".Lidata.str.\name":
 	.asciz	"\name\().dll"
   .previous
 .endm

ape/loader-elf.S

@@ -175,7 +175,7 @@ macho:	.long	0xFEEDFACE+1
 510:	.quad	0				# rax
 	.quad	0				# rbx
 	.quad	0				# rcx
-	.quad	XNU				# rdx
+	.quad	_HOSTXNU			# rdx
 	.quad	0				# rdi
 	.quad	0				# rsi
 	.quad	0				# rbp
@@ -221,7 +221,7 @@ _start:
 	jne	0f
 	cmp	$+1,%edx
 	jne	0f
-	mov	$XNU,%dl
+	mov	$_HOSTXNU,%dl
 	xor	%ecx,%ecx
 
 0:	mov	%rsp,%rsi

ape/loader-macho.S

@@ -90,7 +90,7 @@ macho:	.long	0xFEEDFACE+1
 510:	.quad	0				# rax
 	.quad	0				# rbx
 	.quad	0				# rcx
-	.quad	XNU				# rdx
+	.quad	_HOSTXNU			# rdx
 	.quad	0				# rdi
 	.quad	0				# rsi
 	.quad	0				# rbp
@@ -121,7 +121,7 @@ _start:
 	jne	0f
 	cmp	$+1,%edx
 	jne	0f
-	mov	$XNU,%dl
+	mov	$_HOSTXNU,%dl
 	xor	%ecx,%ecx
 
 0:	mov	%rsp,%rsi

ape/macros.internal.h

@@ -180,6 +180,20 @@
  .stub	\name\()_bcs\n,long
 .endm
 
+//	Task State Segment Descriptor Entries.
+.macro	.tssdescstub name:req
+ .ifndef \name
+  .weak	\name
+  .set	\name,0
+ .endif
+ .ifndef \name\()_end
+  .weak	\name\()_end
+  .set	\name\()_end,0
+ .endif
+ .stub	\name\()_desc_ent0,quad
+ .stub	\name\()_desc_ent1,quad
+.endm
+
 /* clang-format on */
 #elif defined(__LINKER__)
 
@@ -257,5 +271,22 @@
                        (X) % 10 * 0x1000000        \
                      : 0xffffffffffffffff)
 
+/**
+ * Laying out the GDT entries for a TSS for bare metal operation.
+ */
+#define TSSDESCSTUB2(SYM, BASE, LIM)                 \
+  HIDDEN(SYM##_desc_ent0 = TSSDESC_ENT0(BASE, LIM)); \
+  HIDDEN(SYM##_desc_ent1 = TSSDESC_ENT1(BASE));      \
+  ASSERT((LIM) >= 0 && (LIM) <= 0xffff, "bare metal TSS is suspiciously fat")
+#define TSSDESC_ENT0(BASE, LIM)                \
+  (((LIM)        <<  0 & 0x000000000000ffff) | \
+   ((BASE)       << 16 & 0x000000ffffff0000) | \
+    0x89         << 40                       | \
+   ((LIM)  >> 16 << 48 & 0x000f000000000000) | \
+    0x2          << 52                       | \
+   ((BASE) >> 24 << 56 & 0xff00000000000000))
+#define TSSDESC_ENT1(BASE)                     \
+   ((BASE) >> 32 <<  0 & 0x00000000ffffffff)
+
 #endif /* __ASSEMBLER__ */
 #endif /* APE_MACROS_H_ */

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
@@ -102,7 +102,7 @@ endif
 #   - Larger binaries
 #
 ifeq ($(MODE), asan)
-CONFIG_CCFLAGS += $(BACKTRACES) -O2
+CONFIG_CCFLAGS += $(BACKTRACES) -O2 -DSYSDEBUG
 CONFIG_COPTS += -fsanitize=address
 TARGET_ARCH ?= -msse3
 endif
@@ -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,12 @@ CONFIG_CCFLAGS +=			\
 	-fschedule-insns2		\
 	-fomit-frame-pointer		\
 	-momit-leaf-frame-pointer	\
-	-foptimize-sibling-calls
+	-foptimize-sibling-calls	\
+	-DDWARFLESS
+CONFIG_OFLAGS +=			\
+	-g0
+CONFIG_LDFLAGS +=			\
+	-S
 TARGET_ARCH ?=				\
 	-msse3
 PYFLAGS +=				\
@@ -177,9 +198,14 @@ CONFIG_CPPFLAGS +=			\
 	-DTINY				\
 	-DNDEBUG			\
 	-DTRUSTWORTHY			\
-	-DSUPPORT_VECTOR=1
+	-DSUPPORT_VECTOR=1		\
+	-DDWARFLESS
 DEFAULT_COPTS +=			\
 	-mred-zone
+CONFIG_OFLAGS +=			\
+	-g0
+CONFIG_LDFLAGS +=			\
+	-S
 CONFIG_CCFLAGS +=			\
 	-Os				\
 	-fno-align-functions		\
@@ -209,9 +235,14 @@ CONFIG_CPPFLAGS +=		\
 	-DTINY			\
 	-DNDEBUG		\
 	-DTRUSTWORTHY		\
-	-DSUPPORT_VECTOR=113
+	-DSUPPORT_VECTOR=113	\
+	-DDWARFLESS
 DEFAULT_COPTS +=		\
 	-mred-zone
+CONFIG_OFLAGS +=		\
+	-g0
+CONFIG_LDFLAGS +=		\
+	-S
 CONFIG_CCFLAGS +=		\
 	-Os			\
 	-fno-align-functions	\
@@ -240,7 +271,8 @@ CONFIG_CPPFLAGS +=		\
 	-DTINY			\
 	-DNDEBUG		\
 	-DTRUSTWORTHY		\
-	-DSUPPORT_VECTOR=121
+	-DSUPPORT_VECTOR=121	\
+	-DDWARFLESS
 DEFAULT_COPTS +=		\
 	-mred-zone
 CONFIG_CCFLAGS +=		\
@@ -249,6 +281,10 @@ CONFIG_CCFLAGS +=		\
 	-fno-align-jumps	\
 	-fno-align-labels	\
 	-fno-align-loops
+CONFIG_OFLAGS +=		\
+	-g0
+CONFIG_LDFLAGS +=		\
+	-S
 TARGET_ARCH ?=			\
 	-msse3
 endif
@@ -271,17 +307,44 @@ CONFIG_CPPFLAGS +=		\
 	-DTINY			\
 	-DNDEBUG		\
 	-DTRUSTWORTHY		\
-	-DSUPPORT_VECTOR=251
+	-DSUPPORT_VECTOR=251	\
+	-DDWARFLESS
 CONFIG_CCFLAGS +=		\
 	-Os			\
 	-fno-align-functions	\
 	-fno-align-jumps	\
 	-fno-align-labels	\
 	-fno-align-loops
+CONFIG_OFLAGS +=		\
+	-g0
+CONFIG_LDFLAGS +=		\
+	-S
 TARGET_ARCH ?=			\
 	-msse3
 endif
 
+# GCC11 Mode
+# https://justine.lol/compilers/x86_64-linux-musl__x86_64-linux-musl__g++-11.2.0.tar.xz
+ifeq ($(MODE), gcc11)
+.UNVEIL += rx:/opt/gcc11
+CONFIG_CCFLAGS += $(BACKTRACES) $(FTRACE) -DSYSDEBUG -O2
+AS = /opt/gcc11/bin/x86_64-linux-musl-as
+CC = /opt/gcc11/bin/x86_64-linux-musl-gcc
+CXX = /opt/gcc11/bin/x86_64-linux-musl-g++
+CXXFILT = /opt/gcc11/bin/x86_64-linux-musl-c++filt
+LD = /opt/gcc11/bin/x86_64-linux-musl-ld.bfd
+NM = /opt/gcc11/bin/x86_64-linux-musl-nm
+GCC = /opt/gcc11/bin/x86_64-linux-musl-gcc
+STRIP = /opt/gcc11/bin/x86_64-linux-musl-strip
+OBJCOPY = /opt/gcc11/bin/x86_64-linux-musl-objcopy
+OBJDUMP = /opt/gcc11/bin/x86_64-linux-musl-objdump
+ADDR2LINE = /opt/gcc11/bin/x86_64-linux-musl-addr2line
+CONFIG_CCFLAGS += $(BACKTRACES) $(FTRACE) -O2 -Wno-stringop-overread
+CONFIG_CFLAGS += -Wno-old-style-definition
+CONFIG_CPPFLAGS += -DNDEBUG -DSYSDEBUG
+TARGET_ARCH ?= -msse3
+endif
+
 # LLVM Mode
 ifeq ($(MODE), llvm)
 TARGET_ARCH ?= -msse3

build/definitions.mk

@@ -73,33 +73,25 @@ IMAGE_BASE_VIRTUAL ?= 0x400000
 IGNORE := $(shell $(ECHO) -2 ♥cosmo)
 IGNORE := $(shell $(MKDIR) o/tmp)
 
-ifneq ("$(wildcard o/third_party/gcc/bin/x86_64-pc-linux-gnu-as.exe)","")
-AS = o/third_party/gcc/bin/x86_64-pc-linux-gnu-as.exe
-CC = o/third_party/gcc/bin/x86_64-pc-linux-gnu-gcc.exe
-CXX = o/third_party/gcc/bin/x86_64-pc-linux-gnu-g++.exe
-CXXFILT = o/third_party/gcc/bin/x86_64-pc-linux-gnu-c++filt.exe
-LD = o/third_party/gcc/bin/x86_64-pc-linux-gnu-ld.bfd.exe
-NM = o/third_party/gcc/bin/x86_64-pc-linux-gnu-nm.exe
-GCC = o/third_party/gcc/bin/x86_64-pc-linux-gnu-gcc.exe
-STRIP = o/third_party/gcc/bin/x86_64-pc-linux-gnu-strip.exe
-OBJCOPY = o/third_party/gcc/bin/x86_64-pc-linux-gnu-objcopy.exe
-OBJDUMP = o/third_party/gcc/bin/x86_64-pc-linux-gnu-objdump.exe
-ADDR2LINE = $(PWD)/o/third_party/gcc/bin/x86_64-pc-linux-gnu-addr2line.exe
+ifneq ("$(wildcard o/third_party/gcc/bin/x86_64-pc-linux-gnu-*)","")
+PREFIX = o/third_party/gcc/bin/x86_64-pc-linux-gnu-
 else
 IGNORE := $(shell build/bootstrap/unbundle.com)
-AS = o/third_party/gcc/bin/x86_64-linux-musl-as
-CC = o/third_party/gcc/bin/x86_64-linux-musl-gcc
-CXX = o/third_party/gcc/bin/x86_64-linux-musl-g++
-CXXFILT = o/third_party/gcc/bin/x86_64-linux-musl-c++filt
-LD = o/third_party/gcc/bin/x86_64-linux-musl-ld.bfd
-NM = o/third_party/gcc/bin/x86_64-linux-musl-nm
-GCC = o/third_party/gcc/bin/x86_64-linux-musl-gcc
-STRIP = o/third_party/gcc/bin/x86_64-linux-musl-strip
-OBJCOPY = o/third_party/gcc/bin/x86_64-linux-musl-objcopy
-OBJDUMP = o/third_party/gcc/bin/x86_64-linux-musl-objdump
-ADDR2LINE = $(PWD)/o/third_party/gcc/bin/x86_64-linux-musl-addr2line
+PREFIX = o/third_party/gcc/bin/x86_64-linux-musl-
 endif
 
+AS = $(PREFIX)as
+CC = $(PREFIX)gcc
+CXX = $(PREFIX)g++
+CXXFILT = $(PREFIX)c++filt
+LD = $(PREFIX)ld.bfd
+NM = $(PREFIX)nm
+GCC = $(PREFIX)gcc
+STRIP = $(PREFIX)strip
+OBJCOPY = $(PREFIX)objcopy
+OBJDUMP = $(PREFIX)objdump
+ADDR2LINE = $(PWD)/$(PREFIX)addr2line
+
 export ADDR2LINE
 export LC_ALL
 export MKDIR
@@ -148,6 +140,7 @@ DEFAULT_CCFLAGS =							\
 
 DEFAULT_OFLAGS =							\
 	-g								\
+	-gdwarf-4							\
 	-gdescribe-dies
 
 DEFAULT_COPTS =								\

build/rules.mk

@@ -163,15 +163,15 @@ o/$(MODE)%/.zip.o: %
 # and it would be too costly in terms of make latency to have every
 # header file depend on $(HDRS) and $(INCS).
 
-o/%.h.ok: .UNSANDBOXED = 1
+o/%.h.ok: private .UNSANDBOXED = 1
 o/%.h.ok: %.h
 	@$(COMPILE) -ACHECK.h $(COMPILE.c) -xc -g0 -o $@ $<
 
-o/$(MODE)/%.h.ok: .UNSANDBOXED = 1
+o/$(MODE)/%.h.ok: private .UNSANDBOXED = 1
 o/$(MODE)/%.h.ok: %.h
 	@$(COMPILE) -ACHECK.h $(COMPILE.c) -xc -g0 -o $@ $<
 
-o/$(MODE)/%.hh.ok: .UNSANDBOXED = 1
+o/$(MODE)/%.hh.ok: private .UNSANDBOXED = 1
 o/$(MODE)/%.hh.ok: %.hh
 	@$(COMPILE) -ACHECK.h $(COMPILE.cxx) -xc++ -g0 -o $@ $<
 
@@ -179,7 +179,7 @@ o/%.okk: .UNSANDBOXED = 1
 o/%.okk: %
 	@$(COMPILE) -ACHECK.h $(COMPILE.cxx) -xc++ -g0 -o $@ $<
 
-o/$(MODE)/%.okk: .UNSANDBOXED = 1
+o/$(MODE)/%.okk: private .UNSANDBOXED = 1
 o/$(MODE)/%.okk: %
 	@$(COMPILE) -ACHECK.h $(COMPILE.cxx) -xc++ -g0 -o $@ $<
 
@@ -207,19 +207,19 @@ MAKE_SYMTAB_ZIP =				\
 ################################################################################
 # EMACS ASSEMBLY GENERATION
 
-o/$(MODE)/%-gcc.asm: .UNSANDBOXED = 1
+o/$(MODE)/%-gcc.asm: private .UNSANDBOXED = 1
 o/$(MODE)/%-gcc.asm: %.c
 	@$(COMPILE) -AOBJECTIFY.c $(OBJECTIFY.c) -S -g0 $(OUTPUT_OPTION) $<
 
-o/$(MODE)/%-gcc.asm: .UNSANDBOXED = 1
+o/$(MODE)/%-gcc.asm: private .UNSANDBOXED = 1
 o/$(MODE)/%-gcc.asm: %.cc
 	@$(COMPILE) -AOBJECTIFY.c $(OBJECTIFY.cxx) -S -g0 $(OUTPUT_OPTION) $<
 
-o/$(MODE)/%-clang.asm: .UNSANDBOXED = 1
+o/$(MODE)/%-clang.asm: private .UNSANDBOXED = 1
 o/$(MODE)/%-clang.asm: %.c
 	@$(COMPILE) -AOBJECTIFY.c $(OBJECTIFY.c) -S -g0 $(OUTPUT_OPTION) $<
 
 o/$(MODE)/%-clang.asm: CC = $(CLANG)
-o/$(MODE)/%-clang.asm: .UNSANDBOXED = 1
+o/$(MODE)/%-clang.asm: private .UNSANDBOXED = 1
 o/$(MODE)/%-clang.asm: %.cc
 	@$(COMPILE) -AOBJECTIFY.c $(OBJECTIFY.cxx) -S -g0 $(OUTPUT_OPTION) $<

dsp/tty/config.c

@@ -30,7 +30,7 @@
  * @see ttyconfig(), ttyrestore()
  */
 int ttyconfig(int ttyfd, ttyconf_f fn, int64_t arg,
-              const struct termios *opt_out_oldconf) {
+              struct termios *opt_out_oldconf) {
   struct termios conf[2];
   if (tcgetattr(ttyfd, &conf[0]) != -1 &&
       fn(memcpy(&conf[1], &conf[0], sizeof(conf[0])), arg) != -1 &&

dsp/tty/tty.h

@@ -44,7 +44,7 @@ int ttysendtitle(int, const char *, const struct TtyIdent *);
 int ttyident(struct TtyIdent *, int, int);
 void ttyidentclear(struct TtyIdent *);
 char *ttydescribe(char *, size_t, const struct TtyIdent *);
-int ttyconfig(int, ttyconf_f, int64_t, const struct termios *);
+int ttyconfig(int, ttyconf_f, int64_t, struct termios *);
 int ttyrestore(int, const struct termios *);
 int ttysetrawdeadline(struct termios *, int64_t);
 int ttysetrawmode(struct termios *, int64_t);

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

@@ -0,0 +1,56 @@
+#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/struct/timespec.h"
+#include "libc/errno.h"
+#include "libc/intrin/describeflags.internal.h"
+#include "libc/intrin/kprintf.h"
+#include "libc/str/str.h"
+#include "libc/sysv/consts/clock.h"
+
+int n;
+int shown[64];
+
+void show(int clock) {
+  int i;
+  struct timespec ts;
+  if (clock == 127) return;
+  for (i = 0; i < n; ++i) {
+    if (shown[i] == clock) {
+      return;
+    }
+  }
+  shown[n++] = clock;
+  if (clock_getres(clock, &ts) != -1) {
+    kprintf("%s %'ld ns\n", DescribeClockName(clock), timespec_tonanos(ts));
+  } else {
+    kprintf("%s %s\n", DescribeClockName(clock), _strerrno(errno));
+  }
+}
+
+int main(int argc, char *argv[]) {
+  show(CLOCK_REALTIME);
+  show(CLOCK_REALTIME_FAST);
+  show(CLOCK_REALTIME_PRECISE);
+  show(CLOCK_MONOTONIC);
+  show(CLOCK_MONOTONIC_RAW);
+  show(CLOCK_MONOTONIC_FAST);
+  show(CLOCK_MONOTONIC_PRECISE);
+  show(CLOCK_PROCESS_CPUTIME_ID);
+  show(CLOCK_THREAD_CPUTIME_ID);
+  show(CLOCK_PROF);
+  show(CLOCK_BOOTTIME);
+  show(CLOCK_REALTIME_ALARM);
+  show(CLOCK_BOOTTIME_ALARM);
+  show(CLOCK_TAI);
+  show(CLOCK_UPTIME);
+  show(CLOCK_UPTIME_PRECISE);
+  show(CLOCK_UPTIME_FAST);
+  show(CLOCK_SECOND);
+}

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

@@ -183,7 +183,7 @@ int main(int argc, char *argv[]) {
   struct Url url;
   char *host, *port;
   bool usessl = false;
-  _gc(ParseUrl(urlarg, -1, &url));
+  _gc(ParseUrl(urlarg, -1, &url, kUrlPlus));
   _gc(url.params.p);
   if (url.scheme.n) {
     if (url.scheme.n == 5 && !memcasecmp(url.scheme.p, "https", 5)) {

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,8 +71,10 @@ EXAMPLES_DIRECTDEPS =								\
 	LIBC_ZIPOS								\
 	NET_HTTP								\
 	NET_HTTPS								\
+	THIRD_PARTY_AWK								\
 	THIRD_PARTY_COMPILER_RT							\
 	THIRD_PARTY_DLMALLOC							\
+	THIRD_PARTY_DOUBLECONVERSION						\
 	THIRD_PARTY_GDTOA							\
 	THIRD_PARTY_GETOPT							\
 	THIRD_PARTY_LIBCXX							\
@@ -81,8 +83,11 @@ EXAMPLES_DIRECTDEPS =								\
 	THIRD_PARTY_MBEDTLS							\
 	THIRD_PARTY_MUSL							\
 	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								\
@@ -141,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/forkrand.c

@@ -9,19 +9,12 @@
 #endif
 #include "libc/calls/calls.h"
 #include "libc/log/check.h"
-#include "libc/log/log.h"
-#include "libc/nt/nt/process.h"
-#include "libc/mem/gc.h"
-#include "libc/runtime/memtrack.internal.h"
-#include "libc/runtime/runtime.h"
 #include "libc/stdio/rand.h"
 #include "libc/stdio/stdio.h"
-#include "libc/time/time.h"
-#include "libc/x/x.h"
 
 dontinline void dostuff(const char *s) {
   int i, us;
-  srand(rand64()); /* seeds rand() w/ intel rdrnd, auxv, etc. */
+  srand(_rand64()); /* seeds rand() w/ intel rdrnd, auxv, etc. */
   for (i = 0; i < 5; ++i) {
     us = rand() % 500000;
     usleep(us);

examples/getcpucount.c

@@ -8,8 +8,8 @@
 ╚─────────────────────────────────────────────────────────────────*/
 #endif
 #include "libc/intrin/kprintf.h"
-#include "libc/runtime/sysconf.h"
+#include "libc/runtime/runtime.h"
 
 int main() {
-  kprintf("%d\n", GetCpuCount());
+  kprintf("%d\n", _getcpucount());
 }

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"
@@ -102,7 +103,7 @@ uint64_t rngset64(void) {
   static unsigned i;
   static uint64_t s;
   if (!i) {
-    s = rand64();
+    s = _rand64();
     i = (s + 1) & (511);
   }
   return MarsagliaXorshift64(&s);
@@ -215,7 +216,7 @@ const struct Function {
     {"moby", moby},              //
     {"mt19937", _mt19937},       //
     {"python", pythonx2},        //
-    {"rand64", rand64},          //
+    {"rand64", _rand64},         //
     {"rdrand", rdrand},          //
     {"rdrnd", rdrand},           //
     {"rdseed", rdseed},          //

examples/greenbean.c

@@ -28,7 +28,6 @@
 #include "libc/runtime/internal.h"
 #include "libc/runtime/runtime.h"
 #include "libc/runtime/stack.h"
-#include "libc/runtime/sysconf.h"
 #include "libc/sock/sock.h"
 #include "libc/sock/struct/pollfd.h"
 #include "libc/sock/struct/sockaddr.h"
@@ -137,7 +136,7 @@ void *Worker(void *id) {
   setsockopt(server, SOL_TCP, TCP_QUICKACK, &yes, sizeof(yes));
   errno = 0;
 
-  if (bind(server, &addr, sizeof(addr)) == -1) {
+  if (bind(server, (struct sockaddr *)&addr, sizeof(addr)) == -1) {
     kprintf("%s() failed %m\n", "socket");
     goto CloseWorker;
   }
@@ -299,7 +298,7 @@ int main(int argc, char *argv[]) {
             PORT);
   }
 
-  threads = argc > 1 ? atoi(argv[1]) : GetCpuCount();
+  threads = argc > 1 ? atoi(argv[1]) : _getcpucount();
   if (!(1 <= threads && threads <= 100000)) {
     kprintf("error: invalid number of threads: %d\n", threads);
     exit(1);

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

@@ -0,0 +1,521 @@
+/*-*- mode:c;indent-tabs-mode:t;c-basic-offset:8;tab-width:8;coding:utf-8   -*-│
+│vi: set et ft=c ts=8 tw=8 fenc=utf-8                                       :vi│
+╞══════════════════════════════════════════════════════════════════════════════╡
+│ Copyright (c) 2010, 2012 David E. O'Brien                                    │
+│ Copyright (c) 1980, 1992, 1993                                               │
+│      The Regents of the University of California.  All rights reserved.      │
+│                                                                              │
+│ Redistribution and use in source and binary forms, with or without           │
+│ modification, are permitted provided that the following conditions           │
+│ are met:                                                                     │
+│  1. Redistributions of source code must retain the above copyright           │
+│     notice, this list of conditions and the following disclaimer.            │
+│  2. Redistributions in binary form must reproduce the above copyright        │
+│     notice, this list of conditions and the following disclaimer in the      │
+│     documentation and/or other materials provided with the distribution.     │
+│  3. Neither the name of the University nor the names of its contributors     │
+│     may be used to endorse or promote products derived from this software    │
+│     without specific prior written permission.                               │
+│                                                                              │
+│ THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND      │
+│ ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE        │
+│ IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE   │
+│ ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE     │
+│ FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL   │
+│ DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS      │
+│ OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)        │
+│ HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT   │
+│ LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY    │
+│ OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF       │
+│ SUCH DAMAGE.                                                                 │
+╚─────────────────────────────────────────────────────────────────────────────*/
+#include "libc/calls/calls.h"
+#include "libc/calls/struct/iovec.h"
+#include "libc/calls/struct/stat.h"
+#include "libc/calls/struct/termios.h"
+#include "libc/calls/struct/timeval.h"
+#include "libc/calls/struct/winsize.h"
+#include "libc/calls/termios.h"
+#include "libc/calls/weirdtypes.h"
+#include "libc/errno.h"
+#include "libc/fmt/conv.h"
+#include "libc/intrin/bswap.h"
+#include "libc/log/bsd.h"
+#include "libc/macros.internal.h"
+#include "libc/mem/mem.h"
+#include "libc/paths.h"
+#include "libc/runtime/runtime.h"
+#include "libc/sock/select.h"
+#include "libc/stdio/stdio.h"
+#include "libc/sysv/consts/fileno.h"
+#include "libc/sysv/consts/s.h"
+#include "libc/sysv/consts/termios.h"
+#include "libc/time/time.h"
+#include "third_party/getopt/getopt.h"
+// clang-format off
+
+/**
+ * @fileoverview Terminal Screencast Recorder / Player, e.g.
+ *
+ *     make o//examples/script.com
+ *     o//examples/script.com -r
+ *     # type stuff..
+ *     # CTRL-D
+ *     o//examples/script.com -p typescript
+ *
+ * @note works on Linux, OpenBSD, NetBSD, FreeBSD, MacOS
+ * @see https://asciinema.org/
+ */
+
+asm(".ident\t\"\\n\\n\
+FreeBSD Script (BSD-3 License)\\n\
+Copyright (c) 2010, 2012 David E. O'Brien\\n\
+Copyright (c) 1980, 1992, 1993\\n\
+\tThe Regents of the University of California.\\n\
+\tAll rights reserved.\"");
+asm(".include \"libc/disclaimer.inc\"");
+
+#define DEF_BUF 65536
+
+struct stamp {
+	uint64_t scr_len;	/* amount of data */
+	uint64_t scr_sec;	/* time it arrived in seconds... */
+	uint32_t scr_usec;	/* ...and microseconds */
+	uint32_t scr_direction; /* 'i', 'o', etc (also indicates endianness) */
+};
+
+static FILE *fscript;
+static int master, slave;
+static int child;
+static const char *fname;
+static char *fmfname;
+static int qflg, ttyflg;
+static int usesleep, rawout, showexit;
+
+static struct termios tt;
+
+static void done(int) wontreturn;
+static void doshell(char **);
+static void finish(void);
+static void record(FILE *, char *, size_t, int);
+static void consume(FILE *, off_t, char *, int);
+static void playback(FILE *) wontreturn;
+static void usage(void);
+
+int
+main(int argc, char *argv[])
+{
+	int cc;
+	struct termios rtt, stt;
+	struct winsize win;
+	struct timeval tv, *tvp;
+	time_t tvec, start;
+	static char obuf[BUFSIZ];
+	static char ibuf[BUFSIZ];
+	fd_set rfd;
+	int aflg, Fflg, kflg, pflg, ch, k, n;
+	int flushtime, readstdin;
+	int fm_fd, fm_log;
+
+	aflg = Fflg = kflg = pflg = 0;
+	usesleep = 1;
+	rawout = 0;
+	flushtime = 30;
+	fm_fd = -1;	/* Shut up stupid "may be used uninitialized" GCC
+			   warning. (not needed w/clang) */
+	showexit = 0;
+
+	while ((ch = getopt(argc, argv, "adeFfkpqrt:")) != -1)
+		switch(ch) {
+		case 'a':
+			aflg = 1;
+			break;
+		case 'd':
+			usesleep = 0;
+			break;
+		case 'e':	/* Default behavior, accepted for linux compat */
+			break;
+		case 'F':
+			Fflg = 1;
+			break;
+		case 'k':
+			kflg = 1;
+			break;
+		case 'p':
+			pflg = 1;
+			break;
+		case 'q':
+			qflg = 1;
+			break;
+		case 'r':
+			rawout = 1;
+			break;
+		case 't':
+			flushtime = atoi(optarg);
+			if (flushtime < 0)
+				err(1, "invalid flush time %d", flushtime);
+			break;
+		case '?':
+		default:
+			usage();
+		}
+	argc -= optind;
+	argv += optind;
+
+	if (argc > 0) {
+		fname = argv[0];
+		argv++;
+		argc--;
+	} else
+		fname = "typescript";
+
+	if ((fscript = fopen(fname, pflg ? "r" : aflg ? "a" : "w")) == NULL)
+		err(1, "%s", fname);
+
+	if (pflg)
+		playback(fscript);
+
+	if (tcgetattr(STDIN_FILENO, &tt) == -1 ||
+	    ioctl(STDIN_FILENO, TIOCGWINSZ, &win) == -1) {
+		if (errno != ENOTTY) /* For debugger. */
+			err(1, "tcgetattr/ioctl");
+		if (openpty(&master, &slave, NULL, NULL, NULL) == -1)
+			err(1, "openpty");
+	} else {
+		if (openpty(&master, &slave, NULL, &tt, &win) == -1)
+			err(1, "openpty");
+		ttyflg = 1;
+	}
+
+	if (rawout)
+		record(fscript, NULL, 0, 's');
+
+	if (!qflg) {
+		tvec = time(NULL);
+		printf("Script started, output file is %s\n", fname);
+		if (!rawout) {
+			fprintf(fscript, "Script started on %s",
+			    ctime(&tvec));
+			if (argv[0]) {
+				showexit = 1;
+				fprintf(fscript, "Command: ");
+				for (k = 0 ; argv[k] ; ++k)
+					fprintf(fscript, "%s%s", k ? " " : "",
+						argv[k]);
+				fprintf(fscript, "\n");
+			}
+		}
+		fflush(fscript);
+	}
+	if (ttyflg) {
+		rtt = tt;
+		cfmakeraw(&rtt);
+		rtt.c_lflag &= ~ECHO;
+		tcsetattr(STDIN_FILENO, TCSAFLUSH, &rtt);
+	}
+
+	child = fork();
+	if (child < 0) {
+		warn("fork");
+		done(1);
+	}
+	if (child == 0) {
+		doshell(argv);
+	}
+	close(slave);
+
+	start = tvec = time(0);
+	readstdin = 1;
+	for (;;) {
+		FD_ZERO(&rfd);
+		FD_SET(master, &rfd);
+		if (readstdin)
+			FD_SET(STDIN_FILENO, &rfd);
+		if (!readstdin && ttyflg) {
+			tv.tv_sec = 1;
+			tv.tv_usec = 0;
+			tvp = &tv;
+			readstdin = 1;
+		} else if (flushtime > 0) {
+			tv.tv_sec = flushtime - (tvec - start);
+			tv.tv_usec = 0;
+			tvp = &tv;
+		} else {
+			tvp = NULL;
+		}
+		n = select(master + 1, &rfd, 0, 0, tvp);
+		if (n < 0 && errno != EINTR)
+			break;
+		if (n > 0 && FD_ISSET(STDIN_FILENO, &rfd)) {
+			cc = read(STDIN_FILENO, ibuf, BUFSIZ);
+			if (cc < 0)
+				break;
+			if (cc == 0) {
+				if (tcgetattr(master, &stt) == 0 &&
+				    (stt.c_lflag & ICANON) != 0) {
+					write(master, &stt.c_cc[VEOF], 1);
+				}
+				readstdin = 0;
+			}
+			if (cc > 0) {
+				if (rawout)
+					record(fscript, ibuf, cc, 'i');
+				write(master, ibuf, cc);
+				if (kflg && tcgetattr(master, &stt) >= 0 &&
+				    ((stt.c_lflag & ECHO) == 0)) {
+					fwrite(ibuf, 1, cc, fscript);
+				}
+			}
+		}
+		if (n > 0 && FD_ISSET(master, &rfd)) {
+			cc = read(master, obuf, sizeof (obuf));
+			if (cc <= 0)
+				break;
+			write(STDOUT_FILENO, obuf, cc);
+			if (rawout)
+				record(fscript, obuf, cc, 'o');
+			else
+				fwrite(obuf, 1, cc, fscript);
+		}
+		tvec = time(0);
+		if (tvec - start >= flushtime) {
+			fflush(fscript);
+			start = tvec;
+		}
+		if (Fflg)
+			fflush(fscript);
+	}
+	finish();
+	done(0);
+}
+
+static void
+usage(void)
+{
+	fprintf(stderr,
+		"usage: script [-adfkpqr] [-t time] [file [command ...]]\n");
+	exit(1);
+}
+
+static void
+finish(void)
+{
+	int e, status;
+
+	if (waitpid(child, &status, 0) == child) {
+		if (WIFEXITED(status))
+			e = WEXITSTATUS(status);
+		else if (WIFSIGNALED(status))
+			e = WTERMSIG(status);
+		else /* can't happen */
+			e = 1;
+		done(e);
+	}
+}
+
+static void
+doshell(char **av)
+{
+	const char *shell;
+
+	shell = getenv("SHELL");
+	if (shell == NULL)
+		shell = _PATH_BSHELL;
+
+	close(master);
+	fclose(fscript);
+	free(fmfname);
+	login_tty(slave);
+	setenv("SCRIPT", fname, 1);
+	if (av[0]) {
+		execvp(av[0], av);
+		warn("%s", av[0]);
+	} else {
+		execl(shell, shell, "-i", 0);
+		warn("%s", shell);
+	}
+	exit(1);
+}
+
+static void
+done(int eno)
+{
+	time_t tvec;
+
+	if (ttyflg)
+		tcsetattr(STDIN_FILENO, TCSAFLUSH, &tt);
+	tvec = time(NULL);
+	if (rawout)
+		record(fscript, NULL, 0, 'e');
+	if (!qflg) {
+		if (!rawout) {
+			if (showexit)
+				fprintf(fscript, "\nCommand exit status:"
+				    " %d", eno);
+			fprintf(fscript,"\nScript done on %s",
+			    ctime(&tvec));
+		}
+		printf("\nScript done, output file is %s\n", fname);
+	}
+	fclose(fscript);
+	close(master);
+	exit(eno);
+}
+
+static void
+record(FILE *fp, char *buf, size_t cc, int direction)
+{
+	struct iovec iov[2];
+	struct stamp stamp;
+	struct timeval tv;
+
+	gettimeofday(&tv, NULL);
+	stamp.scr_len = cc;
+	stamp.scr_sec = tv.tv_sec;
+	stamp.scr_usec = tv.tv_usec;
+	stamp.scr_direction = direction;
+	iov[0].iov_len = sizeof(stamp);
+	iov[0].iov_base = &stamp;
+	iov[1].iov_len = cc;
+	iov[1].iov_base = buf;
+	if (writev(fileno(fp), &iov[0], 2) == -1)
+		err(1, "writev");
+}
+
+static void
+consume(FILE *fp, off_t len, char *buf, int reg)
+{
+	size_t l;
+
+	if (reg) {
+		if (fseeko(fp, len, SEEK_CUR) == -1)
+			err(1, NULL);
+	}
+	else {
+		while (len > 0) {
+			l = MIN(DEF_BUF, len);
+			if (fread(buf, sizeof(char), l, fp) != l)
+				err(1, "cannot read buffer");
+			len -= l;
+		}
+	}
+}
+
+#define swapstamp(stamp) do { \
+	if (stamp.scr_direction > 0xff) { \
+		stamp.scr_len = bswap_64(stamp.scr_len); \
+		stamp.scr_sec = bswap_64(stamp.scr_sec); \
+		stamp.scr_usec = bswap_32(stamp.scr_usec); \
+		stamp.scr_direction = bswap_32(stamp.scr_direction); \
+	} \
+} while (0/*CONSTCOND*/)
+
+static void
+termset(void)
+{
+	struct termios traw;
+
+	if (tcgetattr(STDOUT_FILENO, &tt) == -1) {
+		if (errno != ENOTTY) /* For debugger. */
+			err(1, "tcgetattr");
+		return;
+	}
+	ttyflg = 1;
+	traw = tt;
+	cfmakeraw(&traw);
+	traw.c_lflag |= ISIG;
+	tcsetattr(STDOUT_FILENO, TCSANOW, &traw);
+}
+
+static void
+termreset(void)
+{
+	if (ttyflg) {
+		tcsetattr(STDOUT_FILENO, TCSADRAIN, &tt);
+		ttyflg = 0;
+	}
+}
+
+static void
+playback(FILE *fp)
+{
+	struct timespec tsi, tso;
+	struct stamp stamp;
+	struct stat pst;
+	static char buf[DEF_BUF];
+	off_t nread, save_len;
+	size_t l;
+	time_t tclock;
+	int reg;
+
+	if (fstat(fileno(fp), &pst) == -1)
+		err(1, "fstat failed");
+
+	reg = S_ISREG(pst.st_mode);
+
+	for (nread = 0; !reg || nread < pst.st_size; nread += save_len) {
+		if (fread(&stamp, sizeof(stamp), 1, fp) != 1) {
+			if (reg)
+				err(1, "reading playback header");
+			else
+				break;
+		}
+		swapstamp(stamp);
+		save_len = sizeof(stamp);
+
+		if (reg && stamp.scr_len >
+		    (uint64_t)(pst.st_size - save_len) - nread)
+			errx(1, "invalid stamp");
+
+		save_len += stamp.scr_len;
+		tclock = stamp.scr_sec;
+		tso.tv_sec = stamp.scr_sec;
+		tso.tv_nsec = stamp.scr_usec * 1000;
+
+		switch (stamp.scr_direction) {
+		case 's':
+			if (!qflg)
+			    printf("Script started on %s",
+				ctime(&tclock));
+			tsi = tso;
+			consume(fp, stamp.scr_len, buf, reg);
+			termset();
+			atexit(termreset);
+			break;
+		case 'e':
+			termreset();
+			if (!qflg)
+				printf("\nScript done on %s",
+				    ctime(&tclock));
+			consume(fp, stamp.scr_len, buf, reg);
+			break;
+		case 'i':
+			/* throw input away */
+			consume(fp, stamp.scr_len, buf, reg);
+			break;
+		case 'o':
+			tsi.tv_sec = tso.tv_sec - tsi.tv_sec;
+			tsi.tv_nsec = tso.tv_nsec - tsi.tv_nsec;
+			if (tsi.tv_nsec < 0) {
+				tsi.tv_sec -= 1;
+				tsi.tv_nsec += 1000000000;
+			}
+			if (usesleep)
+				nanosleep(&tsi, NULL);
+			tsi = tso;
+			while (stamp.scr_len > 0) {
+				l = MIN(DEF_BUF, stamp.scr_len);
+				if (fread(buf, sizeof(char), l, fp) != l)
+					err(1, "cannot read buffer");
+
+				write(STDOUT_FILENO, buf, l);
+				stamp.scr_len -= l;
+			}
+			break;
+		default:
+			errx(1, "invalid direction");
+		}
+	}
+	fclose(fp);
+	exit(0);
+}

examples/script.txt

@@ -0,0 +1,100 @@
+SCRIPT(1)            Cosmopolitan General Commands Manual              SCRIPT(1)
+
+𝐍𝐀𝐌𝐄
+     𝘀𝗰𝗿𝗶𝗽𝘁 — make typescript of terminal session
+
+𝐒𝐘𝐍𝐎𝐏𝐒𝐈𝐒
+     𝘀𝗰𝗿𝗶𝗽𝘁 [-𝗮𝗱𝗲𝗳𝗸𝗽𝗾𝗿] [-𝐅 p̲i̲p̲e̲] [-𝘁 t̲i̲m̲e̲] [f̲i̲l̲e̲ [c̲o̲m̲m̲a̲n̲d̲ .̲.̲.̲]]
+
+𝐃𝐄𝐒𝐂𝐑𝐈𝐏𝐓𝐈𝐎𝐍
+     The 𝘀𝗰𝗿𝗶𝗽𝘁 utility makes a typescript of everything printed on your termi‐
+     nal.  It is useful for students who need a hardcopy record of an interac‐
+     tive session as proof of an assignment, as the typescript file can be
+     printed out later with lpr(1).
+
+     If the argument f̲i̲l̲e̲ is given, 𝘀𝗰𝗿𝗶𝗽𝘁 saves all dialogue in f̲i̲l̲e̲.  If no
+     file name is given, the typescript is saved in the file t̲y̲p̲e̲s̲c̲r̲i̲p̲t̲.
+
+     If the argument c̲o̲m̲m̲a̲n̲d̲ is given, 𝘀𝗰𝗿𝗶𝗽𝘁 will run the specified command
+     with an optional argument vector instead of an interactive shell.
+
+     The following options are available:
+
+     -𝗮      Append the output to f̲i̲l̲e̲ or t̲y̲p̲e̲s̲c̲r̲i̲p̲t̲, retaining the prior con‐
+             tents.
+
+     -𝗱      When playing back a session with the -𝗽 flag, do not sleep between
+             records when playing back a timestamped session.
+
+     -𝗲      Accepted for compatibility with u̲t̲i̲l̲-̲l̲i̲n̲u̲x̲ 𝘀𝗰𝗿𝗶𝗽𝘁.  The child com‐
+             mand exit status is always the exit status of 𝘀𝗰𝗿𝗶𝗽𝘁.
+
+     -𝐅 p̲i̲p̲e̲
+             Immediately flush output after each write.  This will allow a user
+             to create a named pipe using mkfifo(1) and another user may watch
+             the live session using a utility like cat(1).
+
+     -𝗸      Log keys sent to the program as well as output.
+
+     -𝗽      Play back a session recorded with the -𝗿 flag in real time.
+
+     -𝗾      Run in quiet mode, omit the start, stop and command status mes‐
+             sages.
+
+     -𝗿      Record a session with input, output, and timestamping.
+
+     -𝘁 t̲i̲m̲e̲
+             Specify the interval at which the script output file will be
+             flushed to disk, in seconds.  A value of 0 causes 𝘀𝗰𝗿𝗶𝗽𝘁 to flush
+             after every character I/O event.  The default interval is 30 sec‐
+             onds.
+
+     The script ends when the forked shell (or command) exits (a c̲o̲n̲t̲r̲o̲l̲-̲D̲ to
+     exit the Bourne shell (sh(1)), and e̲x̲i̲t̲, l̲o̲g̲o̲u̲t̲ or c̲o̲n̲t̲r̲o̲l̲-̲D̲ (if i̲g̲n̲o̲r̲e̲e̲o̲f̲
+     is not set) for the C-shell, csh(1)).
+
+     Certain interactive commands, such as vi(1), create garbage in the type‐
+     script file.  The 𝘀𝗰𝗿𝗶𝗽𝘁 utility works best with commands that do not ma‐
+     nipulate the screen.  The results are meant to emulate a hardcopy terminal,
+     not an addressable one.
+
+𝐄𝐍𝐕𝐈𝐑𝐎𝐍𝐌𝐄𝐍𝐓
+     The following environment variables are utilized by 𝘀𝗰𝗿𝗶𝗽𝘁:
+
+     SCRIPT
+            The SCRIPT environment variable is added to the sub-shell.  If
+            SCRIPT already existed in the users environment, its value is over‐
+            written within the sub-shell.  The value of SCRIPT is the name of
+            the t̲y̲p̲e̲s̲c̲r̲i̲p̲t̲ file.
+
+     SHELL  If the variable SHELL exists, the shell forked by 𝘀𝗰𝗿𝗶𝗽𝘁 will be
+            that shell.  If SHELL is not set, the Bourne shell is assumed.
+            (Most shells set this variable automatically).
+
+𝐒𝐄𝐄 𝐀𝐋𝐒𝐎
+     csh(1) (for the h̲i̲s̲t̲o̲r̲y̲ mechanism)
+
+𝐇𝐈𝐒𝐓𝐎𝐑𝐘
+     The 𝘀𝗰𝗿𝗶𝗽𝘁 command appeared in 3.0BSD.
+
+     The -𝗱, -𝗽 and -𝗿 options first appeared in NetBSD 2.0 and were ported to
+     FreeBSD 9.2.
+
+𝐁𝐔𝐆𝐒
+     The 𝘀𝗰𝗿𝗶𝗽𝘁 utility places 𝗲𝘃𝗲𝗿𝘆𝘁𝗵𝗶𝗻𝗴 in the log file, including linefeeds
+     and backspaces.  This is not what the naive user expects.
+
+     It is not possible to specify a command without also naming the script file
+     because of argument parsing compatibility issues.
+
+     When running in -𝗸 mode, echo cancelling is far from ideal.  The slave ter‐
+     minal mode is checked for ECHO mode to check when to avoid manual echo log‐
+     ging.  This does not work when the terminal is in a raw mode where the pro‐
+     gram being run is doing manual echo.
+
+     If 𝘀𝗰𝗿𝗶𝗽𝘁 reads zero bytes from the terminal, it switches to a mode when it
+     only attempts to read once a second until there is data to read.  This pre‐
+     vents 𝘀𝗰𝗿𝗶𝗽𝘁 from spinning on zero-byte reads, but might cause a 1-second
+     delay in processing of user input.
+
+BSD                             September 1, 2020                            BSD

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'");
 }

examples/vga.c

@@ -49,12 +49,12 @@ int main(int argc, char *argv[]) {
     printf("res = %d?\n", res);
     return -1;
   }
-  printf("Hello World! %.19Lg\n", atan2l(x, y));
+  printf("\e[92;44mHello World!\e[0m %.19Lg\n", atan2l(x, y));
 
   // read/print loop so machine doesn't reset on metal
   for (;;) {
     if ((res = readansi(0, buf, 16)) > 0) {
-      printf("got %`'.*s\r\n", res, buf);
+      printf("got \e[97m%`'.*s\e[0m\r\n", res, buf);
     }
   }
 }

examples/vga2.c

@@ -0,0 +1,33 @@
+#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/calls/termios.h"
+#include "libc/isystem/unistd.h"
+#include "libc/math.h"
+#include "libc/stdio/stdio.h"
+#include "libc/str/str.h"
+#include "libc/sysv/consts/termios.h"
+
+/**
+ * @fileoverview Demo of program crash reporting with Bare Metal VGA TTY.
+ *
+ *     make -j8 o//examples/vga2.com
+ *     qemu-system-x86_64 -hda o//examples/vga2.com -serial stdio
+ */
+
+STATIC_YOINK("vga_console");
+STATIC_YOINK("_idt");
+
+int main(int argc, char *argv[]) {
+  volatile int x = 1;
+  volatile int y = 2;
+  printf("\e[92;44mHello World!\e[0m %d\n", 1 / (x + y - 3));
+  for (;;);
+}

examples/wall.c

@@ -0,0 +1,148 @@
+#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/calls/struct/timespec.h"
+#include "libc/calls/termios.h"
+#include "libc/errno.h"
+#include "libc/fmt/fmt.h"
+#include "libc/runtime/runtime.h"
+#include "libc/stdio/append.h"
+#include "libc/stdio/stdio.h"
+#include "libc/str/str.h"
+#include "libc/sysv/consts/o.h"
+#include "libc/time/struct/tm.h"
+#include "third_party/getopt/getopt.h"
+#include "third_party/musl/passwd.h"
+
+/**
+ * @fileoverview program for broadcasting message to all terminals, e.g.
+ *
+ *     o//examples/wall.com hello friends
+ *
+ * Will place some bold text into the top left corners of all terminals:
+ *
+ *     Broadcast message from jart@host (pts/4) (Tue Oct 11 03:52:24 2022):
+ *     hello friends
+ *
+ * It's useful for having one terminal tab notify your other ones when
+ * something like a long running job completes. In the old days back
+ * when unix systems had multiple users, the wall command provided the
+ * ultimate lulz especially if it's a setuid binary with root privs.
+ */
+
+#define GETOPTS "v"
+#define USAGE \
+  "\
+Usage: wall.com [-v] [TEXTMSG] [<TEXTMSG]\n\
+  -v          increase verbosity\n\
+Examples:\n\
+  wall.com 'hello my friends'\n\
+  echo hello my friends | wall.com\n\
+"
+
+int g_verbose;
+
+static void GetOpts(int argc, char *argv[]) {
+  int opt;
+  while ((opt = getopt(argc, argv, GETOPTS)) != -1) {
+    switch (opt) {
+      case 'v':
+        g_verbose++;
+        break;
+      case '?':
+        write(1, USAGE, sizeof(USAGE) - 1);
+        exit(0);
+      default:
+        write(2, USAGE, sizeof(USAGE) - 1);
+        exit(64);
+    }
+  }
+}
+
+char *GetHost(void) {
+  static char host[254];
+  if (gethostname(host, sizeof(host))) {
+    strcpy(host, "localhost");
+  }
+  return host;
+}
+
+char *GetTime(void) {
+  int64_t t;
+  struct tm tm;
+  struct timespec ts;
+  clock_gettime(0, &ts);
+  localtime_r(&ts.tv_sec, &tm);
+  return _chomp(asctime(&tm));
+}
+
+int main(int argc, char *argv[]) {
+  GetOpts(argc, argv);
+
+  // create broadcast banner
+  // we use \e[1m so the text is strong & visually distinct
+  // we use \e[K so it doesn't get lost in a forest of text
+  // we map \n → \r\n because teletype might be in raw mode
+  char *msg = 0;
+  const char *s;
+  appends(&msg, "\e7");    // save cursor position
+  appends(&msg, "\e[H");   // goto top left corne
+  appends(&msg, "\e[K");   // clear line forward
+  appends(&msg, "\e[1m");  // bold text
+  appendf(&msg, "Broadcast message from %s@%s", getpwuid(getuid())->pw_name,
+          GetHost());
+  if (isatty(0) && (s = ttyname(0))) appendf(&msg, " (%s)", s);
+  appendf(&msg, " (%s):\r\n", GetTime());
+  appends(&msg, "\e[K");
+
+  // append broadcast message
+  if (optind < argc) {
+    // use cli arguments as message if they exist
+    for (int i = 0; optind + i < argc; ++i) {
+      if (i) appends(&msg, " ");
+      for (s = argv[optind + i]; *s; ++s) {
+        if (*s == '\n') {
+          appends(&msg, "\r\n\e[K");
+        } else {
+          appendw(&msg, *s & 255);
+        }
+      }
+    }
+  } else {
+    // otherwise use stdin as message
+    ssize_t i, rc;
+    char buf[512];
+    while ((rc = read(0, buf, sizeof(buf))) > 0) {
+      for (i = 0; i < rc; ++i) {
+        if (buf[i] == '\n') {
+          appends(&msg, "\r\n\e[K");  // clear line forward
+        } else {
+          appendw(&msg, buf[i] & 255);
+        }
+      }
+    }
+  }
+  appends(&msg, "\r\n\e[K\e[0m\e8");  // restore
+
+  // try to send message to all pseudoteletypewriters
+  for (int i = 0;; ++i) {
+    int fd;
+    char pts[32];
+    snprintf(pts, sizeof(pts), "/dev/pts/%d", i);
+    if ((fd = open(pts, O_WRONLY | O_NOCTTY)) == -1) {
+      if (errno == ENOENT) break;
+      if (g_verbose) perror(pts);
+    }
+    write(fd, msg, appendz(msg).i);
+    close(fd);
+  }
+
+  return 0;
+}

examples/whois.c

@@ -0,0 +1,617 @@
+/*-*- mode:c;indent-tabs-mode:t;c-basic-offset:8;tab-width:8;coding:utf-8   -*-│
+│vi: set et ft=c ts=8 tw=8 fenc=utf-8                                       :vi│
+╞══════════════════════════════════════════════════════════════════════════════╡
+│ Copyright (c) 1980, 1993                                                     │
+│      The Regents of the University of California.  All rights reserved.      │
+│                                                                              │
+│ Redistribution and use in source and binary forms, with or without           │
+│ modification, are permitted provided that the following conditions           │
+│ are met:                                                                     │
+│  1. Redistributions of source code must retain the above copyright           │
+│     notice, this list of conditions and the following disclaimer.            │
+│  2. Redistributions in binary form must reproduce the above copyright        │
+│     notice, this list of conditions and the following disclaimer in the      │
+│     documentation and/or other materials provided with the distribution.     │
+│  3. Neither the name of the University nor the names of its contributors     │
+│     may be used to endorse or promote products derived from this software    │
+│     without specific prior written permission.                               │
+│                                                                              │
+│ THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND      │
+│ ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE        │
+│ IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE   │
+│ ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE     │
+│ FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL   │
+│ DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS      │
+│ OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)        │
+│ HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT   │
+│ LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY    │
+│ OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF       │
+│ SUCH DAMAGE.                                                                 │
+╚─────────────────────────────────────────────────────────────────────────────*/
+#include "libc/calls/calls.h"
+#include "libc/dns/dns.h"
+#include "libc/errno.h"
+#include "libc/log/bsd.h"
+#include "libc/mem/fmt.h"
+#include "libc/mem/mem.h"
+#include "libc/runtime/runtime.h"
+#include "libc/sock/struct/pollfd.h"
+#include "libc/str/str.h"
+#include "libc/sysv/consts/af.h"
+#include "libc/sysv/consts/ex.h"
+#include "libc/sysv/consts/f.h"
+#include "libc/sysv/consts/o.h"
+#include "libc/sysv/consts/poll.h"
+#include "libc/sysv/consts/sock.h"
+#include "third_party/getopt/getopt.h"
+// clang-format off
+
+asm(".ident\t\"\\n\\n\
+FreeBSD Whois (BSD-3 License)\\n\
+Copyright (c) 1980, 1993\\n\
+\tThe Regents of the University of California.\\n\
+\tAll rights reserved.\"");
+asm(".include \"libc/disclaimer.inc\"");
+
+#define	ABUSEHOST	"whois.abuse.net"
+#define	ANICHOST	"whois.arin.net"
+#define	DENICHOST	"whois.denic.de"
+#define	DKNICHOST	"whois.dk-hostmaster.dk"
+#define	FNICHOST	"whois.afrinic.net"
+#define	GNICHOST	"whois.nic.gov"
+#define	IANAHOST	"whois.iana.org"
+#define	INICHOST	"whois.internic.net"
+#define	KNICHOST	"whois.krnic.net"
+#define	LNICHOST	"whois.lacnic.net"
+#define	MNICHOST	"whois.ra.net"
+#define	PDBHOST		"whois.peeringdb.com"
+#define	PNICHOST	"whois.apnic.net"
+#define	QNICHOST_TAIL	".whois-servers.net"
+#define	RNICHOST	"whois.ripe.net"
+#define	VNICHOST	"whois.verisign-grs.com"
+
+#define	DEFAULT_PORT	"whois"
+
+#define WHOIS_RECURSE	0x01
+#define WHOIS_QUICK	0x02
+#define WHOIS_SPAM_ME	0x04
+
+#define CHOPSPAM	">>> Last update of WHOIS database:"
+
+#define ishost(h) (isalnum((unsigned char)h) || h == '.' || h == '-')
+
+#define SCAN(p, end, check)					\
+	while ((p) < (end))					\
+		if (check) ++(p);				\
+		else break
+
+static struct {
+	const char *suffix, *server;
+} whoiswhere[] = {
+	/* Various handles */
+	{ "-ARIN", ANICHOST },
+	{ "-NICAT", "at" QNICHOST_TAIL },
+	{ "-NORID", "no" QNICHOST_TAIL },
+	{ "-RIPE", RNICHOST },
+	/* Nominet's whois server doesn't return referrals to JANET */
+	{ ".ac.uk", "ac.uk" QNICHOST_TAIL },
+	{ ".gov.uk", "ac.uk" QNICHOST_TAIL },
+	{ "", IANAHOST }, /* default */
+	{ NULL, NULL } /* safety belt */
+};
+
+#define WHOIS_REFERRAL(s) { s, sizeof(s) - 1 }
+static struct {
+	const char *prefix;
+	size_t len;
+} whois_referral[] = {
+	WHOIS_REFERRAL("whois:"), /* IANA */
+	WHOIS_REFERRAL("Whois Server:"),
+	WHOIS_REFERRAL("Registrar WHOIS Server:"), /* corporatedomains.com */
+	WHOIS_REFERRAL("ReferralServer:  whois://"), /* ARIN */
+	WHOIS_REFERRAL("ReferralServer:  rwhois://"), /* ARIN */
+	WHOIS_REFERRAL("descr:          region. Please query"), /* AfriNIC */
+	{ NULL, 0 }
+};
+
+/*
+ * We have a list of patterns for RIRs that assert ignorance rather than
+ * providing referrals. If that happens, we guess that ARIN will be more
+ * helpful. But, before following a referral to an RIR, we check if we have
+ * asked that RIR already, and if so we make another guess.
+ */
+static const char *actually_arin[] = {
+	"netname:        ERX-NETBLOCK\n", /* APNIC */
+	"netname:        NON-RIPE-NCC-MANAGED-ADDRESS-BLOCK\n",
+	NULL
+};
+
+static struct {
+	int loop;
+	const char *host;
+} try_rir[] = {
+	{ 0, ANICHOST },
+	{ 0, RNICHOST },
+	{ 0, PNICHOST },
+	{ 0, FNICHOST },
+	{ 0, LNICHOST },
+	{ 0, NULL }
+};
+
+static void
+reset_rir(void) {
+	int i;
+
+	for (i = 0; try_rir[i].host != NULL; i++)
+		try_rir[i].loop = 0;
+}
+
+static const char *port = DEFAULT_PORT;
+
+static const char *choose_server(char *);
+static struct addrinfo *gethostinfo(const char *, const char *, int);
+static void s_asprintf(char **ret, const char *format, ...);
+static void usage(void);
+static void whois(const char *, const char *, const char *, int);
+
+int
+main(int argc, char *argv[])
+{
+	const char *country, *host;
+	int ch, flags;
+
+#ifdef	SOCKS
+	SOCKSinit(argv[0]);
+#endif
+
+	country = host = NULL;
+	flags = 0;
+	while ((ch = getopt(argc, argv, "aAbc:fgh:iIklmp:PQrRS")) != -1) {
+		switch (ch) {
+		case 'a':
+			host = ANICHOST;
+			break;
+		case 'A':
+			host = PNICHOST;
+			break;
+		case 'b':
+			host = ABUSEHOST;
+			break;
+		case 'c':
+			country = optarg;
+			break;
+		case 'f':
+			host = FNICHOST;
+			break;
+		case 'g':
+			host = GNICHOST;
+			break;
+		case 'h':
+			host = optarg;
+			break;
+		case 'i':
+			host = INICHOST;
+			break;
+		case 'I':
+			host = IANAHOST;
+			break;
+		case 'k':
+			host = KNICHOST;
+			break;
+		case 'l':
+			host = LNICHOST;
+			break;
+		case 'm':
+			host = MNICHOST;
+			break;
+		case 'p':
+			port = optarg;
+			break;
+		case 'P':
+			host = PDBHOST;
+			break;
+		case 'Q':
+			flags |= WHOIS_QUICK;
+			break;
+		case 'r':
+			host = RNICHOST;
+			break;
+		case 'R':
+			flags |= WHOIS_RECURSE;
+			break;
+		case 'S':
+			flags |= WHOIS_SPAM_ME;
+			break;
+		case '?':
+		default:
+			usage();
+			/* NOTREACHED */
+		}
+	}
+	argc -= optind;
+	argv += optind;
+
+	if (!argc || (country != NULL && host != NULL))
+		usage();
+
+	/*
+	 * If no host or country is specified, rely on referrals from IANA.
+	 */
+	if (host == NULL && country == NULL) {
+		if ((host = getenv("WHOIS_SERVER")) == NULL &&
+		    (host = getenv("RA_SERVER")) == NULL) {
+			if (!(flags & WHOIS_QUICK))
+				flags |= WHOIS_RECURSE;
+		}
+	}
+	while (argc-- > 0) {
+		if (country != NULL) {
+			char *qnichost;
+			s_asprintf(&qnichost, "%s%s", country, QNICHOST_TAIL);
+			whois(*argv, qnichost, port, flags);
+			free(qnichost);
+		} else
+			whois(*argv, host != NULL ? host :
+			      choose_server(*argv), port, flags);
+		reset_rir();
+		argv++;
+	}
+	exit(0);
+}
+
+static const char *
+choose_server(char *domain)
+{
+	size_t len = strlen(domain);
+	int i;
+
+	for (i = 0; whoiswhere[i].suffix != NULL; i++) {
+		size_t suffix_len = strlen(whoiswhere[i].suffix);
+		if (len > suffix_len &&
+		    strcasecmp(domain + len - suffix_len,
+			       whoiswhere[i].suffix) == 0)
+			return (whoiswhere[i].server);
+	}
+	errx(EX_SOFTWARE, "no default whois server");
+}
+
+static struct addrinfo *
+gethostinfo(const char *host, const char *hport, int exit_on_noname)
+{
+	struct addrinfo hints, *res;
+	int error;
+
+	memset(&hints, 0, sizeof(hints));
+	hints.ai_flags = AI_CANONNAME;
+	hints.ai_family = AF_UNSPEC;
+	hints.ai_socktype = SOCK_STREAM;
+	res = NULL;
+	error = getaddrinfo(host, hport, &hints, &res);
+	if (error && (exit_on_noname || error != EAI_NONAME))
+		err(EX_NOHOST, "%s: %s", host, gai_strerror(error));
+	return (res);
+}
+
+/*
+ * Wrapper for asprintf(3) that exits on error.
+ */
+static void
+s_asprintf(char **ret, const char *format, ...)
+{
+	va_list ap;
+
+	va_start(ap, format);
+	if (vasprintf(ret, format, ap) == -1) {
+		va_end(ap);
+		err(EX_OSERR, "vasprintf()");
+	}
+	va_end(ap);
+}
+
+static int
+connect_to_any_host(struct addrinfo *hostres)
+{
+	struct addrinfo *res;
+	nfds_t i, j;
+	size_t count;
+	struct pollfd *fds;
+	int timeout = 180, s = -1;
+
+	for (res = hostres, count = 0; res; res = res->ai_next)
+		count++;
+	fds = calloc(count, sizeof(*fds));
+	if (fds == NULL)
+		err(EX_OSERR, "calloc()");
+
+	/*
+	 * Traverse the result list elements and make non-block
+	 * connection attempts.
+	 */
+	count = i = 0;
+	for (res = hostres; res != NULL; res = res->ai_next) {
+		s = socket(res->ai_family, res->ai_socktype | SOCK_NONBLOCK,
+		    res->ai_protocol);
+		if (s < 0)
+			continue;
+		if (connect(s, res->ai_addr, res->ai_addrlen) < 0) {
+			if (errno == EINPROGRESS) {
+				/* Add the socket to poll list */
+				fds[i].fd = s;
+				fds[i].events = POLLERR | POLLHUP |
+						POLLIN | POLLOUT;
+				/*
+				 * From here until a socket connects, the
+				 * socket fd is owned by the fds[] poll array.
+				 */
+				s = -1;
+				count++;
+				i++;
+			} else {
+				close(s);
+				s = -1;
+
+				/*
+				 * Poll only if we have something to poll,
+				 * otherwise just go ahead and try next
+				 * address
+				 */
+				if (count == 0)
+					continue;
+			}
+		} else
+			goto done;
+
+		/*
+		 * If we are at the last address, poll until a connection is
+		 * established or we failed all connection attempts.
+		 */
+		if (res->ai_next == NULL)
+			timeout = INFTIM;
+
+		/*
+		 * Poll the watched descriptors for successful connections:
+		 * if we still have more untried resolved addresses, poll only
+		 * once; otherwise, poll until all descriptors have errors,
+		 * which will be considered as ETIMEDOUT later.
+		 */
+		do {
+			int n;
+
+			n = poll(fds, i, timeout);
+			if (n == 0) {
+				/*
+				 * No event reported in time.  Try with a
+				 * smaller timeout (but cap at 2-3ms)
+				 * after a new host have been added.
+				 */
+				if (timeout >= 3)
+					timeout >>= 1;
+
+				break;
+			} else if (n < 0) {
+				/*
+				 * errno here can only be EINTR which we would
+				 * want to clean up and bail out.
+				 */
+				s = -1;
+				goto done;
+			}
+
+			/*
+			 * Check for the event(s) we have seen.
+			 */
+			for (j = 0; j < i; j++) {
+				if (fds[j].fd == -1 || fds[j].events == 0 ||
+				    fds[j].revents == 0)
+					continue;
+				if (fds[j].revents & ~(POLLIN | POLLOUT)) {
+					close(fds[j].fd);
+					fds[j].fd = -1;
+					fds[j].events = 0;
+					count--;
+					continue;
+				} else if (fds[j].revents & (POLLIN | POLLOUT)) {
+					/* Connect succeeded. */
+					s = fds[j].fd;
+					fds[j].fd = -1;
+
+					goto done;
+				}
+
+			}
+		} while (timeout == INFTIM && count != 0);
+	}
+
+	/* All attempts were failed */
+	s = -1;
+	if (count == 0)
+		errno = ETIMEDOUT;
+
+done:
+	/* Close all watched fds except the succeeded one */
+	for (j = 0; j < i; j++)
+		if (fds[j].fd != -1)
+			close(fds[j].fd);
+	free(fds);
+	return (s);
+}
+
+static void
+whois(const char *query, const char *hostname, const char *hostport, int flags)
+{
+	FILE *fp;
+	struct addrinfo *hostres;
+	char *buf, *host, *nhost, *nport, *p;
+	int comment, s, f;
+	size_t len, i;
+
+	hostres = gethostinfo(hostname, hostport, 1);
+	s = connect_to_any_host(hostres);
+	if (s == -1)
+		err(EX_OSERR, "connect()");
+
+	/* Restore default blocking behavior.  */
+	if ((f = fcntl(s, F_GETFL)) == -1)
+		err(EX_OSERR, "fcntl()");
+	f &= ~O_NONBLOCK;
+	if (fcntl(s, F_SETFL, f) == -1)
+		err(EX_OSERR, "fcntl()");
+
+	fp = fdopen(s, "r+");
+	if (fp == NULL)
+		err(EX_OSERR, "fdopen()");
+
+	if (!(flags & WHOIS_SPAM_ME) &&
+	    (strcasecmp(hostname, DENICHOST) == 0 ||
+	     strcasecmp(hostname, "de" QNICHOST_TAIL) == 0)) {
+		const char *q;
+		int idn = 0;
+		for (q = query; *q != '\0'; q++)
+			if (!isascii(*q))
+				idn = 1;
+		fprintf(fp, "-T dn%s %s\r\n", idn ? "" : ",ace", query);
+	} else if (!(flags & WHOIS_SPAM_ME) &&
+		   (strcasecmp(hostname, DKNICHOST) == 0 ||
+		    strcasecmp(hostname, "dk" QNICHOST_TAIL) == 0))
+		fprintf(fp, "--show-handles %s\r\n", query);
+	else if ((flags & WHOIS_SPAM_ME) ||
+		 strchr(query, ' ') != NULL)
+		fprintf(fp, "%s\r\n", query);
+	else if (strcasecmp(hostname, ANICHOST) == 0) {
+		if (strncasecmp(query, "AS", 2) == 0 &&
+		    strspn(query+2, "0123456789") == strlen(query+2))
+			fprintf(fp, "+ a %s\r\n", query+2);
+		else
+			fprintf(fp, "+ %s\r\n", query);
+	} else if (strcasecmp(hostres->ai_canonname, VNICHOST) == 0)
+		fprintf(fp, "domain %s\r\n", query);
+	else
+		fprintf(fp, "%s\r\n", query);
+	fflush(fp);
+
+	comment = 0;
+	if (!(flags & WHOIS_SPAM_ME) &&
+	    (strcasecmp(hostname, ANICHOST) == 0 ||
+	     strcasecmp(hostname, RNICHOST) == 0)) {
+		comment = 2;
+	}
+
+	nhost = NULL;
+	while ((buf = fgetln(fp, &len)) != NULL) {
+		/* Nominet */
+		if (!(flags & WHOIS_SPAM_ME) &&
+		    len == 5 && strncmp(buf, "-- \r\n", 5) == 0)
+			break;
+		/* RIRs */
+		if (comment == 1 && buf[0] == '#')
+			break;
+		else if (comment == 2) {
+			if (strchr("#%\r\n", buf[0]) != NULL)
+				continue;
+			else
+				comment = 1;
+		}
+
+		printf("%.*s", (int)len, buf);
+
+		if ((flags & WHOIS_RECURSE) && nhost == NULL) {
+			for (i = 0; whois_referral[i].prefix != NULL; i++) {
+				p = buf;
+				SCAN(p, buf+len, *p == ' ');
+				if (strncasecmp(p, whois_referral[i].prefix,
+					           whois_referral[i].len) != 0)
+					continue;
+				p += whois_referral[i].len;
+				SCAN(p, buf+len, *p == ' ');
+				host = p;
+				SCAN(p, buf+len, ishost(*p));
+				if (p > host) {
+					char *pstr;
+
+					s_asprintf(&nhost, "%.*s",
+						   (int)(p - host), host);
+
+					if (*p != ':') {
+						s_asprintf(&nport, "%s", port);
+						break;
+					}
+
+					pstr = ++p;
+					SCAN(p, buf+len, isdigit(*p));
+					if (p > pstr && (p - pstr) < 6) {
+						s_asprintf(&nport, "%.*s",
+						    (int)(p - pstr), pstr);
+						break;
+					}
+
+					/* Invalid port; don't recurse */
+					free(nhost);
+					nhost = NULL;
+				}
+				break;
+			}
+			for (i = 0; actually_arin[i] != NULL; i++) {
+				if (strncmp(buf, actually_arin[i], len) == 0) {
+					s_asprintf(&nhost, "%s", ANICHOST);
+					s_asprintf(&nport, "%s", port);
+					break;
+				}
+			}
+		}
+		/* Verisign etc. */
+		if (!(flags & WHOIS_SPAM_ME) &&
+		    len >= sizeof(CHOPSPAM)-1 &&
+		    (strncasecmp(buf, CHOPSPAM, sizeof(CHOPSPAM)-1) == 0 ||
+		     strncasecmp(buf, CHOPSPAM+4, sizeof(CHOPSPAM)-5) == 0)) {
+			printf("\n");
+			break;
+		}
+	}
+	fclose(fp);
+	freeaddrinfo(hostres);
+
+	f = 0;
+	for (i = 0; try_rir[i].host != NULL; i++) {
+		/* Remember visits to RIRs */
+		if (try_rir[i].loop == 0 &&
+		    strcasecmp(try_rir[i].host, hostname) == 0)
+			try_rir[i].loop = 1;
+		/* Do we need to find an alternative RIR? */
+		if (try_rir[i].loop != 0 && nhost != NULL &&
+		    strcasecmp(try_rir[i].host, nhost) == 0) {
+			free(nhost);
+			nhost = NULL;
+			free(nport);
+			nport = NULL;
+			f = 1;
+		}
+	}
+	if (f) {
+		/* Find a replacement RIR */
+		for (i = 0; try_rir[i].host != NULL; i++) {
+			if (try_rir[i].loop == 0) {
+				s_asprintf(&nhost, "%s", try_rir[i].host);
+				s_asprintf(&nport, "%s", port);
+				break;
+			}
+		}
+	}
+	if (nhost != NULL) {
+		/* Ignore self-referrals */
+		if (strcasecmp(hostname, nhost) != 0) {
+			printf("# %s\n\n", nhost);
+			whois(query, nhost, nport, flags);
+		}
+		free(nhost);
+		free(nport);
+	}
+}
+
+static void
+usage(void)
+{
+	fprintf(stderr,
+	    "usage: whois [-aAbfgiIklmPQrRS] [-c country-code | -h hostname] "
+	    "[-p port] name ...\n");
+	exit(EX_USAGE);
+}

libc/assert.h

@@ -7,29 +7,69 @@ extern bool __assert_disable;
 void __assert_fail(const char *, const char *, int) hidden relegated;
 
 #ifdef NDEBUG
-#define assert(EXPR) ((void)0)
+#define assert(x) ((void)0)
 #else
-#define assert(EXPR) \
-  ((void)((EXPR) || (__assert_fail(#EXPR, __FILE__, __LINE__), 0)))
+#define assert(x) ((void)((x) || (__assert_fail(#x, __FILE__, __LINE__), 0)))
 #endif
 
 #ifndef __cplusplus
 #define static_assert _Static_assert
 #endif
 
-#define _unassert(x)                 \
-  do {                               \
-    if (__builtin_expect(!(x), 0)) { \
-      unreachable;                   \
-    }                                \
-  } while (0)
-
+#ifdef __GNUC__
+#if !defined(TINY) && !defined(MODE_DBG)
+/**
+ * Specifies expression can't possibly be false.
+ *
+ * This macro uses the `notpossible` keyword and is intended for things
+ * like systems integration, where we know for a fact that something is
+ * never going to happen, but there's no proof. So we don't want to add
+ * extra bloat for filenames and line numbers, since `ShowCrashReports`
+ * can print a backtrace if we just embed the UD2 instruction to crash.
+ * That's useful for systems code, for the following reason. Invariants
+ * make sense with _unassert() since they usually get placed at the top
+ * of functions. But if you used _unassert() to test a system call does
+ * not fail, then check happens at the end of your function usually and
+ * is therefore likely to result in a failure condition where execution
+ * falls through into a different function, which is shocking to debug.
+ *
+ * In `MODE=tiny` these assertions are redefined as undefined behavior.
+ */
 #define _npassert(x)                 \
-  do {                               \
+  ({                                 \
     if (__builtin_expect(!(x), 0)) { \
       notpossible;                   \
     }                                \
-  } while (0)
+    (void)0;                         \
+  })
+#else
+#define _npassert(x) _unassert(x)
+#endif
+#endif
+
+#ifdef __GNUC__
+/**
+ * Specifies expression being false is undefined behavior.
+ *
+ * This is a good way to tell the compiler about your invariants, which
+ * leads to smaller faster programs. The expression is never removed by
+ * the preprocessor so it's recommended that it be free of side-effects
+ * if you intend for it to be removed. At the same time, this guarantee
+ * makes this assertion useful for things like system calls, since they
+ * won't be removed by `NDEBUG` mode.
+ *
+ * If this assertion fails, the worst possible things can happen unless
+ * you've built your binary in `MODE=dbg` since UBSAN is the only thing
+ * that's capable of debugging this macro.
+ */
+#define _unassert(x)                 \
+  ({                                 \
+    if (__builtin_expect(!(x), 0)) { \
+      unreachable;                   \
+    }                                \
+    (void)0;                         \
+  })
+#endif
 
 COSMOPOLITAN_C_END_
 #endif /* !(__ASSEMBLER__ + __LINKER__ + 0) */

libc/calls/__sig.c

@@ -16,5 +16,6 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
+#include "libc/calls/sig.internal.h"
 
-bool __time_critical;
+struct Signals __sig;

libc/calls/__sig2.c

@@ -16,26 +16,23 @@
 │ 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"
 #include "libc/calls/state.internal.h"
 #include "libc/calls/struct/sigaction.h"
 #include "libc/calls/struct/siginfo.h"
-#include "libc/intrin/cmpxchg.h"
-#include "libc/intrin/lockcmpxchg.h"
+#include "libc/calls/struct/sigset.h"
 #include "libc/intrin/strace.internal.h"
-#include "libc/log/libfatal.internal.h"
 #include "libc/macros.internal.h"
 #include "libc/runtime/internal.h"
 #include "libc/runtime/runtime.h"
+#include "libc/str/str.h"
 #include "libc/sysv/consts/sa.h"
 #include "libc/sysv/consts/sig.h"
 #include "libc/sysv/errfuns.h"
-
-/**
- * @fileoverview UNIX signals for the New Technology, Part 2.
- * @threadsafe
- */
+#include "libc/thread/tls.h"
 
 /**
  * Allocates piece of memory for storing pending signal.
@@ -61,6 +58,18 @@ static textwindows void __sig_free(struct Signal *mem) {
   mem->used = false;
 }
 
+static inline textwindows int __sig_is_masked(int sig) {
+  if (__tls_enabled) {
+    return __get_tls()->tib_sigmask & (1ull << (sig - 1));
+  } else {
+    return __sig.sigmask & (1ull << (sig - 1));
+  }
+}
+
+textwindows int __sig_is_applicable(struct Signal *s) {
+  return s->tid <= 0 || s->tid == gettid();
+}
+
 /**
  * Dequeues signal that isn't masked.
  * @return signal or null if empty or none unmasked
@@ -70,7 +79,7 @@ static textwindows struct Signal *__sig_remove(void) {
   if (__sig.queue) {
     __sig_lock();
     for (prev = 0, res = __sig.queue; res; prev = res, res = res->next) {
-      if (!sigismember(&__sig.mask, res->sig)) {
+      if (__sig_is_applicable(res) && !__sig_is_masked(res->sig)) {
         if (res == __sig.queue) {
           __sig.queue = res->next;
         } else if (prev) {
@@ -78,8 +87,6 @@ static textwindows struct Signal *__sig_remove(void) {
         }
         res->next = 0;
         break;
-      } else {
-        STRACE("%G is masked", res->sig);
       }
     }
     __sig_unlock();
@@ -101,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)) {
@@ -112,12 +118,11 @@ 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()
   if (flags & SA_SIGINFO) {
-    __repstosb(&info, 0, sizeof(info));
+    bzero(&info, sizeof(info));
     info.si_signo = sig;
     info.si_code = si_code;
     infop = &info;
@@ -134,7 +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.
-    _lockcmpxchg(__sighandrvas + sig, (int32_t)(intptr_t)SIG_DFL, rva);
+    if (__sighandrvas[sig] == (int32_t)(intptr_t)SIG_DFL) {
+      __sighandrvas[sig] = rva;
+    }
   }
 
   if (!restartable) {
@@ -150,7 +157,7 @@ static bool __sig_deliver(bool restartable, int sig, int si_code,
 /**
  * Returns true if signal default action is to end process.
  */
-static textwindows bool __sig_isfatal(int sig) {
+static textwindows bool __sig_is_fatal(int sig) {
   if (sig == SIGCHLD || sig == SIGURG || sig == SIGWINCH) {
     return false;
   } else {
@@ -168,7 +175,7 @@ bool __sig_handle(bool restartable, int sig, int si_code, ucontext_t *ctx) {
   bool delivered;
   switch (__sighandrvas[sig]) {
     case (intptr_t)SIG_DFL:
-      if (__sig_isfatal(sig)) {
+      if (__sig_is_fatal(sig)) {
         STRACE("terminating on %G", sig);
         _Exitr(128 + sig);
       }
@@ -194,20 +201,18 @@ bool __sig_handle(bool restartable, int sig, int si_code, ucontext_t *ctx) {
  * @threadsafe
  */
 textwindows int __sig_raise(int sig, int si_code) {
-  int rc;
-  int candeliver;
-  __sig_lock();
-  candeliver = !sigismember(&__sig.mask, sig);
-  __sig_unlock();
-  switch (candeliver) {
-    case 1:
+  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;
-    case 0:
+    } else {
       STRACE("%G is masked", sig);
-      return __sig_add(sig, si_code);
-    default:
-      return -1;  // sigismember() validates `sig`
+      return __sig_add(gettid(), sig, si_code);
+    }
+  } else {
+    return einval();
   }
 }
 
@@ -216,18 +221,19 @@ textwindows int __sig_raise(int sig, int si_code) {
  * @return 0 on success, otherwise -1 w/ errno
  * @threadsafe
  */
-textwindows int __sig_add(int sig, int si_code) {
+textwindows int __sig_add(int tid, int sig, int si_code) {
   int rc;
   struct Signal *mem;
-  if (1 <= sig && sig <= NSIG) {
-    __sig_lock();
+  if (1 <= sig && sig <= 64) {
     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;
         mem->sig = sig;
         mem->si_code = si_code;
         mem->next = __sig.queue;
@@ -236,8 +242,8 @@ textwindows int __sig_add(int sig, int si_code) {
       } else {
         rc = enomem();
       }
+      __sig_unlock();
     }
-    __sig_unlock();
   } else {
     rc = einval();
   }
@@ -276,7 +282,7 @@ textwindows bool __sig_check(bool restartable) {
 textwindows void __sig_check_ignore(const int sig, const unsigned rva) {
   struct Signal *cur, *prev, *next;
   if (rva != (unsigned)(intptr_t)SIG_IGN &&
-      (rva != (unsigned)(intptr_t)SIG_DFL || __sig_isfatal(sig))) {
+      (rva != (unsigned)(intptr_t)SIG_DFL || __sig_is_fatal(sig))) {
     return;
   }
   if (__sig.queue) {
@@ -298,25 +304,3 @@ textwindows void __sig_check_ignore(const int sig, const unsigned rva) {
     __sig_unlock();
   }
 }
-
-/**
- * Determines the pending signals on New Technology.
- *
- * @param pending is to hold the pending signals
- * @threadsafe
- */
-textwindows void __sig_pending(sigset_t *pending) {
-  struct Signal *cur;
-  sigemptyset(pending);
-  if (__sig.queue) {
-    __sig_lock();
-    for (cur = __sig.queue; cur; cur = cur->next) {
-      if (__sighandrvas[cur->sig] != (unsigned)(intptr_t)SIG_IGN) {
-        pending->__bits[(cur->sig - 1) >> 6] |= (1ull << ((cur->sig - 1) & 63));
-      } else {
-        STRACE("%G is ignored", cur->sig);
-      }
-    }
-    __sig_unlock();
-  }
-}

libc/calls/__sig_mask.c

@@ -16,50 +16,45 @@
 │ 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/state.internal.h"
-#include "libc/macros.internal.h"
+#include "libc/calls/struct/sigset.h"
 #include "libc/sysv/consts/sig.h"
 #include "libc/sysv/errfuns.h"
+#include "libc/thread/tls.h"
 
-/**
- * @fileoverview UNIX signals for the New Technology, Part 1.
- * @threadsafe
- */
+#define GetSigBit(x) (1ull << (((x)-1) & 63))
 
-struct Signals __sig;  // TODO(jart): Need TLS
-
-#define GetSigBit(XXSIG) (1ull << (((XXSIG)-1) & 63))
-
-/**
- * Changes signal mask for main thread.
- * @return 0 on success, or -1 w/ errno
- */
 textwindows int __sig_mask(int how, const sigset_t *neu, sigset_t *old) {
-  int i;
-  uint64_t a, b;
+  uint64_t x, y, *mask;
   if (how == SIG_BLOCK || how == SIG_UNBLOCK || how == SIG_SETMASK) {
-    __sig_lock();
+    if (__tls_enabled) {
+      mask = &__get_tls()->tib_sigmask;
+    } else {
+      mask = &__sig.sigmask;
+    }
     if (old) {
-      *old = __sig.mask;
+      old->__bits[0] = *mask;
+      old->__bits[1] = 0;
     }
     if (neu) {
-      for (i = 0; i < ARRAYLEN(__sig.mask.__bits); ++i) {
-        if (how == SIG_BLOCK) {
-          __sig.mask.__bits[i] |= neu->__bits[i];
-        } else if (how == SIG_UNBLOCK) {
-          __sig.mask.__bits[i] &= ~neu->__bits[i];
-        } else {
-          __sig.mask.__bits[i] = neu->__bits[i];
-        }
+      x = *mask;
+      y = neu->__bits[0];
+      if (how == SIG_BLOCK) {
+        x |= y;
+      } else if (how == SIG_UNBLOCK) {
+        x &= ~y;
+      } else {
+        x = y;
       }
-      __sig.mask.__bits[0] &= ~(GetSigBit(SIGKILL) | GetSigBit(SIGSTOP));
+      x &= ~(0
+#define M(x) | GetSigBit(x)
+#include "libc/intrin/sigisprecious.inc"
+      );
+      *mask = x;
     }
-    __sig_unlock();
     return 0;
   } else {
     return einval();
   }
 }
-
-#undef GetSigBit

libc/calls/__sig_pending.c

@@ -0,0 +1,43 @@
+/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│
+│vi: set net ft=c ts=2 sts=2 sw=2 fenc=utf-8                                :vi│
+╞══════════════════════════════════════════════════════════════════════════════╡
+│ Copyright 2022 Justine Alexandra Roberts Tunney                              │
+│                                                                              │
+│ Permission to use, copy, modify, and/or distribute this software for         │
+│ any purpose with or without fee is hereby granted, provided that the         │
+│ above copyright notice and this permission notice appear in all copies.      │
+│                                                                              │
+│ THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL                │
+│ WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED                │
+│ WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE             │
+│ AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL         │
+│ DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR        │
+│ PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER               │
+│ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
+│ PERFORMANCE OF THIS SOFTWARE.                                                │
+╚─────────────────────────────────────────────────────────────────────────────*/
+#include "libc/calls/calls.h"
+#include "libc/calls/sig.internal.h"
+#include "libc/calls/state.internal.h"
+#include "libc/calls/struct/sigset.h"
+
+/**
+ * Determines the pending signals on New Technology.
+ *
+ * @param pending is to hold the pending signals
+ * @threadsafe
+ */
+textwindows void __sig_pending(sigset_t *pending) {
+  struct Signal *s;
+  sigemptyset(pending);
+  if (__sig.queue) {
+    __sig_lock();
+    for (s = __sig.queue; s; s = s->next) {
+      if (__sig_is_applicable(s) &&
+          __sighandrvas[s->sig] != (unsigned)(intptr_t)SIG_IGN) {
+        sigaddset(pending, s->sig);
+      }
+    }
+    __sig_unlock();
+  }
+}

libc/calls/_ptsname.c

@@ -0,0 +1,93 @@
+/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│
+│vi: set net ft=c ts=2 sts=2 sw=2 fenc=utf-8                                :vi│
+╞══════════════════════════════════════════════════════════════════════════════╡
+│ Copyright 2022 Justine Alexandra Roberts Tunney                              │
+│                                                                              │
+│ Permission to use, copy, modify, and/or distribute this software for         │
+│ any purpose with or without fee is hereby granted, provided that the         │
+│ above copyright notice and this permission notice appear in all copies.      │
+│                                                                              │
+│ THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL                │
+│ WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED                │
+│ WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE             │
+│ AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL         │
+│ DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR        │
+│ PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER               │
+│ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
+│ PERFORMANCE OF THIS SOFTWARE.                                                │
+╚─────────────────────────────────────────────────────────────────────────────*/
+#include "libc/calls/syscall-sysv.internal.h"
+#include "libc/calls/syscall_support-sysv.internal.h"
+#include "libc/dce.h"
+#include "libc/errno.h"
+#include "libc/fmt/itoa.h"
+#include "libc/str/str.h"
+#include "libc/sysv/consts/termios.h"
+#include "libc/sysv/errfuns.h"
+
+extern const unsigned FIODGNAME;
+extern const unsigned TIOCPTSNAME;
+extern const unsigned TIOCPTYGNAME;
+
+struct fiodgname_arg {
+  int len;
+  void *buf;
+};
+
+struct ptmget {
+  int cfd;
+  int sfd;
+  char cn[1024];
+  char sn[1024];
+};
+
+int _ptsname(int fd, char *buf, size_t size) {
+  int pty;
+  size_t n;
+  struct ptmget t;
+
+  if (_isptmaster(fd)) {
+    return -1;
+  }
+
+  t.sn[0] = '/';
+  t.sn[1] = 'd';
+  t.sn[2] = 'e';
+  t.sn[3] = 'v';
+  t.sn[4] = '/';
+  t.sn[5] = 0;
+
+  if (IsLinux()) {
+    if (sys_ioctl(fd, TIOCGPTN, &pty)) return -1;
+    t.sn[5] = 'p';
+    t.sn[6] = 't';
+    t.sn[7] = 's';
+    t.sn[8] = '/';
+    FormatInt32(t.sn + 9, pty);
+  } else if (IsXnu()) {
+    if (sys_ioctl(fd, TIOCPTYGNAME, t.sn)) {
+      return -1;
+    }
+  } else if (IsFreebsd()) {
+    struct fiodgname_arg fgn = {sizeof(t.sn) - 5, t.sn + 5};
+    if (sys_ioctl(fd, FIODGNAME, &fgn) == -1) {
+      if (errno == EINVAL) {
+        errno = ERANGE;
+      }
+      return -1;
+    }
+  } else if (IsNetbsd()) {
+    if (sys_ioctl(fd, TIOCPTSNAME, &t)) {
+      return -1;
+    }
+  } else {
+    return enosys();
+  }
+
+  if ((n = strlen(t.sn)) < size) {
+    memcpy(buf, t.sn, n + 1);
+    return 0;
+  } else {
+    return erange();
+  }
+}

libc/calls/access.c

@@ -22,9 +22,14 @@
 /**
  * Checks if effective user can access path in particular ways.
  *
+ * This is equivalent to saying:
+ *
+ *     faccessat(AT_FDCWD, path, mode, 0);
+ *
  * @param path is a filename or directory
  * @param mode can be R_OK, W_OK, X_OK, F_OK
- * @return 0 if ok, or -1 and sets errno
+ * @return 0 if ok, or -1 w/ errno
+ * @see faccessat() for further documentation
  * @asyncsignalsafe
  */
 int access(const char *path, int mode) {

libc/calls/alarm.c

@@ -32,12 +32,10 @@
  * @asyncsignalsafe
  */
 unsigned alarm(unsigned seconds) {
-  int rc;
   struct itimerval it;
   bzero(&it, sizeof(it));
   it.it_value.tv_sec = seconds;
-  rc = setitimer(ITIMER_REAL, &it, &it);
-  assert(rc != -1);
+  _npassert(!setitimer(ITIMER_REAL, &it, &it));
   if (!it.it_value.tv_sec && !it.it_value.tv_usec) {
     return 0;
   } else {

libc/calls/asan.internal.h

@@ -1,7 +1,8 @@
 #ifndef COSMOPOLITAN_LIBC_CALLS_ASAN_INTERNAL_H_
 #define COSMOPOLITAN_LIBC_CALLS_ASAN_INTERNAL_H_
-#include "libc/intrin/asmflag.h"
 #include "libc/calls/struct/timespec.h"
+#include "libc/calls/struct/timeval.h"
+#include "libc/intrin/asmflag.h"
 #if !(__ASSEMBLER__ + __LINKER__ + 0)
 COSMOPOLITAN_C_START_
 
@@ -14,6 +15,10 @@ forceinline bool __asan_is_valid_timespec(const struct timespec *ts) {
   return zf;
 }
 
+forceinline bool __asan_is_valid_timeval(const struct timeval *tv) {
+  return __asan_is_valid_timespec((const struct timespec *)tv);
+}
+
 COSMOPOLITAN_C_END_
 #endif /* !(__ASSEMBLER__ + __LINKER__ + 0) */
 #endif /* COSMOPOLITAN_LIBC_CALLS_ASAN_INTERNAL_H_ */

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,24 +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 faccessat(int, const char *, int, uint32_t);
+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;
@@ -109,35 +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 *, uint32_t);
-int mkdirat(int, const char *, uint32_t);
-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 mkdir(const char *, unsigned);
+int mkdirat(int, const char *, unsigned);
+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, ...);
@@ -147,7 +139,7 @@ int pipe(int[hasatleast 2]);
 int pipe2(int[hasatleast 2], int);
 int pivot_root(const char *, const char *);
 int pledge(const char *, const char *);
-int posix_fadvise(int, uint64_t, uint64_t, int);
+int posix_fadvise(int, int64_t, int64_t, int);
 int posix_madvise(void *, uint64_t, int);
 int prctl(int, ...);
 int raise(int);
@@ -159,36 +151,42 @@ 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 setfsgid(int);
-int setfsuid(int);
-int setgid(int);
-int setgroups(size_t size, const uint32_t list[]);
+int setegid(unsigned);
+int seteuid(unsigned);
+int setfsgid(unsigned);
+int setfsuid(unsigned);
+int setgid(unsigned);
+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(int);
+int setuid(unsigned);
 int sigignore(int);
 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 truncate(const char *, uint64_t);
+int touch(const char *, unsigned);
+int truncate(const char *, int64_t);
 int ttyname_r(int, char *, size_t);
-int umask(int);
 int unlink(const char *);
 int unlink_s(const char **);
 int unlinkat(int, const char *, int);
@@ -197,21 +195,25 @@ 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, unsigned);
+ssize_t lseek(int, int64_t, int);
 ssize_t pread(int, void *, size_t, int64_t);
 ssize_t pwrite(int, const void *, size_t, int64_t);
 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

@@ -65,6 +65,13 @@ $(LIBC_CALLS_A).pkg:					\
 		$(LIBC_CALLS_A_OBJS)			\
 		$(foreach x,$(LIBC_CALLS_A_DIRECTDEPS),$($(x)_A).pkg)
 
+# we can't use asan because:
+#   siginfo_t memory is owned by kernels
+o/$(MODE)/libc/calls/siginfo2cosmo.o: private		\
+		OVERRIDE_COPTS +=			\
+			-ffreestanding			\
+			-fno-sanitize=address
+
 # we can't use asan because:
 #   ucontext_t memory is owned by xnu kernel
 o/$(MODE)/libc/calls/sigenter-xnu.o: private		\
@@ -97,6 +104,7 @@ o/$(MODE)/libc/calls/ntcontext2linux.o: private		\
 
 # we always want -O3 because:
 #   it makes the code size smaller too
+o/$(MODE)/libc/calls/termios2host.o			\
 o/$(MODE)/libc/calls/sigenter-freebsd.o			\
 o/$(MODE)/libc/calls/sigenter-netbsd.o			\
 o/$(MODE)/libc/calls/sigenter-openbsd.o			\
@@ -171,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

@@ -17,17 +17,72 @@
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/calls/termios.h"
+#include "libc/sysv/consts/termios.h"
 #include "libc/sysv/errfuns.h"
 
-int cfsetispeed(struct termios *t, int speed) {
+/**
+ * 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) return einval();
-      t->c_cflag &= ~CBAUD;
-      t->c_cflag |= speed;
+      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)) {
+      t->c_cflag &= ~CBAUD;
+      t->c_cflag |= speed;
+      return 0;
+    } else {
+      return einval();
+    }
+  } else {
+    t->c_ospeed = speed;
+    return 0;
+  }
+}

libc/calls/chdir-nt.c

@@ -26,35 +26,36 @@
 #include "libc/nt/synchronization.h"
 #include "libc/sysv/errfuns.h"
 
-textwindows int sys_chdir_nt(const char *path) {
+textwindows int sys_chdir_nt_impl(char16_t path[hasatleast PATH_MAX],
+                                  uint32_t len) {
   uint32_t n;
-  int e, ms, err, len;
-  char16_t path16[PATH_MAX], var[4];
-  if ((len = __mkntpath(path, path16)) == -1) return -1;
-  if (!len) return enoent();
-  if (len && path16[len - 1] != u'\\') {
+  int e, ms, err;
+  char16_t var[4];
+
+  if (len && path[len - 1] != u'\\') {
     if (len + 2 > PATH_MAX) return enametoolong();
-    path16[len + 0] = u'\\';
-    path16[len + 1] = u'\0';
+    path[len + 0] = u'\\';
+    path[len + 1] = u'\0';
   }
+
   /*
    * chdir() seems flaky on windows 7
    * in a similar way to rmdir() sigh
    */
   for (err = errno, ms = 1;; ms *= 2) {
-    if (SetCurrentDirectory(path16)) {
+    if (SetCurrentDirectory(path)) {
       /*
        * Now we need to set a magic environment variable.
        */
-      if ((n = GetCurrentDirectory(ARRAYLEN(path16), path16))) {
-        if (n < ARRAYLEN(path16)) {
-          if (!((path16[0] == '/' && path16[1] == '/') ||
-                (path16[0] == '\\' && path16[1] == '\\'))) {
+      if ((n = GetCurrentDirectory(PATH_MAX, path))) {
+        if (n < PATH_MAX) {
+          if (!((path[0] == '/' && path[1] == '/') ||
+                (path[0] == '\\' && path[1] == '\\'))) {
             var[0] = '=';
-            var[1] = path16[0];
+            var[1] = path[0];
             var[2] = ':';
             var[3] = 0;
-            if (!SetEnvironmentVariable(var, path16)) {
+            if (!SetEnvironmentVariable(var, path)) {
               return __winerr();
             }
           }
@@ -77,5 +78,13 @@ textwindows int sys_chdir_nt(const char *path) {
       }
     }
   }
-  return __fix_enotdir(-1, path16);
+  return __fix_enotdir(-1, path);
+}
+
+textwindows int sys_chdir_nt(const char *path) {
+  int len;
+  char16_t path16[PATH_MAX];
+  if ((len = __mkntpath(path, path16)) == -1) return -1;
+  if (!len) return enoent();
+  return sys_chdir_nt_impl(path16, len);
 }

libc/calls/chdir.c

@@ -16,11 +16,12 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/intrin/strace.internal.h"
 #include "libc/calls/syscall-nt.internal.h"
 #include "libc/calls/syscall-sysv.internal.h"
 #include "libc/dce.h"
 #include "libc/intrin/asan.internal.h"
+#include "libc/intrin/strace.internal.h"
+#include "libc/runtime/runtime.h"
 #include "libc/sysv/errfuns.h"
 
 /**
@@ -34,7 +35,8 @@
  */
 int chdir(const char *path) {
   int rc;
-  if (!path || (IsAsan() && !__asan_is_valid(path, 1))) {
+  GetProgramExecutableName();  // XXX: ugly workaround
+  if (!path || (IsAsan() && !__asan_is_valid_str(path))) {
     rc = efault();
   } else if (!IsWindows()) {
     rc = sys_chdir(path);

libc/calls/chroot.c

@@ -17,17 +17,43 @@
 │ 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/errfuns.h"
 
 /**
  * Changes root directory.
  *
+ * Please consider using unveil() instead of chroot(). If you use this
+ * system call then consider using both chdir() and closefrom() before
+ * calling this function. Otherwise there's a small risk that fchdir()
+ * could be used to escape the chroot() environment. Cosmopolitan Libc
+ * focuses on static binaries which make chroot() infinitely easier to
+ * use since you don't need to construct an entire userspace each time
+ * however unveil() is still better to use on modern Linux and OpenBSD
+ * because it doesn't require root privileges.
+ *
+ * @param path shall become the new root directory
+ * @return 0 on success, or -1 w/ errno
+ * @raise EACCES if we don't have permission to search a component of `path`
+ * @raise ENOTDIR if a directory component in `path` exists as non-directory
+ * @raise ENAMETOOLONG if symlink-resolved `path` length exceeds `PATH_MAX`
+ * @raise ENAMETOOLONG if component in `path` exists longer than `NAME_MAX`
+ * @raise EPERM if not root or pledge() is in play
+ * @raise EIO if a low-level i/o error occurred
+ * @raise EFAULT if `path` is bad memory
+ * @raise ENOENT if `path` doesn't exist
  * @raise ENOSYS on Windows
  */
 int chroot(const char *path) {
   int rc;
-  rc = sys_chroot(path);
+  if (!path || (IsAsan() && !__asan_is_valid_str(path))) {
+    rc = efault();
+  } else {
+    rc = sys_chroot(path);
+  }
   STRACE("chroot(%s) → %d% m", path, rc);
   return rc;
 }

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

@@ -17,10 +17,10 @@
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/calls/asan.internal.h"
-#include "libc/intrin/strace.internal.h"
 #include "libc/calls/struct/timespec.internal.h"
 #include "libc/dce.h"
 #include "libc/intrin/describeflags.internal.h"
+#include "libc/intrin/strace.internal.h"
 #include "libc/sysv/consts/clock.h"
 #include "libc/sysv/errfuns.h"
 #include "libc/time/time.h"
@@ -49,6 +49,12 @@ static int sys_clock_getres_xnu(int clock, struct timespec *ts) {
 
 /**
  * Returns granularity of clock.
+ *
+ * @return 0 on success, or -1 w/ errno
+ * @error EPERM if pledge() is in play without stdio promise
+ * @error EINVAL if `clock` isn't supported on this system
+ * @error EFAULT if `ts` points to bad memory
+ * @threadsafe
  */
 int clock_getres(int clock, struct timespec *ts) {
   int rc;

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

@@ -20,7 +20,6 @@
 #include "libc/calls/asan.internal.h"
 #include "libc/calls/clock_gettime.internal.h"
 #include "libc/calls/state.internal.h"
-#include "libc/intrin/strace.internal.h"
 #include "libc/calls/struct/timespec.internal.h"
 #include "libc/calls/struct/timeval.h"
 #include "libc/calls/syscall_support-sysv.internal.h"
@@ -30,9 +29,11 @@
 #include "libc/intrin/asmflag.h"
 #include "libc/intrin/bits.h"
 #include "libc/intrin/describeflags.internal.h"
+#include "libc/intrin/strace.internal.h"
 #include "libc/mem/alloca.h"
 #include "libc/nt/synchronization.h"
 #include "libc/sysv/errfuns.h"
+#include "libc/thread/tls.h"
 
 /**
  * Returns nanosecond time.
@@ -48,12 +49,30 @@
  *     __clock_gettime     l:        35𝑐        11𝑛𝑠
  *     sys_clock_gettime   l:       220𝑐        71𝑛𝑠
  *
- * @param clock can be CLOCK_REALTIME, CLOCK_MONOTONIC, etc.
+ * @param clock can be one of:
+ *     - `CLOCK_REALTIME`: universally supported
+ *     - `CLOCK_REALTIME_FAST`: ditto but faster on freebsd
+ *     - `CLOCK_MONOTONIC`: universally supported
+ *     - `CLOCK_MONOTONIC_FAST`: ditto but faster on freebsd
+ *     - `CLOCK_MONOTONIC_RAW`: nearly universally supported
+ *     - `CLOCK_PROCESS_CPUTIME_ID`: linux and bsd
+ *     - `CLOCK_THREAD_CPUTIME_ID`: linux and bsd
+ *     - `CLOCK_REALTIME_COARSE`: : linux and openbsd
+ *     - `CLOCK_MONOTONIC_COARSE`: linux
+ *     - `CLOCK_PROF`: linux and netbsd
+ *     - `CLOCK_BOOTTIME`: linux and openbsd
+ *     - `CLOCK_REALTIME_ALARM`: linux-only
+ *     - `CLOCK_BOOTTIME_ALARM`: linux-only
+ *     - `CLOCK_TAI`: linux-only
  * @param ts is where the result is stored
  * @return 0 on success, or -1 w/ errno
- * @error EINVAL if clock isn't supported on this system
+ * @error EPERM if pledge() is in play without stdio promise
+ * @error EINVAL if `clock` isn't supported on this system
+ * @error EFAULT if `ts` points to bad memory
  * @see strftime(), gettimeofday()
  * @asyncsignalsafe
+ * @threadsafe
+ * @vforksafe
  */
 int clock_gettime(int clock, struct timespec *ts) {
   int rc;
@@ -65,7 +84,7 @@ int clock_gettime(int clock, struct timespec *ts) {
     rc = __clock_gettime(clock, ts);
   }
 #if SYSDEBUG
-  if (!__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

@@ -0,0 +1,57 @@
+/*-*- 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/internal.h"
+#include "libc/calls/sig.internal.h"
+#include "libc/calls/struct/timespec.h"
+#include "libc/calls/struct/timespec.internal.h"
+#include "libc/macros.internal.h"
+#include "libc/nt/synchronization.h"
+#include "libc/sysv/consts/timer.h"
+#include "libc/sysv/errfuns.h"
+
+textwindows int sys_clock_nanosleep_nt(int clock, int flags,
+                                       const struct timespec *req,
+                                       struct timespec *rem) {
+  struct timespec now, abs;
+  if (flags & TIMER_ABSTIME) {
+    abs = *req;
+    for (;;) {
+      if (sys_clock_gettime_nt(clock, &now)) return -1;
+      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))),
+              false);
+    }
+  } else {
+    if (sys_clock_gettime_nt(clock, &now)) return -1;
+    abs = timespec_add(now, *req);
+    for (;;) {
+      sys_clock_gettime_nt(clock, &now);
+      if (timespec_cmp(now, abs) >= 0) return 0;
+      if (_check_interrupts(false, g_fds.p)) {
+        if (rem) *rem = timespec_sub(abs, now);
+        return -1;
+      }
+      SleepEx(MIN(__SIG_POLLING_INTERVAL_MS,
+                  timespec_tomillis(timespec_sub(abs, now))),
+              false);
+    }
+  }
+}

libc/calls/clock_nanosleep-openbsd.c

@@ -0,0 +1,45 @@
+/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│
+│vi: set net ft=c ts=2 sts=2 sw=2 fenc=utf-8                                :vi│
+╞══════════════════════════════════════════════════════════════════════════════╡
+│ Copyright 2022 Justine Alexandra Roberts Tunney                              │
+│                                                                              │
+│ Permission to use, copy, modify, and/or distribute this software for         │
+│ any purpose with or without fee is hereby granted, provided that the         │
+│ above copyright notice and this permission notice appear in all copies.      │
+│                                                                              │
+│ THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL                │
+│ WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED                │
+│ WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE             │
+│ AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL         │
+│ DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR        │
+│ PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER               │
+│ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
+│ PERFORMANCE OF THIS SOFTWARE.                                                │
+╚─────────────────────────────────────────────────────────────────────────────*/
+#include "libc/calls/struct/timespec.h"
+#include "libc/calls/struct/timespec.internal.h"
+#include "libc/sysv/consts/clock.h"
+#include "libc/sysv/errfuns.h"
+
+int sys_clock_nanosleep_openbsd(int clock, int flags,
+                                const struct timespec *req,
+                                struct timespec *rem) {
+  int res;
+  struct timespec now, rel;
+  if (clock == CLOCK_REALTIME) {
+    if (!flags) {
+      res = sys_nanosleep(req, rem);
+    } else {
+      sys_clock_gettime(clock, &now);
+      if (timespec_cmp(*req, now) > 0) {
+        rel = timespec_sub(*req, now);
+        res = sys_nanosleep(&rel, 0);
+      } else {
+        res = 0;
+      }
+    }
+  } else {
+    res = enotsup();
+  }
+  return res;
+}

libc/calls/clock_nanosleep-xnu.c

@@ -1,7 +1,7 @@
 /*-*- 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                              │
+│ Copyright 2022 Justine Alexandra Roberts Tunney                              │
 │                                                                              │
 │ Permission to use, copy, modify, and/or distribute this software for         │
 │ any purpose with or without fee is hereby granted, provided that the         │
@@ -16,21 +16,34 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/calls/struct/timespec.h"
 #include "libc/calls/struct/timespec.internal.h"
 #include "libc/calls/struct/timeval.h"
 #include "libc/calls/struct/timeval.internal.h"
-#include "libc/sysv/consts/at.h"
+#include "libc/fmt/conv.h"
+#include "libc/sock/internal.h"
+#include "libc/sysv/consts/clock.h"
+#include "libc/sysv/consts/timer.h"
+#include "libc/sysv/errfuns.h"
 
-textwindows int sys_utimes_nt(const char *path, const struct timeval tv[2]) {
-  struct timespec ts[2];
-  if (tv) {
-    ts[0].tv_sec = tv[0].tv_sec;
-    ts[0].tv_nsec = tv[0].tv_usec * 1000;
-    ts[1].tv_sec = tv[1].tv_sec;
-    ts[1].tv_nsec = tv[1].tv_usec * 1000;
-    return sys_utimensat_nt(AT_FDCWD, path, ts, 0);
+int sys_clock_nanosleep_xnu(int clock, int flags, const struct timespec *req,
+                            struct timespec *rem) {
+  int res;
+  struct timeval now, abs, rel;
+  if (clock == CLOCK_REALTIME) {
+    if (flags & TIMER_ABSTIME) {
+      abs = timespec_totimeval(*req);
+      sys_gettimeofday_xnu(&now, 0, 0);
+      if (timeval_cmp(abs, now) > 0) {
+        rel = timeval_sub(abs, now);
+        res = sys_select(0, 0, 0, 0, &rel);
+      } else {
+        res = 0;
+      }
+    } else {
+      res = sys_nanosleep_xnu(req, rem);
+    }
   } else {
-    return sys_utimensat_nt(AT_FDCWD, path, NULL, 0);
+    res = enotsup();
   }
+  return res;
 }

libc/calls/clock_nanosleep.c

@@ -0,0 +1,130 @@
+/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│
+│vi: set net ft=c ts=2 sts=2 sw=2 fenc=utf-8                                :vi│
+╞══════════════════════════════════════════════════════════════════════════════╡
+│ Copyright 2022 Justine Alexandra Roberts Tunney                              │
+│                                                                              │
+│ Permission to use, copy, modify, and/or distribute this software for         │
+│ any purpose with or without fee is hereby granted, provided that the         │
+│ above copyright notice and this permission notice appear in all copies.      │
+│                                                                              │
+│ THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL                │
+│ WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED                │
+│ WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE             │
+│ AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL         │
+│ DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR        │
+│ PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER               │
+│ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
+│ PERFORMANCE OF THIS SOFTWARE.                                                │
+╚─────────────────────────────────────────────────────────────────────────────*/
+#include "libc/calls/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"
+#include "libc/calls/struct/timeval.h"
+#include "libc/calls/struct/timeval.internal.h"
+#include "libc/dce.h"
+#include "libc/errno.h"
+#include "libc/intrin/describeflags.internal.h"
+#include "libc/intrin/strace.internal.h"
+#include "libc/sysv/consts/clock.h"
+#include "libc/sysv/consts/timer.h"
+#include "libc/sysv/errfuns.h"
+#include "libc/thread/tls.h"
+
+/**
+ * Sleeps for particular amount of time.
+ *
+ * Here's how you could sleep for one second:
+ *
+ *     clock_nanosleep(0, 0, &(struct timespec){1}, 0);
+ *
+ * Your sleep will be interrupted automatically if you do something like
+ * press ctrl-c during the wait. That's an `EINTR` error and it lets you
+ * immediately react to status changes. This is always the case, even if
+ * you're using `SA_RESTART` since this is a `@norestart` system call.
+ *
+ *     void OnCtrlC(int sig) {} // EINTR only happens after delivery
+ *     signal(SIGINT, OnCtrlC); // do delivery rather than kill proc
+ *     printf("save me from sleeping forever by pressing ctrl-c\n");
+ *     clock_nanosleep(0, 0, &(struct timespec){INT_MAX}, 0);
+ *     printf("you're my hero\n");
+ *
+ * If you want to perform an uninterruptible sleep without having to use
+ * sigprocmask() to block all signals then this function provides a good
+ * solution to that problem. For example:
+ *
+ *     struct timespec rel, now, abs;
+ *     clock_gettime(CLOCK_REALTIME, &now);
+ *     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
+ * signal delivery and you're not losing precision on your wait timeout.
+ * This function has first-class support on Linux, FreeBSD, and NetBSD;
+ * on OpenBSD it's good; on XNU it's bad; and on Windows it's ugly.
+ *
+ * @param clock should be `CLOCK_REALTIME` and you may consult the docs
+ *     of your preferred platforms to see what other clocks might work
+ * @param flags can be 0 for relative and `TIMER_ABSTIME` for absolute
+ * @param req can be a relative or absolute time, depending on `flags`
+ * @param rem shall be updated with the remainder of unslept time when
+ *     (1) it's non-null; (2) `flags` is 0; and (3) -1 w/ `EINTR` is
+ *     returned; if this function returns 0 then `rem` is undefined;
+ *     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))))) {
+    rc = efault();
+  } else if (clock == 127 ||              //
+             (flags & ~TIMER_ABSTIME) ||  //
+             req->tv_sec < 0 ||           //
+             !(0 <= req->tv_nsec && req->tv_nsec <= 999999999)) {
+    rc = einval();
+  } else if (IsLinux() || IsFreebsd() || IsNetbsd()) {
+    rc = sys_clock_nanosleep(clock, flags, req, rem);
+  } else if (IsXnu()) {
+    rc = sys_clock_nanosleep_xnu(clock, flags, req, rem);
+  } else if (IsOpenbsd()) {
+    rc = sys_clock_nanosleep_openbsd(clock, flags, req, rem);
+  } else if (IsMetal()) {
+    rc = enosys();
+  } else {
+    rc = sys_clock_nanosleep_nt(clock, flags, req, rem);
+  }
+
+  if (rc == -1) {
+    rc = errno;
+    errno = e;
+  }
+
+  END_CANCELLATION_POINT;
+
+#if SYSDEBUG
+  if (__tls_enabled && !(__get_tls()->tib_flags & TIB_FLAG_TIME_CRITICAL)) {
+    STRACE("clock_nanosleep(%s, %s, %s, [%s]) → %s", DescribeClockName(clock),
+           DescribeSleepFlags(flags), DescribeTimespec(0, req),
+           DescribeTimespec(rc, rem), DescribeErrnoResult(rc));
+  }
+#endif
+
+  return 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"
@@ -32,17 +32,25 @@
 /**
  * Closes file descriptor.
  *
- * This function may be used for file descriptors returned by functions
- * like open, socket, accept, epoll_create, and landlock_create_ruleset.
+ * This function releases resources returned by functions such as:
  *
- * This function should never be called twice for the same file
- * descriptor, regardless of whether or not an error happened. However
- * that doesn't mean the error should be ignored.
+ * - openat()
+ * - socket()
+ * - accept()
+ * - epoll_create()
+ * - landlock_create_ruleset()
+ *
+ * This function should never be reattempted if an error is returned;
+ * however, that doesn't mean the error should be ignored. This goes
+ * against the conventional wisdom of looping on `EINTR`.
  *
  * @return 0 on success, or -1 w/ errno
- * @error EINTR means a signal was received while closing in which case
- *     close() does not need to be called again, since the fd will close
- *     in the background
+ * @raise EINTR if signal was delivered; do *not* retry
+ * @raise EBADF if `fd` is negative or not open; however, an exception
+ *     is made by Cosmopolitan Libc for `close(-1)` which returns zero
+ *     and does nothing, in order to assist with code that may wish to
+ *     close the same resource multiple times without dirtying `errno`
+ * @raise EIO if a low-level i/o error occurred
  * @asyncsignalsafe
  * @vforksafe
  */
@@ -51,7 +59,7 @@ int close(int fd) {
   if (fd == -1) {
     rc = 0;
   } else if (fd < 0) {
-    rc = einval();
+    rc = ebadf();
   } else {
     // for performance reasons we want to avoid holding __fds_lock()
     // while sys_close() is happening. this leaves the kernel / libc
@@ -73,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/close_range.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/errno.h"
-#include "libc/limits.h"
+#include "libc/dce.h"
+#include "libc/intrin/strace.internal.h"
+#include "libc/sysv/errfuns.h"
 
 /**
  * Closes inclusive range of file descriptors, e.g.
@@ -32,33 +32,27 @@
  *       }
  *     }
  *
- * This is supported on Linux 5.9+, FreeBSD, and OpenBSD. On FreeBSD,
- * `flags` must be zero. On OpenBSD, we call closefrom(int) so `last`
- * should be `-1` in order to get OpenBSD support, otherwise `ENOSYS`
- * will be returned. We also polyfill closefrom on FreeBSD since it's
- * available on older kernels.
+ * The following flags are available:
  *
- * On Linux, the following flags are supported:
+ * - `CLOSE_RANGE_UNSHARE` (Linux-only)
+ * - `CLOSE_RANGE_CLOEXEC` (Linux-only)
  *
- * - CLOSE_RANGE_UNSHARE
- * - CLOSE_RANGE_CLOEXEC
+ * This is only supported on Linux 5.9+ and FreeBSD 13+. Consider using
+ * closefrom() which will work on OpenBSD too.
  *
  * @return 0 on success, or -1 w/ errno
- * @error ENOSYS if not Linux 5.9+ / FreeBSD / OpenBSD
- * @error EBADF on OpenBSD if `first` is greater than highest fd
  * @error EINVAL if flags are bad or first is greater than last
  * @error EMFILE if a weird race condition happens on Linux
- * @error EINTR possibly on OpenBSD
+ * @error ENOSYS if not Linux 5.9+ or FreeBSD 13+
  * @error ENOMEM on Linux maybe
+ * @see closefrom()
  */
 int close_range(unsigned int first, unsigned int last, unsigned int flags) {
-  int rc, err;
-  err = errno;
-  if ((rc = sys_close_range(first, last, flags)) == -1) {
-    if (errno == ENOSYS && first <= INT_MAX && last == UINT_MAX && !flags) {
-      errno = err;
-      rc = sys_closefrom(first);
-    }
+  int rc;
+  if (IsLinux() || IsFreebsd()) {
+    rc = sys_close_range(first, last, flags);
+  } else {
+    rc = enosys();
   }
   STRACE("close_range(%d, %d, %#x) → %d% m", first, last, flags, rc);
   return rc;

libc/calls/closefrom.c

@@ -17,43 +17,45 @@
 │ 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/errno.h"
+#include "libc/intrin/strace.internal.h"
 #include "libc/limits.h"
 #include "libc/sysv/errfuns.h"
 
 /**
  * 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
- * @error ENOSYS if not Linux 5.9+ / FreeBSD / OpenBSD
- * @error EBADF on OpenBSD if `first` is greater than highest fd
- * @error EINVAL if flags are bad or first is greater than last
- * @error EMFILE if a weird race condition happens on Linux
- * @error EINTR possibly on OpenBSD
- * @error ENOMEM on Linux maybe
- * @note supported on Linux 5.9+, FreeBSD 8+, and OpenBSD
+ * @raise EBADF if `first` is negative
+ * @raise ENOSYS if not Linux 5.9+, FreeBSD 8+, OpenBSD, or NetBSD
+ * @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
  */
 int closefrom(int first) {
   int rc, err;
-  if (first >= 0) {
-    err = errno;
-    if ((rc = sys_close_range(first, -1, 0)) == -1) {
-      if (errno == ENOSYS) {
-        errno = err;
-        rc = sys_closefrom(first);
-      }
-    }
-  } else {
+  if (first < 0) {
+    // consistent with openbsd
+    // freebsd allows this but it's dangerous
+    // necessary on linux due to type signature
     rc = ebadf();
+  } else if (IsFreebsd() || IsOpenbsd()) {
+    rc = sys_closefrom(first);
+  } else if (IsLinux()) {
+    rc = sys_close_range(first, 0xffffffffu, 0);
+  } else if (IsNetbsd()) {
+    rc = __sys_fcntl(first, 10 /*F_CLOSEM*/, first);
+  } else {
+    rc = enosys();
   }
   STRACE("closefrom(%d) → %d% m", first, rc);
   return rc;

libc/calls/copy_file_range.c

@@ -0,0 +1,129 @@
+/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│
+│vi: set net ft=c ts=2 sts=2 sw=2 fenc=utf-8                                :vi│
+╞══════════════════════════════════════════════════════════════════════════════╡
+│ Copyright 2022 Justine Alexandra Roberts Tunney                              │
+│                                                                              │
+│ Permission to use, copy, modify, and/or distribute this software for         │
+│ any purpose with or without fee is hereby granted, provided that the         │
+│ above copyright notice and this permission notice appear in all copies.      │
+│                                                                              │
+│ THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL                │
+│ WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED                │
+│ WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE             │
+│ AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL         │
+│ DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR        │
+│ PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER               │
+│ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
+│ PERFORMANCE OF THIS SOFTWARE.                                                │
+╚─────────────────────────────────────────────────────────────────────────────*/
+#include "libc/calls/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"
+#include "libc/calls/syscall-sysv.internal.h"
+#include "libc/dce.h"
+#include "libc/errno.h"
+#include "libc/intrin/asan.internal.h"
+#include "libc/intrin/describeflags.internal.h"
+#include "libc/intrin/strace.internal.h"
+#include "libc/sysv/consts/sig.h"
+#include "libc/sysv/errfuns.h"
+#include "libc/thread/thread.h"
+
+static struct CopyFileRange {
+  pthread_once_t once;
+  bool ok;
+} g_copy_file_range;
+
+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().
+    // https://www.cygwin.com/bugzilla/show_bug.cgi?id=26338
+    ok = sys_close_range(-1, -2, 0) == -1 && errno == EINVAL;
+  } else if (IsFreebsd()) {
+    ok = sys_copy_file_range(-1, 0, -1, 0, 0, 0) == -1 && errno == EBADF;
+  } else {
+    ok = false;
+  }
+  ALLOW_CANCELLATIONS;
+  errno = e;
+  return ok;
+}
+
+static void copy_file_range_init(void) {
+  g_copy_file_range.ok = HasCopyFileRange();
+}
+
+/**
+ * Transfers data between files.
+ *
+ * If this system call is available (Linux c. 2018 or FreeBSD c. 2021)
+ * and the file system supports it (e.g. ext4) and the source and dest
+ * files are on the same file system, then this system call shall make
+ * copies go about 2x faster.
+ *
+ * This implementation requires Linux 5.9+ even though the system call
+ * was introduced in Linux 4.5. That's to ensure ENOSYS works reliably
+ * due to a faulty backport, that happened in RHEL7. FreeBSD detection
+ * on the other hand will work fine.
+ *
+ * @param infd is source file, which should be on same file system
+ * @param opt_in_out_inoffset may be specified for pread() behavior
+ * @param outfd should be a writable file, but not `O_APPEND`
+ * @param opt_in_out_outoffset may be specified for pwrite() behavior
+ * @param uptobytes is maximum number of bytes to transfer
+ * @param flags is reserved for future use and must be zero
+ * @return number of bytes transferred, or -1 w/ errno
+ * @raise EXDEV if source and destination are on different filesystems
+ * @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
+ * @raise ERANGE if overflow happens computing ranges
+ * @raise ENOSPC if file system has run out of space
+ * @raise ETXTBSY if source or dest is a swap file
+ * @raise EINTR if a signal was delivered instead
+ * @raise EISDIR if source or dest is a directory
+ * @raise ENOSYS if not Linux 5.9+ or FreeBSD 13+
+ * @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 &&
+                           !__asan_is_valid(opt_in_out_inoffset, 8)) ||
+                          (opt_in_out_outoffset &&
+                           !__asan_is_valid(opt_in_out_outoffset, 8)))) {
+    rc = efault();
+  } else if (__isfdkind(infd, kFdZip) || __isfdkind(outfd, kFdZip)) {
+    rc = enotsup();
+  } else {
+    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);
+  return rc;
+}

libc/calls/cp.c

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

@@ -21,20 +21,22 @@
 #include "libc/sysv/consts/o.h"
 
 /**
- * Creates new file, returning open()'d file descriptor.
+ * Creates file.
  *
- * This function is shorthand for:
+ * This is equivalent to saying:
  *
- *     open(file, O_CREAT | O_WRONLY | O_TRUNC, mode)
+ *     int fd = openat(AT_FDCWD, file, O_CREAT | O_WRONLY | O_TRUNC, mode);
  *
- * @param file is a UTF-8 string, which is truncated if it exists
- * @param mode is an octal user/group/other permission, e.g. 0755
- * @return a number registered with the system to track the open file,
- *     which must be stored using a 64-bit type in order to support both
- *     System V and Windows, and must be closed later on using close()
- * @see open(), touch()
+ * @param file specifies filesystem path to create
+ * @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
+ * @vforksafe
  */
-dontdiscard int creat(const char *file, uint32_t mode) {
+int creat(const char *file, uint32_t mode) {
   return openat(AT_FDCWD, file, O_CREAT | O_WRONLY | O_TRUNC, mode);
 }

libc/calls/dup-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/state.internal.h"
@@ -27,19 +28,14 @@
 #include "libc/sysv/consts/o.h"
 #include "libc/sysv/errfuns.h"
 
-/**
- * Implements dup(), dup2(), dup3(), and F_DUPFD for Windows.
- */
+// 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;
-
-  // validate the api usage
-  if (oldfd < 0) return ebadf();
-  if (flags & ~O_CLOEXEC) return einval();
+  _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();
@@ -47,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);
     }
   }
 
@@ -88,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/dup.c

@@ -18,10 +18,10 @@
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/calls/calls.h"
 #include "libc/calls/internal.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/sysv/errfuns.h"
 
 /**
@@ -32,15 +32,16 @@
  *
  * @param fd remains open afterwards
  * @return some arbitrary new number for fd
- * @raise EOPNOTSUPP if zipos file
- * @raise EBADF if fd isn't open
+ * @raise EPERM if pledge() is in play without stdio
+ * @raise ENOTSUP if `fd` is a zip file descriptor
+ * @raise EBADF if `fd` is negative or not open
  * @asyncsignalsafe
  * @vforksafe
  */
 int dup(int fd) {
   int rc;
   if (__isfdkind(fd, kFdZip)) {
-    rc = eopnotsupp();
+    rc = enotsup();
   } else if (!IsWindows()) {
     rc = sys_dup(fd);
   } else {

libc/calls/dup2.c

@@ -18,10 +18,10 @@
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/calls/calls.h"
 #include "libc/calls/internal.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/sysv/errfuns.h"
 
 /**
@@ -38,16 +38,19 @@
  * @param newfd if already assigned, is silently closed beforehand;
  *     unless it's equal to oldfd, in which case dup2() is a no-op
  * @return new file descriptor, or -1 w/ errno
- * @raise EBADF is oldfd isn't open
- * @raise EBADF is newfd negative or too big
+ * @raise EPERM if pledge() is in play without stdio
+ * @raise EMFILE if `RLIMIT_NOFILE` has been reached
+ * @raise ENOTSUP if `oldfd` is on zip file system
  * @raise EINTR if a signal handler was called
+ * @raise EBADF is `newfd` negative or too big
+ * @raise EBADF is `oldfd` isn't open
  * @asyncsignalsafe
  * @vforksafe
  */
 int dup2(int oldfd, int newfd) {
   int rc;
   if (__isfdkind(oldfd, kFdZip)) {
-    rc = eopnotsupp();
+    rc = enotsup();
   } else if (!IsWindows()) {
     rc = sys_dup2(oldfd, newfd);
   } else if (newfd < 0) {

libc/calls/dup3-sysv.c

@@ -16,41 +16,52 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/intrin/strace.internal.h"
+#include "libc/assert.h"
 #include "libc/calls/syscall-sysv.internal.h"
 #include "libc/calls/syscall_support-sysv.internal.h"
 #include "libc/dce.h"
 #include "libc/errno.h"
+#include "libc/intrin/strace.internal.h"
 #include "libc/sysv/consts/o.h"
 #include "libc/sysv/errfuns.h"
+#include "libc/thread/thread.h"
 
 #define F_DUP2FD         10
 #define F_DUP2FD_CLOEXEC 18
 
-int32_t sys_dup3(int32_t oldfd, int32_t newfd, int flags) {
-  static bool once;
-  static bool demodernize;
-  int olderr, how, fd;
-  if (!once) {
-    olderr = errno;
-    fd = __sys_dup3(oldfd, newfd, flags);
-    if (fd == -1 && errno == ENOSYS) {
-      STRACE("demodernizing %s() due to %s", "dup3", "RHEL5:CVE-2010-3301");
-      demodernize = true;
-      once = true;
-      errno = olderr;
-    } else {
-      once = true;
-      return fd;
-    }
-  } else if (!demodernize) {
-    return __sys_dup3(oldfd, newfd, flags);
+static struct Dup3 {
+  pthread_once_t once;
+  bool demodernize;
+} g_dup3;
+
+static void sys_dup3_test(void) {
+  int e = errno;
+  __sys_dup3(-1, -1, 0);
+  if ((g_dup3.demodernize = errno == ENOSYS)) {
+    STRACE("demodernizing %s() due to %s", "dup3", "ENOSYS");
   }
-  if (oldfd == newfd) return einval();
-  if (flags & ~O_CLOEXEC) return einval();
+  errno = e;
+}
+
+int32_t sys_dup3(int32_t oldfd, int32_t newfd, int flags) {
+  int how;
+  _unassert(oldfd >= 0);
+  _unassert(newfd >= 0);
+  _unassert(!(flags & ~O_CLOEXEC));
+
   if (IsFreebsd()) {
-    how = flags & O_CLOEXEC ? F_DUP2FD_CLOEXEC : F_DUP2FD;
+    if (flags & O_CLOEXEC) {
+      how = F_DUP2FD_CLOEXEC;
+    } else {
+      how = F_DUP2FD;
+    }
     return __sys_fcntl(oldfd, how, newfd);
+  }
+
+  pthread_once(&g_dup3.once, sys_dup3_test);
+
+  if (!g_dup3.demodernize) {
+    return __sys_dup3(oldfd, newfd, flags);
   } else {
     return __fixupnewfd(sys_dup2(oldfd, newfd), flags);
   }

libc/calls/dup3.c

@@ -18,10 +18,11 @@
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/calls/calls.h"
 #include "libc/calls/internal.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/sysv/consts/o.h"
 #include "libc/sysv/errfuns.h"
 
 /**
@@ -37,23 +38,25 @@
  * @param flags may have O_CLOEXEC which is needed to preserve the
  *     close-on-execve() state after file descriptor duplication
  * @return newfd on success, or -1 w/ errno
- * @raise EINVAL if flags has unsupported bits
- * @raise EINVAL if newfd equals oldfd
- * @raise EBADF is oldfd isn't open
- * @raise EBADF is newfd negative or too big
+ * @raise ENOTSUP if `oldfd` is a zip file descriptor
+ * @raise EPERM if pledge() is in play without stdio
+ * @raise EINVAL if `flags` has unsupported bits
  * @raise EINTR if a signal handler was called
+ * @raise EBADF is `newfd` negative or too big
+ * @raise EINVAL if `newfd` equals oldfd
+ * @raise EBADF is `oldfd` isn't open
  * @see dup(), dup2()
  */
 int dup3(int oldfd, int newfd, int flags) {
   int rc;
-  if (__isfdkind(oldfd, kFdZip)) {
-    rc = eopnotsupp();
-  } else if (oldfd == newfd) {
-    rc = einval();
+  if (oldfd == newfd || (flags & ~O_CLOEXEC)) {
+    rc = einval();  // NetBSD doesn't do this
+  } else if (oldfd < 0 || newfd < 0) {
+    rc = ebadf();
+  } else if (__isfdkind(oldfd, kFdZip)) {
+    rc = enotsup();
   } else if (!IsWindows()) {
     rc = sys_dup3(oldfd, newfd, flags);
-  } else if (newfd < 0) {
-    rc = ebadf();
   } else {
     rc = sys_dup_nt(oldfd, newfd, flags, -1);
   }

libc/calls/execve-nt.greg.c

@@ -99,7 +99,7 @@ textwindows int sys_execve_nt(const char *program, char *const argv[],
   startinfo.hStdError = __getfdhandleactual(2);
 
   // spawn the process
-  rc = ntspawn(program, argv, envp, 0, 0, 0, 1, 0, 0, &startinfo, &procinfo);
+  rc = ntspawn(program, argv, envp, 0, 0, 0, true, 0, 0, &startinfo, &procinfo);
   if (rc == -1) {
     STRACE("panic: unrecoverable ntspawn(%#s) error: %m", program);
     __imp_ExitProcess(6543);

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

@@ -17,6 +17,7 @@
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/calls/calls.h"
+#include "libc/calls/internal.h"
 #include "libc/calls/syscall-nt.internal.h"
 #include "libc/calls/syscall-sysv.internal.h"
 #include "libc/dce.h"
@@ -35,33 +36,42 @@
  * @param dirfd is normally AT_FDCWD but if it's an open directory and
  *     file is a relative path, then file is opened relative to dirfd
  * @param path is a filename or directory
- * @param mode can be R_OK, W_OK, X_OK, F_OK
- * @param flags can have AT_EACCESS, AT_SYMLINK_NOFOLLOW
- * @note on Linux flags is only supported on Linux 5.8+
+ * @param amode can be `R_OK`, `W_OK`, `X_OK`, or `F_OK`
+ * @param flags can have `AT_EACCESS` and/or `AT_SYMLINK_NOFOLLOW`
  * @return 0 if ok, or -1 and sets errno
+ * @raise EINVAL if `mode` has bad value
+ * @raise EPERM if pledge() is in play without rpath promise
+ * @raise EACCES if access for requested `mode` would be denied
+ * @raise ENOTDIR if a directory component in `path` exists as non-directory
+ * @raise ENOENT if component of `path` doesn't exist or `path` is empty
+ * @raise ENOTSUP if `path` is a zip file and `dirfd` isn't `AT_FDCWD`
+ * @note on Linux `flags` is only supported on Linux 5.8+
  * @asyncsignalsafe
  */
-int faccessat(int dirfd, const char *path, int mode, uint32_t flags) {
+int faccessat(int dirfd, const char *path, int amode, int flags) {
   int e, rc;
-  if (IsAsan() && !__asan_is_valid(path, 1)) {
+  struct ZiposUri zipname;
+  if (!path || (IsAsan() && !__asan_is_valid_str(path))) {
     rc = efault();
-  } else if (_weaken(__zipos_notat) &&
-             _weaken(__zipos_notat)(dirfd, path) == -1) {
-    rc = -1; /* TODO(jart): implement me */
+  } else if (__isfdkind(dirfd, kFdZip)) {
+    rc = enotsup();
+  } else if (_weaken(__zipos_open) &&
+             _weaken(__zipos_parseuri)(path, &zipname) != -1) {
+    rc = _weaken(__zipos_access)(&zipname, amode);
   } else if (!IsWindows()) {
     e = errno;
     if (!flags) goto NoFlags;
-    if ((rc = sys_faccessat2(dirfd, path, mode, flags)) == -1) {
+    if ((rc = sys_faccessat2(dirfd, path, amode, flags)) == -1) {
       if (errno == ENOSYS) {
         errno = e;
       NoFlags:
-        rc = sys_faccessat(dirfd, path, mode, flags);
+        rc = sys_faccessat(dirfd, path, amode, flags);
       }
     }
   } else {
-    rc = sys_faccessat_nt(dirfd, path, mode, flags);
+    rc = sys_faccessat_nt(dirfd, path, amode, flags);
   }
   STRACE("faccessat(%s, %#s, %#o, %#x) → %d% m", DescribeDirfd(dirfd), path,
-         mode, flags, rc);
+         amode, flags, rc);
   return rc;
 }

libc/calls/fadvise-nt.c

@@ -21,6 +21,7 @@
 #include "libc/calls/syscall_support-nt.internal.h"
 #include "libc/nt/createfile.h"
 #include "libc/nt/enum/fileflagandattributes.h"
+#include "libc/nt/enum/filetype.h"
 #include "libc/nt/files.h"
 #include "libc/nt/runtime.h"
 #include "libc/sysv/consts/madv.h"
@@ -33,6 +34,7 @@ textwindows int sys_fadvise_nt(int fd, uint64_t offset, uint64_t len,
   int rc, flags, mode;
   uint32_t perm, share, attr;
 
+  if ((int64_t)len < 0) return einval();
   if (!__isfdkind(fd, kFdFile)) return ebadf();
   h1 = g_fds.p[fd].handle;
   mode = g_fds.p[fd].mode;
@@ -57,6 +59,10 @@ textwindows int sys_fadvise_nt(int fd, uint64_t offset, uint64_t len,
     return -1;
   }
 
+  if (GetFileType(h1) == kNtFileTypePipe) {
+    return espipe();
+  }
+
   // MSDN says only these are allowed, otherwise it returns EINVAL.
   attr &= kNtFileFlagBackupSemantics | kNtFileFlagDeleteOnClose |
           kNtFileFlagNoBuffering | kNtFileFlagOpenNoRecall |

libc/calls/fadvise.c

@@ -16,11 +16,17 @@
 │ 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/intrin/strace.internal.h"
 #include "libc/calls/syscall-nt.internal.h"
 #include "libc/calls/syscall-sysv.internal.h"
 #include "libc/dce.h"
+#include "libc/errno.h"
+#include "libc/intrin/strace.internal.h"
+#include "libc/str/str.h"
+#include "libc/sysv/errfuns.h"
+
+int sys_fadvise_netbsd(int, int, int64_t, int64_t, int) asm("sys_fadvise");
 
 /**
  * Drops hints to O/S about intended I/O behavior.
@@ -28,16 +34,33 @@
  * It makes a huge difference. For example, when copying a large file,
  * it can stop the system from persisting GBs of useless memory content.
  *
- * @param len 0 means ‘til end of file
+ * @param len 0 means until end of file
  * @param advice can be MADV_SEQUENTIAL, MADV_RANDOM, etc.
- * @return -1 on error
+ * @return 0 on success, or -1 w/ errno
+ * @raise EBADF if `fd` isn't a valid file descriptor
+ * @raise ESPIPE if `fd` refers to a pipe
+ * @raise EINVAL if `advice` was invalid
+ * @raise ENOSYS on XNU and OpenBSD
  */
 int fadvise(int fd, uint64_t offset, uint64_t len, int advice) {
-  int rc;
-  if (!IsWindows()) {
-    rc = sys_fadvise(fd, offset, len, advice); /* linux & freebsd */
-  } else {
+  int rc, e = errno;
+  if (IsLinux()) {
+    rc = sys_fadvise(fd, offset, len, advice);
+  } else if (IsFreebsd() || IsNetbsd()) {
+    if (IsFreebsd()) {
+      rc = sys_fadvise(fd, offset, len, advice);
+    } else {
+      rc = sys_fadvise_netbsd(fd, offset, offset, len, advice);
+    }
+    _npassert(rc >= 0);
+    if (rc) {
+      errno = rc;
+      rc = -1;
+    }
+  } else if (IsWindows()) {
     rc = sys_fadvise_nt(fd, offset, len, advice);
+  } else {
+    rc = enosys();
   }
   STRACE("fadvise(%d, %'lu, %'lu, %d) → %d% m", fd, offset, len, advice, rc);
   return rc;

libc/calls/fchdir-nt.c

@@ -23,20 +23,12 @@
 #include "libc/nt/files.h"
 #include "libc/sysv/errfuns.h"
 
+int sys_chdir_nt_impl(char16_t[hasatleast PATH_MAX], uint32_t);
+
 textwindows int sys_fchdir_nt(int dirfd) {
-  uint32_t len;
   char16_t dir[PATH_MAX];
   if (!__isfdkind(dirfd, kFdFile)) return ebadf();
-  len = GetFinalPathNameByHandle(g_fds.p[dirfd].handle, dir, ARRAYLEN(dir),
-                                 kNtFileNameNormalized | kNtVolumeNameDos);
-  if (len + 1 + 1 > ARRAYLEN(dir)) return enametoolong();
-  if (dir[len - 1] != u'\\') {
-    dir[len + 0] = u'\\';
-    dir[len + 1] = u'\0';
-  }
-  if (SetCurrentDirectory(dir)) {
-    return 0;
-  } else {
-    return __winerr();
-  }
+  return sys_chdir_nt_impl(
+      dir, GetFinalPathNameByHandle(g_fds.p[dirfd].handle, dir, ARRAYLEN(dir),
+                                    kNtFileNameNormalized | kNtVolumeNameDos));
 }

libc/calls/fchmodat.c

@@ -37,17 +37,18 @@
  * @param path must exist
  * @param mode contains octal flags (base 8)
  * @param flags can have `AT_SYMLINK_NOFOLLOW`
+ * @raise ENOTSUP if `dirfd` or `path` use zip file system
  * @errors ENOENT, ENOTDIR, ENOSYS
  * @asyncsignalsafe
  * @see fchmod()
  */
 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) {
-    rc = eopnotsupp();
+    rc = enotsup();
   } else if (!IsWindows()) {
     rc = sys_fchmodat(dirfd, path, mode, flags);
   } else {

libc/calls/fchownat.c

@@ -34,6 +34,7 @@
  * @param gid is group id, or -1 to not change
  * @param flags can have AT_SYMLINK_NOFOLLOW, etc.
  * @return 0 on success, or -1 w/ errno
+ * @raise ENOTSUP if `dirfd` or `path` use zip file system
  * @see chown(), lchown() for shorthand notation
  * @see /etc/passwd for user ids
  * @see /etc/group for group ids
@@ -42,11 +43,11 @@
 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) {
-    STRACE("zipos fchownat not supported yet");
+    rc = enotsup();
   } else {
     rc = sys_fchownat(dirfd, path, uid, gid, flags);
   }

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,72 +25,131 @@
 #include "libc/calls/syscall_support-nt.internal.h"
 #include "libc/calls/wincrash.internal.h"
 #include "libc/errno.h"
-#include "libc/intrin/cmpxchg.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/createfile.h"
-#include "libc/nt/enum/accessmask.h"
-#include "libc/nt/enum/fileflagandattributes.h"
 #include "libc/nt/enum/filelockflags.h"
-#include "libc/nt/enum/filesharemode.h"
-#include "libc/nt/enum/formatmessageflags.h"
 #include "libc/nt/errors.h"
 #include "libc/nt/files.h"
-#include "libc/nt/process.h"
 #include "libc/nt/runtime.h"
 #include "libc/nt/struct/byhandlefileinformation.h"
 #include "libc/nt/struct/overlapped.h"
-#include "libc/nt/synchronization.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"
 
-bool __force_sqlite_to_work_until_we_can_fix_it;
+struct FileLock {
+  struct FileLock *next;
+  int64_t off;
+  int64_t len;
+  int fd;
+  bool exc;
+};
 
-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 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();
   }
 
@@ -98,88 +158,193 @@ 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) {
       flags |= kNtLockfileExclusiveLock;
     }
-    e = errno;
     ok = LockFileEx(f->handle, flags, 0, len, len >> 32, &ov);
     if (cmd == F_GETLK) {
       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;
     }
-    if (ok) {
-      return 0;
-    } else if (__force_sqlite_to_work_until_we_can_fix_it) {
-      errno = e;
-      return 0;
-    } else {
-      return -1;
-    }
+    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,17 +17,22 @@
 │ 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"
 #include "libc/calls/syscall-nt.internal.h"
 #include "libc/calls/syscall-sysv.internal.h"
 #include "libc/dce.h"
+#include "libc/intrin/describeflags.internal.h"
 #include "libc/intrin/strace.internal.h"
 #include "libc/intrin/weaken.h"
+#include "libc/sysv/consts/f.h"
 #include "libc/sysv/errfuns.h"
 #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));
  *
@@ -37,18 +42,60 @@
  *     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, e.g.
+ * 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.
  *
- *     CHECK_NE(-1, fcntl(zfd, F_SETLKW, &(struct flock){F_WRLCK}));
- *     // ...
- *     CHECK_NE(-1, fcntl(zfd, F_SETLK, &(struct flock){F_UNLCK}));
+ * 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`.
  *
- * Please be warned that locks currently do nothing on Windows since
- * figuring out how to polyfill them correctly is a work in progress.
- *
- * @param cmd can be F_{GET,SET}{FD,FL}, etc.
+ * @param fd is the file descriptor
+ * @param cmd can be one of:
+ *     - `F_GETFD` gets `FD_CLOEXEC` status of `fd
+ *     - `F_SETFD` sets `FD_CLOEXEC` status of `arg` file descriptor
+ *     - `F_GETFL` returns file descriptor status flags
+ *     - `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 for lock (SQLite avoids this)
+ *     - `F_GETLK` to retrieve information about a record lock
+ *     - `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`
+ *     - `F_GETNOSIGPIPE` on MacOS and NetBSD to control `SIGPIPE`
+ *     - `F_GETPATH` on MacOS and NetBSD where arg is `char[PATH_MAX]`
+ *     - `F_MAXFD` on NetBSD to get max open file descriptor
+ *     - `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` (Linux only)
+ *       - `DN_ACCESS` for file access
+ *       - `DN_MODIFY` for file modifications
+ *       - `DN_CREATE` for file creations
+ *       - `DN_DELETE` for file deletions
+ *       - `DN_RENAME` for file renames
+ *       - `DN_ATTRIB` for file attribute changes
+ *       - `DN_MULTISHOT` bitwise or for realtime signals (non-coalesced)
  * @param arg can be FD_CLOEXEC, etc. depending
  * @return 0 on success, or -1 w/ errno
+ * @raise EBADF if `fd` isn't a valid open file descriptor
+ * @raise EINVAL if `cmd` is unknown or unsupported by os
+ * @raise EINVAL if `cmd` is invalid or unsupported by os
+ * @raise EPERM if pledge() is in play w/o `stdio` or `flock` promise
+ * @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
  */
@@ -56,20 +103,64 @@ int fcntl(int fd, int cmd, ...) {
   int rc;
   va_list va;
   uintptr_t arg;
+
   va_start(va, cmd);
   arg = va_arg(va, uintptr_t);
   va_end(va);
+
   if (fd >= 0) {
-    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 >= 0) {
+      if (fd < g_fds.n && g_fds.p[fd].kind == kFdZip) {
+        rc = _weaken(__zipos_fcntl)(fd, cmd, arg);
+      } else if (!IsWindows()) {
+        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);
+      }
     } else {
-      rc = sys_fcntl_nt(fd, cmd, arg);
+      rc = einval();
     }
   } else {
-    rc = einval();
+    rc = ebadf();
   }
-  STRACE("fcntl(%d, %d, %p) → %#x% m", fd, cmd, arg, rc);
+
+#ifdef SYSDEBUG
+  if (cmd == F_GETFD ||         //
+      cmd == F_GETOWN ||        //
+      cmd == F_FULLFSYNC ||     //
+      cmd == F_BARRIERFSYNC ||  //
+      cmd == F_MAXFD) {
+    STRACE("fcntl(%d, %s) → %d% m", fd, DescribeFcntlCmd(cmd), rc);
+  } else if (cmd == F_GETFL) {
+    STRACE("fcntl(%d, %s) → %s% m", fd, DescribeFcntlCmd(cmd),
+           DescribeOpenFlags(rc));
+  } else if (cmd == F_SETLK ||                       //
+             cmd == F_SETLKW ||                      //
+             cmd == F_GETLK ||                       //
+             ((SupportsLinux() || SupportsXnu()) &&  //
+              cmd != -1 &&                           //
+              (cmd == F_OFD_SETLK ||                 //
+               cmd == F_OFD_SETLKW ||                //
+               cmd == F_OFD_GETLK))) {
+    STRACE("fcntl(%d, %s, %s) → %d% m", fd, DescribeFcntlCmd(cmd),
+           DescribeFlock(cmd, (struct flock *)arg), rc);
+  } else if ((SupportsNetbsd() || SupportsXnu()) && cmd != -1 &&
+             cmd == F_GETPATH) {
+    STRACE("fcntl(%d, %s, [%s]) → %d% m", fd, DescribeFcntlCmd(cmd),
+           !rc ? (const char *)arg : "n/a", rc);
+  } else if (SupportsLinux() && cmd != -1 && cmd == F_NOTIFY) {
+    STRACE("fcntl(%d, %s, %s) → %d% m", fd, DescribeFcntlCmd(cmd),
+           DescribeDnotifyFlags(arg), rc);
+  } else {
+    STRACE("fcntl(%d, %s, %ld) → %#x% m", fd, DescribeFcntlCmd(cmd), arg, rc);
+  }
+#endif
+
   return rc;
 }

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,10 +17,12 @@
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/calls/calls.h"
-#include "libc/intrin/strace.internal.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"
 #include "libc/dce.h"
+#include "libc/intrin/strace.internal.h"
 #include "libc/runtime/runtime.h"
 
 /**
@@ -29,20 +31,26 @@
  * @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 = 0;
-    STRACE("fdatasync(%d) → disabled% m", fd);
+    rc = fstat(fd, &st);
+    STRACE("fdatasync_fake(%d) → %d% m", fd, rc);
   }
   return rc;
 }