sled-agent needs to expose cpu_family for inventory collections too

the existing plumbing was sufficient for sled-agent to report the CPU
family at startup, but did not provide the CPU family when Nexus calls
later for inventory collections. when you've upgraded to this version,
the database migration sets the sled CPU family to `unknown` expecting
that the next inventory collection will figure things out. this doesn't
happen, and the initial check-in doesn't update the CPU type either
(presumably because the sled is already known and initialized from the
control plane's perspective?)

this does... most of the plumbing to report a sled's CPU family for
inventory collection, but it doesn't actually work. `SledCpuFamily`
being both in `omicron-common` and `nexus-client` is kind of unworkable.
probably need a `ConvertInto` or something to transform the shared into
the `nexus-client` when needed..? i've been trying to figure out what
exactly is necessary and what is just building a mess for myself for two
hours and this feels like it's going nowhere.

Author: iximeow

common/src/api/internal/shared.rs

@@ -1101,6 +1101,39 @@ pub struct SledIdentifiers {
     pub serial: String,
 }
 
+/// Identifies the kind of CPU present on a sled, determined by reading CPUID.
+#[derive(Serialize, Deserialize, Copy, Clone, Debug, PartialEq, Eq, JsonSchema)]
+#[serde(rename_all = "snake_case")]
+pub enum SledCpuFamily {
+    /// The CPU vendor or its family number don't correspond to any of the
+    /// known family variants.
+    Unknown,
+
+    /// AMD Milan processors (or very close). Could be an actual Milan in a
+    /// Gimlet, a close-to-Milan client Zen 3 part, or Zen 4 (for which Milan is
+    /// the greatest common denominator).
+    AmdMilan,
+
+    /// AMD Turin processors (or very close). Could be an actual Turin in a
+    /// Cosmo, or a close-to-Turin client Zen 5 part.
+    AmdTurin,
+
+    /// AMD Turin Dense processors. There are no "Turin Dense-like" CPUs unlike
+    /// other cases, so this means a bona fide Zen 5c Turin Dense part.
+    AmdTurinDense,
+}
+
+impl fmt::Display for SledCpuFamily {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            SledCpuFamily::Unknown => write!(f, "unknown"),
+            SledCpuFamily::AmdMilan => write!(f, "milan"),
+            SledCpuFamily::AmdTurin => write!(f, "turin"),
+            SledCpuFamily::AmdTurinDense => write!(f, "turin_dense"),
+        }
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;

nexus-sled-agent-shared/src/inventory.rs

@@ -26,7 +26,7 @@ use omicron_common::update::OmicronZoneManifestSource;
 use omicron_common::{
     api::{
         external::{ByteCount, Generation},
-        internal::shared::{NetworkInterface, SourceNatConfig},
+        internal::shared::{NetworkInterface, SourceNatConfig, SledCpuFamily},
     },
     disk::{DatasetConfig, DiskVariant, OmicronPhysicalDiskConfig},
     update::ArtifactId,
@@ -121,6 +121,7 @@ pub struct Inventory {
     pub baseboard: Baseboard,
     pub usable_hardware_threads: u32,
     pub usable_physical_ram: ByteCount,
+    pub cpu_family: SledCpuFamily,
     pub reservoir_size: ByteCount,
     pub disks: Vec<InventoryDisk>,
     pub zpools: Vec<InventoryZpool>,

nexus/db-model/src/inventory.rs

@@ -8,6 +8,7 @@ use crate::ArtifactHash;
 use crate::Generation;
 use crate::PhysicalDiskKind;
 use crate::omicron_zone_config::{self, OmicronZoneNic};
+use crate::sled_cpu_family::SledCpuFamily;
 use crate::typed_uuid::DbTypedUuid;
 use crate::{
     ByteCount, MacAddr, Name, ServiceKind, SqlU8, SqlU16, SqlU32,
@@ -887,6 +888,7 @@ pub struct InvSledAgent {
     pub sled_role: SledRole,
     pub usable_hardware_threads: SqlU32,
     pub usable_physical_ram: ByteCount,
+    pub cpu_family: SledCpuFamily,
     pub reservoir_size: ByteCount,
     // Soft foreign key to an `InvOmicronSledConfig`
     pub ledgered_sled_config: Option<DbTypedUuid<OmicronSledConfigKind>>,
@@ -1300,6 +1302,7 @@ impl InvSledAgent {
                 usable_physical_ram: ByteCount::from(
                     sled_agent.usable_physical_ram,
                 ),
+                cpu_family: sled_agent.cpu_family.into(),
                 reservoir_size: ByteCount::from(sled_agent.reservoir_size),
                 ledgered_sled_config: ledgered_sled_config.map(From::from),
                 reconciler_status,

nexus/db-model/src/sled_cpu_family.rs

@@ -26,9 +26,9 @@ impl_enum_type!(
     AmdTurinDense => b"amd_turin_dense"
 );
 
-impl From<nexus_types::internal_api::params::SledCpuFamily> for SledCpuFamily {
-    fn from(value: nexus_types::internal_api::params::SledCpuFamily) -> Self {
-        use nexus_types::internal_api::params::SledCpuFamily as InputFamily;
+impl From<omicron_common::api::internal::shared::SledCpuFamily> for SledCpuFamily {
+    fn from(value: omicron_common::api::internal::shared::SledCpuFamily) -> Self {
+        use omicron_common::api::internal::shared::SledCpuFamily as InputFamily;
         match value {
             InputFamily::Unknown => Self::Unknown,
             InputFamily::AmdMilan => Self::AmdMilan,
@@ -38,7 +38,7 @@ impl From<nexus_types::internal_api::params::SledCpuFamily> for SledCpuFamily {
     }
 }
 
-impl From<SledCpuFamily> for nexus_types::internal_api::params::SledCpuFamily {
+impl From<SledCpuFamily> for omicron_common::api::internal::shared::SledCpuFamily {
     fn from(value: SledCpuFamily) -> Self {
         match value {
             SledCpuFamily::Unknown => Self::Unknown,

nexus/db-queries/src/db/datastore/inventory.rs

@@ -1385,6 +1385,8 @@ impl DataStore {
                                 sled_agent.usable_physical_ram,
                             )
                             .into_sql::<diesel::sql_types::Int8>(),
+                            nexus_db_model::SledCpuFamily::from(sled_agent.cpu_family)
+                            .into_sql::<nexus_db_schema::enums::SledCpuFamilyEnum>(),
                             nexus_db_model::ByteCount::from(
                                 sled_agent.reservoir_size,
                             )
@@ -1439,6 +1441,7 @@ impl DataStore {
                                 sa_dsl::sled_role,
                                 sa_dsl::usable_hardware_threads,
                                 sa_dsl::usable_physical_ram,
+                                sa_dsl::cpu_family,
                                 sa_dsl::reservoir_size,
                                 sa_dsl::ledgered_sled_config,
                                 sa_dsl::reconciler_status_kind,
@@ -1470,6 +1473,7 @@ impl DataStore {
                         _sled_role,
                         _usable_hardware_threads,
                         _usable_physical_ram,
+                        _cpu_family,
                         _reservoir_size,
                         _ledgered_sled_config,
                         _reconciler_status_kind,
@@ -3846,6 +3850,7 @@ impl DataStore {
                 sled_role: s.sled_role.into(),
                 usable_hardware_threads: u32::from(s.usable_hardware_threads),
                 usable_physical_ram: s.usable_physical_ram.into(),
+                cpu_family: s.cpu_family.into(),
                 reservoir_size: s.reservoir_size.into(),
                 // For disks, zpools, and datasets, the map for a sled ID is
                 // only populated if there is at least one disk/zpool/dataset

nexus/db-schema/src/schema.rs

@@ -1609,6 +1609,7 @@ table! {
         sled_role -> crate::enums::SledRoleEnum,
         usable_hardware_threads -> Int8,
         usable_physical_ram -> Int8,
+        cpu_family -> crate::enums::SledCpuFamilyEnum,
         reservoir_size -> Int8,
 
         ledgered_sled_config -> Nullable<Uuid>,

nexus/inventory/src/builder.rs

@@ -595,6 +595,7 @@ impl CollectionBuilder {
             baseboard_id,
             usable_hardware_threads: inventory.usable_hardware_threads,
             usable_physical_ram: inventory.usable_physical_ram,
+            cpu_family: inventory.cpu_family,
             reservoir_size: inventory.reservoir_size,
             time_collected,
             sled_id,

nexus/inventory/src/examples.rs

@@ -40,6 +40,7 @@ use nexus_types::inventory::ZpoolName;
 use omicron_cockroach_metrics::MetricValue;
 use omicron_cockroach_metrics::PrometheusMetrics;
 use omicron_common::api::external::ByteCount;
+use omicron_common::api::internal::shared::SledCpuFamily;
 use omicron_common::disk::DatasetConfig;
 use omicron_common::disk::DatasetKind;
 use omicron_common::disk::DatasetName;
@@ -957,6 +958,7 @@ pub fn sled_agent(
         sled_id,
         usable_hardware_threads: 10,
         usable_physical_ram: ByteCount::from(1024 * 1024),
+        cpu_family: SledCpuFamily::AmdMilan,
         disks,
         zpools,
         datasets,

nexus/reconfigurator/planning/src/system.rs

@@ -57,6 +57,7 @@ use omicron_common::address::SLED_PREFIX;
 use omicron_common::address::get_sled_address;
 use omicron_common::api::external::ByteCount;
 use omicron_common::api::external::Generation;
+use omicron_common::api::internal::shared::SledCpuFamily;
 use omicron_common::disk::DiskIdentity;
 use omicron_common::disk::DiskVariant;
 use omicron_common::disk::M2Slot;
@@ -1071,6 +1072,7 @@ impl Sled {
                 sled_id,
                 usable_hardware_threads: 10,
                 usable_physical_ram: ByteCount::from(1024 * 1024),
+                cpu_family: SledCpuFamily::AmdMilan,
                 // Populate disks, appearing like a real device.
                 disks: zpools
                     .values()
@@ -1267,6 +1269,7 @@ impl Sled {
             sled_id,
             usable_hardware_threads: inv_sled_agent.usable_hardware_threads,
             usable_physical_ram: inv_sled_agent.usable_physical_ram,
+            cpu_family: inv_sled_agent.cpu_family,
             disks: vec![],
             zpools: vec![],
             datasets: vec![],

nexus/types/src/internal_api/params.rs

@@ -18,6 +18,7 @@ use omicron_common::api::internal::nexus::Certificate;
 use omicron_common::api::internal::shared::AllowedSourceIps;
 use omicron_common::api::internal::shared::ExternalPortDiscovery;
 use omicron_common::api::internal::shared::RackNetworkConfig;
+use omicron_common::api::internal::shared::SledCpuFamily;
 use omicron_common::api::internal::shared::SourceNatConfig;
 use omicron_uuid_kinds::DatasetUuid;
 use omicron_uuid_kinds::PhysicalDiskUuid;
@@ -30,28 +31,6 @@ use std::net::SocketAddr;
 use std::net::SocketAddrV6;
 use uuid::Uuid;
 
-/// Identifies the kind of CPU present on a sled, determined by reading CPUID.
-#[derive(Serialize, Deserialize, Debug, JsonSchema)]
-#[serde(rename_all = "snake_case")]
-pub enum SledCpuFamily {
-    /// The CPU vendor or its family number don't correspond to any of the
-    /// known family variants.
-    Unknown,
-
-    /// AMD Milan processors (or very close). Could be an actual Milan in a
-    /// Gimlet, a close-to-Milan client Zen 3 part, or Zen 4 (for which Milan is
-    /// the greatest common denominator).
-    AmdMilan,
-
-    /// AMD Turin processors (or very close). Could be an actual Turin in a
-    /// Cosmo, or a close-to-Turin client Zen 5 part.
-    AmdTurin,
-
-    /// AMD Turin Dense processors. There are no "Turin Dense-like" CPUs unlike
-    /// other cases, so this means a bona fide Zen 5c Turin Dense part.
-    AmdTurinDense,
-}
-
 /// Sent by a sled agent to Nexus to inform about resources
 #[derive(Serialize, Deserialize, Debug, JsonSchema)]
 pub struct SledAgentInfo {