mirrors/Odin
1
0
Fork 0
mirror of https://github.com/odin-lang/Odin.git synced 2026-04-19 13:00:28 +00:00
Code Issues Packages Projects Releases Wiki Activity

Implement new sys/unix package

Browse Source
This commit is contained in:
flysand7
2023-10-18 01:57:26 +11:00
parent 8e4bdcfb98
commit 4d65b1ab9c
25 changed files with 6683 additions and 755 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1400
core/sys/linux/bits.odin Normal file
View File

File diff suppressed because it is too large Load Diff

199
core/sys/linux/constants.odin Normal file
View File

@@ -0,0 +1,199 @@
package linux
/// Special file descriptor to pass to `*at` functions to specify
/// that relative paths are relative to current directory
AT_FDCWD :: Fd(-100)
/// Special value to put into timespec for utimensat() to set timestamp to the current time
UTIME_NOW :: uint((1 << 30) - 1)
/// Special value to put into the timespec for utimensat() to leave the corresponding field of the timestamp unchanged
UTIME_OMIT :: uint((1 << 30) - 2)
/// For wait4: Pass this pid to wait for any process
WAIT_ANY :: Pid(-1)
/// For wait4: Pass this pid to wait for any process in current process group
WAIT_MYPGRP :: Pid(0)
/// Maximum priority (aka nice value) for the process
PRIO_MAX :: 20
/// Minimum priority (aka nice value) for the process
PRIO_MIN :: -20
SIGRTMIN :: Signal(32)
SIGRTMAX :: Signal(64)
S_IFMT :: Mode{.IFREG, .IFDIR, .IFCHR, .IFFIFO}
S_IFSOCK :: Mode{.IFREG, .IFDIR}
S_IFLNK :: Mode{.IFREG, .IFCHR}
S_IFBLK :: Mode{.IFDIR, .IFCHR}
S_IFFIFO :: Mode{.IFFIFO}
S_IFCHR :: Mode{.IFCHR}
S_IFDIR :: Mode{.IFDIR}
S_IFREG :: Mode{.IFREG}
/// Checks the Mode bits to see if the file is a named pipe (FIFO)
S_ISFIFO :: #force_inline proc "contextless" (m: Mode) -> bool {return (S_IFFIFO == (m & S_IFMT))}
/// Check the Mode bits to see if the file is a character device
S_ISCHR :: #force_inline proc "contextless" (m: Mode) -> bool {return (S_IFCHR == (m & S_IFMT))}
/// Check the Mode bits to see if the file is a directory
S_ISDIR :: #force_inline proc "contextless" (m: Mode) -> bool {return (S_IFDIR == (m & S_IFMT))}
/// Check the Mode bits to see if the file is a register
S_ISREG :: #force_inline proc "contextless" (m: Mode) -> bool {return (S_IFREG == (m & S_IFMT))}
/// Check the Mode bits to see if the file is a socket
S_ISSOCK :: #force_inline proc "contextless" (m: Mode) -> bool {return (S_IFSOCK == (m & S_IFMT))}
/// Check the Mode bits to see if the file is a symlink
S_ISLNK :: #force_inline proc "contextless" (m: Mode) -> bool {return (S_IFLNK == (m & S_IFMT))}
/// Check the Mode bits to see if the file is a block device
S_ISBLK :: #force_inline proc "contextless" (m: Mode) -> bool {return (S_IFBLK == (m & S_IFMT))}
/// For access.2 syscall family: instruct to check if the file exists
F_OK :: Mode{}
/// For access.2 syscall family: instruct to check if the file is executable
X_OK :: Mode{.IXOTH}
/// For access.2 syscall family: instruct to check if the file is writeable
W_OK :: Mode{.IWOTH}
/// For access.2 syscall family: instruct to check if the file is readable
R_OK :: Mode{.IROTH}
/// The stats you get by calling `stat`
STATX_BASIC_STATS :: Statx_Mask {
.TYPE,
.MODE,
.NLINK,
.UID,
.GID,
.ATIME,
.MTIME,
.CTIME,
.INO,
.SIZE,
.BLOCKS,
}
FCntl_Command_DUPFD :: distinct FCntl_Command
FCntl_Command_GETFD :: distinct FCntl_Command
FCntl_Command_SETFD :: distinct FCntl_Command
FCntl_Command_GETFL :: distinct FCntl_Command
FCntl_Command_SETFL :: distinct FCntl_Command
FCntl_Command_GETLK :: distinct FCntl_Command
FCntl_Command_SETLK :: distinct FCntl_Command
FCntl_Command_SETLKW :: distinct FCntl_Command
FCntl_Command_DUPFD_CLOEXEC :: distinct FCntl_Command
FCntl_Command_SETOWN :: distinct FCntl_Command
FCntl_Command_GETOWN :: distinct FCntl_Command
FCntl_Command_SETSIG :: distinct FCntl_Command
FCntl_Command_GETSIG :: distinct FCntl_Command
FCntl_Command_SETOWN_EX :: distinct FCntl_Command
FCntl_Command_GETOWN_EX :: distinct FCntl_Command
FCntl_Command_SETLEASE :: distinct FCntl_Command
FCntl_Command_GETLEASE :: distinct FCntl_Command
FCntl_Command_NOTIFY :: distinct FCntl_Command
FCntl_Command_SETPIPE_SZ :: distinct FCntl_Command
FCntl_Command_GETPIPE_SZ :: distinct FCntl_Command
FCntl_Command_ADD_SEALS :: distinct FCntl_Command
FCntl_Command_GET_SEALS :: distinct FCntl_Command
FCntl_Command_GET_RW_HINT :: distinct FCntl_Command
FCntl_Command_SET_RW_HINT :: distinct FCntl_Command
FCntl_Command_GET_FILE_RW_HINT :: distinct FCntl_Command
FCntl_Command_SET_FILE_RW_HINT :: distinct FCntl_Command
F_DUPFD :: FCntl_Command_DUPFD(.DUPFD)
F_GETFD :: FCntl_Command_GETFD(.GETFD)
F_SETFD :: FCntl_Command_SETFD(.SETFD)
F_GETFL :: FCntl_Command_GETFL(.GETFL)
F_SETFL :: FCntl_Command_SETFL(.SETFL)
// F_GETLK64 :: FCntl_Command_GETLK64(.GETLK64)
// F_SETLK64 :: FCntl_Command_SETLK64(.SETLK64)
// F_SETLKW64 :: FCntl_Command_SETLKW64(.SETLKW64)
F_GETLK :: FCntl_Command_GETLK(.GETLK)
F_SETLK :: FCntl_Command_SETLK(.SETLK)
F_SETLKW :: FCntl_Command_SETLKW(.SETLKW)
F_DUPFD_CLOEXEC :: FCntl_Command_DUPFD_CLOEXEC(.DUPFD_CLOEXEC)
F_SETOWN :: FCntl_Command_SETOWN(.SETOWN)
F_GETOWN :: FCntl_Command_GETOWN(.GETOWN)
F_SETSIG :: FCntl_Command_SETSIG(.SETSIG)
F_GETSIG :: FCntl_Command_GETSIG(.GETSIG)
F_SETOWN_EX :: FCntl_Command_SETOWN_EX(.SETOWN_EX)
F_GETOWN_EX :: FCntl_Command_GETOWN_EX(.GETOWN_EX)
F_SETLEASE :: FCntl_Command_SETLEASE(.SETLEASE)
F_GETLEASE :: FCntl_Command_GETLEASE(.GETLEASE)
F_NOTIFY :: FCntl_Command_NOTIFY(.NOTIFY)
F_SETPIPE_SZ :: FCntl_Command_SETPIPE_SZ(.SETPIPE_SZ)
F_GETPIPE_SZ :: FCntl_Command_GETPIPE_SZ(.GETPIPE_SZ)
F_ADD_SEALS :: FCntl_Command_ADD_SEALS(.ADD_SEALS)
F_GET_SEALS :: FCntl_Command_GET_SEALS(.GET_SEALS)
F_GET_RW_HINT :: FCntl_Command_GET_RW_HINT(.GET_RW_HINT)
F_SET_RW_HINT :: FCntl_Command_SET_RW_HINT(.SET_RW_HINT)
F_GET_FILE_RW_HINT :: FCntl_Command_GET_FILE_RW_HINT(.GET_FILE_RW_HINT)
F_SET_FILE_RW_HINT :: FCntl_Command_SET_FILE_RW_HINT(.SET_FILE_RW_HINT)
Socket_API_Level_Sock :: distinct Socket_API_Level
Socket_API_Level_TCP :: distinct Socket_API_Level
Socket_API_Level_UDP :: distinct Socket_API_Level
Socket_API_Level_Raw :: distinct Socket_API_Level
SOL_SOCKET :: Socket_API_Level_Sock(.SOCKET)
SOL_TCP :: Socket_API_Level_TCP(.TCP)
SOL_UDP :: Socket_API_Level_UDP(.UDP)
SOL_RAW :: Socket_API_Level_Raw(.RAW)
Futex_Wait_Type :: distinct Futex_Op
Futex_Wake_Type :: distinct Futex_Op
Futex_Fd_Type :: distinct Futex_Op
Futex_Requeue_Type :: distinct Futex_Op
Futex_Cmp_Requeue_Type :: distinct Futex_Op
Futex_Wake_Op_Type :: distinct Futex_Op
Futex_Lock_Pi_Type :: distinct Futex_Op
Futex_Unlock_Pi_Type :: distinct Futex_Op
Futex_Trylock_Pi_Type :: distinct Futex_Op
Futex_Wait_Bitset_Type :: distinct Futex_Op
Futex_Wake_Bitset_Type :: distinct Futex_Op
Futex_Wait_requeue_Pi_Type :: distinct Futex_Op
Futex_Cmp_requeue_Pi_Type :: distinct Futex_Op
Futex_Lock_Pi2_Type :: distinct Futex_Op
/// Wait on futex wakeup signal
FUTEX_WAIT :: Futex_Wait_Type(.WAIT)
/// Wake up other processes waiting on the futex
FUTEX_WAKE :: Futex_Wake_Type(.WAKE)
/// Not implemented. Basically, since
FUTEX_FD :: Futex_Fd_Type(.FD)
/// Requeue waiters from one futex to another
FUTEX_REQUEUE :: Futex_Requeue_Type(.REQUEUE)
/// Requeue waiters from one futex to another if the value at mutex matches
FUTEX_CMP_REQUEUE :: Futex_Cmp_Requeue_Type(.CMP_REQUEUE)
/// See man pages, I'm not describing it here
FUTEX_WAKE_OP :: Futex_Wake_Op_Type(.WAKE_OP)
/// Wait on a futex, but the value is a bitset
FUTEX_WAIT_BITSET :: Futex_Wait_Bitset_Type(.WAIT_BITSET)
/// Wait on a futex, but the value is a bitset
FUTEX_WAKE_BITSET :: Futex_Wake_Bitset_Type(.WAKE_BITSET)
// TODO(flysand): Priority inversion futexes
FUTEX_LOCK_PI :: Futex_Lock_Pi_Type(.LOCK_PI)
FUTEX_UNLOCK_PI :: Futex_Unlock_Pi_Type(.UNLOCK_PI)
FUTEX_TRYLOCK_PI :: Futex_Trylock_Pi_Type(.TRYLOCK_PI)
FUTEX_WAIT_REQUEUE_PI :: Futex_Wait_requeue_Pi_Type(.WAIT_REQUEUE_PI)
FUTEX_CMP_REQUEUE_PI :: Futex_Cmp_requeue_Pi_Type(.CMP_REQUEUE_PI)
FUTEX_LOCK_PI2 :: Futex_Lock_Pi2_Type(.LOCK_PI2)

150
core/sys/linux/helpers.odin Normal file
View File

@@ -0,0 +1,150 @@
//+build linux
package linux
import "core:intrinsics"
// Note(flysand): In the case of syscall let's get rid of extra
// casting. First of all, let these syscalls return int, because
// we'll need to check for Errno anyway. Second of all
// most parameters are going to be trivially-castable to
// uintptr, so we'll have that.
@(private)
syscall0 :: #force_inline proc "contextless" (nr: uintptr) -> int {
return cast(int) intrinsics.syscall(nr)
}
@(private)
syscall1 :: #force_inline proc "contextless" (nr: uintptr, p1: $T) -> int
where
size_of(p1) <= size_of(uintptr)
{
return cast(int) intrinsics.syscall(nr, cast(uintptr) p1)
}
@(private)
syscall2 :: #force_inline proc "contextless" (nr: uintptr,p1: $T1, p2: $T2) -> int
where
size_of(p1) <= size_of(uintptr) &&
size_of(p2) <= size_of(uintptr)
{
return cast(int) intrinsics.syscall(nr,
cast(uintptr) p1, cast(uintptr) p2)
}
@(private)
syscall3 :: #force_inline proc "contextless" (nr: uintptr, p1: $T1, p2: $T2, p3: $T3) -> int
where
size_of(p1) <= size_of(uintptr) &&
size_of(p2) <= size_of(uintptr) &&
size_of(p3) <= size_of(uintptr)
{
return cast(int) intrinsics.syscall(nr,
cast(uintptr) p1,
cast(uintptr) p2,
cast(uintptr) p3)
}
@(private)
syscall4 :: #force_inline proc "contextless" (nr: uintptr, p1: $T1, p2: $T2, p3: $T3, p4: $T4) -> int
where
size_of(p1) <= size_of(uintptr) &&
size_of(p2) <= size_of(uintptr) &&
size_of(p3) <= size_of(uintptr) &&
size_of(p4) <= size_of(uintptr)
{
return cast(int) intrinsics.syscall(nr,
cast(uintptr) p1,
cast(uintptr) p2,
cast(uintptr) p3,
cast(uintptr) p4)
}
@(private)
syscall5 :: #force_inline proc "contextless" (nr: uintptr, p1: $T1, p2: $T2, p3: $T3, p4: $T4, p5: $T5) -> int
where
size_of(p1) <= size_of(uintptr) &&
size_of(p2) <= size_of(uintptr) &&
size_of(p3) <= size_of(uintptr) &&
size_of(p4) <= size_of(uintptr) &&
size_of(p5) <= size_of(uintptr)
{
return cast(int) intrinsics.syscall(nr,
cast(uintptr) p1,
cast(uintptr) p2,
cast(uintptr) p3,
cast(uintptr) p4,
cast(uintptr) p5)
}
@(private)
syscall6 :: #force_inline proc "contextless" (nr: uintptr, p1: $T1, p2: $T2, p3: $T3, p4: $T4, p5: $T5, p6: $T6) -> int
where
size_of(p1) <= size_of(uintptr) &&
size_of(p2) <= size_of(uintptr) &&
size_of(p3) <= size_of(uintptr) &&
size_of(p4) <= size_of(uintptr) &&
size_of(p5) <= size_of(uintptr) &&
size_of(p6) <= size_of(uintptr)
{
return cast(int) intrinsics.syscall(nr,
cast(uintptr) p1,
cast(uintptr) p2,
cast(uintptr) p3,
cast(uintptr) p4,
cast(uintptr) p5,
cast(uintptr) p6)
}
syscall :: proc {syscall0, syscall1, syscall2, syscall3, syscall4, syscall5, syscall6}
// Note(bumbread): This should shrug off a few lines from every syscall.
// Since not any type can be trivially casted to another type, we take two arguments:
// the final type to cast to, and the type to transmute to before casting.
// One transmute + one cast should allow us to get to any type we might want
// to return from a syscall wrapper.
@(private)
errno_unwrap3 :: #force_inline proc "contextless" (ret: $P, $T: typeid, $U: typeid) -> (T, Errno)
where
intrinsics.type_is_ordered_numeric(P)
{
if ret < 0 {
default_value: T
return default_value, Errno(-ret)
} else {
return cast(T) transmute(U) ret, Errno(.NONE)
}
}
@(private)
errno_unwrap2 :: #force_inline proc "contextless" (ret: $P, $T: typeid) -> (T, Errno) {
if ret < 0 {
default_value: T
return default_value, Errno(-ret)
} else {
return cast(T) ret, Errno(.NONE)
}
}
@(private)
errno_unwrap :: proc {errno_unwrap2, errno_unwrap3}
// Note(flysand): 32-bit architectures sometimes take in a 64-bit argument in a
// register pair. This function should help me avoid typing the same code a few times..
when size_of(int) == 4 {
// xxx64 system calls take some parameters as pairs of ulongs rather than a single pointer
@(private)
compat64_arg_pair :: #force_inline proc "contextless" (a: i64) -> (hi: uint, lo: uint) {
no_sign := uint(a)
hi = uint(no_sign >> 32)
lo = uint(no_sign & 0xffff_ffff)
return
}
} else {
// ... and on 64-bit architectures it's just a long
@(private)
compat64_arg_pair :: #force_inline proc "contextless" (a: i64) -> (uint) {
return uint(a)
}
}

2038
core/sys/linux/sys.odin Normal file
View File

File diff suppressed because it is too large Load Diff

373
core/sys/linux/syscall_amd64.odin Normal file
View File

@@ -0,0 +1,373 @@
//+build amd64
package linux
// AMD64 uses the new way to define syscalls, i.e. one that
// is different from the other architectures. Instead of using
// a .tbl file, they define constants to tell which syscalls they
// want and then include a generic unistd.h file.
SYS_read :: uintptr(0)
SYS_write :: uintptr(1)
SYS_open :: uintptr(2)
SYS_close :: uintptr(3)
SYS_stat :: uintptr(4)
SYS_fstat :: uintptr(5)
SYS_lstat :: uintptr(6)
SYS_poll :: uintptr(7)
SYS_lseek :: uintptr(8)
SYS_mmap :: uintptr(9)
SYS_mprotect :: uintptr(10)
SYS_munmap :: uintptr(11)
SYS_brk :: uintptr(12)
SYS_rt_sigaction :: uintptr(13)
SYS_rt_sigprocmask :: uintptr(14)
SYS_rt_sigreturn :: uintptr(15)
SYS_ioctl :: uintptr(16)
SYS_pread64 :: uintptr(17)
SYS_pwrite64 :: uintptr(18)
SYS_readv :: uintptr(19)
SYS_writev :: uintptr(20)
SYS_access :: uintptr(21)
SYS_pipe :: uintptr(22)
SYS_select :: uintptr(23)
SYS_sched_yield :: uintptr(24)
SYS_mremap :: uintptr(25)
SYS_msync :: uintptr(26)
SYS_mincore :: uintptr(27)
SYS_madvise :: uintptr(28)
SYS_shmget :: uintptr(29)
SYS_shmat :: uintptr(30)
SYS_shmctl :: uintptr(31)
SYS_dup :: uintptr(32)
SYS_dup2 :: uintptr(33)
SYS_pause :: uintptr(34)
SYS_nanosleep :: uintptr(35)
SYS_getitimer :: uintptr(36)
SYS_alarm :: uintptr(37)
SYS_setitimer :: uintptr(38)
SYS_getpid :: uintptr(39)
SYS_sendfile :: uintptr(40)
SYS_socket :: uintptr(41)
SYS_connect :: uintptr(42)
SYS_accept :: uintptr(43)
SYS_sendto :: uintptr(44)
SYS_recvfrom :: uintptr(45)
SYS_sendmsg :: uintptr(46)
SYS_recvmsg :: uintptr(47)
SYS_shutdown :: uintptr(48)
SYS_bind :: uintptr(49)
SYS_listen :: uintptr(50)
SYS_getsockname :: uintptr(51)
SYS_getpeername :: uintptr(52)
SYS_socketpair :: uintptr(53)
SYS_setsockopt :: uintptr(54)
SYS_getsockopt :: uintptr(55)
SYS_clone :: uintptr(56)
SYS_fork :: uintptr(57)
SYS_vfork :: uintptr(58)
SYS_execve :: uintptr(59)
SYS_exit :: uintptr(60)
SYS_wait4 :: uintptr(61)
SYS_kill :: uintptr(62)
SYS_uname :: uintptr(63)
SYS_semget :: uintptr(64)
SYS_semop :: uintptr(65)
SYS_semctl :: uintptr(66)
SYS_shmdt :: uintptr(67)
SYS_msgget :: uintptr(68)
SYS_msgsnd :: uintptr(69)
SYS_msgrcv :: uintptr(70)
SYS_msgctl :: uintptr(71)
SYS_fcntl :: uintptr(72)
SYS_flock :: uintptr(73)
SYS_fsync :: uintptr(74)
SYS_fdatasync :: uintptr(75)
SYS_truncate :: uintptr(76)
SYS_ftruncate :: uintptr(77)
SYS_getdents :: uintptr(78)
SYS_getcwd :: uintptr(79)
SYS_chdir :: uintptr(80)
SYS_fchdir :: uintptr(81)
SYS_rename :: uintptr(82)
SYS_mkdir :: uintptr(83)
SYS_rmdir :: uintptr(84)
SYS_creat :: uintptr(85)
SYS_link :: uintptr(86)
SYS_unlink :: uintptr(87)
SYS_symlink :: uintptr(88)
SYS_readlink :: uintptr(89)
SYS_chmod :: uintptr(90)
SYS_fchmod :: uintptr(91)
SYS_chown :: uintptr(92)
SYS_fchown :: uintptr(93)
SYS_lchown :: uintptr(94)
SYS_umask :: uintptr(95)
SYS_gettimeofday :: uintptr(96)
SYS_getrlimit :: uintptr(97)
SYS_getrusage :: uintptr(98)
SYS_sysinfo :: uintptr(99)
SYS_times :: uintptr(100)
SYS_ptrace :: uintptr(101)
SYS_getuid :: uintptr(102)
SYS_syslog :: uintptr(103)
SYS_getgid :: uintptr(104)
SYS_setuid :: uintptr(105)
SYS_setgid :: uintptr(106)
SYS_geteuid :: uintptr(107)
SYS_getegid :: uintptr(108)
SYS_setpgid :: uintptr(109)
SYS_getppid :: uintptr(110)
SYS_getpgrp :: uintptr(111)
SYS_setsid :: uintptr(112)
SYS_setreuid :: uintptr(113)
SYS_setregid :: uintptr(114)
SYS_getgroups :: uintptr(115)
SYS_setgroups :: uintptr(116)
SYS_setresuid :: uintptr(117)
SYS_getresuid :: uintptr(118)
SYS_setresgid :: uintptr(119)
SYS_getresgid :: uintptr(120)
SYS_getpgid :: uintptr(121)
SYS_setfsuid :: uintptr(122)
SYS_setfsgid :: uintptr(123)
SYS_getsid :: uintptr(124)
SYS_capget :: uintptr(125)
SYS_capset :: uintptr(126)
SYS_rt_sigpending :: uintptr(127)
SYS_rt_sigtimedwait :: uintptr(128)
SYS_rt_sigqueueinfo :: uintptr(129)
SYS_rt_sigsuspend :: uintptr(130)
SYS_sigaltstack :: uintptr(131)
SYS_utime :: uintptr(132)
SYS_mknod :: uintptr(133)
SYS_uselib :: uintptr(134)
SYS_personality :: uintptr(135)
SYS_ustat :: uintptr(136)
SYS_statfs :: uintptr(137)
SYS_fstatfs :: uintptr(138)
SYS_sysfs :: uintptr(139)
SYS_getpriority :: uintptr(140)
SYS_setpriority :: uintptr(141)
SYS_sched_setparam :: uintptr(142)
SYS_sched_getparam :: uintptr(143)
SYS_sched_setscheduler :: uintptr(144)
SYS_sched_getscheduler :: uintptr(145)
SYS_sched_get_priority_max :: uintptr(146)
SYS_sched_get_priority_min :: uintptr(147)
SYS_sched_rr_get_interval :: uintptr(148)
SYS_mlock :: uintptr(149)
SYS_munlock :: uintptr(150)
SYS_mlockall :: uintptr(151)
SYS_munlockall :: uintptr(152)
SYS_vhangup :: uintptr(153)
SYS_modify_ldt :: uintptr(154)
SYS_pivot_root :: uintptr(155)
SYS__sysctl :: uintptr(156)
SYS_prctl :: uintptr(157)
SYS_arch_prctl :: uintptr(158)
SYS_adjtimex :: uintptr(159)
SYS_setrlimit :: uintptr(160)
SYS_chroot :: uintptr(161)
SYS_sync :: uintptr(162)
SYS_acct :: uintptr(163)
SYS_settimeofday :: uintptr(164)
SYS_mount :: uintptr(165)
SYS_umount2 :: uintptr(166)
SYS_swapon :: uintptr(167)
SYS_swapoff :: uintptr(168)
SYS_reboot :: uintptr(169)
SYS_sethostname :: uintptr(170)
SYS_setdomainname :: uintptr(171)
SYS_iopl :: uintptr(172)
SYS_ioperm :: uintptr(173)
SYS_create_module :: uintptr(174)
SYS_init_module :: uintptr(175)
SYS_delete_module :: uintptr(176)
SYS_get_kernel_syms :: uintptr(177)
SYS_query_module :: uintptr(178)
SYS_quotactl :: uintptr(179)
SYS_nfsservctl :: uintptr(180)
SYS_getpmsg :: uintptr(181)
SYS_putpmsg :: uintptr(182)
SYS_afs_syscall :: uintptr(183)
SYS_tuxcall :: uintptr(184)
SYS_security :: uintptr(185)
SYS_gettid :: uintptr(186)
SYS_readahead :: uintptr(187)
SYS_setxattr :: uintptr(188)
SYS_lsetxattr :: uintptr(189)
SYS_fsetxattr :: uintptr(190)
SYS_getxattr :: uintptr(191)
SYS_lgetxattr :: uintptr(192)
SYS_fgetxattr :: uintptr(193)
SYS_listxattr :: uintptr(194)
SYS_llistxattr :: uintptr(195)
SYS_flistxattr :: uintptr(196)
SYS_removexattr :: uintptr(197)
SYS_lremovexattr :: uintptr(198)
SYS_fremovexattr :: uintptr(199)
SYS_tkill :: uintptr(200)
SYS_time :: uintptr(201)
SYS_futex :: uintptr(202)
SYS_sched_setaffinity :: uintptr(203)
SYS_sched_getaffinity :: uintptr(204)
SYS_set_thread_area :: uintptr(205)
SYS_io_setup :: uintptr(206)
SYS_io_destroy :: uintptr(207)
SYS_io_getevents :: uintptr(208)
SYS_io_submit :: uintptr(209)
SYS_io_cancel :: uintptr(210)
SYS_get_thread_area :: uintptr(211)
SYS_lookup_dcookie :: uintptr(212)
SYS_epoll_create :: uintptr(213)
SYS_epoll_ctl_old :: uintptr(214)
SYS_epoll_wait_old :: uintptr(215)
SYS_remap_file_pages :: uintptr(216)
SYS_getdents64 :: uintptr(217)
SYS_set_tid_address :: uintptr(218)
SYS_restart_syscall :: uintptr(219)
SYS_semtimedop :: uintptr(220)
SYS_fadvise64 :: uintptr(221)
SYS_timer_create :: uintptr(222)
SYS_timer_settime :: uintptr(223)
SYS_timer_gettime :: uintptr(224)
SYS_timer_getoverrun :: uintptr(225)
SYS_timer_delete :: uintptr(226)
SYS_clock_settime :: uintptr(227)
SYS_clock_gettime :: uintptr(228)
SYS_clock_getres :: uintptr(229)
SYS_clock_nanosleep :: uintptr(230)
SYS_exit_group :: uintptr(231)
SYS_epoll_wait :: uintptr(232)
SYS_epoll_ctl :: uintptr(233)
SYS_tgkill :: uintptr(234)
SYS_utimes :: uintptr(235)
SYS_vserver :: uintptr(236)
SYS_mbind :: uintptr(237)
SYS_set_mempolicy :: uintptr(238)
SYS_get_mempolicy :: uintptr(239)
SYS_mq_open :: uintptr(240)
SYS_mq_unlink :: uintptr(241)
SYS_mq_timedsend :: uintptr(242)
SYS_mq_timedreceive :: uintptr(243)
SYS_mq_notify :: uintptr(244)
SYS_mq_getsetattr :: uintptr(245)
SYS_kexec_load :: uintptr(246)
SYS_waitid :: uintptr(247)
SYS_add_key :: uintptr(248)
SYS_request_key :: uintptr(249)
SYS_keyctl :: uintptr(250)
SYS_ioprio_set :: uintptr(251)
SYS_ioprio_get :: uintptr(252)
SYS_inotify_init :: uintptr(253)
SYS_inotify_add_watch :: uintptr(254)
SYS_inotify_rm_watch :: uintptr(255)
SYS_migrate_pages :: uintptr(256)
SYS_openat :: uintptr(257)
SYS_mkdirat :: uintptr(258)
SYS_mknodat :: uintptr(259)
SYS_fchownat :: uintptr(260)
SYS_futimesat :: uintptr(261)
SYS_newfstatat :: uintptr(262)
SYS_unlinkat :: uintptr(263)
SYS_renameat :: uintptr(264)
SYS_linkat :: uintptr(265)
SYS_symlinkat :: uintptr(266)
SYS_readlinkat :: uintptr(267)
SYS_fchmodat :: uintptr(268)
SYS_faccessat :: uintptr(269)
SYS_pselect6 :: uintptr(270)
SYS_ppoll :: uintptr(271)
SYS_unshare :: uintptr(272)
SYS_set_robust_list :: uintptr(273)
SYS_get_robust_list :: uintptr(274)
SYS_splice :: uintptr(275)
SYS_tee :: uintptr(276)
SYS_sync_file_range :: uintptr(277)
SYS_vmsplice :: uintptr(278)
SYS_move_pages :: uintptr(279)
SYS_utimensat :: uintptr(280)
SYS_epoll_pwait :: uintptr(281)
SYS_signalfd :: uintptr(282)
SYS_timerfd_create :: uintptr(283)
SYS_eventfd :: uintptr(284)
SYS_fallocate :: uintptr(285)
SYS_timerfd_settime :: uintptr(286)
SYS_timerfd_gettime :: uintptr(287)
SYS_accept4 :: uintptr(288)
SYS_signalfd4 :: uintptr(289)
SYS_eventfd2 :: uintptr(290)
SYS_epoll_create1 :: uintptr(291)
SYS_dup3 :: uintptr(292)
SYS_pipe2 :: uintptr(293)
SYS_inotify_init1 :: uintptr(294)
SYS_preadv :: uintptr(295)
SYS_pwritev :: uintptr(296)
SYS_rt_tgsigqueueinfo :: uintptr(297)
SYS_perf_event_open :: uintptr(298)
SYS_recvmmsg :: uintptr(299)
SYS_fanotify_init :: uintptr(300)
SYS_fanotify_mark :: uintptr(301)
SYS_prlimit64 :: uintptr(302)
SYS_name_to_handle_at :: uintptr(303)
SYS_open_by_handle_at :: uintptr(304)
SYS_clock_adjtime :: uintptr(305)
SYS_syncfs :: uintptr(306)
SYS_sendmmsg :: uintptr(307)
SYS_setns :: uintptr(308)
SYS_getcpu :: uintptr(309)
SYS_process_vm_readv :: uintptr(310)
SYS_process_vm_writev :: uintptr(311)
SYS_kcmp :: uintptr(312)
SYS_finit_module :: uintptr(313)
SYS_sched_setattr :: uintptr(314)
SYS_sched_getattr :: uintptr(315)
SYS_renameat2 :: uintptr(316)
SYS_seccomp :: uintptr(317)
SYS_getrandom :: uintptr(318)
SYS_memfd_create :: uintptr(319)
SYS_kexec_file_load :: uintptr(320)
SYS_bpf :: uintptr(321)
SYS_execveat :: uintptr(322)
SYS_userfaultfd :: uintptr(323)
SYS_membarrier :: uintptr(324)
SYS_mlock2 :: uintptr(325)
SYS_copy_file_range :: uintptr(326)
SYS_preadv2 :: uintptr(327)
SYS_pwritev2 :: uintptr(328)
SYS_pkey_mprotect :: uintptr(329)
SYS_pkey_alloc :: uintptr(330)
SYS_pkey_free :: uintptr(331)
SYS_statx :: uintptr(332)
SYS_io_pgetevents :: uintptr(333)
SYS_rseq :: uintptr(334)
SYS_pidfd_send_signal :: uintptr(424)
SYS_io_uring_setup :: uintptr(425)
SYS_io_uring_enter :: uintptr(426)
SYS_io_uring_register :: uintptr(427)
SYS_open_tree :: uintptr(428)
SYS_move_mount :: uintptr(429)
SYS_fsopen :: uintptr(430)
SYS_fsconfig :: uintptr(431)
SYS_fsmount :: uintptr(432)
SYS_fspick :: uintptr(433)
SYS_pidfd_open :: uintptr(434)
SYS_clone3 :: uintptr(435)
SYS_close_range :: uintptr(436)
SYS_openat2 :: uintptr(437)
SYS_pidfd_getfd :: uintptr(438)
SYS_faccessat2 :: uintptr(439)
SYS_process_madvise :: uintptr(440)
SYS_epoll_pwait2 :: uintptr(441)
SYS_mount_setattr :: uintptr(442)
SYS_quotactl_fd :: uintptr(443)
SYS_landlock_create_ruleset :: uintptr(444)
SYS_landlock_add_rule :: uintptr(445)
SYS_landlock_restrict_self :: uintptr(446)
SYS_memfd_secret :: uintptr(447)
SYS_process_mrelease :: uintptr(448)
SYS_futex_waitv :: uintptr(449)
SYS_set_mempolicy_home_node :: uintptr(450)
SYS_cachestat :: uintptr(451)
SYS_fchmodat2 :: uintptr(452)
SYS_map_shadow_stack :: uintptr(453)

470
core/sys/linux/syscall_arm32.odin Normal file
View File

@@ -0,0 +1,470 @@
//+build arm32
package linux
// This file was taken and transformed from
// /arch/arm/tools/syscall.tbl
// in linux headers. OABI and EABI syscalls
// are included.
// TODO(bumbread, 2023-10-13): I'm not sure whether I have used
// the right syscall table. ARM64 stuff seems to be also compatible
// with ARM32, I'm not sure whether ARM32 also uses the new way of
// defining the syscall table, and this one is just for compatibility..?
// This syscall is not meant to be used by userspace
SYS_restart_syscall :: uintptr(0)
SYS_exit :: uintptr(1)
SYS_fork :: uintptr(2)
SYS_read :: uintptr(3)
SYS_write :: uintptr(4)
SYS_open :: uintptr(5)
SYS_close :: uintptr(6)
// 7 was sys_waitpid
SYS_creat :: uintptr(8)
SYS_link :: uintptr(9)
SYS_unlink :: uintptr(10)
SYS_execve :: uintptr(11)
SYS_chdir :: uintptr(12)
SYS_time :: uintptr(13)
SYS_mknod :: uintptr(14)
SYS_chmod :: uintptr(15)
SYS_lchown :: uintptr(16)
// 17 was sys_break
// 18 was sys_stat
SYS_lseek :: uintptr(19)
SYS_getpid :: uintptr(20)
SYS_mount :: uintptr(21)
SYS_umount :: uintptr(22)
SYS_setuid :: uintptr(23)
SYS_getuid :: uintptr(24)
SYS_stime :: uintptr(25)
SYS_ptrace :: uintptr(26)
SYS_alarm :: uintptr(27)
// 28 was sys_fstat
SYS_pause :: uintptr(29)
SYS_utime :: uintptr(30)
// 31 was sys_stty
// 32 was sys_gtty
SYS_access :: uintptr(33)
SYS_nice :: uintptr(34)
// 35 was sys_ftime
SYS_sync :: uintptr(36)
SYS_kill :: uintptr(37)
SYS_rename :: uintptr(38)
SYS_mkdir :: uintptr(39)
SYS_rmdir :: uintptr(40)
SYS_dup :: uintptr(41)
SYS_pipe :: uintptr(42)
SYS_times :: uintptr(43)
// 44 was sys_prof
SYS_brk :: uintptr(45)
SYS_setgid :: uintptr(46)
SYS_getgid :: uintptr(47)
// 48 was sys_signal
SYS_geteuid :: uintptr(49)
SYS_getegid :: uintptr(50)
SYS_acct :: uintptr(51)
SYS_umount2 :: uintptr(52)
// 53 was sys_lock
SYS_ioctl :: uintptr(54)
SYS_fcntl :: uintptr(55)
// 56 was sys_mpx
SYS_setpgid :: uintptr(57)
// 58 was sys_ulimit
// 59 was sys_olduname
SYS_umask :: uintptr(60)
SYS_chroot :: uintptr(61)
SYS_ustat :: uintptr(62)
SYS_dup2 :: uintptr(63)
SYS_getppid :: uintptr(64)
SYS_getpgrp :: uintptr(65)
SYS_setsid :: uintptr(66)
SYS_sigaction :: uintptr(67)
// 68 was sys_sgetmask
// 69 was sys_ssetmask
SYS_setreuid :: uintptr(70)
SYS_setregid :: uintptr(71)
SYS_sigsuspend :: uintptr(72)
SYS_sigpending :: uintptr(73)
SYS_sethostname :: uintptr(74)
SYS_setrlimit :: uintptr(75)
// Back compat 2GB limited rlimit
SYS_getrlimit :: uintptr(76)
SYS_getrusage :: uintptr(77)
SYS_gettimeofday :: uintptr(78)
SYS_settimeofday :: uintptr(79)
SYS_getgroups :: uintptr(80)
SYS_setgroups :: uintptr(81)
SYS_select :: uintptr(82)
SYS_symlink :: uintptr(83)
// 84 was sys_lstat
SYS_readlink :: uintptr(85)
SYS_uselib :: uintptr(86)
SYS_swapon :: uintptr(87)
SYS_reboot :: uintptr(88)
SYS_readdir :: uintptr(89)
SYS_mmap :: uintptr(90)
SYS_munmap :: uintptr(91)
SYS_truncate :: uintptr(92)
SYS_ftruncate :: uintptr(93)
SYS_fchmod :: uintptr(94)
SYS_fchown :: uintptr(95)
SYS_getpriority :: uintptr(96)
SYS_setpriority :: uintptr(97)
// 98 was sys_profil
SYS_statfs :: uintptr(99)
SYS_fstatfs :: uintptr(100)
// 101 was sys_ioperm
SYS_socketcall :: uintptr(102)
SYS_syslog :: uintptr(103)
SYS_setitimer :: uintptr(104)
SYS_getitimer :: uintptr(105)
SYS_stat :: uintptr(106)
SYS_lstat :: uintptr(107)
SYS_fstat :: uintptr(108)
// 109 was sys_uname
// 110 was sys_iopl
SYS_vhangup :: uintptr(111)
// 112 was sys_idle
// syscall to call a syscall!
SYS_syscall :: uintptr(113)
SYS_wait4 :: uintptr(114)
SYS_swapoff :: uintptr(115)
SYS_sysinfo :: uintptr(116)
SYS_ipc :: uintptr(117)
SYS_fsync :: uintptr(118)
SYS_sigreturn :: uintptr(119)
SYS_clone :: uintptr(120)
SYS_setdomainname :: uintptr(121)
SYS_uname :: uintptr(122)
// 123 was sys_modify_ldt
SYS_adjtimex :: uintptr(124)
SYS_mprotect :: uintptr(125)
SYS_sigprocmask :: uintptr(126)
// 127 was sys_create_module
SYS_init_module :: uintptr(128)
SYS_delete_module :: uintptr(129)
// 130 was sys_get_kernel_syms
SYS_quotactl :: uintptr(131)
SYS_getpgid :: uintptr(132)
SYS_fchdir :: uintptr(133)
SYS_bdflush :: uintptr(134)
SYS_sysfs :: uintptr(135)
SYS_personality :: uintptr(136)
// 137 was sys_afs_syscall
SYS_setfsuid :: uintptr(138)
SYS_setfsgid :: uintptr(139)
SYS__llseek :: uintptr(140)
SYS_getdents :: uintptr(141)
SYS__newselect :: uintptr(142)
SYS_flock :: uintptr(143)
SYS_msync :: uintptr(144)
SYS_readv :: uintptr(145)
SYS_writev :: uintptr(146)
SYS_getsid :: uintptr(147)
SYS_fdatasync :: uintptr(148)
SYS__sysctl :: uintptr(149)
SYS_mlock :: uintptr(150)
SYS_munlock :: uintptr(151)
SYS_mlockall :: uintptr(152)
SYS_munlockall :: uintptr(153)
SYS_sched_setparam :: uintptr(154)
SYS_sched_getparam :: uintptr(155)
SYS_sched_setscheduler :: uintptr(156)
SYS_sched_getscheduler :: uintptr(157)
SYS_sched_yield :: uintptr(158)
SYS_sched_get_priority_max :: uintptr(159)
SYS_sched_get_priority_min :: uintptr(160)
SYS_sched_rr_get_interval :: uintptr(161)
SYS_nanosleep :: uintptr(162)
SYS_mremap :: uintptr(163)
SYS_setresuid :: uintptr(164)
SYS_getresuid :: uintptr(165)
// 166 was sys_vm86
// 167 was sys_query_module
SYS_poll :: uintptr(168)
SYS_nfsservctl :: uintptr(169)
SYS_setresgid :: uintptr(170)
SYS_getresgid :: uintptr(171)
SYS_prctl :: uintptr(172)
SYS_rt_sigreturn :: uintptr(173)
SYS_rt_sigaction :: uintptr(174)
SYS_rt_sigprocmask :: uintptr(175)
SYS_rt_sigpending :: uintptr(176)
SYS_rt_sigtimedwait :: uintptr(177)
SYS_rt_sigqueueinfo :: uintptr(178)
SYS_rt_sigsuspend :: uintptr(179)
SYS_pread64 :: uintptr(180)
SYS_pwrite64 :: uintptr(181)
SYS_chown :: uintptr(182)
SYS_getcwd :: uintptr(183)
SYS_capget :: uintptr(184)
SYS_capset :: uintptr(185)
SYS_sigaltstack :: uintptr(186)
SYS_sendfile :: uintptr(187)
// 188 reserved
// 189 reserved
SYS_vfork :: uintptr(190)
// SuS compliant getrlimit
SYS_ugetrlimit :: uintptr(191)
SYS_mmap2 :: uintptr(192)
SYS_truncate64 :: uintptr(193)
SYS_ftruncate64 :: uintptr(194)
SYS_stat64 :: uintptr(195)
SYS_lstat64 :: uintptr(196)
SYS_fstat64 :: uintptr(197)
SYS_lchown32 :: uintptr(198)
SYS_getuid32 :: uintptr(199)
SYS_getgid32 :: uintptr(200)
SYS_geteuid32 :: uintptr(201)
SYS_getegid32 :: uintptr(202)
SYS_setreuid32 :: uintptr(203)
SYS_setregid32 :: uintptr(204)
SYS_getgroups32 :: uintptr(205)
SYS_setgroups32 :: uintptr(206)
SYS_fchown32 :: uintptr(207)
SYS_setresuid32 :: uintptr(208)
SYS_getresuid32 :: uintptr(209)
SYS_setresgid32 :: uintptr(210)
SYS_getresgid32 :: uintptr(211)
SYS_chown32 :: uintptr(212)
SYS_setuid32 :: uintptr(213)
SYS_setgid32 :: uintptr(214)
SYS_setfsuid32 :: uintptr(215)
SYS_setfsgid32 :: uintptr(216)
SYS_getdents64 :: uintptr(217)
SYS_pivot_root :: uintptr(218)
SYS_mincore :: uintptr(219)
SYS_madvise :: uintptr(220)
SYS_fcntl64 :: uintptr(221)
// 222 for tux
// 223 is unused
SYS_gettid :: uintptr(224)
SYS_readahead :: uintptr(225)
SYS_setxattr :: uintptr(226)
SYS_lsetxattr :: uintptr(227)
SYS_fsetxattr :: uintptr(228)
SYS_getxattr :: uintptr(229)
SYS_lgetxattr :: uintptr(230)
SYS_fgetxattr :: uintptr(231)
SYS_listxattr :: uintptr(232)
SYS_llistxattr :: uintptr(233)
SYS_flistxattr :: uintptr(234)
SYS_removexattr :: uintptr(235)
SYS_lremovexattr :: uintptr(236)
SYS_fremovexattr :: uintptr(237)
SYS_tkill :: uintptr(238)
SYS_sendfile64 :: uintptr(239)
SYS_futex :: uintptr(240)
SYS_sched_setaffinity :: uintptr(241)
SYS_sched_getaffinity :: uintptr(242)
SYS_io_setup :: uintptr(243)
SYS_io_destroy :: uintptr(244)
SYS_io_getevents :: uintptr(245)
SYS_io_submit :: uintptr(246)
SYS_io_cancel :: uintptr(247)
SYS_exit_group :: uintptr(248)
SYS_lookup_dcookie :: uintptr(249)
SYS_epoll_create :: uintptr(250)
SYS_epoll_ctl :: uintptr(251)
SYS_epoll_wait :: uintptr(252)
SYS_remap_file_pages :: uintptr(253)
// 254 for set_thread_area
// 255 for get_thread_area
SYS_set_tid_address :: uintptr(256)
SYS_timer_create :: uintptr(257)
SYS_timer_settime :: uintptr(258)
SYS_timer_gettime :: uintptr(259)
SYS_timer_getoverrun :: uintptr(260)
SYS_timer_delete :: uintptr(261)
SYS_clock_settime :: uintptr(262)
SYS_clock_gettime :: uintptr(263)
SYS_clock_getres :: uintptr(264)
SYS_clock_nanosleep :: uintptr(265)
SYS_statfs64 :: uintptr(266)
SYS_fstatfs64 :: uintptr(267)
SYS_tgkill :: uintptr(268)
SYS_utimes :: uintptr(269)
SYS_arm_fadvise64_64 :: uintptr(270)
SYS_pciconfig_iobase :: uintptr(271)
SYS_pciconfig_read :: uintptr(272)
SYS_pciconfig_write :: uintptr(273)
SYS_mq_open :: uintptr(274)
SYS_mq_unlink :: uintptr(275)
SYS_mq_timedsend :: uintptr(276)
SYS_mq_timedreceive :: uintptr(277)
SYS_mq_notify :: uintptr(278)
SYS_mq_getsetattr :: uintptr(279)
SYS_waitid :: uintptr(280)
SYS_socket :: uintptr(281)
SYS_bind :: uintptr(282)
SYS_connect :: uintptr(283)
SYS_listen :: uintptr(284)
SYS_accept :: uintptr(285)
SYS_getsockname :: uintptr(286)
SYS_getpeername :: uintptr(287)
SYS_socketpair :: uintptr(288)
SYS_send :: uintptr(289)
SYS_sendto :: uintptr(290)
SYS_recv :: uintptr(291)
SYS_recvfrom :: uintptr(292)
SYS_shutdown :: uintptr(293)
SYS_setsockopt :: uintptr(294)
SYS_getsockopt :: uintptr(295)
SYS_sendmsg :: uintptr(296)
SYS_recvmsg :: uintptr(297)
SYS_semop :: uintptr(298)
SYS_semget :: uintptr(299)
SYS_semctl :: uintptr(300)
SYS_msgsnd :: uintptr(301)
SYS_msgrcv :: uintptr(302)
SYS_msgget :: uintptr(303)
SYS_msgctl :: uintptr(304)
SYS_shmat :: uintptr(305)
SYS_shmdt :: uintptr(306)
SYS_shmget :: uintptr(307)
SYS_shmctl :: uintptr(308)
SYS_add_key :: uintptr(309)
SYS_request_key :: uintptr(310)
SYS_keyctl :: uintptr(311)
SYS_semtimedop :: uintptr(312)
SYS_vserver :: uintptr(313)
SYS_ioprio_set :: uintptr(314)
SYS_ioprio_get :: uintptr(315)
SYS_inotify_init :: uintptr(316)
SYS_inotify_add_watch :: uintptr(317)
SYS_inotify_rm_watch :: uintptr(318)
SYS_mbind :: uintptr(319)
SYS_get_mempolicy :: uintptr(320)
SYS_set_mempolicy :: uintptr(321)
SYS_openat :: uintptr(322)
SYS_mkdirat :: uintptr(323)
SYS_mknodat :: uintptr(324)
SYS_fchownat :: uintptr(325)
SYS_futimesat :: uintptr(326)
SYS_fstatat64 :: uintptr(327)
SYS_unlinkat :: uintptr(328)
SYS_renameat :: uintptr(329)
SYS_linkat :: uintptr(330)
SYS_symlinkat :: uintptr(331)
SYS_readlinkat :: uintptr(332)
SYS_fchmodat :: uintptr(333)
SYS_faccessat :: uintptr(334)
SYS_pselect6 :: uintptr(335)
SYS_ppoll :: uintptr(336)
SYS_unshare :: uintptr(337)
SYS_set_robust_list :: uintptr(338)
SYS_get_robust_list :: uintptr(339)
SYS_splice :: uintptr(340)
SYS_arm_sync_file_range :: uintptr(341)
SYS_tee :: uintptr(342)
SYS_vmsplice :: uintptr(343)
SYS_move_pages :: uintptr(344)
SYS_getcpu :: uintptr(345)
SYS_epoll_pwait :: uintptr(346)
SYS_kexec_load :: uintptr(347)
SYS_utimensat :: uintptr(348)
SYS_signalfd :: uintptr(349)
SYS_timerfd_create :: uintptr(350)
SYS_eventfd :: uintptr(351)
SYS_fallocate :: uintptr(352)
SYS_timerfd_settime :: uintptr(353)
SYS_timerfd_gettime :: uintptr(354)
SYS_signalfd4 :: uintptr(355)
SYS_eventfd2 :: uintptr(356)
SYS_epoll_create1 :: uintptr(357)
SYS_dup3 :: uintptr(358)
SYS_pipe2 :: uintptr(359)
SYS_inotify_init1 :: uintptr(360)
SYS_preadv :: uintptr(361)
SYS_pwritev :: uintptr(362)
SYS_rt_tgsigqueueinfo :: uintptr(363)
SYS_perf_event_open :: uintptr(364)
SYS_recvmmsg :: uintptr(365)
SYS_accept4 :: uintptr(366)
SYS_fanotify_init :: uintptr(367)
SYS_fanotify_mark :: uintptr(368)
SYS_prlimit64 :: uintptr(369)
SYS_name_to_handle_at :: uintptr(370)
SYS_open_by_handle_at :: uintptr(371)
SYS_clock_adjtime :: uintptr(372)
SYS_syncfs :: uintptr(373)
SYS_sendmmsg :: uintptr(374)
SYS_setns :: uintptr(375)
SYS_process_vm_readv :: uintptr(376)
SYS_process_vm_writev :: uintptr(377)
SYS_kcmp :: uintptr(378)
SYS_finit_module :: uintptr(379)
SYS_sched_setattr :: uintptr(380)
SYS_sched_getattr :: uintptr(381)
SYS_renameat2 :: uintptr(382)
SYS_seccomp :: uintptr(383)
SYS_getrandom :: uintptr(384)
SYS_memfd_create :: uintptr(385)
SYS_bpf :: uintptr(386)
SYS_execveat :: uintptr(387)
SYS_userfaultfd :: uintptr(388)
SYS_membarrier :: uintptr(389)
SYS_mlock2 :: uintptr(390)
SYS_copy_file_range :: uintptr(391)
SYS_preadv2 :: uintptr(392)
SYS_pwritev2 :: uintptr(393)
SYS_pkey_mprotect :: uintptr(394)
SYS_pkey_alloc :: uintptr(395)
SYS_pkey_free :: uintptr(396)
SYS_statx :: uintptr(397)
SYS_rseq :: uintptr(398)
SYS_io_pgetevents :: uintptr(399)
SYS_migrate_pages :: uintptr(400)
SYS_kexec_file_load :: uintptr(401)
// 402 is unused
SYS_clock_gettime64 :: uintptr(403)
SYS_clock_settime64 :: uintptr(404)
SYS_clock_adjtime64 :: uintptr(405)
SYS_clock_getres_time64 :: uintptr(406)
SYS_clock_nanosleep_time64 :: uintptr(407)
SYS_timer_gettime64 :: uintptr(408)
SYS_timer_settime64 :: uintptr(409)
SYS_timerfd_gettime64 :: uintptr(410)
SYS_timerfd_settime64 :: uintptr(411)
SYS_utimensat_time64 :: uintptr(412)
SYS_pselect6_time64 :: uintptr(413)
SYS_ppoll_time64 :: uintptr(414)
SYS_io_pgetevents_time64 :: uintptr(416)
SYS_recvmmsg_time64 :: uintptr(417)
SYS_mq_timedsend_time64 :: uintptr(418)
SYS_mq_timedreceive_time64 :: uintptr(419)
SYS_semtimedop_time64 :: uintptr(420)
SYS_rt_sigtimedwait_time64 :: uintptr(421)
SYS_futex_time64 :: uintptr(422)
SYS_sched_rr_get_interval_time64:: uintptr(423)
SYS_pidfd_send_signal :: uintptr(424)
SYS_io_uring_setup :: uintptr(425)
SYS_io_uring_enter :: uintptr(426)
SYS_io_uring_register :: uintptr(427)
SYS_open_tree :: uintptr(428)
SYS_move_mount :: uintptr(429)
SYS_fsopen :: uintptr(430)
SYS_fsconfig :: uintptr(431)
SYS_fsmount :: uintptr(432)
SYS_fspick :: uintptr(433)
SYS_pidfd_open :: uintptr(434)
SYS_clone3 :: uintptr(435)
SYS_close_range :: uintptr(436)
SYS_openat2 :: uintptr(437)
SYS_pidfd_getfd :: uintptr(438)
SYS_faccessat2 :: uintptr(439)
SYS_process_madvise :: uintptr(440)
SYS_epoll_pwait2 :: uintptr(441)
SYS_mount_setattr :: uintptr(442)
SYS_quotactl_fd :: uintptr(443)
SYS_landlock_create_ruleset :: uintptr(444)
SYS_landlock_add_rule :: uintptr(445)
SYS_landlock_restrict_self :: uintptr(446)
// 447 reserved for memfd_secret
SYS_process_mrelease :: uintptr(448)
SYS_futex_waitv :: uintptr(449)
SYS_set_mempolicy_home_node :: uintptr(450)
SYS_cachestat :: uintptr(451)
SYS_fchmodat2 :: uintptr(452)

321
core/sys/linux/syscall_arm64.odin Normal file
View File

@@ -0,0 +1,321 @@
//+build arm64
package linux
// Syscalls for arm64 are defined using the new way, i.e. differently from
// the other platforms. It defines a few constants representing which optional
// syscalls it wants and includes the generic unistd.h file.
SYS_io_setup :: uintptr(0)
SYS_io_destroy :: uintptr(1)
SYS_io_submit :: uintptr(2)
SYS_io_cancel :: uintptr(3)
// time32 syscall
SYS_io_getevents :: uintptr(4)
SYS_setxattr :: uintptr(5)
SYS_lsetxattr :: uintptr(6)
SYS_fsetxattr :: uintptr(7)
SYS_getxattr :: uintptr(8)
SYS_lgetxattr :: uintptr(9)
SYS_fgetxattr :: uintptr(10)
SYS_listxattr :: uintptr(11)
SYS_llistxattr :: uintptr(12)
SYS_flistxattr :: uintptr(13)
SYS_removexattr :: uintptr(14)
SYS_lremovexattr :: uintptr(15)
SYS_fremovexattr :: uintptr(16)
SYS_getcwd :: uintptr(17)
SYS_lookup_dcookie :: uintptr(18)
SYS_eventfd2 :: uintptr(19)
SYS_epoll_create1 :: uintptr(20)
SYS_epoll_ctl :: uintptr(21)
SYS_epoll_pwait :: uintptr(22)
SYS_dup :: uintptr(23)
SYS_dup3 :: uintptr(24)
SYS_fcntl :: uintptr(25)
SYS_inotify_init1 :: uintptr(26)
SYS_inotify_add_watch :: uintptr(27)
SYS_inotify_rm_watch :: uintptr(28)
SYS_ioctl :: uintptr(29)
SYS_ioprio_set :: uintptr(30)
SYS_ioprio_get :: uintptr(31)
SYS_flock :: uintptr(32)
SYS_mknodat :: uintptr(33)
SYS_mkdirat :: uintptr(34)
SYS_unlinkat :: uintptr(35)
SYS_symlinkat :: uintptr(36)
SYS_linkat :: uintptr(37)
SYS_renameat :: uintptr(38)
SYS_umount2 :: uintptr(39)
SYS_mount :: uintptr(40)
SYS_pivot_root :: uintptr(41)
SYS_nfsservctl :: uintptr(42)
SYS_statfs :: uintptr(43)
SYS_fstatfs :: uintptr(44)
SYS_truncate :: uintptr(45)
SYS_ftruncate :: uintptr(46)
SYS_fallocate :: uintptr(47)
SYS_faccessat :: uintptr(48)
SYS_chdir :: uintptr(49)
SYS_fchdir :: uintptr(50)
SYS_chroot :: uintptr(51)
SYS_fchmod :: uintptr(52)
SYS_fchmodat :: uintptr(53)
SYS_fchownat :: uintptr(54)
SYS_fchown :: uintptr(55)
SYS_openat :: uintptr(56)
SYS_close :: uintptr(57)
SYS_vhangup :: uintptr(58)
SYS_pipe2 :: uintptr(59)
SYS_quotactl :: uintptr(60)
SYS_getdents64 :: uintptr(61)
SYS_lseek :: uintptr(62)
SYS_read :: uintptr(63)
SYS_write :: uintptr(64)
SYS_readv :: uintptr(65)
SYS_writev :: uintptr(66)
SYS_pread64 :: uintptr(67)
SYS_pwrite64 :: uintptr(68)
SYS_preadv :: uintptr(69)
SYS_pwritev :: uintptr(70)
SYS_sendfile :: uintptr(71)
SYS_pselect6 :: uintptr(72)
SYS_ppoll :: uintptr(73)
SYS_signalfd4 :: uintptr(74)
SYS_vmsplice :: uintptr(75)
SYS_splice :: uintptr(76)
SYS_tee :: uintptr(77)
SYS_readlinkat :: uintptr(78)
SYS_fstatat :: uintptr(79)
SYS_fstat :: uintptr(80)
SYS_sync :: uintptr(81)
SYS_fsync :: uintptr(82)
SYS_fdatasync :: uintptr(83)
SYS_sync_file_range :: uintptr(84)
SYS_timerfd_create :: uintptr(85)
SYS_timerfd_settime :: uintptr(86)
SYS_timerfd_gettime :: uintptr(87)
SYS_utimensat :: uintptr(88)
SYS_acct :: uintptr(89)
SYS_capget :: uintptr(90)
SYS_capset :: uintptr(91)
SYS_personality :: uintptr(92)
SYS_exit :: uintptr(93)
SYS_exit_group :: uintptr(94)
SYS_waitid :: uintptr(95)
SYS_set_tid_address :: uintptr(96)
SYS_unshare :: uintptr(97)
SYS_futex :: uintptr(98)
SYS_set_robust_list :: uintptr(99)
SYS_get_robust_list :: uintptr(100)
SYS_nanosleep :: uintptr(101)
SYS_getitimer :: uintptr(102)
SYS_setitimer :: uintptr(103)
SYS_kexec_load :: uintptr(104)
SYS_init_module :: uintptr(105)
SYS_delete_module :: uintptr(106)
SYS_timer_create :: uintptr(107)
SYS_timer_gettime :: uintptr(108)
SYS_timer_getoverrun :: uintptr(109)
SYS_timer_settime :: uintptr(110)
SYS_timer_delete :: uintptr(111)
SYS_clock_settime :: uintptr(112)
SYS_clock_gettime :: uintptr(113)
SYS_clock_getres :: uintptr(114)
SYS_clock_nanosleep :: uintptr(115)
SYS_syslog :: uintptr(116)
SYS_ptrace :: uintptr(117)
SYS_sched_setparam :: uintptr(118)
SYS_sched_setscheduler :: uintptr(119)
SYS_sched_getscheduler :: uintptr(120)
SYS_sched_getparam :: uintptr(121)
SYS_sched_setaffinity :: uintptr(122)
SYS_sched_getaffinity :: uintptr(123)
SYS_sched_yield :: uintptr(124)
SYS_sched_get_priority_max :: uintptr(125)
SYS_sched_get_priority_min :: uintptr(126)
SYS_sched_rr_get_interval :: uintptr(127)
SYS_restart_syscall :: uintptr(128)
SYS_kill :: uintptr(129)
SYS_tkill :: uintptr(130)
SYS_tgkill :: uintptr(131)
SYS_sigaltstack :: uintptr(132)
SYS_rt_sigsuspend :: uintptr(133)
SYS_rt_sigaction :: uintptr(134)
SYS_rt_sigprocmask :: uintptr(135)
SYS_rt_sigpending :: uintptr(136)
SYS_rt_sigtimedwait :: uintptr(137)
SYS_rt_sigqueueinfo :: uintptr(138)
SYS_rt_sigreturn :: uintptr(139)
SYS_setpriority :: uintptr(140)
SYS_getpriority :: uintptr(141)
SYS_reboot :: uintptr(142)
SYS_setregid :: uintptr(143)
SYS_setgid :: uintptr(144)
SYS_setreuid :: uintptr(145)
SYS_setuid :: uintptr(146)
SYS_setresuid :: uintptr(147)
SYS_getresuid :: uintptr(148)
SYS_setresgid :: uintptr(149)
SYS_getresgid :: uintptr(150)
SYS_setfsuid :: uintptr(151)
SYS_setfsgid :: uintptr(152)
SYS_times :: uintptr(153)
SYS_setpgid :: uintptr(154)
SYS_getpgid :: uintptr(155)
SYS_getsid :: uintptr(156)
SYS_setsid :: uintptr(157)
SYS_getgroups :: uintptr(158)
SYS_setgroups :: uintptr(159)
SYS_uname :: uintptr(160)
SYS_sethostname :: uintptr(161)
SYS_setdomainname :: uintptr(162)
SYS_getrlimit :: uintptr(163)
SYS_setrlimit :: uintptr(164)
SYS_getrusage :: uintptr(165)
SYS_umask :: uintptr(166)
SYS_prctl :: uintptr(167)
SYS_getcpu :: uintptr(168)
SYS_gettimeofday :: uintptr(169)
SYS_settimeofday :: uintptr(170)
SYS_adjtimex :: uintptr(171)
SYS_getpid :: uintptr(172)
SYS_getppid :: uintptr(173)
SYS_getuid :: uintptr(174)
SYS_geteuid :: uintptr(175)
SYS_getgid :: uintptr(176)
SYS_getegid :: uintptr(177)
SYS_gettid :: uintptr(178)
SYS_sysinfo :: uintptr(179)
SYS_mq_open :: uintptr(180)
SYS_mq_unlink :: uintptr(181)
SYS_mq_timedsend :: uintptr(182)
SYS_mq_timedreceive :: uintptr(183)
SYS_mq_notify :: uintptr(184)
SYS_mq_getsetattr :: uintptr(185)
SYS_msgget :: uintptr(186)
SYS_msgctl :: uintptr(187)
SYS_msgrcv :: uintptr(188)
SYS_msgsnd :: uintptr(189)
SYS_semget :: uintptr(190)
SYS_semctl :: uintptr(191)
SYS_semtimedop :: uintptr(192)
SYS_semop :: uintptr(193)
SYS_shmget :: uintptr(194)
SYS_shmctl :: uintptr(195)
SYS_shmat :: uintptr(196)
SYS_shmdt :: uintptr(197)
SYS_socket :: uintptr(198)
SYS_socketpair :: uintptr(199)
SYS_bind :: uintptr(200)
SYS_listen :: uintptr(201)
SYS_accept :: uintptr(202)
SYS_connect :: uintptr(203)
SYS_getsockname :: uintptr(204)
SYS_getpeername :: uintptr(205)
SYS_sendto :: uintptr(206)
SYS_recvfrom :: uintptr(207)
SYS_setsockopt :: uintptr(208)
SYS_getsockopt :: uintptr(209)
SYS_shutdown :: uintptr(210)
SYS_sendmsg :: uintptr(211)
SYS_recvmsg :: uintptr(212)
SYS_readahead :: uintptr(213)
SYS_brk :: uintptr(214)
SYS_munmap :: uintptr(215)
SYS_mremap :: uintptr(216)
SYS_add_key :: uintptr(217)
SYS_request_key :: uintptr(218)
SYS_keyctl :: uintptr(219)
SYS_clone :: uintptr(220)
SYS_execve :: uintptr(221)
SYS_mmap :: uintptr(222)
SYS_fadvise64 :: uintptr(223)
/* CONFIG_MMU only */
SYS_swapon :: uintptr(224)
SYS_swapoff :: uintptr(225)
SYS_mprotect :: uintptr(226)
SYS_msync :: uintptr(227)
SYS_mlock :: uintptr(228)
SYS_munlock :: uintptr(229)
SYS_mlockall :: uintptr(230)
SYS_munlockall :: uintptr(231)
SYS_mincore :: uintptr(232)
SYS_madvise :: uintptr(233)
SYS_remap_file_pages :: uintptr(234)
SYS_mbind :: uintptr(235)
SYS_get_mempolicy :: uintptr(236)
SYS_set_mempolicy :: uintptr(237)
SYS_migrate_pages :: uintptr(238)
SYS_move_pages :: uintptr(239)
SYS_rt_tgsigqueueinfo :: uintptr(240)
SYS_perf_event_open :: uintptr(241)
SYS_accept4 :: uintptr(242)
SYS_recvmmsg :: uintptr(243)
SYS_wait4 :: uintptr(260)
SYS_prlimit64 :: uintptr(261)
SYS_fanotify_init :: uintptr(262)
SYS_fanotify_mark :: uintptr(263)
SYS_name_to_handle_at :: uintptr(264)
SYS_open_by_handle_at :: uintptr(265)
SYS_clock_adjtime :: uintptr(266)
SYS_syncfs :: uintptr(267)
SYS_setns :: uintptr(268)
SYS_sendmmsg :: uintptr(269)
SYS_process_vm_readv :: uintptr(270)
SYS_process_vm_writev :: uintptr(271)
SYS_kcmp :: uintptr(272)
SYS_finit_module :: uintptr(273)
SYS_sched_setattr :: uintptr(274)
SYS_sched_getattr :: uintptr(275)
SYS_renameat2 :: uintptr(276)
SYS_seccomp :: uintptr(277)
SYS_getrandom :: uintptr(278)
SYS_memfd_create :: uintptr(279)
SYS_bpf :: uintptr(280)
SYS_execveat :: uintptr(281)
SYS_userfaultfd :: uintptr(282)
SYS_membarrier :: uintptr(283)
SYS_mlock2 :: uintptr(284)
SYS_copy_file_range :: uintptr(285)
SYS_preadv2 :: uintptr(286)
SYS_pwritev2 :: uintptr(287)
SYS_pkey_mprotect :: uintptr(288)
SYS_pkey_alloc :: uintptr(289)
SYS_pkey_free :: uintptr(290)
SYS_statx :: uintptr(291)
SYS_io_pgetevents :: uintptr(292)
SYS_rseq :: uintptr(293)
SYS_kexec_file_load :: uintptr(294)
SYS_pidfd_send_signal :: uintptr(424)
SYS_io_uring_setup :: uintptr(425)
SYS_io_uring_enter :: uintptr(426)
SYS_io_uring_register :: uintptr(427)
SYS_open_tree :: uintptr(428)
SYS_move_mount :: uintptr(429)
SYS_fsopen :: uintptr(430)
SYS_fsconfig :: uintptr(431)
SYS_fsmount :: uintptr(432)
SYS_fspick :: uintptr(433)
SYS_pidfd_open :: uintptr(434)
SYS_clone3 :: uintptr(435)
SYS_close_range :: uintptr(436)
SYS_openat2 :: uintptr(437)
SYS_pidfd_getfd :: uintptr(438)
SYS_faccessat2 :: uintptr(439)
SYS_process_madvise :: uintptr(440)
SYS_epoll_pwait2 :: uintptr(441)
SYS_mount_setattr :: uintptr(442)
SYS_quotactl_fd :: uintptr(443)
SYS_landlock_create_ruleset :: uintptr(444)
SYS_landlock_add_rule :: uintptr(445)
SYS_landlock_restrict_self :: uintptr(446)
SYS_memfd_secret :: uintptr(447)
SYS_process_mrelease :: uintptr(448)
SYS_futex_waitv :: uintptr(449)
SYS_set_mempolicy_home_node :: uintptr(450)
SYS_cachestat :: uintptr(451)
SYS_fchmodat2 :: uintptr(452)

458
core/sys/linux/syscall_i386.odin Normal file
View File

@@ -0,0 +1,458 @@
//+build i386
package linux
// The numbers are taken from
// /arch/x86/entry/syscalls/syscall_32.tbl
// in Linux headers. Only x64 and common ABI
// syscalls were taken, for x32 is not
// supported by Odin
// This syscall is only used by the kernel internally
// userspace has no reason to use it.
SYS_restart_syscall :: uintptr(0)
SYS_exit :: uintptr(1)
SYS_fork :: uintptr(2)
SYS_read :: uintptr(3)
SYS_write :: uintptr(4)
SYS_open :: uintptr(5)
SYS_close :: uintptr(6)
SYS_waitpid :: uintptr(7)
SYS_creat :: uintptr(8)
SYS_link :: uintptr(9)
SYS_unlink :: uintptr(10)
SYS_execve :: uintptr(11)
SYS_chdir :: uintptr(12)
SYS_time :: uintptr(13)
SYS_mknod :: uintptr(14)
SYS_chmod :: uintptr(15)
SYS_lchown :: uintptr(16)
SYS_break :: uintptr(17)
SYS_oldstat :: uintptr(18)
SYS_lseek :: uintptr(19)
SYS_getpid :: uintptr(20)
SYS_mount :: uintptr(21)
SYS_umount :: uintptr(22)
SYS_setuid :: uintptr(23)
SYS_getuid :: uintptr(24)
SYS_stime :: uintptr(25)
SYS_ptrace :: uintptr(26)
SYS_alarm :: uintptr(27)
SYS_oldfstat :: uintptr(28)
SYS_pause :: uintptr(29)
SYS_utime :: uintptr(30)
SYS_stty :: uintptr(31)
SYS_gtty :: uintptr(32)
SYS_access :: uintptr(33)
SYS_nice :: uintptr(34)
SYS_ftime :: uintptr(35)
SYS_sync :: uintptr(36)
SYS_kill :: uintptr(37)
SYS_rename :: uintptr(38)
SYS_mkdir :: uintptr(39)
SYS_rmdir :: uintptr(40)
SYS_dup :: uintptr(41)
SYS_pipe :: uintptr(42)
SYS_times :: uintptr(43)
SYS_prof :: uintptr(44)
SYS_brk :: uintptr(45)
SYS_setgid :: uintptr(46)
SYS_getgid :: uintptr(47)
SYS_signal :: uintptr(48)
SYS_geteuid :: uintptr(49)
SYS_getegid :: uintptr(50)
SYS_acct :: uintptr(51)
SYS_umount2 :: uintptr(52)
SYS_lock :: uintptr(53)
SYS_ioctl :: uintptr(54)
SYS_fcntl :: uintptr(55)
SYS_mpx :: uintptr(56)
SYS_setpgid :: uintptr(57)
SYS_ulimit :: uintptr(58)
SYS_oldolduname :: uintptr(59)
SYS_umask :: uintptr(60)
SYS_chroot :: uintptr(61)
SYS_ustat :: uintptr(62)
SYS_dup2 :: uintptr(63)
SYS_getppid :: uintptr(64)
SYS_getpgrp :: uintptr(65)
SYS_setsid :: uintptr(66)
SYS_sigaction :: uintptr(67)
SYS_sgetmask :: uintptr(68)
SYS_ssetmask :: uintptr(69)
SYS_setreuid :: uintptr(70)
SYS_setregid :: uintptr(71)
SYS_sigsuspend :: uintptr(72)
SYS_sigpending :: uintptr(73)
SYS_sethostname :: uintptr(74)
SYS_setrlimit :: uintptr(75)
SYS_getrlimit :: uintptr(76)
SYS_getrusage :: uintptr(77)
SYS_gettimeofday :: uintptr(78)
SYS_settimeofday :: uintptr(79)
SYS_getgroups :: uintptr(80)
SYS_setgroups :: uintptr(81)
SYS_select :: uintptr(82)
SYS_symlink :: uintptr(83)
SYS_oldlstat :: uintptr(84)
SYS_readlink :: uintptr(85)
SYS_uselib :: uintptr(86)
SYS_swapon :: uintptr(87)
SYS_reboot :: uintptr(88)
SYS_readdir :: uintptr(89)
SYS_mmap :: uintptr(90)
SYS_munmap :: uintptr(91)
SYS_truncate :: uintptr(92)
SYS_ftruncate :: uintptr(93)
SYS_fchmod :: uintptr(94)
SYS_fchown :: uintptr(95)
SYS_getpriority :: uintptr(96)
SYS_setpriority :: uintptr(97)
SYS_profil :: uintptr(98)
SYS_statfs :: uintptr(99)
SYS_fstatfs :: uintptr(100)
SYS_ioperm :: uintptr(101)
SYS_socketcall :: uintptr(102)
SYS_syslog :: uintptr(103)
SYS_setitimer :: uintptr(104)
SYS_getitimer :: uintptr(105)
SYS_stat :: uintptr(106)
SYS_lstat :: uintptr(107)
SYS_fstat :: uintptr(108)
SYS_olduname :: uintptr(109)
SYS_iopl :: uintptr(110)
SYS_vhangup :: uintptr(111)
SYS_idle :: uintptr(112)
SYS_vm86old :: uintptr(113)
SYS_wait4 :: uintptr(114)
SYS_swapoff :: uintptr(115)
SYS_sysinfo :: uintptr(116)
SYS_ipc :: uintptr(117)
SYS_fsync :: uintptr(118)
SYS_sigreturn :: uintptr(119)
SYS_clone :: uintptr(120)
SYS_setdomainname :: uintptr(121)
SYS_uname :: uintptr(122)
SYS_modify_ldt :: uintptr(123)
SYS_adjtimex :: uintptr(124)
SYS_mprotect :: uintptr(125)
SYS_sigprocmask :: uintptr(126)
SYS_create_module :: uintptr(127)
SYS_init_module :: uintptr(128)
SYS_delete_module :: uintptr(129)
SYS_get_kernel_syms :: uintptr(130)
SYS_quotactl :: uintptr(131)
SYS_getpgid :: uintptr(132)
SYS_fchdir :: uintptr(133)
SYS_bdflush :: uintptr(134)
SYS_sysfs :: uintptr(135)
SYS_personality :: uintptr(136)
SYS_afs_syscall :: uintptr(137)
SYS_setfsuid :: uintptr(138)
SYS_setfsgid :: uintptr(139)
SYS__llseek :: uintptr(140)
SYS_getdents :: uintptr(141)
SYS__newselect :: uintptr(142)
SYS_flock :: uintptr(143)
SYS_msync :: uintptr(144)
SYS_readv :: uintptr(145)
SYS_writev :: uintptr(146)
SYS_getsid :: uintptr(147)
SYS_fdatasync :: uintptr(148)
SYS__sysctl :: uintptr(149)
SYS_mlock :: uintptr(150)
SYS_munlock :: uintptr(151)
SYS_mlockall :: uintptr(152)
SYS_munlockall :: uintptr(153)
SYS_sched_setparam :: uintptr(154)
SYS_sched_getparam :: uintptr(155)
SYS_sched_setscheduler :: uintptr(156)
SYS_sched_getscheduler :: uintptr(157)
SYS_sched_yield :: uintptr(158)
SYS_sched_get_priority_max :: uintptr(159)
SYS_sched_get_priority_min :: uintptr(160)
SYS_sched_rr_get_interval :: uintptr(161)
SYS_nanosleep :: uintptr(162)
SYS_mremap :: uintptr(163)
SYS_setresuid :: uintptr(164)
SYS_getresuid :: uintptr(165)
SYS_vm86 :: uintptr(166)
SYS_query_module :: uintptr(167)
SYS_poll :: uintptr(168)
SYS_nfsservctl :: uintptr(169)
SYS_setresgid :: uintptr(170)
SYS_getresgid :: uintptr(171)
SYS_prctl :: uintptr(172)
SYS_rt_sigreturn :: uintptr(173)
SYS_rt_sigaction :: uintptr(174)
SYS_rt_sigprocmask :: uintptr(175)
SYS_rt_sigpending :: uintptr(176)
SYS_rt_sigtimedwait :: uintptr(177)
SYS_rt_sigqueueinfo :: uintptr(178)
SYS_rt_sigsuspend :: uintptr(179)
SYS_pread64 :: uintptr(180)
SYS_pwrite64 :: uintptr(181)
SYS_chown :: uintptr(182)
SYS_getcwd :: uintptr(183)
SYS_capget :: uintptr(184)
SYS_capset :: uintptr(185)
SYS_sigaltstack :: uintptr(186)
SYS_sendfile :: uintptr(187)
SYS_getpmsg :: uintptr(188)
SYS_putpmsg :: uintptr(189)
SYS_vfork :: uintptr(190)
SYS_ugetrlimit :: uintptr(191)
SYS_mmap2 :: uintptr(192)
SYS_truncate64 :: uintptr(193)
SYS_ftruncate64 :: uintptr(194)
SYS_stat64 :: uintptr(195)
SYS_lstat64 :: uintptr(196)
SYS_fstat64 :: uintptr(197)
SYS_lchown32 :: uintptr(198)
SYS_getuid32 :: uintptr(199)
SYS_getgid32 :: uintptr(200)
SYS_geteuid32 :: uintptr(201)
SYS_getegid32 :: uintptr(202)
SYS_setreuid32 :: uintptr(203)
SYS_setregid32 :: uintptr(204)
SYS_getgroups32 :: uintptr(205)
SYS_setgroups32 :: uintptr(206)
SYS_fchown32 :: uintptr(207)
SYS_setresuid32 :: uintptr(208)
SYS_getresuid32 :: uintptr(209)
SYS_setresgid32 :: uintptr(210)
SYS_getresgid32 :: uintptr(211)
SYS_chown32 :: uintptr(212)
SYS_setuid32 :: uintptr(213)
SYS_setgid32 :: uintptr(214)
SYS_setfsuid32 :: uintptr(215)
SYS_setfsgid32 :: uintptr(216)
SYS_pivot_root :: uintptr(217)
SYS_mincore :: uintptr(218)
SYS_madvise :: uintptr(219)
SYS_getdents64 :: uintptr(220)
SYS_fcntl64 :: uintptr(221)
// 222 is unused
// 223 is unused
SYS_gettid :: uintptr(224)
SYS_readahead :: uintptr(225)
SYS_setxattr :: uintptr(226)
SYS_lsetxattr :: uintptr(227)
SYS_fsetxattr :: uintptr(228)
SYS_getxattr :: uintptr(229)
SYS_lgetxattr :: uintptr(230)
SYS_fgetxattr :: uintptr(231)
SYS_listxattr :: uintptr(232)
SYS_llistxattr :: uintptr(233)
SYS_flistxattr :: uintptr(234)
SYS_removexattr :: uintptr(235)
SYS_lremovexattr :: uintptr(236)
SYS_fremovexattr :: uintptr(237)
SYS_tkill :: uintptr(238)
SYS_sendfile64 :: uintptr(239)
SYS_futex :: uintptr(240)
SYS_sched_setaffinity :: uintptr(241)
SYS_sched_getaffinity :: uintptr(242)
SYS_set_thread_area :: uintptr(243)
SYS_get_thread_area :: uintptr(244)
SYS_io_setup :: uintptr(245)
SYS_io_destroy :: uintptr(246)
SYS_io_getevents :: uintptr(247)
SYS_io_submit :: uintptr(248)
SYS_io_cancel :: uintptr(249)
SYS_fadvise64 :: uintptr(250)
// 251 is available for reuse (was briefly sys_set_zone_reclaim)
SYS_exit_group :: uintptr(252)
SYS_lookup_dcookie :: uintptr(253)
SYS_epoll_create :: uintptr(254)
SYS_epoll_ctl :: uintptr(255)
SYS_epoll_wait :: uintptr(256)
SYS_remap_file_pages :: uintptr(257)
SYS_set_tid_address :: uintptr(258)
SYS_timer_create :: uintptr(259)
SYS_timer_settime :: uintptr(260)
SYS_timer_gettime :: uintptr(261)
SYS_timer_getoverrun :: uintptr(262)
SYS_timer_delete :: uintptr(263)
SYS_clock_settime :: uintptr(264)
SYS_clock_gettime :: uintptr(265)
SYS_clock_getres :: uintptr(266)
SYS_clock_nanosleep :: uintptr(267)
SYS_statfs64 :: uintptr(268)
SYS_fstatfs64 :: uintptr(269)
SYS_tgkill :: uintptr(270)
SYS_utimes :: uintptr(271)
SYS_fadvise64_64 :: uintptr(272)
SYS_vserver :: uintptr(273)
SYS_mbind :: uintptr(274)
SYS_get_mempolicy :: uintptr(275)
SYS_set_mempolicy :: uintptr(276)
SYS_mq_open :: uintptr(277)
SYS_mq_unlink :: uintptr(278)
SYS_mq_timedsend :: uintptr(279)
SYS_mq_timedreceive :: uintptr(280)
SYS_mq_notify :: uintptr(281)
SYS_mq_getsetattr :: uintptr(282)
SYS_kexec_load :: uintptr(283)
SYS_waitid :: uintptr(284)
// 285 sys_setaltroot
SYS_add_key :: uintptr(286)
SYS_request_key :: uintptr(287)
SYS_keyctl :: uintptr(288)
SYS_ioprio_set :: uintptr(289)
SYS_ioprio_get :: uintptr(290)
SYS_inotify_init :: uintptr(291)
SYS_inotify_add_watch :: uintptr(292)
SYS_inotify_rm_watch :: uintptr(293)
SYS_migrate_pages :: uintptr(294)
SYS_openat :: uintptr(295)
SYS_mkdirat :: uintptr(296)
SYS_mknodat :: uintptr(297)
SYS_fchownat :: uintptr(298)
SYS_futimesat :: uintptr(299)
SYS_fstatat64 :: uintptr(300)
SYS_unlinkat :: uintptr(301)
SYS_renameat :: uintptr(302)
SYS_linkat :: uintptr(303)
SYS_symlinkat :: uintptr(304)
SYS_readlinkat :: uintptr(305)
SYS_fchmodat :: uintptr(306)
SYS_faccessat :: uintptr(307)
SYS_pselect6 :: uintptr(308)
SYS_ppoll :: uintptr(309)
SYS_unshare :: uintptr(310)
SYS_set_robust_list :: uintptr(311)
SYS_get_robust_list :: uintptr(312)
SYS_splice :: uintptr(313)
SYS_sync_file_range :: uintptr(314)
SYS_tee :: uintptr(315)
SYS_vmsplice :: uintptr(316)
SYS_move_pages :: uintptr(317)
SYS_getcpu :: uintptr(318)
SYS_epoll_pwait :: uintptr(319)
SYS_utimensat :: uintptr(320)
SYS_signalfd :: uintptr(321)
SYS_timerfd_create :: uintptr(322)
SYS_eventfd :: uintptr(323)
SYS_fallocate :: uintptr(324)
SYS_timerfd_settime :: uintptr(325)
SYS_timerfd_gettime :: uintptr(326)
SYS_signalfd4 :: uintptr(327)
SYS_eventfd2 :: uintptr(328)
SYS_epoll_create1 :: uintptr(329)
SYS_dup3 :: uintptr(330)
SYS_pipe2 :: uintptr(331)
SYS_inotify_init1 :: uintptr(332)
SYS_preadv :: uintptr(333)
SYS_pwritev :: uintptr(334)
SYS_rt_tgsigqueueinfo :: uintptr(335)
SYS_perf_event_open :: uintptr(336)
SYS_recvmmsg :: uintptr(337)
SYS_fanotify_init :: uintptr(338)
SYS_fanotify_mark :: uintptr(339)
SYS_prlimit64 :: uintptr(340)
SYS_name_to_handle_at :: uintptr(341)
SYS_open_by_handle_at :: uintptr(342)
SYS_clock_adjtime :: uintptr(343)
SYS_syncfs :: uintptr(344)
SYS_sendmmsg :: uintptr(345)
SYS_setns :: uintptr(346)
SYS_process_vm_readv :: uintptr(347)
SYS_process_vm_writev :: uintptr(348)
SYS_kcmp :: uintptr(349)
SYS_finit_module :: uintptr(350)
SYS_sched_setattr :: uintptr(351)
SYS_sched_getattr :: uintptr(352)
SYS_renameat2 :: uintptr(353)
SYS_seccomp :: uintptr(354)
SYS_getrandom :: uintptr(355)
SYS_memfd_create :: uintptr(356)
SYS_bpf :: uintptr(357)
SYS_execveat :: uintptr(358)
SYS_socket :: uintptr(359)
SYS_socketpair :: uintptr(360)
SYS_bind :: uintptr(361)
SYS_connect :: uintptr(362)
SYS_listen :: uintptr(363)
SYS_accept4 :: uintptr(364)
SYS_getsockopt :: uintptr(365)
SYS_setsockopt :: uintptr(366)
SYS_getsockname :: uintptr(367)
SYS_getpeername :: uintptr(368)
SYS_sendto :: uintptr(369)
SYS_sendmsg :: uintptr(370)
SYS_recvfrom :: uintptr(371)
SYS_recvmsg :: uintptr(372)
SYS_shutdown :: uintptr(373)
SYS_userfaultfd :: uintptr(374)
SYS_membarrier :: uintptr(375)
SYS_mlock2 :: uintptr(376)
SYS_copy_file_range :: uintptr(377)
SYS_preadv2 :: uintptr(378)
SYS_pwritev2 :: uintptr(379)
SYS_pkey_mprotect :: uintptr(380)
SYS_pkey_alloc :: uintptr(381)
SYS_pkey_free :: uintptr(382)
SYS_statx :: uintptr(383)
SYS_arch_prctl :: uintptr(384)
SYS_io_pgetevents :: uintptr(385)
SYS_rseq :: uintptr(386)
SYS_semget :: uintptr(393)
SYS_semctl :: uintptr(394)
SYS_shmget :: uintptr(395)
SYS_shmctl :: uintptr(396)
SYS_shmat :: uintptr(397)
SYS_shmdt :: uintptr(398)
SYS_msgget :: uintptr(399)
SYS_msgsnd :: uintptr(400)
SYS_msgrcv :: uintptr(401)
SYS_msgctl :: uintptr(402)
SYS_clock_gettime64 :: uintptr(403)
SYS_clock_settime64 :: uintptr(404)
SYS_clock_adjtime64 :: uintptr(405)
SYS_clock_getres_time64 :: uintptr(406)
SYS_clock_nanosleep_time64 :: uintptr(407)
SYS_timer_gettime64 :: uintptr(408)
SYS_timer_settime64 :: uintptr(409)
SYS_timerfd_gettime64 :: uintptr(410)
SYS_timerfd_settime64 :: uintptr(411)
SYS_utimensat_time64 :: uintptr(412)
SYS_pselect6_time64 :: uintptr(413)
SYS_ppoll_time64 :: uintptr(414)
SYS_io_pgetevents_time64 :: uintptr(416)
SYS_recvmmsg_time64 :: uintptr(417)
SYS_mq_timedsend_time64 :: uintptr(418)
SYS_mq_timedreceive_time64 :: uintptr(419)
SYS_semtimedop_time64 :: uintptr(420)
SYS_rt_sigtimedwait_time64 :: uintptr(421)
SYS_futex_time64 :: uintptr(422)
SYS_sched_rr_get_interval_time64 :: uintptr(423)
SYS_pidfd_send_signal :: uintptr(424)
SYS_io_uring_setup :: uintptr(425)
SYS_io_uring_enter :: uintptr(426)
SYS_io_uring_register :: uintptr(427)
SYS_open_tree :: uintptr(428)
SYS_move_mount :: uintptr(429)
SYS_fsopen :: uintptr(430)
SYS_fsconfig :: uintptr(431)
SYS_fsmount :: uintptr(432)
SYS_fspick :: uintptr(433)
SYS_pidfd_open :: uintptr(434)
SYS_clone3 :: uintptr(435)
SYS_close_range :: uintptr(436)
SYS_openat2 :: uintptr(437)
SYS_pidfd_getfd :: uintptr(438)
SYS_faccessat2 :: uintptr(439)
SYS_process_madvise :: uintptr(440)
SYS_epoll_pwait2 :: uintptr(441)
SYS_mount_setattr :: uintptr(442)
SYS_quotactl_fd :: uintptr(443)
SYS_landlock_create_ruleset :: uintptr(444)
SYS_landlock_add_rule :: uintptr(445)
SYS_landlock_restrict_self :: uintptr(446)
SYS_memfd_secret :: uintptr(447)
SYS_process_mrelease :: uintptr(448)
SYS_futex_waitv :: uintptr(449)
SYS_set_mempolicy_home_node :: uintptr(450)
SYS_cachestat :: uintptr(451)
SYS_fchmodat2 :: uintptr(452)

566
core/sys/linux/types.odin Normal file
View File

@@ -0,0 +1,566 @@
//+build linux
package linux
/// Represents storage device handle
Dev :: distinct int
/// Represents 32-bit user id
Uid :: distinct u32
/// Represents 32-bit group id
Gid :: distinct u32
/// Process id's
Pid :: distinct int
/// Represents pid, pifd, pgid values in general
Id :: distinct uint
/// Represents a file descriptor
Fd :: distinct i32
/// Represents a PID file descriptor
Pid_FD :: distinct i32
/// Represents 64-bit inode number for files
/// Used pretty much only in struct Stat64 for 32-bit platforms
Inode :: distinct u64
/// Represents time with nanosecond precision
Time_Spec :: struct {
time_sec: uint,
time_nsec: uint,
}
/// Represents time with millisecond precision
Time_Val :: struct {
seconds: int,
microseconds: int,
}
/// open.2 flags
Open_Flags :: bit_set[Open_Flags_Bits; u32]
/// Flags for the file descriptor to be passed in some syscalls
FD_Flags :: bit_set[FD_Flags_Bits; i32]
/// Represents file's permission and status bits
/// Example:
/// When you're passing a value of this type the recommended usage is
/// sys.Mode{.S_IXOTH, .S_IROTH} | sys.S_IRWXU | sys.S_IRWXG
/// This would generate a mode that has full permissions for the
/// file's owner and group, and only "read" and "execute" bits
/// for others.
Mode :: bit_set[Mode_Bits; u32]
when ODIN_ARCH == .amd64 {
// x86-64 has mode and nlink swapped for some reason
_Arch_Stat :: struct {
dev: Dev,
ino: Inode,
nlink: uint,
mode: Mode,
uid: Uid,
gid: Gid,
_: u32,
rdev: Dev,
size: uint,
blksize: uint,
blocks: uint,
atime: Time_Spec,
mtime: Time_Spec,
ctime: Time_Spec,
_: [3]uint,
}
} else when ODIN_ARCH == .arm64 {
_Arch_Stat :: struct {
dev: Dev,
ino: Inode,
mode: Mode,
nlink: u32,
uid: Uid,
gid: Gid,
rdev: Dev,
_: u64,
size: int,
blksize: i32,
_: i32,
blocks: int,
atime: Time_Spec,
mtime: Time_Spec,
ctime: Time_Spec,
_: [3]uint,
}
} else {
_Arch_Stat :: struct {
dev: Dev,
_: [4]u8,
_ino: uint, // Old 32-bit inode number, don't use
mode: Mode,
nlink: u32,
uid: Uid,
gid: Gid,
rdev: Dev,
size: i64,
blksize: uint,
blocks: u64,
atim: Time_Spec,
mtim: Time_Spec,
ctim: Time_Spec,
ino: Inode,
}
}
/// Represents the file state.
/// Mirrors struct stat in glibc/linux kernel.
/// If you're on 32-bit platform, consider using Stat64 instead
Stat :: struct {
using _impl_stat: _Arch_Stat,
}
/// Timestamp type used for Statx struct
Statx_Timestamp :: struct {
sec: i64,
nsec: u32,
_: i32,
}
/// Query params/results for `statx()`
Statx_Mask :: bit_set[Statx_Mask_Bits; u32]
/// File attributes, returned by statx. This bitset is also
/// used to specify which attributes are present, not just
/// their value.
Statx_Attr :: bit_set[Statx_Attr_Bits; u64]
/// The extended Stat struct
Statx :: struct {
mask: Statx_Mask,
blksize: u32,
attributes: Statx_Attr,
nlink: u32,
uid: Uid,
gid: Gid,
// Note(flysand): mode is 16-bit on linux + there's
// 16-bit padding following it. Since our mode is 32-bits,
// we're using the padding. This should be fine because
// the placement of that padding suggests it was going to
// be used for the Mode bits anyway.
mode: Mode,
ino: Inode,
size: u64,
blocks: u64,
attributes_mask: Statx_Attr,
atime: Statx_Timestamp,
btime: Statx_Timestamp,
ctime: Statx_Timestamp,
mtime: Statx_Timestamp,
rdev_major: u32,
rdev_minor: u32,
dev_major: u32,
dev_minor: u32,
mnt_id: u64,
dio_mem_align: u32,
dio_offset_align: u32,
_: [12]u64,
}
/// Mount flags for filesystem
FS_Flags :: bit_set[FS_Flags_Bits; u32]
when size_of(int) == 8 {
_Arch_Stat_FS :: struct {
// Note(flysand): The FS_Magic bits are never above
// 32-bits, so it should be fine for now...
type: FS_Magic,
_: u32,
bsize: i64,
blocks: i64,
bfree: i64,
bavail: i64,
files: i64,
ffree: i64,
fsid : [2]i32,
namelen: i64,
frsize: i64,
// Note(flysand): Same story as type
flags: FS_Flags,
_: u32,
spare: [4]i64,
}
} else {
_Arch_Stat_FS :: struct {
type: FS_Magic,
bsize: u32,
blocks: u64,
bfree: u64,
bavail: u64,
files: u64,
ffree: u64,
fsid: [2]i32,
namelen: u32,
frsize: u32,
flags: FS_Flags,
spare: [4]u32,
}
}
Stat_FS :: struct {
using _impl_stat_fs: _Arch_Stat_FS,
}
/// Flags for close_range.2
Close_Range_Flags :: bit_set[Close_Range_Flags_Bits; u32]
/// Flags for rename.2
Rename_Flags :: bit_set[Rename_Flags_Bits; u32]
/// Directory entry
/// Recommended to use this with dirent_iterator()
/// and dirent_name()
Dirent :: struct {
ino: Inode,
off: i64,
reclen: u16,
type: Dirent_Type,
name: [0]u8, // See dirent_name
}
/// Lock record for fcntl.2
FLock :: struct {
type: FLock_Type,
whence: Seek_Whence,
start: i64,
len: i64,
pid: Pid,
}
/// Flags for fcntl_notify
FD_Notifications :: bit_set[FD_Notifications_Bits; i32]
/// Seals for fcntl_add_seals
Seal :: bit_set[Seal_Bits; i32]
/// Represents owner that receives events on file updates
F_Owner :: struct {
type: F_Owner_Type,
pid: Pid,
}
/// Events for ppoll
Fd_Poll_Events :: bit_set[Fd_Poll_Events_Bits; u16]
/// Struct for ppoll
Poll_Fd :: struct {
fd: Fd,
events: Fd_Poll_Events,
revents: Fd_Poll_Events,
}
/// Specifies protection for memory pages
Mem_Protection :: bit_set[Mem_Protection_Bits; i32]
/// Flags for mmap
Map_Flags :: bit_set[Map_Flags_Bits; i32]
/// Flags for mlock.2
MLock_Flags :: bit_set[MLock_Flags_Bits; u32]
/// Flags for msync.2
MSync_Flags :: bit_set[MSync_Flags_Bits; i32]
/// Access rights for pkey_alloc.2
PKey_Access_Rights :: bit_set[PKey_Access_Bits; u32]
/// Flags for mremap.2
MRemap_Flags :: bit_set[MRemap_Flags_Bits; i32]
/// Flags for getrandom syscall
Get_Random_Flags :: bit_set[Get_Random_Flags_Bits; i32]
/// Flags for perf_event_open syscall
Perf_Flags :: bit_set[Perf_Flags_Bits; uint]
Perf_Event_Flags :: distinct bit_set[Perf_Event_Flags_Bits; u64]
Perf_Cap_Flags :: distinct bit_set[Perf_Cap_Flags_Bits; u64]
Perf_Event_Sample_Type :: bit_set[Perf_Event_Sample_Type_Bits; u64]
/// Specifies which branches to include in branch record
Branch_Sample_Type :: bit_set[Branch_Sample_Type_Bits; u64]
/// The struct for perf_event_open
Perf_Event_Attr :: struct #packed {
type: Perf_Event_Type,
size: u32,
config: struct #raw_union {
hw: Perf_Hardware_Id,
sw: Perf_Software_Id,
cache: u64,
other: u64,
},
sample: struct #raw_union {
period: u64,
frequency: u64,
},
sample_type: Perf_Event_Sample_Type,
read_format: Perf_Read_Format,
flags: Perf_Event_Flags,
wakeup: struct #raw_union {
events: u32,
watermark: u32,
},
breakpoint_type: Hardware_Breakpoint_Type,
using _: struct #raw_union {
breakpoint_addr: u64,
kprobe_func: u64,
uprobe_path: u64,
config1: u64,
},
using _: struct #raw_union {
breakpoint_len: u64,
kprobe_addr: u64,
uprobe_offset: u64,
config2: u64,
},
branch_sample_type: Branch_Sample_Type,
sample_regs_user: u64,
sample_stack_user: u32,
clock_id: i32, // TODO(flysand): clock_id
sample_regs_intr: u64,
aux_watermark: u32,
sample_max_stack: u16,
_: u16,
}
/// The ring buffer structure when mmaping Perf_Event_Attr
Perf_Event_Mmap_Page :: struct #packed {
version: u32,
compat_version: u32,
lock: u32,
index: u32,
offset: i64,
time_enabled: u64,
time_running: u64,
cap: struct #raw_union {
capabilities: u64,
flags: Perf_Cap_Flags,
},
pmc_width: u16,
time_shift: u16,
time_mult: u32,
time_offset: u64,
time_zero: u64,
size: u32,
reserved1: u32,
time_cycles: u64,
time_mask: u64,
reserved2: [116*8]u8,
data_head: u64,
data_tail: u64,
data_offset: u64,
data_size: u64,
aux_head: u64,
aux_tail: u64,
aux_offset: u64,
aux_size: u64,
}
// TODO(flysand): Its taking too much effort to bind the other data structures related to perf_event_open
/// Options for wait4() and waitpid()
Wait_Options :: bit_set[Wait_Option; i32]
/// Flags for pidfd_open.2
Pid_FD_Flags :: bit_set[Pid_FD_Flags_Bits; i32]
// Note(flysand): these could, in principle be implemented with bitfields,
// however there are ABI differences between odin's bitfields and linux sigsets.
// Mainly:
// 1. Odin's bitfields start from 0, whereas signals start from 1
// 2. It's unclear how bitfields act in terms of ABI (are they an array of ints or an array of longs?).
// it makes a difference because ARM is big endian.
@private _SIGSET_NWORDS :: (1024 / (8 * size_of(uint)))
Sig_Set :: [_SIGSET_NWORDS]uint
@private SI_MAX_SIZE :: 128
@private SI_ARCH_PREAMBLE :: 3 * size_of(i32)
@private SI_PAD_SIZE :: (SI_MAX_SIZE - SI_ARCH_PREAMBLE) / size_of(i32)
@private SI_TIMER_PAD_SIZE :: size_of(Uid) - size_of(i32)
Sig_Handler_Fn :: #type proc "c" (sig: Signal)
Sig_Restore_Fn :: #type proc "c" ()
Sig_Info :: struct #packed {
signo: Signal,
errno: Errno,
code: i32,
_pad0: i32,
using _union: struct #raw_union {
_pad1: [SI_PAD_SIZE]u8,
using _kill: struct {
pid: Pid, /* sender's pid */
uid: Uid, /* sender's uid */
},
using _timer: struct {
timerid: i32, /* timer id */
overrun: i32, /* overrun count */
},
/* POSIX.1b signals */
using _rt: struct {
_pid0: Pid, /* sender's pid */
_uid0: Uid, /* sender's uid */
},
/* SIGCHLD */
using _sigchld: struct {
_pid1: Pid, /* which child */
_uid1: Uid, /* sender's uid */
status: i32, /* exit code */
utime: uint,
stime: uint, //clock_t
},
/* SIGILL, SIGFPE, SIGSEGV, SIGBUS */
using _sigfault: struct {
addr: rawptr, /* faulting insn/memory ref. */
addr_lsb: i16, /* LSB of the reported address */
},
/* SIGPOLL */
using _sigpoll: struct {
band: int, /* POLL_IN, POLL_OUT, POLL_MSG */
fd: Fd,
},
/* SIGSYS */
using _sigsys: struct {
call_addr: rawptr, /* calling user insn */
syscall: i32, /* triggering system call number */
arch: u32, /* AUDIT_ARCH_* of syscall */
},
},
}
Sig_Stack_Flags :: bit_set[Sig_Stack_Flag; i32]
Sig_Stack :: struct {
sp: rawptr,
flags: Sig_Stack_Flags,
size: uintptr,
}
Sig_Action :: struct($T: typeid) {
using _u: struct #raw_union {
handler: Sig_Handler_Fn,
sigaction: #type proc "c" (sig: Signal, si: ^Sig_Info, ctx: ^T),
},
flags: uint,
restorer: Sig_Restore_Fn,
mask: Sig_Set,
}
/// Flags for the socket file descriptor
/// Note, on linux these are technically passed by OR'ing together
/// with Socket_Type, our wrapper does this under the hood.
Socket_FD_Flags :: bit_set[Socket_FD_Flags_Bits; int]
/// Address family for the socket
/// Typically there's one address family for every protocol family
Address_Family :: distinct Protocol_Family
/// Flags for the socket for send/recv calls
Socket_Msg :: bit_set[Socket_Msg_Bits; i32]
/// Struct representing IPv4 socket address
Sock_Addr_In :: struct #packed {
sin_family: Address_Family,
sin_port: u16be,
sin_addr: [4]u8,
}
/// Struct representing IPv6 socket address
Sock_Addr_In6 :: struct #packed {
sin6_family: Address_Family,
sin6_port: u16be,
sin6_flowinfo: u32,
sin6_addr: [16]u8,
sin6_scope_id: u32,
}
/// Struct representing an arbitrary socket address
Sock_Addr_Any :: struct #raw_union {
using _: struct {
family: Address_Family,
port: u16be,
},
using ipv4: Sock_Addr_In,
using ipv6: Sock_Addr_In6,
}
/// Just an alias to make futex-values more visible
Futex :: u32
/// Flags for the futex (they are kept separately)
Futex_Flags :: bit_set[Futex_Flags_Bits; u32]
/// Times
Tms :: struct {
tms_utime: int,
tms_stime: int,
tms_cutime: int,
tms_cstime: int,
}
/// "Unix time-sharing system name", allegedly
/// Basically system info
UTS_Name :: struct {
sysname: [65]u8 `fmt:"s,0"`,
nodename: [65]u8 `fmt:"s,0"`,
release: [65]u8 `fmt:"s,0"`,
version: [65]u8 `fmt:"s,0"`,
machine: [65]u8 `fmt:"s,0"`,
domainname: [65]u8 `fmt:"s,0"`,
}
/// Return buffer for the sysinfo syscall
Sys_Info :: struct {
uptime: int,
loads: [3]int,
totalram: uint,
freeram: uint,
sharedram: uint,
bufferram: uint,
totalswap: uint,
freeswap: uint,
procs: u16,
totalhigh: uint,
freehigh: uint,
mem_unit: i32,
_padding: [20 - (2 * size_of(int)) - size_of(i32)]u8,
}
/// Resource limit
RLimit :: struct {
cur: uint,
max: uint,
}
/// Structure representing how much of each resource
/// got used.
RUsage :: struct {
utime: Time_Val,
stime: Time_Val,
maxrss_word: int,
ixrss_word: int,
idrss_word: int,
isrss_word: int,
minflt_word: int,
majflt_word: int,
nswap_word: int,
inblock_word: int,
oublock_word: int,
msgsnd_word: int,
msgrcv_word: int,
nsignals_word: int,
nvcsw_word: int,
nivcsw_word: int,
}

121
core/sys/linux/wrappers.odin Normal file
View File

@@ -0,0 +1,121 @@
//+build linux
package linux
/// Low 8 bits of the exit code
/// Only retrieve the exit code if WIFEXITED(s) = true
WEXITSTATUS :: #force_inline proc "contextless" (s: u32) -> u32 {
return (s & 0xff00) >> 8
}
/// Termination signal
/// Only retrieve the code if WIFSIGNALED(s) = true
WTERMSIG :: #force_inline proc "contextless" (s: u32) -> u32 {
return s & 0x7f
}
/// The signal that stopped the child
/// Only retrieve if WIFSTOPPED(s) = true
WSTOPSIG :: #force_inline proc "contextless" (s: u32) -> u32 {
return WEXITSTATUS(s)
}
/// Check if the process terminated normally (via exit.2)
WIFEXITED :: #force_inline proc "contextless" (s: u32) -> bool {
return WTERMSIG(s) == 0
}
/// Check if the process signaled
WIFSIGNALED :: #force_inline proc "contextless" (s: u32) -> bool {
return cast(i8)(((s) & 0x7f) + 1) >> 1 > 0
}
/// Check if the process has stopped
WIFSTOPPED :: #force_inline proc "contextless" (s: u32) -> bool {
return (s & 0xff) == 0x7f
}
/// Check if the process is continued by the tracee
WIFCONTINUED :: #force_inline proc "contextless" (s: u32) -> bool {
return s == 0xffff
}
/// Check if the process dumped core
WCOREDUMP :: #force_inline proc "contextless" (s: u32) -> bool {
return s & 0x80 == 0x80
}
@private _sigmask :: proc "contextless" (sig: Signal) -> (uint) {
return 1 << ((cast(uint)(sig) - 1) % (8*size_of(uint)))
}
@private _sigword :: proc "contextless" (sig: Signal) -> (uint) {
return (cast(uint)sig - 1) / (8*size_of(uint))
}
// TODO: sigaddset etc
/// Iterate the results of getdents
/// Only iterates as much data as loaded in the buffer
/// In case you need to iterate *all* files in a directory
/// consider using dirent_get_iterate
///
/// Example of using dirent_iterate_buf
/// // Get dirents into a buffer
/// buf: [128]u8
/// sys.getdents(dirfd, buf[:])
/// // Print the names of the files
/// for dir in sys.dirent_iterate_buf(buf[:], &offs) {
/// name := sys.dirent_name(dir)
/// fmt.println(name)
/// }
/// This function doesn't automatically make a request
/// for the buffer to be refilled
dirent_iterate_buf :: proc "contextless" (buf: []u8, offs: ^int) -> (d: ^Dirent, cont: bool) {
// Stopped iterating when there's no space left
if offs^ >= len(buf) {
return nil, false
}
// Retrieve dirent form the current offset
dirent := cast(^Dirent) &buf[offs^]
// Add the stride of dirent struct to the current offset
offs^ += cast(int) dirent.reclen
return dirent, true
}
/// Obtain the name of dirent as a string
/// The lifetime of the string is bound to the lifetime of the provided dirent structure
dirent_name :: proc "contextless" (dirent: ^Dirent) -> string #no_bounds_check {
str := transmute([^]u8) &dirent.name
// Note(flysand): The string size calculated above applies only to the ideal case
// we subtract 1 byte from the string size, because a null terminator is guaranteed
// to be present. But! That said, the dirents are aligned to 8 bytes and the padding
// between the null terminator and the start of the next struct may be not initialized
// which means we also have to scan these garbage bytes.
str_size := (cast(int) dirent.reclen) - 1 - cast(int) offset_of(Dirent, name)
// This skips *only* over the garbage, since if we're not garbage we're at nul terminator,
// which skips this loop
for str[str_size] != 0 {
str_size -= 1
}
for str[str_size-1] == 0 {
str_size -= 1
}
// Oh yeah btw i could also just `repne scasb` this thing, but honestly I started doing
// it the painful way, might as well finish doing it that way
return string(str[:str_size])
}
/// Constructor for the `futex_op` argument of a FUTEX_WAKE_OP call
futex_op :: proc "contextless" (arg_op: Futex_Arg_Op, cmp_op: Futex_Cmp_Op, op_arg: u32, cmp_arg: u32) -> u32 {
arg_op := cast(u32) arg_op
cmp_op := cast(u32) cmp_op
return (arg_op << 28) | (cmp_op << 24) | ((op_arg & 0xfff) << 12) | (cmp_arg & 0xfff)
}
/// Helper function for constructing the config for caches
perf_cache_config :: #force_inline proc "contextless" (id: Perf_Hardware_Cache_Id,
op: Perf_Hardware_Cache_Op_Id,
res: Perf_Hardware_Cache_Result_Id) -> u64
{
return u64(id) | (u64(op) << 8) | (u64(res) << 16)
}