kernel/src/main.cpp

@@ -33,40 +33,38 @@ void reap_thread()
 
 [[noreturn]] void init()
 {
-    {
-        kinfoln("Starting Moon %s %s", MOON_VERSION, MOON_RELEASE);
+    kinfoln("Starting Moon %s %s", MOON_VERSION, MOON_RELEASE);
 
-        // Default hostname if nobody from userspace changes it
-        set_host_name("moon"_sv);
+    // Default hostname if nobody from userspace changes it
+    set_host_name("moon"_sv);
 
-        kinfoln("Current platform: %s", CPU::platform_string().chars());
-        kinfoln("Current processor: %s", CPU::identify().value_or("(unknown)"_sv).chars());
+    kinfoln("Current platform: %s", CPU::platform_string().chars());
+    kinfoln("Current processor: %s", CPU::identify().value_or("(unknown)"_sv).chars());
 
-        auto root = mark_critical(TmpFS::FileSystem::create(), "Failed to create initial ramfs");
-        mark_critical(VFS::mount_root(root), "Failed to mount the initial ramfs as the root filesystem");
-        mark_critical(InitRD::populate_vfs(), "Failed to load files from the initial ramdisk");
-        mark_critical(DeviceRegistry::init(), "Failed to register initial devices");
+    auto root = mark_critical(TmpFS::FileSystem::create(), "Failed to create initial ramfs");
+    mark_critical(VFS::mount_root(root), "Failed to mount the initial ramfs as the root filesystem");
+    mark_critical(InitRD::populate_vfs(), "Failed to load files from the initial ramdisk");
+    mark_critical(DeviceRegistry::init(), "Failed to register initial devices");
 
-        mark_critical(BinaryFormat::init(), "Failed to register initial binary formats");
+    mark_critical(BinaryFormat::init(), "Failed to register initial binary formats");
 
-        auto init =
-            mark_critical(VFS::resolve_path("/bin/preinit", Credentials {}), "Can't find init in the initial ramfs!");
-        auto init_thread = mark_critical(Scheduler::new_userspace_thread(init, "/bin/preinit"),
-                                         "Failed to create PID 1 process for init");
+    auto init =
+        mark_critical(VFS::resolve_path("/bin/preinit", Credentials {}), "Can't find init in the initial ramfs!");
+    auto init_thread =
+        mark_critical(Scheduler::new_userspace_thread(init, "/bin/preinit"), "Failed to create PID 1 process for init");
 
-        auto reap = mark_critical(Scheduler::new_kernel_thread(reap_thread, "[reap]"),
-                                  "Failed to create the process reaper kernel thread");
-        Scheduler::set_reap_thread(reap);
+    auto reap = mark_critical(Scheduler::new_kernel_thread(reap_thread, "[reap]"),
+                              "Failed to create the process reaper kernel thread");
+    Scheduler::set_reap_thread(reap);
 
 #ifdef ARCH_X86_64
-        ATA::Controller::scan();
+    ATA::Controller::scan();
 #endif
 
-        // Disable console logging before transferring control to userspace.
-        setup_log(log_debug_enabled(), log_serial_enabled(), false);
+    // Disable console logging before transferring control to userspace.
+    setup_log(log_debug_enabled(), log_serial_enabled(), false);
 
-        init_thread->wake_up();
-    }
+    init_thread->wake_up();
 
     kernel_exit();
 }

kernel/src/net/UnixSocket.cpp

@@ -143,12 +143,9 @@ Result<void> UnixSocket::connect(Registers* regs, int flags, struct sockaddr* ad
         m_blocked_thread = nullptr;
         if (current->interrupted)
         {
-            if (current->will_ignore_pending_signal())
-            {
-                current->process_pending_signals(regs);
-                continue;
-            }
-            return err(EINTR);
+            if (current->will_invoke_signal_handler()) return err(EINTR);
+            current->process_pending_signals(regs);
+            continue;
         }
         break;
     }
@@ -185,12 +182,9 @@ Result<SharedPtr<OpenFileDescription>> UnixSocket::accept(Registers* regs, int f
         m_blocked_thread = nullptr;
         if (current->interrupted)
         {
-            if (current->will_ignore_pending_signal())
-            {
-                current->process_pending_signals(regs);
-                continue;
-            }
-            return err(EINTR);
+            if (current->will_invoke_signal_handler()) return err(EINTR);
+            current->process_pending_signals(regs);
+            continue;
         }
     }
 

kernel/src/sys/file.cpp

@@ -35,12 +35,8 @@ Result<u64> sys_read(Registers* regs, SyscallArgs args)
         if (current->interrupted)
         {
             kdbgln("signal: read interrupted by signal");
-            if (current->will_ignore_pending_signal())
-            {
-                current->process_pending_signals(regs);
-                continue;
-            }
-            return err(EINTR);
+            if (current->will_invoke_signal_handler()) return err(EINTR);
+            current->process_pending_signals(regs);
         }
     }
 

kernel/src/sys/poll.cpp

@@ -5,7 +5,7 @@
 #include "thread/Scheduler.h"
 #include <bits/poll.h>
 
-Result<u64> sys_poll(Registers*, SyscallArgs args)
+Result<u64> sys_poll(Registers* regs, SyscallArgs args)
 {
     struct pollfd* fds = (struct pollfd*)args[0];
     nfds_t nfds = (nfds_t)args[1];
@@ -58,6 +58,8 @@ Result<u64> sys_poll(Registers*, SyscallArgs args)
             {
                 guard.deactivate();
                 free_impl(kfds);
+                if (current->will_invoke_signal_handler()) return err(EINTR);
+                current->process_pending_signals(regs);
                 return err(EINTR);
             }
             continue;

kernel/src/sys/waitpid.cpp

@@ -27,12 +27,9 @@ Result<u64> sys_waitpid(Registers* regs, SyscallArgs args)
         if (current->interrupted)
         {
             kdbgln("signal: waitpid interrupted by signal");
-            if (current->will_ignore_pending_signal())
-            {
-                current->process_pending_signals(regs);
-                goto wait_for_child;
-            }
-            return err(EINTR);
+            if (current->will_invoke_signal_handler()) return err(EINTR);
+            current->process_pending_signals(regs);
+            goto wait_for_child;
         }
 
         check(thread->state == ThreadState::Exited);
@@ -51,12 +48,9 @@ Result<u64> sys_waitpid(Registers* regs, SyscallArgs args)
             if (current->interrupted)
             {
                 kdbgln("signal: waitpid interrupted by signal");
-                if (current->will_ignore_pending_signal())
-                {
-                    current->process_pending_signals(regs);
-                    goto wait_for_any_child;
-                }
-                return err(EINTR);
+                if (current->will_invoke_signal_handler()) return err(EINTR);
+                current->process_pending_signals(regs);
+                goto wait_for_any_child;
             }
 
             check(current->child_being_waited_for.value_or(-1) != -1);

kernel/src/thread/Thread.cpp

@@ -186,19 +186,18 @@ void Thread::process_pending_signals(Registers* current_regs)
     }
 }
 
-bool Thread::will_ignore_pending_signal()
+bool Thread::will_invoke_signal_handler()
 {
     for (int i = 0; i < NSIG; i++)
     {
         if (pending_signals & (1 << i))
         {
             int signo = i + 1;
-            if (signo == SIGKILL || signo == SIGSTOP) return false;
-            if (signal_mask & (1 << i)) continue;
+            if (signo != SIGKILL && signo != SIGSTOP && signal_mask & (1 << i)) continue;
             auto handler = signal_handlers[i];
-            if (handler.sa_handler == SIG_IGN) return true;
-            if (handler.sa_handler == SIG_DFL && default_actions[i] == DefaultSignalAction::Ignore) return true;
-            return false;
+            if (handler.sa_handler == SIG_IGN || handler.sa_handler == SIG_DFL) return false;
+            if (signo == SIGKILL || signo == SIGSTOP) return false;
+            return true;
         }
     }
     return false;

kernel/src/thread/Thread.h

@@ -159,7 +159,7 @@ struct Thread : public LinkedListNode<Thread>
 
     void process_pending_signals(Registers* current_regs);
 
-    bool will_ignore_pending_signal();
+    bool will_invoke_signal_handler();
 
     bool deliver_signal(int signo, Registers* current_regs);
     void sigreturn(Registers* current_regs);

libc/src/stdio.cpp

@@ -135,8 +135,6 @@ static ssize_t read_data_into_buffer(FILE* stream)
     stream->_buf.index = 0;
     ssize_t nread = read(stream->_fd, stream->_buf.buffer, stream->_buf.capacity);
     if (nread >= 0) stream->_buf.size = nread;
-    else
-        stream->_buf.size = 0;
     stream->_buf.status |= FileStatusFlags::LastRead;
     return nread;
 }