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