Support dumping Turin data structures and Milan data structures at the same time.

Fixes <#135>.

Author: daym

rust-toolchain

@@ -1,3 +1,3 @@
 [toolchain]
 channel = "nightly-2024-06-19"
-components = [ "rustfmt", "rust-src" ]
+components = [ "rustfmt", "rust-src", "rust-analyzer" ]

src/apcb.rs

@@ -2,7 +2,7 @@
 // License, v. 2.0. If a copy of the MPL was not distributed with this
 // file, You can obtain one at https://mozilla.org/MPL/2.0/.
 
-use crate::types::{Error, FileSystemError, PtrMut, Result};
+use crate::types::{ApcbContext, Error, FileSystemError, PtrMut, Result};
 
 use crate::entry::EntryItemBody;
 use crate::group::{GroupItem, GroupMutItem};
@@ -50,29 +50,41 @@ use std::borrow::Cow;
 #[derive(Clone)]
 pub struct ApcbIoOptions {
     pub check_checksum: bool,
+    pub context: ApcbContext,
 }
 
 impl Default for ApcbIoOptions {
     fn default() -> Self {
-        Self { check_checksum: true }
+        Self { check_checksum: true, context: ApcbContext::default() }
     }
 }
 
 impl ApcbIoOptions {
     pub fn builder() -> Self {
         Self::default()
     }
+    pub fn check_checksum(&self) -> bool {
+        self.check_checksum
+    }
+    pub fn context(&self) -> ApcbContext {
+        self.context
+    }
     pub fn with_check_checksum(&mut self, value: bool) -> &mut Self {
         self.check_checksum = value;
         self
     }
+    pub fn with_context(&mut self, value: ApcbContext) -> &mut Self {
+        self.context = value;
+        self
+    }
     pub fn build(&self) -> Self {
         self.clone()
     }
 }
 
 #[cfg_attr(feature = "std", derive(Clone))]
 pub struct Apcb<'a> {
+    context: ApcbContext,
     used_size: usize,
     pub backing_store: PtrMut<'a, [u8]>,
 }
@@ -83,6 +95,11 @@ pub struct Apcb<'a> {
 #[cfg_attr(feature = "serde", serde(deny_unknown_fields))]
 #[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
 pub struct SerdeApcb {
+    /// This field is out-of-band information. At the cost of slight redundancy
+    /// in user config and another extra field that isn't actually in the blob,
+    /// we can actually handle the out-of-band information quite natually.
+    #[cfg_attr(feature = "serde", serde(default))]
+    pub context: ApcbContext,
     pub version: String,
     pub header: V2_HEADER,
     pub v3_header_ext: Option<V3_HEADER_EXT>,
@@ -110,11 +127,15 @@ impl<'a> schemars::JsonSchema for Apcb<'a> {
 use core::convert::TryFrom;
 
 #[cfg(feature = "serde")]
-impl<'a> TryFrom<SerdeApcb> for Apcb<'a> {
-    type Error = Error;
+impl<'a> Apcb<'a> {
+    //    type Error = Error;
     fn try_from(serde_apcb: SerdeApcb) -> Result<Self> {
         let buf = Cow::from(vec![0xFFu8; Self::MAX_SIZE]);
-        let mut apcb = Apcb::create(buf, 42, &ApcbIoOptions::default())?;
+        let mut apcb = Apcb::create(
+            buf,
+            42,
+            &ApcbIoOptions::default().with_context(serde_apcb.context).build(),
+        )?;
         *apcb.header_mut()? = serde_apcb.header;
         match serde_apcb.v3_header_ext {
             Some(v3) => {
@@ -217,11 +238,13 @@ impl<'de> Deserialize<'de> for Apcb<'_> {
 }
 
 pub struct ApcbIterMut<'a> {
+    context: ApcbContext,
     buf: &'a mut [u8],
     remaining_used_size: usize,
 }
 
 pub struct ApcbIter<'a> {
+    context: ApcbContext,
     buf: &'a [u8],
     remaining_used_size: usize,
 }
@@ -230,7 +253,10 @@ impl<'a> ApcbIterMut<'a> {
     /// It's useful to have some way of NOT mutating self.buf.  This is what
     /// this function does. Note: The caller needs to manually decrease
     /// remaining_used_size for each call if desired.
-    fn next_item<'b>(buf: &mut &'b mut [u8]) -> Result<GroupMutItem<'b>> {
+    fn next_item<'b>(
+        context: ApcbContext,
+        buf: &mut &'b mut [u8],
+    ) -> Result<GroupMutItem<'b>> {
         if buf.is_empty() {
             return Err(Error::FileSystem(
                 FileSystemError::InconsistentHeader,
@@ -256,7 +282,7 @@ impl<'a> ApcbIterMut<'a> {
             ))?;
         let body_len = body.len();
 
-        Ok(GroupMutItem { header, buf: body, used_size: body_len })
+        Ok(GroupMutItem { context, header, buf: body, used_size: body_len })
     }
 
     /// Moves the point to the group with the given GROUP_ID.  Returns (offset,
@@ -273,12 +299,12 @@ impl<'a> ApcbIterMut<'a> {
             if buf.is_empty() {
                 break;
             }
-            let group = ApcbIterMut::next_item(&mut buf)?;
+            let group = ApcbIterMut::next_item(self.context, &mut buf)?;
             let group_size = group.header.group_size.get();
             if group.header.group_id.get() == group_id {
                 return Ok((offset, group_size as usize));
             }
-            let group = ApcbIterMut::next_item(&mut self.buf)?;
+            let group = ApcbIterMut::next_item(self.context, &mut self.buf)?;
             let group_size = group.header.group_size.get() as usize;
             offset = offset
                 .checked_add(group_size)
@@ -295,7 +321,7 @@ impl<'a> ApcbIterMut<'a> {
 
     pub(crate) fn next1(&mut self) -> Result<GroupMutItem<'a>> {
         assert!(self.remaining_used_size != 0, "Internal error");
-        let item = Self::next_item(&mut self.buf)?;
+        let item = Self::next_item(self.context, &mut self.buf)?;
         let group_size = item.header.group_size.get() as usize;
         if group_size <= self.remaining_used_size {
             self.remaining_used_size -= group_size;
@@ -324,7 +350,10 @@ impl<'a> ApcbIter<'a> {
     /// It's useful to have some way of NOT mutating self.buf.  This is what
     /// this function does. Note: The caller needs to manually decrease
     /// remaining_used_size for each call if desired.
-    fn next_item<'b>(buf: &mut &'b [u8]) -> Result<GroupItem<'b>> {
+    fn next_item<'b>(
+        context: ApcbContext,
+        buf: &mut &'b [u8],
+    ) -> Result<GroupItem<'b>> {
         if buf.is_empty() {
             return Err(Error::FileSystem(
                 FileSystemError::InconsistentHeader,
@@ -351,12 +380,12 @@ impl<'a> ApcbIter<'a> {
 
         let body_len = body.len();
 
-        Ok(GroupItem { header, buf: body, used_size: body_len })
+        Ok(GroupItem { context, header, buf: body, used_size: body_len })
     }
 
     pub(crate) fn next1(&mut self) -> Result<GroupItem<'a>> {
         assert!(self.remaining_used_size != 0, "Internal error");
-        let item = Self::next_item(&mut self.buf)?;
+        let item = Self::next_item(self.context, &mut self.buf)?;
         let group_size = item.header.group_size.get() as usize;
         if group_size <= self.remaining_used_size {
             self.remaining_used_size -= group_size;
@@ -369,7 +398,7 @@ impl<'a> ApcbIter<'a> {
         }
     }
     /// Validates the entries (recursively).  Also consumes iterator.
-    pub(crate) fn validate(mut self) -> Result<()> {
+    pub(crate) fn validate(mut self, context: ApcbContext) -> Result<()> {
         while self.remaining_used_size > 0 {
             let item = self.next1()?;
             GroupId::from_u16(item.header.group_id.get()).ok_or(
@@ -509,6 +538,7 @@ impl<'a> Apcb<'a> {
 
     pub fn groups(&self) -> Result<ApcbIter<'_>> {
         Ok(ApcbIter {
+            context: self.context,
             buf: self.beginning_of_groups()?,
             remaining_used_size: self.used_size,
         })
@@ -522,13 +552,14 @@ impl<'a> Apcb<'a> {
     /// If ABL0_VERSION is Some, also validates against that AGESA
     /// bootloader version.
     pub fn validate(&self, abl0_version: Option<u32>) -> Result<()> {
-        self.groups()?.validate()?;
+        self.groups()?.validate(self.context)?;
         self.ensure_abl0_compatibility(abl0_version)
     }
 
     pub fn groups_mut(&mut self) -> Result<ApcbIterMut<'_>> {
         let used_size = self.used_size;
         Ok(ApcbIterMut {
+            context: self.context,
             buf: &mut *self.beginning_of_groups_mut()?,
             remaining_used_size: used_size,
         })
@@ -1030,6 +1061,7 @@ impl<'a> Apcb<'a> {
         signature: [u8; 4],
     ) -> Result<GroupMutItem<'_>> {
         // TODO: insert sorted.
+        let context = self.context;
 
         if !match group_id {
             GroupId::Psp => signature == *b"PSPG",
@@ -1090,7 +1122,7 @@ impl<'a> Apcb<'a> {
             ))?;
         let body_len = body.len();
 
-        Ok(GroupMutItem { header, buf: body, used_size: body_len })
+        Ok(GroupMutItem { context, header, buf: body, used_size: body_len })
     }
 
     pub(crate) fn calculate_checksum(
@@ -1263,9 +1295,11 @@ impl<'a> Apcb<'a> {
                 ));
             }
         }
-        let result = Self { backing_store: bs, used_size };
+        let result =
+            Self { context: options.context(), backing_store: bs, used_size };
 
-        match result.groups()?.validate() {
+        let context = options.context();
+        match result.groups()?.validate(context) {
             Ok(_) => {}
             Err(e) => {
                 return Err(e);

src/entry.rs

@@ -12,7 +12,9 @@ use crate::ondisk::{
 };
 use crate::ondisk::{Parameters, ParametersIter};
 use crate::tokens_entry::TokensEntryBodyItem;
-use crate::types::{Error, FileSystemError, Result};
+use crate::types::{
+    ApcbContext, Error, FileSystemError, MemDfeSearchVersion, Result,
+};
 use core::marker::PhantomData;
 use core::mem::size_of;
 use num_traits::FromPrimitive;
@@ -46,6 +48,7 @@ impl<'a> EntryItemBody<&'a mut [u8]> {
     pub(crate) fn from_slice(
         header: &ENTRY_HEADER,
         b: &'a mut [u8],
+        context: ApcbContext,
     ) -> Result<EntryItemBody<&'a mut [u8]>> {
         let context_type = ContextType::from_u8(header.context_type).ok_or(
             Error::FileSystem(
@@ -66,7 +69,7 @@ impl<'a> EntryItemBody<&'a mut [u8]> {
             ContextType::Tokens => {
                 let used_size = b.len();
                 Ok(Self::Tokens(TokensEntryBodyItem::<&mut [u8]>::new(
-                    header, b, used_size,
+                    header, b, used_size, context,
                 )?))
             }
             ContextType::Parameters => Err(Error::EntryTypeMismatch),
@@ -78,6 +81,7 @@ impl<'a> EntryItemBody<&'a [u8]> {
     pub(crate) fn from_slice(
         header: &ENTRY_HEADER,
         b: &'a [u8],
+        context: ApcbContext,
     ) -> Result<EntryItemBody<&'a [u8]>> {
         let context_type = ContextType::from_u8(header.context_type).ok_or(
             Error::FileSystem(
@@ -98,7 +102,7 @@ impl<'a> EntryItemBody<&'a [u8]> {
             ContextType::Tokens => {
                 let used_size = b.len();
                 Ok(Self::Tokens(TokensEntryBodyItem::<&[u8]>::new(
-                    header, b, used_size,
+                    header, b, used_size, context,
                 )?))
             }
             ContextType::Parameters => Err(Error::EntryTypeMismatch),
@@ -117,6 +121,7 @@ impl<'a> EntryItemBody<&'a [u8]> {
 
 #[derive(Debug)]
 pub struct EntryMutItem<'a> {
+    pub(crate) context: ApcbContext,
     pub(crate) header: &'a mut ENTRY_HEADER,
     pub body: EntryItemBody<&'a mut [u8]>,
 }
@@ -420,6 +425,7 @@ use std::fmt;
 
 #[derive(Clone)]
 pub struct EntryItem<'a> {
+    pub(crate) context: ApcbContext,
     pub(crate) header: &'a ENTRY_HEADER,
     pub body: EntryItemBody<&'a [u8]>,
 }
@@ -677,12 +683,6 @@ impl<'a> Serialize for EntryItem<'a> {
                 } else if let Some(s) = self.body_as_struct_array::<memory::Ddr5CaPinMapElement>() {
                     let v = s.iter().collect::<Vec<_>>();
                     state.serialize_field("Ddr5CaPinMapElement", &v)?;
-//                } else if let Some(s) = self.body_as_struct_array::<memory::MemDfeSearchElement32>() { // UH OH
-//                    let v = s.iter().collect::<Vec<_>>();
-//                    state.serialize_field("MemDfeSearchElement32", &v)?;
-                } else if let Some(s) = self.body_as_struct_array::<memory::MemDfeSearchElement36>() {
-                    let v = s.iter().collect::<Vec<_>>();
-                    state.serialize_field("MemDfeSearchElement36", &v)?;
                 } else if let Some(s) = self.body_as_struct_array::<memory::DdrDqPinMapElement>() {
                     let v = s.iter().collect::<Vec<_>>();
                     state.serialize_field("DdrDqPinMapElement", &v)?;
@@ -747,7 +747,27 @@ self.body_as_struct_sequence::<memory::platform_tuning::ElementRef<'_>>() {
                     let v = parameters.collect::<Vec<_>>();
                     state.serialize_field("parameters", &v)?;
                 } else {
-                    state.serialize_field("struct_body", &buf)?;
+                    match self.context.mem_dfe_search_version() {
+                        Some(MemDfeSearchVersion::Genoa2) => { // UH OH
+                            if let Some(s) = self.body_as_struct_array::<memory::MemDfeSearchElement32>() {
+                                    let v = s.iter().collect::<Vec<_>>();
+                                    state.serialize_field("MemDfeSearchElement32", &v)?;
+                            } else {
+                                    state.serialize_field("struct_body", &buf)?;
+                             }
+                        },
+                        Some(MemDfeSearchVersion::Turin1) => {
+                                if let Some(s) = self.body_as_struct_array::<memory::MemDfeSearchElement36>() {
+                                    let v = s.iter().collect::<Vec<_>>();
+                                    state.serialize_field("MemDfeSearchElement36", &v)?;
+                                } else {
+                                    state.serialize_field("struct_body", &buf)?;
+                                }
+                          }
+                          _ => {
+                                state.serialize_field("struct_body", &buf)?;
+                          }
+                    }
                 }
             }
         }
@@ -1223,12 +1243,22 @@ impl<'de> Deserialize<'de> for SerdeEntryItem {
                             )?;
                         }
                         Field::MemDfeSearchElement32 => {
+                            // TODO: maybe also sanity-check
+                            // context.mem_dfe_search_version()
+                            // Note: context.mem_dfe_search_version is optional.
+                            // If it's not specified, it deserialization should
+                            // still work.
                             struct_vec_to_body::<
                                 memory::MemDfeSearchElement32,
                                 V,
                             >(&mut body, &mut map)?;
                         }
                         Field::MemDfeSearchElement36 => {
+                            // TODO: maybe also sanity-check
+                            // context.mem_dfe_search_version()
+                            // Note: context.mem_dfe_search_version is optional.
+                            // If it's not specified, it deserialization should
+                            // still work.
                             struct_vec_to_body::<
                                 memory::MemDfeSearchElement36,
                                 V,