Merge #621

621: feat: implement `exit` system call r=toku-sa-n a=toku-sa-n

- feat: implement `exit` system call
- test: add a process to test `exit` system call
Fixes: #620 
bors r+


Co-authored-by: toku-sa-n <[email protected]>

Author: bors[bot]

kernel/src/lib.rs

@@ -111,13 +111,14 @@ fn initialize_in_user_mode(boot_info: &mut kernelboot::Info) {
     ustar.list();
     ustar.content("build/bootx64.efi");
 
-    process::init();
+    process::manager::init();
 
     process::manager::add(run_tasks, Privilege::User);
 
     if cfg!(feature = "qemu_test") {
         process::manager::add(tests::main, Privilege::User);
         process::manager::add(tests::process::kernel_privilege_test, Privilege::Kernel);
+        process::manager::add(tests::process::exit_test, Privilege::User);
     }
 }
 

kernel/src/process/collections/process.rs

@@ -39,6 +39,10 @@ where
     f(p)
 }
 
+pub(in crate::process) fn remove(id: process::Id) {
+    lock_processes().remove(&id).expect("No such process.");
+}
+
 fn lock_processes() -> SpinlockGuard<'static, BTreeMap<process::Id, Process>> {
     PROCESSES
         .try_lock()

kernel/src/process/collections/woken_pid.rs

@@ -20,6 +20,12 @@ pub(super) fn active_pid() -> process::Id {
     lock_queue()[0]
 }
 
+pub(in crate::process) fn pop() -> process::Id {
+    lock_queue()
+        .pop_front()
+        .expect("All processes are terminated.")
+}
+
 fn lock_queue() -> SpinlockGuard<'static, VecDeque<process::Id>> {
     WOKEN_PIDS
         .try_lock()

kernel/src/process/exit.rs

@@ -0,0 +1,43 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+use super::{
+    collections,
+    manager::{self, Message},
+};
+use common::constant::INTERRUPT_STACK;
+
+// Do not define this as a function as the function cannot return.
+macro_rules! change_stack {
+    () => {
+        const RSP: u64 = INTERRUPT_STACK.as_u64();
+        unsafe {
+            asm!("
+            mov rsp, {}
+            ", const RSP);
+        }
+    };
+}
+
+pub fn exit() -> ! {
+    change_stack!();
+    free_stack();
+    manager::set_temporary_stack_frame();
+    send_exit_message();
+    cause_timer_interrupt();
+}
+
+fn free_stack() {
+    collections::process::handle_running_mut(|p| {
+        p.stack = None;
+        p.stack_frame = None;
+    });
+}
+
+fn send_exit_message() {
+    let id = collections::woken_pid::pop();
+    manager::send_message(Message::Exit(id));
+}
+
+fn cause_timer_interrupt() -> ! {
+    unsafe { asm!("int 0x20", options(noreturn)) }
+}

kernel/src/process/manager.rs

@@ -1,36 +1,52 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
 
 use super::{collections, collections::woken_pid, switch, Privilege, Process};
+use crate::tss::TSS;
 use alloc::collections::VecDeque;
+use common::constant::INTERRUPT_STACK;
 use conquer_once::spin::Lazy;
 use spinning_top::Spinlock;
+
+pub use super::exit::exit;
 pub use switch::switch;
 
 static MESSAGE: Lazy<Spinlock<VecDeque<Message>>> = Lazy::new(|| Spinlock::new(VecDeque::new()));
 
 pub fn main() -> ! {
     loop {
-        while let Some(Message::Add(f, p)) = MESSAGE.lock().pop_front() {
-            match p {
-                Privilege::Kernel => push_process_to_queue(Process::kernel(f)),
-                Privilege::User => push_process_to_queue(Process::user(f)),
+        while let Some(m) = MESSAGE.lock().pop_front() {
+            match m {
+                Message::Add(f, p) => match p {
+                    Privilege::Kernel => push_process_to_queue(Process::kernel(f)),
+                    Privilege::User => push_process_to_queue(Process::user(f)),
+                },
+                Message::Exit(id) => collections::process::remove(id),
             }
         }
     }
 }
 
 pub fn init() {
+    set_temporary_stack_frame();
     push_process_to_queue(Process::user(main));
 }
 
 pub fn add(f: fn() -> !, p: Privilege) {
-    MESSAGE.lock().push_back(Message::Add(f, p));
+    send_message(Message::Add(f, p));
 }
 
 pub fn getpid() -> i32 {
     collections::process::handle_running(|p| p.id.as_i32())
 }
 
+pub(super) fn send_message(m: Message) {
+    MESSAGE.lock().push_back(m);
+}
+
+pub(super) fn set_temporary_stack_frame() {
+    TSS.lock().interrupt_stack_table[0] = INTERRUPT_STACK;
+}
+
 fn push_process_to_queue(p: Process) {
     add_pid(p.id());
     add_process(p);
@@ -48,6 +64,7 @@ pub(super) fn loader(f: fn() -> !) -> ! {
     f()
 }
 
-enum Message {
+pub(super) enum Message {
     Add(fn() -> !, Privilege),
+    Exit(super::Id),
 }

kernel/src/process/mod.rs

@@ -1,31 +1,19 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
 
 mod collections;
+mod exit;
 pub mod manager;
 mod stack_frame;
 mod switch;
 
-use crate::{
-    mem::{allocator::page_box::PageBox, paging::pml4::PML4},
-    tss::TSS,
-};
-use common::constant::INTERRUPT_STACK;
+use crate::mem::{allocator::page_box::PageBox, paging::pml4::PML4};
 use core::sync::atomic::{AtomicI32, Ordering};
 use stack_frame::StackFrame;
 use x86_64::{
     structures::paging::{PageTable, PageTableFlags},
     PhysAddr, VirtAddr,
 };
 
-pub fn init() {
-    register_initial_interrupt_stack_table_addr();
-    manager::init();
-}
-
-fn register_initial_interrupt_stack_table_addr() {
-    TSS.lock().interrupt_stack_table[0] = INTERRUPT_STACK;
-}
-
 #[derive(Debug)]
 pub struct Process {
     id: Id,

kernel/src/syscall.rs

@@ -13,7 +13,7 @@ use x86_64::{
     PhysAddr, VirtAddr,
 };
 
-use crate::mem::allocator;
+use crate::{mem::allocator, process};
 
 pub fn init() {
     enable();
@@ -94,6 +94,7 @@ unsafe fn select_proper_syscall(idx: u64, a1: u64, a2: u64) -> u64 {
                 sys_unmap_pages(VirtAddr::new(a1), Bytes::new(a2.try_into().unwrap()))
             }
             syscalls::Ty::GetPid => sys_getpid().try_into().unwrap(),
+            syscalls::Ty::Exit => sys_exit(),
         },
         None => panic!("Unsupported syscall index: {}", idx),
     }
@@ -168,5 +169,9 @@ fn sys_unmap_pages(start: VirtAddr, bytes: Bytes) -> u64 {
 }
 
 fn sys_getpid() -> i32 {
-    crate::process::manager::getpid()
+    process::manager::getpid()
+}
+
+fn sys_exit() -> ! {
+    process::manager::exit();
 }

kernel/src/tests/process.rs

@@ -19,3 +19,7 @@ pub fn kernel_privilege_test() -> ! {
         x86_64::instructions::hlt()
     }
 }
+
+pub fn exit_test() -> ! {
+    syscalls::exit();
+}

syscalls/src/lib.rs

@@ -92,6 +92,11 @@ pub fn getpid() -> i32 {
     unsafe { general_syscall(Ty::GetPid, 0, 0).try_into().unwrap() }
 }
 
+pub fn exit() -> ! {
+    let ty = Ty::Exit as u64;
+    unsafe { asm!("syscall", in("rax") ty, options(noreturn)) }
+}
+
 /// SAFETY: This function is unsafe if arguments are invalid.
 unsafe fn general_syscall(ty: Ty, a1: u64, a2: u64) -> u64 {
     let ty = ty as u64;
@@ -117,4 +122,5 @@ pub enum Ty {
     MapPages,
     UnmapPages,
     GetPid,
+    Exit,
 }