scalability monitor 2nd (#1685)

* tekito

* monitor

* fix

* all

* ci

* ci

fuzzers/libfuzzer_libpng_centralized/Cargo.toml

@@ -19,7 +19,7 @@ cc = { version = "1.0", features = ["parallel"] }
 which = "4.4"
 
 [dependencies]
-libafl = { path = "../../libafl/", features = ["std", "derive", "rand_trait", "fork", "prelude", "gzip", "regex"] }
+libafl = { path = "../../libafl/", features = ["std", "derive", "rand_trait", "fork", "prelude", "gzip", "regex", "scalability_introspection"] }
 libafl_bolts = { path = "../../libafl_bolts/" }
 libafl_targets = { path = "../../libafl_targets/", features = ["sancov_pcguard_hitcounts", "libfuzzer"] }
 # TODO Include it only when building cc

libafl/Cargo.toml

@@ -30,7 +30,7 @@ std = ["serde_json", "serde_json/std", "nix", "serde/std", "bincode", "wait-time
 introspection = []
 
 ## Collects stats about scalability
-scalability_introspecition = []
+scalability_introspection = []
 
 ## Will build the `pyo3` bindings
 python = ["pyo3", "concat-idents", "libafl_bolts/python"]

libafl/src/events/centralized.rs

@@ -20,6 +20,8 @@ use serde::{Deserialize, Serialize};
 use super::{CustomBufEventResult, HasCustomBufHandlers, ProgressReporter};
 #[cfg(feature = "llmp_compression")]
 use crate::events::llmp::COMPRESS_THRESHOLD;
+#[cfg(feature = "scalability_introspection")]
+use crate::state::HasScalabilityMonitor;
 use crate::{
     events::{
         llmp::EventStatsCollector, BrokerEventResult, Event, EventConfig, EventFirer, EventManager,
@@ -652,34 +654,36 @@ where
             } => {
                 log::info!("Received new Testcase from {client_id:?} ({client_config:?}, forward {forward_id:?})");
 
-                #[cfg(feature = "scalability_introspection")]
+                let res =
-                println!(
+                    if client_config.match_with(&self.configuration()) && observers_buf.is_some() {
-                    "{} {}",
-                    state.scalability_monitor().testcase_with_observers,
-                    state.scalability_monitor().testcase_without_observers
-                );
-                let res = if client_config.match_with(&self.configuration())
-                    && observers_buf.is_some()
-                {
                         let observers: E::Observers =
                             postcard::from_bytes(observers_buf.as_ref().unwrap())?;
                         #[cfg(feature = "scalability_introspection")]
                         {
                             state.scalability_monitor_mut().testcase_with_observers += 1;
                         }
-                    fuzzer.process_execution(state, self, input, &observers, &exit_kind, true)?
+                        fuzzer.process_execution(
+                            state,
+                            self,
+                            input.clone(),
+                            &observers,
+                            &exit_kind,
+                            false,
+                        )?
                     } else {
                         #[cfg(feature = "scalability_introspection")]
                         {
                             state.scalability_monitor_mut().testcase_without_observers += 1;
                         }
-                    let res = fuzzer.evaluate_input_with_observers::<E, Self>(
+                        fuzzer.evaluate_input_with_observers::<E, Self>(
                             state,
                             executor,
                             self,
                             input.clone(),
                             false,
-                    )?;
+                        )?
+                    };
+                if let Some(item) = res.1 {
                     if res.1.is_some() {
                         self.inner.fire(
                             state,
@@ -695,9 +699,6 @@ where
                             },
                         )?;
                     }
-                    res
-                };
-                if let Some(item) = res.1 {
                     log::info!("Added received Testcase as item #{item}");
                 }
                 Ok(())

libafl/src/events/launcher.rs

@@ -579,7 +579,7 @@ where
                             mgr,
                             self.shmem_provider.clone(),
                             self.centralized_broker_port,
-                            id == 0,
+                            index == 1,
                         )?;
 
                         return (self.run_client.take().unwrap())(state, c_mgr, *bind_to);

libafl/src/events/mod.rs

@@ -15,6 +15,8 @@ pub mod llmp;
 #[cfg(feature = "tcp_manager")]
 #[allow(clippy::ignored_unit_patterns)]
 pub mod tcp;
+#[cfg(feature = "scalability_introspection")]
+use alloc::string::ToString;
 use alloc::{boxed::Box, string::String, vec::Vec};
 #[cfg(all(unix, feature = "std"))]
 use core::ffi::c_void;
@@ -48,6 +50,8 @@ use crate::{
     state::{HasExecutions, HasLastReportTime, HasMetadata, State},
     Error,
 };
+#[cfg(feature = "scalability_introspection")]
+use crate::{monitors::UserStats::Number, state::HasScalabilityMonitor};
 
 /// Check if ctrl-c is sent with this struct
 #[cfg(all(unix, feature = "std"))]
@@ -525,6 +529,22 @@ where
             )?;
         }
 
+        // If we are measuring scalability stuff..
+        #[cfg(feature = "scalability_introspection")]
+        {
+            let imported_with_observer = state.scalability_monitor().testcase_with_observers;
+            let imported_without_observer = state.scalability_monitor().testcase_without_observers;
+
+            self.fire(
+                state,
+                Event::UpdateUserStats {
+                    name: "total imported".to_string(),
+                    value: Number((imported_with_observer + imported_without_observer) as u64),
+                    phantom: PhantomData,
+                },
+            )?;
+        }
+
         *state.last_report_time_mut() = Some(cur);
 
         Ok(())

libafl/src/stages/concolic.rs

@@ -8,7 +8,7 @@ use alloc::{borrow::ToOwned, string::ToString, vec::Vec};
 use core::marker::PhantomData;
 
 use super::{Stage, TracingStage};
-#[cfg(feature = "introspection")]
+#[cfg(all(feature = "introspection", feature = "concolic_mutation"))]
 use crate::state::HasClientPerfMonitor;
 #[cfg(feature = "concolic_mutation")]
 use crate::state::State;

libafl/src/state/mod.rs

@@ -123,20 +123,20 @@ impl<T> MaybeHasClientPerfMonitor for T {}
 impl<T> MaybeHasClientPerfMonitor for T where T: HasClientPerfMonitor {}
 
 /// Intermediate trait for `HasScalabilityMonitor`
-#[cfg(feature = "scalability_monitor")]
+#[cfg(feature = "scalability_introspection")]
 pub trait MaybeHasScalabilityMonitor: HasScalabilityMonitor {}
 /// Intermediate trait for `HasScalabilityMonitor`
-#[cfg(not(feature = "scalability_monitor"))]
+#[cfg(not(feature = "scalability_introspection"))]
 pub trait MaybeHasScalabilityMonitor {}
 
-#[cfg(not(feature = "scalability_monitor"))]
+#[cfg(not(feature = "scalability_introspection"))]
 impl<T> MaybeHasScalabilityMonitor for T {}
 
-#[cfg(feature = "scalability_monitor")]
+#[cfg(feature = "scalability_introspection")]
 impl<T> MaybeHasScalabilityMonitor for T where T: HasScalabilityMonitor {}
 
 /// Trait for offering a [`ScalabilityMonitor`]
-#[cfg(feature = "scalability_monitor")]
+#[cfg(feature = "scalability_introspection")]
 pub trait HasScalabilityMonitor {
     /// Ref to [`ScalabilityMonitor`]
     fn scalability_monitor(&self) -> &ScalabilityMonitor;
@@ -1011,6 +1011,17 @@ impl<I> HasClientPerfMonitor for NopState<I> {
     }
 }
 
+#[cfg(feature = "scalability_introspection")]
+impl<I> HasScalabilityMonitor for NopState<I> {
+    fn scalability_monitor(&self) -> &ScalabilityMonitor {
+        unimplemented!();
+    }
+
+    fn scalability_monitor_mut(&mut self) -> &mut ScalabilityMonitor {
+        unimplemented!();
+    }
+}
+
 #[cfg(feature = "python")]
 #[allow(missing_docs)]
 /// `State` Python bindings