The Pedigree Project 0.1
thread-signal-syscall-regressions.cc
1/*
2 * Copyright (c) 2026, Pedigree Developers
3 *
4 * Permission to use, copy, modify, and distribute this software for any
5 * purpose with or without fee is hereby granted.
6 */
7
8#include "pedigree/kernel/Atomic.h"
9#include "pedigree/kernel/Log.h"
10#include "pedigree/kernel/errors.h"
11#include "pedigree/kernel/process/Process.h"
12#include "pedigree/kernel/process/Scheduler.h"
13#include "pedigree/kernel/process/SignalEvent.h"
14#include "pedigree/kernel/process/Thread.h"
15#include "pedigree/kernel/processor/Processor.h"
16
17#include <limits.h>
18#include <signal.h>
19
20#include "modules/subsys/posix/PosixProcess.h"
21#include "modules/subsys/posix/PosixSubsystem.h"
22#include "modules/subsys/posix/signal-syscalls.h"
23
24namespace {
25constexpr size_t HostedAttempts = 10000;
26constexpr size_t MuslTimerSignal = 32;
27constexpr size_t MuslCancelSignal = 33;
28constexpr size_t MuslSyncCallSignal = 34;
29constexpr size_t FirstRealtimeSignal = 35;
30constexpr size_t LastRealtimeSignal = 64;
31constexpr size_t FirstUnsupportedSignal = 65;
32
33void threadSignalHandler(size_t) {}
34
35void installDisposition(PosixSubsystem* subsystem, size_t signal, int type) {
36 PosixSubsystem::SignalHandler* handler = new PosixSubsystem::SignalHandler;
37 handler->type = type;
38 handler->pEvent = new SignalEvent(reinterpret_cast<uintptr_t>(&threadSignalHandler), signal);
39 subsystem->setSignalHandler(signal, handler);
40}
41
42PosixProcess* makeProcess(Process* parent, int64_t uid) {
43 PosixProcess* process = new PosixProcess(parent);
44 process->setSubsystem(new PosixSubsystem);
45 process->setUserId(uid);
46 process->setEffectiveUserId(uid);
47 process->setSavedUserId(uid);
48 return process;
49}
50
51int dormantThread(void*) {
52 return 0;
53}
54
55struct ThreadSignalContext {
56 ThreadSignalContext(PosixProcess* targetProcess, Thread* sameTarget, Thread* remoteTarget,
57 PosixProcess* deniedProcess, Thread* deniedTarget)
58 : targetProcess(targetProcess),
59 sameTarget(sameTarget),
60 remoteTarget(remoteTarget),
61 deniedProcess(deniedProcess),
62 deniedTarget(deniedTarget),
63 entered(0),
64 passed(0) {}
65
66 PosixProcess* targetProcess;
67 Thread* sameTarget;
68 Thread* remoteTarget;
69 PosixProcess* deniedProcess;
70 Thread* deniedTarget;
71 Atomic<size_t> entered;
72 Atomic<size_t> passed;
73};
74
75bool expectResult(Thread* current, int result, int expectedResult, size_t expectedError) {
76 return result == expectedResult && current->getErrno() == expectedError;
77}
78
79int runThreadSignalCalls(void* parameter) {
80 ThreadSignalContext* context = reinterpret_cast<ThreadSignalContext*>(parameter);
81 Thread* current = Processor::information().getCurrentThread();
82 PosixProcess* caller = static_cast<PosixProcess*>(current->getParent());
83 bool passed = true;
84 context->entered += 1;
85
86 current->setErrno(0);
87 passed &= expectResult(current, posix_tkill(context->sameTarget->getId(), 0), 0, 0);
88 passed &= !context->sameTarget->hasEvent(SIGUSR1);
89
90 current->setErrno(0);
91 passed &= expectResult(current, posix_tkill(context->sameTarget->getId(), SIGUSR2), 0, 0);
92 passed &= !context->sameTarget->hasEvent(SIGUSR2);
93
94 const uint64_t originalMask = context->sameTarget->getSignalMask();
95 context->sameTarget->setSignalMask(originalMask | (static_cast<uint64_t>(1) << (SIGUSR1 - 1)));
96 current->setErrno(0);
97 passed &= expectResult(current, posix_tkill(context->sameTarget->getId(), SIGUSR1), 0, 0);
98 passed &= context->sameTarget->hasEvent(SIGUSR1) && !current->hasEvent(SIGUSR1);
99 context->sameTarget->cullSignalEvent(SIGUSR1);
100 context->sameTarget->setSignalMask(originalMask);
101
102 context->sameTarget->setSignalMask(originalMask |
103 (static_cast<uint64_t>(1) << (MuslTimerSignal - 1)));
104 current->setErrno(0);
105 passed &= expectResult(current, posix_tkill(context->sameTarget->getId(), MuslTimerSignal), 0, 0);
106 passed &= context->sameTarget->hasEvent(MuslTimerSignal);
107 context->sameTarget->cullSignalEvent(MuslTimerSignal);
108 context->sameTarget->setSignalMask(originalMask);
109
110 current->setErrno(0);
111 passed &=
112 expectResult(current, posix_tkill(context->sameTarget->getId(), MuslCancelSignal), 0, 0);
113 passed &= context->sameTarget->hasEvent(MuslCancelSignal);
114 context->sameTarget->cullSignalEvent(MuslCancelSignal);
115
116 current->setErrno(0);
117 passed &= expectResult(current, posix_tkill(0, 0), -1, Error::InvalidArgument);
118 current->setErrno(0);
119 passed &= expectResult(current, posix_tkill(-1, 0), -1, Error::InvalidArgument);
120 current->setErrno(0);
121 passed &=
122 expectResult(current, posix_tkill(context->remoteTarget->getId(), FirstUnsupportedSignal), -1,
123 Error::NoSuchProcess);
124 current->setErrno(0);
125 passed &= expectResult(current, posix_tkill(context->sameTarget->getId(), FirstUnsupportedSignal),
126 -1, Error::InvalidArgument);
127
128 current->setErrno(0);
129 passed &=
130 expectResult(current, posix_tgkill(caller->getId(), context->sameTarget->getId(), 0), 0, 0);
131 current->setErrno(0);
132 passed &= expectResult(current, posix_tgkill(0, context->sameTarget->getId(), 0), -1,
133 Error::InvalidArgument);
134 current->setErrno(0);
135 passed &= expectResult(current, posix_tgkill(caller->getId(), 0, 0), -1, Error::InvalidArgument);
136
137 current->setErrno(0);
138 passed &= expectResult(
139 current,
140 posix_tgkill(context->targetProcess->getId(), context->remoteTarget->getId(), SIGUSR1), 0, 0);
141 passed &= context->remoteTarget->hasEvent(SIGUSR1);
142 context->remoteTarget->cullSignalEvent(SIGUSR1);
143
144 current->setErrno(0);
145 passed &= expectResult(
146 current,
147 posix_tgkill(context->targetProcess->getId(), context->remoteTarget->getId(), SIGUSR2), 0, 0);
148 passed &= !context->remoteTarget->hasEvent(SIGUSR2);
149
150 current->setErrno(0);
151 passed &= expectResult(current,
152 posix_tgkill(context->targetProcess->getId(),
153 context->remoteTarget->getId(), MuslSyncCallSignal),
154 0, 0);
155 passed &= context->remoteTarget->hasEvent(MuslSyncCallSignal);
156 context->remoteTarget->cullSignalEvent(MuslSyncCallSignal);
157
158 const size_t realtimeSignals[] = {FirstRealtimeSignal, LastRealtimeSignal};
159 for (size_t signal : realtimeSignals) {
160 context->sameTarget->setSignalMask(originalMask | (static_cast<uint64_t>(1) << (signal - 1)));
161 current->setErrno(0);
162 passed &= expectResult(current, posix_tkill(context->sameTarget->getId(), signal), 0, 0);
163 passed &= context->sameTarget->hasEvent(signal) && !current->hasEvent(signal);
164 context->sameTarget->cullSignalEvent(signal);
165 context->sameTarget->setSignalMask(originalMask);
166
167 current->setErrno(0);
168 passed &= expectResult(
169 current,
170 posix_tgkill(context->targetProcess->getId(), context->remoteTarget->getId(), signal), 0,
171 0);
172 passed &= context->remoteTarget->hasEvent(signal);
173 context->remoteTarget->cullSignalEvent(signal);
174
175 current->setErrno(0);
176 passed &= expectResult(
177 current,
178 posix_tgkill(context->deniedProcess->getId(), context->deniedTarget->getId(), signal), -1,
179 Error::NotEnoughPermissions);
180 }
181
182 current->setErrno(0);
183 passed &= expectResult(
184 current, posix_tgkill(context->targetProcess->getId(), INT_MAX, FirstUnsupportedSignal), -1,
185 Error::NoSuchProcess);
186 current->setErrno(0);
187 passed &= expectResult(
188 current, posix_tgkill(INT_MAX, context->remoteTarget->getId(), FirstUnsupportedSignal), -1,
189 Error::NoSuchProcess);
190 current->setErrno(0);
191 passed &= expectResult(current,
192 posix_tgkill(context->targetProcess->getId(),
193 context->remoteTarget->getId(), FirstUnsupportedSignal),
194 -1, Error::InvalidArgument);
195
196 current->setErrno(0);
197 passed &= expectResult(current, posix_kill(caller->getId(), MuslCancelSignal), -1,
198 Error::InvalidArgument);
199 current->setErrno(0);
200 passed &= expectResult(current, posix_kill(caller->getId(), FirstUnsupportedSignal), -1,
201 Error::InvalidArgument);
202
203 // The permitted target is a sibling, not a child of the caller.
204 current->setErrno(0);
205 passed &= expectResult(current, posix_kill(-1, 0), 0, 0);
206
207 current->setErrno(0);
208 passed &= expectResult(
209 current, posix_tgkill(context->deniedProcess->getId(), context->deniedTarget->getId(), 0), -1,
210 Error::NotEnoughPermissions);
211
212 if (passed) {
213 context->passed += 1;
214 }
215 current->setErrno(0);
216 return 0;
217}
218
219struct SuspendContext {
220 explicit SuspendContext(Process* process) : process(process), entered(0), returned(0) {}
221
222 Process* process;
223 Atomic<size_t> entered;
224 Atomic<size_t> returned;
225};
226
227int suspendTarget(void* parameter) {
228 SuspendContext* context = reinterpret_cast<SuspendContext*>(parameter);
229 context->entered += 1;
230 context->process->suspend();
231 context->returned += 1;
232 return 0;
233}
234
235bool waitForSuspension(Process* process) {
236 for (size_t attempt = 0; attempt < HostedAttempts; ++attempt) {
237 if (process->isSuspended()) {
238 return true;
239 }
240 Scheduler::instance().yield();
241 }
242 return false;
243}
244} // namespace
245
246bool runHostedThreadSignalSyscallRegressions(Process* kernelProcess) {
247 PosixProcess* caller = makeProcess(kernelProcess, 1000);
248 PosixSubsystem* callerSubsystem = static_cast<PosixSubsystem*>(caller->getSubsystem());
249 installDisposition(callerSubsystem, SIGUSR1, 0);
250 installDisposition(callerSubsystem, SIGUSR2, 2);
251 installDisposition(callerSubsystem, MuslTimerSignal, 0);
252 installDisposition(callerSubsystem, MuslCancelSignal, 0);
253 installDisposition(callerSubsystem, FirstRealtimeSignal, 0);
254 installDisposition(callerSubsystem, LastRealtimeSignal, 0);
255 Thread* sameTarget = new Thread(caller, dormantThread, nullptr, nullptr, false, true, true);
256
257 PosixProcess* target = makeProcess(kernelProcess, 1000);
258 PosixSubsystem* targetSubsystem = static_cast<PosixSubsystem*>(target->getSubsystem());
259 installDisposition(targetSubsystem, SIGUSR1, 0);
260 installDisposition(targetSubsystem, SIGUSR2, 2);
261 installDisposition(targetSubsystem, MuslSyncCallSignal, 0);
262 installDisposition(targetSubsystem, FirstRealtimeSignal, 0);
263 installDisposition(targetSubsystem, LastRealtimeSignal, 0);
264 new Thread(target, dormantThread, nullptr, nullptr, false, true, true);
265 new Thread(target, dormantThread, nullptr, nullptr, false, true, true);
266 Thread* remoteTarget = new Thread(target, dormantThread, nullptr, nullptr, false, true, true);
267
268 PosixProcess* denied = makeProcess(kernelProcess, 2000);
269 PosixSubsystem* deniedSubsystem = static_cast<PosixSubsystem*>(denied->getSubsystem());
270 installDisposition(deniedSubsystem, SIGUSR1, 0);
271 Thread* deniedTarget = new Thread(denied, dormantThread, nullptr, nullptr, false, true, true);
272
273 ThreadSignalContext context(target, sameTarget, remoteTarget, denied, deniedTarget);
274 Thread* callerThread =
275 new Thread(caller, runThreadSignalCalls, &context, nullptr, false, true, true);
276 callerThread->setName("hosted thread-signal syscall caller");
277
278 caller->publish();
279 target->publish();
280 denied->publish();
281
282 SuspendContext suspendContext(target);
283 Thread* suspender =
284 new Thread(kernelProcess, suspendTarget, &suspendContext, nullptr, false, true, true);
285 suspender->setName("hosted thread-signal suspended-target fixture");
286 const bool suspenderStarted = suspender->start();
287 const bool suspended = suspenderStarted && waitForSuspension(target);
288 const bool callerStarted = suspended && callerThread->start();
289 const bool callerJoined = callerStarted && callerThread->joinForCompletion();
290
291 if (suspenderStarted && !suspended) {
292 suspender->setUnwindState(Thread::TerminateThread);
293 }
294 if (target->isSuspended()) {
295 target->resume();
296 }
297 const bool suspenderJoined = suspenderStarted && suspender->joinForCompletion();
298 if (target->isSuspended()) {
299 target->resume();
300 }
301 if (!callerStarted) {
302 delete callerThread;
303 }
304 if (!suspenderStarted) {
305 delete suspender;
306 }
307
308 const bool passed = suspended && callerJoined && suspenderJoined && suspendContext.entered == 1 &&
309 suspendContext.returned == 1 && context.entered == 1 && context.passed == 1;
310
311 delete caller;
312 delete target;
313 delete denied;
314
315 if (!passed) {
316 ERROR(
317 "HOSTED-SYSCALL-TEST: FAIL thread-signal-syscalls: "
318 "tkill/tgkill target, mask, suspension, error, or permission semantics regressed");
319 return false;
320 }
321
322 NOTICE("HOSTED-SYSCALL-TEST: PASS thread-signal-syscalls");
323 return true;
324}
PosixSubsystem::setSignalHandler
void setSignalHandler(size_t sig, SignalHandler *handler)
Definition PosixSubsystem.cc:1202
Process::getId
size_t getId()
Definition Process.h:499
Process::resume
void resume()
Definition Process.cc:2155
ProcessorBase::information
static ProcessorInformation & information()
Definition x64/Processor.h:30
Scheduler::instance
static Scheduler & instance()
Definition Scheduler.h:96
Scheduler::yield
void yield()
Definition Scheduler.cc:236
Thread::setErrno
void setErrno(size_t err)
Definition Thread.h:482
Thread::setUnwindState
void setUnwindState(UnwindType ut)
Definition Thread.cc:3580
Thread::TerminateThread
@ TerminateThread
Exit only this thread during Process exit.
Definition Thread.h:519
Thread::hasEvent
bool hasEvent(Event *pEvent)
Definition Thread.cc:2618
Thread::getErrno
size_t getErrno()
Definition Thread.h:477
Thread::joinForCompletion
bool joinForCompletion()
Definition Thread.cc:2750
Thread::getParent
Process * getParent() const
Definition Thread.h:340
Thread::start
bool start()
Definition Thread.cc:751
PosixSubsystem::SignalHandler::type
int type
Type - 0 = normal, 1 = SIG_DFL, 2 = SIG_IGN.
Definition PosixSubsystem.h:411
PosixSubsystem::SignalHandler::pEvent
SignalEvent * pEvent
Event for the signal handler.
Definition PosixSubsystem.h:399
Generated on Sat Oct 3 2026 06:38:06 for The Pedigree Project by doxygen 1.9.8