Support RTC updates from illumos 15462

This also addresses some backward-compatibility issues around the
vmm-data interface, for both the VMM_ARCH and VMM_TIME classes.

Author: pfmooney

Cargo.lock

@@ -3,7 +3,7 @@ use std::fs::File;
 use std::io::{Error, ErrorKind};
 use std::num::NonZeroUsize;
 use std::sync::Arc;
-use std::time::SystemTime;
+use std::time::{SystemTime, UNIX_EPOCH};
 
 use oximeter::types::ProducerRegistry;
 use propolis::block;
@@ -146,7 +146,11 @@ impl<'a> MachineInitializer<'a> {
 
         let rtc = &self.machine.kernel_devs.rtc;
         rtc.memsize_to_nvram(lowmem as u32, highmem as u64)?;
-        rtc.set_time(SystemTime::now())?;
+        rtc.set_time(
+            SystemTime::now()
+                .duration_since(UNIX_EPOCH)
+                .expect("system time precedes UNIX epoch"),
+        )?;
 
         Ok(())
     }

bin/propolis-server/src/lib/initializer.rs

@@ -10,6 +10,7 @@ path = "src/main.rs"
 
 [dependencies]
 anyhow.workspace = true
+bhyve_api.workspace = true
 clap = { workspace = true, features = ["derive"] }
 ctrlc.workspace = true
 futures.workspace = true

bin/propolis-standalone/Cargo.toml

@@ -4,7 +4,7 @@ use std::io::{Error, ErrorKind, Result};
 use std::path::Path;
 use std::sync::atomic::{AtomicUsize, Ordering};
 use std::sync::{Arc, Condvar, Mutex, MutexGuard};
-use std::time::SystemTime;
+use std::time::{SystemTime, UNIX_EPOCH};
 
 use anyhow::Context;
 use clap::Parser;
@@ -709,7 +709,11 @@ fn setup_instance(
 
     let rtc = &machine.kernel_devs.rtc;
     rtc.memsize_to_nvram(lowmem as u32, highmem as u64)?;
-    rtc.set_time(SystemTime::now())?;
+    rtc.set_time(
+        SystemTime::now()
+            .duration_since(UNIX_EPOCH)
+            .expect("system time precedes UNIX epoch"),
+    )?;
 
     let (power_pin, reset_pin) = inst.generate_pins();
     let pci_topo =

bin/propolis-standalone/src/main.rs

@@ -18,12 +18,19 @@ use std::path::Path;
 use std::sync::Arc;
 
 use anyhow::Context;
+use bhyve_api::{
+    vdi_field_entry_v1, vdi_time_info_v1, ApiVersion, VAI_BOOT_HRTIME,
+    VDC_VMM_ARCH, VDC_VMM_TIME,
+};
+use propolis::vmm::data as vmm_data;
 use propolis::{
     chardev::UDSock,
     common::{GuestAddr, GuestRegion},
     inventory::Order,
     migrate::{MigrateCtx, Migrator},
+    vmm::VmmHdl,
 };
+
 use slog::{info, warn};
 use tokio::{
     fs::File,
@@ -57,9 +64,9 @@ pub(crate) async fn save(
 
     info!(log, "Serializing global VM state");
     let global_state = {
-        let global_state =
-            hdl.export().context("Failed to export global VM state")?;
-        serde_json::to_vec(&global_state)?
+        let output =
+            export_global(&hdl).context("Failed to export global VM state")?;
+        serde_json::to_vec(&output)?
     };
 
     info!(log, "Serializing VM device state");
@@ -223,13 +230,12 @@ pub(crate) async fn restore(
         let state_len = file.read_u64().await?;
         let mut global_state = vec![0; state_len.try_into()?];
         file.read_exact(&mut global_state).await?;
-        let mut deserializer =
-            serde_json::Deserializer::from_slice(&global_state);
-        let deserializer =
-            &mut <dyn erased_serde::Deserializer>::erase(&mut deserializer);
 
-        // Restore it
-        hdl.import(deserializer).context("Failed to import global VM state")?;
+        let data: VmGlobalState = serde_json::from_slice(&global_state)
+            .context("Failed to deserialize global VM state")?;
+
+        import_global(&hdl, &data)
+            .context("failed to import global VM state")?;
     }
 
     // Next are the devices
@@ -333,3 +339,48 @@ pub(crate) async fn restore(
     drop(inst_inner);
     Ok((inst, com1_sock))
 }
+
+#[derive(serde::Serialize, serde::Deserialize)]
+pub struct VmGlobalState {
+    // Just using the raw boot_hrtime leaves room for all sorts of failures,
+    // especially if a saved state file is used after a subsequent reboot of the
+    // host.  These problems can be addressed later.
+    pub boot_hrtime: i64,
+    // Fixing up the guest TSC is left as an exercise for later
+}
+
+fn export_global(hdl: &VmmHdl) -> std::io::Result<VmGlobalState> {
+    if hdl.api_version()? > ApiVersion::V11.into() {
+        let info: vdi_time_info_v1 = vmm_data::read(hdl, -1, VDC_VMM_TIME, 1)?;
+
+        Ok(VmGlobalState { boot_hrtime: info.vt_boot_hrtime })
+    } else {
+        let arch_entries: Vec<bhyve_api::vdi_field_entry_v1> =
+            vmm_data::read_many(hdl, -1, VDC_VMM_ARCH, 1)?;
+        let boot_ent = arch_entries
+            .iter()
+            .find(|ent| ent.vfe_ident == VAI_BOOT_HRTIME)
+            .expect("VAI_BOOT_HRTIME should be present");
+
+        Ok(VmGlobalState { boot_hrtime: boot_ent.vfe_value as i64 })
+    }
+}
+fn import_global(hdl: &VmmHdl, state: &VmGlobalState) -> std::io::Result<()> {
+    if hdl.api_version()? > ApiVersion::V11.into() {
+        let mut info: vdi_time_info_v1 =
+            vmm_data::read(hdl, -1, VDC_VMM_TIME, 1)?;
+
+        info.vt_boot_hrtime = state.boot_hrtime;
+        vmm_data::write(hdl, -1, VDC_VMM_TIME, 1, info)?;
+
+        Ok(())
+    } else {
+        let arch_entry = vdi_field_entry_v1 {
+            vfe_ident: VAI_BOOT_HRTIME,
+            vfe_value: state.boot_hrtime as u64,
+            ..Default::default()
+        };
+        vmm_data::write(hdl, -1, VDC_VMM_ARCH, 1, arch_entry)?;
+        Ok(())
+    }
+}

bin/propolis-standalone/src/snapshot.rs

@@ -44,16 +44,10 @@ fn print_globals(mut fp: File, len: u64) -> anyhow::Result<()> {
     let mut buf = vec![0u8; len as usize];
     fp.read_exact(&mut buf[..])?;
 
-    let data: propolis::vmm::migrate::BhyveVmV1 = serde_json::from_slice(&buf)?;
+    let data: serde_json::Value = serde_json::from_slice(&buf)?;
 
-    println!("Global entries:");
-    if !data.arch_entries.is_empty() {
-        for ent in data.arch_entries {
-            println!("{:08X} = {}", ent.ident, ent.value);
-        }
-    } else {
-        println!("None");
-    }
+    println!("Global data:");
+    println!("{:?}", data);
 
     Ok(())
 }

bin/propolis-utils/src/bin/savex.rs

@@ -12,6 +12,8 @@ libc = "0.2"
 [build-dependencies]
 cc = "1"
 ctest2 = "0.4"
+# Build-time conditions depend on the max API version defined in the crate
+bhyve_api_sys = { path = "../sys" }
 
 [[test]]
 name = "main"

crates/bhyve-api/header-check/Cargo.toml

@@ -3,10 +3,31 @@
 use std::convert::TryFrom;
 use std::env;
 use std::path::PathBuf;
+use std::str::FromStr;
+use std::sync::atomic::{AtomicU32, Ordering};
+
+extern crate bhyve_api_sys;
+use bhyve_api_sys::VMM_CURRENT_INTERFACE_VERSION;
+
+static CHECK_VERSION: AtomicU32 = AtomicU32::new(VMM_CURRENT_INTERFACE_VERSION);
+
+/// Source checked against has API version greater than `ver` argument
+fn ver_gt(ver: u32) -> bool {
+    CHECK_VERSION.load(Ordering::Relaxed) > ver
+}
+/// Source checked against has API version less than `ver` argument
+fn ver_lt(ver: u32) -> bool {
+    CHECK_VERSION.load(Ordering::Relaxed) < ver
+}
+/// Source checked against has API version equal to `ver` argument
+fn ver_eq(ver: u32) -> bool {
+    CHECK_VERSION.load(Ordering::Relaxed) == ver
+}
 
 fn main() {
     let mut cfg = ctest2::TestGenerator::new();
 
+    // We cannot proceed without a path to the source
     let gate_dir = match env::var("GATE_SRC").map(PathBuf::try_from) {
         Ok(Ok(dir)) => dir,
         _ => {
@@ -15,6 +36,26 @@ fn main() {
         }
     };
 
+    // Allow the user to specify a target interface version to check against.
+    match env::var("API_VERSION").ok().map(|v| u32::from_str(&v)) {
+        Some(Ok(ver)) => {
+            if ver > VMM_CURRENT_INTERFACE_VERSION {
+                eprintln!(
+                    "API_VERSION {} cannot be > \
+                    VMM_CURRENT_INTERFACE_VERSION ({})",
+                    ver, VMM_CURRENT_INTERFACE_VERSION
+                );
+                std::process::exit(1);
+            }
+            CHECK_VERSION.store(ver, Ordering::Relaxed);
+        }
+        Some(Err(e)) => {
+            eprintln!("Invalid API_VERSION {:?}", e);
+            std::process::exit(1);
+        }
+        _ => {}
+    }
+
     let include_paths = [
         // For #include_next to work, these need to be first
         "usr/src/compat/bhyve",
@@ -46,6 +87,23 @@ fn main() {
         // We expose our own copy for now for us as a constraint.
         "VM_MAXCPU" => true,
 
+        // Do not bother checking the version definition define if we are
+        // assuming the source is from a different version.
+        "VMM_CURRENT_INTERFACE_VERSION"
+            if !ver_eq(VMM_CURRENT_INTERFACE_VERSION) =>
+        {
+            true
+        }
+
+        // API V11 saw the removal of several time-realted VMM_ARCH defines
+        "VAI_TSC_BOOT_OFFSET" | "VAI_BOOT_HRTIME" | "VAI_TSC_FREQ"
+            if ver_gt(10) =>
+        {
+            true
+        }
+        // API V11 saw the addition of the VMM_TIME data class
+        "VDC_VMM_TIME" if ver_lt(11) => true,
+
         _ => false,
     });
 
@@ -64,6 +122,14 @@ fn main() {
         "vm_inst_emul" => true,
         "vm_paging" => true,
 
+        // In API V12, the RTC data struct was revised to v2, with the old v1
+        // definition being removed.
+        "vdi_rtc_v1" if ver_gt(11) => true,
+        "vdi_rtc_v2" if ver_lt(12) => true,
+
+        // VMM_TIME struct added in API V11
+        "vdi_time_info_v1" if ver_lt(11) => true,
+
         _ => false,
     });