Now available: The Design and Implementation of the FreeBSD Operating System (Second Edition)
[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]
FreeBSD/Linux Kernel Cross Reference
sys/kern/kern_fork.c
Version:
- FREEBSD - FREEBSD-13-STABLE - FREEBSD-13-0 - FREEBSD-12-STABLE - FREEBSD-12-0 - FREEBSD-11-STABLE - FREEBSD-11-0 - FREEBSD-10-STABLE - FREEBSD-10-0 - FREEBSD-9-STABLE - FREEBSD-9-0 - FREEBSD-8-STABLE - FREEBSD-8-0 - FREEBSD-7-STABLE - FREEBSD-7-0 - FREEBSD-6-STABLE - FREEBSD-6-0 - FREEBSD-5-STABLE - FREEBSD-5-0 - FREEBSD-4-STABLE - FREEBSD-3-STABLE - FREEBSD22 - l41 - OPENBSD - linux-2.6 - MK84 - PLAN9 - xnu-8792
SearchContext: - none - 3 - 10
SearchContext: - none - 3 - 10
1 /*- 2 * Copyright (c) 1982, 1986, 1989, 1991, 1993 3 * The Regents of the University of California. All rights reserved. 4 * (c) UNIX System Laboratories, Inc. 5 * All or some portions of this file are derived from material licensed 6 * to the University of California by American Telephone and Telegraph 7 * Co. or Unix System Laboratories, Inc. and are reproduced herein with 8 * the permission of UNIX System Laboratories, Inc. 9 * 10 * Redistribution and use in source and binary forms, with or without 11 * modification, are permitted provided that the following conditions 12 * are met: 13 * 1. Redistributions of source code must retain the above copyright 14 * notice, this list of conditions and the following disclaimer. 15 * 2. Redistributions in binary form must reproduce the above copyright 16 * notice, this list of conditions and the following disclaimer in the 17 * documentation and/or other materials provided with the distribution. 18 * 4. Neither the name of the University nor the names of its contributors 19 * may be used to endorse or promote products derived from this software 20 * without specific prior written permission. 21 * 22 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND 23 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 24 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 25 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE 26 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 27 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 28 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 29 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 30 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 31 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 32 * SUCH DAMAGE. 33 * 34 * @(#)kern_fork.c 8.6 (Berkeley) 4/8/94 35 */ 36 37 #include <sys/cdefs.h> 38 __FBSDID("$FreeBSD: releng/11.1/sys/kern/kern_fork.c 318192 2017-05-11 17:26:34Z jhb $"); 39 40 #include "opt_ktrace.h" 41 #include "opt_kstack_pages.h" 42 43 #include <sys/param.h> 44 #include <sys/systm.h> 45 #include <sys/sysproto.h> 46 #include <sys/eventhandler.h> 47 #include <sys/fcntl.h> 48 #include <sys/filedesc.h> 49 #include <sys/jail.h> 50 #include <sys/kernel.h> 51 #include <sys/kthread.h> 52 #include <sys/sysctl.h> 53 #include <sys/lock.h> 54 #include <sys/malloc.h> 55 #include <sys/mutex.h> 56 #include <sys/priv.h> 57 #include <sys/proc.h> 58 #include <sys/procdesc.h> 59 #include <sys/pioctl.h> 60 #include <sys/ptrace.h> 61 #include <sys/racct.h> 62 #include <sys/resourcevar.h> 63 #include <sys/sched.h> 64 #include <sys/syscall.h> 65 #include <sys/vmmeter.h> 66 #include <sys/vnode.h> 67 #include <sys/acct.h> 68 #include <sys/ktr.h> 69 #include <sys/ktrace.h> 70 #include <sys/unistd.h> 71 #include <sys/sdt.h> 72 #include <sys/sx.h> 73 #include <sys/sysent.h> 74 #include <sys/signalvar.h> 75 76 #include <security/audit/audit.h> 77 #include <security/mac/mac_framework.h> 78 79 #include <vm/vm.h> 80 #include <vm/pmap.h> 81 #include <vm/vm_map.h> 82 #include <vm/vm_extern.h> 83 #include <vm/uma.h> 84 #include <vm/vm_domain.h> 85 86 #ifdef KDTRACE_HOOKS 87 #include <sys/dtrace_bsd.h> 88 dtrace_fork_func_t dtrace_fasttrap_fork; 89 #endif 90 91 SDT_PROVIDER_DECLARE(proc); 92 SDT_PROBE_DEFINE3(proc, , , create, "struct proc *", "struct proc *", "int"); 93 94 #ifndef _SYS_SYSPROTO_H_ 95 struct fork_args { 96 int dummy; 97 }; 98 #endif 99 100 /* ARGSUSED */ 101 int 102 sys_fork(struct thread *td, struct fork_args *uap) 103 { 104 struct fork_req fr; 105 int error, pid; 106 107 bzero(&fr, sizeof(fr)); 108 fr.fr_flags = RFFDG | RFPROC; 109 fr.fr_pidp = &pid; 110 error = fork1(td, &fr); 111 if (error == 0) { 112 td->td_retval[0] = pid; 113 td->td_retval[1] = 0; 114 } 115 return (error); 116 } 117 118 /* ARGUSED */ 119 int 120 sys_pdfork(struct thread *td, struct pdfork_args *uap) 121 { 122 struct fork_req fr; 123 int error, fd, pid; 124 125 bzero(&fr, sizeof(fr)); 126 fr.fr_flags = RFFDG | RFPROC | RFPROCDESC; 127 fr.fr_pidp = &pid; 128 fr.fr_pd_fd = &fd; 129 fr.fr_pd_flags = uap->flags; 130 /* 131 * It is necessary to return fd by reference because 0 is a valid file 132 * descriptor number, and the child needs to be able to distinguish 133 * itself from the parent using the return value. 134 */ 135 error = fork1(td, &fr); 136 if (error == 0) { 137 td->td_retval[0] = pid; 138 td->td_retval[1] = 0; 139 error = copyout(&fd, uap->fdp, sizeof(fd)); 140 } 141 return (error); 142 } 143 144 /* ARGSUSED */ 145 int 146 sys_vfork(struct thread *td, struct vfork_args *uap) 147 { 148 struct fork_req fr; 149 int error, pid; 150 151 bzero(&fr, sizeof(fr)); 152 fr.fr_flags = RFFDG | RFPROC | RFPPWAIT | RFMEM; 153 fr.fr_pidp = &pid; 154 error = fork1(td, &fr); 155 if (error == 0) { 156 td->td_retval[0] = pid; 157 td->td_retval[1] = 0; 158 } 159 return (error); 160 } 161 162 int 163 sys_rfork(struct thread *td, struct rfork_args *uap) 164 { 165 struct fork_req fr; 166 int error, pid; 167 168 /* Don't allow kernel-only flags. */ 169 if ((uap->flags & RFKERNELONLY) != 0) 170 return (EINVAL); 171 172 AUDIT_ARG_FFLAGS(uap->flags); 173 bzero(&fr, sizeof(fr)); 174 fr.fr_flags = uap->flags; 175 fr.fr_pidp = &pid; 176 error = fork1(td, &fr); 177 if (error == 0) { 178 td->td_retval[0] = pid; 179 td->td_retval[1] = 0; 180 } 181 return (error); 182 } 183 184 int nprocs = 1; /* process 0 */ 185 int lastpid = 0; 186 SYSCTL_INT(_kern, OID_AUTO, lastpid, CTLFLAG_RD, &lastpid, 0, 187 "Last used PID"); 188 189 /* 190 * Random component to lastpid generation. We mix in a random factor to make 191 * it a little harder to predict. We sanity check the modulus value to avoid 192 * doing it in critical paths. Don't let it be too small or we pointlessly 193 * waste randomness entropy, and don't let it be impossibly large. Using a 194 * modulus that is too big causes a LOT more process table scans and slows 195 * down fork processing as the pidchecked caching is defeated. 196 */ 197 static int randompid = 0; 198 199 static int 200 sysctl_kern_randompid(SYSCTL_HANDLER_ARGS) 201 { 202 int error, pid; 203 204 error = sysctl_wire_old_buffer(req, sizeof(int)); 205 if (error != 0) 206 return(error); 207 sx_xlock(&allproc_lock); 208 pid = randompid; 209 error = sysctl_handle_int(oidp, &pid, 0, req); 210 if (error == 0 && req->newptr != NULL) { 211 if (pid < 0 || pid > pid_max - 100) /* out of range */ 212 pid = pid_max - 100; 213 else if (pid < 2) /* NOP */ 214 pid = 0; 215 else if (pid < 100) /* Make it reasonable */ 216 pid = 100; 217 randompid = pid; 218 } 219 sx_xunlock(&allproc_lock); 220 return (error); 221 } 222 223 SYSCTL_PROC(_kern, OID_AUTO, randompid, CTLTYPE_INT|CTLFLAG_RW, 224 0, 0, sysctl_kern_randompid, "I", "Random PID modulus"); 225 226 static int 227 fork_findpid(int flags) 228 { 229 struct proc *p; 230 int trypid; 231 static int pidchecked = 0; 232 233 /* 234 * Requires allproc_lock in order to iterate over the list 235 * of processes, and proctree_lock to access p_pgrp. 236 */ 237 sx_assert(&allproc_lock, SX_LOCKED); 238 sx_assert(&proctree_lock, SX_LOCKED); 239 240 /* 241 * Find an unused process ID. We remember a range of unused IDs 242 * ready to use (from lastpid+1 through pidchecked-1). 243 * 244 * If RFHIGHPID is set (used during system boot), do not allocate 245 * low-numbered pids. 246 */ 247 trypid = lastpid + 1; 248 if (flags & RFHIGHPID) { 249 if (trypid < 10) 250 trypid = 10; 251 } else { 252 if (randompid) 253 trypid += arc4random() % randompid; 254 } 255 retry: 256 /* 257 * If the process ID prototype has wrapped around, 258 * restart somewhat above 0, as the low-numbered procs 259 * tend to include daemons that don't exit. 260 */ 261 if (trypid >= pid_max) { 262 trypid = trypid % pid_max; 263 if (trypid < 100) 264 trypid += 100; 265 pidchecked = 0; 266 } 267 if (trypid >= pidchecked) { 268 int doingzomb = 0; 269 270 pidchecked = PID_MAX; 271 /* 272 * Scan the active and zombie procs to check whether this pid 273 * is in use. Remember the lowest pid that's greater 274 * than trypid, so we can avoid checking for a while. 275 * 276 * Avoid reuse of the process group id, session id or 277 * the reaper subtree id. Note that for process group 278 * and sessions, the amount of reserved pids is 279 * limited by process limit. For the subtree ids, the 280 * id is kept reserved only while there is a 281 * non-reaped process in the subtree, so amount of 282 * reserved pids is limited by process limit times 283 * two. 284 */ 285 p = LIST_FIRST(&allproc); 286 again: 287 for (; p != NULL; p = LIST_NEXT(p, p_list)) { 288 while (p->p_pid == trypid || 289 p->p_reapsubtree == trypid || 290 (p->p_pgrp != NULL && 291 (p->p_pgrp->pg_id == trypid || 292 (p->p_session != NULL && 293 p->p_session->s_sid == trypid)))) { 294 trypid++; 295 if (trypid >= pidchecked) 296 goto retry; 297 } 298 if (p->p_pid > trypid && pidchecked > p->p_pid) 299 pidchecked = p->p_pid; 300 if (p->p_pgrp != NULL) { 301 if (p->p_pgrp->pg_id > trypid && 302 pidchecked > p->p_pgrp->pg_id) 303 pidchecked = p->p_pgrp->pg_id; 304 if (p->p_session != NULL && 305 p->p_session->s_sid > trypid && 306 pidchecked > p->p_session->s_sid) 307 pidchecked = p->p_session->s_sid; 308 } 309 } 310 if (!doingzomb) { 311 doingzomb = 1; 312 p = LIST_FIRST(&zombproc); 313 goto again; 314 } 315 } 316 317 /* 318 * RFHIGHPID does not mess with the lastpid counter during boot. 319 */ 320 if (flags & RFHIGHPID) 321 pidchecked = 0; 322 else 323 lastpid = trypid; 324 325 return (trypid); 326 } 327 328 static int 329 fork_norfproc(struct thread *td, int flags) 330 { 331 int error; 332 struct proc *p1; 333 334 KASSERT((flags & RFPROC) == 0, 335 ("fork_norfproc called with RFPROC set")); 336 p1 = td->td_proc; 337 338 if (((p1->p_flag & (P_HADTHREADS|P_SYSTEM)) == P_HADTHREADS) && 339 (flags & (RFCFDG | RFFDG))) { 340 PROC_LOCK(p1); 341 if (thread_single(p1, SINGLE_BOUNDARY)) { 342 PROC_UNLOCK(p1); 343 return (ERESTART); 344 } 345 PROC_UNLOCK(p1); 346 } 347 348 error = vm_forkproc(td, NULL, NULL, NULL, flags); 349 if (error) 350 goto fail; 351 352 /* 353 * Close all file descriptors. 354 */ 355 if (flags & RFCFDG) { 356 struct filedesc *fdtmp; 357 fdtmp = fdinit(td->td_proc->p_fd, false); 358 fdescfree(td); 359 p1->p_fd = fdtmp; 360 } 361 362 /* 363 * Unshare file descriptors (from parent). 364 */ 365 if (flags & RFFDG) 366 fdunshare(td); 367 368 fail: 369 if (((p1->p_flag & (P_HADTHREADS|P_SYSTEM)) == P_HADTHREADS) && 370 (flags & (RFCFDG | RFFDG))) { 371 PROC_LOCK(p1); 372 thread_single_end(p1, SINGLE_BOUNDARY); 373 PROC_UNLOCK(p1); 374 } 375 return (error); 376 } 377 378 static void 379 do_fork(struct thread *td, struct fork_req *fr, struct proc *p2, struct thread *td2, 380 struct vmspace *vm2, struct file *fp_procdesc) 381 { 382 struct proc *p1, *pptr; 383 int trypid; 384 struct filedesc *fd; 385 struct filedesc_to_leader *fdtol; 386 struct sigacts *newsigacts; 387 388 sx_assert(&proctree_lock, SX_SLOCKED); 389 sx_assert(&allproc_lock, SX_XLOCKED); 390 391 p1 = td->td_proc; 392 393 trypid = fork_findpid(fr->fr_flags); 394 395 sx_sunlock(&proctree_lock); 396 397 p2->p_state = PRS_NEW; /* protect against others */ 398 p2->p_pid = trypid; 399 AUDIT_ARG_PID(p2->p_pid); 400 LIST_INSERT_HEAD(&allproc, p2, p_list); 401 allproc_gen++; 402 LIST_INSERT_HEAD(PIDHASH(p2->p_pid), p2, p_hash); 403 tidhash_add(td2); 404 PROC_LOCK(p2); 405 PROC_LOCK(p1); 406 407 sx_xunlock(&allproc_lock); 408 409 bcopy(&p1->p_startcopy, &p2->p_startcopy, 410 __rangeof(struct proc, p_startcopy, p_endcopy)); 411 p2->p_elf_machine = p1->p_elf_machine; 412 p2->p_elf_flags = p1->p_elf_flags; 413 pargs_hold(p2->p_args); 414 415 PROC_UNLOCK(p1); 416 417 bzero(&p2->p_startzero, 418 __rangeof(struct proc, p_startzero, p_endzero)); 419 p2->p_ptevents = 0; 420 421 /* Tell the prison that we exist. */ 422 prison_proc_hold(p2->p_ucred->cr_prison); 423 424 PROC_UNLOCK(p2); 425 426 /* 427 * Malloc things while we don't hold any locks. 428 */ 429 if (fr->fr_flags & RFSIGSHARE) 430 newsigacts = NULL; 431 else 432 newsigacts = sigacts_alloc(); 433 434 /* 435 * Copy filedesc. 436 */ 437 if (fr->fr_flags & RFCFDG) { 438 fd = fdinit(p1->p_fd, false); 439 fdtol = NULL; 440 } else if (fr->fr_flags & RFFDG) { 441 fd = fdcopy(p1->p_fd); 442 fdtol = NULL; 443 } else { 444 fd = fdshare(p1->p_fd); 445 if (p1->p_fdtol == NULL) 446 p1->p_fdtol = filedesc_to_leader_alloc(NULL, NULL, 447 p1->p_leader); 448 if ((fr->fr_flags & RFTHREAD) != 0) { 449 /* 450 * Shared file descriptor table, and shared 451 * process leaders. 452 */ 453 fdtol = p1->p_fdtol; 454 FILEDESC_XLOCK(p1->p_fd); 455 fdtol->fdl_refcount++; 456 FILEDESC_XUNLOCK(p1->p_fd); 457 } else { 458 /* 459 * Shared file descriptor table, and different 460 * process leaders. 461 */ 462 fdtol = filedesc_to_leader_alloc(p1->p_fdtol, 463 p1->p_fd, p2); 464 } 465 } 466 /* 467 * Make a proc table entry for the new process. 468 * Start by zeroing the section of proc that is zero-initialized, 469 * then copy the section that is copied directly from the parent. 470 */ 471 472 PROC_LOCK(p2); 473 PROC_LOCK(p1); 474 475 bzero(&td2->td_startzero, 476 __rangeof(struct thread, td_startzero, td_endzero)); 477 td2->td_sleeptimo = 0; 478 479 bcopy(&td->td_startcopy, &td2->td_startcopy, 480 __rangeof(struct thread, td_startcopy, td_endcopy)); 481 482 bcopy(&p2->p_comm, &td2->td_name, sizeof(td2->td_name)); 483 td2->td_sigstk = td->td_sigstk; 484 td2->td_flags = TDF_INMEM; 485 td2->td_lend_user_pri = PRI_MAX; 486 487 #ifdef VIMAGE 488 td2->td_vnet = NULL; 489 td2->td_vnet_lpush = NULL; 490 #endif 491 492 /* 493 * Allow the scheduler to initialize the child. 494 */ 495 thread_lock(td); 496 sched_fork(td, td2); 497 thread_unlock(td); 498 499 /* 500 * Duplicate sub-structures as needed. 501 * Increase reference counts on shared objects. 502 */ 503 p2->p_flag = P_INMEM; 504 p2->p_flag2 = p1->p_flag2 & (P2_NOTRACE | P2_NOTRACE_EXEC | P2_TRAPCAP); 505 p2->p_swtick = ticks; 506 if (p1->p_flag & P_PROFIL) 507 startprofclock(p2); 508 509 /* 510 * Whilst the proc lock is held, copy the VM domain data out 511 * using the VM domain method. 512 */ 513 vm_domain_policy_init(&p2->p_vm_dom_policy); 514 vm_domain_policy_localcopy(&p2->p_vm_dom_policy, 515 &p1->p_vm_dom_policy); 516 517 if (fr->fr_flags & RFSIGSHARE) { 518 p2->p_sigacts = sigacts_hold(p1->p_sigacts); 519 } else { 520 sigacts_copy(newsigacts, p1->p_sigacts); 521 p2->p_sigacts = newsigacts; 522 } 523 524 if (fr->fr_flags & RFTSIGZMB) 525 p2->p_sigparent = RFTSIGNUM(fr->fr_flags); 526 else if (fr->fr_flags & RFLINUXTHPN) 527 p2->p_sigparent = SIGUSR1; 528 else 529 p2->p_sigparent = SIGCHLD; 530 531 p2->p_textvp = p1->p_textvp; 532 p2->p_fd = fd; 533 p2->p_fdtol = fdtol; 534 535 if (p1->p_flag2 & P2_INHERIT_PROTECTED) { 536 p2->p_flag |= P_PROTECTED; 537 p2->p_flag2 |= P2_INHERIT_PROTECTED; 538 } 539 540 /* 541 * p_limit is copy-on-write. Bump its refcount. 542 */ 543 lim_fork(p1, p2); 544 545 thread_cow_get_proc(td2, p2); 546 547 pstats_fork(p1->p_stats, p2->p_stats); 548 549 PROC_UNLOCK(p1); 550 PROC_UNLOCK(p2); 551 552 /* Bump references to the text vnode (for procfs). */ 553 if (p2->p_textvp) 554 vrefact(p2->p_textvp); 555 556 /* 557 * Set up linkage for kernel based threading. 558 */ 559 if ((fr->fr_flags & RFTHREAD) != 0) { 560 mtx_lock(&ppeers_lock); 561 p2->p_peers = p1->p_peers; 562 p1->p_peers = p2; 563 p2->p_leader = p1->p_leader; 564 mtx_unlock(&ppeers_lock); 565 PROC_LOCK(p1->p_leader); 566 if ((p1->p_leader->p_flag & P_WEXIT) != 0) { 567 PROC_UNLOCK(p1->p_leader); 568 /* 569 * The task leader is exiting, so process p1 is 570 * going to be killed shortly. Since p1 obviously 571 * isn't dead yet, we know that the leader is either 572 * sending SIGKILL's to all the processes in this 573 * task or is sleeping waiting for all the peers to 574 * exit. We let p1 complete the fork, but we need 575 * to go ahead and kill the new process p2 since 576 * the task leader may not get a chance to send 577 * SIGKILL to it. We leave it on the list so that 578 * the task leader will wait for this new process 579 * to commit suicide. 580 */ 581 PROC_LOCK(p2); 582 kern_psignal(p2, SIGKILL); 583 PROC_UNLOCK(p2); 584 } else 585 PROC_UNLOCK(p1->p_leader); 586 } else { 587 p2->p_peers = NULL; 588 p2->p_leader = p2; 589 } 590 591 sx_xlock(&proctree_lock); 592 PGRP_LOCK(p1->p_pgrp); 593 PROC_LOCK(p2); 594 PROC_LOCK(p1); 595 596 /* 597 * Preserve some more flags in subprocess. P_PROFIL has already 598 * been preserved. 599 */ 600 p2->p_flag |= p1->p_flag & P_SUGID; 601 td2->td_pflags |= (td->td_pflags & TDP_ALTSTACK) | TDP_FORKING; 602 SESS_LOCK(p1->p_session); 603 if (p1->p_session->s_ttyvp != NULL && p1->p_flag & P_CONTROLT) 604 p2->p_flag |= P_CONTROLT; 605 SESS_UNLOCK(p1->p_session); 606 if (fr->fr_flags & RFPPWAIT) 607 p2->p_flag |= P_PPWAIT; 608 609 p2->p_pgrp = p1->p_pgrp; 610 LIST_INSERT_AFTER(p1, p2, p_pglist); 611 PGRP_UNLOCK(p1->p_pgrp); 612 LIST_INIT(&p2->p_children); 613 LIST_INIT(&p2->p_orphans); 614 615 callout_init_mtx(&p2->p_itcallout, &p2->p_mtx, 0); 616 617 /* 618 * If PF_FORK is set, the child process inherits the 619 * procfs ioctl flags from its parent. 620 */ 621 if (p1->p_pfsflags & PF_FORK) { 622 p2->p_stops = p1->p_stops; 623 p2->p_pfsflags = p1->p_pfsflags; 624 } 625 626 /* 627 * This begins the section where we must prevent the parent 628 * from being swapped. 629 */ 630 _PHOLD(p1); 631 PROC_UNLOCK(p1); 632 633 /* 634 * Attach the new process to its parent. 635 * 636 * If RFNOWAIT is set, the newly created process becomes a child 637 * of init. This effectively disassociates the child from the 638 * parent. 639 */ 640 if ((fr->fr_flags & RFNOWAIT) != 0) { 641 pptr = p1->p_reaper; 642 p2->p_reaper = pptr; 643 } else { 644 p2->p_reaper = (p1->p_treeflag & P_TREE_REAPER) != 0 ? 645 p1 : p1->p_reaper; 646 pptr = p1; 647 } 648 p2->p_pptr = pptr; 649 LIST_INSERT_HEAD(&pptr->p_children, p2, p_sibling); 650 LIST_INIT(&p2->p_reaplist); 651 LIST_INSERT_HEAD(&p2->p_reaper->p_reaplist, p2, p_reapsibling); 652 if (p2->p_reaper == p1) 653 p2->p_reapsubtree = p2->p_pid; 654 sx_xunlock(&proctree_lock); 655 656 /* Inform accounting that we have forked. */ 657 p2->p_acflag = AFORK; 658 PROC_UNLOCK(p2); 659 660 #ifdef KTRACE 661 ktrprocfork(p1, p2); 662 #endif 663 664 /* 665 * Finish creating the child process. It will return via a different 666 * execution path later. (ie: directly into user mode) 667 */ 668 vm_forkproc(td, p2, td2, vm2, fr->fr_flags); 669 670 if (fr->fr_flags == (RFFDG | RFPROC)) { 671 PCPU_INC(cnt.v_forks); 672 PCPU_ADD(cnt.v_forkpages, p2->p_vmspace->vm_dsize + 673 p2->p_vmspace->vm_ssize); 674 } else if (fr->fr_flags == (RFFDG | RFPROC | RFPPWAIT | RFMEM)) { 675 PCPU_INC(cnt.v_vforks); 676 PCPU_ADD(cnt.v_vforkpages, p2->p_vmspace->vm_dsize + 677 p2->p_vmspace->vm_ssize); 678 } else if (p1 == &proc0) { 679 PCPU_INC(cnt.v_kthreads); 680 PCPU_ADD(cnt.v_kthreadpages, p2->p_vmspace->vm_dsize + 681 p2->p_vmspace->vm_ssize); 682 } else { 683 PCPU_INC(cnt.v_rforks); 684 PCPU_ADD(cnt.v_rforkpages, p2->p_vmspace->vm_dsize + 685 p2->p_vmspace->vm_ssize); 686 } 687 688 /* 689 * Associate the process descriptor with the process before anything 690 * can happen that might cause that process to need the descriptor. 691 * However, don't do this until after fork(2) can no longer fail. 692 */ 693 if (fr->fr_flags & RFPROCDESC) 694 procdesc_new(p2, fr->fr_pd_flags); 695 696 /* 697 * Both processes are set up, now check if any loadable modules want 698 * to adjust anything. 699 */ 700 EVENTHANDLER_INVOKE(process_fork, p1, p2, fr->fr_flags); 701 702 /* 703 * Set the child start time and mark the process as being complete. 704 */ 705 PROC_LOCK(p2); 706 PROC_LOCK(p1); 707 microuptime(&p2->p_stats->p_start); 708 PROC_SLOCK(p2); 709 p2->p_state = PRS_NORMAL; 710 PROC_SUNLOCK(p2); 711 712 #ifdef KDTRACE_HOOKS 713 /* 714 * Tell the DTrace fasttrap provider about the new process so that any 715 * tracepoints inherited from the parent can be removed. We have to do 716 * this only after p_state is PRS_NORMAL since the fasttrap module will 717 * use pfind() later on. 718 */ 719 if ((fr->fr_flags & RFMEM) == 0 && dtrace_fasttrap_fork) 720 dtrace_fasttrap_fork(p1, p2); 721 #endif 722 /* 723 * Hold the process so that it cannot exit after we make it runnable, 724 * but before we wait for the debugger. 725 */ 726 _PHOLD(p2); 727 if (p1->p_ptevents & PTRACE_FORK) { 728 /* 729 * Arrange for debugger to receive the fork event. 730 * 731 * We can report PL_FLAG_FORKED regardless of 732 * P_FOLLOWFORK settings, but it does not make a sense 733 * for runaway child. 734 */ 735 td->td_dbgflags |= TDB_FORK; 736 td->td_dbg_forked = p2->p_pid; 737 td2->td_dbgflags |= TDB_STOPATFORK; 738 } 739 if (fr->fr_flags & RFPPWAIT) { 740 td->td_pflags |= TDP_RFPPWAIT; 741 td->td_rfppwait_p = p2; 742 td->td_dbgflags |= TDB_VFORK; 743 } 744 PROC_UNLOCK(p2); 745 746 /* 747 * Now can be swapped. 748 */ 749 _PRELE(p1); 750 PROC_UNLOCK(p1); 751 752 /* 753 * Tell any interested parties about the new process. 754 */ 755 knote_fork(p1->p_klist, p2->p_pid); 756 SDT_PROBE3(proc, , , create, p2, p1, fr->fr_flags); 757 758 if (fr->fr_flags & RFPROCDESC) { 759 procdesc_finit(p2->p_procdesc, fp_procdesc); 760 fdrop(fp_procdesc, td); 761 } 762 763 if ((fr->fr_flags & RFSTOPPED) == 0) { 764 /* 765 * If RFSTOPPED not requested, make child runnable and 766 * add to run queue. 767 */ 768 thread_lock(td2); 769 TD_SET_CAN_RUN(td2); 770 sched_add(td2, SRQ_BORING); 771 thread_unlock(td2); 772 if (fr->fr_pidp != NULL) 773 *fr->fr_pidp = p2->p_pid; 774 } else { 775 *fr->fr_procp = p2; 776 } 777 778 PROC_LOCK(p2); 779 /* 780 * Wait until debugger is attached to child. 781 */ 782 while (td2->td_proc == p2 && (td2->td_dbgflags & TDB_STOPATFORK) != 0) 783 cv_wait(&p2->p_dbgwait, &p2->p_mtx); 784 _PRELE(p2); 785 racct_proc_fork_done(p2); 786 PROC_UNLOCK(p2); 787 } 788 789 int 790 fork1(struct thread *td, struct fork_req *fr) 791 { 792 struct proc *p1, *newproc; 793 struct thread *td2; 794 struct vmspace *vm2; 795 struct file *fp_procdesc; 796 vm_ooffset_t mem_charged; 797 int error, nprocs_new, ok; 798 static int curfail; 799 static struct timeval lastfail; 800 int flags, pages; 801 802 flags = fr->fr_flags; 803 pages = fr->fr_pages; 804 805 if ((flags & RFSTOPPED) != 0) 806 MPASS(fr->fr_procp != NULL && fr->fr_pidp == NULL); 807 else 808 MPASS(fr->fr_procp == NULL); 809 810 /* Check for the undefined or unimplemented flags. */ 811 if ((flags & ~(RFFLAGS | RFTSIGFLAGS(RFTSIGMASK))) != 0) 812 return (EINVAL); 813 814 /* Signal value requires RFTSIGZMB. */ 815 if ((flags & RFTSIGFLAGS(RFTSIGMASK)) != 0 && (flags & RFTSIGZMB) == 0) 816 return (EINVAL); 817 818 /* Can't copy and clear. */ 819 if ((flags & (RFFDG|RFCFDG)) == (RFFDG|RFCFDG)) 820 return (EINVAL); 821 822 /* Check the validity of the signal number. */ 823 if ((flags & RFTSIGZMB) != 0 && (u_int)RFTSIGNUM(flags) > _SIG_MAXSIG) 824 return (EINVAL); 825 826 if ((flags & RFPROCDESC) != 0) { 827 /* Can't not create a process yet get a process descriptor. */ 828 if ((flags & RFPROC) == 0) 829 return (EINVAL); 830 831 /* Must provide a place to put a procdesc if creating one. */ 832 if (fr->fr_pd_fd == NULL) 833 return (EINVAL); 834 835 /* Check if we are using supported flags. */ 836 if ((fr->fr_pd_flags & ~PD_ALLOWED_AT_FORK) != 0) 837 return (EINVAL); 838 } 839 840 p1 = td->td_proc; 841 842 /* 843 * Here we don't create a new process, but we divorce 844 * certain parts of a process from itself. 845 */ 846 if ((flags & RFPROC) == 0) { 847 if (fr->fr_procp != NULL) 848 *fr->fr_procp = NULL; 849 else if (fr->fr_pidp != NULL) 850 *fr->fr_pidp = 0; 851 return (fork_norfproc(td, flags)); 852 } 853 854 fp_procdesc = NULL; 855 newproc = NULL; 856 vm2 = NULL; 857 858 /* 859 * Increment the nprocs resource before allocations occur. 860 * Although process entries are dynamically created, we still 861 * keep a global limit on the maximum number we will 862 * create. There are hard-limits as to the number of processes 863 * that can run, established by the KVA and memory usage for 864 * the process data. 865 * 866 * Don't allow a nonprivileged user to use the last ten 867 * processes; don't let root exceed the limit. 868 */ 869 nprocs_new = atomic_fetchadd_int(&nprocs, 1) + 1; 870 if ((nprocs_new >= maxproc - 10 && priv_check_cred(td->td_ucred, 871 PRIV_MAXPROC, 0) != 0) || nprocs_new >= maxproc) { 872 error = EAGAIN; 873 sx_xlock(&allproc_lock); 874 if (ppsratecheck(&lastfail, &curfail, 1)) { 875 printf("maxproc limit exceeded by uid %u (pid %d); " 876 "see tuning(7) and login.conf(5)\n", 877 td->td_ucred->cr_ruid, p1->p_pid); 878 } 879 sx_xunlock(&allproc_lock); 880 goto fail2; 881 } 882 883 /* 884 * If required, create a process descriptor in the parent first; we 885 * will abandon it if something goes wrong. We don't finit() until 886 * later. 887 */ 888 if (flags & RFPROCDESC) { 889 error = procdesc_falloc(td, &fp_procdesc, fr->fr_pd_fd, 890 fr->fr_pd_flags, fr->fr_pd_fcaps); 891 if (error != 0) 892 goto fail2; 893 } 894 895 mem_charged = 0; 896 if (pages == 0) 897 pages = kstack_pages; 898 /* Allocate new proc. */ 899 newproc = uma_zalloc(proc_zone, M_WAITOK); 900 td2 = FIRST_THREAD_IN_PROC(newproc); 901 if (td2 == NULL) { 902 td2 = thread_alloc(pages); 903 if (td2 == NULL) { 904 error = ENOMEM; 905 goto fail2; 906 } 907 proc_linkup(newproc, td2); 908 } else { 909 if (td2->td_kstack == 0 || td2->td_kstack_pages != pages) { 910 if (td2->td_kstack != 0) 911 vm_thread_dispose(td2); 912 if (!thread_alloc_stack(td2, pages)) { 913 error = ENOMEM; 914 goto fail2; 915 } 916 } 917 } 918 919 if ((flags & RFMEM) == 0) { 920 vm2 = vmspace_fork(p1->p_vmspace, &mem_charged); 921 if (vm2 == NULL) { 922 error = ENOMEM; 923 goto fail2; 924 } 925 if (!swap_reserve(mem_charged)) { 926 /* 927 * The swap reservation failed. The accounting 928 * from the entries of the copied vm2 will be 929 * subtracted in vmspace_free(), so force the 930 * reservation there. 931 */ 932 swap_reserve_force(mem_charged); 933 error = ENOMEM; 934 goto fail2; 935 } 936 } else 937 vm2 = NULL; 938 939 /* 940 * XXX: This is ugly; when we copy resource usage, we need to bump 941 * per-cred resource counters. 942 */ 943 proc_set_cred_init(newproc, crhold(td->td_ucred)); 944 945 /* 946 * Initialize resource accounting for the child process. 947 */ 948 error = racct_proc_fork(p1, newproc); 949 if (error != 0) { 950 error = EAGAIN; 951 goto fail1; 952 } 953 954 #ifdef MAC 955 mac_proc_init(newproc); 956 #endif 957 newproc->p_klist = knlist_alloc(&newproc->p_mtx); 958 STAILQ_INIT(&newproc->p_ktr); 959 960 /* We have to lock the process tree while we look for a pid. */ 961 sx_slock(&proctree_lock); 962 sx_xlock(&allproc_lock); 963 964 /* 965 * Increment the count of procs running with this uid. Don't allow 966 * a nonprivileged user to exceed their current limit. 967 * 968 * XXXRW: Can we avoid privilege here if it's not needed? 969 */ 970 error = priv_check_cred(td->td_ucred, PRIV_PROC_LIMIT, 0); 971 if (error == 0) 972 ok = chgproccnt(td->td_ucred->cr_ruidinfo, 1, 0); 973 else { 974 ok = chgproccnt(td->td_ucred->cr_ruidinfo, 1, 975 lim_cur(td, RLIMIT_NPROC)); 976 } 977 if (ok) { 978 do_fork(td, fr, newproc, td2, vm2, fp_procdesc); 979 return (0); 980 } 981 982 error = EAGAIN; 983 sx_sunlock(&proctree_lock); 984 sx_xunlock(&allproc_lock); 985 #ifdef MAC 986 mac_proc_destroy(newproc); 987 #endif 988 racct_proc_exit(newproc); 989 fail1: 990 crfree(newproc->p_ucred); 991 newproc->p_ucred = NULL; 992 fail2: 993 if (vm2 != NULL) 994 vmspace_free(vm2); 995 uma_zfree(proc_zone, newproc); 996 if ((flags & RFPROCDESC) != 0 && fp_procdesc != NULL) { 997 fdclose(td, fp_procdesc, *fr->fr_pd_fd); 998 fdrop(fp_procdesc, td); 999 } 1000 atomic_add_int(&nprocs, -1); 1001 pause("fork", hz / 2); 1002 return (error); 1003 } 1004 1005 /* 1006 * Handle the return of a child process from fork1(). This function 1007 * is called from the MD fork_trampoline() entry point. 1008 */ 1009 void 1010 fork_exit(void (*callout)(void *, struct trapframe *), void *arg, 1011 struct trapframe *frame) 1012 { 1013 struct proc *p; 1014 struct thread *td; 1015 struct thread *dtd; 1016 1017 td = curthread; 1018 p = td->td_proc; 1019 KASSERT(p->p_state == PRS_NORMAL, ("executing process is still new")); 1020 1021 CTR4(KTR_PROC, "fork_exit: new thread %p (td_sched %p, pid %d, %s)", 1022 td, td_get_sched(td), p->p_pid, td->td_name); 1023 1024 sched_fork_exit(td); 1025 /* 1026 * Processes normally resume in mi_switch() after being 1027 * cpu_switch()'ed to, but when children start up they arrive here 1028 * instead, so we must do much the same things as mi_switch() would. 1029 */ 1030 if ((dtd = PCPU_GET(deadthread))) { 1031 PCPU_SET(deadthread, NULL); 1032 thread_stash(dtd); 1033 } 1034 thread_unlock(td); 1035 1036 /* 1037 * cpu_fork_kthread_handler intercepts this function call to 1038 * have this call a non-return function to stay in kernel mode. 1039 * initproc has its own fork handler, but it does return. 1040 */ 1041 KASSERT(callout != NULL, ("NULL callout in fork_exit")); 1042 callout(arg, frame); 1043 1044 /* 1045 * Check if a kernel thread misbehaved and returned from its main 1046 * function. 1047 */ 1048 if (p->p_flag & P_KPROC) { 1049 printf("Kernel thread \"%s\" (pid %d) exited prematurely.\n", 1050 td->td_name, p->p_pid); 1051 kthread_exit(); 1052 } 1053 mtx_assert(&Giant, MA_NOTOWNED); 1054 1055 if (p->p_sysent->sv_schedtail != NULL) 1056 (p->p_sysent->sv_schedtail)(td); 1057 td->td_pflags &= ~TDP_FORKING; 1058 } 1059 1060 /* 1061 * Simplified back end of syscall(), used when returning from fork() 1062 * directly into user mode. This function is passed in to fork_exit() 1063 * as the first parameter and is called when returning to a new 1064 * userland process. 1065 */ 1066 void 1067 fork_return(struct thread *td, struct trapframe *frame) 1068 { 1069 struct proc *p, *dbg; 1070 1071 p = td->td_proc; 1072 if (td->td_dbgflags & TDB_STOPATFORK) { 1073 sx_xlock(&proctree_lock); 1074 PROC_LOCK(p); 1075 if (p->p_pptr->p_ptevents & PTRACE_FORK) { 1076 /* 1077 * If debugger still wants auto-attach for the 1078 * parent's children, do it now. 1079 */ 1080 dbg = p->p_pptr->p_pptr; 1081 proc_set_traced(p, true); 1082 CTR2(KTR_PTRACE, 1083 "fork_return: attaching to new child pid %d: oppid %d", 1084 p->p_pid, p->p_oppid); 1085 proc_reparent(p, dbg); 1086 sx_xunlock(&proctree_lock); 1087 td->td_dbgflags |= TDB_CHILD | TDB_SCX | TDB_FSTP; 1088 ptracestop(td, SIGSTOP, NULL); 1089 td->td_dbgflags &= ~(TDB_CHILD | TDB_SCX); 1090 } else { 1091 /* 1092 * ... otherwise clear the request. 1093 */ 1094 sx_xunlock(&proctree_lock); 1095 td->td_dbgflags &= ~TDB_STOPATFORK; 1096 cv_broadcast(&p->p_dbgwait); 1097 } 1098 PROC_UNLOCK(p); 1099 } else if (p->p_flag & P_TRACED || td->td_dbgflags & TDB_BORN) { 1100 /* 1101 * This is the start of a new thread in a traced 1102 * process. Report a system call exit event. 1103 */ 1104 PROC_LOCK(p); 1105 td->td_dbgflags |= TDB_SCX; 1106 _STOPEVENT(p, S_SCX, td->td_dbg_sc_code); 1107 if ((p->p_ptevents & PTRACE_SCX) != 0 || 1108 (td->td_dbgflags & TDB_BORN) != 0) 1109 ptracestop(td, SIGTRAP, NULL); 1110 td->td_dbgflags &= ~(TDB_SCX | TDB_BORN); 1111 PROC_UNLOCK(p); 1112 } 1113 1114 userret(td, frame); 1115 1116 #ifdef KTRACE 1117 if (KTRPOINT(td, KTR_SYSRET)) 1118 ktrsysret(SYS_fork, 0, 0); 1119 #endif 1120 }
Cache object: bf7e747e0afe0fca9f7ef8e47ff949f2
[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]