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