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