feat: tls

Author: AsakuraMizu

api/src/imp/task/clone.rs

@@ -8,16 +8,12 @@ use axsync::Mutex;
 use axtask::{TaskExtRef, current};
 use bitflags::bitflags;
 use linux_raw_sys::general::*;
-use macro_rules_attribute::apply;
 use starry_core::{
     mm::copy_from_kernel,
     task::{ProcessData, TaskExt, ThreadData, add_thread_to_table, new_user_task},
 };
 
-use crate::{
-    ptr::{PtrWrapper, UserPtr},
-    syscall_instrument,
-};
+use crate::ptr::{PtrWrapper, UserPtr};
 
 bitflags! {
     /// Options for use with [`sys_clone`].
@@ -82,13 +78,14 @@ bitflags! {
     }
 }
 
-#[apply(syscall_instrument)]
 pub fn sys_clone(
+    tf: &TrapFrame,
     flags: u32,
     stack: usize,
     parent_tid: usize,
-    child_tid: usize,
+    #[cfg(any(target_arch = "x86_64", target_arch = "loongarch64"))] child_tid: usize,
     tls: usize,
+    #[cfg(not(any(target_arch = "x86_64", target_arch = "loongarch64")))] child_tid: usize,
 ) -> LinuxResult<isize> {
     const FLAG_MASK: u32 = 0xff;
     let exit_signal = flags & FLAG_MASK;
@@ -103,23 +100,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 +114,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 +200,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,38 @@ 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,
+    code: i32,
+    addr: usize,
+) -> LinuxResult<isize> {
+    use crate::ptr::{PtrWrapper, UserPtr};
+
+    let code = ArchPrctlCode::try_from(code).map_err(|_| axerrno::LinuxError::EINVAL)?;
+    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();
@@ -37,17 +37,16 @@ fn handle_syscall(tf: &TrapFrame, syscall_num: usize) -> isize {
         Sysno::dup => sys_dup(tf.arg0() as _),
         Sysno::dup3 => sys_dup3(tf.arg0() as _, tf.arg1() as _),
         Sysno::fcntl => sys_fcntl(tf.arg0() as _, tf.arg1() as _, tf.arg2() as _),
-        Sysno::clone => {
-            let (child_tid, tls) = if cfg!(any(target_arch = "x86_64", target_arch = "loongarch64"))
-            {
-                (tf.arg3() as _, tf.arg4() as _)
-            } else {
-                (tf.arg4() as _, tf.arg3() as _)
-            };
-            sys_clone(tf.arg0() as _, tf.arg1() as _, tf.arg2(), child_tid, tls)
-        }
+        Sysno::clone => sys_clone(
+            tf,
+            tf.arg0() as _,
+            tf.arg1() as _,
+            tf.arg2(),
+            tf.arg3(),
+            tf.arg4(),
+        ),
         #[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 +106,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, tf.arg0() as _, tf.arg1() as _),
         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(),