diff --git a/userspace/ksud/src/boot_patch.rs b/userspace/ksud/src/boot_patch.rs
index 5a3fb860..8b3a9c04 100644
--- a/userspace/ksud/src/boot_patch.rs
+++ b/userspace/ksud/src/boot_patch.rs
@@ -97,9 +97,9 @@ pub fn get_current_kmi() -> Result<String> {
     bail!("Unsupported platform")
 }
 
-fn do_cpio_cmd(magiskboot: &Path, workding_dir: &Path, cmd: &str) -> Result<()> {
+fn do_cpio_cmd(magiskboot: &Path, workdir: &Path, cmd: &str) -> Result<()> {
     let status = Command::new(magiskboot)
-        .current_dir(workding_dir)
+        .current_dir(workdir)
         .stdout(Stdio::null())
         .stderr(Stdio::null())
         .arg("cpio")
@@ -111,9 +111,9 @@ fn do_cpio_cmd(magiskboot: &Path, workding_dir: &Path, cmd: &str) -> Result<()>
     Ok(())
 }
 
-fn is_magisk_patched(magiskboot: &Path, workding_dir: &Path) -> Result<bool> {
+fn is_magisk_patched(magiskboot: &Path, workdir: &Path) -> Result<bool> {
     let status = Command::new(magiskboot)
-        .current_dir(workding_dir)
+        .current_dir(workdir)
         .stdout(Stdio::null())
         .stderr(Stdio::null())
         .args(["cpio", "ramdisk.cpio", "test"])
@@ -123,9 +123,9 @@ fn is_magisk_patched(magiskboot: &Path, workding_dir: &Path) -> Result<bool> {
     Ok(status.code() == Some(1))
 }
 
-fn is_kernelsu_patched(magiskboot: &Path, workding_dir: &Path) -> Result<bool> {
+fn is_kernelsu_patched(magiskboot: &Path, workdir: &Path) -> Result<bool> {
     let status = Command::new(magiskboot)
-        .current_dir(workding_dir)
+        .current_dir(workdir)
         .stdout(Stdio::null())
         .stderr(Stdio::null())
         .args(["cpio", "ramdisk.cpio", "exists kernelsu.ko"])
@@ -155,14 +155,15 @@ pub fn restore(
     magiskboot_path: Option<PathBuf>,
     flash: bool,
 ) -> Result<()> {
-    let workding_dir = tempdir::TempDir::new("KernelSU").context("create temp dir failed")?;
-    let magiskboot = find_magiskboot(magiskboot_path, workding_dir.path())?;
+    let tmpdir = tempdir::TempDir::new("KernelSU").context("create temp dir failed")?;
+    let workdir = tmpdir.path();
+    let magiskboot = find_magiskboot(magiskboot_path, workdir)?;
 
-    let (bootimage, bootdevice) = find_boot_image(&image, false, false, workding_dir.path())?;
+    let (bootimage, bootdevice) = find_boot_image(&image, false, false, workdir)?;
 
     println!("- Unpacking boot image");
     let status = Command::new(&magiskboot)
-        .current_dir(workding_dir.path())
+        .current_dir(workdir)
         .stdout(Stdio::null())
         .stderr(Stdio::null())
         .arg("unpack")
@@ -170,26 +171,20 @@ pub fn restore(
         .status()?;
     ensure!(status.success(), "magiskboot unpack failed");
 
-    let is_kernelsu_patched = is_kernelsu_patched(&magiskboot, workding_dir.path())?;
+    let is_kernelsu_patched = is_kernelsu_patched(&magiskboot, workdir)?;
     ensure!(is_kernelsu_patched, "boot image is not patched by KernelSU");
 
     let mut new_boot = None;
     let mut from_backup = false;
 
     #[cfg(target_os = "android")]
-    if do_cpio_cmd(
-        &magiskboot,
-        workding_dir.path(),
-        &format!("exists {}", BACKUP_FILENAME),
-    )
-    .is_ok()
-    {
+    if do_cpio_cmd(&magiskboot, workdir, &format!("exists {BACKUP_FILENAME}")).is_ok() {
         do_cpio_cmd(
             &magiskboot,
-            workding_dir.path(),
+            workdir,
             &format!("extract {0} {0}", BACKUP_FILENAME),
         )?;
-        let sha = std::fs::read(workding_dir.path().join(BACKUP_FILENAME))?;
+        let sha = std::fs::read(workdir.join(BACKUP_FILENAME))?;
         let sha = String::from_utf8(sha)?;
         let sha = sha.trim();
         let backup_path =
@@ -210,27 +205,27 @@ pub fn restore(
 
     if new_boot.is_none() {
         // remove kernelsu.ko
-        do_cpio_cmd(&magiskboot, workding_dir.path(), "rm kernelsu.ko")?;
+        do_cpio_cmd(&magiskboot, workdir, "rm kernelsu.ko")?;
 
         // if init.real exists, restore it
-        let status = do_cpio_cmd(&magiskboot, workding_dir.path(), "exists init.real").is_ok();
+        let status = do_cpio_cmd(&magiskboot, workdir, "exists init.real").is_ok();
         if status {
-            do_cpio_cmd(&magiskboot, workding_dir.path(), "mv init.real init")?;
+            do_cpio_cmd(&magiskboot, workdir, "mv init.real init")?;
         } else {
-            let ramdisk = workding_dir.path().join("ramdisk.cpio");
+            let ramdisk = workdir.join("ramdisk.cpio");
             std::fs::remove_file(ramdisk)?;
         }
 
         println!("- Repacking boot image");
         let status = Command::new(&magiskboot)
-            .current_dir(workding_dir.path())
+            .current_dir(workdir)
             .stdout(Stdio::null())
             .stderr(Stdio::null())
             .arg("repack")
             .arg(bootimage.display().to_string())
             .status()?;
         ensure!(status.success(), "magiskboot repack failed");
-        new_boot = Some(workding_dir.path().join("new-boot.img"));
+        new_boot = Some(workdir.join("new-boot.img"));
     }
 
     let new_boot = new_boot.unwrap();
@@ -311,10 +306,10 @@ fn do_patch(
         );
     }
 
-    let workding_dir = tempdir::TempDir::new("KernelSU").context("create temp dir failed")?;
+    let tmpdir = tempdir::TempDir::new("KernelSU").context("create temp dir failed")?;
+    let workdir = tmpdir.path();
 
-    let (bootimage, bootdevice) =
-        find_boot_image(&image, ota, is_replace_kernel, workding_dir.path())?;
+    let (bootimage, bootdevice) = find_boot_image(&image, ota, is_replace_kernel, workdir)?;
 
     let bootimage = bootimage.display().to_string();
 
@@ -322,16 +317,15 @@ fn do_patch(
     let _ = assets::ensure_binaries(false);
 
     // extract magiskboot
-    let magiskboot = find_magiskboot(magiskboot_path, workding_dir.path())?;
+    let magiskboot = find_magiskboot(magiskboot_path, workdir)?;
 
     if let Some(kernel) = kernel {
-        std::fs::copy(kernel, workding_dir.path().join("kernel"))
-            .context("copy kernel from failed")?;
+        std::fs::copy(kernel, workdir.join("kernel")).context("copy kernel from failed")?;
     }
 
     println!("- Preparing assets");
 
-    let kmod_file = workding_dir.path().join("kernelsu.ko");
+    let kmod_file = workdir.join("kernelsu.ko");
     if let Some(kmod) = kmod {
         std::fs::copy(kmod, kmod_file).context("copy kernel module failed")?;
     } else {
@@ -347,7 +341,7 @@ fn do_patch(
             .with_context(|| format!("Failed to copy {name}"))?;
     };
 
-    let init_file = workding_dir.path().join("init");
+    let init_file = workdir.join("init");
     if let Some(init) = init {
         std::fs::copy(init, init_file).context("copy init failed")?;
     } else {
@@ -361,7 +355,7 @@ fn do_patch(
 
     println!("- Unpacking boot image");
     let status = Command::new(&magiskboot)
-        .current_dir(workding_dir.path())
+        .current_dir(workdir)
         .stdout(Stdio::null())
         .stderr(Stdio::null())
         .arg("unpack")
@@ -369,37 +363,33 @@ fn do_patch(
         .status()?;
     ensure!(status.success(), "magiskboot unpack failed");
 
-    let no_ramdisk = !workding_dir.path().join("ramdisk.cpio").exists();
-    let is_magisk_patched = is_magisk_patched(&magiskboot, workding_dir.path())?;
+    let no_ramdisk = !workdir.join("ramdisk.cpio").exists();
+    let is_magisk_patched = is_magisk_patched(&magiskboot, workdir)?;
     ensure!(
         no_ramdisk || !is_magisk_patched,
         "Cannot work with Magisk patched image"
     );
 
     println!("- Adding KernelSU LKM");
-    let is_kernelsu_patched = is_kernelsu_patched(&magiskboot, workding_dir.path())?;
+    let is_kernelsu_patched = is_kernelsu_patched(&magiskboot, workdir)?;
 
     let mut need_backup = false;
     if !is_kernelsu_patched {
         // kernelsu.ko is not exist, backup init if necessary
-        let status = do_cpio_cmd(&magiskboot, workding_dir.path(), "exists init");
+        let status = do_cpio_cmd(&magiskboot, workdir, "exists init");
         if status.is_ok() {
-            do_cpio_cmd(&magiskboot, workding_dir.path(), "mv init init.real")?;
+            do_cpio_cmd(&magiskboot, workdir, "mv init init.real")?;
         }
 
         need_backup = flash;
     }
 
-    do_cpio_cmd(&magiskboot, workding_dir.path(), "add 0755 init init")?;
-    do_cpio_cmd(
-        &magiskboot,
-        workding_dir.path(),
-        "add 0755 kernelsu.ko kernelsu.ko",
-    )?;
+    do_cpio_cmd(&magiskboot, workdir, "add 0755 init init")?;
+    do_cpio_cmd(&magiskboot, workdir, "add 0755 kernelsu.ko kernelsu.ko")?;
 
     #[cfg(target_os = "android")]
     if need_backup {
-        if let Err(e) = do_backup(&magiskboot, workding_dir.path(), &bootimage) {
+        if let Err(e) = do_backup(&magiskboot, workdir, &bootimage) {
             println!("- Backup stock image failed: {e}");
         }
     }
@@ -407,14 +397,14 @@ fn do_patch(
     println!("- Repacking boot image");
     // magiskboot repack boot.img
     let status = Command::new(&magiskboot)
-        .current_dir(workding_dir.path())
+        .current_dir(workdir)
         .stdout(Stdio::null())
         .stderr(Stdio::null())
         .arg("repack")
         .arg(&bootimage)
         .status()?;
     ensure!(status.success(), "magiskboot repack failed");
-    let new_boot = workding_dir.path().join("new-boot.img");
+    let new_boot = workdir.join("new-boot.img");
 
     if patch_file {
         // if image is specified, write to output file
@@ -446,10 +436,10 @@ fn do_patch(
 }
 
 #[cfg(target_os = "android")]
-fn do_backup(magiskboot: &Path, workding_dir: &Path, image: &str) -> Result<()> {
+fn do_backup(magiskboot: &Path, workdir: &Path, image: &str) -> Result<()> {
     // calc boot sha1
     let output = Command::new(magiskboot)
-        .current_dir(workding_dir)
+        .current_dir(workdir)
         .arg("sha1")
         .arg(image)
         .output()?;
@@ -465,10 +455,10 @@ fn do_backup(magiskboot: &Path, workding_dir: &Path, image: &str) -> Result<()>
     // magiskboot cpio ramdisk.cpio 'add 0755 $BACKUP_FILENAME'
     let target = format!("{KSU_BACKUP_DIR}{filename}");
     std::fs::copy(image, &target).with_context(|| format!("backup to {target}"))?;
-    std::fs::write(workding_dir.join(BACKUP_FILENAME), sha1.as_bytes()).context("write sha1")?;
+    std::fs::write(workdir.join(BACKUP_FILENAME), sha1.as_bytes()).context("write sha1")?;
     do_cpio_cmd(
         magiskboot,
-        workding_dir,
+        workdir,
         &format!("add 0755 {0} {0}", BACKUP_FILENAME),
     )?;
     println!("- Stock image has been backup to");
@@ -512,7 +502,7 @@ fn flash_boot(bootdevice: &Option<String>, new_boot: PathBuf) -> Result<()> {
     Ok(())
 }
 
-fn find_magiskboot(magiskboot_path: Option<PathBuf>, workding_dir: &Path) -> Result<PathBuf> {
+fn find_magiskboot(magiskboot_path: Option<PathBuf>, workdir: &Path) -> Result<PathBuf> {
     let magiskboot = {
         if which("magiskboot").is_ok() {
             let _ = assets::ensure_binaries(true);
@@ -522,7 +512,7 @@ fn find_magiskboot(magiskboot_path: Option<PathBuf>, workding_dir: &Path) -> Res
             let magiskboot = if let Some(magiskboot_path) = magiskboot_path {
                 std::fs::canonicalize(magiskboot_path)?
             } else {
-                let magiskboot_path = workding_dir.join("magiskboot");
+                let magiskboot_path = workdir.join("magiskboot");
                 assets::copy_assets_to_file("magiskboot", &magiskboot_path)
                     .context("copy magiskboot failed")?;
                 magiskboot_path
@@ -540,7 +530,7 @@ fn find_boot_image(
     image: &Option<PathBuf>,
     ota: bool,
     is_replace_kernel: bool,
-    workding_dir: &Path,
+    workdir: &Path,
 ) -> Result<(PathBuf, Option<String>)> {
     let bootimage;
     let mut bootdevice = None;
@@ -568,7 +558,7 @@ fn find_boot_image(
         };
 
         println!("- Bootdevice: {boot_partition}");
-        let tmp_boot_path = workding_dir.join("boot.img");
+        let tmp_boot_path = workdir.join("boot.img");
 
         dd(&boot_partition, &tmp_boot_path)?;