Remove change I am faaairly certain I did NOT add :O

I'm guessing it's some issue after a rebase or something...

src/syscall/debug.rs

@@ -1,5 +1,4 @@
-use core::mem;
-use core::ops::Range;
+use core::{ascii, mem};
 use alloc::string::String;
 use alloc::vec::Vec;
 
@@ -8,47 +7,13 @@ use super::flag::*;
 use super::number::*;
 use super::validate::*;
 
-// Copied from std
-pub struct EscapeDefault {
-    range: Range<usize>,
-    data: [u8; 4],
-}
-
-pub fn escape_default(c: u8) -> EscapeDefault {
-    let (data, len) = match c {
-        b'\t' => ([b'\\', b't', 0, 0], 2),
-        b'\r' => ([b'\\', b'r', 0, 0], 2),
-        b'\n' => ([b'\\', b'n', 0, 0], 2),
-        b'\\' => ([b'\\', b'\\', 0, 0], 2),
-        b'\'' => ([b'\\', b'\'', 0, 0], 2),
-        b'"' => ([b'\\', b'"', 0, 0], 2),
-        b'\x20' ... b'\x7e' => ([c, 0, 0, 0], 1),
-        _ => ([b'\\', b'x', hexify(c >> 4), hexify(c & 0xf)], 4),
-    };
-
-    return EscapeDefault { range: (0.. len), data: data };
-
-    fn hexify(b: u8) -> u8 {
-        match b {
-            0 ... 9 => b'0' + b,
-            _ => b'a' + b - 10,
-        }
-    }
-}
-
-impl Iterator for EscapeDefault {
-    type Item = u8;
-    fn next(&mut self) -> Option<u8> { self.range.next().map(|i| self.data[i]) }
-    fn size_hint(&self) -> (usize, Option<usize>) { self.range.size_hint() }
-}
-
 struct ByteStr<'a>(&'a[u8]);
 
 impl<'a> ::core::fmt::Debug for ByteStr<'a> {
     fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
         write!(f, "\"")?;
         for i in self.0 {
-            for ch in escape_default(*i) {
+            for ch in ascii::escape_default(*i) {
                 write!(f, "{}", ch as char)?;
             }
         }

src/syscall/driver.rs

@@ -25,7 +25,8 @@ pub fn iopl(level: usize, stack: &mut SyscallStack) -> Result<usize> {
         return Err(Error::new(EINVAL));
     }
 
-    stack.rflags = (stack.rflags & !(3 << 12)) | ((level & 3) << 12);
+    let iret = &mut stack.interrupt_stack.iret;
+    iret.rflags = (iret.rflags & !(3 << 12)) | ((level & 3) << 12);
 
     Ok(0)
 }

src/syscall/process.rs

@@ -6,21 +6,21 @@ use core::{intrinsics, mem};
 use core::ops::DerefMut;
 use spin::Mutex;
 
+use crate::context::file::FileDescriptor;
+use crate::context::{ContextId, WaitpidKey};
+use crate::context;
+#[cfg(not(feature="doc"))]
+use crate::elf::{self, program_header};
+use crate::interrupt;
+use crate::ipi::{ipi, IpiKind, IpiTarget};
 use crate::memory::allocate_frames;
-use crate::paging::{ActivePageTable, InactivePageTable, Page, VirtualAddress, PAGE_SIZE};
 use crate::paging::entry::EntryFlags;
 use crate::paging::mapper::MapperFlushAll;
 use crate::paging::temporary_page::TemporaryPage;
-use crate::start::usermode;
-use crate::interrupt;
-use crate::context;
-use crate::context::{ContextId, WaitpidKey};
-use crate::context::file::FileDescriptor;
-#[cfg(not(feature="doc"))]
-use crate::elf::{self, program_header};
-use crate::ipi::{ipi, IpiKind, IpiTarget};
+use crate::paging::{ActivePageTable, InactivePageTable, Page, VirtualAddress, PAGE_SIZE};
+use crate::ptrace;
 use crate::scheme::FileHandle;
-use crate::syscall;
+use crate::start::usermode;
 use crate::syscall::data::{SigAction, Stat};
 use crate::syscall::error::*;
 use crate::syscall::flag::{CLONE_VFORK, CLONE_VM, CLONE_FS, CLONE_FILES, CLONE_SIGHAND, CLONE_STACK,
@@ -28,6 +28,7 @@ use crate::syscall::flag::{CLONE_VFORK, CLONE_VM, CLONE_FS, CLONE_FILES, CLONE_S
                     SIG_DFL, SIG_BLOCK, SIG_UNBLOCK, SIG_SETMASK, SIGCONT, SIGTERM,
                     WCONTINUED, WNOHANG, WUNTRACED, wifcontinued, wifstopped};
 use crate::syscall::validate::{validate_slice, validate_slice_mut};
+use crate::syscall;
 
 pub fn brk(address: usize) -> Result<usize> {
     let contexts = context::contexts();
@@ -128,10 +129,25 @@ pub fn clone(flags: usize, stack_base: usize) -> Result<ContextId> {
             }
 
             if let Some(ref stack) = context.kstack {
+                // Get the relative offset to the return address of this function
+                // (base pointer - start of stack) - one
                 offset = stack_base - stack.as_ptr() as usize - mem::size_of::<usize>(); // Add clone ret
                 let mut new_stack = stack.clone();
 
                 unsafe {
+                    if let Some(regs) = ptrace::rebase_regs_ptr_mut(context.regs, Some(&mut new_stack)) {
+                        // We'll need to tell the clone that it should
+                        // return 0, but that's it. We don't actually
+                        // clone the registers, because it will then
+                        // become None and be exempt from all kinds of
+                        // ptracing until the current syscall has
+                        // completed.
+                        (*regs).scratch.rax = 0;
+                    }
+
+                    // Change the return address of the child
+                    // (previously syscall) to the arch-specific
+                    // clone_ret callback
                     let func_ptr = new_stack.as_mut_ptr().offset(offset as isize);
                     *(func_ptr as *mut usize) = interrupt::syscall::clone_ret as usize;
                 }
@@ -1052,6 +1068,8 @@ pub fn exit(status: usize) -> ! {
             context.id
         };
 
+        ptrace::close(pid);
+
         // Files must be closed while context is valid so that messages can be passed
         for (_fd, file_option) in close_files.drain(..).enumerate() {
             if let Some(file) = file_option {