fix: tls

Author: AsakuraMizu

api/src/imp/task/clone.rs

@@ -84,6 +84,7 @@ bitflags! {
 
 #[apply(syscall_instrument)]
 pub fn sys_clone(
+    tf: &TrapFrame,
     flags: u32,
     stack: usize,
     parent_tid: usize,
@@ -103,23 +104,12 @@ pub fn sys_clone(
         return Err(LinuxError::EINVAL);
     }
 
-    let curr = current();
-
-    let trap_frame = read_trapframe_from_kstack(curr.get_kernel_stack_top().unwrap());
-    let mut new_uctx = UspaceContext::from(&trap_frame);
+    let mut new_uctx = UspaceContext::from(tf);
     if stack != 0 {
         new_uctx.set_sp(stack);
     }
-    // Skip current instruction
-    // FIXME: we should do this in arceos before calling `handle_syscall`.
-    // See: https://github.com/oscomp/arceos/commit/13ff3f58bd825c37ea5eef3393a4f8c0bb5b4f41
-    #[cfg(any(target_arch = "riscv64", target_arch = "loongarch64"))]
-    {
-        let new_uctx_ip = new_uctx.ip();
-        new_uctx.set_ip(new_uctx_ip + 4);
-    }
     if flags.contains(CloneFlags::SETTLS) {
-        warn!("sys_clone: CLONE_SETTLS is not supported yet");
+        new_uctx.set_tls(tls);
     }
     new_uctx.set_retval(0);
 
@@ -128,13 +118,9 @@ pub fn sys_clone(
     } else {
         None
     };
-    let mut new_task = new_user_task(curr.name(), new_uctx, set_child_tid);
 
-    // FIXME: remove this when we fix the tls issue
-    #[cfg(any(target_arch = "x86_64", target_arch = "aarch64"))]
-    new_task
-        .ctx_mut()
-        .set_tls(axhal::arch::read_thread_pointer().into());
+    let curr = current();
+    let mut new_task = new_user_task(curr.name(), new_uctx, set_child_tid);
 
     let tid = new_task.id().as_u64() as Pid;
     if flags.contains(CloneFlags::PARENT_SETTID) {
@@ -218,12 +204,6 @@ pub fn sys_clone(
     Ok(tid as _)
 }
 
-fn read_trapframe_from_kstack(kstack_top: usize) -> TrapFrame {
-    let trap_frame_size = core::mem::size_of::<TrapFrame>();
-    let trap_frame_ptr = (kstack_top - trap_frame_size) as *mut TrapFrame;
-    unsafe { *trap_frame_ptr }
-}
-
-pub fn sys_fork() -> LinuxResult<isize> {
-    sys_clone(SIGCHLD, 0, 0, 0, 0)
+pub fn sys_fork(tf: &TrapFrame) -> LinuxResult<isize> {
+    sys_clone(tf, SIGCHLD, 0, 0, 0, 0)
 }

api/src/imp/task/thread.rs

@@ -61,33 +61,36 @@ pub fn sys_set_tid_address(clear_child_tid: usize) -> LinuxResult<isize> {
 
 #[cfg(target_arch = "x86_64")]
 #[apply(syscall_instrument)]
-pub fn sys_arch_prctl(code: i32, addr: crate::ptr::UserPtr<u64>) -> LinuxResult<isize> {
-    use crate::ptr::PtrWrapper;
-    match ArchPrctlCode::try_from(code).map_err(|_| axerrno::LinuxError::EINVAL)? {
+pub fn sys_arch_prctl(tf: &mut axhal::arch::TrapFrame) -> LinuxResult<isize> {
+    use crate::ptr::{PtrWrapper, UserPtr};
+
+    let code =
+        ArchPrctlCode::try_from(tf.arg0() as i32).map_err(|_| axerrno::LinuxError::EINVAL)?;
+    let addr = tf.arg1();
+    debug!("sys_arch_prctl: code = {:?}, addr = {:#x}", code, addr);
+
+    match code {
         // According to Linux implementation, SetFs & SetGs does not return
         // error at all
-        ArchPrctlCode::SetFs => {
+        ArchPrctlCode::GetFs => {
             unsafe {
-                axhal::arch::write_thread_pointer(addr.address().as_usize());
+                *UserPtr::from(addr).get()? = tf.tls();
             }
             Ok(0)
         }
-        ArchPrctlCode::SetGs => {
-            unsafe {
-                x86::msr::wrmsr(x86::msr::IA32_KERNEL_GSBASE, addr.address().as_usize() as _);
-            }
+        ArchPrctlCode::SetFs => {
+            tf.set_tls(addr);
             Ok(0)
         }
-        ArchPrctlCode::GetFs => {
+        ArchPrctlCode::GetGs => {
             unsafe {
-                *addr.get()? = axhal::arch::read_thread_pointer() as u64;
+                *UserPtr::from(addr).get()? = x86::msr::rdmsr(x86::msr::IA32_KERNEL_GSBASE);
             }
             Ok(0)
         }
-
-        ArchPrctlCode::GetGs => {
+        ArchPrctlCode::SetGs => {
             unsafe {
-                *addr.get()? = x86::msr::rdmsr(x86::msr::IA32_KERNEL_GSBASE);
+                x86::msr::wrmsr(x86::msr::IA32_KERNEL_GSBASE, addr as _);
             }
             Ok(0)
         }

src/syscall.rs

@@ -8,7 +8,7 @@ use starry_core::task::{time_stat_from_kernel_to_user, time_stat_from_user_to_ke
 use syscalls::Sysno;
 
 #[register_trap_handler(SYSCALL)]
-fn handle_syscall(tf: &TrapFrame, syscall_num: usize) -> isize {
+fn handle_syscall(tf: &mut TrapFrame, syscall_num: usize) -> isize {
     let sysno = Sysno::from(syscall_num as u32);
     info!("Syscall {}", sysno);
     time_stat_from_user_to_kernel();
@@ -44,10 +44,17 @@ fn handle_syscall(tf: &TrapFrame, syscall_num: usize) -> isize {
             } else {
                 (tf.arg4() as _, tf.arg3() as _)
             };
-            sys_clone(tf.arg0() as _, tf.arg1() as _, tf.arg2(), child_tid, tls)
+            sys_clone(
+                tf,
+                tf.arg0() as _,
+                tf.arg1() as _,
+                tf.arg2(),
+                child_tid,
+                tls,
+            )
         }
         #[cfg(target_arch = "x86_64")]
-        Sysno::fork => sys_fork(),
+        Sysno::fork => sys_fork(tf),
         Sysno::wait4 => sys_waitpid(tf.arg0() as _, tf.arg1().into(), tf.arg2() as _),
         Sysno::pipe2 => sys_pipe2(tf.arg0().into()),
         Sysno::close => sys_close(tf.arg0() as _),
@@ -107,7 +114,7 @@ fn handle_syscall(tf: &TrapFrame, syscall_num: usize) -> isize {
         Sysno::times => sys_times(tf.arg0().into()),
         Sysno::brk => sys_brk(tf.arg0() as _),
         #[cfg(target_arch = "x86_64")]
-        Sysno::arch_prctl => sys_arch_prctl(tf.arg0() as _, tf.arg1().into()),
+        Sysno::arch_prctl => sys_arch_prctl(tf),
         Sysno::set_tid_address => sys_set_tid_address(tf.arg0()),
         Sysno::clock_gettime => sys_clock_gettime(tf.arg0() as _, tf.arg1().into()),
         Sysno::getuid => sys_getuid(),