1 use core::{
2 hint::spin_loop,
3 ptr::null_mut,
4 sync::atomic::{AtomicUsize, Ordering},
5 };
6
7 use alloc::{boxed::Box, format, string::ToString, sync::Arc};
8
9 use crate::{
10 arch::asm::current::current_pcb,
11 driver::disk::ahci::{self},
12 filesystem::{
13 devfs::DevFS,
14 fat::fs::FATFileSystem,
15 procfs::ProcFS,
16 ramfs::RamFS,
17 sysfs::SysFS,
18 vfs::{file::File, mount::MountFS, FileSystem, FileType},
19 },
20 include::bindings::bindings::PAGE_4K_SIZE,
21 io::SeekFrom,
22 kerror, kinfo,
23 syscall::SystemError,
24 };
25
26 use super::{file::FileMode, utils::rsplit_path, IndexNode, InodeId};
27
28 /// @brief 原子地生成新的Inode号。
29 /// 请注意，所有的inode号都需要通过该函数来生成.全局的inode号，除了以下两个特殊的以外，都是唯一的
30 /// 特殊的两个inode号：
31 /// [0]: 对应'.'目录项
32 /// [1]: 对应'..'目录项
generate_inode_id() -> InodeId33 pub fn generate_inode_id() -> InodeId {
34 static INO: AtomicUsize = AtomicUsize::new(1);
35 return INO.fetch_add(1, Ordering::SeqCst);
36 }
37
38 static mut __ROOT_INODE: *mut Arc<dyn IndexNode> = null_mut();
39
40 /// @brief 获取全局的根节点
41 #[inline(always)]
42 #[allow(non_snake_case)]
ROOT_INODE() -> Arc<dyn IndexNode>43 pub fn ROOT_INODE() -> Arc<dyn IndexNode> {
44 unsafe {
45 return __ROOT_INODE.as_ref().unwrap().clone();
46 }
47 }
48
49 #[no_mangle]
vfs_init() -> i3250 pub extern "C" fn vfs_init() -> i32 {
51 // 使用Ramfs作为默认的根文件系统
52 let ramfs = RamFS::new();
53 let mount_fs = MountFS::new(ramfs, None);
54 let root_inode = Box::leak(Box::new(mount_fs.root_inode()));
55
56 unsafe {
57 __ROOT_INODE = root_inode;
58 }
59
60 // 创建文件夹
61 root_inode
62 .create("proc", FileType::Dir, 0o777)
63 .expect("Failed to create /proc");
64 root_inode
65 .create("dev", FileType::Dir, 0o777)
66 .expect("Failed to create /dev");
67 root_inode
68 .create("sys", FileType::Dir, 0o777)
69 .expect("Failed to create /sys");
70
71 // // 创建procfs实例
72 let procfs: Arc<ProcFS> = ProcFS::new();
73
74 // procfs挂载
75 let _t = root_inode
76 .find("proc")
77 .expect("Cannot find /proc")
78 .mount(procfs)
79 .expect("Failed to mount procfs.");
80 kinfo!("ProcFS mounted.");
81
82 // 创建 devfs 实例
83 let devfs: Arc<DevFS> = DevFS::new();
84 // devfs 挂载
85 let _t = root_inode
86 .find("dev")
87 .expect("Cannot find /dev")
88 .mount(devfs)
89 .expect("Failed to mount devfs");
90 kinfo!("DevFS mounted.");
91
92 // 创建 sysfs 实例
93 let sysfs: Arc<SysFS> = SysFS::new();
94 // sysfs 挂载
95 let _t = root_inode
96 .find("sys")
97 .expect("Cannot find /sys")
98 .mount(sysfs)
99 .expect("Failed to mount sysfs");
100 kinfo!("SysFS mounted.");
101
102 let root_inode = ROOT_INODE().list().expect("VFS init failed");
103 if root_inode.len() > 0 {
104 kinfo!("Successfully initialized VFS!");
105 }
106 return 0;
107 }
108
109 /// @brief 真正执行伪文件系统迁移的过程
110 ///
111 /// @param mountpoint_name 在根目录下的挂载点的名称
112 /// @param inode 原本的挂载点的inode
do_migrate( new_root_inode: Arc<dyn IndexNode>, mountpoint_name: &str, fs: &MountFS, ) -> Result<(), SystemError>113 fn do_migrate(
114 new_root_inode: Arc<dyn IndexNode>,
115 mountpoint_name: &str,
116 fs: &MountFS,
117 ) -> Result<(), SystemError> {
118 let r = new_root_inode.find(mountpoint_name);
119 let mountpoint = if r.is_err() {
120 new_root_inode
121 .create(mountpoint_name, FileType::Dir, 0o777)
122 .expect(format!("Failed to create '/{mountpoint_name}'").as_str())
123 } else {
124 r.unwrap()
125 };
126 // 迁移挂载点
127 mountpoint
128 .mount(fs.inner_filesystem())
129 .expect(format!("Failed to migrate {mountpoint_name}").as_str());
130 return Ok(());
131 }
132
133 /// @brief 迁移伪文件系统的inode
134 /// 请注意，为了避免删掉了伪文件系统内的信息，因此没有在原root inode那里调用unlink.
migrate_virtual_filesystem(new_fs: Arc<dyn FileSystem>) -> Result<(), SystemError>135 fn migrate_virtual_filesystem(new_fs: Arc<dyn FileSystem>) -> Result<(), SystemError> {
136 kinfo!("VFS: Migrating filesystems...");
137
138 // ==== 在这里获取要被迁移的文件系统的inode ===
139 let binding = ROOT_INODE().find("proc").expect("ProcFS not mounted!").fs();
140 let proc: &MountFS = binding.as_any_ref().downcast_ref::<MountFS>().unwrap();
141 let binding = ROOT_INODE().find("dev").expect("DevFS not mounted!").fs();
142 let dev: &MountFS = binding.as_any_ref().downcast_ref::<MountFS>().unwrap();
143 let binding = ROOT_INODE().find("sys").expect("SysFs not mounted!").fs();
144 let sys: &MountFS = binding.as_any_ref().downcast_ref::<MountFS>().unwrap();
145
146 let new_fs = MountFS::new(new_fs, None);
147 // 获取新的根文件系统的根节点的引用
148 let new_root_inode = Box::leak(Box::new(new_fs.root_inode()));
149
150 // 把上述文件系统,迁移到新的文件系统下
151 do_migrate(new_root_inode.clone(), "proc", proc)?;
152 do_migrate(new_root_inode.clone(), "dev", dev)?;
153 do_migrate(new_root_inode.clone(), "sys", sys)?;
154
155 unsafe {
156 // drop旧的Root inode
157 let old_root_inode: Box<Arc<dyn IndexNode>> = Box::from_raw(__ROOT_INODE);
158 __ROOT_INODE = null_mut();
159 drop(old_root_inode);
160
161 // 设置全局的新的ROOT Inode
162 __ROOT_INODE = new_root_inode;
163 }
164
165 kinfo!("VFS: Migrate filesystems done!");
166
167 return Ok(());
168 }
169
170 #[no_mangle]
mount_root_fs() -> i32171 pub extern "C" fn mount_root_fs() -> i32 {
172 kinfo!("Try to mount FAT32 as root fs...");
173 let partiton: Arc<crate::io::disk_info::Partition> =
174 ahci::get_disks_by_name("ahci_disk_0".to_string())
175 .unwrap()
176 .0
177 .lock()
178 .partitions[0]
179 .clone();
180
181 let fatfs: Result<Arc<FATFileSystem>, SystemError> = FATFileSystem::new(partiton);
182 if fatfs.is_err() {
183 kerror!(
184 "Failed to initialize fatfs, code={:?}",
185 fatfs.as_ref().err()
186 );
187 loop {
188 spin_loop();
189 }
190 }
191 let fatfs: Arc<FATFileSystem> = fatfs.unwrap();
192 let r = migrate_virtual_filesystem(fatfs);
193 if r.is_err() {
194 kerror!("Failed to migrate virtual filesystem to FAT32!");
195 loop {
196 spin_loop();
197 }
198 }
199 kinfo!("Successfully migrate rootfs to FAT32!");
200
201 return 0;
202 }
203
204 /// @brief 为当前进程打开一个文件
do_open(path: &str, mode: FileMode) -> Result<i32, SystemError>205 pub fn do_open(path: &str, mode: FileMode) -> Result<i32, SystemError> {
206 // 文件名过长
207 if path.len() > PAGE_4K_SIZE as usize {
208 return Err(SystemError::ENAMETOOLONG);
209 }
210
211 let inode: Result<Arc<dyn IndexNode>, SystemError> = ROOT_INODE().lookup(path);
212
213 let inode: Arc<dyn IndexNode> = if inode.is_err() {
214 let errno = inode.unwrap_err();
215 // 文件不存在，且需要创建
216 if mode.contains(FileMode::O_CREAT)
217 && !mode.contains(FileMode::O_DIRECTORY)
218 && errno == SystemError::ENOENT
219 {
220 let (filename, parent_path) = rsplit_path(path);
221 // 查找父目录
222 let parent_inode: Arc<dyn IndexNode> =
223 ROOT_INODE().lookup(parent_path.unwrap_or("/"))?;
224 // 创建文件
225 let inode: Arc<dyn IndexNode> = parent_inode.create(filename, FileType::File, 0o777)?;
226 inode
227 } else {
228 // 不需要创建文件，因此返回错误码
229 return Err(errno);
230 }
231 } else {
232 inode.unwrap()
233 };
234
235 let file_type: FileType = inode.metadata()?.file_type;
236 // 如果要打开的是文件夹，而目标不是文件夹
237 if mode.contains(FileMode::O_DIRECTORY) && file_type != FileType::Dir {
238 return Err(SystemError::ENOTDIR);
239 }
240
241 // 如果O_TRUNC，并且，打开模式包含O_RDWR或O_WRONLY，清空文件
242 if mode.contains(FileMode::O_TRUNC)
243 && (mode.contains(FileMode::O_RDWR) || mode.contains(FileMode::O_WRONLY))
244 && file_type == FileType::File
245 {
246 inode.truncate(0)?;
247 }
248
249 // 创建文件对象
250 let mut file: File = File::new(inode, mode)?;
251
252 // 打开模式为“追加”
253 if mode.contains(FileMode::O_APPEND) {
254 file.lseek(SeekFrom::SeekEnd(0))?;
255 }
256
257 // 把文件对象存入pcb
258 return current_pcb().alloc_fd(file, None);
259 }
260
261 /// @brief 根据文件描述符，读取文件数据。尝试读取的数据长度与buf的长度相同。
262 ///
263 /// @param fd 文件描述符编号
264 /// @param buf 输出缓冲区。
265 ///
266 /// @return Ok(usize) 成功读取的数据的字节数
267 /// @return Err(SystemError) 读取失败，返回posix错误码
do_read(fd: i32, buf: &mut [u8]) -> Result<usize, SystemError>268 pub fn do_read(fd: i32, buf: &mut [u8]) -> Result<usize, SystemError> {
269 let file: Option<&mut File> = current_pcb().get_file_mut_by_fd(fd);
270 if file.is_none() {
271 return Err(SystemError::EBADF);
272 }
273 let file: &mut File = file.unwrap();
274
275 return file.read(buf.len(), buf);
276 }
277
278 /// @brief 根据文件描述符，向文件写入数据。尝试写入的数据长度与buf的长度相同。
279 ///
280 /// @param fd 文件描述符编号
281 /// @param buf 输入缓冲区。
282 ///
283 /// @return Ok(usize) 成功写入的数据的字节数
284 /// @return Err(SystemError) 写入失败，返回posix错误码
do_write(fd: i32, buf: &[u8]) -> Result<usize, SystemError>285 pub fn do_write(fd: i32, buf: &[u8]) -> Result<usize, SystemError> {
286 let file: Option<&mut File> = current_pcb().get_file_mut_by_fd(fd);
287 if file.is_none() {
288 return Err(SystemError::EBADF);
289 }
290 let file: &mut File = file.unwrap();
291
292 return file.write(buf.len(), buf);
293 }
294
295 /// @brief 调整文件操作指针的位置
296 ///
297 /// @param fd 文件描述符编号
298 /// @param seek 调整的方式
299 ///
300 /// @return Ok(usize) 调整后，文件访问指针相对于文件头部的偏移量
301 /// @return Err(SystemError) 调整失败，返回posix错误码
do_lseek(fd: i32, seek: SeekFrom) -> Result<usize, SystemError>302 pub fn do_lseek(fd: i32, seek: SeekFrom) -> Result<usize, SystemError> {
303 let file: Option<&mut File> = current_pcb().get_file_mut_by_fd(fd);
304 if file.is_none() {
305 return Err(SystemError::EBADF);
306 }
307 let file: &mut File = file.unwrap();
308 return file.lseek(seek);
309 }
310
311 /// @brief 创建文件/文件夹
do_mkdir(path: &str, _mode: FileMode) -> Result<u64, SystemError>312 pub fn do_mkdir(path: &str, _mode: FileMode) -> Result<u64, SystemError> {
313 // 文件名过长
314 if path.len() > PAGE_4K_SIZE as usize {
315 return Err(SystemError::ENAMETOOLONG);
316 }
317
318 let inode: Result<Arc<dyn IndexNode>, SystemError> = ROOT_INODE().lookup(path);
319
320 if inode.is_err() {
321 let errno = inode.unwrap_err();
322 // 文件不存在，且需要创建
323 if errno == SystemError::ENOENT {
324 let (filename, parent_path) = rsplit_path(path);
325 // 查找父目录
326 let parent_inode: Arc<dyn IndexNode> =
327 ROOT_INODE().lookup(parent_path.unwrap_or("/"))?;
328 // 创建文件夹
329 let _create_inode: Arc<dyn IndexNode> =
330 parent_inode.create(filename, FileType::Dir, 0o777)?;
331 } else {
332 // 不需要创建文件，因此返回错误码
333 return Err(errno);
334 }
335 }
336
337 return Ok(0);
338 }
339
340 /// @breif 删除文件夹
do_remove_dir(path: &str) -> Result<u64, SystemError>341 pub fn do_remove_dir(path: &str) -> Result<u64, SystemError> {
342 // 文件名过长
343 if path.len() > PAGE_4K_SIZE as usize {
344 return Err(SystemError::ENAMETOOLONG);
345 }
346
347 let inode: Result<Arc<dyn IndexNode>, SystemError> = ROOT_INODE().lookup(path);
348
349 if inode.is_err() {
350 let errno = inode.unwrap_err();
351 // 文件不存在
352 if errno == SystemError::ENOENT {
353 return Err(SystemError::ENOENT);
354 }
355 }
356
357 let (filename, parent_path) = rsplit_path(path);
358 // 查找父目录
359 let parent_inode: Arc<dyn IndexNode> = ROOT_INODE().lookup(parent_path.unwrap_or("/"))?;
360
361 if parent_inode.metadata()?.file_type != FileType::Dir {
362 return Err(SystemError::ENOTDIR);
363 }
364
365 let target_inode: Arc<dyn IndexNode> = parent_inode.find(filename)?;
366 if target_inode.metadata()?.file_type != FileType::Dir {
367 return Err(SystemError::ENOTDIR);
368 }
369
370 // 删除文件夹
371 parent_inode.rmdir(filename)?;
372
373 return Ok(0);
374 }
375
376 /// @brief 删除文件
do_unlink_at(path: &str, _mode: FileMode) -> Result<u64, SystemError>377 pub fn do_unlink_at(path: &str, _mode: FileMode) -> Result<u64, SystemError> {
378 // 文件名过长
379 if path.len() > PAGE_4K_SIZE as usize {
380 return Err(SystemError::ENAMETOOLONG);
381 }
382
383 let inode: Result<Arc<dyn IndexNode>, SystemError> = ROOT_INODE().lookup(path);
384
385 if inode.is_err() {
386 let errno = inode.clone().unwrap_err();
387 // 文件不存在，且需要创建
388 if errno == SystemError::ENOENT {
389 return Err(SystemError::ENOENT);
390 }
391 }
392 // 禁止在目录上unlink
393 if inode.unwrap().metadata()?.file_type == FileType::Dir {
394 return Err(SystemError::EPERM);
395 }
396
397 let (filename, parent_path) = rsplit_path(path);
398 // 查找父目录
399 let parent_inode: Arc<dyn IndexNode> = ROOT_INODE().lookup(parent_path.unwrap_or("/"))?;
400
401 if parent_inode.metadata()?.file_type != FileType::Dir {
402 return Err(SystemError::ENOTDIR);
403 }
404
405 // 删除文件
406 parent_inode.unlink(filename)?;
407
408 return Ok(0);
409 }
410