ExternalVendorCode/genode
1
0
Fork 0
mirror of https://github.com/genodelabs/genode.git synced 2025-01-18 10:46:25 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

base: make PD session upgradeable

Browse Source 
Ref #1443
This commit is contained in:
Stefan Kalkowski 2015-05-05 08:50:16 +02:00 committed by Christian Helmuth
parent 2d41f13229
commit 73c3a81e0b
38 changed files with 250 additions and 146 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

9
repos/base-codezero/src/core/include/platform_pd.h
View File

@ -45,14 +45,19 @@ namespace Genode {
* Constructors
*/
Platform_pd(bool core);
Platform_pd(Allocator * md_alloc, size_t ram_quota,
char const *, signed pd_id = -1, bool create = true);
Platform_pd(Allocator * md_alloc, char const *,
signed pd_id = -1, bool create = true);
/**
* Destructor
*/
~Platform_pd();
/**
* Register quota donation at allocator guard
*/
void upgrade_ram_quota(size_t ram_quota) { }
/**
* Bind thread to protection domain
*

4
repos/base-codezero/src/core/platform_pd.cc
View File

@ -98,8 +98,8 @@ Platform_pd::Platform_pd(bool core)
}
Platform_pd::Platform_pd(Allocator * md_alloc, size_t ram_quota,
char const *, signed pd_id, bool create)
Platform_pd::Platform_pd(Allocator * md_alloc, char const *,
signed pd_id, bool create)
: _space_id(TASK_ID_INVALID)
{
_space_id = TASK_ID_INVALID;

10
repos/base-fiasco/src/core/include/platform_pd.h
View File

@ -143,15 +143,19 @@ namespace Genode {
/**
* Constructor
*/
Platform_pd(Allocator * md_alloc, size_t ram_quota,
char const *, signed pd_id = PD_INVALID,
bool create = true);
Platform_pd(Allocator * md_alloc, char const *,
signed pd_id = PD_INVALID, bool create = true);
/**
* Destructor
*/
~Platform_pd();
/**
* Register quota donation at allocator guard
*/
void upgrade_ram_quota(size_t ram_quota) { }
/**
* Initialize L4 task facility
*/

2
repos/base-fiasco/src/core/platform.cc
View File

@ -490,7 +490,7 @@ Platform::Platform() :
/* setup pd object for core pd */
_core_label[0] = 0;
_core_pd = new(core_mem_alloc()) Platform_pd(nullptr, 0, _core_label,
_core_pd = new(core_mem_alloc()) Platform_pd(nullptr, _core_label,
myself.id.task, false);
/*

4
repos/base-fiasco/src/core/platform_pd.cc
View File

@ -236,8 +236,8 @@ void Platform_pd::unbind_thread(Platform_thread *thread)
}
Platform_pd::Platform_pd(Allocator * md_alloc, size_t ram_quota,
char const *, signed pd_id, bool create)
Platform_pd::Platform_pd(Allocator * md_alloc, char const *,
signed pd_id, bool create)
{
/* check correct init */
if (!_init)

5
repos/base-foc/src/core/include/pd_session_component.h
View File

@ -38,6 +38,11 @@ namespace Genode {
Allocator *md_alloc, const char *args)
: _thread_ep(thread_ep) { }
/**
* Register quota donation at allocator guard
*/
void upgrade_ram_quota(size_t ram_quota) { }
/**************************
** PD session interface **

3
repos/base-hw/src/core/include/platform_pd.h
View File

@ -66,8 +66,7 @@ namespace Genode
*
* \param label name of protection domain
*/
Platform_pd(Allocator * md_alloc, size_t ram_quota,
char const *label)
Platform_pd(Allocator * md_alloc, char const *label)
: _main_thread(0), _label(label),
_kernel_pd(reinterpret_cast<Kernel::Pd*>(_kernel_pd_data))
{

2
repos/base-linux/include/pd_session/connection.h
View File

@ -79,6 +79,8 @@ namespace Genode {
public:
enum { RAM_QUOTA = 4*1024 };
/**
* Constructor
*

12
repos/base-linux/src/base/process/process.cc
View File

@ -53,21 +53,22 @@ static bool _check_dynamic_elf(Dataspace_capability elf_ds_cap)
Process::Process(Dataspace_capability elf_data_ds_cap,
Pd_session_capability pd_session_cap,
Ram_session_capability ram_session_cap,
Cpu_session_capability cpu_session_cap,
Rm_session_capability rm_session_cap,
Parent_capability parent_cap,
char const *name,
Native_pd_args const *pd_args)
char const *name)
:
_pd(name, pd_args),
_pd_session_client(pd_session_cap),
_cpu_session_client(cpu_session_cap),
_rm_session_client(Rm_session_capability())
{
/* check for dynamic program header */
if (_check_dynamic_elf(elf_data_ds_cap)) {
if (!_dynamic_linker_cap.valid()) {
PERR("Dynamically linked file found, but no dynamic linker binary present");
PERR("Dynamically linked file found, "
"but no dynamic linker binary present");
return;
}
elf_data_ds_cap = _dynamic_linker_cap;
@ -83,7 +84,8 @@ Process::Process(Dataspace_capability elf_data_ds_cap,
enum { WEIGHT = Cpu_session::DEFAULT_WEIGHT };
_thread0_cap = _cpu_session_client.create_thread(WEIGHT, name);
Linux_pd_session_client lx_pd(static_cap_cast<Linux_pd_session>(_pd.cap()));
Linux_pd_session_client
lx_pd(static_cap_cast<Linux_pd_session>(pd_session_cap));
lx_pd.assign_parent(parent_cap);
lx_pd.start(elf_data_ds_cap);

5
repos/base-linux/src/core/include/pd_session_component.h
View File

@ -53,6 +53,11 @@ namespace Genode {
~Pd_session_component();
/**
* Register quota donation at allocator guard
*/
void upgrade_ram_quota(size_t ram_quota) { }
/**************************
** PD session interface **

9
repos/base-nova/src/core/include/pd_session_component.h
View File

@ -55,11 +55,14 @@ namespace Genode {
Pd_session_component(Rpc_entrypoint *thread_ep,
Allocator * md_alloc, char const *args)
: _label(args),
_pd(md_alloc,
Arg_string::find_arg(args, "ram_quota").long_value(0),
_label.string),
_pd(md_alloc, _label.string),
_thread_ep(thread_ep) { }
/**
* Register quota donation at allocator guard
*/
void upgrade_ram_quota(size_t ram_quota) { }
/**************************/
/** PD session interface **/

4
repos/base-nova/src/core/include/platform_pd.h
View File

@ -40,8 +40,8 @@ namespace Genode {
/**
* Constructors
*/
Platform_pd(Allocator * md_alloc, size_t ram_quota,
char const *, signed pd_id = -1, bool create = true);
Platform_pd(Allocator * md_alloc, char const *,
signed pd_id = -1, bool create = true);
/**
* Destructor

4
repos/base-nova/src/core/platform_pd.cc
View File

@ -46,8 +46,8 @@ int Platform_pd::assign_parent(Native_capability parent)
}
Platform_pd::Platform_pd(Allocator * md_alloc, size_t ram_quota,
char const *, signed pd_id, bool create)
Platform_pd::Platform_pd(Allocator * md_alloc, char const *,
signed pd_id, bool create)
: _thread_cnt(0), _pd_sel(~0UL) { }

5
repos/base-okl4/src/core/include/pd_session_component.h
View File

@ -37,6 +37,11 @@ namespace Genode {
Allocator *md_alloc, const char *args)
: _thread_ep(thread_ep) { }
/**
* Register quota donation at allocator guard
*/
void upgrade_ram_quota(size_t ram_quota) { }
/**************************
** Pd session interface **

10
repos/base-pistachio/src/core/include/platform_pd.h
View File

@ -184,15 +184,19 @@ namespace Genode {
* Constructors
*/
Platform_pd(bool core);
Platform_pd(Allocator * md_alloc, size_t ram_quota,
char const *, signed pd_id = PD_INVALID,
bool create = true);
Platform_pd(Allocator * md_alloc, char const *,
signed pd_id = PD_INVALID, bool create = true);
/**
* Destructor
*/
~Platform_pd();
/**
* Register quota donation at allocator guard
*/
void upgrade_ram_quota(size_t ram_quota) { }
static Pistachio::L4_Word_t _core_utcb_ptr;
static void touch_utcb_space();

4
repos/base-pistachio/src/core/platform_pd.cc
View File

@ -340,8 +340,8 @@ Platform_pd::Platform_pd(bool core) :
}
Platform_pd::Platform_pd(Allocator * md_alloc, size_t ram_quota,
char const *, signed pd_id, bool create)
Platform_pd::Platform_pd(Allocator * md_alloc, char const *,
signed pd_id, bool create)
{
if (!create)
panic("create must be true.");

8
repos/base-sel4/include/pd_session/connection.h
View File

@ -22,15 +22,17 @@ namespace Genode { struct Pd_connection; }
struct Genode::Pd_connection : Connection<Pd_session>, Pd_session_client
{
enum { RAM_QUOTA = 64*1024 };
/**
* Constructor
*
* \param label session label
*/
Pd_connection(char const *label = "", Native_pd_args const *pd_args = 0)
:
Connection<Pd_session>(session("ram_quota=64K, label=\"%s\"", label)),
Pd_session_client(cap())
: Connection<Pd_session>(session("ram_quota=%u, label=\"%s\"",
RAM_QUOTA, label)),
Pd_session_client(cap())
{ }
};

4
repos/base-sel4/src/core/include/platform_pd.h
View File

@ -68,8 +68,8 @@ class Genode::Platform_pd : public Address_space
/**
* Constructors
*/
Platform_pd(Allocator * md_alloc, size_t ram_quota,
char const *, signed pd_id = -1, bool create = true);
Platform_pd(Allocator * md_alloc, char const *,
signed pd_id = -1, bool create = true);
/**
* Destructor

4
repos/base-sel4/src/core/platform_pd.cc
View File

@ -139,8 +139,8 @@ void Platform_pd::flush(addr_t virt_addr, size_t size)
}
Platform_pd::Platform_pd(Allocator * md_alloc, size_t ram_quota,
char const *, signed pd_id, bool create)
Platform_pd::Platform_pd(Allocator * md_alloc, char const *,
signed pd_id, bool create)
:
_id(pd_id_alloc().alloc()),
_page_table_registry(*md_alloc),

16
repos/base/include/base/child.h
View File

@ -161,6 +161,10 @@ class Genode::Child : protected Rpc_object<Parent>
class Session;
/* PD session representing the protection domain of the child */
Pd_session_capability _pd;
Pd_session_client _pd_session_client;
/* RAM session that contains the quota of the child */
Ram_session_capability _ram;
Ram_session_client _ram_session_client;
@ -171,7 +175,8 @@ class Genode::Child : protected Rpc_object<Parent>
/* RM session representing the address space of the child */
Rm_session_capability _rm;
/* Services where the RAM, CPU, and RM resources come from */
/* Services where the PD, RAM, CPU, and RM resources come from */
Service &_pd_service;
Service &_ram_service;
Service &_cpu_service;
Service &_rm_service;
@ -235,12 +240,14 @@ class Genode::Child : protected Rpc_object<Parent>
* Constructor
*
* \param elf_ds dataspace containing the binary
* \param pd PD session representing the protection domain
* \param ram RAM session with the child's quota
* \param cpu CPU session with the child's quota
* \param rm RM session representing the address space
* of the child
* \param entrypoint server entrypoint to serve the parent interface
* \param policy child policy
* \param pd_service provider of the 'pd' session
* \param ram_service provider of the 'ram' session
* \param cpu_service provider of the 'cpu' session
* \param rm_service provider of the 'rm' session
@ -257,11 +264,13 @@ class Genode::Child : protected Rpc_object<Parent>
* resources are provided by the parent.
*/
Child(Dataspace_capability elf_ds,
Pd_session_capability pd,
Ram_session_capability ram,
Cpu_session_capability cpu,
Rm_session_capability rm,
Rpc_entrypoint *entrypoint,
Child_policy *policy,
Service &pd_service = *_parent_service(),
Service &ram_service = *_parent_service(),
Service &cpu_service = *_parent_service(),
Service &rm_service = *_parent_service());
@ -279,10 +288,11 @@ class Genode::Child : protected Rpc_object<Parent>
*/
Allocator *heap() { return &_heap; }
Pd_session_capability pd_session_cap() const { return _pd; }
Ram_session_capability ram_session_cap() const { return _ram; }
Cpu_session_capability cpu_session_cap() const { return _cpu; }
Rm_session_capability rm_session_cap() const { return _rm; }
Parent_capability parent_cap() const { return cap(); }
Rm_session_capability rm_session_cap() const { return _rm; }
Parent_capability parent_cap() const { return cap(); }
/**
* Discard all sessions to specified service

29
repos/base/include/base/process.h
View File

@ -15,8 +15,8 @@
#define _INCLUDE__BASE__PROCESS_H_
#include <ram_session/capability.h>
#include <rm_session/connection.h>
#include <pd_session/connection.h>
#include <rm_session/client.h>
#include <pd_session/client.h>
#include <cpu_session/client.h>
#include <parent/capability.h>
@ -27,40 +27,27 @@ class Genode::Process
{
private:
Pd_connection _pd;
Pd_session_client _pd_session_client;
Thread_capability _thread0_cap;
Cpu_session_client _cpu_session_client;
Rm_session_client _rm_session_client;
static Dataspace_capability _dynamic_linker_cap;
/*
* Hook for passing additional platform-specific session
* arguments to the PD session. For example, on Linux a new
* process is created locally via 'fork' and the new PID gets
* then communicated to core via a PD-session argument.
*/
enum { PRIV_ARGBUF_LEN = 32 };
char _priv_pd_argbuf[PRIV_ARGBUF_LEN];
const char *_priv_pd_args(Parent_capability parent_cap,
Dataspace_capability elf_data_ds,
const char *name, char *const argv[]);
public:
/**
* Constructor
*
* \param elf_data_ds dataspace that contains the elf binary
* \param pd_session the new protection domain
* \param ram_session RAM session providing the BSS for the
* new protection domain
* \param cpu_session CPU session for the new protection domain
* \param rm_session RM session for the new protection domain
* \param parent parent of the new protection domain
* \param name name of protection domain (can be used
* for debugging)
* \param pd_args platform-specific arguments supplied to
* the PD session of the process
* for debugging)
*
* The dataspace 'elf_data_ds' can be read-only.
*
@ -68,12 +55,12 @@ class Genode::Process
* thread is started immediately.
*/
Process(Dataspace_capability elf_data_ds,
Pd_session_capability pd_session,
Ram_session_capability ram_session,
Cpu_session_capability cpu_session,
Rm_session_capability rm_session,
Parent_capability parent,
char const *name,
Native_pd_args const *args = 0);
char const *name);
/**
* Destructor
@ -87,8 +74,6 @@ class Genode::Process
_dynamic_linker_cap = dynamic_linker_cap;
}
Pd_session_capability pd_session_cap() const { return _pd.cap(); }
Thread_capability main_thread_cap() const { return _thread0_cap; }
};

2
repos/base/include/pd_session/connection.h
View File

@ -22,6 +22,8 @@ namespace Genode { struct Pd_connection; }
struct Genode::Pd_connection : Connection<Pd_session>, Pd_session_client
{
enum { RAM_QUOTA = 4*1024 };
/**
* Constructor
*

13
repos/base/src/base/child/child.cc
View File

@ -271,7 +271,7 @@ Session_capability Child::session(Parent::Service_name const &name,
if (!strcmp("Env::ram_session", name.string())) return _ram;
if (!strcmp("Env::cpu_session", name.string())) return _cpu;
if (!strcmp("Env::rm_session", name.string())) return _rm;
if (!strcmp("Env::pd_session", name.string())) return _process.pd_session_cap();
if (!strcmp("Env::pd_session", name.string())) return _pd;
/* filter session arguments according to the child policy */
strncpy(_args, args.string(), sizeof(_args));
@ -325,6 +325,8 @@ void Child::upgrade(Session_capability to_session, Parent::Upgrade_args const &a
targeted_service = &_cpu_service;
if (to_session.local_name() == _rm.local_name())
targeted_service = &_rm_service;
if (to_session.local_name() == _pd.local_name())
targeted_service = &_pd_service;
/* check if upgrade refers to server */
Object_pool<Session>::Guard session(_session_pool.lookup_and_lock(to_session));
@ -371,7 +373,7 @@ void Child::close(Session_capability session_cap)
if (session_cap.local_name() == _ram.local_name()
|| session_cap.local_name() == _cpu.local_name()
|| session_cap.local_name() == _rm.local_name()
|| session_cap.local_name() == _process.pd_session_cap().local_name())
|| session_cap.local_name() == _pd.local_name())
return;
Session *s = _session_pool.lookup_and_lock(session_cap);
@ -464,16 +466,19 @@ void Child::yield_response() { _policy->yield_response(); }
Child::Child(Dataspace_capability elf_ds,
Pd_session_capability pd,
Ram_session_capability ram,
Cpu_session_capability cpu,
Rm_session_capability rm,
Rpc_entrypoint *entrypoint,
Child_policy *policy,
Service &pd_service,
Service &ram_service,
Service &cpu_service,
Service &rm_service)
:
_ram(ram), _ram_session_client(ram), _cpu(cpu), _rm(rm),
_pd(pd), _pd_session_client(pd), _ram(ram), _ram_session_client(ram),
_cpu(cpu), _rm(rm), _pd_service(pd_service),
_ram_service(ram_service), _cpu_service(cpu_service),
_rm_service(rm_service),
_heap(&_ram_session_client, env()->rm_session()),
@ -481,7 +486,7 @@ Child::Child(Dataspace_capability elf_ds,
_parent_cap(_entrypoint->manage(this)),
_policy(policy),
_server(ram),
_process(elf_ds, ram, cpu, rm, _parent_cap, policy->name(), policy->pd_args())
_process(elf_ds, pd, ram, cpu, rm, _parent_cap, policy->name())
{ }

17
repos/base/src/base/process/process.cc
View File

@ -170,18 +170,17 @@ static addr_t _setup_elf(Parent_capability parent_cap,
Process::Process(Dataspace_capability elf_ds_cap,
Pd_session_capability pd_session_cap,
Ram_session_capability ram_session_cap,
Cpu_session_capability cpu_session_cap,
Rm_session_capability rm_session_cap,
Parent_capability parent_cap,
char const *name,
Native_pd_args const *pd_args)
:
_pd(name, pd_args),
_cpu_session_client(cpu_session_cap),
_rm_session_client(rm_session_cap)
char const *name)
: _pd_session_client(pd_session_cap),
_cpu_session_client(cpu_session_cap),
_rm_session_client(rm_session_cap)
{
if (!_pd.cap().valid())
if (!pd_session_cap.valid())
return;
enum Local_exception
@ -238,13 +237,13 @@ Process::Process(Dataspace_capability elf_ds_cap,
}
/* register parent interface for new protection domain */
if (_pd.assign_parent(parent_cap)) {
if (_pd_session_client.assign_parent(parent_cap)) {
PERR("Could not assign parent interface to new PD");
throw ASSIGN_PARENT_FAIL;
}
/* bind thread0 */
err = _pd.bind_thread(_thread0_cap);
err = _pd_session_client.bind_thread(_thread0_cap);
if (err) {
PERR("Thread binding failed (%d)", err);
throw THREAD_BIND_FAIL;

7
repos/base/src/core/include/pd_root.h
View File

@ -41,6 +41,13 @@ class Genode::Pd_root
_md_alloc, args);
}
void _upgrade_session(Pd_session_component *p, const char *args)
{
size_t ram_quota =
Arg_string::find_arg(args, "ram_quota").ulong_value(0);
p->upgrade_ram_quota(ram_quota);
}
public:
/**

97
repos/base/src/core/include/pd_session_component.h
View File

@ -1,6 +1,7 @@
/*
* \brief Core-specific instance of the PD session interface
* \author Christian Helmuth
* \author Stefan Kalkowski
* \date 2006-07-17
*/
@ -15,6 +16,7 @@
#define _CORE__INCLUDE__PD_SESSION_COMPONENT_H_
/* Genode includes */
#include <base/allocator_guard.h>
#include <base/rpc_server.h>
#include <pd_session/pd_session.h>
#include <util/arg_string.h>
@ -22,52 +24,59 @@
/* core includes */
#include <platform_pd.h>
namespace Genode {
class Pd_session_component : public Rpc_object<Pd_session>
{
private:
/**
* Read and store the PD label
*/
struct Label {
enum { MAX_LEN = 64 };
char string[MAX_LEN];
/**
* Constructor
*/
Label(char const *args)
{
Arg_string::find_arg(args, "label").string(string, sizeof(string), "");
}
} const _label;
Platform_pd _pd;
Parent_capability _parent;
Rpc_entrypoint *_thread_ep;
public:
Pd_session_component(Rpc_entrypoint *thread_ep,
Allocator * md_alloc, char const *args)
: _label(args),
_pd(md_alloc,
Arg_string::find_arg(args, "ram_quota").long_value(0),
_label.string),
_thread_ep(thread_ep) { }
namespace Genode { class Pd_session_component; }
/**************************/
/** PD session interface **/
/**************************/
class Genode::Pd_session_component : public Rpc_object<Pd_session>
{
private:
int bind_thread(Thread_capability);
int assign_parent(Parent_capability);
};
}
/**
* Read and store the PD label
*/
struct Label {
enum { MAX_LEN = 64 };
char string[MAX_LEN];
Label(char const *args)
{
Arg_string::find_arg(args, "label").string(string,
sizeof(string), "");
}
} const _label;
Allocator_guard _md_alloc; /* guarded meta-data allocator */
Platform_pd _pd;
Parent_capability _parent;
Rpc_entrypoint *_thread_ep;
size_t _ram_quota(char const * args) {
return Arg_string::find_arg(args, "ram_quota").long_value(0); }
public:
Pd_session_component(Rpc_entrypoint * thread_ep,
Allocator * md_alloc,
char const * args)
: _label(args),
_md_alloc(md_alloc, _ram_quota(args)),
_pd(&_md_alloc, _label.string),
_thread_ep(thread_ep) { }
/**
* Register quota donation at allocator guard
*/
void upgrade_ram_quota(size_t ram_quota) {
_md_alloc.upgrade(ram_quota); }
/**************************/
/** PD session interface **/
/**************************/
int bind_thread(Thread_capability);
int assign_parent(Parent_capability);
};
#endif /* _CORE__INCLUDE__PD_SESSION_COMPONENT_H_ */

15
repos/base/src/core/main.cc
View File

@ -16,6 +16,8 @@
#include <base/sleep.h>
#include <base/service.h>
#include <base/child.h>
#include <rm_session/connection.h>
#include <pd_session/connection.h>
#include <rom_session/connection.h>
#include <cpu_session/connection.h>
@ -118,13 +120,15 @@ class Core_child : public Child_policy
/**
* Constructor
*/
Core_child(Dataspace_capability elf_ds, Cap_session *cap_session,
Ram_session_capability ram, Cpu_session_capability cpu,
Rm_session_capability rm, Service_registry &services)
Core_child(Dataspace_capability elf_ds, Pd_session_capability pd,
Cap_session *cap_session, Ram_session_capability ram,
Cpu_session_capability cpu, Rm_session_capability rm,
Service_registry &services)
:
_entrypoint(cap_session, STACK_SIZE, "init", false),
_local_services(services),
_child(elf_ds, ram, cpu, rm, &_entrypoint, this,
_child(elf_ds, pd, ram, cpu, rm, &_entrypoint, this,
*_local_services.find(Pd_session::service_name()),
*_local_services.find(Ram_session::service_name()),
*_local_services.find(Cpu_session::service_name()),
*_local_services.find(Rm_session::service_name()))
@ -280,9 +284,10 @@ int main()
env()->ram_session()->transfer_quota(init_ram_session_cap, init_quota);
PDBG("transferred %zu MB to init", init_quota / (1024*1024));
Pd_connection init_pd("init");
Core_child *init = new (env()->heap())
Core_child(Rom_session_client(init_rom_session_cap).dataspace(),
core_env()->cap_session(), init_ram_session_cap,
init_pd, core_env()->cap_session(), init_ram_session_cap,
init_cpu.cap(), init_rm.cap(), local_services);
PDBG("--- init created, waiting for exit condition ---");

9
repos/base/src/test/rm_fault/main.cc
View File

@ -21,6 +21,8 @@
#include <base/env.h>
#include <base/sleep.h>
#include <base/child.h>
#include <pd_session/connection.h>
#include <rm_session/connection.h>
#include <ram_session/connection.h>
#include <rom_session/connection.h>
#include <cpu_session/connection.h>
@ -88,13 +90,14 @@ class Test_child : public Child_policy
* Constructor
*/
Test_child(Genode::Dataspace_capability elf_ds,
Genode::Pd_session_capability pd,
Genode::Ram_session_capability ram,
Genode::Cpu_session_capability cpu,
Genode::Rm_session_capability rm,
Genode::Cap_session *cap)
:
_entrypoint(cap, STACK_SIZE, "child", false),
_child(elf_ds, ram, cpu, rm, &_entrypoint, this),
_child(elf_ds, pd, ram, cpu, rm, &_entrypoint, this),
_log_service("LOG"), _rm_service("RM")
{
/* start execution of the new child */
@ -132,6 +135,7 @@ void main_parent(Dataspace_capability elf_ds)
printf("parent role started\n");
/* create environment for new child */
static Pd_connection pd;
static Ram_connection ram;
static Cpu_connection cpu;
static Rm_connection rm;
@ -149,7 +153,8 @@ void main_parent(Dataspace_capability elf_ds)
rm.fault_handler(fault_handler.manage(&signal_context));
/* create child */
static Test_child child(elf_ds, ram.cap(), cpu.cap(), rm.cap(), &cap);
static Test_child child(elf_ds, pd.cap(), ram.cap(), cpu.cap(),
rm.cap(), &cap);
/* allocate dataspace used for creating shared memory between parent and child */
Dataspace_capability ds = env()->ram_session()->alloc(4096);

3
repos/demo/include/launchpad/launchpad.h
View File

@ -174,6 +174,7 @@ class Launchpad_child : public Genode::List<Launchpad_child>::Element
Launchpad_child(const char *name,
Genode::Dataspace_capability elf_ds,
Genode::Pd_session_capability pd,
Genode::Ram_session_capability ram,
Genode::Cpu_session_capability cpu,
Genode::Rm_session_capability rm,
@ -189,7 +190,7 @@ class Launchpad_child : public Genode::List<Launchpad_child>::Element
_entrypoint(cap_session, ENTRYPOINT_STACK_SIZE, name, false),
_policy(name, &_server, parent_services, child_services,
config_ds, elf_ds, &_entrypoint),
_child(elf_ds, ram, cpu, rm, &_entrypoint, &_policy) {
_child(elf_ds, pd, ram, cpu, rm, &_entrypoint, &_policy) {
_entrypoint.activate(); }
Genode::Rom_session_capability rom_session_cap() { return _rom; }

13
repos/demo/src/lib/launchpad/launchpad.cc
View File

@ -261,9 +261,20 @@ Launchpad_child *Launchpad::start_child(const char *filename,
return 0;
}
Pd_connection pd;
pd.on_destruction(Pd_connection::KEEP_OPEN);
if (!pd.cap().valid()) {
PWRN("Failed to create PD session");
env()->parent()->close(ram.cap());
env()->parent()->close(cpu.cap());
env()->parent()->close(rom_cap);
env()->parent()->close(rm.cap());
return 0;
}
try {
Launchpad_child *c = new (&_sliced_heap)
Launchpad_child(unique_name, file_cap, ram.cap(),
Launchpad_child(unique_name, file_cap, pd.cap(), ram.cap(),
cpu.cap(), rm.cap(), rom_cap,
&_cap_session, &_parent_services, &_child_services,
config_ds, this);

7
repos/os/include/cli_monitor/child.h
View File

@ -20,6 +20,8 @@
#include <init/child_policy.h>
#include <os/child_policy_dynamic_rom.h>
#include <cpu_session/connection.h>
#include <rm_session/connection.h>
#include <pd_session/connection.h>
/* CLI-monitor includes */
#include <cli_monitor/ram.h>
@ -48,12 +50,13 @@ class Child_base : public Genode::Child_policy
struct Resources
{
Genode::Pd_connection pd;
Genode::Ram_connection ram;
Genode::Cpu_connection cpu;
Genode::Rm_connection rm;
Resources(const char *label, Genode::size_t ram_quota)
: ram(label), cpu(label)
: pd(label), ram(label), cpu(label)
{
if (ram_quota > DONATED_RAM_QUOTA)
ram_quota -= DONATED_RAM_QUOTA;
@ -111,7 +114,7 @@ class Child_base : public Genode::Child_policy
_labeling_policy(_label.string()),
_binary_policy("binary", _binary_rom.dataspace(), &_entrypoint),
_config_policy("config", _entrypoint, &_resources.ram),
_child(_binary_rom.dataspace(),
_child(_binary_rom.dataspace(), _resources.pd.cap(),
_resources.ram.cap(), _resources.cpu.cap(),
_resources.rm.cap(), &_entrypoint, this),
_yield_response_sigh_cap(yield_response_sig_cap)

15
repos/os/include/init/child.h
View File

@ -15,7 +15,9 @@
#define _INCLUDE__INIT__CHILD_H_
/* Genode includes */
#include <pd_session/connection.h>
#include <ram_session/connection.h>
#include <rm_session/connection.h>
#include <cpu_session/connection.h>
#include <cap_session/connection.h>
#include <base/printf.h>
@ -440,6 +442,7 @@ class Init::Child : Genode::Child_policy
Genode::size_t ram_quota;
Genode::size_t cpu_quota_pc;
bool constrain_phys;
Genode::Pd_connection pd;
Genode::Ram_connection ram;
Genode::Cpu_connection cpu;
Genode::Rm_connection rm;
@ -448,20 +451,23 @@ class Init::Child : Genode::Child_policy
Resources(Genode::Xml_node start_node, const char *label,
long prio_levels_log2,
Genode::Affinity::Space const &affinity_space)
Genode::Affinity::Space const &affinity_space,
Genode::Native_pd_args const * pd_args)
:
Read_quota(start_node, ram_quota, cpu_quota_pc, constrain_phys),
prio_levels_log2(prio_levels_log2),
priority(read_priority(start_node)),
affinity(affinity_space,
read_affinity_location(affinity_space, start_node)),
pd(label, pd_args),
ram(label),
cpu(label,
priority*(Genode::Cpu_session::PRIORITY_LIMIT >> prio_levels_log2),
affinity)
{
/* deduce session costs from usable ram quota */
Genode::size_t session_donations = Genode::Rm_connection::RAM_QUOTA +
Genode::size_t session_donations = Genode::Pd_connection::RAM_QUOTA +
Genode::Rm_connection::RAM_QUOTA +
Genode::Cpu_connection::RAM_QUOTA +
Genode::Ram_connection::RAM_QUOTA;
@ -532,13 +538,14 @@ class Init::Child : Genode::Child_policy
_name_registry(name_registry),
_name(start_node, name_registry),
_pd_args(start_node),
_resources(start_node, _name.unique, prio_levels_log2, affinity_space),
_resources(start_node, _name.unique, prio_levels_log2,
affinity_space, &_pd_args),
_entrypoint(cap_session, ENTRYPOINT_STACK_SIZE, _name.unique, false, _resources.affinity.location()),
_binary_rom(_name.file, _name.unique),
_binary_rom_ds(_binary_rom.dataspace()),
_config(_resources.ram.cap(), start_node),
_server(_resources.ram.cap()),
_child(_binary_rom_ds, _resources.ram.cap(),
_child(_binary_rom_ds, _resources.pd.cap(), _resources.ram.cap(),
_resources.cpu.cap(), _resources.rm.cap(), &_entrypoint, this),
_parent_services(parent_services),
_child_services(child_services),

6
repos/os/include/os/slave.h
View File

@ -22,6 +22,7 @@
#include <ram_session/connection.h>
#include <cpu_session/connection.h>
#include <rm_session/connection.h>
#include <pd_session/connection.h>
#include <os/child_policy_dynamic_rom.h>
namespace Genode {
@ -158,6 +159,7 @@ class Genode::Slave
struct Resources
{
Genode::Pd_connection pd;
Genode::Ram_connection ram;
Genode::Cpu_connection cpu;
Genode::Rm_connection rm;
@ -165,7 +167,7 @@ class Genode::Slave
class Quota_exceeded : public Genode::Exception { };
Resources(const char *label, Genode::size_t ram_quota)
: ram(label), cpu(label)
: pd(label), ram(label), cpu(label)
{
/*
* XXX derive donated quota from information to be provided by
@ -191,7 +193,7 @@ class Genode::Slave
Genode::size_t ram_quota)
:
_resources(slave_policy.name(), ram_quota),
_child(slave_policy.binary(),
_child(slave_policy.binary(), _resources.pd.cap(),
_resources.ram.cap(), _resources.cpu.cap(),
_resources.rm.cap(), &entrypoint, &slave_policy)
{ }

7
repos/os/src/server/loader/child.h
View File

@ -20,7 +20,9 @@
#include <util/arg_string.h>
#include <init/child_policy.h>
#include <ram_session/connection.h>
#include <rm_session/connection.h>
#include <cpu_session/connection.h>
#include <pd_session/connection.h>
namespace Loader {
@ -42,6 +44,7 @@ namespace Loader {
struct Resources
{
Pd_connection pd;
Ram_connection ram;
Cpu_connection cpu;
Rm_connection rm;
@ -50,7 +53,7 @@ namespace Loader {
Ram_session_client &ram_session_client,
size_t ram_quota,
Signal_context_capability fault_sigh)
: ram(label), cpu(label)
: pd(label), ram(label), cpu(label)
{
/* deduce session costs from usable ram quota */
size_t session_donations = Rm_connection::RAM_QUOTA +
@ -128,7 +131,7 @@ namespace Loader {
_binary_policy("binary", _binary_rom_session.dataspace(), &_ep),
_labeling_policy(_label.string),
_pd_args_policy(&_pd_args),
_child(_binary_rom_session.dataspace(),
_child(_binary_rom_session.dataspace(), _resources.pd.cap(),
_resources.ram.cap(), _resources.cpu.cap(),
_resources.rm.cap(), &_ep, this)
{ }

9
repos/os/src/test/bomb/main.cc
View File

@ -25,6 +25,7 @@
#include <rom_session/connection.h>
#include <cap_session/connection.h>
#include <rm_session/connection.h>
#include <pd_session/connection.h>
#include <timer_session/connection.h>
#include <os/config.h>
@ -37,6 +38,7 @@ class Bomb_child_resources
{
protected:
Genode::Pd_connection _pd;
Genode::Rom_connection _rom;
Genode::Ram_connection _ram;
Genode::Cpu_connection _cpu;
@ -45,8 +47,7 @@ class Bomb_child_resources
Bomb_child_resources(const char *file_name, const char *name,
Genode::size_t ram_quota)
:
_rom(file_name, name), _ram(name), _cpu(name)
: _pd(name), _rom(file_name, name), _ram(name), _cpu(name)
{
Genode::strncpy(_name, name, sizeof(_name));
@ -88,8 +89,8 @@ class Bomb_child : private Bomb_child_resources,
Bomb_child_resources(file_name, unique_name, ram_quota),
Init::Child_policy_enforce_labeling(Bomb_child_resources::_name),
_entrypoint(cap_session, STACK_SIZE, "bomb", false),
_child(_rom.dataspace(), _ram.cap(), _cpu.cap(), _rm.cap(),
&_entrypoint, this),
_child(_rom.dataspace(), _pd.cap(), _ram.cap(), _cpu.cap(),
_rm.cap(), &_entrypoint, this),
_parent_services(parent_services) {
_entrypoint.activate(); }

10
repos/os/src/test/failsafe/main.cc
View File

@ -16,9 +16,11 @@
#include <base/sleep.h>
#include <base/child.h>
#include <ram_session/connection.h>
#include <rm_session/connection.h>
#include <rom_session/connection.h>
#include <cpu_session/connection.h>
#include <cap_session/connection.h>
#include <pd_session/connection.h>
#include <loader_session/connection.h>
@ -51,11 +53,13 @@ class Test_child : public Genode::Child_policy
struct Resources
{
Genode::Pd_connection pd;
Genode::Ram_connection ram;
Genode::Cpu_connection cpu;
Genode::Rm_connection rm;
Resources(Genode::Signal_context_capability sigh)
Resources(Genode::Signal_context_capability sigh, char const *label)
: pd(label)
{
using namespace Genode;
@ -93,10 +97,10 @@ class Test_child : public Genode::Child_policy
char const *elf_name,
Genode::Signal_context_capability sigh)
:
_resources(sigh),
_resources(sigh, elf_name),
_elf(elf_name),
_log_service("LOG"), _rm_service("RM"),
_child(_elf.dataspace(), _resources.ram.cap(),
_child(_elf.dataspace(), _resources.pd.cap(), _resources.ram.cap(),
_resources.cpu.cap(), _resources.rm.cap(), &ep, this)
{ }

7
repos/ports/src/app/gdb_monitor/app_child.h
View File

@ -19,6 +19,7 @@
#include <base/child.h>
#include <base/service.h>
#include <pd_session/connection.h>
#include <init/child_config.h>
#include <init/child_policy.h>
@ -63,6 +64,8 @@ namespace Gdb_monitor {
Ram_session_capability _ram_session_cap;
Pd_connection _pd;
Child _child;
Genode::Rpc_entrypoint *_root_ep;
@ -274,7 +277,9 @@ namespace Gdb_monitor {
_cpu_root(&_entrypoint, env()->heap() /* should be _child.heap() */, &_gdb_stub_thread),
_cpu_session_cap(_get_cpu_session_cap()),
_ram_session_cap(ram_session),
_child(elf_ds, ram_session, _cpu_session_cap, _rm_session_cap, &_entrypoint, this),
_pd(unique_name),
_child(elf_ds, _pd.cap(), ram_session, _cpu_session_cap,
_rm_session_cap, &_entrypoint, this),
_root_ep(root_ep),
_rom_service(&_entrypoint, _child.heap()),
_rm_service(&_entrypoint, _child.heap(), &_managed_ds_map)

6
repos/ports/src/noux/child.h
View File

@ -18,6 +18,7 @@
#include <base/signal.h>
#include <base/semaphore.h>
#include <cap_session/cap_session.h>
#include <pd_session/connection.h>
#include <os/attached_ram_dataspace.h>
/* Noux includes */
@ -124,6 +125,8 @@ namespace Noux {
enum { STACK_SIZE = 4*1024*sizeof(long) };
Rpc_entrypoint _entrypoint;
Pd_connection _pd;
/**
* Resources assigned to the child
*/
@ -338,6 +341,7 @@ namespace Noux {
_destruct_context_cap(sig_rec->manage(&_destruct_dispatcher)),
_cap_session(cap_session),
_entrypoint(cap_session, STACK_SIZE, "noux_process", false),
_pd(binary_name),
_resources(binary_name, resources_ep, false),
_args(ARGS_DS_SIZE, args),
_env(env),
@ -363,7 +367,7 @@ namespace Noux {
*this, parent_exit, *this, _destruct_context_cap,
_resources.ram, verbose),
_child(forked ? Dataspace_capability() : _elf._binary_ds,
_resources.ram.cap(), _resources.cpu.cap(),
_pd.cap(), _resources.ram.cap(), _resources.cpu.cap(),
_resources.rm.cap(), &_entrypoint, &_child_policy,
/**
* Override the implicit assignment to _parent_service