1 #![allow(dead_code)]
2 
3 pub mod core;
4 pub mod fcntl;
5 pub mod file;
6 pub mod mount;
7 pub mod syscall;
8 mod utils;
9 
10 use ::core::{any::Any, fmt::Debug};
11 
12 use alloc::{string::String, sync::Arc, vec::Vec};
13 
14 use crate::{libs::casting::DowncastArc, syscall::SystemError, time::TimeSpec};
15 
16 use self::{core::generate_inode_id, file::FileMode};
17 pub use self::{core::ROOT_INODE, file::FilePrivateData, mount::MountFS};
18 
19 /// vfs容许的最大的路径名称长度
20 pub const MAX_PATHLEN: usize = 1024;
21 
22 /// 定义inode号的类型为usize
23 pub type InodeId = usize;
24 
25 /// 文件的类型
26 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
27 pub enum FileType {
28     /// 文件
29     File,
30     /// 文件夹
31     Dir,
32     /// 块设备
33     BlockDevice,
34     /// 字符设备
35     CharDevice,
36     /// 管道文件
37     Pipe,
38     /// 符号链接
39     SymLink,
40     /// 套接字
41     Socket,
42 }
43 
44 /* these are defined by POSIX and also present in glibc's dirent.h */
45 /// 完整含义请见 http://www.gnu.org/software/libc/manual/html_node/Directory-Entries.html
46 pub const DT_UNKNOWN: u16 = 0;
47 /// 命名管道，或者FIFO
48 pub const DT_FIFO: u16 = 1;
49 // 字符设备
50 pub const DT_CHR: u16 = 2;
51 // 目录
52 pub const DT_DIR: u16 = 4;
53 // 块设备
54 pub const DT_BLK: u16 = 6;
55 // 常规文件
56 pub const DT_REG: u16 = 8;
57 // 符号链接
58 pub const DT_LNK: u16 = 10;
59 // 是一个socket
60 pub const DT_SOCK: u16 = 12;
61 // 这个是抄Linux的，还不知道含义
62 pub const DT_WHT: u16 = 14;
63 pub const DT_MAX: u16 = 16;
64 
65 impl FileType {
get_file_type_num(&self) -> u1666     pub fn get_file_type_num(&self) -> u16 {
67         return match self {
68             FileType::File => DT_REG,
69             FileType::Dir => DT_DIR,
70             FileType::BlockDevice => DT_BLK,
71             FileType::CharDevice => DT_CHR,
72             FileType::Pipe => DT_FIFO,
73             FileType::SymLink => DT_LNK,
74             FileType::Socket => DT_SOCK,
75         };
76     }
77 }
78 
79 bitflags! {
80     /// @brief inode的状态（由poll方法返回）
81     pub struct PollStatus: u8 {
82         const WRITE = 1u8 << 0;
83         const READ = 1u8 << 1;
84         const ERROR = 1u8 << 2;
85     }
86 }
87 
88 pub trait IndexNode: Any + Sync + Send + Debug {
89     /// @brief 打开文件
90     ///
91     /// @return 成功：Ok()
92     ///         失败：Err(错误码)
open(&self, _data: &mut FilePrivateData, _mode: &FileMode) -> Result<(), SystemError>93     fn open(&self, _data: &mut FilePrivateData, _mode: &FileMode) -> Result<(), SystemError> {
94         // 若文件系统没有实现此方法，则返回“不支持”
95         return Err(SystemError::EOPNOTSUPP_OR_ENOTSUP);
96     }
97 
98     /// @brief 关闭文件
99     ///
100     /// @return 成功：Ok()
101     ///         失败：Err(错误码)
close(&self, _data: &mut FilePrivateData) -> Result<(), SystemError>102     fn close(&self, _data: &mut FilePrivateData) -> Result<(), SystemError> {
103         // 若文件系统没有实现此方法，则返回“不支持”
104         return Err(SystemError::EOPNOTSUPP_OR_ENOTSUP);
105     }
106 
107     /// @brief 在inode的指定偏移量开始，读取指定大小的数据
108     ///
109     /// @param offset 起始位置在Inode中的偏移量
110     /// @param len 要读取的字节数
111     /// @param buf 缓冲区. 请注意，必须满足@buf.len()>=@len
112     /// @param _data 各文件系统系统所需私有信息
113     ///
114     /// @return 成功：Ok(读取的字节数)
115     ///         失败：Err(Posix错误码)
read_at( &self, offset: usize, len: usize, buf: &mut [u8], _data: &mut FilePrivateData, ) -> Result<usize, SystemError>116     fn read_at(
117         &self,
118         offset: usize,
119         len: usize,
120         buf: &mut [u8],
121         _data: &mut FilePrivateData,
122     ) -> Result<usize, SystemError>;
123 
124     /// @brief 在inode的指定偏移量开始，写入指定大小的数据（从buf的第0byte开始写入）
125     ///
126     /// @param offset 起始位置在Inode中的偏移量
127     /// @param len 要写入的字节数
128     /// @param buf 缓冲区. 请注意，必须满足@buf.len()>=@len
129     /// @param _data 各文件系统系统所需私有信息
130     ///
131     /// @return 成功：Ok(写入的字节数)
132     ///         失败：Err(Posix错误码)
write_at( &self, offset: usize, len: usize, buf: &[u8], _data: &mut FilePrivateData, ) -> Result<usize, SystemError>133     fn write_at(
134         &self,
135         offset: usize,
136         len: usize,
137         buf: &[u8],
138         _data: &mut FilePrivateData,
139     ) -> Result<usize, SystemError>;
140 
141     /// @brief 获取当前inode的状态。
142     ///
143     /// @return PollStatus结构体
poll(&self) -> Result<PollStatus, SystemError>144     fn poll(&self) -> Result<PollStatus, SystemError>;
145 
146     /// @brief 获取inode的元数据
147     ///
148     /// @return 成功：Ok(inode的元数据)
149     ///         失败：Err(错误码)
metadata(&self) -> Result<Metadata, SystemError>150     fn metadata(&self) -> Result<Metadata, SystemError> {
151         // 若文件系统没有实现此方法，则返回“不支持”
152         return Err(SystemError::EOPNOTSUPP_OR_ENOTSUP);
153     }
154 
155     /// @brief 设置inode的元数据
156     ///
157     /// @return 成功：Ok()
158     ///         失败：Err(错误码)
set_metadata(&self, _metadata: &Metadata) -> Result<(), SystemError>159     fn set_metadata(&self, _metadata: &Metadata) -> Result<(), SystemError> {
160         // 若文件系统没有实现此方法，则返回“不支持”
161         return Err(SystemError::EOPNOTSUPP_OR_ENOTSUP);
162     }
163 
164     /// @brief 重新设置文件的大小
165     ///
166     /// 如果文件大小增加，则文件内容不变，但是文件的空洞部分会被填充为0
167     /// 如果文件大小减小，则文件内容会被截断
168     ///
169     /// @return 成功：Ok()
170     ///         失败：Err(错误码)
resize(&self, _len: usize) -> Result<(), SystemError>171     fn resize(&self, _len: usize) -> Result<(), SystemError> {
172         // 若文件系统没有实现此方法，则返回“不支持”
173         return Err(SystemError::EOPNOTSUPP_OR_ENOTSUP);
174     }
175 
176     /// @brief 在当前目录下创建一个新的inode
177     ///
178     /// @param name 目录项的名字
179     /// @param file_type 文件类型
180     /// @param mode 权限
181     ///
182     /// @return 创建成功：返回Ok(新的inode的Arc指针)
183     /// @return 创建失败：返回Err(错误码)
create( &self, name: &str, file_type: FileType, mode: u32, ) -> Result<Arc<dyn IndexNode>, SystemError>184     fn create(
185         &self,
186         name: &str,
187         file_type: FileType,
188         mode: u32,
189     ) -> Result<Arc<dyn IndexNode>, SystemError> {
190         // 若文件系统没有实现此方法，则默认调用其create_with_data方法。如果仍未实现，则会得到一个Err(-EOPNOTSUPP_OR_ENOTSUP)的返回值
191         return self.create_with_data(name, file_type, mode, 0);
192     }
193 
194     /// @brief 在当前目录下创建一个新的inode，并传入一个简单的data字段，方便进行初始化。
195     ///
196     /// @param name 目录项的名字
197     /// @param file_type 文件类型
198     /// @param mode 权限
199     /// @param data 用于初始化该inode的数据。（为0则表示忽略此字段）对于不同的文件系统来说，代表的含义可能不同。
200     ///
201     /// @return 创建成功：返回Ok(新的inode的Arc指针)
202     /// @return 创建失败：返回Err(错误码)
create_with_data( &self, _name: &str, _file_type: FileType, _mode: u32, _data: usize, ) -> Result<Arc<dyn IndexNode>, SystemError>203     fn create_with_data(
204         &self,
205         _name: &str,
206         _file_type: FileType,
207         _mode: u32,
208         _data: usize,
209     ) -> Result<Arc<dyn IndexNode>, SystemError> {
210         // 若文件系统没有实现此方法，则返回“不支持”
211         return Err(SystemError::EOPNOTSUPP_OR_ENOTSUP);
212     }
213 
214     /// @brief 在当前目录下，创建一个名为Name的硬链接，指向另一个IndexNode
215     ///
216     /// @param name 硬链接的名称
217     /// @param other 要被指向的IndexNode的Arc指针
218     ///
219     /// @return 成功：Ok()
220     ///         失败：Err(错误码)
link(&self, _name: &str, _other: &Arc<dyn IndexNode>) -> Result<(), SystemError>221     fn link(&self, _name: &str, _other: &Arc<dyn IndexNode>) -> Result<(), SystemError> {
222         // 若文件系统没有实现此方法，则返回“不支持”
223         return Err(SystemError::EOPNOTSUPP_OR_ENOTSUP);
224     }
225 
226     /// @brief 在当前目录下，删除一个名为Name的硬链接
227     ///
228     /// @param name 硬链接的名称
229     ///
230     /// @return 成功：Ok()
231     ///         失败：Err(错误码)
unlink(&self, _name: &str) -> Result<(), SystemError>232     fn unlink(&self, _name: &str) -> Result<(), SystemError> {
233         // 若文件系统没有实现此方法，则返回“不支持”
234         return Err(SystemError::EOPNOTSUPP_OR_ENOTSUP);
235     }
236 
237     /// @brief 删除文件夹
238     ///
239     /// @param name 文件夹名称
240     ///
241     /// @return 成功 Ok(())
242     /// @return 失败 Err(错误码)
rmdir(&self, _name: &str) -> Result<(), SystemError>243     fn rmdir(&self, _name: &str) -> Result<(), SystemError> {
244         return Err(SystemError::EOPNOTSUPP_OR_ENOTSUP);
245     }
246 
247     /// @brief 将指定名称的子目录项的文件内容，移动到target这个目录下。如果_old_name所指向的inode与_target的相同，那么则直接执行重命名的操作。
248     ///
249     /// @param old_name 旧的名字
250     ///
251     /// @param target 移动到指定的inode
252     ///
253     /// @param new_name 新的文件名
254     ///
255     /// @return 成功: Ok()
256     ///         失败: Err(错误码)
move_( &self, _old_name: &str, _target: &Arc<dyn IndexNode>, _new_name: &str, ) -> Result<(), SystemError>257     fn move_(
258         &self,
259         _old_name: &str,
260         _target: &Arc<dyn IndexNode>,
261         _new_name: &str,
262     ) -> Result<(), SystemError> {
263         // 若文件系统没有实现此方法，则返回“不支持”
264         return Err(SystemError::EOPNOTSUPP_OR_ENOTSUP);
265     }
266 
267     /// @brief 寻找一个名为Name的inode
268     ///
269     /// @param name 要寻找的inode的名称
270     ///
271     /// @return 成功：Ok()
272     ///         失败：Err(错误码)
find(&self, _name: &str) -> Result<Arc<dyn IndexNode>, SystemError>273     fn find(&self, _name: &str) -> Result<Arc<dyn IndexNode>, SystemError> {
274         // 若文件系统没有实现此方法，则返回“不支持”
275         return Err(SystemError::EOPNOTSUPP_OR_ENOTSUP);
276     }
277 
278     /// @brief 根据inode号，获取子目录项的名字
279     ///
280     /// @param ino inode号
281     ///
282     /// @return 成功：Ok()
283     ///         失败：Err(错误码)
get_entry_name(&self, _ino: InodeId) -> Result<String, SystemError>284     fn get_entry_name(&self, _ino: InodeId) -> Result<String, SystemError> {
285         // 若文件系统没有实现此方法，则返回“不支持”
286         return Err(SystemError::EOPNOTSUPP_OR_ENOTSUP);
287     }
288 
289     /// @brief 根据inode号，获取子目录项的名字和元数据
290     ///
291     /// @param ino inode号
292     ///
293     /// @return 成功：Ok(String, Metadata)
294     ///         失败：Err(错误码)
get_entry_name_and_metadata(&self, ino: InodeId) -> Result<(String, Metadata), SystemError>295     fn get_entry_name_and_metadata(&self, ino: InodeId) -> Result<(String, Metadata), SystemError> {
296         // 如果有条件，请在文件系统中使用高效的方式实现本接口，而不是依赖这个低效率的默认实现。
297         let name = self.get_entry_name(ino)?;
298         let entry = self.find(&name)?;
299         return Ok((name, entry.metadata()?));
300     }
301 
302     /// @brief io control接口
303     ///
304     /// @param cmd 命令
305     /// @param data 数据
306     ///
307     /// @return 成功：Ok()
308     ///         失败：Err(错误码)
ioctl(&self, _cmd: u32, _data: usize) -> Result<usize, SystemError>309     fn ioctl(&self, _cmd: u32, _data: usize) -> Result<usize, SystemError> {
310         // 若文件系统没有实现此方法，则返回“不支持”
311         return Err(SystemError::EOPNOTSUPP_OR_ENOTSUP);
312     }
313 
314     /// @brief 获取inode所在的文件系统的指针
fs(&self) -> Arc<dyn FileSystem>315     fn fs(&self) -> Arc<dyn FileSystem>;
316 
317     /// @brief 本函数用于实现动态转换。
318     /// 具体的文件系统在实现本函数时，最简单的方式就是：直接返回self
as_any_ref(&self) -> &dyn Any319     fn as_any_ref(&self) -> &dyn Any;
320 
321     /// @brief 列出当前inode下的所有目录项的名字
list(&self) -> Result<Vec<String>, SystemError>322     fn list(&self) -> Result<Vec<String>, SystemError>;
323 
324     /// @brief 在当前Inode下，挂载一个新的文件系统
325     /// 请注意！该函数只能被MountFS实现，其他文件系统不应实现这个函数
mount(&self, _fs: Arc<dyn FileSystem>) -> Result<Arc<MountFS>, SystemError>326     fn mount(&self, _fs: Arc<dyn FileSystem>) -> Result<Arc<MountFS>, SystemError> {
327         return Err(SystemError::EOPNOTSUPP_OR_ENOTSUP);
328     }
329 
330     /// @brief 截断当前inode到指定的长度。如果当前文件长度小于len,则不操作。
331     ///
332     /// @param len 要被截断到的目标长度
truncate(&self, _len: usize) -> Result<(), SystemError>333     fn truncate(&self, _len: usize) -> Result<(), SystemError> {
334         return Err(SystemError::EOPNOTSUPP_OR_ENOTSUP);
335     }
336 
337     /// @brief 将当前inode的内容同步到具体设备上
sync(&self) -> Result<(), SystemError>338     fn sync(&self) -> Result<(), SystemError> {
339         return Ok(());
340     }
341 }
342 
343 impl DowncastArc for dyn IndexNode {
as_any_arc(self: Arc<Self>) -> Arc<dyn Any>344     fn as_any_arc(self: Arc<Self>) -> Arc<dyn Any> {
345         self
346     }
347 }
348 
349 impl dyn IndexNode {
350     /// @brief 将当前Inode转换为一个具体的结构体（类型由T指定）
351     /// 如果类型正确，则返回Some,否则返回None
downcast_ref<T: IndexNode>(&self) -> Option<&T>352     pub fn downcast_ref<T: IndexNode>(&self) -> Option<&T> {
353         return self.as_any_ref().downcast_ref::<T>();
354     }
355 
356     /// @brief 查找文件（不考虑符号链接）
357     ///
358     /// @param path 文件路径
359     ///
360     /// @return Ok(Arc<dyn IndexNode>) 要寻找的目录项的inode
361     /// @return Err(SystemError) 错误码
lookup(&self, path: &str) -> Result<Arc<dyn IndexNode>, SystemError>362     pub fn lookup(&self, path: &str) -> Result<Arc<dyn IndexNode>, SystemError> {
363         return self.lookup_follow_symlink(path, 0);
364     }
365 
366     /// @brief 查找文件（考虑符号链接）
367     ///
368     /// @param path 文件路径
369     /// @param max_follow_times 最大经过的符号链接的大小
370     ///
371     /// @return Ok(Arc<dyn IndexNode>) 要寻找的目录项的inode
372     /// @return Err(SystemError) 错误码
lookup_follow_symlink( &self, path: &str, max_follow_times: usize, ) -> Result<Arc<dyn IndexNode>, SystemError>373     pub fn lookup_follow_symlink(
374         &self,
375         path: &str,
376         max_follow_times: usize,
377     ) -> Result<Arc<dyn IndexNode>, SystemError> {
378         if self.metadata()?.file_type != FileType::Dir {
379             return Err(SystemError::ENOTDIR);
380         }
381 
382         // 处理绝对路径
383         // result: 上一个被找到的inode
384         // rest_path: 还没有查找的路径
385         let (mut result, mut rest_path) = if let Some(rest) = path.strip_prefix('/') {
386             (ROOT_INODE().clone(), String::from(rest))
387         } else {
388             // 是相对路径
389             (self.find(".")?, String::from(path))
390         };
391 
392         // 逐级查找文件
393         while !rest_path.is_empty() {
394             // 当前这一级不是文件夹
395             if result.metadata()?.file_type != FileType::Dir {
396                 return Err(SystemError::ENOTDIR);
397             }
398 
399             let name;
400 
401             // 寻找“/”
402             match rest_path.find('/') {
403                 Some(pos) => {
404                     // 找到了，设置下一个要查找的名字
405                     name = String::from(&rest_path[0..pos]);
406                     // 剩余的路径字符串
407                     rest_path = String::from(&rest_path[pos + 1..]);
408                 }
409                 None => {
410                     name = rest_path;
411                     rest_path = String::new();
412                 }
413             }
414 
415             // 遇到连续多个"/"的情况
416             if name.is_empty() {
417                 continue;
418             }
419 
420             let inode = result.find(&name)?;
421 
422             // 处理符号链接的问题
423             if inode.metadata()?.file_type == FileType::SymLink && max_follow_times > 0 {
424                 let mut content = [0u8; 256];
425                 // 读取符号链接
426                 let len = inode.read_at(0, 256, &mut content, &mut FilePrivateData::Unused)?;
427 
428                 // 将读到的数据转换为utf8字符串（先转为str，再转为String）
429                 let link_path = String::from(
430                     ::core::str::from_utf8(&content[..len]).map_err(|_| SystemError::ENOTDIR)?,
431                 );
432 
433                 let new_path = link_path + "/" + &rest_path;
434                 // 继续查找符号链接
435                 return result.lookup_follow_symlink(&new_path, max_follow_times - 1);
436             } else {
437                 result = inode;
438             }
439         }
440 
441         return Ok(result);
442     }
443 }
444 
445 /// IndexNode的元数据
446 ///
447 /// 对应Posix2008中的sys/stat.h中的定义 https://pubs.opengroup.org/onlinepubs/9699919799/basedefs/sys_stat.h.html
448 #[derive(Debug, PartialEq, Eq, Clone)]
449 pub struct Metadata {
450     /// 当前inode所在的文件系统的设备号
451     pub dev_id: usize,
452 
453     /// inode号
454     pub inode_id: InodeId,
455 
456     /// Inode的大小
457     /// 文件：文件大小（单位：字节）
458     /// 目录：目录项中的文件、文件夹数量
459     pub size: i64,
460 
461     /// Inode所在的文件系统中，每个块的大小
462     pub blk_size: usize,
463 
464     /// Inode所占的块的数目
465     pub blocks: usize,
466 
467     /// inode最后一次被访问的时间
468     pub atime: TimeSpec,
469 
470     /// inode最后一次修改的时间
471     pub mtime: TimeSpec,
472 
473     /// inode的创建时间
474     pub ctime: TimeSpec,
475 
476     /// 文件类型
477     pub file_type: FileType,
478 
479     /// 权限
480     pub mode: u32,
481 
482     /// 硬链接的数量
483     pub nlinks: usize,
484 
485     /// User ID
486     pub uid: usize,
487 
488     /// Group ID
489     pub gid: usize,
490 
491     /// 文件指向的设备的id（对于设备文件系统来说）
492     pub raw_dev: usize,
493 }
494 
495 impl Default for Metadata {
default() -> Self496     fn default() -> Self {
497         return Self {
498             dev_id: 0,
499             inode_id: 0,
500             size: 0,
501             blk_size: 0,
502             blocks: 0,
503             atime: TimeSpec::default(),
504             mtime: TimeSpec::default(),
505             ctime: TimeSpec::default(),
506             file_type: FileType::File,
507             mode: 0,
508             nlinks: 1,
509             uid: 0,
510             gid: 0,
511             raw_dev: 0,
512         };
513     }
514 }
515 
516 /// @brief 所有文件系统都应该实现的trait
517 pub trait FileSystem: Any + Sync + Send + Debug {
518     /// @brief 获取当前文件系统的root inode的指针
root_inode(&self) -> Arc<dyn IndexNode>519     fn root_inode(&self) -> Arc<dyn IndexNode>;
520 
521     /// @brief 获取当前文件系统的信息
info(&self) -> FsInfo522     fn info(&self) -> FsInfo;
523 
524     /// @brief 本函数用于实现动态转换。
525     /// 具体的文件系统在实现本函数时，最简单的方式就是：直接返回self
as_any_ref(&self) -> &dyn Any526     fn as_any_ref(&self) -> &dyn Any;
527 }
528 
529 #[derive(Debug)]
530 pub struct FsInfo {
531     /// 文件系统所在的块设备的id
532     pub blk_dev_id: usize,
533     /// 文件名的最大长度
534     pub max_name_len: usize,
535 }
536 
537 /// @brief 整合主设备号+次设备号
make_rawdev(major: usize, minor: usize) -> usize538 pub fn make_rawdev(major: usize, minor: usize) -> usize {
539     ((major & 0xffffff) << 8) | (minor & 0xff)
540 }
541 
542 /// @brief
543 #[repr(C)]
544 #[derive(Debug)]
545 pub struct Dirent {
546     d_ino: u64,    // 文件序列号
547     d_off: i64,    // dir偏移量
548     d_reclen: u16, // 目录下的记录数
549     d_type: u8,    // entry的类型
550     d_name: u8,    // 文件entry的名字(是一个零长数组)， 本字段仅用于占位
551 }
552 
553 impl Metadata {
new(file_type: FileType, mode: u32) -> Self554     pub fn new(file_type: FileType, mode: u32) -> Self {
555         Metadata {
556             dev_id: 0,
557             inode_id: generate_inode_id(),
558             size: 0,
559             blk_size: 0,
560             blocks: 0,
561             atime: TimeSpec::default(),
562             mtime: TimeSpec::default(),
563             ctime: TimeSpec::default(),
564             file_type,
565             mode,
566             nlinks: 1,
567             uid: 0,
568             gid: 0,
569             raw_dev: 0,
570         }
571     }
572 }
573