ehmry/genode
ehmry
/
genode
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity
genode/repos/base/include/base/alarm.h

190 lines
4.5 KiB
C
Raw Normal View History

Imported Genode release 11.11
2011-12-22 16:19:25 +01:00
/*
* \brief Timed event scheduler interface
* \date 2005-10-24
* \author Norman Feske
*/
/*
Adjust file headers to refer to the AGPLv3
2017-02-20 13:23:52 +01:00
* Copyright (C) 2005-2017 Genode Labs GmbH
Imported Genode release 11.11
2011-12-22 16:19:25 +01:00
*
* This file is part of the Genode OS framework, which is distributed
Adjust file headers to refer to the AGPLv3
2017-02-20 13:23:52 +01:00
* under the terms of the GNU Affero General Public License version 3.
Imported Genode release 11.11
2011-12-22 16:19:25 +01:00
*/
Move timer from os to base repository Since the timer and timeout handling is part of the base library (the dynamic linker), it belongs to the base repository. Besides moving the timer and its related infrastructure (alarm, timeout libs, tests) to the base repository, this patch also moves the timer from the 'drivers' subdirectory directly to 'src' and disamibuates the timer's build locations for the various kernels. Otherwise the different timer implementations could interfere with each other when using one build directory with multiple kernels. Note that this patch changes the include paths for the former os/timer, os/alarm.h, os/duration.h, and os/timed_semaphore.h to base/. Issue #3101
2019-01-03 18:01:49 +01:00
#ifndef _INCLUDE__BASE__ALARM_H_
#define _INCLUDE__BASE__ALARM_H_
Imported Genode release 11.11
2011-12-22 16:19:25 +01:00
#include <base/lock.h>
namespace Genode {
class Alarm_scheduler;
base,os: Coding-style unification Fixes #1432
2015-03-04 21:12:14 +01:00
class Alarm;
Imported Genode release 11.11
2011-12-22 16:19:25 +01:00
}
base,os: Coding-style unification Fixes #1432
2015-03-04 21:12:14 +01:00
class Genode::Alarm
{
public:
timeout: use uint64_t for all plain time values This enforces the use of unsigned 64-bit values for time in the duration type, the timeout framework, the timer session, the userland timer-drivers, and the alarm framework on all platforms. The commit also adapts the code that uses these tools accross all basic repositories (base, base-*, os. gems, libports, ports, dde_*) to use unsigned 64-bit values for time as well as far as this does not imply profound modifications. Fixes #3208
2019-04-09 15:46:36 +02:00
typedef uint64_t Time;
base,os: Coding-style unification Fixes #1432
2015-03-04 21:12:14 +01:00
private:
friend class Alarm_scheduler;
timer: limit rate of handling timeouts Ensure that the timer does not handle timeouts again within 1000 microseconds after the last handling of timeouts. This makes denial of service attacks harder. This commit does not limit the rate of timeout signals handled inside the timer but it causes the timer to do it less often. If a client continuously installs a very small timeout at the timer it still causes a signal to be submitted to the timer each time and some extra CPU time to be spent in the internal handling method. But only every 1000 microseconds this internal handling causes user timeouts to trigger. If we would want to limit also the call of the internal handling method to ensure that CPU time is spent beside the RPCs only every 1000 microseconds, things would get more complex. For instance, on NOVA Time_source::schedule_timeout(0) must be called each time a new timeout gets installed and becomes head of the scheduling queue. We cannot simply overwrite the already running timeout with the new one. Ref #2490
2017-09-29 14:12:10 +02:00
struct Raw
{
Time deadline; /* next deadline */
bool deadline_period;
Time period; /* duration between alarms */
timeout: use uint64_t for all plain time values This enforces the use of unsigned 64-bit values for time in the duration type, the timeout framework, the timer session, the userland timer-drivers, and the alarm framework on all platforms. The commit also adapts the code that uses these tools accross all basic repositories (base, base-*, os. gems, libports, ports, dde_*) to use unsigned 64-bit values for time as well as far as this does not imply profound modifications. Fixes #3208
2019-04-09 15:46:36 +02:00
bool is_pending_at(uint64_t time, bool time_period) const;
timer: limit rate of handling timeouts Ensure that the timer does not handle timeouts again within 1000 microseconds after the last handling of timeouts. This makes denial of service attacks harder. This commit does not limit the rate of timeout signals handled inside the timer but it causes the timer to do it less often. If a client continuously installs a very small timeout at the timer it still causes a signal to be submitted to the timer each time and some extra CPU time to be spent in the internal handling method. But only every 1000 microseconds this internal handling causes user timeouts to trigger. If we would want to limit also the call of the internal handling method to ensure that CPU time is spent beside the RPCs only every 1000 microseconds, things would get more complex. For instance, on NOVA Time_source::schedule_timeout(0) must be called each time a new timeout gets installed and becomes head of the scheduling queue. We cannot simply overwrite the already running timeout with the new one. Ref #2490
2017-09-29 14:12:10 +02:00
};
Follow practices suggested by "Effective C++" The patch adjust the code of the base, base-<kernel>, and os repository. To adapt existing components to fix violations of the best practices suggested by "Effective C++" as reported by the -Weffc++ compiler argument. The changes follow the patterns outlined below: * A class with virtual functions can no longer publicly inherit base classed without a vtable. The inherited object may either be moved to a member variable, or inherited privately. The latter would be used for classes that inherit 'List::Element' or 'Avl_node'. In order to enable the 'List' and 'Avl_tree' to access the meta data, the 'List' must become a friend. * Instead of adding a virtual destructor to abstract base classes, we inherit the new 'Interface' class, which contains a virtual destructor. This way, single-line abstract base classes can stay as compact as they are now. The 'Interface' utility resides in base/include/util/interface.h. * With the new warnings enabled, all member variables must be explicitly initialized. Basic types may be initialized with '='. All other types are initialized with braces '{ ... }' or as class initializers. If basic types and non-basic types appear in a row, it is nice to only use the brace syntax (also for basic types) and align the braces. * If a class contains pointers as members, it must now also provide a copy constructor and assignment operator. In the most cases, one would make them private, effectively disallowing the objects to be copied. Unfortunately, this warning cannot be fixed be inheriting our existing 'Noncopyable' class (the compiler fails to detect that the inheriting class cannot be copied and still gives the error). For now, we have to manually add declarations for both the copy constructor and assignment operator as private class members. Those declarations should be prepended with a comment like this: /* * Noncopyable */ Thread(Thread const &); Thread &operator = (Thread const &); In the future, we should revisit these places and try to replace the pointers with references. In the presence of at least one reference member, the compiler would no longer implicitly generate a copy constructor. So we could remove the manual declaration. Issue #465
2017-12-21 15:42:15 +01:00
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 */
base,os: Coding-style unification Fixes #1432
2015-03-04 21:12:14 +01:00
alarm: fix information loss due to int-cast When we have two time values of an unsigned integer type and we create the difference and want to know wether it is positive or negative within the same value we loose at least one half of the value range for casting to signed integers. This was the case in the alarm scheduler when checking wether an alarm already triggered. Even worse, we casted from 'unsigned long' to 'signed int' which caused further loss on at least x86_64. Thus, big timeouts like ~0UL falsely triggered directly. Now, we use an extra boolean value to remember in which period of the time counter we are and to which period of the time counter the deadline of an alarm belongs. This boolean switches its value each time the time counter wraps. This way, we can avoid any casting by checking wether the current time is of the same period as the deadline of the alarm that we inspect. If so, the alarm is pending if "current time >= alarm deadline", otherwise it is pending if "current time < alarm deadline". Ref #2490
2017-09-12 13:15:01 +02:00
void _assign(Time period,
Time deadline,
bool deadline_period,
Alarm_scheduler *scheduler)
{
timer: limit rate of handling timeouts Ensure that the timer does not handle timeouts again within 1000 microseconds after the last handling of timeouts. This makes denial of service attacks harder. This commit does not limit the rate of timeout signals handled inside the timer but it causes the timer to do it less often. If a client continuously installs a very small timeout at the timer it still causes a signal to be submitted to the timer each time and some extra CPU time to be spent in the internal handling method. But only every 1000 microseconds this internal handling causes user timeouts to trigger. If we would want to limit also the call of the internal handling method to ensure that CPU time is spent beside the RPCs only every 1000 microseconds, things would get more complex. For instance, on NOVA Time_source::schedule_timeout(0) must be called each time a new timeout gets installed and becomes head of the scheduling queue. We cannot simply overwrite the already running timeout with the new one. Ref #2490
2017-09-29 14:12:10 +02:00
_raw.period = period;
_raw.deadline_period = deadline_period;
_raw.deadline = deadline;
_scheduler = scheduler;
alarm: fix information loss due to int-cast When we have two time values of an unsigned integer type and we create the difference and want to know wether it is positive or negative within the same value we loose at least one half of the value range for casting to signed integers. This was the case in the alarm scheduler when checking wether an alarm already triggered. Even worse, we casted from 'unsigned long' to 'signed int' which caused further loss on at least x86_64. Thus, big timeouts like ~0UL falsely triggered directly. Now, we use an extra boolean value to remember in which period of the time counter we are and to which period of the time counter the deadline of an alarm belongs. This boolean switches its value each time the time counter wraps. This way, we can avoid any casting by checking wether the current time is of the same period as the deadline of the alarm that we inspect. If so, the alarm is pending if "current time >= alarm deadline", otherwise it is pending if "current time < alarm deadline". Ref #2490
2017-09-12 13:15:01 +02:00
}
base,os: Coding-style unification Fixes #1432
2015-03-04 21:12:14 +01:00
void _reset() {
alarm: fix information loss due to int-cast When we have two time values of an unsigned integer type and we create the difference and want to know wether it is positive or negative within the same value we loose at least one half of the value range for casting to signed integers. This was the case in the alarm scheduler when checking wether an alarm already triggered. Even worse, we casted from 'unsigned long' to 'signed int' which caused further loss on at least x86_64. Thus, big timeouts like ~0UL falsely triggered directly. Now, we use an extra boolean value to remember in which period of the time counter we are and to which period of the time counter the deadline of an alarm belongs. This boolean switches its value each time the time counter wraps. This way, we can avoid any casting by checking wether the current time is of the same period as the deadline of the alarm that we inspect. If so, the alarm is pending if "current time >= alarm deadline", otherwise it is pending if "current time < alarm deadline". Ref #2490
2017-09-12 13:15:01 +02:00
_assign(0, 0, false, 0), _active = 0, _next = 0; }
Follow practices suggested by "Effective C++" The patch adjust the code of the base, base-<kernel>, and os repository. To adapt existing components to fix violations of the best practices suggested by "Effective C++" as reported by the -Weffc++ compiler argument. The changes follow the patterns outlined below: * A class with virtual functions can no longer publicly inherit base classed without a vtable. The inherited object may either be moved to a member variable, or inherited privately. The latter would be used for classes that inherit 'List::Element' or 'Avl_node'. In order to enable the 'List' and 'Avl_tree' to access the meta data, the 'List' must become a friend. * Instead of adding a virtual destructor to abstract base classes, we inherit the new 'Interface' class, which contains a virtual destructor. This way, single-line abstract base classes can stay as compact as they are now. The 'Interface' utility resides in base/include/util/interface.h. * With the new warnings enabled, all member variables must be explicitly initialized. Basic types may be initialized with '='. All other types are initialized with braces '{ ... }' or as class initializers. If basic types and non-basic types appear in a row, it is nice to only use the brace syntax (also for basic types) and align the braces. * If a class contains pointers as members, it must now also provide a copy constructor and assignment operator. In the most cases, one would make them private, effectively disallowing the objects to be copied. Unfortunately, this warning cannot be fixed be inheriting our existing 'Noncopyable' class (the compiler fails to detect that the inheriting class cannot be copied and still gives the error). For now, we have to manually add declarations for both the copy constructor and assignment operator as private class members. Those declarations should be prepended with a comment like this: /* * Noncopyable */ Thread(Thread const &); Thread &operator = (Thread const &); In the future, we should revisit these places and try to replace the pointers with references. In the presence of at least one reference member, the compiler would no longer implicitly generate a copy constructor. So we could remove the manual declaration. Issue #465
2017-12-21 15:42:15 +01:00
/*
* Noncopyable
*/
Alarm(Alarm const &);
Alarm &operator = (Alarm const &);
base,os: Coding-style unification Fixes #1432
2015-03-04 21:12:14 +01:00
protected:
/**
Revised API documentation This patch curates the API documentation to become suitable for the functional specificaton, which is partially generated from the header files.
2015-03-20 17:50:41 +01:00
* Method to be called on when deadline is reached
base,os: Coding-style unification Fixes #1432
2015-03-04 21:12:14 +01:00
*
Revised API documentation This patch curates the API documentation to become suitable for the functional specificaton, which is partially generated from the header files.
2015-03-20 17:50:41 +01:00
* This method must be implemented by a derived class. If the
base,os: Coding-style unification Fixes #1432
2015-03-04 21:12:14 +01:00
* return value is 'true' and the alarm is periodically scheduled,
* the alarm is scheduled again.
*/
timeout: use uint64_t for all plain time values This enforces the use of unsigned 64-bit values for time in the duration type, the timeout framework, the timer session, the userland timer-drivers, and the alarm framework on all platforms. The commit also adapts the code that uses these tools accross all basic repositories (base, base-*, os. gems, libports, ports, dde_*) to use unsigned 64-bit values for time as well as far as this does not imply profound modifications. Fixes #3208
2019-04-09 15:46:36 +02:00
virtual bool on_alarm(uint64_t) { return false; }
base,os: Coding-style unification Fixes #1432
2015-03-04 21:12:14 +01:00
public:
Alarm() { _reset(); }
virtual ~Alarm();
};
class Genode::Alarm_scheduler
{
private:
Follow practices suggested by "Effective C++" The patch adjust the code of the base, base-<kernel>, and os repository. To adapt existing components to fix violations of the best practices suggested by "Effective C++" as reported by the -Weffc++ compiler argument. The changes follow the patterns outlined below: * A class with virtual functions can no longer publicly inherit base classed without a vtable. The inherited object may either be moved to a member variable, or inherited privately. The latter would be used for classes that inherit 'List::Element' or 'Avl_node'. In order to enable the 'List' and 'Avl_tree' to access the meta data, the 'List' must become a friend. * Instead of adding a virtual destructor to abstract base classes, we inherit the new 'Interface' class, which contains a virtual destructor. This way, single-line abstract base classes can stay as compact as they are now. The 'Interface' utility resides in base/include/util/interface.h. * With the new warnings enabled, all member variables must be explicitly initialized. Basic types may be initialized with '='. All other types are initialized with braces '{ ... }' or as class initializers. If basic types and non-basic types appear in a row, it is nice to only use the brace syntax (also for basic types) and align the braces. * If a class contains pointers as members, it must now also provide a copy constructor and assignment operator. In the most cases, one would make them private, effectively disallowing the objects to be copied. Unfortunately, this warning cannot be fixed be inheriting our existing 'Noncopyable' class (the compiler fails to detect that the inheriting class cannot be copied and still gives the error). For now, we have to manually add declarations for both the copy constructor and assignment operator as private class members. Those declarations should be prepended with a comment like this: /* * Noncopyable */ Thread(Thread const &); Thread &operator = (Thread const &); In the future, we should revisit these places and try to replace the pointers with references. In the presence of at least one reference member, the compiler would no longer implicitly generate a copy constructor. So we could remove the manual declaration. Issue #465
2017-12-21 15:42:15 +01:00
Lock _lock { }; /* protect alarm list */
timer: limit rate of handling timeouts Ensure that the timer does not handle timeouts again within 1000 microseconds after the last handling of timeouts. This makes denial of service attacks harder. This commit does not limit the rate of timeout signals handled inside the timer but it causes the timer to do it less often. If a client continuously installs a very small timeout at the timer it still causes a signal to be submitted to the timer each time and some extra CPU time to be spent in the internal handling method. But only every 1000 microseconds this internal handling causes user timeouts to trigger. If we would want to limit also the call of the internal handling method to ensure that CPU time is spent beside the RPCs only every 1000 microseconds, things would get more complex. For instance, on NOVA Time_source::schedule_timeout(0) must be called each time a new timeout gets installed and becomes head of the scheduling queue. We cannot simply overwrite the already running timeout with the new one. Ref #2490
2017-09-29 14:12:10 +02:00
Alarm *_head { nullptr }; /* head of alarm list */
Alarm::Time _now { 0UL }; /* recent time (updated by handle method) */
alarm: fix information loss due to int-cast When we have two time values of an unsigned integer type and we create the difference and want to know wether it is positive or negative within the same value we loose at least one half of the value range for casting to signed integers. This was the case in the alarm scheduler when checking wether an alarm already triggered. Even worse, we casted from 'unsigned long' to 'signed int' which caused further loss on at least x86_64. Thus, big timeouts like ~0UL falsely triggered directly. Now, we use an extra boolean value to remember in which period of the time counter we are and to which period of the time counter the deadline of an alarm belongs. This boolean switches its value each time the time counter wraps. This way, we can avoid any casting by checking wether the current time is of the same period as the deadline of the alarm that we inspect. If so, the alarm is pending if "current time >= alarm deadline", otherwise it is pending if "current time < alarm deadline". Ref #2490
2017-09-12 13:15:01 +02:00
bool _now_period { false };
Follow practices suggested by "Effective C++" The patch adjust the code of the base, base-<kernel>, and os repository. To adapt existing components to fix violations of the best practices suggested by "Effective C++" as reported by the -Weffc++ compiler argument. The changes follow the patterns outlined below: * A class with virtual functions can no longer publicly inherit base classed without a vtable. The inherited object may either be moved to a member variable, or inherited privately. The latter would be used for classes that inherit 'List::Element' or 'Avl_node'. In order to enable the 'List' and 'Avl_tree' to access the meta data, the 'List' must become a friend. * Instead of adding a virtual destructor to abstract base classes, we inherit the new 'Interface' class, which contains a virtual destructor. This way, single-line abstract base classes can stay as compact as they are now. The 'Interface' utility resides in base/include/util/interface.h. * With the new warnings enabled, all member variables must be explicitly initialized. Basic types may be initialized with '='. All other types are initialized with braces '{ ... }' or as class initializers. If basic types and non-basic types appear in a row, it is nice to only use the brace syntax (also for basic types) and align the braces. * If a class contains pointers as members, it must now also provide a copy constructor and assignment operator. In the most cases, one would make them private, effectively disallowing the objects to be copied. Unfortunately, this warning cannot be fixed be inheriting our existing 'Noncopyable' class (the compiler fails to detect that the inheriting class cannot be copied and still gives the error). For now, we have to manually add declarations for both the copy constructor and assignment operator as private class members. Those declarations should be prepended with a comment like this: /* * Noncopyable */ Thread(Thread const &); Thread &operator = (Thread const &); In the future, we should revisit these places and try to replace the pointers with references. In the presence of at least one reference member, the compiler would no longer implicitly generate a copy constructor. So we could remove the manual declaration. Issue #465
2017-12-21 15:42:15 +01:00
Alarm::Raw _min_handle_period { };
base,os: Coding-style unification Fixes #1432
2015-03-04 21:12:14 +01:00
/**
* Enqueue alarm into alarm queue
*
Revised API documentation This patch curates the API documentation to become suitable for the functional specificaton, which is partially generated from the header files.
2015-03-20 17:50:41 +01:00
* This is a helper for 'schedule' and 'handle'.
base,os: Coding-style unification Fixes #1432
2015-03-04 21:12:14 +01:00
*/
void _unsynchronized_enqueue(Alarm *alarm);
/**
* Dequeue alarm from alarm queue
*/
void _unsynchronized_dequeue(Alarm *alarm);
/**
* Dequeue next pending alarm from alarm list
*
* \return dequeued pending alarm
* \retval 0 no alarm pending
*/
Alarm *_get_pending_alarm();
alarm: reposition reprogrammed alarms in queue The alarm library failed to handle the case properly where an already scheduled alarm gets rescheduled before it triggered. Even though the attempt to reschedule the alarm (twice insertion into alarm queue) was detected, this condition resulted in the mere modification of the alarm's parameters while keeping the alarm's queue position unchanged. This, in turn, may violate the invariant that all enqueued alarm objects are strictly ordered by their deadlines. The patch handles the case by dequeuing the alarm object before reinserting it into the queue at the right position. Fixes #1646
2015-08-13 22:53:03 +02:00
/**
* Assign timeout values to alarm object and add it to the schedule
*/
void _setup_alarm(Alarm &alarm, Alarm::Time period, Alarm::Time deadline);
Follow practices suggested by "Effective C++" The patch adjust the code of the base, base-<kernel>, and os repository. To adapt existing components to fix violations of the best practices suggested by "Effective C++" as reported by the -Weffc++ compiler argument. The changes follow the patterns outlined below: * A class with virtual functions can no longer publicly inherit base classed without a vtable. The inherited object may either be moved to a member variable, or inherited privately. The latter would be used for classes that inherit 'List::Element' or 'Avl_node'. In order to enable the 'List' and 'Avl_tree' to access the meta data, the 'List' must become a friend. * Instead of adding a virtual destructor to abstract base classes, we inherit the new 'Interface' class, which contains a virtual destructor. This way, single-line abstract base classes can stay as compact as they are now. The 'Interface' utility resides in base/include/util/interface.h. * With the new warnings enabled, all member variables must be explicitly initialized. Basic types may be initialized with '='. All other types are initialized with braces '{ ... }' or as class initializers. If basic types and non-basic types appear in a row, it is nice to only use the brace syntax (also for basic types) and align the braces. * If a class contains pointers as members, it must now also provide a copy constructor and assignment operator. In the most cases, one would make them private, effectively disallowing the objects to be copied. Unfortunately, this warning cannot be fixed be inheriting our existing 'Noncopyable' class (the compiler fails to detect that the inheriting class cannot be copied and still gives the error). For now, we have to manually add declarations for both the copy constructor and assignment operator as private class members. Those declarations should be prepended with a comment like this: /* * Noncopyable */ Thread(Thread const &); Thread &operator = (Thread const &); In the future, we should revisit these places and try to replace the pointers with references. In the presence of at least one reference member, the compiler would no longer implicitly generate a copy constructor. So we could remove the manual declaration. Issue #465
2017-12-21 15:42:15 +01:00
/*
* Noncopyable
*/
Alarm_scheduler(Alarm_scheduler const &);
Alarm_scheduler &operator = (Alarm_scheduler const &);
base,os: Coding-style unification Fixes #1432
2015-03-04 21:12:14 +01:00
public:
timer: limit rate of handling timeouts Ensure that the timer does not handle timeouts again within 1000 microseconds after the last handling of timeouts. This makes denial of service attacks harder. This commit does not limit the rate of timeout signals handled inside the timer but it causes the timer to do it less often. If a client continuously installs a very small timeout at the timer it still causes a signal to be submitted to the timer each time and some extra CPU time to be spent in the internal handling method. But only every 1000 microseconds this internal handling causes user timeouts to trigger. If we would want to limit also the call of the internal handling method to ensure that CPU time is spent beside the RPCs only every 1000 microseconds, things would get more complex. For instance, on NOVA Time_source::schedule_timeout(0) must be called each time a new timeout gets installed and becomes head of the scheduling queue. We cannot simply overwrite the already running timeout with the new one. Ref #2490
2017-09-29 14:12:10 +02:00
Alarm_scheduler(Alarm::Time min_handle_period = 1)
{
Alarm::Time const deadline = _now + min_handle_period;
_min_handle_period.period = min_handle_period;
_min_handle_period.deadline = deadline;
_min_handle_period.deadline_period = _now > deadline ?
!_now_period : _now_period;
}
base,os: Coding-style unification Fixes #1432
2015-03-04 21:12:14 +01:00
~Alarm_scheduler();
/**
* Schedule absolute timeout
*
* \param timeout absolute point in time for execution
*/
void schedule_absolute(Alarm *alarm, Alarm::Time timeout);
/**
* Schedule alarm (periodic timeout)
*
* \param period alarm period
*
* The first deadline is overdue after this call, i.e. on_alarm() is
* called immediately.
*/
void schedule(Alarm *alarm, Alarm::Time period);
/**
* Remove alarm from schedule
*/
void discard(Alarm *alarm);
/**
* Handle alarms
*
* \param now current time
*/
void handle(Alarm::Time now);
/**
* Determine next deadline (absolute)
*
* \param deadline out parameter for storing the next deadline
* \return true if an alarm is scheduled
*/
bool next_deadline(Alarm::Time *deadline);
/**
* Determine if given alarm object is current head element
*
* \param alarm alarm object
* \return true if alarm is head element of timeout queue
*/
bool head_timeout(const Alarm * alarm) { return _head == alarm; }
};
Move timer from os to base repository Since the timer and timeout handling is part of the base library (the dynamic linker), it belongs to the base repository. Besides moving the timer and its related infrastructure (alarm, timeout libs, tests) to the base repository, this patch also moves the timer from the 'drivers' subdirectory directly to 'src' and disamibuates the timer's build locations for the various kernels. Otherwise the different timer implementations could interfere with each other when using one build directory with multiple kernels. Note that this patch changes the include paths for the former os/timer, os/alarm.h, os/duration.h, and os/timed_semaphore.h to base/. Issue #3101
2019-01-03 18:01:49 +01:00
#endif /* _INCLUDE__BASE__ALARM_H_ */