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 * 3. 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 * $FreeBSD: src/sys/kern/kern_fork.c,v 1.72.2.14 2003/06/26 04:15:10 silby Exp $ 36 */ 37 38 #include "opt_ktrace.h" 39 40 #include <sys/param.h> 41 #include <sys/systm.h> 42 #include <sys/sysproto.h> 43 #include <sys/filedesc.h> 44 #include <sys/kernel.h> 45 #include <sys/sysctl.h> 46 #include <sys/malloc.h> 47 #include <sys/proc.h> 48 #include <sys/resourcevar.h> 49 #include <sys/vnode.h> 50 #include <sys/acct.h> 51 #include <sys/ktrace.h> 52 #include <sys/unistd.h> 53 #include <sys/jail.h> 54 55 #include <vm/vm.h> 56 #include <sys/lock.h> 57 #include <vm/pmap.h> 58 #include <vm/vm_map.h> 59 #include <vm/vm_extern.h> 60 61 #include <sys/vmmeter.h> 62 #include <sys/refcount.h> 63 #include <sys/thread2.h> 64 #include <sys/signal2.h> 65 #include <sys/spinlock2.h> 66 67 #include <sys/dsched.h> 68 69 static MALLOC_DEFINE(M_ATFORK, "atfork", "atfork callback"); 70 71 /* 72 * These are the stuctures used to create a callout list for things to do 73 * when forking a process 74 */ 75 struct forklist { 76 forklist_fn function; 77 TAILQ_ENTRY(forklist) next; 78 }; 79 80 TAILQ_HEAD(forklist_head, forklist); 81 static struct forklist_head fork_list = TAILQ_HEAD_INITIALIZER(fork_list); 82 83 static struct lwp *lwp_fork(struct lwp *, struct proc *, int flags); 84 85 int forksleep; /* Place for fork1() to sleep on. */ 86 87 /* 88 * Red-Black tree support for LWPs 89 */ 90 91 static int 92 rb_lwp_compare(struct lwp *lp1, struct lwp *lp2) 93 { 94 if (lp1->lwp_tid < lp2->lwp_tid) 95 return(-1); 96 if (lp1->lwp_tid > lp2->lwp_tid) 97 return(1); 98 return(0); 99 } 100 101 RB_GENERATE2(lwp_rb_tree, lwp, u.lwp_rbnode, rb_lwp_compare, lwpid_t, lwp_tid); 102 103 /* 104 * Fork system call 105 * 106 * MPALMOSTSAFE 107 */ 108 int 109 sys_fork(struct fork_args *uap) 110 { 111 struct lwp *lp = curthread->td_lwp; 112 struct proc *p2; 113 int error; 114 115 error = fork1(lp, RFFDG | RFPROC | RFPGLOCK, &p2); 116 if (error == 0) { 117 PHOLD(p2); 118 start_forked_proc(lp, p2); 119 uap->sysmsg_fds[0] = p2->p_pid; 120 uap->sysmsg_fds[1] = 0; 121 PRELE(p2); 122 } 123 return error; 124 } 125 126 /* 127 * MPALMOSTSAFE 128 */ 129 int 130 sys_vfork(struct vfork_args *uap) 131 { 132 struct lwp *lp = curthread->td_lwp; 133 struct proc *p2; 134 int error; 135 136 error = fork1(lp, RFFDG | RFPROC | RFPPWAIT | RFMEM | RFPGLOCK, &p2); 137 if (error == 0) { 138 PHOLD(p2); 139 start_forked_proc(lp, p2); 140 uap->sysmsg_fds[0] = p2->p_pid; 141 uap->sysmsg_fds[1] = 0; 142 PRELE(p2); 143 } 144 return error; 145 } 146 147 /* 148 * Handle rforks. An rfork may (1) operate on the current process without 149 * creating a new, (2) create a new process that shared the current process's 150 * vmspace, signals, and/or descriptors, or (3) create a new process that does 151 * not share these things (normal fork). 152 * 153 * Note that we only call start_forked_proc() if a new process is actually 154 * created. 155 * 156 * rfork { int flags } 157 * 158 * MPALMOSTSAFE 159 */ 160 int 161 sys_rfork(struct rfork_args *uap) 162 { 163 struct lwp *lp = curthread->td_lwp; 164 struct proc *p2; 165 int error; 166 167 if ((uap->flags & RFKERNELONLY) != 0) 168 return (EINVAL); 169 170 error = fork1(lp, uap->flags | RFPGLOCK, &p2); 171 if (error == 0) { 172 if (p2) { 173 PHOLD(p2); 174 start_forked_proc(lp, p2); 175 uap->sysmsg_fds[0] = p2->p_pid; 176 uap->sysmsg_fds[1] = 0; 177 PRELE(p2); 178 } else { 179 uap->sysmsg_fds[0] = 0; 180 uap->sysmsg_fds[1] = 0; 181 } 182 } 183 return error; 184 } 185 186 /* 187 * MPALMOSTSAFE 188 */ 189 int 190 sys_lwp_create(struct lwp_create_args *uap) 191 { 192 struct proc *p = curproc; 193 struct lwp *lp; 194 struct lwp_params params; 195 int error; 196 197 error = copyin(uap->params, ¶ms, sizeof(params)); 198 if (error) 199 goto fail2; 200 201 lwkt_gettoken(&p->p_token); 202 plimit_lwp_fork(p); /* force exclusive access */ 203 lp = lwp_fork(curthread->td_lwp, p, RFPROC); 204 error = cpu_prepare_lwp(lp, ¶ms); 205 if (error) 206 goto fail; 207 if (params.tid1 != NULL && 208 (error = copyout(&lp->lwp_tid, params.tid1, sizeof(lp->lwp_tid)))) 209 goto fail; 210 if (params.tid2 != NULL && 211 (error = copyout(&lp->lwp_tid, params.tid2, sizeof(lp->lwp_tid)))) 212 goto fail; 213 214 /* 215 * Now schedule the new lwp. 216 */ 217 p->p_usched->resetpriority(lp); 218 crit_enter(); 219 lp->lwp_stat = LSRUN; 220 p->p_usched->setrunqueue(lp); 221 crit_exit(); 222 lwkt_reltoken(&p->p_token); 223 224 return (0); 225 226 fail: 227 lwp_rb_tree_RB_REMOVE(&p->p_lwp_tree, lp); 228 --p->p_nthreads; 229 /* lwp_dispose expects an exited lwp, and a held proc */ 230 atomic_set_int(&lp->lwp_mpflags, LWP_MP_WEXIT); 231 lp->lwp_thread->td_flags |= TDF_EXITING; 232 lwkt_remove_tdallq(lp->lwp_thread); 233 PHOLD(p); 234 biosched_done(lp->lwp_thread); 235 dsched_exit_thread(lp->lwp_thread); 236 lwp_dispose(lp); 237 lwkt_reltoken(&p->p_token); 238 fail2: 239 return (error); 240 } 241 242 int nprocs = 1; /* process 0 */ 243 244 int 245 fork1(struct lwp *lp1, int flags, struct proc **procp) 246 { 247 struct proc *p1 = lp1->lwp_proc; 248 struct proc *p2; 249 struct proc *pptr; 250 struct pgrp *p1grp; 251 struct pgrp *plkgrp; 252 uid_t uid; 253 int ok, error; 254 static int curfail = 0; 255 static struct timeval lastfail; 256 struct forklist *ep; 257 struct filedesc_to_leader *fdtol; 258 259 if ((flags & (RFFDG|RFCFDG)) == (RFFDG|RFCFDG)) 260 return (EINVAL); 261 262 lwkt_gettoken(&p1->p_token); 263 plkgrp = NULL; 264 p2 = NULL; 265 266 /* 267 * Here we don't create a new process, but we divorce 268 * certain parts of a process from itself. 269 */ 270 if ((flags & RFPROC) == 0) { 271 /* 272 * This kind of stunt does not work anymore if 273 * there are native threads (lwps) running 274 */ 275 if (p1->p_nthreads != 1) { 276 error = EINVAL; 277 goto done; 278 } 279 280 vm_fork(p1, 0, flags); 281 282 /* 283 * Close all file descriptors. 284 */ 285 if (flags & RFCFDG) { 286 struct filedesc *fdtmp; 287 fdtmp = fdinit(p1); 288 fdfree(p1, fdtmp); 289 } 290 291 /* 292 * Unshare file descriptors (from parent.) 293 */ 294 if (flags & RFFDG) { 295 if (p1->p_fd->fd_refcnt > 1) { 296 struct filedesc *newfd; 297 error = fdcopy(p1, &newfd); 298 if (error != 0) { 299 error = ENOMEM; 300 goto done; 301 } 302 fdfree(p1, newfd); 303 } 304 } 305 *procp = NULL; 306 error = 0; 307 goto done; 308 } 309 310 /* 311 * Interlock against process group signal delivery. If signals 312 * are pending after the interlock is obtained we have to restart 313 * the system call to process the signals. If we don't the child 314 * can miss a pgsignal (such as ^C) sent during the fork. 315 * 316 * We can't use CURSIG() here because it will process any STOPs 317 * and cause the process group lock to be held indefinitely. If 318 * a STOP occurs, the fork will be restarted after the CONT. 319 */ 320 p1grp = p1->p_pgrp; 321 if ((flags & RFPGLOCK) && (plkgrp = p1->p_pgrp) != NULL) { 322 pgref(plkgrp); 323 lockmgr(&plkgrp->pg_lock, LK_SHARED); 324 if (CURSIG_NOBLOCK(lp1)) { 325 error = ERESTART; 326 goto done; 327 } 328 } 329 330 /* 331 * Although process entries are dynamically created, we still keep 332 * a global limit on the maximum number we will create. Don't allow 333 * a nonprivileged user to use the last ten processes; don't let root 334 * exceed the limit. The variable nprocs is the current number of 335 * processes, maxproc is the limit. 336 */ 337 uid = lp1->lwp_thread->td_ucred->cr_ruid; 338 if ((nprocs >= maxproc - 10 && uid != 0) || nprocs >= maxproc) { 339 if (ppsratecheck(&lastfail, &curfail, 1)) 340 kprintf("maxproc limit exceeded by uid %d, please " 341 "see tuning(7) and login.conf(5).\n", uid); 342 tsleep(&forksleep, 0, "fork", hz / 2); 343 error = EAGAIN; 344 goto done; 345 } 346 347 /* 348 * Increment the nprocs resource before blocking can occur. There 349 * are hard-limits as to the number of processes that can run. 350 */ 351 atomic_add_int(&nprocs, 1); 352 353 /* 354 * Increment the count of procs running with this uid. Don't allow 355 * a nonprivileged user to exceed their current limit. 356 */ 357 ok = chgproccnt(lp1->lwp_thread->td_ucred->cr_ruidinfo, 1, 358 (uid != 0) ? p1->p_rlimit[RLIMIT_NPROC].rlim_cur : 0); 359 if (!ok) { 360 /* 361 * Back out the process count 362 */ 363 atomic_add_int(&nprocs, -1); 364 if (ppsratecheck(&lastfail, &curfail, 1)) 365 kprintf("maxproc limit exceeded by uid %d, please " 366 "see tuning(7) and login.conf(5).\n", uid); 367 tsleep(&forksleep, 0, "fork", hz / 2); 368 error = EAGAIN; 369 goto done; 370 } 371 372 /* 373 * Allocate a new process, don't get fancy: zero the structure. 374 */ 375 p2 = kmalloc(sizeof(struct proc), M_PROC, M_WAITOK|M_ZERO); 376 377 /* 378 * Core initialization. SIDL is a safety state that protects the 379 * partially initialized process once it starts getting hooked 380 * into system structures and becomes addressable. 381 * 382 * We must be sure to acquire p2->p_token as well, we must hold it 383 * once the process is on the allproc list to avoid things such 384 * as competing modifications to p_flags. 385 */ 386 p2->p_lasttid = -1; /* first tid will be 0 */ 387 p2->p_stat = SIDL; 388 389 RB_INIT(&p2->p_lwp_tree); 390 spin_init(&p2->p_spin); 391 lwkt_token_init(&p2->p_token, "proc"); 392 lwkt_gettoken(&p2->p_token); 393 394 /* 395 * Setup linkage for kernel based threading XXX lwp. Also add the 396 * process to the allproclist. 397 * 398 * The process structure is addressable after this point. 399 */ 400 if (flags & RFTHREAD) { 401 p2->p_peers = p1->p_peers; 402 p1->p_peers = p2; 403 p2->p_leader = p1->p_leader; 404 } else { 405 p2->p_leader = p2; 406 } 407 proc_add_allproc(p2); 408 409 /* 410 * Initialize the section which is copied verbatim from the parent. 411 */ 412 bcopy(&p1->p_startcopy, &p2->p_startcopy, 413 ((caddr_t)&p2->p_endcopy - (caddr_t)&p2->p_startcopy)); 414 415 /* 416 * Duplicate sub-structures as needed. Increase reference counts 417 * on shared objects. 418 * 419 * NOTE: because we are now on the allproc list it is possible for 420 * other consumers to gain temporary references to p2 421 * (p2->p_lock can change). 422 */ 423 if (p1->p_flags & P_PROFIL) 424 startprofclock(p2); 425 p2->p_ucred = crhold(lp1->lwp_thread->td_ucred); 426 427 if (jailed(p2->p_ucred)) 428 p2->p_flags |= P_JAILED; 429 430 if (p2->p_args) 431 refcount_acquire(&p2->p_args->ar_ref); 432 433 p2->p_usched = p1->p_usched; 434 /* XXX: verify copy of the secondary iosched stuff */ 435 dsched_new_proc(p2); 436 437 if (flags & RFSIGSHARE) { 438 p2->p_sigacts = p1->p_sigacts; 439 refcount_acquire(&p2->p_sigacts->ps_refcnt); 440 } else { 441 p2->p_sigacts = kmalloc(sizeof(*p2->p_sigacts), 442 M_SUBPROC, M_WAITOK); 443 bcopy(p1->p_sigacts, p2->p_sigacts, sizeof(*p2->p_sigacts)); 444 refcount_init(&p2->p_sigacts->ps_refcnt, 1); 445 } 446 if (flags & RFLINUXTHPN) 447 p2->p_sigparent = SIGUSR1; 448 else 449 p2->p_sigparent = SIGCHLD; 450 451 /* bump references to the text vnode (for procfs) */ 452 p2->p_textvp = p1->p_textvp; 453 if (p2->p_textvp) 454 vref(p2->p_textvp); 455 456 /* copy namecache handle to the text file */ 457 if (p1->p_textnch.mount) 458 cache_copy(&p1->p_textnch, &p2->p_textnch); 459 460 /* 461 * Handle file descriptors 462 */ 463 if (flags & RFCFDG) { 464 p2->p_fd = fdinit(p1); 465 fdtol = NULL; 466 } else if (flags & RFFDG) { 467 error = fdcopy(p1, &p2->p_fd); 468 if (error != 0) { 469 error = ENOMEM; 470 goto done; 471 } 472 fdtol = NULL; 473 } else { 474 p2->p_fd = fdshare(p1); 475 if (p1->p_fdtol == NULL) { 476 p1->p_fdtol = filedesc_to_leader_alloc(NULL, 477 p1->p_leader); 478 } 479 if ((flags & RFTHREAD) != 0) { 480 /* 481 * Shared file descriptor table and 482 * shared process leaders. 483 */ 484 fdtol = p1->p_fdtol; 485 fdtol->fdl_refcount++; 486 } else { 487 /* 488 * Shared file descriptor table, and 489 * different process leaders 490 */ 491 fdtol = filedesc_to_leader_alloc(p1->p_fdtol, p2); 492 } 493 } 494 p2->p_fdtol = fdtol; 495 p2->p_limit = plimit_fork(p1); 496 497 /* 498 * Preserve some more flags in subprocess. P_PROFIL has already 499 * been preserved. 500 */ 501 p2->p_flags |= p1->p_flags & P_SUGID; 502 if (p1->p_session->s_ttyvp != NULL && (p1->p_flags & P_CONTROLT)) 503 p2->p_flags |= P_CONTROLT; 504 if (flags & RFPPWAIT) 505 p2->p_flags |= P_PPWAIT; 506 507 /* 508 * Inherit the virtual kernel structure (allows a virtual kernel 509 * to fork to simulate multiple cpus). 510 */ 511 if (p1->p_vkernel) 512 vkernel_inherit(p1, p2); 513 514 /* 515 * Once we are on a pglist we may receive signals. XXX we might 516 * race a ^C being sent to the process group by not receiving it 517 * at all prior to this line. 518 */ 519 pgref(p1grp); 520 lwkt_gettoken(&p1grp->pg_token); 521 LIST_INSERT_AFTER(p1, p2, p_pglist); 522 lwkt_reltoken(&p1grp->pg_token); 523 524 /* 525 * Attach the new process to its parent. 526 * 527 * If RFNOWAIT is set, the newly created process becomes a child 528 * of init. This effectively disassociates the child from the 529 * parent. 530 */ 531 if (flags & RFNOWAIT) 532 pptr = initproc; 533 else 534 pptr = p1; 535 p2->p_pptr = pptr; 536 LIST_INIT(&p2->p_children); 537 538 lwkt_gettoken(&pptr->p_token); 539 LIST_INSERT_HEAD(&pptr->p_children, p2, p_sibling); 540 lwkt_reltoken(&pptr->p_token); 541 542 varsymset_init(&p2->p_varsymset, &p1->p_varsymset); 543 callout_init_mp(&p2->p_ithandle); 544 545 #ifdef KTRACE 546 /* 547 * Copy traceflag and tracefile if enabled. If not inherited, 548 * these were zeroed above but we still could have a trace race 549 * so make sure p2's p_tracenode is NULL. 550 */ 551 if ((p1->p_traceflag & KTRFAC_INHERIT) && p2->p_tracenode == NULL) { 552 p2->p_traceflag = p1->p_traceflag; 553 p2->p_tracenode = ktrinherit(p1->p_tracenode); 554 } 555 #endif 556 557 /* 558 * This begins the section where we must prevent the parent 559 * from being swapped. 560 * 561 * Gets PRELE'd in the caller in start_forked_proc(). 562 */ 563 PHOLD(p1); 564 565 vm_fork(p1, p2, flags); 566 567 /* 568 * Create the first lwp associated with the new proc. 569 * It will return via a different execution path later, directly 570 * into userland, after it was put on the runq by 571 * start_forked_proc(). 572 */ 573 lwp_fork(lp1, p2, flags); 574 575 if (flags == (RFFDG | RFPROC | RFPGLOCK)) { 576 mycpu->gd_cnt.v_forks++; 577 mycpu->gd_cnt.v_forkpages += p2->p_vmspace->vm_dsize + 578 p2->p_vmspace->vm_ssize; 579 } else if (flags == (RFFDG | RFPROC | RFPPWAIT | RFMEM | RFPGLOCK)) { 580 mycpu->gd_cnt.v_vforks++; 581 mycpu->gd_cnt.v_vforkpages += p2->p_vmspace->vm_dsize + 582 p2->p_vmspace->vm_ssize; 583 } else if (p1 == &proc0) { 584 mycpu->gd_cnt.v_kthreads++; 585 mycpu->gd_cnt.v_kthreadpages += p2->p_vmspace->vm_dsize + 586 p2->p_vmspace->vm_ssize; 587 } else { 588 mycpu->gd_cnt.v_rforks++; 589 mycpu->gd_cnt.v_rforkpages += p2->p_vmspace->vm_dsize + 590 p2->p_vmspace->vm_ssize; 591 } 592 593 /* 594 * Both processes are set up, now check if any loadable modules want 595 * to adjust anything. 596 * What if they have an error? XXX 597 */ 598 TAILQ_FOREACH(ep, &fork_list, next) { 599 (*ep->function)(p1, p2, flags); 600 } 601 602 /* 603 * Set the start time. Note that the process is not runnable. The 604 * caller is responsible for making it runnable. 605 */ 606 microtime(&p2->p_start); 607 p2->p_acflag = AFORK; 608 609 /* 610 * tell any interested parties about the new process 611 */ 612 KNOTE(&p1->p_klist, NOTE_FORK | p2->p_pid); 613 614 /* 615 * Return child proc pointer to parent. 616 */ 617 *procp = p2; 618 error = 0; 619 done: 620 if (p2) 621 lwkt_reltoken(&p2->p_token); 622 lwkt_reltoken(&p1->p_token); 623 if (plkgrp) { 624 lockmgr(&plkgrp->pg_lock, LK_RELEASE); 625 pgrel(plkgrp); 626 } 627 return (error); 628 } 629 630 static struct lwp * 631 lwp_fork(struct lwp *origlp, struct proc *destproc, int flags) 632 { 633 globaldata_t gd = mycpu; 634 struct lwp *lp; 635 struct thread *td; 636 637 lp = kmalloc(sizeof(struct lwp), M_LWP, M_WAITOK|M_ZERO); 638 639 lp->lwp_proc = destproc; 640 lp->lwp_vmspace = destproc->p_vmspace; 641 lp->lwp_stat = LSRUN; 642 bcopy(&origlp->lwp_startcopy, &lp->lwp_startcopy, 643 (unsigned) ((caddr_t)&lp->lwp_endcopy - 644 (caddr_t)&lp->lwp_startcopy)); 645 lp->lwp_flags |= origlp->lwp_flags & LWP_ALTSTACK; 646 /* 647 * Set cpbase to the last timeout that occured (not the upcoming 648 * timeout). 649 * 650 * A critical section is required since a timer IPI can update 651 * scheduler specific data. 652 */ 653 crit_enter(); 654 lp->lwp_cpbase = gd->gd_schedclock.time - gd->gd_schedclock.periodic; 655 destproc->p_usched->heuristic_forking(origlp, lp); 656 crit_exit(); 657 lp->lwp_cpumask &= usched_mastermask; 658 lwkt_token_init(&lp->lwp_token, "lwp_token"); 659 spin_init(&lp->lwp_spin); 660 661 /* 662 * Assign the thread to the current cpu to begin with so we 663 * can manipulate it. 664 */ 665 td = lwkt_alloc_thread(NULL, LWKT_THREAD_STACK, gd->gd_cpuid, 0); 666 lp->lwp_thread = td; 667 td->td_proc = destproc; 668 td->td_lwp = lp; 669 td->td_switch = cpu_heavy_switch; 670 #ifdef NO_LWKT_SPLIT_USERPRI 671 lwkt_setpri(td, TDPRI_USER_NORM); 672 #else 673 lwkt_setpri(td, TDPRI_KERN_USER); 674 #endif 675 lwkt_set_comm(td, "%s", destproc->p_comm); 676 677 /* 678 * cpu_fork will copy and update the pcb, set up the kernel stack, 679 * and make the child ready to run. 680 */ 681 cpu_fork(origlp, lp, flags); 682 kqueue_init(&lp->lwp_kqueue, destproc->p_fd); 683 684 /* 685 * Assign a TID to the lp. Loop until the insert succeeds (returns 686 * NULL). 687 */ 688 lp->lwp_tid = destproc->p_lasttid; 689 do { 690 if (++lp->lwp_tid < 0) 691 lp->lwp_tid = 1; 692 } while (lwp_rb_tree_RB_INSERT(&destproc->p_lwp_tree, lp) != NULL); 693 destproc->p_lasttid = lp->lwp_tid; 694 destproc->p_nthreads++; 695 696 return (lp); 697 } 698 699 /* 700 * The next two functionms are general routines to handle adding/deleting 701 * items on the fork callout list. 702 * 703 * at_fork(): 704 * Take the arguments given and put them onto the fork callout list, 705 * However first make sure that it's not already there. 706 * Returns 0 on success or a standard error number. 707 */ 708 int 709 at_fork(forklist_fn function) 710 { 711 struct forklist *ep; 712 713 #ifdef INVARIANTS 714 /* let the programmer know if he's been stupid */ 715 if (rm_at_fork(function)) { 716 kprintf("WARNING: fork callout entry (%p) already present\n", 717 function); 718 } 719 #endif 720 ep = kmalloc(sizeof(*ep), M_ATFORK, M_WAITOK|M_ZERO); 721 ep->function = function; 722 TAILQ_INSERT_TAIL(&fork_list, ep, next); 723 return (0); 724 } 725 726 /* 727 * Scan the exit callout list for the given item and remove it.. 728 * Returns the number of items removed (0 or 1) 729 */ 730 int 731 rm_at_fork(forklist_fn function) 732 { 733 struct forklist *ep; 734 735 TAILQ_FOREACH(ep, &fork_list, next) { 736 if (ep->function == function) { 737 TAILQ_REMOVE(&fork_list, ep, next); 738 kfree(ep, M_ATFORK); 739 return(1); 740 } 741 } 742 return (0); 743 } 744 745 /* 746 * Add a forked process to the run queue after any remaining setup, such 747 * as setting the fork handler, has been completed. 748 * 749 * p2 is held by the caller. 750 */ 751 void 752 start_forked_proc(struct lwp *lp1, struct proc *p2) 753 { 754 struct lwp *lp2 = ONLY_LWP_IN_PROC(p2); 755 756 /* 757 * Move from SIDL to RUN queue, and activate the process's thread. 758 * Activation of the thread effectively makes the process "a" 759 * current process, so we do not setrunqueue(). 760 * 761 * YYY setrunqueue works here but we should clean up the trampoline 762 * code so we just schedule the LWKT thread and let the trampoline 763 * deal with the userland scheduler on return to userland. 764 */ 765 KASSERT(p2->p_stat == SIDL, 766 ("cannot start forked process, bad status: %p", p2)); 767 p2->p_usched->resetpriority(lp2); 768 crit_enter(); 769 p2->p_stat = SACTIVE; 770 lp2->lwp_stat = LSRUN; 771 p2->p_usched->setrunqueue(lp2); 772 crit_exit(); 773 774 /* 775 * Now can be swapped. 776 */ 777 PRELE(lp1->lwp_proc); 778 779 /* 780 * Preserve synchronization semantics of vfork. If waiting for 781 * child to exec or exit, set P_PPWAIT on child, and sleep on our 782 * proc (in case of exec or exit). 783 * 784 * We must hold our p_token to interlock the flag/tsleep 785 */ 786 lwkt_gettoken(&p2->p_token); 787 while (p2->p_flags & P_PPWAIT) 788 tsleep(lp1->lwp_proc, 0, "ppwait", 0); 789 lwkt_reltoken(&p2->p_token); 790 } 791