Avoid using feature flags and env variable to set the same parameter pt.1 emulation_mode (#2512)

* Remove emulation_mode env variable and custom cfg

* Using only the feature flag simplifies things a bit and allow the usage of optional dependencies

* Do not use --all-features on libafl_qemu

* Add missing target_os = "linux"

Author: Marcondiro

.github/workflows/build_and_test.yml

@@ -130,7 +130,7 @@ jobs:
       - uses: Swatinem/rust-cache@v2
         with: { shared-key: "ubuntu" }
       - name: Run clippy
-        run: ./scripts/clippy.sh
+        run: LLVM_CONFIG=llvm-config-${{env.MAIN_LLVM_VERSION}} ./scripts/clippy.sh
     # --- test embedding the libafl_libfuzzer_runtime library
     # Fix me plz
     # - name: Test Build libafl_libfuzzer with embed

fuzzers/full_system/qemu_baremetal/Cargo.toml

@@ -32,12 +32,7 @@ libafl_targets = { path = "../../../libafl_targets" }
 libafl_qemu = { path = "../../../libafl_qemu", features = [
   "arm",
   "systemmode",
-] }
-libafl_qemu_sys = { path = "../../../libafl_qemu/libafl_qemu_sys", features = [
-  "arm",
-  "systemmode",
-] }
-
+], default-features = false }
 env_logger = "0.11.5"
 log = { version = "0.4.22", features = ["release_max_level_info"] }
 

fuzzers/full_system/qemu_baremetal/src/fuzzer_low_level.rs

@@ -30,9 +30,9 @@ use libafl_bolts::{
 };
 use libafl_qemu::{
     config, elf::EasyElf, executor::QemuExecutor, modules::edges::StdEdgeCoverageModuleBuilder,
-    Emulator, Qemu, QemuExitError, QemuExitReason, QemuRWError, QemuShutdownCause, Regs,
+    Emulator, GuestPhysAddr, Qemu, QemuExitError, QemuExitReason, QemuRWError, QemuShutdownCause,
+    Regs,
 };
-use libafl_qemu_sys::GuestPhysAddr;
 use libafl_targets::{edges_map_mut_ptr, EDGES_MAP_DEFAULT_SIZE, MAX_EDGES_FOUND};
 
 pub static mut MAX_INPUT_SIZE: usize = 50;

libafl_qemu/Cargo.toml

@@ -23,6 +23,7 @@ rustdoc-args = ["--cfg", "docsrs"]
 
 [features]
 default = [
+  "usermode",
   "fork",
   "build_libgasan",
   "build_libqasan",
@@ -95,7 +96,7 @@ libafl_bolts = { path = "../libafl_bolts", version = "0.13.2", default-features
   "derive",
 ] }
 libafl_targets = { path = "../libafl_targets", version = "0.13.2" }
-libafl_qemu_sys = { path = "./libafl_qemu_sys", version = "0.13.2" }
+libafl_qemu_sys = { path = "./libafl_qemu_sys", version = "0.13.2", default-features = false }
 libafl_derive = { path = "../libafl_derive", version = "0.13.2" }
 
 serde = { workspace = true, default-features = false, features = [

libafl_qemu/build.rs

@@ -4,8 +4,6 @@ mod host_specific {
 
     #[cfg(not(target_os = "linux"))]
     pub fn build() {
-        // Print a emulation_mode to silence clippy's unexpected cfg on macOS
-        println!("cargo:rustc-cfg=emulation_mode=\"usermode\"");
         println!("cargo:warning=libafl_qemu only builds on Linux hosts");
     }
 }

libafl_qemu/build_linux.rs

@@ -16,17 +16,19 @@ void __libafl_qemu_testfile() {}
 #[allow(clippy::too_many_lines)]
 pub fn build() {
     // Note: Unique features are checked in libafl_qemu_sys
-    println!(r#"cargo::rustc-check-cfg=cfg(emulation_mode, values("usermode", "systemmode"))"#);
     println!(
         r#"cargo::rustc-check-cfg=cfg(cpu_target, values("arm", "aarch64", "hexagon", "i386", "mips", "ppc", "x86_64"))"#
     );
 
     let emulation_mode = if cfg!(feature = "usermode") {
-        "usermode".to_string()
+        "usermode"
     } else if cfg!(feature = "systemmode") {
-        "systemmode".to_string()
+        "systemmode"
     } else {
-        env::var("EMULATION_MODE").unwrap_or_else(|_| "usermode".to_string())
+        unreachable!(
+            "The macros `assert_unique_feature` and `assert_at_least_one_feature` in \
+            `libafl_qemu_sys/build_linux.rs` should panic before this code is reached."
+        );
     };
 
     let src_dir = env::var("CARGO_MANIFEST_DIR").unwrap();
@@ -57,23 +59,23 @@ pub fn build() {
     let libafl_qemu_impl_hdr = libafl_runtime_dir.join(libafl_qemu_impl_hdr_name);
 
     let libafl_runtime_testfile = out_dir.join("runtime_test.c");
-    fs::write(&libafl_runtime_testfile, LIBAFL_QEMU_RUNTIME_TEST).expect("Could not write runtime test file");
+    fs::write(&libafl_runtime_testfile, LIBAFL_QEMU_RUNTIME_TEST)
+        .expect("Could not write runtime test file");
 
     let mut runtime_test_cc_compiler = cc::Build::new();
 
-    runtime_test_cc_compiler.cpp(false)
+    runtime_test_cc_compiler
+        .cpp(false)
         .include(&libafl_runtime_dir)
         .file(&libafl_runtime_testfile);
 
-    runtime_test_cc_compiler.try_compile("runtime_test").unwrap();
+    runtime_test_cc_compiler
+        .try_compile("runtime_test")
+        .unwrap();
 
     let runtime_bindings_file = out_dir.join("libafl_qemu_bindings.rs");
     let stub_runtime_bindings_file = src_dir.join("runtime/libafl_qemu_stub_bindings.rs");
 
-    println!("cargo::rustc-check-cfg=cfg(emulation_mode, values(\"usermode\", \"systemmode\"))");
-    println!("cargo:rustc-cfg=emulation_mode=\"{emulation_mode}\"");
-    println!("cargo:rerun-if-env-changed=EMULATION_MODE");
-
     println!("cargo:rerun-if-changed=build.rs");
     println!("cargo:rerun-if-changed=build_linux.rs");
     println!("cargo:rerun-if-changed={}", libafl_runtime_dir.display());
@@ -99,7 +101,7 @@ pub fn build() {
     println!("cargo:rustc-cfg=cpu_target=\"{cpu_target}\"");
     println!("cargo::rustc-check-cfg=cfg(cpu_target, values(\"x86_64\", \"arm\", \"aarch64\", \"i386\", \"mips\", \"ppc\", \"hexagon\"))");
 
-    let cross_cc = if (emulation_mode == "usermode") && (qemu_asan || qemu_asan_guest) {
+    let cross_cc = if cfg!(feature = "usermode") && (qemu_asan || qemu_asan_guest) {
         // TODO try to autodetect a cross compiler with the arch name (e.g. aarch64-linux-gnu-gcc)
         let cross_cc = env::var("CROSS_CC").unwrap_or_else(|_| {
             println!("cargo:warning=CROSS_CC is not set, default to cc (things can go wrong if the selected cpu target ({cpu_target}) is not the host arch ({}))", env::consts::ARCH);
@@ -162,12 +164,12 @@ pub fn build() {
 
     maybe_generate_stub_bindings(
         &cpu_target,
-        &emulation_mode,
+        emulation_mode,
         stub_runtime_bindings_file.as_path(),
-        runtime_bindings_file.as_path()
+        runtime_bindings_file.as_path(),
     );
 
-    if (emulation_mode == "usermode") && (qemu_asan || qemu_asan_guest) {
+    if cfg!(feature = "usermode") && (qemu_asan || qemu_asan_guest) {
         let qasan_dir = Path::new("libqasan");
         let qasan_dir = fs::canonicalize(qasan_dir).unwrap();
         println!("cargo:rerun-if-changed={}", qasan_dir.display());

libafl_qemu/libafl_qemu_sys/Cargo.toml

@@ -23,8 +23,10 @@ features = ["x86_64", "usermode"]
 rustdoc-args = ["--cfg", "docsrs"]
 
 [features]
+default = ["usermode", "x86_64"]
+
 # The following architecture features are mutually exclusive.
-x86_64 = []  # build qemu for x86_64 (default)
+x86_64 = []  # build qemu for x86_64
 i386 = []    # build qemu for i386
 arm = []     # build qemu for arm
 aarch64 = [] # build qemu for aarch64

libafl_qemu/libafl_qemu_sys/build_linux.rs

@@ -14,24 +14,30 @@ macro_rules! assert_unique_feature {
     }
 }
 
+#[macro_export]
+macro_rules! assert_at_least_one_feature {
+    ($($feature:literal),+) => {
+        #[cfg(not(any($(feature = $feature),+)))]
+        compile_error!(concat!("At least one of the following features must be enabled:", $(" ", $feature),+));
+    };
+}
+
 pub fn build() {
-    // Make sure that exactly one qemu mode is set
+    // Make sure that at most one qemu mode is set
     assert_unique_feature!("usermode", "systemmode");
+    // Make sure that at least one qemu mode is set
+    assert_at_least_one_feature!("usermode", "systemmode");
+
     let emulation_mode = if cfg!(feature = "usermode") {
-        "usermode".to_string()
+        "usermode"
     } else if cfg!(feature = "systemmode") {
-        "systemmode".to_string()
+        "systemmode"
     } else {
-        env::var("EMULATION_MODE").unwrap_or_else(|_| {
-            println!(
-                "cargo:warning=No emulation mode feature enabled or EMULATION_MODE env specified for libafl_qemu, supported: usermode, systemmmode - defaulting to usermode"
-            );
-            "usermode".to_string()
-        })
+        unreachable!(
+            "The above macros, `assert_unique_feature` and `assert_at_least_one_feature`, should \
+             panic before this code is reached."
+        );
     };
-    println!("cargo::rustc-check-cfg=cfg(emulation_mode, values(\"usermode\", \"systemmode\"))");
-    println!("cargo:rustc-cfg=emulation_mode=\"{emulation_mode}\"");
-    println!("cargo:rerun-if-env-changed=EMULATION_MODE");
 
     // Make sure we have at most one architecutre feature set
     // Else, we default to `x86_64` - having a default makes CI easier :)
@@ -100,7 +106,7 @@ pub fn build() {
     // If the bindings are built and differ from the current stub, replace it with the freshly generated bindings
     maybe_generate_stub_bindings(
         &cpu_target,
-        &emulation_mode,
+        emulation_mode,
         stub_bindings_file.as_path(),
         bindings_file.as_path(),
     );

libafl_qemu/libafl_qemu_sys/src/lib.rs

@@ -17,14 +17,14 @@ use strum_macros::EnumIter;
 mod bindings;
 pub use bindings::*;
 
-#[cfg(emulation_mode = "usermode")]
+#[cfg(feature = "usermode")]
 mod usermode;
-#[cfg(emulation_mode = "usermode")]
+#[cfg(feature = "usermode")]
 pub use usermode::*;
 
-// #[cfg(emulation_mode = "systemmode")]
+// #[cfg(feature = "systemmode")]
 // mod systemmode;
-// #[cfg(emulation_mode = "systemmode")]
+// #[cfg(feature = "systemmode")]
 // pub use systemmode::*;
 
 /// Safe linking with of extern "C" functions.

libafl_qemu/libafl_qemu_sys/src/usermode.rs

@@ -104,6 +104,8 @@ impl IntoPy<PyObject> for MmapPerms {
         n.into_py(py)
     }
 }
+
+#[cfg(target_os = "linux")]
 impl From<libafl_mapinfo> for MapInfo {
     fn from(map_info: libafl_mapinfo) -> Self {
         let path: Option<String> = if map_info.path.is_null() {

libafl_qemu/src/command/mod.rs

@@ -12,7 +12,7 @@ use libafl::{
 };
 use libafl_bolts::AsSlice;
 use libafl_qemu_sys::GuestAddr;
-#[cfg(emulation_mode = "systemmode")]
+#[cfg(feature = "systemmode")]
 use libafl_qemu_sys::GuestPhysAddr;
 use libc::c_uint;
 use num_enum::TryFromPrimitive;
@@ -457,7 +457,7 @@ where
         }
 
         // Auto page filtering if option is enabled
-        #[cfg(emulation_mode = "systemmode")]
+        #[cfg(feature = "systemmode")]
         if emu.driver_mut().allow_page_on_start() {
             if let Some(page_id) = qemu.current_cpu().unwrap().current_paging_id() {
                 emu.modules_mut().modules_mut().allow_page_id_all(page_id);
@@ -566,13 +566,13 @@ where
     }
 }
 
-#[cfg(emulation_mode = "systemmode")]
+#[cfg(feature = "systemmode")]
 #[derive(Debug, Clone)]
 pub struct PageAllowCommand {
     page_id: GuestPhysAddr,
 }
 
-#[cfg(emulation_mode = "systemmode")]
+#[cfg(feature = "systemmode")]
 impl<CM, ED, ET, S, SM> IsCommand<CM, ED, ET, S, SM> for PageAllowCommand
 where
     ET: EmulatorModuleTuple<S>,
@@ -760,7 +760,7 @@ impl Display for AddressAllowCommand {
     }
 }
 
-#[cfg(emulation_mode = "systemmode")]
+#[cfg(feature = "systemmode")]
 impl Display for PageAllowCommand {
     fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
         write!(f, "Allowed page: {:?}", self.page_id)

libafl_qemu/src/emu/builder.rs

@@ -6,7 +6,7 @@ use libafl::{
 };
 use libafl_bolts::tuples::{tuple_list, Prepend};
 
-#[cfg(emulation_mode = "systemmode")]
+#[cfg(feature = "systemmode")]
 use crate::FastSnapshotManager;
 use crate::{
     command::{CommandManager, NopCommandManager, StdCommandManager},
@@ -53,7 +53,7 @@ where
     }
 }
 
-#[cfg(emulation_mode = "usermode")]
+#[cfg(feature = "usermode")]
 impl<S> EmulatorBuilder<StdCommandManager<S>, StdEmulatorDriver, (), S, StdSnapshotManager>
 where
     S: State + HasExecutions + Unpin,
@@ -73,7 +73,7 @@ where
     }
 }
 
-#[cfg(emulation_mode = "systemmode")]
+#[cfg(feature = "systemmode")]
 impl<S> EmulatorBuilder<StdCommandManager<S>, StdEmulatorDriver, (), S, StdSnapshotManager>
 where
     S: State + HasExecutions + Unpin,

libafl_qemu/src/emu/drivers.rs

@@ -117,7 +117,7 @@ pub struct StdEmulatorDriver {
     input_location: OnceCell<InputLocation>,
     #[builder(default = true)]
     hooks_locked: bool,
-    #[cfg(emulation_mode = "systemmode")]
+    #[cfg(feature = "systemmode")]
     #[builder(default = false)]
     allow_page_on_start: bool,
     #[cfg(feature = "x86_64")]
@@ -147,7 +147,7 @@ impl StdEmulatorDriver {
         was_locked
     }
 
-    #[cfg(emulation_mode = "systemmode")]
+    #[cfg(feature = "systemmode")]
     pub fn allow_page_on_start(&self) -> bool {
         self.allow_page_on_start
     }