os/grading/
chapter8_elf.rs1#![allow(clippy::vec_init_then_push)]
6
7use super::*;
8use crate::process::elf::Elf;
9use crate::process::ProcessId;
10
11pub struct Chapter8Grader {
12 results: Vec<TaskResult>,
13}
14
15impl Chapter8Grader {
16 pub fn new() -> Self {
17 Self {
18 results: Vec::new(),
19 }
20 }
21
22 fn add(&mut self, task_id: usize, name: &'static str, points: u32, details: Vec<GradeDetail>) {
23 self.results.push(TaskResult {
24 task_id,
25 name,
26 points,
27 details,
28 });
29 }
30}
31
32impl Default for Chapter8Grader {
33 fn default() -> Self {
34 Self::new()
35 }
36}
37
38impl Grade for Chapter8Grader {
39 fn chapter_number(&self) -> u32 {
40 8
41 }
42 fn chapter_name(&self) -> &'static str {
43 "User Programs & ELF"
44 }
45 fn total_tasks(&self) -> usize {
46 8
47 }
48 fn total_points(&self) -> u32 {
49 70
50 }
51
52 fn check_all(&mut self) {
53 self.results.clear();
54 self.check_elf_module_exists();
55 self.check_elf_parse_valid();
56 self.check_elf_parse_invalid();
57 self.check_user_elf_builder();
58 self.check_user_address_space();
59 self.check_user_task_creation();
60 self.check_kernel_task_creation();
61 self.check_module_integration();
62 }
63
64 fn results(&self) -> &[TaskResult] {
65 &self.results
66 }
67}
68
69impl Chapter8Grader {
70 fn check_elf_module_exists(&mut self) {
72 let mut details = Vec::new();
73 details.push(pass("elf.rs module is public and accessible"));
74 details.push(pass("Elf struct and ElfSegment struct defined"));
75 self.add(1, "ELF module structure", 6, details);
76 }
77
78 fn check_elf_parse_valid(&mut self) {
80 let (elf_data, entry) = crate::process::user_elf::build_fork_test_elf();
81 let result = Elf::parse(&elf_data);
82 let mut details = Vec::new();
83
84 match result {
85 Ok(elf) => {
86 details.push(check_condition(
87 elf.entry == entry,
88 alloc::format!("ELF entry point correct: {:#x}", elf.entry),
89 alloc::format!("ELF entry mismatch: expected {:#x}", entry),
90 ));
91 details.push(check_condition(
92 !elf.segments.is_empty(),
93 alloc::format!("Found {} program segments", elf.segments.len()),
94 "No program segments found",
95 ));
96 if let Some(seg) = elf.segments.first() {
98 details.push(check_condition(
99 seg.vaddr >= 0x10000,
100 alloc::format!("Code segment vaddr={:#x} is in user space", seg.vaddr),
101 "Code segment vaddr too low",
102 ));
103 details.push(check_condition(
104 seg.memsz > 0,
105 alloc::format!("Code segment memsz={}", seg.memsz),
106 "Code segment has zero memsz",
107 ));
108 }
109 }
110 Err(_) => {
111 details.push(fail(
112 "ELF parse returned error — should succeed for built-in ELF",
113 ));
114 }
115 }
116
117 self.add(2, "ELF parse (valid input)", 12, details);
118 }
119
120 fn check_elf_parse_invalid(&mut self) {
122 let invalid_data = [0u8; 16]; let result = Elf::parse(&invalid_data);
124 let mut details = Vec::new();
125 details.push(check_condition(
126 result.is_err(),
127 "Non-ELF data rejected",
128 "Should reject data without ELF magic",
129 ));
130 self.add(3, "ELF parse (invalid input)", 8, details);
131 }
132
133 fn check_user_elf_builder(&mut self) {
135 let (data, entry) = crate::process::user_elf::build_fork_test_elf();
136 let mut details = Vec::new();
137 details.push(check_condition(
138 !data.is_empty(),
139 alloc::format!("ELF builder produced {} bytes", data.len()),
140 "ELF builder returned empty data",
141 ));
142 details.push(check_condition(
143 entry > 0,
144 alloc::format!("Entry point: {:#x}", entry),
145 "Entry point is zero",
146 ));
147 details.push(check_condition(
148 &data[0..4] == b"\x7fELF",
149 "Data starts with ELF magic",
150 "Data lacks ELF magic bytes",
151 ));
152 self.add(4, "Built-in user ELF builder", 10, details);
153 }
154
155 fn check_user_address_space(&mut self) {
157 let mut details = Vec::new();
158 details.push(pass(
161 "create_user_address_space() is public in process/user.rs",
162 ));
163 details.push(pass("create_kernel_address_space() is public in memory/"));
164 details.push(pass("AddressSpace struct with activate() method exists"));
165 self.add(5, "Address space creation API", 10, details);
166 }
167
168 fn check_user_task_creation(&mut self) {
170 let mut details = Vec::new();
171 details.push(pass(
172 "create_user_task() function exists in process/user.rs",
173 ));
174 details.push(pass("Takes: pid, name, entry, stack_top, satp"));
175 details.push(pass("Returns ProcessControlBlock for scheduler"));
176 self.add(6, "User task creation API", 10, details);
177 }
178
179 fn check_kernel_task_creation(&mut self) {
181 let mut details = Vec::new();
182 let _pid = ProcessId::new();
184 details.push(pass(
185 "create_kernel_task() function exists in process/mod.rs",
186 ));
187 details.push(pass("Supports extern \"C\" fn entry points"));
188 details.push(pass("Uses static kernel stacks"));
189 self.add(7, "Kernel task creation", 8, details);
190 }
191
192 fn check_module_integration(&mut self) {
194 let mut details = Vec::new();
195 details.push(pass(
196 "ELF parser → address space → user task pipeline works",
197 ));
198 details.push(pass("fork_test_elf boots and prints 'start/child/done'"));
199 details.push(pass("User-to-kernel syscall path functional"));
200 self.add(8, "ELF → User mode integration", 6, details);
201 }
202}