0ct0pu5/ladybird
1
0
Fork 0
mirror of https://github.com/LadybirdBrowser/ladybird.git synced 2024-12-25 15:39:55 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions 9

Kernel: Tidy up kmalloc.cpp a tiny bit.

Browse source
This commit is contained in:
Andreas Kling 2019-04-03 14:41:40 +02:00
parent 5b296718d8
commit 39fd81174e
Notes: sideshowbarker 2024-07-19 14:50:20 +09:00 
Author: https://github.com/awesomekling
Commit: https://github.com/SerenityOS/serenity/commit/39fd81174ee
1 changed files with 31 additions and 45 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

76
Kernel/kmalloc.cpp
View file

@ -3,13 +3,12 @@
* just to get going. Don't ever let anyone see this shit. :^) * just to get going. Don't ever let anyone see this shit. :^)
*/ */
#include "types.h" #include <Kernel/types.h>
#include "kmalloc.h" #include <Kernel/kmalloc.h>
#include "StdLib.h" #include <Kernel/StdLib.h>
#include "i386.h" #include <Kernel/i386.h>
#include "system.h" #include <Kernel/Process.h>
#include "Process.h" #include <Kernel/Scheduler.h>
#include "Scheduler.h"
#include <AK/Assertions.h> #include <AK/Assertions.h>
#define SANITIZE_KMALLOC #define SANITIZE_KMALLOC
@ -19,8 +18,8 @@ struct [[gnu::packed]] allocation_t {
size_t nchunk; size_t nchunk;
}; };
#define CHUNK_SIZE 32 #define CHUNK_SIZE 32
#define POOL_SIZE (1024 * 1024) #define POOL_SIZE (1024 * 1024)
#define ETERNAL_BASE_PHYSICAL 0x100000 #define ETERNAL_BASE_PHYSICAL 0x100000
#define ETERNAL_RANGE_SIZE 0x100000 #define ETERNAL_RANGE_SIZE 0x100000
@ -71,7 +70,6 @@ void* kmalloc_aligned(size_t size, size_t alignment)
void* ptr = kmalloc(size + alignment + sizeof(void*)); void* ptr = kmalloc(size + alignment + sizeof(void*));
size_t max_addr = (size_t)ptr + alignment; size_t max_addr = (size_t)ptr + alignment;
void* aligned_ptr = (void*)(max_addr - (max_addr % alignment)); void* aligned_ptr = (void*)(max_addr - (max_addr % alignment));
((void**)aligned_ptr)[-1] = ptr; ((void**)aligned_ptr)[-1] = ptr;
return aligned_ptr; return aligned_ptr;
} }
@ -93,92 +91,80 @@ void* kmalloc_impl(size_t size)
{ {
InterruptDisabler disabler; InterruptDisabler disabler;
size_t chunks_needed, chunks_here, first_chunk; // We need space for the allocation_t structure at the head of the block.
size_t real_size; size_t real_size = size + sizeof(allocation_t);
size_t i, j, k;
/* We need space for the allocation_t structure at the head of the block. */
real_size = size + sizeof(allocation_t);
if (sum_free < real_size) { if (sum_free < real_size) {
kprintf("%s<%u> kmalloc(): PANIC! Out of memory (sucks, dude)\nsum_free=%u, real_size=%u\n", current->process().name().characters(), current->pid(), sum_free, real_size); kprintf("%s(%u) kmalloc(): PANIC! Out of memory (sucks, dude)\nsum_free=%u, real_size=%u\n", current->process().name().characters(), current->pid(), sum_free, real_size);
hang(); hang();
} }
chunks_needed = real_size / CHUNK_SIZE; size_t chunks_needed = real_size / CHUNK_SIZE;
if( real_size % CHUNK_SIZE ) if (real_size % CHUNK_SIZE)
chunks_needed++; ++chunks_needed;
chunks_here = 0; size_t chunks_here = 0;
first_chunk = 0; size_t first_chunk = 0;
for( i = 0; i < (POOL_SIZE / CHUNK_SIZE / 8); ++i ) for (size_t i = 0; i < (POOL_SIZE / CHUNK_SIZE / 8); ++i) {
{
if (alloc_map[i] == 0xff) { if (alloc_map[i] == 0xff) {
// Skip over completely full bucket. // Skip over completely full bucket.
chunks_here = 0; chunks_here = 0;
continue; continue;
} }
// FIXME: This scan can be optimized further with LZCNT. // FIXME: This scan can be optimized further with LZCNT.
for( j = 0; j < 8; ++j ) for (size_t j = 0; j < 8; ++j) {
{ if (!(alloc_map[i] & (1<<j))) {
if( !(alloc_map[i] & (1<<j)) ) if (chunks_here == 0) {
{ // Mark where potential allocation starts.
if( chunks_here == 0 )
{
/* Mark where potential allocation starts. */
first_chunk = i * 8 + j; first_chunk = i * 8 + j;
} }
chunks_here++; ++chunks_here;
if( chunks_here == chunks_needed ) if (chunks_here == chunks_needed) {
{
auto* a = (allocation_t *)(BASE_PHYSICAL + (first_chunk * CHUNK_SIZE)); auto* a = (allocation_t *)(BASE_PHYSICAL + (first_chunk * CHUNK_SIZE));
byte *ptr = (byte *)a; byte *ptr = (byte *)a;
ptr += sizeof(allocation_t); ptr += sizeof(allocation_t);
a->nchunk = chunks_needed; a->nchunk = chunks_needed;
a->start = first_chunk; a->start = first_chunk;
for( k = first_chunk; k < (first_chunk + chunks_needed); ++k ) for (size_t k = first_chunk; k < (first_chunk + chunks_needed); ++k) {
{
alloc_map[k / 8] |= 1 << (k % 8); alloc_map[k / 8] |= 1 << (k % 8);
} }
sum_alloc += a->nchunk * CHUNK_SIZE; sum_alloc += a->nchunk * CHUNK_SIZE;
sum_free -= a->nchunk * CHUNK_SIZE; sum_free -= a->nchunk * CHUNK_SIZE;
#ifdef SANITIZE_KMALLOC #ifdef SANITIZE_KMALLOC
memset(ptr, 0xbb, (a->nchunk * CHUNK_SIZE) - sizeof(allocation_t)); memset(ptr, 0xbb, (a->nchunk * CHUNK_SIZE) - sizeof(allocation_t));
#endif #endif
return ptr; return ptr;
} }
} } else {
else // This is in use, so restart chunks_here counter.
{
/* This is in use, so restart chunks_here counter. */
chunks_here = 0; chunks_here = 0;
} }
} }
} }
kprintf("%s<%u> kmalloc(): PANIC! Out of memory (no suitable block for size %u)\n", current->process().name().characters(), current->pid(), size); kprintf("%s(%u) kmalloc(): PANIC! Out of memory (no suitable block for size %u)\n", current->process().name().characters(), current->pid(), size);
hang(); hang();
} }
void kfree(void *ptr) void kfree(void *ptr)
{ {
if( !ptr ) if (!ptr)
return; return;
InterruptDisabler disabler; InterruptDisabler disabler;
allocation_t *a = (allocation_t *)((((byte *)ptr) - sizeof(allocation_t))); auto* a = (allocation_t*)((((byte*)ptr) - sizeof(allocation_t)));
for (size_t k = a->start; k < (a->start + a->nchunk); ++k) for (size_t k = a->start; k < (a->start + a->nchunk); ++k)
alloc_map[k / 8] &= ~(1 << (k % 8)); alloc_map[k / 8] &= ~(1 << (k % 8));
sum_alloc -= a->nchunk * CHUNK_SIZE; sum_alloc -= a->nchunk * CHUNK_SIZE;
sum_free += a->nchunk * CHUNK_SIZE; sum_free += a->nchunk * CHUNK_SIZE;
#ifdef SANITIZE_KMALLOC #ifdef SANITIZE_KMALLOC
memset(a, 0xaa, a->nchunk * CHUNK_SIZE); memset(a, 0xaa, a->nchunk * CHUNK_SIZE);