hw: introduce non-blocking signal checking

* Introduces pending_signal syscall to check for new signals for the
  calling thread without blocking
* Implements pending_signal in the base-library specific for hw to use the
  new syscall

Fix #3217

repos/base-hw/src/core/kernel/thread.cc

@@ -464,6 +464,33 @@ void Thread::_call_await_signal()
 }
 
 
+void Thread::_call_pending_signal()
+{
+	/* lookup receiver */
+	Signal_receiver * const r = pd().cap_tree().find<Signal_receiver>(user_arg_1());
+	if (!r) {
+		Genode::warning(*this, ": cannot await, unknown signal receiver ",
+		                (unsigned)user_arg_1());
+		user_arg_0(-1);
+		return;
+	}
+
+	/* register handler at the receiver */
+	if (r->add_handler(this)) {
+		user_arg_0(-1);
+		return;
+	}
+
+	if (_state == AWAITS_SIGNAL) {
+		_cancel_blocking();
+		user_arg_0(-1);
+		return;
+	}
+
+	user_arg_0(0);
+}
+
+
 void Thread::_call_cancel_next_await_signal()
 {
 	/* kill the caller if the capability of the target thread is invalid */
@@ -631,6 +658,7 @@ void Thread::_call()
 	case call_id_kill_signal_context():      _call_kill_signal_context(); return;
 	case call_id_submit_signal():            _call_submit_signal(); return;
 	case call_id_await_signal():             _call_await_signal(); return;
+	case call_id_pending_signal():           _call_pending_signal(); return;
 	case call_id_cancel_next_await_signal(): _call_cancel_next_await_signal(); return;
 	case call_id_ack_signal():               _call_ack_signal(); return;
 	case call_id_print_char():               _call_print_char(); return;

repos/base-hw/src/core/kernel/thread.h

@@ -216,6 +216,7 @@ class Kernel::Thread
 		void _call_update_instr_region();
 		void _call_print_char();
 		void _call_await_signal();
+		void _call_pending_signal();
 		void _call_cancel_next_await_signal();
 		void _call_submit_signal();
 		void _call_ack_signal();

repos/base-hw/src/lib/base/signal_receiver.cc

@@ -129,9 +129,10 @@ void Signal_receiver::block_for_signal()
 		/* canceled */
 		return;
 	}
+
 	/* read signal data */
-	const void * const     utcb    = Thread::myself()->utcb()->data();
-	Signal::Data * const   data    = (Signal::Data *)utcb;
+	Signal::Data * const data =
+		(Signal::Data *)Thread::myself()->utcb()->data();
 	Signal_context * const context = data->context;
 
 	/**
@@ -145,11 +146,60 @@ void Signal_receiver::block_for_signal()
 		context->_pending     = true;
 		context->_curr_signal = Signal::Data(context, num);
 	}
+
 	/* end kernel-aided life-time management */
 	Kernel::ack_signal(Capability_space::capid(data->context->_cap));
 }
 
 
+Signal Signal_receiver::pending_signal()
+{
+	Lock::Guard contexts_lock_guard(_contexts_lock);
+	Signal::Data result;
+	_contexts.for_each_locked([&] (Signal_context &context) {
+
+		if (!context._pending) return;
+
+		_contexts.head(context._next);
+		context._pending     = false;
+		result               = context._curr_signal;
+		context._curr_signal = Signal::Data(0, 0);
+
+		Trace::Signal_received trace_event(context, result.num);
+		throw Context_ring::Break_for_each();
+	});
+	if (result.context) {
+		Lock::Guard lock_guard(result.context->_lock);
+		if (result.num == 0)
+			warning("returning signal with num == 0");
+
+		return result;
+	}
+
+	/* look for pending signals */
+	if (Kernel::pending_signal(Capability_space::capid(_cap)) != 0) {
+		throw Signal_not_pending();
+	}
+
+	/* read signal data */
+	Signal::Data * const data =
+		(Signal::Data *)Thread::myself()->utcb()->data();
+	Signal_context * const context = data->context;
+
+	{
+		/* update signal context */
+		Lock::Guard lock_guard(context->_lock);
+		context->_pending     = false;
+		context->_curr_signal = Signal::Data(context, data->num);
+		result                = context->_curr_signal;
+	}
+
+	/* end kernel-aided life-time management */
+	Kernel::ack_signal(Capability_space::capid(data->context->_cap));
+	return result;
+}
+
+
 void Signal_receiver::unblock_signal_waiter(Rpc_entrypoint &rpc_ep)
 {
 	Kernel::cancel_next_await_signal(native_thread_id(&rpc_ep));