1use 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
11const USER_STACK_PAGES: usize = 8;
13const USER_STACK_TOP: usize = 0x7FFF_F000;
15
16pub 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 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 for seg in &elf.segments {
42 load_segment(seg, raw_elf, &mut addr_space, allocator)?;
43 }
44
45 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
72fn 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 let mut prot = PageTableFlags::Valid as usize | PageTableFlags::User as usize;
106 if seg.flags & 1 != 0 {
107 prot |= PageTableFlags::Execute as usize;
108 } if seg.flags & 2 != 0 {
110 prot |= PageTableFlags::Write as usize;
111 } if seg.flags & 4 != 0 {
113 prot |= PageTableFlags::Read as usize;
114 } 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
164pub 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 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 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}