use openat when encountering ENAMETOOLONG

This adds a fallback to various fs methods that handles ENAMETOOLONG
by splitting the path into relative segments and then opening each
segment with openat(dirfd, segment, O_PATH).

Limitations:

* not all fs methods are covered. the primary motivation is to get
  remove_dir_all working to delete a deep directory structure
  created by accident
* requires O_PATH, so this can currently only be a fallback and
  not the default due to our current minimum kernel version. If you're
  not dealing with long paths it won't be used.
* currently linux-only. this could be extended to platforms which have
  either O_PATH or O_EXEC but there's no CI coverage for the BSDs
  so I don't want to foist it on them
* O(n²) performance if remove_dir_all has to use the fallback, albeit
  a small constant factor due to the long path segments used
  but ideally it should be rewritten to use openat in its recursion steps.
  But to do it properly we need a higher minimum kernel version.

Author: the8472

library/std/src/fs/tests.rs

@@ -1658,36 +1658,36 @@ fn test_file_times() {
     let modified = SystemTime::UNIX_EPOCH + Duration::from_secs(54321);
     times = times.set_accessed(accessed).set_modified(modified);
     #[cfg(any(
-        windows,
-        target_os = "macos",
-        target_os = "ios",
-        target_os = "watchos",
-        target_os = "tvos",
+    windows,
+    target_os = "macos",
+    target_os = "ios",
+    target_os = "watchos",
+    target_os = "tvos",
     ))]
-    let created = SystemTime::UNIX_EPOCH + Duration::from_secs(32123);
+        let created = SystemTime::UNIX_EPOCH + Duration::from_secs(32123);
     #[cfg(any(
-        windows,
-        target_os = "macos",
-        target_os = "ios",
-        target_os = "watchos",
-        target_os = "tvos",
+    windows,
+    target_os = "macos",
+    target_os = "ios",
+    target_os = "watchos",
+    target_os = "tvos",
     ))]
     {
         times = times.set_created(created);
     }
     match file.set_times(times) {
         // Allow unsupported errors on platforms which don't support setting times.
         #[cfg(not(any(
-            windows,
-            all(
-                unix,
-                not(any(
-                    target_os = "android",
-                    target_os = "redox",
-                    target_os = "espidf",
-                    target_os = "horizon"
-                ))
-            )
+        windows,
+        all(
+        unix,
+        not(any(
+        target_os = "android",
+        target_os = "redox",
+        target_os = "espidf",
+        target_os = "horizon"
+        ))
+        )
         )))]
         Err(e) if e.kind() == ErrorKind::Unsupported => return,
         Err(e) => panic!("error setting file times: {e:?}"),
@@ -1697,13 +1697,36 @@ fn test_file_times() {
     assert_eq!(metadata.accessed().unwrap(), accessed);
     assert_eq!(metadata.modified().unwrap(), modified);
     #[cfg(any(
-        windows,
-        target_os = "macos",
-        target_os = "ios",
-        target_os = "watchos",
-        target_os = "tvos",
+    windows,
+    target_os = "macos",
+    target_os = "ios",
+    target_os = "watchos",
+    target_os = "tvos",
     ))]
     {
         assert_eq!(metadata.created().unwrap(), created);
     }
 }
+
+#[test]
+#[cfg(any(target_os = "linux", target_os = "android"))]
+fn deep_traversal() -> crate::io::Result<()> {
+    use crate::fs::{create_dir_all, metadata, remove_dir_all, write};
+    use crate::iter::repeat;
+
+    let tmpdir = tmpdir();
+
+    let segment = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA";
+
+    let mut dir = tmpdir.join(segment);
+    repeat(segment).take(100).for_each(|name| dir.push(name));
+    assert!(dir.as_os_str().len() > libc::PATH_MAX as usize);
+    let file = dir.join("b");
+
+    create_dir_all(&dir).expect("deep create tailed");
+    write(&file, "foo").expect("deep write failed");
+    metadata(&file).expect("deep stat failed");
+    remove_dir_all(&dir).expect("deep remove failed");
+
+    Ok(())
+}

library/std/src/sys/common/small_c_string.rs

@@ -1,6 +1,5 @@
-use crate::ffi::{CStr, CString};
+use crate::ffi::{CStr, CString, OsStr};
 use crate::mem::MaybeUninit;
-use crate::path::Path;
 use crate::slice;
 use crate::{io, ptr};
 
@@ -15,11 +14,11 @@ const NUL_ERR: io::Error =
     io::const_io_error!(io::ErrorKind::InvalidInput, "file name contained an unexpected NUL byte");
 
 #[inline]
-pub fn run_path_with_cstr<T, F>(path: &Path, f: F) -> io::Result<T>
+pub fn run_path_with_cstr<T, F>(path: &(impl AsRef<OsStr> + ?Sized), f: F) -> io::Result<T>
 where
     F: FnOnce(&CStr) -> io::Result<T>,
 {
-    run_with_cstr(path.as_os_str().as_os_str_bytes(), f)
+    run_with_cstr(path.as_ref().as_os_str_bytes(), f)
 }
 
 #[inline]