alloc: remove the slab alloctor for now

* I will soon (tm) make a more optimizing slab allocator then this junk
that a wrote a while ago.

Signed-off-by: Andy-Python-Programmer <[email protected]>

Author: Andy-Python-Programmer

src/aero_kernel/src/mem/alloc.rs

@@ -20,141 +20,22 @@
 use core::alloc;
 use core::alloc::{GlobalAlloc, Layout};
 
-use crate::utils::sync::Mutex;
-
 use super::paging::FRAME_ALLOCATOR;
 use super::vmalloc;
 use crate::mem::paging::*;
 
-#[repr(C)]
-struct SlabHeader {
-    ptr: *mut Slab,
-}
-
-/// The slab is the primary unit of currency in the slab allocator.
-struct Slab {
-    size: usize,
-    first_free: usize,
-}
-
-impl Slab {
-    const fn new(size: usize) -> Self {
-        Self {
-            size,
-            first_free: 0,
-        }
-    }
-
-    fn init(&mut self) {
-        let frame: PhysFrame<Size4KiB> = FRAME_ALLOCATOR
-            .allocate_frame()
-            .expect("slab_init: failed to allocate frame");
-
-        self.first_free = frame.start_address().as_hhdm_virt().as_u64() as usize;
-
-        let hdr_size = core::mem::size_of::<SlabHeader>() as u64;
-        let aligned_hdr_size = align_up(hdr_size, self.size as u64) as usize;
-
-        let avl_size = Size4KiB::SIZE as usize - aligned_hdr_size;
-
-        let slab_ptr = unsafe { &mut *(self.first_free as *mut SlabHeader) };
-        slab_ptr.ptr = self as *mut Slab;
-
-        self.first_free += aligned_hdr_size;
-
-        let arr_ptr = self.first_free as *mut usize;
-        let array = unsafe { core::slice::from_raw_parts_mut(arr_ptr, avl_size) };
-
-        // A slab is built by allocating a 4KiB page, placing the slab data at
-        // the end, and dividing the rest into equal-size buffers:
-        //
-        // ------------------------------------------------------
-        // | buffer | buffer | buffer | buffer | slab header
-        // ------------------------------------------------------
-        //                         one page
-        let max = avl_size / self.size - 1;
-        let fact = self.size / 8;
-
-        for i in 0..max {
-            unsafe {
-                array[i * fact] = array.as_ptr().add((i + 1) * fact) as usize;
-            }
-        }
-
-        array[max * fact] = 0;
-    }
-
-    fn alloc(&mut self) -> *mut u8 {
-        if self.first_free == 0 {
-            self.init();
-        }
-
-        let old_free = self.first_free as *mut usize;
-
-        unsafe {
-            self.first_free = *old_free;
-        }
-
-        old_free as *mut u8
-    }
-
-    fn dealloc(&mut self, ptr: *mut u8) {
-        if ptr == core::ptr::null_mut() {
-            panic!("dealloc: attempted to free a nullptr")
-        }
-
-        let new_head = ptr as *mut usize;
-
-        unsafe {
-            *new_head = self.first_free;
-        }
-
-        self.first_free = new_head as usize;
-    }
-}
-
-struct ProtectedAllocator {
-    slabs: [Slab; 10],
-}
-
-struct Allocator {
-    inner: Mutex<ProtectedAllocator>,
-}
+struct Allocator {}
 
 impl Allocator {
     const fn new() -> Self {
-        Self {
-            inner: Mutex::new(ProtectedAllocator {
-                slabs: [
-                    Slab::new(8),
-                    Slab::new(16),
-                    Slab::new(24),
-                    Slab::new(32),
-                    Slab::new(48),
-                    Slab::new(64),
-                    Slab::new(128),
-                    Slab::new(256),
-                    Slab::new(512),
-                    Slab::new(1024),
-                ],
-            }),
-        }
+        Self {}
     }
 
     fn alloc(&self, layout: Layout) -> *mut u8 {
-        let mut inner = self.inner.lock_irq();
-
-        let slab = inner
-            .slabs
-            .iter_mut()
-            .find(|slab| slab.size >= (8 + layout.size()));
-
-        if let Some(slab) = slab {
-            slab.alloc()
+        if layout.size() <= 4096 {
+            let frame: PhysFrame<Size4KiB> = FRAME_ALLOCATOR.allocate_frame().unwrap();
+            frame.start_address().as_hhdm_virt().as_mut_ptr()
         } else {
-            // the vmalloc allocator may require reverse dependency
-            core::mem::drop(inner);
-
             let size = align_up(layout.size() as _, Size4KiB::SIZE) / Size4KiB::SIZE;
 
             vmalloc::get_vmalloc()
@@ -172,12 +53,7 @@ impl Allocator {
             return;
         }
 
-        let slab_header = (ptr as usize & !(0xfff)) as *mut SlabHeader;
-
-        let slab_header = unsafe { &mut *slab_header };
-        let slab = unsafe { &mut *slab_header.ptr };
-
-        slab.dealloc(ptr);
+        // TODO: free the slab.
     }
 }
 

src/aero_kernel/src/mem/vmalloc.rs

@@ -26,6 +26,7 @@
 //! at [`VMALLOC_VIRT_START`] and ending at [`VMALLOC_VIRT_END`].
 
 use alloc::boxed::Box;
+use alloc::collections::VecDeque;
 use intrusive_collections::*;
 use spin::Once;
 
@@ -82,17 +83,17 @@ impl<'a> KeyAdapter<'a> for VmallocAreaAdaptor {
 intrusive_collections::intrusive_adapter!(VmallocAreaAdaptor = Box<VmallocArea>: VmallocArea { link: RBTreeLink });
 
 pub(super) struct Vmalloc {
-    free_list: RBTree<VmallocAreaAdaptor>,
+    free_list: VecDeque<VmallocArea>,
 }
 
 impl Vmalloc {
     fn new() -> Self {
         let mut this = Self {
-            free_list: RBTree::new(Default::default()),
+            free_list: VecDeque::new(),
         };
 
         this.free_list
-            .insert(box VmallocArea::new(VMALLOC_START, VMALLOC_MAX_SIZE));
+            .push_back(VmallocArea::new(VMALLOC_START, VMALLOC_MAX_SIZE));
 
         this
     }
@@ -101,10 +102,11 @@ impl Vmalloc {
         // +1: area for the guard page.
         let size_bytes = (npages + 1) * Size4KiB::SIZE as usize;
 
-        let area = self
+        let (i, area) = self
             .free_list
             .iter()
-            .find(|area| area.protected.lock().size >= size_bytes)?;
+            .enumerate()
+            .find(|(_, area)| area.protected.lock().size >= size_bytes)?;
 
         let mut area_p = area.protected.lock();
         let address = area_p.addr.clone();
@@ -117,11 +119,7 @@ impl Vmalloc {
             // from the free list.
             core::mem::drop(area_p); // unlock
 
-            let area_ptr = area as *const VmallocArea;
-
-            // SAFETY: The constructed pointer is a valid object that is in the tree,
-            let mut area_cursor = unsafe { self.free_list.cursor_mut_from_ptr(area_ptr) };
-            area_cursor.remove();
+            self.free_list.remove(i);
         }
 
         // subtract the size of the guard page since we are not required to allocate
@@ -174,8 +172,9 @@ impl Vmalloc {
             merge.addr = addr;
             merge.size += size;
         } else {
-            // the block cannot be merged, so add it to the free list.
-            self.free_list.insert(box VmallocArea::new(addr, size));
+            // We add it to the back of the free list since, its more likely
+            // to find larger free areas in the front of the list.
+            self.free_list.push_back(VmallocArea::new(addr, size));
         }
 
         // subtract the size of the guard page since its not mapped.