xref: /DragonOS/kernel/src/filesystem/vfs/mod.rs (revision 9430523b465b19db4dd476e9fd3038bdc2aa0c8d) 
1 pub mod core;
2 pub mod fcntl;
3 pub mod file;
4 pub mod mount;
5 pub mod open;
6 pub mod syscall;
7 mod utils;
8 
9 use ::core::{any::Any, fmt::Debug, sync::atomic::AtomicUsize};
10 use alloc::{string::String, sync::Arc, vec::Vec};
11 use system_error::SystemError;
12 
13 use crate::{
14     driver::base::{
15         block::block_device::BlockDevice, char::CharDevice, device::device_number::DeviceNumber,
16     },
17     ipc::pipe::LockedPipeInode,
18     libs::casting::DowncastArc,
19     time::TimeSpec,
20 };
21 
22 use self::{core::generate_inode_id, file::FileMode, syscall::ModeType};
23 pub use self::{core::ROOT_INODE, file::FilePrivateData, mount::MountFS};
24 
25 /// vfs容许的最大的路径名称长度
26 pub const MAX_PATHLEN: usize = 1024;
27 
28 // 定义inode号
29 int_like!(InodeId, AtomicInodeId, usize, AtomicUsize);
30 
31 /// 文件的类型
32 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
33 pub enum FileType {
34     /// 文件
35     File,
36     /// 文件夹
37     Dir,
38     /// 块设备
39     BlockDevice,
40     /// 字符设备
41     CharDevice,
42     /// 帧缓冲设备
43     FramebufferDevice,
44     /// kvm设备
45     KvmDevice,
46     /// 管道文件
47     Pipe,
48     /// 符号链接
49     SymLink,
50     /// 套接字
51     Socket,
52 }
53 
54 #[allow(dead_code)]
55 #[derive(Debug, Clone)]
56 pub enum SpecialNodeData {
57     /// 管道文件
58     Pipe(Arc<LockedPipeInode>),
59     /// 字符设备
60     CharDevice(Arc<dyn CharDevice>),
61     /// 块设备
62     BlockDevice(Arc<dyn BlockDevice>),
63 }
64 
65 /* these are defined by POSIX and also present in glibc's dirent.h */
66 /// 完整含义请见 http://www.gnu.org/software/libc/manual/html_node/Directory-Entries.html
67 #[allow(dead_code)]
68 pub const DT_UNKNOWN: u16 = 0;
69 /// 命名管道，或者FIFO
70 pub const DT_FIFO: u16 = 1;
71 // 字符设备
72 pub const DT_CHR: u16 = 2;
73 // 目录
74 pub const DT_DIR: u16 = 4;
75 // 块设备
76 pub const DT_BLK: u16 = 6;
77 // 常规文件
78 pub const DT_REG: u16 = 8;
79 // 符号链接
80 pub const DT_LNK: u16 = 10;
81 // 是一个socket
82 pub const DT_SOCK: u16 = 12;
83 // 这个是抄Linux的，还不知道含义
84 #[allow(dead_code)]
85 pub const DT_WHT: u16 = 14;
86 #[allow(dead_code)]
87 pub const DT_MAX: u16 = 16;
88 
89 /// vfs容许的最大的符号链接跳转次数
90 pub const VFS_MAX_FOLLOW_SYMLINK_TIMES: usize = 8;
91 
92 impl FileType {
93     pub fn get_file_type_num(&self) -> u16 {
94         return match self {
95             FileType::File => DT_REG,
96             FileType::Dir => DT_DIR,
97             FileType::BlockDevice => DT_BLK,
98             FileType::CharDevice => DT_CHR,
99             FileType::KvmDevice => DT_CHR,
100             FileType::Pipe => DT_FIFO,
101             FileType::SymLink => DT_LNK,
102             FileType::Socket => DT_SOCK,
103             FileType::FramebufferDevice => DT_CHR,
104         };
105     }
106 }
107 
108 bitflags! {
109     /// @brief inode的状态（由poll方法返回）
110     pub struct PollStatus: u8 {
111         const WRITE = 1u8 << 0;
112         const READ = 1u8 << 1;
113         const ERROR = 1u8 << 2;
114     }
115 }
116 
117 pub trait IndexNode: Any + Sync + Send + Debug {
118     /// @brief 打开文件
119     ///
120     /// @return 成功：Ok()
121     ///         失败：Err(错误码)
122     fn open(&self, _data: &mut FilePrivateData, _mode: &FileMode) -> Result<(), SystemError> {
123         // 若文件系统没有实现此方法，则返回“不支持”
124         return Err(SystemError::EOPNOTSUPP_OR_ENOTSUP);
125     }
126 
127     /// @brief 关闭文件
128     ///
129     /// @return 成功：Ok()
130     ///         失败：Err(错误码)
131     fn close(&self, _data: &mut FilePrivateData) -> Result<(), SystemError> {
132         // 若文件系统没有实现此方法，则返回“不支持”
133         return Err(SystemError::EOPNOTSUPP_OR_ENOTSUP);
134     }
135 
136     /// @brief 在inode的指定偏移量开始，读取指定大小的数据
137     ///
138     /// @param offset 起始位置在Inode中的偏移量
139     /// @param len 要读取的字节数
140     /// @param buf 缓冲区. 请注意，必须满足@buf.len()>=@len
141     /// @param _data 各文件系统系统所需私有信息
142     ///
143     /// @return 成功：Ok(读取的字节数)
144     ///         失败：Err(Posix错误码)
145     fn read_at(
146         &self,
147         offset: usize,
148         len: usize,
149         buf: &mut [u8],
150         _data: &mut FilePrivateData,
151     ) -> Result<usize, SystemError>;
152 
153     /// @brief 在inode的指定偏移量开始，写入指定大小的数据（从buf的第0byte开始写入）
154     ///
155     /// @param offset 起始位置在Inode中的偏移量
156     /// @param len 要写入的字节数
157     /// @param buf 缓冲区. 请注意，必须满足@buf.len()>=@len
158     /// @param _data 各文件系统系统所需私有信息
159     ///
160     /// @return 成功：Ok(写入的字节数)
161     ///         失败：Err(Posix错误码)
162     fn write_at(
163         &self,
164         offset: usize,
165         len: usize,
166         buf: &[u8],
167         _data: &mut FilePrivateData,
168     ) -> Result<usize, SystemError>;
169 
170     /// @brief 获取当前inode的状态。
171     ///
172     /// @return PollStatus结构体
173     fn poll(&self, _private_data: &FilePrivateData) -> Result<usize, SystemError> {
174         // 若文件系统没有实现此方法，则返回“不支持”
175         return Err(SystemError::EOPNOTSUPP_OR_ENOTSUP);
176     }
177 
178     /// @brief 获取inode的元数据
179     ///
180     /// @return 成功：Ok(inode的元数据)
181     ///         失败：Err(错误码)
182     fn metadata(&self) -> Result<Metadata, SystemError> {
183         // 若文件系统没有实现此方法，则返回“不支持”
184         return Err(SystemError::EOPNOTSUPP_OR_ENOTSUP);
185     }
186 
187     /// @brief 设置inode的元数据
188     ///
189     /// @return 成功：Ok()
190     ///         失败：Err(错误码)
191     fn set_metadata(&self, _metadata: &Metadata) -> Result<(), SystemError> {
192         // 若文件系统没有实现此方法，则返回“不支持”
193         return Err(SystemError::EOPNOTSUPP_OR_ENOTSUP);
194     }
195 
196     /// @brief 重新设置文件的大小
197     ///
198     /// 如果文件大小增加，则文件内容不变，但是文件的空洞部分会被填充为0
199     /// 如果文件大小减小，则文件内容会被截断
200     ///
201     /// @return 成功：Ok()
202     ///         失败：Err(错误码)
203     fn resize(&self, _len: usize) -> Result<(), SystemError> {
204         // 若文件系统没有实现此方法，则返回“不支持”
205         return Err(SystemError::EOPNOTSUPP_OR_ENOTSUP);
206     }
207 
208     /// @brief 在当前目录下创建一个新的inode
209     ///
210     /// @param name 目录项的名字
211     /// @param file_type 文件类型
212     /// @param mode 权限
213     ///
214     /// @return 创建成功：返回Ok(新的inode的Arc指针)
215     /// @return 创建失败：返回Err(错误码)
216     fn create(
217         &self,
218         name: &str,
219         file_type: FileType,
220         mode: ModeType,
221     ) -> Result<Arc<dyn IndexNode>, SystemError> {
222         // 若文件系统没有实现此方法，则默认调用其create_with_data方法。如果仍未实现，则会得到一个Err(-EOPNOTSUPP_OR_ENOTSUP)的返回值
223         return self.create_with_data(name, file_type, mode, 0);
224     }
225 
226     /// @brief 在当前目录下创建一个新的inode，并传入一个简单的data字段，方便进行初始化。
227     ///
228     /// @param name 目录项的名字
229     /// @param file_type 文件类型
230     /// @param mode 权限
231     /// @param data 用于初始化该inode的数据。（为0则表示忽略此字段）对于不同的文件系统来说，代表的含义可能不同。
232     ///
233     /// @return 创建成功：返回Ok(新的inode的Arc指针)
234     /// @return 创建失败：返回Err(错误码)
235     fn create_with_data(
236         &self,
237         _name: &str,
238         _file_type: FileType,
239         _mode: ModeType,
240         _data: usize,
241     ) -> Result<Arc<dyn IndexNode>, SystemError> {
242         // 若文件系统没有实现此方法，则返回“不支持”
243         return Err(SystemError::EOPNOTSUPP_OR_ENOTSUP);
244     }
245 
246     /// @brief 在当前目录下，创建一个名为Name的硬链接，指向另一个IndexNode
247     ///
248     /// @param name 硬链接的名称
249     /// @param other 要被指向的IndexNode的Arc指针
250     ///
251     /// @return 成功：Ok()
252     ///         失败：Err(错误码)
253     fn link(&self, _name: &str, _other: &Arc<dyn IndexNode>) -> Result<(), SystemError> {
254         // 若文件系统没有实现此方法，则返回“不支持”
255         return Err(SystemError::EOPNOTSUPP_OR_ENOTSUP);
256     }
257 
258     /// @brief 在当前目录下，删除一个名为Name的硬链接
259     ///
260     /// @param name 硬链接的名称
261     ///
262     /// @return 成功：Ok()
263     ///         失败：Err(错误码)
264     fn unlink(&self, _name: &str) -> Result<(), SystemError> {
265         // 若文件系统没有实现此方法，则返回“不支持”
266         return Err(SystemError::EOPNOTSUPP_OR_ENOTSUP);
267     }
268 
269     /// @brief 删除文件夹
270     ///
271     /// @param name 文件夹名称
272     ///
273     /// @return 成功 Ok(())
274     /// @return 失败 Err(错误码)
275     fn rmdir(&self, _name: &str) -> Result<(), SystemError> {
276         return Err(SystemError::EOPNOTSUPP_OR_ENOTSUP);
277     }
278 
279     /// @brief 将指定名称的子目录项的文件内容，移动到target这个目录下。如果_old_name所指向的inode与_target的相同，那么则直接执行重命名的操作。
280     ///
281     /// @param old_name 旧的名字
282     ///
283     /// @param target 移动到指定的inode
284     ///
285     /// @param new_name 新的文件名
286     ///
287     /// @return 成功: Ok()
288     ///         失败: Err(错误码)
289     fn move_to(
290         &self,
291         _old_name: &str,
292         _target: &Arc<dyn IndexNode>,
293         _new_name: &str,
294     ) -> Result<(), SystemError> {
295         // 若文件系统没有实现此方法，则返回“不支持”
296         return Err(SystemError::EOPNOTSUPP_OR_ENOTSUP);
297     }
298 
299     /// # 修改文件名
300     ///
301     ///
302     /// ## 参数
303     ///
304     /// - _old_name: 源文件路径
305     /// - _new_name: 目标文件路径
306     ///
307     /// ## 返回值
308     /// - Ok(返回值类型): 返回值的说明
309     /// - Err(错误值类型): 错误的说明
310     ///
311     fn rename(&self, _old_name: &str, _new_name: &str) -> Result<(), SystemError> {
312         // 若文件系统没有实现此方法，则返回“不支持”
313         return Err(SystemError::EOPNOTSUPP_OR_ENOTSUP);
314     }
315 
316     /// @brief 寻找一个名为Name的inode
317     ///
318     /// @param name 要寻找的inode的名称
319     ///
320     /// @return 成功：Ok()
321     ///         失败：Err(错误码)
322     fn find(&self, _name: &str) -> Result<Arc<dyn IndexNode>, SystemError> {
323         // 若文件系统没有实现此方法，则返回“不支持”
324         return Err(SystemError::EOPNOTSUPP_OR_ENOTSUP);
325     }
326 
327     /// @brief 根据inode号，获取子目录项的名字
328     ///
329     /// @param ino inode号
330     ///
331     /// @return 成功：Ok()
332     ///         失败：Err(错误码)
333     fn get_entry_name(&self, _ino: InodeId) -> Result<String, SystemError> {
334         // 若文件系统没有实现此方法，则返回“不支持”
335         return Err(SystemError::EOPNOTSUPP_OR_ENOTSUP);
336     }
337 
338     /// @brief 根据inode号，获取子目录项的名字和元数据
339     ///
340     /// @param ino inode号
341     ///
342     /// @return 成功：Ok(String, Metadata)
343     ///         失败：Err(错误码)
344     fn get_entry_name_and_metadata(&self, ino: InodeId) -> Result<(String, Metadata), SystemError> {
345         // 如果有条件，请在文件系统中使用高效的方式实现本接口，而不是依赖这个低效率的默认实现。
346         let name = self.get_entry_name(ino)?;
347         let entry = self.find(&name)?;
348         return Ok((name, entry.metadata()?));
349     }
350 
351     /// @brief io control接口
352     ///
353     /// @param cmd 命令
354     /// @param data 数据
355     ///
356     /// @return 成功：Ok()
357     ///         失败：Err(错误码)
358     fn ioctl(
359         &self,
360         _cmd: u32,
361         _data: usize,
362         _private_data: &FilePrivateData,
363     ) -> Result<usize, SystemError> {
364         // 若文件系统没有实现此方法，则返回“不支持”
365         return Err(SystemError::EOPNOTSUPP_OR_ENOTSUP);
366     }
367 
368     /// @brief 获取inode所在的文件系统的指针
369     fn fs(&self) -> Arc<dyn FileSystem>;
370 
371     /// @brief 本函数用于实现动态转换。
372     /// 具体的文件系统在实现本函数时，最简单的方式就是：直接返回self
373     fn as_any_ref(&self) -> &dyn Any;
374 
375     /// @brief 列出当前inode下的所有目录项的名字
376     fn list(&self) -> Result<Vec<String>, SystemError>;
377 
378     /// @brief 在当前Inode下，挂载一个新的文件系统
379     /// 请注意！该函数只能被MountFS实现，其他文件系统不应实现这个函数
380     fn mount(&self, _fs: Arc<dyn FileSystem>) -> Result<Arc<MountFS>, SystemError> {
381         return Err(SystemError::EOPNOTSUPP_OR_ENOTSUP);
382     }
383 
384     /// @brief 截断当前inode到指定的长度。如果当前文件长度小于len,则不操作。
385     ///
386     /// @param len 要被截断到的目标长度
387     fn truncate(&self, _len: usize) -> Result<(), SystemError> {
388         return Err(SystemError::EOPNOTSUPP_OR_ENOTSUP);
389     }
390 
391     /// @brief 将当前inode的内容同步到具体设备上
392     fn sync(&self) -> Result<(), SystemError> {
393         return Ok(());
394     }
395 
396     /// ## 创建一个特殊文件节点
397     /// - _filename: 文件名
398     /// - _mode: 权限信息
399     fn mknod(
400         &self,
401         _filename: &str,
402         _mode: ModeType,
403         _dev_t: DeviceNumber,
404     ) -> Result<Arc<dyn IndexNode>, SystemError> {
405         return Err(SystemError::EOPNOTSUPP_OR_ENOTSUP);
406     }
407 
408     /// ## 返回特殊文件的inode
409     fn special_node(&self) -> Option<SpecialNodeData> {
410         None
411     }
412 }
413 
414 impl DowncastArc for dyn IndexNode {
415     fn as_any_arc(self: Arc<Self>) -> Arc<dyn Any> {
416         self
417     }
418 }
419 
420 impl dyn IndexNode {
421     /// @brief 将当前Inode转换为一个具体的结构体（类型由T指定）
422     /// 如果类型正确，则返回Some,否则返回None
423     pub fn downcast_ref<T: IndexNode>(&self) -> Option<&T> {
424         return self.as_any_ref().downcast_ref::<T>();
425     }
426 
427     /// @brief 查找文件（不考虑符号链接）
428     ///
429     /// @param path 文件路径
430     ///
431     /// @return Ok(Arc<dyn IndexNode>) 要寻找的目录项的inode
432     /// @return Err(SystemError) 错误码
433     pub fn lookup(&self, path: &str) -> Result<Arc<dyn IndexNode>, SystemError> {
434         return self.lookup_follow_symlink(path, 0);
435     }
436 
437     /// @brief 查找文件（考虑符号链接）
438     ///
439     /// @param path 文件路径
440     /// @param max_follow_times 最大经过的符号链接的大小
441     ///
442     /// @return Ok(Arc<dyn IndexNode>) 要寻找的目录项的inode
443     /// @return Err(SystemError) 错误码
444     pub fn lookup_follow_symlink(
445         &self,
446         path: &str,
447         max_follow_times: usize,
448     ) -> Result<Arc<dyn IndexNode>, SystemError> {
449         if self.metadata()?.file_type != FileType::Dir {
450             return Err(SystemError::ENOTDIR);
451         }
452 
453         // 处理绝对路径
454         // result: 上一个被找到的inode
455         // rest_path: 还没有查找的路径
456         let (mut result, mut rest_path) = if let Some(rest) = path.strip_prefix('/') {
457             (ROOT_INODE().clone(), String::from(rest))
458         } else {
459             // 是相对路径
460             (self.find(".")?, String::from(path))
461         };
462 
463         // 逐级查找文件
464         while !rest_path.is_empty() {
465             // 当前这一级不是文件夹
466             if result.metadata()?.file_type != FileType::Dir {
467                 return Err(SystemError::ENOTDIR);
468             }
469 
470             let name;
471 
472             // 寻找“/”
473             match rest_path.find('/') {
474                 Some(pos) => {
475                     // 找到了，设置下一个要查找的名字
476                     name = String::from(&rest_path[0..pos]);
477                     // 剩余的路径字符串
478                     rest_path = String::from(&rest_path[pos + 1..]);
479                 }
480                 None => {
481                     name = rest_path;
482                     rest_path = String::new();
483                 }
484             }
485 
486             // 遇到连续多个"/"的情况
487             if name.is_empty() {
488                 continue;
489             }
490 
491             let inode = result.find(&name)?;
492 
493             // 处理符号链接的问题
494             if inode.metadata()?.file_type == FileType::SymLink && max_follow_times > 0 {
495                 let mut content = [0u8; 256];
496                 // 读取符号链接
497                 let len = inode.read_at(0, 256, &mut content, &mut FilePrivateData::Unused)?;
498 
499                 // 将读到的数据转换为utf8字符串（先转为str，再转为String）
500                 let link_path = String::from(
501                     ::core::str::from_utf8(&content[..len]).map_err(|_| SystemError::ENOTDIR)?,
502                 );
503 
504                 let new_path = link_path + "/" + &rest_path;
505                 // 继续查找符号链接
506                 return result.lookup_follow_symlink(&new_path, max_follow_times - 1);
507             } else {
508                 result = inode;
509             }
510         }
511 
512         return Ok(result);
513     }
514 }
515 
516 /// IndexNode的元数据
517 ///
518 /// 对应Posix2008中的sys/stat.h中的定义 https://pubs.opengroup.org/onlinepubs/9699919799/basedefs/sys_stat.h.html
519 #[derive(Debug, PartialEq, Eq, Clone)]
520 pub struct Metadata {
521     /// 当前inode所在的文件系统的设备号
522     pub dev_id: usize,
523 
524     /// inode号
525     pub inode_id: InodeId,
526 
527     /// Inode的大小
528     /// 文件：文件大小（单位：字节）
529     /// 目录：目录项中的文件、文件夹数量
530     pub size: i64,
531 
532     /// Inode所在的文件系统中，每个块的大小
533     pub blk_size: usize,
534 
535     /// Inode所占的块的数目
536     pub blocks: usize,
537 
538     /// inode最后一次被访问的时间
539     pub atime: TimeSpec,
540 
541     /// inode最后一次修改的时间
542     pub mtime: TimeSpec,
543 
544     /// inode的创建时间
545     pub ctime: TimeSpec,
546 
547     /// 文件类型
548     pub file_type: FileType,
549 
550     /// 权限
551     pub mode: ModeType,
552 
553     /// 硬链接的数量
554     pub nlinks: usize,
555 
556     /// User ID
557     pub uid: usize,
558 
559     /// Group ID
560     pub gid: usize,
561 
562     /// 文件指向的设备的id（对于设备文件系统来说）
563     pub raw_dev: DeviceNumber,
564 }
565 
566 impl Default for Metadata {
567     fn default() -> Self {
568         return Self {
569             dev_id: 0,
570             inode_id: InodeId::new(0),
571             size: 0,
572             blk_size: 0,
573             blocks: 0,
574             atime: TimeSpec::default(),
575             mtime: TimeSpec::default(),
576             ctime: TimeSpec::default(),
577             file_type: FileType::File,
578             mode: ModeType::empty(),
579             nlinks: 1,
580             uid: 0,
581             gid: 0,
582             raw_dev: DeviceNumber::default(),
583         };
584     }
585 }
586 
587 #[derive(Debug, Clone)]
588 pub struct SuperBlock {
589     // type of filesystem
590     pub magic: Magic,
591     // optimal transfer block size
592     pub bsize: u64,
593     // total data blocks in filesystem
594     pub blocks: u64,
595     // free block in system
596     pub bfree: u64,
597     // 可供非特权用户使用的空闲块
598     pub bavail: u64,
599     // total inodes in filesystem
600     pub files: u64,
601     // free inodes in filesystem
602     pub ffree: u64,
603     // filesysytem id
604     pub fsid: u64,
605     // Max length of filename
606     pub namelen: u64,
607     // fragment size
608     pub frsize: u64,
609     // mount flags of filesystem
610     pub flags: u64,
611 }
612 
613 impl SuperBlock {
614     pub fn new(magic: Magic, bsize: u64, namelen: u64) -> Self {
615         Self {
616             magic,
617             bsize,
618             blocks: 0,
619             bfree: 0,
620             bavail: 0,
621             files: 0,
622             ffree: 0,
623             fsid: 0,
624             namelen,
625             frsize: 0,
626             flags: 0,
627         }
628     }
629 }
630 bitflags! {
631     pub struct Magic: u64 {
632         const DEVFS_MAGIC = 0x1373;
633         const FAT_MAGIC =  0xf2f52011;
634         const KER_MAGIC = 0x3153464b;
635         const PROC_MAGIC = 0x9fa0;
636         const RAMFS_MAGIC = 0x858458f6;
637         const MOUNT_MAGIC = 61267;
638     }
639 }
640 
641 /// @brief 所有文件系统都应该实现的trait
642 pub trait FileSystem: Any + Sync + Send + Debug {
643     /// @brief 获取当前文件系统的root inode的指针
644     fn root_inode(&self) -> Arc<dyn IndexNode>;
645 
646     /// @brief 获取当前文件系统的信息
647     fn info(&self) -> FsInfo;
648 
649     /// @brief 本函数用于实现动态转换。
650     /// 具体的文件系统在实现本函数时，最简单的方式就是：直接返回self
651     fn as_any_ref(&self) -> &dyn Any;
652 
653     fn name(&self) -> &str;
654 
655     fn super_block(&self) -> SuperBlock;
656 }
657 
658 impl DowncastArc for dyn FileSystem {
659     fn as_any_arc(self: Arc<Self>) -> Arc<dyn Any> {
660         self
661     }
662 }
663 
664 #[derive(Debug)]
665 pub struct FsInfo {
666     /// 文件系统所在的块设备的id
667     pub blk_dev_id: usize,
668     /// 文件名的最大长度
669     pub max_name_len: usize,
670 }
671 
672 /// @brief
673 #[repr(C)]
674 #[derive(Debug)]
675 pub struct Dirent {
676     d_ino: u64,    // 文件序列号
677     d_off: i64,    // dir偏移量
678     d_reclen: u16, // 目录下的记录数
679     d_type: u8,    // entry的类型
680     d_name: u8,    // 文件entry的名字(是一个零长数组)， 本字段仅用于占位
681 }
682 
683 impl Metadata {
684     pub fn new(file_type: FileType, mode: ModeType) -> Self {
685         Metadata {
686             dev_id: 0,
687             inode_id: generate_inode_id(),
688             size: 0,
689             blk_size: 0,
690             blocks: 0,
691             atime: TimeSpec::default(),
692             mtime: TimeSpec::default(),
693             ctime: TimeSpec::default(),
694             file_type,
695             mode,
696             nlinks: 1,
697             uid: 0,
698             gid: 0,
699             raw_dev: DeviceNumber::default(),
700         }
701     }
702 }
703 pub struct FileSystemMaker {
704     function: &'static FileSystemNewFunction,
705     name: &'static str,
706 }
707 
708 impl FileSystemMaker {
709     pub const fn new(
710         name: &'static str,
711         function: &'static FileSystemNewFunction,
712     ) -> FileSystemMaker {
713         FileSystemMaker { function, name }
714     }
715 
716     pub fn call(&self) -> Result<Arc<dyn FileSystem>, SystemError> {
717         (self.function)()
718     }
719 }
720 
721 pub type FileSystemNewFunction = fn() -> Result<Arc<dyn FileSystem>, SystemError>;
722 
723 #[macro_export]
724 macro_rules! define_filesystem_maker_slice {
725     ($name:ident) => {
726         #[::linkme::distributed_slice]
727         pub static $name: [FileSystemMaker] = [..];
728     };
729     () => {
730         compile_error!("define_filesystem_maker_slice! requires at least one argument: slice_name");
731     };
732 }
733 
734 /// 调用指定数组中的所有初始化器
735 #[macro_export]
736 macro_rules! producefs {
737     ($initializer_slice:ident,$filesystem:ident) => {
738         match $initializer_slice.iter().find(|&m| m.name == $filesystem) {
739             Some(maker) => maker.call(),
740             None => {
741                 kerror!("mismatch filesystem type : {}", $filesystem);
742                 Err(SystemError::EINVAL)
743             }
744         }
745     };
746 }
747 
748 define_filesystem_maker_slice!(FSMAKER);
749