Improve dump subcommand.

Fixes <#160>.

Author: daym

Cargo.lock

@@ -19,6 +19,7 @@ use std::cmp::min;
 use std::collections::HashSet;
 use std::fs;
 use std::fs::File;
+use std::io::stdout;
 use std::io::BufReader;
 use std::io::Read;
 use std::io::Seek;
@@ -653,6 +654,11 @@ fn dump_bhd_directory<'a, T: FlashRead + FlashWrite>(
             .map_while(|entry| {
                 let entry = entry.clone();
                 if let Ok(typ) = entry.typ_or_err() {
+                    if typ == BhdDirectoryEntryType::Apob {
+                        // Since this is a runtime value we cannot read it
+                        // from the image.
+                        return None;
+                    }
                     let payload_beginning =
                         bhd_directory.payload_beginning(&entry).unwrap();
                     let size = entry.size().unwrap() as usize;
@@ -727,6 +733,7 @@ fn dump_bhd_directory<'a, T: FlashRead + FlashWrite>(
 fn dump(
     image_filename: &Path,
     blob_dump_dirname: Option<PathBuf>,
+    output_config_file: &mut impl std::io::Write,
 ) -> std::io::Result<()> {
     let filename = image_filename;
     let storage = FlashImage::load(filename)?;
@@ -735,25 +742,40 @@ fn dump(
         if filesize <= 0x100_0000 { Some(filesize as u32) } else { None };
     let efs = Efs::load(&storage, None, amd_physical_mode_mmio_size).unwrap();
     if !efs.compatible_with_processor_generation(ProcessorGeneration::Milan) {
-        panic!("only Milan is supported for dumping right now");
+        if !efs.compatible_with_processor_generation(ProcessorGeneration::Rome)
+        {
+            panic!("only Milan or Rome is supported for dumping right now");
+        }
     }
     let mut apcb_buffer = [0xFFu8; Apcb::MAX_SIZE];
     let mut apcb_buffer_option = Some(&mut apcb_buffer[..]);
+    let processor_generation = if efs
+        .compatible_with_processor_generation(ProcessorGeneration::Milan)
+    {
+        ProcessorGeneration::Milan
+    } else {
+        ProcessorGeneration::Rome
+    };
     let config = SerdeConfig {
-        processor_generation: ProcessorGeneration::Milan, // FIXME could be ambiguous
-        spi_mode_bulldozer: efs.spi_mode_bulldozer().unwrap(),
-        spi_mode_zen_naples: efs.spi_mode_zen_naples().unwrap(),
-        spi_mode_zen_rome: efs.spi_mode_zen_rome().unwrap(),
+        processor_generation,
+        spi_mode_bulldozer: efs
+            .spi_mode_bulldozer()
+            .expect("Bulldozer SPI Mode"),
+        spi_mode_zen_naples: efs
+            .spi_mode_zen_naples()
+            .expect("Naples SPI Mode"),
+        spi_mode_zen_rome: efs.spi_mode_zen_rome().expect("Rome SPI Mode"),
         // TODO: psp_directory or psp_combo_directory
         psp: dump_psp_directory(
             &storage,
-            &efs.psp_directory().unwrap(),
+            &efs.psp_directory().expect("PSP directory"),
             &blob_dump_dirname,
         ),
         // TODO: bhd_directory or bhd_combo_directory
         bhd: dump_bhd_directory(
             &storage,
-            &efs.bhd_directory(None).unwrap(),
+            &efs.bhd_directory(Some(processor_generation))
+                .expect("BHD directory"),
             &mut apcb_buffer_option,
             &blob_dump_dirname,
         ),
@@ -766,7 +788,11 @@ fn dump(
         let mut file = File::create(&path).expect("creation failed");
         writeln!(file, "{}", json5::to_string(&config).unwrap())?;
     } else {
-        println!("{}", serde_json::to_string_pretty(&config)?);
+        writeln!(
+            output_config_file,
+            "{}",
+            serde_json::to_string_pretty(&config)?
+        )?;
     }
     Ok(())
 }
@@ -1155,21 +1181,42 @@ fn run() -> std::io::Result<()> {
     };
     match opts {
         Opts::Dump { input_filename, blob_dump_dirname } => {
-            dump(&input_filename, blob_dump_dirname)
+            dump(&input_filename, blob_dump_dirname, &mut stdout().lock())
         }
         Opts::Generate {
             output_filename,
             efs_configuration_filename,
             reset_image_filename,
             blobdirs,
             verbose,
-        } => generate(
-            &output_filename,
-            &efs_configuration_filename,
-            &reset_image_filename,
-            blobdirs,
-            verbose,
-        ),
+        } => {
+            let x = generate(
+                &output_filename,
+                &efs_configuration_filename,
+                &reset_image_filename,
+                blobdirs,
+                verbose,
+            );
+
+            // In order to make sure that we can dump it back out, try it.
+            struct DummyOutput {}
+            impl std::io::Write for DummyOutput {
+                fn write(
+                    &mut self,
+                    buf: &[u8],
+                ) -> std::result::Result<usize, std::io::Error>
+                {
+                    Ok(buf.len())
+                }
+                fn flush(&mut self) -> std::result::Result<(), std::io::Error> {
+                    Ok(())
+                }
+            }
+            let mut dummy_output = DummyOutput {};
+            dump(&output_filename, None, &mut dummy_output)
+                .expect("read it back out from the image");
+            x
+        }
     }
 }