pub fn do_fuzz_update(&mut self, shared: &mut[u8]) -> Result<(), String> {
        thread::yield_now();

        //maybe better weight it against #calls in current group
        //this way we trust a lot that every call is implemented correctly == good way
        //it is quick death then, like object is no longer online
        //however, if some syscall poorely implemented this will kill fuzzing for whole fuzzy object most
        // likely ...
        let e = match self.do_fuzz_update_impl() {
            Ok(_) => return Ok(()),
            Err(e) => e,
        };
        self.call_dtor(shared);

        Err(format!("[state] failing fuzzning cycle : update failed for fuzzed object <{:?}::{:?}> total fuzzed calls : {:?}, with details <{e}>", self.info.name, self.info.fd.data(), self.info.total))
    }
/// need to be called after do_fuzz_one, to change level based on slopes!
///
/// - call once do_fuzz_one will return true
/// - this basically wraps do_fuzz_update_impl, that it checks for end of fuzzing
///     - and then it performs closing of this State by calling dtor syscall!
need to be called after do_fuzz_one, to change level based on slopes.
call once do_fuzz_one will return true
this basically wraps do_fuzz_update_impl, that it checks for end of fuzzing
and then it performs closing of this State by calling dtor syscall!
need to be called after do_fuzz_one to change level based on slopes . call once do_fuzz_one will return true this basically wraps do_fuzz_update_impl that it checks for end of fuzzing and then it performs closing of this State by calling dtor syscall!
pub fn do_fuzz_update(&mut self, shared: &mut[u8]) -> Result<(), String> {
        thread::yield_now();
        //maybe better weight it against #calls in current group
        //this way we trust a lot that every call is implemented correctly == good way
        //it is quick death then, like object is no longer online
        //however, if some syscall poorely implemented this will kill fuzzing for whole fuzzy object most
        // likely ...
        let e = match self.do_fuzz_update_impl() {
            Ok(_) => return Ok(()),
            Err(e) => e,
        };
        self.call_dtor(shared);
        Err(format!("[state] failing fuzzning cycle : update failed for fuzzed object <{:?}::{:?}> total fuzzed calls : {:?}, with details <{e}>", self.info.name, self.info.fd.data(), self.info.total))
    }
pub fn do_fuzz_update ( & mut self , shared : & mut [ u8 ] ) -> Result < ( ) , String > { thread :: yield_now ( ) ; //maybe better weight it against #calls in current group //this way we trust a lot that every call is implemented correctly == good way //it is quick death then, like object is no longer online //however, if some syscall poorely implemented this will kill fuzzing for whole fuzzy object most // likely ... let e = match self . do_fuzz_update_impl ( ) { Ok ( _ ) => return Ok ( ( ) ) , Err ( e ) => e , } ; self . call_dtor ( shared ) ; Err ( format ! ( " " self info name self info fd data ( ) self info total ) ) }
need to be called after do_fuzz_one, to change level based on slopes!
need to be called after do_fuzz_one to change level based on slopes!
&mut self
shared
&mut[u8]
&mut self
shared
&mut[u8]