genode/repos/demo/include/launchpad/launchpad.h
2019-01-30 13:49:54 +01:00

291 lines
8.6 KiB
C++

/*
* \brief Launchpad interface
* \author Norman Feske
* \date 2006-09-01
*
* This class is a convenience-wrapper for starting and killing
* child processes. To support the Launchpad application, is
* also provides an interface to glues the child handling and
* the GUI together.
*/
/*
* Copyright (C) 2006-2017 Genode Labs GmbH
*
* This file is part of the Genode OS framework, which is distributed
* under the terms of the GNU Affero General Public License version 3.
*/
#ifndef _INCLUDE__LAUNCHPAD__LAUNCHPAD_H_
#define _INCLUDE__LAUNCHPAD__LAUNCHPAD_H_
#include <util/xml_node.h>
#include <base/allocator.h>
#include <base/service.h>
#include <base/lock.h>
#include <base/child.h>
#include <timer_session/timer_session.h>
#include <pd_session/client.h>
#include <init/child_policy.h>
#include <os/session_requester.h>
class Launchpad;
class Launchpad_child : public Genode::Child_policy,
private Genode::List<Launchpad_child>::Element,
public Genode::Async_service::Wakeup
{
private:
friend class Genode::List<Launchpad_child>;
public:
typedef Genode::Child_policy::Name Name;
typedef Genode::Registered<Genode::Child_service> Child_service;
typedef Genode::Registered<Genode::Parent_service> Parent_service;
typedef Genode::Registry<Child_service> Child_services;
typedef Genode::Registry<Parent_service> Parent_services;
private:
Name const _name;
Binary_name const _elf_name;
Genode::Env &_env;
Genode::Allocator &_alloc;
Genode::Cap_quota const _cap_quota;
Genode::Ram_quota const _ram_quota;
Parent_services &_parent_services;
Child_services &_child_services;
Genode::Dataspace_capability _config_ds { };
Genode::Session_requester _session_requester;
Init::Child_policy_provide_rom_file _config_policy;
Genode::Child _child;
/**
* Child_service::Wakeup callback
*/
void wakeup_async_service() override
{
_session_requester.trigger_update();
}
template <typename T>
static Genode::Service *_find_service(Genode::Registry<T> &services,
Genode::Service::Name const &name)
{
Genode::Service *service = nullptr;
services.for_each([&] (T &s) {
if (!service && (s.name() == name))
service = &s; });
return service;
}
public:
Launchpad_child(Genode::Env &env,
Genode::Allocator &alloc,
Genode::Session_label const &label,
Binary_name const &elf_name,
Genode::Cap_quota cap_quota,
Genode::Ram_quota ram_quota,
Parent_services &parent_services,
Child_services &child_services,
Genode::Dataspace_capability config_ds)
:
_name(label), _elf_name(elf_name),
_env(env), _alloc(alloc),
_cap_quota(Genode::Child::effective_quota(cap_quota)),
_ram_quota(Genode::Child::effective_quota(ram_quota)),
_parent_services(parent_services),
_child_services(child_services),
_session_requester(env.ep().rpc_ep(), _env.ram(), _env.rm()),
_config_policy("config", config_ds, &_env.ep().rpc_ep()),
_child(_env.rm(), _env.ep().rpc_ep(), *this)
{ }
~Launchpad_child()
{
using namespace Genode;
/* unregister services */
_child_services.for_each(
[&] (Child_service &service) {
if (service.has_id_space(_session_requester.id_space()))
Genode::destroy(_alloc, &service); });
}
using Genode::List<Launchpad_child>::Element::next;
/****************************
** Child_policy interface **
****************************/
Name name() const override { return _name; }
Binary_name binary_name() const override { return _elf_name; }
Genode::Pd_session &ref_pd() override { return _env.pd(); }
Genode::Pd_session_capability ref_pd_cap() const override { return _env.pd_session_cap(); }
void init(Genode::Pd_session &session,
Genode::Pd_session_capability cap) override
{
session.ref_account(_env.pd_session_cap());
_env.pd().transfer_quota(cap, _cap_quota);
_env.pd().transfer_quota(cap, _ram_quota);
}
Genode::Id_space<Genode::Parent::Server> &server_id_space() override {
return _session_requester.id_space(); }
Genode::Child_policy::Route
resolve_session_request(Genode::Service::Name const &service_name,
Genode::Session_label const &label) override
{
auto route = [&] (Genode::Service &service) {
return Genode::Child_policy::Route { .service = service,
.label = label,
.diag = Genode::Session::Diag() }; };
Genode::Service *service = nullptr;
/* check for config file request */
if ((service = _config_policy.resolve_session_request_with_label(service_name, label)))
return route(*service);
/* check for "session_requests" ROM request */
if (service_name == Genode::Rom_session::service_name()
&& label.last_element() == Genode::Session_requester::rom_name())
return route(_session_requester.service());
/* if service is provided by one of our children, use it */
if ((service = _find_service(_child_services, service_name)))
return route(*service);
/*
* Handle special case of the demo scenario when the user uses
* a nested Launchad for starting another Nitpicker instance
* before starting Liquid_fb. In this case, we do not want to
* delegate Nitpicker's session requests to the parent. The
* parent may be a launchpad again trying to apply the same
* policy. This instance will recognise that the session is not
* available at init (because the actual input and framebuffer
* drivers are singletons, and would therefore block for
* Framebuffer or Input to become available at one of its own
* children. The launchpad with which the user originally
* interacted, however, would block at the parent interface
* until this condition gets satisfied.
*/
if (service_name != "Input"
&& service_name != "Framebuffer"
&& ((service = _find_service(_parent_services, service_name))))
return route(*service);
Genode::warning(name(), ": service ", service_name, " not available");
throw Genode::Service_denied();
}
void announce_service(Genode::Service::Name const &service_name) override
{
if (_find_service(_child_services, service_name)) {
Genode::warning(name(), ": service ", service_name, " is already registered");
return;
}
new (_alloc)
Child_service(_child_services, service_name,
_session_requester.id_space(),
_child.session_factory(), *this,
_child.pd_session_cap(),
_child.pd_session_cap());
}
};
class Launchpad
{
private:
Genode::Env &_env;
Genode::Heap _heap { _env.ram(), _env.rm() };
unsigned long _initial_quota;
Launchpad_child::Parent_services _parent_services { };
Launchpad_child::Child_services _child_services { };
Genode::Lock _children_lock { };
Genode::List<Launchpad_child> _children { };
bool _child_name_exists(Launchpad_child::Name const &);
Launchpad_child::Name _get_unique_child_name(Launchpad_child::Name const &);
Genode::Sliced_heap _sliced_heap;
protected:
int _ypos = 0;
public:
typedef Genode::Cap_quota Cap_quota;
typedef Genode::Ram_quota Ram_quota;
Launchpad(Genode::Env &env, unsigned long initial_quota);
unsigned long initial_quota() { return _initial_quota; }
virtual ~Launchpad() { }
/**
* Process launchpad XML configuration
*/
void process_config(Genode::Xml_node);
/*************************
** Configuring the GUI **
*************************/
virtual void quota(unsigned long) { }
virtual void add_launcher(Launchpad_child::Name const & /* binary_name */,
Cap_quota, unsigned long /* default_quota */,
Genode::Dataspace_capability /* config_ds */) { }
virtual void add_child(Launchpad_child::Name const &,
unsigned long /* quota */,
Launchpad_child &,
Genode::Allocator &) { }
virtual void remove_child(Launchpad_child::Name const &,
Genode::Allocator &) { }
Launchpad_child *start_child(Launchpad_child::Name const &binary_name,
Cap_quota cap_quota, Ram_quota ram_quota,
Genode::Dataspace_capability config_ds);
/**
* Exit child and close all its sessions
*/
void exit_child(Launchpad_child &child);
};
#endif /* _INCLUDE__LAUNCHPAD__LAUNCHPAD_H_ */