int
main(int argc, char **argv)
{
struct driver_ops *ops;
objref_t obj;
/*
* XXX: Should we be inserting the timer device into naming here?
*/
main_tid = thread_l4tid(env_thread(iguana_getenv("MAIN")));
obj = device_create_impl(main_tid, 0UL, NULL);
naming_insert("timer", obj);
ops = TIMER_DRIVER.ops.d_ops;
iguana_cb_handle = cb_attach(__callback_buffer);
#ifdef ENABLE_PM_THREAD
{
L4_ThreadId_t unused;
pm_thread = thread_create_priority(1, &unused);
L4_KDB_SetThreadName(unused, "PwrMgmt");
}
#endif
L4_Accept(L4_AsynchItemsAcceptor);
L4_Set_NotifyMask(1UL << 31);
timer_server_loop();
assert(!"Should reach here\n");
return 0;
}
/*
* Simple spinning thread.
*/
static void spinner(void)
{
ARCH_THREAD_INIT
L4_KDB_SetThreadName(L4_myselfconst, "Spinner");
for (;;) {}
}
static void
setup_extended_graph(void)
{
setup_graph();
prio8_thread = createThread(other_sending_thread);
L4_KDB_SetThreadName(prio8_thread, "prio8_thread");
L4_Set_Priority(prio8_thread, 201);
L4_Set_Priority(prio8_thread, 8);
prio6bis_thread = createThread(other_sending_thread);
L4_KDB_SetThreadName(prio6bis_thread, "prio6bis_thread");
L4_Set_Priority(prio6bis_thread, 201);
L4_Set_Priority(prio6bis_thread, 6);
L4_Receive(main_thread);
L4_LoadMR(0, 0);
L4_Send(main_thread);
}
/*
* Simple thread increasing a counter.
*/
static void counted_spinner(void)
{
ARCH_THREAD_INIT
L4_KDB_SetThreadName(L4_myselfconst, "Count Spin");
for (;;) {
spinner_count++;
}
}
static void
setup_graph(void)
{
main_thread = createThread(runnable_main_thread);
L4_KDB_SetThreadName(main_thread, "main_thread");
L4_Set_Priority(main_thread, 3);
L4_Receive(main_thread);
prio6_thread = createThread(sending_thread);
L4_KDB_SetThreadName(prio6_thread, "prio6_thread");
L4_Set_UserDefinedHandleOf(prio6_thread, 0);
L4_Set_Priority(prio6_thread, 201);
L4_Set_Priority(prio6_thread, 6);
prio1_thread = createThread(sending_thread);
L4_KDB_SetThreadName(prio1_thread, "prio1_thread");
L4_Set_UserDefinedHandleOf(prio1_thread, 1);
L4_Set_Priority(prio1_thread, 201);
L4_Set_Priority(prio1_thread, 1);
prio2_thread = createThread(locking_m1_thread);
L4_KDB_SetThreadName(prio2_thread, "prio2_thread");
L4_Set_Priority(prio2_thread, 201);
L4_Set_Priority(prio2_thread, 2);
prio5_thread = createThread(locking_m1_thread);
L4_KDB_SetThreadName(prio5_thread, "prio5_thread");
L4_Set_Priority(prio5_thread, 201);
L4_Set_Priority(prio5_thread, 5);
prio4_thread = createThread(locking_m2_thread);
L4_KDB_SetThreadName(prio4_thread, "prio4_thread");
L4_Set_Priority(prio4_thread, 201);
L4_Set_Priority(prio4_thread, 4);
prio7_thread = createThread(locking_m2_thread);
L4_KDB_SetThreadName(prio7_thread, "prio7_thread");
L4_Set_Priority(prio7_thread, 201);
L4_Set_Priority(prio7_thread, 7);
L4_LoadMR(0, 0);
L4_Send(main_thread);
measure_thread = createThread(measure_effective_prio_thread);
L4_KDB_SetThreadName(measure_thread, "measure_thread");
L4_Set_Priority(measure_thread, 9);
}
static void
worker_a(void *ignore)
{
ARCH_THREAD_INIT
memsection_ref_t m;
uintptr_t base;
int i;
L4_KDB_SetThreadName(thread_l4tid(thread_myself()), "worker_a");
L4_Yield();
for (i = 0; i < 10000; i++) {
m = pd_create_memsection(pd_myself(), 1UL << 31, &base);
assert(m == 0);
}
worker_a_done = 1;
L4_WaitForever();
}
static void
utimer(void)
{
L4_KDB_SetThreadName(sos_my_tid(), "utimer");
L4_Accept(L4_UntypedWordsAcceptor);
List *entryq;
entryq = list_empty();
for (;;) {
L4_Yield();
// Walk the timer list
L4_Word_t now = L4_KDB_GetTick();
list_delete(entryq, processExpired, &now);
// Wait for a new packet either blocking or non-blocking
L4_MsgTag_t tag = L4_Niltag;
if (list_null(entryq))
L4_Set_ReceiveBlock(&tag);
else
L4_Clear_ReceiveBlock(&tag);
L4_ThreadId_t wait_tid = L4_nilthread;
tag = L4_Ipc(L4_nilthread, L4_anythread, tag, &wait_tid);
if (!L4_IpcFailed(tag)) {
// Received a time out request queue it
L4_Msg_t msg; L4_MsgStore(tag, &msg); // Get the message
utimer_entry_t *entry = (utimer_entry_t *) L4_MsgWord(&msg, 0);
entry->fTid = wait_tid;
list_shift(entryq, entry);
}
else if (3 == L4_ErrorCode()) // Receive error # 1
continue; // no-partner - non-blocking
else
assert(!"Unhandled IPC error");
}
}
static void
worker_b(void *ignore)
{
ARCH_THREAD_INIT
memsection_ref_t m;
uintptr_t base;
int i;
char *p;
L4_KDB_SetThreadName(thread_l4tid(thread_myself()), "worker_b");
L4_Yield();
for (i = 0; i < 1000; i++) {
m = pd_create_memsection(pd_myself(), MEM_SIZE, &base);
assert(m != 0);
p = (char *)base;
memset(p, '%', 0x10);
memsection_delete(m);
}
worker_b_done = 1;
L4_WaitForever();
}
static void
ipc_setup(struct bench_test *test, int args[])
{
static bool setup = false;
int r;
L4_Word_t utcb;
fass = (test == &bench_ipc_fass);
pagertimer = (test == &bench_ipc_pagemap);
pagertimer_simulated = (test == &bench_ipc_pagemap_simulated);
inter = (test == &bench_ipc_inter);
fass_buffer = ((test == &bench_ipc_fass_buffer) || (test == &bench_ipc_fass_buffer_vspace));
fault_test = (test == &bench_ipc_page_faults);
intra_open = (test == &bench_ipc_intra_open);
intra_close = (test == &bench_ipc_intra_close);
intra_rpc = (test == &bench_ipc_intra_rpc);
intra_ovh = (test == &bench_ipc_intra_ovh);
intra_async = (test == &bench_ipc_intra_async);
intra_async_ovh = (test == &bench_ipc_intra_async_ovh);
num_iterations = args[0];
num_mrs = args[1];
ping_space = pong_space = L4_nilspace;
if (! setup) {
/* Find smallest supported page size. There's better at least one
* bit set. */
/* Size for one UTCB */
utcb_size = L4_GetUtcbSize();
/* We need a maximum of two threads per task */
#ifdef NO_UTCB_RELOCATE
no_utcb_alloc = 1;
utcb_area = L4_Nilpage;
if (fass) {
pong_utcb_area = L4_Nilpage;
}
#else
no_utcb_alloc = 0;
utcb_area = L4_Fpage((L4_Word_t) UTCB_ADDRESS,
L4_GetUtcbAreaSize() + 1);
if (fass) {
pong_utcb_area = L4_Fpage ((L4_Word_t) UTCB_ADDRESS,
L4_GetUtcbAreaSize() + 1);
}
#endif
/* Create pager */
master_tid.raw = KBENCH_SERVER.raw;
pager_tid.raw = KBENCH_SERVER.raw + 1;
ping_tid.raw = KBENCH_SERVER.raw + 2;
pong_tid.raw = KBENCH_SERVER.raw + 3;
/* VU: calculate UTCB address -- this has to be revised */
/** @todo FIXME: Should put into arch subdir - changhua. */
#if defined(ARCH_ARM)
L4_Word_t pager_utcb = (L4_Word_t) __L4_ARM_Utcb();
#elif defined(ARCH_IA32)
L4_Word_t pager_utcb = (L4_Word_t) __L4_X86_Utcb();
#elif defined(ARCH_SH)
L4_Word_t pager_utcb = (L4_Word_t) L4_GetUtcbBase();
#else
#error "Please define arch get_Utcb()"
#endif
pager_utcb = no_utcb_alloc ? ~0UL : (pager_utcb & ~(utcb_size - 1)) + utcb_size;
r = L4_ThreadControl (pager_tid, KBENCH_SPACE, master_tid, master_tid,
master_tid, 0, (void*)pager_utcb);
if (r == 0) printf("Thread create Error: %lx\n", L4_ErrorCode());
assert(r == 1);
L4_KDB_SetThreadName(pager_tid, "pager");
L4_Start_SpIp (pager_tid, (L4_Word_t) pager_stack + sizeof(pager_stack) - 32, START_ADDR (pager));
/* Find some area of memory to page to */
setup = true;
}
if (pagertimer) {
/* Only create ping space and ping thread. */
r = okl4_kspaceid_allocany(spaceid_pool, &ping_space);
assert(r == OKL4_OK);
r = L4_SpaceControl(ping_space, L4_SpaceCtrl_new, KBENCH_CLIST, utcb_area, 0, NULL);
assert(r == 1);
utcb = no_utcb_alloc ? ~0UL : UTCB(0);
r = L4_ThreadControl(ping_tid, ping_space, master_tid, pager_tid, pager_tid, 0, (void *) utcb);
L4_StoreMR(0, &ping_th.raw);
assert(r == 1);
} else if (fault_test) {
/* Only create pong space and pong thread. */
r = okl4_kspaceid_allocany(spaceid_pool, &pong_space);
assert(r == OKL4_OK);
r = L4_SpaceControl(pong_space, L4_SpaceCtrl_new, KBENCH_CLIST, utcb_area, 0, NULL);
assert(r == 1);
utcb = no_utcb_alloc ? ~0UL : UTCB(0);
r = L4_ThreadControl(pong_tid, pong_space, master_tid, pager_tid, pager_tid, 0, (void *) utcb);
L4_StoreMR(0, &pong_th.raw);
assert(r == 1);
} else if (pagertimer_simulated || inter || fass || fass_buffer) {
/* Create both ping, pong space, and create ping, pong thread in their own space */
L4_Word_t ctrl = 0;
if (test == &bench_ipc_fass_buffer_vspace) {
ctrl = (1 << 16);
}
r = okl4_kspaceid_allocany(spaceid_pool, &ping_space);
assert(r == OKL4_OK);
r = L4_SpaceControl(ping_space, L4_SpaceCtrl_new, KBENCH_CLIST, utcb_area, ctrl, NULL);
if (r == 0) printf("Space control Error: 0x%lx\n", L4_ErrorCode());
assert( r == 1 );
r = okl4_kspaceid_allocany(spaceid_pool, &pong_space);
assert(r == OKL4_OK);
r = L4_SpaceControl(pong_space, L4_SpaceCtrl_new, KBENCH_CLIST, (fass ? pong_utcb_area : utcb_area), ctrl, NULL);
assert( r == 1);
utcb = no_utcb_alloc ? ~0UL : UTCB(0);
r = L4_ThreadControl(ping_tid, ping_space, master_tid, pager_tid, pager_tid, 0, (void *) utcb);
L4_StoreMR(0, &ping_th.raw);
assert( r == 1);
utcb = no_utcb_alloc ? ~0UL : fass ? PONGUTCB(1) : UTCB(1);
r = L4_ThreadControl(pong_tid, pong_space, master_tid, pager_tid, pager_tid, 0, (void *)utcb);
L4_StoreMR(0, &pong_th.raw);
} else {
/* Only Create ping space, but create both ping, pong thread in that space. */
r = okl4_kspaceid_allocany(spaceid_pool, &ping_space);
assert(r == OKL4_OK);
r = L4_SpaceControl(ping_space, L4_SpaceCtrl_new, KBENCH_CLIST, utcb_area, 0, NULL);
assert( r == 1 );
utcb = no_utcb_alloc ? ~0UL : UTCB(0);
r = L4_ThreadControl(ping_tid, ping_space, master_tid, pager_tid, pager_tid, 0, (void *) utcb);
L4_StoreMR(0, &ping_th.raw);
assert( r == 1);
utcb = no_utcb_alloc ? ~0UL : UTCB(1);
r = L4_ThreadControl(pong_tid, ping_space, master_tid, pager_tid, pager_tid, 0, (void *) utcb);
L4_StoreMR(0, &pong_th.raw);
assert( r == 1);
}
L4_KDB_SetThreadName(ping_tid, "ping");
if (test != &bench_ipc_pagemap) {
L4_KDB_SetThreadName(pong_tid, "pong");
}
}
static void
ipc_irq_setup(struct new_bench_test *test, int args[])
{
int r;
L4_Word_t utcb;
L4_Word_t utcb_size;
// L4_Word_t dummy;
num_iterations = args[0];
handler_space = L4_nilspace;
/* We need a maximum of two threads per task */
utcb_size = L4_GetUtcbSize();
#ifdef NO_UTCB_RELOCATE
utcb = ~0UL;
#else
utcb =(L4_Word_t)L4_GetUtcbBase() + utcb_size;
#endif
/* Create pager */
master_tid = KBENCH_SERVER;
pager_tid.raw = KBENCH_SERVER.raw + 1;
handler_tid.raw = KBENCH_SERVER.raw + 2;
interrupt = PMU_IRQ;
#if SPINNER
spinner_tid = L4_GlobalId (L4_ThreadNo (master_tid) + 3, 2);
#endif
r = L4_ThreadControl (pager_tid, KBENCH_SPACE, master_tid, master_tid,
master_tid, 0, (void*)utcb);
if (r == 0 && (L4_ErrorCode() == 2))
{
r = L4_ThreadControl (pager_tid, L4_nilspace, L4_nilthread,
L4_nilthread, L4_nilthread, 0, (void *) 0);
assert(r == 1);
r = L4_ThreadControl (pager_tid, KBENCH_SPACE, master_tid, master_tid,
master_tid, 0, (void*)utcb);
assert(r == 1);
}
L4_KDB_SetThreadName(pager_tid, "pager");
//L4_Schedule(pager_tid, -1, -1, 1, -1, -1, 0, &dummy, &dummy);
L4_Set_Priority(pager_tid, 254);
L4_Start_SpIp (pager_tid, (L4_Word_t) pager_stack + sizeof(pager_stack) - 32, START_ADDR (pager));
L4_Receive(pager_tid);
#ifdef NO_UTCB_RELOCATE
utcb = ~0UL;
#else
utcb += utcb_size;
#endif
r = L4_ThreadControl(handler_tid, KBENCH_SPACE, master_tid, pager_tid, pager_tid, 0, (void *) utcb);
assert(r == 1);
L4_KDB_SetThreadName(handler_tid, "handler");
L4_Set_Priority(handler_tid, 100);
// Startup notification, start handler thread
//printf("register irq %ld, to %lx\n", interrupt, handler_tid.raw);
L4_Word_t control = 0 | (0 << 6) | (31<<27);
L4_LoadMR(0, interrupt);
r = L4_InterruptControl(handler_tid, control);
if (r == 0) {
printf("Cannot register interrupt %lu\n", interrupt);
}
L4_Start_SpIp (handler_tid, (L4_Word_t) handler_stack + sizeof(handler_stack) - 32, START_ADDR(handler));
L4_Receive(handler_tid);
#if SPINNER
//Create spinner thread
#ifdef NO_UTCB_RELOCATE
utcb = ~0UL;
#else
utcb += utcb_size;
#endif
r = L4_ThreadControl (spinner_tid, KBENCH_SPACE, master_tid, pager_tid, pager_tid, 0, (void*) utcb);
if (r == 0) printf("create spinner failed %ld\n", L4_ErrorCode());
assert(r == 1);
L4_KDB_SetThreadName(spinner_tid, "spinner");
//L4_Schedule(spinner_tid, -1, -1, 1, -1, -1, 0, &dummy, &dummy);
//Set priority to the lowest.
L4_Set_Priority(spinner_tid, 1);
L4_Start_SpIp (spinner_tid, (L4_Word_t) spinner_stack + sizeof(spinner_stack) - 32, START_ADDR (spinner));
#endif
}
