Struct libafl::events::llmp::LlmpRestartingEventManager

pub struct LlmpRestartingEventManager<I, S, SP, ST> where
    I: Input,
    S: IfInteresting<I>,
    SP: ShMemProvider + 'static,
    ST: Stats,  { /* fields omitted */ }

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

Implementations

impl<I, S, SP, ST> LlmpRestartingEventManager<I, S, SP, ST> where
    I: Input,
    S: IfInteresting<I>,
    SP: ShMemProvider,
    ST: Stats, 

pub fn new(
    llmp_mgr: LlmpEventManager<I, S, SP, ST>,
    sender: LlmpSender<SP>
) -> Self

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

pub fn sender(&self) -> &LlmpSender<SP>

Get the sender

pub fn sender_mut(&mut self) -> &mut LlmpSender<SP>

Get the sender (mut)

Trait Implementations

impl<I: Debug, S: Debug, SP: Debug, ST: Debug> Debug for LlmpRestartingEventManager<I, S, SP, ST> where
    I: Input,
    S: IfInteresting<I>,
    SP: ShMemProvider + 'static,
    ST: Stats, 

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

Formats the value using the given formatter.

impl<I, S, SP, ST> EventManager<I, S> for LlmpRestartingEventManager<I, S, SP, ST> where
    I: Input,
    S: IfInteresting<I> + Serialize,
    SP: ShMemProvider,
    ST: Stats, 

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.

fn process<CS, E, OT>(
    &mut self,
    state: &mut S,
    executor: &mut E,
    scheduler: &CS
) -> Result<usize, Error> where
    CS: CorpusScheduler<I, S>,
    E: Executor<I> + HasObservers<OT>,
    OT: ObserversTuple, 

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

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

Send off an event to the broker

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

Serialize all observers for this type and manager

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

Deserialize all observers for this type and manager