132569d12b
On Linux, Genode used to represent each RPC object by a socket descriptor of the receiving thread (entrypoint) and a globally-unique value that identifies the object. Because the latter was transferred as plain message payload, clients had to be trusted to not forge the values. For this reason, Linux could not be considered as a productive Genode base platform but remained merely a development vehicle. This patch changes the RPC mechanism such that each RPC object is represented by a dedicated socket pair. Entrypoints wait on a set of the local ends of the socket pairs of all RPC objects managed by the respective entrypoint. The epoll kernel interface is used as the underlying mechanism to wait for a set of socket descriptors at the server side. When delegating a capability, the remote end of the socket pair is transferred to the recipient along with a plaintext copy of the socket-descriptor value of the local end. The latter value serves as a hint for re-identifiying a capability whenever it is delegated back to its origin. Note that the client is not trusted to preserve this information. The integrity of the hint value is protected by comparing the inode values of incoming and already present capablities at the originating site (whenever the capability is invoked or presented to the owner of the RPC object). The new mechanism effectively equips base-linux with Genode's capablity model as described in the Chapter 3 of the Genode Foundations book. That said, the sandboxing of components cannot be assumed at this point because each component has still direct access to the Linux system-call interface. This patch is based on the extensive exploration work conducted by Stefan Thoeni who strongly motivated the inclusion of this feature into Genode. Issue #3581
65 lines
1.7 KiB
C++
65 lines
1.7 KiB
C++
/*
|
|
* \brief Back end of the RPC entrypoint
|
|
* \author Norman Feske
|
|
* \date 2016-01-19
|
|
*/
|
|
|
|
/*
|
|
* Copyright (C) 2016-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.
|
|
*/
|
|
|
|
/* Genode includes */
|
|
#include <base/env.h>
|
|
#include <base/rpc_server.h>
|
|
#include <deprecated/env.h>
|
|
|
|
/* base-internal includes */
|
|
#include <base/internal/native_thread.h>
|
|
|
|
using namespace Genode;
|
|
|
|
|
|
Native_capability Rpc_entrypoint::_alloc_rpc_cap(Pd_session& pd, Native_capability,
|
|
addr_t)
|
|
{
|
|
/* first we allocate a cap from core, to allow accounting of caps. */
|
|
for (;;) {
|
|
Ram_quota ram_upgrade { 0 };
|
|
Cap_quota cap_upgrade { 0 };
|
|
|
|
try { pd.alloc_rpc_cap(_cap); break; }
|
|
catch (Out_of_ram) { ram_upgrade = Ram_quota { 2*1024*sizeof(long) }; }
|
|
catch (Out_of_caps) { cap_upgrade = Cap_quota { 4 }; }
|
|
|
|
env_deprecated()->parent()->upgrade(Parent::Env::pd(),
|
|
String<100>("ram_quota=", ram_upgrade, ", "
|
|
"cap_quota=", cap_upgrade).string());
|
|
}
|
|
|
|
return Thread::native_thread().epoll.alloc_rpc_cap();
|
|
}
|
|
|
|
|
|
void Rpc_entrypoint::_free_rpc_cap(Pd_session& pd, Native_capability cap)
|
|
{
|
|
Native_thread::Epoll &epoll = Thread::native_thread().epoll;
|
|
|
|
/*
|
|
* Flag RPC entrypoint as exited to prevent 'free_rpc_cap' from issuing
|
|
* a remote control request.
|
|
*/
|
|
if (_exit_handler.exit)
|
|
epoll.rpc_ep_exited();
|
|
|
|
/*
|
|
* Perform the accounting of the PDs cap quota at core, to remain
|
|
* consistent with other kernel platforms.
|
|
*/
|
|
pd.free_rpc_cap(Native_capability());
|
|
|
|
epoll.free_rpc_cap(cap);
|
|
}
|