1 use core::{intrinsics::unlikely, sync::atomic::Ordering}; 2 3 use alloc::{string::ToString, sync::Arc}; 4 use system_error::SystemError; 5 6 use crate::{ 7 arch::{interrupt::TrapFrame, ipc::signal::Signal}, 8 filesystem::procfs::procfs_register_pid, 9 ipc::signal::flush_signal_handlers, 10 libs::rwlock::RwLock, 11 mm::VirtAddr, 12 process::ProcessFlags, 13 syscall::user_access::UserBufferWriter, 14 }; 15 16 use super::{ 17 kthread::{KernelThreadPcbPrivate, WorkerPrivate}, 18 KernelStack, Pid, ProcessControlBlock, ProcessManager, 19 }; 20 21 bitflags! { 22 /// 进程克隆标志 23 pub struct CloneFlags: u64 { 24 /// 在进程间共享虚拟内存空间 25 const CLONE_VM = 0x00000100; 26 /// 在进程间共享文件系统信息 27 const CLONE_FS = 0x00000200; 28 /// 共享打开的文件 29 const CLONE_FILES = 0x00000400; 30 /// 克隆时，与父进程共享信号处理结构体 31 const CLONE_SIGHAND = 0x00000800; 32 /// 返回进程的文件描述符 33 const CLONE_PIDFD = 0x00001000; 34 /// 使克隆对象成为父进程的跟踪对象 35 const CLONE_PTRACE = 0x00002000; 36 /// 在执行 exec() 或 _exit() 之前挂起父进程的执行 37 const CLONE_VFORK = 0x00004000; 38 /// 使克隆对象的父进程为调用进程的父进程 39 const CLONE_PARENT = 0x00008000; 40 /// 拷贝线程 41 const CLONE_THREAD = 0x00010000; 42 /// 创建一个新的命名空间，其中包含独立的文件系统挂载点层次结构。 43 const CLONE_NEWNS = 0x00020000; 44 /// 与父进程共享 System V 信号量。 45 const CLONE_SYSVSEM = 0x00040000; 46 /// 设置其线程本地存储 47 const CLONE_SETTLS = 0x00080000; 48 /// 设置partent_tid地址为子进程线程 ID 49 const CLONE_PARENT_SETTID = 0x00100000; 50 /// 在子进程中设置一个清除线程 ID 的用户空间地址 51 const CLONE_CHILD_CLEARTID = 0x00200000; 52 /// 创建一个新线程，将其设置为分离状态 53 const CLONE_DETACHED = 0x00400000; 54 /// 使其在创建者进程或线程视角下成为无法跟踪的。 55 const CLONE_UNTRACED = 0x00800000; 56 /// 设置其子进程线程 ID 57 const CLONE_CHILD_SETTID = 0x01000000; 58 /// 将其放置在一个新的 cgroup 命名空间中 59 const CLONE_NEWCGROUP = 0x02000000; 60 /// 将其放置在一个新的 UTS 命名空间中 61 const CLONE_NEWUTS = 0x04000000; 62 /// 将其放置在一个新的 IPC 命名空间中 63 const CLONE_NEWIPC = 0x08000000; 64 /// 将其放置在一个新的用户命名空间中 65 const CLONE_NEWUSER = 0x10000000; 66 /// 将其放置在一个新的 PID 命名空间中 67 const CLONE_NEWPID = 0x20000000; 68 /// 将其放置在一个新的网络命名空间中 69 const CLONE_NEWNET = 0x40000000; 70 /// 在新的 I/O 上下文中运行它 71 const CLONE_IO = 0x80000000; 72 /// 克隆时，与父进程共享信号结构体 73 const CLONE_SIGNAL = 0x00010000 | 0x00000800; 74 /// 克隆时，将原本被设置为SIG_IGNORE的信号，设置回SIG_DEFAULT 75 const CLONE_CLEAR_SIGHAND = 0x100000000; 76 } 77 } 78 79 /// ## clone与clone3系统调用的参数载体 80 /// 81 /// 因为这两个系统调用的参数很多，所以有这样一个载体更灵活 82 /// 83 /// 仅仅作为参数传递 84 #[derive(Debug, Clone, Copy)] 85 pub struct KernelCloneArgs { 86 pub flags: CloneFlags, 87 88 // 下列属性均来自用户空间 89 pub pidfd: VirtAddr, 90 pub child_tid: VirtAddr, 91 pub parent_tid: VirtAddr, 92 pub set_tid: VirtAddr, 93 94 /// 进程退出时发送的信号 95 pub exit_signal: Signal, 96 97 pub stack: usize, 98 // clone3用到 99 pub stack_size: usize, 100 pub tls: usize, 101 102 pub set_tid_size: usize, 103 pub cgroup: i32, 104 105 pub io_thread: bool, 106 pub kthread: bool, 107 pub idle: bool, 108 pub func: VirtAddr, 109 pub fn_arg: VirtAddr, 110 // cgrp 和 cset? 111 } 112 113 impl KernelCloneArgs { 114 pub fn new() -> Self { 115 let null_addr = VirtAddr::new(0); 116 Self { 117 flags: unsafe { CloneFlags::from_bits_unchecked(0) }, 118 pidfd: null_addr, 119 child_tid: null_addr, 120 parent_tid: null_addr, 121 set_tid: null_addr, 122 exit_signal: Signal::SIGCHLD, 123 stack: 0, 124 stack_size: 0, 125 tls: 0, 126 set_tid_size: 0, 127 cgroup: 0, 128 io_thread: false, 129 kthread: false, 130 idle: false, 131 func: null_addr, 132 fn_arg: null_addr, 133 } 134 } 135 } 136 137 impl ProcessManager { 138 /// 创建一个新进程 139 /// 140 /// ## 参数 141 /// 142 /// - `current_trapframe`: 当前进程的trapframe 143 /// - `clone_flags`: 进程克隆标志 144 /// 145 /// ## 返回值 146 /// 147 /// - 成功：返回新进程的pid 148 /// - 失败：返回Err(SystemError)，fork失败的话，子线程不会执行。 149 /// 150 /// ## Safety 151 /// 152 /// - fork失败的话，子线程不会执行。 153 pub fn fork( 154 current_trapframe: &mut TrapFrame, 155 clone_flags: CloneFlags, 156 ) -> Result<Pid, SystemError> { 157 let current_pcb = ProcessManager::current_pcb(); 158 159 let new_kstack: KernelStack = KernelStack::new()?; 160 161 let name = current_pcb.basic().name().to_string(); 162 let pcb = ProcessControlBlock::new(name, new_kstack); 163 164 let mut args = KernelCloneArgs::new(); 165 args.flags = clone_flags; 166 args.exit_signal = Signal::SIGCHLD; 167 168 Self::copy_process(¤t_pcb, &pcb, args, current_trapframe)?; 169 170 ProcessManager::add_pcb(pcb.clone()); 171 172 // 向procfs注册进程 173 procfs_register_pid(pcb.pid()).unwrap_or_else(|e| { 174 panic!( 175 "fork: Failed to register pid to procfs, pid: [{:?}]. Error: {:?}", 176 pcb.pid(), 177 e 178 ) 179 }); 180 181 ProcessManager::wakeup(&pcb).unwrap_or_else(|e| { 182 panic!( 183 "fork: Failed to wakeup new process, pid: [{:?}]. Error: {:?}", 184 pcb.pid(), 185 e 186 ) 187 }); 188 189 return Ok(pcb.pid()); 190 } 191 192 fn copy_flags( 193 clone_flags: &CloneFlags, 194 new_pcb: &Arc<ProcessControlBlock>, 195 ) -> Result<(), SystemError> { 196 if clone_flags.contains(CloneFlags::CLONE_VM) { 197 new_pcb.flags().insert(ProcessFlags::VFORK); 198 } 199 *new_pcb.flags.get_mut() = ProcessManager::current_pcb().flags().clone(); 200 return Ok(()); 201 } 202 203 /// 拷贝进程的地址空间 204 /// 205 /// ## 参数 206 /// 207 /// - `clone_vm`: 是否与父进程共享地址空间。true表示共享 208 /// - `new_pcb`: 新进程的pcb 209 /// 210 /// ## 返回值 211 /// 212 /// - 成功：返回Ok(()) 213 /// - 失败：返回Err(SystemError) 214 /// 215 /// ## Panic 216 /// 217 /// - 如果当前进程没有用户地址空间，则panic 218 #[inline(never)] 219 fn copy_mm( 220 clone_flags: &CloneFlags, 221 current_pcb: &Arc<ProcessControlBlock>, 222 new_pcb: &Arc<ProcessControlBlock>, 223 ) -> Result<(), SystemError> { 224 let old_address_space = current_pcb.basic().user_vm().unwrap_or_else(|| { 225 panic!( 226 "copy_mm: Failed to get address space of current process, current pid: [{:?}]", 227 current_pcb.pid() 228 ) 229 }); 230 231 if clone_flags.contains(CloneFlags::CLONE_VM) { 232 unsafe { new_pcb.basic_mut().set_user_vm(Some(old_address_space)) }; 233 return Ok(()); 234 } 235 let new_address_space = old_address_space.write().try_clone().unwrap_or_else(|e| { 236 panic!( 237 "copy_mm: Failed to clone address space of current process, current pid: [{:?}], new pid: [{:?}]. Error: {:?}", 238 current_pcb.pid(), new_pcb.pid(), e 239 ) 240 }); 241 unsafe { new_pcb.basic_mut().set_user_vm(Some(new_address_space)) }; 242 return Ok(()); 243 } 244 245 fn copy_files( 246 clone_flags: &CloneFlags, 247 current_pcb: &Arc<ProcessControlBlock>, 248 new_pcb: &Arc<ProcessControlBlock>, 249 ) -> Result<(), SystemError> { 250 // 如果不共享文件描述符表，则拷贝文件描述符表 251 if !clone_flags.contains(CloneFlags::CLONE_FILES) { 252 let new_fd_table = current_pcb.basic().fd_table().unwrap().read().clone(); 253 let new_fd_table = Arc::new(RwLock::new(new_fd_table)); 254 new_pcb.basic_mut().set_fd_table(Some(new_fd_table)); 255 } else { 256 // 如果共享文件描述符表，则直接拷贝指针 257 new_pcb 258 .basic_mut() 259 .set_fd_table(current_pcb.basic().fd_table().clone()); 260 } 261 262 return Ok(()); 263 } 264 265 #[allow(dead_code)] 266 fn copy_sighand( 267 clone_flags: &CloneFlags, 268 current_pcb: &Arc<ProcessControlBlock>, 269 new_pcb: &Arc<ProcessControlBlock>, 270 ) -> Result<(), SystemError> { 271 // // 将信号的处理函数设置为default(除了那些被手动屏蔽的) 272 if clone_flags.contains(CloneFlags::CLONE_CLEAR_SIGHAND) { 273 flush_signal_handlers(new_pcb.clone(), false); 274 } 275 276 if clone_flags.contains(CloneFlags::CLONE_SIGHAND) { 277 (*new_pcb.sig_struct()).handlers = current_pcb.sig_struct().handlers.clone(); 278 } 279 return Ok(()); 280 } 281 282 /// 拷贝进程信息 283 /// 284 /// ## panic: 285 /// 某一步拷贝失败时会引发panic 286 /// 例如：copy_mm等失败时会触发panic 287 /// 288 /// ## 参数 289 /// 290 /// - clone_flags 标志位 291 /// - des_pcb 目标pcb 292 /// - src_pcb 拷贝源pcb 293 /// 294 /// ## return 295 /// - 发生错误时返回Err(SystemError) 296 #[inline(never)] 297 pub fn copy_process( 298 current_pcb: &Arc<ProcessControlBlock>, 299 pcb: &Arc<ProcessControlBlock>, 300 clone_args: KernelCloneArgs, 301 current_trapframe: &mut TrapFrame, 302 ) -> Result<(), SystemError> { 303 let clone_flags = clone_args.flags; 304 // 不允许与不同namespace的进程共享根目录 305 if (clone_flags == (CloneFlags::CLONE_NEWNS | CloneFlags::CLONE_FS)) 306 || clone_flags == (CloneFlags::CLONE_NEWUSER | CloneFlags::CLONE_FS) 307 { 308 return Err(SystemError::EINVAL); 309 } 310 311 // 线程组必须共享信号，分离线程只能在线程组内启动。 312 if clone_flags.contains(CloneFlags::CLONE_THREAD) 313 && !clone_flags.contains(CloneFlags::CLONE_SIGHAND) 314 { 315 return Err(SystemError::EINVAL); 316 } 317 318 // 共享信号处理器意味着共享vm。 319 // 线程组也意味着共享vm。阻止这种情况可以简化其他代码。 320 if clone_flags.contains(CloneFlags::CLONE_SIGHAND) 321 && !clone_flags.contains(CloneFlags::CLONE_VM) 322 { 323 return Err(SystemError::EINVAL); 324 } 325 326 // TODO: 处理CLONE_PARENT 与 SIGNAL_UNKILLABLE的情况 327 328 // 如果新进程使用不同的 pid 或 namespace， 329 // 则不允许它与分叉任务共享线程组。 330 if clone_flags.contains(CloneFlags::CLONE_THREAD) { 331 if clone_flags.contains(CloneFlags::CLONE_NEWUSER | CloneFlags::CLONE_NEWPID) { 332 return Err(SystemError::EINVAL); 333 } 334 // TODO: 判断新进程与当前进程namespace是否相同，不同则返回错误 335 } 336 337 // 如果新进程将处于不同的time namespace， 338 // 则不能让它共享vm或线程组。 339 if clone_flags.contains(CloneFlags::CLONE_THREAD | CloneFlags::CLONE_VM) { 340 // TODO: 判断time namespace，不同则返回错误 341 } 342 343 if clone_flags.contains(CloneFlags::CLONE_PIDFD) 344 && clone_flags.contains(CloneFlags::CLONE_DETACHED | CloneFlags::CLONE_THREAD) 345 { 346 return Err(SystemError::EINVAL); 347 } 348 349 // TODO: 克隆前应该锁信号处理，等待克隆完成后再处理 350 351 // 克隆架构相关 352 let guard = current_pcb.arch_info_irqsave(); 353 pcb.arch_info().clone_from(&guard); 354 drop(guard); 355 356 // 为内核线程设置WorkerPrivate 357 if current_pcb.flags().contains(ProcessFlags::KTHREAD) { 358 *pcb.worker_private() = 359 Some(WorkerPrivate::KernelThread(KernelThreadPcbPrivate::new())); 360 } 361 362 // 设置clear_child_tid，在线程结束时将其置0以通知父进程 363 if clone_flags.contains(CloneFlags::CLONE_CHILD_CLEARTID) { 364 pcb.thread.write().clear_child_tid = Some(clone_args.child_tid); 365 } 366 367 // 设置child_tid，意味着子线程能够知道自己的id 368 if clone_flags.contains(CloneFlags::CLONE_CHILD_SETTID) { 369 pcb.thread.write().set_child_tid = Some(clone_args.child_tid); 370 } 371 372 // 将子进程/线程的id存储在用户态传进的地址中 373 if clone_flags.contains(CloneFlags::CLONE_PARENT_SETTID) { 374 let mut writer = UserBufferWriter::new( 375 clone_args.parent_tid.data() as *mut i32, 376 core::mem::size_of::<i32>(), 377 true, 378 )?; 379 380 writer.copy_one_to_user(&(pcb.pid().0 as i32), 0)?; 381 } 382 383 // 拷贝标志位 384 Self::copy_flags(&clone_flags, &pcb).unwrap_or_else(|e| { 385 panic!( 386 "fork: Failed to copy flags from current process, current pid: [{:?}], new pid: [{:?}]. Error: {:?}", 387 current_pcb.pid(), pcb.pid(), e 388 ) 389 }); 390 391 // 拷贝用户地址空间 392 Self::copy_mm(&clone_flags, ¤t_pcb, &pcb).unwrap_or_else(|e| { 393 panic!( 394 "fork: Failed to copy mm from current process, current pid: [{:?}], new pid: [{:?}]. Error: {:?}", 395 current_pcb.pid(), pcb.pid(), e 396 ) 397 }); 398 399 // 拷贝文件描述符表 400 Self::copy_files(&clone_flags, ¤t_pcb, &pcb).unwrap_or_else(|e| { 401 panic!( 402 "fork: Failed to copy files from current process, current pid: [{:?}], new pid: [{:?}]. Error: {:?}", 403 current_pcb.pid(), pcb.pid(), e 404 ) 405 }); 406 407 // 拷贝信号相关数据 408 Self::copy_sighand(&clone_flags, ¤t_pcb, &pcb).map_err(|e| { 409 panic!( 410 "fork: Failed to copy sighand from current process, current pid: [{:?}], new pid: [{:?}]. Error: {:?}", 411 current_pcb.pid(), pcb.pid(), e 412 ) 413 })?; 414 415 // 拷贝线程 416 Self::copy_thread(¤t_pcb, &pcb, clone_args,¤t_trapframe).unwrap_or_else(|e| { 417 panic!( 418 "fork: Failed to copy thread from current process, current pid: [{:?}], new pid: [{:?}]. Error: {:?}", 419 current_pcb.pid(), pcb.pid(), e 420 ) 421 }); 422 423 // 设置线程组id、组长 424 if clone_flags.contains(CloneFlags::CLONE_THREAD) { 425 pcb.thread.write().group_leader = current_pcb.thread.read().group_leader.clone(); 426 unsafe { 427 let ptr = pcb.as_ref() as *const ProcessControlBlock as *mut ProcessControlBlock; 428 (*ptr).tgid = current_pcb.tgid; 429 } 430 } else { 431 pcb.thread.write().group_leader = Arc::downgrade(&pcb); 432 unsafe { 433 let ptr = pcb.as_ref() as *const ProcessControlBlock as *mut ProcessControlBlock; 434 (*ptr).tgid = pcb.tgid; 435 } 436 } 437 438 // CLONE_PARENT re-uses the old parent 439 if clone_flags.contains(CloneFlags::CLONE_PARENT | CloneFlags::CLONE_THREAD) { 440 *pcb.real_parent_pcb.write() = current_pcb.real_parent_pcb.read().clone(); 441 442 if clone_flags.contains(CloneFlags::CLONE_THREAD) { 443 pcb.exit_signal.store(Signal::INVALID, Ordering::SeqCst); 444 } else { 445 let leader = current_pcb.thread.read().group_leader(); 446 if unlikely(leader.is_none()) { 447 panic!( 448 "fork: Failed to get leader of current process, current pid: [{:?}]", 449 current_pcb.pid() 450 ); 451 } 452 453 pcb.exit_signal.store( 454 leader.unwrap().exit_signal.load(Ordering::SeqCst), 455 Ordering::SeqCst, 456 ); 457 } 458 } else { 459 // 新创建的进程，设置其父进程为当前进程 460 *pcb.real_parent_pcb.write() = Arc::downgrade(¤t_pcb); 461 pcb.exit_signal 462 .store(clone_args.exit_signal, Ordering::SeqCst); 463 } 464 465 // todo: 增加线程组相关的逻辑。 参考 https://opengrok.ringotek.cn/xref/linux-6.1.9/kernel/fork.c#2437 466 467 Ok(()) 468 } 469 } 470