process/signal: Signal fixes

Author: marv7000

kernel/src/arch/sched.rs

@@ -2,11 +2,11 @@ use super::internal;
 use crate::{
     memory::{VirtAddr, stack::KernelStack},
     posix::errno::EResult,
-    process::{signal::SignalSet, task::Task},
+    process::task::Task,
 };
 use core::{fmt::Debug, mem::MaybeUninit};
 
-pub use internal::sched::Context;
+pub use internal::sched::{Context, SyscallRestart};
 assert_trait_impl!(TaskContext, Debug);
 assert_trait_impl!(Context, Default);
 assert_trait_impl!(Context, Clone);
@@ -97,12 +97,9 @@ pub unsafe fn jump_to_context(context: *mut Context) {
 /// When the handler returns, execution continues via the restorer which calls sigreturn.
 pub fn setup_signal_frame(
     context: &mut Context,
-    handler: usize,
-    signal: u32,
-    mask: SignalSet,
-    restorer: usize,
+    delivery: &crate::process::signal::SignalDelivery,
 ) {
-    internal::sched::setup_signal_frame(context, handler, signal, mask, restorer);
+    internal::sched::setup_signal_frame(context, delivery);
 }
 
 /// Restores the original context from a signal frame on the user stack.
@@ -117,9 +114,25 @@ pub fn restore_signal_frame(context: &mut Context) {
 #[doc(hidden)]
 #[allow(unused)]
 mod api {
-    use super::Context;
+    use super::{Context, SyscallRestart};
 
     fn set_return(ctx: &mut Context, val: usize, err: usize) {
         ctx.set_return(val, err);
     }
+
+    fn sp(ctx: &Context) -> usize {
+        ctx.sp()
+    }
+
+    fn return_error(ctx: &Context) -> usize {
+        ctx.syscall_error()
+    }
+
+    fn snapshot_syscall(ctx: &Context) -> SyscallRestart {
+        ctx.snapshot_syscall()
+    }
+
+    fn restart_syscall(ctx: &mut Context, restart: &SyscallRestart) {
+        ctx.restart_syscall(restart);
+    }
 }

kernel/src/arch/x86_64/irq.rs

@@ -117,11 +117,12 @@ pub unsafe extern "C" fn amd64_syscall_stub() {
 extern "C" fn syscall_handler(frame: *mut Context) {
     unsafe {
         let frame = frame.as_mut().unwrap();
+        let restart = frame.snapshot_syscall();
 
         crate::syscall::dispatch(frame);
 
         // Check for pending signals before returning to userspace.
-        crate::process::signal::deliver_pending_signals(frame);
+        signal::deliver_pending_signals(frame, Some(restart));
     }
 }
 
@@ -257,8 +258,20 @@ unsafe extern "C" fn idt_handler(context: *mut Context) {
                 }
             };
 
+            let code = match sig {
+                Signal::SigIll => crate::uapi::signal::ILL_ILLOPC,
+                Signal::SigBus => crate::uapi::signal::BUS_ADRALN,
+                Signal::SigSegv => crate::uapi::signal::SEGV_MAPERR,
+                _ => 0,
+            };
+            let info = signal::SigInfoData {
+                code: code as i32,
+                addr: context.rip as usize,
+                ..Default::default()
+            };
+
             let task = Scheduler::get_current();
-            signal::send_signal_to_thread(&task, sig);
+            signal::send_signal_info_to_thread(&task, sig, info);
         }
         // Kernel exceptions are fatal.
         0x00..0x20 => {
@@ -294,7 +307,7 @@ unsafe extern "C" fn idt_handler(context: *mut Context) {
 
     // Check for pending signals before returning to userspace.
     if from_user {
-        signal::deliver_pending_signals(context);
+        signal::deliver_pending_signals(context, None);
     }
 }
 

kernel/src/arch/x86_64/sched.rs

@@ -13,10 +13,11 @@ use crate::{
     posix::errno::EResult,
     process::{
         Process, State,
-        signal::{Signal, SignalSet},
+        signal::{Signal, SignalDelivery, SignalSet},
         task::Task,
     },
     sched::Scheduler,
+    uapi::signal::{SA_ONSTACK, siginfo_t},
 };
 use alloc::boxed::Box;
 use core::{
@@ -75,6 +76,10 @@ impl Context {
         self.rax as usize
     }
 
+    pub fn syscall_error(&self) -> usize {
+        self.rdx as usize
+    }
+
     pub fn arg0(&self) -> usize {
         self.rdi as usize
     }
@@ -103,6 +108,36 @@ impl Context {
         self.rax = val as _;
         self.rdx = err as _;
     }
+
+    pub fn sp(&self) -> usize {
+        self.rsp as usize
+    }
+
+    pub fn ip(&self) -> usize {
+        self.rip as usize
+    }
+
+    pub fn snapshot_syscall(&self) -> SyscallRestart {
+        SyscallRestart {
+            nr: self.rax as usize,
+            arg2: self.rdx as usize,
+        }
+    }
+
+    pub fn restart_syscall(&mut self, restart: &SyscallRestart) {
+        self.rip -= 2; // Length of the `syscall` instruction.
+        self.rax = restart.nr as u64;
+        self.rdx = restart.arg2 as u64;
+    }
+}
+
+/// Registers captured before a syscall is dispatched so that an interrupted
+/// syscall can be transparently restarted afterwards.
+/// The fields are whichever registers [`Context::set_return`] would clobber.
+#[derive(Clone, Copy, Debug)]
+pub struct SyscallRestart {
+    nr: usize,
+    arg2: usize,
 }
 
 impl core::fmt::Debug for Context {
@@ -379,57 +414,132 @@ pub(in crate::arch) unsafe fn jump_to_context(context: *mut Context) -> ! {
     }
 }
 
-/// Signal frame placed on the user stack when delivering a signal.
-/// The restorer function pops this frame via sigreturn.
+/// Saved state for `sigreturn`, written to the user stack below the rest of the signal frame.
 #[repr(C)]
 #[derive(Clone, Copy)]
 struct SignalFrame {
-    /// The saved signal mask to restore after handler returns.
     saved_mask: u64,
-    /// The saved user context to restore after handler returns.
     saved_context: Context,
-    /// The signal number.
-    signal_number: u32,
+}
+
+#[repr(C)]
+#[derive(Clone, Copy, Default)]
+struct UserStack {
+    ss_sp: u64,
+    ss_size: u64,
+    ss_flags: i32,
     _pad: u32,
-    /// Return address: points to the restorer trampoline.
-    restorer_ret: u64,
 }
 
-pub(in crate::arch) fn setup_signal_frame(
-    context: &mut Context,
-    handler: usize,
-    signal: u32,
-    mask: SignalSet,
-    restorer: usize,
-) {
-    let frame_sp = (context.rsp as usize - size_of::<SignalFrame>()) & !0xF;
+#[repr(C)]
+#[derive(Clone, Copy, Default)]
+struct Mcontext {
+    oldmask: u64,
+    gregs: [u64; 16],
+    pc: u64,
+    pr: u64,
+    sr: u64,
+    gbr: u64,
+    mach: u64,
+    macl: u64,
+    fpregs: [u64; 16],
+    xfpregs: [u64; 16],
+    fpscr: u32,
+    fpul: u32,
+    ownedfp: u32,
+}
+
+#[repr(C)]
+#[derive(Clone, Copy)]
+struct Ucontext {
+    uc_link: u64,
+    uc_stack: UserStack,
+    uc_mcontext: Mcontext,
+    uc_sigmask: u64,
+}
+
+pub(in crate::arch) fn setup_signal_frame(context: &mut Context, delivery: &SignalDelivery) {
+    let altstack = delivery.altstack;
+    let on_altstack = altstack.contains(context.rsp as usize);
+    let use_altstack = delivery.flags & SA_ONSTACK != 0 && altstack.is_enabled() && !on_altstack;
+
+    // Top of the alternate stack if requested, otherwise below the 128-byte red zone
+    // of the interrupted stack (System V AMD64 ABI).
+    let base = if use_altstack {
+        altstack.sp + altstack.size
+    } else {
+        context.rsp as usize - 128
+    };
+
+    let align = |x: usize| x & !0xF;
+
+    let info_addr = align(base - size_of::<siginfo_t>());
+    let uc_addr = align(info_addr - size_of::<Ucontext>());
+    let sf_addr = align(uc_addr - size_of::<SignalFrame>());
+    let ret_addr = sf_addr - 8;
+
+    let mut gregs = [0u64; 16];
+    gregs[0] = context.rax;
+    gregs[1] = context.rbx;
+    gregs[2] = context.rcx;
+    gregs[3] = context.rdx;
+    gregs[4] = context.rsi;
+    gregs[5] = context.rdi;
+    gregs[6] = context.rbp;
+    gregs[7] = context.rsp;
+    gregs[8] = context.r8;
+    gregs[9] = context.r9;
+    gregs[10] = context.r10;
+    gregs[11] = context.r11;
+    gregs[12] = context.r12;
+    gregs[13] = context.r13;
+    gregs[14] = context.r14;
+    gregs[15] = context.r15;
+
+    let ucontext = Ucontext {
+        uc_link: 0,
+        uc_stack: UserStack {
+            ss_sp: altstack.sp as u64,
+            ss_size: altstack.size as u64,
+            ss_flags: altstack.flags,
+            _pad: 0,
+        },
+        uc_mcontext: Mcontext {
+            oldmask: delivery.old_mask.as_raw(),
+            gregs,
+            pc: context.rip,
+            ..Default::default()
+        },
+        uc_sigmask: delivery.old_mask.as_raw(),
+    };
 
     let frame = SignalFrame {
-        saved_mask: mask.as_raw(),
+        saved_mask: delivery.old_mask.as_raw(),
         saved_context: *context,
-        signal_number: signal,
-        _pad: 0,
-        restorer_ret: restorer as u64,
     };
 
-    let mut ptr = UserPtr::<SignalFrame>::new(VirtAddr::new(frame_sp));
-    if ptr.write(frame).is_none() {
-        Process::exit(State::Signaled(Signal::SigSegv));
-    }
-
-    // Place the restorer return address BELOW the signal frame so the
-    // handler's stack grows downward away from the frame, not into it.
-    // Also ensures RSP % 16 == 8 at handler entry (x86_64 ABI).
-    let ret_sp = frame_sp - 8;
-    let mut ret_ptr = UserPtr::<u64>::new(VirtAddr::new(ret_sp));
-    if ret_ptr.write(restorer as u64).is_none() {
+    let ok = UserPtr::<siginfo_t>::new(VirtAddr::new(info_addr))
+        .write(delivery.info)
+        .is_some()
+        && UserPtr::<Ucontext>::new(VirtAddr::new(uc_addr))
+            .write(ucontext)
+            .is_some()
+        && UserPtr::<SignalFrame>::new(VirtAddr::new(sf_addr))
+            .write(frame)
+            .is_some()
+        && UserPtr::<u64>::new(VirtAddr::new(ret_addr))
+            .write(delivery.restorer as u64)
+            .is_some();
+    if !ok {
         Process::exit(State::Signaled(Signal::SigSegv));
     }
 
-    // Modify context to jump to the handler.
-    context.rip = handler as u64;
-    context.rdi = signal as u64; // First argument: signal number.
-    context.rsp = ret_sp as u64;
+    // Hand control to the handler.
+    context.rip = delivery.handler as u64;
+    context.rdi = delivery.signal as u64;
+    context.rsi = info_addr as u64;
+    context.rdx = uc_addr as u64;
+    context.rsp = ret_addr as u64;
     context.rflags &= !consts::RFLAGS_DF;
 }
 

kernel/src/memory/virt/fault.rs

@@ -1,7 +1,11 @@
+use crate::memory::virt::VmFlags;
 use crate::{
     arch,
-    memory::{MemoryObject, PagedMemoryObject, VirtAddr, pmm::KernelAlloc, virt::VmFlags},
-    process::signal::Signal,
+    memory::{
+        MemoryObject, PagedMemoryObject, VirtAddr,
+        pmm::KernelAlloc,
+    },
+    process::signal::{self, SigInfoData, Signal},
     sched::Scheduler,
 };
 use alloc::sync::Arc;
@@ -114,7 +118,37 @@ fn signal_or_panic(info: &PageFaultInfo) -> bool {
     if info.caused_by_user {
         // Force SIGSEGV to the faulting user process. Using force_signal ensures the signal
         // cannot be masked or caught in a loop (handler is reset to SIG_DFL).
-        crate::process::signal::force_signal_to_thread(&task, Signal::SigSegv);
+        let code = if info.page_was_present {
+            crate::uapi::signal::SEGV_ACCERR
+        } else {
+            crate::uapi::signal::SEGV_MAPERR
+        };
+        let sig_info = SigInfoData {
+            code: code as i32,
+            addr: info.addr.value(),
+            ..Default::default()
+        };
+        let proc = task.get_process();
+        warn!(
+            "segfault in {} (pid {}): {} {} page at {:#x} (IP {:#x})",
+            proc.get_name(),
+            proc.get_pid(),
+            if info.caused_by_write {
+                "write to"
+            } else if info.caused_by_fetch {
+                "execute on"
+            } else {
+                "read from"
+            },
+            if info.page_was_present {
+                "present"
+            } else {
+                "non-present"
+            },
+            info.addr.value(),
+            info.ip.value(),
+        );
+        signal::force_signal_to_thread(&task, Signal::SigSegv, sig_info);
         return true; // Will be delivered on return to userspace.
     }
 

kernel/src/process/mod.rs

@@ -378,7 +378,15 @@ impl Process {
             }
         }
 
-        signal::notify_parent_of_child_state_change(&proc, false);
+        let (cld_code, cld_status) = match *proc.status.lock() {
+            State::Exited(code) => (uapi::signal::CLD_EXITED as i32, code as i32),
+            State::Signaled(sig) if sig.default_action() == signal::DefaultAction::CoreDump => {
+                (uapi::signal::CLD_DUMPED as i32, sig as i32)
+            }
+            State::Signaled(sig) => (uapi::signal::CLD_KILLED as i32, sig as i32),
+            _ => (uapi::signal::CLD_EXITED as i32, 0),
+        };
+        signal::notify_parent_of_child_state_change(&proc, cld_code, cld_status);
 
         drop(proc);
         drop(task);