userspace: Implement heap

Author: sysheap

src/common/src/lib.rs

@@ -1,6 +1,38 @@
 #![no_std]
 #![allow(dead_code)]
 #![allow(unused_variables)]
+#![feature(custom_test_frameworks)]
+#![test_runner(test_runner)]
+#![reexport_test_harness_main = "test_main"]
 
 pub mod mutex;
 pub mod syscalls;
+
+// Inspired by https://os.phil-opp.com/testing/
+
+pub trait Testable {
+    fn run(&self);
+}
+
+impl<T> Testable for T
+where
+    T: Fn(),
+{
+    fn run(&self) {
+        // print!("TEST: {}\n", core::any::type_name::<T>());
+        self();
+    }
+}
+
+#[allow(dead_code)]
+fn test_runner(tests: &[&dyn Testable]) {
+    // println!("Running {} tests", tests.len());
+    for test in tests {
+        test.run();
+    }
+}
+
+#[cfg(test)]
+pub fn mytest() {
+    test_main();
+}

src/common/src/mutex.rs

@@ -72,3 +72,11 @@ impl<'a, T> DerefMut for MutexGuard<'a, T> {
         unsafe { &mut *self.mutex.data.get() }
     }
 }
+
+#[cfg(test)]
+mod tests {
+    #[test_case]
+    fn fail_lib_tets() {
+        assert!(1 == 2, "THIS MUST FAIL");
+    }
+}

src/userspace/src/bin/shell.rs

@@ -1,12 +1,13 @@
 #![no_std]
 #![no_main]
 
-use common::{mutex::Mutex, syscalls::SYSCALL_WAIT};
+use alloc::string::String;
+use common::syscalls::SYSCALL_WAIT;
 use userspace::{print, println, util::wait};
 
+extern crate alloc;
 extern crate userspace;
 
-static INPUT_BUFFER: Mutex<[u8; 1024]> = Mutex::new([0; 1024]);
 const DELETE: u8 = 127;
 
 #[no_mangle]
@@ -16,8 +17,7 @@ fn main() {
     println!("Type 'help' for a list of available commands.");
     loop {
         print!("$ ");
-        let mut input_buffer = INPUT_BUFFER.lock();
-        let mut buffer_index = 0;
+        let mut input = String::new();
         loop {
             let mut result: isize;
             loop {
@@ -35,26 +35,23 @@ fn main() {
                     break;
                 }
                 DELETE => {
-                    if buffer_index > 0 {
-                        buffer_index -= 1;
+                    if input.pop().is_some() {
                         print!("{}{}{}", 8 as char, ' ', 8 as char);
                     }
                 }
                 _ => {
-                    input_buffer[buffer_index] = next_char;
-                    buffer_index += 1;
+                    input.push(next_char as char);
                     print!("{}", next_char as char);
                 }
             }
         }
         // Parse input and execute
-        let command = core::str::from_utf8(&input_buffer[0..buffer_index]).unwrap();
-        parse_command_and_execute(command);
+        parse_command_and_execute(input);
     }
 }
 
-fn parse_command_and_execute(command: &str) {
-    match command {
+fn parse_command_and_execute(command: String) {
+    match command.as_str() {
         "" => {}
         "exit" => {
             println!("Exiting...");