1 use core::{ 2 ffi::{c_char, c_int, c_void, CStr}, 3 sync::atomic::{AtomicBool, Ordering}, 4 }; 5 6 use crate::{ 7 arch::syscall::{ 8 SYS_ACCESS, SYS_CHMOD, SYS_CLOCK_GETTIME, SYS_FACCESSAT, SYS_FACCESSAT2, SYS_FCHMOD, 9 SYS_FCHMODAT, SYS_LSTAT, SYS_PRLIMIT64, SYS_READV, SYS_SYSINFO, SYS_UMASK, SYS_UNLINK, 10 }, 11 libs::{futex::constant::FutexFlag, rand::GRandFlags}, 12 process::{ 13 fork::KernelCloneArgs, 14 resource::{RLimit64, RUsage}, 15 }, 16 }; 17 18 use num_traits::{FromPrimitive, ToPrimitive}; 19 20 use crate::{ 21 arch::{cpu::cpu_reset, interrupt::TrapFrame, MMArch}, 22 driver::base::{block::SeekFrom, device::DeviceNumber}, 23 filesystem::vfs::{ 24 fcntl::FcntlCommand, 25 file::FileMode, 26 syscall::{ModeType, PosixKstat, SEEK_CUR, SEEK_END, SEEK_MAX, SEEK_SET}, 27 MAX_PATHLEN, 28 }, 29 include::bindings::bindings::{PAGE_2M_SIZE, PAGE_4K_SIZE}, 30 kinfo, 31 libs::align::page_align_up, 32 mm::{verify_area, MemoryManagementArch, VirtAddr}, 33 net::syscall::SockAddr, 34 process::{fork::CloneFlags, Pid}, 35 time::{ 36 syscall::{PosixTimeZone, PosixTimeval}, 37 TimeSpec, 38 }, 39 }; 40 41 use self::{ 42 misc::SysInfo, 43 user_access::{UserBufferReader, UserBufferWriter}, 44 }; 45 46 pub mod misc; 47 pub mod user_access; 48 49 #[repr(i32)] 50 #[derive(Debug, FromPrimitive, ToPrimitive, PartialEq, Eq, Clone)] 51 #[allow(dead_code, non_camel_case_types)] 52 pub enum SystemError { 53 /// 操作不被允许 Operation not permitted. 54 EPERM = 1, 55 /// 没有指定的文件或目录 No such file or directory. 56 ENOENT = 2, 57 /// 没有这样的进程 No such process. 58 ESRCH = 3, 59 /// 被中断的函数 Interrupted function. 60 EINTR = 4, 61 /// I/O错误 I/O error. 62 EIO = 5, 63 /// 没有这样的设备或地址 No such device or address. 64 ENXIO = 6, 65 /// 参数列表过长，或者在输出buffer中缺少空间 或者参数比系统内建的最大值要大 Argument list too long. 66 E2BIG = 7, 67 /// 可执行文件格式错误 Executable file format error 68 ENOEXEC = 8, 69 /// 错误的文件描述符 Bad file descriptor. 70 EBADF = 9, 71 /// 没有子进程 No child processes. 72 ECHILD = 10, 73 /// 资源不可用，请重试。 Resource unavailable, try again.(may be the same value as [EWOULDBLOCK]) 74 /// 75 /// 操作将被禁止 Operation would block.(may be the same value as [EAGAIN]). 76 EAGAIN_OR_EWOULDBLOCK = 11, 77 /// 没有足够的空间 Not enough space. 78 ENOMEM = 12, 79 /// 访问被拒绝 Permission denied 80 EACCES = 13, 81 /// 错误的地址 Bad address 82 EFAULT = 14, 83 /// 需要块设备 Block device required 84 ENOTBLK = 15, 85 /// 设备或资源忙 Device or resource busy. 86 EBUSY = 16, 87 /// 文件已存在 File exists. 88 EEXIST = 17, 89 /// 跨设备连接 Cross-device link. 90 EXDEV = 18, 91 /// 没有指定的设备 No such device. 92 ENODEV = 19, 93 /// 不是目录 Not a directory. 94 ENOTDIR = 20, 95 /// 是一个目录 Is a directory 96 EISDIR = 21, 97 /// 不可用的参数 Invalid argument. 98 EINVAL = 22, 99 /// 系统中打开的文件过多 Too many files open in system. 100 ENFILE = 23, 101 /// 文件描述符的值过大 File descriptor value too large. 102 EMFILE = 24, 103 /// 不正确的I/O控制操作 Inappropriate I/O control operation. 104 ENOTTY = 25, 105 /// 文本文件忙 Text file busy. 106 ETXTBSY = 26, 107 /// 文件太大 File too large. 108 EFBIG = 27, 109 /// 设备上没有空间 No space left on device. 110 ENOSPC = 28, 111 /// 错误的寻道.当前文件是pipe，不允许seek请求 Invalid seek. 112 ESPIPE = 29, 113 /// 只读的文件系统 Read-only file system. 114 EROFS = 30, 115 /// 链接数过多 Too many links. 116 EMLINK = 31, 117 /// 断开的管道 Broken pipe. 118 EPIPE = 32, 119 /// 数学参数超出作用域 Mathematics argument out of domain of function. 120 EDOM = 33, 121 /// 结果过大 Result too large. 122 ERANGE = 34, 123 /// 资源死锁将要发生 Resource deadlock would occur. 124 EDEADLK = 35, 125 /// 文件名过长 Filename too long. 126 ENAMETOOLONG = 36, 127 /// 没有可用的锁 No locks available. 128 ENOLCK = 37, 129 /// 功能不支持 Function not supported. 130 ENOSYS = 38, 131 /// 目录非空 Directory not empty. 132 ENOTEMPTY = 39, 133 /// 符号链接级别过多 Too many levels of symbolic links. 134 ELOOP = 40, 135 /// 没有期待类型的消息 No message of the desired type. 136 ENOMSG = 41, 137 /// 标志符被移除 Identifier removed. 138 EIDRM = 42, 139 /// 通道号超出范围 Channel number out of range 140 ECHRNG = 43, 141 /// 二级不同步 Level 2 not synchronized 142 EL2NSYNC = 44, 143 /// 三级暂停 Level 3 halted 144 EL3HLT = 45, 145 /// 三级重置 Level 3 reset 146 EL3RST = 46, 147 /// 链接号超出范围 Link number out of range 148 ELNRNG = 47, 149 /// 未连接协议驱动程序 Protocol driver not attached 150 EUNATCH = 48, 151 /// 没有可用的CSI结构 No CSI structure available 152 ENOCSI = 49, 153 /// 二级暂停 Level 2 halted 154 EL2HLT = 50, 155 /// 无效交换 Invalid exchange 156 EBADE = 51, 157 /// 无效的请求描述符 Invalid request descriptor 158 EBADR = 52, 159 /// 交换满 Exchange full 160 EXFULL = 53, 161 /// 无阳极 No anode 162 ENOANO = 54, 163 /// 请求码无效 Invalid request code 164 EBADRQC = 55, 165 /// 无效插槽 Invalid slot 166 EBADSLT = 56, 167 /// 资源死锁 Resource deadlock would occur 168 EDEADLOCK = 57, 169 /// 错误的字体文件格式 Bad font file format 170 EBFONT = 58, 171 /// 不是STREAM Not a STREAM 172 ENOSTR = 59, 173 /// 队列头没有可读取的消息 No message is available on the STREAM head read queue. 174 ENODATA = 60, 175 /// 流式ioctl()超时 Stream ioctl() timeout 176 ETIME = 61, 177 /// 没有STREAM资源 No STREAM resources. 178 ENOSR = 62, 179 /// 机器不在网络上 Machine is not on the network 180 ENONET = 63, 181 /// 未安装软件包 Package not installed 182 ENOPKG = 64, 183 /// 远程对象 Object is remote 184 EREMOTE = 65, 185 /// 保留 Reserved. 186 ENOLINK = 66, 187 /// 外设错误 Advertise error. 188 EADV = 67, 189 /// 安装错误 Srmount error 190 ESRMNT = 68, 191 /// 发送时发生通信错误 Communication error on send 192 ECOMM = 69, 193 /// 协议错误 Protocol error. 194 EPROTO = 70, 195 /// 保留使用 Reserved. 196 EMULTIHOP = 71, 197 /// RFS特定错误 RFS specific error 198 EDOTDOT = 72, 199 /// 错误的消息 Bad message. 200 EBADMSG = 73, 201 /// 数值过大，产生溢出 Value too large to be stored in data type. 202 EOVERFLOW = 74, 203 /// 名称在网络上不是唯一的 Name not unique on network 204 ENOTUNIQ = 75, 205 /// 处于不良状态的文件描述符 File descriptor in bad state 206 EBADFD = 76, 207 /// 远程地址已更改 Remote address changed 208 EREMCHG = 77, 209 /// 无法访问所需的共享库 Can not access a needed shared library 210 ELIBACC = 78, 211 /// 访问损坏的共享库 Accessing a corrupted shared library 212 ELIBBAD = 79, 213 /// a. out中的.lib部分已损坏 .lib section in a.out corrupted 214 ELIBSCN = 80, 215 /// 尝试链接太多共享库 Attempting to link in too many shared libraries 216 ELIBMAX = 81, 217 /// 无法直接执行共享库 Cannot exec a shared library directly 218 ELIBEXEC = 82, 219 /// 不合法的字符序列 Illegal byte sequence. 220 EILSEQ = 83, 221 /// 中断的系统调用应该重新启动 Interrupted system call should be restarted 222 ERESTART = 84, 223 /// 流管道错误 Streams pipe error 224 ESTRPIPE = 85, 225 /// 用户太多 Too many users 226 EUSERS = 86, 227 /// 不是一个套接字 Not a socket. 228 ENOTSOCK = 87, 229 /// 需要目标地址 Destination address required. 230 EDESTADDRREQ = 88, 231 /// 消息过大 Message too large. 232 EMSGSIZE = 89, 233 /// 对于套接字而言，错误的协议 Protocol wrong type for socket. 234 EPROTOTYPE = 90, 235 /// 协议不可用 Protocol not available. 236 ENOPROTOOPT = 91, 237 /// 协议不被支持 Protocol not supported. 238 EPROTONOSUPPORT = 92, 239 /// 不支持套接字类型 Socket type not supported 240 ESOCKTNOSUPPORT = 93, 241 /// 套接字不支持该操作 Operation not supported on socket (may be the same value as [ENOTSUP]). 242 /// 243 /// 不被支持 Not supported (may be the same value as [EOPNOTSUPP]). 244 EOPNOTSUPP_OR_ENOTSUP = 94, 245 /// 不支持协议系列 Protocol family not supported 246 EPFNOSUPPORT = 95, 247 /// 地址family不支持 Address family not supported. 248 EAFNOSUPPORT = 96, 249 /// 地址正在被使用 Address in use. 250 EADDRINUSE = 97, 251 /// 地址不可用 Address not available. 252 EADDRNOTAVAIL = 98, 253 /// 网络已关闭 Network is down. 254 ENETDOWN = 99, 255 /// 网络不可达 Network unreachable. 256 ENETUNREACH = 100, 257 /// 网络连接已断开 Connection aborted by network. 258 ENETRESET = 101, 259 /// 连接已断开 Connection aborted. 260 ECONNABORTED = 102, 261 /// 连接被重置 Connection reset. 262 ECONNRESET = 103, 263 /// 缓冲区空间不足 No buffer space available. 264 ENOBUFS = 104, 265 /// 套接字已连接 Socket is connected. 266 EISCONN = 105, 267 /// 套接字未连接 The socket is not connected. 268 ENOTCONN = 106, 269 /// 传输端点关闭后无法发送 Cannot send after transport endpoint shutdown 270 ESHUTDOWN = 107, 271 /// 引用太多：无法拼接 Too many references: cannot splice 272 ETOOMANYREFS = 108, 273 /// 连接超时 Connection timed out. 274 ETIMEDOUT = 109, 275 /// 连接被拒绝 Connection refused. 276 ECONNREFUSED = 110, 277 /// 主机已关闭 Host is down 278 EHOSTDOWN = 111, 279 /// 主机不可达 Host is unreachable. 280 EHOSTUNREACH = 112, 281 /// 连接已经在处理 Connection already in progress. 282 EALREADY = 113, 283 /// 操作正在处理 Operation in progress. 284 EINPROGRESS = 114, 285 /// 保留 Reserved. 286 ESTALE = 115, 287 /// 结构需要清理 Structure needs cleaning 288 EUCLEAN = 116, 289 /// 不是XENIX命名类型文件 Not a XENIX named type file 290 ENOTNAM = 117, 291 /// 没有可用的XENIX信号量 No XENIX semaphores available 292 ENAVAIL = 118, 293 /// 是命名类型文件 Is a named type file 294 EISNAM = 119, 295 /// 远程I/O错误 Remote I/O error 296 EREMOTEIO = 120, 297 /// 保留使用 Reserved 298 EDQUOT = 121, 299 /// 没有找到媒介 No medium found 300 ENOMEDIUM = 122, 301 /// 介质类型错误 Wrong medium type 302 EMEDIUMTYPE = 123, 303 /// 操作被取消 Operation canceled. 304 ECANCELED = 124, 305 /// 所需的密钥不可用 Required key not available 306 ENOKEY = 125, 307 /// 密钥已过期 Key has expired 308 EKEYEXPIRED = 126, 309 /// 密钥已被撤销 Key has been revoked 310 EKEYREVOKED = 127, 311 /// 密钥被服务拒绝 Key has been revoked 312 EKEYREJECTED = 128, 313 /// 之前的拥有者挂了 Previous owner died. 314 EOWNERDEAD = 129, 315 /// 状态不可恢复 State not recoverable. 316 ENOTRECOVERABLE = 130, 317 // VMX on 虚拟化开启指令出错 318 EVMXONFailed = 131, 319 // VMX off 虚拟化关闭指令出错 320 EVMXOFFFailed = 132, 321 // VMX VMWRITE 写入虚拟化VMCS内存出错 322 EVMWRITEFailed = 133, 323 EVMREADFailed = 134, 324 EVMPRTLDFailed = 135, 325 EVMLAUNCHFailed = 136, 326 KVM_HVA_ERR_BAD = 137, 327 328 // === 以下错误码不应该被用户态程序使用 === 329 ERESTARTSYS = 512, 330 } 331 332 impl SystemError { 333 /// @brief 把posix错误码转换为系统错误枚举类型。 334 pub fn from_posix_errno(errno: i32) -> Option<SystemError> { 335 // posix 错误码是小于0的 336 if errno >= 0 { 337 return None; 338 } 339 return <Self as FromPrimitive>::from_i32(-errno); 340 } 341 342 /// @brief 把系统错误枚举类型转换为负数posix错误码。 343 pub fn to_posix_errno(&self) -> i32 { 344 return -<Self as ToPrimitive>::to_i32(self).unwrap(); 345 } 346 } 347 348 // 定义系统调用号 349 pub const SYS_READ: usize = 0; 350 pub const SYS_WRITE: usize = 1; 351 pub const SYS_OPEN: usize = 2; 352 pub const SYS_CLOSE: usize = 3; 353 pub const SYS_STAT: usize = 4; 354 pub const SYS_FSTAT: usize = 5; 355 356 pub const SYS_POLL: usize = 7; 357 pub const SYS_LSEEK: usize = 8; 358 pub const SYS_MMAP: usize = 9; 359 pub const SYS_MPROTECT: usize = 10; 360 361 pub const SYS_MUNMAP: usize = 11; 362 pub const SYS_BRK: usize = 12; 363 pub const SYS_SIGACTION: usize = 13; 364 pub const SYS_RT_SIGPROCMASK: usize = 14; 365 pub const SYS_RT_SIGRETURN: usize = 15; 366 367 pub const SYS_IOCTL: usize = 16; 368 369 pub const SYS_WRITEV: usize = 20; 370 371 pub const SYS_MADVISE: usize = 28; 372 373 pub const SYS_DUP: usize = 32; 374 pub const SYS_DUP2: usize = 33; 375 376 pub const SYS_NANOSLEEP: usize = 35; 377 378 pub const SYS_GETPID: usize = 39; 379 380 pub const SYS_SOCKET: usize = 41; 381 pub const SYS_CONNECT: usize = 42; 382 pub const SYS_ACCEPT: usize = 43; 383 pub const SYS_SENDTO: usize = 44; 384 pub const SYS_RECVFROM: usize = 45; 385 386 pub const SYS_RECVMSG: usize = 47; 387 pub const SYS_SHUTDOWN: usize = 48; 388 pub const SYS_BIND: usize = 49; 389 pub const SYS_LISTEN: usize = 50; 390 pub const SYS_GETSOCKNAME: usize = 51; 391 pub const SYS_GETPEERNAME: usize = 52; 392 pub const SYS_SOCKET_PAIR: usize = 53; 393 pub const SYS_SETSOCKOPT: usize = 54; 394 pub const SYS_GETSOCKOPT: usize = 55; 395 396 pub const SYS_CLONE: usize = 56; 397 pub const SYS_FORK: usize = 57; 398 pub const SYS_VFORK: usize = 58; 399 pub const SYS_EXECVE: usize = 59; 400 pub const SYS_EXIT: usize = 60; 401 pub const SYS_WAIT4: usize = 61; 402 pub const SYS_KILL: usize = 62; 403 404 pub const SYS_FCNTL: usize = 72; 405 406 pub const SYS_FTRUNCATE: usize = 77; 407 pub const SYS_GET_DENTS: usize = 78; 408 409 pub const SYS_GETCWD: usize = 79; 410 411 pub const SYS_CHDIR: usize = 80; 412 413 pub const SYS_MKDIR: usize = 83; 414 415 pub const SYS_READLINK: usize = 89; 416 417 pub const SYS_GETTIMEOFDAY: usize = 96; 418 pub const SYS_GETRUSAGE: usize = 98; 419 420 pub const SYS_GETUID: usize = 102; 421 pub const SYS_SYSLOG: usize = 103; 422 pub const SYS_GETGID: usize = 104; 423 pub const SYS_SETUID: usize = 105; 424 425 pub const SYS_SETGID: usize = 106; 426 pub const SYS_GETEUID: usize = 107; 427 pub const SYS_GETEGID: usize = 108; 428 429 pub const SYS_GETPPID: usize = 110; 430 pub const SYS_GETPGID: usize = 121; 431 432 pub const SYS_SIGALTSTACK: usize = 131; 433 pub const SYS_MKNOD: usize = 133; 434 435 pub const SYS_ARCH_PRCTL: usize = 158; 436 437 pub const SYS_REBOOT: usize = 169; 438 439 pub const SYS_GETTID: usize = 186; 440 441 #[allow(dead_code)] 442 pub const SYS_TKILL: usize = 200; 443 444 #[allow(dead_code)] 445 pub const SYS_FUTEX: usize = 202; 446 447 pub const SYS_GET_DENTS_64: usize = 217; 448 #[allow(dead_code)] 449 pub const SYS_SET_TID_ADDR: usize = 218; 450 451 pub const SYS_EXIT_GROUP: usize = 231; 452 453 pub const SYS_UNLINK_AT: usize = 263; 454 455 pub const SYS_READLINK_AT: usize = 267; 456 457 pub const SYS_ACCEPT4: usize = 288; 458 459 pub const SYS_PIPE: usize = 293; 460 461 #[allow(dead_code)] 462 pub const SYS_GET_RANDOM: usize = 318; 463 464 // 与linux不一致的调用，在linux基础上累加 465 pub const SYS_PUT_STRING: usize = 100000; 466 pub const SYS_SBRK: usize = 100001; 467 /// todo: 该系统调用与Linux不一致，将来需要删除该系统调用！！！ 删的时候记得改C版本的libc 468 pub const SYS_CLOCK: usize = 100002; 469 pub const SYS_SCHED: usize = 100003; 470 471 #[derive(Debug)] 472 pub struct Syscall; 473 474 extern "C" { 475 fn do_put_string(s: *const u8, front_color: u32, back_color: u32) -> usize; 476 } 477 478 #[no_mangle] 479 pub extern "C" fn syscall_init() -> i32 { 480 kinfo!("Initializing syscall..."); 481 Syscall::init().expect("syscall init failed"); 482 kinfo!("Syscall init successfully!"); 483 return 0; 484 } 485 486 impl Syscall { 487 /// 初始化系统调用 488 pub fn init() -> Result<(), SystemError> { 489 static INIT_FLAG: AtomicBool = AtomicBool::new(false); 490 let prev = INIT_FLAG.swap(true, Ordering::SeqCst); 491 if prev { 492 panic!("Cannot initialize syscall more than once!"); 493 } 494 return crate::arch::syscall::arch_syscall_init(); 495 } 496 /// @brief 系统调用分发器，用于分发系统调用。 497 /// 498 /// 这个函数内，需要根据系统调用号，调用对应的系统调用处理函数。 499 /// 并且，对于用户态传入的指针参数，需要在本函数内进行越界检查，防止访问到内核空间。 500 pub fn handle( 501 syscall_num: usize, 502 args: &[usize], 503 frame: &mut TrapFrame, 504 ) -> Result<usize, SystemError> { 505 let r = match syscall_num { 506 SYS_PUT_STRING => { 507 Self::put_string(args[0] as *const u8, args[1] as u32, args[2] as u32) 508 } 509 SYS_OPEN => { 510 let path: &CStr = unsafe { CStr::from_ptr(args[0] as *const c_char) }; 511 let path: Result<&str, core::str::Utf8Error> = path.to_str(); 512 let res = if path.is_err() { 513 Err(SystemError::EINVAL) 514 } else { 515 let path: &str = path.unwrap(); 516 517 let flags = args[1]; 518 let open_flags: FileMode = FileMode::from_bits_truncate(flags as u32); 519 Self::open(path, open_flags, true) 520 }; 521 res 522 } 523 SYS_CLOSE => { 524 let fd = args[0]; 525 526 let res = Self::close(fd); 527 528 res 529 } 530 SYS_READ => { 531 let fd = args[0] as i32; 532 let buf_vaddr = args[1]; 533 let len = args[2]; 534 let from_user = frame.from_user(); 535 let mut user_buffer_writer = 536 UserBufferWriter::new(buf_vaddr as *mut u8, len, from_user)?; 537 538 let user_buf = user_buffer_writer.buffer(0)?; 539 let res = Self::read(fd, user_buf); 540 res 541 } 542 SYS_WRITE => { 543 let fd = args[0] as i32; 544 let buf_vaddr = args[1]; 545 let len = args[2]; 546 let from_user = frame.from_user(); 547 let user_buffer_reader = 548 UserBufferReader::new(buf_vaddr as *const u8, len, from_user)?; 549 550 let user_buf = user_buffer_reader.read_from_user(0)?; 551 let res = Self::write(fd, user_buf); 552 res 553 } 554 555 SYS_LSEEK => { 556 let fd = args[0] as i32; 557 let offset = args[1] as i64; 558 let whence = args[2] as u32; 559 560 let w = match whence { 561 SEEK_SET => Ok(SeekFrom::SeekSet(offset)), 562 SEEK_CUR => Ok(SeekFrom::SeekCurrent(offset)), 563 SEEK_END => Ok(SeekFrom::SeekEnd(offset)), 564 SEEK_MAX => Ok(SeekFrom::SeekEnd(0)), 565 _ => Err(SystemError::EINVAL), 566 }?; 567 568 Self::lseek(fd, w) 569 } 570 SYS_IOCTL => { 571 let fd = args[0]; 572 let cmd = args[1]; 573 let data = args[2]; 574 Self::ioctl(fd, cmd as u32, data) 575 } 576 577 SYS_FORK => Self::fork(frame), 578 SYS_VFORK => Self::vfork(frame), 579 580 SYS_BRK => { 581 let new_brk = VirtAddr::new(args[0]); 582 Self::brk(new_brk).map(|vaddr| vaddr.data()) 583 } 584 585 SYS_SBRK => { 586 let increment = args[0] as isize; 587 Self::sbrk(increment).map(|vaddr: VirtAddr| vaddr.data()) 588 } 589 590 SYS_REBOOT => Self::reboot(), 591 592 SYS_CHDIR => { 593 // Closure for checking arguments 594 let chdir_check = |arg0: usize| { 595 if arg0 == 0 { 596 return Err(SystemError::EFAULT); 597 } 598 let path_ptr = arg0 as *const c_char; 599 let virt_addr = VirtAddr::new(path_ptr as usize); 600 // 权限校验 601 if path_ptr.is_null() 602 || (frame.from_user() 603 && verify_area(virt_addr, PAGE_2M_SIZE as usize).is_err()) 604 { 605 return Err(SystemError::EINVAL); 606 } 607 let dest_path: &CStr = unsafe { CStr::from_ptr(path_ptr) }; 608 let dest_path: &str = dest_path.to_str().map_err(|_| SystemError::EINVAL)?; 609 if dest_path.len() == 0 { 610 return Err(SystemError::EINVAL); 611 } else if dest_path.len() > MAX_PATHLEN as usize { 612 return Err(SystemError::ENAMETOOLONG); 613 } 614 615 return Ok(dest_path); 616 }; 617 618 let r = chdir_check(args[0])?; 619 Self::chdir(r) 620 } 621 622 SYS_GET_DENTS | SYS_GET_DENTS_64 => { 623 let fd = args[0] as i32; 624 625 let buf_vaddr = args[1]; 626 let len = args[2]; 627 let virt_addr: VirtAddr = VirtAddr::new(buf_vaddr); 628 // 判断缓冲区是否来自用户态，进行权限校验 629 let res = if frame.from_user() && verify_area(virt_addr, len as usize).is_err() { 630 // 来自用户态，而buffer在内核态，这样的操作不被允许 631 Err(SystemError::EPERM) 632 } else if buf_vaddr == 0 { 633 Err(SystemError::EFAULT) 634 } else { 635 let buf: &mut [u8] = unsafe { 636 core::slice::from_raw_parts_mut::<'static, u8>(buf_vaddr as *mut u8, len) 637 }; 638 Self::getdents(fd, buf) 639 }; 640 641 res 642 } 643 644 SYS_EXECVE => { 645 let path_ptr = args[0]; 646 let argv_ptr = args[1]; 647 let env_ptr = args[2]; 648 let virt_path_ptr = VirtAddr::new(path_ptr); 649 let virt_argv_ptr = VirtAddr::new(argv_ptr); 650 let virt_env_ptr = VirtAddr::new(env_ptr); 651 // 权限校验 652 if frame.from_user() 653 && (verify_area(virt_path_ptr, MAX_PATHLEN as usize).is_err() 654 || verify_area(virt_argv_ptr, PAGE_4K_SIZE as usize).is_err()) 655 || verify_area(virt_env_ptr, PAGE_4K_SIZE as usize).is_err() 656 { 657 Err(SystemError::EFAULT) 658 } else { 659 Self::execve( 660 path_ptr as *const u8, 661 argv_ptr as *const *const u8, 662 env_ptr as *const *const u8, 663 frame, 664 ) 665 .map(|_| 0) 666 } 667 } 668 SYS_WAIT4 => { 669 let pid = args[0] as i32; 670 let wstatus = args[1] as *mut i32; 671 let options = args[2] as c_int; 672 let rusage = args[3] as *mut c_void; 673 // 权限校验 674 // todo: 引入rusage之后，更正以下权限校验代码中，rusage的大小 675 Self::wait4(pid.into(), wstatus, options, rusage) 676 } 677 678 SYS_EXIT => { 679 let exit_code = args[0]; 680 Self::exit(exit_code) 681 } 682 SYS_MKDIR => { 683 let path_ptr = args[0] as *const c_char; 684 let mode = args[1]; 685 let virt_path_ptr = VirtAddr::new(path_ptr as usize); 686 let security_check = || { 687 if path_ptr.is_null() 688 || (frame.from_user() 689 && verify_area(virt_path_ptr, PAGE_2M_SIZE as usize).is_err()) 690 { 691 return Err(SystemError::EINVAL); 692 } 693 let path: &CStr = unsafe { CStr::from_ptr(path_ptr) }; 694 let path: &str = path.to_str().map_err(|_| SystemError::EINVAL)?.trim(); 695 696 if path == "" { 697 return Err(SystemError::EINVAL); 698 } 699 return Ok(path); 700 }; 701 702 let path = security_check(); 703 if path.is_err() { 704 Err(path.unwrap_err()) 705 } else { 706 Self::mkdir(path.unwrap(), mode) 707 } 708 } 709 710 SYS_NANOSLEEP => { 711 let req = args[0] as *const TimeSpec; 712 let rem = args[1] as *mut TimeSpec; 713 let virt_req = VirtAddr::new(req as usize); 714 let virt_rem = VirtAddr::new(rem as usize); 715 if frame.from_user() 716 && (verify_area(virt_req, core::mem::size_of::<TimeSpec>() as usize).is_err() 717 || verify_area(virt_rem, core::mem::size_of::<TimeSpec>() as usize) 718 .is_err()) 719 { 720 Err(SystemError::EFAULT) 721 } else { 722 Self::nanosleep(req, rem) 723 } 724 } 725 726 SYS_CLOCK => Self::clock(), 727 SYS_PIPE => { 728 let pipefd: *mut i32 = args[0] as *mut c_int; 729 let arg1 = args[1]; 730 if pipefd.is_null() { 731 Err(SystemError::EFAULT) 732 } else { 733 let flags = FileMode::from_bits_truncate(arg1 as u32); 734 Self::pipe2(pipefd, flags) 735 } 736 } 737 738 SYS_UNLINK_AT => { 739 let dirfd = args[0] as i32; 740 let pathname = args[1] as *const c_char; 741 let flags = args[2] as u32; 742 let virt_pathname = VirtAddr::new(pathname as usize); 743 if frame.from_user() && verify_area(virt_pathname, PAGE_4K_SIZE as usize).is_err() { 744 Err(SystemError::EFAULT) 745 } else if pathname.is_null() { 746 Err(SystemError::EFAULT) 747 } else { 748 let get_path = || { 749 let pathname: &CStr = unsafe { CStr::from_ptr(pathname) }; 750 751 let pathname: &str = pathname.to_str().map_err(|_| SystemError::EINVAL)?; 752 if pathname.len() >= MAX_PATHLEN { 753 return Err(SystemError::ENAMETOOLONG); 754 } 755 return Ok(pathname.trim()); 756 }; 757 let pathname = get_path(); 758 if pathname.is_err() { 759 Err(pathname.unwrap_err()) 760 } else { 761 // kdebug!("sys unlinkat: dirfd: {}, pathname: {}", dirfd, pathname.as_ref().unwrap()); 762 Self::unlinkat(dirfd, pathname.unwrap(), flags) 763 } 764 } 765 } 766 767 SYS_UNLINK => { 768 let pathname = args[0] as *const u8; 769 Self::unlink(pathname) 770 } 771 SYS_KILL => { 772 let pid = Pid::new(args[0]); 773 let sig = args[1] as c_int; 774 // kdebug!("KILL SYSCALL RECEIVED"); 775 Self::kill(pid, sig) 776 } 777 778 SYS_SIGACTION => { 779 let sig = args[0] as c_int; 780 let act = args[1]; 781 let old_act = args[2]; 782 Self::sigaction(sig, act, old_act, frame.from_user()) 783 } 784 785 SYS_RT_SIGRETURN => { 786 // 由于目前signal机制的实现，与x86_64强关联，因此暂时在arch/x86_64/syscall.rs中调用 787 // todo: 未来需要将signal机制与平台解耦 788 todo!() 789 } 790 791 SYS_GETPID => Self::getpid().map(|pid| pid.into()), 792 793 SYS_SCHED => Self::sched(frame.from_user()), 794 SYS_DUP => { 795 let oldfd: i32 = args[0] as c_int; 796 Self::dup(oldfd) 797 } 798 SYS_DUP2 => { 799 let oldfd: i32 = args[0] as c_int; 800 let newfd: i32 = args[1] as c_int; 801 Self::dup2(oldfd, newfd) 802 } 803 804 SYS_SOCKET => Self::socket(args[0], args[1], args[2]), 805 SYS_SETSOCKOPT => { 806 let optval = args[3] as *const u8; 807 let optlen = args[4] as usize; 808 let virt_optval = VirtAddr::new(optval as usize); 809 // 验证optval的地址是否合法 810 if verify_area(virt_optval, optlen as usize).is_err() { 811 // 地址空间超出了用户空间的范围，不合法 812 Err(SystemError::EFAULT) 813 } else { 814 let data: &[u8] = unsafe { core::slice::from_raw_parts(optval, optlen) }; 815 Self::setsockopt(args[0], args[1], args[2], data) 816 } 817 } 818 SYS_GETSOCKOPT => { 819 let optval = args[3] as *mut u8; 820 let optlen = args[4] as *mut usize; 821 let virt_optval = VirtAddr::new(optval as usize); 822 let virt_optlen = VirtAddr::new(optlen as usize); 823 let security_check = || { 824 // 验证optval的地址是否合法 825 if verify_area(virt_optval, PAGE_4K_SIZE as usize).is_err() { 826 // 地址空间超出了用户空间的范围，不合法 827 return Err(SystemError::EFAULT); 828 } 829 830 // 验证optlen的地址是否合法 831 if verify_area(virt_optlen, core::mem::size_of::<u32>() as usize).is_err() { 832 // 地址空间超出了用户空间的范围，不合法 833 return Err(SystemError::EFAULT); 834 } 835 return Ok(()); 836 }; 837 let r = security_check(); 838 if r.is_err() { 839 Err(r.unwrap_err()) 840 } else { 841 Self::getsockopt(args[0], args[1], args[2], optval, optlen as *mut u32) 842 } 843 } 844 845 SYS_CONNECT => { 846 let addr = args[1] as *const SockAddr; 847 let addrlen = args[2] as usize; 848 let virt_addr = VirtAddr::new(addr as usize); 849 // 验证addr的地址是否合法 850 if verify_area(virt_addr, addrlen as usize).is_err() { 851 // 地址空间超出了用户空间的范围，不合法 852 Err(SystemError::EFAULT) 853 } else { 854 Self::connect(args[0], addr, addrlen) 855 } 856 } 857 SYS_BIND => { 858 let addr = args[1] as *const SockAddr; 859 let addrlen = args[2] as usize; 860 let virt_addr = VirtAddr::new(addr as usize); 861 // 验证addr的地址是否合法 862 if verify_area(virt_addr, addrlen as usize).is_err() { 863 // 地址空间超出了用户空间的范围，不合法 864 Err(SystemError::EFAULT) 865 } else { 866 Self::bind(args[0], addr, addrlen) 867 } 868 } 869 870 SYS_SENDTO => { 871 let buf = args[1] as *const u8; 872 let len = args[2] as usize; 873 let flags = args[3] as u32; 874 let addr = args[4] as *const SockAddr; 875 let addrlen = args[5] as usize; 876 let virt_buf = VirtAddr::new(buf as usize); 877 let virt_addr = VirtAddr::new(addr as usize); 878 // 验证buf的地址是否合法 879 if verify_area(virt_buf, len as usize).is_err() { 880 // 地址空间超出了用户空间的范围，不合法 881 Err(SystemError::EFAULT) 882 } else if verify_area(virt_addr, addrlen as usize).is_err() { 883 // 地址空间超出了用户空间的范围，不合法 884 Err(SystemError::EFAULT) 885 } else { 886 let data: &[u8] = unsafe { core::slice::from_raw_parts(buf, len) }; 887 Self::sendto(args[0], data, flags, addr, addrlen) 888 } 889 } 890 891 SYS_RECVFROM => { 892 let buf = args[1] as *mut u8; 893 let len = args[2] as usize; 894 let flags = args[3] as u32; 895 let addr = args[4] as *mut SockAddr; 896 let addrlen = args[5] as *mut usize; 897 let virt_buf = VirtAddr::new(buf as usize); 898 let virt_addrlen = VirtAddr::new(addrlen as usize); 899 let virt_addr = VirtAddr::new(addr as usize); 900 let security_check = || { 901 // 验证buf的地址是否合法 902 if verify_area(virt_buf, len as usize).is_err() { 903 // 地址空间超出了用户空间的范围，不合法 904 return Err(SystemError::EFAULT); 905 } 906 907 // 验证addrlen的地址是否合法 908 if verify_area(virt_addrlen, core::mem::size_of::<u32>() as usize).is_err() { 909 // 地址空间超出了用户空间的范围，不合法 910 return Err(SystemError::EFAULT); 911 } 912 913 if verify_area(virt_addr, core::mem::size_of::<SockAddr>() as usize).is_err() { 914 // 地址空间超出了用户空间的范围，不合法 915 return Err(SystemError::EFAULT); 916 } 917 return Ok(()); 918 }; 919 let r = security_check(); 920 if r.is_err() { 921 Err(r.unwrap_err()) 922 } else { 923 let buf = unsafe { core::slice::from_raw_parts_mut(buf, len) }; 924 Self::recvfrom(args[0], buf, flags, addr, addrlen as *mut u32) 925 } 926 } 927 928 SYS_RECVMSG => { 929 let msg = args[1] as *mut crate::net::syscall::MsgHdr; 930 let flags = args[2] as u32; 931 match UserBufferWriter::new( 932 msg, 933 core::mem::size_of::<crate::net::syscall::MsgHdr>(), 934 true, 935 ) { 936 Err(e) => Err(e), 937 Ok(mut user_buffer_writer) => { 938 match user_buffer_writer.buffer::<crate::net::syscall::MsgHdr>(0) { 939 Err(e) => Err(e), 940 Ok(buffer) => { 941 let msg = &mut buffer[0]; 942 Self::recvmsg(args[0], msg, flags) 943 } 944 } 945 } 946 } 947 } 948 949 SYS_LISTEN => Self::listen(args[0], args[1]), 950 SYS_SHUTDOWN => Self::shutdown(args[0], args[1]), 951 SYS_ACCEPT => Self::accept(args[0], args[1] as *mut SockAddr, args[2] as *mut u32), 952 SYS_ACCEPT4 => Self::accept4( 953 args[0], 954 args[1] as *mut SockAddr, 955 args[2] as *mut u32, 956 args[3] as u32, 957 ), 958 SYS_GETSOCKNAME => { 959 Self::getsockname(args[0], args[1] as *mut SockAddr, args[2] as *mut u32) 960 } 961 SYS_GETPEERNAME => { 962 Self::getpeername(args[0], args[1] as *mut SockAddr, args[2] as *mut u32) 963 } 964 SYS_GETTIMEOFDAY => { 965 let timeval = args[0] as *mut PosixTimeval; 966 let timezone_ptr = args[1] as *mut PosixTimeZone; 967 Self::gettimeofday(timeval, timezone_ptr) 968 } 969 SYS_MMAP => { 970 let len = page_align_up(args[1]); 971 let virt_addr = VirtAddr::new(args[0] as usize); 972 if verify_area(virt_addr, len as usize).is_err() { 973 Err(SystemError::EFAULT) 974 } else { 975 Self::mmap( 976 VirtAddr::new(args[0]), 977 len, 978 args[2], 979 args[3], 980 args[4] as i32, 981 args[5], 982 ) 983 } 984 } 985 SYS_MUNMAP => { 986 let addr = args[0]; 987 let len = page_align_up(args[1]); 988 if addr & (MMArch::PAGE_SIZE - 1) != 0 { 989 // The addr argument is not a multiple of the page size 990 Err(SystemError::EINVAL) 991 } else { 992 Self::munmap(VirtAddr::new(addr), len) 993 } 994 } 995 SYS_MPROTECT => { 996 let addr = args[0]; 997 let len = page_align_up(args[1]); 998 if addr & (MMArch::PAGE_SIZE - 1) != 0 { 999 // The addr argument is not a multiple of the page size 1000 Err(SystemError::EINVAL) 1001 } else { 1002 Self::mprotect(VirtAddr::new(addr), len, args[2]) 1003 } 1004 } 1005 1006 SYS_GETCWD => { 1007 let buf = args[0] as *mut u8; 1008 let size = args[1] as usize; 1009 let security_check = || { 1010 verify_area(VirtAddr::new(buf as usize), size)?; 1011 return Ok(()); 1012 }; 1013 let r = security_check(); 1014 if r.is_err() { 1015 Err(r.unwrap_err()) 1016 } else { 1017 let buf = unsafe { core::slice::from_raw_parts_mut(buf, size) }; 1018 Self::getcwd(buf).map(|ptr| ptr.data()) 1019 } 1020 } 1021 1022 SYS_GETPGID => Self::getpgid(Pid::new(args[0])).map(|pid| pid.into()), 1023 1024 SYS_GETPPID => Self::getppid().map(|pid| pid.into()), 1025 SYS_FSTAT => { 1026 let fd = args[0] as i32; 1027 let kstat = args[1] as *mut PosixKstat; 1028 let vaddr = VirtAddr::new(kstat as usize); 1029 // FIXME 由于c中的verify_area与rust中的verify_area重名，所以在引入时加了前缀区分 1030 // TODO 应该将用了c版本的verify_area都改为rust的verify_area 1031 match verify_area(vaddr, core::mem::size_of::<PosixKstat>()) { 1032 Ok(_) => Self::fstat(fd, kstat), 1033 Err(e) => Err(e), 1034 } 1035 } 1036 1037 SYS_FCNTL => { 1038 let fd = args[0] as i32; 1039 let cmd: Option<FcntlCommand> = 1040 <FcntlCommand as FromPrimitive>::from_u32(args[1] as u32); 1041 let arg = args[2] as i32; 1042 let res = if let Some(cmd) = cmd { 1043 Self::fcntl(fd, cmd, arg) 1044 } else { 1045 Err(SystemError::EINVAL) 1046 }; 1047 1048 // kdebug!("FCNTL: fd: {}, cmd: {:?}, arg: {}, res: {:?}", fd, cmd, arg, res); 1049 res 1050 } 1051 1052 SYS_FTRUNCATE => { 1053 let fd = args[0] as i32; 1054 let len = args[1] as usize; 1055 let res = Self::ftruncate(fd, len); 1056 // kdebug!("FTRUNCATE: fd: {}, len: {}, res: {:?}", fd, len, res); 1057 res 1058 } 1059 1060 SYS_MKNOD => { 1061 let path = args[0]; 1062 let flags = args[1]; 1063 let dev_t = args[2]; 1064 let flags: ModeType = ModeType::from_bits_truncate(flags as u32); 1065 Self::mknod(path as *const i8, flags, DeviceNumber::from(dev_t)) 1066 } 1067 1068 SYS_CLONE => { 1069 let parent_tid = VirtAddr::new(args[2]); 1070 let child_tid = VirtAddr::new(args[3]); 1071 1072 // 地址校验 1073 verify_area(parent_tid, core::mem::size_of::<i32>())?; 1074 verify_area(child_tid, core::mem::size_of::<i32>())?; 1075 1076 let mut clone_args = KernelCloneArgs::new(); 1077 clone_args.flags = CloneFlags::from_bits_truncate(args[0] as u64); 1078 clone_args.stack = args[1]; 1079 clone_args.parent_tid = parent_tid; 1080 clone_args.child_tid = child_tid; 1081 clone_args.tls = args[4]; 1082 Self::clone(frame, clone_args) 1083 } 1084 1085 SYS_FUTEX => { 1086 let uaddr = VirtAddr::new(args[0]); 1087 let operation = FutexFlag::from_bits(args[1] as u32).ok_or(SystemError::ENOSYS)?; 1088 let val = args[2] as u32; 1089 let utime = args[3]; 1090 let uaddr2 = VirtAddr::new(args[4]); 1091 let val3 = args[5] as u32; 1092 1093 verify_area(uaddr, core::mem::size_of::<u32>())?; 1094 verify_area(uaddr2, core::mem::size_of::<u32>())?; 1095 1096 let mut timespec = None; 1097 if utime != 0 && operation.contains(FutexFlag::FLAGS_HAS_TIMEOUT) { 1098 let reader = UserBufferReader::new( 1099 utime as *const TimeSpec, 1100 core::mem::size_of::<TimeSpec>(), 1101 true, 1102 )?; 1103 1104 timespec = Some(reader.read_one_from_user::<TimeSpec>(0)?.clone()); 1105 } 1106 1107 Self::do_futex(uaddr, operation, val, timespec, uaddr2, utime as u32, val3) 1108 } 1109 1110 SYS_READV => Self::readv(args[0] as i32, args[1], args[2]), 1111 SYS_WRITEV => Self::writev(args[0] as i32, args[1], args[2]), 1112 1113 SYS_ARCH_PRCTL => Self::arch_prctl(args[0], args[1]), 1114 1115 SYS_SET_TID_ADDR => Self::set_tid_address(args[0]), 1116 1117 SYS_STAT | SYS_LSTAT => { 1118 let path: &CStr = unsafe { CStr::from_ptr(args[0] as *const c_char) }; 1119 let path: Result<&str, core::str::Utf8Error> = path.to_str(); 1120 let res = if path.is_err() { 1121 Err(SystemError::EINVAL) 1122 } else { 1123 let path: &str = path.unwrap(); 1124 let kstat = args[1] as *mut PosixKstat; 1125 let vaddr = VirtAddr::new(kstat as usize); 1126 match verify_area(vaddr, core::mem::size_of::<PosixKstat>()) { 1127 Ok(_) => { 1128 if syscall_num == SYS_STAT { 1129 Self::stat(path, kstat) 1130 } else { 1131 Self::lstat(path, kstat) 1132 } 1133 } 1134 Err(e) => Err(e), 1135 } 1136 }; 1137 1138 res 1139 } 1140 1141 // 目前为了适配musl-libc,以下系统调用先这样写着 1142 SYS_GET_RANDOM => { 1143 let flags = GRandFlags::from_bits(args[2] as u8).ok_or(SystemError::EINVAL)?; 1144 Self::get_random(args[0] as *mut u8, args[1], flags) 1145 } 1146 1147 SYS_SOCKET_PAIR => { 1148 unimplemented!() 1149 } 1150 1151 SYS_POLL => { 1152 kwarn!("SYS_POLL has not yet been implemented"); 1153 Ok(0) 1154 } 1155 1156 SYS_RT_SIGPROCMASK => { 1157 kwarn!("SYS_RT_SIGPROCMASK has not yet been implemented"); 1158 Ok(0) 1159 } 1160 1161 SYS_TKILL => { 1162 kwarn!("SYS_TKILL has not yet been implemented"); 1163 Ok(0) 1164 } 1165 1166 SYS_SIGALTSTACK => { 1167 kwarn!("SYS_SIGALTSTACK has not yet been implemented"); 1168 Ok(0) 1169 } 1170 1171 SYS_EXIT_GROUP => { 1172 kwarn!("SYS_EXIT_GROUP has not yet been implemented"); 1173 Ok(0) 1174 } 1175 1176 SYS_MADVISE => { 1177 kwarn!("SYS_MADVISE has not yet been implemented"); 1178 Ok(0) 1179 } 1180 SYS_GETTID => Self::gettid().map(|tid| tid.into()), 1181 SYS_GETUID => Self::getuid().map(|uid| uid.into()), 1182 SYS_SYSLOG => { 1183 kwarn!("SYS_SYSLOG has not yet been implemented"); 1184 Ok(0) 1185 } 1186 SYS_GETGID => Self::getgid().map(|gid| gid.into()), 1187 SYS_SETUID => { 1188 kwarn!("SYS_SETUID has not yet been implemented"); 1189 Ok(0) 1190 } 1191 SYS_SETGID => { 1192 kwarn!("SYS_SETGID has not yet been implemented"); 1193 Ok(0) 1194 } 1195 SYS_GETEUID => Self::geteuid().map(|euid| euid.into()), 1196 SYS_GETEGID => Self::getegid().map(|egid| egid.into()), 1197 SYS_GETRUSAGE => { 1198 let who = args[0] as c_int; 1199 let rusage = args[1] as *mut RUsage; 1200 Self::get_rusage(who, rusage) 1201 } 1202 1203 SYS_READLINK => { 1204 let path = args[0] as *const u8; 1205 let buf = args[1] as *mut u8; 1206 let bufsiz = args[2] as usize; 1207 Self::readlink(path, buf, bufsiz) 1208 } 1209 1210 SYS_READLINK_AT => { 1211 let dirfd = args[0] as i32; 1212 let pathname = args[1] as *const u8; 1213 let buf = args[2] as *mut u8; 1214 let bufsiz = args[3] as usize; 1215 Self::readlink_at(dirfd, pathname, buf, bufsiz) 1216 } 1217 1218 SYS_PRLIMIT64 => { 1219 let pid = args[0]; 1220 let pid = Pid::new(pid); 1221 let resource = args[1]; 1222 let new_limit = args[2] as *const RLimit64; 1223 let old_limit = args[3] as *mut RLimit64; 1224 1225 Self::prlimit64(pid, resource, new_limit, old_limit) 1226 } 1227 1228 SYS_ACCESS => { 1229 let pathname = args[0] as *const u8; 1230 let mode = args[1] as u32; 1231 Self::access(pathname, mode) 1232 } 1233 1234 SYS_FACCESSAT => { 1235 let dirfd = args[0] as i32; 1236 let pathname = args[1] as *const u8; 1237 let mode = args[2] as u32; 1238 Self::faccessat2(dirfd, pathname, mode, 0) 1239 } 1240 1241 SYS_FACCESSAT2 => { 1242 let dirfd = args[0] as i32; 1243 let pathname = args[1] as *const u8; 1244 let mode = args[2] as u32; 1245 let flags = args[3] as u32; 1246 Self::faccessat2(dirfd, pathname, mode, flags) 1247 } 1248 1249 SYS_CLOCK_GETTIME => { 1250 let clockid = args[0] as i32; 1251 let timespec = args[1] as *mut TimeSpec; 1252 Self::clock_gettime(clockid, timespec) 1253 } 1254 1255 SYS_SYSINFO => { 1256 let info = args[0] as *mut SysInfo; 1257 Self::sysinfo(info) 1258 } 1259 1260 SYS_UMASK => { 1261 let mask = args[0] as u32; 1262 Self::umask(mask) 1263 } 1264 1265 SYS_CHMOD => { 1266 let pathname = args[0] as *const u8; 1267 let mode = args[1] as u32; 1268 Self::chmod(pathname, mode) 1269 } 1270 SYS_FCHMOD => { 1271 let fd = args[0] as i32; 1272 let mode = args[1] as u32; 1273 Self::fchmod(fd, mode) 1274 } 1275 SYS_FCHMODAT => { 1276 let dirfd = args[0] as i32; 1277 let pathname = args[1] as *const u8; 1278 let mode = args[2] as u32; 1279 Self::fchmodat(dirfd, pathname, mode) 1280 } 1281 1282 _ => panic!("Unsupported syscall ID: {}", syscall_num), 1283 }; 1284 return r; 1285 } 1286 1287 pub fn put_string( 1288 s: *const u8, 1289 front_color: u32, 1290 back_color: u32, 1291 ) -> Result<usize, SystemError> { 1292 return Ok(unsafe { do_put_string(s, front_color, back_color) }); 1293 } 1294 1295 pub fn reboot() -> Result<usize, SystemError> { 1296 cpu_reset(); 1297 } 1298 } 1299