ember_os 0.1.3

A simple OS kernel implemented in rust, which has referenced https://os.phil-opp.com/
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96

#![allow(stable_features)]
#![no_std]
#![cfg_attr(test, no_main)]
#![feature(const_mut_refs)] // stable in 1.83.0-nightly
#![feature(custom_test_frameworks)]
#![feature(abi_x86_interrupt)]
#![feature(async_closure)] // stable in 1.85.0-nightly
#![feature(allocator_api)]
#![feature(slice_ptr_get)]
#![test_runner(crate::test_runner)]
#![reexport_test_harness_main = "test_main"]

extern crate alloc;

pub mod allocator;
pub mod collections;
pub mod demo;
pub mod exit;
pub mod gdt;
pub mod interrupts;
pub mod io;
pub mod memory;
pub mod prelude;
pub mod serial;
pub mod shell;
pub mod task;
pub mod test_framework;
pub mod utils;
pub mod vga_buffer;

#[cfg(test)]
use bootloader::entry_point;
use bootloader::BootInfo;
use core::panic::PanicInfo;
use exit::{exit_qemu, QemuExitCode};
use memory::BootInfoFrameAllocator;
use test_framework::Testable;
use x86_64::VirtAddr;

#[cfg(test)]
entry_point!(test_kernel_main);

/// Entry point for `cargo test`
#[cfg(test)]
fn test_kernel_main(boot_info: &'static BootInfo) -> ! {
  minimum_init(boot_info);
  test_main();
  hlt_loop();
}

pub fn test_runner(tests: &[&dyn Testable]) {
  serial_println!("\nRunning {} tests\n", tests.len());
  for test in tests {
    test.run();
  }
  serial_println!();
  exit_qemu(QemuExitCode::Success);
}

pub fn test_panic_handler(info: &PanicInfo) -> ! {
  serial_println!("[failed]\n");
  serial_println!("Error: {}\n", info);
  exit_qemu(QemuExitCode::Failed);
  hlt_loop()
}

pub fn hlt_loop() -> ! {
  loop {
    x86_64::instructions::hlt()
  }
}

#[cfg(test)]
#[panic_handler]
pub fn panic(info: &PanicInfo) -> ! {
  test_panic_handler(info)
}

pub fn minimum_init(boot_info: &'static BootInfo) {
  // gdt(tss) init
  gdt::init();
  // idt init
  interrupts::init_idt();
  // PIC init
  unsafe { interrupts::PICS.lock().initialize() };
  // enable listening on PIC
  x86_64::instructions::interrupts::enable();
  // heap init
  let (mut mapper, mut frame_allocator) = {
    let phys_mem_offset = VirtAddr::new(boot_info.physical_memory_offset);
    let mapper = unsafe { memory::init(phys_mem_offset) };
    let frame_allocator = unsafe { BootInfoFrameAllocator::init(&boot_info.memory_map) };
    (mapper, frame_allocator)
  };
  allocator::init_heap(&mut mapper, &mut frame_allocator).expect("heap initialization failed!\n");
}