initial ptrace

Author: arihant2math

etc/syscalls_linux_aarch64.md

@@ -117,7 +117,7 @@
 | 0x72 (114)  | clock_getres            | (const clockid_t which_clock, struct __kernel_timespec *tp)                                                                                | __arm64_sys_clock_getres            | false       |
 | 0x73 (115)  | clock_nanosleep         | (const clockid_t which_clock, int flags, const struct __kernel_timespec *rqtp, struct __kernel_timespec *rmtp)                             | __arm64_sys_clock_nanosleep         | false       |
 | 0x74 (116)  | syslog                  | (int type, char *buf, int len)                                                                                                             | __arm64_sys_syslog                  | false       |
-| 0x75 (117)  | ptrace                  | (long request, long pid, unsigned long addr, unsigned long data)                                                                           | __arm64_sys_ptrace                  | false       |
+| 0x75 (117)  | ptrace                  | (long request, long pid, unsigned long addr, unsigned long data)                                                                           | __arm64_sys_ptrace                  | partially   |
 | 0x76 (118)  | sched_setparam          | (pid_t pid, struct sched_param *param)                                                                                                     | __arm64_sys_sched_setparam          | false       |
 | 0x77 (119)  | sched_setscheduler      | (pid_t pid, int policy, struct sched_param *param)                                                                                         | __arm64_sys_sched_setscheduler      | false       |
 | 0x78 (120)  | sched_getscheduler      | (pid_t pid)                                                                                                                                | __arm64_sys_sched_getscheduler      | false       |

src/process/clone.rs

@@ -8,6 +8,7 @@ use crate::{
     sync::SpinLock,
 };
 use alloc::boxed::Box;
+use core::sync::atomic::AtomicBool;
 use bitflags::bitflags;
 use libkernel::memory::address::TUA;
 use libkernel::{
@@ -153,6 +154,7 @@ pub async fn sys_clone(
                 creds: SpinLock::new(creds),
                 state: Arc::new(SpinLock::new(TaskState::Runnable)),
                 last_cpu: SpinLock::new(CpuId::this()),
+                ptrace: AtomicBool::new(flags.contains(CloneFlags::CLONE_PTRACE) && current_task.ptrace.load(core::sync::atomic::Ordering::SeqCst)),
             }),
         }
     };

src/process/mod.rs

@@ -4,6 +4,7 @@ use alloc::{
     sync::{Arc, Weak},
 };
 use core::fmt::Display;
+use core::sync::atomic::AtomicBool;
 use creds::Credentials;
 use fd_table::FileDescriptorTable;
 use libkernel::{VirtualMemory, fs::Inode};
@@ -18,6 +19,7 @@ pub mod exec;
 pub mod exit;
 pub mod fd_table;
 pub mod owned;
+pub mod ptrace;
 pub mod sleep;
 pub mod thread_group;
 pub mod threading;
@@ -163,6 +165,7 @@ pub struct Task {
     pub fd_table: Arc<SpinLock<FileDescriptorTable>>,
     pub state: Arc<SpinLock<TaskState>>,
     pub last_cpu: SpinLock<CpuId>,
+    pub ptrace: AtomicBool
 }
 
 impl Task {

src/process/owned.rs

@@ -19,6 +19,7 @@ use crate::{
     sync::SpinLock,
 };
 use alloc::sync::Arc;
+use core::sync::atomic::AtomicBool;
 use libkernel::{
     VirtualMemory,
     fs::pathbuf::PathBuf,
@@ -75,6 +76,7 @@ impl OwnedTask {
             vm: Arc::new(SpinLock::new(vm)),
             fd_table: Arc::new(SpinLock::new(FileDescriptorTable::new())),
             last_cpu: SpinLock::new(CpuId::this()),
+            ptrace: AtomicBool::new(false),
         };
 
         Self {
@@ -102,6 +104,7 @@ impl OwnedTask {
             )),
             fd_table: Arc::new(SpinLock::new(FileDescriptorTable::new())),
             last_cpu: SpinLock::new(CpuId::this()),
+            ptrace: AtomicBool::new(false),
         };
 
         Self {

src/process/ptrace.rs

@@ -0,0 +1,38 @@
+use core::sync::atomic::Ordering;
+use libkernel::error::{KernelError, Result};
+use libkernel::memory::address::UA;
+use crate::process::Tid;
+use crate::sched::current::current_task_shared;
+
+#[repr(i32)]
+#[derive(Copy, Clone, Debug, PartialEq, Eq)]
+enum PtraceOperation {
+    TraceMe = 0,
+    PeekText = 1,
+    PeekData = 2,
+}
+
+impl TryFrom<i32> for PtraceOperation {
+    type Error = KernelError;
+
+    fn try_from(value: i32) -> Result<Self> {
+        match value {
+            0 => Ok(PtraceOperation::TraceMe),
+            1 => Ok(PtraceOperation::PeekText),
+            2 => Ok(PtraceOperation::PeekData),
+            // TODO: Should be EIO
+            _ => Err(KernelError::InvalidValue)
+        }
+    }
+}
+
+pub async fn sys_ptrace(op: i32, pid: Tid, addr: UA, data: UA) -> Result<usize> {
+    let op = PtraceOperation::try_from(op)?;
+    match op {
+        PtraceOperation::TraceMe => {
+            current_task_shared().ptrace.store(true, Ordering::SeqCst);
+            Ok(0)
+        }
+        _ => Err(KernelError::InvalidValue),
+    }
+}