Implement more Linux syscalls. (#6083)

4 files changed, 186 insertions, 14 deletions

diff --git a/core/sys/linux/bits.odin b/core/sys/linux/bits.odin
index 213d6c26f..2487ebe92 100644
--- a/core/sys/linux/bits.odin
+++ b/core/sys/linux/bits.odin
@@ -2269,3 +2269,34 @@ Swap_Flags_Bits :: enum {
 	PREFER  = log2(0x8000),
 	DISCARD = log2(0x10000),
 }
+
+Sched_Policy :: enum u32 {
+	OTHER    = 0,
+	BATCH    = 3,
+	IDLE     = 5,
+	FIFO     = 1,
+	RR       = 2,
+	DEADLINE = 6,
+}
+
+Sched_Flag_Bits :: enum {
+	RESET_ON_FORK  = log2(0x01),
+	RECLAIM        = log2(0x02),
+	DL_OVERRUN     = log2(0x04),
+	KEEP_POLICY    = log2(0x08),
+	KEEP_PARAMS    = log2(0x10),
+	UTIL_CLAMP_MIN = log2(0x20),
+	UTIL_CLAMP_MAX = log2(0x40),
+}
+
+Sched_Attr_Flag_Bits :: enum {}
+
+/*
+	See `constants.odin` for `MFD_HUGE_16KB`, et al.
+*/
+Memfd_Create_Flag_Bits :: enum {
+	CLOEXEC       = log2(0x1),
+	ALLOW_SEALING = log2(0x2),
+	HUGETLB       = log2(0x4),
+}
+
diff --git a/core/sys/linux/constants.odin b/core/sys/linux/constants.odin
index 71a16312e..4de57f40b 100644
--- a/core/sys/linux/constants.odin
+++ b/core/sys/linux/constants.odin
@@ -395,6 +395,20 @@ MAP_HUGE_1GB        :: transmute(Map_Flags)(u32(30) << MAP_HUGE_SHIFT)
 MAP_HUGE_2GB        :: transmute(Map_Flags)(u32(31) << MAP_HUGE_SHIFT)
 MAP_HUGE_16GB       :: transmute(Map_Flags)(u32(34) << MAP_HUGE_SHIFT)
 
+MFD_HUGE_16KB       :: transmute(Memfd_Create_Flags)(u32(14) << MAP_HUGE_SHIFT)
+MFD_HUGE_64KB       :: transmute(Memfd_Create_Flags)(u32(16) << MAP_HUGE_SHIFT)
+MFD_HUGE_512KB      :: transmute(Memfd_Create_Flags)(u32(19) << MAP_HUGE_SHIFT)
+MFD_HUGE_1MB        :: transmute(Memfd_Create_Flags)(u32(20) << MAP_HUGE_SHIFT)
+MFD_HUGE_2MB        :: transmute(Memfd_Create_Flags)(u32(21) << MAP_HUGE_SHIFT)
+MFD_HUGE_8MB        :: transmute(Memfd_Create_Flags)(u32(23) << MAP_HUGE_SHIFT)
+MFD_HUGE_16MB       :: transmute(Memfd_Create_Flags)(u32(24) << MAP_HUGE_SHIFT)
+MFD_HUGE_32MB       :: transmute(Memfd_Create_Flags)(u32(25) << MAP_HUGE_SHIFT)
+MFD_HUGE_256MB      :: transmute(Memfd_Create_Flags)(u32(28) << MAP_HUGE_SHIFT)
+MFD_HUGE_512MB      :: transmute(Memfd_Create_Flags)(u32(29) << MAP_HUGE_SHIFT)
+MFD_HUGE_1GB        :: transmute(Memfd_Create_Flags)(u32(30) << MAP_HUGE_SHIFT)
+MFD_HUGE_2GB        :: transmute(Memfd_Create_Flags)(u32(31) << MAP_HUGE_SHIFT)
+MFD_HUGE_16GB       :: transmute(Memfd_Create_Flags)(u32(34) << MAP_HUGE_SHIFT)
+
 /* Get window size */
 TIOCGWINSZ :: 0x5413
 
diff --git a/core/sys/linux/sys.odin b/core/sys/linux/sys.odin
index faeda6f43..b4943411a 100644
--- a/core/sys/linux/sys.odin
+++ b/core/sys/linux/sys.odin
@@ -2043,22 +2043,71 @@ setpriority :: proc "contextless" (which: Priority_Which, who: i32, prio: i32) -
 	return Errno(-ret)
 }
 
-// TODO(flysand): sched_setparam
+/*
+	Set scheduling parameters.
+	Available since Linux 2.0.
+*/
+sched_setparam :: proc "contextless" (pid: Pid, param: ^Sched_Param) -> (Errno) {
+	ret := syscall(SYS_sched_setparam, pid, param)
+	return Errno(-ret)
+}
 
-// TODO(flysand): sched_getparam
+/*
+	Get scheduling parameters.
+	Available since Linux 2.0.
+*/
+sched_getparam :: proc "contextless" (pid: Pid, param: ^Sched_Param) -> (Errno) {
+	ret := syscall(SYS_sched_getparam, pid, param)
+	return Errno(-ret)
+}
 
-// TODO(flysand): sched_setscheduler
+/*
+	Set scheduling policy/parameters.
+	Available since Linux 2.0.
+*/
+sched_setscheduler :: proc "contextless" (pid: Pid, policy: i32, param: ^Sched_Param) -> (Errno) {
+	ret := syscall(SYS_sched_setscheduler, pid, policy, param)
+	return Errno(-ret)
+}
 
-// TODO(flysand): sched_getscheduler
+/*
+	Get scheduling policy/parameters.
+	Available since Linux 2.0.
+*/
+sched_getscheduler :: proc "contextless" (pid: Pid, policy: i32, param: ^Sched_Param) -> (i32, Errno) {
+	ret := syscall(SYS_sched_getscheduler, pid)
+	return errno_unwrap(ret, i32)
+}
 
-// TODO(flysand): sched_get_priority_max
+/*
+	Get static priority range.
+	Available since Linux 2.0.
+*/
+sched_get_priority_max :: proc "contextless" (policy: i32) -> (i32, Errno) {
+	ret := syscall(SYS_sched_get_priority_max, policy)
+	return errno_unwrap(ret, i32)
+}
 
-// TODO(flysand): sched_get_priority_min
+/*
+	Get static priority range.
+	Available since Linux 2.0.
+*/
+sched_get_priority_min :: proc "contextless" (policy: i32) -> (i32, Errno) {
+	ret := syscall(SYS_sched_get_priority_min, policy)
+	return errno_unwrap(ret, i32)
+}
 
-// TODO(flysand): sched_rr_get_interval
+/*
+	get the SCHED_RR interval for the named process.
+	Available since Linux 2.0.
+*/
+sched_rr_get_interval :: proc "contextless" (pid: Pid, tp: ^Time_Spec) -> (Errno) {
+	ret := syscall(SYS_sched_rr_get_interval, pid, tp)
+	return Errno(-ret)
+}
 
 /*
-	Lock and memory.
+	Lock memory.
 	Available since Linux 2.0.
 	If flags specified, available since Linux 4.4.
 */
@@ -2560,9 +2609,29 @@ futex :: proc{
 	futex_wake_bitset,
 }
 
-// TODO(flysand): sched_setaffinity
+/*
+	Set a thread's CPU affinity mask.
+	Available since Linux 2.6.
+	
+	If you are running on a system with less than 128 cores you can use `linux.Cpu_Set` as the type for the mask argument.
+	Otherwise use an array of integers.
+*/
+sched_setaffinity :: proc "contextless" (pid: Pid, cpusetsize: uint, mask: rawptr) -> (Errno) {
+	ret := syscall(SYS_sched_setaffinity, pid, cpusetsize, mask)
+	return Errno(-ret)
+}
 
-// TODO(flysand): sched_getaffinity
+/*
+	Get a thread's CPU affinity mask.
+	Available since Linux 2.6.
+	
+	If you are running on a system with less than 128 cores you can use `linux.Cpu_Set` as the type for the mask argument.
+	Otherwise use an array of integers.
+*/
+sched_getaffinity :: proc "contextless" (pid: Pid, cpusetsize: uint, mask: rawptr) -> (Errno) {
+	ret := syscall(SYS_sched_getaffinity, pid, cpusetsize, mask)
+	return Errno(-ret)
+}
 
 // TODO(flysand): set_thread_area
 
@@ -3100,7 +3169,14 @@ sendmmsg :: proc "contextless" (sock: Fd, msg_vec: []MMsg_Hdr, flags: Socket_Msg
 
 // TODO(flysand): setns
 
-// TODO(flysand): getcpu
+/*
+	Determine CPU and NUMA node on which the calling thread is running.
+	Available since Linux 2.6.19.
+*/
+getcpu :: proc "contextless" (cpu, node: ^u32) -> (Errno) {
+	ret := syscall(SYS_getcpu, cpu, node)
+	return Errno(-ret)
+}
 
 // TODO(flysand): process_vm_readv
 
@@ -3110,9 +3186,23 @@ sendmmsg :: proc "contextless" (sock: Fd, msg_vec: []MMsg_Hdr, flags: Socket_Msg
 
 // TODO(flysand): finit_module
 
-// TODO(flysand): sched_setattr
+/*
+	Set scheduling policy and attributes.
+	Available since Linux 3.14.
+*/
+sched_setattr :: proc "contextless" (pid: Pid, attr: ^Sched_Attr, flags: Sched_Attr_Flags) -> (Errno) {
+	ret := syscall(SYS_sched_setattr, pid, attr, transmute(u32)flags)
+	return Errno(-ret)
+}
 
-// TODO(flysand): sched_getattr
+/*
+	Get scheduling policy and attributes.
+	Available since Linux 3.14.
+*/
+sched_getattr :: proc "contextless" (pid: Pid, attr: ^Sched_Attr, size: u32, flags: Sched_Attr_Flags) -> (Errno) {
+	ret := syscall(SYS_sched_getattr, pid, attr, transmute(u32)flags)
+	return Errno(-ret)
+}
 
 /*
 	Rename the file with names relative to the specified dirfd's with other options.
@@ -3130,7 +3220,14 @@ getrandom :: proc "contextless" (buf: []u8, flags: Get_Random_Flags) -> (int, Er
 	return errno_unwrap(ret, int)
 }
 
-// TODO(flysand): memfd_create
+/*
+	Create an anonymous file.
+	Available since Linux 3.17.
+*/
+memfd_create :: proc "contextless" (name: cstring, flags: Memfd_Create_Flags) -> (Fd, Errno) {
+	ret := syscall(SYS_memfd_create, cast(rawptr)name, transmute(u32)flags)
+	return errno_unwrap(ret, Fd)
+}
 
 // TODO(flysand): kexec_file_load
 
diff --git a/core/sys/linux/types.odin b/core/sys/linux/types.odin
index 0910f11ec..d0cc6c433 100644
--- a/core/sys/linux/types.odin
+++ b/core/sys/linux/types.odin
@@ -1748,3 +1748,33 @@ Mount_Flags :: bit_set[Mount_Flags_Bits; uint]
 Umount2_Flags :: bit_set[Umount2_Flags_Bits; u32]
 
 Swap_Flags :: bit_set[Swap_Flags_Bits; u32]
+
+Cpu_Set :: bit_set[0 ..< 128]
+
+Sched_Param :: struct {
+	sched_priority: i32,
+}
+
+Sched_Flags :: bit_set[Sched_Flag_Bits; u32]
+
+Sched_Attr :: struct {
+	size:           u32,
+
+	sched_policy:   Sched_Policy,
+	sched_flags:    Sched_Flags,
+	sched_nice:     i32,
+	sched_priority: u32,
+
+	/* For the DEADLINE policy */
+	sched_runtime:  u64,
+	sched_deadline: u64,
+	sched_period:   u64,
+
+	/* Utilization hints */
+	sched_util_min: u32,
+	sched_util_max: u32,
+}
+
+Sched_Attr_Flags :: bit_set[Sched_Attr_Flag_Bits; u32]
+
+Memfd_Create_Flags :: bit_set[Memfd_Create_Flag_Bits; u32]