RedoxFS 0.5.0

Significant re-design to use copy-on-write and hashes for all data

src/disk/cache.rs

@@ -2,8 +2,8 @@ use std::collections::{HashMap, VecDeque};
 use std::{cmp, ptr};
 use syscall::error::Result;
 
-use disk::Disk;
-use BLOCK_SIZE;
+use crate::disk::Disk;
+use crate::BLOCK_SIZE;
 
 fn copy_memory(src: &[u8], dest: &mut [u8]) -> usize {
     let len = cmp::min(src.len(), dest.len());
@@ -21,7 +21,7 @@ pub struct DiskCache<T> {
 impl<T: Disk> DiskCache<T> {
     pub fn new(inner: T) -> Self {
         DiskCache {
-            inner: inner,
+            inner,
             cache: HashMap::new(),
             order: VecDeque::new(),
             size: 65536, // 256 MB cache
@@ -40,7 +40,7 @@ impl<T: Disk> DiskCache<T> {
 }
 
 impl<T: Disk> Disk for DiskCache<T> {
-    fn read_at(&mut self, block: u64, buffer: &mut [u8]) -> Result<usize> {
+    unsafe fn read_at(&mut self, block: u64, buffer: &mut [u8]) -> Result<usize> {
         // println!("Cache read at {}", block);
 
         let mut read = 0;
@@ -80,7 +80,7 @@ impl<T: Disk> Disk for DiskCache<T> {
         Ok(read)
     }
 
-    fn write_at(&mut self, block: u64, buffer: &[u8]) -> Result<usize> {
+    unsafe fn write_at(&mut self, block: u64, buffer: &[u8]) -> Result<usize> {
         //TODO: Write only blocks that have changed
         // println!("Cache write at {}", block);
 

src/disk/file.rs

@@ -3,8 +3,8 @@ use std::io::{Read, Seek, SeekFrom, Write};
 use std::path::Path;
 use syscall::error::{Error, Result, EIO};
 
-use disk::Disk;
-use BLOCK_SIZE;
+use crate::disk::Disk;
+use crate::BLOCK_SIZE;
 
 macro_rules! try_disk {
     ($expr:expr) => {
@@ -25,7 +25,7 @@ pub struct DiskFile {
 impl DiskFile {
     pub fn open<P: AsRef<Path>>(path: P) -> Result<DiskFile> {
         let file = try_disk!(OpenOptions::new().read(true).write(true).open(path));
-        Ok(DiskFile { file: file })
+        Ok(DiskFile { file })
     }
 
     pub fn create<P: AsRef<Path>>(path: P, size: u64) -> Result<DiskFile> {
@@ -35,18 +35,18 @@ impl DiskFile {
             .create(true)
             .open(path));
         try_disk!(file.set_len(size));
-        Ok(DiskFile { file: file })
+        Ok(DiskFile { file })
     }
 }
 
 impl Disk for DiskFile {
-    fn read_at(&mut self, block: u64, buffer: &mut [u8]) -> Result<usize> {
+    unsafe fn read_at(&mut self, block: u64, buffer: &mut [u8]) -> Result<usize> {
         try_disk!(self.file.seek(SeekFrom::Start(block * BLOCK_SIZE)));
         let count = try_disk!(self.file.read(buffer));
         Ok(count)
     }
 
-    fn write_at(&mut self, block: u64, buffer: &[u8]) -> Result<usize> {
+    unsafe fn write_at(&mut self, block: u64, buffer: &[u8]) -> Result<usize> {
         try_disk!(self.file.seek(SeekFrom::Start(block * BLOCK_SIZE)));
         let count = try_disk!(self.file.write(buffer));
         Ok(count)

src/disk/mod.rs

@@ -16,7 +16,18 @@ mod sparse;
 
 /// A disk
 pub trait Disk {
-    fn read_at(&mut self, block: u64, buffer: &mut [u8]) -> Result<usize>;
-    fn write_at(&mut self, block: u64, buffer: &[u8]) -> Result<usize>;
+    /// Read blocks from disk
+    ///
+    /// # Safety
+    /// Unsafe to discourage use, use filesystem wrappers instead
+    unsafe fn read_at(&mut self, block: u64, buffer: &mut [u8]) -> Result<usize>;
+
+    /// Write blocks from disk
+    ///
+    /// # Safety
+    /// Unsafe to discourage use, use filesystem wrappers instead
+    unsafe fn write_at(&mut self, block: u64, buffer: &[u8]) -> Result<usize>;
+
+    /// Get size of disk in bytes
     fn size(&mut self) -> Result<u64>;
 }

src/disk/sparse.rs

@@ -4,8 +4,8 @@ use std::path::Path;
 use std::u64;
 use syscall::error::{Error, Result, EIO};
 
-use disk::Disk;
-use BLOCK_SIZE;
+use crate::disk::Disk;
+use crate::BLOCK_SIZE;
 
 macro_rules! try_disk {
     ($expr:expr) => {
@@ -21,33 +21,34 @@ macro_rules! try_disk {
 
 pub struct DiskSparse {
     pub file: File,
+    pub max_size: u64,
 }
 
 impl DiskSparse {
-    pub fn create<P: AsRef<Path>>(path: P) -> Result<DiskSparse> {
+    pub fn create<P: AsRef<Path>>(path: P, max_size: u64) -> Result<DiskSparse> {
         let file = try_disk!(OpenOptions::new()
             .read(true)
             .write(true)
             .create(true)
             .open(path));
-        Ok(DiskSparse { file })
+        Ok(DiskSparse { file, max_size })
     }
 }
 
 impl Disk for DiskSparse {
-    fn read_at(&mut self, block: u64, buffer: &mut [u8]) -> Result<usize> {
+    unsafe fn read_at(&mut self, block: u64, buffer: &mut [u8]) -> Result<usize> {
         try_disk!(self.file.seek(SeekFrom::Start(block * BLOCK_SIZE)));
         let count = try_disk!(self.file.read(buffer));
         Ok(count)
     }
 
-    fn write_at(&mut self, block: u64, buffer: &[u8]) -> Result<usize> {
+    unsafe fn write_at(&mut self, block: u64, buffer: &[u8]) -> Result<usize> {
         try_disk!(self.file.seek(SeekFrom::Start(block * BLOCK_SIZE)));
         let count = try_disk!(self.file.write(buffer));
         Ok(count)
     }
 
     fn size(&mut self) -> Result<u64> {
-        Ok(u64::MAX)
+        Ok(self.max_size)
     }
 }