syscall_check_signals: implement todo!()

Signed-off-by: Andy-Python-Programmer <[email protected]>

Author: Andy-Python-Programmer

src/aero_kernel/src/arch/x86_64/signals.rs

@@ -17,6 +17,9 @@
  * along with Aero. If not, see <https://www.gnu.org/licenses/>.
  */
 
+use aero_syscall::signal::{SigProcMask, SignalFlags};
+use aero_syscall::AeroSyscallError;
+
 use crate::userland;
 use crate::userland::scheduler;
 use crate::utils::StackHelper;
@@ -42,6 +45,23 @@ impl SignalFrame {
             sigmask,
         }
     }
+
+    fn from_syscall(
+        restart: bool,
+        syscall_result: u64,
+        frame: &mut InterruptStack,
+        sigmask: u64,
+    ) -> SignalFrame {
+        SignalFrame {
+            restart_syscall: if restart {
+                frame.scratch.rax // syscall number
+            } else {
+                syscall_result
+            },
+            frame: *frame,
+            sigmask,
+        }
+    }
 }
 
 pub fn interrupt_check_signals(stack: &mut InterruptStack) {
@@ -59,12 +79,7 @@ pub fn interrupt_check_signals(stack: &mut InterruptStack) {
             let old_mask = signals.blocked_mask();
 
             let signal_frame = SignalFrame::from_interrupt(stack, old_mask);
-
-            signals.set_mask(
-                aero_syscall::signal::SigProcMask::Block,
-                1u64 << signal,
-                None,
-            );
+            signals.set_mask(SigProcMask::Block, 1u64 << signal, None);
 
             // We cannot straight away update the stack pointer from the stack
             // helper, since it will created a reference to a packed field which
@@ -92,10 +107,47 @@ pub fn interrupt_check_signals(stack: &mut InterruptStack) {
     }
 }
 
-pub fn syscall_check_signals(_syscall_result: isize, _stack: &mut InterruptStack) {
-    if let Some((_signal, entry)) = userland::signals::check_for_signals() {
-        if let aero_syscall::signal::SignalHandler::Handle(_) = entry.handler() {
-            todo!()
+pub fn syscall_check_signals(syscall_result: isize, stack: &mut InterruptStack) {
+    if let Some((signal, entry)) = userland::signals::check_for_signals() {
+        if let aero_syscall::signal::SignalHandler::Handle(func) = entry.handler() {
+            let task = scheduler::get_scheduler().current_task();
+
+            let signals = task.signals();
+            let old_mask = signals.blocked_mask();
+
+            let syscall_rresult = aero_syscall::isize_as_syscall_result(syscall_result);
+            let restart_syscall = syscall_rresult == Err(AeroSyscallError::EINTR)
+                && entry.flags().contains(SignalFlags::SA_RESTART);
+
+            #[cfg(feature = "syslog")]
+            log::warn!("syscall routine signaled: (restart={restart_syscall})");
+
+            let signal_frame =
+                SignalFrame::from_syscall(restart_syscall, syscall_result as _, stack, old_mask);
+            signals.set_mask(SigProcMask::Block, 1u64 << signal, None);
+
+            // We cannot straight away update the stack pointer from the stack
+            // helper, since it will created a reference to a packed field which
+            // is undefined behavior. So we create a copy of the current rsp and
+            // update the actual rsp with the updated rsp.
+            let mut ptr = stack.iret.rsp;
+            let mut writer = StackHelper::new(&mut ptr);
+
+            // Signal handlers are executed on the same stack, but 128 bytes
+            // known as the red zone is subtracted from the stack before
+            // anything is pushed to the stack. This allows small leaf
+            // functions to use 128 bytes of stack space without reserving
+            // stack space by subtracting from the stack pointer.
+            writer.skip_by(REDZONE_SIZE);
+
+            unsafe {
+                writer.write(signal_frame);
+                writer.write(entry.sigreturn());
+            }
+
+            stack.iret.rsp = ptr;
+            stack.iret.rip = func as u64;
+            stack.scratch.rdi = signal as u64;
         }
     }
 }
@@ -118,6 +170,12 @@ pub fn sigreturn(stack: &mut InterruptStack) -> usize {
     *stack = signal_frame.frame;
 
     if signal_frame.restart_syscall != u64::MAX {
+        #[cfg(feature = "syslog")]
+        log::debug!(
+            "sigreturn: restarting {} syscall",
+            aero_syscall::syscall_as_str(signal_frame.restart_syscall as _)
+        );
+
         stack.iret.rip -= SYSCALL_INSTRUCTION_SIZE;
     }
 

src/aero_kernel/src/userland/signals.rs

@@ -169,6 +169,10 @@ impl SignalEntry {
             sa_sigaction: 0,
         }
     }
+
+    pub fn flags(&self) -> SignalFlags {
+        self.flags
+    }
 }
 
 impl SignalEntry {