20d8655a7f
Genode used to create new processes by directly forking from the respective Genode parent using the process library. The forking process created a PD session at core merely for propagating the PID of the new process into core (for later destruction). This traditional mechanisms has the following disadvantages: First, the PID reported by the creating process to core cannot easily be validated by core. Therefore core has to trust the PD client to not specify a PID of an existing process, which would happen to be killed once the PD session gets destructed. This problem is documented by issue #318. Second, there is no way for a Genode process to detect the failure of its any grandchildren. The immediate parent of a faulting process could use the SIGCHLD-and-waitpid mechanism to observe its children but this mechanism does not work transitively. By performing the process creation exclusively within core, all Genode processes become immediate child processes of core. Hence, core can respond to failures of any of those processes and reflect such conditions via core's session interfaces. Furthermore, the PID associated to a PD session is locally known within core and cannot be forged anymore. In fact, there is actually no need at all to make processes aware of any PIDs of other processes. Please note that this patch breaks the 'chroot' mechanism that comes in the form of the 'os/src/app/chroot' program. Because all processes are forked from core, a chroot'ed process could sneak outside its chroot environment by just creating a new Genode process. To address this issue, the chroot mechanism must be added to core.
83 lines
2.0 KiB
C++
83 lines
2.0 KiB
C++
/*
|
|
* \brief Implementation of process creation for Linux
|
|
* \author Norman Feske
|
|
* \date 2006-07-06
|
|
*/
|
|
|
|
/*
|
|
* 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/elf.h>
|
|
#include <base/env.h>
|
|
#include <base/process.h>
|
|
#include <base/printf.h>
|
|
#include <linux_pd_session/client.h>
|
|
|
|
/* framework-internal includes */
|
|
#include <linux_syscalls.h>
|
|
|
|
|
|
using namespace Genode;
|
|
|
|
Dataspace_capability Process::_dynamic_linker_cap;
|
|
|
|
|
|
/**
|
|
* Check for dynamic ELF header
|
|
*/
|
|
static bool _check_dynamic_elf(Dataspace_capability elf_ds_cap)
|
|
{
|
|
/* attach ELF locally */
|
|
addr_t elf_addr;
|
|
|
|
try { elf_addr = env()->rm_session()->attach(elf_ds_cap); }
|
|
catch (...) { return false; }
|
|
|
|
/*
|
|
* If attach is called within core, it will return zero because
|
|
* Linux uses Core_rm_session.
|
|
*/
|
|
if (!elf_addr) return false;
|
|
|
|
/* read program header and interpreter */
|
|
Elf_binary elf((addr_t)elf_addr);
|
|
env()->rm_session()->detach((void *)elf_addr);
|
|
|
|
return elf.is_dynamically_linked();
|
|
}
|
|
|
|
|
|
Process::Process(Dataspace_capability elf_data_ds_cap,
|
|
Ram_session_capability ram_session_cap,
|
|
Cpu_session_capability cpu_session_cap,
|
|
Rm_session_capability rm_session_cap,
|
|
Parent_capability parent_cap,
|
|
const char *name,
|
|
char *const argv[])
|
|
:
|
|
_cpu_session_client(Cpu_session_capability()),
|
|
_rm_session_client(Rm_session_capability())
|
|
{
|
|
/* check for dynamic program header */
|
|
if (_check_dynamic_elf(elf_data_ds_cap)) {
|
|
if (!_dynamic_linker_cap.valid()) {
|
|
PERR("Dynamically linked file found, but no dynamic linker binary present");
|
|
return;
|
|
}
|
|
elf_data_ds_cap = _dynamic_linker_cap;
|
|
}
|
|
|
|
Linux_pd_session_client lx_pd(static_cap_cast<Linux_pd_session>(_pd.cap()));
|
|
|
|
lx_pd.assign_parent(parent_cap);
|
|
lx_pd.start(elf_data_ds_cap, name);
|
|
}
|
|
|
|
|
|
Process::~Process() { }
|