matos/core/alloc.c

222 lines
7.4 KiB
C
Raw Normal View History

2019-04-11 22:34:20 +02:00
#define pr_fmt(fmt) "[alloc]: " fmt
//#define DEBUG
#include "alloc.h"
#include "errno.h"
#include "klibc.h"
2019-04-11 22:34:20 +02:00
#include "list.h"
#include "math.h"
#include "mem.h"
2019-04-15 22:48:37 +02:00
#define IS_SELF_CONTAINED(desc) ((vaddr_t)((desc)->page) == (vaddr_t)(desc))
2019-04-11 22:34:20 +02:00
// Slab will contains object from sizeof(void *) to PAGE_SIZE/2 by pow2
#define SLUB_SIZE (PAGE_SHIFT)
2019-04-14 15:56:48 +02:00
struct slabDesc *slub;
2019-04-11 22:34:20 +02:00
int allocSlab(struct slabDesc **desc, size_t size, int self_containing);
int allocSlabEntry(struct slabEntry **desc, size_t size, int selfContained);
static int formatPage(struct slabEntry *desc, size_t size, int selfContained);
2019-04-11 22:34:20 +02:00
int allocInit(void)
2019-04-11 22:34:20 +02:00
{
uint start = log2(sizeof(void *));
2019-04-14 15:56:48 +02:00
list_init(slub);
2019-04-15 22:48:37 +02:00
int ret;
if ((ret = allocBookSlab(sizeof(struct slabDesc), 1))) {
pr_devel("Fail to allocBookSlab %d for slabDesc :( \n", ret);
return ret;
}
if ((ret = allocBookSlab(sizeof(struct slabEntry), 1))) {
pr_devel("Fail to allocBookSlab %d for slabEntry :( \n", ret);
2019-04-15 22:48:37 +02:00
return ret;
}
2019-04-16 21:04:32 +02:00
for (uint i = start; i <= SLUB_SIZE; i++) {
2019-04-15 22:48:37 +02:00
if ((ret = allocBookSlab(1U << i, 0))) {
2019-04-17 23:13:46 +02:00
if(ret == -EEXIST)
continue;
2019-04-15 22:48:37 +02:00
pr_devel("Fail to allocBookSlab %d for %d \n", ret, (1U << i));
return ret;
}
}
return 0;
}
2019-04-15 22:48:37 +02:00
int allocBookSlab(size_t size, int selfContained)
{
pr_devel("%s for size %d is self %d\n", __func__, size, selfContained);
struct slabDesc *slab = NULL;
int slabIdx;
int ret;
list_foreach(slub, slab, slabIdx)
{
if (slab->size == size) {
return -EEXIST;
}
if (slab->size > size) {
break;
}
2019-04-11 22:34:20 +02:00
}
struct slabDesc *newSlab;
if ((ret = allocSlab(&newSlab, size, selfContained)))
return ret;
if (list_foreach_early_break(slub, slab, slabIdx)) {
list_insert_before(slub, slab, newSlab);
} else {
list_add_tail(slub, newSlab);
}
2019-04-11 22:34:20 +02:00
return 0;
}
int allocSlab(struct slabDesc **desc, size_t size, int selfContained)
{
// pr_devel("%s for size %d is self %d\n", __func__, size, selfContained);
if (size > PAGE_SIZE)
return -ENOENT;
paddr_t alloc = allocPhyPage();
if (alloc == (paddr_t)NULL)
return -ENOMEM;
if (pageMap((vaddr_t)alloc, alloc, PAGING_MEM_WRITE))
return -ENOMEM;
if (selfContained) {
*desc = (struct slabDesc *)alloc;
((*desc)->slab).freeEl = (char *)(*desc) + sizeof(struct slabDesc);
} else {
*desc = malloc(sizeof(struct slabDesc));
(*desc)->slab.freeEl = (void *)alloc;
}
struct slabEntry *slab = &(*desc)->slab;
list_singleton(slab, slab);
slab->page = (vaddr_t)alloc;
slab->full = 0;
(*desc)->size = size;
// pr_devel("got page %d for size %d first %d", alloc, size, (*desc)->slab.freeEl);
return formatPage(&(*desc)->slab, size, selfContained);
}
int allocSlabEntry(struct slabEntry **desc, size_t size, int selfContained)
2019-04-11 22:34:20 +02:00
{
2019-04-15 22:48:37 +02:00
pr_devel("%s for size %d is self %d\n", __func__, size, selfContained);
2019-04-11 22:34:20 +02:00
if (size > PAGE_SIZE)
return -ENOENT;
2019-04-11 22:34:20 +02:00
paddr_t alloc = allocPhyPage();
if (alloc == (paddr_t)NULL)
return -ENOMEM;
if (pageMap((vaddr_t)alloc, alloc, PAGING_MEM_WRITE))
return -ENOMEM;
2019-04-15 22:48:37 +02:00
if (selfContained) {
*desc = (struct slabEntry *)alloc;
(*desc)->freeEl = (char *)(*desc) + sizeof(struct slabEntry);
2019-04-15 22:48:37 +02:00
} else {
*desc = malloc(sizeof(struct slabEntry));
2019-04-15 22:48:37 +02:00
(*desc)->freeEl = (void *)alloc;
}
2019-04-11 22:34:20 +02:00
list_singleton(*desc, *desc);
2019-04-16 20:11:24 +02:00
(*desc)->page = (vaddr_t)alloc;
(*desc)->full = 0;
// pr_devel("got page %d for size %d first %d", alloc, size, (*desc)->freeEl);
2019-04-15 22:48:37 +02:00
return formatPage((*desc), size, selfContained);
2019-04-11 22:34:20 +02:00
}
static int formatPage(struct slabEntry *desc, size_t size, int selfContained)
2019-04-11 22:34:20 +02:00
{
2019-04-15 22:48:37 +02:00
char *cur = desc->freeEl;
ulong nbEl = PAGE_SIZE / size - 1;
if (selfContained)
nbEl = (PAGE_SIZE - sizeof(struct slabDesc)) / size - 1;
2019-04-11 22:34:20 +02:00
ulong i;
2019-04-15 22:48:37 +02:00
for (i = 0; i < nbEl; i++) {
2019-04-11 22:34:20 +02:00
*((vaddr_t *)cur) = (vaddr_t)cur + size;
cur += size;
}
*((vaddr_t *)cur) = (vaddr_t)NULL;
// pr_devel("last at %d allocated %d\n", cur, i + 1);
2019-04-11 22:34:20 +02:00
return 0;
}
static void *allocFromSlab(struct slabEntry *slab)
2019-04-11 22:34:20 +02:00
{
vaddr_t *next = slab->freeEl;
if (*next == (vaddr_t)NULL) {
2019-04-17 23:13:46 +02:00
pr_devel("Slab @%d is now full\n", slab);
2019-04-11 22:34:20 +02:00
slab->full = 1;
} else {
slab->freeEl = (void *)(*next);
}
return (void *)next;
}
void *malloc(size_t size)
{
if (size > (1U << SLUB_SIZE)) {
printf("implement malloc for big size\n");
return NULL;
}
struct slabDesc *slab;
2019-04-16 20:11:24 +02:00
uint slubIdx;
list_foreach(slub, slab, slubIdx)
2019-04-14 15:56:48 +02:00
{
if (size <= slab->size)
2019-04-14 15:56:48 +02:00
break;
2019-04-11 22:34:20 +02:00
}
struct slabEntry *slabEntry;
2019-04-11 22:34:20 +02:00
int slabIdx;
list_foreach(&slab->slab, slabEntry, slabIdx)
2019-04-11 22:34:20 +02:00
{
if (!slabEntry->full) {
// pr_devel("found place in slub %d at idx %d for size %d\n", slubIdx,
// slabIdx, size);
return allocFromSlab(slabEntry);
2019-04-11 22:34:20 +02:00
}
}
2019-04-15 22:48:37 +02:00
// No room found
struct slabEntry *newSlabEntry;
struct slabEntry *slabList = &slab->slab;
2019-04-15 22:48:37 +02:00
int ret;
if ((ret = allocSlabEntry(&newSlabEntry, slab->size, IS_SELF_CONTAINED(&slab->slab)))) {
pr_devel("Fail to allocSlabEntry %d\n", ret);
2019-04-15 22:48:37 +02:00
return NULL;
2019-04-11 22:34:20 +02:00
}
pr_devel("Allocate new slab for object of size %d\n", slab->size);
list_add_tail(slabList, newSlabEntry);
return allocFromSlab(newSlabEntry);
2019-04-11 22:34:20 +02:00
}
2019-04-15 23:09:09 +02:00
int freeFromSlab(void *ptr, struct slabEntry *slab)
2019-04-16 20:11:24 +02:00
{
struct slabEntry *slabEntry;
2019-04-15 23:09:09 +02:00
int slabIdx;
list_foreach(slab, slabEntry, slabIdx)
{
if ((slabEntry->page <= (vaddr_t)ptr) &&
2019-04-16 20:11:24 +02:00
((vaddr_t)ptr < (slabEntry->page + PAGE_SIZE))) {
// pr_devel("free place! was %d is now %d\n", slabEntry->freeEl, ptr);
2019-04-15 23:09:09 +02:00
*((vaddr_t *)ptr) = (vaddr_t)slabEntry->freeEl;
slabEntry->freeEl = ptr;
2019-04-16 20:11:24 +02:00
slabEntry->full = 0;
2019-04-15 23:09:09 +02:00
return 1;
}
}
return 0;
}
2019-04-16 20:11:24 +02:00
void free(void *ptr)
{
if (!ptr)
2019-04-15 23:09:09 +02:00
return;
struct slabDesc *slab;
int slabIdx;
2019-04-16 20:11:24 +02:00
list_foreach(slub, slab, slabIdx)
{
struct slabEntry *slabEntry;
int entryIdx;
list_foreach(&slab->slab, slabEntry, entryIdx)
{
if (freeFromSlab(ptr, slabEntry))
return;
}
2019-04-15 23:09:09 +02:00
}
pr_devel("free: slab not found\n");
}