1 use core::{
2 fmt,
3 hash::Hash,
4 hint::spin_loop,
5 intrinsics::{likely, unlikely},
6 mem::ManuallyDrop,
7 sync::atomic::{compiler_fence, fence, AtomicBool, AtomicUsize, Ordering},
8 };
9
10 use alloc::{
11 ffi::CString,
12 string::{String, ToString},
13 sync::{Arc, Weak},
14 vec::Vec,
15 };
16 use cred::INIT_CRED;
17 use hashbrown::HashMap;
18 use log::{debug, error, info, warn};
19 use system_error::SystemError;
20
21 use crate::{
22 arch::{
23 cpu::current_cpu_id,
24 ipc::signal::{AtomicSignal, SigSet, Signal},
25 process::ArchPCBInfo,
26 CurrentIrqArch,
27 },
28 driver::tty::tty_core::TtyCore,
29 exception::InterruptArch,
30 filesystem::{
31 procfs::procfs_unregister_pid,
32 vfs::{file::FileDescriptorVec, FileType},
33 },
34 ipc::signal_types::{SigInfo, SigPending, SignalStruct},
35 libs::{
36 align::AlignedBox,
37 casting::DowncastArc,
38 futex::{
39 constant::{FutexFlag, FUTEX_BITSET_MATCH_ANY},
40 futex::{Futex, RobustListHead},
41 },
42 lock_free_flags::LockFreeFlags,
43 rwlock::{RwLock, RwLockReadGuard, RwLockWriteGuard},
44 spinlock::{SpinLock, SpinLockGuard},
45 wait_queue::WaitQueue,
46 },
47 mm::{
48 percpu::{PerCpu, PerCpuVar},
49 set_IDLE_PROCESS_ADDRESS_SPACE,
50 ucontext::AddressSpace,
51 VirtAddr,
52 },
53 namespaces::{mnt_namespace::FsStruct, pid_namespace::PidStrcut, NsProxy},
54 net::socket::SocketInode,
55 sched::{
56 completion::Completion, cpu_rq, fair::FairSchedEntity, prio::MAX_PRIO, DequeueFlag,
57 EnqueueFlag, OnRq, SchedMode, WakeupFlags, __schedule,
58 },
59 smp::{
60 core::smp_get_processor_id,
61 cpu::{AtomicProcessorId, ProcessorId},
62 kick_cpu,
63 },
64 syscall::{user_access::clear_user, Syscall},
65 };
66 use timer::AlarmTimer;
67
68 use self::{cred::Cred, kthread::WorkerPrivate};
69
70 pub mod abi;
71 pub mod c_adapter;
72 pub mod cred;
73 pub mod exec;
74 pub mod exit;
75 pub mod fork;
76 pub mod idle;
77 pub mod kthread;
78 pub mod pid;
79 pub mod resource;
80 pub mod stdio;
81 pub mod syscall;
82 pub mod timer;
83 pub mod utils;
84
85 /// 系统中所有进程的pcb
86 static ALL_PROCESS: SpinLock<Option<HashMap<Pid, Arc<ProcessControlBlock>>>> = SpinLock::new(None);
87
88 pub static mut PROCESS_SWITCH_RESULT: Option<PerCpuVar<SwitchResult>> = None;
89
90 /// 一个只改变1次的全局变量，标志进程管理器是否已经初始化完成
91 static mut __PROCESS_MANAGEMENT_INIT_DONE: bool = false;
92
93 pub struct SwitchResult {
94 pub prev_pcb: Option<Arc<ProcessControlBlock>>,
95 pub next_pcb: Option<Arc<ProcessControlBlock>>,
96 }
97
98 impl SwitchResult {
new() -> Self99 pub fn new() -> Self {
100 Self {
101 prev_pcb: None,
102 next_pcb: None,
103 }
104 }
105 }
106
107 #[derive(Debug)]
108 pub struct ProcessManager;
109 impl ProcessManager {
110 #[inline(never)]
init()111 fn init() {
112 static INIT_FLAG: AtomicBool = AtomicBool::new(false);
113 if INIT_FLAG
114 .compare_exchange(false, true, Ordering::SeqCst, Ordering::SeqCst)
115 .is_err()
116 {
117 panic!("ProcessManager has been initialized!");
118 }
119
120 unsafe {
121 compiler_fence(Ordering::SeqCst);
122 debug!("To create address space for INIT process.");
123 // test_buddy();
124 set_IDLE_PROCESS_ADDRESS_SPACE(
125 AddressSpace::new(true).expect("Failed to create address space for INIT process."),
126 );
127 debug!("INIT process address space created.");
128 compiler_fence(Ordering::SeqCst);
129 };
130
131 ALL_PROCESS.lock_irqsave().replace(HashMap::new());
132 Self::init_switch_result();
133 Self::arch_init();
134 debug!("process arch init done.");
135 Self::init_idle();
136 debug!("process idle init done.");
137
138 unsafe { __PROCESS_MANAGEMENT_INIT_DONE = true };
139 info!("Process Manager initialized.");
140 }
141
init_switch_result()142 fn init_switch_result() {
143 let mut switch_res_vec: Vec<SwitchResult> = Vec::new();
144 for _ in 0..PerCpu::MAX_CPU_NUM {
145 switch_res_vec.push(SwitchResult::new());
146 }
147 unsafe {
148 PROCESS_SWITCH_RESULT = Some(PerCpuVar::new(switch_res_vec).unwrap());
149 }
150 }
151
152 /// 判断进程管理器是否已经初始化完成
153 #[allow(dead_code)]
initialized() -> bool154 pub fn initialized() -> bool {
155 unsafe { __PROCESS_MANAGEMENT_INIT_DONE }
156 }
157
158 /// 获取当前进程的pcb
current_pcb() -> Arc<ProcessControlBlock>159 pub fn current_pcb() -> Arc<ProcessControlBlock> {
160 if unlikely(unsafe { !__PROCESS_MANAGEMENT_INIT_DONE }) {
161 error!("unsafe__PROCESS_MANAGEMENT_INIT_DONE == false");
162 loop {
163 spin_loop();
164 }
165 }
166 return ProcessControlBlock::arch_current_pcb();
167 }
168
169 /// 获取当前进程的pid
170 ///
171 /// 如果进程管理器未初始化完成，那么返回0
current_pid() -> Pid172 pub fn current_pid() -> Pid {
173 if unlikely(unsafe { !__PROCESS_MANAGEMENT_INIT_DONE }) {
174 return Pid(0);
175 }
176
177 return ProcessManager::current_pcb().pid();
178 }
179
180 /// 增加当前进程的锁持有计数
181 #[inline(always)]
preempt_disable()182 pub fn preempt_disable() {
183 if likely(unsafe { __PROCESS_MANAGEMENT_INIT_DONE }) {
184 ProcessManager::current_pcb().preempt_disable();
185 }
186 }
187
188 /// 减少当前进程的锁持有计数
189 #[inline(always)]
preempt_enable()190 pub fn preempt_enable() {
191 if likely(unsafe { __PROCESS_MANAGEMENT_INIT_DONE }) {
192 ProcessManager::current_pcb().preempt_enable();
193 }
194 }
195
196 /// 根据pid获取进程的pcb
197 ///
198 /// ## 参数
199 ///
200 /// - `pid` : 进程的pid
201 ///
202 /// ## 返回值
203 ///
204 /// 如果找到了对应的进程，那么返回该进程的pcb，否则返回None
find(pid: Pid) -> Option<Arc<ProcessControlBlock>>205 pub fn find(pid: Pid) -> Option<Arc<ProcessControlBlock>> {
206 return ALL_PROCESS.lock_irqsave().as_ref()?.get(&pid).cloned();
207 }
208
209 /// 向系统中添加一个进程的pcb
210 ///
211 /// ## 参数
212 ///
213 /// - `pcb` : 进程的pcb
214 ///
215 /// ## 返回值
216 ///
217 /// 无
add_pcb(pcb: Arc<ProcessControlBlock>)218 pub fn add_pcb(pcb: Arc<ProcessControlBlock>) {
219 ALL_PROCESS
220 .lock_irqsave()
221 .as_mut()
222 .unwrap()
223 .insert(pcb.pid(), pcb.clone());
224 }
225
226 /// 唤醒一个进程
wakeup(pcb: &Arc<ProcessControlBlock>) -> Result<(), SystemError>227 pub fn wakeup(pcb: &Arc<ProcessControlBlock>) -> Result<(), SystemError> {
228 let _guard = unsafe { CurrentIrqArch::save_and_disable_irq() };
229 let state = pcb.sched_info().inner_lock_read_irqsave().state();
230 if state.is_blocked() {
231 let mut writer = pcb.sched_info().inner_lock_write_irqsave();
232 let state = writer.state();
233 if state.is_blocked() {
234 writer.set_state(ProcessState::Runnable);
235 writer.set_wakeup();
236
237 // avoid deadlock
238 drop(writer);
239
240 let rq =
241 cpu_rq(pcb.sched_info().on_cpu().unwrap_or(current_cpu_id()).data() as usize);
242
243 let (rq, _guard) = rq.self_lock();
244 rq.update_rq_clock();
245 rq.activate_task(
246 pcb,
247 EnqueueFlag::ENQUEUE_WAKEUP | EnqueueFlag::ENQUEUE_NOCLOCK,
248 );
249
250 rq.check_preempt_currnet(pcb, WakeupFlags::empty());
251
252 // sched_enqueue(pcb.clone(), true);
253 return Ok(());
254 } else if state.is_exited() {
255 return Err(SystemError::EINVAL);
256 } else {
257 return Ok(());
258 }
259 } else if state.is_exited() {
260 return Err(SystemError::EINVAL);
261 } else {
262 return Ok(());
263 }
264 }
265
266 /// 唤醒暂停的进程
wakeup_stop(pcb: &Arc<ProcessControlBlock>) -> Result<(), SystemError>267 pub fn wakeup_stop(pcb: &Arc<ProcessControlBlock>) -> Result<(), SystemError> {
268 let _guard = unsafe { CurrentIrqArch::save_and_disable_irq() };
269 let state = pcb.sched_info().inner_lock_read_irqsave().state();
270 if let ProcessState::Stopped = state {
271 let mut writer = pcb.sched_info().inner_lock_write_irqsave();
272 let state = writer.state();
273 if let ProcessState::Stopped = state {
274 writer.set_state(ProcessState::Runnable);
275 // avoid deadlock
276 drop(writer);
277
278 let rq = cpu_rq(pcb.sched_info().on_cpu().unwrap().data() as usize);
279
280 let (rq, _guard) = rq.self_lock();
281 rq.update_rq_clock();
282 rq.activate_task(
283 pcb,
284 EnqueueFlag::ENQUEUE_WAKEUP | EnqueueFlag::ENQUEUE_NOCLOCK,
285 );
286
287 rq.check_preempt_currnet(pcb, WakeupFlags::empty());
288
289 // sched_enqueue(pcb.clone(), true);
290 return Ok(());
291 } else if state.is_runnable() {
292 return Ok(());
293 } else {
294 return Err(SystemError::EINVAL);
295 }
296 } else if state.is_runnable() {
297 return Ok(());
298 } else {
299 return Err(SystemError::EINVAL);
300 }
301 }
302
303 /// 标志当前进程永久睡眠，但是发起调度的工作，应该由调用者完成
304 ///
305 /// ## 注意
306 ///
307 /// - 进入当前函数之前，不能持有sched_info的锁
308 /// - 进入当前函数之前，必须关闭中断
309 /// - 进入当前函数之后必须保证逻辑的正确性，避免被重复加入调度队列
mark_sleep(interruptable: bool) -> Result<(), SystemError>310 pub fn mark_sleep(interruptable: bool) -> Result<(), SystemError> {
311 assert!(
312 !CurrentIrqArch::is_irq_enabled(),
313 "interrupt must be disabled before enter ProcessManager::mark_sleep()"
314 );
315 let pcb = ProcessManager::current_pcb();
316 let mut writer = pcb.sched_info().inner_lock_write_irqsave();
317 if !matches!(writer.state(), ProcessState::Exited(_)) {
318 writer.set_state(ProcessState::Blocked(interruptable));
319 writer.set_sleep();
320 pcb.flags().insert(ProcessFlags::NEED_SCHEDULE);
321 fence(Ordering::SeqCst);
322 drop(writer);
323 return Ok(());
324 }
325 return Err(SystemError::EINTR);
326 }
327
328 /// 标志当前进程为停止状态，但是发起调度的工作，应该由调用者完成
329 ///
330 /// ## 注意
331 ///
332 /// - 进入当前函数之前，不能持有sched_info的锁
333 /// - 进入当前函数之前，必须关闭中断
mark_stop() -> Result<(), SystemError>334 pub fn mark_stop() -> Result<(), SystemError> {
335 assert!(
336 !CurrentIrqArch::is_irq_enabled(),
337 "interrupt must be disabled before enter ProcessManager::mark_stop()"
338 );
339
340 let pcb = ProcessManager::current_pcb();
341 let mut writer = pcb.sched_info().inner_lock_write_irqsave();
342 if !matches!(writer.state(), ProcessState::Exited(_)) {
343 writer.set_state(ProcessState::Stopped);
344 pcb.flags().insert(ProcessFlags::NEED_SCHEDULE);
345 drop(writer);
346
347 return Ok(());
348 }
349 return Err(SystemError::EINTR);
350 }
351 /// 当子进程退出后向父进程发送通知
exit_notify()352 fn exit_notify() {
353 let current = ProcessManager::current_pcb();
354 // 让INIT进程收养所有子进程
355 if current.pid() != Pid(1) {
356 unsafe {
357 current
358 .adopt_childen()
359 .unwrap_or_else(|e| panic!("adopte_childen failed: error: {e:?}"))
360 };
361 let r = current.parent_pcb.read_irqsave().upgrade();
362 if r.is_none() {
363 return;
364 }
365 let parent_pcb = r.unwrap();
366 let r = Syscall::kill(parent_pcb.pid(), Signal::SIGCHLD as i32);
367 if r.is_err() {
368 warn!(
369 "failed to send kill signal to {:?}'s parent pcb {:?}",
370 current.pid(),
371 parent_pcb.pid()
372 );
373 }
374 // todo: 这里需要向父进程发送SIGCHLD信号
375 // todo: 这里还需要根据线程组的信息，决定信号的发送
376 }
377 }
378
379 /// 退出当前进程
380 ///
381 /// ## 参数
382 ///
383 /// - `exit_code` : 进程的退出码
exit(exit_code: usize) -> !384 pub fn exit(exit_code: usize) -> ! {
385 // 关中断
386 let _guard = unsafe { CurrentIrqArch::save_and_disable_irq() };
387 let pcb = ProcessManager::current_pcb();
388 let pid = pcb.pid();
389 pcb.sched_info
390 .inner_lock_write_irqsave()
391 .set_state(ProcessState::Exited(exit_code));
392 pcb.wait_queue.wakeup(Some(ProcessState::Blocked(true)));
393
394 let rq = cpu_rq(smp_get_processor_id().data() as usize);
395 let (rq, guard) = rq.self_lock();
396 rq.deactivate_task(
397 pcb.clone(),
398 DequeueFlag::DEQUEUE_SLEEP | DequeueFlag::DEQUEUE_NOCLOCK,
399 );
400 drop(guard);
401
402 // 进行进程退出后的工作
403 let thread = pcb.thread.write_irqsave();
404 if let Some(addr) = thread.set_child_tid {
405 unsafe { clear_user(addr, core::mem::size_of::<i32>()).expect("clear tid failed") };
406 }
407
408 if let Some(addr) = thread.clear_child_tid {
409 if Arc::strong_count(&pcb.basic().user_vm().expect("User VM Not found")) > 1 {
410 let _ =
411 Futex::futex_wake(addr, FutexFlag::FLAGS_MATCH_NONE, 1, FUTEX_BITSET_MATCH_ANY);
412 }
413 unsafe { clear_user(addr, core::mem::size_of::<i32>()).expect("clear tid failed") };
414 }
415
416 RobustListHead::exit_robust_list(pcb.clone());
417
418 // 如果是vfork出来的进程，则需要处理completion
419 if thread.vfork_done.is_some() {
420 thread.vfork_done.as_ref().unwrap().complete_all();
421 }
422 drop(thread);
423 unsafe { pcb.basic_mut().set_user_vm(None) };
424
425 // TODO 由于未实现进程组，tty记录的前台进程组等于当前进程，故退出前要置空
426 // 后续相关逻辑需要在SYS_EXIT_GROUP系统调用中实现
427 if let Some(tty) = pcb.sig_info_irqsave().tty() {
428 tty.core().contorl_info_irqsave().pgid = None;
429 }
430 pcb.sig_info_mut().set_tty(None);
431
432 drop(pcb);
433 ProcessManager::exit_notify();
434 // unsafe { CurrentIrqArch::interrupt_enable() };
435 __schedule(SchedMode::SM_NONE);
436 error!("pid {pid:?} exited but sched again!");
437 #[allow(clippy::empty_loop)]
438 loop {
439 spin_loop();
440 }
441 }
442
release(pid: Pid)443 pub unsafe fn release(pid: Pid) {
444 let pcb = ProcessManager::find(pid);
445 if pcb.is_some() {
446 // let pcb = pcb.unwrap();
447 // 判断该pcb是否在全局没有任何引用
448 // TODO: 当前，pcb的Arc指针存在泄露问题，引用计数不正确，打算在接下来实现debug专用的Arc，方便调试，然后解决这个bug。
449 // 因此目前暂时注释掉，使得能跑
450 // if Arc::strong_count(&pcb) <= 2 {
451 // drop(pcb);
452 // ALL_PROCESS.lock().as_mut().unwrap().remove(&pid);
453 // } else {
454 // // 如果不为1就panic
455 // let msg = format!("pcb '{:?}' is still referenced, strong count={}",pcb.pid(), Arc::strong_count(&pcb));
456 // error!("{}", msg);
457 // panic!()
458 // }
459
460 ALL_PROCESS.lock_irqsave().as_mut().unwrap().remove(&pid);
461 }
462 }
463
464 /// 上下文切换完成后的钩子函数
switch_finish_hook()465 unsafe fn switch_finish_hook() {
466 // debug!("switch_finish_hook");
467 let prev_pcb = PROCESS_SWITCH_RESULT
468 .as_mut()
469 .unwrap()
470 .get_mut()
471 .prev_pcb
472 .take()
473 .expect("prev_pcb is None");
474 let next_pcb = PROCESS_SWITCH_RESULT
475 .as_mut()
476 .unwrap()
477 .get_mut()
478 .next_pcb
479 .take()
480 .expect("next_pcb is None");
481
482 // 由于进程切换前使用了SpinLockGuard::leak()，所以这里需要手动释放锁
483 fence(Ordering::SeqCst);
484
485 prev_pcb.arch_info.force_unlock();
486 fence(Ordering::SeqCst);
487
488 next_pcb.arch_info.force_unlock();
489 fence(Ordering::SeqCst);
490 }
491
492 /// 如果目标进程正在目标CPU上运行，那么就让这个cpu陷入内核态
493 ///
494 /// ## 参数
495 ///
496 /// - `pcb` : 进程的pcb
497 #[allow(dead_code)]
kick(pcb: &Arc<ProcessControlBlock>)498 pub fn kick(pcb: &Arc<ProcessControlBlock>) {
499 ProcessManager::current_pcb().preempt_disable();
500 let cpu_id = pcb.sched_info().on_cpu();
501
502 if let Some(cpu_id) = cpu_id {
503 if pcb.pid() == cpu_rq(cpu_id.data() as usize).current().pid() {
504 kick_cpu(cpu_id).expect("ProcessManager::kick(): Failed to kick cpu");
505 }
506 }
507
508 ProcessManager::current_pcb().preempt_enable();
509 }
510 }
511
512 /// 上下文切换的钩子函数,当这个函数return的时候,将会发生上下文切换
513 #[cfg(target_arch = "x86_64")]
514 #[inline(never)]
switch_finish_hook()515 pub unsafe extern "sysv64" fn switch_finish_hook() {
516 ProcessManager::switch_finish_hook();
517 }
518 #[cfg(target_arch = "riscv64")]
519 #[inline(always)]
switch_finish_hook()520 pub unsafe fn switch_finish_hook() {
521 ProcessManager::switch_finish_hook();
522 }
523
524 int_like!(Pid, AtomicPid, usize, AtomicUsize);
525
526 impl fmt::Display for Pid {
fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result527 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
528 write!(f, "{}", self.0)
529 }
530 }
531
532 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
533 pub enum ProcessState {
534 /// The process is running on a CPU or in a run queue.
535 Runnable,
536 /// The process is waiting for an event to occur.
537 /// 其中的bool表示该等待过程是否可以被打断。
538 /// - 如果该bool为true,那么，硬件中断/信号/其他系统事件都可以打断该等待过程，使得该进程重新进入Runnable状态。
539 /// - 如果该bool为false,那么，这个进程必须被显式的唤醒，才能重新进入Runnable状态。
540 Blocked(bool),
541 /// 进程被信号终止
542 Stopped,
543 /// 进程已经退出，usize表示进程的退出码
544 Exited(usize),
545 }
546
547 #[allow(dead_code)]
548 impl ProcessState {
549 #[inline(always)]
is_runnable(&self) -> bool550 pub fn is_runnable(&self) -> bool {
551 return matches!(self, ProcessState::Runnable);
552 }
553
554 #[inline(always)]
is_blocked(&self) -> bool555 pub fn is_blocked(&self) -> bool {
556 return matches!(self, ProcessState::Blocked(_));
557 }
558
559 #[inline(always)]
is_blocked_interruptable(&self) -> bool560 pub fn is_blocked_interruptable(&self) -> bool {
561 return matches!(self, ProcessState::Blocked(true));
562 }
563
564 /// Returns `true` if the process state is [`Exited`].
565 #[inline(always)]
is_exited(&self) -> bool566 pub fn is_exited(&self) -> bool {
567 return matches!(self, ProcessState::Exited(_));
568 }
569
570 /// Returns `true` if the process state is [`Stopped`].
571 ///
572 /// [`Stopped`]: ProcessState::Stopped
573 #[inline(always)]
is_stopped(&self) -> bool574 pub fn is_stopped(&self) -> bool {
575 matches!(self, ProcessState::Stopped)
576 }
577
578 /// Returns exit code if the process state is [`Exited`].
579 #[inline(always)]
exit_code(&self) -> Option<usize>580 pub fn exit_code(&self) -> Option<usize> {
581 match self {
582 ProcessState::Exited(code) => Some(*code),
583 _ => None,
584 }
585 }
586 }
587
588 bitflags! {
589 /// pcb的标志位
590 pub struct ProcessFlags: usize {
591 /// 当前pcb表示一个内核线程
592 const KTHREAD = 1 << 0;
593 /// 当前进程需要被调度
594 const NEED_SCHEDULE = 1 << 1;
595 /// 进程由于vfork而与父进程存在资源共享
596 const VFORK = 1 << 2;
597 /// 进程不可被冻结
598 const NOFREEZE = 1 << 3;
599 /// 进程正在退出
600 const EXITING = 1 << 4;
601 /// 进程由于接收到终止信号唤醒
602 const WAKEKILL = 1 << 5;
603 /// 进程由于接收到信号而退出.(Killed by a signal)
604 const SIGNALED = 1 << 6;
605 /// 进程需要迁移到其他cpu上
606 const NEED_MIGRATE = 1 << 7;
607 /// 随机化的虚拟地址空间，主要用于动态链接器的加载
608 const RANDOMIZE = 1 << 8;
609 }
610 }
611 #[derive(Debug)]
612 pub struct ProcessControlBlock {
613 /// 当前进程的pid
614 pid: Pid,
615 /// 当前进程的线程组id（这个值在同一个线程组内永远不变）
616 tgid: Pid,
617 /// 有关Pid的相关的信息
618 thread_pid: Arc<RwLock<PidStrcut>>,
619 basic: RwLock<ProcessBasicInfo>,
620 /// 当前进程的自旋锁持有计数
621 preempt_count: AtomicUsize,
622
623 flags: LockFreeFlags<ProcessFlags>,
624 worker_private: SpinLock<Option<WorkerPrivate>>,
625 /// 进程的内核栈
626 kernel_stack: RwLock<KernelStack>,
627
628 /// 系统调用栈
629 syscall_stack: RwLock<KernelStack>,
630
631 /// 与调度相关的信息
632 sched_info: ProcessSchedulerInfo,
633 /// 与处理器架构相关的信息
634 arch_info: SpinLock<ArchPCBInfo>,
635 /// 与信号处理相关的信息(似乎可以是无锁的)
636 sig_info: RwLock<ProcessSignalInfo>,
637 /// 信号处理结构体
638 sig_struct: SpinLock<SignalStruct>,
639 /// 退出信号S
640 exit_signal: AtomicSignal,
641
642 /// 父进程指针
643 parent_pcb: RwLock<Weak<ProcessControlBlock>>,
644 /// 真实父进程指针
645 real_parent_pcb: RwLock<Weak<ProcessControlBlock>>,
646
647 /// 子进程链表
648 children: RwLock<Vec<Pid>>,
649
650 /// 等待队列
651 wait_queue: WaitQueue,
652
653 /// 线程信息
654 thread: RwLock<ThreadInfo>,
655
656 /// 进程文件系统的状态
657 fs: Arc<SpinLock<FsStruct>>,
658
659 ///闹钟定时器
660 alarm_timer: SpinLock<Option<AlarmTimer>>,
661
662 /// 进程的robust lock列表
663 robust_list: RwLock<Option<RobustListHead>>,
664
665 /// namespace的指针
666 nsproxy: Arc<RwLock<NsProxy>>,
667
668 /// 进程作为主体的凭证集
669 cred: SpinLock<Cred>,
670 }
671
672 impl ProcessControlBlock {
673 /// Generate a new pcb.
674 ///
675 /// ## 参数
676 ///
677 /// - `name` : 进程的名字
678 /// - `kstack` : 进程的内核栈
679 ///
680 /// ## 返回值
681 ///
682 /// 返回一个新的pcb
new(name: String, kstack: KernelStack) -> Arc<Self>683 pub fn new(name: String, kstack: KernelStack) -> Arc<Self> {
684 return Self::do_create_pcb(name, kstack, false);
685 }
686
687 /// 创建一个新的idle进程
688 ///
689 /// 请注意，这个函数只能在进程管理初始化的时候调用。
new_idle(cpu_id: u32, kstack: KernelStack) -> Arc<Self>690 pub fn new_idle(cpu_id: u32, kstack: KernelStack) -> Arc<Self> {
691 let name = format!("idle-{}", cpu_id);
692 return Self::do_create_pcb(name, kstack, true);
693 }
694
695 /// # 函数的功能
696 ///
697 /// 返回此函数是否是内核进程
698 ///
699 /// # 返回值
700 ///
701 /// 若进程是内核进程则返回true 否则返回false
is_kthread(&self) -> bool702 pub fn is_kthread(&self) -> bool {
703 return matches!(self.flags(), &mut ProcessFlags::KTHREAD);
704 }
705
706 #[inline(never)]
do_create_pcb(name: String, kstack: KernelStack, is_idle: bool) -> Arc<Self>707 fn do_create_pcb(name: String, kstack: KernelStack, is_idle: bool) -> Arc<Self> {
708 let (pid, ppid, cwd, cred, tty) = if is_idle {
709 let cred = INIT_CRED.clone();
710 (Pid(0), Pid(0), "/".to_string(), cred, None)
711 } else {
712 let ppid = ProcessManager::current_pcb().pid();
713 let mut cred = ProcessManager::current_pcb().cred();
714 cred.cap_permitted = cred.cap_ambient;
715 cred.cap_effective = cred.cap_ambient;
716 let cwd = ProcessManager::current_pcb().basic().cwd();
717 let tty = ProcessManager::current_pcb().sig_info_irqsave().tty();
718 (Self::generate_pid(), ppid, cwd, cred, tty)
719 };
720
721 let basic_info = ProcessBasicInfo::new(Pid(0), ppid, Pid(0), name, cwd, None);
722 let preempt_count = AtomicUsize::new(0);
723 let flags = unsafe { LockFreeFlags::new(ProcessFlags::empty()) };
724
725 let sched_info = ProcessSchedulerInfo::new(None);
726 let arch_info = SpinLock::new(ArchPCBInfo::new(&kstack));
727
728 let ppcb: Weak<ProcessControlBlock> = ProcessManager::find(ppid)
729 .map(|p| Arc::downgrade(&p))
730 .unwrap_or_default();
731 let pcb = Self {
732 pid,
733 tgid: pid,
734 thread_pid: Arc::new(RwLock::new(PidStrcut::new())),
735 basic: basic_info,
736 preempt_count,
737 flags,
738 kernel_stack: RwLock::new(kstack),
739 syscall_stack: RwLock::new(KernelStack::new().unwrap()),
740 worker_private: SpinLock::new(None),
741 sched_info,
742 arch_info,
743 sig_info: RwLock::new(ProcessSignalInfo::default()),
744 sig_struct: SpinLock::new(SignalStruct::new()),
745 exit_signal: AtomicSignal::new(Signal::SIGCHLD),
746 parent_pcb: RwLock::new(ppcb.clone()),
747 real_parent_pcb: RwLock::new(ppcb),
748 children: RwLock::new(Vec::new()),
749 wait_queue: WaitQueue::default(),
750 thread: RwLock::new(ThreadInfo::new()),
751 fs: Arc::new(SpinLock::new(FsStruct::new())),
752 alarm_timer: SpinLock::new(None),
753 robust_list: RwLock::new(None),
754 nsproxy: Arc::new(RwLock::new(NsProxy::new())),
755 cred: SpinLock::new(cred),
756 };
757
758 pcb.sig_info.write().set_tty(tty);
759
760 // 初始化系统调用栈
761 #[cfg(target_arch = "x86_64")]
762 pcb.arch_info
763 .lock()
764 .init_syscall_stack(&pcb.syscall_stack.read());
765
766 let pcb = Arc::new(pcb);
767
768 pcb.sched_info()
769 .sched_entity()
770 .force_mut()
771 .set_pcb(Arc::downgrade(&pcb));
772 // 设置进程的arc指针到内核栈和系统调用栈的最低地址处
773 unsafe {
774 pcb.kernel_stack
775 .write()
776 .set_pcb(Arc::downgrade(&pcb))
777 .unwrap();
778
779 pcb.syscall_stack
780 .write()
781 .set_pcb(Arc::downgrade(&pcb))
782 .unwrap()
783 };
784
785 // 将当前pcb加入父进程的子进程哈希表中
786 if pcb.pid() > Pid(1) {
787 if let Some(ppcb_arc) = pcb.parent_pcb.read_irqsave().upgrade() {
788 let mut children = ppcb_arc.children.write_irqsave();
789 children.push(pcb.pid());
790 } else {
791 panic!("parent pcb is None");
792 }
793 }
794
795 return pcb;
796 }
797
798 /// 生成一个新的pid
799 #[inline(always)]
generate_pid() -> Pid800 fn generate_pid() -> Pid {
801 static NEXT_PID: AtomicPid = AtomicPid::new(Pid(1));
802 return NEXT_PID.fetch_add(Pid(1), Ordering::SeqCst);
803 }
804
805 /// 返回当前进程的锁持有计数
806 #[inline(always)]
preempt_count(&self) -> usize807 pub fn preempt_count(&self) -> usize {
808 return self.preempt_count.load(Ordering::SeqCst);
809 }
810
811 /// 增加当前进程的锁持有计数
812 #[inline(always)]
preempt_disable(&self)813 pub fn preempt_disable(&self) {
814 self.preempt_count.fetch_add(1, Ordering::SeqCst);
815 }
816
817 /// 减少当前进程的锁持有计数
818 #[inline(always)]
preempt_enable(&self)819 pub fn preempt_enable(&self) {
820 self.preempt_count.fetch_sub(1, Ordering::SeqCst);
821 }
822
823 #[inline(always)]
set_preempt_count(&self, count: usize)824 pub unsafe fn set_preempt_count(&self, count: usize) {
825 self.preempt_count.store(count, Ordering::SeqCst);
826 }
827
828 #[inline(always)]
flags(&self) -> &mut ProcessFlags829 pub fn flags(&self) -> &mut ProcessFlags {
830 return self.flags.get_mut();
831 }
832
833 /// 请注意，这个值能在中断上下文中读取，但不能被中断上下文修改
834 /// 否则会导致死锁
835 #[inline(always)]
basic(&self) -> RwLockReadGuard<ProcessBasicInfo>836 pub fn basic(&self) -> RwLockReadGuard<ProcessBasicInfo> {
837 return self.basic.read_irqsave();
838 }
839
840 #[inline(always)]
set_name(&self, name: String)841 pub fn set_name(&self, name: String) {
842 self.basic.write().set_name(name);
843 }
844
845 #[inline(always)]
basic_mut(&self) -> RwLockWriteGuard<ProcessBasicInfo>846 pub fn basic_mut(&self) -> RwLockWriteGuard<ProcessBasicInfo> {
847 return self.basic.write_irqsave();
848 }
849
850 /// # 获取arch info的锁，同时关闭中断
851 #[inline(always)]
arch_info_irqsave(&self) -> SpinLockGuard<ArchPCBInfo>852 pub fn arch_info_irqsave(&self) -> SpinLockGuard<ArchPCBInfo> {
853 return self.arch_info.lock_irqsave();
854 }
855
856 /// # 获取arch info的锁，但是不关闭中断
857 ///
858 /// 由于arch info在进程切换的时候会使用到，
859 /// 因此在中断上下文外，获取arch info 而不irqsave是不安全的.
860 ///
861 /// 只能在以下情况下使用这个函数：
862 /// - 在中断上下文中（中断已经禁用），获取arch info的锁。
863 /// - 刚刚创建新的pcb
864 #[inline(always)]
arch_info(&self) -> SpinLockGuard<ArchPCBInfo>865 pub unsafe fn arch_info(&self) -> SpinLockGuard<ArchPCBInfo> {
866 return self.arch_info.lock();
867 }
868
869 #[inline(always)]
kernel_stack(&self) -> RwLockReadGuard<KernelStack>870 pub fn kernel_stack(&self) -> RwLockReadGuard<KernelStack> {
871 return self.kernel_stack.read();
872 }
873
kernel_stack_force_ref(&self) -> &KernelStack874 pub unsafe fn kernel_stack_force_ref(&self) -> &KernelStack {
875 self.kernel_stack.force_get_ref()
876 }
877
878 #[inline(always)]
879 #[allow(dead_code)]
kernel_stack_mut(&self) -> RwLockWriteGuard<KernelStack>880 pub fn kernel_stack_mut(&self) -> RwLockWriteGuard<KernelStack> {
881 return self.kernel_stack.write();
882 }
883
884 #[inline(always)]
sched_info(&self) -> &ProcessSchedulerInfo885 pub fn sched_info(&self) -> &ProcessSchedulerInfo {
886 return &self.sched_info;
887 }
888
889 #[inline(always)]
worker_private(&self) -> SpinLockGuard<Option<WorkerPrivate>>890 pub fn worker_private(&self) -> SpinLockGuard<Option<WorkerPrivate>> {
891 return self.worker_private.lock();
892 }
893
894 #[inline(always)]
pid(&self) -> Pid895 pub fn pid(&self) -> Pid {
896 return self.pid;
897 }
898
899 #[inline(always)]
pid_strcut(&self) -> Arc<RwLock<PidStrcut>>900 pub fn pid_strcut(&self) -> Arc<RwLock<PidStrcut>> {
901 self.thread_pid.clone()
902 }
903
904 #[inline(always)]
tgid(&self) -> Pid905 pub fn tgid(&self) -> Pid {
906 return self.tgid;
907 }
908
909 #[inline(always)]
fs_struct(&self) -> Arc<SpinLock<FsStruct>>910 pub fn fs_struct(&self) -> Arc<SpinLock<FsStruct>> {
911 self.fs.clone()
912 }
913
914 /// 获取文件描述符表的Arc指针
915 #[inline(always)]
fd_table(&self) -> Arc<RwLock<FileDescriptorVec>>916 pub fn fd_table(&self) -> Arc<RwLock<FileDescriptorVec>> {
917 return self.basic.read().fd_table().unwrap();
918 }
919
920 #[inline(always)]
cred(&self) -> Cred921 pub fn cred(&self) -> Cred {
922 self.cred.lock().clone()
923 }
924
925 /// 根据文件描述符序号，获取socket对象的Arc指针
926 ///
927 /// ## 参数
928 ///
929 /// - `fd` 文件描述符序号
930 ///
931 /// ## 返回值
932 ///
933 /// Option(&mut Box<dyn Socket>) socket对象的可变引用. 如果文件描述符不是socket，那么返回None
get_socket(&self, fd: i32) -> Option<Arc<SocketInode>>934 pub fn get_socket(&self, fd: i32) -> Option<Arc<SocketInode>> {
935 let binding = ProcessManager::current_pcb().fd_table();
936 let fd_table_guard = binding.read();
937
938 let f = fd_table_guard.get_file_by_fd(fd)?;
939 drop(fd_table_guard);
940
941 if f.file_type() != FileType::Socket {
942 return None;
943 }
944 let socket: Arc<SocketInode> = f
945 .inode()
946 .downcast_arc::<SocketInode>()
947 .expect("Not a socket inode");
948 return Some(socket);
949 }
950
951 /// 当前进程退出时,让初始进程收养所有子进程
adopt_childen(&self) -> Result<(), SystemError>952 unsafe fn adopt_childen(&self) -> Result<(), SystemError> {
953 match ProcessManager::find(Pid(1)) {
954 Some(init_pcb) => {
955 let childen_guard = self.children.write();
956 let mut init_childen_guard = init_pcb.children.write();
957
958 childen_guard.iter().for_each(|pid| {
959 init_childen_guard.push(*pid);
960 });
961
962 return Ok(());
963 }
964 _ => Err(SystemError::ECHILD),
965 }
966 }
967
968 /// 生成进程的名字
generate_name(program_path: &str, args: &Vec<CString>) -> String969 pub fn generate_name(program_path: &str, args: &Vec<CString>) -> String {
970 let mut name = program_path.to_string();
971 for arg in args {
972 name.push(' ');
973 name.push_str(arg.to_string_lossy().as_ref());
974 }
975 return name;
976 }
977
sig_info_irqsave(&self) -> RwLockReadGuard<ProcessSignalInfo>978 pub fn sig_info_irqsave(&self) -> RwLockReadGuard<ProcessSignalInfo> {
979 self.sig_info.read_irqsave()
980 }
981
try_siginfo_irqsave(&self, times: u8) -> Option<RwLockReadGuard<ProcessSignalInfo>>982 pub fn try_siginfo_irqsave(&self, times: u8) -> Option<RwLockReadGuard<ProcessSignalInfo>> {
983 for _ in 0..times {
984 if let Some(r) = self.sig_info.try_read_irqsave() {
985 return Some(r);
986 }
987 }
988
989 return None;
990 }
991
sig_info_mut(&self) -> RwLockWriteGuard<ProcessSignalInfo>992 pub fn sig_info_mut(&self) -> RwLockWriteGuard<ProcessSignalInfo> {
993 self.sig_info.write_irqsave()
994 }
995
try_siginfo_mut(&self, times: u8) -> Option<RwLockWriteGuard<ProcessSignalInfo>>996 pub fn try_siginfo_mut(&self, times: u8) -> Option<RwLockWriteGuard<ProcessSignalInfo>> {
997 for _ in 0..times {
998 if let Some(r) = self.sig_info.try_write_irqsave() {
999 return Some(r);
1000 }
1001 }
1002
1003 return None;
1004 }
1005
1006 /// 判断当前进程是否有未处理的信号
has_pending_signal(&self) -> bool1007 pub fn has_pending_signal(&self) -> bool {
1008 let sig_info = self.sig_info_irqsave();
1009 let has_pending = sig_info.sig_pending().has_pending();
1010 drop(sig_info);
1011 return has_pending;
1012 }
1013
sig_struct(&self) -> SpinLockGuard<SignalStruct>1014 pub fn sig_struct(&self) -> SpinLockGuard<SignalStruct> {
1015 self.sig_struct.lock_irqsave()
1016 }
1017
try_sig_struct_irqsave(&self, times: u8) -> Option<SpinLockGuard<SignalStruct>>1018 pub fn try_sig_struct_irqsave(&self, times: u8) -> Option<SpinLockGuard<SignalStruct>> {
1019 for _ in 0..times {
1020 if let Ok(r) = self.sig_struct.try_lock_irqsave() {
1021 return Some(r);
1022 }
1023 }
1024
1025 return None;
1026 }
1027
sig_struct_irqsave(&self) -> SpinLockGuard<SignalStruct>1028 pub fn sig_struct_irqsave(&self) -> SpinLockGuard<SignalStruct> {
1029 self.sig_struct.lock_irqsave()
1030 }
1031
1032 #[inline(always)]
get_robust_list(&self) -> RwLockReadGuard<Option<RobustListHead>>1033 pub fn get_robust_list(&self) -> RwLockReadGuard<Option<RobustListHead>> {
1034 return self.robust_list.read_irqsave();
1035 }
1036
1037 #[inline(always)]
set_robust_list(&self, new_robust_list: Option<RobustListHead>)1038 pub fn set_robust_list(&self, new_robust_list: Option<RobustListHead>) {
1039 *self.robust_list.write_irqsave() = new_robust_list;
1040 }
1041
alarm_timer_irqsave(&self) -> SpinLockGuard<Option<AlarmTimer>>1042 pub fn alarm_timer_irqsave(&self) -> SpinLockGuard<Option<AlarmTimer>> {
1043 return self.alarm_timer.lock_irqsave();
1044 }
1045
get_nsproxy(&self) -> Arc<RwLock<NsProxy>>1046 pub fn get_nsproxy(&self) -> Arc<RwLock<NsProxy>> {
1047 self.nsproxy.clone()
1048 }
1049
set_nsproxy(&self, nsprsy: NsProxy)1050 pub fn set_nsproxy(&self, nsprsy: NsProxy) {
1051 *self.nsproxy.write() = nsprsy;
1052 }
1053 }
1054
1055 impl Drop for ProcessControlBlock {
drop(&mut self)1056 fn drop(&mut self) {
1057 let irq_guard = unsafe { CurrentIrqArch::save_and_disable_irq() };
1058 // 在ProcFS中,解除进程的注册
1059 procfs_unregister_pid(self.pid())
1060 .unwrap_or_else(|e| panic!("procfs_unregister_pid failed: error: {e:?}"));
1061
1062 if let Some(ppcb) = self.parent_pcb.read_irqsave().upgrade() {
1063 ppcb.children
1064 .write_irqsave()
1065 .retain(|pid| *pid != self.pid());
1066 }
1067
1068 drop(irq_guard);
1069 }
1070 }
1071
1072 /// 线程信息
1073 #[derive(Debug)]
1074 pub struct ThreadInfo {
1075 // 来自用户空间记录用户线程id的地址，在该线程结束时将该地址置0以通知父进程
1076 clear_child_tid: Option<VirtAddr>,
1077 set_child_tid: Option<VirtAddr>,
1078
1079 vfork_done: Option<Arc<Completion>>,
1080 /// 线程组的组长
1081 group_leader: Weak<ProcessControlBlock>,
1082 }
1083
1084 impl ThreadInfo {
new() -> Self1085 pub fn new() -> Self {
1086 Self {
1087 clear_child_tid: None,
1088 set_child_tid: None,
1089 vfork_done: None,
1090 group_leader: Weak::default(),
1091 }
1092 }
1093
group_leader(&self) -> Option<Arc<ProcessControlBlock>>1094 pub fn group_leader(&self) -> Option<Arc<ProcessControlBlock>> {
1095 return self.group_leader.upgrade();
1096 }
1097 }
1098
1099 /// 进程的基本信息
1100 ///
1101 /// 这个结构体保存进程的基本信息，主要是那些不会随着进程的运行而经常改变的信息。
1102 #[derive(Debug)]
1103 pub struct ProcessBasicInfo {
1104 /// 当前进程的进程组id
1105 pgid: Pid,
1106 /// 当前进程的父进程的pid
1107 ppid: Pid,
1108 /// 当前进程所属会话id
1109 sid: Pid,
1110 /// 进程的名字
1111 name: String,
1112
1113 /// 当前进程的工作目录
1114 cwd: String,
1115
1116 /// 用户地址空间
1117 user_vm: Option<Arc<AddressSpace>>,
1118
1119 /// 文件描述符表
1120 fd_table: Option<Arc<RwLock<FileDescriptorVec>>>,
1121 }
1122
1123 impl ProcessBasicInfo {
1124 #[inline(never)]
new( pgid: Pid, ppid: Pid, sid: Pid, name: String, cwd: String, user_vm: Option<Arc<AddressSpace>>, ) -> RwLock<Self>1125 pub fn new(
1126 pgid: Pid,
1127 ppid: Pid,
1128 sid: Pid,
1129 name: String,
1130 cwd: String,
1131 user_vm: Option<Arc<AddressSpace>>,
1132 ) -> RwLock<Self> {
1133 let fd_table = Arc::new(RwLock::new(FileDescriptorVec::new()));
1134 return RwLock::new(Self {
1135 pgid,
1136 ppid,
1137 sid,
1138 name,
1139 cwd,
1140 user_vm,
1141 fd_table: Some(fd_table),
1142 });
1143 }
1144
pgid(&self) -> Pid1145 pub fn pgid(&self) -> Pid {
1146 return self.pgid;
1147 }
1148
ppid(&self) -> Pid1149 pub fn ppid(&self) -> Pid {
1150 return self.ppid;
1151 }
1152
sid(&self) -> Pid1153 pub fn sid(&self) -> Pid {
1154 return self.sid;
1155 }
1156
name(&self) -> &str1157 pub fn name(&self) -> &str {
1158 return &self.name;
1159 }
1160
set_name(&mut self, name: String)1161 pub fn set_name(&mut self, name: String) {
1162 self.name = name;
1163 }
1164
cwd(&self) -> String1165 pub fn cwd(&self) -> String {
1166 return self.cwd.clone();
1167 }
set_cwd(&mut self, path: String)1168 pub fn set_cwd(&mut self, path: String) {
1169 return self.cwd = path;
1170 }
1171
user_vm(&self) -> Option<Arc<AddressSpace>>1172 pub fn user_vm(&self) -> Option<Arc<AddressSpace>> {
1173 return self.user_vm.clone();
1174 }
1175
set_user_vm(&mut self, user_vm: Option<Arc<AddressSpace>>)1176 pub unsafe fn set_user_vm(&mut self, user_vm: Option<Arc<AddressSpace>>) {
1177 self.user_vm = user_vm;
1178 }
1179
fd_table(&self) -> Option<Arc<RwLock<FileDescriptorVec>>>1180 pub fn fd_table(&self) -> Option<Arc<RwLock<FileDescriptorVec>>> {
1181 return self.fd_table.clone();
1182 }
1183
set_fd_table(&mut self, fd_table: Option<Arc<RwLock<FileDescriptorVec>>>)1184 pub fn set_fd_table(&mut self, fd_table: Option<Arc<RwLock<FileDescriptorVec>>>) {
1185 self.fd_table = fd_table;
1186 }
1187 }
1188
1189 #[derive(Debug)]
1190 pub struct ProcessSchedulerInfo {
1191 /// 当前进程所在的cpu
1192 on_cpu: AtomicProcessorId,
1193 /// 如果当前进程等待被迁移到另一个cpu核心上（也就是flags中的PF_NEED_MIGRATE被置位），
1194 /// 该字段存储要被迁移到的目标处理器核心号
1195 // migrate_to: AtomicProcessorId,
1196 inner_locked: RwLock<InnerSchedInfo>,
1197 /// 进程的调度优先级
1198 // priority: SchedPriority,
1199 /// 当前进程的虚拟运行时间
1200 // virtual_runtime: AtomicIsize,
1201 /// 由实时调度器管理的时间片
1202 // rt_time_slice: AtomicIsize,
1203 pub sched_stat: RwLock<SchedInfo>,
1204 /// 调度策略
1205 pub sched_policy: RwLock<crate::sched::SchedPolicy>,
1206 /// cfs调度实体
1207 pub sched_entity: Arc<FairSchedEntity>,
1208 pub on_rq: SpinLock<OnRq>,
1209
1210 pub prio_data: RwLock<PrioData>,
1211 }
1212
1213 #[derive(Debug, Default)]
1214 #[allow(dead_code)]
1215 pub struct SchedInfo {
1216 /// 记录任务在特定 CPU 上运行的次数
1217 pub pcount: usize,
1218 /// 记录任务等待在运行队列上的时间
1219 pub run_delay: usize,
1220 /// 记录任务上次在 CPU 上运行的时间戳
1221 pub last_arrival: u64,
1222 /// 记录任务上次被加入到运行队列中的时间戳
1223 pub last_queued: u64,
1224 }
1225
1226 #[derive(Debug)]
1227 #[allow(dead_code)]
1228 pub struct PrioData {
1229 pub prio: i32,
1230 pub static_prio: i32,
1231 pub normal_prio: i32,
1232 }
1233
1234 impl Default for PrioData {
default() -> Self1235 fn default() -> Self {
1236 Self {
1237 prio: MAX_PRIO - 20,
1238 static_prio: MAX_PRIO - 20,
1239 normal_prio: MAX_PRIO - 20,
1240 }
1241 }
1242 }
1243
1244 #[derive(Debug)]
1245 pub struct InnerSchedInfo {
1246 /// 当前进程的状态
1247 state: ProcessState,
1248 /// 进程的调度策略
1249 sleep: bool,
1250 }
1251
1252 impl InnerSchedInfo {
state(&self) -> ProcessState1253 pub fn state(&self) -> ProcessState {
1254 return self.state;
1255 }
1256
set_state(&mut self, state: ProcessState)1257 pub fn set_state(&mut self, state: ProcessState) {
1258 self.state = state;
1259 }
1260
set_sleep(&mut self)1261 pub fn set_sleep(&mut self) {
1262 self.sleep = true;
1263 }
1264
set_wakeup(&mut self)1265 pub fn set_wakeup(&mut self) {
1266 self.sleep = false;
1267 }
1268
is_mark_sleep(&self) -> bool1269 pub fn is_mark_sleep(&self) -> bool {
1270 self.sleep
1271 }
1272 }
1273
1274 impl ProcessSchedulerInfo {
1275 #[inline(never)]
new(on_cpu: Option<ProcessorId>) -> Self1276 pub fn new(on_cpu: Option<ProcessorId>) -> Self {
1277 let cpu_id = on_cpu.unwrap_or(ProcessorId::INVALID);
1278 return Self {
1279 on_cpu: AtomicProcessorId::new(cpu_id),
1280 // migrate_to: AtomicProcessorId::new(ProcessorId::INVALID),
1281 inner_locked: RwLock::new(InnerSchedInfo {
1282 state: ProcessState::Blocked(false),
1283 sleep: false,
1284 }),
1285 // virtual_runtime: AtomicIsize::new(0),
1286 // rt_time_slice: AtomicIsize::new(0),
1287 // priority: SchedPriority::new(100).unwrap(),
1288 sched_stat: RwLock::new(SchedInfo::default()),
1289 sched_policy: RwLock::new(crate::sched::SchedPolicy::CFS),
1290 sched_entity: FairSchedEntity::new(),
1291 on_rq: SpinLock::new(OnRq::None),
1292 prio_data: RwLock::new(PrioData::default()),
1293 };
1294 }
1295
sched_entity(&self) -> Arc<FairSchedEntity>1296 pub fn sched_entity(&self) -> Arc<FairSchedEntity> {
1297 return self.sched_entity.clone();
1298 }
1299
on_cpu(&self) -> Option<ProcessorId>1300 pub fn on_cpu(&self) -> Option<ProcessorId> {
1301 let on_cpu = self.on_cpu.load(Ordering::SeqCst);
1302 if on_cpu == ProcessorId::INVALID {
1303 return None;
1304 } else {
1305 return Some(on_cpu);
1306 }
1307 }
1308
set_on_cpu(&self, on_cpu: Option<ProcessorId>)1309 pub fn set_on_cpu(&self, on_cpu: Option<ProcessorId>) {
1310 if let Some(cpu_id) = on_cpu {
1311 self.on_cpu.store(cpu_id, Ordering::SeqCst);
1312 } else {
1313 self.on_cpu.store(ProcessorId::INVALID, Ordering::SeqCst);
1314 }
1315 }
1316
1317 // pub fn migrate_to(&self) -> Option<ProcessorId> {
1318 // let migrate_to = self.migrate_to.load(Ordering::SeqCst);
1319 // if migrate_to == ProcessorId::INVALID {
1320 // return None;
1321 // } else {
1322 // return Some(migrate_to);
1323 // }
1324 // }
1325
1326 // pub fn set_migrate_to(&self, migrate_to: Option<ProcessorId>) {
1327 // if let Some(data) = migrate_to {
1328 // self.migrate_to.store(data, Ordering::SeqCst);
1329 // } else {
1330 // self.migrate_to
1331 // .store(ProcessorId::INVALID, Ordering::SeqCst)
1332 // }
1333 // }
1334
inner_lock_write_irqsave(&self) -> RwLockWriteGuard<InnerSchedInfo>1335 pub fn inner_lock_write_irqsave(&self) -> RwLockWriteGuard<InnerSchedInfo> {
1336 return self.inner_locked.write_irqsave();
1337 }
1338
inner_lock_read_irqsave(&self) -> RwLockReadGuard<InnerSchedInfo>1339 pub fn inner_lock_read_irqsave(&self) -> RwLockReadGuard<InnerSchedInfo> {
1340 return self.inner_locked.read_irqsave();
1341 }
1342
1343 // pub fn inner_lock_try_read_irqsave(
1344 // &self,
1345 // times: u8,
1346 // ) -> Option<RwLockReadGuard<InnerSchedInfo>> {
1347 // for _ in 0..times {
1348 // if let Some(r) = self.inner_locked.try_read_irqsave() {
1349 // return Some(r);
1350 // }
1351 // }
1352
1353 // return None;
1354 // }
1355
1356 // pub fn inner_lock_try_upgradable_read_irqsave(
1357 // &self,
1358 // times: u8,
1359 // ) -> Option<RwLockUpgradableGuard<InnerSchedInfo>> {
1360 // for _ in 0..times {
1361 // if let Some(r) = self.inner_locked.try_upgradeable_read_irqsave() {
1362 // return Some(r);
1363 // }
1364 // }
1365
1366 // return None;
1367 // }
1368
1369 // pub fn virtual_runtime(&self) -> isize {
1370 // return self.virtual_runtime.load(Ordering::SeqCst);
1371 // }
1372
1373 // pub fn set_virtual_runtime(&self, virtual_runtime: isize) {
1374 // self.virtual_runtime
1375 // .store(virtual_runtime, Ordering::SeqCst);
1376 // }
1377 // pub fn increase_virtual_runtime(&self, delta: isize) {
1378 // self.virtual_runtime.fetch_add(delta, Ordering::SeqCst);
1379 // }
1380
1381 // pub fn rt_time_slice(&self) -> isize {
1382 // return self.rt_time_slice.load(Ordering::SeqCst);
1383 // }
1384
1385 // pub fn set_rt_time_slice(&self, rt_time_slice: isize) {
1386 // self.rt_time_slice.store(rt_time_slice, Ordering::SeqCst);
1387 // }
1388
1389 // pub fn increase_rt_time_slice(&self, delta: isize) {
1390 // self.rt_time_slice.fetch_add(delta, Ordering::SeqCst);
1391 // }
1392
policy(&self) -> crate::sched::SchedPolicy1393 pub fn policy(&self) -> crate::sched::SchedPolicy {
1394 return *self.sched_policy.read_irqsave();
1395 }
1396 }
1397
1398 #[derive(Debug, Clone)]
1399 pub struct KernelStack {
1400 stack: Option<AlignedBox<[u8; KernelStack::SIZE], { KernelStack::ALIGN }>>,
1401 /// 标记该内核栈是否可以被释放
1402 can_be_freed: bool,
1403 }
1404
1405 impl KernelStack {
1406 pub const SIZE: usize = 0x4000;
1407 pub const ALIGN: usize = 0x4000;
1408
new() -> Result<Self, SystemError>1409 pub fn new() -> Result<Self, SystemError> {
1410 return Ok(Self {
1411 stack: Some(
1412 AlignedBox::<[u8; KernelStack::SIZE], { KernelStack::ALIGN }>::new_zeroed()?,
1413 ),
1414 can_be_freed: true,
1415 });
1416 }
1417
1418 /// 根据已有的空间，构造一个内核栈结构体
1419 ///
1420 /// 仅仅用于BSP启动时，为idle进程构造内核栈。其他时候使用这个函数，很可能造成错误！
from_existed(base: VirtAddr) -> Result<Self, SystemError>1421 pub unsafe fn from_existed(base: VirtAddr) -> Result<Self, SystemError> {
1422 if base.is_null() || !base.check_aligned(Self::ALIGN) {
1423 return Err(SystemError::EFAULT);
1424 }
1425
1426 return Ok(Self {
1427 stack: Some(
1428 AlignedBox::<[u8; KernelStack::SIZE], { KernelStack::ALIGN }>::new_unchecked(
1429 base.data() as *mut [u8; KernelStack::SIZE],
1430 ),
1431 ),
1432 can_be_freed: false,
1433 });
1434 }
1435
1436 /// 返回内核栈的起始虚拟地址(低地址)
start_address(&self) -> VirtAddr1437 pub fn start_address(&self) -> VirtAddr {
1438 return VirtAddr::new(self.stack.as_ref().unwrap().as_ptr() as usize);
1439 }
1440
1441 /// 返回内核栈的结束虚拟地址(高地址)(不包含该地址)
stack_max_address(&self) -> VirtAddr1442 pub fn stack_max_address(&self) -> VirtAddr {
1443 return VirtAddr::new(self.stack.as_ref().unwrap().as_ptr() as usize + Self::SIZE);
1444 }
1445
set_pcb(&mut self, pcb: Weak<ProcessControlBlock>) -> Result<(), SystemError>1446 pub unsafe fn set_pcb(&mut self, pcb: Weak<ProcessControlBlock>) -> Result<(), SystemError> {
1447 // 将一个Weak<ProcessControlBlock>放到内核栈的最低地址处
1448 let p: *const ProcessControlBlock = Weak::into_raw(pcb);
1449 let stack_bottom_ptr = self.start_address().data() as *mut *const ProcessControlBlock;
1450
1451 // 如果内核栈的最低地址处已经有了一个pcb，那么，这里就不再设置,直接返回错误
1452 if unlikely(unsafe { !(*stack_bottom_ptr).is_null() }) {
1453 error!("kernel stack bottom is not null: {:p}", *stack_bottom_ptr);
1454 return Err(SystemError::EPERM);
1455 }
1456 // 将pcb的地址放到内核栈的最低地址处
1457 unsafe {
1458 *stack_bottom_ptr = p;
1459 }
1460
1461 return Ok(());
1462 }
1463
1464 /// 清除内核栈的pcb指针
1465 ///
1466 /// ## 参数
1467 ///
1468 /// - `force` : 如果为true,那么，即使该内核栈的pcb指针不为null，也会被强制清除而不处理Weak指针问题
clear_pcb(&mut self, force: bool)1469 pub unsafe fn clear_pcb(&mut self, force: bool) {
1470 let stack_bottom_ptr = self.start_address().data() as *mut *const ProcessControlBlock;
1471 if unlikely(unsafe { (*stack_bottom_ptr).is_null() }) {
1472 return;
1473 }
1474
1475 if !force {
1476 let pcb_ptr: Weak<ProcessControlBlock> = Weak::from_raw(*stack_bottom_ptr);
1477 drop(pcb_ptr);
1478 }
1479
1480 *stack_bottom_ptr = core::ptr::null();
1481 }
1482
1483 /// 返回指向当前内核栈pcb的Arc指针
1484 #[allow(dead_code)]
pcb(&self) -> Option<Arc<ProcessControlBlock>>1485 pub unsafe fn pcb(&self) -> Option<Arc<ProcessControlBlock>> {
1486 // 从内核栈的最低地址处取出pcb的地址
1487 let p = self.stack.as_ref().unwrap().as_ptr() as *const *const ProcessControlBlock;
1488 if unlikely(unsafe { (*p).is_null() }) {
1489 return None;
1490 }
1491
1492 // 为了防止内核栈的pcb指针被释放，这里需要将其包装一下，使得Arc的drop不会被调用
1493 let weak_wrapper: ManuallyDrop<Weak<ProcessControlBlock>> =
1494 ManuallyDrop::new(Weak::from_raw(*p));
1495
1496 let new_arc: Arc<ProcessControlBlock> = weak_wrapper.upgrade()?;
1497 return Some(new_arc);
1498 }
1499 }
1500
1501 impl Drop for KernelStack {
drop(&mut self)1502 fn drop(&mut self) {
1503 if self.stack.is_some() {
1504 let ptr = self.stack.as_ref().unwrap().as_ptr() as *const *const ProcessControlBlock;
1505 if unsafe { !(*ptr).is_null() } {
1506 let pcb_ptr: Weak<ProcessControlBlock> = unsafe { Weak::from_raw(*ptr) };
1507 drop(pcb_ptr);
1508 }
1509 }
1510 // 如果该内核栈不可以被释放，那么，这里就forget，不调用AlignedBox的drop函数
1511 if !self.can_be_freed {
1512 let bx = self.stack.take();
1513 core::mem::forget(bx);
1514 }
1515 }
1516 }
1517
process_init()1518 pub fn process_init() {
1519 ProcessManager::init();
1520 }
1521
1522 #[derive(Debug)]
1523 pub struct ProcessSignalInfo {
1524 // 当前进程
1525 sig_block: SigSet,
1526 // sig_pending 中存储当前线程要处理的信号
1527 sig_pending: SigPending,
1528 // sig_shared_pending 中存储当前线程所属进程要处理的信号
1529 sig_shared_pending: SigPending,
1530 // 当前进程对应的tty
1531 tty: Option<Arc<TtyCore>>,
1532 }
1533
1534 impl ProcessSignalInfo {
sig_block(&self) -> &SigSet1535 pub fn sig_block(&self) -> &SigSet {
1536 &self.sig_block
1537 }
1538
sig_pending(&self) -> &SigPending1539 pub fn sig_pending(&self) -> &SigPending {
1540 &self.sig_pending
1541 }
1542
sig_pending_mut(&mut self) -> &mut SigPending1543 pub fn sig_pending_mut(&mut self) -> &mut SigPending {
1544 &mut self.sig_pending
1545 }
1546
sig_block_mut(&mut self) -> &mut SigSet1547 pub fn sig_block_mut(&mut self) -> &mut SigSet {
1548 &mut self.sig_block
1549 }
1550
sig_shared_pending_mut(&mut self) -> &mut SigPending1551 pub fn sig_shared_pending_mut(&mut self) -> &mut SigPending {
1552 &mut self.sig_shared_pending
1553 }
1554
sig_shared_pending(&self) -> &SigPending1555 pub fn sig_shared_pending(&self) -> &SigPending {
1556 &self.sig_shared_pending
1557 }
1558
tty(&self) -> Option<Arc<TtyCore>>1559 pub fn tty(&self) -> Option<Arc<TtyCore>> {
1560 self.tty.clone()
1561 }
1562
set_tty(&mut self, tty: Option<Arc<TtyCore>>)1563 pub fn set_tty(&mut self, tty: Option<Arc<TtyCore>>) {
1564 self.tty = tty;
1565 }
1566
1567 /// 从 pcb 的 siginfo中取出下一个要处理的信号，先处理线程信号，再处理进程信号
1568 ///
1569 /// ## 参数
1570 ///
1571 /// - `sig_mask` 被忽略掉的信号
1572 ///
dequeue_signal(&mut self, sig_mask: &SigSet) -> (Signal, Option<SigInfo>)1573 pub fn dequeue_signal(&mut self, sig_mask: &SigSet) -> (Signal, Option<SigInfo>) {
1574 let res = self.sig_pending.dequeue_signal(sig_mask);
1575 if res.0 != Signal::INVALID {
1576 return res;
1577 } else {
1578 return self.sig_shared_pending.dequeue_signal(sig_mask);
1579 }
1580 }
1581 }
1582
1583 impl Default for ProcessSignalInfo {
default() -> Self1584 fn default() -> Self {
1585 Self {
1586 sig_block: SigSet::empty(),
1587 sig_pending: SigPending::default(),
1588 sig_shared_pending: SigPending::default(),
1589 tty: None,
1590 }
1591 }
1592 }
1593