Changeset a35b458 in mainline for uspace/lib/c/generic/malloc.c

Timestamp:

2018-03-02T20:10:49Z (7 years ago)

Author:

Jiří Zárevúcky <zarevucky.jiri@…>

Branches:

lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export

Children:

f1380b7

Parents:

3061bc1

git-author:

Jiří Zárevúcky <zarevucky.jiri@…> (2018-02-28 17:38:31)

git-committer:

Jiří Zárevúcky <zarevucky.jiri@…> (2018-03-02 20:10:49)

Message:

style: Remove trailing whitespace on _all_ lines, including empty ones, for particular file types.

Command used: tools/srepl '\s\+$' '' -- *.c *.h *.py *.sh *.s *.S *.ag

Currently, whitespace on empty lines is very inconsistent.
There are two basic choices: Either remove the whitespace, or keep empty lines
indented to the level of surrounding code. The former is AFAICT more common,
and also much easier to do automatically.

Alternatively, we could write script for automatic indentation, and use that
instead. However, if such a script exists, it's possible to use the indented
style locally, by having the editor apply relevant conversions on load/save,
without affecting remote repository. IMO, it makes more sense to adopt
the simpler rule.

File:

• uspace/lib/c/generic/malloc.c (modified) (48 diffs)

uspace/lib/c/generic/malloc.c

@@ -142 +142 @@
          */
         void *start;
-        
+
         /** End of the heap area (aligned on page boundary) */
         void *end;
-        
+
         /** Previous heap area */
         struct heap_area *prev;
-        
+
         /** Next heap area */
         struct heap_area *next;
-        
+
         /** A magic value */
         uint32_t magic;
@@ -162 +162 @@
         /* Size of the block (including header and footer) */
         size_t size;
-        
+
         /* Indication of a free block */
         bool free;
-        
+
         /** Heap area this block belongs to */
         heap_area_t *area;
-        
+
         /* A magic value to detect overwrite of heap header */
         uint32_t magic;
@@ -179 +179 @@
         /* Size of the block (including header and footer) */
         size_t size;
-        
+
         /* A magic value to detect overwrite of heap footer */
         uint32_t magic;
@@ -277 +277 @@
         /* Calculate the position of the header and the footer */
         heap_block_head_t *head = (heap_block_head_t *) addr;
-        
+
         head->size = size;
         head->free = free;
         head->area = area;
         head->magic = HEAP_BLOCK_HEAD_MAGIC;
-        
+
         heap_block_foot_t *foot = BLOCK_FOOT(head);
-        
+
         foot->size = size;
         foot->magic = HEAP_BLOCK_FOOT_MAGIC;
@@ -301 +301 @@
 {
         heap_block_head_t *head = (heap_block_head_t *) addr;
-        
+
         malloc_assert(head->magic == HEAP_BLOCK_HEAD_MAGIC);
-        
+
         heap_block_foot_t *foot = BLOCK_FOOT(head);
-        
+
         malloc_assert(foot->magic == HEAP_BLOCK_FOOT_MAGIC);
         malloc_assert(head->size == foot->size);
@@ -320 +320 @@
 {
         heap_area_t *area = (heap_area_t *) addr;
-        
+
         malloc_assert(area->magic == HEAP_AREA_MAGIC);
         malloc_assert(addr == area->start);
@@ -343 +343 @@
         if (astart == AS_MAP_FAILED)
                 return false;
-        
+
         heap_area_t *area = (heap_area_t *) astart;
-        
+
         area->start = astart;
         area->end = (void *) ((uintptr_t) astart + asize);
@@ -351 +351 @@
         area->next = NULL;
         area->magic = HEAP_AREA_MAGIC;
-        
+
         void *block = (void *) AREA_FIRST_BLOCK_HEAD(area);
         size_t bsize = (size_t) (area->end - block);
-        
+
         block_init(block, bsize, true, area);
-        
+
         if (last_heap_area == NULL) {
                 first_heap_area = area;
@@ -365 +365 @@
                 last_heap_area = area;
         }
-        
+
         return true;
 }
@@ -383 +383 @@
         if (size == 0)
                 return true;
-        
+
         area_check(area);
-        
+
         /* New heap area size */
         size_t gross_size = (size_t) (area->end - area->start) + size;
         size_t asize = ALIGN_UP(gross_size, PAGE_SIZE);
         void *end = (void *) ((uintptr_t) area->start + asize);
-        
+
         /* Check for overflow */
         if (end < area->start)
                 return false;
-        
+
         /* Resize the address space area */
         errno_t ret = as_area_resize(area->start, asize, 0);
         if (ret != EOK)
                 return false;
-        
+
         heap_block_head_t *last_head =
             (heap_block_head_t *) AREA_LAST_BLOCK_HEAD(area);
-        
+
         if (last_head->free) {
                 /* Add the new space to the last block. */
@@ -414 +414 @@
                         block_init(area->end, net_size, true, area);
         }
-        
+
         /* Update heap area parameters */
         area->end = end;
-        
+
         return true;
 }
@@ -432 +432 @@
 {
         area_check(area);
-        
+
         heap_block_foot_t *last_foot =
             (heap_block_foot_t *) AREA_LAST_BLOCK_FOOT(area);
         heap_block_head_t *last_head = BLOCK_HEAD(last_foot);
-        
+
         block_check((void *) last_head);
         malloc_assert(last_head->area == area);
-        
+
         if (last_head->free) {
                 /*
@@ -446 +446 @@
                  * shrunk.
                  */
-                
+
                 heap_block_head_t *first_head =
                     (heap_block_head_t *) AREA_FIRST_BLOCK_HEAD(area);
-                
+
                 block_check((void *) first_head);
                 malloc_assert(first_head->area == area);
-                
+
                 size_t shrink_size = ALIGN_DOWN(last_head->size, PAGE_SIZE);
-                
+
                 if (first_head == last_head) {
                         /*
@@ -461 +461 @@
                          * of it entirely.
                          */
-                        
+
                         heap_area_t *prev = area->prev;
                         heap_area_t *next = area->next;
-                        
+
                         if (prev != NULL) {
                                 area_check(prev);
@@ -470 +470 @@
                         } else
                                 first_heap_area = next;
-                        
+
                         if (next != NULL) {
                                 area_check(next);
@@ -476 +476 @@
                         } else
                                 last_heap_area = prev;
-                        
+
                         as_area_destroy(area->start);
                 } else if (shrink_size >= SHRINK_GRANULARITY) {
@@ -484 +484 @@
                          * the block layout accordingly.
                          */
-                        
+
                         size_t asize = (size_t) (area->end - area->start) - shrink_size;
                         void *end = (void *) ((uintptr_t) area->start + asize);
-                        
+
                         /* Resize the address space area */
                         errno_t ret = as_area_resize(area->start, asize, 0);
                         if (ret != EOK)
                                 abort();
-                        
+
                         /* Update heap area parameters */
                         area->end = end;
                         size_t excess = ((size_t) area->end) - ((size_t) last_head);
-                        
+
                         if (excess > 0) {
                                 if (excess >= STRUCT_OVERHEAD) {
@@ -513 +513 @@
                                             (((uintptr_t) last_head) - sizeof(heap_block_foot_t));
                                         heap_block_head_t *prev_head = BLOCK_HEAD(prev_foot);
-                                        
+
                                         block_check((void *) prev_head);
-                                        
+
                                         block_init(prev_head, prev_head->size + excess,
                                             prev_head->free, area);
@@ -522 +522 @@
                 }
         }
-        
+
         next_fit = NULL;
 }
@@ -551 +551 @@
 {
         malloc_assert(cur->size >= size);
-        
+
         /* See if we should split the block. */
         size_t split_limit = GROSS_SIZE(size);
-        
+
         if (cur->size > split_limit) {
                 /* Block big enough -> split. */
@@ -588 +588 @@
         malloc_assert((void *) first_block >= (void *) AREA_FIRST_BLOCK_HEAD(area));
         malloc_assert((void *) first_block < area->end);
-        
+
         for (heap_block_head_t *cur = first_block; (void *) cur < area->end;
             cur = (heap_block_head_t *) (((void *) cur) + cur->size)) {
                 block_check(cur);
-                
+
                 /* Finish searching on the final block */
                 if ((final_block != NULL) && (cur == final_block))
                         break;
-                
+
                 /* Try to find a block that is free and large enough. */
                 if ((cur->free) && (cur->size >= real_size)) {
@@ -607 +607 @@
                         void *aligned = (void *)
                             ALIGN_UP((uintptr_t) addr, falign);
-                        
+
                         if (addr == aligned) {
                                 /* Exact block start including alignment. */
                                 split_mark(cur, real_size);
-                                
+
                                 next_fit = cur;
                                 return addr;
@@ -617 +617 @@
                                 /* Block start has to be aligned */
                                 size_t excess = (size_t) (aligned - addr);
-                                
+
                                 if (cur->size >= real_size + excess) {
                                         /*
@@ -631 +631 @@
                                                 heap_block_foot_t *prev_foot = (heap_block_foot_t *)
                                                     ((void *) cur - sizeof(heap_block_foot_t));
-                                                
+
                                                 heap_block_head_t *prev_head = (heap_block_head_t *)
                                                     ((void *) cur - prev_foot->size);
-                                                
+
                                                 block_check(prev_head);
-                                                
+
                                                 size_t reduced_size = cur->size - excess;
                                                 heap_block_head_t *next_head = ((void *) cur) + excess;
-                                                
+
                                                 if ((!prev_head->free) &&
                                                     (excess >= STRUCT_OVERHEAD)) {
@@ -660 +660 @@
                                                             prev_head->free, area);
                                                 }
-                                                
+
                                                 block_init(next_head, reduced_size, true, area);
                                                 split_mark(next_head, real_size);
-                                                
+
                                                 next_fit = next_head;
                                                 return aligned;
@@ -678 +678 @@
                                                         excess += falign;
                                                 }
-                                                
+
                                                 /* Check for current block size again */
                                                 if (cur->size >= real_size + excess) {
@@ -684 +684 @@
                                                         cur = (heap_block_head_t *)
                                                             (AREA_FIRST_BLOCK_HEAD(area) + excess);
-                                                        
+
                                                         block_init((void *) AREA_FIRST_BLOCK_HEAD(area),
                                                             excess, true, area);
                                                         block_init(cur, reduced_size, true, area);
                                                         split_mark(cur, real_size);
-                                                        
+
                                                         next_fit = cur;
                                                         return aligned;
@@ -698 +698 @@
                 }
         }
-        
+
         return NULL;
 }
@@ -718 +718 @@
         if (size == 0)
                 return NULL;
-        
+
         /* First try to enlarge some existing area */
         for (heap_area_t *area = first_heap_area; area != NULL;
             area = area->next) {
-                
+
                 if (area_grow(area, size + align)) {
                         heap_block_head_t *first =
                             (heap_block_head_t *) AREA_LAST_BLOCK_HEAD(area);
-                        
+
                         void *addr =
                             malloc_area(area, first, NULL, size, align);
@@ -733 +733 @@
                 }
         }
-        
+
         /* Eventually try to create a new area */
         if (area_create(AREA_OVERHEAD(size + align))) {
                 heap_block_head_t *first =
                     (heap_block_head_t *) AREA_FIRST_BLOCK_HEAD(last_heap_area);
-                
+
                 void *addr =
                     malloc_area(last_heap_area, first, NULL, size, align);
@@ -744 +744 @@
                 return addr;
         }
-        
+
         return NULL;
 }
@@ -761 +761 @@
 {
         malloc_assert(first_heap_area != NULL);
-        
+
         if (align == 0)
                 return NULL;
-        
+
         size_t falign = lcm(align, BASE_ALIGN);
-        
+
         /* Check for integer overflow. */
         if (falign < align)
                 return NULL;
-        
+
         /*
          * The size of the allocated block needs to be naturally
@@ -778 +778 @@
          */
         size_t gross_size = GROSS_SIZE(ALIGN_UP(size, BASE_ALIGN));
-        
+
         /* Try the next fit approach */
         heap_block_head_t *split = next_fit;
-        
+
         if (split != NULL) {
                 void *addr = malloc_area(split->area, split, NULL, gross_size,
                     falign);
-                
+
                 if (addr != NULL)
                         return addr;
         }
-        
+
         /* Search the entire heap */
         for (heap_area_t *area = first_heap_area; area != NULL;
@@ -795 +795 @@
                 heap_block_head_t *first = (heap_block_head_t *)
                     AREA_FIRST_BLOCK_HEAD(area);
-                
+
                 void *addr = malloc_area(area, first, split, gross_size,
                     falign);
-                
+
                 if (addr != NULL)
                         return addr;
         }
-        
+
         /* Finally, try to grow heap space and allocate in the new area. */
         return heap_grow_and_alloc(gross_size, falign);
@@ -818 +818 @@
 {
         // FIXME: Check for overflow
-        
+
         void *block = malloc(nmemb * size);
         if (block == NULL)
                 return NULL;
-        
+
         memset(block, 0, nmemb * size);
         return block;
@@ -855 +855 @@
         if (align == 0)
                 return NULL;
-        
+
         size_t palign =
             1 << (fnzb(max(sizeof(void *), align) - 1) + 1);
@@ -883 +883 @@
         if (addr == NULL)
                 return malloc(size);
-        
+
         heap_lock();
-        
+
         /* Calculate the position of the header. */
         heap_block_head_t *head =
             (heap_block_head_t *) (addr - sizeof(heap_block_head_t));
-        
+
         block_check(head);
         malloc_assert(!head->free);
-        
+
         heap_area_t *area = head->area;
-        
+
         area_check(area);
         malloc_assert((void *) head >= (void *) AREA_FIRST_BLOCK_HEAD(area));
         malloc_assert((void *) head < area->end);
-        
+
         void *ptr = NULL;
         bool reloc = false;
         size_t real_size = GROSS_SIZE(ALIGN_UP(size, BASE_ALIGN));
         size_t orig_size = head->size;
-        
+
         if (orig_size > real_size) {
                 /* Shrink */
@@ -916 +916 @@
                         heap_shrink(area);
                 }
-                
+
                 ptr = ((void *) head) + sizeof(heap_block_head_t);
         } else {
@@ -948 +948 @@
                         }
                 }
-                
+
                 /*
                  * Look at the next block. If it is free and the size is
@@ -962 +962 @@
                             area);
                         split_mark(head, real_size);
-                        
+
                         ptr = ((void *) head) + sizeof(heap_block_head_t);
                         next_fit = NULL;
@@ -969 +969 @@
                 }
         }
-        
+
         heap_unlock();
-        
+
         if (reloc) {
                 ptr = malloc(size);
@@ -979 +979 @@
                 }
         }
-        
+
         return ptr;
 }
@@ -992 +992 @@
         if (addr == NULL)
                 return;
-        
+
         heap_lock();
-        
+
         /* Calculate the position of the header. */
         heap_block_head_t *head
             = (heap_block_head_t *) (addr - sizeof(heap_block_head_t));
-        
+
         block_check(head);
         malloc_assert(!head->free);
-        
+
         heap_area_t *area = head->area;
-        
+
         area_check(area);
         malloc_assert((void *) head >= (void *) AREA_FIRST_BLOCK_HEAD(area));
         malloc_assert((void *) head < area->end);
-        
+
         /* Mark the block itself as free. */
         head->free = true;
-        
+
         /* Look at the next block. If it is free, merge the two. */
         heap_block_head_t *next_head
             = (heap_block_head_t *) (((void *) head) + head->size);
-        
+
         if ((void *) next_head < area->end) {
                 block_check(next_head);
@@ -1020 +1020 @@
                         block_init(head, head->size + next_head->size, true, area);
         }
-        
+
         /* Look at the previous block. If it is free, merge the two. */
         if ((void *) head > (void *) AREA_FIRST_BLOCK_HEAD(area)) {
                 heap_block_foot_t *prev_foot =
                     (heap_block_foot_t *) (((void *) head) - sizeof(heap_block_foot_t));
-                
+
                 heap_block_head_t *prev_head =
                     (heap_block_head_t *) (((void *) head) - prev_foot->size);
-                
+
                 block_check(prev_head);
-                
+
                 if (prev_head->free)
                         block_init(prev_head, prev_head->size + head->size, true,
                             area);
         }
-        
+
         heap_shrink(area);
-        
+
         heap_unlock();
 }
@@ -1044 +1044 @@
 {
         heap_lock();
-        
+
         if (first_heap_area == NULL) {
                 heap_unlock();
                 return (void *) -1;
         }
-        
+
         /* Walk all heap areas */
         for (heap_area_t *area = first_heap_area; area != NULL;
             area = area->next) {
-                
+
                 /* Check heap area consistency */
                 if ((area->magic != HEAP_AREA_MAGIC) ||
@@ -1063 +1063 @@
                         return (void *) area;
                 }
-                
+
                 /* Walk all heap blocks */
                 for (heap_block_head_t *head = (heap_block_head_t *)
                     AREA_FIRST_BLOCK_HEAD(area); (void *) head < area->end;
                     head = (heap_block_head_t *) (((void *) head) + head->size)) {
-                        
+
                         /* Check heap block consistency */
                         if (head->magic != HEAP_BLOCK_HEAD_MAGIC) {
@@ -1074 +1074 @@
                                 return (void *) head;
                         }
-                        
+
                         heap_block_foot_t *foot = BLOCK_FOOT(head);
-                        
+
                         if ((foot->magic != HEAP_BLOCK_FOOT_MAGIC) ||
                             (head->size != foot->size)) {
@@ -1084 +1084 @@
                 }
         }
-        
+
         heap_unlock();
-        
+
         return NULL;
 }