cp: omit pipe() if input is pipe

Author: oech3

src/uu/cat/src/splice.rs

@@ -6,8 +6,6 @@ use super::{CatResult, FdReadable, InputHandle};
 
 use std::os::fd::AsFd;
 
-use uucore::pipes::{MAX_ROOTLESS_PIPE_SIZE, might_fuse, splice};
-
 /// This function is called from `write_fast()` on Linux and Android. The
 /// function `splice()` is used to move data between two file descriptors
 /// without copying between kernel and user spaces. This results in a large
@@ -20,10 +18,6 @@ pub(super) fn write_fast_using_splice<R: FdReadable, S: AsFd>(
     handle: &InputHandle<R>,
     write_fd: &mut S,
 ) -> CatResult<bool> {
-    let res = match splice(&handle.reader, &write_fd, MAX_ROOTLESS_PIPE_SIZE) {
-        Ok(_) => uucore::pipes::splice_unbounded(&handle.reader, write_fd)?,
-        // both of in/output are not pipe
-        _ => uucore::pipes::splice_unbounded_broker(&handle.reader, write_fd)?,
-    };
-    Ok(res || might_fuse(&handle.reader))
+    let res = uucore::pipes::splice_unbounded_auto(&handle.reader, write_fd)?;
+    Ok(res || uucore::pipes::might_fuse(&handle.reader))
 }

src/uu/tail/src/tail.rs

@@ -591,7 +591,7 @@ fn print_target_section<
     } else {
         // zero-copy fast-path
         #[cfg(any(target_os = "linux", target_os = "android"))]
-        if uucore::pipes::splice_unbounded_broker(file, &mut stdout)? {
+        if uucore::pipes::splice_unbounded_auto(file, &mut stdout)? {
             io::copy(file, &mut stdout)?;
         }
         #[cfg(not(any(target_os = "linux", target_os = "android")))]

src/uucore/src/lib/features/buf_copy/linux.rs

@@ -39,21 +39,14 @@ where
     R: Read + AsFd + AsRawFd,
     S: Write + AsFd + AsRawFd,
 {
-    // If we're on Linux or Android, try to use the splice() system call
-    // for faster writing. If it works, we're done.
-    // todo: bypass broker pipe this if input or output is pipe. We use this mostly for stream.
-    if !crate::pipes::splice_unbounded_broker(src, dest)? {
-        return Ok(());
+    // try to use the splice() system call
+    // for faster writing. If it works, we're done
+    if crate::pipes::splice_unbounded_auto(&src, dest)? {
+        std::io::copy(src, dest)?;
+        // todo: Do not mix writing by raw syscall and std's buffered write,
+        // or order of output would be wrong when this was called multiple times
+        // and splice_unbounded_auto sent content partially. flush works as an workaround.
+        dest.flush()?;
     }
-
-    // If the splice() call failed, fall back on slower writing.
-    std::io::copy(src, dest)?;
-
-    // If the splice() call failed and there has been some data written to
-    // stdout via while loop above AND there will be second splice() call
-    // that will succeed, data pushed through splice will be output before
-    // the data buffered in stdout.lock. Therefore additional explicit flush
-    // is required here.
-    dest.flush()?;
     Ok(())
 }

src/uucore/src/lib/features/pipes.rs

@@ -151,6 +151,22 @@ where
     }
 }
 
+/// try splice_unbounded 1st and splice_unbounded_broker if both of in/output are not pipe
+#[inline]
+#[cfg(any(target_os = "linux", target_os = "android"))]
+pub fn splice_unbounded_auto<R, S>(source: &R, dest: &mut S) -> std::io::Result<bool>
+where
+    R: Read + AsFd,
+    S: AsFd,
+{
+    // use splice to check that input or output is pipe which is efficient
+    let fallback = match splice(&source, dest, MAX_ROOTLESS_PIPE_SIZE) {
+        Ok(_) => splice_unbounded(source, dest)?,
+        _ => splice_unbounded_broker(source, dest)?,
+    };
+    Ok(fallback)
+}
+
 /// splice `n` bytes with safe read/write fallback
 /// return actually sent bytes
 #[inline]