docs(net): multishot on io-uring (#860)

Author: Berrysoft

compio-net/src/tcp.rs

@@ -116,6 +116,10 @@ impl TcpListener {
     }
 
     /// Returns a stream of incoming connections to this listener.
+    ///
+    /// ## Platform specific
+    /// * io-uring: an old kernel may not support multishot operations, in which
+    ///   case this method will return an error in the first item of the stream.
     pub fn incoming(&self) -> TcpIncoming<'_> {
         TcpIncoming {
             inner: self.inner.incoming(),
@@ -476,12 +480,18 @@ impl AsyncReadManaged for &TcpStream {
     }
 }
 
+/// ## Platform specific
+/// * io-uring: an old kernel may not support multishot operations, in which
+///   case this method will return an error in the first item of the stream.
 impl AsyncReadMulti for TcpStream {
     fn read_multi(&mut self, len: usize) -> impl Stream<Item = io::Result<Self::Buffer>> {
         self.inner.recv_multi(len, 0)
     }
 }
 
+/// ## Platform specific
+/// * io-uring: an old kernel may not support multishot operations, in which
+///   case this method will return an error in the first item of the stream.
 impl AsyncReadMulti for &TcpStream {
     fn read_multi(&mut self, len: usize) -> impl Stream<Item = io::Result<Self::Buffer>> {
         self.inner.recv_multi(len, 0)
@@ -559,6 +569,9 @@ impl AsyncReadAncillaryManaged for &TcpStream {
     }
 }
 
+/// ## Platform specific
+/// * io-uring: an old kernel may not support multishot operations, in which
+///   case this method will return an error in the first item of the stream.
 impl AsyncReadAncillaryMulti for TcpStream {
     type Return = RecvMsgMultiResult;
 
@@ -571,6 +584,9 @@ impl AsyncReadAncillaryMulti for TcpStream {
     }
 }
 
+/// ## Platform specific
+/// * io-uring: an old kernel may not support multishot operations, in which
+///   case this method will return an error in the first item of the stream.
 impl AsyncReadAncillaryMulti for &TcpStream {
     type Return = RecvMsgMultiResult;
 

compio-net/src/udp.rs

@@ -221,6 +221,10 @@ impl UdpSocket {
     /// If `len` == 0, will use buffer pool's inner buffer size as the max len
     /// of each buffer; if `len` > 0, `min(len, inner buffer size)` will be
     /// the read max len of each buffer.
+    ///
+    /// ## Platform specific
+    /// * io-uring: an old kernel may not support multishot operations, in which
+    ///   case this method will return an error in the first item of the stream.
     pub fn recv_multi(&self, len: usize) -> impl Stream<Item = io::Result<BufferRef>> {
         self.inner.recv_multi(len, 0)
     }
@@ -292,6 +296,10 @@ impl UdpSocket {
 
     /// Read some bytes from this source and the runtime's buffer pool and
     /// return a stream of [`RecvFromMultiResult`].
+    ///
+    /// ## Platform specific
+    /// * io-uring: an old kernel may not support multishot operations, in which
+    ///   case this method will return an error in the first item of the stream.
     pub fn recv_from_multi(&self) -> impl Stream<Item = io::Result<RecvFromMultiResult>> {
         self.inner.recv_from_multi(0)
     }
@@ -361,6 +369,10 @@ impl UdpSocket {
 
     /// Receives multiple single datagram messages and ancillary data on the
     /// socket from the runtime's buffer pool.
+    ///
+    /// ## Platform specific
+    /// * io-uring: an old kernel may not support multishot operations, in which
+    ///   case this method will return an error in the first item of the stream.
     pub fn recv_msg_multi(
         &self,
         control_len: usize,

compio-net/src/unix.rs

@@ -110,6 +110,10 @@ impl UnixListener {
     }
 
     /// Returns a stream of incoming connections to this listener.
+    ///
+    /// ## Platform specific
+    /// * io-uring: an old kernel may not support multishot operations, in which
+    ///   case this method will return an error in the first item of the stream.
     pub fn incoming(&self) -> UnixIncoming<'_> {
         UnixIncoming {
             inner: self.inner.incoming(),
@@ -340,12 +344,18 @@ impl AsyncReadManaged for &UnixStream {
     }
 }
 
+/// ## Platform specific
+/// * io-uring: an old kernel may not support multishot operations, in which
+///   case this method will return an error in the first item of the stream.
 impl AsyncReadMulti for UnixStream {
     fn read_multi(&mut self, len: usize) -> impl Stream<Item = io::Result<Self::Buffer>> {
         self.inner.recv_multi(len, 0)
     }
 }
 
+/// ## Platform specific
+/// * io-uring: an old kernel may not support multishot operations, in which
+///   case this method will return an error in the first item of the stream.
 impl AsyncReadMulti for &UnixStream {
     fn read_multi(&mut self, len: usize) -> impl Stream<Item = io::Result<Self::Buffer>> {
         self.inner.recv_multi(len, 0)
@@ -423,6 +433,9 @@ impl AsyncReadAncillaryManaged for &UnixStream {
     }
 }
 
+/// ## Platform specific
+/// * io-uring: an old kernel may not support multishot operations, in which
+///   case this method will return an error in the first item of the stream.
 impl AsyncReadAncillaryMulti for UnixStream {
     type Return = RecvMsgMultiResult;
 
@@ -435,6 +448,9 @@ impl AsyncReadAncillaryMulti for UnixStream {
     }
 }
 
+/// ## Platform specific
+/// * io-uring: an old kernel may not support multishot operations, in which
+///   case this method will return an error in the first item of the stream.
 impl AsyncReadAncillaryMulti for &UnixStream {
     type Return = RecvMsgMultiResult;