perfrecord-mach-ipc-rendezvous-0.2.1/.cargo_vcs_info.json0000644000000001120000000000100170420ustar { "git": { "sha1": "72c628979c843e1b0cdf4132348a7826e41cb31b" } } perfrecord-mach-ipc-rendezvous-0.2.1/.gitignore000064400000000000000000000000230072674642500176530ustar 00000000000000/target Cargo.lock perfrecord-mach-ipc-rendezvous-0.2.1/Cargo.toml0000644000000020310000000000100150420ustar # THIS FILE IS AUTOMATICALLY GENERATED BY CARGO # # When uploading crates to the registry Cargo will automatically # "normalize" Cargo.toml files for maximal compatibility # with all versions of Cargo and also rewrite `path` dependencies # to registry (e.g., crates.io) dependencies. # # If you are reading this file be aware that the original Cargo.toml # will likely look very different (and much more reasonable). # See Cargo.toml.orig for the original contents. [package] edition = "2018" name = "perfrecord-mach-ipc-rendezvous" version = "0.2.1" authors = ["The Servo Project Developers", "Markus Stange "] description = "A subset of the ipc-channel mach functionality to establish two-way communication and exchange the mach_task_self port." homepage = "https://github.com/mstange/perfrecord/" readme = "README.md" license = "MIT/Apache-2.0" repository = "https://github.com/mstange/perfrecord/" [dependencies.lazy_static] version = "1.4.0" [dependencies.libc] version = "0.2.70" [dependencies.rand] version = "0.8.4" perfrecord-mach-ipc-rendezvous-0.2.1/Cargo.toml.orig000064400000000000000000000010170072674642500205560ustar 00000000000000[package] name = "perfrecord-mach-ipc-rendezvous" version = "0.2.1" description = "A subset of the ipc-channel mach functionality to establish two-way communication and exchange the mach_task_self port." homepage = "https://github.com/mstange/perfrecord/" repository = "https://github.com/mstange/perfrecord/" readme = "README.md" authors = ["The Servo Project Developers", "Markus Stange "] license = "MIT/Apache-2.0" edition = "2018" [dependencies] libc = "0.2.70" rand = "0.8.4" lazy_static = "1.4.0" perfrecord-mach-ipc-rendezvous-0.2.1/Readme.md000064400000000000000000000011100072674642500174000ustar 00000000000000# perfrecord-mach-ipc-rendzvous This crate has some code that allows establishing two-way mach communication between a parent process and a child process. This code was originally written by pcwalton for ipc-channel. I needed some extra functionality to be able to send raw ports, namely `mach_task_self()`, so I forked the code. I may also remove large pieces of functionality that I don't need, so that the size of the perfrecord-preload library gets reduced. This is a separate crate, rather than just a mod inside perfrecord, so that it can also be used by perfrecord-preload. perfrecord-mach-ipc-rendezvous-0.2.1/src/lib.rs000064400000000000000000001371560072674642500176100ustar 00000000000000// Copyright 2015 The Servo Project Developers. See the COPYRIGHT // file at the top-level directory of this distribution. // // Licensed under the Apache License, Version 2.0 or the MIT license // , at your // option. This file may not be copied, modified, or distributed // except according to those terms. use self::mach_sys::mach_port_deallocate; use self::mach_sys::{kern_return_t, mach_msg_body_t, mach_msg_header_t, mach_msg_return_t}; use self::mach_sys::{mach_msg_ool_descriptor_t, mach_msg_port_descriptor_t, mach_msg_type_name_t}; use self::mach_sys::{mach_msg_timeout_t, mach_port_limits_t, mach_port_msgcount_t}; use self::mach_sys::{mach_port_right_t, mach_task_self_, vm_inherit_t}; pub use self::mach_sys::mach_port_t; use lazy_static::lazy_static; use libc::{self, c_char, c_uint, c_void, size_t}; use rand::{self, Rng}; use std::cell::Cell; use std::ffi::CString; use std::fmt::{self, Debug, Formatter}; use std::io::{Error, ErrorKind}; use std::marker::PhantomData; use std::mem; use std::ops::Deref; use std::ptr; use std::slice; use std::sync::RwLock; use std::time::Duration; use std::usize; mod mach_sys; /// The size that we preallocate on the stack to receive messages. If the message is larger than /// this, we retry and spill to the heap. const SMALL_MESSAGE_SIZE: usize = 4096; /// A string to prepend to our bootstrap ports. static BOOTSTRAP_PREFIX: &'static str = "org.rust-lang.ipc-channel."; pub const MACH_PORT_NULL: mach_port_t = 0; const BOOTSTRAP_NAME_IN_USE: kern_return_t = 1101; const BOOTSTRAP_SUCCESS: kern_return_t = 0; const KERN_NOT_IN_SET: kern_return_t = 12; const KERN_INVALID_NAME: kern_return_t = 15; const KERN_INVALID_RIGHT: kern_return_t = 17; const KERN_INVALID_VALUE: kern_return_t = 18; const KERN_UREFS_OVERFLOW: kern_return_t = 19; const KERN_INVALID_CAPABILITY: kern_return_t = 20; const KERN_SUCCESS: kern_return_t = 0; const KERN_NO_SPACE: kern_return_t = 3; const MACH_MSGH_BITS_COMPLEX: u32 = 0x80000000; const MACH_MSG_IPC_KERNEL: kern_return_t = 0x00000800; const MACH_MSG_IPC_SPACE: kern_return_t = 0x00002000; const MACH_MSG_OOL_DESCRIPTOR: u8 = 1; const MACH_MSG_PORT_DESCRIPTOR: u8 = 0; const MACH_MSG_SUCCESS: kern_return_t = 0; const MACH_MSG_TIMEOUT_NONE: mach_msg_timeout_t = 0; const MACH_MSG_TYPE_COPY_SEND: u8 = 19; const MACH_MSG_TYPE_MAKE_SEND: u8 = 20; const MACH_MSG_TYPE_MAKE_SEND_ONCE: u8 = 21; const MACH_MSG_TYPE_MOVE_RECEIVE: u8 = 16; const MACH_MSG_TYPE_MOVE_SEND: u8 = 17; const MACH_MSG_TYPE_PORT_SEND: u8 = MACH_MSG_TYPE_MOVE_SEND; const MACH_MSG_VIRTUAL_COPY: c_uint = 1; const MACH_MSG_VM_KERNEL: kern_return_t = 0x00000400; const MACH_MSG_VM_SPACE: kern_return_t = 0x00001000; const MACH_NOTIFY_FIRST: i32 = 64; const MACH_NOTIFY_NO_SENDERS: i32 = MACH_NOTIFY_FIRST + 6; const MACH_PORT_LIMITS_INFO: i32 = 1; const MACH_PORT_QLIMIT_LARGE: mach_port_msgcount_t = 1024; const MACH_PORT_QLIMIT_MAX: mach_port_msgcount_t = MACH_PORT_QLIMIT_LARGE; const MACH_PORT_RIGHT_PORT_SET: mach_port_right_t = 3; const MACH_PORT_RIGHT_RECEIVE: mach_port_right_t = 1; const MACH_PORT_RIGHT_SEND: mach_port_right_t = 0; const MACH_RCV_BODY_ERROR: kern_return_t = 0x1000400c; const MACH_RCV_HEADER_ERROR: kern_return_t = 0x1000400b; const MACH_RCV_INTERRUPTED: kern_return_t = 0x10004005; const MACH_RCV_INVALID_DATA: kern_return_t = 0x10004008; const MACH_RCV_INVALID_NAME: kern_return_t = 0x10004002; const MACH_RCV_INVALID_NOTIFY: kern_return_t = 0x10004007; const MACH_RCV_INVALID_TRAILER: kern_return_t = 0x1000400f; const MACH_RCV_INVALID_TYPE: kern_return_t = 0x1000400d; const MACH_RCV_IN_PROGRESS: kern_return_t = 0x10004001; const MACH_RCV_IN_PROGRESS_TIMED: kern_return_t = 0x10004011; const MACH_RCV_IN_SET: kern_return_t = 0x1000400a; const MACH_RCV_LARGE: i32 = 4; const MACH_RCV_MSG: i32 = 2; const MACH_RCV_PORT_CHANGED: kern_return_t = 0x10004006; const MACH_RCV_PORT_DIED: kern_return_t = 0x10004009; const MACH_RCV_SCATTER_SMALL: kern_return_t = 0x1000400e; const MACH_RCV_TIMED_OUT: kern_return_t = 0x10004003; const MACH_RCV_TIMEOUT: i32 = 0x100; const MACH_RCV_TOO_LARGE: kern_return_t = 0x10004004; const MACH_SEND_INTERRUPTED: kern_return_t = 0x10000007; const MACH_SEND_INVALID_DATA: kern_return_t = 0x10000002; const MACH_SEND_INVALID_DEST: kern_return_t = 0x10000003; const MACH_SEND_INVALID_HEADER: kern_return_t = 0x10000010; const MACH_SEND_INVALID_MEMORY: kern_return_t = 0x1000000c; const MACH_SEND_INVALID_NOTIFY: kern_return_t = 0x1000000b; const MACH_SEND_INVALID_REPLY: kern_return_t = 0x10000009; const MACH_SEND_INVALID_RIGHT: kern_return_t = 0x1000000a; const MACH_SEND_INVALID_RT_OOL_SIZE: kern_return_t = 0x10000015; const MACH_SEND_INVALID_TRAILER: kern_return_t = 0x10000011; const MACH_SEND_INVALID_TYPE: kern_return_t = 0x1000000f; const MACH_SEND_INVALID_VOUCHER: kern_return_t = 0x10000005; const MACH_SEND_IN_PROGRESS: kern_return_t = 0x10000001; const MACH_SEND_MSG: i32 = 1; const MACH_SEND_MSG_TOO_SMALL: kern_return_t = 0x10000008; const MACH_SEND_NO_BUFFER: kern_return_t = 0x1000000d; const MACH_SEND_TIMED_OUT: kern_return_t = 0x10000004; const MACH_SEND_TOO_LARGE: kern_return_t = 0x1000000e; const TASK_BOOTSTRAP_PORT: i32 = 4; const VM_INHERIT_SHARE: vm_inherit_t = 0; #[allow(non_camel_case_types)] type name_t = *const c_char; pub fn channel() -> Result<(OsIpcSender, OsIpcReceiver), MachError> { let receiver = OsIpcReceiver::new()?; let sender = receiver.sender()?; receiver.request_no_senders_notification()?; Ok((sender, receiver)) } #[derive(PartialEq, Debug)] pub struct OsIpcReceiver { port: Cell, } impl Drop for OsIpcReceiver { fn drop(&mut self) { let port = self.port.get(); if port != MACH_PORT_NULL { mach_port_mod_release(port, MACH_PORT_RIGHT_RECEIVE).unwrap(); } } } fn mach_port_allocate(right: mach_port_right_t) -> Result { let mut port: mach_port_t = 0; let os_result = unsafe { mach_sys::mach_port_allocate(mach_task_self(), right, &mut port) }; if os_result == KERN_SUCCESS { return Ok(port); } Err(os_result.into()) } fn mach_port_mod_addref(port: mach_port_t, right: mach_port_right_t) -> Result<(), KernelError> { let err = unsafe { mach_sys::mach_port_mod_refs(mach_task_self(), port, right, 1) }; if err == KERN_SUCCESS { return Ok(()); } Err(err.into()) } fn mach_port_mod_release(port: mach_port_t, right: mach_port_right_t) -> Result<(), KernelError> { let err = unsafe { mach_sys::mach_port_mod_refs(mach_task_self(), port, right, -1) }; if err == KERN_SUCCESS { return Ok(()); } Err(err.into()) } fn mach_port_move_member(port: mach_port_t, set: mach_port_t) -> Result<(), KernelError> { let error = unsafe { mach_sys::mach_port_move_member(mach_task_self(), port, set) }; if error == KERN_SUCCESS { return Ok(()); } Err(error.into()) } fn mach_port_extract_right( port: mach_port_t, message_type: mach_msg_type_name_t, ) -> Result<(mach_port_t, mach_msg_type_name_t), KernelError> { let (mut right, mut acquired_right) = (0, 0); let error = unsafe { mach_sys::mach_port_extract_right( mach_task_self(), port, message_type, &mut right, &mut acquired_right, ) }; if error == KERN_SUCCESS { return Ok((right, acquired_right)); } Err(error.into()) } impl OsIpcReceiver { fn new() -> Result { let port = mach_port_allocate(MACH_PORT_RIGHT_RECEIVE)?; let limits = mach_port_limits_t { mpl_qlimit: MACH_PORT_QLIMIT_MAX, }; let os_result = unsafe { mach_sys::mach_port_set_attributes( mach_task_self(), port, MACH_PORT_LIMITS_INFO, mem::transmute(&limits), 1, ) }; if os_result == KERN_SUCCESS { Ok(OsIpcReceiver::from_name(port)) } else { Err(KernelError::from(os_result).into()) } } fn from_name(port: mach_port_t) -> OsIpcReceiver { OsIpcReceiver { port: Cell::new(port), } } fn extract_port(&self) -> mach_port_t { let port = self.port.get(); debug_assert!(port != MACH_PORT_NULL); port } fn consume_port(&self) -> mach_port_t { let port = self.extract_port(); self.port.set(MACH_PORT_NULL); port } pub fn consume(&self) -> OsIpcReceiver { OsIpcReceiver::from_name(self.consume_port()) } fn sender(&self) -> Result { let port = self.port.get(); debug_assert!(port != MACH_PORT_NULL); let (right, acquired_right) = mach_port_extract_right(port, MACH_MSG_TYPE_MAKE_SEND as u32)?; debug_assert!(acquired_right == MACH_MSG_TYPE_PORT_SEND as u32); Ok(OsIpcSender::from_name(right)) } fn register_bootstrap_name(&self) -> Result { let port = self.port.get(); debug_assert!(port != MACH_PORT_NULL); unsafe { let mut bootstrap_port = 0; let os_result = mach_sys::task_get_special_port( mach_task_self(), TASK_BOOTSTRAP_PORT, &mut bootstrap_port, ); if os_result != KERN_SUCCESS { return Err(KernelError::from(os_result).into()); } // FIXME(pcwalton): Does this leak? let (right, acquired_right) = mach_port_extract_right(port, MACH_MSG_TYPE_MAKE_SEND as u32)?; debug_assert!(acquired_right == MACH_MSG_TYPE_PORT_SEND as u32); let mut os_result; let mut name; loop { name = format!("{}{}", BOOTSTRAP_PREFIX, rand::thread_rng().gen::()); let c_name = CString::new(name.clone()).unwrap(); os_result = bootstrap_register2(bootstrap_port, c_name.as_ptr(), right, 0); if os_result == BOOTSTRAP_NAME_IN_USE { continue; } if os_result != BOOTSTRAP_SUCCESS { return Err(MachError::from(os_result)); } break; } Ok(name) } } fn unregister_global_name(name: String) -> Result<(), MachError> { unsafe { let mut bootstrap_port = 0; let os_result = mach_sys::task_get_special_port( mach_task_self(), TASK_BOOTSTRAP_PORT, &mut bootstrap_port, ); if os_result != KERN_SUCCESS { return Err(KernelError::from(os_result).into()); } let c_name = CString::new(name).unwrap(); let os_result = bootstrap_register2(bootstrap_port, c_name.as_ptr(), MACH_PORT_NULL, 0); if os_result == BOOTSTRAP_SUCCESS { Ok(()) } else { Err(MachError::from(os_result)) } } } fn request_no_senders_notification(&self) -> Result<(), MachError> { let port = self.port.get(); debug_assert!(port != MACH_PORT_NULL); unsafe { let os_result = mach_sys::mach_port_request_notification( mach_task_self(), port, MACH_NOTIFY_NO_SENDERS, 0, port, MACH_MSG_TYPE_MAKE_SEND_ONCE as u32, &mut 0, ); if os_result != KERN_SUCCESS { return Err(KernelError::from(os_result).into()); } } Ok(()) } pub fn recv_with_blocking_mode( &self, blocking_mode: BlockingMode, ) -> Result<(Vec, Vec, Vec), MachError> { select(self.port.get(), blocking_mode).and_then(|result| match result { OsIpcSelectionResult::DataReceived(_, data, channels, shared_memory_regions) => { Ok((data, channels, shared_memory_regions)) } OsIpcSelectionResult::ChannelClosed(_) => Err(MachError::from(MACH_NOTIFY_NO_SENDERS)), }) } pub fn recv( &self, ) -> Result<(Vec, Vec, Vec), MachError> { self.recv_with_blocking_mode(BlockingMode::Blocking) } pub fn try_recv( &self, ) -> Result<(Vec, Vec, Vec), MachError> { self.recv_with_blocking_mode(BlockingMode::Nonblocking) } } enum SendData<'a> { Inline(&'a [u8]), OutOfLine(Option), } lazy_static! { static ref MAX_INLINE_SIZE: RwLock = RwLock::new(usize::MAX); } impl<'a> From<&'a [u8]> for SendData<'a> { fn from(data: &'a [u8]) -> SendData<'a> { let max_inline_size = *MAX_INLINE_SIZE.read().unwrap(); if data.len() >= max_inline_size { // Convert the data payload into a shared memory region to avoid exceeding // any message size limits. SendData::OutOfLine(Some(OsIpcSharedMemory::from_bytes(data))) } else { SendData::Inline(data) } } } impl<'a> SendData<'a> { fn take_shared_memory(&mut self) -> Option { match *self { SendData::Inline(_) => None, SendData::OutOfLine(ref mut data) => data.take(), } } fn is_inline(&self) -> bool { match *self { SendData::Inline(_) => true, SendData::OutOfLine(_) => false, } } fn inline_data(&self) -> &[u8] { match *self { SendData::Inline(ref data) => data, SendData::OutOfLine(_) => &[], } } } #[derive(PartialEq, Debug)] pub struct OsIpcSender { port: mach_port_t, // Make sure this is `!Sync`, to match `crossbeam_channel::Sender`; and to discourage sharing // references. // // (Rather, senders should just be cloned, as they are shared internally anyway -- // another layer of sharing only adds unnecessary overhead...) nosync_marker: PhantomData>, } impl Drop for OsIpcSender { fn drop(&mut self) { if self.port == MACH_PORT_NULL { return; } // mach_port_deallocate and mach_port_mod_refs are very similar, except that // mach_port_mod_refs returns an error when there are no receivers for the port, // causing the sender port to never be deallocated. mach_port_deallocate handles // this case correctly and is therefore important to avoid dangling port leaks. let err = unsafe { mach_port_deallocate(mach_task_self(), self.port) }; if err != KERN_SUCCESS { panic!("mach_port_deallocate({}) failed: {:?}", self.port, err); } } } impl Clone for OsIpcSender { fn clone(&self) -> OsIpcSender { let mut cloned_port = self.port; if cloned_port != MACH_PORT_NULL { match mach_port_mod_addref(cloned_port, MACH_PORT_RIGHT_SEND) { Ok(()) => (), Err(KernelError::InvalidRight) => cloned_port = MACH_PORT_NULL, Err(error) => panic!("mach_port_mod_refs(1, {}) failed: {:?}", cloned_port, error), } } OsIpcSender { port: cloned_port, nosync_marker: PhantomData, } } } impl OsIpcSender { fn from_name(port: mach_port_t) -> OsIpcSender { OsIpcSender { port: port, nosync_marker: PhantomData, } } pub fn connect(name: String) -> Result { unsafe { let mut bootstrap_port = 0; let os_result = mach_sys::task_get_special_port( mach_task_self(), TASK_BOOTSTRAP_PORT, &mut bootstrap_port, ); if os_result != KERN_SUCCESS { return Err(KernelError::from(os_result).into()); } let mut port = 0; let c_name = CString::new(name).unwrap(); let os_result = bootstrap_look_up(bootstrap_port, c_name.as_ptr(), &mut port); if os_result == BOOTSTRAP_SUCCESS { Ok(OsIpcSender::from_name(port)) } else { Err(MachError::from(os_result)) } } } pub fn get_max_fragment_size() -> usize { usize::MAX } pub fn send( &self, data: &[u8], ports: Vec, mut shared_memory_regions: Vec, ) -> Result<(), MachError> { let mut data = SendData::from(data); if let Some(data) = data.take_shared_memory() { shared_memory_regions.push(data); } unsafe { let size = Message::size_of(&data, ports.len(), shared_memory_regions.len()); let message = libc::malloc(size as size_t) as *mut Message; (*message).header.msgh_bits = (MACH_MSG_TYPE_COPY_SEND as u32) | MACH_MSGH_BITS_COMPLEX; (*message).header.msgh_size = size as u32; (*message).header.msgh_local_port = MACH_PORT_NULL; (*message).header.msgh_remote_port = self.port; (*message).header.msgh_reserved = 0; (*message).header.msgh_id = 0; (*message).body.msgh_descriptor_count = (ports.len() + shared_memory_regions.len()) as u32; let mut port_descriptor_dest = message.offset(1) as *mut mach_msg_port_descriptor_t; for outgoing_port in &ports { (*port_descriptor_dest).name = outgoing_port.port(); (*port_descriptor_dest).pad1 = 0; (*port_descriptor_dest).disposition = match *outgoing_port { OsIpcChannel::Sender(_) => MACH_MSG_TYPE_MOVE_SEND, OsIpcChannel::Receiver(_) => MACH_MSG_TYPE_MOVE_RECEIVE, OsIpcChannel::RawPort(_) => MACH_MSG_TYPE_COPY_SEND, }; (*port_descriptor_dest).type_ = MACH_MSG_PORT_DESCRIPTOR; port_descriptor_dest = port_descriptor_dest.offset(1); } let mut shared_memory_descriptor_dest = port_descriptor_dest as *mut mach_msg_ool_descriptor_t; for shared_memory_region in &shared_memory_regions { (*shared_memory_descriptor_dest).address = shared_memory_region.as_ptr() as *const c_void as *mut c_void; (*shared_memory_descriptor_dest).size = shared_memory_region.len() as u32; (*shared_memory_descriptor_dest).deallocate = 1; (*shared_memory_descriptor_dest).copy = MACH_MSG_VIRTUAL_COPY as u8; (*shared_memory_descriptor_dest).type_ = MACH_MSG_OOL_DESCRIPTOR; shared_memory_descriptor_dest = shared_memory_descriptor_dest.offset(1); } let is_inline_dest = shared_memory_descriptor_dest as *mut bool; *is_inline_dest = data.is_inline(); if data.is_inline() { // Zero out the last word for paranoia's sake. *((message as *mut u8).offset(size as isize - 4) as *mut u32) = 0; let data = data.inline_data(); let data_size = data.len(); let data_size_dest = is_inline_dest.offset(1) as *mut usize; *data_size_dest = data_size; let data_dest = data_size_dest.offset(1) as *mut u8; ptr::copy_nonoverlapping(data.as_ptr(), data_dest, data_size); } let os_result = mach_sys::mach_msg( message as *mut _, MACH_SEND_MSG, (*message).header.msgh_size, 0, MACH_PORT_NULL, MACH_MSG_TIMEOUT_NONE, MACH_PORT_NULL, ); libc::free(message as *mut _); if os_result == MACH_SEND_TOO_LARGE && data.is_inline() { let inline_data = data.inline_data(); { let mut max_inline_size = MAX_INLINE_SIZE.write().unwrap(); let inline_len = inline_data.len(); if inline_len < *max_inline_size { *max_inline_size = inline_len; } } return self.send(inline_data, ports, shared_memory_regions); } if os_result != MACH_MSG_SUCCESS { return Err(MachError::from(os_result)); } for outgoing_port in ports { mem::forget(outgoing_port); } for shared_memory_region in shared_memory_regions { mem::forget(shared_memory_region); } Ok(()) } } } pub enum OsIpcChannel { Sender(OsIpcSender), Receiver(OsIpcReceiver), RawPort(mach_port_t), } impl OsIpcChannel { fn port(&self) -> mach_port_t { match *self { OsIpcChannel::Sender(ref sender) => sender.port, OsIpcChannel::Receiver(ref receiver) => receiver.port.get(), OsIpcChannel::RawPort(ref port) => *port, } } } #[derive(PartialEq, Debug)] pub struct OsOpaqueIpcChannel { port: mach_port_t, } impl Drop for OsOpaqueIpcChannel { fn drop(&mut self) { // Make sure we don't leak! debug_assert!(self.port == MACH_PORT_NULL); } } impl OsOpaqueIpcChannel { fn from_name(name: mach_port_t) -> OsOpaqueIpcChannel { OsOpaqueIpcChannel { port: name } } pub fn to_sender(&mut self) -> OsIpcSender { OsIpcSender { port: mem::replace(&mut self.port, MACH_PORT_NULL), nosync_marker: PhantomData, } } pub fn to_receiver(&mut self) -> OsIpcReceiver { OsIpcReceiver::from_name(mem::replace(&mut self.port, MACH_PORT_NULL)) } pub fn to_port(&mut self) -> mach_port_t { mem::replace(&mut self.port, MACH_PORT_NULL) } } pub struct OsIpcReceiverSet { port: mach_port_t, ports: Vec, } impl OsIpcReceiverSet { pub fn new() -> Result { let port = mach_port_allocate(MACH_PORT_RIGHT_PORT_SET)?; Ok(OsIpcReceiverSet { port: port, ports: vec![], }) } pub fn add(&mut self, receiver: OsIpcReceiver) -> Result { mach_port_move_member(receiver.extract_port(), self.port)?; let receiver_port = receiver.consume_port(); self.ports.push(receiver_port); Ok(receiver_port as u64) } pub fn select(&mut self) -> Result, MachError> { select(self.port, BlockingMode::Blocking).map(|result| vec![result]) } } impl Drop for OsIpcReceiverSet { fn drop(&mut self) { for port in &self.ports { mach_port_mod_release(*port, MACH_PORT_RIGHT_RECEIVE).unwrap(); } mach_port_mod_release(self.port, MACH_PORT_RIGHT_PORT_SET).unwrap(); } } pub enum OsIpcSelectionResult { DataReceived( u64, Vec, Vec, Vec, ), ChannelClosed(u64), } impl OsIpcSelectionResult { pub fn unwrap( self, ) -> ( u64, Vec, Vec, Vec, ) { match self { OsIpcSelectionResult::DataReceived(id, data, channels, shared_memory_regions) => { (id, data, channels, shared_memory_regions) } OsIpcSelectionResult::ChannelClosed(id) => panic!( "OsIpcSelectionResult::unwrap(): receiver ID {} was closed!", id ), } } } #[derive(Copy, Clone)] pub enum BlockingMode { Blocking, BlockingWithTimeout(Duration), Nonblocking, } fn select( port: mach_port_t, blocking_mode: BlockingMode, ) -> Result { debug_assert!(port != MACH_PORT_NULL); unsafe { let mut buffer = [0; SMALL_MESSAGE_SIZE]; let mut allocated_buffer = None; setup_receive_buffer(&mut buffer, port); let mut message = &mut buffer[0] as *mut _ as *mut Message; let (flags, timeout) = match blocking_mode { BlockingMode::Blocking => (MACH_RCV_MSG | MACH_RCV_LARGE, MACH_MSG_TIMEOUT_NONE), BlockingMode::BlockingWithTimeout(dur) => ( MACH_RCV_MSG | MACH_RCV_LARGE | MACH_RCV_TIMEOUT, (dur.as_secs_f32() * 1000.0).round() as u32, ), BlockingMode::Nonblocking => (MACH_RCV_MSG | MACH_RCV_LARGE | MACH_RCV_TIMEOUT, 0), }; match mach_sys::mach_msg( message as *mut _, flags, 0, (*message).header.msgh_size, port, timeout, MACH_PORT_NULL, ) { MACH_RCV_TOO_LARGE => { loop { // the actual size gets written into msgh_size by the kernel let max_trailer_size = mem::size_of::() as mach_sys::mach_msg_size_t; let actual_size = (*message).header.msgh_size + max_trailer_size; allocated_buffer = Some(libc::malloc(actual_size as size_t)); setup_receive_buffer( slice::from_raw_parts_mut( allocated_buffer.unwrap() as *mut u8, actual_size as usize, ), port, ); message = allocated_buffer.unwrap() as *mut Message; match mach_sys::mach_msg( message as *mut _, flags, 0, actual_size, port, timeout, MACH_PORT_NULL, ) { MACH_MSG_SUCCESS => break, MACH_RCV_TOO_LARGE => { libc::free(allocated_buffer.unwrap() as *mut _); continue; } os_result => { libc::free(allocated_buffer.unwrap() as *mut _); return Err(MachError::from(os_result)); } } } } MACH_MSG_SUCCESS => {} os_result => return Err(MachError::from(os_result)), } let local_port = (*message).header.msgh_local_port; if (*message).header.msgh_id == MACH_NOTIFY_NO_SENDERS { return Ok(OsIpcSelectionResult::ChannelClosed(local_port as u64)); } let (mut ports, mut shared_memory_regions) = (Vec::new(), Vec::new()); let mut port_descriptor = message.offset(1) as *mut mach_msg_port_descriptor_t; let mut descriptors_remaining = (*message).body.msgh_descriptor_count; while descriptors_remaining > 0 { if (*port_descriptor).type_ != MACH_MSG_PORT_DESCRIPTOR { break; } ports.push(OsOpaqueIpcChannel::from_name((*port_descriptor).name)); port_descriptor = port_descriptor.offset(1); descriptors_remaining -= 1; } let mut shared_memory_descriptor = port_descriptor as *mut mach_msg_ool_descriptor_t; while descriptors_remaining > 0 { debug_assert!((*shared_memory_descriptor).type_ == MACH_MSG_OOL_DESCRIPTOR); shared_memory_regions.push(OsIpcSharedMemory::from_raw_parts( (*shared_memory_descriptor).address as *mut u8, (*shared_memory_descriptor).size as usize, )); shared_memory_descriptor = shared_memory_descriptor.offset(1); descriptors_remaining -= 1; } let has_inline_data_ptr = shared_memory_descriptor as *mut bool; let has_inline_data = *has_inline_data_ptr; let payload = if has_inline_data { let payload_size_ptr = has_inline_data_ptr.offset(1) as *mut usize; let payload_size = *payload_size_ptr; let max_payload_size = message as usize + ((*message).header.msgh_size as usize) - (shared_memory_descriptor as usize); assert!(payload_size <= max_payload_size); let payload_ptr = payload_size_ptr.offset(1) as *mut u8; slice::from_raw_parts(payload_ptr, payload_size).to_vec() } else { let ool_payload = shared_memory_regions .pop() .expect("Missing OOL shared memory region"); ool_payload.to_vec() }; if let Some(allocated_buffer) = allocated_buffer { libc::free(allocated_buffer) } Ok(OsIpcSelectionResult::DataReceived( local_port as u64, payload, ports, shared_memory_regions, )) } } pub struct OsIpcOneShotServer { receiver: OsIpcReceiver, name: String, } impl Drop for OsIpcOneShotServer { fn drop(&mut self) { drop(OsIpcReceiver::unregister_global_name(mem::replace( &mut self.name, String::new(), ))); } } impl OsIpcOneShotServer { pub fn new() -> Result<(OsIpcOneShotServer, String), MachError> { let receiver = OsIpcReceiver::new()?; let name = receiver.register_bootstrap_name()?; Ok(( OsIpcOneShotServer { receiver: receiver, name: name.clone(), }, name, )) } pub fn accept( self, ) -> Result< ( OsIpcReceiver, Vec, Vec, Vec, ), MachError, > { let (bytes, channels, shared_memory_regions) = self.receiver.recv()?; Ok(( self.receiver.consume(), bytes, channels, shared_memory_regions, )) } } pub struct OsIpcMultiShotServer { receiver: OsIpcReceiver, name: String, } impl Drop for OsIpcMultiShotServer { fn drop(&mut self) { drop(OsIpcReceiver::unregister_global_name(mem::replace( &mut self.name, String::new(), ))); } } impl OsIpcMultiShotServer { pub fn new() -> Result<(OsIpcMultiShotServer, String), MachError> { let receiver = OsIpcReceiver::new()?; let name = receiver.register_bootstrap_name()?; Ok(( OsIpcMultiShotServer { receiver: receiver, name: name.clone(), }, name, )) } pub fn accept( &mut self, blocking_mode: BlockingMode, ) -> Result< ( Vec, Vec, Vec, ), MachError, > { let (bytes, channels, shared_memory_regions) = self.receiver.recv_with_blocking_mode(blocking_mode)?; Ok(( bytes, channels, shared_memory_regions, )) } } pub struct OsIpcSharedMemory { ptr: *mut u8, length: usize, } unsafe impl Send for OsIpcSharedMemory {} unsafe impl Sync for OsIpcSharedMemory {} impl Drop for OsIpcSharedMemory { fn drop(&mut self) { if !self.ptr.is_null() { unsafe { assert!( mach_sys::vm_deallocate(mach_task_self(), self.ptr as usize, self.length) == KERN_SUCCESS ); } } } } impl Clone for OsIpcSharedMemory { fn clone(&self) -> OsIpcSharedMemory { let mut address = 0; unsafe { if !self.ptr.is_null() { let err = mach_sys::vm_remap( mach_task_self(), &mut address, self.length, 0, 1, mach_task_self(), self.ptr as usize, 0, &mut 0, &mut 0, VM_INHERIT_SHARE, ); assert!(err == KERN_SUCCESS); } OsIpcSharedMemory::from_raw_parts(address as *mut u8, self.length) } } } impl PartialEq for OsIpcSharedMemory { fn eq(&self, other: &OsIpcSharedMemory) -> bool { **self == **other } } impl Debug for OsIpcSharedMemory { fn fmt(&self, formatter: &mut Formatter) -> Result<(), fmt::Error> { (**self).fmt(formatter) } } impl Deref for OsIpcSharedMemory { type Target = [u8]; #[inline] fn deref(&self) -> &[u8] { if self.ptr.is_null() && self.length > 0 { panic!("attempted to access a consumed `OsIpcSharedMemory`") } unsafe { slice::from_raw_parts(self.ptr, self.length) } } } impl OsIpcSharedMemory { unsafe fn from_raw_parts(ptr: *mut u8, length: usize) -> OsIpcSharedMemory { OsIpcSharedMemory { ptr: ptr, length: length, } } pub fn from_byte(byte: u8, length: usize) -> OsIpcSharedMemory { unsafe { let address = allocate_vm_pages(length); for element in slice::from_raw_parts_mut(address, length) { *element = byte; } OsIpcSharedMemory::from_raw_parts(address, length) } } pub fn from_bytes(bytes: &[u8]) -> OsIpcSharedMemory { unsafe { let address = allocate_vm_pages(bytes.len()); ptr::copy_nonoverlapping(bytes.as_ptr(), address, bytes.len()); OsIpcSharedMemory::from_raw_parts(address, bytes.len()) } } } unsafe fn allocate_vm_pages(length: usize) -> *mut u8 { let mut address = 0; let result = mach_sys::vm_allocate(mach_task_self(), &mut address, length, 1); if result != KERN_SUCCESS { panic!("`vm_allocate()` failed: {}", result); } address as *mut u8 } unsafe fn setup_receive_buffer(buffer: &mut [u8], port_name: mach_port_t) { let message: *mut mach_msg_header_t = mem::transmute(&buffer[0]); (*message).msgh_local_port = port_name; (*message).msgh_size = buffer.len() as u32 } pub unsafe fn mach_task_self() -> mach_port_t { mach_task_self_ } #[repr(C)] struct Message { header: mach_msg_header_t, body: mach_msg_body_t, } impl Message { fn size_of(data: &SendData, port_length: usize, shared_memory_length: usize) -> usize { let mut size = mem::size_of::() + mem::size_of::() * port_length + mem::size_of::() * shared_memory_length + mem::size_of::(); if data.is_inline() { size += mem::size_of::() + data.inline_data().len(); } // Round up to the next 4 bytes; mach_msg_send returns an error for unaligned sizes. if (size & 0x3) != 0 { size = (size & !0x3) + 4; } size } } #[derive(Clone, Copy, Debug, PartialEq)] pub enum KernelError { Success, NoSpace, InvalidName, InvalidRight, InvalidValue, InvalidCapability, UrefsOverflow, NotInSet, Unknown(kern_return_t), } impl From for KernelError { fn from(code: kern_return_t) -> KernelError { match code { KERN_SUCCESS => KernelError::Success, KERN_NO_SPACE => KernelError::NoSpace, KERN_INVALID_NAME => KernelError::InvalidName, KERN_INVALID_RIGHT => KernelError::InvalidRight, KERN_INVALID_VALUE => KernelError::InvalidValue, KERN_INVALID_CAPABILITY => KernelError::InvalidCapability, KERN_UREFS_OVERFLOW => KernelError::UrefsOverflow, KERN_NOT_IN_SET => KernelError::NotInSet, code => KernelError::Unknown(code), } } } #[derive(Clone, Copy, Debug, PartialEq)] pub enum MachError { Success, Kernel(KernelError), IpcSpace, VmSpace, IpcKernel, VmKernel, RcvInProgress, RcvInvalidName, RcvTimedOut, RcvTooLarge, RcvInterrupted, RcvPortChanged, RcvInvalidNotify, RcvInvalidData, RcvPortDied, RcvInSet, RcvHeaderError, RcvBodyError, RcvInvalidType, RcvScatterSmall, RcvInvalidTrailer, RcvInProgressTimed, NotifyNoSenders, SendInterrupted, SendInvalidData, SendInvalidDest, SendInvalidHeader, SendInvalidMemory, SendInvalidNotify, SendInvalidReply, SendInvalidRight, SendInvalidRtOolSize, SendInvalidTrailer, SendInvalidType, SendInvalidVoucher, SendInProgress, SendMsgTooSmall, SendNoBuffer, SendTimedOut, SendTooLarge, Unknown(mach_msg_return_t), } impl MachError { #[allow(dead_code)] pub fn channel_is_closed(&self) -> bool { *self == MachError::NotifyNoSenders } } impl From for MachError { fn from(code: mach_msg_return_t) -> MachError { match code { MACH_MSG_SUCCESS => MachError::Success, MACH_MSG_IPC_KERNEL => MachError::IpcKernel, MACH_MSG_IPC_SPACE => MachError::IpcSpace, MACH_MSG_VM_KERNEL => MachError::VmKernel, MACH_MSG_VM_SPACE => MachError::VmSpace, MACH_RCV_BODY_ERROR => MachError::RcvBodyError, MACH_RCV_HEADER_ERROR => MachError::RcvHeaderError, MACH_RCV_INTERRUPTED => MachError::RcvInterrupted, MACH_RCV_INVALID_DATA => MachError::RcvInvalidData, MACH_RCV_INVALID_NAME => MachError::RcvInvalidName, MACH_RCV_INVALID_NOTIFY => MachError::RcvInvalidNotify, MACH_RCV_INVALID_TRAILER => MachError::RcvInvalidTrailer, MACH_RCV_INVALID_TYPE => MachError::RcvInvalidType, MACH_RCV_IN_PROGRESS => MachError::RcvInProgress, MACH_RCV_IN_PROGRESS_TIMED => MachError::RcvInProgressTimed, MACH_RCV_IN_SET => MachError::RcvInSet, MACH_RCV_PORT_CHANGED => MachError::RcvPortChanged, MACH_RCV_PORT_DIED => MachError::RcvPortDied, MACH_RCV_SCATTER_SMALL => MachError::RcvScatterSmall, MACH_RCV_TIMED_OUT => MachError::RcvTimedOut, MACH_RCV_TOO_LARGE => MachError::RcvTooLarge, MACH_NOTIFY_NO_SENDERS => MachError::NotifyNoSenders, MACH_SEND_INTERRUPTED => MachError::SendInterrupted, MACH_SEND_INVALID_DATA => MachError::SendInvalidData, MACH_SEND_INVALID_DEST => MachError::SendInvalidDest, MACH_SEND_INVALID_HEADER => MachError::SendInvalidHeader, MACH_SEND_INVALID_MEMORY => MachError::SendInvalidMemory, MACH_SEND_INVALID_NOTIFY => MachError::SendInvalidNotify, MACH_SEND_INVALID_REPLY => MachError::SendInvalidReply, MACH_SEND_INVALID_RIGHT => MachError::SendInvalidRight, MACH_SEND_INVALID_RT_OOL_SIZE => MachError::SendInvalidRtOolSize, MACH_SEND_INVALID_TRAILER => MachError::SendInvalidTrailer, MACH_SEND_INVALID_TYPE => MachError::SendInvalidType, MACH_SEND_INVALID_VOUCHER => MachError::SendInvalidVoucher, MACH_SEND_IN_PROGRESS => MachError::SendInProgress, MACH_SEND_MSG_TOO_SMALL => MachError::SendMsgTooSmall, MACH_SEND_NO_BUFFER => MachError::SendNoBuffer, MACH_SEND_TIMED_OUT => MachError::SendTimedOut, MACH_SEND_TOO_LARGE => MachError::SendTooLarge, code => MachError::Unknown(code), } } } impl From for MachError { fn from(kernel_error: KernelError) -> MachError { MachError::Kernel(kernel_error) } } impl From for Error { /// These error descriptions are from `mach/message.h` and `mach/kern_return.h`. fn from(mach_error: MachError) -> Error { match mach_error { MachError::Success => Error::new(ErrorKind::Other, "Success"), MachError::Kernel(KernelError::Success) => Error::new(ErrorKind::Other, "Success."), MachError::Kernel(KernelError::NoSpace) => Error::new( ErrorKind::Other, "No room in IPC name space for another right.", ), MachError::Kernel(KernelError::InvalidName) => { Error::new(ErrorKind::Other, "Name doesn't denote a right in the task.") } MachError::Kernel(KernelError::InvalidRight) => Error::new( ErrorKind::Other, "Name denotes a right, but not an appropriate right.", ), MachError::Kernel(KernelError::InvalidValue) => { Error::new(ErrorKind::Other, "Blatant range error.") } MachError::Kernel(KernelError::InvalidCapability) => Error::new( ErrorKind::Other, "The supplied (port) capability is improper.", ), MachError::Kernel(KernelError::UrefsOverflow) => Error::new( ErrorKind::Other, "Operation would overflow limit on user-references.", ), MachError::Kernel(KernelError::NotInSet) => Error::new( ErrorKind::Other, "Receive right is not a member of a port set.", ), MachError::Kernel(KernelError::Unknown(code)) => Error::new( ErrorKind::Other, format!("Unknown kernel error: {:x}", code), ), MachError::IpcSpace => Error::new( ErrorKind::Other, "No room in IPC name space for another capability name.", ), MachError::VmSpace => Error::new( ErrorKind::Other, "No room in VM address space for out-of-line memory.", ), MachError::IpcKernel => Error::new( ErrorKind::Other, "Kernel resource shortage handling an IPC capability.", ), MachError::VmKernel => Error::new( ErrorKind::Other, "Kernel resource shortage handling out-of-line memory.", ), MachError::SendInProgress => Error::new( ErrorKind::Interrupted, "Thread is waiting to send. (Internal use only.)", ), MachError::SendInvalidData => Error::new(ErrorKind::InvalidData, "Bogus in-line data."), MachError::SendInvalidDest => { Error::new(ErrorKind::NotFound, "Bogus destination port.") } MachError::SendTimedOut => Error::new( ErrorKind::TimedOut, "Message not sent before timeout expired.", ), MachError::SendInvalidVoucher => Error::new(ErrorKind::NotFound, "Bogus voucher port."), MachError::SendInterrupted => Error::new(ErrorKind::Interrupted, "Software interrupt."), MachError::SendMsgTooSmall => Error::new( ErrorKind::InvalidData, "Data doesn't contain a complete message.", ), MachError::SendInvalidReply => Error::new(ErrorKind::InvalidInput, "Bogus reply port."), MachError::SendInvalidRight => Error::new( ErrorKind::InvalidInput, "Bogus port rights in the message body.", ), MachError::SendInvalidNotify => { Error::new(ErrorKind::InvalidInput, "Bogus notify port argument.") } MachError::SendInvalidMemory => Error::new( ErrorKind::InvalidInput, "Invalid out-of-line memory pointer.", ), MachError::SendNoBuffer => { Error::new(ErrorKind::Other, "No message buffer is available.") } MachError::SendTooLarge => { Error::new(ErrorKind::InvalidData, "Send is too large for port") } MachError::SendInvalidType => { Error::new(ErrorKind::InvalidInput, "Invalid msg-type specification.") } MachError::SendInvalidHeader => Error::new( ErrorKind::InvalidInput, "A field in the header had a bad value.", ), MachError::SendInvalidTrailer => Error::new( ErrorKind::InvalidData, "The trailer to be sent does not match kernel format.", ), MachError::SendInvalidRtOolSize => Error::new( ErrorKind::Other, "compatibility: no longer a returned error", ), MachError::RcvInProgress => Error::new( ErrorKind::Interrupted, "Thread is waiting for receive. (Internal use only.)", ), MachError::RcvInvalidName => Error::new( ErrorKind::InvalidInput, "Bogus name for receive port/port-set.", ), MachError::RcvTimedOut => Error::new( ErrorKind::TimedOut, "Didn't get a message within the timeout value.", ), MachError::RcvTooLarge => Error::new( ErrorKind::InvalidInput, "Message buffer is not large enough for inline data.", ), MachError::RcvInterrupted => Error::new(ErrorKind::Interrupted, "Software interrupt."), MachError::RcvPortChanged => Error::new( ErrorKind::Other, "compatibility: no longer a returned error", ), MachError::RcvInvalidNotify => { Error::new(ErrorKind::InvalidInput, "Bogus notify port argument.") } MachError::RcvInvalidData => Error::new( ErrorKind::InvalidInput, "Bogus message buffer for inline data.", ), MachError::RcvPortDied => Error::new( ErrorKind::BrokenPipe, "Port/set was sent away/died during receive.", ), MachError::RcvInSet => Error::new( ErrorKind::Other, "compatibility: no longer a returned error", ), MachError::RcvHeaderError => Error::new( ErrorKind::Other, "Error receiving message header. See special bits.", ), MachError::RcvBodyError => Error::new( ErrorKind::Other, "Error receiving message body. See special bits.", ), MachError::RcvInvalidType => Error::new( ErrorKind::InvalidInput, "Invalid msg-type specification in scatter list.", ), MachError::RcvScatterSmall => Error::new( ErrorKind::InvalidInput, "Out-of-line overwrite region is not large enough", ), MachError::RcvInvalidTrailer => Error::new( ErrorKind::InvalidInput, "trailer type or number of trailer elements not supported", ), MachError::RcvInProgressTimed => Error::new( ErrorKind::Interrupted, "Waiting for receive with timeout. (Internal use only.)", ), MachError::NotifyNoSenders => Error::new( ErrorKind::ConnectionReset, "No senders exist for this port.", ), MachError::Unknown(mach_error_number) => Error::new( ErrorKind::Other, format!("Unknown Mach error: {:x}", mach_error_number), ), } } } extern "C" { fn bootstrap_register2( bp: mach_port_t, service_name: name_t, sp: mach_port_t, flags: u64, ) -> kern_return_t; fn bootstrap_look_up( bp: mach_port_t, service_name: name_t, sp: *mut mach_port_t, ) -> kern_return_t; } perfrecord-mach-ipc-rendezvous-0.2.1/src/mach_sys.rs000064400000000000000000014323630072674642500206470ustar 00000000000000/* automatically generated by rust-bindgen */ #![allow(warnings)] // Some manual additions to fix up bindgen output: pub type __darwin_natural_t = u32; pub type __uint8_t = u8; pub type __uint16_t = u16; pub type __uint32_t = u32; pub type __uint64_t = u64; pub type int32_t = i32; pub type int64_t = i64; pub type uint8_t = u8; pub type uint16_t = u16; pub type uint32_t = u32; pub type uint64_t = u64; pub type uintptr_t = usize; #[repr(C)] pub struct mach_vm_info_region { vir_start: mach_vm_offset_t, vir_end: mach_vm_offset_t, vir_object: mach_vm_offset_t, vir_offset: memory_object_offset_t, vir_needs_copy: boolean_t, vir_protection: vm_prot_t, vir_max_protection: vm_prot_t, vir_inheritance: vm_inherit_t, vir_wired_count: natural_t, vir_user_wired_count: natural_t, } pub type mach_vm_info_region_t = mach_vm_info_region; // Code below this line is automatically generated. pub type boolean_t = ::libc::c_uint; pub type kern_return_t = ::libc::c_int; pub type natural_t = __darwin_natural_t; pub type integer_t = ::libc::c_int; pub type vm_offset_t = uintptr_t; pub type vm_size_t = uintptr_t; pub type mach_vm_address_t = uint64_t; pub type mach_vm_offset_t = uint64_t; pub type mach_vm_size_t = uint64_t; pub type vm_map_offset_t = uint64_t; pub type vm_map_address_t = uint64_t; pub type vm_map_size_t = uint64_t; pub type mach_port_context_t = mach_vm_address_t; pub type mach_port_name_t = natural_t; pub type mach_port_name_array_t = *mut mach_port_name_t; pub type mach_port_t = mach_port_name_t; pub type mach_port_array_t = *mut mach_port_t; pub type mach_port_right_t = natural_t; pub type mach_port_type_t = natural_t; pub type mach_port_type_array_t = *mut mach_port_type_t; pub type mach_port_urefs_t = natural_t; pub type mach_port_delta_t = integer_t; pub type mach_port_seqno_t = natural_t; pub type mach_port_mscount_t = natural_t; pub type mach_port_msgcount_t = natural_t; pub type mach_port_rights_t = natural_t; pub type mach_port_srights_t = ::libc::c_uint; #[repr(C)] #[derive(Copy)] pub struct Struct_mach_port_status { pub mps_pset: mach_port_rights_t, pub mps_seqno: mach_port_seqno_t, pub mps_mscount: mach_port_mscount_t, pub mps_qlimit: mach_port_msgcount_t, pub mps_msgcount: mach_port_msgcount_t, pub mps_sorights: mach_port_rights_t, pub mps_srights: boolean_t, pub mps_pdrequest: boolean_t, pub mps_nsrequest: boolean_t, pub mps_flags: natural_t, } impl ::std::clone::Clone for Struct_mach_port_status { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_mach_port_status { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type mach_port_status_t = Struct_mach_port_status; #[repr(C)] #[derive(Copy)] pub struct Struct_mach_port_limits { pub mpl_qlimit: mach_port_msgcount_t, } impl ::std::clone::Clone for Struct_mach_port_limits { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_mach_port_limits { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type mach_port_limits_t = Struct_mach_port_limits; pub type mach_port_info_t = *mut integer_t; pub type mach_port_flavor_t = ::libc::c_int; #[repr(C)] #[derive(Copy)] pub struct Struct_mach_port_qos { pub _bindgen_bitfield_1_: ::libc::c_uint, pub _bindgen_bitfield_2_: boolean_t, pub len: natural_t, } impl ::std::clone::Clone for Struct_mach_port_qos { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_mach_port_qos { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type mach_port_qos_t = Struct_mach_port_qos; pub type pointer_t = vm_offset_t; pub type vm_address_t = vm_offset_t; pub type addr64_t = uint64_t; pub type reg64_t = uint32_t; pub type ppnum_t = uint32_t; pub type vm_map_t = mach_port_t; pub type vm_object_offset_t = uint64_t; pub type vm_object_size_t = uint64_t; pub type upl_t = mach_port_t; pub type vm_named_entry_t = mach_port_t; pub type mach_msg_timeout_t = natural_t; pub type mach_msg_bits_t = ::libc::c_uint; pub type mach_msg_size_t = natural_t; pub type mach_msg_id_t = integer_t; pub type mach_msg_type_name_t = ::libc::c_uint; pub type mach_msg_copy_options_t = u8; pub type mach_msg_descriptor_type_t = ::libc::c_uint; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed1 { pub pad1: natural_t, pub pad2: mach_msg_size_t, pub _bindgen_bitfield_1_: ::libc::c_uint, pub _bindgen_bitfield_2_: mach_msg_descriptor_type_t, } impl ::std::clone::Clone for Struct_Unnamed1 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed1 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type mach_msg_type_descriptor_t = Struct_Unnamed1; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed2 { pub name: mach_port_t, pub pad1: mach_msg_size_t, pub pad2: u16, pub disposition: u8, pub type_: u8, } impl ::std::clone::Clone for Struct_Unnamed2 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed2 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type mach_msg_port_descriptor_t = Struct_Unnamed2; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed3 { pub address: uint32_t, pub size: mach_msg_size_t, pub _bindgen_bitfield_1_: boolean_t, pub _bindgen_bitfield_2_: mach_msg_copy_options_t, pub _bindgen_bitfield_3_: ::libc::c_uint, pub _bindgen_bitfield_4_: mach_msg_descriptor_type_t, } impl ::std::clone::Clone for Struct_Unnamed3 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed3 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type mach_msg_ool_descriptor32_t = Struct_Unnamed3; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed4 { pub address: uint64_t, pub _bindgen_bitfield_1_: boolean_t, pub _bindgen_bitfield_2_: mach_msg_copy_options_t, pub _bindgen_bitfield_3_: ::libc::c_uint, pub _bindgen_bitfield_4_: mach_msg_descriptor_type_t, pub size: mach_msg_size_t, } impl ::std::clone::Clone for Struct_Unnamed4 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed4 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type mach_msg_ool_descriptor64_t = Struct_Unnamed4; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed5 { pub address: *mut ::libc::c_void, pub deallocate: u8, pub copy: u8, pub disposition: u8, pub type_: u8, pub size: mach_msg_size_t, } impl ::std::clone::Clone for Struct_Unnamed5 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed5 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type mach_msg_ool_descriptor_t = Struct_Unnamed5; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed6 { pub address: uint32_t, pub count: mach_msg_size_t, pub _bindgen_bitfield_1_: boolean_t, pub _bindgen_bitfield_2_: mach_msg_copy_options_t, pub _bindgen_bitfield_3_: mach_msg_type_name_t, pub _bindgen_bitfield_4_: mach_msg_descriptor_type_t, } impl ::std::clone::Clone for Struct_Unnamed6 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed6 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type mach_msg_ool_ports_descriptor32_t = Struct_Unnamed6; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed7 { pub address: uint64_t, pub _bindgen_bitfield_1_: boolean_t, pub _bindgen_bitfield_2_: mach_msg_copy_options_t, pub _bindgen_bitfield_3_: mach_msg_type_name_t, pub _bindgen_bitfield_4_: mach_msg_descriptor_type_t, pub count: mach_msg_size_t, } impl ::std::clone::Clone for Struct_Unnamed7 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed7 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type mach_msg_ool_ports_descriptor64_t = Struct_Unnamed7; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed8 { pub address: *mut ::libc::c_void, pub _bindgen_bitfield_1_: boolean_t, pub _bindgen_bitfield_2_: mach_msg_copy_options_t, pub _bindgen_bitfield_3_: mach_msg_type_name_t, pub _bindgen_bitfield_4_: mach_msg_descriptor_type_t, pub count: mach_msg_size_t, } impl ::std::clone::Clone for Struct_Unnamed8 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed8 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type mach_msg_ool_ports_descriptor_t = Struct_Unnamed8; #[repr(C)] #[derive(Copy)] pub struct Union_Unnamed9 { pub _bindgen_data_: [u32; 4usize], } impl Union_Unnamed9 { pub unsafe fn port(&mut self) -> *mut mach_msg_port_descriptor_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn out_of_line(&mut self) -> *mut mach_msg_ool_descriptor_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn ool_ports(&mut self) -> *mut mach_msg_ool_ports_descriptor_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn _type(&mut self) -> *mut mach_msg_type_descriptor_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } } impl ::std::clone::Clone for Union_Unnamed9 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Union_Unnamed9 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type mach_msg_descriptor_t = Union_Unnamed9; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed10 { pub msgh_descriptor_count: mach_msg_size_t, } impl ::std::clone::Clone for Struct_Unnamed10 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed10 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type mach_msg_body_t = Struct_Unnamed10; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed11 { pub msgh_bits: mach_msg_bits_t, pub msgh_size: mach_msg_size_t, pub msgh_remote_port: mach_port_t, pub msgh_local_port: mach_port_t, pub msgh_reserved: mach_msg_size_t, pub msgh_id: mach_msg_id_t, } impl ::std::clone::Clone for Struct_Unnamed11 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed11 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type mach_msg_header_t = Struct_Unnamed11; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed12 { pub header: mach_msg_header_t, pub body: mach_msg_body_t, } impl ::std::clone::Clone for Struct_Unnamed12 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed12 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type mach_msg_base_t = Struct_Unnamed12; pub type mach_msg_trailer_type_t = ::libc::c_uint; pub type mach_msg_trailer_size_t = ::libc::c_uint; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed13 { pub msgh_trailer_type: mach_msg_trailer_type_t, pub msgh_trailer_size: mach_msg_trailer_size_t, } impl ::std::clone::Clone for Struct_Unnamed13 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed13 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type mach_msg_trailer_t = Struct_Unnamed13; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed14 { pub msgh_trailer_type: mach_msg_trailer_type_t, pub msgh_trailer_size: mach_msg_trailer_size_t, pub msgh_seqno: mach_port_seqno_t, } impl ::std::clone::Clone for Struct_Unnamed14 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed14 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type mach_msg_seqno_trailer_t = Struct_Unnamed14; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed15 { pub val: [::libc::c_uint; 2usize], } impl ::std::clone::Clone for Struct_Unnamed15 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed15 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type security_token_t = Struct_Unnamed15; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed16 { pub msgh_trailer_type: mach_msg_trailer_type_t, pub msgh_trailer_size: mach_msg_trailer_size_t, pub msgh_seqno: mach_port_seqno_t, pub msgh_sender: security_token_t, } impl ::std::clone::Clone for Struct_Unnamed16 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed16 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type mach_msg_security_trailer_t = Struct_Unnamed16; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed17 { pub val: [::libc::c_uint; 8usize], } impl ::std::clone::Clone for Struct_Unnamed17 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed17 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type audit_token_t = Struct_Unnamed17; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed18 { pub msgh_trailer_type: mach_msg_trailer_type_t, pub msgh_trailer_size: mach_msg_trailer_size_t, pub msgh_seqno: mach_port_seqno_t, pub msgh_sender: security_token_t, pub msgh_audit: audit_token_t, } impl ::std::clone::Clone for Struct_Unnamed18 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed18 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type mach_msg_audit_trailer_t = Struct_Unnamed18; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed19 { pub msgh_trailer_type: mach_msg_trailer_type_t, pub msgh_trailer_size: mach_msg_trailer_size_t, pub msgh_seqno: mach_port_seqno_t, pub msgh_sender: security_token_t, pub msgh_audit: audit_token_t, pub msgh_context: mach_port_context_t, } impl ::std::clone::Clone for Struct_Unnamed19 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed19 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type mach_msg_context_trailer_t = Struct_Unnamed19; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed20 { pub sender: mach_port_name_t, } impl ::std::clone::Clone for Struct_Unnamed20 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed20 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type msg_labels_t = Struct_Unnamed20; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed21 { pub msgh_trailer_type: mach_msg_trailer_type_t, pub msgh_trailer_size: mach_msg_trailer_size_t, pub msgh_seqno: mach_port_seqno_t, pub msgh_sender: security_token_t, pub msgh_audit: audit_token_t, pub msgh_context: mach_port_context_t, pub msgh_ad: ::libc::c_int, pub msgh_labels: msg_labels_t, } impl ::std::clone::Clone for Struct_Unnamed21 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed21 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type mach_msg_mac_trailer_t = Struct_Unnamed21; pub type mach_msg_max_trailer_t = mach_msg_mac_trailer_t; pub type mach_msg_format_0_trailer_t = mach_msg_security_trailer_t; pub type mach_msg_options_t = integer_t; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed22 { pub header: mach_msg_header_t, } impl ::std::clone::Clone for Struct_Unnamed22 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed22 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type mach_msg_empty_send_t = Struct_Unnamed22; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed23 { pub header: mach_msg_header_t, pub trailer: mach_msg_trailer_t, } impl ::std::clone::Clone for Struct_Unnamed23 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed23 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type mach_msg_empty_rcv_t = Struct_Unnamed23; #[repr(C)] #[derive(Copy)] pub struct Union_Unnamed24 { pub _bindgen_data_: [u32; 8usize], } impl Union_Unnamed24 { pub unsafe fn send(&mut self) -> *mut mach_msg_empty_send_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn rcv(&mut self) -> *mut mach_msg_empty_rcv_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } } impl ::std::clone::Clone for Union_Unnamed24 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Union_Unnamed24 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type mach_msg_empty_t = Union_Unnamed24; pub type mach_msg_type_size_t = natural_t; pub type mach_msg_type_number_t = natural_t; pub type mach_msg_option_t = integer_t; pub type mach_msg_return_t = kern_return_t; #[repr(C)] #[derive(Copy)] pub struct Struct_vm_statistics { pub free_count: natural_t, pub active_count: natural_t, pub inactive_count: natural_t, pub wire_count: natural_t, pub zero_fill_count: natural_t, pub reactivations: natural_t, pub pageins: natural_t, pub pageouts: natural_t, pub faults: natural_t, pub cow_faults: natural_t, pub lookups: natural_t, pub hits: natural_t, pub purgeable_count: natural_t, pub purges: natural_t, pub speculative_count: natural_t, } impl ::std::clone::Clone for Struct_vm_statistics { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_vm_statistics { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type vm_statistics_t = *mut Struct_vm_statistics; pub type vm_statistics_data_t = Struct_vm_statistics; #[repr(C)] #[derive(Copy)] pub struct Struct_vm_statistics64 { pub free_count: natural_t, pub active_count: natural_t, pub inactive_count: natural_t, pub wire_count: natural_t, pub zero_fill_count: uint64_t, pub reactivations: uint64_t, pub pageins: uint64_t, pub pageouts: uint64_t, pub faults: uint64_t, pub cow_faults: uint64_t, pub lookups: uint64_t, pub hits: uint64_t, pub purges: uint64_t, pub purgeable_count: natural_t, pub speculative_count: natural_t, } impl ::std::clone::Clone for Struct_vm_statistics64 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_vm_statistics64 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type vm_statistics64_t = *mut Struct_vm_statistics64; pub type vm_statistics64_data_t = Struct_vm_statistics64; #[repr(C)] #[derive(Copy)] pub struct Struct_vm_extmod_statistics { pub task_for_pid_count: int64_t, pub task_for_pid_caller_count: int64_t, pub thread_creation_count: int64_t, pub thread_creation_caller_count: int64_t, pub thread_set_state_count: int64_t, pub thread_set_state_caller_count: int64_t, } impl ::std::clone::Clone for Struct_vm_extmod_statistics { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_vm_extmod_statistics { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type vm_extmod_statistics_t = *mut Struct_vm_extmod_statistics; pub type vm_extmod_statistics_data_t = Struct_vm_extmod_statistics; pub type cpu_type_t = integer_t; pub type cpu_subtype_t = integer_t; pub type cpu_threadtype_t = integer_t; #[repr(C)] #[derive(Copy)] pub struct Struct_time_value { pub seconds: integer_t, pub microseconds: integer_t, } impl ::std::clone::Clone for Struct_time_value { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_time_value { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type time_value_t = Struct_time_value; pub type host_info_t = *mut integer_t; pub type host_info64_t = *mut integer_t; pub type host_info_data_t = [integer_t; 1024usize]; pub type kernel_version_t = [::libc::c_char; 512usize]; pub type kernel_boot_info_t = [::libc::c_char; 4096usize]; pub type host_flavor_t = integer_t; #[repr(C)] #[derive(Copy)] pub struct Struct_host_basic_info { pub max_cpus: integer_t, pub avail_cpus: integer_t, pub memory_size: natural_t, pub cpu_type: cpu_type_t, pub cpu_subtype: cpu_subtype_t, pub cpu_threadtype: cpu_threadtype_t, pub physical_cpu: integer_t, pub physical_cpu_max: integer_t, pub logical_cpu: integer_t, pub logical_cpu_max: integer_t, pub max_mem: uint64_t, } impl ::std::clone::Clone for Struct_host_basic_info { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_host_basic_info { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type host_basic_info_data_t = Struct_host_basic_info; pub type host_basic_info_t = *mut Struct_host_basic_info; #[repr(C)] #[derive(Copy)] pub struct Struct_host_sched_info { pub min_timeout: integer_t, pub min_quantum: integer_t, } impl ::std::clone::Clone for Struct_host_sched_info { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_host_sched_info { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type host_sched_info_data_t = Struct_host_sched_info; pub type host_sched_info_t = *mut Struct_host_sched_info; #[repr(C)] #[derive(Copy)] pub struct Struct_kernel_resource_sizes { pub task: natural_t, pub thread: natural_t, pub port: natural_t, pub memory_region: natural_t, pub memory_object: natural_t, } impl ::std::clone::Clone for Struct_kernel_resource_sizes { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_kernel_resource_sizes { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type kernel_resource_sizes_data_t = Struct_kernel_resource_sizes; pub type kernel_resource_sizes_t = *mut Struct_kernel_resource_sizes; #[repr(C)] #[derive(Copy)] pub struct Struct_host_priority_info { pub kernel_priority: integer_t, pub system_priority: integer_t, pub server_priority: integer_t, pub user_priority: integer_t, pub depress_priority: integer_t, pub idle_priority: integer_t, pub minimum_priority: integer_t, pub maximum_priority: integer_t, } impl ::std::clone::Clone for Struct_host_priority_info { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_host_priority_info { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type host_priority_info_data_t = Struct_host_priority_info; pub type host_priority_info_t = *mut Struct_host_priority_info; #[repr(C)] #[derive(Copy)] pub struct Struct_host_load_info { pub avenrun: [integer_t; 3usize], pub mach_factor: [integer_t; 3usize], } impl ::std::clone::Clone for Struct_host_load_info { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_host_load_info { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type host_load_info_data_t = Struct_host_load_info; pub type host_load_info_t = *mut Struct_host_load_info; #[repr(C)] #[derive(Copy)] pub struct Struct_host_cpu_load_info { pub cpu_ticks: [natural_t; 4usize], } impl ::std::clone::Clone for Struct_host_cpu_load_info { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_host_cpu_load_info { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type host_cpu_load_info_data_t = Struct_host_cpu_load_info; pub type host_cpu_load_info_t = *mut Struct_host_cpu_load_info; pub type vm_prot_t = ::libc::c_int; pub type vm_sync_t = ::libc::c_uint; pub type memory_object_offset_t = ::libc::c_ulonglong; pub type memory_object_size_t = ::libc::c_ulonglong; pub type memory_object_cluster_size_t = natural_t; pub type memory_object_fault_info_t = *mut natural_t; pub type vm_object_id_t = ::libc::c_ulonglong; pub type memory_object_t = mach_port_t; pub type memory_object_control_t = mach_port_t; pub type memory_object_array_t = *mut memory_object_t; pub type memory_object_name_t = mach_port_t; pub type memory_object_default_t = mach_port_t; pub type memory_object_copy_strategy_t = ::libc::c_int; pub type memory_object_return_t = ::libc::c_int; pub type memory_object_info_t = *mut ::libc::c_int; pub type memory_object_flavor_t = ::libc::c_int; pub type memory_object_info_data_t = [::libc::c_int; 1024usize]; #[repr(C)] #[derive(Copy)] pub struct Struct_memory_object_perf_info { pub cluster_size: memory_object_cluster_size_t, pub may_cache: boolean_t, } impl ::std::clone::Clone for Struct_memory_object_perf_info { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_memory_object_perf_info { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy)] pub struct Struct_memory_object_attr_info { pub copy_strategy: memory_object_copy_strategy_t, pub cluster_size: memory_object_cluster_size_t, pub may_cache_object: boolean_t, pub temporary: boolean_t, } impl ::std::clone::Clone for Struct_memory_object_attr_info { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_memory_object_attr_info { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy)] pub struct Struct_memory_object_behave_info { pub copy_strategy: memory_object_copy_strategy_t, pub temporary: boolean_t, pub invalidate: boolean_t, pub silent_overwrite: boolean_t, pub advisory_pageout: boolean_t, } impl ::std::clone::Clone for Struct_memory_object_behave_info { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_memory_object_behave_info { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type memory_object_behave_info_t = *mut Struct_memory_object_behave_info; pub type memory_object_behave_info_data_t = Struct_memory_object_behave_info; pub type memory_object_perf_info_t = *mut Struct_memory_object_perf_info; pub type memory_object_perf_info_data_t = Struct_memory_object_perf_info; pub type memory_object_attr_info_t = *mut Struct_memory_object_attr_info; pub type memory_object_attr_info_data_t = Struct_memory_object_attr_info; #[repr(C)] #[derive(Copy)] pub struct Struct___darwin_i386_thread_state { pub __eax: ::libc::c_uint, pub __ebx: ::libc::c_uint, pub __ecx: ::libc::c_uint, pub __edx: ::libc::c_uint, pub __edi: ::libc::c_uint, pub __esi: ::libc::c_uint, pub __ebp: ::libc::c_uint, pub __esp: ::libc::c_uint, pub __ss: ::libc::c_uint, pub __eflags: ::libc::c_uint, pub __eip: ::libc::c_uint, pub __cs: ::libc::c_uint, pub __ds: ::libc::c_uint, pub __es: ::libc::c_uint, pub __fs: ::libc::c_uint, pub __gs: ::libc::c_uint, } impl ::std::clone::Clone for Struct___darwin_i386_thread_state { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct___darwin_i386_thread_state { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy)] pub struct Struct___darwin_fp_control { pub _bindgen_bitfield_1_: ::libc::c_ushort, } impl ::std::clone::Clone for Struct___darwin_fp_control { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct___darwin_fp_control { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __darwin_fp_control_t = Struct___darwin_fp_control; #[repr(C)] #[derive(Copy)] pub struct Struct___darwin_fp_status { pub _bindgen_bitfield_1_: ::libc::c_ushort, } impl ::std::clone::Clone for Struct___darwin_fp_status { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct___darwin_fp_status { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __darwin_fp_status_t = Struct___darwin_fp_status; #[repr(C)] #[derive(Copy)] pub struct Struct___darwin_mmst_reg { pub __mmst_reg: [::libc::c_char; 10usize], pub __mmst_rsrv: [::libc::c_char; 6usize], } impl ::std::clone::Clone for Struct___darwin_mmst_reg { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct___darwin_mmst_reg { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy)] pub struct Struct___darwin_xmm_reg { pub __xmm_reg: [::libc::c_char; 16usize], } impl ::std::clone::Clone for Struct___darwin_xmm_reg { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct___darwin_xmm_reg { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy)] pub struct Struct___darwin_i386_float_state { pub __fpu_reserved: [::libc::c_int; 2usize], pub __fpu_fcw: Struct___darwin_fp_control, pub __fpu_fsw: Struct___darwin_fp_status, pub __fpu_ftw: __uint8_t, pub __fpu_rsrv1: __uint8_t, pub __fpu_fop: __uint16_t, pub __fpu_ip: __uint32_t, pub __fpu_cs: __uint16_t, pub __fpu_rsrv2: __uint16_t, pub __fpu_dp: __uint32_t, pub __fpu_ds: __uint16_t, pub __fpu_rsrv3: __uint16_t, pub __fpu_mxcsr: __uint32_t, pub __fpu_mxcsrmask: __uint32_t, pub __fpu_stmm0: Struct___darwin_mmst_reg, pub __fpu_stmm1: Struct___darwin_mmst_reg, pub __fpu_stmm2: Struct___darwin_mmst_reg, pub __fpu_stmm3: Struct___darwin_mmst_reg, pub __fpu_stmm4: Struct___darwin_mmst_reg, pub __fpu_stmm5: Struct___darwin_mmst_reg, pub __fpu_stmm6: Struct___darwin_mmst_reg, pub __fpu_stmm7: Struct___darwin_mmst_reg, pub __fpu_xmm0: Struct___darwin_xmm_reg, pub __fpu_xmm1: Struct___darwin_xmm_reg, pub __fpu_xmm2: Struct___darwin_xmm_reg, pub __fpu_xmm3: Struct___darwin_xmm_reg, pub __fpu_xmm4: Struct___darwin_xmm_reg, pub __fpu_xmm5: Struct___darwin_xmm_reg, pub __fpu_xmm6: Struct___darwin_xmm_reg, pub __fpu_xmm7: Struct___darwin_xmm_reg, pub __fpu_rsrv4: [::libc::c_char; 224usize], pub __fpu_reserved1: ::libc::c_int, } impl ::std::clone::Clone for Struct___darwin_i386_float_state { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct___darwin_i386_float_state { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy)] pub struct Struct___darwin_i386_avx_state { pub __fpu_reserved: [::libc::c_int; 2usize], pub __fpu_fcw: Struct___darwin_fp_control, pub __fpu_fsw: Struct___darwin_fp_status, pub __fpu_ftw: __uint8_t, pub __fpu_rsrv1: __uint8_t, pub __fpu_fop: __uint16_t, pub __fpu_ip: __uint32_t, pub __fpu_cs: __uint16_t, pub __fpu_rsrv2: __uint16_t, pub __fpu_dp: __uint32_t, pub __fpu_ds: __uint16_t, pub __fpu_rsrv3: __uint16_t, pub __fpu_mxcsr: __uint32_t, pub __fpu_mxcsrmask: __uint32_t, pub __fpu_stmm0: Struct___darwin_mmst_reg, pub __fpu_stmm1: Struct___darwin_mmst_reg, pub __fpu_stmm2: Struct___darwin_mmst_reg, pub __fpu_stmm3: Struct___darwin_mmst_reg, pub __fpu_stmm4: Struct___darwin_mmst_reg, pub __fpu_stmm5: Struct___darwin_mmst_reg, pub __fpu_stmm6: Struct___darwin_mmst_reg, pub __fpu_stmm7: Struct___darwin_mmst_reg, pub __fpu_xmm0: Struct___darwin_xmm_reg, pub __fpu_xmm1: Struct___darwin_xmm_reg, pub __fpu_xmm2: Struct___darwin_xmm_reg, pub __fpu_xmm3: Struct___darwin_xmm_reg, pub __fpu_xmm4: Struct___darwin_xmm_reg, pub __fpu_xmm5: Struct___darwin_xmm_reg, pub __fpu_xmm6: Struct___darwin_xmm_reg, pub __fpu_xmm7: Struct___darwin_xmm_reg, pub __fpu_rsrv4: [::libc::c_char; 224usize], pub __fpu_reserved1: ::libc::c_int, pub __avx_reserved1: [::libc::c_char; 64usize], pub __fpu_ymmh0: Struct___darwin_xmm_reg, pub __fpu_ymmh1: Struct___darwin_xmm_reg, pub __fpu_ymmh2: Struct___darwin_xmm_reg, pub __fpu_ymmh3: Struct___darwin_xmm_reg, pub __fpu_ymmh4: Struct___darwin_xmm_reg, pub __fpu_ymmh5: Struct___darwin_xmm_reg, pub __fpu_ymmh6: Struct___darwin_xmm_reg, pub __fpu_ymmh7: Struct___darwin_xmm_reg, } impl ::std::clone::Clone for Struct___darwin_i386_avx_state { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct___darwin_i386_avx_state { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy)] pub struct Struct___darwin_i386_exception_state { pub __trapno: __uint16_t, pub __cpu: __uint16_t, pub __err: __uint32_t, pub __faultvaddr: __uint32_t, } impl ::std::clone::Clone for Struct___darwin_i386_exception_state { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct___darwin_i386_exception_state { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy)] pub struct Struct___darwin_x86_debug_state32 { pub __dr0: ::libc::c_uint, pub __dr1: ::libc::c_uint, pub __dr2: ::libc::c_uint, pub __dr3: ::libc::c_uint, pub __dr4: ::libc::c_uint, pub __dr5: ::libc::c_uint, pub __dr6: ::libc::c_uint, pub __dr7: ::libc::c_uint, } impl ::std::clone::Clone for Struct___darwin_x86_debug_state32 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct___darwin_x86_debug_state32 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy)] pub struct Struct___darwin_x86_thread_state64 { pub __rax: __uint64_t, pub __rbx: __uint64_t, pub __rcx: __uint64_t, pub __rdx: __uint64_t, pub __rdi: __uint64_t, pub __rsi: __uint64_t, pub __rbp: __uint64_t, pub __rsp: __uint64_t, pub __r8: __uint64_t, pub __r9: __uint64_t, pub __r10: __uint64_t, pub __r11: __uint64_t, pub __r12: __uint64_t, pub __r13: __uint64_t, pub __r14: __uint64_t, pub __r15: __uint64_t, pub __rip: __uint64_t, pub __rflags: __uint64_t, pub __cs: __uint64_t, pub __fs: __uint64_t, pub __gs: __uint64_t, } impl ::std::clone::Clone for Struct___darwin_x86_thread_state64 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct___darwin_x86_thread_state64 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy)] pub struct Struct___darwin_x86_float_state64 { pub __fpu_reserved: [::libc::c_int; 2usize], pub __fpu_fcw: Struct___darwin_fp_control, pub __fpu_fsw: Struct___darwin_fp_status, pub __fpu_ftw: __uint8_t, pub __fpu_rsrv1: __uint8_t, pub __fpu_fop: __uint16_t, pub __fpu_ip: __uint32_t, pub __fpu_cs: __uint16_t, pub __fpu_rsrv2: __uint16_t, pub __fpu_dp: __uint32_t, pub __fpu_ds: __uint16_t, pub __fpu_rsrv3: __uint16_t, pub __fpu_mxcsr: __uint32_t, pub __fpu_mxcsrmask: __uint32_t, pub __fpu_stmm0: Struct___darwin_mmst_reg, pub __fpu_stmm1: Struct___darwin_mmst_reg, pub __fpu_stmm2: Struct___darwin_mmst_reg, pub __fpu_stmm3: Struct___darwin_mmst_reg, pub __fpu_stmm4: Struct___darwin_mmst_reg, pub __fpu_stmm5: Struct___darwin_mmst_reg, pub __fpu_stmm6: Struct___darwin_mmst_reg, pub __fpu_stmm7: Struct___darwin_mmst_reg, pub __fpu_xmm0: Struct___darwin_xmm_reg, pub __fpu_xmm1: Struct___darwin_xmm_reg, pub __fpu_xmm2: Struct___darwin_xmm_reg, pub __fpu_xmm3: Struct___darwin_xmm_reg, pub __fpu_xmm4: Struct___darwin_xmm_reg, pub __fpu_xmm5: Struct___darwin_xmm_reg, pub __fpu_xmm6: Struct___darwin_xmm_reg, pub __fpu_xmm7: Struct___darwin_xmm_reg, pub __fpu_xmm8: Struct___darwin_xmm_reg, pub __fpu_xmm9: Struct___darwin_xmm_reg, pub __fpu_xmm10: Struct___darwin_xmm_reg, pub __fpu_xmm11: Struct___darwin_xmm_reg, pub __fpu_xmm12: Struct___darwin_xmm_reg, pub __fpu_xmm13: Struct___darwin_xmm_reg, pub __fpu_xmm14: Struct___darwin_xmm_reg, pub __fpu_xmm15: Struct___darwin_xmm_reg, pub __fpu_rsrv4: [::libc::c_char; 96usize], pub __fpu_reserved1: ::libc::c_int, } impl ::std::clone::Clone for Struct___darwin_x86_float_state64 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct___darwin_x86_float_state64 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy)] pub struct Struct___darwin_x86_avx_state64 { pub __fpu_reserved: [::libc::c_int; 2usize], pub __fpu_fcw: Struct___darwin_fp_control, pub __fpu_fsw: Struct___darwin_fp_status, pub __fpu_ftw: __uint8_t, pub __fpu_rsrv1: __uint8_t, pub __fpu_fop: __uint16_t, pub __fpu_ip: __uint32_t, pub __fpu_cs: __uint16_t, pub __fpu_rsrv2: __uint16_t, pub __fpu_dp: __uint32_t, pub __fpu_ds: __uint16_t, pub __fpu_rsrv3: __uint16_t, pub __fpu_mxcsr: __uint32_t, pub __fpu_mxcsrmask: __uint32_t, pub __fpu_stmm0: Struct___darwin_mmst_reg, pub __fpu_stmm1: Struct___darwin_mmst_reg, pub __fpu_stmm2: Struct___darwin_mmst_reg, pub __fpu_stmm3: Struct___darwin_mmst_reg, pub __fpu_stmm4: Struct___darwin_mmst_reg, pub __fpu_stmm5: Struct___darwin_mmst_reg, pub __fpu_stmm6: Struct___darwin_mmst_reg, pub __fpu_stmm7: Struct___darwin_mmst_reg, pub __fpu_xmm0: Struct___darwin_xmm_reg, pub __fpu_xmm1: Struct___darwin_xmm_reg, pub __fpu_xmm2: Struct___darwin_xmm_reg, pub __fpu_xmm3: Struct___darwin_xmm_reg, pub __fpu_xmm4: Struct___darwin_xmm_reg, pub __fpu_xmm5: Struct___darwin_xmm_reg, pub __fpu_xmm6: Struct___darwin_xmm_reg, pub __fpu_xmm7: Struct___darwin_xmm_reg, pub __fpu_xmm8: Struct___darwin_xmm_reg, pub __fpu_xmm9: Struct___darwin_xmm_reg, pub __fpu_xmm10: Struct___darwin_xmm_reg, pub __fpu_xmm11: Struct___darwin_xmm_reg, pub __fpu_xmm12: Struct___darwin_xmm_reg, pub __fpu_xmm13: Struct___darwin_xmm_reg, pub __fpu_xmm14: Struct___darwin_xmm_reg, pub __fpu_xmm15: Struct___darwin_xmm_reg, pub __fpu_rsrv4: [::libc::c_char; 96usize], pub __fpu_reserved1: ::libc::c_int, pub __avx_reserved1: [::libc::c_char; 64usize], pub __fpu_ymmh0: Struct___darwin_xmm_reg, pub __fpu_ymmh1: Struct___darwin_xmm_reg, pub __fpu_ymmh2: Struct___darwin_xmm_reg, pub __fpu_ymmh3: Struct___darwin_xmm_reg, pub __fpu_ymmh4: Struct___darwin_xmm_reg, pub __fpu_ymmh5: Struct___darwin_xmm_reg, pub __fpu_ymmh6: Struct___darwin_xmm_reg, pub __fpu_ymmh7: Struct___darwin_xmm_reg, pub __fpu_ymmh8: Struct___darwin_xmm_reg, pub __fpu_ymmh9: Struct___darwin_xmm_reg, pub __fpu_ymmh10: Struct___darwin_xmm_reg, pub __fpu_ymmh11: Struct___darwin_xmm_reg, pub __fpu_ymmh12: Struct___darwin_xmm_reg, pub __fpu_ymmh13: Struct___darwin_xmm_reg, pub __fpu_ymmh14: Struct___darwin_xmm_reg, pub __fpu_ymmh15: Struct___darwin_xmm_reg, } impl ::std::clone::Clone for Struct___darwin_x86_avx_state64 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct___darwin_x86_avx_state64 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy)] pub struct Struct___darwin_x86_exception_state64 { pub __trapno: __uint16_t, pub __cpu: __uint16_t, pub __err: __uint32_t, pub __faultvaddr: __uint64_t, } impl ::std::clone::Clone for Struct___darwin_x86_exception_state64 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct___darwin_x86_exception_state64 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy)] pub struct Struct___darwin_x86_debug_state64 { pub __dr0: __uint64_t, pub __dr1: __uint64_t, pub __dr2: __uint64_t, pub __dr3: __uint64_t, pub __dr4: __uint64_t, pub __dr5: __uint64_t, pub __dr6: __uint64_t, pub __dr7: __uint64_t, } impl ::std::clone::Clone for Struct___darwin_x86_debug_state64 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct___darwin_x86_debug_state64 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy)] pub struct Struct_x86_state_hdr { pub flavor: ::libc::c_int, pub count: ::libc::c_int, } impl ::std::clone::Clone for Struct_x86_state_hdr { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_x86_state_hdr { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type x86_state_hdr_t = Struct_x86_state_hdr; pub type i386_thread_state_t = Struct___darwin_i386_thread_state; pub type x86_thread_state32_t = Struct___darwin_i386_thread_state; pub type i386_float_state_t = Struct___darwin_i386_float_state; pub type x86_float_state32_t = Struct___darwin_i386_float_state; pub type x86_avx_state32_t = Struct___darwin_i386_avx_state; pub type i386_exception_state_t = Struct___darwin_i386_exception_state; pub type x86_exception_state32_t = Struct___darwin_i386_exception_state; pub type x86_debug_state32_t = Struct___darwin_x86_debug_state32; pub type x86_thread_state64_t = Struct___darwin_x86_thread_state64; pub type x86_float_state64_t = Struct___darwin_x86_float_state64; pub type x86_avx_state64_t = Struct___darwin_x86_avx_state64; pub type x86_exception_state64_t = Struct___darwin_x86_exception_state64; pub type x86_debug_state64_t = Struct___darwin_x86_debug_state64; #[repr(C)] #[derive(Copy)] pub struct Struct_x86_thread_state { pub tsh: x86_state_hdr_t, pub uts: Union_Unnamed25, } impl ::std::clone::Clone for Struct_x86_thread_state { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_x86_thread_state { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy)] pub struct Union_Unnamed25 { pub _bindgen_data_: [u64; 21usize], } impl Union_Unnamed25 { pub unsafe fn ts32(&mut self) -> *mut x86_thread_state32_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn ts64(&mut self) -> *mut x86_thread_state64_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } } impl ::std::clone::Clone for Union_Unnamed25 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Union_Unnamed25 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy)] pub struct Struct_x86_float_state { pub fsh: x86_state_hdr_t, pub ufs: Union_Unnamed26, } impl ::std::clone::Clone for Struct_x86_float_state { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_x86_float_state { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy)] pub struct Union_Unnamed26 { pub _bindgen_data_: [u32; 131usize], } impl Union_Unnamed26 { pub unsafe fn fs32(&mut self) -> *mut x86_float_state32_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn fs64(&mut self) -> *mut x86_float_state64_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } } impl ::std::clone::Clone for Union_Unnamed26 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Union_Unnamed26 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy)] pub struct Struct_x86_exception_state { pub esh: x86_state_hdr_t, pub ues: Union_Unnamed27, } impl ::std::clone::Clone for Struct_x86_exception_state { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_x86_exception_state { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy)] pub struct Union_Unnamed27 { pub _bindgen_data_: [u64; 2usize], } impl Union_Unnamed27 { pub unsafe fn es32(&mut self) -> *mut x86_exception_state32_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn es64(&mut self) -> *mut x86_exception_state64_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } } impl ::std::clone::Clone for Union_Unnamed27 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Union_Unnamed27 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy)] pub struct Struct_x86_debug_state { pub dsh: x86_state_hdr_t, pub uds: Union_Unnamed28, } impl ::std::clone::Clone for Struct_x86_debug_state { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_x86_debug_state { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy)] pub struct Union_Unnamed28 { pub _bindgen_data_: [u64; 8usize], } impl Union_Unnamed28 { pub unsafe fn ds32(&mut self) -> *mut x86_debug_state32_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn ds64(&mut self) -> *mut x86_debug_state64_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } } impl ::std::clone::Clone for Union_Unnamed28 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Union_Unnamed28 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy)] pub struct Struct_x86_avx_state { pub ash: x86_state_hdr_t, pub ufs: Union_Unnamed29, } impl ::std::clone::Clone for Struct_x86_avx_state { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_x86_avx_state { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy)] pub struct Union_Unnamed29 { pub _bindgen_data_: [u32; 211usize], } impl Union_Unnamed29 { pub unsafe fn as32(&mut self) -> *mut x86_avx_state32_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn as64(&mut self) -> *mut x86_avx_state64_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } } impl ::std::clone::Clone for Union_Unnamed29 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Union_Unnamed29 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type x86_thread_state_t = Struct_x86_thread_state; pub type x86_float_state_t = Struct_x86_float_state; pub type x86_exception_state_t = Struct_x86_exception_state; pub type x86_debug_state_t = Struct_x86_debug_state; pub type x86_avx_state_t = Struct_x86_avx_state; #[repr(C)] #[derive(Copy)] pub struct Struct_x86_seg_load_fault32 { pub trapno: uint16_t, pub cpu: uint16_t, pub err: uint32_t, pub eip: uint32_t, pub cs: uint32_t, pub efl: uint32_t, } impl ::std::clone::Clone for Struct_x86_seg_load_fault32 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_x86_seg_load_fault32 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type thread_state_t = *mut natural_t; pub type thread_state_data_t = [natural_t; 224usize]; pub type thread_state_flavor_t = ::libc::c_int; pub type thread_state_flavor_array_t = *mut thread_state_flavor_t; pub type exception_type_t = ::libc::c_int; pub type exception_data_type_t = integer_t; pub type mach_exception_data_type_t = int64_t; pub type exception_behavior_t = ::libc::c_int; pub type exception_data_t = *mut exception_data_type_t; pub type mach_exception_data_t = *mut mach_exception_data_type_t; pub type exception_mask_t = ::libc::c_uint; pub type exception_mask_array_t = *mut exception_mask_t; pub type exception_behavior_array_t = *mut exception_behavior_t; pub type exception_flavor_array_t = *mut thread_state_flavor_t; pub type exception_port_array_t = *mut mach_port_t; pub type mach_exception_code_t = mach_exception_data_type_t; pub type mach_exception_subcode_t = mach_exception_data_type_t; pub type processor_info_t = *mut integer_t; pub type processor_info_array_t = *mut integer_t; pub type processor_info_data_t = [integer_t; 1024usize]; pub type processor_set_info_t = *mut integer_t; pub type processor_set_info_data_t = [integer_t; 1024usize]; pub type processor_flavor_t = ::libc::c_int; #[repr(C)] #[derive(Copy)] pub struct Struct_processor_basic_info { pub cpu_type: cpu_type_t, pub cpu_subtype: cpu_subtype_t, pub running: boolean_t, pub slot_num: ::libc::c_int, pub is_master: boolean_t, } impl ::std::clone::Clone for Struct_processor_basic_info { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_processor_basic_info { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type processor_basic_info_data_t = Struct_processor_basic_info; pub type processor_basic_info_t = *mut Struct_processor_basic_info; #[repr(C)] #[derive(Copy)] pub struct Struct_processor_cpu_load_info { pub cpu_ticks: [::libc::c_uint; 4usize], } impl ::std::clone::Clone for Struct_processor_cpu_load_info { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_processor_cpu_load_info { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type processor_cpu_load_info_data_t = Struct_processor_cpu_load_info; pub type processor_cpu_load_info_t = *mut Struct_processor_cpu_load_info; pub type processor_set_flavor_t = ::libc::c_int; #[repr(C)] #[derive(Copy)] pub struct Struct_processor_set_basic_info { pub processor_count: ::libc::c_int, pub default_policy: ::libc::c_int, } impl ::std::clone::Clone for Struct_processor_set_basic_info { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_processor_set_basic_info { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type processor_set_basic_info_data_t = Struct_processor_set_basic_info; pub type processor_set_basic_info_t = *mut Struct_processor_set_basic_info; #[repr(C)] #[derive(Copy)] pub struct Struct_processor_set_load_info { pub task_count: ::libc::c_int, pub thread_count: ::libc::c_int, pub load_average: integer_t, pub mach_factor: integer_t, } impl ::std::clone::Clone for Struct_processor_set_load_info { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_processor_set_load_info { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type processor_set_load_info_data_t = Struct_processor_set_load_info; pub type processor_set_load_info_t = *mut Struct_processor_set_load_info; pub type policy_t = ::libc::c_int; pub type policy_info_t = *mut integer_t; pub type policy_base_t = *mut integer_t; pub type policy_limit_t = *mut integer_t; #[repr(C)] #[derive(Copy)] pub struct Struct_policy_timeshare_base { pub base_priority: integer_t, } impl ::std::clone::Clone for Struct_policy_timeshare_base { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_policy_timeshare_base { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy)] pub struct Struct_policy_timeshare_limit { pub max_priority: integer_t, } impl ::std::clone::Clone for Struct_policy_timeshare_limit { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_policy_timeshare_limit { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy)] pub struct Struct_policy_timeshare_info { pub max_priority: integer_t, pub base_priority: integer_t, pub cur_priority: integer_t, pub depressed: boolean_t, pub depress_priority: integer_t, } impl ::std::clone::Clone for Struct_policy_timeshare_info { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_policy_timeshare_info { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type policy_timeshare_base_t = *mut Struct_policy_timeshare_base; pub type policy_timeshare_limit_t = *mut Struct_policy_timeshare_limit; pub type policy_timeshare_info_t = *mut Struct_policy_timeshare_info; pub type policy_timeshare_base_data_t = Struct_policy_timeshare_base; pub type policy_timeshare_limit_data_t = Struct_policy_timeshare_limit; pub type policy_timeshare_info_data_t = Struct_policy_timeshare_info; #[repr(C)] #[derive(Copy)] pub struct Struct_policy_rr_base { pub base_priority: integer_t, pub quantum: integer_t, } impl ::std::clone::Clone for Struct_policy_rr_base { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_policy_rr_base { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy)] pub struct Struct_policy_rr_limit { pub max_priority: integer_t, } impl ::std::clone::Clone for Struct_policy_rr_limit { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_policy_rr_limit { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy)] pub struct Struct_policy_rr_info { pub max_priority: integer_t, pub base_priority: integer_t, pub quantum: integer_t, pub depressed: boolean_t, pub depress_priority: integer_t, } impl ::std::clone::Clone for Struct_policy_rr_info { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_policy_rr_info { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type policy_rr_base_t = *mut Struct_policy_rr_base; pub type policy_rr_limit_t = *mut Struct_policy_rr_limit; pub type policy_rr_info_t = *mut Struct_policy_rr_info; pub type policy_rr_base_data_t = Struct_policy_rr_base; pub type policy_rr_limit_data_t = Struct_policy_rr_limit; pub type policy_rr_info_data_t = Struct_policy_rr_info; #[repr(C)] #[derive(Copy)] pub struct Struct_policy_fifo_base { pub base_priority: integer_t, } impl ::std::clone::Clone for Struct_policy_fifo_base { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_policy_fifo_base { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy)] pub struct Struct_policy_fifo_limit { pub max_priority: integer_t, } impl ::std::clone::Clone for Struct_policy_fifo_limit { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_policy_fifo_limit { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy)] pub struct Struct_policy_fifo_info { pub max_priority: integer_t, pub base_priority: integer_t, pub depressed: boolean_t, pub depress_priority: integer_t, } impl ::std::clone::Clone for Struct_policy_fifo_info { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_policy_fifo_info { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type policy_fifo_base_t = *mut Struct_policy_fifo_base; pub type policy_fifo_limit_t = *mut Struct_policy_fifo_limit; pub type policy_fifo_info_t = *mut Struct_policy_fifo_info; pub type policy_fifo_base_data_t = Struct_policy_fifo_base; pub type policy_fifo_limit_data_t = Struct_policy_fifo_limit; pub type policy_fifo_info_data_t = Struct_policy_fifo_info; #[repr(C)] #[derive(Copy)] pub struct Struct_policy_bases { pub ts: policy_timeshare_base_data_t, pub rr: policy_rr_base_data_t, pub fifo: policy_fifo_base_data_t, } impl ::std::clone::Clone for Struct_policy_bases { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_policy_bases { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy)] pub struct Struct_policy_limits { pub ts: policy_timeshare_limit_data_t, pub rr: policy_rr_limit_data_t, pub fifo: policy_fifo_limit_data_t, } impl ::std::clone::Clone for Struct_policy_limits { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_policy_limits { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy)] pub struct Struct_policy_infos { pub ts: policy_timeshare_info_data_t, pub rr: policy_rr_info_data_t, pub fifo: policy_fifo_info_data_t, } impl ::std::clone::Clone for Struct_policy_infos { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_policy_infos { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type policy_base_data_t = Struct_policy_bases; pub type policy_limit_data_t = Struct_policy_limits; pub type policy_info_data_t = Struct_policy_infos; pub type task_flavor_t = natural_t; pub type task_info_t = *mut integer_t; pub type task_info_data_t = [integer_t; 1024usize]; #[repr(C)] #[derive(Copy)] pub struct Struct_task_basic_info_32 { pub suspend_count: integer_t, pub virtual_size: natural_t, pub resident_size: natural_t, pub user_time: time_value_t, pub system_time: time_value_t, pub policy: policy_t, } impl ::std::clone::Clone for Struct_task_basic_info_32 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_task_basic_info_32 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type task_basic_info_32_data_t = Struct_task_basic_info_32; pub type task_basic_info_32_t = *mut Struct_task_basic_info_32; #[repr(C)] #[derive(Copy)] pub struct Struct_task_basic_info_64 { pub suspend_count: integer_t, pub virtual_size: mach_vm_size_t, pub resident_size: mach_vm_size_t, pub user_time: time_value_t, pub system_time: time_value_t, pub policy: policy_t, } impl ::std::clone::Clone for Struct_task_basic_info_64 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_task_basic_info_64 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type task_basic_info_64_data_t = Struct_task_basic_info_64; pub type task_basic_info_64_t = *mut Struct_task_basic_info_64; #[repr(C)] #[derive(Copy)] pub struct Struct_task_basic_info { pub suspend_count: integer_t, pub virtual_size: vm_size_t, pub resident_size: vm_size_t, pub user_time: time_value_t, pub system_time: time_value_t, pub policy: policy_t, } impl ::std::clone::Clone for Struct_task_basic_info { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_task_basic_info { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type task_basic_info_data_t = Struct_task_basic_info; pub type task_basic_info_t = *mut Struct_task_basic_info; #[repr(C)] #[derive(Copy)] pub struct Struct_task_events_info { pub faults: integer_t, pub pageins: integer_t, pub cow_faults: integer_t, pub messages_sent: integer_t, pub messages_received: integer_t, pub syscalls_mach: integer_t, pub syscalls_unix: integer_t, pub csw: integer_t, } impl ::std::clone::Clone for Struct_task_events_info { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_task_events_info { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type task_events_info_data_t = Struct_task_events_info; pub type task_events_info_t = *mut Struct_task_events_info; #[repr(C)] #[derive(Copy)] pub struct Struct_task_thread_times_info { pub user_time: time_value_t, pub system_time: time_value_t, } impl ::std::clone::Clone for Struct_task_thread_times_info { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_task_thread_times_info { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type task_thread_times_info_data_t = Struct_task_thread_times_info; pub type task_thread_times_info_t = *mut Struct_task_thread_times_info; #[repr(C)] #[derive(Copy)] pub struct Struct_task_absolutetime_info { pub total_user: uint64_t, pub total_system: uint64_t, pub threads_user: uint64_t, pub threads_system: uint64_t, } impl ::std::clone::Clone for Struct_task_absolutetime_info { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_task_absolutetime_info { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type task_absolutetime_info_data_t = Struct_task_absolutetime_info; pub type task_absolutetime_info_t = *mut Struct_task_absolutetime_info; #[repr(C)] #[derive(Copy)] pub struct Struct_task_kernelmemory_info { pub total_palloc: uint64_t, pub total_pfree: uint64_t, pub total_salloc: uint64_t, pub total_sfree: uint64_t, } impl ::std::clone::Clone for Struct_task_kernelmemory_info { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_task_kernelmemory_info { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type task_kernelmemory_info_data_t = Struct_task_kernelmemory_info; pub type task_kernelmemory_info_t = *mut Struct_task_kernelmemory_info; #[repr(C)] #[derive(Copy)] pub struct Struct_task_affinity_tag_info { pub set_count: integer_t, pub min: integer_t, pub max: integer_t, pub task_count: integer_t, } impl ::std::clone::Clone for Struct_task_affinity_tag_info { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_task_affinity_tag_info { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type task_affinity_tag_info_data_t = Struct_task_affinity_tag_info; pub type task_affinity_tag_info_t = *mut Struct_task_affinity_tag_info; #[repr(C)] #[derive(Copy)] pub struct Struct_task_dyld_info { pub all_image_info_addr: mach_vm_address_t, pub all_image_info_size: mach_vm_size_t, pub all_image_info_format: integer_t, } impl ::std::clone::Clone for Struct_task_dyld_info { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_task_dyld_info { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type task_dyld_info_data_t = Struct_task_dyld_info; pub type task_dyld_info_t = *mut Struct_task_dyld_info; #[repr(C)] #[derive(Copy)] pub struct Struct_task_extmod_info { pub task_uuid: [::libc::c_uchar; 16usize], pub extmod_statistics: vm_extmod_statistics_data_t, } impl ::std::clone::Clone for Struct_task_extmod_info { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_task_extmod_info { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type task_extmod_info_data_t = Struct_task_extmod_info; pub type task_extmod_info_t = *mut Struct_task_extmod_info; #[repr(C)] #[derive(Copy)] pub struct Struct_task_power_info { pub total_user: uint64_t, pub total_system: uint64_t, pub task_interrupt_wakeups: uint64_t, pub task_platform_idle_wakeups: uint64_t, pub task_timer_wakeups_bin_1: uint64_t, pub task_timer_wakeups_bin_2: uint64_t, } impl ::std::clone::Clone for Struct_task_power_info { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_task_power_info { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type task_power_info_data_t = Struct_task_power_info; pub type task_power_info_t = *mut Struct_task_power_info; #[repr(C)] #[derive(Copy)] pub struct Struct_mach_task_basic_info { pub virtual_size: mach_vm_size_t, pub resident_size: mach_vm_size_t, pub resident_size_max: mach_vm_size_t, pub user_time: time_value_t, pub system_time: time_value_t, pub policy: policy_t, pub suspend_count: integer_t, } impl ::std::clone::Clone for Struct_mach_task_basic_info { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_mach_task_basic_info { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type mach_task_basic_info_data_t = Struct_mach_task_basic_info; pub type mach_task_basic_info_t = *mut Struct_mach_task_basic_info; pub type task_policy_flavor_t = natural_t; pub type task_policy_t = *mut integer_t; pub type Enum_task_role = ::libc::c_int; pub const TASK_RENICED: ::libc::c_int = -1; pub const TASK_UNSPECIFIED: ::libc::c_int = 0; pub const TASK_FOREGROUND_APPLICATION: ::libc::c_int = 1; pub const TASK_BACKGROUND_APPLICATION: ::libc::c_int = 2; pub const TASK_CONTROL_APPLICATION: ::libc::c_int = 3; pub const TASK_GRAPHICS_SERVER: ::libc::c_int = 4; pub const TASK_THROTTLE_APPLICATION: ::libc::c_int = 5; pub const TASK_NONUI_APPLICATION: ::libc::c_int = 6; pub const TASK_DEFAULT_APPLICATION: ::libc::c_int = 7; pub type task_role_t = Enum_task_role; #[repr(C)] #[derive(Copy)] pub struct Struct_task_category_policy { pub role: task_role_t, } impl ::std::clone::Clone for Struct_task_category_policy { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_task_category_policy { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type task_category_policy_data_t = Struct_task_category_policy; pub type task_category_policy_t = *mut Struct_task_category_policy; pub type task_special_port_t = ::libc::c_int; pub type thread_flavor_t = natural_t; pub type thread_info_t = *mut integer_t; pub type thread_info_data_t = [integer_t; 1024usize]; #[repr(C)] #[derive(Copy)] pub struct Struct_thread_basic_info { pub user_time: time_value_t, pub system_time: time_value_t, pub cpu_usage: integer_t, pub policy: policy_t, pub run_state: integer_t, pub flags: integer_t, pub suspend_count: integer_t, pub sleep_time: integer_t, } impl ::std::clone::Clone for Struct_thread_basic_info { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_thread_basic_info { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type thread_basic_info_data_t = Struct_thread_basic_info; pub type thread_basic_info_t = *mut Struct_thread_basic_info; #[repr(C)] #[derive(Copy)] pub struct Struct_thread_identifier_info { pub thread_id: uint64_t, pub thread_handle: uint64_t, pub dispatch_qaddr: uint64_t, } impl ::std::clone::Clone for Struct_thread_identifier_info { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_thread_identifier_info { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type thread_identifier_info_data_t = Struct_thread_identifier_info; pub type thread_identifier_info_t = *mut Struct_thread_identifier_info; pub type thread_policy_flavor_t = natural_t; pub type thread_policy_t = *mut integer_t; #[repr(C)] #[derive(Copy)] pub struct Struct_thread_standard_policy { pub no_data: natural_t, } impl ::std::clone::Clone for Struct_thread_standard_policy { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_thread_standard_policy { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type thread_standard_policy_data_t = Struct_thread_standard_policy; pub type thread_standard_policy_t = *mut Struct_thread_standard_policy; #[repr(C)] #[derive(Copy)] pub struct Struct_thread_extended_policy { pub timeshare: boolean_t, } impl ::std::clone::Clone for Struct_thread_extended_policy { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_thread_extended_policy { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type thread_extended_policy_data_t = Struct_thread_extended_policy; pub type thread_extended_policy_t = *mut Struct_thread_extended_policy; #[repr(C)] #[derive(Copy)] pub struct Struct_thread_time_constraint_policy { pub period: uint32_t, pub computation: uint32_t, pub constraint: uint32_t, pub preemptible: boolean_t, } impl ::std::clone::Clone for Struct_thread_time_constraint_policy { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_thread_time_constraint_policy { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type thread_time_constraint_policy_data_t = Struct_thread_time_constraint_policy; pub type thread_time_constraint_policy_t = *mut Struct_thread_time_constraint_policy; #[repr(C)] #[derive(Copy)] pub struct Struct_thread_precedence_policy { pub importance: integer_t, } impl ::std::clone::Clone for Struct_thread_precedence_policy { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_thread_precedence_policy { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type thread_precedence_policy_data_t = Struct_thread_precedence_policy; pub type thread_precedence_policy_t = *mut Struct_thread_precedence_policy; #[repr(C)] #[derive(Copy)] pub struct Struct_thread_affinity_policy { pub affinity_tag: integer_t, } impl ::std::clone::Clone for Struct_thread_affinity_policy { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_thread_affinity_policy { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type thread_affinity_policy_data_t = Struct_thread_affinity_policy; pub type thread_affinity_policy_t = *mut Struct_thread_affinity_policy; #[repr(C)] #[derive(Copy)] pub struct Struct_thread_background_policy { pub priority: integer_t, } impl ::std::clone::Clone for Struct_thread_background_policy { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_thread_background_policy { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type thread_background_policy_data_t = Struct_thread_background_policy; pub type thread_background_policy_t = *mut Struct_thread_background_policy; pub type alarm_type_t = ::libc::c_int; pub type sleep_type_t = ::libc::c_int; pub type clock_id_t = ::libc::c_int; pub type clock_flavor_t = ::libc::c_int; pub type clock_attr_t = *mut ::libc::c_int; pub type clock_res_t = ::libc::c_int; #[repr(C)] #[derive(Copy)] pub struct Struct_mach_timespec { pub tv_sec: ::libc::c_uint, pub tv_nsec: clock_res_t, } impl ::std::clone::Clone for Struct_mach_timespec { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_mach_timespec { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type mach_timespec_t = Struct_mach_timespec; pub type vm_machine_attribute_t = ::libc::c_uint; pub type vm_machine_attribute_val_t = ::libc::c_int; pub type vm_inherit_t = ::libc::c_uint; pub type vm_purgable_t = ::libc::c_int; pub type vm_behavior_t = ::libc::c_int; pub type vm32_object_id_t = uint32_t; pub type vm_region_info_t = *mut ::libc::c_int; pub type vm_region_info_64_t = *mut ::libc::c_int; pub type vm_region_recurse_info_t = *mut ::libc::c_int; pub type vm_region_recurse_info_64_t = *mut ::libc::c_int; pub type vm_region_flavor_t = ::libc::c_int; pub type vm_region_info_data_t = [::libc::c_int; 1024usize]; #[repr(C)] #[derive(Copy)] pub struct Struct_vm_region_basic_info_64 { pub protection: vm_prot_t, pub max_protection: vm_prot_t, pub inheritance: vm_inherit_t, pub shared: boolean_t, pub reserved: boolean_t, pub offset: memory_object_offset_t, pub behavior: vm_behavior_t, pub user_wired_count: ::libc::c_ushort, } impl ::std::clone::Clone for Struct_vm_region_basic_info_64 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_vm_region_basic_info_64 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type vm_region_basic_info_64_t = *mut Struct_vm_region_basic_info_64; pub type vm_region_basic_info_data_64_t = Struct_vm_region_basic_info_64; #[repr(C)] #[derive(Copy)] pub struct Struct_vm_region_basic_info { pub protection: vm_prot_t, pub max_protection: vm_prot_t, pub inheritance: vm_inherit_t, pub shared: boolean_t, pub reserved: boolean_t, pub offset: uint32_t, pub behavior: vm_behavior_t, pub user_wired_count: ::libc::c_ushort, } impl ::std::clone::Clone for Struct_vm_region_basic_info { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_vm_region_basic_info { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type vm_region_basic_info_t = *mut Struct_vm_region_basic_info; pub type vm_region_basic_info_data_t = Struct_vm_region_basic_info; #[repr(C)] #[derive(Copy)] pub struct Struct_vm_region_extended_info { pub protection: vm_prot_t, pub user_tag: ::libc::c_uint, pub pages_resident: ::libc::c_uint, pub pages_shared_now_private: ::libc::c_uint, pub pages_swapped_out: ::libc::c_uint, pub pages_dirtied: ::libc::c_uint, pub ref_count: ::libc::c_uint, pub shadow_depth: ::libc::c_ushort, pub external_pager: ::libc::c_uchar, pub share_mode: ::libc::c_uchar, } impl ::std::clone::Clone for Struct_vm_region_extended_info { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_vm_region_extended_info { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type vm_region_extended_info_t = *mut Struct_vm_region_extended_info; pub type vm_region_extended_info_data_t = Struct_vm_region_extended_info; #[repr(C)] #[derive(Copy)] pub struct Struct_vm_region_top_info { pub obj_id: ::libc::c_uint, pub ref_count: ::libc::c_uint, pub private_pages_resident: ::libc::c_uint, pub shared_pages_resident: ::libc::c_uint, pub share_mode: ::libc::c_uchar, } impl ::std::clone::Clone for Struct_vm_region_top_info { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_vm_region_top_info { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type vm_region_top_info_t = *mut Struct_vm_region_top_info; pub type vm_region_top_info_data_t = Struct_vm_region_top_info; #[repr(C)] #[derive(Copy)] pub struct Struct_vm_region_submap_info { pub protection: vm_prot_t, pub max_protection: vm_prot_t, pub inheritance: vm_inherit_t, pub offset: uint32_t, pub user_tag: ::libc::c_uint, pub pages_resident: ::libc::c_uint, pub pages_shared_now_private: ::libc::c_uint, pub pages_swapped_out: ::libc::c_uint, pub pages_dirtied: ::libc::c_uint, pub ref_count: ::libc::c_uint, pub shadow_depth: ::libc::c_ushort, pub external_pager: ::libc::c_uchar, pub share_mode: ::libc::c_uchar, pub is_submap: boolean_t, pub behavior: vm_behavior_t, pub object_id: vm32_object_id_t, pub user_wired_count: ::libc::c_ushort, } impl ::std::clone::Clone for Struct_vm_region_submap_info { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_vm_region_submap_info { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type vm_region_submap_info_t = *mut Struct_vm_region_submap_info; pub type vm_region_submap_info_data_t = Struct_vm_region_submap_info; #[repr(C)] #[derive(Copy)] pub struct Struct_vm_region_submap_info_64 { pub protection: vm_prot_t, pub max_protection: vm_prot_t, pub inheritance: vm_inherit_t, pub offset: memory_object_offset_t, pub user_tag: ::libc::c_uint, pub pages_resident: ::libc::c_uint, pub pages_shared_now_private: ::libc::c_uint, pub pages_swapped_out: ::libc::c_uint, pub pages_dirtied: ::libc::c_uint, pub ref_count: ::libc::c_uint, pub shadow_depth: ::libc::c_ushort, pub external_pager: ::libc::c_uchar, pub share_mode: ::libc::c_uchar, pub is_submap: boolean_t, pub behavior: vm_behavior_t, pub object_id: vm32_object_id_t, pub user_wired_count: ::libc::c_ushort, } impl ::std::clone::Clone for Struct_vm_region_submap_info_64 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_vm_region_submap_info_64 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type vm_region_submap_info_64_t = *mut Struct_vm_region_submap_info_64; pub type vm_region_submap_info_data_64_t = Struct_vm_region_submap_info_64; #[repr(C)] #[derive(Copy)] pub struct Struct_vm_region_submap_short_info_64 { pub protection: vm_prot_t, pub max_protection: vm_prot_t, pub inheritance: vm_inherit_t, pub offset: memory_object_offset_t, pub user_tag: ::libc::c_uint, pub ref_count: ::libc::c_uint, pub shadow_depth: ::libc::c_ushort, pub external_pager: ::libc::c_uchar, pub share_mode: ::libc::c_uchar, pub is_submap: boolean_t, pub behavior: vm_behavior_t, pub object_id: vm32_object_id_t, pub user_wired_count: ::libc::c_ushort, } impl ::std::clone::Clone for Struct_vm_region_submap_short_info_64 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_vm_region_submap_short_info_64 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type vm_region_submap_short_info_64_t = *mut Struct_vm_region_submap_short_info_64; pub type vm_region_submap_short_info_data_64_t = Struct_vm_region_submap_short_info_64; #[repr(C)] #[derive(Copy)] pub struct Struct_mach_vm_read_entry { pub address: mach_vm_address_t, pub size: mach_vm_size_t, } impl ::std::clone::Clone for Struct_mach_vm_read_entry { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_mach_vm_read_entry { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy)] pub struct Struct_vm_read_entry { pub address: vm_address_t, pub size: vm_size_t, } impl ::std::clone::Clone for Struct_vm_read_entry { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_vm_read_entry { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type mach_vm_read_entry_t = [Struct_mach_vm_read_entry; 256usize]; pub type vm_read_entry_t = [Struct_vm_read_entry; 256usize]; pub type vm_page_info_t = *mut ::libc::c_int; pub type vm_page_info_data_t = *mut ::libc::c_int; pub type vm_page_info_flavor_t = ::libc::c_int; #[repr(C)] #[derive(Copy)] pub struct Struct_vm_page_info_basic { pub disposition: ::libc::c_int, pub ref_count: ::libc::c_int, pub object_id: vm_object_id_t, pub offset: memory_object_offset_t, pub depth: ::libc::c_int, pub __pad: ::libc::c_int, } impl ::std::clone::Clone for Struct_vm_page_info_basic { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_vm_page_info_basic { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type vm_page_info_basic_t = *mut Struct_vm_page_info_basic; pub type vm_page_info_basic_data_t = Struct_vm_page_info_basic; pub type kmod_t = ::libc::c_int; pub type kmod_start_func_t = extern "C" fn(ki: *mut Struct_kmod_info, data: *mut ::libc::c_void) -> kern_return_t; pub type kmod_stop_func_t = extern "C" fn(ki: *mut Struct_kmod_info, data: *mut ::libc::c_void) -> kern_return_t; #[repr(C)] #[derive(Copy)] pub struct Struct_kmod_reference { pub next: *mut Struct_kmod_reference, pub info: *mut Struct_kmod_info, } impl ::std::clone::Clone for Struct_kmod_reference { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_kmod_reference { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type kmod_reference_t = Struct_kmod_reference; #[repr(C)] #[derive(Copy)] pub struct Struct_kmod_info { pub next: *mut Struct_kmod_info, pub info_version: int32_t, pub id: uint32_t, pub name: [::libc::c_char; 64usize], pub version: [::libc::c_char; 64usize], pub reference_count: int32_t, pub reference_list: *mut kmod_reference_t, pub address: vm_address_t, pub size: vm_size_t, pub hdr_size: vm_size_t, pub start: *mut ::std::option::Option kern_return_t>, pub stop: *mut ::std::option::Option kern_return_t>, } impl ::std::clone::Clone for Struct_kmod_info { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_kmod_info { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type kmod_info_t = Struct_kmod_info; #[repr(C)] #[derive(Copy)] pub struct Struct_kmod_info_32_v1 { pub next_addr: uint32_t, pub info_version: int32_t, pub id: uint32_t, pub name: [uint8_t; 64usize], pub version: [uint8_t; 64usize], pub reference_count: int32_t, pub reference_list_addr: uint32_t, pub address: uint32_t, pub size: uint32_t, pub hdr_size: uint32_t, pub start_addr: uint32_t, pub stop_addr: uint32_t, } impl ::std::clone::Clone for Struct_kmod_info_32_v1 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_kmod_info_32_v1 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type kmod_info_32_v1_t = Struct_kmod_info_32_v1; #[repr(C)] #[derive(Copy)] pub struct Struct_kmod_info_64_v1 { pub next_addr: uint64_t, pub info_version: int32_t, pub id: uint32_t, pub name: [uint8_t; 64usize], pub version: [uint8_t; 64usize], pub reference_count: int32_t, pub reference_list_addr: uint64_t, pub address: uint64_t, pub size: uint64_t, pub hdr_size: uint64_t, pub start_addr: uint64_t, pub stop_addr: uint64_t, } impl ::std::clone::Clone for Struct_kmod_info_64_v1 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_kmod_info_64_v1 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type kmod_info_64_v1_t = Struct_kmod_info_64_v1; pub type kmod_args_t = *mut ::libc::c_void; pub type kmod_control_flavor_t = ::libc::c_int; pub type kmod_info_array_t = *mut kmod_info_t; pub type task_t = mach_port_t; pub type task_name_t = mach_port_t; pub type thread_t = mach_port_t; pub type thread_act_t = mach_port_t; pub type ipc_space_t = mach_port_t; pub type host_t = mach_port_t; pub type host_priv_t = mach_port_t; pub type host_security_t = mach_port_t; pub type processor_t = mach_port_t; pub type processor_set_t = mach_port_t; pub type processor_set_control_t = mach_port_t; pub type semaphore_t = mach_port_t; pub type lock_set_t = mach_port_t; pub type ledger_t = mach_port_t; pub type alarm_t = mach_port_t; pub type clock_serv_t = mach_port_t; pub type clock_ctrl_t = mach_port_t; pub type processor_set_name_t = processor_set_t; pub type clock_reply_t = mach_port_t; pub type bootstrap_t = mach_port_t; pub type mem_entry_name_port_t = mach_port_t; pub type exception_handler_t = mach_port_t; pub type exception_handler_array_t = *mut exception_handler_t; pub type vm_task_entry_t = mach_port_t; pub type io_master_t = mach_port_t; pub type UNDServerRef = mach_port_t; pub type task_array_t = *mut task_t; pub type thread_array_t = *mut thread_t; pub type processor_set_array_t = *mut processor_set_t; pub type processor_set_name_array_t = *mut processor_set_t; pub type processor_array_t = *mut processor_t; pub type thread_act_array_t = *mut thread_act_t; pub type ledger_array_t = *mut ledger_t; pub type task_port_t = task_t; pub type task_port_array_t = task_array_t; pub type thread_port_t = thread_t; pub type thread_port_array_t = thread_array_t; pub type ipc_space_port_t = ipc_space_t; pub type host_name_t = host_t; pub type host_name_port_t = host_t; pub type processor_set_port_t = processor_set_t; pub type processor_set_name_port_t = processor_set_t; pub type processor_set_name_port_array_t = processor_set_array_t; pub type processor_set_control_port_t = processor_set_t; pub type processor_port_t = processor_t; pub type processor_port_array_t = processor_array_t; pub type thread_act_port_t = thread_act_t; pub type thread_act_port_array_t = thread_act_array_t; pub type semaphore_port_t = semaphore_t; pub type lock_set_port_t = lock_set_t; pub type ledger_port_t = ledger_t; pub type ledger_port_array_t = ledger_array_t; pub type alarm_port_t = alarm_t; pub type clock_serv_port_t = clock_serv_t; pub type clock_ctrl_port_t = clock_ctrl_t; pub type exception_port_t = exception_handler_t; pub type exception_port_arrary_t = exception_handler_array_t; pub type ledger_item_t = natural_t; pub type ledger_amount_t = int64_t; pub type emulation_vector_t = *mut mach_vm_offset_t; pub type user_subsystem_t = *mut ::libc::c_char; pub type labelstr_t = *mut ::libc::c_char; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed30 { pub mig_vers: ::libc::c_uchar, pub if_vers: ::libc::c_uchar, pub reserved1: ::libc::c_uchar, pub mig_encoding: ::libc::c_uchar, pub int_rep: ::libc::c_uchar, pub char_rep: ::libc::c_uchar, pub float_rep: ::libc::c_uchar, pub reserved2: ::libc::c_uchar, } impl ::std::clone::Clone for Struct_Unnamed30 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed30 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type NDR_record_t = Struct_Unnamed30; pub type notify_port_t = mach_port_t; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed31 { pub not_header: mach_msg_header_t, pub NDR: NDR_record_t, pub not_port: mach_port_name_t, pub trailer: mach_msg_format_0_trailer_t, } impl ::std::clone::Clone for Struct_Unnamed31 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed31 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type mach_port_deleted_notification_t = Struct_Unnamed31; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed32 { pub not_header: mach_msg_header_t, pub NDR: NDR_record_t, pub not_port: mach_port_name_t, pub trailer: mach_msg_format_0_trailer_t, } impl ::std::clone::Clone for Struct_Unnamed32 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed32 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type mach_send_possible_notification_t = Struct_Unnamed32; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed33 { pub not_header: mach_msg_header_t, pub not_body: mach_msg_body_t, pub not_port: mach_msg_port_descriptor_t, pub trailer: mach_msg_format_0_trailer_t, } impl ::std::clone::Clone for Struct_Unnamed33 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed33 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type mach_port_destroyed_notification_t = Struct_Unnamed33; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed34 { pub not_header: mach_msg_header_t, pub NDR: NDR_record_t, pub not_count: mach_msg_type_number_t, pub trailer: mach_msg_format_0_trailer_t, } impl ::std::clone::Clone for Struct_Unnamed34 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed34 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type mach_no_senders_notification_t = Struct_Unnamed34; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed35 { pub not_header: mach_msg_header_t, pub trailer: mach_msg_format_0_trailer_t, } impl ::std::clone::Clone for Struct_Unnamed35 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed35 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type mach_send_once_notification_t = Struct_Unnamed35; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed36 { pub not_header: mach_msg_header_t, pub NDR: NDR_record_t, pub not_port: mach_port_name_t, pub trailer: mach_msg_format_0_trailer_t, } impl ::std::clone::Clone for Struct_Unnamed36 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed36 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type mach_dead_name_notification_t = Struct_Unnamed36; pub type mig_stub_routine_t = ::std::option::Option< extern "C" fn(InHeadP: *mut mach_msg_header_t, OutHeadP: *mut mach_msg_header_t) -> (), >; pub type mig_routine_t = mig_stub_routine_t; pub type mig_server_routine_t = ::std::option::Option mig_routine_t>; pub type mig_impl_routine_t = ::std::option::Option kern_return_t>; pub type routine_arg_descriptor = mach_msg_type_descriptor_t; pub type routine_arg_descriptor_t = *mut mach_msg_type_descriptor_t; pub type mig_routine_arg_descriptor_t = *mut mach_msg_type_descriptor_t; #[repr(C)] #[derive(Copy)] pub struct Struct_routine_descriptor { pub impl_routine: mig_impl_routine_t, pub stub_routine: mig_stub_routine_t, pub argc: ::libc::c_uint, pub descr_count: ::libc::c_uint, pub arg_descr: routine_arg_descriptor_t, pub max_reply_msg: ::libc::c_uint, } impl ::std::clone::Clone for Struct_routine_descriptor { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_routine_descriptor { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type routine_descriptor_t = *mut Struct_routine_descriptor; pub type mig_routine_descriptor = Struct_routine_descriptor; pub type mig_routine_descriptor_t = *mut mig_routine_descriptor; #[repr(C)] #[derive(Copy)] pub struct Struct_mig_subsystem { pub server: mig_server_routine_t, pub start: mach_msg_id_t, pub end: mach_msg_id_t, pub maxsize: mach_msg_size_t, pub reserved: vm_address_t, pub routine: [mig_routine_descriptor; 1usize], } impl ::std::clone::Clone for Struct_mig_subsystem { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_mig_subsystem { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type mig_subsystem_t = *mut Struct_mig_subsystem; #[repr(C)] #[derive(Copy)] pub struct Struct_mig_symtab { pub ms_routine_name: *mut ::libc::c_char, pub ms_routine_number: ::libc::c_int, pub ms_routine: ::std::option::Option ()>, } impl ::std::clone::Clone for Struct_mig_symtab { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_mig_symtab { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type mig_symtab_t = Struct_mig_symtab; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed37 { pub Head: mach_msg_header_t, pub NDR: NDR_record_t, pub RetCode: kern_return_t, } impl ::std::clone::Clone for Struct_Unnamed37 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed37 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type mig_reply_error_t = Struct_Unnamed37; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed38 { pub Head: mach_msg_header_t, pub NDR: NDR_record_t, pub new_time: mach_timespec_t, } impl ::std::clone::Clone for Struct_Unnamed38 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed38 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __Request__clock_set_time_t = Struct_Unnamed38; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed39 { pub Head: mach_msg_header_t, pub NDR: NDR_record_t, pub flavor: clock_flavor_t, pub clock_attrCnt: mach_msg_type_number_t, pub clock_attr: [::libc::c_int; 1usize], } impl ::std::clone::Clone for Struct_Unnamed39 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed39 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __Request__clock_set_attributes_t = Struct_Unnamed39; #[repr(C)] #[derive(Copy)] pub struct Union___RequestUnion__clock_priv_subsystem { pub _bindgen_data_: [u32; 11usize], } impl Union___RequestUnion__clock_priv_subsystem { pub unsafe fn Request_clock_set_time(&mut self) -> *mut __Request__clock_set_time_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Request_clock_set_attributes( &mut self, ) -> *mut __Request__clock_set_attributes_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } } impl ::std::clone::Clone for Union___RequestUnion__clock_priv_subsystem { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Union___RequestUnion__clock_priv_subsystem { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed40 { pub Head: mach_msg_header_t, pub NDR: NDR_record_t, pub RetCode: kern_return_t, } impl ::std::clone::Clone for Struct_Unnamed40 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed40 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __Reply__clock_set_time_t = Struct_Unnamed40; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed41 { pub Head: mach_msg_header_t, pub NDR: NDR_record_t, pub RetCode: kern_return_t, } impl ::std::clone::Clone for Struct_Unnamed41 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed41 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __Reply__clock_set_attributes_t = Struct_Unnamed41; #[repr(C)] #[derive(Copy)] pub struct Union___ReplyUnion__clock_priv_subsystem { pub _bindgen_data_: [u32; 9usize], } impl Union___ReplyUnion__clock_priv_subsystem { pub unsafe fn Reply_clock_set_time(&mut self) -> *mut __Reply__clock_set_time_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Reply_clock_set_attributes(&mut self) -> *mut __Reply__clock_set_attributes_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } } impl ::std::clone::Clone for Union___ReplyUnion__clock_priv_subsystem { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Union___ReplyUnion__clock_priv_subsystem { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed42 { pub Head: mach_msg_header_t, } impl ::std::clone::Clone for Struct_Unnamed42 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed42 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __Request__host_get_boot_info_t = Struct_Unnamed42; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed43 { pub Head: mach_msg_header_t, pub NDR: NDR_record_t, pub options: ::libc::c_int, } impl ::std::clone::Clone for Struct_Unnamed43 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed43 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __Request__host_reboot_t = Struct_Unnamed43; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed44 { pub Head: mach_msg_header_t, pub NDR: NDR_record_t, pub flavor: host_flavor_t, pub host_info_outCnt: mach_msg_type_number_t, } impl ::std::clone::Clone for Struct_Unnamed44 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed44 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __Request__host_priv_statistics_t = Struct_Unnamed44; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed45 { pub Head: mach_msg_header_t, pub msgh_body: mach_msg_body_t, pub default_manager: mach_msg_port_descriptor_t, pub NDR: NDR_record_t, pub cluster_size: memory_object_cluster_size_t, } impl ::std::clone::Clone for Struct_Unnamed45 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed45 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __Request__host_default_memory_manager_t = Struct_Unnamed45; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed46 { pub Head: mach_msg_header_t, pub msgh_body: mach_msg_body_t, pub task: mach_msg_port_descriptor_t, pub NDR: NDR_record_t, pub address: vm_address_t, pub size: vm_size_t, pub desired_access: vm_prot_t, } impl ::std::clone::Clone for Struct_Unnamed46 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed46 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __Request__vm_wire_t = Struct_Unnamed46; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed47 { pub Head: mach_msg_header_t, pub msgh_body: mach_msg_body_t, pub thread: mach_msg_port_descriptor_t, pub NDR: NDR_record_t, pub wired: boolean_t, } impl ::std::clone::Clone for Struct_Unnamed47 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed47 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __Request__thread_wire_t = Struct_Unnamed47; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed48 { pub Head: mach_msg_header_t, pub msgh_body: mach_msg_body_t, pub task: mach_msg_port_descriptor_t, pub NDR: NDR_record_t, pub address: vm_address_t, pub size: vm_size_t, pub flags: ::libc::c_int, } impl ::std::clone::Clone for Struct_Unnamed48 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed48 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __Request__vm_allocate_cpm_t = Struct_Unnamed48; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed49 { pub Head: mach_msg_header_t, } impl ::std::clone::Clone for Struct_Unnamed49 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed49 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __Request__host_processors_t = Struct_Unnamed49; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed50 { pub Head: mach_msg_header_t, pub NDR: NDR_record_t, pub clock_id: clock_id_t, } impl ::std::clone::Clone for Struct_Unnamed50 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed50 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __Request__host_get_clock_control_t = Struct_Unnamed50; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed51 { pub Head: mach_msg_header_t, pub NDR: NDR_record_t, pub info: vm_address_t, } impl ::std::clone::Clone for Struct_Unnamed51 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed51 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __Request__kmod_create_t = Struct_Unnamed51; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed52 { pub Head: mach_msg_header_t, pub NDR: NDR_record_t, pub module: kmod_t, } impl ::std::clone::Clone for Struct_Unnamed52 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed52 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __Request__kmod_destroy_t = Struct_Unnamed52; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed53 { pub Head: mach_msg_header_t, pub msgh_body: mach_msg_body_t, pub data: mach_msg_ool_descriptor_t, pub NDR: NDR_record_t, pub module: kmod_t, pub flavor: kmod_control_flavor_t, pub dataCnt: mach_msg_type_number_t, } impl ::std::clone::Clone for Struct_Unnamed53 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed53 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __Request__kmod_control_t = Struct_Unnamed53; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed54 { pub Head: mach_msg_header_t, pub NDR: NDR_record_t, pub node: ::libc::c_int, pub which: ::libc::c_int, } impl ::std::clone::Clone for Struct_Unnamed54 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed54 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __Request__host_get_special_port_t = Struct_Unnamed54; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed55 { pub Head: mach_msg_header_t, pub msgh_body: mach_msg_body_t, pub port: mach_msg_port_descriptor_t, pub NDR: NDR_record_t, pub which: ::libc::c_int, } impl ::std::clone::Clone for Struct_Unnamed55 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed55 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __Request__host_set_special_port_t = Struct_Unnamed55; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed56 { pub Head: mach_msg_header_t, pub msgh_body: mach_msg_body_t, pub new_port: mach_msg_port_descriptor_t, pub NDR: NDR_record_t, pub exception_mask: exception_mask_t, pub behavior: exception_behavior_t, pub new_flavor: thread_state_flavor_t, } impl ::std::clone::Clone for Struct_Unnamed56 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed56 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __Request__host_set_exception_ports_t = Struct_Unnamed56; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed57 { pub Head: mach_msg_header_t, pub NDR: NDR_record_t, pub exception_mask: exception_mask_t, } impl ::std::clone::Clone for Struct_Unnamed57 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed57 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __Request__host_get_exception_ports_t = Struct_Unnamed57; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed58 { pub Head: mach_msg_header_t, pub msgh_body: mach_msg_body_t, pub new_port: mach_msg_port_descriptor_t, pub NDR: NDR_record_t, pub exception_mask: exception_mask_t, pub behavior: exception_behavior_t, pub new_flavor: thread_state_flavor_t, } impl ::std::clone::Clone for Struct_Unnamed58 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed58 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __Request__host_swap_exception_ports_t = Struct_Unnamed58; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed59 { pub Head: mach_msg_header_t, pub msgh_body: mach_msg_body_t, pub task: mach_msg_port_descriptor_t, pub NDR: NDR_record_t, pub address: mach_vm_address_t, pub size: mach_vm_size_t, pub desired_access: vm_prot_t, } impl ::std::clone::Clone for Struct_Unnamed59 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed59 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __Request__mach_vm_wire_t = Struct_Unnamed59; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed60 { pub Head: mach_msg_header_t, } impl ::std::clone::Clone for Struct_Unnamed60 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed60 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __Request__host_processor_sets_t = Struct_Unnamed60; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed61 { pub Head: mach_msg_header_t, pub msgh_body: mach_msg_body_t, pub set_name: mach_msg_port_descriptor_t, } impl ::std::clone::Clone for Struct_Unnamed61 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed61 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __Request__host_processor_set_priv_t = Struct_Unnamed61; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed62 { pub Head: mach_msg_header_t, pub msgh_body: mach_msg_body_t, pub control_port: mach_msg_port_descriptor_t, } impl ::std::clone::Clone for Struct_Unnamed62 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed62 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __Request__set_dp_control_port_t = Struct_Unnamed62; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed63 { pub Head: mach_msg_header_t, } impl ::std::clone::Clone for Struct_Unnamed63 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed63 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __Request__get_dp_control_port_t = Struct_Unnamed63; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed64 { pub Head: mach_msg_header_t, pub msgh_body: mach_msg_body_t, pub server: mach_msg_port_descriptor_t, } impl ::std::clone::Clone for Struct_Unnamed64 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed64 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __Request__host_set_UNDServer_t = Struct_Unnamed64; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed65 { pub Head: mach_msg_header_t, } impl ::std::clone::Clone for Struct_Unnamed65 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed65 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __Request__host_get_UNDServer_t = Struct_Unnamed65; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed66 { pub Head: mach_msg_header_t, pub msgh_body: mach_msg_body_t, pub request_data: mach_msg_ool_descriptor_t, pub NDR: NDR_record_t, pub user_log_flags: uint32_t, pub request_dataCnt: mach_msg_type_number_t, } impl ::std::clone::Clone for Struct_Unnamed66 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed66 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __Request__kext_request_t = Struct_Unnamed66; #[repr(C)] #[derive(Copy)] pub struct Union___RequestUnion__host_priv_subsystem { pub _bindgen_data_: [u32; 17usize], } impl Union___RequestUnion__host_priv_subsystem { pub unsafe fn Request_host_get_boot_info(&mut self) -> *mut __Request__host_get_boot_info_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Request_host_reboot(&mut self) -> *mut __Request__host_reboot_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Request_host_priv_statistics( &mut self, ) -> *mut __Request__host_priv_statistics_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Request_host_default_memory_manager( &mut self, ) -> *mut __Request__host_default_memory_manager_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Request_vm_wire(&mut self) -> *mut __Request__vm_wire_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Request_thread_wire(&mut self) -> *mut __Request__thread_wire_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Request_vm_allocate_cpm(&mut self) -> *mut __Request__vm_allocate_cpm_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Request_host_processors(&mut self) -> *mut __Request__host_processors_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Request_host_get_clock_control( &mut self, ) -> *mut __Request__host_get_clock_control_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Request_kmod_create(&mut self) -> *mut __Request__kmod_create_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Request_kmod_destroy(&mut self) -> *mut __Request__kmod_destroy_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Request_kmod_control(&mut self) -> *mut __Request__kmod_control_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Request_host_get_special_port( &mut self, ) -> *mut __Request__host_get_special_port_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Request_host_set_special_port( &mut self, ) -> *mut __Request__host_set_special_port_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Request_host_set_exception_ports( &mut self, ) -> *mut __Request__host_set_exception_ports_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Request_host_get_exception_ports( &mut self, ) -> *mut __Request__host_get_exception_ports_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Request_host_swap_exception_ports( &mut self, ) -> *mut __Request__host_swap_exception_ports_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Request_mach_vm_wire(&mut self) -> *mut __Request__mach_vm_wire_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Request_host_processor_sets(&mut self) -> *mut __Request__host_processor_sets_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Request_host_processor_set_priv( &mut self, ) -> *mut __Request__host_processor_set_priv_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Request_set_dp_control_port(&mut self) -> *mut __Request__set_dp_control_port_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Request_get_dp_control_port(&mut self) -> *mut __Request__get_dp_control_port_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Request_host_set_UNDServer(&mut self) -> *mut __Request__host_set_UNDServer_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Request_host_get_UNDServer(&mut self) -> *mut __Request__host_get_UNDServer_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Request_kext_request(&mut self) -> *mut __Request__kext_request_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } } impl ::std::clone::Clone for Union___RequestUnion__host_priv_subsystem { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Union___RequestUnion__host_priv_subsystem { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed67 { pub Head: mach_msg_header_t, pub NDR: NDR_record_t, pub RetCode: kern_return_t, pub boot_infoOffset: mach_msg_type_number_t, pub boot_infoCnt: mach_msg_type_number_t, pub boot_info: [::libc::c_char; 4096usize], } impl ::std::clone::Clone for Struct_Unnamed67 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed67 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __Reply__host_get_boot_info_t = Struct_Unnamed67; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed68 { pub Head: mach_msg_header_t, pub NDR: NDR_record_t, pub RetCode: kern_return_t, } impl ::std::clone::Clone for Struct_Unnamed68 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed68 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __Reply__host_reboot_t = Struct_Unnamed68; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed69 { pub Head: mach_msg_header_t, pub NDR: NDR_record_t, pub RetCode: kern_return_t, pub host_info_outCnt: mach_msg_type_number_t, pub host_info_out: [integer_t; 18usize], } impl ::std::clone::Clone for Struct_Unnamed69 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed69 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __Reply__host_priv_statistics_t = Struct_Unnamed69; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed70 { pub Head: mach_msg_header_t, pub msgh_body: mach_msg_body_t, pub default_manager: mach_msg_port_descriptor_t, } impl ::std::clone::Clone for Struct_Unnamed70 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed70 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __Reply__host_default_memory_manager_t = Struct_Unnamed70; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed71 { pub Head: mach_msg_header_t, pub NDR: NDR_record_t, pub RetCode: kern_return_t, } impl ::std::clone::Clone for Struct_Unnamed71 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed71 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __Reply__vm_wire_t = Struct_Unnamed71; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed72 { pub Head: mach_msg_header_t, pub NDR: NDR_record_t, pub RetCode: kern_return_t, } impl ::std::clone::Clone for Struct_Unnamed72 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed72 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __Reply__thread_wire_t = Struct_Unnamed72; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed73 { pub Head: mach_msg_header_t, pub NDR: NDR_record_t, pub RetCode: kern_return_t, pub address: vm_address_t, } impl ::std::clone::Clone for Struct_Unnamed73 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed73 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __Reply__vm_allocate_cpm_t = Struct_Unnamed73; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed74 { pub Head: mach_msg_header_t, pub msgh_body: mach_msg_body_t, pub out_processor_list: mach_msg_ool_ports_descriptor_t, pub NDR: NDR_record_t, pub out_processor_listCnt: mach_msg_type_number_t, } impl ::std::clone::Clone for Struct_Unnamed74 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed74 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __Reply__host_processors_t = Struct_Unnamed74; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed75 { pub Head: mach_msg_header_t, pub msgh_body: mach_msg_body_t, pub clock_ctrl: mach_msg_port_descriptor_t, } impl ::std::clone::Clone for Struct_Unnamed75 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed75 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __Reply__host_get_clock_control_t = Struct_Unnamed75; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed76 { pub Head: mach_msg_header_t, pub NDR: NDR_record_t, pub RetCode: kern_return_t, pub module: kmod_t, } impl ::std::clone::Clone for Struct_Unnamed76 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed76 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __Reply__kmod_create_t = Struct_Unnamed76; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed77 { pub Head: mach_msg_header_t, pub NDR: NDR_record_t, pub RetCode: kern_return_t, } impl ::std::clone::Clone for Struct_Unnamed77 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed77 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __Reply__kmod_destroy_t = Struct_Unnamed77; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed78 { pub Head: mach_msg_header_t, pub msgh_body: mach_msg_body_t, pub data: mach_msg_ool_descriptor_t, pub NDR: NDR_record_t, pub dataCnt: mach_msg_type_number_t, } impl ::std::clone::Clone for Struct_Unnamed78 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed78 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __Reply__kmod_control_t = Struct_Unnamed78; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed79 { pub Head: mach_msg_header_t, pub msgh_body: mach_msg_body_t, pub port: mach_msg_port_descriptor_t, } impl ::std::clone::Clone for Struct_Unnamed79 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed79 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __Reply__host_get_special_port_t = Struct_Unnamed79; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed80 { pub Head: mach_msg_header_t, pub NDR: NDR_record_t, pub RetCode: kern_return_t, } impl ::std::clone::Clone for Struct_Unnamed80 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed80 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __Reply__host_set_special_port_t = Struct_Unnamed80; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed81 { pub Head: mach_msg_header_t, pub NDR: NDR_record_t, pub RetCode: kern_return_t, } impl ::std::clone::Clone for Struct_Unnamed81 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed81 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __Reply__host_set_exception_ports_t = Struct_Unnamed81; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed82 { pub Head: mach_msg_header_t, pub msgh_body: mach_msg_body_t, pub old_handlers: [mach_msg_port_descriptor_t; 32usize], pub NDR: NDR_record_t, pub masksCnt: mach_msg_type_number_t, pub masks: [exception_mask_t; 32usize], pub old_behaviors: [exception_behavior_t; 32usize], pub old_flavors: [thread_state_flavor_t; 32usize], } impl ::std::clone::Clone for Struct_Unnamed82 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed82 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __Reply__host_get_exception_ports_t = Struct_Unnamed82; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed83 { pub Head: mach_msg_header_t, pub msgh_body: mach_msg_body_t, pub old_handlerss: [mach_msg_port_descriptor_t; 32usize], pub NDR: NDR_record_t, pub masksCnt: mach_msg_type_number_t, pub masks: [exception_mask_t; 32usize], pub old_behaviors: [exception_behavior_t; 32usize], pub old_flavors: [thread_state_flavor_t; 32usize], } impl ::std::clone::Clone for Struct_Unnamed83 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed83 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __Reply__host_swap_exception_ports_t = Struct_Unnamed83; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed84 { pub Head: mach_msg_header_t, pub NDR: NDR_record_t, pub RetCode: kern_return_t, } impl ::std::clone::Clone for Struct_Unnamed84 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed84 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __Reply__mach_vm_wire_t = Struct_Unnamed84; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed85 { pub Head: mach_msg_header_t, pub msgh_body: mach_msg_body_t, pub processor_sets: mach_msg_ool_ports_descriptor_t, pub NDR: NDR_record_t, pub processor_setsCnt: mach_msg_type_number_t, } impl ::std::clone::Clone for Struct_Unnamed85 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed85 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __Reply__host_processor_sets_t = Struct_Unnamed85; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed86 { pub Head: mach_msg_header_t, pub msgh_body: mach_msg_body_t, pub set: mach_msg_port_descriptor_t, } impl ::std::clone::Clone for Struct_Unnamed86 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed86 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __Reply__host_processor_set_priv_t = Struct_Unnamed86; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed87 { pub Head: mach_msg_header_t, pub NDR: NDR_record_t, pub RetCode: kern_return_t, } impl ::std::clone::Clone for Struct_Unnamed87 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed87 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __Reply__set_dp_control_port_t = Struct_Unnamed87; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed88 { pub Head: mach_msg_header_t, pub msgh_body: mach_msg_body_t, pub contorl_port: mach_msg_port_descriptor_t, } impl ::std::clone::Clone for Struct_Unnamed88 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed88 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __Reply__get_dp_control_port_t = Struct_Unnamed88; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed89 { pub Head: mach_msg_header_t, pub NDR: NDR_record_t, pub RetCode: kern_return_t, } impl ::std::clone::Clone for Struct_Unnamed89 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed89 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __Reply__host_set_UNDServer_t = Struct_Unnamed89; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed90 { pub Head: mach_msg_header_t, pub msgh_body: mach_msg_body_t, pub server: mach_msg_port_descriptor_t, } impl ::std::clone::Clone for Struct_Unnamed90 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed90 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __Reply__host_get_UNDServer_t = Struct_Unnamed90; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed91 { pub Head: mach_msg_header_t, pub msgh_body: mach_msg_body_t, pub response_data: mach_msg_ool_descriptor_t, pub log_data: mach_msg_ool_descriptor_t, pub NDR: NDR_record_t, pub response_dataCnt: mach_msg_type_number_t, pub log_dataCnt: mach_msg_type_number_t, pub op_result: kern_return_t, } impl ::std::clone::Clone for Struct_Unnamed91 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed91 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __Reply__kext_request_t = Struct_Unnamed91; #[repr(C)] #[derive(Copy)] pub struct Union___ReplyUnion__host_priv_subsystem { pub _bindgen_data_: [u32; 1035usize], } impl Union___ReplyUnion__host_priv_subsystem { pub unsafe fn Reply_host_get_boot_info(&mut self) -> *mut __Reply__host_get_boot_info_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Reply_host_reboot(&mut self) -> *mut __Reply__host_reboot_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Reply_host_priv_statistics(&mut self) -> *mut __Reply__host_priv_statistics_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Reply_host_default_memory_manager( &mut self, ) -> *mut __Reply__host_default_memory_manager_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Reply_vm_wire(&mut self) -> *mut __Reply__vm_wire_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Reply_thread_wire(&mut self) -> *mut __Reply__thread_wire_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Reply_vm_allocate_cpm(&mut self) -> *mut __Reply__vm_allocate_cpm_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Reply_host_processors(&mut self) -> *mut __Reply__host_processors_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Reply_host_get_clock_control( &mut self, ) -> *mut __Reply__host_get_clock_control_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Reply_kmod_create(&mut self) -> *mut __Reply__kmod_create_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Reply_kmod_destroy(&mut self) -> *mut __Reply__kmod_destroy_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Reply_kmod_control(&mut self) -> *mut __Reply__kmod_control_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Reply_host_get_special_port(&mut self) -> *mut __Reply__host_get_special_port_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Reply_host_set_special_port(&mut self) -> *mut __Reply__host_set_special_port_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Reply_host_set_exception_ports( &mut self, ) -> *mut __Reply__host_set_exception_ports_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Reply_host_get_exception_ports( &mut self, ) -> *mut __Reply__host_get_exception_ports_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Reply_host_swap_exception_ports( &mut self, ) -> *mut __Reply__host_swap_exception_ports_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Reply_mach_vm_wire(&mut self) -> *mut __Reply__mach_vm_wire_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Reply_host_processor_sets(&mut self) -> *mut __Reply__host_processor_sets_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Reply_host_processor_set_priv( &mut self, ) -> *mut __Reply__host_processor_set_priv_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Reply_set_dp_control_port(&mut self) -> *mut __Reply__set_dp_control_port_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Reply_get_dp_control_port(&mut self) -> *mut __Reply__get_dp_control_port_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Reply_host_set_UNDServer(&mut self) -> *mut __Reply__host_set_UNDServer_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Reply_host_get_UNDServer(&mut self) -> *mut __Reply__host_get_UNDServer_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Reply_kext_request(&mut self) -> *mut __Reply__kext_request_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } } impl ::std::clone::Clone for Union___ReplyUnion__host_priv_subsystem { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Union___ReplyUnion__host_priv_subsystem { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed92 { pub Head: mach_msg_header_t, pub msgh_body: mach_msg_body_t, pub parent_task: mach_msg_port_descriptor_t, pub host: mach_msg_port_descriptor_t, pub ledgers: mach_msg_ool_ports_descriptor_t, pub NDR: NDR_record_t, pub sec_token: security_token_t, pub audit_token: audit_token_t, pub ledgersCnt: mach_msg_type_number_t, pub inherit_memory: boolean_t, } impl ::std::clone::Clone for Struct_Unnamed92 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed92 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __Request__host_security_create_task_token_t = Struct_Unnamed92; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed93 { pub Head: mach_msg_header_t, pub msgh_body: mach_msg_body_t, pub target_task: mach_msg_port_descriptor_t, pub host: mach_msg_port_descriptor_t, pub NDR: NDR_record_t, pub sec_token: security_token_t, pub audit_token: audit_token_t, } impl ::std::clone::Clone for Struct_Unnamed93 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed93 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __Request__host_security_set_task_token_t = Struct_Unnamed93; #[repr(C)] #[derive(Copy)] pub struct Union___RequestUnion__host_security_subsystem { pub _bindgen_data_: [u32; 31usize], } impl Union___RequestUnion__host_security_subsystem { pub unsafe fn Request_host_security_create_task_token( &mut self, ) -> *mut __Request__host_security_create_task_token_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Request_host_security_set_task_token( &mut self, ) -> *mut __Request__host_security_set_task_token_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } } impl ::std::clone::Clone for Union___RequestUnion__host_security_subsystem { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Union___RequestUnion__host_security_subsystem { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed94 { pub Head: mach_msg_header_t, pub msgh_body: mach_msg_body_t, pub child_task: mach_msg_port_descriptor_t, } impl ::std::clone::Clone for Struct_Unnamed94 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed94 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __Reply__host_security_create_task_token_t = Struct_Unnamed94; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed95 { pub Head: mach_msg_header_t, pub NDR: NDR_record_t, pub RetCode: kern_return_t, } impl ::std::clone::Clone for Struct_Unnamed95 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed95 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __Reply__host_security_set_task_token_t = Struct_Unnamed95; #[repr(C)] #[derive(Copy)] pub struct Union___ReplyUnion__host_security_subsystem { pub _bindgen_data_: [u32; 10usize], } impl Union___ReplyUnion__host_security_subsystem { pub unsafe fn Reply_host_security_create_task_token( &mut self, ) -> *mut __Reply__host_security_create_task_token_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Reply_host_security_set_task_token( &mut self, ) -> *mut __Reply__host_security_set_task_token_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } } impl ::std::clone::Clone for Union___ReplyUnion__host_security_subsystem { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Union___ReplyUnion__host_security_subsystem { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed96 { pub Head: mach_msg_header_t, pub NDR: NDR_record_t, pub lock_id: ::libc::c_int, } impl ::std::clone::Clone for Struct_Unnamed96 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed96 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __Request__lock_acquire_t = Struct_Unnamed96; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed97 { pub Head: mach_msg_header_t, pub NDR: NDR_record_t, pub lock_id: ::libc::c_int, } impl ::std::clone::Clone for Struct_Unnamed97 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed97 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __Request__lock_release_t = Struct_Unnamed97; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed98 { pub Head: mach_msg_header_t, pub NDR: NDR_record_t, pub lock_id: ::libc::c_int, } impl ::std::clone::Clone for Struct_Unnamed98 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed98 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __Request__lock_try_t = Struct_Unnamed98; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed99 { pub Head: mach_msg_header_t, pub NDR: NDR_record_t, pub lock_id: ::libc::c_int, } impl ::std::clone::Clone for Struct_Unnamed99 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed99 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __Request__lock_make_stable_t = Struct_Unnamed99; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed100 { pub Head: mach_msg_header_t, pub NDR: NDR_record_t, pub lock_id: ::libc::c_int, } impl ::std::clone::Clone for Struct_Unnamed100 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed100 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __Request__lock_handoff_t = Struct_Unnamed100; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed101 { pub Head: mach_msg_header_t, pub NDR: NDR_record_t, pub lock_id: ::libc::c_int, } impl ::std::clone::Clone for Struct_Unnamed101 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed101 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __Request__lock_handoff_accept_t = Struct_Unnamed101; #[repr(C)] #[derive(Copy)] pub struct Union___RequestUnion__lock_set_subsystem { pub _bindgen_data_: [u32; 9usize], } impl Union___RequestUnion__lock_set_subsystem { pub unsafe fn Request_lock_acquire(&mut self) -> *mut __Request__lock_acquire_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Request_lock_release(&mut self) -> *mut __Request__lock_release_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Request_lock_try(&mut self) -> *mut __Request__lock_try_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Request_lock_make_stable(&mut self) -> *mut __Request__lock_make_stable_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Request_lock_handoff(&mut self) -> *mut __Request__lock_handoff_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Request_lock_handoff_accept(&mut self) -> *mut __Request__lock_handoff_accept_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } } impl ::std::clone::Clone for Union___RequestUnion__lock_set_subsystem { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Union___RequestUnion__lock_set_subsystem { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed102 { pub Head: mach_msg_header_t, pub NDR: NDR_record_t, pub RetCode: kern_return_t, } impl ::std::clone::Clone for Struct_Unnamed102 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed102 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __Reply__lock_acquire_t = Struct_Unnamed102; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed103 { pub Head: mach_msg_header_t, pub NDR: NDR_record_t, pub RetCode: kern_return_t, } impl ::std::clone::Clone for Struct_Unnamed103 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed103 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __Reply__lock_release_t = Struct_Unnamed103; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed104 { pub Head: mach_msg_header_t, pub NDR: NDR_record_t, pub RetCode: kern_return_t, } impl ::std::clone::Clone for Struct_Unnamed104 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed104 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __Reply__lock_try_t = Struct_Unnamed104; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed105 { pub Head: mach_msg_header_t, pub NDR: NDR_record_t, pub RetCode: kern_return_t, } impl ::std::clone::Clone for Struct_Unnamed105 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed105 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __Reply__lock_make_stable_t = Struct_Unnamed105; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed106 { pub Head: mach_msg_header_t, pub NDR: NDR_record_t, pub RetCode: kern_return_t, } impl ::std::clone::Clone for Struct_Unnamed106 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed106 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __Reply__lock_handoff_t = Struct_Unnamed106; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed107 { pub Head: mach_msg_header_t, pub NDR: NDR_record_t, pub RetCode: kern_return_t, } impl ::std::clone::Clone for Struct_Unnamed107 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed107 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __Reply__lock_handoff_accept_t = Struct_Unnamed107; #[repr(C)] #[derive(Copy)] pub struct Union___ReplyUnion__lock_set_subsystem { pub _bindgen_data_: [u32; 9usize], } impl Union___ReplyUnion__lock_set_subsystem { pub unsafe fn Reply_lock_acquire(&mut self) -> *mut __Reply__lock_acquire_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Reply_lock_release(&mut self) -> *mut __Reply__lock_release_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Reply_lock_try(&mut self) -> *mut __Reply__lock_try_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Reply_lock_make_stable(&mut self) -> *mut __Reply__lock_make_stable_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Reply_lock_handoff(&mut self) -> *mut __Reply__lock_handoff_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Reply_lock_handoff_accept(&mut self) -> *mut __Reply__lock_handoff_accept_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } } impl ::std::clone::Clone for Union___ReplyUnion__lock_set_subsystem { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Union___ReplyUnion__lock_set_subsystem { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed108 { pub Head: mach_msg_header_t, } impl ::std::clone::Clone for Struct_Unnamed108 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed108 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __Request__processor_start_t = Struct_Unnamed108; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed109 { pub Head: mach_msg_header_t, } impl ::std::clone::Clone for Struct_Unnamed109 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed109 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __Request__processor_exit_t = Struct_Unnamed109; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed110 { pub Head: mach_msg_header_t, pub NDR: NDR_record_t, pub flavor: processor_flavor_t, pub processor_info_outCnt: mach_msg_type_number_t, } impl ::std::clone::Clone for Struct_Unnamed110 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed110 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __Request__processor_info_t = Struct_Unnamed110; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed111 { pub Head: mach_msg_header_t, pub NDR: NDR_record_t, pub processor_cmdCnt: mach_msg_type_number_t, pub processor_cmd: [integer_t; 12usize], } impl ::std::clone::Clone for Struct_Unnamed111 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed111 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __Request__processor_control_t = Struct_Unnamed111; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed112 { pub Head: mach_msg_header_t, pub msgh_body: mach_msg_body_t, pub new_set: mach_msg_port_descriptor_t, pub NDR: NDR_record_t, pub wait: boolean_t, } impl ::std::clone::Clone for Struct_Unnamed112 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed112 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __Request__processor_assign_t = Struct_Unnamed112; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed113 { pub Head: mach_msg_header_t, } impl ::std::clone::Clone for Struct_Unnamed113 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed113 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __Request__processor_get_assignment_t = Struct_Unnamed113; #[repr(C)] #[derive(Copy)] pub struct Union___RequestUnion__processor_subsystem { pub _bindgen_data_: [u32; 21usize], } impl Union___RequestUnion__processor_subsystem { pub unsafe fn Request_processor_start(&mut self) -> *mut __Request__processor_start_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Request_processor_exit(&mut self) -> *mut __Request__processor_exit_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Request_processor_info(&mut self) -> *mut __Request__processor_info_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Request_processor_control(&mut self) -> *mut __Request__processor_control_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Request_processor_assign(&mut self) -> *mut __Request__processor_assign_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Request_processor_get_assignment( &mut self, ) -> *mut __Request__processor_get_assignment_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } } impl ::std::clone::Clone for Union___RequestUnion__processor_subsystem { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Union___RequestUnion__processor_subsystem { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed114 { pub Head: mach_msg_header_t, pub NDR: NDR_record_t, pub RetCode: kern_return_t, } impl ::std::clone::Clone for Struct_Unnamed114 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed114 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __Reply__processor_start_t = Struct_Unnamed114; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed115 { pub Head: mach_msg_header_t, pub NDR: NDR_record_t, pub RetCode: kern_return_t, } impl ::std::clone::Clone for Struct_Unnamed115 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed115 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __Reply__processor_exit_t = Struct_Unnamed115; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed116 { pub Head: mach_msg_header_t, pub msgh_body: mach_msg_body_t, pub host: mach_msg_port_descriptor_t, pub NDR: NDR_record_t, pub processor_info_outCnt: mach_msg_type_number_t, pub processor_info_out: [integer_t; 12usize], } impl ::std::clone::Clone for Struct_Unnamed116 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed116 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __Reply__processor_info_t = Struct_Unnamed116; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed117 { pub Head: mach_msg_header_t, pub NDR: NDR_record_t, pub RetCode: kern_return_t, } impl ::std::clone::Clone for Struct_Unnamed117 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed117 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __Reply__processor_control_t = Struct_Unnamed117; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed118 { pub Head: mach_msg_header_t, pub NDR: NDR_record_t, pub RetCode: kern_return_t, } impl ::std::clone::Clone for Struct_Unnamed118 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed118 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __Reply__processor_assign_t = Struct_Unnamed118; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed119 { pub Head: mach_msg_header_t, pub msgh_body: mach_msg_body_t, pub assigned_set: mach_msg_port_descriptor_t, } impl ::std::clone::Clone for Struct_Unnamed119 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed119 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __Reply__processor_get_assignment_t = Struct_Unnamed119; #[repr(C)] #[derive(Copy)] pub struct Union___ReplyUnion__processor_subsystem { pub _bindgen_data_: [u32; 25usize], } impl Union___ReplyUnion__processor_subsystem { pub unsafe fn Reply_processor_start(&mut self) -> *mut __Reply__processor_start_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Reply_processor_exit(&mut self) -> *mut __Reply__processor_exit_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Reply_processor_info(&mut self) -> *mut __Reply__processor_info_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Reply_processor_control(&mut self) -> *mut __Reply__processor_control_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Reply_processor_assign(&mut self) -> *mut __Reply__processor_assign_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Reply_processor_get_assignment( &mut self, ) -> *mut __Reply__processor_get_assignment_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } } impl ::std::clone::Clone for Union___ReplyUnion__processor_subsystem { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Union___ReplyUnion__processor_subsystem { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed120 { pub Head: mach_msg_header_t, pub NDR: NDR_record_t, pub flavor: processor_set_flavor_t, pub info_outCnt: mach_msg_type_number_t, } impl ::std::clone::Clone for Struct_Unnamed120 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed120 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __Request__processor_set_statistics_t = Struct_Unnamed120; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed121 { pub Head: mach_msg_header_t, } impl ::std::clone::Clone for Struct_Unnamed121 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed121 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __Request__processor_set_destroy_t = Struct_Unnamed121; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed122 { pub Head: mach_msg_header_t, pub NDR: NDR_record_t, pub max_priority: ::libc::c_int, pub change_threads: boolean_t, } impl ::std::clone::Clone for Struct_Unnamed122 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed122 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __Request__processor_set_max_priority_t = Struct_Unnamed122; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed123 { pub Head: mach_msg_header_t, pub NDR: NDR_record_t, pub policy: ::libc::c_int, } impl ::std::clone::Clone for Struct_Unnamed123 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed123 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __Request__processor_set_policy_enable_t = Struct_Unnamed123; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed124 { pub Head: mach_msg_header_t, pub NDR: NDR_record_t, pub policy: ::libc::c_int, pub change_threads: boolean_t, } impl ::std::clone::Clone for Struct_Unnamed124 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed124 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __Request__processor_set_policy_disable_t = Struct_Unnamed124; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed125 { pub Head: mach_msg_header_t, } impl ::std::clone::Clone for Struct_Unnamed125 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed125 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __Request__processor_set_tasks_t = Struct_Unnamed125; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed126 { pub Head: mach_msg_header_t, } impl ::std::clone::Clone for Struct_Unnamed126 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed126 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __Request__processor_set_threads_t = Struct_Unnamed126; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed127 { pub Head: mach_msg_header_t, pub NDR: NDR_record_t, pub flavor: processor_set_flavor_t, pub policy_infoCnt: mach_msg_type_number_t, pub policy_info: [integer_t; 5usize], pub change: boolean_t, } impl ::std::clone::Clone for Struct_Unnamed127 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed127 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __Request__processor_set_policy_control_t = Struct_Unnamed127; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed128 { pub Head: mach_msg_header_t, } impl ::std::clone::Clone for Struct_Unnamed128 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed128 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __Request__processor_set_stack_usage_t = Struct_Unnamed128; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed129 { pub Head: mach_msg_header_t, pub NDR: NDR_record_t, pub flavor: ::libc::c_int, pub info_outCnt: mach_msg_type_number_t, } impl ::std::clone::Clone for Struct_Unnamed129 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed129 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __Request__processor_set_info_t = Struct_Unnamed129; #[repr(C)] #[derive(Copy)] pub struct Union___RequestUnion__processor_set_subsystem { pub _bindgen_data_: [u32; 16usize], } impl Union___RequestUnion__processor_set_subsystem { pub unsafe fn Request_processor_set_statistics( &mut self, ) -> *mut __Request__processor_set_statistics_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Request_processor_set_destroy( &mut self, ) -> *mut __Request__processor_set_destroy_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Request_processor_set_max_priority( &mut self, ) -> *mut __Request__processor_set_max_priority_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Request_processor_set_policy_enable( &mut self, ) -> *mut __Request__processor_set_policy_enable_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Request_processor_set_policy_disable( &mut self, ) -> *mut __Request__processor_set_policy_disable_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Request_processor_set_tasks(&mut self) -> *mut __Request__processor_set_tasks_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Request_processor_set_threads( &mut self, ) -> *mut __Request__processor_set_threads_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Request_processor_set_policy_control( &mut self, ) -> *mut __Request__processor_set_policy_control_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Request_processor_set_stack_usage( &mut self, ) -> *mut __Request__processor_set_stack_usage_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Request_processor_set_info(&mut self) -> *mut __Request__processor_set_info_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } } impl ::std::clone::Clone for Union___RequestUnion__processor_set_subsystem { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Union___RequestUnion__processor_set_subsystem { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed130 { pub Head: mach_msg_header_t, pub NDR: NDR_record_t, pub RetCode: kern_return_t, pub info_outCnt: mach_msg_type_number_t, pub info_out: [integer_t; 5usize], } impl ::std::clone::Clone for Struct_Unnamed130 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed130 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __Reply__processor_set_statistics_t = Struct_Unnamed130; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed131 { pub Head: mach_msg_header_t, pub NDR: NDR_record_t, pub RetCode: kern_return_t, } impl ::std::clone::Clone for Struct_Unnamed131 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed131 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __Reply__processor_set_destroy_t = Struct_Unnamed131; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed132 { pub Head: mach_msg_header_t, pub NDR: NDR_record_t, pub RetCode: kern_return_t, } impl ::std::clone::Clone for Struct_Unnamed132 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed132 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __Reply__processor_set_max_priority_t = Struct_Unnamed132; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed133 { pub Head: mach_msg_header_t, pub NDR: NDR_record_t, pub RetCode: kern_return_t, } impl ::std::clone::Clone for Struct_Unnamed133 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed133 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __Reply__processor_set_policy_enable_t = Struct_Unnamed133; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed134 { pub Head: mach_msg_header_t, pub NDR: NDR_record_t, pub RetCode: kern_return_t, } impl ::std::clone::Clone for Struct_Unnamed134 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed134 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __Reply__processor_set_policy_disable_t = Struct_Unnamed134; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed135 { pub Head: mach_msg_header_t, pub msgh_body: mach_msg_body_t, pub task_list: mach_msg_ool_ports_descriptor_t, pub NDR: NDR_record_t, pub task_listCnt: mach_msg_type_number_t, } impl ::std::clone::Clone for Struct_Unnamed135 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed135 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __Reply__processor_set_tasks_t = Struct_Unnamed135; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed136 { pub Head: mach_msg_header_t, pub msgh_body: mach_msg_body_t, pub thread_list: mach_msg_ool_ports_descriptor_t, pub NDR: NDR_record_t, pub thread_listCnt: mach_msg_type_number_t, } impl ::std::clone::Clone for Struct_Unnamed136 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed136 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __Reply__processor_set_threads_t = Struct_Unnamed136; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed137 { pub Head: mach_msg_header_t, pub NDR: NDR_record_t, pub RetCode: kern_return_t, } impl ::std::clone::Clone for Struct_Unnamed137 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed137 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __Reply__processor_set_policy_control_t = Struct_Unnamed137; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed138 { pub Head: mach_msg_header_t, pub NDR: NDR_record_t, pub RetCode: kern_return_t, pub ltotal: ::libc::c_uint, pub space: vm_size_t, pub resident: vm_size_t, pub maxusage: vm_size_t, pub maxstack: vm_offset_t, } impl ::std::clone::Clone for Struct_Unnamed138 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed138 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __Reply__processor_set_stack_usage_t = Struct_Unnamed138; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed139 { pub Head: mach_msg_header_t, pub msgh_body: mach_msg_body_t, pub host: mach_msg_port_descriptor_t, pub NDR: NDR_record_t, pub info_outCnt: mach_msg_type_number_t, pub info_out: [integer_t; 5usize], } impl ::std::clone::Clone for Struct_Unnamed139 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed139 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __Reply__processor_set_info_t = Struct_Unnamed139; #[repr(C)] #[derive(Copy)] pub struct Union___ReplyUnion__processor_set_subsystem { pub _bindgen_data_: [u32; 18usize], } impl Union___ReplyUnion__processor_set_subsystem { pub unsafe fn Reply_processor_set_statistics( &mut self, ) -> *mut __Reply__processor_set_statistics_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Reply_processor_set_destroy(&mut self) -> *mut __Reply__processor_set_destroy_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Reply_processor_set_max_priority( &mut self, ) -> *mut __Reply__processor_set_max_priority_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Reply_processor_set_policy_enable( &mut self, ) -> *mut __Reply__processor_set_policy_enable_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Reply_processor_set_policy_disable( &mut self, ) -> *mut __Reply__processor_set_policy_disable_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Reply_processor_set_tasks(&mut self) -> *mut __Reply__processor_set_tasks_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Reply_processor_set_threads(&mut self) -> *mut __Reply__processor_set_threads_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Reply_processor_set_policy_control( &mut self, ) -> *mut __Reply__processor_set_policy_control_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Reply_processor_set_stack_usage( &mut self, ) -> *mut __Reply__processor_set_stack_usage_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Reply_processor_set_info(&mut self) -> *mut __Reply__processor_set_info_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } } impl ::std::clone::Clone for Union___ReplyUnion__processor_set_subsystem { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Union___ReplyUnion__processor_set_subsystem { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type sync_policy_t = ::libc::c_int; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed140 { pub Head: mach_msg_header_t, pub msgh_body: mach_msg_body_t, pub ledgers: mach_msg_ool_ports_descriptor_t, pub NDR: NDR_record_t, pub ledgersCnt: mach_msg_type_number_t, pub inherit_memory: boolean_t, } impl ::std::clone::Clone for Struct_Unnamed140 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed140 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __Request__task_create_t = Struct_Unnamed140; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed141 { pub Head: mach_msg_header_t, } impl ::std::clone::Clone for Struct_Unnamed141 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed141 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __Request__task_terminate_t = Struct_Unnamed141; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed142 { pub Head: mach_msg_header_t, } impl ::std::clone::Clone for Struct_Unnamed142 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed142 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __Request__task_threads_t = Struct_Unnamed142; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed143 { pub Head: mach_msg_header_t, pub msgh_body: mach_msg_body_t, pub init_port_set: mach_msg_ool_ports_descriptor_t, pub NDR: NDR_record_t, pub init_port_setCnt: mach_msg_type_number_t, } impl ::std::clone::Clone for Struct_Unnamed143 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed143 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __Request__mach_ports_register_t = Struct_Unnamed143; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed144 { pub Head: mach_msg_header_t, } impl ::std::clone::Clone for Struct_Unnamed144 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed144 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __Request__mach_ports_lookup_t = Struct_Unnamed144; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed145 { pub Head: mach_msg_header_t, pub NDR: NDR_record_t, pub flavor: task_flavor_t, pub task_info_outCnt: mach_msg_type_number_t, } impl ::std::clone::Clone for Struct_Unnamed145 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed145 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __Request__task_info_t = Struct_Unnamed145; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed146 { pub Head: mach_msg_header_t, pub NDR: NDR_record_t, pub flavor: task_flavor_t, pub task_info_inCnt: mach_msg_type_number_t, pub task_info_in: [integer_t; 32usize], } impl ::std::clone::Clone for Struct_Unnamed146 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed146 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __Request__task_set_info_t = Struct_Unnamed146; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed147 { pub Head: mach_msg_header_t, } impl ::std::clone::Clone for Struct_Unnamed147 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed147 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __Request__task_suspend_t = Struct_Unnamed147; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed148 { pub Head: mach_msg_header_t, } impl ::std::clone::Clone for Struct_Unnamed148 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed148 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __Request__task_resume_t = Struct_Unnamed148; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed149 { pub Head: mach_msg_header_t, pub NDR: NDR_record_t, pub which_port: ::libc::c_int, } impl ::std::clone::Clone for Struct_Unnamed149 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed149 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __Request__task_get_special_port_t = Struct_Unnamed149; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed150 { pub Head: mach_msg_header_t, pub msgh_body: mach_msg_body_t, pub special_port: mach_msg_port_descriptor_t, pub NDR: NDR_record_t, pub which_port: ::libc::c_int, } impl ::std::clone::Clone for Struct_Unnamed150 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed150 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __Request__task_set_special_port_t = Struct_Unnamed150; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed151 { pub Head: mach_msg_header_t, } impl ::std::clone::Clone for Struct_Unnamed151 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed151 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __Request__thread_create_t = Struct_Unnamed151; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed152 { pub Head: mach_msg_header_t, pub NDR: NDR_record_t, pub flavor: thread_state_flavor_t, pub new_stateCnt: mach_msg_type_number_t, pub new_state: [natural_t; 224usize], } impl ::std::clone::Clone for Struct_Unnamed152 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed152 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __Request__thread_create_running_t = Struct_Unnamed152; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed153 { pub Head: mach_msg_header_t, pub msgh_body: mach_msg_body_t, pub new_port: mach_msg_port_descriptor_t, pub NDR: NDR_record_t, pub exception_mask: exception_mask_t, pub behavior: exception_behavior_t, pub new_flavor: thread_state_flavor_t, } impl ::std::clone::Clone for Struct_Unnamed153 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed153 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __Request__task_set_exception_ports_t = Struct_Unnamed153; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed154 { pub Head: mach_msg_header_t, pub NDR: NDR_record_t, pub exception_mask: exception_mask_t, } impl ::std::clone::Clone for Struct_Unnamed154 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed154 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __Request__task_get_exception_ports_t = Struct_Unnamed154; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed155 { pub Head: mach_msg_header_t, pub msgh_body: mach_msg_body_t, pub new_port: mach_msg_port_descriptor_t, pub NDR: NDR_record_t, pub exception_mask: exception_mask_t, pub behavior: exception_behavior_t, pub new_flavor: thread_state_flavor_t, } impl ::std::clone::Clone for Struct_Unnamed155 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed155 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __Request__task_swap_exception_ports_t = Struct_Unnamed155; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed156 { pub Head: mach_msg_header_t, pub NDR: NDR_record_t, pub n_ulocks: ::libc::c_int, pub policy: ::libc::c_int, } impl ::std::clone::Clone for Struct_Unnamed156 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed156 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __Request__lock_set_create_t = Struct_Unnamed156; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed157 { pub Head: mach_msg_header_t, pub msgh_body: mach_msg_body_t, pub lock_set: mach_msg_port_descriptor_t, } impl ::std::clone::Clone for Struct_Unnamed157 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed157 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __Request__lock_set_destroy_t = Struct_Unnamed157; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed158 { pub Head: mach_msg_header_t, pub NDR: NDR_record_t, pub policy: ::libc::c_int, pub value: ::libc::c_int, } impl ::std::clone::Clone for Struct_Unnamed158 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed158 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __Request__semaphore_create_t = Struct_Unnamed158; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed159 { pub Head: mach_msg_header_t, pub msgh_body: mach_msg_body_t, pub semaphore: mach_msg_port_descriptor_t, } impl ::std::clone::Clone for Struct_Unnamed159 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed159 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __Request__semaphore_destroy_t = Struct_Unnamed159; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed160 { pub Head: mach_msg_header_t, pub NDR: NDR_record_t, pub flavor: task_policy_flavor_t, pub policy_infoCnt: mach_msg_type_number_t, pub policy_info: [integer_t; 16usize], } impl ::std::clone::Clone for Struct_Unnamed160 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed160 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __Request__task_policy_set_t = Struct_Unnamed160; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed161 { pub Head: mach_msg_header_t, pub NDR: NDR_record_t, pub flavor: task_policy_flavor_t, pub policy_infoCnt: mach_msg_type_number_t, pub get_default: boolean_t, } impl ::std::clone::Clone for Struct_Unnamed161 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed161 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __Request__task_policy_get_t = Struct_Unnamed161; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed162 { pub Head: mach_msg_header_t, pub msgh_body: mach_msg_body_t, pub reply: mach_msg_port_descriptor_t, } impl ::std::clone::Clone for Struct_Unnamed162 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed162 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __Request__task_sample_t = Struct_Unnamed162; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed163 { pub Head: mach_msg_header_t, pub NDR: NDR_record_t, pub policy: policy_t, pub baseCnt: mach_msg_type_number_t, pub base: [integer_t; 5usize], pub set_limit: boolean_t, pub change: boolean_t, } impl ::std::clone::Clone for Struct_Unnamed163 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed163 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __Request__task_policy_t = Struct_Unnamed163; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed164 { pub Head: mach_msg_header_t, pub NDR: NDR_record_t, pub routine_entry_pt: vm_address_t, pub routine_number: ::libc::c_int, } impl ::std::clone::Clone for Struct_Unnamed164 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed164 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __Request__task_set_emulation_t = Struct_Unnamed164; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed165 { pub Head: mach_msg_header_t, } impl ::std::clone::Clone for Struct_Unnamed165 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed165 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __Request__task_get_emulation_vector_t = Struct_Unnamed165; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed166 { pub Head: mach_msg_header_t, pub msgh_body: mach_msg_body_t, pub emulation_vector: mach_msg_ool_descriptor_t, pub NDR: NDR_record_t, pub vector_start: ::libc::c_int, pub emulation_vectorCnt: mach_msg_type_number_t, } impl ::std::clone::Clone for Struct_Unnamed166 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed166 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __Request__task_set_emulation_vector_t = Struct_Unnamed166; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed167 { pub Head: mach_msg_header_t, pub NDR: NDR_record_t, pub basepc: vm_address_t, pub boundspc: vm_address_t, } impl ::std::clone::Clone for Struct_Unnamed167 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed167 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __Request__task_set_ras_pc_t = Struct_Unnamed167; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed168 { pub Head: mach_msg_header_t, } impl ::std::clone::Clone for Struct_Unnamed168 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed168 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __Request__task_zone_info_t = Struct_Unnamed168; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed169 { pub Head: mach_msg_header_t, pub msgh_body: mach_msg_body_t, pub new_set: mach_msg_port_descriptor_t, pub NDR: NDR_record_t, pub assign_threads: boolean_t, } impl ::std::clone::Clone for Struct_Unnamed169 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed169 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __Request__task_assign_t = Struct_Unnamed169; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed170 { pub Head: mach_msg_header_t, pub NDR: NDR_record_t, pub assign_threads: boolean_t, } impl ::std::clone::Clone for Struct_Unnamed170 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed170 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __Request__task_assign_default_t = Struct_Unnamed170; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed171 { pub Head: mach_msg_header_t, } impl ::std::clone::Clone for Struct_Unnamed171 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed171 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __Request__task_get_assignment_t = Struct_Unnamed171; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed172 { pub Head: mach_msg_header_t, pub msgh_body: mach_msg_body_t, pub pset: mach_msg_port_descriptor_t, pub NDR: NDR_record_t, pub policy: policy_t, pub baseCnt: mach_msg_type_number_t, pub base: [integer_t; 5usize], pub limitCnt: mach_msg_type_number_t, pub limit: [integer_t; 1usize], pub change: boolean_t, } impl ::std::clone::Clone for Struct_Unnamed172 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed172 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __Request__task_set_policy_t = Struct_Unnamed172; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed173 { pub Head: mach_msg_header_t, pub NDR: NDR_record_t, pub flavor: thread_state_flavor_t, pub old_stateCnt: mach_msg_type_number_t, } impl ::std::clone::Clone for Struct_Unnamed173 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed173 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __Request__task_get_state_t = Struct_Unnamed173; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed174 { pub Head: mach_msg_header_t, pub NDR: NDR_record_t, pub flavor: thread_state_flavor_t, pub new_stateCnt: mach_msg_type_number_t, pub new_state: [natural_t; 224usize], } impl ::std::clone::Clone for Struct_Unnamed174 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed174 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __Request__task_set_state_t = Struct_Unnamed174; #[repr(C)] #[derive(Copy)] pub struct Union___RequestUnion__task_subsystem { pub _bindgen_data_: [u32; 234usize], } impl Union___RequestUnion__task_subsystem { pub unsafe fn Request_task_create(&mut self) -> *mut __Request__task_create_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Request_task_terminate(&mut self) -> *mut __Request__task_terminate_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Request_task_threads(&mut self) -> *mut __Request__task_threads_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Request_mach_ports_register(&mut self) -> *mut __Request__mach_ports_register_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Request_mach_ports_lookup(&mut self) -> *mut __Request__mach_ports_lookup_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Request_task_info(&mut self) -> *mut __Request__task_info_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Request_task_set_info(&mut self) -> *mut __Request__task_set_info_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Request_task_suspend(&mut self) -> *mut __Request__task_suspend_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Request_task_resume(&mut self) -> *mut __Request__task_resume_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Request_task_get_special_port( &mut self, ) -> *mut __Request__task_get_special_port_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Request_task_set_special_port( &mut self, ) -> *mut __Request__task_set_special_port_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Request_thread_create(&mut self) -> *mut __Request__thread_create_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Request_thread_create_running( &mut self, ) -> *mut __Request__thread_create_running_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Request_task_set_exception_ports( &mut self, ) -> *mut __Request__task_set_exception_ports_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Request_task_get_exception_ports( &mut self, ) -> *mut __Request__task_get_exception_ports_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Request_task_swap_exception_ports( &mut self, ) -> *mut __Request__task_swap_exception_ports_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Request_lock_set_create(&mut self) -> *mut __Request__lock_set_create_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Request_lock_set_destroy(&mut self) -> *mut __Request__lock_set_destroy_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Request_semaphore_create(&mut self) -> *mut __Request__semaphore_create_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Request_semaphore_destroy(&mut self) -> *mut __Request__semaphore_destroy_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Request_task_policy_set(&mut self) -> *mut __Request__task_policy_set_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Request_task_policy_get(&mut self) -> *mut __Request__task_policy_get_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Request_task_sample(&mut self) -> *mut __Request__task_sample_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Request_task_policy(&mut self) -> *mut __Request__task_policy_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Request_task_set_emulation(&mut self) -> *mut __Request__task_set_emulation_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Request_task_get_emulation_vector( &mut self, ) -> *mut __Request__task_get_emulation_vector_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Request_task_set_emulation_vector( &mut self, ) -> *mut __Request__task_set_emulation_vector_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Request_task_set_ras_pc(&mut self) -> *mut __Request__task_set_ras_pc_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Request_task_zone_info(&mut self) -> *mut __Request__task_zone_info_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Request_task_assign(&mut self) -> *mut __Request__task_assign_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Request_task_assign_default(&mut self) -> *mut __Request__task_assign_default_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Request_task_get_assignment(&mut self) -> *mut __Request__task_get_assignment_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Request_task_set_policy(&mut self) -> *mut __Request__task_set_policy_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Request_task_get_state(&mut self) -> *mut __Request__task_get_state_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Request_task_set_state(&mut self) -> *mut __Request__task_set_state_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } } impl ::std::clone::Clone for Union___RequestUnion__task_subsystem { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Union___RequestUnion__task_subsystem { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed175 { pub Head: mach_msg_header_t, pub msgh_body: mach_msg_body_t, pub child_task: mach_msg_port_descriptor_t, } impl ::std::clone::Clone for Struct_Unnamed175 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed175 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __Reply__task_create_t = Struct_Unnamed175; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed176 { pub Head: mach_msg_header_t, pub NDR: NDR_record_t, pub RetCode: kern_return_t, } impl ::std::clone::Clone for Struct_Unnamed176 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed176 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __Reply__task_terminate_t = Struct_Unnamed176; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed177 { pub Head: mach_msg_header_t, pub msgh_body: mach_msg_body_t, pub act_list: mach_msg_ool_ports_descriptor_t, pub NDR: NDR_record_t, pub act_listCnt: mach_msg_type_number_t, } impl ::std::clone::Clone for Struct_Unnamed177 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed177 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __Reply__task_threads_t = Struct_Unnamed177; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed178 { pub Head: mach_msg_header_t, pub NDR: NDR_record_t, pub RetCode: kern_return_t, } impl ::std::clone::Clone for Struct_Unnamed178 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed178 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __Reply__mach_ports_register_t = Struct_Unnamed178; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed179 { pub Head: mach_msg_header_t, pub msgh_body: mach_msg_body_t, pub init_port_set: mach_msg_ool_ports_descriptor_t, pub NDR: NDR_record_t, pub init_port_setCnt: mach_msg_type_number_t, } impl ::std::clone::Clone for Struct_Unnamed179 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed179 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __Reply__mach_ports_lookup_t = Struct_Unnamed179; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed180 { pub Head: mach_msg_header_t, pub NDR: NDR_record_t, pub RetCode: kern_return_t, pub task_info_outCnt: mach_msg_type_number_t, pub task_info_out: [integer_t; 32usize], } impl ::std::clone::Clone for Struct_Unnamed180 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed180 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __Reply__task_info_t = Struct_Unnamed180; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed181 { pub Head: mach_msg_header_t, pub NDR: NDR_record_t, pub RetCode: kern_return_t, } impl ::std::clone::Clone for Struct_Unnamed181 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed181 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __Reply__task_set_info_t = Struct_Unnamed181; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed182 { pub Head: mach_msg_header_t, pub NDR: NDR_record_t, pub RetCode: kern_return_t, } impl ::std::clone::Clone for Struct_Unnamed182 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed182 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __Reply__task_suspend_t = Struct_Unnamed182; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed183 { pub Head: mach_msg_header_t, pub NDR: NDR_record_t, pub RetCode: kern_return_t, } impl ::std::clone::Clone for Struct_Unnamed183 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed183 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __Reply__task_resume_t = Struct_Unnamed183; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed184 { pub Head: mach_msg_header_t, pub msgh_body: mach_msg_body_t, pub special_port: mach_msg_port_descriptor_t, } impl ::std::clone::Clone for Struct_Unnamed184 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed184 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __Reply__task_get_special_port_t = Struct_Unnamed184; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed185 { pub Head: mach_msg_header_t, pub NDR: NDR_record_t, pub RetCode: kern_return_t, } impl ::std::clone::Clone for Struct_Unnamed185 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed185 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __Reply__task_set_special_port_t = Struct_Unnamed185; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed186 { pub Head: mach_msg_header_t, pub msgh_body: mach_msg_body_t, pub child_act: mach_msg_port_descriptor_t, } impl ::std::clone::Clone for Struct_Unnamed186 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed186 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __Reply__thread_create_t = Struct_Unnamed186; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed187 { pub Head: mach_msg_header_t, pub msgh_body: mach_msg_body_t, pub child_act: mach_msg_port_descriptor_t, } impl ::std::clone::Clone for Struct_Unnamed187 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed187 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __Reply__thread_create_running_t = Struct_Unnamed187; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed188 { pub Head: mach_msg_header_t, pub NDR: NDR_record_t, pub RetCode: kern_return_t, } impl ::std::clone::Clone for Struct_Unnamed188 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed188 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __Reply__task_set_exception_ports_t = Struct_Unnamed188; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed189 { pub Head: mach_msg_header_t, pub msgh_body: mach_msg_body_t, pub old_handlers: [mach_msg_port_descriptor_t; 32usize], pub NDR: NDR_record_t, pub masksCnt: mach_msg_type_number_t, pub masks: [exception_mask_t; 32usize], pub old_behaviors: [exception_behavior_t; 32usize], pub old_flavors: [thread_state_flavor_t; 32usize], } impl ::std::clone::Clone for Struct_Unnamed189 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed189 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __Reply__task_get_exception_ports_t = Struct_Unnamed189; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed190 { pub Head: mach_msg_header_t, pub msgh_body: mach_msg_body_t, pub old_handlerss: [mach_msg_port_descriptor_t; 32usize], pub NDR: NDR_record_t, pub masksCnt: mach_msg_type_number_t, pub masks: [exception_mask_t; 32usize], pub old_behaviors: [exception_behavior_t; 32usize], pub old_flavors: [thread_state_flavor_t; 32usize], } impl ::std::clone::Clone for Struct_Unnamed190 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed190 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __Reply__task_swap_exception_ports_t = Struct_Unnamed190; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed191 { pub Head: mach_msg_header_t, pub msgh_body: mach_msg_body_t, pub new_lock_set: mach_msg_port_descriptor_t, } impl ::std::clone::Clone for Struct_Unnamed191 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed191 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __Reply__lock_set_create_t = Struct_Unnamed191; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed192 { pub Head: mach_msg_header_t, pub NDR: NDR_record_t, pub RetCode: kern_return_t, } impl ::std::clone::Clone for Struct_Unnamed192 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed192 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __Reply__lock_set_destroy_t = Struct_Unnamed192; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed193 { pub Head: mach_msg_header_t, pub msgh_body: mach_msg_body_t, pub semaphore: mach_msg_port_descriptor_t, } impl ::std::clone::Clone for Struct_Unnamed193 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed193 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __Reply__semaphore_create_t = Struct_Unnamed193; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed194 { pub Head: mach_msg_header_t, pub NDR: NDR_record_t, pub RetCode: kern_return_t, } impl ::std::clone::Clone for Struct_Unnamed194 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed194 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __Reply__semaphore_destroy_t = Struct_Unnamed194; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed195 { pub Head: mach_msg_header_t, pub NDR: NDR_record_t, pub RetCode: kern_return_t, } impl ::std::clone::Clone for Struct_Unnamed195 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed195 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __Reply__task_policy_set_t = Struct_Unnamed195; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed196 { pub Head: mach_msg_header_t, pub NDR: NDR_record_t, pub RetCode: kern_return_t, pub policy_infoCnt: mach_msg_type_number_t, pub policy_info: [integer_t; 16usize], pub get_default: boolean_t, } impl ::std::clone::Clone for Struct_Unnamed196 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed196 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __Reply__task_policy_get_t = Struct_Unnamed196; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed197 { pub Head: mach_msg_header_t, pub NDR: NDR_record_t, pub RetCode: kern_return_t, } impl ::std::clone::Clone for Struct_Unnamed197 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed197 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __Reply__task_sample_t = Struct_Unnamed197; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed198 { pub Head: mach_msg_header_t, pub NDR: NDR_record_t, pub RetCode: kern_return_t, } impl ::std::clone::Clone for Struct_Unnamed198 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed198 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __Reply__task_policy_t = Struct_Unnamed198; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed199 { pub Head: mach_msg_header_t, pub NDR: NDR_record_t, pub RetCode: kern_return_t, } impl ::std::clone::Clone for Struct_Unnamed199 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed199 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __Reply__task_set_emulation_t = Struct_Unnamed199; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed200 { pub Head: mach_msg_header_t, pub msgh_body: mach_msg_body_t, pub emulation_vector: mach_msg_ool_descriptor_t, pub NDR: NDR_record_t, pub vector_start: ::libc::c_int, pub emulation_vectorCnt: mach_msg_type_number_t, } impl ::std::clone::Clone for Struct_Unnamed200 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed200 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __Reply__task_get_emulation_vector_t = Struct_Unnamed200; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed201 { pub Head: mach_msg_header_t, pub NDR: NDR_record_t, pub RetCode: kern_return_t, } impl ::std::clone::Clone for Struct_Unnamed201 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed201 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __Reply__task_set_emulation_vector_t = Struct_Unnamed201; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed202 { pub Head: mach_msg_header_t, pub NDR: NDR_record_t, pub RetCode: kern_return_t, } impl ::std::clone::Clone for Struct_Unnamed202 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed202 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __Reply__task_set_ras_pc_t = Struct_Unnamed202; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed203 { pub Head: mach_msg_header_t, pub msgh_body: mach_msg_body_t, pub names: mach_msg_ool_descriptor_t, pub info: mach_msg_ool_descriptor_t, pub NDR: NDR_record_t, pub namesCnt: mach_msg_type_number_t, pub infoCnt: mach_msg_type_number_t, } impl ::std::clone::Clone for Struct_Unnamed203 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed203 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __Reply__task_zone_info_t = Struct_Unnamed203; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed204 { pub Head: mach_msg_header_t, pub NDR: NDR_record_t, pub RetCode: kern_return_t, } impl ::std::clone::Clone for Struct_Unnamed204 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed204 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __Reply__task_assign_t = Struct_Unnamed204; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed205 { pub Head: mach_msg_header_t, pub NDR: NDR_record_t, pub RetCode: kern_return_t, } impl ::std::clone::Clone for Struct_Unnamed205 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed205 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __Reply__task_assign_default_t = Struct_Unnamed205; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed206 { pub Head: mach_msg_header_t, pub msgh_body: mach_msg_body_t, pub assigned_set: mach_msg_port_descriptor_t, } impl ::std::clone::Clone for Struct_Unnamed206 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed206 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __Reply__task_get_assignment_t = Struct_Unnamed206; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed207 { pub Head: mach_msg_header_t, pub NDR: NDR_record_t, pub RetCode: kern_return_t, } impl ::std::clone::Clone for Struct_Unnamed207 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed207 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __Reply__task_set_policy_t = Struct_Unnamed207; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed208 { pub Head: mach_msg_header_t, pub NDR: NDR_record_t, pub RetCode: kern_return_t, pub old_stateCnt: mach_msg_type_number_t, pub old_state: [natural_t; 224usize], } impl ::std::clone::Clone for Struct_Unnamed208 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed208 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __Reply__task_get_state_t = Struct_Unnamed208; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed209 { pub Head: mach_msg_header_t, pub NDR: NDR_record_t, pub RetCode: kern_return_t, } impl ::std::clone::Clone for Struct_Unnamed209 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed209 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __Reply__task_set_state_t = Struct_Unnamed209; #[repr(C)] #[derive(Copy)] pub struct Union___ReplyUnion__task_subsystem { pub _bindgen_data_: [u32; 234usize], } impl Union___ReplyUnion__task_subsystem { pub unsafe fn Reply_task_create(&mut self) -> *mut __Reply__task_create_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Reply_task_terminate(&mut self) -> *mut __Reply__task_terminate_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Reply_task_threads(&mut self) -> *mut __Reply__task_threads_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Reply_mach_ports_register(&mut self) -> *mut __Reply__mach_ports_register_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Reply_mach_ports_lookup(&mut self) -> *mut __Reply__mach_ports_lookup_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Reply_task_info(&mut self) -> *mut __Reply__task_info_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Reply_task_set_info(&mut self) -> *mut __Reply__task_set_info_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Reply_task_suspend(&mut self) -> *mut __Reply__task_suspend_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Reply_task_resume(&mut self) -> *mut __Reply__task_resume_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Reply_task_get_special_port(&mut self) -> *mut __Reply__task_get_special_port_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Reply_task_set_special_port(&mut self) -> *mut __Reply__task_set_special_port_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Reply_thread_create(&mut self) -> *mut __Reply__thread_create_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Reply_thread_create_running(&mut self) -> *mut __Reply__thread_create_running_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Reply_task_set_exception_ports( &mut self, ) -> *mut __Reply__task_set_exception_ports_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Reply_task_get_exception_ports( &mut self, ) -> *mut __Reply__task_get_exception_ports_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Reply_task_swap_exception_ports( &mut self, ) -> *mut __Reply__task_swap_exception_ports_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Reply_lock_set_create(&mut self) -> *mut __Reply__lock_set_create_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Reply_lock_set_destroy(&mut self) -> *mut __Reply__lock_set_destroy_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Reply_semaphore_create(&mut self) -> *mut __Reply__semaphore_create_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Reply_semaphore_destroy(&mut self) -> *mut __Reply__semaphore_destroy_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Reply_task_policy_set(&mut self) -> *mut __Reply__task_policy_set_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Reply_task_policy_get(&mut self) -> *mut __Reply__task_policy_get_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Reply_task_sample(&mut self) -> *mut __Reply__task_sample_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Reply_task_policy(&mut self) -> *mut __Reply__task_policy_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Reply_task_set_emulation(&mut self) -> *mut __Reply__task_set_emulation_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Reply_task_get_emulation_vector( &mut self, ) -> *mut __Reply__task_get_emulation_vector_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Reply_task_set_emulation_vector( &mut self, ) -> *mut __Reply__task_set_emulation_vector_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Reply_task_set_ras_pc(&mut self) -> *mut __Reply__task_set_ras_pc_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Reply_task_zone_info(&mut self) -> *mut __Reply__task_zone_info_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Reply_task_assign(&mut self) -> *mut __Reply__task_assign_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Reply_task_assign_default(&mut self) -> *mut __Reply__task_assign_default_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Reply_task_get_assignment(&mut self) -> *mut __Reply__task_get_assignment_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Reply_task_set_policy(&mut self) -> *mut __Reply__task_set_policy_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Reply_task_get_state(&mut self) -> *mut __Reply__task_get_state_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Reply_task_set_state(&mut self) -> *mut __Reply__task_set_state_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } } impl ::std::clone::Clone for Union___ReplyUnion__task_subsystem { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Union___ReplyUnion__task_subsystem { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed210 { pub Head: mach_msg_header_t, } impl ::std::clone::Clone for Struct_Unnamed210 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed210 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __Request__thread_terminate_t = Struct_Unnamed210; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed211 { pub Head: mach_msg_header_t, pub NDR: NDR_record_t, pub flavor: ::libc::c_int, pub old_stateCnt: mach_msg_type_number_t, } impl ::std::clone::Clone for Struct_Unnamed211 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed211 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __Request__act_get_state_t = Struct_Unnamed211; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed212 { pub Head: mach_msg_header_t, pub NDR: NDR_record_t, pub flavor: ::libc::c_int, pub new_stateCnt: mach_msg_type_number_t, pub new_state: [natural_t; 224usize], } impl ::std::clone::Clone for Struct_Unnamed212 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed212 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __Request__act_set_state_t = Struct_Unnamed212; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed213 { pub Head: mach_msg_header_t, pub NDR: NDR_record_t, pub flavor: thread_state_flavor_t, pub old_stateCnt: mach_msg_type_number_t, } impl ::std::clone::Clone for Struct_Unnamed213 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed213 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __Request__thread_get_state_t = Struct_Unnamed213; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed214 { pub Head: mach_msg_header_t, pub NDR: NDR_record_t, pub flavor: thread_state_flavor_t, pub new_stateCnt: mach_msg_type_number_t, pub new_state: [natural_t; 224usize], } impl ::std::clone::Clone for Struct_Unnamed214 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed214 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __Request__thread_set_state_t = Struct_Unnamed214; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed215 { pub Head: mach_msg_header_t, } impl ::std::clone::Clone for Struct_Unnamed215 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed215 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __Request__thread_suspend_t = Struct_Unnamed215; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed216 { pub Head: mach_msg_header_t, } impl ::std::clone::Clone for Struct_Unnamed216 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed216 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __Request__thread_resume_t = Struct_Unnamed216; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed217 { pub Head: mach_msg_header_t, } impl ::std::clone::Clone for Struct_Unnamed217 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed217 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __Request__thread_abort_t = Struct_Unnamed217; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed218 { pub Head: mach_msg_header_t, } impl ::std::clone::Clone for Struct_Unnamed218 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed218 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __Request__thread_abort_safely_t = Struct_Unnamed218; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed219 { pub Head: mach_msg_header_t, } impl ::std::clone::Clone for Struct_Unnamed219 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed219 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __Request__thread_depress_abort_t = Struct_Unnamed219; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed220 { pub Head: mach_msg_header_t, pub NDR: NDR_record_t, pub which_port: ::libc::c_int, } impl ::std::clone::Clone for Struct_Unnamed220 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed220 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __Request__thread_get_special_port_t = Struct_Unnamed220; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed221 { pub Head: mach_msg_header_t, pub msgh_body: mach_msg_body_t, pub special_port: mach_msg_port_descriptor_t, pub NDR: NDR_record_t, pub which_port: ::libc::c_int, } impl ::std::clone::Clone for Struct_Unnamed221 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed221 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __Request__thread_set_special_port_t = Struct_Unnamed221; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed222 { pub Head: mach_msg_header_t, pub NDR: NDR_record_t, pub flavor: thread_flavor_t, pub thread_info_outCnt: mach_msg_type_number_t, } impl ::std::clone::Clone for Struct_Unnamed222 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed222 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __Request__thread_info_t = Struct_Unnamed222; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed223 { pub Head: mach_msg_header_t, pub msgh_body: mach_msg_body_t, pub new_port: mach_msg_port_descriptor_t, pub NDR: NDR_record_t, pub exception_mask: exception_mask_t, pub behavior: exception_behavior_t, pub new_flavor: thread_state_flavor_t, } impl ::std::clone::Clone for Struct_Unnamed223 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed223 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __Request__thread_set_exception_ports_t = Struct_Unnamed223; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed224 { pub Head: mach_msg_header_t, pub NDR: NDR_record_t, pub exception_mask: exception_mask_t, } impl ::std::clone::Clone for Struct_Unnamed224 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed224 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __Request__thread_get_exception_ports_t = Struct_Unnamed224; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed225 { pub Head: mach_msg_header_t, pub msgh_body: mach_msg_body_t, pub new_port: mach_msg_port_descriptor_t, pub NDR: NDR_record_t, pub exception_mask: exception_mask_t, pub behavior: exception_behavior_t, pub new_flavor: thread_state_flavor_t, } impl ::std::clone::Clone for Struct_Unnamed225 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed225 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __Request__thread_swap_exception_ports_t = Struct_Unnamed225; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed226 { pub Head: mach_msg_header_t, pub NDR: NDR_record_t, pub policy: policy_t, pub baseCnt: mach_msg_type_number_t, pub base: [integer_t; 5usize], pub set_limit: boolean_t, } impl ::std::clone::Clone for Struct_Unnamed226 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed226 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __Request__thread_policy_t = Struct_Unnamed226; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed227 { pub Head: mach_msg_header_t, pub NDR: NDR_record_t, pub flavor: thread_policy_flavor_t, pub policy_infoCnt: mach_msg_type_number_t, pub policy_info: [integer_t; 16usize], } impl ::std::clone::Clone for Struct_Unnamed227 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed227 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __Request__thread_policy_set_t = Struct_Unnamed227; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed228 { pub Head: mach_msg_header_t, pub NDR: NDR_record_t, pub flavor: thread_policy_flavor_t, pub policy_infoCnt: mach_msg_type_number_t, pub get_default: boolean_t, } impl ::std::clone::Clone for Struct_Unnamed228 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed228 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __Request__thread_policy_get_t = Struct_Unnamed228; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed229 { pub Head: mach_msg_header_t, pub msgh_body: mach_msg_body_t, pub reply: mach_msg_port_descriptor_t, } impl ::std::clone::Clone for Struct_Unnamed229 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed229 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __Request__thread_sample_t = Struct_Unnamed229; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed230 { pub Head: mach_msg_header_t, pub NDR: NDR_record_t, pub trace_status: boolean_t, } impl ::std::clone::Clone for Struct_Unnamed230 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed230 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __Request__etap_trace_thread_t = Struct_Unnamed230; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed231 { pub Head: mach_msg_header_t, pub msgh_body: mach_msg_body_t, pub new_set: mach_msg_port_descriptor_t, } impl ::std::clone::Clone for Struct_Unnamed231 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed231 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __Request__thread_assign_t = Struct_Unnamed231; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed232 { pub Head: mach_msg_header_t, } impl ::std::clone::Clone for Struct_Unnamed232 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed232 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __Request__thread_assign_default_t = Struct_Unnamed232; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed233 { pub Head: mach_msg_header_t, } impl ::std::clone::Clone for Struct_Unnamed233 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed233 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __Request__thread_get_assignment_t = Struct_Unnamed233; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed234 { pub Head: mach_msg_header_t, pub msgh_body: mach_msg_body_t, pub pset: mach_msg_port_descriptor_t, pub NDR: NDR_record_t, pub policy: policy_t, pub baseCnt: mach_msg_type_number_t, pub base: [integer_t; 5usize], pub limitCnt: mach_msg_type_number_t, pub limit: [integer_t; 1usize], } impl ::std::clone::Clone for Struct_Unnamed234 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed234 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __Request__thread_set_policy_t = Struct_Unnamed234; #[repr(C)] #[derive(Copy)] pub struct Union___RequestUnion__thread_act_subsystem { pub _bindgen_data_: [u32; 234usize], } impl Union___RequestUnion__thread_act_subsystem { pub unsafe fn Request_thread_terminate(&mut self) -> *mut __Request__thread_terminate_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Request_act_get_state(&mut self) -> *mut __Request__act_get_state_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Request_act_set_state(&mut self) -> *mut __Request__act_set_state_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Request_thread_get_state(&mut self) -> *mut __Request__thread_get_state_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Request_thread_set_state(&mut self) -> *mut __Request__thread_set_state_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Request_thread_suspend(&mut self) -> *mut __Request__thread_suspend_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Request_thread_resume(&mut self) -> *mut __Request__thread_resume_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Request_thread_abort(&mut self) -> *mut __Request__thread_abort_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Request_thread_abort_safely(&mut self) -> *mut __Request__thread_abort_safely_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Request_thread_depress_abort( &mut self, ) -> *mut __Request__thread_depress_abort_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Request_thread_get_special_port( &mut self, ) -> *mut __Request__thread_get_special_port_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Request_thread_set_special_port( &mut self, ) -> *mut __Request__thread_set_special_port_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Request_thread_info(&mut self) -> *mut __Request__thread_info_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Request_thread_set_exception_ports( &mut self, ) -> *mut __Request__thread_set_exception_ports_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Request_thread_get_exception_ports( &mut self, ) -> *mut __Request__thread_get_exception_ports_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Request_thread_swap_exception_ports( &mut self, ) -> *mut __Request__thread_swap_exception_ports_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Request_thread_policy(&mut self) -> *mut __Request__thread_policy_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Request_thread_policy_set(&mut self) -> *mut __Request__thread_policy_set_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Request_thread_policy_get(&mut self) -> *mut __Request__thread_policy_get_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Request_thread_sample(&mut self) -> *mut __Request__thread_sample_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Request_etap_trace_thread(&mut self) -> *mut __Request__etap_trace_thread_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Request_thread_assign(&mut self) -> *mut __Request__thread_assign_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Request_thread_assign_default( &mut self, ) -> *mut __Request__thread_assign_default_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Request_thread_get_assignment( &mut self, ) -> *mut __Request__thread_get_assignment_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Request_thread_set_policy(&mut self) -> *mut __Request__thread_set_policy_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } } impl ::std::clone::Clone for Union___RequestUnion__thread_act_subsystem { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Union___RequestUnion__thread_act_subsystem { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed235 { pub Head: mach_msg_header_t, pub NDR: NDR_record_t, pub RetCode: kern_return_t, } impl ::std::clone::Clone for Struct_Unnamed235 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed235 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __Reply__thread_terminate_t = Struct_Unnamed235; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed236 { pub Head: mach_msg_header_t, pub NDR: NDR_record_t, pub RetCode: kern_return_t, pub old_stateCnt: mach_msg_type_number_t, pub old_state: [natural_t; 224usize], } impl ::std::clone::Clone for Struct_Unnamed236 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed236 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __Reply__act_get_state_t = Struct_Unnamed236; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed237 { pub Head: mach_msg_header_t, pub NDR: NDR_record_t, pub RetCode: kern_return_t, } impl ::std::clone::Clone for Struct_Unnamed237 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed237 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __Reply__act_set_state_t = Struct_Unnamed237; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed238 { pub Head: mach_msg_header_t, pub NDR: NDR_record_t, pub RetCode: kern_return_t, pub old_stateCnt: mach_msg_type_number_t, pub old_state: [natural_t; 224usize], } impl ::std::clone::Clone for Struct_Unnamed238 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed238 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __Reply__thread_get_state_t = Struct_Unnamed238; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed239 { pub Head: mach_msg_header_t, pub NDR: NDR_record_t, pub RetCode: kern_return_t, } impl ::std::clone::Clone for Struct_Unnamed239 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed239 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __Reply__thread_set_state_t = Struct_Unnamed239; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed240 { pub Head: mach_msg_header_t, pub NDR: NDR_record_t, pub RetCode: kern_return_t, } impl ::std::clone::Clone for Struct_Unnamed240 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed240 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __Reply__thread_suspend_t = Struct_Unnamed240; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed241 { pub Head: mach_msg_header_t, pub NDR: NDR_record_t, pub RetCode: kern_return_t, } impl ::std::clone::Clone for Struct_Unnamed241 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed241 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __Reply__thread_resume_t = Struct_Unnamed241; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed242 { pub Head: mach_msg_header_t, pub NDR: NDR_record_t, pub RetCode: kern_return_t, } impl ::std::clone::Clone for Struct_Unnamed242 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed242 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __Reply__thread_abort_t = Struct_Unnamed242; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed243 { pub Head: mach_msg_header_t, pub NDR: NDR_record_t, pub RetCode: kern_return_t, } impl ::std::clone::Clone for Struct_Unnamed243 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed243 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __Reply__thread_abort_safely_t = Struct_Unnamed243; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed244 { pub Head: mach_msg_header_t, pub NDR: NDR_record_t, pub RetCode: kern_return_t, } impl ::std::clone::Clone for Struct_Unnamed244 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed244 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __Reply__thread_depress_abort_t = Struct_Unnamed244; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed245 { pub Head: mach_msg_header_t, pub msgh_body: mach_msg_body_t, pub special_port: mach_msg_port_descriptor_t, } impl ::std::clone::Clone for Struct_Unnamed245 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed245 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __Reply__thread_get_special_port_t = Struct_Unnamed245; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed246 { pub Head: mach_msg_header_t, pub NDR: NDR_record_t, pub RetCode: kern_return_t, } impl ::std::clone::Clone for Struct_Unnamed246 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed246 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __Reply__thread_set_special_port_t = Struct_Unnamed246; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed247 { pub Head: mach_msg_header_t, pub NDR: NDR_record_t, pub RetCode: kern_return_t, pub thread_info_outCnt: mach_msg_type_number_t, pub thread_info_out: [integer_t; 12usize], } impl ::std::clone::Clone for Struct_Unnamed247 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed247 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __Reply__thread_info_t = Struct_Unnamed247; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed248 { pub Head: mach_msg_header_t, pub NDR: NDR_record_t, pub RetCode: kern_return_t, } impl ::std::clone::Clone for Struct_Unnamed248 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed248 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __Reply__thread_set_exception_ports_t = Struct_Unnamed248; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed249 { pub Head: mach_msg_header_t, pub msgh_body: mach_msg_body_t, pub old_handlers: [mach_msg_port_descriptor_t; 32usize], pub NDR: NDR_record_t, pub masksCnt: mach_msg_type_number_t, pub masks: [exception_mask_t; 32usize], pub old_behaviors: [exception_behavior_t; 32usize], pub old_flavors: [thread_state_flavor_t; 32usize], } impl ::std::clone::Clone for Struct_Unnamed249 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed249 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __Reply__thread_get_exception_ports_t = Struct_Unnamed249; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed250 { pub Head: mach_msg_header_t, pub msgh_body: mach_msg_body_t, pub old_handlers: [mach_msg_port_descriptor_t; 32usize], pub NDR: NDR_record_t, pub masksCnt: mach_msg_type_number_t, pub masks: [exception_mask_t; 32usize], pub old_behaviors: [exception_behavior_t; 32usize], pub old_flavors: [thread_state_flavor_t; 32usize], } impl ::std::clone::Clone for Struct_Unnamed250 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed250 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __Reply__thread_swap_exception_ports_t = Struct_Unnamed250; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed251 { pub Head: mach_msg_header_t, pub NDR: NDR_record_t, pub RetCode: kern_return_t, } impl ::std::clone::Clone for Struct_Unnamed251 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed251 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __Reply__thread_policy_t = Struct_Unnamed251; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed252 { pub Head: mach_msg_header_t, pub NDR: NDR_record_t, pub RetCode: kern_return_t, } impl ::std::clone::Clone for Struct_Unnamed252 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed252 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __Reply__thread_policy_set_t = Struct_Unnamed252; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed253 { pub Head: mach_msg_header_t, pub NDR: NDR_record_t, pub RetCode: kern_return_t, pub policy_infoCnt: mach_msg_type_number_t, pub policy_info: [integer_t; 16usize], pub get_default: boolean_t, } impl ::std::clone::Clone for Struct_Unnamed253 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed253 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __Reply__thread_policy_get_t = Struct_Unnamed253; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed254 { pub Head: mach_msg_header_t, pub NDR: NDR_record_t, pub RetCode: kern_return_t, } impl ::std::clone::Clone for Struct_Unnamed254 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed254 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __Reply__thread_sample_t = Struct_Unnamed254; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed255 { pub Head: mach_msg_header_t, pub NDR: NDR_record_t, pub RetCode: kern_return_t, } impl ::std::clone::Clone for Struct_Unnamed255 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed255 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __Reply__etap_trace_thread_t = Struct_Unnamed255; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed256 { pub Head: mach_msg_header_t, pub NDR: NDR_record_t, pub RetCode: kern_return_t, } impl ::std::clone::Clone for Struct_Unnamed256 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed256 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __Reply__thread_assign_t = Struct_Unnamed256; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed257 { pub Head: mach_msg_header_t, pub NDR: NDR_record_t, pub RetCode: kern_return_t, } impl ::std::clone::Clone for Struct_Unnamed257 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed257 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __Reply__thread_assign_default_t = Struct_Unnamed257; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed258 { pub Head: mach_msg_header_t, pub msgh_body: mach_msg_body_t, pub assigned_set: mach_msg_port_descriptor_t, } impl ::std::clone::Clone for Struct_Unnamed258 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed258 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __Reply__thread_get_assignment_t = Struct_Unnamed258; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed259 { pub Head: mach_msg_header_t, pub NDR: NDR_record_t, pub RetCode: kern_return_t, } impl ::std::clone::Clone for Struct_Unnamed259 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed259 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __Reply__thread_set_policy_t = Struct_Unnamed259; #[repr(C)] #[derive(Copy)] pub struct Union___ReplyUnion__thread_act_subsystem { pub _bindgen_data_: [u32; 234usize], } impl Union___ReplyUnion__thread_act_subsystem { pub unsafe fn Reply_thread_terminate(&mut self) -> *mut __Reply__thread_terminate_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Reply_act_get_state(&mut self) -> *mut __Reply__act_get_state_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Reply_act_set_state(&mut self) -> *mut __Reply__act_set_state_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Reply_thread_get_state(&mut self) -> *mut __Reply__thread_get_state_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Reply_thread_set_state(&mut self) -> *mut __Reply__thread_set_state_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Reply_thread_suspend(&mut self) -> *mut __Reply__thread_suspend_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Reply_thread_resume(&mut self) -> *mut __Reply__thread_resume_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Reply_thread_abort(&mut self) -> *mut __Reply__thread_abort_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Reply_thread_abort_safely(&mut self) -> *mut __Reply__thread_abort_safely_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Reply_thread_depress_abort(&mut self) -> *mut __Reply__thread_depress_abort_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Reply_thread_get_special_port( &mut self, ) -> *mut __Reply__thread_get_special_port_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Reply_thread_set_special_port( &mut self, ) -> *mut __Reply__thread_set_special_port_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Reply_thread_info(&mut self) -> *mut __Reply__thread_info_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Reply_thread_set_exception_ports( &mut self, ) -> *mut __Reply__thread_set_exception_ports_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Reply_thread_get_exception_ports( &mut self, ) -> *mut __Reply__thread_get_exception_ports_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Reply_thread_swap_exception_ports( &mut self, ) -> *mut __Reply__thread_swap_exception_ports_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Reply_thread_policy(&mut self) -> *mut __Reply__thread_policy_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Reply_thread_policy_set(&mut self) -> *mut __Reply__thread_policy_set_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Reply_thread_policy_get(&mut self) -> *mut __Reply__thread_policy_get_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Reply_thread_sample(&mut self) -> *mut __Reply__thread_sample_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Reply_etap_trace_thread(&mut self) -> *mut __Reply__etap_trace_thread_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Reply_thread_assign(&mut self) -> *mut __Reply__thread_assign_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Reply_thread_assign_default(&mut self) -> *mut __Reply__thread_assign_default_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Reply_thread_get_assignment(&mut self) -> *mut __Reply__thread_get_assignment_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Reply_thread_set_policy(&mut self) -> *mut __Reply__thread_set_policy_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } } impl ::std::clone::Clone for Union___ReplyUnion__thread_act_subsystem { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Union___ReplyUnion__thread_act_subsystem { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed260 { pub Head: mach_msg_header_t, pub NDR: NDR_record_t, pub address: vm_address_t, pub flavor: vm_region_flavor_t, pub infoCnt: mach_msg_type_number_t, } impl ::std::clone::Clone for Struct_Unnamed260 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed260 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __Request__vm_region_t = Struct_Unnamed260; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed261 { pub Head: mach_msg_header_t, pub NDR: NDR_record_t, pub address: vm_address_t, pub size: vm_size_t, pub flags: ::libc::c_int, } impl ::std::clone::Clone for Struct_Unnamed261 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed261 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __Request__vm_allocate_t = Struct_Unnamed261; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed262 { pub Head: mach_msg_header_t, pub NDR: NDR_record_t, pub address: vm_address_t, pub size: vm_size_t, } impl ::std::clone::Clone for Struct_Unnamed262 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed262 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __Request__vm_deallocate_t = Struct_Unnamed262; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed263 { pub Head: mach_msg_header_t, pub NDR: NDR_record_t, pub address: vm_address_t, pub size: vm_size_t, pub set_maximum: boolean_t, pub new_protection: vm_prot_t, } impl ::std::clone::Clone for Struct_Unnamed263 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed263 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __Request__vm_protect_t = Struct_Unnamed263; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed264 { pub Head: mach_msg_header_t, pub NDR: NDR_record_t, pub address: vm_address_t, pub size: vm_size_t, pub new_inheritance: vm_inherit_t, } impl ::std::clone::Clone for Struct_Unnamed264 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed264 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __Request__vm_inherit_t = Struct_Unnamed264; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed265 { pub Head: mach_msg_header_t, pub NDR: NDR_record_t, pub address: vm_address_t, pub size: vm_size_t, } impl ::std::clone::Clone for Struct_Unnamed265 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed265 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __Request__vm_read_t = Struct_Unnamed265; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed266 { pub Head: mach_msg_header_t, pub NDR: NDR_record_t, pub data_list: vm_read_entry_t, pub count: natural_t, } impl ::std::clone::Clone for Struct_Unnamed266 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed266 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __Request__vm_read_list_t = Struct_Unnamed266; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed267 { pub Head: mach_msg_header_t, pub msgh_body: mach_msg_body_t, pub data: mach_msg_ool_descriptor_t, pub NDR: NDR_record_t, pub address: vm_address_t, pub dataCnt: mach_msg_type_number_t, } impl ::std::clone::Clone for Struct_Unnamed267 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed267 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __Request__vm_write_t = Struct_Unnamed267; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed268 { pub Head: mach_msg_header_t, pub NDR: NDR_record_t, pub source_address: vm_address_t, pub size: vm_size_t, pub dest_address: vm_address_t, } impl ::std::clone::Clone for Struct_Unnamed268 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed268 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __Request__vm_copy_t = Struct_Unnamed268; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed269 { pub Head: mach_msg_header_t, pub NDR: NDR_record_t, pub address: vm_address_t, pub size: vm_size_t, pub data: vm_address_t, } impl ::std::clone::Clone for Struct_Unnamed269 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed269 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __Request__vm_read_overwrite_t = Struct_Unnamed269; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed270 { pub Head: mach_msg_header_t, pub NDR: NDR_record_t, pub address: vm_address_t, pub size: vm_size_t, pub sync_flags: vm_sync_t, } impl ::std::clone::Clone for Struct_Unnamed270 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed270 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __Request__vm_msync_t = Struct_Unnamed270; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed271 { pub Head: mach_msg_header_t, pub NDR: NDR_record_t, pub address: vm_address_t, pub size: vm_size_t, pub new_behavior: vm_behavior_t, } impl ::std::clone::Clone for Struct_Unnamed271 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed271 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __Request__vm_behavior_set_t = Struct_Unnamed271; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed272 { pub Head: mach_msg_header_t, pub msgh_body: mach_msg_body_t, pub object: mach_msg_port_descriptor_t, pub NDR: NDR_record_t, pub address: vm_address_t, pub size: vm_size_t, pub mask: vm_address_t, pub flags: ::libc::c_int, pub offset: vm_offset_t, pub copy: boolean_t, pub cur_protection: vm_prot_t, pub max_protection: vm_prot_t, pub inheritance: vm_inherit_t, } impl ::std::clone::Clone for Struct_Unnamed272 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed272 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __Request__vm_map_t = Struct_Unnamed272; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed273 { pub Head: mach_msg_header_t, pub NDR: NDR_record_t, pub address: vm_address_t, pub size: vm_size_t, pub attribute: vm_machine_attribute_t, pub value: vm_machine_attribute_val_t, } impl ::std::clone::Clone for Struct_Unnamed273 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed273 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __Request__vm_machine_attribute_t = Struct_Unnamed273; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed274 { pub Head: mach_msg_header_t, pub msgh_body: mach_msg_body_t, pub src_task: mach_msg_port_descriptor_t, pub NDR: NDR_record_t, pub target_address: vm_address_t, pub size: vm_size_t, pub mask: vm_address_t, pub flags: ::libc::c_int, pub src_address: vm_address_t, pub copy: boolean_t, pub inheritance: vm_inherit_t, } impl ::std::clone::Clone for Struct_Unnamed274 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed274 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __Request__vm_remap_t = Struct_Unnamed274; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed275 { pub Head: mach_msg_header_t, pub NDR: NDR_record_t, pub must_wire: boolean_t, } impl ::std::clone::Clone for Struct_Unnamed275 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed275 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __Request__task_wire_t = Struct_Unnamed275; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed276 { pub Head: mach_msg_header_t, pub msgh_body: mach_msg_body_t, pub parent_entry: mach_msg_port_descriptor_t, pub NDR: NDR_record_t, pub size: vm_size_t, pub offset: vm_offset_t, pub permission: vm_prot_t, } impl ::std::clone::Clone for Struct_Unnamed276 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed276 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __Request__mach_make_memory_entry_t = Struct_Unnamed276; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed277 { pub Head: mach_msg_header_t, pub NDR: NDR_record_t, pub offset: vm_offset_t, } impl ::std::clone::Clone for Struct_Unnamed277 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed277 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __Request__vm_map_page_query_t = Struct_Unnamed277; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed278 { pub Head: mach_msg_header_t, pub NDR: NDR_record_t, pub address: vm_address_t, } impl ::std::clone::Clone for Struct_Unnamed278 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed278 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __Request__mach_vm_region_info_t = Struct_Unnamed278; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed279 { pub Head: mach_msg_header_t, } impl ::std::clone::Clone for Struct_Unnamed279 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed279 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __Request__vm_mapped_pages_info_t = Struct_Unnamed279; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed280 { pub Head: mach_msg_header_t, pub NDR: NDR_record_t, pub address: vm_address_t, pub nesting_depth: natural_t, pub infoCnt: mach_msg_type_number_t, } impl ::std::clone::Clone for Struct_Unnamed280 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed280 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __Request__vm_region_recurse_t = Struct_Unnamed280; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed281 { pub Head: mach_msg_header_t, pub NDR: NDR_record_t, pub address: vm_address_t, pub nesting_depth: natural_t, pub infoCnt: mach_msg_type_number_t, } impl ::std::clone::Clone for Struct_Unnamed281 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed281 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __Request__vm_region_recurse_64_t = Struct_Unnamed281; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed282 { pub Head: mach_msg_header_t, pub NDR: NDR_record_t, pub address: vm_address_t, } impl ::std::clone::Clone for Struct_Unnamed282 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed282 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __Request__mach_vm_region_info_64_t = Struct_Unnamed282; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed283 { pub Head: mach_msg_header_t, pub NDR: NDR_record_t, pub address: vm_address_t, pub flavor: vm_region_flavor_t, pub infoCnt: mach_msg_type_number_t, } impl ::std::clone::Clone for Struct_Unnamed283 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed283 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __Request__vm_region_64_t = Struct_Unnamed283; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed284 { pub Head: mach_msg_header_t, pub msgh_body: mach_msg_body_t, pub parent_entry: mach_msg_port_descriptor_t, pub NDR: NDR_record_t, pub size: memory_object_size_t, pub offset: memory_object_offset_t, pub permission: vm_prot_t, } impl ::std::clone::Clone for Struct_Unnamed284 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed284 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __Request__mach_make_memory_entry_64_t = Struct_Unnamed284; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed285 { pub Head: mach_msg_header_t, pub msgh_body: mach_msg_body_t, pub object: mach_msg_port_descriptor_t, pub NDR: NDR_record_t, pub address: vm_address_t, pub size: vm_size_t, pub mask: vm_address_t, pub flags: ::libc::c_int, pub offset: memory_object_offset_t, pub copy: boolean_t, pub cur_protection: vm_prot_t, pub max_protection: vm_prot_t, pub inheritance: vm_inherit_t, } impl ::std::clone::Clone for Struct_Unnamed285 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed285 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __Request__vm_map_64_t = Struct_Unnamed285; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed286 { pub Head: mach_msg_header_t, pub NDR: NDR_record_t, pub address: vm_address_t, pub control: vm_purgable_t, pub state: ::libc::c_int, } impl ::std::clone::Clone for Struct_Unnamed286 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed286 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __Request__vm_purgable_control_t = Struct_Unnamed286; #[repr(C)] #[derive(Copy)] pub struct Union___RequestUnion__vm_map_subsystem { pub _bindgen_data_: [u32; 1033usize], } impl Union___RequestUnion__vm_map_subsystem { pub unsafe fn Request_vm_region(&mut self) -> *mut __Request__vm_region_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Request_vm_allocate(&mut self) -> *mut __Request__vm_allocate_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Request_vm_deallocate(&mut self) -> *mut __Request__vm_deallocate_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Request_vm_protect(&mut self) -> *mut __Request__vm_protect_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Request_vm_inherit(&mut self) -> *mut __Request__vm_inherit_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Request_vm_read(&mut self) -> *mut __Request__vm_read_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Request_vm_read_list(&mut self) -> *mut __Request__vm_read_list_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Request_vm_write(&mut self) -> *mut __Request__vm_write_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Request_vm_copy(&mut self) -> *mut __Request__vm_copy_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Request_vm_read_overwrite(&mut self) -> *mut __Request__vm_read_overwrite_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Request_vm_msync(&mut self) -> *mut __Request__vm_msync_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Request_vm_behavior_set(&mut self) -> *mut __Request__vm_behavior_set_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Request_vm_map(&mut self) -> *mut __Request__vm_map_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Request_vm_machine_attribute( &mut self, ) -> *mut __Request__vm_machine_attribute_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Request_vm_remap(&mut self) -> *mut __Request__vm_remap_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Request_task_wire(&mut self) -> *mut __Request__task_wire_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Request_mach_make_memory_entry( &mut self, ) -> *mut __Request__mach_make_memory_entry_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Request_vm_map_page_query(&mut self) -> *mut __Request__vm_map_page_query_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Request_mach_vm_region_info(&mut self) -> *mut __Request__mach_vm_region_info_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Request_vm_mapped_pages_info( &mut self, ) -> *mut __Request__vm_mapped_pages_info_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Request_vm_region_recurse(&mut self) -> *mut __Request__vm_region_recurse_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Request_vm_region_recurse_64( &mut self, ) -> *mut __Request__vm_region_recurse_64_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Request_mach_vm_region_info_64( &mut self, ) -> *mut __Request__mach_vm_region_info_64_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Request_vm_region_64(&mut self) -> *mut __Request__vm_region_64_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Request_mach_make_memory_entry_64( &mut self, ) -> *mut __Request__mach_make_memory_entry_64_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Request_vm_map_64(&mut self) -> *mut __Request__vm_map_64_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Request_vm_purgable_control(&mut self) -> *mut __Request__vm_purgable_control_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } } impl ::std::clone::Clone for Union___RequestUnion__vm_map_subsystem { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Union___RequestUnion__vm_map_subsystem { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed287 { pub Head: mach_msg_header_t, pub msgh_body: mach_msg_body_t, pub object_name: mach_msg_port_descriptor_t, pub NDR: NDR_record_t, pub address: vm_address_t, pub size: vm_size_t, pub infoCnt: mach_msg_type_number_t, pub info: [::libc::c_int; 10usize], } impl ::std::clone::Clone for Struct_Unnamed287 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed287 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __Reply__vm_region_t = Struct_Unnamed287; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed288 { pub Head: mach_msg_header_t, pub NDR: NDR_record_t, pub RetCode: kern_return_t, pub address: vm_address_t, } impl ::std::clone::Clone for Struct_Unnamed288 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed288 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __Reply__vm_allocate_t = Struct_Unnamed288; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed289 { pub Head: mach_msg_header_t, pub NDR: NDR_record_t, pub RetCode: kern_return_t, } impl ::std::clone::Clone for Struct_Unnamed289 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed289 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __Reply__vm_deallocate_t = Struct_Unnamed289; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed290 { pub Head: mach_msg_header_t, pub NDR: NDR_record_t, pub RetCode: kern_return_t, } impl ::std::clone::Clone for Struct_Unnamed290 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed290 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __Reply__vm_protect_t = Struct_Unnamed290; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed291 { pub Head: mach_msg_header_t, pub NDR: NDR_record_t, pub RetCode: kern_return_t, } impl ::std::clone::Clone for Struct_Unnamed291 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed291 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __Reply__vm_inherit_t = Struct_Unnamed291; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed292 { pub Head: mach_msg_header_t, pub msgh_body: mach_msg_body_t, pub data: mach_msg_ool_descriptor_t, pub NDR: NDR_record_t, pub dataCnt: mach_msg_type_number_t, } impl ::std::clone::Clone for Struct_Unnamed292 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed292 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __Reply__vm_read_t = Struct_Unnamed292; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed293 { pub Head: mach_msg_header_t, pub NDR: NDR_record_t, pub RetCode: kern_return_t, pub data_list: vm_read_entry_t, } impl ::std::clone::Clone for Struct_Unnamed293 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed293 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __Reply__vm_read_list_t = Struct_Unnamed293; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed294 { pub Head: mach_msg_header_t, pub NDR: NDR_record_t, pub RetCode: kern_return_t, } impl ::std::clone::Clone for Struct_Unnamed294 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed294 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __Reply__vm_write_t = Struct_Unnamed294; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed295 { pub Head: mach_msg_header_t, pub NDR: NDR_record_t, pub RetCode: kern_return_t, } impl ::std::clone::Clone for Struct_Unnamed295 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed295 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __Reply__vm_copy_t = Struct_Unnamed295; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed296 { pub Head: mach_msg_header_t, pub NDR: NDR_record_t, pub RetCode: kern_return_t, pub outsize: vm_size_t, } impl ::std::clone::Clone for Struct_Unnamed296 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed296 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __Reply__vm_read_overwrite_t = Struct_Unnamed296; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed297 { pub Head: mach_msg_header_t, pub NDR: NDR_record_t, pub RetCode: kern_return_t, } impl ::std::clone::Clone for Struct_Unnamed297 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed297 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __Reply__vm_msync_t = Struct_Unnamed297; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed298 { pub Head: mach_msg_header_t, pub NDR: NDR_record_t, pub RetCode: kern_return_t, } impl ::std::clone::Clone for Struct_Unnamed298 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed298 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __Reply__vm_behavior_set_t = Struct_Unnamed298; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed299 { pub Head: mach_msg_header_t, pub NDR: NDR_record_t, pub RetCode: kern_return_t, pub address: vm_address_t, } impl ::std::clone::Clone for Struct_Unnamed299 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed299 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __Reply__vm_map_t = Struct_Unnamed299; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed300 { pub Head: mach_msg_header_t, pub NDR: NDR_record_t, pub RetCode: kern_return_t, pub value: vm_machine_attribute_val_t, } impl ::std::clone::Clone for Struct_Unnamed300 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed300 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __Reply__vm_machine_attribute_t = Struct_Unnamed300; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed301 { pub Head: mach_msg_header_t, pub NDR: NDR_record_t, pub RetCode: kern_return_t, pub target_address: vm_address_t, pub cur_protection: vm_prot_t, pub max_protection: vm_prot_t, } impl ::std::clone::Clone for Struct_Unnamed301 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed301 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __Reply__vm_remap_t = Struct_Unnamed301; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed302 { pub Head: mach_msg_header_t, pub NDR: NDR_record_t, pub RetCode: kern_return_t, } impl ::std::clone::Clone for Struct_Unnamed302 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed302 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __Reply__task_wire_t = Struct_Unnamed302; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed303 { pub Head: mach_msg_header_t, pub msgh_body: mach_msg_body_t, pub object_handle: mach_msg_port_descriptor_t, pub NDR: NDR_record_t, pub size: vm_size_t, } impl ::std::clone::Clone for Struct_Unnamed303 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed303 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __Reply__mach_make_memory_entry_t = Struct_Unnamed303; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed304 { pub Head: mach_msg_header_t, pub NDR: NDR_record_t, pub RetCode: kern_return_t, pub disposition: integer_t, pub ref_count: integer_t, } impl ::std::clone::Clone for Struct_Unnamed304 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed304 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __Reply__vm_map_page_query_t = Struct_Unnamed304; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed306 { pub Head: mach_msg_header_t, pub msgh_body: mach_msg_body_t, pub pages: mach_msg_ool_descriptor_t, pub NDR: NDR_record_t, pub pagesCnt: mach_msg_type_number_t, } impl ::std::clone::Clone for Struct_Unnamed306 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed306 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __Reply__vm_mapped_pages_info_t = Struct_Unnamed306; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed307 { pub Head: mach_msg_header_t, pub NDR: NDR_record_t, pub RetCode: kern_return_t, pub address: vm_address_t, pub size: vm_size_t, pub nesting_depth: natural_t, pub infoCnt: mach_msg_type_number_t, pub info: [::libc::c_int; 19usize], } impl ::std::clone::Clone for Struct_Unnamed307 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed307 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __Reply__vm_region_recurse_t = Struct_Unnamed307; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed308 { pub Head: mach_msg_header_t, pub NDR: NDR_record_t, pub RetCode: kern_return_t, pub address: vm_address_t, pub size: vm_size_t, pub nesting_depth: natural_t, pub infoCnt: mach_msg_type_number_t, pub info: [::libc::c_int; 19usize], } impl ::std::clone::Clone for Struct_Unnamed308 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed308 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __Reply__vm_region_recurse_64_t = Struct_Unnamed308; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed310 { pub Head: mach_msg_header_t, pub msgh_body: mach_msg_body_t, pub object_name: mach_msg_port_descriptor_t, pub NDR: NDR_record_t, pub address: vm_address_t, pub size: vm_size_t, pub infoCnt: mach_msg_type_number_t, pub info: [::libc::c_int; 10usize], } impl ::std::clone::Clone for Struct_Unnamed310 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed310 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __Reply__vm_region_64_t = Struct_Unnamed310; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed311 { pub Head: mach_msg_header_t, pub msgh_body: mach_msg_body_t, pub object_handle: mach_msg_port_descriptor_t, pub NDR: NDR_record_t, pub size: memory_object_size_t, } impl ::std::clone::Clone for Struct_Unnamed311 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed311 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __Reply__mach_make_memory_entry_64_t = Struct_Unnamed311; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed312 { pub Head: mach_msg_header_t, pub NDR: NDR_record_t, pub RetCode: kern_return_t, pub address: vm_address_t, } impl ::std::clone::Clone for Struct_Unnamed312 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed312 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __Reply__vm_map_64_t = Struct_Unnamed312; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed313 { pub Head: mach_msg_header_t, pub NDR: NDR_record_t, pub RetCode: kern_return_t, pub state: ::libc::c_int, } impl ::std::clone::Clone for Struct_Unnamed313 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed313 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __Reply__vm_purgable_control_t = Struct_Unnamed313; #[repr(C)] #[derive(Copy)] pub struct Union___ReplyUnion__vm_map_subsystem { pub _bindgen_data_: [u32; 1033usize], } impl Union___ReplyUnion__vm_map_subsystem { pub unsafe fn Reply_vm_region(&mut self) -> *mut __Reply__vm_region_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Reply_vm_allocate(&mut self) -> *mut __Reply__vm_allocate_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Reply_vm_deallocate(&mut self) -> *mut __Reply__vm_deallocate_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Reply_vm_protect(&mut self) -> *mut __Reply__vm_protect_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Reply_vm_inherit(&mut self) -> *mut __Reply__vm_inherit_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Reply_vm_read(&mut self) -> *mut __Reply__vm_read_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Reply_vm_read_list(&mut self) -> *mut __Reply__vm_read_list_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Reply_vm_write(&mut self) -> *mut __Reply__vm_write_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Reply_vm_copy(&mut self) -> *mut __Reply__vm_copy_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Reply_vm_read_overwrite(&mut self) -> *mut __Reply__vm_read_overwrite_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Reply_vm_msync(&mut self) -> *mut __Reply__vm_msync_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Reply_vm_behavior_set(&mut self) -> *mut __Reply__vm_behavior_set_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Reply_vm_map(&mut self) -> *mut __Reply__vm_map_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Reply_vm_machine_attribute(&mut self) -> *mut __Reply__vm_machine_attribute_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Reply_vm_remap(&mut self) -> *mut __Reply__vm_remap_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Reply_task_wire(&mut self) -> *mut __Reply__task_wire_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Reply_mach_make_memory_entry( &mut self, ) -> *mut __Reply__mach_make_memory_entry_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Reply_vm_map_page_query(&mut self) -> *mut __Reply__vm_map_page_query_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Reply_vm_mapped_pages_info(&mut self) -> *mut __Reply__vm_mapped_pages_info_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Reply_vm_region_recurse(&mut self) -> *mut __Reply__vm_region_recurse_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Reply_vm_region_recurse_64(&mut self) -> *mut __Reply__vm_region_recurse_64_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Reply_vm_region_64(&mut self) -> *mut __Reply__vm_region_64_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Reply_mach_make_memory_entry_64( &mut self, ) -> *mut __Reply__mach_make_memory_entry_64_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Reply_vm_map_64(&mut self) -> *mut __Reply__vm_map_64_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Reply_vm_purgable_control(&mut self) -> *mut __Reply__vm_purgable_control_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } } impl ::std::clone::Clone for Union___ReplyUnion__vm_map_subsystem { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Union___ReplyUnion__vm_map_subsystem { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed314 { pub Head: mach_msg_header_t, } impl ::std::clone::Clone for Struct_Unnamed314 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed314 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __Request__mach_port_names_t = Struct_Unnamed314; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed315 { pub Head: mach_msg_header_t, pub NDR: NDR_record_t, pub name: mach_port_name_t, } impl ::std::clone::Clone for Struct_Unnamed315 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed315 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __Request__mach_port_type_t = Struct_Unnamed315; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed316 { pub Head: mach_msg_header_t, pub NDR: NDR_record_t, pub old_name: mach_port_name_t, pub new_name: mach_port_name_t, } impl ::std::clone::Clone for Struct_Unnamed316 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed316 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __Request__mach_port_rename_t = Struct_Unnamed316; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed317 { pub Head: mach_msg_header_t, pub NDR: NDR_record_t, pub right: mach_port_right_t, pub name: mach_port_name_t, } impl ::std::clone::Clone for Struct_Unnamed317 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed317 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __Request__mach_port_allocate_name_t = Struct_Unnamed317; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed318 { pub Head: mach_msg_header_t, pub NDR: NDR_record_t, pub right: mach_port_right_t, } impl ::std::clone::Clone for Struct_Unnamed318 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed318 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __Request__mach_port_allocate_t = Struct_Unnamed318; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed319 { pub Head: mach_msg_header_t, pub NDR: NDR_record_t, pub name: mach_port_name_t, } impl ::std::clone::Clone for Struct_Unnamed319 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed319 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __Request__mach_port_destroy_t = Struct_Unnamed319; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed320 { pub Head: mach_msg_header_t, pub NDR: NDR_record_t, pub name: mach_port_name_t, } impl ::std::clone::Clone for Struct_Unnamed320 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed320 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __Request__mach_port_deallocate_t = Struct_Unnamed320; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed321 { pub Head: mach_msg_header_t, pub NDR: NDR_record_t, pub name: mach_port_name_t, pub right: mach_port_right_t, } impl ::std::clone::Clone for Struct_Unnamed321 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed321 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __Request__mach_port_get_refs_t = Struct_Unnamed321; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed322 { pub Head: mach_msg_header_t, pub NDR: NDR_record_t, pub name: mach_port_name_t, pub right: mach_port_right_t, pub delta: mach_port_delta_t, } impl ::std::clone::Clone for Struct_Unnamed322 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed322 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __Request__mach_port_mod_refs_t = Struct_Unnamed322; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed323 { pub Head: mach_msg_header_t, pub NDR: NDR_record_t, pub name: mach_port_name_t, pub mscount: mach_port_mscount_t, } impl ::std::clone::Clone for Struct_Unnamed323 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed323 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __Request__mach_port_set_mscount_t = Struct_Unnamed323; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed324 { pub Head: mach_msg_header_t, pub NDR: NDR_record_t, pub name: mach_port_name_t, } impl ::std::clone::Clone for Struct_Unnamed324 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed324 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __Request__mach_port_get_set_status_t = Struct_Unnamed324; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed325 { pub Head: mach_msg_header_t, pub NDR: NDR_record_t, pub member: mach_port_name_t, pub after: mach_port_name_t, } impl ::std::clone::Clone for Struct_Unnamed325 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed325 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __Request__mach_port_move_member_t = Struct_Unnamed325; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed326 { pub Head: mach_msg_header_t, pub msgh_body: mach_msg_body_t, pub notify: mach_msg_port_descriptor_t, pub NDR: NDR_record_t, pub name: mach_port_name_t, pub msgid: mach_msg_id_t, pub sync: mach_port_mscount_t, } impl ::std::clone::Clone for Struct_Unnamed326 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed326 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __Request__mach_port_request_notification_t = Struct_Unnamed326; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed327 { pub Head: mach_msg_header_t, pub msgh_body: mach_msg_body_t, pub poly: mach_msg_port_descriptor_t, pub NDR: NDR_record_t, pub name: mach_port_name_t, } impl ::std::clone::Clone for Struct_Unnamed327 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed327 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __Request__mach_port_insert_right_t = Struct_Unnamed327; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed328 { pub Head: mach_msg_header_t, pub NDR: NDR_record_t, pub name: mach_port_name_t, pub msgt_name: mach_msg_type_name_t, } impl ::std::clone::Clone for Struct_Unnamed328 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed328 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __Request__mach_port_extract_right_t = Struct_Unnamed328; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed329 { pub Head: mach_msg_header_t, pub NDR: NDR_record_t, pub name: mach_port_name_t, pub seqno: mach_port_seqno_t, } impl ::std::clone::Clone for Struct_Unnamed329 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed329 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __Request__mach_port_set_seqno_t = Struct_Unnamed329; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed330 { pub Head: mach_msg_header_t, pub NDR: NDR_record_t, pub name: mach_port_name_t, pub flavor: mach_port_flavor_t, pub port_info_outCnt: mach_msg_type_number_t, } impl ::std::clone::Clone for Struct_Unnamed330 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed330 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __Request__mach_port_get_attributes_t = Struct_Unnamed330; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed331 { pub Head: mach_msg_header_t, pub NDR: NDR_record_t, pub name: mach_port_name_t, pub flavor: mach_port_flavor_t, pub port_infoCnt: mach_msg_type_number_t, pub port_info: [integer_t; 10usize], } impl ::std::clone::Clone for Struct_Unnamed331 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed331 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __Request__mach_port_set_attributes_t = Struct_Unnamed331; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed332 { pub Head: mach_msg_header_t, pub NDR: NDR_record_t, pub right: mach_port_right_t, pub qos: mach_port_qos_t, } impl ::std::clone::Clone for Struct_Unnamed332 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed332 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __Request__mach_port_allocate_qos_t = Struct_Unnamed332; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed333 { pub Head: mach_msg_header_t, pub msgh_body: mach_msg_body_t, pub proto: mach_msg_port_descriptor_t, pub NDR: NDR_record_t, pub right: mach_port_right_t, pub qos: mach_port_qos_t, pub name: mach_port_name_t, } impl ::std::clone::Clone for Struct_Unnamed333 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed333 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __Request__mach_port_allocate_full_t = Struct_Unnamed333; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed334 { pub Head: mach_msg_header_t, pub NDR: NDR_record_t, pub table_entries: ::libc::c_int, } impl ::std::clone::Clone for Struct_Unnamed334 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed334 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __Request__task_set_port_space_t = Struct_Unnamed334; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed335 { pub Head: mach_msg_header_t, pub NDR: NDR_record_t, pub name: mach_port_name_t, } impl ::std::clone::Clone for Struct_Unnamed335 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed335 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __Request__mach_port_get_srights_t = Struct_Unnamed335; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed336 { pub Head: mach_msg_header_t, } impl ::std::clone::Clone for Struct_Unnamed336 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed336 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __Request__mach_port_space_info_t = Struct_Unnamed336; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed337 { pub Head: mach_msg_header_t, pub NDR: NDR_record_t, pub name: mach_port_name_t, } impl ::std::clone::Clone for Struct_Unnamed337 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed337 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __Request__mach_port_dnrequest_info_t = Struct_Unnamed337; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed338 { pub Head: mach_msg_header_t, pub NDR: NDR_record_t, pub name: mach_port_name_t, } impl ::std::clone::Clone for Struct_Unnamed338 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed338 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __Request__mach_port_kernel_object_t = Struct_Unnamed338; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed339 { pub Head: mach_msg_header_t, pub NDR: NDR_record_t, pub name: mach_port_name_t, pub pset: mach_port_name_t, } impl ::std::clone::Clone for Struct_Unnamed339 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed339 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __Request__mach_port_insert_member_t = Struct_Unnamed339; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed340 { pub Head: mach_msg_header_t, pub NDR: NDR_record_t, pub name: mach_port_name_t, pub pset: mach_port_name_t, } impl ::std::clone::Clone for Struct_Unnamed340 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed340 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __Request__mach_port_extract_member_t = Struct_Unnamed340; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed341 { pub Head: mach_msg_header_t, pub NDR: NDR_record_t, pub name: mach_port_name_t, } impl ::std::clone::Clone for Struct_Unnamed341 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed341 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __Request__mach_port_get_context_t = Struct_Unnamed341; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed342 { pub Head: mach_msg_header_t, pub NDR: NDR_record_t, pub name: mach_port_name_t, pub context: mach_port_context_t, } impl ::std::clone::Clone for Struct_Unnamed342 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed342 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __Request__mach_port_set_context_t = Struct_Unnamed342; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed343 { pub Head: mach_msg_header_t, pub NDR: NDR_record_t, pub name: mach_port_name_t, } impl ::std::clone::Clone for Struct_Unnamed343 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed343 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __Request__mach_port_kobject_t = Struct_Unnamed343; #[repr(C)] #[derive(Copy)] pub struct Union___RequestUnion__mach_port_subsystem { pub _bindgen_data_: [u32; 21usize], } impl Union___RequestUnion__mach_port_subsystem { pub unsafe fn Request_mach_port_names(&mut self) -> *mut __Request__mach_port_names_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Request_mach_port_type(&mut self) -> *mut __Request__mach_port_type_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Request_mach_port_rename(&mut self) -> *mut __Request__mach_port_rename_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Request_mach_port_allocate_name( &mut self, ) -> *mut __Request__mach_port_allocate_name_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Request_mach_port_allocate(&mut self) -> *mut __Request__mach_port_allocate_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Request_mach_port_destroy(&mut self) -> *mut __Request__mach_port_destroy_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Request_mach_port_deallocate( &mut self, ) -> *mut __Request__mach_port_deallocate_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Request_mach_port_get_refs(&mut self) -> *mut __Request__mach_port_get_refs_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Request_mach_port_mod_refs(&mut self) -> *mut __Request__mach_port_mod_refs_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Request_mach_port_set_mscount( &mut self, ) -> *mut __Request__mach_port_set_mscount_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Request_mach_port_get_set_status( &mut self, ) -> *mut __Request__mach_port_get_set_status_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Request_mach_port_move_member( &mut self, ) -> *mut __Request__mach_port_move_member_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Request_mach_port_request_notification( &mut self, ) -> *mut __Request__mach_port_request_notification_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Request_mach_port_insert_right( &mut self, ) -> *mut __Request__mach_port_insert_right_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Request_mach_port_extract_right( &mut self, ) -> *mut __Request__mach_port_extract_right_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Request_mach_port_set_seqno(&mut self) -> *mut __Request__mach_port_set_seqno_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Request_mach_port_get_attributes( &mut self, ) -> *mut __Request__mach_port_get_attributes_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Request_mach_port_set_attributes( &mut self, ) -> *mut __Request__mach_port_set_attributes_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Request_mach_port_allocate_qos( &mut self, ) -> *mut __Request__mach_port_allocate_qos_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Request_mach_port_allocate_full( &mut self, ) -> *mut __Request__mach_port_allocate_full_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Request_task_set_port_space(&mut self) -> *mut __Request__task_set_port_space_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Request_mach_port_get_srights( &mut self, ) -> *mut __Request__mach_port_get_srights_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Request_mach_port_space_info( &mut self, ) -> *mut __Request__mach_port_space_info_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Request_mach_port_dnrequest_info( &mut self, ) -> *mut __Request__mach_port_dnrequest_info_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Request_mach_port_kernel_object( &mut self, ) -> *mut __Request__mach_port_kernel_object_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Request_mach_port_insert_member( &mut self, ) -> *mut __Request__mach_port_insert_member_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Request_mach_port_extract_member( &mut self, ) -> *mut __Request__mach_port_extract_member_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Request_mach_port_get_context( &mut self, ) -> *mut __Request__mach_port_get_context_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Request_mach_port_set_context( &mut self, ) -> *mut __Request__mach_port_set_context_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Request_mach_port_kobject(&mut self) -> *mut __Request__mach_port_kobject_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } } impl ::std::clone::Clone for Union___RequestUnion__mach_port_subsystem { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Union___RequestUnion__mach_port_subsystem { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed344 { pub Head: mach_msg_header_t, pub msgh_body: mach_msg_body_t, pub names: mach_msg_ool_descriptor_t, pub types: mach_msg_ool_descriptor_t, pub NDR: NDR_record_t, pub namesCnt: mach_msg_type_number_t, pub typesCnt: mach_msg_type_number_t, } impl ::std::clone::Clone for Struct_Unnamed344 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed344 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __Reply__mach_port_names_t = Struct_Unnamed344; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed345 { pub Head: mach_msg_header_t, pub NDR: NDR_record_t, pub RetCode: kern_return_t, pub ptype: mach_port_type_t, } impl ::std::clone::Clone for Struct_Unnamed345 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed345 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __Reply__mach_port_type_t = Struct_Unnamed345; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed346 { pub Head: mach_msg_header_t, pub NDR: NDR_record_t, pub RetCode: kern_return_t, } impl ::std::clone::Clone for Struct_Unnamed346 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed346 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __Reply__mach_port_rename_t = Struct_Unnamed346; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed347 { pub Head: mach_msg_header_t, pub NDR: NDR_record_t, pub RetCode: kern_return_t, } impl ::std::clone::Clone for Struct_Unnamed347 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed347 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __Reply__mach_port_allocate_name_t = Struct_Unnamed347; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed348 { pub Head: mach_msg_header_t, pub NDR: NDR_record_t, pub RetCode: kern_return_t, pub name: mach_port_name_t, } impl ::std::clone::Clone for Struct_Unnamed348 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed348 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __Reply__mach_port_allocate_t = Struct_Unnamed348; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed349 { pub Head: mach_msg_header_t, pub NDR: NDR_record_t, pub RetCode: kern_return_t, } impl ::std::clone::Clone for Struct_Unnamed349 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed349 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __Reply__mach_port_destroy_t = Struct_Unnamed349; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed350 { pub Head: mach_msg_header_t, pub NDR: NDR_record_t, pub RetCode: kern_return_t, } impl ::std::clone::Clone for Struct_Unnamed350 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed350 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __Reply__mach_port_deallocate_t = Struct_Unnamed350; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed351 { pub Head: mach_msg_header_t, pub NDR: NDR_record_t, pub RetCode: kern_return_t, pub refs: mach_port_urefs_t, } impl ::std::clone::Clone for Struct_Unnamed351 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed351 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __Reply__mach_port_get_refs_t = Struct_Unnamed351; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed352 { pub Head: mach_msg_header_t, pub NDR: NDR_record_t, pub RetCode: kern_return_t, } impl ::std::clone::Clone for Struct_Unnamed352 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed352 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __Reply__mach_port_mod_refs_t = Struct_Unnamed352; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed353 { pub Head: mach_msg_header_t, pub NDR: NDR_record_t, pub RetCode: kern_return_t, } impl ::std::clone::Clone for Struct_Unnamed353 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed353 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __Reply__mach_port_set_mscount_t = Struct_Unnamed353; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed354 { pub Head: mach_msg_header_t, pub msgh_body: mach_msg_body_t, pub members: mach_msg_ool_descriptor_t, pub NDR: NDR_record_t, pub membersCnt: mach_msg_type_number_t, } impl ::std::clone::Clone for Struct_Unnamed354 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed354 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __Reply__mach_port_get_set_status_t = Struct_Unnamed354; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed355 { pub Head: mach_msg_header_t, pub NDR: NDR_record_t, pub RetCode: kern_return_t, } impl ::std::clone::Clone for Struct_Unnamed355 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed355 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __Reply__mach_port_move_member_t = Struct_Unnamed355; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed356 { pub Head: mach_msg_header_t, pub msgh_body: mach_msg_body_t, pub previous: mach_msg_port_descriptor_t, } impl ::std::clone::Clone for Struct_Unnamed356 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed356 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __Reply__mach_port_request_notification_t = Struct_Unnamed356; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed357 { pub Head: mach_msg_header_t, pub NDR: NDR_record_t, pub RetCode: kern_return_t, } impl ::std::clone::Clone for Struct_Unnamed357 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed357 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __Reply__mach_port_insert_right_t = Struct_Unnamed357; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed358 { pub Head: mach_msg_header_t, pub msgh_body: mach_msg_body_t, pub poly: mach_msg_port_descriptor_t, } impl ::std::clone::Clone for Struct_Unnamed358 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed358 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __Reply__mach_port_extract_right_t = Struct_Unnamed358; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed359 { pub Head: mach_msg_header_t, pub NDR: NDR_record_t, pub RetCode: kern_return_t, } impl ::std::clone::Clone for Struct_Unnamed359 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed359 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __Reply__mach_port_set_seqno_t = Struct_Unnamed359; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed360 { pub Head: mach_msg_header_t, pub NDR: NDR_record_t, pub RetCode: kern_return_t, pub port_info_outCnt: mach_msg_type_number_t, pub port_info_out: [integer_t; 10usize], } impl ::std::clone::Clone for Struct_Unnamed360 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed360 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __Reply__mach_port_get_attributes_t = Struct_Unnamed360; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed361 { pub Head: mach_msg_header_t, pub NDR: NDR_record_t, pub RetCode: kern_return_t, } impl ::std::clone::Clone for Struct_Unnamed361 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed361 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __Reply__mach_port_set_attributes_t = Struct_Unnamed361; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed362 { pub Head: mach_msg_header_t, pub NDR: NDR_record_t, pub RetCode: kern_return_t, pub qos: mach_port_qos_t, pub name: mach_port_name_t, } impl ::std::clone::Clone for Struct_Unnamed362 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed362 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __Reply__mach_port_allocate_qos_t = Struct_Unnamed362; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed363 { pub Head: mach_msg_header_t, pub NDR: NDR_record_t, pub RetCode: kern_return_t, pub qos: mach_port_qos_t, pub name: mach_port_name_t, } impl ::std::clone::Clone for Struct_Unnamed363 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed363 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __Reply__mach_port_allocate_full_t = Struct_Unnamed363; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed364 { pub Head: mach_msg_header_t, pub NDR: NDR_record_t, pub RetCode: kern_return_t, } impl ::std::clone::Clone for Struct_Unnamed364 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed364 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __Reply__task_set_port_space_t = Struct_Unnamed364; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed365 { pub Head: mach_msg_header_t, pub NDR: NDR_record_t, pub RetCode: kern_return_t, pub srights: mach_port_rights_t, } impl ::std::clone::Clone for Struct_Unnamed365 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed365 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __Reply__mach_port_get_srights_t = Struct_Unnamed365; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed367 { pub Head: mach_msg_header_t, pub NDR: NDR_record_t, pub RetCode: kern_return_t, pub dnr_total: ::libc::c_uint, pub dnr_used: ::libc::c_uint, } impl ::std::clone::Clone for Struct_Unnamed367 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed367 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __Reply__mach_port_dnrequest_info_t = Struct_Unnamed367; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed368 { pub Head: mach_msg_header_t, pub NDR: NDR_record_t, pub RetCode: kern_return_t, pub object_type: ::libc::c_uint, pub object_addr: ::libc::c_uint, } impl ::std::clone::Clone for Struct_Unnamed368 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed368 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __Reply__mach_port_kernel_object_t = Struct_Unnamed368; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed369 { pub Head: mach_msg_header_t, pub NDR: NDR_record_t, pub RetCode: kern_return_t, } impl ::std::clone::Clone for Struct_Unnamed369 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed369 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __Reply__mach_port_insert_member_t = Struct_Unnamed369; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed370 { pub Head: mach_msg_header_t, pub NDR: NDR_record_t, pub RetCode: kern_return_t, } impl ::std::clone::Clone for Struct_Unnamed370 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed370 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __Reply__mach_port_extract_member_t = Struct_Unnamed370; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed371 { pub Head: mach_msg_header_t, pub NDR: NDR_record_t, pub RetCode: kern_return_t, pub context: mach_port_context_t, } impl ::std::clone::Clone for Struct_Unnamed371 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed371 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __Reply__mach_port_get_context_t = Struct_Unnamed371; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed372 { pub Head: mach_msg_header_t, pub NDR: NDR_record_t, pub RetCode: kern_return_t, } impl ::std::clone::Clone for Struct_Unnamed372 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed372 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __Reply__mach_port_set_context_t = Struct_Unnamed372; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed373 { pub Head: mach_msg_header_t, pub NDR: NDR_record_t, pub RetCode: kern_return_t, pub object_type: natural_t, pub object_addr: mach_vm_address_t, } impl ::std::clone::Clone for Struct_Unnamed373 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed373 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __Reply__mach_port_kobject_t = Struct_Unnamed373; #[repr(C)] #[derive(Copy)] pub struct Union___ReplyUnion__mach_port_subsystem { pub _bindgen_data_: [u32; 25usize], } impl Union___ReplyUnion__mach_port_subsystem { pub unsafe fn Reply_mach_port_names(&mut self) -> *mut __Reply__mach_port_names_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Reply_mach_port_type(&mut self) -> *mut __Reply__mach_port_type_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Reply_mach_port_rename(&mut self) -> *mut __Reply__mach_port_rename_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Reply_mach_port_allocate_name( &mut self, ) -> *mut __Reply__mach_port_allocate_name_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Reply_mach_port_allocate(&mut self) -> *mut __Reply__mach_port_allocate_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Reply_mach_port_destroy(&mut self) -> *mut __Reply__mach_port_destroy_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Reply_mach_port_deallocate(&mut self) -> *mut __Reply__mach_port_deallocate_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Reply_mach_port_get_refs(&mut self) -> *mut __Reply__mach_port_get_refs_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Reply_mach_port_mod_refs(&mut self) -> *mut __Reply__mach_port_mod_refs_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Reply_mach_port_set_mscount(&mut self) -> *mut __Reply__mach_port_set_mscount_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Reply_mach_port_get_set_status( &mut self, ) -> *mut __Reply__mach_port_get_set_status_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Reply_mach_port_move_member(&mut self) -> *mut __Reply__mach_port_move_member_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Reply_mach_port_request_notification( &mut self, ) -> *mut __Reply__mach_port_request_notification_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Reply_mach_port_insert_right( &mut self, ) -> *mut __Reply__mach_port_insert_right_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Reply_mach_port_extract_right( &mut self, ) -> *mut __Reply__mach_port_extract_right_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Reply_mach_port_set_seqno(&mut self) -> *mut __Reply__mach_port_set_seqno_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Reply_mach_port_get_attributes( &mut self, ) -> *mut __Reply__mach_port_get_attributes_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Reply_mach_port_set_attributes( &mut self, ) -> *mut __Reply__mach_port_set_attributes_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Reply_mach_port_allocate_qos( &mut self, ) -> *mut __Reply__mach_port_allocate_qos_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Reply_mach_port_allocate_full( &mut self, ) -> *mut __Reply__mach_port_allocate_full_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Reply_task_set_port_space(&mut self) -> *mut __Reply__task_set_port_space_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Reply_mach_port_get_srights(&mut self) -> *mut __Reply__mach_port_get_srights_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Reply_mach_port_dnrequest_info( &mut self, ) -> *mut __Reply__mach_port_dnrequest_info_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Reply_mach_port_kernel_object( &mut self, ) -> *mut __Reply__mach_port_kernel_object_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Reply_mach_port_insert_member( &mut self, ) -> *mut __Reply__mach_port_insert_member_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Reply_mach_port_extract_member( &mut self, ) -> *mut __Reply__mach_port_extract_member_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Reply_mach_port_get_context(&mut self) -> *mut __Reply__mach_port_get_context_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Reply_mach_port_set_context(&mut self) -> *mut __Reply__mach_port_set_context_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Reply_mach_port_kobject(&mut self) -> *mut __Reply__mach_port_kobject_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } } impl ::std::clone::Clone for Union___ReplyUnion__mach_port_subsystem { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Union___ReplyUnion__mach_port_subsystem { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed374 { pub Head: mach_msg_header_t, pub NDR: NDR_record_t, pub flavor: host_flavor_t, pub host_info_outCnt: mach_msg_type_number_t, } impl ::std::clone::Clone for Struct_Unnamed374 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed374 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __Request__host_info_t = Struct_Unnamed374; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed375 { pub Head: mach_msg_header_t, } impl ::std::clone::Clone for Struct_Unnamed375 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed375 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __Request__host_kernel_version_t = Struct_Unnamed375; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed376 { pub Head: mach_msg_header_t, } impl ::std::clone::Clone for Struct_Unnamed376 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed376 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __Request___host_page_size_t = Struct_Unnamed376; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed377 { pub Head: mach_msg_header_t, pub msgh_body: mach_msg_body_t, pub pager: mach_msg_port_descriptor_t, pub NDR: NDR_record_t, pub internal: boolean_t, pub size: vm_size_t, pub permission: vm_prot_t, } impl ::std::clone::Clone for Struct_Unnamed377 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed377 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __Request__mach_memory_object_memory_entry_t = Struct_Unnamed377; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed378 { pub Head: mach_msg_header_t, pub NDR: NDR_record_t, pub flavor: processor_flavor_t, } impl ::std::clone::Clone for Struct_Unnamed378 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed378 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __Request__host_processor_info_t = Struct_Unnamed378; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed379 { pub Head: mach_msg_header_t, } impl ::std::clone::Clone for Struct_Unnamed379 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed379 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __Request__host_get_io_master_t = Struct_Unnamed379; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed380 { pub Head: mach_msg_header_t, pub NDR: NDR_record_t, pub clock_id: clock_id_t, } impl ::std::clone::Clone for Struct_Unnamed380 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed380 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __Request__host_get_clock_service_t = Struct_Unnamed380; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed381 { pub Head: mach_msg_header_t, } impl ::std::clone::Clone for Struct_Unnamed381 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed381 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __Request__kmod_get_info_t = Struct_Unnamed381; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed382 { pub Head: mach_msg_header_t, } impl ::std::clone::Clone for Struct_Unnamed382 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed382 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __Request__host_zone_info_t = Struct_Unnamed382; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed383 { pub Head: mach_msg_header_t, } impl ::std::clone::Clone for Struct_Unnamed383 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed383 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __Request__host_virtual_physical_table_info_t = Struct_Unnamed383; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed384 { pub Head: mach_msg_header_t, } impl ::std::clone::Clone for Struct_Unnamed384 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed384 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __Request__processor_set_default_t = Struct_Unnamed384; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed385 { pub Head: mach_msg_header_t, } impl ::std::clone::Clone for Struct_Unnamed385 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed385 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __Request__processor_set_create_t = Struct_Unnamed385; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed386 { pub Head: mach_msg_header_t, pub msgh_body: mach_msg_body_t, pub pager: mach_msg_port_descriptor_t, pub NDR: NDR_record_t, pub internal: boolean_t, pub size: memory_object_size_t, pub permission: vm_prot_t, } impl ::std::clone::Clone for Struct_Unnamed386 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed386 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __Request__mach_memory_object_memory_entry_64_t = Struct_Unnamed386; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed387 { pub Head: mach_msg_header_t, pub NDR: NDR_record_t, pub flavor: host_flavor_t, pub host_info_outCnt: mach_msg_type_number_t, } impl ::std::clone::Clone for Struct_Unnamed387 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed387 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __Request__host_statistics_t = Struct_Unnamed387; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed388 { pub Head: mach_msg_header_t, pub msgh_body: mach_msg_body_t, pub notify_port: mach_msg_port_descriptor_t, pub NDR: NDR_record_t, pub notify_type: host_flavor_t, } impl ::std::clone::Clone for Struct_Unnamed388 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed388 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __Request__host_request_notification_t = Struct_Unnamed388; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed389 { pub Head: mach_msg_header_t, } impl ::std::clone::Clone for Struct_Unnamed389 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed389 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __Request__host_lockgroup_info_t = Struct_Unnamed389; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed390 { pub Head: mach_msg_header_t, pub NDR: NDR_record_t, pub flavor: host_flavor_t, pub host_info64_outCnt: mach_msg_type_number_t, } impl ::std::clone::Clone for Struct_Unnamed390 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed390 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __Request__host_statistics64_t = Struct_Unnamed390; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed391 { pub Head: mach_msg_header_t, } impl ::std::clone::Clone for Struct_Unnamed391 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed391 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __Request__mach_zone_info_t = Struct_Unnamed391; #[repr(C)] #[derive(Copy)] pub struct Union___RequestUnion__mach_host_subsystem { pub _bindgen_data_: [u32; 16usize], } impl Union___RequestUnion__mach_host_subsystem { pub unsafe fn Request_host_info(&mut self) -> *mut __Request__host_info_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Request_host_kernel_version(&mut self) -> *mut __Request__host_kernel_version_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Request__host_page_size(&mut self) -> *mut __Request___host_page_size_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Request_mach_memory_object_memory_entry( &mut self, ) -> *mut __Request__mach_memory_object_memory_entry_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Request_host_processor_info(&mut self) -> *mut __Request__host_processor_info_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Request_host_get_io_master(&mut self) -> *mut __Request__host_get_io_master_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Request_host_get_clock_service( &mut self, ) -> *mut __Request__host_get_clock_service_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Request_kmod_get_info(&mut self) -> *mut __Request__kmod_get_info_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Request_host_zone_info(&mut self) -> *mut __Request__host_zone_info_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Request_host_virtual_physical_table_info( &mut self, ) -> *mut __Request__host_virtual_physical_table_info_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Request_processor_set_default( &mut self, ) -> *mut __Request__processor_set_default_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Request_processor_set_create( &mut self, ) -> *mut __Request__processor_set_create_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Request_mach_memory_object_memory_entry_64( &mut self, ) -> *mut __Request__mach_memory_object_memory_entry_64_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Request_host_statistics(&mut self) -> *mut __Request__host_statistics_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Request_host_request_notification( &mut self, ) -> *mut __Request__host_request_notification_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Request_host_lockgroup_info(&mut self) -> *mut __Request__host_lockgroup_info_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Request_host_statistics64(&mut self) -> *mut __Request__host_statistics64_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Request_mach_zone_info(&mut self) -> *mut __Request__mach_zone_info_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } } impl ::std::clone::Clone for Union___RequestUnion__mach_host_subsystem { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Union___RequestUnion__mach_host_subsystem { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed392 { pub Head: mach_msg_header_t, pub NDR: NDR_record_t, pub RetCode: kern_return_t, pub host_info_outCnt: mach_msg_type_number_t, pub host_info_out: [integer_t; 18usize], } impl ::std::clone::Clone for Struct_Unnamed392 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed392 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __Reply__host_info_t = Struct_Unnamed392; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed393 { pub Head: mach_msg_header_t, pub NDR: NDR_record_t, pub RetCode: kern_return_t, pub kernel_versionOffset: mach_msg_type_number_t, pub kernel_versionCnt: mach_msg_type_number_t, pub kernel_version: [::libc::c_char; 512usize], } impl ::std::clone::Clone for Struct_Unnamed393 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed393 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __Reply__host_kernel_version_t = Struct_Unnamed393; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed394 { pub Head: mach_msg_header_t, pub NDR: NDR_record_t, pub RetCode: kern_return_t, pub out_page_size: vm_size_t, } impl ::std::clone::Clone for Struct_Unnamed394 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed394 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __Reply___host_page_size_t = Struct_Unnamed394; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed395 { pub Head: mach_msg_header_t, pub msgh_body: mach_msg_body_t, pub entry_handle: mach_msg_port_descriptor_t, } impl ::std::clone::Clone for Struct_Unnamed395 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed395 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __Reply__mach_memory_object_memory_entry_t = Struct_Unnamed395; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed396 { pub Head: mach_msg_header_t, pub msgh_body: mach_msg_body_t, pub out_processor_info: mach_msg_ool_descriptor_t, pub NDR: NDR_record_t, pub out_processor_count: natural_t, pub out_processor_infoCnt: mach_msg_type_number_t, } impl ::std::clone::Clone for Struct_Unnamed396 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed396 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __Reply__host_processor_info_t = Struct_Unnamed396; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed397 { pub Head: mach_msg_header_t, pub msgh_body: mach_msg_body_t, pub io_master: mach_msg_port_descriptor_t, } impl ::std::clone::Clone for Struct_Unnamed397 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed397 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __Reply__host_get_io_master_t = Struct_Unnamed397; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed398 { pub Head: mach_msg_header_t, pub msgh_body: mach_msg_body_t, pub clock_serv: mach_msg_port_descriptor_t, } impl ::std::clone::Clone for Struct_Unnamed398 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed398 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __Reply__host_get_clock_service_t = Struct_Unnamed398; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed399 { pub Head: mach_msg_header_t, pub msgh_body: mach_msg_body_t, pub modules: mach_msg_ool_descriptor_t, pub NDR: NDR_record_t, pub modulesCnt: mach_msg_type_number_t, } impl ::std::clone::Clone for Struct_Unnamed399 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed399 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __Reply__kmod_get_info_t = Struct_Unnamed399; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed400 { pub Head: mach_msg_header_t, pub msgh_body: mach_msg_body_t, pub names: mach_msg_ool_descriptor_t, pub info: mach_msg_ool_descriptor_t, pub NDR: NDR_record_t, pub namesCnt: mach_msg_type_number_t, pub infoCnt: mach_msg_type_number_t, } impl ::std::clone::Clone for Struct_Unnamed400 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed400 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __Reply__host_zone_info_t = Struct_Unnamed400; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed401 { pub Head: mach_msg_header_t, pub msgh_body: mach_msg_body_t, pub info: mach_msg_ool_descriptor_t, pub NDR: NDR_record_t, pub infoCnt: mach_msg_type_number_t, } impl ::std::clone::Clone for Struct_Unnamed401 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed401 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __Reply__host_virtual_physical_table_info_t = Struct_Unnamed401; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed402 { pub Head: mach_msg_header_t, pub msgh_body: mach_msg_body_t, pub default_set: mach_msg_port_descriptor_t, } impl ::std::clone::Clone for Struct_Unnamed402 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed402 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __Reply__processor_set_default_t = Struct_Unnamed402; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed403 { pub Head: mach_msg_header_t, pub msgh_body: mach_msg_body_t, pub new_set: mach_msg_port_descriptor_t, pub new_name: mach_msg_port_descriptor_t, } impl ::std::clone::Clone for Struct_Unnamed403 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed403 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __Reply__processor_set_create_t = Struct_Unnamed403; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed404 { pub Head: mach_msg_header_t, pub msgh_body: mach_msg_body_t, pub entry_handle: mach_msg_port_descriptor_t, } impl ::std::clone::Clone for Struct_Unnamed404 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed404 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __Reply__mach_memory_object_memory_entry_64_t = Struct_Unnamed404; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed405 { pub Head: mach_msg_header_t, pub NDR: NDR_record_t, pub RetCode: kern_return_t, pub host_info_outCnt: mach_msg_type_number_t, pub host_info_out: [integer_t; 18usize], } impl ::std::clone::Clone for Struct_Unnamed405 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed405 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __Reply__host_statistics_t = Struct_Unnamed405; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed406 { pub Head: mach_msg_header_t, pub NDR: NDR_record_t, pub RetCode: kern_return_t, } impl ::std::clone::Clone for Struct_Unnamed406 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed406 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __Reply__host_request_notification_t = Struct_Unnamed406; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed407 { pub Head: mach_msg_header_t, pub msgh_body: mach_msg_body_t, pub lockgroup_info: mach_msg_ool_descriptor_t, pub NDR: NDR_record_t, pub lockgroup_infoCnt: mach_msg_type_number_t, } impl ::std::clone::Clone for Struct_Unnamed407 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed407 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __Reply__host_lockgroup_info_t = Struct_Unnamed407; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed408 { pub Head: mach_msg_header_t, pub NDR: NDR_record_t, pub RetCode: kern_return_t, pub host_info64_outCnt: mach_msg_type_number_t, pub host_info64_out: [integer_t; 256usize], } impl ::std::clone::Clone for Struct_Unnamed408 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed408 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __Reply__host_statistics64_t = Struct_Unnamed408; #[repr(C)] #[derive(Copy)] pub struct Struct_Unnamed409 { pub Head: mach_msg_header_t, pub msgh_body: mach_msg_body_t, pub names: mach_msg_ool_descriptor_t, pub info: mach_msg_ool_descriptor_t, pub NDR: NDR_record_t, pub namesCnt: mach_msg_type_number_t, pub infoCnt: mach_msg_type_number_t, } impl ::std::clone::Clone for Struct_Unnamed409 { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_Unnamed409 { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type __Reply__mach_zone_info_t = Struct_Unnamed409; #[repr(C)] #[derive(Copy)] pub struct Union___ReplyUnion__mach_host_subsystem { pub _bindgen_data_: [u32; 266usize], } impl Union___ReplyUnion__mach_host_subsystem { pub unsafe fn Reply_host_info(&mut self) -> *mut __Reply__host_info_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Reply_host_kernel_version(&mut self) -> *mut __Reply__host_kernel_version_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Reply__host_page_size(&mut self) -> *mut __Reply___host_page_size_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Reply_mach_memory_object_memory_entry( &mut self, ) -> *mut __Reply__mach_memory_object_memory_entry_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Reply_host_processor_info(&mut self) -> *mut __Reply__host_processor_info_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Reply_host_get_io_master(&mut self) -> *mut __Reply__host_get_io_master_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Reply_host_get_clock_service( &mut self, ) -> *mut __Reply__host_get_clock_service_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Reply_kmod_get_info(&mut self) -> *mut __Reply__kmod_get_info_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Reply_host_zone_info(&mut self) -> *mut __Reply__host_zone_info_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Reply_host_virtual_physical_table_info( &mut self, ) -> *mut __Reply__host_virtual_physical_table_info_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Reply_processor_set_default(&mut self) -> *mut __Reply__processor_set_default_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Reply_processor_set_create(&mut self) -> *mut __Reply__processor_set_create_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Reply_mach_memory_object_memory_entry_64( &mut self, ) -> *mut __Reply__mach_memory_object_memory_entry_64_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Reply_host_statistics(&mut self) -> *mut __Reply__host_statistics_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Reply_host_request_notification( &mut self, ) -> *mut __Reply__host_request_notification_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Reply_host_lockgroup_info(&mut self) -> *mut __Reply__host_lockgroup_info_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Reply_host_statistics64(&mut self) -> *mut __Reply__host_statistics64_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Reply_mach_zone_info(&mut self) -> *mut __Reply__mach_zone_info_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } } impl ::std::clone::Clone for Union___ReplyUnion__mach_host_subsystem { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Union___ReplyUnion__mach_host_subsystem { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type routine_arg_type = ::libc::c_uint; pub type routine_arg_offset = ::libc::c_uint; pub type routine_arg_size = ::libc::c_uint; #[repr(C)] #[derive(Copy)] pub struct Struct_rpc_routine_arg_descriptor { pub _type: routine_arg_type, pub size: routine_arg_size, pub count: routine_arg_size, pub offset: routine_arg_offset, } impl ::std::clone::Clone for Struct_rpc_routine_arg_descriptor { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_rpc_routine_arg_descriptor { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type rpc_routine_arg_descriptor_t = *mut Struct_rpc_routine_arg_descriptor; #[repr(C)] #[derive(Copy)] pub struct Struct_rpc_routine_descriptor { pub impl_routine: mig_impl_routine_t, pub stub_routine: mig_stub_routine_t, pub argc: ::libc::c_uint, pub descr_count: ::libc::c_uint, pub arg_descr: rpc_routine_arg_descriptor_t, pub max_reply_msg: ::libc::c_uint, } impl ::std::clone::Clone for Struct_rpc_routine_descriptor { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_rpc_routine_descriptor { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type rpc_routine_descriptor_t = *mut Struct_rpc_routine_descriptor; #[repr(C)] #[derive(Copy)] pub struct Struct_rpc_signature { pub rd: Struct_rpc_routine_descriptor, pub rad: [Struct_rpc_routine_arg_descriptor; 1usize], } impl ::std::clone::Clone for Struct_rpc_signature { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_rpc_signature { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } #[repr(C)] #[derive(Copy)] pub struct Struct_rpc_subsystem { pub reserved: *mut ::libc::c_void, pub start: mach_msg_id_t, pub end: mach_msg_id_t, pub maxsize: ::libc::c_uint, pub base_addr: vm_address_t, pub routine: [Struct_rpc_routine_descriptor; 1usize], pub arg_descriptor: [Struct_rpc_routine_arg_descriptor; 1usize], } impl ::std::clone::Clone for Struct_rpc_subsystem { fn clone(&self) -> Self { *self } } impl ::std::default::Default for Struct_rpc_subsystem { fn default() -> Self { unsafe { ::std::mem::zeroed() } } } pub type rpc_subsystem_t = *mut Struct_rpc_subsystem; pub type mach_error_t = kern_return_t; pub type mach_error_fn_t = ::std::option::Option mach_error_t>; extern "C" { pub static mut KERNEL_SECURITY_TOKEN: security_token_t; pub static mut KERNEL_AUDIT_TOKEN: audit_token_t; pub static mut NDR_record: NDR_record_t; pub static mut mach_task_self_: mach_port_t; pub static mut bootstrap_port: mach_port_t; pub static mut vm_page_size: vm_size_t; pub static mut vm_page_mask: vm_size_t; pub static mut vm_page_shift: ::libc::c_int; } extern "C" { pub fn mach_msg_overwrite( msg: *mut mach_msg_header_t, option: mach_msg_option_t, send_size: mach_msg_size_t, rcv_size: mach_msg_size_t, rcv_name: mach_port_name_t, timeout: mach_msg_timeout_t, notify: mach_port_name_t, rcv_msg: *mut mach_msg_header_t, rcv_limit: mach_msg_size_t, ) -> mach_msg_return_t; pub fn mach_msg( msg: *mut mach_msg_header_t, option: mach_msg_option_t, send_size: mach_msg_size_t, rcv_size: mach_msg_size_t, rcv_name: mach_port_name_t, timeout: mach_msg_timeout_t, notify: mach_port_name_t, ) -> mach_msg_return_t; pub fn mig_get_reply_port() -> mach_port_t; pub fn mig_dealloc_reply_port(reply_port: mach_port_t) -> (); pub fn mig_put_reply_port(reply_port: mach_port_t) -> (); pub fn mig_strncpy( dest: *mut ::libc::c_char, src: *const ::libc::c_char, len: ::libc::c_int, ) -> ::libc::c_int; pub fn mig_allocate(arg1: *mut vm_address_t, arg2: vm_size_t) -> (); pub fn mig_deallocate(arg1: vm_address_t, arg2: vm_size_t) -> (); pub fn clock_set_time(clock_ctrl: clock_ctrl_t, new_time: mach_timespec_t) -> kern_return_t; pub fn clock_set_attributes( clock_ctrl: clock_ctrl_t, flavor: clock_flavor_t, clock_attr: clock_attr_t, clock_attrCnt: mach_msg_type_number_t, ) -> kern_return_t; pub fn host_get_boot_info( host_priv: host_priv_t, boot_info: kernel_boot_info_t, ) -> kern_return_t; pub fn host_reboot(host_priv: host_priv_t, options: ::libc::c_int) -> kern_return_t; pub fn host_priv_statistics( host_priv: host_priv_t, flavor: host_flavor_t, host_info_out: host_info_t, host_info_outCnt: *mut mach_msg_type_number_t, ) -> kern_return_t; pub fn host_default_memory_manager( host_priv: host_priv_t, default_manager: *mut memory_object_default_t, cluster_size: memory_object_cluster_size_t, ) -> kern_return_t; pub fn vm_wire( host_priv: host_priv_t, task: vm_map_t, address: vm_address_t, size: vm_size_t, desired_access: vm_prot_t, ) -> kern_return_t; pub fn thread_wire( host_priv: host_priv_t, thread: thread_act_t, wired: boolean_t, ) -> kern_return_t; pub fn vm_allocate_cpm( host_priv: host_priv_t, task: vm_map_t, address: *mut vm_address_t, size: vm_size_t, flags: ::libc::c_int, ) -> kern_return_t; pub fn host_processors( host_priv: host_priv_t, out_processor_list: *mut processor_array_t, out_processor_listCnt: *mut mach_msg_type_number_t, ) -> kern_return_t; pub fn host_get_clock_control( host_priv: host_priv_t, clock_id: clock_id_t, clock_ctrl: *mut clock_ctrl_t, ) -> kern_return_t; pub fn kmod_create( host_priv: host_priv_t, info: vm_address_t, module: *mut kmod_t, ) -> kern_return_t; pub fn kmod_destroy(host_priv: host_priv_t, module: kmod_t) -> kern_return_t; pub fn kmod_control( host_priv: host_priv_t, module: kmod_t, flavor: kmod_control_flavor_t, data: *mut kmod_args_t, dataCnt: *mut mach_msg_type_number_t, ) -> kern_return_t; pub fn host_get_special_port( host_priv: host_priv_t, node: ::libc::c_int, which: ::libc::c_int, port: *mut mach_port_t, ) -> kern_return_t; pub fn host_set_special_port( host_priv: host_priv_t, which: ::libc::c_int, port: mach_port_t, ) -> kern_return_t; pub fn host_set_exception_ports( host_priv: host_priv_t, exception_mask: exception_mask_t, new_port: mach_port_t, behavior: exception_behavior_t, new_flavor: thread_state_flavor_t, ) -> kern_return_t; pub fn host_get_exception_ports( host_priv: host_priv_t, exception_mask: exception_mask_t, masks: exception_mask_array_t, masksCnt: *mut mach_msg_type_number_t, old_handlers: exception_handler_array_t, old_behaviors: exception_behavior_array_t, old_flavors: exception_flavor_array_t, ) -> kern_return_t; pub fn host_swap_exception_ports( host_priv: host_priv_t, exception_mask: exception_mask_t, new_port: mach_port_t, behavior: exception_behavior_t, new_flavor: thread_state_flavor_t, masks: exception_mask_array_t, masksCnt: *mut mach_msg_type_number_t, old_handlerss: exception_handler_array_t, old_behaviors: exception_behavior_array_t, old_flavors: exception_flavor_array_t, ) -> kern_return_t; pub fn mach_vm_wire( host_priv: host_priv_t, task: vm_map_t, address: mach_vm_address_t, size: mach_vm_size_t, desired_access: vm_prot_t, ) -> kern_return_t; pub fn host_processor_sets( host_priv: host_priv_t, processor_sets: *mut processor_set_name_array_t, processor_setsCnt: *mut mach_msg_type_number_t, ) -> kern_return_t; pub fn host_processor_set_priv( host_priv: host_priv_t, set_name: processor_set_name_t, set: *mut processor_set_t, ) -> kern_return_t; pub fn set_dp_control_port(host: host_priv_t, control_port: mach_port_t) -> kern_return_t; pub fn get_dp_control_port(host: host_priv_t, contorl_port: *mut mach_port_t) -> kern_return_t; pub fn host_set_UNDServer(host: host_priv_t, server: UNDServerRef) -> kern_return_t; pub fn host_get_UNDServer(host: host_priv_t, server: *mut UNDServerRef) -> kern_return_t; pub fn kext_request( host_priv: host_priv_t, user_log_flags: uint32_t, request_data: vm_offset_t, request_dataCnt: mach_msg_type_number_t, response_data: *mut vm_offset_t, response_dataCnt: *mut mach_msg_type_number_t, log_data: *mut vm_offset_t, log_dataCnt: *mut mach_msg_type_number_t, op_result: *mut kern_return_t, ) -> kern_return_t; pub fn host_security_create_task_token( host_security: host_security_t, parent_task: task_t, sec_token: security_token_t, audit_token: audit_token_t, host: host_t, ledgers: ledger_array_t, ledgersCnt: mach_msg_type_number_t, inherit_memory: boolean_t, child_task: *mut task_t, ) -> kern_return_t; pub fn host_security_set_task_token( host_security: host_security_t, target_task: task_t, sec_token: security_token_t, audit_token: audit_token_t, host: host_t, ) -> kern_return_t; pub fn lock_acquire(lock_set: lock_set_t, lock_id: ::libc::c_int) -> kern_return_t; pub fn lock_release(lock_set: lock_set_t, lock_id: ::libc::c_int) -> kern_return_t; pub fn lock_try(lock_set: lock_set_t, lock_id: ::libc::c_int) -> kern_return_t; pub fn lock_make_stable(lock_set: lock_set_t, lock_id: ::libc::c_int) -> kern_return_t; pub fn lock_handoff(lock_set: lock_set_t, lock_id: ::libc::c_int) -> kern_return_t; pub fn lock_handoff_accept(lock_set: lock_set_t, lock_id: ::libc::c_int) -> kern_return_t; pub fn processor_start(processor: processor_t) -> kern_return_t; pub fn processor_exit(processor: processor_t) -> kern_return_t; pub fn processor_info( processor: processor_t, flavor: processor_flavor_t, host: *mut host_t, processor_info_out: processor_info_t, processor_info_outCnt: *mut mach_msg_type_number_t, ) -> kern_return_t; pub fn processor_control( processor: processor_t, processor_cmd: processor_info_t, processor_cmdCnt: mach_msg_type_number_t, ) -> kern_return_t; pub fn processor_assign( processor: processor_t, new_set: processor_set_t, wait: boolean_t, ) -> kern_return_t; pub fn processor_get_assignment( processor: processor_t, assigned_set: *mut processor_set_name_t, ) -> kern_return_t; pub fn processor_set_statistics( pset: processor_set_name_t, flavor: processor_set_flavor_t, info_out: processor_set_info_t, info_outCnt: *mut mach_msg_type_number_t, ) -> kern_return_t; pub fn processor_set_destroy(set: processor_set_t) -> kern_return_t; pub fn processor_set_max_priority( processor_set: processor_set_t, max_priority: ::libc::c_int, change_threads: boolean_t, ) -> kern_return_t; pub fn processor_set_policy_enable( processor_set: processor_set_t, policy: ::libc::c_int, ) -> kern_return_t; pub fn processor_set_policy_disable( processor_set: processor_set_t, policy: ::libc::c_int, change_threads: boolean_t, ) -> kern_return_t; pub fn processor_set_tasks( processor_set: processor_set_t, task_list: *mut task_array_t, task_listCnt: *mut mach_msg_type_number_t, ) -> kern_return_t; pub fn processor_set_threads( processor_set: processor_set_t, thread_list: *mut thread_act_array_t, thread_listCnt: *mut mach_msg_type_number_t, ) -> kern_return_t; pub fn processor_set_policy_control( pset: processor_set_t, flavor: processor_set_flavor_t, policy_info: processor_set_info_t, policy_infoCnt: mach_msg_type_number_t, change: boolean_t, ) -> kern_return_t; pub fn processor_set_stack_usage( pset: processor_set_t, ltotal: *mut ::libc::c_uint, space: *mut vm_size_t, resident: *mut vm_size_t, maxusage: *mut vm_size_t, maxstack: *mut vm_offset_t, ) -> kern_return_t; pub fn processor_set_info( set_name: processor_set_name_t, flavor: ::libc::c_int, host: *mut host_t, info_out: processor_set_info_t, info_outCnt: *mut mach_msg_type_number_t, ) -> kern_return_t; pub fn semaphore_signal(semaphore: semaphore_t) -> kern_return_t; pub fn semaphore_signal_all(semaphore: semaphore_t) -> kern_return_t; pub fn semaphore_wait(semaphore: semaphore_t) -> kern_return_t; pub fn semaphore_timedwait(semaphore: semaphore_t, wait_time: mach_timespec_t) -> kern_return_t; pub fn semaphore_timedwait_signal( wait_semaphore: semaphore_t, signal_semaphore: semaphore_t, wait_time: mach_timespec_t, ) -> kern_return_t; pub fn semaphore_wait_signal( wait_semaphore: semaphore_t, signal_semaphore: semaphore_t, ) -> kern_return_t; pub fn semaphore_signal_thread(semaphore: semaphore_t, thread: thread_t) -> kern_return_t; pub fn task_create( target_task: task_t, ledgers: ledger_array_t, ledgersCnt: mach_msg_type_number_t, inherit_memory: boolean_t, child_task: *mut task_t, ) -> kern_return_t; pub fn task_terminate(target_task: task_t) -> kern_return_t; pub fn task_threads( target_task: task_t, act_list: *mut thread_act_array_t, act_listCnt: *mut mach_msg_type_number_t, ) -> kern_return_t; pub fn mach_ports_register( target_task: task_t, init_port_set: mach_port_array_t, init_port_setCnt: mach_msg_type_number_t, ) -> kern_return_t; pub fn mach_ports_lookup( target_task: task_t, init_port_set: *mut mach_port_array_t, init_port_setCnt: *mut mach_msg_type_number_t, ) -> kern_return_t; pub fn task_info( target_task: task_name_t, flavor: task_flavor_t, task_info_out: task_info_t, task_info_outCnt: *mut mach_msg_type_number_t, ) -> kern_return_t; pub fn task_set_info( target_task: task_t, flavor: task_flavor_t, task_info_in: task_info_t, task_info_inCnt: mach_msg_type_number_t, ) -> kern_return_t; pub fn task_suspend(target_task: task_t) -> kern_return_t; pub fn task_resume(target_task: task_t) -> kern_return_t; pub fn task_get_special_port( task: task_t, which_port: ::libc::c_int, special_port: *mut mach_port_t, ) -> kern_return_t; pub fn task_set_special_port( task: task_t, which_port: ::libc::c_int, special_port: mach_port_t, ) -> kern_return_t; pub fn thread_create(parent_task: task_t, child_act: *mut thread_act_t) -> kern_return_t; pub fn thread_create_running( parent_task: task_t, flavor: thread_state_flavor_t, new_state: thread_state_t, new_stateCnt: mach_msg_type_number_t, child_act: *mut thread_act_t, ) -> kern_return_t; pub fn task_set_exception_ports( task: task_t, exception_mask: exception_mask_t, new_port: mach_port_t, behavior: exception_behavior_t, new_flavor: thread_state_flavor_t, ) -> kern_return_t; pub fn task_get_exception_ports( task: task_t, exception_mask: exception_mask_t, masks: exception_mask_array_t, masksCnt: *mut mach_msg_type_number_t, old_handlers: exception_handler_array_t, old_behaviors: exception_behavior_array_t, old_flavors: exception_flavor_array_t, ) -> kern_return_t; pub fn task_swap_exception_ports( task: task_t, exception_mask: exception_mask_t, new_port: mach_port_t, behavior: exception_behavior_t, new_flavor: thread_state_flavor_t, masks: exception_mask_array_t, masksCnt: *mut mach_msg_type_number_t, old_handlerss: exception_handler_array_t, old_behaviors: exception_behavior_array_t, old_flavors: exception_flavor_array_t, ) -> kern_return_t; pub fn lock_set_create( task: task_t, new_lock_set: *mut lock_set_t, n_ulocks: ::libc::c_int, policy: ::libc::c_int, ) -> kern_return_t; pub fn lock_set_destroy(task: task_t, lock_set: lock_set_t) -> kern_return_t; pub fn semaphore_create( task: task_t, semaphore: *mut semaphore_t, policy: ::libc::c_int, value: ::libc::c_int, ) -> kern_return_t; pub fn semaphore_destroy(task: task_t, semaphore: semaphore_t) -> kern_return_t; pub fn task_policy_set( task: task_t, flavor: task_policy_flavor_t, policy_info: task_policy_t, policy_infoCnt: mach_msg_type_number_t, ) -> kern_return_t; pub fn task_policy_get( task: task_t, flavor: task_policy_flavor_t, policy_info: task_policy_t, policy_infoCnt: *mut mach_msg_type_number_t, get_default: *mut boolean_t, ) -> kern_return_t; pub fn task_sample(task: task_t, reply: mach_port_t) -> kern_return_t; pub fn task_policy( task: task_t, policy: policy_t, base: policy_base_t, baseCnt: mach_msg_type_number_t, set_limit: boolean_t, change: boolean_t, ) -> kern_return_t; pub fn task_set_emulation( target_port: task_t, routine_entry_pt: vm_address_t, routine_number: ::libc::c_int, ) -> kern_return_t; pub fn task_get_emulation_vector( task: task_t, vector_start: *mut ::libc::c_int, emulation_vector: *mut emulation_vector_t, emulation_vectorCnt: *mut mach_msg_type_number_t, ) -> kern_return_t; pub fn task_set_emulation_vector( task: task_t, vector_start: ::libc::c_int, emulation_vector: emulation_vector_t, emulation_vectorCnt: mach_msg_type_number_t, ) -> kern_return_t; pub fn task_set_ras_pc( target_task: task_t, basepc: vm_address_t, boundspc: vm_address_t, ) -> kern_return_t; pub fn task_assign( task: task_t, new_set: processor_set_t, assign_threads: boolean_t, ) -> kern_return_t; pub fn task_assign_default(task: task_t, assign_threads: boolean_t) -> kern_return_t; pub fn task_get_assignment( task: task_t, assigned_set: *mut processor_set_name_t, ) -> kern_return_t; pub fn task_set_policy( task: task_t, pset: processor_set_t, policy: policy_t, base: policy_base_t, baseCnt: mach_msg_type_number_t, limit: policy_limit_t, limitCnt: mach_msg_type_number_t, change: boolean_t, ) -> kern_return_t; pub fn task_get_state( task: task_t, flavor: thread_state_flavor_t, old_state: thread_state_t, old_stateCnt: *mut mach_msg_type_number_t, ) -> kern_return_t; pub fn task_set_state( task: task_t, flavor: thread_state_flavor_t, new_state: thread_state_t, new_stateCnt: mach_msg_type_number_t, ) -> kern_return_t; pub fn thread_terminate(target_act: thread_act_t) -> kern_return_t; pub fn act_get_state( target_act: thread_act_t, flavor: ::libc::c_int, old_state: thread_state_t, old_stateCnt: *mut mach_msg_type_number_t, ) -> kern_return_t; pub fn act_set_state( target_act: thread_act_t, flavor: ::libc::c_int, new_state: thread_state_t, new_stateCnt: mach_msg_type_number_t, ) -> kern_return_t; pub fn thread_get_state( target_act: thread_act_t, flavor: thread_state_flavor_t, old_state: thread_state_t, old_stateCnt: *mut mach_msg_type_number_t, ) -> kern_return_t; pub fn thread_set_state( target_act: thread_act_t, flavor: thread_state_flavor_t, new_state: thread_state_t, new_stateCnt: mach_msg_type_number_t, ) -> kern_return_t; pub fn thread_suspend(target_act: thread_act_t) -> kern_return_t; pub fn thread_resume(target_act: thread_act_t) -> kern_return_t; pub fn thread_abort(target_act: thread_act_t) -> kern_return_t; pub fn thread_abort_safely(target_act: thread_act_t) -> kern_return_t; pub fn thread_depress_abort(thread: thread_act_t) -> kern_return_t; pub fn thread_get_special_port( thr_act: thread_act_t, which_port: ::libc::c_int, special_port: *mut mach_port_t, ) -> kern_return_t; pub fn thread_set_special_port( thr_act: thread_act_t, which_port: ::libc::c_int, special_port: mach_port_t, ) -> kern_return_t; pub fn thread_info( target_act: thread_act_t, flavor: thread_flavor_t, thread_info_out: thread_info_t, thread_info_outCnt: *mut mach_msg_type_number_t, ) -> kern_return_t; pub fn thread_set_exception_ports( thread: thread_act_t, exception_mask: exception_mask_t, new_port: mach_port_t, behavior: exception_behavior_t, new_flavor: thread_state_flavor_t, ) -> kern_return_t; pub fn thread_get_exception_ports( thread: thread_act_t, exception_mask: exception_mask_t, masks: exception_mask_array_t, masksCnt: *mut mach_msg_type_number_t, old_handlers: exception_handler_array_t, old_behaviors: exception_behavior_array_t, old_flavors: exception_flavor_array_t, ) -> kern_return_t; pub fn thread_swap_exception_ports( thread: thread_act_t, exception_mask: exception_mask_t, new_port: mach_port_t, behavior: exception_behavior_t, new_flavor: thread_state_flavor_t, masks: exception_mask_array_t, masksCnt: *mut mach_msg_type_number_t, old_handlers: exception_handler_array_t, old_behaviors: exception_behavior_array_t, old_flavors: exception_flavor_array_t, ) -> kern_return_t; pub fn thread_policy( thr_act: thread_act_t, policy: policy_t, base: policy_base_t, baseCnt: mach_msg_type_number_t, set_limit: boolean_t, ) -> kern_return_t; pub fn thread_policy_set( thread: thread_act_t, flavor: thread_policy_flavor_t, policy_info: thread_policy_t, policy_infoCnt: mach_msg_type_number_t, ) -> kern_return_t; pub fn thread_policy_get( thread: thread_act_t, flavor: thread_policy_flavor_t, policy_info: thread_policy_t, policy_infoCnt: *mut mach_msg_type_number_t, get_default: *mut boolean_t, ) -> kern_return_t; pub fn thread_sample(thread: thread_act_t, reply: mach_port_t) -> kern_return_t; pub fn etap_trace_thread(target_act: thread_act_t, trace_status: boolean_t) -> kern_return_t; pub fn thread_assign(thread: thread_act_t, new_set: processor_set_t) -> kern_return_t; pub fn thread_assign_default(thread: thread_act_t) -> kern_return_t; pub fn thread_get_assignment( thread: thread_act_t, assigned_set: *mut processor_set_name_t, ) -> kern_return_t; pub fn thread_set_policy( thr_act: thread_act_t, pset: processor_set_t, policy: policy_t, base: policy_base_t, baseCnt: mach_msg_type_number_t, limit: policy_limit_t, limitCnt: mach_msg_type_number_t, ) -> kern_return_t; pub fn vm_region( target_task: vm_map_t, address: *mut vm_address_t, size: *mut vm_size_t, flavor: vm_region_flavor_t, info: vm_region_info_t, infoCnt: *mut mach_msg_type_number_t, object_name: *mut mach_port_t, ) -> kern_return_t; pub fn vm_allocate( target_task: vm_map_t, address: *mut vm_address_t, size: vm_size_t, flags: ::libc::c_int, ) -> kern_return_t; pub fn vm_deallocate( target_task: vm_map_t, address: vm_address_t, size: vm_size_t, ) -> kern_return_t; pub fn vm_protect( target_task: vm_map_t, address: vm_address_t, size: vm_size_t, set_maximum: boolean_t, new_protection: vm_prot_t, ) -> kern_return_t; pub fn vm_inherit( target_task: vm_map_t, address: vm_address_t, size: vm_size_t, new_inheritance: vm_inherit_t, ) -> kern_return_t; pub fn vm_read( target_task: vm_map_t, address: vm_address_t, size: vm_size_t, data: *mut vm_offset_t, dataCnt: *mut mach_msg_type_number_t, ) -> kern_return_t; pub fn vm_read_list( target_task: vm_map_t, data_list: vm_read_entry_t, count: natural_t, ) -> kern_return_t; pub fn vm_write( target_task: vm_map_t, address: vm_address_t, data: vm_offset_t, dataCnt: mach_msg_type_number_t, ) -> kern_return_t; pub fn vm_copy( target_task: vm_map_t, source_address: vm_address_t, size: vm_size_t, dest_address: vm_address_t, ) -> kern_return_t; pub fn vm_read_overwrite( target_task: vm_map_t, address: vm_address_t, size: vm_size_t, data: vm_address_t, outsize: *mut vm_size_t, ) -> kern_return_t; pub fn vm_msync( target_task: vm_map_t, address: vm_address_t, size: vm_size_t, sync_flags: vm_sync_t, ) -> kern_return_t; pub fn vm_behavior_set( target_task: vm_map_t, address: vm_address_t, size: vm_size_t, new_behavior: vm_behavior_t, ) -> kern_return_t; pub fn vm_map( target_task: vm_map_t, address: *mut vm_address_t, size: vm_size_t, mask: vm_address_t, flags: ::libc::c_int, object: mem_entry_name_port_t, offset: vm_offset_t, copy: boolean_t, cur_protection: vm_prot_t, max_protection: vm_prot_t, inheritance: vm_inherit_t, ) -> kern_return_t; pub fn vm_machine_attribute( target_task: vm_map_t, address: vm_address_t, size: vm_size_t, attribute: vm_machine_attribute_t, value: *mut vm_machine_attribute_val_t, ) -> kern_return_t; pub fn vm_remap( target_task: vm_map_t, target_address: *mut vm_address_t, size: vm_size_t, mask: vm_address_t, flags: ::libc::c_int, src_task: vm_map_t, src_address: vm_address_t, copy: boolean_t, cur_protection: *mut vm_prot_t, max_protection: *mut vm_prot_t, inheritance: vm_inherit_t, ) -> kern_return_t; pub fn task_wire(target_task: vm_map_t, must_wire: boolean_t) -> kern_return_t; pub fn mach_make_memory_entry( target_task: vm_map_t, size: *mut vm_size_t, offset: vm_offset_t, permission: vm_prot_t, object_handle: *mut mem_entry_name_port_t, parent_entry: mem_entry_name_port_t, ) -> kern_return_t; pub fn vm_map_page_query( target_map: vm_map_t, offset: vm_offset_t, disposition: *mut integer_t, ref_count: *mut integer_t, ) -> kern_return_t; pub fn vm_region_recurse( target_task: vm_map_t, address: *mut vm_address_t, size: *mut vm_size_t, nesting_depth: *mut natural_t, info: vm_region_recurse_info_t, infoCnt: *mut mach_msg_type_number_t, ) -> kern_return_t; pub fn vm_region_recurse_64( target_task: vm_map_t, address: *mut vm_address_t, size: *mut vm_size_t, nesting_depth: *mut natural_t, info: vm_region_recurse_info_t, infoCnt: *mut mach_msg_type_number_t, ) -> kern_return_t; pub fn vm_region_64( target_task: vm_map_t, address: *mut vm_address_t, size: *mut vm_size_t, flavor: vm_region_flavor_t, info: vm_region_info_t, infoCnt: *mut mach_msg_type_number_t, object_name: *mut mach_port_t, ) -> kern_return_t; pub fn mach_make_memory_entry_64( target_task: vm_map_t, size: *mut memory_object_size_t, offset: memory_object_offset_t, permission: vm_prot_t, object_handle: *mut mach_port_t, parent_entry: mem_entry_name_port_t, ) -> kern_return_t; pub fn vm_map_64( target_task: vm_map_t, address: *mut vm_address_t, size: vm_size_t, mask: vm_address_t, flags: ::libc::c_int, object: mem_entry_name_port_t, offset: memory_object_offset_t, copy: boolean_t, cur_protection: vm_prot_t, max_protection: vm_prot_t, inheritance: vm_inherit_t, ) -> kern_return_t; pub fn vm_purgable_control( target_task: vm_map_t, address: vm_address_t, control: vm_purgable_t, state: *mut ::libc::c_int, ) -> kern_return_t; pub fn mach_port_names( task: ipc_space_t, names: *mut mach_port_name_array_t, namesCnt: *mut mach_msg_type_number_t, types: *mut mach_port_type_array_t, typesCnt: *mut mach_msg_type_number_t, ) -> kern_return_t; pub fn mach_port_type( task: ipc_space_t, name: mach_port_name_t, ptype: *mut mach_port_type_t, ) -> kern_return_t; pub fn mach_port_rename( task: ipc_space_t, old_name: mach_port_name_t, new_name: mach_port_name_t, ) -> kern_return_t; pub fn mach_port_allocate_name( task: ipc_space_t, right: mach_port_right_t, name: mach_port_name_t, ) -> kern_return_t; pub fn mach_port_allocate( task: ipc_space_t, right: mach_port_right_t, name: *mut mach_port_name_t, ) -> kern_return_t; pub fn mach_port_destroy(task: ipc_space_t, name: mach_port_name_t) -> kern_return_t; pub fn mach_port_deallocate(task: ipc_space_t, name: mach_port_name_t) -> kern_return_t; pub fn mach_port_get_refs( task: ipc_space_t, name: mach_port_name_t, right: mach_port_right_t, refs: *mut mach_port_urefs_t, ) -> kern_return_t; pub fn mach_port_mod_refs( task: ipc_space_t, name: mach_port_name_t, right: mach_port_right_t, delta: mach_port_delta_t, ) -> kern_return_t; pub fn mach_port_set_mscount( task: ipc_space_t, name: mach_port_name_t, mscount: mach_port_mscount_t, ) -> kern_return_t; pub fn mach_port_get_set_status( task: ipc_space_t, name: mach_port_name_t, members: *mut mach_port_name_array_t, membersCnt: *mut mach_msg_type_number_t, ) -> kern_return_t; pub fn mach_port_move_member( task: ipc_space_t, member: mach_port_name_t, after: mach_port_name_t, ) -> kern_return_t; pub fn mach_port_request_notification( task: ipc_space_t, name: mach_port_name_t, msgid: mach_msg_id_t, sync: mach_port_mscount_t, notify: mach_port_t, notifyPoly: mach_msg_type_name_t, previous: *mut mach_port_t, ) -> kern_return_t; pub fn mach_port_insert_right( task: ipc_space_t, name: mach_port_name_t, poly: mach_port_t, polyPoly: mach_msg_type_name_t, ) -> kern_return_t; pub fn mach_port_extract_right( task: ipc_space_t, name: mach_port_name_t, msgt_name: mach_msg_type_name_t, poly: *mut mach_port_t, polyPoly: *mut mach_msg_type_name_t, ) -> kern_return_t; pub fn mach_port_set_seqno( task: ipc_space_t, name: mach_port_name_t, seqno: mach_port_seqno_t, ) -> kern_return_t; pub fn mach_port_get_attributes( task: ipc_space_t, name: mach_port_name_t, flavor: mach_port_flavor_t, port_info_out: mach_port_info_t, port_info_outCnt: *mut mach_msg_type_number_t, ) -> kern_return_t; pub fn mach_port_set_attributes( task: ipc_space_t, name: mach_port_name_t, flavor: mach_port_flavor_t, port_info: mach_port_info_t, port_infoCnt: mach_msg_type_number_t, ) -> kern_return_t; pub fn mach_port_allocate_qos( task: ipc_space_t, right: mach_port_right_t, qos: *mut mach_port_qos_t, name: *mut mach_port_name_t, ) -> kern_return_t; pub fn mach_port_allocate_full( task: ipc_space_t, right: mach_port_right_t, proto: mach_port_t, qos: *mut mach_port_qos_t, name: *mut mach_port_name_t, ) -> kern_return_t; pub fn task_set_port_space(task: ipc_space_t, table_entries: ::libc::c_int) -> kern_return_t; pub fn mach_port_get_srights( task: ipc_space_t, name: mach_port_name_t, srights: *mut mach_port_rights_t, ) -> kern_return_t; pub fn mach_port_dnrequest_info( task: ipc_space_t, name: mach_port_name_t, dnr_total: *mut ::libc::c_uint, dnr_used: *mut ::libc::c_uint, ) -> kern_return_t; pub fn mach_port_kernel_object( task: ipc_space_t, name: mach_port_name_t, object_type: *mut ::libc::c_uint, object_addr: *mut ::libc::c_uint, ) -> kern_return_t; pub fn mach_port_insert_member( task: ipc_space_t, name: mach_port_name_t, pset: mach_port_name_t, ) -> kern_return_t; pub fn mach_port_extract_member( task: ipc_space_t, name: mach_port_name_t, pset: mach_port_name_t, ) -> kern_return_t; pub fn mach_port_get_context( task: ipc_space_t, name: mach_port_name_t, context: *mut mach_port_context_t, ) -> kern_return_t; pub fn mach_port_set_context( task: ipc_space_t, name: mach_port_name_t, context: mach_port_context_t, ) -> kern_return_t; pub fn mach_port_kobject( task: ipc_space_t, name: mach_port_name_t, object_type: *mut natural_t, object_addr: *mut mach_vm_address_t, ) -> kern_return_t; pub fn mach_host_self() -> mach_port_t; pub fn mach_thread_self() -> mach_port_t; pub fn host_page_size(arg1: host_t, arg2: *mut vm_size_t) -> kern_return_t; pub fn clock_sleep_trap( clock_name: mach_port_name_t, sleep_type: sleep_type_t, sleep_sec: ::libc::c_int, sleep_nsec: ::libc::c_int, wakeup_time: *mut mach_timespec_t, ) -> kern_return_t; pub fn _kernelrpc_mach_vm_allocate_trap( target: mach_port_name_t, addr: *mut mach_vm_offset_t, size: mach_vm_size_t, flags: ::libc::c_int, ) -> kern_return_t; pub fn _kernelrpc_mach_vm_deallocate_trap( target: mach_port_name_t, address: mach_vm_address_t, size: mach_vm_size_t, ) -> kern_return_t; pub fn _kernelrpc_mach_vm_protect_trap( target: mach_port_name_t, address: mach_vm_address_t, size: mach_vm_size_t, set_maximum: boolean_t, new_protection: vm_prot_t, ) -> kern_return_t; pub fn _kernelrpc_mach_port_allocate_trap( target: mach_port_name_t, right: mach_port_right_t, name: *mut mach_port_name_t, ) -> kern_return_t; pub fn _kernelrpc_mach_port_destroy_trap( target: mach_port_name_t, name: mach_port_name_t, ) -> kern_return_t; pub fn _kernelrpc_mach_port_deallocate_trap( target: mach_port_name_t, name: mach_port_name_t, ) -> kern_return_t; pub fn _kernelrpc_mach_port_mod_refs_trap( target: mach_port_name_t, name: mach_port_name_t, right: mach_port_right_t, delta: mach_port_delta_t, ) -> kern_return_t; pub fn _kernelrpc_mach_port_move_member_trap( target: mach_port_name_t, member: mach_port_name_t, after: mach_port_name_t, ) -> kern_return_t; pub fn _kernelrpc_mach_port_insert_right_trap( target: mach_port_name_t, name: mach_port_name_t, poly: mach_port_name_t, polyPoly: mach_msg_type_name_t, ) -> kern_return_t; pub fn _kernelrpc_mach_port_insert_member_trap( target: mach_port_name_t, name: mach_port_name_t, pset: mach_port_name_t, ) -> kern_return_t; pub fn _kernelrpc_mach_port_extract_member_trap( target: mach_port_name_t, name: mach_port_name_t, pset: mach_port_name_t, ) -> kern_return_t; pub fn macx_swapon( filename: uint64_t, flags: ::libc::c_int, size: ::libc::c_int, priority: ::libc::c_int, ) -> kern_return_t; pub fn macx_swapoff(filename: uint64_t, flags: ::libc::c_int) -> kern_return_t; pub fn macx_triggers( hi_water: ::libc::c_int, low_water: ::libc::c_int, flags: ::libc::c_int, alert_port: mach_port_t, ) -> kern_return_t; pub fn macx_backing_store_suspend(suspend: boolean_t) -> kern_return_t; pub fn macx_backing_store_recovery(pid: ::libc::c_int) -> kern_return_t; pub fn swtch_pri(pri: ::libc::c_int) -> boolean_t; pub fn swtch() -> boolean_t; pub fn thread_switch( thread_name: mach_port_name_t, option: ::libc::c_int, option_time: mach_msg_timeout_t, ) -> kern_return_t; pub fn task_self_trap() -> mach_port_name_t; pub fn task_for_pid( target_tport: mach_port_name_t, pid: ::libc::c_int, t: *mut mach_port_name_t, ) -> kern_return_t; pub fn task_name_for_pid( target_tport: mach_port_name_t, pid: ::libc::c_int, tn: *mut mach_port_name_t, ) -> kern_return_t; pub fn pid_for_task(t: mach_port_name_t, x: *mut ::libc::c_int) -> kern_return_t; pub fn host_info( host: host_t, flavor: host_flavor_t, host_info_out: host_info_t, host_info_outCnt: *mut mach_msg_type_number_t, ) -> kern_return_t; pub fn host_kernel_version(host: host_t, kernel_version: kernel_version_t) -> kern_return_t; pub fn _host_page_size(host: host_t, out_page_size: *mut vm_size_t) -> kern_return_t; pub fn mach_memory_object_memory_entry( host: host_t, internal: boolean_t, size: vm_size_t, permission: vm_prot_t, pager: memory_object_t, entry_handle: *mut mach_port_t, ) -> kern_return_t; pub fn host_processor_info( host: host_t, flavor: processor_flavor_t, out_processor_count: *mut natural_t, out_processor_info: *mut processor_info_array_t, out_processor_infoCnt: *mut mach_msg_type_number_t, ) -> kern_return_t; pub fn host_get_io_master(host: host_t, io_master: *mut io_master_t) -> kern_return_t; pub fn host_get_clock_service( host: host_t, clock_id: clock_id_t, clock_serv: *mut clock_serv_t, ) -> kern_return_t; pub fn kmod_get_info( host: host_t, modules: *mut kmod_args_t, modulesCnt: *mut mach_msg_type_number_t, ) -> kern_return_t; pub fn processor_set_default( host: host_t, default_set: *mut processor_set_name_t, ) -> kern_return_t; pub fn processor_set_create( host: host_t, new_set: *mut processor_set_t, new_name: *mut processor_set_name_t, ) -> kern_return_t; pub fn mach_memory_object_memory_entry_64( host: host_t, internal: boolean_t, size: memory_object_size_t, permission: vm_prot_t, pager: memory_object_t, entry_handle: *mut mach_port_t, ) -> kern_return_t; pub fn host_statistics( host_priv: host_t, flavor: host_flavor_t, host_info_out: host_info_t, host_info_outCnt: *mut mach_msg_type_number_t, ) -> kern_return_t; pub fn host_request_notification( host: host_t, notify_type: host_flavor_t, notify_port: mach_port_t, ) -> kern_return_t; pub fn host_statistics64( host_priv: host_t, flavor: host_flavor_t, host_info64_out: host_info64_t, host_info64_outCnt: *mut mach_msg_type_number_t, ) -> kern_return_t; pub fn mach_error_string(error_value: mach_error_t) -> *mut ::libc::c_char; pub fn mach_error(str: *const ::libc::c_char, error_value: mach_error_t) -> (); pub fn mach_error_type(error_value: mach_error_t) -> *mut ::libc::c_char; pub fn panic_init(arg1: mach_port_t) -> (); pub fn panic(arg1: *const ::libc::c_char, ...) -> (); pub fn safe_gets( arg1: *mut ::libc::c_char, arg2: *mut ::libc::c_char, arg3: ::libc::c_int, ) -> (); pub fn slot_name( arg1: cpu_type_t, arg2: cpu_subtype_t, arg3: *mut *mut ::libc::c_char, arg4: *mut *mut ::libc::c_char, ) -> (); pub fn mig_reply_setup(arg1: *mut mach_msg_header_t, arg2: *mut mach_msg_header_t) -> (); pub fn mach_msg_destroy(arg1: *mut mach_msg_header_t) -> (); pub fn mach_msg_receive(arg1: *mut mach_msg_header_t) -> mach_msg_return_t; pub fn mach_msg_send(arg1: *mut mach_msg_header_t) -> mach_msg_return_t; pub fn mach_msg_server_once( arg1: ::std::option::Option< extern "C" fn(arg1: *mut mach_msg_header_t, arg2: *mut mach_msg_header_t) -> boolean_t, >, arg2: mach_msg_size_t, arg3: mach_port_t, arg4: mach_msg_options_t, ) -> mach_msg_return_t; pub fn mach_msg_server( arg1: ::std::option::Option< extern "C" fn(arg1: *mut mach_msg_header_t, arg2: *mut mach_msg_header_t) -> boolean_t, >, arg2: mach_msg_size_t, arg3: mach_port_t, arg4: mach_msg_options_t, ) -> mach_msg_return_t; pub fn clock_get_res(arg1: mach_port_t, arg2: *mut clock_res_t) -> kern_return_t; pub fn clock_set_res(arg1: mach_port_t, arg2: clock_res_t) -> kern_return_t; pub fn clock_sleep( arg1: mach_port_t, arg2: ::libc::c_int, arg3: mach_timespec_t, arg4: *mut mach_timespec_t, ) -> kern_return_t; }