xref: /DragonOS/kernel/src/filesystem/vfs/core.rs (revision 80c9e8f8f0adb25c1a33ff09cb51e7df5b1cdd99) 
1 use core::{hint::spin_loop, sync::atomic::Ordering};
2 
3 use alloc::sync::Arc;
4 use log::{error, info};
5 use system_error::SystemError;
6 
7 use crate::{
8     driver::base::block::{gendisk::GenDisk, manager::block_dev_manager},
9     filesystem::{
10         devfs::devfs_init,
11         fat::fs::FATFileSystem,
12         procfs::procfs_init,
13         ramfs::RamFS,
14         sysfs::sysfs_init,
15         vfs::{
16             mount::MountFS, syscall::ModeType, AtomicInodeId, FileSystem, FileType, MAX_PATHLEN,
17         },
18     },
19     libs::spinlock::SpinLock,
20     process::ProcessManager,
21     syscall::user_access::check_and_clone_cstr,
22 };
23 
24 use super::{
25     fcntl::AtFlags,
26     file::FileMode,
27     mount::{init_mountlist, MOUNT_LIST},
28     syscall::UmountFlag,
29     utils::{rsplit_path, user_path_at},
30     FilePrivateData, IndexNode, InodeId, VFS_MAX_FOLLOW_SYMLINK_TIMES,
31 };
32 
33 /// 当没有指定根文件系统时，尝试的根文件系统列表
34 const ROOTFS_TRY_LIST: [&str; 4] = ["/dev/sda1", "/dev/sda", "/dev/vda1", "/dev/vda"];
35 kernel_cmdline_param_kv!(ROOTFS_PATH_PARAM, root, "");
36 
37 /// @brief 原子地生成新的Inode号。
38 /// 请注意，所有的inode号都需要通过该函数来生成.全局的inode号，除了以下两个特殊的以外，都是唯一的
39 /// 特殊的两个inode号：
40 /// [0]: 对应'.'目录项
41 /// [1]: 对应'..'目录项
42 pub fn generate_inode_id() -> InodeId {
43     static INO: AtomicInodeId = AtomicInodeId::new(InodeId::new(1));
44     return INO.fetch_add(InodeId::new(1), Ordering::SeqCst);
45 }
46 
47 static mut __ROOT_INODE: Option<Arc<dyn IndexNode>> = None;
48 
49 /// @brief 获取全局的根节点
50 #[inline(always)]
51 #[allow(non_snake_case)]
52 pub fn ROOT_INODE() -> Arc<dyn IndexNode> {
53     unsafe {
54         return __ROOT_INODE.as_ref().unwrap().clone();
55     }
56 }
57 
58 /// 初始化虚拟文件系统
59 #[inline(never)]
60 pub fn vfs_init() -> Result<(), SystemError> {
61     // 使用Ramfs作为默认的根文件系统
62     let ramfs = RamFS::new();
63     let mount_fs = MountFS::new(ramfs, None);
64     let root_inode = mount_fs.root_inode();
65     init_mountlist();
66     unsafe {
67         __ROOT_INODE = Some(root_inode.clone());
68     }
69 
70     procfs_init().expect("Failed to initialize procfs");
71 
72     devfs_init().expect("Failed to initialize devfs");
73 
74     sysfs_init().expect("Failed to initialize sysfs");
75 
76     let root_entries = ROOT_INODE().list().expect("VFS init failed");
77     if !root_entries.is_empty() {
78         info!("Successfully initialized VFS!");
79     }
80     return Ok(());
81 }
82 
83 /// @brief 迁移伪文件系统的inode
84 /// 请注意，为了避免删掉了伪文件系统内的信息，因此没有在原root inode那里调用unlink.
85 fn migrate_virtual_filesystem(new_fs: Arc<dyn FileSystem>) -> Result<(), SystemError> {
86     info!("VFS: Migrating filesystems...");
87 
88     let new_fs = MountFS::new(new_fs, None);
89     // 获取新的根文件系统的根节点的引用
90     let new_root_inode = new_fs.root_inode();
91 
92     // ==== 在这里获取要被迁移的文件系统的inode并迁移 ===
93     // 因为是换根所以路径没有变化
94     // 不需要重新注册挂载目录
95     new_root_inode
96         .mkdir("proc", ModeType::from_bits_truncate(0o755))
97         .expect("Unable to create /proc")
98         .mount_from(ROOT_INODE().find("proc").expect("proc not mounted!"))
99         .expect("Failed to migrate filesystem of proc");
100     new_root_inode
101         .mkdir("dev", ModeType::from_bits_truncate(0o755))
102         .expect("Unable to create /dev")
103         .mount_from(ROOT_INODE().find("dev").expect("dev not mounted!"))
104         .expect("Failed to migrate filesystem of dev");
105     new_root_inode
106         .mkdir("sys", ModeType::from_bits_truncate(0o755))
107         .expect("Unable to create /sys")
108         .mount_from(ROOT_INODE().find("sys").expect("sys not mounted!"))
109         .expect("Failed to migrate filesystem of sys");
110 
111     unsafe {
112         // drop旧的Root inode
113         let old_root_inode = __ROOT_INODE.take().unwrap();
114         // 设置全局的新的ROOT Inode
115         __ROOT_INODE = Some(new_root_inode.clone());
116         drop(old_root_inode);
117     }
118 
119     info!("VFS: Migrate filesystems done!");
120 
121     return Ok(());
122 }
123 
124 fn try_find_gendisk_as_rootfs(path: &str) -> Option<Arc<GenDisk>> {
125     if let Some(gd) = block_dev_manager().lookup_gendisk_by_path(path) {
126         info!("Use {} as rootfs", path);
127         return Some(gd);
128     }
129     return None;
130 }
131 
132 pub fn mount_root_fs() -> Result<(), SystemError> {
133     info!("Try to mount root fs...");
134     block_dev_manager().print_gendisks();
135     let gendisk = if let Some(rootfs_dev_path) = ROOTFS_PATH_PARAM.value_str() {
136         try_find_gendisk_as_rootfs(rootfs_dev_path)
137             .unwrap_or_else(|| panic!("Failed to find rootfs device {}", rootfs_dev_path))
138     } else {
139         ROOTFS_TRY_LIST
140             .iter()
141             .find_map(|&path| try_find_gendisk_as_rootfs(path))
142             .ok_or(SystemError::ENODEV)?
143     };
144 
145     let fatfs: Result<Arc<FATFileSystem>, SystemError> = FATFileSystem::new(gendisk);
146     if fatfs.is_err() {
147         error!(
148             "Failed to initialize fatfs, code={:?}",
149             fatfs.as_ref().err()
150         );
151         loop {
152             spin_loop();
153         }
154     }
155     let fatfs: Arc<FATFileSystem> = fatfs.unwrap();
156     let r = migrate_virtual_filesystem(fatfs);
157     if r.is_err() {
158         error!("Failed to migrate virtual filesystem to FAT32!");
159         loop {
160             spin_loop();
161         }
162     }
163     info!("Successfully migrate rootfs to FAT32!");
164 
165     return Ok(());
166 }
167 
168 /// @brief 创建文件/文件夹
169 pub fn do_mkdir_at(
170     dirfd: i32,
171     path: &str,
172     mode: FileMode,
173 ) -> Result<Arc<dyn IndexNode>, SystemError> {
174     // debug!("Call do mkdir at");
175     let (mut current_inode, path) =
176         user_path_at(&ProcessManager::current_pcb(), dirfd, path.trim())?;
177     let (name, parent) = rsplit_path(&path);
178     if let Some(parent) = parent {
179         current_inode =
180             current_inode.lookup_follow_symlink(parent, VFS_MAX_FOLLOW_SYMLINK_TIMES)?;
181     }
182     // debug!("mkdir at {:?}", current_inode.metadata()?.inode_id);
183     return current_inode.mkdir(name, ModeType::from_bits_truncate(mode.bits()));
184 }
185 
186 /// @brief 删除文件夹
187 pub fn do_remove_dir(dirfd: i32, path: &str) -> Result<u64, SystemError> {
188     let path = path.trim();
189 
190     let pcb = ProcessManager::current_pcb();
191     let (inode_begin, remain_path) = user_path_at(&pcb, dirfd, path)?;
192     let (filename, parent_path) = rsplit_path(&remain_path);
193 
194     // 最后一项文件项为.时返回EINVAL
195     if filename == "." {
196         return Err(SystemError::EINVAL);
197     }
198 
199     // 查找父目录
200     let parent_inode: Arc<dyn IndexNode> = inode_begin
201         .lookup_follow_symlink(parent_path.unwrap_or("/"), VFS_MAX_FOLLOW_SYMLINK_TIMES)?;
202 
203     if parent_inode.metadata()?.file_type != FileType::Dir {
204         return Err(SystemError::ENOTDIR);
205     }
206 
207     // 在目标点为symlink时也返回ENOTDIR
208     let target_inode = parent_inode.find(filename)?;
209     if target_inode.metadata()?.file_type != FileType::Dir {
210         return Err(SystemError::ENOTDIR);
211     }
212 
213     // 删除文件夹
214     parent_inode.rmdir(filename)?;
215 
216     return Ok(0);
217 }
218 
219 /// @brief 删除文件
220 pub fn do_unlink_at(dirfd: i32, path: &str) -> Result<u64, SystemError> {
221     let path = path.trim();
222 
223     let pcb = ProcessManager::current_pcb();
224     let (inode_begin, remain_path) = user_path_at(&pcb, dirfd, path)?;
225     let inode: Result<Arc<dyn IndexNode>, SystemError> =
226         inode_begin.lookup_follow_symlink(&remain_path, VFS_MAX_FOLLOW_SYMLINK_TIMES);
227 
228     if inode.is_err() {
229         let errno = inode.clone().unwrap_err();
230         // 文件不存在，且需要创建
231         if errno == SystemError::ENOENT {
232             return Err(SystemError::ENOENT);
233         }
234     }
235     // 禁止在目录上unlink
236     if inode.unwrap().metadata()?.file_type == FileType::Dir {
237         return Err(SystemError::EPERM);
238     }
239 
240     let (filename, parent_path) = rsplit_path(&remain_path);
241     // 查找父目录
242     let parent_inode: Arc<dyn IndexNode> = inode_begin
243         .lookup_follow_symlink(parent_path.unwrap_or("/"), VFS_MAX_FOLLOW_SYMLINK_TIMES)?;
244 
245     if parent_inode.metadata()?.file_type != FileType::Dir {
246         return Err(SystemError::ENOTDIR);
247     }
248 
249     // 删除文件
250     parent_inode.unlink(filename)?;
251 
252     return Ok(0);
253 }
254 
255 pub fn do_symlinkat(from: *const u8, newdfd: i32, to: *const u8) -> Result<usize, SystemError> {
256     let oldname = check_and_clone_cstr(from, Some(MAX_PATHLEN))?
257         .into_string()
258         .map_err(|_| SystemError::EINVAL)?;
259     let newname = check_and_clone_cstr(to, Some(MAX_PATHLEN))?
260         .into_string()
261         .map_err(|_| SystemError::EINVAL)?;
262     let from = oldname.as_str().trim();
263     let to = newname.as_str().trim();
264 
265     // TODO: 添加权限检查，确保进程拥有目标路径的权限
266 
267     let pcb = ProcessManager::current_pcb();
268     let (old_begin_inode, old_remain_path) = user_path_at(&pcb, AtFlags::AT_FDCWD.bits(), from)?;
269     // info!("old_begin_inode={:?}", old_begin_inode.metadata());
270     let _ =
271         old_begin_inode.lookup_follow_symlink(&old_remain_path, VFS_MAX_FOLLOW_SYMLINK_TIMES)?;
272 
273     // 得到新创建节点的父节点
274     let (new_begin_inode, new_remain_path) = user_path_at(&pcb, newdfd, to)?;
275     let (new_name, new_parent_path) = rsplit_path(&new_remain_path);
276     let new_parent = new_begin_inode
277         .lookup_follow_symlink(new_parent_path.unwrap_or("/"), VFS_MAX_FOLLOW_SYMLINK_TIMES)?;
278     // info!("new_parent={:?}", new_parent.metadata());
279 
280     if new_parent.metadata()?.file_type != FileType::Dir {
281         return Err(SystemError::ENOTDIR);
282     }
283 
284     let new_inode = new_parent.create_with_data(
285         new_name,
286         FileType::SymLink,
287         ModeType::from_bits_truncate(0o777),
288         0,
289     )?;
290 
291     let buf = old_remain_path.as_bytes();
292     let len = buf.len();
293     new_inode.write_at(0, len, buf, SpinLock::new(FilePrivateData::Unused).lock())?;
294     return Ok(0);
295 }
296 
297 /// # do_mount - 挂载文件系统
298 ///
299 /// 将给定的文件系统挂载到指定的挂载点。
300 ///
301 /// 此函数会检查是否已经挂载了相同的文件系统，如果已经挂载，则返回错误。
302 /// 它还会处理符号链接，并确保挂载点是有效的。
303 ///
304 /// ## 参数
305 ///
306 /// - `fs`: Arc<dyn FileSystem>，要挂载的文件系统。
307 /// - `mount_point`: &str，挂载点路径。
308 ///
309 /// ## 返回值
310 ///
311 /// - `Ok(Arc<MountFS>)`: 挂载成功后返回挂载的文件系统。
312 /// - `Err(SystemError)`: 挂载失败时返回错误。
313 pub fn do_mount(fs: Arc<dyn FileSystem>, mount_point: &str) -> Result<Arc<MountFS>, SystemError> {
314     let (current_node, rest_path) = user_path_at(
315         &ProcessManager::current_pcb(),
316         AtFlags::AT_FDCWD.bits(),
317         mount_point,
318     )?;
319     let inode = current_node.lookup_follow_symlink(&rest_path, VFS_MAX_FOLLOW_SYMLINK_TIMES)?;
320     if let Some((_, rest, _fs)) = MOUNT_LIST().get_mount_point(mount_point) {
321         if rest.is_empty() {
322             return Err(SystemError::EBUSY);
323         }
324     }
325     // 移至IndexNode.mount()来记录
326     return inode.mount(fs);
327 }
328 
329 /// # do_mount_mkdir - 在指定挂载点创建目录并挂载文件系统
330 ///
331 /// 在指定的挂载点创建一个目录，并将其挂载到文件系统中。如果挂载点已经存在，并且不是空的，
332 /// 则会返回错误。成功时，会返回一个新的挂载文件系统的引用。
333 ///
334 /// ## 参数
335 ///
336 /// - `fs`: FileSystem - 文件系统的引用，用于创建和挂载目录。
337 /// - `mount_point`: &str - 挂载点路径，用于创建和挂载目录。
338 ///
339 /// ## 返回值
340 ///
341 /// - `Ok(Arc<MountFS>)`: 成功挂载文件系统后，返回挂载文件系统的共享引用。
342 /// - `Err(SystemError)`: 挂载失败时，返回系统错误。
343 pub fn do_mount_mkdir(
344     fs: Arc<dyn FileSystem>,
345     mount_point: &str,
346 ) -> Result<Arc<MountFS>, SystemError> {
347     let inode = do_mkdir_at(
348         AtFlags::AT_FDCWD.bits(),
349         mount_point,
350         FileMode::from_bits_truncate(0o755),
351     )?;
352     if let Some((_, rest, _fs)) = MOUNT_LIST().get_mount_point(mount_point) {
353         if rest.is_empty() {
354             return Err(SystemError::EBUSY);
355         }
356     }
357     return inode.mount(fs);
358 }
359 
360 /// # do_umount2 - 执行卸载文件系统的函数
361 ///
362 /// 这个函数用于卸载指定的文件系统。
363 ///
364 /// ## 参数
365 ///
366 /// - dirfd: i32 - 目录文件描述符，用于指定要卸载的文件系统的根目录。
367 /// - target: &str - 要卸载的文件系统的目标路径。
368 /// - _flag: UmountFlag - 卸载标志，目前未使用。
369 ///
370 /// ## 返回值
371 ///
372 /// - Ok(Arc<MountFS>): 成功时返回文件系统的 Arc 引用。
373 /// - Err(SystemError): 出错时返回系统错误。
374 ///
375 /// ## 错误处理
376 ///
377 /// 如果指定的路径没有对应的文件系统，或者在尝试卸载时发生错误，将返回错误。
378 pub fn do_umount2(
379     dirfd: i32,
380     target: &str,
381     _flag: UmountFlag,
382 ) -> Result<Arc<MountFS>, SystemError> {
383     let (work, rest) = user_path_at(&ProcessManager::current_pcb(), dirfd, target)?;
384     let path = work.absolute_path()? + &rest;
385     let do_umount = || -> Result<Arc<MountFS>, SystemError> {
386         if let Some(fs) = MOUNT_LIST().remove(path) {
387             // Todo: 占用检测
388             fs.umount()?;
389             return Ok(fs);
390         }
391         return Err(SystemError::EINVAL);
392     };
393     return do_umount();
394 }
395