static void
ping_thread_simulated (void)
{
volatile L4_Word_t x;
/* Wait for pong thread to come up */
L4_Msg_t msg;
L4_MsgTag_t tag;
for (int i=0; i < num_iterations; i++) {
L4_Fpage_t ppage = L4_Fpage((L4_Word_t)&fault_area[i*1024], 4096);
L4_Set_Rights(&ppage, L4_FullyAccessible);
/* accept fpages */
L4_Accept(L4_UntypedWordsAcceptor);
/* send it to our pager */
L4_MsgClear(&msg);
L4_MsgAppendWord(&msg, (L4_Word_t) ppage.raw);
L4_MsgAppendWord(&msg, (L4_Word_t) 0);
L4_Set_Label(&msg.tag, L4_PAGEFAULT);
L4_MsgLoad(&msg);
/* make the call */
tag = L4_Call(pager_tid);
x = fault_area[i*1024];
}
/* Tell master that we're finished */
L4_Set_MsgTag (L4_Niltag);
L4_Send (master_tid);
for (;;)
L4_WaitForever();
/* NOTREACHED */
}
void thread_start(L4_ThreadId_t tid, L4_Word_t ip, char *cmdline, int npaths, char **paths, HpfCapability *caps)
{
list_t *li;
L4_Word_t sp;
mutex_lock(&thrlock);
li = list_find(thread_list, &tid, sizeof(L4_ThreadId_t));
if (!li) {
mutex_unlock(&thrlock);
return;
}
sp = STACK_BASE - (THREAD_TYPE(li->data)->index * STACK_SIZE);
sp -= thread_prepare_stack(THREAD_TYPE(li->data)->space, sp, cmdline, npaths, paths, caps);
/* send "start" message */
L4_Msg_t msg;
L4_MsgClear(&msg);
L4_MsgAppendWord(&msg, ip);
L4_MsgAppendWord(&msg, sp);
L4_Set_Propagation(&msg.tag);
L4_Set_VirtualSender(THREAD_TYPE(li->data)->space->pager);
L4_MsgLoad(&msg);
L4_Send(tid);
mutex_unlock(&thrlock);
}
void
sys$sigma0_map_fpage(L4_Fpage_t virt_page, L4_Fpage_t phys_page,
unsigned int priv)
{
L4_ThreadId_t tid;
L4_MsgTag_t tag;
L4_Msg_t msg;
L4_MapItem_t map;
// Find Pager's ID
tid = L4_Pager();
L4_Set_Rights(&phys_page, priv);
L4_Accept(L4_MapGrantItems(virt_page));
L4_MsgClear(&msg);
L4_MsgAppendWord(&msg, (L4_Word_t) phys_page.raw);
L4_MsgAppendWord(&msg, (L4_Word_t) 0);
L4_Set_Label(&msg.tag, SIGMA0_REQUEST_LABEL);
L4_MsgLoad(&msg);
tag = L4_Call(tid);
PANIC(L4_IpcFailed(tag), notice(IPC_F_FAILED "IPC failed (error %ld: %s)\n",
L4_ErrorCode(), L4_ErrorCode_String(L4_ErrorCode())));
L4_MsgStore(tag, &msg);
L4_MsgGetMapItem(&msg, 0, &map);
if (dbg$virtual_memory == 1)
{
if (map.X.snd_fpage.raw == L4_Nilpage.raw)
{
notice(MEM_I_REJMAP "rejecting mapping\n");
notice(MEM_I_REJMAP "virtual $%016lX - $%016lX\n",
L4_Address(virt_page), L4_Address(virt_page)
+ (L4_Size(virt_page) - 1));
notice(MEM_I_REJMAP "physical $%016lX - $%016lX\n",
L4_Address(phys_page), L4_Address(phys_page)
+ (L4_Size(phys_page) - 1));
}
else
{
notice(MEM_I_ACCMAP "accepting mapping\n");
notice(MEM_I_ACCMAP "virtual $%016lX - $%016lX\n",
L4_Address(virt_page), L4_Address(virt_page)
+ (L4_Size(virt_page) - 1));
notice(MEM_I_ACCMAP "physical $%016lX - $%016lX\n",
L4_Address(phys_page), L4_Address(phys_page)
+ (L4_Size(phys_page) - 1));
}
}
return;
}
static void
send_startup_ipc (L4_ThreadId_t tid, L4_Word_t ip, L4_Word_t sp)
{
L4_Msg_t msg;
L4_MsgClear(&msg);
L4_MsgAppendWord(&msg, ip);
L4_MsgAppendWord(&msg, sp);
L4_MsgLoad(&msg);
L4_Send(tid);
}
static void __USER_TEXT start_thread(L4_ThreadId_t t, L4_Word_t ip,
L4_Word_t sp, L4_Word_t stack_size)
{
L4_Msg_t msg;
L4_MsgClear(&msg);
L4_MsgAppendWord(&msg, ip);
L4_MsgAppendWord(&msg, sp);
L4_MsgAppendWord(&msg, stack_size);
L4_MsgAppendWord(&msg, 0);
L4_MsgAppendWord(&msg, 0);
L4_MsgLoad(&msg);
L4_Send(t);
}
void
utimer_sleep(uint32_t microseconds)
{
utimer_entry_t entry =
{ L4_KDB_GetTick(), (uint32_t) US_TO_TICKS(microseconds)};
L4_Msg_t msg; L4_MsgClear(&msg);
L4_MsgAppendWord(&msg, (uintptr_t) &entry);
L4_MsgLoad(&msg);
L4_Call(utimer_tid);
}
size_t
sos_write(const void *vData, long int position, size_t count, void *handle)
{
size_t i;
const char *realdata = vData;
// send over serial
for (i = 0; i < count; i++)
L4_KDB_PrintChar(realdata[i]);
// send to syscall in chunks of 5 words
// so that we use all 6 ARM registers
//for (i = position; i < count;) // well looks like this is not what position is for.
for (i = 0; i < count;) // i incremented in the loop
{
L4_Msg_t msg;
L4_MsgClear(&msg);
L4_Set_MsgLabel(&msg, MAKETAG_SYSLAB(SOS_SYSCALL_SERIAL_SEND));
// add the words to the message
for (int j = 0; j < WORDS_SENT_PER_IPC && i < count; j++)
{
// initialize to 0 so we send 0-chars if the message
// is not word-padded
L4_Word_t word = 0;
// add bytes one by one
char* writeTo = (char*) &word;
for (int k = 0; k < sizeof(L4_Word_t) && i < count; k++)
{
*(writeTo++) = realdata[i++];
}
L4_MsgAppendWord(&msg, word);
}
L4_MsgLoad(&msg);
L4_MsgTag_t tag = L4_Send(sSystemId);
if (L4_IpcFailed(tag)) {
// FIXME: actually useful debug message
L4_KDB_PrintChar('E');
L4_KDB_PrintChar('S');
L4_KDB_PrintChar('M');
break;
}
}
return i;
}
int
main(void)
{
int i = 0;
int res = 1;
L4_SpaceId_t space;
okl4_allocator_attr_t attr;
L4_Word_t end, result;
L4_CapId_t sender;
L4_MsgTag_t tag;
L4_Msg_t msg;
struct okl4_bitmap_allocator *spaceid_pool = okl4_env_get("MAIN_SPACE_ID_POOL");
HEAP_EXHAUSTION_CLIST = L4_ClistId(*(OKL4_ENV_GET_MAIN_CLISTID("MAIN_CLIST_ID")));
while(res == 1)
{
result = okl4_kspaceid_allocany(spaceid_pool, &space);
if (result != OKL4_OK) {
printf("Failed to allocate space id\n");
}
res = create_address_space(space,
L4_Fpage(0xb10000, 0x1000));
if (res != 1) {
printf("SpaceControl failed, space id=%lu, Error code: %lu\n", space.space_no, L4_ErrorCode());
break;
}
/* 2gb mapping of 512k pages*/
res = map_series(space, 0x80000, 4096, 0, 0);
i++;
}
printf("Created %d address spaces\n", i);
if (i == 0) {
okl4_kspaceid_free(spaceid_pool, space);
res = 0;
goto ipc_ktest;
}
/* clean up */
okl4_kspaceid_getattribute(spaceid_pool, &attr);
end = attr.base + attr.size;
for (i = attr.base; i < end; i++)
{
L4_SpaceId_t id = L4_SpaceId(i);
if (okl4_kspaceid_isallocated(spaceid_pool, id))
{
L4_SpaceControl(id, L4_SpaceCtrl_delete,
HEAP_EXHAUSTION_CLIST, L4_Nilpage, 0, NULL);
okl4_kspaceid_free(spaceid_pool, id);
}
}
res = 1;
ipc_ktest:
tag = L4_Wait(&sender);
L4_MsgClear(&msg);
L4_MsgAppendWord(&msg, (L4_Word_t)res);
L4_MsgLoad(&msg);
L4_Reply(sender);
assert(L4_IpcSucceeded(tag));
L4_WaitForever();
}
int
l4e_sigma0_map_fpage(L4_Fpage_t virt_page, L4_Fpage_t phys_page)
{
/*
* XXX: These two special cases are workarounds for broken superpage
* support in pistachio. On ARM, 1M superpages are disabled by
* pistachio to reduce the size of the mapping database, however due to
* bugs in the mapping code, any mappings >= 1M get converted into 4K
* mappings (rather than 64K). For MIPS, the tlb refill code assumes
* only 4K mappings are used, even the the pagetable building code will
* use superpages where possible. -- alexw
*/
#if defined(ARCH_ARM)
uintptr_t virt_base = L4_Address(virt_page);
uintptr_t phys_base = L4_Address(phys_page);
uintptr_t offset = 0;
uintptr_t step = L4_Size(virt_page) > 0x10000 ? 0x10000 : L4_Size(virt_page);
uintptr_t limit = L4_Size(virt_page) - 1;
for (virt_page = L4_Fpage(virt_base + offset, step),
phys_page = L4_Fpage(phys_base + offset, step);
offset < limit;
offset += step,
virt_page = L4_Fpage(virt_base + offset, step),
phys_page = L4_Fpage(phys_base + offset, step))
#elif defined(ARCH_MIPS64)
uintptr_t virt_base = L4_Address(virt_page);
uintptr_t phys_base = L4_Address(phys_page);
uintptr_t offset = 0;
uintptr_t step = 0x1000;
uintptr_t limit = L4_Size(virt_page) - 1;
for (virt_page = L4_Fpage(virt_base + offset, step),
phys_page = L4_Fpage(phys_base + offset, step);
offset < limit;
offset += step,
virt_page = L4_Fpage(virt_base + offset, step),
phys_page = L4_Fpage(phys_base + offset, step))
#endif
{
L4_ThreadId_t tid;
L4_MsgTag_t tag;
L4_Msg_t msg;
L4_MapItem_t map;
/*
* find our pager's ID
*/
tid = L4_Pager();
L4_Set_Rights(&phys_page, L4_FullyAccessible);
/* accept fpages */
L4_Accept(L4_MapGrantItems(virt_page));
/* send it to our pager */
L4_MsgClear(&msg);
L4_MsgAppendWord(&msg, (L4_Word_t) phys_page.raw);
L4_MsgAppendWord(&msg, (L4_Word_t) 0);
L4_Set_Label(&msg.tag, SIGMA0_REQUEST_LABEL);
L4_MsgLoad(&msg);
/* make the call */
tag = L4_Call(tid);
/* check for an error */
if (L4_IpcFailed(tag)) {
return 2;
}
L4_MsgStore(tag, &msg);
L4_MsgGetMapItem(&msg, 0, &map);
/*
* rejected mapping?
*/
if (map.X.snd_fpage.raw == L4_Nilpage.raw) {
return 1;
}
}
return 0;
}
