Make Topology service part of a component's environment, just like CPU.

repos/base/include/base/child.h

@@ -26,6 +26,7 @@
 #include <cpu_session/connection.h>
 #include <log_session/connection.h>
 #include <rom_session/connection.h>
+#include <topo_session/connection.h>
 #include <parent/capability.h>
 
 namespace Genode {
@@ -609,6 +610,7 @@ class Genode::Child : protected Rpc_object<Parent>,
 		Env_connection<Cpu_connection> _cpu    { *this, Env::cpu(),    _policy.name() };
 		Env_connection<Log_connection> _log    { *this, Env::log(),    _policy.name() };
 		Env_connection<Rom_connection> _binary { *this, Env::binary(), _policy.binary_name() };
+		Env_connection<Topo_connection> _topo  { *this, Env::topo(),    _policy.name() };
 
 		Constructible<Env_connection<Rom_connection> > _linker { };
 
@@ -761,6 +763,7 @@ class Genode::Child : protected Rpc_object<Parent>,
 		Ram_allocator       &ram()       { return _pd.session(); }
 		Ram_allocator const &ram() const { return _pd.session(); }
 		Cpu_session         &cpu()       { return _cpu.session(); }
+		Topo_session        &topo() 	 { return _topo.session(); }
 		Pd_session          &pd()        { return _pd.session(); }
 		Pd_session    const &pd()  const { return _pd.session(); }
 

repos/base/include/base/env.h

@@ -18,6 +18,7 @@
 #include <base/entrypoint.h>
 #include <cpu_session/capability.h>
 #include <pd_session/capability.h>
+#include <topo_session/capability.h>
 
 namespace Genode { struct Env; }
 
@@ -48,6 +49,12 @@ struct Genode::Env : Interface
 	 */
 	Ram_allocator &ram() { return pd(); }
 
+	/**
+	 * @brief Topology model
+	 * 
+	 */
+	virtual Topo_session &topo() = 0;
+
 	/**
 	 * Entrypoint for handling RPC requests and signals
 	 */
@@ -63,6 +70,12 @@ struct Genode::Env : Interface
 	 */
 	virtual Pd_session_capability pd_session_cap()  = 0;
 
+	/**
+	 * @brief Return the Topo-session capability 
+	 * 
+	 */
+	virtual Topo_session_capability topo_session_cap() = 0;
+
 	/**
 	 * ID space of sessions obtained from the parent
 	 */

repos/base/include/deprecated/env.h

@@ -22,6 +22,8 @@
 #include <region_map/region_map.h>
 #include <cpu_session/cpu_session.h>
 #include <cpu_session/capability.h>
+#include <topo_session/topo_session.h>
+#include <topo_session/capability.h>
 #include <pd_session/capability.h>
 #include <base/allocator.h>
 #include <base/snprintf.h>
@@ -87,6 +89,9 @@ struct Genode::Env_deprecated : Interface
 	 */
 	virtual Pd_session *pd_session() = 0;
 	virtual Pd_session_capability pd_session_cap() = 0;
+
+	virtual Topo_session *topo_session() = 0;
+	virtual Topo_session_capability topo_session_cap() = 0;
 };
 
 #endif /* _INCLUDE__DEPRECATED__ENV_H_ */

repos/base/include/parent/parent.h

@@ -71,7 +71,8 @@ class Genode::Parent
 			static Client::Id log()     { return { 3 }; }
 			static Client::Id binary()  { return { 4 }; }
 			static Client::Id linker()  { return { 5 }; }
-			static Client::Id last()    { return { 5 }; }
+			static Client::Id topo() 	{ return { 6 }; }
+			static Client::Id last()    { return { 6 }; }
 
 			/**
 			 * True if session ID refers to an environment session

repos/base/src/core/include/core_env.h

@@ -18,6 +18,7 @@
 /* Genode includes */
 #include <base/env.h>
 #include <deprecated/env.h>
+#include <topo_session/capability.h>
 
 /* base-internal includes */
 #include <base/internal/globals.h>
@@ -98,6 +99,8 @@ class Genode::Core_env : public Env_deprecated, Noncopyable
 		Pd_session             *pd_session()      override { return &_pd_session; }
 		Cpu_session            *cpu_session()     override { ASSERT_NEVER_CALLED; }
 		Cpu_session_capability  cpu_session_cap() override { ASSERT_NEVER_CALLED; }
+		Topo_session *topo_session() override { ASSERT_NEVER_CALLED; }
+		Topo_session_capability topo_session_cap() override { ASSERT_NEVER_CALLED; }
 		Pd_session_capability   pd_session_cap()  override { return _pd_session.cap(); }
 };
 

repos/base/src/include/base/internal/expanding_topo_session_client.h

@@ -0,0 +1,51 @@
+/*
+ * \brief   Topology session client that upgrades its session quota on demand
+ * \author  Michael Müller
+ * \date    2022-10-06
+ * 
+ * A topology session stores the component's view on the hardware topology, i.e. it's location within the NUMA topology.
+ */
+
+/*
+ * Copyright (C) 2022 Michael Müller
+ *
+ * This file is part of EalánOS which is based on the Genode OS framework
+ * released under the terms of the GNU Affero General Public License version 3.
+ */
+
+#pragma once
+
+#include <util/retry.h>
+#include <topo_session/client.h>
+
+#include <base/internal/upgradeable_client.h>
+
+namespace Genode {
+    struct Expanding_topo_session_client;
+}
+
+struct Genode::Expanding_topo_session_client : Upgradeable_client<Genode::Topo_session_client>
+{
+    Expanding_topo_session_client(Parent &parent, Genode::Topo_session_capability cap, Parent::Client::Id id) 
+    :
+        Upgradeable_client<Genode::Topo_session_client>
+            (parent, static_cap_cast<Genode::Topo_session_client::Rpc_interface>(cap), id)
+    { }
+
+    Node *node_affinity_of(Affinity::Location &loc) override 
+    {
+        return retry<Out_of_ram>(
+            [&]()
+            {
+                return retry<Out_of_caps>(
+                    [&]()
+                    {
+                        return Topo_session_client::node_affinity_of(loc);
+                    },
+                    [&]()
+                    { upgrade_caps(2); });
+            },
+            [&]()
+            { upgrade_ram(8 * 1024); });
+    }
+};

repos/base/src/include/base/internal/platform_env.h

@@ -34,6 +34,7 @@
 #include <base/internal/expanding_pd_session_client.h>
 #include <base/internal/expanding_region_map_client.h>
 #include <base/internal/expanding_parent_client.h>
+#include <base/internal/expanding_topo_session_client.h>
 
 
 namespace Genode {
@@ -60,13 +61,15 @@ class Genode::Platform_env : public Platform_env_base
 			Expanding_pd_session_client  pd;
 			Expanding_cpu_session_client cpu;
 			Expanding_region_map_client  rm;
+			Expanding_topo_session_client topo;
 
 			Resources(Parent &parent)
 			:
 				pd (parent, request<Pd_session> (parent, Parent::Env::pd())),
 				cpu(parent, request<Cpu_session>(parent, Parent::Env::cpu()),
 				                                 Parent::Env::cpu()),
-				rm(parent, pd.rpc_cap(), pd.address_space(), Parent::Env::pd())
+				rm(parent, pd.rpc_cap(), pd.address_space(), Parent::Env::pd()),
+				topo(parent, request<Topo_session>(parent, Parent::Env::topo()), Parent::Env::topo())
 			{ }
 		};
 
@@ -107,6 +110,8 @@ class Genode::Platform_env : public Platform_env_base
 		Pd_session             *pd_session()      override { return &_resources.pd; }
 		Pd_session_capability   pd_session_cap()  override { return  _resources.pd.rpc_cap(); }
 		Region_map             *rm_session()      override { return &_resources.rm; }
+		Topo_session *topo_session() override { return &_resources.topo; }
+		Topo_session_capability topo_session_cap() override { return _resources.topo.rpc_cap();  }
 };
 
 #endif /* _INCLUDE__BASE__INTERNAL__PLATFORM_ENV_H_ */

repos/base/src/lib/base/component.cc

@@ -22,6 +22,7 @@
 
 /* base-internal includes */
 #include <base/internal/globals.h>
+#include <topo_session/capability.h>
 
 /*
  * XXX remove this pointer once 'Env_deprecated' is removed
@@ -78,6 +79,7 @@ namespace {
 		Genode::Region_map  &rm()     override { return *Genode::env_deprecated()->rm_session(); }
 		Genode::Pd_session  &pd()     override { return *Genode::env_deprecated()->pd_session(); }
 		Genode::Entrypoint  &ep()     override { return _ep; }
+		Genode::Topo_session &topo() override { return *Genode::env_deprecated()->topo_session(); }
 
 		Genode::Cpu_session_capability cpu_session_cap() override
 		{
@@ -94,6 +96,11 @@ namespace {
 			return Genode::env_session_id_space();
 		}
 
+		Genode::Topo_session_capability topo_session_cap() override 
+		{
+			return Genode::env_deprecated()->topo_session_cap();
+		}
+
 		void _block_for_session()
 		{
 			/*

repos/base/src/lib/base/env_session_id_space.cc

@@ -34,7 +34,8 @@ Id_space<Parent::Client> &Genode::env_session_id_space()
 		cpu    { dummy, id_space, Parent::Env::cpu()    },
 		log    { dummy, id_space, Parent::Env::log()    },
 		binary { dummy, id_space, Parent::Env::binary() },
-		linker { dummy, id_space, Parent::Env::linker() };
+		linker { dummy, id_space, Parent::Env::linker() },
+		topo   { dummy, id_space, Parent::Env::topo()   };
 
 	return id_space;
 }