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