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