Add basic task switching

Author: lexs

rost/core2/cast.rs

@@ -0,0 +1,11 @@
+use core2::intrinsics;
+
+/**
+ * Move a thing into the void
+ *
+ * The forget function will take ownership of the provided value but neglect
+ * to run any required cleanup or memory-management operations on it. This
+ * can be used for various acts of magick.
+ */
+#[inline]
+pub unsafe fn forget<T>(thing: T) { intrinsics::forget(thing); }

rost/core2/intrinsics.rs

@@ -1,4 +1,14 @@
 extern "rust-intrinsic" {
+    /// Create an uninitialized value.
+    pub fn uninit<T>() -> T;
+
+    /// Move a value out of scope without running drop glue.
+    ///
+    /// `forget` is unsafe because the caller is responsible for
+    /// ensuring the argument is deallocated already.
+    pub fn forget<T>(_: T) -> ();
+    pub fn transmute<T,U>(e: T) -> U;
+
     pub fn offset<T>(dst: *T, offset: int) -> *T;
 
     pub fn volatile_load<T>(src: *T) -> T;

rost/core2/list.rs

@@ -0,0 +1,122 @@
+use core::option::{Option, Some, None};
+use core::iter::Iterator;
+use core::container::Container;
+
+use core2::util;
+
+type Link<T> = Option<~Node<T>>;
+struct Node<T> {
+    value: T,
+    next: Link<T>
+}
+
+pub struct List<T> {
+    head: Link<T>,
+    length: uint
+}
+
+/// Double-ended DList iterator
+//#[deriving(Clone)]
+pub struct Items<'a, T> {
+    priv head: &'a Link<T>,
+    priv length: uint
+}
+
+macro_rules! count (
+    () => (0);
+    ($head:expr $($tail:expr)*) => (
+        1 + count!( $($tail)* )
+    );
+)
+
+macro_rules! link (
+    () => (None);
+    ($head:expr $($tail:expr)*) => (
+        Some(~Node { value: $head, next: link!( $($tail)* ) })
+    );
+)
+
+macro_rules! list (
+    ($($value:expr),*) => (
+        List { head: link!( $($value)* ), length: count!( $($value)* ) }
+    );
+
+)
+
+impl<T> Node<T> {
+    fn new(value: T, next: Link<T>) -> Node<T> {
+        Node { value: value, next: next }
+    }
+}
+
+impl<T> List<T> {
+    pub fn new() -> List<T> {
+        List { head: None, length: 0 }
+    }
+
+    pub fn front<'a>(&'a self) -> Option<&'a T> {
+        self.head.as_ref().map(|node| {
+            &node.value
+        })
+    }
+
+    pub fn front_mut<'a>(&'a mut self) -> Option<&'a mut T> {
+        self.head.as_mut().map(|node| {
+            &mut node.value
+        })
+    }
+
+    pub fn add(&mut self, value: T) {
+        let tail = util::replace(&mut self.head, None);
+        self.head = Some(~Node::new(value, tail));
+        self.length += 1;
+    }
+
+    pub fn pop_front(&mut self) -> Option<T> {
+        self.pop_front_node().map(|node| {
+            node.value
+        })
+    }
+
+    fn pop_front_node(&mut self) -> Option<~Node<T>> {
+        self.head.take().map(|mut front_node| {
+            self.head = front_node.next.take();
+            self.length -= 1;
+            front_node
+        })
+    } 
+
+    /// Provide a forward iterator
+    #[inline]
+    pub fn iter<'a>(&'a self) -> Items<'a, T> {
+        Items { length: self.len(), head: &self.head }
+    }
+}
+
+impl<T> Container for List<T> {
+    #[inline]
+    fn is_empty(&self) -> bool {
+        self.len() == 0
+    }
+
+    #[inline]
+    fn len(&self) -> uint {
+        self.length
+    }
+}
+
+impl<'a, A> Iterator<&'a A> for Items<'a, A> {
+    #[inline]
+    fn next(&mut self) -> Option<&'a A> {
+        self.head.as_ref().map(|head| {
+            self.head = &head.next;
+            self.length -= 1;
+            &head.value
+        })
+    }
+
+    #[inline]
+    fn size_hint(&self) -> (uint, Option<uint>) {
+        (self.length, Some(self.length))
+    }
+}

rost/core2/mod.rs

@@ -1,4 +1,7 @@
 pub mod intrinsics;
 pub mod ptr;
+pub mod cast;
+pub mod util;
+pub mod list;
 
 pub mod global_heap;

rost/core2/util.rs

@@ -0,0 +1,38 @@
+use core::ptr;
+
+use core2::intrinsics;
+use core2::cast;
+
+/**
+ * Swap the values at two mutable locations of the same type, without
+ * deinitialising or copying either one.
+ */
+#[inline]
+pub fn swap<T>(x: &mut T, y: &mut T) {
+    unsafe {
+        // Give ourselves some scratch space to work with
+        let mut tmp: T = intrinsics::uninit();
+        let t: *mut T = &mut tmp;
+
+        // Perform the swap, `&mut` pointers never alias
+        let x_raw: *mut T = x;
+        let y_raw: *mut T = y;
+        ptr::copy_nonoverlapping_memory(t, x_raw as *T, 1);
+        ptr::copy_nonoverlapping_memory(x, y_raw as *T, 1);
+        ptr::copy_nonoverlapping_memory(y, t as *T, 1);
+
+        // y and t now point to the same thing, but we need to completely forget `tmp`
+        // because it's no longer relevant.
+        cast::forget(tmp);
+    }
+}
+
+/**
+ * Replace the value at a mutable location with a new one, returning the old
+ * value, without deinitialising or copying either one.
+ */
+#[inline]
+pub fn replace<T>(dest: &mut T, mut src: T) -> T {
+    swap(dest, &mut src);
+    src
+}

rost/exec/mod.rs

@@ -1,2 +1,3 @@
+pub mod tasking;
 pub mod elf;
 pub mod syscalls;

rost/exec/tasking.rs

@@ -0,0 +1,80 @@
+use core::option::{Option, Some, None};
+use core::mem::transmute;
+
+use core2::list::List;
+
+use kernel::console;
+use memory::malloc::malloc;
+
+pub struct Task {
+    pid: uint,
+    esp: u32,
+    eip: u32
+}
+
+static STACK_SIZE: u32 = 8 * 1024;
+
+static mut next_pid: uint = 1;
+static mut tasks: List<Task> = List { head: None, length: 0 };
+
+static mut current_task: Task = Task {
+        pid: 0,
+        esp: 0,
+        eip: 0
+};
+
+pub fn exec(f: fn()) {
+    let eip: u32 = unsafe { transmute(f) };
+    let stack: u32 = unsafe { transmute(malloc(STACK_SIZE)) };
+
+    let new_task = Task {
+        pid: aquire_pid(),
+        esp: stack + STACK_SIZE,
+        eip: eip
+    };
+
+    unsafe { tasks.add(new_task); }
+}
+
+pub fn schedule() {
+    let next_task = match unsafe { tasks.pop_front() } {
+        None => return,
+        Some(task) => task
+    };
+
+    let last_task = unsafe {
+        tasks.add(current_task);
+        current_task = next_task;
+        tasks.front_mut().get()
+    };
+
+    unsafe { switch_to(last_task, &current_task); }
+}
+
+#[inline(never)] // We can't inline because then the label "resume" would fail to be found
+unsafe fn switch_to(prev: &mut Task, next: &Task) {
+    // These blocks are split in two because we need to guarantee that the store
+    // into prev.esp and prev.eip happens BEFORE the jmp. Optimally we would like
+    // to use "=m" as a constraint but rustc/llvm doesn't seem to like that.
+    asm!(
+        "cli;
+        push %ebp;
+        mov %esp, $0;
+        lea resume, $1;"
+        : "=r"(prev.esp), "=r"(prev.eip) ::: "volatile");
+    asm!(
+       "mov $0, %esp;
+       sti;
+       jmp *$1;
+       resume:
+       pop %ebp;"
+       :: "m"(next.esp), "m"(next.eip) :: "volatile");
+}
+
+fn aquire_pid() -> uint {
+    unsafe {
+        let pid = next_pid;
+        next_pid += 1;
+        pid
+    }
+}

rost/mod.rs

@@ -20,6 +20,12 @@ mod core2;
 
 mod util;
 
+fn hello_again() {
+    drivers::vga::puts("Hello again!\n");
+    exec::tasking::schedule();
+    loop {}
+}
+
 #[no_mangle]
 pub extern fn kernel_main() {
     arch::gdt::init();
@@ -34,6 +40,10 @@ pub extern fn kernel_main() {
     drivers::vga::clear_screen();
     drivers::vga::puts("Hello world!\n");
 
+    exec::tasking::exec(hello_again);
+
+    exec::tasking::schedule();
+
     extern { static _binary_hello_world_elf_start: u8; }
     let do_nothing = &_binary_hello_world_elf_start as *u8;