Fix formatting and update Dockerfile comments, README build instructions

Author: Bingus

Dockerfile

@@ -1,8 +1,6 @@
-# 
-#  Runs the build of CrystalOS in a Docker container. It should work now anyway. Just run docker build . -o <output_folder>.
-#  There was probably a good reason to include this file in the repo but it is somewhat unclear to myself.
-#  I have just updated a couple things to cache dependencies and create a small container to copy the relevant build artifacts tos.
-# 
+# Runs the build of CrystalOS in a Docker container. It should work now anyway. Just run "DOCKER_BUILDKIT=1 docker build . -o <output_folder>."
+# There was probably a good reason to include this file in the repo but it is somewhat unclear to myself.
+# I have just updated a couple things to cache dependencies and create a small container to copy the relevant build artifacts to.
 
 FROM rustlang/rust:nightly AS build
 

README.md

@@ -49,3 +49,17 @@ while I'm waiting for the third edition to release, I guess I'm gonna just have
 
   - a shell that can enter apps and run commands like 'echo' and 'clear'
     - well actually just those commands lol. Might try making a shell language or something if i get some spare time over christmas
+
+## Building with Docker
+
+To build using Docker, just run this:
+
+```sh
+DOCKER_BUILDKIT=1 docker build . -o ./path/to/output/folder
+```
+
+### TODOs with Docker/CI etc:
+
+* Setup everything including qemu inside of Docker.
+* Running tests inside of Docker.
+* Possible automatic releases when you git tag? (Not too hard using the docker image and uploading to GitHub)

src/lib.rs

@@ -16,98 +16,95 @@ use bootloader::BootInfo;
 use core::panic::PanicInfo;
 extern crate alloc;
 
-
 pub mod system;
 pub mod user;
-pub use system::std as std;
+pub use system::std;
 pub use user::bin::*;
 
-
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 #[repr(u32)]
 pub enum QemuExitCode {
-	Ok = 0x10,
-	Err = 0x11,
+    Ok = 0x10,
+    Err = 0x11,
 }
 
 pub fn poweroff() {
-	exit(QemuExitCode::Ok);
+    exit(QemuExitCode::Ok);
 }
 
 pub fn exit(code: QemuExitCode) {
-	use x86_64::instructions::port::Port;
+    use x86_64::instructions::port::Port;
 
-	unsafe {
-		let mut port = Port::new(0xf4);
-		port.write(code as u32);
-	}
-	println!("e");
+    unsafe {
+        let mut port = Port::new(0xf4);
+        port.write(code as u32);
+    }
+    println!("e");
 }
 
 #[alloc_error_handler]
 fn alloc_error_handler(layout: alloc::alloc::Layout) -> ! {
-	panic!("error while allocating: {:?}", layout)
+    panic!("error while allocating: {:?}", layout)
 }
 
 pub fn start(boot_info: &'static BootInfo) {
-	system::init(boot_info);
+    system::init(boot_info);
 }
 
 pub fn hlt() -> ! {
-	loop {
-		x86_64::instructions::hlt();
-	}
+    loop {
+        x86_64::instructions::hlt();
+    }
 }
 
-
 #[cfg(test)]
 entry_point!(test_kernel_main);
 
 #[cfg(test)]
 fn test_kernel_main(boot_info: &'static BootInfo) -> ! {
-	system::init(boot_info);
-	test_main();
-	hlt();
+    system::init(boot_info);
+    test_main();
+    hlt();
 }
 
 pub trait Testable {
-	fn run(&self) -> ();
+    fn run(&self) -> ();
 }
 
-impl<T> Testable for T where T: Fn(), {
-	fn run(&self) {
-		serial_print!("{}...\t", core::any::type_name::<T>());
-		self();
-		serial_println!("OK");
-	}
+impl<T> Testable for T
+where
+    T: Fn(),
+{
+    fn run(&self) {
+        serial_print!("{}...\t", core::any::type_name::<T>());
+        self();
+        serial_println!("OK");
+    }
 }
 
 pub fn test_runner(tests: &[&dyn Testable]) {
-	serial_println!("Running {} tests", tests.len());
-	for test in tests {
-		test.run();
-	}
-	exit(QemuExitCode::Ok);
+    serial_println!("Running {} tests", tests.len());
+    for test in tests {
+        test.run();
+    }
+    exit(QemuExitCode::Ok);
 }
 
 pub fn test_panic_handler(info: &PanicInfo) -> ! {
-	serial_println!("ERR");
-	serial_println!("Error: {}\n", info);
-	exit(QemuExitCode::Err);
-	hlt();
+    serial_println!("ERR");
+    serial_println!("Error: {}\n", info);
+    exit(QemuExitCode::Err);
+    hlt();
 }
 
-
 #[cfg(test)]
 #[panic_handler]
 fn panic(info: &PanicInfo) -> ! {
-	test_panic_handler(info)
+    test_panic_handler(info)
 }
 
-
-
 #[cfg(test)]
 #[test_case]
 fn trivial_assertion() {
-	assert_eq!(1, 1);
+    assert_eq!(1, 1);
 }

src/main.rs

@@ -7,7 +7,8 @@
 use bootloader::{entry_point, BootInfo};
 use core::panic::PanicInfo;
 use CrystalOS::std::tasks::{Executor, Task};
-use CrystalOS::{printerr,  std::syscall};
+use CrystalOS::{print_log, serial_println};
+use CrystalOS::{printerr, std::syscall};
 extern crate alloc;
 use CrystalOS::user::bin::shell;
 
@@ -25,12 +26,13 @@ fn panic(info: &PanicInfo) -> ! {
     CrystalOS::test_panic_handler(info)
 }
 
-
 entry_point!(main);
 
 fn main(boot_info: &'static BootInfo) -> ! {
     CrystalOS::start(boot_info);
 
+    print_log!("test");
+
     #[cfg(test)]
     test_main();
 
@@ -41,4 +43,3 @@ fn main(boot_info: &'static BootInfo) -> ! {
         executor.try_run();
     }
 }
-

src/system/kernel/allocator.rs

@@ -1,59 +1,50 @@
-
 use alloc::alloc::{GlobalAlloc, Layout};
 use core::ptr::null_mut;
 use linked_list_allocator::LockedHeap;
 
-
 use x86_64::{
-	structures::paging::{
-		mapper::MapToError, FrameAllocator, Mapper, Page, PageTableFlags, Size4KiB,
-	},
-	VirtAddr,
+    structures::paging::{
+        mapper::MapToError, FrameAllocator, Mapper, Page, PageTableFlags, Size4KiB,
+    },
+    VirtAddr,
 };
 
 pub fn init_heap(
-	mapper: &mut impl Mapper<Size4KiB>,
-	frame_allocator: &mut impl FrameAllocator<Size4KiB>
+    mapper: &mut impl Mapper<Size4KiB>,
+    frame_allocator: &mut impl FrameAllocator<Size4KiB>,
 ) -> Result<(), MapToError<Size4KiB>> {
-	let page_range = {
-		let heap_start = VirtAddr::new(HEAP_START as u64);
-		let heap_end = heap_start + HEAP_SIZE - 1u64;
-		let heap_start_page = Page::containing_address(heap_start);
-		let heap_end_page = Page::containing_address(heap_end);
-		Page::range_inclusive(heap_start_page, heap_end_page)
-	};
-
-	for page in page_range {
-		let frame = frame_allocator.allocate_frame()
-			.ok_or(MapToError::FrameAllocationFailed)?;
-		let flags = PageTableFlags::PRESENT | PageTableFlags::WRITABLE;
-		unsafe {
-			mapper.map_to(page, frame, flags, frame_allocator)?.flush()
-		};
-
-		unsafe { ALLOCATOR.lock().init(HEAP_START as *mut u8, HEAP_SIZE); }
-	}
-	Ok(())
+    let page_range = {
+        let heap_start = VirtAddr::new(HEAP_START as u64);
+        let heap_end = heap_start + HEAP_SIZE - 1u64;
+        let heap_start_page = Page::containing_address(heap_start);
+        let heap_end_page = Page::containing_address(heap_end);
+        Page::range_inclusive(heap_start_page, heap_end_page)
+    };
+
+    for page in page_range {
+        let frame = frame_allocator
+            .allocate_frame()
+            .ok_or(MapToError::FrameAllocationFailed)?;
+        let flags = PageTableFlags::PRESENT | PageTableFlags::WRITABLE;
+        unsafe { mapper.map_to(page, frame, flags, frame_allocator)?.flush() };
+
+        unsafe {
+            ALLOCATOR.lock().init(HEAP_START as *mut u8, HEAP_SIZE);
+        }
+    }
+    Ok(())
 }
 
-
-
-
-
-
-
-
-
 pub struct Dummy;
 
 unsafe impl GlobalAlloc for Dummy {
-	unsafe fn alloc(&self, _layout: Layout) -> *mut u8 {
-		null_mut()
-	}
+    unsafe fn alloc(&self, _layout: Layout) -> *mut u8 {
+        null_mut()
+    }
 
-	unsafe fn dealloc(&self, _ptr: *mut u8, _layout: Layout) {
-		panic!("this method should not be used")
-	}
+    unsafe fn dealloc(&self, _ptr: *mut u8, _layout: Layout) {
+        panic!("this method should not be used")
+    }
 }
 
 #[global_allocator]

src/system/kernel/authenticator.rs

@@ -1,14 +1,14 @@
-use lazy_static::lazy_static;
 use alloc::sync::Arc;
+use alloc::{string::String, vec, vec::Vec};
+use lazy_static::lazy_static;
 use spin::Mutex;
-use alloc::{vec, vec::Vec, string::String};
 
-lazy_static!(
+lazy_static! {
     static ref AUTHENTICATOR: Arc<Mutex<Vec<User>>> = Arc::new(Mutex::new(vec![User::new(
         String::from("fantasypvp"),
         String::from("password")
     )]));
-);
+};
 
 pub struct User {
     username: String,
@@ -18,7 +18,10 @@ pub struct User {
 impl User {
     fn new(username: String, password: String) -> User {
         let pass_hash = User::get_pass_hash(&password);
-        User { username, pass_hash }
+        User {
+            username,
+            pass_hash,
+        }
     }
 
     fn get_pass_hash(pass: &String) -> u64 {
@@ -33,4 +36,4 @@ impl User {
             Some(false)
         }
     }
-}
+}