Add HostFlash commands (#392)

Add HostFlashRead and {Start, Get}HostFlashHash

Author: labbott

Cargo.lock

@@ -44,6 +44,7 @@ nix = { version = "0.27.1", features = ["net"] }
 omicron-zone-package = "0.11.0"
 once_cell = "1.21.3"
 paste = "1.0.15"
+parse_int = "0.6"
 rand = "0.8.5"
 serde = { version = "1.0", default-features = false, features = ["derive"] }
 serde-big-array = "0.5.1"

Cargo.toml

@@ -14,6 +14,7 @@ hex.workspace = true
 humantime.workspace = true
 nix.workspace = true
 rand.workspace = true
+parse_int.workspace = true
 serde.workspace = true
 serde_json.workspace = true
 sha2.workspace = true

faux-mgs/Cargo.toml

@@ -247,7 +247,9 @@ enum Command {
     },
 
     /// Get or set startup options on an SP.
-    StartupOptions { options: Option<u64> },
+    StartupOptions {
+        options: Option<u64>,
+    },
 
     /// Ask SP for its inventory.
     Inventory,
@@ -305,7 +307,9 @@ enum Command {
     UsartDetach,
 
     /// Serve host phase 2 images.
-    ServeHostPhase2 { directory: PathBuf },
+    ServeHostPhase2 {
+        directory: PathBuf,
+    },
 
     /// Upload a new image to the SP or one of its components.
     ///
@@ -454,6 +458,20 @@ enum Command {
         #[clap(subcommand)]
         cmd: DumpCommand,
     },
+    /// Read Host flash at address
+    ReadHostFlash {
+        slot: u16,
+        // Giving addresses in hex is nice and the default clap parser
+        // does not support that
+        #[clap(value_parser = parse_int::parse::<u32>)]
+        addr: u32,
+    },
+    StartHostFlashHash {
+        slot: u16,
+    },
+    GetHostFlashHash {
+        slot: u16,
+    },
 }
 
 #[derive(Subcommand, Debug, Clone)]
@@ -1702,6 +1720,18 @@ async fn run_command(
                 }
             }
         },
+        Command::ReadHostFlash { slot, addr } => {
+            let result = sp.read_host_flash(slot, addr).await?;
+            Ok(Output::Lines(vec![format!("{result:x?}")]))
+        }
+        Command::StartHostFlashHash { slot } => {
+            sp.start_host_flash_hash(slot).await?;
+            Ok(Output::Lines(vec!["hash started".to_string()]))
+        }
+        Command::GetHostFlashHash { slot } => {
+            let result = sp.get_host_flash_hash(slot).await?;
+            Ok(Output::Lines(vec![format!("{result:x?}")]))
+        }
     }
 }
 

faux-mgs/src/main.rs

@@ -38,6 +38,9 @@ pub const MAX_SERIALIZED_SIZE: usize = 1024;
 /// Size for a memory page in the Root of Trust (LPC55)
 pub const ROT_PAGE_SIZE: usize = 512;
 
+/// Size for a host flash page
+pub const HF_PAGE_SIZE: usize = 256;
+
 /// Module specifying the minimum and current version of the MGS protocol.
 ///
 /// Our primary mechanism for serializing requests and responses is enums
@@ -66,7 +69,7 @@ pub const ROT_PAGE_SIZE: usize = 512;
 /// for more detail and discussion.
 pub mod version {
     pub const MIN: u32 = 2;
-    pub const CURRENT: u32 = 18;
+    pub const CURRENT: u32 = 19;
 
     /// MGS protocol version in which SP watchdog messages were added
     pub const WATCHDOG_VERSION: u32 = 12;

gateway-messages/src/lib.rs

@@ -221,6 +221,21 @@ pub enum MgsRequest {
     },
 
     Dump(DumpRequest),
+
+    /// Read the host flash at the specified address for the current
+    /// persistent slot. Always returns one (host) page size
+    ReadHostFlash {
+        slot: u16,
+        addr: u32,
+    },
+    /// Start a hash of the specified flash bank
+    StartHostFlashHash {
+        slot: u16,
+    },
+    /// sha2-256 sum of the slot
+    GetHostFlashHash {
+        slot: u16,
+    },
 }
 
 #[derive(

gateway-messages/src/mgs_to_sp.rs

@@ -49,6 +49,7 @@ use crate::TlvPage;
 use crate::UpdateChunk;
 use crate::UpdateId;
 use crate::UpdateStatus;
+use crate::HF_PAGE_SIZE;
 use crate::ROT_PAGE_SIZE;
 use hubpack::error::Error as HubpackError;
 use hubpack::error::Result as HubpackResult;
@@ -405,6 +406,17 @@ pub trait SpHandler {
         seq: u32,
         buf: &mut [u8],
     ) -> Result<Option<DumpSegment>, SpError>;
+
+    fn read_host_flash(
+        &mut self,
+        slot: u16,
+        addr: u32,
+        buf: &mut [u8],
+    ) -> Result<(), SpError>;
+
+    fn start_host_flash_hash(&mut self, slot: u16) -> Result<(), SpError>;
+
+    fn get_host_flash_hash(&mut self, slot: u16) -> Result<[u8; 32], SpError>;
 }
 
 /// Handle a single incoming message.
@@ -1006,6 +1018,20 @@ fn handle_mgs_request<H: SpHandler>(
             }
             r.map(|d| SpResponse::Dump(DumpResponse::TaskDumpRead(d)))
         }
+        MgsRequest::ReadHostFlash { slot, addr } => {
+            let r = handler.read_host_flash(slot, addr, trailing_tx_buf);
+            if r.is_ok() {
+                outgoing_trailing_data =
+                    Some(OutgoingTrailingData::ShiftFromTail(HF_PAGE_SIZE));
+            }
+            r.map(|_| SpResponse::ReadHostFlash)
+        }
+        MgsRequest::StartHostFlashHash { slot } => handler
+            .start_host_flash_hash(slot)
+            .map(|_| SpResponse::StartHostFlashHashAck),
+        MgsRequest::GetHostFlashHash { slot } => {
+            handler.get_host_flash_hash(slot).map(SpResponse::HostFlashHash)
+        }
     };
 
     let response = match result {
@@ -1411,6 +1437,26 @@ mod tests {
         ) -> Result<Option<DumpSegment>, SpError> {
             unimplemented!()
         }
+
+        fn read_host_flash(
+            &mut self,
+            _slot: u16,
+            _addr: u32,
+            _buf: &mut [u8],
+        ) -> Result<(), SpError> {
+            unimplemented!()
+        }
+
+        fn start_host_flash_hash(&mut self, _slot: u16) -> Result<(), SpError> {
+            unimplemented!()
+        }
+
+        fn get_host_flash_hash(
+            &mut self,
+            _slot: u16,
+        ) -> Result<[u8; 32], SpError> {
+            unimplemented!()
+        }
     }
 
     #[cfg(feature = "std")]

gateway-messages/src/sp_impl.rs

@@ -168,6 +168,15 @@ pub enum SpResponse {
     /// Response to a `SetPowerState` request indicating that the system was
     /// already in the desired power state and no transition occurred.
     PowerStateUnchanged,
+
+    /// Packet contains the host flash data
+    ReadHostFlash,
+
+    /// Started a hash of a flash bank
+    StartHostFlashHashAck,
+
+    /// sha2-256 hash of a flash bank
+    HostFlashHash([u8; 32]),
 }
 
 /// Identifier for one of of an SP's KSZ8463 management-network-facing ports.
@@ -1093,6 +1102,7 @@ pub enum SpError {
     Watchdog(WatchdogError),
     Monorail(MonorailError),
     Dump(DumpError),
+    Hf(HfError),
 }
 
 impl fmt::Display for SpError {
@@ -1207,6 +1217,7 @@ impl fmt::Display for SpError {
             Self::Watchdog(e) => write!(f, "watchdog: {}", e),
             Self::Monorail(e) => write!(f, "monorail: {}", e),
             Self::Dump(e) => write!(f, "dump: {}", e),
+            Self::Hf(e) => write!(f, "hf: {}", e),
         }
     }
 }
@@ -1708,3 +1719,37 @@ impl fmt::Display for DumpError {
         write!(f, "{s}")
     }
 }
+
+/// Errors encountered when reading host flash. This isn't all the possible
+/// host flash errors but enough of the ones we should see commonly
+///
+/// This value is wrapped by [`SpError`]
+#[derive(
+    Debug, Clone, Copy, Eq, PartialEq, SerializedSize, Serialize, Deserialize,
+)]
+pub enum HfError {
+    NotMuxedToSp,
+    BadAddress,
+    QspiTimeout,
+    QspiTransferError,
+    HashUncalculated,
+    RecalculateHash,
+    HashInProgress,
+}
+
+impl fmt::Display for HfError {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        let s = match self {
+            Self::NotMuxedToSp => "Host flash not muxed to SP",
+            Self::BadAddress => "Bad host flash address",
+            Self::QspiTimeout => "Host QSPI timeout",
+            Self::QspiTransferError => {
+                "Host QSPI Transfer Error (check address)"
+            }
+            Self::HashUncalculated => "No hash calculated for slot",
+            Self::RecalculateHash => "Slot requires hash recalculation",
+            Self::HashInProgress => "Hash calcuation in progress",
+        };
+        write!(f, "{s}")
+    }
+}

gateway-messages/src/sp_to_mgs.rs

@@ -24,6 +24,7 @@ mod v15;
 mod v16;
 mod v17;
 mod v18;
+mod v19;
 
 pub fn assert_serialized<T: Serialize + SerializedSize + std::fmt::Debug>(
     expected: &[u8],

gateway-messages/tests/versioning/mod.rs

@@ -0,0 +1,62 @@
+// This Source Code Form is subject to the terms of the Mozilla Public
+// 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/.
+
+//! This source file is named after the protocol version being tested,
+//! e.g. v01.rs implements tests for protocol version 1.
+//! The tested protocol version is represented by "$VERSION" below.
+//!
+//! The tests in this module check that the serialized form of messages from MGS
+//! protocol version $VERSION have not changed.
+//!
+//! If a test in this module fails, _do not change the test_! This means you
+//! have changed, deleted, or reordered an existing message type or enum
+//! variant, and you should revert that change. This will remain true until we
+//! bump the `version::MIN` to a value higher than $VERSION, at which point these
+//! tests can be removed as we will stop supporting $VERSION.
+
+use super::assert_serialized;
+use gateway_messages::{HfError, MgsRequest, SpError, SpResponse};
+
+#[test]
+fn read_host_flash() {
+    let request = MgsRequest::ReadHostFlash { slot: 0, addr: 0 };
+    assert_serialized(&[47, 0, 0, 0, 0, 0, 0], &request);
+
+    let request = MgsRequest::StartHostFlashHash { slot: 0 };
+    assert_serialized(&[48, 0, 0], &request);
+
+    let request = MgsRequest::GetHostFlashHash { slot: 0 };
+    assert_serialized(&[49, 0, 0], &request);
+
+    let response = SpResponse::ReadHostFlash;
+    assert_serialized(&[49], &response);
+
+    let response = SpResponse::StartHostFlashHashAck;
+    assert_serialized(&[50], &response);
+
+    let response = SpResponse::HostFlashHash([0; 32]);
+    assert_serialized(
+        &[
+            51, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        ],
+        &response,
+    );
+
+    for (i, e) in [
+        HfError::NotMuxedToSp,
+        HfError::BadAddress,
+        HfError::QspiTimeout,
+        HfError::QspiTransferError,
+        HfError::HashUncalculated,
+        HfError::RecalculateHash,
+        HfError::HashInProgress,
+    ]
+    .into_iter()
+    .enumerate()
+    {
+        let request = SpError::Hf(e);
+        assert_serialized(&[38, i as u8], &request);
+    }
+}