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