enderice2/Fennix
enderice2/Fennix
1
0
Fork 0
mirror of https://github.com/EnderIce2/Fennix.git synced 2025-05-28 15:34:31 +00:00
Code Issues Actions Releases Wiki Activity

kernel/signals: Update headers for syscalls.h changes

Browse Source 
Signed-off-by: EnderIce2 <enderice2@protonmail.com>
This commit is contained in:
EnderIce2 2024-12-26 02:23:12 +02:00
parent 95a8d6fb6f
commit 911caf7203
No known key found for this signature in database
GPG Key ID: 2EE20AF089811A5A
6 changed files with 282 additions and 208 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

141
Kernel/include/interface/syscalls.h
View File

@ -223,6 +223,147 @@ typedef enum
__SYS_SET_FS = 3, __SYS_SET_FS = 3,
} prctl_options_t; } 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 int __SYS_clockid_t;
typedef unsigned int __SYS_socklen_t; typedef unsigned int __SYS_socklen_t;

253
Kernel/include/signal.hpp
View File

@ -18,6 +18,7 @@
#ifndef __FENNIX_KERNEL_SIGNAL_H__ #ifndef __FENNIX_KERNEL_SIGNAL_H__
#define __FENNIX_KERNEL_SIGNAL_H__ #define __FENNIX_KERNEL_SIGNAL_H__
#include <interface/syscalls.h>
#include <unordered_map> #include <unordered_map>
#include <syscalls.hpp> #include <syscalls.hpp>
#include <lock.hpp> #include <lock.hpp>
@ -25,154 +26,86 @@
#include <bitset> #include <bitset>
#include <list> #include <list>
enum Signals : int #define SIGNULL __SYS_SIGNULL
{ #define SIGABRT __SYS_SIGABRT
SIG_NULL = 0, #define SIGALRM __SYS_SIGALRM
/* Process abort signal. */ #define SIGBUS __SYS_SIGBUS
SIGABRT = 1, #define SIGCHLD __SYS_SIGCHLD
/* Alarm clock. */ #define SIGCONT __SYS_SIGCONT
SIGALRM = 2, #define SIGFPE __SYS_SIGFPE
/* Access to an undefined portion of a memory object. */ #define SIGHUP __SYS_SIGHUP
SIGBUS = 3, #define SIGILL __SYS_SIGILL
/* Child process terminated, stopped, or continued. */ #define SIGINT __SYS_SIGINT
SIGCHLD = 4, #define SIGKILL __SYS_SIGKILL
/* Continue executing, if stopped. */ #define SIGPIPE __SYS_SIGPIPE
SIGCONT = 5, #define SIGQUIT __SYS_SIGQUIT
/* Erroneous arithmetic operation. */ #define SIGSEGV __SYS_SIGSEGV
SIGFPE = 6, #define SIGSTOP __SYS_SIGSTOP
/* Hangup. */ #define SIGTERM __SYS_SIGTERM
SIGHUP = 7, #define SIGTSTP __SYS_SIGTSTP
/* Illegal instruction. */ #define SIGTTIN __SYS_SIGTTIN
SIGILL = 8, #define SIGTTOU __SYS_SIGTTOU
/* Terminal interrupt signal. */ #define SIGUSR1 __SYS_SIGUSR1
SIGINT = 9, #define SIGUSR2 __SYS_SIGUSR2
/* Kill (cannot be caught or ignored). */ #define SIGPOLL __SYS_SIGPOLL
SIGKILL = 10, #define SIGPROF __SYS_SIGPROF
/* Write on a pipe with no one to read it. */ #define SIGSYS __SYS_SIGSYS
SIGPIPE = 11, #define SIGTRAP __SYS_SIGTRAP
/* Terminal quit signal. */ #define SIGURG __SYS_SIGURG
SIGQUIT = 12, #define SIGVTALRM __SYS_SIGVTALRM
/* Invalid memory reference. */ #define SIGXCPU __SYS_SIGXCPU
SIGSEGV = 13, #define SIGXFSZ __SYS_SIGXFSZ
/* Stop executing (cannot be caught or ignored). */ #define SIGCOMP1 __SYS_SIGCOMP1
SIGSTOP = 14, #define SIGCOMP2 __SYS_SIGCOMP2
/* Termination signal. */ #define SIGCOMP3 __SYS_SIGCOMP3
SIGTERM = 15, #define SIGRTMIN __SYS_SIGRTMIN
/* Terminal stop signal. */ #define SIGRT_1 __SYS_SIGRT_1
SIGTSTP = 16, #define SIGRT_2 __SYS_SIGRT_2
/* Background process attempting read. */ #define SIGRT_3 __SYS_SIGRT_3
SIGTTIN = 17, #define SIGRT_4 __SYS_SIGRT_4
/* Background process attempting write. */ #define SIGRT_5 __SYS_SIGRT_5
SIGTTOU = 18, #define SIGRT_6 __SYS_SIGRT_6
/* User-defined signal 1. */ #define SIGRT_7 __SYS_SIGRT_7
SIGUSR1 = 19, #define SIGRT_8 __SYS_SIGRT_8
/* User-defined signal 2. */ #define SIGRT_9 __SYS_SIGRT_9
SIGUSR2 = 20, #define SIGRT_10 __SYS_SIGRT_10
/* Pollable event. */ #define SIGRT_11 __SYS_SIGRT_11
SIGPOLL = 21, #define SIGRT_12 __SYS_SIGRT_12
/* Profiling timer expired. */ #define SIGRT_13 __SYS_SIGRT_13
SIGPROF = 22, #define SIGRT_14 __SYS_SIGRT_14
/* Bad system call. */ #define SIGRT_15 __SYS_SIGRT_15
SIGSYS = 23, #define SIGRT_16 __SYS_SIGRT_16
/* Trace/breakpoint trap. */ #define SIGRT_17 __SYS_SIGRT_17
SIGTRAP = 24, #define SIGRT_18 __SYS_SIGRT_18
/* High bandwidth data is available at a socket. */ #define SIGRT_19 __SYS_SIGRT_19
SIGURG = 25, #define SIGRT_20 __SYS_SIGRT_20
/* Virtual timer expired. */ #define SIGRT_21 __SYS_SIGRT_21
SIGVTALRM = 26, #define SIGRT_22 __SYS_SIGRT_22
/* CPU time limit exceeded. */ #define SIGRT_23 __SYS_SIGRT_23
SIGXCPU = 27, #define SIGRT_24 __SYS_SIGRT_24
/* File size limit exceeded. */ #define SIGRT_25 __SYS_SIGRT_25
SIGXFSZ = 28, #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
/** #define SIG_TERM __SYS_SIG_TERM
* Reserved #define SIG_IGN __SYS_SIG_IGN
* These are just to match Linux's signal numbers. #define SIG_CORE __SYS_SIG_CORE
*/ #define SIG_STOP __SYS_SIG_STOP
SIGCOMP1 = 29, #define SIG_CONT __SYS_SIG_CONT
SIGCOMP2 = 30,
SIGCOMP3 = 31,
/* Real-time signals. */ #define SIG_BLOCK __SYS_SIG_BLOCK
SIGRTMIN = 32, #define SIG_UNBLOCK __SYS_SIG_UNBLOCK
SIGRT_1 = 33, #define SIG_SETMASK __SYS_SIG_SETMASK
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,
/* Maximum signal number. */ #define SIG_ERR __SYS_SIG_ERR
SIGNAL_MAX = SIGRTMAX #define SIG_DFL __SYS_SIG_DFL
}; #define SIG_IGN __SYS_SIG_IGN
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 SA_NOCLDSTOP 1 #define SA_NOCLDSTOP 1
#define SA_NOCLDWAIT 2 #define SA_NOCLDWAIT 2
@ -300,7 +233,7 @@ namespace Tasking
private: private:
struct SignalInfo struct SignalInfo
{ {
int sig = SIG_NULL; int sig = SIGNULL;
union sigval val union sigval val
{ {
0 0
@ -330,7 +263,7 @@ namespace Tasking
NewLock(SignalLock); NewLock(SignalLock);
void *ctx; void *ctx;
Signals LastSignal = SIG_NULL; signal_t LastSignal = SIGNULL;
// Signal trampoline // Signal trampoline
void *TrampAddr = nullptr; void *TrampAddr = nullptr;
@ -339,9 +272,9 @@ namespace Tasking
std::list<SignalInfo> Queue; std::list<SignalInfo> Queue;
SignalAction sa[64 + 1]{}; SignalAction sa[64 + 1]{};
// std::bitset<SIGNAL_MAX> GlobalMask; // std::bitset<SIGNAL_MAX> GlobalMask;
// SignalDispositions Disposition[SIGNAL_MAX]; // signal_disposition_t Disposition[SIGNAL_MAX];
std::list<SignalInfo> Watchers; std::list<SignalInfo> Watchers;
std::unordered_map<Signals, SignalDispositions> Disposition = { std::unordered_map<signal_t, signal_disposition_t> Disposition = {
{SIGHUP, SIG_TERM}, {SIGHUP, SIG_TERM},
{SIGINT, SIG_TERM}, {SIGINT, SIG_TERM},
{SIGQUIT, SIG_TERM}, {SIGQUIT, SIG_TERM},
@ -408,25 +341,25 @@ namespace Tasking
{SIGRTMAX, SIG_IGN}}; {SIGRTMAX, SIG_IGN}};
bool LinuxSig(); bool LinuxSig();
int MakeExitCode(Signals sig); int MakeExitCode(signal_t sig);
void InitTrampoline(); void InitTrampoline();
SignalInfo GetAvailableSignal(void *thread); SignalInfo GetAvailableSignal(void *thread);
public: public:
void *GetContext() { return ctx; } void *GetContext() { return ctx; }
Signals GetLastSignal() { return LastSignal; } signal_t GetLastSignal() { return LastSignal; }
int AddWatcher(Signal *who, Signals sig); int AddWatcher(Signal *who, signal_t sig);
int RemoveWatcher(Signal *who, Signals sig); int RemoveWatcher(Signal *who, signal_t sig);
int AddSignal(Signals sig, union sigval val = {0}, pid_t tid = -1); int AddSignal(signal_t sig, union sigval val = {0}, pid_t tid = -1);
int RemoveSignal(Signals sig); int RemoveSignal(signal_t sig);
bool HandleSignal(CPU::SchedulerFrame *tf, void *thread); bool HandleSignal(CPU::SchedulerFrame *tf, void *thread);
void RestoreHandleSignal(SyscallsFrame *tf, void *thread); void RestoreHandleSignal(SyscallsFrame *tf, void *thread);
int SetAction(Signals sig, const SignalAction *act); int SetAction(signal_t sig, const SignalAction *act);
int GetAction(Signals sig, SignalAction *act); int GetAction(signal_t sig, SignalAction *act);
/** /**
* Send a signal to the process * Send a signal to the process
@ -438,7 +371,7 @@ namespace Tasking
* *
* @return 0 on success, -errno on error * @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(); int WaitAnySignal();
bool HasPendingSignal() { return !Queue.empty(); } bool HasPendingSignal() { return !Queue.empty(); }
@ -451,7 +384,7 @@ namespace Tasking
* *
* @return 0 on success, -errno on error * @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 * Wait for a signal with a timeout
@ -462,7 +395,7 @@ namespace Tasking
* *
* @return 0 on success, -errno on error * @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(void *ctx);
~Signal(); ~Signal();

48
Kernel/subsystem/linux/syscall.cpp
View File

@ -366,8 +366,8 @@ const char *rlimitStr[] = {
static const struct static const struct
{ {
int linuxSignal; int linuxSignal;
Signals nativeSignal; signal_t nativeSignal;
SignalDispositions nativeDisposition; signal_disposition_t nativeDisposition;
} signalMapping[] = { } signalMapping[] = {
{linux_SIGHUP, SIGHUP, SIG_TERM}, {linux_SIGHUP, SIGHUP, SIG_TERM},
{linux_SIGINT, SIGINT, SIG_TERM}, {linux_SIGINT, SIGINT, SIG_TERM},
@ -535,7 +535,7 @@ inline intptr_t ConvertErrnoToLinux(auto err)
return -ret; return -ret;
} }
int ConvertSignalToLinux(Signals sig) int ConvertSignalToLinux(signal_t sig)
{ {
if (sig >= SIGRTMIN && sig <= SIGRTMAX) if (sig >= SIGRTMIN && sig <= SIGRTMAX)
return sig; /* We ignore for now */ return sig; /* We ignore for now */
@ -552,13 +552,13 @@ int ConvertSignalToLinux(Signals sig)
} }
debug("Unknown signal %d", sig); debug("Unknown signal %d", sig);
// assert(!"Unknown signal"); // assert(!"Unknown signal");
return SIG_NULL; return SIGNULL;
} }
Signals ConvertSignalToNative(int sig) signal_t ConvertSignalToNative(int sig)
{ {
if (sig >= linux_SIGRTMIN && sig <= linux_SIGRTMAX) 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) foreach (auto &mapping in signalMapping)
{ {
@ -572,7 +572,7 @@ Signals ConvertSignalToNative(int sig)
} }
debug("Unknown signal %d", sig); debug("Unknown signal %d", sig);
// assert(!"Unknown signal"); // assert(!"Unknown signal");
return SIG_NULL; return SIGNULL;
} }
unsigned long ConvertMaskToNative(unsigned long mask) unsigned long ConvertMaskToNative(unsigned long mask)
@ -583,7 +583,7 @@ unsigned long ConvertMaskToNative(unsigned long mask)
if (mask & (1ul << i)) if (mask & (1ul << i))
{ {
int sig = ConvertSignalToNative(i + 1); int sig = ConvertSignalToNative(i + 1);
if (unlikely(sig == SIG_NULL)) if (unlikely(sig == SIGNULL))
continue; continue;
ret |= 1ul << (sig - 1); ret |= 1ul << (sig - 1);
} }
@ -605,8 +605,8 @@ unsigned long ConvertMaskToLinux(unsigned long mask)
{ {
if (mask & (1ul << i)) if (mask & (1ul << i))
{ {
int sig = ConvertSignalToLinux((Signals)(i + 1)); int sig = ConvertSignalToLinux((signal_t)(i + 1));
if (unlikely(sig == SIG_NULL)) if (unlikely(sig == SIGNULL))
continue; continue;
ret |= 1ul << (sig - 1); ret |= 1ul << (sig - 1);
} }
@ -1881,8 +1881,8 @@ static pid_t linux_wait4(SysFrm *, pid_t pid, int *wstatus,
bool ProcessSignaled = true; bool ProcessSignaled = true;
bool CoreDumped = true; bool CoreDumped = true;
int TermSignal = child->Signals.GetLastSignal(); int TermSignal = child->Signals.GetLastSignal();
TermSignal = ConvertSignalToLinux((Signals)TermSignal); TermSignal = ConvertSignalToLinux((signal_t)TermSignal);
assert(TermSignal != SIG_NULL); assert(TermSignal != SIGNULL);
debug("Process returned %d", ExitStatus); debug("Process returned %d", ExitStatus);
@ -2050,8 +2050,8 @@ static int linux_kill(SysFrm *, pid_t pid, int sig)
if (pid == 0) if (pid == 0)
{ {
bool found = false; bool found = false;
Signals nSig = ConvertSignalToNative(sig); signal_t nSig = ConvertSignalToNative(sig);
assert(nSig != SIG_NULL); assert(nSig != SIGNULL);
foreach (auto proc in pcb->GetContext()->GetProcessList()) foreach (auto proc in pcb->GetContext()->GetProcessList())
{ {
if (proc->Security.ProcessGroupID == thisProcess->Security.ProcessGroupID) if (proc->Security.ProcessGroupID == thisProcess->Security.ProcessGroupID)
@ -2078,8 +2078,8 @@ static int linux_kill(SysFrm *, pid_t pid, int sig)
return -linux_ENOSYS; return -linux_ENOSYS;
} }
Signals nSig = ConvertSignalToNative(sig); signal_t nSig = ConvertSignalToNative(sig);
assert(nSig != SIG_NULL); assert(nSig != SIGNULL);
return ConvertErrnoToLinux(pcb->SendSignal(nSig)); return ConvertErrnoToLinux(pcb->SendSignal(nSig));
} }
@ -2676,8 +2676,8 @@ static int linux_sigaction(SysFrm *, int signum, const k_sigaction *act,
if (pOldact) if (pOldact)
{ {
Signals nSig = ConvertSignalToNative(signum); signal_t nSig = ConvertSignalToNative(signum);
assert(nSig != SIG_NULL); assert(nSig != SIGNULL);
SignalAction nSA{}; SignalAction nSA{};
SetSigActToNative(pOldact, &nSA); SetSigActToNative(pOldact, &nSA);
@ -2696,8 +2696,8 @@ static int linux_sigaction(SysFrm *, int signum, const k_sigaction *act,
return -linux_EINVAL; return -linux_EINVAL;
} }
Signals nSig = ConvertSignalToNative(signum); signal_t nSig = ConvertSignalToNative(signum);
assert(nSig != SIG_NULL); assert(nSig != SIGNULL);
SignalAction nSA{}; SignalAction nSA{};
SetSigActToNative(pAct, &nSA); SetSigActToNative(pAct, &nSA);
@ -2778,8 +2778,8 @@ static int linux_tkill(SysFrm *, int tid, int sig)
if (!tcb) if (!tcb)
return -linux_ESRCH; return -linux_ESRCH;
Signals nSig = ConvertSignalToNative(sig); signal_t nSig = ConvertSignalToNative(sig);
assert(nSig != SIG_NULL); assert(nSig != SIGNULL);
return ConvertErrnoToLinux(tcb->SendSignal(nSig)); 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; return -linux_ESRCH;
} }
Signals nSig = ConvertSignalToNative(sig); signal_t nSig = ConvertSignalToNative(sig);
assert(nSig != SIG_NULL); assert(nSig != SIGNULL);
return ConvertErrnoToLinux(tcb->SendSignal(nSig)); return ConvertErrnoToLinux(tcb->SendSignal(nSig));
} }

2
Kernel/tasking/process.cpp
View File

@ -59,7 +59,7 @@ namespace Tasking
int PCB::SendSignal(int sig) int PCB::SendSignal(int sig)
{ {
return this->Signals.SendSignal((enum Signals)sig); return this->Signals.SendSignal((signal_t)sig);
} }
void PCB::SetState(TaskState state) void PCB::SetState(TaskState state)

44
Kernel/tasking/signal.cpp
View File

@ -112,8 +112,8 @@ extern "C" uintptr_t _sig_linux_trampoline_start, _sig_linux_trampoline_end;
static const struct static const struct
{ {
Signals Signal; signal_t Signal;
SignalDispositions Disposition; signal_disposition_t Disposition;
} SignalDisposition[] = { } SignalDisposition[] = {
{SIGHUP, SIG_TERM}, {SIGHUP, SIG_TERM},
{SIGINT, SIG_TERM}, {SIGINT, SIG_TERM},
@ -181,7 +181,7 @@ static const struct
{SIGRTMAX, SIG_IGN}, {SIGRTMAX, SIG_IGN},
}; };
SignalDispositions GetDefaultSignalDisposition(Signals sig) signal_disposition_t GetDefaultSignalDisposition(signal_t sig)
{ {
foreach (auto var in SignalDisposition) foreach (auto var in SignalDisposition)
{ {
@ -194,7 +194,7 @@ SignalDispositions GetDefaultSignalDisposition(Signals sig)
} }
/* subsystem/linux/syscall.cpp */ /* subsystem/linux/syscall.cpp */
extern int ConvertSignalToLinux(Signals sig); extern int ConvertSignalToLinux(signal_t sig);
namespace Tasking namespace Tasking
{ {
@ -203,7 +203,7 @@ namespace Tasking
return ((PCB *)ctx)->Info.Compatibility == Linux; return ((PCB *)ctx)->Info.Compatibility == Linux;
} }
int Signal::MakeExitCode(Signals sig) int Signal::MakeExitCode(signal_t sig)
{ {
if (this->LinuxSig()) if (this->LinuxSig())
return 128 + ConvertSignalToLinux(sig); 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; SignalInfo info;
info.sig = sig; info.sig = sig;
@ -277,7 +277,7 @@ namespace Tasking
return 0; return 0;
} }
int Signal::RemoveWatcher(Signal *who, Signals sig) int Signal::RemoveWatcher(Signal *who, signal_t sig)
{ {
SmartLock(SignalLock); SmartLock(SignalLock);
forItr(itr, Watchers) forItr(itr, Watchers)
@ -292,14 +292,14 @@ namespace Tasking
return -ENOENT; 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}; SignalInfo info{.sig = sig, .val = val, .tid = tid};
Queue.push_back(info); Queue.push_back(info);
return 0; return 0;
} }
int Signal::RemoveSignal(Signals sig) int Signal::RemoveSignal(signal_t sig)
{ {
size_t n = Queue.remove_if([sig](SignalInfo &info) size_t n = Queue.remove_if([sig](SignalInfo &info)
{ return info.sig == sig; }); { return info.sig == sig; });
@ -332,8 +332,8 @@ namespace Tasking
continue; continue;
} }
assert(sa[itr->sig].sa_handler.Disposition != SAD_IGN); assert(sa[itr->sig].sa_handler.Disposition != SIG_IGN);
assert(sa[itr->sig].sa_handler.Disposition != SAD_DFL); assert(sa[itr->sig].sa_handler.Disposition != SIG_DFL);
Queue.erase(itr); Queue.erase(itr);
debug("Signal %s is available", sigStr[itr->sig]); debug("Signal %s is available", sigStr[itr->sig]);
@ -357,7 +357,7 @@ namespace Tasking
SmartLock(SignalLock); SmartLock(SignalLock);
SignalInfo sigI = GetAvailableSignal(thread); SignalInfo sigI = GetAvailableSignal(thread);
if (sigI.sig == SIG_NULL) if (sigI.sig == SIGNULL)
return false; return false;
uintptr_t _p_rsp = ((PCB *)ctx)->PageTable->Get(tf->rsp); uintptr_t _p_rsp = ((PCB *)ctx)->PageTable->Get(tf->rsp);
@ -398,7 +398,7 @@ namespace Tasking
assert(!((uintptr_t)pRsp & 0xF)); 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 #ifdef DEBUG
DumpData("Stack Data", (void *)pRsp, DumpData("Stack Data", (void *)pRsp,
@ -487,7 +487,7 @@ namespace Tasking
/* Return because we will restore at sysretq */ /* 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); SmartLock(SignalLock);
if ((size_t)sig > sizeof(sa) / sizeof(sa[0])) if ((size_t)sig > sizeof(sa) / sizeof(sa[0]))
@ -496,7 +496,7 @@ namespace Tasking
return -EINVAL; return -EINVAL;
} }
if ((long)act->sa_handler.Disposition == SAD_IGN) if ((long)act->sa_handler.Disposition == SIG_IGN)
{ {
Disposition[sig] = SIG_IGN; Disposition[sig] = SIG_IGN;
debug("Set disposition for %s to SIG_IGN", sigStr[sig]); 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); Disposition[sig] = GetDefaultSignalDisposition(sig);
debug("Set disposition for %s to %s (default)", sigStr[sig], debug("Set disposition for %s to %s (default)", sigStr[sig],
@ -536,7 +536,7 @@ namespace Tasking
return 0; return 0;
} }
int Signal::GetAction(Signals sig, SignalAction *act) int Signal::GetAction(signal_t sig, SignalAction *act)
{ {
SmartLock(SignalLock); SmartLock(SignalLock);
if ((size_t)sig > sizeof(sa) / sizeof(sa[0])) if ((size_t)sig > sizeof(sa) / sizeof(sa[0]))
@ -554,7 +554,7 @@ namespace Tasking
return 0; 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); SmartLock(SignalLock);
PCB *pcb = (PCB *)ctx; PCB *pcb = (PCB *)ctx;
@ -571,7 +571,7 @@ namespace Tasking
return -EINVAL; return -EINVAL;
} }
if (sa[sig].sa_handler.Disposition == SAD_IGN) if (sa[sig].sa_handler.Disposition == SIG_IGN)
{ {
debug("Ignoring signal %s", sigStr[sig]); debug("Ignoring signal %s", sigStr[sig]);
return 0; return 0;
@ -706,13 +706,13 @@ namespace Tasking
return -EINTR; return -EINTR;
} }
int Signal::WaitSignal(Signals sig, union sigval *val) int Signal::WaitSignal(signal_t sig, union sigval *val)
{ {
assert(!"WaitSignal not implemented"); assert(!"WaitSignal not implemented");
return 0; 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"); assert(!"WaitSignalTimeout not implemented");
return 0; return 0;
@ -733,7 +733,7 @@ namespace Tasking
for (int i = 1; i < SIGNAL_MAX; i++) for (int i = 1; i < SIGNAL_MAX; i++)
debug("%s: %s", debug("%s: %s",
sigStr[i], sigStr[i],
dispStr[Disposition[(Signals)i]]); dispStr[Disposition[(signal_t)i]]);
} }
#endif #endif
} }

2
Kernel/tasking/thread.cpp
View File

@ -64,7 +64,7 @@ namespace Tasking
{ {
int TCB::SendSignal(int sig) 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) void TCB::SetState(TaskState state)