diff options
author | Andreas Kling <awesomekling@gmail.com> | 2019-04-03 14:41:40 +0200 |
---|---|---|
committer | Andreas Kling <awesomekling@gmail.com> | 2019-04-03 14:41:40 +0200 |
commit | 39fd81174eec44511a95d2db5db52bcabc930653 (patch) | |
tree | b3eb187e787576aa4a47d87c8c211acae569f89b /Kernel/kmalloc.cpp | |
parent | 5b296718d8b250ab976129097f03a7577ce9020d (diff) | |
download | serenity-39fd81174eec44511a95d2db5db52bcabc930653.zip |
Kernel: Tidy up kmalloc.cpp a tiny bit.
Diffstat (limited to 'Kernel/kmalloc.cpp')
-rw-r--r-- | Kernel/kmalloc.cpp | 76 |
1 files changed, 31 insertions, 45 deletions
diff --git a/Kernel/kmalloc.cpp b/Kernel/kmalloc.cpp index 7e448ce2f2..81bdd46737 100644 --- a/Kernel/kmalloc.cpp +++ b/Kernel/kmalloc.cpp @@ -3,13 +3,12 @@ * just to get going. Don't ever let anyone see this shit. :^) */ -#include "types.h" -#include "kmalloc.h" -#include "StdLib.h" -#include "i386.h" -#include "system.h" -#include "Process.h" -#include "Scheduler.h" +#include <Kernel/types.h> +#include <Kernel/kmalloc.h> +#include <Kernel/StdLib.h> +#include <Kernel/i386.h> +#include <Kernel/Process.h> +#include <Kernel/Scheduler.h> #include <AK/Assertions.h> #define SANITIZE_KMALLOC @@ -19,8 +18,8 @@ struct [[gnu::packed]] allocation_t { size_t nchunk; }; -#define CHUNK_SIZE 32 -#define POOL_SIZE (1024 * 1024) +#define CHUNK_SIZE 32 +#define POOL_SIZE (1024 * 1024) #define ETERNAL_BASE_PHYSICAL 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*)); size_t max_addr = (size_t)ptr + alignment; void* aligned_ptr = (void*)(max_addr - (max_addr % alignment)); - ((void**)aligned_ptr)[-1] = ptr; return aligned_ptr; } @@ -93,92 +91,80 @@ void* kmalloc_impl(size_t size) { InterruptDisabler disabler; - size_t chunks_needed, chunks_here, first_chunk; - size_t real_size; - 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); + // We need space for the allocation_t structure at the head of the block. + size_t real_size = size + sizeof(allocation_t); 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(); } - chunks_needed = real_size / CHUNK_SIZE; - if( real_size % CHUNK_SIZE ) - chunks_needed++; + size_t chunks_needed = real_size / CHUNK_SIZE; + if (real_size % CHUNK_SIZE) + ++chunks_needed; - chunks_here = 0; - first_chunk = 0; + size_t chunks_here = 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) { // Skip over completely full bucket. chunks_here = 0; continue; } // FIXME: This scan can be optimized further with LZCNT. - for( j = 0; j < 8; ++j ) - { - if( !(alloc_map[i] & (1<<j)) ) - { - if( chunks_here == 0 ) - { - /* Mark where potential allocation starts. */ + for (size_t j = 0; j < 8; ++j) { + if (!(alloc_map[i] & (1<<j))) { + if (chunks_here == 0) { + // Mark where potential allocation starts. 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)); byte *ptr = (byte *)a; ptr += sizeof(allocation_t); a->nchunk = chunks_needed; 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); } sum_alloc += a->nchunk * CHUNK_SIZE; - sum_free -= a->nchunk * CHUNK_SIZE; + sum_free -= a->nchunk * CHUNK_SIZE; #ifdef SANITIZE_KMALLOC memset(ptr, 0xbb, (a->nchunk * CHUNK_SIZE) - sizeof(allocation_t)); #endif return ptr; } - } - else - { - /* This is in use, so restart chunks_here counter. */ + } else { + // This is in use, so restart chunks_here counter. 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(); } void kfree(void *ptr) { - if( !ptr ) + if (!ptr) return; 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) alloc_map[k / 8] &= ~(1 << (k % 8)); sum_alloc -= a->nchunk * CHUNK_SIZE; - sum_free += a->nchunk * CHUNK_SIZE; + sum_free += a->nchunk * CHUNK_SIZE; #ifdef SANITIZE_KMALLOC memset(a, 0xaa, a->nchunk * CHUNK_SIZE); |