feat: refactor stdio handling

Author: xtqqczze

Cargo.lock

@@ -476,31 +476,25 @@ fn get_input_type(path: &OsString) -> CatResult<InputType> {
 /// Writes handle to stdout with no configuration. This allows a
 /// simple memory copy.
 fn print_fast<R: FdReadable>(handle: &mut InputHandle<R>) -> CatResult<()> {
-    let stdout = io::stdout();
-    #[cfg(any(target_os = "linux", target_os = "android"))]
-    let mut stdout = stdout;
     // Try to use the splice() system call for faster writing. If it works, we're done.
     #[cfg(any(target_os = "linux", target_os = "android"))]
-    if uucore::pipes::splice_unbounded_auto(&handle.reader, &mut stdout)?.is_ok()
+    if uucore::pipes::splice_unbounded_auto(&handle.reader, &mut *uucore::stdio::stdout_raw())?.is_ok()
         && !uucore::pipes::might_fuse(&handle.reader)
     {
         return Ok(());
     }
 
     // If we're not on Linux or Android, or the splice() call failed,
     // fall back on slower writing.
-    print_unbuffered(handle, stdout)
+    print_unbuffered(handle)
 }
 
 #[cfg_attr(any(target_os = "linux", target_os = "android"), inline(never))] // splice fast-path does not require this allocation
-fn print_unbuffered<R: FdReadable>(
-    handle: &mut InputHandle<R>,
-    stdout: io::Stdout,
-) -> CatResult<()> {
+fn print_unbuffered<R: FdReadable>(handle: &mut InputHandle<R>) -> CatResult<()> {
     #[cfg(any(unix, target_os = "wasi"))]
-    let mut stdout = uucore::io::RawWriter(stdout); // use raw syscall to remove buffering
+    let mut stdout = uucore::stdio::stdout_raw();
     #[cfg(not(any(unix, target_os = "wasi")))]
-    let mut stdout = stdout.lock();
+    let mut stdout = io::stdout().lock();
     let mut buf = [0; 1024 * 64];
     loop {
         match handle.reader.read(&mut buf) {

src/uu/cat/src/cat.rs

@@ -22,6 +22,7 @@ doctest = false
 clap = { workspace = true }
 gcd = { workspace = true }
 libc = { workspace = true }
+rustix = { workspace = true }
 uucore = { workspace = true, features = [
   "format",
   "parser-size",

src/uu/dd/Cargo.toml

@@ -36,7 +36,13 @@ jiff = { workspace = true, optional = true, features = [
   "tzdb-concatenated",
 ] }
 rustc-hash = { workspace = true }
-rustix = { workspace = true, features = ["fs", "net", "pipe", "process"] }
+rustix = { workspace = true, features = [
+  "fs",
+  "net",
+  "pipe",
+  "process",
+  "stdio",
+] }
 time = { workspace = true, optional = true, features = [
   "formatting",
   "local-offset",

src/uucore/Cargo.toml

@@ -32,6 +32,8 @@ pub use crate::mods::locale;
 pub use crate::mods::os;
 pub use crate::mods::panic;
 pub use crate::mods::posix;
+#[cfg(any(unix, target_os = "wasi"))]
+pub use crate::mods::stdio;
 
 // * feature-gated modules
 #[cfg(feature = "backup-control")]

src/uucore/src/lib/lib.rs

@@ -14,3 +14,5 @@ pub mod locale;
 pub mod os;
 pub mod panic;
 pub mod posix;
+#[cfg(any(unix, target_os = "wasi"))]
+pub mod stdio;

src/uucore/src/lib/mods.rs

@@ -0,0 +1,55 @@
+// This file is part of the uutils coreutils package.
+//
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
+
+//! Abstractions for raw access to stdin and stdout, without buffering.
+
+use core::ops::{Deref, DerefMut};
+use std::{fs::File, mem::ManuallyDrop};
+
+pub struct StdinRaw(ManuallyDrop<File>);
+
+pub struct StdoutRaw(ManuallyDrop<File>);
+
+pub fn stdin_raw() -> StdinRaw {
+    // SAFETY: We ensure that the file descriptor is never closed by
+    // wrapping the `File` in `ManuallyDrop`.
+    let fd = unsafe { rustix::stdio::take_stdin() };
+    StdinRaw(ManuallyDrop::new(File::from(fd)))
+}
+
+pub fn stdout_raw() -> StdoutRaw {
+    // SAFETY: We ensure that the file descriptor is never closed by
+    // wrapping the `File` in `ManuallyDrop`.
+    let fd = unsafe { rustix::stdio::take_stdout() };
+    StdoutRaw(ManuallyDrop::new(File::from(fd)))
+}
+
+impl Deref for StdinRaw {
+    type Target = File;
+
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+
+impl DerefMut for StdinRaw {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.0
+    }
+}
+
+impl Deref for StdoutRaw {
+    type Target = File;
+
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+
+impl DerefMut for StdoutRaw {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.0
+    }
+}