Struct nix::sys::aio::AioReadv

#[repr(transparent)]
pub struct AioReadv<'a> { /* private fields */ }

Available on crate feature aio only.

Asynchronously reads from a file descriptor into a scatter/gather list of buffers.

References

aio_readv

Examples

const INITIAL: &[u8] = b"abcdef123456";
let mut rbuf0 = vec![0; 4];
let mut rbuf1 = vec![0; 2];
let expected_len = rbuf0.len() + rbuf1.len();
let mut rbufs = [IoSliceMut::new(&mut rbuf0), IoSliceMut::new(&mut rbuf1)];
let mut f = tempfile().unwrap();
f.write_all(INITIAL).unwrap();
{
   let mut aior = Box::pin(
       AioReadv::new(
           f.as_raw_fd(),
           2,   //offset
           &mut rbufs,
           0,   //priority
           SigevNotify::SigevNone
       )
   );
   aior.as_mut().submit().unwrap();
   while (aior.as_mut().error() == Err(Errno::EINPROGRESS)) {
       thread::sleep(time::Duration::from_millis(10));
   }
   assert_eq!(aior.as_mut().aio_return().unwrap(), expected_len);
}
assert_eq!(rbuf0, b"cdef");
assert_eq!(rbuf1, b"12");

Implementations

impl<'a> AioReadv<'a>

pub fn iovlen(&self) -> usize

Returns the number of buffers the operation will read into.

pub fn new(
    fd: RawFd,
    offs: off_t,
    bufs: &mut [IoSliceMut<'a>],
    prio: i32,
    sigev_notify: SigevNotify
) -> Self

Create a new AioReadv, placing the data in a list of mutable slices.

Arguments

• fd: File descriptor to read from
• offs: File offset
• bufs: A scatter/gather list of memory buffers. They must outlive the AioReadv.
• prio: If POSIX Prioritized IO is supported, then the operation will be prioritized at the process’s priority level minus prio
• sigev_notify: Determines how you will be notified of event completion.

pub fn offset(&self) -> off_t

Returns the file offset of the operation.

Trait Implementations

impl<'a> Aio for AioReadv<'a>

type Output = usize

The return type of Aio::aio_return.

fn cancel(self: Pin<&mut Self>) -> Result<AioCancelStat>

Cancels an outstanding AIO request.

fn error(self: Pin<&mut Self>) -> Result<()>

Retrieve error status of an asynchronous operation.

fn fd(&self) -> RawFd

Returns the underlying file descriptor associated with the operation.

fn in_progress(&self) -> bool

Does this operation currently have any in-kernel state?

fn priority(&self) -> i32

Returns the priority of the AioCb

fn set_sigev_notify(&mut self, sev: SigevNotify)

Update the notification settings for an existing AIO operation that has not yet been submitted.

fn sigevent(&self) -> SigEvent

Returns the SigEvent that will be used for notification.

fn aio_return(self: Pin<&mut Self>) -> Result<<Self as Aio>::Output>

Retrieve return status of an asynchronous operation.

fn submit(self: Pin<&mut Self>) -> Result<()>

Actually start the I/O operation.

impl<'a> AsMut<aiocb> for AioReadv<'a>

fn as_mut(&mut self) -> &mut aiocb

Converts this type into a mutable reference of the (usually inferred) input type.

impl<'a> AsRef<aiocb> for AioReadv<'a>

fn as_ref(&self) -> &aiocb

Converts this type into a shared reference of the (usually inferred) input type.

impl<'a> Debug for AioReadv<'a>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.