fix palloc pfree bitmap

Author: xor-bits

crates/arch-x86_64/src/vmm.rs

@@ -569,6 +569,7 @@ pub enum TryMapSizedError<T: PageSize> {
     Overflow,
     NotAligned,
     MapToError(MapToError<T>),
+    WrongSize,
 }
 
 fn try_map_sized<T>(
@@ -647,10 +648,8 @@ where
             // hyperion_log::debug!("already not mapped");
             Ok(())
         }
-        Err(_err) => {
-            // hyperion_log::error!("{err:?}");
-            panic!("{_err:?}");
-        }
+        Err(UnmapError::ParentEntryHugePage) => Err(TryMapSizedError::WrongSize),
+        Err(_err) => panic!("{_err:?}"),
     }
 }
 

crates/kernel/src/panic.rs

@@ -5,7 +5,7 @@ use core::panic::PanicInfo;
 #[cfg(not(test))]
 #[panic_handler]
 fn panic_handler(info: &PanicInfo) -> ! {
-    hyperion_log::println!("Kernel CPU {info}");
+    hyperion_log::error!("Kernel CPU {info}");
     // hyperion_backtrace::print_backtrace();
     hyperion_arch::done();
 }

crates/kernel/src/syscall.rs

@@ -191,15 +191,24 @@ pub fn palloc(args: &mut SyscallRegs) -> Result<usize> {
     }
 
     let frames = pmm::PFA.alloc(pages);
+
+    // debug!(
+    //     "mapping [{:?}..{:?}] to {:?}",
+    //     VirtAddr::new(alloc_bottom as _),
+    //     VirtAddr::new(alloc_top as _),
+    //     frames.physical_addr(),
+    // );
     active.address_space.page_map.map(
         VirtAddr::new(alloc_bottom as _)..VirtAddr::new(alloc_top as _),
         frames.physical_addr(),
         PageTableFlags::PRESENT | PageTableFlags::WRITABLE | PageTableFlags::USER_ACCESSIBLE,
     );
 
-    let page_bottom = alloc_bottom / 0x1000;
+    let page_bottom = frames.physical_addr().as_u64() as usize / 0x1000;
     for page in page_bottom..page_bottom + pages {
-        allocs.set(page, true).unwrap();
+        if allocs.set(page, true).is_none() {
+            panic!("alloc set page:{page} len:{}", allocs.len());
+        }
     }
 
     return Ok(alloc_bottom);
@@ -220,7 +229,11 @@ pub fn pfree(args: &mut SyscallRegs) -> Result<usize> {
     let active = hyperion_scheduler::process();
     let mut allocs = active.allocs.bitmap();
 
-    let page_bottom = alloc_bottom.as_u64() as usize / 0x1000;
+    let Some(palloc) = active.address_space.page_map.virt_to_phys(alloc_bottom) else {
+        return Err(Error::INVALID_ADDRESS);
+    };
+
+    let page_bottom = palloc.as_u64() as usize / 0x1000;
     for page in page_bottom..page_bottom + pages {
         if !allocs.get(page).unwrap() {
             return Err(Error::INVALID_ALLOC);
@@ -229,10 +242,6 @@ pub fn pfree(args: &mut SyscallRegs) -> Result<usize> {
         allocs.set(page, false).unwrap();
     }
 
-    let Some(palloc) = active.address_space.page_map.virt_to_phys(alloc_bottom) else {
-        return Err(Error::INVALID_ADDRESS);
-    };
-
     let frames = unsafe { PageFrame::new(palloc, pages) };
     pmm::PFA.free(frames);
     active

crates/kshell/src/shell.rs

@@ -594,9 +594,9 @@ impl Shell {
                 .collect();
             let args = &args[..];
 
-            hyperion_log::debug!("spawning \"{name}\" with args {args:?}");
+            hyperion_log::trace!("spawning \"{name}\" with args {args:?}");
 
-            hyperion_log::debug!(
+            hyperion_log::trace!(
                 "ELF file from: {}",
                 env!("CARGO_BIN_FILE_HYPERION_SAMPLE_ELF")
             );
@@ -609,7 +609,7 @@ impl Shell {
                 hyperion_log::debug!("entry point missing");
             }
         });
-        hyperion_log::debug!("spawning {name} done (PID:{pid})");
+        hyperion_log::trace!("spawning {name} done (PID:{pid})");
         pid
     }
 

crates/sample-elf/src/main.rs

@@ -6,14 +6,15 @@
 
 extern crate alloc;
 
-use alloc::boxed::Box;
+use alloc::{boxed::Box, format};
 use core::{
     alloc::GlobalAlloc,
     fmt::{self, Write},
     ptr::NonNull,
 };
 
 use hyperion_syscall::{
+    err::Result,
     net::{Protocol, SocketDomain, SocketType},
     *,
 };
@@ -24,43 +25,54 @@ mod io; // partial std::io
 
 //
 
-pub fn main(_args: CliArgs) {
-    // println!("sample app main");
-    // println!("args: {args:?}");
-
-    // for i in 1..13 {
-    //     if i == 2 || i == 8 {
-    //         continue;
-    //     }
-    //     println!("{:?}", unsafe { syscall_0(i) });
-    // }
+fn run_server() -> Result<()> {
+    let server = socket(SocketDomain::LOCAL, SocketType::STREAM, Protocol::LOCAL)?;
+    bind(server, "/dev/server.sock")?;
 
-    spawn(|| {
-        let server = socket(SocketDomain::LOCAL, SocketType::STREAM, Protocol::LOCAL).unwrap();
+    rename("local server")?;
 
-        bind(server, "/dev/server.sock").unwrap();
+    loop {
+        let conn = accept(server)?;
+        println!("connected");
 
-        let conn = accept(server).unwrap();
+        let mut i = 0usize;
+        spawn(move || loop {
+            let msg = format!("Hello {i}");
+            i += 1;
+            send(conn, msg.as_bytes(), 0).unwrap();
+        });
+    }
+}
 
-        println!("connected");
+fn run_client() -> Result<()> {
+    let client = socket(SocketDomain::LOCAL, SocketType::STREAM, Protocol::LOCAL)?;
+    connect(client, "/dev/server.sock")?;
 
-        send(conn, b"Hello", 0).unwrap();
-    });
+    rename("local client")?;
 
-    // wait for the server to be up
-    nanosleep(50_000_000);
+    println!("connected");
 
-    let client = socket(SocketDomain::LOCAL, SocketType::STREAM, Protocol::LOCAL).unwrap();
+    loop {
+        let mut buf = [0u8; 64];
+        let len = recv(client, &mut buf, 0)?;
 
-    connect(client, "/dev/server.sock").unwrap();
+        println!("got `{:?}`", core::str::from_utf8(&buf[..len]));
+    }
 
-    println!("connected");
+    Ok(())
+}
 
-    let mut buf = [0u8; 64];
-    let len = recv(client, &mut buf, 0).unwrap();
-    assert_eq!(&buf[..len], b"Hello");
+pub fn main(_args: CliArgs) {
+    let mut i = 0usize;
+    loop {
+        let msg = format!("Hello {i}");
+        i += 1;
+        println!("{msg}");
+    }
 
-    println!("got `{:?}`", core::str::from_utf8(&buf[..len]));
+    if run_server().is_err() {
+        run_client().unwrap();
+    }
 
     /* match args.iter().next().expect("arg0 to be present") {
         // busybox style single binary 'coreutils'

crates/scheduler/src/task.rs

@@ -3,6 +3,7 @@ use alloc::{
     boxed::Box,
     collections::BTreeMap,
     sync::{Arc, Weak},
+    vec,
     vec::Vec,
 };
 use core::{
@@ -122,9 +123,8 @@ impl PageAllocs {
     pub fn bitmap(&self) -> MutexGuard<Bitmap<'static>> {
         self.bitmap
             .call_once(|| {
-                let bitmap_alloc: Vec<u8> = (0..pmm::PFA.bitmap_len() / 8).map(|_| 0u8).collect();
-                let bitmap_alloc = Vec::leak(bitmap_alloc); // TODO: free
-                Mutex::new(Bitmap::new(bitmap_alloc))
+                let bitmap_alloc = vec![0u8; pmm::PFA.bitmap_len() / 8];
+                Mutex::new(Bitmap::new(Vec::leak(bitmap_alloc)))
             })
             .lock()
     }