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