// SPDX-License-Identifier: MPL-2.0 // (c) Hare authors fn syscall0(_: u64) u64; fn syscall1(_: u64, _: u64) u64; fn syscall2(_: u64, _: u64, _: u64) u64; fn syscall3(_: u64, _: u64, _: u64, _: u64) u64; fn syscall4(_: u64, _: u64, _: u64, _: u64, _: u64) u64; fn syscall5(_: u64, _: u64, _: u64, _: u64, _: u64, _: u64) u64; fn syscall6(_: u64, _: u64, _: u64, _: u64, _: u64, _: u64, _: u64) u64; fn __sigtramp_siginfo_2(_: u64) u64; let pathbuf: [PATH_MAX]u8 = [0...]; // The use of this function is discouraged, as it can create race conditions. // TOCTOU is preferred: attempt to simply use the resource you need and handle // any access errors which occur. export fn access(path: path, mode: int) (bool | errno) = faccessat(AT_FDCWD, path, mode, 0); export fn fchdir(fd: int) (void | errno) = { wrap_return(syscall1(SYS_fchdir, fd: u64))?; }; export fn chdir(path: path) (void | errno) = { let path = kpath(path)?; wrap_return(syscall1(SYS_chdir, path: uintptr: u64))?; }; export fn chroot(path: path) (void | errno) = { let path = kpath(path)?; wrap_return(syscall1(SYS_chroot, path: uintptr: u64))?; }; export fn fchmod(fd: int, mode: uint) (void | errno) = { wrap_return(syscall2(SYS_fchmod, fd: u64, mode: u64))?; }; export fn fchmodat(dirfd: int, path: path, mode: uint, flags: int) (void | errno) = { let path = kpath(path)?; wrap_return(syscall4(SYS_fchmodat, dirfd: u64, path: uintptr: u64, mode: u64, flags: u64))?; }; export fn fchown(fd: int, uid: uint, gid: uint) (void | errno) = { wrap_return(syscall3(SYS_fchown, fd: u64, uid: u32, gid: u32))?; }; export fn fchownat(dirfd: int, path: path, uid: uint, gid: uint, flags: int) (void | errno) = { let path = kpath(path)?; wrap_return(syscall5(SYS_fchownat, dirfd: u64, path: uintptr: u64, uid: u32, gid: u32, flags: u64))?; }; export fn fstatat(fd: int, path: path, _stat: *st, flag: int) (void | errno) = { let path = kpath(path)?; let sb = stat { ... }; wrap_return(syscall4(SYS_fstatat, fd: u64, path: uintptr: u64, &sb: uintptr: u64, flag: u64))?; _stat.dev = sb.st_dev; _stat.ino = sb.st_ino; _stat.mode = sb.st_mode; _stat.nlink = sb.st_nlink; _stat.uid = sb.st_uid; _stat.gid = sb.st_gid; _stat.rdev = sb.st_rdev; _stat.atime.tv_sec = sb.st_atim.tv_sec; _stat.atime.tv_nsec = sb.st_atim.tv_nsec: i64; _stat.mtime.tv_sec = sb.st_mtim.tv_sec; _stat.mtime.tv_nsec = sb.st_mtim.tv_nsec: i64; _stat.ctime.tv_sec = sb.st_ctim.tv_sec; _stat.ctime.tv_nsec = sb.st_ctim.tv_nsec: i64; _stat.btime.tv_sec = sb.st_birthtim.tv_sec; _stat.btime.tv_nsec = sb.st_birthtim.tv_nsec: i64; _stat.sz = sb.st_size; _stat.blocks = sb.st_blocks; _stat.blksz = sb.st_blksize; _stat.flags = sb.st_flags; }; export fn fstatvfs1(fd: int, _statvfs: *statvfs, flag: int) (void | errno) = { wrap_return(syscall3(SYS___fstatvfs190, fd: u64, _statvfs: uintptr: u64, flag: u64))?; }; export fn futimens(fd: int, ts: *[2]timespec) (void | errno) = { wrap_return(syscall2(SYS_futimens, fd: u64, ts: uintptr: u64))?; }; export fn getdents(dirfd: int, buf: *opaque, nbytes: size) (size | errno) = { return wrap_return(syscall3(SYS___getdents30, dirfd: u64, buf: uintptr: u64, nbytes: u64))?: size; }; // 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...]; wrap_return(syscall2(SYS___getcwd, &pathbuf: *[*]u8: uintptr: u64, PATH_MAX))?; return &pathbuf: *const u8; }; export fn mkdirat(dirfd: int, path: path, mode: uint) (void | errno) = { let path = kpath(path)?; wrap_return(syscall3(SYS_mkdirat, dirfd: u64, path: uintptr: u64, mode: u64))?; }; export fn openat( dirfd: int, path: path, flags: int, mode: uint, ) (int | errno) = { let path = kpath(path)?; return wrap_return(syscall4(SYS_openat, dirfd: u64, path: uintptr: u64, flags: u64, mode: u64))?: int; }; export fn readlinkat( dirfd: int, path: path, buf: []u8, ) (size | errno) = { let path = kpath(path)?; return wrap_return(syscall4(SYS_readlinkat, dirfd: u64, path: uintptr: u64, buf: *[*]u8: uintptr: u64, len(buf): u64))?: size; }; export fn renameat( olddirfd: int, oldpath: str, newdirfd: int, newpath: str, ) (void | errno) = { let oldpath = kpath(oldpath)?; static let newpathbuf: [PATH_MAX]u8 = [0...]; let newpath = copy_kpath(newpath, newpathbuf)?; wrap_return(syscall4(SYS_renameat, olddirfd: u64, oldpath: uintptr: u64, newdirfd: u64, newpath: uintptr: u64))?; }; export fn sysctl(name: []const u32, oldp: nullable *opaque, oldlenp: nullable *size, newp: nullable *const opaque, newlen: size) (void | errno) = { wrap_return(syscall6(SYS___sysctl, &name[0]: uintptr: u64, len(name): u64, oldp: uintptr: u64, oldlenp: uintptr: u64, newp: uintptr: u64, newlen: u64))?; }; export fn unlink(path: path) (void | errno) = { let path = kpath(path)?; wrap_return(syscall1(SYS_unlink, path: uintptr: u64))?; }; export fn unlinkat(dirfd: int, path: path, flags: int) (void | errno) = { let path = kpath(path)?; wrap_return(syscall3(SYS_unlinkat, dirfd: u64, path: uintptr: u64, flags: u64))?; }; export fn utimensat(dirfd: int, path: str, ts: *[2]timespec, flags: int) (void | errno) = { let path = kpath(path)?; wrap_return(syscall4(SYS_utimensat, dirfd: u64, path: uintptr: u64, ts: uintptr: u64, flags: u64))?; }; export fn close(fd: int) (void | errno) = { wrap_return(syscall1(SYS_close, fd: u64))?; }; export fn lseek(fd: int, off: i64, whence: int) (i64 | errno) = { return wrap_return(syscall3(SYS_lseek, fd: u64, off: u64, whence: u64))?: i64; }; export fn dup2(old: int, new: int) (int | errno) = wrap_return(syscall2(SYS_dup2, old: u64, new: u64))?: int; export fn getpid() pid_t = syscall0(SYS_getpid): pid_t; export def EXIT_SUCCESS: int = 0; export fn exit(status: int) never = { syscall1(SYS_exit, status: u64); abort(); }; export fn fork() (pid_t | void | errno) = { let n = wrap_return(syscall0(SYS_fork))?: pid_t; switch (n) { case 0 => return; case => return n; }; }; export fn execve( path: *const u8, argv: *[*]nullable *const u8, envp: *[*]nullable *const u8, ) int = syscall3(SYS_execve, path: uintptr: u64, argv: uintptr: u64, envp: uintptr: u64): int; export fn wait4( pid: pid_t, wstatus: nullable *int, options: int, rusage: nullable *rusage, ) (int | errno) = { return wrap_return(syscall4(SYS___wait450, pid: u64, wstatus: uintptr: u64, options: u64, rusage: uintptr: u64))?: int; }; export fn wifexited(status: int) bool = wtermsig(status) == 0; export fn wexitstatus(status: int) int = (status & 0xff00) >> 8; export fn wtermsig(status: int) int = status & 0x7f; export fn wifsignaled(status: int) bool = wtermsig(status) != 0o177 && wtermsig(status) != 0 && status != 0x13; export fn kill(pid: pid_t, signal: int) (void | errno) = { wrap_return(syscall2(SYS_kill, pid: u64, signal: u64))?; }; export fn pipe2(pipefd: *[2]int, flags: int) (void | errno) = { wrap_return(syscall2(SYS_pipe2, pipefd: uintptr: u64, flags: u64))?; }; export fn mmap( addr: nullable *opaque, length: size, prot: uint, flags: uint, fd: int, offs: size ) (errno | *opaque) = { return wrap_return(syscall6(SYS_mmap, addr: uintptr: u64, length: u64, prot: u64, flags: u64, fd: u64, offs: u64)): uintptr: *opaque; }; export fn munmap(addr: *opaque, length: size) (void | errno) = { wrap_return(syscall2(SYS_munmap, addr: uintptr: u64, length: u64))?; }; export type fcntl_arg = (void | int | *st_flock | *u64); export fn fcntl(fd: int, cmd: int, arg: fcntl_arg) (int | errno) = { let _fd = fd: u64, _cmd = cmd: u64; return wrap_return(match (arg) { case void => yield syscall2(SYS_fcntl, _fd, _cmd); case let i: int => yield syscall3(SYS_fcntl, _fd, _cmd, i: u64); case let l: *st_flock => yield syscall3(SYS_fcntl, _fd, _cmd, l: uintptr: u64); case let u: *u64 => yield syscall3(SYS_fcntl, _fd, _cmd, u: uintptr: u64); })?: int; }; export fn read(fd: int, buf: *opaque, count: size) (size | errno) = { return wrap_return(syscall3(SYS_read, fd: u64, buf: uintptr: u64, count: u64))?: size; }; export fn write(fd: int, buf: *const opaque, count: size) (size | errno) = { return wrap_return(syscall3(SYS_write, fd: u64, buf: uintptr: u64, count: u64))?: size; }; export fn readv(fd: int, iov: const *[*]iovec, iovcnt: int) (size | errno) = { return wrap_return(syscall3(SYS_readv, fd: u64, iov: uintptr: u64, iovcnt: u64))?: size; }; export fn writev(fd: int, iov: const *[*]iovec, iovcnt: int) (size | errno) = { return wrap_return(syscall3(SYS_writev, fd: u64, iov: uintptr: u64, iovcnt: u64))?: size; }; export fn flock(fd: int, op: int) (void | errno) = { wrap_return(syscall2(SYS_flock, fd: u64, op: u64))?; }; export fn ftruncate(fd: int, ln: off_t) (void | errno) = { wrap_return(syscall2(SYS_ftruncate, fd: u64, ln: u32))?; }; export fn nanosleep( req: *const timespec, rem: nullable *timespec, ) (void | errno) = { wrap_return(syscall2(SYS___nanosleep50, req: uintptr: u64, rem: uintptr: u64))?; }; export fn clock_nanosleep( clock_id: int, flags: int, requested: *timespec, remaining: nullable *timespec, ) (void | errno) = { wrap_return(syscall4(SYS_clock_nanosleep, clock_id: u64, flags: u64, requested: uintptr: u64, remaining: uintptr: u64 ))?; }; export fn clock_gettime(clock_id: int, tp: *timespec) (void | errno) = { wrap_return(syscall2(SYS___clock_gettime50, clock_id: u64, tp: uintptr: u64))?; }; export fn clock_settime(clock_id: int, tp: *const timespec) (void | errno) = { wrap_return(syscall2(SYS___clock_settime50, clock_id: u64, tp: uintptr: u64))?; }; export fn faccessat( dirfd: int, path: path, mode: int, flags: int, ) (bool | errno) = { let path = kpath(path)?; match (wrap_return(syscall4(SYS_faccessat, dirfd: u64, path: uintptr: u64, mode: u64, flags: u64))) { case let err: errno => switch (err) { case EACCES => return false; case => return err; }; case let n: u64 => assert(n == 0); return true; }; }; // NUL terminates a string and stores it in a static buffer of PATH_MAX bytes in // length. fn kpath(path: path) (*const u8 | errno) = { return copy_kpath(path, pathbuf); }; fn copy_kpath(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(pathbuf)) { return ENAMETOOLONG; }; memcpy(buf: *[*]u8, path: *[*]u8, len(path)); buf[len(path)] = 0; return buf: *[*]u8: *const u8; }; export fn getgroups(gids: []gid_t) (uint | errno) = { return wrap_return(syscall2(SYS_getgroups, len(gids): u64, gids: *[*]gid_t: uintptr: u64))?: uint; }; export fn setgroups(gids: []gid_t) (void | errno) = { wrap_return(syscall2(SYS_setgroups, len(gids): u64, gids: *[*]gid_t: uintptr: u64))?; }; export fn getppid() pid_t = syscall0(SYS_getppid): pid_t; export fn getpgrp() pid_t = syscall0(SYS_getpgrp): pid_t; export fn getsid(pid: pid_t) (pid_t | errno) = { return wrap_return(syscall1(SYS_getsid, pid))?: pid_t; }; export fn getpriority(which: int, who: id_t) (int | errno) = { return wrap_return(syscall2(SYS_getpriority, which: u64, who: u64))?: int; }; export fn setpriority(which: int, who: id_t, prio: int) (void | errno) = { wrap_return(syscall3(SYS_setpriority, which: u64, who: u64, prio: u64))?; }; export fn umask(mode: mode_t) (mode_t | errno) = { return wrap_return(syscall1(SYS_umask, mode: u64))?: mode_t; }; export fn getuid() (uid_t | errno) = { return wrap_return(syscall0(SYS_getuid))?: uid_t; }; export fn geteuid() (uid_t | errno) = { return wrap_return(syscall0(SYS_geteuid))?: uid_t; }; export fn getgid() (gid_t | errno) = { return wrap_return(syscall0(SYS_getgid))?: gid_t; }; export fn getegid() (gid_t | errno) = { return wrap_return(syscall0(SYS_getegid))?: gid_t; }; export fn setuid(uid: *uid_t) (void | errno) = { wrap_return(syscall1(SYS_setuid, uid: uintptr: u64))?; }; export fn seteuid(euid: *uid_t) (void | errno) = { wrap_return(syscall1(SYS_seteuid, euid: uintptr: u64))?; }; export fn setgid(gid: *gid_t) (void | errno) = { wrap_return(syscall1(SYS_setgid, gid: uintptr: u64))?; }; export fn setegid(egid: *gid_t) (void | errno) = { wrap_return(syscall1(SYS_setegid, egid: uintptr: u64))?; }; export fn sigaction( signum: int, act: *const sigact, old: nullable *sigact, ) (int | errno) = { return wrap_return(syscall5(SYS___sigaction_sigtramp, signum: u64, act: uintptr: u64, old: uintptr: u64, &__sigtramp_siginfo_2: uintptr: u64, __SIGTRAMP_SIGINFO_VERSION: u64))?: int; }; export fn sigprocmask( how: int, set: nullable *const sigset, old: nullable *sigset, ) (int | errno) = { return wrap_return(syscall3(SYS___sigprocmask14, how: u64, set: uintptr: u64, old: uintptr: u64))?: int; }; export fn getrlimit(resource: int, rlim: *rlimit) (void | errno) = { wrap_return(syscall2(SYS_getrlimit, resource: u64, rlim: uintptr: u64))?; }; export fn setrlimit(resource: int, rlim: *const rlimit) (void | errno) = { wrap_return(syscall2(SYS_setrlimit, resource: u64, rlim: uintptr: u64))?; }; export fn open( path: path, flags: int, mode: uint, ) (int | errno) = { let path = kpath(path)?; return wrap_return(syscall3(SYS_open, path: uintptr: u64, flags: u64, mode: u64))?: int; }; export fn fstat(fd: int, _stat: *st) (void | errno) = { let sb = stat { ... }; wrap_return(syscall2(SYS___fstat50, fd: u64, &sb: uintptr: u64))?; _stat.dev = sb.st_dev; _stat.ino = sb.st_ino; _stat.mode = sb.st_mode; _stat.nlink = sb.st_nlink; _stat.uid = sb.st_uid; _stat.gid = sb.st_gid; _stat.rdev = sb.st_rdev; _stat.atime.tv_sec = sb.st_atim.tv_sec; _stat.atime.tv_nsec = sb.st_atim.tv_nsec: i64; _stat.mtime.tv_sec = sb.st_mtim.tv_sec; _stat.mtime.tv_nsec = sb.st_mtim.tv_nsec: i64; _stat.ctime.tv_sec = sb.st_ctim.tv_sec; _stat.ctime.tv_nsec = sb.st_ctim.tv_nsec: i64; _stat.btime.tv_sec = sb.st_birthtim.tv_sec; _stat.btime.tv_nsec = sb.st_birthtim.tv_nsec: i64; _stat.sz = sb.st_size; _stat.blocks = sb.st_blocks; _stat.blksz = sb.st_blksize; _stat.flags = sb.st_flags; }; export fn fexecve(fd: int, argv: *[*]nullable *const u8, envp: *[*]nullable *const u8) errno = { return match (wrap_return(syscall3(SYS_fexecve, fd: u64, argv: uintptr: u64, envp: uintptr: u64))) { case let err: errno => yield err; case u64 => abort("unreachable"); }; }; export type ioctl_arg = (nullable *opaque | u64); export fn ioctl(fd: int, req: u64, arg: ioctl_arg) (int | errno) = { let fd = fd: u64, req = req: u64; return wrap_return(match (arg) { case let u: u64 => yield syscall3(SYS_ioctl, fd, req, u); case let v: nullable *opaque => yield syscall3(SYS_ioctl, fd, req, v: uintptr: u64); })?: int; }; export fn posix_openpt(flags: int) (int | errno) = { return open("/dev/ptmx", flags, 0); }; export fn sigaltstack( ss: nullable *stack_t, old_ss: nullable *stack_t, ) (void | errno) = { wrap_return(syscall2(SYS___sigaltstack14, ss: uintptr: u64, old_ss: uintptr: u64))?; }; export fn ppoll( fds: *[*]pollfd, nfds: nfds_t, timeout: const nullable *timespec, sigmask: const nullable *sigset, ) (int | errno) = { return wrap_return(syscall4(SYS___pollts50, fds: uintptr: u64, nfds: u64, timeout: uintptr: u64, sigmask: uintptr: u64))?: int; }; export fn getrandom(buf: *opaque, bufln: size, flags: uint) (size | errno) = { return wrap_return(syscall3(SYS_getrandom, buf: uintptr: u64, bufln: u64, flags: u64))?: size; }; export fn paccept(sockfd: int, addr: nullable *sockaddr, addrlen: nullable *u32, mask: nullable *int, flags: int) (int | errno) = { return wrap_return(syscall5(SYS_paccept, sockfd: u64, addr: uintptr: u64, addrlen: uintptr: u64, mask: uintptr: u64, flags: u64))?: int; }; export fn accept4(sockfd: int, addr: nullable *sockaddr, addrlen: nullable *u32, flags: int) (int | errno) = { return paccept(sockfd, addr, addrlen, null, flags); }; export fn sendmsg(fd: int, msg: *const msghdr, flags: int) (int | errno) = { return wrap_return(syscall3(SYS_sendmsg, fd: u64, msg: uintptr: u64, flags: u64))?: int; }; export fn recvmsg(fd: int, msg: *const msghdr, flags: int) (int | errno) = { return wrap_return(syscall3(SYS_recvmsg, fd: u64, msg: uintptr: u64, flags: u64))?: int; }; export fn shutdown(sockfd: int, how: int) (void | errno) = { wrap_return(syscall2(SYS_shutdown, sockfd: u64, how: u64))?; }; export fn socket(domain: int, type_: int, protocol: int) (int | errno) = { return wrap_return(syscall3(SYS___socket30, domain: u64, type_: u64, protocol: u64))?: int; }; export fn connect(sockfd: int, addr: *const sockaddr, addrlen: u32) (void | errno) = { wrap_return(syscall3(SYS_connect, sockfd: u64, addr: uintptr: u64, addrlen: u64))?; }; export fn bind(sockfd: int, addr: *const sockaddr, addrlen: u32) (void | errno) = { wrap_return(syscall3(SYS_bind, sockfd: u64, addr: uintptr: u64, addrlen: u64))?; }; export fn getsockname(sockfd: int, addr: nullable *sockaddr, addrlen: nullable *u32) (int | errno) = { return wrap_return(syscall3(SYS_getsockname, sockfd: u64, addr: uintptr: u64, addrlen: uintptr: u64))?: int; }; export fn send(sockfd: int, buf: *opaque, len_: size, flags: int) (size | errno) = { return sendto(sockfd, buf, len_, flags, null, 0); }; export fn sendto(sockfd: int, buf: *opaque, len_: size, flags: int, dest_addr: nullable *sockaddr, addrlen: u32 ) (size | errno) = { return wrap_return(syscall6(SYS_sendto, sockfd: u64, buf: uintptr: u64, len_: u64, flags: u64, dest_addr: uintptr: u64, addrlen: u64))?: size; }; export fn recv(sockfd: int, buf: *opaque, len_: size, flags: int) (size | errno) = { return recvfrom(sockfd, buf, len_, flags, null, null); }; export fn setsockopt(sockfd: int, level: int, optname: int, optval: *opaque, optlen: u32) (int | errno) = { return wrap_return(syscall5(SYS_setsockopt, sockfd: u64, level: u64, optname: u64, optval: uintptr: u64, optlen: u64))?: int; }; export fn recvfrom(sockfd: int, buf: *opaque, len_: size, flags: int, src_addr: nullable *sockaddr, addrlen: nullable *u32 ) (size | errno) = { return wrap_return(syscall6(SYS_recvfrom, sockfd: u64, buf: uintptr: u64, len_: u64, flags: u64, src_addr: uintptr: u64, addrlen: uintptr: u64))?: size; }; export fn listen(sockfd: int, backlog: u32) (int | errno) = { return wrap_return(syscall2(SYS_listen, sockfd: u64, backlog: u64))?: int; }; export fn getpeername(sockfd: int, addr: nullable *sockaddr, addrlen: nullable *u32) (int | errno) = { return wrap_return(syscall3(SYS_getpeername, sockfd: u64, addr: uintptr: u64, addrlen: uintptr: u64))?: int; }; export fn socketpair( domain: int, type_: int, protocol: int, sv: *[*]int, ) (int | errno) = { return wrap_return(syscall4(SYS_socketpair, domain: u64, type_: u64, protocol: u64, sv: uintptr: u64))?: int; }; export fn fsync(fd: int) (void | errno) = { wrap_return(syscall1(SYS_fsync, fd: u64))?; }; export fn fdatasync(fd: int) (void | errno) = { wrap_return(syscall1(SYS_fdatasync, fd: u64))?; }; // Scheduling // netbsd-specific scheduler access functions export fn _sched_getparam(pid: pid_t, lwpid: lwpid_t, policy: *int, sp: *sched_param) (void | errno) = { wrap_return(syscall4(SYS__sched_getparam, pid: u64, lwpid: u64, policy: uintptr: u64, sp: uintptr: u64))?; }; export fn _sched_setparam(pid: pid_t, lwpid: lwpid_t, policy: int, sp: *sched_param) (void | errno) = { wrap_return(syscall4(SYS__sched_setparam, pid: u64, lwpid: u64, policy: u64, sp: uintptr: u64))?; }; // The POSIX functions are defined in terms of the netbsd functions. export fn sched_getscheduler(pid: pid_t) (int | errno) = { let policy: int = 0; let sp = sched_param{...}; _sched_getparam(pid, P_ALL_LWPS, &policy, &sp)?; return policy; }; export fn sched_setscheduler(pid: pid_t, policy: int, params: *sched_param) (int | errno) = { let old_policy: int = 0; let old_sp = sched_param{...}; _sched_getparam(pid, P_ALL_LWPS, &old_policy, &old_sp)?; _sched_setparam(pid, P_ALL_LWPS, policy, params)?; return old_policy; }; export fn sched_yield() void = { syscall0(SYS_sched_yield); };