linux-aio-tokio 0.4.1

Tokio bindings for Linux kernel AIO
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106

use crate::flags::{ReadFlags, WriteFlags};
use crate::locked_buf::LifetimeExtender;
use crate::{LockedBuf, aio};

/// Raw AIO command
#[derive(Debug)]
pub enum RawCommand<'a> {
    /// Read
    Pread {
        /// Offset
        offset: u64,
        /// Buffer
        buffer: &'a mut LockedBuf,
        /// Read flags
        flags: ReadFlags,
        /// Optional len
        len: u64,
    },

    /// Write
    Pwrite {
        /// Offset
        offset: u64,
        /// Buffer
        buffer: &'a LockedBuf,

        /// Write flags
        flags: WriteFlags,
        /// Optional len
        len: u64,
    },

    /// Sync data only
    Fdsync,

    /// Sync data and metadata
    Fsync,
}

impl<'a> RawCommand<'a> {
    pub(crate) fn opcode(&self) -> u32 {
        use RawCommand::*;

        match self {
            Pread { .. } => aio::IOCB_CMD_PREAD,
            Pwrite { .. } => aio::IOCB_CMD_PWRITE,
            Fdsync => aio::IOCB_CMD_FDSYNC,
            Fsync => aio::IOCB_CMD_FSYNC,
        }
    }

    pub(crate) fn offset(&self) -> Option<u64> {
        use RawCommand::*;

        match *self {
            Pread { offset, .. } => Some(offset),
            Pwrite { offset, .. } => Some(offset),
            Fdsync => None,
            Fsync => None,
        }
    }

    pub(crate) fn len(&self) -> Option<u64> {
        use RawCommand::*;

        match *self {
            Pread { len, .. } => Some(len),
            Pwrite { len, .. } => Some(len),
            Fdsync => None,
            Fsync => None,
        }
    }

    pub(crate) fn buffer_addr(&self) -> Option<(u64, u64)> {
        use RawCommand::*;

        match self {
            Pread { buffer, .. } => Some(buffer.aio_addr_and_len()),
            Pwrite { buffer, .. } => Some(buffer.aio_addr_and_len()),
            Fdsync => None,
            Fsync => None,
        }
    }

    pub(crate) fn flags(&self) -> Option<u32> {
        use RawCommand::*;

        match self {
            Pread { flags, .. } => Some(flags.bits() as _),
            Pwrite { flags, .. } => Some(flags.bits() as _),
            Fdsync => None,
            Fsync => None,
        }
    }

    pub(crate) fn buffer_lifetime_extender(&self) -> Option<LifetimeExtender> {
        use RawCommand::*;

        match self {
            Pread { buffer, .. } => Some(buffer.lifetime_extender()),
            Pwrite { buffer, .. } => Some(buffer.lifetime_extender()),
            Fdsync => None,
            Fsync => None,
        }
    }
}