Skip to main content

os/process/
user.rs

1//! User-mode task creation and address space management.
2
3use crate::memory::paging::map_page;
4use crate::memory::{
5    AddressSpace, PageTableFlags, PhysAddr, SimpleFrameAllocator, VirtAddr, PAGE_SIZE,
6};
7use crate::process::elf::{Elf, ElfSegment};
8use crate::process::{ProcessControlBlock, ProcessId};
9use alloc::boxed::Box;
10
11/// Default user stack size: 8 pages (32 KB)
12const USER_STACK_PAGES: usize = 8;
13/// Default user stack top (grows downward from here)
14const USER_STACK_TOP: usize = 0x7FFF_F000;
15
16/// Create a user address space by privately cloning kernel mappings and loading
17/// ELF segments.
18///
19/// Kernel/MMIO leaf mappings still point at the same physical pages so trap
20/// handlers and kernel code remain accessible during exceptions/syscalls, but
21/// the intermediate page-table pages are not shared with the boot kernel root.
22/// User pages are mapped with the U flag set.
23pub fn create_user_address_space(
24    elf: &Elf,
25    raw_elf: &[u8],
26    allocator: &mut SimpleFrameAllocator,
27    kernel_page_table_paddr: PhysAddr,
28) -> Result<AddressSpace, &'static str> {
29    let mut addr_space = AddressSpace::new(allocator)?;
30
31    // Clone kernel mappings into private page-table pages so traps/syscalls
32    // work without letting user ELF mappings pollute the boot kernel root.
33    addr_space.copy_kernel_mappings_from(kernel_page_table_paddr, allocator)?;
34
35    crate::serial_println!(
36        "[USER] Kernel mappings cloned to user page table (root at {:#x})",
37        addr_space.page_table_paddr().as_usize()
38    );
39
40    // Load each PT_LOAD segment into user address space
41    for seg in &elf.segments {
42        load_segment(seg, raw_elf, &mut addr_space, allocator)?;
43    }
44
45    // Map user stack (grows downward from USER_STACK_TOP)
46    let stack_start = USER_STACK_TOP - USER_STACK_PAGES * PAGE_SIZE;
47    let stack_flags = PageTableFlags::Valid as usize
48        | PageTableFlags::Read as usize
49        | PageTableFlags::Write as usize
50        | PageTableFlags::User as usize;
51
52    for i in 0..USER_STACK_PAGES {
53        let vaddr = VirtAddr::new(stack_start + i * PAGE_SIZE);
54        let frame = allocator.allocate().ok_or("Out of memory for user stack")?;
55        let paddr = frame.start_address();
56        unsafe {
57            let root = &mut *addr_space.page_table_ptr();
58            map_page(root, vaddr, paddr, stack_flags, allocator)?;
59        }
60    }
61
62    crate::serial_println!(
63        "[USER] Stack mapped: {:#x} - {:#x}",
64        stack_start,
65        USER_STACK_TOP
66    );
67    crate::serial_println!("[USER] Entry point: {:#x}", elf.entry);
68
69    Ok(addr_space)
70}
71
72/// Load a single ELF segment into the user address space.
73fn load_segment(
74    seg: &ElfSegment,
75    raw_elf: &[u8],
76    addr_space: &mut AddressSpace,
77    allocator: &mut SimpleFrameAllocator,
78) -> Result<(), &'static str> {
79    let seg_start = seg.vaddr;
80    let seg_end = seg
81        .vaddr
82        .checked_add(seg.memsz)
83        .ok_or("ELF segment address overflow")?;
84    let page_start = seg_start & !(PAGE_SIZE - 1);
85    let page_end = seg_end
86        .checked_add(PAGE_SIZE - 1)
87        .ok_or("ELF segment page range overflow")?
88        & !(PAGE_SIZE - 1);
89
90    if seg.filesz > seg.memsz {
91        return Err("ELF segment file size exceeds memory size");
92    }
93    let file_end = seg
94        .offset
95        .checked_add(seg.filesz)
96        .ok_or("ELF segment file range overflow")?;
97    let file_data = raw_elf
98        .get(seg.offset..file_end)
99        .ok_or("ELF segment file data out of bounds")?;
100    let file_vaddr_end = seg_start
101        .checked_add(seg.filesz)
102        .ok_or("ELF segment file address overflow")?;
103
104    // Build flags from ELF PF_ flags + User
105    let mut prot = PageTableFlags::Valid as usize | PageTableFlags::User as usize;
106    if seg.flags & 1 != 0 {
107        prot |= PageTableFlags::Execute as usize;
108    } // PF_X
109    if seg.flags & 2 != 0 {
110        prot |= PageTableFlags::Write as usize;
111    } // PF_W
112    if seg.flags & 4 != 0 {
113        prot |= PageTableFlags::Read as usize;
114    } // PF_R
115
116    crate::serial_println!(
117        "[USER] Loading segment: vaddr={:#x}..{:#x} filesz={} memsz={} prot={:#x}",
118        seg_start,
119        seg_end,
120        seg.filesz,
121        seg.memsz,
122        prot
123    );
124
125    let root = unsafe { &mut *addr_space.page_table_ptr() };
126
127    for page_off in (0..(page_end - page_start)).step_by(PAGE_SIZE) {
128        let vaddr = VirtAddr::new(page_start + page_off);
129        let frame = allocator
130            .allocate()
131            .ok_or("Out of memory for user segment")?;
132        let paddr = frame.start_address();
133
134        map_page(root, vaddr, paddr, prot, allocator)?;
135
136        let dst = paddr.as_usize() as *mut u8;
137        unsafe {
138            for i in 0..PAGE_SIZE {
139                *dst.add(i) = 0;
140            }
141        }
142
143        let page_vaddr_start = vaddr.as_usize();
144        let page_vaddr_end = core::cmp::min(page_vaddr_start + PAGE_SIZE, seg_end);
145        let copy_vaddr_start = core::cmp::max(page_vaddr_start, seg_start);
146        let copy_vaddr_end = core::cmp::min(page_vaddr_end, file_vaddr_end);
147
148        if copy_vaddr_start < copy_vaddr_end {
149            let src_start = copy_vaddr_start - seg_start;
150            let dst_start = copy_vaddr_start - page_vaddr_start;
151            let len = copy_vaddr_end - copy_vaddr_start;
152            let src = &file_data[src_start..src_start + len];
153            unsafe {
154                for (idx, byte) in src.iter().enumerate() {
155                    *dst.add(dst_start + idx) = *byte;
156                }
157            }
158        }
159    }
160
161    Ok(())
162}
163
164/// Create a user-mode task PCB.
165///
166/// The task will start in U-mode at `entry` with `sp` set to `stack_top`.
167/// The user page table (`satp`) is set so the CPU can access user memory
168/// while kernel trap handlers remain reachable.
169pub fn create_user_task(
170    pid: ProcessId,
171    name: &'static str,
172    entry: usize,
173    stack_top: usize,
174    satp: usize,
175) -> Box<ProcessControlBlock> {
176    let mut pcb = ProcessControlBlock::new(pid, name, None);
177    let ctx = pcb.context_mut();
178
179    ctx.set_ra(entry);
180    ctx.set_sp(stack_top);
181    ctx.set_sepc(entry);
182
183    // U-mode sstatus: SPP=0 (User), SPIE=1, SUM=1, SIE=0
184    let raw_sstatus: usize;
185    unsafe {
186        core::arch::asm!("csrr {}, sstatus", out(reg) raw_sstatus);
187    }
188    let user_sstatus = (raw_sstatus | (1 << 5) | (1 << 18)) & !((1 << 8) | (1 << 1));
189    ctx.set_sstatus(user_sstatus);
190
191    ctx.set_satp(satp);
192
193    Box::new(pcb)
194}
195
196#[cfg(test)]
197mod tests {
198    use super::*;
199    use crate::memory::paging::walk_page_table;
200    use crate::memory::{MemoryAreaType, PageTable, PAGE_SIZE};
201    use crate::process::user_elf::build_user_elf;
202
203    #[test_case]
204    fn create_user_address_space_does_not_pollute_kernel_low_uart_subtree() {
205        let mut allocator = SimpleFrameAllocator::new(0x8060_0000, 0x8080_0000);
206        let mut kernel_space = AddressSpace::new(&mut allocator).expect("kernel address space");
207
208        // UART is deliberately low (VPN[2] == 0), the same root slot used by
209        // the teaching user ELF at 0x10000.  This used to expose a shallow-copy
210        // bug where mapping the user ELF mutated the boot kernel root subtree.
211        kernel_space
212            .map_region_identity(
213                PhysAddr::new(0x1000_0000),
214                PAGE_SIZE,
215                MemoryAreaType::Data,
216                &mut allocator,
217            )
218            .expect("map UART");
219        let kernel_root_paddr = kernel_space.page_table_paddr();
220
221        let (elf_bytes, _) = build_user_elf();
222        let elf = Elf::parse(&elf_bytes).expect("embedded ELF parses");
223
224        let first = create_user_address_space(&elf, &elf_bytes, &mut allocator, kernel_root_paddr)
225            .expect("first user address space");
226        assert!(
227            walk_page_table(kernel_root_paddr, VirtAddr::new(0x10000)).is_none(),
228            "creating a user address space must not add user ELF mappings to the kernel root"
229        );
230
231        let _second =
232            create_user_address_space(&elf, &elf_bytes, &mut allocator, kernel_root_paddr)
233                .expect("second user address space should not see stale user mappings");
234        assert!(
235            walk_page_table(kernel_root_paddr, VirtAddr::new(0x10000)).is_none(),
236            "repeated user address-space creation must leave the kernel root clean"
237        );
238
239        let kernel_root = unsafe { &*(kernel_root_paddr.as_usize() as *const PageTable) };
240        let user_root = unsafe { &*(first.page_table_ptr() as *const PageTable) };
241        assert_ne!(
242            kernel_root
243                .get_entry(VirtAddr::new(0x1000_0000).vpn2())
244                .phys_addr(),
245            user_root
246                .get_entry(VirtAddr::new(0x1000_0000).vpn2())
247                .phys_addr(),
248            "kernel and user roots must not share the low UART intermediate page table"
249        );
250    }
251}