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