base-nova: cleanup specific Rm_session_client

- Align implementation to the current generic implementation
- Document NOVA-specific implementation of dataspace() (as in the
  original commit message)

repos/base-nova/include/rm_session/client.h

@@ -18,46 +18,55 @@
 #include <rm_session/capability.h>
 #include <base/rpc_client.h>
 
-namespace Genode {
+namespace Genode { struct Rm_session_client; }
 
-	struct Rm_session_client : Rpc_client<Rm_session>
+
+struct Genode::Rm_session_client : Rpc_client<Rm_session>
+{
+	/*
+	 * Multiple calls to get the dataspace capability on NOVA lead to the
+	 * situation that the caller gets each time a new mapping of the same
+	 * capability at different indexes. But the client/caller assumes to get
+	 * every time the very same index, e.g. in Noux the index is used to look
+	 * up data structures attached to the capability. Therefore, we cache the
+	 * dataspace capability on the first request.
+	 */
+	Dataspace_capability _rm_ds_cap;
+
+	explicit Rm_session_client(Rm_session_capability session)
+	: Rpc_client<Rm_session>(session) { }
+
+	Local_addr attach(Dataspace_capability ds, size_t size = 0,
+	                  off_t offset = 0, bool use_local_addr = false,
+	                  Local_addr local_addr = (void *)0,
+	                  bool executable = false) override
 	{
-		Dataspace_capability _rm_ds_cap;
+		return call<Rpc_attach>(ds, size, offset,
+		                        use_local_addr, local_addr,
+		                        executable);
+	}
 
-		explicit Rm_session_client(Rm_session_capability session)
-		: Rpc_client<Rm_session>(session) { }
+	void detach(Local_addr local_addr) override {
+		call<Rpc_detach>(local_addr); }
 
-		Local_addr attach(Dataspace_capability ds, size_t size = 0,
-		                  off_t offset = 0, bool use_local_addr = false,
-		                  Local_addr local_addr = (void *)0,
-		                  bool executable = false)
-		{
-			return call<Rpc_attach>(ds, size, offset,
-			                        use_local_addr, local_addr,
-			                        executable);
-		}
+	Pager_capability add_client(Thread_capability thread) override {
+		return call<Rpc_add_client>(thread); }
 
-		void detach(Local_addr local_addr) {
-			call<Rpc_detach>(local_addr); }
+	void remove_client(Pager_capability pager) override {
+		call<Rpc_remove_client>(pager); }
 
-		Pager_capability add_client(Thread_capability thread) {
-			return call<Rpc_add_client>(thread); }
+	void fault_handler(Signal_context_capability handler) override {
+		call<Rpc_fault_handler>(handler); }
 
-		void remove_client(Pager_capability pager) {
-			call<Rpc_remove_client>(pager); }
+	State state() override {
+		return call<Rpc_state>(); }
 
-		void fault_handler(Signal_context_capability handler) {
-			call<Rpc_fault_handler>(handler); }
-
-		State state() {
-			return call<Rpc_state>(); }
-
-		Dataspace_capability dataspace() {
-			if (!_rm_ds_cap.valid())
-				_rm_ds_cap = call<Rpc_dataspace>();
-			return _rm_ds_cap;
-		}
-	};
-}
+	Dataspace_capability dataspace() override
+	{
+		if (!_rm_ds_cap.valid())
+			_rm_ds_cap = call<Rpc_dataspace>();
+		return _rm_ds_cap;
+	}
+};
 
 #endif /* _INCLUDE__RM_SESSION__CLIENT_H_ */