Pop the op later.

compio-driver/src/iocp/mod.rs

@@ -293,8 +293,7 @@ impl<T> Overlapped<T> {
     }
 }
 
-#[doc(hidden)]
-pub struct RawOp(NonNull<Overlapped<dyn OpCode>>);
+pub(crate) struct RawOp(NonNull<Overlapped<dyn OpCode>>);
 
 impl RawOp {
     pub(crate) fn new(user_data: usize, op: impl OpCode + 'static) -> Self {

compio-driver/src/iour/mod.rs

@@ -15,8 +15,7 @@ use slab::Slab;
 use crate::Entry;
 
 pub(crate) mod op;
-#[doc(hidden)]
-pub use crate::unix::RawOp;
+pub(crate) use crate::unix::RawOp;
 
 /// Abstraction of io-uring operations.
 pub trait OpCode {

compio-driver/src/lib.rs

@@ -253,18 +253,13 @@ impl Operation {
         Self { op, user_data }
     }
 
-    #[doc(hidden)]
-    pub fn into_inner(self) -> RawOp {
-        self.op
-    }
-
     /// Restore the original operation.
     ///
     /// # Safety
     ///
     /// The caller should guarantee that the type is right.
     pub unsafe fn into_op<T: OpCode>(self) -> T {
-        self.into_inner().into_inner()
+        self.op.into_inner()
     }
 
     /// The same user_data when the operation is pushed into the driver.

compio-driver/src/poll/mod.rs

@@ -17,8 +17,7 @@ use slab::Slab;
 use crate::{syscall, Entry};
 
 pub(crate) mod op;
-#[doc(hidden)]
-pub use crate::unix::RawOp;
+pub(crate) use crate::unix::RawOp;
 
 /// Abstraction of operations.
 pub trait OpCode {

compio-driver/src/unix/mod.rs

@@ -7,8 +7,7 @@ use std::{mem::ManuallyDrop, pin::Pin, ptr::NonNull};
 
 use crate::OpCode;
 
-#[doc(hidden)]
-pub struct RawOp(NonNull<dyn OpCode>);
+pub(crate) struct RawOp(NonNull<dyn OpCode>);
 
 impl RawOp {
     pub(crate) fn new(_user_data: usize, op: impl OpCode + 'static) -> Self {

compio-runtime/src/runtime/mod.rs

@@ -118,11 +118,13 @@ impl Runtime {
         let mut op_runtime = self.op_runtime.borrow_mut();
         if op_runtime.has_result(*user_data) {
             let op = op_runtime.remove(*user_data);
-            Poll::Ready(BufResult(op.result.unwrap(), unsafe {
-                op.op
-                    .expect("`poll_task` called on dummy Op")
-                    .into_inner::<T>()
-            }))
+            let res = self
+                .driver
+                .borrow_mut()
+                .pop(&mut op.entry.into_iter())
+                .next()
+                .expect("the result should have come");
+            Poll::Ready(res.map_buffer(|op| unsafe { op.into_op::<T>() }))
         } else {
             op_runtime.update_waker(*user_data, cx.waker().clone());
             Poll::Pending
@@ -150,12 +152,10 @@ impl Runtime {
         let mut driver = self.driver.borrow_mut();
         match driver.poll(timeout, &mut entries) {
             Ok(_) => {
-                for BufResult(res, op) in driver.pop(&mut entries.into_iter()) {
-                    self.op_runtime.borrow_mut().update_result(
-                        op.user_data(),
-                        op.into_inner(),
-                        res,
-                    );
+                for entry in entries {
+                    self.op_runtime
+                        .borrow_mut()
+                        .update_result(entry.user_data(), entry);
                 }
             }
             Err(e) => match e.kind() {

compio-runtime/src/runtime/op.rs

@@ -1,21 +1,19 @@
 use std::{
     collections::HashMap,
     future::Future,
-    io,
     pin::Pin,
     task::{Context, Poll, Waker},
 };
 
 use compio_buf::BufResult;
-use compio_driver::{OpCode, RawOp};
+use compio_driver::{Entry, OpCode};
 
 use crate::key::Key;
 
 #[derive(Default)]
 pub(crate) struct RegisteredOp {
-    pub op: Option<RawOp>,
     pub waker: Option<Waker>,
-    pub result: Option<io::Result<usize>>,
+    pub entry: Option<Entry>,
     pub cancelled: bool,
 }
 
@@ -29,13 +27,12 @@ impl OpRuntime {
         self.ops.entry(key).or_default().waker = Some(waker);
     }
 
-    pub fn update_result(&mut self, key: usize, raw_op: RawOp, result: io::Result<usize>) {
+    pub fn update_result(&mut self, key: usize, entry: Entry) {
         let op = self.ops.entry(key).or_default();
         if let Some(waker) = op.waker.take() {
             waker.wake();
         }
-        op.op = Some(raw_op);
-        op.result = Some(result);
+        op.entry = Some(entry);
         if op.cancelled {
             self.remove(key);
         }
@@ -44,7 +41,7 @@ impl OpRuntime {
     pub fn has_result(&mut self, key: usize) -> bool {
         self.ops
             .get_mut(&key)
-            .map(|op| op.result.is_some())
+            .map(|op| op.entry.is_some())
             .unwrap_or_default()
     }