[gateway] update MGS Git dependency

Cargo.toml

@@ -415,8 +415,8 @@ gateway-client = { path = "clients/gateway-client" }
 # is "fine", because SP/MGS communication maintains forwards and backwards
 # compatibility, but will mean that faux-mgs might be missing new
 # functionality.)
-gateway-messages = { git = "https://github.com/oxidecomputer/management-gateway-service", rev = "9bbac475dcaac88286c07a20b6bd3e94fc81d7f0", default-features = false, features = ["std"] }
-gateway-sp-comms = { git = "https://github.com/oxidecomputer/management-gateway-service", rev = "9bbac475dcaac88286c07a20b6bd3e94fc81d7f0" }
+gateway-messages = { git = "https://github.com/oxidecomputer/management-gateway-service", rev = "f9566e68e0a0ccb7c3eeea081ae1cea279c11b2a", default-features = false, features = ["std"] }
+gateway-sp-comms = { git = "https://github.com/oxidecomputer/management-gateway-service", rev = "f9566e68e0a0ccb7c3eeea081ae1cea279c11b2a" }
 gateway-test-utils = { path = "gateway-test-utils" }
 gateway-types = { path = "gateway-types" }
 gethostname = "0.5.0"

dev-tools/omdb/src/bin/omdb/mgs/sensors.rs

@@ -119,6 +119,13 @@ pub(crate) struct Sensor {
 impl Sensor {
     fn units(&self) -> &str {
         match self.kind {
+            MeasurementKind::CpuTctl => {
+                // Part of me kiiiind of wants to make this "%", as Tctl is
+                // always in the range of 0-100 --- it's essentially a sort of
+                // abstract "thermal shutdown Badness Percentage". But, nobody
+                // else seems to format it as a percentage AFAIK...
+                ""
+            }
             MeasurementKind::Temperature => "°C",
             MeasurementKind::Current | MeasurementKind::InputCurrent => "A",
             MeasurementKind::Voltage | MeasurementKind::InputVoltage => "V",
@@ -149,6 +156,7 @@ impl Sensor {
 
     fn to_kind_string(&self) -> &str {
         match self.kind {
+            MeasurementKind::CpuTctl => "cpu-tctl",
             MeasurementKind::Temperature => "temp",
             MeasurementKind::Power => "power",
             MeasurementKind::Current => "current",
@@ -161,6 +169,7 @@ impl Sensor {
 
     fn from_string(name: &str, kind: &str) -> Option<Self> {
         let k = match kind {
+            "cpu-tctl" => Some(MeasurementKind::CpuTctl),
             "temp" | "temperature" => Some(MeasurementKind::Temperature),
             "power" => Some(MeasurementKind::Power),
             "current" => Some(MeasurementKind::Current),

gateway-types/src/component_details.rs

@@ -374,6 +374,7 @@ pub enum MeasurementKind {
     InputCurrent,
     InputVoltage,
     Speed,
+    CpuTctl,
 }
 
 impl From<gateway_messages::measurement::MeasurementKind> for MeasurementKind {
@@ -387,6 +388,7 @@ impl From<gateway_messages::measurement::MeasurementKind> for MeasurementKind {
             MeasurementKind::InputCurrent => Self::InputCurrent,
             MeasurementKind::InputVoltage => Self::InputVoltage,
             MeasurementKind::Speed => Self::Speed,
+            MeasurementKind::CpuTctl => Self::CpuTctl,
         }
     }
 }

gateway/src/metrics.rs

@@ -791,11 +791,13 @@ impl SpPoller {
                     // We do this first so that we only have to clone the
                     // sensor's name if there's an error, rather than always
                     // cloning it in *case* there's an error.
+                    const TCTL_NAME: &str = "amd_cpu_tctl";
                     if let Err(error) = m.value {
                         let kind = match m.kind {
                             MeasurementKind::Temperature if is_tctl => {
-                                "amd_cpu_tctl"
+                                TCTL_NAME
                             }
+                            MeasurementKind::CpuTctl => TCTL_NAME,
                             MeasurementKind::Temperature => "temperature",
                             MeasurementKind::Current => "current",
                             MeasurementKind::Voltage => "voltage",
@@ -878,6 +880,17 @@ impl SpPoller {
                                 &metric::Temperature { sensor, datum: 0.0 },
                             )
                         }
+
+                        (Ok(datum), MeasurementKind::CpuTctl) => Sample::new(
+                            target,
+                            &metric::AmdCpuTctl { sensor, datum },
+                        ),
+                        (Err(_), MeasurementKind::CpuTctl) => {
+                            Sample::new_missing(
+                                target,
+                                &metric::AmdCpuTctl { sensor, datum: 0.0 },
+                            )
+                        }
                         (Ok(datum), MeasurementKind::Current) => Sample::new(
                             target,
                             &metric::Current { sensor, datum },
@@ -1204,5 +1217,8 @@ fn comms_error_str(error: CommunicationError) -> &'static str {
         CommunicationError::BadTrailingDataSize { .. } => {
             "bad_trailing_data_size"
         }
+        CommunicationError::BadDecompressionSize { .. } => {
+            "bad_decompression_size"
+        }
     }
 }

nexus/tests/integration_tests/metrics.rs

@@ -712,6 +712,7 @@ async fn test_mgs_metrics(
             for sensor in &component.sensors {
                 use gateway_messages::measurement::MeasurementKind as Kind;
                 match sensor.def.kind {
+                    Kind::CpuTctl => cpu_tctl += 1,
                     Kind::Temperature => {
                         // Currently, Tctl measurements are reported as a
                         // "temperature" measurement, but are tracked by a

openapi/gateway.json

@@ -1953,6 +1953,20 @@
             "required": [
               "kind"
             ]
+          },
+          {
+            "type": "object",
+            "properties": {
+              "kind": {
+                "type": "string",
+                "enum": [
+                  "cpu_tctl"
+                ]
+              }
+            },
+            "required": [
+              "kind"
+            ]
           }
         ]
       },

sp-sim/src/gimlet.rs

@@ -22,6 +22,8 @@ use futures::future;
 use gateway_messages::CfpaPage;
 use gateway_messages::ComponentAction;
 use gateway_messages::ComponentActionResponse;
+use gateway_messages::DumpSegment;
+use gateway_messages::DumpTask;
 use gateway_messages::Header;
 use gateway_messages::MgsRequest;
 use gateway_messages::MgsResponse;
@@ -1502,6 +1504,30 @@ impl SpHandler for Handler {
             }
         }
     }
+
+    fn get_task_dump_count(&mut self) -> Result<u32, SpError> {
+        debug!(&self.log, "received get_task_dump_count");
+        Err(SpError::RequestUnsupportedForSp)
+    }
+
+    fn task_dump_read_start(
+        &mut self,
+        index: u32,
+        _key: [u8; 16],
+    ) -> Result<DumpTask, SpError> {
+        debug!(&self.log, "received task_dump_read_start"; "index" => index);
+        Err(SpError::RequestUnsupportedForSp)
+    }
+
+    fn task_dump_read_continue(
+        &mut self,
+        _key: [u8; 16],
+        seq: u32,
+        _buf: &mut [u8],
+    ) -> Result<Option<DumpSegment>, SpError> {
+        debug!(&self.log, "received task_dump_read_continue"; "seq" => seq);
+        Err(SpError::RequestUnsupportedForSp)
+    }
 }
 
 impl SimSpHandler for Handler {

sp-sim/src/sidecar.rs

@@ -27,6 +27,8 @@ use gateway_messages::ComponentAction;
 use gateway_messages::ComponentActionResponse;
 use gateway_messages::ComponentDetails;
 use gateway_messages::DiscoverResponse;
+use gateway_messages::DumpSegment;
+use gateway_messages::DumpTask;
 use gateway_messages::IgnitionCommand;
 use gateway_messages::IgnitionState;
 use gateway_messages::MgsError;
@@ -1202,6 +1204,30 @@ impl SpHandler for Handler {
             }
         }
     }
+
+    fn get_task_dump_count(&mut self) -> Result<u32, SpError> {
+        debug!(&self.log, "received get_task_dump_count");
+        Err(SpError::RequestUnsupportedForSp)
+    }
+
+    fn task_dump_read_start(
+        &mut self,
+        index: u32,
+        _key: [u8; 16],
+    ) -> Result<DumpTask, SpError> {
+        debug!(&self.log, "received task_dump_read_start"; "index" => index);
+        Err(SpError::RequestUnsupportedForSp)
+    }
+
+    fn task_dump_read_continue(
+        &mut self,
+        _key: [u8; 16],
+        seq: u32,
+        _buf: &mut [u8],
+    ) -> Result<Option<DumpSegment>, SpError> {
+        debug!(&self.log, "received task_dump_read_continue"; "seq" => seq);
+        Err(SpError::RequestUnsupportedForSp)
+    }
 }
 
 impl SimSpHandler for Handler {