Cargo.lock

@@ -5,29 +5,3 @@ version = 3
 [[package]]
 name = "julios"
 version = "0.1.0"
-dependencies = [
- "lazy_static",
- "spin",
- "volatile",
-]
-
-[[package]]
-name = "lazy_static"
-version = "1.4.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e2abad23fbc42b3700f2f279844dc832adb2b2eb069b2df918f455c4e18cc646"
-dependencies = [
- "spin",
-]
-
-[[package]]
-name = "spin"
-version = "0.5.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6e63cff320ae2c57904679ba7cb63280a3dc4613885beafb148ee7bf9aa9042d"
-
-[[package]]
-name = "volatile"
-version = "0.2.7"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f6b06ad3ed06fef1713569d547cdbdb439eafed76341820fb0e0344f29a41945"

Cargo.toml

@@ -7,11 +7,3 @@ edition = "2018"
 
 [lib]
 crate-type = ["staticlib"]
-
-[dependencies]
-volatile = "0.2.6"
-spin = "0.5.2"
-
-[dependencies.lazy_static]
-version = "1.0"
-features = ["spin_no_std"]

src/boot/boot.asm

@@ -164,7 +164,7 @@ p2_table:
     resb 4096
 
 stack_bottom:
-    resb 4096
+    resb 64
 stack_top:
 
 

src/lib.rs

@@ -1,20 +1,41 @@
 #![no_std]
 #![no_main]
 
-use core::panic::PanicInfo;
-
 #[panic_handler]
-fn panic_handler(info: &PanicInfo) -> ! {
-    println!("{}", info);
+fn panic(_info: &core::panic::PanicInfo) -> !
+{
     loop {}
 }
 
-mod vga;
+static HELLO: &[u8] = b"Welcome to the JuliOS";
+
+static STAR: &[u8] = b"|/-\\";
 
 #[no_mangle]
-pub extern "C" fn julios_main() -> ! {
-    println!("Hello World!");
-    println!("{}", "***JuliOS***");
-    panic!("Test panick");
-    loop {}
+pub extern "C" fn julios_main() -> !
+{
+    let vga_buffer: *mut u8 = 0xb8000 as *mut u8;
+
+    let mut k: usize = 0;
+    for (i, &byte) in HELLO.iter().enumerate()
+    {
+        unsafe
+        {
+            *vga_buffer.offset(i as isize * 2) = byte;
+            *vga_buffer.offset(i as isize * 2 + 1) = 0xb;
+        }
+        k = i * 2 + 2;
+    }
+
+    let mut j: usize = 0;
+    loop
+    {
+        unsafe
+        {
+            *vga_buffer.offset(k as isize) = STAR[j];
+            *vga_buffer.offset(k as isize + 1) = 0xb;
+            j += 1;
+            j %= 4;
+        }
+    }
 }

src/vga.rs

@@ -1,143 +0,0 @@
-use volatile::Volatile;
-use core::fmt;
-use lazy_static::lazy_static;
-use spin::Mutex;
-
-const BUFFER_HEIGHT: usize = 25;
-const BUFFER_WIDTH: usize = 80;
-
-lazy_static! {
-    pub static ref WRITER: Mutex<Writer> = Mutex::new(Writer {
-        column: 0,
-        color_code: ColorCode::new(Color::Green, Color::Black),
-        buffer: unsafe { &mut *(0xb8000 as *mut VgaBuffer) }
-    });
-}
-
-#[macro_export]
-macro_rules! print {
-    ($($arg:tt)*) => ($crate::vga::_print(format_args!($($arg)*)));
-}
-
-#[macro_export]
-macro_rules! println {
-    () => ($crate::print!("\n"));
-    ($($arg:tt)*) => ($crate::print!("{}\n", format_args!($($arg)*)));
-}
-
-#[doc(hidden)]
-pub fn _print(args: fmt::Arguments) {
-    use core::fmt::Write;
-    WRITER.lock().write_fmt(args).unwrap();
-}
-
-
-#[allow(dead_code)]
-#[derive(Debug, Clone, Copy, PartialEq, Eq)]
-#[repr(u8)]
-pub enum Color {
-    Black = 0x0,
-    Blue = 0x1,
-    Green = 0x2,
-    Cyan = 0x3,
-    Red = 0x4,
-    Magenta = 0x5,
-    Brown = 0x6,
-    LightGray = 0x7,
-    DarkGray = 0x8,
-    LightBlue = 0x9,
-    LightGreen = 0xa,
-    LightCyan = 0xb,
-    LightRed = 0xc,
-    Pink = 0xd,
-    Yellow = 0xe,
-    White = 0xf,
-}
-
-#[derive(Debug, Clone, Copy, PartialEq, Eq)]
-#[repr(transparent)]
-struct ColorCode(u8);
-
-impl ColorCode {
-    fn new(fg: Color, bg: Color) -> ColorCode {
-        ColorCode((bg as u8) << 4 | (fg as u8))
-    }
-}
-
-#[derive(Debug, Clone, Copy, PartialEq, Eq)]
-#[repr(C)]
-struct VgaChar {
-    character: u8,
-    color_code: ColorCode,
-}
-
-#[repr(transparent)]
-struct VgaBuffer {
-    chars: [[Volatile<VgaChar>; BUFFER_WIDTH]; BUFFER_HEIGHT],
-}
-
-pub struct Writer {
-    column: usize,
-    color_code: ColorCode,
-    buffer: &'static mut VgaBuffer,
-}
-
-impl Writer {
-    pub fn write_string(&mut self, s: &str) {
-        for byte in s.bytes() {
-            match byte {
-                0x20..=0x7e | b'\n' => self.write_byte(byte),
-                _ => self.write_byte(0xfe)
-            }
-        }
-    }
-
-    pub fn write_byte(&mut self, byte: u8) {
-        match byte {
-            b'\n' => self.new_line(),
-            byte => {
-                if self.column >= BUFFER_WIDTH {
-                    self.new_line();
-                }
-
-                let row = BUFFER_HEIGHT - 1;
-                let col = self.column;
-
-                let color_code = self.color_code;
-                self.buffer.chars[row][col].write(VgaChar {
-                    character: byte,
-                    color_code
-                });
-                self.column += 1;
-            }
-        }
-    }
-
-    fn new_line(&mut self) {
-        for row in 1..BUFFER_HEIGHT {
-            for col in 0..BUFFER_WIDTH {
-                let character = self.buffer.chars[row][col].read();
-                self.buffer.chars[row - 1][col].write(character);
-            }
-        }
-        self.clear_row(BUFFER_HEIGHT - 1);
-        self.column = 0;
-    }
-
-    fn clear_row(&mut self, row: usize) {
-        let blank = VgaChar {
-            character: b' ',
-            color_code: self.color_code
-        };
-        for col in 0..BUFFER_WIDTH {
-            self.buffer.chars[row][col].write(blank);
-        }
-    }
-}
-
-impl fmt::Write for Writer {
-    fn write_str(&mut self, s: &str) -> fmt::Result {
-        self.write_string(s);
-        Ok(())
-    }
-}