ehmry/genode
ehmry
/
genode
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity
genode/repos/os/src/init/state_reporter.h

198 lines
5.1 KiB
C
Raw Normal View History

init: refactoring into multiple files This patch splits the implementation of init into several headers to make the implementation easier to digest and to maintain.
2017-03-03 16:57:41 +01:00
/*
* \brief Init-state reporting mechanism
* \author Norman Feske
* \date 2017-03-03
*/
/*
* Copyright (C) 2017 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.
*/
#ifndef _SRC__INIT__STATE_REPORTER_H_
#define _SRC__INIT__STATE_REPORTER_H_
init: service forwarding This patch equips init with the ability to act as a server that forwards session requests to its children. Session requests can be routed depending of the requested service type and the session label originating from init's parent. The feature is configured by one or multiple <service> nodes hosted in init's <config> node. The routing policy is selected by via the regular server-side policy-selection mechanism, for example: <config> ... <service name="LOG"> <policy label="noux"> <child name="terminal_log" label="important"/> </policy> <default-policy> <child name="nitlog"/> </default-policy> </service> ... </config> Each policy node must have a <child> sub node, which denotes name of the server with the 'name' attribute. The optional 'label' attribute defines the session label presented to the server, analogous to how the rewriting of session labels works in session routes. If not specified, the client-provided label is presented to the server as is. Fixes #2247
2017-03-08 10:21:49 +01:00
/* Genode includes */
init: refactoring into multiple files This patch splits the implementation of init into several headers to make the implementation easier to digest and to maintain.
2017-03-03 16:57:41 +01:00
#include <os/reporter.h>
#include <timer_session/connection.h>
init: service forwarding This patch equips init with the ability to act as a server that forwards session requests to its children. Session requests can be routed depending of the requested service type and the session label originating from init's parent. The feature is configured by one or multiple <service> nodes hosted in init's <config> node. The routing policy is selected by via the regular server-side policy-selection mechanism, for example: <config> ... <service name="LOG"> <policy label="noux"> <child name="terminal_log" label="important"/> </policy> <default-policy> <child name="nitlog"/> </default-policy> </service> ... </config> Each policy node must have a <child> sub node, which denotes name of the server with the 'name' attribute. The optional 'label' attribute defines the session label presented to the server, analogous to how the rewriting of session labels works in session routes. If not specified, the client-provided label is presented to the server as is. Fixes #2247
2017-03-08 10:21:49 +01:00
/* local includes */
init: make 'Server' class usable by external components Issue #2574
2017-11-13 16:25:37 +01:00
#include "report.h"
init: service forwarding This patch equips init with the ability to act as a server that forwards session requests to its children. Session requests can be routed depending of the requested service type and the session label originating from init's parent. The feature is configured by one or multiple <service> nodes hosted in init's <config> node. The routing policy is selected by via the regular server-side policy-selection mechanism, for example: <config> ... <service name="LOG"> <policy label="noux"> <child name="terminal_log" label="important"/> </policy> <default-policy> <child name="nitlog"/> </default-policy> </service> ... </config> Each policy node must have a <child> sub node, which denotes name of the server with the 'name' attribute. The optional 'label' attribute defines the session label presented to the server, analogous to how the rewriting of session labels works in session routes. If not specified, the client-provided label is presented to the server as is. Fixes #2247
2017-03-08 10:21:49 +01:00
init: refactoring into multiple files This patch splits the implementation of init into several headers to make the implementation easier to digest and to maintain.
2017-03-03 16:57:41 +01:00
namespace Init { class State_reporter; }
class Init::State_reporter : public Report_update_trigger
{
public:
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
struct Producer : Interface
init: refactoring into multiple files This patch splits the implementation of init into several headers to make the implementation easier to digest and to maintain.
2017-03-03 16:57:41 +01:00
{
virtual void produce_state_report(Xml_generator &xml,
Report_detail const &) const = 0;
};
private:
Env &_env;
Producer &_producer;
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
Constructible<Reporter> _reporter { };
init: refactoring into multiple files This patch splits the implementation of init into several headers to make the implementation easier to digest and to maintain.
2017-03-03 16:57:41 +01:00
size_t _buffer_size = 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
Reconstructible<Report_detail> _report_detail { };
init: refactoring into multiple files This patch splits the implementation of init into several headers to make the implementation easier to digest and to maintain.
2017-03-03 16:57:41 +01:00
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
uint64_t _report_delay_ms = 0;
init: refactoring into multiple files This patch splits the implementation of init into several headers to make the implementation easier to digest and to maintain.
2017-03-03 16:57:41 +01:00
init: limit rate of periodic reports by 'delay_ms' This is a follow-up patch to "init: periodic state updates if sensible". In situations where the report rate is deliberately limited via the 'delay_ms' attribute while also reporting child-resource stats, we don't want generate reports at a fixed rate of one second. This patch limits the rate according to the 'delay_ms' value.
2017-11-09 17:13:39 +01:00
/* interval used when child-ram reporting is enabled */
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
uint64_t _report_period_ms = 0;
init: limit rate of periodic reports by 'delay_ms' This is a follow-up patch to "init: periodic state updates if sensible". In situations where the report rate is deliberately limited via the 'delay_ms' attribute while also reporting child-resource stats, we don't want generate reports at a fixed rate of one second. This patch limits the rate according to the 'delay_ms' value.
2017-11-09 17:13:39 +01:00
init: refactoring into multiple files This patch splits the implementation of init into several headers to make the implementation easier to digest and to maintain.
2017-03-03 16:57:41 +01:00
/* version string from config, to be reflected in the report */
typedef String<64> Version;
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
Version _version { };
init: refactoring into multiple files This patch splits the implementation of init into several headers to make the implementation easier to digest and to maintain.
2017-03-03 16:57:41 +01: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
Constructible<Timer::Connection> _timer { };
Constructible<Timer::Connection> _timer_periodic { };
init: refactoring into multiple files This patch splits the implementation of init into several headers to make the implementation easier to digest and to maintain.
2017-03-03 16:57:41 +01:00
Signal_handler<State_reporter> _timer_handler {
_env.ep(), *this, &State_reporter::_handle_timer };
init: periodic state updates if sensible Under certain circumstances we don't want inits state report to become too outdated even if there is no change to its config or the sessions of its children. This is the case if init is requested to provide a capability or RAM info of it's children via its state report. Now, init automatically updates the state report with each 1000 ms if the attribute 'child_caps' or 'child_ram' is positively set in the 'report' tag.
2017-10-25 16:34:52 +02:00
Signal_handler<State_reporter> _timer_periodic_handler {
_env.ep(), *this, &State_reporter::_handle_timer };
init: reduce report latency for resource requests In contrast to most information of init's state reports, which can be monitored at a relatively low rate (like 2 seconds in Sculpt's runtime), resource requests call for an immediate response by the consumer of the report. Otherwise the requesting child stays unnecessarily blocked until the next rate-limited state report is due. This patch adds a fast lane for such low-latency state updates to init.
2018-06-01 13:55:07 +02:00
Signal_handler<State_reporter> _immediate_handler {
_env.ep(), *this, &State_reporter::_handle_timer };
init: refactoring into multiple files This patch splits the implementation of init into several headers to make the implementation easier to digest and to maintain.
2017-03-03 16:57:41 +01:00
bool _scheduled = false;
void _handle_timer()
{
_scheduled = false;
try {
Reporter::Xml_generator xml(*_reporter, [&] () {
if (_version.valid())
xml.attribute("version", _version);
_producer.produce_state_report(xml, *_report_detail);
});
}
catch(Xml_generator::Buffer_exceeded) {
error("state report exceeds maximum size");
/* try to reflect the error condition as state report */
try {
Reporter::Xml_generator xml(*_reporter, [&] () {
xml.attribute("error", "report buffer exceeded"); });
}
catch (...) { }
}
}
public:
State_reporter(Env &env, Producer &producer)
:
_env(env), _producer(producer)
{ }
void apply_config(Xml_node config)
{
try {
Xml_node report = config.sub_node("report");
/* (re-)construct reporter whenever the buffer size is changed */
Number_of_bytes const buffer_size =
report.attribute_value("buffer", Number_of_bytes(4096));
if (buffer_size != _buffer_size || !_reporter.constructed()) {
_buffer_size = buffer_size;
_reporter.construct(_env, "state", "state", _buffer_size);
}
_report_detail.construct(report);
_report_delay_ms = report.attribute_value("delay_ms", 100UL);
_reporter->enabled(true);
}
catch (Xml_node::Nonexistent_sub_node) {
_report_detail.construct();
_report_delay_ms = 0;
if (_reporter.constructed())
_reporter->enabled(false);
}
init: trigger report update on version change If the version attribute of init's <config> is changes, trigger the generation of a new state report that includes the information of the new version.
2017-03-16 11:32:28 +01:00
bool trigger_update = false;
init: refactoring into multiple files This patch splits the implementation of init into several headers to make the implementation easier to digest and to maintain.
2017-03-03 16:57:41 +01:00
init: trigger report update on version change If the version attribute of init's <config> is changes, trigger the generation of a new state report that includes the information of the new version.
2017-03-16 11:32:28 +01:00
Version const version = config.attribute_value("version", Version());
if (version != _version) {
_version = version;
trigger_update = true;
}
init: refactoring into multiple files This patch splits the implementation of init into several headers to make the implementation easier to digest and to maintain.
2017-03-03 16:57:41 +01:00
init: trigger report update on version change If the version attribute of init's <config> is changes, trigger the generation of a new state report that includes the information of the new version.
2017-03-16 11:32:28 +01:00
if (_report_delay_ms) {
init: refactoring into multiple files This patch splits the implementation of init into several headers to make the implementation easier to digest and to maintain.
2017-03-03 16:57:41 +01:00
if (!_timer.constructed()) {
_timer.construct(_env);
_timer->sigh(_timer_handler);
}
init: trigger report update on version change If the version attribute of init's <config> is changes, trigger the generation of a new state report that includes the information of the new version.
2017-03-16 11:32:28 +01:00
trigger_update = true;
}
init: refactoring into multiple files This patch splits the implementation of init into several headers to make the implementation easier to digest and to maintain.
2017-03-03 16:57:41 +01:00
init: trigger report update on version change If the version attribute of init's <config> is changes, trigger the generation of a new state report that includes the information of the new version.
2017-03-16 11:32:28 +01:00
if (trigger_update)
init: refactoring into multiple files This patch splits the implementation of init into several headers to make the implementation easier to digest and to maintain.
2017-03-03 16:57:41 +01:00
trigger_report_update();
init: periodic state updates if sensible Under certain circumstances we don't want inits state report to become too outdated even if there is no change to its config or the sessions of its children. This is the case if init is requested to provide a capability or RAM info of it's children via its state report. Now, init automatically updates the state report with each 1000 ms if the attribute 'child_caps' or 'child_ram' is positively set in the 'report' tag.
2017-10-25 16:34:52 +02:00
init: limit rate of periodic reports by 'delay_ms' This is a follow-up patch to "init: periodic state updates if sensible". In situations where the report rate is deliberately limited via the 'delay_ms' attribute while also reporting child-resource stats, we don't want generate reports at a fixed rate of one second. This patch limits the rate according to the 'delay_ms' value.
2017-11-09 17:13:39 +01:00
/*
* If the report features information about child-RAM quotas, we
* update the report periodically. Even in the absence of any other
* report-triggering event, a child may consume/free RAM from its
* RAM session without any interplay with init. The periodic
* reports ensure that such changes are reflected by init's state
* report.
*
* By default, the interval is one second. However, when the
* 'delay_ms' attribute is defined with a higher value than that,
* the user intends to limit the rate of state reports. If so, we
* use the value of 'delay_ms' as interval.
*/
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
uint64_t const period_ms = max(1000U, _report_delay_ms);
init: limit rate of periodic reports by 'delay_ms' This is a follow-up patch to "init: periodic state updates if sensible". In situations where the report rate is deliberately limited via the 'delay_ms' attribute while also reporting child-resource stats, we don't want generate reports at a fixed rate of one second. This patch limits the rate according to the 'delay_ms' value.
2017-11-09 17:13:39 +01:00
bool const period_changed = (_report_period_ms != period_ms);
bool const report_periodically = _report_detail->child_ram()
|| _report_detail->child_caps();
if (report_periodically && !_timer_periodic.constructed()) {
_timer_periodic.construct(_env);
_timer_periodic->sigh(_timer_periodic_handler);
}
if (!report_periodically && _timer_periodic.constructed()) {
_report_period_ms = 0;
_timer_periodic.destruct();
}
if (period_changed && _timer_periodic.constructed()) {
_report_period_ms = period_ms;
_timer_periodic->trigger_periodic(1000*_report_period_ms);
init: periodic state updates if sensible Under certain circumstances we don't want inits state report to become too outdated even if there is no change to its config or the sessions of its children. This is the case if init is requested to provide a capability or RAM info of it's children via its state report. Now, init automatically updates the state report with each 1000 ms if the attribute 'child_caps' or 'child_ram' is positively set in the 'report' tag.
2017-10-25 16:34:52 +02:00
}
init: refactoring into multiple files This patch splits the implementation of init into several headers to make the implementation easier to digest and to maintain.
2017-03-03 16:57:41 +01:00
}
void trigger_report_update() override
{
if (!_scheduled && _timer.constructed() && _report_delay_ms) {
_timer->trigger_once(_report_delay_ms*1000);
_scheduled = true;
}
}
init: reduce report latency for resource requests In contrast to most information of init's state reports, which can be monitored at a relatively low rate (like 2 seconds in Sculpt's runtime), resource requests call for an immediate response by the consumer of the report. Otherwise the requesting child stays unnecessarily blocked until the next rate-limited state report is due. This patch adds a fast lane for such low-latency state updates to init.
2018-06-01 13:55:07 +02:00
void trigger_immediate_report_update() override
{
if (_report_delay_ms)
Signal_transmitter(_immediate_handler).submit();
}
init: refactoring into multiple files This patch splits the implementation of init into several headers to make the implementation easier to digest and to maintain.
2017-03-03 16:57:41 +01:00
};
#endif /* _SRC__INIT__STATE_REPORTER_H_ */