improve buffer reuse and parameterize SMALL_PATH_BUFFER_SIZE

Signed-off-by: Inteon <[email protected]>

Author: inteon

src/fs/at.rs

@@ -11,6 +11,7 @@ use crate::fs::CloneFlags;
 #[cfg(any(linux_raw, all(libc, any(target_os = "android", target_os = "linux"))))]
 use crate::fs::RenameFlags;
 use crate::io::{self, OwnedFd};
+use crate::path::SMALL_PATH_BUFFER_SIZE;
 #[cfg(not(target_os = "wasi"))]
 use crate::process::{Gid, Uid};
 use crate::{imp, path};
@@ -71,7 +72,8 @@ fn _readlinkat(dirfd: BorrowedFd<'_>, path: &ZStr, mut buffer: Vec<u8>) -> io::R
     // This code would benefit from having a better way to read into
     // uninitialized memory, but that requires `unsafe`.
     buffer.clear();
-    buffer.resize(256, 0_u8);
+    buffer.reserve(SMALL_PATH_BUFFER_SIZE);
+    buffer.resize(buffer.capacity(), 0_u8);
 
     loop {
         let nread = imp::syscalls::readlinkat(dirfd, path, &mut buffer)?;
@@ -82,7 +84,8 @@ fn _readlinkat(dirfd: BorrowedFd<'_>, path: &ZStr, mut buffer: Vec<u8>) -> io::R
             buffer.resize(nread, 0_u8);
             return Ok(ZString::new(buffer).unwrap());
         }
-        buffer.resize(buffer.len() * 2, 0_u8);
+        buffer.reserve(1); // use `Vec` reallocation strategy to grow capacity exponentially
+        buffer.resize(buffer.capacity(), 0_u8);
     }
 }
 

src/io/tty.rs

@@ -12,7 +12,9 @@ use imp::fd::AsFd;
     all(linux_raw, feature = "procfs"),
     all(libc, not(any(target_os = "fuchsia", target_os = "wasi")))
 ))]
-use {crate::ffi::ZString, alloc::vec::Vec, imp::fd::BorrowedFd};
+use {
+    crate::ffi::ZString, crate::path::SMALL_PATH_BUFFER_SIZE, alloc::vec::Vec, imp::fd::BorrowedFd,
+};
 
 /// `isatty(fd)`—Tests whether a file descriptor refers to a terminal.
 ///
@@ -57,13 +59,17 @@ fn _ttyname(dirfd: BorrowedFd<'_>, mut buffer: Vec<u8>) -> io::Result<ZString> {
     // This code would benefit from having a better way to read into
     // uninitialized memory, but that requires `unsafe`.
     buffer.clear();
-    buffer.resize(256, 0_u8);
+    buffer.reserve(SMALL_PATH_BUFFER_SIZE);
+    buffer.resize(buffer.capacity(), 0_u8);
 
     loop {
         match imp::syscalls::ttyname(dirfd, &mut buffer) {
-            Err(imp::io::Error::RANGE) => buffer.resize(buffer.len() * 2, 0_u8),
+            Err(imp::io::Error::RANGE) => {
+                buffer.reserve(1); // use `Vec` reallocation strategy to grow capacity exponentially
+                buffer.resize(buffer.capacity(), 0_u8);
+            }
             Ok(len) => {
-                buffer.resize(len, 0);
+                buffer.resize(len, 0_u8);
                 return Ok(ZString::new(buffer).unwrap());
             }
             Err(errno) => return Err(errno),

src/path/arg.rs

@@ -2,6 +2,7 @@ use crate::ffi::{ZStr, ZString};
 use crate::io;
 #[cfg(feature = "itoa")]
 use crate::path::DecInt;
+use crate::path::SMALL_PATH_BUFFER_SIZE;
 use alloc::borrow::Cow;
 use alloc::string::String;
 use alloc::vec::Vec;
@@ -952,16 +953,17 @@ fn with_z_str<T, F>(bytes: &[u8], f: F) -> io::Result<T>
 where
     F: FnOnce(&ZStr) -> io::Result<T>,
 {
-    // Most paths are less than this long. The rest can go through the dynamic
-    // allocation path. If you're opening many files in a directory with a long
-    // path, consider opening the directory and using openat to open the files
-    // under it, which will avoid this, and is often faster in the OS as well.
-    const SIZE: usize = 256;
+    // Most paths are less than `SMALL_PATH_BUFFER_SIZE` long. The rest can go through
+    // the dynamic allocation path. If you're opening many files in a directory
+    // with a long path, consider opening the directory and using `openat` to open
+    // the files under it, which will avoid this, and is often faster in the OS
+    // as well.
+
     // Test with >= so that we have room for the trailing NUL.
-    if bytes.len() >= SIZE {
+    if bytes.len() >= SMALL_PATH_BUFFER_SIZE {
         return with_z_str_slow_path(bytes, f);
     }
-    let mut buffer: [u8; SIZE] = [0_u8; SIZE];
+    let mut buffer: [u8; SMALL_PATH_BUFFER_SIZE] = [0_u8; SMALL_PATH_BUFFER_SIZE];
     // Copy the bytes in; the buffer already has zeros for the trailing NUL.
     buffer[..bytes.len()].copy_from_slice(bytes);
     f(ZStr::from_bytes_with_nul(&buffer[..=bytes.len()]).map_err(|_cstr_err| io::Error::INVAL)?)

src/path/mod.rs

@@ -7,3 +7,5 @@ mod dec_int;
 pub use arg::Arg;
 #[cfg(feature = "itoa")]
 pub use dec_int::DecInt;
+
+pub(crate) const SMALL_PATH_BUFFER_SIZE: usize = 256;

src/process/chdir.rs

@@ -1,4 +1,5 @@
 use crate::ffi::ZString;
+use crate::path::SMALL_PATH_BUFFER_SIZE;
 use crate::{imp, io, path};
 use alloc::vec::Vec;
 #[cfg(not(target_os = "fuchsia"))]
@@ -52,11 +53,15 @@ fn _getcwd(mut buffer: Vec<u8>) -> io::Result<ZString> {
     // This code would benefit from having a better way to read into
     // uninitialized memory, but that requires `unsafe`.
     buffer.clear();
-    buffer.resize(256, 0_u8);
+    buffer.reserve(SMALL_PATH_BUFFER_SIZE);
+    buffer.resize(buffer.capacity(), 0_u8);
 
     loop {
         match imp::syscalls::getcwd(&mut buffer) {
-            Err(imp::io::Error::RANGE) => buffer.resize(buffer.len() * 2, 0_u8),
+            Err(imp::io::Error::RANGE) => {
+                buffer.reserve(1); // use `Vec` reallocation strategy to grow capacity exponentially
+                buffer.resize(buffer.capacity(), 0_u8);
+            }
             Ok(_) => {
                 let len = buffer.iter().position(|x| *x == b'\0').unwrap();
                 buffer.resize(len, 0_u8);