packrat: Add helper API for serde ereports (#2225)

In practice, so far, most ereport payloads have been defined as structs
implementing `serde::Serialize` and encoded using the `minicbor-serde`
adapter crate. This requires a bit of boilerplate code, so it seems
worthwhile to provide a method that just does that. This commit adds one
in `task-packrat-api`. It's feature-flagged so we can avoid compiling
`minicbor`, `minicbor-serde`, and `serde` in tasks that don't submit
ereports using this.

Author: hawkw

Cargo.lock

@@ -20,13 +20,11 @@ gnarle = { path = "../../lib/gnarle" }
 ringbuf = { path = "../../lib/ringbuf" }
 userlib = { path = "../../sys/userlib", features = ["panic-messages"] }
 task-jefe-api = { path = "../../task/jefe-api" }
-task-packrat-api = { path = "../../task/packrat-api" }
+task-packrat-api = { path = "../../task/packrat-api", features = ["serde"] }
 
 cfg-if = { workspace = true }
 idol-runtime.workspace = true
 num-traits = { workspace = true }
-minicbor = { workspace = true }
-minicbor-serde = { workspace = true }
 pmbus = { workspace = true }
 serde = { workspace = true }
 zerocopy = { workspace = true }

drv/cosmo-seq-server/Cargo.toml

@@ -73,7 +73,7 @@ enum Trace {
     StatusMfrSpecific(Rail, Result<u8, ResponseCode>),
     I2cError(Rail, PmbusCmd, raa229620a::Error),
     EreportSent(Rail, usize),
-    EreportLost(Rail, usize, packrat::EreportWriteError),
+    EreportLost(Rail, usize, task_packrat_api::EreportWriteError),
     EreportTooBig(Rail),
 }
 
@@ -444,24 +444,13 @@ fn deliver_ereport(
     data: &impl serde::Serialize,
 ) {
     let mut ereport_buf = [0u8; 256];
-    let writer = minicbor::encode::write::Cursor::new(&mut ereport_buf[..]);
-    let mut s = minicbor_serde::Serializer::new(writer);
-    match data.serialize(&mut s) {
-        Ok(_) => {
-            let len = s.into_encoder().into_writer().position();
-            match packrat.deliver_ereport(&ereport_buf[..len]) {
-                Ok(_) => {
-                    ringbuf_entry!(Trace::EreportSent(rail, len));
-                }
-                Err(e) => {
-                    ringbuf_entry!(Trace::EreportLost(rail, len, e));
-                }
-            }
-            ringbuf_entry!(Trace::EreportSentOff(rail, len));
+    match packrat.serialize_ereport(data, &mut ereport_buf[..]) {
+        Ok(len) => ringbuf_entry!(Trace::EreportSent(rail, len)),
+        Err(task_packrat_api::EreportSerializeError::Packrat { len, err }) => {
+            ringbuf_entry!(Trace::EreportLost(rail, len, err))
         }
-        Err(_) => {
-            // XXX(eliza): ereport didn't fit in buffer...what do
-            ringbuf_entry!(Trace::EreportTooBig(rail));
+        Err(task_packrat_api::EreportSerializeError::Serialize(_)) => {
+            ringbuf_entry!(Trace::EreportTooBig(rail))
         }
     }
 }

drv/cosmo-seq-server/src/vcore.rs

@@ -18,7 +18,7 @@ counters = { path = "../../lib/counters" }
 gnarle = { path = "../../lib/gnarle" }
 ringbuf = { path = "../../lib/ringbuf" }
 task-jefe-api = { path = "../../task/jefe-api" }
-task-packrat-api = { path = "../../task/packrat-api" }
+task-packrat-api = { path = "../../task/packrat-api", features = ["serde"] }
 userlib = { path = "../../sys/userlib", features = ["panic-messages"] }
 
 cfg-if = { workspace = true }
@@ -30,8 +30,6 @@ zerocopy-derive = { workspace = true }
 num-derive = { workspace = true }
 static_assertions = { workspace = true }
 spd = { workspace = true }
-minicbor = { workspace = true }
-minicbor-serde = { workspace = true }
 serde = { workspace = true }
 pmbus = { workspace = true }
 

drv/gimlet-seq-server/Cargo.toml

@@ -339,23 +339,13 @@ struct Ereport {
 #[inline(never)]
 fn deliver_ereport(packrat: &packrat_api::Packrat, data: &impl Serialize) {
     let mut ereport_buf = [0u8; 128];
-    let writer = minicbor::encode::write::Cursor::new(&mut ereport_buf[..]);
-    let mut s = minicbor_serde::Serializer::new(writer);
-    match data.serialize(&mut s) {
-        Ok(_) => {
-            let len = s.into_encoder().into_writer().position();
-            match packrat.deliver_ereport(&ereport_buf[..len]) {
-                Ok(_) => {
-                    ringbuf_entry!(Trace::EreportSent(len));
-                }
-                Err(e) => {
-                    ringbuf_entry!(Trace::EreportLost(len, e));
-                }
-            }
+    match packrat.serialize_ereport(data, &mut ereport_buf[..]) {
+        Ok(len) => ringbuf_entry!(Trace::EreportSent(len)),
+        Err(task_packrat_api::EreportSerializeError::Packrat { len, err }) => {
+            ringbuf_entry!(Trace::EreportLost(len, err))
         }
-        Err(_) => {
-            // XXX(eliza): ereport didn't fit in buffer...what do
-            ringbuf_entry!(Trace::EreportTooBig);
+        Err(task_packrat_api::EreportSerializeError::Serialize(_)) => {
+            ringbuf_entry!(Trace::EreportTooBig)
         }
     }
 }

drv/gimlet-seq-server/src/vcore.rs

@@ -3,6 +3,10 @@ name = "task-packrat-api"
 version = "0.1.0"
 edition = "2021"
 
+[features]
+# Enable Serde support for the ereport API.
+serde = ["dep:serde", "dep:minicbor", "dep:minicbor-serde"]
+
 [dependencies]
 counters = { path = "../../lib/counters" }
 derive-idol-err.path = "../../lib/derive-idol-err"
@@ -12,7 +16,10 @@ userlib.path = "../../sys/userlib"
 
 gateway-ereport-messages.workspace = true
 idol-runtime.workspace = true
+minicbor = { workspace = true, optional = true }
+minicbor-serde = { workspace = true, optional = true }
 num-traits.workspace = true
+serde = { workspace = true, optional = true }
 zerocopy.workspace = true
 zerocopy-derive.workspace = true
 

task/packrat-api/Cargo.toml

@@ -69,4 +69,54 @@ pub enum EreportWriteError {
     Lost = 1,
 }
 
+/// Errors returned by [`Packrat::serialize_ereport`].
+#[derive(counters::Count)]
+#[cfg(feature = "serde")]
+pub enum EreportSerializeError {
+    /// The IPC to deliver the serialized ereport failed.
+    Packrat {
+        len: usize,
+        #[count(children)]
+        err: EreportWriteError,
+    },
+    /// Serializing the ereport failed.
+    Serialize(
+        minicbor_serde::error::EncodeError<minicbor::encode::write::EndOfSlice>,
+    ),
+}
+
+#[cfg(feature = "serde")]
+impl Packrat {
+    /// Deliver an ereport for a value that implements [`serde::Serialize`]. The
+    /// provided `buf` is used to serialize the value before sending it to
+    /// Packrat.
+    pub fn serialize_ereport(
+        &self,
+        ereport: &impl serde::Serialize,
+        buf: &mut [u8],
+    ) -> Result<usize, EreportSerializeError> {
+        let mut s = {
+            let writer = minicbor::encode::write::Cursor::new(buf);
+            minicbor_serde::Serializer::new(writer)
+        };
+
+        // Try to serialize the ereport...
+        ereport
+            .serialize(&mut s)
+            .map_err(EreportSerializeError::Serialize)?;
+
+        // Okay, get the buffer back out, and figure out how much of it was
+        // used.
+        let writer = s.into_encoder().into_writer();
+        let len = writer.position();
+        let buf = writer.into_inner();
+
+        // Now, try to send that to Packrat.
+        self.deliver_ereport(&buf[..len])
+            .map_err(|err| EreportSerializeError::Packrat { len, err })?;
+
+        Ok(len)
+    }
+}
+
 include!(concat!(env!("OUT_DIR"), "/client_stub.rs"));