From 911caf7203a9eccd5f315d99561ce765c4a3d019 Mon Sep 17 00:00:00 2001 From: EnderIce2 Date: Thu, 26 Dec 2024 02:23:12 +0200 Subject: [PATCH] kernel/signals: Update headers for syscalls.h changes Signed-off-by: EnderIce2 --- Kernel/include/interface/syscalls.h | 141 ++++++++++++++++ Kernel/include/signal.hpp | 253 ++++++++++------------------ Kernel/subsystem/linux/syscall.cpp | 48 +++--- Kernel/tasking/process.cpp | 2 +- Kernel/tasking/signal.cpp | 44 ++--- Kernel/tasking/thread.cpp | 2 +- 6 files changed, 282 insertions(+), 208 deletions(-) diff --git a/Kernel/include/interface/syscalls.h b/Kernel/include/interface/syscalls.h index da7809de..28361402 100644 --- a/Kernel/include/interface/syscalls.h +++ b/Kernel/include/interface/syscalls.h @@ -223,6 +223,147 @@ typedef enum __SYS_SET_FS = 3, } prctl_options_t; +typedef enum +{ + __SYS_SIGNULL = 0, + /* Process abort signal. */ + __SYS_SIGABRT = 1, + /* Alarm clock. */ + __SYS_SIGALRM = 2, + /* Access to an undefined portion of a memory object. */ + __SYS_SIGBUS = 3, + /* Child process terminated, stopped, or continued. */ + __SYS_SIGCHLD = 4, + /* Continue executing, if stopped. */ + __SYS_SIGCONT = 5, + /* Erroneous arithmetic operation. */ + __SYS_SIGFPE = 6, + /* Hangup. */ + __SYS_SIGHUP = 7, + /* Illegal instruction. */ + __SYS_SIGILL = 8, + /* Terminal interrupt signal. */ + __SYS_SIGINT = 9, + /* Kill (cannot be caught or ignored). */ + __SYS_SIGKILL = 10, + /* Write on a pipe with no one to read it. */ + __SYS_SIGPIPE = 11, + /* Terminal quit signal. */ + __SYS_SIGQUIT = 12, + /* Invalid memory reference. */ + __SYS_SIGSEGV = 13, + /* Stop executing (cannot be caught or ignored). */ + __SYS_SIGSTOP = 14, + /* Termination signal. */ + __SYS_SIGTERM = 15, + /* Terminal stop signal. */ + __SYS_SIGTSTP = 16, + /* Background process attempting read. */ + __SYS_SIGTTIN = 17, + /* Background process attempting write. */ + __SYS_SIGTTOU = 18, + /* User-defined signal 1. */ + __SYS_SIGUSR1 = 19, + /* User-defined signal 2. */ + __SYS_SIGUSR2 = 20, + /* Pollable event. */ + __SYS_SIGPOLL = 21, + /* Profiling timer expired. */ + __SYS_SIGPROF = 22, + /* Bad system call. */ + __SYS_SIGSYS = 23, + /* Trace/breakpoint trap. */ + __SYS_SIGTRAP = 24, + /* High bandwidth data is available at a socket. */ + __SYS_SIGURG = 25, + /* Virtual timer expired. */ + __SYS_SIGVTALRM = 26, + /* CPU time limit exceeded. */ + __SYS_SIGXCPU = 27, + /* File size limit exceeded. */ + __SYS_SIGXFSZ = 28, + + /** + * Reserved + * These are just to match Linux's signal numbers. + */ + __SYS_SIGCOMP1 = 29, + __SYS_SIGCOMP2 = 30, + __SYS_SIGCOMP3 = 31, + + /* Real-time signals. */ + __SYS_SIGRTMIN = 32, + __SYS_SIGRT_1 = 33, + __SYS_SIGRT_2 = 34, + __SYS_SIGRT_3 = 35, + __SYS_SIGRT_4 = 36, + __SYS_SIGRT_5 = 37, + __SYS_SIGRT_6 = 38, + __SYS_SIGRT_7 = 39, + __SYS_SIGRT_8 = 40, + __SYS_SIGRT_9 = 41, + __SYS_SIGRT_10 = 42, + __SYS_SIGRT_11 = 43, + __SYS_SIGRT_12 = 44, + __SYS_SIGRT_13 = 45, + __SYS_SIGRT_14 = 46, + __SYS_SIGRT_15 = 47, + __SYS_SIGRT_16 = 48, + __SYS_SIGRT_17 = 49, + __SYS_SIGRT_18 = 50, + __SYS_SIGRT_19 = 51, + __SYS_SIGRT_20 = 52, + __SYS_SIGRT_21 = 53, + __SYS_SIGRT_22 = 54, + __SYS_SIGRT_23 = 55, + __SYS_SIGRT_24 = 56, + __SYS_SIGRT_25 = 57, + __SYS_SIGRT_26 = 58, + __SYS_SIGRT_27 = 59, + __SYS_SIGRT_28 = 60, + __SYS_SIGRT_29 = 61, + __SYS_SIGRT_30 = 62, + __SYS_SIGRT_31 = 63, + __SYS_SIGRTMAX = 64, + + /* Maximum signal number. */ + __SYS_SIGNAL_MAX = __SYS_SIGRTMAX +} signal_t; + +typedef enum +{ + /** Terminate the process. */ + __SYS_SIG_TERM = 0, + /** Ignore the signal. */ + __SYS_SIG_IGN = 1, + /** Continue the process. */ + __SYS_SIG_CONT = 2, + /** Stop the process. */ + __SYS_SIG_STOP = 3, + /** Dump core. */ + __SYS_SIG_CORE = 4 +} signal_disposition_t; + +typedef enum +{ + __SYS_SIG_BLOCK = 0, + __SYS_SIG_UNBLOCK = 1, + __SYS_SIG_SETMASK = 2 +} signal_actions_t; + +typedef enum +{ + __SYS_SIG_ERR = -1, + __SYS_SIG_DFL = 0, + ___SYS_SIG_IGN = 1 +} signal_action_disposition_t; + +#ifndef __cplusplus +_Static_assert((int)__SYS_SIG_IGN == (int)___SYS_SIG_IGN, "SIG_IGN values do not match"); +#else +static_assert((int)__SYS_SIG_IGN == (int)___SYS_SIG_IGN, "SIG_IGN values do not match"); +#endif + typedef int __SYS_clockid_t; typedef unsigned int __SYS_socklen_t; diff --git a/Kernel/include/signal.hpp b/Kernel/include/signal.hpp index 1b9d8554..a82b4136 100644 --- a/Kernel/include/signal.hpp +++ b/Kernel/include/signal.hpp @@ -18,6 +18,7 @@ #ifndef __FENNIX_KERNEL_SIGNAL_H__ #define __FENNIX_KERNEL_SIGNAL_H__ +#include #include #include #include @@ -25,154 +26,86 @@ #include #include -enum Signals : int -{ - SIG_NULL = 0, - /* Process abort signal. */ - SIGABRT = 1, - /* Alarm clock. */ - SIGALRM = 2, - /* Access to an undefined portion of a memory object. */ - SIGBUS = 3, - /* Child process terminated, stopped, or continued. */ - SIGCHLD = 4, - /* Continue executing, if stopped. */ - SIGCONT = 5, - /* Erroneous arithmetic operation. */ - SIGFPE = 6, - /* Hangup. */ - SIGHUP = 7, - /* Illegal instruction. */ - SIGILL = 8, - /* Terminal interrupt signal. */ - SIGINT = 9, - /* Kill (cannot be caught or ignored). */ - SIGKILL = 10, - /* Write on a pipe with no one to read it. */ - SIGPIPE = 11, - /* Terminal quit signal. */ - SIGQUIT = 12, - /* Invalid memory reference. */ - SIGSEGV = 13, - /* Stop executing (cannot be caught or ignored). */ - SIGSTOP = 14, - /* Termination signal. */ - SIGTERM = 15, - /* Terminal stop signal. */ - SIGTSTP = 16, - /* Background process attempting read. */ - SIGTTIN = 17, - /* Background process attempting write. */ - SIGTTOU = 18, - /* User-defined signal 1. */ - SIGUSR1 = 19, - /* User-defined signal 2. */ - SIGUSR2 = 20, - /* Pollable event. */ - SIGPOLL = 21, - /* Profiling timer expired. */ - SIGPROF = 22, - /* Bad system call. */ - SIGSYS = 23, - /* Trace/breakpoint trap. */ - SIGTRAP = 24, - /* High bandwidth data is available at a socket. */ - SIGURG = 25, - /* Virtual timer expired. */ - SIGVTALRM = 26, - /* CPU time limit exceeded. */ - SIGXCPU = 27, - /* File size limit exceeded. */ - SIGXFSZ = 28, +#define SIGNULL __SYS_SIGNULL +#define SIGABRT __SYS_SIGABRT +#define SIGALRM __SYS_SIGALRM +#define SIGBUS __SYS_SIGBUS +#define SIGCHLD __SYS_SIGCHLD +#define SIGCONT __SYS_SIGCONT +#define SIGFPE __SYS_SIGFPE +#define SIGHUP __SYS_SIGHUP +#define SIGILL __SYS_SIGILL +#define SIGINT __SYS_SIGINT +#define SIGKILL __SYS_SIGKILL +#define SIGPIPE __SYS_SIGPIPE +#define SIGQUIT __SYS_SIGQUIT +#define SIGSEGV __SYS_SIGSEGV +#define SIGSTOP __SYS_SIGSTOP +#define SIGTERM __SYS_SIGTERM +#define SIGTSTP __SYS_SIGTSTP +#define SIGTTIN __SYS_SIGTTIN +#define SIGTTOU __SYS_SIGTTOU +#define SIGUSR1 __SYS_SIGUSR1 +#define SIGUSR2 __SYS_SIGUSR2 +#define SIGPOLL __SYS_SIGPOLL +#define SIGPROF __SYS_SIGPROF +#define SIGSYS __SYS_SIGSYS +#define SIGTRAP __SYS_SIGTRAP +#define SIGURG __SYS_SIGURG +#define SIGVTALRM __SYS_SIGVTALRM +#define SIGXCPU __SYS_SIGXCPU +#define SIGXFSZ __SYS_SIGXFSZ +#define SIGCOMP1 __SYS_SIGCOMP1 +#define SIGCOMP2 __SYS_SIGCOMP2 +#define SIGCOMP3 __SYS_SIGCOMP3 +#define SIGRTMIN __SYS_SIGRTMIN +#define SIGRT_1 __SYS_SIGRT_1 +#define SIGRT_2 __SYS_SIGRT_2 +#define SIGRT_3 __SYS_SIGRT_3 +#define SIGRT_4 __SYS_SIGRT_4 +#define SIGRT_5 __SYS_SIGRT_5 +#define SIGRT_6 __SYS_SIGRT_6 +#define SIGRT_7 __SYS_SIGRT_7 +#define SIGRT_8 __SYS_SIGRT_8 +#define SIGRT_9 __SYS_SIGRT_9 +#define SIGRT_10 __SYS_SIGRT_10 +#define SIGRT_11 __SYS_SIGRT_11 +#define SIGRT_12 __SYS_SIGRT_12 +#define SIGRT_13 __SYS_SIGRT_13 +#define SIGRT_14 __SYS_SIGRT_14 +#define SIGRT_15 __SYS_SIGRT_15 +#define SIGRT_16 __SYS_SIGRT_16 +#define SIGRT_17 __SYS_SIGRT_17 +#define SIGRT_18 __SYS_SIGRT_18 +#define SIGRT_19 __SYS_SIGRT_19 +#define SIGRT_20 __SYS_SIGRT_20 +#define SIGRT_21 __SYS_SIGRT_21 +#define SIGRT_22 __SYS_SIGRT_22 +#define SIGRT_23 __SYS_SIGRT_23 +#define SIGRT_24 __SYS_SIGRT_24 +#define SIGRT_25 __SYS_SIGRT_25 +#define SIGRT_26 __SYS_SIGRT_26 +#define SIGRT_27 __SYS_SIGRT_27 +#define SIGRT_28 __SYS_SIGRT_28 +#define SIGRT_29 __SYS_SIGRT_29 +#define SIGRT_30 __SYS_SIGRT_30 +#define SIGRT_31 __SYS_SIGRT_31 +#define SIGRTMAX __SYS_SIGRTMAX +#define SIGNAL_MAX __SYS_SIGNAL_MAX - /** - * Reserved - * These are just to match Linux's signal numbers. - */ - SIGCOMP1 = 29, - SIGCOMP2 = 30, - SIGCOMP3 = 31, +#define SIG_TERM __SYS_SIG_TERM +#define SIG_IGN __SYS_SIG_IGN +#define SIG_CORE __SYS_SIG_CORE +#define SIG_STOP __SYS_SIG_STOP +#define SIG_CONT __SYS_SIG_CONT - /* Real-time signals. */ - SIGRTMIN = 32, - SIGRT_1 = 33, - SIGRT_2 = 34, - SIGRT_3 = 35, - SIGRT_4 = 36, - SIGRT_5 = 37, - SIGRT_6 = 38, - SIGRT_7 = 39, - SIGRT_8 = 40, - SIGRT_9 = 41, - SIGRT_10 = 42, - SIGRT_11 = 43, - SIGRT_12 = 44, - SIGRT_13 = 45, - SIGRT_14 = 46, - SIGRT_15 = 47, - SIGRT_16 = 48, - SIGRT_17 = 49, - SIGRT_18 = 50, - SIGRT_19 = 51, - SIGRT_20 = 52, - SIGRT_21 = 53, - SIGRT_22 = 54, - SIGRT_23 = 55, - SIGRT_24 = 56, - SIGRT_25 = 57, - SIGRT_26 = 58, - SIGRT_27 = 59, - SIGRT_28 = 60, - SIGRT_29 = 61, - SIGRT_30 = 62, - SIGRT_31 = 63, - SIGRTMAX = 64, +#define SIG_BLOCK __SYS_SIG_BLOCK +#define SIG_UNBLOCK __SYS_SIG_UNBLOCK +#define SIG_SETMASK __SYS_SIG_SETMASK - /* Maximum signal number. */ - SIGNAL_MAX = SIGRTMAX -}; - -enum SignalDispositions -{ - /** - * Terminate the process. - */ - SIG_TERM, - - /** - * Ignore the signal. - */ - SIG_IGN, - - /** - * Dump core. - */ - SIG_CORE, - - /** - * Stop the process. - */ - SIG_STOP, - - /** - * Continue the process. - */ - SIG_CONT -}; - -enum SignalActions -{ - SIG_BLOCK, - SIG_UNBLOCK, - SIG_SETMASK -}; - -enum SignalActionDisposition : long -{ - SAD_ERR = -1, - SAD_DFL = 0, - SAD_IGN = 1, -}; +#define SIG_ERR __SYS_SIG_ERR +#define SIG_DFL __SYS_SIG_DFL +#define SIG_IGN __SYS_SIG_IGN #define SA_NOCLDSTOP 1 #define SA_NOCLDWAIT 2 @@ -300,7 +233,7 @@ namespace Tasking private: struct SignalInfo { - int sig = SIG_NULL; + int sig = SIGNULL; union sigval val { 0 @@ -330,7 +263,7 @@ namespace Tasking NewLock(SignalLock); void *ctx; - Signals LastSignal = SIG_NULL; + signal_t LastSignal = SIGNULL; // Signal trampoline void *TrampAddr = nullptr; @@ -339,9 +272,9 @@ namespace Tasking std::list Queue; SignalAction sa[64 + 1]{}; // std::bitset GlobalMask; - // SignalDispositions Disposition[SIGNAL_MAX]; + // signal_disposition_t Disposition[SIGNAL_MAX]; std::list Watchers; - std::unordered_map Disposition = { + std::unordered_map Disposition = { {SIGHUP, SIG_TERM}, {SIGINT, SIG_TERM}, {SIGQUIT, SIG_TERM}, @@ -408,25 +341,25 @@ namespace Tasking {SIGRTMAX, SIG_IGN}}; bool LinuxSig(); - int MakeExitCode(Signals sig); + int MakeExitCode(signal_t sig); void InitTrampoline(); SignalInfo GetAvailableSignal(void *thread); public: void *GetContext() { return ctx; } - Signals GetLastSignal() { return LastSignal; } + signal_t GetLastSignal() { return LastSignal; } - int AddWatcher(Signal *who, Signals sig); - int RemoveWatcher(Signal *who, Signals sig); + int AddWatcher(Signal *who, signal_t sig); + int RemoveWatcher(Signal *who, signal_t sig); - int AddSignal(Signals sig, union sigval val = {0}, pid_t tid = -1); - int RemoveSignal(Signals sig); + int AddSignal(signal_t sig, union sigval val = {0}, pid_t tid = -1); + int RemoveSignal(signal_t sig); bool HandleSignal(CPU::SchedulerFrame *tf, void *thread); void RestoreHandleSignal(SyscallsFrame *tf, void *thread); - int SetAction(Signals sig, const SignalAction *act); - int GetAction(Signals sig, SignalAction *act); + int SetAction(signal_t sig, const SignalAction *act); + int GetAction(signal_t sig, SignalAction *act); /** * Send a signal to the process @@ -438,7 +371,7 @@ namespace Tasking * * @return 0 on success, -errno on error */ - int SendSignal(Signals sig, sigval val = {0}, pid_t tid = -1); + int SendSignal(signal_t sig, sigval val = {0}, pid_t tid = -1); int WaitAnySignal(); bool HasPendingSignal() { return !Queue.empty(); } @@ -451,7 +384,7 @@ namespace Tasking * * @return 0 on success, -errno on error */ - int WaitSignal(Signals sig, union sigval *val); + int WaitSignal(signal_t sig, union sigval *val); /** * Wait for a signal with a timeout @@ -462,7 +395,7 @@ namespace Tasking * * @return 0 on success, -errno on error */ - int WaitSignalTimeout(Signals sig, union sigval *val, uint64_t timeout); + int WaitSignalTimeout(signal_t sig, union sigval *val, uint64_t timeout); Signal(void *ctx); ~Signal(); diff --git a/Kernel/subsystem/linux/syscall.cpp b/Kernel/subsystem/linux/syscall.cpp index 23085f91..031d6b14 100644 --- a/Kernel/subsystem/linux/syscall.cpp +++ b/Kernel/subsystem/linux/syscall.cpp @@ -366,8 +366,8 @@ const char *rlimitStr[] = { static const struct { int linuxSignal; - Signals nativeSignal; - SignalDispositions nativeDisposition; + signal_t nativeSignal; + signal_disposition_t nativeDisposition; } signalMapping[] = { {linux_SIGHUP, SIGHUP, SIG_TERM}, {linux_SIGINT, SIGINT, SIG_TERM}, @@ -535,7 +535,7 @@ inline intptr_t ConvertErrnoToLinux(auto err) return -ret; } -int ConvertSignalToLinux(Signals sig) +int ConvertSignalToLinux(signal_t sig) { if (sig >= SIGRTMIN && sig <= SIGRTMAX) return sig; /* We ignore for now */ @@ -552,13 +552,13 @@ int ConvertSignalToLinux(Signals sig) } debug("Unknown signal %d", sig); // assert(!"Unknown signal"); - return SIG_NULL; + return SIGNULL; } -Signals ConvertSignalToNative(int sig) +signal_t ConvertSignalToNative(int sig) { if (sig >= linux_SIGRTMIN && sig <= linux_SIGRTMAX) - return (Signals)sig; /* We ignore for now */ + return (signal_t)sig; /* We ignore for now */ foreach (auto &mapping in signalMapping) { @@ -572,7 +572,7 @@ Signals ConvertSignalToNative(int sig) } debug("Unknown signal %d", sig); // assert(!"Unknown signal"); - return SIG_NULL; + return SIGNULL; } unsigned long ConvertMaskToNative(unsigned long mask) @@ -583,7 +583,7 @@ unsigned long ConvertMaskToNative(unsigned long mask) if (mask & (1ul << i)) { int sig = ConvertSignalToNative(i + 1); - if (unlikely(sig == SIG_NULL)) + if (unlikely(sig == SIGNULL)) continue; ret |= 1ul << (sig - 1); } @@ -605,8 +605,8 @@ unsigned long ConvertMaskToLinux(unsigned long mask) { if (mask & (1ul << i)) { - int sig = ConvertSignalToLinux((Signals)(i + 1)); - if (unlikely(sig == SIG_NULL)) + int sig = ConvertSignalToLinux((signal_t)(i + 1)); + if (unlikely(sig == SIGNULL)) continue; ret |= 1ul << (sig - 1); } @@ -1881,8 +1881,8 @@ static pid_t linux_wait4(SysFrm *, pid_t pid, int *wstatus, bool ProcessSignaled = true; bool CoreDumped = true; int TermSignal = child->Signals.GetLastSignal(); - TermSignal = ConvertSignalToLinux((Signals)TermSignal); - assert(TermSignal != SIG_NULL); + TermSignal = ConvertSignalToLinux((signal_t)TermSignal); + assert(TermSignal != SIGNULL); debug("Process returned %d", ExitStatus); @@ -2050,8 +2050,8 @@ static int linux_kill(SysFrm *, pid_t pid, int sig) if (pid == 0) { bool found = false; - Signals nSig = ConvertSignalToNative(sig); - assert(nSig != SIG_NULL); + signal_t nSig = ConvertSignalToNative(sig); + assert(nSig != SIGNULL); foreach (auto proc in pcb->GetContext()->GetProcessList()) { if (proc->Security.ProcessGroupID == thisProcess->Security.ProcessGroupID) @@ -2078,8 +2078,8 @@ static int linux_kill(SysFrm *, pid_t pid, int sig) return -linux_ENOSYS; } - Signals nSig = ConvertSignalToNative(sig); - assert(nSig != SIG_NULL); + signal_t nSig = ConvertSignalToNative(sig); + assert(nSig != SIGNULL); return ConvertErrnoToLinux(pcb->SendSignal(nSig)); } @@ -2676,8 +2676,8 @@ static int linux_sigaction(SysFrm *, int signum, const k_sigaction *act, if (pOldact) { - Signals nSig = ConvertSignalToNative(signum); - assert(nSig != SIG_NULL); + signal_t nSig = ConvertSignalToNative(signum); + assert(nSig != SIGNULL); SignalAction nSA{}; SetSigActToNative(pOldact, &nSA); @@ -2696,8 +2696,8 @@ static int linux_sigaction(SysFrm *, int signum, const k_sigaction *act, return -linux_EINVAL; } - Signals nSig = ConvertSignalToNative(signum); - assert(nSig != SIG_NULL); + signal_t nSig = ConvertSignalToNative(signum); + assert(nSig != SIGNULL); SignalAction nSA{}; SetSigActToNative(pAct, &nSA); @@ -2778,8 +2778,8 @@ static int linux_tkill(SysFrm *, int tid, int sig) if (!tcb) return -linux_ESRCH; - Signals nSig = ConvertSignalToNative(sig); - assert(nSig != SIG_NULL); + signal_t nSig = ConvertSignalToNative(sig); + assert(nSig != SIGNULL); return ConvertErrnoToLinux(tcb->SendSignal(nSig)); } @@ -3074,8 +3074,8 @@ static int linux_tgkill(SysFrm *sf, pid_t tgid, pid_t tid, int sig) return -linux_ESRCH; } - Signals nSig = ConvertSignalToNative(sig); - assert(nSig != SIG_NULL); + signal_t nSig = ConvertSignalToNative(sig); + assert(nSig != SIGNULL); return ConvertErrnoToLinux(tcb->SendSignal(nSig)); } diff --git a/Kernel/tasking/process.cpp b/Kernel/tasking/process.cpp index 27259e52..f23735ce 100644 --- a/Kernel/tasking/process.cpp +++ b/Kernel/tasking/process.cpp @@ -59,7 +59,7 @@ namespace Tasking int PCB::SendSignal(int sig) { - return this->Signals.SendSignal((enum Signals)sig); + return this->Signals.SendSignal((signal_t)sig); } void PCB::SetState(TaskState state) diff --git a/Kernel/tasking/signal.cpp b/Kernel/tasking/signal.cpp index 3092f82b..488b5fa8 100644 --- a/Kernel/tasking/signal.cpp +++ b/Kernel/tasking/signal.cpp @@ -112,8 +112,8 @@ extern "C" uintptr_t _sig_linux_trampoline_start, _sig_linux_trampoline_end; static const struct { - Signals Signal; - SignalDispositions Disposition; + signal_t Signal; + signal_disposition_t Disposition; } SignalDisposition[] = { {SIGHUP, SIG_TERM}, {SIGINT, SIG_TERM}, @@ -181,7 +181,7 @@ static const struct {SIGRTMAX, SIG_IGN}, }; -SignalDispositions GetDefaultSignalDisposition(Signals sig) +signal_disposition_t GetDefaultSignalDisposition(signal_t sig) { foreach (auto var in SignalDisposition) { @@ -194,7 +194,7 @@ SignalDispositions GetDefaultSignalDisposition(Signals sig) } /* subsystem/linux/syscall.cpp */ -extern int ConvertSignalToLinux(Signals sig); +extern int ConvertSignalToLinux(signal_t sig); namespace Tasking { @@ -203,7 +203,7 @@ namespace Tasking return ((PCB *)ctx)->Info.Compatibility == Linux; } - int Signal::MakeExitCode(Signals sig) + int Signal::MakeExitCode(signal_t sig) { if (this->LinuxSig()) return 128 + ConvertSignalToLinux(sig); @@ -266,7 +266,7 @@ namespace Tasking /* ------------------------------------------------------ */ - int Signal::AddWatcher(Signal *who, Signals sig) + int Signal::AddWatcher(Signal *who, signal_t sig) { SignalInfo info; info.sig = sig; @@ -277,7 +277,7 @@ namespace Tasking return 0; } - int Signal::RemoveWatcher(Signal *who, Signals sig) + int Signal::RemoveWatcher(Signal *who, signal_t sig) { SmartLock(SignalLock); forItr(itr, Watchers) @@ -292,14 +292,14 @@ namespace Tasking return -ENOENT; } - int Signal::AddSignal(Signals sig, union sigval val, pid_t tid) + int Signal::AddSignal(signal_t sig, union sigval val, pid_t tid) { SignalInfo info{.sig = sig, .val = val, .tid = tid}; Queue.push_back(info); return 0; } - int Signal::RemoveSignal(Signals sig) + int Signal::RemoveSignal(signal_t sig) { size_t n = Queue.remove_if([sig](SignalInfo &info) { return info.sig == sig; }); @@ -332,8 +332,8 @@ namespace Tasking continue; } - assert(sa[itr->sig].sa_handler.Disposition != SAD_IGN); - assert(sa[itr->sig].sa_handler.Disposition != SAD_DFL); + assert(sa[itr->sig].sa_handler.Disposition != SIG_IGN); + assert(sa[itr->sig].sa_handler.Disposition != SIG_DFL); Queue.erase(itr); debug("Signal %s is available", sigStr[itr->sig]); @@ -357,7 +357,7 @@ namespace Tasking SmartLock(SignalLock); SignalInfo sigI = GetAvailableSignal(thread); - if (sigI.sig == SIG_NULL) + if (sigI.sig == SIGNULL) return false; uintptr_t _p_rsp = ((PCB *)ctx)->PageTable->Get(tf->rsp); @@ -398,7 +398,7 @@ namespace Tasking assert(!((uintptr_t)pRsp & 0xF)); - int cSig = LinuxSig() ? ConvertSignalToLinux((Signals)sigI.sig) : sigI.sig; + int cSig = LinuxSig() ? ConvertSignalToLinux((signal_t)sigI.sig) : sigI.sig; #ifdef DEBUG DumpData("Stack Data", (void *)pRsp, @@ -487,7 +487,7 @@ namespace Tasking /* Return because we will restore at sysretq */ } - int Signal::SetAction(Signals sig, const SignalAction *act) + int Signal::SetAction(signal_t sig, const SignalAction *act) { SmartLock(SignalLock); if ((size_t)sig > sizeof(sa) / sizeof(sa[0])) @@ -496,7 +496,7 @@ namespace Tasking return -EINVAL; } - if ((long)act->sa_handler.Disposition == SAD_IGN) + if ((long)act->sa_handler.Disposition == SIG_IGN) { Disposition[sig] = SIG_IGN; debug("Set disposition for %s to SIG_IGN", sigStr[sig]); @@ -519,7 +519,7 @@ namespace Tasking } } - if ((long)act->sa_handler.Disposition == SAD_DFL) + if ((long)act->sa_handler.Disposition == SIG_DFL) { Disposition[sig] = GetDefaultSignalDisposition(sig); debug("Set disposition for %s to %s (default)", sigStr[sig], @@ -536,7 +536,7 @@ namespace Tasking return 0; } - int Signal::GetAction(Signals sig, SignalAction *act) + int Signal::GetAction(signal_t sig, SignalAction *act) { SmartLock(SignalLock); if ((size_t)sig > sizeof(sa) / sizeof(sa[0])) @@ -554,7 +554,7 @@ namespace Tasking return 0; } - int Signal::SendSignal(Signals sig, sigval val, pid_t tid) + int Signal::SendSignal(signal_t sig, sigval val, pid_t tid) { SmartLock(SignalLock); PCB *pcb = (PCB *)ctx; @@ -571,7 +571,7 @@ namespace Tasking return -EINVAL; } - if (sa[sig].sa_handler.Disposition == SAD_IGN) + if (sa[sig].sa_handler.Disposition == SIG_IGN) { debug("Ignoring signal %s", sigStr[sig]); return 0; @@ -706,13 +706,13 @@ namespace Tasking return -EINTR; } - int Signal::WaitSignal(Signals sig, union sigval *val) + int Signal::WaitSignal(signal_t sig, union sigval *val) { assert(!"WaitSignal not implemented"); return 0; } - int Signal::WaitSignalTimeout(Signals sig, union sigval *val, uint64_t timeout) + int Signal::WaitSignalTimeout(signal_t sig, union sigval *val, uint64_t timeout) { assert(!"WaitSignalTimeout not implemented"); return 0; @@ -733,7 +733,7 @@ namespace Tasking for (int i = 1; i < SIGNAL_MAX; i++) debug("%s: %s", sigStr[i], - dispStr[Disposition[(Signals)i]]); + dispStr[Disposition[(signal_t)i]]); } #endif } diff --git a/Kernel/tasking/thread.cpp b/Kernel/tasking/thread.cpp index 8365c0a6..374d0b1e 100644 --- a/Kernel/tasking/thread.cpp +++ b/Kernel/tasking/thread.cpp @@ -64,7 +64,7 @@ namespace Tasking { int TCB::SendSignal(int sig) { - return this->Parent->Signals.SendSignal((enum Signals)sig, {0}, this->ID); + return this->Parent->Signals.SendSignal((signal_t)sig, {0}, this->ID); } void TCB::SetState(TaskState state)