Struct SYSCALLS 

pub struct SYSCALLS { /* private fields */ }

Methods from Deref<Target = Syscalls2>

pub fn ensure_init(&self)

Load the plugin and initialize it if it hasn’t been loaded already.

pub fn add_callback_on_sys_accept_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, arg0: i32, arg1: u64, arg2: u64), )

pub fn remove_callback_on_sys_accept_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, arg0: i32, arg1: u64, arg2: u64), )

pub fn add_callback_on_sys_accept_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, arg0: i32, arg1: u64, arg2: u64), )

pub fn remove_callback_on_sys_accept_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, arg0: i32, arg1: u64, arg2: u64), )

pub fn add_callback_on_sys_accept4_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, arg0: i32, arg1: u64, arg2: u64, arg3: i32), )

pub fn remove_callback_on_sys_accept4_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, arg0: i32, arg1: u64, arg2: u64, arg3: i32), )

pub fn add_callback_on_sys_accept4_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, arg0: i32, arg1: u64, arg2: u64, arg3: i32), )

pub fn remove_callback_on_sys_accept4_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, arg0: i32, arg1: u64, arg2: u64, arg3: i32), )

pub fn add_callback_on_sys_access_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, filename: u64, mode: i32), )

pub fn remove_callback_on_sys_access_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, filename: u64, mode: i32), )

pub fn add_callback_on_sys_access_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, filename: u64, mode: i32), )

pub fn remove_callback_on_sys_access_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, filename: u64, mode: i32), )

pub fn add_callback_on_sys_acct_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, name: u64), )

pub fn remove_callback_on_sys_acct_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, name: u64), )

pub fn add_callback_on_sys_acct_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, name: u64), )

pub fn remove_callback_on_sys_acct_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, name: u64), )

pub fn add_callback_on_sys_add_key_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, _type: u64, _description: u64, _payload: u64, plen: u32, destringid: u32), )

pub fn remove_callback_on_sys_add_key_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, _type: u64, _description: u64, _payload: u64, plen: u32, destringid: u32), )

pub fn add_callback_on_sys_add_key_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, _type: u64, _description: u64, _payload: u64, plen: u32, destringid: u32), )

pub fn remove_callback_on_sys_add_key_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, _type: u64, _description: u64, _payload: u64, plen: u32, destringid: u32), )

pub fn add_callback_on_sys_adjtimex_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, txc_p: u64), )

pub fn remove_callback_on_sys_adjtimex_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, txc_p: u64), )

pub fn add_callback_on_sys_adjtimex_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, txc_p: u64), )

pub fn remove_callback_on_sys_adjtimex_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, txc_p: u64), )

pub fn add_callback_on_sys_alarm_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, seconds: u32), )

pub fn remove_callback_on_sys_alarm_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, seconds: u32), )

pub fn add_callback_on_sys_alarm_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, seconds: u32), )

pub fn remove_callback_on_sys_alarm_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, seconds: u32), )

pub fn add_callback_on_sys_arch_prctl_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, arg0: i32, arg1: u64), )

pub fn remove_callback_on_sys_arch_prctl_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, arg0: i32, arg1: u64), )

pub fn add_callback_on_sys_arch_prctl_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, arg0: i32, arg1: u64), )

pub fn remove_callback_on_sys_arch_prctl_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, arg0: i32, arg1: u64), )

pub fn add_callback_on_sys_bind_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, arg0: i32, arg1: u64, arg2: i32), )

pub fn remove_callback_on_sys_bind_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, arg0: i32, arg1: u64, arg2: i32), )

pub fn add_callback_on_sys_bind_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, arg0: i32, arg1: u64, arg2: i32), )

pub fn remove_callback_on_sys_bind_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, arg0: i32, arg1: u64, arg2: i32), )

pub fn add_callback_on_sys_bpf_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, cmd: i32, attr: u64, size: u32), )

pub fn remove_callback_on_sys_bpf_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, cmd: i32, attr: u64, size: u32), )

pub fn add_callback_on_sys_bpf_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, cmd: i32, attr: u64, size: u32), )

pub fn remove_callback_on_sys_bpf_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, cmd: i32, attr: u64, size: u32), )

pub fn add_callback_on_sys_brk_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, brk: u64), )

pub fn remove_callback_on_sys_brk_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, brk: u64), )

pub fn add_callback_on_sys_brk_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, brk: u64), )

pub fn remove_callback_on_sys_brk_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, brk: u64), )

pub fn add_callback_on_sys_capget_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, header: u64, dataptr: u64), )

pub fn remove_callback_on_sys_capget_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, header: u64, dataptr: u64), )

pub fn add_callback_on_sys_capget_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, header: u64, dataptr: u64), )

pub fn remove_callback_on_sys_capget_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, header: u64, dataptr: u64), )

pub fn add_callback_on_sys_capset_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, header: u64, _data: u64), )

pub fn remove_callback_on_sys_capset_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, header: u64, _data: u64), )

pub fn add_callback_on_sys_capset_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, header: u64, _data: u64), )

pub fn remove_callback_on_sys_capset_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, header: u64, _data: u64), )

pub fn add_callback_on_sys_chdir_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, filename: u64), )

pub fn remove_callback_on_sys_chdir_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, filename: u64), )

pub fn add_callback_on_sys_chdir_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, filename: u64), )

pub fn remove_callback_on_sys_chdir_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, filename: u64), )

pub fn add_callback_on_sys_chmod_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, filename: u64, mode: u32), )

pub fn remove_callback_on_sys_chmod_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, filename: u64, mode: u32), )

pub fn add_callback_on_sys_chmod_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, filename: u64, mode: u32), )

pub fn remove_callback_on_sys_chmod_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, filename: u64, mode: u32), )

pub fn add_callback_on_sys_chown_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, filename: u64, user: u32, group: u32), )

pub fn remove_callback_on_sys_chown_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, filename: u64, user: u32, group: u32), )

pub fn add_callback_on_sys_chown_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, filename: u64, user: u32, group: u32), )

pub fn remove_callback_on_sys_chown_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, filename: u64, user: u32, group: u32), )

pub fn add_callback_on_sys_chroot_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, filename: u64), )

pub fn remove_callback_on_sys_chroot_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, filename: u64), )

pub fn add_callback_on_sys_chroot_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, filename: u64), )

pub fn remove_callback_on_sys_chroot_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, filename: u64), )

pub fn add_callback_on_sys_clock_adjtime_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, which_clock: u32, tx: u64), )

pub fn remove_callback_on_sys_clock_adjtime_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, which_clock: u32, tx: u64), )

pub fn add_callback_on_sys_clock_adjtime_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, which_clock: u32, tx: u64), )

pub fn remove_callback_on_sys_clock_adjtime_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, which_clock: u32, tx: u64), )

pub fn add_callback_on_sys_clock_getres_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, which_clock: u32, tp: u64), )

pub fn remove_callback_on_sys_clock_getres_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, which_clock: u32, tp: u64), )

pub fn add_callback_on_sys_clock_getres_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, which_clock: u32, tp: u64), )

pub fn remove_callback_on_sys_clock_getres_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, which_clock: u32, tp: u64), )

pub fn add_callback_on_sys_clock_gettime_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, which_clock: u32, tp: u64), )

pub fn remove_callback_on_sys_clock_gettime_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, which_clock: u32, tp: u64), )

pub fn add_callback_on_sys_clock_gettime_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, which_clock: u32, tp: u64), )

pub fn remove_callback_on_sys_clock_gettime_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, which_clock: u32, tp: u64), )

pub fn add_callback_on_sys_clock_nanosleep_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, which_clock: u32, flags: i32, rqtp: u64, rmtp: u64), )

pub fn remove_callback_on_sys_clock_nanosleep_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, which_clock: u32, flags: i32, rqtp: u64, rmtp: u64), )

pub fn add_callback_on_sys_clock_nanosleep_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, which_clock: u32, flags: i32, rqtp: u64, rmtp: u64), )

pub fn remove_callback_on_sys_clock_nanosleep_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, which_clock: u32, flags: i32, rqtp: u64, rmtp: u64), )

pub fn add_callback_on_sys_clock_settime_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, which_clock: u32, tp: u64), )

pub fn remove_callback_on_sys_clock_settime_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, which_clock: u32, tp: u64), )

pub fn add_callback_on_sys_clock_settime_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, which_clock: u32, tp: u64), )

pub fn remove_callback_on_sys_clock_settime_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, which_clock: u32, tp: u64), )

pub fn add_callback_on_sys_clone_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, arg0: u64, arg1: u64, arg2: u64, arg3: u64, arg4: u64), )

pub fn remove_callback_on_sys_clone_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, arg0: u64, arg1: u64, arg2: u64, arg3: u64, arg4: u64), )

pub fn add_callback_on_sys_clone_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, arg0: u64, arg1: u64, arg2: u64, arg3: u64, arg4: u64), )

pub fn remove_callback_on_sys_clone_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, arg0: u64, arg1: u64, arg2: u64, arg3: u64, arg4: u64), )

pub fn add_callback_on_sys_close_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, fd: u32), )

pub fn remove_callback_on_sys_close_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, fd: u32), )

pub fn add_callback_on_sys_close_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, fd: u32), )

pub fn remove_callback_on_sys_close_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, fd: u32), )

pub fn add_callback_on_sys_connect_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, arg0: i32, arg1: u64, arg2: i32), )

pub fn remove_callback_on_sys_connect_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, arg0: i32, arg1: u64, arg2: i32), )

pub fn add_callback_on_sys_connect_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, arg0: i32, arg1: u64, arg2: i32), )

pub fn remove_callback_on_sys_connect_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, arg0: i32, arg1: u64, arg2: i32), )

pub fn add_callback_on_sys_copy_file_range_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, fd_in: i32, off_in: u64, fd_out: i32, off_out: u64, len: u32, flags: u32), )

pub fn remove_callback_on_sys_copy_file_range_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, fd_in: i32, off_in: u64, fd_out: i32, off_out: u64, len: u32, flags: u32), )

pub fn add_callback_on_sys_copy_file_range_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, fd_in: i32, off_in: u64, fd_out: i32, off_out: u64, len: u32, flags: u32), )

pub fn remove_callback_on_sys_copy_file_range_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, fd_in: i32, off_in: u64, fd_out: i32, off_out: u64, len: u32, flags: u32), )

pub fn add_callback_on_sys_creat_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, pathname: u64, mode: u32), )

pub fn remove_callback_on_sys_creat_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, pathname: u64, mode: u32), )

pub fn add_callback_on_sys_creat_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, pathname: u64, mode: u32), )

pub fn remove_callback_on_sys_creat_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, pathname: u64, mode: u32), )

pub fn add_callback_on_sys_delete_module_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, name_user: u64, flags: u32), )

pub fn remove_callback_on_sys_delete_module_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, name_user: u64, flags: u32), )

pub fn add_callback_on_sys_delete_module_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, name_user: u64, flags: u32), )

pub fn remove_callback_on_sys_delete_module_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, name_user: u64, flags: u32), )

pub fn add_callback_on_sys_dup_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, fildes: u32), )

pub fn remove_callback_on_sys_dup_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, fildes: u32), )

pub fn add_callback_on_sys_dup_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, fildes: u32), )

pub fn remove_callback_on_sys_dup_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, fildes: u32), )

pub fn add_callback_on_sys_dup2_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, oldfd: u32, newfd: u32), )

pub fn remove_callback_on_sys_dup2_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, oldfd: u32, newfd: u32), )

pub fn add_callback_on_sys_dup2_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, oldfd: u32, newfd: u32), )

pub fn remove_callback_on_sys_dup2_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, oldfd: u32, newfd: u32), )

pub fn add_callback_on_sys_dup3_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, oldfd: u32, newfd: u32, flags: i32), )

pub fn remove_callback_on_sys_dup3_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, oldfd: u32, newfd: u32, flags: i32), )

pub fn add_callback_on_sys_dup3_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, oldfd: u32, newfd: u32, flags: i32), )

pub fn remove_callback_on_sys_dup3_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, oldfd: u32, newfd: u32, flags: i32), )

pub fn add_callback_on_sys_epoll_create_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, size: i32), )

pub fn remove_callback_on_sys_epoll_create_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, size: i32), )

pub fn add_callback_on_sys_epoll_create_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, size: i32), )

pub fn remove_callback_on_sys_epoll_create_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, size: i32), )

pub fn add_callback_on_sys_epoll_create1_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, flags: i32), )

pub fn remove_callback_on_sys_epoll_create1_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, flags: i32), )

pub fn add_callback_on_sys_epoll_create1_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, flags: i32), )

pub fn remove_callback_on_sys_epoll_create1_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, flags: i32), )

pub fn add_callback_on_sys_epoll_ctl_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, epfd: i32, op: i32, fd: i32, event: u64), )

pub fn remove_callback_on_sys_epoll_ctl_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, epfd: i32, op: i32, fd: i32, event: u64), )

pub fn add_callback_on_sys_epoll_ctl_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, epfd: i32, op: i32, fd: i32, event: u64), )

pub fn remove_callback_on_sys_epoll_ctl_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, epfd: i32, op: i32, fd: i32, event: u64), )

pub fn add_callback_on_sys_epoll_pwait_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, epfd: i32, events: u64, maxevents: i32, timeout: i32, sigmask: u64, sigsetsize: u32), )

pub fn remove_callback_on_sys_epoll_pwait_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, epfd: i32, events: u64, maxevents: i32, timeout: i32, sigmask: u64, sigsetsize: u32), )

pub fn add_callback_on_sys_epoll_pwait_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, epfd: i32, events: u64, maxevents: i32, timeout: i32, sigmask: u64, sigsetsize: u32), )

pub fn remove_callback_on_sys_epoll_pwait_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, epfd: i32, events: u64, maxevents: i32, timeout: i32, sigmask: u64, sigsetsize: u32), )

pub fn add_callback_on_sys_epoll_wait_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, epfd: i32, events: u64, maxevents: i32, timeout: i32), )

pub fn remove_callback_on_sys_epoll_wait_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, epfd: i32, events: u64, maxevents: i32, timeout: i32), )

pub fn add_callback_on_sys_epoll_wait_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, epfd: i32, events: u64, maxevents: i32, timeout: i32), )

pub fn remove_callback_on_sys_epoll_wait_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, epfd: i32, events: u64, maxevents: i32, timeout: i32), )

pub fn add_callback_on_sys_eventfd_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, count: u32), )

pub fn remove_callback_on_sys_eventfd_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, count: u32), )

pub fn add_callback_on_sys_eventfd_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, count: u32), )

pub fn remove_callback_on_sys_eventfd_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, count: u32), )

pub fn add_callback_on_sys_eventfd2_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, count: u32, flags: i32), )

pub fn remove_callback_on_sys_eventfd2_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, count: u32, flags: i32), )

pub fn add_callback_on_sys_eventfd2_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, count: u32, flags: i32), )

pub fn remove_callback_on_sys_eventfd2_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, count: u32, flags: i32), )

pub fn add_callback_on_sys_execve_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, filename: u64, argv: u64, envp: u64), )

pub fn remove_callback_on_sys_execve_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, filename: u64, argv: u64, envp: u64), )

pub fn add_callback_on_sys_execve_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, filename: u64, argv: u64, envp: u64), )

pub fn remove_callback_on_sys_execve_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, filename: u64, argv: u64, envp: u64), )

pub fn add_callback_on_sys_execveat_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, dfd: i32, filename: u64, argv: u64, envp: u64, flags: i32), )

pub fn remove_callback_on_sys_execveat_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, dfd: i32, filename: u64, argv: u64, envp: u64, flags: i32), )

pub fn add_callback_on_sys_execveat_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, dfd: i32, filename: u64, argv: u64, envp: u64, flags: i32), )

pub fn remove_callback_on_sys_execveat_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, dfd: i32, filename: u64, argv: u64, envp: u64, flags: i32), )

pub fn add_callback_on_sys_exit_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, rval: i32), )

pub fn remove_callback_on_sys_exit_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, rval: i32), )

pub fn add_callback_on_sys_exit_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, rval: i32), )

pub fn remove_callback_on_sys_exit_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, rval: i32), )

pub fn add_callback_on_sys_exit_group_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, error_code: i32), )

pub fn remove_callback_on_sys_exit_group_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, error_code: i32), )

pub fn add_callback_on_sys_exit_group_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, error_code: i32), )

pub fn remove_callback_on_sys_exit_group_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, error_code: i32), )

pub fn add_callback_on_sys_faccessat_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, dfd: i32, filename: u64, mode: i32), )

pub fn remove_callback_on_sys_faccessat_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, dfd: i32, filename: u64, mode: i32), )

pub fn add_callback_on_sys_faccessat_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, dfd: i32, filename: u64, mode: i32), )

pub fn remove_callback_on_sys_faccessat_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, dfd: i32, filename: u64, mode: i32), )

pub fn add_callback_on_sys_fadvise64_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, fd: i32, offset: u64, len: u32, advice: i32), )

pub fn remove_callback_on_sys_fadvise64_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, fd: i32, offset: u64, len: u32, advice: i32), )

pub fn add_callback_on_sys_fadvise64_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, fd: i32, offset: u64, len: u32, advice: i32), )

pub fn remove_callback_on_sys_fadvise64_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, fd: i32, offset: u64, len: u32, advice: i32), )

pub fn add_callback_on_sys_fallocate_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, fd: i32, mode: i32, offset: u64, len: u64), )

pub fn remove_callback_on_sys_fallocate_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, fd: i32, mode: i32, offset: u64, len: u64), )

pub fn add_callback_on_sys_fallocate_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, fd: i32, mode: i32, offset: u64, len: u64), )

pub fn remove_callback_on_sys_fallocate_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, fd: i32, mode: i32, offset: u64, len: u64), )

pub fn add_callback_on_sys_fanotify_init_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, flags: u32, event_f_flags: u32), )

pub fn remove_callback_on_sys_fanotify_init_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, flags: u32, event_f_flags: u32), )

pub fn add_callback_on_sys_fanotify_init_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, flags: u32, event_f_flags: u32), )

pub fn remove_callback_on_sys_fanotify_init_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, flags: u32, event_f_flags: u32), )

pub fn add_callback_on_sys_fanotify_mark_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, fanotify_fd: i32, flags: u32, mask: u64, fd: i32, pathname: u64), )

pub fn remove_callback_on_sys_fanotify_mark_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, fanotify_fd: i32, flags: u32, mask: u64, fd: i32, pathname: u64), )

pub fn add_callback_on_sys_fanotify_mark_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, fanotify_fd: i32, flags: u32, mask: u64, fd: i32, pathname: u64), )

pub fn remove_callback_on_sys_fanotify_mark_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, fanotify_fd: i32, flags: u32, mask: u64, fd: i32, pathname: u64), )

pub fn add_callback_on_sys_fchdir_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, fd: u32), )

pub fn remove_callback_on_sys_fchdir_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, fd: u32), )

pub fn add_callback_on_sys_fchdir_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, fd: u32), )

pub fn remove_callback_on_sys_fchdir_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, fd: u32), )

pub fn add_callback_on_sys_fchmod_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, fd: u32, mode: u32), )

pub fn remove_callback_on_sys_fchmod_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, fd: u32, mode: u32), )

pub fn add_callback_on_sys_fchmod_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, fd: u32, mode: u32), )

pub fn remove_callback_on_sys_fchmod_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, fd: u32, mode: u32), )

pub fn add_callback_on_sys_fchmodat_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, dfd: i32, filename: u64, mode: u32), )

pub fn remove_callback_on_sys_fchmodat_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, dfd: i32, filename: u64, mode: u32), )

pub fn add_callback_on_sys_fchmodat_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, dfd: i32, filename: u64, mode: u32), )

pub fn remove_callback_on_sys_fchmodat_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, dfd: i32, filename: u64, mode: u32), )

pub fn add_callback_on_sys_fchown_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, fd: u32, user: u32, group: u32), )

pub fn remove_callback_on_sys_fchown_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, fd: u32, user: u32, group: u32), )

pub fn add_callback_on_sys_fchown_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, fd: u32, user: u32, group: u32), )

pub fn remove_callback_on_sys_fchown_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, fd: u32, user: u32, group: u32), )

pub fn add_callback_on_sys_fchownat_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, dfd: i32, filename: u64, user: u32, group: u32, flag: i32), )

pub fn remove_callback_on_sys_fchownat_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, dfd: i32, filename: u64, user: u32, group: u32, flag: i32), )

pub fn add_callback_on_sys_fchownat_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, dfd: i32, filename: u64, user: u32, group: u32, flag: i32), )

pub fn remove_callback_on_sys_fchownat_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, dfd: i32, filename: u64, user: u32, group: u32, flag: i32), )

pub fn add_callback_on_sys_fcntl_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, fd: u32, cmd: u32, arg: u64), )

pub fn remove_callback_on_sys_fcntl_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, fd: u32, cmd: u32, arg: u64), )

pub fn add_callback_on_sys_fcntl_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, fd: u32, cmd: u32, arg: u64), )

pub fn remove_callback_on_sys_fcntl_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, fd: u32, cmd: u32, arg: u64), )

pub fn add_callback_on_sys_fdatasync_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, fd: u32), )

pub fn remove_callback_on_sys_fdatasync_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, fd: u32), )

pub fn add_callback_on_sys_fdatasync_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, fd: u32), )

pub fn remove_callback_on_sys_fdatasync_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, fd: u32), )

pub fn add_callback_on_sys_fgetxattr_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, fd: i32, name: u64, value: u64, size: u32), )

pub fn remove_callback_on_sys_fgetxattr_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, fd: i32, name: u64, value: u64, size: u32), )

pub fn add_callback_on_sys_fgetxattr_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, fd: i32, name: u64, value: u64, size: u32), )

pub fn remove_callback_on_sys_fgetxattr_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, fd: i32, name: u64, value: u64, size: u32), )

pub fn add_callback_on_sys_finit_module_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, fd: i32, uargs: u64, flags: i32), )

pub fn remove_callback_on_sys_finit_module_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, fd: i32, uargs: u64, flags: i32), )

pub fn add_callback_on_sys_finit_module_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, fd: i32, uargs: u64, flags: i32), )

pub fn remove_callback_on_sys_finit_module_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, fd: i32, uargs: u64, flags: i32), )

pub fn add_callback_on_sys_flistxattr_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, fd: i32, list: u64, size: u32), )

pub fn remove_callback_on_sys_flistxattr_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, fd: i32, list: u64, size: u32), )

pub fn add_callback_on_sys_flistxattr_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, fd: i32, list: u64, size: u32), )

pub fn remove_callback_on_sys_flistxattr_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, fd: i32, list: u64, size: u32), )

pub fn add_callback_on_sys_flock_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, fd: u32, cmd: u32), )

pub fn remove_callback_on_sys_flock_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, fd: u32, cmd: u32), )

pub fn add_callback_on_sys_flock_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, fd: u32, cmd: u32), )

pub fn remove_callback_on_sys_flock_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, fd: u32, cmd: u32), )

pub fn add_callback_on_sys_fork_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc), )

pub fn remove_callback_on_sys_fork_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc), )

pub fn add_callback_on_sys_fork_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc), )

pub fn remove_callback_on_sys_fork_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc), )

pub fn add_callback_on_sys_fremovexattr_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, fd: i32, name: u64), )

pub fn remove_callback_on_sys_fremovexattr_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, fd: i32, name: u64), )

pub fn add_callback_on_sys_fremovexattr_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, fd: i32, name: u64), )

pub fn remove_callback_on_sys_fremovexattr_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, fd: i32, name: u64), )

pub fn add_callback_on_sys_fsetxattr_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, fd: i32, name: u64, value: u64, size: u32, flags: i32), )

pub fn remove_callback_on_sys_fsetxattr_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, fd: i32, name: u64, value: u64, size: u32, flags: i32), )

pub fn add_callback_on_sys_fsetxattr_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, fd: i32, name: u64, value: u64, size: u32, flags: i32), )

pub fn remove_callback_on_sys_fsetxattr_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, fd: i32, name: u64, value: u64, size: u32, flags: i32), )

pub fn add_callback_on_sys_fstatfs_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, fd: u32, buf: u64), )

pub fn remove_callback_on_sys_fstatfs_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, fd: u32, buf: u64), )

pub fn add_callback_on_sys_fstatfs_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, fd: u32, buf: u64), )

pub fn remove_callback_on_sys_fstatfs_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, fd: u32, buf: u64), )

pub fn add_callback_on_sys_fsync_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, fd: u32), )

pub fn remove_callback_on_sys_fsync_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, fd: u32), )

pub fn add_callback_on_sys_fsync_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, fd: u32), )

pub fn remove_callback_on_sys_fsync_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, fd: u32), )

pub fn add_callback_on_sys_ftruncate_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, fd: u32, length: u64), )

pub fn remove_callback_on_sys_ftruncate_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, fd: u32, length: u64), )

pub fn add_callback_on_sys_ftruncate_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, fd: u32, length: u64), )

pub fn remove_callback_on_sys_ftruncate_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, fd: u32, length: u64), )

pub fn add_callback_on_sys_futex_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, uaddr: u64, op: i32, val: u32, utime: u64, uaddr2: u64, val3: u32), )

pub fn remove_callback_on_sys_futex_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, uaddr: u64, op: i32, val: u32, utime: u64, uaddr2: u64, val3: u32), )

pub fn add_callback_on_sys_futex_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, uaddr: u64, op: i32, val: u32, utime: u64, uaddr2: u64, val3: u32), )

pub fn remove_callback_on_sys_futex_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, uaddr: u64, op: i32, val: u32, utime: u64, uaddr2: u64, val3: u32), )

pub fn add_callback_on_sys_futimesat_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, dfd: i32, filename: u64, utimes: u64), )

pub fn remove_callback_on_sys_futimesat_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, dfd: i32, filename: u64, utimes: u64), )

pub fn add_callback_on_sys_futimesat_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, dfd: i32, filename: u64, utimes: u64), )

pub fn remove_callback_on_sys_futimesat_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, dfd: i32, filename: u64, utimes: u64), )

pub fn add_callback_on_sys_get_mempolicy_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, policy: u64, nmask: u64, maxnode: u64, addr: u64, flags: u64), )

pub fn remove_callback_on_sys_get_mempolicy_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, policy: u64, nmask: u64, maxnode: u64, addr: u64, flags: u64), )

pub fn add_callback_on_sys_get_mempolicy_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, policy: u64, nmask: u64, maxnode: u64, addr: u64, flags: u64), )

pub fn remove_callback_on_sys_get_mempolicy_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, policy: u64, nmask: u64, maxnode: u64, addr: u64, flags: u64), )

pub fn add_callback_on_sys_get_robust_list_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, pid: i32, head_ptr: u64, len_ptr: u64), )

pub fn remove_callback_on_sys_get_robust_list_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, pid: i32, head_ptr: u64, len_ptr: u64), )

pub fn add_callback_on_sys_get_robust_list_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, pid: i32, head_ptr: u64, len_ptr: u64), )

pub fn remove_callback_on_sys_get_robust_list_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, pid: i32, head_ptr: u64, len_ptr: u64), )

pub fn add_callback_on_sys_getcpu_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, _cpu: u64, node: u64, cache: u64), )

pub fn remove_callback_on_sys_getcpu_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, _cpu: u64, node: u64, cache: u64), )

pub fn add_callback_on_sys_getcpu_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, _cpu: u64, node: u64, cache: u64), )

pub fn remove_callback_on_sys_getcpu_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, _cpu: u64, node: u64, cache: u64), )

pub fn add_callback_on_sys_getcwd_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, buf: u64, size: u64), )

pub fn remove_callback_on_sys_getcwd_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, buf: u64, size: u64), )

pub fn add_callback_on_sys_getcwd_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, buf: u64, size: u64), )

pub fn remove_callback_on_sys_getcwd_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, buf: u64, size: u64), )

pub fn add_callback_on_sys_getdents_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, fd: u32, dirent: u64, count: u32), )

pub fn remove_callback_on_sys_getdents_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, fd: u32, dirent: u64, count: u32), )

pub fn add_callback_on_sys_getdents_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, fd: u32, dirent: u64, count: u32), )

pub fn remove_callback_on_sys_getdents_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, fd: u32, dirent: u64, count: u32), )

pub fn add_callback_on_sys_getdents64_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, fd: u32, dirent: u64, count: u32), )

pub fn remove_callback_on_sys_getdents64_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, fd: u32, dirent: u64, count: u32), )

pub fn add_callback_on_sys_getdents64_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, fd: u32, dirent: u64, count: u32), )

pub fn remove_callback_on_sys_getdents64_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, fd: u32, dirent: u64, count: u32), )

pub fn add_callback_on_sys_getegid_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc), )

pub fn remove_callback_on_sys_getegid_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc), )

pub fn add_callback_on_sys_getegid_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc), )

pub fn remove_callback_on_sys_getegid_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc), )

pub fn add_callback_on_sys_geteuid_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc), )

pub fn remove_callback_on_sys_geteuid_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc), )

pub fn add_callback_on_sys_geteuid_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc), )

pub fn remove_callback_on_sys_geteuid_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc), )

pub fn add_callback_on_sys_getgid_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc), )

pub fn remove_callback_on_sys_getgid_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc), )

pub fn add_callback_on_sys_getgid_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc), )

pub fn remove_callback_on_sys_getgid_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc), )

pub fn add_callback_on_sys_getgroups_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, gidsetsize: i32, grouplist: u64), )

pub fn remove_callback_on_sys_getgroups_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, gidsetsize: i32, grouplist: u64), )

pub fn add_callback_on_sys_getgroups_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, gidsetsize: i32, grouplist: u64), )

pub fn remove_callback_on_sys_getgroups_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, gidsetsize: i32, grouplist: u64), )

pub fn add_callback_on_sys_getitimer_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, which: i32, value: u64), )

pub fn remove_callback_on_sys_getitimer_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, which: i32, value: u64), )

pub fn add_callback_on_sys_getitimer_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, which: i32, value: u64), )

pub fn remove_callback_on_sys_getitimer_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, which: i32, value: u64), )

pub fn add_callback_on_sys_getpeername_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, arg0: i32, arg1: u64, arg2: u64), )

pub fn remove_callback_on_sys_getpeername_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, arg0: i32, arg1: u64, arg2: u64), )

pub fn add_callback_on_sys_getpeername_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, arg0: i32, arg1: u64, arg2: u64), )

pub fn remove_callback_on_sys_getpeername_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, arg0: i32, arg1: u64, arg2: u64), )

pub fn add_callback_on_sys_getpgid_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, pid: i32), )

pub fn remove_callback_on_sys_getpgid_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, pid: i32), )

pub fn add_callback_on_sys_getpgid_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, pid: i32), )

pub fn remove_callback_on_sys_getpgid_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, pid: i32), )

pub fn add_callback_on_sys_getpgrp_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc), )

pub fn remove_callback_on_sys_getpgrp_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc), )

pub fn add_callback_on_sys_getpgrp_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc), )

pub fn remove_callback_on_sys_getpgrp_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc), )

pub fn add_callback_on_sys_getpid_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc), )

pub fn remove_callback_on_sys_getpid_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc), )

pub fn add_callback_on_sys_getpid_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc), )

pub fn remove_callback_on_sys_getpid_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc), )

pub fn add_callback_on_sys_getppid_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc), )

pub fn remove_callback_on_sys_getppid_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc), )

pub fn add_callback_on_sys_getppid_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc), )

pub fn remove_callback_on_sys_getppid_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc), )

pub fn add_callback_on_sys_getpriority_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, which: i32, who: i32), )

pub fn remove_callback_on_sys_getpriority_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, which: i32, who: i32), )

pub fn add_callback_on_sys_getpriority_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, which: i32, who: i32), )

pub fn remove_callback_on_sys_getpriority_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, which: i32, who: i32), )

pub fn add_callback_on_sys_getrandom_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, buf: u64, count: u32, flags: u32), )

pub fn remove_callback_on_sys_getrandom_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, buf: u64, count: u32, flags: u32), )

pub fn add_callback_on_sys_getrandom_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, buf: u64, count: u32, flags: u32), )

pub fn remove_callback_on_sys_getrandom_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, buf: u64, count: u32, flags: u32), )

pub fn add_callback_on_sys_getresgid_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, rgid: u64, egid: u64, sgid: u64), )

pub fn remove_callback_on_sys_getresgid_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, rgid: u64, egid: u64, sgid: u64), )

pub fn add_callback_on_sys_getresgid_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, rgid: u64, egid: u64, sgid: u64), )

pub fn remove_callback_on_sys_getresgid_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, rgid: u64, egid: u64, sgid: u64), )

pub fn add_callback_on_sys_getresuid_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, ruid: u64, euid: u64, suid: u64), )

pub fn remove_callback_on_sys_getresuid_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, ruid: u64, euid: u64, suid: u64), )

pub fn add_callback_on_sys_getresuid_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, ruid: u64, euid: u64, suid: u64), )

pub fn remove_callback_on_sys_getresuid_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, ruid: u64, euid: u64, suid: u64), )

pub fn add_callback_on_sys_getrlimit_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, resource: u32, rlim: u64), )

pub fn remove_callback_on_sys_getrlimit_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, resource: u32, rlim: u64), )

pub fn add_callback_on_sys_getrlimit_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, resource: u32, rlim: u64), )

pub fn remove_callback_on_sys_getrlimit_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, resource: u32, rlim: u64), )

pub fn add_callback_on_sys_getrusage_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, who: i32, ru: u64), )

pub fn remove_callback_on_sys_getrusage_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, who: i32, ru: u64), )

pub fn add_callback_on_sys_getrusage_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, who: i32, ru: u64), )

pub fn remove_callback_on_sys_getrusage_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, who: i32, ru: u64), )

pub fn add_callback_on_sys_getsid_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, pid: i32), )

pub fn remove_callback_on_sys_getsid_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, pid: i32), )

pub fn add_callback_on_sys_getsid_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, pid: i32), )

pub fn remove_callback_on_sys_getsid_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, pid: i32), )

pub fn add_callback_on_sys_getsockname_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, arg0: i32, arg1: u64, arg2: u64), )

pub fn remove_callback_on_sys_getsockname_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, arg0: i32, arg1: u64, arg2: u64), )

pub fn add_callback_on_sys_getsockname_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, arg0: i32, arg1: u64, arg2: u64), )

pub fn remove_callback_on_sys_getsockname_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, arg0: i32, arg1: u64, arg2: u64), )

pub fn add_callback_on_sys_getsockopt_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, fd: i32, level: i32, optname: i32, optval: u64, optlen: u64), )

pub fn remove_callback_on_sys_getsockopt_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, fd: i32, level: i32, optname: i32, optval: u64, optlen: u64), )

pub fn add_callback_on_sys_getsockopt_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, fd: i32, level: i32, optname: i32, optval: u64, optlen: u64), )

pub fn remove_callback_on_sys_getsockopt_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, fd: i32, level: i32, optname: i32, optval: u64, optlen: u64), )

pub fn add_callback_on_sys_gettid_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc), )

pub fn remove_callback_on_sys_gettid_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc), )

pub fn add_callback_on_sys_gettid_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc), )

pub fn remove_callback_on_sys_gettid_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc), )

pub fn add_callback_on_sys_gettimeofday_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, tv: u64, tz: u64), )

pub fn remove_callback_on_sys_gettimeofday_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, tv: u64, tz: u64), )

pub fn add_callback_on_sys_gettimeofday_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, tv: u64, tz: u64), )

pub fn remove_callback_on_sys_gettimeofday_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, tv: u64, tz: u64), )

pub fn add_callback_on_sys_getuid_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc), )

pub fn remove_callback_on_sys_getuid_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc), )

pub fn add_callback_on_sys_getuid_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc), )

pub fn remove_callback_on_sys_getuid_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc), )

pub fn add_callback_on_sys_getxattr_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, path: u64, name: u64, value: u64, size: u32), )

pub fn remove_callback_on_sys_getxattr_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, path: u64, name: u64, value: u64, size: u32), )

pub fn add_callback_on_sys_getxattr_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, path: u64, name: u64, value: u64, size: u32), )

pub fn remove_callback_on_sys_getxattr_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, path: u64, name: u64, value: u64, size: u32), )

pub fn add_callback_on_sys_init_module_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, umod: u64, len: u64, uargs: u64), )

pub fn remove_callback_on_sys_init_module_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, umod: u64, len: u64, uargs: u64), )

pub fn add_callback_on_sys_init_module_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, umod: u64, len: u64, uargs: u64), )

pub fn remove_callback_on_sys_init_module_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, umod: u64, len: u64, uargs: u64), )

pub fn add_callback_on_sys_inotify_add_watch_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, fd: i32, path: u64, mask: u32), )

pub fn remove_callback_on_sys_inotify_add_watch_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, fd: i32, path: u64, mask: u32), )

pub fn add_callback_on_sys_inotify_add_watch_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, fd: i32, path: u64, mask: u32), )

pub fn remove_callback_on_sys_inotify_add_watch_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, fd: i32, path: u64, mask: u32), )

pub fn add_callback_on_sys_inotify_init_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc), )

pub fn remove_callback_on_sys_inotify_init_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc), )

pub fn add_callback_on_sys_inotify_init_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc), )

pub fn remove_callback_on_sys_inotify_init_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc), )

pub fn add_callback_on_sys_inotify_init1_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, flags: i32), )

pub fn remove_callback_on_sys_inotify_init1_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, flags: i32), )

pub fn add_callback_on_sys_inotify_init1_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, flags: i32), )

pub fn remove_callback_on_sys_inotify_init1_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, flags: i32), )

pub fn add_callback_on_sys_inotify_rm_watch_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, fd: i32, wd: i32), )

pub fn remove_callback_on_sys_inotify_rm_watch_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, fd: i32, wd: i32), )

pub fn add_callback_on_sys_inotify_rm_watch_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, fd: i32, wd: i32), )

pub fn remove_callback_on_sys_inotify_rm_watch_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, fd: i32, wd: i32), )

pub fn add_callback_on_sys_io_cancel_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, ctx_id: u64, iocb: u64, result: u64), )

pub fn remove_callback_on_sys_io_cancel_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, ctx_id: u64, iocb: u64, result: u64), )

pub fn add_callback_on_sys_io_cancel_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, ctx_id: u64, iocb: u64, result: u64), )

pub fn remove_callback_on_sys_io_cancel_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, ctx_id: u64, iocb: u64, result: u64), )

pub fn add_callback_on_sys_io_destroy_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, ctx: u64), )

pub fn remove_callback_on_sys_io_destroy_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, ctx: u64), )

pub fn add_callback_on_sys_io_destroy_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, ctx: u64), )

pub fn remove_callback_on_sys_io_destroy_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, ctx: u64), )

pub fn add_callback_on_sys_io_getevents_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, ctx_id: u64, min_nr: i64, nr: i64, events: u64, timeout: u64), )

pub fn remove_callback_on_sys_io_getevents_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, ctx_id: u64, min_nr: i64, nr: i64, events: u64, timeout: u64), )

pub fn add_callback_on_sys_io_getevents_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, ctx_id: u64, min_nr: i64, nr: i64, events: u64, timeout: u64), )

pub fn remove_callback_on_sys_io_getevents_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, ctx_id: u64, min_nr: i64, nr: i64, events: u64, timeout: u64), )

pub fn add_callback_on_sys_io_setup_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, nr_reqs: u32, ctx: u64), )

pub fn remove_callback_on_sys_io_setup_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, nr_reqs: u32, ctx: u64), )

pub fn add_callback_on_sys_io_setup_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, nr_reqs: u32, ctx: u64), )

pub fn remove_callback_on_sys_io_setup_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, nr_reqs: u32, ctx: u64), )

pub fn add_callback_on_sys_io_submit_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, arg0: u64, arg1: i64, arg2: u64), )

pub fn remove_callback_on_sys_io_submit_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, arg0: u64, arg1: i64, arg2: u64), )

pub fn add_callback_on_sys_io_submit_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, arg0: u64, arg1: i64, arg2: u64), )

pub fn remove_callback_on_sys_io_submit_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, arg0: u64, arg1: i64, arg2: u64), )

pub fn add_callback_on_sys_ioctl_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, fd: u32, cmd: u32, arg: u64), )

pub fn remove_callback_on_sys_ioctl_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, fd: u32, cmd: u32, arg: u64), )

pub fn add_callback_on_sys_ioctl_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, fd: u32, cmd: u32, arg: u64), )

pub fn remove_callback_on_sys_ioctl_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, fd: u32, cmd: u32, arg: u64), )

pub fn add_callback_on_sys_ioperm_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, arg0: u64, arg1: u64, arg2: i32), )

pub fn remove_callback_on_sys_ioperm_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, arg0: u64, arg1: u64, arg2: i32), )

pub fn add_callback_on_sys_ioperm_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, arg0: u64, arg1: u64, arg2: i32), )

pub fn remove_callback_on_sys_ioperm_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, arg0: u64, arg1: u64, arg2: i32), )

pub fn add_callback_on_sys_iopl_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, arg0: u32), )

pub fn remove_callback_on_sys_iopl_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, arg0: u32), )

pub fn add_callback_on_sys_iopl_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, arg0: u32), )

pub fn remove_callback_on_sys_iopl_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, arg0: u32), )

pub fn add_callback_on_sys_ioprio_get_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, which: i32, who: i32), )

pub fn remove_callback_on_sys_ioprio_get_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, which: i32, who: i32), )

pub fn add_callback_on_sys_ioprio_get_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, which: i32, who: i32), )

pub fn remove_callback_on_sys_ioprio_get_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, which: i32, who: i32), )

pub fn add_callback_on_sys_ioprio_set_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, which: i32, who: i32, ioprio: i32), )

pub fn remove_callback_on_sys_ioprio_set_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, which: i32, who: i32, ioprio: i32), )

pub fn add_callback_on_sys_ioprio_set_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, which: i32, who: i32, ioprio: i32), )

pub fn remove_callback_on_sys_ioprio_set_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, which: i32, who: i32, ioprio: i32), )

pub fn add_callback_on_sys_kcmp_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, pid1: i32, pid2: i32, _type: i32, idx1: u64, idx2: u64), )

pub fn remove_callback_on_sys_kcmp_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, pid1: i32, pid2: i32, _type: i32, idx1: u64, idx2: u64), )

pub fn add_callback_on_sys_kcmp_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, pid1: i32, pid2: i32, _type: i32, idx1: u64, idx2: u64), )

pub fn remove_callback_on_sys_kcmp_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, pid1: i32, pid2: i32, _type: i32, idx1: u64, idx2: u64), )

pub fn add_callback_on_sys_kexec_file_load_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, kernel_fd: i32, initrd_fd: i32, cmdline_len: u64, cmdline_ptr: u64, flags: u64), )

pub fn remove_callback_on_sys_kexec_file_load_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, kernel_fd: i32, initrd_fd: i32, cmdline_len: u64, cmdline_ptr: u64, flags: u64), )

pub fn add_callback_on_sys_kexec_file_load_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, kernel_fd: i32, initrd_fd: i32, cmdline_len: u64, cmdline_ptr: u64, flags: u64), )

pub fn remove_callback_on_sys_kexec_file_load_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, kernel_fd: i32, initrd_fd: i32, cmdline_len: u64, cmdline_ptr: u64, flags: u64), )

pub fn add_callback_on_sys_kexec_load_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, entry: u64, nr_segments: u64, segments: u64, flags: u64), )

pub fn remove_callback_on_sys_kexec_load_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, entry: u64, nr_segments: u64, segments: u64, flags: u64), )

pub fn add_callback_on_sys_kexec_load_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, entry: u64, nr_segments: u64, segments: u64, flags: u64), )

pub fn remove_callback_on_sys_kexec_load_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, entry: u64, nr_segments: u64, segments: u64, flags: u64), )

pub fn add_callback_on_sys_keyctl_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, cmd: i32, arg2: u64, arg3: u64, arg4: u64, arg5: u64), )

pub fn remove_callback_on_sys_keyctl_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, cmd: i32, arg2: u64, arg3: u64, arg4: u64, arg5: u64), )

pub fn add_callback_on_sys_keyctl_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, cmd: i32, arg2: u64, arg3: u64, arg4: u64, arg5: u64), )

pub fn remove_callback_on_sys_keyctl_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, cmd: i32, arg2: u64, arg3: u64, arg4: u64, arg5: u64), )

pub fn add_callback_on_sys_kill_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, pid: i32, sig: i32), )

pub fn remove_callback_on_sys_kill_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, pid: i32, sig: i32), )

pub fn add_callback_on_sys_kill_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, pid: i32, sig: i32), )

pub fn remove_callback_on_sys_kill_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, pid: i32, sig: i32), )

pub fn add_callback_on_sys_lchown_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, filename: u64, user: u32, group: u32), )

pub fn remove_callback_on_sys_lchown_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, filename: u64, user: u32, group: u32), )

pub fn add_callback_on_sys_lchown_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, filename: u64, user: u32, group: u32), )

pub fn remove_callback_on_sys_lchown_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, filename: u64, user: u32, group: u32), )

pub fn add_callback_on_sys_lgetxattr_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, path: u64, name: u64, value: u64, size: u32), )

pub fn remove_callback_on_sys_lgetxattr_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, path: u64, name: u64, value: u64, size: u32), )

pub fn add_callback_on_sys_lgetxattr_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, path: u64, name: u64, value: u64, size: u32), )

pub fn remove_callback_on_sys_lgetxattr_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, path: u64, name: u64, value: u64, size: u32), )

pub fn add_callback_on_sys_link_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, oldname: u64, newname: u64), )

pub fn remove_callback_on_sys_link_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, oldname: u64, newname: u64), )

pub fn add_callback_on_sys_link_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, oldname: u64, newname: u64), )

pub fn remove_callback_on_sys_link_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, oldname: u64, newname: u64), )

pub fn add_callback_on_sys_linkat_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, olddfd: i32, oldname: u64, newdfd: i32, newname: u64, flags: i32), )

pub fn remove_callback_on_sys_linkat_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, olddfd: i32, oldname: u64, newdfd: i32, newname: u64, flags: i32), )

pub fn add_callback_on_sys_linkat_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, olddfd: i32, oldname: u64, newdfd: i32, newname: u64, flags: i32), )

pub fn remove_callback_on_sys_linkat_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, olddfd: i32, oldname: u64, newdfd: i32, newname: u64, flags: i32), )

pub fn add_callback_on_sys_listen_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, arg0: i32, arg1: i32), )

pub fn remove_callback_on_sys_listen_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, arg0: i32, arg1: i32), )

pub fn add_callback_on_sys_listen_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, arg0: i32, arg1: i32), )

pub fn remove_callback_on_sys_listen_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, arg0: i32, arg1: i32), )

pub fn add_callback_on_sys_listxattr_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, path: u64, list: u64, size: u32), )

pub fn remove_callback_on_sys_listxattr_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, path: u64, list: u64, size: u32), )

pub fn add_callback_on_sys_listxattr_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, path: u64, list: u64, size: u32), )

pub fn remove_callback_on_sys_listxattr_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, path: u64, list: u64, size: u32), )

pub fn add_callback_on_sys_llistxattr_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, path: u64, list: u64, size: u32), )

pub fn remove_callback_on_sys_llistxattr_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, path: u64, list: u64, size: u32), )

pub fn add_callback_on_sys_llistxattr_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, path: u64, list: u64, size: u32), )

pub fn remove_callback_on_sys_llistxattr_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, path: u64, list: u64, size: u32), )

pub fn add_callback_on_sys_lookup_dcookie_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, cookie64: u64, buf: u64, len: u32), )

pub fn remove_callback_on_sys_lookup_dcookie_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, cookie64: u64, buf: u64, len: u32), )

pub fn add_callback_on_sys_lookup_dcookie_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, cookie64: u64, buf: u64, len: u32), )

pub fn remove_callback_on_sys_lookup_dcookie_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, cookie64: u64, buf: u64, len: u32), )

pub fn add_callback_on_sys_lremovexattr_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, path: u64, name: u64), )

pub fn remove_callback_on_sys_lremovexattr_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, path: u64, name: u64), )

pub fn add_callback_on_sys_lremovexattr_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, path: u64, name: u64), )

pub fn remove_callback_on_sys_lremovexattr_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, path: u64, name: u64), )

pub fn add_callback_on_sys_lseek_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, fd: u32, offset: u64, whence: u32), )

pub fn remove_callback_on_sys_lseek_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, fd: u32, offset: u64, whence: u32), )

pub fn add_callback_on_sys_lseek_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, fd: u32, offset: u64, whence: u32), )

pub fn remove_callback_on_sys_lseek_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, fd: u32, offset: u64, whence: u32), )

pub fn add_callback_on_sys_lsetxattr_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, path: u64, name: u64, value: u64, size: u32, flags: i32), )

pub fn remove_callback_on_sys_lsetxattr_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, path: u64, name: u64, value: u64, size: u32, flags: i32), )

pub fn add_callback_on_sys_lsetxattr_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, path: u64, name: u64, value: u64, size: u32, flags: i32), )

pub fn remove_callback_on_sys_lsetxattr_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, path: u64, name: u64, value: u64, size: u32, flags: i32), )

pub fn add_callback_on_sys_madvise_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, start: u64, len: u32, behavior: i32), )

pub fn remove_callback_on_sys_madvise_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, start: u64, len: u32, behavior: i32), )

pub fn add_callback_on_sys_madvise_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, start: u64, len: u32, behavior: i32), )

pub fn remove_callback_on_sys_madvise_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, start: u64, len: u32, behavior: i32), )

pub fn add_callback_on_sys_mbind_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, start: u64, len: u64, mode: u64, nmask: u64, maxnode: u64, flags: u32), )

pub fn remove_callback_on_sys_mbind_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, start: u64, len: u64, mode: u64, nmask: u64, maxnode: u64, flags: u32), )

pub fn add_callback_on_sys_mbind_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, start: u64, len: u64, mode: u64, nmask: u64, maxnode: u64, flags: u32), )

pub fn remove_callback_on_sys_mbind_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, start: u64, len: u64, mode: u64, nmask: u64, maxnode: u64, flags: u32), )

pub fn add_callback_on_sys_membarrier_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, cmd: i32, flags: i32), )

pub fn remove_callback_on_sys_membarrier_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, cmd: i32, flags: i32), )

pub fn add_callback_on_sys_membarrier_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, cmd: i32, flags: i32), )

pub fn remove_callback_on_sys_membarrier_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, cmd: i32, flags: i32), )

pub fn add_callback_on_sys_memfd_create_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, uname_ptr: u64, flags: u32), )

pub fn remove_callback_on_sys_memfd_create_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, uname_ptr: u64, flags: u32), )

pub fn add_callback_on_sys_memfd_create_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, uname_ptr: u64, flags: u32), )

pub fn remove_callback_on_sys_memfd_create_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, uname_ptr: u64, flags: u32), )

pub fn add_callback_on_sys_migrate_pages_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, pid: i32, maxnode: u64, from: u64, to: u64), )

pub fn remove_callback_on_sys_migrate_pages_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, pid: i32, maxnode: u64, from: u64, to: u64), )

pub fn add_callback_on_sys_migrate_pages_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, pid: i32, maxnode: u64, from: u64, to: u64), )

pub fn remove_callback_on_sys_migrate_pages_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, pid: i32, maxnode: u64, from: u64, to: u64), )

pub fn add_callback_on_sys_mincore_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, start: u64, len: u32, vec: u64), )

pub fn remove_callback_on_sys_mincore_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, start: u64, len: u32, vec: u64), )

pub fn add_callback_on_sys_mincore_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, start: u64, len: u32, vec: u64), )

pub fn remove_callback_on_sys_mincore_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, start: u64, len: u32, vec: u64), )

pub fn add_callback_on_sys_mkdir_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, pathname: u64, mode: u32), )

pub fn remove_callback_on_sys_mkdir_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, pathname: u64, mode: u32), )

pub fn add_callback_on_sys_mkdir_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, pathname: u64, mode: u32), )

pub fn remove_callback_on_sys_mkdir_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, pathname: u64, mode: u32), )

pub fn add_callback_on_sys_mkdirat_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, dfd: i32, pathname: u64, mode: u32), )

pub fn remove_callback_on_sys_mkdirat_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, dfd: i32, pathname: u64, mode: u32), )

pub fn add_callback_on_sys_mkdirat_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, dfd: i32, pathname: u64, mode: u32), )

pub fn remove_callback_on_sys_mkdirat_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, dfd: i32, pathname: u64, mode: u32), )

pub fn add_callback_on_sys_mknod_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, filename: u64, mode: u32, dev: u32), )

pub fn remove_callback_on_sys_mknod_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, filename: u64, mode: u32, dev: u32), )

pub fn add_callback_on_sys_mknod_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, filename: u64, mode: u32, dev: u32), )

pub fn remove_callback_on_sys_mknod_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, filename: u64, mode: u32, dev: u32), )

pub fn add_callback_on_sys_mknodat_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, dfd: i32, filename: u64, mode: u32, dev: u32), )

pub fn remove_callback_on_sys_mknodat_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, dfd: i32, filename: u64, mode: u32, dev: u32), )

pub fn add_callback_on_sys_mknodat_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, dfd: i32, filename: u64, mode: u32, dev: u32), )

pub fn remove_callback_on_sys_mknodat_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, dfd: i32, filename: u64, mode: u32, dev: u32), )

pub fn add_callback_on_sys_mlock_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, start: u64, len: u32), )

pub fn remove_callback_on_sys_mlock_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, start: u64, len: u32), )

pub fn add_callback_on_sys_mlock_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, start: u64, len: u32), )

pub fn remove_callback_on_sys_mlock_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, start: u64, len: u32), )

pub fn add_callback_on_sys_mlock2_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, start: u64, len: u32, flags: i32), )

pub fn remove_callback_on_sys_mlock2_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, start: u64, len: u32, flags: i32), )

pub fn add_callback_on_sys_mlock2_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, start: u64, len: u32, flags: i32), )

pub fn remove_callback_on_sys_mlock2_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, start: u64, len: u32, flags: i32), )

pub fn add_callback_on_sys_mlockall_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, flags: i32), )

pub fn remove_callback_on_sys_mlockall_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, flags: i32), )

pub fn add_callback_on_sys_mlockall_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, flags: i32), )

pub fn remove_callback_on_sys_mlockall_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, flags: i32), )

pub fn add_callback_on_sys_mmap_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, arg0: u64, arg1: u64, arg2: u64, arg3: u64, arg4: u64, arg5: u64), )

pub fn remove_callback_on_sys_mmap_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, arg0: u64, arg1: u64, arg2: u64, arg3: u64, arg4: u64, arg5: u64), )

pub fn add_callback_on_sys_mmap_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, arg0: u64, arg1: u64, arg2: u64, arg3: u64, arg4: u64, arg5: u64), )

pub fn remove_callback_on_sys_mmap_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, arg0: u64, arg1: u64, arg2: u64, arg3: u64, arg4: u64, arg5: u64), )

pub fn add_callback_on_sys_modify_ldt_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, arg0: i32, arg1: u64, arg2: u64), )

pub fn remove_callback_on_sys_modify_ldt_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, arg0: i32, arg1: u64, arg2: u64), )

pub fn add_callback_on_sys_modify_ldt_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, arg0: i32, arg1: u64, arg2: u64), )

pub fn remove_callback_on_sys_modify_ldt_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, arg0: i32, arg1: u64, arg2: u64), )

pub fn add_callback_on_sys_mount_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, dev_name: u64, dir_name: u64, _type: u64, flags: u64, _data: u64), )

pub fn remove_callback_on_sys_mount_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, dev_name: u64, dir_name: u64, _type: u64, flags: u64, _data: u64), )

pub fn add_callback_on_sys_mount_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, dev_name: u64, dir_name: u64, _type: u64, flags: u64, _data: u64), )

pub fn remove_callback_on_sys_mount_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, dev_name: u64, dir_name: u64, _type: u64, flags: u64, _data: u64), )

pub fn add_callback_on_sys_move_pages_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, pid: i32, nr_pages: u64, pages: u64, nodes: u64, status: u64, flags: i32), )

pub fn remove_callback_on_sys_move_pages_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, pid: i32, nr_pages: u64, pages: u64, nodes: u64, status: u64, flags: i32), )

pub fn add_callback_on_sys_move_pages_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, pid: i32, nr_pages: u64, pages: u64, nodes: u64, status: u64, flags: i32), )

pub fn remove_callback_on_sys_move_pages_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, pid: i32, nr_pages: u64, pages: u64, nodes: u64, status: u64, flags: i32), )

pub fn add_callback_on_sys_mprotect_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, start: u64, len: u32, prot: u64), )

pub fn remove_callback_on_sys_mprotect_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, start: u64, len: u32, prot: u64), )

pub fn add_callback_on_sys_mprotect_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, start: u64, len: u32, prot: u64), )

pub fn remove_callback_on_sys_mprotect_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, start: u64, len: u32, prot: u64), )

pub fn add_callback_on_sys_mq_getsetattr_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, mqdes: u32, mqstat: u64, omqstat: u64), )

pub fn remove_callback_on_sys_mq_getsetattr_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, mqdes: u32, mqstat: u64, omqstat: u64), )

pub fn add_callback_on_sys_mq_getsetattr_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, mqdes: u32, mqstat: u64, omqstat: u64), )

pub fn remove_callback_on_sys_mq_getsetattr_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, mqdes: u32, mqstat: u64, omqstat: u64), )

pub fn add_callback_on_sys_mq_notify_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, mqdes: u32, notification: u64), )

pub fn remove_callback_on_sys_mq_notify_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, mqdes: u32, notification: u64), )

pub fn add_callback_on_sys_mq_notify_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, mqdes: u32, notification: u64), )

pub fn remove_callback_on_sys_mq_notify_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, mqdes: u32, notification: u64), )

pub fn add_callback_on_sys_mq_open_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, name: u64, oflag: i32, mode: u32, attr: u64), )

pub fn remove_callback_on_sys_mq_open_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, name: u64, oflag: i32, mode: u32, attr: u64), )

pub fn add_callback_on_sys_mq_open_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, name: u64, oflag: i32, mode: u32, attr: u64), )

pub fn remove_callback_on_sys_mq_open_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, name: u64, oflag: i32, mode: u32, attr: u64), )

pub fn add_callback_on_sys_mq_timedreceive_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, mqdes: u32, msg_ptr: u64, msg_len: u32, msg_prio: u64, abs_timeout: u64), )

pub fn remove_callback_on_sys_mq_timedreceive_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, mqdes: u32, msg_ptr: u64, msg_len: u32, msg_prio: u64, abs_timeout: u64), )

pub fn add_callback_on_sys_mq_timedreceive_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, mqdes: u32, msg_ptr: u64, msg_len: u32, msg_prio: u64, abs_timeout: u64), )

pub fn remove_callback_on_sys_mq_timedreceive_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, mqdes: u32, msg_ptr: u64, msg_len: u32, msg_prio: u64, abs_timeout: u64), )

pub fn add_callback_on_sys_mq_timedsend_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, mqdes: u32, msg_ptr: u64, msg_len: u32, msg_prio: u32, abs_timeout: u64), )

pub fn remove_callback_on_sys_mq_timedsend_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, mqdes: u32, msg_ptr: u64, msg_len: u32, msg_prio: u32, abs_timeout: u64), )

pub fn add_callback_on_sys_mq_timedsend_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, mqdes: u32, msg_ptr: u64, msg_len: u32, msg_prio: u32, abs_timeout: u64), )

pub fn remove_callback_on_sys_mq_timedsend_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, mqdes: u32, msg_ptr: u64, msg_len: u32, msg_prio: u32, abs_timeout: u64), )

pub fn add_callback_on_sys_mq_unlink_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, name: u64), )

pub fn remove_callback_on_sys_mq_unlink_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, name: u64), )

pub fn add_callback_on_sys_mq_unlink_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, name: u64), )

pub fn remove_callback_on_sys_mq_unlink_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, name: u64), )

pub fn add_callback_on_sys_mremap_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, addr: u64, old_len: u64, new_len: u64, flags: u64, new_addr: u64), )

pub fn remove_callback_on_sys_mremap_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, addr: u64, old_len: u64, new_len: u64, flags: u64, new_addr: u64), )

pub fn add_callback_on_sys_mremap_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, addr: u64, old_len: u64, new_len: u64, flags: u64, new_addr: u64), )

pub fn remove_callback_on_sys_mremap_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, addr: u64, old_len: u64, new_len: u64, flags: u64, new_addr: u64), )

pub fn add_callback_on_sys_msgctl_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, msqid: i32, cmd: i32, buf: u64), )

pub fn remove_callback_on_sys_msgctl_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, msqid: i32, cmd: i32, buf: u64), )

pub fn add_callback_on_sys_msgctl_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, msqid: i32, cmd: i32, buf: u64), )

pub fn remove_callback_on_sys_msgctl_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, msqid: i32, cmd: i32, buf: u64), )

pub fn add_callback_on_sys_msgget_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, key: u32, msgflg: i32), )

pub fn remove_callback_on_sys_msgget_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, key: u32, msgflg: i32), )

pub fn add_callback_on_sys_msgget_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, key: u32, msgflg: i32), )

pub fn remove_callback_on_sys_msgget_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, key: u32, msgflg: i32), )

pub fn add_callback_on_sys_msgrcv_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, msqid: i32, msgp: u64, msgsz: u32, msgtyp: i64, msgflg: i32), )

pub fn remove_callback_on_sys_msgrcv_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, msqid: i32, msgp: u64, msgsz: u32, msgtyp: i64, msgflg: i32), )

pub fn add_callback_on_sys_msgrcv_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, msqid: i32, msgp: u64, msgsz: u32, msgtyp: i64, msgflg: i32), )

pub fn remove_callback_on_sys_msgrcv_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, msqid: i32, msgp: u64, msgsz: u32, msgtyp: i64, msgflg: i32), )

pub fn add_callback_on_sys_msgsnd_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, msqid: i32, msgp: u64, msgsz: u32, msgflg: i32), )

pub fn remove_callback_on_sys_msgsnd_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, msqid: i32, msgp: u64, msgsz: u32, msgflg: i32), )

pub fn add_callback_on_sys_msgsnd_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, msqid: i32, msgp: u64, msgsz: u32, msgflg: i32), )

pub fn remove_callback_on_sys_msgsnd_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, msqid: i32, msgp: u64, msgsz: u32, msgflg: i32), )

pub fn add_callback_on_sys_msync_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, start: u64, len: u32, flags: i32), )

pub fn remove_callback_on_sys_msync_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, start: u64, len: u32, flags: i32), )

pub fn add_callback_on_sys_msync_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, start: u64, len: u32, flags: i32), )

pub fn remove_callback_on_sys_msync_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, start: u64, len: u32, flags: i32), )

pub fn add_callback_on_sys_munlock_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, start: u64, len: u32), )

pub fn remove_callback_on_sys_munlock_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, start: u64, len: u32), )

pub fn add_callback_on_sys_munlock_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, start: u64, len: u32), )

pub fn remove_callback_on_sys_munlock_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, start: u64, len: u32), )

pub fn add_callback_on_sys_munlockall_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc), )

pub fn remove_callback_on_sys_munlockall_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc), )

pub fn add_callback_on_sys_munlockall_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc), )

pub fn remove_callback_on_sys_munlockall_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc), )

pub fn add_callback_on_sys_munmap_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, addr: u64, len: u32), )

pub fn remove_callback_on_sys_munmap_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, addr: u64, len: u32), )

pub fn add_callback_on_sys_munmap_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, addr: u64, len: u32), )

pub fn remove_callback_on_sys_munmap_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, addr: u64, len: u32), )

pub fn add_callback_on_sys_name_to_handle_at_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, dfd: i32, name: u64, handle: u64, mnt_id: u64, flag: i32), )

pub fn remove_callback_on_sys_name_to_handle_at_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, dfd: i32, name: u64, handle: u64, mnt_id: u64, flag: i32), )

pub fn add_callback_on_sys_name_to_handle_at_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, dfd: i32, name: u64, handle: u64, mnt_id: u64, flag: i32), )

pub fn remove_callback_on_sys_name_to_handle_at_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, dfd: i32, name: u64, handle: u64, mnt_id: u64, flag: i32), )

pub fn add_callback_on_sys_nanosleep_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, rqtp: u64, rmtp: u64), )

pub fn remove_callback_on_sys_nanosleep_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, rqtp: u64, rmtp: u64), )

pub fn add_callback_on_sys_nanosleep_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, rqtp: u64, rmtp: u64), )

pub fn remove_callback_on_sys_nanosleep_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, rqtp: u64, rmtp: u64), )

pub fn add_callback_on_sys_newfstat_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, fd: u32, statbuf: u64), )

pub fn remove_callback_on_sys_newfstat_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, fd: u32, statbuf: u64), )

pub fn add_callback_on_sys_newfstat_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, fd: u32, statbuf: u64), )

pub fn remove_callback_on_sys_newfstat_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, fd: u32, statbuf: u64), )

pub fn add_callback_on_sys_newfstatat_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, dfd: i32, filename: u64, statbuf: u64, flag: i32), )

pub fn remove_callback_on_sys_newfstatat_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, dfd: i32, filename: u64, statbuf: u64, flag: i32), )

pub fn add_callback_on_sys_newfstatat_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, dfd: i32, filename: u64, statbuf: u64, flag: i32), )

pub fn remove_callback_on_sys_newfstatat_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, dfd: i32, filename: u64, statbuf: u64, flag: i32), )

pub fn add_callback_on_sys_newlstat_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, filename: u64, statbuf: u64), )

pub fn remove_callback_on_sys_newlstat_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, filename: u64, statbuf: u64), )

pub fn add_callback_on_sys_newlstat_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, filename: u64, statbuf: u64), )

pub fn remove_callback_on_sys_newlstat_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, filename: u64, statbuf: u64), )

pub fn add_callback_on_sys_newstat_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, filename: u64, statbuf: u64), )

pub fn remove_callback_on_sys_newstat_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, filename: u64, statbuf: u64), )

pub fn add_callback_on_sys_newstat_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, filename: u64, statbuf: u64), )

pub fn remove_callback_on_sys_newstat_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, filename: u64, statbuf: u64), )

pub fn add_callback_on_sys_newuname_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, name: u64), )

pub fn remove_callback_on_sys_newuname_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, name: u64), )

pub fn add_callback_on_sys_newuname_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, name: u64), )

pub fn remove_callback_on_sys_newuname_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, name: u64), )

pub fn add_callback_on_sys_open_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, filename: u64, flags: i32, mode: u32), )

pub fn remove_callback_on_sys_open_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, filename: u64, flags: i32, mode: u32), )

pub fn add_callback_on_sys_open_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, filename: u64, flags: i32, mode: u32), )

pub fn remove_callback_on_sys_open_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, filename: u64, flags: i32, mode: u32), )

pub fn add_callback_on_sys_open_by_handle_at_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, mountdirfd: i32, handle: u64, flags: i32), )

pub fn remove_callback_on_sys_open_by_handle_at_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, mountdirfd: i32, handle: u64, flags: i32), )

pub fn add_callback_on_sys_open_by_handle_at_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, mountdirfd: i32, handle: u64, flags: i32), )

pub fn remove_callback_on_sys_open_by_handle_at_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, mountdirfd: i32, handle: u64, flags: i32), )

pub fn add_callback_on_sys_openat_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, dfd: i32, filename: u64, flags: i32, mode: u32), )

pub fn remove_callback_on_sys_openat_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, dfd: i32, filename: u64, flags: i32, mode: u32), )

pub fn add_callback_on_sys_openat_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, dfd: i32, filename: u64, flags: i32, mode: u32), )

pub fn remove_callback_on_sys_openat_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, dfd: i32, filename: u64, flags: i32, mode: u32), )

pub fn add_callback_on_sys_pause_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc), )

pub fn remove_callback_on_sys_pause_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc), )

pub fn add_callback_on_sys_pause_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc), )

pub fn remove_callback_on_sys_pause_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc), )

pub fn add_callback_on_sys_perf_event_open_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, attr_uptr: u64, pid: i32, _cpu: i32, group_fd: i32, flags: u64), )

pub fn remove_callback_on_sys_perf_event_open_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, attr_uptr: u64, pid: i32, _cpu: i32, group_fd: i32, flags: u64), )

pub fn add_callback_on_sys_perf_event_open_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, attr_uptr: u64, pid: i32, _cpu: i32, group_fd: i32, flags: u64), )

pub fn remove_callback_on_sys_perf_event_open_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, attr_uptr: u64, pid: i32, _cpu: i32, group_fd: i32, flags: u64), )

pub fn add_callback_on_sys_personality_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, personality: u32), )

pub fn remove_callback_on_sys_personality_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, personality: u32), )

pub fn add_callback_on_sys_personality_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, personality: u32), )

pub fn remove_callback_on_sys_personality_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, personality: u32), )

pub fn add_callback_on_sys_pipe_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, fildes: u64), )

pub fn remove_callback_on_sys_pipe_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, fildes: u64), )

pub fn add_callback_on_sys_pipe_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, fildes: u64), )

pub fn remove_callback_on_sys_pipe_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, fildes: u64), )

pub fn add_callback_on_sys_pipe2_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, fildes: u64, flags: i32), )

pub fn remove_callback_on_sys_pipe2_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, fildes: u64, flags: i32), )

pub fn add_callback_on_sys_pipe2_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, fildes: u64, flags: i32), )

pub fn remove_callback_on_sys_pipe2_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, fildes: u64, flags: i32), )

pub fn add_callback_on_sys_pivot_root_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, new_root: u64, put_old: u64), )

pub fn remove_callback_on_sys_pivot_root_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, new_root: u64, put_old: u64), )

pub fn add_callback_on_sys_pivot_root_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, new_root: u64, put_old: u64), )

pub fn remove_callback_on_sys_pivot_root_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, new_root: u64, put_old: u64), )

pub fn add_callback_on_sys_pkey_alloc_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, flags: u64, init_val: u64), )

pub fn remove_callback_on_sys_pkey_alloc_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, flags: u64, init_val: u64), )

pub fn add_callback_on_sys_pkey_alloc_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, flags: u64, init_val: u64), )

pub fn remove_callback_on_sys_pkey_alloc_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, flags: u64, init_val: u64), )

pub fn add_callback_on_sys_pkey_free_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, pkey: i32), )

pub fn remove_callback_on_sys_pkey_free_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, pkey: i32), )

pub fn add_callback_on_sys_pkey_free_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, pkey: i32), )

pub fn remove_callback_on_sys_pkey_free_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, pkey: i32), )

pub fn add_callback_on_sys_pkey_mprotect_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, start: u64, len: u32, prot: u64, pkey: i32), )

pub fn remove_callback_on_sys_pkey_mprotect_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, start: u64, len: u32, prot: u64, pkey: i32), )

pub fn add_callback_on_sys_pkey_mprotect_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, start: u64, len: u32, prot: u64, pkey: i32), )

pub fn remove_callback_on_sys_pkey_mprotect_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, start: u64, len: u32, prot: u64, pkey: i32), )

pub fn add_callback_on_sys_poll_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, ufds: u64, nfds: u32, timeout: i32), )

pub fn remove_callback_on_sys_poll_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, ufds: u64, nfds: u32, timeout: i32), )

pub fn add_callback_on_sys_poll_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, ufds: u64, nfds: u32, timeout: i32), )

pub fn remove_callback_on_sys_poll_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, ufds: u64, nfds: u32, timeout: i32), )

pub fn add_callback_on_sys_ppoll_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, arg0: u64, arg1: u32, arg2: u64, arg3: u64, arg4: u32), )

pub fn remove_callback_on_sys_ppoll_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, arg0: u64, arg1: u32, arg2: u64, arg3: u64, arg4: u32), )

pub fn add_callback_on_sys_ppoll_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, arg0: u64, arg1: u32, arg2: u64, arg3: u64, arg4: u32), )

pub fn remove_callback_on_sys_ppoll_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, arg0: u64, arg1: u32, arg2: u64, arg3: u64, arg4: u32), )

pub fn add_callback_on_sys_prctl_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, option: i32, arg2: u64, arg3: u64, arg4: u64, arg5: u64), )

pub fn remove_callback_on_sys_prctl_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, option: i32, arg2: u64, arg3: u64, arg4: u64, arg5: u64), )

pub fn add_callback_on_sys_prctl_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, option: i32, arg2: u64, arg3: u64, arg4: u64, arg5: u64), )

pub fn remove_callback_on_sys_prctl_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, option: i32, arg2: u64, arg3: u64, arg4: u64, arg5: u64), )

pub fn add_callback_on_sys_pread64_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, fd: u32, buf: u64, count: u32, pos: u64), )

pub fn remove_callback_on_sys_pread64_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, fd: u32, buf: u64, count: u32, pos: u64), )

pub fn add_callback_on_sys_pread64_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, fd: u32, buf: u64, count: u32, pos: u64), )

pub fn remove_callback_on_sys_pread64_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, fd: u32, buf: u64, count: u32, pos: u64), )

pub fn add_callback_on_sys_preadv_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, fd: u64, vec: u64, vlen: u64, pos_l: u64, pos_h: u64), )

pub fn remove_callback_on_sys_preadv_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, fd: u64, vec: u64, vlen: u64, pos_l: u64, pos_h: u64), )

pub fn add_callback_on_sys_preadv_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, fd: u64, vec: u64, vlen: u64, pos_l: u64, pos_h: u64), )

pub fn remove_callback_on_sys_preadv_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, fd: u64, vec: u64, vlen: u64, pos_l: u64, pos_h: u64), )

pub fn add_callback_on_sys_preadv2_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, fd: u64, vec: u64, vlen: u64, pos_l: u64, pos_h: u64, flags: u32), )

pub fn remove_callback_on_sys_preadv2_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, fd: u64, vec: u64, vlen: u64, pos_l: u64, pos_h: u64, flags: u32), )

pub fn add_callback_on_sys_preadv2_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, fd: u64, vec: u64, vlen: u64, pos_l: u64, pos_h: u64, flags: u32), )

pub fn remove_callback_on_sys_preadv2_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, fd: u64, vec: u64, vlen: u64, pos_l: u64, pos_h: u64, flags: u32), )

pub fn add_callback_on_sys_prlimit64_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, pid: i32, resource: u32, new_rlim: u64, old_rlim: u64), )

pub fn remove_callback_on_sys_prlimit64_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, pid: i32, resource: u32, new_rlim: u64, old_rlim: u64), )

pub fn add_callback_on_sys_prlimit64_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, pid: i32, resource: u32, new_rlim: u64, old_rlim: u64), )

pub fn remove_callback_on_sys_prlimit64_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, pid: i32, resource: u32, new_rlim: u64, old_rlim: u64), )

pub fn add_callback_on_sys_process_vm_readv_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, pid: i32, lvec: u64, liovcnt: u64, rvec: u64, riovcnt: u64, flags: u64), )

pub fn remove_callback_on_sys_process_vm_readv_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, pid: i32, lvec: u64, liovcnt: u64, rvec: u64, riovcnt: u64, flags: u64), )

pub fn add_callback_on_sys_process_vm_readv_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, pid: i32, lvec: u64, liovcnt: u64, rvec: u64, riovcnt: u64, flags: u64), )

pub fn remove_callback_on_sys_process_vm_readv_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, pid: i32, lvec: u64, liovcnt: u64, rvec: u64, riovcnt: u64, flags: u64), )

pub fn add_callback_on_sys_process_vm_writev_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, pid: i32, lvec: u64, liovcnt: u64, rvec: u64, riovcnt: u64, flags: u64), )

pub fn remove_callback_on_sys_process_vm_writev_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, pid: i32, lvec: u64, liovcnt: u64, rvec: u64, riovcnt: u64, flags: u64), )

pub fn add_callback_on_sys_process_vm_writev_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, pid: i32, lvec: u64, liovcnt: u64, rvec: u64, riovcnt: u64, flags: u64), )

pub fn remove_callback_on_sys_process_vm_writev_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, pid: i32, lvec: u64, liovcnt: u64, rvec: u64, riovcnt: u64, flags: u64), )

pub fn add_callback_on_sys_pselect6_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, arg0: i32, arg1: u64, arg2: u64, arg3: u64, arg4: u64, arg5: u64), )

pub fn remove_callback_on_sys_pselect6_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, arg0: i32, arg1: u64, arg2: u64, arg3: u64, arg4: u64, arg5: u64), )

pub fn add_callback_on_sys_pselect6_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, arg0: i32, arg1: u64, arg2: u64, arg3: u64, arg4: u64, arg5: u64), )

pub fn remove_callback_on_sys_pselect6_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, arg0: i32, arg1: u64, arg2: u64, arg3: u64, arg4: u64, arg5: u64), )

pub fn add_callback_on_sys_ptrace_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, request: i64, pid: i64, addr: u64, _data: u64), )

pub fn remove_callback_on_sys_ptrace_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, request: i64, pid: i64, addr: u64, _data: u64), )

pub fn add_callback_on_sys_ptrace_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, request: i64, pid: i64, addr: u64, _data: u64), )

pub fn remove_callback_on_sys_ptrace_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, request: i64, pid: i64, addr: u64, _data: u64), )

pub fn add_callback_on_sys_pwrite64_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, fd: u32, buf: u64, count: u32, pos: u64), )

pub fn remove_callback_on_sys_pwrite64_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, fd: u32, buf: u64, count: u32, pos: u64), )

pub fn add_callback_on_sys_pwrite64_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, fd: u32, buf: u64, count: u32, pos: u64), )

pub fn remove_callback_on_sys_pwrite64_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, fd: u32, buf: u64, count: u32, pos: u64), )

pub fn add_callback_on_sys_pwritev_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, fd: u64, vec: u64, vlen: u64, pos_l: u64, pos_h: u64), )

pub fn remove_callback_on_sys_pwritev_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, fd: u64, vec: u64, vlen: u64, pos_l: u64, pos_h: u64), )

pub fn add_callback_on_sys_pwritev_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, fd: u64, vec: u64, vlen: u64, pos_l: u64, pos_h: u64), )

pub fn remove_callback_on_sys_pwritev_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, fd: u64, vec: u64, vlen: u64, pos_l: u64, pos_h: u64), )

pub fn add_callback_on_sys_pwritev2_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, fd: u64, vec: u64, vlen: u64, pos_l: u64, pos_h: u64, flags: u32), )

pub fn remove_callback_on_sys_pwritev2_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, fd: u64, vec: u64, vlen: u64, pos_l: u64, pos_h: u64, flags: u32), )

pub fn add_callback_on_sys_pwritev2_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, fd: u64, vec: u64, vlen: u64, pos_l: u64, pos_h: u64, flags: u32), )

pub fn remove_callback_on_sys_pwritev2_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, fd: u64, vec: u64, vlen: u64, pos_l: u64, pos_h: u64, flags: u32), )

pub fn add_callback_on_sys_quotactl_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, cmd: u32, special: u64, id: u32, addr: u64), )

pub fn remove_callback_on_sys_quotactl_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, cmd: u32, special: u64, id: u32, addr: u64), )

pub fn add_callback_on_sys_quotactl_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, cmd: u32, special: u64, id: u32, addr: u64), )

pub fn remove_callback_on_sys_quotactl_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, cmd: u32, special: u64, id: u32, addr: u64), )

pub fn add_callback_on_sys_read_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, fd: u32, buf: u64, count: u32), )

pub fn remove_callback_on_sys_read_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, fd: u32, buf: u64, count: u32), )

pub fn add_callback_on_sys_read_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, fd: u32, buf: u64, count: u32), )

pub fn remove_callback_on_sys_read_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, fd: u32, buf: u64, count: u32), )

pub fn add_callback_on_sys_readahead_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, fd: i32, offset: u64, count: u32), )

pub fn remove_callback_on_sys_readahead_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, fd: i32, offset: u64, count: u32), )

pub fn add_callback_on_sys_readahead_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, fd: i32, offset: u64, count: u32), )

pub fn remove_callback_on_sys_readahead_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, fd: i32, offset: u64, count: u32), )

pub fn add_callback_on_sys_readlink_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, path: u64, buf: u64, bufsiz: i32), )

pub fn remove_callback_on_sys_readlink_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, path: u64, buf: u64, bufsiz: i32), )

pub fn add_callback_on_sys_readlink_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, path: u64, buf: u64, bufsiz: i32), )

pub fn remove_callback_on_sys_readlink_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, path: u64, buf: u64, bufsiz: i32), )

pub fn add_callback_on_sys_readlinkat_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, dfd: i32, path: u64, buf: u64, bufsiz: i32), )

pub fn remove_callback_on_sys_readlinkat_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, dfd: i32, path: u64, buf: u64, bufsiz: i32), )

pub fn add_callback_on_sys_readlinkat_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, dfd: i32, path: u64, buf: u64, bufsiz: i32), )

pub fn remove_callback_on_sys_readlinkat_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, dfd: i32, path: u64, buf: u64, bufsiz: i32), )

pub fn add_callback_on_sys_readv_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, fd: u64, vec: u64, vlen: u64), )

pub fn remove_callback_on_sys_readv_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, fd: u64, vec: u64, vlen: u64), )

pub fn add_callback_on_sys_readv_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, fd: u64, vec: u64, vlen: u64), )

pub fn remove_callback_on_sys_readv_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, fd: u64, vec: u64, vlen: u64), )

pub fn add_callback_on_sys_reboot_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, magic1: i32, magic2: i32, cmd: u32, arg: u64), )

pub fn remove_callback_on_sys_reboot_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, magic1: i32, magic2: i32, cmd: u32, arg: u64), )

pub fn add_callback_on_sys_reboot_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, magic1: i32, magic2: i32, cmd: u32, arg: u64), )

pub fn remove_callback_on_sys_reboot_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, magic1: i32, magic2: i32, cmd: u32, arg: u64), )

pub fn add_callback_on_sys_recvfrom_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, arg0: i32, arg1: u64, arg2: u32, arg3: u32, arg4: u64, arg5: u64), )

pub fn remove_callback_on_sys_recvfrom_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, arg0: i32, arg1: u64, arg2: u32, arg3: u32, arg4: u64, arg5: u64), )

pub fn add_callback_on_sys_recvfrom_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, arg0: i32, arg1: u64, arg2: u32, arg3: u32, arg4: u64, arg5: u64), )

pub fn remove_callback_on_sys_recvfrom_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, arg0: i32, arg1: u64, arg2: u32, arg3: u32, arg4: u64, arg5: u64), )

pub fn add_callback_on_sys_recvmmsg_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, fd: i32, msg: u64, vlen: u32, flags: u32, timeout: u64), )

pub fn remove_callback_on_sys_recvmmsg_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, fd: i32, msg: u64, vlen: u32, flags: u32, timeout: u64), )

pub fn add_callback_on_sys_recvmmsg_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, fd: i32, msg: u64, vlen: u32, flags: u32, timeout: u64), )

pub fn remove_callback_on_sys_recvmmsg_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, fd: i32, msg: u64, vlen: u32, flags: u32, timeout: u64), )

pub fn add_callback_on_sys_recvmsg_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, fd: i32, msg: u64, flags: u32), )

pub fn remove_callback_on_sys_recvmsg_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, fd: i32, msg: u64, flags: u32), )

pub fn add_callback_on_sys_recvmsg_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, fd: i32, msg: u64, flags: u32), )

pub fn remove_callback_on_sys_recvmsg_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, fd: i32, msg: u64, flags: u32), )

pub fn add_callback_on_sys_remap_file_pages_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, start: u64, size: u64, prot: u64, pgoff: u64, flags: u64), )

pub fn remove_callback_on_sys_remap_file_pages_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, start: u64, size: u64, prot: u64, pgoff: u64, flags: u64), )

pub fn add_callback_on_sys_remap_file_pages_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, start: u64, size: u64, prot: u64, pgoff: u64, flags: u64), )

pub fn remove_callback_on_sys_remap_file_pages_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, start: u64, size: u64, prot: u64, pgoff: u64, flags: u64), )

pub fn add_callback_on_sys_removexattr_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, path: u64, name: u64), )

pub fn remove_callback_on_sys_removexattr_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, path: u64, name: u64), )

pub fn add_callback_on_sys_removexattr_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, path: u64, name: u64), )

pub fn remove_callback_on_sys_removexattr_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, path: u64, name: u64), )

pub fn add_callback_on_sys_rename_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, oldname: u64, newname: u64), )

pub fn remove_callback_on_sys_rename_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, oldname: u64, newname: u64), )

pub fn add_callback_on_sys_rename_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, oldname: u64, newname: u64), )

pub fn remove_callback_on_sys_rename_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, oldname: u64, newname: u64), )

pub fn add_callback_on_sys_renameat_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, olddfd: i32, oldname: u64, newdfd: i32, newname: u64), )

pub fn remove_callback_on_sys_renameat_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, olddfd: i32, oldname: u64, newdfd: i32, newname: u64), )

pub fn add_callback_on_sys_renameat_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, olddfd: i32, oldname: u64, newdfd: i32, newname: u64), )

pub fn remove_callback_on_sys_renameat_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, olddfd: i32, oldname: u64, newdfd: i32, newname: u64), )

pub fn add_callback_on_sys_renameat2_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, olddfd: i32, oldname: u64, newdfd: i32, newname: u64, flags: u32), )

pub fn remove_callback_on_sys_renameat2_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, olddfd: i32, oldname: u64, newdfd: i32, newname: u64, flags: u32), )

pub fn add_callback_on_sys_renameat2_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, olddfd: i32, oldname: u64, newdfd: i32, newname: u64, flags: u32), )

pub fn remove_callback_on_sys_renameat2_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, olddfd: i32, oldname: u64, newdfd: i32, newname: u64, flags: u32), )

pub fn add_callback_on_sys_request_key_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, _type: u64, _description: u64, _callout_info: u64, destringid: u32), )

pub fn remove_callback_on_sys_request_key_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, _type: u64, _description: u64, _callout_info: u64, destringid: u32), )

pub fn add_callback_on_sys_request_key_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, _type: u64, _description: u64, _callout_info: u64, destringid: u32), )

pub fn remove_callback_on_sys_request_key_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, _type: u64, _description: u64, _callout_info: u64, destringid: u32), )

pub fn add_callback_on_sys_restart_syscall_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc), )

pub fn remove_callback_on_sys_restart_syscall_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc), )

pub fn add_callback_on_sys_restart_syscall_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc), )

pub fn remove_callback_on_sys_restart_syscall_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc), )

pub fn add_callback_on_sys_rmdir_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, pathname: u64), )

pub fn remove_callback_on_sys_rmdir_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, pathname: u64), )

pub fn add_callback_on_sys_rmdir_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, pathname: u64), )

pub fn remove_callback_on_sys_rmdir_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, pathname: u64), )

pub fn add_callback_on_sys_rt_sigaction_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, arg0: i32, arg1: u64, arg2: u64, arg3: u32), )

pub fn remove_callback_on_sys_rt_sigaction_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, arg0: i32, arg1: u64, arg2: u64, arg3: u32), )

pub fn add_callback_on_sys_rt_sigaction_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, arg0: i32, arg1: u64, arg2: u64, arg3: u32), )

pub fn remove_callback_on_sys_rt_sigaction_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, arg0: i32, arg1: u64, arg2: u64, arg3: u32), )

pub fn add_callback_on_sys_rt_sigpending_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, set: u64, sigsetsize: u32), )

pub fn remove_callback_on_sys_rt_sigpending_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, set: u64, sigsetsize: u32), )

pub fn add_callback_on_sys_rt_sigpending_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, set: u64, sigsetsize: u32), )

pub fn remove_callback_on_sys_rt_sigpending_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, set: u64, sigsetsize: u32), )

pub fn add_callback_on_sys_rt_sigprocmask_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, how: i32, set: u64, oset: u64, sigsetsize: u32), )

pub fn remove_callback_on_sys_rt_sigprocmask_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, how: i32, set: u64, oset: u64, sigsetsize: u32), )

pub fn add_callback_on_sys_rt_sigprocmask_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, how: i32, set: u64, oset: u64, sigsetsize: u32), )

pub fn remove_callback_on_sys_rt_sigprocmask_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, how: i32, set: u64, oset: u64, sigsetsize: u32), )

pub fn add_callback_on_sys_rt_sigqueueinfo_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, pid: i32, sig: i32, uinfo: u64), )

pub fn remove_callback_on_sys_rt_sigqueueinfo_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, pid: i32, sig: i32, uinfo: u64), )

pub fn add_callback_on_sys_rt_sigqueueinfo_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, pid: i32, sig: i32, uinfo: u64), )

pub fn remove_callback_on_sys_rt_sigqueueinfo_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, pid: i32, sig: i32, uinfo: u64), )

pub fn add_callback_on_sys_rt_sigreturn_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc), )

pub fn remove_callback_on_sys_rt_sigreturn_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc), )

pub fn add_callback_on_sys_rt_sigreturn_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc), )

pub fn remove_callback_on_sys_rt_sigreturn_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc), )

pub fn add_callback_on_sys_rt_sigsuspend_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, unewset: u64, sigsetsize: u32), )

pub fn remove_callback_on_sys_rt_sigsuspend_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, unewset: u64, sigsetsize: u32), )

pub fn add_callback_on_sys_rt_sigsuspend_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, unewset: u64, sigsetsize: u32), )

pub fn remove_callback_on_sys_rt_sigsuspend_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, unewset: u64, sigsetsize: u32), )

pub fn add_callback_on_sys_rt_sigtimedwait_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, uthese: u64, uinfo: u64, uts: u64, sigsetsize: u32), )

pub fn remove_callback_on_sys_rt_sigtimedwait_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, uthese: u64, uinfo: u64, uts: u64, sigsetsize: u32), )

pub fn add_callback_on_sys_rt_sigtimedwait_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, uthese: u64, uinfo: u64, uts: u64, sigsetsize: u32), )

pub fn remove_callback_on_sys_rt_sigtimedwait_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, uthese: u64, uinfo: u64, uts: u64, sigsetsize: u32), )

pub fn add_callback_on_sys_rt_tgsigqueueinfo_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, tgid: i32, pid: i32, sig: i32, uinfo: u64), )

pub fn remove_callback_on_sys_rt_tgsigqueueinfo_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, tgid: i32, pid: i32, sig: i32, uinfo: u64), )

pub fn add_callback_on_sys_rt_tgsigqueueinfo_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, tgid: i32, pid: i32, sig: i32, uinfo: u64), )

pub fn remove_callback_on_sys_rt_tgsigqueueinfo_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, tgid: i32, pid: i32, sig: i32, uinfo: u64), )

pub fn add_callback_on_sys_sched_get_priority_max_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, policy: i32), )

pub fn remove_callback_on_sys_sched_get_priority_max_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, policy: i32), )

pub fn add_callback_on_sys_sched_get_priority_max_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, policy: i32), )

pub fn remove_callback_on_sys_sched_get_priority_max_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, policy: i32), )

pub fn add_callback_on_sys_sched_get_priority_min_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, policy: i32), )

pub fn remove_callback_on_sys_sched_get_priority_min_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, policy: i32), )

pub fn add_callback_on_sys_sched_get_priority_min_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, policy: i32), )

pub fn remove_callback_on_sys_sched_get_priority_min_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, policy: i32), )

pub fn add_callback_on_sys_sched_getaffinity_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, pid: i32, len: u32, user_mask_ptr: u64), )

pub fn remove_callback_on_sys_sched_getaffinity_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, pid: i32, len: u32, user_mask_ptr: u64), )

pub fn add_callback_on_sys_sched_getaffinity_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, pid: i32, len: u32, user_mask_ptr: u64), )

pub fn remove_callback_on_sys_sched_getaffinity_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, pid: i32, len: u32, user_mask_ptr: u64), )

pub fn add_callback_on_sys_sched_getattr_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, pid: i32, attr: u64, size: u32, flags: u32), )

pub fn remove_callback_on_sys_sched_getattr_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, pid: i32, attr: u64, size: u32, flags: u32), )

pub fn add_callback_on_sys_sched_getattr_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, pid: i32, attr: u64, size: u32, flags: u32), )

pub fn remove_callback_on_sys_sched_getattr_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, pid: i32, attr: u64, size: u32, flags: u32), )

pub fn add_callback_on_sys_sched_getparam_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, pid: i32, param: u64), )

pub fn remove_callback_on_sys_sched_getparam_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, pid: i32, param: u64), )

pub fn add_callback_on_sys_sched_getparam_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, pid: i32, param: u64), )

pub fn remove_callback_on_sys_sched_getparam_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, pid: i32, param: u64), )

pub fn add_callback_on_sys_sched_getscheduler_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, pid: i32), )

pub fn remove_callback_on_sys_sched_getscheduler_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, pid: i32), )

pub fn add_callback_on_sys_sched_getscheduler_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, pid: i32), )

pub fn remove_callback_on_sys_sched_getscheduler_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, pid: i32), )

pub fn add_callback_on_sys_sched_rr_get_interval_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, pid: i32, interval: u64), )

pub fn remove_callback_on_sys_sched_rr_get_interval_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, pid: i32, interval: u64), )

pub fn add_callback_on_sys_sched_rr_get_interval_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, pid: i32, interval: u64), )

pub fn remove_callback_on_sys_sched_rr_get_interval_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, pid: i32, interval: u64), )

pub fn add_callback_on_sys_sched_setaffinity_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, pid: i32, len: u32, user_mask_ptr: u64), )

pub fn remove_callback_on_sys_sched_setaffinity_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, pid: i32, len: u32, user_mask_ptr: u64), )

pub fn add_callback_on_sys_sched_setaffinity_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, pid: i32, len: u32, user_mask_ptr: u64), )

pub fn remove_callback_on_sys_sched_setaffinity_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, pid: i32, len: u32, user_mask_ptr: u64), )

pub fn add_callback_on_sys_sched_setattr_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, pid: i32, attr: u64, flags: u32), )

pub fn remove_callback_on_sys_sched_setattr_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, pid: i32, attr: u64, flags: u32), )

pub fn add_callback_on_sys_sched_setattr_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, pid: i32, attr: u64, flags: u32), )

pub fn remove_callback_on_sys_sched_setattr_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, pid: i32, attr: u64, flags: u32), )

pub fn add_callback_on_sys_sched_setparam_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, pid: i32, param: u64), )

pub fn remove_callback_on_sys_sched_setparam_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, pid: i32, param: u64), )

pub fn add_callback_on_sys_sched_setparam_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, pid: i32, param: u64), )

pub fn remove_callback_on_sys_sched_setparam_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, pid: i32, param: u64), )

pub fn add_callback_on_sys_sched_setscheduler_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, pid: i32, policy: i32, param: u64), )

pub fn remove_callback_on_sys_sched_setscheduler_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, pid: i32, policy: i32, param: u64), )

pub fn add_callback_on_sys_sched_setscheduler_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, pid: i32, policy: i32, param: u64), )

pub fn remove_callback_on_sys_sched_setscheduler_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, pid: i32, policy: i32, param: u64), )

pub fn add_callback_on_sys_sched_yield_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc), )

pub fn remove_callback_on_sys_sched_yield_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc), )

pub fn add_callback_on_sys_sched_yield_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc), )

pub fn remove_callback_on_sys_sched_yield_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc), )

pub fn add_callback_on_sys_seccomp_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, op: u32, flags: u32, uargs: u64), )

pub fn remove_callback_on_sys_seccomp_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, op: u32, flags: u32, uargs: u64), )

pub fn add_callback_on_sys_seccomp_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, op: u32, flags: u32, uargs: u64), )

pub fn remove_callback_on_sys_seccomp_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, op: u32, flags: u32, uargs: u64), )

pub fn add_callback_on_sys_select_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, n: i32, inp: u64, outp: u64, exp: u64, tvp: u64), )

pub fn remove_callback_on_sys_select_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, n: i32, inp: u64, outp: u64, exp: u64, tvp: u64), )

pub fn add_callback_on_sys_select_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, n: i32, inp: u64, outp: u64, exp: u64, tvp: u64), )

pub fn remove_callback_on_sys_select_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, n: i32, inp: u64, outp: u64, exp: u64, tvp: u64), )

pub fn add_callback_on_sys_semctl_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, semid: i32, semnum: i32, cmd: i32, arg: u64), )

pub fn remove_callback_on_sys_semctl_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, semid: i32, semnum: i32, cmd: i32, arg: u64), )

pub fn add_callback_on_sys_semctl_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, semid: i32, semnum: i32, cmd: i32, arg: u64), )

pub fn remove_callback_on_sys_semctl_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, semid: i32, semnum: i32, cmd: i32, arg: u64), )

pub fn add_callback_on_sys_semget_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, key: u32, nsems: i32, semflg: i32), )

pub fn remove_callback_on_sys_semget_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, key: u32, nsems: i32, semflg: i32), )

pub fn add_callback_on_sys_semget_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, key: u32, nsems: i32, semflg: i32), )

pub fn remove_callback_on_sys_semget_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, key: u32, nsems: i32, semflg: i32), )

pub fn add_callback_on_sys_semop_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, semid: i32, sops: u64, nsops: u32), )

pub fn remove_callback_on_sys_semop_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, semid: i32, sops: u64, nsops: u32), )

pub fn add_callback_on_sys_semop_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, semid: i32, sops: u64, nsops: u32), )

pub fn remove_callback_on_sys_semop_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, semid: i32, sops: u64, nsops: u32), )

pub fn add_callback_on_sys_semtimedop_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, semid: i32, sops: u64, nsops: u32, timeout: u64), )

pub fn remove_callback_on_sys_semtimedop_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, semid: i32, sops: u64, nsops: u32, timeout: u64), )

pub fn add_callback_on_sys_semtimedop_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, semid: i32, sops: u64, nsops: u32, timeout: u64), )

pub fn remove_callback_on_sys_semtimedop_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, semid: i32, sops: u64, nsops: u32, timeout: u64), )

pub fn add_callback_on_sys_sendfile64_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, out_fd: i32, in_fd: i32, offset: u64, count: u32), )

pub fn remove_callback_on_sys_sendfile64_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, out_fd: i32, in_fd: i32, offset: u64, count: u32), )

pub fn add_callback_on_sys_sendfile64_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, out_fd: i32, in_fd: i32, offset: u64, count: u32), )

pub fn remove_callback_on_sys_sendfile64_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, out_fd: i32, in_fd: i32, offset: u64, count: u32), )

pub fn add_callback_on_sys_sendmmsg_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, fd: i32, msg: u64, vlen: u32, flags: u32), )

pub fn remove_callback_on_sys_sendmmsg_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, fd: i32, msg: u64, vlen: u32, flags: u32), )

pub fn add_callback_on_sys_sendmmsg_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, fd: i32, msg: u64, vlen: u32, flags: u32), )

pub fn remove_callback_on_sys_sendmmsg_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, fd: i32, msg: u64, vlen: u32, flags: u32), )

pub fn add_callback_on_sys_sendmsg_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, fd: i32, msg: u64, flags: u32), )

pub fn remove_callback_on_sys_sendmsg_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, fd: i32, msg: u64, flags: u32), )

pub fn add_callback_on_sys_sendmsg_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, fd: i32, msg: u64, flags: u32), )

pub fn remove_callback_on_sys_sendmsg_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, fd: i32, msg: u64, flags: u32), )

pub fn add_callback_on_sys_sendto_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, arg0: i32, arg1: u64, arg2: u32, arg3: u32, arg4: u64, arg5: i32), )

pub fn remove_callback_on_sys_sendto_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, arg0: i32, arg1: u64, arg2: u32, arg3: u32, arg4: u64, arg5: i32), )

pub fn add_callback_on_sys_sendto_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, arg0: i32, arg1: u64, arg2: u32, arg3: u32, arg4: u64, arg5: i32), )

pub fn remove_callback_on_sys_sendto_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, arg0: i32, arg1: u64, arg2: u32, arg3: u32, arg4: u64, arg5: i32), )

pub fn add_callback_on_sys_set_mempolicy_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, mode: i32, nmask: u64, maxnode: u64), )

pub fn remove_callback_on_sys_set_mempolicy_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, mode: i32, nmask: u64, maxnode: u64), )

pub fn add_callback_on_sys_set_mempolicy_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, mode: i32, nmask: u64, maxnode: u64), )

pub fn remove_callback_on_sys_set_mempolicy_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, mode: i32, nmask: u64, maxnode: u64), )

pub fn add_callback_on_sys_set_robust_list_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, head: u64, len: u32), )

pub fn remove_callback_on_sys_set_robust_list_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, head: u64, len: u32), )

pub fn add_callback_on_sys_set_robust_list_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, head: u64, len: u32), )

pub fn remove_callback_on_sys_set_robust_list_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, head: u64, len: u32), )

pub fn add_callback_on_sys_set_tid_address_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, tidptr: u64), )

pub fn remove_callback_on_sys_set_tid_address_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, tidptr: u64), )

pub fn add_callback_on_sys_set_tid_address_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, tidptr: u64), )

pub fn remove_callback_on_sys_set_tid_address_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, tidptr: u64), )

pub fn add_callback_on_sys_setdomainname_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, name: u64, len: i32), )

pub fn remove_callback_on_sys_setdomainname_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, name: u64, len: i32), )

pub fn add_callback_on_sys_setdomainname_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, name: u64, len: i32), )

pub fn remove_callback_on_sys_setdomainname_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, name: u64, len: i32), )

pub fn add_callback_on_sys_setfsgid_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, gid: u32), )

pub fn remove_callback_on_sys_setfsgid_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, gid: u32), )

pub fn add_callback_on_sys_setfsgid_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, gid: u32), )

pub fn remove_callback_on_sys_setfsgid_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, gid: u32), )

pub fn add_callback_on_sys_setfsuid_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, uid: u32), )

pub fn remove_callback_on_sys_setfsuid_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, uid: u32), )

pub fn add_callback_on_sys_setfsuid_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, uid: u32), )

pub fn remove_callback_on_sys_setfsuid_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, uid: u32), )

pub fn add_callback_on_sys_setgid_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, gid: u32), )

pub fn remove_callback_on_sys_setgid_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, gid: u32), )

pub fn add_callback_on_sys_setgid_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, gid: u32), )

pub fn remove_callback_on_sys_setgid_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, gid: u32), )

pub fn add_callback_on_sys_setgroups_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, gidsetsize: i32, grouplist: u64), )

pub fn remove_callback_on_sys_setgroups_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, gidsetsize: i32, grouplist: u64), )

pub fn add_callback_on_sys_setgroups_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, gidsetsize: i32, grouplist: u64), )

pub fn remove_callback_on_sys_setgroups_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, gidsetsize: i32, grouplist: u64), )

pub fn add_callback_on_sys_sethostname_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, name: u64, len: i32), )

pub fn remove_callback_on_sys_sethostname_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, name: u64, len: i32), )

pub fn add_callback_on_sys_sethostname_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, name: u64, len: i32), )

pub fn remove_callback_on_sys_sethostname_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, name: u64, len: i32), )

pub fn add_callback_on_sys_setitimer_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, which: i32, value: u64, ovalue: u64), )

pub fn remove_callback_on_sys_setitimer_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, which: i32, value: u64, ovalue: u64), )

pub fn add_callback_on_sys_setitimer_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, which: i32, value: u64, ovalue: u64), )

pub fn remove_callback_on_sys_setitimer_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, which: i32, value: u64, ovalue: u64), )

pub fn add_callback_on_sys_setns_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, fd: i32, nstype: i32), )

pub fn remove_callback_on_sys_setns_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, fd: i32, nstype: i32), )

pub fn add_callback_on_sys_setns_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, fd: i32, nstype: i32), )

pub fn remove_callback_on_sys_setns_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, fd: i32, nstype: i32), )

pub fn add_callback_on_sys_setpgid_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, pid: i32, pgid: i32), )

pub fn remove_callback_on_sys_setpgid_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, pid: i32, pgid: i32), )

pub fn add_callback_on_sys_setpgid_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, pid: i32, pgid: i32), )

pub fn remove_callback_on_sys_setpgid_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, pid: i32, pgid: i32), )

pub fn add_callback_on_sys_setpriority_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, which: i32, who: i32, niceval: i32), )

pub fn remove_callback_on_sys_setpriority_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, which: i32, who: i32, niceval: i32), )

pub fn add_callback_on_sys_setpriority_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, which: i32, who: i32, niceval: i32), )

pub fn remove_callback_on_sys_setpriority_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, which: i32, who: i32, niceval: i32), )

pub fn add_callback_on_sys_setregid_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, rgid: u32, egid: u32), )

pub fn remove_callback_on_sys_setregid_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, rgid: u32, egid: u32), )

pub fn add_callback_on_sys_setregid_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, rgid: u32, egid: u32), )

pub fn remove_callback_on_sys_setregid_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, rgid: u32, egid: u32), )

pub fn add_callback_on_sys_setresgid_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, rgid: u32, egid: u32, sgid: u32), )

pub fn remove_callback_on_sys_setresgid_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, rgid: u32, egid: u32, sgid: u32), )

pub fn add_callback_on_sys_setresgid_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, rgid: u32, egid: u32, sgid: u32), )

pub fn remove_callback_on_sys_setresgid_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, rgid: u32, egid: u32, sgid: u32), )

pub fn add_callback_on_sys_setresuid_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, ruid: u32, euid: u32, suid: u32), )

pub fn remove_callback_on_sys_setresuid_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, ruid: u32, euid: u32, suid: u32), )

pub fn add_callback_on_sys_setresuid_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, ruid: u32, euid: u32, suid: u32), )

pub fn remove_callback_on_sys_setresuid_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, ruid: u32, euid: u32, suid: u32), )

pub fn add_callback_on_sys_setreuid_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, ruid: u32, euid: u32), )

pub fn remove_callback_on_sys_setreuid_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, ruid: u32, euid: u32), )

pub fn add_callback_on_sys_setreuid_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, ruid: u32, euid: u32), )

pub fn remove_callback_on_sys_setreuid_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, ruid: u32, euid: u32), )

pub fn add_callback_on_sys_setrlimit_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, resource: u32, rlim: u64), )

pub fn remove_callback_on_sys_setrlimit_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, resource: u32, rlim: u64), )

pub fn add_callback_on_sys_setrlimit_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, resource: u32, rlim: u64), )

pub fn remove_callback_on_sys_setrlimit_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, resource: u32, rlim: u64), )

pub fn add_callback_on_sys_setsid_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc), )

pub fn remove_callback_on_sys_setsid_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc), )

pub fn add_callback_on_sys_setsid_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc), )

pub fn remove_callback_on_sys_setsid_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc), )

pub fn add_callback_on_sys_setsockopt_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, fd: i32, level: i32, optname: i32, optval: u64, optlen: i32), )

pub fn remove_callback_on_sys_setsockopt_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, fd: i32, level: i32, optname: i32, optval: u64, optlen: i32), )

pub fn add_callback_on_sys_setsockopt_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, fd: i32, level: i32, optname: i32, optval: u64, optlen: i32), )

pub fn remove_callback_on_sys_setsockopt_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, fd: i32, level: i32, optname: i32, optval: u64, optlen: i32), )

pub fn add_callback_on_sys_settimeofday_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, tv: u64, tz: u64), )

pub fn remove_callback_on_sys_settimeofday_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, tv: u64, tz: u64), )

pub fn add_callback_on_sys_settimeofday_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, tv: u64, tz: u64), )

pub fn remove_callback_on_sys_settimeofday_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, tv: u64, tz: u64), )

pub fn add_callback_on_sys_setuid_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, uid: u32), )

pub fn remove_callback_on_sys_setuid_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, uid: u32), )

pub fn add_callback_on_sys_setuid_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, uid: u32), )

pub fn remove_callback_on_sys_setuid_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, uid: u32), )

pub fn add_callback_on_sys_setxattr_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, path: u64, name: u64, value: u64, size: u32, flags: i32), )

pub fn remove_callback_on_sys_setxattr_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, path: u64, name: u64, value: u64, size: u32, flags: i32), )

pub fn add_callback_on_sys_setxattr_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, path: u64, name: u64, value: u64, size: u32, flags: i32), )

pub fn remove_callback_on_sys_setxattr_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, path: u64, name: u64, value: u64, size: u32, flags: i32), )

pub fn add_callback_on_sys_shmat_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, shmid: i32, shmaddr: u64, shmflg: i32), )

pub fn remove_callback_on_sys_shmat_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, shmid: i32, shmaddr: u64, shmflg: i32), )

pub fn add_callback_on_sys_shmat_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, shmid: i32, shmaddr: u64, shmflg: i32), )

pub fn remove_callback_on_sys_shmat_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, shmid: i32, shmaddr: u64, shmflg: i32), )

pub fn add_callback_on_sys_shmctl_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, shmid: i32, cmd: i32, buf: u64), )

pub fn remove_callback_on_sys_shmctl_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, shmid: i32, cmd: i32, buf: u64), )

pub fn add_callback_on_sys_shmctl_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, shmid: i32, cmd: i32, buf: u64), )

pub fn remove_callback_on_sys_shmctl_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, shmid: i32, cmd: i32, buf: u64), )

pub fn add_callback_on_sys_shmdt_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, shmaddr: u64), )

pub fn remove_callback_on_sys_shmdt_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, shmaddr: u64), )

pub fn add_callback_on_sys_shmdt_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, shmaddr: u64), )

pub fn remove_callback_on_sys_shmdt_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, shmaddr: u64), )

pub fn add_callback_on_sys_shmget_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, key: u32, size: u32, flag: i32), )

pub fn remove_callback_on_sys_shmget_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, key: u32, size: u32, flag: i32), )

pub fn add_callback_on_sys_shmget_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, key: u32, size: u32, flag: i32), )

pub fn remove_callback_on_sys_shmget_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, key: u32, size: u32, flag: i32), )

pub fn add_callback_on_sys_shutdown_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, arg0: i32, arg1: i32), )

pub fn remove_callback_on_sys_shutdown_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, arg0: i32, arg1: i32), )

pub fn add_callback_on_sys_shutdown_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, arg0: i32, arg1: i32), )

pub fn remove_callback_on_sys_shutdown_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, arg0: i32, arg1: i32), )

pub fn add_callback_on_sys_sigaltstack_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, uss: u64, uoss: u64), )

pub fn remove_callback_on_sys_sigaltstack_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, uss: u64, uoss: u64), )

pub fn add_callback_on_sys_sigaltstack_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, uss: u64, uoss: u64), )

pub fn remove_callback_on_sys_sigaltstack_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, uss: u64, uoss: u64), )

pub fn add_callback_on_sys_signalfd_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, ufd: i32, user_mask: u64, sizemask: u32), )

pub fn remove_callback_on_sys_signalfd_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, ufd: i32, user_mask: u64, sizemask: u32), )

pub fn add_callback_on_sys_signalfd_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, ufd: i32, user_mask: u64, sizemask: u32), )

pub fn remove_callback_on_sys_signalfd_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, ufd: i32, user_mask: u64, sizemask: u32), )

pub fn add_callback_on_sys_signalfd4_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, ufd: i32, user_mask: u64, sizemask: u32, flags: i32), )

pub fn remove_callback_on_sys_signalfd4_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, ufd: i32, user_mask: u64, sizemask: u32, flags: i32), )

pub fn add_callback_on_sys_signalfd4_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, ufd: i32, user_mask: u64, sizemask: u32, flags: i32), )

pub fn remove_callback_on_sys_signalfd4_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, ufd: i32, user_mask: u64, sizemask: u32, flags: i32), )

pub fn add_callback_on_sys_socket_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, arg0: i32, arg1: i32, arg2: i32), )

pub fn remove_callback_on_sys_socket_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, arg0: i32, arg1: i32, arg2: i32), )

pub fn add_callback_on_sys_socket_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, arg0: i32, arg1: i32, arg2: i32), )

pub fn remove_callback_on_sys_socket_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, arg0: i32, arg1: i32, arg2: i32), )

pub fn add_callback_on_sys_socketpair_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, arg0: i32, arg1: i32, arg2: i32, arg3: u64), )

pub fn remove_callback_on_sys_socketpair_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, arg0: i32, arg1: i32, arg2: i32, arg3: u64), )

pub fn add_callback_on_sys_socketpair_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, arg0: i32, arg1: i32, arg2: i32, arg3: u64), )

pub fn remove_callback_on_sys_socketpair_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, arg0: i32, arg1: i32, arg2: i32, arg3: u64), )

pub fn add_callback_on_sys_splice_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, fd_in: i32, off_in: u64, fd_out: i32, off_out: u64, len: u32, flags: u32), )

pub fn remove_callback_on_sys_splice_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, fd_in: i32, off_in: u64, fd_out: i32, off_out: u64, len: u32, flags: u32), )

pub fn add_callback_on_sys_splice_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, fd_in: i32, off_in: u64, fd_out: i32, off_out: u64, len: u32, flags: u32), )

pub fn remove_callback_on_sys_splice_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, fd_in: i32, off_in: u64, fd_out: i32, off_out: u64, len: u32, flags: u32), )

pub fn add_callback_on_sys_statfs_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, path: u64, buf: u64), )

pub fn remove_callback_on_sys_statfs_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, path: u64, buf: u64), )

pub fn add_callback_on_sys_statfs_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, path: u64, buf: u64), )

pub fn remove_callback_on_sys_statfs_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, path: u64, buf: u64), )

pub fn add_callback_on_sys_statx_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, dfd: i32, path: u64, flags: u32, mask: u32, buffer: u64), )

pub fn remove_callback_on_sys_statx_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, dfd: i32, path: u64, flags: u32, mask: u32, buffer: u64), )

pub fn add_callback_on_sys_statx_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, dfd: i32, path: u64, flags: u32, mask: u32, buffer: u64), )

pub fn remove_callback_on_sys_statx_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, dfd: i32, path: u64, flags: u32, mask: u32, buffer: u64), )

pub fn add_callback_on_sys_swapoff_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, specialfile: u64), )

pub fn remove_callback_on_sys_swapoff_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, specialfile: u64), )

pub fn add_callback_on_sys_swapoff_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, specialfile: u64), )

pub fn remove_callback_on_sys_swapoff_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, specialfile: u64), )

pub fn add_callback_on_sys_swapon_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, specialfile: u64, swap_flags: i32), )

pub fn remove_callback_on_sys_swapon_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, specialfile: u64, swap_flags: i32), )

pub fn add_callback_on_sys_swapon_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, specialfile: u64, swap_flags: i32), )

pub fn remove_callback_on_sys_swapon_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, specialfile: u64, swap_flags: i32), )

pub fn add_callback_on_sys_symlink_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, old: u64, _new: u64), )

pub fn remove_callback_on_sys_symlink_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, old: u64, _new: u64), )

pub fn add_callback_on_sys_symlink_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, old: u64, _new: u64), )

pub fn remove_callback_on_sys_symlink_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, old: u64, _new: u64), )

pub fn add_callback_on_sys_symlinkat_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, oldname: u64, newdfd: i32, newname: u64), )

pub fn remove_callback_on_sys_symlinkat_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, oldname: u64, newdfd: i32, newname: u64), )

pub fn add_callback_on_sys_symlinkat_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, oldname: u64, newdfd: i32, newname: u64), )

pub fn remove_callback_on_sys_symlinkat_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, oldname: u64, newdfd: i32, newname: u64), )

pub fn add_callback_on_sys_sync_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc), )

pub fn remove_callback_on_sys_sync_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc), )

pub fn add_callback_on_sys_sync_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc), )

pub fn remove_callback_on_sys_sync_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc), )

pub fn add_callback_on_sys_sync_file_range_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, fd: i32, offset: u64, nbytes: u64, flags: u32), )

pub fn remove_callback_on_sys_sync_file_range_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, fd: i32, offset: u64, nbytes: u64, flags: u32), )

pub fn add_callback_on_sys_sync_file_range_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, fd: i32, offset: u64, nbytes: u64, flags: u32), )

pub fn remove_callback_on_sys_sync_file_range_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, fd: i32, offset: u64, nbytes: u64, flags: u32), )

pub fn add_callback_on_sys_syncfs_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, fd: i32), )

pub fn remove_callback_on_sys_syncfs_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, fd: i32), )

pub fn add_callback_on_sys_syncfs_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, fd: i32), )

pub fn remove_callback_on_sys_syncfs_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, fd: i32), )

pub fn add_callback_on_sys_sysctl_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, args: u64), )

pub fn remove_callback_on_sys_sysctl_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, args: u64), )

pub fn add_callback_on_sys_sysctl_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, args: u64), )

pub fn remove_callback_on_sys_sysctl_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, args: u64), )

pub fn add_callback_on_sys_sysfs_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, option: i32, arg1: u64, arg2: u64), )

pub fn remove_callback_on_sys_sysfs_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, option: i32, arg1: u64, arg2: u64), )

pub fn add_callback_on_sys_sysfs_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, option: i32, arg1: u64, arg2: u64), )

pub fn remove_callback_on_sys_sysfs_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, option: i32, arg1: u64, arg2: u64), )

pub fn add_callback_on_sys_sysinfo_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, info: u64), )

pub fn remove_callback_on_sys_sysinfo_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, info: u64), )

pub fn add_callback_on_sys_sysinfo_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, info: u64), )

pub fn remove_callback_on_sys_sysinfo_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, info: u64), )

pub fn add_callback_on_sys_syslog_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, _type: i32, buf: u64, len: i32), )

pub fn remove_callback_on_sys_syslog_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, _type: i32, buf: u64, len: i32), )

pub fn add_callback_on_sys_syslog_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, _type: i32, buf: u64, len: i32), )

pub fn remove_callback_on_sys_syslog_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, _type: i32, buf: u64, len: i32), )

pub fn add_callback_on_sys_tee_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, fdin: i32, fdout: i32, len: u32, flags: u32), )

pub fn remove_callback_on_sys_tee_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, fdin: i32, fdout: i32, len: u32, flags: u32), )

pub fn add_callback_on_sys_tee_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, fdin: i32, fdout: i32, len: u32, flags: u32), )

pub fn remove_callback_on_sys_tee_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, fdin: i32, fdout: i32, len: u32, flags: u32), )

pub fn add_callback_on_sys_tgkill_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, tgid: i32, pid: i32, sig: i32), )

pub fn remove_callback_on_sys_tgkill_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, tgid: i32, pid: i32, sig: i32), )

pub fn add_callback_on_sys_tgkill_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, tgid: i32, pid: i32, sig: i32), )

pub fn remove_callback_on_sys_tgkill_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, tgid: i32, pid: i32, sig: i32), )

pub fn add_callback_on_sys_time_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, tloc: u64), )

pub fn remove_callback_on_sys_time_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, tloc: u64), )

pub fn add_callback_on_sys_time_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, tloc: u64), )

pub fn remove_callback_on_sys_time_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, tloc: u64), )

pub fn add_callback_on_sys_timer_create_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, which_clock: u32, timer_event_spec: u64, created_timer_id: u64), )

pub fn remove_callback_on_sys_timer_create_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, which_clock: u32, timer_event_spec: u64, created_timer_id: u64), )

pub fn add_callback_on_sys_timer_create_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, which_clock: u32, timer_event_spec: u64, created_timer_id: u64), )

pub fn remove_callback_on_sys_timer_create_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, which_clock: u32, timer_event_spec: u64, created_timer_id: u64), )

pub fn add_callback_on_sys_timer_delete_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, timer_id: u32), )

pub fn remove_callback_on_sys_timer_delete_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, timer_id: u32), )

pub fn add_callback_on_sys_timer_delete_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, timer_id: u32), )

pub fn remove_callback_on_sys_timer_delete_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, timer_id: u32), )

pub fn add_callback_on_sys_timer_getoverrun_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, timer_id: u32), )

pub fn remove_callback_on_sys_timer_getoverrun_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, timer_id: u32), )

pub fn add_callback_on_sys_timer_getoverrun_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, timer_id: u32), )

pub fn remove_callback_on_sys_timer_getoverrun_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, timer_id: u32), )

pub fn add_callback_on_sys_timer_gettime_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, timer_id: u32, setting: u64), )

pub fn remove_callback_on_sys_timer_gettime_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, timer_id: u32, setting: u64), )

pub fn add_callback_on_sys_timer_gettime_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, timer_id: u32, setting: u64), )

pub fn remove_callback_on_sys_timer_gettime_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, timer_id: u32, setting: u64), )

pub fn add_callback_on_sys_timer_settime_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, timer_id: u32, flags: i32, new_setting: u64, old_setting: u64), )

pub fn remove_callback_on_sys_timer_settime_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, timer_id: u32, flags: i32, new_setting: u64, old_setting: u64), )

pub fn add_callback_on_sys_timer_settime_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, timer_id: u32, flags: i32, new_setting: u64, old_setting: u64), )

pub fn remove_callback_on_sys_timer_settime_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, timer_id: u32, flags: i32, new_setting: u64, old_setting: u64), )

pub fn add_callback_on_sys_timerfd_create_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, clockid: i32, flags: i32), )

pub fn remove_callback_on_sys_timerfd_create_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, clockid: i32, flags: i32), )

pub fn add_callback_on_sys_timerfd_create_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, clockid: i32, flags: i32), )

pub fn remove_callback_on_sys_timerfd_create_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, clockid: i32, flags: i32), )

pub fn add_callback_on_sys_timerfd_gettime_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, ufd: i32, otmr: u64), )

pub fn remove_callback_on_sys_timerfd_gettime_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, ufd: i32, otmr: u64), )

pub fn add_callback_on_sys_timerfd_gettime_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, ufd: i32, otmr: u64), )

pub fn remove_callback_on_sys_timerfd_gettime_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, ufd: i32, otmr: u64), )

pub fn add_callback_on_sys_timerfd_settime_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, ufd: i32, flags: i32, utmr: u64, otmr: u64), )

pub fn remove_callback_on_sys_timerfd_settime_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, ufd: i32, flags: i32, utmr: u64, otmr: u64), )

pub fn add_callback_on_sys_timerfd_settime_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, ufd: i32, flags: i32, utmr: u64, otmr: u64), )

pub fn remove_callback_on_sys_timerfd_settime_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, ufd: i32, flags: i32, utmr: u64, otmr: u64), )

pub fn add_callback_on_sys_times_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, tbuf: u64), )

pub fn remove_callback_on_sys_times_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, tbuf: u64), )

pub fn add_callback_on_sys_times_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, tbuf: u64), )

pub fn remove_callback_on_sys_times_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, tbuf: u64), )

pub fn add_callback_on_sys_tkill_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, pid: i32, sig: i32), )

pub fn remove_callback_on_sys_tkill_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, pid: i32, sig: i32), )

pub fn add_callback_on_sys_tkill_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, pid: i32, sig: i32), )

pub fn remove_callback_on_sys_tkill_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, pid: i32, sig: i32), )

pub fn add_callback_on_sys_truncate_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, path: u64, length: i64), )

pub fn remove_callback_on_sys_truncate_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, path: u64, length: i64), )

pub fn add_callback_on_sys_truncate_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, path: u64, length: i64), )

pub fn remove_callback_on_sys_truncate_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, path: u64, length: i64), )

pub fn add_callback_on_sys_umask_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, mask: i32), )

pub fn remove_callback_on_sys_umask_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, mask: i32), )

pub fn add_callback_on_sys_umask_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, mask: i32), )

pub fn remove_callback_on_sys_umask_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, mask: i32), )

pub fn add_callback_on_sys_umount_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, name: u64, flags: i32), )

pub fn remove_callback_on_sys_umount_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, name: u64, flags: i32), )

pub fn add_callback_on_sys_umount_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, name: u64, flags: i32), )

pub fn remove_callback_on_sys_umount_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, name: u64, flags: i32), )

pub fn add_callback_on_sys_unlink_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, pathname: u64), )

pub fn remove_callback_on_sys_unlink_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, pathname: u64), )

pub fn add_callback_on_sys_unlink_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, pathname: u64), )

pub fn remove_callback_on_sys_unlink_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, pathname: u64), )

pub fn add_callback_on_sys_unlinkat_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, dfd: i32, pathname: u64, flag: i32), )

pub fn remove_callback_on_sys_unlinkat_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, dfd: i32, pathname: u64, flag: i32), )

pub fn add_callback_on_sys_unlinkat_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, dfd: i32, pathname: u64, flag: i32), )

pub fn remove_callback_on_sys_unlinkat_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, dfd: i32, pathname: u64, flag: i32), )

pub fn add_callback_on_sys_unshare_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, unshare_flags: u64), )

pub fn remove_callback_on_sys_unshare_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, unshare_flags: u64), )

pub fn add_callback_on_sys_unshare_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, unshare_flags: u64), )

pub fn remove_callback_on_sys_unshare_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, unshare_flags: u64), )

pub fn add_callback_on_sys_userfaultfd_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, flags: i32), )

pub fn remove_callback_on_sys_userfaultfd_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, flags: i32), )

pub fn add_callback_on_sys_userfaultfd_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, flags: i32), )

pub fn remove_callback_on_sys_userfaultfd_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, flags: i32), )

pub fn add_callback_on_sys_ustat_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, dev: u32, ubuf: u64), )

pub fn remove_callback_on_sys_ustat_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, dev: u32, ubuf: u64), )

pub fn add_callback_on_sys_ustat_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, dev: u32, ubuf: u64), )

pub fn remove_callback_on_sys_ustat_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, dev: u32, ubuf: u64), )

pub fn add_callback_on_sys_utime_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, filename: u64, times: u64), )

pub fn remove_callback_on_sys_utime_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, filename: u64, times: u64), )

pub fn add_callback_on_sys_utime_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, filename: u64, times: u64), )

pub fn remove_callback_on_sys_utime_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, filename: u64, times: u64), )

pub fn add_callback_on_sys_utimensat_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, dfd: i32, filename: u64, utimes: u64, flags: i32), )

pub fn remove_callback_on_sys_utimensat_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, dfd: i32, filename: u64, utimes: u64, flags: i32), )

pub fn add_callback_on_sys_utimensat_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, dfd: i32, filename: u64, utimes: u64, flags: i32), )

pub fn remove_callback_on_sys_utimensat_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, dfd: i32, filename: u64, utimes: u64, flags: i32), )

pub fn add_callback_on_sys_utimes_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, filename: u64, utimes: u64), )

pub fn remove_callback_on_sys_utimes_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, filename: u64, utimes: u64), )

pub fn add_callback_on_sys_utimes_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, filename: u64, utimes: u64), )

pub fn remove_callback_on_sys_utimes_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, filename: u64, utimes: u64), )

pub fn add_callback_on_sys_vfork_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc), )

pub fn remove_callback_on_sys_vfork_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc), )

pub fn add_callback_on_sys_vfork_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc), )

pub fn remove_callback_on_sys_vfork_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc), )

pub fn add_callback_on_sys_vhangup_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc), )

pub fn remove_callback_on_sys_vhangup_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc), )

pub fn add_callback_on_sys_vhangup_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc), )

pub fn remove_callback_on_sys_vhangup_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc), )

pub fn add_callback_on_sys_vmsplice_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, fd: i32, iov: u64, nr_segs: u64, flags: u32), )

pub fn remove_callback_on_sys_vmsplice_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, fd: i32, iov: u64, nr_segs: u64, flags: u32), )

pub fn add_callback_on_sys_vmsplice_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, fd: i32, iov: u64, nr_segs: u64, flags: u32), )

pub fn remove_callback_on_sys_vmsplice_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, fd: i32, iov: u64, nr_segs: u64, flags: u32), )

pub fn add_callback_on_sys_wait4_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, pid: i32, stat_addr: u64, options: i32, ru: u64), )

pub fn remove_callback_on_sys_wait4_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, pid: i32, stat_addr: u64, options: i32, ru: u64), )

pub fn add_callback_on_sys_wait4_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, pid: i32, stat_addr: u64, options: i32, ru: u64), )

pub fn remove_callback_on_sys_wait4_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, pid: i32, stat_addr: u64, options: i32, ru: u64), )

pub fn add_callback_on_sys_waitid_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, which: i32, pid: i32, infop: u64, options: i32, ru: u64), )

pub fn remove_callback_on_sys_waitid_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, which: i32, pid: i32, infop: u64, options: i32, ru: u64), )

pub fn add_callback_on_sys_waitid_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, which: i32, pid: i32, infop: u64, options: i32, ru: u64), )

pub fn remove_callback_on_sys_waitid_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, which: i32, pid: i32, infop: u64, options: i32, ru: u64), )

pub fn add_callback_on_sys_write_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, fd: u32, buf: u64, count: u32), )

pub fn remove_callback_on_sys_write_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, fd: u32, buf: u64, count: u32), )

pub fn add_callback_on_sys_write_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, fd: u32, buf: u64, count: u32), )

pub fn remove_callback_on_sys_write_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, fd: u32, buf: u64, count: u32), )

pub fn add_callback_on_sys_writev_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, fd: u64, vec: u64, vlen: u64), )

pub fn remove_callback_on_sys_writev_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, fd: u64, vec: u64, vlen: u64), )

pub fn add_callback_on_sys_writev_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, fd: u64, vec: u64, vlen: u64), )

pub fn remove_callback_on_sys_writev_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, fd: u64, vec: u64, vlen: u64), )

pub fn add_callback_on_all_sys_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, callno: target_ulong), )

pub fn remove_callback_on_all_sys_enter( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, callno: target_ulong), )

pub fn add_callback_on_all_sys_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, callno: target_ulong), )

pub fn remove_callback_on_all_sys_return( &self, callback: extern "C" fn(cpu: &mut CPUState, pc: SyscallPc, callno: target_ulong), )

Trait Implementations

impl Deref for SYSCALLS

type Target = Syscalls2

The resulting type after dereferencing.

fn deref(&self) -> &Syscalls2

Dereferences the value.

impl LazyStatic for SYSCALLS