[Sled Agent] Expunged disks are not in use after omicron_physical_disks_ensure

sled-agent/src/instance_manager.rs

@@ -333,7 +333,10 @@ impl InstanceManager {
     ///
     /// This function looks for transient zone filesystem usage on expunged
     /// zpools.
-    pub async fn only_use_disks(&self, disks: AllDisks) -> Result<(), Error> {
+    pub async fn use_only_these_disks(
+        &self,
+        disks: AllDisks,
+    ) -> Result<(), Error> {
         let (tx, rx) = oneshot::channel();
         self.inner
             .tx
@@ -517,7 +520,7 @@ impl InstanceManagerRunner {
                             self.get_instance_state(tx, instance_id).await
                         },
                         Some(OnlyUseDisks { disks, tx } ) => {
-                            self.only_use_disks(disks).await;
+                            self.use_only_these_disks(disks).await;
                             tx.send(Ok(())).map_err(|_| Error::FailedSendClientClosed)
                         },
                         None => {
@@ -802,23 +805,20 @@ impl InstanceManagerRunner {
         Ok(())
     }
 
-    async fn only_use_disks(
-        &mut self,
-        disks: AllDisks,
-    )  {
+    async fn use_only_these_disks(&mut self, disks: AllDisks) {
         // Consider the generation number on the incoming request to avoid
         // applying old requests.
         let requested_generation = *disks.generation();
         if let Some(last_gen) = self.storage_generation {
             if last_gen >= requested_generation {
                 // This request looks old, ignore it.
-                info!(self.log, "only_use_disks: Ignoring request";
+                info!(self.log, "use_only_these_disks: Ignoring request";
                     "last_gen" => ?last_gen, "requested_gen" => ?requested_generation);
                 return;
             }
         }
         self.storage_generation = Some(requested_generation);
-        info!(self.log, "only_use_disks: Processing new request";
+        info!(self.log, "use_only_these_disks: Processing new request";
             "gen" => ?requested_generation);
 
         let u2_set: HashSet<_> = disks.all_u2_zpools().into_iter().collect();
@@ -830,7 +830,7 @@ impl InstanceManagerRunner {
             let Ok(Some(filesystem_pool)) =
                 instance.get_filesystem_zpool().await
             else {
-                info!(self.log, "only_use_disks: Cannot read filesystem pool"; "instance_id" => ?id);
+                info!(self.log, "use_only_these_disks: Cannot read filesystem pool"; "instance_id" => ?id);
                 continue;
             };
             if !u2_set.contains(&filesystem_pool) {
@@ -839,16 +839,16 @@ impl InstanceManagerRunner {
         }
 
         for id in to_remove {
-            info!(self.log, "only_use_disks: Removing instance"; "instance_id" => ?id);
+            info!(self.log, "use_only_these_disks: Removing instance"; "instance_id" => ?id);
             if let Some((_, instance)) = self.instances.remove(&id) {
                 let (tx, rx) = oneshot::channel();
                 if let Err(e) = instance.terminate(tx).await {
-                    warn!(self.log, "only_use_disks: Failed to request instance removal"; "err" => ?e);
+                    warn!(self.log, "use_only_these_disks: Failed to request instance removal"; "err" => ?e);
                     continue;
                 }
 
                 if let Err(e) = rx.await {
-                    warn!(self.log, "only_use_disks: Failed while removing instance"; "err" => ?e);
+                    warn!(self.log, "use_only_these_disks: Failed while removing instance"; "err" => ?e);
                 }
             }
         }

sled-agent/src/probe_manager.rs

@@ -97,7 +97,7 @@ impl ProbeManager {
 
     /// Removes any probes using filesystem roots on zpools that are not
     /// contained in the set of "disks".
-    pub(crate) async fn only_use_disks(&self, disks: &AllDisks) {
+    pub(crate) async fn use_only_these_disks(&self, disks: &AllDisks) {
         let u2_set: HashSet<_> = disks.all_u2_zpools().into_iter().collect();
         let mut probes = self.inner.running_probes.lock().await;
 
@@ -107,13 +107,13 @@ impl ProbeManager {
         if let Some(last_gen) = probes.storage_generation {
             if last_gen >= requested_generation {
                 // This request looks old, ignore it.
-                info!(self.inner.log, "only_use_disks: Ignoring request";
+                info!(self.inner.log, "use_only_these_disks: Ignoring request";
                     "last_gen" => ?last_gen, "requested_gen" => ?requested_generation);
                 return;
             }
         }
         probes.storage_generation = Some(requested_generation);
-        info!(self.inner.log, "only_use_disks: Processing new request";
+        info!(self.inner.log, "use_only_these_disks: Processing new request";
             "gen" => ?requested_generation);
 
         let to_remove = probes
@@ -122,7 +122,7 @@ impl ProbeManager {
             .filter_map(|(id, probe)| {
                 let Some(probe_pool) = probe.root_zpool() else {
                     // No known pool for this probe
-                    info!(self.inner.log, "only_use_disks: Cannot read filesystem pool"; "id" => ?id);
+                    info!(self.inner.log, "use_only_these_disks: Cannot read filesystem pool"; "id" => ?id);
                     return None;
                 };
 
@@ -135,7 +135,7 @@ impl ProbeManager {
             .collect::<Vec<_>>();
 
         for probe_id in to_remove {
-            info!(self.inner.log, "only_use_disks: Removing probe"; "probe_id" => ?probe_id);
+            info!(self.inner.log, "use_only_these_disks: Removing probe"; "probe_id" => ?probe_id);
             self.inner.remove_probe_locked(&mut probes, probe_id).await;
         }
     }

sled-agent/src/sled_agent.rs

@@ -864,12 +864,12 @@ impl SledAgent {
         // Ensure that all probes, at least after our call to
         // "omicron_physical_disks_ensure", stop using any disks that
         // may have been in-service from before that request.
-        self.inner.probes.only_use_disks(&latest_disks).await;
+        self.inner.probes.use_only_these_disks(&latest_disks).await;
         info!(self.log, "physical disks ensure: Updated probes");
 
         // Do the same for instances - mark them failed if they were using
         // expunged disks.
-        self.inner.instances.only_use_disks(latest_disks).await?;
+        self.inner.instances.use_only_these_disks(latest_disks).await?;
         info!(self.log, "physical disks ensure: Updated instances");
 
         Ok(disk_result)