Reorganize code

tetros/Cargo.toml

@@ -32,7 +32,6 @@ missing_docs = "allow"
 needless_return = "allow"
 new_without_default = "allow"
 tabs_in_doc_comments = "allow"
-expect_used = "deny"
 dbg_macro = "deny"
 allow_attributes = "deny"
 create_dir = "deny"
@@ -55,8 +54,9 @@ match_on_vec_items = "deny"
 wildcard_dependencies = "deny"
 negative_feature_names = "deny"
 redundant_feature_names = "deny"
-multiple_crate_versions = "deny"
+multiple_crate_versions = "allow"
-
+missing_safety_doc = "allow"
+identity_op = "allow"
 
 #
 # MARK: dependencies
@@ -65,7 +65,7 @@ multiple_crate_versions = "deny"
 
 [dependencies]
 linked_list_allocator = "0.10.5"
-spin = "0.9.5"
+spin = "0.9.8"
 uart_16550 = "0.3.2"
 
 [dependencies.lazy_static]

tetros/src/drivers/mod.rs

@@ -0,0 +1,4 @@
+#[macro_use]
+pub mod serial;
+
+pub mod vga;

tetros/src/drivers/serial.rs

@@ -42,7 +42,7 @@ pub fn _print(args: core::fmt::Arguments<'_>) {
 #[macro_export]
 macro_rules! print {
 	($($arg:tt)*) => {
-		$crate::serial::_print(format_args!($($arg)*));
+		$crate::drivers::serial::_print(format_args!($($arg)*));
 	};
 }
 

tetros/src/main.rs

@@ -6,68 +6,76 @@
 
 extern crate alloc;
 
-use self::os::{OsMemoryEntry, OsMemoryKind};
+use drivers::vga::Vga13h;
+use linked_list_allocator::LockedHeap;
+use os::{memory_map::memory_map, thunk::ThunkData};
+use spin::Mutex;
+use tetrisboard::TetrisBoard;
 
-#[macro_use]
 mod os;
+mod tetrisboard;
 
 #[macro_use]
-mod serial;
+mod drivers;
-
-//TODO: allocate this in a more reasonable manner
-static mut AREAS: [OsMemoryEntry; 1024] = [OsMemoryEntry {
-	base: 0,
-	size: 0,
-	kind: OsMemoryKind::Null,
-}; 1024];
-static mut AREAS_LEN: usize = 0;
-
-pub fn area_add(area: OsMemoryEntry) {
-	unsafe {
-		for existing_area in &mut AREAS[0..AREAS_LEN] {
-			if existing_area.kind == area.kind {
-				if existing_area.base.unchecked_add(existing_area.size) == area.base {
-					existing_area.size += area.size;
-					return;
-				}
-				if area.base.unchecked_add(area.size) == existing_area.base {
-					existing_area.base = area.base;
-					return;
-				}
-			}
-		}
-		*AREAS.get_mut(AREAS_LEN).expect("AREAS overflowed!") = area;
-		AREAS_LEN += 1;
-	}
-}
-
-pub static mut LIVE_OPT: Option<(u64, &'static [u8])> = None;
 
+// We don't need `main()`
+// It's only here to keep rust-analyzer happy.
 #[allow(dead_code)]
-#[derive(Debug)]
-#[repr(C, packed(8))]
-pub struct KernelArgs {
-	kernel_base: u64,
-	kernel_size: u64,
-	stack_base: u64,
-	stack_size: u64,
-	env_base: u64,
-	env_size: u64,
-
-	/// The base pointer to the saved RSDP.
-	///
-	/// This field can be NULL, and if so, the system has not booted with UEFI or in some other way
-	/// retrieved the RSDPs. The kernel or a userspace driver will thus try searching the BIOS
-	/// memory instead. On UEFI systems, searching is not guaranteed to actually work though.
-	acpi_rsdp_base: u64,
-	/// The size of the RSDP region.
-	acpi_rsdp_size: u64,
-
-	areas_base: u64,
-	areas_size: u64,
-
-	bootstrap_base: u64,
-	bootstrap_size: u64,
-}
-
 fn main() {}
+
+#[global_allocator]
+static ALLOCATOR: LockedHeap = LockedHeap::empty();
+
+pub(crate) static VGA: Mutex<Vga13h> = Mutex::new(unsafe { Vga13h::new() });
+
+#[no_mangle]
+pub unsafe extern "C" fn start(
+	_boot_disk: usize,
+	thunk10: extern "C" fn(),
+	_thunk13: extern "C" fn(),
+	thunk15: extern "C" fn(),
+	_thunk16: extern "C" fn(),
+) -> ! {
+	println!("Entered Rust, serial ready.");
+
+	{
+		// Set vga mode
+		let mut data = ThunkData::new();
+		data.eax = 0x13;
+		data.with(thunk10);
+	}
+
+	{
+		// Disable cursor
+		let mut data = ThunkData::new();
+		data.eax = 0x0100;
+		data.ecx = 0x3F00;
+		data.with(thunk10);
+	}
+
+	{
+		// Initialize allocator
+		let (heap_start, heap_size) = memory_map(thunk15).expect("No memory for heap");
+		ALLOCATOR.lock().init(heap_start as *mut u8, heap_size);
+	}
+
+	// Clear screen
+	let mut v = VGA.lock();
+
+	/*
+	let fb = v.get_fb();
+	let mut c: u8 = 0;
+	for x in 0..128 {
+		for y in 0..128 {
+			let idx = Vga13h::pix_idx(x, y);
+			fb[idx] = c;
+			c = c.wrapping_add(1);
+		}
+	}
+	*/
+
+	let t = TetrisBoard::new();
+	t.draw(&mut v);
+
+	panic!("kernel");
+}

tetros/src/os/bios/mod.rs

@@ -1,75 +0,0 @@
-use linked_list_allocator::LockedHeap;
-use spin::Mutex;
-use tetris::TetrisBoard;
-use vga::Vga13h;
-
-use self::memory_map::memory_map;
-use self::thunk::ThunkData;
-
-use crate::println;
-
-mod memory_map;
-mod panic;
-mod tetris;
-mod thunk;
-mod vga;
-
-// Real mode memory allocation, for use with thunk
-// 0x500 to 0x7BFF is free
-const MEMORY_MAP_ADDR: usize = 0x1380; // 24 bytes, ends at 0x1397
-const THUNK_STACK_ADDR: usize = 0x7C00; // Grows downwards
-
-#[global_allocator]
-static ALLOCATOR: LockedHeap = LockedHeap::empty();
-
-pub(crate) static VGA: Mutex<Vga13h> = Mutex::new(unsafe { Vga13h::new() });
-
-#[no_mangle]
-pub unsafe extern "C" fn start(
-	_boot_disk: usize,
-	thunk10: extern "C" fn(),
-	_thunk13: extern "C" fn(),
-	thunk15: extern "C" fn(),
-	_thunk16: extern "C" fn(),
-) -> ! {
-	println!("Entered Rust, serial ready.");
-
-	{
-		// Set vga mode
-		let mut data = ThunkData::new();
-		data.eax = 0x13;
-		data.with(thunk10);
-	}
-
-	{
-		// Disable cursor
-		let mut data = ThunkData::new();
-		data.eax = 0x0100;
-		data.ecx = 0x3F00;
-		data.with(thunk10);
-	}
-
-	// Clear screen
-	let mut v = VGA.lock();
-
-	/*
-	let fb = v.get_fb();
-	let mut c: u8 = 0;
-	for x in 0..128 {
-		for y in 0..128 {
-			let idx = Vga13h::pix_idx(x, y);
-			fb[idx] = c;
-			c = c.wrapping_add(1);
-		}
-	}
-	*/
-
-	let t = TetrisBoard::new();
-	t.draw(&mut v);
-
-	let (heap_start, heap_size) = memory_map(thunk15).expect("No memory for heap");
-
-	ALLOCATOR.lock().init(heap_start as *mut u8, heap_size);
-
-	panic!("kernel");
-}

tetros/src/os/bios/vga-copy.rs

@@ -1,119 +0,0 @@
-use core::{fmt, slice};
-
-#[derive(Clone, Copy)]
-#[repr(C, packed)]
-pub struct VgaTextBlock {
-	pub char: u8,
-	pub color: u8,
-}
-
-#[allow(dead_code)]
-#[derive(Clone, Copy)]
-#[repr(u8)]
-pub enum VgaTextColor {
-	Black = 0,
-	Blue = 1,
-	Green = 2,
-	Cyan = 3,
-	Red = 4,
-	Purple = 5,
-	Brown = 6,
-	Gray = 7,
-	DarkGray = 8,
-	LightBlue = 9,
-	LightGreen = 10,
-	LightCyan = 11,
-	LightRed = 12,
-	LightPurple = 13,
-	Yellow = 14,
-	White = 15,
-}
-
-pub struct Vga {
-	pub base: usize,
-	pub width: usize,
-	pub height: usize,
-	pub x: usize,
-	pub y: usize,
-	pub bg: VgaTextColor,
-	pub fg: VgaTextColor,
-}
-
-impl Vga {
-	pub const unsafe fn new(base: usize, width: usize, height: usize) -> Self {
-		Self {
-			base,
-			width,
-			height,
-			x: 0,
-			y: 0,
-			bg: VgaTextColor::Black,
-			fg: VgaTextColor::Gray,
-		}
-	}
-
-	pub unsafe fn blocks(&mut self) -> &'static mut [VgaTextBlock] {
-		slice::from_raw_parts_mut(self.base as *mut VgaTextBlock, self.width * self.height)
-	}
-
-	pub fn clear(&mut self) {
-		self.x = 0;
-		self.y = 0;
-		let blocks = unsafe { self.blocks() };
-		for i in 0..blocks.len() {
-			blocks[i] = VgaTextBlock {
-				char: 0,
-				color: ((self.bg as u8) << 4) | (self.fg as u8),
-			};
-		}
-	}
-}
-
-impl fmt::Write for Vga {
-	fn write_str(&mut self, s: &str) -> Result<(), fmt::Error> {
-		let blocks = unsafe { self.blocks() };
-		for c in s.chars() {
-			if self.x >= self.width {
-				self.x = 0;
-				self.y += 1;
-			}
-			while self.y >= self.height {
-				for y in 1..self.height {
-					for x in 0..self.width {
-						let i = y * self.width + x;
-						let j = i - self.width;
-						blocks[j] = blocks[i];
-						if y + 1 == self.height {
-							blocks[i].char = 0;
-						}
-					}
-				}
-				self.y -= 1;
-			}
-			match c {
-				'\x08' => {
-					if self.x > 0 {
-						self.x -= 1;
-					}
-				}
-				'\r' => {
-					self.x = 0;
-				}
-				'\n' => {
-					self.x = 0;
-					self.y += 1;
-				}
-				_ => {
-					let i = self.y * self.width + self.x;
-					if let Some(block) = blocks.get_mut(i) {
-						block.char = c as u8;
-						block.color = ((self.bg as u8) << 4) | (self.fg as u8);
-					}
-					self.x += 1;
-				}
-			}
-		}
-
-		Ok(())
-	}
-}

tetros/src/os/memory_map.rs

@@ -1,9 +1,26 @@
 use core::{cmp, mem, ptr};
 
-use crate::area_add;
+use super::{thunk::ThunkData, AREAS, AREAS_LEN};
-use crate::os::{OsMemoryEntry, OsMemoryKind};
+use crate::os::{OsMemoryEntry, OsMemoryKind, MEMORY_MAP_ADDR};
 
-use super::{thunk::ThunkData, MEMORY_MAP_ADDR};
+fn area_add(area: OsMemoryEntry) {
+	unsafe {
+		for existing_area in &mut AREAS[0..AREAS_LEN] {
+			if existing_area.kind == area.kind {
+				if existing_area.base.unchecked_add(existing_area.size) == area.base {
+					existing_area.size += area.size;
+					return;
+				}
+				if area.base.unchecked_add(area.size) == existing_area.base {
+					existing_area.base = area.base;
+					return;
+				}
+			}
+		}
+		*AREAS.get_mut(AREAS_LEN).expect("AREAS overflowed!") = area;
+		AREAS_LEN += 1;
+	}
+}
 
 #[repr(C, packed)]
 struct MemoryMapEntry {

tetros/src/os/mod.rs

@@ -1,6 +1,20 @@
-pub use self::bios::*;
+pub mod memory_map;
+pub mod thunk;
+
 #[macro_use]
-mod bios;
+pub mod panic;
+
+// Real mode memory allocation, for use with thunk
+// 0x500 to 0x7BFF is free
+const MEMORY_MAP_ADDR: usize = 0x1380; // 24 bytes, ends at 0x1397
+const THUNK_STACK_ADDR: usize = 0x7C00; // Grows downwards
+
+static mut AREAS: [OsMemoryEntry; 1024] = [OsMemoryEntry {
+	base: 0,
+	size: 0,
+	kind: OsMemoryKind::Null,
+}; 1024];
+static mut AREAS_LEN: usize = 0;
 
 // Keep synced with BootloaderMemoryKind in kernel
 #[derive(Clone, Copy, Debug, Eq, PartialEq)]

tetros/src/tetrisboard/cell.rs

@@ -0,0 +1,31 @@
+#[repr(u8)]
+#[derive(Debug, Clone, Copy)]
+pub enum TetrisCell {
+	Empty,
+	Blue,
+	Cyan,
+	Orange,
+	Red,
+	Green,
+	Purple,
+	Yellow,
+}
+
+impl TetrisCell {
+	pub fn vga_color(&self) -> u8 {
+		match self {
+			Self::Empty => 0b0000_0000,
+			Self::Blue => 0b0000_0001,
+			Self::Cyan => 0b0000_0011,
+			Self::Orange => 0b0000_0110,
+			Self::Red => 0b0000_0100,
+			Self::Green => 0b0000_0010,
+			Self::Purple => 0b0000_0101,
+			Self::Yellow => 0b1100_0000,
+		}
+	}
+
+	pub fn is_empty(&self) -> bool {
+		matches!(self, Self::Empty)
+	}
+}

tetros/src/tetrisboard/draw.rs

@@ -1,70 +1,10 @@
-use super::vga::Vga13h;
+use crate::drivers::vga::Vga13h;
 
-#[repr(u8)]
+use super::{TetrisBoard, TetrisCell};
-#[derive(Debug, Clone, Copy)]
-pub enum TetrisCell {
-	Empty,
-	Blue,
-	Cyan,
-	Orange,
-	Red,
-	Green,
-	Purple,
-	Yellow,
-}
-
-impl TetrisCell {
-	pub fn to_vga_color(&self) -> u8 {
-		match self {
-			Self::Empty => 0b000_00000,
-			Self::Blue => 0b000_00001,
-			Self::Cyan => 0b000_00011,
-			Self::Orange => 0b000_00110,
-			Self::Red => 0b000_00100,
-			Self::Green => 0b000_00010,
-			Self::Purple => 0b000_00101,
-			Self::Yellow => 0b110_000_00,
-		}
-	}
-
-	pub fn is_empty(&self) -> bool {
-		matches!(self, Self::Empty)
-	}
-}
-
-pub struct TetrisBoard {
-	board: [TetrisCell; TetrisBoard::BOARD_WIDTH * TetrisBoard::BOARD_HEIGHT],
-}
 
 impl TetrisBoard {
-	const BOARD_WIDTH: usize = 10;
-	const BOARD_HEIGHT: usize = 20;
-
-	const CELL_SIZE: usize = 9;
-
-	pub fn new() -> Self {
-		let mut x = Self {
-			board: [TetrisCell::Empty; TetrisBoard::BOARD_WIDTH * TetrisBoard::BOARD_HEIGHT],
-		};
-
-		x.board[0] = TetrisCell::Blue;
-		x.board[1] = TetrisCell::Cyan;
-		x.board[2] = TetrisCell::Orange;
-		x.board[3] = TetrisCell::Red;
-		x.board[4] = TetrisCell::Green;
-		x.board[5] = TetrisCell::Purple;
-		x.board[6] = TetrisCell::Yellow;
-
-		x.board[9] = TetrisCell::Blue;
-		x.board[8] = TetrisCell::Blue;
-		x.board[10] = TetrisCell::Blue;
-		x.board[12] = TetrisCell::Blue;
-
-		x
-	}
-
 	fn draw_cell(&self, fb: &mut [u8], state: TetrisCell, x: usize, y: usize) {
-		let color = state.to_vga_color();
+		let color = state.vga_color();
 		for yo in 0..TetrisBoard::CELL_SIZE {
 			let left = Vga13h::pix_idx(x, y + yo);
 			let right = Vga13h::pix_idx(x + TetrisBoard::CELL_SIZE, y + yo);
@@ -73,7 +13,7 @@ impl TetrisBoard {
 	}
 
 	fn draw_frame(&self, fb: &mut [u8], x: usize, y: usize) {
-		let color = 0b111_000_00;
+		let color = 0b1110_0000;
 		for yo in 0..TetrisBoard::CELL_SIZE {
 			let left = Vga13h::pix_idx(x, y + yo);
 			let right = Vga13h::pix_idx(x + TetrisBoard::CELL_SIZE, y + yo);

tetros/src/tetrisboard/mod.rs

@@ -0,0 +1,35 @@
+mod cell;
+mod draw;
+pub use cell::*;
+
+pub struct TetrisBoard {
+	board: [TetrisCell; TetrisBoard::BOARD_WIDTH * TetrisBoard::BOARD_HEIGHT],
+}
+
+impl TetrisBoard {
+	const BOARD_WIDTH: usize = 10;
+	const BOARD_HEIGHT: usize = 20;
+
+	const CELL_SIZE: usize = 9;
+
+	pub fn new() -> Self {
+		let mut x = Self {
+			board: [TetrisCell::Empty; TetrisBoard::BOARD_WIDTH * TetrisBoard::BOARD_HEIGHT],
+		};
+
+		x.board[0] = TetrisCell::Blue;
+		x.board[1] = TetrisCell::Cyan;
+		x.board[2] = TetrisCell::Orange;
+		x.board[3] = TetrisCell::Red;
+		x.board[4] = TetrisCell::Green;
+		x.board[5] = TetrisCell::Purple;
+		x.board[6] = TetrisCell::Yellow;
+
+		x.board[9] = TetrisCell::Blue;
+		x.board[8] = TetrisCell::Blue;
+		x.board[10] = TetrisCell::Blue;
+		x.board[12] = TetrisCell::Blue;
+
+		x
+	}
+}