1 /// 导出devfs的模块 2 pub mod null_dev; 3 pub mod zero_dev; 4 5 use super::vfs::{ 6 core::{generate_inode_id, ROOT_INODE}, 7 file::FileMode, 8 syscall::ModeType, 9 utils::DName, 10 FilePrivateData, FileSystem, FileType, FsInfo, IndexNode, Magic, Metadata, SuperBlock, 11 }; 12 use crate::{ 13 driver::base::device::device_number::DeviceNumber, 14 libs::{ 15 once::Once, 16 spinlock::{SpinLock, SpinLockGuard}, 17 }, 18 time::PosixTimeSpec, 19 }; 20 use alloc::{ 21 collections::BTreeMap, 22 string::{String, ToString}, 23 sync::{Arc, Weak}, 24 vec::Vec, 25 }; 26 use log::{error, info}; 27 use system_error::SystemError; 28 29 const DEVFS_BLOCK_SIZE: u64 = 512; 30 const DEVFS_MAX_NAMELEN: usize = 255; 31 /// @brief dev文件系统 32 #[derive(Debug)] 33 pub struct DevFS { 34 // 文件系统根节点 35 root_inode: Arc<LockedDevFSInode>, 36 super_block: SuperBlock, 37 } 38 39 impl FileSystem for DevFS { 40 fn as_any_ref(&self) -> &dyn core::any::Any { 41 self 42 } 43 44 fn root_inode(&self) -> Arc<dyn super::vfs::IndexNode> { 45 return self.root_inode.clone(); 46 } 47 48 fn info(&self) -> super::vfs::FsInfo { 49 return FsInfo { 50 blk_dev_id: 0, 51 max_name_len: DEVFS_MAX_NAMELEN, 52 }; 53 } 54 55 fn name(&self) -> &str { 56 "devfs" 57 } 58 59 fn super_block(&self) -> SuperBlock { 60 self.super_block.clone() 61 } 62 } 63 64 impl DevFS { 65 pub fn new() -> Arc<Self> { 66 let super_block = SuperBlock::new( 67 Magic::DEVFS_MAGIC, 68 DEVFS_BLOCK_SIZE, 69 DEVFS_MAX_NAMELEN as u64, 70 ); 71 // 初始化root inode 72 let root: Arc<LockedDevFSInode> = Arc::new(LockedDevFSInode(SpinLock::new( 73 // /dev 的权限设置为 读+执行,root 可以读写 74 // root 的 parent 是空指针 75 DevFSInode::new(FileType::Dir, ModeType::from_bits_truncate(0o755), 0), 76 ))); 77 78 let devfs: Arc<DevFS> = Arc::new(DevFS { 79 root_inode: root, 80 super_block, 81 }); 82 83 // 对root inode加锁,并继续完成初始化工作 84 let mut root_guard: SpinLockGuard<DevFSInode> = devfs.root_inode.0.lock(); 85 root_guard.parent = Arc::downgrade(&devfs.root_inode); 86 root_guard.self_ref = Arc::downgrade(&devfs.root_inode); 87 root_guard.fs = Arc::downgrade(&devfs); 88 // 释放锁 89 drop(root_guard); 90 91 // 创建文件夹 92 let root: &Arc<LockedDevFSInode> = &devfs.root_inode; 93 root.add_dir("char") 94 .expect("DevFS: Failed to create /dev/char"); 95 96 root.add_dir("block") 97 .expect("DevFS: Failed to create /dev/block"); 98 devfs.register_bultinin_device(); 99 100 // debug!("ls /dev: {:?}", root.list()); 101 return devfs; 102 } 103 104 /// @brief 注册系统内部自带的设备 105 fn register_bultinin_device(&self) { 106 use null_dev::LockedNullInode; 107 use zero_dev::LockedZeroInode; 108 let dev_root: Arc<LockedDevFSInode> = self.root_inode.clone(); 109 dev_root 110 .add_dev("null", LockedNullInode::new()) 111 .expect("DevFS: Failed to register /dev/null"); 112 dev_root 113 .add_dev("zero", LockedZeroInode::new()) 114 .expect("DevFS: Failed to register /dev/zero"); 115 } 116 117 /// @brief 在devfs内注册设备 118 /// 119 /// @param name 设备名称 120 /// @param device 设备节点的结构体 121 pub fn register_device<T: DeviceINode>( 122 &self, 123 name: &str, 124 device: Arc<T>, 125 ) -> Result<(), SystemError> { 126 let dev_root_inode: Arc<LockedDevFSInode> = self.root_inode.clone(); 127 let metadata = device.metadata()?; 128 match metadata.file_type { 129 // 字节设备挂载在 /dev/char 130 FileType::CharDevice => { 131 if dev_root_inode.find("char").is_err() { 132 dev_root_inode.create( 133 "char", 134 FileType::Dir, 135 ModeType::from_bits_truncate(0o755), 136 )?; 137 } 138 139 let any_char_inode = dev_root_inode.find("char")?; 140 let dev_char_inode: &LockedDevFSInode = any_char_inode 141 .as_any_ref() 142 .downcast_ref::<LockedDevFSInode>() 143 .unwrap(); 144 // 在 /dev/char 下创建设备节点 145 dev_char_inode.add_dev(name, device.clone())?; 146 147 // 特殊处理 tty 设备,挂载在 /dev 下 148 if name.starts_with("tty") && name.len() > 3 { 149 dev_root_inode.add_dev(name, device.clone())?; 150 } 151 // ptmx设备 152 if name == "ptmx" { 153 dev_root_inode.add_dev(name, device.clone())?; 154 } 155 device.set_fs(dev_char_inode.0.lock().fs.clone()); 156 } 157 FileType::BlockDevice => { 158 if dev_root_inode.find("block").is_err() { 159 dev_root_inode.create( 160 "block", 161 FileType::Dir, 162 ModeType::from_bits_truncate(0o755), 163 )?; 164 } 165 166 let any_block_inode = dev_root_inode.find("block")?; 167 let dev_block_inode: &LockedDevFSInode = any_block_inode 168 .as_any_ref() 169 .downcast_ref::<LockedDevFSInode>() 170 .unwrap(); 171 172 dev_block_inode.add_dev(name, device.clone())?; 173 device.set_fs(dev_block_inode.0.lock().fs.clone()); 174 } 175 FileType::KvmDevice => { 176 dev_root_inode 177 .add_dev(name, device.clone()) 178 .expect("DevFS: Failed to register /dev/kvm"); 179 } 180 FileType::FramebufferDevice => { 181 dev_root_inode 182 .add_dev(name, device.clone()) 183 .expect("DevFS: Failed to register /dev/fb"); 184 } 185 _ => { 186 return Err(SystemError::ENOSYS); 187 } 188 } 189 190 return Ok(()); 191 } 192 193 /// @brief 卸载设备 194 pub fn unregister_device<T: DeviceINode>( 195 &self, 196 name: &str, 197 device: Arc<T>, 198 ) -> Result<(), SystemError> { 199 let dev_root_inode: Arc<LockedDevFSInode> = self.root_inode.clone(); 200 match device.metadata().unwrap().file_type { 201 // 字节设备挂载在 /dev/char 202 FileType::CharDevice => { 203 if dev_root_inode.find("char").is_err() { 204 return Err(SystemError::ENOENT); 205 } 206 207 let any_char_inode = dev_root_inode.find("char")?; 208 let dev_char_inode = any_char_inode 209 .as_any_ref() 210 .downcast_ref::<LockedDevFSInode>() 211 .unwrap(); 212 // TODO: 调用设备的卸载接口(当引入卸载接口之后) 213 dev_char_inode.remove(name)?; 214 } 215 FileType::BlockDevice => { 216 if dev_root_inode.find("block").is_err() { 217 return Err(SystemError::ENOENT); 218 } 219 220 let any_block_inode = dev_root_inode.find("block")?; 221 let dev_block_inode = any_block_inode 222 .as_any_ref() 223 .downcast_ref::<LockedDevFSInode>() 224 .unwrap(); 225 226 dev_block_inode.remove(name)?; 227 } 228 _ => { 229 return Err(SystemError::ENOSYS); 230 } 231 } 232 233 return Ok(()); 234 } 235 } 236 237 /// @brief dev文件i节点(锁) 238 #[derive(Debug)] 239 pub struct LockedDevFSInode(SpinLock<DevFSInode>); 240 241 /// @brief dev文件i节点(无锁) 242 #[derive(Debug)] 243 pub struct DevFSInode { 244 /// 指向父Inode的弱引用 245 parent: Weak<LockedDevFSInode>, 246 /// 指向自身的弱引用 247 self_ref: Weak<LockedDevFSInode>, 248 /// 子Inode的B树 249 children: BTreeMap<DName, Arc<dyn IndexNode>>, 250 /// 指向inode所在的文件系统对象的指针 251 fs: Weak<DevFS>, 252 /// INode 元数据 253 metadata: Metadata, 254 /// 目录名 255 dname: DName, 256 } 257 258 impl DevFSInode { 259 pub fn new(dev_type_: FileType, mode: ModeType, data_: usize) -> Self { 260 return Self::new_with_parent(Weak::default(), dev_type_, mode, data_); 261 } 262 263 pub fn new_with_parent( 264 parent: Weak<LockedDevFSInode>, 265 dev_type_: FileType, 266 mode: ModeType, 267 data_: usize, 268 ) -> Self { 269 return DevFSInode { 270 parent, 271 self_ref: Weak::default(), 272 children: BTreeMap::new(), 273 metadata: Metadata { 274 dev_id: 1, 275 inode_id: generate_inode_id(), 276 size: 0, 277 blk_size: 0, 278 blocks: 0, 279 atime: PosixTimeSpec::default(), 280 mtime: PosixTimeSpec::default(), 281 ctime: PosixTimeSpec::default(), 282 file_type: dev_type_, // 文件夹 283 mode, 284 nlinks: 1, 285 uid: 0, 286 gid: 0, 287 raw_dev: DeviceNumber::from(data_ as u32), 288 }, 289 fs: Weak::default(), 290 dname: DName::default(), 291 }; 292 } 293 } 294 295 impl LockedDevFSInode { 296 pub fn add_dir(&self, name: &str) -> Result<(), SystemError> { 297 let guard: SpinLockGuard<DevFSInode> = self.0.lock(); 298 299 if guard.children.contains_key(&DName::from(name)) { 300 return Err(SystemError::EEXIST); 301 } 302 303 match self.do_create_with_data( 304 guard, 305 name, 306 FileType::Dir, 307 ModeType::from_bits_truncate(0o755), 308 0, 309 ) { 310 Ok(inode) => inode, 311 Err(err) => { 312 return Err(err); 313 } 314 }; 315 316 return Ok(()); 317 } 318 319 pub fn add_dev(&self, name: &str, dev: Arc<dyn IndexNode>) -> Result<(), SystemError> { 320 let mut this = self.0.lock(); 321 let name = DName::from(name); 322 if this.children.contains_key(&name) { 323 return Err(SystemError::EEXIST); 324 } 325 326 this.children.insert(name, dev); 327 return Ok(()); 328 } 329 330 pub fn remove(&self, name: &str) -> Result<(), SystemError> { 331 let x = self 332 .0 333 .lock() 334 .children 335 .remove(&DName::from(name)) 336 .ok_or(SystemError::ENOENT)?; 337 338 drop(x); 339 return Ok(()); 340 } 341 342 fn do_create_with_data( 343 &self, 344 mut guard: SpinLockGuard<DevFSInode>, 345 name: &str, 346 file_type: FileType, 347 mode: ModeType, 348 data: usize, 349 ) -> Result<Arc<dyn IndexNode>, SystemError> { 350 if guard.metadata.file_type != FileType::Dir { 351 return Err(SystemError::ENOTDIR); 352 } 353 let name = DName::from(name); 354 // 如果有重名的,则返回 355 if guard.children.contains_key(&name) { 356 return Err(SystemError::EEXIST); 357 } 358 359 // 创建inode 360 let result: Arc<LockedDevFSInode> = Arc::new(LockedDevFSInode(SpinLock::new(DevFSInode { 361 parent: guard.self_ref.clone(), 362 self_ref: Weak::default(), 363 children: BTreeMap::new(), 364 metadata: Metadata { 365 dev_id: 0, 366 inode_id: generate_inode_id(), 367 size: 0, 368 blk_size: 0, 369 blocks: 0, 370 atime: PosixTimeSpec::default(), 371 mtime: PosixTimeSpec::default(), 372 ctime: PosixTimeSpec::default(), 373 file_type, 374 mode, 375 nlinks: 1, 376 uid: 0, 377 gid: 0, 378 raw_dev: DeviceNumber::from(data as u32), 379 }, 380 fs: guard.fs.clone(), 381 dname: name.clone(), 382 }))); 383 384 // 初始化inode的自引用的weak指针 385 result.0.lock().self_ref = Arc::downgrade(&result); 386 387 // 将子inode插入父inode的B树中 388 guard.children.insert(name, result.clone()); 389 return Ok(result); 390 } 391 } 392 393 impl IndexNode for LockedDevFSInode { 394 fn as_any_ref(&self) -> &dyn core::any::Any { 395 self 396 } 397 398 fn open( 399 &self, 400 _data: SpinLockGuard<FilePrivateData>, 401 _mode: &FileMode, 402 ) -> Result<(), SystemError> { 403 return Ok(()); 404 } 405 406 fn close(&self, _data: SpinLockGuard<FilePrivateData>) -> Result<(), SystemError> { 407 return Ok(()); 408 } 409 410 fn create_with_data( 411 &self, 412 name: &str, 413 file_type: FileType, 414 mode: ModeType, 415 data: usize, 416 ) -> Result<Arc<dyn IndexNode>, SystemError> { 417 // 获取当前inode 418 let guard: SpinLockGuard<DevFSInode> = self.0.lock(); 419 // 如果当前inode不是文件夹,则返回 420 return self.do_create_with_data(guard, name, file_type, mode, data); 421 } 422 423 fn find(&self, name: &str) -> Result<Arc<dyn IndexNode>, SystemError> { 424 let inode = self.0.lock(); 425 426 if inode.metadata.file_type != FileType::Dir { 427 return Err(SystemError::ENOTDIR); 428 } 429 430 match name { 431 "" | "." => { 432 return Ok(inode.self_ref.upgrade().ok_or(SystemError::ENOENT)?); 433 } 434 ".." => { 435 return Ok(inode.parent.upgrade().ok_or(SystemError::ENOENT)?); 436 } 437 name => { 438 // 在子目录项中查找 439 return Ok(inode 440 .children 441 .get(&DName::from(name)) 442 .ok_or(SystemError::ENOENT)? 443 .clone()); 444 } 445 } 446 } 447 448 fn fs(&self) -> Arc<dyn FileSystem> { 449 return self.0.lock().fs.upgrade().unwrap(); 450 } 451 452 fn get_entry_name(&self, ino: super::vfs::InodeId) -> Result<String, SystemError> { 453 let inode: SpinLockGuard<DevFSInode> = self.0.lock(); 454 if inode.metadata.file_type != FileType::Dir { 455 return Err(SystemError::ENOTDIR); 456 } 457 458 match ino.into() { 459 0 => { 460 return Ok(String::from(".")); 461 } 462 1 => { 463 return Ok(String::from("..")); 464 } 465 ino => { 466 // 暴力遍历所有的children,判断inode id是否相同 467 // TODO: 优化这里,这个地方性能很差! 468 let mut key: Vec<String> = inode 469 .children 470 .iter() 471 .filter_map(|(k, v)| { 472 if v.metadata().unwrap().inode_id.into() == ino { 473 Some(k.to_string()) 474 } else { 475 None 476 } 477 }) 478 .collect(); 479 480 match key.len() { 481 0=>{return Err(SystemError::ENOENT);} 482 1=>{return Ok(key.remove(0));} 483 _ => panic!("Devfs 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) 484 } 485 } 486 } 487 } 488 489 fn ioctl( 490 &self, 491 _cmd: u32, 492 _data: usize, 493 _private_data: &FilePrivateData, 494 ) -> Result<usize, SystemError> { 495 Err(SystemError::ENOSYS) 496 } 497 498 fn list(&self) -> Result<Vec<String>, SystemError> { 499 let info = self.metadata()?; 500 if info.file_type != FileType::Dir { 501 return Err(SystemError::ENOTDIR); 502 } 503 504 let mut keys: Vec<String> = Vec::new(); 505 keys.push(String::from(".")); 506 keys.push(String::from("..")); 507 keys.append( 508 &mut self 509 .0 510 .lock() 511 .children 512 .keys() 513 .map(ToString::to_string) 514 .collect(), 515 ); 516 517 return Ok(keys); 518 } 519 520 fn metadata(&self) -> Result<Metadata, SystemError> { 521 return Ok(self.0.lock().metadata.clone()); 522 } 523 524 fn set_metadata(&self, metadata: &Metadata) -> Result<(), SystemError> { 525 let mut inode = self.0.lock(); 526 inode.metadata.atime = metadata.atime; 527 inode.metadata.mtime = metadata.mtime; 528 inode.metadata.ctime = metadata.ctime; 529 inode.metadata.mode = metadata.mode; 530 inode.metadata.uid = metadata.uid; 531 inode.metadata.gid = metadata.gid; 532 533 return Ok(()); 534 } 535 536 /// 读设备 - 应该调用设备的函数读写,而不是通过文件系统读写 537 fn read_at( 538 &self, 539 _offset: usize, 540 _len: usize, 541 _buf: &mut [u8], 542 _data: SpinLockGuard<FilePrivateData>, 543 ) -> Result<usize, SystemError> { 544 error!("DevFS: read_at is not supported!"); 545 Err(SystemError::ENOSYS) 546 } 547 548 /// 写设备 - 应该调用设备的函数读写,而不是通过文件系统读写 549 fn write_at( 550 &self, 551 _offset: usize, 552 _len: usize, 553 _buf: &[u8], 554 _data: SpinLockGuard<FilePrivateData>, 555 ) -> Result<usize, SystemError> { 556 Err(SystemError::ENOSYS) 557 } 558 559 fn parent(&self) -> Result<Arc<dyn IndexNode>, SystemError> { 560 let me = self.0.lock(); 561 Ok(me 562 .parent 563 .upgrade() 564 .unwrap_or(me.self_ref.upgrade().unwrap())) 565 } 566 567 fn dname(&self) -> Result<DName, SystemError> { 568 Ok(self.0.lock().dname.clone()) 569 } 570 } 571 572 /// @brief 所有的设备INode都需要额外实现这个trait 573 pub trait DeviceINode: IndexNode { 574 fn set_fs(&self, fs: Weak<DevFS>); 575 // TODO: 增加 unregister 方法 576 } 577 578 /// @brief 获取devfs实例的强类型不可变引用 579 macro_rules! devfs_exact_ref { 580 () => {{ 581 let devfs_inode: Result<Arc<dyn IndexNode>, SystemError> = ROOT_INODE().find("dev"); 582 if let Err(e) = devfs_inode { 583 error!("failed to get DevFS ref. errcode = {:?}", e); 584 return Err(SystemError::ENOENT); 585 } 586 587 let binding = devfs_inode.unwrap(); 588 let devfs_inode: &LockedDevFSInode = binding 589 .as_any_ref() 590 .downcast_ref::<LockedDevFSInode>() 591 .unwrap(); 592 let binding = devfs_inode.fs(); 593 binding 594 } 595 .as_any_ref() 596 .downcast_ref::<DevFS>() 597 .unwrap()}; 598 } 599 /// @brief devfs的设备注册函数 600 pub fn devfs_register<T: DeviceINode>(name: &str, device: Arc<T>) -> Result<(), SystemError> { 601 return devfs_exact_ref!().register_device(name, device); 602 } 603 604 /// @brief devfs的设备卸载函数 605 #[allow(dead_code)] 606 pub fn devfs_unregister<T: DeviceINode>(name: &str, device: Arc<T>) -> Result<(), SystemError> { 607 return devfs_exact_ref!().unregister_device(name, device); 608 } 609 610 pub fn devfs_init() -> Result<(), SystemError> { 611 static INIT: Once = Once::new(); 612 let mut result = None; 613 INIT.call_once(|| { 614 info!("Initializing DevFS..."); 615 // 创建 devfs 实例 616 let devfs: Arc<DevFS> = DevFS::new(); 617 // devfs 挂载 618 ROOT_INODE() 619 .mkdir("dev", ModeType::from_bits_truncate(0o755)) 620 .expect("Unabled to find /dev") 621 .mount(devfs) 622 .expect("Failed to mount at /dev"); 623 info!("DevFS mounted."); 624 result = Some(Ok(())); 625 }); 626 627 return result.unwrap(); 628 } 629