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