Add simple async signal example

include/signals_session/client.h

@@ -0,0 +1,19 @@
+#ifndef _INCLUDE__SIGNALS_SESSION__CLIENT_H_
+#define _INCLUDE__SIGNALS_SESSION__CLIENT_H_
+
+#include <signals_session/signals_session.h>
+#include <base/rpc_client.h>
+
+namespace Signals { struct Session_client; }
+
+struct Signals::Session_client : Genode::Rpc_client<Session>
+{
+  Session_client(Genode::Capability<Session> cap) : Genode::Rpc_client<Session>(cap) {
+  }
+
+  Genode::Signal_context_capability get_sig_con() override {
+    return call<Rpc_get_sig_con>();
+  }
+};
+
+#endif /* _INCLUDE__SIGNALS_SESSION__CLIENT_H_ */

include/signals_session/connection.h

@@ -0,0 +1,14 @@
+#ifndef _INCLUDE__SIGNALS_SESSION__CONNECTION_H_
+#define _INCLUDE__SIGNALS_SESSION__CONNECTION_H_
+
+#include <signals_session/client.h>
+#include <base/connection.h>
+
+namespace Signals { struct Connection; }
+
+struct Signals::Connection : Genode::Connection<Session>, Session_client {
+ Connection(Genode::Env &env) : Genode::Connection<Signals::Session>(env, session(env.parent(), "ram_quota=6K, cap_quota=4")),
+									    Session_client(cap()) { }
+};
+
+#endif /* _INCLUDE__SIGNALS_SESSION__CONNECTION_H_ */

include/signals_session/signals_session.h

@@ -0,0 +1,21 @@
+#ifndef _INCLUDE__SIGNALS_SESSION__SIGNALS_SESSION_H
+#define _INCLUDE__SIGNALS_SESSION__SIGNALS_SESSION_H
+
+#include <session/session.h>
+#include <base/rpc.h>
+
+namespace Signals { struct Session; }
+
+struct Signals::Session : Genode::Session {
+  static const char *service_name() { return "Signals"; }
+
+  enum { CAP_QUOTA = 2 };
+
+  virtual Genode::Signal_context_capability get_sig_con() = 0;
+
+  GENODE_RPC(Rpc_get_sig_con, Genode::Signal_context_capability, get_sig_con);
+
+  GENODE_RPC_INTERFACE(Rpc_get_sig_con);
+};
+
+#endif /* _INCLUDE__SIGNALS_SESSION__SIGNALS_SESSION_H */

run/eth_udp.run

@@ -0,0 +1,84 @@
+#
+# Build
+#
+
+if {[expr [have_spec linux]] ||
+    [expr [have_spec imx53] && [have_spec trustzone]] ||
+    [have_spec rpi3] ||
+    [expr [have_spec riscv]]} {
+	puts "\n Run script is not supported on this platform. \n"; exit 0 }
+
+create_boot_directory
+
+import_from_depot [depot_user]/src/[base_src] \
+                  [depot_user]/pkg/[drivers_nic_pkg] \
+                  [depot_user]/src/init \
+                  [depot_user]/src/libc \
+                  [depot_user]/src/vfs_lwip \
+                  [depot_user]/src/vfs
+
+build { app/eth_udp }
+
+install_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="100"/>
+
+	<start name="timer">
+		<resource name="RAM" quantum="1M"/>
+		<provides> <service name="Timer"/> </provides>
+	</start>
+
+	<start name="drivers" caps="1000">
+		<resource name="RAM" quantum="32M" constrain_phys="yes"/>
+		<binary name="init"/>
+		<route>
+			<service name="ROM" label="config"> <parent label="drivers.config"/> </service>
+			<service name="Timer"> <child name="timer"/> </service>
+			<any-service> <parent/> </any-service>
+		</route>
+		<provides> <service name="Nic"/> </provides>
+	</start>
+
+	<start name="eth_udp" caps="120">
+		<resource name="RAM" quantum="4M"/>
+		<config>
+			<vfs>
+				<dir name="dev">    <log/>             </dir>
+				<dir name="socket"> <lwip dhcp="yes"/> </dir>
+			</vfs>
+			<libc stdout="/dev/log" stderr="/dev/log" socket="/socket"/>
+		</config>
+	</start>
+</config>
+}
+
+build_boot_image { eth_udp }
+
+#
+# Qemu config
+#
+proc qemu_nic_model {} {
+	if [have_spec x86]         { return e1000 }
+	if [have_spec lan9118]     { return lan9118 }
+	if [have_spec zynq]        { return cadence_gem }
+	return nic_model_missing
+}
+append qemu_args "  -nographic "
+append qemu_args " -net nic,model=[qemu_nic_model],netdev=net0 "
+
+run_genode_until forever
+
+# vi: set ft=tcl :

run/signals.run

@@ -0,0 +1,46 @@
+#
+# Build
+#
+
+build { core init timer signals }
+
+create_boot_directory
+
+#
+# Generate config
+#
+
+install_config {
+<config>
+	<parent-provides>
+		<service name="LOG"/>
+		<service name="PD"/>
+		<service name="CPU"/>
+		<service name="ROM"/>
+	</parent-provides>
+	<default-route>
+		<any-service> <parent/> <any-child/> </any-service>
+	</default-route>
+	<default caps="100"/>
+	<start name="timer">
+		<resource name="RAM" quantum="1M"/>
+		<provides> <service name="Timer"/> </provides>
+	</start>
+	<start name="signals_server">
+		<resource name="RAM" quantum="1M"/>
+		<provides> <service name="Signals"/> </provides>
+	</start>
+	<start name="signals_client">
+		<resource name="RAM" quantum="1M"/>
+	</start>
+</config>}
+
+#
+# Boot image
+#
+
+build_boot_image { core ld.lib.so init timer signals_client signals_server }
+
+append qemu_args " -nographic "
+
+run_genode_until forever

src/app/eth_udp/main.cc

@@ -0,0 +1,53 @@
+/*
+ * \brief  Test client for the Hello RPC interface
+ * \author Björn Döbel
+ * \author Norman Feske
+ * \date   2008-03-20
+ */
+
+/*
+ * Copyright (C) 2008-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.
+ */
+
+#include <base/component.h>
+#include <base/log.h>
+#include <libc/component.h>
+
+#include <unistd.h>
+#include <fcntl.h>
+#include <sys/socket.h>
+#include <netinet/in.h>
+#include <arpa/inet.h>
+
+#include <util/string.h>
+
+void Libc::Component::construct(Libc::Env &env)
+{
+  Libc::with_libc([&] () {
+		    struct sockaddr_in srv_addr;
+		    srv_addr.sin_port = htons(8080);
+		    srv_addr.sin_family = AF_INET;
+		    srv_addr.sin_addr.s_addr = inet_addr("192.168.100.0");
+
+		    unsigned int len = sizeof(srv_addr);
+
+		    int sd = ::socket(AF_INET, SOCK_DGRAM, 0);
+		    sendto(sd, "Hello World\n", 12, 0, (struct sockaddr*)&srv_addr, len);
+
+		    char buf[64] = {'\0'};
+		    int ret = -1;
+		    while(true) {
+		      ret = recvfrom(sd, buf, sizeof(buf), 0, NULL, NULL);
+		      buf[ret] = '\0';
+		      Genode::log((const char *)buf);
+		    }
+
+		    Genode::log("Connection closed…");
+
+		    // ----------------------------------
+
+		  });
+}

src/app/eth_udp/target.mk

@@ -0,0 +1,5 @@
+TARGET = eth_udp
+SRC_CC = main.cc
+LIBS   = base libc
+
+CC_CXX_WARN_STRICT =

src/signals/client/main.cc

@@ -0,0 +1,19 @@
+#include <base/component.h>
+#include <base/log.h>
+#include <signals_session/connection.h>
+#include <timer_session/connection.h>
+
+
+void Component::construct(Genode::Env &env)
+{
+  Signals::Connection _signals(env);
+  Genode::Signal_transmitter _signal_transmitter(_signals.get_sig_con());
+
+  Timer::Connection _timer(env);
+
+  while(true) {
+    _timer.msleep(1000);
+    Genode::log("Sending signal…");
+    _signal_transmitter.submit();
+  };
+}

src/signals/client/target.mk

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

src/signals/server/main.cc

@@ -0,0 +1,54 @@
+#include <base/component.h>
+#include <base/log.h>
+#include <base/heap.h>
+#include <root/component.h>
+#include <signals_session/signals_session.h>
+
+namespace Signals {
+  struct Session_component;
+  class Root_component;
+  struct Main;
+}
+
+struct Signals::Session_component : Genode::Rpc_object<Session> {
+  Genode::Signal_context_capability _sig_con;
+  Genode::Signal_context_capability get_sig_con() override {
+    return _sig_con;
+  }
+
+  Session_component(Genode::Signal_context_capability &sig_con) : _sig_con(sig_con) { }
+};
+
+class Signals::Root_component : public Genode::Root_component<Session_component> {
+private:
+  Genode::Signal_context_capability _sig_con;
+protected:
+  Session_component *_create_session(const char *) override {
+    return new (md_alloc()) Session_component(_sig_con);
+  }
+
+public:
+  Root_component(Genode::Entrypoint &ep, Genode::Allocator &alloc, Genode::Signal_context_capability sig_con) : Genode::Root_component<Session_component>(ep, alloc), _sig_con(sig_con) { }
+};
+
+struct Signals::Main {
+  Genode::Env &_env;
+
+  Genode::Signal_handler<Main> _sig_handler = { _env.ep(), *this, &Main::_handle_signal };
+
+  Genode::Sliced_heap sliced_heap { _env.ram(), _env.rm() };
+
+  Signals::Root_component root { _env.ep(), sliced_heap, _sig_handler };
+
+  Main(Genode::Env &env) : _env(env) {
+    env.parent().announce(env.ep().manage(root));
+  }
+
+  void _handle_signal() {
+    Genode::log("Signal received!");
+  }
+};
+
+void Component::construct(Genode::Env &env) {
+  static Signals::Main main(env);
+}

src/signals/server/target.mk

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