feat: basic support for x86_64

Co-authored-by: eternalcomet <mydragonos@outlook.com>

Author: AsakuraMizu

Cargo.lock

@@ -142,11 +142,12 @@ optional = true
 
 [patch.crates-io]
 axbacktrace = { git = "https://github.com/Starry-OS/axbacktrace.git", rev = "09c22b6" }
-axcpu = { git = "https://github.com/Starry-OS/axcpu.git", rev = "53455db" }
+axcpu = { git = "https://github.com/Starry-OS/axcpu.git", rev = "3349bfd" }
 axerrno = { git = "https://github.com/Starry-OS/axerrno.git", rev = "58be232" }
 axfs-ng-vfs = { git = "https://github.com/Starry-OS/axfs-ng-vfs.git", rev = "6cf8893" }
 axio = { git = "https://github.com/Starry-OS/axio.git", rev = "ebb0c6b" }
 axplat = { git = "https://github.com/Starry-OS/axplat_crates.git", rev = "243fdc9" }
+axplat-x86-pc = { git = "https://github.com/Starry-OS/axplat_crates.git", rev = "243fdc9" }
 axplat-aarch64-qemu-virt = { git = "https://github.com/Starry-OS/axplat_crates.git", rev = "243fdc9" }
 axplat-riscv64-qemu-virt = { git = "https://github.com/Starry-OS/axplat_crates.git", rev = "243fdc9" }
 axplat-loongarch64-qemu-virt = { git = "https://github.com/Starry-OS/axplat_crates.git", rev = "243fdc9" }

Cargo.toml

@@ -323,12 +323,12 @@ pub fn sys_readlinkat(
 }
 
 #[cfg(target_arch = "x86_64")]
-pub fn sys_chown(path: *const c_char, uid: u32, gid: u32) -> AxResult<isize> {
+pub fn sys_chown(path: *const c_char, uid: i32, gid: i32) -> AxResult<isize> {
     sys_fchownat(AT_FDCWD, path, uid, gid, 0)
 }
 
 #[cfg(target_arch = "x86_64")]
-pub fn sys_lchown(path: *const c_char, uid: u32, gid: u32) -> AxResult<isize> {
+pub fn sys_lchown(path: *const c_char, uid: i32, gid: i32) -> AxResult<isize> {
     use linux_raw_sys::general::AT_SYMLINK_NOFOLLOW;
     sys_fchownat(AT_FDCWD, path, uid, gid, AT_SYMLINK_NOFOLLOW)
 }

api/src/syscall/fs/ctl.rs

@@ -34,10 +34,10 @@ pub fn sys_fstat(fd: i32, statbuf: *mut stat) -> AxResult<isize> {
 ///
 /// Return 0 if success.
 #[cfg(target_arch = "x86_64")]
-pub fn sys_lstat(path: *const c_char, statbuf: UserPtr<stat>) -> AxResult<isize> {
-    use linux_raw_sys::general::{AT_FDCWD, AT_SYMLINK_FOLLOW};
+pub fn sys_lstat(path: *const c_char, statbuf: *mut stat) -> AxResult<isize> {
+    use linux_raw_sys::general::{AT_FDCWD, AT_SYMLINK_NOFOLLOW};
 
-    sys_fstatat(AT_FDCWD, path, statbuf, AT_SYMLINK_FOLLOW)
+    sys_fstatat(AT_FDCWD, path, statbuf, AT_SYMLINK_NOFOLLOW)
 }
 
 pub fn sys_fstatat(

api/src/syscall/fs/stat.rs

@@ -75,6 +75,10 @@ pub fn handle_syscall(uctx: &mut UserContext) {
         Sysno::syncfs => sys_syncfs(uctx.arg0() as _),
 
         // file ops
+        #[cfg(target_arch = "x86_64")]
+        Sysno::chown => sys_chown(uctx.arg0() as _, uctx.arg1() as _, uctx.arg2() as _),
+        #[cfg(target_arch = "x86_64")]
+        Sysno::lchown => sys_lchown(uctx.arg0() as _, uctx.arg1() as _, uctx.arg2() as _),
         Sysno::fchown => sys_fchown(uctx.arg0() as _, uctx.arg1() as _, uctx.arg2() as _),
         Sysno::fchownat => sys_fchownat(
             uctx.arg0() as _,
@@ -427,7 +431,7 @@ pub fn handle_syscall(uctx: &mut UserContext) {
         Sysno::fork => sys_fork(uctx),
         Sysno::exit => sys_exit(uctx.arg0() as _),
         Sysno::exit_group => sys_exit_group(uctx.arg0() as _),
-        Sysno::wait4 => sys_waitpid(uctx, uctx.arg0() as _, uctx.arg1() as _, uctx.arg2() as _),
+        Sysno::wait4 => sys_waitpid(uctx.arg0() as _, uctx.arg1() as _, uctx.arg2() as _),
         Sysno::getsid => sys_getsid(uctx.arg0() as _),
         Sysno::setsid => sys_setsid(),
         Sysno::getpgid => sys_getpgid(uctx.arg0() as _),

api/src/syscall/mod.rs

@@ -54,38 +54,35 @@ pub fn sys_set_tid_address(clear_child_tid: usize) -> AxResult<isize> {
 
 #[cfg(target_arch = "x86_64")]
 pub fn sys_arch_prctl(
-    tf: &mut axhal::context::TrapFrame,
+    uctx: &mut axhal::uspace::UserContext,
     code: i32,
     addr: usize,
 ) -> AxResult<isize> {
     use starry_vm::VmMutPtr;
 
-    let code = ArchPrctlCode::try_from(code).map_err(|_| axerrno::AxError::EINVAL)?;
+    let code = ArchPrctlCode::try_from(code).map_err(|_| AxError::InvalidInput)?;
     debug!("sys_arch_prctl: code = {:?}, addr = {:#x}", code, addr);
 
     match code {
         // According to Linux implementation, SetFs & SetGs does not return
         // error at all
         ArchPrctlCode::GetFs => {
-            (addr as *mut usize).vm_write(tf.tls())?;
+            (addr as *mut usize).vm_write(uctx.tls())?;
             Ok(0)
         }
         ArchPrctlCode::SetFs => {
-            tf.set_tls(addr);
+            uctx.set_tls(addr);
             Ok(0)
         }
         ArchPrctlCode::GetGs => {
-            (addr as *mut usize)
-                .vm_write(unsafe { x86::msr::rdmsr(x86::msr::IA32_KERNEL_GSBASE) })?;
+            (addr as *mut usize).vm_write(uctx.gs_base as _)?;
             Ok(0)
         }
         ArchPrctlCode::SetGs => {
-            unsafe {
-                x86::msr::wrmsr(x86::msr::IA32_KERNEL_GSBASE, addr as _);
-            }
+            uctx.gs_base = addr as _;
             Ok(0)
         }
         ArchPrctlCode::GetCpuid => Ok(0),
-        ArchPrctlCode::SetCpuid => Err(axerrno::AxError::ENODEV),
+        ArchPrctlCode::SetCpuid => Err(axerrno::AxError::NoSuchDevice),
     }
 }

api/src/syscall/task/thread.rs

@@ -2,7 +2,6 @@ use alloc::vec::Vec;
 use core::{future::poll_fn, task::Poll};
 
 use axerrno::{AxError, AxResult, LinuxError};
-use axhal::uspace::UserContext;
 use axtask::{
     current,
     future::{block_on, interruptible},
@@ -15,8 +14,6 @@ use starry_core::task::AsThread;
 use starry_process::{Pid, Process};
 use starry_vm::{VmMutPtr, VmPtr};
 
-use crate::signal::check_signals;
-
 bitflags! {
     #[derive(Debug)]
     struct WaitOptions: u32 {
@@ -62,12 +59,7 @@ impl WaitPid {
     }
 }
 
-pub fn sys_waitpid(
-    uctx: &mut UserContext,
-    pid: i32,
-    exit_code: *mut i32,
-    options: u32,
-) -> AxResult<isize> {
+pub fn sys_waitpid(pid: i32, exit_code: *mut i32, options: u32) -> AxResult<isize> {
     let options = WaitOptions::from_bits_truncate(options);
     info!("sys_waitpid <= pid: {:?}, options: {:?}", pid, options);
 
@@ -112,23 +104,13 @@ pub fn sys_waitpid(
         }
     };
 
-    let result = block_on(interruptible(poll_fn(|cx| {
+    block_on(interruptible(poll_fn(|cx| {
         match check_children().transpose() {
             Some(res) => Poll::Ready(res),
             None => {
                 proc_data.child_exit_event.register(cx.waker());
                 Poll::Pending
             }
         }
-    })));
-    match result {
-        Ok(r) => r,
-        Err(_) => {
-            // FIXME: more general syscall RESTART
-            let ip = uctx.ip() - 4;
-            uctx.set_ip(ip);
-            while check_signals(curr.as_thread(), uctx, None) {}
-            Ok(0)
-        }
-    }
+    })))?
 }