1 use core::{ 2 ffi::{c_int, c_void}, 3 ptr::null, 4 sync::atomic::{AtomicBool, Ordering}, 5 }; 6 7 use crate::{ 8 arch::{ipc::signal::SigSet, syscall::nr::*}, 9 driver::base::device::device_number::DeviceNumber, 10 libs::{futex::constant::FutexFlag, rand::GRandFlags}, 11 mm::syscall::MremapFlags, 12 net::syscall::MsgHdr, 13 process::{ 14 fork::KernelCloneArgs, 15 resource::{RLimit64, RUsage}, 16 ProcessManager, 17 }, 18 syscall::user_access::check_and_clone_cstr, 19 }; 20 21 use num_traits::FromPrimitive; 22 use system_error::SystemError; 23 24 use crate::{ 25 arch::{cpu::cpu_reset, interrupt::TrapFrame, MMArch}, 26 filesystem::vfs::{ 27 fcntl::{AtFlags, FcntlCommand}, 28 file::FileMode, 29 syscall::{ModeType, PosixKstat}, 30 MAX_PATHLEN, 31 }, 32 include::bindings::bindings::PAGE_4K_SIZE, 33 kinfo, 34 libs::align::page_align_up, 35 mm::{verify_area, MemoryManagementArch, VirtAddr}, 36 net::syscall::SockAddr, 37 process::{fork::CloneFlags, syscall::PosixOldUtsName, Pid}, 38 time::{ 39 syscall::{PosixTimeZone, PosixTimeval}, 40 TimeSpec, 41 }, 42 }; 43 44 use self::{ 45 misc::SysInfo, 46 user_access::{UserBufferReader, UserBufferWriter}, 47 }; 48 49 pub mod misc; 50 pub mod user_access; 51 52 // 与linux不一致的调用，在linux基础上累加 53 pub const SYS_PUT_STRING: usize = 100000; 54 pub const SYS_SBRK: usize = 100001; 55 /// todo: 该系统调用与Linux不一致，将来需要删除该系统调用！！！ 删的时候记得改C版本的libc 56 pub const SYS_CLOCK: usize = 100002; 57 pub const SYS_SCHED: usize = 100003; 58 59 #[derive(Debug)] 60 pub struct Syscall; 61 62 impl Syscall { 63 /// 初始化系统调用 64 #[inline(never)] 65 pub fn init() -> Result<(), SystemError> { 66 static INIT_FLAG: AtomicBool = AtomicBool::new(false); 67 let prev = INIT_FLAG.swap(true, Ordering::SeqCst); 68 if prev { 69 panic!("Cannot initialize syscall more than once!"); 70 } 71 kinfo!("Initializing syscall..."); 72 let r = crate::arch::syscall::arch_syscall_init(); 73 kinfo!("Syscall init successfully!"); 74 75 return r; 76 } 77 /// @brief 系统调用分发器，用于分发系统调用。 78 /// 79 /// 这个函数内，需要根据系统调用号，调用对应的系统调用处理函数。 80 /// 并且，对于用户态传入的指针参数，需要在本函数内进行越界检查，防止访问到内核空间。 81 #[inline(never)] 82 pub fn handle( 83 syscall_num: usize, 84 args: &[usize], 85 frame: &mut TrapFrame, 86 ) -> Result<usize, SystemError> { 87 let r = match syscall_num { 88 SYS_PUT_STRING => { 89 Self::put_string(args[0] as *const u8, args[1] as u32, args[2] as u32) 90 } 91 #[cfg(target_arch = "x86_64")] 92 SYS_OPEN => { 93 let path = args[0] as *const u8; 94 let flags = args[1] as u32; 95 let mode = args[2] as u32; 96 97 Self::open(path, flags, mode, true) 98 } 99 100 SYS_RENAME => { 101 let oldname: *const u8 = args[0] as *const u8; 102 let newname: *const u8 = args[1] as *const u8; 103 Self::do_renameat2( 104 AtFlags::AT_FDCWD.bits(), 105 oldname, 106 AtFlags::AT_FDCWD.bits(), 107 newname, 108 0, 109 ) 110 } 111 112 SYS_RENAMEAT => { 113 let oldfd = args[0] as i32; 114 let oldname: *const u8 = args[1] as *const u8; 115 let newfd = args[2] as i32; 116 let newname: *const u8 = args[3] as *const u8; 117 Self::do_renameat2(oldfd, oldname, newfd, newname, 0) 118 } 119 120 SYS_RENAMEAT2 => { 121 let oldfd = args[0] as i32; 122 let oldname: *const u8 = args[1] as *const u8; 123 let newfd = args[2] as i32; 124 let newname: *const u8 = args[3] as *const u8; 125 let flags = args[4] as u32; 126 Self::do_renameat2(oldfd, oldname, newfd, newname, flags) 127 } 128 129 SYS_OPENAT => { 130 let dirfd = args[0] as i32; 131 let path = args[1] as *const u8; 132 let flags = args[2] as u32; 133 let mode = args[3] as u32; 134 135 Self::openat(dirfd, path, flags, mode, true) 136 } 137 SYS_CLOSE => { 138 let fd = args[0]; 139 Self::close(fd) 140 } 141 SYS_READ => { 142 let fd = args[0] as i32; 143 let buf_vaddr = args[1]; 144 let len = args[2]; 145 let from_user = frame.from_user(); 146 let mut user_buffer_writer = 147 UserBufferWriter::new(buf_vaddr as *mut u8, len, from_user)?; 148 149 let user_buf = user_buffer_writer.buffer(0)?; 150 Self::read(fd, user_buf) 151 } 152 SYS_WRITE => { 153 let fd = args[0] as i32; 154 let buf_vaddr = args[1]; 155 let len = args[2]; 156 let from_user = frame.from_user(); 157 let user_buffer_reader = 158 UserBufferReader::new(buf_vaddr as *const u8, len, from_user)?; 159 160 let user_buf = user_buffer_reader.read_from_user(0)?; 161 Self::write(fd, user_buf) 162 } 163 164 SYS_LSEEK => { 165 let fd = args[0] as i32; 166 let offset = args[1] as i64; 167 let whence = args[2] as u32; 168 169 Self::lseek(fd, offset, whence) 170 } 171 172 SYS_PREAD64 => { 173 let fd = args[0] as i32; 174 let buf_vaddr = args[1]; 175 let len = args[2]; 176 let offset = args[3]; 177 178 let mut user_buffer_writer = 179 UserBufferWriter::new(buf_vaddr as *mut u8, len, frame.from_user())?; 180 let buf = user_buffer_writer.buffer(0)?; 181 Self::pread(fd, buf, len, offset) 182 } 183 184 SYS_PWRITE64 => { 185 let fd = args[0] as i32; 186 let buf_vaddr = args[1]; 187 let len = args[2]; 188 let offset = args[3]; 189 190 let user_buffer_reader = 191 UserBufferReader::new(buf_vaddr as *const u8, len, frame.from_user())?; 192 193 let buf = user_buffer_reader.read_from_user(0)?; 194 Self::pwrite(fd, buf, len, offset) 195 } 196 197 SYS_IOCTL => { 198 let fd = args[0]; 199 let cmd = args[1]; 200 let data = args[2]; 201 Self::ioctl(fd, cmd as u32, data) 202 } 203 204 #[cfg(target_arch = "x86_64")] 205 SYS_FORK => Self::fork(frame), 206 #[cfg(target_arch = "x86_64")] 207 SYS_VFORK => Self::vfork(frame), 208 209 SYS_BRK => { 210 let new_brk = VirtAddr::new(args[0]); 211 Self::brk(new_brk).map(|vaddr| vaddr.data()) 212 } 213 214 SYS_SBRK => { 215 let increment = args[0] as isize; 216 Self::sbrk(increment).map(|vaddr: VirtAddr| vaddr.data()) 217 } 218 219 SYS_REBOOT => Self::reboot(), 220 221 SYS_CHDIR => { 222 let r = args[0] as *const u8; 223 Self::chdir(r) 224 } 225 226 #[allow(unreachable_patterns)] 227 SYS_GETDENTS64 | SYS_GETDENTS => { 228 let fd = args[0] as i32; 229 230 let buf_vaddr = args[1]; 231 let len = args[2]; 232 let virt_addr: VirtAddr = VirtAddr::new(buf_vaddr); 233 // 判断缓冲区是否来自用户态，进行权限校验 234 let res = if frame.from_user() && verify_area(virt_addr, len as usize).is_err() { 235 // 来自用户态，而buffer在内核态，这样的操作不被允许 236 Err(SystemError::EPERM) 237 } else if buf_vaddr == 0 { 238 Err(SystemError::EFAULT) 239 } else { 240 let buf: &mut [u8] = unsafe { 241 core::slice::from_raw_parts_mut::<'static, u8>(buf_vaddr as *mut u8, len) 242 }; 243 Self::getdents(fd, buf) 244 }; 245 246 res 247 } 248 249 SYS_EXECVE => { 250 let path_ptr = args[0]; 251 let argv_ptr = args[1]; 252 let env_ptr = args[2]; 253 let virt_path_ptr = VirtAddr::new(path_ptr); 254 let virt_argv_ptr = VirtAddr::new(argv_ptr); 255 let virt_env_ptr = VirtAddr::new(env_ptr); 256 // 权限校验 257 if frame.from_user() 258 && (verify_area(virt_path_ptr, MAX_PATHLEN as usize).is_err() 259 || verify_area(virt_argv_ptr, PAGE_4K_SIZE as usize).is_err()) 260 || verify_area(virt_env_ptr, PAGE_4K_SIZE as usize).is_err() 261 { 262 Err(SystemError::EFAULT) 263 } else { 264 Self::execve( 265 path_ptr as *const u8, 266 argv_ptr as *const *const u8, 267 env_ptr as *const *const u8, 268 frame, 269 ) 270 .map(|_| 0) 271 } 272 } 273 SYS_WAIT4 => { 274 let pid = args[0] as i32; 275 let wstatus = args[1] as *mut i32; 276 let options = args[2] as c_int; 277 let rusage = args[3] as *mut c_void; 278 // 权限校验 279 // todo: 引入rusage之后，更正以下权限校验代码中，rusage的大小 280 Self::wait4(pid.into(), wstatus, options, rusage) 281 } 282 283 SYS_EXIT => { 284 let exit_code = args[0]; 285 Self::exit(exit_code) 286 } 287 #[cfg(target_arch = "x86_64")] 288 SYS_MKDIR => { 289 let path = args[0] as *const u8; 290 let mode = args[1]; 291 292 Self::mkdir(path, mode) 293 } 294 295 SYS_NANOSLEEP => { 296 let req = args[0] as *const TimeSpec; 297 let rem = args[1] as *mut TimeSpec; 298 let virt_req = VirtAddr::new(req as usize); 299 let virt_rem = VirtAddr::new(rem as usize); 300 if frame.from_user() 301 && (verify_area(virt_req, core::mem::size_of::<TimeSpec>() as usize).is_err() 302 || verify_area(virt_rem, core::mem::size_of::<TimeSpec>() as usize) 303 .is_err()) 304 { 305 Err(SystemError::EFAULT) 306 } else { 307 Self::nanosleep(req, rem) 308 } 309 } 310 311 SYS_CLOCK => Self::clock(), 312 #[cfg(target_arch = "x86_64")] 313 SYS_PIPE => { 314 let pipefd: *mut i32 = args[0] as *mut c_int; 315 if pipefd.is_null() { 316 Err(SystemError::EFAULT) 317 } else { 318 Self::pipe2(pipefd, FileMode::empty()) 319 } 320 } 321 322 SYS_PIPE2 => { 323 let pipefd: *mut i32 = args[0] as *mut c_int; 324 let arg1 = args[1]; 325 if pipefd.is_null() { 326 Err(SystemError::EFAULT) 327 } else { 328 let flags = FileMode::from_bits_truncate(arg1 as u32); 329 Self::pipe2(pipefd, flags) 330 } 331 } 332 333 SYS_UNLINKAT => { 334 let dirfd = args[0] as i32; 335 let path = args[1] as *const u8; 336 let flags = args[2] as u32; 337 Self::unlinkat(dirfd, path, flags) 338 } 339 340 #[cfg(target_arch = "x86_64")] 341 SYS_RMDIR => { 342 let path = args[0] as *const u8; 343 Self::rmdir(path) 344 } 345 346 #[cfg(target_arch = "x86_64")] 347 SYS_UNLINK => { 348 let path = args[0] as *const u8; 349 Self::unlink(path) 350 } 351 SYS_KILL => { 352 let pid = Pid::new(args[0]); 353 let sig = args[1] as c_int; 354 // kdebug!("KILL SYSCALL RECEIVED"); 355 Self::kill(pid, sig) 356 } 357 358 SYS_RT_SIGACTION => { 359 let sig = args[0] as c_int; 360 let act = args[1]; 361 let old_act = args[2]; 362 Self::sigaction(sig, act, old_act, frame.from_user()) 363 } 364 365 SYS_GETPID => Self::getpid().map(|pid| pid.into()), 366 367 SYS_SCHED => Self::sched(frame.from_user()), 368 SYS_DUP => { 369 let oldfd: i32 = args[0] as c_int; 370 Self::dup(oldfd) 371 } 372 373 #[cfg(target_arch = "x86_64")] 374 SYS_DUP2 => { 375 let oldfd: i32 = args[0] as c_int; 376 let newfd: i32 = args[1] as c_int; 377 Self::dup2(oldfd, newfd) 378 } 379 380 SYS_SOCKET => Self::socket(args[0], args[1], args[2]), 381 SYS_SETSOCKOPT => { 382 let optval = args[3] as *const u8; 383 let optlen = args[4] as usize; 384 let virt_optval = VirtAddr::new(optval as usize); 385 // 验证optval的地址是否合法 386 if verify_area(virt_optval, optlen as usize).is_err() { 387 // 地址空间超出了用户空间的范围，不合法 388 Err(SystemError::EFAULT) 389 } else { 390 let data: &[u8] = unsafe { core::slice::from_raw_parts(optval, optlen) }; 391 Self::setsockopt(args[0], args[1], args[2], data) 392 } 393 } 394 SYS_GETSOCKOPT => { 395 let optval = args[3] as *mut u8; 396 let optlen = args[4] as *mut usize; 397 let virt_optval = VirtAddr::new(optval as usize); 398 let virt_optlen = VirtAddr::new(optlen as usize); 399 let security_check = || { 400 // 验证optval的地址是否合法 401 if verify_area(virt_optval, PAGE_4K_SIZE as usize).is_err() { 402 // 地址空间超出了用户空间的范围，不合法 403 return Err(SystemError::EFAULT); 404 } 405 406 // 验证optlen的地址是否合法 407 if verify_area(virt_optlen, core::mem::size_of::<u32>() as usize).is_err() { 408 // 地址空间超出了用户空间的范围，不合法 409 return Err(SystemError::EFAULT); 410 } 411 return Ok(()); 412 }; 413 let r = security_check(); 414 if r.is_err() { 415 Err(r.unwrap_err()) 416 } else { 417 Self::getsockopt(args[0], args[1], args[2], optval, optlen as *mut u32) 418 } 419 } 420 421 SYS_CONNECT => { 422 let addr = args[1] as *const SockAddr; 423 let addrlen = args[2] as usize; 424 let virt_addr = VirtAddr::new(addr as usize); 425 // 验证addr的地址是否合法 426 if verify_area(virt_addr, addrlen as usize).is_err() { 427 // 地址空间超出了用户空间的范围，不合法 428 Err(SystemError::EFAULT) 429 } else { 430 Self::connect(args[0], addr, addrlen) 431 } 432 } 433 SYS_BIND => { 434 let addr = args[1] as *const SockAddr; 435 let addrlen = args[2] as usize; 436 let virt_addr = VirtAddr::new(addr as usize); 437 // 验证addr的地址是否合法 438 if verify_area(virt_addr, addrlen as usize).is_err() { 439 // 地址空间超出了用户空间的范围，不合法 440 Err(SystemError::EFAULT) 441 } else { 442 Self::bind(args[0], addr, addrlen) 443 } 444 } 445 446 SYS_SENDTO => { 447 let buf = args[1] as *const u8; 448 let len = args[2] as usize; 449 let flags = args[3] as u32; 450 let addr = args[4] as *const SockAddr; 451 let addrlen = args[5] as usize; 452 let virt_buf = VirtAddr::new(buf as usize); 453 let virt_addr = VirtAddr::new(addr as usize); 454 // 验证buf的地址是否合法 455 if verify_area(virt_buf, len as usize).is_err() { 456 // 地址空间超出了用户空间的范围，不合法 457 Err(SystemError::EFAULT) 458 } else if verify_area(virt_addr, addrlen as usize).is_err() { 459 // 地址空间超出了用户空间的范围，不合法 460 Err(SystemError::EFAULT) 461 } else { 462 let data: &[u8] = unsafe { core::slice::from_raw_parts(buf, len) }; 463 Self::sendto(args[0], data, flags, addr, addrlen) 464 } 465 } 466 467 SYS_RECVFROM => { 468 let buf = args[1] as *mut u8; 469 let len = args[2] as usize; 470 let flags = args[3] as u32; 471 let addr = args[4] as *mut SockAddr; 472 let addrlen = args[5] as *mut usize; 473 let virt_buf = VirtAddr::new(buf as usize); 474 let virt_addrlen = VirtAddr::new(addrlen as usize); 475 let virt_addr = VirtAddr::new(addr as usize); 476 let security_check = || { 477 // 验证buf的地址是否合法 478 if verify_area(virt_buf, len).is_err() { 479 // 地址空间超出了用户空间的范围，不合法 480 return Err(SystemError::EFAULT); 481 } 482 483 // 验证addrlen的地址是否合法 484 if verify_area(virt_addrlen, core::mem::size_of::<u32>()).is_err() { 485 // 地址空间超出了用户空间的范围，不合法 486 return Err(SystemError::EFAULT); 487 } 488 489 if verify_area(virt_addr, core::mem::size_of::<SockAddr>()).is_err() { 490 // 地址空间超出了用户空间的范围，不合法 491 return Err(SystemError::EFAULT); 492 } 493 return Ok(()); 494 }; 495 let r = security_check(); 496 if r.is_err() { 497 Err(r.unwrap_err()) 498 } else { 499 let buf = unsafe { core::slice::from_raw_parts_mut(buf, len) }; 500 Self::recvfrom(args[0], buf, flags, addr, addrlen as *mut u32) 501 } 502 } 503 504 SYS_RECVMSG => { 505 let msg = args[1] as *mut MsgHdr; 506 let flags = args[2] as u32; 507 508 let mut user_buffer_writer = 509 UserBufferWriter::new(msg, core::mem::size_of::<MsgHdr>(), frame.from_user())?; 510 let buffer = user_buffer_writer.buffer::<MsgHdr>(0)?; 511 512 let msg = &mut buffer[0]; 513 Self::recvmsg(args[0], msg, flags) 514 } 515 516 SYS_LISTEN => Self::listen(args[0], args[1]), 517 SYS_SHUTDOWN => Self::shutdown(args[0], args[1]), 518 SYS_ACCEPT => Self::accept(args[0], args[1] as *mut SockAddr, args[2] as *mut u32), 519 SYS_ACCEPT4 => Self::accept4( 520 args[0], 521 args[1] as *mut SockAddr, 522 args[2] as *mut u32, 523 args[3] as u32, 524 ), 525 SYS_GETSOCKNAME => { 526 Self::getsockname(args[0], args[1] as *mut SockAddr, args[2] as *mut u32) 527 } 528 SYS_GETPEERNAME => { 529 Self::getpeername(args[0], args[1] as *mut SockAddr, args[2] as *mut u32) 530 } 531 SYS_GETTIMEOFDAY => { 532 let timeval = args[0] as *mut PosixTimeval; 533 let timezone_ptr = args[1] as *mut PosixTimeZone; 534 Self::gettimeofday(timeval, timezone_ptr) 535 } 536 SYS_MMAP => { 537 let len = page_align_up(args[1]); 538 let virt_addr = VirtAddr::new(args[0]); 539 if verify_area(virt_addr, len).is_err() { 540 Err(SystemError::EFAULT) 541 } else { 542 Self::mmap( 543 VirtAddr::new(args[0]), 544 len, 545 args[2], 546 args[3], 547 args[4] as i32, 548 args[5], 549 ) 550 } 551 } 552 SYS_MREMAP => { 553 let old_vaddr = VirtAddr::new(args[0]); 554 let old_len = args[1]; 555 let new_len = args[2]; 556 let mremap_flags = MremapFlags::from_bits_truncate(args[3] as u8); 557 let new_vaddr = VirtAddr::new(args[4]); 558 559 Self::mremap(old_vaddr, old_len, new_len, mremap_flags, new_vaddr) 560 } 561 SYS_MUNMAP => { 562 let addr = args[0]; 563 let len = page_align_up(args[1]); 564 if addr & (MMArch::PAGE_SIZE - 1) != 0 { 565 // The addr argument is not a multiple of the page size 566 Err(SystemError::EINVAL) 567 } else { 568 Self::munmap(VirtAddr::new(addr), len) 569 } 570 } 571 SYS_MPROTECT => { 572 let addr = args[0]; 573 let len = page_align_up(args[1]); 574 if addr & (MMArch::PAGE_SIZE - 1) != 0 { 575 // The addr argument is not a multiple of the page size 576 Err(SystemError::EINVAL) 577 } else { 578 Self::mprotect(VirtAddr::new(addr), len, args[2]) 579 } 580 } 581 582 SYS_GETCWD => { 583 let buf = args[0] as *mut u8; 584 let size = args[1]; 585 let security_check = || { 586 verify_area(VirtAddr::new(buf as usize), size)?; 587 return Ok(()); 588 }; 589 let r = security_check(); 590 if r.is_err() { 591 Err(r.unwrap_err()) 592 } else { 593 let buf = unsafe { core::slice::from_raw_parts_mut(buf, size) }; 594 Self::getcwd(buf).map(|ptr| ptr.data()) 595 } 596 } 597 598 SYS_GETPGID => Self::getpgid(Pid::new(args[0])).map(|pid| pid.into()), 599 600 SYS_GETPPID => Self::getppid().map(|pid| pid.into()), 601 SYS_FSTAT => { 602 let fd = args[0] as i32; 603 let kstat = args[1] as *mut PosixKstat; 604 let vaddr = VirtAddr::new(kstat as usize); 605 // FIXME 由于c中的verify_area与rust中的verify_area重名，所以在引入时加了前缀区分 606 // TODO 应该将用了c版本的verify_area都改为rust的verify_area 607 match verify_area(vaddr, core::mem::size_of::<PosixKstat>()) { 608 Ok(_) => Self::fstat(fd, kstat), 609 Err(e) => Err(e), 610 } 611 } 612 613 SYS_FCNTL => { 614 let fd = args[0] as i32; 615 let cmd: Option<FcntlCommand> = 616 <FcntlCommand as FromPrimitive>::from_u32(args[1] as u32); 617 let arg = args[2] as i32; 618 let res = if let Some(cmd) = cmd { 619 Self::fcntl(fd, cmd, arg) 620 } else { 621 Err(SystemError::EINVAL) 622 }; 623 624 // kdebug!("FCNTL: fd: {}, cmd: {:?}, arg: {}, res: {:?}", fd, cmd, arg, res); 625 res 626 } 627 628 SYS_FTRUNCATE => { 629 let fd = args[0] as i32; 630 let len = args[1]; 631 let res = Self::ftruncate(fd, len); 632 // kdebug!("FTRUNCATE: fd: {}, len: {}, res: {:?}", fd, len, res); 633 res 634 } 635 636 #[cfg(target_arch = "x86_64")] 637 SYS_MKNOD => { 638 let path = args[0]; 639 let flags = args[1]; 640 let dev_t = args[2]; 641 let flags: ModeType = ModeType::from_bits_truncate(flags as u32); 642 Self::mknod(path as *const u8, flags, DeviceNumber::from(dev_t as u32)) 643 } 644 645 SYS_CLONE => { 646 let parent_tid = VirtAddr::new(args[2]); 647 let child_tid = VirtAddr::new(args[3]); 648 649 // 地址校验 650 verify_area(parent_tid, core::mem::size_of::<i32>())?; 651 verify_area(child_tid, core::mem::size_of::<i32>())?; 652 653 let mut clone_args = KernelCloneArgs::new(); 654 clone_args.flags = CloneFlags::from_bits_truncate(args[0] as u64); 655 clone_args.stack = args[1]; 656 clone_args.parent_tid = parent_tid; 657 clone_args.child_tid = child_tid; 658 clone_args.tls = args[4]; 659 Self::clone(frame, clone_args) 660 } 661 662 SYS_FUTEX => { 663 let uaddr = VirtAddr::new(args[0]); 664 let operation = FutexFlag::from_bits(args[1] as u32).ok_or(SystemError::ENOSYS)?; 665 let val = args[2] as u32; 666 let utime = args[3]; 667 let uaddr2 = VirtAddr::new(args[4]); 668 let val3 = args[5] as u32; 669 670 verify_area(uaddr, core::mem::size_of::<u32>())?; 671 verify_area(uaddr2, core::mem::size_of::<u32>())?; 672 673 let mut timespec = None; 674 if utime != 0 && operation.contains(FutexFlag::FLAGS_HAS_TIMEOUT) { 675 let reader = UserBufferReader::new( 676 utime as *const TimeSpec, 677 core::mem::size_of::<TimeSpec>(), 678 true, 679 )?; 680 681 timespec = Some(*reader.read_one_from_user::<TimeSpec>(0)?); 682 } 683 684 Self::do_futex(uaddr, operation, val, timespec, uaddr2, utime as u32, val3) 685 } 686 687 SYS_READV => Self::readv(args[0] as i32, args[1], args[2]), 688 SYS_WRITEV => Self::writev(args[0] as i32, args[1], args[2]), 689 690 SYS_SET_TID_ADDRESS => Self::set_tid_address(args[0]), 691 692 #[cfg(target_arch = "x86_64")] 693 SYS_LSTAT => { 694 let path = args[0] as *const u8; 695 let kstat = args[1] as *mut PosixKstat; 696 Self::lstat(path, kstat) 697 } 698 699 #[cfg(target_arch = "x86_64")] 700 SYS_STAT => { 701 let path = args[0] as *const u8; 702 let kstat = args[1] as *mut PosixKstat; 703 Self::stat(path, kstat) 704 } 705 706 SYS_EPOLL_CREATE => Self::epoll_create(args[0] as i32), 707 SYS_EPOLL_CREATE1 => Self::epoll_create1(args[0]), 708 709 SYS_EPOLL_CTL => Self::epoll_ctl( 710 args[0] as i32, 711 args[1], 712 args[2] as i32, 713 VirtAddr::new(args[3]), 714 ), 715 716 SYS_EPOLL_WAIT => Self::epoll_wait( 717 args[0] as i32, 718 VirtAddr::new(args[1]), 719 args[2] as i32, 720 args[3] as i32, 721 ), 722 723 SYS_EPOLL_PWAIT => { 724 let epfd = args[0] as i32; 725 let epoll_event = VirtAddr::new(args[1]); 726 let max_events = args[2] as i32; 727 let timespec = args[3] as i32; 728 let sigmask_addr = args[4] as *mut SigSet; 729 730 if sigmask_addr.is_null() { 731 return Self::epoll_wait(epfd, epoll_event, max_events, timespec); 732 } 733 let sigmask_reader = 734 UserBufferReader::new(sigmask_addr, core::mem::size_of::<SigSet>(), true)?; 735 let mut sigmask = *sigmask_reader.read_one_from_user::<SigSet>(0)?; 736 737 Self::epoll_pwait( 738 args[0] as i32, 739 VirtAddr::new(args[1]), 740 args[2] as i32, 741 args[3] as i32, 742 &mut sigmask, 743 ) 744 } 745 746 // 目前为了适配musl-libc,以下系统调用先这样写着 747 SYS_GETRANDOM => { 748 let flags = GRandFlags::from_bits(args[2] as u8).ok_or(SystemError::EINVAL)?; 749 Self::get_random(args[0] as *mut u8, args[1], flags) 750 } 751 752 SYS_SOCKETPAIR => { 753 let mut user_buffer_writer = UserBufferWriter::new( 754 args[3] as *mut c_int, 755 core::mem::size_of::<[c_int; 2]>(), 756 frame.from_user(), 757 )?; 758 let fds = user_buffer_writer.buffer::<i32>(0)?; 759 Self::socketpair(args[0], args[1], args[2], fds) 760 } 761 762 #[cfg(target_arch = "x86_64")] 763 SYS_POLL => { 764 kwarn!("SYS_POLL has not yet been implemented"); 765 Ok(0) 766 } 767 768 SYS_SETPGID => { 769 kwarn!("SYS_SETPGID has not yet been implemented"); 770 Ok(0) 771 } 772 773 SYS_RT_SIGPROCMASK => { 774 kwarn!("SYS_RT_SIGPROCMASK has not yet been implemented"); 775 Ok(0) 776 } 777 778 SYS_TKILL => { 779 kwarn!("SYS_TKILL has not yet been implemented"); 780 Ok(0) 781 } 782 783 SYS_SIGALTSTACK => { 784 kwarn!("SYS_SIGALTSTACK has not yet been implemented"); 785 Ok(0) 786 } 787 788 SYS_EXIT_GROUP => { 789 kwarn!("SYS_EXIT_GROUP has not yet been implemented"); 790 Ok(0) 791 } 792 793 SYS_MADVISE => { 794 // 这个太吵了，总是打印，先注释掉 795 // kwarn!("SYS_MADVISE has not yet been implemented"); 796 Ok(0) 797 } 798 SYS_GETTID => Self::gettid().map(|tid| tid.into()), 799 SYS_GETUID => Self::getuid(), 800 801 SYS_SYSLOG => { 802 let syslog_action_type = args[0]; 803 let buf_vaddr = args[1]; 804 let len = args[2]; 805 let from_user = frame.from_user(); 806 let mut user_buffer_writer = 807 UserBufferWriter::new(buf_vaddr as *mut u8, len, from_user)?; 808 809 let user_buf = user_buffer_writer.buffer(0)?; 810 Self::do_syslog(syslog_action_type, user_buf, len) 811 } 812 813 SYS_GETGID => Self::getgid(), 814 SYS_SETUID => { 815 kwarn!("SYS_SETUID has not yet been implemented"); 816 Ok(0) 817 } 818 SYS_SETGID => { 819 kwarn!("SYS_SETGID has not yet been implemented"); 820 Ok(0) 821 } 822 SYS_GETEUID => Self::geteuid(), 823 SYS_GETEGID => Self::getegid(), 824 SYS_GETRUSAGE => { 825 let who = args[0] as c_int; 826 let rusage = args[1] as *mut RUsage; 827 Self::get_rusage(who, rusage) 828 } 829 830 #[cfg(target_arch = "x86_64")] 831 SYS_READLINK => { 832 let path = args[0] as *const u8; 833 let buf = args[1] as *mut u8; 834 let bufsiz = args[2]; 835 Self::readlink(path, buf, bufsiz) 836 } 837 838 SYS_READLINKAT => { 839 let dirfd = args[0] as i32; 840 let path = args[1] as *const u8; 841 let buf = args[2] as *mut u8; 842 let bufsiz = args[3]; 843 Self::readlink_at(dirfd, path, buf, bufsiz) 844 } 845 846 SYS_PRLIMIT64 => { 847 let pid = args[0]; 848 let pid = Pid::new(pid); 849 let resource = args[1]; 850 let new_limit = args[2] as *const RLimit64; 851 let old_limit = args[3] as *mut RLimit64; 852 853 Self::prlimit64(pid, resource, new_limit, old_limit) 854 } 855 856 #[cfg(target_arch = "x86_64")] 857 SYS_ACCESS => { 858 let pathname = args[0] as *const u8; 859 let mode = args[1] as u32; 860 Self::access(pathname, mode) 861 } 862 863 SYS_FACCESSAT => { 864 let dirfd = args[0] as i32; 865 let pathname = args[1] as *const u8; 866 let mode = args[2] as u32; 867 Self::faccessat2(dirfd, pathname, mode, 0) 868 } 869 870 SYS_FACCESSAT2 => { 871 let dirfd = args[0] as i32; 872 let pathname = args[1] as *const u8; 873 let mode = args[2] as u32; 874 let flags = args[3] as u32; 875 Self::faccessat2(dirfd, pathname, mode, flags) 876 } 877 878 SYS_CLOCK_GETTIME => { 879 let clockid = args[0] as i32; 880 let timespec = args[1] as *mut TimeSpec; 881 Self::clock_gettime(clockid, timespec) 882 } 883 884 SYS_SYSINFO => { 885 let info = args[0] as *mut SysInfo; 886 Self::sysinfo(info) 887 } 888 889 SYS_UMASK => { 890 let mask = args[0] as u32; 891 Self::umask(mask) 892 } 893 894 SYS_FCHOWN => { 895 kwarn!("SYS_FCHOWN has not yet been implemented"); 896 Ok(0) 897 } 898 899 SYS_FSYNC => { 900 kwarn!("SYS_FSYNC has not yet been implemented"); 901 Ok(0) 902 } 903 904 #[cfg(target_arch = "x86_64")] 905 SYS_CHMOD => { 906 let pathname = args[0] as *const u8; 907 let mode = args[1] as u32; 908 Self::chmod(pathname, mode) 909 } 910 SYS_FCHMOD => { 911 let fd = args[0] as i32; 912 let mode = args[1] as u32; 913 Self::fchmod(fd, mode) 914 } 915 SYS_FCHMODAT => { 916 let dirfd = args[0] as i32; 917 let pathname = args[1] as *const u8; 918 let mode = args[2] as u32; 919 Self::fchmodat(dirfd, pathname, mode) 920 } 921 922 SYS_SCHED_GETAFFINITY => { 923 // todo: 这个系统调用还没有实现 924 925 Err(SystemError::ENOSYS) 926 } 927 928 #[cfg(target_arch = "x86_64")] 929 SYS_GETRLIMIT => { 930 let resource = args[0]; 931 let rlimit = args[1] as *mut RLimit64; 932 933 Self::prlimit64( 934 ProcessManager::current_pcb().pid(), 935 resource, 936 core::ptr::null::<RLimit64>(), 937 rlimit, 938 ) 939 } 940 941 SYS_FADVISE64 => { 942 // todo: 这个系统调用还没有实现 943 944 Err(SystemError::ENOSYS) 945 } 946 947 SYS_MOUNT => { 948 let source = args[0] as *const u8; 949 let target = args[1] as *const u8; 950 let filesystemtype = args[2] as *const u8; 951 return Self::mount(source, target, filesystemtype, 0, null()); 952 } 953 SYS_NEWFSTATAT => { 954 // todo: 这个系统调用还没有实现 955 956 Err(SystemError::ENOSYS) 957 } 958 959 SYS_SCHED_YIELD => Self::sched_yield(), 960 SYS_UNAME => { 961 let name = args[0] as *mut PosixOldUtsName; 962 Self::uname(name) 963 } 964 965 _ => panic!("Unsupported syscall ID: {}", syscall_num), 966 }; 967 968 return r; 969 } 970 971 pub fn put_string( 972 s: *const u8, 973 front_color: u32, 974 back_color: u32, 975 ) -> Result<usize, SystemError> { 976 // todo: 删除这个系统调用 977 let s = check_and_clone_cstr(s, Some(4096))?; 978 let fr = (front_color & 0x00ff0000) >> 16; 979 let fg = (front_color & 0x0000ff00) >> 8; 980 let fb = front_color & 0x000000ff; 981 let br = (back_color & 0x00ff0000) >> 16; 982 let bg = (back_color & 0x0000ff00) >> 8; 983 let bb = back_color & 0x000000ff; 984 print!("\x1B[38;2;{fr};{fg};{fb};48;2;{br};{bg};{bb}m{s}\x1B[0m"); 985 return Ok(s.len()); 986 } 987 988 pub fn reboot() -> Result<usize, SystemError> { 989 unsafe { cpu_reset() }; 990 } 991 } 992