Index: kernel/generic/src/mm/as.c =================================================================== --- kernel/generic/src/mm/as.c (revision d56382d76ccb7c32d44dba5afaf11a973ee2e2bb) +++ kernel/generic/src/mm/as.c (revision 7943c43ec7446695410d2e5521eb8121555e8c0c) @@ -387,4 +387,71 @@ } +/** Return pointer to unmapped address space area + * + * The address space must be already locked when calling + * this function. + * + * @param as Address space. + * @param bound Lowest address bound. + * @param size Requested size of the allocation. + * + * @return Address of the beginning of unmapped address space area. + * @return -1 if no suitable address space area was found. + * + */ +NO_TRACE static uintptr_t as_get_unmapped_area(as_t *as, uintptr_t bound, + size_t size) +{ + ASSERT(mutex_locked(&as->lock)); + + if (size == 0) + return (uintptr_t) -1; + + /* + * Make sure we allocate from page-aligned + * address. Check for possible overflow in + * each step. + */ + + size_t pages = SIZE2FRAMES(size); + + /* + * Find the lowest unmapped address aligned on the size + * boundary, not smaller than bound and of the required size. + */ + + /* First check the bound address itself */ + uintptr_t addr = ALIGN_UP(bound, PAGE_SIZE); + if ((addr >= bound) && + (check_area_conflicts(as, addr, pages, NULL))) + return addr; + + /* Eventually check the addresses behind each area */ + list_foreach(as->as_area_btree.leaf_list, cur) { + btree_node_t *node = + list_get_instance(cur, btree_node_t, leaf_link); + + for (btree_key_t i = 0; i < node->keys; i++) { + as_area_t *area = (as_area_t *) node->value[i]; + + mutex_lock(&area->lock); + + addr = + ALIGN_UP(area->base + P2SZ(area->pages), PAGE_SIZE); + bool avail = + ((addr >= bound) && (addr >= area->base) && + (check_area_conflicts(as, addr, pages, area))); + + mutex_unlock(&area->lock); + + if (avail) + return addr; + } + } + + /* No suitable address space area found */ + return (uintptr_t) -1; +} + /** Create address space area of common attributes. * @@ -394,8 +461,11 @@ * @param flags Flags of the area memory. * @param size Size of area. - * @param base Base address of area. * @param attrs Attributes of the area. * @param backend Address space area backend. NULL if no backend is used. * @param backend_data NULL or a pointer to an array holding two void *. + * @param base Starting virtual address of the area. + * If set to -1, a suitable mappable area is found. + * @param bound Lowest address bound if base is set to -1. + * Otherwise ignored. * * @return Address space area on success or NULL on failure. @@ -403,8 +473,8 @@ */ as_area_t *as_area_create(as_t *as, unsigned int flags, size_t size, - uintptr_t base, unsigned int attrs, mem_backend_t *backend, - mem_backend_data_t *backend_data) -{ - if ((base % PAGE_SIZE) != 0) + unsigned int attrs, mem_backend_t *backend, + mem_backend_data_t *backend_data, uintptr_t *base, uintptr_t bound) +{ + if ((*base != (uintptr_t) -1) && ((*base % PAGE_SIZE) != 0)) return NULL; @@ -420,5 +490,13 @@ mutex_lock(&as->lock); - if (!check_area_conflicts(as, base, pages, NULL)) { + if (*base == (uintptr_t) -1) { + *base = as_get_unmapped_area(as, bound, size); + if (*base == (uintptr_t) -1) { + mutex_unlock(&as->lock); + return NULL; + } + } + + if (!check_area_conflicts(as, *base, pages, NULL)) { mutex_unlock(&as->lock); return NULL; @@ -434,5 +512,5 @@ area->pages = pages; area->resident = 0; - area->base = base; + area->base = *base; area->sh_info = NULL; area->backend = backend; @@ -452,5 +530,6 @@ btree_create(&area->used_space); - btree_insert(&as->as_area_btree, base, (void *) area, NULL); + btree_insert(&as->as_area_btree, *base, (void *) area, + NULL); mutex_unlock(&as->lock); @@ -860,6 +939,9 @@ * @param acc_size Expected size of the source area. * @param dst_as Pointer to destination address space. - * @param dst_base Target base address. * @param dst_flags_mask Destination address space area flags mask. + * @param dst_base Target base address. If set to -1, + * a suitable mappable area is found. + * @param bound Lowest address bound if dst_base is set to -1. + * Otherwise ignored. * * @return Zero on success. @@ -873,5 +955,6 @@ */ int as_area_share(as_t *src_as, uintptr_t src_base, size_t acc_size, - as_t *dst_as, uintptr_t dst_base, unsigned int dst_flags_mask) + as_t *dst_as, unsigned int dst_flags_mask, uintptr_t *dst_base, + uintptr_t bound) { mutex_lock(&src_as->lock); @@ -945,6 +1028,7 @@ * to support sharing in less privileged mode. */ - as_area_t *dst_area = as_area_create(dst_as, dst_flags_mask, src_size, - dst_base, AS_AREA_ATTR_PARTIAL, src_backend, &src_backend_data); + as_area_t *dst_area = as_area_create(dst_as, dst_flags_mask, + src_size, AS_AREA_ATTR_PARTIAL, src_backend, + &src_backend_data, dst_base, bound); if (!dst_area) { /* @@ -1955,15 +2039,16 @@ */ -/** Wrapper for as_area_create(). */ -sysarg_t sys_as_area_create(uintptr_t address, size_t size, unsigned int flags) -{ - if (as_area_create(AS, flags | AS_AREA_CACHEABLE, size, address, - AS_AREA_ATTR_NONE, &anon_backend, NULL)) - return (sysarg_t) address; - else +sysarg_t sys_as_area_create(uintptr_t base, size_t size, unsigned int flags, + uintptr_t bound) +{ + uintptr_t virt = base; + as_area_t *area = as_area_create(AS, flags | AS_AREA_CACHEABLE, size, + AS_AREA_ATTR_NONE, &anon_backend, NULL, &virt, bound); + if (area == NULL) return (sysarg_t) -1; -} - -/** Wrapper for as_area_resize(). */ + + return (sysarg_t) virt; +} + sysarg_t sys_as_area_resize(uintptr_t address, size_t size, unsigned int flags) { @@ -1971,5 +2056,4 @@ } -/** Wrapper for as_area_change_flags(). */ sysarg_t sys_as_area_change_flags(uintptr_t address, unsigned int flags) { @@ -1977,75 +2061,7 @@ } -/** Wrapper for as_area_destroy(). */ sysarg_t sys_as_area_destroy(uintptr_t address) { return (sysarg_t) as_area_destroy(AS, address); -} - -/** Return pointer to unmapped address space area - * - * @param base Lowest address bound. - * @param size Requested size of the allocation. - * - * @return Pointer to the beginning of unmapped address space area. - * - */ -sysarg_t sys_as_get_unmapped_area(uintptr_t base, size_t size) -{ - if (size == 0) - return 0; - - /* - * Make sure we allocate from page-aligned - * address. Check for possible overflow in - * each step. - */ - - size_t pages = SIZE2FRAMES(size); - uintptr_t ret = 0; - - /* - * Find the lowest unmapped address aligned on the sz - * boundary, not smaller than base and of the required size. - */ - - mutex_lock(&AS->lock); - - /* First check the base address itself */ - uintptr_t addr = ALIGN_UP(base, PAGE_SIZE); - if ((addr >= base) && - (check_area_conflicts(AS, addr, pages, NULL))) - ret = addr; - - /* Eventually check the addresses behind each area */ - list_foreach(AS->as_area_btree.leaf_list, cur) { - if (ret != 0) - break; - - btree_node_t *node = - list_get_instance(cur, btree_node_t, leaf_link); - - btree_key_t i; - for (i = 0; (ret == 0) && (i < node->keys); i++) { - uintptr_t addr; - - as_area_t *area = (as_area_t *) node->value[i]; - - mutex_lock(&area->lock); - - addr = ALIGN_UP(area->base + P2SZ(area->pages), - PAGE_SIZE); - - if ((addr >= base) && (addr >= area->base) && - (check_area_conflicts(AS, addr, pages, area))) - ret = addr; - - mutex_unlock(&area->lock); - } - } - - mutex_unlock(&AS->lock); - - return (sysarg_t) ret; } Index: kernel/generic/src/mm/frame.c =================================================================== --- kernel/generic/src/mm/frame.c (revision d56382d76ccb7c32d44dba5afaf11a973ee2e2bb) +++ kernel/generic/src/mm/frame.c (revision 7943c43ec7446695410d2e5521eb8121555e8c0c) @@ -870,5 +870,6 @@ size_t order = ispwr2(size) ? fnzb(size) : (fnzb(size) + 1); - return ADDR2PFN((uintptr_t) frame_alloc(order - FRAME_WIDTH, FRAME_LOWMEM)); + return ADDR2PFN((uintptr_t) frame_alloc(order - FRAME_WIDTH, + FRAME_LOWMEM | FRAME_ATOMIC)); }