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]: 对应'..'目录项
generate_inode_id() -> InodeId42 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)]
ROOT_INODE() -> Arc<dyn IndexNode>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)]
vfs_init() -> Result<(), SystemError>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.
migrate_virtual_filesystem(new_fs: Arc<dyn FileSystem>) -> Result<(), SystemError>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
try_find_gendisk_as_rootfs(path: &str) -> Option<Arc<GenDisk>>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
mount_root_fs() -> Result<(), SystemError>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 创建文件/文件夹
do_mkdir_at( dirfd: i32, path: &str, mode: FileMode, ) -> Result<Arc<dyn IndexNode>, SystemError>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 删除文件夹
do_remove_dir(dirfd: i32, path: &str) -> Result<u64, SystemError>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 删除文件
do_unlink_at(dirfd: i32, path: &str) -> Result<u64, SystemError>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
do_symlinkat(from: *const u8, newdfd: i32, to: *const u8) -> Result<usize, SystemError>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)`: 挂载失败时返回错误。
do_mount(fs: Arc<dyn FileSystem>, mount_point: &str) -> Result<Arc<MountFS>, 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)`: 挂载失败时,返回系统错误。
do_mount_mkdir( fs: Arc<dyn FileSystem>, mount_point: &str, ) -> Result<Arc<MountFS>, 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 /// 如果指定的路径没有对应的文件系统,或者在尝试卸载时发生错误,将返回错误。
do_umount2( dirfd: i32, target: &str, _flag: UmountFlag, ) -> Result<Arc<MountFS>, SystemError>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