Add ops {ReadvFixed, WritevFixed}

Author: silvanshade

io-uring-test/src/main.rs

@@ -116,6 +116,7 @@ fn test<S: squeue::EntryMarker, C: cqueue::EntryMarker>(
     tests::fs::test_fixed_fd_install(&mut ring, &test)?;
     tests::fs::test_get_set_xattr(&mut ring, &test)?;
     tests::fs::test_f_get_set_xattr(&mut ring, &test)?;
+    tests::fs::test_pipe_fixed_writev_readv(&mut ring, &test)?;
 
     // timeout
     tests::timeout::test_timeout(&mut ring, &test)?;

io-uring-test/src/tests/fs.rs

@@ -263,6 +263,113 @@ pub fn test_file_writev_readv<S: squeue::EntryMarker, C: cqueue::EntryMarker>(
     Ok(())
 }
 
+pub fn test_pipe_fixed_writev_readv<S: squeue::EntryMarker, C: cqueue::EntryMarker>(
+    ring: &mut IoUring<S, C>,
+    test: &Test,
+) -> anyhow::Result<()> {
+    require!(
+        test;
+        test.probe.is_supported(opcode::WritevFixed::CODE);
+        test.probe.is_supported(opcode::ReadvFixed::CODE);
+    );
+
+    println!("test pipe_fixed_writev_readv");
+
+    use ::rustix::io_uring::iovec;
+
+    ring.submitter().unregister_buffers()?;
+
+    let (rx, tx) = ::std::io::pipe()?;
+
+    const BYTES0: &[u8] = "The quick brown fox jumps over the lazy dog.".as_bytes();
+    const BYTES1: &[u8] = "我能吞下玻璃而不伤身体。".as_bytes();
+
+    let mut src = Vec::with_capacity(BYTES0.len() + BYTES1.len());
+    src.extend_from_slice(BYTES0);
+    src.extend_from_slice(BYTES1);
+
+    let mut dst = vec![0u8; BYTES0.len() + BYTES1.len()];
+
+    unsafe {
+        ring.submitter().register_buffers(&[
+            iovec {
+                iov_base: src.as_mut_ptr() as *mut _,
+                iov_len: src.len(),
+            },
+            iovec {
+                iov_base: dst.as_mut_ptr() as *mut _,
+                iov_len: dst.len(),
+            },
+        ])?;
+    }
+
+    let src_parts = [
+        iovec {
+            iov_base: src.as_ptr() as *mut _,
+            iov_len: BYTES0.len(),
+        },
+        iovec {
+            iov_base: unsafe { src.as_ptr().add(BYTES0.len()) } as *mut _,
+            iov_len: BYTES1.len(),
+        },
+    ];
+    unsafe {
+        ring.submission().push(
+            &opcode::WritevFixed::new(
+                types::Fd(tx.as_raw_fd()),
+                src_parts.as_ptr().cast(),
+                src_parts.len() as u32,
+                0,
+            )
+            .build()
+            .user_data(0x666)
+            .into(),
+        )?;
+    }
+    ring.submit_and_wait(1)?;
+    for cqe in ring.completion().map(Into::<cqueue::Entry>::into) {
+        assert_eq!(cqe.user_data_u64(), 0x666);
+        let len = cqe.result()?;
+        assert_eq!(len, src.len() as _);
+    }
+
+    let dst_parts = [
+        iovec {
+            iov_base: dst.as_ptr() as *mut _,
+            iov_len: BYTES0.len(),
+        },
+        iovec {
+            iov_base: unsafe { dst.as_ptr().add(BYTES0.len()) } as *mut _,
+            iov_len: BYTES1.len(),
+        },
+    ];
+    unsafe {
+        ring.submission().push(
+            &opcode::ReadvFixed::new(
+                types::Fd(rx.as_raw_fd()),
+                dst_parts.as_ptr().cast(),
+                dst_parts.len() as u32,
+                1,
+            )
+            .build()
+            .user_data(0x666)
+            .into(),
+        )?;
+    }
+    ring.submit_and_wait(1)?;
+    for cqe in ring.completion().map(Into::<cqueue::Entry>::into) {
+        assert_eq!(cqe.user_data_u64(), 0x666);
+        let len = cqe.result()?;
+        assert_eq!(len, src.len() as _);
+    }
+
+    ring.submitter().unregister_buffers()?;
+
+    assert_eq!(src, dst);
+
+    Ok(())
+}
+
 pub fn test_file_fsync<S: squeue::EntryMarker, C: cqueue::EntryMarker>(
     ring: &mut IoUring<S, C>,
     test: &Test,

src/opcode.rs

@@ -2298,3 +2298,65 @@ opcode! {
         Entry(sqe)
     }
 }
+
+opcode! {
+    /// Vectored read into a fixed buffer, equivalent to `preadv2(2)`.
+    pub struct ReadvFixed {
+        fd: { impl sealed::UseFixed },
+        iovec: { *const types::iovec },
+        len: { u32 },
+        buf_index: { u16 },
+        ;;
+        ioprio: u16 = 0,
+        offset: u64 = 0,
+        rw_flags: types::RwFlags = types::RwFlags::empty(),
+    }
+
+    pub const CODE = sys::IoringOp::ReadvFixed;
+
+    pub fn build(self) -> Entry {
+        let Self { fd, iovec, len, buf_index, offset, ioprio, rw_flags } = self;
+
+        let mut sqe = sqe_zeroed();
+        sqe.opcode = Self::CODE;
+        assign_fd!(sqe.fd = fd);
+        sqe.off_or_addr2.off = offset as _;
+        sqe.addr_or_splice_off_in.addr.ptr = iovec as _;
+        sqe.len.len = len;
+        sqe.buf.buf_index = buf_index;
+        sqe.ioprio.ioprio = ioprio;
+        sqe.op_flags.rw_flags = rw_flags;
+        Entry(sqe)
+    }
+}
+
+opcode! {
+    /// Vectored write from a fixed buffer, equivalent to `pwritev2(2)`.
+    pub struct WritevFixed {
+        fd: { impl sealed::UseFixed },
+        iovec: { *const sys::iovec },
+        len: { u32 },
+        buf_index: { u16 },
+        ;;
+        ioprio: u16 = 0,
+        offset: u64 = 0,
+        rw_flags: types::RwFlags = types::RwFlags::empty()
+    }
+
+    pub const CODE = sys::IoringOp::WritevFixed;
+
+    pub fn build(self) -> Entry {
+        let Self { fd, iovec, len, buf_index, offset, ioprio, rw_flags } = self;
+
+        let mut sqe = sqe_zeroed();
+        sqe.opcode = Self::CODE;
+        assign_fd!(sqe.fd = fd);
+        sqe.off_or_addr2.off = offset as _;
+        sqe.addr_or_splice_off_in.addr.ptr = iovec as _;
+        sqe.len.len = len;
+        sqe.buf.buf_index = buf_index;
+        sqe.ioprio.ioprio = ioprio;
+        sqe.op_flags.rw_flags = rw_flags;
+        Entry(sqe)
+    }
+}