uspace/libc/generic/as.c

   1 /*
   2  * Copyright (c) 2006 Jakub Jermar
   3  * All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions
   7  * are met:
   8  *
   9  * - Redistributions of source code must retain the above copyright
  10  *   notice, this list of conditions and the following disclaimer.
  11  * - Redistributions in binary form must reproduce the above copyright
  12  *   notice, this list of conditions and the following disclaimer in the
  13  *   documentation and/or other materials provided with the distribution.
  14  * - The name of the author may not be used to endorse or promote products
  15  *   derived from this software without specific prior written permission.
  16  *
  17  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
  18  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  19  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  20  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
  21  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  22  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  23  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  24  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  25  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  26  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  27  */
  28
  29 /** @addtogroup libc
  30  * @{
  31  */
  32 /** @file
  33  */
  34
  35 #include <as.h>
  36 #include <libc.h>
  37 #include <unistd.h>
  38 #include <align.h>
  39 #include <types.h>
  40 #include <bitops.h>
  41
  42 /**
  43  * Either 4*256M on 32-bit architecures or 16*256M on 64-bit architectures.
  44  */
  45 #define MAX_HEAP_SIZE   (sizeof(uintptr_t)<<28)
  46
  47 /** Create address space area.
  48  *
  49  * @param address Virtual address where to place new address space area.
  50  * @param size Size of the area.
  51  * @param flags Flags describing type of the area.
  52  *
  53  * @return address on success, (void *) -1 otherwise.
  54  */
  55 void *as_area_create(void *address, size_t size, int flags)
  56 {
  57         return (void *) __SYSCALL3(SYS_AS_AREA_CREATE, (sysarg_t ) address,
  58                 (sysarg_t) size, (sysarg_t) flags);
  59 }
  60
  61 /** Resize address space area.
  62  *
  63  * @param address Virtual address pointing into already existing address space
  64  *      area.
  65  * @param size New requested size of the area.
  66  * @param flags Currently unused.
  67  *
  68  * @return Zero on success or a code from @ref errno.h on failure.
  69  */
  70 int as_area_resize(void *address, size_t size, int flags)
  71 {
  72         return __SYSCALL3(SYS_AS_AREA_RESIZE, (sysarg_t ) address, (sysarg_t)
  73                 size, (sysarg_t) flags);
  74 }
  75
  76 /** Destroy address space area.
  77  *
  78  * @param address Virtual address pointing into the address space area being
  79  *      destroyed.
  80  *
  81  * @return Zero on success or a code from @ref errno.h on failure.
  82  */
  83 int as_area_destroy(void *address)
  84 {
  85         return __SYSCALL1(SYS_AS_AREA_DESTROY, (sysarg_t ) address);
  86 }
  87
  88 static size_t heapsize = 0;
  89 static size_t maxheapsize = (size_t) (-1);
  90
  91 static void * last_allocated = 0;
  92
  93 /* Start of heap linker symbol */
  94 extern char _heap;
  95
  96 /** Sbrk emulation
  97  *
  98  * @param incr New area that should be allocated or negative,
  99                if it should be shrinked
 100  * @return Pointer to newly allocated area
 101  */
 102 void *sbrk(ssize_t incr)
 103 {
 104         int rc;
 105         void *res;
 106
 107         /* Check for invalid values */
 108         if (incr < 0 && -incr > heapsize)
 109                 return NULL;
 110
 111         /* Check for too large value */
 112         if (incr > 0 && incr+heapsize < heapsize)
 113                 return NULL;
 114
 115         /* Check for too small values */
 116         if (incr < 0 && incr+heapsize > heapsize)
 117                 return NULL;
 118
 119         /* Check for user limit */
 120         if ((maxheapsize != (size_t) (-1)) && (heapsize + incr) > maxheapsize)
 121                 return NULL;
 122
 123         rc = as_area_resize(&_heap, heapsize + incr, 0);
 124         if (rc != 0)
 125                 return NULL;
 126
 127         /* Compute start of new area */
 128         res = (void *) &_heap + heapsize;
 129
 130         heapsize += incr;
 131
 132         return res;
 133 }
 134
 135 /** Set maximum heap size and return pointer just after the heap */
 136 void *set_maxheapsize(size_t mhs)
 137 {
 138         maxheapsize = mhs;
 139         /* Return pointer to area not managed by sbrk */
 140         return ((void *) &_heap + maxheapsize);
 141 }
 142
 143 /** Return pointer to some unmapped area, where fits new as_area
 144  *
 145  * @param sz Requested size of the allocation.
 146  * @param color Requested virtual color of the allocation.
 147  *
 148  * @return Pointer to the beginning
 149  *
 150  * TODO: make some first_fit/... algorithm, we are now just incrementing
 151  *       the pointer to last area
 152  */
 153 #include <stdio.h>
 154 void *as_get_mappable_page(size_t sz, int color)
 155 {
 156         void *res;
 157         uint64_t asz;
 158         int i;
 159
 160         if (!sz)
 161                 return NULL;
 162
 163         asz = 1 << (fnzb64(sz - 1) + 1);
 164
 165         /* Set heapsize to some meaningful value */
 166         if (maxheapsize == -1)
 167                 set_maxheapsize(MAX_HEAP_SIZE);
 168
 169         /*
 170          * Make sure we allocate from naturally aligned address and a page of
 171          * appropriate color.
 172          */
 173         i = 0;
 174         do {
 175                 if (!last_allocated) {
 176                         last_allocated = (void *) ALIGN_UP((void *) &_heap +
 177                                 maxheapsize, asz);
 178                 } else {
 179                         last_allocated = (void *) ALIGN_UP(((uintptr_t)
 180                                 last_allocated) + (int) (i > 0), asz);
 181                 }
 182         } while ((asz < (1 << (PAGE_COLOR_BITS + PAGE_WIDTH))) &&
 183                 (PAGE_COLOR((uintptr_t) last_allocated) != color) &&
 184                 (++i < (1 << PAGE_COLOR_BITS)));
 185
 186         res = last_allocated;
 187         last_allocated += ALIGN_UP(sz, PAGE_SIZE);
 188
 189         return res;
 190 }
 191
 192 /** @}
 193  */