Update post and code

src/memory/mod.rs

@@ -9,7 +9,7 @@
 
 pub use self::area_frame_allocator::AreaFrameAllocator;
 pub use self::paging::remap_the_kernel;
-pub use self::stack_allocator::{StackAllocator, StackPointer};
+pub use self::stack_allocator::{Stack, StackPointer};
 use self::paging::PhysicalAddress;
 use multiboot2::BootInformation;
 
@@ -62,11 +62,10 @@ pub fn init(boot_info: &BootInformation) -> MemoryController {
     }
 
     let stack_allocator = {
-        let stack_alloc_start_page = heap_end_page + 1;
-        let stack_alloc_end_page = stack_alloc_start_page + 100;
-        let stack_alloc_page_range = Page::range_inclusive(stack_alloc_start_page,
-                                                           stack_alloc_end_page);
-        stack_allocator::new_stack_allocator(stack_alloc_page_range)
+        let stack_alloc_start = heap_end_page + 1;
+        let stack_alloc_end = stack_alloc_start + 100;
+        let stack_alloc_range = Page::range_inclusive(stack_alloc_start, stack_alloc_end);
+        stack_allocator::new_stack_allocator(stack_alloc_range)
     };
 
     MemoryController {
@@ -79,11 +78,11 @@ pub fn init(boot_info: &BootInformation) -> MemoryController {
 pub struct MemoryController {
     active_table: paging::ActivePageTable,
     frame_allocator: AreaFrameAllocator,
-    stack_allocator: StackAllocator,
+    stack_allocator: stack_allocator::StackAllocator,
 }
 
 impl MemoryController {
-    pub fn alloc_stack(&mut self, size_in_pages: usize) -> Result<StackPointer, ()> {
+    pub fn alloc_stack(&mut self, size_in_pages: usize) -> Option<Stack> {
         let &mut MemoryController { ref mut active_table,
                                     ref mut frame_allocator,
                                     ref mut stack_allocator } = self;

src/memory/paging/mod.rs

@@ -70,6 +70,7 @@ impl Add<usize> for Page {
     }
 }
 
+#[derive(Debug, Clone)]
 pub struct PageIter {
     start: Page,
     end: Page,

src/memory/stack_allocator.rs

@@ -15,37 +15,73 @@ impl StackAllocator {
                                            active_table: &mut ActivePageTable,
                                            frame_allocator: &mut FA,
                                            size_in_pages: usize)
-                                           -> Result<StackPointer, ()> {
+                                           -> Option<Stack> {
         if size_in_pages == 0 {
-            return Err(());
+            return None;
         }
 
-        let _guard_page = self.range.next().ok_or(())?;
+        let mut range = self.range.clone();
 
-        let stack_start = self.range.next().ok_or(())?;
+        // try to allocate the stack pages and a guard page
+        let guard_page = range.next();
+        let stack_start = range.next();
         let stack_end = if size_in_pages == 1 {
             stack_start
         } else {
-            self.range.nth(size_in_pages - 1).ok_or(())?
+            range.nth(size_in_pages - 2)
         };
 
-        for page in Page::range_inclusive(stack_start, stack_end) {
-            active_table.map(page, paging::WRITABLE, frame_allocator);
-        }
+        match (guard_page, stack_start, stack_end) {
+            (Some(_), Some(start), Some(end)) => {
+                // success! write back updated range
+                self.range = range;
 
-        let top_of_stack = stack_end.start_address() + PAGE_SIZE;
-        StackPointer::new(top_of_stack).ok_or(())
+                // map stack pages to physical frames
+                for page in Page::range_inclusive(start, end) {
+                    active_table.map(page, paging::WRITABLE, frame_allocator);
+                }
+
+                // create a new stack
+                let top_of_stack = end.start_address() + PAGE_SIZE;
+                Some(Stack::new(top_of_stack, start.start_address()))
+            }
+            _ => None, /* not enough pages */
+        }
     }
 }
 
 #[derive(Debug)]
+pub struct Stack {
+    top: StackPointer,
+    bottom: StackPointer,
+}
+
+impl Stack {
+    fn new(top: usize, bottom: usize) -> Stack {
+        assert!(top > bottom);
+        Stack {
+            top: StackPointer::new(top),
+            bottom: StackPointer::new(bottom),
+        }
+    }
+
+    pub fn top(&self) -> StackPointer {
+        self.top
+    }
+}
+
+#[derive(Debug, Clone, Copy)]
 pub struct StackPointer(NonZero<usize>);
 
 impl StackPointer {
-    fn new(ptr: usize) -> Option<StackPointer> {
-        match ptr {
-            0 => None,
-            ptr => Some(StackPointer(unsafe { NonZero::new(ptr) })),
-        }
+    fn new(ptr: usize) -> StackPointer {
+        assert!(ptr != 0);
+        StackPointer(unsafe { NonZero::new(ptr) })
+    }
+}
+
+impl Into<usize> for StackPointer {
+    fn into(self) -> usize {
+        *self.0
     }
 }