summaryrefslogtreecommitdiff
path: root/Kernel/kmalloc.cpp
diff options
context:
space:
mode:
authorAndreas Kling <awesomekling@gmail.com>2019-04-03 14:41:40 +0200
committerAndreas Kling <awesomekling@gmail.com>2019-04-03 14:41:40 +0200
commit39fd81174eec44511a95d2db5db52bcabc930653 (patch)
treeb3eb187e787576aa4a47d87c8c211acae569f89b /Kernel/kmalloc.cpp
parent5b296718d8b250ab976129097f03a7577ce9020d (diff)
downloadserenity-39fd81174eec44511a95d2db5db52bcabc930653.zip
Kernel: Tidy up kmalloc.cpp a tiny bit.
Diffstat (limited to 'Kernel/kmalloc.cpp')
-rw-r--r--Kernel/kmalloc.cpp76
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);