1 use core::{ffi::c_void, panic};
2
3 use alloc::{string::String, vec::Vec};
4
5 use crate::{
6 arch::{asm::current::current_pcb, CurrentIrqArch},
7 exception::InterruptArch,
8 filesystem::vfs::MAX_PATHLEN,
9 include::bindings::bindings::{
10 pt_regs, set_system_trap_gate, CLONE_FS, CLONE_SIGNAL, CLONE_VM, USER_CS, USER_DS,
11 },
12 ipc::signal::sys_rt_sigreturn,
13 mm::{ucontext::AddressSpace, verify_area, VirtAddr},
14 process::exec::{load_binary_file, ExecParam, ExecParamFlags},
15 syscall::{
16 user_access::{check_and_clone_cstr, check_and_clone_cstr_array},
17 Syscall, SystemError, SYS_EXECVE, SYS_FORK, SYS_RT_SIGRETURN, SYS_VFORK,
18 },
19 };
20
21 use super::{asm::ptrace::user_mode, mm::barrier::mfence};
22
23 extern "C" {
do_fork(regs: *mut pt_regs, clone_flags: u64, stack_start: u64, stack_size: u64) -> u6424 fn do_fork(regs: *mut pt_regs, clone_flags: u64, stack_start: u64, stack_size: u64) -> u64;
25
syscall_int()26 fn syscall_int();
27 }
28
29 macro_rules! syscall_return {
30 ($val:expr, $regs:expr) => {{
31 let ret = $val;
32 $regs.rax = ret as u64;
33 return;
34 }};
35 }
36
37 #[no_mangle]
syscall_handler(regs: &mut pt_regs) -> ()38 pub extern "C" fn syscall_handler(regs: &mut pt_regs) -> () {
39 let syscall_num = regs.rax as usize;
40 let args = [
41 regs.r8 as usize,
42 regs.r9 as usize,
43 regs.r10 as usize,
44 regs.r11 as usize,
45 regs.r12 as usize,
46 regs.r13 as usize,
47 regs.r14 as usize,
48 regs.r15 as usize,
49 ];
50 mfence();
51 mfence();
52 let from_user = user_mode(regs);
53
54 // 由于进程管理未完成重构，有些系统调用需要在这里临时处理，以后这里的特殊处理要删掉。
55 match syscall_num {
56 SYS_FORK => unsafe {
57 syscall_return!(do_fork(regs, 0, regs.rsp, 0), regs);
58 },
59 SYS_VFORK => unsafe {
60 syscall_return!(
61 do_fork(
62 regs,
63 (CLONE_VM | CLONE_FS | CLONE_SIGNAL) as u64,
64 regs.rsp,
65 0,
66 ),
67 regs
68 );
69 },
70 SYS_EXECVE => {
71 let path_ptr = args[0];
72 let argv_ptr = args[1];
73 let env_ptr = args[2];
74
75 // 权限校验
76 if from_user
77 && (verify_area(VirtAddr::new(path_ptr), MAX_PATHLEN).is_err()
78 || verify_area(VirtAddr::new(argv_ptr), MAX_PATHLEN).is_err()
79 || verify_area(VirtAddr::new(env_ptr), MAX_PATHLEN).is_err())
80 {
81 syscall_return!(SystemError::EFAULT.to_posix_errno() as u64, regs);
82 } else {
83 unsafe {
84 // kdebug!("syscall: execve\n");
85 syscall_return!(
86 rs_do_execve(
87 path_ptr as *const u8,
88 argv_ptr as *const *const u8,
89 env_ptr as *const *const u8,
90 regs
91 ),
92 regs
93 );
94 // let path = String::from("/bin/about.elf");
95 // let argv = vec![String::from("/bin/about.elf")];
96 // let envp = vec![String::from("PATH=/bin")];
97 // let r = tmp_rs_execve(path, argv, envp, regs);
98 // kdebug!("syscall: execve r: {:?}\n", r);
99
100 // syscall_return!(
101 // r.map(|_| 0).unwrap_or_else(|e| e.to_posix_errno() as usize),
102 // regs
103 // )
104 }
105 }
106 }
107
108 SYS_RT_SIGRETURN => {
109 syscall_return!(sys_rt_sigreturn(regs), regs);
110 }
111 // SYS_SCHED => {
112 // syscall_return!(sched(from_user) as u64, regs);
113 // }
114 _ => {}
115 }
116 syscall_return!(Syscall::handle(syscall_num, &args, from_user) as u64, regs);
117 }
118
119 /// 系统调用初始化
arch_syscall_init() -> Result<(), SystemError>120 pub fn arch_syscall_init() -> Result<(), SystemError> {
121 // kinfo!("arch_syscall_init\n");
122 unsafe { set_system_trap_gate(0x80, 0, syscall_int as *mut c_void) }; // 系统调用门
123 return Ok(());
124 }
125
126 #[no_mangle]
rs_do_execve( path: *const u8, argv: *const *const u8, envp: *const *const u8, regs: &mut pt_regs, ) -> usize127 pub unsafe extern "C" fn rs_do_execve(
128 path: *const u8,
129 argv: *const *const u8,
130 envp: *const *const u8,
131 regs: &mut pt_regs,
132 ) -> usize {
133 if path.is_null() {
134 return SystemError::EINVAL.to_posix_errno() as usize;
135 }
136
137 let x = || {
138 let path: String = check_and_clone_cstr(path, Some(MAX_PATHLEN))?;
139 let argv: Vec<String> = check_and_clone_cstr_array(argv)?;
140 let envp: Vec<String> = check_and_clone_cstr_array(envp)?;
141 Ok((path, argv, envp))
142 };
143 let r: Result<(String, Vec<String>, Vec<String>), SystemError> = x();
144 if let Err(e) = r {
145 panic!("Failed to execve: {:?}", e);
146 }
147 let (path, argv, envp) = r.unwrap();
148
149 return tmp_rs_execve(path, argv, envp, regs)
150 .map(|_| 0)
151 .unwrap_or_else(|e| {
152 panic!(
153 "Failed to execve, pid: {} error: {:?}",
154 current_pcb().pid,
155 e
156 )
157 });
158 }
159
160 /// 执行第一个用户进程的函数（只应该被调用一次）
161 ///
162 /// 当进程管理重构完成后，这个函数应该被删除。调整为别的函数。
163 #[no_mangle]
rs_exec_init_process(regs: &mut pt_regs) -> usize164 pub extern "C" fn rs_exec_init_process(regs: &mut pt_regs) -> usize {
165 let path = String::from("/bin/shell.elf");
166 let argv = vec![String::from("/bin/shell.elf")];
167 let envp = vec![String::from("PATH=/bin")];
168 let r = tmp_rs_execve(path, argv, envp, regs);
169 // kdebug!("rs_exec_init_process: r: {:?}\n", r);
170 return r.map(|_| 0).unwrap_or_else(|e| e.to_posix_errno() as usize);
171 }
172
173 /// 临时的execve系统调用实现，以后要把它改为普通的系统调用。
174 ///
175 /// 现在放在这里的原因是，还没有重构中断管理模块，未实现TrapFrame这个抽象，
176 /// 导致我们必须手动设置中断返回时，各个寄存器的值，这个过程很繁琐，所以暂时放在这里。
tmp_rs_execve( path: String, argv: Vec<String>, envp: Vec<String>, regs: &mut pt_regs, ) -> Result<(), SystemError>177 fn tmp_rs_execve(
178 path: String,
179 argv: Vec<String>,
180 envp: Vec<String>,
181 regs: &mut pt_regs,
182 ) -> Result<(), SystemError> {
183 // kdebug!(
184 // "tmp_rs_execve: path: {:?}, argv: {:?}, envp: {:?}\n",
185 // path,
186 // argv,
187 // envp
188 // );
189 // 关中断，防止在设置地址空间的时候，发生中断，然后进调度器，出现错误。
190 let irq_guard = unsafe { CurrentIrqArch::save_and_disable_irq() };
191 // 暂存原本的用户地址空间的引用(因为如果在切换页表之前释放了它，可能会造成内存use after free)
192 let old_address_space = current_pcb().address_space();
193 // 在pcb中原来的用户地址空间
194 unsafe {
195 current_pcb().drop_address_space();
196 }
197 // 创建新的地址空间并设置为当前地址空间
198 let address_space = AddressSpace::new(true).expect("Failed to create new address space");
199 unsafe {
200 current_pcb().set_address_space(address_space.clone());
201 }
202 assert!(
203 AddressSpace::is_current(&address_space),
204 "Failed to set address space"
205 );
206 // kdebug!("Switch to new address space");
207
208 // 切换到新的用户地址空间
209 unsafe { address_space.read().user_mapper.utable.make_current() };
210
211 drop(old_address_space);
212 drop(irq_guard);
213 // kdebug!("to load binary file");
214 let mut param = ExecParam::new(path.as_str(), address_space.clone(), ExecParamFlags::EXEC);
215 // 加载可执行文件
216 let load_result = load_binary_file(&mut param)
217 .unwrap_or_else(|e| panic!("Failed to load binary file: {:?}, path: {:?}", e, path));
218 // kdebug!("load binary file done");
219
220 param.init_info_mut().args = argv;
221 param.init_info_mut().envs = envp;
222
223 // 把proc_init_info写到用户栈上
224
225 let (user_sp, argv_ptr) = unsafe {
226 param
227 .init_info()
228 .push_at(
229 address_space
230 .write()
231 .user_stack_mut()
232 .expect("No user stack found"),
233 )
234 .expect("Failed to push proc_init_info to user stack")
235 };
236
237 // kdebug!("write proc_init_info to user stack done");
238
239 // （兼容旧版libc）把argv的指针写到寄存器内
240 // TODO: 改写旧版libc，不再需要这个兼容
241 regs.rdi = param.init_info().args.len() as u64;
242 regs.rsi = argv_ptr.data() as u64;
243
244 // 设置系统调用返回时的寄存器状态
245 // TODO: 中断管理重构后，这里的寄存器状态设置要删掉！！！改为对trap frame的设置。要增加架构抽象。
246 regs.rsp = user_sp.data() as u64;
247 regs.rbp = user_sp.data() as u64;
248 regs.rip = load_result.entry_point().data() as u64;
249
250 regs.cs = USER_CS as u64 | 3;
251 regs.ds = USER_DS as u64 | 3;
252 regs.ss = USER_DS as u64 | 3;
253 regs.es = 0;
254 regs.rflags = 0x200;
255 regs.rax = 1;
256
257 // kdebug!("regs: {:?}\n", regs);
258
259 // kdebug!(
260 // "tmp_rs_execve: done, load_result.entry_point()={:?}",
261 // load_result.entry_point()
262 // );
263 return Ok(());
264 }
265