Struct panda::PppCallback

#[repr(transparent)]
pub struct PppCallback(_);

A reference to a given callback slot which can be used to install, enable, disable, or otherwise reference, a closure-based callback for PANDA plugin-to-plugin (“PPP”) callbacks.

Since this is a reference to a callback slot and does not include storage for the callback itself, it can be trivially copied, as well as included in the callback itself (for the purposes of enabling/disabling).

In order to actually install the callback, you will need to import the trait for the specific plugin whose callbacks you want to run. In the example below, the ProcStartLinuxCallbacks trait provides the on_rec_auxv method in order to add the callback.

Example

use panda::plugins::proc_start_linux::ProcStartLinuxCallbacks;
use panda::PppCallback;
use panda::prelude::*;

PppCallback::new().on_rec_auxv(|_, _, auxv| {
    dbg!(auxv);
});

Panda::new().generic("x86_64").replay("test").run();

The above installs a callback to print out the contents of the auxillary vector using dbg whenever a new process is spawned in the guest.

Example output:

...
[panda-rs/examples/closures.rs:18] auxv = AuxvValues {
    argc: 3,
    argv_ptr_ptr: 0x7fffffffebb8,
    arg_ptr: [
        0x7fffffffede6,
        0x7fffffffedeb,
        0x7fffffffedee,
    ],
    argv: [
        "bash",
        "-c",
        "echo test2",
    ],
    envc: 20,
    env_ptr_ptr: 0x7fffffffebd8,
    env_ptr: [
        0x7fffffffedf9,
        0x7fffffffee04,
        // ...
        0x7fffffffefc2,
        0x7fffffffefe2,
    ],
    envp: [
        "LS_COLORS=",
        "LESSCLOSE=/usr/bin/lesspipe %s %s",
        "LANG=C.UTwcap2: 0,F-8",
        "INVOCATION_ID=0b2d5ea4eb39435388bf53e507047b2f",
        "XDG_SESSION_ID=1",
        "HUSHLOGIN=FALSE",
        "USER=root",
        "PWD=/root",
        "HOME=/root",
        "JOURNAL_STREAM=9:16757",
        "XDG_DATA_DIRS=/usr/local/share:/usr/share:/var/lib/snapd/desktop",
        "MAIL=/var/mail/root",
        "SHELL=/bin/bash",
        "TERM=vt220",
        "SHLVL=1",
        "LOGNAME=root",
        "XDG_RUNTIME_DIR=/run/user/0",
        "PATH=/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin:/usr/games:/usr/local/games:/snap/bin",
        "LESSOPEN=| /usr/bin/lesspipe %s",
        "_=/bin/bash",
    ],
    execfn_ptr: 0x7fffffffefee,
    execfn: "/bin/bash",
    phdr: 0x555555554040,
    entry: 0x555555585520,
    ehdr: 0x7ffff7ffa000,
    // ...
}
Replay completed successfully
Exiting cpu_handle_exception loop

Note

Callback closures must have a 'static lifetime in order to live past the end of the function. This means that the only references a callback can include are references to static variables or leaked objects on the heap (See Box::leak for more info).

If you’d like to reference shared data without leaking, this can be accomplished via reference counting. See Arc for more info. If you want to capture data owned by the current function without sharing it, you can mark your closure as move in order to move all the variables you capture into your closure. (Such as in the above example, where count is moved into the closure for modification)

Implementations

impl PppCallback

pub fn new() -> Self

Create a new callback slot which can then be used to install or modify a given callback.

pub fn enable(&self)

Enable the callback assigned to the given slot, if any.

pub fn disable(&self)

Disable the callback assigned to the given slot, if any.

Trait Implementations

impl Clone for PppCallback

fn clone(&self) -> PppCallback

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Hooks2Callbacks for PppCallback

fn on_process_start<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, *const c_char, target_ulong, target_pid_t) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_process_start callback is hit.

fn on_process_end<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, *const c_char, target_ulong, target_pid_t) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_process_end callback is hit.

fn on_thread_start<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, *const c_char, target_ulong, target_pid_t, target_pid_t) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_thread_start callback is hit.

fn on_thread_end<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, *const c_char, target_ulong, target_pid_t, target_pid_t) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_thread_end callback is hit.

fn on_mmap_updated<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, *const c_char, target_ulong, target_ulong) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_mmap_updated callback is hit.

impl Ord for PppCallback

fn cmp(&self, other: &PppCallback) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

Restrict a value to a certain interval.

impl PartialEq<PppCallback> for PppCallback

fn eq(&self, other: &PppCallback) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &PppCallback) -> bool

This method tests for !=.

impl PartialOrd<PppCallback> for PppCallback

fn partial_cmp(&self, other: &PppCallback) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl ProcStartLinuxCallbacks for PppCallback

fn on_rec_auxv<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, &mut TranslationBlock, &AuxvValues) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_rec_auxv callback is hit.

impl Syscalls2Callbacks for PppCallback

fn on_sys_accept_enter<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, i32, u64, u64) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_accept_enter callback is hit.

fn on_sys_accept_return<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, i32, u64, u64) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_accept_return callback is hit.

fn on_sys_accept4_enter<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, i32, u64, u64, i32) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_accept4_enter callback is hit.

fn on_sys_accept4_return<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, i32, u64, u64, i32) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_accept4_return callback is hit.

fn on_sys_access_enter<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, u64, i32) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_access_enter callback is hit.

fn on_sys_access_return<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, u64, i32) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_access_return callback is hit.

fn on_sys_acct_enter<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, u64) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_acct_enter callback is hit.

fn on_sys_acct_return<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, u64) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_acct_return callback is hit.

fn on_sys_add_key_enter<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, u64, u64, u64, u32, u32) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_add_key_enter callback is hit.

fn on_sys_add_key_return<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, u64, u64, u64, u32, u32) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_add_key_return callback is hit.

fn on_sys_adjtimex_enter<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, u64) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_adjtimex_enter callback is hit.

fn on_sys_adjtimex_return<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, u64) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_adjtimex_return callback is hit.

fn on_sys_alarm_enter<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, u32) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_alarm_enter callback is hit.

fn on_sys_alarm_return<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, u32) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_alarm_return callback is hit.

fn on_sys_arch_prctl_enter<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, i32, u64) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_arch_prctl_enter callback is hit.

fn on_sys_arch_prctl_return<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, i32, u64) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_arch_prctl_return callback is hit.

fn on_sys_bind_enter<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, i32, u64, i32) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_bind_enter callback is hit.

fn on_sys_bind_return<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, i32, u64, i32) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_bind_return callback is hit.

fn on_sys_bpf_enter<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, i32, u64, u32) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_bpf_enter callback is hit.

fn on_sys_bpf_return<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, i32, u64, u32) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_bpf_return callback is hit.

fn on_sys_brk_enter<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, u64) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_brk_enter callback is hit.

fn on_sys_brk_return<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, u64) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_brk_return callback is hit.

fn on_sys_capget_enter<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, u64, u64) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_capget_enter callback is hit.

fn on_sys_capget_return<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, u64, u64) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_capget_return callback is hit.

fn on_sys_capset_enter<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, u64, u64) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_capset_enter callback is hit.

fn on_sys_capset_return<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, u64, u64) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_capset_return callback is hit.

fn on_sys_chdir_enter<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, u64) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_chdir_enter callback is hit.

fn on_sys_chdir_return<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, u64) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_chdir_return callback is hit.

fn on_sys_chmod_enter<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, u64, u32) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_chmod_enter callback is hit.

fn on_sys_chmod_return<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, u64, u32) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_chmod_return callback is hit.

fn on_sys_chown_enter<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, u64, u32, u32) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_chown_enter callback is hit.

fn on_sys_chown_return<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, u64, u32, u32) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_chown_return callback is hit.

fn on_sys_chroot_enter<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, u64) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_chroot_enter callback is hit.

fn on_sys_chroot_return<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, u64) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_chroot_return callback is hit.

fn on_sys_clock_adjtime_enter<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, u32, u64) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_clock_adjtime_enter callback is hit.

fn on_sys_clock_adjtime_return<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, u32, u64) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_clock_adjtime_return callback is hit.

fn on_sys_clock_getres_enter<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, u32, u64) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_clock_getres_enter callback is hit.

fn on_sys_clock_getres_return<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, u32, u64) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_clock_getres_return callback is hit.

fn on_sys_clock_gettime_enter<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, u32, u64) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_clock_gettime_enter callback is hit.

fn on_sys_clock_gettime_return<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, u32, u64) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_clock_gettime_return callback is hit.

fn on_sys_clock_nanosleep_enter<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, u32, i32, u64, u64) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_clock_nanosleep_enter callback is hit.

fn on_sys_clock_nanosleep_return<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, u32, i32, u64, u64) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_clock_nanosleep_return callback is hit.

fn on_sys_clock_settime_enter<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, u32, u64) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_clock_settime_enter callback is hit.

fn on_sys_clock_settime_return<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, u32, u64) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_clock_settime_return callback is hit.

fn on_sys_clone_enter<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, u64, u64, u64, u64, u64) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_clone_enter callback is hit.

fn on_sys_clone_return<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, u64, u64, u64, u64, u64) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_clone_return callback is hit.

fn on_sys_close_enter<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, u32) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_close_enter callback is hit.

fn on_sys_close_return<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, u32) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_close_return callback is hit.

fn on_sys_connect_enter<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, i32, u64, i32) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_connect_enter callback is hit.

fn on_sys_connect_return<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, i32, u64, i32) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_connect_return callback is hit.

fn on_sys_copy_file_range_enter<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, i32, u64, i32, u64, u32, u32) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_copy_file_range_enter callback is hit.

fn on_sys_copy_file_range_return<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, i32, u64, i32, u64, u32, u32) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_copy_file_range_return callback is hit.

fn on_sys_creat_enter<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, u64, u32) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_creat_enter callback is hit.

fn on_sys_creat_return<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, u64, u32) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_creat_return callback is hit.

fn on_sys_delete_module_enter<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, u64, u32) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_delete_module_enter callback is hit.

fn on_sys_delete_module_return<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, u64, u32) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_delete_module_return callback is hit.

fn on_sys_dup_enter<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, u32) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_dup_enter callback is hit.

fn on_sys_dup_return<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, u32) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_dup_return callback is hit.

fn on_sys_dup2_enter<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, u32, u32) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_dup2_enter callback is hit.

fn on_sys_dup2_return<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, u32, u32) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_dup2_return callback is hit.

fn on_sys_dup3_enter<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, u32, u32, i32) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_dup3_enter callback is hit.

fn on_sys_dup3_return<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, u32, u32, i32) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_dup3_return callback is hit.

fn on_sys_epoll_create_enter<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, i32) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_epoll_create_enter callback is hit.

fn on_sys_epoll_create_return<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, i32) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_epoll_create_return callback is hit.

fn on_sys_epoll_create1_enter<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, i32) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_epoll_create1_enter callback is hit.

fn on_sys_epoll_create1_return<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, i32) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_epoll_create1_return callback is hit.

fn on_sys_epoll_ctl_enter<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, i32, i32, i32, u64) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_epoll_ctl_enter callback is hit.

fn on_sys_epoll_ctl_return<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, i32, i32, i32, u64) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_epoll_ctl_return callback is hit.

fn on_sys_epoll_pwait_enter<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, i32, u64, i32, i32, u64, u32) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_epoll_pwait_enter callback is hit.

fn on_sys_epoll_pwait_return<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, i32, u64, i32, i32, u64, u32) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_epoll_pwait_return callback is hit.

fn on_sys_epoll_wait_enter<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, i32, u64, i32, i32) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_epoll_wait_enter callback is hit.

fn on_sys_epoll_wait_return<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, i32, u64, i32, i32) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_epoll_wait_return callback is hit.

fn on_sys_eventfd_enter<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, u32) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_eventfd_enter callback is hit.

fn on_sys_eventfd_return<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, u32) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_eventfd_return callback is hit.

fn on_sys_eventfd2_enter<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, u32, i32) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_eventfd2_enter callback is hit.

fn on_sys_eventfd2_return<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, u32, i32) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_eventfd2_return callback is hit.

fn on_sys_execve_enter<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, u64, u64, u64) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_execve_enter callback is hit.

fn on_sys_execve_return<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, u64, u64, u64) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_execve_return callback is hit.

fn on_sys_execveat_enter<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, i32, u64, u64, u64, i32) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_execveat_enter callback is hit.

fn on_sys_execveat_return<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, i32, u64, u64, u64, i32) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_execveat_return callback is hit.

fn on_sys_exit_enter<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, i32) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_exit_enter callback is hit.

fn on_sys_exit_return<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, i32) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_exit_return callback is hit.

fn on_sys_exit_group_enter<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, i32) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_exit_group_enter callback is hit.

fn on_sys_exit_group_return<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, i32) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_exit_group_return callback is hit.

fn on_sys_faccessat_enter<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, i32, u64, i32) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_faccessat_enter callback is hit.

fn on_sys_faccessat_return<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, i32, u64, i32) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_faccessat_return callback is hit.

fn on_sys_fadvise64_enter<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, i32, u64, u32, i32) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_fadvise64_enter callback is hit.

fn on_sys_fadvise64_return<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, i32, u64, u32, i32) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_fadvise64_return callback is hit.

fn on_sys_fallocate_enter<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, i32, i32, u64, u64) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_fallocate_enter callback is hit.

fn on_sys_fallocate_return<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, i32, i32, u64, u64) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_fallocate_return callback is hit.

fn on_sys_fanotify_init_enter<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, u32, u32) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_fanotify_init_enter callback is hit.

fn on_sys_fanotify_init_return<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, u32, u32) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_fanotify_init_return callback is hit.

fn on_sys_fanotify_mark_enter<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, i32, u32, u64, i32, u64) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_fanotify_mark_enter callback is hit.

fn on_sys_fanotify_mark_return<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, i32, u32, u64, i32, u64) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_fanotify_mark_return callback is hit.

fn on_sys_fchdir_enter<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, u32) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_fchdir_enter callback is hit.

fn on_sys_fchdir_return<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, u32) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_fchdir_return callback is hit.

fn on_sys_fchmod_enter<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, u32, u32) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_fchmod_enter callback is hit.

fn on_sys_fchmod_return<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, u32, u32) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_fchmod_return callback is hit.

fn on_sys_fchmodat_enter<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, i32, u64, u32) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_fchmodat_enter callback is hit.

fn on_sys_fchmodat_return<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, i32, u64, u32) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_fchmodat_return callback is hit.

fn on_sys_fchown_enter<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, u32, u32, u32) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_fchown_enter callback is hit.

fn on_sys_fchown_return<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, u32, u32, u32) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_fchown_return callback is hit.

fn on_sys_fchownat_enter<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, i32, u64, u32, u32, i32) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_fchownat_enter callback is hit.

fn on_sys_fchownat_return<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, i32, u64, u32, u32, i32) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_fchownat_return callback is hit.

fn on_sys_fcntl_enter<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, u32, u32, u64) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_fcntl_enter callback is hit.

fn on_sys_fcntl_return<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, u32, u32, u64) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_fcntl_return callback is hit.

fn on_sys_fdatasync_enter<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, u32) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_fdatasync_enter callback is hit.

fn on_sys_fdatasync_return<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, u32) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_fdatasync_return callback is hit.

fn on_sys_fgetxattr_enter<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, i32, u64, u64, u32) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_fgetxattr_enter callback is hit.

fn on_sys_fgetxattr_return<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, i32, u64, u64, u32) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_fgetxattr_return callback is hit.

fn on_sys_finit_module_enter<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, i32, u64, i32) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_finit_module_enter callback is hit.

fn on_sys_finit_module_return<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, i32, u64, i32) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_finit_module_return callback is hit.

fn on_sys_flistxattr_enter<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, i32, u64, u32) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_flistxattr_enter callback is hit.

fn on_sys_flistxattr_return<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, i32, u64, u32) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_flistxattr_return callback is hit.

fn on_sys_flock_enter<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, u32, u32) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_flock_enter callback is hit.

fn on_sys_flock_return<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, u32, u32) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_flock_return callback is hit.

fn on_sys_fork_enter<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_fork_enter callback is hit.

fn on_sys_fork_return<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_fork_return callback is hit.

fn on_sys_fremovexattr_enter<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, i32, u64) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_fremovexattr_enter callback is hit.

fn on_sys_fremovexattr_return<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, i32, u64) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_fremovexattr_return callback is hit.

fn on_sys_fsetxattr_enter<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, i32, u64, u64, u32, i32) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_fsetxattr_enter callback is hit.

fn on_sys_fsetxattr_return<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, i32, u64, u64, u32, i32) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_fsetxattr_return callback is hit.

fn on_sys_fstatfs_enter<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, u32, u64) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_fstatfs_enter callback is hit.

fn on_sys_fstatfs_return<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, u32, u64) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_fstatfs_return callback is hit.

fn on_sys_fsync_enter<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, u32) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_fsync_enter callback is hit.

fn on_sys_fsync_return<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, u32) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_fsync_return callback is hit.

fn on_sys_ftruncate_enter<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, u32, u64) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_ftruncate_enter callback is hit.

fn on_sys_ftruncate_return<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, u32, u64) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_ftruncate_return callback is hit.

fn on_sys_futex_enter<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, u64, i32, u32, u64, u64, u32) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_futex_enter callback is hit.

fn on_sys_futex_return<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, u64, i32, u32, u64, u64, u32) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_futex_return callback is hit.

fn on_sys_futimesat_enter<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, i32, u64, u64) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_futimesat_enter callback is hit.

fn on_sys_futimesat_return<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, i32, u64, u64) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_futimesat_return callback is hit.

fn on_sys_get_mempolicy_enter<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, u64, u64, u64, u64, u64) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_get_mempolicy_enter callback is hit.

fn on_sys_get_mempolicy_return<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, u64, u64, u64, u64, u64) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_get_mempolicy_return callback is hit.

fn on_sys_get_robust_list_enter<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, i32, u64, u64) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_get_robust_list_enter callback is hit.

fn on_sys_get_robust_list_return<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, i32, u64, u64) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_get_robust_list_return callback is hit.

fn on_sys_getcpu_enter<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, u64, u64, u64) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_getcpu_enter callback is hit.

fn on_sys_getcpu_return<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, u64, u64, u64) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_getcpu_return callback is hit.

fn on_sys_getcwd_enter<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, u64, u64) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_getcwd_enter callback is hit.

fn on_sys_getcwd_return<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, u64, u64) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_getcwd_return callback is hit.

fn on_sys_getdents_enter<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, u32, u64, u32) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_getdents_enter callback is hit.

fn on_sys_getdents_return<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, u32, u64, u32) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_getdents_return callback is hit.

fn on_sys_getdents64_enter<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, u32, u64, u32) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_getdents64_enter callback is hit.

fn on_sys_getdents64_return<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, u32, u64, u32) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_getdents64_return callback is hit.

fn on_sys_getegid_enter<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_getegid_enter callback is hit.

fn on_sys_getegid_return<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_getegid_return callback is hit.

fn on_sys_geteuid_enter<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_geteuid_enter callback is hit.

fn on_sys_geteuid_return<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_geteuid_return callback is hit.

fn on_sys_getgid_enter<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_getgid_enter callback is hit.

fn on_sys_getgid_return<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_getgid_return callback is hit.

fn on_sys_getgroups_enter<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, i32, u64) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_getgroups_enter callback is hit.

fn on_sys_getgroups_return<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, i32, u64) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_getgroups_return callback is hit.

fn on_sys_getitimer_enter<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, i32, u64) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_getitimer_enter callback is hit.

fn on_sys_getitimer_return<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, i32, u64) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_getitimer_return callback is hit.

fn on_sys_getpeername_enter<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, i32, u64, u64) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_getpeername_enter callback is hit.

fn on_sys_getpeername_return<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, i32, u64, u64) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_getpeername_return callback is hit.

fn on_sys_getpgid_enter<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, i32) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_getpgid_enter callback is hit.

fn on_sys_getpgid_return<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, i32) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_getpgid_return callback is hit.

fn on_sys_getpgrp_enter<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_getpgrp_enter callback is hit.

fn on_sys_getpgrp_return<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_getpgrp_return callback is hit.

fn on_sys_getpid_enter<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_getpid_enter callback is hit.

fn on_sys_getpid_return<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_getpid_return callback is hit.

fn on_sys_getppid_enter<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_getppid_enter callback is hit.

fn on_sys_getppid_return<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_getppid_return callback is hit.

fn on_sys_getpriority_enter<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, i32, i32) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_getpriority_enter callback is hit.

fn on_sys_getpriority_return<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, i32, i32) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_getpriority_return callback is hit.

fn on_sys_getrandom_enter<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, u64, u32, u32) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_getrandom_enter callback is hit.

fn on_sys_getrandom_return<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, u64, u32, u32) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_getrandom_return callback is hit.

fn on_sys_getresgid_enter<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, u64, u64, u64) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_getresgid_enter callback is hit.

fn on_sys_getresgid_return<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, u64, u64, u64) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_getresgid_return callback is hit.

fn on_sys_getresuid_enter<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, u64, u64, u64) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_getresuid_enter callback is hit.

fn on_sys_getresuid_return<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, u64, u64, u64) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_getresuid_return callback is hit.

fn on_sys_getrlimit_enter<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, u32, u64) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_getrlimit_enter callback is hit.

fn on_sys_getrlimit_return<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, u32, u64) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_getrlimit_return callback is hit.

fn on_sys_getrusage_enter<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, i32, u64) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_getrusage_enter callback is hit.

fn on_sys_getrusage_return<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, i32, u64) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_getrusage_return callback is hit.

fn on_sys_getsid_enter<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, i32) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_getsid_enter callback is hit.

fn on_sys_getsid_return<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, i32) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_getsid_return callback is hit.

fn on_sys_getsockname_enter<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, i32, u64, u64) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_getsockname_enter callback is hit.

fn on_sys_getsockname_return<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, i32, u64, u64) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_getsockname_return callback is hit.

fn on_sys_getsockopt_enter<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, i32, i32, i32, u64, u64) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_getsockopt_enter callback is hit.

fn on_sys_getsockopt_return<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, i32, i32, i32, u64, u64) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_getsockopt_return callback is hit.

fn on_sys_gettid_enter<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_gettid_enter callback is hit.

fn on_sys_gettid_return<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_gettid_return callback is hit.

fn on_sys_gettimeofday_enter<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, u64, u64) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_gettimeofday_enter callback is hit.

fn on_sys_gettimeofday_return<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, u64, u64) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_gettimeofday_return callback is hit.

fn on_sys_getuid_enter<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_getuid_enter callback is hit.

fn on_sys_getuid_return<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_getuid_return callback is hit.

fn on_sys_getxattr_enter<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, u64, u64, u64, u32) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_getxattr_enter callback is hit.

fn on_sys_getxattr_return<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, u64, u64, u64, u32) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_getxattr_return callback is hit.

fn on_sys_init_module_enter<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, u64, u64, u64) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_init_module_enter callback is hit.

fn on_sys_init_module_return<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, u64, u64, u64) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_init_module_return callback is hit.

fn on_sys_inotify_add_watch_enter<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, i32, u64, u32) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_inotify_add_watch_enter callback is hit.

fn on_sys_inotify_add_watch_return<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, i32, u64, u32) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_inotify_add_watch_return callback is hit.

fn on_sys_inotify_init_enter<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_inotify_init_enter callback is hit.

fn on_sys_inotify_init_return<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_inotify_init_return callback is hit.

fn on_sys_inotify_init1_enter<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, i32) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_inotify_init1_enter callback is hit.

fn on_sys_inotify_init1_return<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, i32) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_inotify_init1_return callback is hit.

fn on_sys_inotify_rm_watch_enter<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, i32, i32) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_inotify_rm_watch_enter callback is hit.

fn on_sys_inotify_rm_watch_return<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, i32, i32) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_inotify_rm_watch_return callback is hit.

fn on_sys_io_cancel_enter<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, u64, u64, u64) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_io_cancel_enter callback is hit.

fn on_sys_io_cancel_return<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, u64, u64, u64) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_io_cancel_return callback is hit.

fn on_sys_io_destroy_enter<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, u64) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_io_destroy_enter callback is hit.

fn on_sys_io_destroy_return<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, u64) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_io_destroy_return callback is hit.

fn on_sys_io_getevents_enter<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, u64, i64, i64, u64, u64) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_io_getevents_enter callback is hit.

fn on_sys_io_getevents_return<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, u64, i64, i64, u64, u64) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_io_getevents_return callback is hit.

fn on_sys_io_setup_enter<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, u32, u64) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_io_setup_enter callback is hit.

fn on_sys_io_setup_return<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, u32, u64) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_io_setup_return callback is hit.

fn on_sys_io_submit_enter<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, u64, i64, u64) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_io_submit_enter callback is hit.

fn on_sys_io_submit_return<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, u64, i64, u64) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_io_submit_return callback is hit.

fn on_sys_ioctl_enter<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, u32, u32, u64) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_ioctl_enter callback is hit.

fn on_sys_ioctl_return<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, u32, u32, u64) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_ioctl_return callback is hit.

fn on_sys_ioperm_enter<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, u64, u64, i32) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_ioperm_enter callback is hit.

fn on_sys_ioperm_return<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, u64, u64, i32) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_ioperm_return callback is hit.

fn on_sys_iopl_enter<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, u32) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_iopl_enter callback is hit.

fn on_sys_iopl_return<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, u32) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_iopl_return callback is hit.

fn on_sys_ioprio_get_enter<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, i32, i32) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_ioprio_get_enter callback is hit.

fn on_sys_ioprio_get_return<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, i32, i32) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_ioprio_get_return callback is hit.

fn on_sys_ioprio_set_enter<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, i32, i32, i32) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_ioprio_set_enter callback is hit.

fn on_sys_ioprio_set_return<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, i32, i32, i32) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_ioprio_set_return callback is hit.

fn on_sys_kcmp_enter<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, i32, i32, i32, u64, u64) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_kcmp_enter callback is hit.

fn on_sys_kcmp_return<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, i32, i32, i32, u64, u64) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_kcmp_return callback is hit.

fn on_sys_kexec_file_load_enter<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, i32, i32, u64, u64, u64) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_kexec_file_load_enter callback is hit.

fn on_sys_kexec_file_load_return<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, i32, i32, u64, u64, u64) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_kexec_file_load_return callback is hit.

fn on_sys_kexec_load_enter<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, u64, u64, u64, u64) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_kexec_load_enter callback is hit.

fn on_sys_kexec_load_return<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, u64, u64, u64, u64) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_kexec_load_return callback is hit.

fn on_sys_keyctl_enter<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, i32, u64, u64, u64, u64) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_keyctl_enter callback is hit.

fn on_sys_keyctl_return<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, i32, u64, u64, u64, u64) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_keyctl_return callback is hit.

fn on_sys_kill_enter<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, i32, i32) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_kill_enter callback is hit.

fn on_sys_kill_return<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, i32, i32) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_kill_return callback is hit.

fn on_sys_lchown_enter<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, u64, u32, u32) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_lchown_enter callback is hit.

fn on_sys_lchown_return<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, u64, u32, u32) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_lchown_return callback is hit.

fn on_sys_lgetxattr_enter<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, u64, u64, u64, u32) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_lgetxattr_enter callback is hit.

fn on_sys_lgetxattr_return<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, u64, u64, u64, u32) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_lgetxattr_return callback is hit.

fn on_sys_link_enter<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, u64, u64) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_link_enter callback is hit.

fn on_sys_link_return<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, u64, u64) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_link_return callback is hit.

fn on_sys_linkat_enter<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, i32, u64, i32, u64, i32) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_linkat_enter callback is hit.

fn on_sys_linkat_return<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, i32, u64, i32, u64, i32) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_linkat_return callback is hit.

fn on_sys_listen_enter<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, i32, i32) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_listen_enter callback is hit.

fn on_sys_listen_return<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, i32, i32) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_listen_return callback is hit.

fn on_sys_listxattr_enter<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, u64, u64, u32) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_listxattr_enter callback is hit.

fn on_sys_listxattr_return<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, u64, u64, u32) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_listxattr_return callback is hit.

fn on_sys_llistxattr_enter<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, u64, u64, u32) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_llistxattr_enter callback is hit.

fn on_sys_llistxattr_return<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, u64, u64, u32) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_llistxattr_return callback is hit.

fn on_sys_lookup_dcookie_enter<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, u64, u64, u32) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_lookup_dcookie_enter callback is hit.

fn on_sys_lookup_dcookie_return<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, u64, u64, u32) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_lookup_dcookie_return callback is hit.

fn on_sys_lremovexattr_enter<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, u64, u64) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_lremovexattr_enter callback is hit.

fn on_sys_lremovexattr_return<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, u64, u64) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_lremovexattr_return callback is hit.

fn on_sys_lseek_enter<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, u32, u64, u32) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_lseek_enter callback is hit.

fn on_sys_lseek_return<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, u32, u64, u32) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_lseek_return callback is hit.

fn on_sys_lsetxattr_enter<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, u64, u64, u64, u32, i32) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_lsetxattr_enter callback is hit.

fn on_sys_lsetxattr_return<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, u64, u64, u64, u32, i32) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_lsetxattr_return callback is hit.

fn on_sys_madvise_enter<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, u64, u32, i32) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_madvise_enter callback is hit.

fn on_sys_madvise_return<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, u64, u32, i32) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_madvise_return callback is hit.

fn on_sys_mbind_enter<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, u64, u64, u64, u64, u64, u32) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_mbind_enter callback is hit.

fn on_sys_mbind_return<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, u64, u64, u64, u64, u64, u32) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_mbind_return callback is hit.

fn on_sys_membarrier_enter<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, i32, i32) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_membarrier_enter callback is hit.

fn on_sys_membarrier_return<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, i32, i32) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_membarrier_return callback is hit.

fn on_sys_memfd_create_enter<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, u64, u32) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_memfd_create_enter callback is hit.

fn on_sys_memfd_create_return<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, u64, u32) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_memfd_create_return callback is hit.

fn on_sys_migrate_pages_enter<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, i32, u64, u64, u64) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_migrate_pages_enter callback is hit.

fn on_sys_migrate_pages_return<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, i32, u64, u64, u64) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_migrate_pages_return callback is hit.

fn on_sys_mincore_enter<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, u64, u32, u64) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_mincore_enter callback is hit.

fn on_sys_mincore_return<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, u64, u32, u64) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_mincore_return callback is hit.

fn on_sys_mkdir_enter<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, u64, u32) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_mkdir_enter callback is hit.

fn on_sys_mkdir_return<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, u64, u32) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_mkdir_return callback is hit.

fn on_sys_mkdirat_enter<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, i32, u64, u32) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_mkdirat_enter callback is hit.

fn on_sys_mkdirat_return<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, i32, u64, u32) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_mkdirat_return callback is hit.

fn on_sys_mknod_enter<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, u64, u32, u32) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_mknod_enter callback is hit.

fn on_sys_mknod_return<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, u64, u32, u32) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_mknod_return callback is hit.

fn on_sys_mknodat_enter<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, i32, u64, u32, u32) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_mknodat_enter callback is hit.

fn on_sys_mknodat_return<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, i32, u64, u32, u32) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_mknodat_return callback is hit.

fn on_sys_mlock_enter<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, u64, u32) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_mlock_enter callback is hit.

fn on_sys_mlock_return<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, u64, u32) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_mlock_return callback is hit.

fn on_sys_mlock2_enter<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, u64, u32, i32) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_mlock2_enter callback is hit.

fn on_sys_mlock2_return<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, u64, u32, i32) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_mlock2_return callback is hit.

fn on_sys_mlockall_enter<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, i32) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_mlockall_enter callback is hit.

fn on_sys_mlockall_return<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, i32) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_mlockall_return callback is hit.

fn on_sys_mmap_enter<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, u64, u64, u64, u64, u64, u64) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_mmap_enter callback is hit.

fn on_sys_mmap_return<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, u64, u64, u64, u64, u64, u64) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_mmap_return callback is hit.

fn on_sys_modify_ldt_enter<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, i32, u64, u64) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_modify_ldt_enter callback is hit.

fn on_sys_modify_ldt_return<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, i32, u64, u64) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_modify_ldt_return callback is hit.

fn on_sys_mount_enter<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, u64, u64, u64, u64, u64) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_mount_enter callback is hit.

fn on_sys_mount_return<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, u64, u64, u64, u64, u64) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_mount_return callback is hit.

fn on_sys_move_pages_enter<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, i32, u64, u64, u64, u64, i32) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_move_pages_enter callback is hit.

fn on_sys_move_pages_return<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, i32, u64, u64, u64, u64, i32) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_move_pages_return callback is hit.

fn on_sys_mprotect_enter<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, u64, u32, u64) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_mprotect_enter callback is hit.

fn on_sys_mprotect_return<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, u64, u32, u64) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_mprotect_return callback is hit.

fn on_sys_mq_getsetattr_enter<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, u32, u64, u64) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_mq_getsetattr_enter callback is hit.

fn on_sys_mq_getsetattr_return<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, u32, u64, u64) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_mq_getsetattr_return callback is hit.

fn on_sys_mq_notify_enter<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, u32, u64) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_mq_notify_enter callback is hit.

fn on_sys_mq_notify_return<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, u32, u64) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_mq_notify_return callback is hit.

fn on_sys_mq_open_enter<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, u64, i32, u32, u64) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_mq_open_enter callback is hit.

fn on_sys_mq_open_return<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, u64, i32, u32, u64) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_mq_open_return callback is hit.

fn on_sys_mq_timedreceive_enter<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, u32, u64, u32, u64, u64) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_mq_timedreceive_enter callback is hit.

fn on_sys_mq_timedreceive_return<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, u32, u64, u32, u64, u64) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_mq_timedreceive_return callback is hit.

fn on_sys_mq_timedsend_enter<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, u32, u64, u32, u32, u64) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_mq_timedsend_enter callback is hit.

fn on_sys_mq_timedsend_return<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, u32, u64, u32, u32, u64) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_mq_timedsend_return callback is hit.

fn on_sys_mq_unlink_enter<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, u64) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_mq_unlink_enter callback is hit.

fn on_sys_mq_unlink_return<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, u64) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_mq_unlink_return callback is hit.

fn on_sys_mremap_enter<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, u64, u64, u64, u64, u64) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_mremap_enter callback is hit.

fn on_sys_mremap_return<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, u64, u64, u64, u64, u64) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_mremap_return callback is hit.

fn on_sys_msgctl_enter<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, i32, i32, u64) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_msgctl_enter callback is hit.

fn on_sys_msgctl_return<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, i32, i32, u64) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_msgctl_return callback is hit.

fn on_sys_msgget_enter<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, u32, i32) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_msgget_enter callback is hit.

fn on_sys_msgget_return<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, u32, i32) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_msgget_return callback is hit.

fn on_sys_msgrcv_enter<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, i32, u64, u32, i64, i32) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_msgrcv_enter callback is hit.

fn on_sys_msgrcv_return<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, i32, u64, u32, i64, i32) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_msgrcv_return callback is hit.

fn on_sys_msgsnd_enter<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, i32, u64, u32, i32) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_msgsnd_enter callback is hit.

fn on_sys_msgsnd_return<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, i32, u64, u32, i32) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_msgsnd_return callback is hit.

fn on_sys_msync_enter<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, u64, u32, i32) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_msync_enter callback is hit.

fn on_sys_msync_return<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, u64, u32, i32) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_msync_return callback is hit.

fn on_sys_munlock_enter<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, u64, u32) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_munlock_enter callback is hit.

fn on_sys_munlock_return<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, u64, u32) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_munlock_return callback is hit.

fn on_sys_munlockall_enter<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_munlockall_enter callback is hit.

fn on_sys_munlockall_return<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_munlockall_return callback is hit.

fn on_sys_munmap_enter<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, u64, u32) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_munmap_enter callback is hit.

fn on_sys_munmap_return<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, u64, u32) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_munmap_return callback is hit.

fn on_sys_name_to_handle_at_enter<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, i32, u64, u64, u64, i32) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_name_to_handle_at_enter callback is hit.

fn on_sys_name_to_handle_at_return<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, i32, u64, u64, u64, i32) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_name_to_handle_at_return callback is hit.

fn on_sys_nanosleep_enter<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, u64, u64) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_nanosleep_enter callback is hit.

fn on_sys_nanosleep_return<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, u64, u64) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_nanosleep_return callback is hit.

fn on_sys_newfstat_enter<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, u32, u64) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_newfstat_enter callback is hit.

fn on_sys_newfstat_return<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, u32, u64) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_newfstat_return callback is hit.

fn on_sys_newfstatat_enter<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, i32, u64, u64, i32) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_newfstatat_enter callback is hit.

fn on_sys_newfstatat_return<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, i32, u64, u64, i32) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_newfstatat_return callback is hit.

fn on_sys_newlstat_enter<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, u64, u64) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_newlstat_enter callback is hit.

fn on_sys_newlstat_return<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, u64, u64) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_newlstat_return callback is hit.

fn on_sys_newstat_enter<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, u64, u64) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_newstat_enter callback is hit.

fn on_sys_newstat_return<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, u64, u64) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_newstat_return callback is hit.

fn on_sys_newuname_enter<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, u64) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_newuname_enter callback is hit.

fn on_sys_newuname_return<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, u64) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_newuname_return callback is hit.

fn on_sys_open_enter<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, u64, i32, u32) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_open_enter callback is hit.

fn on_sys_open_return<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, u64, i32, u32) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_open_return callback is hit.

fn on_sys_open_by_handle_at_enter<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, i32, u64, i32) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_open_by_handle_at_enter callback is hit.

fn on_sys_open_by_handle_at_return<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, i32, u64, i32) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_open_by_handle_at_return callback is hit.

fn on_sys_openat_enter<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, i32, u64, i32, u32) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_openat_enter callback is hit.

fn on_sys_openat_return<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, i32, u64, i32, u32) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_openat_return callback is hit.

fn on_sys_pause_enter<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_pause_enter callback is hit.

fn on_sys_pause_return<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_pause_return callback is hit.

fn on_sys_perf_event_open_enter<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, u64, i32, i32, i32, u64) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_perf_event_open_enter callback is hit.

fn on_sys_perf_event_open_return<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, u64, i32, i32, i32, u64) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_perf_event_open_return callback is hit.

fn on_sys_personality_enter<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, u32) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_personality_enter callback is hit.

fn on_sys_personality_return<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, u32) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_personality_return callback is hit.

fn on_sys_pipe_enter<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, u64) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_pipe_enter callback is hit.

fn on_sys_pipe_return<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, u64) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_pipe_return callback is hit.

fn on_sys_pipe2_enter<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, u64, i32) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_pipe2_enter callback is hit.

fn on_sys_pipe2_return<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, u64, i32) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_pipe2_return callback is hit.

fn on_sys_pivot_root_enter<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, u64, u64) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_pivot_root_enter callback is hit.

fn on_sys_pivot_root_return<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, u64, u64) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_pivot_root_return callback is hit.

fn on_sys_pkey_alloc_enter<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, u64, u64) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_pkey_alloc_enter callback is hit.

fn on_sys_pkey_alloc_return<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, u64, u64) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_pkey_alloc_return callback is hit.

fn on_sys_pkey_free_enter<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, i32) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_pkey_free_enter callback is hit.

fn on_sys_pkey_free_return<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, i32) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_pkey_free_return callback is hit.

fn on_sys_pkey_mprotect_enter<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, u64, u32, u64, i32) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_pkey_mprotect_enter callback is hit.

fn on_sys_pkey_mprotect_return<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, u64, u32, u64, i32) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_pkey_mprotect_return callback is hit.

fn on_sys_poll_enter<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, u64, u32, i32) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_poll_enter callback is hit.

fn on_sys_poll_return<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, u64, u32, i32) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_poll_return callback is hit.

fn on_sys_ppoll_enter<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, u64, u32, u64, u64, u32) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_ppoll_enter callback is hit.

fn on_sys_ppoll_return<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, u64, u32, u64, u64, u32) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_ppoll_return callback is hit.

fn on_sys_prctl_enter<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, i32, u64, u64, u64, u64) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_prctl_enter callback is hit.

fn on_sys_prctl_return<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, i32, u64, u64, u64, u64) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_prctl_return callback is hit.

fn on_sys_pread64_enter<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, u32, u64, u32, u64) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_pread64_enter callback is hit.

fn on_sys_pread64_return<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, u32, u64, u32, u64) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_pread64_return callback is hit.

fn on_sys_preadv_enter<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, u64, u64, u64, u64, u64) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_preadv_enter callback is hit.

fn on_sys_preadv_return<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, u64, u64, u64, u64, u64) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_preadv_return callback is hit.

fn on_sys_preadv2_enter<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, u64, u64, u64, u64, u64, u32) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_preadv2_enter callback is hit.

fn on_sys_preadv2_return<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, u64, u64, u64, u64, u64, u32) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_preadv2_return callback is hit.

fn on_sys_prlimit64_enter<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, i32, u32, u64, u64) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_prlimit64_enter callback is hit.

fn on_sys_prlimit64_return<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, i32, u32, u64, u64) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_prlimit64_return callback is hit.

fn on_sys_process_vm_readv_enter<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, i32, u64, u64, u64, u64, u64) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_process_vm_readv_enter callback is hit.

fn on_sys_process_vm_readv_return<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, i32, u64, u64, u64, u64, u64) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_process_vm_readv_return callback is hit.

fn on_sys_process_vm_writev_enter<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, i32, u64, u64, u64, u64, u64) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_process_vm_writev_enter callback is hit.

fn on_sys_process_vm_writev_return<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, i32, u64, u64, u64, u64, u64) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_process_vm_writev_return callback is hit.

fn on_sys_pselect6_enter<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, i32, u64, u64, u64, u64, u64) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_pselect6_enter callback is hit.

fn on_sys_pselect6_return<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, i32, u64, u64, u64, u64, u64) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_pselect6_return callback is hit.

fn on_sys_ptrace_enter<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, i64, i64, u64, u64) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_ptrace_enter callback is hit.

fn on_sys_ptrace_return<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, i64, i64, u64, u64) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_ptrace_return callback is hit.

fn on_sys_pwrite64_enter<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, u32, u64, u32, u64) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_pwrite64_enter callback is hit.

fn on_sys_pwrite64_return<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, u32, u64, u32, u64) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_pwrite64_return callback is hit.

fn on_sys_pwritev_enter<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, u64, u64, u64, u64, u64) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_pwritev_enter callback is hit.

fn on_sys_pwritev_return<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, u64, u64, u64, u64, u64) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_pwritev_return callback is hit.

fn on_sys_pwritev2_enter<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, u64, u64, u64, u64, u64, u32) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_pwritev2_enter callback is hit.

fn on_sys_pwritev2_return<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, u64, u64, u64, u64, u64, u32) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_pwritev2_return callback is hit.

fn on_sys_quotactl_enter<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, u32, u64, u32, u64) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_quotactl_enter callback is hit.

fn on_sys_quotactl_return<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, u32, u64, u32, u64) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_quotactl_return callback is hit.

fn on_sys_read_enter<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, u32, u64, u32) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_read_enter callback is hit.

fn on_sys_read_return<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, u32, u64, u32) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_read_return callback is hit.

fn on_sys_readahead_enter<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, i32, u64, u32) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_readahead_enter callback is hit.

fn on_sys_readahead_return<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, i32, u64, u32) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_readahead_return callback is hit.

fn on_sys_readlink_enter<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, u64, u64, i32) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_readlink_enter callback is hit.

fn on_sys_readlink_return<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, u64, u64, i32) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_readlink_return callback is hit.

fn on_sys_readlinkat_enter<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, i32, u64, u64, i32) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_readlinkat_enter callback is hit.

fn on_sys_readlinkat_return<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, i32, u64, u64, i32) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_readlinkat_return callback is hit.

fn on_sys_readv_enter<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, u64, u64, u64) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_readv_enter callback is hit.

fn on_sys_readv_return<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, u64, u64, u64) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_readv_return callback is hit.

fn on_sys_reboot_enter<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, i32, i32, u32, u64) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_reboot_enter callback is hit.

fn on_sys_reboot_return<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, i32, i32, u32, u64) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_reboot_return callback is hit.

fn on_sys_recvfrom_enter<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, i32, u64, u32, u32, u64, u64) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_recvfrom_enter callback is hit.

fn on_sys_recvfrom_return<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, i32, u64, u32, u32, u64, u64) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_recvfrom_return callback is hit.

fn on_sys_recvmmsg_enter<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, i32, u64, u32, u32, u64) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_recvmmsg_enter callback is hit.

fn on_sys_recvmmsg_return<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, i32, u64, u32, u32, u64) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_recvmmsg_return callback is hit.

fn on_sys_recvmsg_enter<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, i32, u64, u32) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_recvmsg_enter callback is hit.

fn on_sys_recvmsg_return<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, i32, u64, u32) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_recvmsg_return callback is hit.

fn on_sys_remap_file_pages_enter<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, u64, u64, u64, u64, u64) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_remap_file_pages_enter callback is hit.

fn on_sys_remap_file_pages_return<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, u64, u64, u64, u64, u64) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_remap_file_pages_return callback is hit.

fn on_sys_removexattr_enter<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, u64, u64) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_removexattr_enter callback is hit.

fn on_sys_removexattr_return<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, u64, u64) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_removexattr_return callback is hit.

fn on_sys_rename_enter<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, u64, u64) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_rename_enter callback is hit.

fn on_sys_rename_return<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, u64, u64) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_rename_return callback is hit.

fn on_sys_renameat_enter<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, i32, u64, i32, u64) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_renameat_enter callback is hit.

fn on_sys_renameat_return<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, i32, u64, i32, u64) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_renameat_return callback is hit.

fn on_sys_renameat2_enter<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, i32, u64, i32, u64, u32) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_renameat2_enter callback is hit.

fn on_sys_renameat2_return<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, i32, u64, i32, u64, u32) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_renameat2_return callback is hit.

fn on_sys_request_key_enter<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, u64, u64, u64, u32) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_request_key_enter callback is hit.

fn on_sys_request_key_return<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, u64, u64, u64, u32) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_request_key_return callback is hit.

fn on_sys_restart_syscall_enter<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_restart_syscall_enter callback is hit.

fn on_sys_restart_syscall_return<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_restart_syscall_return callback is hit.

fn on_sys_rmdir_enter<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, u64) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_rmdir_enter callback is hit.

fn on_sys_rmdir_return<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, u64) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_rmdir_return callback is hit.

fn on_sys_rt_sigaction_enter<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, i32, u64, u64, u32) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_rt_sigaction_enter callback is hit.

fn on_sys_rt_sigaction_return<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, i32, u64, u64, u32) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_rt_sigaction_return callback is hit.

fn on_sys_rt_sigpending_enter<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, u64, u32) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_rt_sigpending_enter callback is hit.

fn on_sys_rt_sigpending_return<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, u64, u32) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_rt_sigpending_return callback is hit.

fn on_sys_rt_sigprocmask_enter<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, i32, u64, u64, u32) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_rt_sigprocmask_enter callback is hit.

fn on_sys_rt_sigprocmask_return<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, i32, u64, u64, u32) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_rt_sigprocmask_return callback is hit.

fn on_sys_rt_sigqueueinfo_enter<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, i32, i32, u64) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_rt_sigqueueinfo_enter callback is hit.

fn on_sys_rt_sigqueueinfo_return<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, i32, i32, u64) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_rt_sigqueueinfo_return callback is hit.

fn on_sys_rt_sigreturn_enter<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_rt_sigreturn_enter callback is hit.

fn on_sys_rt_sigreturn_return<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_rt_sigreturn_return callback is hit.

fn on_sys_rt_sigsuspend_enter<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, u64, u32) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_rt_sigsuspend_enter callback is hit.

fn on_sys_rt_sigsuspend_return<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, u64, u32) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_rt_sigsuspend_return callback is hit.

fn on_sys_rt_sigtimedwait_enter<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, u64, u64, u64, u32) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_rt_sigtimedwait_enter callback is hit.

fn on_sys_rt_sigtimedwait_return<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, u64, u64, u64, u32) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_rt_sigtimedwait_return callback is hit.

fn on_sys_rt_tgsigqueueinfo_enter<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, i32, i32, i32, u64) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_rt_tgsigqueueinfo_enter callback is hit.

fn on_sys_rt_tgsigqueueinfo_return<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, i32, i32, i32, u64) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_rt_tgsigqueueinfo_return callback is hit.

fn on_sys_sched_get_priority_max_enter<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, i32) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_sched_get_priority_max_enter callback is hit.

fn on_sys_sched_get_priority_max_return<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, i32) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_sched_get_priority_max_return callback is hit.

fn on_sys_sched_get_priority_min_enter<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, i32) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_sched_get_priority_min_enter callback is hit.

fn on_sys_sched_get_priority_min_return<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, i32) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_sched_get_priority_min_return callback is hit.

fn on_sys_sched_getaffinity_enter<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, i32, u32, u64) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_sched_getaffinity_enter callback is hit.

fn on_sys_sched_getaffinity_return<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, i32, u32, u64) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_sched_getaffinity_return callback is hit.

fn on_sys_sched_getattr_enter<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, i32, u64, u32, u32) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_sched_getattr_enter callback is hit.

fn on_sys_sched_getattr_return<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, i32, u64, u32, u32) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_sched_getattr_return callback is hit.

fn on_sys_sched_getparam_enter<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, i32, u64) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_sched_getparam_enter callback is hit.

fn on_sys_sched_getparam_return<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, i32, u64) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_sched_getparam_return callback is hit.

fn on_sys_sched_getscheduler_enter<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, i32) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_sched_getscheduler_enter callback is hit.

fn on_sys_sched_getscheduler_return<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, i32) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_sched_getscheduler_return callback is hit.

fn on_sys_sched_rr_get_interval_enter<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, i32, u64) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_sched_rr_get_interval_enter callback is hit.

fn on_sys_sched_rr_get_interval_return<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, i32, u64) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_sched_rr_get_interval_return callback is hit.

fn on_sys_sched_setaffinity_enter<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, i32, u32, u64) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_sched_setaffinity_enter callback is hit.

fn on_sys_sched_setaffinity_return<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, i32, u32, u64) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_sched_setaffinity_return callback is hit.

fn on_sys_sched_setattr_enter<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, i32, u64, u32) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_sched_setattr_enter callback is hit.

fn on_sys_sched_setattr_return<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, i32, u64, u32) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_sched_setattr_return callback is hit.

fn on_sys_sched_setparam_enter<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, i32, u64) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_sched_setparam_enter callback is hit.

fn on_sys_sched_setparam_return<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, i32, u64) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_sched_setparam_return callback is hit.

fn on_sys_sched_setscheduler_enter<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, i32, i32, u64) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_sched_setscheduler_enter callback is hit.

fn on_sys_sched_setscheduler_return<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, i32, i32, u64) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_sched_setscheduler_return callback is hit.

fn on_sys_sched_yield_enter<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_sched_yield_enter callback is hit.

fn on_sys_sched_yield_return<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_sched_yield_return callback is hit.

fn on_sys_seccomp_enter<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, u32, u32, u64) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_seccomp_enter callback is hit.

fn on_sys_seccomp_return<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, u32, u32, u64) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_seccomp_return callback is hit.

fn on_sys_select_enter<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, i32, u64, u64, u64, u64) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_select_enter callback is hit.

fn on_sys_select_return<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, i32, u64, u64, u64, u64) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_select_return callback is hit.

fn on_sys_semctl_enter<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, i32, i32, i32, u64) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_semctl_enter callback is hit.

fn on_sys_semctl_return<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, i32, i32, i32, u64) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_semctl_return callback is hit.

fn on_sys_semget_enter<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, u32, i32, i32) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_semget_enter callback is hit.

fn on_sys_semget_return<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, u32, i32, i32) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_semget_return callback is hit.

fn on_sys_semop_enter<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, i32, u64, u32) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_semop_enter callback is hit.

fn on_sys_semop_return<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, i32, u64, u32) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_semop_return callback is hit.

fn on_sys_semtimedop_enter<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, i32, u64, u32, u64) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_semtimedop_enter callback is hit.

fn on_sys_semtimedop_return<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, i32, u64, u32, u64) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_semtimedop_return callback is hit.

fn on_sys_sendfile64_enter<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, i32, i32, u64, u32) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_sendfile64_enter callback is hit.

fn on_sys_sendfile64_return<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, i32, i32, u64, u32) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_sendfile64_return callback is hit.

fn on_sys_sendmmsg_enter<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, i32, u64, u32, u32) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_sendmmsg_enter callback is hit.

fn on_sys_sendmmsg_return<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, i32, u64, u32, u32) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_sendmmsg_return callback is hit.

fn on_sys_sendmsg_enter<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, i32, u64, u32) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_sendmsg_enter callback is hit.

fn on_sys_sendmsg_return<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, i32, u64, u32) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_sendmsg_return callback is hit.

fn on_sys_sendto_enter<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, i32, u64, u32, u32, u64, i32) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_sendto_enter callback is hit.

fn on_sys_sendto_return<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, i32, u64, u32, u32, u64, i32) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_sendto_return callback is hit.

fn on_sys_set_mempolicy_enter<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, i32, u64, u64) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_set_mempolicy_enter callback is hit.

fn on_sys_set_mempolicy_return<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, i32, u64, u64) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_set_mempolicy_return callback is hit.

fn on_sys_set_robust_list_enter<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, u64, u32) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_set_robust_list_enter callback is hit.

fn on_sys_set_robust_list_return<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, u64, u32) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_set_robust_list_return callback is hit.

fn on_sys_set_tid_address_enter<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, u64) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_set_tid_address_enter callback is hit.

fn on_sys_set_tid_address_return<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, u64) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_set_tid_address_return callback is hit.

fn on_sys_setdomainname_enter<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, u64, i32) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_setdomainname_enter callback is hit.

fn on_sys_setdomainname_return<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, u64, i32) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_setdomainname_return callback is hit.

fn on_sys_setfsgid_enter<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, u32) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_setfsgid_enter callback is hit.

fn on_sys_setfsgid_return<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, u32) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_setfsgid_return callback is hit.

fn on_sys_setfsuid_enter<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, u32) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_setfsuid_enter callback is hit.

fn on_sys_setfsuid_return<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, u32) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_setfsuid_return callback is hit.

fn on_sys_setgid_enter<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, u32) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_setgid_enter callback is hit.

fn on_sys_setgid_return<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, u32) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_setgid_return callback is hit.

fn on_sys_setgroups_enter<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, i32, u64) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_setgroups_enter callback is hit.

fn on_sys_setgroups_return<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, i32, u64) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_setgroups_return callback is hit.

fn on_sys_sethostname_enter<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, u64, i32) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_sethostname_enter callback is hit.

fn on_sys_sethostname_return<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, u64, i32) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_sethostname_return callback is hit.

fn on_sys_setitimer_enter<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, i32, u64, u64) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_setitimer_enter callback is hit.

fn on_sys_setitimer_return<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, i32, u64, u64) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_setitimer_return callback is hit.

fn on_sys_setns_enter<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, i32, i32) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_setns_enter callback is hit.

fn on_sys_setns_return<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, i32, i32) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_setns_return callback is hit.

fn on_sys_setpgid_enter<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, i32, i32) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_setpgid_enter callback is hit.

fn on_sys_setpgid_return<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, i32, i32) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_setpgid_return callback is hit.

fn on_sys_setpriority_enter<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, i32, i32, i32) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_setpriority_enter callback is hit.

fn on_sys_setpriority_return<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, i32, i32, i32) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_setpriority_return callback is hit.

fn on_sys_setregid_enter<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, u32, u32) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_setregid_enter callback is hit.

fn on_sys_setregid_return<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, u32, u32) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_setregid_return callback is hit.

fn on_sys_setresgid_enter<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, u32, u32, u32) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_setresgid_enter callback is hit.

fn on_sys_setresgid_return<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, u32, u32, u32) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_setresgid_return callback is hit.

fn on_sys_setresuid_enter<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, u32, u32, u32) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_setresuid_enter callback is hit.

fn on_sys_setresuid_return<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, u32, u32, u32) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_setresuid_return callback is hit.

fn on_sys_setreuid_enter<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, u32, u32) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_setreuid_enter callback is hit.

fn on_sys_setreuid_return<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, u32, u32) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_setreuid_return callback is hit.

fn on_sys_setrlimit_enter<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, u32, u64) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_setrlimit_enter callback is hit.

fn on_sys_setrlimit_return<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, u32, u64) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_setrlimit_return callback is hit.

fn on_sys_setsid_enter<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_setsid_enter callback is hit.

fn on_sys_setsid_return<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_setsid_return callback is hit.

fn on_sys_setsockopt_enter<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, i32, i32, i32, u64, i32) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_setsockopt_enter callback is hit.

fn on_sys_setsockopt_return<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, i32, i32, i32, u64, i32) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_setsockopt_return callback is hit.

fn on_sys_settimeofday_enter<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, u64, u64) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_settimeofday_enter callback is hit.

fn on_sys_settimeofday_return<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, u64, u64) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_settimeofday_return callback is hit.

fn on_sys_setuid_enter<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, u32) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_setuid_enter callback is hit.

fn on_sys_setuid_return<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, u32) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_setuid_return callback is hit.

fn on_sys_setxattr_enter<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, u64, u64, u64, u32, i32) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_setxattr_enter callback is hit.

fn on_sys_setxattr_return<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, u64, u64, u64, u32, i32) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_setxattr_return callback is hit.

fn on_sys_shmat_enter<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, i32, u64, i32) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_shmat_enter callback is hit.

fn on_sys_shmat_return<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, i32, u64, i32) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_shmat_return callback is hit.

fn on_sys_shmctl_enter<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, i32, i32, u64) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_shmctl_enter callback is hit.

fn on_sys_shmctl_return<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, i32, i32, u64) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_shmctl_return callback is hit.

fn on_sys_shmdt_enter<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, u64) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_shmdt_enter callback is hit.

fn on_sys_shmdt_return<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, u64) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_shmdt_return callback is hit.

fn on_sys_shmget_enter<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, u32, u32, i32) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_shmget_enter callback is hit.

fn on_sys_shmget_return<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, u32, u32, i32) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_shmget_return callback is hit.

fn on_sys_shutdown_enter<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, i32, i32) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_shutdown_enter callback is hit.

fn on_sys_shutdown_return<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, i32, i32) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_shutdown_return callback is hit.

fn on_sys_sigaltstack_enter<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, u64, u64) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_sigaltstack_enter callback is hit.

fn on_sys_sigaltstack_return<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, u64, u64) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_sigaltstack_return callback is hit.

fn on_sys_signalfd_enter<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, i32, u64, u32) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_signalfd_enter callback is hit.

fn on_sys_signalfd_return<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, i32, u64, u32) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_signalfd_return callback is hit.

fn on_sys_signalfd4_enter<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, i32, u64, u32, i32) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_signalfd4_enter callback is hit.

fn on_sys_signalfd4_return<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, i32, u64, u32, i32) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_signalfd4_return callback is hit.

fn on_sys_socket_enter<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, i32, i32, i32) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_socket_enter callback is hit.

fn on_sys_socket_return<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, i32, i32, i32) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_socket_return callback is hit.

fn on_sys_socketpair_enter<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, i32, i32, i32, u64) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_socketpair_enter callback is hit.

fn on_sys_socketpair_return<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, i32, i32, i32, u64) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_socketpair_return callback is hit.

fn on_sys_splice_enter<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, i32, u64, i32, u64, u32, u32) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_splice_enter callback is hit.

fn on_sys_splice_return<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, i32, u64, i32, u64, u32, u32) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_splice_return callback is hit.

fn on_sys_statfs_enter<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, u64, u64) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_statfs_enter callback is hit.

fn on_sys_statfs_return<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, u64, u64) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_statfs_return callback is hit.

fn on_sys_statx_enter<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, i32, u64, u32, u32, u64) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_statx_enter callback is hit.

fn on_sys_statx_return<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, i32, u64, u32, u32, u64) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_statx_return callback is hit.

fn on_sys_swapoff_enter<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, u64) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_swapoff_enter callback is hit.

fn on_sys_swapoff_return<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, u64) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_swapoff_return callback is hit.

fn on_sys_swapon_enter<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, u64, i32) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_swapon_enter callback is hit.

fn on_sys_swapon_return<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, u64, i32) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_swapon_return callback is hit.

fn on_sys_symlink_enter<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, u64, u64) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_symlink_enter callback is hit.

fn on_sys_symlink_return<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, u64, u64) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_symlink_return callback is hit.

fn on_sys_symlinkat_enter<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, u64, i32, u64) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_symlinkat_enter callback is hit.

fn on_sys_symlinkat_return<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, u64, i32, u64) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_symlinkat_return callback is hit.

fn on_sys_sync_enter<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_sync_enter callback is hit.

fn on_sys_sync_return<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_sync_return callback is hit.

fn on_sys_sync_file_range_enter<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, i32, u64, u64, u32) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_sync_file_range_enter callback is hit.

fn on_sys_sync_file_range_return<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, i32, u64, u64, u32) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_sync_file_range_return callback is hit.

fn on_sys_syncfs_enter<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, i32) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_syncfs_enter callback is hit.

fn on_sys_syncfs_return<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, i32) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_syncfs_return callback is hit.

fn on_sys_sysctl_enter<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, u64) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_sysctl_enter callback is hit.

fn on_sys_sysctl_return<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, u64) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_sysctl_return callback is hit.

fn on_sys_sysfs_enter<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, i32, u64, u64) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_sysfs_enter callback is hit.

fn on_sys_sysfs_return<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, i32, u64, u64) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_sysfs_return callback is hit.

fn on_sys_sysinfo_enter<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, u64) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_sysinfo_enter callback is hit.

fn on_sys_sysinfo_return<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, u64) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_sysinfo_return callback is hit.

fn on_sys_syslog_enter<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, i32, u64, i32) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_syslog_enter callback is hit.

fn on_sys_syslog_return<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, i32, u64, i32) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_syslog_return callback is hit.

fn on_sys_tee_enter<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, i32, i32, u32, u32) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_tee_enter callback is hit.

fn on_sys_tee_return<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, i32, i32, u32, u32) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_tee_return callback is hit.

fn on_sys_tgkill_enter<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, i32, i32, i32) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_tgkill_enter callback is hit.

fn on_sys_tgkill_return<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, i32, i32, i32) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_tgkill_return callback is hit.

fn on_sys_time_enter<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, u64) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_time_enter callback is hit.

fn on_sys_time_return<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, u64) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_time_return callback is hit.

fn on_sys_timer_create_enter<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, u32, u64, u64) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_timer_create_enter callback is hit.

fn on_sys_timer_create_return<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, u32, u64, u64) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_timer_create_return callback is hit.

fn on_sys_timer_delete_enter<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, u32) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_timer_delete_enter callback is hit.

fn on_sys_timer_delete_return<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, u32) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_timer_delete_return callback is hit.

fn on_sys_timer_getoverrun_enter<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, u32) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_timer_getoverrun_enter callback is hit.

fn on_sys_timer_getoverrun_return<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, u32) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_timer_getoverrun_return callback is hit.

fn on_sys_timer_gettime_enter<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, u32, u64) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_timer_gettime_enter callback is hit.

fn on_sys_timer_gettime_return<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, u32, u64) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_timer_gettime_return callback is hit.

fn on_sys_timer_settime_enter<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, u32, i32, u64, u64) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_timer_settime_enter callback is hit.

fn on_sys_timer_settime_return<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, u32, i32, u64, u64) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_timer_settime_return callback is hit.

fn on_sys_timerfd_create_enter<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, i32, i32) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_timerfd_create_enter callback is hit.

fn on_sys_timerfd_create_return<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, i32, i32) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_timerfd_create_return callback is hit.

fn on_sys_timerfd_gettime_enter<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, i32, u64) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_timerfd_gettime_enter callback is hit.

fn on_sys_timerfd_gettime_return<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, i32, u64) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_timerfd_gettime_return callback is hit.

fn on_sys_timerfd_settime_enter<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, i32, i32, u64, u64) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_timerfd_settime_enter callback is hit.

fn on_sys_timerfd_settime_return<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, i32, i32, u64, u64) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_timerfd_settime_return callback is hit.

fn on_sys_times_enter<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, u64) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_times_enter callback is hit.

fn on_sys_times_return<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, u64) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_times_return callback is hit.

fn on_sys_tkill_enter<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, i32, i32) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_tkill_enter callback is hit.

fn on_sys_tkill_return<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, i32, i32) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_tkill_return callback is hit.

fn on_sys_truncate_enter<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, u64, i64) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_truncate_enter callback is hit.

fn on_sys_truncate_return<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, u64, i64) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_truncate_return callback is hit.

fn on_sys_umask_enter<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, i32) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_umask_enter callback is hit.

fn on_sys_umask_return<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, i32) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_umask_return callback is hit.

fn on_sys_umount_enter<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, u64, i32) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_umount_enter callback is hit.

fn on_sys_umount_return<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, u64, i32) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_umount_return callback is hit.

fn on_sys_unlink_enter<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, u64) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_unlink_enter callback is hit.

fn on_sys_unlink_return<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, u64) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_unlink_return callback is hit.

fn on_sys_unlinkat_enter<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, i32, u64, i32) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_unlinkat_enter callback is hit.

fn on_sys_unlinkat_return<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, i32, u64, i32) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_unlinkat_return callback is hit.

fn on_sys_unshare_enter<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, u64) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_unshare_enter callback is hit.

fn on_sys_unshare_return<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, u64) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_unshare_return callback is hit.

fn on_sys_userfaultfd_enter<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, i32) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_userfaultfd_enter callback is hit.

fn on_sys_userfaultfd_return<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, i32) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_userfaultfd_return callback is hit.

fn on_sys_ustat_enter<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, u32, u64) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_ustat_enter callback is hit.

fn on_sys_ustat_return<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, u32, u64) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_ustat_return callback is hit.

fn on_sys_utime_enter<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, u64, u64) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_utime_enter callback is hit.

fn on_sys_utime_return<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, u64, u64) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_utime_return callback is hit.

fn on_sys_utimensat_enter<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, i32, u64, u64, i32) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_utimensat_enter callback is hit.

fn on_sys_utimensat_return<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, i32, u64, u64, i32) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_utimensat_return callback is hit.

fn on_sys_utimes_enter<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, u64, u64) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_utimes_enter callback is hit.

fn on_sys_utimes_return<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, u64, u64) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_utimes_return callback is hit.

fn on_sys_vfork_enter<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_vfork_enter callback is hit.

fn on_sys_vfork_return<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_vfork_return callback is hit.

fn on_sys_vhangup_enter<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_vhangup_enter callback is hit.

fn on_sys_vhangup_return<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_vhangup_return callback is hit.

fn on_sys_vmsplice_enter<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, i32, u64, u64, u32) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_vmsplice_enter callback is hit.

fn on_sys_vmsplice_return<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, i32, u64, u64, u32) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_vmsplice_return callback is hit.

fn on_sys_wait4_enter<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, i32, u64, i32, u64) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_wait4_enter callback is hit.

fn on_sys_wait4_return<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, i32, u64, i32, u64) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_wait4_return callback is hit.

fn on_sys_waitid_enter<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, i32, i32, u64, i32, u64) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_waitid_enter callback is hit.

fn on_sys_waitid_return<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, i32, i32, u64, i32, u64) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_waitid_return callback is hit.

fn on_sys_write_enter<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, u32, u64, u32) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_write_enter callback is hit.

fn on_sys_write_return<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, u32, u64, u32) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_write_return callback is hit.

fn on_sys_writev_enter<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, u64, u64, u64) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_writev_enter callback is hit.

fn on_sys_writev_return<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, u64, u64, u64) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_sys_writev_return callback is hit.

fn on_all_sys_enter<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, target_ulong) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_all_sys_enter callback is hit.

fn on_all_sys_return<CallbackFn>(self, callback: CallbackFn) where
    CallbackFn: FnMut(&mut CPUState, target_ulong, target_ulong) + 'static, 

Installs the given closure over the callback slot provided by the panda::PppCallback this is called on, setting it to be run whenever the on_all_sys_return callback is hit.

impl Copy for PppCallback

impl Eq for PppCallback

impl StructuralEq for PppCallback

impl StructuralPartialEq for PppCallback