Quelle mod.rs
Sprache: unbekannt
|
|
//! Apple (ios/darwin)-specific definitions
//!
//! This covers *-apple-* triples currently
pub type c_char = i8;
pub type wchar_t = i32;
pub type clock_t = c_ulong;
pub type time_t = c_long;
pub type suseconds_t = i32;
pub type dev_t = i32;
pub type ino_t = u64;
pub type mode_t = u16;
pub type nlink_t = u16;
pub type blksize_t = i32;
pub type rlim_t = u64;
pub type pthread_key_t = c_ulong;
pub type sigset_t = u32;
pub type clockid_t = ::c_uint;
pub type fsblkcnt_t = ::c_uint;
pub type fsfilcnt_t = ::c_uint;
pub type speed_t = ::c_ulong;
pub type tcflag_t = ::c_ulong;
pub type nl_item = ::c_int;
pub type id_t = ::c_uint;
pub type sem_t = ::c_int;
pub type idtype_t = ::c_uint;
pub type integer_t = ::c_int;
pub type cpu_type_t = integer_t;
pub type cpu_subtype_t = integer_t;
pub type natural_t = u32;
pub type mach_msg_type_number_t = natural_t;
pub type kern_return_t = ::c_int;
pub type uuid_t = [u8; 16];
pub type task_info_t = *mut integer_t;
pub type host_info_t = *mut integer_t;
pub type task_flavor_t = natural_t;
pub type rusage_info_t = *mut ::c_void;
pub type vm_offset_t = ::uintptr_t;
pub type vm_size_t = ::uintptr_t;
pub type vm_address_t = vm_offset_t;
pub type posix_spawnattr_t = *mut ::c_void;
pub type posix_spawn_file_actions_t = *mut ::c_void;
pub type key_t = ::c_int;
pub type shmatt_t = ::c_ushort;
pub type sae_associd_t = u32;
pub type sae_connid_t = u32;
pub type mach_port_t = ::c_uint;
pub type host_t = ::c_uint;
pub type host_flavor_t = integer_t;
pub type host_info64_t = *mut integer_t;
pub type processor_flavor_t = ::c_int;
pub type thread_flavor_t = natural_t;
pub type thread_inspect_t = ::mach_port_t;
pub type thread_act_t = ::mach_port_t;
pub type thread_act_array_t = *mut ::thread_act_t;
pub type policy_t = ::c_int;
pub type mach_vm_address_t = u64;
pub type mach_vm_offset_t = u64;
pub type mach_vm_size_t = u64;
pub type vm_map_t = ::mach_port_t;
pub type mem_entry_name_port_t = ::mach_port_t;
pub type memory_object_t = ::mach_port_t;
pub type memory_object_offset_t = ::c_ulonglong;
pub type vm_inherit_t = ::c_uint;
pub type vm_prot_t = ::c_int;
pub type ledger_t = ::mach_port_t;
pub type ledger_array_t = *mut ::ledger_t;
pub type iconv_t = *mut ::c_void;
pub type processor_cpu_load_info_t = *mut processor_cpu_load_info;
pub type processor_cpu_load_info_data_t = processor_cpu_load_info;
pub type processor_basic_info_t = *mut processor_basic_info;
pub type processor_basic_info_data_t = processor_basic_info;
pub type processor_set_basic_info_data_t = processor_set_basic_info;
pub type processor_set_basic_info_t = *mut processor_set_basic_info;
pub type processor_set_load_info_data_t = processor_set_load_info;
pub type processor_set_load_info_t = *mut processor_set_load_info;
pub type processor_info_t = *mut integer_t;
pub type processor_info_array_t = *mut integer_t;
pub type mach_task_basic_info_data_t = mach_task_basic_info;
pub type mach_task_basic_info_t = *mut mach_task_basic_info;
pub type task_thread_times_info_data_t = task_thread_times_info;
pub type task_thread_times_info_t = *mut task_thread_times_info;
pub type thread_info_t = *mut integer_t;
pub type thread_basic_info_t = *mut thread_basic_info;
pub type thread_basic_info_data_t = thread_basic_info;
pub type thread_identifier_info_t = *mut thread_identifier_info;
pub type thread_identifier_info_data_t = thread_identifier_info;
pub type thread_extended_info_t = *mut thread_extended_info;
pub type thread_extended_info_data_t = thread_extended_info;
pub type thread_t = ::mach_port_t;
pub type thread_policy_flavor_t = natural_t;
pub type thread_policy_t = *mut integer_t;
pub type thread_latency_qos_t = integer_t;
pub type thread_throughput_qos_t = integer_t;
pub type thread_standard_policy_data_t = thread_standard_policy;
pub type thread_standard_policy_t = *mut thread_standard_policy;
pub type thread_extended_policy_data_t = thread_extended_policy;
pub type thread_extended_policy_t = *mut thread_extended_policy;
pub type thread_time_constraint_policy_data_t = thread_time_constraint_policy;
pub type thread_time_constraint_policy_t = *mut thread_time_constraint_policy;
pub type thread_precedence_policy_data_t = thread_precedence_policy;
pub type thread_precedence_policy_t = *mut thread_precedence_policy;
pub type thread_affinity_policy_data_t = thread_affinity_policy;
pub type thread_affinity_policy_t = *mut thread_affinity_policy;
pub type thread_background_policy_data_t = thread_background_policy;
pub type thread_background_policy_t = *mut thread_background_policy;
pub type thread_latency_qos_policy_data_t = thread_latency_qos_policy;
pub type thread_latency_qos_policy_t = *mut thread_latency_qos_policy;
pub type thread_throughput_qos_policy_data_t = thread_throughput_qos_policy;
pub type thread_throughput_qos_policy_t = *mut thread_throughput_qos_policy;
pub type pthread_introspection_hook_t =
extern "C" fn(event: ::c_uint, thread: ::pthread_t, addr: *mut ::c_void, size: ::size_t);
pub type pthread_jit_write_callback_t = ::Option<extern "C" fn(ctx: *mut ::c_void) -> ::c_int>;
pub type os_clockid_t = u32;
pub type os_sync_wait_on_address_flags_t = u32;
pub type os_sync_wake_by_address_flags_t = u32;
pub type os_unfair_lock = os_unfair_lock_s;
pub type os_unfair_lock_t = *mut os_unfair_lock;
pub type os_log_t = *mut ::c_void;
pub type os_log_type_t = u8;
pub type os_signpost_id_t = u64;
pub type os_signpost_type_t = u8;
pub type vm_statistics_t = *mut vm_statistics;
pub type vm_statistics_data_t = vm_statistics;
pub type vm_statistics64_t = *mut vm_statistics64;
pub type vm_statistics64_data_t = vm_statistics64;
pub type task_t = ::mach_port_t;
pub type task_inspect_t = ::mach_port_t;
pub type sysdir_search_path_enumeration_state = ::c_uint;
pub type CCStatus = i32;
pub type CCCryptorStatus = i32;
pub type CCRNGStatus = ::CCCryptorStatus;
pub type copyfile_state_t = *mut ::c_void;
pub type copyfile_flags_t = u32;
pub type copyfile_callback_t = ::Option<
extern "C" fn(
::c_int,
::c_int,
copyfile_state_t,
*const ::c_char,
*const ::c_char,
*mut ::c_void,
) -> ::c_int,
>;
pub type attrgroup_t = u32;
pub type vol_capabilities_set_t = [u32; 4];
deprecated_mach! {
pub type mach_timebase_info_data_t = mach_timebase_info;
}
#[cfg_attr(feature = "extra_traits", derive(Debug))]
pub enum timezone {}
impl ::Copy for timezone {}
impl ::Clone for timezone {
fn clone(&self) -> timezone {
*self
}
}
#[cfg_attr(feature = "extra_traits", derive(Debug))]
#[repr(u32)]
pub enum qos_class_t {
QOS_CLASS_USER_INTERACTIVE = 0x21,
QOS_CLASS_USER_INITIATED = 0x19,
QOS_CLASS_DEFAULT = 0x15,
QOS_CLASS_UTILITY = 0x11,
QOS_CLASS_BACKGROUND = 0x09,
QOS_CLASS_UNSPECIFIED = 0x00,
}
impl ::Copy for qos_class_t {}
impl ::Clone for qos_class_t {
fn clone(&self) -> qos_class_t {
*self
}
}
#[cfg_attr(feature = "extra_traits", derive(Debug))]
#[repr(u32)]
pub enum sysdir_search_path_directory_t {
SYSDIR_DIRECTORY_APPLICATION = 1,
SYSDIR_DIRECTORY_DEMO_APPLICATION = 2,
SYSDIR_DIRECTORY_DEVELOPER_APPLICATION = 3,
SYSDIR_DIRECTORY_ADMIN_APPLICATION = 4,
SYSDIR_DIRECTORY_LIBRARY = 5,
SYSDIR_DIRECTORY_DEVELOPER = 6,
SYSDIR_DIRECTORY_USER = 7,
SYSDIR_DIRECTORY_DOCUMENTATION = 8,
SYSDIR_DIRECTORY_DOCUMENT = 9,
SYSDIR_DIRECTORY_CORESERVICE = 10,
SYSDIR_DIRECTORY_AUTOSAVED_INFORMATION = 11,
SYSDIR_DIRECTORY_DESKTOP = 12,
SYSDIR_DIRECTORY_CACHES = 13,
SYSDIR_DIRECTORY_APPLICATION_SUPPORT = 14,
SYSDIR_DIRECTORY_DOWNLOADS = 15,
SYSDIR_DIRECTORY_INPUT_METHODS = 16,
SYSDIR_DIRECTORY_MOVIES = 17,
SYSDIR_DIRECTORY_MUSIC = 18,
SYSDIR_DIRECTORY_PICTURES = 19,
SYSDIR_DIRECTORY_PRINTER_DESCRIPTION = 20,
SYSDIR_DIRECTORY_SHARED_PUBLIC = 21,
SYSDIR_DIRECTORY_PREFERENCE_PANES = 22,
SYSDIR_DIRECTORY_ALL_APPLICATIONS = 100,
SYSDIR_DIRECTORY_ALL_LIBRARIES = 101,
}
impl ::Copy for sysdir_search_path_directory_t {}
impl ::Clone for sysdir_search_path_directory_t {
fn clone(&self) -> sysdir_search_path_directory_t {
*self
}
}
#[cfg_attr(feature = "extra_traits", derive(Debug))]
#[repr(u32)]
pub enum sysdir_search_path_domain_mask_t {
SYSDIR_DOMAIN_MASK_USER = (1 << 0),
SYSDIR_DOMAIN_MASK_LOCAL = (1 << 1),
SYSDIR_DOMAIN_MASK_NETWORK = (1 << 2),
SYSDIR_DOMAIN_MASK_SYSTEM = (1 << 3),
SYSDIR_DOMAIN_MASK_ALL = 0x0ffff,
}
impl ::Copy for sysdir_search_path_domain_mask_t {}
impl ::Clone for sysdir_search_path_domain_mask_t {
fn clone(&self) -> sysdir_search_path_domain_mask_t {
*self
}
}
s! {
pub struct ip_mreq {
pub imr_multiaddr: in_addr,
pub imr_interface: in_addr,
}
pub struct ip_mreqn {
pub imr_multiaddr: in_addr,
pub imr_address: in_addr,
pub imr_ifindex: ::c_int,
}
pub struct ip_mreq_source {
pub imr_multiaddr: in_addr,
pub imr_sourceaddr: in_addr,
pub imr_interface: in_addr,
}
pub struct aiocb {
pub aio_fildes: ::c_int,
pub aio_offset: ::off_t,
pub aio_buf: *mut ::c_void,
pub aio_nbytes: ::size_t,
pub aio_reqprio: ::c_int,
pub aio_sigevent: sigevent,
pub aio_lio_opcode: ::c_int
}
pub struct glob_t {
pub gl_pathc: ::size_t,
__unused1: ::c_int,
pub gl_offs: ::size_t,
__unused2: ::c_int,
pub gl_pathv: *mut *mut ::c_char,
__unused3: *mut ::c_void,
__unused4: *mut ::c_void,
__unused5: *mut ::c_void,
__unused6: *mut ::c_void,
__unused7: *mut ::c_void,
__unused8: *mut ::c_void,
}
pub struct addrinfo {
pub ai_flags: ::c_int,
pub ai_family: ::c_int,
pub ai_socktype: ::c_int,
pub ai_protocol: ::c_int,
pub ai_addrlen: ::socklen_t,
pub ai_canonname: *mut ::c_char,
pub ai_addr: *mut ::sockaddr,
pub ai_next: *mut addrinfo,
}
#[deprecated(
since = "0.2.55",
note = "Use the `mach2` crate instead",
)]
pub struct mach_timebase_info {
pub numer: u32,
pub denom: u32,
}
pub struct stat {
pub st_dev: dev_t,
pub st_mode: mode_t,
pub st_nlink: nlink_t,
pub st_ino: ino_t,
pub st_uid: ::uid_t,
pub st_gid: ::gid_t,
pub st_rdev: dev_t,
pub st_atime: time_t,
pub st_atime_nsec: c_long,
pub st_mtime: time_t,
pub st_mtime_nsec: c_long,
pub st_ctime: time_t,
pub st_ctime_nsec: c_long,
pub st_birthtime: time_t,
pub st_birthtime_nsec: c_long,
pub st_size: ::off_t,
pub st_blocks: ::blkcnt_t,
pub st_blksize: blksize_t,
pub st_flags: u32,
pub st_gen: u32,
pub st_lspare: i32,
pub st_qspare: [i64; 2],
}
pub struct pthread_mutexattr_t {
__sig: ::c_long,
__opaque: [u8; 8],
}
pub struct pthread_condattr_t {
__sig: ::c_long,
__opaque: [u8; __PTHREAD_CONDATTR_SIZE__],
}
pub struct pthread_rwlockattr_t {
__sig: ::c_long,
__opaque: [u8; __PTHREAD_RWLOCKATTR_SIZE__],
}
pub struct siginfo_t {
pub si_signo: ::c_int,
pub si_errno: ::c_int,
pub si_code: ::c_int,
pub si_pid: ::pid_t,
pub si_uid: ::uid_t,
pub si_status: ::c_int,
pub si_addr: *mut ::c_void,
//Requires it to be union for tests
//pub si_value: ::sigval,
_pad: [usize; 9],
}
pub struct sigaction {
// FIXME: this field is actually a union
pub sa_sigaction: ::sighandler_t,
pub sa_mask: sigset_t,
pub sa_flags: ::c_int,
}
pub struct stack_t {
pub ss_sp: *mut ::c_void,
pub ss_size: ::size_t,
pub ss_flags: ::c_int,
}
pub struct fstore_t {
pub fst_flags: ::c_uint,
pub fst_posmode: ::c_int,
pub fst_offset: ::off_t,
pub fst_length: ::off_t,
pub fst_bytesalloc: ::off_t,
}
pub struct fpunchhole_t {
pub fp_flags: ::c_uint, /* unused */
pub reserved: ::c_uint, /* (to maintain 8-byte alignment) */
pub fp_offset: ::off_t, /* IN: start of the region */
pub fp_length: ::off_t, /* IN: size of the region */
}
pub struct ftrimactivefile_t {
pub fta_offset: ::off_t,
pub fta_length: ::off_t,
}
pub struct fspecread_t {
pub fsr_flags: ::c_uint,
pub reserved: ::c_uint,
pub fsr_offset: ::off_t,
pub fsr_length: ::off_t,
}
pub struct radvisory {
pub ra_offset: ::off_t,
pub ra_count: ::c_int,
}
pub struct statvfs {
pub f_bsize: ::c_ulong,
pub f_frsize: ::c_ulong,
pub f_blocks: ::fsblkcnt_t,
pub f_bfree: ::fsblkcnt_t,
pub f_bavail: ::fsblkcnt_t,
pub f_files: ::fsfilcnt_t,
pub f_ffree: ::fsfilcnt_t,
pub f_favail: ::fsfilcnt_t,
pub f_fsid: ::c_ulong,
pub f_flag: ::c_ulong,
pub f_namemax: ::c_ulong,
}
pub struct Dl_info {
pub dli_fname: *const ::c_char,
pub dli_fbase: *mut ::c_void,
pub dli_sname: *const ::c_char,
pub dli_saddr: *mut ::c_void,
}
pub struct sockaddr_in {
pub sin_len: u8,
pub sin_family: ::sa_family_t,
pub sin_port: ::in_port_t,
pub sin_addr: ::in_addr,
pub sin_zero: [::c_char; 8],
}
pub struct kevent64_s {
pub ident: u64,
pub filter: i16,
pub flags: u16,
pub fflags: u32,
pub data: i64,
pub udata: u64,
pub ext: [u64; 2],
}
pub struct dqblk {
pub dqb_bhardlimit: u64,
pub dqb_bsoftlimit: u64,
pub dqb_curbytes: u64,
pub dqb_ihardlimit: u32,
pub dqb_isoftlimit: u32,
pub dqb_curinodes: u32,
pub dqb_btime: u32,
pub dqb_itime: u32,
pub dqb_id: u32,
pub dqb_spare: [u32; 4],
}
pub struct if_msghdr {
pub ifm_msglen: ::c_ushort,
pub ifm_version: ::c_uchar,
pub ifm_type: ::c_uchar,
pub ifm_addrs: ::c_int,
pub ifm_flags: ::c_int,
pub ifm_index: ::c_ushort,
pub ifm_data: if_data,
}
pub struct ifa_msghdr {
pub ifam_msglen: ::c_ushort,
pub ifam_version: ::c_uchar,
pub ifam_type: ::c_uchar,
pub ifam_addrs: ::c_int,
pub ifam_flags: ::c_int,
pub ifam_index: ::c_ushort,
pub ifam_metric: ::c_int,
}
pub struct ifma_msghdr {
pub ifmam_msglen: ::c_ushort,
pub ifmam_version: ::c_uchar,
pub ifmam_type: ::c_uchar,
pub ifmam_addrs: ::c_int,
pub ifmam_flags: ::c_int,
pub ifmam_index: ::c_ushort,
}
pub struct ifma_msghdr2 {
pub ifmam_msglen: ::c_ushort,
pub ifmam_version: ::c_uchar,
pub ifmam_type: ::c_uchar,
pub ifmam_addrs: ::c_int,
pub ifmam_flags: ::c_int,
pub ifmam_index: ::c_ushort,
pub ifmam_refcount: i32,
}
pub struct rt_metrics {
pub rmx_locks: u32,
pub rmx_mtu: u32,
pub rmx_hopcount: u32,
pub rmx_expire: i32,
pub rmx_recvpipe: u32,
pub rmx_sendpipe: u32,
pub rmx_ssthresh: u32,
pub rmx_rtt: u32,
pub rmx_rttvar: u32,
pub rmx_pksent: u32,
/// This field does not exist anymore, the u32 is now part of a resized
/// `rmx_filler` array.
pub rmx_state: u32,
pub rmx_filler: [u32; 3],
}
pub struct rt_msghdr {
pub rtm_msglen: ::c_ushort,
pub rtm_version: ::c_uchar,
pub rtm_type: ::c_uchar,
pub rtm_index: ::c_ushort,
pub rtm_flags: ::c_int,
pub rtm_addrs: ::c_int,
pub rtm_pid: ::pid_t,
pub rtm_seq: ::c_int,
pub rtm_errno: ::c_int,
pub rtm_use: ::c_int,
pub rtm_inits: u32,
pub rtm_rmx: rt_metrics,
}
pub struct rt_msghdr2 {
pub rtm_msglen: ::c_ushort,
pub rtm_version: ::c_uchar,
pub rtm_type: ::c_uchar,
pub rtm_index: ::c_ushort,
pub rtm_flags: ::c_int,
pub rtm_addrs: ::c_int,
pub rtm_refcnt: i32,
pub rtm_parentflags: ::c_int,
pub rtm_reserved: ::c_int,
pub rtm_use: ::c_int,
pub rtm_inits: u32,
pub rtm_rmx: rt_metrics,
}
pub struct termios {
pub c_iflag: ::tcflag_t,
pub c_oflag: ::tcflag_t,
pub c_cflag: ::tcflag_t,
pub c_lflag: ::tcflag_t,
pub c_cc: [::cc_t; ::NCCS],
pub c_ispeed: ::speed_t,
pub c_ospeed: ::speed_t,
}
pub struct flock {
pub l_start: ::off_t,
pub l_len: ::off_t,
pub l_pid: ::pid_t,
pub l_type: ::c_short,
pub l_whence: ::c_short,
}
pub struct sf_hdtr {
pub headers: *mut ::iovec,
pub hdr_cnt: ::c_int,
pub trailers: *mut ::iovec,
pub trl_cnt: ::c_int,
}
pub struct lconv {
pub decimal_point: *mut ::c_char,
pub thousands_sep: *mut ::c_char,
pub grouping: *mut ::c_char,
pub int_curr_symbol: *mut ::c_char,
pub currency_symbol: *mut ::c_char,
pub mon_decimal_point: *mut ::c_char,
pub mon_thousands_sep: *mut ::c_char,
pub mon_grouping: *mut ::c_char,
pub positive_sign: *mut ::c_char,
pub negative_sign: *mut ::c_char,
pub int_frac_digits: ::c_char,
pub frac_digits: ::c_char,
pub p_cs_precedes: ::c_char,
pub p_sep_by_space: ::c_char,
pub n_cs_precedes: ::c_char,
pub n_sep_by_space: ::c_char,
pub p_sign_posn: ::c_char,
pub n_sign_posn: ::c_char,
pub int_p_cs_precedes: ::c_char,
pub int_n_cs_precedes: ::c_char,
pub int_p_sep_by_space: ::c_char,
pub int_n_sep_by_space: ::c_char,
pub int_p_sign_posn: ::c_char,
pub int_n_sign_posn: ::c_char,
}
pub struct proc_taskinfo {
pub pti_virtual_size: u64,
pub pti_resident_size: u64,
pub pti_total_user: u64,
pub pti_total_system: u64,
pub pti_threads_user: u64,
pub pti_threads_system: u64,
pub pti_policy: i32,
pub pti_faults: i32,
pub pti_pageins: i32,
pub pti_cow_faults: i32,
pub pti_messages_sent: i32,
pub pti_messages_received: i32,
pub pti_syscalls_mach: i32,
pub pti_syscalls_unix: i32,
pub pti_csw: i32,
pub pti_threadnum: i32,
pub pti_numrunning: i32,
pub pti_priority: i32,
}
pub struct proc_bsdinfo {
pub pbi_flags: u32,
pub pbi_status: u32,
pub pbi_xstatus: u32,
pub pbi_pid: u32,
pub pbi_ppid: u32,
pub pbi_uid: ::uid_t,
pub pbi_gid: ::gid_t,
pub pbi_ruid: ::uid_t,
pub pbi_rgid: ::gid_t,
pub pbi_svuid: ::uid_t,
pub pbi_svgid: ::gid_t,
pub rfu_1: u32,
pub pbi_comm: [::c_char; MAXCOMLEN],
pub pbi_name: [::c_char; 32], // MAXCOMLEN * 2, but macro isn't happy...
pub pbi_nfiles: u32,
pub pbi_pgid: u32,
pub pbi_pjobc: u32,
pub e_tdev: u32,
pub e_tpgid: u32,
pub pbi_nice: i32,
pub pbi_start_tvsec: u64,
pub pbi_start_tvusec: u64,
}
pub struct proc_taskallinfo {
pub pbsd: proc_bsdinfo,
pub ptinfo: proc_taskinfo,
}
pub struct xsw_usage {
pub xsu_total: u64,
pub xsu_avail: u64,
pub xsu_used: u64,
pub xsu_pagesize: u32,
pub xsu_encrypted: ::boolean_t,
}
pub struct xucred {
pub cr_version: ::c_uint,
pub cr_uid: ::uid_t,
pub cr_ngroups: ::c_short,
pub cr_groups: [::gid_t;16]
}
#[deprecated(
since = "0.2.55",
note = "Use the `mach2` crate instead",
)]
pub struct mach_header {
pub magic: u32,
pub cputype: cpu_type_t,
pub cpusubtype: cpu_subtype_t,
pub filetype: u32,
pub ncmds: u32,
pub sizeofcmds: u32,
pub flags: u32,
}
#[deprecated(
since = "0.2.55",
note = "Use the `mach2` crate instead",
)]
pub struct mach_header_64 {
pub magic: u32,
pub cputype: cpu_type_t,
pub cpusubtype: cpu_subtype_t,
pub filetype: u32,
pub ncmds: u32,
pub sizeofcmds: u32,
pub flags: u32,
pub reserved: u32,
}
pub struct segment_command {
pub cmd: u32,
pub cmdsize: u32,
pub segname: [::c_char; 16],
pub vmaddr: u32,
pub vmsize: u32,
pub fileoff: u32,
pub filesize: u32,
pub maxprot: vm_prot_t,
pub initprot: vm_prot_t,
pub nsects: u32,
pub flags: u32,
}
pub struct segment_command_64 {
pub cmd: u32,
pub cmdsize: u32,
pub segname: [::c_char; 16],
pub vmaddr: u64,
pub vmsize: u64,
pub fileoff: u64,
pub filesize: u64,
pub maxprot: vm_prot_t,
pub initprot: vm_prot_t,
pub nsects: u32,
pub flags: u32,
}
pub struct load_command {
pub cmd: u32,
pub cmdsize: u32,
}
pub struct sockaddr_dl {
pub sdl_len: ::c_uchar,
pub sdl_family: ::c_uchar,
pub sdl_index: ::c_ushort,
pub sdl_type: ::c_uchar,
pub sdl_nlen: ::c_uchar,
pub sdl_alen: ::c_uchar,
pub sdl_slen: ::c_uchar,
pub sdl_data: [::c_char; 12],
}
pub struct sockaddr_inarp {
pub sin_len: ::c_uchar,
pub sin_family: ::c_uchar,
pub sin_port: ::c_ushort,
pub sin_addr: ::in_addr,
pub sin_srcaddr: ::in_addr,
pub sin_tos: ::c_ushort,
pub sin_other: ::c_ushort,
}
pub struct sockaddr_ctl {
pub sc_len: ::c_uchar,
pub sc_family: ::c_uchar,
pub ss_sysaddr: u16,
pub sc_id: u32,
pub sc_unit: u32,
pub sc_reserved: [u32; 5],
}
pub struct in_pktinfo {
pub ipi_ifindex: ::c_uint,
pub ipi_spec_dst: ::in_addr,
pub ipi_addr: ::in_addr,
}
pub struct in6_pktinfo {
pub ipi6_addr: ::in6_addr,
pub ipi6_ifindex: ::c_uint,
}
// sys/ipc.h:
pub struct ipc_perm {
pub uid: ::uid_t,
pub gid: ::gid_t,
pub cuid: ::uid_t,
pub cgid: ::gid_t,
pub mode: ::mode_t,
pub _seq: ::c_ushort,
pub _key: ::key_t,
}
// sys/sem.h
pub struct sembuf {
pub sem_num: ::c_ushort,
pub sem_op: ::c_short,
pub sem_flg: ::c_short,
}
// sys/shm.h
pub struct arphdr {
pub ar_hrd: u16,
pub ar_pro: u16,
pub ar_hln: u8,
pub ar_pln: u8,
pub ar_op: u16,
}
pub struct in_addr {
pub s_addr: ::in_addr_t,
}
// net/ndrv.h
pub struct sockaddr_ndrv {
pub snd_len: ::c_uchar,
pub snd_family: ::c_uchar,
pub snd_name: [::c_uchar; ::IFNAMSIZ],
}
// sys/socket.h
pub struct sa_endpoints_t {
pub sae_srcif: ::c_uint, // optional source interface
pub sae_srcaddr: *const ::sockaddr, // optional source address
pub sae_srcaddrlen: ::socklen_t, // size of source address
pub sae_dstaddr: *const ::sockaddr, // destination address
pub sae_dstaddrlen: ::socklen_t, // size of destination address
}
pub struct timex {
pub modes: ::c_uint,
pub offset: ::c_long,
pub freq: ::c_long,
pub maxerror: ::c_long,
pub esterror: ::c_long,
pub status: ::c_int,
pub constant: ::c_long,
pub precision: ::c_long,
pub tolerance: ::c_long,
pub ppsfreq: ::c_long,
pub jitter: ::c_long,
pub shift: ::c_int,
pub stabil: ::c_long,
pub jitcnt: ::c_long,
pub calcnt: ::c_long,
pub errcnt: ::c_long,
pub stbcnt: ::c_long,
}
pub struct ntptimeval {
pub time: ::timespec,
pub maxerror: ::c_long,
pub esterror: ::c_long,
pub tai: ::c_long,
pub time_state: ::c_int,
}
pub struct thread_standard_policy {
pub no_data: natural_t,
}
pub struct thread_extended_policy {
pub timeshare: boolean_t,
}
pub struct thread_time_constraint_policy {
pub period: u32,
pub computation: u32,
pub constraint: u32,
pub preemptible: boolean_t,
}
pub struct thread_precedence_policy {
pub importance: integer_t,
}
pub struct thread_affinity_policy {
pub affinity_tag: integer_t,
}
pub struct thread_background_policy {
pub priority: integer_t,
}
pub struct thread_latency_qos_policy {
pub thread_latency_qos_tier: thread_latency_qos_t,
}
pub struct thread_throughput_qos_policy {
pub thread_throughput_qos_tier: thread_throughput_qos_t,
}
// malloc/malloc.h
pub struct malloc_statistics_t {
pub blocks_in_use: ::c_uint,
pub size_in_use: ::size_t,
pub max_size_in_use: ::size_t,
pub size_allocated: ::size_t,
}
pub struct mstats {
pub bytes_total: ::size_t,
pub chunks_used: ::size_t,
pub bytes_used: ::size_t,
pub chunks_free: ::size_t,
pub bytes_free: ::size_t,
}
pub struct vm_range_t {
pub address: ::vm_address_t,
pub size: ::vm_size_t,
}
// sched.h
pub struct sched_param {
pub sched_priority: ::c_int,
__opaque: [::c_char; 4],
}
pub struct vinfo_stat {
pub vst_dev: u32,
pub vst_mode: u16,
pub vst_nlink: u16,
pub vst_ino: u64,
pub vst_uid: ::uid_t,
pub vst_gid: ::gid_t,
pub vst_atime: i64,
pub vst_atimensec: i64,
pub vst_mtime: i64,
pub vst_mtimensec: i64,
pub vst_ctime: i64,
pub vst_ctimensec: i64,
pub vst_birthtime: i64,
pub vst_birthtimensec: i64,
pub vst_size: ::off_t,
pub vst_blocks: i64,
pub vst_blksize: i32,
pub vst_flags: u32,
pub vst_gen: u32,
pub vst_rdev: u32,
pub vst_qspare: [i64; 2],
}
pub struct vnode_info {
pub vi_stat: vinfo_stat,
pub vi_type: ::c_int,
pub vi_pad: ::c_int,
pub vi_fsid: ::fsid_t,
}
pub struct vnode_info_path {
pub vip_vi: vnode_info,
// Normally it's `vip_path: [::c_char; MAXPATHLEN]` but because libc supports an old rustc
// version, we go around this limitation like this.
pub vip_path: [[::c_char; 32]; 32],
}
pub struct proc_vnodepathinfo {
pub pvi_cdir: vnode_info_path,
pub pvi_rdir: vnode_info_path,
}
pub struct vm_statistics {
pub free_count: natural_t,
pub active_count: natural_t,
pub inactive_count: natural_t,
pub wire_count: natural_t,
pub zero_fill_count: natural_t,
pub reactivations: natural_t,
pub pageins: natural_t,
pub pageouts: natural_t,
pub faults: natural_t,
pub cow_faults: natural_t,
pub lookups: natural_t,
pub hits: natural_t,
pub purgeable_count: natural_t,
pub purges: natural_t,
pub speculative_count: natural_t,
}
pub struct task_thread_times_info {
pub user_time: time_value_t,
pub system_time: time_value_t,
}
pub struct rusage_info_v0 {
pub ri_uuid: [u8; 16],
pub ri_user_time: u64,
pub ri_system_time: u64,
pub ri_pkg_idle_wkups: u64,
pub ri_interrupt_wkups: u64,
pub ri_pageins: u64,
pub ri_wired_size: u64,
pub ri_resident_size: u64,
pub ri_phys_footprint: u64,
pub ri_proc_start_abstime: u64,
pub ri_proc_exit_abstime: u64,
}
pub struct rusage_info_v1 {
pub ri_uuid: [u8; 16],
pub ri_user_time: u64,
pub ri_system_time: u64,
pub ri_pkg_idle_wkups: u64,
pub ri_interrupt_wkups: u64,
pub ri_pageins: u64,
pub ri_wired_size: u64,
pub ri_resident_size: u64,
pub ri_phys_footprint: u64,
pub ri_proc_start_abstime: u64,
pub ri_proc_exit_abstime: u64,
pub ri_child_user_time: u64,
pub ri_child_system_time: u64,
pub ri_child_pkg_idle_wkups: u64,
pub ri_child_interrupt_wkups: u64,
pub ri_child_pageins: u64,
pub ri_child_elapsed_abstime: u64,
}
pub struct rusage_info_v2 {
pub ri_uuid: [u8; 16],
pub ri_user_time: u64,
pub ri_system_time: u64,
pub ri_pkg_idle_wkups: u64,
pub ri_interrupt_wkups: u64,
pub ri_pageins: u64,
pub ri_wired_size: u64,
pub ri_resident_size: u64,
pub ri_phys_footprint: u64,
pub ri_proc_start_abstime: u64,
pub ri_proc_exit_abstime: u64,
pub ri_child_user_time: u64,
pub ri_child_system_time: u64,
pub ri_child_pkg_idle_wkups: u64,
pub ri_child_interrupt_wkups: u64,
pub ri_child_pageins: u64,
pub ri_child_elapsed_abstime: u64,
pub ri_diskio_bytesread: u64,
pub ri_diskio_byteswritten: u64,
}
pub struct rusage_info_v3 {
pub ri_uuid: [u8; 16],
pub ri_user_time: u64,
pub ri_system_time: u64,
pub ri_pkg_idle_wkups: u64,
pub ri_interrupt_wkups: u64,
pub ri_pageins: u64,
pub ri_wired_size: u64,
pub ri_resident_size: u64,
pub ri_phys_footprint: u64,
pub ri_proc_start_abstime: u64,
pub ri_proc_exit_abstime: u64,
pub ri_child_user_time: u64,
pub ri_child_system_time: u64,
pub ri_child_pkg_idle_wkups: u64,
pub ri_child_interrupt_wkups: u64,
pub ri_child_pageins: u64,
pub ri_child_elapsed_abstime: u64,
pub ri_diskio_bytesread: u64,
pub ri_diskio_byteswritten: u64,
pub ri_cpu_time_qos_default: u64,
pub ri_cpu_time_qos_maintenance: u64,
pub ri_cpu_time_qos_background: u64,
pub ri_cpu_time_qos_utility: u64,
pub ri_cpu_time_qos_legacy: u64,
pub ri_cpu_time_qos_user_initiated: u64,
pub ri_cpu_time_qos_user_interactive: u64,
pub ri_billed_system_time: u64,
pub ri_serviced_system_time: u64,
}
pub struct rusage_info_v4 {
pub ri_uuid: [u8; 16],
pub ri_user_time: u64,
pub ri_system_time: u64,
pub ri_pkg_idle_wkups: u64,
pub ri_interrupt_wkups: u64,
pub ri_pageins: u64,
pub ri_wired_size: u64,
pub ri_resident_size: u64,
pub ri_phys_footprint: u64,
pub ri_proc_start_abstime: u64,
pub ri_proc_exit_abstime: u64,
pub ri_child_user_time: u64,
pub ri_child_system_time: u64,
pub ri_child_pkg_idle_wkups: u64,
pub ri_child_interrupt_wkups: u64,
pub ri_child_pageins: u64,
pub ri_child_elapsed_abstime: u64,
pub ri_diskio_bytesread: u64,
pub ri_diskio_byteswritten: u64,
pub ri_cpu_time_qos_default: u64,
pub ri_cpu_time_qos_maintenance: u64,
pub ri_cpu_time_qos_background: u64,
pub ri_cpu_time_qos_utility: u64,
pub ri_cpu_time_qos_legacy: u64,
pub ri_cpu_time_qos_user_initiated: u64,
pub ri_cpu_time_qos_user_interactive: u64,
pub ri_billed_system_time: u64,
pub ri_serviced_system_time: u64,
pub ri_logical_writes: u64,
pub ri_lifetime_max_phys_footprint: u64,
pub ri_instructions: u64,
pub ri_cycles: u64,
pub ri_billed_energy: u64,
pub ri_serviced_energy: u64,
pub ri_interval_max_phys_footprint: u64,
pub ri_runnable_time: u64,
}
pub struct image_offset {
pub uuid: ::uuid_t,
pub offset: u32,
}
pub struct attrlist {
pub bitmapcount: ::c_ushort,
pub reserved: u16,
pub commonattr: attrgroup_t,
pub volattr: attrgroup_t,
pub dirattr: attrgroup_t,
pub fileattr: attrgroup_t,
pub forkattr: attrgroup_t,
}
pub struct attrreference_t {
pub attr_dataoffset: i32,
pub attr_length: u32,
}
pub struct vol_capabilities_attr_t {
pub capabilities: vol_capabilities_set_t,
pub valid: vol_capabilities_set_t,
}
pub struct attribute_set_t {
pub commonattr: attrgroup_t,
pub volattr: attrgroup_t,
pub dirattr: attrgroup_t,
pub fileattr: attrgroup_t,
pub forkattr: attrgroup_t,
}
pub struct vol_attributes_attr_t {
pub validattr: attribute_set_t,
pub nativeattr: attribute_set_t,
}
#[cfg_attr(libc_packedN, repr(packed(4)))]
pub struct ifconf {
pub ifc_len: ::c_int,
#[cfg(libc_union)]
pub ifc_ifcu: __c_anonymous_ifc_ifcu,
#[cfg(not(libc_union))]
pub ifc_ifcu: *mut ifreq,
}
#[cfg_attr(libc_align, repr(align(8)))]
pub struct tcp_connection_info {
pub tcpi_state: u8,
pub tcpi_snd_wscale: u8,
pub tcpi_rcv_wscale: u8,
__pad1: u8,
pub tcpi_options: u32,
pub tcpi_flags: u32,
pub tcpi_rto: u32,
pub tcpi_maxseg: u32,
pub tcpi_snd_ssthresh: u32,
pub tcpi_snd_cwnd: u32,
pub tcpi_snd_wnd: u32,
pub tcpi_snd_sbbytes: u32,
pub tcpi_rcv_wnd: u32,
pub tcpi_rttcur: u32,
pub tcpi_srtt: u32,
pub tcpi_rttvar: u32,
pub tcpi_tfo_cookie_req: u32,
pub tcpi_tfo_cookie_rcv: u32,
pub tcpi_tfo_syn_loss: u32,
pub tcpi_tfo_syn_data_sent: u32,
pub tcpi_tfo_syn_data_acked: u32,
pub tcpi_tfo_syn_data_rcv: u32,
pub tcpi_tfo_cookie_req_rcv: u32,
pub tcpi_tfo_cookie_sent: u32,
pub tcpi_tfo_cookie_invalid: u32,
pub tcpi_tfo_cookie_wrong: u32,
pub tcpi_tfo_no_cookie_rcv: u32,
pub tcpi_tfo_heuristics_disable: u32,
pub tcpi_tfo_send_blackhole: u32,
pub tcpi_tfo_recv_blackhole: u32,
pub tcpi_tfo_onebyte_proxy: u32,
__pad2: u32,
pub tcpi_txpackets: u64,
pub tcpi_txbytes: u64,
pub tcpi_txretransmitbytes: u64,
pub tcpi_rxpackets: u64,
pub tcpi_rxbytes: u64,
pub tcpi_rxoutoforderbytes: u64,
pub tcpi_rxretransmitpackets: u64,
}
}
s_no_extra_traits! {
#[cfg_attr(libc_packedN, repr(packed(4)))]
pub struct kevent {
pub ident: ::uintptr_t,
pub filter: i16,
pub flags: u16,
pub fflags: u32,
pub data: ::intptr_t,
pub udata: *mut ::c_void,
}
#[cfg_attr(libc_packedN, repr(packed(4)))]
pub struct semid_ds {
// Note the manpage shows different types than the system header.
pub sem_perm: ipc_perm,
pub sem_base: i32,
pub sem_nsems: ::c_ushort,
pub sem_otime: ::time_t,
pub sem_pad1: i32,
pub sem_ctime: ::time_t,
pub sem_pad2: i32,
pub sem_pad3: [i32; 4],
}
#[cfg_attr(libc_packedN, repr(packed(4)))]
pub struct shmid_ds {
pub shm_perm: ipc_perm,
pub shm_segsz: ::size_t,
pub shm_lpid: ::pid_t,
pub shm_cpid: ::pid_t,
pub shm_nattch: ::shmatt_t,
pub shm_atime: ::time_t, // FIXME: 64-bit wrong align => wrong offset
pub shm_dtime: ::time_t, // FIXME: 64-bit wrong align => wrong offset
pub shm_ctime: ::time_t, // FIXME: 64-bit wrong align => wrong offset
// FIXME: 64-bit wrong align => wrong offset:
pub shm_internal: *mut ::c_void,
}
pub struct proc_threadinfo {
pub pth_user_time: u64,
pub pth_system_time: u64,
pub pth_cpu_usage: i32,
pub pth_policy: i32,
pub pth_run_state: i32,
pub pth_flags: i32,
pub pth_sleep_time: i32,
pub pth_curpri: i32,
pub pth_priority: i32,
pub pth_maxpriority: i32,
pub pth_name: [::c_char; MAXTHREADNAMESIZE],
}
pub struct statfs {
pub f_bsize: u32,
pub f_iosize: i32,
pub f_blocks: u64,
pub f_bfree: u64,
pub f_bavail: u64,
pub f_files: u64,
pub f_ffree: u64,
pub f_fsid: ::fsid_t,
pub f_owner: ::uid_t,
pub f_type: u32,
pub f_flags: u32,
pub f_fssubtype: u32,
pub f_fstypename: [::c_char; 16],
pub f_mntonname: [::c_char; 1024],
pub f_mntfromname: [::c_char; 1024],
pub f_flags_ext: u32,
pub f_reserved: [u32; 7],
}
pub struct dirent {
pub d_ino: u64,
pub d_seekoff: u64,
pub d_reclen: u16,
pub d_namlen: u16,
pub d_type: u8,
pub d_name: [::c_char; 1024],
}
pub struct pthread_rwlock_t {
__sig: ::c_long,
__opaque: [u8; __PTHREAD_RWLOCK_SIZE__],
}
pub struct pthread_mutex_t {
__sig: ::c_long,
__opaque: [u8; __PTHREAD_MUTEX_SIZE__],
}
pub struct pthread_cond_t {
__sig: ::c_long,
__opaque: [u8; __PTHREAD_COND_SIZE__],
}
pub struct sockaddr_storage {
pub ss_len: u8,
pub ss_family: ::sa_family_t,
__ss_pad1: [u8; 6],
__ss_align: i64,
__ss_pad2: [u8; 112],
}
pub struct utmpx {
pub ut_user: [::c_char; _UTX_USERSIZE],
pub ut_id: [::c_char; _UTX_IDSIZE],
pub ut_line: [::c_char; _UTX_LINESIZE],
pub ut_pid: ::pid_t,
pub ut_type: ::c_short,
pub ut_tv: ::timeval,
pub ut_host: [::c_char; _UTX_HOSTSIZE],
ut_pad: [u32; 16],
}
pub struct sigevent {
pub sigev_notify: ::c_int,
pub sigev_signo: ::c_int,
pub sigev_value: ::sigval,
__unused1: *mut ::c_void, //actually a function pointer
pub sigev_notify_attributes: *mut ::pthread_attr_t
}
pub struct processor_cpu_load_info {
pub cpu_ticks: [::c_uint; CPU_STATE_MAX as usize],
}
pub struct processor_basic_info {
pub cpu_type: cpu_type_t,
pub cpu_subtype: cpu_subtype_t,
pub running: ::boolean_t,
pub slot_num: ::c_int,
pub is_master: ::boolean_t,
}
pub struct processor_set_basic_info {
pub processor_count: ::c_int,
pub default_policy: ::c_int,
}
pub struct processor_set_load_info {
pub task_count: ::c_int,
pub thread_count: ::c_int,
pub load_average: integer_t,
pub mach_factor: integer_t,
}
pub struct time_value_t {
pub seconds: integer_t,
pub microseconds: integer_t,
}
pub struct thread_basic_info {
pub user_time: time_value_t,
pub system_time: time_value_t,
pub cpu_usage: ::integer_t,
pub policy: ::policy_t,
pub run_state: ::integer_t,
pub flags: ::integer_t,
pub suspend_count: ::integer_t,
pub sleep_time: ::integer_t,
}
pub struct thread_identifier_info {
pub thread_id: u64,
pub thread_handle: u64,
pub dispatch_qaddr: u64,
}
pub struct thread_extended_info {
pub pth_user_time: u64,
pub pth_system_time: u64,
pub pth_cpu_usage: i32,
pub pth_policy: i32,
pub pth_run_state: i32,
pub pth_flags: i32,
pub pth_sleep_time: i32,
pub pth_curpri: i32,
pub pth_priority: i32,
pub pth_maxpriority: i32,
pub pth_name: [::c_char; MAXTHREADNAMESIZE],
}
#[cfg_attr(libc_packedN, repr(packed(4)))]
pub struct if_data64 {
pub ifi_type: ::c_uchar,
pub ifi_typelen: ::c_uchar,
pub ifi_physical: ::c_uchar,
pub ifi_addrlen: ::c_uchar,
pub ifi_hdrlen: ::c_uchar,
pub ifi_recvquota: ::c_uchar,
pub ifi_xmitquota: ::c_uchar,
pub ifi_unused1: ::c_uchar,
pub ifi_mtu: u32,
pub ifi_metric: u32,
pub ifi_baudrate: u64,
pub ifi_ipackets: u64,
pub ifi_ierrors: u64,
pub ifi_opackets: u64,
pub ifi_oerrors: u64,
pub ifi_collisions: u64,
pub ifi_ibytes: u64,
pub ifi_obytes: u64,
pub ifi_imcasts: u64,
pub ifi_omcasts: u64,
pub ifi_iqdrops: u64,
pub ifi_noproto: u64,
pub ifi_recvtiming: u32,
pub ifi_xmittiming: u32,
#[cfg(target_pointer_width = "32")]
pub ifi_lastchange: ::timeval,
#[cfg(not(target_pointer_width = "32"))]
pub ifi_lastchange: timeval32,
}
#[cfg_attr(libc_packedN, repr(packed(4)))]
pub struct if_msghdr2 {
pub ifm_msglen: ::c_ushort,
pub ifm_version: ::c_uchar,
pub ifm_type: ::c_uchar,
pub ifm_addrs: ::c_int,
pub ifm_flags: ::c_int,
pub ifm_index: ::c_ushort,
pub ifm_snd_len: ::c_int,
pub ifm_snd_maxlen: ::c_int,
pub ifm_snd_drops: ::c_int,
pub ifm_timer: ::c_int,
pub ifm_data: if_data64,
}
#[cfg_attr(libc_packedN, repr(packed(8)))]
pub struct vm_statistics64 {
pub free_count: natural_t,
pub active_count: natural_t,
pub inactive_count: natural_t,
pub wire_count: natural_t,
pub zero_fill_count: u64,
pub reactivations: u64,
pub pageins: u64,
pub pageouts: u64,
pub faults: u64,
pub cow_faults: u64,
pub lookups: u64,
pub hits: u64,
pub purges: u64,
pub purgeable_count: natural_t,
pub speculative_count: natural_t,
pub decompressions: u64,
pub compressions: u64,
pub swapins: u64,
pub swapouts: u64,
pub compressor_page_count: natural_t,
pub throttled_count: natural_t,
pub external_page_count: natural_t,
pub internal_page_count: natural_t,
pub total_uncompressed_pages_in_compressor: u64,
}
#[cfg_attr(libc_packedN, repr(packed(4)))]
pub struct mach_task_basic_info {
pub virtual_size: mach_vm_size_t,
pub resident_size: mach_vm_size_t,
pub resident_size_max: mach_vm_size_t,
pub user_time: time_value_t,
pub system_time: time_value_t,
pub policy: ::policy_t,
pub suspend_count: integer_t,
}
#[cfg_attr(libc_packedN, repr(packed(4)))]
pub struct log2phys {
pub l2p_flags: ::c_uint,
pub l2p_contigbytes: ::off_t,
pub l2p_devoffset: ::off_t,
}
pub struct os_unfair_lock_s {
_os_unfair_lock_opaque: u32,
}
#[cfg_attr(libc_packedN, repr(packed(1)))]
pub struct sockaddr_vm {
pub svm_len: ::c_uchar,
pub svm_family: ::sa_family_t,
pub svm_reserved1: ::c_ushort,
pub svm_port: ::c_uint,
pub svm_cid: ::c_uint,
}
pub struct ifdevmtu {
pub ifdm_current: ::c_int,
pub ifdm_min: ::c_int,
pub ifdm_max: ::c_int,
}
#[cfg(libc_union)]
pub union __c_anonymous_ifk_data {
pub ifk_ptr: *mut ::c_void,
pub ifk_value: ::c_int,
}
#[cfg_attr(libc_packedN, repr(packed(4)))]
pub struct ifkpi {
pub ifk_module_id: ::c_uint,
pub ifk_type: ::c_uint,
#[cfg(libc_union)]
pub ifk_data: __c_anonymous_ifk_data,
}
#[cfg(libc_union)]
pub union __c_anonymous_ifr_ifru {
pub ifru_addr: ::sockaddr,
pub ifru_dstaddr: ::sockaddr,
pub ifru_broadaddr: ::sockaddr,
pub ifru_flags: ::c_short,
pub ifru_metrics: ::c_int,
pub ifru_mtu: ::c_int,
pub ifru_phys: ::c_int,
pub ifru_media: ::c_int,
pub ifru_intval: ::c_int,
pub ifru_data: *mut ::c_char,
pub ifru_devmtu: ifdevmtu,
pub ifru_kpi: ifkpi,
pub ifru_wake_flags: u32,
pub ifru_route_refcnt: u32,
pub ifru_cap: [::c_int; 2],
pub ifru_functional_type: u32,
}
pub struct ifreq {
pub ifr_name: [::c_char; ::IFNAMSIZ],
#[cfg(libc_union)]
pub ifr_ifru: __c_anonymous_ifr_ifru,
#[cfg(not(libc_union))]
pub ifr_ifru: ::sockaddr,
}
#[cfg(libc_union)]
pub union __c_anonymous_ifc_ifcu {
pub ifcu_buf: *mut ::c_char,
pub ifcu_req: *mut ifreq,
}
}
impl siginfo_t {
pub unsafe fn si_addr(&self) -> *mut ::c_void {
self.si_addr
}
pub unsafe fn si_value(&self) -> ::sigval {
#[repr(C)]
struct siginfo_timer {
_si_signo: ::c_int,
_si_errno: ::c_int,
_si_code: ::c_int,
_si_pid: ::pid_t,
_si_uid: ::uid_t,
_si_status: ::c_int,
_si_addr: *mut ::c_void,
si_value: ::sigval,
}
(*(self as *const siginfo_t as *const siginfo_timer)).si_value
}
pub unsafe fn si_pid(&self) -> ::pid_t {
self.si_pid
}
pub unsafe fn si_uid(&self) -> ::uid_t {
self.si_uid
}
pub unsafe fn si_status(&self) -> ::c_int {
self.si_status
}
}
cfg_if! {
if #[cfg(libc_union)] {
s_no_extra_traits! {
pub union semun {
pub val: ::c_int,
pub buf: *mut semid_ds,
pub array: *mut ::c_ushort,
}
}
cfg_if! {
if #[cfg(feature = "extra_traits")] {
impl PartialEq for semun {
fn eq(&self, other: &semun) -> bool {
unsafe { self.val == other.val }
}
}
impl Eq for semun {}
impl ::fmt::Debug for semun {
fn fmt(&self, f: &mut ::fmt::Formatter)
-> ::fmt::Result {
f.debug_struct("semun")
.field("val", unsafe { &self.val })
.finish()
}
}
impl ::hash::Hash for semun {
fn hash<H: ::hash::Hasher>(&self, state: &mut H) {
unsafe { self.val.hash(state) };
}
}
}
}
}
}
cfg_if! {
if #[cfg(feature = "extra_traits")] {
impl PartialEq for kevent {
fn eq(&self, other: &kevent) -> bool {
self.ident == other.ident
&& self.filter == other.filter
&& self.flags == other.flags
&& self.fflags == other.fflags
&& self.data == other.data
&& self.udata == other.udata
}
}
impl Eq for kevent {}
impl ::fmt::Debug for kevent {
fn fmt(&self, f: &mut ::fmt::Formatter) -> ::fmt::Result {
let ident = self.ident;
let filter = self.filter;
let flags = self.flags;
let fflags = self.fflags;
let data = self.data;
let udata = self.udata;
f.debug_struct("kevent")
.field("ident", &ident)
.field("filter", &filter)
.field("flags", &flags)
.field("fflags", &fflags)
.field("data", &data)
.field("udata", &udata)
.finish()
}
}
impl ::hash::Hash for kevent {
fn hash<H: ::hash::Hasher>(&self, state: &mut H) {
let ident = self.ident;
let filter = self.filter;
let flags = self.flags;
let fflags = self.fflags;
let data = self.data;
let udata = self.udata;
ident.hash(state);
filter.hash(state);
flags.hash(state);
fflags.hash(state);
data.hash(state);
udata.hash(state);
}
}
impl PartialEq for semid_ds {
fn eq(&self, other: &semid_ds) -> bool {
let sem_perm = self.sem_perm;
let sem_pad3 = self.sem_pad3;
let other_sem_perm = other.sem_perm;
let other_sem_pad3 = other.sem_pad3;
sem_perm == other_sem_perm
&& self.sem_base == other.sem_base
&& self.sem_nsems == other.sem_nsems
&& self.sem_otime == other.sem_otime
&& self.sem_pad1 == other.sem_pad1
&& self.sem_ctime == other.sem_ctime
&& self.sem_pad2 == other.sem_pad2
&& sem_pad3 == other_sem_pad3
}
}
impl Eq for semid_ds {}
impl ::fmt::Debug for semid_ds {
fn fmt(&self, f: &mut ::fmt::Formatter) -> ::fmt::Result {
let sem_perm = self.sem_perm;
let sem_base = self.sem_base;
let sem_nsems = self.sem_nsems;
let sem_otime = self.sem_otime;
let sem_pad1 = self.sem_pad1;
let sem_ctime = self.sem_ctime;
let sem_pad2 = self.sem_pad2;
let sem_pad3 = self.sem_pad3;
f.debug_struct("semid_ds")
.field("sem_perm", &sem_perm)
.field("sem_base", &sem_base)
.field("sem_nsems", &sem_nsems)
.field("sem_otime", &sem_otime)
.field("sem_pad1", &sem_pad1)
.field("sem_ctime", &sem_ctime)
.field("sem_pad2", &sem_pad2)
.field("sem_pad3", &sem_pad3)
.finish()
}
}
impl ::hash::Hash for semid_ds {
fn hash<H: ::hash::Hasher>(&self, state: &mut H) {
let sem_perm = self.sem_perm;
let sem_base = self.sem_base;
let sem_nsems = self.sem_nsems;
let sem_otime = self.sem_otime;
let sem_pad1 = self.sem_pad1;
let sem_ctime = self.sem_ctime;
let sem_pad2 = self.sem_pad2;
let sem_pad3 = self.sem_pad3;
sem_perm.hash(state);
sem_base.hash(state);
sem_nsems.hash(state);
sem_otime.hash(state);
sem_pad1.hash(state);
sem_ctime.hash(state);
sem_pad2.hash(state);
sem_pad3.hash(state);
}
}
impl PartialEq for shmid_ds {
fn eq(&self, other: &shmid_ds) -> bool {
let shm_perm = self.shm_perm;
let other_shm_perm = other.shm_perm;
shm_perm == other_shm_perm
&& self.shm_segsz == other.shm_segsz
&& self.shm_lpid == other.shm_lpid
&& self.shm_cpid == other.shm_cpid
&& self.shm_nattch == other.shm_nattch
&& self.shm_atime == other.shm_atime
&& self.shm_dtime == other.shm_dtime
&& self.shm_ctime == other.shm_ctime
&& self.shm_internal == other.shm_internal
}
}
impl Eq for shmid_ds {}
impl ::fmt::Debug for shmid_ds {
fn fmt(&self, f: &mut ::fmt::Formatter) -> ::fmt::Result {
let shm_perm = self.shm_perm;
let shm_segsz = self.shm_segsz;
let shm_lpid = self.shm_lpid;
let shm_cpid = self.shm_cpid;
let shm_nattch = self.shm_nattch;
let shm_atime = self.shm_atime;
let shm_dtime = self.shm_dtime;
let shm_ctime = self.shm_ctime;
let shm_internal = self.shm_internal;
f.debug_struct("shmid_ds")
.field("shm_perm", &shm_perm)
.field("shm_segsz", &shm_segsz)
.field("shm_lpid", &shm_lpid)
.field("shm_cpid", &shm_cpid)
.field("shm_nattch", &shm_nattch)
.field("shm_atime", &shm_atime)
.field("shm_dtime", &shm_dtime)
.field("shm_ctime", &shm_ctime)
.field("shm_internal", &shm_internal)
.finish()
}
}
impl ::hash::Hash for shmid_ds {
fn hash<H: ::hash::Hasher>(&self, state: &mut H) {
let shm_perm = self.shm_perm;
let shm_segsz = self.shm_segsz;
let shm_lpid = self.shm_lpid;
let shm_cpid = self.shm_cpid;
let shm_nattch = self.shm_nattch;
let shm_atime = self.shm_atime;
let shm_dtime = self.shm_dtime;
let shm_ctime = self.shm_ctime;
let shm_internal = self.shm_internal;
shm_perm.hash(state);
shm_segsz.hash(state);
shm_lpid.hash(state);
shm_cpid.hash(state);
shm_nattch.hash(state);
shm_atime.hash(state);
shm_dtime.hash(state);
shm_ctime.hash(state);
shm_internal.hash(state);
}
}
impl PartialEq for proc_threadinfo {
fn eq(&self, other: &proc_threadinfo) -> bool {
self.pth_user_time == other.pth_user_time
&& self.pth_system_time == other.pth_system_time
&& self.pth_cpu_usage == other.pth_cpu_usage
&& self.pth_policy == other.pth_policy
&& self.pth_run_state == other.pth_run_state
&& self.pth_flags == other.pth_flags
&& self.pth_sleep_time == other.pth_sleep_time
&& self.pth_curpri == other.pth_curpri
&& self.pth_priority == other.pth_priority
&& self.pth_maxpriority == other.pth_maxpriority
&& self.pth_name
.iter()
.zip(other.pth_name.iter())
.all(|(a,b)| a == b)
}
}
impl Eq for proc_threadinfo {}
impl ::fmt::Debug for proc_threadinfo {
fn fmt(&self, f: &mut ::fmt::Formatter) -> ::fmt::Result {
f.debug_struct("proc_threadinfo")
.field("pth_user_time", &self.pth_user_time)
.field("pth_system_time", &self.pth_system_time)
.field("pth_cpu_usage", &self.pth_cpu_usage)
.field("pth_policy", &self.pth_policy)
.field("pth_run_state", &self.pth_run_state)
.field("pth_flags", &self.pth_flags)
.field("pth_sleep_time", &self.pth_sleep_time)
.field("pth_curpri", &self.pth_curpri)
.field("pth_priority", &self.pth_priority)
.field("pth_maxpriority", &self.pth_maxpriority)
// FIXME: .field("pth_name", &self.pth_name)
.finish()
}
}
impl ::hash::Hash for proc_threadinfo {
fn hash<H: ::hash::Hasher>(&self, state: &mut H) {
self.pth_user_time.hash(state);
self.pth_system_time.hash(state);
self.pth_cpu_usage.hash(state);
self.pth_policy.hash(state);
self.pth_run_state.hash(state);
self.pth_flags.hash(state);
self.pth_sleep_time.hash(state);
self.pth_curpri.hash(state);
self.pth_priority.hash(state);
self.pth_maxpriority.hash(state);
self.pth_name.hash(state);
}
}
impl PartialEq for statfs {
fn eq(&self, other: &statfs) -> bool {
self.f_bsize == other.f_bsize
&& self.f_iosize == other.f_iosize
&& self.f_blocks == other.f_blocks
&& self.f_bfree == other.f_bfree
&& self.f_bavail == other.f_bavail
&& self.f_files == other.f_files
&& self.f_ffree == other.f_ffree
&& self.f_fsid == other.f_fsid
&& self.f_owner == other.f_owner
&& self.f_flags == other.f_flags
&& self.f_fssubtype == other.f_fssubtype
&& self.f_fstypename == other.f_fstypename
&& self.f_type == other.f_type
&& self
.f_mntonname
.iter()
.zip(other.f_mntonname.iter())
.all(|(a,b)| a == b)
&& self
.f_mntfromname
.iter()
.zip(other.f_mntfromname.iter())
.all(|(a,b)| a == b)
&& self.f_reserved == other.f_reserved
}
}
impl Eq for statfs {}
impl ::fmt::Debug for statfs {
fn fmt(&self, f: &mut ::fmt::Formatter) -> ::fmt::Result {
f.debug_struct("statfs")
.field("f_bsize", &self.f_bsize)
.field("f_iosize", &self.f_iosize)
.field("f_blocks", &self.f_blocks)
.field("f_bfree", &self.f_bfree)
.field("f_bavail", &self.f_bavail)
.field("f_files", &self.f_files)
.field("f_ffree", &self.f_ffree)
.field("f_fsid", &self.f_fsid)
.field("f_owner", &self.f_owner)
.field("f_flags", &self.f_flags)
.field("f_fssubtype", &self.f_fssubtype)
.field("f_fstypename", &self.f_fstypename)
.field("f_type", &self.f_type)
// FIXME: .field("f_mntonname", &self.f_mntonname)
// FIXME: .field("f_mntfromname", &self.f_mntfromname)
.field("f_reserved", &self.f_reserved)
.finish()
}
}
impl ::hash::Hash for statfs {
fn hash<H: ::hash::Hasher>(&self, state: &mut H) {
self.f_bsize.hash(state);
self.f_iosize.hash(state);
self.f_blocks.hash(state);
self.f_bfree.hash(state);
self.f_bavail.hash(state);
self.f_files.hash(state);
self.f_ffree.hash(state);
self.f_fsid.hash(state);
self.f_owner.hash(state);
self.f_flags.hash(state);
self.f_fssubtype.hash(state);
self.f_fstypename.hash(state);
self.f_type.hash(state);
self.f_mntonname.hash(state);
self.f_mntfromname.hash(state);
self.f_reserved.hash(state);
}
}
impl PartialEq for dirent {
fn eq(&self, other: &dirent) -> bool {
self.d_ino == other.d_ino
&& self.d_seekoff == other.d_seekoff
&& self.d_reclen == other.d_reclen
&& self.d_namlen == other.d_namlen
&& self.d_type == other.d_type
&& self
.d_name
.iter()
.zip(other.d_name.iter())
.all(|(a,b)| a == b)
}
}
impl Eq for dirent {}
impl ::fmt::Debug for dirent {
fn fmt(&self, f: &mut ::fmt::Formatter) -> ::fmt::Result {
f.debug_struct("dirent")
.field("d_ino", &self.d_ino)
.field("d_seekoff", &self.d_seekoff)
.field("d_reclen", &self.d_reclen)
.field("d_namlen", &self.d_namlen)
.field("d_type", &self.d_type)
// FIXME: .field("d_name", &self.d_name)
.finish()
}
}
impl ::hash::Hash for dirent {
fn hash<H: ::hash::Hasher>(&self, state: &mut H) {
self.d_ino.hash(state);
self.d_seekoff.hash(state);
self.d_reclen.hash(state);
self.d_namlen.hash(state);
self.d_type.hash(state);
self.d_name.hash(state);
}
}
impl PartialEq for pthread_rwlock_t {
fn eq(&self, other: &pthread_rwlock_t) -> bool {
self.__sig == other.__sig
&& self.
__opaque
.iter()
.zip(other.__opaque.iter())
.all(|(a,b)| a == b)
}
}
impl Eq for pthread_rwlock_t {}
impl ::fmt::Debug for pthread_rwlock_t {
fn fmt(&self, f: &mut ::fmt::Formatter) -> ::fmt::Result {
f.debug_struct("pthread_rwlock_t")
.field("__sig", &self.__sig)
// FIXME: .field("__opaque", &self.__opaque)
.finish()
}
}
impl ::hash::Hash for pthread_rwlock_t {
fn hash<H: ::hash::Hasher>(&self, state: &mut H) {
self.__sig.hash(state);
self.__opaque.hash(state);
}
}
impl PartialEq for pthread_mutex_t {
fn eq(&self, other: &pthread_mutex_t) -> bool {
self.__sig == other.__sig
&& self.
__opaque
.iter()
.zip(other.__opaque.iter())
.all(|(a,b)| a == b)
}
}
impl Eq for pthread_mutex_t {}
impl ::fmt::Debug for pthread_mutex_t {
fn fmt(&self, f: &mut ::fmt::Formatter) -> ::fmt::Result {
f.debug_struct("pthread_mutex_t")
.field("__sig", &self.__sig)
// FIXME: .field("__opaque", &self.__opaque)
.finish()
}
}
impl ::hash::Hash for pthread_mutex_t {
fn hash<H: ::hash::Hasher>(&self, state: &mut H) {
self.__sig.hash(state);
self.__opaque.hash(state);
}
}
impl PartialEq for pthread_cond_t {
fn eq(&self, other: &pthread_cond_t) -> bool {
self.__sig == other.__sig
&& self.
__opaque
.iter()
.zip(other.__opaque.iter())
.all(|(a,b)| a == b)
}
}
impl Eq for pthread_cond_t {}
impl ::fmt::Debug for pthread_cond_t {
fn fmt(&self, f: &mut ::fmt::Formatter) -> ::fmt::Result {
f.debug_struct("pthread_cond_t")
.field("__sig", &self.__sig)
// FIXME: .field("__opaque", &self.__opaque)
.finish()
}
}
impl ::hash::Hash for pthread_cond_t {
fn hash<H: ::hash::Hasher>(&self, state: &mut H) {
self.__sig.hash(state);
self.__opaque.hash(state);
}
}
impl PartialEq for sockaddr_storage {
fn eq(&self, other: &sockaddr_storage) -> bool {
self.ss_len == other.ss_len
&& self.ss_family == other.ss_family
&& self
.__ss_pad1
.iter()
.zip(other.__ss_pad1.iter())
.all(|(a, b)| a == b)
&& self.__ss_align == other.__ss_align
&& self
.__ss_pad2
.iter()
.zip(other.__ss_pad2.iter())
.all(|(a, b)| a == b)
}
}
impl Eq for sockaddr_storage {}
impl ::fmt::Debug for sockaddr_storage {
fn fmt(&self, f: &mut ::fmt::Formatter) -> ::fmt::Result {
f.debug_struct("sockaddr_storage")
.field("ss_len", &self.ss_len)
.field("ss_family", &self.ss_family)
.field("__ss_pad1", &self.__ss_pad1)
.field("__ss_align", &self.__ss_align)
// FIXME: .field("__ss_pad2", &self.__ss_pad2)
.finish()
}
}
impl ::hash::Hash for sockaddr_storage {
fn hash<H: ::hash::Hasher>(&self, state: &mut H) {
self.ss_len.hash(state);
self.ss_family.hash(state);
self.__ss_pad1.hash(state);
self.__ss_align.hash(state);
self.__ss_pad2.hash(state);
}
}
impl PartialEq for utmpx {
fn eq(&self, other: &utmpx) -> bool {
--> --------------------
--> maximum size reached
--> --------------------
[ Dauer der Verarbeitung: 0.44 Sekunden
(vorverarbeitet)
]
|
2026-04-02
|
