Ignore:
File:
1 edited

Legend:

Unmodified
Added
Removed

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

    r6aeca0d r21799398  
    200200        do { \
    201201                if (!(expr)) {\
    202                         heap_unlock(); \
     202                        futex_up(&malloc_futex); \
    203203                        assert_abort(#expr, __FILE__, __LINE__); \
    204204                } \
    … …  
    210210
    211211#endif /* NDEBUG */
    212 
    213 
    214 #ifdef FUTEX_UPGRADABLE
    215 /** True if the heap may be accessed from multiple threads. */
    216 static bool multithreaded = false;
    217 
    218 /** Makes accesses to the heap thread safe. */
    219 void malloc_enable_multithreaded(void)
    220 {
    221         multithreaded = true;
    222 }
    223 
    224 /** Serializes access to the heap from multiple threads. */
    225 static inline void heap_lock(void)
    226 {
    227         if (multithreaded) {
    228                 futex_down(&malloc_futex);
    229         } else {
    230                 /*
    231                  * Malloc never switches fibrils while the heap is locked.
    232                  * Similarly, it never creates new threads from within the
    233                  * locked region. Therefore, if there are no other threads
    234                  * except this one, the whole operation will complete without
    235                  * any interruptions.
    236                  */
    237         }
    238 }
    239 
    240 /** Serializes access to the heap from multiple threads. */
    241 static inline void heap_unlock(void)
    242 {
    243         if (multithreaded) {
    244                 futex_up(&malloc_futex);
    245         } else {
    246                 /*
    247                  * Malloc never switches fibrils while the heap is locked.
    248                  * Similarly, it never creates new threads from within the
    249                  * locked region. Therefore, if there are no other threads
    250                  * except this one, the whole operation will complete without
    251                  * any interruptions.
    252                  */
    253         }
    254 }
    255 
    256 #else
    257 
    258 /** Makes accesses to the heap thread safe. */
    259 void malloc_enable_multithreaded(void)
    260 {
    261         /* No-op. Already using thread-safe heap locking operations. */
    262 }
    263 
    264 /** Serializes access to the heap from multiple threads. */
    265 static inline void heap_lock(void)
    266 {
    267         futex_down(&malloc_futex);
    268 }
    269 
    270 /** Serializes access to the heap from multiple threads. */
    271 static inline void heap_unlock(void)
    272 {
    273         futex_up(&malloc_futex);
    274 }
    275 #endif
    276 
    277212
    278213/** Initialize a heap block
    … …  
    354289        size_t asize = ALIGN_UP(size, PAGE_SIZE);
    355290        void *astart = as_area_create(AS_AREA_ANY, asize,
    356             AS_AREA_WRITE | AS_AREA_READ | AS_AREA_CACHEABLE, AS_AREA_UNPAGED);
     291            AS_AREA_WRITE | AS_AREA_READ | AS_AREA_CACHEABLE);
    357292        if (astart == AS_MAP_FAILED)
    358293                return false;
    … …  
    850785void *malloc(const size_t size)
    851786{
    852         heap_lock();
     787        futex_down(&malloc_futex);
    853788        void *block = malloc_internal(size, BASE_ALIGN);
    854         heap_unlock();
    855 
     789        futex_up(&malloc_futex);
     790       
    856791        return block;
    857792}
    … …  
    872807        size_t palign =
    873808            1 << (fnzb(max(sizeof(void *), align) - 1) + 1);
    874 
    875         heap_lock();
     809       
     810        futex_down(&malloc_futex);
    876811        void *block = malloc_internal(size, palign);
    877         heap_unlock();
    878 
     812        futex_up(&malloc_futex);
     813       
    879814        return block;
    880815}
    … …  
    893828                return malloc(size);
    894829       
    895         heap_lock();
     830        futex_down(&malloc_futex);
    896831       
    897832        /* Calculate the position of the header. */
    … …  
    950885        }
    951886       
    952         heap_unlock();
     887        futex_up(&malloc_futex);
    953888       
    954889        if (reloc) {
    … …  
    973908                return;
    974909       
    975         heap_lock();
     910        futex_down(&malloc_futex);
    976911       
    977912        /* Calculate the position of the header. */
    … …  
    1018953        heap_shrink(area);
    1019954       
    1020         heap_unlock();
     955        futex_up(&malloc_futex);
    1021956}
    1022957
    1023958void *heap_check(void)
    1024959{
    1025         heap_lock();
     960        futex_down(&malloc_futex);
    1026961       
    1027962        if (first_heap_area == NULL) {
    1028                 heap_unlock();
     963                futex_up(&malloc_futex);
    1029964                return (void *) -1;
    1030965        }
    … …  
    1040975                    (((uintptr_t) area->start % PAGE_SIZE) != 0) ||
    1041976                    (((uintptr_t) area->end % PAGE_SIZE) != 0)) {
    1042                         heap_unlock();
     977                        futex_up(&malloc_futex);
    1043978                        return (void *) area;
    1044979                }
    … …  
    1051986                        /* Check heap block consistency */
    1052987                        if (head->magic != HEAP_BLOCK_HEAD_MAGIC) {
    1053                                 heap_unlock();
     988                                futex_up(&malloc_futex);
    1054989                                return (void *) head;
    1055990                        }
    … …  
    1059994                        if ((foot->magic != HEAP_BLOCK_FOOT_MAGIC) ||
    1060995                            (head->size != foot->size)) {
    1061                                 heap_unlock();
     996                                futex_up(&malloc_futex);
    1062997                                return (void *) foot;
    1063998                        }
    … …  
    10651000        }
    10661001       
    1067         heap_unlock();
     1002        futex_up(&malloc_futex);
    10681003       
    10691004        return NULL;
Note: See TracChangeset for help on using the changeset viewer.