Add missing mode to LibAFL (#3708)

* Add support for AFL_PIZZA_MODE

* Fix titles

Author: domenukk

crates/libafl/src/monitors/mod.rs

@@ -36,13 +36,49 @@ use core::{
     fmt::{Debug, Write},
     time::Duration,
 };
+#[cfg(feature = "std")]
+use std::sync::OnceLock;
 
 use libafl_bolts::ClientId;
 #[cfg(feature = "prometheus_monitor")]
 pub use prometheus::PrometheusMonitor;
 #[cfg(feature = "statsd_monitor")]
 pub use statsd::StatsdMonitor;
 
+/// Returns if we're cooking.
+#[cfg(feature = "std")]
+#[must_use]
+pub(crate) fn pizza_is_served() -> bool {
+    static PIZZA_IS_SERVED: OnceLock<bool> = OnceLock::new();
+    *PIZZA_IS_SERVED.get_or_init(|| {
+        std::env::var("AFL_PIZZA_MODE").map_or(false, |v| v != "0") || {
+            #[cfg(unix)]
+            // SAFETY: `localtime` and `time` are standard libc functions. `t` is initialized.
+            unsafe {
+                let mut t = 0;
+                libc::time(&raw mut t);
+                let tm = libc::localtime(&raw const t);
+                !tm.is_null() && (*tm).tm_mon == 3 && (*tm).tm_mday == 1
+            }
+            #[cfg(windows)]
+            // SAFETY: `GetLocalTime` is a standard Win32 API.
+            unsafe {
+                let lt = windows::Win32::System::SystemInformation::GetLocalTime();
+                lt.wMonth == 4 && lt.wDay == 1
+            }
+            #[cfg(not(any(unix, windows)))]
+            false
+        }
+    })
+}
+
+#[cfg(not(feature = "std"))]
+/// Returns `true` if it is currently pizza mode.
+#[must_use]
+pub fn pizza_is_served() -> bool {
+    false
+}
+
 use crate::monitors::stats::ClientStatsManager;
 
 /// The monitor trait keeps track of all the client's monitor, and offers methods to display them.
@@ -117,15 +153,40 @@ impl Monitor for SimplePrintingMonitor {
             .collect::<Vec<_>>();
         userstats.sort();
         let global_stats = client_stats_manager.global_stats();
+        let (run, customers, corpus, objectives, executions, speed) = if pizza_is_served() {
+            (
+                "time to bake",
+                "customers",
+                "pizzas",
+                "deliveries",
+                "doughs",
+                "p/s",
+            )
+        } else {
+            (
+                "run time",
+                "clients",
+                "corpus",
+                "objectives",
+                "executions",
+                "exec/sec",
+            )
+        };
         println!(
-            "[{} #{}] run time: {}, clients: {}, corpus: {}, objectives: {}, executions: {}, exec/sec: {}, {}",
+            "[{} #{}] {}: {}, {}: {}, {}: {}, {}: {}, {}: {}, {}: {}, {}",
             event_msg,
             sender_id.0,
+            run,
             global_stats.run_time_pretty,
+            customers,
             global_stats.client_stats_count,
+            corpus,
             global_stats.corpus_size,
+            objectives,
             global_stats.objective_size,
+            executions,
             global_stats.total_execs,
+            speed,
             global_stats.execs_per_sec_pretty,
             userstats.join(", ")
         );
@@ -175,15 +236,40 @@ where
         sender_id: ClientId,
     ) -> Result<(), Error> {
         let global_stats = client_stats_manager.global_stats();
+        let (run, customers, corpus, objectives, executions, speed) = if pizza_is_served() {
+            (
+                "time to bake",
+                "customers",
+                "pizzas",
+                "deliveries",
+                "doughs",
+                "p/s",
+            )
+        } else {
+            (
+                "run time",
+                "clients",
+                "corpus",
+                "objectives",
+                "executions",
+                "exec/sec",
+            )
+        };
         let mut fmt = format!(
-            "[{} #{}] run time: {}, clients: {}, corpus: {}, objectives: {}, executions: {}, exec/sec: {}",
+            "[{} #{}] {}: {}, {}: {}, {}: {}, {}: {}, {}: {}, {}: {}",
             event_msg,
             sender_id.0,
+            run,
             global_stats.run_time_pretty,
+            customers,
             global_stats.client_stats_count,
+            corpus,
             global_stats.corpus_size,
+            objectives,
             global_stats.objective_size,
+            executions,
             global_stats.total_execs,
+            speed,
             global_stats.execs_per_sec_pretty
         );
 
@@ -309,4 +395,18 @@ mod test {
         );
         let _ = mgr_list.display(&mut client_stats, "test", ClientId(0));
     }
+
+    #[test]
+    #[cfg(feature = "std")]
+    fn test_pizza_mode() {
+        let _ = super::pizza_is_served();
+    }
+
+    #[test]
+    #[cfg(feature = "std")]
+    fn test_multi_monitor_pizza_mode() {
+        use std::{cell::RefCell, string::String};
+        let output = RefCell::new(String::new());
+        let _monitor = super::MultiMonitor::new(|s| output.borrow_mut().push_str(s));
+    }
 }

crates/libafl/src/monitors/multi.rs

@@ -1,10 +1,7 @@
 //! The [`MultiMonitor`] displays both cumulative and per-client stats.
 
 use alloc::string::String;
-use core::{
-    fmt::{Debug, Formatter, Write},
-    time::Duration,
-};
+use core::fmt::{Debug, Formatter, Write};
 
 use libafl_bolts::{ClientId, Error, current_time};
 
@@ -17,6 +14,7 @@ where
     F: FnMut(&str),
 {
     print_fn: F,
+    pizza_mode: bool,
 }
 
 impl<F> Debug for MultiMonitor<F>
@@ -46,16 +44,29 @@ where
         };
         let head = format!("{event_msg}{pad} {sender}");
         let global_stats = client_stats_manager.global_stats();
-        let mut global_fmt = format!(
-            "[{}]  (GLOBAL) run time: {}, clients: {}, corpus: {}, objectives: {}, executions: {}, exec/sec: {}",
-            head,
-            global_stats.run_time_pretty,
-            global_stats.client_stats_count,
-            global_stats.corpus_size,
-            global_stats.objective_size,
-            global_stats.total_execs,
-            global_stats.execs_per_sec_pretty
-        );
+        let mut global_fmt = if self.pizza_mode {
+            format!(
+                "[{}]  (GLOBAL) time to bake: {}, customers: {}, pizzas: {}, deliveries: {}, doughs: {}, p/s: {}, Pineapple pizzas: 0",
+                head,
+                global_stats.run_time_pretty,
+                global_stats.client_stats_count,
+                global_stats.corpus_size,
+                global_stats.objective_size,
+                global_stats.total_execs,
+                global_stats.execs_per_sec_pretty
+            )
+        } else {
+            format!(
+                "[{}]  (GLOBAL) run time: {}, clients: {}, corpus: {}, objectives: {}, executions: {}, exec/sec: {}",
+                head,
+                global_stats.run_time_pretty,
+                global_stats.client_stats_count,
+                global_stats.corpus_size,
+                global_stats.objective_size,
+                global_stats.total_execs,
+                global_stats.execs_per_sec_pretty
+            )
+        };
         for (key, val) in client_stats_manager.aggregated() {
             write!(global_fmt, ", {key}: {val}").unwrap();
         }
@@ -64,19 +75,29 @@ where
 
         client_stats_manager.client_stats_insert(sender_id)?;
         let cur_time = current_time();
-        let exec_sec = client_stats_manager
+        let exec_sec_val = client_stats_manager
             .update_client_stats_for(sender_id, |client| client.execs_per_sec_pretty(cur_time))?;
         let client = client_stats_manager.client_stats_for(sender_id)?;
 
-        let pad = " ".repeat(head.len());
-        let mut fmt = format!(
-            " {}   (CLIENT) corpus: {}, objectives: {}, executions: {}, exec/sec: {}",
-            pad,
-            client.corpus_size(),
-            client.objective_size(),
-            client.executions(),
-            exec_sec
-        );
+        let mut fmt = if self.pizza_mode {
+            format!(
+                " {}   (CUSTOMER) pizzas: {}, deliveries: {}, doughs: {}, p/s: {}",
+                pad,
+                client.corpus_size(),
+                client.objective_size(),
+                client.executions(),
+                exec_sec_val
+            )
+        } else {
+            format!(
+                " {}   (CLIENT) corpus: {}, objectives: {}, executions: {}, exec/sec: {}",
+                pad,
+                client.corpus_size(),
+                client.objective_size(),
+                client.executions(),
+                exec_sec_val
+            )
+        };
         for (key, val) in client.user_stats() {
             write!(fmt, ", {key}: {val}").unwrap();
         }
@@ -87,12 +108,29 @@ where
         {
             // Print the client performance monitor. Skip clients with no introspection data
             // (e.g., broker that never fuzzes will have elapsed_cycles == 0)
+            let client_header = if self.pizza_mode {
+                "Customer"
+            } else {
+                "Client"
+            };
+            let cycles_label = if self.pizza_mode {
+                "pizzas baked"
+            } else {
+                "cycles"
+            };
             for (client_id, client) in client_stats_manager
                 .client_stats()
                 .iter()
                 .filter(|(_, x)| x.enabled() && x.introspection_stats.elapsed_cycles() > 0)
             {
-                let fmt = format!("Client {:03}:\n{}", client_id.0, client.introspection_stats);
+                let fmt = format!(
+                    "{} {:03}:\n{} {}: {}",
+                    client_header,
+                    client_id.0,
+                    client.introspection_stats,
+                    cycles_label,
+                    client.executions()
+                );
                 (self.print_fn)(&fmt);
             }
 
@@ -109,15 +147,14 @@ where
 {
     /// Creates the monitor, using the `current_time` as `start_time`.
     pub fn new(print_fn: F) -> Self {
-        Self { print_fn }
+        Self {
+            print_fn,
+            pizza_mode: crate::monitors::pizza_is_served(),
+        }
     }
 
-    /// Creates the monitor with a given `start_time`.
-    #[deprecated(
-        since = "0.16.0",
-        note = "Please use new to create. start_time is useless here."
-    )]
-    pub fn with_time(print_fn: F, _start_time: Duration) -> Self {
-        Self::new(print_fn)
+    /// Adds pineapple.
+    pub fn add_pineapple(&mut self) {
+        self.pizza_mode = false;
     }
 }