Cleanup, add node and header commands

src/disk.rs

@@ -1,9 +1,5 @@
-//use core::result::Result;
-use core::fmt::Display;
-
 /// A disk
-pub trait Disk<E: Display> {
-    fn name(&self) -> &str;
+pub trait Disk<E> {
     fn read_at(&mut self, block: u64, buffer: &mut [u8]) -> Result<usize, E>;
     fn write_at(&mut self, block: u64, buffer: &[u8]) -> Result<usize, E>;
 }

src/filesystem.rs

@@ -1,50 +1,41 @@
 use alloc::boxed::Box;
 
-use collections::{BTreeMap, String};
-
-use core::cmp;
-
-use core::fmt::Display;
-
 use super::{Disk, Header, Node};
 
 /// A file system
 pub struct FileSystem<E> {
     pub disk: Box<Disk<E>>,
     pub header: Header,
-    pub nodes: BTreeMap<u64, Node>,
 }
 
-impl<E: Display> FileSystem<E> {
-    /// Create a file system from a disk
-    pub fn new(mut disk: Box<Disk<E>>) -> Result<Self, String> {
-        let mut header = Header::new();
-        try!(disk.read_at(1, &mut header).map_err(|err| format!("{}: could not read header: {}", disk.name(), err)));
+impl<E> FileSystem<E> {
+    /// Open a file system on a disk
+    pub fn open(mut disk: Box<Disk<E>>) -> Result<Option<Self>, E> {
+        let mut header = Header::default();
+        try!(disk.read_at(1, &mut header));
         if header.valid() {
-            let mut nodes = BTreeMap::new();
-            for extent in &header.extents {
-                if extent.block > 0 && extent.length > 0 {
-                    let current_sectors = (extent.length + 511) / 512;
-                    let max_size = current_sectors * 512;
-
-                    let size = cmp::min(extent.length, max_size);
-
-                    for i in 0..size / 512 {
-                        let node_block = extent.block + i;
-                        let mut node = Node::new();
-                        try!(disk.read_at(node_block, &mut node).map_err(|err| format!("{}: could not read node {}: {}", disk.name(), node_block, err)));
-                        nodes.insert(node_block, node);
-                    }
-                }
-            }
-
-            Ok(FileSystem {
+            Ok(Some(FileSystem {
                 disk: disk,
                 header: header,
-                nodes: nodes,
-            })
+            }))
         }else{
-            Err(format!("{}: invalid header", disk.name()))
+            Ok(None)
         }
     }
+
+    /// Create a file system on a disk
+    pub fn create(mut disk: Box<Disk<E>>) -> Result<Self, E> {
+        let header = Header::new();
+        try!(disk.write_at(1, &header));
+        Ok(FileSystem {
+            disk: disk,
+            header: header,
+        })
+    }
+
+    pub fn node(&mut self, block: u64) -> Result<Node, E> {
+        let mut node = Node::default();
+        try!(self.disk.read_at(block, &mut node));
+        Ok(node)
+    }
 }

src/header.rs

@@ -1,26 +1,44 @@
 use core::{mem, slice};
 use core::ops::{Deref, DerefMut};
 
-use super::Extent;
-
 /// The header of the filesystem
+#[derive(Debug)]
 #[repr(packed)]
 pub struct Header {
+    /// Signature, should be b"REDOXFS\0"
     pub signature: [u8; 8],
+    /// Version, should be 1
     pub version: u64,
-    pub free_space: Extent,
-    pub padding: [u8; 224],
-    pub extents: [Extent; 16],
+    /// Disk ID, a 128-byte unique identifier
+    pub uuid: [u8; 16],
+    /// Disk size, in 512-byte sectors
+    pub size: u64,
+    /// Block of root node
+    pub root: u64,
+    /// Block of free space node
+    pub free_space: u64,
 }
 
 impl Header {
-    pub fn new() -> Header {
+    pub fn default() -> Header {
         Header {
             signature: [0; 8],
             version: 0,
-            free_space: Extent::default(),
-            padding: [0; 224],
-            extents: [Extent::default(); 16]
+            uuid: [0; 16],
+            size: 0,
+            root: 0,
+            free_space: 0,
+        }
+    }
+
+    pub fn new() -> Header {
+        Header {
+            signature: *b"REDOXFS\0",
+            version: 1,
+            uuid: [0; 16],
+            size: 0,
+            root: 0,
+            free_space: 0,
         }
     }
 
@@ -45,3 +63,8 @@ impl DerefMut for Header {
         }
     }
 }
+
+#[test]
+fn header_size_test(){
+    assert!(mem::size_of::<Header>() <= 512);
+}

src/lib.rs

@@ -1,3 +1,5 @@
+#![crate_name="redoxfs"]
+#![crate_type="lib"]
 #![feature(alloc)]
 #![feature(collections)]
 #![no_std]

src/node.rs

@@ -1,5 +1,4 @@
-use core::{mem, slice};
-use core::ops::{Deref, DerefMut};
+use core::{fmt, mem, ops, slice, str};
 
 use super::Extent;
 
@@ -7,19 +6,42 @@ use super::Extent;
 #[repr(packed)]
 pub struct Node {
     pub name: [u8; 256],
-    pub extents: [Extent; 16],
+    pub mode: u64,
+    pub next: u64,
+    pub extents: [Extent; 15],
 }
 
 impl Node {
-    pub fn new() -> Node {
+    pub fn default() -> Node {
         Node {
             name: [0; 256],
-            extents: [Extent::default(); 16]
+            mode: 0,
+            next: 0,
+            extents: [Extent::default(); 15]
         }
     }
+
+    pub fn name(&self) -> Result<&str, str::Utf8Error> {
+        let mut len = 0;
+
+        for &b in self.name.iter() {
+            if b == 0 {
+                break;
+            }
+            len += 1;
+        }
+
+        str::from_utf8(&self.name[..len])
+    }
 }
 
-impl Deref for Node {
+impl fmt::Debug for Node {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        write!(f, "Node {{ name: {:?}, mode: {:?}, next: {:?}, extents: {:?} }}", self.name(), self.mode, self.next, self.extents)
+    }
+}
+
+impl ops::Deref for Node {
     type Target = [u8];
     fn deref(&self) -> &[u8] {
         unsafe {
@@ -28,10 +50,15 @@ impl Deref for Node {
     }
 }
 
-impl DerefMut for Node {
+impl ops::DerefMut for Node {
     fn deref_mut(&mut self) -> &mut [u8] {
         unsafe {
             slice::from_raw_parts_mut(self as *mut Node as *mut u8, mem::size_of::<Node>()) as &mut [u8]
         }
     }
 }
+
+#[test]
+fn node_size_test(){
+    assert!(mem::size_of::<Node>() <= 512);
+}