feature: Add File::truncate for async file truncation

Cargo.toml

@@ -19,8 +19,8 @@ keywords = ["async", "fs", "io-uring"]
 [dependencies]
 tokio = { version = "1.2", features = ["net", "rt", "sync"] }
 slab = "0.4.2"
-libc = "0.2.80"
-io-uring = "0.6.0"
+libc = "0.2.167"
+io-uring = "0.7.3"
 socket2 = { version = "0.4.4", features = ["all"] }
 bytes = { version = "1.0", optional = true }
 futures-util = { version = "0.3.26", default-features = false, features = ["std"] }

src/fs/file.rs

@@ -854,6 +854,34 @@ impl File {
         Op::fallocate(&self.fd, offset, len, flags)?.await
     }
 
+    /// Truncates the file to the specified length.
+    ///
+    /// If the file was larger than `len` bytes, then the extra data is removed.
+    ///
+    /// If the file was smaller than `len` bytes, then the file is extended and filled with zeros.
+    ///
+    /// # Examples
+    ///
+    /// ```no_run
+    /// use tokio_uring::fs::File;
+    ///
+    /// fn main() -> Result<(), Box<dyn std::error::Error>> {
+    ///     tokio_uring::start(async {
+    ///         const PATH: &str = "foo.txt";
+    ///         std::fs::write(PATH, b"hello world").unwrap();
+    ///
+    ///         // Truncate to be shorter.
+    ///         let file = OpenOptions::new().write(true).open(PATH).await.unwrap();
+    ///         file.ftruncate(5).await.unwrap();
+    ///
+    ///         let res = std::fs::read_to_string(PATH).unwrap();
+    ///         assert_eq!(res, "hello");
+    ///     })
+    /// }
+    pub async fn ftruncate(&self, len: u64) -> io::Result<()> {
+        Op::ftruncate(&self.fd, len)?.await
+    }
+
     /// Closes the file using the uring asynchronous close operation and returns the possible error
     /// as described in the close(2) man page.
     ///

src/io/ftruncate.rs

@@ -0,0 +1,35 @@
+use std::io;
+
+use io_uring::{opcode, types};
+
+use crate::{
+    io::SharedFd,
+    runtime::{
+        driver::op::{Completable, CqeResult, Op},
+        CONTEXT,
+    },
+};
+
+pub(crate) struct Ftruncate {
+    fd: SharedFd,
+}
+
+impl Op<Ftruncate> {
+    pub(crate) fn ftruncate(fd: &SharedFd, len: u64) -> io::Result<Op<Ftruncate>> {
+        CONTEXT.with(|x| {
+            x.handle()
+                .expect("not in a runtime context")
+                .submit_op(Ftruncate { fd: fd.clone() }, |ftruncate| {
+                    opcode::Ftruncate::new(types::Fd(ftruncate.fd.raw_fd()), len).build()
+                })
+        })
+    }
+}
+
+impl Completable for Ftruncate {
+    type Output = io::Result<()>;
+
+    fn complete(self, cqe: CqeResult) -> Self::Output {
+        cqe.result.map(|_| ())
+    }
+}

src/io/mod.rs

@@ -58,3 +58,5 @@ mod writev;
 
 mod writev_all;
 pub(crate) use writev_all::writev_at_all;
+
+mod ftruncate;

tests/fs_file.rs

@@ -5,9 +5,10 @@ use std::{
 
 use tempfile::NamedTempFile;
 
-use tokio_uring::buf::fixed::FixedBufRegistry;
-use tokio_uring::buf::{BoundedBuf, BoundedBufMut};
-use tokio_uring::fs::File;
+use tokio_uring::{
+    buf::{fixed::FixedBufRegistry, BoundedBuf, BoundedBufMut},
+    fs::{File, OpenOptions},
+};
 
 #[path = "../src/future.rs"]
 #[allow(warnings)]
@@ -313,6 +314,30 @@ fn basic_fallocate() {
     });
 }
 
+#[test]
+fn basic_ftruncate() {
+    tokio_uring::start(async {
+        let tempfile = tempfile();
+        std::fs::write(&tempfile, b"hello world").unwrap();
+
+        // Truncate to be shorter.
+        let file = OpenOptions::new()
+            .write(true)
+            .open(&tempfile)
+            .await
+            .unwrap();
+        file.ftruncate(5).await.unwrap();
+
+        let res = std::fs::read_to_string(&tempfile).unwrap();
+        assert_eq!(res, "hello");
+
+        // Truncate to be longer; filled with zero.
+        file.ftruncate(10).await.unwrap();
+        let res = std::fs::read_to_string(&tempfile).unwrap();
+        assert_eq!(res, "hello\0\0\0\0\0");
+    })
+}
+
 fn tempfile() -> NamedTempFile {
     NamedTempFile::new().unwrap()
 }