1 use core::{cmp::min, fmt::Debug, intrinsics::unlikely}; 2 3 use alloc::{ 4 string::String, 5 sync::{Arc, Weak}, 6 vec::Vec, 7 }; 8 use hashbrown::HashMap; 9 use system_error::SystemError; 10 11 use crate::{ 12 driver::base::device::device_number::DeviceNumber, 13 libs::{ 14 casting::DowncastArc, 15 rwlock::RwLock, 16 spinlock::{SpinLock, SpinLockGuard}, 17 }, 18 time::TimeSpec, 19 }; 20 21 use self::callback::{KernCallbackData, KernFSCallback, KernInodePrivateData}; 22 23 use super::vfs::{ 24 core::generate_inode_id, file::FileMode, syscall::ModeType, FilePrivateData, FileSystem, 25 FileType, FsInfo, IndexNode, InodeId, Metadata, 26 }; 27 28 pub mod callback; 29 30 #[derive(Debug)] 31 pub struct KernFS { 32 root_inode: Arc<KernFSInode>, 33 } 34 35 impl FileSystem for KernFS { 36 fn as_any_ref(&self) -> &dyn core::any::Any { 37 self 38 } 39 40 fn info(&self) -> FsInfo { 41 return FsInfo { 42 blk_dev_id: 0, 43 max_name_len: KernFS::MAX_NAMELEN, 44 }; 45 } 46 47 fn root_inode(&self) -> Arc<dyn IndexNode> { 48 return self.root_inode.clone(); 49 } 50 } 51 52 impl KernFS { 53 pub const MAX_NAMELEN: usize = 4096; 54 55 #[allow(dead_code)] 56 pub fn new() -> Arc<Self> { 57 let root_inode = Self::create_root_inode(); 58 let fs = Arc::new(Self { 59 root_inode: root_inode.clone(), 60 }); 61 62 { 63 let ptr = root_inode.as_ref() as *const KernFSInode as *mut KernFSInode; 64 unsafe { 65 (*ptr).self_ref = Arc::downgrade(&root_inode); 66 } 67 } 68 root_inode.inner.write().parent = Arc::downgrade(&root_inode); 69 *root_inode.fs.write() = Arc::downgrade(&fs); 70 return fs; 71 } 72 73 fn create_root_inode() -> Arc<KernFSInode> { 74 let metadata = Metadata { 75 size: 0, 76 mode: ModeType::from_bits_truncate(0o755), 77 uid: 0, 78 gid: 0, 79 blk_size: 0, 80 blocks: 0, 81 atime: TimeSpec::new(0, 0), 82 mtime: TimeSpec::new(0, 0), 83 ctime: TimeSpec::new(0, 0), 84 dev_id: 0, 85 inode_id: generate_inode_id(), 86 file_type: FileType::Dir, 87 nlinks: 1, 88 raw_dev: DeviceNumber::default(), 89 }; 90 let root_inode = Arc::new(KernFSInode { 91 name: String::from(""), 92 inner: RwLock::new(InnerKernFSInode { 93 parent: Weak::new(), 94 metadata, 95 symlink_target: None, 96 symlink_target_absolute_path: None, 97 }), 98 self_ref: Weak::new(), 99 fs: RwLock::new(Weak::new()), 100 private_data: SpinLock::new(None), 101 callback: None, 102 children: SpinLock::new(HashMap::new()), 103 inode_type: KernInodeType::Dir, 104 }); 105 106 return root_inode; 107 } 108 } 109 110 #[derive(Debug)] 111 pub struct KernFSInode { 112 inner: RwLock<InnerKernFSInode>, 113 /// 指向当前Inode所属的文件系统的弱引用 114 fs: RwLock<Weak<KernFS>>, 115 /// 指向自身的弱引用 116 self_ref: Weak<KernFSInode>, 117 /// 私有数据 118 private_data: SpinLock<Option<KernInodePrivateData>>, 119 /// 回调函数 120 callback: Option<&'static dyn KernFSCallback>, 121 /// 子Inode 122 children: SpinLock<HashMap<String, Arc<KernFSInode>>>, 123 /// Inode类型 124 inode_type: KernInodeType, 125 /// Inode名称 126 name: String, 127 } 128 129 #[derive(Debug)] 130 pub struct InnerKernFSInode { 131 parent: Weak<KernFSInode>, 132 133 /// 当前inode的元数据 134 metadata: Metadata, 135 /// 符号链接指向的inode（仅当inode_type为SymLink时有效） 136 symlink_target: Option<Weak<KernFSInode>>, 137 symlink_target_absolute_path: Option<String>, 138 } 139 140 impl IndexNode for KernFSInode { 141 fn as_any_ref(&self) -> &dyn core::any::Any { 142 self 143 } 144 145 fn open(&self, _data: &mut FilePrivateData, _mode: &FileMode) -> Result<(), SystemError> { 146 if let Some(callback) = self.callback { 147 let callback_data = 148 KernCallbackData::new(self.self_ref.upgrade().unwrap(), self.private_data.lock()); 149 return callback.open(callback_data); 150 } 151 152 return Ok(()); 153 } 154 155 fn close(&self, _data: &mut FilePrivateData) -> Result<(), SystemError> { 156 return Ok(()); 157 } 158 159 fn metadata(&self) -> Result<Metadata, SystemError> { 160 return Ok(self.inner.read().metadata.clone()); 161 } 162 163 fn set_metadata(&self, _metadata: &Metadata) -> Result<(), SystemError> { 164 // 若文件系统没有实现此方法，则返回“不支持” 165 return Err(SystemError::EOPNOTSUPP_OR_ENOTSUP); 166 } 167 168 fn resize(&self, _len: usize) -> Result<(), SystemError> { 169 return Ok(()); 170 } 171 172 fn create_with_data( 173 &self, 174 _name: &str, 175 _file_type: FileType, 176 _mode: ModeType, 177 _data: usize, 178 ) -> Result<Arc<dyn IndexNode>, SystemError> { 179 // 应当通过kernfs的其它方法来创建文件，而不能从用户态直接调用此方法。 180 return Err(SystemError::EOPNOTSUPP_OR_ENOTSUP); 181 } 182 183 fn link(&self, _name: &str, _other: &Arc<dyn IndexNode>) -> Result<(), SystemError> { 184 // 应当通过kernfs的其它方法来操作文件，而不能从用户态直接调用此方法。 185 return Err(SystemError::EOPNOTSUPP_OR_ENOTSUP); 186 } 187 188 fn unlink(&self, _name: &str) -> Result<(), SystemError> { 189 // 应当通过kernfs的其它方法来操作文件，而不能从用户态直接调用此方法。 190 return Err(SystemError::EOPNOTSUPP_OR_ENOTSUP); 191 } 192 193 fn rmdir(&self, _name: &str) -> Result<(), SystemError> { 194 // 应当通过kernfs的其它方法来操作文件，而不能从用户态直接调用此方法。 195 return Err(SystemError::EOPNOTSUPP_OR_ENOTSUP); 196 } 197 198 fn move_( 199 &self, 200 _old_name: &str, 201 _target: &Arc<dyn IndexNode>, 202 _new_name: &str, 203 ) -> Result<(), SystemError> { 204 // 应当通过kernfs的其它方法来操作文件，而不能从用户态直接调用此方法。 205 return Err(SystemError::EOPNOTSUPP_OR_ENOTSUP); 206 } 207 208 fn find(&self, name: &str) -> Result<Arc<dyn IndexNode>, SystemError> { 209 if unlikely(name.len() > KernFS::MAX_NAMELEN) { 210 return Err(SystemError::ENAMETOOLONG); 211 } 212 if unlikely(self.inode_type != KernInodeType::Dir) { 213 return Err(SystemError::ENOTDIR); 214 } 215 match name { 216 "" | "." => { 217 return Ok(self.self_ref.upgrade().ok_or(SystemError::ENOENT)?); 218 } 219 220 ".." => { 221 return Ok(self 222 .inner 223 .read() 224 .parent 225 .upgrade() 226 .ok_or(SystemError::ENOENT)?); 227 } 228 name => { 229 // 在子目录项中查找 230 return Ok(self 231 .children 232 .lock() 233 .get(name) 234 .ok_or(SystemError::ENOENT)? 235 .clone()); 236 } 237 } 238 } 239 240 fn get_entry_name(&self, ino: InodeId) -> Result<String, SystemError> { 241 if self.inode_type != KernInodeType::Dir { 242 return Err(SystemError::ENOTDIR); 243 } 244 245 let children = self.children.lock(); 246 let r = children 247 .iter() 248 .find(|(_, v)| v.metadata().unwrap().inode_id == ino) 249 .map(|(k, _)| k.clone()); 250 251 return r.ok_or(SystemError::ENOENT); 252 } 253 254 fn get_entry_name_and_metadata(&self, ino: InodeId) -> Result<(String, Metadata), SystemError> { 255 // 如果有条件，请在文件系统中使用高效的方式实现本接口，而不是依赖这个低效率的默认实现。 256 let name = self.get_entry_name(ino)?; 257 let entry = self.find(&name)?; 258 return Ok((name, entry.metadata()?)); 259 } 260 261 fn ioctl( 262 &self, 263 _cmd: u32, 264 _data: usize, 265 _private_data: &FilePrivateData, 266 ) -> Result<usize, SystemError> { 267 // 若文件系统没有实现此方法，则返回“不支持” 268 return Err(SystemError::EOPNOTSUPP_OR_ENOTSUP); 269 } 270 271 fn truncate(&self, _len: usize) -> Result<(), SystemError> { 272 // 应当通过kernfs的其它方法来操作文件，而不能从用户态直接调用此方法。 273 return Err(SystemError::EOPNOTSUPP_OR_ENOTSUP); 274 } 275 276 fn sync(&self) -> Result<(), SystemError> { 277 return Ok(()); 278 } 279 280 fn fs(&self) -> Arc<dyn FileSystem> { 281 return self.fs.read().upgrade().unwrap(); 282 } 283 284 fn list(&self) -> Result<Vec<String>, SystemError> { 285 let info = self.metadata()?; 286 if info.file_type != FileType::Dir { 287 return Err(SystemError::ENOTDIR); 288 } 289 290 let mut keys: Vec<String> = Vec::new(); 291 keys.push(String::from(".")); 292 keys.push(String::from("..")); 293 self.children 294 .lock() 295 .keys() 296 .into_iter() 297 .for_each(|x| keys.push(x.clone())); 298 299 return Ok(keys); 300 } 301 302 fn read_at( 303 &self, 304 offset: usize, 305 len: usize, 306 buf: &mut [u8], 307 _data: &mut FilePrivateData, 308 ) -> Result<usize, SystemError> { 309 if self.inode_type == KernInodeType::SymLink { 310 let inner = self.inner.read(); 311 if offset >= inner.symlink_target_absolute_path.as_ref().unwrap().len() { 312 return Ok(0); 313 } 314 let len = min(len, buf.len()); 315 let len = min( 316 len, 317 inner.symlink_target_absolute_path.as_ref().unwrap().len() - offset, 318 ); 319 buf[0..len].copy_from_slice( 320 &inner 321 .symlink_target_absolute_path 322 .as_ref() 323 .unwrap() 324 .as_bytes()[offset..offset + len], 325 ); 326 return Ok(len); 327 } 328 if self.inode_type != KernInodeType::File { 329 return Err(SystemError::EISDIR); 330 } 331 332 if self.callback.is_none() { 333 kwarn!("kernfs: callback is none"); 334 return Err(SystemError::EOPNOTSUPP_OR_ENOTSUP); 335 } 336 337 let callback_data = 338 KernCallbackData::new(self.self_ref.upgrade().unwrap(), self.private_data.lock()); 339 return self 340 .callback 341 .as_ref() 342 .unwrap() 343 .read(callback_data, &mut buf[..len], offset); 344 } 345 346 fn write_at( 347 &self, 348 offset: usize, 349 len: usize, 350 buf: &[u8], 351 _data: &mut FilePrivateData, 352 ) -> Result<usize, SystemError> { 353 if self.inode_type != KernInodeType::File { 354 return Err(SystemError::EISDIR); 355 } 356 357 if self.callback.is_none() { 358 return Err(SystemError::EOPNOTSUPP_OR_ENOTSUP); 359 } 360 361 let callback_data = 362 KernCallbackData::new(self.self_ref.upgrade().unwrap(), self.private_data.lock()); 363 return self 364 .callback 365 .as_ref() 366 .unwrap() 367 .write(callback_data, &buf[..len], offset); 368 } 369 } 370 371 impl KernFSInode { 372 pub fn new( 373 parent: Option<Arc<KernFSInode>>, 374 name: String, 375 mut metadata: Metadata, 376 inode_type: KernInodeType, 377 private_data: Option<KernInodePrivateData>, 378 callback: Option<&'static dyn KernFSCallback>, 379 ) -> Arc<KernFSInode> { 380 metadata.file_type = inode_type.into(); 381 let parent: Weak<KernFSInode> = parent.map(|x| Arc::downgrade(&x)).unwrap_or_default(); 382 383 let inode = Arc::new(KernFSInode { 384 name, 385 inner: RwLock::new(InnerKernFSInode { 386 parent: parent.clone(), 387 metadata, 388 symlink_target: None, 389 symlink_target_absolute_path: None, 390 }), 391 self_ref: Weak::new(), 392 fs: RwLock::new(Weak::new()), 393 private_data: SpinLock::new(private_data), 394 callback, 395 children: SpinLock::new(HashMap::new()), 396 inode_type, 397 }); 398 399 { 400 let ptr = inode.as_ref() as *const KernFSInode as *mut KernFSInode; 401 unsafe { 402 (*ptr).self_ref = Arc::downgrade(&inode); 403 } 404 } 405 if parent.strong_count() > 0 { 406 let kernfs = parent 407 .upgrade() 408 .unwrap() 409 .fs() 410 .downcast_arc::<KernFS>() 411 .expect("KernFSInode::new: parent is not a KernFS instance"); 412 *inode.fs.write() = Arc::downgrade(&kernfs); 413 } 414 return inode; 415 } 416 417 /// 在当前inode下增加子目录 418 /// 419 /// ## 参数 420 /// 421 /// - `name`：子目录名称 422 /// - `mode`：子目录权限 423 /// - `private_data`：子目录私有数据 424 /// - `callback`：子目录回调函数 425 /// 426 /// ## 返回值 427 /// 428 /// - 成功：子目录inode 429 /// - 失败：错误码 430 #[allow(dead_code)] 431 #[inline] 432 pub fn add_dir( 433 &self, 434 name: String, 435 mode: ModeType, 436 private_data: Option<KernInodePrivateData>, 437 callback: Option<&'static dyn KernFSCallback>, 438 ) -> Result<Arc<KernFSInode>, SystemError> { 439 if unlikely(self.inode_type != KernInodeType::Dir) { 440 return Err(SystemError::ENOTDIR); 441 } 442 443 return self.inner_create(name, KernInodeType::Dir, mode, 0, private_data, callback); 444 } 445 446 /// 在当前inode下增加文件 447 /// 448 /// ## 参数 449 /// 450 /// - `name`：文件名称 451 /// - `mode`：文件权限 452 /// - `size`：文件大小(如果不指定，则默认为4096) 453 /// - `private_data`：文件私有数据 454 /// - `callback`：文件回调函数 455 /// 456 /// 457 /// ## 返回值 458 /// 459 /// - 成功：文件inode 460 /// - 失败：错误码 461 #[allow(dead_code)] 462 #[inline] 463 pub fn add_file( 464 &self, 465 name: String, 466 mode: ModeType, 467 size: Option<usize>, 468 private_data: Option<KernInodePrivateData>, 469 callback: Option<&'static dyn KernFSCallback>, 470 ) -> Result<Arc<KernFSInode>, SystemError> { 471 if unlikely(self.inode_type != KernInodeType::Dir) { 472 return Err(SystemError::ENOTDIR); 473 } 474 475 let size = size.unwrap_or(4096); 476 return self.inner_create( 477 name, 478 KernInodeType::File, 479 mode, 480 size, 481 private_data, 482 callback, 483 ); 484 } 485 486 fn inner_create( 487 &self, 488 name: String, 489 file_type: KernInodeType, 490 mode: ModeType, 491 mut size: usize, 492 private_data: Option<KernInodePrivateData>, 493 callback: Option<&'static dyn KernFSCallback>, 494 ) -> Result<Arc<KernFSInode>, SystemError> { 495 match file_type { 496 KernInodeType::Dir | KernInodeType::SymLink => { 497 size = 0; 498 } 499 _ => {} 500 } 501 502 let metadata = Metadata { 503 size: size as i64, 504 mode, 505 uid: 0, 506 gid: 0, 507 blk_size: 0, 508 blocks: 0, 509 atime: TimeSpec::new(0, 0), 510 mtime: TimeSpec::new(0, 0), 511 ctime: TimeSpec::new(0, 0), 512 dev_id: 0, 513 inode_id: generate_inode_id(), 514 file_type: file_type.into(), 515 nlinks: 1, 516 raw_dev: DeviceNumber::default(), 517 }; 518 519 let new_inode: Arc<KernFSInode> = Self::new( 520 Some(self.self_ref.upgrade().unwrap()), 521 name.clone(), 522 metadata, 523 file_type, 524 private_data, 525 callback, 526 ); 527 528 self.children.lock().insert(name, new_inode.clone()); 529 530 return Ok(new_inode); 531 } 532 533 /// 在当前inode下删除子目录或者文件 534 /// 535 /// 如果要删除的是子目录，且子目录不为空，则返回ENOTEMPTY 536 /// 537 /// ## 参数 538 /// 539 /// - `name`：子目录或者文件名称 540 /// 541 /// ## 返回值 542 /// 543 /// - 成功：() 544 /// - 失败：错误码 545 #[allow(dead_code)] 546 pub fn remove(&self, name: &str) -> Result<(), SystemError> { 547 if unlikely(self.inode_type != KernInodeType::Dir) { 548 return Err(SystemError::ENOTDIR); 549 } 550 551 let mut children = self.children.lock(); 552 let inode = children.get(name).ok_or(SystemError::ENOENT)?; 553 if inode.children.lock().is_empty() { 554 children.remove(name); 555 return Ok(()); 556 } else { 557 return Err(SystemError::ENOTEMPTY); 558 } 559 } 560 561 /// add_link - create a symlink in kernfs 562 /// 563 /// ## 参数 564 /// 565 /// - `parent`: directory to create the symlink in 566 /// - `name`: name of the symlink 567 /// - `target`: target node for the symlink to point to 568 /// 569 /// Returns the created node on success 570 /// 571 /// 参考 https://code.dragonos.org.cn/xref/linux-6.1.9/fs/kernfs/symlink.c#25 572 pub fn add_link( 573 &self, 574 name: String, 575 target: &Arc<KernFSInode>, 576 target_absolute_path: String, 577 ) -> Result<Arc<KernFSInode>, SystemError> { 578 // kdebug!("kernfs add link: name:{name}, target path={target_absolute_path}"); 579 let inode = self.inner_create( 580 name, 581 KernInodeType::SymLink, 582 ModeType::S_IFLNK | ModeType::from_bits_truncate(0o777), 583 0, 584 None, 585 None, 586 )?; 587 588 inode.inner.write().symlink_target = Some(Arc::downgrade(target)); 589 inode.inner.write().symlink_target_absolute_path = Some(target_absolute_path); 590 return Ok(inode); 591 } 592 593 pub fn name(&self) -> &str { 594 return &self.name; 595 } 596 597 pub fn parent(&self) -> Option<Arc<KernFSInode>> { 598 return self.inner.read().parent.upgrade(); 599 } 600 601 pub fn private_data_mut(&self) -> SpinLockGuard<Option<KernInodePrivateData>> { 602 return self.private_data.lock(); 603 } 604 605 #[allow(dead_code)] 606 pub fn symlink_target(&self) -> Option<Arc<KernFSInode>> { 607 return self.inner.read().symlink_target.as_ref()?.upgrade(); 608 } 609 610 /// remove a kernfs_node recursively 611 pub fn remove_recursive(&self) { 612 let mut children = self.children.lock().drain().collect::<Vec<_>>(); 613 while let Some((_, child)) = children.pop() { 614 children.append(&mut child.children.lock().drain().collect::<Vec<_>>()); 615 } 616 } 617 618 /// 删除当前的inode（包括其自身、子目录和子文件） 619 #[allow(dead_code)] 620 pub fn remove_inode_include_self(&self) { 621 let parent = self.parent(); 622 if let Some(parent) = parent { 623 parent.children.lock().remove(self.name()); 624 } 625 self.remove_recursive(); 626 } 627 } 628 #[derive(Debug, Clone, Copy, PartialEq, Eq)] 629 pub enum KernInodeType { 630 Dir, 631 File, 632 SymLink, 633 } 634 635 impl Into<FileType> for KernInodeType { 636 fn into(self) -> FileType { 637 match self { 638 KernInodeType::Dir => FileType::Dir, 639 KernInodeType::File => FileType::File, 640 KernInodeType::SymLink => FileType::SymLink, 641 } 642 } 643 } 644