include/boost/corosio/native/detail/posix/posix_signal_service.hpp

90.2% Lines (296/328) 96.6% List of functions (28/29) 63.7% Branches (116/182)

[ ] prev/next file n p prev/next uncovered line

posix_signal_service.hpp

f(x) Functions (29)

Function Calls Lines Branches Blocks

Line	Branch	Hits	Source Code
1			//
2			// Copyright (c) 2026 Steve Gerbino
3			//
4			// Distributed under the Boost Software License, Version 1.0. (See accompanying
5			// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
6			//
7			// Official repository: https://github.com/cppalliance/corosio
8			//
9
10			#ifndef BOOST_COROSIO_NATIVE_DETAIL_POSIX_POSIX_SIGNAL_SERVICE_HPP
11			#define BOOST_COROSIO_NATIVE_DETAIL_POSIX_POSIX_SIGNAL_SERVICE_HPP
12
13			#include <boost/corosio/detail/platform.hpp>
14
15			#if BOOST_COROSIO_POSIX
16
17			#include <boost/corosio/native/detail/posix/posix_signal.hpp>
18
19			#include <boost/corosio/detail/config.hpp>
20			#include <boost/capy/ex/execution_context.hpp>
21			#include <boost/corosio/detail/scheduler.hpp>
22			#include <boost/capy/error.hpp>
23
24			#include <mutex>
25
26			#include <signal.h>
27
28			/*
29			POSIX Signal Service
30			====================
31
32			Concrete signal service implementation for POSIX backends. Manages signal
33			registrations via sigaction() and dispatches completions through the
34			scheduler. One instance per execution_context, created by
35			get_signal_service().
36
37			See the block comment further down for the full architecture overview.
38			*/
39
40			/*
41			POSIX Signal Implementation
42			===========================
43
44			This file implements signal handling for POSIX systems using sigaction().
45			The implementation supports signal flags (SA_RESTART, etc.) and integrates
46			with any POSIX-compatible scheduler via the abstract scheduler interface.
47
48			Architecture Overview
49			---------------------
50
51			Three layers manage signal registrations:
52
53			1. signal_state (global singleton)
54			- Tracks the global service list and per-signal registration counts
55			- Stores the flags used for first registration of each signal (for
56			conflict detection when multiple signal_sets register same signal)
57			- Owns the mutex that protects signal handler installation/removal
58
59			2. posix_signal_service (one per execution_context)
60			- Maintains registrations_[] table indexed by signal number
61			- Each slot is a doubly-linked list of signal_registrations for that signal
62			- Also maintains impl_list_ of all posix_signal objects it owns
63
64			3. posix_signal (one per signal_set)
65			- Owns a singly-linked list (sorted by signal number) of signal_registrations
66			- Contains the pending_op_ used for wait operations
67
68			Signal Delivery Flow
69			--------------------
70
71			1. Signal arrives -> corosio_posix_signal_handler() (must be async-signal-safe)
72			-> deliver_signal()
73
74			2. deliver_signal() iterates all posix_signal_service services:
75			- If a signal_set is waiting (impl->waiting_ == true), post the signal_op
76			to the scheduler for immediate completion
77			- Otherwise, increment reg->undelivered to queue the signal
78
79			3. When wait() is called via start_wait():
80			- First check for queued signals (undelivered > 0); if found, post
81			immediate completion without blocking
82			- Otherwise, set waiting_ = true and call work_started() to keep
83			the io_context alive
84
85			Locking Protocol
86			----------------
87
88			Two mutex levels exist (MUST acquire in this order to avoid deadlock):
89			1. signal_state::mutex - protects handler registration and service list
90			2. posix_signal_service::mutex_ - protects per-service registration tables
91
92			Async-Signal-Safety Limitation
93			------------------------------
94
95			IMPORTANT: deliver_signal() is called from signal handler context and
96			acquires mutexes. This is NOT strictly async-signal-safe per POSIX.
97			The limitation:
98			- If a signal arrives while another thread holds state->mutex or
99			service->mutex_, and that same thread receives the signal, a
100			deadlock can occur (self-deadlock on non-recursive mutex).
101
102			This design trades strict async-signal-safety for implementation simplicity.
103			In practice, deadlocks are rare because:
104			- Mutexes are held only briefly during registration changes
105			- Most programs don't modify signal sets while signals are expected
106			- The window for signal arrival during mutex hold is small
107
108			A fully async-signal-safe implementation would require lock-free data
109			structures and atomic operations throughout, significantly increasing
110			complexity.
111
112			Flag Handling
113			-------------
114
115			- Flags are abstract values in the public API (signal_set::flags_t)
116			- flags_supported() validates that requested flags are available on
117			this platform; returns false if SA_NOCLDWAIT is unavailable and
118			no_child_wait is requested
119			- to_sigaction_flags() maps validated flags to actual SA_* constants
120			- First registration of a signal establishes the flags; subsequent
121			registrations must be compatible (same flags or dont_care)
122			- Requesting unavailable flags returns operation_not_supported
123
124			Work Tracking
125			-------------
126
127			When waiting for a signal:
128			- start_wait() calls sched_->work_started() to prevent io_context::run()
129			from returning while we wait
130			- signal_op::svc is set to point to the service
131			- signal_op::operator()() calls work_finished() after resuming the coroutine
132
133			If a signal was already queued (undelivered > 0), no work tracking is needed
134			because completion is posted immediately.
135			*/
136
137			namespace boost::corosio {
138
139			namespace detail {
140
141			/** Signal service for POSIX backends.
142
143			Manages signal registrations via sigaction() and dispatches signal
144			completions through the scheduler. One instance per execution_context.
145			*/
146			class BOOST_COROSIO_DECL posix_signal_service final
147			: public capy::execution_context::service
148			, public io_object::io_service
149			{
150			public:
151			using key_type = posix_signal_service;
152
153			posix_signal_service(capy::execution_context& ctx, scheduler& sched);
154			~posix_signal_service() override;
155
156			posix_signal_service(posix_signal_service const&) = delete;
157			posix_signal_service& operator=(posix_signal_service const&) = delete;
158
159			io_object::implementation* construct() override;
160
161		96x	void destroy(io_object::implementation* p) override
162			{
163		96x	auto& impl = static_cast<posix_signal&>(*p);
164		96x	[[maybe_unused]] auto n = impl.clear();
165		96x	impl.cancel();
166		96x	destroy_impl(impl);
167		96x	}
168
169			void shutdown() override;
170
171			void destroy_impl(posix_signal& impl);
172
173			std::error_code add_signal(
174			posix_signal& impl, int signal_number, signal_set::flags_t flags);
175
176			std::error_code remove_signal(posix_signal& impl, int signal_number);
177
178			std::error_code clear_signals(posix_signal& impl);
179
180			void cancel_wait(posix_signal& impl);
181			void start_wait(posix_signal& impl, signal_op* op);
182
183			static void deliver_signal(int signal_number);
184
185			void work_started() noexcept;
186			void work_finished() noexcept;
187			void post(signal_op* op);
188
189			private:
190			static void add_service(posix_signal_service* service);
191			static void remove_service(posix_signal_service* service);
192
193			scheduler* sched_;
194			std::mutex mutex_;
195			intrusive_list<posix_signal> impl_list_;
196
197			// Per-signal registration table
198			signal_registration* registrations_[max_signal_number];
199
200			// Registration counts for each signal
201			std::size_t registration_count_[max_signal_number];
202
203			// Linked list of all posix_signal_service services for signal delivery
204		743x	posix_signal_service* next_ = nullptr;
205		743x	posix_signal_service* prev_ = nullptr;
206			};
207
208			/** Get or create the signal service for the given context.
209
210			This function is called by the concrete scheduler during initialization
211			to create the signal service with a reference to itself.
212
213			@param ctx Reference to the owning execution_context.
214			@param sched Reference to the scheduler for posting completions.
215			@return Reference to the signal service.
216			*/
217			posix_signal_service&
218			get_signal_service(capy::execution_context& ctx, scheduler& sched);
219
220			} // namespace detail
221
222			} // namespace boost::corosio
223
224			// ---------------------------------------------------------------------------
225			// Inline implementation
226			// ---------------------------------------------------------------------------
227
228			namespace boost::corosio {
229
230			namespace detail {
231
232			namespace posix_signal_detail {
233
234			struct signal_state
235			{
236			std::mutex mutex;
237			posix_signal_service* service_list = nullptr;
238			std::size_t registration_count[max_signal_number] = {};
239			signal_set::flags_t registered_flags[max_signal_number] = {};
240			};
241
242			BOOST_COROSIO_DECL signal_state* get_signal_state();
243
244			// Check if requested flags are supported on this platform.
245			// Returns true if all flags are supported, false otherwise.
246			inline bool
247		100x	flags_supported([[maybe_unused]] signal_set::flags_t flags)
248			{
249			#ifndef SA_NOCLDWAIT
250			if (flags & signal_set::no_child_wait)
251			return false;
252			#endif
253		100x	return true;
254			}
255
256			// Map abstract flags to sigaction() flags.
257			// Caller must ensure flags_supported() returns true first.
258			inline int
259		82x	to_sigaction_flags(signal_set::flags_t flags)
260			{
261		82x	int sa_flags = 0;
262	2/2 ✓ Branch 0 taken 64 times. ✓ Branch 1 taken 18 times.	82x	if (flags & signal_set::restart)
263		18x	sa_flags \|= SA_RESTART;
264	1/2 ✓ Branch 0 taken 82 times. ✗ Branch 1 not taken.	82x	if (flags & signal_set::no_child_stop)
265		✗	sa_flags \|= SA_NOCLDSTOP;
266			#ifdef SA_NOCLDWAIT
267	1/2 ✓ Branch 0 taken 82 times. ✗ Branch 1 not taken.	82x	if (flags & signal_set::no_child_wait)
268		✗	sa_flags \|= SA_NOCLDWAIT;
269			#endif
270	2/2 ✓ Branch 0 taken 80 times. ✓ Branch 1 taken 2 times.	82x	if (flags & signal_set::no_defer)
271		2x	sa_flags \|= SA_NODEFER;
272	1/2 ✓ Branch 0 taken 82 times. ✗ Branch 1 not taken.	82x	if (flags & signal_set::reset_handler)
273		✗	sa_flags \|= SA_RESETHAND;
274		82x	return sa_flags;
275			}
276
277			// Check if two flag values are compatible
278			inline bool
279		18x	flags_compatible(signal_set::flags_t existing, signal_set::flags_t requested)
280			{
281			// dont_care is always compatible
282	4/4 ✓ Branch 0 taken 16 times. ✓ Branch 1 taken 2 times. ✓ Branch 2 taken 4 times. ✓ Branch 3 taken 12 times.	18x	if ((existing & signal_set::dont_care) \|\|
283		16x	(requested & signal_set::dont_care))
284		6x	return true;
285
286			// Mask out dont_care bit for comparison
287		12x	constexpr auto mask = ~signal_set::dont_care;
288		12x	return (existing & mask) == (requested & mask);
289		18x	}
290
291			// C signal handler - must be async-signal-safe
292			inline void
293		20x	corosio_posix_signal_handler(int signal_number)
294			{
295		20x	posix_signal_service::deliver_signal(signal_number);
296			// Note: With sigaction(), the handler persists automatically
297			// (unlike some signal() implementations that reset to SIG_DFL)
298		20x	}
299
300			} // namespace posix_signal_detail
301
302			// signal_op implementation
303
304			inline void
305		22x	signal_op::operator()()
306			{
307	1/2 ✗ Branch 0 not taken. ✓ Branch 1 taken 22 times.	22x	if (ec_out)
308		22x	*ec_out = {};
309	1/2 ✗ Branch 0 not taken. ✓ Branch 1 taken 22 times.	22x	if (signal_out)
310		22x	*signal_out = signal_number;
311
312			// Capture svc before resuming (coro may destroy us)
313		22x	auto* service = svc;
314		22x	svc = nullptr;
315
316		22x	cont_op.cont.h = h;
317		22x	d.post(cont_op.cont);
318
319			// Balance the work_started() from start_wait
320	2/2 ✓ Branch 0 taken 10 times. ✓ Branch 1 taken 12 times.	22x	if (service)
321		12x	service->work_finished();
322		22x	}
323
324			inline void
325		✗	signal_op::destroy()
326			{
327			// No-op: signal_op is embedded in posix_signal
328		✗	}
329
330			// posix_signal implementation
331
332		192x	inline posix_signal::posix_signal(posix_signal_service& svc) noexcept
333		96x	: svc_(svc)
334		192x	{
335		96x	}
336
337			inline std::coroutine_handle<>
338		28x	posix_signal::wait(
339			std::coroutine_handle<> h,
340			capy::executor_ref d,
341			std::stop_token token,
342			std::error_code* ec,
343			int* signal_out)
344			{
345		28x	pending_op_.h = h;
346		28x	pending_op_.d = d;
347		28x	pending_op_.ec_out = ec;
348		28x	pending_op_.signal_out = signal_out;
349		28x	pending_op_.signal_number = 0;
350
351	1/2 ✗ Branch 0 not taken. ✓ Branch 1 taken 28 times.	28x	if (token.stop_requested())
352			{
353		✗	if (ec)
354		✗	*ec = make_error_code(capy::error::canceled);
355		✗	if (signal_out)
356		✗	*signal_out = 0;
357		✗	pending_op_.cont_op.cont.h = h;
358		✗	d.post(pending_op_.cont_op.cont);
359			// completion is always posted to scheduler queue, never inline.
360		✗	return std::noop_coroutine();
361			}
362
363		28x	svc_.start_wait(*this, &pending_op_);
364			// completion is always posted to scheduler queue, never inline.
365		28x	return std::noop_coroutine();
366		28x	}
367
368			inline std::error_code
369		102x	posix_signal::add(int signal_number, signal_set::flags_t flags)
370			{
371		102x	return svc_.add_signal(*this, signal_number, flags);
372			}
373
374			inline std::error_code
375		4x	posix_signal::remove(int signal_number)
376			{
377		4x	return svc_.remove_signal(*this, signal_number);
378			}
379
380			inline std::error_code
381		100x	posix_signal::clear()
382			{
383		100x	return svc_.clear_signals(*this);
384			}
385
386			inline void
387		110x	posix_signal::cancel()
388			{
389		110x	svc_.cancel_wait(*this);
390		110x	}
391
392			// posix_signal_service implementation
393
394		2972x	inline posix_signal_service::posix_signal_service(
395			capy::execution_context&, scheduler& sched)
396		743x	: sched_(&sched)
397		2229x	{
398	2/2 ✓ Branch 0 taken 47552 times. ✓ Branch 1 taken 743 times.	48295x	for (int i = 0; i < max_signal_number; ++i)
399			{
400		47552x	registrations_[i] = nullptr;
401		47552x	registration_count_[i] = 0;
402		47552x	}
403	1/2 ✓ Branch 0 taken 743 times. ✗ Branch 1 not taken.	743x	add_service(this);
404		1486x	}
405
406		2229x	inline posix_signal_service::~posix_signal_service()
407		1486x	{
408	1/2 ✓ Branch 0 taken 743 times. ✗ Branch 1 not taken.	743x	remove_service(this);
409		2229x	}
410
411			inline void
412		743x	posix_signal_service::shutdown()
413			{
414		743x	std::lock_guard lock(mutex_);
415
416	1/2 ✗ Branch 0 not taken. ✓ Branch 1 taken 743 times.	743x	for (auto* impl = impl_list_.pop_front(); impl != nullptr;
417		✗	impl = impl_list_.pop_front())
418			{
419		✗	while (auto* reg = impl->signals_)
420			{
421		✗	impl->signals_ = reg->next_in_set;
422		✗	delete reg;
423			}
424		✗	delete impl;
425		✗	}
426		743x	}
427
428			inline io_object::implementation*
429		96x	posix_signal_service::construct()
430			{
431		96x	auto* impl = new posix_signal(*this);
432
433			{
434		96x	std::lock_guard lock(mutex_);
435		96x	impl_list_.push_back(impl);
436		96x	}
437
438		96x	return impl;
439			}
440
441			inline void
442		96x	posix_signal_service::destroy_impl(posix_signal& impl)
443			{
444			{
445		96x	std::lock_guard lock(mutex_);
446		96x	impl_list_.remove(&impl);
447		96x	}
448
449	1/2 ✗ Branch 0 not taken. ✓ Branch 1 taken 96 times.	96x	delete &impl;
450		96x	}
451
452			inline std::error_code
453		102x	posix_signal_service::add_signal(
454			posix_signal& impl, int signal_number, signal_set::flags_t flags)
455			{
456	3/4 ✓ Branch 0 taken 100 times. ✓ Branch 1 taken 2 times. ✗ Branch 2 not taken. ✓ Branch 3 taken 100 times.	102x	if (signal_number < 0 \|\| signal_number >= max_signal_number)
457		2x	return make_error_code(std::errc::invalid_argument);
458
459			// Validate that requested flags are supported on this platform
460			// (e.g., SA_NOCLDWAIT may not be available on all POSIX systems)
461	1/2 ✓ Branch 0 taken 100 times. ✗ Branch 1 not taken.	100x	if (!posix_signal_detail::flags_supported(flags))
462		✗	return make_error_code(std::errc::operation_not_supported);
463
464		100x	posix_signal_detail::signal_state* state =
465		100x	posix_signal_detail::get_signal_state();
466		100x	std::lock_guard state_lock(state->mutex);
467	1/2 ✓ Branch 0 taken 100 times. ✗ Branch 1 not taken.	100x	std::lock_guard lock(mutex_);
468
469			// Find insertion point (list is sorted by signal number)
470		100x	signal_registration** insertion_point = &impl.signals_;
471		100x	signal_registration* reg = impl.signals_;
472	4/4 ✓ Branch 0 taken 88 times. ✓ Branch 1 taken 22 times. ✓ Branch 2 taken 10 times. ✓ Branch 3 taken 100 times.	110x	while (reg && reg->signal_number < signal_number)
473			{
474		10x	insertion_point = &reg->next_in_set;
475		10x	reg = reg->next_in_set;
476			}
477
478			// Already registered in this set - check flag compatibility
479			// (same signal_set adding same signal twice with different flags)
480	4/4 ✓ Branch 0 taken 12 times. ✓ Branch 1 taken 88 times. ✓ Branch 2 taken 10 times. ✓ Branch 3 taken 2 times.	100x	if (reg && reg->signal_number == signal_number)
481			{
482	3/4 ✓ Branch 0 taken 10 times. ✗ Branch 1 not taken. ✓ Branch 2 taken 8 times. ✓ Branch 3 taken 2 times.	10x	if (!posix_signal_detail::flags_compatible(reg->flags, flags))
483		2x	return make_error_code(std::errc::invalid_argument);
484		8x	return {};
485			}
486
487			// Check flag compatibility with global registration
488			// (different signal_set already registered this signal with different flags)
489	2/2 ✓ Branch 0 taken 8 times. ✓ Branch 1 taken 82 times.	90x	if (state->registration_count[signal_number] > 0)
490			{
491	3/4 ✓ Branch 0 taken 8 times. ✗ Branch 1 not taken. ✓ Branch 2 taken 6 times. ✓ Branch 3 taken 2 times.	8x	if (!posix_signal_detail::flags_compatible(
492		8x	state->registered_flags[signal_number], flags))
493		2x	return make_error_code(std::errc::invalid_argument);
494		6x	}
495
496	1/2 ✓ Branch 0 taken 88 times. ✗ Branch 1 not taken.	88x	auto* new_reg = new signal_registration;
497		88x	new_reg->signal_number = signal_number;
498		88x	new_reg->flags = flags;
499		88x	new_reg->owner = &impl;
500		88x	new_reg->undelivered = 0;
501
502			// Install signal handler on first global registration
503	2/2 ✓ Branch 0 taken 82 times. ✓ Branch 1 taken 6 times.	88x	if (state->registration_count[signal_number] == 0)
504			{
505		82x	struct sigaction sa = {};
506		82x	sa.sa_handler = posix_signal_detail::corosio_posix_signal_handler;
507		82x	sigemptyset(&sa.sa_mask);
508	1/2 ✓ Branch 0 taken 82 times. ✗ Branch 1 not taken.	82x	sa.sa_flags = posix_signal_detail::to_sigaction_flags(flags);
509
510	2/4 ✓ Branch 0 taken 82 times. ✗ Branch 1 not taken. ✓ Branch 2 taken 82 times. ✗ Branch 3 not taken.	82x	if (::sigaction(signal_number, &sa, nullptr) < 0)
511			{
512		✗	delete new_reg;
513		✗	return make_error_code(std::errc::invalid_argument);
514			}
515
516			// Store the flags used for first registration
517		82x	state->registered_flags[signal_number] = flags;
518		82x	}
519
520		88x	new_reg->next_in_set = reg;
521		88x	*insertion_point = new_reg;
522
523		88x	new_reg->next_in_table = registrations_[signal_number];
524		88x	new_reg->prev_in_table = nullptr;
525	2/2 ✓ Branch 0 taken 6 times. ✓ Branch 1 taken 82 times.	88x	if (registrations_[signal_number])
526		6x	registrations_[signal_number]->prev_in_table = new_reg;
527		88x	registrations_[signal_number] = new_reg;
528
529		88x	++state->registration_count[signal_number];
530		88x	++registration_count_[signal_number];
531
532		88x	return {};
533		102x	}
534
535			inline std::error_code
536		4x	posix_signal_service::remove_signal(posix_signal& impl, int signal_number)
537			{
538	2/4 ✓ Branch 0 taken 4 times. ✗ Branch 1 not taken. ✗ Branch 2 not taken. ✓ Branch 3 taken 4 times.	4x	if (signal_number < 0 \|\| signal_number >= max_signal_number)
539		✗	return make_error_code(std::errc::invalid_argument);
540
541		4x	posix_signal_detail::signal_state* state =
542		4x	posix_signal_detail::get_signal_state();
543		4x	std::lock_guard state_lock(state->mutex);
544	1/2 ✓ Branch 0 taken 4 times. ✗ Branch 1 not taken.	4x	std::lock_guard lock(mutex_);
545
546		4x	signal_registration** deletion_point = &impl.signals_;
547		4x	signal_registration* reg = impl.signals_;
548	3/4 ✓ Branch 0 taken 2 times. ✓ Branch 1 taken 2 times. ✗ Branch 2 not taken. ✓ Branch 3 taken 4 times.	4x	while (reg && reg->signal_number < signal_number)
549			{
550		✗	deletion_point = &reg->next_in_set;
551		✗	reg = reg->next_in_set;
552			}
553
554	3/4 ✓ Branch 0 taken 2 times. ✓ Branch 1 taken 2 times. ✗ Branch 2 not taken. ✓ Branch 3 taken 2 times.	4x	if (!reg \|\| reg->signal_number != signal_number)
555		2x	return {};
556
557			// Restore default handler on last global unregistration
558	1/2 ✗ Branch 0 not taken. ✓ Branch 1 taken 2 times.	2x	if (state->registration_count[signal_number] == 1)
559			{
560		2x	struct sigaction sa = {};
561		2x	sa.sa_handler = SIG_DFL;
562		2x	sigemptyset(&sa.sa_mask);
563		2x	sa.sa_flags = 0;
564
565	2/4 ✓ Branch 0 taken 2 times. ✗ Branch 1 not taken. ✓ Branch 2 taken 2 times. ✗ Branch 3 not taken.	2x	if (::sigaction(signal_number, &sa, nullptr) < 0)
566		✗	return make_error_code(std::errc::invalid_argument);
567
568			// Clear stored flags
569		2x	state->registered_flags[signal_number] = signal_set::none;
570		2x	}
571
572		2x	*deletion_point = reg->next_in_set;
573
574	1/2 ✗ Branch 0 not taken. ✓ Branch 1 taken 2 times.	2x	if (registrations_[signal_number] == reg)
575		2x	registrations_[signal_number] = reg->next_in_table;
576	1/2 ✓ Branch 0 taken 2 times. ✗ Branch 1 not taken.	2x	if (reg->prev_in_table)
577		✗	reg->prev_in_table->next_in_table = reg->next_in_table;
578	1/2 ✓ Branch 0 taken 2 times. ✗ Branch 1 not taken.	2x	if (reg->next_in_table)
579		✗	reg->next_in_table->prev_in_table = reg->prev_in_table;
580
581		2x	--state->registration_count[signal_number];
582		2x	--registration_count_[signal_number];
583
584	1/2 ✗ Branch 0 not taken. ✓ Branch 1 taken 2 times.	2x	delete reg;
585		2x	return {};
586		4x	}
587
588			inline std::error_code
589		100x	posix_signal_service::clear_signals(posix_signal& impl)
590			{
591		100x	posix_signal_detail::signal_state* state =
592		100x	posix_signal_detail::get_signal_state();
593		100x	std::lock_guard state_lock(state->mutex);
594	1/2 ✓ Branch 0 taken 100 times. ✗ Branch 1 not taken.	100x	std::lock_guard lock(mutex_);
595
596		100x	std::error_code first_error;
597
598	2/2 ✓ Branch 0 taken 86 times. ✓ Branch 1 taken 100 times.	186x	while (signal_registration* reg = impl.signals_)
599			{
600		86x	int signal_number = reg->signal_number;
601
602	2/2 ✓ Branch 0 taken 6 times. ✓ Branch 1 taken 80 times.	86x	if (state->registration_count[signal_number] == 1)
603			{
604		80x	struct sigaction sa = {};
605		80x	sa.sa_handler = SIG_DFL;
606		80x	sigemptyset(&sa.sa_mask);
607		80x	sa.sa_flags = 0;
608
609	2/6 ✗ Branch 0 not taken. ✓ Branch 1 taken 80 times. ✗ Branch 2 not taken. ✓ Branch 3 taken 80 times. ✗ Branch 4 not taken. ✗ Branch 5 not taken.	80x	if (::sigaction(signal_number, &sa, nullptr) < 0 && !first_error)
610		✗	first_error = make_error_code(std::errc::invalid_argument);
611
612			// Clear stored flags
613		80x	state->registered_flags[signal_number] = signal_set::none;
614		80x	}
615
616		86x	impl.signals_ = reg->next_in_set;
617
618	1/2 ✗ Branch 0 not taken. ✓ Branch 1 taken 86 times.	86x	if (registrations_[signal_number] == reg)
619		86x	registrations_[signal_number] = reg->next_in_table;
620	1/2 ✓ Branch 0 taken 86 times. ✗ Branch 1 not taken.	86x	if (reg->prev_in_table)
621		✗	reg->prev_in_table->next_in_table = reg->next_in_table;
622	2/2 ✓ Branch 0 taken 80 times. ✓ Branch 1 taken 6 times.	86x	if (reg->next_in_table)
623		6x	reg->next_in_table->prev_in_table = reg->prev_in_table;
624
625		86x	--state->registration_count[signal_number];
626		86x	--registration_count_[signal_number];
627
628	1/2 ✗ Branch 0 not taken. ✓ Branch 1 taken 86 times.	86x	delete reg;
629			}
630
631	1/2 ✗ Branch 0 not taken. ✓ Branch 1 taken 100 times.	100x	if (first_error)
632		✗	return first_error;
633		100x	return {};
634		100x	}
635
636			inline void
637		110x	posix_signal_service::cancel_wait(posix_signal& impl)
638			{
639		110x	bool was_waiting = false;
640		110x	signal_op* op = nullptr;
641
642			{
643		110x	std::lock_guard lock(mutex_);
644		110x	impl.cancelled_ = true;
645	2/2 ✓ Branch 0 taken 106 times. ✓ Branch 1 taken 4 times.	110x	if (impl.waiting_)
646			{
647		4x	was_waiting = true;
648		4x	impl.waiting_ = false;
649		4x	op = &impl.pending_op_;
650		4x	}
651		110x	}
652
653	2/2 ✓ Branch 0 taken 106 times. ✓ Branch 1 taken 4 times.	110x	if (was_waiting)
654			{
655	1/2 ✗ Branch 0 not taken. ✓ Branch 1 taken 4 times.	4x	if (op->ec_out)
656		4x	*op->ec_out = make_error_code(capy::error::canceled);
657	1/2 ✗ Branch 0 not taken. ✓ Branch 1 taken 4 times.	4x	if (op->signal_out)
658		4x	*op->signal_out = 0;
659		4x	op->cont_op.cont.h = op->h;
660		4x	op->d.post(op->cont_op.cont);
661		4x	sched_->work_finished();
662		4x	}
663		110x	}
664
665			inline void
666		28x	posix_signal_service::start_wait(posix_signal& impl, signal_op* op)
667			{
668			{
669		28x	std::lock_guard lock(mutex_);
670
671			// Check if cancel() was called before this wait started
672	2/2 ✓ Branch 0 taken 2 times. ✓ Branch 1 taken 26 times.	28x	if (impl.cancelled_)
673			{
674		2x	impl.cancelled_ = false;
675	1/2 ✗ Branch 0 not taken. ✓ Branch 1 taken 2 times.	2x	if (op->ec_out)
676		2x	*op->ec_out = make_error_code(capy::error::canceled);
677	1/2 ✗ Branch 0 not taken. ✓ Branch 1 taken 2 times.	2x	if (op->signal_out)
678		2x	*op->signal_out = 0;
679		2x	op->cont_op.cont.h = op->h;
680	1/2 ✓ Branch 0 taken 2 times. ✗ Branch 1 not taken.	2x	op->d.post(op->cont_op.cont);
681		2x	return;
682			}
683
684			// Check for queued signals first (signal arrived before wait started)
685		26x	signal_registration* reg = impl.signals_;
686	2/2 ✓ Branch 0 taken 28 times. ✓ Branch 1 taken 16 times.	44x	while (reg)
687			{
688	2/2 ✓ Branch 0 taken 10 times. ✓ Branch 1 taken 18 times.	28x	if (reg->undelivered > 0)
689			{
690		10x	--reg->undelivered;
691		10x	op->signal_number = reg->signal_number;
692			// svc=nullptr: no work_finished needed since we never called work_started
693		10x	op->svc = nullptr;
694	1/2 ✓ Branch 0 taken 10 times. ✗ Branch 1 not taken.	10x	sched_->post(op);
695		10x	return;
696			}
697		18x	reg = reg->next_in_set;
698			}
699
700			// No queued signals - wait for delivery
701		16x	impl.waiting_ = true;
702			// svc=this: signal_op::operator() will call work_finished() to balance this
703		16x	op->svc = this;
704		16x	sched_->work_started();
705		28x	}
706		28x	}
707
708			inline void
709		20x	posix_signal_service::deliver_signal(int signal_number)
710			{
711	2/4 ✓ Branch 0 taken 20 times. ✗ Branch 1 not taken. ✗ Branch 2 not taken. ✓ Branch 3 taken 20 times.	20x	if (signal_number < 0 \|\| signal_number >= max_signal_number)
712		✗	return;
713
714		20x	posix_signal_detail::signal_state* state =
715		20x	posix_signal_detail::get_signal_state();
716		20x	std::lock_guard lock(state->mutex);
717
718		20x	posix_signal_service* service = state->service_list;
719	2/2 ✓ Branch 0 taken 20 times. ✓ Branch 1 taken 20 times.	40x	while (service)
720			{
721	1/2 ✓ Branch 0 taken 20 times. ✗ Branch 1 not taken.	20x	std::lock_guard svc_lock(service->mutex_);
722
723		20x	signal_registration* reg = service->registrations_[signal_number];
724	2/2 ✓ Branch 0 taken 22 times. ✓ Branch 1 taken 20 times.	42x	while (reg)
725			{
726		22x	posix_signal* impl = static_cast<posix_signal*>(reg->owner);
727
728	2/2 ✓ Branch 0 taken 12 times. ✓ Branch 1 taken 10 times.	22x	if (impl->waiting_)
729			{
730		12x	impl->waiting_ = false;
731		12x	impl->pending_op_.signal_number = signal_number;
732	1/2 ✗ Branch 0 not taken. ✓ Branch 1 taken 12 times.	12x	service->post(&impl->pending_op_);
733		12x	}
734			else
735			{
736		10x	++reg->undelivered;
737			}
738
739		22x	reg = reg->next_in_table;
740			}
741
742		20x	service = service->next_;
743		20x	}
744		20x	}
745
746			inline void
747			posix_signal_service::work_started() noexcept
748			{
749			sched_->work_started();
750			}
751
752			inline void
753		12x	posix_signal_service::work_finished() noexcept
754			{
755		12x	sched_->work_finished();
756		12x	}
757
758			inline void
759		12x	posix_signal_service::post(signal_op* op)
760			{
761		12x	sched_->post(op);
762		12x	}
763
764			inline void
765		743x	posix_signal_service::add_service(posix_signal_service* service)
766			{
767		743x	posix_signal_detail::signal_state* state =
768		743x	posix_signal_detail::get_signal_state();
769		743x	std::lock_guard lock(state->mutex);
770
771		743x	service->next_ = state->service_list;
772		743x	service->prev_ = nullptr;
773	2/2 ✓ Branch 0 taken 738 times. ✓ Branch 1 taken 5 times.	743x	if (state->service_list)
774		5x	state->service_list->prev_ = service;
775		743x	state->service_list = service;
776		743x	}
777
778			inline void
779		743x	posix_signal_service::remove_service(posix_signal_service* service)
780			{
781		743x	posix_signal_detail::signal_state* state =
782		743x	posix_signal_detail::get_signal_state();
783		743x	std::lock_guard lock(state->mutex);
784
785	4/6 ✓ Branch 0 taken 738 times. ✓ Branch 1 taken 5 times. ✓ Branch 2 taken 738 times. ✗ Branch 3 not taken. ✗ Branch 4 not taken. ✓ Branch 5 taken 738 times.	743x	if (service->next_ \|\| service->prev_ \|\| state->service_list == service)
786			{
787	1/2 ✗ Branch 0 not taken. ✓ Branch 1 taken 743 times.	743x	if (state->service_list == service)
788		743x	state->service_list = service->next_;
789	1/2 ✓ Branch 0 taken 743 times. ✗ Branch 1 not taken.	743x	if (service->prev_)
790		✗	service->prev_->next_ = service->next_;
791	2/2 ✓ Branch 0 taken 738 times. ✓ Branch 1 taken 5 times.	743x	if (service->next_)
792		5x	service->next_->prev_ = service->prev_;
793		743x	service->next_ = nullptr;
794		743x	service->prev_ = nullptr;
795		743x	}
796		743x	}
797
798			// get_signal_service - factory function
799
800			inline posix_signal_service&
801		743x	get_signal_service(capy::execution_context& ctx, scheduler& sched)
802			{
803		743x	return ctx.make_service<posix_signal_service>(sched);
804			}
805
806			} // namespace detail
807			} // namespace boost::corosio
808
809			#endif // BOOST_COROSIO_POSIX
810
811			#endif // BOOST_COROSIO_NATIVE_DETAIL_POSIX_POSIX_SIGNAL_SERVICE_HPP
812