LadybirdBrowser/ladybird
1
1
Fork 0
mirror of https://github.com/LadybirdBrowser/ladybird.git synced 2024-11-08 23:42:53 +03:00
Code Issues Packages Projects Releases Wiki Activity

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. :^)
*/
#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);