Remove udev settle and use canonicalized path for crypt activated dev…

…ice path

src/engine/strat_engine/backstore/crypt/handle.rs

@@ -2,7 +2,11 @@
 // License, v. 2.0. If a copy of the MPL was not distributed with this
 // file, You can obtain one at http://mozilla.org/MPL/2.0/.
 
-use std::{fmt::Debug, path::Path};
+use std::{
+    fmt::Debug,
+    iter::once,
+    path::{Path, PathBuf},
+};
 
 use either::Either;
 use serde_json::Value;
@@ -23,6 +27,7 @@ use crate::{
                 },
             },
             cmd::{clevis_decrypt, clevis_luks_bind, clevis_luks_regen, clevis_luks_unbind},
+            dm::DEVICEMAPPER_PATH,
             keys::MemoryPrivateFilesystem,
             metadata::StratisIdentifiers,
         },
@@ -43,6 +48,7 @@ use crate::{
 /// a next crypt device context for each operation.
 #[derive(Debug, Clone)]
 pub struct CryptHandle {
+    activated_path: DevicePath,
     metadata_handle: CryptMetadataHandle,
 }
 
@@ -52,7 +58,7 @@ impl CryptHandle {
         identifiers: StratisIdentifiers,
         encryption_info: EncryptionInfo,
         name: String,
-    ) -> CryptHandle {
+    ) -> StratisResult<CryptHandle> {
         CryptHandle::new_with_metadata_handle(CryptMetadataHandle::new(
             physical_path,
             identifiers,
@@ -61,8 +67,18 @@ impl CryptHandle {
         ))
     }
 
-    pub(super) fn new_with_metadata_handle(metadata_handle: CryptMetadataHandle) -> CryptHandle {
-        CryptHandle { metadata_handle }
+    pub(super) fn new_with_metadata_handle(
+        metadata_handle: CryptMetadataHandle,
+    ) -> StratisResult<CryptHandle> {
+        let activated_path = DevicePath::new(
+            &once(DEVICEMAPPER_PATH)
+                .chain(once(metadata_handle.name()))
+                .collect::<PathBuf>(),
+        )?;
+        Ok(CryptHandle {
+            activated_path,
+            metadata_handle,
+        })
     }
 
     /// Acquire the crypt device handle for the physical path in this `CryptHandle`.
@@ -107,7 +123,7 @@ impl CryptHandle {
     /// storage device. In an encrypted pool, this is the path that can be used to read
     /// the Stratis blockdev metatdata.
     pub fn activated_device_path(&self) -> &Path {
-        self.metadata_handle.activated_path()
+        &*self.activated_path
     }
 
     /// Return the name of the activated devicemapper device.

src/engine/strat_engine/backstore/crypt/initialize.rs

@@ -82,34 +82,31 @@ impl CryptInitializer {
             MetadataSize::try_from(DEFAULT_CRYPT_METADATA_SIZE)?,
             KeyslotsSize::try_from(DEFAULT_CRYPT_KEYSLOTS_SIZE)?,
         )?;
-        let result = self
+        self
             .initialize_with_err(&mut device, key_description, clevis_parsed)
-            .and_then(|path| clevis_info_from_metadata(&mut device).map(|ci| (path, ci)));
-
-        match result {
-            Ok((_, clevis_info)) => {
+            .and_then(|path| clevis_info_from_metadata(&mut device).map(|ci| (path, ci)))
+            .and_then(|(_, clevis_info)| {
                 let encryption_info =
                     EncryptionInfo::from_options((key_description.cloned(), clevis_info))
                         .expect("Encrypted device must be provided encryption parameters");
-                Ok(CryptHandle::new(
-                    self.physical_path,
+                CryptHandle::new(
+                    self.physical_path.clone(),
                     self.identifiers,
                     encryption_info,
-                    self.activation_name,
-                ))
-            }
-            Err(e) => {
+                    self.activation_name.clone(),
+                )
+            })
+            .map_err(|e| {
                 if let Err(err) =
-                    Self::rollback(&mut device, &self.physical_path, self.activation_name)
+                    Self::rollback(&mut device, &self.physical_path, &self.activation_name)
                 {
                     warn!(
                         "Failed to roll back crypt device initialization; you may need to manually wipe this device: {}",
                         err
                     );
                 }
-                Err(e)
-            }
-        }
+                e
+            })
     }
 
     /// Initialize with a passphrase in the kernel keyring only.
@@ -255,8 +252,8 @@ impl CryptInitializer {
     pub fn rollback(
         device: &mut CryptDevice,
         physical_path: &Path,
-        name: String,
+        name: &str,
     ) -> StratisResult<()> {
-        ensure_wiped(device, physical_path, &name)
+        ensure_wiped(device, physical_path, name)
     }
 }

src/engine/strat_engine/backstore/crypt/metadata_handle.rs

@@ -2,16 +2,12 @@
 // License, v. 2.0. If a copy of the MPL was not distributed with this
 // file, You can obtain one at http://mozilla.org/MPL/2.0/.
 
-use std::{
-    iter::once,
-    path::{Path, PathBuf},
-};
+use std::path::Path;
 
 use crate::{
     engine::{
         strat_engine::{
             backstore::crypt::shared::{setup_crypt_device, setup_crypt_metadata_handle},
-            dm::DEVICEMAPPER_PATH,
             metadata::StratisIdentifiers,
         },
         types::{DevicePath, EncryptionInfo},
@@ -26,7 +22,6 @@ pub struct CryptMetadataHandle {
     pub(super) identifiers: StratisIdentifiers,
     pub(super) encryption_info: EncryptionInfo,
     pub(super) name: String,
-    pub(super) activated_path: PathBuf,
 }
 
 impl CryptMetadataHandle {
@@ -40,10 +35,7 @@ impl CryptMetadataHandle {
             physical_path,
             identifiers,
             encryption_info,
-            name: name.clone(),
-            activated_path: once(DEVICEMAPPER_PATH.to_string())
-                .chain(once(name))
-                .collect::<PathBuf>(),
+            name,
         }
     }
 
@@ -75,9 +67,4 @@ impl CryptMetadataHandle {
     pub fn name(&self) -> &str {
         &self.name
     }
-
-    /// Get the path of the activated device.
-    pub fn activated_path(&self) -> &Path {
-        &self.activated_path
-    }
 }

src/engine/strat_engine/backstore/crypt/shared.rs

@@ -300,7 +300,19 @@ pub fn setup_crypt_handle(
         },
     };
 
-    Ok(Some(CryptHandle::new_with_metadata_handle(metadata_handle)))
+    match CryptHandle::new_with_metadata_handle(metadata_handle) {
+        Ok(h) => Ok(Some(h)),
+        Err(e) => {
+            if let Err(err) = ensure_inactive(device, &name) {
+                Err(StratisError::NoActionRollbackError {
+                    causal_error: Box::new(e),
+                    rollback_error: Box::new(err),
+                })
+            } else {
+                Err(e)
+            }
+        }
+    }
 }
 
 /// Create a device handle and load the LUKS2 header into memory from

src/engine/strat_engine/liminal/liminal.rs

@@ -17,7 +17,6 @@ use crate::{
         engine::Pool,
         strat_engine::{
             backstore::{CryptActivationHandle, CryptHandle},
-            cmd::udev_settle,
             liminal::{
                 device_info::{DeviceSet, LInfo, LLuksInfo, LStratisInfo},
                 identify::{
@@ -192,9 +191,6 @@ impl LiminalDevices {
             .stopped_pools
             .remove(&pool_uuid)
             .expect("Checked above");
-        if let Err(e) = udev_settle() {
-            warn!("Failed to wait for udev processing to complete: {}", e);
-        }
         match find_pool_stratis_devices(
             unlocked_devices
                 .iter()