xref: /DragonOS/kernel/src/filesystem/procfs/mod.rs (revision e7071df6a47c100381a8bc2000022e82d422361a) 
1 use core::intrinsics::size_of;
2 
3 use alloc::{
4     borrow::ToOwned,
5     collections::BTreeMap,
6     format,
7     string::String,
8     sync::{Arc, Weak},
9     vec::Vec,
10 };
11 use system_error::SystemError;
12 
13 use crate::{
14     arch::mm::LockedFrameAllocator,
15     filesystem::vfs::{
16         core::{generate_inode_id, ROOT_INODE},
17         FileType,
18     },
19     kerror, kinfo,
20     libs::{
21         once::Once,
22         spinlock::{SpinLock, SpinLockGuard},
23     },
24     mm::allocator::page_frame::FrameAllocator,
25     process::{Pid, ProcessManager},
26     time::TimeSpec,
27 };
28 
29 use super::vfs::{
30     file::{FileMode, FilePrivateData},
31     syscall::ModeType,
32     FileSystem, FsInfo, IndexNode, InodeId, Metadata,
33 };
34 
35 /// @brief 进程文件类型
36 /// @usage 用于定义进程文件夹下的各类文件类型
37 #[derive(Debug)]
38 #[repr(u8)]
39 pub enum ProcFileType {
40     ///展示进程状态信息
41     ProcStatus = 0,
42     /// meminfo
43     ProcMeminfo = 1,
44     //todo: 其他文件类型
45     ///默认文件类型
46     Default,
47 }
48 
49 impl From<u8> for ProcFileType {
50     fn from(value: u8) -> Self {
51         match value {
52             0 => ProcFileType::ProcStatus,
53             1 => ProcFileType::ProcMeminfo,
54             _ => ProcFileType::Default,
55         }
56     }
57 }
58 /// @brief 节点私有信息结构体
59 /// @usage 用于传入各类文件所需的信息
60 #[derive(Debug)]
61 pub struct InodeInfo {
62     ///进程的pid
63     pid: Pid,
64     ///文件类型
65     ftype: ProcFileType,
66     //其他需要传入的信息在此定义
67 }
68 
69 /// @brief procfs的inode名称的最大长度
70 const PROCFS_MAX_NAMELEN: usize = 64;
71 
72 /// @brief procfs文件系统的Inode结构体
73 #[derive(Debug)]
74 pub struct LockedProcFSInode(SpinLock<ProcFSInode>);
75 
76 /// @brief procfs文件系统结构体
77 #[derive(Debug)]
78 pub struct ProcFS {
79     /// procfs的root inode
80     root_inode: Arc<LockedProcFSInode>,
81 }
82 
83 #[derive(Debug, Clone)]
84 pub struct ProcfsFilePrivateData {
85     data: Vec<u8>,
86 }
87 
88 impl ProcfsFilePrivateData {
89     pub fn new() -> Self {
90         return ProcfsFilePrivateData { data: Vec::new() };
91     }
92 }
93 
94 /// @brief procfs文件系统的Inode结构体(不包含锁)
95 #[derive(Debug)]
96 pub struct ProcFSInode {
97     /// 指向父Inode的弱引用
98     parent: Weak<LockedProcFSInode>,
99     /// 指向自身的弱引用
100     self_ref: Weak<LockedProcFSInode>,
101     /// 子Inode的B树
102     children: BTreeMap<String, Arc<LockedProcFSInode>>,
103     /// 当前inode的数据部分
104     data: Vec<u8>,
105     /// 当前inode的元数据
106     metadata: Metadata,
107     /// 指向inode所在的文件系统对象的指针
108     fs: Weak<ProcFS>,
109     /// 储存私有信息
110     fdata: InodeInfo,
111 }
112 
113 /// 对ProcFSInode实现获取各类文件信息的函数
114 impl ProcFSInode {
115     /// @brief 去除Vec中所有的\0,并在结尾添加\0
116     #[inline]
117     fn trim_string(&self, data: &mut Vec<u8>) {
118         data.retain(|x| *x != 0);
119 
120         data.push(0);
121     }
122     // todo:其他数据获取函数实现
123 
124     /// @brief 打开status文件
125     ///
126     fn open_status(&self, pdata: &mut ProcfsFilePrivateData) -> Result<i64, SystemError> {
127         // 获取该pid对应的pcb结构体
128         let pid = self.fdata.pid;
129         let pcb = ProcessManager::find(pid);
130         let pcb = if pcb.is_none() {
131             kerror!(
132                 "ProcFS: Cannot find pcb for pid {:?} when opening its 'status' file.",
133                 pid
134             );
135             return Err(SystemError::ESRCH);
136         } else {
137             pcb.unwrap()
138         };
139         // 传入数据
140         let pdata: &mut Vec<u8> = &mut pdata.data;
141 
142         pdata.append(
143             &mut format!("Name:\t{}", pcb.basic().name())
144                 .as_bytes()
145                 .to_owned(),
146         );
147 
148         let sched_info_guard = pcb.sched_info();
149         let state = sched_info_guard.inner_lock_read_irqsave().state();
150         let cpu_id = sched_info_guard
151             .on_cpu()
152             .map(|cpu| cpu as i32)
153             .unwrap_or(-1);
154 
155         let priority = sched_info_guard.priority();
156         let vrtime = sched_info_guard.virtual_runtime();
157 
158         pdata.append(&mut format!("\nState:\t{:?}", state).as_bytes().to_owned());
159         pdata.append(
160             &mut format!("\nPid:\t{}", pcb.pid().into())
161                 .as_bytes()
162                 .to_owned(),
163         );
164         pdata.append(
165             &mut format!("\nPpid:\t{}", pcb.basic().ppid().into())
166                 .as_bytes()
167                 .to_owned(),
168         );
169         pdata.append(&mut format!("\ncpu_id:\t{}", cpu_id).as_bytes().to_owned());
170         pdata.append(
171             &mut format!("\npriority:\t{}", priority.data())
172                 .as_bytes()
173                 .to_owned(),
174         );
175         pdata.append(
176             &mut format!("\npreempt:\t{}", pcb.preempt_count())
177                 .as_bytes()
178                 .to_owned(),
179         );
180         pdata.append(&mut format!("\nvrtime:\t{}", vrtime).as_bytes().to_owned());
181 
182         if let Some(user_vm) = pcb.basic().user_vm() {
183             let address_space_guard = user_vm.read();
184             // todo: 当前进程运行过程中占用内存的峰值
185             let hiwater_vm: u64 = 0;
186             // 进程代码段的大小
187             let text = (address_space_guard.end_code - address_space_guard.start_code) / 1024;
188             // 进程数据段的大小
189             let data = (address_space_guard.end_data - address_space_guard.start_data) / 1024;
190             drop(address_space_guard);
191             pdata.append(
192                 &mut format!("\nVmPeak:\t{} kB", hiwater_vm)
193                     .as_bytes()
194                     .to_owned(),
195             );
196             pdata.append(&mut format!("\nVmData:\t{} kB", data).as_bytes().to_owned());
197             pdata.append(&mut format!("\nVmExe:\t{} kB", text).as_bytes().to_owned());
198         }
199 
200         pdata.append(
201             &mut format!("\nflags: {:?}\n", pcb.flags().clone())
202                 .as_bytes()
203                 .to_owned(),
204         );
205 
206         // 去除多余的\0
207         self.trim_string(pdata);
208 
209         return Ok((pdata.len() * size_of::<u8>()) as i64);
210     }
211 
212     /// 打开 meminfo 文件
213     fn open_meminfo(&self, pdata: &mut ProcfsFilePrivateData) -> Result<i64, SystemError> {
214         // 获取内存信息
215         let usage = unsafe { LockedFrameAllocator.usage() };
216 
217         // 传入数据
218         let data: &mut Vec<u8> = &mut pdata.data;
219 
220         data.append(
221             &mut format!("MemTotal:\t{} kB\n", usage.total().bytes() >> 10)
222                 .as_bytes()
223                 .to_owned(),
224         );
225 
226         data.append(
227             &mut format!("MemFree:\t{} kB\n", usage.free().bytes() >> 10)
228                 .as_bytes()
229                 .to_owned(),
230         );
231 
232         // 去除多余的\0
233         self.trim_string(data);
234 
235         return Ok((data.len() * size_of::<u8>()) as i64);
236     }
237 
238     /// proc文件系统读取函数
239     fn proc_read(
240         &self,
241         offset: usize,
242         len: usize,
243         buf: &mut [u8],
244         _pdata: &mut ProcfsFilePrivateData,
245     ) -> Result<usize, SystemError> {
246         let start = _pdata.data.len().min(offset);
247         let end = _pdata.data.len().min(offset + len);
248 
249         // buffer空间不足
250         if buf.len() < (end - start) {
251             return Err(SystemError::ENOBUFS);
252         }
253 
254         // 拷贝数据
255         let src = &_pdata.data[start..end];
256         buf[0..src.len()].copy_from_slice(src);
257         return Ok(src.len());
258     }
259 }
260 
261 impl FileSystem for ProcFS {
262     fn root_inode(&self) -> Arc<dyn super::vfs::IndexNode> {
263         return self.root_inode.clone();
264     }
265 
266     fn info(&self) -> FsInfo {
267         return FsInfo {
268             blk_dev_id: 0,
269             max_name_len: PROCFS_MAX_NAMELEN,
270         };
271     }
272 
273     fn as_any_ref(&self) -> &dyn core::any::Any {
274         self
275     }
276 }
277 
278 impl ProcFS {
279     pub fn new() -> Arc<Self> {
280         // 初始化root inode
281         let root: Arc<LockedProcFSInode> =
282             Arc::new(LockedProcFSInode(SpinLock::new(ProcFSInode {
283                 parent: Weak::default(),
284                 self_ref: Weak::default(),
285                 children: BTreeMap::new(),
286                 data: Vec::new(),
287                 metadata: Metadata {
288                     dev_id: 0,
289                     inode_id: generate_inode_id(),
290                     size: 0,
291                     blk_size: 0,
292                     blocks: 0,
293                     atime: TimeSpec::default(),
294                     mtime: TimeSpec::default(),
295                     ctime: TimeSpec::default(),
296                     file_type: FileType::Dir,
297                     mode: ModeType::from_bits_truncate(0o555),
298                     nlinks: 1,
299                     uid: 0,
300                     gid: 0,
301                     raw_dev: 0,
302                 },
303                 fs: Weak::default(),
304                 fdata: InodeInfo {
305                     pid: Pid::new(0),
306                     ftype: ProcFileType::Default,
307                 },
308             })));
309 
310         let result: Arc<ProcFS> = Arc::new(ProcFS { root_inode: root });
311 
312         // 对root inode加锁，并继续完成初始化工作
313         let mut root_guard: SpinLockGuard<ProcFSInode> = result.root_inode.0.lock();
314         root_guard.parent = Arc::downgrade(&result.root_inode);
315         root_guard.self_ref = Arc::downgrade(&result.root_inode);
316         root_guard.fs = Arc::downgrade(&result);
317         // 释放锁
318         drop(root_guard);
319 
320         // 创建meminfo文件
321         let inode = result.root_inode();
322         let binding = inode.create(
323             "meminfo",
324             FileType::File,
325             ModeType::from_bits_truncate(0o444),
326         );
327         if let Ok(meminfo) = binding {
328             let meminfo_file = meminfo
329                 .as_any_ref()
330                 .downcast_ref::<LockedProcFSInode>()
331                 .unwrap();
332             meminfo_file.0.lock().fdata.pid = Pid::new(0);
333             meminfo_file.0.lock().fdata.ftype = ProcFileType::ProcMeminfo;
334         } else {
335             panic!("create meminfo error");
336         }
337 
338         return result;
339     }
340 
341     /// @brief 进程注册函数
342     /// @usage 在进程中调用并创建进程对应文件
343     pub fn register_pid(&self, pid: Pid) -> Result<(), SystemError> {
344         // 获取当前inode
345         let inode: Arc<dyn IndexNode> = self.root_inode();
346         // 创建对应进程文件夹
347         let pid_dir: Arc<dyn IndexNode> = inode.create(
348             &pid.to_string(),
349             FileType::Dir,
350             ModeType::from_bits_truncate(0o555),
351         )?;
352         // 创建相关文件
353         // status文件
354         let binding: Arc<dyn IndexNode> = pid_dir.create(
355             "status",
356             FileType::File,
357             ModeType::from_bits_truncate(0o444),
358         )?;
359         let status_file: &LockedProcFSInode = binding
360             .as_any_ref()
361             .downcast_ref::<LockedProcFSInode>()
362             .unwrap();
363         status_file.0.lock().fdata.pid = pid;
364         status_file.0.lock().fdata.ftype = ProcFileType::ProcStatus;
365 
366         //todo: 创建其他文件
367 
368         return Ok(());
369     }
370 
371     /// @brief 解除进程注册
372     ///
373     pub fn unregister_pid(&self, pid: Pid) -> Result<(), SystemError> {
374         // 获取当前inode
375         let proc: Arc<dyn IndexNode> = self.root_inode();
376         // 获取进程文件夹
377         let pid_dir: Arc<dyn IndexNode> = proc.find(&pid.to_string())?;
378         // 删除进程文件夹下文件
379         pid_dir.unlink("status")?;
380 
381         // 查看进程文件是否还存在
382         // let pf= pid_dir.find("status").expect("Cannot find status");
383 
384         // 删除进程文件夹
385         proc.unlink(&pid.to_string())?;
386 
387         return Ok(());
388     }
389 }
390 
391 impl IndexNode for LockedProcFSInode {
392     fn open(&self, data: &mut FilePrivateData, _mode: &FileMode) -> Result<(), SystemError> {
393         // 加锁
394         let mut inode: SpinLockGuard<ProcFSInode> = self.0.lock();
395 
396         // 如果inode类型为文件夹，则直接返回成功
397         if let FileType::Dir = inode.metadata.file_type {
398             return Ok(());
399         }
400         let mut private_data = ProcfsFilePrivateData::new();
401         // 根据文件类型获取相应数据
402         let file_size = match inode.fdata.ftype {
403             ProcFileType::ProcStatus => inode.open_status(&mut private_data)?,
404             ProcFileType::ProcMeminfo => inode.open_meminfo(&mut private_data)?,
405             _ => {
406                 todo!()
407             }
408         };
409         *data = FilePrivateData::Procfs(private_data);
410         // 更新metadata里面的文件大小数值
411         inode.metadata.size = file_size;
412 
413         return Ok(());
414     }
415 
416     fn close(&self, data: &mut FilePrivateData) -> Result<(), SystemError> {
417         let guard: SpinLockGuard<ProcFSInode> = self.0.lock();
418         // 如果inode类型为文件夹，则直接返回成功
419         if let FileType::Dir = guard.metadata.file_type {
420             return Ok(());
421         }
422         // 释放data
423         *data = FilePrivateData::Procfs(ProcfsFilePrivateData::new());
424 
425         return Ok(());
426     }
427 
428     fn read_at(
429         &self,
430         offset: usize,
431         len: usize,
432         buf: &mut [u8],
433         data: &mut FilePrivateData,
434     ) -> Result<usize, SystemError> {
435         if buf.len() < len {
436             return Err(SystemError::EINVAL);
437         }
438         // 加锁
439         let inode: SpinLockGuard<ProcFSInode> = self.0.lock();
440 
441         // 检查当前inode是否为一个文件夹，如果是的话，就返回错误
442         if inode.metadata.file_type == FileType::Dir {
443             return Err(SystemError::EISDIR);
444         }
445 
446         // 获取数据信息
447         let private_data = match data {
448             FilePrivateData::Procfs(p) => p,
449             _ => {
450                 panic!("ProcFS: FilePrivateData mismatch!");
451             }
452         };
453 
454         // 根据文件类型读取相应数据
455         match inode.fdata.ftype {
456             ProcFileType::ProcStatus => return inode.proc_read(offset, len, buf, private_data),
457             ProcFileType::ProcMeminfo => return inode.proc_read(offset, len, buf, private_data),
458             ProcFileType::Default => (),
459         };
460 
461         // 默认读取
462         let start = inode.data.len().min(offset);
463         let end = inode.data.len().min(offset + len);
464 
465         // buffer空间不足
466         if buf.len() < (end - start) {
467             return Err(SystemError::ENOBUFS);
468         }
469 
470         // 拷贝数据
471         let src = &inode.data[start..end];
472         buf[0..src.len()].copy_from_slice(src);
473         return Ok(src.len());
474     }
475 
476     fn write_at(
477         &self,
478         _offset: usize,
479         _len: usize,
480         _buf: &[u8],
481         _data: &mut FilePrivateData,
482     ) -> Result<usize, SystemError> {
483         return Err(SystemError::EOPNOTSUPP_OR_ENOTSUP);
484     }
485 
486     fn fs(&self) -> Arc<dyn FileSystem> {
487         return self.0.lock().fs.upgrade().unwrap();
488     }
489 
490     fn as_any_ref(&self) -> &dyn core::any::Any {
491         self
492     }
493 
494     fn metadata(&self) -> Result<Metadata, SystemError> {
495         let inode = self.0.lock();
496         let metadata = inode.metadata.clone();
497 
498         return Ok(metadata);
499     }
500 
501     fn set_metadata(&self, metadata: &Metadata) -> Result<(), SystemError> {
502         let mut inode = self.0.lock();
503         inode.metadata.atime = metadata.atime;
504         inode.metadata.mtime = metadata.mtime;
505         inode.metadata.ctime = metadata.ctime;
506         inode.metadata.mode = metadata.mode;
507         inode.metadata.uid = metadata.uid;
508         inode.metadata.gid = metadata.gid;
509 
510         return Ok(());
511     }
512 
513     fn resize(&self, len: usize) -> Result<(), SystemError> {
514         let mut inode = self.0.lock();
515         if inode.metadata.file_type == FileType::File {
516             inode.data.resize(len, 0);
517             return Ok(());
518         } else {
519             return Err(SystemError::EINVAL);
520         }
521     }
522 
523     fn create_with_data(
524         &self,
525         name: &str,
526         file_type: FileType,
527         mode: ModeType,
528         data: usize,
529     ) -> Result<Arc<dyn IndexNode>, SystemError> {
530         // 获取当前inode
531         let mut inode = self.0.lock();
532         // 如果当前inode不是文件夹，则返回
533         if inode.metadata.file_type != FileType::Dir {
534             return Err(SystemError::ENOTDIR);
535         }
536         // 如果有重名的，则返回
537         if inode.children.contains_key(name) {
538             return Err(SystemError::EEXIST);
539         }
540 
541         // 创建inode
542         let result: Arc<LockedProcFSInode> =
543             Arc::new(LockedProcFSInode(SpinLock::new(ProcFSInode {
544                 parent: inode.self_ref.clone(),
545                 self_ref: Weak::default(),
546                 children: BTreeMap::new(),
547                 data: Vec::new(),
548                 metadata: Metadata {
549                     dev_id: 0,
550                     inode_id: generate_inode_id(),
551                     size: 0,
552                     blk_size: 0,
553                     blocks: 0,
554                     atime: TimeSpec::default(),
555                     mtime: TimeSpec::default(),
556                     ctime: TimeSpec::default(),
557                     file_type: file_type,
558                     mode: mode,
559                     nlinks: 1,
560                     uid: 0,
561                     gid: 0,
562                     raw_dev: data,
563                 },
564                 fs: inode.fs.clone(),
565                 fdata: InodeInfo {
566                     pid: Pid::new(0),
567                     ftype: ProcFileType::Default,
568                 },
569             })));
570 
571         // 初始化inode的自引用的weak指针
572         result.0.lock().self_ref = Arc::downgrade(&result);
573 
574         // 将子inode插入父inode的B树中
575         inode.children.insert(String::from(name), result.clone());
576 
577         return Ok(result);
578     }
579 
580     fn link(&self, name: &str, other: &Arc<dyn IndexNode>) -> Result<(), SystemError> {
581         let other: &LockedProcFSInode = other
582             .downcast_ref::<LockedProcFSInode>()
583             .ok_or(SystemError::EPERM)?;
584         let mut inode: SpinLockGuard<ProcFSInode> = self.0.lock();
585         let mut other_locked: SpinLockGuard<ProcFSInode> = other.0.lock();
586 
587         // 如果当前inode不是文件夹，那么报错
588         if inode.metadata.file_type != FileType::Dir {
589             return Err(SystemError::ENOTDIR);
590         }
591 
592         // 如果另一个inode是文件夹，那么也报错
593         if other_locked.metadata.file_type == FileType::Dir {
594             return Err(SystemError::EISDIR);
595         }
596 
597         // 如果当前文件夹下已经有同名文件，也报错。
598         if inode.children.contains_key(name) {
599             return Err(SystemError::EEXIST);
600         }
601 
602         inode
603             .children
604             .insert(String::from(name), other_locked.self_ref.upgrade().unwrap());
605 
606         // 增加硬链接计数
607         other_locked.metadata.nlinks += 1;
608         return Ok(());
609     }
610 
611     fn unlink(&self, name: &str) -> Result<(), SystemError> {
612         let mut inode: SpinLockGuard<ProcFSInode> = self.0.lock();
613         // 如果当前inode不是目录，那么也没有子目录/文件的概念了，因此要求当前inode的类型是目录
614         if inode.metadata.file_type != FileType::Dir {
615             return Err(SystemError::ENOTDIR);
616         }
617         // 不允许删除当前文件夹，也不允许删除上一个目录
618         if name == "." || name == ".." {
619             return Err(SystemError::ENOTEMPTY);
620         }
621 
622         // 获得要删除的文件的inode
623         let to_delete = inode.children.get(name).ok_or(SystemError::ENOENT)?;
624         // 减少硬链接计数
625         to_delete.0.lock().metadata.nlinks -= 1;
626         // 在当前目录中删除这个子目录项
627         inode.children.remove(name);
628         return Ok(());
629     }
630 
631     fn move_(
632         &self,
633         _old_name: &str,
634         _target: &Arc<dyn IndexNode>,
635         _new_name: &str,
636     ) -> Result<(), SystemError> {
637         return Err(SystemError::EOPNOTSUPP_OR_ENOTSUP);
638     }
639 
640     fn find(&self, name: &str) -> Result<Arc<dyn IndexNode>, SystemError> {
641         let inode = self.0.lock();
642 
643         if inode.metadata.file_type != FileType::Dir {
644             return Err(SystemError::ENOTDIR);
645         }
646 
647         match name {
648             "" | "." => {
649                 return Ok(inode.self_ref.upgrade().ok_or(SystemError::ENOENT)?);
650             }
651 
652             ".." => {
653                 return Ok(inode.parent.upgrade().ok_or(SystemError::ENOENT)?);
654             }
655             name => {
656                 // 在子目录项中查找
657                 return Ok(inode.children.get(name).ok_or(SystemError::ENOENT)?.clone());
658             }
659         }
660     }
661 
662     fn get_entry_name(&self, ino: InodeId) -> Result<String, SystemError> {
663         let inode: SpinLockGuard<ProcFSInode> = self.0.lock();
664         if inode.metadata.file_type != FileType::Dir {
665             return Err(SystemError::ENOTDIR);
666         }
667 
668         match ino.into() {
669             0 => {
670                 return Ok(String::from("."));
671             }
672             1 => {
673                 return Ok(String::from(".."));
674             }
675             ino => {
676                 // 暴力遍历所有的children，判断inode id是否相同
677                 // TODO: 优化这里，这个地方性能很差！
678                 let mut key: Vec<String> = inode
679                     .children
680                     .keys()
681                     .filter(|k| {
682                         inode
683                             .children
684                             .get(*k)
685                             .unwrap()
686                             .0
687                             .lock()
688                             .metadata
689                             .inode_id
690                             .into()
691                             == ino
692                     })
693                     .cloned()
694                     .collect();
695 
696                 match key.len() {
697                         0=>{return Err(SystemError::ENOENT);}
698                         1=>{return Ok(key.remove(0));}
699                         _ => panic!("Procfs get_entry_name: key.len()={key_len}>1, current inode_id={inode_id:?}, to find={to_find:?}", key_len=key.len(), inode_id = inode.metadata.inode_id, to_find=ino)
700                     }
701             }
702         }
703     }
704 
705     fn list(&self) -> Result<Vec<String>, SystemError> {
706         let info = self.metadata()?;
707         if info.file_type != FileType::Dir {
708             return Err(SystemError::ENOTDIR);
709         }
710 
711         let mut keys: Vec<String> = Vec::new();
712         keys.push(String::from("."));
713         keys.push(String::from(".."));
714         keys.append(&mut self.0.lock().children.keys().cloned().collect());
715 
716         return Ok(keys);
717     }
718 }
719 
720 /// @brief 向procfs注册进程
721 pub fn procfs_register_pid(pid: Pid) -> Result<(), SystemError> {
722     let procfs_inode = ROOT_INODE().find("proc")?;
723 
724     let procfs_inode = procfs_inode
725         .downcast_ref::<LockedProcFSInode>()
726         .expect("Failed to find procfs' root inode");
727     let fs = procfs_inode.fs();
728     let procfs: &ProcFS = fs.as_any_ref().downcast_ref::<ProcFS>().unwrap();
729 
730     // 调用注册函数
731     procfs.register_pid(pid)?;
732 
733     return Ok(());
734 }
735 
736 /// @brief 在ProcFS中,解除进程的注册
737 pub fn procfs_unregister_pid(pid: Pid) -> Result<(), SystemError> {
738     // 获取procfs实例
739     let procfs_inode: Arc<dyn IndexNode> = ROOT_INODE().find("proc")?;
740 
741     let procfs_inode: &LockedProcFSInode = procfs_inode
742         .downcast_ref::<LockedProcFSInode>()
743         .expect("Failed to find procfs' root inode");
744     let fs: Arc<dyn FileSystem> = procfs_inode.fs();
745     let procfs: &ProcFS = fs.as_any_ref().downcast_ref::<ProcFS>().unwrap();
746 
747     // 调用解除注册函数
748     return procfs.unregister_pid(pid);
749 }
750 
751 pub fn procfs_init() -> Result<(), SystemError> {
752     static INIT: Once = Once::new();
753     let mut result = None;
754     INIT.call_once(|| {
755         kinfo!("Initializing ProcFS...");
756         // 创建 procfs 实例
757         let procfs: Arc<ProcFS> = ProcFS::new();
758 
759         // procfs 挂载
760         let _t = ROOT_INODE()
761             .find("proc")
762             .expect("Cannot find /proc")
763             .mount(procfs)
764             .expect("Failed to mount proc");
765         kinfo!("ProcFS mounted.");
766         result = Some(Ok(()));
767     });
768 
769     return result.unwrap();
770 }
771