dope 0.12.0

The manifold runtime
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
107
108
109
110
111

use std::io;
use std::mem::MaybeUninit;
use std::os::fd::{AsRawFd, RawFd};
use std::ptr::NonNull;

pub(in crate::manifold::file) mod table;

use super::source::Source;
use dope_core::backend::Backend;
use dope_core::backend::RawSqe;
use dope_core::driver::token::Token;
use dope_core::io::file::OpenPath;
use dope_core::platform::Platform;
use std::io::Error;
use std::io::ErrorKind;

type StatBuf = <Backend as Platform>::StatBuf;

pub(super) struct OpenRequest {
    path: OpenPath,
}

impl OpenRequest {
    pub(super) fn new(path: OpenPath) -> Self {
        Self { path }
    }

    pub(super) fn submission(&self, flags: i32, token: Token) -> RawSqe {
        self.path.open_at(flags, token)
    }
}

enum StatSource<'d> {
    Path(OpenPath),
    Fd(Source<'d>),
}

pub(super) struct StatRequest<'d> {
    source: StatSource<'d>,
    output: MaybeUninit<StatBuf>,
}

impl<'d> StatRequest<'d> {
    pub(super) fn path(path: OpenPath) -> Self {
        Self {
            source: StatSource::Path(path),
            output: MaybeUninit::zeroed(),
        }
    }

    pub(super) fn fd(source: Source<'d>) -> Self {
        Self {
            source: StatSource::Fd(source),
            output: MaybeUninit::zeroed(),
        }
    }

    pub(super) fn submission(&mut self, token: Token) -> RawSqe {
        let output = self.output.as_mut_ptr();
        match &self.source {
            StatSource::Path(path) => RawSqe::stat_path(path.as_ptr(), output, token),
            StatSource::Fd(fd) => RawSqe::stat_fd(fd.as_raw_fd(), output, token),
        }
    }

    pub(super) fn complete(&mut self) -> StatBuf {
        unsafe { self.output.assume_init_read() }
    }
}

pub(super) struct ReadRegion {
    ptr: NonNull<MaybeUninit<u8>>,
    len: u32,
}

impl ReadRegion {
    pub(super) fn new(buffer: &mut Vec<u8>) -> Option<Self> {
        let len = buffer.len().min(u32::MAX as usize) as u32;
        (len != 0).then(|| Self {
            ptr: unsafe { NonNull::new_unchecked(buffer.as_mut_ptr().cast()) },
            len,
        })
    }

    pub(super) fn submission(self, fd: RawFd, offset: u64, token: Token) -> (RawSqe, Self) {
        let sqe = RawSqe::read_raw(
            fd,
            self.ptr.as_ptr().cast(),
            self.len as usize,
            offset,
            token,
        );
        (sqe, self)
    }

    pub(super) fn commit(self, buffer: &mut Vec<u8>, amount: u32) -> io::Result<()> {
        if amount > self.len {
            return Err(Error::new(
                ErrorKind::InvalidData,
                "dope::file: completion exceeded its prepared read region",
            ));
        }
        if buffer.as_mut_ptr().cast() != self.ptr.as_ptr() || buffer.len() < self.len as usize {
            return Err(Error::new(
                ErrorKind::InvalidData,
                "dope::file: prepared read buffer changed before completion",
            ));
        }
        Ok(())
    }
}