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

server/report_rom: componentize

Browse Source 
* Check report RAM donation and buffer size.
* Use explicit config ROM attachment.
* Pass Env to session connections.
* Replace logging macros.

Issue #2036
This commit is contained in:
Emery Hemingway
2016-07-07 10:13:39 +02:00
committed by Norman Feske
parent 02e50ce5d7
commit 0efd5a3078
8 changed files with 96 additions and 78 deletions
Download Patch File Download Diff File Expand all files Collapse all files

41
repos/os/include/report_rom/report_service.h
View File

@ -5,7 +5,7 @@
*/ */
/* /*
* Copyright (C) 2014-2016 Genode Labs GmbH * Copyright (C) 2014 Genode Labs GmbH
* *
* This file is part of the Genode OS framework, which is distributed * This file is part of the Genode OS framework, which is distributed
* under the terms of the GNU General Public License version 2. * under the terms of the GNU General Public License version 2.
@ -20,6 +20,7 @@
#include <root/component.h> #include <root/component.h>
#include <util/print_lines.h> #include <util/print_lines.h>
#include <report_rom/rom_registry.h> #include <report_rom/rom_registry.h>
#include <base/log.h>
namespace Report { namespace Report {
@ -54,16 +55,17 @@ struct Report::Session_component : Genode::Rpc_object<Session>, Rom::Writer
static void _log_lines(char const *string, size_t len) static void _log_lines(char const *string, size_t len)
{ {
Genode::print_lines<200>(string, len, Genode::print_lines<200>(string, len,
[&] (char const *line) { PLOG(" %s", line); }); [&] (char const *line) { Genode::log(" ", line); });
} }
public: public:
Session_component(Genode::Session_label const &label, size_t buffer_size, Session_component(Genode::Env &env,
Genode::Session_label const &label, size_t buffer_size,
Rom::Registry_for_writer &registry, bool &verbose) Rom::Registry_for_writer &registry, bool &verbose)
: :
_registry(registry), _label(label), _registry(registry), _label(label),
_ds(Genode::env()->ram_session(), buffer_size), _ds(env.ram(), env.rm(), buffer_size),
_module(_create_module(label.string())), _module(_create_module(label.string())),
_verbose(verbose) _verbose(verbose)
{ } { }
@ -85,7 +87,7 @@ struct Report::Session_component : Genode::Rpc_object<Session>, Rom::Writer
length = Genode::min(length, _ds.size()); length = Genode::min(length, _ds.size());
if (_verbose) { if (_verbose) {
PLOG("report '%s'", _module.name().string()); Genode::log("report '", _module.name().string(), "'");
_log_lines(_ds.local_addr<char>(), length); _log_lines(_ds.local_addr<char>(), length);
} }
@ -102,6 +104,7 @@ struct Report::Root : Genode::Root_component<Session_component>
{ {
private: private:
Genode::Env &_env;
Rom::Registry_for_writer &_rom_registry; Rom::Registry_for_writer &_rom_registry;
bool &_verbose; bool &_verbose;
@ -111,24 +114,42 @@ struct Report::Root : Genode::Root_component<Session_component>
{ {
using namespace Genode; using namespace Genode;
Session_label const label = label_from_args(args);
size_t const ram_quota =
Arg_string::find_arg(args, "ram_quota").aligned_size();
/* read report buffer size from session arguments */ /* read report buffer size from session arguments */
size_t const buffer_size = size_t const buffer_size =
Arg_string::find_arg(args, "buffer_size").ulong_value(0); Arg_string::find_arg(args, "buffer_size").aligned_size();
size_t const session_size =
max(sizeof(Session_component), 4096U) + buffer_size;
if (ram_quota < session_size) {
Genode::error("insufficient ram donation from ", label.string());
throw Root::Quota_exceeded();
}
if (buffer_size == 0) {
Genode::error("zero-length report requested by ", label.string());
throw Root::Invalid_args();
}
return new (md_alloc()) return new (md_alloc())
Session_component(label_from_args(args), buffer_size, Session_component(_env, label, buffer_size,
_rom_registry, _verbose); _rom_registry, _verbose);
} }
public: public:
Root(Server::Entrypoint &ep, Root(Genode::Env &env,
Genode::Allocator &md_alloc, Genode::Allocator &md_alloc,
Rom::Registry_for_writer &rom_registry, Rom::Registry_for_writer &rom_registry,
bool &verbose) bool &verbose)
: :
Genode::Root_component<Session_component>(&ep.rpc_ep(), &md_alloc), Genode::Root_component<Session_component>(&env.ep().rpc_ep(), &md_alloc),
_rom_registry(rom_registry), _verbose(verbose) _env(env), _rom_registry(rom_registry), _verbose(verbose)
{ } { }
}; };

4
repos/os/include/report_rom/rom_module.h
View File

@ -5,7 +5,7 @@
*/ */
/* /*
* Copyright (C) 2014 Genode Labs GmbH * Copyright (C) 2014-2016 Genode Labs GmbH
* *
* This file is part of the Genode OS framework, which is distributed * This file is part of the Genode OS framework, which is distributed
* under the terms of the GNU General Public License version 2. * under the terms of the GNU General Public License version 2.
@ -16,8 +16,8 @@
/* Genode includes */ /* Genode includes */
#include <util/volatile_object.h> #include <util/volatile_object.h>
#include <os/attached_ram_dataspace.h>
#include <os/session_policy.h> #include <os/session_policy.h>
#include <base/attached_ram_dataspace.h>
namespace Rom { namespace Rom {
using Genode::size_t; using Genode::size_t;

7
repos/os/include/report_rom/rom_service.h
View File

@ -5,7 +5,7 @@
*/ */
/* /*
* Copyright (C) 2014 Genode Labs GmbH * Copyright (C) 2014-2016 Genode Labs GmbH
* *
* This file is part of the Genode OS framework, which is distributed * This file is part of the Genode OS framework, which is distributed
* under the terms of the GNU General Public License version 2. * under the terms of the GNU General Public License version 2.
@ -20,7 +20,6 @@
#include <rom_session/rom_session.h> #include <rom_session/rom_session.h>
#include <root/component.h> #include <root/component.h>
#include <report_rom/rom_registry.h> #include <report_rom/rom_registry.h>
#include <os/session_policy.h>
namespace Rom { namespace Rom {
class Session_component; class Session_component;
@ -175,11 +174,11 @@ class Rom::Root : public Genode::Root_component<Session_component>
public: public:
Root(Server::Entrypoint &ep, Root(Genode::Env &env,
Genode::Allocator &md_alloc, Genode::Allocator &md_alloc,
Registry_for_reader &registry) Registry_for_reader &registry)
: :
Genode::Root_component<Session_component>(&ep.rpc_ep(), &md_alloc), Genode::Root_component<Session_component>(&env.ep().rpc_ep(), &md_alloc),
_registry(registry) _registry(registry)
{ } { }
}; };

54
repos/os/src/server/clipboard/main.cc
View File

@ -13,14 +13,12 @@
/* Genode includes */ /* Genode includes */
#include <base/heap.h> #include <base/heap.h>
#include <base/env.h> #include <base/component.h>
#include <os/server.h>
#include <os/config.h>
#include <os/attached_rom_dataspace.h> #include <os/attached_rom_dataspace.h>
#include <report_rom/rom_service.h> #include <report_rom/rom_service.h>
#include <report_rom/report_service.h> #include <report_rom/report_service.h>
namespace Server { struct Main; } namespace Clipboard { struct Main; }
/** /**
@ -69,16 +67,19 @@ struct Rom::Registry : Rom::Registry_for_reader, Rom::Registry_for_writer
}; };
struct Server::Main : Rom::Module::Read_policy, Rom::Module::Write_policy struct Clipboard::Main : Rom::Module::Read_policy, Rom::Module::Write_policy
{ {
Entrypoint &_ep; Genode::Env &_env;
Genode::Sliced_heap _sliced_heap = { Genode::env()->ram_session(), Genode::Sliced_heap _sliced_heap = { Genode::env()->ram_session(),
Genode::env()->rm_session() }; Genode::env()->rm_session() };
Genode::Attached_rom_dataspace _config { _env, "config" };
bool _verbose_config() bool _verbose_config()
{ {
char const *attr = "verbose"; char const *attr = "verbose";
return Genode::config()->xml_node().attribute_value(attr, false); return _config.xml().attribute_value(attr, false);
} }
bool verbose = _verbose_config(); bool verbose = _verbose_config();
@ -87,8 +88,8 @@ struct Server::Main : Rom::Module::Read_policy, Rom::Module::Write_policy
Genode::Attached_rom_dataspace _focus_ds { "focus" }; Genode::Attached_rom_dataspace _focus_ds { "focus" };
Genode::Signal_rpc_member<Main> _focus_dispatcher = Genode::Signal_handler<Main> _focus_handler =
{ _ep, *this, &Main::_handle_focus }; { _env.ep(), *this, &Main::_handle_focus };
Domain _focused_domain; Domain _focused_domain;
@ -97,7 +98,7 @@ struct Server::Main : Rom::Module::Read_policy, Rom::Module::Write_policy
* *
* We only accept reports from the currently focused domain. * We only accept reports from the currently focused domain.
*/ */
void _handle_focus(unsigned) void _handle_focus()
{ {
_focus_ds.update(); _focus_ds.update();
@ -117,7 +118,7 @@ struct Server::Main : Rom::Module::Read_policy, Rom::Module::Write_policy
using namespace Genode; using namespace Genode;
try { try {
return Session_policy(label).attribute_value("domain", Domain()); return Session_policy(label, _config.xml()).attribute_value("domain", Domain());
} catch (Session_policy::No_policy_defined) { } } catch (Session_policy::No_policy_defined) { }
return Domain(); return Domain();
@ -154,9 +155,9 @@ struct Server::Main : Rom::Module::Read_policy, Rom::Module::Write_policy
auto match_flow = [&] (Genode::Xml_node flow) { auto match_flow = [&] (Genode::Xml_node flow) {
if (flow.attribute_value("from", Domain()) == from if (flow.attribute_value("from", Domain()) == from
&& flow.attribute_value("to", Domain()) == to) && flow.attribute_value("to", Domain()) == to)
result = true; }; result = true; };
Genode::config()->xml_node().for_each_sub_node("flow", match_flow); _config.xml().for_each_sub_node("flow", match_flow);
} catch (Genode::Xml_node::Nonexistent_sub_node) { } } catch (Genode::Xml_node::Nonexistent_sub_node) { }
@ -197,30 +198,29 @@ struct Server::Main : Rom::Module::Read_policy, Rom::Module::Write_policy
return false; return false;
} }
Rom::Registry _rom_registry { *this, *this }; Rom::Registry _rom_registry { *this, *this };
Report::Root report_root = { _ep, _sliced_heap, _rom_registry, verbose }; Report::Root report_root = { _env, _sliced_heap, _rom_registry, verbose };
Rom ::Root rom_root = { _ep, _sliced_heap, _rom_registry }; Rom ::Root rom_root = { _env, _sliced_heap, _rom_registry };
Main(Entrypoint &ep) : _ep(ep) Main(Genode::Env &env) : _env(env)
{ {
_focus_ds.sigh(_focus_dispatcher); _focus_ds.sigh(_focus_handler);
Genode::env()->parent()->announce(_ep.manage(report_root)); env.parent().announce(env.ep().manage(report_root));
Genode::env()->parent()->announce(_ep.manage(rom_root)); env.parent().announce(env.ep().manage(rom_root));
} }
}; };
namespace Server { /***************
** Component **
***************/
char const *name() { return "report_rom_ep"; } namespace Component {
size_t stack_size() { return 4*1024*sizeof(long); } Genode::size_t stack_size() { return 4*1024*sizeof(long); }
void construct(Entrypoint &ep) void construct(Genode::Env &env) { static Clipboard::Main main(env); }
{
static Main main(ep);
}
} }

2
repos/os/src/server/clipboard/target.mk
View File

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

47
repos/os/src/server/report_rom/main.cc
View File

@ -5,7 +5,7 @@
*/ */
/* /*
* Copyright (C) 2014 Genode Labs GmbH * Copyright (C) 2014-2016 Genode Labs GmbH
* *
* This file is part of the Genode OS framework, which is distributed * This file is part of the Genode OS framework, which is distributed
* under the terms of the GNU General Public License version 2. * under the terms of the GNU General Public License version 2.
@ -14,51 +14,46 @@
/* Genode includes */ /* Genode includes */
#include <base/heap.h> #include <base/heap.h>
#include <base/env.h> #include <base/env.h>
#include <os/server.h>
#include <os/config.h>
#include <report_rom/rom_service.h> #include <report_rom/rom_service.h>
#include <report_rom/report_service.h> #include <report_rom/report_service.h>
#include <base/attached_rom_dataspace.h>
#include <base/component.h>
/* local includes */ /* local includes */
#include "rom_registry.h" #include "rom_registry.h"
namespace Server { namespace Report_rom { struct Main; }
using Genode::env;
struct Main;
}
struct Server::Main struct Report_rom::Main
{ {
Entrypoint &ep; Genode::Env &env;
Genode::Sliced_heap sliced_heap = { env()->ram_session(), Genode::Sliced_heap sliced_heap { env.ram(), env.rm() };
env()->rm_session() };
Rom::Registry rom_registry = { sliced_heap }; Rom::Registry rom_registry { sliced_heap, config_rom };
bool verbose = Genode::config()->xml_node().attribute_value("verbose", false); Genode::Attached_rom_dataspace config_rom { env, "config" };
Report::Root report_root = { ep, sliced_heap, rom_registry, verbose }; bool verbose = config_rom.xml().attribute_value("verbose", false);
Rom ::Root rom_root = { ep, sliced_heap, rom_registry };
Main(Entrypoint &ep) : ep(ep) Report::Root report_root { env, sliced_heap, rom_registry, verbose };
Rom ::Root rom_root { env, sliced_heap, rom_registry };
Main(Genode::Env &env) : env(env)
{ {
env()->parent()->announce(ep.manage(report_root)); env.parent().announce(env.ep().manage(report_root));
env()->parent()->announce(ep.manage(rom_root)); env.parent().announce(env.ep().manage(rom_root));
} }
}; };
namespace Server { /***************
** Component **
***************/
char const *name() { return "report_rom_ep"; } Genode::size_t Component::stack_size() { return 4*1024*sizeof(long); }
size_t stack_size() { return 4*1024*sizeof(long); } void Component::construct(Genode::Env &env) { static Report_rom::Main main(env); }
void construct(Entrypoint &ep)
{
static Main main(ep);
}
}

17
repos/os/src/server/report_rom/rom_registry.h
View File

@ -5,7 +5,7 @@
*/ */
/* /*
* Copyright (C) 2014 Genode Labs GmbH * Copyright (C) 2014-2016 Genode Labs GmbH
* *
* This file is part of the Genode OS framework, which is distributed * This file is part of the Genode OS framework, which is distributed
* under the terms of the GNU General Public License version 2. * under the terms of the GNU General Public License version 2.
@ -26,6 +26,7 @@ struct Rom::Registry : Registry_for_reader, Registry_for_writer, Genode::Noncopy
private: private:
Genode::Allocator &_md_alloc; Genode::Allocator &_md_alloc;
Genode::Attached_rom_dataspace &_config_rom;
Module_list _modules; Module_list _modules;
@ -118,15 +119,16 @@ struct Rom::Registry : Registry_for_reader, Registry_for_writer, Genode::Noncopy
String<Rom::Module::Name::capacity()> report; String<Rom::Module::Name::capacity()> report;
_config_rom.update();
try { try {
Session_policy policy(rom_label); Session_policy policy(rom_label, _config_rom.xml());
policy.attribute("report").value(&report); policy.attribute("report").value(&report);
return Rom::Module::Name(report.string()); return Rom::Module::Name(report.string());
} catch (Session_policy::No_policy_defined) { } catch (Session_policy::No_policy_defined) {
/* FIXME backwards compatibility, remove at next release */ /* FIXME backwards compatibility, remove at next release */
try { try {
Xml_node rom_node = config()->xml_node().sub_node("rom"); Xml_node rom_node = _config_rom.xml().sub_node("rom");
PWRN("parsing legacy <rom> policies"); warning("parsing legacy <rom> policies");
Session_policy policy(rom_label, rom_node); Session_policy policy(rom_label, rom_node);
policy.attribute("report").value(&report); policy.attribute("report").value(&report);
@ -135,15 +137,16 @@ struct Rom::Registry : Registry_for_reader, Registry_for_writer, Genode::Noncopy
catch (Session_policy::No_policy_defined) { } catch (Session_policy::No_policy_defined) { }
} }
PWRN("no valid policy for label \"%s\"", rom_label.string()); warning("no valid policy for ROM request \", rom_label.string(), \"");
throw Root::Invalid_args(); throw Root::Invalid_args();
} }
public: public:
Registry(Genode::Allocator &md_alloc) Registry(Genode::Allocator &md_alloc,
Genode::Attached_rom_dataspace &config_rom)
: :
_md_alloc(md_alloc) _md_alloc(md_alloc), _config_rom(config_rom)
{ } { }
Module &lookup(Writer &writer, Module::Name const &name) override Module &lookup(Writer &writer, Module::Name const &name) override

2
repos/os/src/server/report_rom/target.mk
View File

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