wash/rosetta
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

lib: c: combine libc and ulibc

Browse Source 
libc is now made up of several independent components, each of which is individually compiled into a static library.
they are then all combined into a single shared library.
This commit is contained in:
max 🍓
2026-03-06 20:12:58 +00:00
parent 267b893bf4
commit 68714fa0e5
33 changed files with 1695 additions and 8483 deletions
Download Patch File Download Diff File Expand all files Collapse all files

33
lib/libc/malloc/CMakeLists.txt Normal file
View File

@@ -0,0 +1,33 @@
set(source_dirs stdlib)
file(GLOB sources *.c *.h)
foreach (dir ${source_dirs})
file(GLOB dir_sources ${CMAKE_CURRENT_SOURCE_DIR}/${dir}/*.c)
file(GLOB dir_headers ${CMAKE_CURRENT_SOURCE_DIR}/${dir}/*.h)
set(sources ${sources} ${dir_sources})
set(headers ${headers} ${dir_headers})
endforeach (dir)
file(GLOB_RECURSE sub_headers ${CMAKE_CURRENT_SOURCE_DIR}/include/*.h)
set(headers ${headers} ${sub_headers})
set(component_sources ${sources} PARENT_SCOPE)
set(component_headers ${headers} PARENT_SCOPE)
set(component_public_include_dirs ${CMAKE_CURRENT_SOURCE_DIR}/include PARENT_SCOPE)
rosetta_add_library(STATIC
NAME libc-malloc
PUBLIC_INCLUDE_DIRS
${public_include_dirs}
${CMAKE_CURRENT_SOURCE_DIR}/include
SOURCES ${sources}
HEADERS ${headers})
sysroot_add_library(
NAME libc-malloc
HEADER_DIR /usr/include
LIB_DIR /usr/lib)
target_link_libraries(libc-malloc libc-core libmango)

112
lib/libc/malloc/heap.c Normal file
View File

@@ -0,0 +1,112 @@
#include "liballoc.h"
#include <heap/heap.h>
#include <mango/handle.h>
#include <mango/log.h>
#include <mango/status.h>
#include <mango/task.h>
#include <mango/vm.h>
#include <stdio.h>
#define HEAP_REGION_SIZE 0x40000000
#define HEAP_EXPAND_INCREMENT 0x100000
void *heap_alloc(heap_t *heap, size_t sz)
{
return _lbmalloc(heap, sz);
}
void *heap_realloc(heap_t *heap, void *p, size_t sz)
{
return _lbrealloc(heap, p, sz);
}
void *heap_calloc(heap_t *heap, size_t num, size_t itemsz)
{
return _lbcalloc(heap, num, itemsz);
}
void heap_free(heap_t *heap, void *p)
{
_lbfree(heap, p);
}
static kern_status_t init_heap_region(heap_t *heap)
{
kern_handle_t self, address_space;
task_self(&self);
task_get_address_space(self, &address_space);
kern_handle_close(self);
kern_status_t status = vm_region_create(
address_space,
"libc-heap",
9,
VM_REGION_ANY_OFFSET,
HEAP_REGION_SIZE,
VM_PROT_READ | VM_PROT_WRITE | VM_PROT_USER,
&heap->heap_region,
&heap->heap_base);
kern_handle_close(address_space);
if (status != KERN_OK) {
return status;
}
return KERN_OK;
}
static kern_status_t expand_heap(heap_t *heap)
{
kern_handle_t vmo;
kern_status_t status = vm_object_create(
"libc-heap-data",
14,
HEAP_EXPAND_INCREMENT,
VM_PROT_READ | VM_PROT_WRITE | VM_PROT_USER,
&vmo);
if (status != KERN_OK) {
return status;
}
virt_addr_t base = 0;
status = vm_region_map_relative(
heap->heap_region,
heap->heap_sys_alloc,
vmo,
0,
HEAP_EXPAND_INCREMENT,
VM_PROT_READ | VM_PROT_WRITE | VM_PROT_USER,
&base);
kern_handle_close(vmo);
heap->heap_sys_alloc += HEAP_EXPAND_INCREMENT;
return status;
}
void *heap_expand(heap_t *heap, size_t size)
{
kern_status_t status = KERN_OK;
if (heap->heap_region == KERN_HANDLE_INVALID) {
status = init_heap_region(heap);
}
if (status != KERN_OK) {
return NULL;
}
while (heap->heap_req_alloc + size > heap->heap_sys_alloc) {
status = expand_heap(heap);
if (status != KERN_OK) {
return NULL;
}
}
void *p = (void *)(heap->heap_base + heap->heap_req_alloc);
heap->heap_req_alloc += size;
return p;
}

16
lib/libc/malloc/include/heap/_liballoc.h Normal file
View File

@@ -0,0 +1,16 @@
#ifndef HEAP__LIBALLOC_H_
#define HEAP__LIBALLOC_H_
struct liballoc_major;
struct liballoc_minor;
#define HEAP_INIT \
{ \
.heap_region = KERN_HANDLE_INVALID, \
.heap_liballoc = { \
.l_pageSize = 4096, \
.l_pageCount = 16, \
}, \
}
#endif

50
lib/libc/malloc/include/heap/heap.h Normal file
View File

@@ -0,0 +1,50 @@
#ifndef HEAP_H_
#define HEAP_H_
#include <heap/_liballoc.h>
#include <mango/types.h>
#include <stddef.h>
typedef enum heap_result {
HEAP_OK = 0,
HEAP_ERR_NO_MEMORY,
HEAP_ERR_INVALID_ARGUMENT,
} heap_result_t;
typedef struct heap {
kern_handle_t heap_region;
/* amount of space requested from the heap by the user */
size_t heap_req_alloc;
/* amount of space requested from the system by the heap */
size_t heap_sys_alloc;
/* base address of the heap */
virt_addr_t heap_base;
union {
struct {
struct liballoc_major *l_memRoot;
struct liballoc_major *l_bestBet;
unsigned int l_pageSize;
unsigned int l_pageCount;
unsigned long long l_allocated;
unsigned long long l_inuse;
long long l_warningCount;
long long l_errorCount;
long long l_possibleOverruns;
} heap_liballoc;
};
} heap_t;
extern kern_status_t heap_init(heap_t *heap, size_t size);
extern kern_status_t heap_destroy(heap_t *heap);
extern void *heap_alloc(heap_t *heap, size_t sz);
extern void *heap_realloc(heap_t *heap, void *p, size_t sz);
extern void *heap_calloc(heap_t *heap, size_t num, size_t itemsz);
extern void heap_free(heap_t *heap, void *p);
extern void *heap_expand(heap_t *heap, size_t size);
#endif

834
lib/libc/malloc/liballoc.c Normal file
View File

@@ -0,0 +1,834 @@
#include "liballoc.h"
/** Durand's Amazing Super Duper Memory functions. */
#define VERSION "1.1"
#define ALIGNMENT \
16ul // 4ul ///< This is the byte alignment
// that memory must be allocated on. IMPORTANT for GTK and other
// stuff.
#define ALIGN_TYPE char /// unsigned char[16] /// unsigned short
#define ALIGN_INFO \
sizeof(ALIGN_TYPE) * 16 ///< Alignment information is stored right
///< before the pointer. This is the number of
///< bytes of information stored there.
#define USE_CASE1
#define USE_CASE2
#define USE_CASE3
#define USE_CASE4
#define USE_CASE5
/** This macro will conveniently align our pointer upwards */
#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
#if defined DEBUG || defined INFO
#include <stdio.h>
#include <stdlib.h>
#define FLUSH() fflush(stdout)
#endif
/** A structure found at the top of all system allocated
* memory blocks. It details the usage of the memory block.
*/
struct liballoc_major {
struct liballoc_major *prev; ///< Linked list information.
struct liballoc_major *next; ///< Linked list information.
unsigned int pages; ///< The number of pages in the block.
unsigned int size; ///< The number of pages in the block.
unsigned int usage; ///< The number of bytes used in the block.
struct liballoc_minor *first; ///< A pointer to the first allocated
///< memory in the block.
};
/** This is a structure found at the beginning of all
* sections in a major block which were allocated by a
* malloc, calloc, realloc call.
*/
struct liballoc_minor {
struct liballoc_minor *prev; ///< Linked list information.
struct liballoc_minor *next; ///< Linked list information.
struct liballoc_major *block; ///< The owning block. A pointer to the
///< major structure.
unsigned int magic; ///< A magic number to idenfity correctness.
unsigned int size; ///< The size of the memory allocated. Could be 1
///< byte or more.
unsigned int req_size; ///< The size of memory requested.
};
#if 0
static struct liballoc_major *l_memRoot
= NULL; ///< The root memory block acquired from the system.
static struct liballoc_major *l_bestBet
= NULL; ///< The major with the most free memory.
static unsigned int l_pageSize
= 4096; ///< The size of an individual page. Set up in liballoc_init.
static unsigned int l_pageCount = 16; ///< The number of pages to request per
///< chunk. Set up in liballoc_init.
static unsigned long long l_allocated
= 0; ///< Running total of allocated memory.
static unsigned long long l_inuse = 0; ///< Running total of used memory.
static long long l_warningCount = 0; ///< Number of warnings encountered
static long long l_errorCount = 0; ///< Number of actual errors
static long long l_possibleOverruns = 0; ///< Number of possible overruns
#endif
// *********** HELPER FUNCTIONS *******************************
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 defined DEBUG || defined INFO
static void liballoc_dump()
{
#ifdef DEBUG
struct liballoc_major *maj = l_memRoot;
struct liballoc_minor *min = NULL;
#endif
printf("liballoc: ------ Memory data ---------------\n");
printf("liballoc: System memory allocated: %i bytes\n", l_allocated);
printf("liballoc: Memory in used (malloc'ed): %i bytes\n", l_inuse);
printf("liballoc: Warning count: %i\n", l_warningCount);
printf("liballoc: Error count: %i\n", l_errorCount);
printf("liballoc: Possible overruns: %i\n", l_possibleOverruns);
#ifdef DEBUG
while (maj != NULL) {
printf("liballoc: %x: total = %i, used = %i\n",
maj,
maj->size,
maj->usage);
min = maj->first;
while (min != NULL) {
printf("liballoc: %x: %i bytes\n", min, min->size);
min = min->next;
}
maj = maj->next;
}
#endif
FLUSH();
}
#endif
#define CTX(n) (heap->heap_liballoc.n)
// ***************************************************************
static struct liballoc_major *allocate_new_page(heap_t *heap, unsigned int size)
{
unsigned int st;
struct liballoc_major *maj;
// This is how much space is required.
st = size + sizeof(struct liballoc_major);
st += sizeof(struct liballoc_minor);
// Perfect amount of space?
if ((st % CTX(l_pageSize)) == 0)
st = st / (CTX(l_pageSize));
else
st = st / (CTX(l_pageSize)) + 1;
// No, add the buffer.
// Make sure it's >= the minimum size.
if (st < CTX(l_pageCount))
st = CTX(l_pageCount);
maj = (struct liballoc_major *)liballoc_alloc(heap, st);
if (maj == NULL) {
CTX(l_warningCount) += 1;
#if defined DEBUG || defined INFO
printf("liballoc: WARNING: liballoc_alloc( %i ) return NULL\n",
st);
FLUSH();
#endif
return NULL; // uh oh, we ran out of memory.
}
maj->prev = NULL;
maj->next = NULL;
maj->pages = st;
maj->size = st * CTX(l_pageSize);
maj->usage = sizeof(struct liballoc_major);
maj->first = NULL;
CTX(l_allocated) += maj->size;
#ifdef DEBUG
printf("liballoc: Resource allocated %x of %i pages (%i bytes) for %i "
"size.\n",
maj,
st,
maj->size,
size);
printf("liballoc: Total memory usage = %i KB\n",
(int)((l_allocated / (1024))));
FLUSH();
#endif
return maj;
}
void *PREFIX(malloc)(heap_t *heap, 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;
// For alignment, we adjust size so there's enough space to align.
if (ALIGNMENT > 1) {
size += ALIGNMENT + ALIGN_INFO;
}
// So, ideally, we really want an alignment of 0 or 1 in order
// to save space.
liballoc_lock(heap);
if (size == 0) {
CTX(l_warningCount) += 1;
#if defined DEBUG || defined INFO
printf("liballoc: WARNING: alloc( 0 ) called from %x\n",
__builtin_return_address(0));
FLUSH();
#endif
liballoc_unlock(heap);
return PREFIX(malloc)(heap, 1);
}
if (CTX(l_memRoot) == NULL) {
#if defined DEBUG || defined INFO
#ifdef DEBUG
printf("liballoc: initialization of liballoc " VERSION "\n");
#endif
atexit(liballoc_dump);
FLUSH();
#endif
// This is the first time we are being used.
CTX(l_memRoot) = allocate_new_page(heap, size);
if (CTX(l_memRoot) == NULL) {
liballoc_unlock(heap);
#ifdef DEBUG
printf("liballoc: initial l_memRoot initialization "
"failed\n",
p);
FLUSH();
#endif
return NULL;
}
#ifdef DEBUG
printf("liballoc: set up first memory major %x\n", l_memRoot);
FLUSH();
#endif
}
#ifdef DEBUG
printf("liballoc: %x PREFIX(malloc)( %i ): ",
__builtin_return_address(0),
size);
FLUSH();
#endif
// Now we need to bounce through every major and find enough space....
maj = CTX(l_memRoot);
startedBet = 0;
// Start at the best bet....
if (CTX(l_bestBet) != NULL) {
bestSize = CTX(l_bestBet)->size - CTX(l_bestBet)->usage;
if (bestSize > (size + sizeof(struct liballoc_minor))) {
maj = CTX(l_bestBet);
startedBet = 1;
}
}
while (maj != NULL) {
diff = maj->size - maj->usage;
// free memory in the block
if (bestSize < diff) {
// Hmm.. this one has more memory then our bestBet.
// Remember!
CTX(l_bestBet) = maj;
bestSize = diff;
}
#ifdef USE_CASE1
// CASE 1: There is not enough space in this major block.
if (diff < (size + sizeof(struct liballoc_minor))) {
#ifdef DEBUG
printf("CASE 1: Insufficient space in block %x\n", maj);
FLUSH();
#endif
// Another major block next to this one?
if (maj->next != NULL) {
maj = maj->next; // Hop to that one.
continue;
}
if (startedBet == 1) // If we started at the best bet,
{ // let's start all over again.
maj = CTX(l_memRoot);
startedBet = 0;
continue;
}
// Create a new major block next to this one and...
maj->next = allocate_new_page(
heap,
size); // next one will be okay.
if (maj->next == NULL)
break; // no more memory.
maj->next->prev = maj;
maj = maj->next;
// .. fall through to CASE 2 ..
}
#endif
#ifdef USE_CASE2
// CASE 2: It's a brand new block.
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);
CTX(l_inuse) += size;
p = (void *)((uintptr_t)(maj->first)
+ sizeof(struct liballoc_minor));
ALIGN(p);
#ifdef DEBUG
printf("CASE 2: returning %x\n", p);
FLUSH();
#endif
liballoc_unlock(heap); // release the lock
return p;
}
#endif
#ifdef USE_CASE3
// CASE 3: Block in use and enough space at the start of the
// block.
diff = (uintptr_t)(maj->first);
diff -= (uintptr_t)maj;
diff -= sizeof(struct liballoc_major);
if (diff >= (size + sizeof(struct liballoc_minor))) {
// Yes, space in front. Squeeze in.
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);
CTX(l_inuse) += size;
p = (void *)((uintptr_t)(maj->first)
+ sizeof(struct liballoc_minor));
ALIGN(p);
#ifdef DEBUG
printf("CASE 3: returning %x\n", p);
FLUSH();
#endif
liballoc_unlock(heap); // release the lock
return p;
}
#endif
#ifdef USE_CASE4
// CASE 4: There is enough space in this block. But is it
// contiguous?
min = maj->first;
// Looping within the block now...
while (min != NULL) {
// CASE 4.1: End of minors in a block. Space from last
// and end?
if (min->next == NULL) {
// the rest of this block is free... is it big
// enough?
diff = (uintptr_t)(maj) + maj->size;
diff -= (uintptr_t)min;
diff -= sizeof(struct liballoc_minor);
diff -= min->size;
// minus already existing usage..
if (diff
>= (size + sizeof(struct liballoc_minor))) {
// yay....
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);
CTX(l_inuse) += size;
p = (void *)((uintptr_t)min
+ sizeof(struct
liballoc_minor));
ALIGN(p);
#ifdef DEBUG
printf("CASE 4.1: returning %x\n", p);
FLUSH();
#endif
liballoc_unlock(
heap); // release the lock
return p;
}
}
// CASE 4.2: Is there space between two minors?
if (min->next != NULL) {
// is the difference between here and next big
// enough?
diff = (uintptr_t)(min->next);
diff -= (uintptr_t)min;
diff -= sizeof(struct liballoc_minor);
diff -= min->size;
// minus our existing usage.
if (diff
>= (size + sizeof(struct liballoc_minor))) {
// yay......
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);
CTX(l_inuse) += size;
p = (void *)((uintptr_t)new_min
+ sizeof(struct
liballoc_minor));
ALIGN(p);
#ifdef DEBUG
printf("CASE 4.2: returning %x\n", p);
FLUSH();
#endif
liballoc_unlock(
heap); // release the lock
return p;
}
} // min->next != NULL
min = min->next;
} // while min != NULL ...
#endif
#ifdef USE_CASE5
// CASE 5: Block full! Ensure next block and loop.
if (maj->next == NULL) {
#ifdef DEBUG
printf("CASE 5: block full\n");
FLUSH();
#endif
if (startedBet == 1) {
maj = CTX(l_memRoot);
startedBet = 0;
continue;
}
// we've run out. we need more...
maj->next = allocate_new_page(
heap,
size); // next one guaranteed to be okay
if (maj->next == NULL)
break; // uh oh, no more memory.....
maj->next->prev = maj;
}
#endif
maj = maj->next;
} // while (maj != NULL)
liballoc_unlock(heap); // release the lock
#ifdef DEBUG
printf("All cases exhausted. No memory available.\n");
FLUSH();
#endif
#if defined DEBUG || defined INFO
printf("liballoc: WARNING: PREFIX(malloc)( %i ) returning NULL.\n",
size);
liballoc_dump();
FLUSH();
#endif
return NULL;
}
void PREFIX(free)(heap_t *heap, void *ptr)
{
struct liballoc_minor *min;
struct liballoc_major *maj;
if (ptr == NULL) {
CTX(l_warningCount) += 1;
#if defined DEBUG || defined INFO
printf("liballoc: WARNING: PREFIX(free)( NULL ) called from "
"%x\n",
__builtin_return_address(0));
FLUSH();
#endif
return;
}
UNALIGN(ptr);
liballoc_lock(heap); // lockit
min = (struct liballoc_minor *)((uintptr_t)ptr
- sizeof(struct liballoc_minor));
if (min->magic != LIBALLOC_MAGIC) {
CTX(l_errorCount) += 1;
// Check for overrun errors. For all bytes of LIBALLOC_MAGIC
if (((min->magic & 0xFFFFFF) == (LIBALLOC_MAGIC & 0xFFFFFF))
|| ((min->magic & 0xFFFF) == (LIBALLOC_MAGIC & 0xFFFF))
|| ((min->magic & 0xFF) == (LIBALLOC_MAGIC & 0xFF))) {
CTX(l_possibleOverruns) += 1;
#if defined DEBUG || defined INFO
printf("liballoc: ERROR: Possible 1-3 byte overrun for "
"magic %x != %x\n",
min->magic,
LIBALLOC_MAGIC);
FLUSH();
#endif
}
if (min->magic == LIBALLOC_DEAD) {
#if defined DEBUG || defined INFO
printf("liballoc: ERROR: multiple PREFIX(free)() "
"attempt on %x from %x.\n",
ptr,
__builtin_return_address(0));
FLUSH();
#endif
} else {
#if defined DEBUG || defined INFO
printf("liballoc: ERROR: Bad PREFIX(free)( %x ) called "
"from %x\n",
ptr,
__builtin_return_address(0));
FLUSH();
#endif
}
// being lied to...
liballoc_unlock(heap); // release the lock
return;
}
#ifdef DEBUG
printf("liballoc: %x PREFIX(free)( %x ): ",
__builtin_return_address(0),
ptr);
FLUSH();
#endif
maj = min->block;
CTX(l_inuse) -= min->size;
maj->usage -= (min->size + sizeof(struct liballoc_minor));
min->magic = LIBALLOC_DEAD; // No mojo.
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;
// Might empty the block. This was the first
// minor.
// We need to clean up after the majors now....
if (maj->first == NULL) // Block completely unused.
{
if (CTX(l_memRoot) == maj)
CTX(l_memRoot) = maj->next;
if (CTX(l_bestBet) == maj)
CTX(l_bestBet) = NULL;
if (maj->prev != NULL)
maj->prev->next = maj->next;
if (maj->next != NULL)
maj->next->prev = maj->prev;
CTX(l_allocated) -= maj->size;
liballoc_free(heap, maj, maj->pages);
} else {
if (CTX(l_bestBet) != NULL) {
int bestSize
= CTX(l_bestBet)->size - CTX(l_bestBet)->usage;
int majSize = maj->size - maj->usage;
if (majSize > bestSize)
CTX(l_bestBet) = maj;
}
}
#ifdef DEBUG
printf("OK\n");
FLUSH();
#endif
liballoc_unlock(heap); // release the lock
}
void *PREFIX(calloc)(heap_t *heap, size_t nobj, size_t size)
{
int real_size;
void *p;
real_size = nobj * size;
p = PREFIX(malloc)(heap, real_size);
liballoc_memset(p, 0, real_size);
return p;
}
void *PREFIX(realloc)(heap_t *heap, void *p, size_t size)
{
void *ptr;
struct liballoc_minor *min;
unsigned int real_size;
// Honour the case of size == 0 => free old and return NULL
if (size == 0) {
PREFIX(free)(heap, p);
return NULL;
}
// In the case of a NULL pointer, return a simple malloc.
if (p == NULL)
return PREFIX(malloc)(heap, size);
// Unalign the pointer if required.
ptr = p;
UNALIGN(ptr);
liballoc_lock(heap); // lockit
min = (struct liballoc_minor *)((uintptr_t)ptr
- sizeof(struct liballoc_minor));
// Ensure it is a valid structure.
if (min->magic != LIBALLOC_MAGIC) {
CTX(l_errorCount) += 1;
// Check for overrun errors. For all bytes of LIBALLOC_MAGIC
if (((min->magic & 0xFFFFFF) == (LIBALLOC_MAGIC & 0xFFFFFF))
|| ((min->magic & 0xFFFF) == (LIBALLOC_MAGIC & 0xFFFF))
|| ((min->magic & 0xFF) == (LIBALLOC_MAGIC & 0xFF))) {
CTX(l_possibleOverruns) += 1;
#if defined DEBUG || defined INFO
printf("liballoc: ERROR: Possible 1-3 byte overrun for "
"magic %x != %x\n",
min->magic,
LIBALLOC_MAGIC);
FLUSH();
#endif
}
if (min->magic == LIBALLOC_DEAD) {
#if defined DEBUG || defined INFO
printf("liballoc: ERROR: multiple PREFIX(free)() "
"attempt on %x from %x.\n",
ptr,
__builtin_return_address(0));
FLUSH();
#endif
} else {
#if defined DEBUG || defined INFO
printf("liballoc: ERROR: Bad PREFIX(free)( %x ) called "
"from %x\n",
ptr,
__builtin_return_address(0));
FLUSH();
#endif
}
// being lied to...
liballoc_unlock(heap); // release the lock
return NULL;
}
// Definitely a memory block.
real_size = min->req_size;
if (real_size >= size) {
min->req_size = size;
liballoc_unlock(heap);
return p;
}
liballoc_unlock(heap);
// If we got here then we're reallocating to a block bigger than us.
ptr = PREFIX(malloc)(heap, size); // We need to allocate new memory
liballoc_memcpy(ptr, p, real_size);
PREFIX(free)(heap, p);
return ptr;
}
int liballoc_lock(heap_t *heap)
{
/* TODO */
return 0;
}
int liballoc_unlock(heap_t *heap)
{
/* TODO */
return 0;
}
void *liballoc_alloc(heap_t *heap, size_t sz)
{
return heap_expand(heap, sz);
}
int liballoc_free(heap_t *heap, void *p, size_t sz)
{
/* TODO */
return 0;
}

76
lib/libc/malloc/liballoc.h Normal file
View File

@@ -0,0 +1,76 @@
#ifndef _LIBALLOC_H
#define _LIBALLOC_H
#include <heap/heap.h>
#include <stddef.h>
/** \defgroup ALLOCHOOKS liballoc hooks
*
* These are the OS specific functions which need to
* be implemented on any platform that the library
* is expected to work on.
*/
/** @{ */
// If we are told to not define our own size_t, then we skip the define.
// #define _HAVE_UINTPTR_T
// typedef unsigned long uintptr_t;
// This lets you prefix malloc and friends
#define PREFIX(func) _lb##func
#ifdef __cplusplus
extern "C" {
#endif
/** This function is supposed to lock the memory data structures. It
* could be as simple as disabling interrupts or acquiring a spinlock.
* It's up to you to decide.
*
* \return 0 if the lock was acquired successfully. Anything else is
* failure.
*/
extern int liballoc_lock(heap_t *);
/** This function unlocks what was previously locked by the liballoc_lock
* function. If it disabled interrupts, it enables interrupts. If it
* had acquiried a spinlock, it releases the spinlock. etc.
*
* \return 0 if the lock was successfully released.
*/
extern int liballoc_unlock(heap_t *);
/** This is the hook into the local system which allocates pages. It
* accepts an integer parameter which is the number of pages
* required. The page size was set up in the liballoc_init function.
*
* \return NULL if the pages were not allocated.
* \return A pointer to the allocated memory.
*/
extern void *liballoc_alloc(heap_t *, size_t);
/** This frees previously allocated memory. The void* parameter passed
* to the function is the exact same value returned from a previous
* liballoc_alloc call.
*
* The integer value is the number of pages to free.
*
* \return 0 if the memory was successfully freed.
*/
extern int liballoc_free(heap_t *, void *, size_t);
extern void *PREFIX(malloc)(heap_t *, size_t); ///< The standard function.
extern void *PREFIX(
realloc)(heap_t *, void *, size_t); ///< The standard function.
extern void *PREFIX(
calloc)(heap_t *, size_t, size_t); ///< The standard function.
extern void PREFIX(free)(heap_t *, void *); ///< The standard function.
#ifdef __cplusplus
}
#endif
/** @} */
#endif

44
lib/libc/malloc/stdlib/malloc.c Normal file
View File

@@ -0,0 +1,44 @@
#include <heap/heap.h>
#ifdef ENABLE_GLOBAL_HEAP
static heap_t global_heap = HEAP_INIT;
void *malloc(size_t count)
{
return heap_alloc(&global_heap, count);
}
void *calloc(size_t count, size_t size)
{
return heap_calloc(&global_heap, count, size);
}
void *realloc(void *p, size_t count)
{
return heap_realloc(&global_heap, p, count);
}
void free(void *p)
{
heap_free(&global_heap, p);
}
#else
void *malloc(size_t count)
{
return NULL;
}
void *calloc(size_t count, size_t size)
{
return NULL;
}
void *realloc(void *p, size_t count)
{
return NULL;
}
void free(void *p)
{
}
#endif