Struct libafl::events::llmp::LlmpRestartingEventManager

pub struct LlmpRestartingEventManager<I, OT, S, SP>where
    I: Input,
    OT: ObserversTuple<I, S>,
    SP: ShMemProvider + 'static,{ /* private fields */ }

A manager that can restart on the fly, storing states in-between (in on_restart)

Implementations

impl<I, OT, S, SP> LlmpRestartingEventManager<I, OT, S, SP>where
    I: Input,
    OT: ObserversTuple<I, S> + DeserializeOwned,
    SP: ShMemProvider + 'static,

pub fn new(
    llmp_mgr: LlmpEventManager<I, OT, S, SP>,
    staterestorer: StateRestorer<SP>
) -> Self

Create a new runner, the executed child doing the actual fuzzing.

pub fn staterestorer(&self) -> &StateRestorer<SP>

Get the staterestorer

pub fn staterestorer_mut(&mut self) -> &mut StateRestorer<SP>

Get the staterestorer (mutable)

Trait Implementations

impl<I: Debug, OT: Debug, S: Debug, SP: Debug> Debug for LlmpRestartingEventManager<I, OT, S, SP>where
    I: Input,
    OT: ObserversTuple<I, S>,
    SP: ShMemProvider + 'static,

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<I, OT, S, SP> EventFirer<I> for LlmpRestartingEventManager<I, OT, S, SP>where
    I: Input,
    OT: ObserversTuple<I, S>,
    SP: ShMemProvider,

fn fire<S2>(&mut self, state: &mut S2, event: Event<I>) -> Result<(), Error>

Send off an Event to the broker

fn configuration(&self) -> EventConfig

Get the configuration

fn log<S>(
    &mut self,
    state: &mut S,
    severity_level: LogSeverity,
    message: String
) -> Result<(), Error>

Send off an Event::Log event to the broker. This is a shortcut for EventFirer::fire with Event::Log as argument.

fn serialize_observers<OT, S>(
    &mut self,
    observers: &OT
) -> Result<Vec<u8>, Error>where
    OT: ObserversTuple<I, S> + Serialize,

Serialize all observers for this type and manager

impl<E, I, OT, S, SP, Z> EventProcessor<E, I, S, Z> for LlmpRestartingEventManager<I, OT, S, SP>where
    E: Executor<LlmpEventManager<I, OT, S, SP>, I, S, Z> + HasObservers<I, OT, S>,
    I: Input,
    Z: ExecutionProcessor<I, OT, S> + EvaluatorObservers<I, OT, S>,
    OT: ObserversTuple<I, S> + DeserializeOwned,
    SP: ShMemProvider + 'static,

fn process(
    &mut self,
    fuzzer: &mut Z,
    state: &mut S,
    executor: &mut E
) -> Result<usize, Error>

Lookup for incoming events and process them. Return the number of processes events or an error

fn deserialize_observers<OT>(
    &mut self,
    observers_buf: &[u8]
) -> Result<OT, Error>where
    OT: ObserversTuple<I, S> + DeserializeOwned,

Deserialize all observers for this type and manager

impl<I, OT, S, SP> EventRestarter<S> for LlmpRestartingEventManager<I, OT, S, SP>where
    I: Input,
    OT: ObserversTuple<I, S>,
    S: Serialize,
    SP: ShMemProvider,

fn await_restart_safe(&mut self)

The llmp client needs to wait until a broker mapped all pages, before shutting down. Otherwise, the OS may already have removed the shared maps,

fn on_restart(&mut self, state: &mut S) -> Result<(), Error>

Reset the single page (we reuse it over and over from pos 0), then send the current state to the next runner.

impl<I, OT, S, SP> HasEventManagerId for LlmpRestartingEventManager<I, OT, S, SP>where
    I: Input,
    OT: ObserversTuple<I, S> + DeserializeOwned,
    S: Serialize,
    SP: ShMemProvider + 'static,

fn mgr_id(&self) -> EventManagerId

The id of this manager. For Multiprocessed EventManagers, each client should have a unique ids.

impl<I, OT, S, SP> ProgressReporter<I> for LlmpRestartingEventManager<I, OT, S, SP>where
    I: Input,
    OT: ObserversTuple<I, S>,
    S: Serialize,
    SP: ShMemProvider,

fn maybe_report_progress<S>(
    &mut self,
    state: &mut S,
    last_report_time: Duration,
    monitor_timeout: Duration
) -> Result<Duration, Error>where
    S: HasExecutions + HasClientPerfMonitor + HasMetadata,

Given the last time, if monitor_timeout seconds passed, send off an info/monitor/heartbeat message to the broker. Returns the new last time (so the old one, unless monitor_timeout time has passed and monitor have been sent) Will return an crate::Error, if the stats could not be sent.

impl<E, I, OT, S, SP, Z> EventManager<E, I, S, Z> for LlmpRestartingEventManager<I, OT, S, SP>where
    E: Executor<LlmpEventManager<I, OT, S, SP>, I, S, Z> + HasObservers<I, OT, S>,
    I: Input,
    S: Serialize,
    Z: ExecutionProcessor<I, OT, S> + EvaluatorObservers<I, OT, S>,
    OT: ObserversTuple<I, S> + DeserializeOwned,
    SP: ShMemProvider + 'static,