进程管理模块重构完成 (#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>
This commit is contained in:
LoGin
2023-09-15 14:58:19 +08:00
committed by GitHub
parent b087521e07
commit 1496ba7b24
153 changed files with 4895 additions and 8190 deletions

View File

@ -1,65 +1,332 @@
use core::{
ptr::null_mut,
ffi::{c_uint, c_void},
mem::MaybeUninit,
sync::atomic::{AtomicBool, Ordering},
};
use alloc::sync::Arc;
use alloc::{boxed::Box, sync::Arc};
use crate::{
exception::softirq::{softirq_vectors, SoftirqNumber, SoftirqVec},
include::bindings::bindings::video_refresh_framebuffer,
arch::MMArch,
driver::uart::uart_device::c_uart_send_str,
driver::uart::uart_device::UartPort::COM1,
include::bindings::bindings::{
multiboot2_get_Framebuffer_info, multiboot2_iter, multiboot_tag_framebuffer_info_t,
FRAME_BUFFER_MAPPING_OFFSET, SPECIAL_MEMOEY_MAPPING_VIRT_ADDR_BASE,
},
kinfo,
libs::{
align::page_align_up,
lib_ui::screen_manager::{ScmBuffer, ScmBufferFlag, ScmBufferInfo},
rwlock::{RwLock, RwLockReadGuard},
spinlock::SpinLock,
},
mm::{
allocator::page_frame::PageFrameCount, kernel_mapper::KernelMapper,
no_init::pseudo_map_phys, page::PageFlags, MemoryManagementArch, PhysAddr, VirtAddr,
},
syscall::SystemError,
time::timer::{Timer, TimerFunction},
};
#[derive(Debug)]
pub struct VideoRefreshFramebuffer {
static mut __MAMAGER: Option<VideoRefreshManager> = None;
pub fn video_refresh_manager() -> &'static VideoRefreshManager {
return unsafe {
&__MAMAGER
.as_ref()
.expect("Video refresh manager has not been initialized yet!")
};
}
///管理显示刷新变量的结构体
pub struct VideoRefreshManager {
device_buffer: RwLock<ScmBufferInfo>,
fb_info: multiboot_tag_framebuffer_info_t,
refresh_target: RwLock<Option<Arc<SpinLock<Box<[u32]>>>>>,
running: AtomicBool,
}
impl SoftirqVec for VideoRefreshFramebuffer {
fn run(&self) {
if self.set_run() == false {
return;
}
const REFRESH_INTERVAL: u64 = 30;
unsafe {
video_refresh_framebuffer(null_mut());
}
impl VideoRefreshManager {
/**
* @brief 启动定时刷新
* @return 启动成功: true, 失败: false
*/
pub fn run_video_refresh(&self) -> bool {
//设置Manager运行标志
let res = self.set_run();
self.clear_run();
//设置成功则开始任务否则直接返回false
if res {
//第一次将expire_jiffies设置小一点使得这次刷新尽快开始后续的刷新将按照REFRESH_INTERVAL间隔进行
let timer = Timer::new(VideoRefreshExecutor::new(), 1);
//将新一次定时任务加入队列
timer.activate();
}
return res;
}
}
impl VideoRefreshFramebuffer {
pub fn new() -> VideoRefreshFramebuffer {
VideoRefreshFramebuffer {
running: AtomicBool::new(false),
}
/// 停止定时刷新
#[allow(dead_code)]
pub fn stop_video_refresh(&self) {
self.running.store(false, Ordering::SeqCst);
}
fn set_run(&self) -> bool {
let x = self
let res = self
.running
.compare_exchange(false, true, Ordering::Acquire, Ordering::Relaxed);
if x.is_ok() {
.compare_exchange(false, true, Ordering::SeqCst, Ordering::SeqCst);
if res.is_ok() {
return true;
} else {
return false;
}
}
fn clear_run(&self) {
self.running.store(false, Ordering::Release);
/**
* @brief VBE帧缓存区的地址重新映射
* 将帧缓存区映射到地址SPECIAL_MEMOEY_MAPPING_VIRT_ADDR_BASE处
*/
fn init_frame_buffer(&self) {
kinfo!("Re-mapping VBE frame buffer...");
let buf_vaddr = VirtAddr::new(
SPECIAL_MEMOEY_MAPPING_VIRT_ADDR_BASE as usize + FRAME_BUFFER_MAPPING_OFFSET as usize,
);
let mut frame_buffer_info_graud = self.device_buffer.write();
if let ScmBuffer::DeviceBuffer(vaddr) = &mut (frame_buffer_info_graud).buf {
*vaddr = buf_vaddr;
}
// 地址映射
let mut paddr = PhysAddr::new(self.fb_info.framebuffer_addr as usize);
let count = PageFrameCount::new(
page_align_up(frame_buffer_info_graud.buf_size()) / MMArch::PAGE_SIZE,
);
let page_flags: PageFlags<MMArch> = PageFlags::new().set_execute(true).set_write(true);
let mut kernel_mapper = KernelMapper::lock();
let mut kernel_mapper = kernel_mapper.as_mut();
assert!(kernel_mapper.is_some());
let mut vaddr = buf_vaddr;
unsafe {
for _ in 0..count.data() {
let flusher = kernel_mapper
.as_mut()
.unwrap()
.map_phys(vaddr, paddr, page_flags)
.unwrap();
flusher.flush();
vaddr += MMArch::PAGE_SIZE;
paddr += MMArch::PAGE_SIZE;
}
}
kinfo!("VBE frame buffer successfully Re-mapped!");
}
/**
* @brief 初始化显示模块,需先低级初始化才能高级初始化
* @param level 初始化等级
* false -> 低级初始化不使用double buffer
* true ->高级初始化增加double buffer的支持
* @return int
*/
pub fn video_reinitialize(&self, level: bool) -> Result<(), SystemError> {
if !level {
self.init_frame_buffer();
} else {
// 开启屏幕计时刷新
assert!(self.run_video_refresh());
}
return Ok(());
}
/**
* @brief 设置帧缓冲区刷新目标
*
* @param buf
* @return int
*/
pub fn set_refresh_target(&self, buf_info: &ScmBufferInfo) -> Result<(), SystemError> {
let mut refresh_target = self.refresh_target.write_irqsave();
if let ScmBuffer::DoubleBuffer(double_buffer) = &buf_info.buf {
*refresh_target = Some(double_buffer.clone());
return Ok(());
}
return Err(SystemError::EINVAL);
}
#[allow(dead_code)]
pub fn refresh_target(&self) -> RwLockReadGuard<'_, Option<Arc<SpinLock<Box<[u32]>>>>> {
let x = self.refresh_target.read();
return x;
}
pub fn device_buffer(&self) -> RwLockReadGuard<'_, ScmBufferInfo> {
return self.device_buffer.read();
}
/**
* @brief 初始化显示驱动
*
* @return int
*/
pub unsafe fn video_init() -> Result<(), SystemError> {
static INIT: AtomicBool = AtomicBool::new(false);
if INIT
.compare_exchange(false, true, Ordering::SeqCst, Ordering::SeqCst)
.is_err()
{
panic!("Try to init video twice!");
}
let mut _reserved: u32 = 0;
let mut fb_info: MaybeUninit<multiboot_tag_framebuffer_info_t> = MaybeUninit::uninit();
//从multiboot2中读取帧缓冲区信息至fb_info
multiboot2_iter(
Some(multiboot2_get_Framebuffer_info),
fb_info.as_mut_ptr() as usize as *mut c_void,
&mut _reserved as *mut c_uint,
);
fb_info.assume_init();
let fb_info: multiboot_tag_framebuffer_info_t = core::mem::transmute(fb_info);
let width = fb_info.framebuffer_width;
let height = fb_info.framebuffer_height;
//初始化帧缓冲区信息结构体
let (bit_depth, flags) = if fb_info.framebuffer_type == 2 {
//当type=2时,width与height用字符数表示,故depth=8
(8u32, ScmBufferFlag::SCM_BF_TEXT | ScmBufferFlag::SCM_BF_FB)
} else {
//否则为图像模式,depth应参照帧缓冲区信息里面的每个像素的位数
(
fb_info.framebuffer_bpp as u32,
ScmBufferFlag::SCM_BF_PIXEL | ScmBufferFlag::SCM_BF_FB,
)
};
let buf_vaddr = VirtAddr::new(0xffff800003200000);
let device_buffer = ScmBufferInfo::new_device_buffer(
width,
height,
width * height * ((bit_depth + 7) / 8),
bit_depth,
flags,
buf_vaddr,
)
.unwrap();
let init_text = "Video driver to map.\n\0";
c_uart_send_str(COM1 as u16, init_text.as_ptr());
//地址映射
let paddr = PhysAddr::new(fb_info.framebuffer_addr as usize);
let count = PageFrameCount::new(
page_align_up(device_buffer.buf_size() as usize) / MMArch::PAGE_SIZE,
);
pseudo_map_phys(buf_vaddr, paddr, count);
let result = Self {
fb_info,
device_buffer: RwLock::new(device_buffer),
refresh_target: RwLock::new(None),
running: AtomicBool::new(false),
};
__MAMAGER = Some(result);
let init_text = "Video driver initialized.\n\0";
c_uart_send_str(COM1 as u16, init_text.as_ptr());
return Ok(());
}
}
pub fn register_softirq_video() {
// kdebug!("register_softirq_video");
let handler = Arc::new(VideoRefreshFramebuffer::new());
softirq_vectors()
.register_softirq(SoftirqNumber::VideoRefresh, handler)
.expect("register_softirq_video run failed");
//刷新任务执行器
#[derive(Debug)]
struct VideoRefreshExecutor;
impl VideoRefreshExecutor {
fn new() -> Box<VideoRefreshExecutor> {
return Box::new(VideoRefreshExecutor);
}
}
// ======= 以下为给C提供的接口,video重构完后请删除 =======
impl TimerFunction for VideoRefreshExecutor {
/**
* @brief 交给定时器执行的任务,此方法不应手动调用
* @return Ok(())
*/
fn run(&mut self) -> Result<(), SystemError> {
// 获得Manager
let manager = video_refresh_manager();
let start_next_refresh = || {
//判断是否还需要刷新,若需要则继续分配下一次计时任务,否则不分配
if manager.running.load(Ordering::SeqCst) {
let timer = Timer::new(VideoRefreshExecutor::new(), REFRESH_INTERVAL);
//将新一次定时任务加入队列
timer.activate();
}
};
let mut refresh_target: Option<RwLockReadGuard<'_, Option<Arc<SpinLock<Box<[u32]>>>>>> =
None;
const TRY_TIMES: i32 = 2;
for i in 0..TRY_TIMES {
let g = manager.refresh_target.try_read();
if g.is_none() {
if i == TRY_TIMES - 1 {
start_next_refresh();
return Ok(());
}
continue;
}
refresh_target = Some(g.unwrap());
break;
}
let refresh_target = refresh_target.unwrap();
if let ScmBuffer::DeviceBuffer(vaddr) = manager.device_buffer().buf {
let p = vaddr.as_ptr() as *mut u8;
let mut target_guard = None;
for _ in 0..2 {
if let Ok(guard) = refresh_target.as_ref().unwrap().try_lock_irqsave() {
target_guard = Some(guard);
break;
}
}
if target_guard.is_none() {
start_next_refresh();
return Ok(());
}
let mut target_guard = target_guard.unwrap();
unsafe {
p.copy_from_nonoverlapping(
target_guard.as_mut_ptr() as *mut u8,
manager.device_buffer().buf_size() as usize,
)
}
}
start_next_refresh();
return Ok(());
}
}
#[no_mangle]
pub extern "C" fn rs_register_softirq_video() {
register_softirq_video();
pub unsafe extern "C" fn rs_video_init() -> i32 {
return VideoRefreshManager::video_init()
.map(|_| 0)
.unwrap_or_else(|e| e.to_posix_errno());
}