1 use core::ffi::c_void; 2 use core::mem::size_of; 3 4 use alloc::string::ToString; 5 use alloc::{string::String, sync::Arc, vec::Vec}; 6 use system_error::SystemError; 7 8 use crate::producefs; 9 use crate::{ 10 driver::base::{block::SeekFrom, device::device_number::DeviceNumber}, 11 filesystem::vfs::{core as Vcore, file::FileDescriptorVec}, 12 kerror, 13 libs::rwlock::RwLockWriteGuard, 14 mm::{verify_area, VirtAddr}, 15 process::ProcessManager, 16 syscall::{ 17 user_access::{self, check_and_clone_cstr, UserBufferWriter}, 18 Syscall, 19 }, 20 time::TimeSpec, 21 }; 22 23 use super::SuperBlock; 24 use super::{ 25 core::{do_mkdir, do_remove_dir, do_unlink_at}, 26 fcntl::{AtFlags, FcntlCommand, FD_CLOEXEC}, 27 file::{File, FileMode}, 28 open::{do_faccessat, do_fchmodat, do_sys_open}, 29 utils::{rsplit_path, user_path_at}, 30 Dirent, FileType, IndexNode, FSMAKER, MAX_PATHLEN, ROOT_INODE, VFS_MAX_FOLLOW_SYMLINK_TIMES, 31 }; 32 // use crate::kdebug; 33 34 pub const SEEK_SET: u32 = 0; 35 pub const SEEK_CUR: u32 = 1; 36 pub const SEEK_END: u32 = 2; 37 pub const SEEK_MAX: u32 = 3; 38 39 bitflags! { 40 /// 文件类型和权限 41 #[repr(C)] 42 pub struct ModeType: u32 { 43 /// 掩码 44 const S_IFMT = 0o0_170_000; 45 /// 文件类型 46 const S_IFSOCK = 0o140000; 47 const S_IFLNK = 0o120000; 48 const S_IFREG = 0o100000; 49 const S_IFBLK = 0o060000; 50 const S_IFDIR = 0o040000; 51 const S_IFCHR = 0o020000; 52 const S_IFIFO = 0o010000; 53 54 const S_ISUID = 0o004000; 55 const S_ISGID = 0o002000; 56 const S_ISVTX = 0o001000; 57 /// 文件用户权限 58 const S_IRWXU = 0o0700; 59 const S_IRUSR = 0o0400; 60 const S_IWUSR = 0o0200; 61 const S_IXUSR = 0o0100; 62 /// 文件组权限 63 const S_IRWXG = 0o0070; 64 const S_IRGRP = 0o0040; 65 const S_IWGRP = 0o0020; 66 const S_IXGRP = 0o0010; 67 /// 文件其他用户权限 68 const S_IRWXO = 0o0007; 69 const S_IROTH = 0o0004; 70 const S_IWOTH = 0o0002; 71 const S_IXOTH = 0o0001; 72 73 /// 0o777 74 const S_IRWXUGO = Self::S_IRWXU.bits | Self::S_IRWXG.bits | Self::S_IRWXO.bits; 75 /// 0o7777 76 const S_IALLUGO = Self::S_ISUID.bits | Self::S_ISGID.bits | Self::S_ISVTX.bits| Self::S_IRWXUGO.bits; 77 /// 0o444 78 const S_IRUGO = Self::S_IRUSR.bits | Self::S_IRGRP.bits | Self::S_IROTH.bits; 79 /// 0o222 80 const S_IWUGO = Self::S_IWUSR.bits | Self::S_IWGRP.bits | Self::S_IWOTH.bits; 81 /// 0o111 82 const S_IXUGO = Self::S_IXUSR.bits | Self::S_IXGRP.bits | Self::S_IXOTH.bits; 83 84 85 } 86 } 87 88 #[repr(C)] 89 #[derive(Clone, Copy)] 90 /// # 文件信息结构体 91 pub struct PosixKstat { 92 /// 硬件设备ID 93 dev_id: u64, 94 /// inode号 95 inode: u64, 96 /// 硬链接数 97 nlink: u64, 98 /// 文件权限 99 mode: ModeType, 100 /// 所有者用户ID 101 uid: i32, 102 /// 所有者组ID 103 gid: i32, 104 /// 设备ID 105 rdev: i64, 106 /// 文件大小 107 size: i64, 108 /// 文件系统块大小 109 blcok_size: i64, 110 /// 分配的512B块数 111 blocks: u64, 112 /// 最后访问时间 113 atime: TimeSpec, 114 /// 最后修改时间 115 mtime: TimeSpec, 116 /// 最后状态变化时间 117 ctime: TimeSpec, 118 /// 用于填充结构体大小的空白数据 119 pub _pad: [i8; 24], 120 } 121 impl PosixKstat { 122 fn new() -> Self { 123 Self { 124 inode: 0, 125 dev_id: 0, 126 mode: ModeType { bits: 0 }, 127 nlink: 0, 128 uid: 0, 129 gid: 0, 130 rdev: 0, 131 size: 0, 132 atime: TimeSpec { 133 tv_sec: 0, 134 tv_nsec: 0, 135 }, 136 mtime: TimeSpec { 137 tv_sec: 0, 138 tv_nsec: 0, 139 }, 140 ctime: TimeSpec { 141 tv_sec: 0, 142 tv_nsec: 0, 143 }, 144 blcok_size: 0, 145 blocks: 0, 146 _pad: Default::default(), 147 } 148 } 149 } 150 151 #[repr(C)] 152 #[derive(Clone, Copy)] 153 /// # 文件信息结构体X 154 pub struct PosixStatx { 155 /* 0x00 */ 156 stx_mask: PosixStatxMask, 157 /// 文件系统块大小 158 stx_blksize: u32, 159 /// Flags conveying information about the file [uncond] 160 stx_attributes: StxAttributes, 161 /* 0x10 */ 162 /// 硬链接数 163 stx_nlink: u32, 164 /// 所有者用户ID 165 stx_uid: u32, 166 /// 所有者组ID 167 stx_gid: u32, 168 /// 文件权限 169 stx_mode: ModeType, 170 171 /* 0x20 */ 172 /// inode号 173 stx_inode: u64, 174 /// 文件大小 175 stx_size: i64, 176 /// 分配的512B块数 177 stx_blocks: u64, 178 /// Mask to show what's supported in stx_attributes 179 stx_attributes_mask: StxAttributes, 180 181 /* 0x40 */ 182 /// 最后访问时间 183 stx_atime: TimeSpec, 184 /// 文件创建时间 185 stx_btime: TimeSpec, 186 /// 最后状态变化时间 187 stx_ctime: TimeSpec, 188 /// 最后修改时间 189 stx_mtime: TimeSpec, 190 191 /* 0x80 */ 192 /// 主设备ID 193 stx_rdev_major: u32, 194 /// 次设备ID 195 stx_rdev_minor: u32, 196 /// 主硬件设备ID 197 stx_dev_major: u32, 198 /// 次硬件设备ID 199 stx_dev_minor: u32, 200 201 /* 0x90 */ 202 stx_mnt_id: u64, 203 stx_dio_mem_align: u32, 204 stx_dio_offset_align: u32, 205 } 206 impl PosixStatx { 207 fn new() -> Self { 208 Self { 209 stx_mask: PosixStatxMask::STATX_BASIC_STATS, 210 stx_blksize: 0, 211 stx_attributes: StxAttributes::STATX_ATTR_APPEND, 212 stx_nlink: 0, 213 stx_uid: 0, 214 stx_gid: 0, 215 stx_mode: ModeType { bits: 0 }, 216 stx_inode: 0, 217 stx_size: 0, 218 stx_blocks: 0, 219 stx_attributes_mask: StxAttributes::STATX_ATTR_APPEND, 220 stx_atime: TimeSpec { 221 tv_sec: 0, 222 tv_nsec: 0, 223 }, 224 stx_btime: TimeSpec { 225 tv_sec: 0, 226 tv_nsec: 0, 227 }, 228 stx_ctime: TimeSpec { 229 tv_sec: 0, 230 tv_nsec: 0, 231 }, 232 stx_mtime: TimeSpec { 233 tv_sec: 0, 234 tv_nsec: 0, 235 }, 236 stx_rdev_major: 0, 237 stx_rdev_minor: 0, 238 stx_dev_major: 0, 239 stx_dev_minor: 0, 240 stx_mnt_id: 0, 241 stx_dio_mem_align: 0, 242 stx_dio_offset_align: 0, 243 } 244 } 245 } 246 247 bitflags! { 248 pub struct PosixStatxMask: u32{ 249 /// Want stx_mode & S_IFMT 250 const STATX_TYPE = 0x00000001; 251 252 /// Want stx_mode & ~S_IFMT 253 const STATX_MODE = 0x00000002; 254 255 /// Want stx_nlink 256 const STATX_NLINK = 0x00000004; 257 258 /// Want stx_uid 259 const STATX_UID = 0x00000008; 260 261 /// Want stx_gid 262 const STATX_GID = 0x00000010; 263 264 /// Want stx_atime 265 const STATX_ATIME = 0x00000020; 266 267 /// Want stx_mtime 268 const STATX_MTIME = 0x00000040; 269 270 /// Want stx_ctime 271 const STATX_CTIME = 0x00000080; 272 273 /// Want stx_ino 274 const STATX_INO = 0x00000100; 275 276 /// Want stx_size 277 const STATX_SIZE = 0x00000200; 278 279 /// Want stx_blocks 280 const STATX_BLOCKS = 0x00000400; 281 282 /// [All of the above] 283 const STATX_BASIC_STATS = 0x000007ff; 284 285 /// Want stx_btime 286 const STATX_BTIME = 0x00000800; 287 288 /// The same as STATX_BASIC_STATS | STATX_BTIME. 289 /// It is deprecated and should not be used. 290 const STATX_ALL = 0x00000fff; 291 292 /// Want stx_mnt_id (since Linux 5.8) 293 const STATX_MNT_ID = 0x00001000; 294 295 /// Want stx_dio_mem_align and stx_dio_offset_align 296 /// (since Linux 6.1; support varies by filesystem) 297 const STATX_DIOALIGN = 0x00002000; 298 299 /// Reserved for future struct statx expansion 300 const STATX_RESERVED = 0x80000000; 301 } 302 } 303 304 bitflags! { 305 pub struct StxAttributes: u64 { 306 /// 文件被文件系统压缩 307 const STATX_ATTR_COMPRESSED = 0x00000004; 308 /// 文件被标记为不可修改 309 const STATX_ATTR_IMMUTABLE = 0x00000010; 310 /// 文件是只追加写入的 311 const STATX_ATTR_APPEND = 0x00000020; 312 /// 文件不会被备份 313 const STATX_ATTR_NODUMP = 0x00000040; 314 /// 文件需要密钥才能在文件系统中解密 315 const STATX_ATTR_ENCRYPTED = 0x00000800; 316 /// 目录是自动挂载触发器 317 const STATX_ATTR_AUTOMOUNT = 0x00001000; 318 /// 目录是挂载点的根目录 319 const STATX_ATTR_MOUNT_ROOT = 0x00002000; 320 /// 文件受到 Verity 保护 321 const STATX_ATTR_VERITY = 0x00100000; 322 /// 文件当前处于 DAX 状态 CPU直接访问 323 const STATX_ATTR_DAX = 0x00200000; 324 } 325 } 326 327 #[repr(C)] 328 #[derive(Debug, Clone, Copy)] 329 pub struct PosixStatfs { 330 f_type: u64, 331 f_bsize: u64, 332 f_blocks: u64, 333 f_bfree: u64, 334 f_bavail: u64, 335 f_files: u64, 336 f_ffree: u64, 337 f_fsid: u64, 338 f_namelen: u64, 339 f_frsize: u64, 340 f_flags: u64, 341 f_spare: [u64; 4], 342 } 343 344 impl From<SuperBlock> for PosixStatfs { 345 fn from(super_block: SuperBlock) -> Self { 346 Self { 347 f_type: super_block.magic.bits, 348 f_bsize: super_block.bsize, 349 f_blocks: super_block.blocks, 350 f_bfree: super_block.bfree, 351 f_bavail: super_block.bavail, 352 f_files: super_block.files, 353 f_ffree: super_block.ffree, 354 f_fsid: super_block.fsid, 355 f_namelen: super_block.namelen, 356 f_frsize: super_block.frsize, 357 f_flags: super_block.flags, 358 f_spare: [0u64; 4], 359 } 360 } 361 } 362 /// 363 /// Arguments for how openat2(2) should open the target path. If only @flags and 364 /// @mode are non-zero, then openat2(2) operates very similarly to openat(2). 365 /// 366 /// However, unlike openat(2), unknown or invalid bits in @flags result in 367 /// -EINVAL rather than being silently ignored. @mode must be zero unless one of 368 /// {O_CREAT, O_TMPFILE} are set. 369 /// 370 /// ## 成员变量 371 /// 372 /// - flags: O_* flags. 373 /// - mode: O_CREAT/O_TMPFILE file mode. 374 /// - resolve: RESOLVE_* flags. 375 #[derive(Debug, Clone, Copy)] 376 #[repr(C)] 377 pub struct PosixOpenHow { 378 pub flags: u64, 379 pub mode: u64, 380 pub resolve: u64, 381 } 382 383 impl PosixOpenHow { 384 #[allow(dead_code)] 385 pub fn new(flags: u64, mode: u64, resolve: u64) -> Self { 386 Self { 387 flags, 388 mode, 389 resolve, 390 } 391 } 392 } 393 394 #[derive(Debug, Clone, Copy)] 395 pub struct OpenHow { 396 pub o_flags: FileMode, 397 pub mode: ModeType, 398 pub resolve: OpenHowResolve, 399 } 400 401 impl OpenHow { 402 pub fn new(mut o_flags: FileMode, mut mode: ModeType, resolve: OpenHowResolve) -> Self { 403 if !o_flags.contains(FileMode::O_CREAT) { 404 mode = ModeType::empty(); 405 } 406 407 if o_flags.contains(FileMode::O_PATH) { 408 o_flags = o_flags.intersection(FileMode::O_PATH_FLAGS); 409 } 410 411 Self { 412 o_flags, 413 mode, 414 resolve, 415 } 416 } 417 } 418 419 impl From<PosixOpenHow> for OpenHow { 420 fn from(posix_open_how: PosixOpenHow) -> Self { 421 let o_flags = FileMode::from_bits_truncate(posix_open_how.flags as u32); 422 let mode = ModeType::from_bits_truncate(posix_open_how.mode as u32); 423 let resolve = OpenHowResolve::from_bits_truncate(posix_open_how.resolve); 424 return Self::new(o_flags, mode, resolve); 425 } 426 } 427 428 bitflags! { 429 pub struct OpenHowResolve: u64{ 430 /// Block mount-point crossings 431 /// (including bind-mounts). 432 const RESOLVE_NO_XDEV = 0x01; 433 434 /// Block traversal through procfs-style 435 /// "magic-links" 436 const RESOLVE_NO_MAGICLINKS = 0x02; 437 438 /// Block traversal through all symlinks 439 /// (implies OEXT_NO_MAGICLINKS) 440 const RESOLVE_NO_SYMLINKS = 0x04; 441 /// Block "lexical" trickery like 442 /// "..", symlinks, and absolute 443 const RESOLVE_BENEATH = 0x08; 444 /// Make all jumps to "/" and ".." 445 /// be scoped inside the dirfd 446 /// (similar to chroot(2)). 447 const RESOLVE_IN_ROOT = 0x10; 448 // Only complete if resolution can be 449 // completed through cached lookup. May 450 // return -EAGAIN if that's not 451 // possible. 452 const RESOLVE_CACHED = 0x20; 453 } 454 } 455 impl Syscall { 456 /// @brief 为当前进程打开一个文件 457 /// 458 /// @param path 文件路径 459 /// @param o_flags 打开文件的标志位 460 /// 461 /// @return 文件描述符编号，或者是错误码 462 pub fn open( 463 path: *const u8, 464 o_flags: u32, 465 mode: u32, 466 follow_symlink: bool, 467 ) -> Result<usize, SystemError> { 468 let path = check_and_clone_cstr(path, Some(MAX_PATHLEN))?; 469 let open_flags: FileMode = FileMode::from_bits(o_flags).ok_or(SystemError::EINVAL)?; 470 let mode = ModeType::from_bits(mode).ok_or(SystemError::EINVAL)?; 471 return do_sys_open( 472 AtFlags::AT_FDCWD.bits(), 473 &path, 474 open_flags, 475 mode, 476 follow_symlink, 477 ); 478 } 479 480 pub fn openat( 481 dirfd: i32, 482 path: *const u8, 483 o_flags: u32, 484 mode: u32, 485 follow_symlink: bool, 486 ) -> Result<usize, SystemError> { 487 let path = check_and_clone_cstr(path, Some(MAX_PATHLEN))?; 488 let open_flags: FileMode = FileMode::from_bits(o_flags).ok_or(SystemError::EINVAL)?; 489 let mode = ModeType::from_bits(mode).ok_or(SystemError::EINVAL)?; 490 return do_sys_open(dirfd, &path, open_flags, mode, follow_symlink); 491 } 492 493 /// @brief 关闭文件 494 /// 495 /// @param fd 文件描述符编号 496 /// 497 /// @return 成功返回0，失败返回错误码 498 pub fn close(fd: usize) -> Result<usize, SystemError> { 499 let binding = ProcessManager::current_pcb().fd_table(); 500 let mut fd_table_guard = binding.write(); 501 502 fd_table_guard.drop_fd(fd as i32).map(|_| 0) 503 } 504 505 /// @brief 发送命令到文件描述符对应的设备， 506 /// 507 /// @param fd 文件描述符编号 508 /// @param cmd 设备相关的请求类型 509 /// 510 /// @return Ok(usize) 成功返回0 511 /// @return Err(SystemError) 读取失败，返回posix错误码 512 pub fn ioctl(fd: usize, cmd: u32, data: usize) -> Result<usize, SystemError> { 513 let binding = ProcessManager::current_pcb().fd_table(); 514 let fd_table_guard = binding.read(); 515 516 let file = fd_table_guard 517 .get_file_by_fd(fd as i32) 518 .ok_or(SystemError::EBADF)?; 519 520 // drop guard 以避免无法调度的问题 521 drop(fd_table_guard); 522 let file = file.lock_no_preempt(); 523 let r = file.inode().ioctl(cmd, data, &file.private_data); 524 return r; 525 } 526 527 /// @brief 根据文件描述符，读取文件数据。尝试读取的数据长度与buf的长度相同。 528 /// 529 /// @param fd 文件描述符编号 530 /// @param buf 输出缓冲区 531 /// 532 /// @return Ok(usize) 成功读取的数据的字节数 533 /// @return Err(SystemError) 读取失败，返回posix错误码 534 pub fn read(fd: i32, buf: &mut [u8]) -> Result<usize, SystemError> { 535 let binding = ProcessManager::current_pcb().fd_table(); 536 let fd_table_guard = binding.read(); 537 538 let file = fd_table_guard.get_file_by_fd(fd); 539 if file.is_none() { 540 return Err(SystemError::EBADF); 541 } 542 // drop guard 以避免无法调度的问题 543 drop(fd_table_guard); 544 let file = file.unwrap(); 545 546 return file.lock_no_preempt().read(buf.len(), buf); 547 } 548 549 /// @brief 根据文件描述符，向文件写入数据。尝试写入的数据长度与buf的长度相同。 550 /// 551 /// @param fd 文件描述符编号 552 /// @param buf 输入缓冲区 553 /// 554 /// @return Ok(usize) 成功写入的数据的字节数 555 /// @return Err(SystemError) 写入失败，返回posix错误码 556 pub fn write(fd: i32, buf: &[u8]) -> Result<usize, SystemError> { 557 let binding = ProcessManager::current_pcb().fd_table(); 558 let fd_table_guard = binding.read(); 559 560 let file = fd_table_guard 561 .get_file_by_fd(fd) 562 .ok_or(SystemError::EBADF)?; 563 564 // drop guard 以避免无法调度的问题 565 drop(fd_table_guard); 566 return file.lock_no_preempt().write(buf.len(), buf); 567 } 568 569 /// @brief 调整文件操作指针的位置 570 /// 571 /// @param fd 文件描述符编号 572 /// @param seek 调整的方式 573 /// 574 /// @return Ok(usize) 调整后，文件访问指针相对于文件头部的偏移量 575 /// @return Err(SystemError) 调整失败，返回posix错误码 576 pub fn lseek(fd: i32, offset: i64, seek: u32) -> Result<usize, SystemError> { 577 let seek = match seek { 578 SEEK_SET => Ok(SeekFrom::SeekSet(offset)), 579 SEEK_CUR => Ok(SeekFrom::SeekCurrent(offset)), 580 SEEK_END => Ok(SeekFrom::SeekEnd(offset)), 581 SEEK_MAX => Ok(SeekFrom::SeekEnd(0)), 582 _ => Err(SystemError::EINVAL), 583 }?; 584 585 let binding = ProcessManager::current_pcb().fd_table(); 586 let fd_table_guard = binding.read(); 587 let file = fd_table_guard 588 .get_file_by_fd(fd) 589 .ok_or(SystemError::EBADF)?; 590 591 // drop guard 以避免无法调度的问题 592 drop(fd_table_guard); 593 return file.lock_no_preempt().lseek(seek); 594 } 595 596 /// # sys_pread64 系统调用的实际执行函数 597 /// 598 /// ## 参数 599 /// - `fd`: 文件描述符 600 /// - `buf`: 读出缓冲区 601 /// - `len`: 要读取的字节数 602 /// - `offset`: 文件偏移量 603 pub fn pread(fd: i32, buf: &mut [u8], len: usize, offset: usize) -> Result<usize, SystemError> { 604 let binding = ProcessManager::current_pcb().fd_table(); 605 let fd_table_guard = binding.read(); 606 607 let file = fd_table_guard.get_file_by_fd(fd); 608 if file.is_none() { 609 return Err(SystemError::EBADF); 610 } 611 // drop guard 以避免无法调度的问题 612 drop(fd_table_guard); 613 let file = file.unwrap(); 614 615 return file.lock_no_preempt().pread(offset, len, buf); 616 } 617 618 /// # sys_pwrite64 系统调用的实际执行函数 619 /// 620 /// ## 参数 621 /// - `fd`: 文件描述符 622 /// - `buf`: 写入缓冲区 623 /// - `len`: 要写入的字节数 624 /// - `offset`: 文件偏移量 625 pub fn pwrite(fd: i32, buf: &[u8], len: usize, offset: usize) -> Result<usize, SystemError> { 626 let binding = ProcessManager::current_pcb().fd_table(); 627 let fd_table_guard = binding.read(); 628 629 let file = fd_table_guard.get_file_by_fd(fd); 630 if file.is_none() { 631 return Err(SystemError::EBADF); 632 } 633 // drop guard 以避免无法调度的问题 634 drop(fd_table_guard); 635 let file = file.unwrap(); 636 637 return file.lock_no_preempt().pwrite(offset, len, buf); 638 } 639 640 /// @brief 切换工作目录 641 /// 642 /// @param dest_path 目标路径 643 /// 644 /// @return 返回码 描述 645 /// 0 | 成功 646 /// 647 /// EACCESS | 权限不足 648 /// 649 /// ELOOP | 解析path时遇到路径循环 650 /// 651 /// ENAMETOOLONG | 路径名过长 652 /// 653 /// ENOENT | 目标文件或目录不存在 654 /// 655 /// ENODIR | 检索期间发现非目录项 656 /// 657 /// ENOMEM | 系统内存不足 658 /// 659 /// EFAULT | 错误的地址 660 /// 661 /// ENAMETOOLONG | 路径过长 662 pub fn chdir(path: *const u8) -> Result<usize, SystemError> { 663 if path.is_null() { 664 return Err(SystemError::EFAULT); 665 } 666 667 let path = check_and_clone_cstr(path, Some(MAX_PATHLEN))?; 668 let proc = ProcessManager::current_pcb(); 669 // Copy path to kernel space to avoid some security issues 670 let mut new_path = String::from(""); 671 if !path.is_empty() { 672 let cwd = match path.as_bytes()[0] { 673 b'/' => String::from("/"), 674 _ => proc.basic().cwd(), 675 }; 676 let mut cwd_vec: Vec<_> = cwd.split('/').filter(|&x| !x.is_empty()).collect(); 677 let path_split = path.split('/').filter(|&x| !x.is_empty()); 678 for seg in path_split { 679 if seg == ".." { 680 cwd_vec.pop(); 681 } else if seg == "." { 682 // 当前目录 683 } else { 684 cwd_vec.push(seg); 685 } 686 } 687 //proc.basic().set_path(String::from("")); 688 for seg in cwd_vec { 689 new_path.push('/'); 690 new_path.push_str(seg); 691 } 692 if new_path.is_empty() { 693 new_path = String::from("/"); 694 } 695 } 696 let inode = 697 match ROOT_INODE().lookup_follow_symlink(&new_path, VFS_MAX_FOLLOW_SYMLINK_TIMES) { 698 Err(_) => { 699 return Err(SystemError::ENOENT); 700 } 701 Ok(i) => i, 702 }; 703 let metadata = inode.metadata()?; 704 if metadata.file_type == FileType::Dir { 705 proc.basic_mut().set_cwd(new_path); 706 return Ok(0); 707 } else { 708 return Err(SystemError::ENOTDIR); 709 } 710 } 711 712 /// @brief 获取当前进程的工作目录路径 713 /// 714 /// @param buf 指向缓冲区的指针 715 /// @param size 缓冲区的大小 716 /// 717 /// @return 成功，返回的指针指向包含工作目录路径的字符串 718 /// @return 错误，没有足够的空间 719 pub fn getcwd(buf: &mut [u8]) -> Result<VirtAddr, SystemError> { 720 let proc = ProcessManager::current_pcb(); 721 let cwd = proc.basic().cwd(); 722 723 let cwd_bytes = cwd.as_bytes(); 724 let cwd_len = cwd_bytes.len(); 725 if cwd_len + 1 > buf.len() { 726 return Err(SystemError::ENOMEM); 727 } 728 buf[..cwd_len].copy_from_slice(cwd_bytes); 729 buf[cwd_len] = 0; 730 731 return Ok(VirtAddr::new(buf.as_ptr() as usize)); 732 } 733 734 /// @brief 获取目录中的数据 735 /// 736 /// TODO: 这个函数的语义与Linux不一致，需要修改！！！ 737 /// 738 /// @param fd 文件描述符号 739 /// @param buf 输出缓冲区 740 /// 741 /// @return 成功返回读取的字节数，失败返回错误码 742 pub fn getdents(fd: i32, buf: &mut [u8]) -> Result<usize, SystemError> { 743 let dirent = 744 unsafe { (buf.as_mut_ptr() as *mut Dirent).as_mut() }.ok_or(SystemError::EFAULT)?; 745 746 if fd < 0 || fd as usize > FileDescriptorVec::PROCESS_MAX_FD { 747 return Err(SystemError::EBADF); 748 } 749 750 // 获取fd 751 let binding = ProcessManager::current_pcb().fd_table(); 752 let fd_table_guard = binding.read(); 753 let file = fd_table_guard 754 .get_file_by_fd(fd) 755 .ok_or(SystemError::EBADF)?; 756 757 // drop guard 以避免无法调度的问题 758 drop(fd_table_guard); 759 760 let res = file.lock_no_preempt().readdir(dirent).map(|x| x as usize); 761 762 return res; 763 } 764 765 /// @brief 创建文件夹 766 /// 767 /// @param path(r8) 路径 / mode(r9) 模式 768 /// 769 /// @return uint64_t 负数错误码 / 0表示成功 770 pub fn mkdir(path: *const u8, mode: usize) -> Result<usize, SystemError> { 771 let path = check_and_clone_cstr(path, Some(MAX_PATHLEN))?; 772 return do_mkdir(&path, FileMode::from_bits_truncate(mode as u32)).map(|x| x as usize); 773 } 774 775 /// **创建硬连接的系统调用** 776 /// 777 /// ## 参数 778 /// 779 /// - 'oldfd': 用于解析源文件路径的文件描述符 780 /// - 'old': 源文件路径 781 /// - 'newfd': 用于解析新文件路径的文件描述符 782 /// - 'new': 新文件将创建的路径 783 /// - 'flags': 标志位，仅以位或方式包含AT_EMPTY_PATH和AT_SYMLINK_FOLLOW 784 /// 785 /// 786 pub fn do_linkat( 787 oldfd: i32, 788 old: &str, 789 newfd: i32, 790 new: &str, 791 flags: AtFlags, 792 ) -> Result<usize, SystemError> { 793 // flag包含其他未规定值时返回EINVAL 794 if !(AtFlags::AT_EMPTY_PATH | AtFlags::AT_SYMLINK_FOLLOW).contains(flags) { 795 return Err(SystemError::EINVAL); 796 } 797 // TODO AT_EMPTY_PATH标志启用时，进行调用者CAP_DAC_READ_SEARCH或相似的检查 798 let symlink_times = if flags.contains(AtFlags::AT_SYMLINK_FOLLOW) { 799 0_usize 800 } else { 801 VFS_MAX_FOLLOW_SYMLINK_TIMES 802 }; 803 let pcb = ProcessManager::current_pcb(); 804 805 // 得到源路径的inode 806 let old_inode: Arc<dyn IndexNode> = if old.is_empty() { 807 if flags.contains(AtFlags::AT_EMPTY_PATH) { 808 // 在AT_EMPTY_PATH启用时，old可以为空，old_inode实际为oldfd所指文件，但该文件不能为目录。 809 let binding = pcb.fd_table(); 810 let fd_table_guard = binding.read(); 811 let file = fd_table_guard 812 .get_file_by_fd(oldfd) 813 .ok_or(SystemError::EBADF)?; 814 let old_inode = file.lock().inode(); 815 old_inode 816 } else { 817 return Err(SystemError::ENONET); 818 } 819 } else { 820 let (old_begin_inode, old_remain_path) = user_path_at(&pcb, oldfd, old)?; 821 old_begin_inode.lookup_follow_symlink(&old_remain_path, symlink_times)? 822 }; 823 824 // old_inode为目录时返回EPERM 825 if old_inode.metadata().unwrap().file_type == FileType::Dir { 826 return Err(SystemError::EPERM); 827 } 828 829 // 得到新创建节点的父节点 830 let (new_begin_inode, new_remain_path) = user_path_at(&pcb, newfd, new)?; 831 let (new_name, new_parent_path) = rsplit_path(&new_remain_path); 832 let new_parent = 833 new_begin_inode.lookup_follow_symlink(new_parent_path.unwrap_or("/"), symlink_times)?; 834 835 // 被调用者利用downcast_ref判断两inode是否为同一文件系统 836 return new_parent.link(new_name, &old_inode).map(|_| 0); 837 } 838 839 pub fn link(old: *const u8, new: *const u8) -> Result<usize, SystemError> { 840 let get_path = |cstr: *const u8| -> Result<String, SystemError> { 841 let res = check_and_clone_cstr(cstr, Some(MAX_PATHLEN))?; 842 if res.len() >= MAX_PATHLEN { 843 return Err(SystemError::ENAMETOOLONG); 844 } 845 if res.is_empty() { 846 return Err(SystemError::ENOENT); 847 } 848 Ok(res) 849 }; 850 let old = get_path(old)?; 851 let new = get_path(new)?; 852 return Self::do_linkat( 853 AtFlags::AT_FDCWD.bits(), 854 &old, 855 AtFlags::AT_FDCWD.bits(), 856 &new, 857 AtFlags::empty(), 858 ); 859 } 860 861 pub fn linkat( 862 oldfd: i32, 863 old: *const u8, 864 newfd: i32, 865 new: *const u8, 866 flags: i32, 867 ) -> Result<usize, SystemError> { 868 let old = check_and_clone_cstr(old, Some(MAX_PATHLEN))?; 869 let new = check_and_clone_cstr(new, Some(MAX_PATHLEN))?; 870 if old.len() >= MAX_PATHLEN || new.len() >= MAX_PATHLEN { 871 return Err(SystemError::ENAMETOOLONG); 872 } 873 // old 根据flags & AtFlags::AT_EMPTY_PATH判空 874 if new.is_empty() { 875 return Err(SystemError::ENOENT); 876 } 877 let flags = AtFlags::from_bits(flags).ok_or(SystemError::EINVAL)?; 878 Self::do_linkat(oldfd, &old, newfd, &new, flags) 879 } 880 881 /// **删除文件夹、取消文件的链接、删除文件的系统调用** 882 /// 883 /// ## 参数 884 /// 885 /// - `dirfd`：文件夹的文件描述符.目前暂未实现 886 /// - `pathname`：文件夹的路径 887 /// - `flags`：标志位 888 /// 889 /// 890 pub fn unlinkat(dirfd: i32, path: *const u8, flags: u32) -> Result<usize, SystemError> { 891 let flags = AtFlags::from_bits(flags as i32).ok_or(SystemError::EINVAL)?; 892 893 let path = check_and_clone_cstr(path, Some(MAX_PATHLEN))?; 894 895 if flags.contains(AtFlags::AT_REMOVEDIR) { 896 // kdebug!("rmdir"); 897 match do_remove_dir(dirfd, &path) { 898 Err(err) => { 899 return Err(err); 900 } 901 Ok(_) => { 902 return Ok(0); 903 } 904 } 905 } 906 907 match do_unlink_at(dirfd, &path) { 908 Err(err) => { 909 return Err(err); 910 } 911 Ok(_) => { 912 return Ok(0); 913 } 914 } 915 } 916 917 pub fn rmdir(path: *const u8) -> Result<usize, SystemError> { 918 let path = check_and_clone_cstr(path, Some(MAX_PATHLEN))?; 919 return do_remove_dir(AtFlags::AT_FDCWD.bits(), &path).map(|v| v as usize); 920 } 921 922 pub fn unlink(path: *const u8) -> Result<usize, SystemError> { 923 let path = check_and_clone_cstr(path, Some(MAX_PATHLEN))?; 924 return do_unlink_at(AtFlags::AT_FDCWD.bits(), &path).map(|v| v as usize); 925 } 926 927 /// # 修改文件名 928 /// 929 /// 930 /// ## 参数 931 /// 932 /// - oldfd: 源文件描述符 933 /// - filename_from: 源文件路径 934 /// - newfd: 目标文件描述符 935 /// - filename_to: 目标文件路径 936 /// - flags: 标志位 937 /// 938 /// 939 /// ## 返回值 940 /// - Ok(返回值类型): 返回值的说明 941 /// - Err(错误值类型): 错误的说明 942 /// 943 pub fn do_renameat2( 944 oldfd: i32, 945 filename_from: *const u8, 946 newfd: i32, 947 filename_to: *const u8, 948 _flags: u32, 949 ) -> Result<usize, SystemError> { 950 let filename_from = check_and_clone_cstr(filename_from, Some(MAX_PATHLEN)).unwrap(); 951 let filename_to = check_and_clone_cstr(filename_to, Some(MAX_PATHLEN)).unwrap(); 952 // 文件名过长 953 if filename_from.len() > MAX_PATHLEN || filename_to.len() > MAX_PATHLEN { 954 return Err(SystemError::ENAMETOOLONG); 955 } 956 957 //获取pcb，文件节点 958 let pcb = ProcessManager::current_pcb(); 959 let (_old_inode_begin, old_remain_path) = user_path_at(&pcb, oldfd, &filename_from)?; 960 let (_new_inode_begin, new_remain_path) = user_path_at(&pcb, newfd, &filename_to)?; 961 //获取父目录 962 let (old_filename, old_parent_path) = rsplit_path(&old_remain_path); 963 let old_parent_inode = ROOT_INODE() 964 .lookup_follow_symlink(old_parent_path.unwrap_or("/"), VFS_MAX_FOLLOW_SYMLINK_TIMES)?; 965 let (new_filename, new_parent_path) = rsplit_path(&new_remain_path); 966 let new_parent_inode = ROOT_INODE() 967 .lookup_follow_symlink(new_parent_path.unwrap_or("/"), VFS_MAX_FOLLOW_SYMLINK_TIMES)?; 968 old_parent_inode.move_to(old_filename, &new_parent_inode, new_filename)?; 969 return Ok(0); 970 } 971 972 /// @brief 根据提供的文件描述符的fd，复制对应的文件结构体，并返回新复制的文件结构体对应的fd 973 pub fn dup(oldfd: i32) -> Result<usize, SystemError> { 974 let binding = ProcessManager::current_pcb().fd_table(); 975 let mut fd_table_guard = binding.write(); 976 977 let old_file = fd_table_guard 978 .get_file_by_fd(oldfd) 979 .ok_or(SystemError::EBADF)?; 980 981 let new_file = old_file 982 .lock_no_preempt() 983 .try_clone() 984 .ok_or(SystemError::EBADF)?; 985 // 申请文件描述符，并把文件对象存入其中 986 let res = fd_table_guard.alloc_fd(new_file, None).map(|x| x as usize); 987 return res; 988 } 989 990 /// 根据提供的文件描述符的fd，和指定新fd，复制对应的文件结构体， 991 /// 并返回新复制的文件结构体对应的fd. 992 /// 如果新fd已经打开，则会先关闭新fd. 993 /// 994 /// ## 参数 995 /// 996 /// - `oldfd`：旧文件描述符 997 /// - `newfd`：新文件描述符 998 /// 999 /// ## 返回值 1000 /// 1001 /// - 成功：新文件描述符 1002 /// - 失败：错误码 1003 pub fn dup2(oldfd: i32, newfd: i32) -> Result<usize, SystemError> { 1004 let binding = ProcessManager::current_pcb().fd_table(); 1005 let mut fd_table_guard = binding.write(); 1006 return Self::do_dup2(oldfd, newfd, &mut fd_table_guard); 1007 } 1008 1009 fn do_dup2( 1010 oldfd: i32, 1011 newfd: i32, 1012 fd_table_guard: &mut RwLockWriteGuard<'_, FileDescriptorVec>, 1013 ) -> Result<usize, SystemError> { 1014 // 确认oldfd, newid是否有效 1015 if !(FileDescriptorVec::validate_fd(oldfd) && FileDescriptorVec::validate_fd(newfd)) { 1016 return Err(SystemError::EBADF); 1017 } 1018 1019 if oldfd == newfd { 1020 // 若oldfd与newfd相等 1021 return Ok(newfd as usize); 1022 } 1023 let new_exists = fd_table_guard.get_file_by_fd(newfd).is_some(); 1024 if new_exists { 1025 // close newfd 1026 if fd_table_guard.drop_fd(newfd).is_err() { 1027 // An I/O error occurred while attempting to close fildes2. 1028 return Err(SystemError::EIO); 1029 } 1030 } 1031 1032 let old_file = fd_table_guard 1033 .get_file_by_fd(oldfd) 1034 .ok_or(SystemError::EBADF)?; 1035 let new_file = old_file 1036 .lock_no_preempt() 1037 .try_clone() 1038 .ok_or(SystemError::EBADF)?; 1039 // 申请文件描述符，并把文件对象存入其中 1040 let res = fd_table_guard 1041 .alloc_fd(new_file, Some(newfd)) 1042 .map(|x| x as usize); 1043 return res; 1044 } 1045 1046 /// # fcntl 1047 /// 1048 /// ## 参数 1049 /// 1050 /// - `fd`：文件描述符 1051 /// - `cmd`：命令 1052 /// - `arg`：参数 1053 pub fn fcntl(fd: i32, cmd: FcntlCommand, arg: i32) -> Result<usize, SystemError> { 1054 match cmd { 1055 FcntlCommand::DupFd => { 1056 if arg < 0 || arg as usize >= FileDescriptorVec::PROCESS_MAX_FD { 1057 return Err(SystemError::EBADF); 1058 } 1059 let arg = arg as usize; 1060 for i in arg..FileDescriptorVec::PROCESS_MAX_FD { 1061 let binding = ProcessManager::current_pcb().fd_table(); 1062 let mut fd_table_guard = binding.write(); 1063 if fd_table_guard.get_file_by_fd(i as i32).is_none() { 1064 return Self::do_dup2(fd, i as i32, &mut fd_table_guard); 1065 } 1066 } 1067 return Err(SystemError::EMFILE); 1068 } 1069 FcntlCommand::GetFd => { 1070 // Get file descriptor flags. 1071 let binding = ProcessManager::current_pcb().fd_table(); 1072 let fd_table_guard = binding.read(); 1073 if let Some(file) = fd_table_guard.get_file_by_fd(fd) { 1074 // drop guard 以避免无法调度的问题 1075 drop(fd_table_guard); 1076 1077 if file.lock().close_on_exec() { 1078 return Ok(FD_CLOEXEC as usize); 1079 } 1080 } 1081 return Err(SystemError::EBADF); 1082 } 1083 FcntlCommand::SetFd => { 1084 // Set file descriptor flags. 1085 let binding = ProcessManager::current_pcb().fd_table(); 1086 let fd_table_guard = binding.write(); 1087 1088 if let Some(file) = fd_table_guard.get_file_by_fd(fd) { 1089 // drop guard 以避免无法调度的问题 1090 drop(fd_table_guard); 1091 let arg = arg as u32; 1092 if arg & FD_CLOEXEC != 0 { 1093 file.lock().set_close_on_exec(true); 1094 } else { 1095 file.lock().set_close_on_exec(false); 1096 } 1097 return Ok(0); 1098 } 1099 return Err(SystemError::EBADF); 1100 } 1101 1102 FcntlCommand::GetFlags => { 1103 // Get file status flags. 1104 let binding = ProcessManager::current_pcb().fd_table(); 1105 let fd_table_guard = binding.read(); 1106 1107 if let Some(file) = fd_table_guard.get_file_by_fd(fd) { 1108 // drop guard 以避免无法调度的问题 1109 drop(fd_table_guard); 1110 return Ok(file.lock_no_preempt().mode().bits() as usize); 1111 } 1112 1113 return Err(SystemError::EBADF); 1114 } 1115 FcntlCommand::SetFlags => { 1116 // Set file status flags. 1117 let binding = ProcessManager::current_pcb().fd_table(); 1118 let fd_table_guard = binding.write(); 1119 1120 if let Some(file) = fd_table_guard.get_file_by_fd(fd) { 1121 let arg = arg as u32; 1122 let mode = FileMode::from_bits(arg).ok_or(SystemError::EINVAL)?; 1123 // drop guard 以避免无法调度的问题 1124 drop(fd_table_guard); 1125 file.lock_no_preempt().set_mode(mode)?; 1126 return Ok(0); 1127 } 1128 1129 return Err(SystemError::EBADF); 1130 } 1131 _ => { 1132 // TODO: unimplemented 1133 // 未实现的命令，返回0，不报错。 1134 1135 // kwarn!("fcntl: unimplemented command: {:?}, defaults to 0.", cmd); 1136 return Ok(0); 1137 } 1138 } 1139 } 1140 1141 /// # ftruncate 1142 /// 1143 /// ## 描述 1144 /// 1145 /// 改变文件大小. 1146 /// 如果文件大小大于原来的大小，那么文件的内容将会被扩展到指定的大小，新的空间将会用0填充. 1147 /// 如果文件大小小于原来的大小，那么文件的内容将会被截断到指定的大小. 1148 /// 1149 /// ## 参数 1150 /// 1151 /// - `fd`：文件描述符 1152 /// - `len`：文件大小 1153 /// 1154 /// ## 返回值 1155 /// 1156 /// 如果成功，返回0，否则返回错误码. 1157 pub fn ftruncate(fd: i32, len: usize) -> Result<usize, SystemError> { 1158 let binding = ProcessManager::current_pcb().fd_table(); 1159 let fd_table_guard = binding.read(); 1160 1161 if let Some(file) = fd_table_guard.get_file_by_fd(fd) { 1162 // drop guard 以避免无法调度的问题 1163 drop(fd_table_guard); 1164 let r = file.lock_no_preempt().ftruncate(len).map(|_| 0); 1165 return r; 1166 } 1167 1168 return Err(SystemError::EBADF); 1169 } 1170 1171 fn do_fstat(fd: i32) -> Result<PosixKstat, SystemError> { 1172 let binding = ProcessManager::current_pcb().fd_table(); 1173 let fd_table_guard = binding.read(); 1174 let file = fd_table_guard 1175 .get_file_by_fd(fd) 1176 .ok_or(SystemError::EBADF)?; 1177 // drop guard 以避免无法调度的问题 1178 drop(fd_table_guard); 1179 1180 let mut kstat = PosixKstat::new(); 1181 // 获取文件信息 1182 let metadata = file.lock().metadata()?; 1183 kstat.size = metadata.size; 1184 kstat.dev_id = metadata.dev_id as u64; 1185 kstat.inode = metadata.inode_id.into() as u64; 1186 kstat.blcok_size = metadata.blk_size as i64; 1187 kstat.blocks = metadata.blocks as u64; 1188 1189 kstat.atime.tv_sec = metadata.atime.tv_sec; 1190 kstat.atime.tv_nsec = metadata.atime.tv_nsec; 1191 kstat.mtime.tv_sec = metadata.mtime.tv_sec; 1192 kstat.mtime.tv_nsec = metadata.mtime.tv_nsec; 1193 kstat.ctime.tv_sec = metadata.ctime.tv_sec; 1194 kstat.ctime.tv_nsec = metadata.ctime.tv_nsec; 1195 1196 kstat.nlink = metadata.nlinks as u64; 1197 kstat.uid = metadata.uid as i32; 1198 kstat.gid = metadata.gid as i32; 1199 kstat.rdev = metadata.raw_dev.data() as i64; 1200 kstat.mode = metadata.mode; 1201 match file.lock().file_type() { 1202 FileType::File => kstat.mode.insert(ModeType::S_IFREG), 1203 FileType::Dir => kstat.mode.insert(ModeType::S_IFDIR), 1204 FileType::BlockDevice => kstat.mode.insert(ModeType::S_IFBLK), 1205 FileType::CharDevice => kstat.mode.insert(ModeType::S_IFCHR), 1206 FileType::SymLink => kstat.mode.insert(ModeType::S_IFLNK), 1207 FileType::Socket => kstat.mode.insert(ModeType::S_IFSOCK), 1208 FileType::Pipe => kstat.mode.insert(ModeType::S_IFIFO), 1209 FileType::KvmDevice => kstat.mode.insert(ModeType::S_IFCHR), 1210 FileType::FramebufferDevice => kstat.mode.insert(ModeType::S_IFCHR), 1211 } 1212 1213 return Ok(kstat); 1214 } 1215 1216 pub fn fstat(fd: i32, usr_kstat: *mut PosixKstat) -> Result<usize, SystemError> { 1217 let mut writer = UserBufferWriter::new(usr_kstat, size_of::<PosixKstat>(), true)?; 1218 let kstat = Self::do_fstat(fd)?; 1219 1220 writer.copy_one_to_user(&kstat, 0)?; 1221 return Ok(0); 1222 } 1223 1224 pub fn stat(path: *const u8, user_kstat: *mut PosixKstat) -> Result<usize, SystemError> { 1225 let fd = Self::open( 1226 path, 1227 FileMode::O_RDONLY.bits(), 1228 ModeType::empty().bits(), 1229 true, 1230 )?; 1231 let r = Self::fstat(fd as i32, user_kstat); 1232 Self::close(fd).ok(); 1233 return r; 1234 } 1235 1236 pub fn lstat(path: *const u8, user_kstat: *mut PosixKstat) -> Result<usize, SystemError> { 1237 let fd = Self::open( 1238 path, 1239 FileMode::O_RDONLY.bits(), 1240 ModeType::empty().bits(), 1241 false, 1242 )?; 1243 let r = Self::fstat(fd as i32, user_kstat); 1244 Self::close(fd).ok(); 1245 return r; 1246 } 1247 1248 pub fn statfs(path: *const u8, user_statfs: *mut PosixStatfs) -> Result<usize, SystemError> { 1249 let mut writer = UserBufferWriter::new(user_statfs, size_of::<PosixStatfs>(), true)?; 1250 let fd = Self::open( 1251 path, 1252 FileMode::O_RDONLY.bits(), 1253 ModeType::empty().bits(), 1254 true, 1255 )?; 1256 let path = check_and_clone_cstr(path, Some(MAX_PATHLEN)).unwrap(); 1257 let pcb = ProcessManager::current_pcb(); 1258 let (_inode_begin, remain_path) = user_path_at(&pcb, fd as i32, &path)?; 1259 let inode = ROOT_INODE().lookup_follow_symlink(&remain_path, MAX_PATHLEN)?; 1260 let statfs = PosixStatfs::from(inode.fs().super_block()); 1261 writer.copy_one_to_user(&statfs, 0)?; 1262 return Ok(0); 1263 } 1264 1265 pub fn fstatfs(fd: i32, user_statfs: *mut PosixStatfs) -> Result<usize, SystemError> { 1266 let mut writer = UserBufferWriter::new(user_statfs, size_of::<PosixStatfs>(), true)?; 1267 let binding = ProcessManager::current_pcb().fd_table(); 1268 let fd_table_guard = binding.read(); 1269 let file = fd_table_guard 1270 .get_file_by_fd(fd) 1271 .ok_or(SystemError::EBADF)?; 1272 drop(fd_table_guard); 1273 let statfs = PosixStatfs::from(file.lock().inode().fs().super_block()); 1274 writer.copy_one_to_user(&statfs, 0)?; 1275 return Ok(0); 1276 } 1277 1278 pub fn do_statx( 1279 fd: i32, 1280 path: *const u8, 1281 flags: u32, 1282 mask: u32, 1283 usr_kstat: *mut PosixStatx, 1284 ) -> Result<usize, SystemError> { 1285 if usr_kstat.is_null() { 1286 return Err(SystemError::EFAULT); 1287 } 1288 1289 let mask = PosixStatxMask::from_bits_truncate(mask); 1290 1291 if mask.contains(PosixStatxMask::STATX_RESERVED) { 1292 return Err(SystemError::ENAVAIL); 1293 } 1294 1295 let flags = FileMode::from_bits_truncate(flags); 1296 let ofd = Self::open(path, flags.bits(), ModeType::empty().bits, true)?; 1297 1298 let binding = ProcessManager::current_pcb().fd_table(); 1299 let fd_table_guard = binding.read(); 1300 let file = fd_table_guard 1301 .get_file_by_fd(ofd as i32) 1302 .ok_or(SystemError::EBADF)?; 1303 // drop guard 以避免无法调度的问题 1304 drop(fd_table_guard); 1305 let mut writer = UserBufferWriter::new(usr_kstat, size_of::<PosixStatx>(), true)?; 1306 let mut tmp: PosixStatx = PosixStatx::new(); 1307 // 获取文件信息 1308 let metadata = file.lock().metadata()?; 1309 1310 tmp.stx_mask |= PosixStatxMask::STATX_BASIC_STATS; 1311 tmp.stx_blksize = metadata.blk_size as u32; 1312 if mask.contains(PosixStatxMask::STATX_MODE) || mask.contains(PosixStatxMask::STATX_TYPE) { 1313 tmp.stx_mode = metadata.mode; 1314 } 1315 if mask.contains(PosixStatxMask::STATX_NLINK) { 1316 tmp.stx_nlink = metadata.nlinks as u32; 1317 } 1318 if mask.contains(PosixStatxMask::STATX_UID) { 1319 tmp.stx_uid = metadata.uid as u32; 1320 } 1321 if mask.contains(PosixStatxMask::STATX_GID) { 1322 tmp.stx_gid = metadata.gid as u32; 1323 } 1324 if mask.contains(PosixStatxMask::STATX_ATIME) { 1325 tmp.stx_atime.tv_sec = metadata.atime.tv_sec; 1326 tmp.stx_atime.tv_nsec = metadata.atime.tv_nsec; 1327 } 1328 if mask.contains(PosixStatxMask::STATX_MTIME) { 1329 tmp.stx_mtime.tv_sec = metadata.ctime.tv_sec; 1330 tmp.stx_mtime.tv_nsec = metadata.ctime.tv_nsec; 1331 } 1332 if mask.contains(PosixStatxMask::STATX_CTIME) { 1333 // ctime是文件上次修改状态的时间 1334 tmp.stx_ctime.tv_sec = metadata.mtime.tv_sec; 1335 tmp.stx_ctime.tv_nsec = metadata.mtime.tv_nsec; 1336 } 1337 if mask.contains(PosixStatxMask::STATX_INO) { 1338 tmp.stx_inode = metadata.inode_id.into() as u64; 1339 } 1340 if mask.contains(PosixStatxMask::STATX_SIZE) { 1341 tmp.stx_size = metadata.size; 1342 } 1343 if mask.contains(PosixStatxMask::STATX_BLOCKS) { 1344 tmp.stx_blocks = metadata.blocks as u64; 1345 } 1346 1347 if mask.contains(PosixStatxMask::STATX_BTIME) { 1348 // btime是文件创建时间 1349 tmp.stx_btime.tv_sec = metadata.ctime.tv_sec; 1350 tmp.stx_btime.tv_nsec = metadata.ctime.tv_nsec; 1351 } 1352 if mask.contains(PosixStatxMask::STATX_ALL) { 1353 tmp.stx_attributes = StxAttributes::STATX_ATTR_APPEND; 1354 tmp.stx_attributes_mask |= 1355 StxAttributes::STATX_ATTR_AUTOMOUNT | StxAttributes::STATX_ATTR_DAX; 1356 tmp.stx_dev_major = metadata.dev_id as u32; 1357 tmp.stx_dev_minor = metadata.dev_id as u32; // 1358 tmp.stx_rdev_major = metadata.raw_dev.data(); 1359 tmp.stx_rdev_minor = metadata.raw_dev.data(); 1360 } 1361 if mask.contains(PosixStatxMask::STATX_MNT_ID) { 1362 tmp.stx_mnt_id = 0; 1363 } 1364 if mask.contains(PosixStatxMask::STATX_DIOALIGN) { 1365 tmp.stx_dio_mem_align = 0; 1366 tmp.stx_dio_offset_align = 0; 1367 } 1368 1369 match file.lock().file_type() { 1370 FileType::File => tmp.stx_mode.insert(ModeType::S_IFREG), 1371 FileType::Dir => tmp.stx_mode.insert(ModeType::S_IFDIR), 1372 FileType::BlockDevice => tmp.stx_mode.insert(ModeType::S_IFBLK), 1373 FileType::CharDevice => tmp.stx_mode.insert(ModeType::S_IFCHR), 1374 FileType::SymLink => tmp.stx_mode.insert(ModeType::S_IFLNK), 1375 FileType::Socket => tmp.stx_mode.insert(ModeType::S_IFSOCK), 1376 FileType::Pipe => tmp.stx_mode.insert(ModeType::S_IFIFO), 1377 FileType::KvmDevice => tmp.stx_mode.insert(ModeType::S_IFCHR), 1378 FileType::FramebufferDevice => tmp.stx_mode.insert(ModeType::S_IFCHR), 1379 } 1380 1381 writer.copy_one_to_user(&tmp, 0)?; 1382 Self::close(fd as usize).ok(); 1383 return Ok(0); 1384 } 1385 1386 pub fn mknod( 1387 path: *const u8, 1388 mode: ModeType, 1389 dev_t: DeviceNumber, 1390 ) -> Result<usize, SystemError> { 1391 let path = check_and_clone_cstr(path, Some(MAX_PATHLEN))?; 1392 let path = path.as_str().trim(); 1393 1394 let inode: Result<Arc<dyn IndexNode>, SystemError> = 1395 ROOT_INODE().lookup_follow_symlink(path, VFS_MAX_FOLLOW_SYMLINK_TIMES); 1396 1397 if inode.is_ok() { 1398 return Err(SystemError::EEXIST); 1399 } 1400 1401 let (filename, parent_path) = rsplit_path(path); 1402 1403 // 查找父目录 1404 let parent_inode: Arc<dyn IndexNode> = ROOT_INODE() 1405 .lookup_follow_symlink(parent_path.unwrap_or("/"), VFS_MAX_FOLLOW_SYMLINK_TIMES)?; 1406 // 创建nod 1407 parent_inode.mknod(filename, mode, dev_t)?; 1408 1409 return Ok(0); 1410 } 1411 1412 pub fn writev(fd: i32, iov: usize, count: usize) -> Result<usize, SystemError> { 1413 // IoVecs会进行用户态检验 1414 let iovecs = unsafe { IoVecs::from_user(iov as *const IoVec, count, false) }?; 1415 1416 let data = iovecs.gather(); 1417 1418 Self::write(fd, &data) 1419 } 1420 1421 pub fn readv(fd: i32, iov: usize, count: usize) -> Result<usize, SystemError> { 1422 // IoVecs会进行用户态检验 1423 let mut iovecs = unsafe { IoVecs::from_user(iov as *const IoVec, count, true) }?; 1424 1425 let mut data = vec![0; iovecs.0.iter().map(|x| x.len()).sum()]; 1426 1427 let len = Self::read(fd, &mut data)?; 1428 1429 iovecs.scatter(&data[..len]); 1430 1431 return Ok(len); 1432 } 1433 1434 pub fn readlink_at( 1435 dirfd: i32, 1436 path: *const u8, 1437 user_buf: *mut u8, 1438 buf_size: usize, 1439 ) -> Result<usize, SystemError> { 1440 let path = check_and_clone_cstr(path, Some(MAX_PATHLEN))?; 1441 let path = path.as_str().trim(); 1442 let mut user_buf = UserBufferWriter::new(user_buf, buf_size, true)?; 1443 1444 let (inode, path) = user_path_at(&ProcessManager::current_pcb(), dirfd, path)?; 1445 1446 let inode = inode.lookup(path.as_str())?; 1447 if inode.metadata()?.file_type != FileType::SymLink { 1448 return Err(SystemError::EINVAL); 1449 } 1450 1451 let ubuf = user_buf.buffer::<u8>(0).unwrap(); 1452 1453 let mut file = File::new(inode, FileMode::O_RDONLY)?; 1454 1455 let len = file.read(buf_size, ubuf)?; 1456 1457 return Ok(len); 1458 } 1459 1460 pub fn readlink( 1461 path: *const u8, 1462 user_buf: *mut u8, 1463 buf_size: usize, 1464 ) -> Result<usize, SystemError> { 1465 return Self::readlink_at(AtFlags::AT_FDCWD.bits(), path, user_buf, buf_size); 1466 } 1467 1468 pub fn access(pathname: *const u8, mode: u32) -> Result<usize, SystemError> { 1469 return do_faccessat( 1470 AtFlags::AT_FDCWD.bits(), 1471 pathname, 1472 ModeType::from_bits(mode).ok_or(SystemError::EINVAL)?, 1473 0, 1474 ); 1475 } 1476 1477 pub fn faccessat2( 1478 dirfd: i32, 1479 pathname: *const u8, 1480 mode: u32, 1481 flags: u32, 1482 ) -> Result<usize, SystemError> { 1483 return do_faccessat( 1484 dirfd, 1485 pathname, 1486 ModeType::from_bits(mode).ok_or(SystemError::EINVAL)?, 1487 flags, 1488 ); 1489 } 1490 1491 pub fn chmod(pathname: *const u8, mode: u32) -> Result<usize, SystemError> { 1492 return do_fchmodat( 1493 AtFlags::AT_FDCWD.bits(), 1494 pathname, 1495 ModeType::from_bits(mode).ok_or(SystemError::EINVAL)?, 1496 ); 1497 } 1498 1499 pub fn fchmodat(dirfd: i32, pathname: *const u8, mode: u32) -> Result<usize, SystemError> { 1500 return do_fchmodat( 1501 dirfd, 1502 pathname, 1503 ModeType::from_bits(mode).ok_or(SystemError::EINVAL)?, 1504 ); 1505 } 1506 1507 pub fn fchmod(fd: i32, mode: u32) -> Result<usize, SystemError> { 1508 let _mode = ModeType::from_bits(mode).ok_or(SystemError::EINVAL)?; 1509 let binding = ProcessManager::current_pcb().fd_table(); 1510 let fd_table_guard = binding.read(); 1511 let _file = fd_table_guard 1512 .get_file_by_fd(fd) 1513 .ok_or(SystemError::EBADF)?; 1514 1515 // fchmod没完全实现，因此不修改文件的权限 1516 // todo: 实现fchmod 1517 kwarn!("fchmod not fully implemented"); 1518 return Ok(0); 1519 } 1520 /// #挂载文件系统 1521 /// 1522 /// 用于挂载文件系统,目前仅支持ramfs挂载 1523 /// 1524 /// ## 参数: 1525 /// 1526 /// - source 挂载设备(暂时不支持) 1527 /// - target 挂载目录 1528 /// - filesystemtype 文件系统 1529 /// - mountflags 挂载选项（暂未实现） 1530 /// - data 带数据挂载 1531 /// 1532 /// ## 返回值 1533 /// - Ok(0): 挂载成功 1534 /// - Err(SystemError) :挂载过程中出错 1535 pub fn mount( 1536 _source: *const u8, 1537 target: *const u8, 1538 filesystemtype: *const u8, 1539 _mountflags: usize, 1540 _data: *const c_void, 1541 ) -> Result<usize, SystemError> { 1542 let target = user_access::check_and_clone_cstr(target, Some(MAX_PATHLEN))?; 1543 1544 let filesystemtype = user_access::check_and_clone_cstr(filesystemtype, Some(MAX_PATHLEN))?; 1545 1546 let filesystemtype = producefs!(FSMAKER, filesystemtype)?; 1547 1548 return Vcore::do_mount(filesystemtype, target.to_string().as_str()); 1549 } 1550 1551 // 想法：可以在VFS中实现一个文件系统分发器，流程如下： 1552 // 1. 接受从上方传来的文件类型字符串 1553 // 2. 将传入值与启动时准备好的字符串数组逐个比较（probe） 1554 // 3. 直接在函数内调用构造方法并直接返回文件系统对象 1555 } 1556 1557 #[repr(C)] 1558 #[derive(Debug, Clone, Copy)] 1559 pub struct IoVec { 1560 /// 缓冲区的起始地址 1561 pub iov_base: *mut u8, 1562 /// 缓冲区的长度 1563 pub iov_len: usize, 1564 } 1565 1566 /// 用于存储多个来自用户空间的IoVec 1567 /// 1568 /// 由于目前内核中的文件系统还不支持分散读写，所以暂时只支持将用户空间的IoVec聚合成一个缓冲区，然后进行操作。 1569 /// TODO：支持分散读写 1570 #[derive(Debug)] 1571 pub struct IoVecs(Vec<&'static mut [u8]>); 1572 1573 impl IoVecs { 1574 /// 从用户空间的IoVec中构造IoVecs 1575 /// 1576 /// @param iov 用户空间的IoVec 1577 /// @param iovcnt 用户空间的IoVec的数量 1578 /// @param readv 是否为readv系统调用 1579 /// 1580 /// @return 构造成功返回IoVecs，否则返回错误码 1581 pub unsafe fn from_user( 1582 iov: *const IoVec, 1583 iovcnt: usize, 1584 _readv: bool, 1585 ) -> Result<Self, SystemError> { 1586 // 检查iov指针所在空间是否合法 1587 verify_area( 1588 VirtAddr::new(iov as usize), 1589 iovcnt * core::mem::size_of::<IoVec>(), 1590 ) 1591 .map_err(|_| SystemError::EFAULT)?; 1592 1593 // 将用户空间的IoVec转换为引用（注意：这里的引用是静态的，因为用户空间的IoVec不会被释放） 1594 let iovs: &[IoVec] = core::slice::from_raw_parts(iov, iovcnt); 1595 1596 let mut slices: Vec<&mut [u8]> = vec![]; 1597 slices.reserve(iovs.len()); 1598 1599 for iov in iovs.iter() { 1600 if iov.iov_len == 0 { 1601 continue; 1602 } 1603 1604 verify_area( 1605 VirtAddr::new(iov.iov_base as usize), 1606 iovcnt * core::mem::size_of::<IoVec>(), 1607 ) 1608 .map_err(|_| SystemError::EFAULT)?; 1609 1610 slices.push(core::slice::from_raw_parts_mut(iov.iov_base, iov.iov_len)); 1611 } 1612 1613 return Ok(Self(slices)); 1614 } 1615 1616 /// @brief 将IoVecs中的数据聚合到一个缓冲区中 1617 /// 1618 /// @return 返回聚合后的缓冲区 1619 pub fn gather(&self) -> Vec<u8> { 1620 let mut buf = Vec::new(); 1621 for slice in self.0.iter() { 1622 buf.extend_from_slice(slice); 1623 } 1624 return buf; 1625 } 1626 1627 /// @brief 将给定的数据分散写入到IoVecs中 1628 pub fn scatter(&mut self, data: &[u8]) { 1629 let mut data: &[u8] = data; 1630 for slice in self.0.iter_mut() { 1631 let len = core::cmp::min(slice.len(), data.len()); 1632 if len == 0 { 1633 continue; 1634 } 1635 1636 slice[..len].copy_from_slice(&data[..len]); 1637 data = &data[len..]; 1638 } 1639 } 1640 1641 /// @brief 创建与IoVecs等长的缓冲区 1642 /// 1643 /// @param set_len 是否设置返回的Vec的len。 1644 /// 如果为true，则返回的Vec的len为所有IoVec的长度之和; 1645 /// 否则返回的Vec的len为0，capacity为所有IoVec的长度之和. 1646 /// 1647 /// @return 返回创建的缓冲区 1648 pub fn new_buf(&self, set_len: bool) -> Vec<u8> { 1649 let total_len: usize = self.0.iter().map(|slice| slice.len()).sum(); 1650 let mut buf: Vec<u8> = Vec::with_capacity(total_len); 1651 1652 if set_len { 1653 buf.resize(total_len, 0); 1654 } 1655 return buf; 1656 } 1657 } 1658