1 use core::any::Any; 2 3 use alloc::{ 4 collections::BTreeMap, 5 string::String, 6 sync::{Arc, Weak}, 7 vec::Vec, 8 }; 9 10 use crate::{ 11 filesystem::vfs::{core::generate_inode_id, FileType}, 12 libs::spinlock::{SpinLock, SpinLockGuard}, 13 syscall::SystemError, 14 time::TimeSpec, 15 }; 16 17 use super::vfs::{ 18 file::FilePrivateData, FileSystem, FsInfo, IndexNode, InodeId, Metadata, PollStatus, 19 }; 20 21 /// RamFS的inode名称的最大长度 22 const RAMFS_MAX_NAMELEN: usize = 64; 23 24 /// @brief 内存文件系统的Inode结构体 25 #[derive(Debug)] 26 struct LockedRamFSInode(SpinLock<RamFSInode>); 27 28 /// @brief 内存文件系统结构体 29 #[derive(Debug)] 30 pub struct RamFS { 31 /// RamFS的root inode 32 root_inode: Arc<LockedRamFSInode>, 33 } 34 35 /// @brief 内存文件系统的Inode结构体(不包含锁) 36 #[derive(Debug)] 37 pub struct RamFSInode { 38 // parent变量目前只在find函数中使用到 39 // 所以只有当inode是文件夹的时候，parent才会生效 40 // 对于文件来说，parent就没什么作用了 41 // 关于parent的说明: 目录不允许有硬链接 42 /// 指向父Inode的弱引用 43 parent: Weak<LockedRamFSInode>, 44 /// 指向自身的弱引用 45 self_ref: Weak<LockedRamFSInode>, 46 /// 子Inode的B树 47 children: BTreeMap<String, Arc<LockedRamFSInode>>, 48 /// 当前inode的数据部分 49 data: Vec<u8>, 50 /// 当前inode的元数据 51 metadata: Metadata, 52 /// 指向inode所在的文件系统对象的指针 53 fs: Weak<RamFS>, 54 } 55 56 impl FileSystem for RamFS { 57 fn root_inode(&self) -> Arc<dyn super::vfs::IndexNode> { 58 return self.root_inode.clone(); 59 } 60 61 fn info(&self) -> FsInfo { 62 return FsInfo { 63 blk_dev_id: 0, 64 max_name_len: RAMFS_MAX_NAMELEN, 65 }; 66 } 67 68 /// @brief 本函数用于实现动态转换。 69 /// 具体的文件系统在实现本函数时，最简单的方式就是：直接返回self 70 fn as_any_ref(&self) -> &dyn Any { 71 self 72 } 73 } 74 75 impl RamFS { 76 pub fn new() -> Arc<Self> { 77 // 初始化root inode 78 let root: Arc<LockedRamFSInode> = Arc::new(LockedRamFSInode(SpinLock::new(RamFSInode { 79 parent: Weak::default(), 80 self_ref: Weak::default(), 81 children: BTreeMap::new(), 82 data: Vec::new(), 83 metadata: Metadata { 84 dev_id: 0, 85 inode_id: generate_inode_id(), 86 size: 0, 87 blk_size: 0, 88 blocks: 0, 89 atime: TimeSpec::default(), 90 mtime: TimeSpec::default(), 91 ctime: TimeSpec::default(), 92 file_type: FileType::Dir, 93 mode: 0o777, 94 nlinks: 1, 95 uid: 0, 96 gid: 0, 97 raw_dev: 0, 98 }, 99 fs: Weak::default(), 100 }))); 101 102 let result: Arc<RamFS> = Arc::new(RamFS { root_inode: root }); 103 104 // 对root inode加锁，并继续完成初始化工作 105 let mut root_guard: SpinLockGuard<RamFSInode> = result.root_inode.0.lock(); 106 root_guard.parent = Arc::downgrade(&result.root_inode); 107 root_guard.self_ref = Arc::downgrade(&result.root_inode); 108 root_guard.fs = Arc::downgrade(&result); 109 // 释放锁 110 drop(root_guard); 111 112 return result; 113 } 114 } 115 116 impl IndexNode for LockedRamFSInode { 117 fn truncate(&self, len: usize) -> Result<(), SystemError> { 118 let mut inode = self.0.lock(); 119 120 //如果是文件夹，则报错 121 if inode.metadata.file_type == FileType::Dir { 122 return Err(SystemError::EINVAL); 123 } 124 125 //当前文件长度大于_len才进行截断，否则不操作 126 if inode.data.len() > len { 127 inode.data.resize(len, 0); 128 } 129 return Ok(()); 130 } 131 132 fn close(&self, _data: &mut FilePrivateData) -> Result<(), SystemError> { 133 return Ok(()); 134 } 135 136 fn open( 137 &self, 138 _data: &mut FilePrivateData, 139 _mode: &super::vfs::file::FileMode, 140 ) -> Result<(), SystemError> { 141 return Ok(()); 142 } 143 144 fn read_at( 145 &self, 146 offset: usize, 147 len: usize, 148 buf: &mut [u8], 149 _data: &mut FilePrivateData, 150 ) -> Result<usize, SystemError> { 151 if buf.len() < len { 152 return Err(SystemError::EINVAL); 153 } 154 // 加锁 155 let inode: SpinLockGuard<RamFSInode> = self.0.lock(); 156 157 // 检查当前inode是否为一个文件夹，如果是的话，就返回错误 158 if inode.metadata.file_type == FileType::Dir { 159 return Err(SystemError::EISDIR); 160 } 161 162 let start = inode.data.len().min(offset); 163 let end = inode.data.len().min(offset + len); 164 165 // buffer空间不足 166 if buf.len() < (end - start) { 167 return Err(SystemError::ENOBUFS); 168 } 169 170 // 拷贝数据 171 let src = &inode.data[start..end]; 172 buf[0..src.len()].copy_from_slice(src); 173 return Ok(src.len()); 174 } 175 176 fn write_at( 177 &self, 178 offset: usize, 179 len: usize, 180 buf: &[u8], 181 _data: &mut FilePrivateData, 182 ) -> Result<usize, SystemError> { 183 if buf.len() < len { 184 return Err(SystemError::EINVAL); 185 } 186 187 // 加锁 188 let mut inode: SpinLockGuard<RamFSInode> = self.0.lock(); 189 190 // 检查当前inode是否为一个文件夹，如果是的话，就返回错误 191 if inode.metadata.file_type == FileType::Dir { 192 return Err(SystemError::EISDIR); 193 } 194 195 let data: &mut Vec<u8> = &mut inode.data; 196 197 // 如果文件大小比原来的大，那就resize这个数组 198 if offset + len > data.len() { 199 data.resize(offset + len, 0); 200 } 201 202 let target = &mut data[offset..offset + len]; 203 target.copy_from_slice(&buf[0..len]); 204 return Ok(len); 205 } 206 207 fn poll(&self) -> Result<PollStatus, SystemError> { 208 // 加锁 209 let inode: SpinLockGuard<RamFSInode> = self.0.lock(); 210 211 // 检查当前inode是否为一个文件夹，如果是的话，就返回错误 212 if inode.metadata.file_type == FileType::Dir { 213 return Err(SystemError::EISDIR); 214 } 215 216 return Ok(PollStatus::READ | PollStatus::WRITE); 217 } 218 219 fn fs(&self) -> Arc<dyn FileSystem> { 220 return self.0.lock().fs.upgrade().unwrap(); 221 } 222 223 fn as_any_ref(&self) -> &dyn core::any::Any { 224 self 225 } 226 227 fn metadata(&self) -> Result<Metadata, SystemError> { 228 let inode = self.0.lock(); 229 let mut metadata = inode.metadata.clone(); 230 metadata.size = inode.data.len() as i64; 231 232 return Ok(metadata); 233 } 234 235 fn set_metadata(&self, metadata: &Metadata) -> Result<(), SystemError> { 236 let mut inode = self.0.lock(); 237 inode.metadata.atime = metadata.atime; 238 inode.metadata.mtime = metadata.mtime; 239 inode.metadata.ctime = metadata.ctime; 240 inode.metadata.mode = metadata.mode; 241 inode.metadata.uid = metadata.uid; 242 inode.metadata.gid = metadata.gid; 243 244 return Ok(()); 245 } 246 247 fn resize(&self, len: usize) -> Result<(), SystemError> { 248 let mut inode = self.0.lock(); 249 if inode.metadata.file_type == FileType::File { 250 inode.data.resize(len, 0); 251 return Ok(()); 252 } else { 253 return Err(SystemError::EINVAL); 254 } 255 } 256 257 fn create_with_data( 258 &self, 259 name: &str, 260 file_type: FileType, 261 mode: u32, 262 data: usize, 263 ) -> Result<Arc<dyn IndexNode>, SystemError> { 264 // 获取当前inode 265 let mut inode = self.0.lock(); 266 // 如果当前inode不是文件夹，则返回 267 if inode.metadata.file_type != FileType::Dir { 268 return Err(SystemError::ENOTDIR); 269 } 270 // 如果有重名的，则返回 271 if inode.children.contains_key(name) { 272 return Err(SystemError::EEXIST); 273 } 274 275 // 创建inode 276 let result: Arc<LockedRamFSInode> = Arc::new(LockedRamFSInode(SpinLock::new(RamFSInode { 277 parent: inode.self_ref.clone(), 278 self_ref: Weak::default(), 279 children: BTreeMap::new(), 280 data: Vec::new(), 281 metadata: Metadata { 282 dev_id: 0, 283 inode_id: generate_inode_id(), 284 size: 0, 285 blk_size: 0, 286 blocks: 0, 287 atime: TimeSpec::default(), 288 mtime: TimeSpec::default(), 289 ctime: TimeSpec::default(), 290 file_type: file_type, 291 mode: mode, 292 nlinks: 1, 293 uid: 0, 294 gid: 0, 295 raw_dev: data, 296 }, 297 fs: inode.fs.clone(), 298 }))); 299 300 // 初始化inode的自引用的weak指针 301 result.0.lock().self_ref = Arc::downgrade(&result); 302 303 // 将子inode插入父inode的B树中 304 inode.children.insert(String::from(name), result.clone()); 305 306 return Ok(result); 307 } 308 309 fn link(&self, name: &str, other: &Arc<dyn IndexNode>) -> Result<(), SystemError> { 310 let other: &LockedRamFSInode = other 311 .downcast_ref::<LockedRamFSInode>() 312 .ok_or(SystemError::EPERM)?; 313 let mut inode: SpinLockGuard<RamFSInode> = self.0.lock(); 314 let mut other_locked: SpinLockGuard<RamFSInode> = other.0.lock(); 315 316 // 如果当前inode不是文件夹，那么报错 317 if inode.metadata.file_type != FileType::Dir { 318 return Err(SystemError::ENOTDIR); 319 } 320 321 // 如果另一个inode是文件夹，那么也报错 322 if other_locked.metadata.file_type == FileType::Dir { 323 return Err(SystemError::EISDIR); 324 } 325 326 // 如果当前文件夹下已经有同名文件，也报错。 327 if inode.children.contains_key(name) { 328 return Err(SystemError::EEXIST); 329 } 330 331 inode 332 .children 333 .insert(String::from(name), other_locked.self_ref.upgrade().unwrap()); 334 335 // 增加硬链接计数 336 other_locked.metadata.nlinks += 1; 337 return Ok(()); 338 } 339 340 fn unlink(&self, name: &str) -> Result<(), SystemError> { 341 let mut inode: SpinLockGuard<RamFSInode> = self.0.lock(); 342 // 如果当前inode不是目录，那么也没有子目录/文件的概念了，因此要求当前inode的类型是目录 343 if inode.metadata.file_type != FileType::Dir { 344 return Err(SystemError::ENOTDIR); 345 } 346 // 不允许删除当前文件夹，也不允许删除上一个目录 347 if name == "." || name == ".." { 348 return Err(SystemError::ENOTEMPTY); 349 } 350 351 // 获得要删除的文件的inode 352 let to_delete = inode.children.get(name).ok_or(SystemError::ENOENT)?; 353 if to_delete.0.lock().metadata.file_type == FileType::Dir { 354 return Err(SystemError::EPERM); 355 } 356 // 减少硬链接计数 357 to_delete.0.lock().metadata.nlinks -= 1; 358 // 在当前目录中删除这个子目录项 359 inode.children.remove(name); 360 return Ok(()); 361 } 362 363 fn rmdir(&self, name: &str) -> Result<(), SystemError> { 364 let mut inode: SpinLockGuard<RamFSInode> = self.0.lock(); 365 // 如果当前inode不是目录，那么也没有子目录/文件的概念了，因此要求当前inode的类型是目录 366 if inode.metadata.file_type != FileType::Dir { 367 return Err(SystemError::ENOTDIR); 368 } 369 // 获得要删除的文件夹的inode 370 let to_delete = inode.children.get(name).ok_or(SystemError::ENOENT)?; 371 if to_delete.0.lock().metadata.file_type != FileType::Dir { 372 return Err(SystemError::ENOTDIR); 373 } 374 375 to_delete.0.lock().metadata.nlinks -= 1; 376 // 在当前目录中删除这个子目录项 377 inode.children.remove(name); 378 return Ok(()); 379 } 380 381 fn move_( 382 &self, 383 old_name: &str, 384 target: &Arc<dyn IndexNode>, 385 new_name: &str, 386 ) -> Result<(), SystemError> { 387 let old_inode: Arc<dyn IndexNode> = self.find(old_name)?; 388 389 // 在新的目录下创建一个硬链接 390 target.link(new_name, &old_inode)?; 391 // 取消现有的目录下的这个硬链接 392 if let Err(err) = self.unlink(old_name) { 393 // 如果取消失败，那就取消新的目录下的硬链接 394 target.unlink(new_name)?; 395 return Err(err); 396 } 397 return Ok(()); 398 } 399 400 fn find(&self, name: &str) -> Result<Arc<dyn IndexNode>, SystemError> { 401 let inode = self.0.lock(); 402 403 if inode.metadata.file_type != FileType::Dir { 404 return Err(SystemError::ENOTDIR); 405 } 406 407 match name { 408 "" | "." => { 409 return Ok(inode.self_ref.upgrade().ok_or(SystemError::ENOENT)?); 410 } 411 412 ".." => { 413 return Ok(inode.parent.upgrade().ok_or(SystemError::ENOENT)?); 414 } 415 name => { 416 // 在子目录项中查找 417 return Ok(inode.children.get(name).ok_or(SystemError::ENOENT)?.clone()); 418 } 419 } 420 } 421 422 fn get_entry_name(&self, ino: InodeId) -> Result<String, SystemError> { 423 let inode: SpinLockGuard<RamFSInode> = self.0.lock(); 424 if inode.metadata.file_type != FileType::Dir { 425 return Err(SystemError::ENOTDIR); 426 } 427 428 match ino { 429 0 => { 430 return Ok(String::from(".")); 431 } 432 1 => { 433 return Ok(String::from("..")); 434 } 435 ino => { 436 // 暴力遍历所有的children，判断inode id是否相同 437 // TODO: 优化这里，这个地方性能很差！ 438 let mut key: Vec<String> = inode 439 .children 440 .keys() 441 .filter(|k| inode.children.get(*k).unwrap().0.lock().metadata.inode_id == ino) 442 .cloned() 443 .collect(); 444 445 match key.len() { 446 0=>{return Err(SystemError::ENOENT);} 447 1=>{return Ok(key.remove(0));} 448 _ => panic!("Ramfs 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) 449 } 450 } 451 } 452 } 453 454 fn list(&self) -> Result<Vec<String>, SystemError> { 455 let info = self.metadata()?; 456 if info.file_type != FileType::Dir { 457 return Err(SystemError::ENOTDIR); 458 } 459 460 let mut keys: Vec<String> = Vec::new(); 461 keys.push(String::from(".")); 462 keys.push(String::from("..")); 463 keys.append(&mut self.0.lock().children.keys().cloned().collect()); 464 465 return Ok(keys); 466 } 467 } 468