aee0a2061b
This patch alleviates the need for any non-core process to create Unix domain sockets locally. All sockets used for RPC communication are created by core and subsequently passed to the other processes via RPC or the parent interface. The immediate benefit is that no process other than core needs to access the 'rpath' directory in order to communicate. However, access to 'rpath' is still needed for accessing dataspaces. Core creates one socket pair per thread on demand on the first call of the 'Linux_cpu_session::server_sd()' or 'Linux_cpu_session::client_sd()' functions. 'Linux_cpu_session' is a Linux-specific extension to the CPU session interface. In addition to the socket accessors, the extension provides a mechanism to register the PID/TID of a thread. Those information were formerly propagated into core along with the thread name as argument to 'create_thread()'. Because core creates socket pairs for entrypoints, it needs to know all threads that are potential entrypoints. For lx_hybrid programs, we hadn't had propagated any thread information into core, yet. Hence, this patch also contains the code for registering threads of hybrid applications at core.
83 lines
2.4 KiB
C++
83 lines
2.4 KiB
C++
/*
|
|
* \brief Client-side CPU session interface
|
|
* \author Norman Feske
|
|
* \date 2012-08-09
|
|
*/
|
|
|
|
/*
|
|
* Copyright (C) 2006-2012 Genode Labs GmbH
|
|
*
|
|
* This file is part of the Genode OS framework, which is distributed
|
|
* under the terms of the GNU General Public License version 2.
|
|
*/
|
|
|
|
#ifndef _INCLUDE__LINUX_CPU_SESSION__CLIENT_H_
|
|
#define _INCLUDE__LINUX_CPU_SESSION__CLIENT_H_
|
|
|
|
#include <linux_cpu_session/linux_cpu_session.h>
|
|
#include <base/rpc_client.h>
|
|
|
|
namespace Genode {
|
|
|
|
struct Linux_cpu_session_client : Rpc_client<Linux_cpu_session>
|
|
{
|
|
explicit Linux_cpu_session_client(Capability<Linux_cpu_session> session)
|
|
: Rpc_client<Linux_cpu_session>(session) { }
|
|
|
|
Thread_capability create_thread(Name const &name, addr_t utcb = 0) {
|
|
return call<Rpc_create_thread>(name, utcb); }
|
|
|
|
Ram_dataspace_capability utcb(Thread_capability thread) {
|
|
return call<Rpc_utcb>(thread); }
|
|
|
|
void kill_thread(Thread_capability thread) {
|
|
call<Rpc_kill_thread>(thread); }
|
|
|
|
int set_pager(Thread_capability thread, Pager_capability pager) {
|
|
return call<Rpc_set_pager>(thread, pager); }
|
|
|
|
int start(Thread_capability thread, addr_t ip, addr_t sp) {
|
|
return call<Rpc_start>(thread, ip, sp); }
|
|
|
|
void pause(Thread_capability thread) {
|
|
call<Rpc_pause>(thread); }
|
|
|
|
void resume(Thread_capability thread) {
|
|
call<Rpc_resume>(thread); }
|
|
|
|
void cancel_blocking(Thread_capability thread) {
|
|
call<Rpc_cancel_blocking>(thread); }
|
|
|
|
int state(Thread_capability thread, Thread_state *dst_state) {
|
|
return call<Rpc_state>(thread, dst_state); }
|
|
|
|
void exception_handler(Thread_capability thread, Signal_context_capability handler) {
|
|
call<Rpc_exception_handler>(thread, handler); }
|
|
|
|
void single_step(Thread_capability thread, bool enable) {
|
|
call<Rpc_single_step>(thread, enable); }
|
|
|
|
unsigned num_cpus() const {
|
|
return call<Rpc_num_cpus>(); }
|
|
|
|
void affinity(Thread_capability thread, unsigned cpu) {
|
|
call<Rpc_affinity>(thread, cpu); }
|
|
|
|
|
|
/*****************************
|
|
* Linux-specific extension **
|
|
*****************************/
|
|
|
|
void thread_id(Thread_capability thread, int pid, int tid) {
|
|
call<Rpc_thread_id>(thread, pid, tid); }
|
|
|
|
Untyped_capability server_sd(Thread_capability thread) {
|
|
return call<Rpc_server_sd>(thread); }
|
|
|
|
Untyped_capability client_sd(Thread_capability thread) {
|
|
return call<Rpc_client_sd>(thread); }
|
|
};
|
|
}
|
|
|
|
#endif /* _INCLUDE__CPU_SESSION__CLIENT_H_ */
|