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.
121 lines
3.1 KiB
C++
121 lines
3.1 KiB
C++
/*
|
|
* \brief Implementation of the Thread API via Linux threads
|
|
* \author Norman Feske
|
|
* \date 2006-06-13
|
|
*/
|
|
|
|
/*
|
|
* 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.
|
|
*/
|
|
|
|
/* Genode includes */
|
|
#include <base/env.h>
|
|
#include <base/thread.h>
|
|
#include <base/snprintf.h>
|
|
#include <base/sleep.h>
|
|
#include <linux_cpu_session/linux_cpu_session.h>
|
|
|
|
/* Linux syscall bindings */
|
|
#include <linux_syscalls.h>
|
|
|
|
using namespace Genode;
|
|
|
|
|
|
static void empty_signal_handler(int) { }
|
|
|
|
|
|
/**
|
|
* Signal handler for killing the thread
|
|
*/
|
|
static void thread_exit_signal_handler(int) { lx_exit(0); }
|
|
|
|
|
|
static void thread_start(void *)
|
|
{
|
|
/*
|
|
* Set signal handler such that canceled system calls get not
|
|
* transparently retried after a signal gets received.
|
|
*/
|
|
lx_sigaction(LX_SIGUSR1, empty_signal_handler);
|
|
|
|
/*
|
|
* Prevent children from becoming zombies. (SIG_IGN = 1)
|
|
*/
|
|
lx_sigaction(LX_SIGCHLD, (void (*)(int))1);
|
|
|
|
Thread_base::myself()->entry();
|
|
sleep_forever();
|
|
}
|
|
|
|
|
|
void Thread_base::_init_platform_thread()
|
|
{
|
|
_thread_cap = env()->cpu_session()->create_thread(_context->name);
|
|
}
|
|
|
|
|
|
void Thread_base::_deinit_platform_thread()
|
|
{
|
|
/*
|
|
* Kill thread until it is really really dead
|
|
*
|
|
* We use the 'tgkill' system call to kill the thread. This system call
|
|
* returns immediately and just flags the corresponding signal at the
|
|
* targeted thread context. However, the thread still lives until the
|
|
* signal flags are evaluated. When leaving this function, however, we want
|
|
* to be sure that the thread is no more executing any code such that we
|
|
* an safely free and unmap the thread's stack. So we call 'tgkill' in a
|
|
* loop until we get an error indicating that the thread does not exists
|
|
* anymore.
|
|
*/
|
|
for (;;) {
|
|
|
|
/* destroy thread locally */
|
|
int ret = lx_tgkill(_tid.pid, _tid.tid, LX_SIGCANCEL);
|
|
|
|
if (ret < 0) break;
|
|
|
|
/* if thread still exists, wait a bit and try to kill it again */
|
|
struct timespec ts = { 0, 500 };
|
|
lx_nanosleep(&ts, 0);
|
|
}
|
|
|
|
/* inform core about the killed thread */
|
|
env()->cpu_session()->kill_thread(_thread_cap);
|
|
}
|
|
|
|
|
|
void Thread_base::start()
|
|
{
|
|
/*
|
|
* The first time we enter this code path, the 'start' function is
|
|
* called by the main thread as there cannot exist other threads
|
|
* without executing this function. When first called, we initialize
|
|
* the thread lib here.
|
|
*/
|
|
static bool threadlib_initialized = false;
|
|
if (!threadlib_initialized) {
|
|
lx_sigaction(LX_SIGCANCEL, thread_exit_signal_handler);
|
|
threadlib_initialized = true;
|
|
}
|
|
|
|
/* align initial stack to 16 byte boundary */
|
|
void *thread_sp = (void *)((addr_t)(_context->stack) & ~0xf);
|
|
_tid.tid = lx_create_thread(thread_start, thread_sp, this);
|
|
_tid.pid = lx_getpid();
|
|
|
|
/* inform core about the new thread and process ID of the new thread */
|
|
Linux_cpu_session *cpu = dynamic_cast<Linux_cpu_session *>(env()->cpu_session());
|
|
if (cpu)
|
|
cpu->thread_id(_thread_cap, _tid.pid, _tid.tid);
|
|
}
|
|
|
|
|
|
void Thread_base::cancel_blocking()
|
|
{
|
|
env()->cpu_session()->cancel_blocking(_thread_cap);
|
|
}
|