Include all loader errors when failing

src/agent/dynamic-library/src/bin/dynamic-library.rs

@@ -38,31 +38,35 @@ fn main() -> Result<()> {
         cmd.env("LD_LIBRARY_PATH", path);
     }
 
-    let missing = find_missing(cmd)?;
+    let (missing, errors) = find_missing(cmd)?;
 
     if missing.is_empty() {
         println!("no missing libraries");
     } else {
         for lib in missing {
             println!("missing library: {lib:x?}");
         }
+
+        if !errors.is_empty() {
+            println!();
+
+            for err in errors {
+                println!("error: {err}");
+            }
+        }
     }
 
     Ok(())
 }
 
 #[cfg(target_os = "linux")]
-fn find_missing(cmd: Command) -> Result<Vec<String>> {
-    Ok(dynamic_library::linux::find_missing(cmd)?
-        .drain()
-        .map(|m| m.name)
-        .collect())
+fn find_missing(cmd: Command) -> Result<(Vec<String>, Vec<String>)> {
+    let (missing, errors) = dynamic_library::linux::find_missing(cmd)?;
+    Ok((missing.into_iter().map(|m| m.name).collect(), errors))
 }
 
 #[cfg(target_os = "windows")]
-fn find_missing(cmd: Command) -> Result<Vec<String>> {
-    Ok(dynamic_library::windows::find_missing(cmd)?
-        .into_iter()
-        .map(|m| m.name)
-        .collect())
+fn find_missing(cmd: Command) -> Result<(Vec<String>, Vec<String>)> {
+    let (missing, errors) = dynamic_library::windows::find_missing(cmd)?;
+    Ok((missing.into_iter().map(|m| m.name).collect(), errors))
 }

src/agent/dynamic-library/src/linux.rs

@@ -13,7 +13,9 @@ use regex::Regex;
 
 const LD_LIBRARY_PATH: &str = "LD_LIBRARY_PATH";
 
-pub fn find_missing(mut cmd: Command) -> Result<HashSet<MissingDynamicLibrary>, io::Error> {
+pub fn find_missing(
+    mut cmd: Command,
+) -> Result<(HashSet<MissingDynamicLibrary>, Vec<String>), io::Error> {
     // Check for missing _linked_ dynamic libraries.
     //
     // We must do this first to avoid false positives or negatives when parsing `LD_DEBUG`
@@ -24,7 +26,7 @@ pub fn find_missing(mut cmd: Command) -> Result<HashSet<MissingDynamicLibrary>,
     let missing_linked = linked.not_found();
 
     if !missing_linked.is_empty() {
-        return Ok(missing_linked);
+        return Ok((missing_linked, Vec::new()));
     }
 
     // Check for missing _loaded_ dynamic libraries.
@@ -34,7 +36,7 @@ pub fn find_missing(mut cmd: Command) -> Result<HashSet<MissingDynamicLibrary>,
     let output = cmd.output()?;
     let logs = LdDebugLogs::parse(&*output.stderr);
 
-    Ok(logs.missing())
+    Ok((logs.missing(), Vec::new()))
 }
 
 pub fn get_linked_library_logs(cmd: &Command) -> Result<std::process::Output, io::Error> {

src/agent/dynamic-library/src/windows.rs

@@ -26,10 +26,10 @@ pub enum CheckDynamicLibrariesError {
 
 pub fn find_missing(
     cmd: Command,
-) -> Result<Vec<MissingDynamicLibrary>, CheckDynamicLibrariesError> {
+) -> Result<(Vec<MissingDynamicLibrary>, Vec<String>), CheckDynamicLibrariesError> {
     let mut handler = LoaderSnapsHandler::default();
     setup_debugger(cmd, &mut handler)?;
-    Ok(handler.missing_libraries())
+    Ok((handler.missing_libraries(), handler.errors()))
 }
 
 pub fn get_logs(cmd: Command) -> Result<Vec<String>, CheckDynamicLibrariesError> {
@@ -273,6 +273,14 @@ impl LoaderSnapsHandler {
 
         missing
     }
+
+    pub fn errors(&self) -> Vec<String> {
+        self.debug_strings
+            .iter()
+            .filter(|text| text.contains("ERROR:"))
+            .map(|text| text.to_owned())
+            .collect()
+    }
 }
 
 impl DebugEventHandler for LoaderSnapsHandler {

src/agent/onefuzz/src/libfuzzer.rs

@@ -306,25 +306,26 @@ impl LibFuzzer {
         if !result.status.success() {
             // To provide user-actionable errors, try to identify any missing shared libraries.
             match self.find_missing_libraries().await {
-                Ok(missing) => {
+                Ok((missing, errors)) => {
                     if missing.is_empty() {
-                        bail!("fuzzer does not respond to '-help=1'. no missing shared libraries detected. output: {:?}", result);
+                        bail!("fuzzer does not respond to '-help=1'. no missing shared libraries detected. output: {result:?}");
                     } else {
                         let missing = missing.join(", ");
+                        let all_errors = errors.join("\n");
 
-                        bail!("fuzzer does not respond to '-help=1'. missing shared libraries: {}. output: {:?}", missing, result);
+                        bail!("fuzzer does not respond to '-help=1'. missing shared libraries: {missing}. output: {result:?}. all errors: {all_errors}");
                     }
                 }
                 Err(err) => {
-                    bail!("fuzzer does not respond to '-help=1'. additional error while checking for missing shared libraries: {}. output: {:?}", err, result);
+                    bail!("fuzzer does not respond to '-help=1'. additional error while checking for missing shared libraries: {err}. output: {result:?}");
                 }
             }
         }
 
         Ok(())
     }
 
-    async fn find_missing_libraries(&self) -> Result<Vec<String>> {
+    async fn find_missing_libraries(&self) -> Result<(Vec<String>, Vec<String>)> {
         let cmd = self.build_std_command(None, None, None, None, None)?;
 
         #[cfg(target_os = "linux")]
@@ -333,10 +334,11 @@ impl LibFuzzer {
         #[cfg(target_os = "windows")]
         let blocking = move || dynamic_library::windows::find_missing(cmd);
 
-        let missing = tokio::task::spawn_blocking(blocking).await??;
+        let (missing, errors) = tokio::task::spawn_blocking(blocking).await??;
+
         let missing = missing.into_iter().map(|m| m.name).collect();
 
-        Ok(missing)
+        Ok((missing, errors))
     }
 
     pub fn fuzz(