Remove Pin<Box<Op<T>>> due to Lifecycle migration to ArcMonitor on Op<T>

Lucas Paixão · Lucas Paixão · commit fcba072aca6a · 2025-04-24T14:33:33.000-03:00
diff --git a/src/io/accept.rs b/src/io/accept.rs
@@ -3,7 +3,6 @@ use crate::runtime::driver::op;
 use crate::runtime::driver::op::{Completable, Op};
 use crate::runtime::CONTEXT;
 use std::net::SocketAddr;
-use std::pin::Pin;
 use std::{boxed::Box, io};
 
 pub(crate) struct Accept {
@@ -12,7 +11,7 @@ pub(crate) struct Accept {
 }
 
 impl Op<Accept> {
-  pub(crate) fn accept(fd: &SharedFd) -> io::Result<Pin<Box<Op<Accept>>>> {
+  pub(crate) fn accept(fd: &SharedFd) -> io::Result<Op<Accept>> {
     use io_uring::{opcode, types};
 
     let socketaddr = Box::new((
diff --git a/src/io/close.rs b/src/io/close.rs
@@ -3,14 +3,13 @@ use crate::runtime::driver::op::{Completable, Op};
 use crate::runtime::CONTEXT;
 use std::io;
 use std::os::unix::io::RawFd;
-use std::pin::Pin;
 
 pub(crate) struct Close {
   fd: RawFd,
 }
 
 impl Op<Close> {
-  pub(crate) fn close(fd: RawFd) -> io::Result<Pin<Box<Op<Close>>>> {
+  pub(crate) fn close(fd: RawFd) -> io::Result<Op<Close>> {
     use io_uring::{opcode, types};
 
     CONTEXT.with(|x| {
diff --git a/src/io/connect.rs b/src/io/connect.rs
@@ -3,7 +3,6 @@ use crate::runtime::driver::op::{Completable, CqeResult, Op};
 use crate::runtime::CONTEXT;
 use socket2::SockAddr;
 use std::io;
-use std::pin::Pin;
 
 /// Open a file
 pub(crate) struct Connect {
@@ -15,7 +14,7 @@ pub(crate) struct Connect {
 
 impl Op<Connect> {
   /// Submit a request to connect.
-  pub(crate) fn connect(fd: &SharedFd, socket_addr: SockAddr) -> io::Result<Pin<Box<Op<Connect>>>> {
+  pub(crate) fn connect(fd: &SharedFd, socket_addr: SockAddr) -> io::Result<Op<Connect>> {
     use io_uring::{opcode, types};
 
     CONTEXT.with(|x| {
diff --git a/src/io/fallocate.rs b/src/io/fallocate.rs
@@ -1,6 +1,5 @@
 use io_uring::{opcode, types};
 use std::io;
-use std::pin::Pin;
 
 use crate::{
   io::SharedFd,
@@ -20,7 +19,7 @@ impl Op<Fallocate> {
     offset: u64,
     len: u64,
     flags: i32,
-  ) -> io::Result<Pin<Box<Op<Fallocate>>>> {
+  ) -> io::Result<Op<Fallocate>> {
     CONTEXT.with(|x| {
       x.handle()
         .submit_op(Fallocate { fd: fd.clone() }, |fallocate| {
diff --git a/src/io/fsync.rs b/src/io/fsync.rs
@@ -3,22 +3,21 @@ use crate::runtime::driver::op::{Completable, CqeResult, Op};
 use crate::runtime::CONTEXT;
 use io_uring::{opcode, types};
 use std::io;
-use std::pin::Pin;
 
 pub(crate) struct Fsync {
   fd: SharedFd,
 }
 
 impl Op<Fsync> {
-  pub(crate) fn fsync(fd: &SharedFd) -> io::Result<Pin<Box<Op<Fsync>>>> {
+  pub(crate) fn fsync(fd: &SharedFd) -> io::Result<Op<Fsync>> {
     CONTEXT.with(|x| {
       x.handle().submit_op(Fsync { fd: fd.clone() }, |fsync| {
         opcode::Fsync::new(types::Fd(fsync.fd.raw_fd())).build()
       })
     })
   }
 
-  pub(crate) fn datasync(fd: &SharedFd) -> io::Result<Pin<Box<Op<Fsync>>>> {
+  pub(crate) fn datasync(fd: &SharedFd) -> io::Result<Op<Fsync>> {
     CONTEXT.with(|x| {
       x.handle().submit_op(Fsync { fd: fd.clone() }, |fsync| {
         opcode::Fsync::new(types::Fd(fsync.fd.raw_fd()))
diff --git a/src/io/mkdir_at.rs b/src/io/mkdir_at.rs
@@ -6,7 +6,6 @@ use super::util::cstr;
 use std::ffi::CString;
 use std::io;
 use std::path::Path;
-use std::pin::Pin;
 
 /// Create a directory at path relative to the current working directory
 /// of the caller's process.
@@ -16,7 +15,7 @@ pub(crate) struct Mkdir {
 
 impl Op<Mkdir> {
   /// Submit a request to create a directory
-  pub(crate) fn make_dir(path: &Path, mode: u32) -> io::Result<Pin<Box<Op<Mkdir>>>> {
+  pub(crate) fn make_dir(path: &Path, mode: u32) -> io::Result<Op<Mkdir>> {
     use io_uring::{opcode, types};
 
     let _path = cstr(path)?;
diff --git a/src/io/noop.rs b/src/io/noop.rs
@@ -1,15 +1,14 @@
 use crate::runtime::driver::op::{Completable, CqeResult, Op};
 use crate::runtime::CONTEXT;
 use std::io;
-use std::pin::Pin;
 
 /// No operation. Just posts a completion event, nothing else.
 ///
 /// Has a place in benchmarking.
 pub struct NoOp {}
 
 impl Op<NoOp> {
-  pub fn no_op() -> io::Result<Pin<Box<Op<NoOp>>>> {
+  pub fn no_op() -> io::Result<Op<NoOp>> {
     use io_uring::opcode;
 
     CONTEXT.with(|x| {
diff --git a/src/io/open.rs b/src/io/open.rs
@@ -6,7 +6,6 @@ use crate::runtime::CONTEXT;
 use std::ffi::CString;
 use std::io;
 use std::path::Path;
-use std::pin::Pin;
 
 /// Open a file
 #[allow(dead_code)]
@@ -17,7 +16,7 @@ pub(crate) struct Open {
 
 impl Op<Open> {
   /// Submit a request to open a file.
-  pub(crate) fn open(path: &Path, options: &OpenOptions) -> io::Result<Pin<Box<Op<Open>>>> {
+  pub(crate) fn open(path: &Path, options: &OpenOptions) -> io::Result<Op<Open>> {
     use io_uring::{opcode, types};
     let path = super::util::cstr(path)?;
     let flags = libc::O_CLOEXEC
diff --git a/src/io/read.rs b/src/io/read.rs
@@ -5,7 +5,6 @@ use crate::BufResult;
 use crate::runtime::driver::op::{Completable, CqeResult, Op};
 use crate::runtime::CONTEXT;
 use std::io;
-use std::pin::Pin;
 
 pub(crate) struct Read<T> {
   /// Holds a strong ref to the FD, preventing the file from being closed
@@ -18,7 +17,7 @@ pub(crate) struct Read<T> {
 }
 
 impl<T: BoundedBufMut> Op<Read<T>> {
-  pub(crate) fn read_at(fd: &SharedFd, buf: T, offset: u64) -> io::Result<Pin<Box<Op<Read<T>>>>> {
+  pub(crate) fn read_at(fd: &SharedFd, buf: T, offset: u64) -> io::Result<Op<Read<T>>> {
     use io_uring::{opcode, types};
 
     CONTEXT.with(|x| {
diff --git a/src/io/read_fixed.rs b/src/io/read_fixed.rs
@@ -6,7 +6,6 @@ use crate::BufResult;
 
 use crate::runtime::CONTEXT;
 use std::io;
-use std::pin::Pin;
 
 pub(crate) struct ReadFixed<T> {
   /// Holds a strong ref to the FD, preventing the file from being closed
@@ -22,11 +21,7 @@ impl<T> Op<ReadFixed<T>>
 where
   T: BoundedBufMut<BufMut = FixedBuf>,
 {
-  pub(crate) fn read_fixed_at(
-    fd: &SharedFd,
-    buf: T,
-    offset: u64,
-  ) -> io::Result<Pin<Box<Op<ReadFixed<T>>>>> {
+  pub(crate) fn read_fixed_at(fd: &SharedFd, buf: T, offset: u64) -> io::Result<Op<ReadFixed<T>>> {
     use io_uring::{opcode, types};
 
     CONTEXT.with(|x| {
diff --git a/src/io/readv.rs b/src/io/readv.rs
@@ -6,7 +6,6 @@ use crate::runtime::driver::op::{Completable, CqeResult, Op};
 use crate::runtime::CONTEXT;
 use libc::iovec;
 use std::io;
-use std::pin::Pin;
 
 pub(crate) struct Readv<T> {
   /// Holds a strong ref to the FD, preventing the file from being closed
@@ -21,11 +20,7 @@ pub(crate) struct Readv<T> {
 }
 
 impl<T: BoundedBufMut> Op<Readv<T>> {
-  pub(crate) fn readv_at(
-    fd: &SharedFd,
-    mut bufs: Vec<T>,
-    offset: u64,
-  ) -> io::Result<Pin<Box<Op<Readv<T>>>>> {
+  pub(crate) fn readv_at(fd: &SharedFd, mut bufs: Vec<T>, offset: u64) -> io::Result<Op<Readv<T>>> {
     use io_uring::{opcode, types};
 
     // Build `iovec` objects referring the provided `bufs` for `io_uring::opcode::Readv`.
diff --git a/src/io/recv_from.rs b/src/io/recv_from.rs
@@ -2,7 +2,6 @@ use crate::runtime::driver::op::{Completable, CqeResult, Op};
 use crate::runtime::CONTEXT;
 use crate::{buf::BoundedBufMut, io::SharedFd, BufResult};
 use socket2::SockAddr;
-use std::pin::Pin;
 use std::{
   io::IoSliceMut,
   {boxed::Box, io, net::SocketAddr},
@@ -18,7 +17,7 @@ pub(crate) struct RecvFrom<T> {
 }
 
 impl<T: BoundedBufMut> Op<RecvFrom<T>> {
-  pub(crate) fn recv_from(fd: &SharedFd, mut buf: T) -> io::Result<Pin<Box<Op<RecvFrom<T>>>>> {
+  pub(crate) fn recv_from(fd: &SharedFd, mut buf: T) -> io::Result<Op<RecvFrom<T>>> {
     use io_uring::{opcode, types};
 
     let mut io_slices = vec![IoSliceMut::new(unsafe {
diff --git a/src/io/recvmsg.rs b/src/io/recvmsg.rs
@@ -2,7 +2,6 @@ use crate::runtime::driver::op::{Completable, CqeResult, Op};
 use crate::runtime::CONTEXT;
 use crate::{buf::BoundedBufMut, io::SharedFd, BufResult};
 use socket2::SockAddr;
-use std::pin::Pin;
 use std::{
   io::IoSliceMut,
   {boxed::Box, io, net::SocketAddr},
@@ -19,7 +18,7 @@ pub(crate) struct RecvMsg<T> {
 }
 
 impl<T: BoundedBufMut> Op<RecvMsg<T>> {
-  pub(crate) fn recvmsg(fd: &SharedFd, mut bufs: Vec<T>) -> io::Result<Pin<Box<Op<RecvMsg<T>>>>> {
+  pub(crate) fn recvmsg(fd: &SharedFd, mut bufs: Vec<T>) -> io::Result<Op<RecvMsg<T>>> {
     use io_uring::{opcode, types};
 
     let mut io_slices = Vec::with_capacity(bufs.len());
diff --git a/src/io/rename_at.rs b/src/io/rename_at.rs
@@ -3,7 +3,6 @@ use crate::runtime::CONTEXT;
 use std::ffi::CString;
 use std::io;
 use std::path::Path;
-use std::pin::Pin;
 
 /// Renames a file, moving it between directories if required.
 ///
@@ -17,11 +16,7 @@ pub(crate) struct RenameAt {
 impl Op<RenameAt> {
   /// Submit a request to rename a specified path to a new name with
   /// the provided flags.
-  pub(crate) fn rename_at(
-    from: &Path,
-    to: &Path,
-    flags: u32,
-  ) -> io::Result<Pin<Box<Op<RenameAt>>>> {
+  pub(crate) fn rename_at(from: &Path, to: &Path, flags: u32) -> io::Result<Op<RenameAt>> {
     use io_uring::{opcode, types};
 
     let from = super::util::cstr(from)?;
diff --git a/src/io/send_to.rs b/src/io/send_to.rs
@@ -5,7 +5,6 @@ use crate::runtime::CONTEXT;
 use crate::BufResult;
 use socket2::SockAddr;
 use std::io::IoSlice;
-use std::pin::Pin;
 use std::{boxed::Box, io, net::SocketAddr};
 
 pub(crate) struct SendTo<T> {
@@ -24,7 +23,7 @@ impl<T: BoundedBuf> Op<SendTo<T>> {
     fd: &SharedFd,
     buf: T,
     socket_addr: Option<SocketAddr>,
-  ) -> io::Result<Pin<Box<Op<SendTo<T>>>>> {
+  ) -> io::Result<Op<SendTo<T>>> {
     use io_uring::{opcode, types};
 
     let io_slices = vec![IoSlice::new(unsafe {
diff --git a/src/io/send_zc.rs b/src/io/send_zc.rs
@@ -2,7 +2,6 @@ use crate::runtime::driver::op::{Completable, CqeResult, MultiCQE, Op, Updateabl
 use crate::runtime::CONTEXT;
 use crate::{buf::BoundedBuf, io::SharedFd, BufResult};
 use std::io;
-use std::pin::Pin;
 
 pub(crate) struct SendZc<T> {
   /// Holds a strong ref to the FD, preventing the file from being closed
@@ -17,7 +16,7 @@ pub(crate) struct SendZc<T> {
 }
 
 impl<T: BoundedBuf> Op<SendZc<T>, MultiCQE> {
-  pub(crate) fn send_zc(fd: &SharedFd, buf: T) -> io::Result<Pin<Box<Self>>> {
+  pub(crate) fn send_zc(fd: &SharedFd, buf: T) -> io::Result<Self> {
     use io_uring::{opcode, types};
 
     CONTEXT.with(|x| {
diff --git a/src/io/sendmsg.rs b/src/io/sendmsg.rs
@@ -6,7 +6,6 @@ use socket2::SockAddr;
 use std::io;
 use std::io::IoSlice;
 use std::net::SocketAddr;
-use std::pin::Pin;
 
 pub(crate) struct SendMsg<T, U> {
   _fd: SharedFd,
@@ -23,7 +22,7 @@ impl<T: BoundedBuf, U: BoundedBuf> Op<SendMsg<T, U>> {
     io_bufs: Vec<T>,
     socket_addr: Option<SocketAddr>,
     msg_control: Option<U>,
-  ) -> io::Result<Pin<Box<Self>>> {
+  ) -> io::Result<Self> {
     use io_uring::{opcode, types};
 
     let mut msghdr: Box<libc::msghdr> = Box::new(unsafe { std::mem::zeroed() });
diff --git a/src/io/sendmsg_zc.rs b/src/io/sendmsg_zc.rs
@@ -6,7 +6,6 @@ use socket2::SockAddr;
 use std::io;
 use std::io::IoSlice;
 use std::net::SocketAddr;
-use std::pin::Pin;
 
 pub(crate) struct SendMsgZc<T, U> {
   #[allow(dead_code)]
@@ -30,7 +29,7 @@ impl<T: BoundedBuf, U: BoundedBuf> Op<SendMsgZc<T, U>, MultiCQE> {
     io_bufs: Vec<T>,
     socket_addr: Option<SocketAddr>,
     msg_control: Option<U>,
-  ) -> io::Result<Pin<Box<Self>>> {
+  ) -> io::Result<Self> {
     use io_uring::{opcode, types};
 
     let mut msghdr: Box<libc::msghdr> = Box::new(unsafe { std::mem::zeroed() });
diff --git a/src/io/statx.rs b/src/io/statx.rs
@@ -1,6 +1,5 @@
 use io_uring::{opcode, types};
 use std::ffi::CString;
-use std::pin::Pin;
 use std::{ffi::CStr, io};
 
 use crate::runtime::{
@@ -30,7 +29,7 @@ impl Op<Statx> {
     path: Option<CString>,
     flags: i32,
     mask: u32,
-  ) -> io::Result<Pin<Box<Op<Statx>>>> {
+  ) -> io::Result<Op<Statx>> {
     let raw = fd.as_ref().map_or(libc::AT_FDCWD, |fd| fd.raw_fd());
     let mut flags = flags;
     let path = match path {
diff --git a/src/io/symlink.rs b/src/io/symlink.rs
@@ -6,18 +6,14 @@ use super::util::cstr;
 use std::ffi::CString;
 use std::io;
 use std::path::Path;
-use std::pin::Pin;
 
 pub(crate) struct Symlink {
   pub(crate) _from: CString,
   pub(crate) _to: CString,
 }
 
 impl Op<Symlink> {
-  pub(crate) fn symlink<P: AsRef<Path>, Q: AsRef<Path>>(
-    from: P,
-    to: Q,
-  ) -> io::Result<Pin<Box<Op<Symlink>>>> {
+  pub(crate) fn symlink<P: AsRef<Path>, Q: AsRef<Path>>(from: P, to: Q) -> io::Result<Op<Symlink>> {
     use io_uring::{opcode, types};
 
     let _from = cstr(from.as_ref())?;
diff --git a/src/io/unlink_at.rs b/src/io/unlink_at.rs
@@ -3,7 +3,6 @@ use crate::runtime::CONTEXT;
 use std::ffi::CString;
 use std::io;
 use std::path::Path;
-use std::pin::Pin;
 
 /// Unlink a path relative to the current working directory of the caller's process.
 pub(crate) struct Unlink {
@@ -12,17 +11,17 @@ pub(crate) struct Unlink {
 
 impl Op<Unlink> {
   /// Submit a request to unlink a directory with provided flags.
-  pub(crate) fn unlink_dir(path: &Path) -> io::Result<Pin<Box<Op<Unlink>>>> {
+  pub(crate) fn unlink_dir(path: &Path) -> io::Result<Op<Unlink>> {
     Self::unlink(path, libc::AT_REMOVEDIR)
   }
 
   /// Submit a request to unlink a file with provided flags.
-  pub(crate) fn unlink_file(path: &Path) -> io::Result<Pin<Box<Op<Unlink>>>> {
+  pub(crate) fn unlink_file(path: &Path) -> io::Result<Op<Unlink>> {
     Self::unlink(path, 0)
   }
 
   /// Submit a request to unlink a specified path with provided flags.
-  pub(crate) fn unlink(path: &Path, flags: i32) -> io::Result<Pin<Box<Op<Unlink>>>> {
+  pub(crate) fn unlink(path: &Path, flags: i32) -> io::Result<Op<Unlink>> {
     use io_uring::{opcode, types};
 
     let path = super::util::cstr(path)?;
diff --git a/src/io/write_fixed.rs b/src/io/write_fixed.rs
diff --git a/src/io/writev.rs b/src/io/writev.rs
diff --git a/src/io/writev_all.rs b/src/io/writev_all.rs
diff --git a/src/runtime/driver/handle.rs b/src/runtime/driver/handle.rs
diff --git a/src/runtime/driver/mod.rs b/src/runtime/driver/mod.rs
diff --git a/src/runtime/driver/op/mod.rs b/src/runtime/driver/op/mod.rs
