Struct Tsffs

#[repr(C)]
pub(crate) struct Tsffs {

    pub(crate) conf_object: ConfObject,
    pub all_breakpoints_are_solutions: bool,
    pub all_exceptions_are_solutions: bool,
    pub exceptions: BTreeSet<i64>,
    pub breakpoints: BTreeSet<BreakpointId>,
    pub timeout: f64,
    pub start_on_harness: bool,
    pub stop_on_harness: bool,
    pub magic_start_index: u64,
    pub magic_stop_indices: Vec<u64>,
    pub magic_assert_indices: Vec<u64>,
    pub iteration_limit: usize,
    pub initial_random_corpus_size: usize,
    pub corpus_directory: PathBuf,
    pub solutions_directory: PathBuf,
    pub generate_random_corpus: bool,
    pub cmplog: bool,
    pub coverage_reporting: bool,
    pub token_executables: Vec<PathBuf>,
    pub token_src_files: Vec<PathBuf>,
    pub token_files: Vec<PathBuf>,
    pub tokens: Vec<Vec<u8>>,
    pub checkpoint_path: PathBuf,
    pub pre_snapshot_checkpoint: bool,
    pub log_path: PathBuf,
    pub log_to_file: bool,
    pub keep_all_corpus: bool,
    pub use_initial_as_corpus: bool,
    pub debug_log_libafl: bool,
    pub shutdown_on_stop_without_reason: bool,
    pub quit_on_iteration_limit: bool,
    pub save_timeout_execution_traces: bool,
    pub save_solution_execution_traces: bool,
    pub save_interesting_execution_traces: bool,
    pub save_all_execution_traces: bool,
    pub execution_trace_directory: PathBuf,
    pub execution_trace_pc_only: bool,
    pub heartbeat: bool,
    pub heartbeat_interval: u64,
    pub symbolic_coverage: bool,
    pub windows: bool,
    pub debuginfo_download_directory: PathBuf,
    pub debug_info: HashMap<String, Vec<PathBuf>>,
    pub debuginfo_source_directory: PathBuf,
    pub symbolic_coverage_system: bool,
    pub symbolic_coverage_directory: PathBuf,
    pub(crate) stop_hap_handle: HapHandle,
    pub(crate) breakpoint_memop_hap_handle: HapHandle,
    pub(crate) exception_hap_handle: HapHandle,
    pub(crate) magic_hap_handle: HapHandle,
    pub(crate) control_register_write_hap_handle: HapHandle,
    pub architecture_hints: HashMap<i32, ArchitectureHint>,
    pub(crate) fuzz_thread: OnceCell<JoinHandle<Result<()>>>,
    pub(crate) fuzzer_tx: OnceCell<Sender<ExitKind>>,
    pub(crate) fuzzer_rx: OnceCell<Receiver<Testcase>>,
    pub(crate) fuzzer_shutdown: OnceCell<Sender<ShutdownMessage>>,
    pub(crate) fuzzer_messages: OnceCell<Receiver<FuzzerMessage>>,
    pub(crate) coverage_map: OnceCell<OwnedMutSlice<'static, u8>>,
    pub(crate) aflpp_cmp_map_ptr: OnceCell<*mut AFLppCmpLogMap>,
    pub(crate) aflpp_cmp_map: OnceCell<&'static mut AFLppCmpLogMap>,
    pub(crate) coverage_prev_loc: u64,
    pub(crate) timeout_event: OnceCell<Event>,
    pub(crate) edges_seen: HashSet<u64>,
    pub(crate) edges_seen_since_last: HashMap<u64, u64>,
    pub(crate) execution_trace: ExecutionTrace,
    pub(crate) coverage: Records,
    pub(crate) snapshot_name: OnceCell<String>,
    pub(crate) micro_checkpoint_index: OnceCell<i32>,
    pub(crate) stop_reason: Option<StopReason>,
    pub(crate) start_info: OnceCell<StartInfo>,
    pub(crate) start_time: OnceCell<SystemTime>,
    pub(crate) last_heartbeat_time: Option<SystemTime>,
    pub(crate) log: OnceCell<File>,
    pub(crate) coverage_enabled: bool,
    pub(crate) cmplog_enabled: bool,
    pub(crate) start_processor_number: OnceCell<i32>,
    pub(crate) processors: HashMap<i32, Architecture>,
    pub(crate) repro_testcase: Option<Vec<u8>>,
    pub(crate) repro_bookmark_set: bool,
    pub(crate) stopped_for_repro: bool,
    pub(crate) iterations: usize,
    pub(crate) use_snapshots: bool,
    pub(crate) timeouts: usize,
    pub(crate) solutions: usize,
    pub(crate) windows_os_info: WindowsOsInfo,
    pub(crate) cr3_cache: HashMap<i32, i64>,
    pub(crate) source_file_cache: SourceCache,
}

The main module class for the TSFFS fuzzer, stores state and configuration information

Fields

conf_object: ConfObject

all_breakpoints_are_solutions: bool

Whether all breakpoints are treated as solutions. When set to True, any breakpoint which triggers a Core_Breakpoint_Memop HAP will be treated as a solution. This allows setting memory breakpoints on specific memory locations to trigger a solution when the memory is read, written, or executed. Not all breakpoints cause this HAP to occur.

For example, to set an execution breakpoint on the address $addr:

$addr = 0x100000 $bp = (bp.memory.break -x $addr) @tsffs.all_breakpoints_are_solutions = True

Tsffs will treat the breakpoint as a solution (along with all other breakpoints), and the fuzzer will stop when the breakpoint is hit.

all_exceptions_are_solutions: bool

Whether all exceptions are treated as solutions. When set to True, any CPU exception or interrupt which triggers a Core_Exception HAP will be treated as a solution. This can be useful when enabled in a callback after which any exception is considered a solution and is typically not useful when enabled during the start-up process because most processors will generate exceptions during start-up and during normal operation.

exceptions: BTreeSet<i64>

The set of exceptions which are treated as solutions. For example on x86_64, setting:

@tsffs.exceptions = [14]

would treat any page fault as a solution.

breakpoints: BTreeSet<BreakpointId>

The set of breakpoints which are treated as solutions. For example, to set a solution breakpoint on the address $addr (note the breakpoint set from the Simics command is accessed through the simenv namespace):

$addr = 0x100000 $bp = (bp.memory.break -x $addr) @tsffs.breakpoints = [simenv.bp]

timeout: f64

The timeout in seconds of virtual time for each iteration of the fuzzer. If the virtual time timeout is exceeded for a single iteration, the iteration is stopped and the testcase is saved as a solution.

start_on_harness: bool

Whether the fuzzer should start on compiled-in harnesses. If set to True, the fuzzer will start fuzzing when a harness macro is executed.

stop_on_harness: bool

Whether the fuzzer should stop on compiled-in harnesses. If set to True, the fuzzer will start fuzzing when a harness macro is executed.

magic_start_index: u64

The index number which is passed to the platform-specific magic instruction HAP by a compiled-in harness to signal that the fuzzer should start the fuzzing loop.

This option is useful when fuzzing a target which has multiple start harnesses compiled into it, and the fuzzer should start on a specific harness.

There can only be one magic start value, because only one fuzzing loop can be running (and they cannot be nested). This only has an effect if start_on_harness is set.

magic_stop_indices: Vec<u64>

The magic numbers which is passed to the platform-specific magic instruction HAP by a compiled-in harness to signal that the fuzzer should stop execution of the current iteration.

This option is useful when fuzzing a target which has multiple stop harnesses compiled into it, and the fuzzer should stop on a specific subset of stop harness macro calls.

This only has an effect if stop_on_harness is set.

magic_assert_indices: Vec<u64>

The numbers which are passed to the platform-specific magic instruction HAP by a compiled-in harness to signal that the fuzzer should stop execution of the current iteration and save the testcase as a solution.

This only has an effect if stop_on_harness is set.

iteration_limit: usize

The limit on the number of fuzzing iterations to execute. If set to 0, the fuzzer will run indefinitely. If set to a positive integer, the fuzzer will run until the limit is reached.

initial_random_corpus_size: usize

The size of the corpus to generate randomly. If generate_random_corpus is set to True, the fuzzer will generate a random corpus of this size before starting the fuzzing loop.

corpus_directory: PathBuf

The directory to load the corpus from and save new corpus items to. This directory may be a SIMICS relative path prefixed with “%simics%”. It is an error to provide no corpus directory when set_generate_random_corpus(True) has not been called prior to fuzzer startup. It is also an error to provide an empty corpus directory without calling set_generate_random_corpus(True). If not provided, “%simics%/corpus” will be used by default.

solutions_directory: PathBuf

The directory to save solutions to. This directory may be a SIMICS relative path prefixed with “%simics%”. If not provided, “%simics%/solutions” will be used by default.

generate_random_corpus: bool

Whether to generate a random corpus before starting the fuzzing loop. If set to True, the fuzzer will generate a random corpus of size initial_random_corpus_size before starting the fuzzing loop. This should generally be used only for debugging and testing purposes, and is not recommended for use in production. A real corpus representative of both valid and invalid inputs should be used in production.

cmplog: bool

Whether comparison logging should be used during fuzzing to enable value-driven mutations. If set to True, the fuzzer will use comparison logging to enable value-driven mutations. This should always be enabled unless the target is known to not benefit from value-driven mutations or run too slowly when solving for comparison values.

coverage_reporting: bool

Whether coverage reporting should be enabled. When enabled, new edge addresses will be logged.

token_executables: Vec<PathBuf>

A set of executable files to tokenize. Tokens will be extracted from these files and used to drive token mutations of testcases.

token_src_files: Vec<PathBuf>

A set of source files to tokenize. Tokens will be extracted from these files and used to drive token mutations of testcases. C source files are expected, and strings and tokens will be extracted from strings in the source files.

token_files: Vec<PathBuf>

Files in the format of:

x = “hello” y = “foo\x41bar”

which will be used to drive token mutations of testcases.

tokens: Vec<Vec<u8>>

Sets of tokens to use to drive token mutations of testcases. Each token set is a bytes which will be randomically inserted into testcases.

checkpoint_path: PathBuf

The path to the checkpoint saved prior to fuzzing when using snapshots

pre_snapshot_checkpoint: bool

log_path: PathBuf

The path to the log file which will be used to log the fuzzer’s output statistics

log_to_file: bool

keep_all_corpus: bool

use_initial_as_corpus: bool

Whether to use the initial contents of the testcase buffer as an entry in the corpus

debug_log_libafl: bool

Whether to enable extra debug logging for LibAFL

shutdown_on_stop_without_reason: bool

Whether to send shut down on stops without reason. This means fuzzing cannot be resumed.

quit_on_iteration_limit: bool

Whether to quit on iteration limit

save_timeout_execution_traces: bool

Whether to save execution traces of test cases which result in a timeout

save_solution_execution_traces: bool

Whether to save execution traces of test cases which result in a solution

save_interesting_execution_traces: bool

Whether to save execution traces of test cases which result in an interesting input

save_all_execution_traces: bool

Whether to save all execution traces. This will consume a very large amount of resources and should only be used for debugging and testing purposes.

execution_trace_directory: PathBuf

The directory to save execution traces to, if any are set to be saved. This directory may be a SIMICS relative path prefixed with “%simics%”. If not provided, “%simics%/execution-traces” will be used by default.

execution_trace_pc_only: bool

Whether execution traces should include just PC (vs instruction text and bytes)

heartbeat: bool

Whether a heartbeat message should be emitted every heartbeat_interval seconds

heartbeat_interval: u64

The interval in seconds between heartbeat messages

symbolic_coverage: bool

Whether symbolic coverage should be used during fuzzing

windows: bool

Whether windows is being run in the simulation

debuginfo_download_directory: PathBuf

Directory in which to download PDB and EXE files from symbol servers on Windows

debug_info: HashMap<String, Vec<PathBuf>>

Mapping of file name (name and extension e.g. fuzzer-app.exe or target.sys) to a tuple of (exe path, debuginfo path) where debuginfo is either a PDB or DWARF file

debuginfo_source_directory: PathBuf

Directory in which source files are located. Source files do not need to be arranged in the same directory structure as the compiled source, and are looked up by hash.

symbolic_coverage_system: bool

Whether symbolic coverage should be collected for system components by downloading executable and debug info files where possible.

symbolic_coverage_directory: PathBuf

Directory in which source files are located. Source files do not need to be arranged in the same directory structure as the compiled source, and are looked up by hash.

stop_hap_handle: HapHandle

Handle for the core simulation stopped hap

breakpoint_memop_hap_handle: HapHandle

Handle for the core breakpoint memop hap

exception_hap_handle: HapHandle

Handle for exception HAP

magic_hap_handle: HapHandle

The handle for the registered magic HAP, used to listen for magic start and stop if start_on_harness or stop_on_harness are set.

control_register_write_hap_handle: HapHandle

Handle for the core control register write hap

architecture_hints: HashMap<i32, ArchitectureHint>

A mapping of architecture hints from CPU index to architecture hint. This architecture hint overrides the detected architecture of the CPU core. This is useful when the architecture of the CPU core is not detected correctly, or when the architecture of the CPU core is not known at the time the fuzzer is started. Specifically, x86 cores which report their architecture as x86_64 can be overridden to x86.

fuzz_thread: OnceCell<JoinHandle<Result<()>>>

Fuzzer thread

fuzzer_tx: OnceCell<Sender<ExitKind>>

Message sender to the fuzzer thread. TSFFS sends exit kinds to the fuzzer thread to report whether testcases resulted in normal exit, timeout, or solutions.

fuzzer_rx: OnceCell<Receiver<Testcase>>

Message receiver from the fuzzer thread. TSFFS receives new testcases and run configuration from the fuzzer thread.

fuzzer_shutdown: OnceCell<Sender<ShutdownMessage>>

A message sender to inform the fuzzer thread that it should exit.

fuzzer_messages: OnceCell<Receiver<FuzzerMessage>>

Reciever from the fuzzer thread to receive messages from the fuzzer thread including status messages and structured introspection data like new edge findings.

coverage_map: OnceCell<OwnedMutSlice<'static, u8>>

The coverage map

aflpp_cmp_map_ptr: OnceCell<*mut AFLppCmpLogMap>

A pointer to the AFL++ comparison map

aflpp_cmp_map: OnceCell<&'static mut AFLppCmpLogMap>

The owned AFL++ comparison map

coverage_prev_loc: u64

The previous location for coverage for calculating the hash of edges.

timeout_event: OnceCell<Event>

The registered timeout event which is registered and used to detect timeouts in virtual time

edges_seen: HashSet<u64>

The set of edges which have been seen at least once.

edges_seen_since_last: HashMap<u64, u64>

A map of the new edges to their AFL indices seen since the last time the fuzzer provided an update. This is not cleared every execution.

execution_trace: ExecutionTrace

The set of PCs comprising the current execution trace. This is cleared every execution.

coverage: Records

The current line coverage state comprising the total execution. This is not cleared and is persistent across the full campaign until the fuzzer stops.

snapshot_name: OnceCell<String>

The name of the fuzz snapshot, if saved

micro_checkpoint_index: OnceCell<i32>

The index of the micro checkpoint saved for the fuzzer. Only present if not using snapshots.

stop_reason: Option<StopReason>

The reason the current stop occurred

start_info: OnceCell<StartInfo>

The buffer and size information, if saved

start_time: OnceCell<SystemTime>

The time the fuzzer was started at

last_heartbeat_time: Option<SystemTime>

The time the fuzzer was started at

log: OnceCell<File>

coverage_enabled: bool

Whether cmplog is currently enabled

cmplog_enabled: bool

Whether cmplog is currently enabled

start_processor_number: OnceCell<i32>

The number of the processor which starts the fuzzing loop (via magic or manual methods)

processors: HashMap<i32, Architecture>

Tracked processors. This always includes the start processor, and may include additional processors that are manually added by the user

repro_testcase: Option<Vec<u8>>

A testcase to use for repro

repro_bookmark_set: bool

Whether a bookmark has been set for repro mode

stopped_for_repro: bool

Whether the fuzzer is currently stopped in repro mode

iterations: usize

The number of iterations which have been executed so far

use_snapshots: bool

Whether snapshots are used. Snapshots are used on Simics 7.0.0 and later.

timeouts: usize

The number of timeouts so far

solutions: usize

The number of solutions so far

windows_os_info: WindowsOsInfo

cr3_cache: HashMap<i32, i64>

source_file_cache: SourceCache

Implementations

impl Tsffs

const EDGES_OBSERVER_NAME: &'static str = "coverage"

const AFLPP_CMP_OBSERVER_NAME: &'static str = "aflpp_cmplog"

const CMPLOG_OBSERVER_NAME: &'static str = "cmplog"

const TIME_OBSERVER_NAME: &'static str = "time"

const TIMEOUT_FEEDBACK_NAME: &'static str = "time"

const CORPUS_CACHE_SIZE: usize = 4_096usize

pub fn start_fuzzer_thread(&mut self) -> Result<()>

Start the fuzzing thread.

pub fn send_shutdown(&mut self) -> Result<()>

pub fn get_testcase(&mut self) -> Result<Testcase>

impl Tsffs

fn on_simulation_stopped_magic_start( &mut self, magic_number: MagicNumber, ) -> Result<()>

fn on_simulation_stopped_magic_assert(&mut self) -> Result<()>

fn on_simulation_stopped_magic_stop(&mut self) -> Result<()>

fn on_simulation_stopped_with_magic( &mut self, magic_number: MagicNumber, ) -> Result<()>

fn on_simulation_stopped_with_manual_start( &mut self, processor: *mut ConfObject, info: ManualStartInfo, ) -> Result<()>

fn on_simulation_stopped_manual_start_without_buffer( &mut self, processor: *mut ConfObject, ) -> Result<()>

fn on_simulation_stopped_manual_stop(&mut self) -> Result<()>

fn on_simulation_stopped_solution(&mut self, kind: SolutionKind) -> Result<()>

fn on_simulation_stopped_with_reason( &mut self, reason: StopReason, ) -> Result<()>

fn on_simulation_stopped_without_reason(&mut self) -> Result<()>

pub fn on_simulation_stopped(&mut self) -> Result<()>

Called on core simulation stopped HAP

pub fn on_exception( &mut self, _obj: *mut ConfObject, exception: i64, ) -> Result<()>

Called on core exception HAP. Check to see if this exception is configured as a solution or all exceptions are solutions and trigger a stop if so

pub fn on_breakpoint_memop( &mut self, obj: *mut ConfObject, breakpoint: i64, transaction: *mut GenericTransaction, ) -> Result<()>

Called on breakpoint memory operation HAP. Check to see if this breakpoint is configured as a solution or if all breakpoints are solutions and trigger a stop if so

pub fn on_magic_instruction( &mut self, trigger_obj: *mut ConfObject, magic_number: MagicNumber, ) -> Result<()>

Check if magic instructions are set to trigger start and stop conditions, and trigger them if needed

pub fn on_control_register_write( &mut self, trigger_obj: *mut ConfObject, register_nr: i64, value: i64, ) -> Result<()>

impl Tsffs

pub fn add_trace_processor(&mut self, cpu: *mut ConfObject) -> Result<()>

pub fn add_architecture_hint( &mut self, cpu: *mut ConfObject, hint: *mut c_char, ) -> Result<()>

impl Tsffs

pub fn repro(&mut self, testcase_file: *mut c_char) -> Result<()>

pub fn start_with_buffer_ptr_size_ptr( &mut self, cpu: *mut ConfObject, buffer_address: GenericAddress, size_address: GenericAddress, virt: bool, ) -> Result<()>

pub fn start_with_buffer_ptr_size_value( &mut self, cpu: *mut ConfObject, testcase_address: GenericAddress, maximum_size: u32, virt: bool, ) -> Result<()>

pub fn start_with_buffer_ptr_size_ptr_value( &mut self, cpu: *mut ConfObject, buffer_address: GenericAddress, size_address: GenericAddress, maximum_size: u32, virt: bool, ) -> Result<()>

pub fn start_without_buffer( &mut self, cpu: *mut ConfObject, ) -> Result<AttrValue>

pub fn stop(&mut self) -> Result<()>

pub fn solution(&mut self, id: u64, message: *mut c_char) -> Result<()>

impl Tsffs

pub fn log_messages(&mut self) -> Result<()>

pub fn log<I>(&mut self, item: I) -> Result<()>

where I: Serialize,

impl Tsffs

pub fn on_control_register_write_windows_symcov( &mut self, trigger_obj: *mut ConfObject, register_nr: i64, value: i64, ) -> Result<()>

Triggered on control register write to refresh windows OS information if necessary

impl Tsffs

fn log_pc(&mut self, pc: u64) -> Result<()>

fn log_cmp( &mut self, pc: u64, types: Vec<CmpType>, cmp: CmpValues, ) -> Result<()>

impl Tsffs

pub fn on_instruction_after( &mut self, _obj: *mut ConfObject, cpu: *mut ConfObject, handle: *mut instruction_handle_t, ) -> Result<()>

pub fn on_instruction_before( &mut self, _obj: *mut ConfObject, cpu: *mut ConfObject, handle: *mut instruction_handle_t, ) -> Result<()>

impl Tsffs

pub(crate) const CLASS: ClassInfo

impl Tsffs

pub const NAME: &'static str = "tsffs"

The name of the class

impl Tsffs

pub(crate) fn new(obj: *mut ConfObject, value: Tsffs) -> *mut ConfObject

impl Tsffs

pub const COVERAGE_MAP_SIZE: usize = 131_072usize

The size of the coverage map in bytes

pub const TIMEOUT_EVENT_NAME: &'static str = "detector_timeout_event"

The name of the registered timeout event

pub const SNAPSHOT_NAME: &'static str = "tsffs-origin-snapshot"

The name of the initial snapshot

impl Tsffs

Implementations for controlling the simulation

pub fn stop_simulation(&mut self, reason: StopReason) -> Result<()>

Stop the simulation with a reason

impl Tsffs

Implementations for common functionality

pub fn add_processor( &mut self, cpu: *mut ConfObject, is_start: bool, ) -> Result<()>

Add a monitored processor to the simulation and whether the processor is the “start processor” which is the processor running when the fuzzing loop begins

pub fn start_processor(&mut self) -> Option<&mut Architecture>

Return a reference to the saved “start processor” if there is one. There will be no “start processor” before a start harness (manual or magic) is executed.

impl Tsffs

pub fn save_initial_snapshot(&mut self) -> Result<()>

Save the initial snapshot using the configured method (either rev-exec micro checkpoints or snapshots)

pub fn restore_initial_snapshot(&mut self) -> Result<()>

Restore the initial snapshot using the configured method (either rev-exec micro checkpoints or snapshots)

pub fn have_initial_snapshot(&self) -> bool

Whether an initial snapshot has been saved

pub fn save_repro_bookmark_if_needed(&mut self) -> Result<()>

Save a repro bookmark if one is needed

impl Tsffs

pub fn get_and_write_testcase(&mut self) -> Result<()>

Get a testcase from the fuzzer and write it to memory along with, optionally, a size

pub fn post_timeout_event(&mut self) -> Result<()>

Post a new timeout event on the start processor with the configured timeout in seconds

pub fn cancel_timeout_event(&mut self) -> Result<()>

Cancel a pending timeout event, if there is one. Used when execution reaches a solution or normal stop condition before a timeout occurs.

pub fn save_symbolic_coverage(&mut self) -> Result<()>

pub fn save_execution_trace(&mut self) -> Result<()>

Save the current execution trace to a file

Trait Implementations

impl AsConfObject for Tsffs

fn as_conf_object(&self) -> *const conf_object

Convert a reference to this object to a raw ConfObject pointer

fn as_conf_object_mut(&mut self) -> *mut conf_object

Convert a mutable reference to this object to a raw ConfObject pointer

impl ClassAlloc for Tsffs

unsafe fn alloc<T>(_cls: *mut conf_class) -> Result<*mut conf_object, Error>

Allocates an instance of the object using mm_zalloc and returns a pointer to the allocated object, whose first entry is the ConfObject instance associated with it

impl ClassCreate for Tsffs

fn create() -> Result<*mut ConfClass>

Create a class and register it in SIMICS. This does not instantiate the class by creating any objects, it only creates the (python) class that is used as a blueprint to instantiate the class

impl ClassDealloc for Tsffs

unsafe fn dealloc(instance: *mut conf_object) -> Result<(), Error>

Called after all objects are deinitialized, this should free the allocated object using mm_free

impl ClassDeinit for Tsffs

unsafe fn deinit(_instance: *mut conf_object) -> Result<(), Error>

Called first on all objects being deleted, should do the opposite of init and deinitialize any additionally-allocated memory, destroy file descriptors, etc. The default implementation of this method does nothing

impl ClassFinalize for Tsffs

unsafe fn finalize(_instance: *mut conf_object) -> Result<(), Error>

Object can do final initialization that requires attribute values, but should avoid calling interface methods on other objects. The default implementation of this method does nothing

impl ClassInit for Tsffs

unsafe fn init(instance: *mut ConfObject) -> Result<*mut ConfObject>

Perform class specific instantiation, set default values for attributes. May allocate additional memory if co-allocation is not used. Attribute setters are called after this function returns. The default implementation returns the object without modification. Returning NULL from this function indicates an error

impl ClassObjectsFinalize for Tsffs

unsafe fn objects_finalized(instance: *mut ConfObject) -> Result<()>

Called after object is fully constructed and can participate in simulation and reverse execution. May call interface methods on other objects here as part of initialization. The default implementation of this method does nothing

impl Default for Tsffs

fn default() -> Tsffs

Returns the “default value” for a type.

impl<'x> From<*const conf_object> for &'x Tsffs

fn from(obj: *const ConfObject) -> &'x Tsffs

Convert a raw ConfObject pointer to a reference to this object

Safety

This function dereferences a raw pointer. It must be called with a valid pointer which has a sufficient lifetime.

impl From<*mut c_void> for &'static Tsffs

fn from(value: *mut c_void) -> Self

Converts to this type from the input type.

impl From<*mut c_void> for &'static mut Tsffs

fn from(value: *mut c_void) -> Self

Converts to this type from the input type.

impl<'x> From<*mut conf_object> for &'x Tsffs

fn from(obj: *mut ConfObject) -> &'x Tsffs

Convert a raw ConfObject pointer to a mutable reference to this object

Safety

This function dereferences a raw pointer. It must be called with a valid pointer which has a sufficient lifetime.

impl<'x> From<*mut conf_object> for &'x mut Tsffs

fn from(obj: *mut ConfObject) -> &'x mut Tsffs

Convert a raw ConfObject pointer to a mutable reference to this object

Safety

This function dereferences a raw pointer. It must be called with a valid pointer which has a sufficient lifetime.

impl FromConfObject for Tsffs

unsafe fn from_conf_object<'a>(obj: *const conf_object) -> &'a Self

Get a reference to this object from a raw ConfObject pointer

unsafe fn from_conf_object_mut<'a>(obj: *mut conf_object) -> &'a mut Self

Get a mutable reference to this object from a raw ConfObject pointer

impl Class for Tsffs

impl HasInterface<config> for Tsffs

impl HasInterface<fuzz> for Tsffs