ExternalVendorCode/genode
1
0
Fork 0
mirror of https://github.com/genodelabs/genode.git synced 2025-06-18 07:08:18 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

Adapt high-level components to new parent API

Browse Source 
This patch adjusts the various users of the 'Child' API to the changes
on the account of the new non-blocking parent interface. It also removes
the use of the no-longer-available 'Connection::KEEP_OPEN' feature.

With the adjustment, we took the opportunity to redesign several
components to fit the non-blocking execution model much better, in
particular the demo applications.

Issue #2120
This commit is contained in:
Norman Feske
2016-11-23 17:07:49 +01:00
committed by Christian Helmuth
parent 8bafb9d41b
commit b44f0554bd
146 changed files with 3026 additions and 3484 deletions
Download Patch File Download Diff File Expand all files Collapse all files

5
repos/gems/src/app/launcher/context_dialog.h
View File

@ -105,12 +105,11 @@ class Launcher::Context_dialog : Input_event_handler, Dialog_generator,
public:
Context_dialog(Server::Entrypoint &ep, Cap_session &cap, Ram_session &ram,
Dataspace_capability ldso_ds,
Context_dialog(Env &env,
Report_rom_slave &report_rom_slave,
Response_handler &response_handler)
:
_dialog(ep, cap, ram, ldso_ds, report_rom_slave,
_dialog(env, report_rom_slave,
"context_dialog", "context_hover",
*this, *this, *this, *this,
Fading_dialog::Position(364, 64)),

34
repos/gems/src/app/launcher/dialog_nitpicker.h
View File

@ -20,6 +20,7 @@
/* Genode includes */
#include <util/string.h>
#include <base/entrypoint.h>
#include <os/attached_dataspace.h>
#include <nitpicker_session/nitpicker_session.h>
#include <input_session/client.h>
@ -54,7 +55,7 @@ struct Launcher::Dialog_nitpicker_session : Wrapped_nitpicker_session
Input_event_handler &_input_event_handler;
Server::Entrypoint &_ep;
Rpc_entrypoint &_session_ep;
Nitpicker::Session &_nitpicker_session;
@ -62,36 +63,43 @@ struct Launcher::Dialog_nitpicker_session : Wrapped_nitpicker_session
Attached_dataspace _nitpicker_input_ds { _nitpicker_input.dataspace() };
Signal_rpc_member<Dialog_nitpicker_session>
_input_dispatcher { _ep, *this, &Dialog_nitpicker_session::_input_handler };
Signal_handler<Dialog_nitpicker_session> _input_handler;
Input::Session_component _input_session;
Capability<Input::Session> _input_session_cap { _ep.manage(_input_session) };
/**
* Constructor
*
* \param input_sigh_ep entrypoint where the input signal handler is
* installed ('env.ep')
* \param service_ep entrypoint providing the nitpicker session
* (slave-specific ep)
*/
Dialog_nitpicker_session(Nitpicker::Session &nitpicker_session,
Server::Entrypoint &ep,
Dialog_nitpicker_session(Nitpicker::Session &nitpicker_session,
Entrypoint &input_sigh_ep,
Rpc_entrypoint &session_ep,
Input_event_handler &input_event_handler)
:
Wrapped_nitpicker_session(nitpicker_session),
_input_event_handler(input_event_handler),
_ep(ep),
_nitpicker_session(nitpicker_session)
_session_ep(session_ep),
_nitpicker_session(nitpicker_session),
_input_handler(input_sigh_ep, *this, &Dialog_nitpicker_session::_handle_input)
{
_nitpicker_input.sigh(_input_dispatcher);
_session_ep.manage(this);
_session_ep.manage(&_input_session);
_nitpicker_input.sigh(_input_handler);
_input_session.event_queue().enabled(true);
}
~Dialog_nitpicker_session()
{
_ep.dissolve(_input_session);
_session_ep.dissolve(&_input_session);
_session_ep.dissolve(this);
}
void _input_handler(unsigned)
void _handle_input()
{
Input::Event const * const events =
_nitpicker_input_ds.local_addr<Input::Event>();
@ -116,7 +124,7 @@ struct Launcher::Dialog_nitpicker_session : Wrapped_nitpicker_session
Input::Session_capability input_session() override
{
return _input_session_cap;
return _input_session.cap();
}
};

131
repos/gems/src/app/launcher/fading_dialog.h
View File

@ -54,17 +54,17 @@ class Launcher::Fading_dialog : private Input_event_handler
{
private:
Rom_session_capability _dialog_rom;
Slave::Connection<Rom_connection> _dialog_rom;
/* dialog reported locally */
Capability<Report::Session> _dialog_report;
Slave::Connection<Report::Connection> _dialog_report;
Rom_session_client _hover_rom;
Slave::Connection<Rom_connection> _hover_rom;
Lazy_volatile_object<Attached_dataspace> _hover_ds;
/* hovered element reported by menu view */
Capability<Report::Session> _hover_report;
Slave::Connection<Report::Connection> _hover_report;
Local_reporter _dialog_reporter { "dialog", _dialog_report };
@ -100,7 +100,7 @@ class Launcher::Fading_dialog : private Input_event_handler
return forward_event;
}
void _handle_hover_update(unsigned)
void _handle_hover_update()
{
try {
if (!_hover_ds.constructed() || _hover_rom.update() == false) {
@ -129,52 +129,10 @@ class Launcher::Fading_dialog : private Input_event_handler
}
}
Signal_rpc_member<Fading_dialog> _hover_update_dispatcher;
Signal_handler<Fading_dialog> _hover_update_handler;
private:
/**
* Local nitpicker service to be handed out to the menu view slave
*/
struct Nitpicker_service : Genode::Service
{
Server::Entrypoint &ep;
Rpc_entrypoint &child_ep;
/* connection to real nitpicker */
Nitpicker::Connection connection { "menu" };
Dialog_nitpicker_session wrapper_session;
Capability<Nitpicker::Session> session_cap { child_ep.manage(&wrapper_session) };
Nitpicker_service(Server::Entrypoint &ep,
Rpc_entrypoint &child_ep,
Dialog_nitpicker_session::Input_event_handler &ev_handler)
:
Genode::Service(Nitpicker::Session::service_name()),
ep(ep), child_ep(child_ep),
wrapper_session(connection, ep, ev_handler)
{ }
/*******************************
** Genode::Service interface **
*******************************/
Genode::Session_capability
session(const char *, Genode::Affinity const &) override
{
return session_cap;
}
void upgrade(Genode::Session_capability, const char *args) override
{
Genode::log("upgrade called args: '", args, "'");
}
void close(Genode::Session_capability) override { }
};
/*
* Entrypoint for the fader slave
*
@ -188,9 +146,21 @@ class Launcher::Fading_dialog : private Input_event_handler
size_t const _fader_slave_ep_stack_size = 4*1024*sizeof(addr_t);
Rpc_entrypoint _fader_slave_ep;
Nitpicker_service _nitpicker_service;
Nit_fader_slave _nit_fader_slave;
Menu_view_slave _menu_view_slave;
/*
* Provide wrapped nitpicker connection as a service handed out to
* the menu-view slave
*/
typedef Genode::Local_service<Dialog_nitpicker_session> Nitpicker_service;
typedef Nitpicker_service::Single_session_factory Nitpicker_factory;
Nitpicker::Connection _nitpicker_connection;
Dialog_nitpicker_session _nitpicker_session;
Nitpicker_factory _nitpicker_factory { _nitpicker_session };
Nitpicker_service _nitpicker_service { _nitpicker_factory };
Nit_fader_slave _nit_fader_slave;
Slave::Connection<Nitpicker::Connection> _nit_fader_connection;
Menu_view_slave _menu_view_slave;
bool _visible = false;
@ -198,47 +168,38 @@ class Launcher::Fading_dialog : private Input_event_handler
typedef Menu_view_slave::Position Position;
/**
* Constructor
*
* \param ep main entrypoint, used for managing the local input
* session provided (indirectly through the wrapped
* nitpicker session) to the menu view
* \param cap capability session to be used for creating the
* slave entrypoints
* \param ram RAM session where to draw the memory for providing
* configuration data to the slave processes
*/
Fading_dialog(Server::Entrypoint &ep,
Cap_session &cap,
Ram_session &ram,
Dataspace_capability ldso_ds,
Report_rom_slave &report_rom_slave,
char const *dialog_name,
char const *hover_name,
Input_event_handler &input_event_handler,
Hover_handler &hover_handler,
Dialog_generator &dialog_generator,
Dialog_model &dialog_model,
Position initial_position)
Fading_dialog(Env &env,
Report_rom_slave &report_rom_slave,
char const *dialog_name,
char const *hover_name,
Input_event_handler &input_event_handler,
Hover_handler &hover_handler,
Dialog_generator &dialog_generator,
Dialog_model &dialog_model,
Position initial_position)
:
_dialog_rom(report_rom_slave.rom_session(dialog_name)),
_dialog_report(report_rom_slave.report_session(dialog_name)),
_hover_rom(report_rom_slave.rom_session(hover_name)),
_hover_report(report_rom_slave.report_session(hover_name)),
_dialog_rom(report_rom_slave.policy(), Slave::Args("label=", dialog_name)),
_dialog_report(report_rom_slave.policy(),
Slave::Args("label=", dialog_name, ", buffer_size=4096")),
_hover_rom(report_rom_slave.policy(), Slave::Args("label=", hover_name)),
_hover_report(report_rom_slave.policy(),
Slave::Args("label=", hover_name, ", buffer_size=4096")),
_dialog_input_event_handler(input_event_handler),
_hover_handler(hover_handler),
_dialog_generator(dialog_generator),
_dialog_model(dialog_model),
_hover_update_dispatcher(ep, *this, &Fading_dialog::_handle_hover_update),
_fader_slave_ep(&cap, _fader_slave_ep_stack_size, "nit_fader"),
_nitpicker_service(ep, _fader_slave_ep, *this),
_nit_fader_slave(_fader_slave_ep, ram, _nitpicker_service, ldso_ds),
_menu_view_slave(cap, ram, ldso_ds,
_nit_fader_slave.nitpicker_session("menu"),
_hover_update_handler(env.ep(), *this, &Fading_dialog::_handle_hover_update),
_fader_slave_ep(&env.pd(), _fader_slave_ep_stack_size, "nit_fader"),
_nitpicker_connection(env, "menu"),
_nitpicker_session(_nitpicker_connection, env.ep(), _fader_slave_ep, *this),
_nit_fader_slave(_fader_slave_ep, env.rm(), env.ram_session_cap(),
_nitpicker_service),
_nit_fader_connection(_nit_fader_slave.policy(), Slave::Args("label=menu")),
_menu_view_slave(env.pd(), env.rm(), env.ram_session_cap(),
_nit_fader_connection,
_dialog_rom, _hover_report, initial_position)
{
Rom_session_client(_hover_rom).sigh(_hover_update_dispatcher);
Rom_session_client(_hover_rom).sigh(_hover_update_handler);
}
void update()

117
repos/gems/src/app/launcher/main.cc
View File

@ -12,9 +12,7 @@
*/
/* Genode includes */
#include <os/server.h>
#include <os/config.h>
#include <cap_session/connection.h>
#include <base/component.h>
#include <decorator/xml_utils.h>
#include <util/volatile_object.h>
#include <os/attached_rom_dataspace.h>
@ -23,25 +21,16 @@
/* local includes */
#include <panel_dialog.h>
namespace Launcher {
using namespace Genode;
struct Main;
}
namespace Launcher { struct Main; }
struct Launcher::Main
{
Server::Entrypoint &_ep;
Genode::Dataspace_capability _request_ldso_ds()
{
try {
static Genode::Rom_connection rom("ld.lib.so");
return rom.dataspace();
} catch (...) { }
return Genode::Dataspace_capability();
}
Genode::Dataspace_capability _ldso_ds = _request_ldso_ds();
Genode::Cap_connection _cap;
Env &_env;
char const *_report_rom_config =
"<config>"
@ -53,35 +42,54 @@ struct Launcher::Main
" <policy label=\"context_hover\" report=\"context_hover\"/>"
"</config>";
Report_rom_slave _report_rom_slave = { _cap, *env()->ram_session(), _report_rom_config };
Report_rom_slave _report_rom_slave {
_env.pd(), _env.rm(), _env.ram_session_cap(), _report_rom_config };
/**
* Nitpicker session used to perform session-control operations on the
* subsystem's nitpicker sessions and to receive global keyboard
* shortcuts.
*/
Nitpicker::Connection _nitpicker;
Nitpicker::Connection _nitpicker { _env };
Genode::Signal_rpc_member<Main> _input_dispatcher =
{ _ep, *this, &Main::_handle_input };
Signal_handler<Main> _input_handler =
{ _env.ep(), *this, &Main::_handle_input };
void _handle_input(unsigned);
void _handle_input();
unsigned _key_cnt = 0;
Genode::Signal_rpc_member<Main> _exited_child_dispatcher =
{ _ep, *this, &Main::_handle_exited_child };
Signal_handler<Main> _exited_child_handler =
{ _env.ep(), *this, &Main::_handle_exited_child };
Subsystem_manager _subsystem_manager { _ep, _cap, _exited_child_dispatcher,
_ldso_ds };
Attached_rom_dataspace _config { _env, "config" };
Panel_dialog _panel_dialog { _ep, _cap, *env()->ram_session(), _ldso_ds,
*env()->heap(),
_report_rom_slave, _subsystem_manager, _nitpicker };
static size_t _ram_preservation(Xml_node config)
{
char const * const node_name = "preservation";
void _handle_config(unsigned);
if (config.has_sub_node(node_name)) {
void _handle_exited_child(unsigned)
Xml_node const node = config.sub_node(node_name);
if (node.attribute_value("name", Genode::String<16>()) == "RAM")
return node.attribute_value("quantum", Genode::Number_of_bytes());
}
return 0;
}
Subsystem_manager _subsystem_manager { _env.ep(), _env.pd(),
_ram_preservation(_config.xml()),
_exited_child_handler };
Heap _heap { _env.ram(), _env.rm() };
Panel_dialog _panel_dialog { _env, _heap, _report_rom_slave,
_subsystem_manager, _nitpicker };
void _handle_config();
void _handle_exited_child()
{
auto kill_child_fn = [&] (Label const &label) { _panel_dialog.kill(label); };
@ -92,37 +100,40 @@ struct Launcher::Main
Genode::Attached_rom_dataspace _focus_rom { "focus" };
void _handle_focus_update(unsigned);
void _handle_focus_update();
Genode::Signal_rpc_member<Main> _focus_update_dispatcher =
{ _ep, *this, &Main::_handle_focus_update };
Signal_handler<Main> _focus_update_handler =
{ _env.ep(), *this, &Main::_handle_focus_update };
/**
* Constructor
*/
Main(Server::Entrypoint &ep) : _ep(ep)
Main(Env &env) : _env(env)
{
_nitpicker.input()->sigh(_input_dispatcher);
_focus_rom.sigh(_focus_update_dispatcher);
_nitpicker.input()->sigh(_input_handler);
_focus_rom.sigh(_focus_update_handler);
_handle_config(0);
_handle_config();
_panel_dialog.visible(true);
}
};
void Launcher::Main::_handle_config(unsigned)
void Launcher::Main::_handle_config()
{
config()->reload();
_config.update();
_focus_prefix = config()->xml_node().attribute_value("focus_prefix", Label());
_focus_prefix = _config.xml().attribute_value("focus_prefix", Label());
_panel_dialog.update(config()->xml_node());
try {
_panel_dialog.update(_config.xml()); }
catch (Allocator::Out_of_memory) {
error("out of memory while applying configuration"); }
}
void Launcher::Main::_handle_input(unsigned)
void Launcher::Main::_handle_input()
{
_nitpicker.input()->for_each_event([&] (Input::Event const &e) {
if (e.type() == Input::Event::PRESS) _key_cnt++;
@ -143,7 +154,7 @@ void Launcher::Main::_handle_input(unsigned)
}
void Launcher::Main::_handle_focus_update(unsigned)
void Launcher::Main::_handle_focus_update()
{
try {
_focus_rom.update();
@ -176,18 +187,4 @@ void Launcher::Main::_handle_focus_update(unsigned)
}
/************
** Server **
************/
namespace Server {
char const *name() { return "desktop_ep"; }
size_t stack_size() { return 4*1024*sizeof(long); }
void construct(Entrypoint &ep)
{
static Launcher::Main desktop(ep);
}
}
void Component::construct(Genode::Env &env) { static Launcher::Main main(env); }

12
repos/gems/src/app/launcher/menu_dialog.h
View File

@ -103,18 +103,14 @@ class Launcher::Menu_dialog : Input_event_handler, Dialog_generator,
public:
Menu_dialog(Server::Entrypoint &ep, Cap_session &cap, Ram_session &ram,
Dataspace_capability ldso_ds,
Menu_dialog(Env &env,
Report_rom_slave &report_rom_slave,
Response_handler &response_handler)
:
_response_handler(response_handler),
_dialog(ep, cap, ram, ldso_ds, report_rom_slave,
"menu_dialog", "menu_hover",
*this, *this, *this, *this,
_position)
{
}
_dialog(env, report_rom_slave, "menu_dialog", "menu_hover",
*this, *this, *this, *this, _position)
{ }
/**
* Dialog_generator interface

85
repos/gems/src/app/launcher/menu_view_slave.h
View File

@ -19,7 +19,7 @@
#include <nitpicker_session/nitpicker_session.h>
/* gems includes */
#include <gems/single_session_service.h>
#include <os/single_session_service.h>
/* local includes */
#include <types.h>
@ -35,16 +35,13 @@ class Launcher::Menu_view_slave
private:
class Policy : public Genode::Slave_policy
class Policy : public Genode::Slave::Policy
{
private:
Lock mutable _nitpicker_root_lock { Lock::LOCKED };
Capability<Root> _nitpicker_root_cap;
Single_session_service _nitpicker_service;
Single_session_service _dialog_rom_service;
Single_session_service _hover_report_service;
Genode::Single_session_service<Nitpicker::Session> _nitpicker;
Genode::Single_session_service<Genode::Rom_session> _dialog_rom;
Genode::Single_session_service<Report::Session> _hover_report;
Position _position;
@ -53,7 +50,7 @@ class Launcher::Menu_view_slave
char const **_permitted_services() const
{
static char const *permitted_services[] = {
"ROM", "LOG", "RM", "Timer", 0 };
"CPU", "PD", "RAM", "ROM", "LOG", "Timer", 0 };
return permitted_services;
};
@ -78,82 +75,70 @@ class Launcher::Menu_view_slave
configure(config);
}
static Name _name() { return "menu_view"; }
static Genode::size_t _quota() { return 6*1024*1024; }
public:
Policy(Genode::Rpc_entrypoint &entrypoint,
Genode::Ram_session &ram,
Policy(Genode::Rpc_entrypoint &ep,
Genode::Region_map &rm,
Genode::Ram_session_capability ram,
Capability<Nitpicker::Session> nitpicker_session,
Capability<Rom_session> dialog_rom_session,
Capability<Report::Session> hover_report_session,
Position position)
:
Slave_policy("menu_view", entrypoint, &ram),
_nitpicker_service(Nitpicker::Session::service_name(), nitpicker_session),
_dialog_rom_service(Rom_session::service_name(), dialog_rom_session),
_hover_report_service(Report::Session::service_name(), hover_report_session),
Genode::Slave::Policy(_name(), _name(), ep, rm, ram, _quota()),
_nitpicker(nitpicker_session),
_dialog_rom(dialog_rom_session),
_hover_report(hover_report_session),
_position(position)
{
_configure(position);
}
void position(Position pos)
void position(Position pos) { _configure(pos); }
Genode::Service &resolve_session_request(Genode::Service::Name const &service,
Genode::Session_state::Args const &args) override
{
_configure(pos);
}
if (service == "Nitpicker")
return _nitpicker.service();
Genode::Service *resolve_session_request(const char *service_name,
const char *args) override
{
using Genode::strcmp;
Genode::Session_label const label(label_from_args(args.string()));
if (strcmp(service_name, "Nitpicker") == 0)
return &_nitpicker_service;
if ((service == "ROM") && (label == "menu_view -> dialog"))
return _dialog_rom.service();
char label[128];
Arg_string::find_arg(args, "label").string(label, sizeof(label), "");
if ((service == "Report") && (label == "menu_view -> hover"))
return _hover_report.service();
if (strcmp(service_name, "ROM") == 0) {
if (strcmp(label, "menu_view -> dialog") == 0)
return &_dialog_rom_service;
}
if (strcmp(service_name, "Report") == 0) {
if (strcmp(label, "menu_view -> hover") == 0)
return &_hover_report_service;
}
return Genode::Slave_policy::resolve_session_request(service_name, args);
return Genode::Slave::Policy::resolve_session_request(service, args);
}
};
Genode::size_t const _ep_stack_size = 4*1024*sizeof(Genode::addr_t);
Genode::Rpc_entrypoint _ep;
Policy _policy;
Genode::size_t const _quota = 6*1024*1024;
Genode::Slave _slave;
Genode::Child _child;
public:
/**
* Constructor
*
* \param ep entrypoint used for child thread
* \param ram RAM session used to allocate the configuration
* dataspace
*/
Menu_view_slave(Genode::Cap_session &cap, Genode::Ram_session &ram,
Genode::Dataspace_capability ldso_ds,
Menu_view_slave(Genode::Pd_session &pd,
Genode::Region_map &rm,
Genode::Ram_session_capability ram,
Capability<Nitpicker::Session> nitpicker_session,
Capability<Rom_session> dialog_rom_session,
Capability<Report::Session> hover_report_session,
Position initial_position)
:
_ep(&cap, _ep_stack_size, "nit_fader"),
_policy(_ep, ram, nitpicker_session, dialog_rom_session,
_ep(&pd, _ep_stack_size, "nit_fader"),
_policy(_ep, rm, ram, nitpicker_session, dialog_rom_session,
hover_report_session, initial_position),
_slave(_ep, _policy, _quota, env()->ram_session_cap(), ldso_ds)
_child(rm, _ep, _policy)
{ }
void position(Position position) { _policy.position(position); }

90
repos/gems/src/app/launcher/nit_fader_slave.h
View File

@ -28,31 +28,33 @@ class Launcher::Nit_fader_slave
{
private:
class Policy : public Slave_policy
class Policy : public Slave::Policy
{
private:
Genode::Service &_nitpicker_service;
Lock mutable _nitpicker_root_lock { Lock::LOCKED };
Capability<Root> _nitpicker_root_cap;
protected:
char const **_permitted_services() const
{
static char const *permitted_services[] = {
"LOG", "RM", "Timer", 0 };
"RAM", "CPU", "PD", "LOG", "Timer", 0 };
return permitted_services;
};
static Name _name() { return "nit_fader"; }
static size_t _quota() { return 2*1024*1024; }
public:
Policy(Rpc_entrypoint &entrypoint,
Ram_session &ram,
Genode::Service &nitpicker_service)
Policy(Rpc_entrypoint &ep,
Region_map &rm,
Ram_session_capability ram,
Genode::Service &nitpicker_service)
:
Slave_policy("nit_fader", entrypoint, &ram),
Genode::Slave::Policy(_name(), _name(), ep, rm, ram, _quota()),
_nitpicker_service(nitpicker_service)
{
visible(false);
@ -66,42 +68,18 @@ class Launcher::Nit_fader_slave
configure(config, strlen(config) + 1);
}
bool announce_service(const char *service_name,
Root_capability root,
Allocator *,
Genode::Server *)
Genode::Service &resolve_session_request(Genode::Service::Name const &service,
Genode::Session_state::Args const &args) override
{
if (strcmp(service_name, "Nitpicker") == 0)
_nitpicker_root_cap = root;
else
return false;
if (service == Nitpicker::Session::service_name())
return _nitpicker_service;
if (_nitpicker_root_cap.valid())
_nitpicker_root_lock.unlock();
return true;
}
Genode::Service *resolve_session_request(const char *service_name,
const char *args) override
{
if (Genode::strcmp(service_name, "Nitpicker") == 0)
return &_nitpicker_service;
return Genode::Slave_policy::resolve_session_request(service_name, args);
}
Root_capability nitpicker_root() const
{
Lock::Guard guard(_nitpicker_root_lock);
return _nitpicker_root_cap;
return Genode::Slave::Policy::resolve_session_request(service, args);
}
};
Policy _policy;
size_t const _quota = 2*1024*1024;
Slave _slave;
Root_client _nitpicker_root;
Policy _policy;
Child _child;
public:
@ -112,38 +90,18 @@ class Launcher::Nit_fader_slave
* \param ram RAM session used to allocate the configuration
* dataspace
*/
Nit_fader_slave(Rpc_entrypoint &ep, Ram_session &ram,
Genode::Service &nitpicker_service,
Genode::Dataspace_capability ldso_ds)
Nit_fader_slave(Rpc_entrypoint &ep,
Genode::Region_map &rm,
Ram_session_capability ram,
Genode::Service &nitpicker_service)
:
_policy(ep, ram, nitpicker_service),
_slave(ep, _policy, _quota, env()->ram_session_cap(), ldso_ds),
_nitpicker_root(_policy.nitpicker_root())
_policy(ep, rm, ram, nitpicker_service),
_child(rm, ep, _policy)
{
visible(false);
}
Capability<Nitpicker::Session> nitpicker_session(char const *label)
{
enum { ARGBUF_SIZE = 128 };
char argbuf[ARGBUF_SIZE];
argbuf[0] = 0;
/*
* Declare ram-quota donation
*/
enum { SESSION_METADATA = 8*1024 };
Arg_string::set_arg(argbuf, sizeof(argbuf), "ram_quota", SESSION_METADATA);
/*
* Set session label
*/
Arg_string::set_arg_string(argbuf, sizeof(argbuf), "label", label);
Session_capability session_cap = _nitpicker_root.session(argbuf, Affinity());
return static_cap_cast<Nitpicker::Session>(session_cap);
}
Genode::Slave::Policy &policy() { return _policy; }
void visible(bool visible)
{

76
repos/gems/src/app/launcher/panel_dialog.h
View File

@ -50,6 +50,39 @@ class Launcher::Panel_dialog : Input_event_handler, Dialog_generator,
Genode::Allocator &_alloc;
struct Buffered_xml
{
Allocator &_alloc;
char const * const _ptr; /* pointer to dynamically allocated buffer */
Xml_node const _xml; /* referring to buffer of '_ptr' */
/**
* \throw Allocator::Out_of_memory
*/
static char const *_init_ptr(Allocator &alloc, Xml_node node)
{
char *ptr = (char *)alloc.alloc(node.size());
Genode::memcpy(ptr, node.addr(), node.size());
return ptr;
}
/**
* Constructor
*
* \throw Allocator::Out_of_memory
*/
Buffered_xml(Allocator &alloc, Xml_node node)
:
_alloc(alloc), _ptr(_init_ptr(alloc, node)), _xml(_ptr, node.size())
{ }
~Buffered_xml() { _alloc.free(const_cast<char *>(_ptr), _xml.size()); }
Xml_node xml() const { return _xml; }
};
Lazy_volatile_object<Buffered_xml> _config;
List<Element> _elements;
Label _focus;
@ -135,7 +168,7 @@ class Launcher::Panel_dialog : Input_event_handler, Dialog_generator,
Element *_clicked = nullptr;
bool _click_in_progress = false;
Signal_rpc_member<Panel_dialog> _timer_dispatcher;
Signal_handler<Panel_dialog> _timer_handler;
Label _context_subsystem;
Context_dialog _context_dialog;
@ -165,9 +198,13 @@ class Launcher::Panel_dialog : Input_event_handler, Dialog_generator,
void _start(Label const &label)
{
if (!_config.constructed()) {
warning("attempt to start subsystem without prior configuration");
return;
}
try {
Xml_node subsystem = _subsystem(config()->xml_node(),
label.string());
Xml_node subsystem = _subsystem(_config->xml(), label.string());
_subsystem_manager.start(subsystem);
Title const title = subsystem.attribute_value("title", Title());
@ -232,7 +269,7 @@ class Launcher::Panel_dialog : Input_event_handler, Dialog_generator,
_context_dialog.visible(true);
}
void _handle_timer(unsigned)
void _handle_timer()
{
if (_click_in_progress && _clicked && _hovered() == _clicked) {
_open_context_dialog(_clicked->label);
@ -250,26 +287,23 @@ class Launcher::Panel_dialog : Input_event_handler, Dialog_generator,
public:
Panel_dialog(Server::Entrypoint &ep, Cap_session &cap, Ram_session &ram,
Dataspace_capability ldso_ds,
Genode::Allocator &alloc,
Report_rom_slave &report_rom_slave,
Subsystem_manager &subsystem_manager,
Panel_dialog(Env &env,
Genode::Allocator &alloc,
Report_rom_slave &report_rom_slave,
Subsystem_manager &subsystem_manager,
Nitpicker::Session &nitpicker)
:
_alloc(alloc),
_subsystem_manager(subsystem_manager),
_nitpicker(nitpicker),
_dialog(ep, cap, ram, ldso_ds, report_rom_slave,
"panel_dialog", "panel_hover",
*this, *this, *this, *this,
_position),
_timer_dispatcher(ep, *this, &Panel_dialog::_handle_timer),
_context_dialog(ep, cap, ram, ldso_ds, report_rom_slave, *this),
_menu_dialog(ep, cap, ram, ldso_ds, report_rom_slave, *this)
_dialog(env, report_rom_slave, "panel_dialog", "panel_hover",
*this, *this, *this, *this, _position),
_timer_handler(env.ep(), *this, &Panel_dialog::_handle_timer),
_context_dialog(env, report_rom_slave, *this),
_menu_dialog(env, report_rom_slave, *this)
{
_elements.insert(&_menu_button);
_timer.sigh(_timer_dispatcher);
_timer.sigh(_timer_handler);
}
/**
@ -514,13 +548,17 @@ class Launcher::Panel_dialog : Input_event_handler, Dialog_generator,
_kill(label);
}
/**
* \throw Allocator::Out_of_memory
*/
void update(Xml_node config)
{
_config.construct(_alloc, config);
/* populate menu dialog with one item per subsystem */
_menu_dialog.update(config);
_menu_dialog.update(_config->xml());
/* evaluate configuration */
_dialog.update();
}

94
repos/gems/src/app/launcher/subsystem_manager.h
View File

@ -25,28 +25,7 @@ namespace Launcher {
class Subsystem_manager;
using Decorator::string_attribute;
}
/***************
** Utilities **
***************/
/*
* XXX copied from 'cli_monitor/main.cc'
*/
static Genode::size_t ram_preservation_from_config()
{
Genode::Number_of_bytes ram_preservation = 0;
try {
Genode::Xml_node node =
Genode::config()->xml_node().sub_node("preservation");
if (node.attribute("name").has_value("RAM"))
node.attribute("quantum").value(&ram_preservation);
} catch (...) { }
return ram_preservation;
using namespace Genode;
}
@ -61,34 +40,15 @@ class Launcher::Subsystem_manager
private:
Server::Entrypoint &_ep;
Cap_session &_cap;
Dataspace_capability _ldso_ds;
Entrypoint &_ep;
Pd_session &_pd;
size_t const _ram_preservation;
struct Child : Child_base, List<Child>::Element
{
typedef String<128> Binary_name;
Child(Ram &ram,
Label const &label,
Binary_name const &binary,
Cap_session &cap_session,
size_t ram_quota,
size_t ram_limit,
Signal_context_capability yield_response_sig_cap,
Signal_context_capability exit_sig_cap,
Dataspace_capability ldso_ds)
:
Child_base(ram,
label.string(),
binary.string(),
cap_session,
ram_quota,
ram_limit,
yield_response_sig_cap,
exit_sig_cap,
ldso_ds)
{ }
template <typename... ARGS>
Child(ARGS &&... args) : Child_base(args...) { }
};
List<Child> _children;
@ -99,10 +59,10 @@ class Launcher::Subsystem_manager
child->try_response_to_resource_request();
}
Genode::Signal_rpc_member<Subsystem_manager> _yield_broadcast_dispatcher =
Signal_handler<Subsystem_manager> _yield_broadcast_handler =
{ _ep, *this, &Subsystem_manager::_handle_yield_broadcast };
void _handle_yield_broadcast(unsigned)
void _handle_yield_broadcast()
{
_try_response_to_resource_request();
@ -129,27 +89,27 @@ class Launcher::Subsystem_manager
child->yield(amount, true);
}
Genode::Signal_rpc_member<Subsystem_manager> _resource_avail_dispatcher =
Signal_handler<Subsystem_manager> _resource_avail_handler =
{ _ep, *this, &Subsystem_manager::_handle_resource_avail };
void _handle_resource_avail(unsigned)
void _handle_resource_avail()
{
_try_response_to_resource_request();
}
Genode::Signal_rpc_member<Subsystem_manager> _yield_response_dispatcher =
Signal_handler<Subsystem_manager> _yield_response_handler =
{ _ep, *this, &Subsystem_manager::_handle_yield_response };
void _handle_yield_response(unsigned)
void _handle_yield_response()
{
_try_response_to_resource_request();
}
Genode::Signal_context_capability _exited_child_sig_cap;
Ram _ram { ram_preservation_from_config(),
_yield_broadcast_dispatcher,
_resource_avail_dispatcher };
Ram _ram { _ram_preservation,
_yield_broadcast_handler,
_resource_avail_handler };
static Child::Binary_name _binary_name(Xml_node subsystem)
{
@ -187,11 +147,11 @@ class Launcher::Subsystem_manager
public:
Subsystem_manager(Server::Entrypoint &ep, Cap_session &cap,
Genode::Signal_context_capability exited_child_sig_cap,
Dataspace_capability ldso_ds)
Subsystem_manager(Genode::Entrypoint &ep, Pd_session &pd,
size_t ram_preservation,
Genode::Signal_context_capability exited_child_sig_cap)
:
_ep(ep), _cap(cap), _ldso_ds(ldso_ds),
_ep(ep), _pd(pd), _ram_preservation(ram_preservation),
_exited_child_sig_cap(exited_child_sig_cap)
{ }
@ -213,10 +173,14 @@ class Launcher::Subsystem_manager
try {
Child *child = new (env()->heap())
Child(_ram, label, binary_name.string(), _cap,
Child(_ram, label, binary_name.string(),
*Genode::env()->pd_session(),
*Genode::env()->ram_session(),
Genode::env()->ram_session_cap(),
*Genode::env()->rm_session(),
ram_config.quantum, ram_config.limit,
_yield_broadcast_dispatcher,
_exited_child_sig_cap, _ldso_ds);
_yield_broadcast_handler,
_exited_child_sig_cap);
/* configure child */
try {
@ -228,8 +192,8 @@ class Launcher::Subsystem_manager
child->start();
} catch (Rom_connection::Rom_connection_failed) {
Genode::error("binary \"", binary_name, "\" is missing");
} catch (Parent::Service_denied) {
Genode::error("failed to start ", binary_name);
throw Invalid_config();
}
}

2
repos/gems/src/app/launcher/target.mk
View File

@ -1,4 +1,4 @@
TARGET = launcher
SRC_CC = main.cc
LIBS = base server config
LIBS = base
INC_DIR += $(PRG_DIR)

2
repos/gems/src/app/themed_decorator/main.cc
View File

@ -118,7 +118,7 @@ struct Decorator::Main : Window_factory_base
* and view_handle operations. Currently, these exceptions will
* abort the decorator.
*/
Genode::env()->parent()->upgrade(nitpicker, "ram_quota=256K");
nitpicker.upgrade_ram(256*1024);
Genode::config()->sigh(config_dispatcher);
handle_config(0);

4
repos/gems/src/server/terminal/main.cc
View File

@ -499,15 +499,11 @@ namespace Terminal {
}
extern "C" void wait_for_continue();
int main(int, char **)
{
using namespace Genode;
log("--- terminal service started ---");
wait_for_continue();
static Framebuffer::Connection framebuffer;
static Input::Connection input;

2
repos/gems/src/server/terminal_mux/main.cc
View File

@ -737,7 +737,7 @@ int main(int, char **)
static Sliced_heap sliced_heap(env()->ram_session(), env()->rm_session());
static Registry registry;
static ::Registry registry;
static Ncurses ncurses;
static Status_window status_window(ncurses);
static Menu menu(ncurses, registry, status_window);

3
repos/gems/src/server/wm/decorator_nitpicker.h
View File

@ -352,7 +352,8 @@ struct Wm::Decorator_nitpicker_session : Genode::Rpc_object<Nitpicker::Session>,
void upgrade(const char *args)
{
Genode::env()->parent()->upgrade(_nitpicker_session, args);
size_t const ram_quota = Arg_string::find_arg(args, "ram_quota").ulong_value(0);
_nitpicker_session.upgrade_ram(ram_quota);
}

3
repos/gems/src/server/wm/direct_nitpicker.h
View File

@ -40,7 +40,8 @@ class Wm::Direct_nitpicker_session : public Genode::Rpc_object<Nitpicker::Sessio
void upgrade(char const *args)
{
Genode::env()->parent()->upgrade(_session, args);
size_t const ram_quota = Arg_string::find_arg(args, "ram_quota").ulong_value(0);
_session.upgrade_ram(ram_quota);
}

3
repos/gems/src/server/wm/nitpicker.h
View File

@ -737,7 +737,8 @@ class Wm::Nitpicker::Session_component : public Rpc_object<Nitpicker::Session>,
void upgrade(char const *args)
{
Genode::env()->parent()->upgrade(_session, args);
size_t const ram_quota = Arg_string::find_arg(args, "ram_quota").ulong_value(0);
_session.upgrade_ram(ram_quota);
}
void try_to_init_real_child_views()