xref: /openbsd-src/sys/kern/kern_proc.c (revision d874cce4b1d9fe6b41c9e4f2117a77d8a4a37b92) 
1 /*	$OpenBSD: kern_proc.c,v 1.36 2007/10/10 15:53:53 art Exp $	*/
2 /*	$NetBSD: kern_proc.c,v 1.14 1996/02/09 18:59:41 christos Exp $	*/
3 
4 /*
5  * Copyright (c) 1982, 1986, 1989, 1991, 1993
6  *	The Regents of the University of California.  All rights reserved.
7  *
8  * Redistribution and use in source and binary forms, with or without
9  * modification, are permitted provided that the following conditions
10  * are met:
11  * 1. Redistributions of source code must retain the above copyright
12  *    notice, this list of conditions and the following disclaimer.
13  * 2. Redistributions in binary form must reproduce the above copyright
14  *    notice, this list of conditions and the following disclaimer in the
15  *    documentation and/or other materials provided with the distribution.
16  * 3. Neither the name of the University nor the names of its contributors
17  *    may be used to endorse or promote products derived from this software
18  *    without specific prior written permission.
19  *
20  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
21  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
22  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
23  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
24  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
25  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
26  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
27  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
28  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
29  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
30  * SUCH DAMAGE.
31  *
32  *	@(#)kern_proc.c	8.4 (Berkeley) 1/4/94
33  */
34 
35 #include <sys/param.h>
36 #include <sys/systm.h>
37 #include <sys/kernel.h>
38 #include <sys/proc.h>
39 #include <sys/buf.h>
40 #include <sys/acct.h>
41 #include <sys/wait.h>
42 #include <sys/file.h>
43 #include <ufs/ufs/quota.h>
44 #include <sys/uio.h>
45 #include <sys/malloc.h>
46 #include <sys/mbuf.h>
47 #include <sys/ioctl.h>
48 #include <sys/tty.h>
49 #include <sys/signalvar.h>
50 #include <sys/pool.h>
51 
52 #define	UIHASH(uid)	(&uihashtbl[(uid) & uihash])
53 LIST_HEAD(uihashhead, uidinfo) *uihashtbl;
54 u_long uihash;		/* size of hash table - 1 */
55 
56 /*
57  * Other process lists
58  */
59 struct pidhashhead *pidhashtbl;
60 u_long pidhash;
61 struct pgrphashhead *pgrphashtbl;
62 u_long pgrphash;
63 struct proclist allproc;
64 struct proclist zombproc;
65 
66 struct pool proc_pool;
67 struct pool process_pool;
68 struct pool rusage_pool;
69 struct pool ucred_pool;
70 struct pool pgrp_pool;
71 struct pool session_pool;
72 struct pool pcred_pool;
73 
74 static void orphanpg(struct pgrp *);
75 #ifdef DEBUG
76 void pgrpdump(void);
77 #endif
78 
79 /*
80  * Initialize global process hashing structures.
81  */
82 void
83 procinit(void)
84 {
85 	LIST_INIT(&allproc);
86 	LIST_INIT(&zombproc);
87 
88 
89 	pidhashtbl = hashinit(maxproc / 4, M_PROC, M_NOWAIT, &pidhash);
90 	pgrphashtbl = hashinit(maxproc / 4, M_PROC, M_NOWAIT, &pgrphash);
91 	uihashtbl = hashinit(maxproc / 16, M_PROC, M_NOWAIT, &uihash);
92 	if (!pidhashtbl || !pgrphashtbl || !uihashtbl)
93 		panic("procinit: malloc");
94 
95 	pool_init(&proc_pool, sizeof(struct proc), 0, 0, 0, "procpl",
96 	    &pool_allocator_nointr);
97 	pool_init(&process_pool, sizeof(struct process), 0, 0, 0, "processpl",
98 	    &pool_allocator_nointr);
99 	pool_init(&rusage_pool, sizeof(struct rusage), 0, 0, 0, "zombiepl",
100 	    &pool_allocator_nointr);
101 	pool_init(&ucred_pool, sizeof(struct ucred), 0, 0, 0, "ucredpl",
102 	    &pool_allocator_nointr);
103 	pool_init(&pgrp_pool, sizeof(struct pgrp), 0, 0, 0, "pgrppl",
104 	    &pool_allocator_nointr);
105 	pool_init(&session_pool, sizeof(struct session), 0, 0, 0, "sessionpl",
106 	    &pool_allocator_nointr);
107 	pool_init(&pcred_pool, sizeof(struct pcred), 0, 0, 0, "pcredpl",
108 	    &pool_allocator_nointr);
109 }
110 
111 /*
112  * Change the count associated with number of processes
113  * a given user is using.
114  */
115 struct uidinfo *
116 uid_find(uid_t uid)
117 {
118 	struct uidinfo *uip, *nuip;
119 	struct uihashhead *uipp;
120 
121 	uipp = UIHASH(uid);
122 	LIST_FOREACH(uip, uipp, ui_hash)
123 		if (uip->ui_uid == uid)
124 			break;
125 	if (uip)
126 		return (uip);
127 	nuip = malloc(sizeof(*nuip), M_PROC, M_WAITOK|M_ZERO);
128 	LIST_FOREACH(uip, uipp, ui_hash)
129 		if (uip->ui_uid == uid)
130 			break;
131 	if (uip) {
132 		free(nuip, M_PROC);
133 		return (uip);
134 	}
135 	nuip->ui_uid = uid;
136 	LIST_INSERT_HEAD(uipp, nuip, ui_hash);
137 
138 	return (nuip);
139 }
140 
141 int
142 chgproccnt(uid_t uid, int diff)
143 {
144 	struct uidinfo *uip;
145 
146 	uip = uid_find(uid);
147 	uip->ui_proccnt += diff;
148 	if (uip->ui_proccnt < 0)
149 		panic("chgproccnt: procs < 0");
150 	return (uip->ui_proccnt);
151 }
152 
153 /*
154  * Is p an inferior of the current process?
155  */
156 int
157 inferior(struct proc *p)
158 {
159 
160 	for (; p != curproc; p = p->p_pptr)
161 		if (p->p_pid == 0)
162 			return (0);
163 	return (1);
164 }
165 
166 /*
167  * Locate a process by number
168  */
169 struct proc *
170 pfind(pid_t pid)
171 {
172 	struct proc *p;
173 
174 	LIST_FOREACH(p, PIDHASH(pid), p_hash)
175 		if (p->p_pid == pid)
176 			return (p);
177 	return (NULL);
178 }
179 
180 /*
181  * Locate a process group by number
182  */
183 struct pgrp *
184 pgfind(pid_t pgid)
185 {
186 	struct pgrp *pgrp;
187 
188 	LIST_FOREACH(pgrp, PGRPHASH(pgid), pg_hash)
189 		if (pgrp->pg_id == pgid)
190 			return (pgrp);
191 	return (NULL);
192 }
193 
194 /*
195  * Move p to a new or existing process group (and session)
196  */
197 int
198 enterpgrp(struct proc *p, pid_t pgid, int mksess)
199 {
200 	struct pgrp *pgrp = pgfind(pgid);
201 
202 #ifdef DIAGNOSTIC
203 	if (pgrp != NULL && mksess)	/* firewalls */
204 		panic("enterpgrp: setsid into non-empty pgrp");
205 	if (SESS_LEADER(p))
206 		panic("enterpgrp: session leader attempted setpgrp");
207 #endif
208 	if (pgrp == NULL) {
209 		pid_t savepid = p->p_pid;
210 		struct proc *np;
211 		/*
212 		 * new process group
213 		 */
214 #ifdef DIAGNOSTIC
215 		if (p->p_pid != pgid)
216 			panic("enterpgrp: new pgrp and pid != pgid");
217 #endif
218 		if ((np = pfind(savepid)) == NULL || np != p)
219 			return (ESRCH);
220 		pgrp = pool_get(&pgrp_pool, PR_WAITOK);
221 		if (mksess) {
222 			struct session *sess;
223 
224 			/*
225 			 * new session
226 			 */
227 			sess = pool_get(&session_pool, PR_WAITOK);
228 			sess->s_leader = p;
229 			sess->s_count = 1;
230 			sess->s_ttyvp = NULL;
231 			sess->s_ttyp = NULL;
232 			bcopy(p->p_session->s_login, sess->s_login,
233 			    sizeof(sess->s_login));
234 			atomic_clearbits_int(&p->p_flag, P_CONTROLT);
235 			pgrp->pg_session = sess;
236 #ifdef DIAGNOSTIC
237 			if (p != curproc)
238 				panic("enterpgrp: mksession and p != curproc");
239 #endif
240 		} else {
241 			pgrp->pg_session = p->p_session;
242 			pgrp->pg_session->s_count++;
243 		}
244 		pgrp->pg_id = pgid;
245 		LIST_INIT(&pgrp->pg_members);
246 		LIST_INSERT_HEAD(PGRPHASH(pgid), pgrp, pg_hash);
247 		pgrp->pg_jobc = 0;
248 	} else if (pgrp == p->p_pgrp)
249 		return (0);
250 
251 	/*
252 	 * Adjust eligibility of affected pgrps to participate in job control.
253 	 * Increment eligibility counts before decrementing, otherwise we
254 	 * could reach 0 spuriously during the first call.
255 	 */
256 	fixjobc(p, pgrp, 1);
257 	fixjobc(p, p->p_pgrp, 0);
258 
259 	LIST_REMOVE(p, p_pglist);
260 	if (LIST_EMPTY(&p->p_pgrp->pg_members))
261 		pgdelete(p->p_pgrp);
262 	p->p_pgrp = pgrp;
263 	LIST_INSERT_HEAD(&pgrp->pg_members, p, p_pglist);
264 	return (0);
265 }
266 
267 /*
268  * remove process from process group
269  */
270 int
271 leavepgrp(struct proc *p)
272 {
273 
274 	LIST_REMOVE(p, p_pglist);
275 	if (LIST_EMPTY(&p->p_pgrp->pg_members))
276 		pgdelete(p->p_pgrp);
277 	p->p_pgrp = 0;
278 	return (0);
279 }
280 
281 /*
282  * delete a process group
283  */
284 void
285 pgdelete(struct pgrp *pgrp)
286 {
287 
288 	if (pgrp->pg_session->s_ttyp != NULL &&
289 	    pgrp->pg_session->s_ttyp->t_pgrp == pgrp)
290 		pgrp->pg_session->s_ttyp->t_pgrp = NULL;
291 	LIST_REMOVE(pgrp, pg_hash);
292 	SESSRELE(pgrp->pg_session);
293 	pool_put(&pgrp_pool, pgrp);
294 }
295 
296 /*
297  * Adjust pgrp jobc counters when specified process changes process group.
298  * We count the number of processes in each process group that "qualify"
299  * the group for terminal job control (those with a parent in a different
300  * process group of the same session).  If that count reaches zero, the
301  * process group becomes orphaned.  Check both the specified process'
302  * process group and that of its children.
303  * entering == 0 => p is leaving specified group.
304  * entering == 1 => p is entering specified group.
305  */
306 void
307 fixjobc(struct proc *p, struct pgrp *pgrp, int entering)
308 {
309 	struct pgrp *hispgrp;
310 	struct session *mysession = pgrp->pg_session;
311 
312 	/*
313 	 * Check p's parent to see whether p qualifies its own process
314 	 * group; if so, adjust count for p's process group.
315 	 */
316 	if ((hispgrp = p->p_pptr->p_pgrp) != pgrp &&
317 	    hispgrp->pg_session == mysession) {
318 		if (entering)
319 			pgrp->pg_jobc++;
320 		else if (--pgrp->pg_jobc == 0)
321 			orphanpg(pgrp);
322 	}
323 
324 	/*
325 	 * Check this process' children to see whether they qualify
326 	 * their process groups; if so, adjust counts for children's
327 	 * process groups.
328 	 */
329 	LIST_FOREACH(p, &p->p_children, p_sibling)
330 		if ((hispgrp = p->p_pgrp) != pgrp &&
331 		    hispgrp->pg_session == mysession &&
332 		    P_ZOMBIE(p) == 0) {
333 			if (entering)
334 				hispgrp->pg_jobc++;
335 			else if (--hispgrp->pg_jobc == 0)
336 				orphanpg(hispgrp);
337 		}
338 }
339 
340 /*
341  * A process group has become orphaned;
342  * if there are any stopped processes in the group,
343  * hang-up all process in that group.
344  */
345 static void
346 orphanpg(struct pgrp *pg)
347 {
348 	struct proc *p;
349 
350 	LIST_FOREACH(p, &pg->pg_members, p_pglist) {
351 		if (p->p_stat == SSTOP) {
352 			LIST_FOREACH(p, &pg->pg_members, p_pglist) {
353 				psignal(p, SIGHUP);
354 				psignal(p, SIGCONT);
355 			}
356 			return;
357 		}
358 	}
359 }
360 
361 #ifdef DDB
362 void
363 proc_printit(struct proc *p, const char *modif, int (*pr)(const char *, ...))
364 {
365 	static const char *const pstat[] = {
366 		"idle", "run", "sleep", "stop", "zombie", "dead", "onproc"
367 	};
368 	char pstbuf[5];
369 	const char *pst = pstbuf;
370 
371 	if (p->p_stat < 1 || p->p_stat > sizeof(pstat) / sizeof(pstat[0]))
372 		snprintf(pstbuf, sizeof(pstbuf), "%d", p->p_stat);
373 	else
374 		pst = pstat[(int)p->p_stat - 1];
375 
376 	(*pr)("PROC (%s) pid=%d stat=%s flags=%b\n",
377 	    p->p_comm, p->p_pid, pst, p->p_flag, P_BITS);
378 	(*pr)("    pri=%u, usrpri=%u, nice=%d\n",
379 	    p->p_priority, p->p_usrpri, p->p_nice);
380 	(*pr)("    forw=%p, list=%p,%p\n",
381 	    TAILQ_NEXT(p, p_runq), p->p_list.le_next, p->p_list.le_prev);
382 	(*pr)("    user=%p, vmspace=%p\n",
383 	    p->p_addr, p->p_vmspace);
384 	(*pr)("    estcpu=%u, cpticks=%d, pctcpu=%u.%u%, swtime=%u\n",
385 	    p->p_estcpu, p->p_cpticks, p->p_pctcpu / 100, p->p_pctcpu % 100,
386 	    p->p_swtime);
387 	(*pr)("    user=%llu, sys=%llu, intr=%llu\n",
388 	    p->p_uticks, p->p_sticks, p->p_iticks);
389 }
390 #include <machine/db_machdep.h>
391 
392 #include <ddb/db_interface.h>
393 #include <ddb/db_output.h>
394 
395 void
396 db_show_all_procs(db_expr_t addr, int haddr, db_expr_t count, char *modif)
397 {
398 	char *mode;
399 	int doingzomb = 0;
400 	struct proc *p, *pp;
401 
402 	if (modif[0] == 0)
403 		modif[0] = 'n';			/* default == normal mode */
404 
405 	mode = "mawn";
406 	while (*mode && *mode != modif[0])
407 		mode++;
408 	if (*mode == 0 || *mode == 'm') {
409 		db_printf("usage: show all procs [/a] [/n] [/w]\n");
410 		db_printf("\t/a == show process address info\n");
411 		db_printf("\t/n == show normal process info [default]\n");
412 		db_printf("\t/w == show process wait/emul info\n");
413 		return;
414 	}
415 
416 	p = LIST_FIRST(&allproc);
417 
418 	switch (*mode) {
419 
420 	case 'a':
421 		db_printf("   PID  %-10s  %18s  %18s  %18s\n",
422 		    "COMMAND", "STRUCT PROC *", "UAREA *", "VMSPACE/VM_MAP");
423 		break;
424 	case 'n':
425 		db_printf("   PID  %5s  %5s  %5s  S  %10s  %-12s  %-16s\n",
426 		    "PPID", "PGRP", "UID", "FLAGS", "WAIT", "COMMAND");
427 		break;
428 	case 'w':
429 		db_printf("   PID  %-16s  %-8s  %18s  %s\n",
430 		    "COMMAND", "EMUL", "WAIT-CHANNEL", "WAIT-MSG");
431 		break;
432 	}
433 
434 	while (p != 0) {
435 		pp = p->p_pptr;
436 		if (p->p_stat) {
437 
438 			db_printf("%c%5d  ", p == curproc ? '*' : ' ',
439 				p->p_pid);
440 
441 			switch (*mode) {
442 
443 			case 'a':
444 				db_printf("%-10.10s  %18p  %18p  %18p\n",
445 				    p->p_comm, p, p->p_addr, p->p_vmspace);
446 				break;
447 
448 			case 'n':
449 				db_printf("%5d  %5d  %5d  %d  %#10x  "
450 				    "%-12.12s  %-16s\n",
451 				    pp ? pp->p_pid : -1, p->p_pgrp->pg_id,
452 				    p->p_cred->p_ruid, p->p_stat, p->p_flag,
453 				    (p->p_wchan && p->p_wmesg) ?
454 					p->p_wmesg : "", p->p_comm);
455 				break;
456 
457 			case 'w':
458 				db_printf("%-16s  %-8s  %18p  %s\n", p->p_comm,
459 				    p->p_emul->e_name, p->p_wchan,
460 				    (p->p_wchan && p->p_wmesg) ?
461 					p->p_wmesg : "");
462 				break;
463 
464 			}
465 		}
466 		p = LIST_NEXT(p, p_list);
467 		if (p == 0 && doingzomb == 0) {
468 			doingzomb = 1;
469 			p = LIST_FIRST(&zombproc);
470 		}
471 	}
472 }
473 #endif
474 
475 #ifdef DEBUG
476 void
477 pgrpdump(void)
478 {
479 	struct pgrp *pgrp;
480 	struct proc *p;
481 	int i;
482 
483 	for (i = 0; i <= pgrphash; i++) {
484 		if (!LIST_EMPTY(&pgrphashtbl[i])) {
485 			printf("\tindx %d\n", i);
486 			LIST_FOREACH(pgrp, &pgrphashtbl[i], pg_hash) {
487 				printf("\tpgrp %p, pgid %d, sess %p, sesscnt %d, mem %p\n",
488 				    pgrp, pgrp->pg_id, pgrp->pg_session,
489 				    pgrp->pg_session->s_count,
490 				    LIST_FIRST(&pgrp->pg_members));
491 				LIST_FOREACH(p, &pgrp->pg_members, p_pglist) {
492 					printf("\t\tpid %d addr %p pgrp %p\n",
493 					    p->p_pid, p, p->p_pgrp);
494 				}
495 			}
496 		}
497 	}
498 }
499 #endif /* DEBUG */
500