mirrors/Odin
1
0
Fork 0
mirror of https://github.com/odin-lang/Odin.git synced 2025-12-31 18:32:12 +00:00
Code Issues Packages Projects Releases Wiki Activity

freebsd_amd64 support

Browse Source
This commit is contained in:
Sébastien Marie
2022-03-13 11:42:42 +00:00
parent f907516cbd
commit ca67cf032c
9 changed files with 515 additions and 97 deletions
Download Patch File Download Diff File Expand all files Collapse all files

25
core/c/libc/stdio.odin
View File

@@ -103,6 +103,31 @@ when ODIN_OS == .OpenBSD {
}
}
when ODIN_OS == .FreeBSD {
fpos_t :: distinct i64
_IOFBF :: 0
_IOLBF :: 1
_IONBF :: 1
BUFSIZ :: 1024
EOF :: int(-1)
FOPEN_MAX :: 20
FILENAME_MAX :: 1024
SEEK_SET :: 0
SEEK_CUR :: 1
SEEK_END :: 2
foreign libc {
stderr: ^FILE
stdin: ^FILE
stdout: ^FILE
}
}
when ODIN_OS == .Darwin {
fpos_t :: distinct i64

14
core/c/libc/wctype.odin
View File

@@ -13,21 +13,23 @@ when ODIN_OS == .Windows {
when ODIN_OS == .Windows {
wctrans_t :: distinct wchar_t
wctype_t :: distinct ushort
}
when ODIN_OS == .Linux {
} else when ODIN_OS == .Linux {
wctrans_t :: distinct intptr_t
wctype_t :: distinct ulong
}
when ODIN_OS == .Darwin {
} else when ODIN_OS == .Darwin {
wctrans_t :: distinct int
wctype_t :: distinct u32
}
when ODIN_OS == .OpenBSD {
} else when ODIN_OS == .OpenBSD {
wctrans_t :: distinct rawptr
wctype_t :: distinct rawptr
} else when ODIN_OS == .FreeBSD {
wctrans_t :: distinct int
wctype_t :: distinct ulong
}
@(default_calling_convention="c")

70
core/os/dir_freebsd.odin Normal file
View File

@@ -0,0 +1,70 @@
package os
import "core:strings"
import "core:mem"
read_dir :: proc(fd: Handle, n: int, allocator := context.allocator) -> (fi: []File_Info, err: Errno) {
dirp: Dir
dirp, err = _fdopendir(fd)
if err != ERROR_NONE {
return
}
defer _closedir(dirp)
dirpath: string
dirpath, err = absolute_path_from_handle(fd)
if err != ERROR_NONE {
return
}
defer delete(dirpath)
n := n
size := n
if n <= 0 {
n = -1
size = 100
}
dfi := make([dynamic]File_Info, 0, size, allocator)
for {
entry: Dirent
end_of_stream: bool
entry, err, end_of_stream = _readdir(dirp)
if err != ERROR_NONE {
for fi_ in dfi {
file_info_delete(fi_, allocator)
}
delete(dfi)
return
} else if end_of_stream {
break
}
fi_: File_Info
filename := cast(string)(transmute(cstring)mem.Raw_Cstring{ data = &entry.name[0] })
if filename == "." || filename == ".." {
continue
}
fullpath := strings.join( []string{ dirpath, filename }, "/", context.temp_allocator)
defer delete(fullpath, context.temp_allocator)
fi_, err = stat(fullpath, allocator)
if err != ERROR_NONE {
for fi__ in dfi {
file_info_delete(fi__, allocator)
}
delete(dfi)
return
}
append(&dfi, fi_)
}
return dfi[:], ERROR_NONE
}

311
core/os/os_freebsd.odin
View File

@@ -10,7 +10,6 @@ import "core:c"
Handle :: distinct i32
File_Time :: distinct u64
Errno :: distinct i32
Syscall :: distinct i32
INVALID_HANDLE :: ~Handle(0)
@@ -142,40 +141,74 @@ RTLD_TRACE :: 0x200
RTLD_NODELETE :: 0x01000
RTLD_NOLOAD :: 0x02000
MAX_PATH :: 1024
args := _alloc_command_line_arguments()
Unix_File_Time :: struct {
seconds: i64,
seconds: time_t,
nanoseconds: c.long,
}
dev_t :: u64
ino_t :: u64
nlink_t :: u64
off_t :: i64
mode_t :: u16
pid_t :: u32
uid_t :: u32
gid_t :: u32
blkcnt_t :: i64
blksize_t :: i32
fflags_t :: u32
when ODIN_ARCH == .amd64 /* LP64 */ {
time_t :: i64
} else {
time_t :: i32
}
OS_Stat :: struct {
device_id: u64,
serial: u64,
nlink: u64,
mode: u32,
device_id: dev_t,
serial: ino_t,
nlink: nlink_t,
mode: mode_t,
_padding0: i16,
uid: u32,
gid: u32,
uid: uid_t,
gid: gid_t,
_padding1: i32,
rdev: u64,
rdev: dev_t,
last_access: Unix_File_Time,
modified: Unix_File_Time,
status_change: Unix_File_Time,
birthtime: Unix_File_Time,
size: i64,
blocks: i64,
block_size: i32,
size: off_t,
blocks: blkcnt_t,
block_size: blksize_t,
flags: u32,
flags: fflags_t,
gen: u64,
lspare: i64,
lspare: [10]u64,
}
// since FreeBSD v12
Dirent :: struct {
ino: ino_t,
off: off_t,
reclen: u16,
type: u8,
_pad0: u8,
namlen: u16,
_pad1: u16,
name: [256]byte,
}
Dir :: distinct rawptr // DIR*
// File type
S_IFMT :: 0o170000 // Type of file mask
S_IFIFO :: 0o010000 // Named pipe (fifo)
@@ -211,13 +244,13 @@ S_ISGID :: 0o2000 // Set group id on execution
S_ISVTX :: 0o1000 // Directory restrcted delete
S_ISLNK :: #force_inline proc(m: u32) -> bool do return (m & S_IFMT) == S_IFLNK
S_ISREG :: #force_inline proc(m: u32) -> bool do return (m & S_IFMT) == S_IFREG
S_ISDIR :: #force_inline proc(m: u32) -> bool do return (m & S_IFMT) == S_IFDIR
S_ISCHR :: #force_inline proc(m: u32) -> bool do return (m & S_IFMT) == S_IFCHR
S_ISBLK :: #force_inline proc(m: u32) -> bool do return (m & S_IFMT) == S_IFBLK
S_ISFIFO :: #force_inline proc(m: u32) -> bool do return (m & S_IFMT) == S_IFIFO
S_ISSOCK :: #force_inline proc(m: u32) -> bool do return (m & S_IFMT) == S_IFSOCK
S_ISLNK :: #force_inline proc(m: mode_t) -> bool do return (m & S_IFMT) == S_IFLNK
S_ISREG :: #force_inline proc(m: mode_t) -> bool do return (m & S_IFMT) == S_IFREG
S_ISDIR :: #force_inline proc(m: mode_t) -> bool do return (m & S_IFMT) == S_IFDIR
S_ISCHR :: #force_inline proc(m: mode_t) -> bool do return (m & S_IFMT) == S_IFCHR
S_ISBLK :: #force_inline proc(m: mode_t) -> bool do return (m & S_IFMT) == S_IFBLK
S_ISFIFO :: #force_inline proc(m: mode_t) -> bool do return (m & S_IFMT) == S_IFIFO
S_ISSOCK :: #force_inline proc(m: mode_t) -> bool do return (m & S_IFMT) == S_IFSOCK
F_OK :: 0 // Test for file existance
X_OK :: 1 // Test for execute permission
@@ -225,27 +258,38 @@ W_OK :: 2 // Test for write permission
R_OK :: 4 // Test for read permission
foreign libc {
@(link_name="__error") __errno_location :: proc() -> ^int ---
@(link_name="syscall") syscall :: proc(number: Syscall, #c_vararg args: ..any) -> int ---
@(link_name="__error") __errno_location :: proc() -> ^int ---
@(link_name="open") _unix_open :: proc(path: cstring, flags: c.int, mode: c.int) -> Handle ---
@(link_name="close") _unix_close :: proc(fd: Handle) -> c.int ---
@(link_name="read") _unix_read :: proc(fd: Handle, buf: rawptr, size: c.size_t) -> c.ssize_t ---
@(link_name="write") _unix_write :: proc(fd: Handle, buf: rawptr, size: c.size_t) -> c.ssize_t ---
@(link_name="lseek") _unix_seek :: proc(fd: Handle, offset: i64, whence: c.int) -> i64 ---
@(link_name="gettid") _unix_gettid :: proc() -> u64 ---
@(link_name="lseek") _unix_seek :: proc(fd: Handle, offset: i64, whence: c.int) -> i64 ---
@(link_name="getpagesize") _unix_getpagesize :: proc() -> c.int ---
@(link_name="stat") _unix_stat :: proc(path: cstring, stat: ^OS_Stat) -> c.int ---
@(link_name="stat") _unix_stat :: proc(path: cstring, stat: ^OS_Stat) -> c.int ---
@(link_name="lstat") _unix_lstat :: proc(path: cstring, sb: ^OS_Stat) -> c.int ---
@(link_name="fstat") _unix_fstat :: proc(fd: Handle, stat: ^OS_Stat) -> c.int ---
@(link_name="readlink") _unix_readlink :: proc(path: cstring, buf: ^byte, bufsiz: c.size_t) -> c.ssize_t ---
@(link_name="access") _unix_access :: proc(path: cstring, mask: c.int) -> c.int ---
@(link_name="getcwd") _unix_getcwd :: proc(buf: cstring, len: c.size_t) -> cstring ---
@(link_name="chdir") _unix_chdir :: proc(buf: cstring) -> c.int ---
@(link_name="rename") _unix_rename :: proc(old, new: cstring) -> c.int ---
@(link_name="unlink") _unix_unlink :: proc(path: cstring) -> c.int ---
@(link_name="rmdir") _unix_rmdir :: proc(path: cstring) -> c.int ---
@(link_name="mkdir") _unix_mkdir :: proc(path: cstring, mode: mode_t) -> c.int ---
@(link_name="fdopendir") _unix_fdopendir :: proc(fd: Handle) -> Dir ---
@(link_name="closedir") _unix_closedir :: proc(dirp: Dir) -> c.int ---
@(link_name="rewinddir") _unix_rewinddir :: proc(dirp: Dir) ---
@(link_name="readdir_r") _unix_readdir_r :: proc(dirp: Dir, entry: ^Dirent, result: ^^Dirent) -> c.int ---
@(link_name="malloc") _unix_malloc :: proc(size: c.size_t) -> rawptr ---
@(link_name="calloc") _unix_calloc :: proc(num, size: c.size_t) -> rawptr ---
@(link_name="free") _unix_free :: proc(ptr: rawptr) ---
@(link_name="realloc") _unix_realloc :: proc(ptr: rawptr, size: c.size_t) -> rawptr ---
@(link_name="getenv") _unix_getenv :: proc(cstring) -> cstring ---
@(link_name="getcwd") _unix_getcwd :: proc(buf: cstring, len: c.size_t) -> cstring ---
@(link_name="chdir") _unix_chdir :: proc(buf: cstring) -> c.int ---
@(link_name="realpath") _unix_realpath :: proc(path: cstring, resolved_path: rawptr) -> rawptr ---
@(link_name="exit") _unix_exit :: proc(status: c.int) -> ! ---
}
@@ -318,12 +362,102 @@ file_size :: proc(fd: Handle) -> (i64, Errno) {
return s.size, ERROR_NONE
}
stdin: Handle = 0
rename :: proc(old_path, new_path: string) -> Errno {
old_path_cstr := strings.clone_to_cstring(old_path, context.temp_allocator)
new_path_cstr := strings.clone_to_cstring(new_path, context.temp_allocator)
res := _unix_rename(old_path_cstr, new_path_cstr)
if res == -1 {
return Errno(get_last_error())
}
return ERROR_NONE
}
remove :: proc(path: string) -> Errno {
path_cstr := strings.clone_to_cstring(path, context.temp_allocator)
res := _unix_unlink(path_cstr)
if res == -1 {
return Errno(get_last_error())
}
return ERROR_NONE
}
make_directory :: proc(path: string, mode: mode_t = 0o775) -> Errno {
path_cstr := strings.clone_to_cstring(path, context.temp_allocator)
res := _unix_mkdir(path_cstr, mode)
if res == -1 {
return Errno(get_last_error())
}
return ERROR_NONE
}
remove_directory :: proc(path: string) -> Errno {
path_cstr := strings.clone_to_cstring(path, context.temp_allocator)
res := _unix_rmdir(path_cstr)
if res == -1 {
return Errno(get_last_error())
}
return ERROR_NONE
}
is_file_handle :: proc(fd: Handle) -> bool {
s, err := _fstat(fd)
if err != ERROR_NONE {
return false
}
return S_ISREG(s.mode)
}
is_file_path :: proc(path: string, follow_links: bool = true) -> bool {
s: OS_Stat
err: Errno
if follow_links {
s, err = _stat(path)
} else {
s, err = _lstat(path)
}
if err != ERROR_NONE {
return false
}
return S_ISREG(s.mode)
}
is_dir_handle :: proc(fd: Handle) -> bool {
s, err := _fstat(fd)
if err != ERROR_NONE {
return false
}
return S_ISDIR(s.mode)
}
is_dir_path :: proc(path: string, follow_links: bool = true) -> bool {
s: OS_Stat
err: Errno
if follow_links {
s, err = _stat(path)
} else {
s, err = _lstat(path)
}
if err != ERROR_NONE {
return false
}
return S_ISDIR(s.mode)
}
is_file :: proc {is_file_path, is_file_handle}
is_dir :: proc {is_dir_path, is_dir_handle}
// NOTE(bill): Uses startup to initialize it
stdin: Handle = 0
stdout: Handle = 1
stderr: Handle = 2
/* TODO(zangent): Implement these!
last_write_time :: proc(fd: Handle) -> File_Time {}
last_write_time_by_name :: proc(name: string) -> File_Time {}
*/
last_write_time :: proc(fd: Handle) -> (File_Time, Errno) {
s, err := fstat(fd)
s, err := _fstat(fd)
if err != ERROR_NONE {
return 0, err
}
@@ -332,7 +466,7 @@ last_write_time :: proc(fd: Handle) -> (File_Time, Errno) {
}
last_write_time_by_name :: proc(name: string) -> (File_Time, Errno) {
s, err := stat(name)
s, err := _stat(name)
if err != ERROR_NONE {
return 0, err
}
@@ -340,18 +474,33 @@ last_write_time_by_name :: proc(name: string) -> (File_Time, Errno) {
return File_Time(modified), ERROR_NONE
}
stat :: proc(path: string) -> (OS_Stat, Errno) {
@private
_stat :: proc(path: string) -> (OS_Stat, Errno) {
cstr := strings.clone_to_cstring(path, context.temp_allocator)
s: OS_Stat
result := _unix_stat(cstr, &s)
s: OS_Stat = ---
result := _unix_lstat(cstr, &s)
if result == -1 {
return s, Errno(get_last_error())
}
return s, ERROR_NONE
}
fstat :: proc(fd: Handle) -> (OS_Stat, Errno) {
s: OS_Stat
@private
_lstat :: proc(path: string) -> (OS_Stat, Errno) {
cstr := strings.clone_to_cstring(path, context.temp_allocator)
// deliberately uninitialized
s: OS_Stat = ---
res := _unix_lstat(cstr, &s)
if res == -1 {
return s, Errno(get_last_error())
}
return s, ERROR_NONE
}
@private
_fstat :: proc(fd: Handle) -> (OS_Stat, Errno) {
s: OS_Stat = ---
result := _unix_fstat(fd, &s)
if result == -1 {
return s, Errno(get_last_error())
@@ -359,6 +508,95 @@ fstat :: proc(fd: Handle) -> (OS_Stat, Errno) {
return s, ERROR_NONE
}
@private
_fdopendir :: proc(fd: Handle) -> (Dir, Errno) {
dirp := _unix_fdopendir(fd)
if dirp == cast(Dir)nil {
return nil, Errno(get_last_error())
}
return dirp, ERROR_NONE
}
@private
_closedir :: proc(dirp: Dir) -> Errno {
rc := _unix_closedir(dirp)
if rc != 0 {
return Errno(get_last_error())
}
return ERROR_NONE
}
@private
_rewinddir :: proc(dirp: Dir) {
_unix_rewinddir(dirp)
}
@private
_readdir :: proc(dirp: Dir) -> (entry: Dirent, err: Errno, end_of_stream: bool) {
result: ^Dirent
rc := _unix_readdir_r(dirp, &entry, &result)
if rc != 0 {
err = Errno(get_last_error())
return
}
err = ERROR_NONE
if result == nil {
end_of_stream = true
return
}
return
}
@private
_readlink :: proc(path: string) -> (string, Errno) {
path_cstr := strings.clone_to_cstring(path, context.temp_allocator)
bufsz : uint = MAX_PATH
buf := make([]byte, MAX_PATH)
for {
rc := _unix_readlink(path_cstr, &(buf[0]), bufsz)
if rc == -1 {
delete(buf)
return "", Errno(get_last_error())
} else if rc == int(bufsz) {
bufsz += MAX_PATH
delete(buf)
buf = make([]byte, bufsz)
} else {
return strings.string_from_ptr(&buf[0], rc), ERROR_NONE
}
}
unreachable()
}
// XXX FreeBSD
absolute_path_from_handle :: proc(fd: Handle) -> (string, Errno) {
return "", Errno(ENOSYS)
}
absolute_path_from_relative :: proc(rel: string) -> (path: string, err: Errno) {
rel := rel
if rel == "" {
rel = "."
}
rel_cstr := strings.clone_to_cstring(rel, context.temp_allocator)
path_ptr := _unix_realpath(rel_cstr, nil)
if path_ptr == nil {
return "", Errno(get_last_error())
}
defer _unix_free(path_ptr)
path_cstr := transmute(cstring)path_ptr
path = strings.clone( string(path_cstr) )
return path, ERROR_NONE
}
access :: proc(path: string, mask: int) -> (bool, Errno) {
cstr := strings.clone_to_cstring(path, context.temp_allocator)
result := _unix_access(cstr, c.int(mask))
@@ -464,4 +702,3 @@ _alloc_command_line_arguments :: proc() -> []string {
}
return res
}

4
core/os/stat_unix.odin
View File

@@ -1,4 +1,4 @@
//+build linux, darwin, openbsd
//+build linux, darwin, freebsd, openbsd
package os
import "core:time"
@@ -61,7 +61,7 @@ _make_time_from_unix_file_time :: proc(uft: Unix_File_Time) -> time.Time {
_fill_file_info_from_stat :: proc(fi: ^File_Info, s: OS_Stat) {
fi.size = s.size
fi.mode = cast(File_Mode)s.mode
fi.is_dir = S_ISDIR(u32(s.mode))
fi.is_dir = S_ISDIR(s.mode)
// NOTE(laleksic, 2021-01-21): Not really creation time, but closest we can get (maybe better to leave it 0?)
fi.creation_time = _make_time_from_unix_file_time(s.status_change)

75
core/sync/sync2/futex_freebsd.odin Normal file
View File

@@ -0,0 +1,75 @@
//+private
//+build freebsd
package sync2
import "core:c"
import "core:os"
import "core:time"
UMTX_OP_WAIT :: 2
UMTX_OP_WAKE :: 3
foreign import libc "system:c"
foreign libc {
_umtx_op :: proc "c" (obj: rawptr, op: c.int, val: c.ulong, uaddr: rawptr, uaddr2: rawptr) -> c.int ---
}
_futex_wait :: proc(f: ^Futex, expected: u32) -> bool {
timeout := os.Unix_File_Time{
seconds = 5,
nanoseconds = 0,
}
for {
res := _umtx_op(f, UMTX_OP_WAIT, c.ulong(expected), nil, &timeout)
if res != -1 {
return true
}
if os.Errno(os.get_last_error()) == os.ETIMEDOUT {
continue
}
panic("_futex_wait failure")
}
unreachable()
}
_futex_wait_with_timeout :: proc(f: ^Futex, expected: u32, duration: time.Duration) -> bool {
if duration <= 0 {
return false
}
res := _umtx_op(f, UMTX_OP_WAIT, c.ulong(expected), nil, &os.Unix_File_Time{
seconds = (os.time_t)(duration/1e9),
nanoseconds = (c.long)(duration%1e9),
})
if res != -1 {
return true
}
if os.Errno(os.get_last_error()) == os.ETIMEDOUT {
return false
}
panic("_futex_wait_with_timeout failure")
}
_futex_signal :: proc(f: ^Futex) {
res := _umtx_op(f, UMTX_OP_WAKE, 1, nil, nil)
if res == -1 {
panic("_futex_signal failure")
}
}
_futex_broadcast :: proc(f: ^Futex) {
res := _umtx_op(f, UMTX_OP_WAKE, c.ulong(max(i32)), nil, nil)
if res == -1 {
panic("_futex_broadcast failure")
}
}

9
core/sync/sync2/primitives_freebsd.odin Normal file
View File

@@ -0,0 +1,9 @@
//+build freebsd
//+private
package sync2
import "core:os"
_current_thread_id :: proc "contextless" () -> int {
return os.current_thread_id()
}

14
core/sync/sync_freebsd.odin
View File

@@ -5,8 +5,8 @@ import "core:intrinsics"
current_thread_id :: proc "contextless" () -> int {
SYS_GETTID :: 186;
return int(intrinsics.syscall(SYS_GETTID));
SYS_GETTID :: 186
return int(intrinsics.syscall(SYS_GETTID))
}
@@ -19,22 +19,22 @@ Semaphore :: struct #align 16 {
}
semaphore_init :: proc(s: ^Semaphore, initial_count := 0) {
assert(unix.sem_init(&s.handle, 0, u32(initial_count)) == 0);
assert(unix.sem_init(&s.handle, 0, u32(initial_count)) == 0)
}
semaphore_destroy :: proc(s: ^Semaphore) {
assert(unix.sem_destroy(&s.handle) == 0);
s.handle = {};
assert(unix.sem_destroy(&s.handle) == 0)
s.handle = {}
}
semaphore_post :: proc(s: ^Semaphore, count := 1) {
// NOTE: SPEED: If there's one syscall to do this, we should use it instead of the loop.
for in 0..<count {
assert(unix.sem_post(&s.handle) == 0);
assert(unix.sem_post(&s.handle) == 0)
}
}
semaphore_wait_for :: proc(s: ^Semaphore) {
assert(unix.sem_wait(&s.handle) == 0);
assert(unix.sem_wait(&s.handle) == 0)
}

90
core/sys/unix/pthread_freebsd.odin
View File

@@ -1,76 +1,76 @@
//+build freebsd
package unix
import "core:c";
import "core:c"
pthread_t :: distinct u64;
// pthread_t :: struct #align 16 { x: u64 };
pthread_t :: distinct u64
// pthread_t :: struct #align 16 { x: u64 }
PTHREAD_COND_T_SIZE :: 8;
PTHREAD_COND_T_SIZE :: 8
PTHREAD_MUTEXATTR_T_SIZE :: 8;
PTHREAD_CONDATTR_T_SIZE :: 8;
PTHREAD_RWLOCKATTR_T_SIZE :: 8;
PTHREAD_BARRIERATTR_T_SIZE :: 8;
PTHREAD_MUTEXATTR_T_SIZE :: 8
PTHREAD_CONDATTR_T_SIZE :: 8
PTHREAD_RWLOCKATTR_T_SIZE :: 8
PTHREAD_BARRIERATTR_T_SIZE :: 8
// WARNING: The sizes of these things are different yet again
// on non-X86!
when size_of(int) == 8 {
PTHREAD_ATTR_T_SIZE :: 8;
PTHREAD_MUTEX_T_SIZE :: 8;
PTHREAD_RWLOCK_T_SIZE :: 8;
PTHREAD_BARRIER_T_SIZE :: 8;
PTHREAD_ATTR_T_SIZE :: 8
PTHREAD_MUTEX_T_SIZE :: 8
PTHREAD_RWLOCK_T_SIZE :: 8
PTHREAD_BARRIER_T_SIZE :: 8
} else when size_of(int) == 4 { // TODO
PTHREAD_ATTR_T_SIZE :: 32;
PTHREAD_MUTEX_T_SIZE :: 32;
PTHREAD_RWLOCK_T_SIZE :: 44;
PTHREAD_BARRIER_T_SIZE :: 20;
PTHREAD_ATTR_T_SIZE :: 32
PTHREAD_MUTEX_T_SIZE :: 32
PTHREAD_RWLOCK_T_SIZE :: 44
PTHREAD_BARRIER_T_SIZE :: 20
}
pthread_cond_t :: struct #align 16 {
_: [PTHREAD_COND_T_SIZE] c.char,
};
}
pthread_mutex_t :: struct #align 16 {
_: [PTHREAD_MUTEX_T_SIZE] c.char,
};
}
pthread_rwlock_t :: struct #align 16 {
_: [PTHREAD_RWLOCK_T_SIZE] c.char,
};
}
pthread_barrier_t :: struct #align 16 {
_: [PTHREAD_BARRIER_T_SIZE] c.char,
};
}
pthread_attr_t :: struct #align 16 {
_: [PTHREAD_ATTR_T_SIZE] c.char,
};
}
pthread_condattr_t :: struct #align 16 {
_: [PTHREAD_CONDATTR_T_SIZE] c.char,
};
}
pthread_mutexattr_t :: struct #align 16 {
_: [PTHREAD_MUTEXATTR_T_SIZE] c.char,
};
}
pthread_rwlockattr_t :: struct #align 16 {
_: [PTHREAD_RWLOCKATTR_T_SIZE] c.char,
};
}
pthread_barrierattr_t :: struct #align 16 {
_: [PTHREAD_BARRIERATTR_T_SIZE] c.char,
};
}
PTHREAD_MUTEX_ERRORCHECK :: 1;
PTHREAD_MUTEX_RECURSIVE :: 2;
PTHREAD_MUTEX_NORMAL :: 3;
PTHREAD_MUTEX_ERRORCHECK :: 1
PTHREAD_MUTEX_RECURSIVE :: 2
PTHREAD_MUTEX_NORMAL :: 3
PTHREAD_CREATE_JOINABLE :: 0;
PTHREAD_CREATE_DETACHED :: 1;
PTHREAD_INHERIT_SCHED :: 4;
PTHREAD_EXPLICIT_SCHED :: 0;
PTHREAD_PROCESS_PRIVATE :: 0;
PTHREAD_PROCESS_SHARED :: 1;
PTHREAD_CREATE_JOINABLE :: 0
PTHREAD_CREATE_DETACHED :: 1
PTHREAD_INHERIT_SCHED :: 4
PTHREAD_EXPLICIT_SCHED :: 0
PTHREAD_PROCESS_PRIVATE :: 0
PTHREAD_PROCESS_SHARED :: 1
SCHED_FIFO :: 1;
SCHED_OTHER :: 2;
SCHED_RR :: 3; // Round robin.
SCHED_FIFO :: 1
SCHED_OTHER :: 2
SCHED_RR :: 3 // Round robin.
sched_param :: struct {
@@ -98,17 +98,17 @@ foreign import "system:pthread"
foreign pthread {
// create named semaphore.
// used in process-shared semaphores.
sem_open :: proc(name: cstring, flags: c.int) -> ^sem_t ---;
sem_open :: proc(name: cstring, flags: c.int) -> ^sem_t ---
sem_init :: proc(sem: ^sem_t, pshared: c.int, initial_value: c.uint) -> c.int ---;
sem_destroy :: proc(sem: ^sem_t) -> c.int ---;
sem_post :: proc(sem: ^sem_t) -> c.int ---;
sem_wait :: proc(sem: ^sem_t) -> c.int ---;
sem_trywait :: proc(sem: ^sem_t) -> c.int ---;
// sem_timedwait :: proc(sem: ^sem_t, timeout: time.TimeSpec) -> c.int ---;
sem_init :: proc(sem: ^sem_t, pshared: c.int, initial_value: c.uint) -> c.int ---
sem_destroy :: proc(sem: ^sem_t) -> c.int ---
sem_post :: proc(sem: ^sem_t) -> c.int ---
sem_wait :: proc(sem: ^sem_t) -> c.int ---
sem_trywait :: proc(sem: ^sem_t) -> c.int ---
// sem_timedwait :: proc(sem: ^sem_t, timeout: time.TimeSpec) -> c.int ---
// NOTE: unclear whether pthread_yield is well-supported on Linux systems,
// see https://linux.die.net/man/3/pthread_yield
pthread_yield :: proc() ---;
pthread_yield :: proc() ---
}