Working minimal interception of PD + CPU

include/swcr/services/cpu.h

@@ -0,0 +1,121 @@
+#ifndef __swcr_services_cpu_h__
+#define __swcr_services_cpu_h__
+
+#include <root/component.h>
+#include <cpu_session/connection.h>
+
+#include <swcr/services/pd.h>
+
+namespace SWCR
+{
+    class Cpu_session_component;
+    class Cpu_session_factory;
+}
+
+using namespace Genode;
+
+class SWCR::Cpu_session_component : public Genode::Rpc_object<Genode::Cpu_session>
+{
+    private:
+    Genode::Env &_env;
+    Genode::Cpu_connection _real_cpu;
+    SWCR::Pd_session_component &_psc;
+
+    public:
+    Cpu_session_component(Genode::Env &env, Pd_session_component &psc) : _env(env),
+                                              _real_cpu(_env),
+                                              _psc(psc)
+    {
+        _env.ep().rpc_ep().manage(this);
+    }
+
+    ~Cpu_session_component()
+    {
+        _env.ep().rpc_ep().dissolve(this);
+    }
+
+    Thread_capability create_thread(Capability<Pd_session> pd,
+                                    Name const            &name,
+                                    Affinity::Location     affinity,
+                                    Weight                 weight,
+                                    addr_t                 utcb = 0)
+    {
+        Genode::log("CPU::\033[33m", __func__, "\033[0m");
+        return _real_cpu.create_thread(_psc.parent_pd_cap(), name, affinity, weight, utcb);
+    };
+
+    void kill_thread(Thread_capability thread)
+    {
+        Genode::log("CPU::\033[33m", __func__, "\033[0m");
+        _real_cpu.kill_thread(thread);
+    };
+
+    void exception_sigh(Signal_context_capability sigh)
+    {
+        Genode::log("CPU::\033[33m", __func__, "\033[0m");
+        _real_cpu.exception_sigh(sigh);
+    };
+
+    Affinity::Space affinity_space() const
+    {
+        Genode::log("CPU::\033[33m", __func__, "\033[0m");
+        return _real_cpu.affinity_space();
+    };
+
+    Dataspace_capability trace_control()
+    {
+        Genode::log("CPU::\033[33m", __func__, "\033[0m");
+        return _real_cpu.trace_control();
+    };
+
+    int ref_account(Cpu_session_capability cpu_session)
+    {
+        Genode::log("CPU::\033[33m", __func__, "\033[0m");
+        return _real_cpu.ref_account(cpu_session);
+    };
+
+    int transfer_quota(Cpu_session_capability cpu_session, size_t amount)
+    {
+        Genode::log("CPU::\033[33m", __func__, "\033[0m");
+        return _real_cpu.transfer_quota(cpu_session, amount);
+    };
+
+    Quota quota()
+    {
+        Genode::log("CPU::\033[33m", __func__, "\033[0m");
+        return _real_cpu.quota();
+    };
+
+    Capability<Native_cpu> native_cpu()
+    {
+        Genode::log("CPU::\033[33m", __func__, "\033[0m");
+        return _real_cpu.native_cpu();
+    };
+};
+
+class SWCR::Cpu_session_factory : public Genode::Local_service<Cpu_session_component>::Factory
+{
+    private:
+    Genode::Env &_env;
+    Genode::Allocator &_alloc;
+
+    Pd_session_component &_psc;
+
+    public:
+    Cpu_session_factory(Genode::Env &env, Genode::Allocator &alloc, Pd_session_component &psc) : _env(env), _alloc(alloc), _psc(psc) { }
+    ~Cpu_session_factory() { }
+
+    Cpu_session_component &create(Args const &, Genode::Affinity) override
+    {
+        return *new (_alloc) Cpu_session_component(_env, _psc);
+    }
+
+    void upgrade(Cpu_session_component &, Args const &) override { }
+
+    void destroy(Cpu_session_component &session) override
+    {
+        Genode::destroy(_alloc, &session);
+    }
+};
+
+#endif /*__swcr_services_cpu_h__*/

include/swcr/services/pd.h

@@ -0,0 +1,213 @@
+#ifndef __swcr_services_pd_h__
+#define __swcr_services_pd_h__
+
+#include <root/component.h>
+#include <pd_session/connection.h>
+
+namespace SWCR
+{
+    class Pd_session_component;
+    class Pd_session_factory;
+}
+
+using namespace Genode;
+
+class SWCR::Pd_session_component : public Genode::Rpc_object<Genode::Pd_session>
+{
+    private:
+    Genode::Env &_env;
+    Genode::Pd_connection _real_pd;
+
+    public:
+    Pd_session_component(Genode::Env &env, const char *label) : _env(env), _real_pd(_env, label)
+    {
+        _env.ep().rpc_ep().manage(this);
+    }
+    ~Pd_session_component()
+    {
+        _env.ep().rpc_ep().dissolve(this);
+    }
+
+    Ram_dataspace_capability alloc(size_t size, Cache_attribute cached = CACHED)
+    {
+        Genode::log("PD::\033[33m", __func__, "\033[0m");
+        return _real_pd.alloc(size, cached);
+    };
+
+    void free(Ram_dataspace_capability ds)
+    {
+        Genode::log("PD::\033[33m", __func__, "\033[0m");
+        _real_pd.free(ds);
+    };
+
+    size_t dataspace_size(Ram_dataspace_capability ds) const
+    {
+        Genode::log("PD::\033[33m", __func__, "\033[0m");
+        return _real_pd.dataspace_size(ds);
+    };
+
+    void assign_parent(Capability<Parent> parent)
+    {
+        Genode::log("PD::\033[33m", __func__, "\033[0m");
+        _real_pd.assign_parent(parent);
+    };
+
+    bool assign_pci(addr_t pci_config_memory_address, uint16_t bdf)
+    {
+        Genode::log("PD::\033[33m", __func__, "\033[0m");
+        return _real_pd.assign_pci(pci_config_memory_address, bdf);
+    };
+
+    void map(addr_t virt, addr_t size)
+    {
+        Genode::log("PD::\033[33m", __func__, "\033[0m");
+        _real_pd.map(virt, size);
+    };
+
+    Signal_source_capability alloc_signal_source()
+    {
+        Genode::log("PD::\033[33m", __func__, "\033[0m");
+        return _real_pd.alloc_signal_source();
+    };
+
+    void free_signal_source(Signal_source_capability cap)
+    {
+        Genode::log("PD::\033[33m", __func__, "\033[0m");
+        _real_pd.free_signal_source(cap);
+    };
+
+    Capability<Signal_context> alloc_context(Signal_source_capability source, unsigned long imprint)
+    {
+        Genode::log("PD::\033[33m", __func__, "\033[0m");
+        return _real_pd.alloc_context(source, imprint);
+    };
+
+    void free_context(Capability<Signal_context> cap)
+    {
+        Genode::log("PD::\033[33m", __func__, "\033[0m");
+        _real_pd.free_context(cap);
+    };
+
+    void submit(Capability<Signal_context> context, unsigned cnt = 1)
+    {
+        Genode::log("PD::\033[33m", __func__, "\033[0m");
+        _real_pd.submit(context, cnt);
+    };
+
+    Native_capability alloc_rpc_cap(Native_capability ep)
+    {
+        Genode::log("PD::\033[33m", __func__, "\033[0m");
+        return _real_pd.alloc_rpc_cap(ep);
+    };
+
+    void free_rpc_cap(Native_capability cap)
+    {
+        Genode::log("PD::\033[33m", __func__, "\033[0m");
+        _real_pd.free_rpc_cap(cap);
+    };
+
+    Capability<Region_map> address_space()
+    {
+        Genode::log("PD::\033[33m", __func__, "\033[0m");
+        return _real_pd.address_space();
+    };
+
+    Capability<Region_map> stack_area()
+    {
+        Genode::log("PD::\033[33m", __func__, "\033[0m");
+        return _real_pd.stack_area();
+    };
+
+    Capability<Region_map> linker_area()
+    {
+        Genode::log("PD::\033[33m", __func__, "\033[0m");
+        return _real_pd.linker_area();
+    };
+
+    void ref_account(Capability<Pd_session> pd)
+    {
+        Genode::log("PD::\033[33m", __func__, "\033[0m");
+        _real_pd.ref_account(pd);
+    };
+
+    void transfer_quota(Capability<Pd_session> to, Cap_quota amount)
+    {
+        Genode::log("PD::\033[33m", __func__, "\033[0m");
+        _real_pd.transfer_quota(to, amount);
+    };
+
+    Cap_quota cap_quota() const
+    {
+        Genode::log("PD::\033[33m", __func__, "\033[0m");
+        return _real_pd.cap_quota();
+    };
+
+    Cap_quota used_caps() const
+    {
+        Genode::log("PD::\033[33m", __func__, "\033[0m");
+        return _real_pd.used_caps();
+    };
+
+    void transfer_quota(Capability<Pd_session> to, Ram_quota amount)
+    {
+        Genode::log("PD::\033[33m", __func__, "\033[0m");
+        _real_pd.transfer_quota(to, amount);
+    };
+
+    Ram_quota ram_quota() const
+    {
+        Genode::log("PD::\033[33m", __func__, "\033[0m");
+        return _real_pd.ram_quota();
+    };
+
+    Ram_quota used_ram() const
+    {
+        Genode::log("PD::\033[33m", __func__, "\033[0m");
+        return _real_pd.used_ram();
+    };
+
+    Capability<Native_pd> native_pd()
+    {
+        Genode::log("PD::\033[33m", __func__, "\033[0m");
+        return _real_pd.native_pd();
+    };
+
+    Pd_session_capability parent_pd_cap()
+    {
+        return _real_pd.cap();
+    }
+};
+
+class SWCR::Pd_session_factory : public Genode::Local_service<Pd_session_component>::Factory
+{
+    private:
+    Genode::Env &_env;
+    Genode::Allocator &_alloc;
+    const char *_label;
+
+    Pd_session_component *_cpsc;
+
+    public:
+    Pd_session_factory(Genode::Env &env, Genode::Allocator &alloc, const char *label) : _env(env), _alloc(alloc), _label(label) { }
+    ~Pd_session_factory() { }
+
+    Pd_session_component &create(Args const &, Genode::Affinity) override
+    {
+        _cpsc = new (_alloc) Pd_session_component(_env, _label);
+        return *_cpsc;
+    }
+
+    void upgrade(Pd_session_component &, Args const &) override { }
+
+    void destroy(Pd_session_component &session) override
+    {
+        Genode::destroy(_alloc, &session);
+    }
+
+    Pd_session_component &custom_pd_session_component()
+    {
+        return *_cpsc;
+    }
+};
+
+#endif /*__swcr_services_pd_h__*/

include/swcr/target_child.h

@@ -0,0 +1,95 @@
+#ifndef __swcr_target_child_h__
+#define __swcr_target_child_h__
+
+#include <base/child.h>
+#include <swcr/services/pd.h>
+#include <swcr/services/cpu.h>
+
+namespace SWCR
+{
+    class Target_child;
+    typedef Genode::Registered<Genode::Parent_service> Parent_service;
+    typedef Genode::Registry<Parent_service> Parent_services;
+}
+
+class SWCR::Target_child : public Genode::Child_policy
+{
+    private:
+    Genode::Env &_env;
+    Genode::Heap _heap;
+    Genode::Cap_quota const _cap_quota { 50 };
+    Genode::Ram_quota const _ram_quota { 8 * 1024 * 1024 };
+
+    Parent_services &_parent_services;
+
+    SWCR::Pd_session_factory _psf;
+    Genode::Local_service<Pd_session_component> _pls;
+
+    SWCR::Cpu_session_factory *_csf;
+    Genode::Local_service<Cpu_session_component> *_cls;
+
+    Genode::Child _child;
+
+    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;
+    }
+
+    Genode::Child_policy::Route
+    resolve_session_request(Genode::Service::Name const &service_name,
+			                Genode::Session_label const &label) override
+    {
+        Genode::log(__func__, ": ", service_name, " ", label);
+        auto route = [&] (Genode::Service &service) {
+            return Genode::Child_policy::Route { .service = service,
+							                     .label   = label,
+					                    		 .diag    = Genode::Session::Diag() }; };
+
+        Genode::Service *service = nullptr;
+        if (!Genode::strcmp("PD", service_name.string()))
+            service = &_pls;
+        else if (!Genode::strcmp("CPU", service_name.string()))
+            service = _cls;
+        else
+            service = _find_service(_parent_services, service_name);
+        return route(*service);
+    }
+
+    public:
+    Target_child(Genode::Env &env,
+                 Parent_services &parent_services) : _env(env),
+                                                     _heap(_env.ram(), _env.rm()),
+                                                     _parent_services(parent_services),
+                                                     _psf(_env, _heap, "hello"),
+                                                     _pls(_psf),
+                                                     _child(_env.rm(), _env.ep().rpc_ep(), *this)
+    { }
+    ~Target_child() { };
+
+    Name name() const override { return "hello"; };
+
+    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 &custom_pd, Genode::Pd_session_capability pd_cap) override
+    {
+        custom_pd.ref_account(ref_pd_cap());
+        Genode::log("transfering");
+        Pd_session_component &pdsc = _psf.custom_pd_session_component();
+        _csf = new (_heap) SWCR::Cpu_session_factory(_env, _heap, pdsc);
+        _cls = new (_heap) Genode::Local_service<SWCR::Cpu_session_component>(*_csf);
+        ref_pd().transfer_quota(pdsc.parent_pd_cap(), _cap_quota);
+        ref_pd().transfer_quota(pdsc.parent_pd_cap(), _ram_quota);
+        Genode::log("done");
+        /*ref_pd().transfer_quota(_cpsc.parent_pd_cap(), _cap_quota);
+        ref_pd().transfer_quota(_cpsc.parent_pd_cap(), _ram_quota);*/
+    }
+};
+
+#endif /*__swcr_target_child_h__*/

run/swcr.run

@@ -0,0 +1,96 @@
+#
+# Build
+#
+
+set use_usb_driver [expr [have_spec omap4] || [have_spec arndale] || [have_spec rpi]]
+set use_nic_driver [expr !$use_usb_driver && ![have_spec odroid_xu] && ![have_spec linux]]
+
+if {[expr !$use_usb_driver && !$use_nic_driver] ||
+    [expr [have_spec imx53] && [have_spec trustzone]]} {
+	puts "\n Run script is not supported on this platform. \n"; exit 0 }
+
+set build_components {
+    core init
+    drivers/timer drivers/nic
+    app/swcr app/hello
+}
+
+lappend_if $use_usb_driver              build_components drivers/usb
+lappend_if [have_spec gpio]             build_components drivers/gpio
+
+proc gpio_drv { } { if {[have_spec rpi] && [have_spec hw]}  { return hw_gpio_drv }
+                    if {[have_spec rpi] && [have_spec foc]} { return foc_gpio_drv }
+                    return gpio_drv }
+
+source ${genode_dir}/repos/base/run/platform_drv.inc
+append_platform_drv_build_components
+
+build $build_components
+
+create_boot_directory
+
+#
+# Generate config
+#
+
+set config {
+<config verbose="yes">
+	<parent-provides>
+		<service name="ROM"/>
+		<service name="IRQ"/>
+		<service name="IO_MEM"/>
+		<service name="IO_PORT"/>
+		<service name="PD"/>
+		<service name="RM"/>
+		<service name="CPU"/>
+		<service name="LOG"/>
+	</parent-provides>
+	<default-route>
+		<any-service> <parent/> <any-child/> </any-service>
+	</default-route>
+	<default caps="200"/>
+	<start name="timer">
+		<resource name="RAM" quantum="1M"/>
+		<provides> <service name="Timer"/> </provides>
+	</start>
+	<start name="swcr" caps="300">
+		<resource name="RAM" quantum="16M"/>
+	</start>}
+
+append_if [have_spec gpio] config "
+	<start name=\"[gpio_drv]\" caps=\"140\">
+		<resource name=\"RAM\" quantum=\"4M\"/>
+		<provides><service name=\"Gpio\"/></provides>
+		<config/>
+	</start>"
+
+append_if $use_usb_driver config {
+	<start name="usb_drv" caps="120">
+		<resource name="RAM" quantum="14M"/>
+		<provides>
+			<service name="Nic"/>
+		</provides>
+		<config ehci="yes">
+			<nic mac="02:00:00:00:01:01" />
+		</config>
+	</start>}
+
+append_platform_drv_config
+
+append config {
+</config>
+}
+
+install_config $config
+
+#
+# Boot image
+#
+
+build_boot_image { core ld.lib.so init swcr timer hello }
+
+append qemu_args " -nographic "
+
+#append_if [have_spec lan9119] qemu_args " -net nic,macaddr=02:00:00:00:01:03 -net nic,model=lan9118 -net tap,ifname=tap0,script=no "
+
+run_genode_until forever

src/app/swcr/main.cc

@@ -0,0 +1,32 @@
+#include <base/component.h>
+#include <swcr/target_child.h>
+
+namespace SWCR
+{
+    struct Main;
+}
+
+struct SWCR::Main
+{
+    Genode::Env &_env;
+    Genode::Heap _heap { _env.ram(), _env.rm() };
+
+    Parent_services _parent_services { };
+
+    Main(Genode::Env &env) : _env(env)
+    {
+        const char *names[] = { "RM", "PD", "CPU", "IO_MEM", "IO_PORT", "IRQ", "ROM", "LOG", 0 };
+
+        for (unsigned i = 0; names[i]; i++)
+        {
+            new (_heap) Parent_service(_parent_services, env, names[i]);
+        }
+
+        new (_heap) Target_child(_env, _parent_services);
+    }
+};
+
+void Component::construct(Genode::Env &env)
+{
+    static SWCR::Main main(env);
+}

src/app/swcr/target.mk

@@ -0,0 +1,3 @@
+TARGET = swcr
+SRC_CC = main.cc
+LIBS   = base