ehmry/genode
ehmry
/
genode
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Move context area definition to native_type

This commit is contained in:
Alexander Boettcher 2012-08-29 14:42:56 +02:00 committed by Norman Feske
parent 62d81ae487
commit ea38aad30e
33 changed files with 275 additions and 110 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

15
base-codezero/include/base/native_types.h
View File

@ -15,6 +15,7 @@
#define _INCLUDE__BASE__NATIVE_TYPES_H_ #define _INCLUDE__BASE__NATIVE_TYPES_H_
#include <base/native_capability.h> #include <base/native_capability.h>
#include <base/stdint.h>
namespace Codezero { namespace Codezero {
@ -115,6 +116,20 @@ namespace Genode {
typedef Native_capability_tpl<Cap_dst_policy> Native_capability; typedef Native_capability_tpl<Cap_dst_policy> Native_capability;
typedef int Native_connection_state; typedef int Native_connection_state;
struct Native_config
{
/**
* Thread-context area configuration.
*/
static addr_t context_area_virtual_base() { return 0x40000000UL; }
static addr_t context_area_virtual_size() { return 0x10000000UL; }
/**
* Size of virtual address region holding the context of one thread
*/
static addr_t context_virtual_size() { return 0x00100000UL; }
};
} }

4
base-codezero/src/core/platform.cc
View File

@ -250,8 +250,8 @@ Platform::Platform() :
_core_mem_alloc.virt_alloc()->remove_range(core_virt_beg, core_size); _core_mem_alloc.virt_alloc()->remove_range(core_virt_beg, core_size);
/* preserve context area in core's virtual address space */ /* preserve context area in core's virtual address space */
_core_mem_alloc.virt_alloc()->raw()->remove_range(Thread_base::CONTEXT_AREA_VIRTUAL_BASE, _core_mem_alloc.virt_alloc()->raw()->remove_range(Native_config::context_area_virtual_base(),
Thread_base::CONTEXT_AREA_VIRTUAL_SIZE); Native_config::context_area_virtual_size());
/* remove used core memory from physical memory allocator */ /* remove used core memory from physical memory allocator */
_core_mem_alloc.phys_alloc()->remove_range(_lma_start, core_size); _core_mem_alloc.phys_alloc()->remove_range(_lma_start, core_size);

15
base-fiasco/include/base/native_types.h
View File

@ -15,6 +15,7 @@
#define _INCLUDE__BASE__NATIVE_TYPES_H_ #define _INCLUDE__BASE__NATIVE_TYPES_H_
#include <base/native_capability.h> #include <base/native_capability.h>
#include <base/stdint.h>
namespace Fiasco { namespace Fiasco {
#include <l4/sys/types.h> #include <l4/sys/types.h>
@ -73,6 +74,20 @@ namespace Genode {
typedef Native_capability_tpl<Cap_dst_policy> Native_capability; typedef Native_capability_tpl<Cap_dst_policy> Native_capability;
typedef Fiasco::l4_threadid_t Native_connection_state; typedef Fiasco::l4_threadid_t Native_connection_state;
struct Native_config
{
/**
* Thread-context area configuration.
*/
static addr_t context_area_virtual_base() { return 0x40000000UL; }
static addr_t context_area_virtual_size() { return 0x10000000UL; }
/**
* Size of virtual address region holding the context of one thread
*/
static addr_t context_virtual_size() { return 0x00100000UL; }
};
} }
#endif /* _INCLUDE__BASE__NATIVE_TYPES_H_ */ #endif /* _INCLUDE__BASE__NATIVE_TYPES_H_ */

4
base-fiasco/src/core/platform.cc
View File

@ -391,8 +391,8 @@ void Platform::_setup_basics()
_region_alloc.add_range(_vm_start, _vm_size); _region_alloc.add_range(_vm_start, _vm_size);
/* preserve context area in core's virtual address space */ /* preserve context area in core's virtual address space */
_region_alloc.remove_range(Thread_base::CONTEXT_AREA_VIRTUAL_BASE, _region_alloc.remove_range(Native_config::context_area_virtual_base(),
Thread_base::CONTEXT_AREA_VIRTUAL_SIZE); Native_config::context_area_virtual_size());
/* I/O memory could be the whole user address space */ /* I/O memory could be the whole user address space */
/* FIXME if the kernel helps to find out max address - use info here */ /* FIXME if the kernel helps to find out max address - use info here */

15
base-foc/include/base/native_types.h
View File

@ -2,6 +2,7 @@
#define _INCLUDE__BASE__NATIVE_TYPES_H_ #define _INCLUDE__BASE__NATIVE_TYPES_H_
#include <base/cap_map.h> #include <base/cap_map.h>
#include <base/stdint.h>
namespace Fiasco { namespace Fiasco {
#include <l4/sys/consts.h> #include <l4/sys/consts.h>
@ -146,6 +147,20 @@ namespace Genode {
typedef int Native_connection_state; typedef int Native_connection_state;
struct Native_config
{
/**
* Thread-context area configuration.
*/
static addr_t context_area_virtual_base() { return 0x40000000UL; }
static addr_t context_area_virtual_size() { return 0x10000000UL; }
/**
* Size of virtual address region holding the context of one thread
*/
static addr_t context_virtual_size() { return 0x00100000UL; }
};
} }
#endif /* _INCLUDE__BASE__NATIVE_TYPES_H_ */ #endif /* _INCLUDE__BASE__NATIVE_TYPES_H_ */

18
base-foc/src/base/thread/thread.cc
View File

@ -41,14 +41,14 @@ namespace Genode {
Thread_base::Context *Thread_base::Context_allocator::base_to_context(addr_t base) Thread_base::Context *Thread_base::Context_allocator::base_to_context(addr_t base)
{ {
addr_t result = base + CONTEXT_VIRTUAL_SIZE - sizeof(Context); addr_t result = base + Native_config::context_virtual_size() - sizeof(Context);
return reinterpret_cast<Context *>(result); return reinterpret_cast<Context *>(result);
} }
addr_t Thread_base::Context_allocator::addr_to_base(void *addr) addr_t Thread_base::Context_allocator::addr_to_base(void *addr)
{ {
return ((addr_t)addr) & CONTEXT_VIRTUAL_BASE_MASK; return ((addr_t)addr) & ~(Native_config::context_virtual_size() - 1);
} }
@ -70,11 +70,11 @@ Thread_base::Context *Thread_base::Context_allocator::alloc(Thread_base *thread_
/* /*
* Find slot in context area for the new context * Find slot in context area for the new context
*/ */
addr_t base = CONTEXT_AREA_VIRTUAL_BASE; addr_t base = Native_config::context_area_virtual_base();
for (; _is_in_use(base); base += CONTEXT_VIRTUAL_SIZE) { for (; _is_in_use(base); base += Native_config::context_virtual_size()) {
/* check upper bound of context area */ /* check upper bound of context area */
if (base >= CONTEXT_AREA_VIRTUAL_BASE + CONTEXT_AREA_VIRTUAL_SIZE) if (base >= Native_config::context_area_virtual_base() + Native_config::context_area_virtual_size())
return 0; return 0;
} }
@ -122,7 +122,7 @@ Thread_base::Context *Thread_base::_alloc_context(size_t stack_size)
enum { PAGE_SIZE_LOG2 = 12 }; enum { PAGE_SIZE_LOG2 = 12 };
size_t ds_size = align_addr(stack_size, PAGE_SIZE_LOG2); size_t ds_size = align_addr(stack_size, PAGE_SIZE_LOG2);
if (stack_size >= CONTEXT_VIRTUAL_SIZE - sizeof(Native_utcb) - (1 << PAGE_SIZE_LOG2)) if (stack_size >= Native_config::context_virtual_size() - sizeof(Native_utcb) - (1 << PAGE_SIZE_LOG2))
throw Stack_too_large(); throw Stack_too_large();
/* /*
@ -130,7 +130,7 @@ Thread_base::Context *Thread_base::_alloc_context(size_t stack_size)
* *
* The stack is always located at the top of the context. * The stack is always located at the top of the context.
*/ */
addr_t ds_addr = Context_allocator::addr_to_base(context) + CONTEXT_VIRTUAL_SIZE addr_t ds_addr = Context_allocator::addr_to_base(context) + Native_config::context_virtual_size()
- ds_size; - ds_size;
/* add padding for UTCB if defined for the platform */ /* add padding for UTCB if defined for the platform */
@ -141,7 +141,7 @@ Thread_base::Context *Thread_base::_alloc_context(size_t stack_size)
Ram_dataspace_capability ds_cap; Ram_dataspace_capability ds_cap;
try { try {
ds_cap = env_context_area_ram_session()->alloc(ds_size); ds_cap = env_context_area_ram_session()->alloc(ds_size);
addr_t attach_addr = ds_addr - CONTEXT_AREA_VIRTUAL_BASE; addr_t attach_addr = ds_addr - Native_config::context_area_virtual_base();
env_context_area_rm_session()->attach_at(ds_cap, attach_addr, ds_size); env_context_area_rm_session()->attach_at(ds_cap, attach_addr, ds_size);
} catch (Ram_session::Alloc_failed) { } catch (Ram_session::Alloc_failed) {
@ -166,7 +166,7 @@ Thread_base::Context *Thread_base::_alloc_context(size_t stack_size)
void Thread_base::_free_context() void Thread_base::_free_context()
{ {
addr_t ds_addr = _context->stack_base - CONTEXT_AREA_VIRTUAL_BASE; addr_t ds_addr = _context->stack_base - Native_config::context_area_virtual_base();
Ram_dataspace_capability ds_cap = _context->ds_cap; Ram_dataspace_capability ds_cap = _context->ds_cap;
Genode::env_context_area_rm_session()->detach((void *)ds_addr); Genode::env_context_area_rm_session()->detach((void *)ds_addr);
Genode::env_context_area_ram_session()->free(ds_cap); Genode::env_context_area_ram_session()->free(ds_cap);

8
base-foc/src/core/include/platform_pd.h
View File

@ -43,10 +43,14 @@ namespace Genode {
enum { enum {
THREAD_MAX = (1 << 6), THREAD_MAX = (1 << 6),
UTCB_AREA_SIZE = (THREAD_MAX * Fiasco::L4_UTCB_OFFSET), UTCB_AREA_SIZE = (THREAD_MAX * Fiasco::L4_UTCB_OFFSET),
UTCB_AREA_START = (Thread_base::CONTEXT_AREA_VIRTUAL_BASE +
THREAD_MAX * Thread_base::CONTEXT_VIRTUAL_SIZE)
}; };
addr_t utcb_area_start()
{
return (Native_config::context_area_virtual_base() +
THREAD_MAX * Native_config::context_virtual_size());
}
Cap_mapping _task; Cap_mapping _task;
Cap_mapping _parent; Cap_mapping _parent;
Platform_thread *_threads[THREAD_MAX]; Platform_thread *_threads[THREAD_MAX];

4
base-foc/src/core/platform.cc
View File

@ -374,8 +374,8 @@ void Platform::_setup_basics()
_region_alloc.add_range(_vm_start, _vm_size); _region_alloc.add_range(_vm_start, _vm_size);
/* preserve context area in core's virtual address space */ /* preserve context area in core's virtual address space */
_region_alloc.remove_range(Thread_base::CONTEXT_AREA_VIRTUAL_BASE, _region_alloc.remove_range(Native_config::context_area_virtual_base(),
Thread_base::CONTEXT_AREA_VIRTUAL_SIZE); Native_config::context_area_virtual_size());
/* preserve utcb- area in core's virtual address space */ /* preserve utcb- area in core's virtual address space */
_region_alloc.remove_range((addr_t)l4_utcb(), L4_PAGESIZE); _region_alloc.remove_range((addr_t)l4_utcb(), L4_PAGESIZE);

4
base-foc/src/core/platform_pd.cc
View File

@ -52,7 +52,7 @@ int Platform_pd::bind_thread(Platform_thread *thread)
thread->_utcb = (l4_utcb_t*) (core_utcb_base() + i * L4_UTCB_OFFSET); thread->_utcb = (l4_utcb_t*) (core_utcb_base() + i * L4_UTCB_OFFSET);
else else
thread->_utcb = thread->_utcb =
reinterpret_cast<l4_utcb_t*>(UTCB_AREA_START + i * L4_UTCB_OFFSET); reinterpret_cast<l4_utcb_t*>(utcb_area_start() + i * L4_UTCB_OFFSET);
Native_thread cap_offset = THREADS_BASE_CAP + i * THREAD_CAP_SLOT; Native_thread cap_offset = THREADS_BASE_CAP + i * THREAD_CAP_SLOT;
thread->_gate.remote = cap_offset + THREAD_GATE_CAP; thread->_gate.remote = cap_offset + THREAD_GATE_CAP;
thread->_pager.remote = cap_offset + THREAD_PAGER_CAP; thread->_pager.remote = cap_offset + THREAD_PAGER_CAP;
@ -110,7 +110,7 @@ Platform_pd::Platform_pd()
for (unsigned i = 0; i < THREAD_MAX; i++) for (unsigned i = 0; i < THREAD_MAX; i++)
_threads[i] = (Platform_thread*) 0; _threads[i] = (Platform_thread*) 0;
l4_fpage_t utcb_area = l4_fpage(UTCB_AREA_START, l4_fpage_t utcb_area = l4_fpage(utcb_area_start(),
log2<unsigned>(UTCB_AREA_SIZE), 0); log2<unsigned>(UTCB_AREA_SIZE), 0);
l4_msgtag_t tag = l4_factory_create_task(L4_BASE_FACTORY_CAP, l4_msgtag_t tag = l4_factory_create_task(L4_BASE_FACTORY_CAP,
_task.local.dst(), utcb_area); _task.local.dst(), utcb_area);

15
base-host/include/base/native_types.h
View File

@ -15,6 +15,7 @@
#define _INCLUDE__BASE__NATIVE_TYPES_H_ #define _INCLUDE__BASE__NATIVE_TYPES_H_
#include <base/native_capability.h> #include <base/native_capability.h>
#include <base/stdint.h>
namespace Genode { namespace Genode {
@ -31,6 +32,20 @@ namespace Genode {
typedef struct { } Native_utcb; typedef struct { } Native_utcb;
typedef int Native_connection_state; typedef int Native_connection_state;
typedef Native_capability_tpl<Cap_dst_policy> Native_capability; typedef Native_capability_tpl<Cap_dst_policy> Native_capability;
struct Native_config
{
/**
* Thread-context area configuration.
*/
static addr_t context_area_virtual_base() { return 0x40000000UL; }
static addr_t context_area_virtual_size() { return 0x10000000UL; }
/**
* Size of virtual address region holding the context of one thread
*/
static addr_t context_virtual_size() { return 0x00100000UL; }
};
} }
#endif /* _INCLUDE__BASE__NATIVE_TYPES_H_ */ #endif /* _INCLUDE__BASE__NATIVE_TYPES_H_ */

15
base-hw/include/base/native_types.h
View File

@ -17,6 +17,7 @@
/* Genode includes */ /* Genode includes */
#include <kernel/syscalls.h> #include <kernel/syscalls.h>
#include <base/native_capability.h> #include <base/native_capability.h>
#include <base/stdint.h>
namespace Genode namespace Genode
{ {
@ -136,6 +137,20 @@ namespace Genode
addr_t base; addr_t base;
size_t size; size_t size;
}; };
struct Native_config
{
/**
* Thread-context area configuration.
*/
static addr_t context_area_virtual_base() { return 0x40000000UL; }
static addr_t context_area_virtual_size() { return 0x10000000UL; }
/**
* Size of virtual address region holding the context of one thread
*/
static addr_t context_virtual_size() { return 0x00100000UL; }
};
} }
#endif /* _INCLUDE__BASE__NATIVE_TYPES_H_ */ #endif /* _INCLUDE__BASE__NATIVE_TYPES_H_ */

3
base-hw/src/base/thread_support.cc
View File

@ -73,7 +73,8 @@ void Thread_base::start()
Ram_dataspace_capability ds = env()->cpu_session()->utcb(_thread_cap); Ram_dataspace_capability ds = env()->cpu_session()->utcb(_thread_cap);
size_t const size = sizeof(_context->utcb); size_t const size = sizeof(_context->utcb);
addr_t dst = Context_allocator::addr_to_base(_context) + addr_t dst = Context_allocator::addr_to_base(_context) +
CONTEXT_VIRTUAL_SIZE - size - CONTEXT_AREA_VIRTUAL_BASE; Native_config::context_virtual_size() - size -
Native_config::context_area_virtual_base();
env_context_area_rm_session()->attach_at(ds, dst, size); env_context_area_rm_session()->attach_at(ds, dst, size);
} catch (...) { } catch (...) {
PERR("%s: Failed to attach UTCB", __PRETTY_FUNCTION__); PERR("%s: Failed to attach UTCB", __PRETTY_FUNCTION__);

19
base-linux/include/base/native_types.h
View File

@ -15,6 +15,7 @@
#define _INCLUDE__BASE__NATIVE_TYPES_H_ #define _INCLUDE__BASE__NATIVE_TYPES_H_
#include <base/native_capability.h> #include <base/native_capability.h>
#include <base/stdint.h>
/* /*
* We cannot just include <semaphore.h> and <pthread.h> here * We cannot just include <semaphore.h> and <pthread.h> here
@ -107,6 +108,24 @@ namespace Genode {
typedef Native_capability_tpl<Cap_dst_policy> Native_capability; typedef Native_capability_tpl<Cap_dst_policy> Native_capability;
typedef int Native_connection_state; /* socket descriptor */ typedef int Native_connection_state; /* socket descriptor */
struct Native_config
{
/**
* Thread-context area configuration.
*
* Please update platform-specific files after changing these
* values, e.g., 'base-linux/src/platform/context_area.*.ld'.
*/
static addr_t context_area_virtual_base() { return 0x40000000UL; }
static addr_t context_area_virtual_size() { return 0x10000000UL; }
/**
* Size of virtual address region holding the context of one thread
*/
static addr_t context_virtual_size() { return 0x00100000UL; }
};
} }
#endif /* _INCLUDE__BASE__NATIVE_TYPES_H_ */ #endif /* _INCLUDE__BASE__NATIVE_TYPES_H_ */

2
base-linux/src/core/context_area.cc
View File

@ -46,7 +46,7 @@ class Context_area_rm_session : public Genode::Rm_session
/* convert context-area-relative to absolute virtual address */ /* convert context-area-relative to absolute virtual address */
addr_t addr = local_addr; addr_t addr = local_addr;
addr += Thread_base::CONTEXT_AREA_VIRTUAL_BASE; addr += Native_config::context_area_virtual_base();
/* use anonymous mmap for allocating stack backing store */ /* use anonymous mmap for allocating stack backing store */
int flags = MAP_FIXED | MAP_ANONYMOUS | MAP_PRIVATE; int flags = MAP_FIXED | MAP_ANONYMOUS | MAP_PRIVATE;

4
base-linux/src/platform/_main_helper.h
View File

@ -30,8 +30,8 @@ static inline void main_thread_bootstrap()
using namespace Genode; using namespace Genode;
/* reserve context area */ /* reserve context area */
Genode::addr_t base = Thread_base::CONTEXT_AREA_VIRTUAL_BASE; Genode::addr_t base = Native_config::context_area_virtual_base();
Genode::size_t size = Thread_base::CONTEXT_AREA_VIRTUAL_SIZE; Genode::size_t size = Native_config::context_area_virtual_size();
if (lx_vm_reserve(base, size) != base) if (lx_vm_reserve(base, size) != base)
PERR("reservation of context area [%lx,%lx) failed", PERR("reservation of context area [%lx,%lx) failed",
(unsigned long) base, (unsigned long) base + size); (unsigned long) base, (unsigned long) base + size);

15
base-mb/include/base/native_types.h
View File

@ -16,6 +16,7 @@
#include <kernel/types.h> #include <kernel/types.h>
#include <base/native_capability.h> #include <base/native_capability.h>
#include <base/stdint.h>
namespace Genode { namespace Genode {
@ -42,6 +43,20 @@ namespace Genode {
typedef Native_capability_tpl<Cap_dst_policy> Native_capability; typedef Native_capability_tpl<Cap_dst_policy> Native_capability;
typedef int Native_connection_state; typedef int Native_connection_state;
struct Native_config
{
/**
* Thread-context area configuration.
*/
static addr_t context_area_virtual_base() { return 0x40000000UL; }
static addr_t context_area_virtual_size() { return 0x10000000UL; }
/**
* Size of virtual address region holding the context of one thread
*/
static addr_t context_virtual_size() { return 0x00100000UL; }
};
} }
#endif /* _INCLUDE__BASE__NATIVE_TYPES_H_ */ #endif /* _INCLUDE__BASE__NATIVE_TYPES_H_ */

20
base-mb/src/base/thread/thread.cc
View File

@ -38,7 +38,7 @@ namespace Genode {
Thread_base::Context *Thread_base::Context_allocator::base_to_context(addr_t base) Thread_base::Context *Thread_base::Context_allocator::base_to_context(addr_t base)
{ {
addr_t result = base + CONTEXT_VIRTUAL_SIZE - sizeof(Context); addr_t result = base + Native_config::context_virtual_size() - sizeof(Context);
return reinterpret_cast<Context *>(result); return reinterpret_cast<Context *>(result);
} }
@ -67,11 +67,11 @@ Thread_base::Context *Thread_base::Context_allocator::alloc(Thread_base *thread_
/* /*
* Find slot in context area for the new context * Find slot in context area for the new context
*/ */
addr_t base = CONTEXT_AREA_VIRTUAL_BASE; addr_t base = Native_config::context_area_virtual_base();
for (; _is_in_use(base); base += CONTEXT_VIRTUAL_SIZE) { for (; _is_in_use(base); base += Native_config::context_virtual_size()) {
/* check upper bound of context area */ /* check upper bound of context area */
if (base >= CONTEXT_AREA_VIRTUAL_BASE + CONTEXT_AREA_VIRTUAL_SIZE) if (base >= Native_config::context_area_virtual_base() + Native_config::context_area_virtual_size())
return 0; return 0;
} }
@ -118,7 +118,7 @@ Thread_base::Context *Thread_base::_alloc_context(size_t stack_size)
enum { PAGE_SIZE_LOG2 = 12 }; enum { PAGE_SIZE_LOG2 = 12 };
size_t ds_size = align_addr(stack_size, PAGE_SIZE_LOG2); size_t ds_size = align_addr(stack_size, PAGE_SIZE_LOG2);
if (stack_size >= CONTEXT_VIRTUAL_SIZE - sizeof(Native_utcb) - (1 << PAGE_SIZE_LOG2)) if (stack_size >= Native_config::context_virtual_size() - sizeof(Native_utcb) - (1 << PAGE_SIZE_LOG2))
throw Stack_too_large(); throw Stack_too_large();
/* /*
@ -126,7 +126,7 @@ Thread_base::Context *Thread_base::_alloc_context(size_t stack_size)
* *
* The stack is always located at the top of the context. * The stack is always located at the top of the context.
*/ */
addr_t ds_addr = Context_allocator::addr_to_base(context) + CONTEXT_VIRTUAL_SIZE addr_t ds_addr = Context_allocator::addr_to_base(context) + Native_config::context_virtual_size()
- ds_size; - ds_size;
/* add padding for UTCB if defined for the platform */ /* add padding for UTCB if defined for the platform */
@ -137,7 +137,7 @@ Thread_base::Context *Thread_base::_alloc_context(size_t stack_size)
Ram_dataspace_capability ds_cap; Ram_dataspace_capability ds_cap;
try { try {
ds_cap = env_context_area_ram_session()->alloc(ds_size); ds_cap = env_context_area_ram_session()->alloc(ds_size);
addr_t attach_addr = ds_addr - CONTEXT_AREA_VIRTUAL_BASE; addr_t attach_addr = ds_addr - Native_config::context_area_virtual_base();
env_context_area_rm_session()->attach_at(ds_cap, attach_addr, ds_size); env_context_area_rm_session()->attach_at(ds_cap, attach_addr, ds_size);
} catch (Ram_session::Alloc_failed) { } catch (Ram_session::Alloc_failed) {
@ -160,7 +160,7 @@ Thread_base::Context *Thread_base::_alloc_context(size_t stack_size)
void Thread_base::_free_context() void Thread_base::_free_context()
{ {
addr_t ds_addr = _context->stack_base - CONTEXT_AREA_VIRTUAL_BASE; addr_t ds_addr = _context->stack_base - Native_config::context_area_virtual_base();
Ram_dataspace_capability ds_cap = _context->ds_cap; Ram_dataspace_capability ds_cap = _context->ds_cap;
Genode::env_context_area_rm_session()->detach((void *)ds_addr); Genode::env_context_area_rm_session()->detach((void *)ds_addr);
Genode::env_context_area_ram_session()->free(ds_cap); Genode::env_context_area_ram_session()->free(ds_cap);
@ -183,8 +183,8 @@ Thread_base *Thread_base::myself()
* we are the main thread because this condition can never met by any other * we are the main thread because this condition can never met by any other
* thread. * thread.
*/ */
if (sp < CONTEXT_AREA_VIRTUAL_BASE if (sp < Native_config::context_area_virtual_base()
|| sp >= CONTEXT_AREA_VIRTUAL_BASE + CONTEXT_AREA_VIRTUAL_SIZE) || sp >= Native_config::context_area_virtual_base() + Native_config::context_area_virtual_size())
return 0; return 0;
addr_t base = Context_allocator::addr_to_base((void*)sp); addr_t base = Context_allocator::addr_to_base((void*)sp);

2
base-mb/src/core/context_area.cc
View File

@ -58,7 +58,7 @@ class Context_area_rm_session : public Rm_session
} }
if (!map_local(ds->phys_addr(), if (!map_local(ds->phys_addr(),
(addr_t)local_addr + Thread_base::CONTEXT_AREA_VIRTUAL_BASE, (addr_t)local_addr + Native_config::context_area_virtual_base(),
ds->size() >> get_page_size_log2())) ds->size() >> get_page_size_log2()))
return 0; return 0;

67
base-mb/src/core/include/platform_pd.h
View File

@ -38,24 +38,35 @@ namespace Genode {
private: private:
enum{ addr_t context_area_base() {
CONTEXT_AREA_BASE = Thread_base::CONTEXT_AREA_VIRTUAL_BASE, return Native_config::context_area_virtual_base();
CONTEXT_AREA_SIZE = Thread_base::CONTEXT_AREA_VIRTUAL_SIZE, }
CONTEXT_AREA_TOP = CONTEXT_AREA_BASE + CONTEXT_AREA_SIZE, addr_t context_area_size() {
CONTEXT_SIZE = Thread_base::CONTEXT_VIRTUAL_SIZE, return Native_config::context_area_virtual_size();
CONTEXT_BASE_MASK = Thread_base::CONTEXT_VIRTUAL_BASE_MASK, }
CONTEXT_OFFSET_MASK = ~CONTEXT_BASE_MASK, addr_t context_area_top() {
return context_area_base() + context_area_size();
MAX_CONTEXT_ID = CONTEXT_AREA_SIZE/CONTEXT_SIZE-1 }
}; 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();
}
addr_t max_context_id {
return context_area_size()/context_size()-1;
}
Native_process_id _pid; Native_process_id _pid;
Native_thread_id owner_tid_by_context_id[MAX_CONTEXT_ID+1]; Native_thread_id owner_tid_by_context_id[max_context_id()+1];
void _free_context(Native_thread_id const & t) void _free_context(Native_thread_id const & t)
{ {
for (Context_id cid = 0; cid <= MAX_CONTEXT_ID; cid++) { for (Context_id cid = 0; cid <= max_context_id(); cid++) {
if (owner_tid_by_context_id[cid] == t) { if (owner_tid_by_context_id[cid] == t) {
owner_tid_by_context_id[cid] = 0; owner_tid_by_context_id[cid] = 0;
} }
@ -72,7 +83,7 @@ namespace Genode {
{ {
static bool const verbose = false; static bool const verbose = false;
if ((unsigned)User::MAX_THREAD_ID>(unsigned)MAX_CONTEXT_ID) { if ((unsigned)User::MAX_THREAD_ID>(unsigned)max_context_id()) {
PERR("More threads allowed than context areas available"); PERR("More threads allowed than context areas available");
return; return;
} }
@ -99,22 +110,22 @@ namespace Genode {
bool cid_if_context_address(addr_t a, Context_id* cid) bool cid_if_context_address(addr_t a, Context_id* cid)
{ {
if (a < CONTEXT_AREA_BASE || a >= CONTEXT_AREA_TOP) if (a < context_area_base() || a >= context_area_top())
return false; return false;
addr_t context_base = a & CONTEXT_BASE_MASK; addr_t context_base = a & context_base_mask();
*cid = (Context_id)((context_base-CONTEXT_AREA_BASE) / CONTEXT_SIZE); *cid = (Context_id)((context_base-context_area_base()) / context_size());
return true; return true;
} }
Context *context(Context_id i) Context *context(Context_id i)
{ {
return (Context*)(CONTEXT_AREA_BASE+(i+1)*CONTEXT_SIZE-sizeof(Context)); return (Context*)(context_area_base()+(i+1)*context_size()-sizeof(Context));
} }
Context *context_by_tid(Native_thread_id tid) Context *context_by_tid(Native_thread_id tid)
{ {
for (unsigned cid = 0; cid <= MAX_CONTEXT_ID; cid++) for (unsigned cid = 0; cid <= max_context_id(); cid++)
if (owner_tid_by_context_id[cid] == tid) if (owner_tid_by_context_id[cid] == tid)
return context(cid); return context(cid);
@ -128,7 +139,7 @@ namespace Genode {
if (!cid_if_context_address(a, &cid)) if (!cid_if_context_address(a, &cid))
return false; return false;
if (cid > MAX_CONTEXT_ID) { if (cid > max_context_id()) {
PERR("Context ID %i out of range", (unsigned int)cid); PERR("Context ID %i out of range", (unsigned int)cid);
return false; return false;
} }
@ -142,7 +153,7 @@ namespace Genode {
} }
addr_t offset = a & CONTEXT_OFFSET_MASK; addr_t offset = a & CONTEXT_OFFSET_MASK;
Context *context = (Context *)(CONTEXT_SIZE - sizeof(Context)); Context *context = (Context *)(context_size() - sizeof(Context));
if ((void*)offset >= &context->utcb) { if ((void*)offset >= &context->utcb) {
*cp = UTCB_AREA; *cp = UTCB_AREA;
@ -160,7 +171,7 @@ namespace Genode {
{ {
static bool const verbose = false; static bool const verbose = false;
if (cid > MAX_CONTEXT_ID) if (cid > max_context_id())
return 0; return 0;
if (owner_tid_by_context_id[cid]){ if (owner_tid_by_context_id[cid]){
@ -182,21 +193,21 @@ namespace Genode {
* First thread is assumed to be the main thread and gets last * First thread is assumed to be the main thread and gets last
* context-area by convention * context-area by convention
*/ */
if (!owner_tid_by_context_id[MAX_CONTEXT_ID]){ if (!owner_tid_by_context_id[max_context_id()]){
owner_tid_by_context_id[MAX_CONTEXT_ID] = tid; owner_tid_by_context_id[max_context_id()] = tid;
if (verbose) if (verbose)
PDBG("Thread %i owns Context %i (0x%p) of Protection Domain %i", PDBG("Thread %i owns Context %i (0x%p) of Protection Domain %i",
tid, MAX_CONTEXT_ID, context(MAX_CONTEXT_ID), _pid); tid, max_context_id(), context(max_context_id()), _pid);
return context(MAX_CONTEXT_ID); return context(max_context_id());
} }
for (unsigned i = 0; i <= MAX_CONTEXT_ID - 1; i++) { for (unsigned i = 0; i <= max_context_id() - 1; i++) {
if (!owner_tid_by_context_id[i]) { if (!owner_tid_by_context_id[i]) {
owner_tid_by_context_id[i] = tid; owner_tid_by_context_id[i] = tid;
if (verbose) if (verbose)
PDBG("Thread %i owns Context %i (0x%p) of Protection Domain %i", PDBG("Thread %i owns Context %i (0x%p) of Protection Domain %i",
tid, MAX_CONTEXT_ID, context(MAX_CONTEXT_ID), _pid); tid, max_context_id(), context(max_context_id()), _pid);
return context(i); return context(i);
} }
} }
@ -236,7 +247,7 @@ namespace Genode {
*/ */
void free_context(Context_id const & c) void free_context(Context_id const & c)
{ {
if (c > MAX_CONTEXT_ID) { return; } if (c > max_context_id()) { return; }
owner_tid_by_context_id[c] = Kernel::INVALID_THREAD_ID; owner_tid_by_context_id[c] = Kernel::INVALID_THREAD_ID;
} }

4
base-mb/src/core/platform.cc
View File

@ -220,8 +220,8 @@ Genode::Platform::Platform() :
_core_mem_alloc.remove_range(img_base, img_size); _core_mem_alloc.remove_range(img_base, img_size);
/* Preserve core's context area with page-granularity from allocation */ /* Preserve core's context area with page-granularity from allocation */
addr_t const ctxt_area_base = trunc_page((addr_t)Thread_base::CONTEXT_AREA_VIRTUAL_BASE); addr_t const ctxt_area_base = trunc_page((addr_t)Native_config::context_area_virtual_base());
size_t const ctxt_area_size = round_page((addr_t)Thread_base::CONTEXT_AREA_VIRTUAL_BASE); size_t const ctxt_area_size = round_page((addr_t)Native_config::context_area_virtual_base());
_core_mem_alloc.remove_range(ctxt_area_base, ctxt_area_size); _core_mem_alloc.remove_range(ctxt_area_base, ctxt_area_size);
/* Preserve UART MMIO with page-granularity from allocation */ /* Preserve UART MMIO with page-granularity from allocation */

4
base-mb/src/platform/_main_helper.h
View File

@ -43,8 +43,8 @@ static void main_thread_bootstrap()
int volatile pid; int volatile pid;
asm volatile ("mfs %0, rpid" : "=r"(pid) : :); asm volatile ("mfs %0, rpid" : "=r"(pid) : :);
if (pid!=Roottask::PROTECTION_ID) { if (pid!=Roottask::PROTECTION_ID) {
_main_utcb_addr = (Native_utcb*)((Thread_base::CONTEXT_AREA_VIRTUAL_BASE _main_utcb_addr = (Native_utcb*)((Native_config::context_area_virtual_base()
+ Thread_base::CONTEXT_AREA_VIRTUAL_SIZE) + Native_config::context_area_virtual_size())
- sizeof(Native_utcb)); - sizeof(Native_utcb));
} }

15
base-nova/include/base/native_types.h
View File

@ -215,6 +215,21 @@ namespace Genode {
}; };
typedef int Native_connection_state; typedef int Native_connection_state;
struct Native_config
{
/**
* Thread-context area configuration.
*/
static addr_t context_area_virtual_base() { return 0x40000000UL; }
static addr_t context_area_virtual_size() { return 0x10000000UL; }
/**
* Size of virtual address region holding the context of one thread
*/
static addr_t context_virtual_size() { return 0x00100000UL; }
};
} }
#endif /* _INCLUDE__BASE__NATIVE_TYPES_H_ */ #endif /* _INCLUDE__BASE__NATIVE_TYPES_H_ */

6
base-nova/src/core/platform.cc
View File

@ -218,7 +218,7 @@ Platform::Platform() :
/* define core's virtual address space */ /* define core's virtual address space */
addr_t virt_beg = get_page_size(); addr_t virt_beg = get_page_size();
addr_t virt_end = Thread_base::CONTEXT_AREA_VIRTUAL_BASE; addr_t virt_end = Native_config::context_area_virtual_base();
_core_mem_alloc.virt_alloc()->add_range(virt_beg, _core_mem_alloc.virt_alloc()->add_range(virt_beg,
virt_end - virt_beg); virt_end - virt_beg);
@ -229,8 +229,8 @@ Platform::Platform() :
_core_mem_alloc.virt_alloc()->remove_range(core_virt_beg, core_size); _core_mem_alloc.virt_alloc()->remove_range(core_virt_beg, core_size);
/* preserve context area in core's virtual address space */ /* preserve context area in core's virtual address space */
_core_mem_alloc.virt_alloc()->remove_range(Thread_base::CONTEXT_AREA_VIRTUAL_BASE, _core_mem_alloc.virt_alloc()->remove_range(Native_config::context_area_virtual_base(),
Thread_base::CONTEXT_AREA_VIRTUAL_SIZE); Native_config::context_area_virtual_size());
/* initialize core's physical-memory and I/O memory allocator */ /* initialize core's physical-memory and I/O memory allocator */
_io_mem_alloc.add_range(0, ~0xfff); _io_mem_alloc.add_range(0, ~0xfff);

9
base-nova/src/core/platform_thread.cc
View File

@ -55,7 +55,6 @@ int Platform_thread::start(void *ip, void *sp)
return -2; return -2;
} }
enum { PD_UTCB = 0x6000000 };
_pager->initial_eip((addr_t)ip); _pager->initial_eip((addr_t)ip);
if (!_is_main_thread) { if (!_is_main_thread) {
addr_t initial_sp = reinterpret_cast<addr_t>(sp); addr_t initial_sp = reinterpret_cast<addr_t>(sp);
@ -104,7 +103,11 @@ int Platform_thread::start(void *ip, void *sp)
* For the first thread of a new PD, use the initial stack pointer for * For the first thread of a new PD, use the initial stack pointer for
* reporting the thread's UTCB address. * reporting the thread's UTCB address.
*/ */
_pager->initial_esp(PD_UTCB + get_page_size()); addr_t pd_utcb = Native_config::context_area_virtual_base() +
Native_config::context_area_virtual_size() -
get_page_size();
_pager->initial_esp(pd_utcb + get_page_size());
_sel_exc_base = cap_selector_allocator()->alloc(NUM_INITIAL_PT_LOG2); _sel_exc_base = cap_selector_allocator()->alloc(NUM_INITIAL_PT_LOG2);
@ -180,7 +183,7 @@ int Platform_thread::start(void *ip, void *sp)
/* Create first thread in task */ /* Create first thread in task */
enum { THREAD_GLOBAL = true }; enum { THREAD_GLOBAL = true };
res = create_ec(_sel_ec(), pd_sel, _cpu_no, PD_UTCB, 0, 0, res = create_ec(_sel_ec(), pd_sel, _cpu_no, pd_utcb, 0, 0,
THREAD_GLOBAL); THREAD_GLOBAL);
if (res) { if (res) {
PERR("create_ec returned %d", res); PERR("create_ec returned %d", res);

15
base-okl4/include/base/native_types.h
View File

@ -15,6 +15,7 @@
#define _INCLUDE__BASE__NATIVE_TYPES_H_ #define _INCLUDE__BASE__NATIVE_TYPES_H_
#include <base/native_capability.h> #include <base/native_capability.h>
#include <base/stdint.h>
namespace Okl4 { extern "C" { namespace Okl4 { extern "C" {
#include <l4/types.h> #include <l4/types.h>
@ -88,6 +89,20 @@ namespace Genode {
typedef Native_capability_tpl<Cap_dst_policy> Native_capability; typedef Native_capability_tpl<Cap_dst_policy> Native_capability;
typedef Okl4::L4_ThreadId_t Native_connection_state; typedef Okl4::L4_ThreadId_t Native_connection_state;
struct Native_config
{
/**
* Thread-context area configuration.
*/
static addr_t context_area_virtual_base() { return 0x40000000UL; }
static addr_t context_area_virtual_size() { return 0x10000000UL; }
/**
* Size of virtual address region holding the context of one thread
*/
static addr_t context_virtual_size() { return 0x00100000UL; }
};
} }
#endif /* _INCLUDE__BASE__NATIVE_TYPES_H_ */ #endif /* _INCLUDE__BASE__NATIVE_TYPES_H_ */

4
base-okl4/src/core/platform.cc
View File

@ -264,8 +264,8 @@ Platform::Platform() :
_io_port_alloc.add_range(0, 0x10000); _io_port_alloc.add_range(0, 0x10000);
/* preserve context area in core's virtual address space */ /* preserve context area in core's virtual address space */
_core_mem_alloc.virt_alloc()->remove_range(Thread_base::CONTEXT_AREA_VIRTUAL_BASE, _core_mem_alloc.virt_alloc()->remove_range(Native_config::context_area_virtual_base(),
Thread_base::CONTEXT_AREA_VIRTUAL_SIZE); Native_config::context_area_virtual_size());
_vm_start = 0x1000; _vm_start = 0x1000;
_vm_size = 0xb0000000 - 0x1000; _vm_size = 0xb0000000 - 0x1000;

15
base-pistachio/include/base/native_types.h
View File

@ -15,6 +15,7 @@
#define _INCLUDE__BASE__NATIVE_TYPES_H_ #define _INCLUDE__BASE__NATIVE_TYPES_H_
#include <base/native_capability.h> #include <base/native_capability.h>
#include <base/stdint.h>
namespace Pistachio { namespace Pistachio {
#include <l4/types.h> #include <l4/types.h>
@ -74,6 +75,20 @@ namespace Genode {
typedef Native_capability_tpl<Cap_dst_policy> Native_capability; typedef Native_capability_tpl<Cap_dst_policy> Native_capability;
typedef Pistachio::L4_ThreadId_t Native_connection_state; typedef Pistachio::L4_ThreadId_t Native_connection_state;
struct Native_config
{
/**
* Thread-context area configuration.
*/
static addr_t context_area_virtual_base() { return 0x40000000UL; }
static addr_t context_area_virtual_size() { return 0x10000000UL; }
/**
* Size of virtual address region holding the context of one thread
*/
static addr_t context_virtual_size() { return 0x00100000UL; }
};
} }
#endif /* _INCLUDE__BASE__NATIVE_TYPES_H_ */ #endif /* _INCLUDE__BASE__NATIVE_TYPES_H_ */

4
base-pistachio/src/core/platform.cc
View File

@ -515,8 +515,8 @@ void Platform::_setup_basics()
/* configure core's virtual memory, exclude KIP, context area */ /* configure core's virtual memory, exclude KIP, context area */
_region_alloc.add_range(_vm_start, _vm_size); _region_alloc.add_range(_vm_start, _vm_size);
_region_alloc.remove_range((addr_t)kip, kip_size); _region_alloc.remove_range((addr_t)kip, kip_size);
_region_alloc.remove_range(Thread_base::CONTEXT_AREA_VIRTUAL_BASE, _region_alloc.remove_range(Native_config::context_area_virtual_base(),
Thread_base::CONTEXT_AREA_VIRTUAL_SIZE); Native_config::context_area_virtual_size());
/* remove KIP and MBI area from region and IO_MEM allocator */ /* remove KIP and MBI area from region and IO_MEM allocator */
remove_region(Region((addr_t)kip, (addr_t)kip + kip_size), _region_alloc); remove_region(Region((addr_t)kip, (addr_t)kip + kip_size), _region_alloc);

15
base/include/base/thread.h
View File

@ -78,21 +78,6 @@ namespace Genode {
class Stack_too_large : public Exception { }; class Stack_too_large : public Exception { };
class Stack_alloc_failed : public Exception { }; class Stack_alloc_failed : public Exception { };
/*
* Thread-context area configuration.
*
* Please update platform-specific files after changing these
* values, e.g., 'base-linux/src/platform/context_area.*.ld'.
*/
enum { CONTEXT_AREA_VIRTUAL_BASE = 0x40000000 };
enum { CONTEXT_AREA_VIRTUAL_SIZE = 0x10000000 };
/**
* Size of virtual address region holding the context of one thread
*/
enum { CONTEXT_VIRTUAL_SIZE = 0x00100000 };
enum { CONTEXT_VIRTUAL_BASE_MASK = ~(CONTEXT_VIRTUAL_SIZE - 1) };
private: private:
/** /**

6
base/src/base/env/context_area.cc vendored
View File

@ -19,12 +19,12 @@
struct Context_area_rm_session : Genode::Rm_connection struct Context_area_rm_session : Genode::Rm_connection
{ {
Context_area_rm_session() Context_area_rm_session()
: Genode::Rm_connection(0, Genode::Thread_base::CONTEXT_AREA_VIRTUAL_SIZE) : Genode::Rm_connection(0, Genode::Native_config::context_area_virtual_size())
{ {
using namespace Genode; using namespace Genode;
addr_t local_base = Thread_base::CONTEXT_AREA_VIRTUAL_BASE; addr_t local_base = Native_config::context_area_virtual_base();
size_t size = Thread_base::CONTEXT_AREA_VIRTUAL_SIZE; size_t size = Native_config::context_area_virtual_size();
env()->rm_session()->attach_at(dataspace(), local_base, size); env()->rm_session()->attach_at(dataspace(), local_base, size);
} }

30
base/src/base/thread/thread.cc
View File

@ -37,14 +37,15 @@ namespace Genode {
Thread_base::Context *Thread_base::Context_allocator::base_to_context(addr_t base) Thread_base::Context *Thread_base::Context_allocator::base_to_context(addr_t base)
{ {
addr_t result = base + CONTEXT_VIRTUAL_SIZE - sizeof(Context); addr_t result = base + Native_config::context_virtual_size()
- sizeof(Context);
return reinterpret_cast<Context *>(result); return reinterpret_cast<Context *>(result);
} }
addr_t Thread_base::Context_allocator::addr_to_base(void *addr) addr_t Thread_base::Context_allocator::addr_to_base(void *addr)
{ {
return ((addr_t)addr) & CONTEXT_VIRTUAL_BASE_MASK; return ((addr_t)addr) & ~(Native_config::context_virtual_size() - 1);
} }
@ -66,11 +67,12 @@ Thread_base::Context *Thread_base::Context_allocator::alloc(Thread_base *thread_
/* /*
* Find slot in context area for the new context * Find slot in context area for the new context
*/ */
addr_t base = CONTEXT_AREA_VIRTUAL_BASE; addr_t base = Native_config::context_area_virtual_base();
for (; _is_in_use(base); base += CONTEXT_VIRTUAL_SIZE) { for (; _is_in_use(base); base += Native_config::context_virtual_size()) {
/* check upper bound of context area */ /* check upper bound of context area */
if (base >= CONTEXT_AREA_VIRTUAL_BASE + CONTEXT_AREA_VIRTUAL_SIZE) if (base >= Native_config::context_area_virtual_base() +
Native_config::context_area_virtual_size())
return 0; return 0;
} }
@ -118,7 +120,8 @@ Thread_base::Context *Thread_base::_alloc_context(size_t stack_size)
enum { PAGE_SIZE_LOG2 = 12 }; enum { PAGE_SIZE_LOG2 = 12 };
size_t ds_size = align_addr(stack_size, PAGE_SIZE_LOG2); size_t ds_size = align_addr(stack_size, PAGE_SIZE_LOG2);
if (stack_size >= CONTEXT_VIRTUAL_SIZE - sizeof(Native_utcb) - (1 << PAGE_SIZE_LOG2)) if (stack_size >= Native_config::context_virtual_size() -
sizeof(Native_utcb) - (1UL << PAGE_SIZE_LOG2))
throw Stack_too_large(); throw Stack_too_large();
/* /*
@ -126,8 +129,9 @@ Thread_base::Context *Thread_base::_alloc_context(size_t stack_size)
* *
* The stack is always located at the top of the context. * The stack is always located at the top of the context.
*/ */
addr_t ds_addr = Context_allocator::addr_to_base(context) + CONTEXT_VIRTUAL_SIZE addr_t ds_addr = Context_allocator::addr_to_base(context) +
- ds_size; Native_config::context_virtual_size() -
ds_size;
/* add padding for UTCB if defined for the platform */ /* add padding for UTCB if defined for the platform */
if (sizeof(Native_utcb) >= (1 << PAGE_SIZE_LOG2)) if (sizeof(Native_utcb) >= (1 << PAGE_SIZE_LOG2))
@ -137,7 +141,7 @@ Thread_base::Context *Thread_base::_alloc_context(size_t stack_size)
Ram_dataspace_capability ds_cap; Ram_dataspace_capability ds_cap;
try { try {
ds_cap = env_context_area_ram_session()->alloc(ds_size); ds_cap = env_context_area_ram_session()->alloc(ds_size);
addr_t attach_addr = ds_addr - CONTEXT_AREA_VIRTUAL_BASE; addr_t attach_addr = ds_addr - Native_config::context_area_virtual_base();
env_context_area_rm_session()->attach_at(ds_cap, attach_addr, ds_size); env_context_area_rm_session()->attach_at(ds_cap, attach_addr, ds_size);
} catch (Ram_session::Alloc_failed) { } catch (Ram_session::Alloc_failed) {
@ -158,7 +162,8 @@ Thread_base::Context *Thread_base::_alloc_context(size_t stack_size)
void Thread_base::_free_context() void Thread_base::_free_context()
{ {
addr_t ds_addr = _context->stack_base - CONTEXT_AREA_VIRTUAL_BASE; addr_t ds_addr = _context->stack_base -
Native_config::context_area_virtual_base();
Ram_dataspace_capability ds_cap = _context->ds_cap; Ram_dataspace_capability ds_cap = _context->ds_cap;
Genode::env_context_area_rm_session()->detach((void *)ds_addr); Genode::env_context_area_rm_session()->detach((void *)ds_addr);
Genode::env_context_area_ram_session()->free(ds_cap); Genode::env_context_area_ram_session()->free(ds_cap);
@ -182,8 +187,9 @@ Thread_base *Thread_base::myself()
* thread. * thread.
*/ */
addr_t sp = (addr_t)(&dummy); addr_t sp = (addr_t)(&dummy);
if (sp < CONTEXT_AREA_VIRTUAL_BASE if (sp < Native_config::context_area_virtual_base() ||
|| sp >= CONTEXT_AREA_VIRTUAL_BASE + CONTEXT_AREA_VIRTUAL_SIZE) sp >= Native_config::context_area_virtual_base() +
Native_config::context_area_virtual_size())
return 0; return 0;
addr_t base = Context_allocator::addr_to_base(&dummy); addr_t base = Context_allocator::addr_to_base(&dummy);

4
base/src/core/context_area.cc
View File

@ -59,8 +59,8 @@ class Context_area_rm_session : public Rm_session
return (addr_t)0; return (addr_t)0;
} }
if (!map_local(ds->phys_addr(), if (!map_local(ds->phys_addr(), (addr_t)local_addr +
(addr_t)local_addr + Thread_base::CONTEXT_AREA_VIRTUAL_BASE, Native_config::context_area_virtual_base(),
ds->size() >> get_page_size_log2())) ds->size() >> get_page_size_log2()))
return (addr_t)0; return (addr_t)0;

5
ports-foc/src/lib/l4lx/startup.cc
View File

@ -15,6 +15,7 @@
#include <base/elf.h> #include <base/elf.h>
#include <base/env.h> #include <base/env.h>
#include <base/thread.h> #include <base/thread.h>
#include <base/native_types.h>
#include <dataspace/client.h> #include <dataspace/client.h>
#include <rom_session/connection.h> #include <rom_session/connection.h>
#include <foc_cpu_session/connection.h> #include <foc_cpu_session/connection.h>
@ -125,8 +126,8 @@ static void register_reserved_areas()
size_t bin_sz = (addr_t)&_prog_img_end - (addr_t)&_prog_img_beg; size_t bin_sz = (addr_t)&_prog_img_end - (addr_t)&_prog_img_beg;
L4lx::Env::env()->rm()->reserve_range((addr_t)&_prog_img_beg, bin_sz, "Binary"); L4lx::Env::env()->rm()->reserve_range((addr_t)&_prog_img_beg, bin_sz, "Binary");
L4lx::Env::env()->rm()->reserve_range(Thread_base::CONTEXT_AREA_VIRTUAL_BASE, L4lx::Env::env()->rm()->reserve_range(Native_config::context_area_virtual_base(),
Thread_base::CONTEXT_AREA_VIRTUAL_SIZE, Native_config::context_area_virtual_size(),
"Thread Context Area"); "Thread Context Area");
} }