RGBCube/serenity
1
Fork 0
mirror of https://github.com/RGBCube/serenity synced 2025-07-25 16:27:35 +00:00
Code Issues Activity Actions

Adapt kmalloc() for userspace.

Browse source 
A slightly more useful malloc() for userspace. The max allocation limit
is still 128 kB, but at least now free() is able to recycle memory.
This commit is contained in:
Andreas Kling 2018-11-19 00:53:02 +01:00
parent f5a0b6961c
commit 85649077cd
1 changed files with 122 additions and 36 deletions
Download patch file Download diff file Expand all files Collapse all files

158
LibC/stdlib.cpp
View file

@ -10,45 +10,130 @@
extern "C" { extern "C" {
// FIXME: This is a temporary malloc() implementation. It never frees anything, #define SANITIZE_LIBC_MALLOC
// and you can't allocate more than 128 kB total. #define MALLOC_SCRUB_BYTE 0x85
static const size_t mallocBudget = 131072; #define FREE_SCRUB_BYTE 0x82
static byte* nextptr = nullptr; struct MallocHeader {
static byte* endptr = nullptr; uint16_t magic;
uint16_t first_chunk_index;
uint16_t chunk_count;
uint16_t xorcheck;
};
void __malloc_init() #define MALLOC_MAGIC 0x0413 // happy birthday k
{ #define CHUNK_SIZE 32
nextptr = (byte*)mmap(nullptr, mallocBudget, PROT_READ | PROT_WRITE, MAP_ANONYMOUS | MAP_PRIVATE, 0, 0); #define POOL_SIZE 128 * 1024
endptr = nextptr + mallocBudget;
int rc = set_mmap_name(nextptr, mallocBudget, "malloc"); static const size_t malloc_budget = POOL_SIZE;
if (rc < 0) static byte s_malloc_map[POOL_SIZE / CHUNK_SIZE / 8];
perror("set_mmap_name failed"); static byte* s_malloc_pool;
}
static uint32_t s_malloc_sum_alloc = 0;
static uint32_t s_malloc_sum_free = POOL_SIZE;
void* malloc(size_t size) void* malloc(size_t size)
{ {
if ((nextptr + size) > endptr) { // We need space for the MallocHeader structure at the head of the block.
fprintf(stderr, "Unable to serve malloc() request with size %u\n", size); size_t real_size = size + sizeof(MallocHeader);
volatile char* crashme = (char*)0xc007d00d;
*crashme = 0; if (s_malloc_sum_free < real_size) {
fprintf(stderr, "malloc(): Out of memory\ns_malloc_sum_free=%u, real_size=%x\n", s_malloc_sum_free, real_size);
assert(false);
} }
byte* ret = nextptr;
nextptr += size; size_t chunks_needed = real_size / CHUNK_SIZE;
nextptr += 16; if (real_size % CHUNK_SIZE)
nextptr = (byte*)((dword)nextptr & 0xfffffff0); chunks_needed++;
return ret;
size_t chunks_here = 0;
size_t first_chunk = 0;
for (unsigned i = 0; i < (POOL_SIZE / CHUNK_SIZE / 8); ++i) {
if (s_malloc_map[i] == 0xff) {
// Skip over completely full bucket.
chunks_here = 0;
continue;
}
// FIXME: This scan can be optimized further with TZCNT.
for (unsigned j = 0; j < 8; ++j) {
// FIXME: Invert loop.
if (!(s_malloc_map[i] & (1<<j))) {
if (chunks_here == 0) {
// Mark where potential allocation starts.
first_chunk = i * 8 + j;
}
chunks_here++;
if (chunks_here == chunks_needed) {
auto* header = (MallocHeader*)(s_malloc_pool + (first_chunk * CHUNK_SIZE));
byte* ptr = ((byte*)header) + sizeof(MallocHeader);
header->chunk_count = chunks_needed;
header->first_chunk_index = first_chunk;
header->magic = MALLOC_MAGIC;
header->xorcheck = header->magic ^ header->first_chunk_index ^ header->chunk_count;
for (size_t k = first_chunk; k < (first_chunk + chunks_needed); ++k)
s_malloc_map[k / 8] |= 1 << (k % 8);
s_malloc_sum_alloc += header->chunk_count * CHUNK_SIZE;
s_malloc_sum_free -= header->chunk_count * CHUNK_SIZE;
#ifdef SANITIZE_LIBC_MALLOC
memset(ptr, MALLOC_SCRUB_BYTE, (header->chunk_count * CHUNK_SIZE) - sizeof(MallocHeader));
#endif
return ptr;
}
}
else
{
/* This is in use, so restart chunks_here counter. */
chunks_here = 0;
}
}
}
fprintf(stderr, "malloc(): Out of memory (no consecutive chunks found for size %u)\n", size);
volatile char* crashme = (char*)0xc007d00d;
*crashme = 0;
return nullptr;
} }
void free(void* ptr) void free(void *ptr)
{ {
if (!ptr) if (!ptr)
return; return;
#if 0
munmap(ptr, 4096); auto* header = (MallocHeader*)((((byte*)ptr) - sizeof(MallocHeader)));
if (header->magic != MALLOC_MAGIC) {
fprintf(stderr, "free() called on bad pointer %p, magic=%w\n", ptr, header->magic);
assert(false);
}
if (header->xorcheck != (header->magic ^ header->first_chunk_index ^ header->chunk_count)) {
fprintf(stderr, "free() called on bad pointer %p, xorcheck=%w\n", ptr, header->xorcheck);
assert(false);
}
for (unsigned i = header->first_chunk_index; i < (header->first_chunk_index + header->chunk_count); ++i)
s_malloc_map[i / 8] &= ~(1 << (i % 8));
s_malloc_sum_alloc -= header->chunk_count * CHUNK_SIZE;
s_malloc_sum_free += header->chunk_count * CHUNK_SIZE;
#ifdef SANITIZE_LIBC_MALLOC
memset(header, FREE_SCRUB_BYTE, header->chunk_count * CHUNK_SIZE);
#endif #endif
} }
void __malloc_init()
{
s_malloc_pool = (byte*)mmap(nullptr, malloc_budget, PROT_READ | PROT_WRITE, MAP_ANONYMOUS | MAP_PRIVATE, 0, 0);
int rc = set_mmap_name(s_malloc_pool, malloc_budget, "malloc pool");
if (rc < 0)
perror("set_mmap_name failed");
}
void* calloc(size_t nmemb, size_t) void* calloc(size_t nmemb, size_t)
{ {
(void) nmemb; (void) nmemb;
@ -58,9 +143,19 @@ void* calloc(size_t nmemb, size_t)
void* realloc(void *ptr, size_t size) void* realloc(void *ptr, size_t size)
{ {
// FIXME: This is broken as shit. auto* header = (MallocHeader*)((((byte*)ptr) - sizeof(MallocHeader)));
if (header->magic != MALLOC_MAGIC) {
fprintf(stderr, "realloc() called on bad pointer %p, magic=%w\n", ptr, header->magic);
assert(false);
}
if (header->xorcheck != (header->magic ^ header->first_chunk_index ^ header->chunk_count)) {
fprintf(stderr, "realloc() called on bad pointer %p, xorcheck=%w\n", ptr, header->xorcheck);
assert(false);
}
size_t old_size = header->chunk_count * CHUNK_SIZE;
auto* new_ptr = malloc(size); auto* new_ptr = malloc(size);
memcpy(new_ptr, ptr, size); memcpy(new_ptr, ptr, old_size);
return new_ptr; return new_ptr;
} }
@ -119,13 +214,4 @@ long atol(const char* str)
return atoi(str); return atoi(str);
} }
void __qsort(void *base, size_t nmemb, size_t size, int (*compar)(const void *, const void *))
{
(void) base;
(void) nmemb;
(void) size;
(void) compar;
assert(false);
}
} }