12dbef785SGnoCiYeH use core::ffi::CStr; 22dbef785SGnoCiYeH 31496ba7bSLoGin use alloc::{ 41496ba7bSLoGin string::{String, ToString}, 51496ba7bSLoGin sync::Arc, 61496ba7bSLoGin vec::Vec, 71496ba7bSLoGin }; 8004e86ffSlogin 9004e86ffSlogin use crate::{ 102dbef785SGnoCiYeH driver::base::{block::SeekFrom, device::DeviceNumber}, 112b771e32SGou Ngai filesystem::vfs::file::FileDescriptorVec, 122dbef785SGnoCiYeH include::bindings::bindings::{verify_area, AT_REMOVEDIR, PROC_MAX_FD_NUM}, 132b771e32SGou Ngai kerror, 141496ba7bSLoGin libs::rwlock::RwLockWriteGuard, 151496ba7bSLoGin mm::VirtAddr, 161496ba7bSLoGin process::ProcessManager, 17709498caSLoGin syscall::{ 18709498caSLoGin user_access::{check_and_clone_cstr, UserBufferReader, UserBufferWriter}, 19709498caSLoGin Syscall, SystemError, 20709498caSLoGin }, 2167b48188Shoumkh time::TimeSpec, 22004e86ffSlogin }; 23004e86ffSlogin 24004e86ffSlogin use super::{ 25ab5c8ca4Slogin core::{do_mkdir, do_remove_dir, do_unlink_at}, 26709498caSLoGin fcntl::{AtFlags, FcntlCommand, FD_CLOEXEC}, 27004e86ffSlogin file::{File, FileMode}, 28*9b0abe6dSLoGin open::do_faccessat, 29*9b0abe6dSLoGin utils::{rsplit_path, user_path_at}, 30a03c4f9dSLoGin Dirent, FileType, IndexNode, MAX_PATHLEN, ROOT_INODE, VFS_MAX_FOLLOW_SYMLINK_TIMES, 31004e86ffSlogin }; 3240314b30SXiaoye Zheng // use crate::kdebug; 33004e86ffSlogin 34ab5c8ca4Slogin pub const SEEK_SET: u32 = 0; 35ab5c8ca4Slogin pub const SEEK_CUR: u32 = 1; 36ab5c8ca4Slogin pub const SEEK_END: u32 = 2; 37ab5c8ca4Slogin pub const SEEK_MAX: u32 = 3; 38004e86ffSlogin 3967b48188Shoumkh bitflags! { 4067b48188Shoumkh /// 文件类型和权限 416b4e7a29SLoGin #[repr(C)] 4267b48188Shoumkh pub struct ModeType: u32 { 4367b48188Shoumkh /// 掩码 4467b48188Shoumkh const S_IFMT = 0o0_170_000; 4567b48188Shoumkh /// 文件类型 4667b48188Shoumkh const S_IFSOCK = 0o140000; 4767b48188Shoumkh const S_IFLNK = 0o120000; 4867b48188Shoumkh const S_IFREG = 0o100000; 4967b48188Shoumkh const S_IFBLK = 0o060000; 5067b48188Shoumkh const S_IFDIR = 0o040000; 5167b48188Shoumkh const S_IFCHR = 0o020000; 5267b48188Shoumkh const S_IFIFO = 0o010000; 5367b48188Shoumkh 5467b48188Shoumkh const S_ISUID = 0o004000; 5567b48188Shoumkh const S_ISGID = 0o002000; 5667b48188Shoumkh const S_ISVTX = 0o001000; 5767b48188Shoumkh /// 文件用户权限 5867b48188Shoumkh const S_IRWXU = 0o0700; 5967b48188Shoumkh const S_IRUSR = 0o0400; 6067b48188Shoumkh const S_IWUSR = 0o0200; 6167b48188Shoumkh const S_IXUSR = 0o0100; 6267b48188Shoumkh /// 文件组权限 6367b48188Shoumkh const S_IRWXG = 0o0070; 6467b48188Shoumkh const S_IRGRP = 0o0040; 6567b48188Shoumkh const S_IWGRP = 0o0020; 6667b48188Shoumkh const S_IXGRP = 0o0010; 6767b48188Shoumkh /// 文件其他用户权限 6867b48188Shoumkh const S_IRWXO = 0o0007; 6967b48188Shoumkh const S_IROTH = 0o0004; 7067b48188Shoumkh const S_IWOTH = 0o0002; 7167b48188Shoumkh const S_IXOTH = 0o0001; 7206d5e247SLoGin 7306d5e247SLoGin /// 0o777 7406d5e247SLoGin const S_IRWXUGO = Self::S_IRWXU.bits | Self::S_IRWXG.bits | Self::S_IRWXO.bits; 7506d5e247SLoGin /// 0o7777 7606d5e247SLoGin const S_IALLUGO = Self::S_ISUID.bits | Self::S_ISGID.bits | Self::S_ISVTX.bits| Self::S_IRWXUGO.bits; 7706d5e247SLoGin /// 0o444 7806d5e247SLoGin const S_IRUGO = Self::S_IRUSR.bits | Self::S_IRGRP.bits | Self::S_IROTH.bits; 7906d5e247SLoGin /// 0o222 8006d5e247SLoGin const S_IWUGO = Self::S_IWUSR.bits | Self::S_IWGRP.bits | Self::S_IWOTH.bits; 8106d5e247SLoGin /// 0o111 8206d5e247SLoGin const S_IXUGO = Self::S_IXUSR.bits | Self::S_IXGRP.bits | Self::S_IXOTH.bits; 8306d5e247SLoGin 8406d5e247SLoGin 8567b48188Shoumkh } 8667b48188Shoumkh } 8767b48188Shoumkh 8867b48188Shoumkh #[repr(C)] 8967b48188Shoumkh /// # 文件信息结构体 9067b48188Shoumkh pub struct PosixKstat { 9167b48188Shoumkh /// 硬件设备ID 9267b48188Shoumkh dev_id: u64, 9367b48188Shoumkh /// inode号 9467b48188Shoumkh inode: u64, 9567b48188Shoumkh /// 硬链接数 9667b48188Shoumkh nlink: u64, 9767b48188Shoumkh /// 文件权限 9867b48188Shoumkh mode: ModeType, 9967b48188Shoumkh /// 所有者用户ID 10067b48188Shoumkh uid: i32, 10167b48188Shoumkh /// 所有者组ID 10267b48188Shoumkh gid: i32, 10367b48188Shoumkh /// 设备ID 10467b48188Shoumkh rdev: i64, 10567b48188Shoumkh /// 文件大小 10667b48188Shoumkh size: i64, 10767b48188Shoumkh /// 文件系统块大小 10867b48188Shoumkh blcok_size: i64, 10967b48188Shoumkh /// 分配的512B块数 11067b48188Shoumkh blocks: u64, 11167b48188Shoumkh /// 最后访问时间 11267b48188Shoumkh atime: TimeSpec, 11367b48188Shoumkh /// 最后修改时间 11467b48188Shoumkh mtime: TimeSpec, 11567b48188Shoumkh /// 最后状态变化时间 11667b48188Shoumkh ctime: TimeSpec, 11767b48188Shoumkh /// 用于填充结构体大小的空白数据 11867b48188Shoumkh pub _pad: [i8; 24], 11967b48188Shoumkh } 12067b48188Shoumkh impl PosixKstat { 12167b48188Shoumkh fn new() -> Self { 12267b48188Shoumkh Self { 12367b48188Shoumkh inode: 0, 12467b48188Shoumkh dev_id: 0, 12567b48188Shoumkh mode: ModeType { bits: 0 }, 12667b48188Shoumkh nlink: 0, 12767b48188Shoumkh uid: 0, 12867b48188Shoumkh gid: 0, 12967b48188Shoumkh rdev: 0, 13067b48188Shoumkh size: 0, 13167b48188Shoumkh atime: TimeSpec { 13267b48188Shoumkh tv_sec: 0, 13367b48188Shoumkh tv_nsec: 0, 13467b48188Shoumkh }, 13567b48188Shoumkh mtime: TimeSpec { 13667b48188Shoumkh tv_sec: 0, 13767b48188Shoumkh tv_nsec: 0, 13867b48188Shoumkh }, 13967b48188Shoumkh ctime: TimeSpec { 14067b48188Shoumkh tv_sec: 0, 14167b48188Shoumkh tv_nsec: 0, 14267b48188Shoumkh }, 14367b48188Shoumkh blcok_size: 0, 14467b48188Shoumkh blocks: 0, 14567b48188Shoumkh _pad: Default::default(), 14667b48188Shoumkh } 14767b48188Shoumkh } 14867b48188Shoumkh } 149ab5c8ca4Slogin impl Syscall { 150ab5c8ca4Slogin /// @brief 为当前进程打开一个文件 151ab5c8ca4Slogin /// 152ab5c8ca4Slogin /// @param path 文件路径 153ab5c8ca4Slogin /// @param o_flags 打开文件的标志位 154ab5c8ca4Slogin /// 155ab5c8ca4Slogin /// @return 文件描述符编号,或者是错误码 156ab5c8ca4Slogin pub fn open(path: &str, mode: FileMode) -> Result<usize, SystemError> { 1576d81180bSLoGin // kdebug!("open: path: {}, mode: {:?}", path, mode); 158ab5c8ca4Slogin // 文件名过长 1592dbef785SGnoCiYeH if path.len() > MAX_PATHLEN as usize { 160ab5c8ca4Slogin return Err(SystemError::ENAMETOOLONG); 161ab5c8ca4Slogin } 162ab5c8ca4Slogin 163a03c4f9dSLoGin let inode: Result<Arc<dyn IndexNode>, SystemError> = 164a03c4f9dSLoGin ROOT_INODE().lookup_follow_symlink(path, VFS_MAX_FOLLOW_SYMLINK_TIMES); 165ab5c8ca4Slogin 166ab5c8ca4Slogin let inode: Arc<dyn IndexNode> = if inode.is_err() { 167ab5c8ca4Slogin let errno = inode.unwrap_err(); 168ab5c8ca4Slogin // 文件不存在,且需要创建 169ab5c8ca4Slogin if mode.contains(FileMode::O_CREAT) 170ab5c8ca4Slogin && !mode.contains(FileMode::O_DIRECTORY) 171ab5c8ca4Slogin && errno == SystemError::ENOENT 172ab5c8ca4Slogin { 173ab5c8ca4Slogin let (filename, parent_path) = rsplit_path(path); 174ab5c8ca4Slogin // 查找父目录 175ab5c8ca4Slogin let parent_inode: Arc<dyn IndexNode> = 176ab5c8ca4Slogin ROOT_INODE().lookup(parent_path.unwrap_or("/"))?; 177ab5c8ca4Slogin // 创建文件 1786b4e7a29SLoGin let inode: Arc<dyn IndexNode> = parent_inode.create( 1796b4e7a29SLoGin filename, 1806b4e7a29SLoGin FileType::File, 1816b4e7a29SLoGin ModeType::from_bits_truncate(0o755), 1826b4e7a29SLoGin )?; 183ab5c8ca4Slogin inode 184004e86ffSlogin } else { 185ab5c8ca4Slogin // 不需要创建文件,因此返回错误码 186ab5c8ca4Slogin return Err(errno); 187004e86ffSlogin } 188004e86ffSlogin } else { 189ab5c8ca4Slogin inode.unwrap() 190004e86ffSlogin }; 191004e86ffSlogin 192ab5c8ca4Slogin let file_type: FileType = inode.metadata()?.file_type; 193ab5c8ca4Slogin // 如果要打开的是文件夹,而目标不是文件夹 194ab5c8ca4Slogin if mode.contains(FileMode::O_DIRECTORY) && file_type != FileType::Dir { 195ab5c8ca4Slogin return Err(SystemError::ENOTDIR); 196004e86ffSlogin } 197ab5c8ca4Slogin 198ab5c8ca4Slogin // 创建文件对象 19934e6d6c8Syuyi2439 200ab5c8ca4Slogin let mut file: File = File::new(inode, mode)?; 201ab5c8ca4Slogin 202ab5c8ca4Slogin // 打开模式为“追加” 203ab5c8ca4Slogin if mode.contains(FileMode::O_APPEND) { 204ab5c8ca4Slogin file.lseek(SeekFrom::SeekEnd(0))?; 205ab5c8ca4Slogin } 2060facf623SLoGin 2070facf623SLoGin // 如果O_TRUNC,并且,打开模式包含O_RDWR或O_WRONLY,清空文件 2080facf623SLoGin if mode.contains(FileMode::O_TRUNC) 2090facf623SLoGin && (mode.contains(FileMode::O_RDWR) || mode.contains(FileMode::O_WRONLY)) 2100facf623SLoGin && file_type == FileType::File 2110facf623SLoGin { 2120facf623SLoGin file.ftruncate(0)?; 2130facf623SLoGin } 214ab5c8ca4Slogin // 把文件对象存入pcb 2151496ba7bSLoGin let r = ProcessManager::current_pcb() 2161496ba7bSLoGin .fd_table() 2171496ba7bSLoGin .write() 2181496ba7bSLoGin .alloc_fd(file, None) 2191496ba7bSLoGin .map(|fd| fd as usize); 2201496ba7bSLoGin 2216d81180bSLoGin return r; 222ab5c8ca4Slogin } 223ab5c8ca4Slogin 224ab5c8ca4Slogin /// @brief 关闭文件 225ab5c8ca4Slogin /// 226ab5c8ca4Slogin /// @param fd 文件描述符编号 227ab5c8ca4Slogin /// 228ab5c8ca4Slogin /// @return 成功返回0,失败返回错误码 229ab5c8ca4Slogin pub fn close(fd: usize) -> Result<usize, SystemError> { 2301496ba7bSLoGin let binding = ProcessManager::current_pcb().fd_table(); 2311496ba7bSLoGin let mut fd_table_guard = binding.write(); 2321496ba7bSLoGin 23334e6d6c8Syuyi2439 let res = fd_table_guard.drop_fd(fd as i32).map(|_| 0); 23434e6d6c8Syuyi2439 23534e6d6c8Syuyi2439 return res; 236ab5c8ca4Slogin } 237ab5c8ca4Slogin 23840314b30SXiaoye Zheng /// @brief 发送命令到文件描述符对应的设备, 23940314b30SXiaoye Zheng /// 24040314b30SXiaoye Zheng /// @param fd 文件描述符编号 24140314b30SXiaoye Zheng /// @param cmd 设备相关的请求类型 24240314b30SXiaoye Zheng /// 24340314b30SXiaoye Zheng /// @return Ok(usize) 成功返回0 24440314b30SXiaoye Zheng /// @return Err(SystemError) 读取失败,返回posix错误码 24540314b30SXiaoye Zheng pub fn ioctl(fd: usize, cmd: u32, data: usize) -> Result<usize, SystemError> { 24640314b30SXiaoye Zheng let binding = ProcessManager::current_pcb().fd_table(); 24740314b30SXiaoye Zheng let fd_table_guard = binding.read(); 24840314b30SXiaoye Zheng 24940314b30SXiaoye Zheng let file = fd_table_guard 25040314b30SXiaoye Zheng .get_file_by_fd(fd as i32) 25140314b30SXiaoye Zheng .ok_or(SystemError::EBADF)?; 25240314b30SXiaoye Zheng 25340314b30SXiaoye Zheng // drop guard 以避免无法调度的问题 25440314b30SXiaoye Zheng drop(fd_table_guard); 25540314b30SXiaoye Zheng let r = file.lock_no_preempt().inode().ioctl(cmd, data); 25640314b30SXiaoye Zheng return r; 25740314b30SXiaoye Zheng } 25840314b30SXiaoye Zheng 259ab5c8ca4Slogin /// @brief 根据文件描述符,读取文件数据。尝试读取的数据长度与buf的长度相同。 260ab5c8ca4Slogin /// 261ab5c8ca4Slogin /// @param fd 文件描述符编号 262ab5c8ca4Slogin /// @param buf 输出缓冲区。 263ab5c8ca4Slogin /// 264ab5c8ca4Slogin /// @return Ok(usize) 成功读取的数据的字节数 265ab5c8ca4Slogin /// @return Err(SystemError) 读取失败,返回posix错误码 266ab5c8ca4Slogin pub fn read(fd: i32, buf: &mut [u8]) -> Result<usize, SystemError> { 2671496ba7bSLoGin let binding = ProcessManager::current_pcb().fd_table(); 2681496ba7bSLoGin let fd_table_guard = binding.read(); 2691496ba7bSLoGin 2701496ba7bSLoGin let file = fd_table_guard.get_file_by_fd(fd); 271ab5c8ca4Slogin if file.is_none() { 272ab5c8ca4Slogin return Err(SystemError::EBADF); 273ab5c8ca4Slogin } 2741496ba7bSLoGin // drop guard 以避免无法调度的问题 2751496ba7bSLoGin drop(fd_table_guard); 2761496ba7bSLoGin let file = file.unwrap(); 277ab5c8ca4Slogin 2781496ba7bSLoGin return file.lock_no_preempt().read(buf.len(), buf); 279ab5c8ca4Slogin } 280ab5c8ca4Slogin 281ab5c8ca4Slogin /// @brief 根据文件描述符,向文件写入数据。尝试写入的数据长度与buf的长度相同。 282ab5c8ca4Slogin /// 283ab5c8ca4Slogin /// @param fd 文件描述符编号 284ab5c8ca4Slogin /// @param buf 输入缓冲区。 285ab5c8ca4Slogin /// 286ab5c8ca4Slogin /// @return Ok(usize) 成功写入的数据的字节数 287ab5c8ca4Slogin /// @return Err(SystemError) 写入失败,返回posix错误码 288ab5c8ca4Slogin pub fn write(fd: i32, buf: &[u8]) -> Result<usize, SystemError> { 2891496ba7bSLoGin let binding = ProcessManager::current_pcb().fd_table(); 2901496ba7bSLoGin let fd_table_guard = binding.read(); 291ab5c8ca4Slogin 2921496ba7bSLoGin let file = fd_table_guard 2931496ba7bSLoGin .get_file_by_fd(fd) 2941496ba7bSLoGin .ok_or(SystemError::EBADF)?; 2951496ba7bSLoGin 2961496ba7bSLoGin // drop guard 以避免无法调度的问题 2971496ba7bSLoGin drop(fd_table_guard); 2981496ba7bSLoGin return file.lock_no_preempt().write(buf.len(), buf); 299ab5c8ca4Slogin } 300ab5c8ca4Slogin 301ab5c8ca4Slogin /// @brief 调整文件操作指针的位置 302ab5c8ca4Slogin /// 303ab5c8ca4Slogin /// @param fd 文件描述符编号 304ab5c8ca4Slogin /// @param seek 调整的方式 305ab5c8ca4Slogin /// 306ab5c8ca4Slogin /// @return Ok(usize) 调整后,文件访问指针相对于文件头部的偏移量 307ab5c8ca4Slogin /// @return Err(SystemError) 调整失败,返回posix错误码 308ab5c8ca4Slogin pub fn lseek(fd: i32, seek: SeekFrom) -> Result<usize, SystemError> { 3091496ba7bSLoGin let binding = ProcessManager::current_pcb().fd_table(); 3101496ba7bSLoGin let fd_table_guard = binding.read(); 3111496ba7bSLoGin let file = fd_table_guard 3121496ba7bSLoGin .get_file_by_fd(fd) 3131496ba7bSLoGin .ok_or(SystemError::EBADF)?; 3141496ba7bSLoGin 3151496ba7bSLoGin // drop guard 以避免无法调度的问题 3161496ba7bSLoGin drop(fd_table_guard); 3171496ba7bSLoGin return file.lock_no_preempt().lseek(seek); 318004e86ffSlogin } 319004e86ffSlogin 320004e86ffSlogin /// @brief 切换工作目录 321004e86ffSlogin /// 322004e86ffSlogin /// @param dest_path 目标路径 323004e86ffSlogin /// 324004e86ffSlogin /// @return 返回码 描述 325004e86ffSlogin /// 0 | 成功 326004e86ffSlogin /// 327004e86ffSlogin /// EACCESS | 权限不足 328004e86ffSlogin /// 329004e86ffSlogin /// ELOOP | 解析path时遇到路径循环 330004e86ffSlogin /// 331004e86ffSlogin /// ENAMETOOLONG | 路径名过长 332004e86ffSlogin /// 333004e86ffSlogin /// ENOENT | 目标文件或目录不存在 334004e86ffSlogin /// 335004e86ffSlogin /// ENODIR | 检索期间发现非目录项 336004e86ffSlogin /// 337004e86ffSlogin /// ENOMEM | 系统内存不足 338004e86ffSlogin /// 339004e86ffSlogin /// EFAULT | 错误的地址 340004e86ffSlogin /// 341004e86ffSlogin /// ENAMETOOLONG | 路径过长 342ab5c8ca4Slogin pub fn chdir(dest_path: &str) -> Result<usize, SystemError> { 3431496ba7bSLoGin let proc = ProcessManager::current_pcb(); 344ab5c8ca4Slogin // Copy path to kernel space to avoid some security issues 3451496ba7bSLoGin let path = dest_path.to_string(); 3461496ba7bSLoGin let mut new_path = String::from(""); 3471496ba7bSLoGin if path.len() > 0 { 3481496ba7bSLoGin let cwd = match path.as_bytes()[0] { 3491496ba7bSLoGin b'/' => String::from("/"), 3501496ba7bSLoGin _ => proc.basic().cwd(), 3511496ba7bSLoGin }; 3521496ba7bSLoGin let mut cwd_vec: Vec<_> = cwd.split("/").filter(|&x| x != "").collect(); 3531496ba7bSLoGin let path_split = path.split("/").filter(|&x| x != ""); 3541496ba7bSLoGin for seg in path_split { 3551496ba7bSLoGin if seg == ".." { 3561496ba7bSLoGin cwd_vec.pop(); 3571496ba7bSLoGin } else if seg == "." { 3581496ba7bSLoGin // 当前目录 3591496ba7bSLoGin } else { 3601496ba7bSLoGin cwd_vec.push(seg); 3611496ba7bSLoGin } 3621496ba7bSLoGin } 3631496ba7bSLoGin //proc.basic().set_path(String::from("")); 3641496ba7bSLoGin for seg in cwd_vec { 3651496ba7bSLoGin new_path.push_str("/"); 3661496ba7bSLoGin new_path.push_str(seg); 3671496ba7bSLoGin } 3681496ba7bSLoGin if new_path == "" { 3691496ba7bSLoGin new_path = String::from("/"); 3701496ba7bSLoGin } 3711496ba7bSLoGin } 372a03c4f9dSLoGin let inode = 373a03c4f9dSLoGin match ROOT_INODE().lookup_follow_symlink(&new_path, VFS_MAX_FOLLOW_SYMLINK_TIMES) { 374004e86ffSlogin Err(e) => { 375676b8ef6SMork kerror!("Change Directory Failed, Error = {:?}", e); 376ab5c8ca4Slogin return Err(SystemError::ENOENT); 377004e86ffSlogin } 378004e86ffSlogin Ok(i) => i, 379004e86ffSlogin }; 3801496ba7bSLoGin let metadata = inode.metadata()?; 3811496ba7bSLoGin if metadata.file_type == FileType::Dir { 3821496ba7bSLoGin proc.basic_mut().set_cwd(String::from(new_path)); 383ab5c8ca4Slogin return Ok(0); 384004e86ffSlogin } else { 385ab5c8ca4Slogin return Err(SystemError::ENOTDIR); 386004e86ffSlogin } 387004e86ffSlogin } 3881496ba7bSLoGin 3891496ba7bSLoGin /// @brief 获取当前进程的工作目录路径 3901496ba7bSLoGin /// 3911496ba7bSLoGin /// @param buf 指向缓冲区的指针 3921496ba7bSLoGin /// @param size 缓冲区的大小 3931496ba7bSLoGin /// 3941496ba7bSLoGin /// @return 成功,返回的指针指向包含工作目录路径的字符串 3951496ba7bSLoGin /// @return 错误,没有足够的空间 3961496ba7bSLoGin pub fn getcwd(buf: &mut [u8]) -> Result<VirtAddr, SystemError> { 3971496ba7bSLoGin let proc = ProcessManager::current_pcb(); 3981496ba7bSLoGin let cwd = proc.basic().cwd(); 3991496ba7bSLoGin 4001496ba7bSLoGin let cwd_bytes = cwd.as_bytes(); 4011496ba7bSLoGin let cwd_len = cwd_bytes.len(); 4021496ba7bSLoGin if cwd_len + 1 > buf.len() { 4031496ba7bSLoGin return Err(SystemError::ENOMEM); 404004e86ffSlogin } 4051496ba7bSLoGin buf[..cwd_len].copy_from_slice(cwd_bytes); 4061496ba7bSLoGin buf[cwd_len] = 0; 4071496ba7bSLoGin 4081496ba7bSLoGin return Ok(VirtAddr::new(buf.as_ptr() as usize)); 409004e86ffSlogin } 410004e86ffSlogin 411004e86ffSlogin /// @brief 获取目录中的数据 412004e86ffSlogin /// 413ab5c8ca4Slogin /// TODO: 这个函数的语义与Linux不一致,需要修改!!! 414ab5c8ca4Slogin /// 415004e86ffSlogin /// @param fd 文件描述符号 416ab5c8ca4Slogin /// @param buf 输出缓冲区 417ab5c8ca4Slogin /// 418ab5c8ca4Slogin /// @return 成功返回读取的字节数,失败返回错误码 419ab5c8ca4Slogin pub fn getdents(fd: i32, buf: &mut [u8]) -> Result<usize, SystemError> { 420ab5c8ca4Slogin let dirent = 421ab5c8ca4Slogin unsafe { (buf.as_mut_ptr() as *mut Dirent).as_mut() }.ok_or(SystemError::EFAULT)?; 422004e86ffSlogin 423004e86ffSlogin if fd < 0 || fd as u32 > PROC_MAX_FD_NUM { 424ab5c8ca4Slogin return Err(SystemError::EBADF); 425004e86ffSlogin } 426004e86ffSlogin 427004e86ffSlogin // 获取fd 4281496ba7bSLoGin let binding = ProcessManager::current_pcb().fd_table(); 4291496ba7bSLoGin let fd_table_guard = binding.read(); 4301496ba7bSLoGin let file = fd_table_guard 4311496ba7bSLoGin .get_file_by_fd(fd) 4321496ba7bSLoGin .ok_or(SystemError::EBADF)?; 433004e86ffSlogin 4341496ba7bSLoGin // drop guard 以避免无法调度的问题 4351496ba7bSLoGin drop(fd_table_guard); 43634e6d6c8Syuyi2439 43734e6d6c8Syuyi2439 let res = file.lock_no_preempt().readdir(dirent).map(|x| x as usize); 43834e6d6c8Syuyi2439 43934e6d6c8Syuyi2439 return res; 440004e86ffSlogin } 441004e86ffSlogin 442004e86ffSlogin /// @brief 创建文件夹 443004e86ffSlogin /// 444004e86ffSlogin /// @param path(r8) 路径 / mode(r9) 模式 445004e86ffSlogin /// 446004e86ffSlogin /// @return uint64_t 负数错误码 / 0表示成功 447ab5c8ca4Slogin pub fn mkdir(path: &str, mode: usize) -> Result<usize, SystemError> { 448ab5c8ca4Slogin return do_mkdir(path, FileMode::from_bits_truncate(mode as u32)).map(|x| x as usize); 449004e86ffSlogin } 450004e86ffSlogin 451ab5c8ca4Slogin /// **删除文件夹、取消文件的链接、删除文件的系统调用** 452004e86ffSlogin /// 453ab5c8ca4Slogin /// ## 参数 454004e86ffSlogin /// 455ab5c8ca4Slogin /// - `dirfd`:文件夹的文件描述符.目前暂未实现 456ab5c8ca4Slogin /// - `pathname`:文件夹的路径 457ab5c8ca4Slogin /// - `flags`:标志位 458004e86ffSlogin /// 459004e86ffSlogin /// 460ab5c8ca4Slogin pub fn unlinkat(_dirfd: i32, pathname: &str, flags: u32) -> Result<usize, SystemError> { 461004e86ffSlogin // kdebug!("sys_unlink_at={path:?}"); 462ab5c8ca4Slogin if (flags & (!AT_REMOVEDIR)) != 0 { 463ab5c8ca4Slogin return Err(SystemError::EINVAL); 464004e86ffSlogin } 465004e86ffSlogin 466ab5c8ca4Slogin if (flags & AT_REMOVEDIR) > 0 { 467004e86ffSlogin // kdebug!("rmdir"); 468ab5c8ca4Slogin match do_remove_dir(&pathname) { 469004e86ffSlogin Err(err) => { 470676b8ef6SMork kerror!("Failed to Remove Directory, Error Code = {:?}", err); 471ab5c8ca4Slogin return Err(err); 472004e86ffSlogin } 473004e86ffSlogin Ok(_) => { 474ab5c8ca4Slogin return Ok(0); 475004e86ffSlogin } 476004e86ffSlogin } 477004e86ffSlogin } 478004e86ffSlogin 479ab5c8ca4Slogin match do_unlink_at(&pathname, FileMode::from_bits_truncate(flags as u32)) { 480004e86ffSlogin Err(err) => { 481676b8ef6SMork kerror!("Failed to Remove Directory, Error Code = {:?}", err); 482ab5c8ca4Slogin return Err(err); 483004e86ffSlogin } 484004e86ffSlogin Ok(_) => { 485ab5c8ca4Slogin return Ok(0); 486004e86ffSlogin } 487004e86ffSlogin } 488004e86ffSlogin } 4892b771e32SGou Ngai 490ab5c8ca4Slogin /// @brief 根据提供的文件描述符的fd,复制对应的文件结构体,并返回新复制的文件结构体对应的fd 491ab5c8ca4Slogin pub fn dup(oldfd: i32) -> Result<usize, SystemError> { 4921496ba7bSLoGin let binding = ProcessManager::current_pcb().fd_table(); 4931496ba7bSLoGin let mut fd_table_guard = binding.write(); 494ab5c8ca4Slogin 4951496ba7bSLoGin let old_file = fd_table_guard 4961496ba7bSLoGin .get_file_by_fd(oldfd) 4971496ba7bSLoGin .ok_or(SystemError::EBADF)?; 4981496ba7bSLoGin 4991496ba7bSLoGin let new_file = old_file 5001496ba7bSLoGin .lock_no_preempt() 5011496ba7bSLoGin .try_clone() 5021496ba7bSLoGin .ok_or(SystemError::EBADF)?; 5032b771e32SGou Ngai // 申请文件描述符,并把文件对象存入其中 5041496ba7bSLoGin let res = fd_table_guard.alloc_fd(new_file, None).map(|x| x as usize); 5052b771e32SGou Ngai return res; 5062b771e32SGou Ngai } 5072b771e32SGou Ngai 508ab5c8ca4Slogin /// 根据提供的文件描述符的fd,和指定新fd,复制对应的文件结构体, 509ab5c8ca4Slogin /// 并返回新复制的文件结构体对应的fd. 510ab5c8ca4Slogin /// 如果新fd已经打开,则会先关闭新fd. 511ab5c8ca4Slogin /// 512ab5c8ca4Slogin /// ## 参数 513ab5c8ca4Slogin /// 514ab5c8ca4Slogin /// - `oldfd`:旧文件描述符 515ab5c8ca4Slogin /// - `newfd`:新文件描述符 516ab5c8ca4Slogin /// 517ab5c8ca4Slogin /// ## 返回值 518ab5c8ca4Slogin /// 519ab5c8ca4Slogin /// - 成功:新文件描述符 520ab5c8ca4Slogin /// - 失败:错误码 521ab5c8ca4Slogin pub fn dup2(oldfd: i32, newfd: i32) -> Result<usize, SystemError> { 5221496ba7bSLoGin let binding = ProcessManager::current_pcb().fd_table(); 5231496ba7bSLoGin let mut fd_table_guard = binding.write(); 5241496ba7bSLoGin return Self::do_dup2(oldfd, newfd, &mut fd_table_guard); 5251496ba7bSLoGin } 5261496ba7bSLoGin 5271496ba7bSLoGin fn do_dup2( 5281496ba7bSLoGin oldfd: i32, 5291496ba7bSLoGin newfd: i32, 5301496ba7bSLoGin fd_table_guard: &mut RwLockWriteGuard<'_, FileDescriptorVec>, 5311496ba7bSLoGin ) -> Result<usize, SystemError> { 5322b771e32SGou Ngai // 确认oldfd, newid是否有效 5331496ba7bSLoGin if !(FileDescriptorVec::validate_fd(oldfd) && FileDescriptorVec::validate_fd(newfd)) { 5341496ba7bSLoGin return Err(SystemError::EBADF); 5351496ba7bSLoGin } 5361496ba7bSLoGin 5372b771e32SGou Ngai if oldfd == newfd { 5382b771e32SGou Ngai // 若oldfd与newfd相等 539ab5c8ca4Slogin return Ok(newfd as usize); 5402b771e32SGou Ngai } 5411496ba7bSLoGin let new_exists = fd_table_guard.get_file_by_fd(newfd).is_some(); 5421496ba7bSLoGin if new_exists { 5432b771e32SGou Ngai // close newfd 5441496ba7bSLoGin if let Err(_) = fd_table_guard.drop_fd(newfd) { 5452b771e32SGou Ngai // An I/O error occurred while attempting to close fildes2. 5462b771e32SGou Ngai return Err(SystemError::EIO); 5472b771e32SGou Ngai } 5482b771e32SGou Ngai } 5492b771e32SGou Ngai 5501496ba7bSLoGin let old_file = fd_table_guard 5511496ba7bSLoGin .get_file_by_fd(oldfd) 5521496ba7bSLoGin .ok_or(SystemError::EBADF)?; 5531496ba7bSLoGin let new_file = old_file 5541496ba7bSLoGin .lock_no_preempt() 5551496ba7bSLoGin .try_clone() 5561496ba7bSLoGin .ok_or(SystemError::EBADF)?; 5572b771e32SGou Ngai // 申请文件描述符,并把文件对象存入其中 5581496ba7bSLoGin let res = fd_table_guard 5591496ba7bSLoGin .alloc_fd(new_file, Some(newfd)) 560ab5c8ca4Slogin .map(|x| x as usize); 5612b771e32SGou Ngai return res; 5622b771e32SGou Ngai } 5636d81180bSLoGin 5646d81180bSLoGin /// # fcntl 5656d81180bSLoGin /// 5666d81180bSLoGin /// ## 参数 5676d81180bSLoGin /// 5686d81180bSLoGin /// - `fd`:文件描述符 5696d81180bSLoGin /// - `cmd`:命令 5706d81180bSLoGin /// - `arg`:参数 5716d81180bSLoGin pub fn fcntl(fd: i32, cmd: FcntlCommand, arg: i32) -> Result<usize, SystemError> { 5726d81180bSLoGin match cmd { 5736d81180bSLoGin FcntlCommand::DupFd => { 5746d81180bSLoGin if arg < 0 || arg as usize >= FileDescriptorVec::PROCESS_MAX_FD { 5756d81180bSLoGin return Err(SystemError::EBADF); 5766d81180bSLoGin } 5776d81180bSLoGin let arg = arg as usize; 5786d81180bSLoGin for i in arg..FileDescriptorVec::PROCESS_MAX_FD { 5791496ba7bSLoGin let binding = ProcessManager::current_pcb().fd_table(); 5801496ba7bSLoGin let mut fd_table_guard = binding.write(); 5811496ba7bSLoGin if fd_table_guard.get_file_by_fd(fd).is_none() { 5821496ba7bSLoGin return Self::do_dup2(fd, i as i32, &mut fd_table_guard); 5836d81180bSLoGin } 5846d81180bSLoGin } 5856d81180bSLoGin return Err(SystemError::EMFILE); 5866d81180bSLoGin } 5876d81180bSLoGin FcntlCommand::GetFd => { 5886d81180bSLoGin // Get file descriptor flags. 5891496ba7bSLoGin let binding = ProcessManager::current_pcb().fd_table(); 5901496ba7bSLoGin let fd_table_guard = binding.read(); 5911496ba7bSLoGin if let Some(file) = fd_table_guard.get_file_by_fd(fd) { 5921496ba7bSLoGin // drop guard 以避免无法调度的问题 5931496ba7bSLoGin drop(fd_table_guard); 5946d81180bSLoGin 5951496ba7bSLoGin if file.lock().close_on_exec() { 5966d81180bSLoGin return Ok(FD_CLOEXEC as usize); 5976d81180bSLoGin } 5986d81180bSLoGin } 5996d81180bSLoGin return Err(SystemError::EBADF); 6006d81180bSLoGin } 6016d81180bSLoGin FcntlCommand::SetFd => { 6026d81180bSLoGin // Set file descriptor flags. 6031496ba7bSLoGin let binding = ProcessManager::current_pcb().fd_table(); 6041496ba7bSLoGin let fd_table_guard = binding.write(); 6051496ba7bSLoGin 6061496ba7bSLoGin if let Some(file) = fd_table_guard.get_file_by_fd(fd) { 6071496ba7bSLoGin // drop guard 以避免无法调度的问题 6081496ba7bSLoGin drop(fd_table_guard); 6096d81180bSLoGin let arg = arg as u32; 6106d81180bSLoGin if arg & FD_CLOEXEC != 0 { 6111496ba7bSLoGin file.lock().set_close_on_exec(true); 6126d81180bSLoGin } else { 6131496ba7bSLoGin file.lock().set_close_on_exec(false); 6146d81180bSLoGin } 6156d81180bSLoGin return Ok(0); 6166d81180bSLoGin } 6176d81180bSLoGin return Err(SystemError::EBADF); 6186d81180bSLoGin } 6196d81180bSLoGin 6206d81180bSLoGin FcntlCommand::GetFlags => { 6216d81180bSLoGin // Get file status flags. 6221496ba7bSLoGin let binding = ProcessManager::current_pcb().fd_table(); 6231496ba7bSLoGin let fd_table_guard = binding.read(); 6241496ba7bSLoGin 6251496ba7bSLoGin if let Some(file) = fd_table_guard.get_file_by_fd(fd) { 6261496ba7bSLoGin // drop guard 以避免无法调度的问题 6271496ba7bSLoGin drop(fd_table_guard); 6281496ba7bSLoGin return Ok(file.lock_no_preempt().mode().bits() as usize); 6296d81180bSLoGin } 6301496ba7bSLoGin 6316d81180bSLoGin return Err(SystemError::EBADF); 6326d81180bSLoGin } 6336d81180bSLoGin FcntlCommand::SetFlags => { 6346d81180bSLoGin // Set file status flags. 6351496ba7bSLoGin let binding = ProcessManager::current_pcb().fd_table(); 6361496ba7bSLoGin let fd_table_guard = binding.write(); 6371496ba7bSLoGin 6381496ba7bSLoGin if let Some(file) = fd_table_guard.get_file_by_fd(fd) { 6396d81180bSLoGin let arg = arg as u32; 6406d81180bSLoGin let mode = FileMode::from_bits(arg).ok_or(SystemError::EINVAL)?; 6411496ba7bSLoGin // drop guard 以避免无法调度的问题 6421496ba7bSLoGin drop(fd_table_guard); 6431496ba7bSLoGin file.lock_no_preempt().set_mode(mode)?; 6446d81180bSLoGin return Ok(0); 6456d81180bSLoGin } 6461496ba7bSLoGin 6476d81180bSLoGin return Err(SystemError::EBADF); 6486d81180bSLoGin } 6496d81180bSLoGin _ => { 6506d81180bSLoGin // TODO: unimplemented 6516d81180bSLoGin // 未实现的命令,返回0,不报错。 6526d81180bSLoGin 6536d81180bSLoGin // kwarn!("fcntl: unimplemented command: {:?}, defaults to 0.", cmd); 6546d81180bSLoGin return Ok(0); 6556d81180bSLoGin } 6566d81180bSLoGin } 6576d81180bSLoGin } 6586d81180bSLoGin 6596d81180bSLoGin /// # ftruncate 6606d81180bSLoGin /// 6616d81180bSLoGin /// ## 描述 6626d81180bSLoGin /// 6636d81180bSLoGin /// 改变文件大小. 6646d81180bSLoGin /// 如果文件大小大于原来的大小,那么文件的内容将会被扩展到指定的大小,新的空间将会用0填充. 6656d81180bSLoGin /// 如果文件大小小于原来的大小,那么文件的内容将会被截断到指定的大小. 6666d81180bSLoGin /// 6676d81180bSLoGin /// ## 参数 6686d81180bSLoGin /// 6696d81180bSLoGin /// - `fd`:文件描述符 6706d81180bSLoGin /// - `len`:文件大小 6716d81180bSLoGin /// 6726d81180bSLoGin /// ## 返回值 6736d81180bSLoGin /// 6746d81180bSLoGin /// 如果成功,返回0,否则返回错误码. 6756d81180bSLoGin pub fn ftruncate(fd: i32, len: usize) -> Result<usize, SystemError> { 6761496ba7bSLoGin let binding = ProcessManager::current_pcb().fd_table(); 6771496ba7bSLoGin let fd_table_guard = binding.read(); 6781496ba7bSLoGin 6791496ba7bSLoGin if let Some(file) = fd_table_guard.get_file_by_fd(fd) { 6801496ba7bSLoGin // drop guard 以避免无法调度的问题 6811496ba7bSLoGin drop(fd_table_guard); 6821496ba7bSLoGin let r = file.lock_no_preempt().ftruncate(len).map(|_| 0); 6836d81180bSLoGin return r; 6846d81180bSLoGin } 6851496ba7bSLoGin 6866d81180bSLoGin return Err(SystemError::EBADF); 6876d81180bSLoGin } 6881496ba7bSLoGin 68967b48188Shoumkh fn do_fstat(fd: i32) -> Result<PosixKstat, SystemError> { 6901496ba7bSLoGin let binding = ProcessManager::current_pcb().fd_table(); 6911496ba7bSLoGin let fd_table_guard = binding.read(); 6921496ba7bSLoGin let file = fd_table_guard 6931496ba7bSLoGin .get_file_by_fd(fd) 6941496ba7bSLoGin .ok_or(SystemError::EBADF)?; 6951496ba7bSLoGin // drop guard 以避免无法调度的问题 6961496ba7bSLoGin drop(fd_table_guard); 6971496ba7bSLoGin 69867b48188Shoumkh let mut kstat = PosixKstat::new(); 69967b48188Shoumkh // 获取文件信息 7001496ba7bSLoGin let metadata = file.lock().metadata()?; 70167b48188Shoumkh kstat.size = metadata.size as i64; 70267b48188Shoumkh kstat.dev_id = metadata.dev_id as u64; 7036b4e7a29SLoGin kstat.inode = metadata.inode_id.into() as u64; 70467b48188Shoumkh kstat.blcok_size = metadata.blk_size as i64; 70567b48188Shoumkh kstat.blocks = metadata.blocks as u64; 70667b48188Shoumkh 70767b48188Shoumkh kstat.atime.tv_sec = metadata.atime.tv_sec; 70867b48188Shoumkh kstat.atime.tv_nsec = metadata.atime.tv_nsec; 70967b48188Shoumkh kstat.mtime.tv_sec = metadata.mtime.tv_sec; 71067b48188Shoumkh kstat.mtime.tv_nsec = metadata.mtime.tv_nsec; 71167b48188Shoumkh kstat.ctime.tv_sec = metadata.ctime.tv_sec; 71267b48188Shoumkh kstat.ctime.tv_nsec = metadata.ctime.tv_nsec; 71367b48188Shoumkh 71467b48188Shoumkh kstat.nlink = metadata.nlinks as u64; 71567b48188Shoumkh kstat.uid = metadata.uid as i32; 71667b48188Shoumkh kstat.gid = metadata.gid as i32; 71767b48188Shoumkh kstat.rdev = metadata.raw_dev as i64; 7186b4e7a29SLoGin kstat.mode = metadata.mode; 7191496ba7bSLoGin match file.lock().file_type() { 7207eda31b2SLoGin FileType::File => kstat.mode.insert(ModeType::S_IFREG), 72167b48188Shoumkh FileType::Dir => kstat.mode.insert(ModeType::S_IFDIR), 72267b48188Shoumkh FileType::BlockDevice => kstat.mode.insert(ModeType::S_IFBLK), 72367b48188Shoumkh FileType::CharDevice => kstat.mode.insert(ModeType::S_IFCHR), 72467b48188Shoumkh FileType::SymLink => kstat.mode.insert(ModeType::S_IFLNK), 72567b48188Shoumkh FileType::Socket => kstat.mode.insert(ModeType::S_IFSOCK), 72667b48188Shoumkh FileType::Pipe => kstat.mode.insert(ModeType::S_IFIFO), 72740314b30SXiaoye Zheng FileType::KvmDevice => kstat.mode.insert(ModeType::S_IFCHR), 72867b48188Shoumkh } 72967b48188Shoumkh 73067b48188Shoumkh return Ok(kstat); 73167b48188Shoumkh } 7321496ba7bSLoGin 733971462beSGnoCiYeH fn do_stat(path: &str) -> Result<PosixKstat, SystemError> { 734971462beSGnoCiYeH let fd = Self::open(path, FileMode::O_RDONLY)?; 735971462beSGnoCiYeH let ret = Self::do_fstat(fd as i32); 736971462beSGnoCiYeH Self::close(fd)?; 737971462beSGnoCiYeH ret 738971462beSGnoCiYeH } 739971462beSGnoCiYeH 74067b48188Shoumkh pub fn fstat(fd: i32, usr_kstat: *mut PosixKstat) -> Result<usize, SystemError> { 7411496ba7bSLoGin let kstat = Self::do_fstat(fd)?; 74267b48188Shoumkh if usr_kstat.is_null() { 74367b48188Shoumkh return Err(SystemError::EFAULT); 74467b48188Shoumkh } 74567b48188Shoumkh unsafe { 74667b48188Shoumkh *usr_kstat = kstat; 74767b48188Shoumkh } 74867b48188Shoumkh return Ok(0); 74967b48188Shoumkh } 7502dbef785SGnoCiYeH 751971462beSGnoCiYeH pub fn stat(path: &str, user_kstat: *mut PosixKstat) -> Result<usize, SystemError> { 752971462beSGnoCiYeH let fd = Self::open(path, FileMode::O_RDONLY)?; 753971462beSGnoCiYeH Self::fstat(fd as i32, user_kstat).map_err(|e| { 754971462beSGnoCiYeH Self::close(fd).ok(); 755971462beSGnoCiYeH e 756971462beSGnoCiYeH }) 757971462beSGnoCiYeH } 758971462beSGnoCiYeH 7592dbef785SGnoCiYeH pub fn mknod( 7602dbef785SGnoCiYeH path_ptr: *const i8, 7612dbef785SGnoCiYeH mode: ModeType, 7622dbef785SGnoCiYeH dev_t: DeviceNumber, 7632dbef785SGnoCiYeH ) -> Result<usize, SystemError> { 7642dbef785SGnoCiYeH // 安全检验 7652dbef785SGnoCiYeH let len = unsafe { CStr::from_ptr(path_ptr).to_bytes().len() }; 7662dbef785SGnoCiYeH let user_buffer = UserBufferReader::new(path_ptr, len, true)?; 7672dbef785SGnoCiYeH let buf = user_buffer.read_from_user::<u8>(0)?; 7682dbef785SGnoCiYeH let path = core::str::from_utf8(buf).map_err(|_| SystemError::EINVAL)?; 7692dbef785SGnoCiYeH 7702dbef785SGnoCiYeH // 文件名过长 7712dbef785SGnoCiYeH if path.len() > MAX_PATHLEN as usize { 7722dbef785SGnoCiYeH return Err(SystemError::ENAMETOOLONG); 7732dbef785SGnoCiYeH } 7742dbef785SGnoCiYeH 775a03c4f9dSLoGin let inode: Result<Arc<dyn IndexNode>, SystemError> = 776a03c4f9dSLoGin ROOT_INODE().lookup_follow_symlink(path, VFS_MAX_FOLLOW_SYMLINK_TIMES); 7772dbef785SGnoCiYeH 7782dbef785SGnoCiYeH if inode.is_ok() { 7792dbef785SGnoCiYeH return Err(SystemError::EEXIST); 7802dbef785SGnoCiYeH } 7812dbef785SGnoCiYeH 7822dbef785SGnoCiYeH let (filename, parent_path) = rsplit_path(path); 7832dbef785SGnoCiYeH 7842dbef785SGnoCiYeH // 查找父目录 785a03c4f9dSLoGin let parent_inode: Arc<dyn IndexNode> = ROOT_INODE() 786a03c4f9dSLoGin .lookup_follow_symlink(parent_path.unwrap_or("/"), VFS_MAX_FOLLOW_SYMLINK_TIMES)?; 7872dbef785SGnoCiYeH // 创建nod 7882dbef785SGnoCiYeH parent_inode.mknod(filename, mode, dev_t)?; 7892dbef785SGnoCiYeH 7902dbef785SGnoCiYeH return Ok(0); 7912dbef785SGnoCiYeH } 792971462beSGnoCiYeH 793971462beSGnoCiYeH pub fn writev(fd: i32, iov: usize, count: usize) -> Result<usize, SystemError> { 794971462beSGnoCiYeH // IoVecs会进行用户态检验 795971462beSGnoCiYeH let iovecs = unsafe { IoVecs::from_user(iov as *const IoVec, count, false) }?; 796971462beSGnoCiYeH 797971462beSGnoCiYeH let data = iovecs.gather(); 798971462beSGnoCiYeH 799971462beSGnoCiYeH Self::write(fd, &data) 800971462beSGnoCiYeH } 801709498caSLoGin 802709498caSLoGin pub fn readlink_at( 803709498caSLoGin dirfd: i32, 804709498caSLoGin path: *const u8, 805709498caSLoGin user_buf: *mut u8, 806709498caSLoGin buf_size: usize, 807709498caSLoGin ) -> Result<usize, SystemError> { 808*9b0abe6dSLoGin let path = check_and_clone_cstr(path, Some(MAX_PATHLEN))?; 809709498caSLoGin let mut user_buf = UserBufferWriter::new(user_buf, buf_size, true)?; 810709498caSLoGin 811709498caSLoGin if path.len() == 0 { 812709498caSLoGin return Err(SystemError::EINVAL); 81367b48188Shoumkh } 814709498caSLoGin 815*9b0abe6dSLoGin let (inode, path) = user_path_at(&ProcessManager::current_pcb(), dirfd, path)?; 816709498caSLoGin 817709498caSLoGin let inode = inode.lookup(path.as_str())?; 818709498caSLoGin if inode.metadata()?.file_type != FileType::SymLink { 819709498caSLoGin return Err(SystemError::EINVAL); 820709498caSLoGin } 821709498caSLoGin 822709498caSLoGin let ubuf = user_buf.buffer::<u8>(0).unwrap(); 823709498caSLoGin 824709498caSLoGin let mut file = File::new(inode, FileMode::O_RDONLY)?; 825709498caSLoGin 826709498caSLoGin let len = file.read(buf_size, ubuf)?; 827709498caSLoGin 828709498caSLoGin return Ok(len); 829709498caSLoGin } 830709498caSLoGin 831709498caSLoGin pub fn readlink( 832709498caSLoGin path: *const u8, 833709498caSLoGin user_buf: *mut u8, 834709498caSLoGin buf_size: usize, 835709498caSLoGin ) -> Result<usize, SystemError> { 836*9b0abe6dSLoGin return Self::readlink_at(AtFlags::AT_FDCWD.bits(), path, user_buf, buf_size); 837*9b0abe6dSLoGin } 838*9b0abe6dSLoGin 839*9b0abe6dSLoGin pub fn access(pathname: *const u8, mode: u32) -> Result<usize, SystemError> { 840*9b0abe6dSLoGin return do_faccessat( 841*9b0abe6dSLoGin AtFlags::AT_FDCWD.bits(), 842*9b0abe6dSLoGin pathname, 843*9b0abe6dSLoGin ModeType::from_bits_truncate(mode), 844*9b0abe6dSLoGin 0, 845*9b0abe6dSLoGin ); 846*9b0abe6dSLoGin } 847*9b0abe6dSLoGin 848*9b0abe6dSLoGin pub fn faccessat2( 849*9b0abe6dSLoGin dirfd: i32, 850*9b0abe6dSLoGin pathname: *const u8, 851*9b0abe6dSLoGin mode: u32, 852*9b0abe6dSLoGin flags: u32, 853*9b0abe6dSLoGin ) -> Result<usize, SystemError> { 854*9b0abe6dSLoGin return do_faccessat(dirfd, pathname, ModeType::from_bits_truncate(mode), flags); 855709498caSLoGin } 856709498caSLoGin } 857709498caSLoGin 858cde5492fSlogin #[repr(C)] 859cde5492fSlogin #[derive(Debug, Clone, Copy)] 860cde5492fSlogin pub struct IoVec { 861cde5492fSlogin /// 缓冲区的起始地址 862cde5492fSlogin pub iov_base: *mut u8, 863cde5492fSlogin /// 缓冲区的长度 864cde5492fSlogin pub iov_len: usize, 865cde5492fSlogin } 866cde5492fSlogin 867cde5492fSlogin /// 用于存储多个来自用户空间的IoVec 868cde5492fSlogin /// 869cde5492fSlogin /// 由于目前内核中的文件系统还不支持分散读写,所以暂时只支持将用户空间的IoVec聚合成一个缓冲区,然后进行操作。 870cde5492fSlogin /// TODO:支持分散读写 871cde5492fSlogin #[derive(Debug)] 872cde5492fSlogin pub struct IoVecs(Vec<&'static mut [u8]>); 873cde5492fSlogin 874cde5492fSlogin impl IoVecs { 875cde5492fSlogin /// 从用户空间的IoVec中构造IoVecs 876cde5492fSlogin /// 877cde5492fSlogin /// @param iov 用户空间的IoVec 878cde5492fSlogin /// @param iovcnt 用户空间的IoVec的数量 879cde5492fSlogin /// @param readv 是否为readv系统调用 880cde5492fSlogin /// 881cde5492fSlogin /// @return 构造成功返回IoVecs,否则返回错误码 882cde5492fSlogin pub unsafe fn from_user( 883cde5492fSlogin iov: *const IoVec, 884cde5492fSlogin iovcnt: usize, 885cde5492fSlogin _readv: bool, 886cde5492fSlogin ) -> Result<Self, SystemError> { 887cde5492fSlogin // 检查iov指针所在空间是否合法 888cde5492fSlogin if !verify_area( 889cde5492fSlogin iov as usize as u64, 890cde5492fSlogin (iovcnt * core::mem::size_of::<IoVec>()) as u64, 891cde5492fSlogin ) { 892cde5492fSlogin return Err(SystemError::EFAULT); 893cde5492fSlogin } 894cde5492fSlogin 895cde5492fSlogin // 将用户空间的IoVec转换为引用(注意:这里的引用是静态的,因为用户空间的IoVec不会被释放) 896cde5492fSlogin let iovs: &[IoVec] = core::slice::from_raw_parts(iov, iovcnt); 897cde5492fSlogin 898cde5492fSlogin let mut slices: Vec<&mut [u8]> = vec![]; 899cde5492fSlogin slices.reserve(iovs.len()); 900cde5492fSlogin 901cde5492fSlogin for iov in iovs.iter() { 902cde5492fSlogin if iov.iov_len == 0 { 903cde5492fSlogin continue; 904cde5492fSlogin } 905cde5492fSlogin 906cde5492fSlogin if !verify_area(iov.iov_base as usize as u64, iov.iov_len as u64) { 907cde5492fSlogin return Err(SystemError::EFAULT); 908cde5492fSlogin } 909cde5492fSlogin 910cde5492fSlogin slices.push(core::slice::from_raw_parts_mut(iov.iov_base, iov.iov_len)); 911cde5492fSlogin } 912cde5492fSlogin 913cde5492fSlogin return Ok(Self(slices)); 914cde5492fSlogin } 915cde5492fSlogin 916cde5492fSlogin /// @brief 将IoVecs中的数据聚合到一个缓冲区中 917cde5492fSlogin /// 918cde5492fSlogin /// @return 返回聚合后的缓冲区 919cde5492fSlogin pub fn gather(&self) -> Vec<u8> { 920cde5492fSlogin let mut buf = Vec::new(); 921cde5492fSlogin for slice in self.0.iter() { 922cde5492fSlogin buf.extend_from_slice(slice); 923cde5492fSlogin } 924cde5492fSlogin return buf; 925cde5492fSlogin } 926cde5492fSlogin 927cde5492fSlogin /// @brief 将给定的数据分散写入到IoVecs中 928cde5492fSlogin pub fn scatter(&mut self, data: &[u8]) { 929cde5492fSlogin let mut data: &[u8] = data; 930cde5492fSlogin for slice in self.0.iter_mut() { 931cde5492fSlogin let len = core::cmp::min(slice.len(), data.len()); 932cde5492fSlogin if len == 0 { 933cde5492fSlogin continue; 934cde5492fSlogin } 935cde5492fSlogin 936cde5492fSlogin slice[..len].copy_from_slice(&data[..len]); 937cde5492fSlogin data = &data[len..]; 938cde5492fSlogin } 939cde5492fSlogin } 940cde5492fSlogin 941cde5492fSlogin /// @brief 创建与IoVecs等长的缓冲区 942cde5492fSlogin /// 943cde5492fSlogin /// @param set_len 是否设置返回的Vec的len。 944cde5492fSlogin /// 如果为true,则返回的Vec的len为所有IoVec的长度之和; 945cde5492fSlogin /// 否则返回的Vec的len为0,capacity为所有IoVec的长度之和. 946cde5492fSlogin /// 947cde5492fSlogin /// @return 返回创建的缓冲区 948cde5492fSlogin pub fn new_buf(&self, set_len: bool) -> Vec<u8> { 949cde5492fSlogin let total_len: usize = self.0.iter().map(|slice| slice.len()).sum(); 950cde5492fSlogin let mut buf: Vec<u8> = Vec::with_capacity(total_len); 951cde5492fSlogin 952cde5492fSlogin if set_len { 9537ae679ddSLoGin buf.resize(total_len, 0); 954cde5492fSlogin } 955cde5492fSlogin return buf; 956cde5492fSlogin } 957cde5492fSlogin } 958