ehmry/genode
ehmry
/
genode
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

hw: signal receiver in extra header without assert 

ref #528
This commit is contained in:
Martin Stein 2013-09-06 01:36:03 +02:00 committed by Norman Feske
parent bf37159eb9
commit 48f831af3c
3 changed files with 236 additions and 347 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

212
base-hw/src/core/kernel.cc
View File

@ -23,7 +23,6 @@
*/
/* Genode includes */
#include <base/signal.h>
#include <cpu/cpu_state.h>
#include <base/thread_state.h>
@ -56,7 +55,7 @@ namespace Kernel
{
/* import Genode types */
typedef Genode::Thread_state Thread_state;
typedef Genode::umword_t umword_t;
typedef Genode::umword_t umword_t;
class Schedule_context;
@ -297,13 +296,6 @@ void Kernel::Thread::await_signal(Kernel::Signal_receiver * receiver)
}
void Kernel::Thread::received_signal()
{
assert(_state == AWAIT_SIGNAL);
_schedule();
}
void Kernel::Thread::_received_irq()
{
assert(_state == AWAIT_IRQ);
@ -361,145 +353,13 @@ void Kernel::Thread::_awaits_irq()
namespace Kernel
{
class Signal_receiver;
/**
* Specific signal type, owned by a receiver, can be triggered asynchr.
*/
class Signal_context : public Object<Signal_context, MAX_SIGNAL_CONTEXTS>,
public Fifo<Signal_context>::Element
void deliver_signal(Signal_handler * const dst,
void * const base,
size_t const size)
{
friend class Signal_receiver;
Signal_receiver * const _receiver; /* the receiver that owns us */
unsigned const _imprint; /* every outgoing signals gets
* signed with this */
unsigned _submits; /* accumul. undelivered submits */
bool _await_ack; /* delivery ack pending */
Thread * _killer; /* awaits our destruction if >0 */
/**
* Utility to deliver all remaining submits
*/
void _deliver();
/**
* Called by receiver when all submits have been delivered
*/
void _delivered()
{
_submits = 0;
_await_ack = 1;
}
public:
/**
* Constructor
*/
Signal_context(Signal_receiver * const r, unsigned const imprint) :
_receiver(r), _imprint(imprint),
_submits(0), _await_ack(0), _killer(0) { }
/**
* Submit the signal
*
* \param n number of submits
*/
void submit(unsigned const n);
/**
* Acknowledge delivery of signal
*/
void ack();
/**
* Destruct or prepare to do it at next call of 'ack'
*
* \return wether destruction is done
*/
bool kill(Thread * const killer)
{
assert(!_killer);
_killer = killer;
if (_await_ack) {
_killer->kill_signal_context_blocks();
return 0;
}
this->~Signal_context();
return 1;
}
};
/**
* Manage signal contexts and enable threads to trigger and await them
*/
class Signal_receiver :
public Object<Signal_receiver, MAX_SIGNAL_RECEIVERS>
{
Fifo<Thread> _listeners;
Fifo<Signal_context> _pending_contexts;
/**
* Deliver as much submitted signals to listening threads as possible
*/
void _listen()
{
while (1)
{
/* any pending context? */
if (_pending_contexts.empty()) return;
Signal_context * const c = _pending_contexts.dequeue();
/* if there is no listener, enqueue context again and return */
if (_listeners.empty()) {
_pending_contexts.enqueue(c);
return;
}
/* awake a listener and transmit signal info to it */
Thread * const t = _listeners.dequeue();
Signal::Data data((Genode::Signal_context *)c->_imprint,
c->_submits);
*(Signal::Data *)t->phys_utcb()->base() = data;
t->received_signal();
c->_delivered();
}
}
public:
/**
* Let a thread listen to our contexts
*/
void add_listener(Thread * const t)
{
t->await_signal(this);
_listeners.enqueue(t);
_listen();
}
/**
* Stop a thread from listening to our contexts
*/
void remove_listener(Thread * const t) {
_listeners.remove(t); }
/**
* If any of our contexts is pending
*/
bool pending() { return !_pending_contexts.empty(); }
/**
* Recognize that 'c' wants to deliver
*/
void deliver(Signal_context * const c)
{
assert(c->_receiver == this);
if (!c->is_enqueued()) _pending_contexts.enqueue(c);
_listen();
}
};
((Thread *)dst->id())->receive_signal(base, size);
}
class Vm : public Object<Vm, MAX_VMS>,
public Schedule_context
@ -1053,7 +913,8 @@ namespace Kernel
assert(r);
/* let user listen to receiver */
r->add_listener(user);
user->await_signal(r);
r->add_handler(user->signal_handler());
}
@ -1068,7 +929,7 @@ namespace Kernel
assert(r);
/* set return value */
user->user_arg_0(r->pending());
user->user_arg_0(r->deliverable());
}
@ -1094,10 +955,11 @@ namespace Kernel
*/
void do_ack_signal(Thread * const user)
{
Signal_context * const c =
Signal_context::pool()->object(user->user_arg_1());
assert(c);
c->ack();
unsigned id = user->user_arg_1();
Signal_context * const c = Signal_context::pool()->object(id);
if (!c) return;
Thread * const t = (Thread *)c->ack();
if (t) { t->kill_signal_context_done(); }
}
@ -1106,10 +968,11 @@ namespace Kernel
*/
void do_kill_signal_context(Thread * const user)
{
Signal_context * const c =
Signal_context::pool()->object(user->user_arg_1());
assert(c);
user->user_arg_0(c->kill(user));
unsigned id = user->user_arg_1();
Signal_context * const c = Signal_context::pool()->object(id);
if (!c) { return; }
if (c->kill((unsigned)user)) { return; }
user->kill_signal_context_blocks();
}
/**
@ -1319,7 +1182,7 @@ int Kernel::Thread::resume()
return 0;
case AWAIT_SIGNAL:
PDBG("cancel signal receipt");
_signal_receiver->remove_listener(this);
_signal_receiver->remove_handler(signal_handler());
_schedule();
return 0;
case AWAIT_SIGNAL_CONTEXT_DESTRUCT:
@ -1409,38 +1272,3 @@ void Thread::kill_signal_context_done()
user_arg_0(1);
_schedule();
}
/****************************
** Kernel::Signal_context **
****************************/
void Signal_context::_deliver()
{
if (!_submits) return;
_receiver->deliver(this);
}
void Signal_context::ack()
{
assert(_await_ack);
_await_ack = 0;
if (!_killer) {
_deliver();
return;
}
_killer->kill_signal_context_done();
this->~Signal_context();
}
void Signal_context::submit(unsigned const n)
{
assert(_submits < (unsigned)~0 - n);
if (_killer) return;
_submits += n;
if (_await_ack) return;
_deliver();
}

338
base-hw/src/core/kernel/signal_receiver.h
View File

@ -21,48 +21,83 @@
/* core include */
#include <kernel/configuration.h>
#include <kernel/object.h>
#include <assert.h>
namespace Kernel
{
typedef Genode::Signal Signal;
class Signal_receiver;
template <typename T> class Fifo : public Genode::Fifo<T> { };
class Signal_listener : public Fifo<Signal_listener>::Element
{
public:
virtual void receive_signal(void * const signal_base,
size_t const signal_size) = 0;
};
/**
* Enables external components to act as a signal handler
*/
class Signal_handler;
/**
* Specific signal type, owned by a receiver, can be triggered asynchr.
* Signal types that are assigned to a signal receiver each
*/
class Signal_context : public Object<Signal_context, MAX_SIGNAL_CONTEXTS>,
public Fifo<Signal_context>::Element
{
friend class Signal_receiver;
class Signal_context;
Signal_receiver * const _receiver; /* the receiver that owns us */
unsigned const _imprint; /* every outgoing signals gets
* signed with this */
unsigned _submits; /* accumul. undelivered submits */
bool _await_ack; /* delivery ack pending */
/**
* Combines signal contexts to an entity that handlers can listen to
*/
class Signal_receiver;
/*
* if not zero, _killer_id holds the ID of the actor
* that awaits the destruction of the signal context
*/
unsigned _killer_id;
/**
* Signal delivery backend
*
* \param dst destination
* \param base signal-data base
* \param size signal-data size
*/
void deliver_signal(Signal_handler * const dst,
void * const base,
size_t const size);
}
class Kernel::Signal_handler
{
friend class Signal_receiver;
private:
typedef Genode::Fifo_element<Signal_handler> Fifo_element;
Fifo_element _fe;
unsigned const _id;
public:
/**
* Utility to deliver all remaining submits
* Constructor
*/
inline void _deliver();
Signal_handler(unsigned id) : _fe(this), _id(id) { }
/***************
** Accessors **
***************/
unsigned id() { return _id; }
};
class Kernel::Signal_context
:
public Object<Signal_context, MAX_SIGNAL_CONTEXTS>
{
friend class Signal_receiver;
private:
typedef Genode::Fifo_element<Signal_context> Fifo_element;
Fifo_element _fe;
Signal_receiver * const _receiver;
unsigned const _imprint;
unsigned _submits;
bool _ack;
unsigned _killer;
/**
* Tell receiver about the submits of the context if any
*/
inline void _deliverable();
/**
* Called by receiver when all submits have been delivered
@ -70,139 +105,162 @@ namespace Kernel
void _delivered()
{
_submits = 0;
_await_ack = 1;
_ack = 0;
}
public:
/**
* Constructor
*/
Signal_context(Signal_receiver * const r, unsigned const imprint) :
_receiver(r), _imprint(imprint),
_submits(0), _await_ack(0), _killer_id(0) { }
/**
* Submit the signal
*
* \param n number of submits
*/
void submit(unsigned const n)
{
assert(_submits < (unsigned)~0 - n);
if (_killer_id) { return; }
_submits += n;
if (_await_ack) { return; }
_deliver();
}
/**
* Acknowledge delivery of signal
*
* \retval 0 no kill request finished
* \retval > 0 name of finished kill request
*/
unsigned ack()
{
assert(_await_ack);
_await_ack = 0;
if (!_killer_id) {
_deliver();
return 0;
}
this->~Signal_context();
return _killer_id;
}
/**
* Destruct or prepare to do it at next call of 'ack'
*
* \param killer_id name of the kill request
*
* \return wether destruction is done
*/
bool kill(unsigned const killer_id)
{
assert(!_killer_id);
_killer_id = killer_id;
if (_await_ack) { return 0; }
this->~Signal_context();
return 1;
}
};
/**
* Manage signal contexts & enable external actors to trigger & await them
*/
class Signal_receiver :
public Object<Signal_receiver, MAX_SIGNAL_RECEIVERS>
{
Fifo<Signal_listener> _listeners;
Fifo<Signal_context> _pending_contexts;
public:
/**
* Deliver as much submitted signals to listeners as possible
* Constructor
*/
Signal_context(Signal_receiver * const r, unsigned const imprint)
:
_fe(this), _receiver(r), _imprint(imprint), _submits(0), _ack(1),
_killer(0)
{ }
/**
* Submit the signal
*
* \param n number of submits
*/
void submit(unsigned const n)
{
if (_submits >= (unsigned)~0 - n) {
PERR("overflow at signal-submit count");
return;
}
if (_killer) {
PERR("signal context already in destruction");
return;
}
_submits += n;
if (!_ack) { return; }
_deliverable();
}
/**
* Acknowledge delivery of signal
*
* \retval 0 no kill request finished
* \retval > 0 name of finished kill request
*/
unsigned ack()
{
if (_ack) {
PERR("unexpected signal acknowledgment");
return 0;
}
if (!_killer) {
_ack = 1;
_deliverable();
return 0;
}
this->~Signal_context();
return _killer;
}
/**
* Destruct context or prepare to do it as soon as delivery is done
*
* \param killer name of the kill request
*
* \retval 1 destruction is done
* \retval 0 destruction is initiated, will be done with the next ack
*/
bool kill(unsigned const killer)
{
/* FIXME: aggregate or avoid multiple kill requests */
if (_killer) {
PERR("multiple kill requests");
while (1) { }
}
_killer = killer;
if (!_ack) { return 0; }
this->~Signal_context();
return 1;
}
};
class Kernel::Signal_receiver
:
public Object<Signal_receiver, MAX_SIGNAL_RECEIVERS>
{
friend class Signal_context;
private:
typedef Genode::Signal Signal;
template <typename T> class Fifo : public Genode::Fifo<T> { };
Fifo<Signal_handler::Fifo_element> _handlers;
Fifo<Signal_context::Fifo_element> _deliverable;
/**
* Recognize that context 'c' has submits to deliver
*/
void _add_deliverable(Signal_context * const c)
{
if (!c->_fe.is_enqueued()) _deliverable.enqueue(&c->_fe);
_listen();
}
/**
* Deliver as much submits as possible
*/
void _listen()
{
while (1)
{
/* any pending context? */
if (_pending_contexts.empty()) return;
Signal_context * const c = _pending_contexts.dequeue();
/* check if there are deliverable signal */
if (_deliverable.empty()) return;
Signal_context * const c = _deliverable.dequeue()->object();
/* if there is no listener, enqueue context again and return */
if (_listeners.empty()) {
_pending_contexts.enqueue(c);
/* if there is no handler re-enqueue context and exit */
if (_handlers.empty()) {
_deliverable.enqueue(&c->_fe);
return;
}
/* awake a listener and transmit signal info to it */
Signal_listener * const l = _listeners.dequeue();
/* delivery from context to handler */
Signal_handler * const h = _handlers.dequeue()->object();
Signal::Data data((Genode::Signal_context *)c->_imprint,
c->_submits);
l->receive_signal(&data, sizeof(data));
c->_submits);
deliver_signal(h, &data, sizeof(data));
c->_delivered();
}
}
public:
public:
/**
* Let a listener listen to the contexts of the receiver
*/
void add_listener(Signal_listener * const l)
{
_listeners.enqueue(l);
_listen();
}
/**
* Let a handler wait for signals of the receiver
*/
void add_handler(Signal_handler * const h)
{
_handlers.enqueue(&h->_fe);
_listen();
}
/**
* Stop a listener from listen to the contexts of the receiver
*/
void remove_listener(Signal_listener * const l) { _listeners.remove(l); }
/**
* Stop a handler from waiting for signals of the receiver
*/
void remove_handler(Signal_handler * const h)
{
_handlers.remove(&h->_fe);
}
/**
* Return wether any of the contexts of this receiver is pending
*/
bool pending() { return !_pending_contexts.empty(); }
/**
* Return wether any of the contexts of this receiver is deliverable
*/
bool deliverable() { return !_deliverable.empty(); }
};
/**
* Recognize that context 'c' wants to be delivered
*/
void deliver(Signal_context * const c)
{
assert(c->_receiver == this);
if (!c->is_enqueued()) _pending_contexts.enqueue(c);
_listen();
}
};
}
void Kernel::Signal_context::_deliver()
void Kernel::Signal_context::_deliverable()
{
if (!_submits) return;
_receiver->deliver(this);
_receiver->_add_deliverable(this);
}
#endif /* _KERNEL__SIGNAL_RECEIVER_ */

33
base-hw/src/core/kernel/thread.h
View File

@ -15,6 +15,7 @@
#define _CORE__KERNEL__THREAD_H_
/* core includes */
#include <kernel/signal_receiver.h>
#include <kernel/ipc_node.h>
#include <kernel/configuration.h>
#include <kernel/scheduler.h>
@ -34,7 +35,6 @@ namespace Kernel
typedef Genode::Cpu Cpu;
typedef Genode::Page_flags Page_flags;
typedef Genode::Core_tlb Core_tlb;
typedef Genode::Signal Signal;
typedef Genode::Pagefault Pagefault;
typedef Genode::Native_utcb Native_utcb;
@ -52,15 +52,12 @@ namespace Kernel
virtual void proceed() = 0;
};
template <typename T> class Fifo : public Genode::Fifo<T> { };
/**
* Kernel representation of a user thread
*/
class Thread : public Cpu::User_context,
public Object<Thread, MAX_THREADS>,
public Schedule_context,
public Fifo<Thread>::Element,
public Ipc_node,
public Irq_receiver
{
@ -84,8 +81,8 @@ namespace Kernel
unsigned _pd_id; /* ID of the PD this thread runs on */
Native_utcb * _phys_utcb; /* physical UTCB base */
Native_utcb * _virt_utcb; /* virtual UTCB base */
Signal_receiver * _signal_receiver; /* receiver we are currently
* listen to */
Signal_receiver * _signal_receiver;
Signal_handler _signal_handler;
/**
* Resume execution
@ -112,15 +109,24 @@ namespace Kernel
public:
void receive_signal(void * const base, size_t const size)
{
assert(_state == AWAIT_SIGNAL);
assert(size <= phys_utcb()->size())
Genode::memcpy(phys_utcb()->base(), base, size);
_schedule();
}
void * operator new (size_t, void * p) { return p; }
/**
* Constructor
*/
Thread(Platform_thread * const platform_thread) :
_platform_thread(platform_thread),
_state(AWAIT_START), _pager(0), _pd_id(0),
_phys_utcb(0), _virt_utcb(0), _signal_receiver(0)
Thread(Platform_thread * const platform_thread)
:
_platform_thread(platform_thread), _state(AWAIT_START),
_pager(0), _pd_id(0), _phys_utcb(0), _virt_utcb(0),
_signal_receiver(0), _signal_handler((unsigned)this)
{ }
/**
@ -210,11 +216,6 @@ namespace Kernel
*/
void await_signal(Kernel::Signal_receiver * receiver);
/**
* Gets called when we have received a signal at a signal receiver
*/
void received_signal();
/**
* Handle the exception that currently blocks this thread
*/
@ -241,6 +242,8 @@ namespace Kernel
unsigned pd_id() const { return _pd_id; }
Native_utcb * phys_utcb() const { return _phys_utcb; }
Signal_handler * signal_handler() { return &_signal_handler; }
};
}