diff --git a/doc/components.txt b/doc/components.txt index f0c4abef8..da228ce1d 100644 --- a/doc/components.txt +++ b/doc/components.txt @@ -375,11 +375,15 @@ Separate components: A block service that fetches a virtual block device over the network from a HTTP server. -:'fs_rom': +:'os/src/server/fs_rom': A ROM service that translates the 'File_system' session interface to the 'ROM' session' interface. Each request for a ROM file is handled by looking up an equally named file on the file system. +:'os/src/server/dynamic_rom': + A simple ROM service that provides ROM modules that change in time according + to a configured timeline. + Libraries: :'libports/lib/mk/libc': diff --git a/os/src/server/dynamic_rom/README b/os/src/server/dynamic_rom/README new file mode 100644 index 000000000..41b975a7c --- /dev/null +++ b/os/src/server/dynamic_rom/README @@ -0,0 +1,6 @@ +ROM service that provides ROM modules that change during the lifetime of a ROM +session according to a timeline. This main purpuse of this service is the +testing of programs that are able to respond to ROM module changes, for example +configuration changes. + +For a practical example, refer to the 'gems/run/decorator.run' script. diff --git a/os/src/server/dynamic_rom/main.cc b/os/src/server/dynamic_rom/main.cc new file mode 100644 index 000000000..57492a2dc --- /dev/null +++ b/os/src/server/dynamic_rom/main.cc @@ -0,0 +1,288 @@ +/* + * \brief ROM server that changes ROM content driven by time + * \author Norman Feske + * \date 2014-01-10 + */ + +/* + * Copyright (C) 2014 Genode Labs GmbH + * + * This file is part of the Genode OS framework, which is distributed + * under the terms of the GNU General Public License version 2. + */ + +/* Genode includes */ +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + + +namespace Dynamic_rom { + using Server::Entrypoint; + using Genode::Rpc_object; + using Genode::Sliced_heap; + using Genode::env; + using Genode::Lazy_volatile_object; + using Genode::Signal_context_capability; + using Genode::Xml_node; + using Genode::Signal_rpc_member; + using Genode::Arg_string; + + class Session_component; + class Root; + struct Main; +} + + +class Dynamic_rom::Session_component : public Rpc_object +{ + private: + + bool &_verbose; + Xml_node _rom_node; + Timer::Connection _timer; + unsigned _curr_idx = 0; + bool _has_content = false; + unsigned _last_content_idx = ~0; + Signal_context_capability _sigh; + + Lazy_volatile_object _ram_ds; + + void _notify_client() + { + if (!_sigh.valid()) + return; + + Genode::Signal_transmitter(_sigh).submit(); + } + + template + void _log(char const *format, ARGS... args) + { + if (!_verbose) + return; + + char name[200]; + _rom_node.attribute("name").value(name, sizeof(name)); + + Genode::printf("%s: ", name); + Genode::printf(format, args...); + Genode::printf("\n"); + } + + enum Execution_state { EXEC_CONTINUE, EXEC_BLOCK }; + + Execution_state _execute_step(Xml_node curr_step) + { + /* + * Replace content of ROM module by new one. Note that the content + * of the currently handed out dataspace remains untouched until + * the ROM client requests the new version by calling 'dataspace' + * the next time. + */ + if (curr_step.has_type("inline")) { + _last_content_idx = _curr_idx; + _has_content = true; + _notify_client(); + + if (curr_step.has_attribute("description")) { + char desc[200]; + desc[0] = 0; + curr_step.attribute("description").value(desc, sizeof(desc)); + _log("change (%s)", desc); + } else { + _log("change"); + } + } + + /* + * Remove ROM module + */ + if (curr_step.has_type("empty")) { + _last_content_idx = ~0;; + _has_content = false; + _notify_client(); + _log("remove"); + } + + /* + * Sleep some time + * + * The timer will trigger the execution of the next step. + */ + if (curr_step.has_type("sleep") + && curr_step.has_attribute("milliseconds")) { + + unsigned long milliseconds = 0; + curr_step.attribute("milliseconds").value(&milliseconds); + _timer.trigger_once(milliseconds*1000); + _log("sleep %ld milliseconds", milliseconds); + + return EXEC_BLOCK; + } + + return EXEC_CONTINUE; + } + + void _execute_steps_until_sleep() + { + Execution_state exec_state = EXEC_CONTINUE; + while (exec_state == EXEC_CONTINUE) { + + exec_state = _execute_step(_rom_node.sub_node(_curr_idx)); + + /* advance step index, wrap at the end */ + _curr_idx = (_curr_idx + 1) % _rom_node.num_sub_nodes(); + } + } + + void _timer_handler(unsigned) { _execute_steps_until_sleep(); } + + Entrypoint &_ep; + + typedef Session_component This; + Signal_rpc_member _timer_dispatcher = { _ep, *this, &This::_timer_handler }; + + public: + + Session_component(Entrypoint &ep, Xml_node rom_node, bool &verbose) + : + _verbose(verbose), _rom_node(rom_node), _ep(ep) + { + /* init timer signal handler */ + _timer.sigh(_timer_dispatcher); + + /* execute first step immediately at session-creation time */ + _execute_steps_until_sleep(); + } + + ~Session_component() + { + _ep.dissolve(_timer_dispatcher); + } + + Genode::Rom_dataspace_capability dataspace() override + { + using namespace Genode; + + if (!_has_content) + return Rom_dataspace_capability(); + + /* replace dataspace by new one */ + _ram_ds.construct(env()->ram_session(), _rom_node.size()); + + /* fill with content of current step */ + Xml_node step_node = _rom_node.sub_node(_last_content_idx); + memcpy(_ram_ds->local_addr(), + step_node.content_addr(), + step_node.content_size()); + + /* cast RAM into ROM dataspace capability */ + Dataspace_capability ds_cap = static_cap_cast(_ram_ds->cap()); + return static_cap_cast(ds_cap); + } + + void sigh(Genode::Signal_context_capability sigh) override + { + _sigh = sigh; + } +}; + + +class Dynamic_rom::Root : public Genode::Root_component +{ + private: + + Entrypoint &_ep; + Xml_node _config_node; + bool &_verbose; + + class Nonexistent_rom_module { }; + + Xml_node _lookup_rom_node_in_config(char const *name) + { + /* lookup ROM module in config */ + for (unsigned i = 0; i < _config_node.num_sub_nodes(); i++) { + Xml_node node = _config_node.sub_node(i); + if (node.has_attribute("name") + && node.attribute("name").has_value(name)) + return node; + } + throw Nonexistent_rom_module(); + } + + protected: + + Session_component *_create_session(const char *args) + { + /* read name of ROM module from args */ + char name[200]; + Arg_string::find_arg(args, "filename").string(name, sizeof(name), ""); + + try { + return new (md_alloc()) + Session_component(_ep, + _lookup_rom_node_in_config(name), + _verbose); + + } catch (Nonexistent_rom_module) { + PERR("ROM module lookup for \"%s\" failed.", name); + throw Root::Invalid_args(); + } + } + + public: + + Root(Entrypoint &ep, Genode::Allocator &md_alloc, + Xml_node config_node, bool &verbose) + : + Genode::Root_component(&ep.rpc_ep(), &md_alloc), + _ep(ep), _config_node(config_node), _verbose(verbose) + { } +}; + + +struct Dynamic_rom::Main +{ + bool _verbose_config() + { + Xml_node config = Genode::config()->xml_node(); + + return config.has_attribute("verbose") + & config.attribute("verbose").has_value("yes"); + } + + bool verbose = _verbose_config(); + + Entrypoint &ep; + + Sliced_heap sliced_heap = { env()->ram_session(), env()->rm_session() }; + + Root root = { ep, sliced_heap, Genode::config()->xml_node(), verbose }; + + Main(Entrypoint &ep) : ep(ep) + { + env()->parent()->announce(ep.manage(root)); + } +}; + + +namespace Server { + + char const *name() { return "dynamic_rom_ep"; } + + size_t stack_size() { return 4*1024*sizeof(long); } + + void construct(Entrypoint &ep) + { + static Dynamic_rom::Main main(ep); + } +} diff --git a/os/src/server/dynamic_rom/target.mk b/os/src/server/dynamic_rom/target.mk new file mode 100644 index 000000000..91c2a8dec --- /dev/null +++ b/os/src/server/dynamic_rom/target.mk @@ -0,0 +1,3 @@ +TARGET = dynamic_rom +SRC_CC = main.cc +LIBS = base server config