wip: pid & async test

pkg/kernel/Cargo.toml

@@ -27,3 +27,4 @@ crossbeam-queue = { version = "0.3.5", default-features = false, features = ["al
 volatile = "0.4.4"
 xmas-elf = "0.8"
 num_enum = { version = "0.5.7", default-features = false }
+futures-util = { version = "0.3.21", default-features = false, features = ["alloc"] }

pkg/kernel/src/drivers/console.rs

@@ -1,8 +1,6 @@
 use crate::drivers::display::get_display_for_sure;
-use crate::input::get_input_buf_for_sure;
 use crate::utils::colors;
 use crate::utils::font;
-use alloc::string::ToString;
 use core::fmt::Write;
 use embedded_graphics::{
     mono_font::{MonoFont, MonoTextStyle},
@@ -11,7 +9,6 @@ use embedded_graphics::{
     text::{renderer::CharacterStyle, Baseline, Text},
 };
 use fs::*;
-use pc_keyboard::DecodedKey;
 
 once_mutex!(pub CONSOLE: Console);
 
@@ -184,20 +181,8 @@ impl Device<u8> for Console {
         if offset + size >= buf.len() {
             return Err(DeviceError::ReadError);
         }
-        x86_64::instructions::interrupts::without_interrupts(|| {
-            let stdin = get_input_buf_for_sure();
-            let mut read_count = 0;
-            while !stdin.is_empty() && read_count < size {
-                if let Some(DecodedKey::Unicode(c)) = stdin.pop() {
-                    let s = c.to_string();
-                    let len = s.len();
-                    buf[offset + read_count..offset + read_count + len]
-                        .copy_from_slice(s.as_bytes());
-                    read_count += len;
-                }
-            }
-            Ok(read_count)
-        })
+        // TODO: get key
+        Ok(0)
     }
 
     fn write(&mut self, buf: &[u8], offset: usize, size: usize) -> Result<usize, DeviceError> {

pkg/kernel/src/drivers/input.rs

@@ -18,20 +18,18 @@ pub fn init() {
 pub fn try_get_key() -> Option<DecodedKey> {
     interrupts::without_interrupts(|| {
         if let Some(key) = get_input_buf_for_sure().pop() {
-            return Some(key);
+            Some(key)
+        } else {
+            None
         }
-        None
     })
 }
 
 pub fn get_key() -> DecodedKey {
     loop {
-        crate::utils::halt();
-        interrupts::without_interrupts(|| {
-            if let Some(k) = try_get_key() {
-                return k;
-            }
-        })
+        if let Some(k) = try_get_key() {
+            return k;
+        }
     }
 }
 

pkg/kernel/src/drivers/mod.rs

@@ -5,6 +5,6 @@ pub mod serial;
 pub mod console;
 pub mod display;
 pub mod keyboard;
-pub mod input;
+// pub mod input;
 pub mod filesystem;
 pub mod ata;

pkg/kernel/src/interrupt/keyboard.rs

@@ -4,7 +4,7 @@ use x86_64::{
     structures::idt::{InterruptDescriptorTable, InterruptStackFrame},
 };
 use pc_keyboard::DecodedKey;
-use crate::{keyboard::get_keyboard_for_sure, drivers::input::get_input_buf_for_sure};
+use crate::{keyboard::get_keyboard_for_sure, push_key};
 
 pub unsafe fn reg_idt(idt: &mut InterruptDescriptorTable) {
     idt[(consts::Interrupts::IRQ0 as u8 + consts::IRQ::Keyboard as u8) as usize]
@@ -38,6 +38,6 @@ pub fn receive() -> Option<DecodedKey> {
 pub extern "x86-interrupt" fn interrupt_handler(_st: InterruptStackFrame) {
     super::ack(super::consts::IRQ::Keyboard as u8);
     if let Some(key) = receive() {
-        get_input_buf_for_sure().push(key).unwrap();
+        push_key(key);
     }
 }

pkg/kernel/src/interrupt/serial.rs

@@ -1,10 +1,7 @@
 use super::consts;
 use x86_64::structures::idt::{InterruptDescriptorTable, InterruptStackFrame};
 use pc_keyboard::DecodedKey;
-use crate::drivers::{
-    input::get_input_buf_for_sure,
-    serial::get_serial_for_sure
-};
+use crate::{drivers::serial::get_serial_for_sure, push_key};
 
 pub unsafe fn reg_idt(idt: &mut InterruptDescriptorTable) {
     idt[(consts::Interrupts::IRQ0 as u8 + consts::IRQ::Serial0 as u8) as usize]
@@ -33,6 +30,6 @@ pub fn receive() -> Option<DecodedKey> {
 pub extern "x86-interrupt" fn interrupt_handler(_st: InterruptStackFrame) {
     super::ack(super::consts::IRQ::Serial0 as u8);
     if let Some(key) = receive() {
-        get_input_buf_for_sure().push(key).unwrap();
+        push_key(key);
     }
 }

pkg/kernel/src/interrupt/syscall/mod.rs

@@ -40,8 +40,6 @@ pub fn dispatcher(regs: &mut Registers, sf: &mut InterruptStackFrame) {
         regs.rsi,
         regs.rdx
     );
-    debug!("{}", args);
-    debug!("{:#?}\n{:#?}", sf, regs);
 
     match args.syscall {
         Syscall::SpawnProcess => regs.set_rax(spawn_process(&args)),
@@ -58,7 +56,7 @@ pub fn dispatcher(regs: &mut Registers, sf: &mut InterruptStackFrame) {
         Syscall::Draw => sys_draw(&args),
         Syscall::None => {}
     }
-    debug!("syscall finished.");
+    // debug!("syscall finished.");
 }
 
 impl SyscallArgs {

pkg/kernel/src/interrupt/syscall/service.rs

@@ -65,7 +65,7 @@ pub fn spawn_process(args: &SyscallArgs) -> usize {
         warn!("spawn_process: failed to spawn process: {}", path);
         return 0;
     }
-    pid.unwrap() as usize
+    u16::from(pid.unwrap()) as usize
 }
 
 pub fn sys_read(args: &SyscallArgs) -> usize {
@@ -74,12 +74,7 @@ pub fn sys_read(args: &SyscallArgs) -> usize {
         let buf = unsafe {
             core::slice::from_raw_parts_mut(args.arg1 as *mut u8, args.arg2)
         };
-        return if let Ok(size) = res.read(buf) {
-            debug!(
-                "read {} bytes: {:?}",
-                size,
-                unsafe{ core::str::from_utf8_unchecked(&buf[..size]) }
-            );
+        if let Ok(size) = res.read(buf) {
             size
         } else {
             0

pkg/kernel/src/lib.rs

@@ -25,6 +25,9 @@ pub mod drivers;
 pub use drivers::*;
 
 pub mod memory;
+pub mod tasks;
+
+pub use tasks::*;
 use memory::gdt;
 use memory::allocator;
 
@@ -48,7 +51,6 @@ pub fn init(boot_info: &'static BootInfo) {
     allocator::init();          // init heap allocator
     process::init();            // init process manager
     keyboard::init();           // init keyboard
-    input::init();              // init input manager
     ata::init();                // init ata
     filesystem::init();         // init filesystem
 

pkg/kernel/src/main.rs

@@ -1,6 +1,7 @@
 #![no_std]
 #![no_main]
 
+use ggos::*;
 use ggos_kernel as ggos;
 
 extern crate alloc;
@@ -10,14 +11,18 @@ boot::entry_point!(kernal_main);
 pub fn kernal_main(boot_info: &'static boot::BootInfo) -> ! {
     ggos::init(boot_info);
 
-    let sh_file = ggos::filesystem::try_get_file("/APP/SH").unwrap();
-    let pid = ggos::process::spawn(&sh_file).unwrap();
+    // let sh_file = ggos::filesystem::try_get_file("/APP/SH").unwrap();
+    // let pid = ggos::process::spawn(&sh_file).unwrap();
 
-    while ggos::process::still_alive(pid) {
-        unsafe {
-            core::arch::asm!("hlt");
-        }
-    }
+    // while ggos::process::still_alive(pid) {
+    //     unsafe {
+    //         core::arch::asm!("hlt");
+    //     }
+    // }
 
-    ggos::shutdown(boot_info);
+    let mut executor = Executor::new();
+    executor.spawn(Task::new(get_key()));
+    executor.run();
+
+    // ggos::shutdown(boot_info);
 }

pkg/kernel/src/process/manager.rs

@@ -12,10 +12,8 @@ guard_access_fn! {
 }
 
 pub struct ProcessManager {
-    /// the next pid to be assigned
-    next_pid: u16,
     /// pid of the current running process
-    cur_pid: u16,
+    cur_pid: ProcessId,
     processes: Vec<Process>,
 }
 
@@ -24,8 +22,7 @@ impl ProcessManager {
         let mut processes = Vec::<Process>::new();
         processes.push(init);
         Self {
-            cur_pid: 0,
-            next_pid: 1,
+            cur_pid: ProcessId(0),
             processes,
         }
     }
@@ -50,7 +47,7 @@ impl ProcessManager {
             current.tick();
             current.save(regs, sf);
         }
-        debug!("Paused process #{}", self.cur_pid);
+        // debug!("Paused process #{}", self.cur_pid);
     }
 
     fn get_next_pos(&self) -> usize {
@@ -67,15 +64,15 @@ impl ProcessManager {
         }
     }
 
-    pub fn still_alive(&self, pid: u16) -> bool {
+    pub fn still_alive(&self, pid: ProcessId) -> bool {
         self.processes.iter().any(|x| x.pid() == pid)
     }
 
     pub fn switch_next(&mut self, regs: &mut Registers, sf: &mut InterruptStackFrame) {
         let pos = self.get_next_pos();
         let p = &mut self.processes[pos];
 
-        debug!("Next process {} #{}", p.name(), p.pid());
+        // debug!("Next process {} #{}", p.name(), p.pid());
         if p.pid() == self.cur_pid {
             // the next process to be resumed is the same as the current one
             p.resume();
@@ -90,12 +87,11 @@ impl ProcessManager {
         &mut self,
         elf: &ElfFile,
         name: String,
-        parent: u16,
+        parent: ProcessId,
         proc_data: Option<ProcessData>,
-    ) -> u16 {
+    ) -> ProcessId {
         let mut p = Process::new(
             &mut *crate::memory::get_frame_alloc_for_sure(),
-            self.next_pid,
             name,
             parent,
             proc_data,
@@ -110,7 +106,6 @@ impl ProcessManager {
         // info!("Spawn process:\n\n{:?}\n", p);
         let pid = p.pid();
         self.processes.push(p);
-        self.next_pid += 1; // TODO: recycle PID
         pid
     }
 
@@ -119,23 +114,20 @@ impl ProcessManager {
         entry: VirtAddr,
         stack_top: VirtAddr,
         name: String,
-        parent: u16,
+        parent: ProcessId,
         proc_data: Option<ProcessData>,
-    ) -> u16 {
+    ) -> ProcessId {
         let mut p = Process::new(
             &mut *crate::memory::get_frame_alloc_for_sure(),
-            self.next_pid,
             name,
             parent,
             proc_data,
         );
         p.pause();
         p.init_stack_frame(entry, stack_top);
         info!("Spawn process: {}#{}", p.name(), p.pid());
-        // info!("Spawn process:\n\n{:?}\n", p);
         let pid = p.pid();
         self.processes.push(p);
-        self.next_pid += 1; // TODO: recycle PID
         pid
     }