diff --git a/repos/base-hw/src/lib/base/signal_receiver.cc b/repos/base-hw/src/lib/base/signal_receiver.cc index 6ad769adc..254240671 100644 --- a/repos/base-hw/src/lib/base/signal_receiver.cc +++ b/repos/base-hw/src/lib/base/signal_receiver.cc @@ -79,11 +79,11 @@ void Signal_receiver::_platform_begin_dissolve(Signal_context * const c) { /** * Mark the Signal_context as already pending to prevent the receiver - * from taking the lock, and set an invalid context to prevent further + * from taking the mutex, and set an invalid context to prevent further * processing */ { - Lock::Guard context_guard(c->_lock); + Mutex::Guard context_guard(c->_mutex); c->_pending = true; c->_curr_signal = Signal::Data(nullptr, 0); } @@ -96,8 +96,8 @@ void Signal_receiver::_platform_finish_dissolve(Signal_context *) { } Signal_context_capability Signal_receiver::manage(Signal_context * const c) { /* ensure that the context isn't managed already */ - Lock::Guard contexts_guard(_contexts_lock); - Lock::Guard context_guard(c->_lock); + Mutex::Guard contexts_guard(_contexts_mutex); + Mutex::Guard context_guard(c->_mutex); if (c->_receiver) { throw Context_already_in_use(); } for (;;) { @@ -137,11 +137,11 @@ void Signal_receiver::block_for_signal() /** * Check for the signal being pending already to prevent a dead-lock - * when the context is in destruction, and its lock is held + * when the context is in destruction, and its mutex is held */ if (!context->_pending) { /* update signal context */ - Lock::Guard lock_guard(context->_lock); + Mutex::Guard context_guard(context->_mutex); unsigned const num = context->_curr_signal.num + data->num; context->_pending = true; context->_curr_signal = Signal::Data(context, num); @@ -154,7 +154,7 @@ void Signal_receiver::block_for_signal() Signal Signal_receiver::pending_signal() { - Lock::Guard contexts_lock_guard(_contexts_lock); + Mutex::Guard contexts_guard(_contexts_mutex); Signal::Data result; _contexts.for_each_locked([&] (Signal_context &context) { @@ -169,7 +169,7 @@ Signal Signal_receiver::pending_signal() throw Context_ring::Break_for_each(); }); if (result.context) { - Lock::Guard lock_guard(result.context->_lock); + Mutex::Guard context_guard(result.context->_mutex); if (result.num == 0) warning("returning signal with num == 0"); @@ -188,7 +188,7 @@ Signal Signal_receiver::pending_signal() { /* update signal context */ - Lock::Guard lock_guard(context->_lock); + Mutex::Guard context_guard(context->_mutex); context->_pending = false; context->_curr_signal = Signal::Data(context, data->num); result = context->_curr_signal; diff --git a/repos/base-nova/src/lib/base/rpc_entrypoint.cc b/repos/base-nova/src/lib/base/rpc_entrypoint.cc index d2c704eea..f761fb1d5 100644 --- a/repos/base-nova/src/lib/base/rpc_entrypoint.cc +++ b/repos/base-nova/src/lib/base/rpc_entrypoint.cc @@ -64,7 +64,7 @@ Untyped_capability Rpc_entrypoint::_manage(Rpc_object_base *obj) } static void cleanup_call(Rpc_object_base *obj, Nova::Utcb * ep_utcb, - Native_capability &cap, Genode::Lock &delay_start) + Native_capability &cap, Genode::Blockade &delay_start) { /* effectively invalidate the capability used before */ @@ -85,7 +85,7 @@ static void cleanup_call(Rpc_object_base *obj, Nova::Utcb * ep_utcb, return; /* activate entrypoint now - otherwise cleanup call will block forever */ - delay_start.unlock(); + delay_start.wakeup(); /* make a IPC to ensure that cap() identifier is not used anymore */ utcb->msg()[0] = 0xdead; @@ -159,10 +159,11 @@ void Rpc_entrypoint::_activation_entry() ep._rcv_buf.reset(); reply(utcb, exc, ep._snd_buf); } - { - /* potentially delay start */ - Lock::Guard lock_guard(ep._delay_start); - } + + /* delay start */ + ep._delay_start.block(); + /* XXX inadequate usage of Blockade here is planned to be removed, see #3612 */ + ep._delay_start.wakeup(); /* atomically lookup and lock referenced object */ auto lambda = [&] (Rpc_object_base *obj) { @@ -207,7 +208,7 @@ void Rpc_entrypoint::activate() * called, we grab the '_delay_start' lock on construction and release it * here. */ - _delay_start.unlock(); + _delay_start.wakeup(); } @@ -222,7 +223,6 @@ Rpc_entrypoint::Rpc_entrypoint(Pd_session *pd_session, size_t stack_size, Affinity::Location location) : Thread(Cpu_session::Weight::DEFAULT_WEIGHT, name, stack_size, location), - _delay_start(Lock::LOCKED), _pd_session(*pd_session) { /* set magic value evaluated by thread_nova.cc to start a local thread */ diff --git a/repos/base/include/base/alarm.h b/repos/base/include/base/alarm.h index 1159d19cd..f3707f576 100644 --- a/repos/base/include/base/alarm.h +++ b/repos/base/include/base/alarm.h @@ -14,7 +14,7 @@ #ifndef _INCLUDE__BASE__ALARM_H_ #define _INCLUDE__BASE__ALARM_H_ -#include +#include namespace Genode { class Alarm_scheduler; @@ -41,11 +41,11 @@ class Genode::Alarm bool is_pending_at(uint64_t time, bool time_period) const; }; - Lock _dispatch_lock { }; /* taken during handle method */ - Raw _raw { }; - int _active { 0 }; /* set to one when active */ - Alarm *_next { nullptr }; /* next alarm in alarm list */ - Alarm_scheduler *_scheduler { nullptr }; /* currently assigned scheduler */ + Mutex _dispatch_mutex { }; /* taken during handle method */ + Raw _raw { }; + int _active { 0 }; /* set to one when active */ + Alarm *_next { nullptr }; /* next alarm in alarm list */ + Alarm_scheduler *_scheduler { nullptr }; /* currently assigned scheduler */ void _assign(Time period, Time deadline, @@ -90,7 +90,7 @@ class Genode::Alarm_scheduler { private: - Lock _lock { }; /* protect alarm list */ + Mutex _mutex { }; /* protect alarm list */ Alarm *_head { nullptr }; /* head of alarm list */ Alarm::Time _now { 0UL }; /* recent time (updated by handle method) */ bool _now_period { false }; diff --git a/repos/base/include/base/child.h b/repos/base/include/base/child.h index 9f6ea76f3..8c7b33a9d 100644 --- a/repos/base/include/base/child.h +++ b/repos/base/include/base/child.h @@ -17,7 +17,7 @@ #include #include #include -#include +#include #include #include #include @@ -296,8 +296,8 @@ class Genode::Child : protected Rpc_object, Signal_context_capability _heartbeat_sigh { }; /* arguments fetched by the child in response to a yield signal */ - Lock _yield_request_lock { }; - Resource_args _yield_request_args { }; + Mutex _yield_request_mutex { }; + Resource_args _yield_request_args { }; /* number of unanswered heartbeat signals */ unsigned _outstanding_heartbeats = 0; diff --git a/repos/base/include/base/entrypoint.h b/repos/base/include/base/entrypoint.h index fdd9955b8..579016e21 100644 --- a/repos/base/include/base/entrypoint.h +++ b/repos/base/include/base/entrypoint.h @@ -92,7 +92,7 @@ class Genode::Entrypoint : Noncopyable Reconstructible _sig_rec { }; - Lock _deferred_signals_mutex { }; + Mutex _deferred_signals_mutex { }; List > _deferred_signals { }; void _handle_deferred_signals() { } diff --git a/repos/base/include/base/id_space.h b/repos/base/include/base/id_space.h index 411f2f595..95b69c0ab 100644 --- a/repos/base/include/base/id_space.h +++ b/repos/base/include/base/id_space.h @@ -16,7 +16,7 @@ #include #include -#include +#include #include #include @@ -85,7 +85,7 @@ class Genode::Id_space : public Noncopyable : _obj(obj), _id_space(id_space) { - Lock::Guard guard(_id_space._lock); + Mutex::Guard guard(_id_space._mutex); _id = id_space._unused_id(); _id_space._elements.insert(this); } @@ -99,14 +99,14 @@ class Genode::Id_space : public Noncopyable : _obj(obj), _id_space(id_space), _id(id) { - Lock::Guard guard(_id_space._lock); + Mutex::Guard guard(_id_space._mutex); _id_space._check_conflict(id); _id_space._elements.insert(this); } ~Element() { - Lock::Guard guard(_id_space._lock); + Mutex::Guard guard(_id_space._mutex); _id_space._elements.remove(this); } @@ -122,7 +122,7 @@ class Genode::Id_space : public Noncopyable private: - Lock mutable _lock { }; /* protect '_elements' and '_cnt' */ + Mutex mutable _mutex { }; /* protect '_elements' and '_cnt' */ Avl_tree _elements { }; unsigned long _cnt = 0; @@ -175,7 +175,7 @@ class Genode::Id_space : public Noncopyable template void for_each(FUNC const &fn) const { - Lock::Guard guard(_lock); + Mutex::Guard guard(_mutex); if (_elements.first()) _elements.first()->template _for_each(fn); @@ -194,7 +194,7 @@ class Genode::Id_space : public Noncopyable { T *obj = nullptr; { - Lock::Guard guard(_lock); + Mutex::Guard guard(_mutex); if (!_elements.first()) throw Unknown_id(); @@ -226,7 +226,7 @@ class Genode::Id_space : public Noncopyable { T *obj = nullptr; { - Lock::Guard guard(_lock); + Mutex::Guard guard(_mutex); if (_elements.first()) obj = &_elements.first()->_obj; diff --git a/repos/base/include/base/log.h b/repos/base/include/base/log.h index 5519a2d37..320edc819 100644 --- a/repos/base/include/base/log.h +++ b/repos/base/include/base/log.h @@ -15,7 +15,7 @@ #define _INCLUDE__BASE__LOG_H_ #include -#include +#include #include namespace Genode { @@ -46,7 +46,7 @@ class Genode::Log private: - Lock _lock { }; + Mutex _mutex { }; Output &_output; @@ -62,9 +62,9 @@ class Genode::Log { /* * This function is being inlined. Hence, we try to keep it as - * small as possible. For this reason, the lock operations are + * small as possible. For this reason, the mutex operations are * performed by the '_acquire' and '_release' functions instead of - * using a lock guard. + * using a mutex guard. */ _acquire(type); Output::out_args(_output, args...); @@ -107,7 +107,7 @@ class Genode::Trace_output { private: - Lock _lock { }; + Mutex _mutex { }; Output &_output; diff --git a/repos/base/include/base/object_pool.h b/repos/base/include/base/object_pool.h index 4e74e8186..1a2eb3679 100644 --- a/repos/base/include/base/object_pool.h +++ b/repos/base/include/base/object_pool.h @@ -19,6 +19,7 @@ #include #include #include +#include #include namespace Genode { template class Object_pool; } @@ -95,13 +96,13 @@ class Genode::Object_pool : Interface, Noncopyable private: Avl_tree _tree { }; - Lock _lock { }; + Mutex _mutex { }; protected: bool empty() { - Lock::Guard lock_guard(_lock); + Mutex::Guard lock_guard(_mutex); return _tree.first() == nullptr; } @@ -109,13 +110,13 @@ class Genode::Object_pool : Interface, Noncopyable void insert(OBJ_TYPE *obj) { - Lock::Guard lock_guard(_lock); + Mutex::Guard lock_guard(_mutex); _tree.insert(obj); } void remove(OBJ_TYPE *obj) { - Lock::Guard lock_guard(_lock); + Mutex::Guard lock_guard(_mutex); _tree.remove(obj); } @@ -131,7 +132,7 @@ class Genode::Object_pool : Interface, Noncopyable Weak_ptr ptr; { - Lock::Guard lock_guard(_lock); + Mutex::Guard lock_guard(_mutex); Entry * entry = _tree.first() ? _tree.first()->find_by_obj_id(capid) : nullptr; @@ -164,7 +165,7 @@ class Genode::Object_pool : Interface, Noncopyable OBJ_TYPE * obj; { - Lock::Guard lock_guard(_lock); + Mutex::Guard lock_guard(_mutex); if (!((obj = (OBJ_TYPE*) _tree.first()))) return; diff --git a/repos/base/include/base/rpc_server.h b/repos/base/include/base/rpc_server.h index d898aa2f1..1b5a170e7 100644 --- a/repos/base/include/base/rpc_server.h +++ b/repos/base/include/base/rpc_server.h @@ -20,7 +20,7 @@ #include #include #include -#include +#include #include #include #include @@ -345,9 +345,9 @@ class Genode::Rpc_entrypoint : Thread, public Object_pool protected: Native_capability _caller { }; - Lock _cap_valid { }; /* thread startup synchronization */ - Lock _delay_start { }; /* delay start of request dispatching */ - Lock _delay_exit { }; /* delay destructor until server settled */ + Blockade _cap_valid { }; /* thread startup synchronization */ + Blockade _delay_start { }; /* delay start of request dispatching */ + Blockade _delay_exit { }; /* delay destructor until server settled */ Pd_session &_pd_session; /* for creating capabilities */ Exit_handler _exit_handler { }; Capability _exit_cap { }; diff --git a/repos/base/include/base/semaphore.h b/repos/base/include/base/semaphore.h index 1303192ad..84785be11 100644 --- a/repos/base/include/base/semaphore.h +++ b/repos/base/include/base/semaphore.h @@ -15,7 +15,8 @@ #ifndef _INCLUDE__BASE__SEMAPHORE_H_ #define _INCLUDE__BASE__SEMAPHORE_H_ -#include +#include +#include #include namespace Genode { class Semaphore; } @@ -25,16 +26,10 @@ class Genode::Semaphore { protected: - int _cnt; - Lock _meta_lock { }; + int _cnt; + Mutex _meta_lock { }; - struct Element : Fifo::Element - { - Lock lock { Lock::LOCKED }; - - void block() { lock.lock(); } - void wake_up() { lock.unlock(); } - }; + struct Element : Fifo::Element { Blockade blockade { }; }; Fifo _queue { }; @@ -50,7 +45,7 @@ class Genode::Semaphore ~Semaphore() { /* synchronize destruction with unfinished 'up()' */ - try { _meta_lock.lock(); } catch (...) { } + try { _meta_lock.acquire(); } catch (...) { } } /** @@ -64,7 +59,7 @@ class Genode::Semaphore Element * element = nullptr; { - Lock::Guard lock_guard(_meta_lock); + Mutex::Guard guard(_meta_lock); if (++_cnt > 0) return; @@ -78,7 +73,7 @@ class Genode::Semaphore } /* do not hold the lock while unblocking a waiting thread */ - if (element) element->wake_up(); + if (element) element->blockade.wakeup(); } /** @@ -86,7 +81,7 @@ class Genode::Semaphore */ void down() { - _meta_lock.lock(); + _meta_lock.acquire(); if (--_cnt < 0) { @@ -96,17 +91,17 @@ class Genode::Semaphore */ Element queue_element; _queue.enqueue(queue_element); - _meta_lock.unlock(); + _meta_lock.release(); /* * The thread is going to block on a local lock now, * waiting for getting waked from another thread * calling 'up()' * */ - queue_element.block(); + queue_element.blockade.block(); } else { - _meta_lock.unlock(); + _meta_lock.release(); } } diff --git a/repos/base/include/base/signal.h b/repos/base/include/base/signal.h index f3c657f57..097851ea6 100644 --- a/repos/base/include/base/signal.h +++ b/repos/base/include/base/signal.h @@ -208,11 +208,11 @@ class Genode::Signal_context : Interface, Noncopyable */ Signal_receiver *_receiver { nullptr }; - Lock _lock { }; /* protect '_curr_signal' */ + Mutex _mutex { }; /* protect '_curr_signal' */ Signal::Data _curr_signal { }; /* most-currently received signal */ bool _pending { false }; /* current signal is valid */ unsigned int _ref_cnt { 0 }; /* number of references to context */ - Lock _destroy_lock { }; /* prevent destruction while the + Mutex _destroy_mutex { }; /* prevent destruction while the context is in use */ /** @@ -298,7 +298,7 @@ class Genode::Signal_receiver : Noncopyable if (!context) return; do { - Lock::Guard lock_guard(context->_lock); + Mutex::Guard mutex_guard(context->_mutex); try { functor(*context); } catch (Break_for_each) { return; } @@ -322,14 +322,14 @@ class Genode::Signal_receiver : Noncopyable /** * List of associated contexts */ - Lock _contexts_lock { }; - Context_ring _contexts { }; + Mutex _contexts_mutex { }; + Context_ring _contexts { }; /** * Helper to dissolve given context * * This method prevents duplicated code in '~Signal_receiver' - * and 'dissolve'. Note that '_contexts_lock' must be held when + * and 'dissolve'. Note that '_contexts_mutex' must be held when * calling this method. */ void _unsynchronized_dissolve(Signal_context *context); diff --git a/repos/base/include/base/synced_allocator.h b/repos/base/include/base/synced_allocator.h index bf168ed7d..e1c9c8f87 100644 --- a/repos/base/include/base/synced_allocator.h +++ b/repos/base/include/base/synced_allocator.h @@ -1,12 +1,12 @@ /* - * \brief Lock-guarded allocator interface + * \brief Mutex-guarded allocator interface * \author Norman Feske * \author Stefan Kalkowski * \date 2008-08-05 */ /* - * Copyright (C) 2008-2017 Genode Labs GmbH + * Copyright (C) 2008-2020 Genode Labs GmbH * * This file is part of the Genode OS framework, which is distributed * under the terms of the GNU Affero General Public License version 3. @@ -24,7 +24,7 @@ namespace Genode { /** - * Lock-guarded allocator + * Mutex-guarded allocator * * This class wraps the complete 'Allocator' interface while * preventing concurrent calls to the wrapped allocator implementation. @@ -36,17 +36,17 @@ class Genode::Synced_allocator : public Allocator { private: - Lock _lock { }; - ALLOC _alloc; - Synced_interface _synced_object; + Mutex _mutex { }; + ALLOC _alloc; + Synced_interface _synced_object; public: - using Guard = typename Synced_interface::Guard; + using Guard = typename Synced_interface::Guard; template Synced_allocator(ARGS &&... args) - : _alloc(args...), _synced_object(_lock, &_alloc) { } + : _alloc(args...), _synced_object(_mutex, &_alloc) { } Guard operator () () { return _synced_object(); } Guard operator () () const { return _synced_object(); } diff --git a/repos/base/include/base/synced_interface.h b/repos/base/include/base/synced_interface.h index ed1348e01..ddeb6522c 100644 --- a/repos/base/include/base/synced_interface.h +++ b/repos/base/include/base/synced_interface.h @@ -15,11 +15,11 @@ #define _INCLUDE__BASE__SYNCED_INTERFACE_H_ /* Genode includes */ -#include +#include namespace Genode { - template class Synced_interface; + template class Synced_interface; } @@ -48,7 +48,7 @@ class Genode::Synced_interface Guard(LOCK &lock, IF *interface) : _lock(lock), _interface(interface) { - _lock.lock(); + _lock.acquire(); } friend class Synced_interface; @@ -57,7 +57,7 @@ class Genode::Synced_interface public: - ~Guard() { _lock.unlock(); } + ~Guard() { _lock.release(); } Guard(Guard const &other) : _lock(other._lock), _interface(other._interface) { } diff --git a/repos/base/include/base/weak_ptr.h b/repos/base/include/base/weak_ptr.h index a837793c0..297a1674f 100644 --- a/repos/base/include/base/weak_ptr.h +++ b/repos/base/include/base/weak_ptr.h @@ -14,7 +14,8 @@ #ifndef _INCLUDE__BASE__WEAK_PTR_H_ #define _INCLUDE__BASE__WEAK_PTR_H_ -#include +#include +#include #include #include @@ -42,15 +43,15 @@ class Genode::Weak_ptr_base : public Genode::List::Element friend class Weak_object_base; friend class Locked_ptr_base; - Lock mutable _lock { }; + Mutex mutable _mutex { }; Weak_object_base *_obj { nullptr }; /* - * This lock is used to synchronize destruction of a weak pointer - * and its corresponding weak object that happen simultanously + * This blocakde is used to synchronize destruction of a weak pointer + * and its corresponding weak object that happen simultaneously */ - Lock mutable _destruct_lock { Lock::LOCKED }; + Blockade mutable _destruct { }; inline void _adopt(Weak_object_base *obj); inline void _disassociate(); @@ -109,8 +110,8 @@ class Genode::Weak_object_base /** * List of weak pointers currently pointing to the object */ - Lock _list_lock { }; - List _list { }; + Mutex _list_mutex { }; + List _list { }; /** * Buffers dequeued weak pointer that get invalidated currently @@ -118,9 +119,9 @@ class Genode::Weak_object_base Weak_ptr_base *_ptr_in_destruction = nullptr; /** - * Lock to synchronize access to object + * Mutex to synchronize access to object */ - Lock _lock { }; + Mutex _mutex { }; protected: @@ -152,12 +153,12 @@ class Genode::Weak_object_base if (!ptr) return; { - Lock::Guard guard(_list_lock); + Mutex::Guard guard(_list_mutex); /* * If the weak pointer that tries to disassociate is currently * removed to invalidate it by the weak object's destructor, - * signal that fact to the pointer, so it can free it's lock, + * signal that fact to the pointer, so it can free it's mutex, * and block until invalidation is finished. */ if (_ptr_in_destruction == ptr) @@ -182,11 +183,11 @@ class Genode::Weak_object_base /* * To prevent dead-locks we always have to hold - * the order of lock access, therefore we first - * dequeue one weak pointer and free the list lock again + * the order of mutex access, therefore we first + * dequeue one weak pointer and free the list mutex again */ { - Lock::Guard guard(_list_lock); + Mutex::Guard guard(_list_mutex); _ptr_in_destruction = _list.first(); /* if the list is empty we're done */ @@ -195,22 +196,22 @@ class Genode::Weak_object_base } { - Lock::Guard guard(_ptr_in_destruction->_lock); + Mutex::Guard guard(_ptr_in_destruction->_mutex); _ptr_in_destruction->_obj = nullptr; /* * unblock a weak pointer that tried to disassociate * in the meantime */ - _ptr_in_destruction->_destruct_lock.unlock(); + _ptr_in_destruction->_destruct.wakeup(); } } /* - * synchronize with locked pointers that already aquired - * the lock before the corresponding weak pointer got invalidated + * synchronize with locked pointers that already acquired + * the mutex before the corresponding weak pointer got invalidated */ - _lock.lock(); + _mutex.acquire(); } /** @@ -364,7 +365,7 @@ void Genode::Weak_ptr_base::_adopt(Genode::Weak_object_base *obj) if (_obj) { - Lock::Guard guard(_obj->_list_lock); + Mutex::Guard guard(_obj->_list_mutex); _obj->_list.insert(this); } } @@ -374,11 +375,11 @@ void Genode::Weak_ptr_base::_disassociate() { /* defer destruction of object */ try { - Lock::Guard guard(_lock); + Mutex::Guard guard(_mutex); if (_obj) _obj->disassociate(this); } catch(Weak_object_base::In_destruction&) { - _destruct_lock.lock(); + _destruct.block(); } } @@ -398,7 +399,7 @@ Genode::Weak_ptr_base::operator = (Weak_ptr_base const &other) _disassociate(); { - Lock::Guard guard(other._lock); + Mutex::Guard guard(other._mutex); _adopt(other._obj); } return *this; @@ -410,7 +411,7 @@ bool Genode::Weak_ptr_base::operator == (Weak_ptr_base const &other) const if (&other == this) return true; - Lock::Guard guard_this(_lock), guard_other(other._lock); + Mutex::Guard guard_this(_mutex), guard_other(other._mutex); return (_obj == other._obj); } @@ -433,19 +434,19 @@ Genode::Weak_ptr Genode::Weak_object_base::_weak_ptr() Genode::Locked_ptr_base::Locked_ptr_base(Weak_ptr_base &weak_ptr) : curr(nullptr) { - Lock::Guard guard(weak_ptr._lock); + Mutex::Guard guard(weak_ptr._mutex); if (!weak_ptr.obj()) return; curr = weak_ptr.obj(); - curr->_lock.lock(); + curr->_mutex.acquire(); } Genode::Locked_ptr_base::~Locked_ptr_base() { if (curr) - curr->_lock.unlock(); + curr->_mutex.release(); } #endif /* _INCLUDE__BASE__WEAK_PTR_H_ */ diff --git a/repos/base/include/timer/timeout.h b/repos/base/include/timer/timeout.h index 7a5c043fc..832543b84 100644 --- a/repos/base/include/timer/timeout.h +++ b/repos/base/include/timer/timeout.h @@ -21,9 +21,9 @@ /* Genode includes */ #include -#include -#include #include +#include +#include namespace Genode { @@ -169,11 +169,11 @@ class Genode::Timeout : private Noncopyable bool is_pending_at(uint64_t time, bool time_period) const; }; - Lock _dispatch_lock { }; - Raw _raw { }; - int _active { 0 }; - Alarm *_next { nullptr }; - Alarm_timeout_scheduler *_scheduler { nullptr }; + Mutex _dispatch_mutex { }; + Raw _raw { }; + int _active { 0 }; + Alarm *_next { nullptr }; + Alarm_timeout_scheduler *_scheduler { nullptr }; void _alarm_assign(Time period, Time deadline, @@ -239,7 +239,7 @@ class Genode::Alarm_timeout_scheduler : private Noncopyable, using Alarm = Timeout::Alarm; Time_source &_time_source; - Lock _lock { }; + Mutex _mutex { }; Alarm *_active_head { nullptr }; Alarm *_pending_head { nullptr }; Alarm::Time _now { 0UL }; diff --git a/repos/base/include/timer_session/connection.h b/repos/base/include/timer_session/connection.h index 5f310fb15..00c66ef65 100644 --- a/repos/base/include/timer_session/connection.h +++ b/repos/base/include/timer_session/connection.h @@ -146,7 +146,7 @@ class Timer::Connection : public Genode::Connection, using Timeout_handler = Genode::Time_source::Timeout_handler; using Timestamp = Genode::Trace::Timestamp; using Duration = Genode::Duration; - using Lock = Genode::Lock; + using Mutex = Genode::Mutex; using Microseconds = Genode::Microseconds; using Milliseconds = Genode::Milliseconds; using Entrypoint = Genode::Entrypoint; @@ -172,7 +172,7 @@ class Timer::Connection : public Genode::Connection, enum Mode { LEGACY, MODERN }; Mode _mode { LEGACY }; - Genode::Lock _lock { }; + Mutex _mutex { }; Genode::Signal_receiver _sig_rec { }; Genode::Signal_context _default_sigh_ctx { }; @@ -204,7 +204,7 @@ class Timer::Connection : public Genode::Connection, Genode::Io_signal_handler _signal_handler; Timeout_handler *_handler { nullptr }; - Lock _real_time_lock { Lock::UNLOCKED }; + Mutex _real_time_mutex { }; uint64_t _us { elapsed_us() }; Timestamp _ts { _timestamp() }; Duration _real_time { Microseconds(_us) }; @@ -313,7 +313,7 @@ class Timer::Connection : public Genode::Connection, return; /* serialize sleep calls issued by different threads */ - Genode::Lock::Guard guard(_lock); + Mutex::Guard guard(_mutex); /* temporarily install to the default signal handler */ if (_custom_sigh_cap.valid()) diff --git a/repos/base/recipes/pkg/test-synced_interface/runtime b/repos/base/recipes/pkg/test-synced_interface/runtime index 569970d25..de75881d1 100644 --- a/repos/base/recipes/pkg/test-synced_interface/runtime +++ b/repos/base/recipes/pkg/test-synced_interface/runtime @@ -4,9 +4,9 @@ [init -> test-synced_interface] --- Synced interface test --- - [init -> test-synced_interface] lock + [init -> test-synced_interface] acquire [init -> test-synced_interface] adding 13 + 14 - [init -> test-synced_interface] unlock + [init -> test-synced_interface] release [init -> test-synced_interface] result is 27 [init -> test-synced_interface] --- Synced interface test finished --- diff --git a/repos/base/src/core/include/core_mem_alloc.h b/repos/base/src/core/include/core_mem_alloc.h index c873dda8d..a2da39c91 100644 --- a/repos/base/src/core/include/core_mem_alloc.h +++ b/repos/base/src/core/include/core_mem_alloc.h @@ -15,8 +15,8 @@ #ifndef _CORE__INCLUDE__CORE_MEM_ALLOC_H_ #define _CORE__INCLUDE__CORE_MEM_ALLOC_H_ -#include #include +#include #include #include @@ -201,10 +201,10 @@ class Genode::Core_mem_allocator : public Genode::Core_mem_translator protected: /** - * Lock used for synchronization of all operations on the + * Mutex used for synchronization of all operations on the * embedded allocators. */ - Lock _lock { }; + Mutex _mutex { }; /** * Synchronized allocator of physical memory ranges @@ -227,7 +227,7 @@ class Genode::Core_mem_allocator : public Genode::Core_mem_translator * * This allocator is internally used within this class for * allocating meta data for the other allocators. It is not - * synchronized to avoid nested locking. The lock-guarded + * synchronized to avoid nested locking. The Mutex-guarded * access to this allocator from the outer world is * provided via the 'Allocator' interface implemented by * 'Core_mem_allocator'. The allocator works at byte @@ -241,8 +241,8 @@ class Genode::Core_mem_allocator : public Genode::Core_mem_translator * Constructor */ Core_mem_allocator() - : _phys_alloc(_lock, &_mem_alloc), - _virt_alloc(_lock, &_mem_alloc), + : _phys_alloc(_mutex, &_mem_alloc), + _virt_alloc(_mutex, &_mem_alloc), _mem_alloc(_phys_alloc, _virt_alloc) { } /** @@ -283,13 +283,13 @@ class Genode::Core_mem_allocator : public Genode::Core_mem_translator Alloc_return alloc_aligned(size_t size, void **out_addr, int align, addr_t from = 0, addr_t to = ~0UL) override { - Lock::Guard lock_guard(_lock); + Mutex::Guard lock_guard(_mutex); return _mem_alloc.alloc_aligned(size, out_addr, align, from, to); } void free(void *addr) override { - Lock::Guard lock_guard(_lock); + Mutex::Guard lock_guard(_mutex); return _mem_alloc.free(addr); } @@ -307,7 +307,7 @@ class Genode::Core_mem_allocator : public Genode::Core_mem_translator void free(void *addr, size_t size) override { - Lock::Guard lock_guard(_lock); + Mutex::Guard lock_guard(_mutex); return _mem_alloc.free(addr, size); } diff --git a/repos/base/src/core/include/synced_range_allocator.h b/repos/base/src/core/include/synced_range_allocator.h index 31fe647e1..5a3130223 100644 --- a/repos/base/src/core/include/synced_range_allocator.h +++ b/repos/base/src/core/include/synced_range_allocator.h @@ -1,5 +1,5 @@ /* - * \brief Lock-guarded allocator interface + * \brief Mutex-guarded allocator interface * \author Norman Feske * \author Stefan Kalkowski * \date 2008-08-05 @@ -25,7 +25,7 @@ namespace Genode { /** - * Lock-guarded range allocator + * Mutex-guarded range allocator * * This class wraps the complete 'Range_allocator' interface while * preventing concurrent calls to the wrapped allocator implementation. @@ -39,23 +39,23 @@ class Genode::Synced_range_allocator : public Range_allocator friend class Mapped_mem_allocator; - Lock _default_lock { }; - Lock &_lock; - ALLOC _alloc; - Synced_interface _synced_object; + Mutex _default_mutex { }; + Mutex &_mutex; + ALLOC _alloc; + Synced_interface _synced_object; public: - using Guard = typename Synced_interface::Guard; + using Guard = typename Synced_interface::Guard; template - Synced_range_allocator(Lock &lock, ARGS &&... args) - : _lock(lock), _alloc(args...), _synced_object(_lock, &_alloc) { } + Synced_range_allocator(Mutex &mutex, ARGS &&... args) + : _mutex(mutex), _alloc(args...), _synced_object(_mutex, &_alloc) { } template Synced_range_allocator(ARGS &&... args) - : _lock(_default_lock), _alloc(args...), - _synced_object(_lock, &_alloc) { } + : _mutex(_default_mutex), _alloc(args...), + _synced_object(_mutex, &_alloc) { } Guard operator () () { return _synced_object(); } Guard operator () () const { return _synced_object(); } diff --git a/repos/base/src/include/base/internal/capability_space_tpl.h b/repos/base/src/include/base/internal/capability_space_tpl.h index d593e67f8..7b2f9d083 100644 --- a/repos/base/src/include/base/internal/capability_space_tpl.h +++ b/repos/base/src/include/base/internal/capability_space_tpl.h @@ -23,8 +23,8 @@ /* base includes */ #include #include -#include #include +#include #include /* base-internal includes */ @@ -114,7 +114,7 @@ class Genode::Capability_space_tpl Tree_managed_data _caps_data[NUM_CAPS]; Bit_allocator _alloc { }; Avl_tree _tree { }; - Lock mutable _lock { }; + Mutex mutable _mutex { }; /** * Calculate index into _caps_data for capability data object @@ -127,7 +127,7 @@ class Genode::Capability_space_tpl Data *_lookup(Rpc_obj_key key) const { - Lock::Guard guard(_lock); + Mutex::Guard guard(_mutex); if (!_tree.first()) return nullptr; @@ -146,7 +146,7 @@ class Genode::Capability_space_tpl template Native_capability::Data &create_capability(ARGS... args) { - Lock::Guard guard(_lock); + Mutex::Guard guard(_mutex); addr_t const index = _alloc.alloc(); @@ -160,7 +160,7 @@ class Genode::Capability_space_tpl void dec_ref(Data &data) { - Lock::Guard guard(_lock); + Mutex::Guard guard(_mutex); if (data.dec_ref() == 0) { @@ -174,7 +174,7 @@ class Genode::Capability_space_tpl void inc_ref(Data &data) { - Lock::Guard guard(_lock); + Mutex::Guard guard(_mutex); if (data.inc_ref() == 255) throw Native_capability::Reference_count_overflow(); diff --git a/repos/base/src/include/base/internal/expanding_parent_client.h b/repos/base/src/include/base/internal/expanding_parent_client.h index c805096ea..f961d38ab 100644 --- a/repos/base/src/include/base/internal/expanding_parent_client.h +++ b/repos/base/src/include/base/internal/expanding_parent_client.h @@ -46,9 +46,9 @@ class Genode::Expanding_parent_client : public Parent_client State _state = { UNDEFINED }; /** - * Lock used to serialize resource requests + * Mutex used to serialize resource requests */ - Lock _lock { }; + Mutex _mutex { }; struct Io_signal_context : Signal_context { @@ -156,7 +156,7 @@ class Genode::Expanding_parent_client : public Parent_client void resource_avail_sigh(Signal_context_capability sigh) override { - Lock::Guard guard(_lock); + Mutex::Guard guard(_mutex); /* * If signal hander gets de-installed, let the next call of @@ -177,7 +177,7 @@ class Genode::Expanding_parent_client : public Parent_client void resource_request(Resource_args const &args) override { - Lock::Guard guard(_lock); + Mutex::Guard guard(_mutex); /* * Issue request but don't block if a custom signal handler is diff --git a/repos/base/src/include/base/internal/stack_allocator.h b/repos/base/src/include/base/internal/stack_allocator.h index 639d37e40..ebc9db75b 100644 --- a/repos/base/src/include/base/internal/stack_allocator.h +++ b/repos/base/src/include/base/internal/stack_allocator.h @@ -46,7 +46,7 @@ class Genode::Stack_allocator } } _alloc { }; - Lock _threads_lock { }; + Mutex _threads_mutex { }; public: diff --git a/repos/base/src/lib/alarm/alarm.cc b/repos/base/src/lib/alarm/alarm.cc index 3d49c5ceb..eb5b7d48f 100644 --- a/repos/base/src/lib/alarm/alarm.cc +++ b/repos/base/src/lib/alarm/alarm.cc @@ -94,7 +94,7 @@ bool Alarm::Raw::is_pending_at(uint64_t time, bool time_period) const Alarm *Alarm_scheduler::_get_pending_alarm() { - Lock::Guard lock_guard(_lock); + Mutex::Guard guard(_mutex); if (!_head || !_head->_raw.is_pending_at(_now, _now_period)) { return nullptr; } @@ -104,10 +104,10 @@ Alarm *Alarm_scheduler::_get_pending_alarm() _head = _head->_next; /* - * Acquire dispatch lock to defer destruction until the call of 'on_alarm' + * Acquire dispatch mutex to defer destruction until the call of 'on_alarm' * is finished */ - pending_alarm->_dispatch_lock.lock(); + pending_alarm->_dispatch_mutex.acquire(); /* reset alarm object */ pending_alarm->_next = nullptr; @@ -178,12 +178,12 @@ void Alarm_scheduler::handle(Alarm::Time curr_time) curr->_raw.deadline = deadline; /* synchronize enqueue operation */ - Lock::Guard lock_guard(_lock); + Mutex::Guard guard(_mutex); _unsynchronized_enqueue(curr); } /* release alarm, resume concurrent destructor operation */ - curr->_dispatch_lock.unlock(); + curr->_dispatch_mutex.release(); } } @@ -206,7 +206,7 @@ void Alarm_scheduler::_setup_alarm(Alarm &alarm, Alarm::Time period, Alarm::Time void Alarm_scheduler::schedule_absolute(Alarm *alarm, Alarm::Time timeout) { - Lock::Guard alarm_list_lock_guard(_lock); + Mutex::Guard alarm_list_guard(_mutex); _setup_alarm(*alarm, 0, timeout); } @@ -214,7 +214,7 @@ void Alarm_scheduler::schedule_absolute(Alarm *alarm, Alarm::Time timeout) void Alarm_scheduler::schedule(Alarm *alarm, Alarm::Time period) { - Lock::Guard alarm_list_lock_guard(_lock); + Mutex::Guard alarm_list_guard(_mutex); /* * Refuse to schedule a periodic timeout of 0 because it would trigger @@ -236,17 +236,17 @@ void Alarm_scheduler::discard(Alarm *alarm) { /* * Make sure that nobody is inside the '_get_pending_alarm' when - * grabbing the '_dispatch_lock'. This is important when this function - * is called from the 'Alarm' destructor. Without the '_dispatch_lock', - * we could take the lock and proceed with destruction just before - * '_get_pending_alarm' tries to grab the lock. When the destructor is + * grabbing the '_dispatch_mutex'. This is important when this function + * is called from the 'Alarm' destructor. Without the '_dispatch_mutex', + * we could take the mutex and proceed with destruction just before + * '_get_pending_alarm' tries to grab the mutex. When the destructor is * finished, '_get_pending_alarm' would proceed with operating on a * dangling pointer. */ - Lock::Guard alarm_list_lock_guard(_lock); + Mutex::Guard alarm_list_guard(_mutex); if (alarm) { - Lock::Guard alarm_lock_guard(alarm->_dispatch_lock); + Mutex::Guard alarm_guard(alarm->_dispatch_mutex); _unsynchronized_dequeue(alarm); } } @@ -254,7 +254,7 @@ void Alarm_scheduler::discard(Alarm *alarm) bool Alarm_scheduler::next_deadline(Alarm::Time *deadline) { - Lock::Guard alarm_list_lock_guard(_lock); + Mutex::Guard alarm_list_guard(_mutex); if (!_head) return false; @@ -270,7 +270,7 @@ bool Alarm_scheduler::next_deadline(Alarm::Time *deadline) Alarm_scheduler::~Alarm_scheduler() { - Lock::Guard lock_guard(_lock); + Mutex::Guard guard(_mutex); while (_head) { diff --git a/repos/base/src/lib/base/child.cc b/repos/base/src/lib/base/child.cc index 181e61626..3cd5ea3e7 100644 --- a/repos/base/src/lib/base/child.cc +++ b/repos/base/src/lib/base/child.cc @@ -35,7 +35,7 @@ static Service &parent_service() void Child::yield(Resource_args const &args) { - Lock::Guard guard(_yield_request_lock); + Mutex::Guard guard(_yield_request_mutex); /* buffer yield request arguments to be picked up by the child */ _yield_request_args = args; @@ -685,7 +685,7 @@ void Child::yield_sigh(Signal_context_capability sigh) { _yield_sigh = sigh; } Parent::Resource_args Child::yield_request() { - Lock::Guard guard(_yield_request_lock); + Mutex::Guard guard(_yield_request_mutex); return _yield_request_args; } diff --git a/repos/base/src/lib/base/component.cc b/repos/base/src/lib/base/component.cc index aa0b0f5b2..6db7f9c52 100644 --- a/repos/base/src/lib/base/component.cc +++ b/repos/base/src/lib/base/component.cc @@ -48,9 +48,9 @@ namespace { Genode::Parent &_parent = *env_deprecated()->parent(); /** - * Lock for serializing 'session' and 'close' + * Mutex for serializing 'session' and 'close' */ - Genode::Lock _lock { }; + Genode::Mutex _mutex { }; /** * Utility to used block for single signal @@ -121,7 +121,7 @@ namespace { Parent::Session_args const &args, Affinity const &affinity) override { - Lock::Guard guard(_lock); + Mutex::Guard guard(_mutex); /* * Since we account for the backing store for session meta data on @@ -189,7 +189,7 @@ namespace { void upgrade(Parent::Client::Id id, Parent::Upgrade_args const &args) override { - Lock::Guard guard(_lock); + Mutex::Guard guard(_mutex); if (_parent.upgrade(id, args) == Parent::UPGRADE_PENDING) _block_for_session(); @@ -197,7 +197,7 @@ namespace { void close(Parent::Client::Id id) override { - Lock::Guard guard(_lock); + Mutex::Guard guard(_mutex); if (_parent.close(id) == Parent::CLOSE_PENDING) _block_for_session(); diff --git a/repos/base/src/lib/base/entrypoint.cc b/repos/base/src/lib/base/entrypoint.cc index 116b9e966..9c3b9ceb4 100644 --- a/repos/base/src/lib/base/entrypoint.cc +++ b/repos/base/src/lib/base/entrypoint.cc @@ -86,7 +86,7 @@ void Entrypoint::_defer_signal(Signal &sig) { Signal_context *context = sig.context(); - Lock::Guard guard(_deferred_signals_mutex); + Mutex::Guard guard(_deferred_signals_mutex); _deferred_signals.remove(context->deferred_le()); _deferred_signals.insert(context->deferred_le()); } @@ -97,7 +97,7 @@ void Entrypoint::_process_deferred_signals() for (;;) { Signal_context *context = nullptr; { - Lock::Guard guard(_deferred_signals_mutex); + Mutex::Guard guard(_deferred_signals_mutex); if (!_deferred_signals.first()) return; context = _deferred_signals.first()->object(); @@ -118,7 +118,6 @@ void Entrypoint::_process_incoming_signals() do { { /* see documentation in 'wait_and_dispatch_one_io_signal()' */ - Mutex::Guard guard { _block_for_signal_mutex }; _signal_proxy_delivers_signal = true; @@ -281,7 +280,7 @@ void Genode::Entrypoint::dissolve(Signal_dispatcher_base &dispatcher) /* also remove context from deferred signal list */ { - Lock::Guard guard(_deferred_signals_mutex); + Mutex::Guard guard(_deferred_signals_mutex); _deferred_signals.remove(dispatcher.deferred_le()); } } diff --git a/repos/base/src/lib/base/log.cc b/repos/base/src/lib/base/log.cc index 90c77f214..978414ddc 100644 --- a/repos/base/src/lib/base/log.cc +++ b/repos/base/src/lib/base/log.cc @@ -19,7 +19,7 @@ using namespace Genode; void Log::_acquire(Type type) { - _lock.lock(); + _mutex.acquire(); /* * Mark warnings and errors via distinct colors. @@ -39,7 +39,7 @@ void Log::_release() */ _output.out_string("\033[0m\n"); - _lock.unlock(); + _mutex.release(); } @@ -63,7 +63,7 @@ void Raw::_release() void Trace_output::_acquire() { - _lock.lock(); + _mutex.acquire(); } @@ -74,5 +74,5 @@ void Trace_output::_release() */ _output.out_string("\n"); - _lock.unlock(); + _mutex.release(); } diff --git a/repos/base/src/lib/base/root_proxy.cc b/repos/base/src/lib/base/root_proxy.cc index c7e2bafdd..d8485c615 100644 --- a/repos/base/src/lib/base/root_proxy.cc +++ b/repos/base/src/lib/base/root_proxy.cc @@ -51,15 +51,15 @@ namespace { enum { MAX = 32 }; - Lock mutable _lock { }; - Service _services[MAX] { }; - unsigned _cnt = 0; + Mutex mutable _mutex { }; + Service _services[MAX] { }; + unsigned _cnt = 0; public: void insert(Service const &service) { - Lock::Guard guard(_lock); + Mutex::Guard guard(_mutex); if (_cnt == MAX) { error("maximum number of services announced"); @@ -76,10 +76,10 @@ namespace { void apply(Service::Name const &name, FUNC const &fn) { /* - * Protect '_services' but execute 'fn' with the lock released. + * Protect '_services' but execute 'fn' with the mutex released. * - * If we called 'fn' with the lock held, the following scenario - * may result in a deadlock: + * If we called 'fn' with the mutex held, the following + * scenario may result in a deadlock: * * A component provides two services, e.g., "Framebuffer" and * "Input" (fb_sdl or nit_fb). In-between the two 'announce' @@ -91,19 +91,19 @@ namespace { * call blocks until 'Component::construct' returns. However, * before returning, the function announces the second service, * eventually arriving at 'Service_registry::insert', which - * tries to acquire the same lock as the blocking 'apply' call. + * tries to acquire the same mutex as the blocking 'apply' call. */ - _lock.lock(); + _mutex.acquire(); for (unsigned i = 0; i < _cnt; i++) { if (name != _services[i].name) continue; - _lock.unlock(); + _mutex.release(); fn(_services[i]); return; } - _lock.unlock(); + _mutex.release(); } }; diff --git a/repos/base/src/lib/base/rpc_dispatch_loop.cc b/repos/base/src/lib/base/rpc_dispatch_loop.cc index 8b32534da..3b282cb85 100644 --- a/repos/base/src/lib/base/rpc_dispatch_loop.cc +++ b/repos/base/src/lib/base/rpc_dispatch_loop.cc @@ -26,7 +26,7 @@ void Rpc_entrypoint::_entry(Native_context& native_context) Ipc_server srv(native_context); _cap = srv; - _cap_valid.unlock(); + _cap_valid.wakeup(); /* * Now, the capability of the server activation is initialized @@ -35,7 +35,7 @@ void Rpc_entrypoint::_entry(Native_context& native_context) * is completely initialized. Thus, we wait until the activation * gets explicitly unblocked by calling 'Rpc_entrypoint::activate()'. */ - _delay_start.lock(); + _delay_start.block(); Rpc_exception_code exc = Rpc_exception_code(Rpc_exception_code::INVALID_OBJECT); @@ -65,5 +65,5 @@ void Rpc_entrypoint::_entry(Native_context& native_context) ipc_reply(_caller, Rpc_exception_code(Rpc_exception_code::SUCCESS), snd_buf); /* defer the destruction of 'Ipc_server' until '~Rpc_entrypoint' is ready */ - _delay_exit.lock(); + _delay_exit.block(); } diff --git a/repos/base/src/lib/base/rpc_entrypoint.cc b/repos/base/src/lib/base/rpc_entrypoint.cc index fc0bc7f37..64164f338 100644 --- a/repos/base/src/lib/base/rpc_entrypoint.cc +++ b/repos/base/src/lib/base/rpc_entrypoint.cc @@ -44,7 +44,7 @@ void Rpc_entrypoint::_dissolve(Rpc_object_base *obj) void Rpc_entrypoint::_block_until_cap_valid() { - _cap_valid.lock(); + _cap_valid.block(); } @@ -59,7 +59,7 @@ void Rpc_entrypoint::reply_signal_info(Untyped_capability reply_cap, void Rpc_entrypoint::activate() { - _delay_start.unlock(); + _delay_start.wakeup(); } @@ -75,8 +75,6 @@ Rpc_entrypoint::Rpc_entrypoint(Pd_session *pd_session, size_t stack_size, : Thread(Cpu_session::Weight::DEFAULT_WEIGHT, name, _native_stack_size(stack_size), location), _cap(Untyped_capability()), - _cap_valid(Lock::LOCKED), _delay_start(Lock::LOCKED), - _delay_exit(Lock::LOCKED), _pd_session(*pd_session) { Thread::start(); @@ -93,9 +91,9 @@ Rpc_entrypoint::~Rpc_entrypoint() { /* * We have to make sure the server loop is running which is only the case - * if the Rpc_entrypoint was actived before we execute the RPC call. + * if the Rpc_entrypoint was activated before we execute the RPC call. */ - _delay_start.unlock(); + _delay_start.wakeup(); /* leave server loop */ _exit_cap.call(); @@ -111,7 +109,7 @@ Rpc_entrypoint::~Rpc_entrypoint() * entrypoint thread to leave the scope. Thereby, the 'Ipc_server' object * will get destructed. */ - _delay_exit.unlock(); + _delay_exit.wakeup(); join(); } diff --git a/repos/base/src/lib/base/signal.cc b/repos/base/src/lib/base/signal.cc index b058b93ae..e8e4733cd 100644 --- a/repos/base/src/lib/base/signal.cc +++ b/repos/base/src/lib/base/signal.cc @@ -28,7 +28,7 @@ using namespace Genode; -class Signal_handler_thread : Thread, Lock +class Signal_handler_thread : Thread, Blockade { private: @@ -44,7 +44,7 @@ class Signal_handler_thread : Thread, Lock void entry() override { _signal_source.construct(env_deprecated()->pd_session()->alloc_signal_source()); - unlock(); + wakeup(); Signal_receiver::dispatch_signals(&(*_signal_source)); } @@ -56,7 +56,7 @@ class Signal_handler_thread : Thread, Lock * Constructor */ Signal_handler_thread(Env &env) - : Thread(env, "signal handler", STACK_SIZE), Lock(Lock::LOCKED) + : Thread(env, "signal handler", STACK_SIZE) { start(); @@ -65,7 +65,7 @@ class Signal_handler_thread : Thread, Lock * with the use of signals. Otherwise, signals may get lost until * the construction finished. */ - lock(); + block(); } ~Signal_handler_thread() @@ -136,34 +136,34 @@ namespace Genode { * scalability problem, we might introduce a more sophisticated * associative data structure. */ - Lock mutable _lock { }; + Mutex mutable _mutex { }; List > _list { }; public: void insert(List_element *le) { - Lock::Guard guard(_lock); + Mutex::Guard guard(_mutex); _list.insert(le); } void remove(List_element *le) { - Lock::Guard guard(_lock); + Mutex::Guard guard(_mutex); _list.remove(le); } bool test_and_lock(Signal_context *context) const { - Lock::Guard guard(_lock); + Mutex::Guard guard(_mutex); /* search list for context */ List_element const *le = _list.first(); for ( ; le; le = le->next()) { if (context == le->object()) { - /* lock object */ - context->_lock.lock(); + /* acquire the object */ + context->_mutex.acquire(); return true; } } @@ -197,7 +197,7 @@ Signal_context_capability Signal_receiver::manage(Signal_context *context) context->_receiver = this; - Lock::Guard contexts_lock_guard(_contexts_lock); + Mutex::Guard contexts_guard(_contexts_mutex); /* insert context into context list */ _contexts.insert_as_tail(context); @@ -237,7 +237,7 @@ void Signal_receiver::block_for_signal() Signal Signal_receiver::pending_signal() { - Lock::Guard contexts_lock_guard(_contexts_lock); + Mutex::Guard contexts_guard(_contexts_mutex); Signal::Data result; _contexts.for_each_locked([&] (Signal_context &context) { @@ -252,7 +252,7 @@ Signal Signal_receiver::pending_signal() throw Context_ring::Break_for_each(); }); if (result.context) { - Lock::Guard lock_guard(result.context->_lock); + Mutex::Guard context_guard(result.context->_mutex); if (result.num == 0) warning("returning signal with num == 0"); @@ -324,8 +324,8 @@ void Signal_receiver::dispatch_signals(Signal_source *signal_source) warning("signal context ", context, " with no receiver in signal dispatcher"); } - /* free context lock that was taken by 'test_and_lock' */ - context->_lock.unlock(); + /* free context mutex that was taken by 'test_and_lock' */ + context->_mutex.release(); } } @@ -333,8 +333,8 @@ void Signal_receiver::dispatch_signals(Signal_source *signal_source) void Signal_receiver::_platform_begin_dissolve(Signal_context *context) { /* - * Because the 'remove' operation takes the registry lock, the context - * must not be locked when calling this method. See the comment in + * Because the 'remove' operation takes the registry mutex, the context + * must not be acquired when calling this method. See the comment in * 'Signal_receiver::dissolve'. */ signal_context_registry()->remove(&context->_registry_le); diff --git a/repos/base/src/lib/base/signal_common.cc b/repos/base/src/lib/base/signal_common.cc index a92dbe5cb..8d3c15b91 100644 --- a/repos/base/src/lib/base/signal_common.cc +++ b/repos/base/src/lib/base/signal_common.cc @@ -58,10 +58,10 @@ Signal::~Signal() { _dec_ref_and_unlock(); } void Signal::_dec_ref_and_unlock() { if (_data.context) { - Lock::Guard lock_guard(_data.context->_lock); + Mutex::Guard context_guard(_data.context->_mutex); _data.context->_ref_cnt--; if (_data.context->_ref_cnt == 0) - _data.context->_destroy_lock.unlock(); + _data.context->_destroy_mutex.release(); } } @@ -69,7 +69,7 @@ void Signal::_dec_ref_and_unlock() void Signal::_inc_ref() { if (_data.context) { - Lock::Guard lock_guard(_data.context->_lock); + Mutex::Guard context_guard(_data.context->_mutex); _data.context->_ref_cnt++; } } @@ -98,7 +98,7 @@ Signal::Signal(Signal::Data data) : _data(data) * is in its clear state). */ if (_data.context->_ref_cnt == 1) { - _data.context->_destroy_lock.lock(); + _data.context->_destroy_mutex.acquire(); } else { /* print warning only once to avoid flooding the log */ @@ -161,7 +161,7 @@ Signal Signal_receiver::wait_for_signal() Signal_receiver::~Signal_receiver() { - Lock::Guard contexts_lock_guard(_contexts_lock); + Mutex::Guard contexts_guard(_contexts_mutex); /* disassociate contexts from the receiver */ while (Signal_context *context = _contexts.head()) { @@ -197,24 +197,24 @@ void Signal_receiver::dissolve(Signal_context *context) /* * We must adhere to the following lock-taking order: * - * 1. Taking the lock for the list of contexts ('_contexts_lock') + * 1. Taking the lock for the list of contexts ('_contexts_mutex') * 2. Taking the context-registry lock (this happens inside * '_platform_begin_dissolve' on platforms that use such a * registry) * 3. Taking the lock for an individual signal context */ - Lock::Guard contexts_lock_guard(_contexts_lock); + Mutex::Guard contexts_guard(_contexts_mutex); _platform_begin_dissolve(context); - Lock::Guard context_lock_guard(context->_lock); + Mutex::Guard context_guard(context->_mutex); _unsynchronized_dissolve(context); } _platform_finish_dissolve(context); - Lock::Guard context_destroy_lock_guard(context->_destroy_lock); + Mutex::Guard context_destroy_guard(context->_destroy_mutex); } diff --git a/repos/base/src/lib/base/sleep.cc b/repos/base/src/lib/base/sleep.cc index be36e2886..f8d7439da 100644 --- a/repos/base/src/lib/base/sleep.cc +++ b/repos/base/src/lib/base/sleep.cc @@ -6,17 +6,17 @@ */ /* - * Copyright (C) 2006-2017 Genode Labs GmbH + * Copyright (C) 2006-2020 Genode Labs GmbH * * This file is part of the Genode OS framework, which is distributed * under the terms of the GNU Affero General Public License version 3. */ +#include #include -#include void Genode::sleep_forever() { - Lock sleep; - while (true) sleep.lock(); + Blockade sleep; + while (true) sleep.block(); } diff --git a/repos/base/src/lib/base/stack_allocator.cc b/repos/base/src/lib/base/stack_allocator.cc index 0a86772b8..b521c6868 100644 --- a/repos/base/src/lib/base/stack_allocator.cc +++ b/repos/base/src/lib/base/stack_allocator.cc @@ -52,7 +52,7 @@ Stack_allocator::alloc(Thread *, bool main_thread) return base_to_stack(stack_area_virtual_base()); try { - Lock::Guard _lock_guard(_threads_lock); + Mutex::Guard guard(_threads_mutex); return base_to_stack(idx_to_base(_alloc.alloc())); } catch(Bit_allocator::Out_of_indices) { return 0; @@ -64,7 +64,7 @@ void Stack_allocator::free(Stack *stack) { addr_t const base = addr_to_base(stack); - Lock::Guard _lock_guard(_threads_lock); + Mutex::Guard guard(_threads_mutex); _alloc.free(base_to_idx(base)); } diff --git a/repos/base/src/lib/cxx/emutls.cc b/repos/base/src/lib/cxx/emutls.cc index 6100e9b4b..7ee31a697 100644 --- a/repos/base/src/lib/cxx/emutls.cc +++ b/repos/base/src/lib/cxx/emutls.cc @@ -91,9 +91,9 @@ static List &_tls_tree_list() } -static Lock &_emutls_lock() +static Mutex &_emutls_mutex() { - static Lock instance; + static Mutex instance; return instance; } @@ -103,7 +103,7 @@ static Lock &_emutls_lock() */ void Genode::cxx_free_tls(void *thread) { - Lock::Guard lock_guard(_emutls_lock()); + Mutex::Guard lock_guard(_emutls_mutex()); for (Tls_tree *tls_tree = _tls_tree_list().first(); tls_tree; tls_tree = tls_tree->next()) { @@ -130,7 +130,7 @@ void Genode::cxx_free_tls(void *thread) */ extern "C" void *__emutls_get_address(void *obj) { - Lock::Guard lock_guard(_emutls_lock()); + Mutex::Guard lock_guard(_emutls_mutex()); __emutls_object *emutls_object = reinterpret_cast<__emutls_object*>(obj); diff --git a/repos/base/src/lib/ldso/exception.cc b/repos/base/src/lib/ldso/exception.cc index 3df3ef4b6..32f96e26c 100644 --- a/repos/base/src/lib/ldso/exception.cc +++ b/repos/base/src/lib/ldso/exception.cc @@ -38,7 +38,7 @@ extern "C" int dl_iterate_phdr(int (*callback) (Phdr_info *info, size_t size, vo int err = 0; Phdr_info info; - Lock::Guard guard(lock()); + Mutex::Guard guard(mutex()); for (Object *e = obj_list_head();e; e = e->next_obj()) { diff --git a/repos/base/src/lib/ldso/include/linker.h b/repos/base/src/lib/ldso/include/linker.h index b2eca88c3..7ec686aa7 100644 --- a/repos/base/src/lib/ldso/include/linker.h +++ b/repos/base/src/lib/ldso/include/linker.h @@ -20,6 +20,7 @@ #include #include #include +#include /* * Mark functions that are used during the linkers self-relocation phase as @@ -125,9 +126,9 @@ namespace Linker { Dependency *binary_root_dep(); /** - * Global ELF access lock + * Global ELF access mutex */ - Lock &lock(); + Mutex &mutex(); } diff --git a/repos/base/src/lib/ldso/main.cc b/repos/base/src/lib/ldso/main.cc index 7f364f14c..eb4da0e8c 100644 --- a/repos/base/src/lib/ldso/main.cc +++ b/repos/base/src/lib/ldso/main.cc @@ -66,10 +66,10 @@ Linker::Region_map::Constructible_region_map &Linker::Region_map::r() } -Genode::Lock &Linker::lock() +Genode::Mutex &Linker::mutex() { - static Lock _lock; - return _lock; + static Mutex _mutex; + return _mutex; } @@ -296,7 +296,7 @@ struct Linker::Ld : private Dependency, Elf_object Elf::Addr Ld::jmp_slot(Dependency const &dep, Elf::Size index) { - Lock::Guard guard(lock()); + Mutex::Guard guard(mutex()); if (verbose_relocation) log("LD: SLOT ", &dep.obj(), " ", Hex(index)); diff --git a/repos/base/src/lib/ldso/shared_object.cc b/repos/base/src/lib/ldso/shared_object.cc index 614e40dad..d82edb25e 100644 --- a/repos/base/src/lib/ldso/shared_object.cc +++ b/repos/base/src/lib/ldso/shared_object.cc @@ -29,9 +29,9 @@ static Linker::Root_object const &to_root(void *h) * Needed during shared object creation and destruction, since global lists are * manipulated */ -static Genode::Lock & shared_object_lock() +static Genode::Mutex & shared_object_lock() { - static Genode::Lock _lock; + static Genode::Mutex _lock; return _lock; } @@ -61,7 +61,7 @@ Genode::Shared_object::Shared_object(Env &env, Allocator &md_alloc, log("LD: open '", file ? file : "binary", "'"); try { - Lock::Guard guard(shared_object_lock()); + Mutex::Guard guard(shared_object_lock()); _handle = new (md_alloc) Root_object(env, md_alloc, file ? file : binary_name(), @@ -96,7 +96,7 @@ void *Genode::Shared_object::_lookup(const char *name) const log("LD: shared object lookup '", name, "'"); try { - Lock::Guard guard(Linker::lock()); + Mutex::Guard guard(Linker::mutex()); Root_object const &root = to_root(_handle); @@ -121,7 +121,7 @@ Genode::Shared_object::~Shared_object() if (verbose_shared) log("LD: close shared object"); - Lock::Guard guard(shared_object_lock()); + Mutex::Guard guard(shared_object_lock()); destroy(_md_alloc, &const_cast(to_root(_handle))); } diff --git a/repos/base/src/lib/startup/_main.cc b/repos/base/src/lib/startup/_main.cc index 331b52c0d..3c7258991 100644 --- a/repos/base/src/lib/startup/_main.cc +++ b/repos/base/src/lib/startup/_main.cc @@ -62,9 +62,9 @@ static struct atexit } _atexit; -static Genode::Lock &atexit_lock() +static Genode::Mutex &atexit_mutex() { - static Genode::Lock _atexit_lock; + static Genode::Mutex _atexit_lock; return _atexit_lock; } @@ -77,7 +77,7 @@ static void atexit_enable() static int atexit_register(struct atexit_fn *fn) { - Genode::Lock::Guard atexit_lock_guard(atexit_lock()); + Genode::Mutex::Guard atexit_lock_guard(atexit_mutex()); if (!_atexit.enabled) return 0; @@ -144,7 +144,7 @@ void genode___cxa_finalize(void *dso) struct atexit_fn fn; int n = 0; - atexit_lock().lock(); + atexit_mutex().acquire(); for (n = _atexit.index; --n >= 0;) { if (_atexit.fns[n].fn_type == ATEXIT_FN_EMPTY) continue; /* already been called */ @@ -157,7 +157,7 @@ void genode___cxa_finalize(void *dso) * has already been called. */ _atexit.fns[n].fn_type = ATEXIT_FN_EMPTY; - atexit_lock().unlock(); + atexit_mutex().release(); /* call the function of correct type */ if (fn.fn_type == ATEXIT_FN_CXA) @@ -165,9 +165,9 @@ void genode___cxa_finalize(void *dso) else if (fn.fn_type == ATEXIT_FN_STD) fn.fn_ptr.std_func(); - atexit_lock().lock(); + atexit_mutex().acquire(); } - atexit_lock().unlock(); + atexit_mutex().release(); } diff --git a/repos/base/src/lib/timeout/timeout.cc b/repos/base/src/lib/timeout/timeout.cc index 902731b1b..22e8e3136 100644 --- a/repos/base/src/lib/timeout/timeout.cc +++ b/repos/base/src/lib/timeout/timeout.cc @@ -120,7 +120,7 @@ Alarm_timeout_scheduler::Alarm_timeout_scheduler(Time_source &time_source, Alarm_timeout_scheduler::~Alarm_timeout_scheduler() { - Lock::Guard lock_guard(_lock); + Mutex::Guard mutex_guard(_mutex); while (_active_head) { Alarm *next = _active_head->_next; _active_head->_alarm_reset(); @@ -234,7 +234,7 @@ void Alarm_timeout_scheduler::_alarm_unsynchronized_dequeue(Alarm *alarm) Timeout::Alarm *Alarm_timeout_scheduler::_alarm_get_pending_alarm() { - Lock::Guard lock_guard(_lock); + Mutex::Guard mutex_guard(_mutex); if (!_active_head || !_active_head->_raw.is_pending_at(_now, _now_period)) { return nullptr; } @@ -244,10 +244,10 @@ Timeout::Alarm *Alarm_timeout_scheduler::_alarm_get_pending_alarm() _active_head = _active_head->_next; /* - * Acquire dispatch lock to defer destruction until the call of '_on_alarm' + * Acquire dispatch mutex to defer destruction until the call of '_on_alarm' * is finished */ - pending_alarm->_dispatch_lock.lock(); + pending_alarm->_dispatch_mutex.acquire(); /* reset alarm object */ pending_alarm->_next = nullptr; @@ -333,12 +333,12 @@ void Alarm_timeout_scheduler::_alarm_handle(Alarm::Time curr_time) curr->_raw.deadline = deadline; /* synchronize enqueue operation */ - Lock::Guard lock_guard(_lock); + Mutex::Guard mutex_guard(_mutex); _alarm_unsynchronized_enqueue(curr); } /* release alarm, resume concurrent destructor operation */ - curr->_dispatch_lock.unlock(); + curr->_dispatch_mutex.release(); } } @@ -362,7 +362,7 @@ void Alarm_timeout_scheduler::_alarm_setup_alarm(Alarm &alarm, Alarm::Time perio void Alarm_timeout_scheduler::_alarm_schedule_absolute(Alarm *alarm, Alarm::Time duration) { - Lock::Guard alarm_list_lock_guard(_lock); + Mutex::Guard alarm_list_guard(_mutex); _alarm_setup_alarm(*alarm, 0, duration); } @@ -370,7 +370,7 @@ void Alarm_timeout_scheduler::_alarm_schedule_absolute(Alarm *alarm, Alarm::Time void Alarm_timeout_scheduler::_alarm_schedule(Alarm *alarm, Alarm::Time period) { - Lock::Guard alarm_list_lock_guard(_lock); + Mutex::Guard alarm_list_guard(_mutex); /* * Refuse to schedule a periodic timeout of 0 because it would trigger @@ -392,17 +392,17 @@ void Alarm_timeout_scheduler::_alarm_discard(Alarm *alarm) { /* * Make sure that nobody is inside the '_alarm_get_pending_alarm' when - * grabbing the '_dispatch_lock'. This is important when this function - * is called from the 'Alarm' destructor. Without the '_dispatch_lock', - * we could take the lock and proceed with destruction just before - * '_alarm_get_pending_alarm' tries to grab the lock. When the destructor is - * finished, '_alarm_get_pending_alarm' would proceed with operating on a - * dangling pointer. + * grabbing the '_dispatch_mutex'. This is important when this function + * is called from the 'Alarm' destructor. Without the '_dispatch_mutex', + * we could take the mutex and proceed with destruction just before + * '_alarm_get_pending_alarm' tries to grab the mutex. When the destructor + * is finished, '_alarm_get_pending_alarm' would proceed with operating on + * a dangling pointer. */ - Lock::Guard alarm_list_lock_guard(_lock); + Mutex::Guard alarm_list_guard(_mutex); if (alarm) { - Lock::Guard alarm_lock_guard(alarm->_dispatch_lock); + Mutex::Guard alarm_guard(alarm->_dispatch_mutex); _alarm_unsynchronized_dequeue(alarm); } } @@ -410,7 +410,7 @@ void Alarm_timeout_scheduler::_alarm_discard(Alarm *alarm) bool Alarm_timeout_scheduler::_alarm_next_deadline(Alarm::Time *deadline) { - Lock::Guard alarm_list_lock_guard(_lock); + Mutex::Guard alarm_list_guard(_mutex); if (!_active_head) return false; diff --git a/repos/base/src/lib/timeout/timer_connection_time.cc b/repos/base/src/lib/timeout/timer_connection_time.cc index 39ff2327e..8c8f8408b 100644 --- a/repos/base/src/lib/timeout/timer_connection_time.cc +++ b/repos/base/src/lib/timeout/timer_connection_time.cc @@ -21,7 +21,7 @@ using namespace Genode::Trace; void Timer::Connection::_update_real_time() { - Lock_guard lock_guard(_real_time_lock); + Mutex::Guard guard(_real_time_mutex); /* @@ -145,8 +145,8 @@ Duration Timer::Connection::curr_time() { _enable_modern_mode(); - Reconstructible > lock_guard(_real_time_lock); - Duration interpolated_time(_real_time); + Reconstructible mutex_guard(_real_time_mutex); + Duration interpolated_time(_real_time); /* * Interpolate with timestamps only if the factor value @@ -158,12 +158,12 @@ Duration Timer::Connection::curr_time() */ if (_interpolation_quality == MAX_INTERPOLATION_QUALITY) { - /* buffer interpolation related members and free the lock */ + /* buffer interpolation related members and free the mutex */ Timestamp const ts = _ts; uint64_t const us_to_ts_factor = _us_to_ts_factor; unsigned const us_to_ts_factor_shift = _us_to_ts_factor_shift; - lock_guard.destruct(); + mutex_guard.destruct(); /* interpolate time difference since the last real time update */ Timestamp const ts_diff = _timestamp() - ts; @@ -177,7 +177,7 @@ Duration Timer::Connection::curr_time() /* use remote timer instead of timestamps */ interpolated_time.add(Microseconds(elapsed_us() - _us)); - lock_guard.destruct(); + mutex_guard.destruct(); } return _update_interpolated_time(interpolated_time); } diff --git a/repos/base/src/test/smp/main.cc b/repos/base/src/test/smp/main.cc index 684b7c2de..a775ee208 100644 --- a/repos/base/src/test/smp/main.cc +++ b/repos/base/src/test/smp/main.cc @@ -156,11 +156,11 @@ namespace Affinity_test { { Genode::Affinity::Location const location; Genode::uint64_t volatile cnt; - Genode::Lock barrier; + Genode::Blockade barrier { }; void entry() override { - barrier.unlock(); + barrier.wakeup(); Genode::log("Affinity: thread started on CPU ", location, " spinning..."); @@ -170,7 +170,7 @@ namespace Affinity_test { Spinning_thread(Genode::Env &env, Location location) : Genode::Thread(env, Name("spinning_thread"), STACK_SIZE, location, Weight(), env.cpu()), - location(location), cnt(0ULL), barrier(Genode::Lock::LOCKED) { + location(location), cnt(0ULL) { start(); } }; @@ -192,7 +192,7 @@ namespace Affinity_test { /* wait until all threads are up and running */ for (unsigned i = 0; i < cpus.total(); i++) - threads[i]->barrier.lock(); + threads[i]->barrier.block(); log("Affinity: Threads started on a different CPU each."); log("Affinity: You may inspect them using the kernel debugger - if you have one."); @@ -254,13 +254,13 @@ namespace Tlb_shootdown_test { unsigned cpu_idx; volatile unsigned * values; - Genode::Lock barrier; + Genode::Blockade barrier { }; void entry() override { Genode::log("TLB: thread started on CPU ", cpu_idx); values[cpu_idx] = 1; - barrier.unlock(); + barrier.wakeup(); for (; values[cpu_idx] == 1;) ; @@ -271,7 +271,7 @@ namespace Tlb_shootdown_test { volatile unsigned * values) : Genode::Thread(env, Name("tlb_thread"), STACK_SIZE, location, Weight(), env.cpu()), - cpu_idx(idx), values(values), barrier(Genode::Lock::LOCKED) { + cpu_idx(idx), values(values) { start(); } /* @@ -302,7 +302,7 @@ namespace Tlb_shootdown_test { ram_ds->local_addr()); /* wait until all threads are up and running */ - for (unsigned i = 1; i < cpus.total(); i++) threads[i]->barrier.lock(); + for (unsigned i = 1; i < cpus.total(); i++) threads[i]->barrier.block(); log("TLB: all threads are up and running..."); destroy(heap, ram_ds); diff --git a/repos/base/src/test/synced_interface/main.cc b/repos/base/src/test/synced_interface/main.cc index 9724ddbc4..51dc5fa41 100644 --- a/repos/base/src/test/synced_interface/main.cc +++ b/repos/base/src/test/synced_interface/main.cc @@ -28,18 +28,18 @@ struct Adder }; -struct Pseudo_lock +struct Pseudo_mutex { - void lock() { log("lock"); } - void unlock() { log("unlock"); } + void acquire() { log("acquire"); } + void release() { log("release"); } }; struct Main { - Pseudo_lock lock { }; - Adder adder { }; - Synced_interface synced_adder { lock, &adder }; + Pseudo_mutex mutex { }; + Adder adder { }; + Synced_interface synced_adder { mutex, &adder }; Main(Env &) { diff --git a/repos/base/src/test/thread/main.cc b/repos/base/src/test/thread/main.cc index 75c11a82f..786777b06 100644 --- a/repos/base/src/test/thread/main.cc +++ b/repos/base/src/test/thread/main.cc @@ -349,11 +349,11 @@ static void test_create_as_many_threads(Env &env) struct Lock_helper : Thread { - Lock &lock; - bool &lock_is_free; - bool unlock; + Blockade &lock; + bool &lock_is_free; + bool unlock; - Lock_helper(Env &env, const char * name, Cpu_session &cpu, Lock &lock, + Lock_helper(Env &env, const char * name, Cpu_session &cpu, Blockade &lock, bool &lock_is_free, bool unlock = false) : Thread(env, name, STACK_SIZE, Thread::Location(), Thread::Weight(), @@ -366,9 +366,9 @@ struct Lock_helper : Thread log(" thread '", name(), "' started"); if (unlock) - lock.unlock(); + lock.wakeup(); - lock.lock(); + lock.block(); if (!lock_is_free) { log(" thread '", name(), "' got lock but somebody else is within" @@ -378,13 +378,13 @@ struct Lock_helper : Thread log(" thread '", name(), "' done"); - lock.unlock(); + lock.wakeup(); } }; static void test_locks(Genode::Env &env) { - Lock lock (Lock::LOCKED); + Blockade lock; bool lock_is_free = true; @@ -403,7 +403,7 @@ static void test_locks(Genode::Env &env) l3.start(); l4.start(); - lock.lock(); + lock.block(); log(" thread '", Thread::myself()->name(), "' - I'm the lock holder - " "take lock again"); @@ -421,11 +421,11 @@ static void test_locks(Genode::Env &env) for (unsigned volatile i = 0; i < 8000000; ++i) memory_barrier(); log(" spinning done"); - lock.lock(); + lock.block(); log(" I'm the lock holder - still alive"); lock_is_free = true; - lock.unlock(); + lock.wakeup(); /* check that really all threads come back ! */ l1.join(); @@ -444,13 +444,13 @@ static void test_locks(Genode::Env &env) struct Cxa_helper : Thread { - Lock &in_cxa; - Lock &sync_startup; - int test; - bool sync; + Blockade &in_cxa; + Blockade &sync_startup; + int test; + bool sync; - Cxa_helper(Env &env, const char * name, Cpu_session &cpu, Lock &cxa, - Lock &startup, int test, bool sync = false) + Cxa_helper(Env &env, const char * name, Cpu_session &cpu, Blockade &cxa, + Blockade &startup, int test, bool sync = false) : Thread(env, name, STACK_SIZE, Thread::Location(), Thread::Weight(), cpu), @@ -462,14 +462,14 @@ struct Cxa_helper : Thread log(" thread '", name(), "' started"); if (sync) - sync_startup.unlock(); + sync_startup.wakeup(); struct Contention { - Contention(Name name, Lock &in_cxa, Lock &sync_startup) + Contention(Name name, Blockade &in_cxa, Blockade &sync_startup) { log(" thread '", name, "' in static constructor"); - sync_startup.unlock(); - in_cxa.lock(); + sync_startup.wakeup(); + in_cxa.block(); } }; @@ -501,16 +501,16 @@ static void test_cxa_guards(Env &env) { enum { TEST_1ST = 1 }; - Lock in_cxa (Lock::LOCKED); - Lock sync_startup (Lock::LOCKED); + Blockade in_cxa; + Blockade sync_startup; /* start low priority thread */ Cxa_helper cxa_l(env, "cxa_low", cpu_l, in_cxa, sync_startup, TEST_1ST); cxa_l.start(); /* wait until low priority thread is inside static variable */ - sync_startup.lock(); - sync_startup.unlock(); + sync_startup.block(); + sync_startup.wakeup(); /* start high priority threads */ Cxa_helper cxa_h1(env, "cxa_high_1", env.cpu(), in_cxa, sync_startup, @@ -537,10 +537,10 @@ static void test_cxa_guards(Env &env) * if the middle priority thread manages to sync with current * (high priority) entrypoint thread */ - sync_startup.lock(); + sync_startup.block(); /* let's see whether we get all our threads out of the static variable */ - in_cxa.unlock(); + in_cxa.wakeup(); /* eureka ! */ cxa_h1.join(); cxa_h2.join(); cxa_h3.join(); cxa_h4.join(); @@ -551,12 +551,12 @@ static void test_cxa_guards(Env &env) { enum { TEST_2ND = 2, TEST_3RD = 3, TEST_4TH = 4 }; - Lock in_cxa_2 (Lock::LOCKED); - Lock sync_startup_2 (Lock::LOCKED); - Lock in_cxa_3 (Lock::LOCKED); - Lock sync_startup_3 (Lock::LOCKED); - Lock in_cxa_4 (Lock::LOCKED); - Lock sync_startup_4 (Lock::LOCKED); + Blockade in_cxa_2; + Blockade sync_startup_2; + Blockade in_cxa_3; + Blockade sync_startup_3; + Blockade in_cxa_4; + Blockade sync_startup_4; /* start low priority threads */ Cxa_helper cxa_l_2(env, "cxa_low_2", cpu_l, in_cxa_2, sync_startup_2, @@ -570,12 +570,12 @@ static void test_cxa_guards(Env &env) cxa_l_4.start(); /* wait until low priority threads are inside static variables */ - sync_startup_2.lock(); - sync_startup_2.unlock(); - sync_startup_3.lock(); - sync_startup_3.unlock(); - sync_startup_4.lock(); - sync_startup_4.unlock(); + sync_startup_2.block(); + sync_startup_2.wakeup(); + sync_startup_3.block(); + sync_startup_3.wakeup(); + sync_startup_4.block(); + sync_startup_4.wakeup(); /* start high priority threads */ Cxa_helper cxa_h1_2(env, "cxa_high_1_2", env.cpu(), in_cxa_2, @@ -628,14 +628,14 @@ static void test_cxa_guards(Env &env) * variables, if the middle priority threads manage to sync with * current (high priority) entrypoint thread */ - sync_startup_2.lock(); - sync_startup_3.lock(); - sync_startup_4.lock(); + sync_startup_2.block(); + sync_startup_3.block(); + sync_startup_4.block(); /* let's see whether we get all our threads out of the static variable */ - in_cxa_4.unlock(); - in_cxa_3.unlock(); - in_cxa_2.unlock(); + in_cxa_4.wakeup(); + in_cxa_3.wakeup(); + in_cxa_2.wakeup(); cxa_h1_2.join(); cxa_h2_2.join(); cxa_h3_2.join(); cxa_h4_2.join(); cxa_m_2.join(); cxa_l_2.join(); diff --git a/repos/base/src/timer/fiasco/time_source.cc b/repos/base/src/timer/fiasco/time_source.cc index 7737f4639..dd4a484f2 100644 --- a/repos/base/src/timer/fiasco/time_source.cc +++ b/repos/base/src/timer/fiasco/time_source.cc @@ -68,14 +68,14 @@ static l4_timeout_s mus_to_timeout(uint64_t mus) Microseconds Timer::Time_source::max_timeout() const { - Genode::Lock::Guard lock_guard(_lock); + Genode::Mutex::Guard lock_guard(_mutex); return Microseconds(1000 * 1000 * 100); } Duration Timer::Time_source::curr_time() { - Genode::Lock::Guard lock_guard(_lock); + Genode::Mutex::Guard mutex_guard(_mutex); static Genode::Attached_rom_dataspace kip_ds(_env, "l4v2_kip"); static Fiasco::l4_kernel_info_t * const kip = kip_ds.local_addr(); diff --git a/repos/base/src/timer/periodic/time_source.cc b/repos/base/src/timer/periodic/time_source.cc index b1fd9c118..c9948ed5b 100644 --- a/repos/base/src/timer/periodic/time_source.cc +++ b/repos/base/src/timer/periodic/time_source.cc @@ -21,7 +21,7 @@ using namespace Genode; void Timer::Time_source::schedule_timeout(Microseconds duration, Timeout_handler &handler) { - Genode::Lock::Guard lock_guard(_lock); + Mutex::Guard mutex_guard(_mutex); Threaded_time_source::handler(handler); _next_timeout_us = duration.value; } @@ -31,9 +31,9 @@ void Timer::Time_source::_wait_for_irq() { enum { SLEEP_GRANULARITY_US = 1000 }; uint64_t last_time_us = curr_time().trunc_to_plain_us().value; - _lock.lock(); + _mutex.acquire(); while (_next_timeout_us > 0) { - _lock.unlock(); + _mutex.release(); try { _usleep(SLEEP_GRANULARITY_US); } catch (Blocking_canceled) { } @@ -42,11 +42,11 @@ void Timer::Time_source::_wait_for_irq() uint64_t sleep_duration_us = curr_time_us - last_time_us; last_time_us = curr_time_us; - _lock.lock(); + _mutex.acquire(); if (_next_timeout_us >= sleep_duration_us) _next_timeout_us -= sleep_duration_us; else break; } - _lock.unlock(); + _mutex.release(); } diff --git a/repos/base/src/timer/periodic/time_source.h b/repos/base/src/timer/periodic/time_source.h index e6e2cf89f..0aead928f 100644 --- a/repos/base/src/timer/periodic/time_source.h +++ b/repos/base/src/timer/periodic/time_source.h @@ -31,9 +31,9 @@ class Timer::Time_source : public Threaded_time_source Genode::Env &_env; - Genode::Lock mutable _lock { }; - uint64_t _curr_time_us = 0; - uint64_t _next_timeout_us = max_timeout().value; + Genode::Mutex mutable _mutex { }; + uint64_t _curr_time_us = 0; + uint64_t _next_timeout_us = max_timeout().value; void _usleep(uint64_t us); diff --git a/repos/dde_rump/include/rump/timed_semaphore.h b/repos/dde_rump/include/rump/timed_semaphore.h index e076a76d5..ac008786e 100644 --- a/repos/dde_rump/include/rump/timed_semaphore.h +++ b/repos/dde_rump/include/rump/timed_semaphore.h @@ -99,7 +99,7 @@ class Timed_semaphore : public Semaphore */ bool _abort(Element &element) { - Genode::Lock::Guard lock_guard(Semaphore::_meta_lock); + Genode::Mutex::Guard lock_guard(Semaphore::_meta_lock); /* potentially, the queue is empty */ if (++Semaphore::_cnt <= 0) { @@ -119,7 +119,7 @@ class Timed_semaphore : public Semaphore * Wakeup the thread. */ if (&element == e) { - e->wake_up(); + e->blockade.wakeup(); return true; } @@ -198,14 +198,14 @@ class Timed_semaphore : public Semaphore */ Alarm::Time down(Alarm::Time t) { - Semaphore::_meta_lock.lock(); + Semaphore::_meta_lock.acquire(); if (--Semaphore::_cnt < 0) { /* If t==0 we shall not block */ if (t == 0) { ++_cnt; - Semaphore::_meta_lock.unlock(); + Semaphore::_meta_lock.release(); throw Nonblocking_exception(); } @@ -215,7 +215,7 @@ class Timed_semaphore : public Semaphore */ Element queue_element; Semaphore::_queue.enqueue(queue_element); - Semaphore::_meta_lock.unlock(); + Semaphore::_meta_lock.release(); /* Create the timeout */ Alarm::Time const curr_time = _timeout_ep.time(); @@ -227,7 +227,7 @@ class Timed_semaphore : public Semaphore * waiting for getting waked from another thread * calling 'up()' * */ - queue_element.block(); + queue_element.blockade.block(); /* Deactivate timeout */ _timeout_ep.discard(timeout); @@ -243,7 +243,7 @@ class Timed_semaphore : public Semaphore return _timeout_ep.time() - timeout.start(); } else { - Semaphore::_meta_lock.unlock(); + Semaphore::_meta_lock.release(); } return 0; } diff --git a/repos/ports/src/app/seoul/component.cc b/repos/ports/src/app/seoul/component.cc index 40018f5ec..60ae3e1e3 100644 --- a/repos/ports/src/app/seoul/component.cc +++ b/repos/ports/src/app/seoul/component.cc @@ -178,7 +178,7 @@ class Vcpu : public StaticReceiver Vcpu(Genode::Entrypoint &ep, Genode::Vm_connection &vm_con, Genode::Allocator &alloc, Genode::Env &env, - Genode::Lock &vcpu_lock, VCpu *unsynchronized_vcpu, + Genode::Mutex &vcpu_mutex, VCpu *unsynchronized_vcpu, Seoul::Guest_memory &guest_memory, Synced_motherboard &motherboard, bool vmx, bool svm, bool map_small, bool rdtsc) : @@ -197,7 +197,7 @@ class Vcpu : public StaticReceiver _guest_memory(guest_memory), _motherboard(motherboard), - _vcpu(vcpu_lock, unsynchronized_vcpu) + _vcpu(vcpu_mutex, unsynchronized_vcpu) { if (!_svm && !_vmx) Logging::panic("no SVM/VMX available, sorry"); @@ -764,10 +764,10 @@ class Machine : public StaticReceiver Genode::Heap &_heap; Genode::Vm_connection &_vm_con; Clock _clock; - Genode::Lock _motherboard_lock; + Genode::Mutex _motherboard_mutex { }; Motherboard _unsynchronized_motherboard; Synced_motherboard _motherboard; - Genode::Lock _timeouts_lock { }; + Genode::Mutex _timeouts_mutex { }; TimeoutList<32, void> _unsynchronized_timeouts { }; Synced_timeout_list _timeouts; Seoul::Guest_memory &_guest_memory; @@ -912,7 +912,7 @@ class Machine : public StaticReceiver _vcpus_active.set(_vcpus_up, 1); Vcpu * vcpu = new Vcpu(*ep, _vm_con, _heap, _env, - _motherboard_lock, msg.vcpu, + _motherboard_mutex, msg.vcpu, _guest_memory, _motherboard, has_vmx, has_svm, _map_small, _rdtsc_exit); @@ -967,11 +967,11 @@ class Machine : public StaticReceiver _unsynchronized_motherboard.bus_console.send(msgcon); } - _motherboard_lock.unlock(); + _motherboard_mutex.release(); _vcpus[vcpu_id]->block(); - _motherboard_lock.lock(); + _motherboard_mutex.acquire(); if (!_vcpus_active.get(0, 64)) { MessageConsole msgcon(MessageConsole::Type::TYPE_RESET); @@ -1186,16 +1186,17 @@ class Machine : public StaticReceiver : _env(env), _heap(heap), _vm_con(vm_con), _clock(Attached_rom_dataspace(env, "platform_info").xml().sub_node("hardware").sub_node("tsc").attribute_value("freq_khz", 0ULL) * 1000ULL), - _motherboard_lock(Genode::Lock::LOCKED), _unsynchronized_motherboard(&_clock, nullptr), - _motherboard(_motherboard_lock, &_unsynchronized_motherboard), - _timeouts(_timeouts_lock, &_unsynchronized_timeouts), + _motherboard(_motherboard_mutex, &_unsynchronized_motherboard), + _timeouts(_timeouts_mutex, &_unsynchronized_timeouts), _guest_memory(guest_memory), _boot_modules(boot_modules), _map_small(map_small), _rdtsc_exit(rdtsc_exit), _same_cpu(vmm_vcpu_same_cpu) { + _motherboard_mutex.acquire(); + _timeouts()->init(); /* register host operations, called back by the VMM */ @@ -1338,7 +1339,7 @@ class Machine : public StaticReceiver Logging::printf("INIT done\n"); - _motherboard_lock.unlock(); + _motherboard_mutex.release(); } Synced_motherboard &motherboard() { return _motherboard; }