fs_core/
file_device.rs

1//! File-backed `BlockDevice`. Used for disk images, raw `/dev/diskN` reads,
2//! anything that std::fs::File can address.
3
4use crate::block::{BlockDevice, BlockRead};
5use crate::error::{Error, Result};
6use std::fs::{File, OpenOptions};
7use std::io::{Read, Seek, SeekFrom, Write};
8use std::path::Path;
9use std::sync::Mutex;
10
11pub struct FileDevice {
12    file: Mutex<File>,
13    size: u64,
14    writable: bool,
15}
16
17impl FileDevice {
18    /// Open read-only.
19    pub fn open<P: AsRef<Path>>(path: P) -> Result<Self> {
20        let file = File::open(path)?;
21        let size = file.metadata()?.len();
22        Ok(Self {
23            file: Mutex::new(file),
24            size,
25            writable: false,
26        })
27    }
28
29    /// Open read-write. Errors if the path is not writable.
30    pub fn open_rw<P: AsRef<Path>>(path: P) -> Result<Self> {
31        let file = OpenOptions::new().read(true).write(true).open(path)?;
32        let size = file.metadata()?.len();
33        Ok(Self {
34            file: Mutex::new(file),
35            size,
36            writable: true,
37        })
38    }
39
40    /// Open read-write if possible, fall back to read-only otherwise.
41    pub fn open_best_effort<P: AsRef<Path>>(path: P) -> Result<Self> {
42        let p = path.as_ref();
43        match Self::open_rw(p) {
44            Ok(d) => Ok(d),
45            Err(_) => Self::open(p),
46        }
47    }
48}
49
50impl BlockRead for FileDevice {
51    fn read_at(&self, offset: u64, buf: &mut [u8]) -> Result<()> {
52        let mut f = self.file.lock().unwrap();
53        f.seek(SeekFrom::Start(offset))?;
54        let mut total = 0usize;
55        while total < buf.len() {
56            match f.read(&mut buf[total..])? {
57                0 => {
58                    return Err(Error::ShortRead {
59                        offset,
60                        want: buf.len(),
61                        got: total,
62                    });
63                }
64                n => total += n,
65            }
66        }
67        Ok(())
68    }
69
70    fn size_bytes(&self) -> u64 {
71        self.size
72    }
73}
74
75impl BlockDevice for FileDevice {
76    fn write_at(&self, offset: u64, buf: &[u8]) -> Result<()> {
77        if !self.writable {
78            return Err(Error::ReadOnly);
79        }
80        let mut f = self.file.lock().unwrap();
81        f.seek(SeekFrom::Start(offset))?;
82        f.write_all(buf)?;
83        Ok(())
84    }
85
86    fn flush(&self) -> Result<()> {
87        if !self.writable {
88            return Ok(());
89        }
90        let mut f = self.file.lock().unwrap();
91        f.flush()?;
92        f.sync_data()?;
93        Ok(())
94    }
95
96    fn is_writable(&self) -> bool {
97        self.writable
98    }
99}
fs_core/file_device.rs

fs_core/
file_device.rs
