dd: splice fast-path for skip= with nun-seekable input

Author: oech3

Cargo.lock

@@ -34,6 +34,8 @@ fluent = { workspace = true }
 
 [target.'cfg(any(target_os = "linux", target_os = "android"))'.dependencies]
 nix = { workspace = true, features = ["fs", "signal"] }
+rustix = { workspace = true, features = ["pipe"] }
+uucore = { workspace = true, features = ["pipes"] }
 
 [[bin]]
 name = "dd"

src/uu/dd/Cargo.toml

@@ -35,7 +35,6 @@ use std::ffi::OsString;
 use std::fs::Metadata;
 use std::fs::{File, OpenOptions};
 use std::io::{self, Read, Seek, SeekFrom, Write};
-#[cfg(any(target_os = "linux", target_os = "android"))]
 use std::os::fd::AsFd;
 #[cfg(any(target_os = "linux", target_os = "android"))]
 use std::os::unix::fs::OpenOptionsExt;
@@ -183,11 +182,37 @@ impl Num {
 /// This is more efficient than `io::copy` with `BufReader` because it reads
 /// directly in `buf_size`-sized chunks, matching GNU dd's behavior.
 /// Returns the total number of bytes actually read.
-fn read_and_discard<R: Read>(reader: &mut R, n: u64, buf_size: usize) -> io::Result<u64> {
-    // todo: consider splice()ing to /dev/null on Linux
-    let mut buf = Vec::with_capacity(buf_size);
+fn read_and_discard<R: Read + AsFd>(reader: &mut R, n: u64, buf_size: usize) -> io::Result<u64> {
     let mut total = 0u64;
     let mut remaining = n;
+    #[cfg(any(target_os = "linux", target_os = "android"))]
+    {
+        //fast-path
+        use std::sync::OnceLock;
+        use uucore::pipes::{MAX_ROOTLESS_PIPE_SIZE, dev_null, splice};
+        static INIT: OnceLock<Option<File>> = OnceLock::new();
+        let null = INIT.get_or_init(|| {
+            if let Some(f) = dev_null() {
+                let _ = rustix::pipe::fcntl_setpipe_size(&reader, MAX_ROOTLESS_PIPE_SIZE);
+                Some(f)
+            } else {
+                None
+            }
+        });
+        if let Some(null) = null {
+            while remaining > 0 {
+                match splice(&reader, &null, remaining as usize) {
+                    Ok(0) => return Ok(total), // no need to allocate buf
+                    Ok(bytes_read) => {
+                        total += bytes_read as u64;
+                        remaining -= bytes_read as u64;
+                    }
+                    Err(_) => break,
+                }
+            }
+        }
+    }
+    let mut buf = Vec::with_capacity(buf_size);
     while remaining > 0 {
         let to_read = cmp::min(remaining, buf_size as u64);
         buf.clear();