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 {
root_inode(&self) -> Arc<dyn super::vfs::IndexNode>57     fn root_inode(&self) -> Arc<dyn super::vfs::IndexNode> {
58         return self.root_inode.clone();
59     }
60 
info(&self) -> FsInfo61     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
as_any_ref(&self) -> &dyn Any70     fn as_any_ref(&self) -> &dyn Any {
71         self
72     }
73 }
74 
75 impl RamFS {
new() -> Arc<Self>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 {
read_at( &self, offset: usize, len: usize, buf: &mut [u8], _data: &mut FilePrivateData, ) -> Result<usize, SystemError>117     fn read_at(
118         &self,
119         offset: usize,
120         len: usize,
121         buf: &mut [u8],
122         _data: &mut FilePrivateData,
123     ) -> Result<usize, SystemError> {
124         if buf.len() < len {
125             return Err(SystemError::EINVAL);
126         }
127         // 加锁
128         let inode: SpinLockGuard<RamFSInode> = self.0.lock();
129 
130         // 检查当前inode是否为一个文件夹，如果是的话，就返回错误
131         if inode.metadata.file_type == FileType::Dir {
132             return Err(SystemError::EISDIR);
133         }
134 
135         let start = inode.data.len().min(offset);
136         let end = inode.data.len().min(offset + len);
137 
138         // buffer空间不足
139         if buf.len() < (end - start) {
140             return Err(SystemError::ENOBUFS);
141         }
142 
143         // 拷贝数据
144         let src = &inode.data[start..end];
145         buf[0..src.len()].copy_from_slice(src);
146         return Ok(src.len());
147     }
148 
write_at( &self, offset: usize, len: usize, buf: &[u8], _data: &mut FilePrivateData, ) -> Result<usize, SystemError>149     fn write_at(
150         &self,
151         offset: usize,
152         len: usize,
153         buf: &[u8],
154         _data: &mut FilePrivateData,
155     ) -> Result<usize, SystemError> {
156         if buf.len() < len {
157             return Err(SystemError::EINVAL);
158         }
159 
160         // 加锁
161         let mut inode: SpinLockGuard<RamFSInode> = self.0.lock();
162 
163         // 检查当前inode是否为一个文件夹，如果是的话，就返回错误
164         if inode.metadata.file_type == FileType::Dir {
165             return Err(SystemError::EISDIR);
166         }
167 
168         let data: &mut Vec<u8> = &mut inode.data;
169 
170         // 如果文件大小比原来的大，那就resize这个数组
171         if offset + len > data.len() {
172             data.resize(offset + len, 0);
173         }
174 
175         let target = &mut data[offset..offset + len];
176         target.copy_from_slice(&buf[0..len]);
177         return Ok(len);
178     }
179 
poll(&self) -> Result<PollStatus, SystemError>180     fn poll(&self) -> Result<PollStatus, SystemError> {
181         // 加锁
182         let inode: SpinLockGuard<RamFSInode> = self.0.lock();
183 
184         // 检查当前inode是否为一个文件夹，如果是的话，就返回错误
185         if inode.metadata.file_type == FileType::Dir {
186             return Err(SystemError::EISDIR);
187         }
188 
189         return Ok(PollStatus::READ | PollStatus::WRITE);
190     }
191 
fs(&self) -> Arc<dyn FileSystem>192     fn fs(&self) -> Arc<dyn FileSystem> {
193         return self.0.lock().fs.upgrade().unwrap();
194     }
195 
as_any_ref(&self) -> &dyn core::any::Any196     fn as_any_ref(&self) -> &dyn core::any::Any {
197         self
198     }
199 
metadata(&self) -> Result<Metadata, SystemError>200     fn metadata(&self) -> Result<Metadata, SystemError> {
201         let inode = self.0.lock();
202         let mut metadata = inode.metadata.clone();
203         metadata.size = inode.data.len() as i64;
204 
205         return Ok(metadata);
206     }
207 
set_metadata(&self, metadata: &Metadata) -> Result<(), SystemError>208     fn set_metadata(&self, metadata: &Metadata) -> Result<(), SystemError> {
209         let mut inode = self.0.lock();
210         inode.metadata.atime = metadata.atime;
211         inode.metadata.mtime = metadata.mtime;
212         inode.metadata.ctime = metadata.ctime;
213         inode.metadata.mode = metadata.mode;
214         inode.metadata.uid = metadata.uid;
215         inode.metadata.gid = metadata.gid;
216 
217         return Ok(());
218     }
219 
resize(&self, len: usize) -> Result<(), SystemError>220     fn resize(&self, len: usize) -> Result<(), SystemError> {
221         let mut inode = self.0.lock();
222         if inode.metadata.file_type == FileType::File {
223             inode.data.resize(len, 0);
224             return Ok(());
225         } else {
226             return Err(SystemError::EINVAL);
227         }
228     }
229 
create_with_data( &self, name: &str, file_type: FileType, mode: u32, data: usize, ) -> Result<Arc<dyn IndexNode>, SystemError>230     fn create_with_data(
231         &self,
232         name: &str,
233         file_type: FileType,
234         mode: u32,
235         data: usize,
236     ) -> Result<Arc<dyn IndexNode>, SystemError> {
237         // 获取当前inode
238         let mut inode = self.0.lock();
239         // 如果当前inode不是文件夹，则返回
240         if inode.metadata.file_type != FileType::Dir {
241             return Err(SystemError::ENOTDIR);
242         }
243         // 如果有重名的，则返回
244         if inode.children.contains_key(name) {
245             return Err(SystemError::EEXIST);
246         }
247 
248         // 创建inode
249         let result: Arc<LockedRamFSInode> = Arc::new(LockedRamFSInode(SpinLock::new(RamFSInode {
250             parent: inode.self_ref.clone(),
251             self_ref: Weak::default(),
252             children: BTreeMap::new(),
253             data: Vec::new(),
254             metadata: Metadata {
255                 dev_id: 0,
256                 inode_id: generate_inode_id(),
257                 size: 0,
258                 blk_size: 0,
259                 blocks: 0,
260                 atime: TimeSpec::default(),
261                 mtime: TimeSpec::default(),
262                 ctime: TimeSpec::default(),
263                 file_type: file_type,
264                 mode: mode,
265                 nlinks: 1,
266                 uid: 0,
267                 gid: 0,
268                 raw_dev: data,
269             },
270             fs: inode.fs.clone(),
271         })));
272 
273         // 初始化inode的自引用的weak指针
274         result.0.lock().self_ref = Arc::downgrade(&result);
275 
276         // 将子inode插入父inode的B树中
277         inode.children.insert(String::from(name), result.clone());
278 
279         return Ok(result);
280     }
281 
link(&self, name: &str, other: &Arc<dyn IndexNode>) -> Result<(), SystemError>282     fn link(&self, name: &str, other: &Arc<dyn IndexNode>) -> Result<(), SystemError> {
283         let other: &LockedRamFSInode = other
284             .downcast_ref::<LockedRamFSInode>()
285             .ok_or(SystemError::EPERM)?;
286         let mut inode: SpinLockGuard<RamFSInode> = self.0.lock();
287         let mut other_locked: SpinLockGuard<RamFSInode> = other.0.lock();
288 
289         // 如果当前inode不是文件夹，那么报错
290         if inode.metadata.file_type != FileType::Dir {
291             return Err(SystemError::ENOTDIR);
292         }
293 
294         // 如果另一个inode是文件夹，那么也报错
295         if other_locked.metadata.file_type == FileType::Dir {
296             return Err(SystemError::EISDIR);
297         }
298 
299         // 如果当前文件夹下已经有同名文件，也报错。
300         if inode.children.contains_key(name) {
301             return Err(SystemError::EEXIST);
302         }
303 
304         inode
305             .children
306             .insert(String::from(name), other_locked.self_ref.upgrade().unwrap());
307 
308         // 增加硬链接计数
309         other_locked.metadata.nlinks += 1;
310         return Ok(());
311     }
312 
unlink(&self, name: &str) -> Result<(), SystemError>313     fn unlink(&self, name: &str) -> Result<(), SystemError> {
314         let mut inode: SpinLockGuard<RamFSInode> = self.0.lock();
315         // 如果当前inode不是目录，那么也没有子目录/文件的概念了，因此要求当前inode的类型是目录
316         if inode.metadata.file_type != FileType::Dir {
317             return Err(SystemError::ENOTDIR);
318         }
319         // 不允许删除当前文件夹，也不允许删除上一个目录
320         if name == "." || name == ".." {
321             return Err(SystemError::ENOTEMPTY);
322         }
323 
324         // 获得要删除的文件的inode
325         let to_delete = inode.children.get(name).ok_or(SystemError::ENOENT)?;
326         if to_delete.0.lock().metadata.file_type == FileType::Dir {
327             return Err(SystemError::EPERM);
328         }
329         // 减少硬链接计数
330         to_delete.0.lock().metadata.nlinks -= 1;
331         // 在当前目录中删除这个子目录项
332         inode.children.remove(name);
333         return Ok(());
334     }
335 
rmdir(&self, name: &str) -> Result<(), SystemError>336     fn rmdir(&self, name: &str) -> Result<(), SystemError> {
337         let mut inode: SpinLockGuard<RamFSInode> = self.0.lock();
338         // 如果当前inode不是目录，那么也没有子目录/文件的概念了，因此要求当前inode的类型是目录
339         if inode.metadata.file_type != FileType::Dir {
340             return Err(SystemError::ENOTDIR);
341         }
342         // 获得要删除的文件夹的inode
343         let to_delete = inode.children.get(name).ok_or(SystemError::ENOENT)?;
344         if to_delete.0.lock().metadata.file_type != FileType::Dir {
345             return Err(SystemError::ENOTDIR);
346         }
347 
348         to_delete.0.lock().metadata.nlinks -= 1;
349         // 在当前目录中删除这个子目录项
350         inode.children.remove(name);
351         return Ok(());
352     }
353 
move_( &self, old_name: &str, target: &Arc<dyn IndexNode>, new_name: &str, ) -> Result<(), SystemError>354     fn move_(
355         &self,
356         old_name: &str,
357         target: &Arc<dyn IndexNode>,
358         new_name: &str,
359     ) -> Result<(), SystemError> {
360         let old_inode: Arc<dyn IndexNode> = self.find(old_name)?;
361 
362         // 在新的目录下创建一个硬链接
363         target.link(new_name, &old_inode)?;
364         // 取消现有的目录下的这个硬链接
365         if let Err(err) = self.unlink(old_name) {
366             // 如果取消失败，那就取消新的目录下的硬链接
367             target.unlink(new_name)?;
368             return Err(err);
369         }
370         return Ok(());
371     }
372 
find(&self, name: &str) -> Result<Arc<dyn IndexNode>, SystemError>373     fn find(&self, name: &str) -> Result<Arc<dyn IndexNode>, SystemError> {
374         let inode = self.0.lock();
375 
376         if inode.metadata.file_type != FileType::Dir {
377             return Err(SystemError::ENOTDIR);
378         }
379 
380         match name {
381             "" | "." => {
382                 return Ok(inode.self_ref.upgrade().ok_or(SystemError::ENOENT)?);
383             }
384 
385             ".." => {
386                 return Ok(inode.parent.upgrade().ok_or(SystemError::ENOENT)?);
387             }
388             name => {
389                 // 在子目录项中查找
390                 return Ok(inode.children.get(name).ok_or(SystemError::ENOENT)?.clone());
391             }
392         }
393     }
394 
get_entry_name(&self, ino: InodeId) -> Result<String, SystemError>395     fn get_entry_name(&self, ino: InodeId) -> Result<String, SystemError> {
396         let inode: SpinLockGuard<RamFSInode> = self.0.lock();
397         if inode.metadata.file_type != FileType::Dir {
398             return Err(SystemError::ENOTDIR);
399         }
400 
401         match ino {
402             0 => {
403                 return Ok(String::from("."));
404             }
405             1 => {
406                 return Ok(String::from(".."));
407             }
408             ino => {
409                 // 暴力遍历所有的children，判断inode id是否相同
410                 // TODO: 优化这里，这个地方性能很差！
411                 let mut key: Vec<String> = inode
412                     .children
413                     .keys()
414                     .filter(|k| inode.children.get(*k).unwrap().0.lock().metadata.inode_id == ino)
415                     .cloned()
416                     .collect();
417 
418                 match key.len() {
419                     0=>{return Err(SystemError::ENOENT);}
420                     1=>{return Ok(key.remove(0));}
421                     _ => 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)
422                 }
423             }
424         }
425     }
426 
list(&self) -> Result<Vec<String>, SystemError>427     fn list(&self) -> Result<Vec<String>, SystemError> {
428         let info = self.metadata()?;
429         if info.file_type != FileType::Dir {
430             return Err(SystemError::ENOTDIR);
431         }
432 
433         let mut keys: Vec<String> = Vec::new();
434         keys.push(String::from("."));
435         keys.push(String::from(".."));
436         keys.append(&mut self.0.lock().children.keys().cloned().collect());
437 
438         return Ok(keys);
439     }
440 }
441