[sled-agent] Report boot partition contents of M.2 drives in inventory (PR 2/2) (#8451)

Add a `BootPartitionContents` structure to the inventory reported by the sled-agent-config-reconciler which contains:

* which slot we booted from (A or B)
* the contents of each slot

each of which is a `Result` in case we failed to determine any of those
three items. In practice, I'd expect us to basically never fail to
report which slot we booted from, and to only fail on the contents of a
slot if that slot doesn't have a valid phase 2 image in it.

Author: jgallagher

Cargo.lock

@@ -71,6 +71,7 @@ supports-color.workspace = true
 tabled.workspace = true
 textwrap.workspace = true
 tokio = { workspace = true, features = [ "full" ] }
+tufaceous-artifact.workspace = true
 unicode-width.workspace = true
 update-engine.workspace = true
 url.workspace = true

dev-tools/omdb/Cargo.toml

@@ -125,6 +125,10 @@ use nexus_db_queries::db::pagination::Paginator;
 use nexus_db_queries::db::pagination::paginated;
 use nexus_db_queries::db::queries::ALLOW_FULL_TABLE_SCAN_SQL;
 use nexus_db_queries::db::queries::region_allocation;
+use nexus_sled_agent_shared::inventory::BootImageHeader;
+use nexus_sled_agent_shared::inventory::BootPartitionContents;
+use nexus_sled_agent_shared::inventory::BootPartitionDetails;
+use nexus_sled_agent_shared::inventory::ConfigReconcilerInventory;
 use nexus_sled_agent_shared::inventory::ConfigReconcilerInventoryResult;
 use nexus_sled_agent_shared::inventory::ConfigReconcilerInventoryStatus;
 use nexus_sled_agent_shared::inventory::OmicronSledConfig;
@@ -178,6 +182,7 @@ use std::sync::Arc;
 use std::sync::LazyLock;
 use strum::IntoEnumIterator;
 use tabled::Tabled;
+use tufaceous_artifact::ArtifactHash;
 use uuid::Uuid;
 
 mod alert;
@@ -7361,34 +7366,41 @@ fn inv_collection_print_sleds(collection: &Collection) {
         }
 
         if let Some(last_reconciliation) = &sled.last_reconciliation {
-            if Some(&last_reconciliation.last_reconciled_config)
+            let ConfigReconcilerInventory {
+                last_reconciled_config,
+                external_disks,
+                datasets,
+                orphaned_datasets,
+                zones,
+                boot_partitions,
+            } = last_reconciliation;
+
+            inv_print_boot_partition_contents("    ", boot_partitions);
+
+            if Some(last_reconciled_config)
                 == sled.ledgered_sled_config.as_ref()
             {
                 println!("    last reconciled config: matches ledgered config");
             } else {
                 inv_collection_print_sled_config(
                     "LAST RECONCILED CONFIG",
-                    &last_reconciliation.last_reconciled_config,
+                    &last_reconciled_config,
                 );
             }
-            if last_reconciliation.orphaned_datasets.is_empty() {
+            if orphaned_datasets.is_empty() {
                 println!("        no orphaned datasets");
             } else {
                 println!(
                     "        {} orphaned dataset(s):",
-                    last_reconciliation.orphaned_datasets.len()
+                    orphaned_datasets.len()
                 );
-                for orphan in &last_reconciliation.orphaned_datasets {
+                for orphan in orphaned_datasets {
                     print_one_orphaned_dataset("            ", orphan);
                 }
             }
-            let disk_errs = collect_config_reconciler_errors(
-                &last_reconciliation.external_disks,
-            );
-            let dataset_errs =
-                collect_config_reconciler_errors(&last_reconciliation.datasets);
-            let zone_errs =
-                collect_config_reconciler_errors(&last_reconciliation.zones);
+            let disk_errs = collect_config_reconciler_errors(&external_disks);
+            let dataset_errs = collect_config_reconciler_errors(&datasets);
+            let zone_errs = collect_config_reconciler_errors(&zones);
             for (label, errs) in [
                 ("disk", disk_errs),
                 ("dataset", dataset_errs),
@@ -7438,6 +7450,57 @@ fn inv_collection_print_sleds(collection: &Collection) {
     }
 }
 
+fn inv_print_boot_partition_contents(
+    indent: &str,
+    boot_partitions: &BootPartitionContents,
+) {
+    let BootPartitionContents { boot_disk, slot_a, slot_b } = &boot_partitions;
+    print!("{indent}boot disk slot: ");
+    match boot_disk {
+        Ok(slot) => println!("{slot:?}"),
+        Err(err) => println!("FAILED TO DETERMINE: {err}"),
+    }
+    match slot_a {
+        Ok(details) => {
+            println!("{indent}slot A details:");
+            inv_print_boot_partition_details(&format!("{indent}    "), details);
+        }
+        Err(err) => {
+            println!("{indent}slot A details UNAVAILABLE: {err}");
+        }
+    }
+    match slot_b {
+        Ok(details) => {
+            println!("{indent}slot B details:");
+            inv_print_boot_partition_details(&format!("{indent}    "), details);
+        }
+        Err(err) => {
+            println!("{indent}slot B details UNAVAILABLE: {err}");
+        }
+    }
+}
+
+fn inv_print_boot_partition_details(
+    indent: &str,
+    details: &BootPartitionDetails,
+) {
+    let BootPartitionDetails { header, artifact_hash, artifact_size } = details;
+
+    // Not sure it's useful to print all the header details? We'll omit for now.
+    let BootImageHeader {
+        flags: _,
+        data_size: _,
+        image_size: _,
+        target_size: _,
+        sha256,
+        image_name,
+    } = header;
+
+    println!("{indent}artifact: {artifact_hash} ({artifact_size} bytes)");
+    println!("{indent}image name: {image_name}");
+    println!("{indent}phase 2 hash: {}", ArtifactHash(*sha256));
+}
+
 fn inv_collection_print_orphaned_datasets(collection: &Collection) {
     // Helper for `unwrap_or()` passing borrow check below
     static EMPTY_SET: LazyLock<IdOrdMap<OrphanedDataset>> =

dev-tools/omdb/src/bin/omdb/db.rs

@@ -16,16 +16,17 @@ use id_map::IdMappable;
 use iddqd::IdOrdItem;
 use iddqd::IdOrdMap;
 use iddqd::id_upcast;
-use omicron_common::disk::{DatasetKind, DatasetName};
+use omicron_common::disk::{DatasetKind, DatasetName, M2Slot};
 use omicron_common::ledger::Ledgerable;
+use omicron_common::snake_case_result;
+use omicron_common::snake_case_result::SnakeCaseResult;
 use omicron_common::update::OmicronZoneManifestSource;
 use omicron_common::{
     api::{
         external::{ByteCount, Generation},
         internal::shared::{NetworkInterface, SourceNatConfig},
     },
     disk::{DatasetConfig, DiskVariant, OmicronPhysicalDiskConfig},
-    snake_case_result::{self, SnakeCaseResult},
     update::ArtifactId,
     zpool_name::ZpoolName,
 };
@@ -139,6 +140,7 @@ pub struct ConfigReconcilerInventory {
     pub datasets: BTreeMap<DatasetUuid, ConfigReconcilerInventoryResult>,
     pub orphaned_datasets: IdOrdMap<OrphanedDataset>,
     pub zones: BTreeMap<OmicronZoneUuid, ConfigReconcilerInventoryResult>,
+    pub boot_partitions: BootPartitionContents,
 }
 
 impl ConfigReconcilerInventory {
@@ -202,10 +204,57 @@ impl ConfigReconcilerInventory {
             datasets,
             orphaned_datasets: IdOrdMap::new(),
             zones,
+            boot_partitions: {
+                // None of our callers care about this; if that changes, we
+                // could pass in boot partition contents.
+                let err = "constructed via debug_assume_success()".to_string();
+                BootPartitionContents {
+                    boot_disk: Err(err.clone()),
+                    slot_a: Err(err.clone()),
+                    slot_b: Err(err),
+                }
+            },
         }
     }
 }
 
+#[derive(Clone, Debug, PartialEq, Eq, Deserialize, JsonSchema, Serialize)]
+pub struct BootPartitionContents {
+    #[serde(with = "snake_case_result")]
+    #[schemars(schema_with = "SnakeCaseResult::<M2Slot, String>::json_schema")]
+    pub boot_disk: Result<M2Slot, String>,
+    #[serde(with = "snake_case_result")]
+    #[schemars(
+        schema_with = "SnakeCaseResult::<BootPartitionDetails, String>::json_schema"
+    )]
+    pub slot_a: Result<BootPartitionDetails, String>,
+    #[serde(with = "snake_case_result")]
+    #[schemars(
+        schema_with = "SnakeCaseResult::<BootPartitionDetails, String>::json_schema"
+    )]
+    pub slot_b: Result<BootPartitionDetails, String>,
+}
+
+#[derive(Clone, Debug, PartialEq, Eq, Deserialize, JsonSchema, Serialize)]
+pub struct BootPartitionDetails {
+    pub header: BootImageHeader,
+    pub artifact_hash: ArtifactHash,
+    pub artifact_size: usize,
+}
+
+// There are several other fields in the header that we either parse and discard
+// or ignore completely; see https://github.com/oxidecomputer/boot-image-tools
+// for more thorough support.
+#[derive(Clone, Debug, PartialEq, Eq, Deserialize, JsonSchema, Serialize)]
+pub struct BootImageHeader {
+    pub flags: u64,
+    pub data_size: u64,
+    pub image_size: u64,
+    pub target_size: u64,
+    pub sha256: [u8; 32],
+    pub image_name: String,
+}
+
 #[derive(Clone, Debug, PartialEq, Eq, Deserialize, JsonSchema, Serialize)]
 pub struct OrphanedDataset {
     pub name: DatasetName,