install: Only switch to loopback after re-exec

lib/src/blockdev.rs

@@ -89,6 +89,7 @@ impl LoopbackDevice {
             .quiet()
             .read()?;
         let dev = Utf8PathBuf::from(dev.trim());
+        tracing::debug!("Allocated loopback {dev}");
         Ok(Self { dev: Some(dev) })
     }
 
@@ -104,6 +105,7 @@ impl LoopbackDevice {
         let dev = if let Some(dev) = self.dev.take() {
             dev
         } else {
+            tracing::trace!("loopback device already deallocated");
             return Ok(());
         };
         Task::new("losetup", "losetup")

lib/src/install.rs

@@ -1088,27 +1088,35 @@ pub(crate) async fn install_to_disk(opts: InstallToDiskOpts) -> Result<()> {
         .device
         .metadata()
         .with_context(|| format!("Querying {}", &block_opts.device))?;
-    let mut loopback = None;
     if opts.via_loopback {
         if !target_blockdev_meta.file_type().is_file() {
             anyhow::bail!(
                 "Not a regular file (to be used via loopback): {}",
                 block_opts.device
             );
         }
-        let loopback_dev = crate::blockdev::LoopbackDevice::new(block_opts.device.as_std_path())?;
-        block_opts.device = loopback_dev.path().into();
-        loopback = Some(loopback_dev);
     } else if !target_blockdev_meta.file_type().is_block_device() {
         anyhow::bail!("Not a block device: {}", block_opts.device);
     }
     let state = prepare_install(opts.config_opts, opts.source_opts, opts.target_opts).await?;
 
     // This is all blocking stuff
-    let mut rootfs = {
+    let (mut rootfs, loopback) = {
+        let loopback_dev = if opts.via_loopback {
+            let loopback_dev =
+                crate::blockdev::LoopbackDevice::new(block_opts.device.as_std_path())?;
+            block_opts.device = loopback_dev.path().into();
+            Some(loopback_dev)
+        } else {
+            None
+        };
+
         let state = state.clone();
-        tokio::task::spawn_blocking(move || baseline::install_create_rootfs(&state, block_opts))
-            .await??
+        let rootfs = tokio::task::spawn_blocking(move || {
+            baseline::install_create_rootfs(&state, block_opts)
+        })
+        .await??;
+        (rootfs, loopback_dev)
     };
 
     install_to_filesystem_impl(&state, &mut rootfs).await?;