refactor(uu/rm): wrap current_fd in Option for better ownership management in recursive directory removal

- Modified safe_remove_dir_recursive_impl to use Option<DirFd> instead of DirFd for current_fd
- Enables taking ownership during descent and restore cycles to optimize file descriptor handling
- Updated all accesses to use as_ref(), and_then(), take(), and Some() appropriately
- Ensures safe borrowing when calling handler functions like open_subdir, unlink_at, and handle_unlink

Author: mattsu2020

src/uu/rm/src/platform/linux.rs

@@ -343,7 +343,8 @@ pub fn safe_remove_dir_recursive_impl(
         }
     }
     let mut error = false;
-    let mut current_fd = dir_fd;
+    // Wrap in Option to allow taking ownership each descent/restore cycle
+    let mut current_fd = Some(dir_fd);
 
     for (entry_name, entry_stat) in collected {
         let entry_path = path.join(&entry_name);
@@ -357,12 +358,18 @@ pub fn safe_remove_dir_recursive_impl(
                 continue;
             }
 
-            let child_dir_fd = match current_fd.open_subdir(&entry_name) {
+            let child_dir_fd = match current_fd
+                .as_ref()
+                .and_then(|fd| fd.open_subdir(&entry_name).ok())
+            {
                 Ok(fd) => fd,
                 Err(e) => {
                     if e.kind() == std::io::ErrorKind::PermissionDenied {
                         // Try to remove the unreadable directory directly via parent dirfd
-                        match current_fd.unlink_at(entry_name.as_ref(), true) {
+                        match current_fd
+                            .as_ref()
+                            .and_then(|fd| fd.unlink_at(entry_name.as_ref(), true).ok())
+                        {
                             Ok(_) => {
                                 if let Some(pb) = progress_bar {
                                     pb.inc(1);
@@ -391,14 +398,14 @@ pub fn safe_remove_dir_recursive_impl(
             };
 
             // Release current dir fd to keep FD usage low
-            drop(current_fd);
+            drop(current_fd.take());
 
             let (child_error, returned_fd) =
                 safe_remove_dir_recursive_impl(&entry_path, child_dir_fd, options, progress_bar);
             error = error || child_error;
 
             // Restore current directory fd
-            current_fd = match returned_fd {
+            current_fd = Some(match returned_fd {
                 Some(fd) => fd,
                 None => match DirFd::open(path) {
                     Ok(fd) => fd,
@@ -407,7 +414,7 @@ pub fn safe_remove_dir_recursive_impl(
                         continue;
                     }
                 },
-            };
+            });
 
             if !child_error
                 && options.interactive == InteractiveMode::Always
@@ -420,20 +427,18 @@ pub fn safe_remove_dir_recursive_impl(
                 if let Some(pb) = progress_bar {
                     pb.inc(1);
                 }
-                error = handle_unlink(&current_fd, entry_name.as_ref(), &entry_path, true, options)
-                    || error;
+                if let Some(ref fd) = current_fd {
+                    error =
+                        handle_unlink(fd, entry_name.as_ref(), &entry_path, true, options) || error;
+                }
             }
         } else if prompt_file_with_stat(&entry_path, &entry_stat, options) {
             if let Some(pb) = progress_bar {
                 pb.inc(1);
             }
-            error = handle_unlink(
-                &current_fd,
-                entry_name.as_ref(),
-                &entry_path,
-                false,
-                options,
-            ) || error;
+            if let Some(ref fd) = current_fd {
+                error = handle_unlink(fd, entry_name.as_ref(), &entry_path, false, options) || error;
+            }
         }
     }