Compare commits
0
Commits
master
..
184030a45e
No files matched your search
Generated
-7
@@ -168,7 +168,6 @@ dependencies = [
|
|||||||
"pc-keyboard",
|
"pc-keyboard",
|
||||||
"pic8259",
|
"pic8259",
|
||||||
"postcard",
|
"postcard",
|
||||||
"prefix_tree_map",
|
|
||||||
"serde",
|
"serde",
|
||||||
"spin 0.5.2",
|
"spin 0.5.2",
|
||||||
"volatile 0.2.7",
|
"volatile 0.2.7",
|
||||||
@@ -255,12 +254,6 @@ dependencies = [
|
|||||||
"serde",
|
"serde",
|
||||||
]
|
]
|
||||||
|
|
||||||
[[package]]
|
|
||||||
name = "prefix_tree_map"
|
|
||||||
version = "0.2.1"
|
|
||||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
|
||||||
checksum = "ff18d4689013a9426f91537e79fcc8ccdb1b8f595a42b510fcbb7687e96f71da"
|
|
||||||
|
|
||||||
[[package]]
|
[[package]]
|
||||||
name = "proc-macro2"
|
name = "proc-macro2"
|
||||||
version = "1.0.47"
|
version = "1.0.47"
|
||||||
|
|||||||
@@ -20,7 +20,6 @@ postcard = "1.0.0"
|
|||||||
serde = { version = "1.0", default-features = false, features = ["alloc"] }
|
serde = { version = "1.0", default-features = false, features = ["alloc"] }
|
||||||
heapless = "0.7.16"
|
heapless = "0.7.16"
|
||||||
async-trait = "0.1.60"
|
async-trait = "0.1.60"
|
||||||
prefix_tree_map = { version = "0.2.1", default-features = false }
|
|
||||||
|
|
||||||
[dependencies.lazy_static]
|
[dependencies.lazy_static]
|
||||||
version = "1.0"
|
version = "1.0"
|
||||||
|
|||||||
@@ -58,8 +58,7 @@ static ATAPI_SIG: [u8; 4] = [
|
|||||||
];
|
];
|
||||||
|
|
||||||
lazy_static! {
|
lazy_static! {
|
||||||
pub static ref DRIVE: AsyncMutex<Option<ATABus>> =
|
pub static ref DRIVE: AsyncMutex<Option<ATABus>> = AsyncMutex::new(ATABus::discover_atapi_drive());
|
||||||
AsyncMutex::new(ATABus::discover_atapi_drive());
|
|
||||||
}
|
}
|
||||||
|
|
||||||
pub async fn init() {
|
pub async fn init() {
|
||||||
|
|||||||
+4
-1
@@ -37,7 +37,10 @@ impl FDTable {
|
|||||||
|
|
||||||
pub fn unregister_fd(&mut self, fd: &dyn FileDescriptor) {
|
pub fn unregister_fd(&mut self, fd: &dyn FileDescriptor) {
|
||||||
self.table.remove(&fd.get_fd());
|
self.table.remove(&fd.get_fd());
|
||||||
println!("Unregistered fd: {:?}", fd.get_fd());
|
println!(
|
||||||
|
"Unregistered fd: {:?}",
|
||||||
|
fd.get_fd()
|
||||||
|
);
|
||||||
}
|
}
|
||||||
|
|
||||||
pub fn register_fd(&mut self, fd: FDt) {
|
pub fn register_fd(&mut self, fd: FDt) {
|
||||||
|
|||||||
+1
-1
@@ -11,7 +11,7 @@ pub struct IsoFD {
|
|||||||
pub fd: FDId,
|
pub fd: FDId,
|
||||||
offset: u32,
|
offset: u32,
|
||||||
lba: u32,
|
lba: u32,
|
||||||
size: u32,
|
size: u32
|
||||||
}
|
}
|
||||||
|
|
||||||
impl IsoFD {
|
impl IsoFD {
|
||||||
|
|||||||
@@ -92,7 +92,7 @@ impl IsoDir {
|
|||||||
}
|
}
|
||||||
|
|
||||||
pub fn matches(&self, path: &str) -> bool {
|
pub fn matches(&self, path: &str) -> bool {
|
||||||
self.get_idf().to_ascii_uppercase() == path.as_bytes()
|
self.get_idf() == path.as_bytes()
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
|
|||||||
+9
-10
@@ -2,7 +2,7 @@ mod fd;
|
|||||||
pub mod iso9660;
|
pub mod iso9660;
|
||||||
|
|
||||||
use crate::drivers::atapi::read_block;
|
use crate::drivers::atapi::read_block;
|
||||||
use crate::fd::FDt;
|
use crate::fd::{FDt};
|
||||||
use crate::utils::unserialize;
|
use crate::utils::unserialize;
|
||||||
|
|
||||||
use super::FileSystem;
|
use super::FileSystem;
|
||||||
@@ -31,28 +31,26 @@ impl FileSystem for IsoFS {
|
|||||||
}
|
}
|
||||||
|
|
||||||
let root: &IsoDir = &voldesc.root_dir;
|
let root: &IsoDir = &voldesc.root_dir;
|
||||||
let mut curr_entry_block: [u8; iso9660::ISO_BLOCK_SIZE as usize] =
|
let mut curr_entry_block: [u8; iso9660::ISO_BLOCK_SIZE as usize] = read_block(root.data_blk.le).await;
|
||||||
read_block(root.data_blk.le).await;
|
|
||||||
|
|
||||||
let mut curr_entry: &IsoDir = unserialize(curr_entry_block.as_ptr());
|
let mut curr_entry: &IsoDir = unserialize(curr_entry_block.as_ptr());
|
||||||
|
|
||||||
let path_s: String = String::from(path);
|
let path_s: String = String::from(path);
|
||||||
let path_split: Vec<String> = path_s
|
let path_split: Vec<&str> = path_s.split("/").collect();
|
||||||
|
let path_it = path_s
|
||||||
.split("/")
|
.split("/")
|
||||||
.filter(|p| p != &"")
|
.filter(|p| p != &"");
|
||||||
.map(|s| s.to_uppercase())
|
|
||||||
.collect();
|
|
||||||
let path_it = path_split.iter();
|
|
||||||
|
|
||||||
for path_component in path_it {
|
for path_component in path_it {
|
||||||
let mut found = false;
|
let mut found = false;
|
||||||
while curr_entry.idf_len != 0 {
|
while curr_entry.idf_len != 0 {
|
||||||
|
|
||||||
// Found entry
|
// Found entry
|
||||||
if curr_entry.matches(path_component.as_str()) {
|
if curr_entry.matches(path_component) {
|
||||||
found = true;
|
found = true;
|
||||||
|
|
||||||
// Not the last component, go 1 directory deeper
|
// Not the last component, go 1 directory deeper
|
||||||
if path_component.as_str() != path_split[path_split.len() - 1] {
|
if path_component != path_split[path_split.len() - 1] {
|
||||||
// Not a directory
|
// Not a directory
|
||||||
if curr_entry.file_type != iso9660::IsoFileType::ISDIR {
|
if curr_entry.file_type != iso9660::IsoFileType::ISDIR {
|
||||||
return None;
|
return None;
|
||||||
@@ -78,6 +76,7 @@ impl FileSystem for IsoFS {
|
|||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
|
|
||||||
pub async fn get_prim_vol_desc() -> IsoPrimVolDesc {
|
pub async fn get_prim_vol_desc() -> IsoPrimVolDesc {
|
||||||
let desc_block = read_block(iso9660::ISO_PRIM_VOLDESC_BLOCK).await;
|
let desc_block = read_block(iso9660::ISO_PRIM_VOLDESC_BLOCK).await;
|
||||||
*unserialize::<IsoPrimVolDesc>(desc_block.as_ptr())
|
*unserialize::<IsoPrimVolDesc>(desc_block.as_ptr())
|
||||||
|
|||||||
+5
-48
@@ -3,11 +3,10 @@ pub mod iso;
|
|||||||
use crate::fd::FDt;
|
use crate::fd::FDt;
|
||||||
use crate::utils::mutex::AsyncMutex;
|
use crate::utils::mutex::AsyncMutex;
|
||||||
|
|
||||||
use alloc::{boxed::Box, string::String, sync::Arc, vec::Vec};
|
use alloc::{boxed::Box, sync::Arc};
|
||||||
use async_trait::async_trait;
|
use async_trait::async_trait;
|
||||||
use core::cell::RefCell;
|
use core::cell::RefCell;
|
||||||
use lazy_static::lazy_static;
|
use lazy_static::lazy_static;
|
||||||
use prefix_tree_map::{PrefixTreeMap, PrefixTreeMapBuilder};
|
|
||||||
|
|
||||||
pub type FSt = Arc<RefCell<dyn FileSystem>>;
|
pub type FSt = Arc<RefCell<dyn FileSystem>>;
|
||||||
|
|
||||||
@@ -21,62 +20,20 @@ pub trait FileSystem {
|
|||||||
}
|
}
|
||||||
|
|
||||||
pub struct VirtualFS {
|
pub struct VirtualFS {
|
||||||
map_builder: PrefixTreeMapBuilder<String, String, FSt>,
|
fs: FSt,
|
||||||
map: Option<PrefixTreeMap<String, String, FSt>>,
|
|
||||||
}
|
}
|
||||||
|
|
||||||
impl VirtualFS {
|
impl VirtualFS {
|
||||||
fn new() -> Self {
|
fn new() -> Self {
|
||||||
let mut res = VirtualFS {
|
VirtualFS {
|
||||||
map_builder: PrefixTreeMapBuilder::new(),
|
fs: Arc::new(RefCell::new(iso::IsoFS {})),
|
||||||
map: None,
|
|
||||||
};
|
|
||||||
let fs = Arc::new(RefCell::new(iso::IsoFS {}));
|
|
||||||
let fs2 = Arc::new(RefCell::new(iso::IsoFS {}));
|
|
||||||
res.mount("/", fs);
|
|
||||||
res.mount("/mnt/iso", fs2);
|
|
||||||
res
|
|
||||||
}
|
}
|
||||||
|
|
||||||
fn mount(&mut self, path: &str, fs: FSt) {
|
|
||||||
let path_s: String = String::from(path);
|
|
||||||
self.map_builder.insert_exact(
|
|
||||||
path_s
|
|
||||||
.split("/")
|
|
||||||
.filter(|p| p != &"")
|
|
||||||
.map(|s| String::from(s)),
|
|
||||||
fs,
|
|
||||||
);
|
|
||||||
self.map = Some(self.map_builder.clone().build());
|
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
#[async_trait(?Send)]
|
#[async_trait(?Send)]
|
||||||
impl FileSystem for VirtualFS {
|
impl FileSystem for VirtualFS {
|
||||||
async fn open(&mut self, path: &str, flags: u32) -> Option<FDt> {
|
async fn open(&mut self, path: &str, flags: u32) -> Option<FDt> {
|
||||||
if let Some(map) = &self.map {
|
self.fs.borrow_mut().open(path, flags).await
|
||||||
let mut mnt_relative_path: String = String::from("");
|
|
||||||
let path_s: String = String::from(path);
|
|
||||||
let mut path_split: Vec<String> = path_s
|
|
||||||
.split("/")
|
|
||||||
.filter(|p| p != &"")
|
|
||||||
.map(|s| String::from(s))
|
|
||||||
.collect();
|
|
||||||
loop {
|
|
||||||
if let Some(fs) = map.find_exact(&path_split) {
|
|
||||||
// TODO, remove path prefix of the mount point
|
|
||||||
return fs
|
|
||||||
.borrow_mut()
|
|
||||||
.open(mnt_relative_path.as_str(), flags)
|
|
||||||
.await;
|
|
||||||
} else {
|
|
||||||
let component = path_split.remove(path_split.len() - 1);
|
|
||||||
mnt_relative_path =
|
|
||||||
String::from("/") + component.as_str() + mnt_relative_path.as_str();
|
|
||||||
}
|
|
||||||
}
|
|
||||||
} else {
|
|
||||||
None
|
|
||||||
}
|
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
@@ -2,8 +2,6 @@ use crate::drivers::vga::{self, Color, ColorCode};
|
|||||||
use crate::hlt_loop;
|
use crate::hlt_loop;
|
||||||
use crate::memory::gdt;
|
use crate::memory::gdt;
|
||||||
use crate::println;
|
use crate::println;
|
||||||
|
|
||||||
use core::arch::asm;
|
|
||||||
use lazy_static::lazy_static;
|
use lazy_static::lazy_static;
|
||||||
use pic::{
|
use pic::{
|
||||||
disk1_interrupt_handler, disk2_interrupt_handler, init_pic, keyboard_interrupt_handler,
|
disk1_interrupt_handler, disk2_interrupt_handler, init_pic, keyboard_interrupt_handler,
|
||||||
@@ -14,8 +12,6 @@ use x86_64::structures::idt::{InterruptDescriptorTable, InterruptStackFrame};
|
|||||||
|
|
||||||
pub mod pic;
|
pub mod pic;
|
||||||
|
|
||||||
const SYSCALL_32_INTERRUPT_NUMBER: usize = 0x80;
|
|
||||||
|
|
||||||
lazy_static! {
|
lazy_static! {
|
||||||
static ref IDT: InterruptDescriptorTable = {
|
static ref IDT: InterruptDescriptorTable = {
|
||||||
let mut idt = InterruptDescriptorTable::new();
|
let mut idt = InterruptDescriptorTable::new();
|
||||||
@@ -30,7 +26,6 @@ lazy_static! {
|
|||||||
idt[InterruptIndex::Keyboard.as_usize()].set_handler_fn(keyboard_interrupt_handler);
|
idt[InterruptIndex::Keyboard.as_usize()].set_handler_fn(keyboard_interrupt_handler);
|
||||||
idt[InterruptIndex::HardDisk1.as_usize()].set_handler_fn(disk1_interrupt_handler);
|
idt[InterruptIndex::HardDisk1.as_usize()].set_handler_fn(disk1_interrupt_handler);
|
||||||
idt[InterruptIndex::HardDisk2.as_usize()].set_handler_fn(disk2_interrupt_handler);
|
idt[InterruptIndex::HardDisk2.as_usize()].set_handler_fn(disk2_interrupt_handler);
|
||||||
idt[SYSCALL_32_INTERRUPT_NUMBER].set_handler_fn(syscall_handler_32);
|
|
||||||
idt
|
idt
|
||||||
};
|
};
|
||||||
}
|
}
|
||||||
@@ -52,44 +47,6 @@ extern "x86-interrupt" fn breakpoint_handler(stack_frame: InterruptStackFrame) {
|
|||||||
vga::change_color(color);
|
vga::change_color(color);
|
||||||
}
|
}
|
||||||
|
|
||||||
extern "x86-interrupt" fn syscall_handler_32(_stack_frame: InterruptStackFrame) {
|
|
||||||
let rax: u64;
|
|
||||||
let rbx: u64;
|
|
||||||
let rcx: u64;
|
|
||||||
let rdx: u64;
|
|
||||||
let rsi: u64;
|
|
||||||
let rdi: u64;
|
|
||||||
let rbp: u64;
|
|
||||||
unsafe {
|
|
||||||
asm!(
|
|
||||||
"push rax",
|
|
||||||
"push rbx",
|
|
||||||
"push rcx",
|
|
||||||
"push rdx",
|
|
||||||
"push rsi",
|
|
||||||
"push rdi",
|
|
||||||
"push rbp",
|
|
||||||
|
|
||||||
"pop {rbp}",
|
|
||||||
"pop {rdi}",
|
|
||||||
"pop {rsi}",
|
|
||||||
"pop {rdx}",
|
|
||||||
"pop {rcx}",
|
|
||||||
"pop {rbx}",
|
|
||||||
"pop {rax}",
|
|
||||||
rax = out(reg) rax,
|
|
||||||
rbx = out(reg) rbx,
|
|
||||||
rcx = out(reg) rcx,
|
|
||||||
rdx = out(reg) rdx,
|
|
||||||
rsi = out(reg) rsi,
|
|
||||||
rdi = out(reg) rdi,
|
|
||||||
rbp = out(reg) rbp,
|
|
||||||
)
|
|
||||||
}
|
|
||||||
println!("Received syscall");
|
|
||||||
crate::syscalls::syscall_routine(rax);
|
|
||||||
}
|
|
||||||
|
|
||||||
extern "x86-interrupt" fn page_fault_handler(
|
extern "x86-interrupt" fn page_fault_handler(
|
||||||
stack_frame: InterruptStackFrame,
|
stack_frame: InterruptStackFrame,
|
||||||
error_code: PageFaultErrorCode,
|
error_code: PageFaultErrorCode,
|
||||||
|
|||||||
@@ -9,7 +9,6 @@ pub fn gettick() -> u64 {
|
|||||||
}
|
}
|
||||||
|
|
||||||
pub extern "x86-interrupt" fn timer_interrupt_handler(_stack_frame: InterruptStackFrame) {
|
pub extern "x86-interrupt" fn timer_interrupt_handler(_stack_frame: InterruptStackFrame) {
|
||||||
// TODO: thread preemption
|
|
||||||
unsafe {
|
unsafe {
|
||||||
TICKS += 1;
|
TICKS += 1;
|
||||||
PICS.lock()
|
PICS.lock()
|
||||||
|
|||||||
+3
-19
@@ -8,7 +8,6 @@ mod fd;
|
|||||||
mod fs;
|
mod fs;
|
||||||
mod interrupts;
|
mod interrupts;
|
||||||
mod memory;
|
mod memory;
|
||||||
mod proc;
|
|
||||||
mod syscalls;
|
mod syscalls;
|
||||||
mod task;
|
mod task;
|
||||||
mod utils;
|
mod utils;
|
||||||
@@ -21,10 +20,7 @@ use crate::fs::FileSystem;
|
|||||||
use core::panic::PanicInfo;
|
use core::panic::PanicInfo;
|
||||||
use drivers::vga::{self, Color, ColorCode};
|
use drivers::vga::{self, Color, ColorCode};
|
||||||
use multiboot2::BootInformation;
|
use multiboot2::BootInformation;
|
||||||
use task::{executor::EXECUTOR, keyboard, Task};
|
use task::{executor::Executor, keyboard, Task};
|
||||||
|
|
||||||
use alloc::sync::Arc;
|
|
||||||
use core::cell::RefCell;
|
|
||||||
|
|
||||||
#[alloc_error_handler]
|
#[alloc_error_handler]
|
||||||
fn alloc_error_handler(layout: alloc::alloc::Layout) -> ! {
|
fn alloc_error_handler(layout: alloc::alloc::Layout) -> ! {
|
||||||
@@ -61,14 +57,10 @@ pub extern "C" fn julios_main(multiboot_info_addr: usize) -> ! {
|
|||||||
println!("***JuliOS V0.1.0***");
|
println!("***JuliOS V0.1.0***");
|
||||||
serial_println!("Hello serial");
|
serial_println!("Hello serial");
|
||||||
|
|
||||||
let mut executor = EXECUTOR.try_lock().unwrap();
|
let mut executor = Executor::new();
|
||||||
executor.spawn(Task::new(drivers::atapi::init()));
|
executor.spawn(Task::new(drivers::atapi::init()));
|
||||||
executor.spawn(Task::new(keyboard::print_keypresses()));
|
executor.spawn(Task::new(keyboard::print_keypresses()));
|
||||||
executor.spawn(Task::new(get_file()));
|
executor.spawn(Task::new(get_file()));
|
||||||
executor.spawn(Task::new(proc::scheduler::scheduler_run()));
|
|
||||||
|
|
||||||
EXECUTOR.force_unlock(); // Ouioui t'inquietes
|
|
||||||
|
|
||||||
executor.run();
|
executor.run();
|
||||||
}
|
}
|
||||||
|
|
||||||
@@ -76,7 +68,7 @@ async fn get_file() {
|
|||||||
let fd = fs::VIRTUAL_FS
|
let fd = fs::VIRTUAL_FS
|
||||||
.lock()
|
.lock()
|
||||||
.await
|
.await
|
||||||
.open("/mnt/iso//boot/grub//grub.cfg", syscalls::io::O_RDONLY)
|
.open("///boot/grub//grub.cfg", syscalls::io::O_RDONLY)
|
||||||
.await
|
.await
|
||||||
.unwrap();
|
.unwrap();
|
||||||
let mut buf: [u8; 100] = [0; 100];
|
let mut buf: [u8; 100] = [0; 100];
|
||||||
@@ -91,12 +83,4 @@ async fn get_file() {
|
|||||||
serial_println!("{}", alloc::str::from_utf8(&buf).unwrap());
|
serial_println!("{}", alloc::str::from_utf8(&buf).unwrap());
|
||||||
|
|
||||||
fd.borrow_mut().close().await;
|
fd.borrow_mut().close().await;
|
||||||
|
|
||||||
let thread = Arc::new(RefCell::new(proc::thread::Thread::new(
|
|
||||||
proc::thread::routine as u64,
|
|
||||||
)));
|
|
||||||
proc::scheduler::SCHEDULER
|
|
||||||
.lock()
|
|
||||||
.await
|
|
||||||
.register(thread.clone());
|
|
||||||
}
|
}
|
||||||
@@ -1,2 +0,0 @@
|
|||||||
pub mod scheduler;
|
|
||||||
pub mod thread;
|
|
||||||
@@ -1,152 +0,0 @@
|
|||||||
use crate::println;
|
|
||||||
use crate::utils::mutex::AsyncMutex;
|
|
||||||
|
|
||||||
use super::thread::{Thread, ThreadId};
|
|
||||||
|
|
||||||
use alloc::{collections::BTreeMap, sync::Arc};
|
|
||||||
use core::cell::RefCell;
|
|
||||||
use core::{
|
|
||||||
pin::Pin,
|
|
||||||
task::{Context, Poll},
|
|
||||||
};
|
|
||||||
use crossbeam_queue::ArrayQueue;
|
|
||||||
use futures_util::stream::{Stream, StreamExt};
|
|
||||||
use futures_util::task::AtomicWaker;
|
|
||||||
use lazy_static::lazy_static;
|
|
||||||
|
|
||||||
lazy_static! {
|
|
||||||
// TODO: put this in a spin mutex instead
|
|
||||||
pub static ref SCHEDULER: AsyncMutex<Scheduler> = AsyncMutex::new(Scheduler::new());
|
|
||||||
}
|
|
||||||
|
|
||||||
pub type Threadt = Arc<RefCell<Thread>>;
|
|
||||||
|
|
||||||
pub const K_THREAD_ID: ThreadId = ThreadId(0); // Kernel main thread identifier
|
|
||||||
|
|
||||||
struct ThreadStream {
|
|
||||||
// TODO: add the double scheduler queue
|
|
||||||
ids: ArrayQueue<ThreadId>,
|
|
||||||
waker: AtomicWaker,
|
|
||||||
}
|
|
||||||
|
|
||||||
impl ThreadStream {
|
|
||||||
pub fn new() -> Self {
|
|
||||||
ThreadStream {
|
|
||||||
ids: ArrayQueue::new(100),
|
|
||||||
waker: AtomicWaker::new(),
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
pub fn register(&mut self, id: ThreadId) {
|
|
||||||
self.ids.push(id).expect("Thread queue full");
|
|
||||||
self.waker.wake();
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
impl Stream for ThreadStream {
|
|
||||||
type Item = ThreadId;
|
|
||||||
|
|
||||||
fn poll_next(self: Pin<&mut Self>, cx: &mut Context) -> Poll<Option<Self::Item>> {
|
|
||||||
if let Ok(id) = self.ids.pop() {
|
|
||||||
return Poll::Ready(Some(id));
|
|
||||||
}
|
|
||||||
|
|
||||||
self.waker.register(&cx.waker());
|
|
||||||
|
|
||||||
match self.ids.pop() {
|
|
||||||
Ok(id) => {
|
|
||||||
self.waker.take();
|
|
||||||
Poll::Ready(Some(id))
|
|
||||||
}
|
|
||||||
Err(crossbeam_queue::PopError) => Poll::Pending,
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
pub struct Scheduler {
|
|
||||||
pub threads: BTreeMap<ThreadId, Threadt>,
|
|
||||||
thread_queue: ThreadStream,
|
|
||||||
}
|
|
||||||
|
|
||||||
impl Scheduler {
|
|
||||||
pub fn new() -> Self {
|
|
||||||
let mut res = Scheduler {
|
|
||||||
threads: BTreeMap::new(),
|
|
||||||
thread_queue: ThreadStream::new(),
|
|
||||||
};
|
|
||||||
let k_thread: Thread = Thread {
|
|
||||||
id: K_THREAD_ID,
|
|
||||||
entry_point: 0,
|
|
||||||
started: true,
|
|
||||||
rsp: 0,
|
|
||||||
base_stack: 0,
|
|
||||||
is_blocked: false,
|
|
||||||
};
|
|
||||||
res.register(Arc::new(RefCell::new(k_thread)));
|
|
||||||
res
|
|
||||||
}
|
|
||||||
|
|
||||||
pub async fn run(&mut self) {
|
|
||||||
while let Some(id) = self.thread_queue.next().await {
|
|
||||||
if let Some(thread) = self.get_thread(id) {
|
|
||||||
// Thread still exists
|
|
||||||
let blocked: bool;
|
|
||||||
{
|
|
||||||
blocked = thread.borrow().is_blocked;
|
|
||||||
} // Drop thread borrow
|
|
||||||
if !blocked {
|
|
||||||
unsafe {
|
|
||||||
(&mut *thread.as_ptr()).run();
|
|
||||||
}
|
|
||||||
|
|
||||||
if !thread.borrow().is_blocked {
|
|
||||||
self.thread_queue.register(id);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
pub fn register(&mut self, thread: Threadt) {
|
|
||||||
let thread_id = thread.borrow().id;
|
|
||||||
if self.threads.insert(thread_id, thread).is_some() {
|
|
||||||
panic!("Duplicate thread ID")
|
|
||||||
}
|
|
||||||
if thread_id != K_THREAD_ID {
|
|
||||||
self.thread_queue.register(thread_id);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
pub fn block(&mut self, id: ThreadId) {
|
|
||||||
if let Some(thread) = self.get_thread(id) {
|
|
||||||
thread.borrow_mut().is_blocked = true;
|
|
||||||
println!("Blocked thread {:?}", id);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
pub fn unblock(&mut self, id: ThreadId) {
|
|
||||||
if let Some(thread) = self.get_thread(id) {
|
|
||||||
thread.borrow_mut().is_blocked = false;
|
|
||||||
self.thread_queue.register(id);
|
|
||||||
println!("Unblocked thread {:?}", id);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
pub fn exit(&mut self, id: ThreadId) {
|
|
||||||
self.threads.remove(&id).unwrap().borrow().exit();
|
|
||||||
}
|
|
||||||
|
|
||||||
pub fn get_thread(&mut self, id: ThreadId) -> Option<Threadt> {
|
|
||||||
if let Some(thread) = self.threads.get_mut(&id) {
|
|
||||||
Some(thread.clone())
|
|
||||||
} else {
|
|
||||||
None
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
pub async fn scheduler_run() {
|
|
||||||
let mut scheduler = SCHEDULER.lock().await;
|
|
||||||
SCHEDULER.force_unlock();
|
|
||||||
scheduler.run().await;
|
|
||||||
}
|
|
||||||
@@ -1,159 +0,0 @@
|
|||||||
use crate::println;
|
|
||||||
use crate::utils::mutex::AsyncMutex;
|
|
||||||
|
|
||||||
use super::scheduler::{K_THREAD_ID, SCHEDULER};
|
|
||||||
|
|
||||||
use core::arch::asm;
|
|
||||||
use core::sync::atomic::{AtomicU64, Ordering};
|
|
||||||
|
|
||||||
use alloc::alloc::{alloc, dealloc, Layout};
|
|
||||||
use lazy_static::lazy_static;
|
|
||||||
|
|
||||||
const STACK_SIZE: usize = 4096 * 20;
|
|
||||||
|
|
||||||
lazy_static! {
|
|
||||||
pub static ref RUNNING_THREAD: AsyncMutex<ThreadId> = AsyncMutex::new(ThreadId(0));
|
|
||||||
}
|
|
||||||
|
|
||||||
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
|
|
||||||
pub struct ThreadId(pub u64);
|
|
||||||
|
|
||||||
impl ThreadId {
|
|
||||||
fn new() -> Self {
|
|
||||||
static NEXT_ID: AtomicU64 = AtomicU64::new(1);
|
|
||||||
ThreadId(NEXT_ID.fetch_add(1, Ordering::Relaxed))
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
pub fn resume_k_thread() {
|
|
||||||
let k_thread: *mut Thread;
|
|
||||||
{
|
|
||||||
let mut scheduler = SCHEDULER.try_lock().unwrap();
|
|
||||||
k_thread = scheduler.get_thread(K_THREAD_ID).unwrap().as_ptr();
|
|
||||||
} // Drop scheduler mutex guard
|
|
||||||
|
|
||||||
unsafe {
|
|
||||||
(&mut *k_thread).run();
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
pub fn routine() {
|
|
||||||
println!("Routine executed");
|
|
||||||
crate::syscalls::syscall_routine(crate::syscalls::EXIT_ID); // Call exit
|
|
||||||
println!("SHOULD NEVER BE DISPLAYED");
|
|
||||||
}
|
|
||||||
|
|
||||||
pub struct Thread {
|
|
||||||
pub id: ThreadId,
|
|
||||||
pub entry_point: u64,
|
|
||||||
pub started: bool,
|
|
||||||
pub rsp: u64,
|
|
||||||
pub base_stack: u64,
|
|
||||||
pub is_blocked: bool,
|
|
||||||
}
|
|
||||||
|
|
||||||
impl Thread {
|
|
||||||
pub fn new(entry_point: u64) -> Self {
|
|
||||||
unsafe {
|
|
||||||
let stack_bottom = alloc(Layout::new::<[u8; STACK_SIZE]>()) as u64;
|
|
||||||
Thread {
|
|
||||||
id: ThreadId::new(),
|
|
||||||
entry_point: entry_point,
|
|
||||||
started: false,
|
|
||||||
rsp: stack_bottom + STACK_SIZE as u64,
|
|
||||||
base_stack: stack_bottom,
|
|
||||||
is_blocked: false
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
pub fn exit(&self) {
|
|
||||||
unsafe {
|
|
||||||
dealloc(
|
|
||||||
self.base_stack as *mut u8,
|
|
||||||
Layout::new::<[u8; STACK_SIZE]>(),
|
|
||||||
);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
pub fn run(&mut self) {
|
|
||||||
println!("Running thread {:?}", self.id);
|
|
||||||
unsafe {
|
|
||||||
let mut current_thread_guard = RUNNING_THREAD.try_lock().unwrap();
|
|
||||||
|
|
||||||
let mut scheduler = SCHEDULER.try_lock().unwrap();
|
|
||||||
if let Some(current_thread) = scheduler.get_thread(*current_thread_guard) {
|
|
||||||
let current_rsp: u64;
|
|
||||||
asm!(
|
|
||||||
"push rsp", // Recover current rsp
|
|
||||||
"pop {out}",
|
|
||||||
"sub {out}, 56", // Offset to saved registers
|
|
||||||
out = out(reg) current_rsp, // Save thread rsp
|
|
||||||
);
|
|
||||||
current_thread.borrow_mut().rsp = current_rsp;
|
|
||||||
} else {
|
|
||||||
// Thread does not exists anymore
|
|
||||||
*current_thread_guard = self.id; // change running thread
|
|
||||||
asm!( // Just switch to new thead without saving registers
|
|
||||||
"push {rsp}", // Set stack pointer to the new thread
|
|
||||||
"pop rsp",
|
|
||||||
|
|
||||||
"pop rdi", // Restore new thread regs
|
|
||||||
"pop rsi",
|
|
||||||
"pop rbp",
|
|
||||||
"pop rdx",
|
|
||||||
"pop rcx",
|
|
||||||
"pop rbx",
|
|
||||||
"pop rax",
|
|
||||||
rsp = in(reg) self.rsp,
|
|
||||||
);
|
|
||||||
return;
|
|
||||||
}
|
|
||||||
|
|
||||||
*current_thread_guard = self.id; // change running thread
|
|
||||||
} // The scheduler and running thread guards are dropped here
|
|
||||||
|
|
||||||
unsafe {
|
|
||||||
if self.started {
|
|
||||||
asm!(
|
|
||||||
"push rax", // Save current thread regs
|
|
||||||
"push rbx",
|
|
||||||
"push rcx",
|
|
||||||
"push rdx",
|
|
||||||
"push rbp",
|
|
||||||
"push rsi",
|
|
||||||
"push rdi",
|
|
||||||
|
|
||||||
"push {rsp}", // Set stack pointer to the new thread
|
|
||||||
"pop rsp",
|
|
||||||
|
|
||||||
"pop rdi", // Restore new thread regs
|
|
||||||
"pop rsi",
|
|
||||||
"pop rbp",
|
|
||||||
"pop rdx",
|
|
||||||
"pop rcx",
|
|
||||||
"pop rbx",
|
|
||||||
"pop rax",
|
|
||||||
rsp = in(reg) self.rsp,
|
|
||||||
);
|
|
||||||
} else {
|
|
||||||
self.started = true;
|
|
||||||
asm!(
|
|
||||||
"push rax", // Save current thread regs
|
|
||||||
"push rbx",
|
|
||||||
"push rcx",
|
|
||||||
"push rdx",
|
|
||||||
"push rbp",
|
|
||||||
"push rsi",
|
|
||||||
"push rdi",
|
|
||||||
|
|
||||||
"push {rsp}", // Set stack pointer to the new thread
|
|
||||||
"pop rsp",
|
|
||||||
"jmp {rip}", // Jump to thread routine
|
|
||||||
rsp = in(reg) self.rsp,
|
|
||||||
rip = in(reg) self.entry_point,
|
|
||||||
);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
@@ -1,3 +0,0 @@
|
|||||||
pub type SyscallId = u64;
|
|
||||||
|
|
||||||
pub const EXIT_ID: SyscallId = 0;
|
|
||||||
@@ -1,60 +1 @@
|
|||||||
use crate::println;
|
|
||||||
use crate::proc::thread::{resume_k_thread, RUNNING_THREAD};
|
|
||||||
use crate::proc::scheduler::SCHEDULER;
|
|
||||||
use crate::task::yield_executor::YieldExecutor;
|
|
||||||
use crate::task::Task;
|
|
||||||
|
|
||||||
pub use ids::*;
|
|
||||||
|
|
||||||
use alloc::sync::Arc;
|
|
||||||
use core::cell::RefCell;
|
|
||||||
|
|
||||||
pub mod ids;
|
|
||||||
pub mod io;
|
pub mod io;
|
||||||
pub mod proc;
|
|
||||||
|
|
||||||
pub type SyscallContextT = Arc<RefCell<SyscallContext>>;
|
|
||||||
|
|
||||||
pub struct SyscallContext {
|
|
||||||
id: SyscallId,
|
|
||||||
res: u64,
|
|
||||||
thread_id: crate::proc::thread::ThreadId,
|
|
||||||
}
|
|
||||||
|
|
||||||
impl SyscallContext {
|
|
||||||
pub async fn run(&mut self) {
|
|
||||||
println!("Running async syscall runner for {:?}", self.id);
|
|
||||||
self.dispatch().await;
|
|
||||||
}
|
|
||||||
|
|
||||||
pub async fn dispatch(&mut self) {
|
|
||||||
match self.id {
|
|
||||||
EXIT_ID => proc::exit(self).await,
|
|
||||||
_ => bad_syscall().await,
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
async fn syscall_runner(context: SyscallContextT) {
|
|
||||||
context.borrow_mut().run().await;
|
|
||||||
}
|
|
||||||
|
|
||||||
pub fn syscall_routine(syscall_id: SyscallId) -> u64 {
|
|
||||||
println!("Running syscall interrupt handler");
|
|
||||||
let context: SyscallContextT = Arc::new(RefCell::new(SyscallContext {
|
|
||||||
id: syscall_id,
|
|
||||||
res: 0,
|
|
||||||
thread_id: *RUNNING_THREAD.try_lock().unwrap(),
|
|
||||||
}));
|
|
||||||
|
|
||||||
println!("Spawning async syscall runner");
|
|
||||||
let mut executor = YieldExecutor::new(context.borrow().thread_id);
|
|
||||||
executor.spawn(Task::new(syscall_runner(context.clone())));
|
|
||||||
executor.run();
|
|
||||||
|
|
||||||
let res = context.borrow().res;
|
|
||||||
res
|
|
||||||
}
|
|
||||||
|
|
||||||
async fn bad_syscall() {}
|
|
||||||
@@ -1,11 +0,0 @@
|
|||||||
use crate::println;
|
|
||||||
use crate::proc::scheduler::SCHEDULER;
|
|
||||||
use crate::proc::thread::resume_k_thread;
|
|
||||||
|
|
||||||
use super::SyscallContext;
|
|
||||||
|
|
||||||
pub async fn exit(context: &SyscallContext) {
|
|
||||||
println!("Running exit(2)");
|
|
||||||
SCHEDULER.lock().await.exit(context.thread_id);
|
|
||||||
resume_k_thread();
|
|
||||||
}
|
|
||||||
@@ -1,15 +1,7 @@
|
|||||||
use crate::utils::AsyncMutex;
|
|
||||||
|
|
||||||
use super::{Task, TaskId};
|
use super::{Task, TaskId};
|
||||||
|
|
||||||
use alloc::{collections::BTreeMap, sync::Arc, task::Wake};
|
use alloc::{collections::BTreeMap, sync::Arc, task::Wake};
|
||||||
use core::task::{Context, Poll, Waker};
|
use core::task::{Context, Poll, Waker};
|
||||||
use crossbeam_queue::ArrayQueue;
|
use crossbeam_queue::ArrayQueue;
|
||||||
use lazy_static::lazy_static;
|
|
||||||
|
|
||||||
lazy_static! {
|
|
||||||
pub static ref EXECUTOR: AsyncMutex<Executor> = AsyncMutex::new(Executor::new());
|
|
||||||
}
|
|
||||||
|
|
||||||
pub struct Executor {
|
pub struct Executor {
|
||||||
tasks: BTreeMap<TaskId, Task>,
|
tasks: BTreeMap<TaskId, Task>,
|
||||||
|
|||||||
@@ -5,7 +5,6 @@ use core::sync::atomic::{AtomicU64, Ordering};
|
|||||||
use core::task::{Context, Poll};
|
use core::task::{Context, Poll};
|
||||||
|
|
||||||
pub mod executor;
|
pub mod executor;
|
||||||
pub mod yield_executor;
|
|
||||||
pub mod keyboard;
|
pub mod keyboard;
|
||||||
|
|
||||||
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
|
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
|
||||||
|
|||||||
@@ -1,119 +0,0 @@
|
|||||||
|
|
||||||
use crate::println;
|
|
||||||
use crate::proc::thread::{ThreadId, resume_k_thread};
|
|
||||||
use crate::proc::scheduler::SCHEDULER;
|
|
||||||
|
|
||||||
use super::{Task, TaskId};
|
|
||||||
|
|
||||||
use alloc::{collections::BTreeMap, sync::Arc, task::Wake};
|
|
||||||
use core::task::{Context, Poll, Waker};
|
|
||||||
use crossbeam_queue::ArrayQueue;
|
|
||||||
|
|
||||||
pub struct YieldExecutor {
|
|
||||||
tasks: BTreeMap<TaskId, Task>,
|
|
||||||
task_queue: Arc<ArrayQueue<TaskId>>,
|
|
||||||
waker_cache: BTreeMap<TaskId, Waker>,
|
|
||||||
thread_id: ThreadId,
|
|
||||||
}
|
|
||||||
|
|
||||||
impl YieldExecutor {
|
|
||||||
pub fn new(thread_id: ThreadId) -> Self {
|
|
||||||
YieldExecutor {
|
|
||||||
tasks: BTreeMap::new(),
|
|
||||||
task_queue: Arc::new(ArrayQueue::new(100)),
|
|
||||||
waker_cache: BTreeMap::new(),
|
|
||||||
thread_id: thread_id,
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
pub fn run(&mut self) {
|
|
||||||
loop {
|
|
||||||
self.run_ready_tasks();
|
|
||||||
if self.done() {
|
|
||||||
break;
|
|
||||||
} else {
|
|
||||||
println!("Blocking thread");
|
|
||||||
SCHEDULER
|
|
||||||
.try_lock()
|
|
||||||
.unwrap()
|
|
||||||
.block(self.thread_id);
|
|
||||||
println!("Returning to scheduler");
|
|
||||||
resume_k_thread();
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
fn done(&self) -> bool {
|
|
||||||
self.tasks.is_empty()
|
|
||||||
}
|
|
||||||
|
|
||||||
pub fn spawn(&mut self, task: Task) {
|
|
||||||
let task_id = task.id;
|
|
||||||
if self.tasks.insert(task.id, task).is_some() {
|
|
||||||
panic!("Duplicate task ID");
|
|
||||||
}
|
|
||||||
self.task_queue.push(task_id).expect("Task queue full");
|
|
||||||
}
|
|
||||||
|
|
||||||
fn run_ready_tasks(&mut self) {
|
|
||||||
let Self {
|
|
||||||
tasks,
|
|
||||||
task_queue,
|
|
||||||
waker_cache,
|
|
||||||
thread_id,
|
|
||||||
} = self; // Executor destructuring
|
|
||||||
|
|
||||||
while let Ok(task_id) = task_queue.pop() {
|
|
||||||
let task = match tasks.get_mut(&task_id) {
|
|
||||||
Some(task) => task,
|
|
||||||
None => continue, // Task does not exist anymore
|
|
||||||
};
|
|
||||||
let waker = waker_cache
|
|
||||||
.entry(task_id)
|
|
||||||
.or_insert_with(|| YieldTaskWaker::new(task_id, task_queue.clone(), *thread_id));
|
|
||||||
let mut context = Context::from_waker(waker);
|
|
||||||
match task.poll(&mut context) {
|
|
||||||
Poll::Ready(()) => {
|
|
||||||
// task is done
|
|
||||||
tasks.remove(&task_id);
|
|
||||||
waker_cache.remove(&task_id);
|
|
||||||
}
|
|
||||||
Poll::Pending => {}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
struct YieldTaskWaker {
|
|
||||||
task_id: TaskId,
|
|
||||||
task_queue: Arc<ArrayQueue<TaskId>>,
|
|
||||||
thread_id: ThreadId,
|
|
||||||
}
|
|
||||||
|
|
||||||
impl YieldTaskWaker {
|
|
||||||
fn new(task_id: TaskId, task_queue: Arc<ArrayQueue<TaskId>>, thread_id: ThreadId) -> Waker {
|
|
||||||
Waker::from(Arc::new(YieldTaskWaker {
|
|
||||||
task_id,
|
|
||||||
task_queue,
|
|
||||||
thread_id
|
|
||||||
}))
|
|
||||||
}
|
|
||||||
|
|
||||||
fn wake_task(&self) {
|
|
||||||
self.task_queue.push(self.task_id).expect("Task queue full");
|
|
||||||
SCHEDULER
|
|
||||||
.try_lock()
|
|
||||||
.unwrap()
|
|
||||||
.unblock(self.thread_id);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
impl Wake for YieldTaskWaker {
|
|
||||||
fn wake(self: Arc<Self>) {
|
|
||||||
self.wake_task();
|
|
||||||
}
|
|
||||||
|
|
||||||
fn wake_by_ref(self: &Arc<Self>) {
|
|
||||||
self.wake_task();
|
|
||||||
}
|
|
||||||
}
|
|
||||||
+1
-6
@@ -11,7 +11,6 @@ use futures_util::task::AtomicWaker;
|
|||||||
#[derive(Clone)]
|
#[derive(Clone)]
|
||||||
struct Lock {
|
struct Lock {
|
||||||
lock: Arc<AtomicBool>,
|
lock: Arc<AtomicBool>,
|
||||||
// TODO: Make a queue of wakers
|
|
||||||
waker: Arc<AtomicWaker>,
|
waker: Arc<AtomicWaker>,
|
||||||
}
|
}
|
||||||
|
|
||||||
@@ -74,17 +73,13 @@ impl<T> AsyncMutex<T> {
|
|||||||
}
|
}
|
||||||
|
|
||||||
pub fn try_lock(&self) -> Option<AsyncMutexGuard<T>> {
|
pub fn try_lock(&self) -> Option<AsyncMutexGuard<T>> {
|
||||||
if !self.lock.try_lock() {
|
if self.lock.try_lock() {
|
||||||
Some(AsyncMutexGuard { mutex: self })
|
Some(AsyncMutexGuard { mutex: self })
|
||||||
} else {
|
} else {
|
||||||
None
|
None
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
pub fn force_unlock(&self) {
|
|
||||||
self.lock.drop();
|
|
||||||
}
|
|
||||||
|
|
||||||
pub async fn lock(&self) -> AsyncMutexGuard<'_, T> {
|
pub async fn lock(&self) -> AsyncMutexGuard<'_, T> {
|
||||||
self.lock.clone().await;
|
self.lock.clone().await;
|
||||||
AsyncMutexGuard { mutex: self }
|
AsyncMutexGuard { mutex: self }
|
||||||
|
|||||||