src/platform/redox/ptrace.rs

@@ -4,14 +4,23 @@
 //! we are NOT going to bend our API for the sake of
 //! compatibility. So, this module will be a hellhole.
 
-use super::super::{errno, types::*, Pal, PalPtrace, PalSignal, Sys};
+use super::super::{types::*, Pal, PalPtrace, PalSignal, Sys, ERRNO};
+#[cfg(target_arch = "aarch64")]
+use crate::header::arch_aarch64_user::user_regs_struct;
+#[cfg(target_arch = "x86_64")]
+use crate::header::arch_x64_user::user_regs_struct;
 use crate::{
-    c_str::CString,
+    c_str::{CStr, CString},
+    error::Errno,
     fs::File,
-    header::{errno as errnoh, fcntl, signal, sys_ptrace, sys_user::user_regs_struct},
+    header::{
+        errno::{self as errnoh, EIO},
+        fcntl, signal, sys_ptrace,
+    },
     io::{self, prelude::*},
-    sync::{Mutex, Once},
+    sync::Mutex,
 };
+
 use alloc::collections::{btree_map::Entry, BTreeMap};
 use core::mem;
 use syscall;
@@ -34,14 +43,25 @@ impl State {
     }
 }
 
-static STATE: Once<State> = Once::new();
+#[thread_local]
+static mut STATE: Option<State> = None;
 
 pub fn init_state() -> &'static State {
-    STATE.call_once(|| State::new())
+    // Safe due to STATE being thread_local
+    unsafe {
+        if STATE.is_none() {
+            STATE = Some(State::new())
+        }
+        STATE.as_ref().unwrap()
+    }
 }
 pub fn is_traceme(pid: pid_t) -> bool {
+    // Skip special PIDs (<=0)
+    if pid <= 0 {
+        return false;
+    }
     File::open(
-        &CString::new(format!("chan:ptrace-relibc/{}/traceme", pid)).unwrap(),
+        CStr::borrow(&CString::new(format!("/scheme/chan/ptrace-relibc/{}/traceme", pid)).unwrap()),
         fcntl::O_PATH,
     )
     .is_ok()
@@ -58,26 +78,28 @@ pub fn get_session(
                 Ok(entry.insert(Session {
                     first: true,
                     tracer: File::open(
-                        &CString::new(format!("proc:{}/trace", pid)).unwrap(),
-                        NEW_FLAGS | fcntl::O_NONBLOCK,
+                        CStr::borrow(&CString::new(format!("/scheme/proc/{}/trace", pid)).unwrap()),
+                        NEW_FLAGS,
                     )?,
                     mem: File::open(
-                        &CString::new(format!("proc:{}/mem", pid)).unwrap(),
+                        CStr::borrow(&CString::new(format!("/scheme/proc/{}/mem", pid)).unwrap()),
                         NEW_FLAGS,
                     )?,
                     regs: File::open(
-                        &CString::new(format!("proc:{}/regs/int", pid)).unwrap(),
+                        CStr::borrow(
+                            &CString::new(format!("/scheme/proc/{}/regs/int", pid)).unwrap(),
+                        ),
                         NEW_FLAGS,
                     )?,
                     fpregs: File::open(
-                        &CString::new(format!("proc:{}/regs/float", pid)).unwrap(),
+                        CStr::borrow(
+                            &CString::new(format!("/scheme/proc/{}/regs/float", pid)).unwrap(),
+                        ),
                         NEW_FLAGS,
                     )?,
                 }))
             } else {
-                unsafe {
-                    errno = errnoh::ESRCH;
-                }
+                ERRNO.set(errnoh::ESRCH);
                 Err(io::last_os_error())
             }
         }
@@ -85,7 +107,30 @@ pub fn get_session(
     }
 }
 
-fn inner_ptrace(
+#[cfg(target_arch = "aarch64")]
+unsafe fn inner_ptrace(
+    request: c_int,
+    pid: pid_t,
+    addr: *mut c_void,
+    data: *mut c_void,
+) -> io::Result<c_int> {
+    //TODO: aarch64
+    unimplemented!("inner_ptrace not implemented on aarch64");
+}
+
+#[cfg(target_arch = "x86")]
+unsafe fn inner_ptrace(
+    request: c_int,
+    pid: pid_t,
+    addr: *mut c_void,
+    data: *mut c_void,
+) -> io::Result<c_int> {
+    //TODO: x86
+    unimplemented!("inner_ptrace not implemented on x86");
+}
+
+#[cfg(target_arch = "x86_64")]
+unsafe fn inner_ptrace(
     request: c_int,
     pid: pid_t,
     addr: *mut c_void,
@@ -97,7 +142,9 @@ fn inner_ptrace(
         // Mark this child as traced, parent will check for this marker file
         let pid = Sys::getpid();
         mem::forget(File::open(
-            &CString::new(format!("chan:ptrace-relibc/{}/traceme", pid)).unwrap(),
+            CStr::borrow(
+                &CString::new(format!("/scheme/chan/ptrace-relibc/{}/traceme", pid)).unwrap(),
+            ),
             fcntl::O_CREAT | fcntl::O_PATH | fcntl::O_EXCL,
         )?);
         return Ok(0);
@@ -166,8 +213,8 @@ fn inner_ptrace(
                 gs_base: 0, // gs_base: redox_regs.gs_base as _,
                 ds: 0,      // ds: redox_regs.ds as _,
                 es: 0,      // es: redox_regs.es as _,
-                fs: redox_regs.fs as _,
-                gs: 0, // gs: redox_regs.gs as _,
+                fs: 0,      // fs: redox_regs.fs as _,
+                gs: 0,      // gs: redox_regs.gs as _,
             };
             Ok(0)
         }
@@ -199,7 +246,7 @@ fn inner_ptrace(
                 // gs_base: c_regs.gs_base as _,
                 // ds: c_regs.ds as _,
                 // es: c_regs.es as _,
-                fs: c_regs.fs as _,
+                // fs: c_regs.fs as _,
                 // gs: c_regs.gs as _,
             };
             (&mut &session.regs).write(&redox_regs)?;
@@ -209,8 +256,25 @@ fn inner_ptrace(
     }
 }
 
+#[cfg(target_arch = "riscv64")]
+fn inner_ptrace(
+    request: c_int,
+    pid: pid_t,
+    addr: *mut c_void,
+    data: *mut c_void,
+) -> io::Result<c_int> {
+    //TODO: riscv64
+    unimplemented!("inner_ptrace not implemented on riscv64");
+}
+
 impl PalPtrace for Sys {
-    fn ptrace(request: c_int, pid: pid_t, addr: *mut c_void, data: *mut c_void) -> c_int {
-        inner_ptrace(request, pid, addr, data).unwrap_or(-1)
+    unsafe fn ptrace(
+        request: c_int,
+        pid: pid_t,
+        addr: *mut c_void,
+        data: *mut c_void,
+    ) -> Result<c_int, Errno> {
+        inner_ptrace(request, pid, addr, data)
+            .map_err(|err| Errno(err.raw_os_error().unwrap_or(EIO)))
     }
 }