diff --git a/src/builder.rs b/src/builder.rs
index 50d4f8c..17049c3 100644
--- a/src/builder.rs
+++ b/src/builder.rs
@@ -63,7 +63,7 @@ impl RootBuilder for DnfRootBuilder {
 	fn build(&self, chroot: &Path, manifest: &Manifest) -> Result<()> {
 		info!("Running Pre-install scripts");
 
-		run_all_scripts(manifest.scripts.pre.clone(), chroot, false)?;
+		run_all_scripts(&manifest.scripts.pre, chroot, false)?;
 
 		if let Some(disk) = &manifest.disk {
 			let f = disk.fstab(chroot)?;
@@ -102,32 +102,27 @@ impl RootBuilder for DnfRootBuilder {
 		}
 		options.append(&mut exclude.iter().map(|p| format!("--exclude={p}")).collect());
 
-		// todo: maybe not unwrap?
 		util::run_with_chroot(chroot, || -> Result<()> {
 			cmd_lib::run_cmd!(
-				dnf install -y --releasever=${releasever} --installroot=${chroot} $[packages] $[options];
-				dnf clean all --installroot=${chroot};
+				dnf install -y --releasever=$releasever --installroot=$chroot $[packages] $[options];
+				dnf clean all --installroot=$chroot;
 			)?;
 			Ok(())
 		})?;
 
 		info!("Setting up users");
 
-		let users = &manifest.users;
-
-		if users.is_empty() {
+		if manifest.users.is_empty() {
 			warn!("No users specified, no users will be created!");
 		} else {
-			for user in users {
-				user.add_to_chroot(chroot)?;
-			}
+			manifest.users.iter().try_for_each(|user| user.add_to_chroot(chroot))?;
 		}
 
 		// now, let's run some funny post-install scripts
 
 		info!("Running post-install scripts");
 
-		run_all_scripts(manifest.scripts.post.clone(), &chroot, true)?;
+		run_all_scripts(&manifest.scripts.post, &chroot, true)?;
 
 		Ok(())
 	}
@@ -180,10 +175,10 @@ pub fn run_script(script: Script, chroot: &Path, in_chroot: bool) -> Result<()>
 	Ok(())
 }
 
-pub fn run_all_scripts(scripts: Vec<Script>, chroot: &Path, in_chroot: bool) -> Result<()> {
+pub fn run_all_scripts(scripts: &[Script], chroot: &Path, in_chroot: bool) -> Result<()> {
 	let mut scrs: HashMap<String, (Script, bool)> = HashMap::new();
 	scripts.into_iter().for_each(|s| {
-		scrs.insert(s.id.clone().unwrap_or("<?>".into()), (s, false));
+		scrs.insert(s.id.clone().unwrap_or("<?>".into()), (s.clone(), false));
 	});
 	run_scripts(scrs, chroot, in_chroot)
 }
@@ -219,7 +214,7 @@ pub fn run_scripts(
 }
 
 pub trait ImageBuilder {
-	fn build(&self, chroot: PathBuf, image: PathBuf, manifest: &Manifest) -> Result<()>;
+	fn build(&self, chroot: &Path, image: &Path, manifest: &Manifest) -> Result<()>;
 }
 /// Creates a disk image, then installs to it
 pub struct DiskImageBuilder {
@@ -229,7 +224,7 @@ pub struct DiskImageBuilder {
 }
 
 impl ImageBuilder for DiskImageBuilder {
-	fn build(&self, chroot: PathBuf, image: PathBuf, manifest: &Manifest) -> Result<()> {
+	fn build(&self, chroot: &Path, image: &Path, manifest: &Manifest) -> Result<()> {
 		// create sparse file on disk
 		let sparse_path = &image.canonicalize()?.join("katsu.img");
 		debug!(image = ?sparse_path, "Creating sparse file");
@@ -271,7 +266,7 @@ impl ImageBuilder for DiskImageBuilder {
 
 		self.root_builder.build(&chroot.canonicalize()?, manifest)?;
 
-		disk.unmount_from_chroot(&ldp, &chroot)?;
+		disk.unmount_from_chroot(&ldp, chroot)?;
 		loopdev.detach()?;
 
 		Ok(())
@@ -287,7 +282,7 @@ pub struct DeviceInstaller {
 }
 
 impl ImageBuilder for DeviceInstaller {
-	fn build(&self, chroot: PathBuf, image: PathBuf, manifest: &Manifest) -> Result<()> {
+	fn build(&self, chroot: &Path, image: &Path, manifest: &Manifest) -> Result<()> {
 		todo!();
 		self.root_builder.build(&chroot, manifest)?;
 		Ok(())
@@ -300,24 +295,18 @@ pub struct IsoBuilder {
 }
 
 impl IsoBuilder {
-	pub fn squashfs(&self, chroot: PathBuf, image: PathBuf) -> Result<()> {
-		// todo!();
-		cmd_lib::run_cmd!(
-			mksquashfs ${chroot} ${image} -comp xz -Xbcj x86 -b 1048576 -noappend;
-		)?;
+	pub fn squashfs(&self, chroot: &Path, image: &Path) -> Result<()> {
+		cmd_lib::run_cmd!(mksquashfs $chroot $image -comp xz -Xbcj x86 -b 1048576 -noappend)?;
 		Ok(())
 	}
-	pub fn erofs(&self, chroot: PathBuf, image: PathBuf) -> Result<()> {
-		// todo!();
-		cmd_lib::run_cmd!(
-			mkfs.erofs -d ${chroot} -o ${image};
-		)?;
+	pub fn erofs(&self, chroot: &Path, image: &Path) -> Result<()> {
+		cmd_lib::run_cmd!(mkfs.erofs -d $chroot -o $image)?;
 		Ok(())
 	}
 }
 
 impl ImageBuilder for IsoBuilder {
-	fn build(&self, chroot: PathBuf, image: PathBuf, manifest: &Manifest) -> Result<()> {
+	fn build(&self, chroot: &Path, image: &Path, manifest: &Manifest) -> Result<()> {
 		// Create workspace directory
 		let workspace = chroot.parent().unwrap().to_path_buf();
 		debug!("Workspace: {workspace:#?}");
@@ -325,11 +314,11 @@ impl ImageBuilder for IsoBuilder {
 		self.root_builder.build(&chroot, manifest)?;
 
 		// Create image directory
-		let image = workspace.join("image");
-		fs::create_dir_all(image.clone())?;
+		let image_dir = workspace.join("image");
+		fs::create_dir_all(&image_dir)?;
 
 		// generate squashfs
-		self.squashfs(chroot.clone(), image.clone())?;
+		self.squashfs(&chroot, &image)?;
 
 		Ok(())
 	}
@@ -375,7 +364,7 @@ impl KatsuBuilder {
 		let image = workdir.join("image");
 		fs::create_dir_all(&image)?;
 
-		self.image_builder.build(chroot, image, &self.manifest)?;
+		self.image_builder.build(&chroot, &image, &self.manifest)?;
 
 		// chroot_run_cmd!(chroot, unshare -R ${chroot} bash -c "echo woo")?;
 		Ok(())
diff --git a/src/cli.rs b/src/cli.rs
index a926bbc..95f0bc3 100644
--- a/src/cli.rs
+++ b/src/cli.rs
@@ -38,7 +38,7 @@ impl std::str::FromStr for OutputFormat {
 			"iso" => Ok(OutputFormat::Iso),
 			"disk-image" => Ok(OutputFormat::DiskImage),
 			"device" => Ok(OutputFormat::Device),
-			_ => Err(format!("{} is not a valid output format", s)),
+			_ => Err(format!("{s} is not a valid output format")),
 		}
 	}
 }
@@ -50,9 +50,9 @@ pub fn parse(cli: KatsuCli) -> Result<()> {
 
 	sudo::escalate_if_needed().unwrap();
 
-	let manifest = Manifest::load_all(cli.config.unwrap())?;
+	let manifest = Manifest::load_all(&cli.config.unwrap())?;
 
-	trace!(man = ?manifest, "Loaded manifest");
+	trace!(?manifest, "Loaded manifest");
 
 	let builder = KatsuBuilder::new(manifest, cli.output)?;
 
diff --git a/src/config.rs b/src/config.rs
index 92e48b3..b50ead1 100644
--- a/src/config.rs
+++ b/src/config.rs
@@ -44,8 +44,8 @@ pub struct Manifest {
 
 impl Manifest {
 	/// Loads a single manifest from a file
-	pub fn load(path: PathBuf) -> Result<Self> {
-		let mut manifest: Self = serde_yaml::from_str(&std::fs::read_to_string(path.clone())?)?;
+	pub fn load(path: &Path) -> Result<Self> {
+		let mut manifest: Self = serde_yaml::from_str(&std::fs::read_to_string(path)?)?;
 
 		// get dir of path relative to cwd
 
@@ -56,27 +56,23 @@ impl Manifest {
 
 		for import in &mut manifest.import {
 			debug!("Import: {import:#?}");
-			// swap canonicalized path
-			let cn = path_can.join(&import).canonicalize()?;
-			debug!("Canonicalized import: {cn:#?}");
-			*import = cn;
+			*import = path_can.join(&import).canonicalize()?;
+			debug!("Canonicalized import: {import:#?}");
 		}
 
 		// canonicalize all file paths in scripts, then modify their paths put in the manifest
 
 		for script in &mut manifest.scripts.pre {
 			if let Some(f) = script.file.as_mut() {
-				trace!(f = ?f, "Loading Script file");
-				let cn = path_can.join(&f).canonicalize()?;
-				*f = cn;
+				trace!(?f, "Loading pre scripts");
+				*f = path_can.join(&f).canonicalize()?;
 			}
 		}
 
 		for script in &mut manifest.scripts.post {
 			if let Some(f) = script.file.as_mut() {
-				trace!(f = ?f, "Loading script file");
-				let cn = path_can.join(&f).canonicalize()?;
-				*f = cn;
+				trace!(?f, "Loading post scripts");
+				*f = path_can.join(&f).canonicalize()?;
 			}
 		}
 
@@ -93,17 +89,17 @@ impl Manifest {
 		imports
 	} */
 
-	pub fn load_all(path: PathBuf) -> Result<Self> {
+	pub fn load_all(path: &Path) -> Result<Self> {
 		// get all imports, then merge them all
-		let mut manifest = Self::load(path.clone())?;
+		let mut manifest = Self::load(path)?;
 
 		// get dir of path
 
-		let mut path_can = path.clone();
+		let mut path_can = PathBuf::from(path);
 		path_can.pop();
 
 		for import in manifest.import.clone() {
-			let imported_manifest = Self::load_all(import.clone())?;
+			let imported_manifest = Self::load_all(&import)?;
 			manifest = merge(&manifest, &imported_manifest)?;
 		}
 
@@ -146,22 +142,20 @@ impl Script {
 
 /// Utility function for determining partition /dev names
 /// For cases where it's a mmcblk, or nvme, or loop device etc
-pub fn partition_name(disk: &str, partition: u32) -> String {
-	let devname = if disk.starts_with("/dev/mmcblk") {
-		// mmcblk0p1
-		format!("{}p{}", disk, partition)
-	} else if disk.starts_with("/dev/nvme") {
-		// nvme0n1p1
-		format!("{}p{}", disk, partition)
-	} else if disk.starts_with("/dev/loop") {
-		// loop0p1
-		format!("{}p{}", disk, partition)
-	} else {
-		// sda1
-		format!("{}{}", disk, partition)
-	};
-
-	devname
+pub fn partition_name(disk: &str, partition: usize) -> String {
+	format!(
+		"{disk}{}{partition}",
+		if disk.starts_with("/dev/mmcblk")
+			|| disk.starts_with("/dev/nvme")
+			|| disk.starts_with("/dev/loop")
+		{
+			// mmcblk0p1 / nvme0n1p1 / loop0p1
+			"p"
+		} else {
+			// sda1
+			""
+		}
+	)
 }
 
 #[test]
@@ -179,7 +173,7 @@ fn test_dev_name() {
 	assert_eq!(devname, "/dev/sda1");
 }
 
-#[derive(Deserialize, Debug, Clone, Serialize, PartialEq, Eq)]
+#[derive(Deserialize, Debug, Clone, Serialize, PartialEq, Eq, Default)]
 pub struct PartitionLayout {
 	pub size: Option<ByteSize>,
 	pub partitions: Vec<Partition>,
@@ -187,7 +181,7 @@ pub struct PartitionLayout {
 
 impl PartitionLayout {
 	pub fn new() -> Self {
-		Self { partitions: Vec::new(), size: None }
+		Self::default()
 	}
 
 	/// Adds a partition to the layout
@@ -198,16 +192,14 @@ impl PartitionLayout {
 	pub fn get_index(&self, mountpoint: &str) -> Option<usize> {
 		// index should be +1 of the actual partition number (sda1 is index 0)
 
-		Some(
-			self.partitions.iter().position(|p| p.mountpoint == mountpoint).unwrap_or_default() + 1,
-		)
+		self.partitions.iter().position(|p| p.mountpoint == mountpoint).map(|i| i + 1)
 	}
 
 	pub fn get_partition(&self, mountpoint: &str) -> Option<&Partition> {
 		self.partitions.iter().find(|p| p.mountpoint == mountpoint)
 	}
 
-	pub fn sort_partitions(&mut self) -> BTreeMap<usize, Partition> {
+	pub fn sort_partitions(&self) -> Vec<(usize, Partition)> {
 		// We should sort partitions by mountpoint, so that we can mount them in order
 		// In this case, from the least nested to the most nested, so count the number of slashes
 
@@ -219,44 +211,32 @@ impl PartitionLayout {
 
 		let mut ordered = BTreeMap::new();
 
-		for (_, part) in self.partitions.iter().enumerate() {
+		for part in &self.partitions {
 			let index = self.get_index(&part.mountpoint).unwrap();
 			ordered.insert(index, part.clone());
 
-			debug!(index = ?index, "Index of partition");
+			debug!(?index, "Index of partition");
 		}
 
 		// now sort by mountpoint, least nested to most nested by counting the number of slashes
 		// but make an exception if it's just /, then it's 0
 
-		ordered
-			.iter()
-			.map(|(i, part)| {
-				let count = part.mountpoint.chars().filter(|c| *c == '/').count();
-				(count, i, part)
-			})
-			.collect::<Vec<_>>()
-			.sort_by(|(a, _, _), (b, _, _)| a.cmp(b));
-
+		let mut ordered = ordered.into_iter().collect::<Vec<_>>();
+		ordered.sort_by(|(_, a), (_, b)| {
+			a.mountpoint.matches('/').count().cmp(&b.mountpoint.matches('/').count())
+		});
 		ordered
 	}
 
-	pub fn mount_to_chroot(&self, disk: &PathBuf, chroot: &PathBuf) -> Result<()> {
+	pub fn mount_to_chroot(&self, disk: &Path, chroot: &Path) -> Result<()> {
 		// mount partitions to chroot
 
 		// sort partitions by mountpoint
-		let ordered = self.clone().sort_partitions();
-
-		// reverse the order
-
-		let ordered = ordered.into_iter().rev().collect::<Vec<_>>();
-
-		debug!("Mounting partitions to chroot: {:#?}", ordered);
+		let ordered: Vec<_> = self.sort_partitions().into_iter().rev().collect();
 
 		// Ok, so for some reason the partitions are swapped?
-
-		for (index, part) in ordered.iter() {
-			let devname = partition_name(&disk.to_string_lossy(), *index as u32);
+		for (index, part) in &ordered {
+			let devname = partition_name(&disk.to_string_lossy(), *index);
 
 			// clean the mountpoint so we don't have the slash at the start
 			let mp_cleaned = part.mountpoint.trim_start_matches('/');
@@ -264,26 +244,22 @@ impl PartitionLayout {
 
 			std::fs::create_dir_all(&mountpoint)?;
 
-			trace!(
-				"mount {devname} {mountpoint}",
-				devname = devname,
-				mountpoint = mountpoint.to_string_lossy()
-			);
+			trace!("mount {devname} {mountpoint:?}");
 
-			cmd_lib::run_cmd!(mount ${devname} ${mountpoint} 2>&1)?;
+			cmd_lib::run_cmd!(mount $devname $mountpoint 2>&1)?;
 		}
 
 		Ok(())
 	}
 
-	pub fn unmount_from_chroot(&self, disk: &PathBuf, chroot: &PathBuf) -> Result<()> {
+	pub fn unmount_from_chroot(&self, disk: &Path, chroot: &Path) -> Result<()> {
 		// unmount partitions from chroot
 
 		// sort partitions by mountpoint
-		let ordered = self.clone().sort_partitions();
+		let ordered = self.sort_partitions();
 
-		for (index, part) in ordered.iter() {
-			let devname = partition_name(&disk.to_string_lossy(), *index as u32);
+		for (index, part) in &ordered {
+			let devname = partition_name(&disk.to_string_lossy(), *index);
 
 			// clean the mountpoint so we don't have the slash at the start
 			let mp_cleaned = part.mountpoint.trim_start_matches('/');
@@ -291,13 +267,9 @@ impl PartitionLayout {
 
 			std::fs::create_dir_all(&mountpoint)?;
 
-			trace!(
-				"mount {devname} {mountpoint}",
-				devname = devname,
-				mountpoint = mountpoint.to_string_lossy()
-			);
+			trace!("umount {devname} {mountpoint:?}");
 
-			cmd_lib::run_cmd!(umount ${devname} 2>&1)?;
+			cmd_lib::run_cmd!(umount $devname 2>&1)?;
 		}
 		Ok(())
 	}
@@ -305,8 +277,7 @@ impl PartitionLayout {
 	/// Generate fstab entries for the partitions
 	pub fn fstab(&self, chroot: &Path) -> Result<String> {
 		// sort partitions by mountpoint
-		let mut ordered = self.clone();
-		ordered.sort_partitions();
+		let ordered = self.sort_partitions();
 
 		let mut fstab = String::new();
 
@@ -324,24 +295,24 @@ impl PartitionLayout {
 
 		fstab.push_str(LEGEND.trim());
 
-		for part in &ordered.partitions {
+		for part in ordered.iter().map(|(_, p)| p) {
 			// get devname by finding from mount, instead of index because we won't be using it as much
 			let mountpoint = PathBuf::from(&part.mountpoint);
 			let mountpoint_chroot = part.mountpoint.trim_start_matches('/');
 			let mountpoint_chroot = chroot.join(mountpoint_chroot);
 
-			debug!(mountpoint = ?mountpoint, "Mountpoint of partition");
-			debug!(mountpoint_chroot = ?mountpoint_chroot, "Mountpoint of partition in chroot");
+			debug!(?mountpoint, "Mountpoint of partition");
+			debug!(?mountpoint_chroot, "Mountpoint of partition in chroot");
 
-			let devname = cmd_lib::run_fun!(findmnt -n -o SOURCE ${mountpoint_chroot})?;
+			let devname = cmd_lib::run_fun!(findmnt -n -o SOURCE $mountpoint_chroot)?;
 
-			debug!(devname = ?devname, "Device name of partition");
+			debug!(?devname, "Device name of partition");
 
 			// We will generate by UUID
 
-			let uuid = cmd_lib::run_fun!(blkid -s UUID -o value ${devname})?;
+			let uuid = cmd_lib::run_fun!(blkid -s UUID -o value $devname)?;
 
-			debug!(uuid = ?uuid, "UUID of partition");
+			debug!(?uuid, "UUID of partition");
 
 			// clean the mountpoint so we don't have the slash at the start
 			// let mp_cleaned = part.mountpoint.trim_start_matches('/');
@@ -357,8 +328,8 @@ impl PartitionLayout {
 			let fsck = if part.filesystem == "efi" { "0" } else { "2" };
 
 			let entry = format!(
-				"UUID={uuid}\t{mountpoint}\t{fsname}\tdefaults\t0\t{fsck}",
-				mountpoint = mountpoint.to_string_lossy(),
+				"UUID={uuid}\t{mp}\t{fsname}\tdefaults\t0\t{fsck}",
+				mp = mountpoint.to_string_lossy(),
 			);
 
 			fstab.push_str(&entry);
@@ -376,22 +347,21 @@ impl PartitionLayout {
 		// format disk with GPT
 
 		trace!("Formatting disk with GPT");
-		trace!("parted -s {disk} mklabel gpt", disk = disk.to_string_lossy());
-		cmd_lib::run_cmd!(parted -s ${disk} mklabel gpt 2>&1)?;
+		trace!("parted -s {disk:?} mklabel gpt");
+		cmd_lib::run_cmd!(parted -s $disk mklabel gpt 2>&1)?;
 
 		// create partitions
 
 		let mut last_end = 0;
 
 		for (i, part) in self.partitions.iter().enumerate() {
-			trace!("Creating partition {}:", i);
-			trace!("{:#?}", part);
+			trace!("Creating partition {i}: {part:#?}");
 
 			// get index of partition
 			let index = self.get_index(&part.mountpoint).unwrap();
-			trace!("Index: {}", index);
+			trace!("Index: {index}");
 
-			let devname = partition_name(&disk.to_string_lossy(), index as u32);
+			let devname = partition_name(&disk.to_string_lossy(), index);
 
 			let start_string = if i == 0 {
 				// create partition at start of disk
@@ -412,37 +382,20 @@ impl PartitionLayout {
 				"100%".to_string()
 			};
 
-			let part_fs_parted = if part.filesystem == "efi" { "fat32" } else { "ext4" };
+			let parted_fs = if part.filesystem == "efi" { "fat32" } else { "ext4" };
 
-			trace!(
-				"parted -s {disk} mkpart primary {part_fs} {start} {end}",
-				disk = disk.to_string_lossy(),
-				part_fs = part_fs_parted,
-				start = start_string,
-				end = end_string
-			);
+			trace!("parted -s {disk:?} mkpart primary {parted_fs} {start_string} {end_string}");
 
-			cmd_lib::run_cmd!(parted -s ${disk} mkpart primary ${part_fs_parted} ${start_string} ${end_string} 2>&1)?;
+			cmd_lib::run_cmd!(parted -s $disk mkpart primary $parted_fs $start_string $end_string 2>&1)?;
 
 			if part.filesystem == "efi" {
-				trace!(
-					"parted -s {disk} set {index} esp on",
-					disk = disk.to_string_lossy(),
-					index = index
-				);
-
-				cmd_lib::run_cmd!(parted -s ${disk} set ${index} esp on 2>&1)?;
+				trace!("parted -s {disk:?} set {index} esp on");
+				cmd_lib::run_cmd!(parted -s $disk set $index esp on 2>&1)?;
 			}
 
 			if let Some(label) = &part.label {
-				trace!(
-					"parted -s {disk} name {index} {label}",
-					disk = disk.to_string_lossy(),
-					index = index,
-					label = label
-				);
-
-				cmd_lib::run_cmd!(parted -s ${disk} name ${index} ${label} 2>&1)?;
+				trace!("parted -s {disk:?} name {index} {label}");
+				cmd_lib::run_cmd!(parted -s $disk name $index $label 2>&1)?;
 			}
 
 			// time to format the filesystem
@@ -457,13 +410,13 @@ impl PartitionLayout {
 
 			// Some stupid hackery checks for the args of mkfs.fat
 			if part.filesystem == "efi" {
-				trace!("mkfs.fat -F32 {devname}", devname = devname);
+				trace!("mkfs.fat -F32 {devname}");
 
-				cmd_lib::run_cmd!(mkfs.fat -F32 ${devname} 2>&1)?;
+				cmd_lib::run_cmd!(mkfs.fat -F32 $devname 2>&1)?;
 			} else {
-				trace!("mkfs.{fs} {devname}", fs = fsname, devname = devname);
+				trace!("mkfs.{fsname} {devname}");
 
-				cmd_lib::run_cmd!(mkfs.${fsname} ${devname} 2>&1)?;
+				cmd_lib::run_cmd!(mkfs.$fsname $devname 2>&1)?;
 			}
 
 			// create partition
@@ -511,7 +464,7 @@ fn test_partlay() {
 		let index = partlay.get_index(&part.mountpoint).unwrap();
 		println!("Index: {index}");
 
-		println!("Partition name: {}", partition_name(&mock_disk.to_string_lossy(), index as u32));
+		println!("Partition name: {}", partition_name(&mock_disk.to_string_lossy(), index));
 
 		println!("====================");
 	}
@@ -617,10 +570,9 @@ impl Auth {
 
 		args.push(self.username.to_owned());
 
-		trace!(args = ?args, "useradd args");
+		trace!(?args, "useradd args");
 
-		chroot_run_cmd!(chroot, unshare -R ${chroot} useradd $[args] 2>&1)?;
-		// cmd_lib::run_cmd!(useradd $[args] 2>&1)?;
+		chroot_run_cmd!(chroot, unshare -R $chroot useradd $[args] 2>&1)?;
 
 		// add ssh keys
 		if !self.ssh_keys.is_empty() {
@@ -640,9 +592,6 @@ impl Auth {
 				auth_keys_file.write_all(key.as_bytes())?;
 				auth_keys_file.write_all(b"\n")?;
 			}
-
-			auth_keys_file.flush()?;
-			drop(auth_keys_file);
 		}
 
 		Ok(())
diff --git a/src/util.rs b/src/util.rs
index 8ca58eb..a0568e9 100644
--- a/src/util.rs
+++ b/src/util.rs
@@ -62,8 +62,7 @@ macro_rules! chroot_run {
 #[macro_export]
 macro_rules! chroot_run_cmd {
 	($chroot:expr, $($cmd:tt)*) => {{
-		crate::util::run_with_chroot(&PathBuf::from($chroot.clone()), || {
-
+		crate::util::run_with_chroot(&PathBuf::from($chroot), || {
 			cmd_lib::run_cmd!($($cmd)*)?;
 			Ok(())
 		})
@@ -74,8 +73,7 @@ macro_rules! chroot_run_cmd {
 #[macro_export]
 macro_rules! chroot_run_fun {
 	($chroot:expr, $($cmd:tt)*) => {{
-		crate::util::run_with_chroot(&PathBuf::from($chroot.clone()), || {
-
+		crate::util::run_with_chroot(&PathBuf::from($chroot), || {
 			cmd_lib::run_fun!($($cmd)*)?;
 			Ok(())
 		})
@@ -251,8 +249,8 @@ pub fn unmount_chroot(root: &Path) -> Result<()> {
 ///
 /// NOTE: This function requires that the function inside returns a result, so we can catch errors and unmount early
 pub fn run_with_chroot<T>(root: &Path, f: impl FnOnce() -> Result<T>) -> Result<T> {
-	prepare_chroot(root.clone())?;
+	prepare_chroot(root)?;
 	let res = f();
-	unmount_chroot(root.clone())?;
+	unmount_chroot(root)?;
 	res
 }