pub const __DARWIN_ONLY_64_BIT_INO_T: u32 = 0;
pub const __DARWIN_ONLY_VERS_1050: u32 = 0;
pub const __DARWIN_ONLY_UNIX_CONFORMANCE: u32 = 1;
pub const __DARWIN_UNIX03: u32 = 1;
pub const __DARWIN_64_BIT_INO_T: u32 = 1;
pub const __DARWIN_VERS_1050: u32 = 1;
pub const __DARWIN_NON_CANCELABLE: u32 = 0;
pub const __DARWIN_SUF_64_BIT_INO_T: &'static [u8; 9usize] = b"$INODE64\0";
pub const __DARWIN_SUF_1050: &'static [u8; 6usize] = b"$1050\0";
pub const __DARWIN_SUF_EXTSN: &'static [u8; 14usize] = b"$DARWIN_EXTSN\0";
pub const __DARWIN_C_ANSI: u32 = 4096;
pub const __DARWIN_C_FULL: u32 = 900000;
pub const __DARWIN_C_LEVEL: u32 = 900000;
pub const __STDC_WANT_LIB_EXT1__: u32 = 1;
pub const __DARWIN_NO_LONG_LONG: u32 = 0;
pub const _DARWIN_FEATURE_64_BIT_INODE: u32 = 1;
pub const _DARWIN_FEATURE_ONLY_UNIX_CONFORMANCE: u32 = 1;
pub const _DARWIN_FEATURE_UNIX_CONFORMANCE: u32 = 3;
pub const __DARWIN_CLK_TCK: u32 = 100;
pub const CHAR_BIT: u32 = 8;
pub const MB_LEN_MAX: u32 = 6;
pub const CLK_TCK: u32 = 100;
pub const SCHAR_MAX: u32 = 127;
pub const SCHAR_MIN: i32 = -128;
pub const UCHAR_MAX: u32 = 255;
pub const CHAR_MAX: u32 = 127;
pub const CHAR_MIN: i32 = -128;
pub const USHRT_MAX: u32 = 65535;
pub const SHRT_MAX: u32 = 32767;
pub const SHRT_MIN: i32 = -32768;
pub const UINT_MAX: u32 = 4294967295;
pub const INT_MAX: u32 = 2147483647;
pub const INT_MIN: i32 = -2147483648;
pub const ULONG_MAX: i32 = -1;
pub const LONG_MAX: u64 = 9223372036854775807;
pub const LONG_MIN: i64 = -9223372036854775808;
pub const ULLONG_MAX: i32 = -1;
pub const LLONG_MAX: u64 = 9223372036854775807;
pub const LLONG_MIN: i64 = -9223372036854775808;
pub const LONG_BIT: u32 = 64;
pub const SSIZE_MAX: u64 = 9223372036854775807;
pub const WORD_BIT: u32 = 32;
pub const SIZE_T_MAX: i32 = -1;
pub const UQUAD_MAX: i32 = -1;
pub const QUAD_MAX: u64 = 9223372036854775807;
pub const QUAD_MIN: i64 = -9223372036854775808;
pub const ARG_MAX: u32 = 262144;
pub const CHILD_MAX: u32 = 266;
pub const GID_MAX: u32 = 2147483647;
pub const LINK_MAX: u32 = 32767;
pub const MAX_CANON: u32 = 1024;
pub const MAX_INPUT: u32 = 1024;
pub const NAME_MAX: u32 = 255;
pub const NGROUPS_MAX: u32 = 16;
pub const UID_MAX: u32 = 2147483647;
pub const OPEN_MAX: u32 = 10240;
pub const PATH_MAX: u32 = 1024;
pub const PIPE_BUF: u32 = 512;
pub const BC_BASE_MAX: u32 = 99;
pub const BC_DIM_MAX: u32 = 2048;
pub const BC_SCALE_MAX: u32 = 99;
pub const BC_STRING_MAX: u32 = 1000;
pub const CHARCLASS_NAME_MAX: u32 = 14;
pub const COLL_WEIGHTS_MAX: u32 = 2;
pub const EQUIV_CLASS_MAX: u32 = 2;
pub const EXPR_NEST_MAX: u32 = 32;
pub const LINE_MAX: u32 = 2048;
pub const RE_DUP_MAX: u32 = 255;
pub const NZERO: u32 = 20;
pub const _POSIX_ARG_MAX: u32 = 4096;
pub const _POSIX_CHILD_MAX: u32 = 25;
pub const _POSIX_LINK_MAX: u32 = 8;
pub const _POSIX_MAX_CANON: u32 = 255;
pub const _POSIX_MAX_INPUT: u32 = 255;
pub const _POSIX_NAME_MAX: u32 = 14;
pub const _POSIX_NGROUPS_MAX: u32 = 8;
pub const _POSIX_OPEN_MAX: u32 = 20;
pub const _POSIX_PATH_MAX: u32 = 256;
pub const _POSIX_PIPE_BUF: u32 = 512;
pub const _POSIX_SSIZE_MAX: u32 = 32767;
pub const _POSIX_STREAM_MAX: u32 = 8;
pub const _POSIX_TZNAME_MAX: u32 = 6;
pub const _POSIX2_BC_BASE_MAX: u32 = 99;
pub const _POSIX2_BC_DIM_MAX: u32 = 2048;
pub const _POSIX2_BC_SCALE_MAX: u32 = 99;
pub const _POSIX2_BC_STRING_MAX: u32 = 1000;
pub const _POSIX2_EQUIV_CLASS_MAX: u32 = 2;
pub const _POSIX2_EXPR_NEST_MAX: u32 = 32;
pub const _POSIX2_LINE_MAX: u32 = 2048;
pub const _POSIX2_RE_DUP_MAX: u32 = 255;
pub const _POSIX_AIO_LISTIO_MAX: u32 = 2;
pub const _POSIX_AIO_MAX: u32 = 1;
pub const _POSIX_DELAYTIMER_MAX: u32 = 32;
pub const _POSIX_MQ_OPEN_MAX: u32 = 8;
pub const _POSIX_MQ_PRIO_MAX: u32 = 32;
pub const _POSIX_RTSIG_MAX: u32 = 8;
pub const _POSIX_SEM_NSEMS_MAX: u32 = 256;
pub const _POSIX_SEM_VALUE_MAX: u32 = 32767;
pub const _POSIX_SIGQUEUE_MAX: u32 = 32;
pub const _POSIX_TIMER_MAX: u32 = 32;
pub const _POSIX_CLOCKRES_MIN: u32 = 20000000;
pub const _POSIX_THREAD_DESTRUCTOR_ITERATIONS: u32 = 4;
pub const _POSIX_THREAD_KEYS_MAX: u32 = 128;
pub const _POSIX_THREAD_THREADS_MAX: u32 = 64;
pub const PTHREAD_DESTRUCTOR_ITERATIONS: u32 = 4;
pub const PTHREAD_KEYS_MAX: u32 = 512;
pub const PTHREAD_STACK_MIN: u32 = 8192;
pub const _POSIX_HOST_NAME_MAX: u32 = 255;
pub const _POSIX_LOGIN_NAME_MAX: u32 = 9;
pub const _POSIX_SS_REPL_MAX: u32 = 4;
pub const _POSIX_SYMLINK_MAX: u32 = 255;
pub const _POSIX_SYMLOOP_MAX: u32 = 8;
pub const _POSIX_TRACE_EVENT_NAME_MAX: u32 = 30;
pub const _POSIX_TRACE_NAME_MAX: u32 = 8;
pub const _POSIX_TRACE_SYS_MAX: u32 = 8;
pub const _POSIX_TRACE_USER_EVENT_MAX: u32 = 32;
pub const _POSIX_TTY_NAME_MAX: u32 = 9;
pub const _POSIX2_CHARCLASS_NAME_MAX: u32 = 14;
pub const _POSIX2_COLL_WEIGHTS_MAX: u32 = 2;
pub const _POSIX_RE_DUP_MAX: u32 = 255;
pub const OFF_MIN: i64 = -9223372036854775808;
pub const OFF_MAX: u64 = 9223372036854775807;
pub const PASS_MAX: u32 = 128;
pub const NL_ARGMAX: u32 = 9;
pub const NL_LANGMAX: u32 = 14;
pub const NL_MSGMAX: u32 = 32767;
pub const NL_NMAX: u32 = 1;
pub const NL_SETMAX: u32 = 255;
pub const NL_TEXTMAX: u32 = 2048;
pub const _XOPEN_IOV_MAX: u32 = 16;
pub const IOV_MAX: u32 = 1024;
pub const _XOPEN_NAME_MAX: u32 = 255;
pub const _XOPEN_PATH_MAX: u32 = 1024;
pub const MAX_INTERFACE_NAME_LEN: u32 = 256;
pub const SIGAR_F_U64: &'static [u8; 4usize] = b"%lu\0";
pub const SIGAR_FIELD_NOTIMPL: i32 = -1;
pub const SIGAR_OK: u32 = 0;
pub const SIGAR_START_ERROR: u32 = 20000;
pub const SIGAR_ENOTIMPL: u32 = 20001;
pub const SIGAR_OS_START_ERROR: u32 = 40000;
pub const SIGAR_PATH_MAX: u32 = 1024;
pub const __PTHREAD_SIZE__: u32 = 8176;
pub const __PTHREAD_ATTR_SIZE__: u32 = 56;
pub const __PTHREAD_MUTEXATTR_SIZE__: u32 = 8;
pub const __PTHREAD_MUTEX_SIZE__: u32 = 56;
pub const __PTHREAD_CONDATTR_SIZE__: u32 = 8;
pub const __PTHREAD_COND_SIZE__: u32 = 40;
pub const __PTHREAD_ONCE_SIZE__: u32 = 8;
pub const __PTHREAD_RWLOCK_SIZE__: u32 = 192;
pub const __PTHREAD_RWLOCKATTR_SIZE__: u32 = 16;
pub const _QUAD_HIGHWORD: u32 = 1;
pub const _QUAD_LOWWORD: u32 = 0;
pub const __DARWIN_LITTLE_ENDIAN: u32 = 1234;
pub const __DARWIN_BIG_ENDIAN: u32 = 4321;
pub const __DARWIN_PDP_ENDIAN: u32 = 3412;
pub const __DARWIN_BYTE_ORDER: u32 = 1234;
pub const LITTLE_ENDIAN: u32 = 1234;
pub const BIG_ENDIAN: u32 = 4321;
pub const PDP_ENDIAN: u32 = 3412;
pub const BYTE_ORDER: u32 = 1234;
pub const __DARWIN_FD_SETSIZE: u32 = 1024;
pub const __DARWIN_NBBY: u32 = 8;
pub const NBBY: u32 = 8;
pub const FD_SETSIZE: u32 = 1024;
pub const SIGAR_CRED_NAME_MAX: u32 = 512;
pub const SIGAR_PROC_STATE_SLEEP: u8 = 83u8;
pub const SIGAR_PROC_STATE_RUN: u8 = 82u8;
pub const SIGAR_PROC_STATE_STOP: u8 = 84u8;
pub const SIGAR_PROC_STATE_ZOMBIE: u8 = 90u8;
pub const SIGAR_PROC_STATE_IDLE: u8 = 68u8;
pub const SIGAR_PROC_NAME_LEN: u32 = 128;
pub const SIGAR_FS_NAME_LEN: u32 = 1024;
pub const SIGAR_FS_INFO_LEN: u32 = 256;
pub const SIGAR_INET6_ADDRSTRLEN: u32 = 46;
pub const SIGAR_MAXDOMAINNAMELEN: u32 = 256;
pub const SIGAR_MAXHOSTNAMELEN: u32 = 256;
pub const SIGAR_RTF_UP: u32 = 1;
pub const SIGAR_RTF_GATEWAY: u32 = 2;
pub const SIGAR_RTF_HOST: u32 = 4;
pub const SIGAR_IFF_UP: u32 = 1;
pub const SIGAR_IFF_BROADCAST: u32 = 2;
pub const SIGAR_IFF_DEBUG: u32 = 4;
pub const SIGAR_IFF_LOOPBACK: u32 = 8;
pub const SIGAR_IFF_POINTOPOINT: u32 = 16;
pub const SIGAR_IFF_NOTRAILERS: u32 = 32;
pub const SIGAR_IFF_RUNNING: u32 = 64;
pub const SIGAR_IFF_NOARP: u32 = 128;
pub const SIGAR_IFF_PROMISC: u32 = 256;
pub const SIGAR_IFF_ALLMULTI: u32 = 512;
pub const SIGAR_IFF_MULTICAST: u32 = 2048;
pub const SIGAR_IFF_SLAVE: u32 = 4096;
pub const SIGAR_IFF_MASTER: u32 = 8192;
pub const SIGAR_IFF_DYNAMIC: u32 = 16384;
pub const SIGAR_NULL_HWADDR: &'static [u8; 18usize] = b"00:00:00:00:00:00\0";
pub const SIGAR_IPV6_ADDR_ANY: u32 = 0;
pub const SIGAR_IPV6_ADDR_UNICAST: u32 = 1;
pub const SIGAR_IPV6_ADDR_MULTICAST: u32 = 2;
pub const SIGAR_IPV6_ADDR_LOOPBACK: u32 = 16;
pub const SIGAR_IPV6_ADDR_LINKLOCAL: u32 = 32;
pub const SIGAR_IPV6_ADDR_SITELOCAL: u32 = 64;
pub const SIGAR_IPV6_ADDR_COMPATv4: u32 = 128;
pub const SIGAR_NETCONN_CLIENT: u32 = 1;
pub const SIGAR_NETCONN_SERVER: u32 = 2;
pub const SIGAR_NETCONN_TCP: u32 = 16;
pub const SIGAR_NETCONN_UDP: u32 = 32;
pub const SIGAR_NETCONN_RAW: u32 = 64;
pub const SIGAR_NETCONN_UNIX: u32 = 128;
pub const SIGAR_SYS_INFO_LEN: u32 = 256;
pub const SIGAR_FQDN_LEN: u32 = 512;
pub const SIGAR_UREAD: u32 = 1024;
pub const SIGAR_UWRITE: u32 = 512;
pub const SIGAR_UEXECUTE: u32 = 256;
pub const SIGAR_GREAD: u32 = 64;
pub const SIGAR_GWRITE: u32 = 32;
pub const SIGAR_GEXECUTE: u32 = 16;
pub const SIGAR_WREAD: u32 = 4;
pub const SIGAR_WWRITE: u32 = 2;
pub const SIGAR_WEXECUTE: u32 = 1;
pub const __GNUC_VA_LIST: u32 = 1;
pub const SIGAR_LOG_FATAL: u32 = 0;
pub const SIGAR_LOG_ERROR: u32 = 1;
pub const SIGAR_LOG_WARN: u32 = 2;
pub const SIGAR_LOG_INFO: u32 = 3;
pub const SIGAR_LOG_DEBUG: u32 = 4;
pub const SIGAR_LOG_TRACE: u32 = 5;
pub const SIGAR_PTQL_MALFORMED_QUERY: i32 = -1;
pub const SIGAR_PTQL_ERRMSG_SIZE: u32 = 1024;
pub type sigar_uint32_t = ::std::os::raw::c_uint;
pub type sigar_uint64_t = ::std::os::raw::c_ulong;
pub type sigar_int32_t = ::std::os::raw::c_int;
pub type sigar_int64_t = ::std::os::raw::c_long;
pub type __int8_t = ::std::os::raw::c_schar;
pub type __uint8_t = ::std::os::raw::c_uchar;
pub type __int16_t = ::std::os::raw::c_short;
pub type __uint16_t = ::std::os::raw::c_ushort;
pub type __int32_t = ::std::os::raw::c_int;
pub type __uint32_t = ::std::os::raw::c_uint;
pub type __int64_t = ::std::os::raw::c_longlong;
pub type __uint64_t = ::std::os::raw::c_ulonglong;
pub type __darwin_intptr_t = ::std::os::raw::c_long;
pub type __darwin_natural_t = ::std::os::raw::c_uint;
pub type __darwin_ct_rune_t = ::std::os::raw::c_int;
#[repr(C)]
#[derive(Copy, Clone)]
pub union __mbstate_t {
pub __mbstate8: [::std::os::raw::c_char; 128usize],
pub _mbstateL: ::std::os::raw::c_longlong,
_bindgen_union_align: [u64; 16usize],
}
#[test]
fn bindgen_test_layout___mbstate_t() {
assert_eq!(
::std::mem::size_of::<__mbstate_t>(),
128usize,
concat!("Size of: ", stringify!(__mbstate_t))
);
assert_eq!(
::std::mem::align_of::<__mbstate_t>(),
8usize,
concat!("Alignment of ", stringify!(__mbstate_t))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<__mbstate_t>())).__mbstate8 as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(__mbstate_t),
"::",
stringify!(__mbstate8)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<__mbstate_t>()))._mbstateL as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(__mbstate_t),
"::",
stringify!(_mbstateL)
)
);
}
impl Default for __mbstate_t {
fn default() -> Self {
unsafe { ::std::mem::zeroed() }
}
}
pub type __darwin_mbstate_t = __mbstate_t;
pub type __darwin_ptrdiff_t = ::std::os::raw::c_long;
pub type __darwin_size_t = ::std::os::raw::c_ulong;
pub type __darwin_va_list = __builtin_va_list;
pub type __darwin_wchar_t = ::std::os::raw::c_int;
pub type __darwin_rune_t = __darwin_wchar_t;
pub type __darwin_wint_t = ::std::os::raw::c_int;
pub type __darwin_clock_t = ::std::os::raw::c_ulong;
pub type __darwin_socklen_t = __uint32_t;
pub type __darwin_ssize_t = ::std::os::raw::c_long;
pub type __darwin_time_t = ::std::os::raw::c_long;
pub type u_int8_t = ::std::os::raw::c_uchar;
pub type u_int16_t = ::std::os::raw::c_ushort;
pub type u_int32_t = ::std::os::raw::c_uint;
pub type u_int64_t = ::std::os::raw::c_ulonglong;
pub type register_t = i64;
pub type user_addr_t = u_int64_t;
pub type user_size_t = u_int64_t;
pub type user_ssize_t = i64;
pub type user_long_t = i64;
pub type user_ulong_t = u_int64_t;
pub type user_time_t = i64;
pub type user_off_t = i64;
pub type syscall_arg_t = u_int64_t;
pub type __darwin_blkcnt_t = __int64_t;
pub type __darwin_blksize_t = __int32_t;
pub type __darwin_dev_t = __int32_t;
pub type __darwin_fsblkcnt_t = ::std::os::raw::c_uint;
pub type __darwin_fsfilcnt_t = ::std::os::raw::c_uint;
pub type __darwin_gid_t = __uint32_t;
pub type __darwin_id_t = __uint32_t;
pub type __darwin_ino64_t = __uint64_t;
pub type __darwin_ino_t = __darwin_ino64_t;
pub type __darwin_mach_port_name_t = __darwin_natural_t;
pub type __darwin_mach_port_t = __darwin_mach_port_name_t;
pub type __darwin_mode_t = __uint16_t;
pub type __darwin_off_t = __int64_t;
pub type __darwin_pid_t = __int32_t;
pub type __darwin_sigset_t = __uint32_t;
pub type __darwin_suseconds_t = __int32_t;
pub type __darwin_uid_t = __uint32_t;
pub type __darwin_useconds_t = __uint32_t;
pub type __darwin_uuid_t = [::std::os::raw::c_uchar; 16usize];
pub type __darwin_uuid_string_t = [::std::os::raw::c_char; 37usize];
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct __darwin_pthread_handler_rec {
pub __routine: ::std::option::Option<unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void)>,
pub __arg: *mut ::std::os::raw::c_void,
pub __next: *mut __darwin_pthread_handler_rec,
}
#[test]
fn bindgen_test_layout___darwin_pthread_handler_rec() {
assert_eq!(
::std::mem::size_of::<__darwin_pthread_handler_rec>(),
24usize,
concat!("Size of: ", stringify!(__darwin_pthread_handler_rec))
);
assert_eq!(
::std::mem::align_of::<__darwin_pthread_handler_rec>(),
8usize,
concat!("Alignment of ", stringify!(__darwin_pthread_handler_rec))
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<__darwin_pthread_handler_rec>())).__routine as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(__darwin_pthread_handler_rec),
"::",
stringify!(__routine)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<__darwin_pthread_handler_rec>())).__arg as *const _ as usize
},
8usize,
concat!(
"Offset of field: ",
stringify!(__darwin_pthread_handler_rec),
"::",
stringify!(__arg)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<__darwin_pthread_handler_rec>())).__next as *const _ as usize
},
16usize,
concat!(
"Offset of field: ",
stringify!(__darwin_pthread_handler_rec),
"::",
stringify!(__next)
)
);
}
impl Default for __darwin_pthread_handler_rec {
fn default() -> Self {
unsafe { ::std::mem::zeroed() }
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct _opaque_pthread_attr_t {
pub __sig: ::std::os::raw::c_long,
pub __opaque: [::std::os::raw::c_char; 56usize],
}
#[test]
fn bindgen_test_layout__opaque_pthread_attr_t() {
assert_eq!(
::std::mem::size_of::<_opaque_pthread_attr_t>(),
64usize,
concat!("Size of: ", stringify!(_opaque_pthread_attr_t))
);
assert_eq!(
::std::mem::align_of::<_opaque_pthread_attr_t>(),
8usize,
concat!("Alignment of ", stringify!(_opaque_pthread_attr_t))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_opaque_pthread_attr_t>())).__sig as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_opaque_pthread_attr_t),
"::",
stringify!(__sig)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_opaque_pthread_attr_t>())).__opaque as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(_opaque_pthread_attr_t),
"::",
stringify!(__opaque)
)
);
}
impl Default for _opaque_pthread_attr_t {
fn default() -> Self {
unsafe { ::std::mem::zeroed() }
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct _opaque_pthread_cond_t {
pub __sig: ::std::os::raw::c_long,
pub __opaque: [::std::os::raw::c_char; 40usize],
}
#[test]
fn bindgen_test_layout__opaque_pthread_cond_t() {
assert_eq!(
::std::mem::size_of::<_opaque_pthread_cond_t>(),
48usize,
concat!("Size of: ", stringify!(_opaque_pthread_cond_t))
);
assert_eq!(
::std::mem::align_of::<_opaque_pthread_cond_t>(),
8usize,
concat!("Alignment of ", stringify!(_opaque_pthread_cond_t))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_opaque_pthread_cond_t>())).__sig as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_opaque_pthread_cond_t),
"::",
stringify!(__sig)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_opaque_pthread_cond_t>())).__opaque as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(_opaque_pthread_cond_t),
"::",
stringify!(__opaque)
)
);
}
impl Default for _opaque_pthread_cond_t {
fn default() -> Self {
unsafe { ::std::mem::zeroed() }
}
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct _opaque_pthread_condattr_t {
pub __sig: ::std::os::raw::c_long,
pub __opaque: [::std::os::raw::c_char; 8usize],
}
#[test]
fn bindgen_test_layout__opaque_pthread_condattr_t() {
assert_eq!(
::std::mem::size_of::<_opaque_pthread_condattr_t>(),
16usize,
concat!("Size of: ", stringify!(_opaque_pthread_condattr_t))
);
assert_eq!(
::std::mem::align_of::<_opaque_pthread_condattr_t>(),
8usize,
concat!("Alignment of ", stringify!(_opaque_pthread_condattr_t))
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_opaque_pthread_condattr_t>())).__sig as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(_opaque_pthread_condattr_t),
"::",
stringify!(__sig)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_opaque_pthread_condattr_t>())).__opaque as *const _ as usize
},
8usize,
concat!(
"Offset of field: ",
stringify!(_opaque_pthread_condattr_t),
"::",
stringify!(__opaque)
)
);
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct _opaque_pthread_mutex_t {
pub __sig: ::std::os::raw::c_long,
pub __opaque: [::std::os::raw::c_char; 56usize],
}
#[test]
fn bindgen_test_layout__opaque_pthread_mutex_t() {
assert_eq!(
::std::mem::size_of::<_opaque_pthread_mutex_t>(),
64usize,
concat!("Size of: ", stringify!(_opaque_pthread_mutex_t))
);
assert_eq!(
::std::mem::align_of::<_opaque_pthread_mutex_t>(),
8usize,
concat!("Alignment of ", stringify!(_opaque_pthread_mutex_t))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_opaque_pthread_mutex_t>())).__sig as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_opaque_pthread_mutex_t),
"::",
stringify!(__sig)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_opaque_pthread_mutex_t>())).__opaque as *const _ as usize
},
8usize,
concat!(
"Offset of field: ",
stringify!(_opaque_pthread_mutex_t),
"::",
stringify!(__opaque)
)
);
}
impl Default for _opaque_pthread_mutex_t {
fn default() -> Self {
unsafe { ::std::mem::zeroed() }
}
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct _opaque_pthread_mutexattr_t {
pub __sig: ::std::os::raw::c_long,
pub __opaque: [::std::os::raw::c_char; 8usize],
}
#[test]
fn bindgen_test_layout__opaque_pthread_mutexattr_t() {
assert_eq!(
::std::mem::size_of::<_opaque_pthread_mutexattr_t>(),
16usize,
concat!("Size of: ", stringify!(_opaque_pthread_mutexattr_t))
);
assert_eq!(
::std::mem::align_of::<_opaque_pthread_mutexattr_t>(),
8usize,
concat!("Alignment of ", stringify!(_opaque_pthread_mutexattr_t))
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_opaque_pthread_mutexattr_t>())).__sig as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(_opaque_pthread_mutexattr_t),
"::",
stringify!(__sig)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_opaque_pthread_mutexattr_t>())).__opaque as *const _ as usize
},
8usize,
concat!(
"Offset of field: ",
stringify!(_opaque_pthread_mutexattr_t),
"::",
stringify!(__opaque)
)
);
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct _opaque_pthread_once_t {
pub __sig: ::std::os::raw::c_long,
pub __opaque: [::std::os::raw::c_char; 8usize],
}
#[test]
fn bindgen_test_layout__opaque_pthread_once_t() {
assert_eq!(
::std::mem::size_of::<_opaque_pthread_once_t>(),
16usize,
concat!("Size of: ", stringify!(_opaque_pthread_once_t))
);
assert_eq!(
::std::mem::align_of::<_opaque_pthread_once_t>(),
8usize,
concat!("Alignment of ", stringify!(_opaque_pthread_once_t))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_opaque_pthread_once_t>())).__sig as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_opaque_pthread_once_t),
"::",
stringify!(__sig)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_opaque_pthread_once_t>())).__opaque as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(_opaque_pthread_once_t),
"::",
stringify!(__opaque)
)
);
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct _opaque_pthread_rwlock_t {
pub __sig: ::std::os::raw::c_long,
pub __opaque: [::std::os::raw::c_char; 192usize],
}
#[test]
fn bindgen_test_layout__opaque_pthread_rwlock_t() {
assert_eq!(
::std::mem::size_of::<_opaque_pthread_rwlock_t>(),
200usize,
concat!("Size of: ", stringify!(_opaque_pthread_rwlock_t))
);
assert_eq!(
::std::mem::align_of::<_opaque_pthread_rwlock_t>(),
8usize,
concat!("Alignment of ", stringify!(_opaque_pthread_rwlock_t))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_opaque_pthread_rwlock_t>())).__sig as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_opaque_pthread_rwlock_t),
"::",
stringify!(__sig)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_opaque_pthread_rwlock_t>())).__opaque as *const _ as usize
},
8usize,
concat!(
"Offset of field: ",
stringify!(_opaque_pthread_rwlock_t),
"::",
stringify!(__opaque)
)
);
}
impl Default for _opaque_pthread_rwlock_t {
fn default() -> Self {
unsafe { ::std::mem::zeroed() }
}
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct _opaque_pthread_rwlockattr_t {
pub __sig: ::std::os::raw::c_long,
pub __opaque: [::std::os::raw::c_char; 16usize],
}
#[test]
fn bindgen_test_layout__opaque_pthread_rwlockattr_t() {
assert_eq!(
::std::mem::size_of::<_opaque_pthread_rwlockattr_t>(),
24usize,
concat!("Size of: ", stringify!(_opaque_pthread_rwlockattr_t))
);
assert_eq!(
::std::mem::align_of::<_opaque_pthread_rwlockattr_t>(),
8usize,
concat!("Alignment of ", stringify!(_opaque_pthread_rwlockattr_t))
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_opaque_pthread_rwlockattr_t>())).__sig as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(_opaque_pthread_rwlockattr_t),
"::",
stringify!(__sig)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_opaque_pthread_rwlockattr_t>())).__opaque as *const _ as usize
},
8usize,
concat!(
"Offset of field: ",
stringify!(_opaque_pthread_rwlockattr_t),
"::",
stringify!(__opaque)
)
);
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct _opaque_pthread_t {
pub __sig: ::std::os::raw::c_long,
pub __cleanup_stack: *mut __darwin_pthread_handler_rec,
pub __opaque: [::std::os::raw::c_char; 8176usize],
}
#[test]
fn bindgen_test_layout__opaque_pthread_t() {
assert_eq!(
::std::mem::size_of::<_opaque_pthread_t>(),
8192usize,
concat!("Size of: ", stringify!(_opaque_pthread_t))
);
assert_eq!(
::std::mem::align_of::<_opaque_pthread_t>(),
8usize,
concat!("Alignment of ", stringify!(_opaque_pthread_t))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_opaque_pthread_t>())).__sig as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_opaque_pthread_t),
"::",
stringify!(__sig)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_opaque_pthread_t>())).__cleanup_stack as *const _ as usize
},
8usize,
concat!(
"Offset of field: ",
stringify!(_opaque_pthread_t),
"::",
stringify!(__cleanup_stack)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_opaque_pthread_t>())).__opaque as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(_opaque_pthread_t),
"::",
stringify!(__opaque)
)
);
}
impl Default for _opaque_pthread_t {
fn default() -> Self {
unsafe { ::std::mem::zeroed() }
}
}
pub type __darwin_pthread_attr_t = _opaque_pthread_attr_t;
pub type __darwin_pthread_cond_t = _opaque_pthread_cond_t;
pub type __darwin_pthread_condattr_t = _opaque_pthread_condattr_t;
pub type __darwin_pthread_key_t = ::std::os::raw::c_ulong;
pub type __darwin_pthread_mutex_t = _opaque_pthread_mutex_t;
pub type __darwin_pthread_mutexattr_t = _opaque_pthread_mutexattr_t;
pub type __darwin_pthread_once_t = _opaque_pthread_once_t;
pub type __darwin_pthread_rwlock_t = _opaque_pthread_rwlock_t;
pub type __darwin_pthread_rwlockattr_t = _opaque_pthread_rwlockattr_t;
pub type __darwin_pthread_t = *mut _opaque_pthread_t;
pub type u_char = ::std::os::raw::c_uchar;
pub type u_short = ::std::os::raw::c_ushort;
pub type u_int = ::std::os::raw::c_uint;
pub type u_long = ::std::os::raw::c_ulong;
pub type ushort = ::std::os::raw::c_ushort;
pub type uint = ::std::os::raw::c_uint;
pub type u_quad_t = u_int64_t;
pub type quad_t = i64;
pub type qaddr_t = *mut quad_t;
pub type caddr_t = *mut ::std::os::raw::c_char;
pub type daddr_t = i32;
pub type dev_t = __darwin_dev_t;
pub type fixpt_t = u_int32_t;
pub type blkcnt_t = __darwin_blkcnt_t;
pub type blksize_t = __darwin_blksize_t;
pub type gid_t = __darwin_gid_t;
pub type in_addr_t = __uint32_t;
pub type in_port_t = __uint16_t;
pub type ino_t = __darwin_ino_t;
pub type ino64_t = __darwin_ino64_t;
pub type key_t = __int32_t;
pub type mode_t = __darwin_mode_t;
pub type nlink_t = __uint16_t;
pub type id_t = __darwin_id_t;
pub type pid_t = __darwin_pid_t;
pub type off_t = __darwin_off_t;
pub type segsz_t = i32;
pub type swblk_t = i32;
pub type uid_t = __darwin_uid_t;
pub type clock_t = __darwin_clock_t;
pub type time_t = __darwin_time_t;
pub type useconds_t = __darwin_useconds_t;
pub type suseconds_t = __darwin_suseconds_t;
pub type rsize_t = __darwin_size_t;
pub type errno_t = ::std::os::raw::c_int;
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct fd_set {
pub fds_bits: [__int32_t; 32usize],
}
#[test]
fn bindgen_test_layout_fd_set() {
assert_eq!(
::std::mem::size_of::<fd_set>(),
128usize,
concat!("Size of: ", stringify!(fd_set))
);
assert_eq!(
::std::mem::align_of::<fd_set>(),
4usize,
concat!("Alignment of ", stringify!(fd_set))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<fd_set>())).fds_bits as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(fd_set),
"::",
stringify!(fds_bits)
)
);
}
pub type fd_mask = __int32_t;
pub type pthread_attr_t = __darwin_pthread_attr_t;
pub type pthread_cond_t = __darwin_pthread_cond_t;
pub type pthread_condattr_t = __darwin_pthread_condattr_t;
pub type pthread_mutex_t = __darwin_pthread_mutex_t;
pub type pthread_mutexattr_t = __darwin_pthread_mutexattr_t;
pub type pthread_once_t = __darwin_pthread_once_t;
pub type pthread_rwlock_t = __darwin_pthread_rwlock_t;
pub type pthread_rwlockattr_t = __darwin_pthread_rwlockattr_t;
pub type pthread_t = __darwin_pthread_t;
pub type pthread_key_t = __darwin_pthread_key_t;
pub type fsblkcnt_t = __darwin_fsblkcnt_t;
pub type fsfilcnt_t = __darwin_fsfilcnt_t;
pub type sigar_pid_t = pid_t;
pub type sigar_uid_t = uid_t;
pub type sigar_gid_t = gid_t;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct sigar_t {
_unused: [u8; 0],
}
extern "C" {
pub fn sigar_open(sigar: *mut *mut sigar_t) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn sigar_close(sigar: *mut sigar_t) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn sigar_pid_get(sigar: *mut sigar_t) -> sigar_pid_t;
}
extern "C" {
pub fn sigar_proc_kill(
pid: sigar_pid_t,
signum: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn sigar_signum_get(name: *mut ::std::os::raw::c_char) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn sigar_strerror(
sigar: *mut sigar_t,
err: ::std::os::raw::c_int,
) -> *mut ::std::os::raw::c_char;
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct sigar_mem_t {
pub ram: sigar_uint64_t,
pub total: sigar_uint64_t,
pub used: sigar_uint64_t,
pub free: sigar_uint64_t,
pub actual_used: sigar_uint64_t,
pub actual_free: sigar_uint64_t,
pub used_percent: f64,
pub free_percent: f64,
}
#[test]
fn bindgen_test_layout_sigar_mem_t() {
assert_eq!(
::std::mem::size_of::<sigar_mem_t>(),
64usize,
concat!("Size of: ", stringify!(sigar_mem_t))
);
assert_eq!(
::std::mem::align_of::<sigar_mem_t>(),
8usize,
concat!("Alignment of ", stringify!(sigar_mem_t))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<sigar_mem_t>())).ram as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(sigar_mem_t),
"::",
stringify!(ram)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<sigar_mem_t>())).total as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(sigar_mem_t),
"::",
stringify!(total)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<sigar_mem_t>())).used as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(sigar_mem_t),
"::",
stringify!(used)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<sigar_mem_t>())).free as *const _ as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(sigar_mem_t),
"::",
stringify!(free)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<sigar_mem_t>())).actual_used as *const _ as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(sigar_mem_t),
"::",
stringify!(actual_used)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<sigar_mem_t>())).actual_free as *const _ as usize },
40usize,
concat!(
"Offset of field: ",
stringify!(sigar_mem_t),
"::",
stringify!(actual_free)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<sigar_mem_t>())).used_percent as *const _ as usize },
48usize,
concat!(
"Offset of field: ",
stringify!(sigar_mem_t),
"::",
stringify!(used_percent)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<sigar_mem_t>())).free_percent as *const _ as usize },
56usize,
concat!(
"Offset of field: ",
stringify!(sigar_mem_t),
"::",
stringify!(free_percent)
)
);
}
extern "C" {
pub fn sigar_mem_get(sigar: *mut sigar_t, mem: *mut sigar_mem_t) -> ::std::os::raw::c_int;
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct sigar_swap_t {
pub total: sigar_uint64_t,
pub used: sigar_uint64_t,
pub free: sigar_uint64_t,
pub page_in: sigar_uint64_t,
pub page_out: sigar_uint64_t,
}
#[test]
fn bindgen_test_layout_sigar_swap_t() {
assert_eq!(
::std::mem::size_of::<sigar_swap_t>(),
40usize,
concat!("Size of: ", stringify!(sigar_swap_t))
);
assert_eq!(
::std::mem::align_of::<sigar_swap_t>(),
8usize,
concat!("Alignment of ", stringify!(sigar_swap_t))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<sigar_swap_t>())).total as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(sigar_swap_t),
"::",
stringify!(total)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<sigar_swap_t>())).used as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(sigar_swap_t),
"::",
stringify!(used)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<sigar_swap_t>())).free as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(sigar_swap_t),
"::",
stringify!(free)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<sigar_swap_t>())).page_in as *const _ as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(sigar_swap_t),
"::",
stringify!(page_in)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<sigar_swap_t>())).page_out as *const _ as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(sigar_swap_t),
"::",
stringify!(page_out)
)
);
}
extern "C" {
pub fn sigar_swap_get(sigar: *mut sigar_t, swap: *mut sigar_swap_t) -> ::std::os::raw::c_int;
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct sigar_cpu_t {
pub user: sigar_uint64_t,
pub sys: sigar_uint64_t,
pub nice: sigar_uint64_t,
pub idle: sigar_uint64_t,
pub wait: sigar_uint64_t,
pub irq: sigar_uint64_t,
pub soft_irq: sigar_uint64_t,
pub stolen: sigar_uint64_t,
pub total: sigar_uint64_t,
}
#[test]
fn bindgen_test_layout_sigar_cpu_t() {
assert_eq!(
::std::mem::size_of::<sigar_cpu_t>(),
72usize,
concat!("Size of: ", stringify!(sigar_cpu_t))
);
assert_eq!(
::std::mem::align_of::<sigar_cpu_t>(),
8usize,
concat!("Alignment of ", stringify!(sigar_cpu_t))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<sigar_cpu_t>())).user as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(sigar_cpu_t),
"::",
stringify!(user)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<sigar_cpu_t>())).sys as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(sigar_cpu_t),
"::",
stringify!(sys)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<sigar_cpu_t>())).nice as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(sigar_cpu_t),
"::",
stringify!(nice)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<sigar_cpu_t>())).idle as *const _ as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(sigar_cpu_t),
"::",
stringify!(idle)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<sigar_cpu_t>())).wait as *const _ as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(sigar_cpu_t),
"::",
stringify!(wait)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<sigar_cpu_t>())).irq as *const _ as usize },
40usize,
concat!(
"Offset of field: ",
stringify!(sigar_cpu_t),
"::",
stringify!(irq)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<sigar_cpu_t>())).soft_irq as *const _ as usize },
48usize,
concat!(
"Offset of field: ",
stringify!(sigar_cpu_t),
"::",
stringify!(soft_irq)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<sigar_cpu_t>())).stolen as *const _ as usize },
56usize,
concat!(
"Offset of field: ",
stringify!(sigar_cpu_t),
"::",
stringify!(stolen)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<sigar_cpu_t>())).total as *const _ as usize },
64usize,
concat!(
"Offset of field: ",
stringify!(sigar_cpu_t),
"::",
stringify!(total)
)
);
}
extern "C" {
pub fn sigar_cpu_get(sigar: *mut sigar_t, cpu: *mut sigar_cpu_t) -> ::std::os::raw::c_int;
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct sigar_cpu_list_t {
pub number: ::std::os::raw::c_ulong,
pub size: ::std::os::raw::c_ulong,
pub data: *mut sigar_cpu_t,
}
#[test]
fn bindgen_test_layout_sigar_cpu_list_t() {
assert_eq!(
::std::mem::size_of::<sigar_cpu_list_t>(),
24usize,
concat!("Size of: ", stringify!(sigar_cpu_list_t))
);
assert_eq!(
::std::mem::align_of::<sigar_cpu_list_t>(),
8usize,
concat!("Alignment of ", stringify!(sigar_cpu_list_t))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<sigar_cpu_list_t>())).number as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(sigar_cpu_list_t),
"::",
stringify!(number)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<sigar_cpu_list_t>())).size as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(sigar_cpu_list_t),
"::",
stringify!(size)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<sigar_cpu_list_t>())).data as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(sigar_cpu_list_t),
"::",
stringify!(data)
)
);
}
impl Default for sigar_cpu_list_t {
fn default() -> Self {
unsafe { ::std::mem::zeroed() }
}
}
extern "C" {
pub fn sigar_cpu_list_get(
sigar: *mut sigar_t,
cpulist: *mut sigar_cpu_list_t,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn sigar_cpu_list_destroy(
sigar: *mut sigar_t,
cpulist: *mut sigar_cpu_list_t,
) -> ::std::os::raw::c_int;
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct sigar_cpu_info_t {
pub vendor: [::std::os::raw::c_char; 128usize],
pub model: [::std::os::raw::c_char; 128usize],
pub mhz: ::std::os::raw::c_int,
pub mhz_max: ::std::os::raw::c_int,
pub mhz_min: ::std::os::raw::c_int,
pub cache_size: sigar_uint64_t,
pub total_sockets: ::std::os::raw::c_int,
pub total_cores: ::std::os::raw::c_int,
pub cores_per_socket: ::std::os::raw::c_int,
}
#[test]
fn bindgen_test_layout_sigar_cpu_info_t() {
assert_eq!(
::std::mem::size_of::<sigar_cpu_info_t>(),
296usize,
concat!("Size of: ", stringify!(sigar_cpu_info_t))
);
assert_eq!(
::std::mem::align_of::<sigar_cpu_info_t>(),
8usize,
concat!("Alignment of ", stringify!(sigar_cpu_info_t))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<sigar_cpu_info_t>())).vendor as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(sigar_cpu_info_t),
"::",
stringify!(vendor)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<sigar_cpu_info_t>())).model as *const _ as usize },
128usize,
concat!(
"Offset of field: ",
stringify!(sigar_cpu_info_t),
"::",
stringify!(model)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<sigar_cpu_info_t>())).mhz as *const _ as usize },
256usize,
concat!(
"Offset of field: ",
stringify!(sigar_cpu_info_t),
"::",
stringify!(mhz)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<sigar_cpu_info_t>())).mhz_max as *const _ as usize },
260usize,
concat!(
"Offset of field: ",
stringify!(sigar_cpu_info_t),
"::",
stringify!(mhz_max)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<sigar_cpu_info_t>())).mhz_min as *const _ as usize },
264usize,
concat!(
"Offset of field: ",
stringify!(sigar_cpu_info_t),
"::",
stringify!(mhz_min)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<sigar_cpu_info_t>())).cache_size as *const _ as usize },
272usize,
concat!(
"Offset of field: ",
stringify!(sigar_cpu_info_t),
"::",
stringify!(cache_size)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<sigar_cpu_info_t>())).total_sockets as *const _ as usize },
280usize,
concat!(
"Offset of field: ",
stringify!(sigar_cpu_info_t),
"::",
stringify!(total_sockets)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<sigar_cpu_info_t>())).total_cores as *const _ as usize },
284usize,
concat!(
"Offset of field: ",
stringify!(sigar_cpu_info_t),
"::",
stringify!(total_cores)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<sigar_cpu_info_t>())).cores_per_socket as *const _ as usize
},
288usize,
concat!(
"Offset of field: ",
stringify!(sigar_cpu_info_t),
"::",
stringify!(cores_per_socket)
)
);
}
impl Default for sigar_cpu_info_t {
fn default() -> Self {
unsafe { ::std::mem::zeroed() }
}
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct sigar_cpu_info_list_t {
pub number: ::std::os::raw::c_ulong,
pub size: ::std::os::raw::c_ulong,
pub data: *mut sigar_cpu_info_t,
}
#[test]
fn bindgen_test_layout_sigar_cpu_info_list_t() {
assert_eq!(
::std::mem::size_of::<sigar_cpu_info_list_t>(),
24usize,
concat!("Size of: ", stringify!(sigar_cpu_info_list_t))
);
assert_eq!(
::std::mem::align_of::<sigar_cpu_info_list_t>(),
8usize,
concat!("Alignment of ", stringify!(sigar_cpu_info_list_t))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<sigar_cpu_info_list_t>())).number as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(sigar_cpu_info_list_t),
"::",
stringify!(number)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<sigar_cpu_info_list_t>())).size as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(sigar_cpu_info_list_t),
"::",
stringify!(size)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<sigar_cpu_info_list_t>())).data as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(sigar_cpu_info_list_t),
"::",
stringify!(data)
)
);
}
impl Default for sigar_cpu_info_list_t {
fn default() -> Self {
unsafe { ::std::mem::zeroed() }
}
}
extern "C" {
pub fn sigar_cpu_info_list_get(
sigar: *mut sigar_t,
cpu_infos: *mut sigar_cpu_info_list_t,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn sigar_cpu_info_list_destroy(
sigar: *mut sigar_t,
cpu_infos: *mut sigar_cpu_info_list_t,
) -> ::std::os::raw::c_int;
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct sigar_uptime_t {
pub uptime: f64,
}
#[test]
fn bindgen_test_layout_sigar_uptime_t() {
assert_eq!(
::std::mem::size_of::<sigar_uptime_t>(),
8usize,
concat!("Size of: ", stringify!(sigar_uptime_t))
);
assert_eq!(
::std::mem::align_of::<sigar_uptime_t>(),
8usize,
concat!("Alignment of ", stringify!(sigar_uptime_t))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<sigar_uptime_t>())).uptime as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(sigar_uptime_t),
"::",
stringify!(uptime)
)
);
}
extern "C" {
pub fn sigar_uptime_get(
sigar: *mut sigar_t,
uptime: *mut sigar_uptime_t,
) -> ::std::os::raw::c_int;
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct sigar_loadavg_t {
pub loadavg: [f64; 3usize],
}
#[test]
fn bindgen_test_layout_sigar_loadavg_t() {
assert_eq!(
::std::mem::size_of::<sigar_loadavg_t>(),
24usize,
concat!("Size of: ", stringify!(sigar_loadavg_t))
);
assert_eq!(
::std::mem::align_of::<sigar_loadavg_t>(),
8usize,
concat!("Alignment of ", stringify!(sigar_loadavg_t))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<sigar_loadavg_t>())).loadavg as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(sigar_loadavg_t),
"::",
stringify!(loadavg)
)
);
}
extern "C" {
pub fn sigar_loadavg_get(
sigar: *mut sigar_t,
loadavg: *mut sigar_loadavg_t,
) -> ::std::os::raw::c_int;
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct sigar_proc_list_t {
pub number: ::std::os::raw::c_ulong,
pub size: ::std::os::raw::c_ulong,
pub data: *mut sigar_pid_t,
}
#[test]
fn bindgen_test_layout_sigar_proc_list_t() {
assert_eq!(
::std::mem::size_of::<sigar_proc_list_t>(),
24usize,
concat!("Size of: ", stringify!(sigar_proc_list_t))
);
assert_eq!(
::std::mem::align_of::<sigar_proc_list_t>(),
8usize,
concat!("Alignment of ", stringify!(sigar_proc_list_t))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<sigar_proc_list_t>())).number as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(sigar_proc_list_t),
"::",
stringify!(number)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<sigar_proc_list_t>())).size as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(sigar_proc_list_t),
"::",
stringify!(size)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<sigar_proc_list_t>())).data as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(sigar_proc_list_t),
"::",
stringify!(data)
)
);
}
impl Default for sigar_proc_list_t {
fn default() -> Self {
unsafe { ::std::mem::zeroed() }
}
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct sigar_resource_limit_t {
pub cpu_cur: sigar_uint64_t,
pub cpu_max: sigar_uint64_t,
pub file_size_cur: sigar_uint64_t,
pub file_size_max: sigar_uint64_t,
pub pipe_size_cur: sigar_uint64_t,
pub pipe_size_max: sigar_uint64_t,
pub data_cur: sigar_uint64_t,
pub data_max: sigar_uint64_t,
pub stack_cur: sigar_uint64_t,
pub stack_max: sigar_uint64_t,
pub core_cur: sigar_uint64_t,
pub core_max: sigar_uint64_t,
pub memory_cur: sigar_uint64_t,
pub memory_max: sigar_uint64_t,
pub processes_cur: sigar_uint64_t,
pub processes_max: sigar_uint64_t,
pub open_files_cur: sigar_uint64_t,
pub open_files_max: sigar_uint64_t,
pub virtual_memory_cur: sigar_uint64_t,
pub virtual_memory_max: sigar_uint64_t,
}
#[test]
fn bindgen_test_layout_sigar_resource_limit_t() {
assert_eq!(
::std::mem::size_of::<sigar_resource_limit_t>(),
160usize,
concat!("Size of: ", stringify!(sigar_resource_limit_t))
);
assert_eq!(
::std::mem::align_of::<sigar_resource_limit_t>(),
8usize,
concat!("Alignment of ", stringify!(sigar_resource_limit_t))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<sigar_resource_limit_t>())).cpu_cur as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(sigar_resource_limit_t),
"::",
stringify!(cpu_cur)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<sigar_resource_limit_t>())).cpu_max as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(sigar_resource_limit_t),
"::",
stringify!(cpu_max)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<sigar_resource_limit_t>())).file_size_cur as *const _ as usize
},
16usize,
concat!(
"Offset of field: ",
stringify!(sigar_resource_limit_t),
"::",
stringify!(file_size_cur)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<sigar_resource_limit_t>())).file_size_max as *const _ as usize
},
24usize,
concat!(
"Offset of field: ",
stringify!(sigar_resource_limit_t),
"::",
stringify!(file_size_max)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<sigar_resource_limit_t>())).pipe_size_cur as *const _ as usize
},
32usize,
concat!(
"Offset of field: ",
stringify!(sigar_resource_limit_t),
"::",
stringify!(pipe_size_cur)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<sigar_resource_limit_t>())).pipe_size_max as *const _ as usize
},
40usize,
concat!(
"Offset of field: ",
stringify!(sigar_resource_limit_t),
"::",
stringify!(pipe_size_max)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<sigar_resource_limit_t>())).data_cur as *const _ as usize },
48usize,
concat!(
"Offset of field: ",
stringify!(sigar_resource_limit_t),
"::",
stringify!(data_cur)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<sigar_resource_limit_t>())).data_max as *const _ as usize },
56usize,
concat!(
"Offset of field: ",
stringify!(sigar_resource_limit_t),
"::",
stringify!(data_max)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<sigar_resource_limit_t>())).stack_cur as *const _ as usize
},
64usize,
concat!(
"Offset of field: ",
stringify!(sigar_resource_limit_t),
"::",
stringify!(stack_cur)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<sigar_resource_limit_t>())).stack_max as *const _ as usize
},
72usize,
concat!(
"Offset of field: ",
stringify!(sigar_resource_limit_t),
"::",
stringify!(stack_max)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<sigar_resource_limit_t>())).core_cur as *const _ as usize },
80usize,
concat!(
"Offset of field: ",
stringify!(sigar_resource_limit_t),
"::",
stringify!(core_cur)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<sigar_resource_limit_t>())).core_max as *const _ as usize },
88usize,
concat!(
"Offset of field: ",
stringify!(sigar_resource_limit_t),
"::",
stringify!(core_max)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<sigar_resource_limit_t>())).memory_cur as *const _ as usize
},
96usize,
concat!(
"Offset of field: ",
stringify!(sigar_resource_limit_t),
"::",
stringify!(memory_cur)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<sigar_resource_limit_t>())).memory_max as *const _ as usize
},
104usize,
concat!(
"Offset of field: ",
stringify!(sigar_resource_limit_t),
"::",
stringify!(memory_max)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<sigar_resource_limit_t>())).processes_cur as *const _ as usize
},
112usize,
concat!(
"Offset of field: ",
stringify!(sigar_resource_limit_t),
"::",
stringify!(processes_cur)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<sigar_resource_limit_t>())).processes_max as *const _ as usize
},
120usize,
concat!(
"Offset of field: ",
stringify!(sigar_resource_limit_t),
"::",
stringify!(processes_max)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<sigar_resource_limit_t>())).open_files_cur as *const _ as usize
},
128usize,
concat!(
"Offset of field: ",
stringify!(sigar_resource_limit_t),
"::",
stringify!(open_files_cur)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<sigar_resource_limit_t>())).open_files_max as *const _ as usize
},
136usize,
concat!(
"Offset of field: ",
stringify!(sigar_resource_limit_t),
"::",
stringify!(open_files_max)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<sigar_resource_limit_t>())).virtual_memory_cur as *const _
as usize
},
144usize,
concat!(
"Offset of field: ",
stringify!(sigar_resource_limit_t),
"::",
stringify!(virtual_memory_cur)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<sigar_resource_limit_t>())).virtual_memory_max as *const _
as usize
},
152usize,
concat!(
"Offset of field: ",
stringify!(sigar_resource_limit_t),
"::",
stringify!(virtual_memory_max)
)
);
}
extern "C" {
pub fn sigar_resource_limit_get(
sigar: *mut sigar_t,
rlimit: *mut sigar_resource_limit_t,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn sigar_proc_list_get(
sigar: *mut sigar_t,
proclist: *mut sigar_proc_list_t,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn sigar_proc_list_destroy(
sigar: *mut sigar_t,
proclist: *mut sigar_proc_list_t,
) -> ::std::os::raw::c_int;
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct sigar_proc_stat_t {
pub total: sigar_uint64_t,
pub sleeping: sigar_uint64_t,
pub running: sigar_uint64_t,
pub zombie: sigar_uint64_t,
pub stopped: sigar_uint64_t,
pub idle: sigar_uint64_t,
pub threads: sigar_uint64_t,
}
#[test]
fn bindgen_test_layout_sigar_proc_stat_t() {
assert_eq!(
::std::mem::size_of::<sigar_proc_stat_t>(),
56usize,
concat!("Size of: ", stringify!(sigar_proc_stat_t))
);
assert_eq!(
::std::mem::align_of::<sigar_proc_stat_t>(),
8usize,
concat!("Alignment of ", stringify!(sigar_proc_stat_t))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<sigar_proc_stat_t>())).total as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(sigar_proc_stat_t),
"::",
stringify!(total)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<sigar_proc_stat_t>())).sleeping as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(sigar_proc_stat_t),
"::",
stringify!(sleeping)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<sigar_proc_stat_t>())).running as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(sigar_proc_stat_t),
"::",
stringify!(running)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<sigar_proc_stat_t>())).zombie as *const _ as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(sigar_proc_stat_t),
"::",
stringify!(zombie)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<sigar_proc_stat_t>())).stopped as *const _ as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(sigar_proc_stat_t),
"::",
stringify!(stopped)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<sigar_proc_stat_t>())).idle as *const _ as usize },
40usize,
concat!(
"Offset of field: ",
stringify!(sigar_proc_stat_t),
"::",
stringify!(idle)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<sigar_proc_stat_t>())).threads as *const _ as usize },
48usize,
concat!(
"Offset of field: ",
stringify!(sigar_proc_stat_t),
"::",
stringify!(threads)
)
);
}
extern "C" {
pub fn sigar_proc_stat_get(
sigar: *mut sigar_t,
procstat: *mut sigar_proc_stat_t,
) -> ::std::os::raw::c_int;
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct sigar_proc_mem_t {
pub size: sigar_uint64_t,
pub resident: sigar_uint64_t,
pub share: sigar_uint64_t,
pub minor_faults: sigar_uint64_t,
pub major_faults: sigar_uint64_t,
pub page_faults: sigar_uint64_t,
}
#[test]
fn bindgen_test_layout_sigar_proc_mem_t() {
assert_eq!(
::std::mem::size_of::<sigar_proc_mem_t>(),
48usize,
concat!("Size of: ", stringify!(sigar_proc_mem_t))
);
assert_eq!(
::std::mem::align_of::<sigar_proc_mem_t>(),
8usize,
concat!("Alignment of ", stringify!(sigar_proc_mem_t))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<sigar_proc_mem_t>())).size as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(sigar_proc_mem_t),
"::",
stringify!(size)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<sigar_proc_mem_t>())).resident as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(sigar_proc_mem_t),
"::",
stringify!(resident)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<sigar_proc_mem_t>())).share as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(sigar_proc_mem_t),
"::",
stringify!(share)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<sigar_proc_mem_t>())).minor_faults as *const _ as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(sigar_proc_mem_t),
"::",
stringify!(minor_faults)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<sigar_proc_mem_t>())).major_faults as *const _ as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(sigar_proc_mem_t),
"::",
stringify!(major_faults)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<sigar_proc_mem_t>())).page_faults as *const _ as usize },
40usize,
concat!(
"Offset of field: ",
stringify!(sigar_proc_mem_t),
"::",
stringify!(page_faults)
)
);
}
extern "C" {
pub fn sigar_proc_mem_get(
sigar: *mut sigar_t,
pid: sigar_pid_t,
procmem: *mut sigar_proc_mem_t,
) -> ::std::os::raw::c_int;
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct sigar_proc_disk_io_t {
pub bytes_read: sigar_uint64_t,
pub bytes_written: sigar_uint64_t,
pub bytes_total: sigar_uint64_t,
}
#[test]
fn bindgen_test_layout_sigar_proc_disk_io_t() {
assert_eq!(
::std::mem::size_of::<sigar_proc_disk_io_t>(),
24usize,
concat!("Size of: ", stringify!(sigar_proc_disk_io_t))
);
assert_eq!(
::std::mem::align_of::<sigar_proc_disk_io_t>(),
8usize,
concat!("Alignment of ", stringify!(sigar_proc_disk_io_t))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<sigar_proc_disk_io_t>())).bytes_read as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(sigar_proc_disk_io_t),
"::",
stringify!(bytes_read)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<sigar_proc_disk_io_t>())).bytes_written as *const _ as usize
},
8usize,
concat!(
"Offset of field: ",
stringify!(sigar_proc_disk_io_t),
"::",
stringify!(bytes_written)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<sigar_proc_disk_io_t>())).bytes_total as *const _ as usize
},
16usize,
concat!(
"Offset of field: ",
stringify!(sigar_proc_disk_io_t),
"::",
stringify!(bytes_total)
)
);
}
extern "C" {
pub fn sigar_proc_disk_io_get(
sigar: *mut sigar_t,
pid: sigar_pid_t,
proc_disk_io: *mut sigar_proc_disk_io_t,
) -> ::std::os::raw::c_int;
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct sigar_cached_proc_disk_io_t {
pub bytes_read: sigar_uint64_t,
pub bytes_written: sigar_uint64_t,
pub bytes_total: sigar_uint64_t,
pub last_time: sigar_uint64_t,
pub bytes_read_diff: sigar_uint64_t,
pub bytes_written_diff: sigar_uint64_t,
pub bytes_total_diff: sigar_uint64_t,
}
#[test]
fn bindgen_test_layout_sigar_cached_proc_disk_io_t() {
assert_eq!(
::std::mem::size_of::<sigar_cached_proc_disk_io_t>(),
56usize,
concat!("Size of: ", stringify!(sigar_cached_proc_disk_io_t))
);
assert_eq!(
::std::mem::align_of::<sigar_cached_proc_disk_io_t>(),
8usize,
concat!("Alignment of ", stringify!(sigar_cached_proc_disk_io_t))
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<sigar_cached_proc_disk_io_t>())).bytes_read as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(sigar_cached_proc_disk_io_t),
"::",
stringify!(bytes_read)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<sigar_cached_proc_disk_io_t>())).bytes_written as *const _
as usize
},
8usize,
concat!(
"Offset of field: ",
stringify!(sigar_cached_proc_disk_io_t),
"::",
stringify!(bytes_written)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<sigar_cached_proc_disk_io_t>())).bytes_total as *const _ as usize
},
16usize,
concat!(
"Offset of field: ",
stringify!(sigar_cached_proc_disk_io_t),
"::",
stringify!(bytes_total)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<sigar_cached_proc_disk_io_t>())).last_time as *const _ as usize
},
24usize,
concat!(
"Offset of field: ",
stringify!(sigar_cached_proc_disk_io_t),
"::",
stringify!(last_time)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<sigar_cached_proc_disk_io_t>())).bytes_read_diff as *const _
as usize
},
32usize,
concat!(
"Offset of field: ",
stringify!(sigar_cached_proc_disk_io_t),
"::",
stringify!(bytes_read_diff)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<sigar_cached_proc_disk_io_t>())).bytes_written_diff as *const _
as usize
},
40usize,
concat!(
"Offset of field: ",
stringify!(sigar_cached_proc_disk_io_t),
"::",
stringify!(bytes_written_diff)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<sigar_cached_proc_disk_io_t>())).bytes_total_diff as *const _
as usize
},
48usize,
concat!(
"Offset of field: ",
stringify!(sigar_cached_proc_disk_io_t),
"::",
stringify!(bytes_total_diff)
)
);
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct sigar_proc_cumulative_disk_io_t {
pub bytes_read: sigar_uint64_t,
pub bytes_written: sigar_uint64_t,
pub bytes_total: sigar_uint64_t,
}
#[test]
fn bindgen_test_layout_sigar_proc_cumulative_disk_io_t() {
assert_eq!(
::std::mem::size_of::<sigar_proc_cumulative_disk_io_t>(),
24usize,
concat!("Size of: ", stringify!(sigar_proc_cumulative_disk_io_t))
);
assert_eq!(
::std::mem::align_of::<sigar_proc_cumulative_disk_io_t>(),
8usize,
concat!("Alignment of ", stringify!(sigar_proc_cumulative_disk_io_t))
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<sigar_proc_cumulative_disk_io_t>())).bytes_read as *const _
as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(sigar_proc_cumulative_disk_io_t),
"::",
stringify!(bytes_read)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<sigar_proc_cumulative_disk_io_t>())).bytes_written as *const _
as usize
},
8usize,
concat!(
"Offset of field: ",
stringify!(sigar_proc_cumulative_disk_io_t),
"::",
stringify!(bytes_written)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<sigar_proc_cumulative_disk_io_t>())).bytes_total as *const _
as usize
},
16usize,
concat!(
"Offset of field: ",
stringify!(sigar_proc_cumulative_disk_io_t),
"::",
stringify!(bytes_total)
)
);
}
extern "C" {
pub fn sigar_proc_cumulative_disk_io_get(
sigar: *mut sigar_t,
pid: sigar_pid_t,
proc_cumulative_disk_io: *mut sigar_proc_cumulative_disk_io_t,
) -> ::std::os::raw::c_int;
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct sigar_dump_pid_cache_t {
pub dummy: sigar_uint64_t,
}
#[test]
fn bindgen_test_layout_sigar_dump_pid_cache_t() {
assert_eq!(
::std::mem::size_of::<sigar_dump_pid_cache_t>(),
8usize,
concat!("Size of: ", stringify!(sigar_dump_pid_cache_t))
);
assert_eq!(
::std::mem::align_of::<sigar_dump_pid_cache_t>(),
8usize,
concat!("Alignment of ", stringify!(sigar_dump_pid_cache_t))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<sigar_dump_pid_cache_t>())).dummy as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(sigar_dump_pid_cache_t),
"::",
stringify!(dummy)
)
);
}
extern "C" {
pub fn sigar_dump_pid_cache_get(
sigar: *mut sigar_t,
info: *mut sigar_dump_pid_cache_t,
) -> ::std::os::raw::c_int;
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct sigar_proc_cred_t {
pub uid: sigar_uid_t,
pub gid: sigar_gid_t,
pub euid: sigar_uid_t,
pub egid: sigar_gid_t,
}
#[test]
fn bindgen_test_layout_sigar_proc_cred_t() {
assert_eq!(
::std::mem::size_of::<sigar_proc_cred_t>(),
16usize,
concat!("Size of: ", stringify!(sigar_proc_cred_t))
);
assert_eq!(
::std::mem::align_of::<sigar_proc_cred_t>(),
4usize,
concat!("Alignment of ", stringify!(sigar_proc_cred_t))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<sigar_proc_cred_t>())).uid as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(sigar_proc_cred_t),
"::",
stringify!(uid)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<sigar_proc_cred_t>())).gid as *const _ as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(sigar_proc_cred_t),
"::",
stringify!(gid)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<sigar_proc_cred_t>())).euid as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(sigar_proc_cred_t),
"::",
stringify!(euid)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<sigar_proc_cred_t>())).egid as *const _ as usize },
12usize,
concat!(
"Offset of field: ",
stringify!(sigar_proc_cred_t),
"::",
stringify!(egid)
)
);
}
extern "C" {
pub fn sigar_proc_cred_get(
sigar: *mut sigar_t,
pid: sigar_pid_t,
proccred: *mut sigar_proc_cred_t,
) -> ::std::os::raw::c_int;
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct sigar_proc_cred_name_t {
pub user: [::std::os::raw::c_char; 512usize],
pub group: [::std::os::raw::c_char; 512usize],
}
#[test]
fn bindgen_test_layout_sigar_proc_cred_name_t() {
assert_eq!(
::std::mem::size_of::<sigar_proc_cred_name_t>(),
1024usize,
concat!("Size of: ", stringify!(sigar_proc_cred_name_t))
);
assert_eq!(
::std::mem::align_of::<sigar_proc_cred_name_t>(),
1usize,
concat!("Alignment of ", stringify!(sigar_proc_cred_name_t))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<sigar_proc_cred_name_t>())).user as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(sigar_proc_cred_name_t),
"::",
stringify!(user)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<sigar_proc_cred_name_t>())).group as *const _ as usize },
512usize,
concat!(
"Offset of field: ",
stringify!(sigar_proc_cred_name_t),
"::",
stringify!(group)
)
);
}
impl Default for sigar_proc_cred_name_t {
fn default() -> Self {
unsafe { ::std::mem::zeroed() }
}
}
extern "C" {
pub fn sigar_proc_cred_name_get(
sigar: *mut sigar_t,
pid: sigar_pid_t,
proccredname: *mut sigar_proc_cred_name_t,
) -> ::std::os::raw::c_int;
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct sigar_proc_time_t {
pub start_time: sigar_uint64_t,
pub user: sigar_uint64_t,
pub sys: sigar_uint64_t,
pub total: sigar_uint64_t,
}
#[test]
fn bindgen_test_layout_sigar_proc_time_t() {
assert_eq!(
::std::mem::size_of::<sigar_proc_time_t>(),
32usize,
concat!("Size of: ", stringify!(sigar_proc_time_t))
);
assert_eq!(
::std::mem::align_of::<sigar_proc_time_t>(),
8usize,
concat!("Alignment of ", stringify!(sigar_proc_time_t))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<sigar_proc_time_t>())).start_time as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(sigar_proc_time_t),
"::",
stringify!(start_time)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<sigar_proc_time_t>())).user as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(sigar_proc_time_t),
"::",
stringify!(user)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<sigar_proc_time_t>())).sys as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(sigar_proc_time_t),
"::",
stringify!(sys)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<sigar_proc_time_t>())).total as *const _ as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(sigar_proc_time_t),
"::",
stringify!(total)
)
);
}
extern "C" {
pub fn sigar_proc_time_get(
sigar: *mut sigar_t,
pid: sigar_pid_t,
proctime: *mut sigar_proc_time_t,
) -> ::std::os::raw::c_int;
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct sigar_proc_cpu_t {
pub start_time: sigar_uint64_t,
pub user: sigar_uint64_t,
pub sys: sigar_uint64_t,
pub total: sigar_uint64_t,
pub last_time: sigar_uint64_t,
pub percent: f64,
}
#[test]
fn bindgen_test_layout_sigar_proc_cpu_t() {
assert_eq!(
::std::mem::size_of::<sigar_proc_cpu_t>(),
48usize,
concat!("Size of: ", stringify!(sigar_proc_cpu_t))
);
assert_eq!(
::std::mem::align_of::<sigar_proc_cpu_t>(),
8usize,
concat!("Alignment of ", stringify!(sigar_proc_cpu_t))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<sigar_proc_cpu_t>())).start_time as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(sigar_proc_cpu_t),
"::",
stringify!(start_time)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<sigar_proc_cpu_t>())).user as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(sigar_proc_cpu_t),
"::",
stringify!(user)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<sigar_proc_cpu_t>())).sys as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(sigar_proc_cpu_t),
"::",
stringify!(sys)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<sigar_proc_cpu_t>())).total as *const _ as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(sigar_proc_cpu_t),
"::",
stringify!(total)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<sigar_proc_cpu_t>())).last_time as *const _ as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(sigar_proc_cpu_t),
"::",
stringify!(last_time)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<sigar_proc_cpu_t>())).percent as *const _ as usize },
40usize,
concat!(
"Offset of field: ",
stringify!(sigar_proc_cpu_t),
"::",
stringify!(percent)
)
);
}
extern "C" {
pub fn sigar_proc_cpu_get(
sigar: *mut sigar_t,
pid: sigar_pid_t,
proccpu: *mut sigar_proc_cpu_t,
) -> ::std::os::raw::c_int;
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct sigar_proc_state_t {
pub name: [::std::os::raw::c_char; 128usize],
pub state: ::std::os::raw::c_char,
pub ppid: sigar_pid_t,
pub tty: ::std::os::raw::c_int,
pub priority: ::std::os::raw::c_int,
pub nice: ::std::os::raw::c_int,
pub processor: ::std::os::raw::c_int,
pub threads: sigar_uint64_t,
}
#[test]
fn bindgen_test_layout_sigar_proc_state_t() {
assert_eq!(
::std::mem::size_of::<sigar_proc_state_t>(),
160usize,
concat!("Size of: ", stringify!(sigar_proc_state_t))
);
assert_eq!(
::std::mem::align_of::<sigar_proc_state_t>(),
8usize,
concat!("Alignment of ", stringify!(sigar_proc_state_t))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<sigar_proc_state_t>())).name as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(sigar_proc_state_t),
"::",
stringify!(name)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<sigar_proc_state_t>())).state as *const _ as usize },
128usize,
concat!(
"Offset of field: ",
stringify!(sigar_proc_state_t),
"::",
stringify!(state)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<sigar_proc_state_t>())).ppid as *const _ as usize },
132usize,
concat!(
"Offset of field: ",
stringify!(sigar_proc_state_t),
"::",
stringify!(ppid)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<sigar_proc_state_t>())).tty as *const _ as usize },
136usize,
concat!(
"Offset of field: ",
stringify!(sigar_proc_state_t),
"::",
stringify!(tty)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<sigar_proc_state_t>())).priority as *const _ as usize },
140usize,
concat!(
"Offset of field: ",
stringify!(sigar_proc_state_t),
"::",
stringify!(priority)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<sigar_proc_state_t>())).nice as *const _ as usize },
144usize,
concat!(
"Offset of field: ",
stringify!(sigar_proc_state_t),
"::",
stringify!(nice)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<sigar_proc_state_t>())).processor as *const _ as usize },
148usize,
concat!(
"Offset of field: ",
stringify!(sigar_proc_state_t),
"::",
stringify!(processor)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<sigar_proc_state_t>())).threads as *const _ as usize },
152usize,
concat!(
"Offset of field: ",
stringify!(sigar_proc_state_t),
"::",
stringify!(threads)
)
);
}
impl Default for sigar_proc_state_t {
fn default() -> Self {
unsafe { ::std::mem::zeroed() }
}
}
extern "C" {
pub fn sigar_proc_state_get(
sigar: *mut sigar_t,
pid: sigar_pid_t,
procstate: *mut sigar_proc_state_t,
) -> ::std::os::raw::c_int;
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct sigar_proc_args_t {
pub number: ::std::os::raw::c_ulong,
pub size: ::std::os::raw::c_ulong,
pub data: *mut *mut ::std::os::raw::c_char,
}
#[test]
fn bindgen_test_layout_sigar_proc_args_t() {
assert_eq!(
::std::mem::size_of::<sigar_proc_args_t>(),
24usize,
concat!("Size of: ", stringify!(sigar_proc_args_t))
);
assert_eq!(
::std::mem::align_of::<sigar_proc_args_t>(),
8usize,
concat!("Alignment of ", stringify!(sigar_proc_args_t))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<sigar_proc_args_t>())).number as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(sigar_proc_args_t),
"::",
stringify!(number)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<sigar_proc_args_t>())).size as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(sigar_proc_args_t),
"::",
stringify!(size)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<sigar_proc_args_t>())).data as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(sigar_proc_args_t),
"::",
stringify!(data)
)
);
}
impl Default for sigar_proc_args_t {
fn default() -> Self {
unsafe { ::std::mem::zeroed() }
}
}
extern "C" {
pub fn sigar_proc_args_get(
sigar: *mut sigar_t,
pid: sigar_pid_t,
procargs: *mut sigar_proc_args_t,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn sigar_proc_args_destroy(
sigar: *mut sigar_t,
procargs: *mut sigar_proc_args_t,
) -> ::std::os::raw::c_int;
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct sigar_proc_env_t {
pub data: *mut ::std::os::raw::c_void,
pub type_: sigar_proc_env_t__bindgen_ty_1,
pub key: *const ::std::os::raw::c_char,
pub klen: ::std::os::raw::c_int,
pub env_getter: ::std::option::Option<
unsafe extern "C" fn(
arg1: *mut ::std::os::raw::c_void,
arg2: *const ::std::os::raw::c_char,
arg3: ::std::os::raw::c_int,
arg4: *mut ::std::os::raw::c_char,
arg5: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int,
>,
}
pub const sigar_proc_env_t_SIGAR_PROC_ENV_ALL: sigar_proc_env_t__bindgen_ty_1 = 0;
pub const sigar_proc_env_t_SIGAR_PROC_ENV_KEY: sigar_proc_env_t__bindgen_ty_1 = 1;
pub type sigar_proc_env_t__bindgen_ty_1 = u32;
#[test]
fn bindgen_test_layout_sigar_proc_env_t() {
assert_eq!(
::std::mem::size_of::<sigar_proc_env_t>(),
40usize,
concat!("Size of: ", stringify!(sigar_proc_env_t))
);
assert_eq!(
::std::mem::align_of::<sigar_proc_env_t>(),
8usize,
concat!("Alignment of ", stringify!(sigar_proc_env_t))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<sigar_proc_env_t>())).data as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(sigar_proc_env_t),
"::",
stringify!(data)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<sigar_proc_env_t>())).type_ as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(sigar_proc_env_t),
"::",
stringify!(type_)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<sigar_proc_env_t>())).key as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(sigar_proc_env_t),
"::",
stringify!(key)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<sigar_proc_env_t>())).klen as *const _ as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(sigar_proc_env_t),
"::",
stringify!(klen)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<sigar_proc_env_t>())).env_getter as *const _ as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(sigar_proc_env_t),
"::",
stringify!(env_getter)
)
);
}
impl Default for sigar_proc_env_t {
fn default() -> Self {
unsafe { ::std::mem::zeroed() }
}
}
extern "C" {
pub fn sigar_proc_env_get(
sigar: *mut sigar_t,
pid: sigar_pid_t,
procenv: *mut sigar_proc_env_t,
) -> ::std::os::raw::c_int;
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct sigar_proc_fd_t {
pub total: sigar_uint64_t,
}
#[test]
fn bindgen_test_layout_sigar_proc_fd_t() {
assert_eq!(
::std::mem::size_of::<sigar_proc_fd_t>(),
8usize,
concat!("Size of: ", stringify!(sigar_proc_fd_t))
);
assert_eq!(
::std::mem::align_of::<sigar_proc_fd_t>(),
8usize,
concat!("Alignment of ", stringify!(sigar_proc_fd_t))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<sigar_proc_fd_t>())).total as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(sigar_proc_fd_t),
"::",
stringify!(total)
)
);
}
extern "C" {
pub fn sigar_proc_fd_get(
sigar: *mut sigar_t,
pid: sigar_pid_t,
procfd: *mut sigar_proc_fd_t,
) -> ::std::os::raw::c_int;
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct sigar_proc_exe_t {
pub name: [::std::os::raw::c_char; 1025usize],
pub cwd: [::std::os::raw::c_char; 1025usize],
pub root: [::std::os::raw::c_char; 1025usize],
}
#[test]
fn bindgen_test_layout_sigar_proc_exe_t() {
assert_eq!(
::std::mem::size_of::<sigar_proc_exe_t>(),
3075usize,
concat!("Size of: ", stringify!(sigar_proc_exe_t))
);
assert_eq!(
::std::mem::align_of::<sigar_proc_exe_t>(),
1usize,
concat!("Alignment of ", stringify!(sigar_proc_exe_t))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<sigar_proc_exe_t>())).name as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(sigar_proc_exe_t),
"::",
stringify!(name)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<sigar_proc_exe_t>())).cwd as *const _ as usize },
1025usize,
concat!(
"Offset of field: ",
stringify!(sigar_proc_exe_t),
"::",
stringify!(cwd)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<sigar_proc_exe_t>())).root as *const _ as usize },
2050usize,
concat!(
"Offset of field: ",
stringify!(sigar_proc_exe_t),
"::",
stringify!(root)
)
);
}
impl Default for sigar_proc_exe_t {
fn default() -> Self {
unsafe { ::std::mem::zeroed() }
}
}
extern "C" {
pub fn sigar_proc_exe_get(
sigar: *mut sigar_t,
pid: sigar_pid_t,
procexe: *mut sigar_proc_exe_t,
) -> ::std::os::raw::c_int;
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct sigar_proc_modules_t {
pub data: *mut ::std::os::raw::c_void,
pub module_getter: ::std::option::Option<
unsafe extern "C" fn(
arg1: *mut ::std::os::raw::c_void,
arg2: *mut ::std::os::raw::c_char,
arg3: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int,
>,
}
#[test]
fn bindgen_test_layout_sigar_proc_modules_t() {
assert_eq!(
::std::mem::size_of::<sigar_proc_modules_t>(),
16usize,
concat!("Size of: ", stringify!(sigar_proc_modules_t))
);
assert_eq!(
::std::mem::align_of::<sigar_proc_modules_t>(),
8usize,
concat!("Alignment of ", stringify!(sigar_proc_modules_t))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<sigar_proc_modules_t>())).data as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(sigar_proc_modules_t),
"::",
stringify!(data)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<sigar_proc_modules_t>())).module_getter as *const _ as usize
},
8usize,
concat!(
"Offset of field: ",
stringify!(sigar_proc_modules_t),
"::",
stringify!(module_getter)
)
);
}
impl Default for sigar_proc_modules_t {
fn default() -> Self {
unsafe { ::std::mem::zeroed() }
}
}
extern "C" {
pub fn sigar_proc_modules_get(
sigar: *mut sigar_t,
pid: sigar_pid_t,
procmods: *mut sigar_proc_modules_t,
) -> ::std::os::raw::c_int;
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct sigar_thread_cpu_t {
pub user: sigar_uint64_t,
pub sys: sigar_uint64_t,
pub total: sigar_uint64_t,
}
#[test]
fn bindgen_test_layout_sigar_thread_cpu_t() {
assert_eq!(
::std::mem::size_of::<sigar_thread_cpu_t>(),
24usize,
concat!("Size of: ", stringify!(sigar_thread_cpu_t))
);
assert_eq!(
::std::mem::align_of::<sigar_thread_cpu_t>(),
8usize,
concat!("Alignment of ", stringify!(sigar_thread_cpu_t))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<sigar_thread_cpu_t>())).user as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(sigar_thread_cpu_t),
"::",
stringify!(user)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<sigar_thread_cpu_t>())).sys as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(sigar_thread_cpu_t),
"::",
stringify!(sys)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<sigar_thread_cpu_t>())).total as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(sigar_thread_cpu_t),
"::",
stringify!(total)
)
);
}
extern "C" {
pub fn sigar_thread_cpu_get(
sigar: *mut sigar_t,
id: sigar_uint64_t,
cpu: *mut sigar_thread_cpu_t,
) -> ::std::os::raw::c_int;
}
pub const sigar_file_system_type_e_SIGAR_FSTYPE_UNKNOWN: sigar_file_system_type_e = 0;
pub const sigar_file_system_type_e_SIGAR_FSTYPE_NONE: sigar_file_system_type_e = 1;
pub const sigar_file_system_type_e_SIGAR_FSTYPE_LOCAL_DISK: sigar_file_system_type_e = 2;
pub const sigar_file_system_type_e_SIGAR_FSTYPE_NETWORK: sigar_file_system_type_e = 3;
pub const sigar_file_system_type_e_SIGAR_FSTYPE_RAM_DISK: sigar_file_system_type_e = 4;
pub const sigar_file_system_type_e_SIGAR_FSTYPE_CDROM: sigar_file_system_type_e = 5;
pub const sigar_file_system_type_e_SIGAR_FSTYPE_SWAP: sigar_file_system_type_e = 6;
pub const sigar_file_system_type_e_SIGAR_FSTYPE_MAX: sigar_file_system_type_e = 7;
pub type sigar_file_system_type_e = u32;
#[repr(C)]
#[derive(Copy, Clone)]
pub struct sigar_file_system_t {
pub dir_name: [::std::os::raw::c_char; 1024usize],
pub dev_name: [::std::os::raw::c_char; 1024usize],
pub type_name: [::std::os::raw::c_char; 256usize],
pub sys_type_name: [::std::os::raw::c_char; 256usize],
pub options: [::std::os::raw::c_char; 256usize],
pub type_: sigar_file_system_type_e,
pub flags: ::std::os::raw::c_ulong,
}
#[test]
fn bindgen_test_layout_sigar_file_system_t() {
assert_eq!(
::std::mem::size_of::<sigar_file_system_t>(),
2832usize,
concat!("Size of: ", stringify!(sigar_file_system_t))
);
assert_eq!(
::std::mem::align_of::<sigar_file_system_t>(),
8usize,
concat!("Alignment of ", stringify!(sigar_file_system_t))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<sigar_file_system_t>())).dir_name as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(sigar_file_system_t),
"::",
stringify!(dir_name)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<sigar_file_system_t>())).dev_name as *const _ as usize },
1024usize,
concat!(
"Offset of field: ",
stringify!(sigar_file_system_t),
"::",
stringify!(dev_name)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<sigar_file_system_t>())).type_name as *const _ as usize },
2048usize,
concat!(
"Offset of field: ",
stringify!(sigar_file_system_t),
"::",
stringify!(type_name)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<sigar_file_system_t>())).sys_type_name as *const _ as usize
},
2304usize,
concat!(
"Offset of field: ",
stringify!(sigar_file_system_t),
"::",
stringify!(sys_type_name)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<sigar_file_system_t>())).options as *const _ as usize },
2560usize,
concat!(
"Offset of field: ",
stringify!(sigar_file_system_t),
"::",
stringify!(options)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<sigar_file_system_t>())).type_ as *const _ as usize },
2816usize,
concat!(
"Offset of field: ",
stringify!(sigar_file_system_t),
"::",
stringify!(type_)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<sigar_file_system_t>())).flags as *const _ as usize },
2824usize,
concat!(
"Offset of field: ",
stringify!(sigar_file_system_t),
"::",
stringify!(flags)
)
);
}
impl Default for sigar_file_system_t {
fn default() -> Self {
unsafe { ::std::mem::zeroed() }
}
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct sigar_file_system_list_t {
pub number: ::std::os::raw::c_ulong,
pub size: ::std::os::raw::c_ulong,
pub data: *mut sigar_file_system_t,
}
#[test]
fn bindgen_test_layout_sigar_file_system_list_t() {
assert_eq!(
::std::mem::size_of::<sigar_file_system_list_t>(),
24usize,
concat!("Size of: ", stringify!(sigar_file_system_list_t))
);
assert_eq!(
::std::mem::align_of::<sigar_file_system_list_t>(),
8usize,
concat!("Alignment of ", stringify!(sigar_file_system_list_t))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<sigar_file_system_list_t>())).number as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(sigar_file_system_list_t),
"::",
stringify!(number)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<sigar_file_system_list_t>())).size as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(sigar_file_system_list_t),
"::",
stringify!(size)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<sigar_file_system_list_t>())).data as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(sigar_file_system_list_t),
"::",
stringify!(data)
)
);
}
impl Default for sigar_file_system_list_t {
fn default() -> Self {
unsafe { ::std::mem::zeroed() }
}
}
extern "C" {
pub fn sigar_file_system_list_get(
sigar: *mut sigar_t,
fslist: *mut sigar_file_system_list_t,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn sigar_file_system_list_destroy(
sigar: *mut sigar_t,
fslist: *mut sigar_file_system_list_t,
) -> ::std::os::raw::c_int;
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct sigar_disk_usage_t {
pub reads: sigar_uint64_t,
pub writes: sigar_uint64_t,
pub write_bytes: sigar_uint64_t,
pub read_bytes: sigar_uint64_t,
pub rtime: sigar_uint64_t,
pub wtime: sigar_uint64_t,
pub qtime: sigar_uint64_t,
pub time: sigar_uint64_t,
pub snaptime: sigar_uint64_t,
pub service_time: f64,
pub queue: f64,
}
#[test]
fn bindgen_test_layout_sigar_disk_usage_t() {
assert_eq!(
::std::mem::size_of::<sigar_disk_usage_t>(),
88usize,
concat!("Size of: ", stringify!(sigar_disk_usage_t))
);
assert_eq!(
::std::mem::align_of::<sigar_disk_usage_t>(),
8usize,
concat!("Alignment of ", stringify!(sigar_disk_usage_t))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<sigar_disk_usage_t>())).reads as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(sigar_disk_usage_t),
"::",
stringify!(reads)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<sigar_disk_usage_t>())).writes as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(sigar_disk_usage_t),
"::",
stringify!(writes)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<sigar_disk_usage_t>())).write_bytes as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(sigar_disk_usage_t),
"::",
stringify!(write_bytes)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<sigar_disk_usage_t>())).read_bytes as *const _ as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(sigar_disk_usage_t),
"::",
stringify!(read_bytes)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<sigar_disk_usage_t>())).rtime as *const _ as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(sigar_disk_usage_t),
"::",
stringify!(rtime)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<sigar_disk_usage_t>())).wtime as *const _ as usize },
40usize,
concat!(
"Offset of field: ",
stringify!(sigar_disk_usage_t),
"::",
stringify!(wtime)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<sigar_disk_usage_t>())).qtime as *const _ as usize },
48usize,
concat!(
"Offset of field: ",
stringify!(sigar_disk_usage_t),
"::",
stringify!(qtime)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<sigar_disk_usage_t>())).time as *const _ as usize },
56usize,
concat!(
"Offset of field: ",
stringify!(sigar_disk_usage_t),
"::",
stringify!(time)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<sigar_disk_usage_t>())).snaptime as *const _ as usize },
64usize,
concat!(
"Offset of field: ",
stringify!(sigar_disk_usage_t),
"::",
stringify!(snaptime)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<sigar_disk_usage_t>())).service_time as *const _ as usize },
72usize,
concat!(
"Offset of field: ",
stringify!(sigar_disk_usage_t),
"::",
stringify!(service_time)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<sigar_disk_usage_t>())).queue as *const _ as usize },
80usize,
concat!(
"Offset of field: ",
stringify!(sigar_disk_usage_t),
"::",
stringify!(queue)
)
);
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct sigar_file_system_usage_t {
pub disk: sigar_disk_usage_t,
pub use_percent: f64,
pub total: sigar_uint64_t,
pub free: sigar_uint64_t,
pub used: sigar_uint64_t,
pub avail: sigar_uint64_t,
pub files: sigar_uint64_t,
pub free_files: sigar_uint64_t,
}
#[test]
fn bindgen_test_layout_sigar_file_system_usage_t() {
assert_eq!(
::std::mem::size_of::<sigar_file_system_usage_t>(),
144usize,
concat!("Size of: ", stringify!(sigar_file_system_usage_t))
);
assert_eq!(
::std::mem::align_of::<sigar_file_system_usage_t>(),
8usize,
concat!("Alignment of ", stringify!(sigar_file_system_usage_t))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<sigar_file_system_usage_t>())).disk as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(sigar_file_system_usage_t),
"::",
stringify!(disk)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<sigar_file_system_usage_t>())).use_percent as *const _ as usize
},
88usize,
concat!(
"Offset of field: ",
stringify!(sigar_file_system_usage_t),
"::",
stringify!(use_percent)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<sigar_file_system_usage_t>())).total as *const _ as usize },
96usize,
concat!(
"Offset of field: ",
stringify!(sigar_file_system_usage_t),
"::",
stringify!(total)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<sigar_file_system_usage_t>())).free as *const _ as usize },
104usize,
concat!(
"Offset of field: ",
stringify!(sigar_file_system_usage_t),
"::",
stringify!(free)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<sigar_file_system_usage_t>())).used as *const _ as usize },
112usize,
concat!(
"Offset of field: ",
stringify!(sigar_file_system_usage_t),
"::",
stringify!(used)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<sigar_file_system_usage_t>())).avail as *const _ as usize },
120usize,
concat!(
"Offset of field: ",
stringify!(sigar_file_system_usage_t),
"::",
stringify!(avail)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<sigar_file_system_usage_t>())).files as *const _ as usize },
128usize,
concat!(
"Offset of field: ",
stringify!(sigar_file_system_usage_t),
"::",
stringify!(files)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<sigar_file_system_usage_t>())).free_files as *const _ as usize
},
136usize,
concat!(
"Offset of field: ",
stringify!(sigar_file_system_usage_t),
"::",
stringify!(free_files)
)
);
}
extern "C" {
pub fn sigar_file_system_usage_get(
sigar: *mut sigar_t,
dirname: *const ::std::os::raw::c_char,
fsusage: *mut sigar_file_system_usage_t,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn sigar_disk_usage_get(
sigar: *mut sigar_t,
name: *const ::std::os::raw::c_char,
disk: *mut sigar_disk_usage_t,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn sigar_file_system_ping(
sigar: *mut sigar_t,
fs: *mut sigar_file_system_t,
) -> ::std::os::raw::c_int;
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct sigar_net_address_t {
pub family: sigar_net_address_t__bindgen_ty_1,
pub addr: sigar_net_address_t__bindgen_ty_2,
}
pub const sigar_net_address_t_SIGAR_AF_UNSPEC: sigar_net_address_t__bindgen_ty_1 = 0;
pub const sigar_net_address_t_SIGAR_AF_INET: sigar_net_address_t__bindgen_ty_1 = 1;
pub const sigar_net_address_t_SIGAR_AF_INET6: sigar_net_address_t__bindgen_ty_1 = 2;
pub const sigar_net_address_t_SIGAR_AF_LINK: sigar_net_address_t__bindgen_ty_1 = 3;
pub type sigar_net_address_t__bindgen_ty_1 = u32;
#[repr(C)]
#[derive(Copy, Clone)]
pub union sigar_net_address_t__bindgen_ty_2 {
pub in_: sigar_uint32_t,
pub in6: [sigar_uint32_t; 4usize],
pub mac: [::std::os::raw::c_uchar; 8usize],
_bindgen_union_align: [u32; 4usize],
}
#[test]
fn bindgen_test_layout_sigar_net_address_t__bindgen_ty_2() {
assert_eq!(
::std::mem::size_of::<sigar_net_address_t__bindgen_ty_2>(),
16usize,
concat!("Size of: ", stringify!(sigar_net_address_t__bindgen_ty_2))
);
assert_eq!(
::std::mem::align_of::<sigar_net_address_t__bindgen_ty_2>(),
4usize,
concat!(
"Alignment of ",
stringify!(sigar_net_address_t__bindgen_ty_2)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<sigar_net_address_t__bindgen_ty_2>())).in_ as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(sigar_net_address_t__bindgen_ty_2),
"::",
stringify!(in_)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<sigar_net_address_t__bindgen_ty_2>())).in6 as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(sigar_net_address_t__bindgen_ty_2),
"::",
stringify!(in6)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<sigar_net_address_t__bindgen_ty_2>())).mac as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(sigar_net_address_t__bindgen_ty_2),
"::",
stringify!(mac)
)
);
}
impl Default for sigar_net_address_t__bindgen_ty_2 {
fn default() -> Self {
unsafe { ::std::mem::zeroed() }
}
}
#[test]
fn bindgen_test_layout_sigar_net_address_t() {
assert_eq!(
::std::mem::size_of::<sigar_net_address_t>(),
20usize,
concat!("Size of: ", stringify!(sigar_net_address_t))
);
assert_eq!(
::std::mem::align_of::<sigar_net_address_t>(),
4usize,
concat!("Alignment of ", stringify!(sigar_net_address_t))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<sigar_net_address_t>())).family as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(sigar_net_address_t),
"::",
stringify!(family)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<sigar_net_address_t>())).addr as *const _ as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(sigar_net_address_t),
"::",
stringify!(addr)
)
);
}
impl Default for sigar_net_address_t {
fn default() -> Self {
unsafe { ::std::mem::zeroed() }
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct sigar_net_info_t {
pub default_gateway: [::std::os::raw::c_char; 46usize],
pub default_gateway_interface: [::std::os::raw::c_char; 256usize],
pub host_name: [::std::os::raw::c_char; 256usize],
pub domain_name: [::std::os::raw::c_char; 256usize],
pub primary_dns: [::std::os::raw::c_char; 46usize],
pub secondary_dns: [::std::os::raw::c_char; 46usize],
}
#[test]
fn bindgen_test_layout_sigar_net_info_t() {
assert_eq!(
::std::mem::size_of::<sigar_net_info_t>(),
906usize,
concat!("Size of: ", stringify!(sigar_net_info_t))
);
assert_eq!(
::std::mem::align_of::<sigar_net_info_t>(),
1usize,
concat!("Alignment of ", stringify!(sigar_net_info_t))
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<sigar_net_info_t>())).default_gateway as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(sigar_net_info_t),
"::",
stringify!(default_gateway)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<sigar_net_info_t>())).default_gateway_interface as *const _
as usize
},
46usize,
concat!(
"Offset of field: ",
stringify!(sigar_net_info_t),
"::",
stringify!(default_gateway_interface)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<sigar_net_info_t>())).host_name as *const _ as usize },
302usize,
concat!(
"Offset of field: ",
stringify!(sigar_net_info_t),
"::",
stringify!(host_name)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<sigar_net_info_t>())).domain_name as *const _ as usize },
558usize,
concat!(
"Offset of field: ",
stringify!(sigar_net_info_t),
"::",
stringify!(domain_name)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<sigar_net_info_t>())).primary_dns as *const _ as usize },
814usize,
concat!(
"Offset of field: ",
stringify!(sigar_net_info_t),
"::",
stringify!(primary_dns)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<sigar_net_info_t>())).secondary_dns as *const _ as usize },
860usize,
concat!(
"Offset of field: ",
stringify!(sigar_net_info_t),
"::",
stringify!(secondary_dns)
)
);
}
impl Default for sigar_net_info_t {
fn default() -> Self {
unsafe { ::std::mem::zeroed() }
}
}
extern "C" {
pub fn sigar_net_info_get(
sigar: *mut sigar_t,
netinfo: *mut sigar_net_info_t,
) -> ::std::os::raw::c_int;
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct sigar_net_route_t {
pub destination: sigar_net_address_t,
pub gateway: sigar_net_address_t,
pub mask: sigar_net_address_t,
pub flags: sigar_uint64_t,
pub refcnt: sigar_uint64_t,
pub use_: sigar_uint64_t,
pub metric: sigar_uint64_t,
pub mtu: sigar_uint64_t,
pub window: sigar_uint64_t,
pub irtt: sigar_uint64_t,
pub ifname: [::std::os::raw::c_char; 256usize],
}
#[test]
fn bindgen_test_layout_sigar_net_route_t() {
assert_eq!(
::std::mem::size_of::<sigar_net_route_t>(),
376usize,
concat!("Size of: ", stringify!(sigar_net_route_t))
);
assert_eq!(
::std::mem::align_of::<sigar_net_route_t>(),
8usize,
concat!("Alignment of ", stringify!(sigar_net_route_t))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<sigar_net_route_t>())).destination as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(sigar_net_route_t),
"::",
stringify!(destination)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<sigar_net_route_t>())).gateway as *const _ as usize },
20usize,
concat!(
"Offset of field: ",
stringify!(sigar_net_route_t),
"::",
stringify!(gateway)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<sigar_net_route_t>())).mask as *const _ as usize },
40usize,
concat!(
"Offset of field: ",
stringify!(sigar_net_route_t),
"::",
stringify!(mask)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<sigar_net_route_t>())).flags as *const _ as usize },
64usize,
concat!(
"Offset of field: ",
stringify!(sigar_net_route_t),
"::",
stringify!(flags)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<sigar_net_route_t>())).refcnt as *const _ as usize },
72usize,
concat!(
"Offset of field: ",
stringify!(sigar_net_route_t),
"::",
stringify!(refcnt)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<sigar_net_route_t>())).use_ as *const _ as usize },
80usize,
concat!(
"Offset of field: ",
stringify!(sigar_net_route_t),
"::",
stringify!(use_)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<sigar_net_route_t>())).metric as *const _ as usize },
88usize,
concat!(
"Offset of field: ",
stringify!(sigar_net_route_t),
"::",
stringify!(metric)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<sigar_net_route_t>())).mtu as *const _ as usize },
96usize,
concat!(
"Offset of field: ",
stringify!(sigar_net_route_t),
"::",
stringify!(mtu)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<sigar_net_route_t>())).window as *const _ as usize },
104usize,
concat!(
"Offset of field: ",
stringify!(sigar_net_route_t),
"::",
stringify!(window)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<sigar_net_route_t>())).irtt as *const _ as usize },
112usize,
concat!(
"Offset of field: ",
stringify!(sigar_net_route_t),
"::",
stringify!(irtt)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<sigar_net_route_t>())).ifname as *const _ as usize },
120usize,
concat!(
"Offset of field: ",
stringify!(sigar_net_route_t),
"::",
stringify!(ifname)
)
);
}
impl Default for sigar_net_route_t {
fn default() -> Self {
unsafe { ::std::mem::zeroed() }
}
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct sigar_net_route_list_t {
pub number: ::std::os::raw::c_ulong,
pub size: ::std::os::raw::c_ulong,
pub data: *mut sigar_net_route_t,
}
#[test]
fn bindgen_test_layout_sigar_net_route_list_t() {
assert_eq!(
::std::mem::size_of::<sigar_net_route_list_t>(),
24usize,
concat!("Size of: ", stringify!(sigar_net_route_list_t))
);
assert_eq!(
::std::mem::align_of::<sigar_net_route_list_t>(),
8usize,
concat!("Alignment of ", stringify!(sigar_net_route_list_t))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<sigar_net_route_list_t>())).number as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(sigar_net_route_list_t),
"::",
stringify!(number)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<sigar_net_route_list_t>())).size as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(sigar_net_route_list_t),
"::",
stringify!(size)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<sigar_net_route_list_t>())).data as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(sigar_net_route_list_t),
"::",
stringify!(data)
)
);
}
impl Default for sigar_net_route_list_t {
fn default() -> Self {
unsafe { ::std::mem::zeroed() }
}
}
extern "C" {
pub fn sigar_net_route_list_get(
sigar: *mut sigar_t,
routelist: *mut sigar_net_route_list_t,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn sigar_net_route_list_destroy(
sigar: *mut sigar_t,
routelist: *mut sigar_net_route_list_t,
) -> ::std::os::raw::c_int;
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct sigar_net_interface_config_t {
pub name: [::std::os::raw::c_char; 256usize],
pub type_: [::std::os::raw::c_char; 64usize],
pub description: [::std::os::raw::c_char; 256usize],
pub hwaddr: sigar_net_address_t,
pub address: sigar_net_address_t,
pub destination: sigar_net_address_t,
pub broadcast: sigar_net_address_t,
pub netmask: sigar_net_address_t,
pub address6: sigar_net_address_t,
pub prefix6_length: ::std::os::raw::c_int,
pub scope6: ::std::os::raw::c_int,
pub flags: sigar_uint64_t,
pub mtu: sigar_uint64_t,
pub metric: sigar_uint64_t,
pub tx_queue_len: ::std::os::raw::c_int,
}
#[test]
fn bindgen_test_layout_sigar_net_interface_config_t() {
assert_eq!(
::std::mem::size_of::<sigar_net_interface_config_t>(),
736usize,
concat!("Size of: ", stringify!(sigar_net_interface_config_t))
);
assert_eq!(
::std::mem::align_of::<sigar_net_interface_config_t>(),
8usize,
concat!("Alignment of ", stringify!(sigar_net_interface_config_t))
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<sigar_net_interface_config_t>())).name as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(sigar_net_interface_config_t),
"::",
stringify!(name)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<sigar_net_interface_config_t>())).type_ as *const _ as usize
},
256usize,
concat!(
"Offset of field: ",
stringify!(sigar_net_interface_config_t),
"::",
stringify!(type_)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<sigar_net_interface_config_t>())).description as *const _
as usize
},
320usize,
concat!(
"Offset of field: ",
stringify!(sigar_net_interface_config_t),
"::",
stringify!(description)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<sigar_net_interface_config_t>())).hwaddr as *const _ as usize
},
576usize,
concat!(
"Offset of field: ",
stringify!(sigar_net_interface_config_t),
"::",
stringify!(hwaddr)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<sigar_net_interface_config_t>())).address as *const _ as usize
},
596usize,
concat!(
"Offset of field: ",
stringify!(sigar_net_interface_config_t),
"::",
stringify!(address)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<sigar_net_interface_config_t>())).destination as *const _
as usize
},
616usize,
concat!(
"Offset of field: ",
stringify!(sigar_net_interface_config_t),
"::",
stringify!(destination)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<sigar_net_interface_config_t>())).broadcast as *const _ as usize
},
636usize,
concat!(
"Offset of field: ",
stringify!(sigar_net_interface_config_t),
"::",
stringify!(broadcast)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<sigar_net_interface_config_t>())).netmask as *const _ as usize
},
656usize,
concat!(
"Offset of field: ",
stringify!(sigar_net_interface_config_t),
"::",
stringify!(netmask)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<sigar_net_interface_config_t>())).address6 as *const _ as usize
},
676usize,
concat!(
"Offset of field: ",
stringify!(sigar_net_interface_config_t),
"::",
stringify!(address6)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<sigar_net_interface_config_t>())).prefix6_length as *const _
as usize
},
696usize,
concat!(
"Offset of field: ",
stringify!(sigar_net_interface_config_t),
"::",
stringify!(prefix6_length)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<sigar_net_interface_config_t>())).scope6 as *const _ as usize
},
700usize,
concat!(
"Offset of field: ",
stringify!(sigar_net_interface_config_t),
"::",
stringify!(scope6)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<sigar_net_interface_config_t>())).flags as *const _ as usize
},
704usize,
concat!(
"Offset of field: ",
stringify!(sigar_net_interface_config_t),
"::",
stringify!(flags)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<sigar_net_interface_config_t>())).mtu as *const _ as usize
},
712usize,
concat!(
"Offset of field: ",
stringify!(sigar_net_interface_config_t),
"::",
stringify!(mtu)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<sigar_net_interface_config_t>())).metric as *const _ as usize
},
720usize,
concat!(
"Offset of field: ",
stringify!(sigar_net_interface_config_t),
"::",
stringify!(metric)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<sigar_net_interface_config_t>())).tx_queue_len as *const _
as usize
},
728usize,
concat!(
"Offset of field: ",
stringify!(sigar_net_interface_config_t),
"::",
stringify!(tx_queue_len)
)
);
}
impl Default for sigar_net_interface_config_t {
fn default() -> Self {
unsafe { ::std::mem::zeroed() }
}
}
extern "C" {
pub fn sigar_net_interface_config_get(
sigar: *mut sigar_t,
name: *const ::std::os::raw::c_char,
ifconfig: *mut sigar_net_interface_config_t,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn sigar_net_interface_config_primary_get(
sigar: *mut sigar_t,
ifconfig: *mut sigar_net_interface_config_t,
) -> ::std::os::raw::c_int;
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct sigar_net_interface_stat_t {
pub rx_packets: sigar_uint64_t,
pub rx_bytes: sigar_uint64_t,
pub rx_errors: sigar_uint64_t,
pub rx_dropped: sigar_uint64_t,
pub rx_overruns: sigar_uint64_t,
pub rx_frame: sigar_uint64_t,
pub tx_packets: sigar_uint64_t,
pub tx_bytes: sigar_uint64_t,
pub tx_errors: sigar_uint64_t,
pub tx_dropped: sigar_uint64_t,
pub tx_overruns: sigar_uint64_t,
pub tx_collisions: sigar_uint64_t,
pub tx_carrier: sigar_uint64_t,
pub speed: sigar_uint64_t,
}
#[test]
fn bindgen_test_layout_sigar_net_interface_stat_t() {
assert_eq!(
::std::mem::size_of::<sigar_net_interface_stat_t>(),
112usize,
concat!("Size of: ", stringify!(sigar_net_interface_stat_t))
);
assert_eq!(
::std::mem::align_of::<sigar_net_interface_stat_t>(),
8usize,
concat!("Alignment of ", stringify!(sigar_net_interface_stat_t))
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<sigar_net_interface_stat_t>())).rx_packets as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(sigar_net_interface_stat_t),
"::",
stringify!(rx_packets)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<sigar_net_interface_stat_t>())).rx_bytes as *const _ as usize
},
8usize,
concat!(
"Offset of field: ",
stringify!(sigar_net_interface_stat_t),
"::",
stringify!(rx_bytes)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<sigar_net_interface_stat_t>())).rx_errors as *const _ as usize
},
16usize,
concat!(
"Offset of field: ",
stringify!(sigar_net_interface_stat_t),
"::",
stringify!(rx_errors)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<sigar_net_interface_stat_t>())).rx_dropped as *const _ as usize
},
24usize,
concat!(
"Offset of field: ",
stringify!(sigar_net_interface_stat_t),
"::",
stringify!(rx_dropped)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<sigar_net_interface_stat_t>())).rx_overruns as *const _ as usize
},
32usize,
concat!(
"Offset of field: ",
stringify!(sigar_net_interface_stat_t),
"::",
stringify!(rx_overruns)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<sigar_net_interface_stat_t>())).rx_frame as *const _ as usize
},
40usize,
concat!(
"Offset of field: ",
stringify!(sigar_net_interface_stat_t),
"::",
stringify!(rx_frame)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<sigar_net_interface_stat_t>())).tx_packets as *const _ as usize
},
48usize,
concat!(
"Offset of field: ",
stringify!(sigar_net_interface_stat_t),
"::",
stringify!(tx_packets)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<sigar_net_interface_stat_t>())).tx_bytes as *const _ as usize
},
56usize,
concat!(
"Offset of field: ",
stringify!(sigar_net_interface_stat_t),
"::",
stringify!(tx_bytes)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<sigar_net_interface_stat_t>())).tx_errors as *const _ as usize
},
64usize,
concat!(
"Offset of field: ",
stringify!(sigar_net_interface_stat_t),
"::",
stringify!(tx_errors)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<sigar_net_interface_stat_t>())).tx_dropped as *const _ as usize
},
72usize,
concat!(
"Offset of field: ",
stringify!(sigar_net_interface_stat_t),
"::",
stringify!(tx_dropped)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<sigar_net_interface_stat_t>())).tx_overruns as *const _ as usize
},
80usize,
concat!(
"Offset of field: ",
stringify!(sigar_net_interface_stat_t),
"::",
stringify!(tx_overruns)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<sigar_net_interface_stat_t>())).tx_collisions as *const _
as usize
},
88usize,
concat!(
"Offset of field: ",
stringify!(sigar_net_interface_stat_t),
"::",
stringify!(tx_collisions)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<sigar_net_interface_stat_t>())).tx_carrier as *const _ as usize
},
96usize,
concat!(
"Offset of field: ",
stringify!(sigar_net_interface_stat_t),
"::",
stringify!(tx_carrier)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<sigar_net_interface_stat_t>())).speed as *const _ as usize
},
104usize,
concat!(
"Offset of field: ",
stringify!(sigar_net_interface_stat_t),
"::",
stringify!(speed)
)
);
}
extern "C" {
pub fn sigar_net_interface_stat_get(
sigar: *mut sigar_t,
name: *const ::std::os::raw::c_char,
ifstat: *mut sigar_net_interface_stat_t,
) -> ::std::os::raw::c_int;
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct sigar_net_interface_list_t {
pub number: ::std::os::raw::c_ulong,
pub size: ::std::os::raw::c_ulong,
pub data: *mut *mut ::std::os::raw::c_char,
}
#[test]
fn bindgen_test_layout_sigar_net_interface_list_t() {
assert_eq!(
::std::mem::size_of::<sigar_net_interface_list_t>(),
24usize,
concat!("Size of: ", stringify!(sigar_net_interface_list_t))
);
assert_eq!(
::std::mem::align_of::<sigar_net_interface_list_t>(),
8usize,
concat!("Alignment of ", stringify!(sigar_net_interface_list_t))
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<sigar_net_interface_list_t>())).number as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(sigar_net_interface_list_t),
"::",
stringify!(number)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<sigar_net_interface_list_t>())).size as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(sigar_net_interface_list_t),
"::",
stringify!(size)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<sigar_net_interface_list_t>())).data as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(sigar_net_interface_list_t),
"::",
stringify!(data)
)
);
}
impl Default for sigar_net_interface_list_t {
fn default() -> Self {
unsafe { ::std::mem::zeroed() }
}
}
extern "C" {
pub fn sigar_net_interface_list_get(
sigar: *mut sigar_t,
iflist: *mut sigar_net_interface_list_t,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn sigar_net_interface_list_destroy(
sigar: *mut sigar_t,
iflist: *mut sigar_net_interface_list_t,
) -> ::std::os::raw::c_int;
}
pub const SIGAR_TCP_ESTABLISHED: _bindgen_ty_1 = 1;
pub const SIGAR_TCP_SYN_SENT: _bindgen_ty_1 = 2;
pub const SIGAR_TCP_SYN_RECV: _bindgen_ty_1 = 3;
pub const SIGAR_TCP_FIN_WAIT1: _bindgen_ty_1 = 4;
pub const SIGAR_TCP_FIN_WAIT2: _bindgen_ty_1 = 5;
pub const SIGAR_TCP_TIME_WAIT: _bindgen_ty_1 = 6;
pub const SIGAR_TCP_CLOSE: _bindgen_ty_1 = 7;
pub const SIGAR_TCP_CLOSE_WAIT: _bindgen_ty_1 = 8;
pub const SIGAR_TCP_LAST_ACK: _bindgen_ty_1 = 9;
pub const SIGAR_TCP_LISTEN: _bindgen_ty_1 = 10;
pub const SIGAR_TCP_CLOSING: _bindgen_ty_1 = 11;
pub const SIGAR_TCP_IDLE: _bindgen_ty_1 = 12;
pub const SIGAR_TCP_BOUND: _bindgen_ty_1 = 13;
pub const SIGAR_TCP_UNKNOWN: _bindgen_ty_1 = 14;
pub type _bindgen_ty_1 = u32;
#[repr(C)]
#[derive(Copy, Clone)]
pub struct sigar_net_connection_t {
pub local_port: ::std::os::raw::c_ulong,
pub local_address: sigar_net_address_t,
pub remote_port: ::std::os::raw::c_ulong,
pub remote_address: sigar_net_address_t,
pub uid: sigar_uid_t,
pub inode: ::std::os::raw::c_ulong,
pub type_: ::std::os::raw::c_int,
pub state: ::std::os::raw::c_int,
pub send_queue: ::std::os::raw::c_ulong,
pub receive_queue: ::std::os::raw::c_ulong,
}
#[test]
fn bindgen_test_layout_sigar_net_connection_t() {
assert_eq!(
::std::mem::size_of::<sigar_net_connection_t>(),
96usize,
concat!("Size of: ", stringify!(sigar_net_connection_t))
);
assert_eq!(
::std::mem::align_of::<sigar_net_connection_t>(),
8usize,
concat!("Alignment of ", stringify!(sigar_net_connection_t))
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<sigar_net_connection_t>())).local_port as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(sigar_net_connection_t),
"::",
stringify!(local_port)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<sigar_net_connection_t>())).local_address as *const _ as usize
},
8usize,
concat!(
"Offset of field: ",
stringify!(sigar_net_connection_t),
"::",
stringify!(local_address)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<sigar_net_connection_t>())).remote_port as *const _ as usize
},
32usize,
concat!(
"Offset of field: ",
stringify!(sigar_net_connection_t),
"::",
stringify!(remote_port)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<sigar_net_connection_t>())).remote_address as *const _ as usize
},
40usize,
concat!(
"Offset of field: ",
stringify!(sigar_net_connection_t),
"::",
stringify!(remote_address)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<sigar_net_connection_t>())).uid as *const _ as usize },
60usize,
concat!(
"Offset of field: ",
stringify!(sigar_net_connection_t),
"::",
stringify!(uid)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<sigar_net_connection_t>())).inode as *const _ as usize },
64usize,
concat!(
"Offset of field: ",
stringify!(sigar_net_connection_t),
"::",
stringify!(inode)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<sigar_net_connection_t>())).type_ as *const _ as usize },
72usize,
concat!(
"Offset of field: ",
stringify!(sigar_net_connection_t),
"::",
stringify!(type_)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<sigar_net_connection_t>())).state as *const _ as usize },
76usize,
concat!(
"Offset of field: ",
stringify!(sigar_net_connection_t),
"::",
stringify!(state)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<sigar_net_connection_t>())).send_queue as *const _ as usize
},
80usize,
concat!(
"Offset of field: ",
stringify!(sigar_net_connection_t),
"::",
stringify!(send_queue)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<sigar_net_connection_t>())).receive_queue as *const _ as usize
},
88usize,
concat!(
"Offset of field: ",
stringify!(sigar_net_connection_t),
"::",
stringify!(receive_queue)
)
);
}
impl Default for sigar_net_connection_t {
fn default() -> Self {
unsafe { ::std::mem::zeroed() }
}
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct sigar_net_connection_list_t {
pub number: ::std::os::raw::c_ulong,
pub size: ::std::os::raw::c_ulong,
pub data: *mut sigar_net_connection_t,
}
#[test]
fn bindgen_test_layout_sigar_net_connection_list_t() {
assert_eq!(
::std::mem::size_of::<sigar_net_connection_list_t>(),
24usize,
concat!("Size of: ", stringify!(sigar_net_connection_list_t))
);
assert_eq!(
::std::mem::align_of::<sigar_net_connection_list_t>(),
8usize,
concat!("Alignment of ", stringify!(sigar_net_connection_list_t))
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<sigar_net_connection_list_t>())).number as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(sigar_net_connection_list_t),
"::",
stringify!(number)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<sigar_net_connection_list_t>())).size as *const _ as usize
},
8usize,
concat!(
"Offset of field: ",
stringify!(sigar_net_connection_list_t),
"::",
stringify!(size)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<sigar_net_connection_list_t>())).data as *const _ as usize
},
16usize,
concat!(
"Offset of field: ",
stringify!(sigar_net_connection_list_t),
"::",
stringify!(data)
)
);
}
impl Default for sigar_net_connection_list_t {
fn default() -> Self {
unsafe { ::std::mem::zeroed() }
}
}
extern "C" {
pub fn sigar_net_connection_list_get(
sigar: *mut sigar_t,
connlist: *mut sigar_net_connection_list_t,
flags: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn sigar_net_connection_list_destroy(
sigar: *mut sigar_t,
connlist: *mut sigar_net_connection_list_t,
) -> ::std::os::raw::c_int;
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct sigar_net_connection_walker_t {
pub sigar: *mut sigar_t,
pub flags: ::std::os::raw::c_int,
pub data: *mut ::std::os::raw::c_void,
pub add_connection: ::std::option::Option<
unsafe extern "C" fn(
walker: *mut sigar_net_connection_walker_t,
connection: *mut sigar_net_connection_t,
) -> ::std::os::raw::c_int,
>,
}
#[test]
fn bindgen_test_layout_sigar_net_connection_walker_t() {
assert_eq!(
::std::mem::size_of::<sigar_net_connection_walker_t>(),
32usize,
concat!("Size of: ", stringify!(sigar_net_connection_walker_t))
);
assert_eq!(
::std::mem::align_of::<sigar_net_connection_walker_t>(),
8usize,
concat!("Alignment of ", stringify!(sigar_net_connection_walker_t))
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<sigar_net_connection_walker_t>())).sigar as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(sigar_net_connection_walker_t),
"::",
stringify!(sigar)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<sigar_net_connection_walker_t>())).flags as *const _ as usize
},
8usize,
concat!(
"Offset of field: ",
stringify!(sigar_net_connection_walker_t),
"::",
stringify!(flags)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<sigar_net_connection_walker_t>())).data as *const _ as usize
},
16usize,
concat!(
"Offset of field: ",
stringify!(sigar_net_connection_walker_t),
"::",
stringify!(data)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<sigar_net_connection_walker_t>())).add_connection as *const _
as usize
},
24usize,
concat!(
"Offset of field: ",
stringify!(sigar_net_connection_walker_t),
"::",
stringify!(add_connection)
)
);
}
impl Default for sigar_net_connection_walker_t {
fn default() -> Self {
unsafe { ::std::mem::zeroed() }
}
}
extern "C" {
pub fn sigar_net_connection_walk(
walker: *mut sigar_net_connection_walker_t,
) -> ::std::os::raw::c_int;
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct sigar_net_stat_t {
pub tcp_states: [::std::os::raw::c_int; 14usize],
pub tcp_inbound_total: sigar_uint32_t,
pub tcp_outbound_total: sigar_uint32_t,
pub all_inbound_total: sigar_uint32_t,
pub all_outbound_total: sigar_uint32_t,
}
#[test]
fn bindgen_test_layout_sigar_net_stat_t() {
assert_eq!(
::std::mem::size_of::<sigar_net_stat_t>(),
72usize,
concat!("Size of: ", stringify!(sigar_net_stat_t))
);
assert_eq!(
::std::mem::align_of::<sigar_net_stat_t>(),
4usize,
concat!("Alignment of ", stringify!(sigar_net_stat_t))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<sigar_net_stat_t>())).tcp_states as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(sigar_net_stat_t),
"::",
stringify!(tcp_states)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<sigar_net_stat_t>())).tcp_inbound_total as *const _ as usize
},
56usize,
concat!(
"Offset of field: ",
stringify!(sigar_net_stat_t),
"::",
stringify!(tcp_inbound_total)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<sigar_net_stat_t>())).tcp_outbound_total as *const _ as usize
},
60usize,
concat!(
"Offset of field: ",
stringify!(sigar_net_stat_t),
"::",
stringify!(tcp_outbound_total)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<sigar_net_stat_t>())).all_inbound_total as *const _ as usize
},
64usize,
concat!(
"Offset of field: ",
stringify!(sigar_net_stat_t),
"::",
stringify!(all_inbound_total)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<sigar_net_stat_t>())).all_outbound_total as *const _ as usize
},
68usize,
concat!(
"Offset of field: ",
stringify!(sigar_net_stat_t),
"::",
stringify!(all_outbound_total)
)
);
}
extern "C" {
pub fn sigar_net_stat_get(
sigar: *mut sigar_t,
netstat: *mut sigar_net_stat_t,
flags: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn sigar_net_stat_port_get(
sigar: *mut sigar_t,
netstat: *mut sigar_net_stat_t,
flags: ::std::os::raw::c_int,
address: *mut sigar_net_address_t,
port: ::std::os::raw::c_ulong,
) -> ::std::os::raw::c_int;
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct sigar_tcp_t {
pub active_opens: sigar_uint64_t,
pub passive_opens: sigar_uint64_t,
pub attempt_fails: sigar_uint64_t,
pub estab_resets: sigar_uint64_t,
pub curr_estab: sigar_uint64_t,
pub in_segs: sigar_uint64_t,
pub out_segs: sigar_uint64_t,
pub retrans_segs: sigar_uint64_t,
pub in_errs: sigar_uint64_t,
pub out_rsts: sigar_uint64_t,
}
#[test]
fn bindgen_test_layout_sigar_tcp_t() {
assert_eq!(
::std::mem::size_of::<sigar_tcp_t>(),
80usize,
concat!("Size of: ", stringify!(sigar_tcp_t))
);
assert_eq!(
::std::mem::align_of::<sigar_tcp_t>(),
8usize,
concat!("Alignment of ", stringify!(sigar_tcp_t))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<sigar_tcp_t>())).active_opens as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(sigar_tcp_t),
"::",
stringify!(active_opens)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<sigar_tcp_t>())).passive_opens as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(sigar_tcp_t),
"::",
stringify!(passive_opens)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<sigar_tcp_t>())).attempt_fails as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(sigar_tcp_t),
"::",
stringify!(attempt_fails)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<sigar_tcp_t>())).estab_resets as *const _ as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(sigar_tcp_t),
"::",
stringify!(estab_resets)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<sigar_tcp_t>())).curr_estab as *const _ as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(sigar_tcp_t),
"::",
stringify!(curr_estab)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<sigar_tcp_t>())).in_segs as *const _ as usize },
40usize,
concat!(
"Offset of field: ",
stringify!(sigar_tcp_t),
"::",
stringify!(in_segs)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<sigar_tcp_t>())).out_segs as *const _ as usize },
48usize,
concat!(
"Offset of field: ",
stringify!(sigar_tcp_t),
"::",
stringify!(out_segs)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<sigar_tcp_t>())).retrans_segs as *const _ as usize },
56usize,
concat!(
"Offset of field: ",
stringify!(sigar_tcp_t),
"::",
stringify!(retrans_segs)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<sigar_tcp_t>())).in_errs as *const _ as usize },
64usize,
concat!(
"Offset of field: ",
stringify!(sigar_tcp_t),
"::",
stringify!(in_errs)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<sigar_tcp_t>())).out_rsts as *const _ as usize },
72usize,
concat!(
"Offset of field: ",
stringify!(sigar_tcp_t),
"::",
stringify!(out_rsts)
)
);
}
extern "C" {
pub fn sigar_tcp_get(sigar: *mut sigar_t, tcp: *mut sigar_tcp_t) -> ::std::os::raw::c_int;
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct sigar_nfs_v2_t {
pub null: sigar_uint64_t,
pub getattr: sigar_uint64_t,
pub setattr: sigar_uint64_t,
pub root: sigar_uint64_t,
pub lookup: sigar_uint64_t,
pub readlink: sigar_uint64_t,
pub read: sigar_uint64_t,
pub writecache: sigar_uint64_t,
pub write: sigar_uint64_t,
pub create: sigar_uint64_t,
pub remove: sigar_uint64_t,
pub rename: sigar_uint64_t,
pub link: sigar_uint64_t,
pub symlink: sigar_uint64_t,
pub mkdir: sigar_uint64_t,
pub rmdir: sigar_uint64_t,
pub readdir: sigar_uint64_t,
pub fsstat: sigar_uint64_t,
}
#[test]
fn bindgen_test_layout_sigar_nfs_v2_t() {
assert_eq!(
::std::mem::size_of::<sigar_nfs_v2_t>(),
144usize,
concat!("Size of: ", stringify!(sigar_nfs_v2_t))
);
assert_eq!(
::std::mem::align_of::<sigar_nfs_v2_t>(),
8usize,
concat!("Alignment of ", stringify!(sigar_nfs_v2_t))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<sigar_nfs_v2_t>())).null as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(sigar_nfs_v2_t),
"::",
stringify!(null)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<sigar_nfs_v2_t>())).getattr as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(sigar_nfs_v2_t),
"::",
stringify!(getattr)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<sigar_nfs_v2_t>())).setattr as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(sigar_nfs_v2_t),
"::",
stringify!(setattr)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<sigar_nfs_v2_t>())).root as *const _ as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(sigar_nfs_v2_t),
"::",
stringify!(root)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<sigar_nfs_v2_t>())).lookup as *const _ as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(sigar_nfs_v2_t),
"::",
stringify!(lookup)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<sigar_nfs_v2_t>())).readlink as *const _ as usize },
40usize,
concat!(
"Offset of field: ",
stringify!(sigar_nfs_v2_t),
"::",
stringify!(readlink)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<sigar_nfs_v2_t>())).read as *const _ as usize },
48usize,
concat!(
"Offset of field: ",
stringify!(sigar_nfs_v2_t),
"::",
stringify!(read)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<sigar_nfs_v2_t>())).writecache as *const _ as usize },
56usize,
concat!(
"Offset of field: ",
stringify!(sigar_nfs_v2_t),
"::",
stringify!(writecache)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<sigar_nfs_v2_t>())).write as *const _ as usize },
64usize,
concat!(
"Offset of field: ",
stringify!(sigar_nfs_v2_t),
"::",
stringify!(write)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<sigar_nfs_v2_t>())).create as *const _ as usize },
72usize,
concat!(
"Offset of field: ",
stringify!(sigar_nfs_v2_t),
"::",
stringify!(create)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<sigar_nfs_v2_t>())).remove as *const _ as usize },
80usize,
concat!(
"Offset of field: ",
stringify!(sigar_nfs_v2_t),
"::",
stringify!(remove)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<sigar_nfs_v2_t>())).rename as *const _ as usize },
88usize,
concat!(
"Offset of field: ",
stringify!(sigar_nfs_v2_t),
"::",
stringify!(rename)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<sigar_nfs_v2_t>())).link as *const _ as usize },
96usize,
concat!(
"Offset of field: ",
stringify!(sigar_nfs_v2_t),
"::",
stringify!(link)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<sigar_nfs_v2_t>())).symlink as *const _ as usize },
104usize,
concat!(
"Offset of field: ",
stringify!(sigar_nfs_v2_t),
"::",
stringify!(symlink)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<sigar_nfs_v2_t>())).mkdir as *const _ as usize },
112usize,
concat!(
"Offset of field: ",
stringify!(sigar_nfs_v2_t),
"::",
stringify!(mkdir)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<sigar_nfs_v2_t>())).rmdir as *const _ as usize },
120usize,
concat!(
"Offset of field: ",
stringify!(sigar_nfs_v2_t),
"::",
stringify!(rmdir)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<sigar_nfs_v2_t>())).readdir as *const _ as usize },
128usize,
concat!(
"Offset of field: ",
stringify!(sigar_nfs_v2_t),
"::",
stringify!(readdir)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<sigar_nfs_v2_t>())).fsstat as *const _ as usize },
136usize,
concat!(
"Offset of field: ",
stringify!(sigar_nfs_v2_t),
"::",
stringify!(fsstat)
)
);
}
pub type sigar_nfs_client_v2_t = sigar_nfs_v2_t;
pub type sigar_nfs_server_v2_t = sigar_nfs_v2_t;
extern "C" {
pub fn sigar_nfs_client_v2_get(
sigar: *mut sigar_t,
nfs: *mut sigar_nfs_client_v2_t,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn sigar_nfs_server_v2_get(
sigar: *mut sigar_t,
nfs: *mut sigar_nfs_server_v2_t,
) -> ::std::os::raw::c_int;
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct sigar_nfs_v3_t {
pub null: sigar_uint64_t,
pub getattr: sigar_uint64_t,
pub setattr: sigar_uint64_t,
pub lookup: sigar_uint64_t,
pub access: sigar_uint64_t,
pub readlink: sigar_uint64_t,
pub read: sigar_uint64_t,
pub write: sigar_uint64_t,
pub create: sigar_uint64_t,
pub mkdir: sigar_uint64_t,
pub symlink: sigar_uint64_t,
pub mknod: sigar_uint64_t,
pub remove: sigar_uint64_t,
pub rmdir: sigar_uint64_t,
pub rename: sigar_uint64_t,
pub link: sigar_uint64_t,
pub readdir: sigar_uint64_t,
pub readdirplus: sigar_uint64_t,
pub fsstat: sigar_uint64_t,
pub fsinfo: sigar_uint64_t,
pub pathconf: sigar_uint64_t,
pub commit: sigar_uint64_t,
}
#[test]
fn bindgen_test_layout_sigar_nfs_v3_t() {
assert_eq!(
::std::mem::size_of::<sigar_nfs_v3_t>(),
176usize,
concat!("Size of: ", stringify!(sigar_nfs_v3_t))
);
assert_eq!(
::std::mem::align_of::<sigar_nfs_v3_t>(),
8usize,
concat!("Alignment of ", stringify!(sigar_nfs_v3_t))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<sigar_nfs_v3_t>())).null as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(sigar_nfs_v3_t),
"::",
stringify!(null)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<sigar_nfs_v3_t>())).getattr as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(sigar_nfs_v3_t),
"::",
stringify!(getattr)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<sigar_nfs_v3_t>())).setattr as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(sigar_nfs_v3_t),
"::",
stringify!(setattr)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<sigar_nfs_v3_t>())).lookup as *const _ as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(sigar_nfs_v3_t),
"::",
stringify!(lookup)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<sigar_nfs_v3_t>())).access as *const _ as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(sigar_nfs_v3_t),
"::",
stringify!(access)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<sigar_nfs_v3_t>())).readlink as *const _ as usize },
40usize,
concat!(
"Offset of field: ",
stringify!(sigar_nfs_v3_t),
"::",
stringify!(readlink)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<sigar_nfs_v3_t>())).read as *const _ as usize },
48usize,
concat!(
"Offset of field: ",
stringify!(sigar_nfs_v3_t),
"::",
stringify!(read)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<sigar_nfs_v3_t>())).write as *const _ as usize },
56usize,
concat!(
"Offset of field: ",
stringify!(sigar_nfs_v3_t),
"::",
stringify!(write)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<sigar_nfs_v3_t>())).create as *const _ as usize },
64usize,
concat!(
"Offset of field: ",
stringify!(sigar_nfs_v3_t),
"::",
stringify!(create)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<sigar_nfs_v3_t>())).mkdir as *const _ as usize },
72usize,
concat!(
"Offset of field: ",
stringify!(sigar_nfs_v3_t),
"::",
stringify!(mkdir)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<sigar_nfs_v3_t>())).symlink as *const _ as usize },
80usize,
concat!(
"Offset of field: ",
stringify!(sigar_nfs_v3_t),
"::",
stringify!(symlink)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<sigar_nfs_v3_t>())).mknod as *const _ as usize },
88usize,
concat!(
"Offset of field: ",
stringify!(sigar_nfs_v3_t),
"::",
stringify!(mknod)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<sigar_nfs_v3_t>())).remove as *const _ as usize },
96usize,
concat!(
"Offset of field: ",
stringify!(sigar_nfs_v3_t),
"::",
stringify!(remove)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<sigar_nfs_v3_t>())).rmdir as *const _ as usize },
104usize,
concat!(
"Offset of field: ",
stringify!(sigar_nfs_v3_t),
"::",
stringify!(rmdir)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<sigar_nfs_v3_t>())).rename as *const _ as usize },
112usize,
concat!(
"Offset of field: ",
stringify!(sigar_nfs_v3_t),
"::",
stringify!(rename)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<sigar_nfs_v3_t>())).link as *const _ as usize },
120usize,
concat!(
"Offset of field: ",
stringify!(sigar_nfs_v3_t),
"::",
stringify!(link)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<sigar_nfs_v3_t>())).readdir as *const _ as usize },
128usize,
concat!(
"Offset of field: ",
stringify!(sigar_nfs_v3_t),
"::",
stringify!(readdir)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<sigar_nfs_v3_t>())).readdirplus as *const _ as usize },
136usize,
concat!(
"Offset of field: ",
stringify!(sigar_nfs_v3_t),
"::",
stringify!(readdirplus)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<sigar_nfs_v3_t>())).fsstat as *const _ as usize },
144usize,
concat!(
"Offset of field: ",
stringify!(sigar_nfs_v3_t),
"::",
stringify!(fsstat)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<sigar_nfs_v3_t>())).fsinfo as *const _ as usize },
152usize,
concat!(
"Offset of field: ",
stringify!(sigar_nfs_v3_t),
"::",
stringify!(fsinfo)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<sigar_nfs_v3_t>())).pathconf as *const _ as usize },
160usize,
concat!(
"Offset of field: ",
stringify!(sigar_nfs_v3_t),
"::",
stringify!(pathconf)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<sigar_nfs_v3_t>())).commit as *const _ as usize },
168usize,
concat!(
"Offset of field: ",
stringify!(sigar_nfs_v3_t),
"::",
stringify!(commit)
)
);
}
pub type sigar_nfs_client_v3_t = sigar_nfs_v3_t;
pub type sigar_nfs_server_v3_t = sigar_nfs_v3_t;
extern "C" {
pub fn sigar_nfs_client_v3_get(
sigar: *mut sigar_t,
nfs: *mut sigar_nfs_client_v3_t,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn sigar_nfs_server_v3_get(
sigar: *mut sigar_t,
nfs: *mut sigar_nfs_server_v3_t,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn sigar_net_listen_address_get(
sigar: *mut sigar_t,
port: ::std::os::raw::c_ulong,
address: *mut sigar_net_address_t,
) -> ::std::os::raw::c_int;
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct sigar_arp_t {
pub ifname: [::std::os::raw::c_char; 256usize],
pub type_: [::std::os::raw::c_char; 64usize],
pub hwaddr: sigar_net_address_t,
pub address: sigar_net_address_t,
pub flags: sigar_uint64_t,
}
#[test]
fn bindgen_test_layout_sigar_arp_t() {
assert_eq!(
::std::mem::size_of::<sigar_arp_t>(),
368usize,
concat!("Size of: ", stringify!(sigar_arp_t))
);
assert_eq!(
::std::mem::align_of::<sigar_arp_t>(),
8usize,
concat!("Alignment of ", stringify!(sigar_arp_t))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<sigar_arp_t>())).ifname as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(sigar_arp_t),
"::",
stringify!(ifname)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<sigar_arp_t>())).type_ as *const _ as usize },
256usize,
concat!(
"Offset of field: ",
stringify!(sigar_arp_t),
"::",
stringify!(type_)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<sigar_arp_t>())).hwaddr as *const _ as usize },
320usize,
concat!(
"Offset of field: ",
stringify!(sigar_arp_t),
"::",
stringify!(hwaddr)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<sigar_arp_t>())).address as *const _ as usize },
340usize,
concat!(
"Offset of field: ",
stringify!(sigar_arp_t),
"::",
stringify!(address)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<sigar_arp_t>())).flags as *const _ as usize },
360usize,
concat!(
"Offset of field: ",
stringify!(sigar_arp_t),
"::",
stringify!(flags)
)
);
}
impl Default for sigar_arp_t {
fn default() -> Self {
unsafe { ::std::mem::zeroed() }
}
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct sigar_arp_list_t {
pub number: ::std::os::raw::c_ulong,
pub size: ::std::os::raw::c_ulong,
pub data: *mut sigar_arp_t,
}
#[test]
fn bindgen_test_layout_sigar_arp_list_t() {
assert_eq!(
::std::mem::size_of::<sigar_arp_list_t>(),
24usize,
concat!("Size of: ", stringify!(sigar_arp_list_t))
);
assert_eq!(
::std::mem::align_of::<sigar_arp_list_t>(),
8usize,
concat!("Alignment of ", stringify!(sigar_arp_list_t))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<sigar_arp_list_t>())).number as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(sigar_arp_list_t),
"::",
stringify!(number)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<sigar_arp_list_t>())).size as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(sigar_arp_list_t),
"::",
stringify!(size)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<sigar_arp_list_t>())).data as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(sigar_arp_list_t),
"::",
stringify!(data)
)
);
}
impl Default for sigar_arp_list_t {
fn default() -> Self {
unsafe { ::std::mem::zeroed() }
}
}
extern "C" {
pub fn sigar_arp_list_get(
sigar: *mut sigar_t,
arplist: *mut sigar_arp_list_t,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn sigar_arp_list_destroy(
sigar: *mut sigar_t,
arplist: *mut sigar_arp_list_t,
) -> ::std::os::raw::c_int;
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct sigar_who_t {
pub user: [::std::os::raw::c_char; 32usize],
pub device: [::std::os::raw::c_char; 32usize],
pub host: [::std::os::raw::c_char; 256usize],
pub time: sigar_uint64_t,
}
#[test]
fn bindgen_test_layout_sigar_who_t() {
assert_eq!(
::std::mem::size_of::<sigar_who_t>(),
328usize,
concat!("Size of: ", stringify!(sigar_who_t))
);
assert_eq!(
::std::mem::align_of::<sigar_who_t>(),
8usize,
concat!("Alignment of ", stringify!(sigar_who_t))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<sigar_who_t>())).user as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(sigar_who_t),
"::",
stringify!(user)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<sigar_who_t>())).device as *const _ as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(sigar_who_t),
"::",
stringify!(device)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<sigar_who_t>())).host as *const _ as usize },
64usize,
concat!(
"Offset of field: ",
stringify!(sigar_who_t),
"::",
stringify!(host)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<sigar_who_t>())).time as *const _ as usize },
320usize,
concat!(
"Offset of field: ",
stringify!(sigar_who_t),
"::",
stringify!(time)
)
);
}
impl Default for sigar_who_t {
fn default() -> Self {
unsafe { ::std::mem::zeroed() }
}
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct sigar_who_list_t {
pub number: ::std::os::raw::c_ulong,
pub size: ::std::os::raw::c_ulong,
pub data: *mut sigar_who_t,
}
#[test]
fn bindgen_test_layout_sigar_who_list_t() {
assert_eq!(
::std::mem::size_of::<sigar_who_list_t>(),
24usize,
concat!("Size of: ", stringify!(sigar_who_list_t))
);
assert_eq!(
::std::mem::align_of::<sigar_who_list_t>(),
8usize,
concat!("Alignment of ", stringify!(sigar_who_list_t))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<sigar_who_list_t>())).number as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(sigar_who_list_t),
"::",
stringify!(number)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<sigar_who_list_t>())).size as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(sigar_who_list_t),
"::",
stringify!(size)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<sigar_who_list_t>())).data as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(sigar_who_list_t),
"::",
stringify!(data)
)
);
}
impl Default for sigar_who_list_t {
fn default() -> Self {
unsafe { ::std::mem::zeroed() }
}
}
extern "C" {
pub fn sigar_who_list_get(
sigar: *mut sigar_t,
wholist: *mut sigar_who_list_t,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn sigar_who_list_destroy(
sigar: *mut sigar_t,
wholist: *mut sigar_who_list_t,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn sigar_proc_port_get(
sigar: *mut sigar_t,
protocol: ::std::os::raw::c_int,
port: ::std::os::raw::c_ulong,
pid: *mut sigar_pid_t,
) -> ::std::os::raw::c_int;
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct sigar_version_t {
pub build_date: *const ::std::os::raw::c_char,
pub scm_revision: *const ::std::os::raw::c_char,
pub version: *const ::std::os::raw::c_char,
pub archname: *const ::std::os::raw::c_char,
pub archlib: *const ::std::os::raw::c_char,
pub binname: *const ::std::os::raw::c_char,
pub description: *const ::std::os::raw::c_char,
pub major: ::std::os::raw::c_int,
pub minor: ::std::os::raw::c_int,
pub maint: ::std::os::raw::c_int,
pub build: ::std::os::raw::c_int,
}
#[test]
fn bindgen_test_layout_sigar_version_t() {
assert_eq!(
::std::mem::size_of::<sigar_version_t>(),
72usize,
concat!("Size of: ", stringify!(sigar_version_t))
);
assert_eq!(
::std::mem::align_of::<sigar_version_t>(),
8usize,
concat!("Alignment of ", stringify!(sigar_version_t))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<sigar_version_t>())).build_date as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(sigar_version_t),
"::",
stringify!(build_date)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<sigar_version_t>())).scm_revision as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(sigar_version_t),
"::",
stringify!(scm_revision)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<sigar_version_t>())).version as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(sigar_version_t),
"::",
stringify!(version)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<sigar_version_t>())).archname as *const _ as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(sigar_version_t),
"::",
stringify!(archname)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<sigar_version_t>())).archlib as *const _ as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(sigar_version_t),
"::",
stringify!(archlib)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<sigar_version_t>())).binname as *const _ as usize },
40usize,
concat!(
"Offset of field: ",
stringify!(sigar_version_t),
"::",
stringify!(binname)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<sigar_version_t>())).description as *const _ as usize },
48usize,
concat!(
"Offset of field: ",
stringify!(sigar_version_t),
"::",
stringify!(description)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<sigar_version_t>())).major as *const _ as usize },
56usize,
concat!(
"Offset of field: ",
stringify!(sigar_version_t),
"::",
stringify!(major)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<sigar_version_t>())).minor as *const _ as usize },
60usize,
concat!(
"Offset of field: ",
stringify!(sigar_version_t),
"::",
stringify!(minor)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<sigar_version_t>())).maint as *const _ as usize },
64usize,
concat!(
"Offset of field: ",
stringify!(sigar_version_t),
"::",
stringify!(maint)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<sigar_version_t>())).build as *const _ as usize },
68usize,
concat!(
"Offset of field: ",
stringify!(sigar_version_t),
"::",
stringify!(build)
)
);
}
impl Default for sigar_version_t {
fn default() -> Self {
unsafe { ::std::mem::zeroed() }
}
}
extern "C" {
pub fn sigar_version_get() -> *mut sigar_version_t;
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct sigar_sys_info_t {
pub name: [::std::os::raw::c_char; 256usize],
pub version: [::std::os::raw::c_char; 256usize],
pub arch: [::std::os::raw::c_char; 256usize],
pub machine: [::std::os::raw::c_char; 256usize],
pub description: [::std::os::raw::c_char; 256usize],
pub patch_level: [::std::os::raw::c_char; 256usize],
pub vendor: [::std::os::raw::c_char; 256usize],
pub vendor_version: [::std::os::raw::c_char; 256usize],
pub vendor_name: [::std::os::raw::c_char; 256usize],
pub vendor_code_name: [::std::os::raw::c_char; 256usize],
}
#[test]
fn bindgen_test_layout_sigar_sys_info_t() {
assert_eq!(
::std::mem::size_of::<sigar_sys_info_t>(),
2560usize,
concat!("Size of: ", stringify!(sigar_sys_info_t))
);
assert_eq!(
::std::mem::align_of::<sigar_sys_info_t>(),
1usize,
concat!("Alignment of ", stringify!(sigar_sys_info_t))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<sigar_sys_info_t>())).name as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(sigar_sys_info_t),
"::",
stringify!(name)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<sigar_sys_info_t>())).version as *const _ as usize },
256usize,
concat!(
"Offset of field: ",
stringify!(sigar_sys_info_t),
"::",
stringify!(version)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<sigar_sys_info_t>())).arch as *const _ as usize },
512usize,
concat!(
"Offset of field: ",
stringify!(sigar_sys_info_t),
"::",
stringify!(arch)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<sigar_sys_info_t>())).machine as *const _ as usize },
768usize,
concat!(
"Offset of field: ",
stringify!(sigar_sys_info_t),
"::",
stringify!(machine)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<sigar_sys_info_t>())).description as *const _ as usize },
1024usize,
concat!(
"Offset of field: ",
stringify!(sigar_sys_info_t),
"::",
stringify!(description)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<sigar_sys_info_t>())).patch_level as *const _ as usize },
1280usize,
concat!(
"Offset of field: ",
stringify!(sigar_sys_info_t),
"::",
stringify!(patch_level)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<sigar_sys_info_t>())).vendor as *const _ as usize },
1536usize,
concat!(
"Offset of field: ",
stringify!(sigar_sys_info_t),
"::",
stringify!(vendor)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<sigar_sys_info_t>())).vendor_version as *const _ as usize },
1792usize,
concat!(
"Offset of field: ",
stringify!(sigar_sys_info_t),
"::",
stringify!(vendor_version)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<sigar_sys_info_t>())).vendor_name as *const _ as usize },
2048usize,
concat!(
"Offset of field: ",
stringify!(sigar_sys_info_t),
"::",
stringify!(vendor_name)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<sigar_sys_info_t>())).vendor_code_name as *const _ as usize
},
2304usize,
concat!(
"Offset of field: ",
stringify!(sigar_sys_info_t),
"::",
stringify!(vendor_code_name)
)
);
}
impl Default for sigar_sys_info_t {
fn default() -> Self {
unsafe { ::std::mem::zeroed() }
}
}
extern "C" {
pub fn sigar_sys_info_get(
sigar: *mut sigar_t,
sysinfo: *mut sigar_sys_info_t,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn sigar_fqdn_get(
sigar: *mut sigar_t,
name: *mut ::std::os::raw::c_char,
namelen: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn sigar_rpc_ping(
hostname: *mut ::std::os::raw::c_char,
protocol: ::std::os::raw::c_int,
program: ::std::os::raw::c_ulong,
version: ::std::os::raw::c_ulong,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn sigar_rpc_strerror(err: ::std::os::raw::c_int) -> *mut ::std::os::raw::c_char;
}
pub const sigar_file_type_e_SIGAR_FILETYPE_NOFILE: sigar_file_type_e = 0;
pub const sigar_file_type_e_SIGAR_FILETYPE_REG: sigar_file_type_e = 1;
pub const sigar_file_type_e_SIGAR_FILETYPE_DIR: sigar_file_type_e = 2;
pub const sigar_file_type_e_SIGAR_FILETYPE_CHR: sigar_file_type_e = 3;
pub const sigar_file_type_e_SIGAR_FILETYPE_BLK: sigar_file_type_e = 4;
pub const sigar_file_type_e_SIGAR_FILETYPE_PIPE: sigar_file_type_e = 5;
pub const sigar_file_type_e_SIGAR_FILETYPE_LNK: sigar_file_type_e = 6;
pub const sigar_file_type_e_SIGAR_FILETYPE_SOCK: sigar_file_type_e = 7;
pub const sigar_file_type_e_SIGAR_FILETYPE_UNKFILE: sigar_file_type_e = 8;
pub type sigar_file_type_e = u32;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct sigar_file_attrs_t {
pub permissions: sigar_uint64_t,
pub type_: sigar_file_type_e,
pub uid: sigar_uid_t,
pub gid: sigar_gid_t,
pub inode: sigar_uint64_t,
pub device: sigar_uint64_t,
pub nlink: sigar_uint64_t,
pub size: sigar_uint64_t,
pub atime: sigar_uint64_t,
pub mtime: sigar_uint64_t,
pub ctime: sigar_uint64_t,
}
#[test]
fn bindgen_test_layout_sigar_file_attrs_t() {
assert_eq!(
::std::mem::size_of::<sigar_file_attrs_t>(),
80usize,
concat!("Size of: ", stringify!(sigar_file_attrs_t))
);
assert_eq!(
::std::mem::align_of::<sigar_file_attrs_t>(),
8usize,
concat!("Alignment of ", stringify!(sigar_file_attrs_t))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<sigar_file_attrs_t>())).permissions as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(sigar_file_attrs_t),
"::",
stringify!(permissions)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<sigar_file_attrs_t>())).type_ as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(sigar_file_attrs_t),
"::",
stringify!(type_)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<sigar_file_attrs_t>())).uid as *const _ as usize },
12usize,
concat!(
"Offset of field: ",
stringify!(sigar_file_attrs_t),
"::",
stringify!(uid)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<sigar_file_attrs_t>())).gid as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(sigar_file_attrs_t),
"::",
stringify!(gid)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<sigar_file_attrs_t>())).inode as *const _ as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(sigar_file_attrs_t),
"::",
stringify!(inode)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<sigar_file_attrs_t>())).device as *const _ as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(sigar_file_attrs_t),
"::",
stringify!(device)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<sigar_file_attrs_t>())).nlink as *const _ as usize },
40usize,
concat!(
"Offset of field: ",
stringify!(sigar_file_attrs_t),
"::",
stringify!(nlink)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<sigar_file_attrs_t>())).size as *const _ as usize },
48usize,
concat!(
"Offset of field: ",
stringify!(sigar_file_attrs_t),
"::",
stringify!(size)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<sigar_file_attrs_t>())).atime as *const _ as usize },
56usize,
concat!(
"Offset of field: ",
stringify!(sigar_file_attrs_t),
"::",
stringify!(atime)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<sigar_file_attrs_t>())).mtime as *const _ as usize },
64usize,
concat!(
"Offset of field: ",
stringify!(sigar_file_attrs_t),
"::",
stringify!(mtime)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<sigar_file_attrs_t>())).ctime as *const _ as usize },
72usize,
concat!(
"Offset of field: ",
stringify!(sigar_file_attrs_t),
"::",
stringify!(ctime)
)
);
}
impl Default for sigar_file_attrs_t {
fn default() -> Self {
unsafe { ::std::mem::zeroed() }
}
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct sigar_dir_stat_t {
pub total: sigar_uint64_t,
pub files: sigar_uint64_t,
pub subdirs: sigar_uint64_t,
pub symlinks: sigar_uint64_t,
pub chrdevs: sigar_uint64_t,
pub blkdevs: sigar_uint64_t,
pub sockets: sigar_uint64_t,
pub disk_usage: sigar_uint64_t,
}
#[test]
fn bindgen_test_layout_sigar_dir_stat_t() {
assert_eq!(
::std::mem::size_of::<sigar_dir_stat_t>(),
64usize,
concat!("Size of: ", stringify!(sigar_dir_stat_t))
);
assert_eq!(
::std::mem::align_of::<sigar_dir_stat_t>(),
8usize,
concat!("Alignment of ", stringify!(sigar_dir_stat_t))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<sigar_dir_stat_t>())).total as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(sigar_dir_stat_t),
"::",
stringify!(total)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<sigar_dir_stat_t>())).files as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(sigar_dir_stat_t),
"::",
stringify!(files)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<sigar_dir_stat_t>())).subdirs as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(sigar_dir_stat_t),
"::",
stringify!(subdirs)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<sigar_dir_stat_t>())).symlinks as *const _ as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(sigar_dir_stat_t),
"::",
stringify!(symlinks)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<sigar_dir_stat_t>())).chrdevs as *const _ as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(sigar_dir_stat_t),
"::",
stringify!(chrdevs)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<sigar_dir_stat_t>())).blkdevs as *const _ as usize },
40usize,
concat!(
"Offset of field: ",
stringify!(sigar_dir_stat_t),
"::",
stringify!(blkdevs)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<sigar_dir_stat_t>())).sockets as *const _ as usize },
48usize,
concat!(
"Offset of field: ",
stringify!(sigar_dir_stat_t),
"::",
stringify!(sockets)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<sigar_dir_stat_t>())).disk_usage as *const _ as usize },
56usize,
concat!(
"Offset of field: ",
stringify!(sigar_dir_stat_t),
"::",
stringify!(disk_usage)
)
);
}
pub type sigar_dir_usage_t = sigar_dir_stat_t;
extern "C" {
pub fn sigar_file_attrs_type_string_get(
type_: sigar_file_type_e,
) -> *const ::std::os::raw::c_char;
}
extern "C" {
pub fn sigar_file_attrs_get(
sigar: *mut sigar_t,
file: *const ::std::os::raw::c_char,
fileattrs: *mut sigar_file_attrs_t,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn sigar_link_attrs_get(
sigar: *mut sigar_t,
file: *const ::std::os::raw::c_char,
fileattrs: *mut sigar_file_attrs_t,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn sigar_file_attrs_mode_get(permissions: sigar_uint64_t) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn sigar_file_attrs_permissions_string_get(
permissions: sigar_uint64_t,
str: *mut ::std::os::raw::c_char,
) -> *mut ::std::os::raw::c_char;
}
extern "C" {
pub fn sigar_dir_stat_get(
sigar: *mut sigar_t,
dir: *const ::std::os::raw::c_char,
dirstats: *mut sigar_dir_stat_t,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn sigar_dir_usage_get(
sigar: *mut sigar_t,
dir: *const ::std::os::raw::c_char,
dirusage: *mut sigar_dir_usage_t,
) -> ::std::os::raw::c_int;
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct sigar_cpu_perc_t {
pub user: f64,
pub sys: f64,
pub nice: f64,
pub idle: f64,
pub wait: f64,
pub irq: f64,
pub soft_irq: f64,
pub stolen: f64,
pub combined: f64,
}
#[test]
fn bindgen_test_layout_sigar_cpu_perc_t() {
assert_eq!(
::std::mem::size_of::<sigar_cpu_perc_t>(),
72usize,
concat!("Size of: ", stringify!(sigar_cpu_perc_t))
);
assert_eq!(
::std::mem::align_of::<sigar_cpu_perc_t>(),
8usize,
concat!("Alignment of ", stringify!(sigar_cpu_perc_t))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<sigar_cpu_perc_t>())).user as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(sigar_cpu_perc_t),
"::",
stringify!(user)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<sigar_cpu_perc_t>())).sys as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(sigar_cpu_perc_t),
"::",
stringify!(sys)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<sigar_cpu_perc_t>())).nice as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(sigar_cpu_perc_t),
"::",
stringify!(nice)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<sigar_cpu_perc_t>())).idle as *const _ as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(sigar_cpu_perc_t),
"::",
stringify!(idle)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<sigar_cpu_perc_t>())).wait as *const _ as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(sigar_cpu_perc_t),
"::",
stringify!(wait)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<sigar_cpu_perc_t>())).irq as *const _ as usize },
40usize,
concat!(
"Offset of field: ",
stringify!(sigar_cpu_perc_t),
"::",
stringify!(irq)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<sigar_cpu_perc_t>())).soft_irq as *const _ as usize },
48usize,
concat!(
"Offset of field: ",
stringify!(sigar_cpu_perc_t),
"::",
stringify!(soft_irq)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<sigar_cpu_perc_t>())).stolen as *const _ as usize },
56usize,
concat!(
"Offset of field: ",
stringify!(sigar_cpu_perc_t),
"::",
stringify!(stolen)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<sigar_cpu_perc_t>())).combined as *const _ as usize },
64usize,
concat!(
"Offset of field: ",
stringify!(sigar_cpu_perc_t),
"::",
stringify!(combined)
)
);
}
extern "C" {
pub fn sigar_cpu_perc_calculate(
prev: *mut sigar_cpu_t,
curr: *mut sigar_cpu_t,
perc: *mut sigar_cpu_perc_t,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn sigar_uptime_string(
sigar: *mut sigar_t,
uptime: *mut sigar_uptime_t,
buffer: *mut ::std::os::raw::c_char,
buflen: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn sigar_format_size(
size: sigar_uint64_t,
buf: *mut ::std::os::raw::c_char,
) -> *mut ::std::os::raw::c_char;
}
extern "C" {
pub fn sigar_net_address_equals(
addr1: *mut sigar_net_address_t,
addr2: *mut sigar_net_address_t,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn sigar_net_address_to_string(
sigar: *mut sigar_t,
address: *mut sigar_net_address_t,
addr_str: *mut ::std::os::raw::c_char,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn sigar_net_scope_to_string(type_: ::std::os::raw::c_int)
-> *const ::std::os::raw::c_char;
}
extern "C" {
pub fn sigar_net_address_hash(address: *mut sigar_net_address_t) -> sigar_uint32_t;
}
extern "C" {
pub fn sigar_net_connection_type_get(
type_: ::std::os::raw::c_int,
) -> *const ::std::os::raw::c_char;
}
extern "C" {
pub fn sigar_net_connection_state_get(
state: ::std::os::raw::c_int,
) -> *const ::std::os::raw::c_char;
}
extern "C" {
pub fn sigar_net_interface_flags_to_string(
flags: sigar_uint64_t,
buf: *mut ::std::os::raw::c_char,
) -> *mut ::std::os::raw::c_char;
}
extern "C" {
pub fn sigar_net_services_name_get(
sigar: *mut sigar_t,
protocol: ::std::os::raw::c_int,
port: ::std::os::raw::c_ulong,
) -> *mut ::std::os::raw::c_char;
}
pub type va_list = __builtin_va_list;
pub type __gnuc_va_list = __builtin_va_list;
pub type sigar_log_impl_t = ::std::option::Option<
unsafe extern "C" fn(
arg1: *mut sigar_t,
arg2: *mut ::std::os::raw::c_void,
arg3: ::std::os::raw::c_int,
arg4: *mut ::std::os::raw::c_char,
),
>;
extern "C" {
pub fn sigar_log_printf(
sigar: *mut sigar_t,
level: ::std::os::raw::c_int,
format: *const ::std::os::raw::c_char,
...
);
}
extern "C" {
pub fn sigar_log(
sigar: *mut sigar_t,
level: ::std::os::raw::c_int,
message: *mut ::std::os::raw::c_char,
);
}
extern "C" {
pub fn sigar_log_impl_set(
sigar: *mut sigar_t,
data: *mut ::std::os::raw::c_void,
impl_: sigar_log_impl_t,
);
}
extern "C" {
pub fn sigar_log_impl_file(
sigar: *mut sigar_t,
data: *mut ::std::os::raw::c_void,
level: ::std::os::raw::c_int,
message: *mut ::std::os::raw::c_char,
);
}
extern "C" {
pub fn sigar_log_level_get(sigar: *mut sigar_t) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn sigar_log_level_set(sigar: *mut sigar_t, level: ::std::os::raw::c_int);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct sigar_ptql_query_t {
_unused: [u8; 0],
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct sigar_ptql_error_t {
pub message: [::std::os::raw::c_char; 1024usize],
}
#[test]
fn bindgen_test_layout_sigar_ptql_error_t() {
assert_eq!(
::std::mem::size_of::<sigar_ptql_error_t>(),
1024usize,
concat!("Size of: ", stringify!(sigar_ptql_error_t))
);
assert_eq!(
::std::mem::align_of::<sigar_ptql_error_t>(),
1usize,
concat!("Alignment of ", stringify!(sigar_ptql_error_t))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<sigar_ptql_error_t>())).message as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(sigar_ptql_error_t),
"::",
stringify!(message)
)
);
}
impl Default for sigar_ptql_error_t {
fn default() -> Self {
unsafe { ::std::mem::zeroed() }
}
}
pub type sigar_ptql_re_impl_t = ::std::option::Option<
unsafe extern "C" fn(
arg1: *mut ::std::os::raw::c_void,
arg2: *mut ::std::os::raw::c_char,
arg3: *mut ::std::os::raw::c_char,
) -> ::std::os::raw::c_int,
>;
extern "C" {
pub fn sigar_ptql_re_impl_set(
sigar: *mut sigar_t,
data: *mut ::std::os::raw::c_void,
impl_: sigar_ptql_re_impl_t,
);
}
extern "C" {
pub fn sigar_ptql_query_create(
query: *mut *mut sigar_ptql_query_t,
ptql: *mut ::std::os::raw::c_char,
error: *mut sigar_ptql_error_t,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn sigar_ptql_query_match(
sigar: *mut sigar_t,
query: *mut sigar_ptql_query_t,
pid: sigar_pid_t,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn sigar_ptql_query_destroy(query: *mut sigar_ptql_query_t) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn sigar_ptql_query_find_process(
sigar: *mut sigar_t,
query: *mut sigar_ptql_query_t,
pid: *mut sigar_pid_t,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn sigar_ptql_query_find(
sigar: *mut sigar_t,
query: *mut sigar_ptql_query_t,
proclist: *mut sigar_proc_list_t,
) -> ::std::os::raw::c_int;
}
pub type __builtin_va_list = [__va_list_tag; 1usize];
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct __va_list_tag {
pub gp_offset: ::std::os::raw::c_uint,
pub fp_offset: ::std::os::raw::c_uint,
pub overflow_arg_area: *mut ::std::os::raw::c_void,
pub reg_save_area: *mut ::std::os::raw::c_void,
}
#[test]
fn bindgen_test_layout___va_list_tag() {
assert_eq!(
::std::mem::size_of::<__va_list_tag>(),
24usize,
concat!("Size of: ", stringify!(__va_list_tag))
);
assert_eq!(
::std::mem::align_of::<__va_list_tag>(),
8usize,
concat!("Alignment of ", stringify!(__va_list_tag))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<__va_list_tag>())).gp_offset as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(__va_list_tag),
"::",
stringify!(gp_offset)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<__va_list_tag>())).fp_offset as *const _ as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(__va_list_tag),
"::",
stringify!(fp_offset)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<__va_list_tag>())).overflow_arg_area as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(__va_list_tag),
"::",
stringify!(overflow_arg_area)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<__va_list_tag>())).reg_save_area as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(__va_list_tag),
"::",
stringify!(reg_save_area)
)
);
}
impl Default for __va_list_tag {
fn default() -> Self {
unsafe { ::std::mem::zeroed() }
}
}