hare

syscalls.ha (29142B)

---

 // SPDX-License-Identifier: MPL-2.0
 // (c) Hare authors <https://harelang.org>
 
 let pathbuf: [PATH_MAX]u8 = [0...];
 
 // For functions that need more than one path, i.e. unveil, linkat, renameat, etc.
 let pathbuf1: [PATH_MAX]u8 = [0...];
 
 export type path = (str | []u8 | *const u8);
 
 fn copy_cpath(path: path, buf: []u8) (*const u8 | errno) = {
 	let path = match (path) {
 	case let c: *const u8 =>
 		return c;
 	case let s: str =>
 		let ptr = &s: *struct {
 			buf: *[*]u8,
 			length: size,
 			capacity: size,
 		};
 		yield ptr.buf[..ptr.length];
 	case let b: []u8 =>
 		yield b;
 	};
 	if (len(path) + 1 >= len(buf)) {
 		return ENAMETOOLONG;
 	};
 	memcpy(buf: *[*]u8, path: *[*]u8, len(path));
 	buf[len(path)] = 0;
 	return buf: *[*]u8: *const u8;
 };
 
 // NUL terminates a string and stores it in a static buffer of PATH_MAX bytes in
 // length.
 fn cpath(path: path) (*const u8 | errno) = {
 	return copy_cpath(path, pathbuf);
 };
 
 // /usr/include/errno.h: #define errno (*__errno())
 @symbol("__errno") fn __errno() *int;
 
 // exit
 export @symbol("exit") fn exit(status: int) never;
 
 // fork
 
 @symbol("fork") fn libc_fork() int;
 
 export fn fork() (int | void | errno) = {
 	let res = libc_fork();
 	if (res == -1) {
 		return *__errno(): errno;
 	};
 	if (res == 0) {
 		return;
 	};
 	return res;
 };
 
 // read
 
 @symbol("read") fn libc_read(d: int, buf: *opaque, nbytes: size) size;
 
 export fn read(fd: int, buf: *opaque, count: size) (size | errno) = {
 	let res: u64 = libc_read(fd, buf, count);
 	if (res == -1) {
 		return *__errno(): errno;
 	};
 	return res;
 };
 
 // write
 
 @symbol("write") fn libc_write(d: int, buf: *const opaque, nbytes: size) size;
 
 export fn write(fd: int, buf: *const opaque, count: size) (size | errno) = {
 	let res: u64 = libc_write(fd, buf, count);
 	if (res == -1) {
 		return *__errno(): errno;
 	};
 	return res;
 };
 
 // open
 
 @symbol("open") fn libc_open(path: *opaque, flags: int, mode: int) int;
 
 export fn open(path: path, flags: int, mode: int) (int | errno) = {
 	let res = libc_open(cpath(path)?, flags, mode);
 	if (res == -1) {
 		return *__errno(): errno;
 	};
 	return res;
 };
 
 // posix_openpt (libc function not a syscall)
 
 @symbol("posix_openpt") fn libc_openpt(oflag: int) int;
 
 export fn posix_openpt(flags: int) (int | errno) = {
 	let res = libc_openpt(flags);
 	if (res == -1) {
 		return *__errno(): errno;
 	};
 	return res;
 };
 
 // close
 
 @symbol("close") fn libc_close(d: int) int;
 
 export fn close(fd: int) (void | errno) = {
 	let res = libc_close(fd);
 	if (res == -1) {
 		return *__errno(): errno;
 	};
 };
 
 // getentropy
 // __tfork
 // link
 // unlink
 // wait4
 
 @symbol("wait4") fn libc_wait4(
 	wpid: pid_t,
 	status: nullable *int,
 	options: int,
 	rusage: nullable *rusage
 ) pid_t;
 
 export fn wait4(
 	pid: pid_t,
 	wstatus: nullable *int,
 	options: int,
 	rusage: nullable *rusage,
 ) (pid_t | errno) = {
 	let res = libc_wait4(pid, wstatus, options, rusage);
 	if (res == -1) {
 		return *__errno(): errno;
 	};
 	return res;
 };
 
 // chdir
 
 @symbol("chdir") fn libc_chdir(path: *const u8) int;
 
 export fn chdir(path: path) (void | errno) = {
 	let res = libc_chdir(cpath(path)?);
 
 	if (res == -1)  {
 		return *__errno(): errno;
 	};
 };
 
 // fchdir
 
 @symbol("fchdir") fn libc_fchdir(fd: int) int;
 
 export fn fchdir(fd: int) (void | errno) = {
 	let res = libc_fchdir(fd);
 
 	if (res == -1)  {
 		return *__errno(): errno;
 	};
 };
 
 // mknod
 // chmod
 // chown
 // obreak
 // getdtablecount
 // getrusage
 // getpid
 
 export @symbol("getpid") fn getpid() pid_t;
 
 // mount
 // unmount
 // setuid
 
 @symbol("setuid") fn libc_setuid(uid: uid_t) int;
 
 export fn setuid(uid: uid_t) (void | errno) = {
 	let res = libc_setuid(uid);
 	if (res == -1) {
 		return *__errno(): errno;
 	};
 };
 
 // getuid
 
 export @symbol("getuid") fn getuid() uid_t;
 
 // geteuid
 
 export @symbol("geteuid") fn geteuid() uid_t;
 
 // ptrace
 // recvmsg
 
 @symbol("recvmsg") fn libc_recvmsg(s: int, msg: *const msghdr, flags: int) i64;
 
 export fn recvmsg(fd: int, msg: *const msghdr, flags: int) (int | errno) = {
 	let res = libc_recvmsg(fd, msg, flags);
 	if (res == -1) {
 		return *__errno(): errno;
 	};
 	// TODO: could overflow
 	return res: int;
 };
 
 // sendmsg
 
 @symbol("sendmsg") fn libc_sendmsg(s: int, msg: *const msghdr, flags: int) i64;
 
 export fn sendmsg(fd: int, msg: *const msghdr, flags: int) (int | errno) = {
 	let res = libc_sendmsg(fd, msg, flags);
 	if (res == -1) {
 		return *__errno(): errno;
 	};
 	// TODO: could overflow
 	return res: int;
 };
 
 // recvfrom
 
 @symbol("recvfrom") fn libc_recvfrom(
 	s: int,
 	buf: *opaque,
 	length: size,
 	flags: int,
 	from: nullable *sockaddr,
 	fromlen: nullable *u32,
 ) i64;
 
 export fn recvfrom(
 	sockfd: int,
 	buf: *opaque,
 	length: size,
 	flags: int,
 	from: nullable *sockaddr,
 	fromlen: nullable *u32
 ) (size | errno) = {
 	let res = libc_recvfrom(sockfd, buf, length, flags, from, fromlen);
 	if (res == -1) {
 		return *__errno(): errno;
 	};
 	return res: size;
 };
 
 // accept
 // getpeername
 
 @symbol("getpeername") fn libc_getpeername(
 	s: int,
 	name: *sockaddr,
 	namelen: *u32
 ) int;
 
 export fn getpeername(
 	sockfd: int,
 	addr: *sockaddr,
 	addrlen: *u32
 ) (void | errno) = {
 	let res = libc_getpeername(sockfd, addr, addrlen);
 	if (res == -1) {
 		return *__errno(): errno;
 	};
 };
 
 // getsockname
 
 @symbol("getsockname") fn libc_getsockname(
 	sockfd: int,
 	addr: nullable *sockaddr,
 	addrlen: nullable *u32
 ) int;
 
 export fn getsockname(
 	sockfd: int,
 	addr: nullable *sockaddr,
 	addrlen: nullable *u32
 ) (void | errno) = {
 	let res = libc_getsockname(sockfd, addr, addrlen);
 	if (res == -1) {
 		return *__errno(): errno;
 	};
 
 };
 // access
 
 @symbol("access") fn libc_access(path: *const u8, amode: int) int;
 
 export fn access(path: path, amode: int) (bool | errno) = {
 	let res = libc_access(cpath(path)?, amode);
 	if (res == -1) {
 		let err = *__errno(): errno;
 
 		switch (res) {
 		case EACCES =>
 			return false;
 		case =>
 			return err;
 		};
 	};
 
 	return true;
 };
 
 
 // chflags
 // fchflags
 // sync
 // msyscall
 // stat
 
 // getppid
 
 export @symbol("getppid") fn getppid() pid_t;
 
 // lstat
 // dup
 // fstatat
 
 @symbol("fstatat") fn libc_fstatat(fd: int, path: *const u8, sb: *stat, flag: int) int;
 
 export fn fstatat(
 	dirfd: int,
 	path: path,
 	stat: *stat,
 	flag: int
 ) (void | errno) = {
 	let res = libc_fstatat(dirfd, cpath(path)?, stat, flag);
 	if (res == -1) {
 		return *__errno(): errno;
 	};
 };
 
 
 // getegid
 
 export @symbol("getegid") fn getegid() gid_t;
 
 // profil
 // ktrace
 // sigaction
 // sigaltstack
 
 export @symbol("sigaction") fn libc_sigaction(
 	sig: int,
 	act: *const sigact,
 	oact: nullable *sigact
 ) int;
 
 export fn sigaction(
 	signum: int,
 	act: *const sigact,
 	old: nullable *sigact,
 ) (void | errno) = {
 	let res = libc_sigaction(signum, act, old);
 	if (res == -1) {
 		return *__errno(): errno;
 	};
 };
 
 export @symbol("sigaltstack") fn libc_sigaltstack(
 	ss: const nullable *stack_t, oss: nullable *stack_t,
 ) int;
 
 export fn sigaltstack(
 	ss: const nullable *stack_t,
 	oss: nullable *stack_t,
 ) (void | errno) = {
 	let res = libc_sigaltstack(ss, oss);
 	if (res == -1) {
 		return *__errno(): errno;
 	};
 };
 // getgid
 
 export @symbol("getgid") fn getgid() gid_t;
 
 // sigprocmask
 
 @symbol("sigprocmask") fn libc_sigprocmask(
 	how: int,
 	set: nullable *const sigset,
 	old: nullable *sigset
 ) int;
 
 export fn sigprocmask(
 	how: int,
 	set: nullable *const sigset,
 	old: nullable *sigset
 ) (void | errno) = {
 	let res = libc_sigprocmask(how, set, old);
 	if (res == -1) {
 		return *__errno(): errno;
 	};
 };
 
 // mmap
 
 @symbol("mmap") fn libc_mmap(
 	addr: nullable *opaque,
 	len_: size,
 	prot: int,
 	flags: int,
 	fd: int,
 	pos: i64
 ) nullable *opaque;
 
 export fn mmap(
 	addr: nullable *opaque,
 	len_: size,
 	prot: int,
 	flags: int,
 	fd: int,
 	pos: i64
 ) (*opaque | errno) = {
 	let res = libc_mmap(addr, len_, prot, flags, fd, pos);
 
 	if (res == null) {
 		return *__errno(): errno;
 	};
 	return res: *opaque;
 };
 
 // setlogin
 // acct
 // sigpending
 // fstat
 // ioctl
 
 @symbol("ioctl") fn libc_ioctl(fd: int, req: u64, arg: u64) int;
 
 export type ioctl_arg = (nullable *opaque | u64);
 
 export fn ioctl(fd: int, req: u64, arg: ioctl_arg) (int | errno) = {
 	let res = match (arg) {
 	case let u: u64 =>
 		yield libc_ioctl(fd, req, u);
 	case let ptr: nullable *opaque =>
 		yield libc_ioctl(fd, req, ptr: uintptr: u64);
 	};
 	if (res == -1) {
 		return *__errno(): errno;
 	};
 	return res;
 };
 
 // reboot
 // revoke
 // symlink
 // readlink
 // execve
 
 @symbol("execve") fn libc_execve(path: *const u8, argv: *[*]nullable *const u8,
 		envp: *[*]nullable *const u8) int;
 
 export fn execve(path: path, argv: *[*]nullable *const u8,
 		envp: *[*]nullable *const u8) errno = {
 	let res = libc_execve(cpath(path)?, argv, envp);
 	return *__errno(): errno;
 };
 
 // umask
 
 @symbol("umask") fn libc_umask(numask: mode_t) mode_t;
 
 export fn umask(mode: mode_t) (mode_t | errno) = {
 	// Always successful on OpenBSD.
 	return libc_umask(mode);
 };
 
 // chroot
 
 @symbol("chroot") fn libc_chroot(dirname: *const u8) int;
 
 export fn chroot(path: path) (void | errno) = {
 	let res = libc_chroot(cpath(path)?);
 	if (res == -1) {
 		return *__errno(): errno;
 	};
 };
 
 // getfsstat
 // statfs
 // fstatfs
 // fhstatfs
 // vfork
 // gettimeofday
 // settimeofday
 // select
 // kevent
 
 @symbol("kevent") fn libc_kevent(
 	kq: int,
 	changelist: nullable *const [*]kevent,
 	nchanges: int,
 	eventlist: nullable *[*]kevent,
 	nevents: int,
 	timeout: nullable *const timespec
 ) int;
 
 // kevent() wrapper. Renamed to not conflict with the struct "kevent"
 export fn kevent_poll(
 	kq: int,
 	changelist: nullable *const [*]kevent,
 	nchanges: int,
 	eventlist: nullable *[*]kevent,
 	nevents: int,
 	timeout: nullable *const timespec
 ) (int | errno) = {
 	let res = libc_kevent(kq, changelist, nchanges, eventlist, nevents,
 		timeout);
 	if (res == -1) {
 		return *__errno(): errno;
 	};
 	return res;
 };
 
 // munmap
 
 @symbol("munmap") fn libc_munmap(addr: *opaque, len_: size) int;
 
 export fn munmap(addr: *opaque, len_: size) (void | errno) = {
 	let res = libc_munmap(addr, len_);
 	if (res == -1) {
 		return *__errno(): errno;
 	};
 };
 
 // mprotect
 // madvise
 // utimes
 // futimes
 // mquery
 // getgroups
 
 @symbol("getgroups") fn libc_getgroups(gidsetlen: int, gidset: *[*]gid_t) int;
 
 export fn getgroups(gids: []gid_t) (uint | errno) = {
 	let res = libc_getgroups(len(gids): int, gids: *[*]gid_t);
 	if (res == -1) {
 		return *__errno(): errno;
 	};
 	return res: uint;
 };
 
 // setgroups
 
 @symbol("setgroups") fn libc_setgroups(
 	ngroups: int,
 	gidset: *[*]gid_t,
 ) int;
 
 export fn setgroups(gids: []gid_t) (void | errno) = {
 	let res = libc_setgroups(len(gids): int, gids: *[*]gid_t);
 	if (res == -1) {
 		return *__errno(): errno;
 	};
 };
 
 // getpgrp
 
 export @symbol("getpgrp") fn getpgrp() pid_t;
 
 // setpgid
 
 @symbol("setpgid") fn libc_setpgid(pid: pid_t, pgrp: pid_t) int;
 
 export fn setpgid(pid: pid_t, pgrp: pid_t) (void | errno) = {
 	let res = libc_setpgid(pid, pgrp);
 	if (res == -1) {
 		return *__errno(): errno;
 	};
 };
 
 // futex
 // utimensat
 
 @symbol("utimensat") fn libc_utimensat(
 	fd: int,
 	path: *const u8,
 	times: *const [2]timespec,
 	flag: int
 ) int;
 
 export fn utimensat(
 	dirfd: int,
 	path: str,
 	ts: *[2]timespec,
 	flags: int
 ) (void | errno) = {
 	let res = libc_utimensat(dirfd, cpath(path)?, ts, flags);
 	if (res == -1) {
 		return *__errno(): errno;
 	};
 };
 
 // futimens
 
 @symbol("futimens") fn libc_futimens(
 	fd: int,
 	times: *const [2]timespec
 ) int;
 
 export fn futimens(fd: int, ts: *[2]timespec) (void | errno) = {
 	let res = libc_futimens(fd, ts);
 	if (res == -1) {
 		return *__errno(): errno;
 	};
 };
 
 // kbind
 // clock_gettime
 // clock_settime
 
 @symbol("clock_gettime") fn libc_clock_gettime(clock: int, now: *timespec) int;
 
 export fn clock_gettime(clock: int, now: *timespec) (void | errno) = {
 	let res = libc_clock_gettime(clock, now);
 	if (res == -1) {
 		return *__errno(): errno;
 	};
 };
 
 @symbol("clock_settime") fn libc_clock_settime(clock: int, now: *const timespec) int;
 
 export fn clock_settime(clock: int, now: *const timespec) (void | errno) = {
 	let res = libc_clock_settime(clock, now);
 	if (res == -1) {
 		return *__errno(): errno;
 	};
 };
 
 // clock_getres
 // dup2
 
 @symbol("dup2") fn libc_dup2(oldd: int, newd: int) int;
 
 export fn dup2(oldfd: int, newfd: int) (int | errno) = {
 	let res = libc_dup2(oldfd, newfd);
 	if (res == -1) {
 		return *__errno(): errno;
 	};
 	return res;
 };
 
 // nanosleep
 
 @symbol("nanosleep") fn libc_nanosleep(
 	timeout: *const timespec,
 	remainder: *timespec
 ) int;
 
 export fn nanosleep(
 	timeout: *const timespec,
 	remainder: *timespec
 ) (void | errno) = {
 	let res = libc_nanosleep(timeout, remainder);
 	if (res == -1) {
 		return *__errno(): errno;
 	};
 };
 
 // fcntl
 
 @symbol("fcntl") fn libc_fcntl(fd: int, cmd: int, arg: u64) int;
 
 export type fcntl_arg = (void | int | *st_flock | *u64);
 
 export fn fcntl(fd: int, cmd: int, arg: fcntl_arg) (int | errno) = {
 	let res = match (arg) {
 	case void =>
 		yield libc_fcntl(fd, cmd, 0);
 	case let i: int =>
 		yield libc_fcntl(fd, cmd, i: u64);
 	case let l: *st_flock =>
 		yield libc_fcntl(fd, cmd, l: uintptr: u64);
 	case let u: *u64 =>
 		yield libc_fcntl(fd, cmd, u: uintptr: u64);
 	};
 	if (res == -1) {
 		return *__errno(): errno;
 	};
 	return res;
 };
 
 // accept4
 
 @symbol("accept4") fn libc_accept4(
 	s: int,
 	addr: nullable *sockaddr,
 	adddrlen: nullable *u32,
 	flags: int
 ) int;
 
 export fn accept4(
 	sockfd: int,
 	addr: nullable *sockaddr,
 	addrlen: nullable *u32,
 	flags: int
 ) (int | errno) = {
 	let res = libc_accept4(sockfd, addr, addrlen, flags);
 	if (res == -1) {
 		return  *__errno(): errno;
 	};
 	return res;
 };
 
 // __thrsleep
 
 // fsync
 @symbol("fsync") fn libc_fsync(fd: int) int;
 
 export fn fsync(fd: int) (void | errno) = {
 	let res = libc_fsync(fd);
 	if (res == -1) {
 		return *__errno(): errno;
 	};
 	return res;
 };
 
 // fdatasync
 @symbol("fdatasync") fn libc_fdatasync(fd: int) int;
 
 export fn fdatasync(fd: int) (void | errno) = {
 	let res = libc_fdatasync(fd);
 	if (res == -1) {
 		return *__errno(): errno;
 	};
 	return res;
 };
 
 // setpriority
 
 @symbol("setpriority") fn libc_setpriority(
 	which: int,
 	who: id_t,
 	prio: int
 ) int;
 
 export fn setpriority(which: int, who: id_t, prio: int) (void | errno) = {
 	let res = libc_setpriority(which, who, prio);
 	if (res == -1) {
 		return *__errno(): errno;
 	};
 };
 
 // socket
 
 @symbol("socket") fn libc_socket(domain: int, t: int, protocol: int) int;
 
 export fn socket(domain: int, t: int, protocol: int) (int | errno) = {
 	let res = libc_socket(domain, t, protocol);
 	if (res == -1) {
 		return *__errno(): errno;
 	};
 	return res;
 };
 
 // connect
 
 @symbol("connect") fn libc_connect(
 	sockfd: int,
 	addr: *const sockaddr,
 	addrlen: u32
 ) int;
 
 export fn connect(
 	sockfd: int,
 	addr: *const sockaddr,
 	addrlen: u32
 ) (void | errno) = {
 	let res = libc_connect(sockfd, addr, addrlen);
 	if (res == -1) {
 		return *__errno(): errno;
 	};
 };
 
 // getdents
 
 @symbol("getdents") fn libc_getdents(fd: int, buf: *opaque, nbytes: size) int;
 
 export fn getdents(dirfd: int, buf: *opaque, nbytes: size) (int | errno) = {
 	let res = libc_getdents(dirfd, buf, nbytes);
 	if (res == -1) {
 		return *__errno(): errno;
 	};
 	return res;
 };
 
 // getpriority
 
 @symbol("getpriority") fn libc_getpriority(which: int, who: id_t) int;
 
 export fn getpriority(which: int, who: id_t) (int | errno) = {
 	let res = libc_getpriority(which, who);
 	if (res == -1) {
 		return *__errno(): errno;
 	};
 	return res;
 };
 
 // pipe2
 
 @symbol("pipe2") fn libc_pipe2(pipefd: *[2]int, flags: int) int;
 
 export fn pipe2(pipefd: *[2]int, flags: int) (void | errno) = {
 	let res = libc_pipe2(pipefd, flags);
 	if (res == -1) {
 		return *__errno(): errno;
 	};
 };
 
 // dup3
 // sigreturn
 // bind
 
 @symbol("bind") fn libc_bind(
 	sockfd: int,
 	addr: *const sockaddr,
 	addrlen: u32
 ) int;
 
 export fn bind(
 	sockfd: int,
 	addr: *const sockaddr,
 	addrlen: u32
 ) (void | errno) = {
 	let res = libc_bind(sockfd, addr, addrlen);
 	if (res == -1) {
 		return *__errno(): errno;
 	};
 };
 
 // setsockopt
 
 @symbol("setsockopt") fn libc_setsockopt(
 	s: int,
 	level: int,
 	optname: int,
 	optval: *opaque,
 	optlen: u32
 ) int;
 
 export fn setsockopt(
 	sockfd: int,
 	level: int,
 	optname: int,
 	optval: *opaque,
 	optlen: u32
 ) (void | errno) = {
 	let res = libc_setsockopt(sockfd, level, optname, optval, optlen);
 	if (res == -1) {
 		return *__errno(): errno;
 	};
 };
 
 // listen
 
 @symbol("listen") fn libc_listen(s: int, backlog: int) int;
 
 export fn listen(sockfd: int, backlog: u32) (void | errno) = {
 	let res = libc_listen(sockfd, backlog: int);
 	if (res == -1) {
 		return *__errno(): errno;
 	};
 };
 
 // chflagsat
 // pledge
 
 @symbol("pledge") fn libc_pledge(
 	promises: nullable *const u8,
 	execpromises: nullable *const u8
 ) int;
 
 // The "stdio" pledge is always needed. Passing [[nullpromise]] to promises or
 // execpromises specifies to not change the current value. Check the pledge(2)
 // manual page for more information about the differrent promises.
 export fn pledge(
 	promises: (const str | nullpromise),
 	execpromises: (const str | nullpromise),
 ) (void | errno) = {
 	let promises: nullable *u8 = match(promises) {
 	case let p: const str =>
 		yield cpath(p)!;
 	case nullpromise =>
 		yield null;
 	};
 
 	let execpromises: nullable *u8 = match(execpromises) {
 	case let ep: const str =>
 		yield copy_cpath(ep, pathbuf1)!;
 	case nullpromise =>
 		yield null;
 	};
 
 	let res = libc_pledge(promises, execpromises);
 	if (res == -1) {
 		return *__errno(): errno;
 	};
 };
 
 // ppoll
 
 @symbol("ppoll") fn libc_ppoll(
 	fds: *[*]pollfd,
 	nfds: nfds_t,
 	timeout: const nullable *timespec,
 	mask: const nullable *sigset,
 ) int;
 
 export fn ppoll(
 	fds: *[*]pollfd,
 	nfds: nfds_t,
 	timeout: const nullable *timespec,
 	sigmask: const nullable *sigset,
 ) (int | errno) = {
 	let ret = libc_ppoll(fds, nfds, timeout, sigmask);
 	if (ret == -1) {
 		return *__errno(): errno;
 	};
 	return ret;
 };
 
 // pselect
 // sigsuspend
 // sendsyslog
 // unveil
 
 @symbol("unveil") fn libc_unveil(
 	path: nullable *const u8,
 	permissions: nullable *const u8
 ) int;
 
 // After establishing a collection of path and permissions rules, future
 // calls to [[unveil]] can be disabled by calling [[unveil_lock]].
 // Alternatively, [[pledge]] may be used to remove the "unveil" promise.
 export fn unveil(
 	path: path,
 	permissions: const str,
 ) (void | errno) = {
 	let res = libc_unveil(cpath(path)?, copy_cpath(permissions, pathbuf1)?);
 	if (res == -1) {
 		return *__errno(): errno;
 	};
 };
 
 // Disable future calls to [[unveil]].
 export fn unveil_lock() (void | errno) = {
 	let res = libc_unveil(null, null);
 	if (res == -1) {
 		return *__errno(): errno;
 	};
 };
 
 // __realpath
 // recvmmsg
 // sendmmsg
 // getsockopt
 
 @symbol("getsockopt") fn libc_getsockopt(
 	s: int,
 	level: int,
 	optname: int,
 	optval: nullable *opaque,
 	optlen: nullable *u32
 ) int;
 
 export fn getsockopt(
 	sockfd: int,
 	level: int,
 	optname: int,
 	optval: nullable *opaque,
 	optlen: nullable *u32
 ) (void | errno) = {
 	let res = libc_getsockopt(sockfd, level, optname, optval, optlen);
 	if (res == -1) {
 		return *__errno(): errno;
 	};
 };
 
 // thrkill
 // readv
 
 @symbol("readv") fn libc_readv(d: int, iov: const *[*]iovec, iovcnt: int) size;
 
 export fn readv(fd: int, iov: const *[*]iovec, iovcnt: int) (size | errno) = {
 	let res: u64 = libc_readv(fd, iov, iovcnt);
 
 	if (res == -1) {
 		return *__errno(): errno;
 	};
 	return res;
 };
 
 // writev
 
 @symbol("writev") fn libc_writev(d: int, iov: const *[*]iovec, iovcnt: int) size;
 
 export fn writev(fd: int, iov: const *[*]iovec, iovcnt: int) (size | errno) = {
 	let res: u64 = libc_writev(fd, iov, iovcnt);
 
 	if (res == -1) {
 		return *__errno(): errno;
 	};
 	return res;
 };
 
 // kill
 
 @symbol("kill") fn libc_kill(pid: pid_t, signal: int) int;
 
 export fn kill(pid: pid_t, signal: int) (void | errno) = {
 	let res = libc_kill(pid, signal);
 	if (res == -1) {
 		return *__errno(): errno;
 	};
 };
 
 // fchown
 
 @symbol("fchown") fn libc_fchown(
 	fd: int,
 	owner: uid_t,
 	group: gid_t
 ) int;
 
 export fn fchown(fd: int, uid: uid_t, gid: gid_t) (void | errno) = {
 	let res = libc_fchown(fd, uid, gid);
 	if (res == -1) {
 		return *__errno(): errno;
 	};
 };
 
 // fchmod
 
 @symbol("fchmod") fn libc_fchmod(
 	fd: int,
 	mode: uint
 ) int;
 
 export fn fchmod(fd: int, mode: uint) (void | errno) = {
 	let res = libc_fchmod(fd, mode);
 	if (res == -1) {
 		return *__errno(): errno;
 	};
 };
 
 // setreuid
 // setregid
 // rename
 // flock
 
 @symbol("flock") fn libc_flock(fd: int, operation: int) int;
 
 export fn flock(fd: int, op: int) (void | errno) = {
 	let res = libc_flock(fd, op);
 	if (res == -1) {
 		return *__errno(): errno;
 	};
 };
 
 // mkfifo
 // sendto
 
 @symbol("sendto") fn libc_sendto(
 	s: int,
 	msg: *opaque,
 	length: size,
 	flags: int,
 	to: nullable *sockaddr,
 	tolen: socklen_t
 ) i64;
 
 export fn sendto(
 	sockfd: int,
 	buf: *opaque,
 	length: size,
 	flags: int,
 	dest_addr: nullable *sockaddr,
 	addrlen: u32
 ) (size | errno) = {
 	let res = libc_sendto(sockfd, buf, length, flags, dest_addr, addrlen);
 	if (res == -1) {
 		return *__errno(): errno;
 	};
 	return res: size;
 };
 
 // shutdown
 
 @symbol("shutdown") fn libc_shutdown(s: int, how: int) int;
 
 export fn shutdown(s: int, how: int) (void | errno) = {
 	let res = libc_shutdown(s, how);
 	if (res == -1) {
 		return *__errno(): errno;
 	};
 };
 
 // socketpair
 
 @symbol("socketpair") fn libc_socketpair(
 	domain: int,
 	type_: int,
 	protocol: int,
 	sv: *[*]int
 ) int;
 
 export fn socketpair(
 	domain: int,
 	type_: int,
 	protocol: int,
 	sv: *[*]int
 ) (void | errno) = {
 	let res = libc_socketpair(domain, type_, protocol, sv);
 	if (res == -1) {
 		return *__errno(): errno;
 	};
 
 };
 // mkdir
 // rmdir
 // adjtime
 // getlogin_r
 // getthrname
 // setthrname
 // pinsyscall
 
 // setsid
 
 @symbol("setsid") fn libc_setsid() pid_t;
 
 export fn setsid() (void | errno) = {
 	let res = libc_setsid();
 	if (res == -1) {
 		return *__errno(): errno;
 	};
 };
 
 // quotactl
 // ypconnect
 // nfssvc
 // mimmutable
 // waitid
 // getfh
 // __tmpfd
 // sysarch
 // lseek
 
 @symbol("lseek") fn libc_lseek(fildes: int, pos: i64, whence: int) i64;
 
 export fn lseek(fd: int, off: i64, whence: int) (i64 | errno) = {
 	let res = libc_lseek(fd, off, whence);
 	if (res == -1) {
 		return *__errno(): errno;
 	};
 	return res;
 };
 
 // truncate
 // ftruncate
 
 @symbol("ftruncate") fn libc_ftruncate(fd: int, length: i64) int;
 
 export fn ftruncate(fd: int, length: i64) (void | errno) = {
 	let res = libc_ftruncate(fd, length);
 	if (res == -1) {
 		return *__errno(): errno;
 	};
 };
 
 // pread
 // pwrite
 // preadv
 // pwritev
 // setgid
 
 @symbol("setgid") fn libc_setgid(gid: gid_t) int;
 
 export fn setgid(gid: gid_t) (void | errno) = {
 	let res = libc_setgid(gid);
 	if (res == -1) {
 		return *__errno(): errno;
 	};
 };
 
 // setegid
 
 @symbol("setegid") fn libc_setegid(gid: gid_t) int;
 
 export fn setegid(gid: gid_t) (void | errno) = {
 	let res = libc_setegid(gid);
 	if (res == -1) {
 		return *__errno(): errno;
 	};
 };
 
 // seteuid
 
 @symbol("seteuid") fn libc_seteuid(uid: uid_t) int;
 
 export fn seteuid(uid: uid_t) (void | errno) = {
 	let res = libc_seteuid(uid);
 	if (res == -1) {
 		return *__errno(): errno;
 	};
 };
 
 // pathconf
 // fpathconf
 // swapctl
 // getrlimit
 // setrlimit
 // sysctl
 
 @symbol("sysctl") fn libc_sysctl(
 	name: *[*]int,
 	namelen: uint,
 	oldp: nullable *opaque,
 	oldlenp: nullable *size,
 	newp: nullable *opaque,
 	newlen: size
 ) int;
 
 export fn sysctl(
 	name: []int,
 	namelen: uint,
 	oldp: nullable *opaque,
 	oldlenp: nullable *size,
 	newp: nullable *opaque,
 	newlen: size
 ) (void | errno) = {
 	let res = libc_sysctl(name: *[*]int, namelen, oldp, oldlenp, newp, newlen);
 	if (res == -1) {
 		return *__errno(): errno;
 	};
 };
 
 // mlock
 // munlock
 // getpgid
 
 @symbol("getpgid") fn libc_getpgid(pid: pid_t) pid_t;
 
 export fn getpgid(pid: pid_t) (pid_t | errno) = {
 	let res = libc_getpgid(pid);
 	if (res == -1) {
 		return *__errno(): errno;
 	};
 
 	return res;
 };
 
 // utrace
 // semget
 // msgget
 // msgsnd
 // msgrcv
 // shmat
 // shmdt
 // minherit
 // poll
 // issetugid
 // lchown
 
 // shm_open
 
 @symbol("shm_open") fn libc_shm_open(path: *const u8, flags: int, mode: mode_t) int;
 
 export fn shm_open(path: path, flags: int, mode: mode_t) (int | errno) = {
 	let res = libc_shm_open(cpath(path)?, flags, mode);
 	if (res == -1) {
 		return *__errno(): errno;
 	};
 	return res;
 };
 
 // shm_unlink
 
 @symbol("shm_unlink") fn libc_shm_unlink(path: *const u8) int;
 
 export fn shm_unlink(path: path) (void | errno) = {
 	let res = libc_shm_unlink(cpath(path)?);
 	if (res == -1) {
 		return *__errno(): errno;
 	};
 };
 
 // getsid
 
 @symbol("getsid") fn libc_getsid(pid: pid_t) pid_t;
 
 export fn getsid(pid: pid_t) (pid_t | errno) = {
 	let res = libc_getsid(pid);
 	if (res == -1) {
 		return *__errno(): errno;
 	};
 	return res;
 };
 
 // msync
 // pipe
 // fhopen
 // kqueue
 
 @symbol("kqueue") fn libc_kqueue() int;
 
 export fn kqueue() (int | errno) = {
 	let res = libc_kqueue();
 	if (res == -1) {
 		return *__errno(): errno;
 	};
 
 	return res;
 };
 
 // kqueue1
 
 @symbol("kqueue1") fn libc_kqueue1(flags: int) int;
 
 export fn kqueue1(flags: int) (int | errno) = {
 	let res = libc_kqueue1(flags);
 	if (res == -1) {
 		return *__errno(): errno;
 	};
 
 	return res;
 };
 
 // mlockall
 // munlockall
 // getresuid
 // setresuid
 // getresgid
 // setresgid
 // closefrom
 // sigaltstack
 // shmget
 // semop
 // fhstat
 // __semctl
 // shmctl
 // msgctl
 // sched_yield
 // getthrid
 // __thrwakeup
 // __threxit
 // __thrsigdivert
 // getcwd
 
 @symbol("getcwd") fn libc_getcwd(buf: *u8, bufsz: size) *u8;
 
 // The return value is statically allocated and must be duplicated before
 // calling getcwd again.
 export fn getcwd() (*const u8 | errno) = {
 	static let pathbuf: [PATH_MAX]u8 = [0...];
 
 	let res = libc_getcwd(&pathbuf: *u8, len(pathbuf));
 	if (res == null) {
 		return *__errno(): errno;
 	};
 
 	return res;
 };
 
 // adjfreq
 // setrtable
 // getrtable
 // faccessat
 // fchmodat
 
 @symbol("fchmodat") fn libc_fchmodat(
 	fd: int,
 	path: *const u8,
 	mode: mode_t,
 	flag: int
 ) int;
 
 export fn fchmodat(
 	dirfd: int,
 	path: path,
 	mode: mode_t,
 	flag: int
 ) (void | errno) = {
 	let res = libc_fchmodat(dirfd, cpath(path)?, mode, flag);
 	if (res == -1) {
 		return *__errno(): errno;
 	};
 };
 
 // fchownat
 
 @symbol("fchownat") fn libc_fchownat(
 	fd: int,
 	path: *const u8,
 	owner: uid_t,
 	group: gid_t,
 	flag: int
 ) int;
 
 export fn fchownat(
 	dirfd: int,
 	path: path,
 	uid: uid_t,
 	gid: gid_t,
 	flag: int
 ) (void | errno) = {
 	let res = libc_fchownat(dirfd, cpath(path)?, uid, gid, flag);
 	if (res == -1) {
 		return *__errno(): errno;
 	};
 };
 
 // linkat
 
 @symbol("linkat") fn libc_linkat(
 	fd1: int,
 	name1: *const u8,
 	fd2: int,
 	name2: *const u8,
 	flag: int
 ) int;
 
 export fn linkat(
 	olddirfd: int,
 	oldpath: path,
 	newdirfd: int,
 	newpath: path,
 	flags: int,
 ) (void | errno) = {
 	let oldpath = cpath(oldpath)?;
 	let newpath = copy_cpath(newpath, pathbuf1)?;
 
 	let res = libc_linkat(olddirfd, oldpath, newdirfd, newpath, flags);
 	if (res == -1) {
 		return *__errno(): errno;
 	};
 };
 
 // mkdirat
 
 @symbol("mkdirat") fn libc_mkdirat(fd: int, path: *const u8, mode: mode_t) int;
 
 export fn mkdirat(dirfd: int, path: path, mode: mode_t) (void | errno) = {
 	let res = libc_mkdirat(dirfd, cpath(path)?, mode);
 	if (res == -1) {
 		return *__errno(): errno;
 	};
 };
 
 // mkfifoat
 // mknodat
 
 @symbol("mknodat") fn libc_mknodat(
 	fd: int,
 	path: *const u8,
 	mode: mode_t,
 	dev: dev_t
 ) int;
 
 // The OpenBSD implementation of mknodat *only* supports FIFO and
 // device special files.
 export fn mknodat(
 	dirfd: int,
 	path: path,
 	mode: mode_t,
 	dev: dev_t,
 ) (void | errno) = {
 	let res = libc_mknodat(dirfd, cpath(path)?, mode, dev);
 	if (res == -1) {
 		return *__errno(): errno;
 	};
 };
 
 // openat
 
 @symbol("openat") fn libc_openat(
 	fd: int,
 	path: *const u8,
 	flags: int,
 	mode: uint,
 ) int;
 
 export fn openat(
 	dirfd: int,
 	path: path,
 	flags: int,
 	mode: uint,
 ) (int | errno) = {
 	let res = libc_openat(dirfd, cpath(path)?, flags, mode);
 	if (res == -1) {
 		return *__errno(): errno;
 	};
 	return res;
 };
 
 // readlinkat
 
 @symbol("readlinkat") fn libc_readlinkat(
 	fd: int,
 	path: *const u8,
 	buf: *u8,
 	bufsiz: size
 ) i64;
 
 export fn readlinkat(
 	dirfd: int,
 	path: path,
 	buf: []u8,
 ) (size | errno) = {
 	let res = libc_readlinkat(dirfd, cpath(path)?, buf: *[*]u8: *u8, len(buf));
 	if (res == -1) {
 		return *__errno(): errno;
 	};
 	return res: size;
 };
 
 // renameat
 
 @symbol("renameat") fn libc_renameat(
 	fromfd: int,
 	from: *const u8,
 	tofd: int,
 	to: *const u8
 ) int;
 
 export fn renameat(
 	olddirfd: int,
 	oldpath: str,
 	newdirfd: int,
 	newpath: str,
 ) (void | errno) = {
 	let newpath = copy_cpath(newpath, pathbuf1)?;
 
 	let res = libc_renameat(olddirfd, cpath(oldpath)?, newdirfd,
 			newpath);
 	if (res == -1) {
 		return *__errno(): errno;
 	};
 };
 
 // symlinkat
 
 @symbol("symlinkat") fn libc_symlinkat(
 	name1: *const u8,
 	fd: int,
 	name2: *const u8
 ) int;
 
 export fn symlinkat(
 	target: path,
 	newdirfd: int,
 	linkpath: path,
 ) (void | errno) = {
 	let target = cpath(target)?;
 	let linkpath = copy_cpath(linkpath, pathbuf1)?;
 
 	let res = libc_symlinkat(target, newdirfd, linkpath);
 	if (res == -1) {
 		return *__errno(): errno;
 	};
 };
 
 // unlinkat
 
 @symbol("unlinkat") fn libc_unlinkat(fd: int, path: *const u8, flag: int) int;
 
 export fn unlinkat(dirfd: int, path: path, flags: int) (void | errno) = {
 	let res = libc_unlinkat(dirfd, cpath(path)?, flags);
 	if (res == -1) {
 		return *__errno(): errno;
 	};
 };
 
 // __set_tcb
 // __get_tcb