libpfs3 0.1.1

Pure Rust PFS3 (Amiga) filesystem library — read, write, format, and check
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
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154

//! Block device abstraction.
//!
//! Provides a trait for reading/writing blocks and a file-backed implementation
//! that handles partition offsets within RDB disk images.

use std::fs::{File, OpenOptions};
use std::io::{Read, Seek, SeekFrom, Write};
use std::sync::Mutex;

use crate::error::{Error, Result};

/// Abstract block device for reading/writing fixed-size blocks.
pub trait BlockDevice: Send + Sync {
    /// Read a single block into `buf`.
    fn read_block(&self, block: u64, buf: &mut [u8]) -> Result<()>;
    /// Read `count` consecutive blocks into `buf`.
    fn read_blocks(&self, block: u64, count: u32, buf: &mut [u8]) -> Result<()>;
    /// Return the block size in bytes.
    fn block_size(&self) -> u32;
    /// Write a single block from `data`.
    fn write_block(&self, block: u64, data: &[u8]) -> Result<()>;
    /// Write `count` consecutive blocks from `data`.
    fn write_blocks(&self, block: u64, count: u32, data: &[u8]) -> Result<()>;
    /// Flush all pending writes to stable storage.
    fn flush(&self) -> Result<()>;
}

/// File-backed block device with optional partition byte offset.
pub struct FileBlockDevice {
    file: Mutex<File>,
    block_bytes: u32,
    partition_offset: u64,
    total_blocks: u64,
    writable: bool,
}

impl FileBlockDevice {
    /// Open a file as a read-only block device.
    pub fn open(
        path: &std::path::Path,
        block_bytes: u32,
        partition_offset: u64,
        total_blocks: u64,
    ) -> Result<Self> {
        Self::new_impl(
            File::open(path)?,
            block_bytes,
            partition_offset,
            total_blocks,
            false,
        )
    }

    /// Open a file as a read-write block device.
    pub fn open_rw(
        path: &std::path::Path,
        block_bytes: u32,
        partition_offset: u64,
        total_blocks: u64,
    ) -> Result<Self> {
        let file = OpenOptions::new().read(true).write(true).open(path)?;
        Self::new_impl(file, block_bytes, partition_offset, total_blocks, true)
    }

    fn new_impl(
        file: File,
        block_bytes: u32,
        partition_offset: u64,
        total_blocks: u64,
        writable: bool,
    ) -> Result<Self> {
        let file_len = file.metadata()?.len();
        let total_blocks = if total_blocks == 0 {
            (file_len - partition_offset) / block_bytes as u64
        } else {
            total_blocks
        };
        Ok(Self {
            file: Mutex::new(file),
            block_bytes,
            partition_offset,
            total_blocks,
            writable,
        })
    }

    /// Create a new file of given size and open as read-write.
    pub fn create(path: &std::path::Path, block_bytes: u32, total_blocks: u64) -> Result<Self> {
        let file = OpenOptions::new()
            .read(true)
            .write(true)
            .create(true)
            .truncate(true)
            .open(path)?;
        let size = total_blocks * block_bytes as u64;
        file.set_len(size)?;
        Ok(Self {
            file: Mutex::new(file),
            block_bytes,
            partition_offset: 0,
            total_blocks,
            writable: true,
        })
    }

    /// Total number of blocks on the device.
    pub fn total_blocks(&self) -> u64 {
        self.total_blocks
    }
}

impl BlockDevice for FileBlockDevice {
    fn read_block(&self, block: u64, buf: &mut [u8]) -> Result<()> {
        self.read_blocks(block, 1, buf)
    }

    fn read_blocks(&self, block: u64, count: u32, buf: &mut [u8]) -> Result<()> {
        let offset = self.partition_offset + block * self.block_bytes as u64;
        let len = count as usize * self.block_bytes as usize;
        if buf.len() < len {
            return Err(Error::TooShort("read buffer"));
        }
        let mut file = self.file.lock().unwrap();
        file.seek(SeekFrom::Start(offset))?;
        file.read_exact(&mut buf[..len])?;
        Ok(())
    }

    fn block_size(&self) -> u32 {
        self.block_bytes
    }

    fn write_block(&self, block: u64, data: &[u8]) -> Result<()> {
        self.write_blocks(block, 1, data)
    }

    fn write_blocks(&self, block: u64, count: u32, data: &[u8]) -> Result<()> {
        if !self.writable {
            return Err(Error::ReadOnly);
        }
        let offset = self.partition_offset + block * self.block_bytes as u64;
        let len = count as usize * self.block_bytes as usize;
        let mut file = self.file.lock().unwrap();
        file.seek(SeekFrom::Start(offset))?;
        file.write_all(&data[..len])?;
        Ok(())
    }

    fn flush(&self) -> Result<()> {
        let file = self.file.lock().unwrap();
        file.sync_all()?;
        Ok(())
    }
}