Remove unsafe from Vga's constructor.

src/src/kernel/mod.rs

@@ -1,19 +1,22 @@
-use spin::Mutex;
+use core;
 use vga::Vga;
+use spin::Mutex;
 
 #[macro_use]
 mod kprint;
 
 pub struct Context {
-    pub vga: Mutex<Vga>,
+    pub vga: Mutex<Vga<&'static mut [u8]>>,
 }
 
 impl Context {
-    pub const fn new() -> Context {
-        unsafe {
-            Context {
-                vga: Mutex::new(Vga::new(0xb8000 as *mut u8)),
-            }
+    pub fn new() -> Context {
+        let slice = unsafe {
+            core::slice::from_raw_parts_mut(0xb8000 as *mut u8, 4000)
+        };
+
+        Context {
+            vga: Mutex::new(Vga::new(slice)),
         }
     }
 }

src/vga/Cargo.toml

@@ -4,5 +4,3 @@ version = "0.1.0"
 authors = ["Steve Klabnik <steve@steveklabnik.com>"]
 
 [dependencies]
-spin = "0.4.2"
-rlibc = "1.0.0"

src/vga/src/lib.rs

@@ -1,7 +1,4 @@
 #![no_std]
-#![feature(const_fn)]
-
-extern crate rlibc;
 
 use core::fmt;
 use core::fmt::Write;
@@ -13,31 +10,26 @@ const ROWS: usize = 25;
 const COLS: usize = 80;
 const COL_BYTES: usize = COLS * 2;
 
-pub struct Vga {
-    location: *mut u8,
+pub struct Vga<T: AsMut<[u8]>> {
+    slice: T,
     buffer: [u8; ROWS * COL_BYTES],
     position: usize,
 }
 
-unsafe impl Send for Vga {}
+impl<T: AsMut<[u8]>> Vga<T> {
+    pub fn new(mut slice: T) -> Vga<T> {
+        // we must have enough bytes of backing storage to make this work.
+        assert_eq!(slice.as_mut().len(), ROWS * COL_BYTES);
 
-impl Vga {
-    pub const unsafe fn new(location: *mut u8) -> Vga {
         Vga {
-            location: location,
+            slice: slice,
             buffer: [0; ROWS * COL_BYTES],
             position: 0,
         }
     }
 
-    pub fn flush(&self) {
-        unsafe {
-            let location = self.location;
-            let length = self.buffer.len();
-            let buffer = self.buffer.as_ptr();
-
-            core::ptr::copy_nonoverlapping(buffer, location, length);
-        }
+    pub fn flush(&mut self) {
+        self.slice.as_mut().clone_from_slice(&self.buffer);
     }
 
     fn write_byte(&mut self, byte: u8) {
@@ -75,7 +67,7 @@ impl Vga {
     }
 }
 
-impl Write for Vga {
+impl<T: AsMut<[u8]>> Write for Vga<T> {
     fn write_str(&mut self, s: &str) -> Result<(), fmt::Error> {
         for b in s.bytes() {
             self.write_byte(b);
@@ -97,7 +89,7 @@ mod tests {
     fn write_a_letter() {
         let mut mock_memory = [0u8; ROWS * COL_BYTES];
 
-        let mut vga = unsafe { Vga::new(mock_memory.as_mut_ptr()) };
+        let mut vga = Vga::new(&mut mock_memory[..]);
 
         vga.write_str("a").unwrap();
 
@@ -108,7 +100,7 @@ mod tests {
     #[test]
     fn write_a_word() {
         let mut mock_memory = [0u8; ROWS * COL_BYTES];
-        let mut vga = unsafe { Vga::new(mock_memory.as_mut_ptr()) };
+        let mut vga = Vga::new(&mut mock_memory[..]);
 
         let word = "word";
         vga.write_str(word).unwrap();
@@ -126,7 +118,7 @@ mod tests {
     #[test]
     fn write_multiple_words() {
         let mut mock_memory = [0u8; ROWS * COL_BYTES];
-        let mut vga = unsafe { Vga::new(mock_memory.as_mut_ptr()) };
+        let mut vga = Vga::new(&mut mock_memory[..]);
 
         vga.write_str("hello ").unwrap();
         vga.write_str("world").unwrap();
@@ -158,7 +150,7 @@ mod tests {
     #[test]
     fn write_newline() {
         let mut mock_memory = [0u8; ROWS * COL_BYTES];
-        let mut vga = unsafe { Vga::new(mock_memory.as_mut_ptr()) };
+        let mut vga = Vga::new(&mut mock_memory[..]);
 
         vga.write_str("hello\nworld\n!").unwrap();
 
@@ -189,7 +181,7 @@ mod tests {
     #[test]
     fn write_scroll() {
         let mut mock_memory = [0u8; ROWS * COL_BYTES];
-        let mut vga = unsafe { Vga::new(mock_memory.as_mut_ptr()) };
+        let mut vga = Vga::new(&mut mock_memory[..]);
 
         for b in "abcdefghijklmnopqrstuvwxyz".bytes() {
             vga.write_byte(b);

src/vga/tests/vga.rs

@@ -8,27 +8,29 @@ use vga::Vga;
 fn create() {
     let mut mock_memory = vec![0u8; 25 * 80 * 2];
 
-    unsafe { Vga::new(mock_memory.as_mut_ptr()) };
+    Vga::new(&mut mock_memory);
 }
 
 fn check_write<T: Write>(_: T) { }
 
 #[test]
 fn write() {
     let mut mock_memory = vec![0u8; 25 * 80 * 2];
-    let vga = unsafe { Vga::new(mock_memory.as_mut_ptr()) };
+    let vga = Vga::new(&mut mock_memory);
     check_write(vga);
 }
 
 #[test]
 fn flush() {
     let mut mock_memory = vec![0u8; 25 * 80 * 2];
 
-    let mut vga = unsafe { Vga::new(mock_memory.as_mut_ptr()) };
+    {
+        let mut vga = Vga::new(&mut mock_memory);
 
-    vga.write_str("hello").unwrap();
+        vga.write_str("hello").unwrap();
 
-    vga.flush();
+        vga.flush();
+    }
 
     assert_eq!(mock_memory[0], 'h' as u8);
     assert_eq!(mock_memory[1], 0x02);