= note: /uring/target/debug/deps/io_uring_test-af1e753fdc660fe4.3x7eimgxzg68dtpw.rcgu.o: In function `io_uring_test::tests::fs::test_statx':
          /uring/io-uring-test/src/tests/fs.rs:316: undefined reference to `statx'
          collect2: error: ld returned 1 exit status

{
       let uring = IoUring::new();
       let (submit, sq, cq) = uring.split();
       let sq2 = sq.clone();
       let q1 = sq. submission();
       // With the RefCell changes, following statement should panic, which should be the expected behavior:)
       let q2 = sq2.submission();
}

    /// Vectored read, equivalent to `preadv2(2)`.
    pub struct Readv {
        fd: sealed::Target,
        iovec: *const libc::iovec,
        len: u32,
        ioprio: u16,
        offset: libc::off_t,
        rw_flags: types::RwFlags,
    }

    impl Readv {
        /// The opcode of the operation. This can be passed to
        /// [`Probe::is_supported`](crate::Probe::is_supported) to check if this operation is
        /// supported with the current kernel.
        pub const CODE: u8 = sys::IORING_OP_READV as _;
        #[inline]
        pub fn new(fd: impl sealed::UseFixed, iovec: *const libc::iovec, len: u32) -> Self {
            Readv {
                fd: fd.into(),
                iovec: iovec.into(),
                len: len.into(),
                ioprio: 0u16,
                offset: 0i64,
                rw_flags: 0i32,
            }
        }
        #[inline]
        pub const fn ioprio(mut self, ioprio: u16) -> Self {
            self.ioprio = ioprio;
            self
        }
        #[inline]
        pub const fn offset(mut self, offset: libc::off_t) -> Self {
            self.offset = offset;
            self
        }
        /// specified for read operations, contains a bitwise OR of per-I/O flags,
        /// as described in the `preadv2(2)` man page.
        #[inline]
        pub const fn rw_flags(mut self, rw_flags: types::RwFlags) -> Self {
            self.rw_flags = rw_flags;
            self
        }
        #[inline]
        pub fn build(self) -> Entry {
            let mut sqe = sqe_zeroed();
            self.prepare(&mut sqe);
            Entry(sqe)
        }
    }

    impl PrepareSQE for Readv {
        #[inline]
        fn prepare(&self, sqe: &mut sys::io_uring_sqe) {
            sqe.opcode = Readv::CODE;
            sqe.fd = self.fd.as_sqe_value() as _;
            sqe.__bindgen_anon_2.addr = self.iovec.as_sqe_value() as _;
            sqe.len = self.len.as_sqe_value() as _;
            sqe.ioprio = self.ioprio.as_sqe_value() as _;
            sqe.__bindgen_anon_1.off = self.offset.as_sqe_value() as _;
            sqe.__bindgen_anon_3.rw_flags = self.rw_flags.as_sqe_value() as _;
            {
                if match self.fd {
                    sealed::Target::Fixed(_) => true,
                    _ => false,
                } {
                    sqe.flags |= crate::squeue::Flags::FIXED_FILE.bits();
                };
            }
        }
    }

    /// Vectored read, equivalent to `preadv2(2)`.
    #[repr(transparent)]
    pub struct ReadvSqe {
        sqe: sys::io_uring_sqe,
    }

    impl ReadvSqe {
        /// The opcode of the operation. This can be passed to
        /// [`Probe::is_supported`](crate::Probe::is_supported) to check if this operation is
        /// supported with the current kernel.
        pub const CODE: u8 = sys::IORING_OP_READV as _;
        #[inline]
        pub fn prepare(&mut self, fd: sealed::Target, iovec: *const libc::iovec, len: u32) {
            self.sqe.opcode = Self::CODE;
            self.sqe.fd = fd.as_sqe_value() as _;
            self.sqe.__bindgen_anon_2.addr = iovec.as_sqe_value() as _;
            self.sqe.len = len.as_sqe_value() as _;
            self.sqe.ioprio = 0u16.as_sqe_value() as _;
            self.sqe.__bindgen_anon_1.off = 0i64.as_sqe_value() as _;
            self.sqe.__bindgen_anon_3.rw_flags = 0i32.as_sqe_value() as _;
            {
                if match fd {
                    sealed::Target::Fixed(_) => true,
                    _ => false,
                } {
                    self.sqe.flags |= crate::squeue::Flags::FIXED_FILE.bits();
                };
            }
        }
        #[inline]
        pub fn get_mut_sqe(&mut self) -> &mut sys::io_uring_sqe {
            &mut self.sqe
        }
        #[inline]
        pub fn ioprio(mut self, ioprio: u16) -> Self {
            self.sqe.ioprio = ioprio.as_sqe_value() as _;
            self
        }
        #[inline]
        pub fn offset(mut self, offset: libc::off_t) -> Self {
            self.sqe.__bindgen_anon_1.off = offset.as_sqe_value() as _;
            self
        }
        /// specified for read operations, contains a bitwise OR of per-I/O flags,
        /// as described in the `preadv2(2)` man page.
        #[inline]
        pub fn rw_flags(mut self, rw_flags: types::RwFlags) -> Self {
            self.sqe.__bindgen_anon_3.rw_flags = rw_flags.as_sqe_value() as _;
            self
        }
    }

    impl<'a> From<&'a mut sys::io_uring_sqe> for &'a mut ReadvSqe {
        #[inline]
        fn from(sqe: &'a mut sys::io_uring_sqe) -> &'a mut ReadvSqe {
            unsafe { mem::transmute(sqe) }
        }
    }