Kernel+LibC: Don't hardcode the maximum signal number everywhere

Kernel/Process.cpp

@@ -738,7 +738,7 @@ void Process::die()
 void Process::terminate_due_to_signal(u8 signal)
 {
     VERIFY_INTERRUPTS_DISABLED();
-    VERIFY(signal < 32);
+    VERIFY(signal < NSIG);
     VERIFY(&Process::current() == this);
     dbgln("Terminating {} due to signal {}", *this, signal);
     {

Kernel/Syscalls/sigaction.cpp

@@ -54,7 +54,7 @@ ErrorOr<FlatPtr> Process::sys$sigaction(int signum, Userspace<sigaction const*>
 {
     VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this)
     TRY(require_promise(Pledge::sigaction));
-    if (signum < 1 || signum >= 32 || signum == SIGKILL || signum == SIGSTOP)
+    if (signum < 1 || signum >= NSIG || signum == SIGKILL || signum == SIGSTOP)
         return EINVAL;
 
     InterruptDisabler disabler; // FIXME: This should use a narrower lock. Maybe a way to ignore signals temporarily?

Kernel/Syscalls/thread.cpp

@@ -156,7 +156,7 @@ ErrorOr<FlatPtr> Process::sys$kill_thread(pid_t tid, int signal)
     VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this)
     TRY(require_promise(Pledge::thread));
 
-    if (signal < 0 || signal >= 32)
+    if (signal < 0 || signal >= NSIG)
         return EINVAL;
 
     auto thread = Thread::from_tid(tid);

Kernel/Thread.cpp

@@ -720,7 +720,7 @@ u32 Thread::pending_signals_for_state() const
 
 void Thread::send_signal(u8 signal, [[maybe_unused]] Process* sender)
 {
-    VERIFY(signal < 32);
+    VERIFY(signal < NSIG);
     VERIFY(process().is_user_process());
     SpinlockLocker scheduler_lock(g_scheduler_lock);
 
@@ -827,7 +827,7 @@ DispatchSignalResult Thread::dispatch_one_pending_signal()
         return DispatchSignalResult::Continue;
 
     u8 signal = 1;
-    for (; signal < 32; ++signal) {
+    for (; signal < NSIG; ++signal) {
         if ((signal_candidates & (1 << (signal - 1))) != 0) {
             break;
         }
@@ -902,7 +902,7 @@ static DefaultSignalAction default_signal_action(u8 signal)
 
 bool Thread::should_ignore_signal(u8 signal) const
 {
-    VERIFY(signal < 32);
+    VERIFY(signal < NSIG);
     auto const& action = m_process->m_signal_action_data[signal];
     if (action.handler_or_sigaction.is_null())
         return default_signal_action(signal) == DefaultSignalAction::Ignore;
@@ -911,14 +911,14 @@ bool Thread::should_ignore_signal(u8 signal) const
 
 bool Thread::has_signal_handler(u8 signal) const
 {
-    VERIFY(signal < 32);
+    VERIFY(signal < NSIG);
     auto const& action = m_process->m_signal_action_data[signal];
     return !action.handler_or_sigaction.is_null();
 }
 
 bool Thread::is_signal_masked(u8 signal) const
 {
-    VERIFY(signal < 32);
+    VERIFY(signal < NSIG);
     return (1 << (signal - 1)) & m_signal_mask;
 }
 
@@ -969,7 +969,7 @@ DispatchSignalResult Thread::dispatch_signal(u8 signal)
 {
     VERIFY_INTERRUPTS_DISABLED();
     VERIFY(g_scheduler_lock.is_locked_by_current_processor());
-    VERIFY(signal > 0 && signal <= 32);
+    VERIFY(signal > 0 && signal <= NSIG);
     VERIFY(process().is_user_process());
     VERIFY(this == Thread::current());