Struct nix::sys::aio::LioCb[−][src]

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

Expand description

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

[src]

impl<'a> LioCb<'a>

[src]

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

Initialize an empty LioCb

[src]

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

[src]

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());