Re-Rename Retrying Restart Helper (#2340)

domenukk · web-flow · commit ea6e440762c3 · 2024-06-26T23:49:22.000+02:00
diff --git a/fuzzers/baby_fuzzer_wasm/src/lib.rs b/fuzzers/baby_fuzzer_wasm/src/lib.rs
@@ -11,7 +11,7 @@ use libafl::{
     mutators::{havoc_mutations, StdScheduledMutator},
     observers::StdMapObserver,
     schedulers::QueueScheduler,
-    stages::{StdRestartHelper, StdMutationalStage},
+    stages::{RetryCountRestartHelper, StdMutationalStage},
     state::{HasSolutions, StdState},
     Fuzzer, StdFuzzer,
 };
@@ -44,7 +44,7 @@ pub fn fuzz() {
     // No concurrency in WASM so these accesses are not racing.
     unsafe {
         RegistryBuilder::register::<MapFeedbackMetadata<u8>>();
-        RegistryBuilder::register::<StdRestartHelper>();
+        RegistryBuilder::register::<RetryCountRestartHelper>();
     }
 
     let mut signals = [0u8; 64];
diff --git a/libafl/src/stages/calibrate.rs b/libafl/src/stages/calibrate.rs
@@ -20,7 +20,7 @@ use crate::{
     monitors::{AggregatorOps, UserStats, UserStatsValue},
     observers::{MapObserver, ObserversTuple},
     schedulers::powersched::SchedulerMetadata,
-    stages::{Stage, StdRestartHelper},
+    stages::{RetryCountRestartHelper, Stage},
     state::{HasCorpus, HasCurrentTestcase, HasExecutions, UsesState},
     Error, HasMetadata, HasNamedMetadata,
 };
@@ -353,15 +353,15 @@ where
     fn should_restart(&mut self, state: &mut Self::State) -> Result<bool, Error> {
         // Calibration stage disallow restarts
         // If a testcase that causes crash/timeout in the queue, we need to remove it from the queue immediately.
-        StdRestartHelper::no_retry(state, &self.name)
+        RetryCountRestartHelper::no_retry(state, &self.name)
 
         // todo
         // remove this guy from corpus queue
     }
 
     fn clear_progress(&mut self, state: &mut Self::State) -> Result<(), Error> {
         // TODO: Make sure this is the correct way / there may be a better way?
-        StdRestartHelper::clear_progress(state, &self.name)
+        RetryCountRestartHelper::clear_progress(state, &self.name)
     }
 }
 
diff --git a/libafl/src/stages/colorization.rs b/libafl/src/stages/colorization.rs
@@ -19,7 +19,7 @@ use crate::{
     inputs::HasMutatorBytes,
     mutators::mutations::buffer_copy,
     observers::{MapObserver, ObserversTuple},
-    stages::{Stage, StdRestartHelper},
+    stages::{RetryCountRestartHelper, Stage},
     state::{HasCorpus, HasCurrentTestcase, HasRand, UsesState},
     Error, HasMetadata, HasNamedMetadata,
 };
@@ -112,11 +112,11 @@ where
         // This is a deterministic stage
         // Once it failed, then don't retry,
         // It will just fail again
-        StdRestartHelper::no_retry(state, &self.name)
+        RetryCountRestartHelper::no_retry(state, &self.name)
     }
 
     fn clear_progress(&mut self, state: &mut Self::State) -> Result<(), Error> {
-        StdRestartHelper::clear_progress(state, &self.name)
+        RetryCountRestartHelper::clear_progress(state, &self.name)
     }
 }
 
diff --git a/libafl/src/stages/concolic.rs b/libafl/src/stages/concolic.rs
@@ -19,7 +19,7 @@ use crate::state::HasClientPerfMonitor;
 use crate::{
     executors::{Executor, HasObservers},
     observers::concolic::ConcolicObserver,
-    stages::{Stage, StdRestartHelper, TracingStage},
+    stages::{RetryCountRestartHelper, Stage, TracingStage},
     state::{HasCorpus, HasCurrentTestcase, HasExecutions, UsesState},
     Error, HasMetadata, HasNamedMetadata,
 };
@@ -88,11 +88,11 @@ where
         // This is a deterministic stage
         // Once it failed, then don't retry,
         // It will just fail again
-        StdRestartHelper::no_retry(state, &self.name)
+        RetryCountRestartHelper::no_retry(state, &self.name)
     }
 
     fn clear_progress(&mut self, state: &mut Self::State) -> Result<(), Error> {
-        StdRestartHelper::clear_progress(state, &self.name)
+        RetryCountRestartHelper::clear_progress(state, &self.name)
     }
 }
 
@@ -436,12 +436,12 @@ where
         // This is a deterministic stage
         // Once it failed, then don't retry,
         // It will just fail again
-        StdRestartHelper::no_retry(state, &self.name)
+        RetryCountRestartHelper::no_retry(state, &self.name)
     }
 
     #[inline]
     fn clear_progress(&mut self, state: &mut Self::State) -> Result<(), Error> {
-        StdRestartHelper::clear_progress(state, &self.name)
+        RetryCountRestartHelper::clear_progress(state, &self.name)
     }
 }
 
diff --git a/libafl/src/stages/generalization.rs b/libafl/src/stages/generalization.rs
@@ -19,7 +19,7 @@ use crate::{
     mark_feature_time,
     observers::{CanTrack, MapObserver, ObserversTuple},
     require_novelties_tracking,
-    stages::{Stage, StdRestartHelper},
+    stages::{RetryCountRestartHelper, Stage},
     start_timer,
     state::{HasCorpus, HasExecutions, UsesState},
     Error, HasMetadata, HasNamedMetadata,
@@ -328,13 +328,13 @@ where
     #[inline]
     fn should_restart(&mut self, state: &mut Self::State) -> Result<bool, Error> {
         // TODO: We need to be able to resume better if something crashes or times out
-        StdRestartHelper::should_restart(state, &self.name, 3)
+        RetryCountRestartHelper::should_restart(state, &self.name, 3)
     }
 
     #[inline]
     fn clear_progress(&mut self, state: &mut Self::State) -> Result<(), Error> {
         // TODO: We need to be able to resume better if something crashes or times out
-        StdRestartHelper::clear_progress(state, &self.name)
+        RetryCountRestartHelper::clear_progress(state, &self.name)
     }
 }
 
diff --git a/libafl/src/stages/logics.rs b/libafl/src/stages/logics.rs
@@ -10,9 +10,9 @@ use crate::{
 
 /// Progress for nested stages. This merely enters/exits the inner stage's scope.
 #[derive(Debug)]
-pub struct NestedStageStdRestartHelper;
+pub struct NestedStageRetryCountRestartHelper;
 
-impl NestedStageStdRestartHelper {
+impl NestedStageRetryCountRestartHelper {
     fn should_restart<S, ST>(state: &mut S, _stage: &ST) -> Result<bool, Error>
     where
         S: HasNestedStageStatus,
@@ -71,11 +71,11 @@ where
     }
 
     fn should_restart(&mut self, state: &mut Self::State) -> Result<bool, Error> {
-        NestedStageStdRestartHelper::should_restart(state, self)
+        NestedStageRetryCountRestartHelper::should_restart(state, self)
     }
 
     fn clear_progress(&mut self, state: &mut Self::State) -> Result<(), Error> {
-        NestedStageStdRestartHelper::clear_progress(state, self)
+        NestedStageRetryCountRestartHelper::clear_progress(state, self)
     }
 }
 
@@ -135,11 +135,11 @@ where
     }
 
     fn should_restart(&mut self, state: &mut Self::State) -> Result<bool, Error> {
-        NestedStageStdRestartHelper::should_restart(state, self)
+        NestedStageRetryCountRestartHelper::should_restart(state, self)
     }
 
     fn clear_progress(&mut self, state: &mut Self::State) -> Result<(), Error> {
-        NestedStageStdRestartHelper::clear_progress(state, self)
+        NestedStageRetryCountRestartHelper::clear_progress(state, self)
     }
 }
 
@@ -220,11 +220,11 @@ where
     }
 
     fn should_restart(&mut self, state: &mut Self::State) -> Result<bool, Error> {
-        NestedStageStdRestartHelper::should_restart(state, self)
+        NestedStageRetryCountRestartHelper::should_restart(state, self)
     }
 
     fn clear_progress(&mut self, state: &mut Self::State) -> Result<(), Error> {
-        NestedStageStdRestartHelper::clear_progress(state, self)
+        NestedStageRetryCountRestartHelper::clear_progress(state, self)
     }
 }
 
@@ -281,11 +281,11 @@ where
     }
 
     fn should_restart(&mut self, state: &mut Self::State) -> Result<bool, Error> {
-        NestedStageStdRestartHelper::should_restart(state, self)
+        NestedStageRetryCountRestartHelper::should_restart(state, self)
     }
 
     fn clear_progress(&mut self, state: &mut Self::State) -> Result<(), Error> {
-        NestedStageStdRestartHelper::clear_progress(state, self)
+        NestedStageRetryCountRestartHelper::clear_progress(state, self)
     }
 }
 
diff --git a/libafl/src/stages/mod.rs b/libafl/src/stages/mod.rs
@@ -336,12 +336,12 @@ where
     fn should_restart(&mut self, state: &mut Self::State) -> Result<bool, Error> {
         // There's no restart safety in the content of the closure.
         // don't restart
-        StdRestartHelper::no_retry(state, &self.name)
+        RetryCountRestartHelper::no_retry(state, &self.name)
     }
 
     #[inline]
     fn clear_progress(&mut self, state: &mut Self::State) -> Result<(), Error> {
-        StdRestartHelper::clear_progress(state, &self.name)
+        RetryCountRestartHelper::clear_progress(state, &self.name)
     }
 }
 
@@ -481,26 +481,26 @@ where
     #[inline]
     fn should_restart(&mut self, state: &mut Self::State) -> Result<bool, Error> {
         // TODO: Proper restart handling - call post_exec at the right time, etc...
-        StdRestartHelper::no_retry(state, &self.name)
+        RetryCountRestartHelper::no_retry(state, &self.name)
     }
 
     #[inline]
     fn clear_progress(&mut self, state: &mut Self::State) -> Result<(), Error> {
-        StdRestartHelper::clear_progress(state, &self.name)
+        RetryCountRestartHelper::clear_progress(state, &self.name)
     }
 }
 
 /// Progress which permits a fixed amount of resumes per round of fuzzing. If this amount is ever
 /// exceeded, the input will no longer be executed by this stage.
 #[derive(Clone, Deserialize, Serialize, Debug)]
-pub struct StdRestartHelper {
+pub struct RetryCountRestartHelper {
     tries_remaining: Option<usize>,
     skipped: HashSet<CorpusId>,
 }
 
-impl_serdeany!(StdRestartHelper);
+impl_serdeany!(RetryCountRestartHelper);
 
-impl StdRestartHelper {
+impl RetryCountRestartHelper {
     /// Don't allow restart
     pub fn no_retry<S>(state: &mut S, name: &str) -> Result<bool, Error>
     where
@@ -518,7 +518,7 @@ impl StdRestartHelper {
     {
         let corpus_id = state.current_corpus_id()?.ok_or_else(|| {
             Error::illegal_state(
-                "No current_corpus_id set in State, but called StdRestartHelper::should_skip",
+                "No current_corpus_id set in State, but called RetryCountRestartHelper::should_skip",
             )
         })?;
 
@@ -689,7 +689,7 @@ pub mod test {
     use crate::{
         corpus::{Corpus, HasCurrentCorpusId, Testcase},
         inputs::NopInput,
-        stages::{Stage, StdRestartHelper},
+        stages::{RetryCountRestartHelper, Stage},
         state::{test::test_std_state, HasCorpus, State, UsesState},
         HasMetadata,
     };
@@ -776,7 +776,7 @@ pub mod test {
         // No concurrency per testcase
         #[cfg(any(not(feature = "serdeany_autoreg"), miri))]
         unsafe {
-            StdRestartHelper::register();
+            RetryCountRestartHelper::register();
         }
 
         struct StageWithOneTry;
@@ -797,58 +797,58 @@ pub mod test {
 
         for _ in 0..10 {
             // used normally, no retries means we never skip
-            assert!(StdRestartHelper::should_restart(
+            assert!(RetryCountRestartHelper::should_restart(
                 &mut state,
                 stage.name(),
                 1
             )?);
-            StdRestartHelper::clear_progress(&mut state, stage.name())?;
+            RetryCountRestartHelper::clear_progress(&mut state, stage.name())?;
         }
 
         for _ in 0..10 {
             // used normally, only one retry means we never skip
-            assert!(StdRestartHelper::should_restart(
+            assert!(RetryCountRestartHelper::should_restart(
                 &mut state,
                 stage.name(),
                 2
             )?);
-            assert!(StdRestartHelper::should_restart(
+            assert!(RetryCountRestartHelper::should_restart(
                 &mut state,
                 stage.name(),
                 2
             )?);
-            StdRestartHelper::clear_progress(&mut state, stage.name())?;
+            RetryCountRestartHelper::clear_progress(&mut state, stage.name())?;
         }
 
-        assert!(StdRestartHelper::should_restart(
+        assert!(RetryCountRestartHelper::should_restart(
             &mut state,
             stage.name(),
             2
         )?);
         // task failed, let's resume
         // we still have one more try!
-        assert!(StdRestartHelper::should_restart(
+        assert!(RetryCountRestartHelper::should_restart(
             &mut state,
             stage.name(),
             2
         )?);
 
         // task failed, let's resume
         // out of retries, so now we skip
-        assert!(!StdRestartHelper::should_restart(
+        assert!(!RetryCountRestartHelper::should_restart(
             &mut state,
             stage.name(),
             2
         )?);
-        StdRestartHelper::clear_progress(&mut state, stage.name())?;
+        RetryCountRestartHelper::clear_progress(&mut state, stage.name())?;
 
         // we previously exhausted this testcase's retries, so we skip
-        assert!(!StdRestartHelper::should_restart(
+        assert!(!RetryCountRestartHelper::should_restart(
             &mut state,
             stage.name(),
             2
         )?);
-        StdRestartHelper::clear_progress(&mut state, stage.name())?;
+        RetryCountRestartHelper::clear_progress(&mut state, stage.name())?;
 
         Ok(())
     }
diff --git a/libafl/src/stages/mutational.rs b/libafl/src/stages/mutational.rs
@@ -15,7 +15,7 @@ use crate::{
     inputs::Input,
     mark_feature_time,
     mutators::{MultiMutator, MutationResult, Mutator},
-    stages::{Stage, StdRestartHelper},
+    stages::{RetryCountRestartHelper, Stage},
     start_timer,
     state::{HasCorpus, HasCurrentTestcase, HasExecutions, HasRand, UsesState},
     Error, HasMetadata, HasNamedMetadata,
@@ -237,11 +237,11 @@ where
     }
 
     fn should_restart(&mut self, state: &mut Self::State) -> Result<bool, Error> {
-        StdRestartHelper::should_restart(state, &self.name, 3)
+        RetryCountRestartHelper::should_restart(state, &self.name, 3)
     }
 
     fn clear_progress(&mut self, state: &mut Self::State) -> Result<(), Error> {
-        StdRestartHelper::clear_progress(state, &self.name)
+        RetryCountRestartHelper::clear_progress(state, &self.name)
     }
 }
 
@@ -335,12 +335,12 @@ where
     #[inline]
     fn should_restart(&mut self, state: &mut Self::State) -> Result<bool, Error> {
         // Make sure we don't get stuck crashing on a single testcase
-        StdRestartHelper::should_restart(state, &self.name, 3)
+        RetryCountRestartHelper::should_restart(state, &self.name, 3)
     }
 
     #[inline]
     fn clear_progress(&mut self, state: &mut Self::State) -> Result<(), Error> {
-        StdRestartHelper::clear_progress(state, &self.name)
+        RetryCountRestartHelper::clear_progress(state, &self.name)
     }
 
     #[inline]
diff --git a/libafl/src/stages/power.rs b/libafl/src/stages/power.rs
diff --git a/libafl/src/stages/sync.rs b/libafl/src/stages/sync.rs
diff --git a/libafl/src/stages/tracing.rs b/libafl/src/stages/tracing.rs
diff --git a/libafl_targets/src/cmps/stages/aflpptracing.rs b/libafl_targets/src/cmps/stages/aflpptracing.rs

Original file line number	Diff line number	Diff line change
`@@ -19,7 +19,7 @@ use crate::state::HasClientPerfMonitor;`
`19`	`19`	`use crate::{`
`20`	`20`	`executors::{Executor, HasObservers},`
`21`	`21`	`observers::concolic::ConcolicObserver,`
`22`		`- stages::{Stage, StdRestartHelper, TracingStage},`
	`22`	`+ stages::{RetryCountRestartHelper, Stage, TracingStage},`
`23`	`23`	`state::{HasCorpus, HasCurrentTestcase, HasExecutions, UsesState},`
`24`	`24`	`Error, HasMetadata, HasNamedMetadata,`
`25`	`25`	`};`
`@@ -88,11 +88,11 @@ where`
`88`	`88`	`// This is a deterministic stage`
`89`	`89`	`// Once it failed, then don't retry,`
`90`	`90`	`// It will just fail again`
`91`		`- StdRestartHelper::no_retry(state, &self.name)`
	`91`	`+ RetryCountRestartHelper::no_retry(state, &self.name)`
`92`	`92`	`}`
`93`	`93`
`94`	`94`	`fn clear_progress(&mut self, state: &mut Self::State) -> Result<(), Error> {`
`95`		`- StdRestartHelper::clear_progress(state, &self.name)`
	`95`	`+ RetryCountRestartHelper::clear_progress(state, &self.name)`
`96`	`96`	`}`
`97`	`97`	`}`
`98`	`98`
`@@ -436,12 +436,12 @@ where`
`436`	`436`	`// This is a deterministic stage`
`437`	`437`	`// Once it failed, then don't retry,`
`438`	`438`	`// It will just fail again`
`439`		`- StdRestartHelper::no_retry(state, &self.name)`
	`439`	`+ RetryCountRestartHelper::no_retry(state, &self.name)`
`440`	`440`	`}`
`441`	`441`
`442`	`442`	`#[inline]`
`443`	`443`	`fn clear_progress(&mut self, state: &mut Self::State) -> Result<(), Error> {`
`444`		`- StdRestartHelper::clear_progress(state, &self.name)`
	`444`	`+ RetryCountRestartHelper::clear_progress(state, &self.name)`
`445`	`445`	`}`
`446`	`446`	`}`
`447`	`447`
Original file line number	Diff line number	Diff line change
`@@ -10,9 +10,9 @@ use crate::{`
`10`	`10`
`11`	`11`	`/// Progress for nested stages. This merely enters/exits the inner stage's scope.`
`12`	`12`	`#[derive(Debug)]`
`13`		`-pub struct NestedStageStdRestartHelper;`
	`13`	`+pub struct NestedStageRetryCountRestartHelper;`
`14`	`14`
`15`		`-impl NestedStageStdRestartHelper {`
	`15`	`+impl NestedStageRetryCountRestartHelper {`
`16`	`16`	`fn should_restart<S, ST>(state: &mut S, _stage: &ST) -> Result<bool, Error>`
`17`	`17`	`where`
`18`	`18`	`S: HasNestedStageStatus,`
`@@ -71,11 +71,11 @@ where`
`71`	`71`	`}`
`72`	`72`
`73`	`73`	`fn should_restart(&mut self, state: &mut Self::State) -> Result<bool, Error> {`
`74`		`- NestedStageStdRestartHelper::should_restart(state, self)`
	`74`	`+ NestedStageRetryCountRestartHelper::should_restart(state, self)`
`75`	`75`	`}`
`76`	`76`
`77`	`77`	`fn clear_progress(&mut self, state: &mut Self::State) -> Result<(), Error> {`
`78`		`- NestedStageStdRestartHelper::clear_progress(state, self)`
	`78`	`+ NestedStageRetryCountRestartHelper::clear_progress(state, self)`
`79`	`79`	`}`
`80`	`80`	`}`
`81`	`81`
`@@ -135,11 +135,11 @@ where`
`135`	`135`	`}`
`136`	`136`
`137`	`137`	`fn should_restart(&mut self, state: &mut Self::State) -> Result<bool, Error> {`
`138`		`- NestedStageStdRestartHelper::should_restart(state, self)`
	`138`	`+ NestedStageRetryCountRestartHelper::should_restart(state, self)`
`139`	`139`	`}`
`140`	`140`
`141`	`141`	`fn clear_progress(&mut self, state: &mut Self::State) -> Result<(), Error> {`
`142`		`- NestedStageStdRestartHelper::clear_progress(state, self)`
	`142`	`+ NestedStageRetryCountRestartHelper::clear_progress(state, self)`
`143`	`143`	`}`
`144`	`144`	`}`
`145`	`145`
`@@ -220,11 +220,11 @@ where`
`220`	`220`	`}`
`221`	`221`
`222`	`222`	`fn should_restart(&mut self, state: &mut Self::State) -> Result<bool, Error> {`
`223`		`- NestedStageStdRestartHelper::should_restart(state, self)`
	`223`	`+ NestedStageRetryCountRestartHelper::should_restart(state, self)`
`224`	`224`	`}`
`225`	`225`
`226`	`226`	`fn clear_progress(&mut self, state: &mut Self::State) -> Result<(), Error> {`
`227`		`- NestedStageStdRestartHelper::clear_progress(state, self)`
	`227`	`+ NestedStageRetryCountRestartHelper::clear_progress(state, self)`
`228`	`228`	`}`
`229`	`229`	`}`
`230`	`230`
`@@ -281,11 +281,11 @@ where`
`281`	`281`	`}`
`282`	`282`
`283`	`283`	`fn should_restart(&mut self, state: &mut Self::State) -> Result<bool, Error> {`
`284`		`- NestedStageStdRestartHelper::should_restart(state, self)`
	`284`	`+ NestedStageRetryCountRestartHelper::should_restart(state, self)`
`285`	`285`	`}`
`286`	`286`
`287`	`287`	`fn clear_progress(&mut self, state: &mut Self::State) -> Result<(), Error> {`
`288`		`- NestedStageStdRestartHelper::clear_progress(state, self)`
	`288`	`+ NestedStageRetryCountRestartHelper::clear_progress(state, self)`
`289`	`289`	`}`
`290`	`290`	`}`
`291`	`291`
Original file line number	Diff line number	Diff line change
`@@ -15,7 +15,7 @@ use crate::{`
`15`	`15`	`inputs::Input,`
`16`	`16`	`mark_feature_time,`
`17`	`17`	`mutators::{MultiMutator, MutationResult, Mutator},`
`18`		`- stages::{Stage, StdRestartHelper},`
	`18`	`+ stages::{RetryCountRestartHelper, Stage},`
`19`	`19`	`start_timer,`
`20`	`20`	`state::{HasCorpus, HasCurrentTestcase, HasExecutions, HasRand, UsesState},`
`21`	`21`	`Error, HasMetadata, HasNamedMetadata,`
`@@ -237,11 +237,11 @@ where`
`237`	`237`	`}`
`238`	`238`
`239`	`239`	`fn should_restart(&mut self, state: &mut Self::State) -> Result<bool, Error> {`
`240`		`- StdRestartHelper::should_restart(state, &self.name, 3)`
	`240`	`+ RetryCountRestartHelper::should_restart(state, &self.name, 3)`
`241`	`241`	`}`
`242`	`242`
`243`	`243`	`fn clear_progress(&mut self, state: &mut Self::State) -> Result<(), Error> {`
`244`		`- StdRestartHelper::clear_progress(state, &self.name)`
	`244`	`+ RetryCountRestartHelper::clear_progress(state, &self.name)`
`245`	`245`	`}`
`246`	`246`	`}`
`247`	`247`
`@@ -335,12 +335,12 @@ where`
`335`	`335`	`#[inline]`
`336`	`336`	`fn should_restart(&mut self, state: &mut Self::State) -> Result<bool, Error> {`
`337`	`337`	`// Make sure we don't get stuck crashing on a single testcase`
`338`		`- StdRestartHelper::should_restart(state, &self.name, 3)`
	`338`	`+ RetryCountRestartHelper::should_restart(state, &self.name, 3)`
`339`	`339`	`}`
`340`	`340`
`341`	`341`	`#[inline]`
`342`	`342`	`fn clear_progress(&mut self, state: &mut Self::State) -> Result<(), Error> {`
`343`		`- StdRestartHelper::clear_progress(state, &self.name)`
	`343`	`+ RetryCountRestartHelper::clear_progress(state, &self.name)`
`344`	`344`	`}`
`345`	`345`
`346`	`346`	`#[inline]`