int _okl4_kspace_mapbyid(okl4_kspaceid_t kspaceid, okl4_kspace_map_attr_t *attr) { okl4_word_t pages_mapped; okl4_word_t total_pages; assert(attr != NULL); /* Calculate the number of pages we need to map. */ assert(attr->range->size % attr->page_size == 0); total_pages = attr->range->size / attr->page_size; /* Perform the mappings. */ for (pages_mapped = 0; pages_mapped < total_pages; pages_mapped++) { L4_MapItem_t map; okl4_word_t success; /* Setup the map item. */ L4_MapItem_Map(&map, attr->target->segment_id, attr->target->range.base + pages_mapped * attr->page_size, attr->range->base + pages_mapped * attr->page_size, pagesize_to_bits(attr->page_size), attr->attributes, attr->perms); /* Perform the map. */ success = L4_ProcessMapItem(kspaceid, map); if (!success) { return _okl4_convert_kernel_errno(L4_ErrorCode()); } } return OKL4_OK; }
static void pager (void) { L4_ThreadId_t tid; L4_MsgTag_t tag; L4_Msg_t msg; L4_Send(master_tid); for (;;) { tag = L4_Wait(&tid); for (;;) { L4_Word_t faddr, fip; L4_MsgStore(tag, &msg); if (L4_UntypedWords (tag) != 2 || !L4_IpcSucceeded (tag)) { printf ("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); { 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); assert(seg != ~0UL); size = L4_GetMinPageBits(); faddr &= ~((1ul << size)-1); offset &= ~((1ul << size)-1); space.raw = __L4_TCR_SenderSpace(); 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); tag = L4_MsgTag(); L4_Set_SendBlock(&tag); L4_Set_ReceiveBlock(&tag); tag = L4_Ipc(tid, L4_anythread, tag, &tid); } } }
void okl4_map_page_kernel(unsigned long virt_addr, unsigned long src_addr, unsigned rwx, unsigned long attrib) { unsigned long seg; L4_MapItem_t map; virt_addr &= PAGE_MASK; if (!okl4_find_segment(src_addr, &src_addr, &seg)) panic("non existent segment"); L4_MapItem_Map(&map, seg, src_addr, virt_addr, PAGE_SHIFT, attrib, rwx); if (L4_ProcessMapItem(linux_space, map) == 0) panic("L4_ProcessMapItem: map failed"); }
/** * Setup a series of mappings. * * @param[in] page_size the page size to use for all the mappings * @param[in] n_pages how many pages to use in the sequence * @param[in] v the virtual address to start the sequence of mappings * @param[in] p the physical address to start the sequence of mappings * * @return 0 for success and non-zero on error */ static int map_series(L4_SpaceId_t space, L4_Word_t page_size, uintptr_t n_pages, uintptr_t v, uintptr_t offs) { int i, res = 1; uintptr_t page_bits = __L4_Msb(page_size); L4_MapItem_t map; for (i = 0; i < n_pages; i++, offs += page_size) { L4_MapItem_Map(&map, kernel_test_segment_id, offs, v + i*page_size, page_bits, L4_DefaultMemory, L4_FullyAccessible); res = L4_ProcessMapItem(space, map); if(res != 1) break; } return res; }
void okl4_map_page(mm_context_t *context, unsigned long virt_addr, unsigned long src_addr, unsigned rwx, unsigned long attrib) { unsigned long seg; L4_MapItem_t map; virt_addr &= PAGE_MASK; if (likely((last_vstart <= src_addr) && (src_addr <= last_vend))) { src_addr = src_addr - last_vstart; seg = last_seg; } else { if (!okl4_find_segment(src_addr, &src_addr, &seg)) panic("non existent segment"); } L4_MapItem_Map(&map, seg, src_addr, virt_addr, PAGE_SHIFT, attrib, rwx); if (L4_ProcessMapItem(context->space_id, map) == 0) panic("L4_ProcessMapItem: map failed"); }
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); } } }