[apple/xnu.git] / bsd / kern / kern_proc.c

/*
 * Copyright (c) 2000-2002 Apple Computer, Inc. All rights reserved.
 *
 * @APPLE_LICENSE_HEADER_START@
 * 
 * Copyright (c) 1999-2003 Apple Computer, Inc.  All Rights Reserved.
 * 
 * This file contains Original Code and/or Modifications of Original Code
 * as defined in and that are subject to the Apple Public Source License
 * Version 2.0 (the 'License'). You may not use this file except in
 * compliance with the License. Please obtain a copy of the License at
 * http://www.opensource.apple.com/apsl/ and read it before using this
 * file.
 * 
 * The Original Code and all software distributed under the License are
 * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
 * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
 * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
 * Please see the License for the specific language governing rights and
 * limitations under the License.
 * 
 * @APPLE_LICENSE_HEADER_END@
 */
/* Copyright (c) 1995 NeXT Computer, Inc. All Rights Reserved */
/*
 * Copyright (c) 1982, 1986, 1989, 1991, 1993
 *	The Regents of the University of California.  All rights reserved.
 *
 * 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.
 * 3. All advertising materials mentioning features or use of this software
 *    must display the following acknowledgement:
 *	This product includes software developed by the University of
 *	California, Berkeley and its contributors.
 * 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_proc.c	8.4 (Berkeley) 1/4/94
 */
/* HISTORY
 *  04-Aug-97  Umesh Vaishampayan (umeshv@apple.com)
 *	Added current_proc_EXTERNAL() function for the use of kernel
 * 	lodable modules.
 *
 *  05-Jun-95 Mac Gillon (mgillon) at NeXT
 *	New version based on 3.3NS and 4.4
 */


#include <sys/param.h>
#include <sys/systm.h>
#include <sys/kernel.h>
#include <sys/proc.h>
#include <sys/buf.h>
#include <sys/acct.h>
#include <sys/wait.h>
#include <sys/file.h>
#include <ufs/ufs/quota.h>
#include <sys/uio.h>
#include <sys/malloc.h>
#include <sys/mbuf.h>
#include <sys/ioctl.h>
#include <sys/tty.h>
#include <sys/signalvar.h>

/*
 * Structure associated with user cacheing.
 */
struct uidinfo {
	LIST_ENTRY(uidinfo) ui_hash;
	uid_t	ui_uid;
	long	ui_proccnt;
};
#define	UIHASH(uid)	(&uihashtbl[(uid) & uihash])
LIST_HEAD(uihashhead, uidinfo) *uihashtbl;
u_long uihash;		/* size of hash table - 1 */

/*
 * Other process lists
 */
struct pidhashhead *pidhashtbl;
u_long pidhash;
struct pgrphashhead *pgrphashtbl;
u_long pgrphash;
struct proclist allproc;
struct proclist zombproc;

/*
 * Initialize global process hashing structures.
 */
void
procinit()
{

	LIST_INIT(&allproc);
	LIST_INIT(&zombproc);
	pidhashtbl = hashinit(maxproc / 4, M_PROC, &pidhash);
	pgrphashtbl = hashinit(maxproc / 4, M_PROC, &pgrphash);
	uihashtbl = hashinit(maxproc / 16, M_PROC, &uihash);
}

/*
 * Change the count associated with number of processes
 * a given user is using.
 */
int
chgproccnt(uid, diff)
	uid_t	uid;
	int	diff;
{
	register struct uidinfo *uip;
	register struct uihashhead *uipp;

	uipp = UIHASH(uid);
	for (uip = uipp->lh_first; uip != 0; uip = uip->ui_hash.le_next)
		if (uip->ui_uid == uid)
			break;
	if (uip) {
		uip->ui_proccnt += diff;
		if (uip->ui_proccnt > 0)
			return (uip->ui_proccnt);
		if (uip->ui_proccnt < 0)
			panic("chgproccnt: procs < 0");
		LIST_REMOVE(uip, ui_hash);
		FREE_ZONE(uip, sizeof *uip, M_PROC);
		return (0);
	}
	if (diff <= 0) {
		if (diff == 0)
			return(0);
		panic("chgproccnt: lost user");
	}
	MALLOC_ZONE(uip, struct uidinfo *, sizeof(*uip), M_PROC, M_WAITOK);
	LIST_INSERT_HEAD(uipp, uip, ui_hash);
	uip->ui_uid = uid;
	uip->ui_proccnt = diff;
	return (diff);
}

/*
 * Is p an inferior of the current process?
 */
int
inferior(p)
	register struct proc *p;
{

	for (; p != current_proc(); p = p->p_pptr)
		if (p->p_pid == 0)
			return (0);
	return (1);
}
/*
 * Is p an inferior of t ?
 */
int
isinferior(p, t)
	register struct proc *p;
	register struct proc *t;
{

	/* if p==t they are not inferior */
	if (p == t)
		return(0);
	for (; p != t; p = p->p_pptr)
		if (p->p_pid == 0)
			return (0);
	return (1);
}

/*
 * Locate a process by number
 */
struct proc *
pfind(pid)
	register pid_t pid;
{
	register struct proc *p;

	if (!pid)
		return (kernproc);

	for (p = PIDHASH(pid)->lh_first; p != 0; p = p->p_hash.le_next)
		if (p->p_pid == pid)
			return (p);
	return (NULL);
}

/*
 * Locate a zombie by PID
 */
__private_extern__ struct proc *
pzfind(pid)
	register pid_t pid;
{
	register struct proc *p;

	for (p = zombproc.lh_first; p != 0; p = p->p_list.le_next)
		if (p->p_pid == pid)
			return (p);
	return (NULL);
}

/*
 * Locate a process group by number
 */
struct pgrp *
pgfind(pgid)
	register pid_t pgid;
{
	register struct pgrp *pgrp;

	for (pgrp = PGRPHASH(pgid)->lh_first; pgrp != 0; pgrp = pgrp->pg_hash.le_next)
		if (pgrp->pg_id == pgid)
			return (pgrp);
	return (NULL);
}


/*
 * Move p to a new or existing process group (and session)
 */
int
enterpgrp(p, pgid, mksess)
	register struct proc *p;
	pid_t pgid;
	int mksess;
{
	register struct pgrp *pgrp = pgfind(pgid);

#if DIAGNOSTIC
	if (pgrp != NULL && mksess)	/* firewalls */
		panic("enterpgrp: setsid into non-empty pgrp");
	if (SESS_LEADER(p))
		panic("enterpgrp: session leader attempted setpgrp");
#endif
	if (pgrp == NULL) {
		pid_t savepid = p->p_pid;
		struct proc *np;
		/*
		 * new process group
		 */
#if DIAGNOSTIC
		if (p->p_pid != pgid)
			panic("enterpgrp: new pgrp and pid != pgid");
#endif
		MALLOC_ZONE(pgrp, struct pgrp *, sizeof(struct pgrp), M_PGRP,
		    M_WAITOK);
		if ((np = pfind(savepid)) == NULL || np != p) {
			FREE_ZONE(pgrp, sizeof(struct pgrp), M_PGRP);
			return (ESRCH);
		}
		if (mksess) {
			register struct session *sess;

			/*
			 * new session
			 */
			MALLOC_ZONE(sess, struct session *,
				sizeof(struct session), M_SESSION, M_WAITOK);
			sess->s_leader = p;
			sess->s_sid = p->p_pid;
			sess->s_count = 1;
			sess->s_ttyvp = NULL;
			sess->s_ttyp = NULL;
			bcopy(p->p_session->s_login, sess->s_login,
			    sizeof(sess->s_login));
			p->p_flag &= ~P_CONTROLT;
			pgrp->pg_session = sess;
#if DIAGNOSTIC
			if (p != current_proc())
				panic("enterpgrp: mksession and p != curproc");
#endif
		} else {
			pgrp->pg_session = p->p_session;
			pgrp->pg_session->s_count++;
		}
		pgrp->pg_id = pgid;
		LIST_INIT(&pgrp->pg_members);
		LIST_INSERT_HEAD(PGRPHASH(pgid), pgrp, pg_hash);
		pgrp->pg_jobc = 0;
	} else if (pgrp == p->p_pgrp)
		return (0);

	/*
	 * Adjust eligibility of affected pgrps to participate in job control.
	 * Increment eligibility counts before decrementing, otherwise we
	 * could reach 0 spuriously during the first call.
	 */
	fixjobc(p, pgrp, 1);
	fixjobc(p, p->p_pgrp, 0);

	LIST_REMOVE(p, p_pglist);
	if (p->p_pgrp->pg_members.lh_first == 0)
		pgdelete(p->p_pgrp);
	p->p_pgrp = pgrp;
	LIST_INSERT_HEAD(&pgrp->pg_members, p, p_pglist);
	return (0);
}

/*
 * remove process from process group
 */
int
leavepgrp(p)
	register struct proc *p;
{

	LIST_REMOVE(p, p_pglist);
	if (p->p_pgrp->pg_members.lh_first == 0)
		pgdelete(p->p_pgrp);
	p->p_pgrp = 0;
	return (0);
}

/*
 * delete a process group
 */
void
pgdelete(pgrp)
	register struct pgrp *pgrp;
{

	if (pgrp->pg_session->s_ttyp != NULL && 
	    pgrp->pg_session->s_ttyp->t_pgrp == pgrp)
		pgrp->pg_session->s_ttyp->t_pgrp = NULL;
	LIST_REMOVE(pgrp, pg_hash);
	if (--pgrp->pg_session->s_count == 0)
		FREE_ZONE(pgrp->pg_session, sizeof(struct session), M_SESSION);
	FREE_ZONE(pgrp, sizeof *pgrp, M_PGRP);
}

void
sessrele(sess)
	struct session *sess;
{
	if (--sess->s_count == 0)
		FREE_ZONE(sess, sizeof (struct session), M_SESSION);
}

static void orphanpg();

/*
 * Adjust pgrp jobc counters when specified process changes process group.
 * We count the number of processes in each process group that "qualify"
 * the group for terminal job control (those with a parent in a different
 * process group of the same session).  If that count reaches zero, the
 * process group becomes orphaned.  Check both the specified process'
 * process group and that of its children.
 * entering == 0 => p is leaving specified group.
 * entering == 1 => p is entering specified group.
 */
void
fixjobc(p, pgrp, entering)
	register struct proc *p;
	register struct pgrp *pgrp;
	int entering;
{
	register struct pgrp *hispgrp;
	register struct session *mysession = pgrp->pg_session;

	/*
	 * Check p's parent to see whether p qualifies its own process
	 * group; if so, adjust count for p's process group.
	 */
	if ((hispgrp = p->p_pptr->p_pgrp) != pgrp &&
	    hispgrp->pg_session == mysession)
		if (entering)
			pgrp->pg_jobc++;
		else if (--pgrp->pg_jobc == 0)
			orphanpg(pgrp);

	/*
	 * Check this process' children to see whether they qualify
	 * their process groups; if so, adjust counts for children's
	 * process groups.
	 */
	for (p = p->p_children.lh_first; p != 0; p = p->p_sibling.le_next)
		if ((hispgrp = p->p_pgrp) != pgrp &&
		    hispgrp->pg_session == mysession &&
		    p->p_stat != SZOMB)
			if (entering)
				hispgrp->pg_jobc++;
			else if (--hispgrp->pg_jobc == 0)
				orphanpg(hispgrp);
}

/* 
 * A process group has become orphaned;
 * if there are any stopped processes in the group,
 * hang-up all process in that group.
 */
static void
orphanpg(pg)
	struct pgrp *pg;
{
	register struct proc *p;

	for (p = pg->pg_members.lh_first; p != 0; p = p->p_pglist.le_next) {
		if (p->p_stat == SSTOP) {
			for (p = pg->pg_members.lh_first; p != 0;
			    p = p->p_pglist.le_next) {
				pt_setrunnable(p);
				psignal(p, SIGHUP);
				psignal(p, SIGCONT);
			}
			return;
		}
	}
}

#ifdef DEBUG
void
pgrpdump()
{
	register struct pgrp *pgrp;
	register struct proc *p;
	register i;

	for (i = 0; i <= pgrphash; i++) {
		if (pgrp = pgrphashtbl[i].lh_first) {
			printf("\tindx %d\n", i);
			for (; pgrp != 0; pgrp = pgrp->pg_hash.le_next) {
				printf("\tpgrp 0x%08x, pgid %d, sess %p, sesscnt %d, mem %p\n",
				    pgrp, pgrp->pg_id, pgrp->pg_session,
				    pgrp->pg_session->s_count,
				    pgrp->pg_members.lh_first);
				for (p = pgrp->pg_members.lh_first; p != 0;
				    p = p->p_pglist.le_next) {
					printf("\t\tpid %d addr 0x%08x pgrp 0x%08x\n", 
					    p->p_pid, p, p->p_pgrp);
				}
			}
		}
	}
}
#endif /* DEBUG */

int
proc_is_classic(struct proc *p)
{
    return (p->p_flag & P_CLASSIC) ? 1 : 0;
}

struct proc * current_proc_EXTERNAL()
{
	return (current_proc());
}
Commit	Line	Data
1c79356b	1	/*
9bccf70c	2	* Copyright (c) 2000-2002 Apple Computer, Inc. All rights reserved.
1c79356b A	3	*
	4	* @APPLE_LICENSE_HEADER_START@
	5	*
43866e37	6	* Copyright (c) 1999-2003 Apple Computer, Inc. All Rights Reserved.
1c79356b	7	*
43866e37 A	8	* This file contains Original Code and/or Modifications of Original Code
	9	* as defined in and that are subject to the Apple Public Source License
	10	* Version 2.0 (the 'License'). You may not use this file except in
	11	* compliance with the License. Please obtain a copy of the License at
	12	* http://www.opensource.apple.com/apsl/ and read it before using this
	13	* file.
	14	*
	15	* The Original Code and all software distributed under the License are
	16	* distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
1c79356b A	17	* EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
1c79356b A	18	* INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
43866e37 A	19	* FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
	20	* Please see the License for the specific language governing rights and
	21	* limitations under the License.
1c79356b A	22	*
	23	* @APPLE_LICENSE_HEADER_END@
	24	*/
	25	/* Copyright (c) 1995 NeXT Computer, Inc. All Rights Reserved */
	26	/*
	27	* Copyright (c) 1982, 1986, 1989, 1991, 1993
	28	* The Regents of the University of California. All rights reserved.
	29	*
	30	* Redistribution and use in source and binary forms, with or without
	31	* modification, are permitted provided that the following conditions
	32	* are met:
	33	* 1. Redistributions of source code must retain the above copyright
	34	* notice, this list of conditions and the following disclaimer.
	35	* 2. Redistributions in binary form must reproduce the above copyright
	36	* notice, this list of conditions and the following disclaimer in the
	37	* documentation and/or other materials provided with the distribution.
	38	* 3. All advertising materials mentioning features or use of this software
	39	* must display the following acknowledgement:
	40	* This product includes software developed by the University of
	41	* California, Berkeley and its contributors.
	42	* 4. Neither the name of the University nor the names of its contributors
	43	* may be used to endorse or promote products derived from this software
	44	* without specific prior written permission.
	45	*
	46	* THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
	47	* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
	48	* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
	49	* ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
	50	* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
	51	* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
	52	* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
	53	* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
	54	* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
	55	* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
	56	* SUCH DAMAGE.
	57	*
	58	* @(#)kern_proc.c 8.4 (Berkeley) 1/4/94
	59	*/
	60	/* HISTORY
	61	* 04-Aug-97 Umesh Vaishampayan (umeshv@apple.com)
	62	* Added current_proc_EXTERNAL() function for the use of kernel
	63	* lodable modules.
	64	*
	65	* 05-Jun-95 Mac Gillon (mgillon) at NeXT
	66	* New version based on 3.3NS and 4.4
	67	*/
	68
	69
	70	#include <sys/param.h>
	71	#include <sys/systm.h>
	72	#include <sys/kernel.h>
	73	#include <sys/proc.h>
	74	#include <sys/buf.h>
	75	#include <sys/acct.h>
	76	#include <sys/wait.h>
	77	#include <sys/file.h>
	78	#include <ufs/ufs/quota.h>
	79	#include <sys/uio.h>
	80	#include <sys/malloc.h>
	81	#include <sys/mbuf.h>
	82	#include <sys/ioctl.h>
	83	#include <sys/tty.h>
	84	#include <sys/signalvar.h>
	85
86	/*
87	* Structure associated with user cacheing.
88	*/
89	struct uidinfo {
90	LIST_ENTRY(uidinfo) ui_hash;
91	uid_t ui_uid;
92	long ui_proccnt;
93	};
94	#define UIHASH(uid) (&uihashtbl[(uid) & uihash])
95	LIST_HEAD(uihashhead, uidinfo) *uihashtbl;
96	u_long uihash; /* size of hash table - 1 */
97
98	/*
99	* Other process lists
100	*/
101	struct pidhashhead *pidhashtbl;
102	u_long pidhash;
103	struct pgrphashhead *pgrphashtbl;
104	u_long pgrphash;
105	struct proclist allproc;
106	struct proclist zombproc;
107
108	/*
109	* Initialize global process hashing structures.
110	*/
111	void
112	procinit()
113	{
114
115	LIST_INIT(&allproc);
116	LIST_INIT(&zombproc);
117	pidhashtbl = hashinit(maxproc / 4, M_PROC, &pidhash);
118	pgrphashtbl = hashinit(maxproc / 4, M_PROC, &pgrphash);
119	uihashtbl = hashinit(maxproc / 16, M_PROC, &uihash);
120	}
121
122	/*
123	* Change the count associated with number of processes
124	* a given user is using.
125	*/
126	int
127	chgproccnt(uid, diff)
128	uid_t uid;
129	int diff;
130	{
131	register struct uidinfo *uip;
132	register struct uihashhead *uipp;
133
134	uipp = UIHASH(uid);
135	for (uip = uipp->lh_first; uip != 0; uip = uip->ui_hash.le_next)
136	if (uip->ui_uid == uid)
137	break;
138	if (uip) {
139	uip->ui_proccnt += diff;
140	if (uip->ui_proccnt > 0)
141	return (uip->ui_proccnt);
142	if (uip->ui_proccnt < 0)
143	panic("chgproccnt: procs < 0");
144	LIST_REMOVE(uip, ui_hash);
145	FREE_ZONE(uip, sizeof *uip, M_PROC);
146	return (0);
147	}
148	if (diff <= 0) {
149	if (diff == 0)
150	return(0);
151	panic("chgproccnt: lost user");
152	}
153	MALLOC_ZONE(uip, struct uidinfo , sizeof(uip), M_PROC, M_WAITOK);
154	LIST_INSERT_HEAD(uipp, uip, ui_hash);
155	uip->ui_uid = uid;
156	uip->ui_proccnt = diff;
157	return (diff);
158	}
159
160	/*
161	* Is p an inferior of the current process?
162	*/
163	int
164	inferior(p)
165	register struct proc *p;
166	{
167
168	for (; p != current_proc(); p = p->p_pptr)
169	if (p->p_pid == 0)
170	return (0);
171	return (1);
172	}
9bccf70c A	173	/*
	174	* Is p an inferior of t ?
	175	*/
	176	int
	177	isinferior(p, t)
	178	register struct proc *p;
	179	register struct proc *t;
	180	{
	181
	182	/* if p==t they are not inferior */
	183	if (p == t)
	184	return(0);
	185	for (; p != t; p = p->p_pptr)
	186	if (p->p_pid == 0)
	187	return (0);
	188	return (1);
	189	}
1c79356b A	190
	191	/*
	192	* Locate a process by number
	193	*/
	194	struct proc *
	195	pfind(pid)
	196	register pid_t pid;
	197	{
	198	register struct proc *p;
	199
	200	if (!pid)
	201	return (kernproc);
	202
	203	for (p = PIDHASH(pid)->lh_first; p != 0; p = p->p_hash.le_next)
	204	if (p->p_pid == pid)
	205	return (p);
	206	return (NULL);
	207	}
	208
55e303ae A	209	/*
	210	* Locate a zombie by PID
	211	*/
	212	__private_extern__ struct proc *
	213	pzfind(pid)
	214	register pid_t pid;
	215	{
	216	register struct proc *p;
	217
	218	for (p = zombproc.lh_first; p != 0; p = p->p_list.le_next)
	219	if (p->p_pid == pid)
	220	return (p);
	221	return (NULL);
	222	}
	223
1c79356b A	224	/*
	225	* Locate a process group by number
	226	*/
	227	struct pgrp *
	228	pgfind(pgid)
	229	register pid_t pgid;
	230	{
	231	register struct pgrp *pgrp;
	232
	233	for (pgrp = PGRPHASH(pgid)->lh_first; pgrp != 0; pgrp = pgrp->pg_hash.le_next)
	234	if (pgrp->pg_id == pgid)
	235	return (pgrp);
	236	return (NULL);
	237	}
	238
	239
	240	/*
	241	* Move p to a new or existing process group (and session)
	242	*/
	243	int
	244	enterpgrp(p, pgid, mksess)
	245	register struct proc *p;
	246	pid_t pgid;
	247	int mksess;
	248	{
	249	register struct pgrp *pgrp = pgfind(pgid);
	250
	251	#if DIAGNOSTIC
	252	if (pgrp != NULL && mksess) /* firewalls */
	253	panic("enterpgrp: setsid into non-empty pgrp");
	254	if (SESS_LEADER(p))
	255	panic("enterpgrp: session leader attempted setpgrp");
	256	#endif
	257	if (pgrp == NULL) {
	258	pid_t savepid = p->p_pid;
	259	struct proc *np;
	260	/*
	261	* new process group
	262	*/
	263	#if DIAGNOSTIC
	264	if (p->p_pid != pgid)
	265	panic("enterpgrp: new pgrp and pid != pgid");
	266	#endif
	267	MALLOC_ZONE(pgrp, struct pgrp *, sizeof(struct pgrp), M_PGRP,
	268	M_WAITOK);
9bccf70c A	269	if ((np = pfind(savepid)) == NULL \|\| np != p) {
9bccf70c A	270	FREE_ZONE(pgrp, sizeof(struct pgrp), M_PGRP);
1c79356b	271	return (ESRCH);
9bccf70c	272	}
1c79356b A	273	if (mksess) {
	274	register struct session *sess;
	275
	276	/*
	277	* new session
	278	*/
	279	MALLOC_ZONE(sess, struct session *,
	280	sizeof(struct session), M_SESSION, M_WAITOK);
	281	sess->s_leader = p;
9bccf70c	282	sess->s_sid = p->p_pid;
1c79356b A	283	sess->s_count = 1;
	284	sess->s_ttyvp = NULL;
	285	sess->s_ttyp = NULL;
	286	bcopy(p->p_session->s_login, sess->s_login,
	287	sizeof(sess->s_login));
	288	p->p_flag &= ~P_CONTROLT;
	289	pgrp->pg_session = sess;
	290	#if DIAGNOSTIC
	291	if (p != current_proc())
	292	panic("enterpgrp: mksession and p != curproc");
	293	#endif
	294	} else {
	295	pgrp->pg_session = p->p_session;
	296	pgrp->pg_session->s_count++;
	297	}
	298	pgrp->pg_id = pgid;
	299	LIST_INIT(&pgrp->pg_members);
	300	LIST_INSERT_HEAD(PGRPHASH(pgid), pgrp, pg_hash);
	301	pgrp->pg_jobc = 0;
	302	} else if (pgrp == p->p_pgrp)
	303	return (0);
	304
	305	/*
	306	* Adjust eligibility of affected pgrps to participate in job control.
	307	* Increment eligibility counts before decrementing, otherwise we
	308	* could reach 0 spuriously during the first call.
	309	*/
	310	fixjobc(p, pgrp, 1);
	311	fixjobc(p, p->p_pgrp, 0);
	312
	313	LIST_REMOVE(p, p_pglist);
	314	if (p->p_pgrp->pg_members.lh_first == 0)
	315	pgdelete(p->p_pgrp);
	316	p->p_pgrp = pgrp;
	317	LIST_INSERT_HEAD(&pgrp->pg_members, p, p_pglist);
	318	return (0);
	319	}
	320
	321	/*
	322	* remove process from process group
	323	*/
	324	int
	325	leavepgrp(p)
	326	register struct proc *p;
	327	{
	328
	329	LIST_REMOVE(p, p_pglist);
	330	if (p->p_pgrp->pg_members.lh_first == 0)
	331	pgdelete(p->p_pgrp);
	332	p->p_pgrp = 0;
	333	return (0);
	334	}
	335
	336	/*
	337	* delete a process group
	338	*/
	339	void
	340	pgdelete(pgrp)
	341	register struct pgrp *pgrp;
	342	{
	343
	344	if (pgrp->pg_session->s_ttyp != NULL &&
	345	pgrp->pg_session->s_ttyp->t_pgrp == pgrp)
	346	pgrp->pg_session->s_ttyp->t_pgrp = NULL;
347	LIST_REMOVE(pgrp, pg_hash);
348	if (--pgrp->pg_session->s_count == 0)
349	FREE_ZONE(pgrp->pg_session, sizeof(struct session), M_SESSION);
350	FREE_ZONE(pgrp, sizeof *pgrp, M_PGRP);
351	}
352
353	void
354	sessrele(sess)
355	struct session *sess;
356	{
357	if (--sess->s_count == 0)
358	FREE_ZONE(sess, sizeof (struct session), M_SESSION);
359	}
360
361	static void orphanpg();
362
363	/*
364	* Adjust pgrp jobc counters when specified process changes process group.
365	* We count the number of processes in each process group that "qualify"
366	* the group for terminal job control (those with a parent in a different
367	* process group of the same session). If that count reaches zero, the
368	* process group becomes orphaned. Check both the specified process'
369	* process group and that of its children.
370	* entering == 0 => p is leaving specified group.
371	* entering == 1 => p is entering specified group.
372	*/
373	void
374	fixjobc(p, pgrp, entering)
375	register struct proc *p;
376	register struct pgrp *pgrp;
377	int entering;
378	{
379	register struct pgrp *hispgrp;
380	register struct session *mysession = pgrp->pg_session;
381
382	/*
383	* Check p's parent to see whether p qualifies its own process
384	* group; if so, adjust count for p's process group.
385	*/
386	if ((hispgrp = p->p_pptr->p_pgrp) != pgrp &&
387	hispgrp->pg_session == mysession)
388	if (entering)
389	pgrp->pg_jobc++;
390	else if (--pgrp->pg_jobc == 0)
391	orphanpg(pgrp);
392
393	/*
394	* Check this process' children to see whether they qualify
395	* their process groups; if so, adjust counts for children's
396	* process groups.
397	*/
398	for (p = p->p_children.lh_first; p != 0; p = p->p_sibling.le_next)
399	if ((hispgrp = p->p_pgrp) != pgrp &&
400	hispgrp->pg_session == mysession &&
401	p->p_stat != SZOMB)
402	if (entering)
403	hispgrp->pg_jobc++;
404	else if (--hispgrp->pg_jobc == 0)
405	orphanpg(hispgrp);
406	}
407
408	/*
409	* A process group has become orphaned;
410	* if there are any stopped processes in the group,
411	* hang-up all process in that group.
412	*/
413	static void
414	orphanpg(pg)
415	struct pgrp *pg;
416	{
417	register struct proc *p;
418
419	for (p = pg->pg_members.lh_first; p != 0; p = p->p_pglist.le_next) {
420	if (p->p_stat == SSTOP) {
421	for (p = pg->pg_members.lh_first; p != 0;
422	p = p->p_pglist.le_next) {
423	pt_setrunnable(p);
424	psignal(p, SIGHUP);
425	psignal(p, SIGCONT);
426	}
427	return;
428	}
429	}
430	}
431
432	#ifdef DEBUG
433	void
434	pgrpdump()
435	{
436	register struct pgrp *pgrp;
437	register struct proc *p;
438	register i;
439
440	for (i = 0; i <= pgrphash; i++) {
441	if (pgrp = pgrphashtbl[i].lh_first) {
442	printf("\tindx %d\n", i);
443	for (; pgrp != 0; pgrp = pgrp->pg_hash.le_next) {
444	printf("\tpgrp 0x%08x, pgid %d, sess %p, sesscnt %d, mem %p\n",
445	pgrp, pgrp->pg_id, pgrp->pg_session,
446	pgrp->pg_session->s_count,
447	pgrp->pg_members.lh_first);
448	for (p = pgrp->pg_members.lh_first; p != 0;
449	p = p->p_pglist.le_next) {
450	printf("\t\tpid %d addr 0x%08x pgrp 0x%08x\n",
451	p->p_pid, p, p->p_pgrp);
452	}
453	}
454	}
455	}
456	}
457	#endif /* DEBUG */
458
55e303ae A	459	int
	460	proc_is_classic(struct proc *p)
	461	{
	462	return (p->p_flag & P_CLASSIC) ? 1 : 0;
	463	}
	464
1c79356b A	465	struct proc * current_proc_EXTERNAL()
	466	{
	467	return (current_proc());
	468	}