base: fix dangling session pointers in rm_session

If page faults are handled concurrently (as for base-nova) the traverse lookup
call in rm_session_component must be thread safe, which it isn't.
If the faulting area is backed by nested dataspaces which are managed by
various rm_sessions then a race happens under following circumstances
(triggered occasionally by the bomb test).

The traverse lookup may return a pointer to a rm_session of a nested dataspace.
If the rm_session is in parallel subject to destruction it happened that faults
got enqueued to the faulters list of the deleted rm_session and internally to
a list of the current rm_session of the Rm_client.

During destruction of the faulting Rm_client the associated rm_session will
be dissolved from the Rm_client, which leads to dereferencing the
dangling pointer of the already destructed rm_session.

On base-nova the memory of the rm_session object get unmapped eventually, so
that the de-referencing of the dangling pointer caused page faults in core.

The memory on other kernels inside core never get unmapped so that the
bug doesn't trigger visible faults.

The patch replace the keeping of a rm_session pointer by keeping a
capability instead. The rm_session object must be looked up now explicitly in
the Object_pool implementation, which implements proper reference counting on
the rm_session object.

Issue #549

base-linux/src/core/include/rm_session_component.h

@@ -28,10 +28,20 @@ namespace Genode {
 
 	class Rm_session_component : public Rpc_object<Rm_session>
 	{
+		private:
+
+			class Rm_dataspace_component {
+
+				public:
+
+					void sub_rm_session(Native_capability _cap) { }
+			};
+
 		public:
 
 			Rm_session_component(Rpc_entrypoint    *ds_ep,
 			                     Rpc_entrypoint    *thread_ep,
+			                     Rpc_entrypoint    *session_ep,
 			                     Allocator         *md_alloc,
 			                     size_t             ram_quota,
 			                     Pager_entrypoint  *pager_ep,
@@ -56,7 +66,7 @@ namespace Genode {
 
 			Dataspace_capability dataspace() { return Dataspace_capability(); }
 
-			void dissolve(Rm_client *cl) { }
+			Rm_dataspace_component *dataspace_component() { return 0; }
 	};
 
 	struct Rm_member { Rm_session_component *member_rm_session() { return 0; } };