int main(void)
{
#if 0
static char restxt[20] = "Welcome to lkOS/lxL4";
//char *data = (char *) malloc(20);
//static char data[20];
L4m_Setbrk(USR_STACK_BEG + PGSIZE);
char *data = (char *) USR_STACK_BEG;
char *res = (char *) USR_STACK_BEG + 20;
memcpy(res, restxt, 20);
#else
static char restxt[20] = "Welcome to lkOS/lxL4";
#endif
again:;
char *data = (char *) malloc(20);
char *res = (char *) malloc(20);
memcpy(res, restxt, 20);
//printstr("w waiting...\n");
L4_Wait(5, data);
//printstr("w got data=");
//printnstr(data, sizeof(data));
//printstr("\n");
//printstr("w replying...\n");
L4_ReplyWait(5, res, data);
free(data);
free(res);
goto again;
}
static void w_thread(void)
{
static char data[20], res[20] = "Welcome to my lwL4!";
for (;;) L4_Yield();
again:
//printstr("w waiting...\n");
L4_Wait(5, data);
//printstr("w got data=");
//printnstr(data, sizeof(data));
//printstr("\n");
//printstr("w replying...\n");
L4_ReplyWait(5, res, data);
goto again;
}
void fault_server(void)
{
L4m_fault_info_t u;
L4m_fault_result_t r;
L4_Wait(2, &u.data);
while (1) {
ad_t offset = u.pf_offset & PGMASK;
ad_t buff = FDMEM0_ADDR + offset;
r.sv_buff = buff;
L4_ReplyWait(2, &r.data, &u.data);
}
}
int main(void)
{
L4m_fault_info_t u;
L4m_fault_result_t r;
L4_Wait(2, &u.data);
while (1) {
ad_t buff = alloc_page();
load_data((char *) buff);
r.sv_buff = buff;
L4_ReplyWait(2, &r.data, &u.data);
}
}
static void
pager (void)
{
L4_ThreadId_t tid;
L4_MsgTag_t tag;
L4_Msg_t msg;
int count = 0;
for (;;) {
tag = L4_Wait(&tid);
for (;;) {
L4_Word_t faddr, fip;
L4_MsgStore(tag, &msg);
if (L4_Label(tag) == START_LABEL) {
// Startup notification, start ping and pong thread
void (*start_addr)(void);
void (*pong_start_addr)(void);
L4_Word_t *pong_stack_addr = pong_stack;
if (pagertimer) {
start_addr = ping_thread_pager;
} else if (pagertimer_simulated) {
start_addr = ping_thread_simulated;
} else if (fass_buffer) {
start_addr = ping_thread_buffer;
} else if (fault_test) {
count = 0;
start_addr = NULL;
} else if (intra_close) {
start_addr = ping_thread_close;
} else if (intra_open) {
start_addr = ping_thread_open;
} else if (intra_rpc) {
start_addr = ping_thread_rpc_server;
} else if (intra_ovh) {
start_addr = ping_thread_ovh;
} else if (intra_async) {
start_addr = ping_thread_async;
} else if (intra_async_ovh) {
start_addr = ping_thread_async_ovh;
} else {
start_addr = ping_thread;
}
if (start_addr != NULL) {
/*printf("ping_start_addr: %lx ping_stack_addr: %lx\n",
START_ADDR (start_addr), (L4_Word_t) ping_stack);*/
send_startup_ipc (ping_tid,
START_ADDR(start_addr),
(L4_Word_t) ping_stack +
sizeof (ping_stack) - 32);
L4_ThreadSwitch(ping_tid);
}
if (fass_buffer) {
pong_start_addr = pong_thread_buffer;
pong_stack_addr = pong_stack_fass;
} else if (fass) {
pong_start_addr = pong_thread_fass;
pong_stack_addr = pong_stack_fass;
} else if (fault_test) {
pong_stack_addr = pong_stack_fass;
pong_start_addr = pong_thread_faulter;
} else if (intra_close) {
pong_start_addr = pong_thread_close;
} else if (intra_open) {
pong_start_addr = pong_thread_open;
} else if (intra_rpc) {
pong_start_addr = pong_thread_close;
} else if (intra_ovh) {
pong_start_addr = pong_thread_ovh;
} else if (intra_async) {
pong_start_addr = pong_thread_async;
} else if (intra_async_ovh) {
pong_start_addr = pong_thread_async_ovh;
} else {
pong_start_addr = pong_thread;
}
if (!pagertimer) {
/*printf("pong_start_addr: %lx pong_stack_addr: %lx\n",
START_ADDR (pong_start_addr), (L4_Word_t) pong_stack_addr);*/
L4_Set_Priority(ping_tid, 100);
L4_Set_Priority(pong_tid, 99);
send_startup_ipc (pong_tid,
START_ADDR (pong_start_addr),
(L4_Word_t) pong_stack_addr + sizeof (ping_stack) - 32);
}
break;
}
if (L4_UntypedWords (tag) != 2 ||
!L4_IpcSucceeded (tag)) {
printf ("pingpong: malformed pagefault IPC from %p (tag=%p)\n",
(void *) tid.raw, (void *) tag.raw);
L4_KDB_Enter ("malformed pf");
break;
}
faddr = L4_MsgWord(&msg, 0);
fip = L4_MsgWord (&msg, 1);
L4_MsgClear(&msg);
if (fault_test && (faddr == (uintptr_t) fault_area)) {
if (count < num_iterations) {
count++;
} else {
/* Tell master that we're finished */
L4_Set_MsgTag (L4_Niltag);
L4_Send (master_tid);
break;
}
} else {
L4_MapItem_t map;
L4_SpaceId_t space;
L4_Word_t seg, offset, cache, rwx, size;
int r;
seg = get_seg(KBENCH_SPACE, faddr, &offset, &cache, &rwx);
//if can not find mapping, must be page fault test,
//just map any valid address, since fault address is dummy.
if (seg == ~0UL)
seg = get_seg(KBENCH_SPACE, (L4_Word_t) fault_area,
&offset, &cache, &rwx);
if (tid.raw == ping_th.raw)
space = ping_space;
else if (tid.raw == pong_th.raw)
{
if (pong_space.raw != L4_nilspace.raw)
space = pong_space;
else //pong_space is not created, only ping_space is used.
space = ping_space;
}
else
space = KBENCH_SPACE;
size = L4_GetMinPageBits();
faddr &= ~((1ul << size)-1);
offset &= ~((1ul << size)-1);
L4_MapItem_Map(&map, seg, offset, faddr, size,
cache, rwx);
r = L4_ProcessMapItem(space, map);
assert(r == 1);
}
L4_MsgLoad(&msg);
tag = L4_ReplyWait (tid, &tid);
}
}
}
