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

Add Rom_session::update

Browse Source 
The new Rom_session::update function can be used to request the update of
an existing ROM dataspace. If the new data fits into the existing
dataspace, a subsequent call of 'dataspace' can be omitted. This way,
ROM dataspace updates don't suffer from page-fault-handling costs that
would occur when replacing the dataspace with each update.
This commit is contained in:
Norman Feske 2014-06-04 22:02:03 +02:00
parent 0fab869bcc
commit c652655bcb
4 changed files with 118 additions and 66 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

23
repos/base/include/rom_session/client.h
View File

@ -17,18 +17,21 @@
#include <rom_session/capability.h>
#include <base/rpc_client.h>
namespace Genode {
namespace Genode { struct Rom_session_client; }
struct Rom_session_client : Rpc_client<Rom_session>
{
explicit Rom_session_client(Rom_session_capability session)
: Rpc_client<Rom_session>(session) { }
struct Genode::Rom_session_client : Rpc_client<Rom_session>
{
explicit Rom_session_client(Rom_session_capability session)
: Rpc_client<Rom_session>(session) { }
Rom_dataspace_capability dataspace() {
return call<Rpc_dataspace>(); }
Rom_dataspace_capability dataspace() override {
return call<Rpc_dataspace>(); }
void sigh(Signal_context_capability cap) { call<Rpc_sigh>(cap); }
};
}
bool update() override {
return call<Rpc_update>(); }
void sigh(Signal_context_capability cap) override {
call<Rpc_sigh>(cap); }
};
#endif /* _INCLUDE__ROM_SESSION__CLIENT_H_ */

132
repos/base/include/rom_session/rom_session.h
View File

@ -3,12 +3,12 @@
* \author Norman Feske
* \date 2006-07-06
*
* A ROM session corresponds to an open file. The file name is specified as an
* argument on session creation.
* A ROM session corresponds to a ROM module. The module name is specified as
* an argument on session creation.
*/
/*
* Copyright (C) 2006-2013 Genode Labs GmbH
* Copyright (C) 2006-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.
@ -25,58 +25,82 @@ namespace Genode {
struct Rom_dataspace : Dataspace { };
struct Rom_session;
typedef Capability<Rom_dataspace> Rom_dataspace_capability;
struct Rom_session : Session
{
static const char *service_name() { return "ROM"; }
virtual ~Rom_session() { }
/**
* Request dataspace containing the ROM session data
*
* \return capability to ROM dataspace
*
* The capability may be invalid.
*
* Consecutive calls of this functions are not guaranteed to return the
* same dataspace as dynamic ROM sessions may update the ROM data
* during the lifetime of the session. When calling the function, the
* server may destroy the old dataspace and replace it with a new one
* containing the updated data. Hence, prior calling this function, the
* client should make sure to detach the previously requested dataspace
* from its local address space.
*/
virtual Rom_dataspace_capability dataspace() = 0;
/**
* Register signal handler to be notified of ROM data changes
*
* The ROM session interface allows for the implementation of ROM
* services that dynamically update the data exported as ROM dataspace
* during the lifetime of the session. This is useful in scenarios
* where this data is generated rather than originating from a static
* file, for example to update a program's configuration at runtime.
*
* By installing a signal handler using the 'sigh()' function, the
* client will receive a notification each time the data changes at the
* server. From the client's perspective, the original data contained
* in the currently used dataspace remains unchanged until the client
* calls 'dataspace()' the next time.
*/
virtual void sigh(Signal_context_capability sigh) = 0;
/*********************
** RPC declaration **
*********************/
GENODE_RPC(Rpc_dataspace, Rom_dataspace_capability, dataspace);
GENODE_RPC(Rpc_sigh, void, sigh, Signal_context_capability);
GENODE_RPC_INTERFACE(Rpc_dataspace, Rpc_sigh);
};
}
struct Genode::Rom_session : Session
{
static const char *service_name() { return "ROM"; }
virtual ~Rom_session() { }
/**
* Request dataspace containing the ROM session data
*
* \return capability to ROM dataspace
*
* The capability may be invalid.
*
* Consecutive calls of this functions are not guaranteed to return the
* same dataspace as dynamic ROM sessions may update the ROM data
* during the lifetime of the session. When calling the function, the
* server may destroy the old dataspace and replace it with a new one
* containing the updated data. Hence, prior calling this function, the
* client should make sure to detach the previously requested dataspace
* from its local address space.
*/
virtual Rom_dataspace_capability dataspace() = 0;
/**
* Update ROM dataspace content
*
* This function is an optimization for use cases where ROM dataspaces
* are updated at a high rate. In such cases, requesting a new
* dataspace for each update induces a large overhead because
* memory mappings must be revoked and updated (e.g., handling the
* page faults referring to the dataspace). If the updated content
* fits in the existing dataspace, those costly operations can be
* omitted.
*
* When this function is called, the server may replace the dataspace
* content with new data.
*
* \return true if the existing dataspace contains up-to-date content,
* or false if a new dataspace must be requested via the
* 'dataspace' function
*/
virtual bool update() { return false; }
/**
* Register signal handler to be notified of ROM data changes
*
* The ROM session interface allows for the implementation of ROM
* services that dynamically update the data exported as ROM dataspace
* during the lifetime of the session. This is useful in scenarios
* where this data is generated rather than originating from a static
* file, for example to update a program's configuration at runtime.
*
* By installing a signal handler using the 'sigh()' function, the
* client will receive a notification each time the data changes at the
* server. From the client's perspective, the original data contained
* in the currently used dataspace remains unchanged until the client
* calls 'dataspace()' the next time.
*/
virtual void sigh(Signal_context_capability sigh) = 0;
/*********************
** RPC declaration **
*********************/
GENODE_RPC(Rpc_dataspace, Rom_dataspace_capability, dataspace);
GENODE_RPC(Rpc_sigh, void, sigh, Signal_context_capability);
GENODE_RPC(Rpc_update, bool, update);
GENODE_RPC_INTERFACE(Rpc_dataspace, Rpc_update, Rpc_sigh);
};
#endif /* _INCLUDE__ROM_SESSION__ROM_SESSION_H_ */

20
repos/os/include/os/attached_rom_dataspace.h
View File

@ -79,9 +79,25 @@ class Genode::Attached_rom_dataspace
void sigh(Signal_context_capability sigh) { _rom.sigh(sigh); }
/**
* Re-attach ROM module
* Update ROM module content, re-attach if needed
*/
void update() { _try_attach(); }
void update()
{
/*
* If the dataspace is already attached and the update fits into
* the existing dataspace, we can keep everything in place. The
* dataspace content gets updated by the call of '_rom.update'.
*/
if (_ds.is_constructed() && _rom.update() == true)
return;
/*
* If there was no valid dataspace attached beforehand or the
* new data size exceeds the capacity of the existing dataspace,
* replace the current dataspace by a new one.
*/
_try_attach();
}
/**
* Return true of content is present

9
repos/os/src/server/report_rom/rom_service.h
View File

@ -73,6 +73,15 @@ class Rom::Session_component : public Genode::Rpc_object<Genode::Rom_session>,
return static_cap_cast<Rom_dataspace>(ds_cap);
}
bool update() override
{
if (!_ds.is_constructed() || _module.size() > _ds->size())
return false;
_module.read_content(_ds->local_addr<char>(), _ds->size());
return true;
}
void sigh(Genode::Signal_context_capability sigh) override
{
_sigh = sigh;