add CPU platforms to instances

Cargo.toml

@@ -647,6 +647,7 @@ rand_distr = "0.4.3"
 rand_seeder = "0.3.0"
 range-requests = { path = "range-requests" }
 ratatui = "0.29.0"
+raw-cpuid = { git = "https://github.com/oxidecomputer/rust-cpuid.git", rev = "0a8dbd2311263f6a59ea58089e33c8331436ff3a" }
 rayon = "1.10"
 rcgen = "0.12.1"
 reconfigurator-cli = { path = "dev-tools/reconfigurator-cli" }

common/src/api/external/mod.rs

@@ -1194,6 +1194,10 @@ pub struct Instance {
 
     #[serde(flatten)]
     pub auto_restart_status: InstanceAutoRestartStatus,
+
+    /// The CPU platform for this instance. If this is `null`, the instance
+    /// requires no particular CPU platform.
+    pub cpu_platform: Option<InstanceCpuPlatform>,
 }
 
 /// Status of control-plane driven automatic failure recovery for this instance.
@@ -1258,6 +1262,51 @@ pub enum InstanceAutoRestartPolicy {
     BestEffort,
 }
 
+/// A required CPU platform for an instance.
+///
+/// When an instance specifies a required CPU platform:
+///
+/// - The system may expose (to the VM) new CPU features that are only present
+///   on that platform (or on newer platforms of the same lineage that also
+///   support those features).
+/// - The instance must run on hosts that have CPUs that support all the
+///   features of the supplied platform.
+///
+/// That is, the instance is restricted to hosts that have the CPUs which
+/// support all features of the required platform, but in exchange the CPU
+/// features exposed by the platform are available for the guest to use. Note
+/// that this may prevent an instance from starting (if the hosts that could run
+/// it are full but there is capacity on other incompatible hosts).
+///
+/// If an instance does not specify a required CPU platform, then when
+/// it starts, the control plane selects a host for the instance and then
+/// supplies the guest with the "minimum" CPU platform supported by that host.
+/// This maximizes the number of hosts that can run the VM if it later needs to
+/// migrate to another host.
+///
+/// In all cases, the CPU features presented by a given CPU platform are a
+/// subset of what the corresponding hardware may actually support; features
+/// which cannot be used from a virtual environment or do not have full
+/// hypervisor support may be masked off. See RFD 314 for specific CPU features
+/// in a CPU platform.
+#[derive(
+    Copy, Clone, Debug, Deserialize, Serialize, JsonSchema, Eq, PartialEq,
+)]
+#[serde(rename_all = "snake_case")]
+pub enum InstanceCpuPlatform {
+    /// An AMD Milan-like CPU platform.
+    AmdMilan,
+
+    /// An AMD Turin-like CPU platform.
+    // Note that there is only Turin, not Turin Dense - feature-wise there are
+    // collapsed together as the guest-visible platform is the same.
+    // If the two must be distinguished for instance placement, we'll want to
+    // track whatever the motivating constraint is more explicitly. CPU
+    // families, and especially the vendor code names, don't necessarily promise
+    // details about specific processor packaging choices.
+    AmdTurin,
+}
+
 // AFFINITY GROUPS
 
 /// Affinity policy used to describe "what to do when a request cannot be satisfied"

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

@@ -4760,6 +4760,7 @@ async fn cmd_db_instance_info(
                     propolis_ip: _,
                     propolis_port: _,
                     instance_id: _,
+                    cpu_platform: _,
                     time_created,
                     time_deleted,
                     runtime:
@@ -7356,6 +7357,7 @@ fn prettyprint_vmm(
     const INSTANCE_ID: &'static str = "instance ID";
     const SLED_ID: &'static str = "sled ID";
     const SLED_SERIAL: &'static str = "sled serial";
+    const CPU_PLATFORM: &'static str = "CPU platform";
     const ADDRESS: &'static str = "propolis address";
     const STATE: &'static str = "state";
     const WIDTH: usize = const_max_len(&[
@@ -7366,6 +7368,7 @@ fn prettyprint_vmm(
         INSTANCE_ID,
         SLED_ID,
         SLED_SERIAL,
+        CPU_PLATFORM,
         STATE,
         ADDRESS,
     ]);
@@ -7379,6 +7382,7 @@ fn prettyprint_vmm(
         sled_id,
         propolis_ip,
         propolis_port,
+        cpu_platform,
         runtime: db::model::VmmRuntimeState { state, r#gen, time_state_updated },
     } = vmm;
 
@@ -7405,6 +7409,7 @@ fn prettyprint_vmm(
     if let Some(serial) = sled_serial {
         println!("{indent}{SLED_SERIAL:>width$}: {serial}");
     }
+    println!("{indent}{CPU_PLATFORM:>width$}: {cpu_platform}");
 }
 
 async fn cmd_db_vmm_list(
@@ -7480,6 +7485,7 @@ async fn cmd_db_vmm_list(
                 sled_id,
                 propolis_ip: _,
                 propolis_port: _,
+                cpu_platform: _,
                 runtime:
                     db::model::VmmRuntimeState {
                         state,

dev-tools/reconfigurator-cli/tests/output/cmds-example-stdout

@@ -1101,6 +1101,7 @@ sled 2eb69596-f081-4e2d-9425-9994926e0832 (role = Gimlet, serial serial1)
     found at:    <REDACTED_TIMESTAMP> from fake sled agent
     address:     [fd00:1122:3344:102::1]:12345
     usable hw threads:   10
+    CPU family:          amd_milan
     usable memory (GiB): 0
     reservoir (GiB):     0
     physical disks:
@@ -1210,6 +1211,7 @@ sled 32d8d836-4d8a-4e54-8fa9-f31d79c42646 (role = Gimlet, serial serial2)
     found at:    <REDACTED_TIMESTAMP> from fake sled agent
     address:     [fd00:1122:3344:103::1]:12345
     usable hw threads:   10
+    CPU family:          amd_milan
     usable memory (GiB): 0
     reservoir (GiB):     0
     physical disks:
@@ -1319,6 +1321,7 @@ sled 89d02b1b-478c-401a-8e28-7a26f74fa41b (role = Gimlet, serial serial0)
     found at:    <REDACTED_TIMESTAMP> from fake sled agent
     address:     [fd00:1122:3344:101::1]:12345
     usable hw threads:   10
+    CPU family:          amd_milan
     usable memory (GiB): 0
     reservoir (GiB):     0
     physical disks:

dev-tools/reconfigurator-cli/tests/output/cmds-mupdate-update-flow-stdout

@@ -88,6 +88,7 @@ sled 2b8f0cb3-0295-4b3c-bc58-4fe88b57112c (role = Gimlet, serial serial1)
     found at:    <REDACTED_TIMESTAMP> from fake sled agent
     address:     [fd00:1122:3344:102::1]:12345
     usable hw threads:   10
+    CPU family:          amd_milan
     usable memory (GiB): 0
     reservoir (GiB):     0
     physical disks:
@@ -194,6 +195,7 @@ sled 98e6b7c2-2efa-41ca-b20a-0a4d61102fe6 (role = Gimlet, serial serial0)
     found at:    <REDACTED_TIMESTAMP> from fake sled agent
     address:     [fd00:1122:3344:101::1]:12345
     usable hw threads:   10
+    CPU family:          amd_milan
     usable memory (GiB): 0
     reservoir (GiB):     0
     physical disks:
@@ -302,6 +304,7 @@ sled d81c6a84-79b8-4958-ae41-ea46c9b19763 (role = Gimlet, serial serial2)
     found at:    <REDACTED_TIMESTAMP> from fake sled agent
     address:     [fd00:1122:3344:103::1]:12345
     usable hw threads:   10
+    CPU family:          amd_milan
     usable memory (GiB): 0
     reservoir (GiB):     0
     physical disks:

end-to-end-tests/src/instance_launch.rs

@@ -79,6 +79,7 @@ async fn instance_launch() -> Result<()> {
             start: true,
             auto_restart_policy: Default::default(),
             anti_affinity_groups: Vec::new(),
+            cpu_platform: None,
         })
         .send()
         .await?;

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

@@ -40,9 +40,9 @@ use omicron_uuid_kinds::{SledUuid, ZpoolUuid};
 use schemars::schema::{Schema, SchemaObject};
 use schemars::{JsonSchema, SchemaGenerator};
 use serde::{Deserialize, Serialize};
-// Export this type for convenience -- this way, dependents don't have to
+// Export these types for convenience -- this way, dependents don't have to
 // depend on sled-hardware-types.
-pub use sled_hardware_types::Baseboard;
+pub use sled_hardware_types::{Baseboard, SledCpuFamily};
 use strum::EnumIter;
 use tufaceous_artifact::{ArtifactHash, KnownArtifactKind};
 
@@ -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/Cargo.toml

@@ -132,6 +132,7 @@ oxide-tokio-rt.workspace = true
 oximeter.workspace = true
 oximeter-instruments = { workspace = true, features = ["http-instruments"] }
 oximeter-producer.workspace = true
+raw-cpuid = { workspace = true, features = ["std"] }
 rustls = { workspace = true }
 rustls-pemfile = { workspace = true }
 update-common.workspace = true

nexus/db-model/src/instance.rs

@@ -5,7 +5,7 @@
 use super::InstanceIntendedState as IntendedState;
 use super::{
     ByteCount, Disk, ExternalIp, Generation, InstanceAutoRestartPolicy,
-    InstanceCpuCount, InstanceState, Vmm, VmmState,
+    InstanceCpuCount, InstanceCpuPlatform, InstanceState, Vmm, VmmState,
 };
 use crate::collection::DatastoreAttachTargetConfig;
 use crate::serde_time_delta::optional_time_delta;
@@ -68,6 +68,9 @@ pub struct Instance {
     #[diesel(column_name = boot_disk_id)]
     pub boot_disk_id: Option<Uuid>,
 
+    /// The instance's required CPU platform.
+    pub cpu_platform: Option<InstanceCpuPlatform>,
+
     #[diesel(embed)]
     pub runtime_state: InstanceRuntimeState,
 
@@ -139,6 +142,7 @@ impl Instance {
             // Intentionally ignore `params.boot_disk_id` here: we can't set
             // `boot_disk_id` until the referenced disk is attached.
             boot_disk_id: None,
+            cpu_platform: params.cpu_platform.map(Into::into),
 
             runtime_state,
             intended_state,
@@ -493,4 +497,6 @@ pub struct InstanceUpdate {
     pub ncpus: InstanceCpuCount,
 
     pub memory: ByteCount,
+
+    pub cpu_platform: Option<InstanceCpuPlatform>,
 }

nexus/db-model/src/instance_cpu_platform.rs

@@ -0,0 +1,65 @@
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at https://mozilla.org/MPL/2.0/.
+
+use crate::SledCpuFamily;
+
+use super::impl_enum_type;
+use serde::{Deserialize, Serialize};
+
+impl_enum_type!(
+    InstanceCpuPlatformEnum:
+
+    #[derive(
+        Copy,
+        Clone,
+        Debug,
+        PartialEq,
+        AsExpression,
+        FromSqlRow,
+        Serialize,
+        Deserialize
+    )]
+    pub enum InstanceCpuPlatform;
+
+    AmdMilan => b"amd_milan"
+    AmdTurin => b"amd_turin"
+);
+
+impl InstanceCpuPlatform {
+    /// Returns a slice containing the set of sled CPU families that can
+    /// accommodate an instance with this CPU platform.
+    pub fn compatible_sled_cpu_families(&self) -> &'static [SledCpuFamily] {
+        match self {
+            // Turin-based sleds have a superset of the features made available
+            // in a guest's Milan CPU platform
+            Self::AmdMilan => {
+                &[SledCpuFamily::AmdMilan, SledCpuFamily::AmdTurin]
+            }
+            Self::AmdTurin => &[SledCpuFamily::AmdTurin],
+        }
+    }
+}
+
+impl From<omicron_common::api::external::InstanceCpuPlatform>
+    for InstanceCpuPlatform
+{
+    fn from(value: omicron_common::api::external::InstanceCpuPlatform) -> Self {
+        use omicron_common::api::external::InstanceCpuPlatform as ApiPlatform;
+        match value {
+            ApiPlatform::AmdMilan => Self::AmdMilan,
+            ApiPlatform::AmdTurin => Self::AmdTurin,
+        }
+    }
+}
+
+impl From<InstanceCpuPlatform>
+    for omicron_common::api::external::InstanceCpuPlatform
+{
+    fn from(value: InstanceCpuPlatform) -> Self {
+        match value {
+            InstanceCpuPlatform::AmdMilan => Self::AmdMilan,
+            InstanceCpuPlatform::AmdTurin => Self::AmdTurin,
+        }
+    }
+}

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,