mirror of
https://github.com/ziglang/zig.git
synced 2025-12-06 14:23:09 +00:00
b78f3bf1f1
POSIX specifies that the sa_handler field of the sigaction struct may be set to SIG_IGN or SIG_DFL. However, the current constants in the standard library use the function pointer signature corresponding to the sa_sigaction field instead. This may not cause issues in practice because the fields usually occupy the same memory in a union, but this isn't required by POSIX and there may be systems we do not yet support that do this differently. Fixing this also makes the Zig interface less confusing to use after reading the man page.
2688 lines
75 KiB
Zig
2688 lines
75 KiB
Zig
const std = @import("../std.zig");
|
|
const builtin = @import("builtin");
|
|
const assert = std.debug.assert;
|
|
const macho = std.macho;
|
|
const native_arch = builtin.target.cpu.arch;
|
|
const maxInt = std.math.maxInt;
|
|
const iovec_const = std.os.iovec_const;
|
|
|
|
pub const aarch64 = @import("darwin/aarch64.zig");
|
|
pub const x86_64 = @import("darwin/x86_64.zig");
|
|
|
|
const arch_bits = switch (native_arch) {
|
|
.aarch64 => @import("darwin/aarch64.zig"),
|
|
.x86_64 => @import("darwin/x86_64.zig"),
|
|
else => struct {},
|
|
};
|
|
|
|
pub const ucontext_t = extern struct {
|
|
onstack: c_int,
|
|
sigmask: sigset_t,
|
|
stack: stack_t,
|
|
link: ?*ucontext_t,
|
|
mcsize: u64,
|
|
mcontext: *mcontext_t,
|
|
};
|
|
|
|
pub const mcontext_t = extern struct {
|
|
es: arch_bits.exception_state,
|
|
ss: arch_bits.thread_state,
|
|
};
|
|
|
|
extern "c" fn __error() *c_int;
|
|
pub extern "c" fn NSVersionOfRunTimeLibrary(library_name: [*:0]const u8) u32;
|
|
pub extern "c" fn _NSGetExecutablePath(buf: [*:0]u8, bufsize: *u32) c_int;
|
|
pub extern "c" fn _dyld_image_count() u32;
|
|
pub extern "c" fn _dyld_get_image_header(image_index: u32) ?*mach_header;
|
|
pub extern "c" fn _dyld_get_image_vmaddr_slide(image_index: u32) usize;
|
|
pub extern "c" fn _dyld_get_image_name(image_index: u32) [*:0]const u8;
|
|
|
|
pub const COPYFILE_ACL = 1 << 0;
|
|
pub const COPYFILE_STAT = 1 << 1;
|
|
pub const COPYFILE_XATTR = 1 << 2;
|
|
pub const COPYFILE_DATA = 1 << 3;
|
|
|
|
pub const copyfile_state_t = *opaque {};
|
|
pub extern "c" fn fcopyfile(from: fd_t, to: fd_t, state: ?copyfile_state_t, flags: u32) c_int;
|
|
|
|
pub extern "c" fn @"realpath$DARWIN_EXTSN"(noalias file_name: [*:0]const u8, noalias resolved_name: [*]u8) ?[*:0]u8;
|
|
pub const realpath = @"realpath$DARWIN_EXTSN";
|
|
|
|
pub extern "c" fn __getdirentries64(fd: c_int, buf_ptr: [*]u8, buf_len: usize, basep: *i64) isize;
|
|
|
|
const private = struct {
|
|
extern "c" fn fstat(fd: fd_t, buf: *Stat) c_int;
|
|
/// On x86_64 Darwin, fstat has to be manully linked with $INODE64 suffix to
|
|
/// force 64bit version.
|
|
/// Note that this is fixed on aarch64 and no longer necessary.
|
|
extern "c" fn @"fstat$INODE64"(fd: fd_t, buf: *Stat) c_int;
|
|
|
|
extern "c" fn fstatat(dirfd: fd_t, path: [*:0]const u8, stat_buf: *Stat, flags: u32) c_int;
|
|
/// On x86_64 Darwin, fstatat has to be manully linked with $INODE64 suffix to
|
|
/// force 64bit version.
|
|
/// Note that this is fixed on aarch64 and no longer necessary.
|
|
extern "c" fn @"fstatat$INODE64"(dirfd: fd_t, path_name: [*:0]const u8, buf: *Stat, flags: u32) c_int;
|
|
|
|
extern "c" fn readdir(dir: *std.c.DIR) ?*dirent;
|
|
extern "c" fn @"readdir$INODE64"(dir: *std.c.DIR) ?*dirent;
|
|
};
|
|
pub const fstat = if (native_arch == .aarch64) private.fstat else private.@"fstat$INODE64";
|
|
pub const fstatat = if (native_arch == .aarch64) private.fstatat else private.@"fstatat$INODE64";
|
|
pub const readdir = if (native_arch == .aarch64) private.readdir else private.@"readdir$INODE64";
|
|
|
|
pub extern "c" fn mach_absolute_time() u64;
|
|
pub extern "c" fn mach_continuous_time() u64;
|
|
pub extern "c" fn mach_timebase_info(tinfo: ?*mach_timebase_info_data) kern_return_t;
|
|
|
|
pub extern "c" fn malloc_size(?*const anyopaque) usize;
|
|
pub extern "c" fn posix_memalign(memptr: *?*anyopaque, alignment: usize, size: usize) c_int;
|
|
|
|
pub const posix_spawnattr_t = *opaque {};
|
|
pub const posix_spawn_file_actions_t = *opaque {};
|
|
pub extern "c" fn posix_spawnattr_init(attr: *posix_spawnattr_t) c_int;
|
|
pub extern "c" fn posix_spawnattr_destroy(attr: *posix_spawnattr_t) void;
|
|
pub extern "c" fn posix_spawnattr_setflags(attr: *posix_spawnattr_t, flags: c_short) c_int;
|
|
pub extern "c" fn posix_spawnattr_getflags(attr: *const posix_spawnattr_t, flags: *c_short) c_int;
|
|
pub extern "c" fn posix_spawn_file_actions_init(actions: *posix_spawn_file_actions_t) c_int;
|
|
pub extern "c" fn posix_spawn_file_actions_destroy(actions: *posix_spawn_file_actions_t) void;
|
|
pub extern "c" fn posix_spawn_file_actions_addclose(actions: *posix_spawn_file_actions_t, filedes: fd_t) c_int;
|
|
pub extern "c" fn posix_spawn_file_actions_addopen(
|
|
actions: *posix_spawn_file_actions_t,
|
|
filedes: fd_t,
|
|
path: [*:0]const u8,
|
|
oflag: c_int,
|
|
mode: mode_t,
|
|
) c_int;
|
|
pub extern "c" fn posix_spawn_file_actions_adddup2(
|
|
actions: *posix_spawn_file_actions_t,
|
|
filedes: fd_t,
|
|
newfiledes: fd_t,
|
|
) c_int;
|
|
pub extern "c" fn posix_spawn_file_actions_addinherit_np(actions: *posix_spawn_file_actions_t, filedes: fd_t) c_int;
|
|
pub extern "c" fn posix_spawn_file_actions_addchdir_np(actions: *posix_spawn_file_actions_t, path: [*:0]const u8) c_int;
|
|
pub extern "c" fn posix_spawn_file_actions_addfchdir_np(actions: *posix_spawn_file_actions_t, filedes: fd_t) c_int;
|
|
pub extern "c" fn posix_spawn(
|
|
pid: *pid_t,
|
|
path: [*:0]const u8,
|
|
actions: ?*const posix_spawn_file_actions_t,
|
|
attr: ?*const posix_spawnattr_t,
|
|
argv: [*:null]?[*:0]const u8,
|
|
env: [*:null]?[*:0]const u8,
|
|
) c_int;
|
|
pub extern "c" fn posix_spawnp(
|
|
pid: *pid_t,
|
|
path: [*:0]const u8,
|
|
actions: ?*const posix_spawn_file_actions_t,
|
|
attr: ?*const posix_spawnattr_t,
|
|
argv: [*:null]?[*:0]const u8,
|
|
env: [*:null]?[*:0]const u8,
|
|
) c_int;
|
|
|
|
pub extern "c" fn kevent64(
|
|
kq: c_int,
|
|
changelist: [*]const kevent64_s,
|
|
nchanges: c_int,
|
|
eventlist: [*]kevent64_s,
|
|
nevents: c_int,
|
|
flags: c_uint,
|
|
timeout: ?*const timespec,
|
|
) c_int;
|
|
|
|
const mach_hdr = if (@sizeOf(usize) == 8) mach_header_64 else mach_header;
|
|
|
|
/// The value of the link editor defined symbol _MH_EXECUTE_SYM is the address
|
|
/// of the mach header in a Mach-O executable file type. It does not appear in
|
|
/// any file type other than a MH_EXECUTE file type. The type of the symbol is
|
|
/// absolute as the header is not part of any section.
|
|
/// This symbol is populated when linking the system's libc, which is guaranteed
|
|
/// on this operating system. However when building object files or libraries,
|
|
/// the system libc won't be linked until the final executable. So we
|
|
/// export a weak symbol here, to be overridden by the real one.
|
|
var dummy_execute_header: mach_hdr = undefined;
|
|
pub extern var _mh_execute_header: mach_hdr;
|
|
comptime {
|
|
if (builtin.target.isDarwin()) {
|
|
@export(dummy_execute_header, .{ .name = "_mh_execute_header", .linkage = .Weak });
|
|
}
|
|
}
|
|
|
|
pub const mach_header_64 = macho.mach_header_64;
|
|
pub const mach_header = macho.mach_header;
|
|
|
|
pub const _errno = __error;
|
|
|
|
pub extern "c" fn @"close$NOCANCEL"(fd: fd_t) c_int;
|
|
pub extern "c" fn mach_host_self() mach_port_t;
|
|
pub extern "c" fn clock_get_time(clock_serv: clock_serv_t, cur_time: *mach_timespec_t) kern_return_t;
|
|
|
|
pub const vm_map_t = mach_port_t;
|
|
pub const vm_map_read_t = mach_port_t;
|
|
pub const vm_region_flavor_t = c_int;
|
|
pub const vm_region_info_t = *c_int;
|
|
pub const vm_region_recurse_info_t = *c_int;
|
|
pub const mach_vm_address_t = usize;
|
|
pub const vm_offset_t = usize;
|
|
pub const mach_vm_size_t = u64;
|
|
pub const mach_msg_type_number_t = natural_t;
|
|
|
|
extern "c" var mach_task_self_: mach_port_t;
|
|
pub fn mach_task_self() callconv(.C) mach_port_t {
|
|
return mach_task_self_;
|
|
}
|
|
|
|
pub const task_read_t = mach_port_t;
|
|
|
|
pub extern "c" fn task_resume(target_task: task_read_t) kern_return_t;
|
|
pub extern "c" fn task_suspend(target_task: task_read_t) kern_return_t;
|
|
|
|
pub extern "c" fn task_for_pid(target_tport: mach_port_name_t, pid: pid_t, t: *mach_port_name_t) kern_return_t;
|
|
pub extern "c" fn mach_vm_read(
|
|
target_task: vm_map_read_t,
|
|
address: mach_vm_address_t,
|
|
size: mach_vm_size_t,
|
|
data: *vm_offset_t,
|
|
data_cnt: *mach_msg_type_number_t,
|
|
) kern_return_t;
|
|
pub extern "c" fn mach_vm_write(
|
|
target_task: vm_map_t,
|
|
address: mach_vm_address_t,
|
|
data: vm_offset_t,
|
|
data_cnt: mach_msg_type_number_t,
|
|
) kern_return_t;
|
|
pub extern "c" fn mach_vm_region(
|
|
target_task: vm_map_t,
|
|
address: *mach_vm_address_t,
|
|
size: *mach_vm_size_t,
|
|
flavor: vm_region_flavor_t,
|
|
info: vm_region_info_t,
|
|
info_cnt: *mach_msg_type_number_t,
|
|
object_name: *mach_port_t,
|
|
) kern_return_t;
|
|
pub extern "c" fn mach_vm_region_recurse(
|
|
target_task: vm_map_t,
|
|
address: *mach_vm_address_t,
|
|
size: *mach_vm_size_t,
|
|
nesting_depth: *natural_t,
|
|
info: vm_region_recurse_info_t,
|
|
info_cnt: *mach_msg_type_number_t,
|
|
) kern_return_t;
|
|
|
|
pub const vm_inherit_t = u32;
|
|
pub const memory_object_offset_t = u64;
|
|
pub const vm_behavior_t = i32;
|
|
pub const vm32_object_id_t = u32;
|
|
pub const vm_object_id_t = u64;
|
|
|
|
pub const VM_INHERIT_SHARE: vm_inherit_t = 0;
|
|
pub const VM_INHERIT_COPY: vm_inherit_t = 1;
|
|
pub const VM_INHERIT_NONE: vm_inherit_t = 2;
|
|
pub const VM_INHERIT_DONATE_COPY: vm_inherit_t = 3;
|
|
pub const VM_INHERIT_DEFAULT = VM_INHERIT_COPY;
|
|
|
|
pub const VM_BEHAVIOR_DEFAULT: vm_behavior_t = 0;
|
|
pub const VM_BEHAVIOR_RANDOM: vm_behavior_t = 1;
|
|
pub const VM_BEHAVIOR_SEQUENTIAL: vm_behavior_t = 2;
|
|
pub const VM_BEHAVIOR_RSEQNTL: vm_behavior_t = 3;
|
|
|
|
pub const VM_BEHAVIOR_WILLNEED: vm_behavior_t = 4;
|
|
pub const VM_BEHAVIOR_DONTNEED: vm_behavior_t = 5;
|
|
pub const VM_BEHAVIOR_FREE: vm_behavior_t = 6;
|
|
pub const VM_BEHAVIOR_ZERO_WIRED_PAGES: vm_behavior_t = 7;
|
|
pub const VM_BEHAVIOR_REUSABLE: vm_behavior_t = 8;
|
|
pub const VM_BEHAVIOR_REUSE: vm_behavior_t = 9;
|
|
pub const VM_BEHAVIOR_CAN_REUSE: vm_behavior_t = 10;
|
|
pub const VM_BEHAVIOR_PAGEOUT: vm_behavior_t = 11;
|
|
|
|
pub const VM_REGION_BASIC_INFO_64 = 9;
|
|
pub const VM_REGION_EXTENDED_INFO = 13;
|
|
pub const VM_REGION_TOP_INFO = 12;
|
|
pub const VM_REGION_SUBMAP_INFO_COUNT_64: mach_msg_type_number_t = @sizeOf(vm_region_submap_info_64) / @sizeOf(natural_t);
|
|
pub const VM_REGION_SUBMAP_SHORT_INFO_COUNT_64: mach_msg_type_number_t = @sizeOf(vm_region_submap_short_info_64) / @sizeOf(natural_t);
|
|
pub const VM_REGION_BASIC_INFO_COUNT: mach_msg_type_number_t = @sizeOf(vm_region_basic_info_64) / @sizeOf(c_int);
|
|
pub const VM_REGION_EXTENDED_INFO_COUNT: mach_msg_type_number_t = @sizeOf(vm_region_extended_info) / @sizeOf(natural_t);
|
|
pub const VM_REGION_TOP_INFO_COUNT: mach_msg_type_number_t = @sizeOf(vm_region_top_info) / @sizeOf(natural_t);
|
|
|
|
pub const vm_region_basic_info_64 = extern struct {
|
|
protection: vm_prot_t,
|
|
max_protection: vm_prot_t,
|
|
inheritance: vm_inherit_t,
|
|
shared: boolean_t,
|
|
reserved: boolean_t,
|
|
offset: memory_object_offset_t,
|
|
behavior: vm_behavior_t,
|
|
user_wired_count: u16,
|
|
};
|
|
|
|
pub const vm_region_extended_info = extern struct {
|
|
protection: vm_prot_t,
|
|
user_tag: u32,
|
|
pages_resident: u32,
|
|
pages_shared_now_private: u32,
|
|
pages_swapped_out: u32,
|
|
pages_dirtied: u32,
|
|
ref_count: u32,
|
|
shadow_depth: u16,
|
|
external_pager: u8,
|
|
share_mode: u8,
|
|
pages_reusable: u32,
|
|
};
|
|
|
|
pub const vm_region_top_info = extern struct {
|
|
obj_id: u32,
|
|
ref_count: u32,
|
|
private_pages_resident: u32,
|
|
shared_pages_resident: u32,
|
|
share_mode: u8,
|
|
};
|
|
|
|
pub const vm_region_submap_info_64 = extern struct {
|
|
// present across protection
|
|
protection: vm_prot_t,
|
|
// max avail through vm_prot
|
|
max_protection: vm_prot_t,
|
|
// behavior of map/obj on fork
|
|
inheritance: vm_inherit_t,
|
|
// offset into object/map
|
|
offset: memory_object_offset_t,
|
|
// user tag on map entry
|
|
user_tag: u32,
|
|
// only valid for objects
|
|
pages_resident: u32,
|
|
// only for objects
|
|
pages_shared_now_private: u32,
|
|
// only for objects
|
|
pages_swapped_out: u32,
|
|
// only for objects
|
|
pages_dirtied: u32,
|
|
// obj/map mappers, etc.
|
|
ref_count: u32,
|
|
// only for obj
|
|
shadow_depth: u16,
|
|
// only for obj
|
|
external_pager: u8,
|
|
// see enumeration
|
|
share_mode: u8,
|
|
// submap vs obj
|
|
is_submap: boolean_t,
|
|
// access behavior hint
|
|
behavior: vm_behavior_t,
|
|
// obj/map name, not a handle
|
|
object_id: vm32_object_id_t,
|
|
user_wired_count: u16,
|
|
pages_reusable: u32,
|
|
object_id_full: vm_object_id_t,
|
|
};
|
|
|
|
pub const vm_region_submap_short_info_64 = extern struct {
|
|
// present access protection
|
|
protection: vm_prot_t,
|
|
// max avail through vm_prot
|
|
max_protection: vm_prot_t,
|
|
// behavior of map/obj on fork
|
|
inheritance: vm_inherit_t,
|
|
// offset into object/map
|
|
offset: memory_object_offset_t,
|
|
// user tag on map entry
|
|
user_tag: u32,
|
|
// obj/map mappers, etc
|
|
ref_count: u32,
|
|
// only for obj
|
|
shadow_depth: u16,
|
|
// only for obj
|
|
external_pager: u8,
|
|
// see enumeration
|
|
share_mode: u8,
|
|
// submap vs obj
|
|
is_submap: boolean_t,
|
|
// access behavior hint
|
|
behavior: vm_behavior_t,
|
|
// obj/map name, not a handle
|
|
object_id: vm32_object_id_t,
|
|
user_wired_count: u16,
|
|
};
|
|
|
|
pub const thread_act_t = mach_port_t;
|
|
pub const thread_state_t = *natural_t;
|
|
pub const mach_port_array_t = *mach_port_t;
|
|
|
|
pub extern "c" fn task_threads(
|
|
target_task: mach_port_t,
|
|
init_port_set: *mach_port_array_t,
|
|
init_port_count: *mach_msg_type_number_t,
|
|
) kern_return_t;
|
|
pub extern "c" fn thread_get_state(
|
|
thread: thread_act_t,
|
|
flavor: thread_flavor_t,
|
|
state: thread_state_t,
|
|
count: *mach_msg_type_number_t,
|
|
) kern_return_t;
|
|
pub extern "c" fn thread_set_state(
|
|
thread: thread_act_t,
|
|
flavor: thread_flavor_t,
|
|
new_state: thread_state_t,
|
|
count: mach_msg_type_number_t,
|
|
) kern_return_t;
|
|
pub extern "c" fn thread_info(
|
|
thread: thread_act_t,
|
|
flavor: thread_flavor_t,
|
|
info: thread_info_t,
|
|
count: *mach_msg_type_number_t,
|
|
) kern_return_t;
|
|
pub extern "c" fn thread_resume(thread: thread_act_t) kern_return_t;
|
|
|
|
pub const THREAD_BASIC_INFO = 3;
|
|
pub const THREAD_BASIC_INFO_COUNT: mach_msg_type_number_t = @sizeOf(thread_basic_info) / @sizeOf(natural_t);
|
|
|
|
pub const thread_flavor_t = natural_t;
|
|
pub const thread_info_t = *integer_t;
|
|
pub const time_value_t = time_value;
|
|
pub const task_policy_flavor_t = natural_t;
|
|
pub const task_policy_t = *integer_t;
|
|
pub const policy_t = c_int;
|
|
|
|
pub const time_value = extern struct {
|
|
seconds: integer_t,
|
|
microseconds: integer_t,
|
|
};
|
|
|
|
pub const thread_basic_info = extern struct {
|
|
// user run time
|
|
user_time: time_value_t,
|
|
// system run time
|
|
system_time: time_value_t,
|
|
// scaled cpu usage percentage
|
|
cpu_usage: integer_t,
|
|
// scheduling policy in effect
|
|
policy: policy_t,
|
|
// run state
|
|
run_state: integer_t,
|
|
// various flags
|
|
flags: integer_t,
|
|
// suspend count for thread
|
|
suspend_count: integer_t,
|
|
// number of seconds that thread has been sleeping
|
|
sleep_time: integer_t,
|
|
};
|
|
|
|
/// Cachability
|
|
pub const MATTR_CACHE = 1;
|
|
/// Migrability
|
|
pub const MATTR_MIGRATE = 2;
|
|
/// Replicability
|
|
pub const MATTR_REPLICATE = 4;
|
|
|
|
/// (Generic) turn attribute off
|
|
pub const MATTR_VAL_OFF = 0;
|
|
/// (Generic) turn attribute on
|
|
pub const MATTR_VAL_ON = 1;
|
|
/// (Generic) return current value
|
|
pub const MATTR_VAL_GET = 2;
|
|
/// Flush from all caches
|
|
pub const MATTR_VAL_CACHE_FLUSH = 6;
|
|
/// Flush from data caches
|
|
pub const MATTR_VAL_DCACHE_FLUSH = 7;
|
|
/// Flush from instruction caches
|
|
pub const MATTR_VAL_ICACHE_FLUSH = 8;
|
|
/// Sync I+D caches
|
|
pub const MATTR_VAL_CACHE_SYNC = 9;
|
|
/// Get page info (stats)
|
|
pub const MATTR_VAL_GET_INFO = 10;
|
|
|
|
pub const TASK_VM_INFO = 22;
|
|
pub const TASK_VM_INFO_COUNT: mach_msg_type_number_t = @sizeOf(task_vm_info_data_t) / @sizeOf(natural_t);
|
|
|
|
pub const task_vm_info = extern struct {
|
|
// virtual memory size (bytes)
|
|
virtual_size: mach_vm_size_t,
|
|
// number of memory regions
|
|
region_count: integer_t,
|
|
page_size: integer_t,
|
|
// resident memory size (bytes)
|
|
resident_size: mach_vm_size_t,
|
|
// peak resident size (bytes)
|
|
resident_size_peak: mach_vm_size_t,
|
|
|
|
device: mach_vm_size_t,
|
|
device_peak: mach_vm_size_t,
|
|
internal: mach_vm_size_t,
|
|
internal_peak: mach_vm_size_t,
|
|
external: mach_vm_size_t,
|
|
external_peak: mach_vm_size_t,
|
|
reusable: mach_vm_size_t,
|
|
reusable_peak: mach_vm_size_t,
|
|
purgeable_volatile_pmap: mach_vm_size_t,
|
|
purgeable_volatile_resident: mach_vm_size_t,
|
|
purgeable_volatile_virtual: mach_vm_size_t,
|
|
compressed: mach_vm_size_t,
|
|
compressed_peak: mach_vm_size_t,
|
|
compressed_lifetime: mach_vm_size_t,
|
|
|
|
// added for rev1
|
|
phys_footprint: mach_vm_size_t,
|
|
|
|
// added for rev2
|
|
min_address: mach_vm_address_t,
|
|
max_address: mach_vm_address_t,
|
|
|
|
// added for rev3
|
|
ledger_phys_footprint_peak: i64,
|
|
ledger_purgeable_nonvolatile: i64,
|
|
ledger_purgeable_novolatile_compressed: i64,
|
|
ledger_purgeable_volatile: i64,
|
|
ledger_purgeable_volatile_compressed: i64,
|
|
ledger_tag_network_nonvolatile: i64,
|
|
ledger_tag_network_nonvolatile_compressed: i64,
|
|
ledger_tag_network_volatile: i64,
|
|
ledger_tag_network_volatile_compressed: i64,
|
|
ledger_tag_media_footprint: i64,
|
|
ledger_tag_media_footprint_compressed: i64,
|
|
ledger_tag_media_nofootprint: i64,
|
|
ledger_tag_media_nofootprint_compressed: i64,
|
|
ledger_tag_graphics_footprint: i64,
|
|
ledger_tag_graphics_footprint_compressed: i64,
|
|
ledger_tag_graphics_nofootprint: i64,
|
|
ledger_tag_graphics_nofootprint_compressed: i64,
|
|
ledger_tag_neural_footprint: i64,
|
|
ledger_tag_neural_footprint_compressed: i64,
|
|
ledger_tag_neural_nofootprint: i64,
|
|
ledger_tag_neural_nofootprint_compressed: i64,
|
|
|
|
// added for rev4
|
|
limit_bytes_remaining: u64,
|
|
|
|
// added for rev5
|
|
decompressions: integer_t,
|
|
};
|
|
pub const task_vm_info_data_t = task_vm_info;
|
|
|
|
pub const vm_prot_t = c_int;
|
|
pub const boolean_t = c_int;
|
|
|
|
pub extern "c" fn mach_vm_protect(
|
|
target_task: vm_map_t,
|
|
address: mach_vm_address_t,
|
|
size: mach_vm_size_t,
|
|
set_maximum: boolean_t,
|
|
new_protection: vm_prot_t,
|
|
) kern_return_t;
|
|
|
|
pub extern "c" fn mach_port_deallocate(target_tport: mach_port_name_t, task: mach_port_name_t) kern_return_t;
|
|
|
|
pub extern "c" fn task_info(
|
|
target_task: task_name_t,
|
|
flavor: task_flavor_t,
|
|
task_info_out: task_info_t,
|
|
task_info_outCnt: *mach_msg_type_number_t,
|
|
) kern_return_t;
|
|
pub extern "c" fn _host_page_size(task: mach_port_t, size: *vm_size_t) kern_return_t;
|
|
pub extern "c" fn vm_deallocate(target_task: vm_map_t, address: vm_address_t, size: vm_size_t) kern_return_t;
|
|
pub extern "c" fn vm_machine_attribute(
|
|
target_task: vm_map_t,
|
|
address: vm_address_t,
|
|
size: vm_size_t,
|
|
attribute: vm_machine_attribute_t,
|
|
value: *vm_machine_attribute_val_t,
|
|
) kern_return_t;
|
|
|
|
pub const sf_hdtr = extern struct {
|
|
headers: [*]const iovec_const,
|
|
hdr_cnt: c_int,
|
|
trailers: [*]const iovec_const,
|
|
trl_cnt: c_int,
|
|
};
|
|
|
|
pub extern "c" fn sendfile(
|
|
in_fd: fd_t,
|
|
out_fd: fd_t,
|
|
offset: off_t,
|
|
len: *off_t,
|
|
sf_hdtr: ?*sf_hdtr,
|
|
flags: u32,
|
|
) c_int;
|
|
|
|
pub fn sigaddset(set: *sigset_t, signo: u5) void {
|
|
set.* |= @as(u32, 1) << (signo - 1);
|
|
}
|
|
|
|
pub extern "c" fn sigaltstack(ss: ?*stack_t, old_ss: ?*stack_t) c_int;
|
|
|
|
pub const IFNAMESIZE = 16;
|
|
|
|
pub const AI = struct {
|
|
/// get address to use bind()
|
|
pub const PASSIVE = 0x00000001;
|
|
/// fill ai_canonname
|
|
pub const CANONNAME = 0x00000002;
|
|
/// prevent host name resolution
|
|
pub const NUMERICHOST = 0x00000004;
|
|
/// prevent service name resolution
|
|
pub const NUMERICSERV = 0x00001000;
|
|
};
|
|
|
|
pub const EAI = enum(c_int) {
|
|
/// address family for hostname not supported
|
|
ADDRFAMILY = 1,
|
|
|
|
/// temporary failure in name resolution
|
|
AGAIN = 2,
|
|
|
|
/// invalid value for ai_flags
|
|
BADFLAGS = 3,
|
|
|
|
/// non-recoverable failure in name resolution
|
|
FAIL = 4,
|
|
|
|
/// ai_family not supported
|
|
FAMILY = 5,
|
|
|
|
/// memory allocation failure
|
|
MEMORY = 6,
|
|
|
|
/// no address associated with hostname
|
|
NODATA = 7,
|
|
|
|
/// hostname nor servname provided, or not known
|
|
NONAME = 8,
|
|
|
|
/// servname not supported for ai_socktype
|
|
SERVICE = 9,
|
|
|
|
/// ai_socktype not supported
|
|
SOCKTYPE = 10,
|
|
|
|
/// system error returned in errno
|
|
SYSTEM = 11,
|
|
|
|
/// invalid value for hints
|
|
BADHINTS = 12,
|
|
|
|
/// resolved protocol is unknown
|
|
PROTOCOL = 13,
|
|
|
|
/// argument buffer overflow
|
|
OVERFLOW = 14,
|
|
|
|
_,
|
|
};
|
|
|
|
pub const EAI_MAX = 15;
|
|
|
|
pub const pthread_mutex_t = extern struct {
|
|
__sig: c_long = 0x32AAABA7,
|
|
__opaque: [__PTHREAD_MUTEX_SIZE__]u8 = [_]u8{0} ** __PTHREAD_MUTEX_SIZE__,
|
|
};
|
|
pub const pthread_cond_t = extern struct {
|
|
__sig: c_long = 0x3CB0B1BB,
|
|
__opaque: [__PTHREAD_COND_SIZE__]u8 = [_]u8{0} ** __PTHREAD_COND_SIZE__,
|
|
};
|
|
pub const pthread_rwlock_t = extern struct {
|
|
__sig: c_long = 0x2DA8B3B4,
|
|
__opaque: [192]u8 = [_]u8{0} ** 192,
|
|
};
|
|
pub const sem_t = c_int;
|
|
const __PTHREAD_MUTEX_SIZE__ = if (@sizeOf(usize) == 8) 56 else 40;
|
|
const __PTHREAD_COND_SIZE__ = if (@sizeOf(usize) == 8) 40 else 24;
|
|
|
|
pub const pthread_attr_t = extern struct {
|
|
__sig: c_long,
|
|
__opaque: [56]u8,
|
|
};
|
|
|
|
pub extern "c" fn pthread_threadid_np(thread: ?std.c.pthread_t, thread_id: *u64) c_int;
|
|
pub extern "c" fn pthread_setname_np(name: [*:0]const u8) E;
|
|
pub extern "c" fn pthread_getname_np(thread: std.c.pthread_t, name: [*:0]u8, len: usize) E;
|
|
|
|
pub extern "c" fn arc4random_buf(buf: [*]u8, len: usize) void;
|
|
|
|
// Grand Central Dispatch is exposed by libSystem.
|
|
pub extern "c" fn dispatch_release(object: *anyopaque) void;
|
|
|
|
pub const dispatch_semaphore_t = *opaque {};
|
|
pub extern "c" fn dispatch_semaphore_create(value: isize) ?dispatch_semaphore_t;
|
|
pub extern "c" fn dispatch_semaphore_wait(dsema: dispatch_semaphore_t, timeout: dispatch_time_t) isize;
|
|
pub extern "c" fn dispatch_semaphore_signal(dsema: dispatch_semaphore_t) isize;
|
|
|
|
pub const dispatch_time_t = u64;
|
|
pub const DISPATCH_TIME_NOW = @as(dispatch_time_t, 0);
|
|
pub const DISPATCH_TIME_FOREVER = ~@as(dispatch_time_t, 0);
|
|
pub extern "c" fn dispatch_time(when: dispatch_time_t, delta: i64) dispatch_time_t;
|
|
|
|
const dispatch_once_t = usize;
|
|
const dispatch_function_t = fn (?*anyopaque) callconv(.C) void;
|
|
pub extern fn dispatch_once_f(
|
|
predicate: *dispatch_once_t,
|
|
context: ?*anyopaque,
|
|
function: dispatch_function_t,
|
|
) void;
|
|
|
|
// Undocumented futex-like API available on darwin 16+
|
|
// (macOS 10.12+, iOS 10.0+, tvOS 10.0+, watchOS 3.0+, catalyst 13.0+).
|
|
//
|
|
// [ulock.h]: https://github.com/apple/darwin-xnu/blob/master/bsd/sys/ulock.h
|
|
// [sys_ulock.c]: https://github.com/apple/darwin-xnu/blob/master/bsd/kern/sys_ulock.c
|
|
|
|
pub const UL_COMPARE_AND_WAIT = 1;
|
|
pub const UL_UNFAIR_LOCK = 2;
|
|
|
|
// Obsolete/deprecated
|
|
pub const UL_OSSPINLOCK = UL_COMPARE_AND_WAIT;
|
|
pub const UL_HANDOFFLOCK = UL_UNFAIR_LOCK;
|
|
|
|
pub const ULF_WAKE_ALL = 0x100;
|
|
pub const ULF_WAKE_THREAD = 0x200;
|
|
pub const ULF_WAIT_WORKQ_DATA_CONTENTION = 0x10000;
|
|
pub const ULF_WAIT_CANCEL_POINT = 0x20000;
|
|
pub const ULF_NO_ERRNO = 0x1000000;
|
|
|
|
// The following are only supported on darwin 19+
|
|
// (macOS 10.15+, iOS 13.0+)
|
|
pub const UL_COMPARE_AND_WAIT_SHARED = 3;
|
|
pub const UL_UNFAIR_LOCK64_SHARED = 4;
|
|
pub const UL_COMPARE_AND_WAIT64 = 5;
|
|
pub const UL_COMPARE_AND_WAIT64_SHARED = 6;
|
|
pub const ULF_WAIT_ADAPTIVE_SPIN = 0x40000;
|
|
|
|
pub extern "c" fn __ulock_wait2(op: u32, addr: ?*const anyopaque, val: u64, timeout_ns: u64, val2: u64) c_int;
|
|
pub extern "c" fn __ulock_wait(op: u32, addr: ?*const anyopaque, val: u64, timeout_us: u32) c_int;
|
|
pub extern "c" fn __ulock_wake(op: u32, addr: ?*const anyopaque, val: u64) c_int;
|
|
|
|
pub const OS_UNFAIR_LOCK_INIT = os_unfair_lock{};
|
|
pub const os_unfair_lock_t = *os_unfair_lock;
|
|
pub const os_unfair_lock = extern struct {
|
|
_os_unfair_lock_opaque: u32 = 0,
|
|
};
|
|
|
|
pub extern "c" fn os_unfair_lock_lock(o: os_unfair_lock_t) void;
|
|
pub extern "c" fn os_unfair_lock_unlock(o: os_unfair_lock_t) void;
|
|
pub extern "c" fn os_unfair_lock_trylock(o: os_unfair_lock_t) bool;
|
|
pub extern "c" fn os_unfair_lock_assert_owner(o: os_unfair_lock_t) void;
|
|
pub extern "c" fn os_unfair_lock_assert_not_owner(o: os_unfair_lock_t) void;
|
|
|
|
// XXX: close -> close$NOCANCEL
|
|
// XXX: getdirentries -> _getdirentries64
|
|
|
|
// See: https://opensource.apple.com/source/xnu/xnu-6153.141.1/bsd/sys/_types.h.auto.html
|
|
// TODO: audit mode_t/pid_t, should likely be u16/i32
|
|
pub const fd_t = c_int;
|
|
pub const pid_t = c_int;
|
|
pub const mode_t = c_uint;
|
|
pub const uid_t = u32;
|
|
pub const gid_t = u32;
|
|
|
|
pub const in_port_t = u16;
|
|
pub const sa_family_t = u8;
|
|
pub const socklen_t = u32;
|
|
pub const sockaddr = extern struct {
|
|
len: u8,
|
|
family: sa_family_t,
|
|
data: [14]u8,
|
|
|
|
pub const SS_MAXSIZE = 128;
|
|
pub const storage = std.x.os.Socket.Address.Native.Storage;
|
|
pub const in = extern struct {
|
|
len: u8 = @sizeOf(in),
|
|
family: sa_family_t = AF.INET,
|
|
port: in_port_t,
|
|
addr: u32,
|
|
zero: [8]u8 = [8]u8{ 0, 0, 0, 0, 0, 0, 0, 0 },
|
|
};
|
|
pub const in6 = extern struct {
|
|
len: u8 = @sizeOf(in6),
|
|
family: sa_family_t = AF.INET6,
|
|
port: in_port_t,
|
|
flowinfo: u32,
|
|
addr: [16]u8,
|
|
scope_id: u32,
|
|
};
|
|
|
|
/// UNIX domain socket
|
|
pub const un = extern struct {
|
|
len: u8 = @sizeOf(un),
|
|
family: sa_family_t = AF.UNIX,
|
|
path: [104]u8,
|
|
};
|
|
};
|
|
pub const timeval = extern struct {
|
|
tv_sec: c_long,
|
|
tv_usec: i32,
|
|
};
|
|
|
|
pub const timezone = extern struct {
|
|
tz_minuteswest: i32,
|
|
tz_dsttime: i32,
|
|
};
|
|
|
|
pub const mach_timebase_info_data = extern struct {
|
|
numer: u32,
|
|
denom: u32,
|
|
};
|
|
|
|
pub const off_t = i64;
|
|
pub const ino_t = u64;
|
|
|
|
pub const Flock = extern struct {
|
|
start: off_t,
|
|
len: off_t,
|
|
pid: pid_t,
|
|
type: i16,
|
|
whence: i16,
|
|
};
|
|
|
|
pub const Stat = extern struct {
|
|
dev: i32,
|
|
mode: u16,
|
|
nlink: u16,
|
|
ino: ino_t,
|
|
uid: uid_t,
|
|
gid: gid_t,
|
|
rdev: i32,
|
|
atimespec: timespec,
|
|
mtimespec: timespec,
|
|
ctimespec: timespec,
|
|
birthtimespec: timespec,
|
|
size: off_t,
|
|
blocks: i64,
|
|
blksize: i32,
|
|
flags: u32,
|
|
gen: u32,
|
|
lspare: i32,
|
|
qspare: [2]i64,
|
|
|
|
pub fn atime(self: @This()) timespec {
|
|
return self.atimespec;
|
|
}
|
|
|
|
pub fn mtime(self: @This()) timespec {
|
|
return self.mtimespec;
|
|
}
|
|
|
|
pub fn ctime(self: @This()) timespec {
|
|
return self.ctimespec;
|
|
}
|
|
|
|
pub fn birthtime(self: @This()) timespec {
|
|
return self.birthtimespec;
|
|
}
|
|
};
|
|
|
|
pub const timespec = extern struct {
|
|
tv_sec: isize,
|
|
tv_nsec: isize,
|
|
};
|
|
|
|
pub const sigset_t = u32;
|
|
pub const empty_sigset: sigset_t = 0;
|
|
|
|
pub const SIG = struct {
|
|
pub const ERR = @intToPtr(?Sigaction.handler_fn, maxInt(usize));
|
|
pub const DFL = @intToPtr(?Sigaction.handler_fn, 0);
|
|
pub const IGN = @intToPtr(?Sigaction.handler_fn, 1);
|
|
pub const HOLD = @intToPtr(?Sigaction.handler_fn, 5);
|
|
|
|
/// block specified signal set
|
|
pub const _BLOCK = 1;
|
|
/// unblock specified signal set
|
|
pub const _UNBLOCK = 2;
|
|
/// set specified signal set
|
|
pub const _SETMASK = 3;
|
|
/// hangup
|
|
pub const HUP = 1;
|
|
/// interrupt
|
|
pub const INT = 2;
|
|
/// quit
|
|
pub const QUIT = 3;
|
|
/// illegal instruction (not reset when caught)
|
|
pub const ILL = 4;
|
|
/// trace trap (not reset when caught)
|
|
pub const TRAP = 5;
|
|
/// abort()
|
|
pub const ABRT = 6;
|
|
/// pollable event ([XSR] generated, not supported)
|
|
pub const POLL = 7;
|
|
/// compatibility
|
|
pub const IOT = ABRT;
|
|
/// EMT instruction
|
|
pub const EMT = 7;
|
|
/// floating point exception
|
|
pub const FPE = 8;
|
|
/// kill (cannot be caught or ignored)
|
|
pub const KILL = 9;
|
|
/// bus error
|
|
pub const BUS = 10;
|
|
/// segmentation violation
|
|
pub const SEGV = 11;
|
|
/// bad argument to system call
|
|
pub const SYS = 12;
|
|
/// write on a pipe with no one to read it
|
|
pub const PIPE = 13;
|
|
/// alarm clock
|
|
pub const ALRM = 14;
|
|
/// software termination signal from kill
|
|
pub const TERM = 15;
|
|
/// urgent condition on IO channel
|
|
pub const URG = 16;
|
|
/// sendable stop signal not from tty
|
|
pub const STOP = 17;
|
|
/// stop signal from tty
|
|
pub const TSTP = 18;
|
|
/// continue a stopped process
|
|
pub const CONT = 19;
|
|
/// to parent on child stop or exit
|
|
pub const CHLD = 20;
|
|
/// to readers pgrp upon background tty read
|
|
pub const TTIN = 21;
|
|
/// like TTIN for output if (tp->t_local<OSTOP)
|
|
pub const TTOU = 22;
|
|
/// input/output possible signal
|
|
pub const IO = 23;
|
|
/// exceeded CPU time limit
|
|
pub const XCPU = 24;
|
|
/// exceeded file size limit
|
|
pub const XFSZ = 25;
|
|
/// virtual time alarm
|
|
pub const VTALRM = 26;
|
|
/// profiling time alarm
|
|
pub const PROF = 27;
|
|
/// window size changes
|
|
pub const WINCH = 28;
|
|
/// information request
|
|
pub const INFO = 29;
|
|
/// user defined signal 1
|
|
pub const USR1 = 30;
|
|
/// user defined signal 2
|
|
pub const USR2 = 31;
|
|
};
|
|
|
|
pub const siginfo_t = extern struct {
|
|
signo: c_int,
|
|
errno: c_int,
|
|
code: c_int,
|
|
pid: pid_t,
|
|
uid: uid_t,
|
|
status: c_int,
|
|
addr: *anyopaque,
|
|
value: extern union {
|
|
int: c_int,
|
|
ptr: *anyopaque,
|
|
},
|
|
si_band: c_long,
|
|
_pad: [7]c_ulong,
|
|
};
|
|
|
|
/// Renamed from `sigaction` to `Sigaction` to avoid conflict with function name.
|
|
pub const Sigaction = extern struct {
|
|
pub const handler_fn = switch (builtin.zig_backend) {
|
|
.stage1 => fn (c_int) callconv(.C) void,
|
|
else => *const fn (c_int) callconv(.C) void,
|
|
};
|
|
pub const sigaction_fn = switch (builtin.zig_backend) {
|
|
.stage1 => fn (c_int, *const siginfo_t, ?*const anyopaque) callconv(.C) void,
|
|
else => *const fn (c_int, *const siginfo_t, ?*const anyopaque) callconv(.C) void,
|
|
};
|
|
|
|
handler: extern union {
|
|
handler: ?handler_fn,
|
|
sigaction: ?sigaction_fn,
|
|
},
|
|
mask: sigset_t,
|
|
flags: c_uint,
|
|
};
|
|
|
|
pub const dirent = extern struct {
|
|
d_ino: u64,
|
|
d_seekoff: u64,
|
|
d_reclen: u16,
|
|
d_namlen: u16,
|
|
d_type: u8,
|
|
d_name: [1024]u8,
|
|
|
|
pub fn reclen(self: dirent) u16 {
|
|
return self.d_reclen;
|
|
}
|
|
};
|
|
|
|
/// Renamed from `kevent` to `Kevent` to avoid conflict with function name.
|
|
pub const Kevent = extern struct {
|
|
ident: usize,
|
|
filter: i16,
|
|
flags: u16,
|
|
fflags: u32,
|
|
data: isize,
|
|
udata: usize,
|
|
};
|
|
|
|
// sys/types.h on macos uses #pragma pack(4) so these checks are
|
|
// to make sure the struct is laid out the same. These values were
|
|
// produced from C code using the offsetof macro.
|
|
comptime {
|
|
if (builtin.target.isDarwin()) {
|
|
assert(@offsetOf(Kevent, "ident") == 0);
|
|
assert(@offsetOf(Kevent, "filter") == 8);
|
|
assert(@offsetOf(Kevent, "flags") == 10);
|
|
assert(@offsetOf(Kevent, "fflags") == 12);
|
|
assert(@offsetOf(Kevent, "data") == 16);
|
|
assert(@offsetOf(Kevent, "udata") == 24);
|
|
}
|
|
}
|
|
|
|
pub const kevent64_s = extern struct {
|
|
ident: u64,
|
|
filter: i16,
|
|
flags: u16,
|
|
fflags: u32,
|
|
data: i64,
|
|
udata: u64,
|
|
ext: [2]u64,
|
|
};
|
|
|
|
// sys/types.h on macos uses #pragma pack() so these checks are
|
|
// to make sure the struct is laid out the same. These values were
|
|
// produced from C code using the offsetof macro.
|
|
comptime {
|
|
if (builtin.target.isDarwin()) {
|
|
assert(@offsetOf(kevent64_s, "ident") == 0);
|
|
assert(@offsetOf(kevent64_s, "filter") == 8);
|
|
assert(@offsetOf(kevent64_s, "flags") == 10);
|
|
assert(@offsetOf(kevent64_s, "fflags") == 12);
|
|
assert(@offsetOf(kevent64_s, "data") == 16);
|
|
assert(@offsetOf(kevent64_s, "udata") == 24);
|
|
assert(@offsetOf(kevent64_s, "ext") == 32);
|
|
}
|
|
}
|
|
|
|
pub const mach_port_t = c_uint;
|
|
pub const clock_serv_t = mach_port_t;
|
|
pub const clock_res_t = c_int;
|
|
pub const mach_port_name_t = natural_t;
|
|
pub const natural_t = c_uint;
|
|
pub const mach_timespec_t = extern struct {
|
|
tv_sec: c_uint,
|
|
tv_nsec: clock_res_t,
|
|
};
|
|
pub const kern_return_t = c_int;
|
|
pub const host_t = mach_port_t;
|
|
pub const integer_t = c_int;
|
|
pub const task_flavor_t = natural_t;
|
|
pub const task_info_t = *integer_t;
|
|
pub const task_name_t = mach_port_name_t;
|
|
pub const vm_address_t = vm_offset_t;
|
|
pub const vm_size_t = mach_vm_size_t;
|
|
pub const vm_machine_attribute_t = usize;
|
|
pub const vm_machine_attribute_val_t = isize;
|
|
|
|
pub const CALENDAR_CLOCK = 1;
|
|
|
|
pub const PATH_MAX = 1024;
|
|
pub const IOV_MAX = 16;
|
|
|
|
pub const STDIN_FILENO = 0;
|
|
pub const STDOUT_FILENO = 1;
|
|
pub const STDERR_FILENO = 2;
|
|
|
|
pub const PROT = struct {
|
|
/// [MC2] no permissions
|
|
pub const NONE: vm_prot_t = 0x00;
|
|
/// [MC2] pages can be read
|
|
pub const READ: vm_prot_t = 0x01;
|
|
/// [MC2] pages can be written
|
|
pub const WRITE: vm_prot_t = 0x02;
|
|
/// [MC2] pages can be executed
|
|
pub const EXEC: vm_prot_t = 0x04;
|
|
/// When a caller finds that they cannot obtain write permission on a
|
|
/// mapped entry, the following flag can be used. The entry will be
|
|
/// made "needs copy" effectively copying the object (using COW),
|
|
/// and write permission will be added to the maximum protections for
|
|
/// the associated entry.
|
|
pub const COPY: vm_prot_t = 0x10;
|
|
};
|
|
|
|
pub const MAP = struct {
|
|
/// allocated from memory, swap space
|
|
pub const ANONYMOUS = 0x1000;
|
|
/// map from file (default)
|
|
pub const FILE = 0x0000;
|
|
/// interpret addr exactly
|
|
pub const FIXED = 0x0010;
|
|
/// region may contain semaphores
|
|
pub const HASSEMAPHORE = 0x0200;
|
|
/// changes are private
|
|
pub const PRIVATE = 0x0002;
|
|
/// share changes
|
|
pub const SHARED = 0x0001;
|
|
/// don't cache pages for this mapping
|
|
pub const NOCACHE = 0x0400;
|
|
/// don't reserve needed swap area
|
|
pub const NORESERVE = 0x0040;
|
|
pub const FAILED = @intToPtr(*anyopaque, maxInt(usize));
|
|
};
|
|
|
|
pub const MSF = struct {
|
|
pub const ASYNC = 0x1;
|
|
pub const INVALIDATE = 0x2;
|
|
// invalidate, leave mapped
|
|
pub const KILLPAGES = 0x4;
|
|
// deactivate, leave mapped
|
|
pub const DEACTIVATE = 0x8;
|
|
pub const SYNC = 0x10;
|
|
};
|
|
|
|
pub const SA = struct {
|
|
/// take signal on signal stack
|
|
pub const ONSTACK = 0x0001;
|
|
/// restart system on signal return
|
|
pub const RESTART = 0x0002;
|
|
/// reset to SIG.DFL when taking signal
|
|
pub const RESETHAND = 0x0004;
|
|
/// do not generate SIG.CHLD on child stop
|
|
pub const NOCLDSTOP = 0x0008;
|
|
/// don't mask the signal we're delivering
|
|
pub const NODEFER = 0x0010;
|
|
/// don't keep zombies around
|
|
pub const NOCLDWAIT = 0x0020;
|
|
/// signal handler with SIGINFO args
|
|
pub const SIGINFO = 0x0040;
|
|
/// do not bounce off kernel's sigtramp
|
|
pub const USERTRAMP = 0x0100;
|
|
/// signal handler with SIGINFO args with 64bit regs information
|
|
pub const @"64REGSET" = 0x0200;
|
|
};
|
|
|
|
pub const F_OK = 0;
|
|
pub const X_OK = 1;
|
|
pub const W_OK = 2;
|
|
pub const R_OK = 4;
|
|
|
|
pub const O = struct {
|
|
pub const PATH = 0x0000;
|
|
/// open for reading only
|
|
pub const RDONLY = 0x0000;
|
|
/// open for writing only
|
|
pub const WRONLY = 0x0001;
|
|
/// open for reading and writing
|
|
pub const RDWR = 0x0002;
|
|
/// do not block on open or for data to become available
|
|
pub const NONBLOCK = 0x0004;
|
|
/// append on each write
|
|
pub const APPEND = 0x0008;
|
|
/// create file if it does not exist
|
|
pub const CREAT = 0x0200;
|
|
/// truncate size to 0
|
|
pub const TRUNC = 0x0400;
|
|
/// error if CREAT and the file exists
|
|
pub const EXCL = 0x0800;
|
|
/// atomically obtain a shared lock
|
|
pub const SHLOCK = 0x0010;
|
|
/// atomically obtain an exclusive lock
|
|
pub const EXLOCK = 0x0020;
|
|
/// do not follow symlinks
|
|
pub const NOFOLLOW = 0x0100;
|
|
/// allow open of symlinks
|
|
pub const SYMLINK = 0x200000;
|
|
/// descriptor requested for event notifications only
|
|
pub const EVTONLY = 0x8000;
|
|
/// mark as close-on-exec
|
|
pub const CLOEXEC = 0x1000000;
|
|
pub const ACCMODE = 3;
|
|
pub const ALERT = 536870912;
|
|
pub const ASYNC = 64;
|
|
pub const DIRECTORY = 1048576;
|
|
pub const DP_GETRAWENCRYPTED = 1;
|
|
pub const DP_GETRAWUNENCRYPTED = 2;
|
|
pub const DSYNC = 4194304;
|
|
pub const FSYNC = SYNC;
|
|
pub const NOCTTY = 131072;
|
|
pub const POPUP = 2147483648;
|
|
pub const SYNC = 128;
|
|
};
|
|
|
|
pub const SEEK = struct {
|
|
pub const SET = 0x0;
|
|
pub const CUR = 0x1;
|
|
pub const END = 0x2;
|
|
};
|
|
|
|
pub const DT = struct {
|
|
pub const UNKNOWN = 0;
|
|
pub const FIFO = 1;
|
|
pub const CHR = 2;
|
|
pub const DIR = 4;
|
|
pub const BLK = 6;
|
|
pub const REG = 8;
|
|
pub const LNK = 10;
|
|
pub const SOCK = 12;
|
|
pub const WHT = 14;
|
|
};
|
|
|
|
/// no flag value
|
|
pub const KEVENT_FLAG_NONE = 0x000;
|
|
|
|
/// immediate timeout
|
|
pub const KEVENT_FLAG_IMMEDIATE = 0x001;
|
|
|
|
/// output events only include change
|
|
pub const KEVENT_FLAG_ERROR_EVENTS = 0x002;
|
|
|
|
/// add event to kq (implies enable)
|
|
pub const EV_ADD = 0x0001;
|
|
|
|
/// delete event from kq
|
|
pub const EV_DELETE = 0x0002;
|
|
|
|
/// enable event
|
|
pub const EV_ENABLE = 0x0004;
|
|
|
|
/// disable event (not reported)
|
|
pub const EV_DISABLE = 0x0008;
|
|
|
|
/// only report one occurrence
|
|
pub const EV_ONESHOT = 0x0010;
|
|
|
|
/// clear event state after reporting
|
|
pub const EV_CLEAR = 0x0020;
|
|
|
|
/// force immediate event output
|
|
/// ... with or without EV_ERROR
|
|
/// ... use KEVENT_FLAG_ERROR_EVENTS
|
|
/// on syscalls supporting flags
|
|
pub const EV_RECEIPT = 0x0040;
|
|
|
|
/// disable event after reporting
|
|
pub const EV_DISPATCH = 0x0080;
|
|
|
|
/// unique kevent per udata value
|
|
pub const EV_UDATA_SPECIFIC = 0x0100;
|
|
|
|
/// ... in combination with EV_DELETE
|
|
/// will defer delete until udata-specific
|
|
/// event enabled. EINPROGRESS will be
|
|
/// returned to indicate the deferral
|
|
pub const EV_DISPATCH2 = EV_DISPATCH | EV_UDATA_SPECIFIC;
|
|
|
|
/// report that source has vanished
|
|
/// ... only valid with EV_DISPATCH2
|
|
pub const EV_VANISHED = 0x0200;
|
|
|
|
/// reserved by system
|
|
pub const EV_SYSFLAGS = 0xF000;
|
|
|
|
/// filter-specific flag
|
|
pub const EV_FLAG0 = 0x1000;
|
|
|
|
/// filter-specific flag
|
|
pub const EV_FLAG1 = 0x2000;
|
|
|
|
/// EOF detected
|
|
pub const EV_EOF = 0x8000;
|
|
|
|
/// error, data contains errno
|
|
pub const EV_ERROR = 0x4000;
|
|
|
|
pub const EV_POLL = EV_FLAG0;
|
|
pub const EV_OOBAND = EV_FLAG1;
|
|
|
|
pub const EVFILT_READ = -1;
|
|
pub const EVFILT_WRITE = -2;
|
|
|
|
/// attached to aio requests
|
|
pub const EVFILT_AIO = -3;
|
|
|
|
/// attached to vnodes
|
|
pub const EVFILT_VNODE = -4;
|
|
|
|
/// attached to struct proc
|
|
pub const EVFILT_PROC = -5;
|
|
|
|
/// attached to struct proc
|
|
pub const EVFILT_SIGNAL = -6;
|
|
|
|
/// timers
|
|
pub const EVFILT_TIMER = -7;
|
|
|
|
/// Mach portsets
|
|
pub const EVFILT_MACHPORT = -8;
|
|
|
|
/// Filesystem events
|
|
pub const EVFILT_FS = -9;
|
|
|
|
/// User events
|
|
pub const EVFILT_USER = -10;
|
|
|
|
/// Virtual memory events
|
|
pub const EVFILT_VM = -12;
|
|
|
|
/// Exception events
|
|
pub const EVFILT_EXCEPT = -15;
|
|
|
|
pub const EVFILT_SYSCOUNT = 17;
|
|
|
|
/// On input, NOTE_TRIGGER causes the event to be triggered for output.
|
|
pub const NOTE_TRIGGER = 0x01000000;
|
|
|
|
/// ignore input fflags
|
|
pub const NOTE_FFNOP = 0x00000000;
|
|
|
|
/// and fflags
|
|
pub const NOTE_FFAND = 0x40000000;
|
|
|
|
/// or fflags
|
|
pub const NOTE_FFOR = 0x80000000;
|
|
|
|
/// copy fflags
|
|
pub const NOTE_FFCOPY = 0xc0000000;
|
|
|
|
/// mask for operations
|
|
pub const NOTE_FFCTRLMASK = 0xc0000000;
|
|
pub const NOTE_FFLAGSMASK = 0x00ffffff;
|
|
|
|
/// low water mark
|
|
pub const NOTE_LOWAT = 0x00000001;
|
|
|
|
/// OOB data
|
|
pub const NOTE_OOB = 0x00000002;
|
|
|
|
/// vnode was removed
|
|
pub const NOTE_DELETE = 0x00000001;
|
|
|
|
/// data contents changed
|
|
pub const NOTE_WRITE = 0x00000002;
|
|
|
|
/// size increased
|
|
pub const NOTE_EXTEND = 0x00000004;
|
|
|
|
/// attributes changed
|
|
pub const NOTE_ATTRIB = 0x00000008;
|
|
|
|
/// link count changed
|
|
pub const NOTE_LINK = 0x00000010;
|
|
|
|
/// vnode was renamed
|
|
pub const NOTE_RENAME = 0x00000020;
|
|
|
|
/// vnode access was revoked
|
|
pub const NOTE_REVOKE = 0x00000040;
|
|
|
|
/// No specific vnode event: to test for EVFILT_READ activation
|
|
pub const NOTE_NONE = 0x00000080;
|
|
|
|
/// vnode was unlocked by flock(2)
|
|
pub const NOTE_FUNLOCK = 0x00000100;
|
|
|
|
/// process exited
|
|
pub const NOTE_EXIT = 0x80000000;
|
|
|
|
/// process forked
|
|
pub const NOTE_FORK = 0x40000000;
|
|
|
|
/// process exec'd
|
|
pub const NOTE_EXEC = 0x20000000;
|
|
|
|
/// shared with EVFILT_SIGNAL
|
|
pub const NOTE_SIGNAL = 0x08000000;
|
|
|
|
/// exit status to be returned, valid for child process only
|
|
pub const NOTE_EXITSTATUS = 0x04000000;
|
|
|
|
/// provide details on reasons for exit
|
|
pub const NOTE_EXIT_DETAIL = 0x02000000;
|
|
|
|
/// mask for signal & exit status
|
|
pub const NOTE_PDATAMASK = 0x000fffff;
|
|
pub const NOTE_PCTRLMASK = (~NOTE_PDATAMASK);
|
|
|
|
pub const NOTE_EXIT_DETAIL_MASK = 0x00070000;
|
|
pub const NOTE_EXIT_DECRYPTFAIL = 0x00010000;
|
|
pub const NOTE_EXIT_MEMORY = 0x00020000;
|
|
pub const NOTE_EXIT_CSERROR = 0x00040000;
|
|
|
|
/// will react on memory pressure
|
|
pub const NOTE_VM_PRESSURE = 0x80000000;
|
|
|
|
/// will quit on memory pressure, possibly after cleaning up dirty state
|
|
pub const NOTE_VM_PRESSURE_TERMINATE = 0x40000000;
|
|
|
|
/// will quit immediately on memory pressure
|
|
pub const NOTE_VM_PRESSURE_SUDDEN_TERMINATE = 0x20000000;
|
|
|
|
/// there was an error
|
|
pub const NOTE_VM_ERROR = 0x10000000;
|
|
|
|
/// data is seconds
|
|
pub const NOTE_SECONDS = 0x00000001;
|
|
|
|
/// data is microseconds
|
|
pub const NOTE_USECONDS = 0x00000002;
|
|
|
|
/// data is nanoseconds
|
|
pub const NOTE_NSECONDS = 0x00000004;
|
|
|
|
/// absolute timeout
|
|
pub const NOTE_ABSOLUTE = 0x00000008;
|
|
|
|
/// ext[1] holds leeway for power aware timers
|
|
pub const NOTE_LEEWAY = 0x00000010;
|
|
|
|
/// system does minimal timer coalescing
|
|
pub const NOTE_CRITICAL = 0x00000020;
|
|
|
|
/// system does maximum timer coalescing
|
|
pub const NOTE_BACKGROUND = 0x00000040;
|
|
pub const NOTE_MACH_CONTINUOUS_TIME = 0x00000080;
|
|
|
|
/// data is mach absolute time units
|
|
pub const NOTE_MACHTIME = 0x00000100;
|
|
|
|
pub const AF = struct {
|
|
pub const UNSPEC = 0;
|
|
pub const LOCAL = 1;
|
|
pub const UNIX = LOCAL;
|
|
pub const INET = 2;
|
|
pub const SYS_CONTROL = 2;
|
|
pub const IMPLINK = 3;
|
|
pub const PUP = 4;
|
|
pub const CHAOS = 5;
|
|
pub const NS = 6;
|
|
pub const ISO = 7;
|
|
pub const OSI = ISO;
|
|
pub const ECMA = 8;
|
|
pub const DATAKIT = 9;
|
|
pub const CCITT = 10;
|
|
pub const SNA = 11;
|
|
pub const DECnet = 12;
|
|
pub const DLI = 13;
|
|
pub const LAT = 14;
|
|
pub const HYLINK = 15;
|
|
pub const APPLETALK = 16;
|
|
pub const ROUTE = 17;
|
|
pub const LINK = 18;
|
|
pub const XTP = 19;
|
|
pub const COIP = 20;
|
|
pub const CNT = 21;
|
|
pub const RTIP = 22;
|
|
pub const IPX = 23;
|
|
pub const SIP = 24;
|
|
pub const PIP = 25;
|
|
pub const ISDN = 28;
|
|
pub const E164 = ISDN;
|
|
pub const KEY = 29;
|
|
pub const INET6 = 30;
|
|
pub const NATM = 31;
|
|
pub const SYSTEM = 32;
|
|
pub const NETBIOS = 33;
|
|
pub const PPP = 34;
|
|
pub const MAX = 40;
|
|
};
|
|
|
|
pub const PF = struct {
|
|
pub const UNSPEC = AF.UNSPEC;
|
|
pub const LOCAL = AF.LOCAL;
|
|
pub const UNIX = PF.LOCAL;
|
|
pub const INET = AF.INET;
|
|
pub const IMPLINK = AF.IMPLINK;
|
|
pub const PUP = AF.PUP;
|
|
pub const CHAOS = AF.CHAOS;
|
|
pub const NS = AF.NS;
|
|
pub const ISO = AF.ISO;
|
|
pub const OSI = AF.ISO;
|
|
pub const ECMA = AF.ECMA;
|
|
pub const DATAKIT = AF.DATAKIT;
|
|
pub const CCITT = AF.CCITT;
|
|
pub const SNA = AF.SNA;
|
|
pub const DECnet = AF.DECnet;
|
|
pub const DLI = AF.DLI;
|
|
pub const LAT = AF.LAT;
|
|
pub const HYLINK = AF.HYLINK;
|
|
pub const APPLETALK = AF.APPLETALK;
|
|
pub const ROUTE = AF.ROUTE;
|
|
pub const LINK = AF.LINK;
|
|
pub const XTP = AF.XTP;
|
|
pub const COIP = AF.COIP;
|
|
pub const CNT = AF.CNT;
|
|
pub const SIP = AF.SIP;
|
|
pub const IPX = AF.IPX;
|
|
pub const RTIP = AF.RTIP;
|
|
pub const PIP = AF.PIP;
|
|
pub const ISDN = AF.ISDN;
|
|
pub const KEY = AF.KEY;
|
|
pub const INET6 = AF.INET6;
|
|
pub const NATM = AF.NATM;
|
|
pub const SYSTEM = AF.SYSTEM;
|
|
pub const NETBIOS = AF.NETBIOS;
|
|
pub const PPP = AF.PPP;
|
|
pub const MAX = AF.MAX;
|
|
};
|
|
|
|
pub const SYSPROTO_EVENT = 1;
|
|
pub const SYSPROTO_CONTROL = 2;
|
|
|
|
pub const SOCK = struct {
|
|
pub const STREAM = 1;
|
|
pub const DGRAM = 2;
|
|
pub const RAW = 3;
|
|
pub const RDM = 4;
|
|
pub const SEQPACKET = 5;
|
|
pub const MAXADDRLEN = 255;
|
|
|
|
/// Not actually supported by Darwin, but Zig supplies a shim.
|
|
/// This numerical value is not ABI-stable. It need only not conflict
|
|
/// with any other `SOCK` bits.
|
|
pub const CLOEXEC = 1 << 15;
|
|
/// Not actually supported by Darwin, but Zig supplies a shim.
|
|
/// This numerical value is not ABI-stable. It need only not conflict
|
|
/// with any other `SOCK` bits.
|
|
pub const NONBLOCK = 1 << 16;
|
|
};
|
|
|
|
pub const IPPROTO = struct {
|
|
pub const ICMP = 1;
|
|
pub const ICMPV6 = 58;
|
|
pub const TCP = 6;
|
|
pub const UDP = 17;
|
|
pub const IP = 0;
|
|
pub const IPV6 = 41;
|
|
};
|
|
|
|
pub const SOL = struct {
|
|
pub const SOCKET = 0xffff;
|
|
};
|
|
|
|
pub const SO = struct {
|
|
pub const DEBUG = 0x0001;
|
|
pub const ACCEPTCONN = 0x0002;
|
|
pub const REUSEADDR = 0x0004;
|
|
pub const KEEPALIVE = 0x0008;
|
|
pub const DONTROUTE = 0x0010;
|
|
pub const BROADCAST = 0x0020;
|
|
pub const USELOOPBACK = 0x0040;
|
|
pub const LINGER = 0x1080;
|
|
pub const OOBINLINE = 0x0100;
|
|
pub const REUSEPORT = 0x0200;
|
|
pub const ACCEPTFILTER = 0x1000;
|
|
pub const SNDBUF = 0x1001;
|
|
pub const RCVBUF = 0x1002;
|
|
pub const SNDLOWAT = 0x1003;
|
|
pub const RCVLOWAT = 0x1004;
|
|
pub const SNDTIMEO = 0x1005;
|
|
pub const RCVTIMEO = 0x1006;
|
|
pub const ERROR = 0x1007;
|
|
pub const TYPE = 0x1008;
|
|
|
|
pub const NREAD = 0x1020;
|
|
pub const NKE = 0x1021;
|
|
pub const NOSIGPIPE = 0x1022;
|
|
pub const NOADDRERR = 0x1023;
|
|
pub const NWRITE = 0x1024;
|
|
pub const REUSESHAREUID = 0x1025;
|
|
};
|
|
|
|
pub const W = struct {
|
|
/// [XSI] no hang in wait/no child to reap
|
|
pub const NOHANG = 0x00000001;
|
|
/// [XSI] notify on stop, untraced child
|
|
pub const UNTRACED = 0x00000002;
|
|
|
|
pub fn EXITSTATUS(x: u32) u8 {
|
|
return @intCast(u8, x >> 8);
|
|
}
|
|
pub fn TERMSIG(x: u32) u32 {
|
|
return status(x);
|
|
}
|
|
pub fn STOPSIG(x: u32) u32 {
|
|
return x >> 8;
|
|
}
|
|
pub fn IFEXITED(x: u32) bool {
|
|
return status(x) == 0;
|
|
}
|
|
pub fn IFSTOPPED(x: u32) bool {
|
|
return status(x) == stopped and STOPSIG(x) != 0x13;
|
|
}
|
|
pub fn IFSIGNALED(x: u32) bool {
|
|
return status(x) != stopped and status(x) != 0;
|
|
}
|
|
|
|
fn status(x: u32) u32 {
|
|
return x & 0o177;
|
|
}
|
|
const stopped = 0o177;
|
|
};
|
|
|
|
pub const E = enum(u16) {
|
|
/// No error occurred.
|
|
SUCCESS = 0,
|
|
|
|
/// Operation not permitted
|
|
PERM = 1,
|
|
|
|
/// No such file or directory
|
|
NOENT = 2,
|
|
|
|
/// No such process
|
|
SRCH = 3,
|
|
|
|
/// Interrupted system call
|
|
INTR = 4,
|
|
|
|
/// Input/output error
|
|
IO = 5,
|
|
|
|
/// Device not configured
|
|
NXIO = 6,
|
|
|
|
/// Argument list too long
|
|
@"2BIG" = 7,
|
|
|
|
/// Exec format error
|
|
NOEXEC = 8,
|
|
|
|
/// Bad file descriptor
|
|
BADF = 9,
|
|
|
|
/// No child processes
|
|
CHILD = 10,
|
|
|
|
/// Resource deadlock avoided
|
|
DEADLK = 11,
|
|
|
|
/// Cannot allocate memory
|
|
NOMEM = 12,
|
|
|
|
/// Permission denied
|
|
ACCES = 13,
|
|
|
|
/// Bad address
|
|
FAULT = 14,
|
|
|
|
/// Block device required
|
|
NOTBLK = 15,
|
|
|
|
/// Device / Resource busy
|
|
BUSY = 16,
|
|
|
|
/// File exists
|
|
EXIST = 17,
|
|
|
|
/// Cross-device link
|
|
XDEV = 18,
|
|
|
|
/// Operation not supported by device
|
|
NODEV = 19,
|
|
|
|
/// Not a directory
|
|
NOTDIR = 20,
|
|
|
|
/// Is a directory
|
|
ISDIR = 21,
|
|
|
|
/// Invalid argument
|
|
INVAL = 22,
|
|
|
|
/// Too many open files in system
|
|
NFILE = 23,
|
|
|
|
/// Too many open files
|
|
MFILE = 24,
|
|
|
|
/// Inappropriate ioctl for device
|
|
NOTTY = 25,
|
|
|
|
/// Text file busy
|
|
TXTBSY = 26,
|
|
|
|
/// File too large
|
|
FBIG = 27,
|
|
|
|
/// No space left on device
|
|
NOSPC = 28,
|
|
|
|
/// Illegal seek
|
|
SPIPE = 29,
|
|
|
|
/// Read-only file system
|
|
ROFS = 30,
|
|
|
|
/// Too many links
|
|
MLINK = 31,
|
|
|
|
/// Broken pipe
|
|
PIPE = 32,
|
|
|
|
// math software
|
|
|
|
/// Numerical argument out of domain
|
|
DOM = 33,
|
|
|
|
/// Result too large
|
|
RANGE = 34,
|
|
|
|
// non-blocking and interrupt i/o
|
|
|
|
/// Resource temporarily unavailable
|
|
/// This is the same code used for `WOULDBLOCK`.
|
|
AGAIN = 35,
|
|
|
|
/// Operation now in progress
|
|
INPROGRESS = 36,
|
|
|
|
/// Operation already in progress
|
|
ALREADY = 37,
|
|
|
|
// ipc/network software -- argument errors
|
|
|
|
/// Socket operation on non-socket
|
|
NOTSOCK = 38,
|
|
|
|
/// Destination address required
|
|
DESTADDRREQ = 39,
|
|
|
|
/// Message too long
|
|
MSGSIZE = 40,
|
|
|
|
/// Protocol wrong type for socket
|
|
PROTOTYPE = 41,
|
|
|
|
/// Protocol not available
|
|
NOPROTOOPT = 42,
|
|
|
|
/// Protocol not supported
|
|
PROTONOSUPPORT = 43,
|
|
|
|
/// Socket type not supported
|
|
SOCKTNOSUPPORT = 44,
|
|
|
|
/// Operation not supported
|
|
/// The same code is used for `NOTSUP`.
|
|
OPNOTSUPP = 45,
|
|
|
|
/// Protocol family not supported
|
|
PFNOSUPPORT = 46,
|
|
|
|
/// Address family not supported by protocol family
|
|
AFNOSUPPORT = 47,
|
|
|
|
/// Address already in use
|
|
ADDRINUSE = 48,
|
|
/// Can't assign requested address
|
|
|
|
// ipc/network software -- operational errors
|
|
ADDRNOTAVAIL = 49,
|
|
|
|
/// Network is down
|
|
NETDOWN = 50,
|
|
|
|
/// Network is unreachable
|
|
NETUNREACH = 51,
|
|
|
|
/// Network dropped connection on reset
|
|
NETRESET = 52,
|
|
|
|
/// Software caused connection abort
|
|
CONNABORTED = 53,
|
|
|
|
/// Connection reset by peer
|
|
CONNRESET = 54,
|
|
|
|
/// No buffer space available
|
|
NOBUFS = 55,
|
|
|
|
/// Socket is already connected
|
|
ISCONN = 56,
|
|
|
|
/// Socket is not connected
|
|
NOTCONN = 57,
|
|
|
|
/// Can't send after socket shutdown
|
|
SHUTDOWN = 58,
|
|
|
|
/// Too many references: can't splice
|
|
TOOMANYREFS = 59,
|
|
|
|
/// Operation timed out
|
|
TIMEDOUT = 60,
|
|
|
|
/// Connection refused
|
|
CONNREFUSED = 61,
|
|
|
|
/// Too many levels of symbolic links
|
|
LOOP = 62,
|
|
|
|
/// File name too long
|
|
NAMETOOLONG = 63,
|
|
|
|
/// Host is down
|
|
HOSTDOWN = 64,
|
|
|
|
/// No route to host
|
|
HOSTUNREACH = 65,
|
|
/// Directory not empty
|
|
|
|
// quotas & mush
|
|
NOTEMPTY = 66,
|
|
|
|
/// Too many processes
|
|
PROCLIM = 67,
|
|
|
|
/// Too many users
|
|
USERS = 68,
|
|
/// Disc quota exceeded
|
|
|
|
// Network File System
|
|
DQUOT = 69,
|
|
|
|
/// Stale NFS file handle
|
|
STALE = 70,
|
|
|
|
/// Too many levels of remote in path
|
|
REMOTE = 71,
|
|
|
|
/// RPC struct is bad
|
|
BADRPC = 72,
|
|
|
|
/// RPC version wrong
|
|
RPCMISMATCH = 73,
|
|
|
|
/// RPC prog. not avail
|
|
PROGUNAVAIL = 74,
|
|
|
|
/// Program version wrong
|
|
PROGMISMATCH = 75,
|
|
|
|
/// Bad procedure for program
|
|
PROCUNAVAIL = 76,
|
|
|
|
/// No locks available
|
|
NOLCK = 77,
|
|
|
|
/// Function not implemented
|
|
NOSYS = 78,
|
|
|
|
/// Inappropriate file type or format
|
|
FTYPE = 79,
|
|
|
|
/// Authentication error
|
|
AUTH = 80,
|
|
|
|
/// Need authenticator
|
|
NEEDAUTH = 81,
|
|
|
|
// Intelligent device errors
|
|
|
|
/// Device power is off
|
|
PWROFF = 82,
|
|
|
|
/// Device error, e.g. paper out
|
|
DEVERR = 83,
|
|
|
|
/// Value too large to be stored in data type
|
|
OVERFLOW = 84,
|
|
|
|
// Program loading errors
|
|
|
|
/// Bad executable
|
|
BADEXEC = 85,
|
|
|
|
/// Bad CPU type in executable
|
|
BADARCH = 86,
|
|
|
|
/// Shared library version mismatch
|
|
SHLIBVERS = 87,
|
|
|
|
/// Malformed Macho file
|
|
BADMACHO = 88,
|
|
|
|
/// Operation canceled
|
|
CANCELED = 89,
|
|
|
|
/// Identifier removed
|
|
IDRM = 90,
|
|
|
|
/// No message of desired type
|
|
NOMSG = 91,
|
|
|
|
/// Illegal byte sequence
|
|
ILSEQ = 92,
|
|
|
|
/// Attribute not found
|
|
NOATTR = 93,
|
|
|
|
/// Bad message
|
|
BADMSG = 94,
|
|
|
|
/// Reserved
|
|
MULTIHOP = 95,
|
|
|
|
/// No message available on STREAM
|
|
NODATA = 96,
|
|
|
|
/// Reserved
|
|
NOLINK = 97,
|
|
|
|
/// No STREAM resources
|
|
NOSR = 98,
|
|
|
|
/// Not a STREAM
|
|
NOSTR = 99,
|
|
|
|
/// Protocol error
|
|
PROTO = 100,
|
|
|
|
/// STREAM ioctl timeout
|
|
TIME = 101,
|
|
|
|
/// No such policy registered
|
|
NOPOLICY = 103,
|
|
|
|
/// State not recoverable
|
|
NOTRECOVERABLE = 104,
|
|
|
|
/// Previous owner died
|
|
OWNERDEAD = 105,
|
|
|
|
/// Interface output queue is full
|
|
QFULL = 106,
|
|
|
|
_,
|
|
};
|
|
|
|
pub fn getKernError(err: kern_return_t) KernE {
|
|
return @intToEnum(KernE, @truncate(u8, @intCast(usize, err)));
|
|
}
|
|
|
|
/// Kernel return values
|
|
pub const KernE = enum(u8) {
|
|
SUCCESS = 0,
|
|
|
|
/// Specified address is not currently valid
|
|
INVALID_ADDRESS = 1,
|
|
|
|
/// Specified memory is valid, but does not permit the
|
|
/// required forms of access.
|
|
PROTECTION_FAILURE = 2,
|
|
|
|
/// The address range specified is already in use, or
|
|
/// no address range of the size specified could be
|
|
/// found.
|
|
NO_SPACE = 3,
|
|
|
|
/// The function requested was not applicable to this
|
|
/// type of argument, or an argument is invalid
|
|
INVALID_ARGUMENT = 4,
|
|
|
|
/// The function could not be performed. A catch-all.
|
|
FAILURE = 5,
|
|
|
|
/// A system resource could not be allocated to fulfill
|
|
/// this request. This failure may not be permanent.
|
|
RESOURCE_SHORTAGE = 6,
|
|
|
|
/// The task in question does not hold receive rights
|
|
/// for the port argument.
|
|
NOT_RECEIVER = 7,
|
|
|
|
/// Bogus access restriction.
|
|
NO_ACCESS = 8,
|
|
|
|
/// During a page fault, the target address refers to a
|
|
/// memory object that has been destroyed. This
|
|
/// failure is permanent.
|
|
MEMORY_FAILURE = 9,
|
|
|
|
/// During a page fault, the memory object indicated
|
|
/// that the data could not be returned. This failure
|
|
/// may be temporary; future attempts to access this
|
|
/// same data may succeed, as defined by the memory
|
|
/// object.
|
|
MEMORY_ERROR = 10,
|
|
|
|
/// The receive right is already a member of the portset.
|
|
ALREADY_IN_SET = 11,
|
|
|
|
/// The receive right is not a member of a port set.
|
|
NOT_IN_SET = 12,
|
|
|
|
/// The name already denotes a right in the task.
|
|
NAME_EXISTS = 13,
|
|
|
|
/// The operation was aborted. Ipc code will
|
|
/// catch this and reflect it as a message error.
|
|
ABORTED = 14,
|
|
|
|
/// The name doesn't denote a right in the task.
|
|
INVALID_NAME = 15,
|
|
|
|
/// Target task isn't an active task.
|
|
INVALID_TASK = 16,
|
|
|
|
/// The name denotes a right, but not an appropriate right.
|
|
INVALID_RIGHT = 17,
|
|
|
|
/// A blatant range error.
|
|
INVALID_VALUE = 18,
|
|
|
|
/// Operation would overflow limit on user-references.
|
|
UREFS_OVERFLOW = 19,
|
|
|
|
/// The supplied (port) capability is improper.
|
|
INVALID_CAPABILITY = 20,
|
|
|
|
/// The task already has send or receive rights
|
|
/// for the port under another name.
|
|
RIGHT_EXISTS = 21,
|
|
|
|
/// Target host isn't actually a host.
|
|
INVALID_HOST = 22,
|
|
|
|
/// An attempt was made to supply "precious" data
|
|
/// for memory that is already present in a
|
|
/// memory object.
|
|
MEMORY_PRESENT = 23,
|
|
|
|
/// A page was requested of a memory manager via
|
|
/// memory_object_data_request for an object using
|
|
/// a MEMORY_OBJECT_COPY_CALL strategy, with the
|
|
/// VM_PROT_WANTS_COPY flag being used to specify
|
|
/// that the page desired is for a copy of the
|
|
/// object, and the memory manager has detected
|
|
/// the page was pushed into a copy of the object
|
|
/// while the kernel was walking the shadow chain
|
|
/// from the copy to the object. This error code
|
|
/// is delivered via memory_object_data_error
|
|
/// and is handled by the kernel (it forces the
|
|
/// kernel to restart the fault). It will not be
|
|
/// seen by users.
|
|
MEMORY_DATA_MOVED = 24,
|
|
|
|
/// A strategic copy was attempted of an object
|
|
/// upon which a quicker copy is now possible.
|
|
/// The caller should retry the copy using
|
|
/// vm_object_copy_quickly. This error code
|
|
/// is seen only by the kernel.
|
|
MEMORY_RESTART_COPY = 25,
|
|
|
|
/// An argument applied to assert processor set privilege
|
|
/// was not a processor set control port.
|
|
INVALID_PROCESSOR_SET = 26,
|
|
|
|
/// The specified scheduling attributes exceed the thread's
|
|
/// limits.
|
|
POLICY_LIMIT = 27,
|
|
|
|
/// The specified scheduling policy is not currently
|
|
/// enabled for the processor set.
|
|
INVALID_POLICY = 28,
|
|
|
|
/// The external memory manager failed to initialize the
|
|
/// memory object.
|
|
INVALID_OBJECT = 29,
|
|
|
|
/// A thread is attempting to wait for an event for which
|
|
/// there is already a waiting thread.
|
|
ALREADY_WAITING = 30,
|
|
|
|
/// An attempt was made to destroy the default processor
|
|
/// set.
|
|
DEFAULT_SET = 31,
|
|
|
|
/// An attempt was made to fetch an exception port that is
|
|
/// protected, or to abort a thread while processing a
|
|
/// protected exception.
|
|
EXCEPTION_PROTECTED = 32,
|
|
|
|
/// A ledger was required but not supplied.
|
|
INVALID_LEDGER = 33,
|
|
|
|
/// The port was not a memory cache control port.
|
|
INVALID_MEMORY_CONTROL = 34,
|
|
|
|
/// An argument supplied to assert security privilege
|
|
/// was not a host security port.
|
|
INVALID_SECURITY = 35,
|
|
|
|
/// thread_depress_abort was called on a thread which
|
|
/// was not currently depressed.
|
|
NOT_DEPRESSED = 36,
|
|
|
|
/// Object has been terminated and is no longer available
|
|
TERMINATED = 37,
|
|
|
|
/// Lock set has been destroyed and is no longer available.
|
|
LOCK_SET_DESTROYED = 38,
|
|
|
|
/// The thread holding the lock terminated before releasing
|
|
/// the lock
|
|
LOCK_UNSTABLE = 39,
|
|
|
|
/// The lock is already owned by another thread
|
|
LOCK_OWNED = 40,
|
|
|
|
/// The lock is already owned by the calling thread
|
|
LOCK_OWNED_SELF = 41,
|
|
|
|
/// Semaphore has been destroyed and is no longer available.
|
|
SEMAPHORE_DESTROYED = 42,
|
|
|
|
/// Return from RPC indicating the target server was
|
|
/// terminated before it successfully replied
|
|
RPC_SERVER_TERMINATED = 43,
|
|
|
|
/// Terminate an orphaned activation.
|
|
RPC_TERMINATE_ORPHAN = 44,
|
|
|
|
/// Allow an orphaned activation to continue executing.
|
|
RPC_CONTINUE_ORPHAN = 45,
|
|
|
|
/// Empty thread activation (No thread linked to it)
|
|
NOT_SUPPORTED = 46,
|
|
|
|
/// Remote node down or inaccessible.
|
|
NODE_DOWN = 47,
|
|
|
|
/// A signalled thread was not actually waiting.
|
|
NOT_WAITING = 48,
|
|
|
|
/// Some thread-oriented operation (semaphore_wait) timed out
|
|
OPERATION_TIMED_OUT = 49,
|
|
|
|
/// During a page fault, indicates that the page was rejected
|
|
/// as a result of a signature check.
|
|
CODESIGN_ERROR = 50,
|
|
|
|
/// The requested property cannot be changed at this time.
|
|
POLICY_STATIC = 51,
|
|
|
|
/// The provided buffer is of insufficient size for the requested data.
|
|
INSUFFICIENT_BUFFER_SIZE = 52,
|
|
|
|
/// Denied by security policy
|
|
DENIED = 53,
|
|
|
|
/// The KC on which the function is operating is missing
|
|
MISSING_KC = 54,
|
|
|
|
/// The KC on which the function is operating is invalid
|
|
INVALID_KC = 55,
|
|
|
|
/// A search or query operation did not return a result
|
|
NOT_FOUND = 56,
|
|
|
|
_,
|
|
};
|
|
|
|
pub const SIGSTKSZ = 131072;
|
|
pub const MINSIGSTKSZ = 32768;
|
|
|
|
pub const SS_ONSTACK = 1;
|
|
pub const SS_DISABLE = 4;
|
|
|
|
pub const stack_t = extern struct {
|
|
sp: [*]u8,
|
|
size: isize,
|
|
flags: i32,
|
|
};
|
|
|
|
pub const S = struct {
|
|
pub const IFMT = 0o170000;
|
|
|
|
pub const IFIFO = 0o010000;
|
|
pub const IFCHR = 0o020000;
|
|
pub const IFDIR = 0o040000;
|
|
pub const IFBLK = 0o060000;
|
|
pub const IFREG = 0o100000;
|
|
pub const IFLNK = 0o120000;
|
|
pub const IFSOCK = 0o140000;
|
|
pub const IFWHT = 0o160000;
|
|
|
|
pub const ISUID = 0o4000;
|
|
pub const ISGID = 0o2000;
|
|
pub const ISVTX = 0o1000;
|
|
pub const IRWXU = 0o700;
|
|
pub const IRUSR = 0o400;
|
|
pub const IWUSR = 0o200;
|
|
pub const IXUSR = 0o100;
|
|
pub const IRWXG = 0o070;
|
|
pub const IRGRP = 0o040;
|
|
pub const IWGRP = 0o020;
|
|
pub const IXGRP = 0o010;
|
|
pub const IRWXO = 0o007;
|
|
pub const IROTH = 0o004;
|
|
pub const IWOTH = 0o002;
|
|
pub const IXOTH = 0o001;
|
|
|
|
pub fn ISFIFO(m: u32) bool {
|
|
return m & IFMT == IFIFO;
|
|
}
|
|
|
|
pub fn ISCHR(m: u32) bool {
|
|
return m & IFMT == IFCHR;
|
|
}
|
|
|
|
pub fn ISDIR(m: u32) bool {
|
|
return m & IFMT == IFDIR;
|
|
}
|
|
|
|
pub fn ISBLK(m: u32) bool {
|
|
return m & IFMT == IFBLK;
|
|
}
|
|
|
|
pub fn ISREG(m: u32) bool {
|
|
return m & IFMT == IFREG;
|
|
}
|
|
|
|
pub fn ISLNK(m: u32) bool {
|
|
return m & IFMT == IFLNK;
|
|
}
|
|
|
|
pub fn ISSOCK(m: u32) bool {
|
|
return m & IFMT == IFSOCK;
|
|
}
|
|
|
|
pub fn IWHT(m: u32) bool {
|
|
return m & IFMT == IFWHT;
|
|
}
|
|
};
|
|
|
|
pub const HOST_NAME_MAX = 72;
|
|
|
|
pub const AT = struct {
|
|
pub const FDCWD = -2;
|
|
/// Use effective ids in access check
|
|
pub const EACCESS = 0x0010;
|
|
/// Act on the symlink itself not the target
|
|
pub const SYMLINK_NOFOLLOW = 0x0020;
|
|
/// Act on target of symlink
|
|
pub const SYMLINK_FOLLOW = 0x0040;
|
|
/// Path refers to directory
|
|
pub const REMOVEDIR = 0x0080;
|
|
};
|
|
|
|
pub const addrinfo = extern struct {
|
|
flags: i32,
|
|
family: i32,
|
|
socktype: i32,
|
|
protocol: i32,
|
|
addrlen: socklen_t,
|
|
canonname: ?[*:0]u8,
|
|
addr: ?*sockaddr,
|
|
next: ?*addrinfo,
|
|
};
|
|
|
|
pub const RTLD = struct {
|
|
pub const LAZY = 0x1;
|
|
pub const NOW = 0x2;
|
|
pub const LOCAL = 0x4;
|
|
pub const GLOBAL = 0x8;
|
|
pub const NOLOAD = 0x10;
|
|
pub const NODELETE = 0x80;
|
|
pub const FIRST = 0x100;
|
|
|
|
pub const NEXT = @intToPtr(*anyopaque, @bitCast(usize, @as(isize, -1)));
|
|
pub const DEFAULT = @intToPtr(*anyopaque, @bitCast(usize, @as(isize, -2)));
|
|
pub const SELF = @intToPtr(*anyopaque, @bitCast(usize, @as(isize, -3)));
|
|
pub const MAIN_ONLY = @intToPtr(*anyopaque, @bitCast(usize, @as(isize, -5)));
|
|
};
|
|
|
|
pub const F = struct {
|
|
/// duplicate file descriptor
|
|
pub const DUPFD = 0;
|
|
/// get file descriptor flags
|
|
pub const GETFD = 1;
|
|
/// set file descriptor flags
|
|
pub const SETFD = 2;
|
|
/// get file status flags
|
|
pub const GETFL = 3;
|
|
/// set file status flags
|
|
pub const SETFL = 4;
|
|
/// get SIGIO/SIGURG proc/pgrp
|
|
pub const GETOWN = 5;
|
|
/// set SIGIO/SIGURG proc/pgrp
|
|
pub const SETOWN = 6;
|
|
/// get record locking information
|
|
pub const GETLK = 7;
|
|
/// set record locking information
|
|
pub const SETLK = 8;
|
|
/// F.SETLK; wait if blocked
|
|
pub const SETLKW = 9;
|
|
/// F.SETLK; wait if blocked, return on timeout
|
|
pub const SETLKWTIMEOUT = 10;
|
|
pub const FLUSH_DATA = 40;
|
|
/// Used for regression test
|
|
pub const CHKCLEAN = 41;
|
|
/// Preallocate storage
|
|
pub const PREALLOCATE = 42;
|
|
/// Truncate a file without zeroing space
|
|
pub const SETSIZE = 43;
|
|
/// Issue an advisory read async with no copy to user
|
|
pub const RDADVISE = 44;
|
|
/// turn read ahead off/on for this fd
|
|
pub const RDAHEAD = 45;
|
|
/// turn data caching off/on for this fd
|
|
pub const NOCACHE = 48;
|
|
/// file offset to device offset
|
|
pub const LOG2PHYS = 49;
|
|
/// return the full path of the fd
|
|
pub const GETPATH = 50;
|
|
/// fsync + ask the drive to flush to the media
|
|
pub const FULLFSYNC = 51;
|
|
/// find which component (if any) is a package
|
|
pub const PATHPKG_CHECK = 52;
|
|
/// "freeze" all fs operations
|
|
pub const FREEZE_FS = 53;
|
|
/// "thaw" all fs operations
|
|
pub const THAW_FS = 54;
|
|
/// turn data caching off/on (globally) for this file
|
|
pub const GLOBAL_NOCACHE = 55;
|
|
/// add detached signatures
|
|
pub const ADDSIGS = 59;
|
|
/// add signature from same file (used by dyld for shared libs)
|
|
pub const ADDFILESIGS = 61;
|
|
/// used in conjunction with F.NOCACHE to indicate that DIRECT, synchonous writes
|
|
/// should not be used (i.e. its ok to temporaily create cached pages)
|
|
pub const NODIRECT = 62;
|
|
///Get the protection class of a file from the EA, returns int
|
|
pub const GETPROTECTIONCLASS = 63;
|
|
///Set the protection class of a file for the EA, requires int
|
|
pub const SETPROTECTIONCLASS = 64;
|
|
///file offset to device offset, extended
|
|
pub const LOG2PHYS_EXT = 65;
|
|
///get record locking information, per-process
|
|
pub const GETLKPID = 66;
|
|
///Mark the file as being the backing store for another filesystem
|
|
pub const SETBACKINGSTORE = 70;
|
|
///return the full path of the FD, but error in specific mtmd circumstances
|
|
pub const GETPATH_MTMINFO = 71;
|
|
///Returns the code directory, with associated hashes, to the caller
|
|
pub const GETCODEDIR = 72;
|
|
///No SIGPIPE generated on EPIPE
|
|
pub const SETNOSIGPIPE = 73;
|
|
///Status of SIGPIPE for this fd
|
|
pub const GETNOSIGPIPE = 74;
|
|
///For some cases, we need to rewrap the key for AKS/MKB
|
|
pub const TRANSCODEKEY = 75;
|
|
///file being written to a by single writer... if throttling enabled, writes
|
|
///may be broken into smaller chunks with throttling in between
|
|
pub const SINGLE_WRITER = 76;
|
|
///Get the protection version number for this filesystem
|
|
pub const GETPROTECTIONLEVEL = 77;
|
|
///Add detached code signatures (used by dyld for shared libs)
|
|
pub const FINDSIGS = 78;
|
|
///Add signature from same file, only if it is signed by Apple (used by dyld for simulator)
|
|
pub const ADDFILESIGS_FOR_DYLD_SIM = 83;
|
|
///fsync + issue barrier to drive
|
|
pub const BARRIERFSYNC = 85;
|
|
///Add signature from same file, return end offset in structure on success
|
|
pub const ADDFILESIGS_RETURN = 97;
|
|
///Check if Library Validation allows this Mach-O file to be mapped into the calling process
|
|
pub const CHECK_LV = 98;
|
|
///Deallocate a range of the file
|
|
pub const PUNCHHOLE = 99;
|
|
///Trim an active file
|
|
pub const TRIM_ACTIVE_FILE = 100;
|
|
///mark the dup with FD_CLOEXEC
|
|
pub const DUPFD_CLOEXEC = 67;
|
|
/// shared or read lock
|
|
pub const RDLCK = 1;
|
|
/// unlock
|
|
pub const UNLCK = 2;
|
|
/// exclusive or write lock
|
|
pub const WRLCK = 3;
|
|
};
|
|
|
|
pub const FCNTL_FS_SPECIFIC_BASE = 0x00010000;
|
|
|
|
///close-on-exec flag
|
|
pub const FD_CLOEXEC = 1;
|
|
|
|
pub const LOCK = struct {
|
|
pub const SH = 1;
|
|
pub const EX = 2;
|
|
pub const UN = 8;
|
|
pub const NB = 4;
|
|
};
|
|
|
|
pub const nfds_t = u32;
|
|
pub const pollfd = extern struct {
|
|
fd: fd_t,
|
|
events: i16,
|
|
revents: i16,
|
|
};
|
|
|
|
pub const POLL = struct {
|
|
pub const IN = 0x001;
|
|
pub const PRI = 0x002;
|
|
pub const OUT = 0x004;
|
|
pub const RDNORM = 0x040;
|
|
pub const WRNORM = OUT;
|
|
pub const RDBAND = 0x080;
|
|
pub const WRBAND = 0x100;
|
|
|
|
pub const EXTEND = 0x0200;
|
|
pub const ATTRIB = 0x0400;
|
|
pub const NLINK = 0x0800;
|
|
pub const WRITE = 0x1000;
|
|
|
|
pub const ERR = 0x008;
|
|
pub const HUP = 0x010;
|
|
pub const NVAL = 0x020;
|
|
|
|
pub const STANDARD = IN | PRI | OUT | RDNORM | RDBAND | WRBAND | ERR | HUP | NVAL;
|
|
};
|
|
|
|
pub const CLOCK = struct {
|
|
pub const REALTIME = 0;
|
|
pub const MONOTONIC = 6;
|
|
pub const MONOTONIC_RAW = 4;
|
|
pub const MONOTONIC_RAW_APPROX = 5;
|
|
pub const UPTIME_RAW = 8;
|
|
pub const UPTIME_RAW_APPROX = 9;
|
|
pub const PROCESS_CPUTIME_ID = 12;
|
|
pub const THREAD_CPUTIME_ID = 16;
|
|
};
|
|
|
|
/// Max open files per process
|
|
/// https://opensource.apple.com/source/xnu/xnu-4903.221.2/bsd/sys/syslimits.h.auto.html
|
|
pub const OPEN_MAX = 10240;
|
|
|
|
pub const rusage = extern struct {
|
|
utime: timeval,
|
|
stime: timeval,
|
|
maxrss: isize,
|
|
ixrss: isize,
|
|
idrss: isize,
|
|
isrss: isize,
|
|
minflt: isize,
|
|
majflt: isize,
|
|
nswap: isize,
|
|
inblock: isize,
|
|
oublock: isize,
|
|
msgsnd: isize,
|
|
msgrcv: isize,
|
|
nsignals: isize,
|
|
nvcsw: isize,
|
|
nivcsw: isize,
|
|
|
|
pub const SELF = 0;
|
|
pub const CHILDREN = -1;
|
|
};
|
|
|
|
pub const rlimit_resource = enum(c_int) {
|
|
CPU = 0,
|
|
FSIZE = 1,
|
|
DATA = 2,
|
|
STACK = 3,
|
|
CORE = 4,
|
|
RSS = 5,
|
|
MEMLOCK = 6,
|
|
NPROC = 7,
|
|
NOFILE = 8,
|
|
_,
|
|
|
|
pub const AS: rlimit_resource = .RSS;
|
|
};
|
|
|
|
pub const rlim_t = u64;
|
|
|
|
pub const RLIM = struct {
|
|
/// No limit
|
|
pub const INFINITY: rlim_t = (1 << 63) - 1;
|
|
|
|
pub const SAVED_MAX = INFINITY;
|
|
pub const SAVED_CUR = INFINITY;
|
|
};
|
|
|
|
pub const rlimit = extern struct {
|
|
/// Soft limit
|
|
cur: rlim_t,
|
|
/// Hard limit
|
|
max: rlim_t,
|
|
};
|
|
|
|
pub const SHUT = struct {
|
|
pub const RD = 0;
|
|
pub const WR = 1;
|
|
pub const RDWR = 2;
|
|
};
|
|
|
|
// Term
|
|
pub const V = struct {
|
|
pub const EOF = 0;
|
|
pub const EOL = 1;
|
|
pub const EOL2 = 2;
|
|
pub const ERASE = 3;
|
|
pub const WERASE = 4;
|
|
pub const KILL = 5;
|
|
pub const REPRINT = 6;
|
|
pub const INTR = 8;
|
|
pub const QUIT = 9;
|
|
pub const SUSP = 10;
|
|
pub const DSUSP = 11;
|
|
pub const START = 12;
|
|
pub const STOP = 13;
|
|
pub const LNEXT = 14;
|
|
pub const DISCARD = 15;
|
|
pub const MIN = 16;
|
|
pub const TIME = 17;
|
|
pub const STATUS = 18;
|
|
};
|
|
|
|
pub const NCCS = 20; // 2 spares (7, 19)
|
|
|
|
pub const cc_t = u8;
|
|
pub const speed_t = u64;
|
|
pub const tcflag_t = u64;
|
|
|
|
pub const IGNBRK: tcflag_t = 0x00000001; // ignore BREAK condition
|
|
pub const BRKINT: tcflag_t = 0x00000002; // map BREAK to SIGINTR
|
|
pub const IGNPAR: tcflag_t = 0x00000004; // ignore (discard) parity errors
|
|
pub const PARMRK: tcflag_t = 0x00000008; // mark parity and framing errors
|
|
pub const INPCK: tcflag_t = 0x00000010; // enable checking of parity errors
|
|
pub const ISTRIP: tcflag_t = 0x00000020; // strip 8th bit off chars
|
|
pub const INLCR: tcflag_t = 0x00000040; // map NL into CR
|
|
pub const IGNCR: tcflag_t = 0x00000080; // ignore CR
|
|
pub const ICRNL: tcflag_t = 0x00000100; // map CR to NL (ala CRMOD)
|
|
pub const IXON: tcflag_t = 0x00000200; // enable output flow control
|
|
pub const IXOFF: tcflag_t = 0x00000400; // enable input flow control
|
|
pub const IXANY: tcflag_t = 0x00000800; // any char will restart after stop
|
|
pub const IMAXBEL: tcflag_t = 0x00002000; // ring bell on input queue full
|
|
pub const IUTF8: tcflag_t = 0x00004000; // maintain state for UTF-8 VERASE
|
|
|
|
pub const OPOST: tcflag_t = 0x00000001; //enable following output processing
|
|
pub const ONLCR: tcflag_t = 0x00000002; // map NL to CR-NL (ala CRMOD)
|
|
pub const OXTABS: tcflag_t = 0x00000004; // expand tabs to spaces
|
|
pub const ONOEOT: tcflag_t = 0x00000008; // discard EOT's (^D) on output)
|
|
|
|
pub const OCRNL: tcflag_t = 0x00000010; // map CR to NL on output
|
|
pub const ONOCR: tcflag_t = 0x00000020; // no CR output at column 0
|
|
pub const ONLRET: tcflag_t = 0x00000040; // NL performs CR function
|
|
pub const OFILL: tcflag_t = 0x00000080; // use fill characters for delay
|
|
pub const NLDLY: tcflag_t = 0x00000300; // \n delay
|
|
pub const TABDLY: tcflag_t = 0x00000c04; // horizontal tab delay
|
|
pub const CRDLY: tcflag_t = 0x00003000; // \r delay
|
|
pub const FFDLY: tcflag_t = 0x00004000; // form feed delay
|
|
pub const BSDLY: tcflag_t = 0x00008000; // \b delay
|
|
pub const VTDLY: tcflag_t = 0x00010000; // vertical tab delay
|
|
pub const OFDEL: tcflag_t = 0x00020000; // fill is DEL, else NUL
|
|
|
|
pub const NL0: tcflag_t = 0x00000000;
|
|
pub const NL1: tcflag_t = 0x00000100;
|
|
pub const NL2: tcflag_t = 0x00000200;
|
|
pub const NL3: tcflag_t = 0x00000300;
|
|
pub const TAB0: tcflag_t = 0x00000000;
|
|
pub const TAB1: tcflag_t = 0x00000400;
|
|
pub const TAB2: tcflag_t = 0x00000800;
|
|
pub const TAB3: tcflag_t = 0x00000004;
|
|
pub const CR0: tcflag_t = 0x00000000;
|
|
pub const CR1: tcflag_t = 0x00001000;
|
|
pub const CR2: tcflag_t = 0x00002000;
|
|
pub const CR3: tcflag_t = 0x00003000;
|
|
pub const FF0: tcflag_t = 0x00000000;
|
|
pub const FF1: tcflag_t = 0x00004000;
|
|
pub const BS0: tcflag_t = 0x00000000;
|
|
pub const BS1: tcflag_t = 0x00008000;
|
|
pub const VT0: tcflag_t = 0x00000000;
|
|
pub const VT1: tcflag_t = 0x00010000;
|
|
|
|
pub const CIGNORE: tcflag_t = 0x00000001; // ignore control flags
|
|
pub const CSIZE: tcflag_t = 0x00000300; // character size mask
|
|
pub const CS5: tcflag_t = 0x00000000; // 5 bits (pseudo)
|
|
pub const CS6: tcflag_t = 0x00000100; // 6 bits
|
|
pub const CS7: tcflag_t = 0x00000200; // 7 bits
|
|
pub const CS8: tcflag_t = 0x00000300; // 8 bits
|
|
pub const CSTOPB: tcflag_t = 0x0000040; // send 2 stop bits
|
|
pub const CREAD: tcflag_t = 0x00000800; // enable receiver
|
|
pub const PARENB: tcflag_t = 0x00001000; // parity enable
|
|
pub const PARODD: tcflag_t = 0x00002000; // odd parity, else even
|
|
pub const HUPCL: tcflag_t = 0x00004000; // hang up on last close
|
|
pub const CLOCAL: tcflag_t = 0x00008000; // ignore modem status lines
|
|
pub const CCTS_OFLOW: tcflag_t = 0x00010000; // CTS flow control of output
|
|
pub const CRTSCTS: tcflag_t = (CCTS_OFLOW | CRTS_IFLOW);
|
|
pub const CRTS_IFLOW: tcflag_t = 0x00020000; // RTS flow control of input
|
|
pub const CDTR_IFLOW: tcflag_t = 0x00040000; // DTR flow control of input
|
|
pub const CDSR_OFLOW: tcflag_t = 0x00080000; // DSR flow control of output
|
|
pub const CCAR_OFLOW: tcflag_t = 0x00100000; // DCD flow control of output
|
|
pub const MDMBUF: tcflag_t = 0x00100000; // old name for CCAR_OFLOW
|
|
|
|
pub const ECHOKE: tcflag_t = 0x00000001; // visual erase for line kill
|
|
pub const ECHOE: tcflag_t = 0x00000002; // visually erase chars
|
|
pub const ECHOK: tcflag_t = 0x00000004; // echo NL after line kill
|
|
pub const ECHO: tcflag_t = 0x00000008; // enable echoing
|
|
pub const ECHONL: tcflag_t = 0x00000010; // echo NL even if ECHO is off
|
|
pub const ECHOPRT: tcflag_t = 0x00000020; // visual erase mode for hardcopy
|
|
pub const ECHOCTL: tcflag_t = 0x00000040; // echo control chars as ^(Char)
|
|
pub const ISIG: tcflag_t = 0x00000080; // enable signals INTR, QUIT, [D]SUSP
|
|
pub const ICANON: tcflag_t = 0x00000100; // canonicalize input lines
|
|
pub const ALTWERASE: tcflag_t = 0x00000200; // use alternate WERASE algorithm
|
|
pub const IEXTEN: tcflag_t = 0x00000400; // enable DISCARD and LNEXT
|
|
pub const EXTPROC: tcflag_t = 0x00000800; // external processing
|
|
pub const TOSTOP: tcflag_t = 0x00400000; // stop background jobs from output
|
|
pub const FLUSHO: tcflag_t = 0x00800000; // output being flushed (state)
|
|
pub const NOKERNINFO: tcflag_t = 0x02000000; // no kernel output from VSTATUS
|
|
pub const PENDIN: tcflag_t = 0x20000000; // XXX retype pending input (state)
|
|
pub const NOFLSH: tcflag_t = 0x80000000; // don't flush after interrupt
|
|
|
|
pub const TCSANOW: tcflag_t = 0; // make change immediate
|
|
pub const TCSADRAIN: tcflag_t = 1; // drain output, then change
|
|
pub const TCSAFLUSH: tcflag_t = 2; // drain output, flush input
|
|
pub const TCSASOFT: tcflag_t = 0x10; // flag - don't alter h.w. state
|
|
pub const TCSA = enum(c_uint) {
|
|
NOW,
|
|
DRAIN,
|
|
FLUSH,
|
|
_,
|
|
};
|
|
|
|
pub const B0: tcflag_t = 0;
|
|
pub const B50: tcflag_t = 50;
|
|
pub const B75: tcflag_t = 75;
|
|
pub const B110: tcflag_t = 110;
|
|
pub const B134: tcflag_t = 134;
|
|
pub const B150: tcflag_t = 150;
|
|
pub const B200: tcflag_t = 200;
|
|
pub const B300: tcflag_t = 300;
|
|
pub const B600: tcflag_t = 600;
|
|
pub const B1200: tcflag_t = 1200;
|
|
pub const B1800: tcflag_t = 1800;
|
|
pub const B2400: tcflag_t = 2400;
|
|
pub const B4800: tcflag_t = 4800;
|
|
pub const B9600: tcflag_t = 9600;
|
|
pub const B19200: tcflag_t = 19200;
|
|
pub const B38400: tcflag_t = 38400;
|
|
pub const B7200: tcflag_t = 7200;
|
|
pub const B14400: tcflag_t = 14400;
|
|
pub const B28800: tcflag_t = 28800;
|
|
pub const B57600: tcflag_t = 57600;
|
|
pub const B76800: tcflag_t = 76800;
|
|
pub const B115200: tcflag_t = 115200;
|
|
pub const B230400: tcflag_t = 230400;
|
|
pub const EXTA: tcflag_t = 19200;
|
|
pub const EXTB: tcflag_t = 38400;
|
|
|
|
pub const TCIFLUSH: tcflag_t = 1;
|
|
pub const TCOFLUSH: tcflag_t = 2;
|
|
pub const TCIOFLUSH: tcflag_t = 3;
|
|
pub const TCOOFF: tcflag_t = 1;
|
|
pub const TCOON: tcflag_t = 2;
|
|
pub const TCIOFF: tcflag_t = 3;
|
|
pub const TCION: tcflag_t = 4;
|
|
|
|
pub const termios = extern struct {
|
|
iflag: tcflag_t, // input flags
|
|
oflag: tcflag_t, // output flags
|
|
cflag: tcflag_t, // control flags
|
|
lflag: tcflag_t, // local flags
|
|
cc: [NCCS]cc_t, // control chars
|
|
ispeed: speed_t align(8), // input speed
|
|
ospeed: speed_t, // output speed
|
|
};
|
|
|
|
pub const winsize = extern struct {
|
|
ws_row: u16,
|
|
ws_col: u16,
|
|
ws_xpixel: u16,
|
|
ws_ypixel: u16,
|
|
};
|
|
|
|
pub const T = struct {
|
|
pub const IOCGWINSZ = ior(0x40000000, 't', 104, @sizeOf(winsize));
|
|
};
|
|
pub const IOCPARM_MASK = 0x1fff;
|
|
|
|
fn ior(inout: u32, group: usize, num: usize, len: usize) usize {
|
|
return (inout | ((len & IOCPARM_MASK) << 16) | ((group) << 8) | (num));
|
|
}
|
|
|
|
// CPU families mapping
|
|
pub const CPUFAMILY = enum(u32) {
|
|
UNKNOWN = 0,
|
|
POWERPC_G3 = 0xcee41549,
|
|
POWERPC_G4 = 0x77c184ae,
|
|
POWERPC_G5 = 0xed76d8aa,
|
|
INTEL_6_13 = 0xaa33392b,
|
|
INTEL_PENRYN = 0x78ea4fbc,
|
|
INTEL_NEHALEM = 0x6b5a4cd2,
|
|
INTEL_WESTMERE = 0x573b5eec,
|
|
INTEL_SANDYBRIDGE = 0x5490b78c,
|
|
INTEL_IVYBRIDGE = 0x1f65e835,
|
|
INTEL_HASWELL = 0x10b282dc,
|
|
INTEL_BROADWELL = 0x582ed09c,
|
|
INTEL_SKYLAKE = 0x37fc219f,
|
|
INTEL_KABYLAKE = 0x0f817246,
|
|
ARM_9 = 0xe73283ae,
|
|
ARM_11 = 0x8ff620d8,
|
|
ARM_XSCALE = 0x53b005f5,
|
|
ARM_12 = 0xbd1b0ae9,
|
|
ARM_13 = 0x0cc90e64,
|
|
ARM_14 = 0x96077ef1,
|
|
ARM_15 = 0xa8511bca,
|
|
ARM_SWIFT = 0x1e2d6381,
|
|
ARM_CYCLONE = 0x37a09642,
|
|
ARM_TYPHOON = 0x2c91a47e,
|
|
ARM_TWISTER = 0x92fb37c8,
|
|
ARM_HURRICANE = 0x67ceee93,
|
|
ARM_MONSOON_MISTRAL = 0xe81e7ef6,
|
|
ARM_VORTEX_TEMPEST = 0x07d34b9f,
|
|
ARM_LIGHTNING_THUNDER = 0x462504d2,
|
|
ARM_FIRESTORM_ICESTORM = 0x1b588bb3,
|
|
_,
|
|
};
|
|
|
|
pub const POSIX_SPAWN_RESETIDS = 0x0001;
|
|
pub const POSIX_SPAWN_SETPGROUP = 0x0002;
|
|
pub const POSIX_SPAWN_SETSIGDEF = 0x0004;
|
|
pub const POSIX_SPAWN_SETSIGMASK = 0x0008;
|
|
pub const POSIX_SPAWN_SETEXEC = 0x0040;
|
|
pub const POSIX_SPAWN_START_SUSPENDED = 0x0080;
|
|
pub const _POSIX_SPAWN_DISABLE_ASLR = 0x0100;
|
|
pub const POSIX_SPAWN_SETSID = 0x0400;
|
|
pub const _POSIX_SPAWN_RESLIDE = 0x0800;
|
|
pub const POSIX_SPAWN_CLOEXEC_DEFAULT = 0x4000;
|
|
|
|
pub const PT_TRACE_ME = 0;
|
|
pub const PT_CONTINUE = 7;
|
|
pub const PT_KILL = 8;
|
|
pub const PT_STEP = 9;
|
|
pub const PT_DETACH = 11;
|
|
pub const PT_ATTACHEXC = 14;
|
|
pub const PT_DENY_ATTACH = 31;
|
|
|
|
pub const caddr_t = ?[*]u8;
|
|
|
|
pub extern "c" fn ptrace(request: c_int, pid: pid_t, addr: caddr_t, data: c_int) c_int;
|