malloc: fix recursivity with areaAlloc

core/alloc.c

@@ -17,7 +17,7 @@ static struct slabDesc *slub;
 static int allocInitialized = FALSE;
 
 static int allocSlab(struct slabDesc **desc, size_t sizeEl, size_t sizeSlab,
-                     int self_containing);
+                     int self_containing, int neverEmpty);
 static int allocSlabEntry(struct slabEntry **desc, size_t sizeEl, size_t sizeSlab,
                           int selfContained);
 static int formatPage(struct slabEntry *desc, size_t size, size_t sizeSlab, int selfContained);
@@ -28,27 +28,29 @@ static struct {
     size_t elementSize;
     size_t slabSize;
     unsigned char isSelf;
-} initSlab[] = {{4, PAGE_SIZE, 0},
+    unsigned char neverEmpty;
-                {8, PAGE_SIZE, 0},
+} initSlab[] = {{4, PAGE_SIZE, 0, 0},
-                {16, PAGE_SIZE, 0},
+                {8, PAGE_SIZE, 0, 0},
-                {32, PAGE_SIZE, 0},
+                {16, PAGE_SIZE, 0, 0},
-                {64, PAGE_SIZE, 0},
+                {32, PAGE_SIZE, 0, 0},
-                {128, PAGE_SIZE, 0},
+                {64, PAGE_SIZE, 0, 0},
-                {256, 2 * PAGE_SIZE, 0},
+                {128, PAGE_SIZE, 0, 0},
-                {1024, 2 * PAGE_SIZE, 0},
+                {256, 2 * PAGE_SIZE, 0, 0},
-                {2048, 3 * PAGE_SIZE, 0},
+                {1024, 2 * PAGE_SIZE, 0, 0},
-                {4096, 4 * PAGE_SIZE, 0},
+                {2048, 3 * PAGE_SIZE, 0, 0},
-                {0, 0, 0}};
+                {4096, 4 * PAGE_SIZE, 0, 0},
+                {0, 0, 0, 0}};
 
 int allocSetup(size_t sizeOfArea, vaddr_t *areaAddr, vaddr_t *descAddr, vaddr_t *entryAddr)
 {
     list_init(slub);
 
-    assert(allocBookSlab(sizeof(struct slabDesc), PAGE_SIZE, TRUE) == 0);
+    assert(allocBookSlab(sizeof(struct slabDesc), PAGE_SIZE, TRUE, FALSE) == 0);
     *descAddr = (vaddr_t)allocGetSlab(sizeof(struct slabDesc));
-    assert(allocBookSlab(sizeof(struct slabEntry), PAGE_SIZE, TRUE) == 0);
+    assert(allocBookSlab(sizeof(struct slabEntry), PAGE_SIZE, TRUE, FALSE) == 0);
     *entryAddr = (vaddr_t)allocGetSlab(sizeof(struct slabEntry));
-    assert(allocBookSlab(sizeOfArea, PAGE_SIZE, TRUE) == 0);
+    printf("allocSetup for sizeOfArea %d\n", sizeOfArea);
+    assert(allocBookSlab(sizeOfArea, PAGE_SIZE, TRUE, TRUE) == 0);
     *areaAddr        = (vaddr_t)allocGetSlab(sizeOfArea);
     allocInitialized = TRUE;
 
@@ -61,7 +63,7 @@ int allocPopulate()
         int ret;
 
         if ((ret = allocBookSlab(initSlab[i].elementSize, initSlab[i].slabSize,
-                                 initSlab[i].isSelf))) {
+                                 initSlab[i].isSelf, initSlab[i].neverEmpty))) {
             if (ret == -EEXIST)
                 continue;
             pr_err("Fail to allocBookSlab %d for %d \n", ret, (1U << i));
@@ -73,7 +75,7 @@ int allocPopulate()
     return 0;
 }
 
-int allocBookSlab(size_t sizeEl, size_t sizeSlab, int selfContained)
+int allocBookSlab(size_t sizeEl, size_t sizeSlab, int selfContained, int neverEmpty)
 {
     struct slabDesc *slab    = NULL;
     struct slabDesc *newSlab = NULL;
@@ -95,7 +97,7 @@ int allocBookSlab(size_t sizeEl, size_t sizeSlab, int selfContained)
         }
     }
 
-    if ((ret = allocSlab(&newSlab, sizeEl, sizeSlab, selfContained))) {
+    if ((ret = allocSlab(&newSlab, sizeEl, sizeSlab, selfContained, neverEmpty))) {
         pr_devel("Failed to alloc Slab\n");
         restore_IRQs(flags);
         return ret;
@@ -112,7 +114,8 @@ int allocBookSlab(size_t sizeEl, size_t sizeSlab, int selfContained)
     return 0;
 }
 
-static int allocSlab(struct slabDesc **desc, size_t size, size_t sizeSlab, int selfContained)
+static int allocSlab(struct slabDesc **desc, size_t size, size_t sizeSlab, int selfContained,
+                     int neverEmpty)
 {
     uint nbPage, i;
     vaddr_t alloc;
@@ -156,6 +159,7 @@ static int allocSlab(struct slabDesc **desc, size_t size, size_t sizeSlab, int s
     slab->page          = (vaddr_t)alloc;
     slab->full          = 0;
     slab->size          = sizeSlab;
+    (*desc)->neverEmpty = neverEmpty;
     (*desc)->size       = size;
 
     return formatPage(&(*desc)->slab, size, sizeSlab, selfContained);
@@ -202,8 +206,6 @@ static int allocSlabEntry(struct slabEntry **desc, size_t size, size_t sizeSlab,
     (*desc)->size = sizeSlab;
 
     return formatPage((*desc), size, sizeSlab, selfContained);
-
-    return -ENOMEM;
 }
 
 static int formatPage(struct slabEntry *desc, size_t size, size_t sizeSlab, int selfContained)
@@ -271,12 +273,36 @@ void *malloc(size_t size)
         return NULL;
     }
 
+    struct slabEntry *slabList = &slab->slab;
     list_foreach(&slab->slab, slabEntry, slabIdx)
     {
         if (!slabEntry->full) {
-            // pr_devel("found place in slub %d at idx %d for size %d\n", slubIdx,
+            // pr_devel("found place in slab idx %d for size %d\n", slabIdx, slab->size);
-            //         slabIdx, size);
             ret = allocFromSlab(slabEntry);
+            if (slabEntry->full && slab->neverEmpty) {
+
+                pr_devel("Prealloc place for slab for object size %d\n", slab->size);
+                assert(IS_SELF_CONTAINED(slabEntry));
+                size_t slabSize         = slabEntry->size;
+                int nbPages             = DIV_ROUND_UP(slabSize, PAGE_SIZE);
+                struct slabEntry *entry = (struct slabEntry *)areaBook(nbPages, AREA_PHY_MAP);
+                if (entry == NULL) {
+                    restore_IRQs(flags);
+
+                    return NULL;
+                }
+
+                (entry)->freeEl = (char *)(entry) + sizeof(struct slabEntry);
+                list_singleton(entry, entry);
+                entry->page = (vaddr_t)entry;
+                entry->full = 0;
+                entry->size = slabSize;
+
+                formatPage(entry, slab->size, slabSize, 1);
+                list_add_tail(slabList, entry);
+                areaAdd((vaddr_t)entry, (vaddr_t)entry + nbPages * PAGE_SIZE, FALSE);
+            }
+
             restore_IRQs(flags);
             return ret;
         }
@@ -284,7 +310,6 @@ void *malloc(size_t size)
 
     // No room found
     struct slabEntry *newSlabEntry;
-    struct slabEntry *slabList = &slab->slab;
     size_t slabSize = MAX(PAGE_SIZE, size);
     int retSlab;
 
@@ -304,7 +329,8 @@ void *malloc(size_t size)
     return ret;
 }
 
-void *zalloc(size_t size){
+void *zalloc(size_t size)
+{
     void *alloc = malloc(size);
 
     if (alloc != NULL)
@@ -333,7 +359,8 @@ static int freeFromSlab(void *ptr, struct slabEntry *slab)
     return 0;
 }
 
-int freeSlabAllocated(void *ptr){
+int freeSlabAllocated(void *ptr)
+{
     struct slabDesc *slab;
     int slabIdx;
     int flags;

core/alloc.h

@@ -12,7 +12,7 @@ int allocPopulate();
  * Allow malloc to allocate elements of this precise size.
  * Otherwise the allocation will be in the closest biggest pool.
  * */
-int allocBookSlab(size_t size, size_t sizeSlab, int selfContained);
+int allocBookSlab(size_t size, size_t sizeSlab, int selfContained, int neverEmpty);
 
 void *malloc(size_t size);
 void *zalloc(size_t size);
@@ -22,9 +22,9 @@ void free(void *ptr);
  */
 struct slabEntry {
     vaddr_t page;
-    size_t size;
     void *freeEl;
-    char full;
+    size_t size;
+    bool_t full;//TODO replace by freeEl == NULL
     struct slabEntry *next;
     struct slabEntry *prev;
 };
@@ -32,6 +32,7 @@ struct slabEntry {
 struct slabDesc {
     struct slabEntry slab;
     size_t size;
+    bool_t neverEmpty;
     struct slabDesc *next;
     struct slabDesc *prev;
 };

core/allocArea.c

@@ -2,6 +2,7 @@
 #include "alloc.h"
 #include "assert.h"
 #include "kernel.h"
+#include "irq.h"
 #include "list.h"
 #include "mem.h"
 #include "stdarg.h"
@@ -71,13 +72,64 @@ static void insertSorted(struct memArea **list, struct memArea *item)
         list_add_tail(*list, item);
 }
 
+vaddr_t areaBook(unsigned int nbPages, uint32_t flags){
+
+    struct memArea *area;
+    vaddr_t allocated;
+    uint32_t irqFlags;
+
+    disable_IRQs(irqFlags);
+
+    area = areaFindFit(nbPages);
+    if (!area){
+        printf("NULL<\n");
+        restore_IRQs(irqFlags);
+
+        return (vaddr_t)NULL;
+    }
+
+    if (area->nbPages == nbPages) {
+        list_delete(freeArea, area);
+        allocated = area->startAddr;
+    } else {
+
+        allocated = area->startAddr;
+
+        area->nbPages -= nbPages;
+        area->startAddr += nbPages * PAGE_SIZE;
+
+    }
+
+    if (flags & AREA_PHY_MAP) {
+        for (uint i = 0; i < nbPages; i++) {
+            paddr_t page = allocPhyPage(1);
+            if (page) {
+                pageMap(allocated + i * PAGE_SIZE, page, PAGING_MEM_WRITE);
+            } else {
+                printf("Ooops\n");
+                // TODO
+                assert(0);
+            }
+        }
+    }
+
+    restore_IRQs(irqFlags);
+    return allocated;
+}
+
 vaddr_t areaAlloc(unsigned int nbPages, uint32_t flags)
 {
     struct memArea *area, *allocated;
+    uint32_t irqFlags;
+
+    disable_IRQs(irqFlags);
 
     area = areaFindFit(nbPages);
-    if (!area)
+    if (!area){
+        restore_IRQs(irqFlags);
+
         return (vaddr_t)NULL;
+    }
 
     if (area->nbPages == nbPages) {
         list_delete(freeArea, area);
@@ -87,6 +139,7 @@ vaddr_t areaAlloc(unsigned int nbPages, uint32_t flags)
         struct memArea *newArea = (struct memArea *)malloc(sizeof(struct memArea));
         if (!newArea) {
             pr_devel("Failed to allocated area of %d pages\n", nbPages);
+            restore_IRQs(irqFlags);
             return (vaddr_t)NULL;
         }
 
@@ -109,12 +162,14 @@ vaddr_t areaAlloc(unsigned int nbPages, uint32_t flags)
             if (page) {
                 pageMap(allocated->startAddr + i * PAGE_SIZE, page, PAGING_MEM_WRITE);
             } else {
+                printf("Ooops\n");
                 // TODO
-                assert(1);
+                assert(0);
             }
         }
     }
 
+    restore_IRQs(irqFlags);
     return allocated->startAddr;
 }
 

core/allocArea.h

@@ -18,5 +18,9 @@ struct memArea {
 
 void areaInit(vaddr_t firstMemUsed, vaddr_t lastUsed, vaddr_t stack_bottom, vaddr_t stack_top);
 vaddr_t areaAlloc(unsigned int nbPages, uint32_t flags);
+// Remove an area from the free ones but do not add it into used ones.
+// This area should be latter added woth areaAdd.
+// Used by malloc to avoid recursivity issue
+vaddr_t areaBook(unsigned int nbPages, uint32_t flags);
 int areaFree(vaddr_t addr);
 int areaAdd(vaddr_t begin, vaddr_t end, int isFree);

core/mem.c

@@ -133,6 +133,7 @@ paddr_t allocPhyPage(uint nbPage)
         next = mem->next;
     }
     allocatedPage += nbPage;
+
     return head->phy_addr;
 }