Construct PspSoftFuseChain bitfield from serde input and/or serialize to serde.

ahib-config/src/lib.rs

@@ -8,7 +8,7 @@ use amd_efs::flash::Location;
 use amd_efs::{
     AddressMode, ComboDirectoryEntryFilter, EfhBulldozerSpiMode,
     EfhEspiConfiguration, EfhNaplesSpiMode, EfhRomeSpiMode,
-    ProcessorGeneration,
+    ProcessorGeneration, PspSoftFuseChain,
 };
 use amd_efs::{
     BhdDirectoryEntry, BhdDirectoryEntryRegionType, BhdDirectoryEntryType,
@@ -30,6 +30,8 @@ pub enum Error {
     Io(std::io::Error),
     #[error("image too big")]
     ImageTooBig,
+    #[error("psp entry source {0} unknown")]
+    PspEntrySourceUnknown(PspDirectoryEntryType),
 }
 
 impl From<amd_efs::Error> for Error {
@@ -106,11 +108,125 @@ impl TryFromSerdeDirectoryEntryWithContext<SerdePspDirectoryEntry>
     }
 }
 
+#[derive(Clone, serde::Serialize, schemars::JsonSchema)]
+#[serde(rename = "SerdePspEntrySourceValue")]
+#[serde(deny_unknown_fields)]
+#[non_exhaustive]
+pub enum SerdePspEntrySourceValue {
+    PspSoftFuseChain(PspSoftFuseChain),
+    #[serde(deserialize_with = "deserialize_raw")]
+    Unknown(u64),
+}
+
+impl<'de> serde::de::Deserialize<'de> for SerdePspEntrySourceValue {
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::de::Deserializer<'de>,
+    {
+        struct PspVisitor;
+
+        impl<'de> serde::de::Visitor<'de> for PspVisitor {
+            type Value = SerdePspEntrySourceValue;
+
+            fn expecting(
+                &self,
+                formatter: &mut std::fmt::Formatter,
+            ) -> std::fmt::Result {
+                formatter
+                    .write_str("a u64 or a SerdePspEntrySourceValue variant")
+            }
+
+            fn visit_u64<E>(
+                self,
+                value: u64,
+            ) -> std::result::Result<Self::Value, E>
+            where
+                E: serde::de::Error,
+            {
+                Ok(SerdePspEntrySourceValue::Unknown(value))
+            }
+
+            fn visit_i64<E>(
+                self,
+                value: i64,
+            ) -> std::result::Result<Self::Value, E>
+            where
+                E: serde::de::Error,
+            {
+                if value >= 0 {
+                    Ok(SerdePspEntrySourceValue::Unknown(value as u64))
+                } else {
+                    Err(E::invalid_value(
+                        serde::de::Unexpected::Signed(value),
+                        &"a positive integer or SerdePspEntrySourceValue variant",
+                    ))
+                }
+            }
+
+            fn visit_map<A>(
+                self,
+                mut map: A,
+            ) -> std::result::Result<Self::Value, A::Error>
+            where
+                A: serde::de::MapAccess<'de>,
+            {
+                if let Some(key) = map.next_key::<String>()? {
+                    match key.as_str() {
+                        "PspSoftFuseChain" => {
+                            Ok(SerdePspEntrySourceValue::PspSoftFuseChain(
+                                map.next_value::<PspSoftFuseChain>()?,
+                            ))
+                        }
+                        _ => Err(serde::de::Error::custom(
+                            "expected SerdePspEntrySourceValue variant",
+                        )),
+                    }
+                } else {
+                    Err(serde::de::Error::custom(
+                        "expected SerdePspEntrySourceValue variant",
+                    ))
+                }
+            }
+        }
+
+        deserializer.deserialize_any(PspVisitor)
+    }
+}
+
+impl SerdePspEntrySourceValue {
+    pub fn from_u64(value: u64, typ: PspDirectoryEntryType) -> Self {
+        match typ {
+            PspDirectoryEntryType::PspSoftFuseChain => {
+                Self::PspSoftFuseChain(PspSoftFuseChain::from(value))
+            }
+            _ => SerdePspEntrySourceValue::Unknown(value),
+        }
+    }
+
+    pub fn to_u64(
+        &self,
+        typ_or_err: std::result::Result<PspDirectoryEntryType, amd_efs::Error>,
+    ) -> Result<u64> {
+        if let SerdePspEntrySourceValue::Unknown(x) = self {
+            Ok(*x)
+        } else {
+            let typ = typ_or_err.unwrap();
+            match typ {
+                PspDirectoryEntryType::PspSoftFuseChain => match self {
+                    Self::PspSoftFuseChain(x) => Ok(u64::from(*x)),
+                    _ => Err(Error::PspEntrySourceUnknown(typ)),
+                },
+                _ => Err(Error::PspEntrySourceUnknown(typ)),
+            }
+        }
+    }
+}
+
 #[derive(Clone, serde::Serialize, serde::Deserialize, schemars::JsonSchema)]
 #[serde(rename = "PspEntrySource")]
 #[serde(deny_unknown_fields)]
 pub enum SerdePspEntrySource {
-    Value(u64),
+    Value(SerdePspEntrySourceValue),
     BlobFile(PathBuf),
     SecondLevelDirectory(SerdePspDirectory),
 }

src/main.rs

@@ -6,6 +6,7 @@
     ProcessorGeneration, PspDirectory, PspDirectoryEntry,
     PspDirectoryEntryType, PspDirectoryHeader, ValueOrLocation,
 };
+use amd_host_image_builder_config::SerdePspEntrySourceValue;
 use amd_host_image_builder_config::{
     Error, Result, SerdeBhdDirectory, SerdeBhdDirectoryEntry,
     SerdeBhdDirectoryEntryAttrs, SerdeBhdDirectoryEntryBlob,
@@ -56,6 +57,53 @@
     assert_eq!(result.address_mode(), AddressMode::PhysicalAddress);
 }
 
+#[test]
+fn test_valid_compat_serde_psp_entry_source_value_deserialization() {
+    let json = "16"; //     force_security_policy_loading_even_if_insecure
+    let result =
+        serde_json::from_str::<SerdePspEntrySourceValue>(json).unwrap();
+    if let SerdePspEntrySourceValue::Unknown(x) = result {
+        assert_eq!(x, 16);
+    } else {
+        panic!("got the wrong SerdePspEntrySourceValue variant")
+    }
+}
+
+#[test]
+fn test_valid_serde_psp_entry_source_value_deserialization() {
+    use amd_efs::PspSoftFuseChain32MiBSpiDecoding;
+    use amd_efs::PspSoftFuseChainPostCodeDecoding;
+    let json = r#"{"PspSoftFuseChain": {"early_secure_debug_unlock": true, "spi_decoding": "UpperHalf", "postcode_decoding": "Lpc"}}"#;
+    let result =
+        serde_json::from_str::<SerdePspEntrySourceValue>(json).unwrap();
+    if let SerdePspEntrySourceValue::PspSoftFuseChain(x) = result {
+        assert_eq!(
+            x.spi_decoding(),
+            PspSoftFuseChain32MiBSpiDecoding::UpperHalf
+        );
+        assert_eq!(
+            x.postcode_decoding(),
+            PspSoftFuseChainPostCodeDecoding::Lpc
+        );
+        assert!(x.early_secure_debug_unlock());
+        assert!(!x.force_recovery_booting());
+    } else {
+        panic!("got the wrong SerdePspEntrySourceValue variant")
+    }
+}
+
+#[test]
+fn test_invalid_string_deserialization() {
+    let json = r#""x""#;
+    assert!(serde_json::from_str::<SerdePspEntrySourceValue>(json).is_err());
+}
+
+#[test]
+fn test_invalid_wrong_key_name() {
+    let json = r#"{"WrongName": {"some": "data"}}"#;
+    assert!(serde_json::from_str::<SerdePspEntrySourceValue>(json).is_err());
+}
+
 mod hole;
 use hole::Hole;
 
@@ -365,10 +413,10 @@
 ) -> std::io::Result<(PspDirectory, ErasableRange, Option<ErasableLocation>)> {
     let filename = output_filename;
     let efs_to_io_error = |e| {
         std::io::Error::new(
             std::io::ErrorKind::Other,
             format!("EFS error: {e:?} in file {filename:?}"),
         )
     };
 
     let mut first_payload_range_beginning: Option<ErasableLocation> = None;
@@ -475,10 +523,10 @@
 ) -> std::io::Result<(BhdDirectory, ErasableRange, Option<ErasableLocation>)> {
     let filename = output_filename;
     let efs_to_io_error = |e| {
         std::io::Error::new(
             std::io::ErrorKind::Other,
             format!("EFS error: {e:?} in file {filename:?}"),
         )
     };
 
     let mut first_payload_range_beginning: Option<ErasableLocation> = None;
@@ -622,7 +670,7 @@
     // TODO: Handle the other variant (PspComboDirectory)
     let mut blob_dump_filenames = HashSet::<PathBuf>::new();
     SerdePspDirectoryVariant::PspDirectory(SerdePspDirectory {
-        entries: psp_directory.entries().map_while(|e| {
+        entries: psp_directory.entries().map_while(|e| -> Option<SerdePspEntry> {
         if let Ok(typ) = e.typ_or_err() {
             match typ {
                 PspDirectoryEntryType::SecondLevelDirectory => {
@@ -684,7 +732,7 @@
                     }
                     None => {
                         let value = e.value().unwrap();
-                        SerdePspEntrySource::Value(value)
+                        SerdePspEntrySource::Value(SerdePspEntrySourceValue::from_u64(value, typ))
                     }
                 },
                 target: SerdePspDirectoryEntry {
@@ -1096,7 +1144,7 @@
                     SerdePspEntrySource::Value(x) => {
                         // FIXME: assert!(blob_slot_settings.is_none()); fails for some reason
                         // DirectoryRelativeOffset is the one that can always be overridden
-                        raw_entry.set_source(AddressMode::DirectoryRelativeOffset, ValueOrLocation::Value(x)).unwrap();
+                        raw_entry.set_source(AddressMode::DirectoryRelativeOffset, ValueOrLocation::Value(x.to_u64(raw_entry.typ_or_err()).unwrap())).unwrap();
                         vec![(raw_entry, None, None)]
                     }
                     SerdePspEntrySource::BlobFile(
@@ -1210,13 +1258,13 @@
 ) -> BhdDirectoryContents<'a> {
     let mut custom_bios_reset_entry: bool = false;
     let apcb_to_io_error = |e| {
         std::io::Error::new(
             std::io::ErrorKind::Other,
             format!(
                 "APCB error: {e:?} in file {:?}",
                 efs_configuration_filename
             ),
         )
     };
     let bhd_directory_address_mode = AddressMode::EfsRelativeOffset;
     let mut custom_apob = Option::<u64>::None;
@@ -1321,42 +1369,42 @@
 ) -> std::io::Result<()> {
     let filename = output_filename;
     let flash_to_io_error = |e: amd_efs::flash::Error| {
         std::io::Error::new(
             std::io::ErrorKind::Other,
             format!("Flash error: {e:?} in file {filename:?}"),
         )
     };
     let efs_to_io_error = |e: amd_efs::Error| {
         std::io::Error::new(
             std::io::ErrorKind::Other,
             format!(
                 "Config error: {e:?} in file {:?}",
                 efs_configuration_filename
             ),
         )
     };
     let json5_to_io_error = |e: json5::Error| match e {
         json5::Error::Message { ref msg, ref location } => std::io::Error::new(
             std::io::ErrorKind::Other,
             format!(
                 "JSON5 error: {msg} in file {:?} at {}",
                 efs_configuration_filename,
                 match location {
                     None => "unknown location".to_owned(),
                     Some(x) => format!("{x:?}"),
                 }
             ),
         ),
     };
     let amd_host_image_builder_config_error_to_io_error =
         |e: amd_host_image_builder_config::Error| {
             std::io::Error::new(
                 std::io::ErrorKind::Other,
                 format!(
                     "Config error: {e:?} in file {:?}",
                     reset_image_filename
                 ),
             )
         };
     let blobdirs = &blobdirs;
     let resolve_blob = |blob_filename: PathBuf| -> std::io::Result<PathBuf> {
@@ -1364,12 +1412,12 @@
             if blob_filename.exists() {
                 Ok(blob_filename)
             } else {
                 Err(std::io::Error::new(
                     std::io::ErrorKind::Other,
                     format!(
                         "Blob read error: Could not find file {blob_filename:?}",
                     ),
                 ))
             }
         } else {
             for blobdir in blobdirs {
@@ -1381,13 +1429,13 @@
                     return Ok(fullname);
                 }
             }
             Err(std::io::Error::new(
                 std::io::ErrorKind::Other,
                 format!(
                     "Blob read error: Could not find file {blob_filename:?} \
 (neither directly nor in any of the directories {blobdirs:?})",
                 ),
             ))
         }
     };