Struct DiskBlockStore 

pub struct DiskBlockStore { /* private fields */ }

File-backed block store. Uses a regular file as a virtual block device.

Uses pread/pwrite (via FileExt) for positioned I/O without seeking, which is safe for concurrent reads without a mutex on the file descriptor.

Implementations

impl DiskBlockStore

pub fn open(path: &str, block_size: usize, total_blocks: u64) -> FsResult<Self>

Open an existing file as a block store.

The file must already exist and be at least block_size * total_blocks bytes. If total_blocks is 0, it is inferred from the file size.

pub fn create( path: &str, block_size: usize, total_blocks: u64, ) -> FsResult<Self>

Create a new file of the given size and open it as a block store.

Every block is filled with cryptographically random data so that unallocated blocks are indistinguishable from encrypted ones.

Examples found in repository

examples/create_image.rs (line 28)

fn main() {
    let path = std::env::current_dir()
        .unwrap()
        .join("sample.dcfs")
        .to_string_lossy()
        .to_string();

    // Remove leftover from a previous run, if any.
    let _ = std::fs::remove_file(&path);

    // 64 blocks × 64 KiB = 4 MiB image.
    let total_blocks: u64 = 64;
    let store = Arc::new(
        DiskBlockStore::create(&path, DEFAULT_BLOCK_SIZE, total_blocks)
            .expect("failed to create image file"),
    );

    let crypto = Arc::new(ChaChaEngine::generate().expect("failed to init crypto"));
    let mut fs = FilesystemCore::new(store, crypto);

    fs.init_filesystem().expect("init_filesystem failed");

    // Create a text file.
    fs.create_file("hello.txt").expect("create_file failed");
    fs.write_file("hello.txt", 0, b"Hello, hex editor!")
        .expect("write_file failed");

    // Create a directory.
    fs.create_directory("notes")
        .expect("create_directory failed");

    // Create a larger binary file so there's more to look at.
    let pattern: Vec<u8> = (0..=255).cycle().take(200_000).collect();
    fs.create_file("pattern.bin").expect("create_file failed");
    fs.write_file("pattern.bin", 0, &pattern)
        .expect("write_file failed");

    fs.sync().expect("sync failed");

    println!("Filesystem image written to:\n  {path}");
    println!(
        "  {} blocks × {} bytes = {} bytes total",
        total_blocks,
        DEFAULT_BLOCK_SIZE,
        total_blocks as usize * DEFAULT_BLOCK_SIZE
    );
}

Trait Implementations

impl BlockStore for DiskBlockStore

fn block_size(&self) -> usize

Block size in bytes.

fn total_blocks(&self) -> u64

Total number of blocks in the store.

fn read_block(&self, block_id: u64) -> FsResult<Vec<u8>>

Read a full block. Returns exactly block_size() bytes.

fn write_block(&self, block_id: u64, data: &[u8]) -> FsResult<()>

Write a full block. data must be exactly block_size() bytes.

fn sync(&self) -> FsResult<()>

Sync / flush all writes. No-op for in-memory stores.

fn read_blocks(&self, block_ids: &[u64]) -> FsResult<Vec<Vec<u8>>>

Read multiple blocks in one call.

fn write_blocks(&self, blocks: &[(u64, &[u8])]) -> FsResult<()>

Write multiple blocks in one call.