genode/repos/base/src/core/main.cc

/*
 * \brief  Core main program
 * \author Norman Feske
 * \date   2006-07-12
 */

/*
 * 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.
 */

/* Genode includes */
#include <base/snprintf.h>
#include <base/sleep.h>
#include <base/service.h>
#include <base/child.h>
#include <base/log.h>
#include <rm_session/connection.h>
#include <pd_session/connection.h>
#include <rom_session/connection.h>
#include <cpu_session/connection.h>

/* base-internal includes */
#include <base/internal/globals.h>

/* core includes */
#include <platform.h>
#include <core_env.h>
#include <signal_transmitter.h>
#include <ram_root.h>
#include <rom_root.h>
#include <rm_root.h>
#include <cpu_root.h>
#include <pd_root.h>
#include <log_root.h>
#include <io_mem_root.h>
#include <irq_root.h>
#include <trace/root.h>
#include <platform_services.h>

using namespace Genode;


/***************************************
 ** Core environment/platform support **
 ***************************************/

Core_env * Genode::core_env()
{
	/*
	 * Make sure to initialize the platform before constructing the core
	 * environment.
	 */
	platform();

	/*
	 * By placing the environment as static object here, we ensure that its
	 * constructor gets called when this function is used the first time.
	 */
	static Core_env _env;

	/*
	 * Register signal-source entrypoint at core-local signal-transmitter back
	 * end
	 */
	static bool signal_transmitter_initialized;

	if (!signal_transmitter_initialized)
		signal_transmitter_initialized =
			(init_core_signal_transmitter(*_env.entrypoint()), true);

	return &_env;
}


Env_deprecated * Genode::env_deprecated() {
	return core_env(); }


Platform *Genode::platform_specific()
{
	static Platform _platform;
	return &_platform;
}


Platform_generic *Genode::platform() { return platform_specific(); }


/*************************
 ** Core parent support **
 *************************/

Session_capability Core_parent::session(Parent::Client::Id          id,
                                        Parent::Service_name const &name,
                                        Parent::Session_args const &args,
                                        Affinity             const &affinity)
{
	Session_capability cap;

	_services.for_each([&] (Service &service) {

		if ((service.name() != name.string()) || cap.valid())
			return;

		Session_state &session = *new (_alloc)
			Session_state(service, _id_space, id, label_from_args(args.string()),
			              args.string(), affinity);

		service.initiate_request(session);

		cap = session.cap;
	});

	if (!cap.valid())
		error("unexpected core-parent ", name.string(), " session request");

	return cap;
}


/****************
 ** Core child **
 ****************/

class Core_child : public Child_policy
{
	private:

		/*
		 * Entry point used for serving the parent interface
		 */
		Rpc_entrypoint _entrypoint;
		enum { STACK_SIZE = 4 * 1024 * sizeof(Genode::addr_t)};

		Registry<Service> &_services;

		Capability<Pd_session>  _core_pd_cap;
		Pd_session             &_core_pd;

		Capability<Ram_session> _core_ram_cap;
		Ram_session            &_core_ram;

		Capability<Cpu_session> _core_cpu_cap;
		Cpu_session            &_core_cpu;

		Cap_quota const _cap_quota;
		Ram_quota const _ram_quota;

		Child _child;

	public:

		/**
		 * Constructor
		 */
		Core_child(Registry<Service> &services,
		           Pd_session  &core_pd,  Capability<Pd_session>  core_pd_cap,
		           Ram_session &core_ram, Capability<Ram_session> core_ram_cap,
		           Cpu_session &core_cpu, Capability<Cpu_session> core_cpu_cap,
		           Cap_quota cap_quota, Ram_quota ram_quota)
		:
			_entrypoint(nullptr, STACK_SIZE, "init_child", false),
			_services(services),
			_core_pd_cap (core_pd_cap),  _core_pd (core_pd),
			_core_ram_cap(core_ram_cap), _core_ram(core_ram),
			_core_cpu_cap(core_cpu_cap), _core_cpu(core_cpu),
			_cap_quota(Child::effective_quota(cap_quota)),
			_ram_quota(Child::effective_quota(ram_quota)),
			_child(*env_deprecated()->rm_session(), _entrypoint, *this)
		{
			_entrypoint.activate();
		}


		/****************************
		 ** Child-policy interface **
		 ****************************/

		Name name() const { return "init"; }

		Service &resolve_session_request(Service::Name const &name,
		                                 Session_state::Args const &args) override
		{
			Service *service = nullptr;
			_services.for_each([&] (Service &s) {
				if (!service && s.name() == name)
					service = &s; });

			if (!service)
				throw Service_denied();

			return *service;
		}

		void init(Pd_session &session, Capability<Pd_session> cap) override
		{
			session.ref_account(_core_pd_cap);
			_core_pd.transfer_quota(cap, _cap_quota);
		}

		void init(Ram_session &session, Capability<Ram_session> cap) override
		{
			session.ref_account(_core_ram_cap);
			_core_ram.transfer_quota(cap, _ram_quota);
		}

		void init(Cpu_session &session, Capability<Cpu_session> cap) override
		{
			session.ref_account(_core_cpu_cap);
			_core_cpu.transfer_quota(cap, Cpu_session::quota_lim_upscale(100, 100));
		}

		Pd_session           &ref_pd()           { return _core_pd; }
		Pd_session_capability ref_pd_cap() const { return _core_pd_cap; }

		Ram_session           &ref_ram()           { return _core_ram; }
		Ram_session_capability ref_ram_cap() const { return _core_ram_cap; }

		size_t session_alloc_batch_size() const override { return 128; }
};


/****************
 ** Signal API **
 ****************/

/*
 * In contrast to the 'Platform_env' used by non-core components, core disables
 * the signal thread but overriding 'Genode::init_signal_thread' with a dummy.
 * Within core, the signal thread is not needed as core is never supposed to
 * receive any signals. Otherwise, the signal thread would be the only
 * non-entrypoint thread within core, which would be a problem on NOVA where
 * the creation of regular threads within core is unsupported.
 */

void Genode::init_signal_thread(Env &) { }
void Genode::destroy_signal_thread()   { }


/*******************
 ** Trace support **
 *******************/

Trace::Source_registry &Trace::sources()
{
	static Trace::Source_registry inst;
	return inst;
}


/***************
 ** Core main **
 ***************/

namespace Genode {
	extern bool        inhibit_tracing;
	extern char const *version_string;
}


int main()
{
	/**
	 * Disable tracing within core because it is currently not fully implemented.
	 */
	inhibit_tracing = true;

	log("Genode ", Genode::version_string);

	static Trace::Policy_registry trace_policies;

	/*
	 * Initialize root interfaces for our services
	 */
	Rpc_entrypoint *e = core_env()->entrypoint();

	Registry<Service> &services = core_env()->services();

	static Ram_allocator &core_ram_alloc = *core_env()->ram_session();
	static Region_map    &local_rm       = *core_env()->rm_session();

	/*
	 * Allocate session meta data on distinct dataspaces to enable independent
	 * destruction (to enable quota trading) of session component objects.
	 */
	static Sliced_heap sliced_heap(core_ram_alloc, local_rm);

	/*
	 * Factory for creating RPC capabilities within core
	 */
	static Rpc_cap_factory rpc_cap_factory(sliced_heap);

	static Pager_entrypoint pager_ep(rpc_cap_factory);

	static Ram_root     ram_root     (*e, *platform()->ram_alloc(), local_rm, sliced_heap);
	static Rom_root     rom_root     (e, e, platform()->rom_fs(), &sliced_heap);
	static Rm_root      rm_root      (e, &sliced_heap, pager_ep);
	static Cpu_root     cpu_root     (e, e, &pager_ep, &sliced_heap,
	                                  Trace::sources());
	static Pd_root      pd_root      (*e, pager_ep, core_ram_alloc, local_rm, sliced_heap);
	static Log_root     log_root     (e, &sliced_heap);
	static Io_mem_root  io_mem_root  (e, e, platform()->io_mem_alloc(),
	                                  platform()->ram_alloc(), &sliced_heap);
	static Irq_root     irq_root     (core_env()->pd_session(),
	                                  platform()->irq_alloc(), &sliced_heap);
	static Trace::Root  trace_root   (e, &sliced_heap, Trace::sources(), trace_policies);

	static Core_service<Rom_session_component>    rom_service    (services, rom_root);
	static Core_service<Ram_session_component>    ram_service    (services, ram_root);
	static Core_service<Rm_session_component>     rm_service     (services, rm_root);
	static Core_service<Cpu_session_component>    cpu_service    (services, cpu_root);
	static Core_service<Pd_session_component>     pd_service     (services, pd_root);
	static Core_service<Log_session_component>    log_service    (services, log_root);
	static Core_service<Io_mem_session_component> io_mem_service (services, io_mem_root);
	static Core_service<Irq_session_component>    irq_service    (services, irq_root);
	static Core_service<Trace::Session_component> trace_service  (services, trace_root);

	/* make platform-specific services known to service pool */
	platform_add_local_services(e, &sliced_heap, &services);

	/* calculate number of capabilities to be assigned to init */
	size_t const preservered_cap_quota = 1000;

	if (platform()->max_caps() < preservered_cap_quota) {
		error("platform cap limit lower than preservation for core");
		return -1;
	}

	size_t const avail_cap_quota = platform()->max_caps() - preservered_cap_quota;

	/* PD session representing core */
	static Pd_session_component
		core_pd(*e,
		        Session::Resources { Ram_quota { 16*1024 },
		                             Cap_quota { avail_cap_quota } },
		        Session::Label("core"), Session::Diag{false},
		        core_ram_alloc, local_rm, pager_ep, "");

	core_pd.init_cap_account();

	/* CPU session representing core */
	static Cpu_session_component
		core_cpu(e, e, &pager_ep, &sliced_heap, Trace::sources(),
		         "label=\"core\"", Affinity(), Cpu_session::QUOTA_LIMIT);
	Cpu_session_capability core_cpu_cap = core_env()->entrypoint()->manage(&core_cpu);

	/* calculate RAM to be assigned to init */
	size_t const platform_ram_limit = platform()->ram_alloc()->avail();
	size_t const preserved_ram_quota = 224*1024;

	if (platform_ram_limit < preserved_ram_quota) {
		error("platform RAM limit lower than preservation for core");
		return -1;
	}

	size_t const avail_ram_quota = platform_ram_limit - preserved_ram_quota;

	log("", avail_ram_quota / (1024*1024), " MiB RAM and ", avail_cap_quota, " caps "
	    "assigned to init");

	static Reconstructible<Core_child>
		init(services,
		     core_pd, core_pd.cap(),
		     *env_deprecated()->ram_session(), env_deprecated()->ram_session_cap(),
		     core_cpu, core_cpu_cap,
		     core_pd.cap_quota(), Ram_quota{avail_ram_quota});

	platform()->wait_for_exit();

	init.destruct();
	return 0;
}