Changeset db24058 in mainline for uspace/lib/libc/generic


Ignore:
Timestamp:
2009-06-30T15:53:15Z (16 years ago)
Author:
Martin Decky <martin@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
2d11a7d8
Parents:
6db6fd1
Message:

small fixes and coding style changes related to the new memory allocator

Location:
uspace/lib/libc/generic
Files:
1 added
6 edited

Legend:

Unmodified
Added
Removed

  • uspace/lib/libc/generic/as.c

    r6db6fd1 rdb24058  
    3939#include <sys/types.h>
    4040#include <bitops.h>
     41#include <malloc.h>
    4142
    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)
     43/** Last position allocated by as_get_mappable_page */
     44static uintptr_t last_allocated = 0;
    4645
    4746/** Create address space area.
    4847 *
    4948 * @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.
     49 * @param size    Size of the area.
     50 * @param flags   Flags describing type of the area.
    5251 *
    5352 * @return address on success, (void *) -1 otherwise.
     53 *
    5454 */
    5555void *as_area_create(void *address, size_t size, int flags)
    5656{
    57         return (void *) __SYSCALL3(SYS_AS_AREA_CREATE, (sysarg_t ) address,
     57        return (void *) __SYSCALL3(SYS_AS_AREA_CREATE, (sysarg_t) address,
    5858            (sysarg_t) size, (sysarg_t) flags);
    5959}
    … …  
    6262 *
    6363 * @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.
     64 *                area.
     65 * @param size    New requested size of the area.
     66 * @param flags   Currently unused.
    6767 *
    68  * @return Zero on success or a code from @ref errno.h on failure.
     68 * @return zero on success or a code from @ref errno.h on failure.
     69 *
    6970 */
    7071int as_area_resize(void *address, size_t size, int flags)
    7172{
    72         return __SYSCALL3(SYS_AS_AREA_RESIZE, (sysarg_t ) address,
     73        return __SYSCALL3(SYS_AS_AREA_RESIZE, (sysarg_t) address,
    7374            (sysarg_t) size, (sysarg_t) flags);
    7475}
    … …  
    7778 *
    7879 * @param address Virtual address pointing into the address space area being
    79  *      destroyed.
     80 *                destroyed.
    8081 *
    81  * @return Zero on success or a code from @ref errno.h on failure.
     82 * @return zero on success or a code from @ref errno.h on failure.
     83 *
    8284 */
    8385int as_area_destroy(void *address)
    8486{
    85         return __SYSCALL1(SYS_AS_AREA_DESTROY, (sysarg_t ) address);
     87        return __SYSCALL1(SYS_AS_AREA_DESTROY, (sysarg_t) address);
    8688}
    8789
    … …  
    8991 *
    9092 * @param address Virtual address pointing into the address space area being
    91  *      modified.
    92  * @param flags New flags describing type of the area.
     93 *                modified.
     94 * @param flags   New flags describing type of the area.
    9395 *
    94  * @return Zero on success or a code from @ref errno.h on failure.
     96 * @return zero on success or a code from @ref errno.h on failure.
     97 *
    9598 */
    9699int as_area_change_flags(void *address, int flags)
    … …  
    100103}
    101104
    102 static size_t heapsize = 0;
    103 static size_t maxheapsize = (size_t) (-1);
    104 
    105 static void *last_allocated = 0;
    106 
    107 /* Start of heap linker symbol */
    108 extern char _heap;
    109 
    110 /** Sbrk emulation
     105/** Return pointer to some unmapped area, where fits new as_area
    111106 *
    112  * @param incr New area that should be allocated or negative,
    113                if it should be shrinked
    114  * @return Pointer to newly allocated area
     107 * @param size Requested size of the allocation.
     108 *
     109 * @return pointer to the beginning
     110 *
    115111 */
    116 void *sbrk(ssize_t incr)
     112void *as_get_mappable_page(size_t size)
    117113{
    118         int rc;
    119         void *res;
    120        
    121         /* Check for invalid values */
    122         if ((incr < 0) && (((size_t) -incr) > heapsize))
     114        if (size == 0)
    123115                return NULL;
    124116       
    125         /* Check for too large value */
    126         if ((incr > 0) && (incr + heapsize < heapsize))
    127                 return NULL;
    128        
    129         /* Check for too small values */
    130         if ((incr < 0) && (incr + heapsize > heapsize))
    131                 return NULL;
    132        
    133         /* Check for user limit */
    134         if ((maxheapsize != (size_t) (-1)) && (heapsize + incr) > maxheapsize)
    135                 return NULL;
    136        
    137         rc = as_area_resize(&_heap, heapsize + incr, 0);
    138         if (rc != 0)
    139                 return NULL;
    140        
    141         /* Compute start of new area */
    142         res = (void *) &_heap + heapsize;
    143 
    144         heapsize += incr;
    145 
    146         return res;
    147 }
    148 
    149 /** Set maximum heap size and return pointer just after the heap */
    150 void *set_maxheapsize(size_t mhs)
    151 {
    152         maxheapsize = mhs;
    153         /* Return pointer to area not managed by sbrk */
    154         return ((void *) &_heap + maxheapsize);
    155 }
    156 
    157 /** Return pointer to some unmapped area, where fits new as_area
    158  *
    159  * @param sz Requested size of the allocation.
    160  *
    161  * @return Pointer to the beginning
    162  *
    163  * TODO: make some first_fit/... algorithm, we are now just incrementing
    164  *       the pointer to last area
    165  */
    166 void *as_get_mappable_page(size_t sz)
    167 {
    168         void *res;
    169         uint64_t asz;
    170         int i;
    171        
    172         if (!sz)
    173                 return NULL;   
    174 
    175         asz = 1 << (fnzb64(sz - 1) + 1);
    176 
    177         /* Set heapsize to some meaningful value */
    178         if (maxheapsize == (size_t) -1)
    179                 set_maxheapsize(MAX_HEAP_SIZE);
     117        size_t sz = 1 << (fnzb(size - 1) + 1);
     118        if (last_allocated == 0)
     119                last_allocated = get_max_heap_addr();
    180120       
    181121        /*
    182122         * Make sure we allocate from naturally aligned address.
    183123         */
    184         i = 0;
    185         if (!last_allocated) {
    186                 last_allocated = (void *) ALIGN_UP((void *) &_heap +
    187                     maxheapsize, asz);
    188         } else {
    189                 last_allocated = (void *) ALIGN_UP(((uintptr_t)
    190                     last_allocated) + (int) (i > 0), asz);
    191         }
    192 
    193         res = last_allocated;
    194         last_allocated += ALIGN_UP(sz, PAGE_SIZE);
    195 
    196         return res;
     124        uintptr_t res = ALIGN_UP(last_allocated, sz);
     125        last_allocated = res + ALIGN_UP(size, PAGE_SIZE);
     126       
     127        return ((void *) res);
    197128}
    198129

  • uspace/lib/libc/generic/async.c

    r6db6fd1 rdb24058  
    739739 * @return Zero on success or an error code.
    740740 */
    741 int _async_init(void)
     741int __async_init(void)
    742742{
    743743        if (!hash_table_create(&conn_hash_table, CONN_HASH_TABLE_CHAINS, 1,

  • uspace/lib/libc/generic/getopt.c

    r6db6fd1 rdb24058  
    4848int     optopt = '?';           /* character checked for validity */
    4949int     optreset;               /* reset getopt */
    50 char *optarg;           /* argument associated with option */
     50const char *optarg;             /* argument associated with option */
    5151
    5252
    … …  
    163163        const char *options;
    164164{
    165         char *oli;                              /* option letter list index */
     165        const char *oli;                                /* option letter list index */
    166166        int optchar;
    167167
    … …  
    276276                optarg = NULL;
    277277                if (*place)                     /* no white space */
    278                         optarg = *place;
     278                        optarg = place;
    279279                /* XXX: disable test for :: if PC? (GNU doesn't) */
    280280                else if (oli[1] != ':') {       /* arg not optional */
    … …  
    354354        retval = getopt_internal(nargc, (char **)nargv, options);
    355355        if (retval == -2) {
    356                 char *current_argv, *has_equal;
     356                char *current_argv;
     357                const char *has_equal;
    357358                size_t current_argv_len;
    358359                int i, ambiguous, match;

  • uspace/lib/libc/generic/io/io.c

    r6db6fd1 rdb24058  
    9090static LIST_INITIALIZE(files);
    9191
    92 void stdio_init(int filc, fdi_node_t *filv[])
     92void __stdio_init(int filc, fdi_node_t *filv[])
    9393{
    9494        if (filc > 0) {
    … …  
    114114}
    115115
    116 void stdio_done(void)
     116void __stdio_done(void)
    117117{
    118118        link_t *link = files.next;

  • uspace/lib/libc/generic/libc.c

    r6db6fd1 rdb24058  
    5353#include <loader/pcb.h>
    5454
    55 extern char _heap;
    5655extern int main(int argc, char *argv[]);
    57 
    58 int _errno;
    5956
    6057void _exit(int status)
    … …  
    6562void __main(void *pcb_ptr)
    6663{
    67         (void) as_area_create(&_heap, 1, AS_AREA_WRITE | AS_AREA_READ);
    68        
    69         _async_init();
     64        __heap_init();
     65        __async_init();
    7066        fibril_t *fibril = fibril_setup();
    7167        __tcb_set(fibril->tcb);
    … …  
    8076                argc = 0;
    8177                argv = NULL;
    82                 stdio_init(0, NULL);
     78                __stdio_init(0, NULL);
    8379        } else {
    8480                argc = __pcb->argc;
    8581                argv = __pcb->argv;
    86                 stdio_init(__pcb->filc, __pcb->filv);
     82                __stdio_init(__pcb->filc, __pcb->filv);
    8783        }
    8884       
    8985        main(argc, argv);
    90         stdio_done();
     86        __stdio_done();
    9187}
    9288

  • uspace/lib/libc/generic/mman.c

    r6db6fd1 rdb24058  
    3838#include <unistd.h>
    3939
    40 void *mmap(void  *start, size_t length, int prot, int flags, int fd,
     40void *mmap(void *start, size_t length, int prot, int flags, int fd,
    4141    off_t offset)
    4242{
    … …  
    4444                start = as_get_mappable_page(length);
    4545       
    46 //      if (! ((flags & MAP_SHARED) ^ (flags & MAP_PRIVATE)))
     46//      if (!((flags & MAP_SHARED) ^ (flags & MAP_PRIVATE)))
    4747//              return MAP_FAILED;
    48         if (! (flags & MAP_ANONYMOUS))
     48       
     49        if (!(flags & MAP_ANONYMOUS))
    4950                return MAP_FAILED;
    50 
     51       
    5152        return as_area_create(start, length, prot);
    5253}
Note: See TracChangeset for help on using the changeset viewer.