FreeBSD/Linux Kernel Cross Reference
sys/kern/kern_exit.c
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_exit.c 8.7 (Berkeley) 2/12/94
35 */
36
37 #include <sys/cdefs.h>
38 __FBSDID("$FreeBSD: releng/10.4/sys/kern/kern_exit.c 310585 2016-12-26 10:16:05Z kib $");
39
40 #include "opt_compat.h"
41 #include "opt_kdtrace.h"
42 #include "opt_ktrace.h"
43 #include "opt_procdesc.h"
44
45 #include <sys/param.h>
46 #include <sys/systm.h>
47 #include <sys/sysproto.h>
48 #include <sys/capsicum.h>
49 #include <sys/eventhandler.h>
50 #include <sys/kernel.h>
51 #include <sys/malloc.h>
52 #include <sys/lock.h>
53 #include <sys/mutex.h>
54 #include <sys/proc.h>
55 #include <sys/procdesc.h>
56 #include <sys/pioctl.h>
57 #include <sys/jail.h>
58 #include <sys/tty.h>
59 #include <sys/wait.h>
60 #include <sys/vmmeter.h>
61 #include <sys/vnode.h>
62 #include <sys/racct.h>
63 #include <sys/resourcevar.h>
64 #include <sys/sbuf.h>
65 #include <sys/signalvar.h>
66 #include <sys/sched.h>
67 #include <sys/sx.h>
68 #include <sys/syscallsubr.h>
69 #include <sys/syslog.h>
70 #include <sys/ptrace.h>
71 #include <sys/acct.h> /* for acct_process() function prototype */
72 #include <sys/filedesc.h>
73 #include <sys/sdt.h>
74 #include <sys/shm.h>
75 #include <sys/sem.h>
76 #include <sys/umtx.h>
77 #ifdef KTRACE
78 #include <sys/ktrace.h>
79 #endif
80
81 #include <security/audit/audit.h>
82 #include <security/mac/mac_framework.h>
83
84 #include <vm/vm.h>
85 #include <vm/vm_extern.h>
86 #include <vm/vm_param.h>
87 #include <vm/pmap.h>
88 #include <vm/vm_map.h>
89 #include <vm/vm_page.h>
90 #include <vm/uma.h>
91
92 #ifdef KDTRACE_HOOKS
93 #include <sys/dtrace_bsd.h>
94 dtrace_execexit_func_t dtrace_fasttrap_exit;
95 #endif
96
97 SDT_PROVIDER_DECLARE(proc);
98 SDT_PROBE_DEFINE1(proc, , , exit, "int");
99
100 /* Hook for NFS teardown procedure. */
101 void (*nlminfo_release_p)(struct proc *p);
102
103 struct proc *
104 proc_realparent(struct proc *child)
105 {
106 struct proc *p, *parent;
107
108 sx_assert(&proctree_lock, SX_LOCKED);
109 if ((child->p_treeflag & P_TREE_ORPHANED) == 0) {
110 if (child->p_oppid == 0 ||
111 child->p_pptr->p_pid == child->p_oppid)
112 parent = child->p_pptr;
113 else
114 parent = initproc;
115 return (parent);
116 }
117 for (p = child; (p->p_treeflag & P_TREE_FIRST_ORPHAN) == 0;) {
118 /* Cannot use LIST_PREV(), since the list head is not known. */
119 p = __containerof(p->p_orphan.le_prev, struct proc,
120 p_orphan.le_next);
121 KASSERT((p->p_treeflag & P_TREE_ORPHANED) != 0,
122 ("missing P_ORPHAN %p", p));
123 }
124 parent = __containerof(p->p_orphan.le_prev, struct proc,
125 p_orphans.lh_first);
126 return (parent);
127 }
128
129 void
130 reaper_abandon_children(struct proc *p, bool exiting)
131 {
132 struct proc *p1, *p2, *ptmp;
133
134 sx_assert(&proctree_lock, SX_LOCKED);
135 KASSERT(p != initproc, ("reaper_abandon_children for initproc"));
136 if ((p->p_treeflag & P_TREE_REAPER) == 0)
137 return;
138 p1 = p->p_reaper;
139 LIST_FOREACH_SAFE(p2, &p->p_reaplist, p_reapsibling, ptmp) {
140 LIST_REMOVE(p2, p_reapsibling);
141 p2->p_reaper = p1;
142 p2->p_reapsubtree = p->p_reapsubtree;
143 LIST_INSERT_HEAD(&p1->p_reaplist, p2, p_reapsibling);
144 if (exiting && p2->p_pptr == p) {
145 PROC_LOCK(p2);
146 proc_reparent(p2, p1);
147 PROC_UNLOCK(p2);
148 }
149 }
150 KASSERT(LIST_EMPTY(&p->p_reaplist), ("p_reaplist not empty"));
151 p->p_treeflag &= ~P_TREE_REAPER;
152 }
153
154 static void
155 clear_orphan(struct proc *p)
156 {
157 struct proc *p1;
158
159 sx_assert(&proctree_lock, SA_XLOCKED);
160 if ((p->p_treeflag & P_TREE_ORPHANED) == 0)
161 return;
162 if ((p->p_treeflag & P_TREE_FIRST_ORPHAN) != 0) {
163 p1 = LIST_NEXT(p, p_orphan);
164 if (p1 != NULL)
165 p1->p_treeflag |= P_TREE_FIRST_ORPHAN;
166 p->p_treeflag &= ~P_TREE_FIRST_ORPHAN;
167 }
168 LIST_REMOVE(p, p_orphan);
169 p->p_treeflag &= ~P_TREE_ORPHANED;
170 }
171
172 /*
173 * exit -- death of process.
174 */
175 void
176 sys_sys_exit(struct thread *td, struct sys_exit_args *uap)
177 {
178
179 exit1(td, W_EXITCODE(uap->rval, 0));
180 /* NOTREACHED */
181 }
182
183 /*
184 * Exit: deallocate address space and other resources, change proc state to
185 * zombie, and unlink proc from allproc and parent's lists. Save exit status
186 * and rusage for wait(). Check for child processes and orphan them.
187 */
188 void
189 exit1(struct thread *td, int rv)
190 {
191 struct proc *p, *nq, *q, *t;
192 struct thread *tdt;
193 struct vnode *ttyvp = NULL;
194
195 mtx_assert(&Giant, MA_NOTOWNED);
196
197 p = td->td_proc;
198 /*
199 * XXX in case we're rebooting we just let init die in order to
200 * work around an unsolved stack overflow seen very late during
201 * shutdown on sparc64 when the gmirror worker process exists.
202 */
203 if (p == initproc && rebooting == 0) {
204 printf("init died (signal %d, exit %d)\n",
205 WTERMSIG(rv), WEXITSTATUS(rv));
206 panic("Going nowhere without my init!");
207 }
208
209 /*
210 * Deref SU mp, since the thread does not return to userspace.
211 */
212 if (softdep_ast_cleanup != NULL)
213 softdep_ast_cleanup();
214
215 /*
216 * MUST abort all other threads before proceeding past here.
217 */
218 PROC_LOCK(p);
219 /*
220 * First check if some other thread or external request got
221 * here before us. If so, act appropriately: exit or suspend.
222 * We must ensure that stop requests are handled before we set
223 * P_WEXIT.
224 */
225 thread_suspend_check(0);
226 while (p->p_flag & P_HADTHREADS) {
227 /*
228 * Kill off the other threads. This requires
229 * some co-operation from other parts of the kernel
230 * so it may not be instantaneous. With this state set
231 * any thread entering the kernel from userspace will
232 * thread_exit() in trap(). Any thread attempting to
233 * sleep will return immediately with EINTR or EWOULDBLOCK
234 * which will hopefully force them to back out to userland
235 * freeing resources as they go. Any thread attempting
236 * to return to userland will thread_exit() from userret().
237 * thread_exit() will unsuspend us when the last of the
238 * other threads exits.
239 * If there is already a thread singler after resumption,
240 * calling thread_single will fail; in that case, we just
241 * re-check all suspension request, the thread should
242 * either be suspended there or exit.
243 */
244 if (!thread_single(p, SINGLE_EXIT))
245 /*
246 * All other activity in this process is now
247 * stopped. Threading support has been turned
248 * off.
249 */
250 break;
251 /*
252 * Recheck for new stop or suspend requests which
253 * might appear while process lock was dropped in
254 * thread_single().
255 */
256 thread_suspend_check(0);
257 }
258 KASSERT(p->p_numthreads == 1,
259 ("exit1: proc %p exiting with %d threads", p, p->p_numthreads));
260 racct_sub(p, RACCT_NTHR, 1);
261 /*
262 * Wakeup anyone in procfs' PIOCWAIT. They should have a hold
263 * on our vmspace, so we should block below until they have
264 * released their reference to us. Note that if they have
265 * requested S_EXIT stops we will block here until they ack
266 * via PIOCCONT.
267 */
268 _STOPEVENT(p, S_EXIT, rv);
269
270 /*
271 * Ignore any pending request to stop due to a stop signal.
272 * Once P_WEXIT is set, future requests will be ignored as
273 * well.
274 */
275 p->p_flag &= ~P_STOPPED_SIG;
276 KASSERT(!P_SHOULDSTOP(p), ("exiting process is stopped"));
277
278 /*
279 * Note that we are exiting and do another wakeup of anyone in
280 * PIOCWAIT in case they aren't listening for S_EXIT stops or
281 * decided to wait again after we told them we are exiting.
282 */
283 p->p_flag |= P_WEXIT;
284 wakeup(&p->p_stype);
285
286 /*
287 * Wait for any processes that have a hold on our vmspace to
288 * release their reference.
289 */
290 while (p->p_lock > 0)
291 msleep(&p->p_lock, &p->p_mtx, PWAIT, "exithold", 0);
292
293 p->p_xstat = rv; /* Let event handler change exit status */
294 PROC_UNLOCK(p);
295 /* Drain the limit callout while we don't have the proc locked */
296 callout_drain(&p->p_limco);
297
298 #ifdef AUDIT
299 /*
300 * The Sun BSM exit token contains two components: an exit status as
301 * passed to exit(), and a return value to indicate what sort of exit
302 * it was. The exit status is WEXITSTATUS(rv), but it's not clear
303 * what the return value is.
304 */
305 AUDIT_ARG_EXIT(WEXITSTATUS(rv), 0);
306 AUDIT_SYSCALL_EXIT(0, td);
307 #endif
308
309 /* Are we a task leader? */
310 if (p == p->p_leader) {
311 mtx_lock(&ppeers_lock);
312 q = p->p_peers;
313 while (q != NULL) {
314 PROC_LOCK(q);
315 kern_psignal(q, SIGKILL);
316 PROC_UNLOCK(q);
317 q = q->p_peers;
318 }
319 while (p->p_peers != NULL)
320 msleep(p, &ppeers_lock, PWAIT, "exit1", 0);
321 mtx_unlock(&ppeers_lock);
322 }
323
324 /*
325 * Check if any loadable modules need anything done at process exit.
326 * E.g. SYSV IPC stuff
327 * XXX what if one of these generates an error?
328 */
329 EVENTHANDLER_INVOKE(process_exit, p);
330
331 /*
332 * If parent is waiting for us to exit or exec,
333 * P_PPWAIT is set; we will wakeup the parent below.
334 */
335 PROC_LOCK(p);
336 rv = p->p_xstat; /* Event handler could change exit status */
337 stopprofclock(p);
338 p->p_flag &= ~(P_TRACED | P_PPWAIT | P_PPTRACE);
339 p->p_ptevents = 0;
340
341 /*
342 * Stop the real interval timer. If the handler is currently
343 * executing, prevent it from rearming itself and let it finish.
344 */
345 if (timevalisset(&p->p_realtimer.it_value) &&
346 callout_stop(&p->p_itcallout) == 0) {
347 timevalclear(&p->p_realtimer.it_interval);
348 msleep(&p->p_itcallout, &p->p_mtx, PWAIT, "ritwait", 0);
349 KASSERT(!timevalisset(&p->p_realtimer.it_value),
350 ("realtime timer is still armed"));
351 }
352 PROC_UNLOCK(p);
353
354 /*
355 * Reset any sigio structures pointing to us as a result of
356 * F_SETOWN with our pid.
357 */
358 funsetownlst(&p->p_sigiolst);
359
360 /*
361 * If this process has an nlminfo data area (for lockd), release it
362 */
363 if (nlminfo_release_p != NULL && p->p_nlminfo != NULL)
364 (*nlminfo_release_p)(p);
365
366 /*
367 * Close open files and release open-file table.
368 * This may block!
369 */
370 fdescfree(td);
371
372 /*
373 * If this thread tickled GEOM, we need to wait for the giggling to
374 * stop before we return to userland
375 */
376 if (td->td_pflags & TDP_GEOM)
377 g_waitidle();
378
379 /*
380 * Remove ourself from our leader's peer list and wake our leader.
381 */
382 mtx_lock(&ppeers_lock);
383 if (p->p_leader->p_peers) {
384 q = p->p_leader;
385 while (q->p_peers != p)
386 q = q->p_peers;
387 q->p_peers = p->p_peers;
388 wakeup(p->p_leader);
389 }
390 mtx_unlock(&ppeers_lock);
391
392 vmspace_exit(td);
393
394 sx_xlock(&proctree_lock);
395 if (SESS_LEADER(p)) {
396 struct session *sp = p->p_session;
397 struct tty *tp;
398
399 /*
400 * s_ttyp is not zero'd; we use this to indicate that
401 * the session once had a controlling terminal. (for
402 * logging and informational purposes)
403 */
404 SESS_LOCK(sp);
405 ttyvp = sp->s_ttyvp;
406 tp = sp->s_ttyp;
407 sp->s_ttyvp = NULL;
408 sp->s_ttydp = NULL;
409 sp->s_leader = NULL;
410 SESS_UNLOCK(sp);
411
412 /*
413 * Signal foreground pgrp and revoke access to
414 * controlling terminal if it has not been revoked
415 * already.
416 *
417 * Because the TTY may have been revoked in the mean
418 * time and could already have a new session associated
419 * with it, make sure we don't send a SIGHUP to a
420 * foreground process group that does not belong to this
421 * session.
422 */
423
424 if (tp != NULL) {
425 tty_lock(tp);
426 if (tp->t_session == sp)
427 tty_signal_pgrp(tp, SIGHUP);
428 tty_unlock(tp);
429 }
430
431 if (ttyvp != NULL) {
432 sx_xunlock(&proctree_lock);
433 if (vn_lock(ttyvp, LK_EXCLUSIVE) == 0) {
434 VOP_REVOKE(ttyvp, REVOKEALL);
435 VOP_UNLOCK(ttyvp, 0);
436 }
437 sx_xlock(&proctree_lock);
438 }
439 }
440 fixjobc(p, p->p_pgrp, 0);
441 sx_xunlock(&proctree_lock);
442 (void)acct_process(td);
443
444 /* Release the TTY now we've unlocked everything. */
445 if (ttyvp != NULL)
446 vrele(ttyvp);
447 #ifdef KTRACE
448 ktrprocexit(td);
449 #endif
450 /*
451 * Release reference to text vnode
452 */
453 if (p->p_textvp != NULL) {
454 vrele(p->p_textvp);
455 p->p_textvp = NULL;
456 }
457
458 /*
459 * Release our limits structure.
460 */
461 lim_free(p->p_limit);
462 p->p_limit = NULL;
463
464 tidhash_remove(td);
465
466 /*
467 * Remove proc from allproc queue and pidhash chain.
468 * Place onto zombproc. Unlink from parent's child list.
469 */
470 sx_xlock(&allproc_lock);
471 LIST_REMOVE(p, p_list);
472 LIST_INSERT_HEAD(&zombproc, p, p_list);
473 LIST_REMOVE(p, p_hash);
474 sx_xunlock(&allproc_lock);
475
476 /*
477 * Call machine-dependent code to release any
478 * machine-dependent resources other than the address space.
479 * The address space is released by "vmspace_exitfree(p)" in
480 * vm_waitproc().
481 */
482 cpu_exit(td);
483
484 WITNESS_WARN(WARN_PANIC, NULL, "process (pid %d) exiting", p->p_pid);
485
486 /*
487 * Reparent all children processes:
488 * - traced ones to the original parent (or init if we are that parent)
489 * - the rest to init
490 */
491 sx_xlock(&proctree_lock);
492 q = LIST_FIRST(&p->p_children);
493 if (q != NULL) /* only need this if any child is S_ZOMB */
494 wakeup(q->p_reaper);
495 for (; q != NULL; q = nq) {
496 nq = LIST_NEXT(q, p_sibling);
497 PROC_LOCK(q);
498 q->p_sigparent = SIGCHLD;
499
500 if (!(q->p_flag & P_TRACED)) {
501 proc_reparent(q, q->p_reaper);
502 if (q->p_state == PRS_ZOMBIE) {
503 PROC_LOCK(q->p_reaper);
504 pksignal(q->p_reaper, SIGCHLD, q->p_ksi);
505 PROC_UNLOCK(q->p_reaper);
506 }
507 } else {
508 /*
509 * Traced processes are killed since their existence
510 * means someone is screwing up.
511 */
512 t = proc_realparent(q);
513 if (t == p) {
514 proc_reparent(q, q->p_reaper);
515 } else {
516 PROC_LOCK(t);
517 proc_reparent(q, t);
518 PROC_UNLOCK(t);
519 }
520 /*
521 * Since q was found on our children list, the
522 * proc_reparent() call moved q to the orphan
523 * list due to present P_TRACED flag. Clear
524 * orphan link for q now while q is locked.
525 */
526 clear_orphan(q);
527 q->p_flag &= ~(P_TRACED | P_STOPPED_TRACE);
528 q->p_flag2 &= ~P2_PTRACE_FSTP;
529 q->p_ptevents = 0;
530 FOREACH_THREAD_IN_PROC(q, tdt) {
531 tdt->td_dbgflags &= ~(TDB_SUSPEND | TDB_XSIG |
532 TDB_FSTP);
533 }
534 kern_psignal(q, SIGKILL);
535 }
536 PROC_UNLOCK(q);
537 }
538
539 /*
540 * Also get rid of our orphans.
541 */
542 while ((q = LIST_FIRST(&p->p_orphans)) != NULL) {
543 PROC_LOCK(q);
544 CTR2(KTR_PTRACE, "exit: pid %d, clearing orphan %d", p->p_pid,
545 q->p_pid);
546 clear_orphan(q);
547 PROC_UNLOCK(q);
548 }
549
550 /* Save exit status. */
551 PROC_LOCK(p);
552 p->p_xthread = td;
553
554 /* Tell the prison that we are gone. */
555 prison_proc_free(p->p_ucred->cr_prison);
556
557 #ifdef KDTRACE_HOOKS
558 /*
559 * Tell the DTrace fasttrap provider about the exit if it
560 * has declared an interest.
561 */
562 if (dtrace_fasttrap_exit)
563 dtrace_fasttrap_exit(p);
564 #endif
565
566 /*
567 * Notify interested parties of our demise.
568 */
569 KNOTE_LOCKED(&p->p_klist, NOTE_EXIT);
570
571 #ifdef KDTRACE_HOOKS
572 int reason = CLD_EXITED;
573 if (WCOREDUMP(rv))
574 reason = CLD_DUMPED;
575 else if (WIFSIGNALED(rv))
576 reason = CLD_KILLED;
577 SDT_PROBE1(proc, , , exit, reason);
578 #endif
579
580 /*
581 * Just delete all entries in the p_klist. At this point we won't
582 * report any more events, and there are nasty race conditions that
583 * can beat us if we don't.
584 */
585 knlist_clear(&p->p_klist, 1);
586
587 /*
588 * If this is a process with a descriptor, we may not need to deliver
589 * a signal to the parent. proctree_lock is held over
590 * procdesc_exit() to serialize concurrent calls to close() and
591 * exit().
592 */
593 #ifdef PROCDESC
594 if (p->p_procdesc == NULL || procdesc_exit(p)) {
595 #endif
596 /*
597 * Notify parent that we're gone. If parent has the
598 * PS_NOCLDWAIT flag set, or if the handler is set to SIG_IGN,
599 * notify process 1 instead (and hope it will handle this
600 * situation).
601 */
602 PROC_LOCK(p->p_pptr);
603 mtx_lock(&p->p_pptr->p_sigacts->ps_mtx);
604 if (p->p_pptr->p_sigacts->ps_flag &
605 (PS_NOCLDWAIT | PS_CLDSIGIGN)) {
606 struct proc *pp;
607
608 mtx_unlock(&p->p_pptr->p_sigacts->ps_mtx);
609 pp = p->p_pptr;
610 PROC_UNLOCK(pp);
611 proc_reparent(p, p->p_reaper);
612 p->p_sigparent = SIGCHLD;
613 PROC_LOCK(p->p_pptr);
614
615 /*
616 * Notify parent, so in case he was wait(2)ing or
617 * executing waitpid(2) with our pid, he will
618 * continue.
619 */
620 wakeup(pp);
621 } else
622 mtx_unlock(&p->p_pptr->p_sigacts->ps_mtx);
623
624 if (p->p_pptr == p->p_reaper || p->p_pptr == initproc)
625 childproc_exited(p);
626 else if (p->p_sigparent != 0) {
627 if (p->p_sigparent == SIGCHLD)
628 childproc_exited(p);
629 else /* LINUX thread */
630 kern_psignal(p->p_pptr, p->p_sigparent);
631 }
632 #ifdef PROCDESC
633 } else
634 PROC_LOCK(p->p_pptr);
635 #endif
636 sx_xunlock(&proctree_lock);
637
638 /*
639 * The state PRS_ZOMBIE prevents other proesses from sending
640 * signal to the process, to avoid memory leak, we free memory
641 * for signal queue at the time when the state is set.
642 */
643 sigqueue_flush(&p->p_sigqueue);
644 sigqueue_flush(&td->td_sigqueue);
645
646 /*
647 * We have to wait until after acquiring all locks before
648 * changing p_state. We need to avoid all possible context
649 * switches (including ones from blocking on a mutex) while
650 * marked as a zombie. We also have to set the zombie state
651 * before we release the parent process' proc lock to avoid
652 * a lost wakeup. So, we first call wakeup, then we grab the
653 * sched lock, update the state, and release the parent process'
654 * proc lock.
655 */
656 wakeup(p->p_pptr);
657 cv_broadcast(&p->p_pwait);
658 sched_exit(p->p_pptr, td);
659 umtx_thread_exit(td);
660 PROC_SLOCK(p);
661 p->p_state = PRS_ZOMBIE;
662 PROC_UNLOCK(p->p_pptr);
663
664 /*
665 * Hopefully no one will try to deliver a signal to the process this
666 * late in the game.
667 */
668 knlist_destroy(&p->p_klist);
669
670 /*
671 * Save our children's rusage information in our exit rusage.
672 */
673 PROC_STATLOCK(p);
674 ruadd(&p->p_ru, &p->p_rux, &p->p_stats->p_cru, &p->p_crux);
675 PROC_STATUNLOCK(p);
676
677 /*
678 * Make sure the scheduler takes this thread out of its tables etc.
679 * This will also release this thread's reference to the ucred.
680 * Other thread parts to release include pcb bits and such.
681 */
682 thread_exit();
683 }
684
685
686 #ifndef _SYS_SYSPROTO_H_
687 struct abort2_args {
688 char *why;
689 int nargs;
690 void **args;
691 };
692 #endif
693
694 int
695 sys_abort2(struct thread *td, struct abort2_args *uap)
696 {
697 struct proc *p = td->td_proc;
698 struct sbuf *sb;
699 void *uargs[16];
700 int error, i, sig;
701
702 /*
703 * Do it right now so we can log either proper call of abort2(), or
704 * note, that invalid argument was passed. 512 is big enough to
705 * handle 16 arguments' descriptions with additional comments.
706 */
707 sb = sbuf_new(NULL, NULL, 512, SBUF_FIXEDLEN);
708 sbuf_clear(sb);
709 sbuf_printf(sb, "%s(pid %d uid %d) aborted: ",
710 p->p_comm, p->p_pid, td->td_ucred->cr_uid);
711 /*
712 * Since we can't return from abort2(), send SIGKILL in cases, where
713 * abort2() was called improperly
714 */
715 sig = SIGKILL;
716 /* Prevent from DoSes from user-space. */
717 if (uap->nargs < 0 || uap->nargs > 16)
718 goto out;
719 if (uap->nargs > 0) {
720 if (uap->args == NULL)
721 goto out;
722 error = copyin(uap->args, uargs, uap->nargs * sizeof(void *));
723 if (error != 0)
724 goto out;
725 }
726 /*
727 * Limit size of 'reason' string to 128. Will fit even when
728 * maximal number of arguments was chosen to be logged.
729 */
730 if (uap->why != NULL) {
731 error = sbuf_copyin(sb, uap->why, 128);
732 if (error < 0)
733 goto out;
734 } else {
735 sbuf_printf(sb, "(null)");
736 }
737 if (uap->nargs > 0) {
738 sbuf_printf(sb, "(");
739 for (i = 0;i < uap->nargs; i++)
740 sbuf_printf(sb, "%s%p", i == 0 ? "" : ", ", uargs[i]);
741 sbuf_printf(sb, ")");
742 }
743 /*
744 * Final stage: arguments were proper, string has been
745 * successfully copied from userspace, and copying pointers
746 * from user-space succeed.
747 */
748 sig = SIGABRT;
749 out:
750 if (sig == SIGKILL) {
751 sbuf_trim(sb);
752 sbuf_printf(sb, " (Reason text inaccessible)");
753 }
754 sbuf_cat(sb, "\n");
755 sbuf_finish(sb);
756 log(LOG_INFO, "%s", sbuf_data(sb));
757 sbuf_delete(sb);
758 exit1(td, W_EXITCODE(0, sig));
759 return (0);
760 }
761
762
763 #ifdef COMPAT_43
764 /*
765 * The dirty work is handled by kern_wait().
766 */
767 int
768 owait(struct thread *td, struct owait_args *uap __unused)
769 {
770 int error, status;
771
772 error = kern_wait(td, WAIT_ANY, &status, 0, NULL);
773 if (error == 0)
774 td->td_retval[1] = status;
775 return (error);
776 }
777 #endif /* COMPAT_43 */
778
779 /*
780 * The dirty work is handled by kern_wait().
781 */
782 int
783 sys_wait4(struct thread *td, struct wait4_args *uap)
784 {
785 struct rusage ru, *rup;
786 int error, status;
787
788 if (uap->rusage != NULL)
789 rup = &ru;
790 else
791 rup = NULL;
792 error = kern_wait(td, uap->pid, &status, uap->options, rup);
793 if (uap->status != NULL && error == 0 && td->td_retval[0] != 0)
794 error = copyout(&status, uap->status, sizeof(status));
795 if (uap->rusage != NULL && error == 0 && td->td_retval[0] != 0)
796 error = copyout(&ru, uap->rusage, sizeof(struct rusage));
797 return (error);
798 }
799
800 int
801 sys_wait6(struct thread *td, struct wait6_args *uap)
802 {
803 struct __wrusage wru, *wrup;
804 siginfo_t si, *sip;
805 idtype_t idtype;
806 id_t id;
807 int error, status;
808
809 idtype = uap->idtype;
810 id = uap->id;
811
812 if (uap->wrusage != NULL)
813 wrup = &wru;
814 else
815 wrup = NULL;
816
817 if (uap->info != NULL) {
818 sip = &si;
819 bzero(sip, sizeof(*sip));
820 } else
821 sip = NULL;
822
823 /*
824 * We expect all callers of wait6() to know about WEXITED and
825 * WTRAPPED.
826 */
827 error = kern_wait6(td, idtype, id, &status, uap->options, wrup, sip);
828
829 if (uap->status != NULL && error == 0 && td->td_retval[0] != 0)
830 error = copyout(&status, uap->status, sizeof(status));
831 if (uap->wrusage != NULL && error == 0 && td->td_retval[0] != 0)
832 error = copyout(&wru, uap->wrusage, sizeof(wru));
833 if (uap->info != NULL && error == 0)
834 error = copyout(&si, uap->info, sizeof(si));
835 return (error);
836 }
837
838 /*
839 * Reap the remains of a zombie process and optionally return status and
840 * rusage. Asserts and will release both the proctree_lock and the process
841 * lock as part of its work.
842 */
843 void
844 proc_reap(struct thread *td, struct proc *p, int *status, int options)
845 {
846 struct proc *q, *t;
847
848 sx_assert(&proctree_lock, SA_XLOCKED);
849 PROC_LOCK_ASSERT(p, MA_OWNED);
850 PROC_SLOCK_ASSERT(p, MA_OWNED);
851 KASSERT(p->p_state == PRS_ZOMBIE, ("proc_reap: !PRS_ZOMBIE"));
852
853 q = td->td_proc;
854
855 PROC_SUNLOCK(p);
856 td->td_retval[0] = p->p_pid;
857 if (status)
858 *status = p->p_xstat; /* convert to int */
859 if (options & WNOWAIT) {
860 /*
861 * Only poll, returning the status. Caller does not wish to
862 * release the proc struct just yet.
863 */
864 PROC_UNLOCK(p);
865 sx_xunlock(&proctree_lock);
866 return;
867 }
868
869 PROC_LOCK(q);
870 sigqueue_take(p->p_ksi);
871 PROC_UNLOCK(q);
872
873 /*
874 * If we got the child via a ptrace 'attach', we need to give it back
875 * to the old parent.
876 */
877 if (p->p_oppid != 0 && p->p_oppid != p->p_pptr->p_pid) {
878 PROC_UNLOCK(p);
879 t = proc_realparent(p);
880 PROC_LOCK(t);
881 PROC_LOCK(p);
882 CTR2(KTR_PTRACE,
883 "wait: traced child %d moved back to parent %d", p->p_pid,
884 t->p_pid);
885 proc_reparent(p, t);
886 p->p_oppid = 0;
887 PROC_UNLOCK(p);
888 pksignal(t, SIGCHLD, p->p_ksi);
889 wakeup(t);
890 cv_broadcast(&p->p_pwait);
891 PROC_UNLOCK(t);
892 sx_xunlock(&proctree_lock);
893 return;
894 }
895 p->p_oppid = 0;
896 PROC_UNLOCK(p);
897
898 /*
899 * Remove other references to this process to ensure we have an
900 * exclusive reference.
901 */
902 sx_xlock(&allproc_lock);
903 LIST_REMOVE(p, p_list); /* off zombproc */
904 sx_xunlock(&allproc_lock);
905 LIST_REMOVE(p, p_sibling);
906 reaper_abandon_children(p, true);
907 LIST_REMOVE(p, p_reapsibling);
908 PROC_LOCK(p);
909 clear_orphan(p);
910 PROC_UNLOCK(p);
911 leavepgrp(p);
912 #ifdef PROCDESC
913 if (p->p_procdesc != NULL)
914 procdesc_reap(p);
915 #endif
916 sx_xunlock(&proctree_lock);
917
918 /*
919 * As a side effect of this lock, we know that all other writes to
920 * this proc are visible now, so no more locking is needed for p.
921 */
922 PROC_LOCK(p);
923 p->p_xstat = 0; /* XXX: why? */
924 PROC_UNLOCK(p);
925 PROC_LOCK(q);
926 ruadd(&q->p_stats->p_cru, &q->p_crux, &p->p_ru, &p->p_rux);
927 PROC_UNLOCK(q);
928
929 /*
930 * Decrement the count of procs running with this uid.
931 */
932 (void)chgproccnt(p->p_ucred->cr_ruidinfo, -1, 0);
933
934 /*
935 * Destroy resource accounting information associated with the process.
936 */
937 #ifdef RACCT
938 if (racct_enable) {
939 PROC_LOCK(p);
940 racct_sub(p, RACCT_NPROC, 1);
941 PROC_UNLOCK(p);
942 }
943 #endif
944 racct_proc_exit(p);
945
946 /*
947 * Free credentials, arguments, and sigacts.
948 */
949 crfree(p->p_ucred);
950 proc_set_cred(p, NULL);
951 pargs_drop(p->p_args);
952 p->p_args = NULL;
953 sigacts_free(p->p_sigacts);
954 p->p_sigacts = NULL;
955
956 /*
957 * Do any thread-system specific cleanups.
958 */
959 thread_wait(p);
960
961 /*
962 * Give vm and machine-dependent layer a chance to free anything that
963 * cpu_exit couldn't release while still running in process context.
964 */
965 vm_waitproc(p);
966 #ifdef MAC
967 mac_proc_destroy(p);
968 #endif
969 KASSERT(FIRST_THREAD_IN_PROC(p),
970 ("proc_reap: no residual thread!"));
971 uma_zfree(proc_zone, p);
972 atomic_add_int(&nprocs, -1);
973 }
974
975 static int
976 proc_to_reap(struct thread *td, struct proc *p, idtype_t idtype, id_t id,
977 int *status, int options, struct __wrusage *wrusage, siginfo_t *siginfo,
978 int check_only)
979 {
980 struct rusage *rup;
981
982 sx_assert(&proctree_lock, SA_XLOCKED);
983
984 PROC_LOCK(p);
985
986 switch (idtype) {
987 case P_ALL:
988 break;
989 case P_PID:
990 if (p->p_pid != (pid_t)id) {
991 PROC_UNLOCK(p);
992 return (0);
993 }
994 break;
995 case P_PGID:
996 if (p->p_pgid != (pid_t)id) {
997 PROC_UNLOCK(p);
998 return (0);
999 }
1000 break;
1001 case P_SID:
1002 if (p->p_session->s_sid != (pid_t)id) {
1003 PROC_UNLOCK(p);
1004 return (0);
1005 }
1006 break;
1007 case P_UID:
1008 if (p->p_ucred->cr_uid != (uid_t)id) {
1009 PROC_UNLOCK(p);
1010 return (0);
1011 }
1012 break;
1013 case P_GID:
1014 if (p->p_ucred->cr_gid != (gid_t)id) {
1015 PROC_UNLOCK(p);
1016 return (0);
1017 }
1018 break;
1019 case P_JAILID:
1020 if (p->p_ucred->cr_prison->pr_id != (int)id) {
1021 PROC_UNLOCK(p);
1022 return (0);
1023 }
1024 break;
1025 /*
1026 * It seems that the thread structures get zeroed out
1027 * at process exit. This makes it impossible to
1028 * support P_SETID, P_CID or P_CPUID.
1029 */
1030 default:
1031 PROC_UNLOCK(p);
1032 return (0);
1033 }
1034
1035 if (p_canwait(td, p)) {
1036 PROC_UNLOCK(p);
1037 return (0);
1038 }
1039
1040 if (((options & WEXITED) == 0) && (p->p_state == PRS_ZOMBIE)) {
1041 PROC_UNLOCK(p);
1042 return (0);
1043 }
1044
1045 /*
1046 * This special case handles a kthread spawned by linux_clone
1047 * (see linux_misc.c). The linux_wait4 and linux_waitpid
1048 * functions need to be able to distinguish between waiting
1049 * on a process and waiting on a thread. It is a thread if
1050 * p_sigparent is not SIGCHLD, and the WLINUXCLONE option
1051 * signifies we want to wait for threads and not processes.
1052 */
1053 if ((p->p_sigparent != SIGCHLD) ^
1054 ((options & WLINUXCLONE) != 0)) {
1055 PROC_UNLOCK(p);
1056 return (0);
1057 }
1058
1059 if (siginfo != NULL) {
1060 bzero(siginfo, sizeof(*siginfo));
1061 siginfo->si_errno = 0;
1062
1063 /*
1064 * SUSv4 requires that the si_signo value is always
1065 * SIGCHLD. Obey it despite the rfork(2) interface
1066 * allows to request other signal for child exit
1067 * notification.
1068 */
1069 siginfo->si_signo = SIGCHLD;
1070
1071 /*
1072 * This is still a rough estimate. We will fix the
1073 * cases TRAPPED, STOPPED, and CONTINUED later.
1074 */
1075 if (WCOREDUMP(p->p_xstat)) {
1076 siginfo->si_code = CLD_DUMPED;
1077 siginfo->si_status = WTERMSIG(p->p_xstat);
1078 } else if (WIFSIGNALED(p->p_xstat)) {
1079 siginfo->si_code = CLD_KILLED;
1080 siginfo->si_status = WTERMSIG(p->p_xstat);
1081 } else {
1082 siginfo->si_code = CLD_EXITED;
1083 siginfo->si_status = WEXITSTATUS(p->p_xstat);
1084 }
1085
1086 siginfo->si_pid = p->p_pid;
1087 siginfo->si_uid = p->p_ucred->cr_uid;
1088
1089 /*
1090 * The si_addr field would be useful additional
1091 * detail, but apparently the PC value may be lost
1092 * when we reach this point. bzero() above sets
1093 * siginfo->si_addr to NULL.
1094 */
1095 }
1096
1097 /*
1098 * There should be no reason to limit resources usage info to
1099 * exited processes only. A snapshot about any resources used
1100 * by a stopped process may be exactly what is needed.
1101 */
1102 if (wrusage != NULL) {
1103 rup = &wrusage->wru_self;
1104 *rup = p->p_ru;
1105 PROC_STATLOCK(p);
1106 calcru(p, &rup->ru_utime, &rup->ru_stime);
1107 PROC_STATUNLOCK(p);
1108
1109 rup = &wrusage->wru_children;
1110 *rup = p->p_stats->p_cru;
1111 calccru(p, &rup->ru_utime, &rup->ru_stime);
1112 }
1113
1114 if (p->p_state == PRS_ZOMBIE && !check_only) {
1115 PROC_SLOCK(p);
1116 proc_reap(td, p, status, options);
1117 return (-1);
1118 }
1119 PROC_UNLOCK(p);
1120 return (1);
1121 }
1122
1123 int
1124 kern_wait(struct thread *td, pid_t pid, int *status, int options,
1125 struct rusage *rusage)
1126 {
1127 struct __wrusage wru, *wrup;
1128 idtype_t idtype;
1129 id_t id;
1130 int ret;
1131
1132 /*
1133 * Translate the special pid values into the (idtype, pid)
1134 * pair for kern_wait6. The WAIT_MYPGRP case is handled by
1135 * kern_wait6() on its own.
1136 */
1137 if (pid == WAIT_ANY) {
1138 idtype = P_ALL;
1139 id = 0;
1140 } else if (pid < 0) {
1141 idtype = P_PGID;
1142 id = (id_t)-pid;
1143 } else {
1144 idtype = P_PID;
1145 id = (id_t)pid;
1146 }
1147
1148 if (rusage != NULL)
1149 wrup = &wru;
1150 else
1151 wrup = NULL;
1152
1153 /*
1154 * For backward compatibility we implicitly add flags WEXITED
1155 * and WTRAPPED here.
1156 */
1157 options |= WEXITED | WTRAPPED;
1158 ret = kern_wait6(td, idtype, id, status, options, wrup, NULL);
1159 if (rusage != NULL)
1160 *rusage = wru.wru_self;
1161 return (ret);
1162 }
1163
1164 int
1165 kern_wait6(struct thread *td, idtype_t idtype, id_t id, int *status,
1166 int options, struct __wrusage *wrusage, siginfo_t *siginfo)
1167 {
1168 struct proc *p, *q;
1169 int error, nfound, ret;
1170
1171 AUDIT_ARG_VALUE((int)idtype); /* XXX - This is likely wrong! */
1172 AUDIT_ARG_PID((pid_t)id); /* XXX - This may be wrong! */
1173 AUDIT_ARG_VALUE(options);
1174
1175 q = td->td_proc;
1176
1177 if ((pid_t)id == WAIT_MYPGRP && (idtype == P_PID || idtype == P_PGID)) {
1178 PROC_LOCK(q);
1179 id = (id_t)q->p_pgid;
1180 PROC_UNLOCK(q);
1181 idtype = P_PGID;
1182 }
1183
1184 /* If we don't know the option, just return. */
1185 if ((options & ~(WUNTRACED | WNOHANG | WCONTINUED | WNOWAIT |
1186 WEXITED | WTRAPPED | WLINUXCLONE)) != 0)
1187 return (EINVAL);
1188 if ((options & (WEXITED | WUNTRACED | WCONTINUED | WTRAPPED)) == 0) {
1189 /*
1190 * We will be unable to find any matching processes,
1191 * because there are no known events to look for.
1192 * Prefer to return error instead of blocking
1193 * indefinitely.
1194 */
1195 return (EINVAL);
1196 }
1197
1198 loop:
1199 if (q->p_flag & P_STATCHILD) {
1200 PROC_LOCK(q);
1201 q->p_flag &= ~P_STATCHILD;
1202 PROC_UNLOCK(q);
1203 }
1204 nfound = 0;
1205 sx_xlock(&proctree_lock);
1206 LIST_FOREACH(p, &q->p_children, p_sibling) {
1207 ret = proc_to_reap(td, p, idtype, id, status, options,
1208 wrusage, siginfo, 0);
1209 if (ret == 0)
1210 continue;
1211 else if (ret == 1)
1212 nfound++;
1213 else
1214 return (0);
1215
1216 PROC_LOCK(p);
1217 PROC_SLOCK(p);
1218
1219 if ((options & WTRAPPED) != 0 &&
1220 (p->p_flag & P_TRACED) != 0 &&
1221 (p->p_flag & (P_STOPPED_TRACE | P_STOPPED_SIG)) != 0 &&
1222 (p->p_suspcount == p->p_numthreads) &&
1223 ((p->p_flag & P_WAITED) == 0)) {
1224 PROC_SUNLOCK(p);
1225 if ((options & WNOWAIT) == 0)
1226 p->p_flag |= P_WAITED;
1227 sx_xunlock(&proctree_lock);
1228 td->td_retval[0] = p->p_pid;
1229
1230 if (status != NULL)
1231 *status = W_STOPCODE(p->p_xstat);
1232 if (siginfo != NULL) {
1233 siginfo->si_status = p->p_xstat;
1234 siginfo->si_code = CLD_TRAPPED;
1235 }
1236 if ((options & WNOWAIT) == 0) {
1237 PROC_LOCK(q);
1238 sigqueue_take(p->p_ksi);
1239 PROC_UNLOCK(q);
1240 }
1241
1242 CTR4(KTR_PTRACE,
1243 "wait: returning trapped pid %d status %#x (xstat %d) xthread %d",
1244 p->p_pid, W_STOPCODE(p->p_xstat), p->p_xstat,
1245 p->p_xthread != NULL ? p->p_xthread->td_tid : -1);
1246 PROC_UNLOCK(p);
1247 return (0);
1248 }
1249 if ((options & WUNTRACED) != 0 &&
1250 (p->p_flag & P_STOPPED_SIG) != 0 &&
1251 (p->p_suspcount == p->p_numthreads) &&
1252 ((p->p_flag & P_WAITED) == 0)) {
1253 PROC_SUNLOCK(p);
1254 if ((options & WNOWAIT) == 0)
1255 p->p_flag |= P_WAITED;
1256 sx_xunlock(&proctree_lock);
1257 td->td_retval[0] = p->p_pid;
1258
1259 if (status != NULL)
1260 *status = W_STOPCODE(p->p_xstat);
1261 if (siginfo != NULL) {
1262 siginfo->si_status = p->p_xstat;
1263 siginfo->si_code = CLD_STOPPED;
1264 }
1265 if ((options & WNOWAIT) == 0) {
1266 PROC_LOCK(q);
1267 sigqueue_take(p->p_ksi);
1268 PROC_UNLOCK(q);
1269 }
1270
1271 PROC_UNLOCK(p);
1272 return (0);
1273 }
1274 PROC_SUNLOCK(p);
1275 if ((options & WCONTINUED) != 0 &&
1276 (p->p_flag & P_CONTINUED) != 0) {
1277 sx_xunlock(&proctree_lock);
1278 td->td_retval[0] = p->p_pid;
1279 if ((options & WNOWAIT) == 0) {
1280 p->p_flag &= ~P_CONTINUED;
1281 PROC_LOCK(q);
1282 sigqueue_take(p->p_ksi);
1283 PROC_UNLOCK(q);
1284 }
1285 PROC_UNLOCK(p);
1286
1287 if (status != NULL)
1288 *status = SIGCONT;
1289 if (siginfo != NULL) {
1290 siginfo->si_status = SIGCONT;
1291 siginfo->si_code = CLD_CONTINUED;
1292 }
1293 return (0);
1294 }
1295 PROC_UNLOCK(p);
1296 }
1297
1298 /*
1299 * Look in the orphans list too, to allow the parent to
1300 * collect it's child exit status even if child is being
1301 * debugged.
1302 *
1303 * Debugger detaches from the parent upon successful
1304 * switch-over from parent to child. At this point due to
1305 * re-parenting the parent loses the child to debugger and a
1306 * wait4(2) call would report that it has no children to wait
1307 * for. By maintaining a list of orphans we allow the parent
1308 * to successfully wait until the child becomes a zombie.
1309 */
1310 if (nfound == 0) {
1311 LIST_FOREACH(p, &q->p_orphans, p_orphan) {
1312 ret = proc_to_reap(td, p, idtype, id, NULL, options,
1313 NULL, NULL, 1);
1314 if (ret != 0) {
1315 KASSERT(ret != -1, ("reaped an orphan (pid %d)",
1316 (int)td->td_retval[0]));
1317 nfound++;
1318 break;
1319 }
1320 }
1321 }
1322 if (nfound == 0) {
1323 sx_xunlock(&proctree_lock);
1324 return (ECHILD);
1325 }
1326 if (options & WNOHANG) {
1327 sx_xunlock(&proctree_lock);
1328 td->td_retval[0] = 0;
1329 return (0);
1330 }
1331 PROC_LOCK(q);
1332 sx_xunlock(&proctree_lock);
1333 if (q->p_flag & P_STATCHILD) {
1334 q->p_flag &= ~P_STATCHILD;
1335 error = 0;
1336 } else
1337 error = msleep(q, &q->p_mtx, PWAIT | PCATCH, "wait", 0);
1338 PROC_UNLOCK(q);
1339 if (error)
1340 return (error);
1341 goto loop;
1342 }
1343
1344 /*
1345 * Make process 'parent' the new parent of process 'child'.
1346 * Must be called with an exclusive hold of proctree lock.
1347 */
1348 void
1349 proc_reparent(struct proc *child, struct proc *parent)
1350 {
1351
1352 sx_assert(&proctree_lock, SX_XLOCKED);
1353 PROC_LOCK_ASSERT(child, MA_OWNED);
1354 if (child->p_pptr == parent)
1355 return;
1356
1357 PROC_LOCK(child->p_pptr);
1358 sigqueue_take(child->p_ksi);
1359 PROC_UNLOCK(child->p_pptr);
1360 LIST_REMOVE(child, p_sibling);
1361 LIST_INSERT_HEAD(&parent->p_children, child, p_sibling);
1362
1363 clear_orphan(child);
1364 if (child->p_flag & P_TRACED) {
1365 if (LIST_EMPTY(&child->p_pptr->p_orphans)) {
1366 child->p_treeflag |= P_TREE_FIRST_ORPHAN;
1367 LIST_INSERT_HEAD(&child->p_pptr->p_orphans, child,
1368 p_orphan);
1369 } else {
1370 LIST_INSERT_AFTER(LIST_FIRST(&child->p_pptr->p_orphans),
1371 child, p_orphan);
1372 }
1373 child->p_treeflag |= P_TREE_ORPHANED;
1374 }
1375
1376 child->p_pptr = parent;
1377 }
Cache object: 1126459de2709bc501ba277d2a713f4c
|