mirror of https://github.com/barzamin/sparkle
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
90 lines
2.6 KiB
90 lines
2.6 KiB
//! Bullshit naïve bump allocator for kernel heap testing
|
|
//! Lovingly ripped off from^W^W^W inspired by phil-opp's rust os articles
|
|
|
|
#![feature(const_fn)]
|
|
#![no_std]
|
|
|
|
|
|
#[derive(Debug)]
|
|
pub struct Heap {
|
|
/// Start of the heap we're allocating into.
|
|
heap_start: usize,
|
|
/// End of the heap we're allocating into.
|
|
heap_end: usize,
|
|
|
|
/// The next free address in the heap. Absolute address, *not* relative to `heap_start`!
|
|
next_addr: usize,
|
|
}
|
|
|
|
impl Heap {
|
|
/// Create a new allocator using the given range
|
|
/// [heap_start, heap_start+heap_size] for the heap
|
|
pub const fn new(heap_start: usize, heap_size: usize) -> Heap {
|
|
Heap {
|
|
heap_start: heap_start,
|
|
heap_end: heap_start + heap_size,
|
|
|
|
next_addr: heap_start,
|
|
}
|
|
}
|
|
|
|
/// Allocate a chunk of memory with (size, alignment)
|
|
pub fn allocate(&mut self, size: usize, align: usize) -> Option<*mut u8> {
|
|
let alloc_start = align_up(self.next_addr, align);
|
|
let alloc_end = alloc_start.saturating_add(size);
|
|
|
|
if alloc_end <= self.heap_end {
|
|
self.next_addr = alloc_end;
|
|
Some(alloc_start as *mut u8)
|
|
} else {
|
|
None
|
|
}
|
|
}
|
|
|
|
pub fn deallocate(&mut self, _ptr: *mut u8, _size: usize, _align: usize) {
|
|
// nothing! just leak
|
|
}
|
|
}
|
|
|
|
// unsafe impl Alloc for BumpAllocator {
|
|
// #[inline]
|
|
// unsafe fn alloc(&mut self, layout: Layout) -> Result<*mut u8, AllocErr> {
|
|
// self.allocate(layout.size(), layout.align()).ok_or(AllocErr::Exhausted {request: layout})
|
|
// }
|
|
|
|
// unsafe fn dealloc(&mut self, _ptr: *mut u8, _layout: Layout) {
|
|
// // just leak
|
|
// }
|
|
|
|
// fn oom(&mut self, err: AllocErr) -> ! {
|
|
// panic!("kheap OOM: {:?}!", err);
|
|
// }
|
|
|
|
// // Just copy the whole thing up to a new block
|
|
// unsafe fn realloc(&mut self, ptr: *mut u8, layout: Layout, new_layout: Layout) -> Result<*mut u8, AllocErr> {
|
|
|
|
// use core::{ptr, cmp};
|
|
|
|
// let copy_size = cmp::min(layout.size(), new_layout.size()); // copy len = min(size, size')
|
|
// let new_ptr = self.alloc(new_layout)?; // alloc new block
|
|
// ptr::copy(ptr, new_ptr, copy_size);
|
|
// self.dealloc(ptr, layout); // dealloc old pointer
|
|
|
|
// Ok(new_ptr)
|
|
// }
|
|
// }
|
|
|
|
pub fn align_down(addr: usize, align: usize) -> usize {
|
|
if align.is_power_of_two() {
|
|
// unset bits after alignment bit
|
|
addr & !(align - 1)
|
|
} else if align == 0 {
|
|
addr
|
|
} else {
|
|
panic!("`align` must be a power of 2");
|
|
}
|
|
}
|
|
|
|
pub fn align_up(addr: usize, align: usize) -> usize {
|
|
align_down(addr + align - 1, align)
|
|
}
|