| /branches/dynload/kernel/generic/include/mm/as.h |
|---|
| 269,6 → 269,7 |
| extern int as_area_resize(as_t *as, uintptr_t address, size_t size, int flags); |
| int as_area_share(as_t *src_as, uintptr_t src_base, size_t acc_size, |
| as_t *dst_as, uintptr_t dst_base, int dst_flags_mask); |
| extern int as_area_change_flags(as_t *as, int flags, uintptr_t address); |
| extern int as_area_get_flags(as_area_t *area); |
| extern bool as_area_check_access(as_area_t *area, pf_access_t access); |
| 304,6 → 305,7 |
| /* Address space area related syscalls. */ |
| extern unative_t sys_as_area_create(uintptr_t address, size_t size, int flags); |
| extern unative_t sys_as_area_resize(uintptr_t address, size_t size, int flags); |
| extern unative_t sys_as_area_change_flags(uintptr_t address, int flags); |
| extern unative_t sys_as_area_destroy(uintptr_t address); |
| /* Introspection functions. */ |
| /branches/dynload/kernel/generic/include/syscall/syscall.h |
|---|
| 46,6 → 46,7 |
| SYS_FUTEX_WAKEUP, |
| SYS_AS_AREA_CREATE, |
| SYS_AS_AREA_RESIZE, |
| SYS_AS_AREA_CHANGE_FLAGS, |
| SYS_AS_AREA_DESTROY, |
| SYS_IPC_CALL_SYNC_FAST, |
| SYS_IPC_CALL_SYNC_SLOW, |
| 65,8 → 66,8 |
| SYS_PREEMPT_CONTROL, |
| SYS_SYSINFO_VALID, |
| SYS_SYSINFO_VALUE, |
| SYS_DEBUG_PUTINT, |
| SYS_DEBUG_ENABLE_CONSOLE, |
| SYS_DEBUG_PUTINT, |
| SYSCALL_END |
| } syscall_t; |
| /branches/dynload/kernel/generic/src/mm/as.c |
|---|
| 775,6 → 775,100 |
| return true; |
| } |
| /** Change adress area flags. |
| * |
| * The idea is to have the same data, but with a different access mode. |
| * This is needed e.g. for writing code into memory and then executing it. |
| * In order for this to work properly, this may copy the data |
| * into private anonymous memory (unless it's already there). |
| * |
| * @param as Address space. |
| * @param flags Flags of the area memory. |
| * @param address Address withing the area to be changed. |
| * |
| * @return Zero on success or a value from @ref errno.h on failure. |
| */ |
| int as_area_change_flags(as_t *as, int flags, uintptr_t address) |
| { |
| as_area_t *area; |
| uintptr_t base; |
| link_t *cur; |
| ipl_t ipl; |
| ipl = interrupts_disable(); |
| mutex_lock(&as->lock); |
| area = find_area_and_lock(as, address); |
| if (!area) { |
| mutex_unlock(&as->lock); |
| interrupts_restore(ipl); |
| return ENOENT; |
| } |
| if (area->sh_info || area->backend != &anon_backend) { |
| /* Copying shared areas not supported yet */ |
| /* Copying non-anonymous memory not supported yet */ |
| mutex_unlock(&as->lock); |
| interrupts_restore(ipl); |
| return ENOTSUP; |
| } |
| base = area->base; |
| /* |
| * Start TLB shootdown sequence. |
| */ |
| tlb_shootdown_start(TLB_INVL_PAGES, as->asid, area->base, area->pages); |
| /* |
| * Visit only the pages mapped by used_space B+tree. |
| */ |
| for (cur = area->used_space.leaf_head.next; |
| cur != &area->used_space.leaf_head; cur = cur->next) { |
| btree_node_t *node; |
| unsigned int i; |
| node = list_get_instance(cur, btree_node_t, leaf_link); |
| for (i = 0; i < node->keys; i++) { |
| uintptr_t b = node->key[i]; |
| count_t j; |
| pte_t *pte; |
| for (j = 0; j < (count_t) node->value[i]; j++) { |
| page_table_lock(as, false); |
| pte = page_mapping_find(as, b + j * PAGE_SIZE); |
| ASSERT(pte && PTE_VALID(pte) && |
| PTE_PRESENT(pte)); |
| /* Remove old mapping and insert the new one */ |
| page_mapping_remove(as, b + j * PAGE_SIZE); |
| page_mapping_insert(as, b + j * PAGE_SIZE, |
| PTE_GET_FRAME(pte), flags); |
| page_table_unlock(as, false); |
| } |
| } |
| } |
| /* |
| * Finish TLB shootdown sequence. |
| */ |
| tlb_invalidate_pages(as->asid, area->base, area->pages); |
| /* |
| * Invalidate potential software translation caches (e.g. TSB on |
| * sparc64). |
| */ |
| as_invalidate_translation_cache(as, area->base, area->pages); |
| tlb_shootdown_finalize(); |
| mutex_unlock(&area->lock); |
| mutex_unlock(&as->lock); |
| interrupts_restore(ipl); |
| return 0; |
| } |
| /** Handle page fault within the current address space. |
| * |
| * This is the high-level page fault handler. It decides |
| 1770,6 → 1864,12 |
| return (unative_t) as_area_resize(AS, address, size, 0); |
| } |
| /** Wrapper for as_area_change_flags(). */ |
| unative_t sys_as_area_change_flags(uintptr_t address, int flags) |
| { |
| return (unative_t) as_area_change_flags(AS, flags, address); |
| } |
| /** Wrapper for as_area_destroy(). */ |
| unative_t sys_as_area_destroy(uintptr_t address) |
| { |
| /branches/dynload/kernel/generic/src/syscall/syscall.c |
|---|
| 136,6 → 136,7 |
| /* Address space related syscalls. */ |
| (syshandler_t) sys_as_area_create, |
| (syshandler_t) sys_as_area_resize, |
| (syshandler_t) sys_as_area_change_flags, |
| (syshandler_t) sys_as_area_destroy, |
| /* IPC related syscalls. */ |
| 165,8 → 166,8 |
| (syshandler_t) sys_sysinfo_value, |
| /* Debug calls */ |
| (syshandler_t) sys_debug_enable_console, |
| (syshandler_t) sys_debug_putint |
| (syshandler_t) sys_debug_putint, |
| (syshandler_t) sys_debug_enable_console |
| }; |
| /** @} |
| /branches/dynload/uspace/lib/libc/include/as.h |
|---|
| 42,6 → 42,7 |
| extern void *as_area_create(void *address, size_t size, int flags); |
| extern int as_area_resize(void *address, size_t size, int flags); |
| int as_area_change_flags(void *address, int flags); |
| extern int as_area_destroy(void *address); |
| extern void *set_maxheapsize(size_t mhs); |
| extern void * as_get_mappable_page(size_t sz); |
| /branches/dynload/uspace/lib/libc/generic/as.c |
|---|
| 85,6 → 85,20 |
| return __SYSCALL1(SYS_AS_AREA_DESTROY, (sysarg_t ) address); |
| } |
| /** Change address-space area flags. |
| * |
| * @param address Virtual address pointing into the address space area being |
| * modified. |
| * @param flags New flags describing type of the area. |
| * |
| * @return Zero on success or a code from @ref errno.h on failure. |
| */ |
| int as_area_change_flags(void *address, int flags) |
| { |
| return __SYSCALL2(SYS_AS_AREA_DESTROY, (sysarg_t) address, |
| (sysarg_t) flags); |
| } |
| static size_t heapsize = 0; |
| static size_t maxheapsize = (size_t) (-1); |