Support soft shutdown via ACPI PWRBTN_STS

bin/propolis-cli/src/main.rs

@@ -39,7 +39,10 @@ use uuid::Uuid;
 
 use propolis_client::{
     support::{InstanceSerialConsoleHelper, WSClientOffset},
-    types::{InstanceStateRequested, InstanceVcrReplace, MigrationState},
+    types::{
+        InstanceStateChange, InstanceStateRequested, InstanceVcrReplace,
+        MigrationState,
+    },
     Client,
 };
 
@@ -118,6 +121,9 @@ enum Command {
         /// The requested state
         #[clap(value_parser = parse_state)]
         state: InstanceStateRequested,
+        /// The number of seconds to wait after sending ACPI PWRBTN_STS before
+        /// forcing stop/reset. (If omitted, stop/reset are forced immediately)
+        acpi_timeout_secs: Option<u64>,
     },
 
     /// Drop to a Serial console connected to the instance
@@ -572,10 +578,11 @@ async fn get_instance(client: &Client) -> anyhow::Result<()> {
 async fn put_instance(
     client: &Client,
     state: InstanceStateRequested,
+    acpi_timeout_secs: Option<u64>,
 ) -> anyhow::Result<()> {
     client
         .instance_state_put()
-        .body(state)
+        .body(InstanceStateChange { state, acpi_timeout_secs })
         .send()
         .await
         .with_context(|| anyhow!("failed to set instance state"))?;
@@ -958,7 +965,9 @@ async fn main() -> anyhow::Result<()> {
             .await?
         }
         Command::Get => get_instance(&client).await?,
-        Command::State { state } => put_instance(&client, state).await?,
+        Command::State { state, acpi_timeout_secs } => {
+            put_instance(&client, state, acpi_timeout_secs).await?
+        }
         Command::Serial { byte_offset } => {
             serial(addr, byte_offset, log).await?
         }

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

@@ -189,6 +189,7 @@ pub fn build_instance(
 pub struct RegisteredChipset {
     chipset: Arc<dyn Chipset>,
     isa: Arc<i440fx::Piix3Lpc>,
+    pm: Arc<i440fx::Piix3PM>,
 }
 impl RegisteredChipset {
     pub fn pci_attach(&self, bdf: pci::Bdf, dev: Arc<dyn pci::Endpoint>) {
@@ -197,6 +198,9 @@ impl RegisteredChipset {
     pub fn irq_pin(&self, irq: u8) -> Option<Box<dyn intr_pins::IntrPin>> {
         self.isa.irq_pin(irq)
     }
+    pub fn acpi_shutdown(&self) {
+        self.pm.acpi_shutdown();
+    }
     fn reset_pin(&self) -> Arc<dyn intr_pins::IntrPin> {
         self.chipset.reset_pin()
     }
@@ -356,6 +360,7 @@ impl MachineInitializer<'_> {
                 let chipset_pm = i440fx::Piix3PM::create(
                     self.machine.hdl.clone(),
                     chipset_hb.power_pin(),
+                    chipset_lpc.sci_pin(),
                     self.log.new(slog::o!("device" => "piix3pm")),
                 );
 
@@ -387,7 +392,7 @@ impl MachineInitializer<'_> {
                 );
                 self.devices.insert(
                     SpecKey::Name(chipset_pm.type_name().into()),
-                    chipset_pm,
+                    chipset_pm.clone(),
                 );
 
                 // Record attachment for any bridges in PCI topology too
@@ -404,7 +409,11 @@ impl MachineInitializer<'_> {
                     self.devices.insert(spec_element.0.clone(), bridge);
                 }
 
-                Ok(RegisteredChipset { chipset: chipset_hb, isa: chipset_lpc })
+                Ok(RegisteredChipset {
+                    chipset: chipset_hb,
+                    isa: chipset_lpc,
+                    pm: chipset_pm,
+                })
             }
         }
     }

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

@@ -43,7 +43,7 @@ use propolis_api_types::disk::{
 };
 use propolis_api_types::instance::{
     ErrorCode, Instance, InstanceEnsureRequest, InstanceEnsureResponse,
-    InstanceGetResponse, InstanceInitializationMethod,
+    InstanceGetResponse, InstanceInitializationMethod, InstanceStateChange,
     InstanceStateMonitorRequest, InstanceStateMonitorResponse,
     InstanceStateRequested,
 };
@@ -364,13 +364,13 @@ impl PropolisServerApi for PropolisServerImpl {
 
     async fn instance_state_put(
         rqctx: RequestContext<Self::Context>,
-        request: TypedBody<InstanceStateRequested>,
+        request: TypedBody<InstanceStateChange>,
     ) -> Result<HttpResponseUpdatedNoContent, HttpError> {
         let ctx = rqctx.context();
-        let requested_state = request.into_inner();
+        let requested_change = request.into_inner();
         let vm = ctx.vm.active_vm().await.ok_or_else(not_created_error)?;
         let result = vm
-            .put_state(requested_state)
+            .put_state(requested_change)
             .map(|_| HttpResponseUpdatedNoContent {})
             .map_err(|e| match e {
                 VmError::WaitingToInitialize => HttpError::for_unavail(
@@ -391,7 +391,7 @@ impl PropolisServerApi for PropolisServerImpl {
             });
 
         if result.is_ok() {
-            if let InstanceStateRequested::Reboot = requested_state {
+            if let InstanceStateRequested::Reboot = requested_change.state {
                 let stats = MutexGuard::map(
                     vm.services().oximeter.lock().await,
                     |state| &mut state.stats,

bin/propolis-server/src/lib/vm/active.rs

@@ -5,15 +5,17 @@
 //! Implements a wrapper around an active VM.
 
 use std::sync::Arc;
+use std::time::Duration;
 
 use propolis_api_types::instance::{
-    InstanceProperties, InstanceStateRequested,
+    InstanceProperties, InstanceStateChange, InstanceStateRequested,
 };
 use propolis_api_types::instance_spec::SpecKey;
 use slog::info;
 use uuid::Uuid;
 
-use crate::vm::request_queue::ExternalRequest;
+use crate::vm::request_queue::{ExternalRequest, RequestDeniedReason};
+use crate::vm::SoftShutdownFate;
 
 use super::{
     objects::VmObjects, services::VmServices, CrucibleReplaceResultTx,
@@ -57,17 +59,31 @@ impl ActiveVm {
     /// Pushes a state change request to the VM's state change queue.
     pub(crate) fn put_state(
         &self,
-        requested: InstanceStateRequested,
+        requested: InstanceStateChange,
     ) -> Result<(), VmError> {
         info!(self.log, "requested state via API";
-              "state" => ?requested);
-
-        self.state_driver_queue
-            .queue_external_request(match requested {
+              "state" => ?requested.state,
+              "timeout" => ?requested.acpi_timeout_secs);
+
+        let ext_req = if let Some(secs) = requested.acpi_timeout_secs {
+            let timeout = Duration::from_secs(secs);
+            let fate = match requested.state {
+                InstanceStateRequested::Run => {
+                    return Err(RequestDeniedReason::TimeoutOnRun.into());
+                }
+                InstanceStateRequested::Stop => SoftShutdownFate::Stop,
+                InstanceStateRequested::Reboot => SoftShutdownFate::Reboot,
+            };
+            ExternalRequest::acpi_shutdown(fate, timeout)
+        } else {
+            match requested.state {
                 InstanceStateRequested::Run => ExternalRequest::start(),
                 InstanceStateRequested::Stop => ExternalRequest::stop(),
                 InstanceStateRequested::Reboot => ExternalRequest::reboot(),
-            })
+            }
+        };
+        self.state_driver_queue
+            .queue_external_request(ext_req)
             .map_err(Into::into)
     }
 

bin/propolis-server/src/lib/vm/ensure.rs

@@ -656,6 +656,7 @@ async fn initialize_vm_objects(
         framebuffer: Some(ramfb),
         ps2ctrl,
         attest_handle,
+        chipset: chipset.into(),
     };
 
     // Another really terrible hack. As we've found in Propolis#1008, brk()

bin/propolis-server/src/lib/vm/mod.rs

@@ -164,6 +164,13 @@ const VMM_MIN_RT_THREADS: usize = 8;
 /// is greater.
 const VMM_BASE_RT_THREADS: usize = 4;
 
+/// The action to take after an ACPI shutdown either completes or times out.
+#[derive(Clone, Copy, Debug)]
+pub enum SoftShutdownFate {
+    Stop,
+    Reboot,
+}
+
 /// Errors generated by the VM controller and its subcomponents.
 #[derive(Debug, thiserror::Error)]
 pub(crate) enum VmError {

bin/propolis-server/src/lib/vm/objects.rs

@@ -22,7 +22,10 @@ use propolis_api_types::instance_spec::SpecKey;
 use slog::info;
 use tokio::sync::{RwLock, RwLockReadGuard, RwLockWriteGuard};
 
-use crate::{serial::Serial, spec::Spec, vcpu_tasks::VcpuTaskController};
+use crate::{
+    initializer::RegisteredChipset, serial::Serial, spec::Spec,
+    vcpu_tasks::VcpuTaskController,
+};
 
 use super::{BlockBackendMap, CrucibleBackendMap, DeviceMap};
 
@@ -53,6 +56,7 @@ pub(super) struct InputVmObjects {
     pub framebuffer: Option<Arc<RamFb>>,
     pub ps2ctrl: Arc<PS2Ctrl>,
     pub attest_handle: Option<attestation::server::AttestationSock>,
+    pub chipset: Arc<RegisteredChipset>,
 }
 
 /// The collection of objects and state that make up a Propolis instance.
@@ -91,6 +95,9 @@ pub(crate) struct VmObjectsLocked {
 
     /// A handle to the VM's attestation server.
     attest_handle: Option<attestation::server::AttestationSock>,
+
+    /// A handle to the VM's mainboard chipset.
+    chipset: Arc<RegisteredChipset>,
 }
 
 impl VmObjects {
@@ -132,6 +139,7 @@ impl VmObjectsLocked {
             framebuffer: input.framebuffer,
             ps2ctrl: input.ps2ctrl,
             attest_handle: input.attest_handle,
+            chipset: input.chipset,
         }
     }
 
@@ -194,6 +202,11 @@ impl VmObjectsLocked {
         &self.ps2ctrl
     }
 
+    /// Yields a clonable reference to this VM's mainboard chipset.
+    pub(crate) fn chipset(&self) -> &Arc<RegisteredChipset> {
+        &self.chipset
+    }
+
     pub(crate) fn device_map(&self) -> &DeviceMap {
         &self.devices
     }