fs_uring_cancel_open.rs

Enable keyboard shortcuts

//! Uring file operations tests.

#![cfg(all(

    tokio_unstable,

    feature = "io-uring",

    feature = "rt",

    feature = "fs",

    target_os = "linux"

))]

use futures::future::FutureExt;

use std::fs;

use std::future::poll_fn;

use std::task::Poll;

use tempfile::NamedTempFile;

// see: https://github.com/tokio-rs/tokio/issues/7979

#[tokio::test]

async fn file_descriptors_are_closed_when_cancelling_open_op() {

    let tmp = NamedTempFile::new().unwrap();

    let path = tmp.path().to_path_buf();

    let fd_count_before_opens = fs::read_dir("/proc/self/fd").unwrap().count();

    for _ in 0..128 {

        let (tx, mut rx) = tokio::sync::mpsc::unbounded_channel();

        let path = path.clone();

        let handle = tokio::spawn(async move {

            poll_fn(|cx| {

                let opt = {

                    let mut opt = tokio::fs::OpenOptions::new();

                    opt.read(true);

opt

};

                let fut = opt.open(&path);

                // If io_uring is enabled (and not falling back to the thread pool),

                // the first poll should return Pending. We don't check if the result

                // is actually pending because we run some checks on old kernel that

                // do not support uring.

                let _pending = Box::pin(fut).poll_unpin(cx);

                tx.send(()).unwrap();

                Poll::<()>::Pending

})

            .await;

});

        // Wait for the first poll

        rx.recv().await.unwrap();

        handle.abort();

        let res = handle.await.unwrap_err();

        assert!(res.is_cancelled());

    let fd_count_after_cancel = fs::read_dir("/proc/self/fd").unwrap().count();

    let leaked = fd_count_after_cancel.saturating_sub(fd_count_before_opens);

    // Since we are opening 128 files, we expect that the related fds

    // related to this operation will be closed. Since some other fds

    // can be opened in the meantime, we expect this number to be higher

    // than the counter before opening the files. This number could be

    // lower, but to avoid test flakiness we check that this is at most

    // half the number of the file we opened to check if there's a leak.

    assert!(leaked <= 64);