From c57a75e1eccf84b19a55a80cd3a05a344125bf53 Mon Sep 17 00:00:00 2001 From: S A Date: Tue, 15 Apr 2025 00:28:24 -0500 Subject: [PATCH 01/15] initial file mmap --- crates/init/src/main.rs | 26 ++++++++++++++++++++++++++ crates/kernel/src/fs/initfs.rs | 21 ++++++++++++++++++++- crates/kernel/src/process/mem.rs | 3 ++- 3 files changed, 48 insertions(+), 2 deletions(-) diff --git a/crates/init/src/main.rs b/crates/init/src/main.rs index 43799843..cdfffa56 100644 --- a/crates/init/src/main.rs +++ b/crates/init/src/main.rs @@ -15,6 +15,32 @@ pub extern "C" fn main() { let root_fd = 3; let path = b"shell.elf"; let file = ulib::sys::openat(root_fd, path, 0, 0).unwrap(); + + let test_file_path = b"test.txt"; + let test_text_file = ulib::sys::openat(root_fd, test_file_path, 0, 0).unwrap(); + + static HELLO_CHARS: [u8; 5] = *b"hello"; + //TODO: add mmap options flags to ulib + let mmap_addr: *mut u8 = unsafe { ulib::sys::mmap(0, 4096, 0, 0, test_text_file, 0).unwrap() } as *mut u8; + println!("Memory range is mmaped!"); + /* + let mut val: usize = 0; + let val_ptr: *mut usize = &mut val; + //For debug + for i in 0..1000 { + let temp: usize = unsafe { val_ptr.read_volatile() }; + println!("Read val: {}", temp); + unsafe { val_ptr.write_volatile(temp + 1)}; + } + */ + for i in 0..5 { + let curr_char: u8 = unsafe { *(mmap_addr.wrapping_add(i)) }; + if curr_char != HELLO_CHARS[i] { + panic!("mmap filed file has an error at index {}! Expected {} got {}", i, HELLO_CHARS[i], curr_char); + } + } + + println!("mmap of test file succeeded!"); let child = spawn_elf(&ulib::sys::SpawnArgs { fd: file, diff --git a/crates/kernel/src/fs/initfs.rs b/crates/kernel/src/fs/initfs.rs index 51bad65b..b1763b0e 100644 --- a/crates/kernel/src/fs/initfs.rs +++ b/crates/kernel/src/fs/initfs.rs @@ -3,6 +3,7 @@ use alloc::sync::{Arc, Weak}; use alloc::vec::Vec; use initfs::{Archive, ArchiveError}; +use crate::arch::memory::palloc::{Size4KiB, PAGE_ALLOCATOR}; use crate::process::fd::{ boxed_future, ArcFd, DirEntry, FileDescResult, FileDescriptor, FileKind, SmallFuture, }; @@ -229,7 +230,25 @@ impl FileDescriptor for InitFsFile { } } fn mmap_page(&self, _offset: u64) -> SmallFuture> { - boxed_future(async move { None }) + if self.header.is_dir() { + return boxed_future(async move { None }); + } + + //File case, need to call read + boxed_future(async move { + let page = PAGE_ALLOCATOR.get().alloc_mapped_frame::(); + let page_paddr = page.paddr; + let page_virt = PAGE_ALLOCATOR.get().get_mapped_frame::(page); + let buf_ref = unsafe { core::slice::from_raw_parts_mut(page_virt as *mut u8, 4096) }; + match self.read(_offset, buf_ref).await.as_result() { + Ok(_val) => { + return Some(FileDescResult::ok(page_paddr as u64)); + }, + Err(_val) => { + return None; + }, + } + }) } fn as_any(&self) -> &dyn core::any::Any { self diff --git a/crates/kernel/src/process/mem.rs b/crates/kernel/src/process/mem.rs index 093cc187..d2eb3704 100644 --- a/crates/kernel/src/process/mem.rs +++ b/crates/kernel/src/process/mem.rs @@ -133,7 +133,8 @@ impl UserAddrSpace { return Err(MmapError::MemoryRangeCollision); } } - + + //TODO: take another look at the size here let node = MemoryRangeNode { start, size, kind }; self.memory_range_map.insert(start, node); Ok(start_addr) From 8de3b8490b8fc01d10bab9c573d2bc78333ffd90 Mon Sep 17 00:00:00 2001 From: S A Date: Wed, 16 Apr 2025 00:44:00 -0500 Subject: [PATCH 02/15] debug state for shared mem --- crates/init/src/main.rs | 84 ++++++++++++++++++++++++---- crates/kernel/examples/user.rs | 4 +- crates/kernel/src/fs/initfs.rs | 1 + crates/kernel/src/process/mem.rs | 26 +++++++-- crates/kernel/src/syscall/exec.rs | 4 +- crates/kernel/src/syscall/fb_hack.rs | 82 +++++++++++++++++++++++++++ crates/kernel/src/syscall/mmap.rs | 12 +++- crates/kernel/src/syscall/mod.rs | 2 +- crates/ulib/src/sys.rs | 2 + 9 files changed, 192 insertions(+), 25 deletions(-) diff --git a/crates/init/src/main.rs b/crates/init/src/main.rs index cdfffa56..239afe80 100644 --- a/crates/init/src/main.rs +++ b/crates/init/src/main.rs @@ -6,7 +6,20 @@ extern crate ulib; mod runtime; -use ulib::sys::spawn_elf; +use ulib::sys::{self, spawn_elf, sys_memfd_create, SpawnArgs}; + +static mut IS_CHILD: bool = false; + +fn set_indicator() { + unsafe { IS_CHILD = true }; +} + +//Shoud the ulib function be exposed to the user? +fn current_sp() -> usize { + let sp: usize; + unsafe { core::arch::asm!("mov {0}, sp", out(reg) sp) }; + sp +} #[unsafe(no_mangle)] pub extern "C" fn main() { @@ -23,16 +36,7 @@ pub extern "C" fn main() { //TODO: add mmap options flags to ulib let mmap_addr: *mut u8 = unsafe { ulib::sys::mmap(0, 4096, 0, 0, test_text_file, 0).unwrap() } as *mut u8; println!("Memory range is mmaped!"); - /* - let mut val: usize = 0; - let val_ptr: *mut usize = &mut val; - //For debug - for i in 0..1000 { - let temp: usize = unsafe { val_ptr.read_volatile() }; - println!("Read val: {}", temp); - unsafe { val_ptr.write_volatile(temp + 1)}; - } - */ + for i in 0..5 { let curr_char: u8 = unsafe { *(mmap_addr.wrapping_add(i)) }; if curr_char != HELLO_CHARS[i] { @@ -42,6 +46,64 @@ pub extern "C" fn main() { println!("mmap of test file succeeded!"); + unsafe { sys::munmap(mmap_addr as *mut ()).unwrap() }; + + ///* + println!("Starting shared memory test"); + + let shared_mem_fd = unsafe { sys_memfd_create() as u32 }; + let shared_frame = unsafe { ulib::sys::mmap(0, 4096, 0, 1 << 2, shared_mem_fd, 0) }.unwrap() as *mut u8; + let excl_ptr: *mut u8 = shared_frame.wrapping_add(6); + unsafe { excl_ptr.write('.' as u8) }; + + println!("Calling spawn"); + //TODO: double check this + let child_args = ulib::sys::SpawnArgs{ fd: 0, stdin: None, stdout: None }; + let args_ptr = &child_args as *const SpawnArgs; + //bad fork + let wait_fd = unsafe { ulib::sys::spawn(set_indicator as usize, current_sp(), args_ptr as usize, 0).unwrap() }; + + ///* + if unsafe { IS_CHILD } { + println!("In child"); + for _i in 0..100000 { + + if unsafe { excl_ptr.read_volatile() } != ('.' as u8) { + break; + } + } + + if unsafe { excl_ptr.read_volatile() } != ('!' as u8) { + ulib::sys::exit(5); + } + + for i in 0..5 { + let curr_char = unsafe { *shared_frame.wrapping_add(i) } as char; + if curr_char != (HELLO_CHARS[i] as char) { + println!("Child found wrong char at index {}. Expected {} found {}", i, (HELLO_CHARS[i] as char), curr_char); + ulib::sys::exit(5); + } + } + + println!("Child is done"); + ulib::sys::exit(0); + + } else { + println!("In parent"); + unsafe { + core::ptr::copy_nonoverlapping(&raw const HELLO_CHARS[0], shared_frame, HELLO_CHARS.len()); + shared_frame.wrapping_add(6).write('!' as u8); + } + + unsafe { excl_ptr.write('!' as u8) }; + let child_exit_val = ulib::sys::wait(wait_fd).unwrap(); + assert!(child_exit_val == 0); + + } + + //TODO: unmap shared frame + //*/ + let child = spawn_elf(&ulib::sys::SpawnArgs { fd: file, stdin: None, diff --git a/crates/kernel/examples/user.rs b/crates/kernel/examples/user.rs index 0959cf4d..6448f125 100644 --- a/crates/kernel/examples/user.rs +++ b/crates/kernel/examples/user.rs @@ -31,7 +31,7 @@ async fn main() { let user_region = process .mem .lock() - .mmap(Some(0x20_0000), user_region_len, MappingKind::Anon) + .mmap(Some(0x20_0000), user_region_len, MappingKind::Anon, false) .unwrap(); let mem = process.mem.lock(); @@ -92,7 +92,7 @@ async fn main() { Some(stack_start - stack_size), stack_size, MappingKind::Anon, - ) + false) .unwrap(); let user_sp = stack_start; diff --git a/crates/kernel/src/fs/initfs.rs b/crates/kernel/src/fs/initfs.rs index b1763b0e..a5eec76c 100644 --- a/crates/kernel/src/fs/initfs.rs +++ b/crates/kernel/src/fs/initfs.rs @@ -245,6 +245,7 @@ impl FileDescriptor for InitFsFile { return Some(FileDescResult::ok(page_paddr as u64)); }, Err(_val) => { + println!("Read failed"); return None; }, } diff --git a/crates/kernel/src/process/mem.rs b/crates/kernel/src/process/mem.rs index d2eb3704..960d9413 100644 --- a/crates/kernel/src/process/mem.rs +++ b/crates/kernel/src/process/mem.rs @@ -32,6 +32,7 @@ pub struct MemoryRangeNode { pub start: usize, pub size: usize, pub kind: MappingKind, + pub is_shared: bool, } #[derive(Clone)] @@ -78,10 +79,10 @@ impl UserAddrSpace { for (range_start, node) in &self.memory_range_map { let start = new_mem - .insert_vme_at(node.start, node.size, node.kind.clone()) + .insert_vme_at(node.start, node.size, node.kind.clone(), node.is_shared) .unwrap(); assert!(start == *range_start); - + for offset in (0..node.size).step_by(buf_size) { let chunk_size = (node.size - offset).min(buf_size); new_mem @@ -93,6 +94,11 @@ impl UserAddrSpace { .await .unwrap(); + if node.is_shared { + println!("Skipping over shared range"); + continue; + } + let src_data = node.start as *const u8; let dst_data = node.start as *mut u8; let buf_ptr: *mut u8 = buffer.as_mut_ptr().cast(); @@ -119,6 +125,7 @@ impl UserAddrSpace { start: usize, size: usize, kind: MappingKind, + is_shared: bool, ) -> Result { let start_addr = (start / PAGE_SIZE) * PAGE_SIZE; let size_pages = (size + (start - start_addr)).next_multiple_of(PAGE_SIZE); @@ -135,7 +142,7 @@ impl UserAddrSpace { } //TODO: take another look at the size here - let node = MemoryRangeNode { start, size, kind }; + let node = MemoryRangeNode { start, size, kind , is_shared }; self.memory_range_map.insert(start, node); Ok(start_addr) } @@ -164,12 +171,13 @@ impl UserAddrSpace { start_addr: Option, size: usize, kind: MappingKind, + is_shared: bool, ) -> Result { let start_addr = match start_addr { Some(s) => s, None => self.find_vme_space(size)?, }; - let base_addr = self.insert_vme_at(start_addr, size, kind)?; + let base_addr = self.insert_vme_at(start_addr, size, kind, is_shared)?; Ok(base_addr) } @@ -258,8 +266,14 @@ impl UserAddrSpace { let offset = vaddr - vme.start; let page = match fd.mmap_page(offset as u64).await.map(|r| r.as_result()) { Some(Ok(page)) => page, - Some(Err(_e)) => return Err(MmapError::FileError), - None => return Err(MmapError::FileError), + Some(Err(_e)) => { + println!("Error in mmap page"); + return Err(MmapError::FileError); + }, + None => { + println!("Mmap page returned none"); + return Err(MmapError::FileError); + }, }; let desc = LeafDescriptor::new(page as usize) .union(LeafDescriptor::UNPRIVILEGED_ACCESS) diff --git a/crates/kernel/src/syscall/exec.rs b/crates/kernel/src/syscall/exec.rs index 4f658c66..465cdd25 100644 --- a/crates/kernel/src/syscall/exec.rs +++ b/crates/kernel/src/syscall/exec.rs @@ -104,7 +104,7 @@ pub unsafe fn sys_execve_fd(ctx: &mut Context) -> *mut Context { let memsize = (phdr.p_memsz as usize).next_multiple_of(4096).max(4096); let base = new_mem - .mmap(Some(phdr.p_vaddr as usize), memsize, MappingKind::Anon) + .mmap(Some(phdr.p_vaddr as usize), memsize, MappingKind::Anon, false) .unwrap(); // TODO: figure out how to handle user page faults when in the kernel @@ -134,7 +134,7 @@ pub unsafe fn sys_execve_fd(ctx: &mut Context) -> *mut Context { Some(stack_start - stack_size), stack_size, MappingKind::Anon, - ) + false) .unwrap(); let old = core::mem::replace(&mut *proc.mem.lock(), new_mem); diff --git a/crates/kernel/src/syscall/fb_hack.rs b/crates/kernel/src/syscall/fb_hack.rs index 4abc6894..18bcd9dc 100644 --- a/crates/kernel/src/syscall/fb_hack.rs +++ b/crates/kernel/src/syscall/fb_hack.rs @@ -1,11 +1,14 @@ +use alloc::collections::btree_map::BTreeMap; use alloc::sync::Arc; +use crate::arch::memory::palloc::{PhysicalPage, Size4KiB, PAGE_ALLOCATOR}; use crate::arch::memory::vmm::PAGE_SIZE; use crate::device::mailbox::RawFB; use crate::device::MAILBOX; use crate::event::async_handler::{run_async_handler, run_event_handler, HandlerContext}; use crate::event::context::Context; use crate::process::fd; +use crate::sync::SpinLock; /// syscall sys_alloc_fb(width: usize, height: usize) -> (fd, buffer_size: usize, width: usize, height: usize, pitch: usize) pub unsafe fn sys_acquire_fb(ctx: &mut Context) -> *mut Context { @@ -62,6 +65,7 @@ impl fd::FileDescriptor for FramebufferFd { fd::boxed_future(async move { Err(1).into() }) } fn mmap_page(&self, offset: u64) -> fd::SmallFuture> { + println!("Inside of memfd mmap page"); let paddr_base = self.0.paddr; assert!(offset % PAGE_SIZE as u64 == 0); if offset >= self.0.size as u64 { @@ -86,3 +90,81 @@ pub unsafe fn sys_poll_key_event(ctx: &mut Context) -> *mut Context { context.resume_return(code) }) } + +pub unsafe fn sys_memfd_create(ctx: &mut Context) -> *mut Context { + run_async_handler(ctx, async move |context: HandlerContext<'_>| { + let proc = context.cur_process().unwrap(); + let fd = Arc::new(MemFd::new()); + let fd = proc.file_descriptors.lock().insert(fd); + context.resume_return(fd) + }) +} + +struct MemFd { + pages: SpinLock>>, +} + +impl MemFd { + fn new() -> Self { + println!("Creating new mem fd"); + Self { + pages: SpinLock::new(BTreeMap::new()), + } + } +} + +impl Drop for MemFd { + fn drop(&mut self) { + let alloc = PAGE_ALLOCATOR.get(); + let pages = core::mem::take(&mut *self.pages.lock()); + for (_, page) in pages { + alloc.dealloc_frame(page); + } + } +} + +impl fd::FileDescriptor for MemFd { + fn is_same_file(&self, other: &dyn fd::FileDescriptor) -> bool { + let other = other.as_any().downcast_ref::(); + other.map(|o| core::ptr::eq(self, o)).unwrap_or(false) + } + fn kind(&self) -> fd::FileKind { + fd::FileKind::Regular + } + fn read<'a>( + &'a self, + _offset: u64, + _buf: &'a mut [u8], + ) -> fd::SmallFuture<'a, fd::FileDescResult> { + // TODO: impl read + fd::boxed_future(async move { Err(1).into() }) + } + fn write<'a>( + &'a self, + _offset: u64, + _buf: &'a [u8], + ) -> fd::SmallFuture<'a, fd::FileDescResult> { + // TODO: impl write + fd::boxed_future(async move { Err(1).into() }) + } + fn size<'a>(&'a self) -> fd::SmallFuture<'a, fd::FileDescResult> { + // TODO: Is size well defined for memfd? + fd::boxed_future(async move { Err(1).into() }) + } + fn mmap_page(&self, offset: u64) -> fd::SmallFuture> { + assert!(offset % PAGE_SIZE as u64 == 0); + + let page_addr = { + let mut pages = self.pages.lock(); + let frame = pages + .entry(offset as usize) + .or_insert_with(|| PAGE_ALLOCATOR.get().alloc_frame()); + frame.paddr + }; + + fd::boxed_future(async move { Some(fd::FileDescResult::ok(page_addr as u64)) }) + } + fn as_any(&self) -> &dyn core::any::Any { + self + } +} diff --git a/crates/kernel/src/syscall/mmap.rs b/crates/kernel/src/syscall/mmap.rs index 88f9c9e3..8134f6d1 100644 --- a/crates/kernel/src/syscall/mmap.rs +++ b/crates/kernel/src/syscall/mmap.rs @@ -7,7 +7,8 @@ bitflags::bitflags! { } struct MmapFlags: u32 { const MAP_FIXED = 1 << 0; - const MAP_ANONYMOUS = 1 << 1; + const MAP_ANONYMOUS = 1 << 1; //if not set this indicates file + const MAP_SHARED = 1 << 2; //if not set indicates private mapping } } @@ -37,6 +38,7 @@ pub unsafe fn sys_mmap(ctx: &mut Context) -> *mut Context { run_async_handler(ctx, async move |mut context: HandlerContext<'_>| { let proc = context.cur_process().unwrap(); + let is_shared: bool = flags.contains(MmapFlags::MAP_SHARED); let kind = if flags.contains(MmapFlags::MAP_ANONYMOUS) { MappingKind::Anon @@ -48,13 +50,17 @@ pub unsafe fn sys_mmap(ctx: &mut Context) -> *mut Context { }; MappingKind::File(file) }; + + if is_shared { + println!("Shared mapping detected in mmap"); + } let res; if flags.contains(MmapFlags::MAP_FIXED) { - res = proc.mem.lock().mmap(Some(request_addr), request_size, kind); + res = proc.mem.lock().mmap(Some(request_addr), request_size, kind, is_shared); } else { // TODO: try to respect hint? - res = proc.mem.lock().mmap(None, request_size, kind); + res = proc.mem.lock().mmap(None, request_size, kind, is_shared); } match res { diff --git a/crates/kernel/src/syscall/mod.rs b/crates/kernel/src/syscall/mod.rs index 9634d28d..da4892ea 100644 --- a/crates/kernel/src/syscall/mod.rs +++ b/crates/kernel/src/syscall/mod.rs @@ -35,7 +35,7 @@ pub unsafe fn register_syscalls() { register_syscall_handler(21, time::sys_get_time_ms); register_syscall_handler(22, time::sys_sleep_ms); - + register_syscall_handler(24, fb_hack::sys_memfd_create); register_syscall_handler(23, fb_hack::sys_acquire_fb); register_syscall_handler(25, fb_hack::sys_poll_key_event); diff --git a/crates/ulib/src/sys.rs b/crates/ulib/src/sys.rs index bb8e9791..c5d5be35 100644 --- a/crates/ulib/src/sys.rs +++ b/crates/ulib/src/sys.rs @@ -88,6 +88,8 @@ syscall!(21 => pub fn sys_get_time_ms() -> usize); syscall!(22 => pub fn sys_sleep_ms(time: usize)); // syscall!(23 => pub fn sys_acquire_fb(width: usize, height: usize) -> (usize, usize, usize, usize, usize)); +syscall!(24 => pub fn sys_memfd_create() -> isize); + #[repr(C)] pub struct RawFB { pub fd: usize, From 0ac40f63854df8d6d65a8e5d58596e4be7e10841 Mon Sep 17 00:00:00 2001 From: S A Date: Thu, 17 Apr 2025 01:53:21 -0500 Subject: [PATCH 03/15] broken user fork --- crates/init/src/main.rs | 18 ++------ crates/kernel/src/process/mem.rs | 19 ++++++++ crates/kernel/src/syscall/fb_hack.rs | 4 +- crates/ulib/src/sys.rs | 67 ++++++++++++++++++++++++++++ 4 files changed, 91 insertions(+), 17 deletions(-) diff --git a/crates/init/src/main.rs b/crates/init/src/main.rs index 239afe80..c662140f 100644 --- a/crates/init/src/main.rs +++ b/crates/init/src/main.rs @@ -8,19 +8,6 @@ mod runtime; use ulib::sys::{self, spawn_elf, sys_memfd_create, SpawnArgs}; -static mut IS_CHILD: bool = false; - -fn set_indicator() { - unsafe { IS_CHILD = true }; -} - -//Shoud the ulib function be exposed to the user? -fn current_sp() -> usize { - let sp: usize; - unsafe { core::arch::asm!("mov {0}, sp", out(reg) sp) }; - sp -} - #[unsafe(no_mangle)] pub extern "C" fn main() { println!("Running in usermode! (parent)"); @@ -61,10 +48,11 @@ pub extern "C" fn main() { let child_args = ulib::sys::SpawnArgs{ fd: 0, stdin: None, stdout: None }; let args_ptr = &child_args as *const SpawnArgs; //bad fork - let wait_fd = unsafe { ulib::sys::spawn(set_indicator as usize, current_sp(), args_ptr as usize, 0).unwrap() }; + let wait_fd = unsafe { ulib::sys::sys_fork()}; ///* - if unsafe { IS_CHILD } { + + if wait_fd == 0 { println!("In child"); for _i in 0..100000 { diff --git a/crates/kernel/src/process/mem.rs b/crates/kernel/src/process/mem.rs index 960d9413..a0a0bdfd 100644 --- a/crates/kernel/src/process/mem.rs +++ b/crates/kernel/src/process/mem.rs @@ -93,7 +93,26 @@ impl UserAddrSpace { self.populate_range(node, node.start + offset, chunk_size) .await .unwrap(); + + /* + //TODO: debug this + + if let MappingKind::File(arc) = &node.kind { + println!("File mapping found"); + + if node.is_shared { + println!("memfd found"); + } + let any_val = arc as &dyn core::any::Any; + if any_val.downcast_ref::().is_some() { + println!("Skipping over shared range"); + continue; + } + } + */ + + //HACK: remove this if node.is_shared { println!("Skipping over shared range"); continue; diff --git a/crates/kernel/src/syscall/fb_hack.rs b/crates/kernel/src/syscall/fb_hack.rs index 18bcd9dc..6ce17055 100644 --- a/crates/kernel/src/syscall/fb_hack.rs +++ b/crates/kernel/src/syscall/fb_hack.rs @@ -65,7 +65,6 @@ impl fd::FileDescriptor for FramebufferFd { fd::boxed_future(async move { Err(1).into() }) } fn mmap_page(&self, offset: u64) -> fd::SmallFuture> { - println!("Inside of memfd mmap page"); let paddr_base = self.0.paddr; assert!(offset % PAGE_SIZE as u64 == 0); if offset >= self.0.size as u64 { @@ -100,7 +99,7 @@ pub unsafe fn sys_memfd_create(ctx: &mut Context) -> *mut Context { }) } -struct MemFd { +pub struct MemFd { pages: SpinLock>>, } @@ -152,6 +151,7 @@ impl fd::FileDescriptor for MemFd { fd::boxed_future(async move { Err(1).into() }) } fn mmap_page(&self, offset: u64) -> fd::SmallFuture> { + println!("Inside of memfd mmap page"); assert!(offset % PAGE_SIZE as u64 == 0); let page_addr = { diff --git a/crates/ulib/src/sys.rs b/crates/ulib/src/sys.rs index c5d5be35..b1468d66 100644 --- a/crates/ulib/src/sys.rs +++ b/crates/ulib/src/sys.rs @@ -127,6 +127,73 @@ syscall!(26 => pub fn sys_sem_create(value: usize) -> isize); syscall!(27 => pub fn sys_sem_up(fd: usize) -> isize); syscall!(28 => pub fn sys_sem_down(fd: usize) -> isize); +core::arch::global_asm!( + ".global {name}; {name}:", + "mov x0, lr", //Read link register value into x0 + "svc #{num}", + "ret", + name = sym sys_fork_helper, + num = const 5, +); +unsafe extern "C" { + fn sys_fork_helper(pc: usize, sp: usize, x0: usize, flags: usize) -> isize; +} + +//Should this save the frame pointer too? +core::arch::global_asm!( + ".global {name}; {name}:", + /* + "push {{x9}}", + "push {{x10}}", + "push {{x11}}", + "push {{x12}}", + "push {{x13}}", + "push {{x14}}", + "push {{x15}}", + "push {{x19}}", + "push {{x20}}", + "push {{x21}}", + "push {{x22}}", + "push {{x23}}", + "push {{x24}}", + "push {{x25}}", + "push {{x26}}", + "push {{x27}}", + "push {{x28}}", + */ + "push {{x9, x10, x11, x12, x13, x14, x15, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28}}", + "mov x1, sp", + "mov x2, 0", //child should get 0 + "mov x3, 0", + "bl sys_fork_helper", + "pop {{x28, x27, x26, x25, x24, x23, x22, x21, x20, x19, x15, x14, x13, x12, x11, x10, x9}}", + /* + "pop {{x28}}", + "pop {{x27}}", + "pop {{x26}}", + "pop {{x25}}", + "pop {{x24}}", + "pop {{x23}}", + "pop {{x22}}", + "pop {{x21}}", + "pop {{x20}}", + "pop {{x19}}", + "pop {{x15}}", + "pop {{x14}}", + "pop {{x13}}", + "pop {{x12}}", + "pop {{x11}}", + "pop {{x10}}", + "pop {{x9}}", + */ + "ret", + name = sym sys_fork, +); +unsafe extern "C" { + pub fn sys_fork() -> isize; +} + + /* * * * * * * * * * * * * * * * * * * */ /* Syscall wrappers */ /* * * * * * * * * * * * * * * * * * * */ From bea36645ebc2d1d858412704579001855a4d0256 Mon Sep 17 00:00:00 2001 From: S A Date: Thu, 17 Apr 2025 03:00:31 -0500 Subject: [PATCH 04/15] fork work --- crates/init/src/main.rs | 8 +--- crates/kernel/src/syscall/proc.rs | 2 + crates/ulib/src/sys.rs | 73 ++++++++++++++++++++++++++++++- 3 files changed, 75 insertions(+), 8 deletions(-) diff --git a/crates/init/src/main.rs b/crates/init/src/main.rs index c662140f..dc00ece6 100644 --- a/crates/init/src/main.rs +++ b/crates/init/src/main.rs @@ -43,12 +43,8 @@ pub extern "C" fn main() { let excl_ptr: *mut u8 = shared_frame.wrapping_add(6); unsafe { excl_ptr.write('.' as u8) }; - println!("Calling spawn"); - //TODO: double check this - let child_args = ulib::sys::SpawnArgs{ fd: 0, stdin: None, stdout: None }; - let args_ptr = &child_args as *const SpawnArgs; - //bad fork - let wait_fd = unsafe { ulib::sys::sys_fork()}; + println!("Calling fork"); + let wait_fd = unsafe { ulib::sys::sys_fork() } as u32; ///* diff --git a/crates/kernel/src/syscall/proc.rs b/crates/kernel/src/syscall/proc.rs index e5de6368..ad5cbd98 100644 --- a/crates/kernel/src/syscall/proc.rs +++ b/crates/kernel/src/syscall/proc.rs @@ -46,6 +46,8 @@ pub unsafe fn sys_spawn(ctx: &mut Context) -> *mut Context { let user_sp = ctx.regs[1]; let user_x0 = ctx.regs[2]; let flags = ctx.regs[3]; + + println!("In sys_spawn with user x0 value of {}", user_x0); run_async_handler(ctx, async move |context: HandlerContext<'_>| { let old_process = context.cur_process().unwrap(); diff --git a/crates/ulib/src/sys.rs b/crates/ulib/src/sys.rs index b1468d66..4b2b6092 100644 --- a/crates/ulib/src/sys.rs +++ b/crates/ulib/src/sys.rs @@ -160,14 +160,83 @@ core::arch::global_asm!( "push {{x26}}", "push {{x27}}", "push {{x28}}", - */ "push {{x9, x10, x11, x12, x13, x14, x15, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28}}", + */ + "sub sp, sp, #4", + "str x9, [sp]", + "sub sp, sp, #4", + "str x10, [sp]", + "sub sp, sp, #4", + "str x11, [sp]", + "sub sp, sp, #4", + "str x12, [sp]", + "sub sp, sp, #4", + "str x13, [sp]", + "sub sp, sp, #4", + "str x14, [sp]", + "sub sp, sp, #4", + "str x15, [sp]", + "sub sp, sp, #4", + "str x19, [sp]", + "sub sp, sp, #4", + "str x20, [sp]", + "sub sp, sp, #4", + "str x21, [sp]", + "sub sp, sp, #4", + "str x22, [sp]", + "sub sp, sp, #4", + "str x23, [sp]", + "sub sp, sp, #4", + "str x24, [sp]", + "sub sp, sp, #4", + "str x25, [sp]", + "sub sp, sp, #4", + "str x26, [sp]", + "sub sp, sp, #4", + "str x27, [sp]", + "sub sp, sp, #4", + "str x28, [sp]", "mov x1, sp", "mov x2, 0", //child should get 0 "mov x3, 0", "bl sys_fork_helper", - "pop {{x28, x27, x26, x25, x24, x23, x22, x21, x20, x19, x15, x14, x13, x12, x11, x10, x9}}", + "ldr x28, [sp]", + "add sp, sp, 4", + "ldr x27, [sp]", + "add sp, sp, 4", + "ldr x26, [sp]", + "add sp, sp, 4", + "ldr x25, [sp]", + "add sp, sp, 4", + "ldr x24, [sp]", + "add sp, sp, 4", + "ldr x23, [sp]", + "add sp, sp, 4", + "ldr x22, [sp]", + "add sp, sp, 4", + "ldr x21, [sp]", + "add sp, sp, 4", + "ldr x20, [sp]", + "add sp, sp, 4", + "ldr x19, [sp]", + "add sp, sp, 4", + "ldr x15, [sp]", + "add sp, sp, 4", + "ldr x14, [sp]", + "add sp, sp, 4", + "ldr x13, [sp]", + "add sp, sp, 4", + "ldr x12, [sp]", + "add sp, sp, 4", + "ldr x11, [sp]", + "add sp, sp, 4", + "ldr x10, [sp]", + "add sp, sp, 4", + "ldr x9, [sp]", + "add sp, sp, 4", + /* + "pop {{x28, x27, x26, x25, x24, x23, x22, x21, x20, x19, x15, x14, x13, x12, x11, x10, x9}}", "pop {{x28}}", "pop {{x27}}", "pop {{x26}}", From 5b63def8f513902df75cf23be09a5bc7b712d7c8 Mon Sep 17 00:00:00 2001 From: S A Date: Thu, 17 Apr 2025 03:19:01 -0500 Subject: [PATCH 05/15] oops we're not in 32 bit --- crates/ulib/src/sys.rs | 68 +++++++++++++++++++++--------------------- 1 file changed, 34 insertions(+), 34 deletions(-) diff --git a/crates/ulib/src/sys.rs b/crates/ulib/src/sys.rs index 4b2b6092..f6bf6f53 100644 --- a/crates/ulib/src/sys.rs +++ b/crates/ulib/src/sys.rs @@ -162,78 +162,78 @@ core::arch::global_asm!( "push {{x28}}", "push {{x9, x10, x11, x12, x13, x14, x15, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28}}", */ - "sub sp, sp, #4", + "sub sp, sp, #8", "str x9, [sp]", - "sub sp, sp, #4", + "sub sp, sp, #8", "str x10, [sp]", - "sub sp, sp, #4", + "sub sp, sp, #8", "str x11, [sp]", - "sub sp, sp, #4", + "sub sp, sp, #8", "str x12, [sp]", - "sub sp, sp, #4", + "sub sp, sp, #8", "str x13, [sp]", - "sub sp, sp, #4", + "sub sp, sp, #8", "str x14, [sp]", - "sub sp, sp, #4", + "sub sp, sp, #8", "str x15, [sp]", - "sub sp, sp, #4", + "sub sp, sp, #8", "str x19, [sp]", - "sub sp, sp, #4", + "sub sp, sp, #8", "str x20, [sp]", - "sub sp, sp, #4", + "sub sp, sp, #8", "str x21, [sp]", - "sub sp, sp, #4", + "sub sp, sp, #8", "str x22, [sp]", - "sub sp, sp, #4", + "sub sp, sp, #8", "str x23, [sp]", - "sub sp, sp, #4", + "sub sp, sp, #8", "str x24, [sp]", - "sub sp, sp, #4", + "sub sp, sp, #8", "str x25, [sp]", - "sub sp, sp, #4", + "sub sp, sp, #8", "str x26, [sp]", - "sub sp, sp, #4", + "sub sp, sp, #8", "str x27, [sp]", - "sub sp, sp, #4", + "sub sp, sp, #8", "str x28, [sp]", "mov x1, sp", "mov x2, 0", //child should get 0 "mov x3, 0", "bl sys_fork_helper", "ldr x28, [sp]", - "add sp, sp, 4", + "add sp, sp, #8", "ldr x27, [sp]", - "add sp, sp, 4", + "add sp, sp, #8", "ldr x26, [sp]", - "add sp, sp, 4", + "add sp, sp, #8", "ldr x25, [sp]", - "add sp, sp, 4", + "add sp, sp, #8", "ldr x24, [sp]", - "add sp, sp, 4", + "add sp, sp, #8", "ldr x23, [sp]", - "add sp, sp, 4", + "add sp, sp, #8", "ldr x22, [sp]", - "add sp, sp, 4", + "add sp, sp, #8", "ldr x21, [sp]", - "add sp, sp, 4", + "add sp, sp, #8", "ldr x20, [sp]", - "add sp, sp, 4", + "add sp, sp, #8", "ldr x19, [sp]", - "add sp, sp, 4", + "add sp, sp, #8", "ldr x15, [sp]", - "add sp, sp, 4", + "add sp, sp, #8", "ldr x14, [sp]", - "add sp, sp, 4", + "add sp, sp, #8", "ldr x13, [sp]", - "add sp, sp, 4", + "add sp, sp, #8", "ldr x12, [sp]", - "add sp, sp, 4", + "add sp, sp, #8", "ldr x11, [sp]", - "add sp, sp, 4", + "add sp, sp, #8", "ldr x10, [sp]", - "add sp, sp, 4", + "add sp, sp, #8", "ldr x9, [sp]", - "add sp, sp, 4", + "add sp, sp, #8", /* "pop {{x28, x27, x26, x25, x24, x23, x22, x21, x20, x19, x15, x14, x13, x12, x11, x10, x9}}", From ec5e83645a758611b56c72699b6155ac5c794c89 Mon Sep 17 00:00:00 2001 From: S A Date: Thu, 17 Apr 2025 14:23:06 -0500 Subject: [PATCH 06/15] fork but it races --- crates/init/src/main.rs | 10 ++++++---- crates/ulib/src/sys.rs | 28 ++++++++-------------------- 2 files changed, 14 insertions(+), 24 deletions(-) diff --git a/crates/init/src/main.rs b/crates/init/src/main.rs index dc00ece6..db42d73f 100644 --- a/crates/init/src/main.rs +++ b/crates/init/src/main.rs @@ -56,8 +56,10 @@ pub extern "C" fn main() { break; } } - - if unsafe { excl_ptr.read_volatile() } != ('!' as u8) { + + let end_val: u8 = unsafe { excl_ptr.read_volatile() }; + if end_val != ('!' as u8) { + println!("Error: child expected to see ! with val {} and instead found {}", ('!' as u8), end_val); ulib::sys::exit(5); } @@ -81,8 +83,8 @@ pub extern "C" fn main() { unsafe { excl_ptr.write('!' as u8) }; let child_exit_val = ulib::sys::wait(wait_fd).unwrap(); - assert!(child_exit_val == 0); - + assert_eq!(child_exit_val, 0); + println!("Parent received exit code 0 from child, all is good"); } //TODO: unmap shared frame diff --git a/crates/ulib/src/sys.rs b/crates/ulib/src/sys.rs index f6bf6f53..4939a629 100644 --- a/crates/ulib/src/sys.rs +++ b/crates/ulib/src/sys.rs @@ -142,26 +142,6 @@ unsafe extern "C" { //Should this save the frame pointer too? core::arch::global_asm!( ".global {name}; {name}:", - /* - "push {{x9}}", - "push {{x10}}", - "push {{x11}}", - "push {{x12}}", - "push {{x13}}", - "push {{x14}}", - "push {{x15}}", - "push {{x19}}", - "push {{x20}}", - "push {{x21}}", - "push {{x22}}", - "push {{x23}}", - "push {{x24}}", - "push {{x25}}", - "push {{x26}}", - "push {{x27}}", - "push {{x28}}", - "push {{x9, x10, x11, x12, x13, x14, x15, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28}}", - */ "sub sp, sp, #8", "str x9, [sp]", "sub sp, sp, #8", @@ -196,10 +176,18 @@ core::arch::global_asm!( "str x27, [sp]", "sub sp, sp, #8", "str x28, [sp]", + "sub sp, sp, #8", + "str x29, [sp]", + "sub sp, sp, #8", + "str x30, [sp]", "mov x1, sp", "mov x2, 0", //child should get 0 "mov x3, 0", "bl sys_fork_helper", + "ldr x30, [sp]", + "add sp, sp, #8", + "ldr x29, [sp]", + "add sp, sp, #8", "ldr x28, [sp]", "add sp, sp, #8", "ldr x27, [sp]", From 0903e6507fed3a71af31c5c96e22733912314475 Mon Sep 17 00:00:00 2001 From: S A Date: Thu, 17 Apr 2025 22:39:16 -0500 Subject: [PATCH 07/15] fix to fork race condition --- crates/init/src/main.rs | 26 +++++++-------- crates/kernel/src/syscall/fb_hack.rs | 2 -- crates/kernel/src/syscall/proc.rs | 2 -- crates/ulib/src/sys.rs | 49 ---------------------------- 4 files changed, 11 insertions(+), 68 deletions(-) diff --git a/crates/init/src/main.rs b/crates/init/src/main.rs index db42d73f..6d5fe8b3 100644 --- a/crates/init/src/main.rs +++ b/crates/init/src/main.rs @@ -6,7 +6,7 @@ extern crate ulib; mod runtime; -use ulib::sys::{self, spawn_elf, sys_memfd_create, SpawnArgs}; +use ulib::sys::{self, spawn_elf, sys_memfd_create}; #[unsafe(no_mangle)] pub extern "C" fn main() { @@ -35,31 +35,29 @@ pub extern "C" fn main() { unsafe { sys::munmap(mmap_addr as *mut ()).unwrap() }; - ///* println!("Starting shared memory test"); let shared_mem_fd = unsafe { sys_memfd_create() as u32 }; let shared_frame = unsafe { ulib::sys::mmap(0, 4096, 0, 1 << 2, shared_mem_fd, 0) }.unwrap() as *mut u8; - let excl_ptr: *mut u8 = shared_frame.wrapping_add(6); - unsafe { excl_ptr.write('.' as u8) }; + let end_ptr: *mut u8 = shared_frame.wrapping_add(6); + unsafe { end_ptr.write_volatile('.' as u8) }; + assert_eq!(unsafe { end_ptr.read_volatile() }, '.' as u8); println!("Calling fork"); let wait_fd = unsafe { ulib::sys::sys_fork() } as u32; - ///* - if wait_fd == 0 { - println!("In child"); - for _i in 0..100000 { + + for _i in 0..1000000 { - if unsafe { excl_ptr.read_volatile() } != ('.' as u8) { + if unsafe { end_ptr.read_volatile() } == ('!' as u8) { break; } } - - let end_val: u8 = unsafe { excl_ptr.read_volatile() }; + + let end_val: u8 = unsafe { end_ptr.read_volatile() }; if end_val != ('!' as u8) { - println!("Error: child expected to see ! with val {} and instead found {}", ('!' as u8), end_val); + println!("Error: child expected to see '!' with val {} and instead found {}", ('!' as u8), end_val); ulib::sys::exit(5); } @@ -75,20 +73,18 @@ pub extern "C" fn main() { ulib::sys::exit(0); } else { - println!("In parent"); + unsafe { core::ptr::copy_nonoverlapping(&raw const HELLO_CHARS[0], shared_frame, HELLO_CHARS.len()); shared_frame.wrapping_add(6).write('!' as u8); } - unsafe { excl_ptr.write('!' as u8) }; let child_exit_val = ulib::sys::wait(wait_fd).unwrap(); assert_eq!(child_exit_val, 0); println!("Parent received exit code 0 from child, all is good"); } //TODO: unmap shared frame - //*/ let child = spawn_elf(&ulib::sys::SpawnArgs { fd: file, diff --git a/crates/kernel/src/syscall/fb_hack.rs b/crates/kernel/src/syscall/fb_hack.rs index 6ce17055..1db58f70 100644 --- a/crates/kernel/src/syscall/fb_hack.rs +++ b/crates/kernel/src/syscall/fb_hack.rs @@ -105,7 +105,6 @@ pub struct MemFd { impl MemFd { fn new() -> Self { - println!("Creating new mem fd"); Self { pages: SpinLock::new(BTreeMap::new()), } @@ -151,7 +150,6 @@ impl fd::FileDescriptor for MemFd { fd::boxed_future(async move { Err(1).into() }) } fn mmap_page(&self, offset: u64) -> fd::SmallFuture> { - println!("Inside of memfd mmap page"); assert!(offset % PAGE_SIZE as u64 == 0); let page_addr = { diff --git a/crates/kernel/src/syscall/proc.rs b/crates/kernel/src/syscall/proc.rs index ad5cbd98..e7b9b592 100644 --- a/crates/kernel/src/syscall/proc.rs +++ b/crates/kernel/src/syscall/proc.rs @@ -47,8 +47,6 @@ pub unsafe fn sys_spawn(ctx: &mut Context) -> *mut Context { let user_x0 = ctx.regs[2]; let flags = ctx.regs[3]; - println!("In sys_spawn with user x0 value of {}", user_x0); - run_async_handler(ctx, async move |context: HandlerContext<'_>| { let old_process = context.cur_process().unwrap(); diff --git a/crates/ulib/src/sys.rs b/crates/ulib/src/sys.rs index 4939a629..d8bb4592 100644 --- a/crates/ulib/src/sys.rs +++ b/crates/ulib/src/sys.rs @@ -143,20 +143,6 @@ unsafe extern "C" { core::arch::global_asm!( ".global {name}; {name}:", "sub sp, sp, #8", - "str x9, [sp]", - "sub sp, sp, #8", - "str x10, [sp]", - "sub sp, sp, #8", - "str x11, [sp]", - "sub sp, sp, #8", - "str x12, [sp]", - "sub sp, sp, #8", - "str x13, [sp]", - "sub sp, sp, #8", - "str x14, [sp]", - "sub sp, sp, #8", - "str x15, [sp]", - "sub sp, sp, #8", "str x19, [sp]", "sub sp, sp, #8", "str x20, [sp]", @@ -208,41 +194,6 @@ core::arch::global_asm!( "add sp, sp, #8", "ldr x19, [sp]", "add sp, sp, #8", - "ldr x15, [sp]", - "add sp, sp, #8", - "ldr x14, [sp]", - "add sp, sp, #8", - "ldr x13, [sp]", - "add sp, sp, #8", - "ldr x12, [sp]", - "add sp, sp, #8", - "ldr x11, [sp]", - "add sp, sp, #8", - "ldr x10, [sp]", - "add sp, sp, #8", - "ldr x9, [sp]", - "add sp, sp, #8", - - /* - "pop {{x28, x27, x26, x25, x24, x23, x22, x21, x20, x19, x15, x14, x13, x12, x11, x10, x9}}", - "pop {{x28}}", - "pop {{x27}}", - "pop {{x26}}", - "pop {{x25}}", - "pop {{x24}}", - "pop {{x23}}", - "pop {{x22}}", - "pop {{x21}}", - "pop {{x20}}", - "pop {{x19}}", - "pop {{x15}}", - "pop {{x14}}", - "pop {{x13}}", - "pop {{x12}}", - "pop {{x11}}", - "pop {{x10}}", - "pop {{x9}}", - */ "ret", name = sym sys_fork, ); From f32d8b8cbb7a2dd3e2c75acfbfb1f155d0ca0290 Mon Sep 17 00:00:00 2001 From: S A Date: Thu, 17 Apr 2025 23:16:19 -0500 Subject: [PATCH 08/15] fork assembly cleanup --- crates/ulib/src/sys.rs | 64 ++++++++++-------------------------------- 1 file changed, 15 insertions(+), 49 deletions(-) diff --git a/crates/ulib/src/sys.rs b/crates/ulib/src/sys.rs index d8bb4592..17853780 100644 --- a/crates/ulib/src/sys.rs +++ b/crates/ulib/src/sys.rs @@ -139,61 +139,27 @@ unsafe extern "C" { fn sys_fork_helper(pc: usize, sp: usize, x0: usize, flags: usize) -> isize; } -//Should this save the frame pointer too? +//saves and restores callee saved registers core::arch::global_asm!( ".global {name}; {name}:", - "sub sp, sp, #8", - "str x19, [sp]", - "sub sp, sp, #8", - "str x20, [sp]", - "sub sp, sp, #8", - "str x21, [sp]", - "sub sp, sp, #8", - "str x22, [sp]", - "sub sp, sp, #8", - "str x23, [sp]", - "sub sp, sp, #8", - "str x24, [sp]", - "sub sp, sp, #8", - "str x25, [sp]", - "sub sp, sp, #8", - "str x26, [sp]", - "sub sp, sp, #8", - "str x27, [sp]", - "sub sp, sp, #8", - "str x28, [sp]", - "sub sp, sp, #8", - "str x29, [sp]", - "sub sp, sp, #8", - "str x30, [sp]", + "sub sp, sp, #0x60", + "stp x19, x20, [sp, #0x50]", + "stp x21, x22, [sp, #0x40]", + "stp x23, x24, [sp, #0x30]", + "stp x25, x26, [sp, #0x20]", + "stp x27, x28, [sp, #0x10]", + "stp x29, x30, [sp]", "mov x1, sp", "mov x2, 0", //child should get 0 "mov x3, 0", "bl sys_fork_helper", - "ldr x30, [sp]", - "add sp, sp, #8", - "ldr x29, [sp]", - "add sp, sp, #8", - "ldr x28, [sp]", - "add sp, sp, #8", - "ldr x27, [sp]", - "add sp, sp, #8", - "ldr x26, [sp]", - "add sp, sp, #8", - "ldr x25, [sp]", - "add sp, sp, #8", - "ldr x24, [sp]", - "add sp, sp, #8", - "ldr x23, [sp]", - "add sp, sp, #8", - "ldr x22, [sp]", - "add sp, sp, #8", - "ldr x21, [sp]", - "add sp, sp, #8", - "ldr x20, [sp]", - "add sp, sp, #8", - "ldr x19, [sp]", - "add sp, sp, #8", + "ldp x29, x30, [sp]", + "ldp x27, x28, [sp, #0x10]", + "ldp x25, x26, [sp, #0x20]", + "ldp x23, x24, [sp, #0x30]", + "ldp x21, x22, [sp, #0x40]", + "ldp x19, x20, [sp, #0x50]", + "add sp, sp, #0x60", "ret", name = sym sys_fork, ); From a86fcbefc79b147a0fa63502c3e261c8e77d964d Mon Sep 17 00:00:00 2001 From: S A Date: Fri, 18 Apr 2025 02:11:52 -0500 Subject: [PATCH 09/15] replaced mmap shared flag with check for memfd --- crates/kernel/examples/user.rs | 6 ++--- crates/kernel/src/process/mem.rs | 41 +++++++++++-------------------- crates/kernel/src/syscall/exec.rs | 6 ++--- crates/kernel/src/syscall/mmap.rs | 6 +++-- 4 files changed, 24 insertions(+), 35 deletions(-) diff --git a/crates/kernel/examples/user.rs b/crates/kernel/examples/user.rs index 6448f125..aa945cd8 100644 --- a/crates/kernel/examples/user.rs +++ b/crates/kernel/examples/user.rs @@ -31,7 +31,7 @@ async fn main() { let user_region = process .mem .lock() - .mmap(Some(0x20_0000), user_region_len, MappingKind::Anon, false) + .mmap(Some(0x20_0000), user_region_len, MappingKind::Anon) .unwrap(); let mem = process.mem.lock(); @@ -91,8 +91,8 @@ async fn main() { .mmap( Some(stack_start - stack_size), stack_size, - MappingKind::Anon, - false) + MappingKind::Anon + ) .unwrap(); let user_sp = stack_start; diff --git a/crates/kernel/src/process/mem.rs b/crates/kernel/src/process/mem.rs index a0a0bdfd..818d6a13 100644 --- a/crates/kernel/src/process/mem.rs +++ b/crates/kernel/src/process/mem.rs @@ -12,6 +12,9 @@ use crate::event::async_handler::{run_async_handler, HandlerContext}; use crate::event::context::{deschedule_thread, Context, DescheduleAction}; use crate::event::exceptions::DataAbortISS; +use crate::process::fd::FileDescriptor; +use crate::syscall::fb_hack::MemFd; + use super::fd::ArcFd; #[derive(Debug)] @@ -32,7 +35,6 @@ pub struct MemoryRangeNode { pub start: usize, pub size: usize, pub kind: MappingKind, - pub is_shared: bool, } #[derive(Clone)] @@ -41,6 +43,7 @@ pub enum MappingKind { File(ArcFd), } + impl UserAddrSpace { pub fn new() -> Self { let table = alloc_top_page_table(); @@ -79,7 +82,7 @@ impl UserAddrSpace { for (range_start, node) in &self.memory_range_map { let start = new_mem - .insert_vme_at(node.start, node.size, node.kind.clone(), node.is_shared) + .insert_vme_at(node.start, node.size, node.kind.clone()) .unwrap(); assert!(start == *range_start); @@ -93,31 +96,17 @@ impl UserAddrSpace { self.populate_range(node, node.start + offset, chunk_size) .await .unwrap(); - - /* - //TODO: debug this - + + //Don't want to copy data in shared mem if let MappingKind::File(arc) = &node.kind { - println!("File mapping found"); - - if node.is_shared { - println!("memfd found"); - } - - let any_val = arc as &dyn core::any::Any; - if any_val.downcast_ref::().is_some() { - println!("Skipping over shared range"); + + if let Some(_s) = arc.as_any().downcast_ref::() { + println!("Skipping over shared range the right way"); continue; } + } - */ - - //HACK: remove this - if node.is_shared { - println!("Skipping over shared range"); - continue; - } - + let src_data = node.start as *const u8; let dst_data = node.start as *mut u8; let buf_ptr: *mut u8 = buffer.as_mut_ptr().cast(); @@ -144,7 +133,6 @@ impl UserAddrSpace { start: usize, size: usize, kind: MappingKind, - is_shared: bool, ) -> Result { let start_addr = (start / PAGE_SIZE) * PAGE_SIZE; let size_pages = (size + (start - start_addr)).next_multiple_of(PAGE_SIZE); @@ -161,7 +149,7 @@ impl UserAddrSpace { } //TODO: take another look at the size here - let node = MemoryRangeNode { start, size, kind , is_shared }; + let node = MemoryRangeNode { start, size, kind }; self.memory_range_map.insert(start, node); Ok(start_addr) } @@ -190,13 +178,12 @@ impl UserAddrSpace { start_addr: Option, size: usize, kind: MappingKind, - is_shared: bool, ) -> Result { let start_addr = match start_addr { Some(s) => s, None => self.find_vme_space(size)?, }; - let base_addr = self.insert_vme_at(start_addr, size, kind, is_shared)?; + let base_addr = self.insert_vme_at(start_addr, size, kind)?; Ok(base_addr) } diff --git a/crates/kernel/src/syscall/exec.rs b/crates/kernel/src/syscall/exec.rs index 465cdd25..9b0017fa 100644 --- a/crates/kernel/src/syscall/exec.rs +++ b/crates/kernel/src/syscall/exec.rs @@ -104,7 +104,7 @@ pub unsafe fn sys_execve_fd(ctx: &mut Context) -> *mut Context { let memsize = (phdr.p_memsz as usize).next_multiple_of(4096).max(4096); let base = new_mem - .mmap(Some(phdr.p_vaddr as usize), memsize, MappingKind::Anon, false) + .mmap(Some(phdr.p_vaddr as usize), memsize, MappingKind::Anon) .unwrap(); // TODO: figure out how to handle user page faults when in the kernel @@ -133,8 +133,8 @@ pub unsafe fn sys_execve_fd(ctx: &mut Context) -> *mut Context { .mmap( Some(stack_start - stack_size), stack_size, - MappingKind::Anon, - false) + MappingKind::Anon + ) .unwrap(); let old = core::mem::replace(&mut *proc.mem.lock(), new_mem); diff --git a/crates/kernel/src/syscall/mmap.rs b/crates/kernel/src/syscall/mmap.rs index 8134f6d1..841b6f2a 100644 --- a/crates/kernel/src/syscall/mmap.rs +++ b/crates/kernel/src/syscall/mmap.rs @@ -38,6 +38,7 @@ pub unsafe fn sys_mmap(ctx: &mut Context) -> *mut Context { run_async_handler(ctx, async move |mut context: HandlerContext<'_>| { let proc = context.cur_process().unwrap(); + //TODO: remove this let is_shared: bool = flags.contains(MmapFlags::MAP_SHARED); let kind = if flags.contains(MmapFlags::MAP_ANONYMOUS) { @@ -51,16 +52,17 @@ pub unsafe fn sys_mmap(ctx: &mut Context) -> *mut Context { MappingKind::File(file) }; + //TODO: remove this if is_shared { println!("Shared mapping detected in mmap"); } let res; if flags.contains(MmapFlags::MAP_FIXED) { - res = proc.mem.lock().mmap(Some(request_addr), request_size, kind, is_shared); + res = proc.mem.lock().mmap(Some(request_addr), request_size, kind); } else { // TODO: try to respect hint? - res = proc.mem.lock().mmap(None, request_size, kind, is_shared); + res = proc.mem.lock().mmap(None, request_size, kind); } match res { From d8134feeb88e3a3a074e5dc1f3ce45f4dc836f8f Mon Sep 17 00:00:00 2001 From: S A Date: Fri, 18 Apr 2025 20:22:55 -0500 Subject: [PATCH 10/15] fixed bug with file offsets --- crates/init/fs/test2.txt | 1 + crates/init/src/main.rs | 93 +++++++++++++++++++++++-------- crates/kernel/examples/user.rs | 7 ++- crates/kernel/src/fs/initfs.rs | 16 +++--- crates/kernel/src/process/mem.rs | 52 +++++++++++------ crates/kernel/src/syscall/exec.rs | 5 +- crates/kernel/src/syscall/mmap.rs | 19 +++---- crates/kernel/src/syscall/proc.rs | 2 +- crates/ulib/src/sys.rs | 1 - 9 files changed, 130 insertions(+), 66 deletions(-) create mode 100644 crates/init/fs/test2.txt diff --git a/crates/init/fs/test2.txt b/crates/init/fs/test2.txt new file mode 100644 index 00000000..b205596a --- /dev/null +++ b/crates/init/fs/test2.txt @@ -0,0 +1 @@ +hello worldaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaahello world \ No newline at end of file diff --git a/crates/init/src/main.rs b/crates/init/src/main.rs index 6d5fe8b3..a2b4d286 100644 --- a/crates/init/src/main.rs +++ b/crates/init/src/main.rs @@ -15,76 +15,125 @@ pub extern "C" fn main() { let root_fd = 3; let path = b"shell.elf"; let file = ulib::sys::openat(root_fd, path, 0, 0).unwrap(); - + let test_file_path = b"test.txt"; - let test_text_file = ulib::sys::openat(root_fd, test_file_path, 0, 0).unwrap(); + let mut test_text_file = ulib::sys::openat(root_fd, test_file_path, 0, 0).unwrap(); static HELLO_CHARS: [u8; 5] = *b"hello"; - //TODO: add mmap options flags to ulib - let mmap_addr: *mut u8 = unsafe { ulib::sys::mmap(0, 4096, 0, 0, test_text_file, 0).unwrap() } as *mut u8; - println!("Memory range is mmaped!"); - + static WORLD_CHARS: [u8; 5] = *b"world"; + //TODO: add mmap options flags to ulib + let mut mmap_addr: *mut u8 = + unsafe { ulib::sys::mmap(0, 4096, 0, 0, test_text_file, 0).unwrap() } as *mut u8; + println!("Memory range is mmaped!"); + for i in 0..5 { let curr_char: u8 = unsafe { *(mmap_addr.wrapping_add(i)) }; if curr_char != HELLO_CHARS[i] { - panic!("mmap filed file has an error at index {}! Expected {} got {}", i, HELLO_CHARS[i], curr_char); + panic!( + "mmap filed file has an error at index {}! Expected {} got {}", + i, HELLO_CHARS[i] as char, curr_char as char + ); } } println!("mmap of test file succeeded!"); + unsafe { sys::munmap(mmap_addr as *mut ()).unwrap() }; + _ = ulib::sys::close(test_text_file); + + println!("starting mmap with offset test 1"); + let test_file_path2 = b"test2.txt"; + test_text_file = ulib::sys::openat(root_fd, test_file_path2, 0, 0).unwrap(); + mmap_addr = + unsafe { ulib::sys::mmap(0, 4096 * 2, 0, 0, test_text_file, 6).unwrap() } as *mut u8; + println!("mmap addr: {:x}", mmap_addr as usize); + + for i in 0..5 { + let curr_char: u8 = unsafe { *(mmap_addr.wrapping_add(i)) }; + if curr_char != WORLD_CHARS[i] { + panic!( + "mmap filed file has an error at index {}! Expected {} got {}", + i, WORLD_CHARS[i] as char, curr_char as char + ); + } + } + + println!("done with mmap with offset test 1"); + println!("starting mmap with offset test 2"); + for i in 0..5 { + let curr_char: u8 = unsafe { *(mmap_addr.wrapping_add(i + 4096)) }; + if curr_char != WORLD_CHARS[i] { + panic!( + "mmap filed file has an error at index {}! Expected {} got {}", + i, WORLD_CHARS[i] as char, curr_char as char + ); + } + } + + println!("done with mmap with offset test 2"); unsafe { sys::munmap(mmap_addr as *mut ()).unwrap() }; - + _ = ulib::sys::close(test_text_file); + println!("Starting shared memory test"); let shared_mem_fd = unsafe { sys_memfd_create() as u32 }; - let shared_frame = unsafe { ulib::sys::mmap(0, 4096, 0, 1 << 2, shared_mem_fd, 0) }.unwrap() as *mut u8; + let shared_frame = + unsafe { ulib::sys::mmap(0, 4096, 0, 1 << 2, shared_mem_fd, 0) }.unwrap() as *mut u8; let end_ptr: *mut u8 = shared_frame.wrapping_add(6); unsafe { end_ptr.write_volatile('.' as u8) }; assert_eq!(unsafe { end_ptr.read_volatile() }, '.' as u8); println!("Calling fork"); let wait_fd = unsafe { ulib::sys::sys_fork() } as u32; - + if wait_fd == 0 { - for _i in 0..1000000 { - if unsafe { end_ptr.read_volatile() } == ('!' as u8) { break; } } let end_val: u8 = unsafe { end_ptr.read_volatile() }; - if end_val != ('!' as u8) { - println!("Error: child expected to see '!' with val {} and instead found {}", ('!' as u8), end_val); + if end_val != ('!' as u8) { + println!( + "Error: child expected to see '!' with val {} and instead found {}", + ('!' as u8), + end_val + ); ulib::sys::exit(5); } - + for i in 0..5 { let curr_char = unsafe { *shared_frame.wrapping_add(i) } as char; if curr_char != (HELLO_CHARS[i] as char) { - println!("Child found wrong char at index {}. Expected {} found {}", i, (HELLO_CHARS[i] as char), curr_char); + println!( + "Child found wrong char at index {}. Expected {} found {}", + i, + (HELLO_CHARS[i] as char), + curr_char + ); ulib::sys::exit(5); } } println!("Child is done"); ulib::sys::exit(0); - } else { - unsafe { - core::ptr::copy_nonoverlapping(&raw const HELLO_CHARS[0], shared_frame, HELLO_CHARS.len()); + core::ptr::copy_nonoverlapping( + &raw const HELLO_CHARS[0], + shared_frame, + HELLO_CHARS.len(), + ); shared_frame.wrapping_add(6).write('!' as u8); } let child_exit_val = ulib::sys::wait(wait_fd).unwrap(); assert_eq!(child_exit_val, 0); - println!("Parent received exit code 0 from child, all is good"); + println!("done with shared memory test, parent received exit code 0 from child"); } - - //TODO: unmap shared frame + + _ = unsafe { ulib::sys::munmap(shared_frame as *mut ()) }; let child = spawn_elf(&ulib::sys::SpawnArgs { fd: file, diff --git a/crates/kernel/examples/user.rs b/crates/kernel/examples/user.rs index aa945cd8..6d709bea 100644 --- a/crates/kernel/examples/user.rs +++ b/crates/kernel/examples/user.rs @@ -31,7 +31,7 @@ async fn main() { let user_region = process .mem .lock() - .mmap(Some(0x20_0000), user_region_len, MappingKind::Anon) + .mmap(Some(0x20_0000), user_region_len, MappingKind::Anon, 0) .unwrap(); let mem = process.mem.lock(); @@ -91,8 +91,9 @@ async fn main() { .mmap( Some(stack_start - stack_size), stack_size, - MappingKind::Anon - ) + MappingKind::Anon, + 0, + ) .unwrap(); let user_sp = stack_start; diff --git a/crates/kernel/src/fs/initfs.rs b/crates/kernel/src/fs/initfs.rs index a5eec76c..4da945e4 100644 --- a/crates/kernel/src/fs/initfs.rs +++ b/crates/kernel/src/fs/initfs.rs @@ -240,15 +240,15 @@ impl FileDescriptor for InitFsFile { let page_paddr = page.paddr; let page_virt = PAGE_ALLOCATOR.get().get_mapped_frame::(page); let buf_ref = unsafe { core::slice::from_raw_parts_mut(page_virt as *mut u8, 4096) }; - match self.read(_offset, buf_ref).await.as_result() { - Ok(_val) => { - return Some(FileDescResult::ok(page_paddr as u64)); - }, - Err(_val) => { - println!("Read failed"); - return None; - }, + match self.read(_offset, buf_ref).await.as_result() { + Ok(_val) => { + return Some(FileDescResult::ok(page_paddr as u64)); } + Err(_val) => { + println!("Read failed"); + return None; + } + } }) } fn as_any(&self) -> &dyn core::any::Any { diff --git a/crates/kernel/src/process/mem.rs b/crates/kernel/src/process/mem.rs index 818d6a13..468a5faf 100644 --- a/crates/kernel/src/process/mem.rs +++ b/crates/kernel/src/process/mem.rs @@ -12,7 +12,6 @@ use crate::event::async_handler::{run_async_handler, HandlerContext}; use crate::event::context::{deschedule_thread, Context, DescheduleAction}; use crate::event::exceptions::DataAbortISS; -use crate::process::fd::FileDescriptor; use crate::syscall::fb_hack::MemFd; use super::fd::ArcFd; @@ -35,6 +34,7 @@ pub struct MemoryRangeNode { pub start: usize, pub size: usize, pub kind: MappingKind, + pub offset: usize, } #[derive(Clone)] @@ -43,7 +43,6 @@ pub enum MappingKind { File(ArcFd), } - impl UserAddrSpace { pub fn new() -> Self { let table = alloc_top_page_table(); @@ -82,10 +81,10 @@ impl UserAddrSpace { for (range_start, node) in &self.memory_range_map { let start = new_mem - .insert_vme_at(node.start, node.size, node.kind.clone()) + .insert_vme_at(node.start, node.size, node.kind.clone(), node.offset) .unwrap(); assert!(start == *range_start); - + for offset in (0..node.size).step_by(buf_size) { let chunk_size = (node.size - offset).min(buf_size); new_mem @@ -96,17 +95,14 @@ impl UserAddrSpace { self.populate_range(node, node.start + offset, chunk_size) .await .unwrap(); - + //Don't want to copy data in shared mem if let MappingKind::File(arc) = &node.kind { - if let Some(_s) = arc.as_any().downcast_ref::() { - println!("Skipping over shared range the right way"); continue; } - } - + let src_data = node.start as *const u8; let dst_data = node.start as *mut u8; let buf_ptr: *mut u8 = buffer.as_mut_ptr().cast(); @@ -133,6 +129,7 @@ impl UserAddrSpace { start: usize, size: usize, kind: MappingKind, + offset: usize, ) -> Result { let start_addr = (start / PAGE_SIZE) * PAGE_SIZE; let size_pages = (size + (start - start_addr)).next_multiple_of(PAGE_SIZE); @@ -147,9 +144,13 @@ impl UserAddrSpace { return Err(MmapError::MemoryRangeCollision); } } - - //TODO: take another look at the size here - let node = MemoryRangeNode { start, size, kind }; + + let node = MemoryRangeNode { + start, + size, + kind, + offset, + }; self.memory_range_map.insert(start, node); Ok(start_addr) } @@ -178,12 +179,13 @@ impl UserAddrSpace { start_addr: Option, size: usize, kind: MappingKind, + offset: usize, ) -> Result { let start_addr = match start_addr { Some(s) => s, None => self.find_vme_space(size)?, }; - let base_addr = self.insert_vme_at(start_addr, size, kind)?; + let base_addr = self.insert_vme_at(start_addr, size, kind, offset)?; Ok(base_addr) } @@ -208,12 +210,23 @@ impl UserAddrSpace { }; let leaf = unsafe { desc.leaf }; + if leaf.is_valid() { let new_desc = TranslationDescriptor::unset(); unsafe { set_translation_descriptor(self.table, virt_addr, 3, 0, new_desc, false) .unwrap() } + //Need this invalidation here or it still accesses old page + unsafe { + core::arch::asm! { + "dsb ISH", + "tlbi vaae1, {0}", + in(reg) (virt_addr >> 12) + //options(readonly, nostack, preserves_flags) + } + } + // TODO: free it match &vme.kind { MappingKind::Anon => { @@ -270,16 +283,20 @@ impl UserAddrSpace { } MappingKind::File(fd) => { let offset = vaddr - vme.start; - let page = match fd.mmap_page(offset as u64).await.map(|r| r.as_result()) { + let page = match fd + .mmap_page(offset as u64 + (vme.offset as u64)) + .await + .map(|r| r.as_result()) + { Some(Ok(page)) => page, Some(Err(_e)) => { println!("Error in mmap page"); return Err(MmapError::FileError); - }, - None => { + } + None => { println!("Mmap page returned none"); return Err(MmapError::FileError); - }, + } }; let desc = LeafDescriptor::new(page as usize) .union(LeafDescriptor::UNPRIVILEGED_ACCESS) @@ -330,7 +347,6 @@ unsafe impl Sync for UserAddrSpace {} pub fn page_fault_handler(ctx: &mut Context, far: usize, _iss: DataAbortISS) -> *mut Context { run_async_handler(ctx, async move |mut context: HandlerContext<'_>| { let proc = context.cur_process().unwrap(); - // TODO: make sure misaligned loads don't loop here? let page_addr = (far / PAGE_SIZE) * PAGE_SIZE; diff --git a/crates/kernel/src/syscall/exec.rs b/crates/kernel/src/syscall/exec.rs index 9b0017fa..6a8089fa 100644 --- a/crates/kernel/src/syscall/exec.rs +++ b/crates/kernel/src/syscall/exec.rs @@ -104,7 +104,7 @@ pub unsafe fn sys_execve_fd(ctx: &mut Context) -> *mut Context { let memsize = (phdr.p_memsz as usize).next_multiple_of(4096).max(4096); let base = new_mem - .mmap(Some(phdr.p_vaddr as usize), memsize, MappingKind::Anon) + .mmap(Some(phdr.p_vaddr as usize), memsize, MappingKind::Anon, 0) .unwrap(); // TODO: figure out how to handle user page faults when in the kernel @@ -133,7 +133,8 @@ pub unsafe fn sys_execve_fd(ctx: &mut Context) -> *mut Context { .mmap( Some(stack_start - stack_size), stack_size, - MappingKind::Anon + MappingKind::Anon, + 0, ) .unwrap(); diff --git a/crates/kernel/src/syscall/mmap.rs b/crates/kernel/src/syscall/mmap.rs index 841b6f2a..6081b91c 100644 --- a/crates/kernel/src/syscall/mmap.rs +++ b/crates/kernel/src/syscall/mmap.rs @@ -33,13 +33,12 @@ pub unsafe fn sys_mmap(ctx: &mut Context) -> *mut Context { }; let fd = ctx.regs[4]; - // TODO: File offset - let _offset = ctx.regs[5]; + let offset = ctx.regs[5]; run_async_handler(ctx, async move |mut context: HandlerContext<'_>| { let proc = context.cur_process().unwrap(); - //TODO: remove this - let is_shared: bool = flags.contains(MmapFlags::MAP_SHARED); + + let _is_shared: bool = flags.contains(MmapFlags::MAP_SHARED); let kind = if flags.contains(MmapFlags::MAP_ANONYMOUS) { MappingKind::Anon @@ -51,18 +50,16 @@ pub unsafe fn sys_mmap(ctx: &mut Context) -> *mut Context { }; MappingKind::File(file) }; - - //TODO: remove this - if is_shared { - println!("Shared mapping detected in mmap"); - } let res; if flags.contains(MmapFlags::MAP_FIXED) { - res = proc.mem.lock().mmap(Some(request_addr), request_size, kind); + res = proc + .mem + .lock() + .mmap(Some(request_addr), request_size, kind, offset); } else { // TODO: try to respect hint? - res = proc.mem.lock().mmap(None, request_size, kind); + res = proc.mem.lock().mmap(None, request_size, kind, offset); } match res { diff --git a/crates/kernel/src/syscall/proc.rs b/crates/kernel/src/syscall/proc.rs index e7b9b592..e5de6368 100644 --- a/crates/kernel/src/syscall/proc.rs +++ b/crates/kernel/src/syscall/proc.rs @@ -46,7 +46,7 @@ pub unsafe fn sys_spawn(ctx: &mut Context) -> *mut Context { let user_sp = ctx.regs[1]; let user_x0 = ctx.regs[2]; let flags = ctx.regs[3]; - + run_async_handler(ctx, async move |context: HandlerContext<'_>| { let old_process = context.cur_process().unwrap(); diff --git a/crates/ulib/src/sys.rs b/crates/ulib/src/sys.rs index 17853780..63950241 100644 --- a/crates/ulib/src/sys.rs +++ b/crates/ulib/src/sys.rs @@ -167,7 +167,6 @@ unsafe extern "C" { pub fn sys_fork() -> isize; } - /* * * * * * * * * * * * * * * * * * * */ /* Syscall wrappers */ /* * * * * * * * * * * * * * * * * * * */ From 0814e38a4ae25c4eb35ae20bf56a8776e1beee65 Mon Sep 17 00:00:00 2001 From: S A Date: Fri, 18 Apr 2025 22:41:22 -0500 Subject: [PATCH 11/15] removing duplicate syscall declaration --- crates/ulib/src/sys.rs | 1 - 1 file changed, 1 deletion(-) diff --git a/crates/ulib/src/sys.rs b/crates/ulib/src/sys.rs index fadcfaeb..9db6484d 100644 --- a/crates/ulib/src/sys.rs +++ b/crates/ulib/src/sys.rs @@ -84,7 +84,6 @@ syscall!(21 => pub fn sys_get_time_ms() -> usize); syscall!(22 => pub fn sys_sleep_ms(time: usize)); // syscall!(23 => pub fn sys_acquire_fb(width: usize, height: usize) -> (usize, usize, usize, usize, usize)); -syscall!(24 => pub fn sys_memfd_create() -> isize); #[repr(C)] pub struct RawFB { From 839b82649e40fa3d0c66e7eb9791ee57568ff2b0 Mon Sep 17 00:00:00 2001 From: S A Date: Thu, 24 Apr 2025 21:39:54 -0500 Subject: [PATCH 12/15] moving shared mem test to its own binary --- crates/init/build.sh | 2 + crates/init/sharedMemTest.rs | 158 +++++++++++++++++++++++++++++++ crates/init/src/main.rs | 123 +----------------------- crates/kernel/src/syscall/mod.rs | 1 - crates/ulib/src/sys.rs | 6 ++ 5 files changed, 168 insertions(+), 122 deletions(-) create mode 100755 crates/init/sharedMemTest.rs diff --git a/crates/init/build.sh b/crates/init/build.sh index c39d0b1e..72e5b9e3 100755 --- a/crates/init/build.sh +++ b/crates/init/build.sh @@ -12,6 +12,8 @@ mkdir -p fs cp shell.elf fs/ ./ls.rs cp ls.elf fs/ +./sharedMemTest.rs +cp sharedMemTest.elf fs/ cargo run -q -p initfs --bin util \ -- create --compress --out fs.arc --root fs fs diff --git a/crates/init/sharedMemTest.rs b/crates/init/sharedMemTest.rs new file mode 100755 index 00000000..62d952a1 --- /dev/null +++ b/crates/init/sharedMemTest.rs @@ -0,0 +1,158 @@ +#!/usr/bin/env bash +#![doc = r##""##] +#![no_std] +#![no_main] + +#[macro_use] +extern crate ulib; + +use ulib::sys::{openat, close, mmap, munmap, wait, exit, MAP_PRIVATE, MAP_SHARED, MAP_FILE}; + +#[no_mangle] +fn main() { + + let root_fd = 3; + + let test_file_path = b"test.txt"; + let mut test_text_file = openat(root_fd, test_file_path, 0, 0).unwrap(); + + static HELLO_CHARS: [u8; 5] = *b"hello"; + static WORLD_CHARS: [u8; 5] = *b"world"; + + let mut mmap_addr: *mut u8 = + unsafe { mmap(0, 4096, 0, MAP_PRIVATE | MAP_FILE, test_text_file, 0).unwrap() } as *mut u8; + println!("Memory range is mmaped!"); + + for i in 0..5 { + let curr_char: u8 = unsafe { *(mmap_addr.wrapping_add(i)) }; + if curr_char != HELLO_CHARS[i] { + panic!( + "mmap filed file has an error at index {}! Expected {} got {}", + i, HELLO_CHARS[i] as char, curr_char as char + ); + } + } + + println!("mmap of test file succeeded!"); + unsafe { munmap(mmap_addr as *mut ()).unwrap() }; + _ = close(test_text_file); + + println!("starting mmap with offset test 1"); + let test_file_path2 = b"test2.txt"; + test_text_file = openat(root_fd, test_file_path2, 0, 0).unwrap(); + mmap_addr = + unsafe { mmap(0, 4096 * 2, 0, MAP_PRIVATE | MAP_FILE, test_text_file, 6).unwrap() } as *mut u8; + println!("mmap addr: {:x}", mmap_addr as usize); + + for i in 0..5 { + let curr_char: u8 = unsafe { *(mmap_addr.wrapping_add(i)) }; + if curr_char != WORLD_CHARS[i] { + panic!( + "mmap filed file has an error at index {}! Expected {} got {}", + i, WORLD_CHARS[i] as char, curr_char as char + ); + } + } + + println!("done with mmap with offset test 1"); + + println!("starting mmap with offset test 2"); + for i in 0..5 { + let curr_char: u8 = unsafe { *(mmap_addr.wrapping_add(i + 4096)) }; + if curr_char != WORLD_CHARS[i] { + panic!( + "mmap filed file has an error at index {}! Expected {} got {}", + i, WORLD_CHARS[i] as char, curr_char as char + ); + } + } + + println!("done with mmap with offset test 2"); + unsafe { munmap(mmap_addr as *mut ()).unwrap() }; + _ = close(test_text_file); + + println!("Starting shared memory test"); + + let shared_mem_fd = unsafe { ulib::sys::sys_memfd_create() as u32 }; + let shared_frame = + unsafe { ulib::sys::mmap(0, 4096, 0, MAP_SHARED, shared_mem_fd, 0) }.unwrap() as *mut u8; + let end_ptr: *mut u8 = shared_frame.wrapping_add(6); + unsafe { end_ptr.write_volatile('.' as u8) }; + assert_eq!(unsafe { end_ptr.read_volatile() }, '.' as u8); + + println!("Calling fork"); + let wait_fd = unsafe { ulib::sys::sys_fork() } as u32; + + if wait_fd == 0 { + for _i in 0..1000000 { + if unsafe { end_ptr.read_volatile() } == ('!' as u8) { + break; + } + } + + let end_val: u8 = unsafe { end_ptr.read_volatile() }; + if end_val != ('!' as u8) { + println!( + "Error: child expected to see '!' with val {} and instead found {}", + ('!' as u8), + end_val + ); + ulib::sys::exit(5); + } + + for i in 0..5 { + let curr_char = unsafe { *shared_frame.wrapping_add(i) } as char; + if curr_char != (HELLO_CHARS[i] as char) { + println!( + "Child found wrong char at index {}. Expected {} found {}", + i, + (HELLO_CHARS[i] as char), + curr_char + ); + ulib::sys::exit(5); + } + } + + println!("Child is done"); + ulib::sys::exit(0); + } else { + unsafe { + core::ptr::copy_nonoverlapping( + &raw const HELLO_CHARS[0], + shared_frame, + HELLO_CHARS.len(), + ); + shared_frame.wrapping_add(6).write('!' as u8); + } + + let child_exit_val = wait(wait_fd).unwrap(); + assert_eq!(child_exit_val, 0); + println!("done with shared memory test, parent received exit code 0 from child"); + } + + _ = unsafe { munmap(shared_frame as *mut ()) }; + + exit(15); +} diff --git a/crates/init/src/main.rs b/crates/init/src/main.rs index 1df30ca7..6b027050 100644 --- a/crates/init/src/main.rs +++ b/crates/init/src/main.rs @@ -6,7 +6,7 @@ extern crate ulib; mod runtime; -use ulib::sys::{self, spawn_elf, sys_memfd_create}; +use ulib::sys::spawn_elf; #[unsafe(no_mangle)] pub extern "C" fn main() { @@ -32,126 +32,7 @@ pub extern "C" fn main() { let path = b"shell.elf"; let file = ulib::sys::openat(root_fd, path, 0, 0).unwrap(); - - let test_file_path = b"test.txt"; - let mut test_text_file = ulib::sys::openat(root_fd, test_file_path, 0, 0).unwrap(); - - static HELLO_CHARS: [u8; 5] = *b"hello"; - static WORLD_CHARS: [u8; 5] = *b"world"; - //TODO: add mmap options flags to ulib - let mut mmap_addr: *mut u8 = - unsafe { ulib::sys::mmap(0, 4096, 0, 0, test_text_file, 0).unwrap() } as *mut u8; - println!("Memory range is mmaped!"); - - for i in 0..5 { - let curr_char: u8 = unsafe { *(mmap_addr.wrapping_add(i)) }; - if curr_char != HELLO_CHARS[i] { - panic!( - "mmap filed file has an error at index {}! Expected {} got {}", - i, HELLO_CHARS[i] as char, curr_char as char - ); - } - } - - println!("mmap of test file succeeded!"); - unsafe { sys::munmap(mmap_addr as *mut ()).unwrap() }; - _ = ulib::sys::close(test_text_file); - - println!("starting mmap with offset test 1"); - let test_file_path2 = b"test2.txt"; - test_text_file = ulib::sys::openat(root_fd, test_file_path2, 0, 0).unwrap(); - mmap_addr = - unsafe { ulib::sys::mmap(0, 4096 * 2, 0, 0, test_text_file, 6).unwrap() } as *mut u8; - println!("mmap addr: {:x}", mmap_addr as usize); - - for i in 0..5 { - let curr_char: u8 = unsafe { *(mmap_addr.wrapping_add(i)) }; - if curr_char != WORLD_CHARS[i] { - panic!( - "mmap filed file has an error at index {}! Expected {} got {}", - i, WORLD_CHARS[i] as char, curr_char as char - ); - } - } - - println!("done with mmap with offset test 1"); - - println!("starting mmap with offset test 2"); - for i in 0..5 { - let curr_char: u8 = unsafe { *(mmap_addr.wrapping_add(i + 4096)) }; - if curr_char != WORLD_CHARS[i] { - panic!( - "mmap filed file has an error at index {}! Expected {} got {}", - i, WORLD_CHARS[i] as char, curr_char as char - ); - } - } - - println!("done with mmap with offset test 2"); - unsafe { sys::munmap(mmap_addr as *mut ()).unwrap() }; - _ = ulib::sys::close(test_text_file); - - println!("Starting shared memory test"); - - let shared_mem_fd = unsafe { sys_memfd_create() as u32 }; - let shared_frame = - unsafe { ulib::sys::mmap(0, 4096, 0, 1 << 2, shared_mem_fd, 0) }.unwrap() as *mut u8; - let end_ptr: *mut u8 = shared_frame.wrapping_add(6); - unsafe { end_ptr.write_volatile('.' as u8) }; - assert_eq!(unsafe { end_ptr.read_volatile() }, '.' as u8); - - println!("Calling fork"); - let wait_fd = unsafe { ulib::sys::sys_fork() } as u32; - - if wait_fd == 0 { - for _i in 0..1000000 { - if unsafe { end_ptr.read_volatile() } == ('!' as u8) { - break; - } - } - - let end_val: u8 = unsafe { end_ptr.read_volatile() }; - if end_val != ('!' as u8) { - println!( - "Error: child expected to see '!' with val {} and instead found {}", - ('!' as u8), - end_val - ); - ulib::sys::exit(5); - } - - for i in 0..5 { - let curr_char = unsafe { *shared_frame.wrapping_add(i) } as char; - if curr_char != (HELLO_CHARS[i] as char) { - println!( - "Child found wrong char at index {}. Expected {} found {}", - i, - (HELLO_CHARS[i] as char), - curr_char - ); - ulib::sys::exit(5); - } - } - - println!("Child is done"); - ulib::sys::exit(0); - } else { - unsafe { - core::ptr::copy_nonoverlapping( - &raw const HELLO_CHARS[0], - shared_frame, - HELLO_CHARS.len(), - ); - shared_frame.wrapping_add(6).write('!' as u8); - } - - let child_exit_val = ulib::sys::wait(wait_fd).unwrap(); - assert_eq!(child_exit_val, 0); - println!("done with shared memory test, parent received exit code 0 from child"); - } - - _ = unsafe { ulib::sys::munmap(shared_frame as *mut ()) }; - + let child = spawn_elf(&ulib::sys::SpawnArgs { fd: file, stdin: None, diff --git a/crates/kernel/src/syscall/mod.rs b/crates/kernel/src/syscall/mod.rs index 2174cf9a..64f6be3b 100644 --- a/crates/kernel/src/syscall/mod.rs +++ b/crates/kernel/src/syscall/mod.rs @@ -35,7 +35,6 @@ pub unsafe fn register_syscalls() { register_syscall_handler(21, time::sys_get_time_ms); register_syscall_handler(22, time::sys_sleep_ms); - register_syscall_handler(24, fb_hack::sys_memfd_create); register_syscall_handler(23, fb_hack::sys_acquire_fb); register_syscall_handler(24, fb_hack::sys_memfd_create); register_syscall_handler(25, fb_hack::sys_poll_key_event); diff --git a/crates/ulib/src/sys.rs b/crates/ulib/src/sys.rs index 9db6484d..adae74d2 100644 --- a/crates/ulib/src/sys.rs +++ b/crates/ulib/src/sys.rs @@ -300,6 +300,12 @@ pub fn wait(fd: FileDesc) -> Result { int_to_error(res) } +pub const MAP_PRIVATE: u32 = 0; +pub const MAP_FILE: u32 = 0; //linux mmap ignores this but can have it for readabilty? +pub const MAP_FIXED: u32 = 1 << 0; +pub const MAP_ANONYMOUS: u32 = 1 << 1; +pub const MAP_SHARED: u32 = 1 << 2; + pub unsafe fn mmap( addr: usize, size: usize, From 884e51284a97a7d8bd1a71854b215b672fd03ee6 Mon Sep 17 00:00:00 2001 From: S A Date: Thu, 24 Apr 2025 22:40:17 -0500 Subject: [PATCH 13/15] moving offset to be a part of mappingkind file --- crates/init/src/main.rs | 2 +- crates/kernel/examples/user.rs | 3 +-- crates/kernel/src/process/mem.rs | 36 ++++++++++++++++--------------- crates/kernel/src/syscall/exec.rs | 3 +-- crates/kernel/src/syscall/mmap.rs | 9 +++----- 5 files changed, 25 insertions(+), 28 deletions(-) diff --git a/crates/init/src/main.rs b/crates/init/src/main.rs index 6b027050..efe0d630 100644 --- a/crates/init/src/main.rs +++ b/crates/init/src/main.rs @@ -32,7 +32,7 @@ pub extern "C" fn main() { let path = b"shell.elf"; let file = ulib::sys::openat(root_fd, path, 0, 0).unwrap(); - + let child = spawn_elf(&ulib::sys::SpawnArgs { fd: file, stdin: None, diff --git a/crates/kernel/examples/user.rs b/crates/kernel/examples/user.rs index 6d709bea..0959cf4d 100644 --- a/crates/kernel/examples/user.rs +++ b/crates/kernel/examples/user.rs @@ -31,7 +31,7 @@ async fn main() { let user_region = process .mem .lock() - .mmap(Some(0x20_0000), user_region_len, MappingKind::Anon, 0) + .mmap(Some(0x20_0000), user_region_len, MappingKind::Anon) .unwrap(); let mem = process.mem.lock(); @@ -92,7 +92,6 @@ async fn main() { Some(stack_start - stack_size), stack_size, MappingKind::Anon, - 0, ) .unwrap(); diff --git a/crates/kernel/src/process/mem.rs b/crates/kernel/src/process/mem.rs index 468a5faf..b04cafa8 100644 --- a/crates/kernel/src/process/mem.rs +++ b/crates/kernel/src/process/mem.rs @@ -34,13 +34,12 @@ pub struct MemoryRangeNode { pub start: usize, pub size: usize, pub kind: MappingKind, - pub offset: usize, } #[derive(Clone)] pub enum MappingKind { Anon, - File(ArcFd), + File { fd: ArcFd, offset: usize }, } impl UserAddrSpace { @@ -81,7 +80,7 @@ impl UserAddrSpace { for (range_start, node) in &self.memory_range_map { let start = new_mem - .insert_vme_at(node.start, node.size, node.kind.clone(), node.offset) + .insert_vme_at(node.start, node.size, node.kind.clone()) .unwrap(); assert!(start == *range_start); @@ -97,7 +96,11 @@ impl UserAddrSpace { .unwrap(); //Don't want to copy data in shared mem - if let MappingKind::File(arc) = &node.kind { + if let MappingKind::File { + fd: arc, + offset: _off, + } = &node.kind + { if let Some(_s) = arc.as_any().downcast_ref::() { continue; } @@ -129,7 +132,6 @@ impl UserAddrSpace { start: usize, size: usize, kind: MappingKind, - offset: usize, ) -> Result { let start_addr = (start / PAGE_SIZE) * PAGE_SIZE; let size_pages = (size + (start - start_addr)).next_multiple_of(PAGE_SIZE); @@ -145,12 +147,7 @@ impl UserAddrSpace { } } - let node = MemoryRangeNode { - start, - size, - kind, - offset, - }; + let node = MemoryRangeNode { start, size, kind }; self.memory_range_map.insert(start, node); Ok(start_addr) } @@ -179,13 +176,12 @@ impl UserAddrSpace { start_addr: Option, size: usize, kind: MappingKind, - offset: usize, ) -> Result { let start_addr = match start_addr { Some(s) => s, None => self.find_vme_space(size)?, }; - let base_addr = self.insert_vme_at(start_addr, size, kind, offset)?; + let base_addr = self.insert_vme_at(start_addr, size, kind)?; Ok(base_addr) } @@ -232,7 +228,10 @@ impl UserAddrSpace { MappingKind::Anon => { // TODO: free } - MappingKind::File(_arc) => { + MappingKind::File { + fd: _arc, + offset: _off, + } => { // TODO: notify file that it's unused? // (for ref counts, page cache?) } @@ -281,10 +280,13 @@ impl UserAddrSpace { desc } - MappingKind::File(fd) => { + MappingKind::File { + fd: arc_fd, + offset: file_offset, + } => { let offset = vaddr - vme.start; - let page = match fd - .mmap_page(offset as u64 + (vme.offset as u64)) + let page = match arc_fd + .mmap_page(offset as u64 + (*file_offset as u64)) .await .map(|r| r.as_result()) { diff --git a/crates/kernel/src/syscall/exec.rs b/crates/kernel/src/syscall/exec.rs index 6a8089fa..4f658c66 100644 --- a/crates/kernel/src/syscall/exec.rs +++ b/crates/kernel/src/syscall/exec.rs @@ -104,7 +104,7 @@ pub unsafe fn sys_execve_fd(ctx: &mut Context) -> *mut Context { let memsize = (phdr.p_memsz as usize).next_multiple_of(4096).max(4096); let base = new_mem - .mmap(Some(phdr.p_vaddr as usize), memsize, MappingKind::Anon, 0) + .mmap(Some(phdr.p_vaddr as usize), memsize, MappingKind::Anon) .unwrap(); // TODO: figure out how to handle user page faults when in the kernel @@ -134,7 +134,6 @@ pub unsafe fn sys_execve_fd(ctx: &mut Context) -> *mut Context { Some(stack_start - stack_size), stack_size, MappingKind::Anon, - 0, ) .unwrap(); diff --git a/crates/kernel/src/syscall/mmap.rs b/crates/kernel/src/syscall/mmap.rs index 6081b91c..0590c3c5 100644 --- a/crates/kernel/src/syscall/mmap.rs +++ b/crates/kernel/src/syscall/mmap.rs @@ -48,18 +48,15 @@ pub unsafe fn sys_mmap(ctx: &mut Context) -> *mut Context { context.regs().regs[0] = i64::from(-1) as usize; return context.resume_final(); }; - MappingKind::File(file) + MappingKind::File { fd: file, offset } }; let res; if flags.contains(MmapFlags::MAP_FIXED) { - res = proc - .mem - .lock() - .mmap(Some(request_addr), request_size, kind, offset); + res = proc.mem.lock().mmap(Some(request_addr), request_size, kind); } else { // TODO: try to respect hint? - res = proc.mem.lock().mmap(None, request_size, kind, offset); + res = proc.mem.lock().mmap(None, request_size, kind); } match res { From 680c8d81c1e1a5ad0e2292c096d31d05798a3971 Mon Sep 17 00:00:00 2001 From: S A Date: Fri, 25 Apr 2025 00:03:31 -0500 Subject: [PATCH 14/15] init build fix --- crates/init/build.sh | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/crates/init/build.sh b/crates/init/build.sh index d3170402..2cc5376d 100755 --- a/crates/init/build.sh +++ b/crates/init/build.sh @@ -8,10 +8,10 @@ PROFILE=${PROFILE-"release"} mkdir -p fs -./shell.rs -cp shell.elf fs/ -./ls.rs -cp ls.elf fs/ +# ./shell.rs +# cp shell.elf fs/ +# ./ls.rs +# cp ls.elf fs/ ./sharedMemTest.rs cp sharedMemTest.elf fs/ From 9cc3d85cd0a18a738b80f982f91f3a8cda8e5819 Mon Sep 17 00:00:00 2001 From: S A Date: Sat, 26 Apr 2025 10:41:44 -0500 Subject: [PATCH 15/15] minor cleanup and fixes --- crates/kernel/src/fs/initfs.rs | 4 ++-- crates/kernel/src/process/mem.rs | 15 +++------------ 2 files changed, 5 insertions(+), 14 deletions(-) diff --git a/crates/kernel/src/fs/initfs.rs b/crates/kernel/src/fs/initfs.rs index dbbefd61..7441bfbd 100644 --- a/crates/kernel/src/fs/initfs.rs +++ b/crates/kernel/src/fs/initfs.rs @@ -253,7 +253,7 @@ impl FileDescriptor for InitFsFile { boxed_future(async move { Err(()) }) } } - fn mmap_page(&self, _offset: u64) -> SmallFuture> { + fn mmap_page(&self, offset: u64) -> SmallFuture> { if self.header.is_dir() { return boxed_future(async move { None }); } @@ -264,7 +264,7 @@ impl FileDescriptor for InitFsFile { let page_paddr = page.paddr; let page_virt = PAGE_ALLOCATOR.get().get_mapped_frame::(page); let buf_ref = unsafe { core::slice::from_raw_parts_mut(page_virt as *mut u8, 4096) }; - match self.read(_offset, buf_ref).await.as_result() { + match self.read(offset, buf_ref).await.as_result() { Ok(_val) => { return Some(FileDescResult::ok(page_paddr as u64)); } diff --git a/crates/kernel/src/process/mem.rs b/crates/kernel/src/process/mem.rs index 319f4eb0..3cede081 100644 --- a/crates/kernel/src/process/mem.rs +++ b/crates/kernel/src/process/mem.rs @@ -97,12 +97,8 @@ impl UserAddrSpace { .unwrap(); //Don't want to copy data in shared mem - if let MappingKind::File { - fd: arc, - offset: _off, - } = &node.kind - { - if let Some(_s) = arc.as_any().downcast_ref::() { + if let MappingKind::File { fd, .. } = &node.kind { + if let Some(_s) = fd.as_any().downcast_ref::() { continue; } } @@ -229,10 +225,7 @@ impl UserAddrSpace { MappingKind::Anon => { // TODO: free } - MappingKind::File { - fd: _arc, - offset: _off, - } => { + MappingKind::File { .. } => { // TODO: notify file that it's unused? // (for ref counts, page cache?) } @@ -293,11 +286,9 @@ impl UserAddrSpace { { Some(Ok(page)) => page, Some(Err(_e)) => { - println!("Error in mmap page"); return Err(MmapError::FileError); } None => { - println!("Mmap page returned none"); return Err(MmapError::FileError); } };