Move HasMetadata/HasNamedMetadata trait to libafl_bolts (#2016)

* move around

* fmt

* rev

* fmt

* doc job

* name

* move to libafl

* separate even more

* miri

.github/workflows/build_and_test.yml

@@ -83,6 +83,64 @@ jobs:
         run: pwd && ls & cd libafl_cc && cargo build --release
 
 
+  ubuntu-doc:
+    runs-on: ubuntu-22.04
+    steps:
+    - name: Remove Dotnet & Haskell
+      run: rm -rf /usr/share/dotnet && rm -rf /opt/ghc
+    - uses: actions-rs/toolchain@v1
+      with:
+        profile: minimal
+        toolchain: stable
+    - name: Remove existing clang and LLVM
+      run: sudo apt purge llvm* clang* lld* lldb* opt*
+    - name: Install and cache deps
+      run: sudo apt update && sudo apt install ninja-build shellcheck libgtk-3-dev gcc-arm-linux-gnueabi g++-arm-linux-gnueabi libslirp-dev libz3-dev
+    - name: Add nightly rustfmt and clippy
+      run: rustup toolchain install nightly --component rustfmt --component clippy --component miri --allow-downgrade
+    - name: Install ucd-generate
+      run: cargo install -f ucd-generate
+    - uses: actions/checkout@v3
+    - uses: Swatinem/rust-cache@v2
+    - name: Install LLVM and Clang
+      uses: KyleMayes/install-llvm-action@v1
+      with:
+        directory: ${{ runner.temp }}/llvm
+        version: 17
+    # ---- doc check ----
+    - name: Build Docs
+      run: RUSTFLAGS="--cfg docsrs" cargo +nightly doc --all-features
+    - name: Test Docs
+      run: RUSTFLAGS="--cfg docsrs" cargo +nightly test --doc --all-features
+
+  ubuntu-miri:
+    runs-on: ubuntu-22.04
+    steps:
+    - name: Remove Dotnet & Haskell
+      run: rm -rf /usr/share/dotnet && rm -rf /opt/ghc
+    - uses: actions-rs/toolchain@v1
+      with:
+        profile: minimal
+        toolchain: stable
+    - name: Remove existing clang and LLVM
+      run: sudo apt purge llvm* clang* lld* lldb* opt*
+    - name: Install and cache deps
+      run: sudo apt update && sudo apt install ninja-build shellcheck libgtk-3-dev gcc-arm-linux-gnueabi g++-arm-linux-gnueabi libslirp-dev libz3-dev
+    - name: Add nightly rustfmt and clippy
+      run: rustup toolchain install nightly --component rustfmt --component clippy --component miri --allow-downgrade
+    - name: Install ucd-generate
+      run: cargo install -f ucd-generate
+    - uses: actions/checkout@v3
+    - uses: Swatinem/rust-cache@v2
+    - name: Install LLVM and Clang
+      uses: KyleMayes/install-llvm-action@v1
+      with:
+        directory: ${{ runner.temp }}/llvm
+        version: 17
+    # --- miri undefined behavior test --
+    - name: Run miri tests
+      run: RUST_BACKTRACE=1 MIRIFLAGS="-Zmiri-disable-isolation" cargo +nightly miri test
+
   ubuntu:
     runs-on: ubuntu-22.04
     steps:
@@ -119,22 +177,12 @@ jobs:
       run: clang-format -n -Werror --style=file $(find . -type f \( -name '*.cpp' -o -iname '*.hpp' -o -name '*.cc' -o -name '*.cxx' -o -name '*.cc' -o -name '*.h' \) | grep -v '/target/' | grep -v 'libpng-1\.6\.37' | grep -v 'stb_image\.h' | grep -v 'dlmalloc\.c' | grep -v 'QEMU-Nyx')
     - name: run shellcheck
       run: shellcheck ./scripts/*.sh
-
-    # ---- doc check ----
-    - name: Build Docs
-      run: RUSTFLAGS="--cfg docsrs" cargo +nightly doc --all-features
-    - name: Test Docs
-      run: RUSTFLAGS="--cfg docsrs" cargo +nightly test --doc --all-features
     # ---- build normal and examples ----
     - name: Run a normal build
       run: cargo build --verbose
     - name: Build examples
       run: cargo build --examples --verbose
 
-    # --- miri undefined behavior test --
-    - name: Run miri tests
-      run: RUST_BACKTRACE=1 MIRIFLAGS="-Zmiri-disable-isolation" cargo +nightly miri test
-
   ubuntu-clippy:
     runs-on: ubuntu-22.04
     steps:

fuzzers/baby_fuzzer_grimoire/src/main.rs

@@ -18,7 +18,8 @@ use libafl::{
     observers::StdMapObserver,
     schedulers::QueueScheduler,
     stages::{mutational::StdMutationalStage, GeneralizationStage},
-    state::{HasMetadata, StdState},
+    state::StdState,
+    HasMetadata,
 };
 use libafl_bolts::{current_nanos, rands::StdRand, tuples::tuple_list, AsSlice};
 

fuzzers/baby_fuzzer_nautilus/src/main.rs

@@ -18,7 +18,8 @@ use libafl::{
     observers::StdMapObserver,
     schedulers::QueueScheduler,
     stages::mutational::StdMutationalStage,
-    state::{HasMetadata, StdState},
+    state::StdState,
+    HasMetadata,
 };
 use libafl_bolts::{current_nanos, rands::StdRand, tuples::tuple_list};
 

fuzzers/forkserver_libafl_cc/src/main.rs

@@ -15,7 +15,8 @@ use libafl::{
     observers::{HitcountsMapObserver, StdMapObserver, TimeObserver},
     schedulers::{IndexesLenTimeMinimizerScheduler, QueueScheduler},
     stages::mutational::StdMutationalStage,
-    state::{HasCorpus, HasMetadata, StdState},
+    state::{HasCorpus, StdState},
+    HasMetadata,
 };
 use libafl_bolts::{
     current_nanos,

fuzzers/forkserver_simple/src/main.rs

@@ -15,7 +15,8 @@ use libafl::{
     observers::{HitcountsMapObserver, StdMapObserver, TimeObserver},
     schedulers::{IndexesLenTimeMinimizerScheduler, QueueScheduler},
     stages::mutational::StdMutationalStage,
-    state::{HasCorpus, HasMetadata, StdState},
+    state::{HasCorpus, StdState},
+    HasMetadata,
 };
 use libafl_bolts::{
     current_nanos,

fuzzers/frida_executable_libpng/src/fuzzer.rs

@@ -23,8 +23,8 @@ use libafl::{
     observers::{HitcountsMapObserver, StdMapObserver, TimeObserver},
     schedulers::{IndexesLenTimeMinimizerScheduler, QueueScheduler},
     stages::{ShadowTracingStage, StdMutationalStage},
-    state::{HasCorpus, HasMetadata, StdState},
+    state::{HasCorpus, StdState},
-    Error,
+    Error, HasMetadata,
 };
 #[cfg(unix)]
 use libafl::{feedback_and_fast, feedbacks::ConstFeedback};

fuzzers/frida_gdiplus/src/fuzzer.rs

@@ -29,8 +29,8 @@ use libafl::{
     observers::{HitcountsMapObserver, StdMapObserver, TimeObserver},
     schedulers::{IndexesLenTimeMinimizerScheduler, QueueScheduler},
     stages::{ShadowTracingStage, StdMutationalStage},
-    state::{HasCorpus, HasMetadata, StdState},
+    state::{HasCorpus, StdState},
-    Error,
+    Error, HasMetadata,
 };
 #[cfg(unix)]
 use libafl::{feedback_and_fast, feedbacks::ConstFeedback};

fuzzers/frida_libpng/src/fuzzer.rs

@@ -23,8 +23,8 @@ use libafl::{
     observers::{HitcountsMapObserver, StdMapObserver, TimeObserver},
     schedulers::{IndexesLenTimeMinimizerScheduler, QueueScheduler},
     stages::{ShadowTracingStage, StdMutationalStage},
-    state::{HasCorpus, HasMetadata, StdState},
+    state::{HasCorpus, StdState},
-    Error,
+    Error, HasMetadata,
 };
 #[cfg(unix)]
 use libafl::{feedback_and_fast, feedbacks::ConstFeedback};

fuzzers/fuzzbench/src/lib.rs

@@ -36,8 +36,8 @@ use libafl::{
         calibrate::CalibrationStage, power::StdPowerMutationalStage, StdMutationalStage,
         TracingStage,
     },
-    state::{HasCorpus, HasMetadata, StdState},
+    state::{HasCorpus, StdState},
-    Error,
+    Error, HasMetadata,
 };
 use libafl_bolts::{
     current_nanos, current_time,

fuzzers/fuzzbench_ctx/src/lib.rs

@@ -39,8 +39,8 @@ use libafl::{
         calibrate::CalibrationStage, power::StdPowerMutationalStage, StdMutationalStage,
         TracingStage,
     },
-    state::{HasCorpus, HasMetadata, StdState},
+    state::{HasCorpus, StdState},
-    Error,
+    Error, HasMetadata,
 };
 use libafl_bolts::{
     current_nanos, current_time,

fuzzers/fuzzbench_fork_qemu/src/fuzzer.rs

@@ -34,8 +34,8 @@ use libafl::{
         calibrate::CalibrationStage, power::StdPowerMutationalStage, ShadowTracingStage,
         StdMutationalStage,
     },
-    state::{HasCorpus, HasMetadata, StdState},
+    state::{HasCorpus, StdState},
-    Error,
+    Error, HasMetadata,
 };
 use libafl_bolts::{
     current_nanos, current_time,

fuzzers/fuzzbench_forkserver/src/main.rs

@@ -29,8 +29,8 @@ use libafl::{
         calibrate::CalibrationStage, power::StdPowerMutationalStage, StdMutationalStage,
         TracingStage,
     },
-    state::{HasCorpus, HasMetadata, StdState},
+    state::{HasCorpus, StdState},
-    Error,
+    Error, HasMetadata,
 };
 use libafl_bolts::{
     current_nanos, current_time,

fuzzers/fuzzbench_forkserver_cmplog/src/main.rs

@@ -29,8 +29,8 @@ use libafl::{
         calibrate::CalibrationStage, mutational::MultiMutationalStage,
         power::StdPowerMutationalStage, ColorizationStage, IfStage,
     },
-    state::{HasCorpus, HasCurrentTestcase, HasMetadata, StdState},
+    state::{HasCorpus, HasCurrentTestcase, StdState},
-    Error,
+    Error, HasMetadata,
 };
 use libafl_bolts::{
     current_nanos, current_time,

fuzzers/fuzzbench_qemu/src/fuzzer.rs

@@ -33,8 +33,8 @@ use libafl::{
         calibrate::CalibrationStage, power::StdPowerMutationalStage, ShadowTracingStage,
         StdMutationalStage,
     },
-    state::{HasCorpus, HasMetadata, StdState},
+    state::{HasCorpus, StdState},
-    Error,
+    Error, HasMetadata,
 };
 use libafl_bolts::{
     current_nanos, current_time,

fuzzers/fuzzbench_text/src/lib.rs

@@ -42,8 +42,8 @@ use libafl::{
         calibrate::CalibrationStage, power::StdPowerMutationalStage, GeneralizationStage,
         StdMutationalStage, TracingStage,
     },
-    state::{HasCorpus, HasMetadata, StdState},
+    state::{HasCorpus, StdState},
-    Error,
+    Error, HasMetadata,
 };
 use libafl_bolts::{
     current_nanos, current_time,

fuzzers/libafl_atheris/src/lib.rs

@@ -28,8 +28,8 @@ use libafl::{
     observers::{HitcountsMapObserver, StdMapObserver, TimeObserver},
     schedulers::{IndexesLenTimeMinimizerScheduler, QueueScheduler},
     stages::{StdMutationalStage, TracingStage},
-    state::{HasCorpus, HasMetadata, StdState},
+    state::{HasCorpus, StdState},
-    Error,
+    Error, HasMetadata,
 };
 use libafl_bolts::{
     core_affinity::Cores,

fuzzers/libfuzzer_libmozjpeg/src/lib.rs

@@ -22,8 +22,8 @@ use libafl::{
     observers::StdMapObserver,
     schedulers::RandScheduler,
     stages::mutational::StdMutationalStage,
-    state::{HasCorpus, HasMetadata, StdState},
+    state::{HasCorpus, StdState},
-    Error,
+    Error, HasMetadata,
 };
 use libafl_bolts::{
     current_nanos,

fuzzers/libfuzzer_libpng/src/lib.rs

@@ -27,8 +27,8 @@ use libafl::{
         powersched::PowerSchedule, IndexesLenTimeMinimizerScheduler, StdWeightedScheduler,
     },
     stages::{calibrate::CalibrationStage, power::StdPowerMutationalStage},
-    state::{HasCorpus, HasMetadata, StdState},
+    state::{HasCorpus, StdState},
-    Error,
+    Error, HasMetadata,
 };
 use libafl_bolts::{
     current_nanos,

fuzzers/libfuzzer_libpng_accounting/src/lib.rs

@@ -26,8 +26,8 @@ use libafl::{
     observers::{HitcountsMapObserver, StdMapObserver, TimeObserver},
     schedulers::{CoverageAccountingScheduler, QueueScheduler},
     stages::mutational::StdMutationalStage,
-    state::{HasCorpus, HasMetadata, StdState},
+    state::{HasCorpus, StdState},
-    Error,
+    Error, HasMetadata,
 };
 use libafl_bolts::{
     core_affinity::Cores,

fuzzers/libfuzzer_libpng_aflpp_ui/src/lib.rs

@@ -27,8 +27,8 @@ use libafl::{
         powersched::PowerSchedule, IndexesLenTimeMinimizerScheduler, StdWeightedScheduler,
     },
     stages::{calibrate::CalibrationStage, power::StdPowerMutationalStage, stats::AflStatsStage},
-    state::{HasCorpus, HasMetadata, StdState},
+    state::{HasCorpus, StdState},
-    Error,
+    Error, HasMetadata,
 };
 use libafl_bolts::{
     current_nanos,

fuzzers/libfuzzer_libpng_centralized/src/lib.rs

@@ -26,8 +26,8 @@ use libafl::{
     observers::{HitcountsMapObserver, TimeObserver},
     schedulers::{IndexesLenTimeMinimizerScheduler, QueueScheduler},
     stages::mutational::StdMutationalStage,
-    state::{HasCorpus, HasMetadata, StdState},
+    state::{HasCorpus, StdState},
-    Error,
+    Error, HasMetadata,
 };
 use libafl_bolts::{
     core_affinity::{CoreId, Cores},

fuzzers/libfuzzer_libpng_cmin/src/lib.rs

@@ -30,8 +30,8 @@ use libafl::{
         powersched::PowerSchedule, IndexesLenTimeMinimizerScheduler, StdWeightedScheduler,
     },
     stages::{calibrate::CalibrationStage, power::StdPowerMutationalStage},
-    state::{HasCorpus, HasMetadata, StdState},
+    state::{HasCorpus, StdState},
-    Error,
+    Error, HasMetadata,
 };
 use libafl_bolts::{
     current_nanos,

fuzzers/libfuzzer_libpng_launcher/src/lib.rs

@@ -26,8 +26,8 @@ use libafl::{
     observers::{HitcountsMapObserver, TimeObserver},
     schedulers::{IndexesLenTimeMinimizerScheduler, QueueScheduler},
     stages::mutational::StdMutationalStage,
-    state::{HasCorpus, HasMetadata, StdState},
+    state::{HasCorpus, StdState},
-    Error,
+    Error, HasMetadata,
 };
 use libafl_bolts::{
     core_affinity::Cores,

fuzzers/libfuzzer_libpng_norestart/src/lib.rs

@@ -29,8 +29,8 @@ use libafl::{
     observers::{HitcountsMapObserver, TimeObserver},
     schedulers::{IndexesLenTimeMinimizerScheduler, QueueScheduler},
     stages::mutational::StdMutationalStage,
-    state::{HasCorpus, HasMetadata, StdState},
+    state::{HasCorpus, StdState},
-    Error,
+    Error, HasMetadata,
 };
 use libafl_bolts::{
     core_affinity::Cores,

fuzzers/libfuzzer_libpng_tcp_manager/src/lib.rs

@@ -27,8 +27,8 @@ use libafl::{
         powersched::PowerSchedule, IndexesLenTimeMinimizerScheduler, StdWeightedScheduler,
     },
     stages::{calibrate::CalibrationStage, power::StdPowerMutationalStage},
-    state::{HasCorpus, HasMetadata, StdState},
+    state::{HasCorpus, StdState},
-    Error,
+    Error, HasMetadata,
 };
 use libafl_bolts::{
     current_nanos,

fuzzers/nautilus_sync/src/lib.rs

@@ -23,8 +23,8 @@ use libafl::{
     none_input_converter,
     schedulers::QueueScheduler,
     stages::{mutational::StdMutationalStage, sync::SyncFromBrokerStage},
-    state::{HasMetadata, StdState},
+    state::StdState,
-    Error,
+    Error, HasMetadata,
 };
 use libafl_bolts::{
     core_affinity::Cores,

fuzzers/qemu_launcher/src/instance.rs

@@ -26,8 +26,8 @@ use libafl::{
         calibrate::CalibrationStage, power::StdPowerMutationalStage, ShadowTracingStage,
         StagesTuple, StdMutationalStage,
     },
-    state::{HasCorpus, HasMetadata, StdState, UsesState},
+    state::{HasCorpus, StdState, UsesState},
-    Error,
+    Error, HasMetadata,
 };
 #[cfg(not(feature = "simplemgr"))]
 use libafl_bolts::shmem::StdShMemProvider;

fuzzers/tutorial/src/metadata.rs

@@ -5,8 +5,8 @@ use libafl::{
     feedbacks::{Feedback, MapIndexesMetadata},
     observers::ObserversTuple,
     schedulers::{MinimizerScheduler, TestcaseScore},
-    state::{HasCorpus, HasMetadata, State},
+    state::{HasCorpus, State},
-    Error,
+    Error, HasMetadata,
 };
 use libafl_bolts::{Named, SerdeAny};
 use serde::{Deserialize, Serialize};

libafl/src/common/mod.rs

@@ -0,0 +1,149 @@
+//! This module defines trait shared across different `LibAFL` modules
+
+use alloc::boxed::Box;
+use core::any::type_name;
+
+use libafl_bolts::{
+    serdeany::{NamedSerdeAnyMap, SerdeAny, SerdeAnyMap},
+    Error,
+};
+/// Trait for elements offering metadata
+pub trait HasMetadata {
+    /// A map, storing all metadata
+    fn metadata_map(&self) -> &SerdeAnyMap;
+    /// A map, storing all metadata (mutable)
+    fn metadata_map_mut(&mut self) -> &mut SerdeAnyMap;
+
+    /// Add a metadata to the metadata map
+    #[inline]
+    fn add_metadata<M>(&mut self, meta: M)
+    where
+        M: SerdeAny,
+    {
+        self.metadata_map_mut().insert(meta);
+    }
+
+    /// Gets metadata, or inserts it using the given construction function `default`
+    fn metadata_or_insert_with<M>(&mut self, default: impl FnOnce() -> M) -> &mut M
+    where
+        M: SerdeAny,
+    {
+        self.metadata_map_mut().get_or_insert_with::<M>(default)
+    }
+
+    /// Remove a metadata from the metadata map
+    #[inline]
+    fn remove_metadata<M>(&mut self) -> Option<Box<M>>
+    where
+        M: SerdeAny,
+    {
+        self.metadata_map_mut().remove::<M>()
+    }
+
+    /// Check for a metadata
+    ///
+    /// # Note
+    /// For performance reasons, you likely want to use [`Self::metadata_or_insert_with`] instead
+    #[inline]
+    fn has_metadata<M>(&self) -> bool
+    where
+        M: SerdeAny,
+    {
+        self.metadata_map().get::<M>().is_some()
+    }
+
+    /// To get metadata
+    #[inline]
+    fn metadata<M>(&self) -> Result<&M, Error>
+    where
+        M: SerdeAny,
+    {
+        self.metadata_map()
+            .get::<M>()
+            .ok_or_else(|| Error::key_not_found(format!("{} not found", type_name::<M>())))
+    }
+
+    /// To get mutable metadata
+    #[inline]
+    fn metadata_mut<M>(&mut self) -> Result<&mut M, Error>
+    where
+        M: SerdeAny,
+    {
+        self.metadata_map_mut()
+            .get_mut::<M>()
+            .ok_or_else(|| Error::key_not_found(format!("{} not found", type_name::<M>())))
+    }
+}
+
+/// Trait for elements offering named metadata
+pub trait HasNamedMetadata {
+    /// A map, storing all metadata
+    fn named_metadata_map(&self) -> &NamedSerdeAnyMap;
+    /// A map, storing all metadata (mutable)
+    fn named_metadata_map_mut(&mut self) -> &mut NamedSerdeAnyMap;
+
+    /// Add a metadata to the metadata map
+    #[inline]
+    fn add_named_metadata<M>(&mut self, name: &str, meta: M)
+    where
+        M: SerdeAny,
+    {
+        self.named_metadata_map_mut().insert(name, meta);
+    }
+
+    /// Add a metadata to the metadata map
+    #[inline]
+    fn remove_named_metadata<M>(&mut self, name: &str) -> Option<Box<M>>
+    where
+        M: SerdeAny,
+    {
+        self.named_metadata_map_mut().remove::<M>(name)
+    }
+
+    /// Gets metadata, or inserts it using the given construction function `default`
+    fn named_metadata_or_insert_with<M>(
+        &mut self,
+        name: &str,
+        default: impl FnOnce() -> M,
+    ) -> &mut M
+    where
+        M: SerdeAny,
+    {
+        self.named_metadata_map_mut()
+            .get_or_insert_with::<M>(name, default)
+    }
+
+    /// Check for a metadata
+    ///
+    /// # Note
+    /// You likely want to use [`Self::named_metadata_or_insert_with`] for performance reasons.
+    #[inline]
+    fn has_named_metadata<M>(&self, name: &str) -> bool
+    where
+        M: SerdeAny,
+    {
+        self.named_metadata_map().contains::<M>(name)
+    }
+
+    /// To get named metadata
+    #[inline]
+    fn named_metadata<M>(&self, name: &str) -> Result<&M, Error>
+    where
+        M: SerdeAny,
+    {
+        self.named_metadata_map()
+            .get::<M>(name)
+            .ok_or_else(|| Error::key_not_found(format!("{} not found", type_name::<M>())))
+    }
+
+    /// To get mutable named metadata
+    #[inline]
+    fn named_metadata_mut<M>(&mut self, name: &str) -> Result<&mut M, Error>
+    where
+        M: SerdeAny,
+    {
+        self.named_metadata_map_mut()
+            .get_mut::<M>(name)
+            .ok_or_else(|| Error::key_not_found(format!("{} not found", type_name::<M>())))
+    }
+}

libafl/src/corpus/inmemory_ondisk.rs

@@ -24,8 +24,7 @@ use super::{
 use crate::{
     corpus::{Corpus, CorpusId, InMemoryCorpus, Testcase},
     inputs::{Input, UsesInput},
-    state::HasMetadata,
+    Error, HasMetadata,
-    Error,
 };
 
 /// The [`Testcase`] metadata that'll be stored to disk

libafl/src/corpus/minimizer.rs

@@ -19,8 +19,8 @@ use crate::{
     monitors::{AggregatorOps, UserStats, UserStatsValue},
     observers::{MapObserver, ObserversTuple},
     schedulers::{LenTimeMulTestcaseScore, RemovableScheduler, Scheduler, TestcaseScore},
-    state::{HasCorpus, HasExecutions, HasMetadata, UsesState},
+    state::{HasCorpus, HasExecutions, UsesState},
-    Error, HasScheduler,
+    Error, HasMetadata, HasScheduler,
 };
 
 /// `CorpusMinimizers` minimize corpora according to internal logic. See various implementations for

libafl/src/corpus/testcase.rs

@@ -16,8 +16,7 @@ use super::Corpus;
 use crate::{
     corpus::CorpusId,
     inputs::{Input, UsesInput},
-    state::HasMetadata,
+    Error, HasMetadata,
-    Error,
 };
 
 /// Shorthand to receive a [`Ref`] or [`RefMut`] to a stored [`Testcase`], by [`CorpusId`].

libafl/src/events/centralized.rs

@@ -38,8 +38,8 @@ use crate::{
     fuzzer::{EvaluatorObservers, ExecutionProcessor},
     inputs::{Input, UsesInput},
     observers::ObserversTuple,
-    state::{HasExecutions, HasLastReportTime, HasMetadata, UsesState},
+    state::{HasExecutions, HasLastReportTime, UsesState},
-    Error,
+    Error, HasMetadata,
 };
 
 const _LLMP_TAG_TO_MAIN: Tag = Tag(0x3453453);

libafl/src/events/llmp.rs

@@ -57,8 +57,8 @@ use crate::{
     inputs::{Input, InputConverter, UsesInput},
     monitors::Monitor,
     observers::ObserversTuple,
-    state::{HasExecutions, HasLastReportTime, HasMetadata, State, UsesState},
+    state::{HasExecutions, HasLastReportTime, State, UsesState},
-    Error,
+    Error, HasMetadata,
 };
 
 /// Forward this to the client

libafl/src/events/mod.rs

@@ -46,8 +46,8 @@ use crate::{
     inputs::Input,
     monitors::UserStats,
     observers::ObserversTuple,
-    state::{HasExecutions, HasLastReportTime, HasMetadata, State},
+    state::{HasExecutions, HasLastReportTime, State},
-    Error,
+    Error, HasMetadata,
 };
 #[cfg(feature = "scalability_introspection")]
 use crate::{

libafl/src/events/simple.rs

@@ -32,8 +32,8 @@ use crate::{
     },
     inputs::UsesInput,
     monitors::Monitor,
-    state::{HasExecutions, HasLastReportTime, HasMetadata, State, UsesState},
+    state::{HasExecutions, HasLastReportTime, State, UsesState},
-    Error,
+    Error, HasMetadata,
 };
 #[cfg(feature = "std")]
 use crate::{

libafl/src/events/tcp.rs

@@ -48,8 +48,8 @@ use crate::{
     fuzzer::{EvaluatorObservers, ExecutionProcessor},
     inputs::{Input, UsesInput},
     monitors::Monitor,
-    state::{HasExecutions, HasLastReportTime, HasMetadata, State, UsesState},
+    state::{HasExecutions, HasLastReportTime, State, UsesState},
-    Error,
+    Error, HasMetadata,
 };
 
 /// Tries to create (synchronously) a [`TcpListener`] that is `nonblocking` (for later use in tokio).

libafl/src/executors/inprocess/mod.rs

@@ -32,8 +32,8 @@ use crate::{
     fuzzer::HasObjective,
     inputs::UsesInput,
     observers::{ObserversTuple, UsesObservers},
-    state::{HasCorpus, HasExecutions, HasMetadata, HasSolutions, State, UsesState},
+    state::{HasCorpus, HasExecutions, HasSolutions, State, UsesState},
-    Error,
+    Error, HasMetadata,
 };
 
 /// The inner structure of `InProcessExecutor`.

libafl/src/feedbacks/concolic.rs

@@ -15,8 +15,8 @@ use crate::{
     feedbacks::Feedback,
     inputs::UsesInput,
     observers::{concolic::ConcolicObserver, ObserversTuple},
-    state::{HasMetadata, State},
+    state::State,
-    Error,
+    Error, HasMetadata,
 };
 
 /// The concolic feedback. It is used to attach concolic tracing metadata to the testcase.

libafl/src/feedbacks/differential.rs

@@ -16,8 +16,8 @@ use crate::{
     feedbacks::Feedback,
     inputs::Input,
     observers::{Observer, ObserversTuple},
-    state::{HasMetadata, State},
+    state::State,
-    Error,
+    Error, HasMetadata,
 };
 
 /// The result of a differential test between two observers.

libafl/src/feedbacks/list.rs

@@ -10,7 +10,8 @@ use crate::{
     executors::ExitKind,
     feedbacks::Feedback,
     observers::{ListObserver, ObserversTuple},
-    state::{HasNamedMetadata, State},
+    state::State,
+    HasNamedMetadata,
 };
 
 /// The metadata to remember past observed value

libafl/src/feedbacks/map.rs

@@ -24,8 +24,8 @@ use crate::{
     inputs::UsesInput,
     monitors::{AggregatorOps, UserStats, UserStatsValue},
     observers::{MapObserver, Observer, ObserversTuple, UsesObserver},
-    state::{HasMetadata, HasNamedMetadata, State},
+    state::State,
-    Error,
+    Error, HasMetadata, HasNamedMetadata,
 };
 
 /// A [`MapFeedback`] that implements the AFL algorithm using an [`OrReducer`] combining the bits for the history map and the bit from ``HitcountsMapObserver``.

libafl/src/feedbacks/nautilus.rs

@@ -15,8 +15,8 @@ use crate::{
     generators::NautilusContext,
     inputs::NautilusInput,
     observers::ObserversTuple,
-    state::{HasCorpus, HasMetadata, State},
+    state::{HasCorpus, State},
-    Error,
+    Error, HasMetadata,
 };
 
 /// Metadata for Nautilus grammar mutator chunks

libafl/src/feedbacks/new_hash_feedback.rs

@@ -13,8 +13,8 @@ use crate::{
     feedbacks::{Feedback, HasObserverName},
     inputs::UsesInput,
     observers::{ObserverWithHashField, ObserversTuple},
-    state::{HasNamedMetadata, State},
+    state::State,
-    Error,
+    Error, HasNamedMetadata,
 };
 
 /// The prefix of the metadata names

libafl/src/feedbacks/transferred.rs

@@ -5,11 +5,8 @@ use libafl_bolts::{impl_serdeany, Error, Named};
 use serde::{Deserialize, Serialize};
 
 use crate::{
-    events::EventFirer,
+    events::EventFirer, executors::ExitKind, feedbacks::Feedback, observers::ObserversTuple,
-    executors::ExitKind,
+    state::State, HasMetadata,
-    feedbacks::Feedback,
-    observers::ObserversTuple,
-    state::{HasMetadata, State},
 };
 
 /// Constant name of the [`TransferringMetadata`].

libafl/src/fuzzer/mod.rs

@@ -17,11 +17,8 @@ use crate::{
     schedulers::Scheduler,
     stages::{HasCurrentStage, StagesTuple},
     start_timer,
-    state::{
+    state::{HasCorpus, HasExecutions, HasImported, HasLastReportTime, HasSolutions, UsesState},
-        HasCorpus, HasExecutions, HasImported, HasLastReportTime, HasMetadata, HasSolutions,
+    Error, HasMetadata,
-        UsesState,
-    },
-    Error,
 };
 #[cfg(feature = "introspection")]
 use crate::{monitors::PerfFeature, state::HasClientPerfMonitor};
@@ -762,8 +759,8 @@ pub mod test {
         corpus::CorpusId,
         events::ProgressReporter,
         stages::{HasCurrentStage, StagesTuple},
-        state::{HasExecutions, HasLastReportTime, HasMetadata, State, UsesState},
+        state::{HasExecutions, HasLastReportTime, State, UsesState},
-        Fuzzer,
+        Fuzzer, HasMetadata,
     };
 
     #[derive(Clone, Debug)]

libafl/src/inputs/generalized.rs

@@ -9,8 +9,8 @@ use crate::{
     corpus::Testcase,
     inputs::BytesInput,
     stages::mutational::{MutatedTransform, MutatedTransformPost},
-    state::{HasCorpus, HasMetadata},
+    state::HasCorpus,
-    Error,
+    Error, HasMetadata,
 };
 
 /// An item of the generalized input

libafl/src/lib.rs

@@ -98,6 +98,8 @@ pub mod bolts {}
 #[doc(hidden)]
 pub use libafl_derive::*;
 
+pub mod common;
+pub use common::*;
 pub mod corpus;
 pub mod events;
 pub mod executors;

libafl/src/mutators/gramatron.rs

@@ -13,8 +13,8 @@ use crate::{
     inputs::{GramatronInput, Terminal},
     mutators::{MutationResult, Mutator},
     random_corpus_id,
-    state::{HasCorpus, HasMetadata, HasRand},
+    state::{HasCorpus, HasRand},
-    Error,
+    Error, HasMetadata,
 };
 
 const RECUR_THRESHOLD: u64 = 5;

libafl/src/mutators/grimoire.rs

@@ -11,8 +11,8 @@ use crate::{
     inputs::{GeneralizedInputMetadata, GeneralizedItem},
     mutators::{token_mutations::Tokens, MutationResult, Mutator},
     random_corpus_id,
-    state::{HasCorpus, HasMetadata, HasRand},
+    state::{HasCorpus, HasRand},
-    Error,
+    Error, HasMetadata,
 };
 
 const RECURSIVE_REPLACEMENT_DEPTH: [usize; 6] = [2, 4, 8, 16, 32, 64];

libafl/src/mutators/mopt_mutator.rs

@@ -18,8 +18,8 @@ use super::MutationId;
 use crate::{
     corpus::{Corpus, CorpusId},
     mutators::{ComposedByMutations, MutationResult, Mutator, MutatorsTuple, ScheduledMutator},
-    state::{HasCorpus, HasMetadata, HasRand, HasSolutions},
+    state::{HasCorpus, HasRand, HasSolutions},
-    Error,
+    Error, HasMetadata,
 };
 
 /// A Struct for managing MOpt-mutator parameters.

libafl/src/mutators/mutations.rs

@@ -1306,11 +1306,8 @@ mod tests {
 
     use super::*;
     use crate::{
-        corpus::InMemoryCorpus,
+        corpus::InMemoryCorpus, feedbacks::ConstFeedback, inputs::BytesInput,
-        feedbacks::ConstFeedback,
+        mutators::MutatorsTuple, state::StdState, HasMetadata,
-        inputs::BytesInput,
-        mutators::MutatorsTuple,
-        state::{HasMetadata, StdState},
     };
 
     type TestMutatorsTupleType = tuple_list_type!(

libafl/src/mutators/nautilus.rs

@@ -14,8 +14,8 @@ use crate::{
     generators::nautilus::NautilusContext,
     inputs::nautilus::NautilusInput,
     mutators::{MutationResult, Mutator},
-    state::{HasCorpus, HasMetadata},
+    state::HasCorpus,
-    Error,
+    Error, HasMetadata,
 };
 
 /// The randomic mutator for `Nautilus` grammar.

libafl/src/mutators/scheduled.rs

@@ -28,8 +28,8 @@ use crate::{
         token_mutations::{TokenInsert, TokenReplace},
         MutationResult, Mutator, MutatorsTuple,
     },
-    state::{HasCorpus, HasMetadata, HasRand},
+    state::{HasCorpus, HasRand},
-    Error,
+    Error, HasMetadata,
 };
 
 /// The metadata placed in a [`crate::corpus::Testcase`] by a [`LoggerScheduledMutator`].

libafl/src/mutators/string.rs

@@ -16,7 +16,8 @@ use crate::{
         mutational::{MutatedTransform, MutatedTransformPost},
         StringIdentificationMetadata,
     },
-    state::{HasCorpus, HasMaxSize, HasMetadata, HasRand},
+    state::{HasCorpus, HasMaxSize, HasRand},
+    HasMetadata,
 };
 
 /// Unicode category data, as used by string analysis and mutators.

libafl/src/mutators/token_mutations.rs

@@ -30,8 +30,8 @@ use crate::{
     },
     observers::cmp::{AFLppCmpValuesMetadata, CmpValues, CmpValuesMetadata},
     stages::TaintMetadata,
-    state::{HasCorpus, HasMaxSize, HasMetadata, HasRand},
+    state::{HasCorpus, HasMaxSize, HasRand},
-    Error,
+    Error, HasMetadata,
 };
 
 /// A state metadata holding a list of tokens

libafl/src/mutators/tuneable.rs

@@ -18,8 +18,8 @@ use crate::{
     mutators::{
         ComposedByMutations, MutationId, MutationResult, Mutator, MutatorsTuple, ScheduledMutator,
     },
-    state::{HasMetadata, HasRand},
+    state::HasRand,
-    Error,
+    Error, HasMetadata,
 };
 
 /// Metadata in the state, that controls the behavior of the [`TuneableScheduledMutator`] at runtime

libafl/src/observers/cmp.rs

@@ -11,9 +11,7 @@ use hashbrown::HashMap;
 use libafl_bolts::{ownedref::OwnedRefMut, serdeany::SerdeAny, AsMutSlice, AsSlice, Named};
 use serde::{de::DeserializeOwned, Deserialize, Serialize};
 
-use crate::{
+use crate::{executors::ExitKind, inputs::UsesInput, observers::Observer, Error, HasMetadata};
-    executors::ExitKind, inputs::UsesInput, observers::Observer, state::HasMetadata, Error,
-};
 
 /// Generic metadata trait for use in a `CmpObserver`, which adds comparisons from a `CmpObserver`
 /// primarily intended for use with `AFLppCmpValuesMetadata` or `CmpValuesMetadata`

libafl/src/schedulers/accounting.rs

@@ -16,8 +16,8 @@ use crate::{
         minimizer::{IsFavoredMetadata, MinimizerScheduler, DEFAULT_SKIP_NON_FAVORED_PROB},
         LenTimeMulTestcaseScore, Scheduler,
     },
-    state::{HasCorpus, HasMetadata, HasRand, UsesState},
+    state::{HasCorpus, HasRand, UsesState},
-    Error,
+    Error, HasMetadata,
 };
 
 /// A testcase metadata holding a list of indexes of a map

libafl/src/schedulers/minimizer.rs

@@ -14,8 +14,8 @@ use crate::{
     inputs::UsesInput,
     observers::ObserversTuple,
     schedulers::{LenTimeMulTestcaseScore, RemovableScheduler, Scheduler, TestcaseScore},
-    state::{HasCorpus, HasMetadata, HasRand, UsesState},
+    state::{HasCorpus, HasRand, UsesState},
-    Error,
+    Error, HasMetadata,
 };
 
 /// Default probability to skip the non-favored values

libafl/src/schedulers/mod.rs

@@ -35,8 +35,8 @@ use crate::{
     inputs::UsesInput,
     observers::{MapObserver, ObserversTuple},
     random_corpus_id,
-    state::{HasCorpus, HasMetadata, HasRand, State, UsesState},
+    state::{HasCorpus, HasRand, State, UsesState},
-    Error,
+    Error, HasMetadata,
 };
 
 /// The scheduler also implements `on_remove` and `on_replace` if it implements this stage.

libafl/src/schedulers/powersched.rs

@@ -13,8 +13,8 @@ use crate::{
     inputs::UsesInput,
     observers::{MapObserver, ObserversTuple},
     schedulers::{HasAFLSchedulerMetadata, RemovableScheduler, Scheduler},
-    state::{HasCorpus, HasMetadata, State, UsesState},
+    state::{HasCorpus, State, UsesState},
-    Error,
+    Error, HasMetadata,
 };
 
 /// The n fuzz size

libafl/src/schedulers/probabilistic_sampling.rs

@@ -12,8 +12,8 @@ use crate::{
     corpus::{Corpus, CorpusId, HasTestcase, Testcase},
     inputs::UsesInput,
     schedulers::{RemovableScheduler, Scheduler, TestcaseScore},
-    state::{HasCorpus, HasMetadata, HasRand, State, UsesState},
+    state::{HasCorpus, HasRand, State, UsesState},
-    Error,
+    Error, HasMetadata,
 };
 
 /// Conduct reservoir sampling (probabilistic sampling) over all corpus elements.
@@ -202,8 +202,8 @@ mod tests {
         feedbacks::ConstFeedback,
         inputs::{bytes::BytesInput, Input, UsesInput},
         schedulers::{ProbabilitySamplingScheduler, Scheduler, TestcaseScore},
-        state::{HasCorpus, HasMetadata, StdState},
+        state::{HasCorpus, StdState},
-        Error,
+        Error, HasMetadata,
     };
 
     const FACTOR: f64 = 1337.0;

libafl/src/schedulers/testcase_score.rs

@@ -11,8 +11,8 @@ use crate::{
         minimizer::{IsFavoredMetadata, TopRatedsMetadata},
         powersched::{PowerSchedule, SchedulerMetadata},
     },
-    state::{HasCorpus, HasMetadata},
+    state::HasCorpus,
-    Error,
+    Error, HasMetadata,
 };
 
 /// Compute the favor factor of a [`Testcase`]. Higher is better.

libafl/src/schedulers/tuneable.rs

@@ -12,8 +12,8 @@ use super::RemovableScheduler;
 use crate::{
     corpus::{Corpus, CorpusId, HasTestcase},
     schedulers::Scheduler,
-    state::{HasCorpus, HasMetadata, State, UsesState},
+    state::{HasCorpus, State, UsesState},
-    Error,
+    Error, HasMetadata,
 };
 
 #[derive(Default, Clone, Copy, Eq, PartialEq, Debug, Serialize, Deserialize)]

libafl/src/schedulers/weighted.rs

@@ -18,8 +18,8 @@ use crate::{
         testcase_score::{CorpusWeightTestcaseScore, TestcaseScore},
         HasAFLSchedulerMetadata, RemovableScheduler, Scheduler,
     },
-    state::{HasCorpus, HasMetadata, HasRand, State, UsesState},
+    state::{HasCorpus, HasRand, State, UsesState},
-    Error,
+    Error, HasMetadata,
 };
 
 /// The Metadata for `WeightedScheduler`

libafl/src/stages/calibrate.rs

@@ -21,11 +21,8 @@ use crate::{
     observers::{MapObserver, ObserversTuple, UsesObserver},
     schedulers::powersched::SchedulerMetadata,
     stages::{ExecutionCountRestartHelper, Stage},
-    state::{
+    state::{HasCorpus, HasCurrentTestcase, HasExecutions, State, UsesState},
-        HasCorpus, HasCurrentTestcase, HasExecutions, HasMetadata, HasNamedMetadata, State,
+    Error, HasMetadata, HasNamedMetadata,
-        UsesState,
-    },
-    Error,
 };
 
 /// The metadata to keep unstable entries

libafl/src/stages/colorization.rs

@@ -16,8 +16,8 @@ use crate::{
     mutators::mutations::buffer_copy,
     observers::{MapObserver, ObserversTuple},
     stages::{RetryRestartHelper, Stage},
-    state::{HasCorpus, HasCurrentTestcase, HasMetadata, HasNamedMetadata, HasRand, UsesState},
+    state::{HasCorpus, HasCurrentTestcase, HasRand, UsesState},
-    Error,
+    Error, HasMetadata, HasNamedMetadata,
 };
 
 // Bigger range is better

libafl/src/stages/concolic.rs

@@ -18,10 +18,8 @@ use crate::{
     executors::{Executor, HasObservers},
     observers::concolic::ConcolicObserver,
     stages::{RetryRestartHelper, Stage, TracingStage},
-    state::{
+    state::{HasCorpus, HasCurrentTestcase, HasExecutions, UsesState},
-        HasCorpus, HasCurrentTestcase, HasExecutions, HasMetadata, HasNamedMetadata, UsesState,
+    Error, HasMetadata, HasNamedMetadata,
-    },
-    Error,
 };
 #[cfg(feature = "concolic_mutation")]
 use crate::{

libafl/src/stages/dump.rs

@@ -11,8 +11,8 @@ use crate::{
     corpus::{Corpus, CorpusId},
     inputs::UsesInput,
     stages::Stage,
-    state::{HasCorpus, HasMetadata, HasRand, HasSolutions, UsesState},
+    state::{HasCorpus, HasRand, HasSolutions, UsesState},
-    Error,
+    Error, HasMetadata,
 };
 
 /// Metadata used to store information about disk dump indexes for names

libafl/src/stages/generalization.rs

@@ -17,8 +17,8 @@ use crate::{
     observers::{MapObserver, ObserversTuple},
     stages::{RetryRestartHelper, Stage},
     start_timer,
-    state::{HasCorpus, HasExecutions, HasMetadata, HasNamedMetadata, UsesState},
+    state::{HasCorpus, HasExecutions, UsesState},
-    Error,
+    Error, HasMetadata, HasNamedMetadata,
 };
 #[cfg(feature = "introspection")]
 use crate::{monitors::PerfFeature, state::HasClientPerfMonitor};

libafl/src/stages/mod.rs

@@ -46,11 +46,9 @@ use crate::{
     observers::ObserversTuple,
     schedulers::Scheduler,
     stages::push::PushStage,
-    state::{
+    state::{HasCorpus, HasExecutions, HasLastReportTime, HasRand, State, UsesState},
-        HasCorpus, HasExecutions, HasLastReportTime, HasMetadata, HasNamedMetadata, HasRand, State,
+    Error, EvaluatorObservers, ExecutesInput, ExecutionProcessor, HasMetadata, HasNamedMetadata,
-        UsesState,
+    HasScheduler,
-    },
-    Error, EvaluatorObservers, ExecutesInput, ExecutionProcessor, HasScheduler,
 };
 
 /// Mutational stage is the normal fuzzing stage.
@@ -655,7 +653,8 @@ pub mod test {
         corpus::{Corpus, HasCurrentCorpusIdx, Testcase},
         inputs::NopInput,
         stages::{RetryRestartHelper, Stage},
-        state::{test::test_std_state, HasCorpus, HasMetadata, State, UsesState},
+        state::{test::test_std_state, HasCorpus, State, UsesState},
+        HasMetadata,
     };
 
     #[derive(Debug)]

libafl/src/stages/mutational.rs

@@ -13,11 +13,8 @@ use crate::{
     mutators::{MultiMutator, MutationResult, Mutator},
     stages::{ExecutionCountRestartHelper, RetryRestartHelper, Stage},
     start_timer,
-    state::{
+    state::{HasCorpus, HasCurrentTestcase, HasExecutions, HasRand, UsesState},
-        HasCorpus, HasCurrentTestcase, HasExecutions, HasMetadata, HasNamedMetadata, HasRand,
+    Error, HasMetadata, HasNamedMetadata,
-        UsesState,
-    },
-    Error,
 };
 #[cfg(feature = "introspection")]
 use crate::{monitors::PerfFeature, state::HasClientPerfMonitor};

libafl/src/stages/power.rs

@@ -8,8 +8,8 @@ use crate::{
     mutators::Mutator,
     schedulers::{testcase_score::CorpusPowerTestcaseScore, TestcaseScore},
     stages::{mutational::MutatedTransform, ExecutionCountRestartHelper, MutationalStage, Stage},
-    state::{HasCorpus, HasCurrentTestcase, HasExecutions, HasMetadata, HasRand, UsesState},
+    state::{HasCorpus, HasCurrentTestcase, HasExecutions, HasRand, UsesState},
-    Error,
+    Error, HasMetadata,
 };
 
 /// The mutational stage using power schedules

libafl/src/stages/push/mod.rs

@@ -22,8 +22,8 @@ use crate::{
     inputs::UsesInput,
     observers::ObserversTuple,
     schedulers::Scheduler,
-    state::{HasCorpus, HasExecutions, HasLastReportTime, HasMetadata, HasRand},
+    state::{HasCorpus, HasExecutions, HasLastReportTime, HasRand},
-    Error, EvaluatorObservers, ExecutionProcessor, HasScheduler,
+    Error, EvaluatorObservers, ExecutionProcessor, HasMetadata, HasScheduler,
 };
 
 /// Send a monitor update all 15 (or more) seconds

libafl/src/stages/push/mutational.rs

@@ -20,8 +20,8 @@ use crate::{
     observers::ObserversTuple,
     schedulers::Scheduler,
     start_timer,
-    state::{HasCorpus, HasExecutions, HasLastReportTime, HasMetadata, HasRand},
+    state::{HasCorpus, HasExecutions, HasLastReportTime, HasRand},
-    Error, EvaluatorObservers, ExecutionProcessor, HasScheduler,
+    Error, EvaluatorObservers, ExecutionProcessor, HasMetadata, HasScheduler,
 };
 #[cfg(feature = "introspection")]
 use crate::{monitors::PerfFeature, state::HasClientPerfMonitor};

libafl/src/stages/stats.rs

@@ -13,8 +13,8 @@ use crate::{
     events::EventFirer,
     schedulers::minimizer::IsFavoredMetadata,
     stages::Stage,
-    state::{HasCorpus, HasImported, HasMetadata, UsesState},
+    state::{HasCorpus, HasImported, UsesState},
-    Error,
+    Error, HasMetadata,
 };
 #[cfg(feature = "std")]
 use crate::{

libafl/src/stages/string.rs

@@ -11,7 +11,8 @@ use crate::{
     corpus::HasTestcase,
     inputs::{BytesInput, HasBytesVec},
     stages::Stage,
-    state::{HasCorpus, HasCurrentTestcase, HasMetadata, State, UsesState},
+    state::{HasCorpus, HasCurrentTestcase, State, UsesState},
+    HasMetadata,
 };
 
 /// Metadata which stores the list of pre-computed string-like ranges in the input

libafl/src/stages/sync.rs

@@ -19,8 +19,8 @@ use crate::{
     fuzzer::{Evaluator, EvaluatorObservers, ExecutionProcessor},
     inputs::{Input, InputConverter, UsesInput},
     stages::{RetryRestartHelper, Stage},
-    state::{HasCorpus, HasExecutions, HasMetadata, HasNamedMetadata, HasRand, State, UsesState},
+    state::{HasCorpus, HasExecutions, HasRand, State, UsesState},
-    Error,
+    Error, HasMetadata, HasNamedMetadata,
 };
 
 /// Metadata used to store information about disk sync time

libafl/src/stages/tmin.rs

@@ -22,10 +22,9 @@ use crate::{
     },
     start_timer,
     state::{
-        HasCorpus, HasCurrentTestcase, HasExecutions, HasMaxSize, HasMetadata, HasSolutions, State,
+        HasCorpus, HasCurrentTestcase, HasExecutions, HasMaxSize, HasSolutions, State, UsesState,
-        UsesState,
     },
-    Error, ExecutesInput, ExecutionProcessor, HasFeedback, HasScheduler,
+    Error, ExecutesInput, ExecutionProcessor, HasFeedback, HasMetadata, HasScheduler,
 };
 #[cfg(feature = "introspection")]
 use crate::{monitors::PerfFeature, state::HasClientPerfMonitor};

libafl/src/stages/tracing.rs

@@ -10,8 +10,8 @@ use crate::{
     observers::ObserversTuple,
     stages::{RetryRestartHelper, Stage},
     start_timer,
-    state::{HasCorpus, HasCurrentTestcase, HasExecutions, HasNamedMetadata, State, UsesState},
+    state::{HasCorpus, HasCurrentTestcase, HasExecutions, State, UsesState},
-    Error,
+    Error, HasNamedMetadata,
 };
 #[cfg(feature = "introspection")]
 use crate::{monitors::PerfFeature, state::HasClientPerfMonitor};

libafl/src/stages/tuneable.rs

@@ -14,11 +14,8 @@ use crate::{
         ExecutionCountRestartHelper, MutationalStage, Stage,
     },
     start_timer,
-    state::{
+    state::{HasCorpus, HasCurrentTestcase, HasExecutions, HasRand, UsesState},
-        HasCorpus, HasCurrentTestcase, HasExecutions, HasMetadata, HasNamedMetadata, HasRand,
+    Error, Evaluator, HasMetadata, HasNamedMetadata,
-        UsesState,
-    },
-    Error, Evaluator,
 };
 #[cfg(feature = "introspection")]
 use crate::{monitors::PerfFeature, state::HasClientPerfMonitor};

libafl/src/state/mod.rs

@@ -1,6 +1,6 @@
 //! The fuzzer, and state are the core pieces of every good fuzzer
 
-use alloc::{boxed::Box, vec::Vec};
+use alloc::vec::Vec;
 use core::{
     borrow::BorrowMut,
     cell::{Ref, RefMut},
@@ -18,7 +18,7 @@ use std::{
 use libafl_bolts::core_affinity::{CoreId, Cores};
 use libafl_bolts::{
     rands::{Rand, StdRand},
-    serdeany::{NamedSerdeAnyMap, SerdeAny, SerdeAnyMap},
+    serdeany::{NamedSerdeAnyMap, SerdeAnyMap},
 };
 use serde::{de::DeserializeOwned, Deserialize, Serialize};
 
@@ -34,7 +34,7 @@ use crate::{
     generators::Generator,
     inputs::{Input, UsesInput},
     stages::{HasCurrentStage, HasNestedStageStatus},
-    Error,
+    Error, HasMetadata, HasNamedMetadata,
 };
 
 /// The maximum size of a testcase
@@ -155,149 +155,6 @@ pub trait HasScalabilityMonitor {
     fn scalability_monitor_mut(&mut self) -> &mut ScalabilityMonitor;
 }
 
-/// Trait for elements offering metadata
-pub trait HasMetadata {
-    /// A map, storing all metadata
-    fn metadata_map(&self) -> &SerdeAnyMap;
-    /// A map, storing all metadata (mutable)
-    fn metadata_map_mut(&mut self) -> &mut SerdeAnyMap;
-
-    /// Add a metadata to the metadata map
-    #[inline]
-    fn add_metadata<M>(&mut self, meta: M)
-    where
-        M: SerdeAny,
-    {
-        self.metadata_map_mut().insert(meta);
-    }
-
-    /// Gets metadata, or inserts it using the given construction function `default`
-    fn metadata_or_insert_with<M>(&mut self, default: impl FnOnce() -> M) -> &mut M
-    where
-        M: SerdeAny,
-    {
-        self.metadata_map_mut().get_or_insert_with::<M>(default)
-    }
-
-    /// Remove a metadata from the metadata map
-    #[inline]
-    fn remove_metadata<M>(&mut self) -> Option<Box<M>>
-    where
-        M: SerdeAny,
-    {
-        self.metadata_map_mut().remove::<M>()
-    }
-
-    /// Check for a metadata
-    ///
-    /// # Note
-    /// For performance reasons, you likely want to use [`Self::metadata_or_insert_with`] instead
-    #[inline]
-    fn has_metadata<M>(&self) -> bool
-    where
-        M: SerdeAny,
-    {
-        self.metadata_map().get::<M>().is_some()
-    }
-
-    /// To get metadata
-    #[inline]
-    fn metadata<M>(&self) -> Result<&M, Error>
-    where
-        M: SerdeAny,
-    {
-        self.metadata_map().get::<M>().ok_or_else(|| {
-            Error::key_not_found(format!("{} not found", core::any::type_name::<M>()))
-        })
-    }
-
-    /// To get mutable metadata
-    #[inline]
-    fn metadata_mut<M>(&mut self) -> Result<&mut M, Error>
-    where
-        M: SerdeAny,
-    {
-        self.metadata_map_mut().get_mut::<M>().ok_or_else(|| {
-            Error::key_not_found(format!("{} not found", core::any::type_name::<M>()))
-        })
-    }
-}
-
-/// Trait for elements offering named metadata
-pub trait HasNamedMetadata {
-    /// A map, storing all metadata
-    fn named_metadata_map(&self) -> &NamedSerdeAnyMap;
-    /// A map, storing all metadata (mutable)
-    fn named_metadata_map_mut(&mut self) -> &mut NamedSerdeAnyMap;
-
-    /// Add a metadata to the metadata map
-    #[inline]
-    fn add_named_metadata<M>(&mut self, name: &str, meta: M)
-    where
-        M: SerdeAny,
-    {
-        self.named_metadata_map_mut().insert(name, meta);
-    }
-
-    /// Add a metadata to the metadata map
-    #[inline]
-    fn remove_named_metadata<M>(&mut self, name: &str) -> Option<Box<M>>
-    where
-        M: SerdeAny,
-    {
-        self.named_metadata_map_mut().remove::<M>(name)
-    }
-
-    /// Gets metadata, or inserts it using the given construction function `default`
-    fn named_metadata_or_insert_with<M>(
-        &mut self,
-        name: &str,
-        default: impl FnOnce() -> M,
-    ) -> &mut M
-    where
-        M: SerdeAny,
-    {
-        self.named_metadata_map_mut()
-            .get_or_insert_with::<M>(name, default)
-    }
-
-    /// Check for a metadata
-    ///
-    /// # Note
-    /// You likely want to use [`Self::named_metadata_or_insert_with`] for performance reasons.
-    #[inline]
-    fn has_named_metadata<M>(&self, name: &str) -> bool
-    where
-        M: SerdeAny,
-    {
-        self.named_metadata_map().contains::<M>(name)
-    }
-
-    /// To get named metadata
-    #[inline]
-    fn named_metadata<M>(&self, name: &str) -> Result<&M, Error>
-    where
-        M: SerdeAny,
-    {
-        self.named_metadata_map().get::<M>(name).ok_or_else(|| {
-            Error::key_not_found(format!("{} not found", core::any::type_name::<M>()))
-        })
-    }
-
-    /// To get mutable named metadata
-    #[inline]
-    fn named_metadata_mut<M>(&mut self, name: &str) -> Result<&mut M, Error>
-    where
-        M: SerdeAny,
-    {
-        self.named_metadata_map_mut()
-            .get_mut::<M>(name)
-            .ok_or_else(|| {
-                Error::key_not_found(format!("{} not found", core::any::type_name::<M>()))
-            })
-    }
-}
-
 /// Trait for the execution counter
 pub trait HasExecutions {
     /// The executions counter

libafl_frida/src/asan/errors.rs

@@ -18,8 +18,8 @@ use libafl::{
     feedbacks::Feedback,
     inputs::{HasTargetBytes, UsesInput},
     observers::{Observer, ObserversTuple},
-    state::{HasMetadata, State},
+    state::State,
-    Error,
+    Error, HasMetadata,
 };
 use libafl_bolts::{ownedref::OwnedPtr, Named, SerdeAny};
 use serde::{Deserialize, Serialize};

libafl_libfuzzer/libafl_libfuzzer_runtime/src/feedbacks.rs

@@ -9,8 +9,8 @@ use libafl::{
     feedbacks::{Feedback, MinMapFeedback},
     inputs::{BytesInput, Input},
     observers::ObserversTuple,
-    state::{HasMetadata, State},
+    state::State,
-    Error,
+    Error, HasMetadata,
 };
 use libafl_bolts::{impl_serdeany, Named};
 use libafl_targets::OomFeedback;

libafl_libfuzzer/libafl_libfuzzer_runtime/src/fuzz.rs

@@ -23,8 +23,8 @@ use libafl::{
         Monitor, MultiMonitor, SimpleMonitor,
     },
     stages::{HasCurrentStage, StagesTuple},
-    state::{HasExecutions, HasLastReportTime, HasMetadata, HasSolutions, UsesState},
+    state::{HasExecutions, HasLastReportTime, HasSolutions, UsesState},
-    Error, Fuzzer,
+    Error, Fuzzer, HasMetadata,
 };
 use libafl_bolts::{
     core_affinity::Cores,

libafl_libfuzzer/libafl_libfuzzer_runtime/src/misc.rs

@@ -3,7 +3,7 @@ use std::{
     path::PathBuf,
 };
 
-use libafl::{state::HasMetadata, Error};
+use libafl::{Error, HasMetadata};
 use libafl_bolts::impl_serdeany;
 use serde::{Deserialize, Serialize};
 use utf8_chars::BufReadCharsExt;

libafl_libfuzzer/libafl_libfuzzer_runtime/src/report.rs

@@ -7,8 +7,8 @@ use libafl::{
     inputs::UsesInput,
     monitors::SimpleMonitor,
     stages::{HasCurrentStage, StagesTuple},
-    state::{HasExecutions, HasLastReportTime, HasMetadata, HasNamedMetadata},
+    state::{HasExecutions, HasLastReportTime},
-    Error, Fuzzer,
+    Error, Fuzzer, HasMetadata, HasNamedMetadata,
 };
 
 use crate::{fuzz_with, options::LibfuzzerOptions};

libafl_libfuzzer/libafl_libfuzzer_runtime/src/schedulers.rs

@@ -8,8 +8,8 @@ use libafl::{
     feedbacks::MapNoveltiesMetadata,
     inputs::UsesInput,
     schedulers::{RemovableScheduler, Scheduler},
-    state::{HasCorpus, HasMetadata, State, UsesState},
+    state::{HasCorpus, State, UsesState},
-    Error,
+    Error, HasMetadata,
 };
 
 #[derive(Clone, Debug)]

libafl_qemu/src/asan.rs

@@ -8,9 +8,7 @@ use std::{
 };
 
 use addr2line::object::{Object, ObjectSection};
-use libafl::{
+use libafl::{executors::ExitKind, inputs::UsesInput, observers::ObserversTuple, HasMetadata};
-    executors::ExitKind, inputs::UsesInput, observers::ObserversTuple, state::HasMetadata,
-};
 use libafl_qemu_sys::GuestAddr;
 use libc::{
     c_void, MAP_ANON, MAP_FAILED, MAP_FIXED, MAP_NORESERVE, MAP_PRIVATE, PROT_READ, PROT_WRITE,

libafl_qemu/src/cmplog.rs

@@ -1,7 +1,7 @@
 #[cfg(emulation_mode = "usermode")]
 use capstone::{arch::BuildsCapstone, Capstone, InsnDetail};
 use hashbrown::HashMap;
-use libafl::{inputs::UsesInput, state::HasMetadata};
+use libafl::{inputs::UsesInput, HasMetadata};
 use libafl_qemu_sys::GuestAddr;
 pub use libafl_targets::{
     cmps::{

libafl_qemu/src/drcov.rs

@@ -1,9 +1,7 @@
 use std::{path::PathBuf, sync::Mutex};
 
 use hashbrown::{hash_map::Entry, HashMap};
-use libafl::{
+use libafl::{executors::ExitKind, inputs::UsesInput, observers::ObserversTuple, HasMetadata};
-    executors::ExitKind, inputs::UsesInput, observers::ObserversTuple, state::HasMetadata,
-};
 use libafl_qemu_sys::{GuestAddr, GuestUsize};
 use libafl_targets::drcov::{DrCovBasicBlock, DrCovWriter};
 use rangemap::RangeMap;

libafl_qemu/src/edges.rs

@@ -1,7 +1,7 @@
 use std::{cell::UnsafeCell, cmp::max};
 
 use hashbrown::{hash_map::Entry, HashMap};
-use libafl::{inputs::UsesInput, state::HasMetadata};
+use libafl::{inputs::UsesInput, HasMetadata};
 use libafl_qemu_sys::GuestAddr;
 #[cfg(emulation_mode = "systemmode")]
 use libafl_qemu_sys::GuestPhysAddr;

libafl_qemu/src/executor/mod.rs

@@ -8,11 +8,7 @@ use core::{
 };
 
 #[cfg(feature = "fork")]
-use libafl::{
+use libafl::{events::EventManager, executors::InProcessForkExecutor, state::HasLastReportTime};
-    events::EventManager,
-    executors::InProcessForkExecutor,
-    state::{HasLastReportTime, HasMetadata},
-};
 use libafl::{
     events::{EventFirer, EventRestarter},
     executors::{
@@ -24,7 +20,7 @@ use libafl::{
     fuzzer::HasObjective,
     observers::{ObserversTuple, UsesObservers},
     state::{HasCorpus, HasExecutions, HasSolutions, State, UsesState},
-    Error,
+    Error, HasMetadata,
 };
 use libafl_bolts::os::unix_signals::{siginfo_t, ucontext_t, Signal};
 #[cfg(feature = "fork")]

libafl_qemu/src/snapshot.rs

@@ -4,7 +4,7 @@ use std::{
     sync::Mutex,
 };
 
-use libafl::{inputs::UsesInput, state::HasMetadata};
+use libafl::{inputs::UsesInput, HasMetadata};
 use libafl_qemu_sys::{GuestAddr, MmapPerms};
 use meminterval::{Interval, IntervalTree};
 use thread_local::ThreadLocal;

libafl_sugar/src/forkserver.rs

@@ -18,8 +18,8 @@ use libafl::{
     observers::{HitcountsMapObserver, StdMapObserver, TimeObserver},
     schedulers::{IndexesLenTimeMinimizerScheduler, QueueScheduler},
     stages::StdMutationalStage,
-    state::{HasCorpus, HasMetadata, StdState},
+    state::{HasCorpus, StdState},
-    Error,
+    Error, HasMetadata,
 };
 use libafl_bolts::{
     core_affinity::Cores,

libafl_sugar/src/inmemory.rs

@@ -21,8 +21,8 @@ use libafl::{
     observers::{HitcountsMapObserver, TimeObserver},
     schedulers::{IndexesLenTimeMinimizerScheduler, QueueScheduler},
     stages::{ShadowTracingStage, StdMutationalStage},
-    state::{HasCorpus, HasMetadata, StdState},
+    state::{HasCorpus, StdState},
-    Error,
+    Error, HasMetadata,
 };
 use libafl_bolts::{
     core_affinity::Cores,

libafl_sugar/src/qemu.rs

@@ -24,7 +24,8 @@ use libafl::{
     observers::{HitcountsMapObserver, TimeObserver, VariableMapObserver},
     schedulers::{IndexesLenTimeMinimizerScheduler, QueueScheduler},
     stages::{ShadowTracingStage, StdMutationalStage},
-    state::{HasCorpus, HasMetadata, StdState},
+    state::{HasCorpus, StdState},
+    HasMetadata,
 };
 use libafl_bolts::{
     core_affinity::Cores,

libafl_targets/src/cmps/observers/aflpp.rs

@@ -11,8 +11,7 @@ use libafl::{
         cmp::{AFLppCmpValuesMetadata, CmpMap, CmpObserver, CmpObserverMetadata, CmpValues},
         Observer,
     },
-    state::HasMetadata,
+    Error, HasMetadata,
-    Error,
 };
 use libafl_bolts::{ownedref::OwnedRefMut, Named};
 use serde::{Deserialize, Serialize};

libafl_targets/src/cmps/observers/cmplog.rs

@@ -9,8 +9,7 @@ use libafl::{
     executors::ExitKind,
     inputs::UsesInput,
     observers::{cmp::CmpValuesMetadata, CmpMap, CmpObserver, Observer},
-    state::HasMetadata,
+    Error, HasMetadata,
-    Error,
 };
 use libafl_bolts::{ownedref::OwnedMutPtr, Named};