ExternalVendorCode/genode
1
0
Fork 0
mirror of https://github.com/genodelabs/genode.git synced 2024-12-19 05:37:54 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

Noux cleanup and source documentation

Browse Source 
This patch decomposes the former 'child.h' into several header files,
unifies the naming of classes, and adds source-code documentation.
This commit is contained in:
Norman Feske 2012-02-22 22:24:32 +01:00
parent 2bbf40d76a
commit 7c98268901
7 changed files with 862 additions and 641 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

670
ports/src/noux/child.h
View File

@ -16,8 +16,6 @@
/* Genode includes */
#include <init/child_policy.h>
#include <ram_session/connection.h>
#include <cpu_session/connection.h>
#include <base/signal.h>
#include <base/semaphore.h>
#include <cap_session/cap_session.h>
@ -30,6 +28,10 @@
#include <noux_session/capability.h>
#include <args.h>
#include <environment.h>
#include <local_rm_service.h>
#include <ram_session_component.h>
#include <cpu_session_component.h>
namespace Noux {
@ -61,11 +63,7 @@ namespace Noux {
/**
* Return singleton instance of PID allocator
*/
Pid_allocator *pid_allocator()
{
static Pid_allocator inst;
return &inst;
}
Pid_allocator *pid_allocator();
class Child;
@ -155,598 +153,23 @@ namespace Noux {
*/
struct Resources
{
/*
* XXX not used yet
/**
* Entrypoint used to serve the RPC interfaces of the
* locally-provided services
*/
struct Dataspace_destroyer
{
virtual void destroy(Dataspace_capability) = 0;
};
class Dataspace_registry;
class Dataspace_info : public Object_pool<Dataspace_info>::Entry
{
private:
size_t _size;
Dataspace_capability _ds_cap;
Dataspace_destroyer &_destroyer;
public:
Dataspace_info(Dataspace_capability ds_cap,
Dataspace_destroyer &destroyer)
:
Object_pool<Dataspace_info>::Entry(ds_cap),
_size(Dataspace_client(ds_cap).size()),
_ds_cap(ds_cap),
_destroyer(destroyer)
{ }
size_t size() const { return _size; }
Dataspace_capability ds_cap() const { return _ds_cap; }
/**
* Create shadow copy of dataspace
*
* \param ds_registry registry for keeping track of
* the new dataspace
* \param ep entrypoint used to serve the RPC
* interface of the new dataspace
* (used if the dataspace is a sub
* RM session)
* \return capability for the new dataspace
*/
virtual Dataspace_capability fork(Ram_session_capability ram,
Dataspace_destroyer &destroyer,
Dataspace_registry &ds_registry,
Rpc_entrypoint &ep) = 0;
/**
* Write data sequence into dataspace
*
* \param dst_offset destination offset within dataspace
* \param src data source buffer
* \param len length of source buffer in bytes
*/
virtual void poke(addr_t dst_offset, void const *src, size_t len) = 0;
Dataspace_destroyer &destroyer() { return _destroyer; }
};
class Dataspace_registry
{
private:
Object_pool<Dataspace_info> _pool;
public:
void insert(Dataspace_info *info)
{
_pool.insert(info);
}
void remove(Dataspace_info *info)
{
_pool.remove(info);
}
Dataspace_info *lookup_info(Dataspace_capability ds_cap)
{
return _pool.obj_by_cap(ds_cap);
}
};
struct Ram_dataspace_info : Dataspace_info,
List<Ram_dataspace_info>::Element
{
Ram_dataspace_info(Ram_dataspace_capability ds_cap,
Dataspace_destroyer &destroyer)
: Dataspace_info(ds_cap, destroyer) { }
Dataspace_capability fork(Ram_session_capability ram,
Dataspace_destroyer &destroyer,
Dataspace_registry &,
Rpc_entrypoint &)
{
size_t const size = Dataspace_client(ds_cap()).size();
Ram_dataspace_capability dst_ds;
try {
dst_ds = Ram_session_client(ram).alloc(size);
} catch (...) {
return Dataspace_capability();
}
void *src = 0;
try {
src = Genode::env()->rm_session()->attach(ds_cap());
} catch (...) { }
void *dst = 0;
try {
dst = Genode::env()->rm_session()->attach(dst_ds);
} catch (...) { }
if (src && dst)
memcpy(dst, src, size);
if (src) Genode::env()->rm_session()->detach(src);
if (dst) Genode::env()->rm_session()->detach(dst);
if (!src || !dst) {
Ram_session_client(ram).free(dst_ds);
return Dataspace_capability();
}
return dst_ds;
}
void poke(addr_t dst_offset, void const *src, size_t len)
{
if ((dst_offset >= size()) || (dst_offset + len > size())) {
PERR("illegal attemt to write beyond dataspace boundary");
return;
}
char *dst = 0;
try {
dst = Genode::env()->rm_session()->attach(ds_cap());
} catch (...) { }
if (src && dst)
memcpy(dst + dst_offset, src, len);
if (dst) Genode::env()->rm_session()->detach(dst);
}
};
struct Local_ram_session : Rpc_object<Ram_session>,
Dataspace_destroyer
{
List<Ram_dataspace_info> _list;
/*
* Track the RAM resources accumulated via RAM session
* allocations.
*/
size_t _used_quota;
Dataspace_registry &_registry;
/**
* Constructor
*/
Local_ram_session(Dataspace_registry &registry)
: _used_quota(0), _registry(registry) { }
/**
* Destructor
*/
~Local_ram_session()
{
Ram_dataspace_info *info = 0;
while ((info = _list.first()))
free(static_cap_cast<Ram_dataspace>(info->ds_cap()));
}
/***********************************
** Dataspace_destroyer interface **
***********************************/
/* XXX not used yet */
void destroy(Dataspace_capability ds)
{
free(static_cap_cast<Ram_dataspace>(ds));
}
/***************************
** Ram_session interface **
***************************/
Ram_dataspace_capability alloc(size_t size)
{
Ram_dataspace_capability ds_cap = env()->ram_session()->alloc(size);
Ram_dataspace_info *ds_info = new (env()->heap())
Ram_dataspace_info(ds_cap, *this);
_used_quota += ds_info->size();
_registry.insert(ds_info);
_list.insert(ds_info);
return ds_cap;
}
void free(Ram_dataspace_capability ds_cap)
{
Ram_dataspace_info *ds_info =
dynamic_cast<Ram_dataspace_info *>(_registry.lookup_info(ds_cap));
if (!ds_info) {
PERR("RAM free: dataspace lookup failed");
return;
}
_registry.remove(ds_info);
_list.remove(ds_info);
_used_quota -= ds_info->size();
env()->ram_session()->free(ds_cap);
Genode::destroy(env()->heap(), ds_info);
}
int ref_account(Ram_session_capability) { return 0; }
int transfer_quota(Ram_session_capability, size_t) { return 0; }
size_t quota() { return env()->ram_session()->quota(); }
size_t used() { return _used_quota; }
};
Rpc_entrypoint &ep;
/**
* Used to record all RM attachements
* Registry of dataspaces owned by the Noux process
*/
struct Local_rm_session : Rpc_object<Rm_session>
{
struct Region : List<Region>::Element
{
Dataspace_capability ds;
size_t size;
off_t offset;
addr_t local_addr;
Region(Dataspace_capability ds, size_t size,
off_t offset, addr_t local_addr)
:
ds(ds), size(size),
offset(offset), local_addr(local_addr)
{ }
/**
* Return true if region contains specified address
*/
bool contains(addr_t addr) const
{
return (addr >= local_addr)
&& (addr < local_addr + size);
}
};
Rm_connection _rm;
Dataspace_registry &_ds_registry;
List<Region> _regions;
Region *_lookup_region_by_addr(addr_t local_addr)
{
Region *curr = _regions.first();
for (; curr; curr = curr->next()) {
if (curr->contains(local_addr))
return curr;
}
return 0;
}
Local_rm_session(Dataspace_registry &ds_registry,
addr_t start = ~0UL, size_t size = 0)
: _rm(start, size), _ds_registry(ds_registry) { }
~Local_rm_session()
{
Region *curr = 0;
for (; curr; curr = curr->next())
detach(curr->local_addr);
}
/**
* Replay attachments onto specified RM session
*
* \param dst_ram backing store used for allocating the
* the copies of RAM dataspaces
*/
void replay(Ram_session_capability dst_ram,
Rm_session_capability dst_rm,
Dataspace_registry &ds_registry,
Rpc_entrypoint &ep)
{
/*
* XXX remove this
*/
struct Dummy_destroyer : Dataspace_destroyer
{
void destroy(Dataspace_capability) { }
};
static Dummy_destroyer dummy_destroyer;
Region *curr = _regions.first();
for (; curr; curr = curr->next()) {
Dataspace_capability ds;
Dataspace_info *info = _ds_registry.lookup_info(curr->ds);
if (info) {
/*
* XXX using 'this' as destroyer may be false,
* the destroyer should better correspond to
* dst_ram.
*/
ds = info->fork(dst_ram,
dummy_destroyer,
ds_registry,
ep);
if (!ds.valid())
PERR("replay: Error while forking dataspace");
/*
* XXX We could detect dataspaces that are
* attached more than once. For now, we
* create a new fork for each attachment.
*/
} else {
/*
* If the dataspace is not a RAM dataspace,
* assume that it's a ROM dataspace.
*
* XXX Handle ROM dataspaces explicitly. For
* once, we need to make sure that they
* remain available until the child process
* exits even if the parent process exits
* earlier. Furthermore, we would like to
* detect unexpected dataspaces.
*/
ds = curr->ds;
PWRN("replay: unknown dataspace type, assume ROM");
}
Rm_session_client(dst_rm).attach(ds, curr->size,
curr->offset,
true,
curr->local_addr);
}
}
void poke(addr_t dst_addr, void const *src, size_t len)
{
Region *region = _lookup_region_by_addr(dst_addr);
if (!region) {
PERR("poke: no region at 0x%lx", dst_addr);
return;
}
/*
* Test if start and end address occupied by the object
* type refers to the same region.
*/
if (region != _lookup_region_by_addr(dst_addr + len - 1)) {
PERR("attempt to write beyond region boundary");
return;
}
Dataspace_info *info = _ds_registry.lookup_info(region->ds);
if (!info) {
PERR("attempt to write to unknown dataspace type");
for (;;);
return;
}
if (region->offset) {
PERR("poke: writing to region with offset is not supported");
return;
}
info->poke(dst_addr - region->local_addr, src, len);
}
/**************************
** RM session interface **
**************************/
Local_addr attach(Dataspace_capability ds,
size_t size = 0, off_t offset = 0,
bool use_local_addr = false,
Local_addr local_addr = (addr_t)0)
{
if (size == 0)
size = Dataspace_client(ds).size();
/*
* XXX look if we can identify the specified dataspace.
* Is it a dataspace allocated via 'Local_ram_session'?
*/
local_addr = _rm.attach(ds, size, offset,
use_local_addr, local_addr);
/*
* Record attachement for later replay (needed during
* fork)
*/
_regions.insert(new (Genode::env()->heap())
Region(ds, size, offset, local_addr));
return local_addr;
}
void detach(Local_addr local_addr)
{
_rm.detach(local_addr);
Region *region = _lookup_region_by_addr(local_addr);
if (!region) {
PWRN("Attempt to detach unknown region at 0x%p",
(void *)local_addr);
return;
}
_regions.remove(region);
destroy(Genode::env()->heap(), region);
}
Pager_capability add_client(Thread_capability thread)
{
return _rm.add_client(thread);
}
void fault_handler(Signal_context_capability handler)
{
return _rm.fault_handler(handler);
}
State state()
{
return _rm.state();
}
Dataspace_capability dataspace()
{
return _rm.dataspace();
}
};
struct Sub_rm_dataspace_info : Dataspace_info
{
struct Dummy_destroyer : Dataspace_destroyer
{
void destroy(Dataspace_capability) { }
} _dummy_destroyer;
Local_rm_session &_sub_rm;
Sub_rm_dataspace_info(Local_rm_session &sub_rm)
:
Dataspace_info(sub_rm.dataspace(), _dummy_destroyer),
_sub_rm(sub_rm)
{ }
Dataspace_capability fork(Ram_session_capability ram,
Dataspace_destroyer &destoyer,
Dataspace_registry &ds_registry,
Rpc_entrypoint &ep)
{
Local_rm_session *new_sub_rm =
new Local_rm_session(ds_registry, 0, size());
Rm_session_capability rm_cap = ep.manage(new_sub_rm);
_sub_rm.replay(ram, rm_cap, ds_registry, ep);
ds_registry.insert(new Sub_rm_dataspace_info(*new_sub_rm));
return new_sub_rm->dataspace();
}
void poke(addr_t dst_offset, void const *src, size_t len)
{
if ((dst_offset >= size()) || (dst_offset + len > size())) {
PERR("illegal attemt to write beyond RM boundary");
return;
}
_sub_rm.poke(dst_offset, src, len);
}
};
Dataspace_registry ds_registry;
/**
* Used to defer the execution of the process' main thread
* Locally-provided services for accessing platform resources
*/
struct Local_cpu_session : Rpc_object<Cpu_session>
{
bool const forked;
Cpu_connection cpu;
Thread_capability main_thread;
Local_cpu_session(char const *label, bool forked)
: forked(forked), cpu(label) { }
Thread_capability create_thread(Name const &name)
{
/*
* Prevent any attempt to create more than the main
* thread.
*/
if (main_thread.valid()) {
PWRN("Invalid attempt to create a thread besides main");
while (1);
return Thread_capability();
}
main_thread = cpu.create_thread(name);
PINF("created main thread");
return main_thread;
}
void kill_thread(Thread_capability thread) {
cpu.kill_thread(thread); }
Thread_capability first() {
return cpu.first(); }
Thread_capability next(Thread_capability curr) {
return cpu.next(curr); }
int set_pager(Thread_capability thread,
Pager_capability pager) {
return cpu.set_pager(thread, pager); }
int start(Thread_capability thread, addr_t ip, addr_t sp)
{
if (forked) {
PINF("defer attempt to start thread at ip 0x%lx", ip);
return 0;
}
return cpu.start(thread, ip, sp);
}
void pause(Thread_capability thread) {
cpu.pause(thread); }
void resume(Thread_capability thread) {
cpu.resume(thread); }
void cancel_blocking(Thread_capability thread) {
cpu.cancel_blocking(thread); }
int state(Thread_capability thread, Thread_state *dst) {
return cpu.state(thread, dst); }
void exception_handler(Thread_capability thread,
Signal_context_capability handler) {
cpu.exception_handler(thread, handler); }
void single_step(Thread_capability thread, bool enable) {
cpu.single_step(thread, enable); }
/**
* Explicitly start main thread, only meaningful when
* 'forked' is true
*/
void start_main_thread(addr_t ip, addr_t sp)
{
cpu.start(main_thread, ip, sp);
}
};
Rpc_entrypoint &ep;
Dataspace_registry ds_registry;
Local_ram_session ram;
Local_cpu_session cpu;
Local_rm_session rm;
Ram_session_component ram;
Cpu_session_component cpu;
Rm_session_component rm;
Resources(char const *label, Rpc_entrypoint &ep, bool forked)
:
@ -818,41 +241,7 @@ namespace Noux {
} _local_noux_service;
struct Local_sub_rm_service : public Service
{
Rpc_entrypoint &_ep;
Resources::Dataspace_registry &_ds_registry;
Local_sub_rm_service(Rpc_entrypoint &ep,
Resources::Dataspace_registry &ds_registry)
:
Service(Rm_session::service_name()),
_ep(ep), _ds_registry(ds_registry)
{ }
Genode::Session_capability session(const char *args)
{
addr_t start = Arg_string::find_arg(args, "start").ulong_value(~0UL);
size_t size = Arg_string::find_arg(args, "size").ulong_value(0);
Resources::Local_rm_session *rm =
new Resources::Local_rm_session(_ds_registry, start, size);
Genode::Session_capability cap = _ep.manage(rm);
_ds_registry.insert(new Resources::Sub_rm_dataspace_info(*rm));
return cap;
}
void upgrade(Genode::Session_capability, const char *args) { }
void close(Genode::Session_capability)
{
PWRN("Local_sub_rm_service::close not implemented, leaking memory");
}
} _local_sub_rm_service;
Local_rm_service _local_rm_service;
/**
* Exception type for failed file-descriptor lookup
@ -891,16 +280,16 @@ namespace Noux {
* or children created via execve, or
* true if the child is a fork from another child
*/
Child(char const *name,
int pid,
Signal_receiver *sig_rec,
Vfs *vfs,
Args const &args,
char const *env,
Cap_session *cap_session,
Service_registry *parent_services,
Rpc_entrypoint &resources_ep,
bool forked)
Child(char const *name,
int pid,
Signal_receiver *sig_rec,
Vfs *vfs,
Args const &args,
char const *env,
Cap_session *cap_session,
Service_registry *parent_services,
Rpc_entrypoint &resources_ep,
bool forked)
:
_pid(pid),
_sig_rec(sig_rec),
@ -927,7 +316,7 @@ namespace Noux {
_sysio(_sysio_ds.local_addr<Sysio>()),
_noux_session_cap(Session_capability(_entrypoint.manage(this))),
_local_noux_service(_noux_session_cap),
_local_sub_rm_service(_entrypoint, _resources.ds_registry)
_local_rm_service(_entrypoint, _resources.ds_registry)
{
_args.dump();
strncpy(_name, name, sizeof(_name));
@ -954,8 +343,7 @@ namespace Noux {
Ram_session_capability ram() const { return _resources.ram.cap(); }
Rm_session_capability rm() const { return _resources.rm.cap(); }
Resources::Dataspace_registry &ds_registry() { return _resources.ds_registry; }
Dataspace_registry &ds_registry() { return _resources.ds_registry; }
/****************************
@ -985,7 +373,7 @@ namespace Noux {
* space.
*/
if (strcmp(service_name, Rm_session::service_name()) == 0)
return &_local_sub_rm_service;
return &_local_rm_service;
return _parent_services->find(service_name);
}

134
ports/src/noux/cpu_session_component.h Normal file
View File

@ -0,0 +1,134 @@
/*
* \brief CPU session provided to Noux processes
* \author Norman Feske
* \date 2012-02-22
*
* The custom implementation of the CPU session interface is used to tweak
* the startup procedure as performed by the 'Process' class. Normally,
* processes start execution immediately at creation time at the ELF entry
* point. For implementing fork semantics, however, this default behavior
* does not work. Instead, we need to defer the start of the main thread
* until we have finished copying the address space of the forking process.
* Furthermore, we need to start the main thread at a custom trampoline
* function rather than at the ELF entry point. Those customizations are
* possible by wrapping core's CPU service.
*/
/*
* Copyright (C) 2012 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.
*/
#ifndef _NOUX__CPU_SESSION_COMPONENT_H_
#define _NOUX__CPU_SESSION_COMPONENT_H_
/* Genode includes */
#include <base/rpc_server.h>
#include <cpu_session/connection.h>
namespace Noux {
using namespace Genode;
class Cpu_session_component : public Rpc_object<Cpu_session>
{
private:
bool const _forked;
Cpu_connection _cpu;
Thread_capability _main_thread;
public:
/**
* Constructor
*
* \param forked false if the CPU session belongs to a child
* created via execve or to the init process, or
* true if the CPU session belongs to a newly forked
* process.
*
* The 'forked' parameter controls the policy applied to the
* startup of the main thread.
*/
Cpu_session_component(char const *label, bool forked)
: _forked(forked), _cpu(label) { }
/**
* Explicitly start main thread, only meaningful when
* 'forked' is true
*/
void start_main_thread(addr_t ip, addr_t sp)
{
_cpu.start(_main_thread, ip, sp);
}
/***************************
** Cpu_session interface **
***************************/
Thread_capability create_thread(Name const &name)
{
/*
* Prevent any attempt to create more than the main
* thread.
*/
if (_main_thread.valid()) {
PWRN("Invalid attempt to create a thread besides main");
while (1);
return Thread_capability();
}
_main_thread = _cpu.create_thread(name);
PINF("created main thread");
return _main_thread;
}
void kill_thread(Thread_capability thread) {
_cpu.kill_thread(thread); }
Thread_capability first() {
return _cpu.first(); }
Thread_capability next(Thread_capability curr) {
return _cpu.next(curr); }
int set_pager(Thread_capability thread,
Pager_capability pager) {
return _cpu.set_pager(thread, pager); }
int start(Thread_capability thread, addr_t ip, addr_t sp)
{
if (_forked) {
PINF("defer attempt to start thread at ip 0x%lx", ip);
return 0;
}
return _cpu.start(thread, ip, sp);
}
void pause(Thread_capability thread) {
_cpu.pause(thread); }
void resume(Thread_capability thread) {
_cpu.resume(thread); }
void cancel_blocking(Thread_capability thread) {
_cpu.cancel_blocking(thread); }
int state(Thread_capability thread, Thread_state *dst) {
return _cpu.state(thread, dst); }
void exception_handler(Thread_capability thread,
Signal_context_capability handler) {
_cpu.exception_handler(thread, handler); }
void single_step(Thread_capability thread, bool enable) {
_cpu.single_step(thread, enable); }
};
}
#endif /* _NOUX__CPU_SESSION_COMPONENT_H_ */

112
ports/src/noux/dataspace_registry.h Normal file
View File

@ -0,0 +1,112 @@
/*
* \brief Registry for dataspaces used by noux processes
* \author Norman Feske
* \date 2012-02-22
*/
/*
* Copyright (C) 2012 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.
*/
#ifndef _NOUX__DATASPACE_REGISTRY_H_
#define _NOUX__DATASPACE_REGISTRY_H_
/* Genode includes */
#include <base/object_pool.h>
namespace Noux {
using namespace Genode;
/*
* XXX not used yet
*/
struct Dataspace_destroyer
{
virtual void destroy(Dataspace_capability) = 0;
};
class Dataspace_registry;
class Dataspace_info : public Object_pool<Dataspace_info>::Entry
{
private:
size_t _size;
Dataspace_capability _ds_cap;
Dataspace_destroyer &_destroyer;
public:
Dataspace_info(Dataspace_capability ds_cap,
Dataspace_destroyer &destroyer)
:
Object_pool<Dataspace_info>::Entry(ds_cap),
_size(Dataspace_client(ds_cap).size()),
_ds_cap(ds_cap),
_destroyer(destroyer)
{ }
size_t size() const { return _size; }
Dataspace_capability ds_cap() const { return _ds_cap; }
/**
* Create shadow copy of dataspace
*
* \param ds_registry registry for keeping track of
* the new dataspace
* \param ep entrypoint used to serve the RPC
* interface of the new dataspace
* (used if the dataspace is a sub
* RM session)
* \return capability for the new dataspace
*/
virtual Dataspace_capability fork(Ram_session_capability ram,
Dataspace_destroyer &destroyer,
Dataspace_registry &ds_registry,
Rpc_entrypoint &ep) = 0;
/**
* Write raw byte sequence into dataspace
*
* \param dst_offset destination offset within dataspace
* \param src data source buffer
* \param len length of source buffer in bytes
*/
virtual void poke(addr_t dst_offset, void const *src, size_t len) = 0;
Dataspace_destroyer &destroyer() { return _destroyer; }
};
class Dataspace_registry
{
private:
Object_pool<Dataspace_info> _pool;
public:
void insert(Dataspace_info *info)
{
_pool.insert(info);
}
void remove(Dataspace_info *info)
{
_pool.remove(info);
}
Dataspace_info *lookup_info(Dataspace_capability ds_cap)
{
return _pool.obj_by_cap(ds_cap);
}
};
}
#endif /* _NOUX__DATASPACE_REGISTRY_H_ */

119
ports/src/noux/local_rm_service.h Normal file
View File

@ -0,0 +1,119 @@
/*
* \brief RM service provided to Noux processes
* \author Norman Feske
* \date 2012-02-22
*/
/*
* Copyright (C) 2012 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.
*/
#ifndef _NOUX__LOCAL_RM_SERVICE_H_
#define _NOUX__LOCAL_RM_SERVICE_H_
/* Genode includes */
#include <base/service.h>
/* Noux includes */
#include <dataspace_registry.h>
#include <rm_session_component.h>
namespace Noux {
using namespace Genode;
class Rm_dataspace_info : public Dataspace_info
{
private:
struct Dummy_destroyer : Dataspace_destroyer
{
void destroy(Dataspace_capability) { }
} _dummy_destroyer;
Rm_session_component &_sub_rm;
public:
Rm_dataspace_info(Rm_session_component &sub_rm)
:
Dataspace_info(sub_rm.dataspace(), _dummy_destroyer),
_sub_rm(sub_rm)
{ }
Dataspace_capability fork(Ram_session_capability ram,
Dataspace_destroyer &,
Dataspace_registry &ds_registry,
Rpc_entrypoint &ep)
{
Rm_session_component *new_sub_rm =
new Rm_session_component(ds_registry, 0, size());
Rm_session_capability rm_cap = ep.manage(new_sub_rm);
/*
* XXX Where to dissolve the RM session?
*/
_sub_rm.replay(ram, rm_cap, ds_registry, ep);
ds_registry.insert(new Rm_dataspace_info(*new_sub_rm));
return new_sub_rm->dataspace();
}
void poke(addr_t dst_offset, void const *src, size_t len)
{
if ((dst_offset >= size()) || (dst_offset + len > size())) {
PERR("illegal attemt to write beyond RM boundary");
return;
}
_sub_rm.poke(dst_offset, src, len);
}
};
class Local_rm_service : public Service
{
private:
Rpc_entrypoint &_ep;
Dataspace_registry &_ds_registry;
public:
Local_rm_service(Rpc_entrypoint &ep, Dataspace_registry &ds_registry)
:
Service(Rm_session::service_name()), _ep(ep),
_ds_registry(ds_registry)
{ }
Genode::Session_capability session(const char *args)
{
addr_t start = Arg_string::find_arg(args, "start").ulong_value(~0UL);
size_t size = Arg_string::find_arg(args, "size").ulong_value(0);
Rm_session_component *rm =
new Rm_session_component(_ds_registry, start, size);
Genode::Session_capability cap = _ep.manage(rm);
_ds_registry.insert(new Rm_dataspace_info(*rm));
return cap;
}
void upgrade(Genode::Session_capability, const char *args) { }
void close(Genode::Session_capability)
{
PWRN("Local_rm_service::close not implemented, leaking memory");
}
};
}
#endif /* _NOUX__LOCAL_RM_SERVICE_H_ */

7
ports/src/noux/main.cc
View File

@ -435,6 +435,13 @@ static char const *env_string_of_init_process()
}
Noux::Pid_allocator *Noux::pid_allocator()
{
static Noux::Pid_allocator inst;
return &inst;
}
void *operator new (Genode::size_t size) {
return Genode::env()->heap()->alloc(size); }

196
ports/src/noux/ram_session_component.h Normal file
View File

@ -0,0 +1,196 @@
/*
* \brief RAM service used by Noux processes
* \author Norman Feske
* \date 2012-02-22
*
* The custom implementation of the RAM session interface provides a pool of
* RAM shared by Noux and all Noux processes. The use of a shared pool
* alleviates the need to assign RAM quota to individual Noux processes.
*
* Furthermore, the custom implementation is needed to get hold of the RAM
* dataspaces allocated by each Noux process. When forking a process, the
* acquired information (in the form of 'Ram_dataspace_info' objects) is used
* to create a shadow copy of the forking address space.
*/
/*
* Copyright (C) 2012 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.
*/
#ifndef _NOUX__RAM_SESSION_COMPONENT_H_
#define _NOUX__RAM_SESSION_COMPONENT_H_
/* Genode includes */
#include <ram_session/capability.h>
#include <base/rpc_server.h>
#include <base/env.h>
/* Noux includes */
#include <dataspace_registry.h>
namespace Noux {
using namespace Genode;
struct Ram_dataspace_info : Dataspace_info,
List<Ram_dataspace_info>::Element
{
Ram_dataspace_info(Ram_dataspace_capability ds_cap,
Dataspace_destroyer &destroyer)
: Dataspace_info(ds_cap, destroyer) { }
Dataspace_capability fork(Ram_session_capability ram,
Dataspace_destroyer &destroyer,
Dataspace_registry &,
Rpc_entrypoint &)
{
size_t const size = Dataspace_client(ds_cap()).size();
Ram_dataspace_capability dst_ds;
try {
dst_ds = Ram_session_client(ram).alloc(size);
} catch (...) {
return Dataspace_capability();
}
void *src = 0;
try {
src = Genode::env()->rm_session()->attach(ds_cap());
} catch (...) { }
void *dst = 0;
try {
dst = Genode::env()->rm_session()->attach(dst_ds);
} catch (...) { }
if (src && dst)
memcpy(dst, src, size);
if (src) Genode::env()->rm_session()->detach(src);
if (dst) Genode::env()->rm_session()->detach(dst);
if (!src || !dst) {
Ram_session_client(ram).free(dst_ds);
return Dataspace_capability();
}
return dst_ds;
}
void poke(addr_t dst_offset, void const *src, size_t len)
{
if ((dst_offset >= size()) || (dst_offset + len > size())) {
PERR("illegal attemt to write beyond dataspace boundary");
return;
}
char *dst = 0;
try {
dst = Genode::env()->rm_session()->attach(ds_cap());
} catch (...) { }
if (src && dst)
memcpy(dst + dst_offset, src, len);
if (dst) Genode::env()->rm_session()->detach(dst);
}
};
class Ram_session_component : public Rpc_object<Ram_session>,
public Dataspace_destroyer
{
private:
List<Ram_dataspace_info> _list;
/*
* Track the RAM resources accumulated via RAM session allocations.
*
* XXX not used yet
*/
size_t _used_quota;
Dataspace_registry &_registry;
public:
/**
* Constructor
*/
Ram_session_component(Dataspace_registry &registry)
: _used_quota(0), _registry(registry) { }
/**
* Destructor
*/
~Ram_session_component()
{
Ram_dataspace_info *info = 0;
while ((info = _list.first()))
free(static_cap_cast<Ram_dataspace>(info->ds_cap()));
}
/***********************************
** Dataspace_destroyer interface **
***********************************/
/*
* XXX not used yet
*/
void destroy(Dataspace_capability ds)
{
free(static_cap_cast<Ram_dataspace>(ds));
}
/***************************
** Ram_session interface **
***************************/
Ram_dataspace_capability alloc(size_t size)
{
Ram_dataspace_capability ds_cap = env()->ram_session()->alloc(size);
Ram_dataspace_info *ds_info = new (env()->heap())
Ram_dataspace_info(ds_cap, *this);
_used_quota += ds_info->size();
_registry.insert(ds_info);
_list.insert(ds_info);
return ds_cap;
}
void free(Ram_dataspace_capability ds_cap)
{
Ram_dataspace_info *ds_info =
dynamic_cast<Ram_dataspace_info *>(_registry.lookup_info(ds_cap));
if (!ds_info) {
PERR("RAM free: dataspace lookup failed");
return;
}
_registry.remove(ds_info);
_list.remove(ds_info);
_used_quota -= ds_info->size();
env()->ram_session()->free(ds_cap);
Genode::destroy(env()->heap(), ds_info);
}
int ref_account(Ram_session_capability) { return 0; }
int transfer_quota(Ram_session_capability, size_t) { return 0; }
size_t quota() { return env()->ram_session()->quota(); }
size_t used() { return _used_quota; }
};
}
#endif /* _NOUX__RAM_SESSION_COMPONENT_H_ */

265
ports/src/noux/rm_session_component.h Normal file
View File

@ -0,0 +1,265 @@
/*
* \brief RM session implementation used by Noux processes
* \author Norman Feske
* \date 2012-02-22
*
* The custom RM implementation is used for recording all RM regions attached
* to the region-manager session. Using the recorded information, the address-
* space layout can then be replayed onto a new process created via fork.
*/
/*
* Copyright (C) 2012 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.
*/
#ifndef _NOUX__RM_SESSION_COMPONENT_H_
#define _NOUX__RM_SESSION_COMPONENT_H_
/* Genode includes */
#include <rm_session/connection.h>
#include <base/rpc_server.h>
namespace Noux {
using namespace Genode;
class Rm_session_component : public Rpc_object<Rm_session>
{
private:
/**
* Record of an attached dataspace
*/
struct Region : List<Region>::Element
{
Dataspace_capability ds;
size_t size;
off_t offset;
addr_t local_addr;
Region(Dataspace_capability ds, size_t size,
off_t offset, addr_t local_addr)
:
ds(ds), size(size), offset(offset), local_addr(local_addr)
{ }
/**
* Return true if region contains specified address
*/
bool contains(addr_t addr) const
{
return (addr >= local_addr)
&& (addr < local_addr + size);
}
};
List<Region> _regions;
Region *_lookup_region_by_addr(addr_t local_addr)
{
Region *curr = _regions.first();
for (; curr; curr = curr->next()) {
if (curr->contains(local_addr))
return curr;
}
return 0;
}
/**
* Wrapped RM session at core
*/
Rm_connection _rm;
Dataspace_registry &_ds_registry;
public:
Rm_session_component(Dataspace_registry &ds_registry,
addr_t start = ~0UL, size_t size = 0)
:
_rm(start, size), _ds_registry(ds_registry)
{ }
~Rm_session_component()
{
Region *curr = 0;
for (; curr; curr = curr->next())
detach(curr->local_addr);
}
/**
* Replay attachments onto specified RM session
*
* \param dst_ram backing store used for allocating the
* the copies of RAM dataspaces
* \param ds_registry dataspace registry used for keeping track
* of newly created dataspaces
* \param ep entrypoint used to serve the RPC interface
* of forked managed dataspaces
*/
void replay(Ram_session_capability dst_ram,
Rm_session_capability dst_rm,
Dataspace_registry &ds_registry,
Rpc_entrypoint &ep)
{
/*
* XXX remove this
*/
struct Dummy_destroyer : Dataspace_destroyer
{
void destroy(Dataspace_capability) { }
};
static Dummy_destroyer dummy_destroyer;
for (Region *curr = _regions.first(); curr; curr = curr->next()) {
Dataspace_capability ds;
Dataspace_info *info = _ds_registry.lookup_info(curr->ds);
if (info) {
/*
* XXX Using 'this' as destroyer may be false, the
* destroyer should better correspond to dst_ram.
*/
ds = info->fork(dst_ram, dummy_destroyer, ds_registry, ep);
/*
* XXX We could detect dataspaces that are attached
* more than once. For now, we create a new fork
* for each attachment.
*/
} else {
/*
* If the dataspace is not a RAM dataspace, assume that
* it's a ROM dataspace.
*
* XXX Handle ROM dataspaces explicitly. For once, we
* need to make sure that they remain available
* until the child process exits even if the parent
* process exits earlier. Furthermore, we would
* like to detect unexpected dataspaces.
*/
ds = curr->ds;
PWRN("replay: unknown dataspace type, assume ROM");
}
if (!ds.valid()) {
PERR("replay: Error while forking dataspace");
continue;
}
Rm_session_client(dst_rm).attach(ds, curr->size,
curr->offset,
true,
curr->local_addr);
}
}
void poke(addr_t dst_addr, void const *src, size_t len)
{
Region *region = _lookup_region_by_addr(dst_addr);
if (!region) {
PERR("poke: no region at 0x%lx", dst_addr);
return;
}
/*
* Test if start and end address occupied by the object
* type refers to the same region.
*/
if (region != _lookup_region_by_addr(dst_addr + len - 1)) {
PERR("attempt to write beyond region boundary");
return;
}
Dataspace_info *info = _ds_registry.lookup_info(region->ds);
if (!info) {
PERR("attempt to write to unknown dataspace type");
for (;;);
return;
}
if (region->offset) {
PERR("poke: writing to region with offset is not supported");
return;
}
info->poke(dst_addr - region->local_addr, src, len);
}
/**************************
** RM session interface **
**************************/
Local_addr attach(Dataspace_capability ds,
size_t size = 0, off_t offset = 0,
bool use_local_addr = false,
Local_addr local_addr = (addr_t)0)
{
if (size == 0)
size = Dataspace_client(ds).size();
/*
* XXX look if we can identify the specified dataspace.
* Is it a dataspace allocated via 'Local_ram_session'?
*/
local_addr = _rm.attach(ds, size, offset,
use_local_addr, local_addr);
/*
* Record attachement for later replay (needed during
* fork)
*/
_regions.insert(new (Genode::env()->heap())
Region(ds, size, offset, local_addr));
return local_addr;
}
void detach(Local_addr local_addr)
{
_rm.detach(local_addr);
Region *region = _lookup_region_by_addr(local_addr);
if (!region) {
PWRN("Attempt to detach unknown region at 0x%p",
(void *)local_addr);
return;
}
_regions.remove(region);
destroy(Genode::env()->heap(), region);
}
Pager_capability add_client(Thread_capability thread)
{
return _rm.add_client(thread);
}
void fault_handler(Signal_context_capability handler)
{
return _rm.fault_handler(handler);
}
State state()
{
return _rm.state();
}
Dataspace_capability dataspace()
{
return _rm.dataspace();
}
};
}
#endif /* _NOUX__RM_SESSION_COMPONENT_H_ */