host: fix last-panic/boot-fail commands

Memory layout changed in Hubris.

Author: cbiffle

Cargo.lock

@@ -17,7 +17,7 @@ name = "humility"
 #
 # Be sure to check in and push all of the files that change.  Happy versioning!
 #
-version = "0.11.6"
+version = "0.11.7"
 authors = ["Bryan Cantrill <[email protected]>"]
 edition = "2018"
 license = "MPL-2.0"

Cargo.toml

@@ -14,4 +14,5 @@ zerocopy.workspace = true
 humility.workspace = true
 humility-cmd.workspace = true
 humility-cli.workspace = true
+humility-doppel.workspace = true
 humility-log.workspace = true

cmd/host/Cargo.toml

@@ -53,13 +53,14 @@
 //! [0; 4096]
 //! ```
 
-use anyhow::{bail, Context, Result};
+use anyhow::{anyhow, bail, Context, Result};
 use clap::{CommandFactory, Parser};
 use zerocopy::FromBytes;
 
-use humility::{core::Core, hubris::HubrisArchive};
+use humility::{core::Core, hubris::HubrisArchive, reflect, reflect::Load};
 use humility_cli::{ExecutionContext, Subcommand};
 use humility_cmd::{Archive, Attach, Command, CommandKind, Validate};
+use humility_doppel as doppel;
 use humility_log::{msg, warn};
 
 #[derive(Parser, Debug)]
@@ -77,35 +78,115 @@ struct HostArgs {
     cmd: HostCommand,
 }
 
-fn read_var(
+static SEPARATE_HOST_BOOT_FAIL_NAME: &str = "LAST_HOST_BOOT_FAIL";
+
+static SEPARATE_LAST_HOST_PANIC_NAME: &str = "LAST_HOST_PANIC";
+
+static HOST_STATE_BUF_NAME: &str =
+    "task_host_sp_comms::ServerImpl::claim_static_resources::BUFS";
+
+/// Mirror type of the internal buf struct in `host_sp_comms`. Must be kept in
+/// (partial) sync with that structure (fields that are present need to match,
+/// other fields can be ignored).
+#[derive(Load)]
+struct HostStateBuf {
+    last_boot_fail: Vec<u8>,
+    last_panic: Vec<u8>,
+}
+
+fn read_uqvar(
     hubris: &HubrisArchive,
     core: &mut dyn Core,
     name: &str,
-) -> Result<Vec<u8>> {
-    msg!("reading {name}");
-    let var = hubris
-        .lookup_variable(name)
-        .context(format!("could not find {name}; is this a Gimlet image?"))?;
+) -> Result<Option<Vec<u8>>> {
+    let Some(var) = hubris.lookup_variable(name).ok() else {
+        return Ok(None);
+    };
 
     let mut buf: Vec<u8> = vec![0u8; var.size];
 
     core.halt()?;
     core.read_8(var.addr, buf.as_mut_slice())?;
     core.run()?;
 
-    Ok(buf)
+    Ok(Some(buf))
 }
 
-fn host_boot_fail(hubris: &HubrisArchive, core: &mut dyn Core) -> Result<()> {
-    let d = read_var(hubris, core, "LAST_HOST_BOOT_FAIL")?;
-    if d.iter().all(|&c| c == 0) {
-        println!("[0; {}]", d.len());
+fn read_qualified_state_buf(
+    hubris: &HubrisArchive,
+    core: &mut dyn Core,
+    name: &str,
+) -> Result<Option<HostStateBuf>> {
+    let Some(var) = hubris.lookup_qualified_variable(name).ok() else {
+        return Ok(None);
+    };
+
+    let var_ty = hubris.lookup_type(var.goff)?;
+
+    let mut buf: Vec<u8> = vec![0u8; var.size];
+
+    core.halt()?;
+    core.read_8(var.addr, &mut buf)?;
+    core.run()?;
+
+    let v = reflect::load_value(hubris, &buf, var_ty, 0)?;
+    let as_static_cell = doppel::ClaimOnceCell::from_value(&v)?;
+    Ok(Some(HostStateBuf::from_value(&as_static_cell.cell.value)?))
+}
+
+fn print_escaped_ascii(mut bytes: &[u8]) {
+    // Drop trailing NULs to avoid escaping them and cluttering up our output.
+    while let Some((&b'\0', prefix)) = bytes.split_last() {
+        bytes = prefix;
+    }
+
+    if bytes.is_empty() {
+        println!("Message contains no non-NUL bytes, not printing.");
+        return;
     } else {
-        match std::str::from_utf8(&d) {
-            Ok(s) => println!("{}", s.trim_matches('\0')),
-            Err(e) => println!("{:?}\n  (could not decode: {e})", d),
+        println!("Message is {} bytes long:", bytes.len());
+    }
+
+    let mut buf = String::new();
+    for &b in bytes {
+        match b {
+            b'\\' => {
+                // Escape any backslashes in the original, so that any escapes
+                // _we_ emit are unambiguous.
+                buf.push_str("\\\\");
+            }
+            b'\n' | b'\r' | b'\t' | 0x20..=0x7E => {
+                // Pass through basic text characters that we expect we might
+                // see in a message.
+                buf.push(b as char);
+            }
+            _ => {
+                // Escape any other non-printable characters.
+                buf.push_str("\\x");
+                buf.push_str(&format!("{b:02X}"));
+            }
         }
     }
+    println!("{buf}");
+}
+
+fn host_boot_fail(hubris: &HubrisArchive, core: &mut dyn Core) -> Result<()> {
+    // Try old name:
+    let d = read_uqvar(hubris, core, SEPARATE_HOST_BOOT_FAIL_NAME)?;
+    if let Some(d) = d {
+        print_escaped_ascii(&d);
+        return Ok(());
+    }
+    // Try new name
+    let buf = read_qualified_state_buf(hubris, core, HOST_STATE_BUF_NAME)?
+        .ok_or_else(|| {
+            anyhow!(
+                "Could not find host boot variables under any known name; \
+            is this a Gimlet image?"
+            )
+        })?;
+
+    print_escaped_ascii(&buf.last_boot_fail[..]);
 
     Ok(())
 }
@@ -149,8 +230,25 @@ struct IpccPanicStack {
 }
 
 fn host_last_panic(hubris: &HubrisArchive, core: &mut dyn Core) -> Result<()> {
-    let d = read_var(hubris, core, "LAST_HOST_PANIC")?;
+    // Try original name:
+    let d = read_uqvar(hubris, core, SEPARATE_LAST_HOST_PANIC_NAME)?;
+    if let Some(d) = d {
+        return print_panic(d);
+    }
+
+    // Try new name:
+    let buf = read_qualified_state_buf(hubris, core, HOST_STATE_BUF_NAME)?
+        .ok_or_else(|| {
+            anyhow!(
+                "Could not find host boot variables under any known name; \
+            is this a Gimlet image?"
+            )
+        })?;
+
+    print_panic(buf.last_panic)
+}
 
+fn print_panic(d: Vec<u8>) -> Result<()> {
     // Fix for https://github.com/oxidecomputer/hubris/issues/1554
     //
     // In some cases, `ipd_cause` is unambiguous based on the first byte;

cmd/host/src/lib.rs

@@ -1899,6 +1899,16 @@ impl HubrisArchive {
         }
     }
 
+    pub fn lookup_qualified_variable(
+        &self,
+        name: &str,
+    ) -> Result<&HubrisVariable> {
+        match self.qualified_variables.get(name) {
+            Some(variable) => Ok(variable),
+            None => Err(anyhow!("variable {} not found", name)),
+        }
+    }
+
     pub fn lookup_variables(&self, name: &str) -> Result<&Vec<HubrisVariable>> {
         match self.variables.get_vec(name) {
             None => Err(anyhow!("variable {} not found", name)),

humility-core/src/hubris.rs

@@ -384,6 +384,11 @@ pub enum CounterVariant {
     Nested(Counters),
 }
 
+#[derive(Clone, Debug, Load)]
+pub struct ClaimOnceCell {
+    pub cell: UnsafeCell,
+}
+
 #[derive(Clone, Debug, Load)]
 pub struct StaticCell {
     pub cell: UnsafeCell,

humility-doppel/src/lib.rs

@@ -13,7 +13,7 @@ For more information try --help
 
 ```
 $ humility --chip this-can-be-anything -V
-humility 0.11.6
+humility 0.11.7
 
 ```
 
@@ -28,7 +28,7 @@ For more information try --help
 
 ```
 $ humility -c apx432 -V
-humility 0.11.6
+humility 0.11.7
 
 ```
 

tests/cmd/chip.trycmd

@@ -2,14 +2,14 @@ Long version flag:
 
 ```
 $ humility --version
-humility 0.11.6
+humility 0.11.7
 
 ```
 
 Short version flag:
 
 ```
 $ humility -V
-humility 0.11.6
+humility 0.11.7
 
 ```