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: &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 163 let pcb = ProcessControlBlock::new(name, new_kstack); 164 165 let mut args = KernelCloneArgs::new(); 166 args.flags = clone_flags; 167 args.exit_signal = Signal::SIGCHLD; 168 169 Self::copy_process(¤t_pcb, &pcb, args, current_trapframe)?; 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_irqsave().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 #[inline(never)] 246 fn copy_files( 247 clone_flags: &CloneFlags, 248 current_pcb: &Arc<ProcessControlBlock>, 249 new_pcb: &Arc<ProcessControlBlock>, 250 ) -> Result<(), SystemError> { 251 // 如果不共享文件描述符表，则拷贝文件描述符表 252 if !clone_flags.contains(CloneFlags::CLONE_FILES) { 253 let new_fd_table = current_pcb.basic().fd_table().unwrap().read().clone(); 254 let new_fd_table = Arc::new(RwLock::new(new_fd_table)); 255 new_pcb.basic_mut().set_fd_table(Some(new_fd_table)); 256 } else { 257 // 如果共享文件描述符表，则直接拷贝指针 258 new_pcb 259 .basic_mut() 260 .set_fd_table(current_pcb.basic().fd_table().clone()); 261 } 262 263 return Ok(()); 264 } 265 266 #[allow(dead_code)] 267 fn copy_sighand( 268 clone_flags: &CloneFlags, 269 current_pcb: &Arc<ProcessControlBlock>, 270 new_pcb: &Arc<ProcessControlBlock>, 271 ) -> Result<(), SystemError> { 272 // // 将信号的处理函数设置为default(除了那些被手动屏蔽的) 273 if clone_flags.contains(CloneFlags::CLONE_CLEAR_SIGHAND) { 274 flush_signal_handlers(new_pcb.clone(), false); 275 } 276 277 if clone_flags.contains(CloneFlags::CLONE_SIGHAND) { 278 (*new_pcb.sig_struct_irqsave()).handlers = 279 current_pcb.sig_struct_irqsave().handlers.clone(); 280 } 281 return Ok(()); 282 } 283 284 /// 拷贝进程信息 285 /// 286 /// ## panic: 287 /// 某一步拷贝失败时会引发panic 288 /// 例如：copy_mm等失败时会触发panic 289 /// 290 /// ## 参数 291 /// 292 /// - clone_flags 标志位 293 /// - current_pcb 拷贝源pcb 294 /// - pcb 目标pcb 295 /// 296 /// ## return 297 /// - 发生错误时返回Err(SystemError) 298 #[inline(never)] 299 pub fn copy_process( 300 current_pcb: &Arc<ProcessControlBlock>, 301 pcb: &Arc<ProcessControlBlock>, 302 clone_args: KernelCloneArgs, 303 current_trapframe: &TrapFrame, 304 ) -> Result<(), SystemError> { 305 let clone_flags = clone_args.flags; 306 // 不允许与不同namespace的进程共享根目录 307 if (clone_flags == (CloneFlags::CLONE_NEWNS | CloneFlags::CLONE_FS)) 308 || clone_flags == (CloneFlags::CLONE_NEWUSER | CloneFlags::CLONE_FS) 309 { 310 return Err(SystemError::EINVAL); 311 } 312 313 // 线程组必须共享信号，分离线程只能在线程组内启动。 314 if clone_flags.contains(CloneFlags::CLONE_THREAD) 315 && !clone_flags.contains(CloneFlags::CLONE_SIGHAND) 316 { 317 return Err(SystemError::EINVAL); 318 } 319 320 // 共享信号处理器意味着共享vm。 321 // 线程组也意味着共享vm。阻止这种情况可以简化其他代码。 322 if clone_flags.contains(CloneFlags::CLONE_SIGHAND) 323 && !clone_flags.contains(CloneFlags::CLONE_VM) 324 { 325 return Err(SystemError::EINVAL); 326 } 327 328 // TODO: 处理CLONE_PARENT 与 SIGNAL_UNKILLABLE的情况 329 330 // 如果新进程使用不同的 pid 或 namespace， 331 // 则不允许它与分叉任务共享线程组。 332 if clone_flags.contains(CloneFlags::CLONE_THREAD) { 333 if clone_flags.contains(CloneFlags::CLONE_NEWUSER | CloneFlags::CLONE_NEWPID) { 334 return Err(SystemError::EINVAL); 335 } 336 // TODO: 判断新进程与当前进程namespace是否相同，不同则返回错误 337 } 338 339 // 如果新进程将处于不同的time namespace， 340 // 则不能让它共享vm或线程组。 341 if clone_flags.contains(CloneFlags::CLONE_THREAD | CloneFlags::CLONE_VM) { 342 // TODO: 判断time namespace，不同则返回错误 343 } 344 345 if clone_flags.contains(CloneFlags::CLONE_PIDFD) 346 && clone_flags.contains(CloneFlags::CLONE_DETACHED | CloneFlags::CLONE_THREAD) 347 { 348 return Err(SystemError::EINVAL); 349 } 350 351 // TODO: 克隆前应该锁信号处理，等待克隆完成后再处理 352 353 // 克隆架构相关 354 let guard = current_pcb.arch_info_irqsave(); 355 unsafe { pcb.arch_info().clone_from(&guard) }; 356 drop(guard); 357 358 // 为内核线程设置WorkerPrivate 359 if current_pcb.flags().contains(ProcessFlags::KTHREAD) { 360 *pcb.worker_private() = 361 Some(WorkerPrivate::KernelThread(KernelThreadPcbPrivate::new())); 362 } 363 364 // 设置clear_child_tid，在线程结束时将其置0以通知父进程 365 if clone_flags.contains(CloneFlags::CLONE_CHILD_CLEARTID) { 366 pcb.thread.write().clear_child_tid = Some(clone_args.child_tid); 367 } 368 369 // 设置child_tid，意味着子线程能够知道自己的id 370 if clone_flags.contains(CloneFlags::CLONE_CHILD_SETTID) { 371 pcb.thread.write().set_child_tid = Some(clone_args.child_tid); 372 } 373 374 // 将子进程/线程的id存储在用户态传进的地址中 375 if clone_flags.contains(CloneFlags::CLONE_PARENT_SETTID) { 376 let mut writer = UserBufferWriter::new( 377 clone_args.parent_tid.data() as *mut i32, 378 core::mem::size_of::<i32>(), 379 true, 380 )?; 381 382 writer.copy_one_to_user(&(pcb.pid().0 as i32), 0)?; 383 } 384 385 // 拷贝标志位 386 Self::copy_flags(&clone_flags, &pcb).unwrap_or_else(|e| { 387 panic!( 388 "fork: Failed to copy flags from current process, current pid: [{:?}], new pid: [{:?}]. Error: {:?}", 389 current_pcb.pid(), pcb.pid(), e 390 ) 391 }); 392 393 // 拷贝用户地址空间 394 Self::copy_mm(&clone_flags, ¤t_pcb, &pcb).unwrap_or_else(|e| { 395 panic!( 396 "fork: Failed to copy mm from current process, current pid: [{:?}], new pid: [{:?}]. Error: {:?}", 397 current_pcb.pid(), pcb.pid(), e 398 ) 399 }); 400 401 // 拷贝文件描述符表 402 Self::copy_files(&clone_flags, ¤t_pcb, &pcb).unwrap_or_else(|e| { 403 panic!( 404 "fork: Failed to copy files from current process, current pid: [{:?}], new pid: [{:?}]. Error: {:?}", 405 current_pcb.pid(), pcb.pid(), e 406 ) 407 }); 408 409 // 拷贝信号相关数据 410 Self::copy_sighand(&clone_flags, ¤t_pcb, &pcb).map_err(|e| { 411 panic!( 412 "fork: Failed to copy sighand from current process, current pid: [{:?}], new pid: [{:?}]. Error: {:?}", 413 current_pcb.pid(), pcb.pid(), e 414 ) 415 })?; 416 417 // 拷贝线程 418 Self::copy_thread(¤t_pcb, &pcb, clone_args,¤t_trapframe).unwrap_or_else(|e| { 419 panic!( 420 "fork: Failed to copy thread from current process, current pid: [{:?}], new pid: [{:?}]. Error: {:?}", 421 current_pcb.pid(), pcb.pid(), e 422 ) 423 }); 424 425 // 设置线程组id、组长 426 if clone_flags.contains(CloneFlags::CLONE_THREAD) { 427 pcb.thread.write().group_leader = current_pcb.thread.read().group_leader.clone(); 428 unsafe { 429 let ptr = pcb.as_ref() as *const ProcessControlBlock as *mut ProcessControlBlock; 430 (*ptr).tgid = current_pcb.tgid; 431 } 432 } else { 433 pcb.thread.write().group_leader = Arc::downgrade(&pcb); 434 unsafe { 435 let ptr = pcb.as_ref() as *const ProcessControlBlock as *mut ProcessControlBlock; 436 (*ptr).tgid = pcb.tgid; 437 } 438 } 439 440 // CLONE_PARENT re-uses the old parent 441 if clone_flags.contains(CloneFlags::CLONE_PARENT | CloneFlags::CLONE_THREAD) { 442 *pcb.real_parent_pcb.write() = current_pcb.real_parent_pcb.read().clone(); 443 444 if clone_flags.contains(CloneFlags::CLONE_THREAD) { 445 pcb.exit_signal.store(Signal::INVALID, Ordering::SeqCst); 446 } else { 447 let leader = current_pcb.thread.read().group_leader(); 448 if unlikely(leader.is_none()) { 449 panic!( 450 "fork: Failed to get leader of current process, current pid: [{:?}]", 451 current_pcb.pid() 452 ); 453 } 454 455 pcb.exit_signal.store( 456 leader.unwrap().exit_signal.load(Ordering::SeqCst), 457 Ordering::SeqCst, 458 ); 459 } 460 } else { 461 // 新创建的进程，设置其父进程为当前进程 462 *pcb.real_parent_pcb.write() = Arc::downgrade(¤t_pcb); 463 pcb.exit_signal 464 .store(clone_args.exit_signal, Ordering::SeqCst); 465 } 466 467 // todo: 增加线程组相关的逻辑。 参考 https://code.dragonos.org.cn/xref/linux-6.1.9/kernel/fork.c#2437 468 469 Ok(()) 470 } 471 } 472