package core:sys/unix

Warning: This was generated for -target:linux_arm64 and might not represent every target this package supports.

⌘K
Ctrl+K
or
/

    Index

    Constants (410)
    Variables (0)

    This section is empty.

    Procedure Groups (0)

    This section is empty.

    Types

    Perf_Capabilities ¶

    Perf_Capabilities :: struct #raw_union {
    	capabilities: u64,
    	flags:        Perf_Event_Flags,
    }

    Perf_Event_Attr ¶

    Perf_Event_Attr :: struct #packed {
    	type:               u32,
    	size:               u32,
    	config:             u64,
    	sample:             Perf_Sample,
    	sample_type:        u64,
    	read_format:        u64,
    	flags:              Perf_Flags,
    	wakeup:             Perf_Wakeup,
    	breakpoint_type:    u32,
    	field1:             Perf_Field1,
    	field2:             Perf_Field2,
    	branch_sample_type: u64,
    	sample_regs_user:   u64,
    	sample_stack_user:  u32,
    	clock_id:           i32,
    	sample_regs_intr:   u64,
    	aux_watermark:      u32,
    	sample_max_stack:   u16,
    	_padding:           u16,
    }

    Perf_Event_Flag ¶

    Perf_Event_Flag :: enum u64 {
    	Bit0               = 0, 
    	Bit0_Is_Deprecated = 1, 
    	User_Rdpmc         = 2, 
    	User_Time          = 3, 
    	User_Time_Zero     = 4, 
    	User_Time_Short    = 5, 
    }

    Perf_Event_mmap_Page ¶

    Perf_Event_mmap_Page :: struct #packed {
    	version:        u32,
    	compat_version: u32,
    	lock:           u32,
    	index:          u32,
    	offset:         i64,
    	time_enabled:   u64,
    	time_running:   u64,
    	cap:            Perf_Capabilities,
    	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:      [928]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,
    }

    Perf_Field1 ¶

    Perf_Field1 :: struct #raw_union {
    	breakpoint_addr: u64,
    	kprobe_func:     u64,
    	uprobe_path:     u64,
    	config1:         u64,
    }

    Perf_Field2 ¶

    Perf_Field2 :: struct #raw_union {
    	breakpoint_len: u64,
    	kprobe_addr:    u64,
    	uprobe_offset:  u64,
    	config2:        u64,
    }

    Perf_Flag ¶

    Perf_Flag :: enum u64 {
    	Disabled                 = 0, 
    	Inherit                  = 1, 
    	Pinned                   = 2, 
    	Exclusive                = 3, 
    	Exclude_User             = 4, 
    	Exclude_Kernel           = 5, 
    	Exclude_HV               = 6, 
    	Exclude_Idle             = 7, 
    	mmap                     = 8, 
    	Comm                     = 9, 
    	Freq                     = 10, 
    	Inherit_Stat             = 11, 
    	Enable_On_Exec           = 12, 
    	Task                     = 13, 
    	Watermark                = 14, 
    	Precise_IP_0             = 15, 
    	Precise_IP_1             = 16, 
    	mmap_Data                = 17, 
    	Sample_Id_All            = 18, 
    	Exclude_Host             = 19, 
    	Exclude_Guest            = 20, 
    	Exclude_Callchain_Kernel = 21, 
    	Exclude_Callchain_User   = 22, 
    	mmap2                    = 23, 
    	Comm_Exec                = 24, 
    	Use_Clockid              = 25, 
    	Context_Switch           = 26, 
    	Write_Backward           = 27, 
    	Namespaces               = 28, 
    	KSymbol                  = 29, 
    	BPF_Event                = 30, 
    	Aux_Output               = 31, 
    	CGroup                   = 32, 
    	Text_Poke                = 33, 
    	Build_Id                 = 34, 
    	Inherit_Thread           = 35, 
    	Remove_On_Exec           = 36, 
    	Sigtrap                  = 37, 
    }

    Perf_Hardware_Id ¶

    Perf_Hardware_Id :: enum u64 {
    	CPU_Cycles              = 0, 
    	Instructions            = 1, 
    	Cache_References        = 2, 
    	Cache_Misses            = 3, 
    	Branch_Instructions     = 4, 
    	Branch_Misses           = 5, 
    	Bus_Cycles              = 6, 
    	Stalled_Cycles_Frontend = 7, 
    	Stalled_Cycles_Backend  = 8, 
    	Ref_CPU_Cycles          = 9, 
    }

    Perf_Sample ¶

    Perf_Sample :: struct #raw_union {
    	period:    u64,
    	frequency: u64,
    }
     

    perf event data

    Perf_Type_Id ¶

    Perf_Type_Id :: enum u32 {
    	Hardware   = 0, 
    	Software   = 1, 
    	Tracepoint = 2, 
    	HW_Cache   = 3, 
    	Raw        = 4, 
    	Breakpoint = 5, 
    }

    Perf_Wakeup ¶

    Perf_Wakeup :: struct #raw_union {
    	events:    u32,
    	watermark: u32,
    }

    timespec ¶

    timespec :: struct {
    	secs:  i64,
    	nsecs: i64,
    }

    Constants

    AT_FDCWD ¶

    AT_FDCWD: uintptr : ~uintptr(99)
     

    syscall related constants

    AT_SYMLINK_FOLLOW :: uintptr(0x400)
    AT_SYMLINK_NOFOLLOW :: uintptr(0x100)

    MADV_NORMAL ¶

    MADV_NORMAL :: 0
     

    madvise flags

    MREMAP_MAYMOVE ¶

    MREMAP_MAYMOVE :: 1
     

    mremap flags

    O_CLOEXEC ¶

    O_CLOEXEC :: 0o2000000
     

    pipe2 flags

    POLLIN ¶

    POLLIN :: 0x0001
     

    poll events

    PROT_NONE ¶

    PROT_NONE :: 0x0
     

    mmap flags

    Variables

    This section is empty.

    Procedures

    get_errno ¶

    get_errno :: proc "contextless" (res: int) -> i32 {…}

    sys_accept ¶

    sys_accept :: proc "contextless" (sd: int, addr: rawptr, len: rawptr) -> int {…}

    sys_access ¶

    sys_access :: proc "contextless" (path: cstring, mask: int) -> int {…}

    sys_bind ¶

    sys_bind :: proc "contextless" (sd: int, addr: rawptr, len: i32) -> int {…}

    sys_chdir ¶

    sys_chdir :: proc "contextless" (path: cstring) -> int {…}

    sys_chmod ¶

    sys_chmod :: proc "contextless" (path: cstring, mode: uint) -> int {…}

    sys_chown ¶

    sys_chown :: proc "contextless" (path: cstring, user: int, group: int) -> int {…}

    sys_close ¶

    sys_close :: proc "contextless" (fd: int) -> int {…}

    sys_connect ¶

    sys_connect :: proc "contextless" (sd: int, addr: rawptr, len: i32) -> int {…}

    sys_dup2 ¶

    sys_dup2 :: proc "contextless" (oldfd: int, newfd: int) -> int {…}

    sys_fchdir ¶

    sys_fchdir :: proc "contextless" (fd: int) -> int {…}

    sys_fchmod ¶

    sys_fchmod :: proc "contextless" (fd: int, mode: uint) -> int {…}

    sys_fchown ¶

    sys_fchown :: proc "contextless" (fd: int, user: int, group: int) -> int {…}

    sys_fcntl ¶

    sys_fcntl :: proc "contextless" (fd: int, cmd: int, arg: int) -> int {…}

    sys_fork ¶

    sys_fork :: proc "contextless" () -> int {…}

    sys_fstat ¶

    sys_fstat :: proc "contextless" (fd: int, stat: rawptr) -> int {…}

    sys_fsync ¶

    sys_fsync :: proc "contextless" (fd: int) -> int {…}

    sys_ftruncate ¶

    sys_ftruncate :: proc "contextless" (fd: int, length: i64) -> int {…}

    sys_getcwd ¶

    sys_getcwd :: proc "contextless" (buf: rawptr, size: uint) -> int {…}

    sys_getdents64 ¶

    sys_getdents64 :: proc "contextless" (fd: int, dirent: rawptr, count: int) -> int {…}

    sys_getrandom ¶

    sys_getrandom :: proc "contextless" (buf: [^]u8, buflen: uint, flags: int) -> int {…}

    sys_gettid ¶

    sys_gettid :: proc "contextless" () -> int {…}

    sys_lchown ¶

    sys_lchown :: proc "contextless" (path: cstring, user: int, group: int) -> int {…}
    sys_link :: proc "contextless" (old_name: cstring, new_name: cstring) -> int {…}

    sys_listen ¶

    sys_listen :: proc "contextless" (sd: int, backlog: int) -> int {…}

    sys_lseek ¶

    sys_lseek :: proc "contextless" (fd: int, offset: i64, whence: int) -> i64 {…}

    sys_lstat ¶

    sys_lstat :: proc "contextless" (path: cstring, stat: rawptr) -> int {…}

    sys_madvise ¶

    sys_madvise :: proc "contextless" (addr: rawptr, length: uint, advice: int) -> int {…}

    sys_mkdir ¶

    sys_mkdir :: proc "contextless" (path: cstring, mode: uint) -> int {…}

    sys_mkdirat ¶

    sys_mkdirat :: proc "contextless" (dfd: int, path: cstring, mode: uint) -> int {…}

    sys_mknod ¶

    sys_mknod :: proc "contextless" (path: cstring, mode: uint, dev: int) -> int {…}

    sys_mknodat ¶

    sys_mknodat :: proc "contextless" (dfd: int, path: cstring, mode: uint, dev: int) -> int {…}

    sys_mmap ¶

    sys_mmap :: proc "contextless" (
    	addr:            rawptr, 
    	length:          uint, 
    	prot, flags, fd: int, 
    	offset:          uintptr, 
    ) -> int {…}

    sys_mprotect ¶

    sys_mprotect :: proc "contextless" (addr: rawptr, length: uint, prot: int) -> int {…}

    sys_mremap ¶

    sys_mremap :: proc "contextless" (
    	addr:                   rawptr, 
    	old_length, new_length: uint, 
    	flags:                  int, 
    	new_addr:               rawptr = nil, 
    ) -> int {…}

    sys_munmap ¶

    sys_munmap :: proc "contextless" (addr: rawptr, length: uint) -> int {…}

    sys_open ¶

    sys_open :: proc "contextless" (path: cstring, flags: int, mode: uint = 0o000) -> int {…}

    sys_openat ¶

    sys_openat :: proc "contextless" (
    	dfd:   int, 
    	path:  cstring, 
    	flags: int, 
    	mode:  uint = 0o000, 
    ) -> int {…}

    sys_perf_event_open ¶

    sys_perf_event_open :: proc "contextless" (
    	event_attr: rawptr, 
    	pid:        i32, 
    	cpu:        i32, 
    	group_fd:   i32, 
    	flags:      u32, 
    ) -> int {…}

    sys_personality ¶

    sys_personality :: proc(persona: u64) -> int {…}

    sys_pipe2 ¶

    sys_pipe2 :: proc "contextless" (fds: rawptr, flags: int) -> int {…}

    sys_poll ¶

    sys_poll :: proc "contextless" (fds: rawptr, nfds: uint, timeout: int) -> int {…}

    sys_ppoll ¶

    sys_ppoll :: proc "contextless" (
    	fds:        rawptr, 
    	nfds:       uint, 
    	timeout:    rawptr, 
    	sigmask:    rawptr, 
    	sigsetsize: uint, 
    ) -> int {…}

    sys_pread ¶

    sys_pread :: proc "contextless" (fd: int, buf: rawptr, size: uint, offset: i64) -> int {…}

    sys_pwrite ¶

    sys_pwrite :: proc "contextless" (fd: int, buf: rawptr, size: uint, offset: i64) -> int {…}

    sys_read ¶

    sys_read :: proc "contextless" (fd: int, buf: rawptr, size: uint) -> int {…}
    sys_readlink :: proc "contextless" (path: cstring, buf: rawptr, bufsiz: uint) -> int {…}

    sys_recvfrom ¶

    sys_recvfrom :: proc "contextless" (
    	sd:    int, 
    	buf:   rawptr, 
    	len:   uint, 
    	flags: int, 
    	addr:  rawptr, 
    	alen:  uintptr, 
    ) -> i64 {…}

    sys_rename ¶

    sys_rename :: proc "contextless" (old, new: cstring) -> int {…}

    sys_rmdir ¶

    sys_rmdir :: proc "contextless" (path: cstring) -> int {…}

    sys_sendto ¶

    sys_sendto :: proc "contextless" (
    	sd:    int, 
    	buf:   rawptr, 
    	len:   uint, 
    	flags: int, 
    	addr:  rawptr, 
    	alen:  i32, 
    ) -> i64 {…}

    sys_setsockopt ¶

    sys_setsockopt :: proc "contextless" (
    	sd:      int, 
    	level:   int, 
    	optname: int, 
    	optval:  rawptr, 
    	optlen:  i32, 
    ) -> int {…}

    sys_shutdown ¶

    sys_shutdown :: proc "contextless" (sd: int, how: int) -> int {…}

    sys_socket ¶

    sys_socket :: proc "contextless" (domain: int, type: int, protocol: int) -> int {…}

    sys_stat ¶

    sys_stat :: proc "contextless" (path: cstring, stat: rawptr) -> int {…}
    sys_symlink :: proc "contextless" (old_name: cstring, new_name: cstring) -> int {…}

    sys_truncate ¶

    sys_truncate :: proc "contextless" (path: cstring, length: i64) -> int {…}
    sys_unlink :: proc "contextless" (path: cstring) -> int {…}

    sys_unlinkat ¶

    sys_unlinkat :: proc "contextless" (dfd: int, path: cstring, flag: int = 0) -> int {…}

    sys_utimensat ¶

    sys_utimensat :: proc "contextless" (
    	dfd:   int, 
    	path:  cstring, 
    	times: rawptr, 
    	flags: int, 
    ) -> int {…}
     

    NOTE: Unsure about if this works directly on 32 bit archs. It may need 32 bit version of the time struct. As of Linux 5.1, there is a utimensat_time64 function. Maybe use this in the future?

    sys_write ¶

    sys_write :: proc "contextless" (fd: int, buf: rawptr, size: uint) -> int {…}

    Procedure Groups

    This section is empty.

    Source Files

    Generation Information

    Generated with odin version dev-2026-10 (vendor "odin") Windows_amd64 @ 2026-10-20 00:04:17.451645900 +0000 UTC