268 lines
6.3 KiB
C++
Executable File
268 lines
6.3 KiB
C++
Executable File
/*
|
|
* \brief Protection-domain facility
|
|
* \author Martin Stein
|
|
* \date 2010-09-13
|
|
*/
|
|
|
|
/*
|
|
* Copyright (C) 2010-2013 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 _SRC__CORE__INCLUDE__PLATFORM_PD_H_
|
|
#define _SRC__CORE__INCLUDE__PLATFORM_PD_H_
|
|
|
|
/* core includes */
|
|
#include <platform_thread.h>
|
|
#include <base/thread.h>
|
|
#include <kernel/config.h>
|
|
|
|
namespace Genode {
|
|
|
|
class Platform_pd;
|
|
|
|
typedef Id_allocator<Platform_pd, Native_process_id, Cpu::BYTE_WIDTH> Pid_allocator;
|
|
|
|
Pid_allocator *pid_allocator();
|
|
|
|
|
|
class Platform_thread;
|
|
class Platform_pd
|
|
{
|
|
public:
|
|
|
|
typedef unsigned Context_id;
|
|
typedef Thread_base::Context Context;
|
|
|
|
private:
|
|
|
|
addr_t context_area_base() {
|
|
return Native_config::context_area_virtual_base();
|
|
}
|
|
addr_t context_area_size() {
|
|
return Native_config::context_area_virtual_size();
|
|
}
|
|
addr_t context_area_top() {
|
|
return context_area_base() + context_area_size();
|
|
}
|
|
addr_t context_size() {
|
|
return Native_config::context_virtual_size();
|
|
}
|
|
addr_t context_base_mask() {
|
|
return ~(Native_config::context_virtual_size() - 1);
|
|
}
|
|
addr_t context_offset_mask() {
|
|
return ~context_base_mask();
|
|
}
|
|
|
|
enum {
|
|
CONTEXT_SIZE = Native_config::CONTEXT_VIRTUAL_SIZE,
|
|
CONTEXT_AREA_SIZE = Native_config::CONTEXT_AREA_VIRTUAL_SIZE,
|
|
MAX_CONTEXT_ID = CONTEXT_AREA_SIZE / CONTEXT_SIZE - 1
|
|
};
|
|
|
|
Native_process_id _pid;
|
|
|
|
Native_thread_id owner_tid_by_context_id[MAX_CONTEXT_ID + 1];
|
|
|
|
void _free_context(Native_thread_id const & t)
|
|
{
|
|
for (Context_id cid = 0; cid <= MAX_CONTEXT_ID; cid++) {
|
|
if (owner_tid_by_context_id[cid] == t) {
|
|
owner_tid_by_context_id[cid] = 0;
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
public:
|
|
|
|
/**
|
|
* Constructors
|
|
*/
|
|
Platform_pd(signed pid = 0, bool create = true) : _pid(pid)
|
|
{
|
|
static bool const verbose = false;
|
|
|
|
if ((unsigned)User::MAX_THREAD_ID>(unsigned)MAX_CONTEXT_ID) {
|
|
PERR("More threads allowed than context areas available");
|
|
return;
|
|
}
|
|
if (!_pid)
|
|
_pid=pid_allocator()->allocate(this);
|
|
|
|
if (!_pid) {
|
|
PERR("Allocating new Process ID failed");
|
|
return;
|
|
}
|
|
if (verbose)
|
|
PDBG("Create protection domain %i", (unsigned int)_pid);
|
|
}
|
|
|
|
/**
|
|
* Destructor
|
|
*/
|
|
~Platform_pd() { }
|
|
|
|
enum Context_part{ NO_CONTEXT_PART = 0,
|
|
MISC_AREA = 1,
|
|
UTCB_AREA = 2,
|
|
STACK_AREA = 3 };
|
|
|
|
bool cid_if_context_address(addr_t a, Context_id* cid)
|
|
{
|
|
if (a < context_area_base() || a >= context_area_top())
|
|
return false;
|
|
|
|
addr_t context_base = a & context_base_mask();
|
|
*cid = (Context_id)((context_base-context_area_base()) / context_size());
|
|
return true;
|
|
}
|
|
|
|
Context *context(Context_id i)
|
|
{
|
|
return (Context*)(context_area_base()+(i+1)*context_size()-sizeof(Context));
|
|
}
|
|
|
|
Context *context_by_tid(Native_thread_id tid)
|
|
{
|
|
for (unsigned cid = 0; cid <= MAX_CONTEXT_ID; cid++)
|
|
if (owner_tid_by_context_id[cid] == tid)
|
|
return context(cid);
|
|
|
|
return 0;
|
|
}
|
|
|
|
bool metadata_if_context_address(addr_t a, Native_thread_id *context_owner_tid,
|
|
Context_part *cp, unsigned *stack_offset)
|
|
{
|
|
Context_id cid;
|
|
if (!cid_if_context_address(a, &cid))
|
|
return false;
|
|
|
|
if (cid > MAX_CONTEXT_ID) {
|
|
PERR("Context ID %i out of range", (unsigned int)cid);
|
|
return false;
|
|
}
|
|
|
|
*context_owner_tid = owner_tid_by_context_id[cid];
|
|
if (!*context_owner_tid) {
|
|
if (_pid == Roottask::PROTECTION_ID)
|
|
PERR("Context %p is not in use", (void*)a);
|
|
|
|
return false;
|
|
}
|
|
|
|
addr_t offset = a & context_offset_mask();
|
|
Context *context = (Context *)(context_size() - sizeof(Context));
|
|
|
|
if ((void*)offset >= &context->utcb) {
|
|
*cp = UTCB_AREA;
|
|
|
|
} else if ((void*)offset < &context->stack) {
|
|
*cp = STACK_AREA;
|
|
*stack_offset = (((unsigned)&(context->stack)) - (unsigned)offset);
|
|
} else {
|
|
*cp = MISC_AREA;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
bool allocate_context(Native_thread_id tid, Context_id cid)
|
|
{
|
|
static bool const verbose = false;
|
|
|
|
if (cid > MAX_CONTEXT_ID)
|
|
return 0;
|
|
|
|
if (owner_tid_by_context_id[cid]){
|
|
PERR("Context is already in use");
|
|
return false;
|
|
}
|
|
owner_tid_by_context_id[cid] = tid;
|
|
if (verbose)
|
|
PDBG("Thread %i owns Context %i (0x%p) of PD %i",
|
|
tid, cid, context(cid), _pid);
|
|
return true;
|
|
}
|
|
|
|
Context *allocate_context(Native_thread_id tid)
|
|
{
|
|
static bool const verbose = false;
|
|
|
|
/*
|
|
* First thread is assumed to be the main thread and gets last
|
|
* context-area by convention
|
|
*/
|
|
if (!owner_tid_by_context_id[MAX_CONTEXT_ID]){
|
|
owner_tid_by_context_id[MAX_CONTEXT_ID] = tid;
|
|
if (verbose)
|
|
PDBG("Thread %i owns Context %i (0x%p) of Protection Domain %i",
|
|
tid, MAX_CONTEXT_ID, context(MAX_CONTEXT_ID), _pid);
|
|
|
|
return context(MAX_CONTEXT_ID);
|
|
}
|
|
|
|
for (unsigned i = 0; i <= MAX_CONTEXT_ID - 1; i++) {
|
|
if (!owner_tid_by_context_id[i]) {
|
|
owner_tid_by_context_id[i] = tid;
|
|
if (verbose)
|
|
PDBG("Thread %i owns Context %i (0x%p) of Protection Domain %i",
|
|
tid, MAX_CONTEXT_ID, context(MAX_CONTEXT_ID), _pid);
|
|
return context(i);
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* Bind thread to protection domain
|
|
*
|
|
* \return 0 on success
|
|
*/
|
|
inline int bind_thread(Platform_thread* pt)
|
|
{
|
|
Context *context = allocate_context(pt->tid());
|
|
if (!context) {
|
|
PERR("Context allocation failed");
|
|
return -1;
|
|
}
|
|
Native_utcb *utcb = &context->utcb;
|
|
pt->_assign_physical_thread(_pid, utcb, this);
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* Unbind thread from protection domain
|
|
*
|
|
* Free the thread's slot and update thread object.
|
|
*/
|
|
inline void unbind_thread(Platform_thread *pt)
|
|
{
|
|
_free_context(pt->tid());
|
|
}
|
|
|
|
/**
|
|
* Free a context so it is allocatable again
|
|
* \param c PD wide unique context ID
|
|
*/
|
|
void free_context(Context_id const & c)
|
|
{
|
|
if (c > MAX_CONTEXT_ID) { return; }
|
|
owner_tid_by_context_id[c] = Kernel::INVALID_THREAD_ID;
|
|
}
|
|
|
|
/**
|
|
* Assign parent interface to protection domain
|
|
*/
|
|
inline int assign_parent(Native_capability parent) { return 0; }
|
|
};
|
|
}
|
|
|
|
#endif /* _SRC__CORE__INCLUDE__PLATFORM_PD_H */
|
|
|
|
|
|
|