1997-02-10 02:22:35 +00:00
|
|
|
/*
|
1994-05-24 10:09:53 +00:00
|
|
|
* Copyright (c) 1982, 1986, 1989, 1991, 1993
|
|
|
|
* The Regents of the University of California. All rights reserved.
|
|
|
|
* (c) UNIX System Laboratories, Inc.
|
|
|
|
* All or some portions of this file are derived from material licensed
|
|
|
|
* to the University of California by American Telephone and Telegraph
|
|
|
|
* Co. or Unix System Laboratories, Inc. and are reproduced herein with
|
|
|
|
* the permission of UNIX System Laboratories, Inc.
|
|
|
|
*
|
|
|
|
* Redistribution and use in source and binary forms, with or without
|
|
|
|
* modification, are permitted provided that the following conditions
|
|
|
|
* are met:
|
|
|
|
* 1. Redistributions of source code must retain the above copyright
|
|
|
|
* notice, this list of conditions and the following disclaimer.
|
|
|
|
* 2. Redistributions in binary form must reproduce the above copyright
|
|
|
|
* notice, this list of conditions and the following disclaimer in the
|
|
|
|
* documentation and/or other materials provided with the distribution.
|
|
|
|
* 4. Neither the name of the University nor the names of its contributors
|
|
|
|
* may be used to endorse or promote products derived from this software
|
|
|
|
* without specific prior written permission.
|
|
|
|
*
|
|
|
|
* THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
|
|
|
|
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
|
|
|
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
|
|
|
* ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
|
|
|
|
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
|
|
|
|
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
|
|
|
|
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
|
|
|
|
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
|
|
|
|
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
|
|
|
|
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
|
|
|
|
* SUCH DAMAGE.
|
|
|
|
*
|
|
|
|
* @(#)kern_exit.c 8.7 (Berkeley) 2/12/94
|
|
|
|
*/
|
|
|
|
|
2003-06-11 00:56:59 +00:00
|
|
|
#include <sys/cdefs.h>
|
|
|
|
__FBSDID("$FreeBSD$");
|
|
|
|
|
1997-12-16 17:40:42 +00:00
|
|
|
#include "opt_compat.h"
|
1996-01-03 21:42:35 +00:00
|
|
|
#include "opt_ktrace.h"
|
2002-11-20 15:41:25 +00:00
|
|
|
#include "opt_mac.h"
|
1996-01-03 21:42:35 +00:00
|
|
|
|
1994-05-24 10:09:53 +00:00
|
|
|
#include <sys/param.h>
|
|
|
|
#include <sys/systm.h>
|
1995-10-23 15:42:12 +00:00
|
|
|
#include <sys/sysproto.h>
|
2003-03-24 21:15:35 +00:00
|
|
|
#include <sys/eventhandler.h>
|
1998-11-10 09:16:29 +00:00
|
|
|
#include <sys/kernel.h>
|
1997-10-12 20:26:33 +00:00
|
|
|
#include <sys/malloc.h>
|
2001-03-28 09:17:56 +00:00
|
|
|
#include <sys/lock.h>
|
2000-10-20 07:58:15 +00:00
|
|
|
#include <sys/mutex.h>
|
1994-05-24 10:09:53 +00:00
|
|
|
#include <sys/proc.h>
|
1997-12-06 04:11:14 +00:00
|
|
|
#include <sys/pioctl.h>
|
1994-05-24 10:09:53 +00:00
|
|
|
#include <sys/tty.h>
|
|
|
|
#include <sys/wait.h>
|
2001-09-10 04:28:58 +00:00
|
|
|
#include <sys/vmmeter.h>
|
2002-05-06 15:46:29 +00:00
|
|
|
#include <sys/vnode.h>
|
1994-05-24 10:09:53 +00:00
|
|
|
#include <sys/resourcevar.h>
|
1994-10-02 17:35:40 +00:00
|
|
|
#include <sys/signalvar.h>
|
2002-10-12 05:32:24 +00:00
|
|
|
#include <sys/sched.h>
|
2001-03-28 11:52:56 +00:00
|
|
|
#include <sys/sx.h>
|
1994-05-24 10:09:53 +00:00
|
|
|
#include <sys/ptrace.h>
|
1996-03-11 02:24:21 +00:00
|
|
|
#include <sys/acct.h> /* for acct_process() function prototype */
|
1994-10-02 17:35:40 +00:00
|
|
|
#include <sys/filedesc.h>
|
2002-11-20 15:41:25 +00:00
|
|
|
#include <sys/mac.h>
|
1996-01-01 12:23:39 +00:00
|
|
|
#include <sys/shm.h>
|
|
|
|
#include <sys/sem.h>
|
2002-06-07 05:41:27 +00:00
|
|
|
#ifdef KTRACE
|
|
|
|
#include <sys/ktrace.h>
|
|
|
|
#endif
|
1996-01-01 12:23:39 +00:00
|
|
|
|
1994-05-24 10:09:53 +00:00
|
|
|
#include <vm/vm.h>
|
2001-09-10 04:28:58 +00:00
|
|
|
#include <vm/vm_extern.h>
|
2002-05-06 15:46:29 +00:00
|
|
|
#include <vm/vm_param.h>
|
1995-12-07 12:48:31 +00:00
|
|
|
#include <vm/pmap.h>
|
|
|
|
#include <vm/vm_map.h>
|
2002-11-25 04:37:44 +00:00
|
|
|
#include <vm/vm_page.h>
|
2002-03-20 04:09:59 +00:00
|
|
|
#include <vm/uma.h>
|
1994-05-24 10:09:53 +00:00
|
|
|
|
1999-01-31 03:15:13 +00:00
|
|
|
/* Required to be non-static for SysVR4 emulator */
|
1999-01-30 06:25:00 +00:00
|
|
|
MALLOC_DEFINE(M_ZOMBIE, "zombie", "zombie proc status");
|
1997-10-11 18:31:40 +00:00
|
|
|
|
1994-05-24 10:09:53 +00:00
|
|
|
/*
|
|
|
|
* exit --
|
|
|
|
* Death of process.
|
2001-09-01 04:37:34 +00:00
|
|
|
*
|
|
|
|
* MPSAFE
|
1994-05-24 10:09:53 +00:00
|
|
|
*/
|
1996-09-13 09:20:15 +00:00
|
|
|
void
|
2003-03-19 00:49:40 +00:00
|
|
|
sys_exit(struct thread *td, struct sys_exit_args *uap)
|
1994-05-24 10:09:53 +00:00
|
|
|
{
|
2001-09-12 08:38:13 +00:00
|
|
|
|
|
|
|
exit1(td, W_EXITCODE(uap->rval, 0));
|
1994-05-24 10:09:53 +00:00
|
|
|
/* NOTREACHED */
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Exit: deallocate address space and other resources, change proc state
|
|
|
|
* to zombie, and unlink proc from allproc and parent's lists. Save exit
|
|
|
|
* status and rusage for wait(). Check for child processes and orphan them.
|
|
|
|
*/
|
1996-09-13 09:20:15 +00:00
|
|
|
void
|
2003-03-19 00:49:40 +00:00
|
|
|
exit1(struct thread *td, int rv)
|
1994-05-24 10:09:53 +00:00
|
|
|
{
|
2004-09-22 15:24:33 +00:00
|
|
|
struct bintime new_switchtime;
|
2002-05-06 17:04:29 +00:00
|
|
|
struct proc *p, *nq, *q;
|
2002-02-23 11:12:57 +00:00
|
|
|
struct tty *tp;
|
2002-05-06 17:04:29 +00:00
|
|
|
struct vnode *ttyvp;
|
2003-03-19 00:49:40 +00:00
|
|
|
struct vmspace *vm;
|
2002-05-06 17:04:29 +00:00
|
|
|
struct vnode *vtmp;
|
2002-05-02 15:09:58 +00:00
|
|
|
#ifdef KTRACE
|
|
|
|
struct vnode *tracevp;
|
2003-03-13 18:24:22 +00:00
|
|
|
struct ucred *tracecred;
|
2002-05-02 15:09:58 +00:00
|
|
|
#endif
|
2004-02-04 21:52:57 +00:00
|
|
|
struct plimit *plim;
|
2004-07-27 03:53:41 +00:00
|
|
|
int refcnt;
|
1994-05-24 10:09:53 +00:00
|
|
|
|
2004-03-05 22:39:53 +00:00
|
|
|
/*
|
|
|
|
* Drop Giant if caller has it. Eventually we should warn about
|
|
|
|
* being called with Giant held.
|
|
|
|
*/
|
|
|
|
while (mtx_owned(&Giant))
|
|
|
|
mtx_unlock(&Giant);
|
2001-07-04 16:20:28 +00:00
|
|
|
|
2002-05-06 17:04:29 +00:00
|
|
|
p = td->td_proc;
|
2002-05-06 17:07:10 +00:00
|
|
|
if (p == initproc) {
|
1994-10-27 05:21:39 +00:00
|
|
|
printf("init died (signal %d, exit %d)\n",
|
1994-05-24 10:09:53 +00:00
|
|
|
WTERMSIG(rv), WEXITSTATUS(rv));
|
1994-10-27 05:21:39 +00:00
|
|
|
panic("Going nowhere without my init!");
|
|
|
|
}
|
1997-06-16 00:29:36 +00:00
|
|
|
|
2002-05-06 15:46:29 +00:00
|
|
|
/*
|
2003-04-01 01:26:20 +00:00
|
|
|
* MUST abort all other threads before proceeding past here.
|
2002-05-06 15:46:29 +00:00
|
|
|
*/
|
Part 1 of KSE-III
The ability to schedule multiple threads per process
(one one cpu) by making ALL system calls optionally asynchronous.
to come: ia64 and power-pc patches, patches for gdb, test program (in tools)
Reviewed by: Almost everyone who counts
(at various times, peter, jhb, matt, alfred, mini, bernd,
and a cast of thousands)
NOTE: this is still Beta code, and contains lots of debugging stuff.
expect slight instability in signals..
2002-06-29 17:26:22 +00:00
|
|
|
PROC_LOCK(p);
|
2004-09-05 02:09:54 +00:00
|
|
|
if (p->p_flag & P_HADTHREADS) {
|
2004-06-18 06:21:09 +00:00
|
|
|
retry:
|
Part 1 of KSE-III
The ability to schedule multiple threads per process
(one one cpu) by making ALL system calls optionally asynchronous.
to come: ia64 and power-pc patches, patches for gdb, test program (in tools)
Reviewed by: Almost everyone who counts
(at various times, peter, jhb, matt, alfred, mini, bernd,
and a cast of thousands)
NOTE: this is still Beta code, and contains lots of debugging stuff.
expect slight instability in signals..
2002-06-29 17:26:22 +00:00
|
|
|
/*
|
|
|
|
* First check if some other thread got here before us..
|
|
|
|
* if so, act apropriatly, (exit or suspend);
|
|
|
|
*/
|
|
|
|
thread_suspend_check(0);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Kill off the other threads. This requires
|
2004-09-24 00:38:15 +00:00
|
|
|
* some co-operation from other parts of the kernel
|
|
|
|
* so it may not be instantaneous. With this state set
|
|
|
|
* any thread entering the kernel from userspace will
|
Part 1 of KSE-III
The ability to schedule multiple threads per process
(one one cpu) by making ALL system calls optionally asynchronous.
to come: ia64 and power-pc patches, patches for gdb, test program (in tools)
Reviewed by: Almost everyone who counts
(at various times, peter, jhb, matt, alfred, mini, bernd,
and a cast of thousands)
NOTE: this is still Beta code, and contains lots of debugging stuff.
expect slight instability in signals..
2002-06-29 17:26:22 +00:00
|
|
|
* thread_exit() in trap(). Any thread attempting to
|
2004-09-24 00:38:15 +00:00
|
|
|
* sleep will return immediately with EINTR or EWOULDBLOCK
|
|
|
|
* which will hopefully force them to back out to userland
|
|
|
|
* freeing resources as they go. Any thread attempting
|
2004-05-09 22:29:14 +00:00
|
|
|
* to return to userland will thread_exit() from userret().
|
2004-09-24 00:38:15 +00:00
|
|
|
* thread_exit() will unsuspend us when the last of the
|
|
|
|
* other threads exits.
|
2004-06-18 11:13:49 +00:00
|
|
|
* If there is already a thread singler after resumption,
|
2004-09-24 00:38:15 +00:00
|
|
|
* calling thread_single will fail; in that case, we just
|
2004-06-18 11:13:49 +00:00
|
|
|
* re-check all suspension request, the thread should
|
|
|
|
* either be suspended there or exit.
|
Part 1 of KSE-III
The ability to schedule multiple threads per process
(one one cpu) by making ALL system calls optionally asynchronous.
to come: ia64 and power-pc patches, patches for gdb, test program (in tools)
Reviewed by: Almost everyone who counts
(at various times, peter, jhb, matt, alfred, mini, bernd,
and a cast of thousands)
NOTE: this is still Beta code, and contains lots of debugging stuff.
expect slight instability in signals..
2002-06-29 17:26:22 +00:00
|
|
|
*/
|
2004-03-13 22:31:39 +00:00
|
|
|
if (thread_single(SINGLE_EXIT))
|
2004-06-18 06:21:09 +00:00
|
|
|
goto retry;
|
2004-09-24 00:38:15 +00:00
|
|
|
|
Part 1 of KSE-III
The ability to schedule multiple threads per process
(one one cpu) by making ALL system calls optionally asynchronous.
to come: ia64 and power-pc patches, patches for gdb, test program (in tools)
Reviewed by: Almost everyone who counts
(at various times, peter, jhb, matt, alfred, mini, bernd,
and a cast of thousands)
NOTE: this is still Beta code, and contains lots of debugging stuff.
expect slight instability in signals..
2002-06-29 17:26:22 +00:00
|
|
|
/*
|
|
|
|
* All other activity in this process is now stopped.
|
2004-09-05 02:09:54 +00:00
|
|
|
* Threading support has been turned off.
|
Part 1 of KSE-III
The ability to schedule multiple threads per process
(one one cpu) by making ALL system calls optionally asynchronous.
to come: ia64 and power-pc patches, patches for gdb, test program (in tools)
Reviewed by: Almost everyone who counts
(at various times, peter, jhb, matt, alfred, mini, bernd,
and a cast of thousands)
NOTE: this is still Beta code, and contains lots of debugging stuff.
expect slight instability in signals..
2002-06-29 17:26:22 +00:00
|
|
|
*/
|
|
|
|
}
|
|
|
|
|
|
|
|
p->p_flag |= P_WEXIT;
|
|
|
|
PROC_UNLOCK(p);
|
2001-09-12 08:38:13 +00:00
|
|
|
|
2002-05-06 15:46:29 +00:00
|
|
|
/* Are we a task leader? */
|
2002-05-04 07:40:49 +00:00
|
|
|
if (p == p->p_leader) {
|
2002-10-15 00:14:32 +00:00
|
|
|
mtx_lock(&ppeers_lock);
|
1997-06-16 00:29:36 +00:00
|
|
|
q = p->p_peers;
|
2001-06-27 06:15:44 +00:00
|
|
|
while (q != NULL) {
|
|
|
|
PROC_LOCK(q);
|
|
|
|
psignal(q, SIGKILL);
|
|
|
|
PROC_UNLOCK(q);
|
1997-06-16 00:29:36 +00:00
|
|
|
q = q->p_peers;
|
|
|
|
}
|
2003-03-19 00:33:38 +00:00
|
|
|
while (p->p_peers != NULL)
|
2002-10-15 00:14:32 +00:00
|
|
|
msleep(p, &ppeers_lock, PWAIT, "exit1", 0);
|
|
|
|
mtx_unlock(&ppeers_lock);
|
2001-01-24 00:33:44 +00:00
|
|
|
}
|
1997-06-16 00:29:36 +00:00
|
|
|
|
2004-03-05 22:39:53 +00:00
|
|
|
PROC_LOCK(p);
|
|
|
|
_STOPEVENT(p, S_EXIT, rv);
|
2000-01-10 04:09:05 +00:00
|
|
|
wakeup(&p->p_stype); /* Wakeup anyone in procfs' PIOCWAIT */
|
2004-03-05 22:39:53 +00:00
|
|
|
PROC_UNLOCK(p);
|
1997-12-06 04:11:14 +00:00
|
|
|
|
2003-03-19 00:33:38 +00:00
|
|
|
/*
|
1999-04-17 08:36:07 +00:00
|
|
|
* Check if any loadable modules need anything done at process exit.
|
2004-09-24 00:38:15 +00:00
|
|
|
* E.g. SYSV IPC stuff
|
1996-08-19 02:28:24 +00:00
|
|
|
* XXX what if one of these generates an error?
|
|
|
|
*/
|
2003-03-24 21:15:35 +00:00
|
|
|
EVENTHANDLER_INVOKE(process_exit, p);
|
2001-01-24 00:33:44 +00:00
|
|
|
|
1994-05-24 10:09:53 +00:00
|
|
|
MALLOC(p->p_ru, struct rusage *, sizeof(struct rusage),
|
2003-02-19 05:47:46 +00:00
|
|
|
M_ZOMBIE, M_WAITOK);
|
1994-05-24 10:09:53 +00:00
|
|
|
/*
|
|
|
|
* If parent is waiting for us to exit or exec,
|
|
|
|
* P_PPWAIT is set; we will wakeup the parent below.
|
|
|
|
*/
|
2001-01-24 00:33:44 +00:00
|
|
|
PROC_LOCK(p);
|
2003-02-08 02:58:16 +00:00
|
|
|
stopprofclock(p);
|
1994-05-24 10:09:53 +00:00
|
|
|
p->p_flag &= ~(P_TRACED | P_PPWAIT);
|
2002-10-01 17:15:53 +00:00
|
|
|
SIGEMPTYSET(p->p_siglist);
|
2003-03-31 22:49:17 +00:00
|
|
|
SIGEMPTYSET(td->td_siglist);
|
2003-06-09 21:46:22 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Stop the real interval timer. If the handler is currently
|
|
|
|
* executing, prevent it from rearming itself and let it finish.
|
|
|
|
*/
|
|
|
|
if (timevalisset(&p->p_realtimer.it_value) &&
|
|
|
|
callout_stop(&p->p_itcallout) == 0) {
|
|
|
|
timevalclear(&p->p_realtimer.it_interval);
|
|
|
|
msleep(&p->p_itcallout, &p->p_mtx, PWAIT, "ritwait", 0);
|
|
|
|
KASSERT(!timevalisset(&p->p_realtimer.it_value),
|
|
|
|
("realtime timer is still armed"));
|
|
|
|
}
|
2003-02-17 10:03:02 +00:00
|
|
|
PROC_UNLOCK(p);
|
1994-05-24 10:09:53 +00:00
|
|
|
|
Installed the second patch attached to kern/7899 with some changes suggested
by bde, a few other tweaks to get the patch to apply cleanly again and
some improvements to the comments.
This change closes some fairly minor security holes associated with
F_SETOWN, fixes a few bugs, and removes some limitations that F_SETOWN
had on tty devices. For more details, see the description on the PR.
Because this patch increases the size of the proc and pgrp structures,
it is necessary to re-install the includes and recompile libkvm,
the vinum lkm, fstat, gcore, gdb, ipfilter, ps, top, and w.
PR: kern/7899
Reviewed by: bde, elvind
1998-11-11 10:04:13 +00:00
|
|
|
/*
|
|
|
|
* Reset any sigio structures pointing to us as a result of
|
|
|
|
* F_SETOWN with our pid.
|
|
|
|
*/
|
2004-03-05 22:39:53 +00:00
|
|
|
mtx_lock(&Giant); /* XXX: not sure if needed */
|
Installed the second patch attached to kern/7899 with some changes suggested
by bde, a few other tweaks to get the patch to apply cleanly again and
some improvements to the comments.
This change closes some fairly minor security holes associated with
F_SETOWN, fixes a few bugs, and removes some limitations that F_SETOWN
had on tty devices. For more details, see the description on the PR.
Because this patch increases the size of the proc and pgrp structures,
it is necessary to re-install the includes and recompile libkvm,
the vinum lkm, fstat, gcore, gdb, ipfilter, ps, top, and w.
PR: kern/7899
Reviewed by: bde, elvind
1998-11-11 10:04:13 +00:00
|
|
|
funsetownlst(&p->p_sigiolst);
|
|
|
|
|
1994-05-24 10:09:53 +00:00
|
|
|
/*
|
|
|
|
* Close open files and release open-file table.
|
|
|
|
* This may block!
|
|
|
|
*/
|
2003-02-15 05:52:56 +00:00
|
|
|
fdfree(td);
|
2004-03-05 22:39:53 +00:00
|
|
|
mtx_unlock(&Giant);
|
1994-05-24 10:09:53 +00:00
|
|
|
|
2001-01-24 00:33:44 +00:00
|
|
|
/*
|
|
|
|
* Remove ourself from our leader's peer list and wake our leader.
|
|
|
|
*/
|
2002-10-15 00:14:32 +00:00
|
|
|
mtx_lock(&ppeers_lock);
|
2002-05-04 07:40:49 +00:00
|
|
|
if (p->p_leader->p_peers) {
|
1999-06-07 20:37:29 +00:00
|
|
|
q = p->p_leader;
|
2002-05-04 07:40:49 +00:00
|
|
|
while (q->p_peers != p)
|
1999-06-07 20:37:29 +00:00
|
|
|
q = q->p_peers;
|
|
|
|
q->p_peers = p->p_peers;
|
2002-06-29 01:50:25 +00:00
|
|
|
wakeup(p->p_leader);
|
1999-06-07 20:37:29 +00:00
|
|
|
}
|
2002-10-15 00:14:32 +00:00
|
|
|
mtx_unlock(&ppeers_lock);
|
1999-06-07 20:37:29 +00:00
|
|
|
|
1994-05-24 10:09:53 +00:00
|
|
|
/* The next two chunks should probably be moved to vmspace_exit. */
|
|
|
|
vm = p->p_vmspace;
|
|
|
|
/*
|
|
|
|
* Release user portion of address space.
|
|
|
|
* This releases references to vnodes,
|
|
|
|
* which could cause I/O if the file has been unlinked.
|
|
|
|
* Need to do this early enough that we can still sleep.
|
|
|
|
* Can't free the entire vmspace as the kernel stack
|
|
|
|
* may be mapped within that space also.
|
2002-12-15 18:50:04 +00:00
|
|
|
*
|
|
|
|
* Processes sharing the same vmspace may exit in one order, and
|
|
|
|
* get cleaned up by vmspace_exit() in a different order. The
|
|
|
|
* last exiting process to reach this point releases as much of
|
|
|
|
* the environment as it can, and the last process cleaned up
|
|
|
|
* by vmspace_exit() (which decrements exitingcnt) cleans up the
|
|
|
|
* remainder.
|
1994-05-24 10:09:53 +00:00
|
|
|
*/
|
2004-07-27 03:53:41 +00:00
|
|
|
atomic_add_int(&vm->vm_exitingcnt, 1);
|
|
|
|
do
|
|
|
|
refcnt = vm->vm_refcnt;
|
|
|
|
while (!atomic_cmpset_int(&vm->vm_refcnt, refcnt, refcnt - 1));
|
|
|
|
if (refcnt == 1) {
|
2003-01-13 23:04:32 +00:00
|
|
|
shmexit(vm);
|
2002-09-21 22:07:17 +00:00
|
|
|
pmap_remove_pages(vmspace_pmap(vm), vm_map_min(&vm->vm_map),
|
|
|
|
vm_map_max(&vm->vm_map));
|
|
|
|
(void) vm_map_remove(&vm->vm_map, vm_map_min(&vm->vm_map),
|
|
|
|
vm_map_max(&vm->vm_map));
|
1996-10-12 21:35:25 +00:00
|
|
|
}
|
1994-05-24 10:09:53 +00:00
|
|
|
|
2004-07-27 03:53:41 +00:00
|
|
|
mtx_lock(&Giant);
|
2002-04-16 17:04:21 +00:00
|
|
|
sx_xlock(&proctree_lock);
|
1994-05-24 10:09:53 +00:00
|
|
|
if (SESS_LEADER(p)) {
|
2003-03-19 00:49:40 +00:00
|
|
|
struct session *sp;
|
1994-05-24 10:09:53 +00:00
|
|
|
|
2002-02-23 11:12:57 +00:00
|
|
|
sp = p->p_session;
|
1994-05-24 10:09:53 +00:00
|
|
|
if (sp->s_ttyvp) {
|
|
|
|
/*
|
|
|
|
* Controlling process.
|
|
|
|
* Signal foreground pgrp,
|
|
|
|
* drain controlling terminal
|
|
|
|
* and revoke access to controlling terminal.
|
|
|
|
*/
|
1996-10-04 23:43:12 +00:00
|
|
|
if (sp->s_ttyp && (sp->s_ttyp->t_session == sp)) {
|
2002-02-23 11:12:57 +00:00
|
|
|
tp = sp->s_ttyp;
|
|
|
|
if (sp->s_ttyp->t_pgrp) {
|
|
|
|
PGRP_LOCK(sp->s_ttyp->t_pgrp);
|
1994-05-24 10:09:53 +00:00
|
|
|
pgsignal(sp->s_ttyp->t_pgrp, SIGHUP, 1);
|
2002-02-23 11:12:57 +00:00
|
|
|
PGRP_UNLOCK(sp->s_ttyp->t_pgrp);
|
|
|
|
}
|
|
|
|
/* XXX tp should be locked. */
|
2002-04-16 17:04:21 +00:00
|
|
|
sx_xunlock(&proctree_lock);
|
2002-02-23 11:12:57 +00:00
|
|
|
(void) ttywait(tp);
|
2002-04-16 17:04:21 +00:00
|
|
|
sx_xlock(&proctree_lock);
|
1994-05-24 10:09:53 +00:00
|
|
|
/*
|
|
|
|
* The tty could have been revoked
|
|
|
|
* if we blocked.
|
|
|
|
*/
|
2002-02-23 11:12:57 +00:00
|
|
|
if (sp->s_ttyvp) {
|
|
|
|
ttyvp = sp->s_ttyvp;
|
|
|
|
SESS_LOCK(p->p_session);
|
|
|
|
sp->s_ttyvp = NULL;
|
|
|
|
SESS_UNLOCK(p->p_session);
|
2002-04-16 17:04:21 +00:00
|
|
|
sx_xunlock(&proctree_lock);
|
2002-02-23 11:12:57 +00:00
|
|
|
VOP_REVOKE(ttyvp, REVOKEALL);
|
|
|
|
vrele(ttyvp);
|
2002-04-16 17:04:21 +00:00
|
|
|
sx_xlock(&proctree_lock);
|
2002-02-23 11:12:57 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
if (sp->s_ttyvp) {
|
|
|
|
ttyvp = sp->s_ttyvp;
|
|
|
|
SESS_LOCK(p->p_session);
|
|
|
|
sp->s_ttyvp = NULL;
|
|
|
|
SESS_UNLOCK(p->p_session);
|
|
|
|
vrele(ttyvp);
|
1994-05-24 10:09:53 +00:00
|
|
|
}
|
|
|
|
/*
|
|
|
|
* s_ttyp is not zero'd; we use this to indicate
|
|
|
|
* that the session once had a controlling terminal.
|
|
|
|
* (for logging and informational purposes)
|
|
|
|
*/
|
|
|
|
}
|
2002-02-23 11:12:57 +00:00
|
|
|
SESS_LOCK(p->p_session);
|
1994-05-24 10:09:53 +00:00
|
|
|
sp->s_leader = NULL;
|
2002-02-23 11:12:57 +00:00
|
|
|
SESS_UNLOCK(p->p_session);
|
|
|
|
}
|
1994-05-24 10:09:53 +00:00
|
|
|
fixjobc(p, p->p_pgrp, 0);
|
2002-04-16 17:04:21 +00:00
|
|
|
sx_xunlock(&proctree_lock);
|
2001-09-12 08:38:13 +00:00
|
|
|
(void)acct_process(td);
|
2004-03-05 22:39:53 +00:00
|
|
|
mtx_unlock(&Giant);
|
1994-05-24 10:09:53 +00:00
|
|
|
#ifdef KTRACE
|
1995-05-30 08:16:23 +00:00
|
|
|
/*
|
1994-05-24 10:09:53 +00:00
|
|
|
* release trace file
|
|
|
|
*/
|
2002-05-02 15:09:58 +00:00
|
|
|
PROC_LOCK(p);
|
2002-06-07 05:41:27 +00:00
|
|
|
mtx_lock(&ktrace_mtx);
|
1994-05-24 10:09:53 +00:00
|
|
|
p->p_traceflag = 0; /* don't trace the vrele() */
|
2003-03-13 18:24:22 +00:00
|
|
|
tracevp = p->p_tracevp;
|
|
|
|
p->p_tracevp = NULL;
|
|
|
|
tracecred = p->p_tracecred;
|
|
|
|
p->p_tracecred = NULL;
|
2002-06-07 05:41:27 +00:00
|
|
|
mtx_unlock(&ktrace_mtx);
|
2002-05-02 15:09:58 +00:00
|
|
|
PROC_UNLOCK(p);
|
2004-03-18 18:15:58 +00:00
|
|
|
if (tracevp != NULL) {
|
|
|
|
mtx_lock(&Giant);
|
2002-05-02 15:09:58 +00:00
|
|
|
vrele(tracevp);
|
2004-03-18 18:15:58 +00:00
|
|
|
mtx_unlock(&Giant);
|
|
|
|
}
|
2003-03-13 18:24:22 +00:00
|
|
|
if (tracecred != NULL)
|
|
|
|
crfree(tracecred);
|
1994-05-24 10:09:53 +00:00
|
|
|
#endif
|
2002-01-05 21:47:58 +00:00
|
|
|
/*
|
|
|
|
* Release reference to text vnode
|
|
|
|
*/
|
|
|
|
if ((vtmp = p->p_textvp) != NULL) {
|
|
|
|
p->p_textvp = NULL;
|
2004-03-05 22:39:53 +00:00
|
|
|
mtx_lock(&Giant);
|
2002-01-05 21:47:58 +00:00
|
|
|
vrele(vtmp);
|
2004-03-05 22:39:53 +00:00
|
|
|
mtx_unlock(&Giant);
|
2002-01-05 21:47:58 +00:00
|
|
|
}
|
|
|
|
|
2002-05-02 15:09:58 +00:00
|
|
|
/*
|
|
|
|
* Release our limits structure.
|
|
|
|
*/
|
2004-02-04 21:52:57 +00:00
|
|
|
PROC_LOCK(p);
|
|
|
|
plim = p->p_limit;
|
|
|
|
p->p_limit = NULL;
|
|
|
|
PROC_UNLOCK(p);
|
|
|
|
lim_free(plim);
|
2002-05-02 15:09:58 +00:00
|
|
|
|
1994-05-24 10:09:53 +00:00
|
|
|
/*
|
|
|
|
* Remove proc from allproc queue and pidhash chain.
|
|
|
|
* Place onto zombproc. Unlink from parent's child list.
|
|
|
|
*/
|
2001-03-28 11:52:56 +00:00
|
|
|
sx_xlock(&allproc_lock);
|
1996-03-11 06:05:03 +00:00
|
|
|
LIST_REMOVE(p, p_list);
|
|
|
|
LIST_INSERT_HEAD(&zombproc, p, p_list);
|
|
|
|
LIST_REMOVE(p, p_hash);
|
2001-03-28 11:52:56 +00:00
|
|
|
sx_xunlock(&allproc_lock);
|
1994-05-24 10:09:53 +00:00
|
|
|
|
2001-03-28 11:52:56 +00:00
|
|
|
sx_xlock(&proctree_lock);
|
1999-11-16 10:56:05 +00:00
|
|
|
q = LIST_FIRST(&p->p_children);
|
2001-01-24 00:33:44 +00:00
|
|
|
if (q != NULL) /* only need this if any child is S_ZOMB */
|
2002-06-29 01:50:25 +00:00
|
|
|
wakeup(initproc);
|
2001-01-24 00:33:44 +00:00
|
|
|
for (; q != NULL; q = nq) {
|
1999-11-16 10:56:05 +00:00
|
|
|
nq = LIST_NEXT(q, p_sibling);
|
2001-01-24 00:33:44 +00:00
|
|
|
PROC_LOCK(q);
|
2001-03-07 02:22:31 +00:00
|
|
|
proc_reparent(q, initproc);
|
1999-03-02 00:28:09 +00:00
|
|
|
q->p_sigparent = SIGCHLD;
|
1994-05-24 10:09:53 +00:00
|
|
|
/*
|
|
|
|
* Traced processes are killed
|
|
|
|
* since their existence means someone is screwing up.
|
|
|
|
*/
|
|
|
|
if (q->p_flag & P_TRACED) {
|
2004-10-23 11:20:26 +00:00
|
|
|
q->p_flag &= ~(P_TRACED | P_STOPPED_TRACE);
|
1994-05-24 10:09:53 +00:00
|
|
|
psignal(q, SIGKILL);
|
2001-03-07 02:22:31 +00:00
|
|
|
}
|
2002-02-23 11:12:57 +00:00
|
|
|
PROC_UNLOCK(q);
|
1994-05-24 10:09:53 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
2004-10-05 18:51:11 +00:00
|
|
|
* Save exit status and finalize rusage info except for times,
|
|
|
|
* adding in child rusage info.
|
1994-05-24 10:09:53 +00:00
|
|
|
*/
|
2002-05-02 15:09:58 +00:00
|
|
|
PROC_LOCK(p);
|
1994-05-24 10:09:53 +00:00
|
|
|
p->p_xstat = rv;
|
Add code to support debugging threaded process.
1. Add tm_lwpid into kse_thr_mailbox to indicate which kernel
thread current user thread is running on. Add tm_dflags into
kse_thr_mailbox, the flags is written by debugger, it tells
UTS and kernel what should be done when the process is being
debugged, current, there two flags TMDF_SSTEP and TMDF_DONOTRUNUSER.
TMDF_SSTEP is used to tell kernel to turn on single stepping,
or turn off if it is not set.
TMDF_DONOTRUNUSER is used to tell kernel to schedule upcall
whenever possible, to UTS, it means do not run the user thread
until debugger clears it, this behaviour is necessary because
gdb wants to resume only one thread when the thread's pc is
at a breakpoint, and thread needs to go forward, in order to
avoid other threads sneak pass the breakpoints, it needs to remove
breakpoint, only wants one thread to go. Also, add km_lwp to
kse_mailbox, the lwp id is copied to kse_thr_mailbox at context
switch time when process is not being debugged, so when process
is attached, debugger can map kernel thread to user thread.
2. Add p_xthread to proc strcuture and td_xsig to thread structure.
p_xthread is used by a thread when it wants to report event
to debugger, every thread can set the pointer, especially, when
it is used in ptracestop, it is the last thread reporting event
will win the race. Every thread has a td_xsig to exchange signal
with debugger, thread uses TDF_XSIG flag to indicate it is reporting
signal to debugger, if the flag is not cleared, thread will keep
retrying until it is cleared by debugger, p_xthread may be
used by debugger to indicate CURRENT thread. The p_xstat is still
in proc structure to keep wait() to work, in future, we may
just use td_xsig.
3. Add TDF_DBSUSPEND flag, the flag is used by debugger to suspend
a thread. When process stops, debugger can set the flag for
thread, thread will check the flag in thread_suspend_check,
enters a loop, unless it is cleared by debugger, process is
detached or process is existing. The flag is also checked in
ptracestop, so debugger can temporarily suspend a thread even
if the thread wants to exchange signal.
4. Current, in ptrace, we always resume all threads, but if a thread
has already a TDF_DBSUSPEND flag set by debugger, it won't run.
Encouraged by: marcel, julian, deischen
2004-07-13 07:20:10 +00:00
|
|
|
p->p_xthread = td;
|
2004-10-05 18:51:11 +00:00
|
|
|
p->p_stats->p_ru.ru_nvcsw++;
|
1994-05-24 10:09:53 +00:00
|
|
|
*p->p_ru = p->p_stats->p_ru;
|
2004-10-05 18:51:11 +00:00
|
|
|
ruadd(p->p_ru, &p->p_rux, &p->p_stats->p_cru, &p->p_crux);
|
1994-05-24 10:09:53 +00:00
|
|
|
|
2000-04-16 18:53:38 +00:00
|
|
|
/*
|
2002-05-06 15:46:29 +00:00
|
|
|
* Notify interested parties of our demise.
|
2000-04-16 18:53:38 +00:00
|
|
|
*/
|
2004-08-15 06:24:42 +00:00
|
|
|
KNOTE_LOCKED(&p->p_klist, NOTE_EXIT);
|
2004-09-22 15:24:33 +00:00
|
|
|
|
2003-11-14 18:49:01 +00:00
|
|
|
/*
|
|
|
|
* Just delete all entries in the p_klist. At this point we won't
|
|
|
|
* report any more events, and there are nasty race conditions that
|
|
|
|
* can beat us if we don't.
|
|
|
|
*/
|
2004-08-15 06:24:42 +00:00
|
|
|
knlist_clear(&p->p_klist, 1);
|
2000-04-16 18:53:38 +00:00
|
|
|
|
1994-05-24 10:09:53 +00:00
|
|
|
/*
|
1999-10-11 20:33:17 +00:00
|
|
|
* Notify parent that we're gone. If parent has the PS_NOCLDWAIT
|
2002-04-27 22:41:41 +00:00
|
|
|
* flag set, or if the handler is set to SIG_IGN, notify process
|
|
|
|
* 1 instead (and hope it will handle this situation).
|
1994-05-24 10:09:53 +00:00
|
|
|
*/
|
2002-05-02 15:09:58 +00:00
|
|
|
PROC_LOCK(p->p_pptr);
|
- Merge struct procsig with struct sigacts.
- Move struct sigacts out of the u-area and malloc() it using the
M_SUBPROC malloc bucket.
- Add a small sigacts_*() API for managing sigacts structures: sigacts_alloc(),
sigacts_free(), sigacts_copy(), sigacts_share(), and sigacts_shared().
- Remove the p_sigignore, p_sigacts, and p_sigcatch macros.
- Add a mutex to struct sigacts that protects all the members of the struct.
- Add sigacts locking.
- Remove Giant from nosys(), kill(), killpg(), and kern_sigaction() now
that sigacts is locked.
- Several in-kernel functions such as psignal(), tdsignal(), trapsignal(),
and thread_stopped() are now MP safe.
Reviewed by: arch@
Approved by: re (rwatson)
2003-05-13 20:36:02 +00:00
|
|
|
mtx_lock(&p->p_pptr->p_sigacts->ps_mtx);
|
|
|
|
if (p->p_pptr->p_sigacts->ps_flag & (PS_NOCLDWAIT | PS_CLDSIGIGN)) {
|
2002-05-06 17:04:29 +00:00
|
|
|
struct proc *pp;
|
|
|
|
|
- Merge struct procsig with struct sigacts.
- Move struct sigacts out of the u-area and malloc() it using the
M_SUBPROC malloc bucket.
- Add a small sigacts_*() API for managing sigacts structures: sigacts_alloc(),
sigacts_free(), sigacts_copy(), sigacts_share(), and sigacts_shared().
- Remove the p_sigignore, p_sigacts, and p_sigcatch macros.
- Add a mutex to struct sigacts that protects all the members of the struct.
- Add sigacts locking.
- Remove Giant from nosys(), kill(), killpg(), and kern_sigaction() now
that sigacts is locked.
- Several in-kernel functions such as psignal(), tdsignal(), trapsignal(),
and thread_stopped() are now MP safe.
Reviewed by: arch@
Approved by: re (rwatson)
2003-05-13 20:36:02 +00:00
|
|
|
mtx_unlock(&p->p_pptr->p_sigacts->ps_mtx);
|
2002-05-06 17:04:29 +00:00
|
|
|
pp = p->p_pptr;
|
2002-02-23 11:12:57 +00:00
|
|
|
PROC_UNLOCK(pp);
|
1997-09-13 19:42:29 +00:00
|
|
|
proc_reparent(p, initproc);
|
2004-02-11 22:06:02 +00:00
|
|
|
p->p_sigparent = SIGCHLD;
|
2002-02-23 11:12:57 +00:00
|
|
|
PROC_LOCK(p->p_pptr);
|
1997-09-13 19:42:29 +00:00
|
|
|
/*
|
|
|
|
* If this was the last child of our parent, notify
|
|
|
|
* parent, so in case he was wait(2)ing, he will
|
|
|
|
* continue.
|
|
|
|
*/
|
|
|
|
if (LIST_EMPTY(&pp->p_children))
|
2002-06-29 01:50:25 +00:00
|
|
|
wakeup(pp);
|
- Merge struct procsig with struct sigacts.
- Move struct sigacts out of the u-area and malloc() it using the
M_SUBPROC malloc bucket.
- Add a small sigacts_*() API for managing sigacts structures: sigacts_alloc(),
sigacts_free(), sigacts_copy(), sigacts_share(), and sigacts_shared().
- Remove the p_sigignore, p_sigacts, and p_sigcatch macros.
- Add a mutex to struct sigacts that protects all the members of the struct.
- Add sigacts locking.
- Remove Giant from nosys(), kill(), killpg(), and kern_sigaction() now
that sigacts is locked.
- Several in-kernel functions such as psignal(), tdsignal(), trapsignal(),
and thread_stopped() are now MP safe.
Reviewed by: arch@
Approved by: re (rwatson)
2003-05-13 20:36:02 +00:00
|
|
|
} else
|
|
|
|
mtx_unlock(&p->p_pptr->p_sigacts->ps_mtx);
|
1997-09-13 19:42:29 +00:00
|
|
|
|
2004-02-19 06:43:48 +00:00
|
|
|
if (p->p_pptr == initproc)
|
2002-10-02 23:12:01 +00:00
|
|
|
psignal(p->p_pptr, SIGCHLD);
|
2004-02-19 06:43:48 +00:00
|
|
|
else if (p->p_sigparent != 0)
|
|
|
|
psignal(p->p_pptr, p->p_sigparent);
|
2001-03-07 02:22:31 +00:00
|
|
|
PROC_UNLOCK(p->p_pptr);
|
2001-06-27 06:15:44 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* If this is a kthread, then wakeup anyone waiting for it to exit.
|
|
|
|
*/
|
|
|
|
if (p->p_flag & P_KTHREAD)
|
2002-06-29 01:50:25 +00:00
|
|
|
wakeup(p);
|
2001-03-07 02:22:31 +00:00
|
|
|
PROC_UNLOCK(p);
|
2003-03-19 00:33:38 +00:00
|
|
|
|
1994-05-24 10:09:53 +00:00
|
|
|
/*
|
|
|
|
* Finally, call machine-dependent code to release the remaining
|
2002-12-10 02:33:45 +00:00
|
|
|
* resources including address space.
|
2002-02-05 21:23:05 +00:00
|
|
|
* The address space is released by "vmspace_exitfree(p)" in
|
|
|
|
* vm_waitproc().
|
1994-05-24 10:09:53 +00:00
|
|
|
*/
|
2001-09-12 08:38:13 +00:00
|
|
|
cpu_exit(td);
|
2001-09-10 04:28:58 +00:00
|
|
|
|
|
|
|
PROC_LOCK(p);
|
2002-05-02 15:09:58 +00:00
|
|
|
PROC_LOCK(p->p_pptr);
|
|
|
|
sx_xunlock(&proctree_lock);
|
2002-12-10 02:33:45 +00:00
|
|
|
|
2001-09-10 04:28:58 +00:00
|
|
|
/*
|
2003-04-17 22:22:47 +00:00
|
|
|
* We have to wait until after acquiring all locks before
|
2004-09-24 20:27:04 +00:00
|
|
|
* changing p_state. We need to avoid all possible context
|
|
|
|
* switches (including ones from blocking on a mutex) while
|
|
|
|
* marked as a zombie.
|
2001-09-10 04:28:58 +00:00
|
|
|
*/
|
2004-02-27 18:39:09 +00:00
|
|
|
mtx_lock_spin(&sched_lock);
|
Part 1 of KSE-III
The ability to schedule multiple threads per process
(one one cpu) by making ALL system calls optionally asynchronous.
to come: ia64 and power-pc patches, patches for gdb, test program (in tools)
Reviewed by: Almost everyone who counts
(at various times, peter, jhb, matt, alfred, mini, bernd,
and a cast of thousands)
NOTE: this is still Beta code, and contains lots of debugging stuff.
expect slight instability in signals..
2002-06-29 17:26:22 +00:00
|
|
|
p->p_state = PRS_ZOMBIE;
|
2004-09-24 20:27:04 +00:00
|
|
|
|
2004-02-27 18:39:09 +00:00
|
|
|
critical_enter();
|
|
|
|
mtx_unlock_spin(&sched_lock);
|
2001-09-10 04:28:58 +00:00
|
|
|
wakeup(p->p_pptr);
|
2002-05-02 15:09:58 +00:00
|
|
|
PROC_UNLOCK(p->p_pptr);
|
2004-02-27 18:39:09 +00:00
|
|
|
mtx_lock_spin(&sched_lock);
|
|
|
|
critical_exit();
|
2004-06-21 14:03:38 +00:00
|
|
|
|
|
|
|
/* Do the same timestamp bookkeeping that mi_switch() would do. */
|
|
|
|
binuptime(&new_switchtime);
|
2004-10-05 18:51:11 +00:00
|
|
|
bintime_add(&p->p_rux.rux_runtime, &new_switchtime);
|
|
|
|
bintime_sub(&p->p_rux.rux_runtime, PCPU_PTR(switchtime));
|
2004-06-21 14:03:38 +00:00
|
|
|
PCPU_SET(switchtime, new_switchtime);
|
2002-05-02 15:09:58 +00:00
|
|
|
PCPU_SET(switchticks, ticks);
|
2004-06-21 14:03:38 +00:00
|
|
|
cnt.v_swtch++;
|
2004-09-24 20:27:04 +00:00
|
|
|
|
2004-07-18 23:36:13 +00:00
|
|
|
sched_exit(p->p_pptr, td);
|
2003-04-11 03:39:07 +00:00
|
|
|
|
2004-08-15 06:24:42 +00:00
|
|
|
/*
|
2004-09-22 15:24:33 +00:00
|
|
|
* Hopefully no one will try to deliver a signal to the process this
|
2004-08-15 06:24:42 +00:00
|
|
|
* late in the game.
|
|
|
|
*/
|
|
|
|
knlist_destroy(&p->p_klist);
|
|
|
|
|
Part 1 of KSE-III
The ability to schedule multiple threads per process
(one one cpu) by making ALL system calls optionally asynchronous.
to come: ia64 and power-pc patches, patches for gdb, test program (in tools)
Reviewed by: Almost everyone who counts
(at various times, peter, jhb, matt, alfred, mini, bernd,
and a cast of thousands)
NOTE: this is still Beta code, and contains lots of debugging stuff.
expect slight instability in signals..
2002-06-29 17:26:22 +00:00
|
|
|
/*
|
2002-12-10 02:33:45 +00:00
|
|
|
* Make sure the scheduler takes this thread out of its tables etc.
|
Part 1 of KSE-III
The ability to schedule multiple threads per process
(one one cpu) by making ALL system calls optionally asynchronous.
to come: ia64 and power-pc patches, patches for gdb, test program (in tools)
Reviewed by: Almost everyone who counts
(at various times, peter, jhb, matt, alfred, mini, bernd,
and a cast of thousands)
NOTE: this is still Beta code, and contains lots of debugging stuff.
expect slight instability in signals..
2002-06-29 17:26:22 +00:00
|
|
|
* This will also release this thread's reference to the ucred.
|
2003-03-19 00:33:38 +00:00
|
|
|
* Other thread parts to release include pcb bits and such.
|
Part 1 of KSE-III
The ability to schedule multiple threads per process
(one one cpu) by making ALL system calls optionally asynchronous.
to come: ia64 and power-pc patches, patches for gdb, test program (in tools)
Reviewed by: Almost everyone who counts
(at various times, peter, jhb, matt, alfred, mini, bernd,
and a cast of thousands)
NOTE: this is still Beta code, and contains lots of debugging stuff.
expect slight instability in signals..
2002-06-29 17:26:22 +00:00
|
|
|
*/
|
|
|
|
thread_exit();
|
1994-05-24 10:09:53 +00:00
|
|
|
}
|
|
|
|
|
1995-11-11 05:49:22 +00:00
|
|
|
#ifdef COMPAT_43
|
2001-09-01 04:37:34 +00:00
|
|
|
/*
|
2004-09-24 20:27:04 +00:00
|
|
|
* The dirty work is handled by kern_wait().
|
|
|
|
*
|
|
|
|
* MPSAFE.
|
2001-09-01 04:37:34 +00:00
|
|
|
*/
|
1994-05-25 09:21:21 +00:00
|
|
|
int
|
2003-03-19 00:49:40 +00:00
|
|
|
owait(struct thread *td, struct owait_args *uap __unused)
|
1994-05-24 10:09:53 +00:00
|
|
|
{
|
2004-03-17 20:00:00 +00:00
|
|
|
int error, status;
|
1994-05-24 10:09:53 +00:00
|
|
|
|
2004-03-17 20:00:00 +00:00
|
|
|
error = kern_wait(td, WAIT_ANY, &status, 0, NULL);
|
|
|
|
if (error == 0)
|
|
|
|
td->td_retval[1] = status;
|
|
|
|
return (error);
|
1994-05-24 10:09:53 +00:00
|
|
|
}
|
1995-11-11 05:49:22 +00:00
|
|
|
#endif /* COMPAT_43 */
|
1994-05-24 10:09:53 +00:00
|
|
|
|
2001-09-01 04:37:34 +00:00
|
|
|
/*
|
2004-09-24 20:27:04 +00:00
|
|
|
* The dirty work is handled by kern_wait().
|
|
|
|
*
|
|
|
|
* MPSAFE.
|
2001-09-01 04:37:34 +00:00
|
|
|
*/
|
1994-05-25 09:21:21 +00:00
|
|
|
int
|
2003-03-19 00:49:40 +00:00
|
|
|
wait4(struct thread *td, struct wait_args *uap)
|
1994-05-24 10:09:53 +00:00
|
|
|
{
|
2004-10-05 18:51:11 +00:00
|
|
|
struct rusage ru, *rup;
|
2004-03-17 20:00:00 +00:00
|
|
|
int error, status;
|
|
|
|
|
2004-10-05 18:51:11 +00:00
|
|
|
if (uap->rusage != NULL)
|
|
|
|
rup = &ru;
|
|
|
|
else
|
|
|
|
rup = NULL;
|
|
|
|
error = kern_wait(td, uap->pid, &status, uap->options, rup);
|
2004-03-17 20:00:00 +00:00
|
|
|
if (uap->status != NULL && error == 0)
|
|
|
|
error = copyout(&status, uap->status, sizeof(status));
|
|
|
|
if (uap->rusage != NULL && error == 0)
|
|
|
|
error = copyout(&ru, uap->rusage, sizeof(struct rusage));
|
|
|
|
return (error);
|
1994-05-24 10:09:53 +00:00
|
|
|
}
|
|
|
|
|
2004-03-17 20:00:00 +00:00
|
|
|
int
|
2004-09-22 15:24:33 +00:00
|
|
|
kern_wait(struct thread *td, pid_t pid, int *status, int options,
|
|
|
|
struct rusage *rusage)
|
1994-05-24 10:09:53 +00:00
|
|
|
{
|
2002-10-09 02:33:36 +00:00
|
|
|
struct proc *p, *q, *t;
|
2004-09-24 20:27:04 +00:00
|
|
|
int error, nfound;
|
1994-05-24 10:09:53 +00:00
|
|
|
|
2001-09-12 08:38:13 +00:00
|
|
|
q = td->td_proc;
|
2004-03-17 20:00:00 +00:00
|
|
|
if (pid == 0) {
|
2002-02-23 11:12:57 +00:00
|
|
|
PROC_LOCK(q);
|
2004-03-17 20:00:00 +00:00
|
|
|
pid = -q->p_pgid;
|
2002-02-23 11:12:57 +00:00
|
|
|
PROC_UNLOCK(q);
|
|
|
|
}
|
2004-03-17 20:00:00 +00:00
|
|
|
if (options &~ (WUNTRACED|WNOHANG|WCONTINUED|WLINUXCLONE))
|
2002-04-09 20:00:40 +00:00
|
|
|
return (EINVAL);
|
1994-05-24 10:09:53 +00:00
|
|
|
loop:
|
|
|
|
nfound = 0;
|
2002-05-02 15:09:58 +00:00
|
|
|
sx_xlock(&proctree_lock);
|
1999-11-16 10:56:05 +00:00
|
|
|
LIST_FOREACH(p, &q->p_children, p_sibling) {
|
2002-02-23 11:12:57 +00:00
|
|
|
PROC_LOCK(p);
|
2004-03-17 20:00:00 +00:00
|
|
|
if (pid != WAIT_ANY &&
|
|
|
|
p->p_pid != pid && p->p_pgid != -pid) {
|
2002-02-23 11:12:57 +00:00
|
|
|
PROC_UNLOCK(p);
|
1994-05-24 10:09:53 +00:00
|
|
|
continue;
|
2002-02-23 11:12:57 +00:00
|
|
|
}
|
1999-03-02 00:28:09 +00:00
|
|
|
|
2000-12-18 07:10:04 +00:00
|
|
|
/*
|
2003-03-19 00:33:38 +00:00
|
|
|
* This special case handles a kthread spawned by linux_clone
|
2000-12-18 07:10:04 +00:00
|
|
|
* (see linux_misc.c). The linux_wait4 and linux_waitpid
|
|
|
|
* functions need to be able to distinguish between waiting
|
|
|
|
* on a process and waiting on a thread. It is a thread if
|
|
|
|
* p_sigparent is not SIGCHLD, and the WLINUXCLONE option
|
|
|
|
* signifies we want to wait for threads and not processes.
|
1999-03-02 00:28:09 +00:00
|
|
|
*/
|
2000-12-18 07:10:04 +00:00
|
|
|
if ((p->p_sigparent != SIGCHLD) ^
|
2004-03-17 20:00:00 +00:00
|
|
|
((options & WLINUXCLONE) != 0)) {
|
2001-01-24 00:33:44 +00:00
|
|
|
PROC_UNLOCK(p);
|
1999-03-02 00:28:09 +00:00
|
|
|
continue;
|
2001-01-24 00:33:44 +00:00
|
|
|
}
|
1999-03-02 00:28:09 +00:00
|
|
|
|
1994-05-24 10:09:53 +00:00
|
|
|
nfound++;
|
Part 1 of KSE-III
The ability to schedule multiple threads per process
(one one cpu) by making ALL system calls optionally asynchronous.
to come: ia64 and power-pc patches, patches for gdb, test program (in tools)
Reviewed by: Almost everyone who counts
(at various times, peter, jhb, matt, alfred, mini, bernd,
and a cast of thousands)
NOTE: this is still Beta code, and contains lots of debugging stuff.
expect slight instability in signals..
2002-06-29 17:26:22 +00:00
|
|
|
if (p->p_state == PRS_ZOMBIE) {
|
2001-09-12 08:38:13 +00:00
|
|
|
td->td_retval[0] = p->p_pid;
|
2004-03-17 20:00:00 +00:00
|
|
|
if (status)
|
|
|
|
*status = p->p_xstat; /* convert to int */
|
2004-10-05 18:51:11 +00:00
|
|
|
if (rusage) {
|
2004-03-17 20:00:00 +00:00
|
|
|
bcopy(p->p_ru, rusage, sizeof(struct rusage));
|
2004-10-05 18:51:11 +00:00
|
|
|
calcru(p, &rusage->ru_utime, &rusage->ru_stime);
|
|
|
|
}
|
2004-03-17 20:00:00 +00:00
|
|
|
|
1994-05-24 10:09:53 +00:00
|
|
|
/*
|
|
|
|
* If we got the child via a ptrace 'attach',
|
|
|
|
* we need to give it back to the old parent.
|
|
|
|
*/
|
2004-03-17 20:00:00 +00:00
|
|
|
PROC_UNLOCK(p);
|
2002-05-02 15:09:58 +00:00
|
|
|
if (p->p_oppid && (t = pfind(p->p_oppid)) != NULL) {
|
|
|
|
PROC_LOCK(p);
|
|
|
|
p->p_oppid = 0;
|
|
|
|
proc_reparent(p, t);
|
|
|
|
PROC_UNLOCK(p);
|
|
|
|
psignal(t, SIGCHLD);
|
2002-06-29 01:50:25 +00:00
|
|
|
wakeup(t);
|
2002-05-02 15:09:58 +00:00
|
|
|
PROC_UNLOCK(t);
|
|
|
|
sx_xunlock(&proctree_lock);
|
|
|
|
return (0);
|
1994-05-24 10:09:53 +00:00
|
|
|
}
|
2002-05-02 15:09:58 +00:00
|
|
|
|
2003-03-12 11:10:04 +00:00
|
|
|
/*
|
|
|
|
* Remove other references to this process to ensure
|
|
|
|
* we have an exclusive reference.
|
|
|
|
*/
|
2003-03-13 00:57:47 +00:00
|
|
|
sx_xlock(&allproc_lock);
|
|
|
|
LIST_REMOVE(p, p_list); /* off zombproc */
|
|
|
|
sx_xunlock(&allproc_lock);
|
|
|
|
LIST_REMOVE(p, p_sibling);
|
2003-03-12 11:10:04 +00:00
|
|
|
leavepgrp(p);
|
2001-03-28 11:52:56 +00:00
|
|
|
sx_xunlock(&proctree_lock);
|
2002-05-02 15:09:58 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* As a side effect of this lock, we know that
|
|
|
|
* all other writes to this proc are visible now, so
|
|
|
|
* no more locking is needed for p.
|
|
|
|
*/
|
2001-03-07 02:22:31 +00:00
|
|
|
PROC_LOCK(p);
|
2002-05-02 15:09:58 +00:00
|
|
|
p->p_xstat = 0; /* XXX: why? */
|
2001-03-07 02:22:31 +00:00
|
|
|
PROC_UNLOCK(p);
|
2002-05-02 15:09:58 +00:00
|
|
|
PROC_LOCK(q);
|
2004-10-05 18:51:11 +00:00
|
|
|
ruadd(&q->p_stats->p_cru, &q->p_crux, p->p_ru,
|
|
|
|
&p->p_rux);
|
2002-05-02 15:09:58 +00:00
|
|
|
PROC_UNLOCK(q);
|
1994-05-24 10:09:53 +00:00
|
|
|
FREE(p->p_ru, M_ZOMBIE);
|
1994-12-28 06:15:08 +00:00
|
|
|
p->p_ru = NULL;
|
1994-05-24 10:09:53 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Decrement the count of procs running with this uid.
|
|
|
|
*/
|
o Merge contents of struct pcred into struct ucred. Specifically, add the
real uid, saved uid, real gid, and saved gid to ucred, as well as the
pcred->pc_uidinfo, which was associated with the real uid, only rename
it to cr_ruidinfo so as not to conflict with cr_uidinfo, which
corresponds to the effective uid.
o Remove p_cred from struct proc; add p_ucred to struct proc, replacing
original macro that pointed.
p->p_ucred to p->p_cred->pc_ucred.
o Universally update code so that it makes use of ucred instead of pcred,
p->p_ucred instead of p->p_pcred, cr_ruidinfo instead of p_uidinfo,
cr_{r,sv}{u,g}id instead of p_*, etc.
o Remove pcred0 and its initialization from init_main.c; initialize
cr_ruidinfo there.
o Restruction many credential modification chunks to always crdup while
we figure out locking and optimizations; generally speaking, this
means moving to a structure like this:
newcred = crdup(oldcred);
...
p->p_ucred = newcred;
crfree(oldcred);
It's not race-free, but better than nothing. There are also races
in sys_process.c, all inter-process authorization, fork, exec, and
exit.
o Remove sigio->sio_ruid since sigio->sio_ucred now contains the ruid;
remove comments indicating that the old arrangement was a problem.
o Restructure exec1() a little to use newcred/oldcred arrangement, and
use improved uid management primitives.
o Clean up exit1() so as to do less work in credential cleanup due to
pcred removal.
o Clean up fork1() so as to do less work in credential cleanup and
allocation.
o Clean up ktrcanset() to take into account changes, and move to using
suser_xxx() instead of performing a direct uid==0 comparision.
o Improve commenting in various kern_prot.c credential modification
calls to better document current behavior. In a couple of places,
current behavior is a little questionable and we need to check
POSIX.1 to make sure it's "right". More commenting work still
remains to be done.
o Update credential management calls, such as crfree(), to take into
account new ruidinfo reference.
o Modify or add the following uid and gid helper routines:
change_euid()
change_egid()
change_ruid()
change_rgid()
change_svuid()
change_svgid()
In each case, the call now acts on a credential not a process, and as
such no longer requires more complicated process locking/etc. They
now assume the caller will do any necessary allocation of an
exclusive credential reference. Each is commented to document its
reference requirements.
o CANSIGIO() is simplified to require only credentials, not processes
and pcreds.
o Remove lots of (p_pcred==NULL) checks.
o Add an XXX to authorization code in nfs_lock.c, since it's
questionable, and needs to be considered carefully.
o Simplify posix4 authorization code to require only credentials, not
processes and pcreds. Note that this authorization, as well as
CANSIGIO(), needs to be updated to use the p_cansignal() and
p_cansched() centralized authorization routines, as they currently
do not take into account some desirable restrictions that are handled
by the centralized routines, as well as being inconsistent with other
similar authorization instances.
o Update libkvm to take these changes into account.
Obtained from: TrustedBSD Project
Reviewed by: green, bde, jhb, freebsd-arch, freebsd-audit
2001-05-25 16:59:11 +00:00
|
|
|
(void)chgproccnt(p->p_ucred->cr_ruidinfo, -1, 0);
|
1994-05-24 10:09:53 +00:00
|
|
|
|
|
|
|
/*
|
2004-09-24 20:27:04 +00:00
|
|
|
* Free credentials, arguments, and sigacts.
|
1994-05-24 10:09:53 +00:00
|
|
|
*/
|
o Merge contents of struct pcred into struct ucred. Specifically, add the
real uid, saved uid, real gid, and saved gid to ucred, as well as the
pcred->pc_uidinfo, which was associated with the real uid, only rename
it to cr_ruidinfo so as not to conflict with cr_uidinfo, which
corresponds to the effective uid.
o Remove p_cred from struct proc; add p_ucred to struct proc, replacing
original macro that pointed.
p->p_ucred to p->p_cred->pc_ucred.
o Universally update code so that it makes use of ucred instead of pcred,
p->p_ucred instead of p->p_pcred, cr_ruidinfo instead of p_uidinfo,
cr_{r,sv}{u,g}id instead of p_*, etc.
o Remove pcred0 and its initialization from init_main.c; initialize
cr_ruidinfo there.
o Restruction many credential modification chunks to always crdup while
we figure out locking and optimizations; generally speaking, this
means moving to a structure like this:
newcred = crdup(oldcred);
...
p->p_ucred = newcred;
crfree(oldcred);
It's not race-free, but better than nothing. There are also races
in sys_process.c, all inter-process authorization, fork, exec, and
exit.
o Remove sigio->sio_ruid since sigio->sio_ucred now contains the ruid;
remove comments indicating that the old arrangement was a problem.
o Restructure exec1() a little to use newcred/oldcred arrangement, and
use improved uid management primitives.
o Clean up exit1() so as to do less work in credential cleanup due to
pcred removal.
o Clean up fork1() so as to do less work in credential cleanup and
allocation.
o Clean up ktrcanset() to take into account changes, and move to using
suser_xxx() instead of performing a direct uid==0 comparision.
o Improve commenting in various kern_prot.c credential modification
calls to better document current behavior. In a couple of places,
current behavior is a little questionable and we need to check
POSIX.1 to make sure it's "right". More commenting work still
remains to be done.
o Update credential management calls, such as crfree(), to take into
account new ruidinfo reference.
o Modify or add the following uid and gid helper routines:
change_euid()
change_egid()
change_ruid()
change_rgid()
change_svuid()
change_svgid()
In each case, the call now acts on a credential not a process, and as
such no longer requires more complicated process locking/etc. They
now assume the caller will do any necessary allocation of an
exclusive credential reference. Each is commented to document its
reference requirements.
o CANSIGIO() is simplified to require only credentials, not processes
and pcreds.
o Remove lots of (p_pcred==NULL) checks.
o Add an XXX to authorization code in nfs_lock.c, since it's
questionable, and needs to be considered carefully.
o Simplify posix4 authorization code to require only credentials, not
processes and pcreds. Note that this authorization, as well as
CANSIGIO(), needs to be updated to use the p_cansignal() and
p_cansched() centralized authorization routines, as they currently
do not take into account some desirable restrictions that are handled
by the centralized routines, as well as being inconsistent with other
similar authorization instances.
o Update libkvm to take these changes into account.
Obtained from: TrustedBSD Project
Reviewed by: green, bde, jhb, freebsd-arch, freebsd-audit
2001-05-25 16:59:11 +00:00
|
|
|
crfree(p->p_ucred);
|
- Merge struct procsig with struct sigacts.
- Move struct sigacts out of the u-area and malloc() it using the
M_SUBPROC malloc bucket.
- Add a small sigacts_*() API for managing sigacts structures: sigacts_alloc(),
sigacts_free(), sigacts_copy(), sigacts_share(), and sigacts_shared().
- Remove the p_sigignore, p_sigacts, and p_sigcatch macros.
- Add a mutex to struct sigacts that protects all the members of the struct.
- Add sigacts locking.
- Remove Giant from nosys(), kill(), killpg(), and kern_sigaction() now
that sigacts is locked.
- Several in-kernel functions such as psignal(), tdsignal(), trapsignal(),
and thread_stopped() are now MP safe.
Reviewed by: arch@
Approved by: re (rwatson)
2003-05-13 20:36:02 +00:00
|
|
|
p->p_ucred = NULL;
|
2002-05-02 15:09:58 +00:00
|
|
|
pargs_drop(p->p_args);
|
|
|
|
p->p_args = NULL;
|
- Merge struct procsig with struct sigacts.
- Move struct sigacts out of the u-area and malloc() it using the
M_SUBPROC malloc bucket.
- Add a small sigacts_*() API for managing sigacts structures: sigacts_alloc(),
sigacts_free(), sigacts_copy(), sigacts_share(), and sigacts_shared().
- Remove the p_sigignore, p_sigacts, and p_sigcatch macros.
- Add a mutex to struct sigacts that protects all the members of the struct.
- Add sigacts locking.
- Remove Giant from nosys(), kill(), killpg(), and kern_sigaction() now
that sigacts is locked.
- Several in-kernel functions such as psignal(), tdsignal(), trapsignal(),
and thread_stopped() are now MP safe.
Reviewed by: arch@
Approved by: re (rwatson)
2003-05-13 20:36:02 +00:00
|
|
|
sigacts_free(p->p_sigacts);
|
|
|
|
p->p_sigacts = NULL;
|
1999-01-26 02:38:12 +00:00
|
|
|
|
Part 1 of KSE-III
The ability to schedule multiple threads per process
(one one cpu) by making ALL system calls optionally asynchronous.
to come: ia64 and power-pc patches, patches for gdb, test program (in tools)
Reviewed by: Almost everyone who counts
(at various times, peter, jhb, matt, alfred, mini, bernd,
and a cast of thousands)
NOTE: this is still Beta code, and contains lots of debugging stuff.
expect slight instability in signals..
2002-06-29 17:26:22 +00:00
|
|
|
/*
|
2004-09-24 20:27:04 +00:00
|
|
|
* Do any thread-system specific cleanups.
|
Part 1 of KSE-III
The ability to schedule multiple threads per process
(one one cpu) by making ALL system calls optionally asynchronous.
to come: ia64 and power-pc patches, patches for gdb, test program (in tools)
Reviewed by: Almost everyone who counts
(at various times, peter, jhb, matt, alfred, mini, bernd,
and a cast of thousands)
NOTE: this is still Beta code, and contains lots of debugging stuff.
expect slight instability in signals..
2002-06-29 17:26:22 +00:00
|
|
|
*/
|
2002-12-10 02:33:45 +00:00
|
|
|
thread_wait(p);
|
Part 1 of KSE-III
The ability to schedule multiple threads per process
(one one cpu) by making ALL system calls optionally asynchronous.
to come: ia64 and power-pc patches, patches for gdb, test program (in tools)
Reviewed by: Almost everyone who counts
(at various times, peter, jhb, matt, alfred, mini, bernd,
and a cast of thousands)
NOTE: this is still Beta code, and contains lots of debugging stuff.
expect slight instability in signals..
2002-06-29 17:26:22 +00:00
|
|
|
|
1994-05-24 10:09:53 +00:00
|
|
|
/*
|
2001-09-10 04:28:58 +00:00
|
|
|
* Give vm and machine-dependent layer a chance
|
1994-05-24 10:09:53 +00:00
|
|
|
* to free anything that cpu_exit couldn't
|
|
|
|
* release while still running in process context.
|
|
|
|
*/
|
2001-09-10 04:28:58 +00:00
|
|
|
vm_waitproc(p);
|
2002-11-20 15:41:25 +00:00
|
|
|
#ifdef MAC
|
|
|
|
mac_destroy_proc(p);
|
|
|
|
#endif
|
2002-09-06 07:00:37 +00:00
|
|
|
KASSERT(FIRST_THREAD_IN_PROC(p),
|
2004-03-17 20:00:00 +00:00
|
|
|
("kern_wait: no residual thread!"));
|
2002-03-20 04:09:59 +00:00
|
|
|
uma_zfree(proc_zone, p);
|
2002-05-02 15:09:58 +00:00
|
|
|
sx_xlock(&allproc_lock);
|
1994-05-24 10:09:53 +00:00
|
|
|
nprocs--;
|
2002-05-02 15:09:58 +00:00
|
|
|
sx_xunlock(&allproc_lock);
|
|
|
|
return (0);
|
1994-05-24 10:09:53 +00:00
|
|
|
}
|
2003-04-23 18:46:51 +00:00
|
|
|
mtx_lock_spin(&sched_lock);
|
2004-09-24 20:27:04 +00:00
|
|
|
if (P_SHOULDSTOP(p) && p->p_suspcount == p->p_numthreads &&
|
|
|
|
(p->p_flag & P_WAITED) == 0 &&
|
2004-03-17 20:00:00 +00:00
|
|
|
(p->p_flag & P_TRACED || options & WUNTRACED)) {
|
2003-04-23 18:46:51 +00:00
|
|
|
mtx_unlock_spin(&sched_lock);
|
1994-05-24 10:09:53 +00:00
|
|
|
p->p_flag |= P_WAITED;
|
2002-05-02 15:09:58 +00:00
|
|
|
sx_xunlock(&proctree_lock);
|
2001-09-12 08:38:13 +00:00
|
|
|
td->td_retval[0] = p->p_pid;
|
2004-03-17 20:00:00 +00:00
|
|
|
if (status)
|
|
|
|
*status = W_STOPCODE(p->p_xstat);
|
|
|
|
PROC_UNLOCK(p);
|
|
|
|
return (0);
|
1994-05-24 10:09:53 +00:00
|
|
|
}
|
2003-04-23 18:46:51 +00:00
|
|
|
mtx_unlock_spin(&sched_lock);
|
2004-03-17 20:00:00 +00:00
|
|
|
if (options & WCONTINUED && (p->p_flag & P_CONTINUED)) {
|
2002-06-01 18:37:46 +00:00
|
|
|
sx_xunlock(&proctree_lock);
|
|
|
|
td->td_retval[0] = p->p_pid;
|
|
|
|
p->p_flag &= ~P_CONTINUED;
|
|
|
|
PROC_UNLOCK(p);
|
|
|
|
|
2004-03-17 20:00:00 +00:00
|
|
|
if (status)
|
|
|
|
*status = SIGCONT;
|
|
|
|
return (0);
|
2002-06-01 18:37:46 +00:00
|
|
|
}
|
2001-01-24 00:33:44 +00:00
|
|
|
PROC_UNLOCK(p);
|
1994-05-24 10:09:53 +00:00
|
|
|
}
|
2001-09-01 04:37:34 +00:00
|
|
|
if (nfound == 0) {
|
2002-05-02 15:09:58 +00:00
|
|
|
sx_xunlock(&proctree_lock);
|
|
|
|
return (ECHILD);
|
2001-09-01 04:37:34 +00:00
|
|
|
}
|
2004-03-17 20:00:00 +00:00
|
|
|
if (options & WNOHANG) {
|
2002-05-02 15:09:58 +00:00
|
|
|
sx_xunlock(&proctree_lock);
|
2001-09-12 08:38:13 +00:00
|
|
|
td->td_retval[0] = 0;
|
2002-05-02 15:09:58 +00:00
|
|
|
return (0);
|
|
|
|
}
|
|
|
|
PROC_LOCK(q);
|
|
|
|
sx_xunlock(&proctree_lock);
|
2002-06-29 01:50:25 +00:00
|
|
|
error = msleep(q, &q->p_mtx, PWAIT | PCATCH, "wait", 0);
|
2002-05-02 15:09:58 +00:00
|
|
|
PROC_UNLOCK(q);
|
2004-03-05 22:39:53 +00:00
|
|
|
if (error)
|
|
|
|
return (error);
|
1994-05-24 10:09:53 +00:00
|
|
|
goto loop;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
2000-12-23 19:43:10 +00:00
|
|
|
* Make process 'parent' the new parent of process 'child'.
|
|
|
|
* Must be called with an exclusive hold of proctree lock.
|
1994-05-24 10:09:53 +00:00
|
|
|
*/
|
|
|
|
void
|
2003-03-19 00:49:40 +00:00
|
|
|
proc_reparent(struct proc *child, struct proc *parent)
|
1994-05-24 10:09:53 +00:00
|
|
|
{
|
|
|
|
|
2001-10-23 22:39:11 +00:00
|
|
|
sx_assert(&proctree_lock, SX_XLOCKED);
|
2001-03-07 02:22:31 +00:00
|
|
|
PROC_LOCK_ASSERT(child, MA_OWNED);
|
1994-05-24 10:09:53 +00:00
|
|
|
if (child->p_pptr == parent)
|
|
|
|
return;
|
|
|
|
|
1996-03-11 06:05:03 +00:00
|
|
|
LIST_REMOVE(child, p_sibling);
|
|
|
|
LIST_INSERT_HEAD(&parent->p_children, child, p_sibling);
|
1994-05-24 10:09:53 +00:00
|
|
|
child->p_pptr = parent;
|
|
|
|
}
|