feat: add multicore

Byte-OS · Apr 27, 2024 · ed76271 · ed76271
1 parent 2267882
commit ed76271
Show file tree

Hide file tree

Showing 10 changed files with 163 additions and 164 deletions.
diff --git a/Cargo.lock b/Cargo.lock
diff --git a/kernel/Cargo.toml b/kernel/Cargo.toml
@@ -14,7 +14,6 @@ serde_derive = "1.0.136"
 
 [dependencies]
 allocator = { git = "https://github.com/Byte-OS/allocator.git", rev = "c6ce949146d5feab1d406502b19b035f5d392c35"}
-crate_interface = { git = "https://github.com/Byte-OS/crate_interface.git" }
 frame_allocator = { git = "https://github.com/Byte-OS/bit_frame_allocator.git" }
 logging = { git = "https://github.com/Byte-OS/logging.git", features = []}
 log = "0.4"

diff --git a/kernel/linker.lds.S b/kernel/linker.lds.S
@@ -40,14 +40,6 @@ SECTIONS
 
     _load_end = .;
 
-    .bss ALIGN(4K): {
-        *(.bss.stack)
-        _sbss = .;
-        *(.bss .bss.*)
-        *(.sbss .sbss.*)
-        _ebss = .;
-    }
-
     . = ALIGN(4K);
     _percpu_start = .;
     .percpu 0x0 : AT(_percpu_start) {
@@ -62,6 +54,14 @@ SECTIONS
     . = _percpu_start + SIZEOF(.percpu);
     _percpu_end = .;
 
+    .bss ALIGN(4K): {
+        *(.bss.stack)
+        _sbss = .;
+        *(.bss .bss.*)
+        *(.sbss .sbss.*)
+        _ebss = .;
+    }
+
     PROVIDE(end = .);
     /DISCARD/ : {
         *(.comment) *(.gnu*) *(.note*) *(.eh_frame*)

diff --git a/kernel/src/main.rs b/kernel/src/main.rs
@@ -214,9 +214,7 @@ fn main(hart_id: usize) {
 
         // init kernel threads and async executor
         tasks::init();
-        loop {
-            arch::wfi()
-        }
+        // loop { arch::wfi() }
         tasks::run_tasks();
 
         println!("Task All Finished!");

diff --git a/kernel/src/panic.rs b/kernel/src/panic.rs
@@ -1,11 +1,25 @@
-use arch::shutdown;
+use arch::{hart_id, shutdown};
 // use backtrace::backtrace;
 use core::panic::PanicInfo;
 
 // 程序遇到错误
 #[panic_handler]
 fn panic_handler(info: &PanicInfo) -> ! {
-    println!("\x1b[1;31mpanic: '{}'\x1b[0m", info.message().unwrap());
+    if let Some(location) = info.location() {
+        println!(
+            "\x1b[1;31m[Core {}][{}:{}]panic: '{}'\x1b[0m",
+            hart_id(),
+            location.file(),
+            location.line(),
+            info.message().unwrap()
+        );
+    } else {
+        println!(
+            "\x1b[1;31m[Core {}]panic: '{}'\x1b[0m",
+            hart_id(),
+            info.message().unwrap()
+        );
+    }
     // backtrace();
     println!("!TEST FINISH!");
     // loop {}

diff --git a/kernel/src/syscall/task.rs b/kernel/src/syscall/task.rs
@@ -24,7 +24,7 @@ use arch::{
 };
 use async_recursion::async_recursion;
 use core::cmp;
-use executor::{select, yield_now, AsyncTask, TASK_QUEUE};
+use executor::{select, thread, tid2task, yield_now, AsyncTask};
 use frame_allocator::{ceil_div, frame_alloc_much, FrameTracker};
 use fs::dentry::{dentry_open, dentry_root};
 use fs::TimeSpec;
@@ -228,8 +228,10 @@ pub async fn exec_with_process(
         Ok(user_task)
     } else {
         drop(caches);
-        let file = dentry_open(dentry_root(), &path, OpenFlags::O_RDONLY).map_err(from_vfs)?;
-        let file = file.node.clone();
+        let file = dentry_open(dentry_root(), &path, OpenFlags::O_RDONLY)
+            .map_err(from_vfs)?
+            .node
+            .clone();
         debug!("file: {:#x?}", file.metadata().unwrap());
         let file_size = file.metadata().unwrap().size;
         let frame_ppn = frame_alloc_much(ceil_div(file_size, PAGE_SIZE));
@@ -454,10 +456,10 @@ impl UserTaskContainer {
         );
 
         let new_task = match flags.contains(CloneFlags::CLONE_THREAD) {
-            true => self.task.clone().thread_clone(user_entry()),
+            true => self.task.clone().thread_clone(),
             // false => curr_task.clone().fork(user_entry()),
             // use cow(Copy On Write) to save memory.
-            false => self.task.clone().cow_fork(user_entry()),
+            false => self.task.clone().cow_fork(),
         };
 
         let clear_child_tid = flags
@@ -484,6 +486,7 @@ impl UserTaskContainer {
         new_tcb.exit_signal = sig as u8;
         drop(new_tcb);
         yield_now().await;
+        thread::spawn(new_task.clone(), user_entry());
         Ok(new_task.task_id)
     }
 
@@ -531,11 +534,13 @@ impl UserTaskContainer {
                 "wait ok: {}  waiter: {}",
                 child_task.task_id, self.task.task_id
             );
+            // release the task resources
             self.task
                 .pcb
                 .lock()
                 .children
                 .retain(|x| x.task_id != child_task.task_id);
+            child_task.release();
             debug!("wait pid: {}", child_task.exit_code().unwrap());
 
             if status.is_valid() {
@@ -555,11 +560,13 @@ impl UserTaskContainer {
             match exit {
                 Some(t1) => {
                     let child_task = child_task.unwrap();
+                    // Release task.
                     self.task
                         .pcb
                         .lock()
                         .children
                         .retain(|x| x.task_id != child_task.task_id);
+                    child_task.release();
                     if status.is_valid() {
                         *status.get_mut() = (t1 as i32) << 8;
                     }
@@ -780,23 +787,12 @@ impl UserTaskContainer {
             self.tid, pid, signal
         );
 
-        let user_task = match pid == self.tid {
-            true => Some(self.task.clone()),
-            false => TASK_QUEUE
-                .lock()
-                .iter()
-                .find(|x| x.task.get_task_id() == pid)
-                .ok_or(LinuxError::ESRCH)?
-                .task
-                .clone()
+        let user_task = match tid2task(pid) {
+            Some(task) => task
                 .downcast_arc::<UserTask>()
-                .ok(),
-        };
-
-        let user_task = match user_task {
-            Some(t) => t,
-            None => return Err(LinuxError::ESRCH),
-        };
+                .map_err(|_| LinuxError::ESRCH),
+            None => Err(LinuxError::ESRCH),
+        }?;
 
         user_task.tcb.write().signal.add_signal(signal.clone());
 

diff --git a/kernel/src/tasks/async_ops.rs b/kernel/src/tasks/async_ops.rs
@@ -2,6 +2,7 @@ use core::{cmp, future::Future, pin::Pin, task::Poll};
 
 use alloc::{sync::Arc, vec::Vec};
 use arch::time::Time;
+use executor::AsyncTask;
 use sync::Mutex;
 
 use crate::syscall::consts::LinuxError;

diff --git a/kernel/src/tasks/initproc.rs b/kernel/src/tasks/initproc.rs
@@ -4,8 +4,8 @@ use alloc::{
     string::{String, ToString},
     vec::Vec,
 };
-use arch::debug::DebugConsole;
-use executor::{current_task, task::TaskType, yield_now, TASK_QUEUE};
+use arch::{debug::DebugConsole, hart_id, shutdown};
+use executor::{current_task, release_task, task::TaskType, tid2task, yield_now, TASK_MAP};
 use frame_allocator::get_free_pages;
 use fs::{
     dentry::{dentry_open, dentry_root, DentryNode},
@@ -56,9 +56,9 @@ fn clear() {
 }
 
 async fn kill_all_tasks() {
-    TASK_QUEUE
-        .lock()
-        .retain(|x| x.task_type != TaskType::MonolithicTask);
+    TASK_MAP.lock().values().into_iter().for_each(|task| {
+        task.upgrade().inspect(|x| x.exit(100));
+    });
 }
 
 async fn run_libc_test() -> bool {
@@ -129,13 +129,10 @@ async fn file_command(cmd: &str) {
             args_extend.extend(args.into_iter());
             // args.into_iter().for_each(|x| args_extend.push(x));
             let task_id = add_user_task(&filename, args_extend, Vec::new()).await;
+            let task = tid2task(task_id).unwrap();
             loop {
-                if TASK_QUEUE
-                    .lock()
-                    .iter()
-                    .find(|x| x.task.get_task_id() == task_id)
-                    .is_none()
-                {
+                if task.exit_code().is_some() {
+                    release_task(task_id);
                     break;
                 }
                 yield_now().await;
@@ -225,6 +222,7 @@ pub async fn initproc() {
     // }
 
     println!("start kernel tasks");
+
     // command("ls").await;
     // command("entry-static.exe crypt").await;
     // command("./runtest.exe -w entry-dynamic.exe dlopen").await;
@@ -283,10 +281,12 @@ pub async fn initproc() {
     // command("busybox echo run libctest_testcode.sh").await;
     // command("busybox sh libctest_testcode.sh").await;
 
+    // command("busybox sh ./run-static.sh").await;
+    // command("./runtest.exe -w entry-dynamic.exe pthread_robust_detach").await;
     // command("busybox echo 123").await;
-    command("qjs.static test.js").await;
+    // command("qjs.static test.js").await;
     // command("qjs.static").await;
-    command("busybox sh").await;
+    // command("busybox sh").await;
     // command("busybox echo run lua_testcode.sh").await;
     // command("busybox sh lua_testcode.sh").await;
 
@@ -306,8 +306,8 @@ pub async fn initproc() {
     // command("busybox echo run lmbench_testcode.sh").await;
     // command("busybox sh lmbench_testcode.sh").await;
 
-    // command("busybox echo run unixbench_testcode.sh").await;
-    // command("busybox sh unixbench_testcode.sh").await;
+    command("busybox echo run unixbench_testcode.sh").await;
+    command("busybox sh unixbench_testcode.sh").await;
 
     // command("copy-file-range-test-1").await;
     // command("copy-file-range-test-2").await;
@@ -380,4 +380,18 @@ pub async fn initproc() {
 
     // switch_to_kernel_page_table();
     println!("!TEST FINISH!");
+
+    // Shutdown if there just have blankkernel task.
+    if TASK_MAP
+        .lock()
+        .values()
+        .find(|x| {
+            x.upgrade()
+                .map(|x| x.get_task_type() != TaskType::BlankKernel)
+                .unwrap_or(false)
+        })
+        .is_none()
+    {
+        shutdown();
+    }
 }
diff --git a/kernel/src/tasks/mod.rs b/kernel/src/tasks/mod.rs
@@ -3,7 +3,7 @@ use alloc::sync::Weak;
 use alloc::{sync::Arc, vec::Vec};
 use arch::get_cpu_num;
 use devices::get_net_device;
-use executor::{current_task, thread, yield_now, AsyncTask, TaskId, DEFAULT_EXECUTOR, TASK_QUEUE};
+use executor::{current_task, thread, yield_now, AsyncTask, TaskId, DEFAULT_EXECUTOR};
 use hal::{ITimerVal, TimeVal};
 
 use crate::syscall::{exec_with_process, NET_SERVER};
@@ -74,9 +74,6 @@ pub async fn handle_net() {
     let mut buffer = vec![0u8; 2048];
     // #[cfg(feature = "net")]
     loop {
-        if TASK_QUEUE.lock().len() == 0 {
-            break;
-        }
         let res = get_net_device(0).recv(&mut buffer);
         if let Ok(rlen) = res {
             NET_SERVER.analysis_net_data(&buffer[..rlen]);
@@ -86,11 +83,10 @@ pub async fn handle_net() {
 }
 
 pub fn init() {
+    DEFAULT_EXECUTOR.init(get_cpu_num());
     thread::spawn_blank(initproc());
     #[cfg(feature = "net")]
     thread::spawn_blank(KernelTask::new(handle_net()));
-
-    DEFAULT_EXECUTOR.init(get_cpu_num());
 }
 
 pub fn run_tasks() {
@@ -99,8 +95,7 @@ pub fn run_tasks() {
 
 pub async fn add_user_task(filename: &str, args: Vec<&str>, envp: Vec<&str>) -> TaskId {
     let curr_task = current_task();
-    let task = UserTask::new(user_entry(), Weak::new(), initproc::USER_WORK_DIR);
-
+    let task = UserTask::new(Weak::new(), initproc::USER_WORK_DIR);
     task.before_run();
     exec_with_process(
         task.clone(),
@@ -111,6 +106,7 @@ pub async fn add_user_task(filename: &str, args: Vec<&str>, envp: Vec<&str>) ->
     .await
     .expect("can't add task to excutor");
     curr_task.before_run();
+    thread::spawn(task.clone(), user_entry());
 
     task.get_task_id()
 }