Struct nix::sys::aio::LioCb

pub struct LioCb<'a> {
    pub aiocbs: Vec<AioCb<'a>>,
    /* private fields */
}

LIO Control Block.

The basic structure used to issue multiple AIO operations simultaneously.

Fields

aiocbs: Vec<AioCb<'a>>

A collection of AioCbs. All of these will be issued simultaneously by the listio method.

Implementations

impl<'a> LioCb<'a>

pub fn with_capacity(capacity: usize) -> LioCb<'a>

Initialize an empty LioCb

pub fn listio(&mut self, mode: LioMode, sigev_notify: SigevNotify) -> Result<()>

Submits multiple asynchronous I/O requests with a single system call.

They are not guaranteed to complete atomically, and the order in which the requests are carried out is not specified. Reads, writes, and fsyncs may be freely mixed.

This function is useful for reducing the context-switch overhead of submitting many AIO operations. It can also be used with LioMode::LIO_WAIT to block on the result of several independent operations. Used that way, it is often useful in programs that otherwise make little use of AIO.

Examples

Use listio to submit an aio operation and wait for its completion. In this case, there is no need to use aio_suspend to wait or AioCb::error to poll.

const WBUF: &[u8] = b"abcdef123456";
let mut f = tempfile().unwrap();
let mut liocb = LioCb::with_capacity(1);
liocb.aiocbs.push(AioCb::from_slice( f.as_raw_fd(),
    2,   //offset
    WBUF,
    0,   //priority
    SigevNotify::SigevNone,
    LioOpcode::LIO_WRITE));
liocb.listio(LioMode::LIO_WAIT,
             SigevNotify::SigevNone).unwrap();
assert_eq!(liocb.aio_return(0).unwrap() as usize, WBUF.len());

References

lio_listio

pub fn listio_resubmit(
    &mut self,
    mode: LioMode,
    sigev_notify: SigevNotify
) -> Result<()>

Resubmits any incomplete operations with lio_listio.

Sometimes, due to system resource limitations, an lio_listio call will return EIO, or EAGAIN. Or, if a signal is received, it may return EINTR. In any of these cases, only a subset of its constituent operations will actually have been initiated. listio_resubmit will resubmit any operations that are still uninitiated.

After calling listio_resubmit, results should be collected by LioCb::aio_return.

Examples

const WBUF: &[u8] = b"abcdef123456";
let mut f = tempfile().unwrap();
let mut liocb = LioCb::with_capacity(1);
liocb.aiocbs.push(AioCb::from_slice( f.as_raw_fd(),
    2,   //offset
    WBUF,
    0,   //priority
    SigevNotify::SigevNone,
    LioOpcode::LIO_WRITE));
let mut err = liocb.listio(LioMode::LIO_WAIT, SigevNotify::SigevNone);
while err == Err(Error::Sys(Errno::EIO)) ||
      err == Err(Error::Sys(Errno::EAGAIN)) {
    thread::sleep(time::Duration::from_millis(10));
    err = liocb.listio_resubmit(LioMode::LIO_WAIT, SigevNotify::SigevNone);
}
assert_eq!(liocb.aio_return(0).unwrap() as usize, WBUF.len());

References

lio_listio

pub fn aio_return(&mut self, i: usize) -> Result<isize>

Collect final status for an individual AioCb submitted as part of an LioCb.

This is just like AioCb::aio_return, except it takes into account operations that were restarted by LioCb::listio_resubmit

pub fn error(&mut self, i: usize) -> Result<()>

Retrieve error status of an individual AioCb submitted as part of an LioCb.

This is just like AioCb::error, except it takes into account operations that were restarted by LioCb::listio_resubmit

Trait Implementations

impl<'a> Debug for LioCb<'a>

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

Formats the value using the given formatter.

impl<'a> From<Vec<AioCb<'a>, Global>> for LioCb<'a>

fn from(src: Vec<AioCb<'a>>) -> LioCb<'a>

Converts to this type from the input type.