2005-01-06 23:35:40 +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"
|
2008-05-24 06:22:16 +00:00
|
|
|
#include "opt_kdtrace.h"
|
1996-01-03 21:42:35 +00:00
|
|
|
#include "opt_ktrace.h"
|
|
|
|
|
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>
|
MFp4:
Bring in updated jail support from bz_jail branch.
This enhances the current jail implementation to permit multiple
addresses per jail. In addtion to IPv4, IPv6 is supported as well.
Due to updated checks it is even possible to have jails without
an IP address at all, which basically gives one a chroot with
restricted process view, no networking,..
SCTP support was updated and supports IPv6 in jails as well.
Cpuset support permits jails to be bound to specific processor
sets after creation.
Jails can have an unrestricted (no duplicate protection, etc.) name
in addition to the hostname. The jail name cannot be changed from
within a jail and is considered to be used for management purposes
or as audit-token in the future.
DDB 'show jails' command was added to aid debugging.
Proper compat support permits 32bit jail binaries to be used on 64bit
systems to manage jails. Also backward compatibility was preserved where
possible: for jail v1 syscalls, as well as with user space management
utilities.
Both jail as well as prison version were updated for the new features.
A gap was intentionally left as the intermediate versions had been
used by various patches floating around the last years.
Bump __FreeBSD_version for the afore mentioned and in kernel changes.
Special thanks to:
- Pawel Jakub Dawidek (pjd) for his multi-IPv4 patches
and Olivier Houchard (cognet) for initial single-IPv6 patches.
- Jeff Roberson (jeff) and Randall Stewart (rrs) for their
help, ideas and review on cpuset and SCTP support.
- Robert Watson (rwatson) for lots and lots of help, discussions,
suggestions and review of most of the patch at various stages.
- John Baldwin (jhb) for his help.
- Simon L. Nielsen (simon) as early adopter testing changes
on cluster machines as well as all the testers and people
who provided feedback the last months on freebsd-jail and
other channels.
- My employer, CK Software GmbH, for the support so I could work on this.
Reviewed by: (see above)
MFC after: 3 months (this is just so that I get the mail)
X-MFC Before: 7.2-RELEASE if possible
2008-11-29 14:32:14 +00:00
|
|
|
#include <sys/jail.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>
|
2005-12-23 11:58:42 +00:00
|
|
|
#include <sys/sbuf.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>
|
2005-01-05 22:19:44 +00:00
|
|
|
#include <sys/syscallsubr.h>
|
2005-12-23 11:58:42 +00:00
|
|
|
#include <sys/syslog.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>
|
2008-05-24 06:22:16 +00:00
|
|
|
#include <sys/sdt.h>
|
1996-01-01 12:23:39 +00:00
|
|
|
#include <sys/shm.h>
|
|
|
|
#include <sys/sem.h>
|
2009-05-08 14:11:06 +00:00
|
|
|
#include <sys/vimage.h>
|
2002-06-07 05:41:27 +00:00
|
|
|
#ifdef KTRACE
|
|
|
|
#include <sys/ktrace.h>
|
|
|
|
#endif
|
1996-01-01 12:23:39 +00:00
|
|
|
|
2006-02-02 01:32:58 +00:00
|
|
|
#include <security/audit/audit.h>
|
2006-10-22 11:52:19 +00:00
|
|
|
#include <security/mac/mac_framework.h>
|
2006-02-02 01:32:58 +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
|
|
|
|
2008-05-24 06:22:16 +00:00
|
|
|
#ifdef KDTRACE_HOOKS
|
|
|
|
#include <sys/dtrace_bsd.h>
|
|
|
|
dtrace_execexit_func_t dtrace_fasttrap_exit;
|
|
|
|
#endif
|
|
|
|
|
|
|
|
SDT_PROVIDER_DECLARE(proc);
|
|
|
|
SDT_PROBE_DEFINE(proc, kernel, , exit);
|
|
|
|
SDT_PROBE_ARGTYPE(proc, kernel, , exit, 0, "int");
|
|
|
|
|
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
|
|
|
|
2005-10-26 07:18:37 +00:00
|
|
|
/* Hook for NFS teardown procedure. */
|
|
|
|
void (*nlminfo_release_p)(struct proc *p);
|
|
|
|
|
1994-05-24 10:09:53 +00:00
|
|
|
/*
|
2007-03-05 13:10:58 +00:00
|
|
|
* exit -- death of process.
|
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 */
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
2007-03-05 13:10:58 +00:00
|
|
|
* 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.
|
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
|
|
|
exit1(struct thread *td, int rv)
|
1994-05-24 10:09:53 +00:00
|
|
|
{
|
2002-05-06 17:04:29 +00:00
|
|
|
struct proc *p, *nq, *q;
|
|
|
|
struct vnode *vtmp;
|
Integrate the new MPSAFE TTY layer to the FreeBSD operating system.
The last half year I've been working on a replacement TTY layer for the
FreeBSD kernel. The new TTY layer was designed to improve the following:
- Improved driver model:
The old TTY layer has a driver model that is not abstract enough to
make it friendly to use. A good example is the output path, where the
device drivers directly access the output buffers. This means that an
in-kernel PPP implementation must always convert network buffers into
TTY buffers.
If a PPP implementation would be built on top of the new TTY layer
(still needs a hooks layer, though), it would allow the PPP
implementation to directly hand the data to the TTY driver.
- Improved hotplugging:
With the old TTY layer, it isn't entirely safe to destroy TTY's from
the system. This implementation has a two-step destructing design,
where the driver first abandons the TTY. After all threads have left
the TTY, the TTY layer calls a routine in the driver, which can be
used to free resources (unit numbers, etc).
The pts(4) driver also implements this feature, which means
posix_openpt() will now return PTY's that are created on the fly.
- Improved performance:
One of the major improvements is the per-TTY mutex, which is expected
to improve scalability when compared to the old Giant locking.
Another change is the unbuffered copying to userspace, which is both
used on TTY device nodes and PTY masters.
Upgrading should be quite straightforward. Unlike previous versions,
existing kernel configuration files do not need to be changed, except
when they reference device drivers that are listed in UPDATING.
Obtained from: //depot/projects/mpsafetty/...
Approved by: philip (ex-mentor)
Discussed: on the lists, at BSDCan, at the DevSummit
Sponsored by: Snow B.V., the Netherlands
dcons(4) fixed by: kan
2008-08-20 08:31:58 +00:00
|
|
|
struct vnode *ttyvp = NULL;
|
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;
|
2006-05-29 21:28:56 +00:00
|
|
|
int locked;
|
1994-05-24 10:09:53 +00:00
|
|
|
|
2008-02-17 15:28:28 +00:00
|
|
|
mtx_assert(&Giant, MA_NOTOWNED);
|
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);
|
2007-10-26 08:00:41 +00:00
|
|
|
while (p->p_flag & P_HADTHREADS) {
|
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
|
|
|
*/
|
2007-10-26 08:00:41 +00:00
|
|
|
if (! thread_single(SINGLE_EXIT))
|
|
|
|
break;
|
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
|
|
|
*/
|
|
|
|
}
|
2007-06-01 01:12:45 +00:00
|
|
|
KASSERT(p->p_numthreads == 1,
|
|
|
|
("exit1: proc %p exiting with %d threads", p, p->p_numthreads));
|
Close some races between procfs/ptrace and exit(2):
- Reorder the events in exit(2) slightly so that we trigger the S_EXIT
stop event earlier. After we have signalled that, we set P_WEXIT and
then wait for any processes with a hold on the vmspace via PHOLD to
release it. PHOLD now KASSERT()'s that P_WEXIT is clear when it is
invoked, and PRELE now does a wakeup if P_WEXIT is set and p_lock drops
to zero.
- Change proc_rwmem() to require that the processing read from has its
vmspace held via PHOLD by the caller and get rid of all the junk to
screw around with the vmspace reference count as we no longer need it.
- In ptrace() and pseudofs(), treat a process with P_WEXIT set as if it
doesn't exist.
- Only do one PHOLD in kern_ptrace() now, and do it earlier so it covers
FIX_SSTEP() (since on alpha at least this can end up calling proc_rwmem()
to clear an earlier single-step simualted via a breakpoint). We only
do one to avoid races. Also, by making the EINVAL error for unknown
requests be part of the default: case in the switch, the various
switch cases can now just break out to return which removes a _lot_ of
duplicated PRELE and proc unlocks, etc. Also, it fixes at least one bug
where a LWP ptrace command could return EINVAL with the proc lock still
held.
- Changed the locking for ptrace_single_step(), ptrace_set_pc(), and
ptrace_clear_single_step() to always be called with the proc lock
held (it was a mixed bag previously). Alpha and arm have to drop
the lock while the mess around with breakpoints, but other archs
avoid extra lock release/acquires in ptrace(). I did have to fix a
couple of other consumers in kern_kse and a few other places to
hold the proc lock and PHOLD.
Tested by: ps (1 mostly, but some bits of 2-4 as well)
MFC after: 1 week
2006-02-22 18:57:50 +00:00
|
|
|
/*
|
|
|
|
* Wakeup anyone in procfs' PIOCWAIT. They should have a hold
|
|
|
|
* on our vmspace, so we should block below until they have
|
|
|
|
* released their reference to us. Note that if they have
|
|
|
|
* requested S_EXIT stops we will block here until they ack
|
|
|
|
* via PIOCCONT.
|
|
|
|
*/
|
|
|
|
_STOPEVENT(p, S_EXIT, rv);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Note that we are exiting and do another wakeup of anyone in
|
|
|
|
* PIOCWAIT in case they aren't listening for S_EXIT stops or
|
|
|
|
* decided to wait again after we told them we are exiting.
|
|
|
|
*/
|
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;
|
Close some races between procfs/ptrace and exit(2):
- Reorder the events in exit(2) slightly so that we trigger the S_EXIT
stop event earlier. After we have signalled that, we set P_WEXIT and
then wait for any processes with a hold on the vmspace via PHOLD to
release it. PHOLD now KASSERT()'s that P_WEXIT is clear when it is
invoked, and PRELE now does a wakeup if P_WEXIT is set and p_lock drops
to zero.
- Change proc_rwmem() to require that the processing read from has its
vmspace held via PHOLD by the caller and get rid of all the junk to
screw around with the vmspace reference count as we no longer need it.
- In ptrace() and pseudofs(), treat a process with P_WEXIT set as if it
doesn't exist.
- Only do one PHOLD in kern_ptrace() now, and do it earlier so it covers
FIX_SSTEP() (since on alpha at least this can end up calling proc_rwmem()
to clear an earlier single-step simualted via a breakpoint). We only
do one to avoid races. Also, by making the EINVAL error for unknown
requests be part of the default: case in the switch, the various
switch cases can now just break out to return which removes a _lot_ of
duplicated PRELE and proc unlocks, etc. Also, it fixes at least one bug
where a LWP ptrace command could return EINVAL with the proc lock still
held.
- Changed the locking for ptrace_single_step(), ptrace_set_pc(), and
ptrace_clear_single_step() to always be called with the proc lock
held (it was a mixed bag previously). Alpha and arm have to drop
the lock while the mess around with breakpoints, but other archs
avoid extra lock release/acquires in ptrace(). I did have to fix a
couple of other consumers in kern_kse and a few other places to
hold the proc lock and PHOLD.
Tested by: ps (1 mostly, but some bits of 2-4 as well)
MFC after: 1 week
2006-02-22 18:57:50 +00:00
|
|
|
wakeup(&p->p_stype);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Wait for any processes that have a hold on our vmspace to
|
|
|
|
* release their reference.
|
|
|
|
*/
|
|
|
|
while (p->p_lock > 0)
|
|
|
|
msleep(&p->p_lock, &p->p_mtx, PWAIT, "exithold", 0);
|
2005-11-08 09:09:26 +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_UNLOCK(p);
|
2007-06-01 01:12:45 +00:00
|
|
|
/* Drain the limit callout while we don't have the proc locked */
|
|
|
|
callout_drain(&p->p_limco);
|
2001-09-12 08:38:13 +00:00
|
|
|
|
2006-02-05 21:08:25 +00:00
|
|
|
#ifdef AUDIT
|
|
|
|
/*
|
|
|
|
* The Sun BSM exit token contains two components: an exit status as
|
|
|
|
* passed to exit(), and a return value to indicate what sort of exit
|
|
|
|
* it was. The exit status is WEXITSTATUS(rv), but it's not clear
|
|
|
|
* what the return value is.
|
|
|
|
*/
|
2009-06-27 13:58:44 +00:00
|
|
|
AUDIT_ARG_EXIT(WEXITSTATUS(rv), 0);
|
2006-02-05 21:08:25 +00:00
|
|
|
AUDIT_SYSCALL_EXIT(0, td);
|
|
|
|
#endif
|
|
|
|
|
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
|
|
|
|
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
|
|
|
/*
|
|
|
|
* 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);
|
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.
|
|
|
|
*/
|
|
|
|
funsetownlst(&p->p_sigiolst);
|
|
|
|
|
2005-10-26 07:18:37 +00:00
|
|
|
/*
|
|
|
|
* If this process has an nlminfo data area (for lockd), release it
|
|
|
|
*/
|
|
|
|
if (nlminfo_release_p != NULL && p->p_nlminfo != NULL)
|
|
|
|
(*nlminfo_release_p)(p);
|
|
|
|
|
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);
|
1994-05-24 10:09:53 +00:00
|
|
|
|
2005-01-29 14:03:41 +00:00
|
|
|
/*
|
|
|
|
* If this thread tickled GEOM, we need to wait for the giggling to
|
|
|
|
* stop before we return to userland
|
|
|
|
*/
|
|
|
|
if (td->td_pflags & TDP_GEOM)
|
|
|
|
g_waitidle();
|
|
|
|
|
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
|
|
|
|
2006-05-29 21:28:56 +00:00
|
|
|
vmspace_exit(td);
|
1994-05-24 10:09:53 +00:00
|
|
|
|
2002-04-16 17:04:21 +00:00
|
|
|
sx_xlock(&proctree_lock);
|
1994-05-24 10:09:53 +00:00
|
|
|
if (SESS_LEADER(p)) {
|
2009-06-15 20:45:51 +00:00
|
|
|
struct session *sp = p->p_session;
|
|
|
|
struct tty *tp;
|
Integrate the new MPSAFE TTY layer to the FreeBSD operating system.
The last half year I've been working on a replacement TTY layer for the
FreeBSD kernel. The new TTY layer was designed to improve the following:
- Improved driver model:
The old TTY layer has a driver model that is not abstract enough to
make it friendly to use. A good example is the output path, where the
device drivers directly access the output buffers. This means that an
in-kernel PPP implementation must always convert network buffers into
TTY buffers.
If a PPP implementation would be built on top of the new TTY layer
(still needs a hooks layer, though), it would allow the PPP
implementation to directly hand the data to the TTY driver.
- Improved hotplugging:
With the old TTY layer, it isn't entirely safe to destroy TTY's from
the system. This implementation has a two-step destructing design,
where the driver first abandons the TTY. After all threads have left
the TTY, the TTY layer calls a routine in the driver, which can be
used to free resources (unit numbers, etc).
The pts(4) driver also implements this feature, which means
posix_openpt() will now return PTY's that are created on the fly.
- Improved performance:
One of the major improvements is the per-TTY mutex, which is expected
to improve scalability when compared to the old Giant locking.
Another change is the unbuffered copying to userspace, which is both
used on TTY device nodes and PTY masters.
Upgrading should be quite straightforward. Unlike previous versions,
existing kernel configuration files do not need to be changed, except
when they reference device drivers that are listed in UPDATING.
Obtained from: //depot/projects/mpsafetty/...
Approved by: philip (ex-mentor)
Discussed: on the lists, at BSDCan, at the DevSummit
Sponsored by: Snow B.V., the Netherlands
dcons(4) fixed by: kan
2008-08-20 08:31:58 +00:00
|
|
|
|
2009-06-15 20:45:51 +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)
|
|
|
|
*/
|
Integrate the new MPSAFE TTY layer to the FreeBSD operating system.
The last half year I've been working on a replacement TTY layer for the
FreeBSD kernel. The new TTY layer was designed to improve the following:
- Improved driver model:
The old TTY layer has a driver model that is not abstract enough to
make it friendly to use. A good example is the output path, where the
device drivers directly access the output buffers. This means that an
in-kernel PPP implementation must always convert network buffers into
TTY buffers.
If a PPP implementation would be built on top of the new TTY layer
(still needs a hooks layer, though), it would allow the PPP
implementation to directly hand the data to the TTY driver.
- Improved hotplugging:
With the old TTY layer, it isn't entirely safe to destroy TTY's from
the system. This implementation has a two-step destructing design,
where the driver first abandons the TTY. After all threads have left
the TTY, the TTY layer calls a routine in the driver, which can be
used to free resources (unit numbers, etc).
The pts(4) driver also implements this feature, which means
posix_openpt() will now return PTY's that are created on the fly.
- Improved performance:
One of the major improvements is the per-TTY mutex, which is expected
to improve scalability when compared to the old Giant locking.
Another change is the unbuffered copying to userspace, which is both
used on TTY device nodes and PTY masters.
Upgrading should be quite straightforward. Unlike previous versions,
existing kernel configuration files do not need to be changed, except
when they reference device drivers that are listed in UPDATING.
Obtained from: //depot/projects/mpsafetty/...
Approved by: philip (ex-mentor)
Discussed: on the lists, at BSDCan, at the DevSummit
Sponsored by: Snow B.V., the Netherlands
dcons(4) fixed by: kan
2008-08-20 08:31:58 +00:00
|
|
|
SESS_LOCK(sp);
|
|
|
|
ttyvp = sp->s_ttyvp;
|
2009-06-15 20:45:51 +00:00
|
|
|
tp = sp->s_ttyp;
|
Integrate the new MPSAFE TTY layer to the FreeBSD operating system.
The last half year I've been working on a replacement TTY layer for the
FreeBSD kernel. The new TTY layer was designed to improve the following:
- Improved driver model:
The old TTY layer has a driver model that is not abstract enough to
make it friendly to use. A good example is the output path, where the
device drivers directly access the output buffers. This means that an
in-kernel PPP implementation must always convert network buffers into
TTY buffers.
If a PPP implementation would be built on top of the new TTY layer
(still needs a hooks layer, though), it would allow the PPP
implementation to directly hand the data to the TTY driver.
- Improved hotplugging:
With the old TTY layer, it isn't entirely safe to destroy TTY's from
the system. This implementation has a two-step destructing design,
where the driver first abandons the TTY. After all threads have left
the TTY, the TTY layer calls a routine in the driver, which can be
used to free resources (unit numbers, etc).
The pts(4) driver also implements this feature, which means
posix_openpt() will now return PTY's that are created on the fly.
- Improved performance:
One of the major improvements is the per-TTY mutex, which is expected
to improve scalability when compared to the old Giant locking.
Another change is the unbuffered copying to userspace, which is both
used on TTY device nodes and PTY masters.
Upgrading should be quite straightforward. Unlike previous versions,
existing kernel configuration files do not need to be changed, except
when they reference device drivers that are listed in UPDATING.
Obtained from: //depot/projects/mpsafetty/...
Approved by: philip (ex-mentor)
Discussed: on the lists, at BSDCan, at the DevSummit
Sponsored by: Snow B.V., the Netherlands
dcons(4) fixed by: kan
2008-08-20 08:31:58 +00:00
|
|
|
sp->s_ttyvp = NULL;
|
2009-06-15 20:45:51 +00:00
|
|
|
sp->s_leader = NULL;
|
Integrate the new MPSAFE TTY layer to the FreeBSD operating system.
The last half year I've been working on a replacement TTY layer for the
FreeBSD kernel. The new TTY layer was designed to improve the following:
- Improved driver model:
The old TTY layer has a driver model that is not abstract enough to
make it friendly to use. A good example is the output path, where the
device drivers directly access the output buffers. This means that an
in-kernel PPP implementation must always convert network buffers into
TTY buffers.
If a PPP implementation would be built on top of the new TTY layer
(still needs a hooks layer, though), it would allow the PPP
implementation to directly hand the data to the TTY driver.
- Improved hotplugging:
With the old TTY layer, it isn't entirely safe to destroy TTY's from
the system. This implementation has a two-step destructing design,
where the driver first abandons the TTY. After all threads have left
the TTY, the TTY layer calls a routine in the driver, which can be
used to free resources (unit numbers, etc).
The pts(4) driver also implements this feature, which means
posix_openpt() will now return PTY's that are created on the fly.
- Improved performance:
One of the major improvements is the per-TTY mutex, which is expected
to improve scalability when compared to the old Giant locking.
Another change is the unbuffered copying to userspace, which is both
used on TTY device nodes and PTY masters.
Upgrading should be quite straightforward. Unlike previous versions,
existing kernel configuration files do not need to be changed, except
when they reference device drivers that are listed in UPDATING.
Obtained from: //depot/projects/mpsafetty/...
Approved by: philip (ex-mentor)
Discussed: on the lists, at BSDCan, at the DevSummit
Sponsored by: Snow B.V., the Netherlands
dcons(4) fixed by: kan
2008-08-20 08:31:58 +00:00
|
|
|
SESS_UNLOCK(sp);
|
|
|
|
|
2009-06-15 20:45:51 +00:00
|
|
|
/*
|
|
|
|
* Signal foreground pgrp and revoke access to
|
|
|
|
* controlling terminal if it has not been revoked
|
|
|
|
* already.
|
|
|
|
*
|
|
|
|
* Because the TTY may have been revoked in the mean
|
|
|
|
* time and could already have a new session associated
|
|
|
|
* with it, make sure we don't send a SIGHUP to a
|
|
|
|
* foreground process group that does not belong to this
|
|
|
|
* session.
|
|
|
|
*/
|
|
|
|
|
|
|
|
if (tp != NULL) {
|
|
|
|
tty_lock(tp);
|
|
|
|
if (tp->t_session == sp)
|
Integrate the new MPSAFE TTY layer to the FreeBSD operating system.
The last half year I've been working on a replacement TTY layer for the
FreeBSD kernel. The new TTY layer was designed to improve the following:
- Improved driver model:
The old TTY layer has a driver model that is not abstract enough to
make it friendly to use. A good example is the output path, where the
device drivers directly access the output buffers. This means that an
in-kernel PPP implementation must always convert network buffers into
TTY buffers.
If a PPP implementation would be built on top of the new TTY layer
(still needs a hooks layer, though), it would allow the PPP
implementation to directly hand the data to the TTY driver.
- Improved hotplugging:
With the old TTY layer, it isn't entirely safe to destroy TTY's from
the system. This implementation has a two-step destructing design,
where the driver first abandons the TTY. After all threads have left
the TTY, the TTY layer calls a routine in the driver, which can be
used to free resources (unit numbers, etc).
The pts(4) driver also implements this feature, which means
posix_openpt() will now return PTY's that are created on the fly.
- Improved performance:
One of the major improvements is the per-TTY mutex, which is expected
to improve scalability when compared to the old Giant locking.
Another change is the unbuffered copying to userspace, which is both
used on TTY device nodes and PTY masters.
Upgrading should be quite straightforward. Unlike previous versions,
existing kernel configuration files do not need to be changed, except
when they reference device drivers that are listed in UPDATING.
Obtained from: //depot/projects/mpsafetty/...
Approved by: philip (ex-mentor)
Discussed: on the lists, at BSDCan, at the DevSummit
Sponsored by: Snow B.V., the Netherlands
dcons(4) fixed by: kan
2008-08-20 08:31:58 +00:00
|
|
|
tty_signal_pgrp(tp, SIGHUP);
|
2009-06-15 20:45:51 +00:00
|
|
|
tty_unlock(tp);
|
|
|
|
}
|
|
|
|
|
2009-07-09 18:54:38 +00:00
|
|
|
if (ttyvp != NULL) {
|
2009-06-15 20:45:51 +00:00
|
|
|
sx_xunlock(&proctree_lock);
|
2009-07-09 18:54:38 +00:00
|
|
|
vn_lock(ttyvp, LK_EXCLUSIVE | LK_RETRY);
|
|
|
|
if (ttyvp->v_type != VBAD)
|
|
|
|
VOP_REVOKE(ttyvp, REVOKEALL);
|
2009-06-15 20:45:51 +00:00
|
|
|
VOP_UNLOCK(ttyvp, 0);
|
|
|
|
sx_xlock(&proctree_lock);
|
1994-05-24 10:09:53 +00:00
|
|
|
}
|
2002-02-23 11:12:57 +00:00
|
|
|
}
|
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);
|
Integrate the new MPSAFE TTY layer to the FreeBSD operating system.
The last half year I've been working on a replacement TTY layer for the
FreeBSD kernel. The new TTY layer was designed to improve the following:
- Improved driver model:
The old TTY layer has a driver model that is not abstract enough to
make it friendly to use. A good example is the output path, where the
device drivers directly access the output buffers. This means that an
in-kernel PPP implementation must always convert network buffers into
TTY buffers.
If a PPP implementation would be built on top of the new TTY layer
(still needs a hooks layer, though), it would allow the PPP
implementation to directly hand the data to the TTY driver.
- Improved hotplugging:
With the old TTY layer, it isn't entirely safe to destroy TTY's from
the system. This implementation has a two-step destructing design,
where the driver first abandons the TTY. After all threads have left
the TTY, the TTY layer calls a routine in the driver, which can be
used to free resources (unit numbers, etc).
The pts(4) driver also implements this feature, which means
posix_openpt() will now return PTY's that are created on the fly.
- Improved performance:
One of the major improvements is the per-TTY mutex, which is expected
to improve scalability when compared to the old Giant locking.
Another change is the unbuffered copying to userspace, which is both
used on TTY device nodes and PTY masters.
Upgrading should be quite straightforward. Unlike previous versions,
existing kernel configuration files do not need to be changed, except
when they reference device drivers that are listed in UPDATING.
Obtained from: //depot/projects/mpsafetty/...
Approved by: philip (ex-mentor)
Discussed: on the lists, at BSDCan, at the DevSummit
Sponsored by: Snow B.V., the Netherlands
dcons(4) fixed by: kan
2008-08-20 08:31:58 +00:00
|
|
|
|
|
|
|
/* Release the TTY now we've unlocked everything. */
|
|
|
|
if (ttyvp != NULL)
|
|
|
|
vrele(ttyvp);
|
1994-05-24 10:09:53 +00:00
|
|
|
#ifdef KTRACE
|
1995-05-30 08:16:23 +00:00
|
|
|
/*
|
2007-06-13 20:01:42 +00:00
|
|
|
* Disable tracing, then drain any pending records and release
|
|
|
|
* the trace file.
|
1994-05-24 10:09:53 +00:00
|
|
|
*/
|
2007-06-13 20:01:42 +00:00
|
|
|
if (p->p_traceflag != 0) {
|
|
|
|
PROC_LOCK(p);
|
|
|
|
mtx_lock(&ktrace_mtx);
|
|
|
|
p->p_traceflag = 0;
|
|
|
|
mtx_unlock(&ktrace_mtx);
|
|
|
|
PROC_UNLOCK(p);
|
|
|
|
ktrprocexit(td);
|
|
|
|
PROC_LOCK(p);
|
|
|
|
mtx_lock(&ktrace_mtx);
|
|
|
|
tracevp = p->p_tracevp;
|
|
|
|
p->p_tracevp = NULL;
|
|
|
|
tracecred = p->p_tracecred;
|
|
|
|
p->p_tracecred = NULL;
|
|
|
|
mtx_unlock(&ktrace_mtx);
|
|
|
|
PROC_UNLOCK(p);
|
|
|
|
if (tracevp != NULL) {
|
|
|
|
locked = VFS_LOCK_GIANT(tracevp->v_mount);
|
|
|
|
vrele(tracevp);
|
|
|
|
VFS_UNLOCK_GIANT(locked);
|
|
|
|
}
|
|
|
|
if (tracecred != NULL)
|
|
|
|
crfree(tracecred);
|
2004-03-18 18:15:58 +00:00
|
|
|
}
|
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;
|
2005-11-08 17:11:03 +00:00
|
|
|
locked = VFS_LOCK_GIANT(vtmp->v_mount);
|
2002-01-05 21:47:58 +00:00
|
|
|
vrele(vtmp);
|
2005-11-08 17:11:03 +00:00
|
|
|
VFS_UNLOCK_GIANT(locked);
|
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
|
|
|
|
2007-05-14 22:21:58 +00:00
|
|
|
/*
|
|
|
|
* Call machine-dependent code to release any
|
|
|
|
* machine-dependent resources other than the address space.
|
|
|
|
* The address space is released by "vmspace_exitfree(p)" in
|
|
|
|
* vm_waitproc().
|
|
|
|
*/
|
|
|
|
cpu_exit(td);
|
|
|
|
|
|
|
|
WITNESS_WARN(WARN_PANIC, NULL, "process (pid %d) exiting", p->p_pid);
|
|
|
|
|
2006-02-03 21:09:40 +00:00
|
|
|
/*
|
|
|
|
* Reparent all of our children to init.
|
|
|
|
*/
|
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) {
|
2008-10-15 06:31:37 +00:00
|
|
|
struct thread *temp;
|
|
|
|
|
2004-10-23 11:20:26 +00:00
|
|
|
q->p_flag &= ~(P_TRACED | P_STOPPED_TRACE);
|
2008-10-15 06:31:37 +00:00
|
|
|
FOREACH_THREAD_IN_PROC(q, temp)
|
|
|
|
temp->td_dbgflags &= ~TDB_SUSPEND;
|
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
|
|
|
}
|
|
|
|
|
2007-06-01 01:12:45 +00:00
|
|
|
/* Save exit status. */
|
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;
|
2008-05-24 06:22:16 +00:00
|
|
|
|
2009-05-27 14:11:23 +00:00
|
|
|
/* Tell the prison that we are gone. */
|
|
|
|
prison_proc_free(p->p_ucred->cr_prison);
|
MFp4:
Bring in updated jail support from bz_jail branch.
This enhances the current jail implementation to permit multiple
addresses per jail. In addtion to IPv4, IPv6 is supported as well.
Due to updated checks it is even possible to have jails without
an IP address at all, which basically gives one a chroot with
restricted process view, no networking,..
SCTP support was updated and supports IPv6 in jails as well.
Cpuset support permits jails to be bound to specific processor
sets after creation.
Jails can have an unrestricted (no duplicate protection, etc.) name
in addition to the hostname. The jail name cannot be changed from
within a jail and is considered to be used for management purposes
or as audit-token in the future.
DDB 'show jails' command was added to aid debugging.
Proper compat support permits 32bit jail binaries to be used on 64bit
systems to manage jails. Also backward compatibility was preserved where
possible: for jail v1 syscalls, as well as with user space management
utilities.
Both jail as well as prison version were updated for the new features.
A gap was intentionally left as the intermediate versions had been
used by various patches floating around the last years.
Bump __FreeBSD_version for the afore mentioned and in kernel changes.
Special thanks to:
- Pawel Jakub Dawidek (pjd) for his multi-IPv4 patches
and Olivier Houchard (cognet) for initial single-IPv6 patches.
- Jeff Roberson (jeff) and Randall Stewart (rrs) for their
help, ideas and review on cpuset and SCTP support.
- Robert Watson (rwatson) for lots and lots of help, discussions,
suggestions and review of most of the patch at various stages.
- John Baldwin (jhb) for his help.
- Simon L. Nielsen (simon) as early adopter testing changes
on cluster machines as well as all the testers and people
who provided feedback the last months on freebsd-jail and
other channels.
- My employer, CK Software GmbH, for the support so I could work on this.
Reviewed by: (see above)
MFC after: 3 months (this is just so that I get the mail)
X-MFC Before: 7.2-RELEASE if possible
2008-11-29 14:32:14 +00:00
|
|
|
|
2008-05-24 06:22:16 +00:00
|
|
|
#ifdef KDTRACE_HOOKS
|
|
|
|
/*
|
|
|
|
* Tell the DTrace fasttrap provider about the exit if it
|
|
|
|
* has declared an interest.
|
|
|
|
*/
|
|
|
|
if (dtrace_fasttrap_exit)
|
|
|
|
dtrace_fasttrap_exit(p);
|
|
|
|
#endif
|
|
|
|
|
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
|
|
|
|
2008-05-24 06:22:16 +00:00
|
|
|
#ifdef KDTRACE_HOOKS
|
|
|
|
int reason = CLD_EXITED;
|
|
|
|
if (WCOREDUMP(rv))
|
|
|
|
reason = CLD_DUMPED;
|
|
|
|
else if (WIFSIGNALED(rv))
|
|
|
|
reason = CLD_KILLED;
|
|
|
|
SDT_PROBE(proc, kernel, , exit, reason, 0, 0, 0, 0);
|
|
|
|
#endif
|
|
|
|
|
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);
|
2009-04-20 14:34:55 +00:00
|
|
|
|
1997-09-13 19:42:29 +00:00
|
|
|
/*
|
2009-04-20 14:34:55 +00:00
|
|
|
* Notify parent, so in case he was wait(2)ing or
|
2009-04-20 15:10:03 +00:00
|
|
|
* executing waitpid(2) with our pid, he will
|
1997-09-13 19:42:29 +00:00
|
|
|
* continue.
|
|
|
|
*/
|
2009-04-20 14:34:55 +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);
|
2005-11-08 09:09:26 +00:00
|
|
|
else if (p->p_sigparent != 0) {
|
|
|
|
if (p->p_sigparent == SIGCHLD)
|
|
|
|
childproc_exited(p);
|
|
|
|
else /* LINUX thread */
|
|
|
|
psignal(p->p_pptr, p->p_sigparent);
|
|
|
|
}
|
2002-05-02 15:09:58 +00:00
|
|
|
sx_xunlock(&proctree_lock);
|
2002-12-10 02:33:45 +00:00
|
|
|
|
2006-10-21 23:59:15 +00:00
|
|
|
/*
|
|
|
|
* The state PRS_ZOMBIE prevents other proesses from sending
|
|
|
|
* signal to the process, to avoid memory leak, we free memory
|
|
|
|
* for signal queue at the time when the state is set.
|
|
|
|
*/
|
|
|
|
sigqueue_flush(&p->p_sigqueue);
|
|
|
|
sigqueue_flush(&td->td_sigqueue);
|
|
|
|
|
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
|
2005-07-18 20:08:14 +00:00
|
|
|
* marked as a zombie. We also have to set the zombie state
|
|
|
|
* before we release the parent process' proc lock to avoid
|
|
|
|
* a lost wakeup. So, we first call wakeup, then we grab the
|
|
|
|
* sched lock, update the state, and release the parent process'
|
|
|
|
* proc lock.
|
2001-09-10 04:28:58 +00:00
|
|
|
*/
|
2005-07-18 20:08:14 +00:00
|
|
|
wakeup(p->p_pptr);
|
2008-12-05 20:50:24 +00:00
|
|
|
cv_broadcast(&p->p_pwait);
|
Commit 14/14 of sched_lock decomposition.
- Use thread_lock() rather than sched_lock for per-thread scheduling
sychronization.
- Use the per-process spinlock rather than the sched_lock for per-process
scheduling synchronization.
Tested by: kris, current@
Tested on: i386, amd64, ULE, 4BSD, libthr, libkse, PREEMPTION, etc.
Discussed with: kris, attilio, kmacy, jhb, julian, bde (small parts each)
2007-06-05 00:00:57 +00:00
|
|
|
sched_exit(p->p_pptr, td);
|
|
|
|
PROC_SLOCK(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
|
|
|
p->p_state = PRS_ZOMBIE;
|
2002-05-02 15:09:58 +00:00
|
|
|
PROC_UNLOCK(p->p_pptr);
|
2004-06-21 14:03:38 +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);
|
|
|
|
|
2007-06-09 18:56:11 +00:00
|
|
|
/*
|
|
|
|
* Save our children's rusage information in our exit rusage.
|
|
|
|
*/
|
|
|
|
ruadd(&p->p_ru, &p->p_rux, &p->p_stats->p_cru, &p->p_crux);
|
|
|
|
|
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
|
|
|
}
|
|
|
|
|
2005-12-23 11:58:42 +00:00
|
|
|
|
|
|
|
#ifndef _SYS_SYSPROTO_H_
|
|
|
|
struct abort2_args {
|
|
|
|
char *why;
|
|
|
|
int nargs;
|
|
|
|
void **args;
|
|
|
|
};
|
|
|
|
#endif
|
|
|
|
|
|
|
|
int
|
|
|
|
abort2(struct thread *td, struct abort2_args *uap)
|
|
|
|
{
|
|
|
|
struct proc *p = td->td_proc;
|
|
|
|
struct sbuf *sb;
|
|
|
|
void *uargs[16];
|
|
|
|
int error, i, sig;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Do it right now so we can log either proper call of abort2(), or
|
|
|
|
* note, that invalid argument was passed. 512 is big enough to
|
|
|
|
* handle 16 arguments' descriptions with additional comments.
|
|
|
|
*/
|
|
|
|
sb = sbuf_new(NULL, NULL, 512, SBUF_FIXEDLEN);
|
|
|
|
sbuf_clear(sb);
|
|
|
|
sbuf_printf(sb, "%s(pid %d uid %d) aborted: ",
|
|
|
|
p->p_comm, p->p_pid, td->td_ucred->cr_uid);
|
|
|
|
/*
|
|
|
|
* Since we can't return from abort2(), send SIGKILL in cases, where
|
|
|
|
* abort2() was called improperly
|
|
|
|
*/
|
|
|
|
sig = SIGKILL;
|
|
|
|
/* Prevent from DoSes from user-space. */
|
|
|
|
if (uap->nargs < 0 || uap->nargs > 16)
|
|
|
|
goto out;
|
2008-03-22 16:32:52 +00:00
|
|
|
if (uap->nargs > 0) {
|
|
|
|
if (uap->args == NULL)
|
|
|
|
goto out;
|
|
|
|
error = copyin(uap->args, uargs, uap->nargs * sizeof(void *));
|
|
|
|
if (error != 0)
|
|
|
|
goto out;
|
|
|
|
}
|
2005-12-23 11:58:42 +00:00
|
|
|
/*
|
|
|
|
* Limit size of 'reason' string to 128. Will fit even when
|
|
|
|
* maximal number of arguments was chosen to be logged.
|
|
|
|
*/
|
|
|
|
if (uap->why != NULL) {
|
|
|
|
error = sbuf_copyin(sb, uap->why, 128);
|
|
|
|
if (error < 0)
|
|
|
|
goto out;
|
|
|
|
} else {
|
|
|
|
sbuf_printf(sb, "(null)");
|
|
|
|
}
|
2008-03-22 16:32:52 +00:00
|
|
|
if (uap->nargs > 0) {
|
2005-12-23 11:58:42 +00:00
|
|
|
sbuf_printf(sb, "(");
|
|
|
|
for (i = 0;i < uap->nargs; i++)
|
|
|
|
sbuf_printf(sb, "%s%p", i == 0 ? "" : ", ", uargs[i]);
|
|
|
|
sbuf_printf(sb, ")");
|
|
|
|
}
|
|
|
|
/*
|
|
|
|
* Final stage: arguments were proper, string has been
|
|
|
|
* successfully copied from userspace, and copying pointers
|
|
|
|
* from user-space succeed.
|
|
|
|
*/
|
|
|
|
sig = SIGABRT;
|
|
|
|
out:
|
|
|
|
if (sig == SIGKILL) {
|
|
|
|
sbuf_trim(sb);
|
|
|
|
sbuf_printf(sb, " (Reason text inaccessible)");
|
|
|
|
}
|
|
|
|
sbuf_cat(sb, "\n");
|
|
|
|
sbuf_finish(sb);
|
|
|
|
log(LOG_INFO, "%s", sbuf_data(sb));
|
|
|
|
sbuf_delete(sb);
|
|
|
|
exit1(td, W_EXITCODE(0, sig));
|
|
|
|
return (0);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
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().
|
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().
|
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
|
|
|
}
|
|
|
|
|
2009-06-08 15:26:09 +00:00
|
|
|
/*
|
|
|
|
* Reap the remains of a zombie process and optionally return status and
|
|
|
|
* rusage. Asserts and will release both the proctree_lock and the process
|
|
|
|
* lock as part of its work.
|
|
|
|
*/
|
|
|
|
static void
|
|
|
|
proc_reap(struct thread *td, struct proc *p, int *status, int options,
|
|
|
|
struct rusage *rusage)
|
|
|
|
{
|
|
|
|
INIT_VPROCG(P_TO_VPROCG(p));
|
|
|
|
struct proc *q, *t;
|
|
|
|
|
|
|
|
sx_assert(&proctree_lock, SA_XLOCKED);
|
|
|
|
PROC_LOCK_ASSERT(p, MA_OWNED);
|
|
|
|
PROC_SLOCK_ASSERT(p, MA_OWNED);
|
|
|
|
KASSERT(p->p_state == PRS_ZOMBIE, ("proc_reap: !PRS_ZOMBIE"));
|
|
|
|
|
|
|
|
q = td->td_proc;
|
|
|
|
if (rusage) {
|
|
|
|
*rusage = p->p_ru;
|
|
|
|
calcru(p, &rusage->ru_utime, &rusage->ru_stime);
|
|
|
|
}
|
|
|
|
PROC_SUNLOCK(p);
|
|
|
|
td->td_retval[0] = p->p_pid;
|
|
|
|
if (status)
|
|
|
|
*status = p->p_xstat; /* convert to int */
|
|
|
|
if (options & WNOWAIT) {
|
|
|
|
/*
|
|
|
|
* Only poll, returning the status. Caller does not wish to
|
|
|
|
* release the proc struct just yet.
|
|
|
|
*/
|
|
|
|
PROC_UNLOCK(p);
|
|
|
|
sx_xunlock(&proctree_lock);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
PROC_LOCK(q);
|
|
|
|
sigqueue_take(p->p_ksi);
|
|
|
|
PROC_UNLOCK(q);
|
|
|
|
PROC_UNLOCK(p);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* If we got the child via a ptrace 'attach', we need to give it back
|
|
|
|
* to the old parent.
|
|
|
|
*/
|
|
|
|
if (p->p_oppid && (t = pfind(p->p_oppid)) != NULL) {
|
|
|
|
PROC_LOCK(p);
|
|
|
|
p->p_oppid = 0;
|
|
|
|
proc_reparent(p, t);
|
|
|
|
PROC_UNLOCK(p);
|
|
|
|
tdsignal(t, NULL, SIGCHLD, p->p_ksi);
|
|
|
|
wakeup(t);
|
|
|
|
cv_broadcast(&p->p_pwait);
|
|
|
|
PROC_UNLOCK(t);
|
|
|
|
sx_xunlock(&proctree_lock);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Remove other references to this process to ensure we have an
|
|
|
|
* exclusive reference.
|
|
|
|
*/
|
|
|
|
sx_xlock(&allproc_lock);
|
|
|
|
LIST_REMOVE(p, p_list); /* off zombproc */
|
|
|
|
sx_xunlock(&allproc_lock);
|
|
|
|
LIST_REMOVE(p, p_sibling);
|
|
|
|
leavepgrp(p);
|
|
|
|
sx_xunlock(&proctree_lock);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* 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.
|
|
|
|
*/
|
|
|
|
PROC_LOCK(p);
|
|
|
|
p->p_xstat = 0; /* XXX: why? */
|
|
|
|
PROC_UNLOCK(p);
|
|
|
|
PROC_LOCK(q);
|
|
|
|
ruadd(&q->p_stats->p_cru, &q->p_crux, &p->p_ru, &p->p_rux);
|
|
|
|
PROC_UNLOCK(q);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Decrement the count of procs running with this uid.
|
|
|
|
*/
|
|
|
|
(void)chgproccnt(p->p_ucred->cr_ruidinfo, -1, 0);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Free credentials, arguments, and sigacts.
|
|
|
|
*/
|
|
|
|
crfree(p->p_ucred);
|
|
|
|
p->p_ucred = NULL;
|
|
|
|
pargs_drop(p->p_args);
|
|
|
|
p->p_args = NULL;
|
|
|
|
sigacts_free(p->p_sigacts);
|
|
|
|
p->p_sigacts = NULL;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Do any thread-system specific cleanups.
|
|
|
|
*/
|
|
|
|
thread_wait(p);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Give vm and machine-dependent layer a chance to free anything that
|
|
|
|
* cpu_exit couldn't release while still running in process context.
|
|
|
|
*/
|
|
|
|
vm_waitproc(p);
|
|
|
|
#ifdef MAC
|
|
|
|
mac_proc_destroy(p);
|
|
|
|
#endif
|
|
|
|
KASSERT(FIRST_THREAD_IN_PROC(p),
|
|
|
|
("proc_reap: no residual thread!"));
|
|
|
|
uma_zfree(proc_zone, p);
|
|
|
|
sx_xlock(&allproc_lock);
|
|
|
|
nprocs--;
|
|
|
|
#ifdef VIMAGE
|
|
|
|
vprocg->nprocs--;
|
|
|
|
#endif
|
|
|
|
sx_xunlock(&allproc_lock);
|
|
|
|
}
|
|
|
|
|
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
|
|
|
{
|
2009-06-08 15:26:09 +00:00
|
|
|
struct proc *p, *q;
|
2004-09-24 20:27:04 +00:00
|
|
|
int error, nfound;
|
1994-05-24 10:09:53 +00:00
|
|
|
|
2009-06-27 13:58:44 +00:00
|
|
|
AUDIT_ARG_PID(pid);
|
2009-07-01 12:36:10 +00:00
|
|
|
AUDIT_ARG_VALUE(options);
|
2006-02-06 00:19:09 +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);
|
|
|
|
}
|
2008-08-26 12:37:16 +00:00
|
|
|
if (options &~ (WUNTRACED|WNOHANG|WCONTINUED|WNOWAIT|WLINUXCLONE))
|
2002-04-09 20:00:40 +00:00
|
|
|
return (EINVAL);
|
1994-05-24 10:09:53 +00:00
|
|
|
loop:
|
2005-04-19 12:31:15 +00:00
|
|
|
if (q->p_flag & P_STATCHILD) {
|
|
|
|
PROC_LOCK(q);
|
|
|
|
q->p_flag &= ~P_STATCHILD;
|
|
|
|
PROC_UNLOCK(q);
|
|
|
|
}
|
1994-05-24 10:09:53 +00:00
|
|
|
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);
|
2005-04-18 13:36:57 +00:00
|
|
|
continue;
|
|
|
|
}
|
|
|
|
if (p_canwait(td, p)) {
|
|
|
|
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++;
|
2007-06-09 18:56:11 +00:00
|
|
|
PROC_SLOCK(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
|
|
|
if (p->p_state == PRS_ZOMBIE) {
|
2009-06-08 15:26:09 +00:00
|
|
|
proc_reap(td, p, status, options, rusage);
|
2002-05-02 15:09:58 +00:00
|
|
|
return (0);
|
1994-05-24 10:09:53 +00:00
|
|
|
}
|
2005-05-05 06:42:02 +00:00
|
|
|
if ((p->p_flag & P_STOPPED_SIG) &&
|
|
|
|
(p->p_suspcount == p->p_numthreads) &&
|
2004-09-24 20:27:04 +00:00
|
|
|
(p->p_flag & P_WAITED) == 0 &&
|
2004-03-17 20:00:00 +00:00
|
|
|
(p->p_flag & P_TRACED || options & WUNTRACED)) {
|
Commit 14/14 of sched_lock decomposition.
- Use thread_lock() rather than sched_lock for per-thread scheduling
sychronization.
- Use the per-process spinlock rather than the sched_lock for per-process
scheduling synchronization.
Tested by: kris, current@
Tested on: i386, amd64, ULE, 4BSD, libthr, libkse, PREEMPTION, etc.
Discussed with: kris, attilio, kmacy, jhb, julian, bde (small parts each)
2007-06-05 00:00:57 +00:00
|
|
|
PROC_SUNLOCK(p);
|
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);
|
2005-11-08 09:09:26 +00:00
|
|
|
|
|
|
|
PROC_LOCK(q);
|
|
|
|
sigqueue_take(p->p_ksi);
|
|
|
|
PROC_UNLOCK(q);
|
2006-10-24 12:04:21 +00:00
|
|
|
PROC_UNLOCK(p);
|
2005-11-08 09:09:26 +00:00
|
|
|
|
2004-03-17 20:00:00 +00:00
|
|
|
return (0);
|
1994-05-24 10:09:53 +00:00
|
|
|
}
|
Commit 14/14 of sched_lock decomposition.
- Use thread_lock() rather than sched_lock for per-thread scheduling
sychronization.
- Use the per-process spinlock rather than the sched_lock for per-process
scheduling synchronization.
Tested by: kris, current@
Tested on: i386, amd64, ULE, 4BSD, libthr, libkse, PREEMPTION, etc.
Discussed with: kris, attilio, kmacy, jhb, julian, bde (small parts each)
2007-06-05 00:00:57 +00:00
|
|
|
PROC_SUNLOCK(p);
|
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;
|
|
|
|
|
2005-11-08 09:09:26 +00:00
|
|
|
PROC_LOCK(q);
|
|
|
|
sigqueue_take(p->p_ksi);
|
|
|
|
PROC_UNLOCK(q);
|
2006-10-24 12:04:21 +00:00
|
|
|
PROC_UNLOCK(p);
|
2005-11-08 09:09:26 +00:00
|
|
|
|
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);
|
2005-04-19 08:07:28 +00:00
|
|
|
if (q->p_flag & P_STATCHILD) {
|
|
|
|
q->p_flag &= ~P_STATCHILD;
|
|
|
|
error = 0;
|
|
|
|
} else
|
|
|
|
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;
|
|
|
|
|
2006-10-25 06:18:04 +00:00
|
|
|
PROC_LOCK(child->p_pptr);
|
|
|
|
sigqueue_take(child->p_ksi);
|
|
|
|
PROC_UNLOCK(child->p_pptr);
|
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;
|
|
|
|
}
|