alex/genode-world
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

remote_rom: update to 17.02

Browse Source
This commit is contained in:
Johannes Schlatow
2017-03-02 14:07:51 +01:00
parent 95f3e6fd4d
commit f0dd661c8f
4 changed files with 57 additions and 73 deletions
Download Patch File Download Diff File Expand all files Collapse all files

55
src/lib/remote_rom/backend/nic_ip/backend.cc
View File

@@ -7,6 +7,7 @@
#include <base/env.h>
#include <base/exception.h>
#include <base/log.h>
#include <base/attached_rom_dataspace.h>
#include <backend_base.h>
@@ -16,8 +17,6 @@
#include <net/ethernet.h>
#include <net/ipv4.h>
#include <os/config.h>
namespace Remote_rom {
bool verbose = false;
using Genode::size_t;
@@ -305,9 +304,9 @@ class Remote_rom::Backend_base
}
public:
explicit Backend_base(Genode::Allocator &alloc, HANDLER &handler)
explicit Backend_base(Genode::Env &env, Genode::Allocator &alloc, HANDLER &handler)
:
_tx_block_alloc(&alloc), _nic(&_tx_block_alloc, BUF_SIZE, BUF_SIZE),
_tx_block_alloc(&alloc), _nic(env, &_tx_block_alloc, BUF_SIZE, BUF_SIZE),
_rx_thread(_nic, handler, _accept_ip)
{
/* start dispatcher thread */
@@ -316,9 +315,11 @@ class Remote_rom::Backend_base
/* store mac address */
_mac_address = _nic.mac_address();
Genode::Attached_rom_dataspace config = {env, "config"};
try {
char ip_string[15];
Genode::Xml_node remoterom = Genode::config()->xml_node().sub_node("remote_rom");
Genode::Xml_node remoterom = config.xml().sub_node("remote_rom");
remoterom.attribute("src").value(ip_string, sizeof(ip_string));
_src_ip = Ipv4_packet::ip_from_string(ip_string);
@@ -358,12 +359,8 @@ class Remote_rom::Backend_base
class Remote_rom::Backend_server : public Backend_server_base, public Backend_base<Backend_server>
{
private:
static Backend_server_base* _instance;
Rom_forwarder_base *_forwarder;
Backend_server(Genode::Allocator &alloc) : Backend_base(alloc, *this), _forwarder(nullptr)
{ }
void send_data()
{
if (!_forwarder) return;
@@ -390,17 +387,8 @@ class Remote_rom::Backend_server : public Backend_server_base, public Backend_ba
}
public:
static Backend_server_base &instance()
{
if (!_instance) {
_instance = new (env()->heap()) Backend_server(*env()->heap());
if (!_instance)
throw Exception();
}
return *_instance;
}
Backend_server(Genode::Env &env, Genode::Allocator &alloc) : Backend_base(env, alloc, *this), _forwarder(nullptr)
{ }
void register_forwarder(Rom_forwarder_base *forwarder)
{
@@ -451,14 +439,10 @@ class Remote_rom::Backend_server : public Backend_server_base, public Backend_ba
class Remote_rom::Backend_client : public Backend_client_base, public Backend_base<Backend_client>
{
private:
static Backend_client_base *_instance;
Rom_receiver_base *_receiver;
char *_write_ptr;
size_t _buf_size;
Backend_client(Genode::Allocator &alloc) : Backend_base(alloc, *this), _receiver(nullptr), _write_ptr(nullptr), _buf_size(0)
{
}
void write(char *data, size_t offset, size_t size)
{
@@ -472,16 +456,8 @@ class Remote_rom::Backend_client : public Backend_client_base, public Backend_ba
}
public:
static Backend_client_base &instance()
Backend_client(Genode::Env &env, Genode::Allocator &alloc) : Backend_base(env, alloc, *this), _receiver(nullptr), _write_ptr(nullptr), _buf_size(0)
{
if (!_instance) {
_instance = new (env()->heap()) Backend_client(*env()->heap());
if (!_instance)
throw Exception();
}
return *_instance;
}
void register_receiver(Rom_receiver_base *receiver)
@@ -564,15 +540,14 @@ class Remote_rom::Backend_client : public Backend_client_base, public Backend_ba
}
};
Remote_rom::Backend_server_base *Remote_rom::Backend_server::_instance = nullptr;
Remote_rom::Backend_client_base *Remote_rom::Backend_client::_instance = nullptr;
Remote_rom::Backend_server_base &Remote_rom::backend_init_server()
Remote_rom::Backend_server_base &Remote_rom::backend_init_server(Genode::Env &env, Genode::Allocator &alloc)
{
return Backend_server::instance();
static Backend_server backend(env, alloc);
return backend;
}
Remote_rom::Backend_client_base &Remote_rom::backend_init_client()
Remote_rom::Backend_client_base &Remote_rom::backend_init_client(Genode::Env &env, Genode::Allocator &alloc)
{
return Backend_client::instance();
static Backend_client backend(env, alloc);
return backend;
}

36
src/proxy/remote_rom/client/main.cc
View File

@@ -26,11 +26,11 @@
#include <base/rpc_server.h>
#include <root/component.h>
#include <os/attached_ram_dataspace.h>
#include <base/attached_ram_dataspace.h>
#include <base/attached_rom_dataspace.h>
#include <rom_session/rom_session.h>
#include <base/component.h>
#include <os/config.h>
#include <backend_base.h>
@@ -44,8 +44,6 @@ namespace Remote_rom {
struct Main;
struct Read_buffer;
static char remotename[255];
typedef Genode::List<Session_component> Session_list;
};
@@ -104,7 +102,7 @@ class Remote_rom::Session_component : public Genode::Rpc_object<Genode::Rom_sess
if (!_ram_ds.is_constructed()
|| _buffer.content_size() > _ram_ds->size()) {
_ram_ds.construct(&_env.ram(), _buffer.content_size());
_ram_ds.construct(_env.ram(), _env.rm(), _buffer.content_size());
}
char *dst = _ram_ds->local_addr<char>();
@@ -170,16 +168,25 @@ struct Remote_rom::Main : public Remote_rom::Read_buffer, public Remote_rom::Rom
Genode::Constructible<Genode::Attached_ram_dataspace> _ds;
size_t _ds_content_size;
Genode::Attached_rom_dataspace _config = { env, "config" };
Backend_client_base &_backend;
Main(Genode::Env &env) : env(env), _ds_content_size(1024), _backend(backend_init_client())
char remotename[255];
Main(Genode::Env &env) : env(env), _ds_content_size(1024), _backend(backend_init_client(env, heap))
{
try {
Genode::Xml_node remote_rom = _config.xml().sub_node("remote_rom");
remote_rom.attribute("name").value(remotename, sizeof(remotename));
} catch (...) {
Genode::error("No ROM module configured!");
}
env.parent().announce(env.ep().manage(remote_rom_root));
/* initialise backend */
_backend.register_receiver(this);
// _ds.construct(Genode::env()->ram_session(), _ds_content_size);
}
const char* module_name() const { return remotename; }
@@ -191,7 +198,7 @@ struct Remote_rom::Main : public Remote_rom::Read_buffer, public Remote_rom::Rom
// TODO (optional) implement double buffering
if (!_ds.is_constructed() || _ds_content_size > _ds->size())
_ds.construct(&env.ram(), _ds_content_size);
_ds.construct(env.ram(), env.rm(), _ds_content_size);
// TODO set write lock
@@ -216,7 +223,7 @@ struct Remote_rom::Main : public Remote_rom::Read_buffer, public Remote_rom::Rom
else {
/* transfer default content if set */
try {
Genode::Xml_node default_content = Genode::config()->xml_node().sub_node("remote_rom").sub_node("default");
Genode::Xml_node default_content = _config.xml().sub_node("remote_rom").sub_node("default");
return default_content.content_size();
} catch (...) { }
}
@@ -234,7 +241,7 @@ struct Remote_rom::Main : public Remote_rom::Read_buffer, public Remote_rom::Rom
else {
/* transfer default content if set */
try {
Genode::Xml_node default_content = Genode::config()->xml_node().sub_node("remote_rom").sub_node("default");
Genode::Xml_node default_content = _config.xml().sub_node("remote_rom").sub_node("default");
size_t const len = Genode::min(dst_len, default_content.content_size());
Genode::memcpy(dst, default_content.content_base(), len);
return len;
@@ -248,13 +255,6 @@ namespace Component {
Genode::size_t stack_size() { return 2*1024*sizeof(long); }
void construct(Genode::Env &env)
{
try {
Genode::Xml_node remote_rom = Genode::config()->xml_node().sub_node("remote_rom");
remote_rom.attribute("name").value(Remote_rom::remotename, sizeof(Remote_rom::remotename));
} catch (...) {
Genode::error("No ROM module configured!");
}
static Remote_rom::Main main(env);
}
}

35
src/proxy/remote_rom/server/main.cc
View File

@@ -19,12 +19,12 @@
#include <base/log.h>
#include <base/env.h>
#include <base/heap.h>
#include <backend_base.h>
#include <base/component.h>
#include <os/config.h>
#include <os/attached_rom_dataspace.h>
#include <base/attached_rom_dataspace.h>
namespace Remote_rom {
using Genode::size_t;
@@ -44,7 +44,10 @@ struct Remote_rom::Rom_forwarder : Rom_forwarder_base
Attached_rom_dataspace &_rom;
Backend_server_base &_backend;
Rom_forwarder(Attached_rom_dataspace &rom, Backend_server_base &backend) : _rom(rom), _backend(backend)
Attached_rom_dataspace &_config;
Rom_forwarder(Attached_rom_dataspace &rom, Backend_server_base &backend, Attached_rom_dataspace &config)
: _rom(rom), _backend(backend), _config(config)
{
_backend.register_forwarder(this);
@@ -75,7 +78,7 @@ struct Remote_rom::Rom_forwarder : Rom_forwarder_base
}
else {
try {
Genode::Xml_node default_content = Genode::config()->xml_node().sub_node("remote_rom").sub_node("default");
Genode::Xml_node default_content = _config.xml().sub_node("remote_rom").sub_node("default");
return default_content.content_size();
} catch (...) { }
}
@@ -92,7 +95,7 @@ struct Remote_rom::Rom_forwarder : Rom_forwarder_base
else {
/* transfer default content if set */
try {
Genode::Xml_node default_content = Genode::config()->xml_node().sub_node("remote_rom").sub_node("default");
Genode::Xml_node default_content = _config.xml().sub_node("remote_rom").sub_node("default");
size_t const len = Genode::min(dst_len, default_content.content_size()-offset);
Genode::memcpy(dst, default_content.content_base() + offset, len);
return len;
@@ -105,16 +108,19 @@ struct Remote_rom::Rom_forwarder : Rom_forwarder_base
struct Remote_rom::Main
{
Genode::Entrypoint &_ep;
Genode::Env &_env;
Genode::Heap _heap = { &_env.ram(), &_env.rm() };
Attached_rom_dataspace _config = { _env, "config" };
Attached_rom_dataspace _rom;
Rom_forwarder _forwarder;
Genode::Signal_handler<Rom_forwarder> _dispatcher = { _ep, _forwarder, &Rom_forwarder::update };
Genode::Signal_handler<Rom_forwarder> _dispatcher = { _env.ep(), _forwarder, &Rom_forwarder::update };
Main(Genode::Entrypoint &ep)
: _ep(ep),
_rom(modulename),
_forwarder(_rom, backend_init_server())
Main(Genode::Env &env)
: _env(env),
_rom(env, modulename),
_forwarder(_rom, backend_init_server(env, _heap), _config)
{
/* register update dispatcher */
_rom.sigh(_dispatcher);
@@ -123,10 +129,13 @@ struct Remote_rom::Main
namespace Component {
Genode::size_t stack_size() { return 2*1024*sizeof(long); }
void construct(Genode::Env &env)
{
Genode::Attached_rom_dataspace config = { env, "config" };
try {
Genode::Xml_node remote_rom = Genode::config()->xml_node().sub_node("remote_rom");
Genode::Xml_node remote_rom = config.xml().sub_node("remote_rom");
if (remote_rom.has_attribute("localname"))
remote_rom.attribute("localname").value(Remote_rom::modulename, sizeof(Remote_rom::modulename));
else
@@ -140,6 +149,6 @@ namespace Component {
Genode::error("No ROM module configured!");
}
static Remote_rom::Main main(env.ep());
static Remote_rom::Main main(env);
}
}