utest: perform the signal_handler test in a child process so we restore the orignal signal handlers at the end :^)

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

Author: Andy-Python-Programmer

userland/utest/src/main.rs

@@ -32,9 +32,9 @@ pub struct Test<'a> {
 }
 
 static TEST_FUNCTIONS: &[&'static Test<'static>] = &[
-    // TODO: When did these tests start failing?
+    // TODO: Why does clone process fail?
     // &clone_process,
-    // &forked_pipe,
+    &forked_pipe,
     &signal_handler,
     &dup_fds,
     &dup2_redirect_stdout,
@@ -126,49 +126,58 @@ fn dup_fds() -> Result<(), AeroSyscallError> {
 
 #[utest_proc::test]
 fn signal_handler() -> Result<(), AeroSyscallError> {
-    let mut pipe = [0usize; 2];
-    sys_pipe(&mut pipe, OpenFlags::empty())?;
+    let child = sys_fork()?;
 
-    static PIPE_WRITE: AtomicUsize = AtomicUsize::new(0);
-    PIPE_WRITE.store(pipe[1], Ordering::SeqCst);
+    // We perform the test in a forked process since then we dont
+    // have to worry about restoring the signal handlers.
+    if child == 0 {
+        let mut pipe = [0usize; 2];
+        sys_pipe(&mut pipe, OpenFlags::empty())?;
 
-    fn handle_segmentation_fault(fault: usize) {
-        core::assert_eq!(fault, 11);
+        static PIPE_WRITE: AtomicUsize = AtomicUsize::new(0);
+        PIPE_WRITE.store(pipe[1], Ordering::SeqCst);
 
-        let pfd = PIPE_WRITE.load(Ordering::SeqCst);
+        fn handle_segmentation_fault(fault: usize) {
+            core::assert_eq!(fault, 11);
 
-        // Dont worry about closing the file descriptors since they will
-        // be auto closed by the parent.
-        sys_write(pfd, b"yes").expect("failed to write to the pipe");
-        sys_exit(0);
-    }
+            let pfd = PIPE_WRITE.load(Ordering::SeqCst);
 
-    // Install the signal handler.
-    let handler = SignalHandler::Handle(handle_segmentation_fault);
-    let sigaction = SigAction::new(handler, 0, SignalFlags::empty());
+            // Dont worry about closing the file descriptors since they will
+            // be auto closed by the parent.
+            sys_write(pfd, b"yes").expect("failed to write to the pipe");
+            sys_exit(0);
+        }
 
-    sys_sigaction(SIGSEGV, Some(&sigaction), None)
-        .expect("failed to install the segmentation fault handler");
+        // Install the signal handler.
+        let handler = SignalHandler::Handle(handle_segmentation_fault);
+        let sigaction = SigAction::new(handler, 0, SignalFlags::empty());
 
-    // On fork the signal handler will be copied over to the child process.
-    let child = sys_fork()?;
+        sys_sigaction(SIGSEGV, Some(&sigaction), None)
+            .expect("failed to install the segmentation fault handler");
 
-    if child == 0 {
-        // Create a traditional page fault :^)
-        unsafe {
-            *(0xcafebabe as *mut usize) = 69;
+        // On fork the signal handler will be copied over to the child process.
+        let child = sys_fork()?;
+
+        if child == 0 {
+            // Create a traditional page fault :^)
+            unsafe {
+                *(0xcafebabe as *mut usize) = 69;
+            }
+        } else {
+            let mut buffer = [0; 3];
+            sys_read(pipe[0], &mut buffer)?;
+
+            core::assert_eq!(&buffer, b"yes");
         }
-    } else {
-        let mut buffer = [0; 3];
-        sys_read(pipe[0], &mut buffer)?;
 
-        core::assert_eq!(&buffer, b"yes");
+        // Close the pipe
+        sys_close(pipe[0])?;
+        sys_close(pipe[1])?;
+    } else {
+        let mut status = 0;
+        sys_waitpid(child, &mut status, 0)?;
     }
 
-    // Close the pipe/
-    sys_close(pipe[0])?;
-    sys_close(pipe[1])?;
-
     Ok(())
 }