cat: use std::io::copy

Author: xtqqczze

src/uu/cat/src/cat.rs

@@ -23,10 +23,6 @@ use uucore::error::{UResult, strip_errno};
 use uucore::translate;
 use uucore::{fast_inc::fast_inc_one, format_usage};
 
-/// Linux splice support
-#[cfg(any(target_os = "linux", target_os = "android"))]
-mod splice;
-
 // Allocate 32 digits for the line number.
 // An estimate is that we can print about 1e8 lines/seconds, so 32 digits
 // would be enough for billions of universe lifetimes.
@@ -363,10 +359,11 @@ fn cat_handle<R: FdReadable>(
     state: &mut OutputState,
 ) -> CatResult<()> {
     if options.can_print_fast() {
-        print_fast(handle)
+        io::copy(&mut handle.reader, &mut *uucore::stdio::stdout_raw())?;
     } else {
-        print_lines(handle, options, state)
+        print_lines(handle, options, state)?;
     }
+    Ok(())
 }
 
 fn cat_path(path: &OsString, options: &OutputOptions, state: &mut OutputState) -> CatResult<()> {
@@ -477,38 +474,6 @@ 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<()> {
-    #[cfg(any(target_os = "linux", target_os = "android"))]
-    {
-        // If we're on Linux or Android, try to use the splice() system call
-        // for faster writing. If it works, we're done.
-        if !splice::write_fast_using_splice(handle, &mut io::stdout())? {
-            return Ok(());
-        }
-    }
-    // If we're not on Linux or Android, or the splice() call failed,
-    // fall back on slower writing.
-    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>) -> CatResult<()> {
-    let mut stdout = uucore::stdio::stdout_raw();
-    let mut buf = [0; 1024 * 64];
-    loop {
-        match handle.reader.read(&mut buf) {
-            Ok(0) => return Ok(()),
-            Ok(n) => stdout
-                .write_all(&buf[..n])
-                .inspect_err(handle_broken_pipe)?,
-            Err(e) if e.kind() != ErrorKind::Interrupted => return Err(e.into()),
-            _ => {}
-        }
-    }
-}
-
 /// Outputs file contents to stdout in a line-by-line fashion,
 /// propagating any errors that might occur.
 fn print_lines<R: FdReadable>(