vendor (and add ext trait for) IoBuf/IoBufMut from tokio-uring

For [`open_at`
support](#21) we
need an `OpenOptions` struct. Sadly we can't re-use the one from
`tokio-uring` because it doesn't have a public API for the conversion of
OpenOptions into the relevant libc flags.

We created [a PR asking for such an
API](neondatabase/tokio-uring#1), but, in the
meantime, let's unblock ourselves by vendoring the pieces of
`tokio-uring` that we need, and cusotmize them as needed.

This PR starts that effort by vendoring the `IoBuf`/`IoBufMut` traits.
`OpenOptions` will follow in a later PR.

The files that reproduce the `tokio-uring` LICENSE text at the top
are copied from `tokio-uring.git:d5e90539bd6d1c518e848298564a098c300866bc`.

Files without it were written by myself.

Cargo.toml

@@ -3,4 +3,5 @@
 members = [
     "tokio-epoll-uring",
     "benchmark",
+    "uring-common",
 ]

tokio-epoll-uring/Cargo.toml

@@ -9,14 +9,13 @@ license = "MIT OR Apache-2.0"
 
 [dependencies]
 futures = "0.3.28"
-io-uring = "0.6.0"
 once_cell = "1.18.0"
 scopeguard = "1.1.0"
 thiserror = "1.0.44"
 tokio = { version = "1.29.1", features = ["io-std", "full"] }
-tokio-uring = "0.4.0"
 tokio-util = "0.7.8"
 tracing = "0.1.37"
+uring-common = { path = "../uring-common" }
 
 [dev-dependencies]
 tokio = { version = "1.29.1", features = ["full"] }

tokio-epoll-uring/src/lib.rs

@@ -80,7 +80,7 @@ pub use system::lifecycle::thread_local::{thread_local_system, Handle};
 pub use system::lifecycle::System;
 pub use system::submission::op_fut::Error as SystemError;
 
-pub use tokio_uring::buf::{IoBuf, IoBufMut};
+pub use uring_common::buf::{IoBuf, IoBufMut};
 
 pub(crate) mod util;
 

tokio-epoll-uring/src/ops/nop.rs

@@ -1,3 +1,5 @@
+use uring_common::io_uring;
+
 use crate::system::submission::op_fut::Op;
 
 pub struct Nop {}

tokio-epoll-uring/src/ops/read.rs

@@ -1,21 +1,23 @@
 use std::os::fd::{AsRawFd, OwnedFd};
 
+use uring_common::{buf::IoBufMut, io_uring};
+
 use crate::system::submission::op_fut::Op;
 
 pub struct ReadOp<B>
 where
-    B: tokio_uring::buf::IoBufMut + Send,
+    B: IoBufMut + Send,
 {
     pub(crate) file: OwnedFd,
     pub(crate) offset: u64,
     pub(crate) buf: B,
 }
 
-impl<B> crate::sealed::Sealed for ReadOp<B> where B: tokio_uring::buf::IoBufMut + Send {}
+impl<B> crate::sealed::Sealed for ReadOp<B> where B: IoBufMut + Send {}
 
 impl<B> Op for ReadOp<B>
 where
-    B: tokio_uring::buf::IoBufMut + Send,
+    B: IoBufMut + Send,
 {
     type Resources = (OwnedFd, B);
     type Success = usize;
@@ -43,7 +45,7 @@ where
         let res = if res < 0 {
             Err(std::io::Error::from_raw_os_error(-res))
         } else {
-            unsafe { tokio_uring::buf::IoBufMut::set_init(&mut self.buf, res as usize) };
+            unsafe { IoBufMut::set_init(&mut self.buf, res as usize) };
             Ok(res as usize)
         };
         ((self.file, self.buf), res)

tokio-epoll-uring/src/system/completion.rs

@@ -6,6 +6,7 @@ use std::{
 use io_uring::CompletionQueue;
 use tokio::sync::{self, broadcast, mpsc, oneshot};
 use tracing::{debug, info, info_span, trace, Instrument};
+use uring_common::io_uring;
 
 use crate::{system::submission::SubmitSideInner, util::oneshot_nonconsuming};
 

tokio-epoll-uring/src/system/lifecycle.rs

@@ -7,6 +7,7 @@ pub mod handle;
 pub mod thread_local;
 
 use io_uring::{CompletionQueue, SubmissionQueue, Submitter};
+use uring_common::io_uring;
 
 use crate::{
     system::{completion::ShutdownRequestImpl, RING_SIZE},

tokio-epoll-uring/src/system/lifecycle/handle.rs

@@ -2,7 +2,7 @@
 
 use futures::FutureExt;
 use std::{os::fd::OwnedFd, task::ready};
-use tokio_uring::buf::IoBufMut;
+use uring_common::buf::IoBufMut;
 
 use crate::{
     ops::read::ReadOp,

tokio-epoll-uring/src/system/slots.rs

@@ -32,6 +32,7 @@ use std::{
 
 use tokio::sync::oneshot;
 use tracing::{debug, trace};
+use uring_common::io_uring;
 
 use crate::system::submission::op_fut::Error;
 

tokio-epoll-uring/src/system/submission.rs

@@ -6,6 +6,7 @@ use std::{
 };
 
 use io_uring::{SubmissionQueue, Submitter};
+use uring_common::io_uring;
 
 use super::{
     completion::CompletionSide,

tokio-epoll-uring/src/system/submission/op_fut.rs

@@ -12,6 +12,8 @@ pub trait Op: crate::sealed::Sealed + Sized + Send + 'static {
     fn make_sqe(&mut self) -> io_uring::squeue::Entry;
 }
 
+use uring_common::io_uring;
+
 use crate::system::{
     completion::ProcessCompletionsCause,
     slots::{self, SlotHandle},

tokio-epoll-uring/src/system/test_util/shared_system_handle.rs

@@ -1,6 +1,7 @@
 use std::sync::{Arc, RwLock};
 
 use futures::Future;
+use uring_common::buf::IoBufMut;
 
 use crate::SystemError;
 use crate::{System, SystemHandle};
@@ -42,7 +43,7 @@ impl SharedSystemHandle {
             .initiate_shutdown()
     }
 
-    pub fn read<B: tokio_uring::buf::IoBufMut + Send>(
+    pub fn read<B: IoBufMut + Send>(
         &self,
         file: std::os::fd::OwnedFd,
         offset: u64,

uring-common/Cargo.toml

@@ -0,0 +1,10 @@
+[package]
+name = "uring-common"
+version = "0.1.0"
+edition = "2021"
+description = "a subset of types from the `tokio-uring` crate"
+license = "MIT" # the same as tokio-uring at the time we forked it
+
+[dependencies]
+libc = "0.2.80"
+io-uring = "0.6.0"

uring-common/src/buf.rs

@@ -0,0 +1,5 @@
+mod io_buf;
+mod io_buf_mut;
+
+pub use io_buf::IoBuf;
+pub use io_buf_mut::IoBufMut;

uring-common/src/buf/io_buf.rs

@@ -0,0 +1,141 @@
+// Copyright (c) 2021 Carl Lerche
+//
+// Permission is hereby granted, free of charge, to any
+// person obtaining a copy of this software and associated
+// documentation files (the "Software"), to deal in the
+// Software without restriction, including without
+// limitation the rights to use, copy, modify, merge,
+// publish, distribute, sublicense, and/or sell copies of
+// the Software, and to permit persons to whom the Software
+// is furnished to do so, subject to the following
+// conditions:
+//
+// The above copyright notice and this permission notice
+// shall be included in all copies or substantial portions
+// of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF
+// ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
+// TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
+// PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
+// SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+// CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR
+// IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+// DEALINGS IN THE SOFTWARE.
+//
+//
+// Based on tokio-uring.git:d5e90539bd6d1c518e848298564a098c300866bc
+
+/// An `io-uring` compatible buffer.
+///
+/// The `IoBuf` trait is implemented by buffer types that can be used with
+/// io-uring operations. Users will not need to use this trait directly.
+/// The [`BoundedBuf`] trait provides some useful methods including `slice`.
+///
+/// # Safety
+///
+/// Buffers passed to `io-uring` operations must reference a stable memory
+/// region. While the runtime holds ownership to a buffer, the pointer returned
+/// by `stable_ptr` must remain valid even if the `IoBuf` value is moved.
+///
+/// [`BoundedBuf`]: crate::buf::BoundedBuf
+pub unsafe trait IoBuf: Unpin + 'static {
+    /// Returns a raw pointer to the vector’s buffer.
+    ///
+    /// This method is to be used by the `tokio-uring` runtime and it is not
+    /// expected for users to call it directly.
+    ///
+    /// The implementation must ensure that, while the `tokio-uring` runtime
+    /// owns the value, the pointer returned by `stable_ptr` **does not**
+    /// change.
+    fn stable_ptr(&self) -> *const u8;
+
+    /// Number of initialized bytes.
+    ///
+    /// This method is to be used by the `tokio-uring` runtime and it is not
+    /// expected for users to call it directly.
+    ///
+    /// For `Vec`, this is identical to `len()`.
+    fn bytes_init(&self) -> usize;
+
+    /// Total size of the buffer, including uninitialized memory, if any.
+    ///
+    /// This method is to be used by the `tokio-uring` runtime and it is not
+    /// expected for users to call it directly.
+    ///
+    /// For `Vec`, this is identical to `capacity()`.
+    fn bytes_total(&self) -> usize;
+}
+
+unsafe impl IoBuf for Vec<u8> {
+    fn stable_ptr(&self) -> *const u8 {
+        self.as_ptr()
+    }
+
+    fn bytes_init(&self) -> usize {
+        self.len()
+    }
+
+    fn bytes_total(&self) -> usize {
+        self.capacity()
+    }
+}
+
+unsafe impl IoBuf for &'static [u8] {
+    fn stable_ptr(&self) -> *const u8 {
+        self.as_ptr()
+    }
+
+    fn bytes_init(&self) -> usize {
+        <[u8]>::len(self)
+    }
+
+    fn bytes_total(&self) -> usize {
+        self.bytes_init()
+    }
+}
+
+unsafe impl IoBuf for &'static str {
+    fn stable_ptr(&self) -> *const u8 {
+        self.as_ptr()
+    }
+
+    fn bytes_init(&self) -> usize {
+        <str>::len(self)
+    }
+
+    fn bytes_total(&self) -> usize {
+        self.bytes_init()
+    }
+}
+
+#[cfg(feature = "bytes")]
+unsafe impl IoBuf for bytes::Bytes {
+    fn stable_ptr(&self) -> *const u8 {
+        self.as_ptr()
+    }
+
+    fn bytes_init(&self) -> usize {
+        self.len()
+    }
+
+    fn bytes_total(&self) -> usize {
+        self.len()
+    }
+}
+
+#[cfg(feature = "bytes")]
+unsafe impl IoBuf for bytes::BytesMut {
+    fn stable_ptr(&self) -> *const u8 {
+        self.as_ptr()
+    }
+
+    fn bytes_init(&self) -> usize {
+        self.len()
+    }
+
+    fn bytes_total(&self) -> usize {
+        self.capacity()
+    }
+}