Mark/tetros
1
0
Fork 0
Code Actions Packages

Reorganize code

Browse Source
This commit is contained in:
--global 2025-02-18 21:18:27 +00:00
parent 2094a91cc9
commit e84df2364f
Signed by: Mark
GPG Key ID: C6D63995FE72FD80
14 changed files with 181 additions and 326 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
tetros/Cargo.toml
View File

@ -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]

4
tetros/src/drivers/mod.rs Normal file
View File

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

2
tetros/src/serial.rs → tetros/src/drivers/serial.rs
View File

@ -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)*));
};
}

0
tetros/src/os/bios/vga.rs → tetros/src/drivers/vga.rs
View File

124
tetros/src/main.rs
View File

@ -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;
//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;
mod drivers;
// 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");
}

75
tetros/src/os/bios/mod.rs
View File

@ -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");
}

119
tetros/src/os/bios/vga-copy.rs
View File

@ -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(())
}
}

23
tetros/src/os/bios/memory_map.rs → tetros/src/os/memory_map.rs
View File

@ -1,9 +1,26 @@
use core::{cmp, mem, ptr};
use crate::area_add;
use crate::os::{OsMemoryEntry, OsMemoryKind};
use super::{thunk::ThunkData, AREAS, AREAS_LEN};
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 {

18
tetros/src/os/mod.rs
View File

@ -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)]

0
tetros/src/os/bios/panic.rs → tetros/src/os/panic.rs
View File

0
tetros/src/os/bios/thunk.rs → tetros/src/os/thunk.rs
View File

31
tetros/src/tetrisboard/cell.rs Normal file
View File

@ -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)
}
}

68
tetros/src/os/bios/tetris.rs → tetros/src/tetrisboard/draw.rs
View File

@ -1,70 +1,10 @@
use super::vga::Vga13h;
use crate::drivers::vga::Vga13h;
#[repr(u8)]
#[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],
}
use super::{TetrisBoard, TetrisCell};
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);

35
tetros/src/tetrisboard/mod.rs Normal file
View File

@ -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
}
}