ssfn: try making normal renderer work (i hope google won't dmca this for adding noto inside lol)
This commit is contained in:
RaphProductions
parent
a6f371b4ad
commit
442b26df09
13 changed files with 11150 additions and 261 deletions
649
kernel/src/mm/liballoc/liballoc.c
Normal file
649
kernel/src/mm/liballoc/liballoc.c
Normal file
|
|
@ -0,0 +1,649 @@
|
|||
// Copyright: Durand Miller <clutter@djm.co.za>
|
||||
#include <mm/liballoc/liballoc.h>
|
||||
|
||||
#define VERSION "1.1"
|
||||
#define ALIGNMENT 16ul
|
||||
|
||||
#define ALIGN_TYPE char
|
||||
#define ALIGN_INFO sizeof(ALIGN_TYPE) * 16
|
||||
|
||||
#define USE_CASE1
|
||||
#define USE_CASE2
|
||||
#define USE_CASE3
|
||||
#define USE_CASE4
|
||||
#define USE_CASE5
|
||||
|
||||
#define ALIGN(ptr) \
|
||||
if (ALIGNMENT > 1) \
|
||||
{ \
|
||||
uintptr_t diff; \
|
||||
ptr = (void *)((uintptr_t)ptr + ALIGN_INFO); \
|
||||
diff = (uintptr_t)ptr & (ALIGNMENT - 1); \
|
||||
if (diff != 0) \
|
||||
{ \
|
||||
diff = ALIGNMENT - diff; \
|
||||
ptr = (void *)((uintptr_t)ptr + diff); \
|
||||
} \
|
||||
*((ALIGN_TYPE *)((uintptr_t)ptr - ALIGN_INFO)) = \
|
||||
diff + ALIGN_INFO; \
|
||||
}
|
||||
|
||||
#define UNALIGN(ptr) \
|
||||
if (ALIGNMENT > 1) \
|
||||
{ \
|
||||
uintptr_t diff = *((ALIGN_TYPE *)((uintptr_t)ptr - ALIGN_INFO)); \
|
||||
if (diff < (ALIGNMENT + ALIGN_INFO)) \
|
||||
{ \
|
||||
ptr = (void *)((uintptr_t)ptr - diff); \
|
||||
} \
|
||||
}
|
||||
|
||||
#define LIBALLOC_MAGIC 0xc001c0de
|
||||
#define LIBALLOC_DEAD 0xdeaddead
|
||||
|
||||
struct liballoc_major
|
||||
{
|
||||
struct liballoc_major *prev;
|
||||
struct liballoc_major *next;
|
||||
unsigned int pages;
|
||||
unsigned int size;
|
||||
unsigned int usage;
|
||||
struct liballoc_minor *first;
|
||||
};
|
||||
|
||||
struct liballoc_minor
|
||||
{
|
||||
struct liballoc_minor *prev;
|
||||
struct liballoc_minor *next;
|
||||
struct liballoc_major *block;
|
||||
unsigned int magic;
|
||||
unsigned int size;
|
||||
unsigned int req_size;
|
||||
};
|
||||
|
||||
static struct liballoc_major *l_memRoot = NULL;
|
||||
static struct liballoc_major *l_bestBet = NULL;
|
||||
|
||||
static unsigned int l_pageSize = 4096;
|
||||
static unsigned int l_pageCount = 16;
|
||||
static unsigned long long l_allocated = 0;
|
||||
static unsigned long long l_inuse = 0;
|
||||
|
||||
static long long l_warningCount = 0;
|
||||
static long long l_errorCount = 0;
|
||||
static long long l_possibleOverruns = 0;
|
||||
|
||||
static void *liballoc_memset(void *s, int c, size_t n)
|
||||
{
|
||||
unsigned int i;
|
||||
for (i = 0; i < n; i++)
|
||||
((char *)s)[i] = c;
|
||||
|
||||
return s;
|
||||
}
|
||||
static void *liballoc_memcpy(void *s1, const void *s2, size_t n)
|
||||
{
|
||||
char *cdest;
|
||||
char *csrc;
|
||||
unsigned int *ldest = (unsigned int *)s1;
|
||||
unsigned int *lsrc = (unsigned int *)s2;
|
||||
|
||||
while (n >= sizeof(unsigned int))
|
||||
{
|
||||
*ldest++ = *lsrc++;
|
||||
n -= sizeof(unsigned int);
|
||||
}
|
||||
|
||||
cdest = (char *)ldest;
|
||||
csrc = (char *)lsrc;
|
||||
|
||||
while (n > 0)
|
||||
{
|
||||
*cdest++ = *csrc++;
|
||||
n -= 1;
|
||||
}
|
||||
|
||||
return s1;
|
||||
}
|
||||
|
||||
#if _DEBUG
|
||||
void liballoc_dump()
|
||||
{
|
||||
#ifdef _DEBUG
|
||||
struct liballoc_major *maj = l_memRoot;
|
||||
struct liballoc_minor *min = NULL;
|
||||
#endif
|
||||
|
||||
info("------ Memory data ---------------");
|
||||
info("System memory allocated: %i bytes", l_allocated);
|
||||
info("Memory in used (malloc'ed): %i bytes", l_inuse);
|
||||
info("Warning count: %i", l_warningCount);
|
||||
info("Error count: %i", l_errorCount);
|
||||
info("Possible overruns: %i", l_possibleOverruns);
|
||||
|
||||
#ifdef _DEBUG
|
||||
while (maj != NULL)
|
||||
{
|
||||
info("%x: total = %i, used = %i",
|
||||
maj,
|
||||
maj->size,
|
||||
maj->usage);
|
||||
|
||||
min = maj->first;
|
||||
while (min != NULL)
|
||||
{
|
||||
info(" %x: %i bytes",
|
||||
min,
|
||||
min->size);
|
||||
min = min->next;
|
||||
}
|
||||
|
||||
maj = maj->next;
|
||||
}
|
||||
#endif
|
||||
}
|
||||
#else
|
||||
void liballoc_dump()
|
||||
{
|
||||
return;
|
||||
}
|
||||
#endif
|
||||
|
||||
static struct liballoc_major *allocate_new_page(unsigned int size)
|
||||
{
|
||||
unsigned int st;
|
||||
struct liballoc_major *maj;
|
||||
|
||||
st = size + sizeof(struct liballoc_major);
|
||||
st += sizeof(struct liballoc_minor);
|
||||
|
||||
if ((st % l_pageSize) == 0)
|
||||
st = st / (l_pageSize);
|
||||
else
|
||||
st = st / (l_pageSize) + 1;
|
||||
|
||||
if (st < l_pageCount)
|
||||
st = l_pageCount;
|
||||
|
||||
maj = (struct liballoc_major *)liballoc_alloc(st);
|
||||
|
||||
if (maj == NULL)
|
||||
{
|
||||
l_warningCount += 1;
|
||||
log("liballoc - (warning) liballoc_alloc( %i ) return NULL", st);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
maj->prev = NULL;
|
||||
maj->next = NULL;
|
||||
maj->pages = st;
|
||||
maj->size = st * l_pageSize;
|
||||
maj->usage = sizeof(struct liballoc_major);
|
||||
maj->first = NULL;
|
||||
|
||||
l_allocated += maj->size;
|
||||
|
||||
log("liballoc - Resource allocated %x of %i pages (%i bytes) for %i size.", maj, st, maj->size, size);
|
||||
log("liballoc - Total memory usage = %i KB", (int)((l_allocated / (1024))));
|
||||
|
||||
return maj;
|
||||
}
|
||||
|
||||
void *PREFIX(malloc)(size_t req_size)
|
||||
{
|
||||
int startedBet = 0;
|
||||
unsigned long long bestSize = 0;
|
||||
void *p = NULL;
|
||||
uintptr_t diff;
|
||||
struct liballoc_major *maj;
|
||||
struct liballoc_minor *min;
|
||||
struct liballoc_minor *new_min;
|
||||
unsigned long size = req_size;
|
||||
|
||||
if (ALIGNMENT > 1)
|
||||
{
|
||||
size += ALIGNMENT + ALIGN_INFO;
|
||||
}
|
||||
|
||||
liballoc_lock();
|
||||
|
||||
if (size == 0)
|
||||
{
|
||||
l_warningCount += 1;
|
||||
log("liballoc - (warning) alloc( 0 ) called from %x",
|
||||
__builtin_return_address(0));
|
||||
|
||||
liballoc_unlock();
|
||||
return PREFIX(malloc)(1);
|
||||
}
|
||||
|
||||
if (l_memRoot == NULL)
|
||||
{
|
||||
log("liballoc - initialization of liballoc " VERSION "");
|
||||
l_memRoot = allocate_new_page(size);
|
||||
if (l_memRoot == NULL)
|
||||
{
|
||||
liballoc_unlock();
|
||||
log("liballoc - initial l_memRoot initialization failed", p);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
log("liballoc - set up first memory major %x", l_memRoot);
|
||||
}
|
||||
|
||||
log("liballoc - %x PREFIX(malloc)( %i ): ",
|
||||
__builtin_return_address(0),
|
||||
size);
|
||||
|
||||
maj = l_memRoot;
|
||||
startedBet = 0;
|
||||
|
||||
if (l_bestBet != NULL)
|
||||
{
|
||||
bestSize = l_bestBet->size - l_bestBet->usage;
|
||||
|
||||
if (bestSize > (size + sizeof(struct liballoc_minor)))
|
||||
{
|
||||
maj = l_bestBet;
|
||||
startedBet = 1;
|
||||
}
|
||||
}
|
||||
|
||||
while (maj != NULL)
|
||||
{
|
||||
diff = maj->size - maj->usage;
|
||||
|
||||
if (bestSize < diff)
|
||||
{
|
||||
|
||||
l_bestBet = maj;
|
||||
bestSize = diff;
|
||||
}
|
||||
|
||||
#ifdef USE_CASE1
|
||||
|
||||
if (diff < (size + sizeof(struct liballoc_minor)))
|
||||
{
|
||||
log("liballoc - (warning) CASE 1: Insufficient space in block %x", maj);
|
||||
|
||||
if (maj->next != NULL)
|
||||
{
|
||||
maj = maj->next;
|
||||
continue;
|
||||
}
|
||||
|
||||
if (startedBet == 1)
|
||||
{
|
||||
maj = l_memRoot;
|
||||
startedBet = 0;
|
||||
continue;
|
||||
}
|
||||
|
||||
maj->next = allocate_new_page(size);
|
||||
if (maj->next == NULL)
|
||||
break;
|
||||
maj->next->prev = maj;
|
||||
maj = maj->next;
|
||||
}
|
||||
|
||||
#endif
|
||||
|
||||
#ifdef USE_CASE2
|
||||
|
||||
if (maj->first == NULL)
|
||||
{
|
||||
maj->first = (struct liballoc_minor *)((uintptr_t)maj + sizeof(struct liballoc_major));
|
||||
|
||||
maj->first->magic = LIBALLOC_MAGIC;
|
||||
maj->first->prev = NULL;
|
||||
maj->first->next = NULL;
|
||||
maj->first->block = maj;
|
||||
maj->first->size = size;
|
||||
maj->first->req_size = req_size;
|
||||
maj->usage += size + sizeof(struct liballoc_minor);
|
||||
|
||||
l_inuse += size;
|
||||
|
||||
p = (void *)((uintptr_t)(maj->first) + sizeof(struct liballoc_minor));
|
||||
|
||||
ALIGN(p);
|
||||
|
||||
log("liballoc - (warning) CASE 2: returning %x", p);
|
||||
liballoc_unlock();
|
||||
return p;
|
||||
}
|
||||
|
||||
#endif
|
||||
|
||||
#ifdef USE_CASE3
|
||||
|
||||
diff = (uintptr_t)(maj->first);
|
||||
diff -= (uintptr_t)maj;
|
||||
diff -= sizeof(struct liballoc_major);
|
||||
|
||||
if (diff >= (size + sizeof(struct liballoc_minor)))
|
||||
{
|
||||
|
||||
maj->first->prev = (struct liballoc_minor *)((uintptr_t)maj + sizeof(struct liballoc_major));
|
||||
maj->first->prev->next = maj->first;
|
||||
maj->first = maj->first->prev;
|
||||
|
||||
maj->first->magic = LIBALLOC_MAGIC;
|
||||
maj->first->prev = NULL;
|
||||
maj->first->block = maj;
|
||||
maj->first->size = size;
|
||||
maj->first->req_size = req_size;
|
||||
maj->usage += size + sizeof(struct liballoc_minor);
|
||||
|
||||
l_inuse += size;
|
||||
|
||||
p = (void *)((uintptr_t)(maj->first) + sizeof(struct liballoc_minor));
|
||||
ALIGN(p);
|
||||
|
||||
log("liballoc - (warning) CASE 3: returning %x", p);
|
||||
liballoc_unlock();
|
||||
return p;
|
||||
}
|
||||
|
||||
#endif
|
||||
|
||||
#ifdef USE_CASE4
|
||||
|
||||
min = maj->first;
|
||||
|
||||
while (min != NULL)
|
||||
{
|
||||
|
||||
if (min->next == NULL)
|
||||
{
|
||||
|
||||
diff = (uintptr_t)(maj) + maj->size;
|
||||
diff -= (uintptr_t)min;
|
||||
diff -= sizeof(struct liballoc_minor);
|
||||
diff -= min->size;
|
||||
|
||||
if (diff >= (size + sizeof(struct liballoc_minor)))
|
||||
{
|
||||
|
||||
min->next = (struct liballoc_minor *)((uintptr_t)min + sizeof(struct liballoc_minor) + min->size);
|
||||
min->next->prev = min;
|
||||
min = min->next;
|
||||
min->next = NULL;
|
||||
min->magic = LIBALLOC_MAGIC;
|
||||
min->block = maj;
|
||||
min->size = size;
|
||||
min->req_size = req_size;
|
||||
maj->usage += size + sizeof(struct liballoc_minor);
|
||||
|
||||
l_inuse += size;
|
||||
|
||||
p = (void *)((uintptr_t)min + sizeof(struct liballoc_minor));
|
||||
ALIGN(p);
|
||||
|
||||
log("liballoc - (warning) CASE 4.1: returning %x", p);
|
||||
liballoc_unlock();
|
||||
return p;
|
||||
}
|
||||
}
|
||||
|
||||
if (min->next != NULL)
|
||||
{
|
||||
|
||||
diff = (uintptr_t)(min->next);
|
||||
diff -= (uintptr_t)min;
|
||||
diff -= sizeof(struct liballoc_minor);
|
||||
diff -= min->size;
|
||||
|
||||
if (diff >= (size + sizeof(struct liballoc_minor)))
|
||||
{
|
||||
|
||||
new_min = (struct liballoc_minor *)((uintptr_t)min + sizeof(struct liballoc_minor) + min->size);
|
||||
|
||||
new_min->magic = LIBALLOC_MAGIC;
|
||||
new_min->next = min->next;
|
||||
new_min->prev = min;
|
||||
new_min->size = size;
|
||||
new_min->req_size = req_size;
|
||||
new_min->block = maj;
|
||||
min->next->prev = new_min;
|
||||
min->next = new_min;
|
||||
maj->usage += size + sizeof(struct liballoc_minor);
|
||||
|
||||
l_inuse += size;
|
||||
|
||||
p = (void *)((uintptr_t)new_min + sizeof(struct liballoc_minor));
|
||||
ALIGN(p);
|
||||
|
||||
log("liballoc - (warning) CASE 4.2: returning %x", p);
|
||||
liballoc_unlock();
|
||||
return p;
|
||||
}
|
||||
}
|
||||
|
||||
min = min->next;
|
||||
}
|
||||
|
||||
#endif
|
||||
|
||||
#ifdef USE_CASE5
|
||||
|
||||
if (maj->next == NULL)
|
||||
{
|
||||
log("liballoc - (warning) CASE 5: block full");
|
||||
|
||||
if (startedBet == 1)
|
||||
{
|
||||
maj = l_memRoot;
|
||||
startedBet = 0;
|
||||
continue;
|
||||
}
|
||||
|
||||
maj->next = allocate_new_page(size);
|
||||
if (maj->next == NULL)
|
||||
break;
|
||||
maj->next->prev = maj;
|
||||
}
|
||||
|
||||
#endif
|
||||
|
||||
maj = maj->next;
|
||||
}
|
||||
|
||||
liballoc_unlock();
|
||||
|
||||
log("liballoc - (warning) All cases exhausted. No memory available.");
|
||||
log("liballoc - (warning) PREFIX(malloc)( %i ) returning NULL.", size);
|
||||
liballoc_dump();
|
||||
|
||||
return NULL;
|
||||
}
|
||||
|
||||
void PREFIX(free)(void *ptr)
|
||||
{
|
||||
struct liballoc_minor *min;
|
||||
struct liballoc_major *maj;
|
||||
|
||||
if (ptr == NULL)
|
||||
{
|
||||
l_warningCount += 1;
|
||||
log("liballoc - (warning) PREFIX(free)( NULL ) called from %x",
|
||||
__builtin_return_address(0));
|
||||
|
||||
return;
|
||||
}
|
||||
|
||||
UNALIGN(ptr);
|
||||
|
||||
liballoc_lock();
|
||||
|
||||
min = (struct liballoc_minor *)((uintptr_t)ptr - sizeof(struct liballoc_minor));
|
||||
|
||||
if (min->magic != LIBALLOC_MAGIC)
|
||||
{
|
||||
l_errorCount += 1;
|
||||
|
||||
if (
|
||||
((min->magic & 0xFFFFFF) == (LIBALLOC_MAGIC & 0xFFFFFF)) ||
|
||||
((min->magic & 0xFFFF) == (LIBALLOC_MAGIC & 0xFFFF)) ||
|
||||
((min->magic & 0xFF) == (LIBALLOC_MAGIC & 0xFF)))
|
||||
{
|
||||
l_possibleOverruns += 1;
|
||||
log("liballoc - (warning) Possible 1-3 byte overrun for magic %x != %x",
|
||||
min->magic,
|
||||
LIBALLOC_MAGIC);
|
||||
}
|
||||
|
||||
if (min->magic == LIBALLOC_DEAD)
|
||||
{
|
||||
log("liballoc - multiple PREFIX(free)() attempt on %x from %x.",
|
||||
ptr,
|
||||
__builtin_return_address(0));
|
||||
}
|
||||
else
|
||||
{
|
||||
log("liballoc - Bad PREFIX(free)( %x ) called from %x",
|
||||
ptr,
|
||||
__builtin_return_address(0));
|
||||
}
|
||||
|
||||
liballoc_unlock();
|
||||
return;
|
||||
}
|
||||
|
||||
log("liballoc - %x PREFIX(free)( %x ): ",
|
||||
__builtin_return_address(0),
|
||||
ptr);
|
||||
|
||||
maj = min->block;
|
||||
|
||||
l_inuse -= min->size;
|
||||
|
||||
maj->usage -= (min->size + sizeof(struct liballoc_minor));
|
||||
min->magic = LIBALLOC_DEAD;
|
||||
|
||||
if (min->next != NULL)
|
||||
min->next->prev = min->prev;
|
||||
if (min->prev != NULL)
|
||||
min->prev->next = min->next;
|
||||
|
||||
if (min->prev == NULL)
|
||||
maj->first = min->next;
|
||||
|
||||
if (maj->first == NULL)
|
||||
{
|
||||
if (l_memRoot == maj)
|
||||
l_memRoot = maj->next;
|
||||
if (l_bestBet == maj)
|
||||
l_bestBet = NULL;
|
||||
if (maj->prev != NULL)
|
||||
maj->prev->next = maj->next;
|
||||
if (maj->next != NULL)
|
||||
maj->next->prev = maj->prev;
|
||||
l_allocated -= maj->size;
|
||||
|
||||
liballoc_free(maj, maj->pages);
|
||||
}
|
||||
else
|
||||
{
|
||||
if (l_bestBet != NULL)
|
||||
{
|
||||
int bestSize = l_bestBet->size - l_bestBet->usage;
|
||||
int majSize = maj->size - maj->usage;
|
||||
|
||||
if (majSize > bestSize)
|
||||
l_bestBet = maj;
|
||||
}
|
||||
}
|
||||
|
||||
log("liballoc - (warning) OK");
|
||||
|
||||
liballoc_unlock();
|
||||
}
|
||||
|
||||
void *PREFIX(calloc)(size_t nobj, size_t size)
|
||||
{
|
||||
int real_size;
|
||||
void *p;
|
||||
|
||||
real_size = nobj * size;
|
||||
|
||||
p = PREFIX(malloc)(real_size);
|
||||
|
||||
liballoc_memset(p, 0, real_size);
|
||||
|
||||
return p;
|
||||
}
|
||||
|
||||
void *PREFIX(realloc)(void *p, size_t size)
|
||||
{
|
||||
void *ptr;
|
||||
struct liballoc_minor *min;
|
||||
unsigned int real_size;
|
||||
|
||||
if (size == 0)
|
||||
{
|
||||
PREFIX(free)
|
||||
(p);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
if (p == NULL)
|
||||
return PREFIX(malloc)(size);
|
||||
|
||||
ptr = p;
|
||||
UNALIGN(ptr);
|
||||
|
||||
liballoc_lock();
|
||||
|
||||
min = (struct liballoc_minor *)((uintptr_t)ptr - sizeof(struct liballoc_minor));
|
||||
|
||||
if (min->magic != LIBALLOC_MAGIC)
|
||||
{
|
||||
l_errorCount += 1;
|
||||
|
||||
if (
|
||||
((min->magic & 0xFFFFFF) == (LIBALLOC_MAGIC & 0xFFFFFF)) ||
|
||||
((min->magic & 0xFFFF) == (LIBALLOC_MAGIC & 0xFFFF)) ||
|
||||
((min->magic & 0xFF) == (LIBALLOC_MAGIC & 0xFF)))
|
||||
{
|
||||
l_possibleOverruns += 1;
|
||||
log("liballoc - Possible 1-3 byte overrun for magic %x != %x",
|
||||
min->magic,
|
||||
LIBALLOC_MAGIC);
|
||||
}
|
||||
|
||||
if (min->magic == LIBALLOC_DEAD)
|
||||
{
|
||||
log("liballoc - liballoc: multiple PREFIX(free)() attempt on %x from %x.",
|
||||
ptr,
|
||||
__builtin_return_address(0));
|
||||
}
|
||||
else
|
||||
{
|
||||
log("liballoc - liballoc: Bad PREFIX(free)( %x ) called from %x",
|
||||
ptr,
|
||||
__builtin_return_address(0));
|
||||
}
|
||||
|
||||
liballoc_unlock();
|
||||
return NULL;
|
||||
}
|
||||
|
||||
real_size = min->req_size;
|
||||
|
||||
if (real_size >= size)
|
||||
{
|
||||
min->req_size = size;
|
||||
liballoc_unlock();
|
||||
return p;
|
||||
}
|
||||
|
||||
liballoc_unlock();
|
||||
|
||||
ptr = PREFIX(malloc)(size);
|
||||
liballoc_memcpy(ptr, p, real_size);
|
||||
PREFIX(free)
|
||||
(p);
|
||||
|
||||
return ptr;
|
||||
}
|
||||
25
kernel/src/mm/liballoc/liballoc.h
Normal file
25
kernel/src/mm/liballoc/liballoc.h
Normal file
|
|
@ -0,0 +1,25 @@
|
|||
// Copyright: Durand Miller <clutter@djm.co.za>
|
||||
#ifndef LIBALLOC_H
|
||||
#define LIBALLOC_H
|
||||
|
||||
#include <stddef.h>
|
||||
#include <stdint.h>
|
||||
#include <sys/log.h>
|
||||
|
||||
#define PREFIX(func) k##func
|
||||
|
||||
#ifdef _DEBUG
|
||||
void liballoc_dump();
|
||||
#endif // _DEBUG
|
||||
|
||||
extern int liballoc_lock();
|
||||
extern int liballoc_unlock();
|
||||
extern void *liballoc_alloc(size_t);
|
||||
extern int liballoc_free(void *, size_t);
|
||||
|
||||
extern void *PREFIX(malloc)(size_t);
|
||||
extern void *PREFIX(realloc)(void *, size_t);
|
||||
extern void *PREFIX(calloc)(size_t, size_t);
|
||||
extern void PREFIX(free)(void *);
|
||||
|
||||
#endif // LIBALLOC_H
|
||||
39
kernel/src/mm/liballoc/liballoc_soaplin.c
Normal file
39
kernel/src/mm/liballoc/liballoc_soaplin.c
Normal file
|
|
@ -0,0 +1,39 @@
|
|||
#include "mm/liballoc/liballoc.h"
|
||||
#include "mm/vmm.h"
|
||||
#include <mm/vma.h>
|
||||
#include <lib/spinlock.h>
|
||||
#include <stddef.h>
|
||||
|
||||
extern vma_context_t *kernel_vma_context;
|
||||
|
||||
static spinlock_t liballoc_lock_var = { 0 };
|
||||
|
||||
int liballoc_lock()
|
||||
{
|
||||
spinlock_acquire(&liballoc_lock_var);
|
||||
return 0;
|
||||
}
|
||||
|
||||
int liballoc_unlock()
|
||||
{
|
||||
spinlock_release(&liballoc_lock_var);
|
||||
return 0;
|
||||
}
|
||||
|
||||
void *liballoc_alloc(size_t pages)
|
||||
{
|
||||
return vma_alloc(kernel_vma_context, pages, VMM_PRESENT | VMM_WRITABLE);
|
||||
}
|
||||
|
||||
int liballoc_free(void *ptr, size_t pages)
|
||||
{
|
||||
(void)pages;
|
||||
vma_free(kernel_vma_context, ptr);
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
extern void *malloc(size_t s) { return PREFIX(malloc)(s); }
|
||||
extern void *realloc(void *v, size_t s) { return PREFIX(realloc)(v, s); }
|
||||
extern void *calloc(size_t s1, size_t s) { return PREFIX(calloc)(s1, s); }
|
||||
extern void free(void *v) { return PREFIX(free)(v); }
|
||||
Loading…
Add table
Add a link
Reference in a new issue