Cargo.lock

@@ -2,15 +2,6 @@
 # It is not intended for manual editing.
 version = 4
 
-[[package]]
-name = "acid_alloc"
-version = "0.1.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b28c4f9c0c9c9c8f1045f71a22fd5f7524f562c086f604929492ea410dae8348"
-dependencies = [
- "sptr",
-]
-
 [[package]]
 name = "acpi"
 version = "6.0.1"
@@ -131,7 +122,6 @@ dependencies = [
 name = "gila"
 version = "0.3.1"
 dependencies = [
- "acid_alloc",
  "acpi",
  "enumflags2",
  "fdt",
@@ -322,12 +312,6 @@ dependencies = [
  "lock_api",
 ]
 
-[[package]]
-name = "sptr"
-version = "0.2.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5cdeee85371b1ec1f4b305c91787271a39f56b66e673bdbd73b7742150de5b0e"
-
 [[package]]
 name = "syn"
 version = "2.0.106"

Cargo.toml

@@ -4,7 +4,6 @@ version = "0.3.1"
 edition = "2024"
 
 [dependencies]
-acid_alloc = { version = "0.1.0", features = ["alloc"] }
 acpi = { version = "6.0.1", optional = true }
 enumflags2 = "0.7.12"
 fdt = { git = "https://github.com/repnop/fdt", version = "0.2.0-alpha1", optional = true }

src/kernel/main.rs

@@ -3,6 +3,8 @@
 
 #![no_std]
 #![no_main]
+#![feature(allocator_api)]
+#![feature(str_from_raw_parts)]
 #![feature(abi_x86_interrupt)]
 
 mod arch;
@@ -15,12 +17,11 @@ mod log;
 mod memory;
 mod panic;
 mod process;
+#[macro_use]
 mod util;
 
 use arch::x86_64::interrupts::IDT;
-use arch::x86_64::serial::SerialPort;
 use boot::{BASE_REVISION, params, *};
-use constants::*;
 use log::*;
 use memory::alloc::{
     boxed::Box,
@@ -30,6 +31,8 @@ use memory::alloc::{
 };
 use params::*;
 
+use crate::arch::x86_64::serial::SerialPort;
+use crate::constants::*;
 use lazy_static::lazy_static;
 use limine::firmware_type::FirmwareType;
 use spin::mutex::Mutex;
@@ -138,6 +141,8 @@ unsafe extern "C" fn main() -> ! {
         log_info!("Hypervisor: {:?}", string.identify());
     }
 
+    SERIAL_3F8.lock().log_write("hi");
+
     loop {
         arch::asm::nop();
     }

src/kernel/memory.rs

@@ -5,7 +5,6 @@ use crate::boot::modules::MODULE_RESPONSE;
 use crate::boot::params::EXECUTABLE_FILE_RESPONSE;
 use crate::{LOGGER, LogLevel, format, log_info, log_trace};
 use alloc::string::String;
-
 use free_list::{AllocError, FreeList, PAGE_SIZE, PageRange};
 use lazy_static::lazy_static;
 use limine::response::MemoryMapResponse;
@@ -28,22 +27,6 @@ lazy_static! {
         .expect("Bootloader did not supply memory map");
 }
 
-pub fn round_up_to(multiple: usize, input: usize) -> usize {
-    if input.is_multiple_of(multiple) {
-        input
-    } else {
-        input - (input % multiple) + multiple
-    }
-}
-
-fn round_down_to(multiple: usize, input: usize) -> usize {
-    if input.is_multiple_of(multiple) {
-        input
-    } else {
-        input - (input % multiple)
-    }
-}
-
 pub fn deallocate_usable() -> Result<(), AllocError> {
     init_statics();
     let mut any_error: Option<AllocError> = None;
@@ -75,19 +58,31 @@ pub fn deallocate_hardware() -> Result<(), AllocError> {
             | (entry.entry_type == EntryType::FRAMEBUFFER)
         {
             if let Err(error) = {
-                let base: usize = round_down_to(PAGE_SIZE, entry.base as usize);
+                // Special handling for regions that are too small
-                let mut length = entry.length as usize + (entry.base as usize - base);
+                // TODO: fix
-                length = round_up_to(PAGE_SIZE, length);
+                let adjusted_base = if (entry.length as usize) < PAGE_SIZE {
-                let range = PageRange::from_start_len(base, length);
+                    entry.base as usize - (PAGE_SIZE - entry.length as usize)
+                } else {
+                    entry.base as usize
+                };
+                let adjusted_length = if (entry.length as usize) < PAGE_SIZE {
+                    PAGE_SIZE
+                } else {
+                    entry.length as usize
+                };
+                let range = PageRange::from_start_len(adjusted_base, adjusted_length);
+                log_trace!(
+                    "Deallocating 0x{:x} @ 0x{:x} hardware reserved memory",
+                    adjusted_length,
+                    adjusted_base
+                );
                 match range {
                     Ok(range_inner) => unsafe { HW_FREELIST.lock().deallocate(range_inner) },
                     Err(err) => {
                         log_error!(
-                            "Failed to convert range 0x{:x} @ 0x{:x} (original: 0x{:x} @ 0x{:x}): {}",
+                            "Failed to convert range 0x{:x} @ 0x{:x}: {}",
-                            length,
+                            adjusted_length,
-                            base,
+                            adjusted_base,
-                            entry.length,
-                            entry.base,
                             err
                         );
                         Ok(())
@@ -175,7 +170,6 @@ pub fn log_memory() {
         );
         log_trace!("Deallocating available memory...");
         let _ = deallocate_usable();
-        log_trace!("Deallocating hardware reserved memory...");
         let _ = deallocate_hardware();
         let free_bytes = { FREELIST.lock().free_space() };
         log_info!(

src/kernel/panic.rs

@@ -1,9 +1,11 @@
 // Copyright (c) 2025 shibedrill
 // SPDX-License-Identifier: GPL-3.0-or-later
 
+use core::arch::asm;
 use core::panic::*;
 
 use crate::format;
+
 use crate::{LOGGER, LogLevel};
 
 #[panic_handler]
@@ -12,6 +14,8 @@ pub fn panic(info: &PanicInfo) -> ! {
     // TODO: If any userspace facilities are still working, *attempt* to flush panic info and
     // logs to disk or whatever else. Then kill all processes and reboot.
     loop {
-        crate::arch::asm::nop();
+        unsafe {
+            asm!("nop");
+        }
     }
 }