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