Changeset 544a2e4 in mainline for uspace/lib/c/generic


Ignore:
Timestamp:
2011-05-30T21:37:43Z (15 years ago)
Author:
Jakub Jermar <jakub@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
7b712b60
Parents:
18ba2e4f (diff), 0743493a (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.
Message:

Merge mainline changes.

Location:
uspace/lib/c/generic
Files:
8 added
14 edited

Legend:

Unmodified
Added
Removed

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

    r18ba2e4f r544a2e4  
    5151 *
    5252 */
    53 void *as_area_create(void *address, size_t size, int flags)
     53void *as_area_create(void *address, size_t size, unsigned int flags)
    5454{
    5555        return (void *) __SYSCALL3(SYS_AS_AREA_CREATE, (sysarg_t) address,
    … …  
    6767 *
    6868 */
    69 int as_area_resize(void *address, size_t size, int flags)
     69int as_area_resize(void *address, size_t size, unsigned int flags)
    7070{
    7171        return __SYSCALL3(SYS_AS_AREA_RESIZE, (sysarg_t) address,
    … …  
    9595 *
    9696 */
    97 int as_area_change_flags(void *address, int flags)
     97int as_area_change_flags(void *address, unsigned int flags)
    9898{
    9999        return __SYSCALL2(SYS_AS_AREA_CHANGE_FLAGS, (sysarg_t) address,

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

    r18ba2e4f r544a2e4  
    102102#include <arch/barrier.h>
    103103#include <bool.h>
     104#include <stdlib.h>
     105#include <malloc.h>
    104106#include "private/async.h"
    105107

  • uspace/lib/c/generic/async_sess.c

    r18ba2e4f r544a2e4  
    105105#include <errno.h>
    106106#include <assert.h>
     107#include <async.h>
    107108#include "private/async_sess.h"
    108109

  • uspace/lib/c/generic/errno.c

    r18ba2e4f r544a2e4  
    3636#include <fibril.h>
    3737
    38 int _errno;
     38static fibril_local int fibril_errno;
     39
     40int *__errno(void)
     41{
     42        return &fibril_errno;
     43}
    3944
    4045/** @}

  • uspace/lib/c/generic/event.c

    r18ba2e4f r544a2e4  
    4141#include <kernel/ipc/event_types.h>
    4242
    43 /** Subscribe for event notifications.
     43/** Subscribe event notifications.
    4444 *
    45  * @param evno   Event number.
    46  * @param method Use this method for notifying me.
     45 * @param evno    Event type to subscribe.
     46 * @param imethod Use this interface and method for notifying me.
    4747 *
    4848 * @return Value returned by the kernel.
     49 *
    4950 */
    50 int event_subscribe(event_type_t e, sysarg_t method)
     51int event_subscribe(event_type_t evno, sysarg_t imethod)
    5152{
    52         return __SYSCALL2(SYS_EVENT_SUBSCRIBE, (sysarg_t) e, (sysarg_t) method);
     53        return __SYSCALL2(SYS_EVENT_SUBSCRIBE, (sysarg_t) evno,
     54            (sysarg_t) imethod);
     55}
     56
     57/** Unmask event notifications.
     58 *
     59 * @param evno Event type to unmask.
     60 *
     61 * @return Value returned by the kernel.
     62 *
     63 */
     64int event_unmask(event_type_t evno)
     65{
     66        return __SYSCALL1(SYS_EVENT_UNMASK, (sysarg_t) evno);
    5367}
    5468

  • uspace/lib/c/generic/fibril_synch.c

    r18ba2e4f r544a2e4  
    4343#include <stacktrace.h>
    4444#include <stdlib.h>
     45#include <stdio.h>
    4546#include "private/async.h"
    4647

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

    r18ba2e4f r544a2e4  
    173173                }
    174174                *flags = (O_APPEND | O_CREAT) | (plus ? O_RDWR : O_WRONLY);
     175                break;
    175176        default:
    176177                errno = EINVAL;

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

    r18ba2e4f r544a2e4  
    3838#include <sys/types.h>
    3939#include <unistd.h>
     40#include <errno.h>
    4041#include <io/klog.h>
     42#include <io/printf_core.h>
    4143
    4244size_t klog_write(const void *buf, size_t size)
    … …  
    5557}
    5658
     59/** Print formatted text to klog.
     60 *
     61 * @param fmt Format string
     62 *
     63 * \see For more details about format string see printf_core.
     64 *
     65 */
     66int klog_printf(const char *fmt, ...)
     67{
     68        va_list args;
     69        va_start(args, fmt);
     70       
     71        int ret = klog_vprintf(fmt, args);
     72       
     73        va_end(args);
     74       
     75        return ret;
     76}
     77
     78static int klog_vprintf_str_write(const char *str, size_t size, void *data)
     79{
     80        size_t wr = klog_write(str, size);
     81        return str_nlength(str, wr);
     82}
     83
     84static int klog_vprintf_wstr_write(const wchar_t *str, size_t size, void *data)
     85{
     86        size_t offset = 0;
     87        size_t chars = 0;
     88       
     89        while (offset < size) {
     90                char buf[STR_BOUNDS(1)];
     91                size_t sz = 0;
     92               
     93                if (chr_encode(str[chars], buf, &sz, STR_BOUNDS(1)) == EOK)
     94                        klog_write(buf, sz);
     95               
     96                chars++;
     97                offset += sizeof(wchar_t);
     98        }
     99       
     100        return chars;
     101}
     102
     103/** Print formatted text to klog.
     104 *
     105 * @param fmt Format string
     106 * @param ap  Format parameters
     107 *
     108 * \see For more details about format string see printf_core.
     109 *
     110 */
     111int klog_vprintf(const char *fmt, va_list ap)
     112{
     113        printf_spec_t ps = {
     114                klog_vprintf_str_write,
     115                klog_vprintf_wstr_write,
     116                NULL
     117        };
     118       
     119        return printf_core(fmt, &ps, ap);
     120}
     121
    57122/** @}
    58123 */

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

    r18ba2e4f r544a2e4  
    9696/** Print formatted text to stdout.
    9797 *
    98  * @param file Output stream
    99  * @param fmt  Format string
    100  * @param ap   Format parameters
     98 * @param fmt Format string
     99 * @param ap  Format parameters
    101100 *
    102101 * \see For more details about format string see printf_core.

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

    r18ba2e4f r544a2e4  
    5353#include "private/io.h"
    5454
     55#ifdef CONFIG_RTLD
     56#include <rtld/rtld.h>
     57#endif
     58
    5559static bool env_setup = false;
    5660
    … …  
    7781        char **argv;
    7882       
     83#ifdef __IN_SHARED_LIBC__
     84        if (__pcb != NULL && __pcb->rtld_runtime != NULL) {
     85                runtime_env = (runtime_env_t *) __pcb->rtld_runtime;
     86        }
     87#endif
    7988        /*
    8089         * Get command line arguments and initialize

  • uspace/lib/c/generic/malloc.c

    r18ba2e4f r544a2e4  
    4444#include <mem.h>
    4545#include <futex.h>
     46#include <stdlib.h>
    4647#include <adt/gcdlcm.h>
    4748#include "private/malloc.h"
    … …  
    6364 */
    6465#define BASE_ALIGN  16
     66
     67/** Heap shrink granularity
     68 *
     69 * Try not to pump and stress the heap to much
     70 * by shrinking and enlarging it too often.
     71 * A heap area won't shrunk if it the released
     72 * free block is smaller than this constant.
     73 *
     74 */
     75#define SHRINK_GRANULARITY  (64 * PAGE_SIZE)
    6576
    6677/** Overhead of each heap block. */
    … …  
    6879        (sizeof(heap_block_head_t) + sizeof(heap_block_foot_t))
    6980
     81/** Overhead of each area. */
     82#define AREA_OVERHEAD(size) \
     83        (ALIGN_UP(size + sizeof(heap_area_t), BASE_ALIGN))
     84
    7085/** Calculate real size of a heap block.
    7186 *
    … …  
    85100 *
    86101 */
    87 #define AREA_FIRST_BLOCK(area) \
     102#define AREA_FIRST_BLOCK_HEAD(area) \
    88103        (ALIGN_UP(((uintptr_t) (area)) + sizeof(heap_area_t), BASE_ALIGN))
     104
     105/** Get last block in heap area.
     106 *
     107 */
     108#define AREA_LAST_BLOCK_FOOT(area) \
     109        (((uintptr_t) (area)->end) - sizeof(heap_block_foot_t))
     110
     111/** Get header in heap block.
     112 *
     113 */
     114#define BLOCK_HEAD(foot) \
     115        ((heap_block_head_t *) \
     116            (((uintptr_t) (foot)) + sizeof(heap_block_foot_t) - (foot)->size))
    89117
    90118/** Get footer in heap block.
    … …  
    93121#define BLOCK_FOOT(head) \
    94122        ((heap_block_foot_t *) \
    95             (((uintptr_t) head) + head->size - sizeof(heap_block_foot_t)))
     123            (((uintptr_t) (head)) + (head)->size - sizeof(heap_block_foot_t)))
    96124
    97125/** Heap area.
    … …  
    114142        void *end;
    115143       
     144        /** Previous heap area */
     145        struct heap_area *prev;
     146       
    116147        /** Next heap area */
    117148        struct heap_area *next;
    … …  
    156187
    157188/** Next heap block to examine (next fit algorithm) */
    158 static heap_block_head_t *next = NULL;
     189static heap_block_head_t *next_fit = NULL;
    159190
    160191/** Futex for thread-safe heap manipulation */
    161192static futex_t malloc_futex = FUTEX_INITIALIZER;
     193
     194#ifndef NDEBUG
     195
     196#define malloc_assert(expr) \
     197        do { \
     198                if (!(expr)) {\
     199                        futex_up(&malloc_futex); \
     200                        assert_abort(#expr, __FILE__, __LINE__); \
     201                } \
     202        } while (0)
     203
     204#else /* NDEBUG */
     205
     206#define malloc_assert(expr)
     207
     208#endif /* NDEBUG */
    162209
    163210/** Initialize a heap block
    … …  
    201248        heap_block_head_t *head = (heap_block_head_t *) addr;
    202249       
    203         assert(head->magic == HEAP_BLOCK_HEAD_MAGIC);
     250        malloc_assert(head->magic == HEAP_BLOCK_HEAD_MAGIC);
    204251       
    205252        heap_block_foot_t *foot = BLOCK_FOOT(head);
    206253       
    207         assert(foot->magic == HEAP_BLOCK_FOOT_MAGIC);
    208         assert(head->size == foot->size);
     254        malloc_assert(foot->magic == HEAP_BLOCK_FOOT_MAGIC);
     255        malloc_assert(head->size == foot->size);
    209256}
    210257
    211258/** Check a heap area structure
    212259 *
     260 * Should be called only inside the critical section.
     261 *
    213262 * @param addr Address of the heap area.
    214263 *
    … …  
    218267        heap_area_t *area = (heap_area_t *) addr;
    219268       
    220         assert(area->magic == HEAP_AREA_MAGIC);
    221         assert(area->start < area->end);
    222         assert(((uintptr_t) area->start % PAGE_SIZE) == 0);
    223         assert(((uintptr_t) area->end % PAGE_SIZE) == 0);
     269        malloc_assert(area->magic == HEAP_AREA_MAGIC);
     270        malloc_assert(addr == area->start);
     271        malloc_assert(area->start < area->end);
     272        malloc_assert(((uintptr_t) area->start % PAGE_SIZE) == 0);
     273        malloc_assert(((uintptr_t) area->end % PAGE_SIZE) == 0);
    224274}
    225275
    226276/** Create new heap area
    227277 *
    228  * @param start Preffered starting address of the new area.
    229  * @param size  Size of the area.
     278 * Should be called only inside the critical section.
     279 *
     280 * @param size Size of the area.
    230281 *
    231282 */
    … …  
    247298       
    248299        area->start = astart;
    249         area->end = (void *)
    250             ALIGN_DOWN((uintptr_t) astart + asize, BASE_ALIGN);
     300        area->end = (void *) ((uintptr_t) astart + asize);
     301        area->prev = NULL;
    251302        area->next = NULL;
    252303        area->magic = HEAP_AREA_MAGIC;
    253304       
    254         void *block = (void *) AREA_FIRST_BLOCK(area);
     305        void *block = (void *) AREA_FIRST_BLOCK_HEAD(area);
    255306        size_t bsize = (size_t) (area->end - block);
    256307       
    … …  
    261312                last_heap_area = area;
    262313        } else {
     314                area->prev = last_heap_area;
    263315                last_heap_area->next = area;
    264316                last_heap_area = area;
    … …  
    270322/** Try to enlarge a heap area
    271323 *
     324 * Should be called only inside the critical section.
     325 *
    272326 * @param area Heap area to grow.
    273  * @param size Gross size of item to allocate (bytes).
     327 * @param size Gross size to grow (bytes).
     328 *
     329 * @return True if successful.
    274330 *
    275331 */
    … …  
    281337        area_check(area);
    282338       
    283         size_t asize = ALIGN_UP((size_t) (area->end - area->start) + size,
    284             PAGE_SIZE);
    285        
    286339        /* New heap area size */
    287         void *end = (void *)
    288             ALIGN_DOWN((uintptr_t) area->start + asize, BASE_ALIGN);
     340        size_t gross_size = (size_t) (area->end - area->start) + size;
     341        size_t asize = ALIGN_UP(gross_size, PAGE_SIZE);
     342        void *end = (void *) ((uintptr_t) area->start + asize);
    289343       
    290344        /* Check for overflow */
    … …  
    298352       
    299353        /* Add new free block */
    300         block_init(area->end, (size_t) (end - area->end), true, area);
     354        size_t net_size = (size_t) (end - area->end);
     355        if (net_size > 0)
     356                block_init(area->end, net_size, true, area);
    301357       
    302358        /* Update heap area parameters */
    … …  
    308364/** Try to enlarge any of the heap areas
    309365 *
     366 * Should be called only inside the critical section.
     367 *
    310368 * @param size Gross size of item to allocate (bytes).
    311369 *
    … …  
    317375       
    318376        /* First try to enlarge some existing area */
    319         heap_area_t *area;
    320         for (area = first_heap_area; area != NULL; area = area->next) {
     377        for (heap_area_t *area = first_heap_area; area != NULL;
     378            area = area->next) {
    321379                if (area_grow(area, size))
    322380                        return true;
    … …  
    324382       
    325383        /* Eventually try to create a new area */
    326         return area_create(AREA_FIRST_BLOCK(size));
    327 }
    328 
    329 /** Try to shrink heap space
    330  *
     384        return area_create(AREA_OVERHEAD(size));
     385}
     386
     387/** Try to shrink heap
     388 *
     389 * Should be called only inside the critical section.
    331390 * In all cases the next pointer is reset.
    332391 *
    333  */
    334 static void heap_shrink(void)
    335 {
    336         next = NULL;
     392 * @param area Last modified heap area.
     393 *
     394 */
     395static void heap_shrink(heap_area_t *area)
     396{
     397        area_check(area);
     398       
     399        heap_block_foot_t *last_foot =
     400            (heap_block_foot_t *) AREA_LAST_BLOCK_FOOT(area);
     401        heap_block_head_t *last_head = BLOCK_HEAD(last_foot);
     402       
     403        block_check((void *) last_head);
     404        malloc_assert(last_head->area == area);
     405       
     406        if (last_head->free) {
     407                /*
     408                 * The last block of the heap area is
     409                 * unused. The area might be potentially
     410                 * shrunk.
     411                 */
     412               
     413                heap_block_head_t *first_head =
     414                    (heap_block_head_t *) AREA_FIRST_BLOCK_HEAD(area);
     415               
     416                block_check((void *) first_head);
     417                malloc_assert(first_head->area == area);
     418               
     419                size_t shrink_size = ALIGN_DOWN(last_head->size, PAGE_SIZE);
     420               
     421                if (first_head == last_head) {
     422                        /*
     423                         * The entire heap area consists of a single
     424                         * free heap block. This means we can get rid
     425                         * of it entirely.
     426                         */
     427                       
     428                        heap_area_t *prev = area->prev;
     429                        heap_area_t *next = area->next;
     430                       
     431                        if (prev != NULL) {
     432                                area_check(prev);
     433                                prev->next = next;
     434                        } else
     435                                first_heap_area = next;
     436                       
     437                        if (next != NULL) {
     438                                area_check(next);
     439                                next->prev = prev;
     440                        } else
     441                                last_heap_area = prev;
     442                       
     443                        as_area_destroy(area->start);
     444                } else if (shrink_size >= SHRINK_GRANULARITY) {
     445                        /*
     446                         * Make sure that we always shrink the area
     447                         * by a multiple of page size and update
     448                         * the block layout accordingly.
     449                         */
     450                       
     451                        size_t asize = (size_t) (area->end - area->start) - shrink_size;
     452                        void *end = (void *) ((uintptr_t) area->start + asize);
     453                       
     454                        /* Resize the address space area */
     455                        int ret = as_area_resize(area->start, asize, 0);
     456                        if (ret != EOK)
     457                                abort();
     458                       
     459                        /* Update heap area parameters */
     460                        area->end = end;
     461                        size_t excess = ((size_t) area->end) - ((size_t) last_head);
     462                       
     463                        if (excess > 0) {
     464                                if (excess >= STRUCT_OVERHEAD) {
     465                                        /*
     466                                         * The previous block cannot be free and there
     467                                         * is enough free space left in the area to
     468                                         * create a new free block.
     469                                         */
     470                                        block_init((void *) last_head, excess, true, area);
     471                                } else {
     472                                        /*
     473                                         * The excess is small. Therefore just enlarge
     474                                         * the previous block.
     475                                         */
     476                                        heap_block_foot_t *prev_foot = (heap_block_foot_t *)
     477                                            (((uintptr_t) last_head) - sizeof(heap_block_foot_t));
     478                                        heap_block_head_t *prev_head = BLOCK_HEAD(prev_foot);
     479                                       
     480                                        block_check((void *) prev_head);
     481                                       
     482                                        block_init(prev_head, prev_head->size + excess,
     483                                            prev_head->free, area);
     484                                }
     485                        }
     486                }
     487        }
     488       
     489        next_fit = NULL;
    337490}
    338491
    … …  
    361514static void split_mark(heap_block_head_t *cur, const size_t size)
    362515{
    363         assert(cur->size >= size);
     516        malloc_assert(cur->size >= size);
    364517       
    365518        /* See if we should split the block. */
    … …  
    397550{
    398551        area_check((void *) area);
    399         assert((void *) first_block >= (void *) AREA_FIRST_BLOCK(area));
    400         assert((void *) first_block < area->end);
    401        
    402         heap_block_head_t *cur;
    403         for (cur = first_block; (void *) cur < area->end;
     552        malloc_assert((void *) first_block >= (void *) AREA_FIRST_BLOCK_HEAD(area));
     553        malloc_assert((void *) first_block < area->end);
     554       
     555        for (heap_block_head_t *cur = first_block; (void *) cur < area->end;
    404556            cur = (heap_block_head_t *) (((void *) cur) + cur->size)) {
    405557                block_check(cur);
    … …  
    424576                                split_mark(cur, real_size);
    425577                               
    426                                 next = cur;
     578                                next_fit = cur;
    427579                                return addr;
    428580                        } else {
    … …  
    435587                                         * data in (including alignment).
    436588                                         */
    437                                         if ((void *) cur > (void *) AREA_FIRST_BLOCK(area)) {
     589                                        if ((void *) cur > (void *) AREA_FIRST_BLOCK_HEAD(area)) {
    438590                                                /*
    439591                                                 * There is a block before the current block.
    … …  
    476628                                                split_mark(next_head, real_size);
    477629                                               
    478                                                 next = next_head;
     630                                                next_fit = next_head;
    479631                                                return aligned;
    480632                                        } else {
    … …  
    495647                                                        size_t reduced_size = cur->size - excess;
    496648                                                        cur = (heap_block_head_t *)
    497                                                             (AREA_FIRST_BLOCK(area) + excess);
     649                                                            (AREA_FIRST_BLOCK_HEAD(area) + excess);
    498650                                                       
    499                                                         block_init((void *) AREA_FIRST_BLOCK(area), excess,
    500                                                             true, area);
     651                                                        block_init((void *) AREA_FIRST_BLOCK_HEAD(area),
     652                                                            excess, true, area);
    501653                                                        block_init(cur, reduced_size, true, area);
    502654                                                        split_mark(cur, real_size);
    503655                                                       
    504                                                         next = cur;
     656                                                        next_fit = cur;
    505657                                                        return aligned;
    506658                                                }
    … …  
    526678static void *malloc_internal(const size_t size, const size_t align)
    527679{
    528         assert(first_heap_area != NULL);
     680        malloc_assert(first_heap_area != NULL);
    529681       
    530682        if (align == 0)
    … …  
    540692       
    541693        /* Try the next fit approach */
    542         split = next;
     694        split = next_fit;
    543695       
    544696        if (split != NULL) {
    … …  
    551703       
    552704        /* Search the entire heap */
    553         heap_area_t *area;
    554         for (area = first_heap_area; area != NULL; area = area->next) {
     705        for (heap_area_t *area = first_heap_area; area != NULL;
     706            area = area->next) {
    555707                heap_block_head_t *first = (heap_block_head_t *)
    556                     AREA_FIRST_BLOCK(area);
     708                    AREA_FIRST_BLOCK_HEAD(area);
    557709               
    558710                void *addr = malloc_area(area, first, split, real_size,
    … …  
    651803       
    652804        block_check(head);
    653         assert(!head->free);
     805        malloc_assert(!head->free);
    654806       
    655807        heap_area_t *area = head->area;
    656808       
    657809        area_check(area);
    658         assert((void *) head >= (void *) AREA_FIRST_BLOCK(area));
    659         assert((void *) head < area->end);
     810        malloc_assert((void *) head >= (void *) AREA_FIRST_BLOCK_HEAD(area));
     811        malloc_assert((void *) head < area->end);
    660812       
    661813        void *ptr = NULL;
    … …  
    674826                        block_init((void *) head + real_size,
    675827                            orig_size - real_size, true, area);
    676                         heap_shrink();
     828                        heap_shrink(area);
    677829                }
    678830               
    … …  
    696848                       
    697849                        ptr = ((void *) head) + sizeof(heap_block_head_t);
    698                         next = NULL;
     850                        next_fit = NULL;
    699851                } else
    700852                        reloc = true;
    … …  
    728880       
    729881        block_check(head);
    730         assert(!head->free);
     882        malloc_assert(!head->free);
    731883       
    732884        heap_area_t *area = head->area;
    733885       
    734886        area_check(area);
    735         assert((void *) head >= (void *) AREA_FIRST_BLOCK(area));
    736         assert((void *) head < area->end);
     887        malloc_assert((void *) head >= (void *) AREA_FIRST_BLOCK_HEAD(area));
     888        malloc_assert((void *) head < area->end);
    737889       
    738890        /* Mark the block itself as free. */
    … …  
    750902       
    751903        /* Look at the previous block. If it is free, merge the two. */
    752         if ((void *) head > (void *) AREA_FIRST_BLOCK(area)) {
     904        if ((void *) head > (void *) AREA_FIRST_BLOCK_HEAD(area)) {
    753905                heap_block_foot_t *prev_foot =
    754906                    (heap_block_foot_t *) (((void *) head) - sizeof(heap_block_foot_t));
    … …  
    764916        }
    765917       
    766         heap_shrink();
     918        heap_shrink(area);
    767919       
    768920        futex_up(&malloc_futex);
    769921}
    770922
     923void *heap_check(void)
     924{
     925        futex_down(&malloc_futex);
     926       
     927        if (first_heap_area == NULL) {
     928                futex_up(&malloc_futex);
     929                return (void *) -1;
     930        }
     931       
     932        /* Walk all heap areas */
     933        for (heap_area_t *area = first_heap_area; area != NULL;
     934            area = area->next) {
     935               
     936                /* Check heap area consistency */
     937                if ((area->magic != HEAP_AREA_MAGIC) ||
     938                    ((void *) area != area->start) ||
     939                    (area->start >= area->end) ||
     940                    (((uintptr_t) area->start % PAGE_SIZE) != 0) ||
     941                    (((uintptr_t) area->end % PAGE_SIZE) != 0)) {
     942                        futex_up(&malloc_futex);
     943                        return (void *) area;
     944                }
     945               
     946                /* Walk all heap blocks */
     947                for (heap_block_head_t *head = (heap_block_head_t *)
     948                    AREA_FIRST_BLOCK_HEAD(area); (void *) head < area->end;
     949                    head = (heap_block_head_t *) (((void *) head) + head->size)) {
     950                       
     951                        /* Check heap block consistency */
     952                        if (head->magic != HEAP_BLOCK_HEAD_MAGIC) {
     953                                futex_up(&malloc_futex);
     954                                return (void *) head;
     955                        }
     956                       
     957                        heap_block_foot_t *foot = BLOCK_FOOT(head);
     958                       
     959                        if ((foot->magic != HEAP_BLOCK_FOOT_MAGIC) ||
     960                            (head->size != foot->size)) {
     961                                futex_up(&malloc_futex);
     962                                return (void *) foot;
     963                        }
     964                }
     965        }
     966       
     967        futex_up(&malloc_futex);
     968       
     969        return NULL;
     970}
     971
    771972/** @}
    772973 */

  • uspace/lib/c/generic/stacktrace.c

    r18ba2e4f r544a2e4  
    6161        stacktrace_prepare();
    6262        stacktrace_print_fp_pc(stacktrace_fp_get(), stacktrace_pc_get());
     63       
    6364        /*
    6465         * Prevent the tail call optimization of the previous call by
    6566         * making it a non-tail call.
    6667         */
    67         (void) stacktrace_fp_get();
     68       
     69        printf("-- end of stack trace --\n");
    6870}
    6971

  • uspace/lib/c/generic/str.c

    r18ba2e4f r544a2e4  
    12151215void order_suffix(const uint64_t val, uint64_t *rv, char *suffix)
    12161216{
    1217         if (val > 10000000000000000000ULL) {
    1218                 *rv = val / 1000000000000000000ULL;
     1217        if (val > UINT64_C(10000000000000000000)) {
     1218                *rv = val / UINT64_C(1000000000000000000);
    12191219                *suffix = 'Z';
    1220         } else if (val > 1000000000000000000ULL) {
    1221                 *rv = val / 1000000000000000ULL;
     1220        } else if (val > UINT64_C(1000000000000000000)) {
     1221                *rv = val / UINT64_C(1000000000000000);
    12221222                *suffix = 'E';
    1223         } else if (val > 1000000000000000ULL) {
    1224                 *rv = val / 1000000000000ULL;
     1223        } else if (val > UINT64_C(1000000000000000)) {
     1224                *rv = val / UINT64_C(1000000000000);
    12251225                *suffix = 'T';
    1226         } else if (val > 1000000000000ULL) {
    1227                 *rv = val / 1000000000ULL;
     1226        } else if (val > UINT64_C(1000000000000)) {
     1227                *rv = val / UINT64_C(1000000000);
    12281228                *suffix = 'G';
    1229         } else if (val > 1000000000ULL) {
    1230                 *rv = val / 1000000ULL;
     1229        } else if (val > UINT64_C(1000000000)) {
     1230                *rv = val / UINT64_C(1000000);
    12311231                *suffix = 'M';
    1232         } else if (val > 1000000ULL) {
    1233                 *rv = val / 1000ULL;
     1232        } else if (val > UINT64_C(1000000)) {
     1233                *rv = val / UINT64_C(1000);
    12341234                *suffix = 'k';
    12351235        } else {
    … …  
    12391239}
    12401240
     1241void bin_order_suffix(const uint64_t val, uint64_t *rv, const char **suffix,
     1242    bool fixed)
     1243{
     1244        if (val > UINT64_C(1152921504606846976)) {
     1245                *rv = val / UINT64_C(1125899906842624);
     1246                *suffix = "EiB";
     1247        } else if (val > UINT64_C(1125899906842624)) {
     1248                *rv = val / UINT64_C(1099511627776);
     1249                *suffix = "TiB";
     1250        } else if (val > UINT64_C(1099511627776)) {
     1251                *rv = val / UINT64_C(1073741824);
     1252                *suffix = "GiB";
     1253        } else if (val > UINT64_C(1073741824)) {
     1254                *rv = val / UINT64_C(1048576);
     1255                *suffix = "MiB";
     1256        } else if (val > UINT64_C(1048576)) {
     1257                *rv = val / UINT64_C(1024);
     1258                *suffix = "KiB";
     1259        } else {
     1260                *rv = val;
     1261                if (fixed)
     1262                        *suffix = "B  ";
     1263                else
     1264                        *suffix = "B";
     1265        }
     1266}
     1267
    12411268/** @}
    12421269 */

  • uspace/lib/c/generic/thread.c

    r18ba2e4f r544a2e4  
    4444
    4545#ifndef THREAD_INITIAL_STACK_PAGES_NO
    46 #define THREAD_INITIAL_STACK_PAGES_NO 1
     46#define THREAD_INITIAL_STACK_PAGES_NO   2
    4747#endif
    4848
Note: See TracChangeset for help on using the changeset viewer.