Add MGS API for getting Host Panic/Host Boot Failure messages

faux-mgs/src/main.rs

@@ -21,6 +21,7 @@ use gateway_messages::ApobComponentActionResponse;
 use gateway_messages::ComponentAction;
 use gateway_messages::ComponentActionResponse;
 use gateway_messages::EcdsaSha2Nistp256Challenge;
+use gateway_messages::HostInfoRequest;
 use gateway_messages::IgnitionCommand;
 use gateway_messages::LedComponentAction;
 use gateway_messages::MonorailComponentAction;
@@ -542,6 +543,10 @@ enum Command {
         #[clap(value_parser = parse_power_rail_name)]
         rail: PowerRailName,
     },
+    /// Get the Host Panic Payload
+    GetHostPanic,
+    /// Get the Host Boot Failure message
+    GetBootFail,
 }
 
 #[derive(Subcommand, Debug, Clone)]
@@ -2524,6 +2529,141 @@ async fn run_command(
 
             Ok(Output::Lines(lines))
         }
+        Command::GetHostPanic => {
+            // Get the first segment, if any
+            //
+            // TODO: buffer sizing? We have a normal sized UDP frame (15xx
+            // bytes?), with some overhead, 1k might be reasonable here, but
+            // there's probably not that much speed benefit to halving the
+            // number of frames sent as this isn't done in a "hot" loop.
+            let res = sp.get_host_panic_payload(None, 512).await?;
+
+            let mut total = res.contents;
+            let ttl_bytes = res.total_len;
+            let seqno = res.seqno;
+
+            // Truncate the payload (which potentially contains *more* bytes
+            // than were actually used!) if the total message bytes fit into
+            // a single frame. This is a no-op if ttl_bytes > total.len().
+            total.truncate(ttl_bytes);
+
+            // Request the entire contents, one chunk at a time
+            while total.len() < ttl_bytes {
+                // Get the NEXT chunk of data, after the part(s) that we already
+                // have received.
+                let res = sp
+                    .get_host_panic_payload(
+                        Some(HostInfoRequest {
+                            offset: total.len() as u32,
+                            seqno,
+                        }),
+                        512,
+                    )
+                    .await?;
+
+                // TODO: If either of these change, it would mean that the host
+                // panicked RIGHT as we were asking about it. The simpler route
+                // is to just panic, if we wanted to be really fancy we could
+                // put this whole match arm in an outer loop and gracefully
+                // retry. If you are taking this impl for real control plane
+                // things, consider doing that, maybe with some upper bound of
+                // retries!
+                //
+                // The SP can only store one host panic at a time, so there's
+                // no way to retrieve an older panic after it has been
+                // overwritten.
+                assert_eq!(seqno, res.seqno);
+                assert_eq!(ttl_bytes, res.total_len);
+                total.extend_from_slice(&res.contents);
+            }
+
+            // Again, truncate `total`, to handle any extra bytes in the last
+            // received frame.
+            total.truncate(ttl_bytes);
+
+            let mut out = vec![];
+            if let Ok(text) = std::str::from_utf8(&total) {
+                out.push("Panic Text:".to_string());
+                // TODO: Is this necessary? Just push as one to_string?
+                out.extend(text.lines().map(str::to_string));
+                Ok(Output::Lines(out))
+            } else {
+                out.push(
+                    "Panic Text was not a valid UTF-8 string.".to_string(),
+                );
+                out.push("Panic Text bytes (hex):".to_string());
+                out.push(format!("{total:02X?}"));
+                Ok(Output::Lines(out))
+            }
+        }
+        Command::GetBootFail => {
+            // Get the first segment, if any
+            //
+            // TODO: buffer sizing? We have a normal sized UDP frame (15xx
+            // bytes?), with some overhead, 1k might be reasonable here, but
+            // there's probably not that much speed benefit to halving the
+            // number of frames sent as this isn't done in a "hot" loop.
+            let res = sp.get_host_bootfail_payload(None, 512).await?;
+
+            let mut total = res.contents;
+            let ttl_bytes = res.total_len;
+            let seqno = res.seqno;
+
+            // Truncate the payload (which potentially contains *more* bytes
+            // than were actually used!) if the total message bytes fit into
+            // a single frame. This is a no-op if ttl_bytes > total.len().
+            total.truncate(ttl_bytes);
+
+            // Request the entire contents, one chunk at a time
+            while total.len() < ttl_bytes {
+                // Get the NEXT chunk of data, after the part(s) that we already
+                // have received.
+                let res = sp
+                    .get_host_bootfail_payload(
+                        Some(HostInfoRequest {
+                            offset: total.len() as u32,
+                            seqno,
+                        }),
+                        512,
+                    )
+                    .await?;
+
+                // TODO: If either of these change, it would mean that the host
+                // failed RIGHT as we were asking about it. The simpler route
+                // is to just panic, if we wanted to be really fancy we could
+                // put this whole match arm in an outer loop and gracefully
+                // retry. If you are taking this impl for real control plane
+                // things, consider doing that, maybe with some upper bound of
+                // retries!
+                //
+                // The SP can only store one bootfail at a time, so there's
+                // no way to retrieve an older panic after it has been
+                // overwritten.
+                assert_eq!(seqno, res.seqno);
+                assert_eq!(ttl_bytes, res.total_len);
+                total.extend_from_slice(&res.contents);
+            }
+
+            // Again, truncate `total`, to handle any extra bytes in the last
+            // received frame.
+            total.truncate(ttl_bytes);
+
+            let mut out = vec![];
+            if let Ok(text) = std::str::from_utf8(&total) {
+                out.push("Boot Failure Text:".to_string());
+                // TODO: Is this necessary? Just push as one to_string?
+                out.extend(text.lines().map(str::to_string));
+                Ok(Output::Lines(out))
+            } else {
+                out.push(
+                    "Boot Failure Text was not a valid UTF-8 string."
+                        .to_string(),
+                );
+                out.push("Boot Failure Text bytes (hex):".to_string());
+                out.push(format!("{total:02X?}"));
+                Ok(Output::Lines(out))
+            }
+        }
     }
 }
 

gateway-messages/src/mgs_to_sp.rs

@@ -243,8 +243,41 @@ pub enum MgsRequest {
     /// different than the current active slot (see `ComponentGetActiveSlot`).
     ComponentGetPersistentSlot(SpComponent),
 
-    /// Request the STATUS registers of a PMBus device, indexed by power rail name.
+    /// Request the STATUS registers of a PMBus device, indexed by power rail
+    /// name.
     GetPmbusStatus(PowerRailName),
+
+    /// Request for Host Panic Payload
+    GetHostPanicPayload {
+        // If Some: must include a valid offset, and the index of the current Host Panic.
+        // If None: Will always be an offset of 0, and the index of the current Host Panic
+        // (if any) will be included in the response
+        request: Option<HostInfoRequest>,
+        // The maximum size, in bytes, of the fragment to be returned
+        len: u32,
+    },
+
+    /// Request for Host Boot Failure Payload
+    GetHostBootfailPayload {
+        // If Some: must include a valid offset, and the index of the current Host Bootfail.
+        // If None: Will always be an offset of 0, and the index of the current Host Bootfail
+        // (if any) will be included in the response
+        request: Option<HostInfoRequest>,
+        // The maximum size, in bytes, of the fragment to be returned
+        len: u32,
+    },
+}
+
+/// Request information for Host Bootfail or Host Panic data
+#[derive(
+    Debug, Clone, Copy, PartialEq, Eq, Deserialize, Serialize, SerializedSize,
+)]
+pub struct HostInfoRequest {
+    /// The offset, in bytes, from the start of the data
+    pub offset: u32,
+    /// The specific data sequence number that uniquely identifies the requested
+    /// data
+    pub seqno: u32,
 }
 
 #[derive(

gateway-messages/src/sp_impl.rs

@@ -19,6 +19,11 @@ use crate::DumpSegment;
 use crate::DumpTask;
 use crate::HF_PAGE_SIZE;
 use crate::Header;
+use crate::HostBootfailPayload;
+use crate::HostBootfailPayloadData;
+use crate::HostInfoRequest;
+use crate::HostPanicPayload;
+use crate::HostPanicPayloadData;
 use crate::IgnitionCommand;
 use crate::IgnitionState;
 use crate::Message;
@@ -430,6 +435,20 @@ pub trait SpHandler {
         &mut self,
         rail: &PowerRailName,
     ) -> Result<PmbusStatus, SpError>;
+
+    fn get_host_panic_payload(
+        &mut self,
+        request: Option<HostInfoRequest>,
+        len: u32,
+        trailing_tx_buf: &mut [u8],
+    ) -> Result<HostPanicPayloadData, SpError>;
+
+    fn get_host_bootfail_payload(
+        &mut self,
+        request: Option<HostInfoRequest>,
+        len: u32,
+        trailing_tx_buf: &mut [u8],
+    ) -> Result<HostBootfailPayloadData, SpError>;
 }
 
 /// Handle a single incoming message.
@@ -1071,6 +1090,27 @@ fn handle_mgs_request<H: SpHandler>(
                 })
             })
         }
+        MgsRequest::GetHostPanicPayload { request, len } => handler
+            .get_host_panic_payload(request, len, trailing_tx_buf)
+            .map(|data| {
+                outgoing_trailing_data =
+                    Some(OutgoingTrailingData::ShiftFromTail(data.len));
+                SpResponse::HostPanicPayload(HostPanicPayload {
+                    total_len: data.total_len,
+                    seqno: data.seqno,
+                })
+            }),
+        MgsRequest::GetHostBootfailPayload { request, len } => handler
+            .get_host_bootfail_payload(request, len, trailing_tx_buf)
+            .map(|data| {
+                outgoing_trailing_data =
+                    Some(OutgoingTrailingData::ShiftFromTail(data.len));
+                SpResponse::HostBootfailPayload(HostBootfailPayload {
+                    total_len: data.total_len,
+                    seqno: data.seqno,
+                    reason: data.reason,
+                })
+            }),
     };
 
     let response = match result {
@@ -1510,6 +1550,24 @@ mod tests {
         ) -> Result<PmbusStatus, SpError> {
             unimplemented!()
         }
+
+        fn get_host_panic_payload(
+            &mut self,
+            _request: Option<HostInfoRequest>,
+            _len: u32,
+            _trailing_tx_buf: &mut [u8],
+        ) -> Result<HostPanicPayloadData, SpError> {
+            unimplemented!()
+        }
+
+        fn get_host_bootfail_payload(
+            &mut self,
+            _request: Option<HostInfoRequest>,
+            _len: u32,
+            _trailing_tx_buf: &mut [u8],
+        ) -> Result<HostBootfailPayloadData, SpError> {
+            unimplemented!()
+        }
     }
 
     #[cfg(feature = "std")]