Allow compiling both livedisk and harddrive

kernel/scheme/initfs.rs

@@ -1,5 +1,4 @@
-use alloc::arc::Arc;
-use collections::{BTreeMap, Vec};
+use collections::BTreeMap;
 use core::{cmp, str};
 use core::sync::atomic::{AtomicUsize, Ordering};
 use spin::RwLock;
@@ -21,27 +20,22 @@ mod gen;
 
 struct Handle {
     path: &'static [u8],
-    data: Arc<RwLock<Vec<u8>>>,
+    data: &'static [u8],
     mode: u16,
     seek: usize
 }
 
 pub struct InitFsScheme {
     next_id: AtomicUsize,
-    files: BTreeMap<&'static [u8], (Arc<RwLock<Vec<u8>>>, bool)>,
+    files: BTreeMap<&'static [u8], (&'static [u8], bool)>,
     handles: RwLock<BTreeMap<usize, Handle>>
 }
 
 impl InitFsScheme {
     pub fn new() -> InitFsScheme {
-        let mut files = BTreeMap::new();
-        for (path, (data, folder)) in gen::gen() {
-            files.insert(path, (Arc::new(RwLock::new(data.to_vec())), folder));
-        }
-
         InitFsScheme {
             next_id: AtomicUsize::new(0),
-            files: files,
+            files: gen::gen(),
             handles: RwLock::new(BTreeMap::new())
         }
     }
@@ -58,12 +52,12 @@ impl Scheme for InitFsScheme {
                 let id = self.next_id.fetch_add(1, Ordering::SeqCst);
                 self.handles.write().insert(id, Handle {
                     path: entry.0,
-                    data: (entry.1).0.clone(),
+                    data: (entry.1).0,
                     mode: if (entry.1).1 { MODE_DIR |  0o755 } else { MODE_FILE | 0o744 },
                     seek: 0
                 });
 
-                return Ok(id)
+                return Ok(id);
             }
         }
 
@@ -74,7 +68,7 @@ impl Scheme for InitFsScheme {
         let (path, data, mode, seek) = {
             let handles = self.handles.read();
             let handle = handles.get(&id).ok_or(Error::new(EBADF))?;
-            (handle.path, handle.data.clone(), handle.mode, handle.seek)
+            (handle.path, handle.data, handle.mode, handle.seek)
         };
 
         let id = self.next_id.fetch_add(1, Ordering::SeqCst);
@@ -91,26 +85,10 @@ impl Scheme for InitFsScheme {
     fn read(&self, id: usize, buffer: &mut [u8]) -> Result<usize> {
         let mut handles = self.handles.write();
         let mut handle = handles.get_mut(&id).ok_or(Error::new(EBADF))?;
-        let data = handle.data.read();
 
         let mut i = 0;
-        while i < buffer.len() && handle.seek < data.len() {
-            buffer[i] = data[handle.seek];
-            i += 1;
-            handle.seek += 1;
-        }
-
-        Ok(i)
-    }
-
-    fn write(&self, id: usize, buffer: &[u8]) -> Result<usize> {
-        let mut handles = self.handles.write();
-        let mut handle = handles.get_mut(&id).ok_or(Error::new(EBADF))?;
-        let mut data = handle.data.write();
-
-        let mut i = 0;
-        while i < buffer.len() && handle.seek < data.len() {
-            data[handle.seek] = buffer[i];
+        while i < buffer.len() && handle.seek < handle.data.len() {
+            buffer[i] = handle.data[handle.seek];
             i += 1;
             handle.seek += 1;
         }
@@ -121,12 +99,11 @@ impl Scheme for InitFsScheme {
     fn seek(&self, id: usize, pos: usize, whence: usize) -> Result<usize> {
         let mut handles = self.handles.write();
         let mut handle = handles.get_mut(&id).ok_or(Error::new(EBADF))?;
-        let data = handle.data.read();
 
         handle.seek = match whence {
-            SEEK_SET => cmp::min(data.len(), pos),
-            SEEK_CUR => cmp::max(0, cmp::min(data.len() as isize, handle.seek as isize + pos as isize)) as usize,
-            SEEK_END => cmp::max(0, cmp::min(data.len() as isize, data.len() as isize + pos as isize)) as usize,
+            SEEK_SET => cmp::min(handle.data.len(), pos),
+            SEEK_CUR => cmp::max(0, cmp::min(handle.data.len() as isize, handle.seek as isize + pos as isize)) as usize,
+            SEEK_END => cmp::max(0, cmp::min(handle.data.len() as isize, handle.data.len() as isize + pos as isize)) as usize,
             _ => return Err(Error::new(EINVAL))
         };
 
@@ -158,20 +135,16 @@ impl Scheme for InitFsScheme {
     fn fstat(&self, id: usize, stat: &mut Stat) -> Result<usize> {
         let handles = self.handles.read();
         let handle = handles.get(&id).ok_or(Error::new(EBADF))?;
-        let data = handle.data.read();
 
         stat.st_mode = handle.mode;
         stat.st_uid = 0;
         stat.st_gid = 0;
-        stat.st_size = data.len() as u64;
+        stat.st_size = handle.data.len() as u64;
 
         Ok(0)
     }
 
-    fn fsync(&self, id: usize) -> Result<usize> {
-        let handles = self.handles.read();
-        let _handle = handles.get(&id).ok_or(Error::new(EBADF))?;
-
+    fn fsync(&self, _id: usize) -> Result<usize> {
         Ok(0)
     }
 

kernel/scheme/live.rs

@@ -0,0 +1,160 @@
+/// Disk scheme replacement when making live disk
+
+use alloc::arc::Arc;
+use collections::{BTreeMap, Vec};
+use core::{cmp, str};
+use core::sync::atomic::{AtomicUsize, Ordering};
+use spin::RwLock;
+
+use syscall::data::Stat;
+use syscall::error::*;
+use syscall::flag::{MODE_DIR, MODE_FILE, SEEK_SET, SEEK_CUR, SEEK_END};
+use syscall::scheme::Scheme;
+
+static FILESYSTEM: &'static [u8] = include_bytes!("../../build/filesystem.bin");
+
+struct Handle {
+    path: &'static [u8],
+    data: Arc<RwLock<Vec<u8>>>,
+    mode: u16,
+    seek: usize
+}
+
+pub struct DiskScheme {
+    next_id: AtomicUsize,
+    data: Arc<RwLock<Vec<u8>>>,
+    handles: RwLock<BTreeMap<usize, Handle>>
+}
+
+impl DiskScheme {
+    pub fn new() -> DiskScheme {
+        DiskScheme {
+            next_id: AtomicUsize::new(0),
+            data: Arc::new(RwLock::new(FILESYSTEM.to_vec())),
+            handles: RwLock::new(BTreeMap::new())
+        }
+    }
+}
+
+impl Scheme for DiskScheme {
+    fn open(&self, _path: &[u8], _flags: usize, _uid: u32, _gid: u32) -> Result<usize> {
+        let id = self.next_id.fetch_add(1, Ordering::SeqCst);
+        self.handles.write().insert(id, Handle {
+            path: b"0",
+            data: self.data.clone(),
+            mode: MODE_FILE | 0o744,
+            seek: 0
+        });
+
+        Ok(id)
+    }
+
+    fn dup(&self, id: usize, _buf: &[u8]) -> Result<usize> {
+        let (path, data, mode, seek) = {
+            let handles = self.handles.read();
+            let handle = handles.get(&id).ok_or(Error::new(EBADF))?;
+            (handle.path, handle.data.clone(), handle.mode, handle.seek)
+        };
+
+        let id = self.next_id.fetch_add(1, Ordering::SeqCst);
+        self.handles.write().insert(id, Handle {
+            path: path,
+            data: data,
+            mode: mode,
+            seek: seek
+        });
+
+        Ok(id)
+    }
+
+    fn read(&self, id: usize, buffer: &mut [u8]) -> Result<usize> {
+        let mut handles = self.handles.write();
+        let mut handle = handles.get_mut(&id).ok_or(Error::new(EBADF))?;
+        let data = handle.data.read();
+
+        let mut i = 0;
+        while i < buffer.len() && handle.seek < data.len() {
+            buffer[i] = data[handle.seek];
+            i += 1;
+            handle.seek += 1;
+        }
+
+        Ok(i)
+    }
+
+    fn write(&self, id: usize, buffer: &[u8]) -> Result<usize> {
+        let mut handles = self.handles.write();
+        let mut handle = handles.get_mut(&id).ok_or(Error::new(EBADF))?;
+        let mut data = handle.data.write();
+
+        let mut i = 0;
+        while i < buffer.len() && handle.seek < data.len() {
+            data[handle.seek] = buffer[i];
+            i += 1;
+            handle.seek += 1;
+        }
+
+        Ok(i)
+    }
+
+    fn seek(&self, id: usize, pos: usize, whence: usize) -> Result<usize> {
+        let mut handles = self.handles.write();
+        let mut handle = handles.get_mut(&id).ok_or(Error::new(EBADF))?;
+        let data = handle.data.read();
+
+        handle.seek = match whence {
+            SEEK_SET => cmp::min(data.len(), pos),
+            SEEK_CUR => cmp::max(0, cmp::min(data.len() as isize, handle.seek as isize + pos as isize)) as usize,
+            SEEK_END => cmp::max(0, cmp::min(data.len() as isize, data.len() as isize + pos as isize)) as usize,
+            _ => return Err(Error::new(EINVAL))
+        };
+
+        Ok(handle.seek)
+    }
+
+    fn fpath(&self, id: usize, buf: &mut [u8]) -> Result<usize> {
+        let handles = self.handles.read();
+        let handle = handles.get(&id).ok_or(Error::new(EBADF))?;
+
+        //TODO: Copy scheme part in kernel
+        let mut i = 0;
+        let scheme_path = b"disk:";
+        while i < buf.len() && i < scheme_path.len() {
+            buf[i] = scheme_path[i];
+            i += 1;
+        }
+
+        let mut j = 0;
+        while i < buf.len() && j < handle.path.len() {
+            buf[i] = handle.path[j];
+            i += 1;
+            j += 1;
+        }
+
+        Ok(i)
+    }
+
+    fn fstat(&self, id: usize, stat: &mut Stat) -> Result<usize> {
+        let handles = self.handles.read();
+        let handle = handles.get(&id).ok_or(Error::new(EBADF))?;
+        let data = handle.data.read();
+
+        stat.st_mode = handle.mode;
+        stat.st_uid = 0;
+        stat.st_gid = 0;
+        stat.st_size = data.len() as u64;
+
+        Ok(0)
+    }
+
+    fn fsync(&self, id: usize) -> Result<usize> {
+        let handles = self.handles.read();
+        let _handle = handles.get(&id).ok_or(Error::new(EBADF))?;
+
+        Ok(0)
+    }
+
+    fn close(&self, id: usize) -> Result<usize> {
+        self.handles.write().remove(&id).ok_or(Error::new(EBADF)).and(Ok(0))
+    }
+}

kernel/scheme/mod.rs

@@ -41,6 +41,10 @@ pub mod initfs;
 /// `irq:` - allows userspace handling of IRQs
 pub mod irq;
 
+/// When compiled with "live" feature - `disk:` - embedded filesystem for live disk
+#[cfg(feature="live")]
+pub mod live;
+
 /// `null:` - a scheme that will discard all writes, and read no bytes
 pub mod null;
 
@@ -111,6 +115,7 @@ impl SchemeList {
     }
 
     /// Initialize the root namespace
+    #[cfg(not(feature="live"))]
     fn new_root(&mut self) {
         // Do common namespace initialization
         let ns = self.new_ns();
@@ -122,6 +127,20 @@ impl SchemeList {
         self.insert(ns, Box::new(*b"pipe"), |scheme_id| Arc::new(Box::new(PipeScheme::new(scheme_id)))).unwrap();
     }
 
+    /// Initialize the root namespace - with live disk
+    #[cfg(feature="live")]
+    fn new_root(&mut self) {
+        // Do common namespace initialization
+        let ns = self.new_ns();
+
+        // Debug, Disk, Initfs and IRQ are only available in the root namespace. Pipe is special
+        self.insert(ns, Box::new(*b"debug"), |scheme_id| Arc::new(Box::new(DebugScheme::new(scheme_id)))).unwrap();
+        self.insert(ns, Box::new(*b"disk"), |scheme_id| Arc::new(Box::new(self::live::DiskScheme::new()))).unwrap();
+        self.insert(ns, Box::new(*b"initfs"), |_| Arc::new(Box::new(InitFsScheme::new()))).unwrap();
+        self.insert(ns, Box::new(*b"irq"), |scheme_id| Arc::new(Box::new(IrqScheme::new(scheme_id)))).unwrap();
+        self.insert(ns, Box::new(*b"pipe"), |scheme_id| Arc::new(Box::new(PipeScheme::new(scheme_id)))).unwrap();
+    }
+
     pub fn setns(&mut self, from: SchemeNamespace, names: &[&[u8]]) -> Result<SchemeNamespace> {
         // Create an empty namespace
         let to = self.new_ns();