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