vfsi_sync/
io.rs

1use std::io::{self, Read, Seek, SeekFrom as IoSeekFrom, Write};
2use std::path::Path;
3
4use crate::traits::{validate_read_results, validate_write_results};
5use crate::{ReadOp, SeekFrom, VecFs, VfFile, VfOffset, WriteOp};
6
7fn io_error(error: crate::VfError) -> io::Error {
8    let kind = match error.err_no() {
9        crate::ERR_NOENT => io::ErrorKind::NotFound,
10        crate::ERR_EXIST => io::ErrorKind::AlreadyExists,
11        crate::ERR_ACCES => io::ErrorKind::PermissionDenied,
12        crate::ERR_NOTDIR => io::ErrorKind::NotADirectory,
13        crate::ERR_ISDIR => io::ErrorKind::IsADirectory,
14        crate::ERR_INVAL | crate::ERR_EBADF => io::ErrorKind::InvalidInput,
15        _ => io::ErrorKind::Other,
16    };
17    io::Error::new(kind, error)
18}
19
20/// Idiomatic Rust open options for a VFSI filesystem.
21#[derive(Clone, Debug)]
22pub struct VfOpenOptions {
23    read: bool,
24    write: bool,
25    append: bool,
26    truncate: bool,
27    create: bool,
28    create_new: bool,
29    mode: u32,
30}
31
32impl Default for VfOpenOptions {
33    fn default() -> Self {
34        Self {
35            read: false,
36            write: false,
37            append: false,
38            truncate: false,
39            create: false,
40            create_new: false,
41            mode: 0o666,
42        }
43    }
44}
45
46impl VfOpenOptions {
47    pub fn new() -> Self {
48        Self::default()
49    }
50
51    pub fn read(&mut self, value: bool) -> &mut Self {
52        self.read = value;
53        self
54    }
55
56    pub fn write(&mut self, value: bool) -> &mut Self {
57        self.write = value;
58        self
59    }
60
61    pub fn append(&mut self, value: bool) -> &mut Self {
62        self.append = value;
63        self
64    }
65
66    pub fn truncate(&mut self, value: bool) -> &mut Self {
67        self.truncate = value;
68        self
69    }
70
71    pub fn create(&mut self, value: bool) -> &mut Self {
72        self.create = value;
73        self
74    }
75
76    pub fn create_new(&mut self, value: bool) -> &mut Self {
77        self.create_new = value;
78        self
79    }
80
81    /// Unix permission bits used when a file is created.
82    pub fn mode(&mut self, mode: u32) -> &mut Self {
83        self.mode = mode;
84        self
85    }
86
87    fn flags(&self) -> io::Result<i32> {
88        let writable = self.write || self.append;
89        let mut flags = match (self.read, writable) {
90            (true, true) => libc::O_RDWR,
91            (false, true) => libc::O_WRONLY,
92            (true, false) => libc::O_RDONLY,
93            (false, false) => {
94                return Err(io::Error::new(
95                    io::ErrorKind::InvalidInput,
96                    "at least one of read, write, or append must be enabled",
97                ));
98            }
99        };
100        if self.truncate && !writable {
101            return Err(io::Error::new(
102                io::ErrorKind::InvalidInput,
103                "truncate requires write or append access",
104            ));
105        }
106        if (self.create || self.create_new) && !writable {
107            return Err(io::Error::new(
108                io::ErrorKind::InvalidInput,
109                "create requires write or append access",
110            ));
111        }
112        if self.append {
113            flags |= libc::O_APPEND;
114        }
115        if self.truncate {
116            flags |= libc::O_TRUNC;
117        }
118        if self.create || self.create_new {
119            flags |= libc::O_CREAT;
120        }
121        if self.create_new {
122            flags |= libc::O_EXCL;
123        }
124        Ok(flags)
125    }
126
127    /// Open a file whose lifetime is tied to the mutable filesystem borrow.
128    pub fn open<'a, F: VecFs + ?Sized>(
129        &self,
130        filesystem: &'a mut F,
131        path: impl AsRef<Path>,
132    ) -> io::Result<VfFileHandle<'a, F>> {
133        let file = filesystem
134            .open(path.as_ref(), self.flags()?, self.mode)
135            .map_err(io_error)?;
136        Ok(VfFileHandle {
137            filesystem,
138            file: Some(file),
139        })
140    }
141}
142
143/// RAII descriptor adapter implementing standard synchronous Rust I/O traits.
144///
145/// Dropping the handle closes the remote descriptor on a best-effort basis.
146/// Use [`close`](Self::close) when a close error must be observed.
147pub struct VfFileHandle<'a, F: VecFs + ?Sized> {
148    filesystem: &'a mut F,
149    file: Option<VfFile>,
150}
151
152impl<F: VecFs + ?Sized> VfFileHandle<'_, F> {
153    pub fn descriptor(&self) -> &VfFile {
154        self.file.as_ref().expect("open handle has a descriptor")
155    }
156
157    pub fn close(mut self) -> io::Result<()> {
158        let file = self.file.as_ref().expect("open handle has a descriptor");
159        self.filesystem.close(file).map_err(io_error)?;
160        self.file = None;
161        Ok(())
162    }
163}
164
165impl<F: VecFs + ?Sized> Read for VfFileHandle<'_, F> {
166    fn read(&mut self, buffer: &mut [u8]) -> io::Result<usize> {
167        if buffer.is_empty() {
168            return Ok(0);
169        }
170        let file = self.file.as_ref().expect("open handle").clone();
171        let requests = [ReadOp::new(file, VfOffset::Cur, buffer.len())];
172        let mut results = self.filesystem.readv(&requests).map_err(io_error)?;
173        validate_read_results("Read::read", &requests, &results).map_err(io_error)?;
174        let result = results.pop().expect("validated one read result");
175        buffer[..result.data.len()].copy_from_slice(&result.data);
176        Ok(result.data.len())
177    }
178}
179
180impl<F: VecFs + ?Sized> Write for VfFileHandle<'_, F> {
181    fn write(&mut self, buffer: &[u8]) -> io::Result<usize> {
182        if buffer.is_empty() {
183            return Ok(0);
184        }
185        let file = self.file.as_ref().expect("open handle").clone();
186        let owned = WriteOp::new(file, VfOffset::Cur, buffer.to_vec());
187        let requests = [crate::WriteOpRef {
188            file: &owned.file,
189            offset: owned.offset,
190            data: &owned.data,
191            creation: owned.creation,
192            truncate: owned.truncate,
193        }];
194        let mut results = self
195            .filesystem
196            .writev(std::slice::from_ref(&owned))
197            .map_err(io_error)?;
198        validate_write_results("Write::write", &requests, &results).map_err(io_error)?;
199        Ok(results.pop().expect("validated one write result").written)
200    }
201
202    fn flush(&mut self) -> io::Result<()> {
203        let file = self.file.as_ref().expect("open handle");
204        self.filesystem.sync_data(file).map_err(io_error)
205    }
206}
207
208impl<F: VecFs + ?Sized> Seek for VfFileHandle<'_, F> {
209    fn seek(&mut self, position: IoSeekFrom) -> io::Result<u64> {
210        let file = self.file.as_ref().expect("open handle").clone();
211        let (offset, whence) = match position {
212            IoSeekFrom::Start(offset) => (
213                i64::try_from(offset).map_err(|_| {
214                    io::Error::new(io::ErrorKind::InvalidInput, "seek offset exceeds i64")
215                })?,
216                SeekFrom::Set,
217            ),
218            IoSeekFrom::End(offset) => (offset, SeekFrom::End),
219            IoSeekFrom::Current(offset) => (offset, SeekFrom::Cur),
220        };
221        let result = self
222            .filesystem
223            .fseek(&file, offset, whence)
224            .map_err(io_error)?;
225        u64::try_from(result)
226            .map_err(|_| io::Error::new(io::ErrorKind::InvalidData, "negative seek result"))
227    }
228}
229
230impl<F: VecFs + ?Sized> Drop for VfFileHandle<'_, F> {
231    fn drop(&mut self) {
232        if let Some(file) = self.file.take() {
233            let _ = self.filesystem.close(&file);
234        }
235    }
236}
vfsi_sync/io.rs

vfsi_sync/
io.rs
