add: println macro

Signed-off-by: squeakbug <[email protected]>

Author: squeakbug

.gitignore

@@ -18,4 +18,8 @@ debug/
 target/
 Cargo.lock
 **/*.rs.bk
-*.pdb
+*.pdb
+
+kernel_img
+map.txt
+kernel_lib.S

Cargo.toml

@@ -19,5 +19,8 @@ mm = { path = "crates/mm" }
 net = { path = "crates/net" }
 types = { path = "crates/types" }
 
+spin = "0.9.8"
+bitflags = "2.6.0"
+
 [profile.release]
 lto = true

Makefile

@@ -24,7 +24,7 @@ KERNEL_LIB_OUT := $(KERNEL_LIBS)/libkernel.a
 KERNEL_LIB_ASM := kernel_lib.S
 RUSTFLAGS := -C soft-float -C panic=abort
 
-LDSCRIPT := $(KERNEL_SRC)/kernel.ld
+LDSCRIPT := $(KERNEL_SRC)/linker/kernel.ld
 LDFLAGS    = -z max-page-size=0x1000 --gc-sections -Map map.txt
 
 CFLAGS = -Wall -Werror -O -fno-omit-frame-pointer -ggdb -gdwarf-2

crates/dev/Cargo.toml

@@ -4,9 +4,9 @@ version = "0.0.1"
 authors = ["squeakbug <[email protected]>"]
 edition = "2021"
 
-[lib]
-name = "dev"
-path = "src/lib.rs"
-crate-type = ["staticlib"]
+[dependencies]
+spin.workspace = true
 
-[dependencies]
+[dependencies.lazy_static]
+version = "1.0"
+features = ["spin_no_std"]

crates/dev/src/console.rs

@@ -0,0 +1,49 @@
+use core::fmt;
+
+use lazy_static::lazy_static;
+use spin::Mutex;
+
+use crate::uart16550::putchar;
+
+pub struct Console {}
+
+lazy_static! {
+    pub static ref GLOBAL_TTY: Mutex<Console> = Mutex::new(Console { });
+}
+
+impl Console {
+    #[no_mangle]
+    pub fn write_string(&mut self, str: &str) {
+        unsafe {
+            let mut str_ptr = str.as_ptr();
+            while *str_ptr != b'\0' {
+                putchar(*str_ptr);
+                str_ptr = str_ptr.add(1);
+            }
+        }
+        return;
+    }
+}
+
+impl fmt::Write for Console {
+    fn write_str(&mut self, s: &str) -> fmt::Result {
+        self.write_string(s);
+        Ok(())
+    }
+}
+
+pub fn _print(args: fmt::Arguments) {
+    use core::fmt::Write;
+    GLOBAL_TTY.lock().write_fmt(args).unwrap();
+}
+
+#[macro_export]
+macro_rules! print {
+    ($($arg:tt)*) => ($crate::console::_print(format_args!($($arg)*)));
+}
+
+#[macro_export]
+macro_rules! println {
+    () => ($crate::print!("\n"));
+    ($($arg:tt)*) => ($crate::print!("{}\n", format_args!($($arg)*)));
+}

crates/dev/src/lib.rs

@@ -1 +1,5 @@
-// TBD
+#![no_main]
+#![no_std]
+
+pub mod uart16550;
+pub mod console;

crates/dev/src/uart16550.rs

@@ -0,0 +1,9 @@
+pub const UART_BASE: usize = 0x1000_0000;
+
+#[no_mangle]
+pub unsafe fn putchar(c: u8) {
+    let uart = UART_BASE as *mut u8;
+    unsafe {
+	    uart.write_volatile(c);
+    }
+}

crates/fs/src/lib.rs

@@ -1 +1,10 @@
-// TBD
+#![no_main]
+#![no_std]
+
+use core::panic::PanicInfo;
+
+#[panic_handler]
+#[no_mangle]
+fn panic(_info: &PanicInfo) -> ! {
+    loop {}
+}

crates/kernel/Cargo.toml

@@ -10,3 +10,8 @@ path = "src/lib.rs"
 crate-type = ["staticlib"]
 
 [dependencies]
+dev.workspace = true
+fs.workspace = true
+mm.workspace = true
+net.workspace = true
+types.workspace = true

crates/kernel/src/lib.rs

@@ -3,34 +3,16 @@
 
 use core::panic::PanicInfo;
 
-pub const UART_BASE: usize = 0x1000_0000;
+use dev::uart16550::{putchar, UART_BASE};
 
-#[no_mangle]
-pub unsafe fn putchar(c: u8) {
-    let uart = UART_BASE as *mut u8;
-    unsafe {
-	    uart.write_volatile(c);
-    }
-}
-
-#[no_mangle]
-pub unsafe fn print(str: &str) {
-    unsafe {
-        let mut str_ptr = str.as_ptr();
-        while *str_ptr != b'\0' {
-            putchar(*str_ptr);
-            str_ptr = str_ptr.add(1);
-        }
-    }
-	return;
-}
- 
 #[no_mangle]
 pub unsafe extern "C" fn kmain() -> ! {
-	print("Hello world!\r\n");
+    mm::init();
+
+	dev::println!("Hello, world!");
     let uart = UART_BASE as *const u8;
 	loop {
-		putchar(uart.read_volatile());
+	 	putchar(uart.read_volatile());
 	}
 }
 

crates/mm/Cargo.toml

@@ -4,19 +4,7 @@ version = "0.1.0"
 edition = "2021"
 
 [dependencies]
-ctor = "0.2.8"
-rand = "0.8.5"
-spin = "0.9.8"
-bitflags = "2.6.0"
+spin.workspace = true
+bitflags.workspace = true
 types.workspace = true
-
-[dev-dependencies]
-criterion = "0.5.1"
-
-[[bench]]
-name = "one_thread"
-harness = false
-
-[[bench]]
-name = "one_thread_std"
-harness = false
+dev.workspace = true

crates/mm/src/layout.rs

@@ -0,0 +1,2 @@
+pub const KERNBASE: usize = 0x8000_0000;
+pub const PHYSTOP: usize = KERNBASE + 32 * 1024 * 1024;

crates/mm/src/lib.rs

@@ -1,6 +1,30 @@
+#![no_main]
+#![no_std]
+
 pub mod page;
 pub mod zone;
+pub mod layout;
+
+use layout::PHYSTOP;
 pub use zone::Zone;
 
 pub mod locked_zone;
 pub use locked_zone::LockedZone;
+use zone::{next_aligned_by, PAGE_SIZE};
+
+#[global_allocator]
+pub static KMEM: LockedZone = LockedZone::new();
+
+unsafe extern "C" {
+    // first address after kernel, defined by kernel.ld
+    unsafe static mut end: [u8; 0];
+}
+
+pub fn init() {
+    unsafe {
+        KMEM.lock().add_to_heap(
+            next_aligned_by(end.as_ptr() as usize, PAGE_SIZE), 
+            next_aligned_by(PHYSTOP, PAGE_SIZE)
+        )
+    }
+}

crates/mm/src/locked_zone.rs

@@ -1,7 +1,6 @@
-use std::{
-    ops::Deref,
-    ptr::NonNull,
-};
+use core::{ops::Deref, ptr::NonNull};
+use core::alloc::{GlobalAlloc, Layout};
+use core::ptr;
 
 use spin::Mutex;
 
@@ -40,3 +39,24 @@ impl Deref for LockedZone {
         &self.0
     }
 }
+
+unsafe impl GlobalAlloc for LockedZone {
+    unsafe fn alloc(&self, layout: Layout) -> *mut u8 {
+        self.0
+            .lock()
+            .alloc_pages(layout.size().next_power_of_two())
+            .map_or(ptr::null_mut(), |p| p.as_ptr())
+    }
+
+    unsafe fn dealloc(&self, ptr: *mut u8, layout: Layout) {
+        match NonNull::new(ptr) {
+            Some(nptr) => {
+                self.0
+                    .lock()
+                    .free_pages(nptr, layout.size().next_power_of_two())
+            },
+            None => { },
+        };
+        
+    }
+}

crates/mm/src/zone.rs

@@ -1,4 +1,4 @@
-use std::{
+use core::{
     cmp::min, fmt,
     ptr::NonNull,
 };
@@ -66,10 +66,10 @@ impl Zone {
 
         let mut current_start = start;
         while current_start + PAGE_SIZE <= end {
-            let mut order = prev_two_order(end - current_start) - PAGE_SHIFT;
-            if order > MAX_PAGE_ORDER - 1 {
-                order = MAX_PAGE_ORDER - 1;
-            }
+             let mut order = prev_two_order(end - current_start) - PAGE_SHIFT;
+             if order > MAX_PAGE_ORDER - 1 {
+                 order = MAX_PAGE_ORDER - 1;
+             }
 
             self.free_area[order].push_front(current_start as *mut usize);
 
@@ -153,8 +153,11 @@ impl Zone {
 
 impl fmt::Debug for Zone {
     fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
-        let sizes = self.free_area.iter().map(|area| area.count()).collect::<Vec<_>>();
-        fmt.debug_struct(std::any::type_name::<Self>())
+        let sizes = &mut [0usize; MAX_PAGE_ORDER];
+        for (i, area) in self.free_area.iter().enumerate() {
+            sizes[i] = area.count();
+        }
+        fmt.debug_struct(core::any::type_name::<Self>())
             .field("managed", &self._managed_pages)
             .field("present", &self._present_pages)
             .field("sizes", &sizes)

crates/net/src/lib.rs

@@ -1 +1,10 @@
-// TBD
+#![no_main]
+#![no_std]
+
+use core::panic::PanicInfo;
+
+#[panic_handler]
+#[no_mangle]
+fn panic(_info: &PanicInfo) -> ! {
+    loop {}
+}

crates/types/src/lib.rs

@@ -1,2 +1,5 @@
+#![no_main]
+#![no_std]
+
 pub mod linked_list;
 pub mod safe_linked_list;

crates/types/src/linked_list.rs

@@ -1,4 +1,6 @@
-use core::{fmt, ptr};
+use core::{
+    {fmt, ptr}
+};
 
 #[derive(Copy, Clone)]
 pub struct List {
@@ -16,7 +18,7 @@ pub struct ListHead {
 
 impl fmt::Debug for ListHead {
     fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
-        fmt.debug_struct(std::any::type_name::<Self>())
+        fmt.debug_struct(core::any::type_name::<Self>())
             .field("next", &self.next)
             .field("prev", &self.prev)
             .finish()