diff options
| -rw-r--r-- | lib/sys/bld.sub | 1 | ||||
| -rw-r--r-- | lib/sys/sys+openbsd:7.0-x64.myr (renamed from lib/sys/sys+openbsd:6.1-x64.myr) | 245 | ||||
| -rw-r--r-- | support/syscall-gen/c2myr.py | 10 | ||||
| -rwxr-xr-x | support/syscall-gen/gensys.sh | 4 | ||||
| -rw-r--r-- | support/syscall-gen/specials+openbsd:7.0-x64.frag | 286 | ||||
| -rw-r--r-- | support/syscall-gen/syscalls+openbsd:7.0.master | 568 | ||||
| -rw-r--r-- | support/syscall-gen/types+openbsd:7.0-x64.frag | 488 |
7 files changed, 1473 insertions, 129 deletions
diff --git a/lib/sys/bld.sub b/lib/sys/bld.sub index ea0794a..68f9e30 100644 --- a/lib/sys/bld.sub +++ b/lib/sys/bld.sub @@ -13,6 +13,7 @@ lib sys = sys+openbsd:6.2-x64.myr sys+openbsd:6.3-x64.myr sys+openbsd:6.4-x64.myr + sys+openbsd:7.0-x64.myr syscall+freebsd-x64.s syscall+netbsd-x64.s diff --git a/lib/sys/sys+openbsd:6.1-x64.myr b/lib/sys/sys+openbsd:7.0-x64.myr index 9ac648a..3b24add 100644 --- a/lib/sys/sys+openbsd:6.1-x64.myr +++ b/lib/sys/sys+openbsd:7.0-x64.myr @@ -1,6 +1,6 @@ /* generated-ish source - stitched for openbsd:6.1 arch:x64 + stitched for openbsd:7.0 arch:x64 edit with caution. */ pkg sys = @@ -10,6 +10,9 @@ pkg sys = type intptr = uint64/* can hold any pointer losslessly */ type time = int64 /* milliseconds since epoch */ type pid = int32 /* process id */ + type uid = int32 /* user id */ + type key = int32 /* sysv ipc key */ + type id = int32 /* id */ type scno = int64 /*syscall*/ type fdopt = int64 /* fd options */ type fd = int32 /* fd */ @@ -26,7 +29,15 @@ pkg sys = type signo = int32 type sigflags = int32 type sigset = uint32 + type clockid = uint32 type msg = void + type msqid_ds = void + type gid = uint32 + + const Futexwait : int = 1 + const Futexwake : int = 2 + const Futexrequeue : int = 3 + type clock = union `Clockrealtime @@ -43,6 +54,11 @@ pkg sys = `Waitstop int32 ;; + type rlimit = struct + cur : uint64 /* current (soft) limit */ + max : uint64 /* maximum value for rlim_cur */ + ;; + type timespec = struct sec : int64 nsec : int64 @@ -53,6 +69,10 @@ pkg sys = usec : int64 ;; + type timezone = struct + minwest : int32 /* minutes west of Greenwich */ + dsttime : int32 /* type of dst correction */ + ;; type pollfd = struct fd : fd @@ -60,11 +80,82 @@ pkg sys = revents : uint16 ;; + type fsid = struct + val : int32[2] + ;; + + type itimerval = struct + interval : timeval /* timer interval */ + value : timeval /* current value */ + ;; + type sigaction = struct handler : byte# /* code pointer */ mask : sigset flags : sigflags ;; + /* + * Information pushed on stack when a signal is delivered. + * This is used by the kernel to restore state following + * execution of the signal handler. It is also made available + * to the handler to allow it to restore state properly if + * a non-standard exit is performed. + */ + type sigcontext = struct + /* plain match trapframe */ + rdi : int64 + rsi : int64 + rdx : int64 + rcx : int64 + r8 : int64 + r9 : int64 + r10 : int64 + r11 : int64 + r12 : int64 + r13 : int64 + r14 : int64 + r15 : int64 + rbp : int64 + rbx : int64 + rax : int64 + gs : int64 + fs : int64 + es : int64 + ds : int64 + trapno : int64 + err : int64 + rip : int64 + cs : int64 + rflags : int64 + rsp : int64 + ss : int64 + + fpstate : fxsave64# + __pad : int32 + mask : int32 + cookie : int64 + ;; + + type sigaltstack = struct + sp : void# + size : size + flags : int32 + ;; + + type fxsave64 = struct + fcw : int16 + fsw : int16 + ftw : int8 + unused1 : int8 + fop : int16 + rip : int64 + rdp : int64 + mxcsr : int32 + mxcsrmask : int32 + st : int64[8][2] /* 8 normal FP regs */ + xmm : int64[16][2] /* 16 SSE2 registers */ + unused3 : int8[96] + ;; const Simaxsz = 128 const Sipad = (Simaxsz / 4) - 3 @@ -272,7 +363,7 @@ pkg sys = const Mfixed : mopt = 0x10 const Mfile : mopt = 0x0 const Manon : mopt = 0x1000 - const Mstack : mopt = 0 + const Mstack : mopt = 0x4000 const Mnoreplace : mopt = 0x0800 /* file types */ @@ -402,14 +493,8 @@ pkg sys = extern const syscall : (sc:scno, args:... -> int64) extern var __cenvp : byte## type dev = int32 - type uid = uint32 - type gid = uint32 type fd_mask = uint32 type uintptr = uint64 - type clockid = int32 - type id = uint32 - type rlim = uint64 - type key = int64 type shmatt = int16 type tfork = struct @@ -430,11 +515,6 @@ pkg sys = ;; - type fsid = struct - val : int32[2] - - ;; - type fid = struct len : uint16 reserved : uint16 @@ -448,18 +528,6 @@ pkg sys = ;; - type timezone = struct - minuteswest : int - dsttime : int - - ;; - - type itimerval = struct - interval : timeval - value : timeval - - ;; - type fdset = struct bits : fd_mask[32] @@ -481,69 +549,6 @@ pkg sys = ;; - type fxsave64 = struct - fcw : uint16 - fsw : uint16 - ftw : uint8 - unused1 : uint8 - fop : uint16 - rip : uint64 - rdp : uint64 - mxcsr : uint32 - mxcsr_mask : uint32 - st : uint64[2][8] - xmm : uint64[2][16] - unused3 : uint8[96] - - ;; - - type sigcontext = struct - rdi : int64 - rsi : int64 - rdx : int64 - rcx : int64 - r8 : int64 - r9 : int64 - r10 : int64 - r11 : int64 - r12 : int64 - r13 : int64 - r14 : int64 - r15 : int64 - rbp : int64 - rbx : int64 - rax : int64 - gs : int64 - fs : int64 - es : int64 - ds : int64 - trapno : int64 - err : int64 - rip : int64 - cs : int64 - rflags : int64 - rsp : int64 - ss : int64 - fpstate : fxsave64# - unused : int - mask : int - cookie : int64 - - ;; - - type rlimit = struct - cur : rlim - max : rlim - - ;; - - type sigaltstack = struct - sp : void# - size : size - flags : int - - ;; - type sembuf = struct num : uint16 op : int16 @@ -578,25 +583,6 @@ pkg sys = ;; - type msqid_ds = struct - perm : ipc_perm - first : msg# - last : msg# - cbytes : uint64 - qnum : uint64 - qbytes : uint64 - lspid : pid - lrpid : pid - stime : time - pad1 : int64 - rtime : time - pad2 : int64 - ctime : time - pad3 : int64 - pad4 : int64[4] - - ;; - const Sysexit : scno = 1 const Sysfork : scno = 2 @@ -634,6 +620,7 @@ pkg sys = const Syschflags : scno = 34 const Sysfchflags : scno = 35 const Syssync : scno = 36 + const Sysmsyscall : scno = 37 const Sysstat : scno = 38 const Sysgetppid : scno = 39 const Syslstat : scno = 40 @@ -645,7 +632,6 @@ pkg sys = const Syssigaction : scno = 46 const Sysgetgid : scno = 47 const Syssigprocmask : scno = 48 - const Sysgetlogin59 : scno = 49 const Syssetlogin : scno = 50 const Sysacct : scno = 51 const Syssigpending : scno = 52 @@ -674,11 +660,11 @@ pkg sys = const Sysmadvise : scno = 75 const Sysutimes : scno = 76 const Sysfutimes : scno = 77 - const Sysmincore : scno = 78 const Sysgetgroups : scno = 79 const Syssetgroups : scno = 80 const Sysgetpgrp : scno = 81 const Syssetpgid : scno = 82 + const Sysfutex : scno = 83 const Sysutimensat : scno = 84 const Sysfutimens : scno = 85 const Syskbind : scno = 86 @@ -708,6 +694,8 @@ pkg sys = const Syspselect : scno = 110 const Syssigsuspend : scno = 111 const Syssendsyslog : scno = 112 + const Sysunveil : scno = 114 + const Sys__realpath : scno = 115 const Sysgetsockopt : scno = 118 const Systhrkill : scno = 119 const Sysreadv : scno = 120 @@ -731,6 +719,7 @@ pkg sys = const Sysquotactl : scno = 148 const Sysnfssvc : scno = 155 const Sysgetfh : scno = 161 + const Sys__tmpfd : scno = 164 const Syssysarch : scno = 165 const Syspread : scno = 173 const Syspwrite : scno = 174 @@ -894,13 +883,13 @@ pkg sys = const chflags : (path : byte#, flags : uint -> int) const fchflags : (fd : int, flags : uint -> int) const sync : ( -> void) + const msyscall : (addr : void#, len : size -> int) const getppid : ( -> pid) const fstatat : (fd : int, path : byte#, buf : statbuf#, flag : int -> int) const getegid : ( -> gid) const profil : (samples : void#, size : size, offset : uint64, scale : uint -> int) const ktrace : (fname : byte#, ops : int, facs : int, pid : pid -> int) const getgid : ( -> gid) - const getlogin59 : (namebuf : byte#, namelen : uint -> int) const setlogin : (namebuf : byte# -> int) const acct : (path : byte# -> int) const sigpending : ( -> int) @@ -925,11 +914,11 @@ pkg sys = const madvise : (addr : void#, len : size, behav : int -> int) const utimes : (path : byte#, tptr : timeval# -> int) const futimes : (fd : int, tptr : timeval# -> int) - const mincore : (addr : void#, len : size, vec : byte# -> int) const getgroups : (gidsetsize : int, gidset : gid# -> int) const setgroups : (gidsetsize : int, gidset : gid# -> int) const getpgrp : ( -> int) const setpgid : (pid : pid, pgid : pid -> int) + const futex : (f : uint32#, op : int, val : int, timeout : timespec#, g : uint32# -> int) const utimensat : (fd : int, path : byte#, times : timespec#, flag : int -> int) const futimens : (fd : int, times : timespec# -> int) const kbind : (param : kbind#, psize : size, proc_cookie : int64 -> int) @@ -942,11 +931,13 @@ pkg sys = const dup3 : (from : int, to : int, flags : int -> int) const sigreturn : (sigcntxp : sigcontext# -> int) const chflagsat : (fd : int, path : byte#, flags : uint, atflags : int -> int) - const pledge : (request : byte#, paths : byte## -> int) + const pledge : (promises : byte#, execpromises : byte# -> int) const ppoll : (fds : pollfd#, nfds : uint, ts : timespec#, mask : sigset# -> int) const pselect : (nd : int, _in : fdset#, ou : fdset#, ex : fdset#, ts : timespec#, mask : sigset# -> int) const sigsuspend : (mask : int -> int) - const sendsyslog : (buf : void#, nbyte : size, flags : int -> int) + const sendsyslog : (buf : byte#, nbyte : size, flags : int -> int) + const unveil : (path : byte#, permissions : byte# -> int) + const __realpath : (pathname : byte#, resolved : byte# -> int) const thrkill : (tid : pid, signum : int, tcb : void# -> int) const fchown : (fd : int, uid : uid, gid : gid -> int) const fchmod : (fd : int, mode : filemode -> int) @@ -965,6 +956,7 @@ pkg sys = const quotactl : (path : byte#, cmd : int, uid : int, arg : byte# -> int) const nfssvc : (flag : int, argp : void# -> int) const getfh : (fname : byte#, fhp : fhandle# -> int) + const __tmpfd : (flags : int -> int) const sysarch : (op : int, parms : void# -> int) const setgid : (gid : gid -> int) const setegid : (egid : gid -> int) @@ -1132,7 +1124,7 @@ pkg sys = generic ioctl = {fd, req, arg; -> (syscall(Sysioctl, a(fd), a(req), a(arg)) : int64)} const chdir = {dir; -> syscall(Syschdir, cstring(dir))} const __getcwd = {buf; -> syscall(Sys__getcwd, a(buf), a(buf.len))} - const getdents = {fd, buf; -> (syscall(Sysgetdents, a(buf), a(buf.len)) : int64)} + const getdents = {fd, buf; -> (syscall(Sysgetdents, a(fd), a(buf), a(buf.len)) : int64)} /* signals */ const sigaction = {sig, act, oact; -> (syscall(Syssigaction, a(sig), a(act), a(oact)) : int)} @@ -1338,6 +1330,9 @@ const fchflags = {fd, flags const sync = { -> (syscall(Syssync) : void) } +const msyscall = {addr, len + -> (syscall(Sysmsyscall, a(addr), a(len)) : int) +} const getppid = { -> (syscall(Sysgetppid) : pid) } @@ -1356,9 +1351,6 @@ const ktrace = {fname, ops, facs, pid const getgid = { -> (syscall(Sysgetgid) : gid) } -const getlogin59 = {namebuf, namelen - -> (syscall(Sysgetlogin59, a(namebuf), a(namelen)) : int) -} const setlogin = {namebuf -> (syscall(Syssetlogin, a(namebuf)) : int) } @@ -1431,9 +1423,6 @@ const utimes = {path, tptr const futimes = {fd, tptr -> (syscall(Sysfutimes, a(fd), a(tptr)) : int) } -const mincore = {addr, len, vec - -> (syscall(Sysmincore, a(addr), a(len), a(vec)) : int) -} const getgroups = {gidsetsize, gidset -> (syscall(Sysgetgroups, a(gidsetsize), a(gidset)) : int) } @@ -1446,6 +1435,9 @@ const getpgrp = { const setpgid = {pid, pgid -> (syscall(Syssetpgid, a(pid), a(pgid)) : int) } +const futex = {f, op, val, timeout, g + -> (syscall(Sysfutex, a(f), a(op), a(val), a(timeout), a(g)) : int) +} const utimensat = {fd, path, times, flag -> (syscall(Sysutimensat, a(fd), a(path), a(times), a(flag)) : int) } @@ -1482,8 +1474,8 @@ const sigreturn = {sigcntxp const chflagsat = {fd, path, flags, atflags -> (syscall(Syschflagsat, a(fd), a(path), a(flags), a(atflags)) : int) } -const pledge = {request, paths - -> (syscall(Syspledge, a(request), a(paths)) : int) +const pledge = {promises, execpromises + -> (syscall(Syspledge, a(promises), a(execpromises)) : int) } const ppoll = {fds, nfds, ts, mask -> (syscall(Sysppoll, a(fds), a(nfds), a(ts), a(mask)) : int) @@ -1497,6 +1489,12 @@ const sigsuspend = {mask const sendsyslog = {buf, nbyte, flags -> (syscall(Syssendsyslog, a(buf), a(nbyte), a(flags)) : int) } +const unveil = {path, permissions + -> (syscall(Sysunveil, a(path), a(permissions)) : int) +} +const __realpath = {pathname, resolved + -> (syscall(Sys__realpath, a(pathname), a(resolved)) : int) +} const thrkill = {tid, signum, tcb -> (syscall(Systhrkill, a(tid), a(signum), a(tcb)) : int) } @@ -1551,6 +1549,9 @@ const nfssvc = {flag, argp const getfh = {fname, fhp -> (syscall(Sysgetfh, a(fname), a(fhp)) : int) } +const __tmpfd = {flags + -> (syscall(Sys__tmpfd, a(flags)) : int) +} const sysarch = {op, parms -> (syscall(Syssysarch, a(op), a(parms)) : int) } diff --git a/support/syscall-gen/c2myr.py b/support/syscall-gen/c2myr.py index 9c262c5..0babd55 100644 --- a/support/syscall-gen/c2myr.py +++ b/support/syscall-gen/c2myr.py @@ -3,7 +3,7 @@ import re import os import traceback import pycparser -import StringIO +import io from pycparser import c_parser, c_ast from pycparser.plyparser import Coord #from pycparser import c_parser, c_ast, parse_file @@ -314,8 +314,8 @@ def myrtype(name, defname=None): return gen if __name__ == '__main__': - structs = StringIO.StringIO() - defs = StringIO.StringIO() + structs = io.StringIO() + defs = io.StringIO() prehdr = ''' #define __builtin_va_list int @@ -355,7 +355,7 @@ if __name__ == '__main__': if os.path.exists("/usr/include/x86_64-linux-gnu/sys"): syshdr = syshdr + ["linux/" + h for h in os.listdir("/usr/include/linux")] for hdr in syshdr: - print 'trying {}'.format(hdr) + print('trying {}'.format(hdr)) if not hdr.endswith(".h"): continue try: @@ -365,7 +365,7 @@ if __name__ == '__main__': pycparser.parse_file('/tmp/myr-includes.h', use_cpp=True) includes.append('#include <{}>'.format(hdr)) except Exception: - print '...skip' + print('...skip') print('importing' + ' '.join(includes)) with open('/tmp/myr-includes.h', 'w') as f: diff --git a/support/syscall-gen/gensys.sh b/support/syscall-gen/gensys.sh index 51415a4..7e508f3 100755 --- a/support/syscall-gen/gensys.sh +++ b/support/syscall-gen/gensys.sh @@ -42,10 +42,10 @@ touch have.txt if [ `uname` = Linux ]; then hdrgen $1 $2 - python ./c2myr.py $1 $2 + python3 ./c2myr.py $1 $2 hdrgen $1 $2 else mastergen $1 $2 - python ./c2myr.py $1 $2 + python3 ./c2myr.py $1 $2 mastergen $1 $2 fi diff --git a/support/syscall-gen/specials+openbsd:7.0-x64.frag b/support/syscall-gen/specials+openbsd:7.0-x64.frag new file mode 100644 index 0000000..b326ec1 --- /dev/null +++ b/support/syscall-gen/specials+openbsd:7.0-x64.frag @@ -0,0 +1,286 @@ +/* process control */ +const exit : (status:int -> void) +const getpid : ( -> pid) +const kill : (pid:pid, sig:int64 -> int64) +const fork : (-> pid) +const wait4 : (pid:pid, loc:int32#, opt : int64, usage:rusage# -> int64) +const waitpid : (pid:pid, loc:int32#, opt : int64 -> int64) +const execv : (cmd : byte[:], args : byte[:][:] -> int64) +const execve : (cmd : byte[:], args : byte[:][:], env : byte[:][:] -> int64) +/* wrappers to extract wait status */ +const waitstatus : (st : int32 -> waitstatus) +extern const __tfork_thread : (tfp : tforkparams#, sz : size, fn : void#, arg : void# -> pid) + +/* fd manipulation */ +const open : (path:byte[:], opts:fdopt -> fd) +const openmode : (path:byte[:], opts:fdopt, mode:int64 -> fd) +const close : (fd:fd -> int64) +const creat : (path:byte[:], mode:int64 -> fd) +const unlink : (path:byte[:] -> int) +const read : (fd:fd, buf:byte[:] -> size) +const pread : (fd:fd, buf:byte[:], off : off -> size) +const readv : (fd:fd, iov:iovec[:] -> size) +const write : (fd:fd, buf:byte[:] -> size) +const pwrite : (fd:fd, buf:byte[:], off : off -> size) +const writev : (fd:fd, iov:iovec[:] -> size) +const lseek : (fd:fd, off : off, whence : whence -> int64) +const stat : (path:byte[:], sb:statbuf# -> int64) +const lstat : (path:byte[:], sb:statbuf# -> int64) +const fstat : (fd:fd, sb:statbuf# -> int64) +const mkdir : (path : byte[:], mode : int64 -> int64) +generic ioctl : (fd:fd, req : int64, arg:@a# -> int64) +const getdents : (fd : fd, buf : byte[:] -> int64) +const chdir : (p : byte[:] -> int64) +const __getcwd : (buf : byte[:] -> int64) +const poll : (pfd : pollfd[:], tm : int -> int) + +/* signals */ +const sigaction : (sig : signo, act : sigaction#, oact : sigaction# -> int) +const sigprocmask : (how : int32, set : sigset#, oset : sigset# -> int) + +/* fd stuff */ +const pipe : (fds : fd[2]# -> int64) +const dup : (fd : fd -> fd) +const dup2 : (src : fd, dst : fd -> fd) +/* NB: the C ABI uses '...' for the args. */ +const fcntl : (fd : fd, cmd : fcntlcmd, args : byte# -> int64) + +/* networking */ +const socket : (dom : sockfam, stype : socktype, proto : sockproto -> fd) +const connect : (sock : fd, addr : sockaddr#, len : size -> int) +const accept : (sock : fd, addr : sockaddr#, len : size# -> fd) +const listen : (sock : fd, backlog : int -> int) +const bind : (sock : fd, addr : sockaddr#, len : size -> int) +const setsockopt : (sock : fd, lev : sockproto, opt : sockopt, val : void#, len : size -> int) +const getsockopt : (sock : fd, lev : sockproto, opt : sockopt, val : void#, len : size# -> int) + +/* memory mapping */ +const munmap : (addr:byte#, len:size -> int64) +const mmap : (addr:byte#, len:size, prot:mprot, flags:mopt, fd:fd, off:off -> byte#) + +/* time - doublecheck if this is right */ +const clock_getres : (clk : clock, ts : timespec# -> int32) +const clock_gettime : (clk : clock, ts : timespec# -> int32) +const clock_settime : (clk : clock, ts : timespec# -> int32) +const sleep : (time : uint64 -> int32) +const nanosleep : (req : timespec#, rem : timespec# -> int32) + +/* system information */ +const uname : (buf : utsname# -> int) +const sysctl : (mib : int[:], \ + old : void#, oldsz : size#, \ + new : void#, newsz : size# \ + -> int) + +/* +wraps a syscall argument, converting it to 64 bits for the syscall function. This is +the same as casting, but more concise than writing a cast to uint64 +*/ +generic a = {x : @t; -> (x : uint64)} + +extern const cstring : (str : byte[:] -> byte#) +extern const alloca : (sz : size -> byte#) + +extern const __freebsd_pipe : (fds : fd[2]# -> int64) + +/* process management */ +const exit = {status; syscall(Sysexit, a(status))} +const getpid = {; -> (syscall(Sysgetpid, 1) : pid)} +const kill = {pid, sig; -> syscall(Syskill, pid, sig)} +const fork = {; -> (syscall(Sysfork) : pid)} +const wait4 = {pid, loc, opt, usage; -> syscall(Syswait4, pid, loc, opt, usage)} +const waitpid = {pid, loc, opt; + -> wait4(pid, loc, opt, (0 : rusage#)) +} + +const execv = {cmd, args + var p, cargs, i + + /* of course we fucking have to duplicate this code everywhere, + * since we want to stack allocate... */ + p = alloca((args.len + 1)*sizeof(byte#)) + cargs = (p : byte##)[:args.len + 1] + for i = 0; i < args.len; i++ + cargs[i] = cstring(args[i]) + ;; + cargs[args.len] = (0 : byte#) + -> syscall(Sysexecve, cstring(cmd), a(p), a(__cenvp)) +} + +const execve = {cmd, args, env + var cargs, cenv, i + var p + + /* copy the args */ + p = alloca((args.len + 1)*sizeof(byte#)) + cargs = (p : byte##)[:args.len] + for i = 0; i < args.len; i++ + cargs[i] = cstring(args[i]) + ;; + cargs[args.len] = (0 : byte#) + + /* + copy the env. + of course we fucking have to duplicate this code everywhere, + since we want to stack allocate... + */ + p = alloca((env.len + 1)*sizeof(byte#)) + cenv = (p : byte##)[:env.len] + for i = 0; i < env.len; i++ + cenv[i] = cstring(env[i]) + ;; + cenv[env.len] = (0 : byte#) + + -> syscall(Sysexecve, cstring(cmd), a(p), a(cenv)) +} + +/* fd manipulation */ +const open = {path, opts; -> (syscall(Sysopen, cstring(path), a(opts), a(0o777)) : fd)} +const openmode = {path, opts, mode; -> (syscall(Sysopen, cstring(path), a(opts), a(mode)) : fd)} +const close = {fd; -> syscall(Sysclose, a(fd))} +const creat = {path, mode; -> (openmode(path, Ocreat | Otrunc | Owronly, mode) : fd)} +const unlink = {path; -> (syscall(Sysunlink, cstring(path)) : int)} +const read = {fd, buf; -> (syscall(Sysread, a(fd), (buf : byte#), a(buf.len)) : size)} +const pread = {fd, buf, off; -> (syscall(Syspread, a(fd), (buf : byte#), a(buf.len), a(off)) : size)} +const readv = {fd, vec; -> (syscall(Sysreadv, a(fd), (vec : iovec#), a(vec.len)) : size)} +const write = {fd, buf; -> (syscall(Syswrite, a(fd), (buf : byte#), a(buf.len)) : size)} +const pwrite = {fd, buf, off; -> (syscall(Syspwrite, a(fd), (buf : byte#), a(buf.len), a(off)) : size)} +const writev = {fd, vec; -> (syscall(Syswritev, a(fd), (vec : iovec#), a(vec.len)) : size)} +const lseek = {fd, off, whence; -> syscall(Syslseek, a(fd), a(off), a(whence))} +const stat = {path, sb; -> syscall(Sysstat, cstring(path), a(sb))} +const lstat = {path, sb; -> syscall(Syslstat, cstring(path), a(sb))} +const fstat = {fd, sb; -> syscall(Sysfstat, a(fd), a(sb))} +const mkdir = {path, mode; -> (syscall(Sysmkdir, cstring(path), a(mode)) : int64)} +generic ioctl = {fd, req, arg; -> (syscall(Sysioctl, a(fd), a(req), a(arg)) : int64)} +const chdir = {dir; -> syscall(Syschdir, cstring(dir))} +const __getcwd = {buf; -> syscall(Sys__getcwd, a(buf), a(buf.len))} +const getdents = {fd, buf; -> (syscall(Sysgetdents, a(fd), a(buf), a(buf.len)) : int64)} + +/* signals */ +const sigaction = {sig, act, oact; -> (syscall(Syssigaction, a(sig), a(act), a(oact)) : int)} +const sigprocmask = {sig, act, oact; -> (syscall(Syssigprocmask, a(sig), a(act), a(oact)) : int)} + +/* file stuff */ +const pipe = {fds; -> syscall(Syspipe, fds)} +const dup = {fd; -> (syscall(Sysdup, a(fd)) : fd)} +const dup2 = {src, dst; -> (syscall(Sysdup2, a(src), a(dst)) : fd)} +const fcntl = {fd, cmd, args; -> syscall(Sysfcntl, a(fd), a(cmd), a(args))} +const poll = {pfd, tm; -> (syscall(Syspoll, (pfd : byte#), a(pfd.len), a(tm)) : int)} + +/* networking */ +const socket = {dom, stype, proto; -> (syscall(Syssocket, a(dom), a(stype), a(proto)) : fd)} +const connect = {sock, addr, len; -> (syscall(Sysconnect, a(sock), a(addr), a(len)) : int)} +const accept = {sock, addr, len; -> (syscall(Sysaccept, a(sock), a(addr), a(len)) : fd)} +const listen = {sock, backlog; -> (syscall(Syslisten, a(sock), a(backlog)) : int)} +const bind = {sock, addr, len; -> (syscall(Sysbind, a(sock), a(addr), a(len)) : int)} +const setsockopt = {sock, lev, opt, val, len; -> (syscall(Syssetsockopt, a(sock), a(lev), a(opt), a(val), a(len)) : int)} +const getsockopt = {sock, lev, opt, val, len; -> (syscall(Syssetsockopt, a(sock), a(lev), a(opt), a(val), a(len)) : int)} + +/* memory management */ +const munmap = {addr, len; -> syscall(Sysmunmap, a(addr), a(len))} +const mmap = {addr, len, prot, flags, fd, off; + /* the actual syscall has padding on the offset arg */ + -> (syscall(Sysmmap, a(addr), a(len), a(prot), a(flags), a(fd), a(0), a(off)) : byte#) +} + +/* time */ +const clock_getres = {clk, ts; -> (syscall(Sysclock_getres, clockid(clk), a(ts)) : int32)} +const clock_gettime = {clk, ts; -> (syscall(Sysclock_gettime, clockid(clk), a(ts)) : int32)} +const clock_settime = {clk, ts; -> (syscall(Sysclock_settime, clockid(clk), a(ts)) : int32)} + +const sleep = {time + var req, rem + req = [.sec = (time : int64), .nsec = 0] + -> nanosleep(&req, &rem) +} + +const nanosleep = {req, rem; -> (syscall(Sysnanosleep, a(req), a(rem)) : int32)} + + +/* system information */ +const uname = {buf + var mib : int[2] + var ret + var sys, syssz + var nod, nodsz + var rel, relsz + var ver, versz + var mach, machsz + + ret = 0 + mib[0] = 1 /* CTL_KERN */ + mib[1] = 1 /* KERN_OSTYPE */ + sys = (buf.system[:] : void#) + syssz = buf.system.len + ret = sysctl(mib[:], sys, &syssz, (0 : void#), (0 : size#)) + if ret < 0 + -> ret + ;; + + mib[0] = 1 /* CTL_KERN */ + mib[1] = 10 /* KERN_HOSTNAME */ + nod = (buf.node[:] : void#) + nodsz = buf.node.len + ret = sysctl(mib[:], nod, &nodsz, (0 : void#), (0 : size#)) + if ret < 0 + -> ret + ;; + + mib[0] = 1 /* CTL_KERN */ + mib[1] = 2 /* KERN_OSRELEASE */ + rel = (buf.release[:] : void#) + relsz = buf.release.len + ret = sysctl(mib[:], rel, &relsz, (0 : void#), (0 : size#)) + if ret < 0 + -> ret + ;; + + mib[0] = 1 /* CTL_KERN */ + mib[1] = 27 /* KERN_OSVERSION */ + ver = (buf.version[:] : void#) + versz = buf.version.len + ret = sysctl(mib[:], ver, &versz, (0 : void#), (0 : size#)) + if ret < 0 + -> ret + ;; + + mib[0] = 6 /* CTL_HW */ + mib[1] = 1 /* HW_MACHINE */ + mach = (buf.machine[:] : void#) + machsz = buf.machine.len + ret = sysctl(mib[:], mach, &machsz, (0 : void#), (0 : size#)) + if ret < 0 + -> ret + ;; + + -> 0 +} + +const sysctl = {mib, old, oldsz, new, newsz + /* all args already passed through a() or ar ptrs */ + -> (syscall(Syssysctl, \ + (mib : int#), a(mib.len), old, oldsz, new, newsz) : int) +} + +const clockid = {clk + match clk + | `Clockrealtime: -> 0 + | `Clockproccputime: -> 2 + | `Clockmonotonic: -> 3 + | `Clockthreadcputime: -> 4 + | `Clockuptime: -> 5 + ;; + -> -1 +} + +const waitstatus = {st + if st < 0 + -> `Waitfail st + ;; + match st & 0o177 + | 0: -> `Waitexit (st >> 8) + | 0x7f:-> `Waitstop (st >> 8) + | sig: -> `Waitsig sig + ;; +} + diff --git a/support/syscall-gen/syscalls+openbsd:7.0.master b/support/syscall-gen/syscalls+openbsd:7.0.master new file mode 100644 index 0000000..3580d86 --- /dev/null +++ b/support/syscall-gen/syscalls+openbsd:7.0.master @@ -0,0 +1,568 @@ +; $OpenBSD: syscalls.master,v 1.218 2021/06/04 09:05:19 mvs Exp $ +; $NetBSD: syscalls.master,v 1.32 1996/04/23 10:24:21 mycroft Exp $ + +; @(#)syscalls.master 8.2 (Berkeley) 1/13/94 + +; OpenBSD system call name/number "master" file. +; (See syscalls.conf to see what it is processed into.) +; +; Fields: number type [type-dependent ...] +; number system call number, must be in order +; type one of the types described below, or one of the +; compatibility options defined in syscalls.conf +; +; types: +; INDIR included, but don't define the syscall args structure, +; and allow it to be "really" varargs +; NOARGS included, but don't define the syscall args structure +; NODEF included, but don't define the syscall number +; NOLOCK don't acquire the kernel lock when calling this syscall +; OBSOL obsolete, not included in system +; STD always included +; UNIMPL unimplemented, not included in system +; +; The compat options are defined in the syscalls.conf file, and the +; compat option name is prefixed to the syscall name. Other than +; that, they're like NODEF (for 'compat' options), or STD (for +; 'libcompat' options). +; +; The type-dependent arguments are as follows: +; For STD, NODEF, NOARGS, and compat syscalls: +; { pseudo-proto } [alias] +; For other syscalls: +; [comment] +; +; #ifdef's, etc. may be included, and are copied to the output files. +; #include's are copied to the syscall switch definition file only. + +#include <sys/param.h> +#include <sys/systm.h> +#include <sys/signal.h> +#include <sys/mount.h> +#include <sys/syscallargs.h> +#include <sys/poll.h> + +; Reserved/unimplemented system calls in the range 0-150 inclusive +; are reserved for use in future Berkeley releases. +; Additional system calls implemented in vendor and other +; redistributions should be placed in the reserved range at the end +; of the current calls. + +0 INDIR { int sys_syscall(int number, ...); } +1 STD { void sys_exit(int rval); } +2 STD { int sys_fork(void); } +3 STD NOLOCK { ssize_t sys_read(int fd, void *buf, size_t nbyte); } +4 STD NOLOCK { ssize_t sys_write(int fd, const void *buf, \ + size_t nbyte); } +5 STD { int sys_open(const char *path, \ + int flags, ... mode_t mode); } +6 STD NOLOCK { int sys_close(int fd); } +7 STD NOLOCK { int sys_getentropy(void *buf, size_t nbyte); } +8 STD { int sys___tfork(const struct __tfork *param, \ + size_t psize); } +9 STD { int sys_link(const char *path, const char *link); } +10 STD { int sys_unlink(const char *path); } +11 STD { pid_t sys_wait4(pid_t pid, int *status, \ + int options, struct rusage *rusage); } +12 STD { int sys_chdir(const char *path); } +13 STD { int sys_fchdir(int fd); } +14 STD { int sys_mknod(const char *path, mode_t mode, \ + dev_t dev); } +15 STD { int sys_chmod(const char *path, mode_t mode); } +16 STD { int sys_chown(const char *path, uid_t uid, \ + gid_t gid); } +17 STD { int sys_obreak(char *nsize); } break +18 STD NOLOCK { int sys_getdtablecount(void); } +19 STD { int sys_getrusage(int who, \ + struct rusage *rusage); } +20 STD NOLOCK { pid_t sys_getpid(void); } +21 STD { int sys_mount(const char *type, const char *path, \ + int flags, void *data); } +22 STD { int sys_unmount(const char *path, int flags); } +23 STD { int sys_setuid(uid_t uid); } +24 STD NOLOCK { uid_t sys_getuid(void); } +25 STD NOLOCK { uid_t sys_geteuid(void); } +#ifdef PTRACE +26 STD { int sys_ptrace(int req, pid_t pid, caddr_t addr, \ + int data); } +#else +26 UNIMPL ptrace +#endif +27 STD NOLOCK { ssize_t sys_recvmsg(int s, struct msghdr *msg, \ + int flags); } +28 STD NOLOCK { ssize_t sys_sendmsg(int s, \ + const struct msghdr *msg, int flags); } +29 STD NOLOCK { ssize_t sys_recvfrom(int s, void *buf, size_t len, \ + int flags, struct sockaddr *from, \ + socklen_t *fromlenaddr); } +30 STD { int sys_accept(int s, struct sockaddr *name, \ + socklen_t *anamelen); } +31 STD { int sys_getpeername(int fdes, struct sockaddr *asa, \ + socklen_t *alen); } +32 STD { int sys_getsockname(int fdes, struct sockaddr *asa, \ + socklen_t *alen); } +33 STD { int sys_access(const char *path, int amode); } +34 STD { int sys_chflags(const char *path, u_int flags); } +35 STD { int sys_fchflags(int fd, u_int flags); } +36 STD { void sys_sync(void); } +37 STD { int sys_msyscall(void *addr, size_t len); } +38 STD { int sys_stat(const char *path, struct stat *ub); } +39 STD NOLOCK { pid_t sys_getppid(void); } +40 STD { int sys_lstat(const char *path, struct stat *ub); } +41 STD NOLOCK { int sys_dup(int fd); } +42 STD { int sys_fstatat(int fd, const char *path, \ + struct stat *buf, int flag); } +43 STD NOLOCK { gid_t sys_getegid(void); } +44 STD { int sys_profil(caddr_t samples, size_t size, \ + u_long offset, u_int scale); } +#ifdef KTRACE +45 STD { int sys_ktrace(const char *fname, int ops, \ + int facs, pid_t pid); } +#else +45 UNIMPL ktrace +#endif +46 STD { int sys_sigaction(int signum, \ + const struct sigaction *nsa, \ + struct sigaction *osa); } +47 STD NOLOCK { gid_t sys_getgid(void); } +48 STD NOLOCK { int sys_sigprocmask(int how, sigset_t mask); } +49 OBSOL ogetlogin +50 STD { int sys_setlogin(const char *namebuf); } +#ifdef ACCOUNTING +51 STD { int sys_acct(const char *path); } +#else +51 UNIMPL acct +#endif +52 STD { int sys_sigpending(void); } +53 STD { int sys_fstat(int fd, struct stat *sb); } +54 STD NOLOCK { int sys_ioctl(int fd, \ + u_long com, ... void *data); } +55 STD { int sys_reboot(int opt); } +56 STD { int sys_revoke(const char *path); } +57 STD { int sys_symlink(const char *path, \ + const char *link); } +58 STD { ssize_t sys_readlink(const char *path, \ + char *buf, size_t count); } +59 STD { int sys_execve(const char *path, \ + char * const *argp, char * const *envp); } +60 STD { mode_t sys_umask(mode_t newmask); } +61 STD { int sys_chroot(const char *path); } +62 STD { int sys_getfsstat(struct statfs *buf, size_t bufsize, \ + int flags); } +63 STD { int sys_statfs(const char *path, \ + struct statfs *buf); } +64 STD { int sys_fstatfs(int fd, struct statfs *buf); } +65 STD { int sys_fhstatfs(const fhandle_t *fhp, \ + struct statfs *buf); } +66 STD { int sys_vfork(void); } +67 STD NOLOCK { int sys_gettimeofday(struct timeval *tp, \ + struct timezone *tzp); } +68 STD NOLOCK { int sys_settimeofday(const struct timeval *tv, \ + const struct timezone *tzp); } +69 STD NOLOCK { int sys_setitimer(int which, \ + const struct itimerval *itv, \ + struct itimerval *oitv); } +70 STD NOLOCK { int sys_getitimer(int which, \ + struct itimerval *itv); } +71 STD { int sys_select(int nd, fd_set *in, fd_set *ou, \ + fd_set *ex, struct timeval *tv); } +72 STD { int sys_kevent(int fd, \ + const struct kevent *changelist, int nchanges, \ + struct kevent *eventlist, int nevents, \ + const struct timespec *timeout); } +73 STD { int sys_munmap(void *addr, size_t len); } +74 STD { int sys_mprotect(void *addr, size_t len, \ + int prot); } +75 STD { int sys_madvise(void *addr, size_t len, \ + int behav); } +76 STD { int sys_utimes(const char *path, \ + const struct timeval *tptr); } +77 STD { int sys_futimes(int fd, \ + const struct timeval *tptr); } +78 UNIMPL mincore +79 STD NOLOCK { int sys_getgroups(int gidsetsize, \ + gid_t *gidset); } +80 STD { int sys_setgroups(int gidsetsize, \ + const gid_t *gidset); } +81 STD { int sys_getpgrp(void); } +82 STD { int sys_setpgid(pid_t pid, pid_t pgid); } +83 STD NOLOCK { int sys_futex(uint32_t *f, int op, int val, \ + const struct timespec *timeout, uint32_t *g); } +84 STD { int sys_utimensat(int fd, const char *path, \ + const struct timespec *times, int flag); } +85 STD { int sys_futimens(int fd, \ + const struct timespec *times); } +86 STD { int sys_kbind(const struct __kbind *param, \ + size_t psize, int64_t proc_cookie); } +87 STD NOLOCK { int sys_clock_gettime(clockid_t clock_id, \ + struct timespec *tp); } +88 STD NOLOCK { int sys_clock_settime(clockid_t clock_id, \ + const struct timespec *tp); } +89 STD NOLOCK { int sys_clock_getres(clockid_t clock_id, \ + struct timespec *tp); } +90 STD NOLOCK { int sys_dup2(int from, int to); } +91 STD NOLOCK { int sys_nanosleep(const struct timespec *rqtp, \ + struct timespec *rmtp); } +92 STD NOLOCK { int sys_fcntl(int fd, int cmd, ... void *arg); } +93 STD { int sys_accept4(int s, struct sockaddr *name, \ + socklen_t *anamelen, int flags); } +94 STD NOLOCK { int sys___thrsleep(const volatile void *ident, \ + clockid_t clock_id, const struct timespec *tp, \ + void *lock, const int *abort); } +95 STD { int sys_fsync(int fd); } +96 STD { int sys_setpriority(int which, id_t who, int prio); } +97 STD NOLOCK { int sys_socket(int domain, int type, int protocol); } +98 STD NOLOCK { int sys_connect(int s, const struct sockaddr *name, \ + socklen_t namelen); } +99 STD { int sys_getdents(int fd, void *buf, size_t buflen); } +100 STD { int sys_getpriority(int which, id_t who); } +101 STD NOLOCK { int sys_pipe2(int *fdp, int flags); } +102 STD NOLOCK { int sys_dup3(int from, int to, int flags); } +103 STD { int sys_sigreturn(struct sigcontext *sigcntxp); } +104 STD { int sys_bind(int s, const struct sockaddr *name, \ + socklen_t namelen); } +105 STD { int sys_setsockopt(int s, int level, int name, \ + const void *val, socklen_t valsize); } +106 STD { int sys_listen(int s, int backlog); } +107 STD { int sys_chflagsat(int fd, const char *path, \ + u_int flags, int atflags); } +108 STD { int sys_pledge(const char *promises, \ + const char *execpromises); } +109 STD { int sys_ppoll(struct pollfd *fds, \ + u_int nfds, const struct timespec *ts, \ + const sigset_t *mask); } +110 STD { int sys_pselect(int nd, fd_set *in, fd_set *ou, \ + fd_set *ex, const struct timespec *ts, \ + const sigset_t *mask); } +111 STD { int sys_sigsuspend(int mask); } +112 STD NOLOCK { int sys_sendsyslog(const char *buf, size_t nbyte, \ + int flags); } +113 UNIMPL fktrace +114 STD { int sys_unveil(const char *path, \ + const char *permissions); } +115 STD { int sys___realpath(const char *pathname, \ + char *resolved); } +116 OBSOL t32_gettimeofday +117 OBSOL t32_getrusage +118 STD { int sys_getsockopt(int s, int level, int name, \ + void *val, socklen_t *avalsize); } +119 STD { int sys_thrkill(pid_t tid, int signum, void *tcb); } +120 STD NOLOCK { ssize_t sys_readv(int fd, \ + const struct iovec *iovp, int iovcnt); } +121 STD NOLOCK { ssize_t sys_writev(int fd, \ + const struct iovec *iovp, int iovcnt); } +122 STD { int sys_kill(int pid, int signum); } +123 STD { int sys_fchown(int fd, uid_t uid, gid_t gid); } +124 STD { int sys_fchmod(int fd, mode_t mode); } +125 OBSOL orecvfrom +126 STD { int sys_setreuid(uid_t ruid, uid_t euid); } +127 STD { int sys_setregid(gid_t rgid, gid_t egid); } +128 STD { int sys_rename(const char *from, const char *to); } +129 OBSOL otruncate +130 OBSOL oftruncate +131 STD NOLOCK { int sys_flock(int fd, int how); } +132 STD { int sys_mkfifo(const char *path, mode_t mode); } +133 STD NOLOCK { ssize_t sys_sendto(int s, const void *buf, \ + size_t len, int flags, const struct sockaddr *to, \ + socklen_t tolen); } +134 STD { int sys_shutdown(int s, int how); } +135 STD NOLOCK { int sys_socketpair(int domain, int type, \ + int protocol, int *rsv); } +136 STD { int sys_mkdir(const char *path, mode_t mode); } +137 STD { int sys_rmdir(const char *path); } +138 OBSOL t32_utimes +139 OBSOL 4.2 sigreturn +140 STD NOLOCK { int sys_adjtime(const struct timeval *delta, \ + struct timeval *olddelta); } +141 STD { int sys_getlogin_r(char *namebuf, u_int namelen); } +142 OBSOL ogethostid +143 OBSOL osethostid +144 OBSOL ogetrlimit +145 OBSOL osetrlimit +146 OBSOL okillpg +147 STD { int sys_setsid(void); } +148 STD { int sys_quotactl(const char *path, int cmd, \ + int uid, char *arg); } +149 OBSOL oquota +150 OBSOL ogetsockname + +; Syscalls 151-180 inclusive are reserved for vendor-specific +; system calls. (This includes various calls added for compatibility +; with other Unix variants.) +; Some of these calls are now supported by BSD... +151 UNIMPL +152 UNIMPL +153 UNIMPL +154 UNIMPL +#if defined(NFSCLIENT) || defined(NFSSERVER) +155 STD { int sys_nfssvc(int flag, void *argp); } +#else +155 UNIMPL +#endif +156 OBSOL ogetdirentries +157 OBSOL statfs25 +158 OBSOL fstatfs25 +159 UNIMPL +160 UNIMPL +161 STD { int sys_getfh(const char *fname, fhandle_t *fhp); } +162 OBSOL ogetdomainname +163 OBSOL osetdomainname +164 STD { int sys___tmpfd(int flags); } +165 STD { int sys_sysarch(int op, void *parms); } +166 UNIMPL +167 UNIMPL +168 UNIMPL +169 OBSOL semsys10 +170 OBSOL msgsys10 +171 OBSOL shmsys10 +172 UNIMPL +173 STD NOLOCK { ssize_t sys_pread(int fd, void *buf, \ + size_t nbyte, int pad, off_t offset); } +174 STD NOLOCK { ssize_t sys_pwrite(int fd, const void *buf, \ + size_t nbyte, int pad, off_t offset); } +175 UNIMPL ntp_gettime +176 UNIMPL ntp_adjtime +177 UNIMPL +178 UNIMPL +179 UNIMPL +180 UNIMPL + +; Syscalls 181-199 are used by/reserved for BSD +181 STD { int sys_setgid(gid_t gid); } +182 STD { int sys_setegid(gid_t egid); } +183 STD { int sys_seteuid(uid_t euid); } +184 OBSOL lfs_bmapv +185 OBSOL lfs_markv +186 OBSOL lfs_segclean +187 OBSOL lfs_segwait +188 OBSOL stat35 +189 OBSOL fstat35 +190 OBSOL lstat35 +191 STD { long sys_pathconf(const char *path, int name); } +192 STD { long sys_fpathconf(int fd, int name); } +193 STD { int sys_swapctl(int cmd, const void *arg, int misc); } +194 STD NOLOCK { int sys_getrlimit(int which, \ + struct rlimit *rlp); } +195 STD NOLOCK { int sys_setrlimit(int which, \ + const struct rlimit *rlp); } +196 OBSOL ogetdirentries48 +197 STD { void *sys_mmap(void *addr, size_t len, int prot, \ + int flags, int fd, long pad, off_t pos); } +198 INDIR { quad_t sys___syscall(quad_t num, ...); } +199 STD NOLOCK { off_t sys_lseek(int fd, int pad, off_t offset, \ + int whence); } +200 STD { int sys_truncate(const char *path, int pad, \ + off_t length); } +201 STD { int sys_ftruncate(int fd, int pad, off_t length); } +202 STD { int sys_sysctl(const int *name, u_int namelen, \ + void *old, size_t *oldlenp, void *new, \ + size_t newlen); } +203 STD { int sys_mlock(const void *addr, size_t len); } +204 STD { int sys_munlock(const void *addr, size_t len); } +205 UNIMPL sys_undelete +206 OBSOL t32_futimes +207 STD { pid_t sys_getpgid(pid_t pid); } +208 OBSOL nnpfspioctl +209 STD { int sys_utrace(const char *label, const void *addr, \ + size_t len); } +; +; Syscalls 210-219 were reserved for dynamically loaded syscalls +; +210 UNIMPL +211 UNIMPL +212 UNIMPL +213 UNIMPL +214 UNIMPL +215 UNIMPL +216 UNIMPL +217 UNIMPL +218 UNIMPL +219 UNIMPL +; System calls 220-240 are reserved for use by OpenBSD +#ifdef SYSVSEM +220 UNIMPL +221 STD { int sys_semget(key_t key, int nsems, int semflg); } +#else +220 UNIMPL semctl +221 UNIMPL semget +#endif +222 OBSOL semop35 +223 OBSOL semconfig35 +#ifdef SYSVMSG +224 UNIMPL +225 STD { int sys_msgget(key_t key, int msgflg); } +226 STD { int sys_msgsnd(int msqid, const void *msgp, size_t msgsz, \ + int msgflg); } +227 STD { int sys_msgrcv(int msqid, void *msgp, size_t msgsz, \ + long msgtyp, int msgflg); } +#else +224 UNIMPL msgctl +225 UNIMPL msgget +226 UNIMPL msgsnd +227 UNIMPL msgrcv +#endif +#ifdef SYSVSHM +228 STD { void *sys_shmat(int shmid, const void *shmaddr, \ + int shmflg); } +229 UNIMPL +230 STD { int sys_shmdt(const void *shmaddr); } +#else +228 UNIMPL shmat +229 UNIMPL shmctl +230 UNIMPL shmdt +#endif +231 OBSOL shmget35 +232 OBSOL t32_clock_gettime +233 OBSOL t32_clock_settime +234 OBSOL t32_clock_getres +235 UNIMPL timer_create +236 UNIMPL timer_delete +237 UNIMPL timer_settime +238 UNIMPL timer_gettime +239 UNIMPL timer_getoverrun +; +; System calls 240-249 are reserved for other IEEE Std1003.1b syscalls +; +240 OBSOL t32_nanosleep +241 UNIMPL +242 UNIMPL +243 UNIMPL +244 UNIMPL +245 UNIMPL +246 UNIMPL +247 UNIMPL +248 UNIMPL +249 UNIMPL +250 STD { int sys_minherit(void *addr, size_t len, \ + int inherit); } +251 OBSOL rfork +252 STD { int sys_poll(struct pollfd *fds, \ + u_int nfds, int timeout); } +253 STD NOLOCK { int sys_issetugid(void); } +254 STD { int sys_lchown(const char *path, uid_t uid, gid_t gid); } +255 STD { pid_t sys_getsid(pid_t pid); } +256 STD { int sys_msync(void *addr, size_t len, int flags); } +257 OBSOL semctl35 +258 OBSOL shmctl35 +259 OBSOL msgctl35 +260 UNIMPL +261 UNIMPL +262 UNIMPL +263 STD NOLOCK { int sys_pipe(int *fdp); } +264 STD { int sys_fhopen(const fhandle_t *fhp, int flags); } +265 UNIMPL +266 UNIMPL +267 STD NOLOCK { ssize_t sys_preadv(int fd, \ + const struct iovec *iovp, int iovcnt, \ + int pad, off_t offset); } +268 STD NOLOCK { ssize_t sys_pwritev(int fd, \ + const struct iovec *iovp, int iovcnt, \ + int pad, off_t offset); } +269 STD NOLOCK { int sys_kqueue(void); } +270 OBSOL t32_kevent +271 STD { int sys_mlockall(int flags); } +272 STD { int sys_munlockall(void); } +273 UNIMPL sys_getpeereid +274 UNIMPL sys_extattrctl +275 UNIMPL sys_extattr_set_file +276 UNIMPL sys_extattr_get_file +277 UNIMPL sys_extattr_delete_file +278 UNIMPL sys_extattr_set_fd +279 UNIMPL sys_extattr_get_fd +280 UNIMPL sys_extattr_delete_fd +281 STD NOLOCK { int sys_getresuid(uid_t *ruid, uid_t *euid, \ + uid_t *suid); } +282 STD { int sys_setresuid(uid_t ruid, uid_t euid, \ + uid_t suid); } +283 STD NOLOCK { int sys_getresgid(gid_t *rgid, gid_t *egid, \ + gid_t *sgid); } +284 STD { int sys_setresgid(gid_t rgid, gid_t egid, \ + gid_t sgid); } +285 OBSOL sys_omquery +286 STD { void *sys_mquery(void *addr, size_t len, int prot, \ + int flags, int fd, long pad, off_t pos); } +287 STD NOLOCK { int sys_closefrom(int fd); } +288 STD { int sys_sigaltstack(const struct sigaltstack *nss, \ + struct sigaltstack *oss); } +#ifdef SYSVSHM +289 STD { int sys_shmget(key_t key, size_t size, int shmflg); } +#else +289 UNIMPL shmget +#endif +#ifdef SYSVSEM +290 STD { int sys_semop(int semid, struct sembuf *sops, \ + size_t nsops); } +#else +290 UNIMPL semop +#endif +291 OBSOL t32_stat +292 OBSOL t32_fstat +293 OBSOL t32_lstat +294 STD { int sys_fhstat(const fhandle_t *fhp, \ + struct stat *sb); } +#ifdef SYSVSEM +295 STD { int sys___semctl(int semid, int semnum, int cmd, \ + union semun *arg); } +#else +295 UNIMPL +#endif +#ifdef SYSVSHM +296 STD { int sys_shmctl(int shmid, int cmd, \ + struct shmid_ds *buf); } +#else +296 UNIMPL +#endif +#ifdef SYSVMSG +297 STD { int sys_msgctl(int msqid, int cmd, \ + struct msqid_ds *buf); } +#else +297 UNIMPL +#endif +298 STD { int sys_sched_yield(void); } +299 STD NOLOCK { pid_t sys_getthrid(void); } +300 OBSOL t32___thrsleep +301 STD NOLOCK { int sys___thrwakeup(const volatile void *ident, \ + int n); } +302 STD { void sys___threxit(pid_t *notdead); } +303 STD { int sys___thrsigdivert(sigset_t sigmask, \ + siginfo_t *info, const struct timespec *timeout); } +304 STD { int sys___getcwd(char *buf, size_t len); } +305 STD NOLOCK { int sys_adjfreq(const int64_t *freq, \ + int64_t *oldfreq); } +306 OBSOL getfsstat53 +307 OBSOL statfs53 +308 OBSOL fstatfs53 +309 OBSOL fhstatfs53 +310 STD NOLOCK { int sys_setrtable(int rtableid); } +311 STD NOLOCK { int sys_getrtable(void); } +312 OBSOL t32_getdirentries +313 STD { int sys_faccessat(int fd, const char *path, \ + int amode, int flag); } +314 STD { int sys_fchmodat(int fd, const char *path, \ + mode_t mode, int flag); } +315 STD { int sys_fchownat(int fd, const char *path, \ + uid_t uid, gid_t gid, int flag); } +316 OBSOL t32_fstatat +317 STD { int sys_linkat(int fd1, const char *path1, int fd2, \ + const char *path2, int flag); } +318 STD { int sys_mkdirat(int fd, const char *path, \ + mode_t mode); } +319 STD { int sys_mkfifoat(int fd, const char *path, \ + mode_t mode); } +320 STD { int sys_mknodat(int fd, const char *path, \ + mode_t mode, dev_t dev); } +321 STD { int sys_openat(int fd, const char *path, int flags, \ + ... mode_t mode); } +322 STD { ssize_t sys_readlinkat(int fd, const char *path, \ + char *buf, size_t count); } +323 STD { int sys_renameat(int fromfd, const char *from, \ + int tofd, const char *to); } +324 STD { int sys_symlinkat(const char *path, int fd, \ + const char *link); } +325 STD { int sys_unlinkat(int fd, const char *path, \ + int flag); } +326 OBSOL t32_utimensat +327 OBSOL t32_futimens +328 OBSOL __tfork51 +329 STD NOLOCK { void sys___set_tcb(void *tcb); } +330 STD NOLOCK { void *sys___get_tcb(void); } diff --git a/support/syscall-gen/types+openbsd:7.0-x64.frag b/support/syscall-gen/types+openbsd:7.0-x64.frag new file mode 100644 index 0000000..09d48e0 --- /dev/null +++ b/support/syscall-gen/types+openbsd:7.0-x64.frag @@ -0,0 +1,488 @@ +type size = int64 /* spans entire address space */ +type usize = uint64 /* unsigned size */ +type off = int64 /* file offsets */ +type intptr = uint64/* can hold any pointer losslessly */ +type time = int64 /* milliseconds since epoch */ +type pid = int32 /* process id */ +type uid = int32 /* user id */ +type key = int32 /* sysv ipc key */ +type id = int32 /* id */ +type scno = int64 /*syscall*/ +type fdopt = int64 /* fd options */ +type fd = int32 /* fd */ +type whence = uint64 /* seek from whence */ +type mprot = int64 /* memory protection */ +type mopt = int64 /* memory mapping options */ +type socktype = int64 /* socket type */ +type sockproto = int64 /* socket protocol */ +type sockopt = int32 /* socket option */ +type sockfam = uint8 /* socket family */ +type filemode = uint32 +type filetype = uint8 +type fcntlcmd = int64 +type signo = int32 +type sigflags = int32 +type sigset = uint32 +type clockid = uint32 +type msg = void +type msqid_ds = void +type gid = uint32 + +const Futexwait : int = 1 +const Futexwake : int = 2 +const Futexrequeue : int = 3 + + +type clock = union + `Clockrealtime + `Clockmonotonic + `Clockproccputime + `Clockthreadcputime + `Clockuptime +;; + +type waitstatus = union + `Waitfail int32 + `Waitexit int32 + `Waitsig int32 + `Waitstop int32 +;; + +type rlimit = struct + cur : uint64 /* current (soft) limit */ + max : uint64 /* maximum value for rlim_cur */ +;; + +type timespec = struct + sec : int64 + nsec : int64 +;; + +type timeval = struct + sec : int64 + usec : int64 +;; + +type timezone = struct + minwest : int32 /* minutes west of Greenwich */ + dsttime : int32 /* type of dst correction */ +;; + +type pollfd = struct + fd : fd + events : uint16 + revents : uint16 +;; + +type fsid = struct + val : int32[2] +;; + +type itimerval = struct + interval : timeval /* timer interval */ + value : timeval /* current value */ +;; + +type sigaction = struct + handler : byte# /* code pointer */ + mask : sigset + flags : sigflags +;; +/* + * Information pushed on stack when a signal is delivered. + * This is used by the kernel to restore state following + * execution of the signal handler. It is also made available + * to the handler to allow it to restore state properly if + * a non-standard exit is performed. + */ +type sigcontext = struct + /* plain match trapframe */ + rdi : int64 + rsi : int64 + rdx : int64 + rcx : int64 + r8 : int64 + r9 : int64 + r10 : int64 + r11 : int64 + r12 : int64 + r13 : int64 + r14 : int64 + r15 : int64 + rbp : int64 + rbx : int64 + rax : int64 + gs : int64 + fs : int64 + es : int64 + ds : int64 + trapno : int64 + err : int64 + rip : int64 + cs : int64 + rflags : int64 + rsp : int64 + ss : int64 + + fpstate : fxsave64# + __pad : int32 + mask : int32 + cookie : int64 +;; + +type sigaltstack = struct + sp : void# + size : size + flags : int32 +;; + +type fxsave64 = struct + fcw : int16 + fsw : int16 + ftw : int8 + unused1 : int8 + fop : int16 + rip : int64 + rdp : int64 + mxcsr : int32 + mxcsrmask : int32 + st : int64[8][2] /* 8 normal FP regs */ + xmm : int64[16][2] /* 16 SSE2 registers */ + unused3 : int8[96] +;; + +const Simaxsz = 128 +const Sipad = (Simaxsz / 4) - 3 +type siginfo = struct + signo : int + code : int + errno : int + pad : int[Sipad] +;; + +type rusage = struct + utime : timeval /* user time */ + stime : timeval /* system time */ + maxrss : uint64 /* max resident set size*/ + ixrss : uint64 /* shared text size */ + idrss : uint64 /* unshared data size */ + isrss : uint64 /* unshared stack size */ + minflt : uint64 /* page reclaims */ + majflt : uint64 /* page faults */ + nswap : uint64 /* swaps */ + inblock : uint64 /* block input ops */ + oublock : uint64 /* block output ops */ + msgsnd : uint64 /* messages sent */ + msgrcv : uint64 /* messages received */ + nsignals : uint64 /* signals received */ + nvcsw : uint64 /* voluntary context switches */ + nivcsw : uint64 /* involuntary context switches */ +;; + +type tforkparams = struct + tcb : void# + tid : pid# + stk : byte# +;; + +type statbuf = struct + mode : filemode + dev : uint32 + ino : uint64 + nlink : uint32 + uid : uint32 + gid : uint32 + rdev : uint32 + atime : timespec + mtime : timespec + ctime : timespec + size : off + blocks : int64 + blksize : uint32 + flags : uint32 + gen : uint32 + birthtim : timespec +;; + +type semun = struct + semarr : void# +;; + +const Mfsnamelen = 16 /* length of fs type name, including nul */ +const Mnamelen = 90 /* length of buffer for returned name */ + +type statfs = struct + flags : uint32 /* copy of mount flags */ + bsize : uint32 /* file system block size */ + iosize : uint32 /* optimal transfer block size */ + + /* unit is f_bsize */ + blocks : uint64 /* total data blocks in file system */ + bfree : uint64 /* free blocks in fs */ + bavail : int64 /* free blocks avail to non-superuser */ + + files : int64 /* total file nodes in file system */ + ffree : int64 /* free file nodes in fs */ + favail : int64 /* free file nodes avail to non-root */ + + syncwr : int64 /* count of sync writes since mount */ + syncrd : int64 /* count of sync reads since mount */ + asyncwr : int64 /* count of async writes since mount */ + asyncrd : int64 /* count of async reads since mount */ + + fsid : fsid /* file system id */ + namemax : uint32 /* maximum filename length */ + owner : uid /* user that mounted the file system */ + ctime : uint64 /* last mount [-u] time */ + + fstypename : byte[Mfsnamelen]; /* fs type name */ + mntonname : byte[Mnamelen]; /* directory on which mounted */ + mntfromname : byte[Mnamelen]; /* mounted file system */ + mntfromspec : byte[Mnamelen]; /* special for mount request */ + ///union mount_info mount_info; /* per-filesystem mount options */ + __mountinfo : byte[160]; /* storage for 'union mount_info' */ +;; + +type utsname = struct + system : byte[32] + node : byte[32] + release : byte[32] + version : byte[32] + machine : byte[32] +;; + +type sockaddr = struct + len : byte + fam : sockfam + data : byte[14] /* what is the *actual* length? */ +;; + +type sockaddr_in = struct + len : byte + fam : sockfam + port : uint16 + addr : byte[4] + zero : byte[8] +;; + +type sockaddr_in6 = struct + len : byte + fam : sockfam + port : uint16 + flow : uint32 + addr : byte[16] + scope : uint32 +;; + +type sockaddr_un = struct + len : uint8 + fam : sockfam + path : byte[104] +;; + +type sockaddr_storage = struct + len : byte + fam : sockfam + __pad1 : byte[6] + __align : int64 + __pad2 : byte[240] +;; + +type dirent = struct + fileno : uint64 + off : uint64 + reclen : uint16 + ftype : uint8 + namlen : uint8 + __pad : byte[4] + name : byte[256] +;; + +type iovec = struct + base : byte# + len : uint64 +;; + +/* open options */ +const Ordonly : fdopt = 0x0 +const Owronly : fdopt = 0x1 +const Ordwr : fdopt = 0x2 +const Oappend : fdopt = 0x8 +const Ondelay : fdopt = 0x4 +const Oshlock : fdopt = 0x10 /* open with shared file lock */ +const Oexlock : fdopt = 0x20 /* open with exclusive file lock */ +const Oasync : fdopt = 0x40 /* signal pgrp when data ready */ +const Osync : fdopt = 0x80 /* backwards compatibility */ +const Onofollow : fdopt = 0x100 +const Ocreat : fdopt = 0x200 +const Otrunc : fdopt = 0x400 +const Oexcl : fdopt = 0x800 +const Ocloexec : fdopt = 0x10000 +const Odsync : fdopt = Osync /* synchronous data writes */ +const Orsync : fdopt = Osync /* synchronous reads */ +const Odir : fdopt = 0x20000 + +/* poll options */ +const Pollin : uint16 = 0x0001 +const Pollpri : uint16 = 0x0002 +const Pollout : uint16 = 0x0004 +const Pollerr : uint16 = 0x0008 +const Pollhup : uint16 = 0x0010 +const Pollnval : uint16 = 0x0020 +const Pollnorm : uint16 = 0x0040 +const Pollrdband: uint16 = 0x0080 +const Pollwrband: uint16 = 0x0100 + +/* stat modes */ +const Sifmt : filemode = 0xf000 +const Sififo : filemode = 0x1000 +const Sifchr : filemode = 0x2000 +const Sifdir : filemode = 0x4000 +const Sifblk : filemode = 0x6000 +const Sifreg : filemode = 0x8000 +const Siflnk : filemode = 0xa000 +const Sifsock : filemode = 0xc000 +const Sisvtx : filemode = 0x0200 + +/* mmap protection */ +const Mprotnone : mprot = 0x0 +const Mprotrd : mprot = 0x1 +const Mprotwr : mprot = 0x2 +const Mprotexec : mprot = 0x4 +const Mprotrw : mprot = 0x3 + +/* mmap options */ +const Mshared : mopt = 0x1 +const Mpriv : mopt = 0x2 +const Mfixed : mopt = 0x10 +const Mfile : mopt = 0x0 +const Manon : mopt = 0x1000 +const Mstack : mopt = 0x4000 +const Mnoreplace : mopt = 0x0800 + +/* file types */ +const Dtunknown : filetype = 0 +const Dtfifo : filetype = 1 +const Dtchr : filetype = 2 +const Dtdir : filetype = 4 +const Dtblk : filetype = 6 +const Dtreg : filetype = 8 +const Dtlnk : filetype = 10 +const Dtsock : filetype = 12 + +/* socket families. INCOMPLETE. */ +const Afunspec : sockfam = 0 +const Afunix : sockfam = 1 +const Afinet : sockfam = 2 +const Afinet6 : sockfam = 24 + +/* socket types. */ +const Sockstream : socktype = 1 +const Sockdgram : socktype = 2 +const Sockraw : socktype = 3 +const Sockrdm : socktype = 4 +const Sockseqpacket : socktype = 5 + +/* socket options */ +const Sodebug : sockopt = 0x0001 /* turn on debugging info recording */ +const Soacceptconn : sockopt = 0x0002 /* socket has had listen() */ +const Soreuseaddr : sockopt = 0x0004 /* allow local address reuse */ +const Sokeepalive : sockopt = 0x0008 /* keep connections alive */ +const Sodontroute : sockopt = 0x0010 /* just use interface addresses */ +const Sobroadcast : sockopt = 0x0020 /* permit sending of broadcast msgs */ +const Souseloopback : sockopt = 0x0040 /* bypass hardware when possible */ +const Solinger : sockopt = 0x0080 /* linger on close if data present */ +const Sooobinline : sockopt = 0x0100 /* leave received OOB data in line */ +const Soreuseport : sockopt = 0x0200 /* allow local address & port reuse */ +const Sotimestamp : sockopt = 0x0800 /* timestamp received dgram traffic */ +const Sobindany : sockopt = 0x1000 /* allow bind to any address */ +const Sosndbuf : sockopt = 0x1001 /* send buffer size */ +const Sorcvbuf : sockopt = 0x1002 /* receive buffer size */ +const Sosndlowat : sockopt = 0x1003 /* send low-water mark */ +const Sorcvlowat : sockopt = 0x1004 /* receive low-water mark */ +const Sosndtimeo : sockopt = 0x1005 /* send timeout */ +const Sorcvtimeo : sockopt = 0x1006 /* receive timeout */ +const Soerror : sockopt = 0x1007 /* get error status and clear */ +const Sotype : sockopt = 0x1008 /* get socket type */ +const Sonetproc : sockopt = 0x1020 /* multiplex; network processing */ +const Sortable : sockopt = 0x1021 /* routing table to be used */ +const Sopeercred : sockopt = 0x1022 /* get connect-time credentials */ +const Sosplice : sockopt = 0x1023 /* splice data to other socket */ + +/* socket option levels */ +const Solsocket : sockproto = 0xffff + +/* network protocols */ +const Ipproto_ip : sockproto = 0 +const Ipproto_icmp : sockproto = 1 +const Ipproto_tcp : sockproto = 6 +const Ipproto_udp : sockproto = 17 +const Ipproto_raw : sockproto = 255 + +const Seekset : whence = 0 +const Seekcur : whence = 1 +const Seekend : whence = 2 + +/* system specific constants */ +const Maxpathlen : size = 1024 + +/* fcntl constants */ +const Fdupfd : fcntlcmd = 0 /* duplicate file descriptor */ +const Fgetfd : fcntlcmd = 1 /* get file descriptor flags */ +const Fsetfd : fcntlcmd = 2 /* set file descriptor flags */ +const Fgetfl : fcntlcmd = 3 /* get file status flags */ +const Fsetfl : fcntlcmd = 4 /* set file status flags */ +const Fgetown : fcntlcmd = 5 /* get SIGIO/SIGURG proc/pgrp */ +const Fsetown : fcntlcmd = 6 /* set SIGIO/SIGURG proc/pgrp */ +const Fogetlk : fcntlcmd = 7 /* get record locking information */ +const Fosetlk : fcntlcmd = 8 /* set record locking information */ + +/* return value for a failed mapping */ +const Mapbad : byte# = (-1 : byte#) + +/* signal flags */ +const Saonstack : sigflags = 0x0001 /* take signal on signal stack */ +const Sarestart : sigflags = 0x0002 /* restart system on signal return */ +const Saresethand : sigflags = 0x0004 /* reset to SIG_DFL when taking signal */ +const Sanodefer : sigflags = 0x0010 /* don't mask the signal we're delivering */ +const Sanocldwait : sigflags = 0x0020 /* don't create zombies (assign to pid 1) */ +const Sanocldstop : sigflags = 0x0008 /* do not generate SIGCHLD on child stop */ +const Sasiginfo : sigflags = 0x0040 /* generate siginfo_t */ + +/* signals */ +const Sighup : signo = 1 /* hangup */ +const Sigint : signo = 2 /* interrupt */ +const Sigquit : signo = 3 /* quit */ +const Sigill : signo = 4 /* illegal instruction (not reset when caught) */ +const Sigtrap : signo = 5 /* trace trap (not reset when caught) */ +const Sigabrt : signo = 6 /* abort() */ +const Sigiot : signo = Sigabrt /* compatibility */ +const Sigemt : signo = 7 /* EMT instruction */ +const Sigfpe : signo = 8 /* floating point exception */ +const Sigkill : signo = 9 /* kill (cannot be caught or ignored) */ +const Sigbus : signo = 10 /* bus error */ +const Sigsegv : signo = 11 /* segmentation violation */ +const Sigsys : signo = 12 /* bad argument to system call */ +const Sigpipe : signo = 13 /* write on a pipe with no one to read it */ +const Sigalrm : signo = 14 /* alarm clock */ +const Sigterm : signo = 15 /* software termination signal from kill */ +const Sigurg : signo = 16 /* urgent condition on IO channel */ +const Sigstop : signo = 17 /* sendable stop signal not from tty */ +const Sigtstp : signo = 18 /* stop signal from tty */ +const Sigcont : signo = 19 /* continue a stopped process */ +const Sigchld : signo = 20 /* to parent on child stop or exit */ +const Sigttin : signo = 21 /* to readers pgrp upon background tty read */ +const Sigttou : signo = 22 /* like TTIN for output if (tp->t_local<OSTOP) */ +const Sigio : signo = 23 /* input/output possible signal */ +const Sigxcpu : signo = 24 /* exceeded CPU time limit */ +const Sigxfsz : signo = 25 /* exceeded file size limit */ +const Sigvtalrm : signo = 26 /* virtual time alarm */ +const Sigprof : signo = 27 /* profiling time alarm */ +const Sigwinch : signo = 28 /* window size changes */ +const Siginfo : signo = 29 /* information request */ +const Sigusr1 : signo = 30 /* user defined signal 1 */ +const Sigusr2 : signo = 31 /* user defined signal 2 */ +const Sigthr : signo = 32 /* thread library AST */ + +extern const syscall : (sc:scno, args:... -> int64) +extern var __cenvp : byte## |