xref: /DragonOS/kernel/src/filesystem/ramfs/mod.rs (revision bd70d2d1f490aabd570a5301b858bd5eb04149fa) 
1 use core::any::Any;
2 use core::intrinsics::unlikely;
3 
4 use crate::filesystem::vfs::FSMAKER;
5 use crate::libs::rwlock::RwLock;
6 use crate::{
7     driver::base::device::device_number::DeviceNumber,
8     filesystem::vfs::{core::generate_inode_id, FileType},
9     ipc::pipe::LockedPipeInode,
10     libs::casting::DowncastArc,
11     libs::spinlock::{SpinLock, SpinLockGuard},
12     time::PosixTimeSpec,
13 };
14 
15 use alloc::string::ToString;
16 use alloc::{
17     collections::BTreeMap,
18     string::String,
19     sync::{Arc, Weak},
20     vec::Vec,
21 };
22 use system_error::SystemError;
23 
24 use super::vfs::{
25     file::FilePrivateData, syscall::ModeType, utils::DName, FileSystem, FileSystemMaker, FsInfo,
26     IndexNode, InodeId, Metadata, SpecialNodeData,
27 };
28 
29 use linkme::distributed_slice;
30 
31 use super::vfs::{Magic, SuperBlock};
32 
33 /// RamFS的inode名称的最大长度
34 const RAMFS_MAX_NAMELEN: usize = 64;
35 const RAMFS_BLOCK_SIZE: u64 = 512;
36 /// @brief 内存文件系统的Inode结构体
37 #[derive(Debug)]
38 struct LockedRamFSInode(SpinLock<RamFSInode>);
39 
40 /// @brief 内存文件系统结构体
41 #[derive(Debug)]
42 pub struct RamFS {
43     /// RamFS的root inode
44     root_inode: Arc<LockedRamFSInode>,
45     super_block: RwLock<SuperBlock>,
46 }
47 
48 /// @brief 内存文件系统的Inode结构体(不包含锁)
49 #[derive(Debug)]
50 pub struct RamFSInode {
51     // parent变量目前只在find函数中使用到
52     // 所以只有当inode是文件夹的时候，parent才会生效
53     // 对于文件来说，parent就没什么作用了
54     // 关于parent的说明: 目录不允许有硬链接
55     /// 指向父Inode的弱引用
56     parent: Weak<LockedRamFSInode>,
57     /// 指向自身的弱引用
58     self_ref: Weak<LockedRamFSInode>,
59     /// 子Inode的B树
60     children: BTreeMap<DName, Arc<LockedRamFSInode>>,
61     /// 当前inode的数据部分
62     data: Vec<u8>,
63     /// 当前inode的元数据
64     metadata: Metadata,
65     /// 指向inode所在的文件系统对象的指针
66     fs: Weak<RamFS>,
67     /// 指向特殊节点
68     special_node: Option<SpecialNodeData>,
69 
70     name: DName,
71 }
72 
73 impl FileSystem for RamFS {
root_inode(&self) -> Arc<dyn super::vfs::IndexNode>74     fn root_inode(&self) -> Arc<dyn super::vfs::IndexNode> {
75         return self.root_inode.clone();
76     }
77 
info(&self) -> FsInfo78     fn info(&self) -> FsInfo {
79         return FsInfo {
80             blk_dev_id: 0,
81             max_name_len: RAMFS_MAX_NAMELEN,
82         };
83     }
84 
85     /// @brief 本函数用于实现动态转换。
86     /// 具体的文件系统在实现本函数时，最简单的方式就是：直接返回self
as_any_ref(&self) -> &dyn Any87     fn as_any_ref(&self) -> &dyn Any {
88         self
89     }
90 
name(&self) -> &str91     fn name(&self) -> &str {
92         "ramfs"
93     }
94 
super_block(&self) -> SuperBlock95     fn super_block(&self) -> SuperBlock {
96         self.super_block.read().clone()
97     }
98 }
99 
100 impl RamFS {
new() -> Arc<Self>101     pub fn new() -> Arc<Self> {
102         let super_block = SuperBlock::new(
103             Magic::RAMFS_MAGIC,
104             RAMFS_BLOCK_SIZE,
105             RAMFS_MAX_NAMELEN as u64,
106         );
107         // 初始化root inode
108         let root: Arc<LockedRamFSInode> = Arc::new(LockedRamFSInode(SpinLock::new(RamFSInode {
109             parent: Weak::default(),
110             self_ref: Weak::default(),
111             children: BTreeMap::new(),
112             data: Vec::new(),
113             metadata: Metadata {
114                 dev_id: 0,
115                 inode_id: generate_inode_id(),
116                 size: 0,
117                 blk_size: 0,
118                 blocks: 0,
119                 atime: PosixTimeSpec::default(),
120                 mtime: PosixTimeSpec::default(),
121                 ctime: PosixTimeSpec::default(),
122                 file_type: FileType::Dir,
123                 mode: ModeType::from_bits_truncate(0o777),
124                 nlinks: 1,
125                 uid: 0,
126                 gid: 0,
127                 raw_dev: DeviceNumber::default(),
128             },
129             fs: Weak::default(),
130             special_node: None,
131             name: Default::default(),
132         })));
133 
134         let result: Arc<RamFS> = Arc::new(RamFS {
135             root_inode: root,
136             super_block: RwLock::new(super_block),
137         });
138 
139         // 对root inode加锁，并继续完成初始化工作
140         let mut root_guard: SpinLockGuard<RamFSInode> = result.root_inode.0.lock();
141         root_guard.parent = Arc::downgrade(&result.root_inode);
142         root_guard.self_ref = Arc::downgrade(&result.root_inode);
143         root_guard.fs = Arc::downgrade(&result);
144         // 释放锁
145         drop(root_guard);
146 
147         return result;
148     }
149 
make_ramfs() -> Result<Arc<dyn FileSystem + 'static>, SystemError>150     pub fn make_ramfs() -> Result<Arc<dyn FileSystem + 'static>, SystemError> {
151         let fs = RamFS::new();
152         return Ok(fs);
153     }
154 }
155 #[distributed_slice(FSMAKER)]
156 static RAMFSMAKER: FileSystemMaker = FileSystemMaker::new(
157     "ramfs",
158     &(RamFS::make_ramfs as fn() -> Result<Arc<dyn FileSystem + 'static>, SystemError>),
159 );
160 
161 impl IndexNode for LockedRamFSInode {
truncate(&self, len: usize) -> Result<(), SystemError>162     fn truncate(&self, len: usize) -> Result<(), SystemError> {
163         let mut inode = self.0.lock();
164 
165         //如果是文件夹，则报错
166         if inode.metadata.file_type == FileType::Dir {
167             return Err(SystemError::EINVAL);
168         }
169 
170         //当前文件长度大于_len才进行截断，否则不操作
171         if inode.data.len() > len {
172             inode.data.resize(len, 0);
173         }
174         return Ok(());
175     }
176 
close(&self, _data: SpinLockGuard<FilePrivateData>) -> Result<(), SystemError>177     fn close(&self, _data: SpinLockGuard<FilePrivateData>) -> Result<(), SystemError> {
178         return Ok(());
179     }
180 
open( &self, _data: SpinLockGuard<FilePrivateData>, _mode: &super::vfs::file::FileMode, ) -> Result<(), SystemError>181     fn open(
182         &self,
183         _data: SpinLockGuard<FilePrivateData>,
184         _mode: &super::vfs::file::FileMode,
185     ) -> Result<(), SystemError> {
186         return Ok(());
187     }
188 
read_at( &self, offset: usize, len: usize, buf: &mut [u8], _data: SpinLockGuard<FilePrivateData>, ) -> Result<usize, SystemError>189     fn read_at(
190         &self,
191         offset: usize,
192         len: usize,
193         buf: &mut [u8],
194         _data: SpinLockGuard<FilePrivateData>,
195     ) -> Result<usize, SystemError> {
196         if buf.len() < len {
197             return Err(SystemError::EINVAL);
198         }
199         // 加锁
200         let inode: SpinLockGuard<RamFSInode> = self.0.lock();
201 
202         // 检查当前inode是否为一个文件夹，如果是的话，就返回错误
203         if inode.metadata.file_type == FileType::Dir {
204             return Err(SystemError::EISDIR);
205         }
206 
207         let start = inode.data.len().min(offset);
208         let end = inode.data.len().min(offset + len);
209 
210         // buffer空间不足
211         if buf.len() < (end - start) {
212             return Err(SystemError::ENOBUFS);
213         }
214 
215         // 拷贝数据
216         let src = &inode.data[start..end];
217         buf[0..src.len()].copy_from_slice(src);
218         return Ok(src.len());
219     }
220 
write_at( &self, offset: usize, len: usize, buf: &[u8], _data: SpinLockGuard<FilePrivateData>, ) -> Result<usize, SystemError>221     fn write_at(
222         &self,
223         offset: usize,
224         len: usize,
225         buf: &[u8],
226         _data: SpinLockGuard<FilePrivateData>,
227     ) -> Result<usize, SystemError> {
228         if buf.len() < len {
229             return Err(SystemError::EINVAL);
230         }
231 
232         // 加锁
233         let mut inode: SpinLockGuard<RamFSInode> = self.0.lock();
234 
235         // 检查当前inode是否为一个文件夹，如果是的话，就返回错误
236         if inode.metadata.file_type == FileType::Dir {
237             return Err(SystemError::EISDIR);
238         }
239 
240         let data: &mut Vec<u8> = &mut inode.data;
241 
242         // 如果文件大小比原来的大，那就resize这个数组
243         if offset + len > data.len() {
244             data.resize(offset + len, 0);
245         }
246 
247         let target = &mut data[offset..offset + len];
248         target.copy_from_slice(&buf[0..len]);
249         return Ok(len);
250     }
251 
fs(&self) -> Arc<dyn FileSystem>252     fn fs(&self) -> Arc<dyn FileSystem> {
253         return self.0.lock().fs.upgrade().unwrap();
254     }
255 
as_any_ref(&self) -> &dyn core::any::Any256     fn as_any_ref(&self) -> &dyn core::any::Any {
257         self
258     }
259 
metadata(&self) -> Result<Metadata, SystemError>260     fn metadata(&self) -> Result<Metadata, SystemError> {
261         let inode = self.0.lock();
262         let mut metadata = inode.metadata.clone();
263         metadata.size = inode.data.len() as i64;
264 
265         return Ok(metadata);
266     }
267 
set_metadata(&self, metadata: &Metadata) -> Result<(), SystemError>268     fn set_metadata(&self, metadata: &Metadata) -> Result<(), SystemError> {
269         let mut inode = self.0.lock();
270         inode.metadata.atime = metadata.atime;
271         inode.metadata.mtime = metadata.mtime;
272         inode.metadata.ctime = metadata.ctime;
273         inode.metadata.mode = metadata.mode;
274         inode.metadata.uid = metadata.uid;
275         inode.metadata.gid = metadata.gid;
276 
277         return Ok(());
278     }
279 
resize(&self, len: usize) -> Result<(), SystemError>280     fn resize(&self, len: usize) -> Result<(), SystemError> {
281         let mut inode = self.0.lock();
282         if inode.metadata.file_type == FileType::File {
283             inode.data.resize(len, 0);
284             return Ok(());
285         } else {
286             return Err(SystemError::EINVAL);
287         }
288     }
289 
create_with_data( &self, name: &str, file_type: FileType, mode: ModeType, data: usize, ) -> Result<Arc<dyn IndexNode>, SystemError>290     fn create_with_data(
291         &self,
292         name: &str,
293         file_type: FileType,
294         mode: ModeType,
295         data: usize,
296     ) -> Result<Arc<dyn IndexNode>, SystemError> {
297         let name = DName::from(name);
298         // 获取当前inode
299         let mut inode = self.0.lock();
300         // 如果当前inode不是文件夹，则返回
301         if inode.metadata.file_type != FileType::Dir {
302             return Err(SystemError::ENOTDIR);
303         }
304         // 如果有重名的，则返回
305         if inode.children.contains_key(&name) {
306             return Err(SystemError::EEXIST);
307         }
308 
309         // 创建inode
310         let result: Arc<LockedRamFSInode> = Arc::new(LockedRamFSInode(SpinLock::new(RamFSInode {
311             parent: inode.self_ref.clone(),
312             self_ref: Weak::default(),
313             children: BTreeMap::new(),
314             data: Vec::new(),
315             metadata: Metadata {
316                 dev_id: 0,
317                 inode_id: generate_inode_id(),
318                 size: 0,
319                 blk_size: 0,
320                 blocks: 0,
321                 atime: PosixTimeSpec::default(),
322                 mtime: PosixTimeSpec::default(),
323                 ctime: PosixTimeSpec::default(),
324                 file_type,
325                 mode,
326                 nlinks: 1,
327                 uid: 0,
328                 gid: 0,
329                 raw_dev: DeviceNumber::from(data as u32),
330             },
331             fs: inode.fs.clone(),
332             special_node: None,
333             name: name.clone(),
334         })));
335 
336         // 初始化inode的自引用的weak指针
337         result.0.lock().self_ref = Arc::downgrade(&result);
338 
339         // 将子inode插入父inode的B树中
340         inode.children.insert(name, result.clone());
341 
342         return Ok(result);
343     }
344 
link(&self, name: &str, other: &Arc<dyn IndexNode>) -> Result<(), SystemError>345     fn link(&self, name: &str, other: &Arc<dyn IndexNode>) -> Result<(), SystemError> {
346         let other: &LockedRamFSInode = other
347             .downcast_ref::<LockedRamFSInode>()
348             .ok_or(SystemError::EPERM)?;
349         let name = DName::from(name);
350         let mut inode: SpinLockGuard<RamFSInode> = self.0.lock();
351         let mut other_locked: SpinLockGuard<RamFSInode> = other.0.lock();
352 
353         // 如果当前inode不是文件夹，那么报错
354         if inode.metadata.file_type != FileType::Dir {
355             return Err(SystemError::ENOTDIR);
356         }
357 
358         // 如果另一个inode是文件夹，那么也报错
359         if other_locked.metadata.file_type == FileType::Dir {
360             return Err(SystemError::EISDIR);
361         }
362 
363         // 如果当前文件夹下已经有同名文件，也报错。
364         if inode.children.contains_key(&name) {
365             return Err(SystemError::EEXIST);
366         }
367 
368         inode
369             .children
370             .insert(name, other_locked.self_ref.upgrade().unwrap());
371 
372         // 增加硬链接计数
373         other_locked.metadata.nlinks += 1;
374         return Ok(());
375     }
376 
unlink(&self, name: &str) -> Result<(), SystemError>377     fn unlink(&self, name: &str) -> Result<(), SystemError> {
378         let mut inode: SpinLockGuard<RamFSInode> = self.0.lock();
379         // 如果当前inode不是目录，那么也没有子目录/文件的概念了，因此要求当前inode的类型是目录
380         if inode.metadata.file_type != FileType::Dir {
381             return Err(SystemError::ENOTDIR);
382         }
383         // 不允许删除当前文件夹，也不允许删除上一个目录
384         if name == "." || name == ".." {
385             return Err(SystemError::ENOTEMPTY);
386         }
387 
388         let name = DName::from(name);
389         // 获得要删除的文件的inode
390         let to_delete = inode.children.get(&name).ok_or(SystemError::ENOENT)?;
391         if to_delete.0.lock().metadata.file_type == FileType::Dir {
392             return Err(SystemError::EPERM);
393         }
394         // 减少硬链接计数
395         to_delete.0.lock().metadata.nlinks -= 1;
396         // 在当前目录中删除这个子目录项
397         inode.children.remove(&name);
398         return Ok(());
399     }
400 
rmdir(&self, name: &str) -> Result<(), SystemError>401     fn rmdir(&self, name: &str) -> Result<(), SystemError> {
402         let name = DName::from(name);
403         let mut inode: SpinLockGuard<RamFSInode> = self.0.lock();
404         // 如果当前inode不是目录，那么也没有子目录/文件的概念了，因此要求当前inode的类型是目录
405         if inode.metadata.file_type != FileType::Dir {
406             return Err(SystemError::ENOTDIR);
407         }
408         // 获得要删除的文件夹的inode
409         let to_delete = inode.children.get(&name).ok_or(SystemError::ENOENT)?;
410         if to_delete.0.lock().metadata.file_type != FileType::Dir {
411             return Err(SystemError::ENOTDIR);
412         }
413 
414         to_delete.0.lock().metadata.nlinks -= 1;
415         // 在当前目录中删除这个子目录项
416         inode.children.remove(&name);
417         return Ok(());
418     }
419 
move_to( &self, old_name: &str, target: &Arc<dyn IndexNode>, new_name: &str, ) -> Result<(), SystemError>420     fn move_to(
421         &self,
422         old_name: &str,
423         target: &Arc<dyn IndexNode>,
424         new_name: &str,
425     ) -> Result<(), SystemError> {
426         let inode_to_move = self
427             .find(old_name)?
428             .downcast_arc::<LockedRamFSInode>()
429             .ok_or(SystemError::EINVAL)?;
430 
431         let new_name = DName::from(new_name);
432 
433         inode_to_move.0.lock().name = new_name.clone();
434 
435         let target_id = target.metadata()?.inode_id;
436 
437         let mut self_inode = self.0.lock();
438         // 判断是否在同一目录下, 是则进行重命名
439         if target_id == self_inode.metadata.inode_id {
440             self_inode.children.remove(&DName::from(old_name));
441             self_inode.children.insert(new_name, inode_to_move);
442             return Ok(());
443         }
444         drop(self_inode);
445 
446         // 修改其对父节点的引用
447         inode_to_move.0.lock().parent = Arc::downgrade(
448             &target
449                 .clone()
450                 .downcast_arc::<LockedRamFSInode>()
451                 .ok_or(SystemError::EINVAL)?,
452         );
453 
454         // 在新的目录下创建一个硬链接
455         target.link(new_name.as_ref(), &(inode_to_move as Arc<dyn IndexNode>))?;
456 
457         // 取消现有的目录下的这个硬链接
458         if let Err(e) = self.unlink(old_name) {
459             // 当操作失败时回退操作
460             target.unlink(new_name.as_ref())?;
461             return Err(e);
462         }
463 
464         return Ok(());
465     }
466 
find(&self, name: &str) -> Result<Arc<dyn IndexNode>, SystemError>467     fn find(&self, name: &str) -> Result<Arc<dyn IndexNode>, SystemError> {
468         let inode = self.0.lock();
469 
470         if inode.metadata.file_type != FileType::Dir {
471             return Err(SystemError::ENOTDIR);
472         }
473 
474         match name {
475             "" | "." => {
476                 return Ok(inode.self_ref.upgrade().ok_or(SystemError::ENOENT)?);
477             }
478 
479             ".." => {
480                 return Ok(inode.parent.upgrade().ok_or(SystemError::ENOENT)?);
481             }
482             name => {
483                 // 在子目录项中查找
484                 let name = DName::from(name);
485                 return Ok(inode
486                     .children
487                     .get(&name)
488                     .ok_or(SystemError::ENOENT)?
489                     .clone());
490             }
491         }
492     }
493 
get_entry_name(&self, ino: InodeId) -> Result<String, SystemError>494     fn get_entry_name(&self, ino: InodeId) -> Result<String, SystemError> {
495         let inode: SpinLockGuard<RamFSInode> = self.0.lock();
496         if inode.metadata.file_type != FileType::Dir {
497             return Err(SystemError::ENOTDIR);
498         }
499 
500         match ino.into() {
501             0 => {
502                 return Ok(String::from("."));
503             }
504             1 => {
505                 return Ok(String::from(".."));
506             }
507             ino => {
508                 // 暴力遍历所有的children，判断inode id是否相同
509                 // TODO: 优化这里，这个地方性能很差！
510                 let mut key: Vec<String> = inode
511                     .children
512                     .iter()
513                     .filter_map(|(k, v)| {
514                         if v.0.lock().metadata.inode_id.into() == ino {
515                             Some(k.to_string())
516                         } else {
517                             None
518                         }
519                     })
520                     .collect();
521 
522                 match key.len() {
523                     0=>{return Err(SystemError::ENOENT);}
524                     1=>{return Ok(key.remove(0));}
525                     _ => 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)
526                 }
527             }
528         }
529     }
530 
list(&self) -> Result<Vec<String>, SystemError>531     fn list(&self) -> Result<Vec<String>, SystemError> {
532         let info = self.metadata()?;
533         if info.file_type != FileType::Dir {
534             return Err(SystemError::ENOTDIR);
535         }
536 
537         let mut keys: Vec<String> = Vec::new();
538         keys.push(String::from("."));
539         keys.push(String::from(".."));
540         keys.append(
541             &mut self
542                 .0
543                 .lock()
544                 .children
545                 .keys()
546                 .map(|k| k.to_string())
547                 .collect(),
548         );
549 
550         return Ok(keys);
551     }
552 
mknod( &self, filename: &str, mode: ModeType, _dev_t: DeviceNumber, ) -> Result<Arc<dyn IndexNode>, SystemError>553     fn mknod(
554         &self,
555         filename: &str,
556         mode: ModeType,
557         _dev_t: DeviceNumber,
558     ) -> Result<Arc<dyn IndexNode>, SystemError> {
559         let mut inode = self.0.lock();
560         if inode.metadata.file_type != FileType::Dir {
561             return Err(SystemError::ENOTDIR);
562         }
563 
564         // 判断需要创建的类型
565         if unlikely(mode.contains(ModeType::S_IFREG)) {
566             // 普通文件
567             return self.create(filename, FileType::File, mode);
568         }
569 
570         let filename = DName::from(filename);
571 
572         let nod = Arc::new(LockedRamFSInode(SpinLock::new(RamFSInode {
573             parent: inode.self_ref.clone(),
574             self_ref: Weak::default(),
575             children: BTreeMap::new(),
576             data: Vec::new(),
577             metadata: Metadata {
578                 dev_id: 0,
579                 inode_id: generate_inode_id(),
580                 size: 0,
581                 blk_size: 0,
582                 blocks: 0,
583                 atime: PosixTimeSpec::default(),
584                 mtime: PosixTimeSpec::default(),
585                 ctime: PosixTimeSpec::default(),
586                 file_type: FileType::Pipe,
587                 mode,
588                 nlinks: 1,
589                 uid: 0,
590                 gid: 0,
591                 raw_dev: DeviceNumber::default(),
592             },
593             fs: inode.fs.clone(),
594             special_node: None,
595             name: filename.clone(),
596         })));
597 
598         nod.0.lock().self_ref = Arc::downgrade(&nod);
599 
600         if mode.contains(ModeType::S_IFIFO) {
601             nod.0.lock().metadata.file_type = FileType::Pipe;
602             // 创建pipe文件
603             let pipe_inode = LockedPipeInode::new();
604             // 设置special_node
605             nod.0.lock().special_node = Some(SpecialNodeData::Pipe(pipe_inode));
606         } else if mode.contains(ModeType::S_IFBLK) {
607             nod.0.lock().metadata.file_type = FileType::BlockDevice;
608             unimplemented!()
609         } else if mode.contains(ModeType::S_IFCHR) {
610             nod.0.lock().metadata.file_type = FileType::CharDevice;
611             unimplemented!()
612         }
613 
614         inode.children.insert(filename, nod.clone());
615         Ok(nod)
616     }
617 
special_node(&self) -> Option<super::vfs::SpecialNodeData>618     fn special_node(&self) -> Option<super::vfs::SpecialNodeData> {
619         return self.0.lock().special_node.clone();
620     }
621 
dname(&self) -> Result<DName, SystemError>622     fn dname(&self) -> Result<DName, SystemError> {
623         Ok(self.0.lock().name.clone())
624     }
625 
parent(&self) -> Result<Arc<dyn IndexNode>, SystemError>626     fn parent(&self) -> Result<Arc<dyn IndexNode>, SystemError> {
627         self.0
628             .lock()
629             .parent
630             .upgrade()
631             .map(|item| item as Arc<dyn IndexNode>)
632             .ok_or(SystemError::EINVAL)
633     }
634 }
635