进程管理模块重构完成 (#380)

* 添加新版pcb的数据结构 (#273)

* 将pcb中的内容分类，分别加锁 (#305)

* 进程管理重构：完成fork的主体逻辑 (#309)

1.完成fork的主体逻辑
2.将文件系统接到新的pcb上
3.经过思考,暂时弃用signal机制,待进程管理重构完成后,重写signal机制.原因是原本的signal机制太烂了

* chdir getcwd pid pgid ppid (#310)


---------

Co-authored-by: longjin <longjin@RinGoTek.cn>

* 删除旧的fork以及signal的代码，并调整fork/vfork/execve系统调用 (#325)

1.删除旧的fork
2.删除signal相关代码,等进程管理重构结束之后,再重新写.
3.调整了fork/vfork/execve系统调用

* 实现切换进程的代码 (#331)



* 实现切换进程的代码

* Patch modify preempt (#332)

* 修改设置preempt的代码

* 删除rust的list和refcount

* 为每个核心初始化idle进程 (#333)

* 为每个核心初始化idle进程

* 完成了新的内核线程机制 (#335)

* 调度器的pcb替换为新的Arc<ProcessControlBlock>，把调度器队列锁从 RwSpinLock 替换为了 SpinLock (#336)

* 把调度器的pcb替换为新的Arc<ProcessControlBlock>

* 把调度器队列锁从 RwSpinLock 替换为了 SpinLock ，修改了签名以通过编译

* 修正一些双重加锁、细节问题

---------

Co-authored-by: longjin <longjin@RinGoTek.cn>

* github workflow自动检查代码是否格式化

* cache toolchain yml

* 调整rust版本的waitqueue中的pcb为新版的pcb (#343)

* 解决设置rust workspace带来的“工具链不一致”的问题 (#344)


* 解决设置rust workspace带来的“工具链不一致”的问题

更改workflow

* 调整pcb的sched_info和rwlock，以避免调度器死锁问题 (#341)

* 调整pcb的sched_info和rwlock，以避免调度器死锁问题

* 修改为在 WriterGuard 中维护 Irq_guard

* 修正了 write_irqsave方法

* 优化了代码

* 把 set state 操作从 wakup 移动到 sched_enqueue 中

* 修正为在 wakeup 中设置 running ，以保留 set_state 的私有性

* 移除了 process_wakeup

* 实现进程退出的逻辑 (#340)

实现进程退出的逻辑

* 标志进程sleep

* 修复wakeup的问题

---------

Co-authored-by: longjin <longjin@RinGoTek.cn>

* rust 重构 completion (#350)

* 完成了completion的基本结构，待完善上级调用

* 用SpinLock保护结构体并发安全

* 修改原子变量为u32，修复符号错误

* irq guard

* 修改为具有内部可变性的结构体

* temp fix

* 修复了由于进程持有自旋锁导致的不被调度的问题

* 对 complete 系列方法上锁，保护 done 数据并发安全

* 移除了未使用的依赖

* 重写显示刷新驱动 (#363)

* 重构显示刷新驱动

* Patch refactor process management (#366)

* 维护进程树

* 维护进程树

* 更改代码结构

* 新建进程时，设置cwd

* 调整adopt childern函数，降低开销

---------

Co-authored-by: longjin <longjin@RinGoTek.cn>

* waitqueue兼容C部分 (#351)

* PATH

* safe init

* waitqueue兼容C部分

* waitqueue兼容C部分

* 删除semaphore.c,在ps2_keyboard中使用waitqueue

* 删除semaphore.c,在ps2_keyboard中使用waitqueue

* current_pcb的C兼容

* current_pcb的C兼容

* current_pcb的C兼容

* fmt

* current_pcb的兼容

* 针对修改

* 调整代码

* fmt

* 删除pcb的set flags

* 更改函数名

---------

Co-authored-by: longjin <longjin@RinGoTek.cn>

* merge master

* Patch debug process management refactor (#372)

* 能够调通，执行完textui_init

* 能跑到initial kernel thread

* fmt

* 能够正常初始化所有服务（尚未能切换到用户程序）

* 删除部分无用的extern

* 存在问题：ap处理器启动后，bsp的smp_init函数return之后就出错了，怀疑是栈损坏

* 解决smp启动由于未换栈导致的内存访问错误

* debug

* 1

* 1

* lock no preempt

* 调通

* 优化代码，删除一些调试日志

* fix

* 使用rust重写wait4 (#377)

* 维护进程树

* 维护进程树

* 更改代码结构

* 新建进程时，设置cwd

* 调整adopt childern函数，降低开销

* wait4

* 删除c_sys_wait4

* 使用userbuffer保护裸指针

---------

Co-authored-by: longjin <longjin@RinGoTek.cn>

* 消除warning

* 1. 修正未设置cpu executing的问题

* 修正kthread机制可能存在的内存泄露问题

* 删除pcb文档

* 删除C的tss struct

---------

Co-authored-by: Bullet <93781792+GP-Bullet@users.noreply.github.com>
Co-authored-by: Chiichen <39649411+Chiichen@users.noreply.github.com>
Co-authored-by: hanjiezhou <zhouhanjie@dragonos.org>
Co-authored-by: GnoCiYeH <118462160+GnoCiYeH@users.noreply.github.com>
Co-authored-by: houmkh <1119644616@qq.com>

kernel/src/libs/spinlock.rs

@@ -1,169 +1,21 @@
 #![allow(dead_code)]
 use core::cell::UnsafeCell;
+use core::hint::spin_loop;
 use core::mem::ManuallyDrop;
 use core::ops::{Deref, DerefMut};
-use core::ptr::read_volatile;
 
 use core::sync::atomic::{AtomicBool, Ordering};
 
-use crate::arch::asm::irqflags::{local_irq_restore, local_irq_save};
-use crate::arch::interrupt::{cli, sti};
-
-use crate::include::bindings::bindings::{spin_lock, spin_unlock, spinlock_t};
-use crate::process::preempt::{preempt_disable, preempt_enable};
+use crate::arch::CurrentIrqArch;
+use crate::exception::{InterruptArch, IrqFlagsGuard};
+use crate::process::ProcessManager;
 use crate::syscall::SystemError;
 
-/// @brief 保存中断状态到flags中，关闭中断，并对自旋锁加锁
-#[inline]
-pub fn spin_lock_irqsave(lock: *mut spinlock_t, flags: &mut usize) {
-    *flags = local_irq_save();
-    unsafe {
-        spin_lock(lock);
-    }
-}
-
-/// @brief 恢复rflags以及中断状态并解锁自旋锁
-#[inline]
-pub fn spin_unlock_irqrestore(lock: *mut spinlock_t, flags: usize) {
-    unsafe {
-        spin_unlock(lock);
-    }
-    local_irq_restore(flags);
-}
-
-/// 判断一个自旋锁是否已经被加锁
-#[inline]
-pub fn spin_is_locked(lock: &spinlock_t) -> bool {
-    let val = unsafe { read_volatile(&lock.lock as *const i8) };
-
-    return if val == 0 { true } else { false };
-}
-
-impl Default for spinlock_t {
-    fn default() -> Self {
-        Self { lock: 1 }
-    }
-}
-
-/// @brief 关闭中断并加锁
-pub fn spin_lock_irq(lock: *mut spinlock_t) {
-    cli();
-    unsafe {
-        spin_lock(lock);
-    }
-}
-
-/// @brief 解锁并开中断
-pub fn spin_unlock_irq(lock: *mut spinlock_t) {
-    unsafe {
-        spin_unlock(lock);
-    }
-    sti();
-}
-
-/// 原始的Spinlock（自旋锁）
-/// 请注意，这个自旋锁和C的不兼容。
-///
-/// @param self.0 这个AtomicBool的值为false时，表示没有被加锁。当它为true时，表示自旋锁已经被上锁。
-#[derive(Debug)]
-pub struct RawSpinlock(AtomicBool);
-
-impl RawSpinlock {
-    /// @brief 初始化自旋锁
-    pub const INIT: RawSpinlock = RawSpinlock(AtomicBool::new(false));
-
-    /// @brief 加锁
-    pub fn lock(&self) {
-        while !self.try_lock() {}
-    }
-
-    /// @brief 关中断并加锁
-    pub fn lock_irq(&self) {
-        cli();
-        self.lock();
-    }
-
-    /// @brief 尝试加锁
-    /// @return 加锁成功->true
-    ///         加锁失败->false
-    pub fn try_lock(&self) -> bool {
-        // 先增加自旋锁持有计数
-        preempt_disable();
-
-        let res = self
-            .0
-            .compare_exchange(false, true, Ordering::Acquire, Ordering::Relaxed)
-            .is_ok();
-
-        // 如果加锁失败恢复自旋锁持有计数
-        if res == false {
-            preempt_enable();
-        }
-        return res;
-    }
-
-    /// @brief 解锁
-    pub fn unlock(&self) {
-        // 减少自旋锁持有计数
-        preempt_enable();
-        self.0.store(false, Ordering::Release);
-    }
-
-    /// 解锁，但是不更改preempt count
-    unsafe fn unlock_no_preempt(&self) {
-        self.0.store(false, Ordering::Release);
-    }
-
-    /// @brief 放锁并开中断
-    pub fn unlock_irq(&self) {
-        self.unlock();
-        sti();
-    }
-
-    /// @brief 判断自旋锁是否被上锁
-    ///
-    /// @return true 自旋锁被上锁
-    /// @return false 自旋锁处于解锁状态
-    pub fn is_locked(&self) -> bool {
-        return self.0.load(Ordering::Relaxed).into();
-    }
-
-    /// @brief 强制设置自旋锁的状态
-    /// 请注意，这样操作可能会带来未知的风险。因此它是unsafe的。（尽管从Rust语言本身来说，它是safe的）
-    pub unsafe fn set_value(&mut self, value: bool) {
-        self.0.store(value, Ordering::SeqCst);
-    }
-
-    /// @brief 保存中断状态到flags中，关闭中断，并对自旋锁加锁
-    pub fn lock_irqsave(&self, flags: &mut usize) {
-        *flags = local_irq_save();
-        self.lock();
-    }
-
-    /// @brief 恢复rflags以及中断状态并解锁自旋锁
-    pub fn unlock_irqrestore(&self, flags: usize) {
-        self.unlock();
-        local_irq_restore(flags);
-    }
-
-    /// @brief 尝试保存中断状态到flags中，关闭中断，并对自旋锁加锁
-    /// @return 加锁成功->true
-    ///         加锁失败->false
-    #[inline(always)]
-    pub fn try_lock_irqsave(&self, flags: &mut usize) -> bool {
-        *flags = local_irq_save();
-        if self.try_lock() {
-            return true;
-        }
-        local_irq_restore(*flags);
-        return false;
-    }
-}
 /// 实现了守卫的SpinLock, 能够支持内部可变性
 ///
 #[derive(Debug)]
 pub struct SpinLock<T> {
-    lock: RawSpinlock,
+    lock: AtomicBool,
     /// 自旋锁保护的数据
     data: UnsafeCell<T>,
 }
@@ -174,7 +26,8 @@ pub struct SpinLock<T> {
 #[derive(Debug)]
 pub struct SpinLockGuard<'a, T: 'a> {
     lock: &'a SpinLock<T>,
-    flag: usize,
+    irq_flag: Option<IrqFlagsGuard>,
+    flags: SpinLockGuardFlags,
 }
 
 impl<'a, T: 'a> SpinLockGuard<'a, T> {
@@ -193,6 +46,12 @@ impl<'a, T: 'a> SpinLockGuard<'a, T> {
         // We know statically that only we are referencing data
         unsafe { &mut *this.lock.data.get() }
     }
+
+    fn unlock_no_preempt(&self) {
+        unsafe {
+            self.lock.force_unlock();
+        }
+    }
 }
 
 /// 向编译器保证，SpinLock在线程之间是安全的.
@@ -202,48 +61,89 @@ unsafe impl<T> Sync for SpinLock<T> where T: Send {}
 impl<T> SpinLock<T> {
     pub const fn new(value: T) -> Self {
         return Self {
-            lock: RawSpinlock::INIT,
+            lock: AtomicBool::new(false),
             data: UnsafeCell::new(value),
         };
     }
 
     #[inline(always)]
     pub fn lock(&self) -> SpinLockGuard<T> {
-        self.lock.lock();
-        // 加锁成功，返回一个守卫
-        return SpinLockGuard {
-            lock: self,
-            flag: 0,
-        };
+        loop {
+            let res = self.try_lock();
+            if res.is_ok() {
+                return res.unwrap();
+            }
+            spin_loop();
+        }
+    }
+
+    /// 加锁，但是不更改preempt count
+    #[inline(always)]
+    pub fn lock_no_preempt(&self) -> SpinLockGuard<T> {
+        loop {
+            if let Ok(guard) = self.try_lock_no_preempt() {
+                return guard;
+            }
+            spin_loop();
+        }
     }
 
     pub fn lock_irqsave(&self) -> SpinLockGuard<T> {
-        let mut flags: usize = 0;
-
-        self.lock.lock_irqsave(&mut flags);
-        // 加锁成功，返回一个守卫
-        return SpinLockGuard {
-            lock: self,
-            flag: flags,
-        };
+        loop {
+            if let Ok(guard) = self.try_lock_irqsave() {
+                return guard;
+            }
+            spin_loop();
+        }
     }
 
     pub fn try_lock(&self) -> Result<SpinLockGuard<T>, SystemError> {
-        if self.lock.try_lock() {
+        // 先增加自旋锁持有计数
+        ProcessManager::preempt_disable();
+
+        if self.inner_try_lock() {
             return Ok(SpinLockGuard {
                 lock: self,
-                flag: 0,
+                irq_flag: None,
+                flags: SpinLockGuardFlags::empty(),
             });
         }
+
+        // 如果加锁失败恢复自旋锁持有计数
+        ProcessManager::preempt_enable();
+
         return Err(SystemError::EAGAIN_OR_EWOULDBLOCK);
     }
 
+    fn inner_try_lock(&self) -> bool {
+        let res = self
+            .lock
+            .compare_exchange(false, true, Ordering::Acquire, Ordering::Relaxed)
+            .is_ok();
+        return res;
+    }
+
     pub fn try_lock_irqsave(&self) -> Result<SpinLockGuard<T>, SystemError> {
-        let mut flags: usize = 0;
-        if self.lock.try_lock_irqsave(&mut flags) {
+        let irq_guard = unsafe { CurrentIrqArch::save_and_disable_irq() };
+        ProcessManager::preempt_disable();
+        if self.inner_try_lock() {
             return Ok(SpinLockGuard {
                 lock: self,
-                flag: flags,
+                irq_flag: Some(irq_guard),
+                flags: SpinLockGuardFlags::empty(),
+            });
+        }
+        ProcessManager::preempt_enable();
+        drop(irq_guard);
+        return Err(SystemError::EAGAIN_OR_EWOULDBLOCK);
+    }
+
+    pub fn try_lock_no_preempt(&self) -> Result<SpinLockGuard<T>, SystemError> {
+        if self.inner_try_lock() {
+            return Ok(SpinLockGuard {
+                lock: self,
+                irq_flag: None,
+                flags: SpinLockGuardFlags::NO_PREEMPT,
             });
         }
         return Err(SystemError::EAGAIN_OR_EWOULDBLOCK);
@@ -256,7 +156,12 @@ impl<T> SpinLock<T> {
     /// 由于这样做可能导致preempt count不正确，因此必须小心的手动维护好preempt count。
     /// 如非必要，请不要使用这个函数。
     pub unsafe fn force_unlock(&self) {
-        self.lock.unlock_no_preempt();
+        self.lock.store(false, Ordering::Release);
+    }
+
+    fn unlock(&self) {
+        self.lock.store(false, Ordering::Release);
+        ProcessManager::preempt_enable();
     }
 }
 
@@ -279,10 +184,19 @@ impl<T> DerefMut for SpinLockGuard<'_, T> {
 /// @brief 为SpinLockGuard实现Drop方法，那么，一旦守卫的生命周期结束，就会自动释放自旋锁，避免了忘记放锁的情况
 impl<T> Drop for SpinLockGuard<'_, T> {
     fn drop(&mut self) {
-        if self.flag != 0 {
-            self.lock.lock.unlock_irqrestore(self.flag);
+        if self.flags.contains(SpinLockGuardFlags::NO_PREEMPT) {
+            self.unlock_no_preempt();
         } else {
-            self.lock.lock.unlock();
+            self.lock.unlock();
         }
+        // restore irq
+        self.irq_flag.take();
+    }
+}
+
+bitflags! {
+    struct SpinLockGuardFlags: u8 {
+        /// 守卫是由“*no_preempt”方法获得的
+        const NO_PREEMPT = (1<<0);
     }
 }