xref: /openbsd-src/sys/kern/kern_proc.c (revision a28daedfc357b214be5c701aa8ba8adb29a7f1c2) 
1 /*	$OpenBSD: kern_proc.c,v 1.40 2009/04/15 10:47:46 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 struct uidinfo *
112 uid_find(uid_t uid)
113 {
114 	struct uidinfo *uip, *nuip;
115 	struct uihashhead *uipp;
116 
117 	uipp = UIHASH(uid);
118 	LIST_FOREACH(uip, uipp, ui_hash)
119 		if (uip->ui_uid == uid)
120 			break;
121 	if (uip)
122 		return (uip);
123 	nuip = malloc(sizeof(*nuip), M_PROC, M_WAITOK|M_ZERO);
124 	LIST_FOREACH(uip, uipp, ui_hash)
125 		if (uip->ui_uid == uid)
126 			break;
127 	if (uip) {
128 		free(nuip, M_PROC);
129 		return (uip);
130 	}
131 	nuip->ui_uid = uid;
132 	LIST_INSERT_HEAD(uipp, nuip, ui_hash);
133 
134 	return (nuip);
135 }
136 
137 /*
138  * Change the count associated with number of processes
139  * a given user is using.
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  * Caller provides a pre-allocated pgrp and session that should
197  * be freed if they are not used.
198  */
199 int
200 enterpgrp(struct proc *p, pid_t pgid, struct pgrp *newpgrp,
201     struct session *newsess)
202 {
203 	struct pgrp *pgrp = pgfind(pgid);
204 
205 #ifdef DIAGNOSTIC
206 	if (pgrp != NULL && newsess)	/* firewalls */
207 		panic("enterpgrp: setsid into non-empty pgrp");
208 	if (SESS_LEADER(p))
209 		panic("enterpgrp: session leader attempted setpgrp");
210 #endif
211 	if (pgrp == NULL) {
212 		struct proc *np;
213 		/*
214 		 * new process group
215 		 */
216 #ifdef DIAGNOSTIC
217 		if (p->p_pid != pgid)
218 			panic("enterpgrp: new pgrp and pid != pgid");
219 #endif
220 
221 		if ((np = pfind(p->p_pid)) == NULL || np != p) {
222 			pool_put(&pgrp_pool, newpgrp);
223 			if (newsess)
224 				pool_put(&session_pool, newsess);
225 			return (ESRCH);
226 		}
227 
228 		pgrp = newpgrp;
229 		if (newsess) {
230 			/*
231 			 * new session
232 			 */
233 			newsess->s_leader = p;
234 			newsess->s_count = 1;
235 			newsess->s_ttyvp = NULL;
236 			newsess->s_ttyp = NULL;
237 			bcopy(p->p_session->s_login, newsess->s_login,
238 			    sizeof(newsess->s_login));
239 			atomic_clearbits_int(&p->p_flag, P_CONTROLT);
240 			pgrp->pg_session = newsess;
241 #ifdef DIAGNOSTIC
242 			if (p != curproc)
243 				panic("enterpgrp: mksession and p != curproc");
244 #endif
245 		} else {
246 			pgrp->pg_session = p->p_session;
247 			pgrp->pg_session->s_count++;
248 		}
249 		pgrp->pg_id = pgid;
250 		LIST_INIT(&pgrp->pg_members);
251 		LIST_INSERT_HEAD(PGRPHASH(pgid), pgrp, pg_hash);
252 		pgrp->pg_jobc = 0;
253 	} else if (pgrp == p->p_pgrp) {
254 		if (newsess)
255 			pool_put(&session_pool, newsess);
256 		pool_put(&pgrp_pool, newpgrp);
257 		return (0);
258 	} else {
259 		if (newsess)
260 			pool_put(&session_pool, newsess);
261 		pool_put(&pgrp_pool, newpgrp);
262 	}
263 
264 	/*
265 	 * Adjust eligibility of affected pgrps to participate in job control.
266 	 * Increment eligibility counts before decrementing, otherwise we
267 	 * could reach 0 spuriously during the first call.
268 	 */
269 	fixjobc(p, pgrp, 1);
270 	fixjobc(p, p->p_pgrp, 0);
271 
272 	LIST_REMOVE(p, p_pglist);
273 	if (LIST_EMPTY(&p->p_pgrp->pg_members))
274 		pgdelete(p->p_pgrp);
275 	p->p_pgrp = pgrp;
276 	LIST_INSERT_HEAD(&pgrp->pg_members, p, p_pglist);
277 	return (0);
278 }
279 
280 /*
281  * remove process from process group
282  */
283 int
284 leavepgrp(struct proc *p)
285 {
286 
287 	LIST_REMOVE(p, p_pglist);
288 	if (LIST_EMPTY(&p->p_pgrp->pg_members))
289 		pgdelete(p->p_pgrp);
290 	p->p_pgrp = 0;
291 	return (0);
292 }
293 
294 /*
295  * delete a process group
296  */
297 void
298 pgdelete(struct pgrp *pgrp)
299 {
300 
301 	if (pgrp->pg_session->s_ttyp != NULL &&
302 	    pgrp->pg_session->s_ttyp->t_pgrp == pgrp)
303 		pgrp->pg_session->s_ttyp->t_pgrp = NULL;
304 	LIST_REMOVE(pgrp, pg_hash);
305 	SESSRELE(pgrp->pg_session);
306 	pool_put(&pgrp_pool, pgrp);
307 }
308 
309 /*
310  * Adjust pgrp jobc counters when specified process changes process group.
311  * We count the number of processes in each process group that "qualify"
312  * the group for terminal job control (those with a parent in a different
313  * process group of the same session).  If that count reaches zero, the
314  * process group becomes orphaned.  Check both the specified process'
315  * process group and that of its children.
316  * entering == 0 => p is leaving specified group.
317  * entering == 1 => p is entering specified group.
318  */
319 void
320 fixjobc(struct proc *p, struct pgrp *pgrp, int entering)
321 {
322 	struct pgrp *hispgrp;
323 	struct session *mysession = pgrp->pg_session;
324 
325 	/*
326 	 * Check p's parent to see whether p qualifies its own process
327 	 * group; if so, adjust count for p's process group.
328 	 */
329 	if ((hispgrp = p->p_pptr->p_pgrp) != pgrp &&
330 	    hispgrp->pg_session == mysession) {
331 		if (entering)
332 			pgrp->pg_jobc++;
333 		else if (--pgrp->pg_jobc == 0)
334 			orphanpg(pgrp);
335 	}
336 
337 	/*
338 	 * Check this process' children to see whether they qualify
339 	 * their process groups; if so, adjust counts for children's
340 	 * process groups.
341 	 */
342 	LIST_FOREACH(p, &p->p_children, p_sibling)
343 		if ((hispgrp = p->p_pgrp) != pgrp &&
344 		    hispgrp->pg_session == mysession &&
345 		    P_ZOMBIE(p) == 0) {
346 			if (entering)
347 				hispgrp->pg_jobc++;
348 			else if (--hispgrp->pg_jobc == 0)
349 				orphanpg(hispgrp);
350 		}
351 }
352 
353 /*
354  * A process group has become orphaned;
355  * if there are any stopped processes in the group,
356  * hang-up all process in that group.
357  */
358 static void
359 orphanpg(struct pgrp *pg)
360 {
361 	struct proc *p;
362 
363 	LIST_FOREACH(p, &pg->pg_members, p_pglist) {
364 		if (p->p_stat == SSTOP) {
365 			LIST_FOREACH(p, &pg->pg_members, p_pglist) {
366 				psignal(p, SIGHUP);
367 				psignal(p, SIGCONT);
368 			}
369 			return;
370 		}
371 	}
372 }
373 
374 #ifdef DDB
375 void
376 proc_printit(struct proc *p, const char *modif, int (*pr)(const char *, ...))
377 {
378 	static const char *const pstat[] = {
379 		"idle", "run", "sleep", "stop", "zombie", "dead", "onproc"
380 	};
381 	char pstbuf[5];
382 	const char *pst = pstbuf;
383 
384 	if (p->p_stat < 1 || p->p_stat > sizeof(pstat) / sizeof(pstat[0]))
385 		snprintf(pstbuf, sizeof(pstbuf), "%d", p->p_stat);
386 	else
387 		pst = pstat[(int)p->p_stat - 1];
388 
389 	(*pr)("PROC (%s) pid=%d stat=%s flags=%b\n",
390 	    p->p_comm, p->p_pid, pst, p->p_flag, P_BITS);
391 	(*pr)("    pri=%u, usrpri=%u, nice=%d\n",
392 	    p->p_priority, p->p_usrpri, p->p_nice);
393 	(*pr)("    forw=%p, list=%p,%p\n",
394 	    TAILQ_NEXT(p, p_runq), p->p_list.le_next, p->p_list.le_prev);
395 	(*pr)("    user=%p, vmspace=%p\n",
396 	    p->p_addr, p->p_vmspace);
397 	(*pr)("    estcpu=%u, cpticks=%d, pctcpu=%u.%u%, swtime=%u\n",
398 	    p->p_estcpu, p->p_cpticks, p->p_pctcpu / 100, p->p_pctcpu % 100,
399 	    p->p_swtime);
400 	(*pr)("    user=%llu, sys=%llu, intr=%llu\n",
401 	    p->p_uticks, p->p_sticks, p->p_iticks);
402 }
403 #include <machine/db_machdep.h>
404 
405 #include <ddb/db_interface.h>
406 #include <ddb/db_output.h>
407 
408 void
409 db_show_all_procs(db_expr_t addr, int haddr, db_expr_t count, char *modif)
410 {
411 	char *mode;
412 	int doingzomb = 0;
413 	struct proc *p, *pp;
414 
415 	if (modif[0] == 0)
416 		modif[0] = 'n';			/* default == normal mode */
417 
418 	mode = "mawn";
419 	while (*mode && *mode != modif[0])
420 		mode++;
421 	if (*mode == 0 || *mode == 'm') {
422 		db_printf("usage: show all procs [/a] [/n] [/w]\n");
423 		db_printf("\t/a == show process address info\n");
424 		db_printf("\t/n == show normal process info [default]\n");
425 		db_printf("\t/w == show process wait/emul info\n");
426 		return;
427 	}
428 
429 	p = LIST_FIRST(&allproc);
430 
431 	switch (*mode) {
432 
433 	case 'a':
434 		db_printf("   PID  %-10s  %18s  %18s  %18s\n",
435 		    "COMMAND", "STRUCT PROC *", "UAREA *", "VMSPACE/VM_MAP");
436 		break;
437 	case 'n':
438 		db_printf("   PID  %5s  %5s  %5s  S  %10s  %-12s  %-16s\n",
439 		    "PPID", "PGRP", "UID", "FLAGS", "WAIT", "COMMAND");
440 		break;
441 	case 'w':
442 		db_printf("   PID  %-16s  %-8s  %18s  %s\n",
443 		    "COMMAND", "EMUL", "WAIT-CHANNEL", "WAIT-MSG");
444 		break;
445 	}
446 
447 	while (p != 0) {
448 		pp = p->p_pptr;
449 		if (p->p_stat) {
450 
451 			db_printf("%c%5d  ", p == curproc ? '*' : ' ',
452 				p->p_pid);
453 
454 			switch (*mode) {
455 
456 			case 'a':
457 				db_printf("%-10.10s  %18p  %18p  %18p\n",
458 				    p->p_comm, p, p->p_addr, p->p_vmspace);
459 				break;
460 
461 			case 'n':
462 				db_printf("%5d  %5d  %5d  %d  %#10x  "
463 				    "%-12.12s  %-16s\n",
464 				    pp ? pp->p_pid : -1, p->p_pgrp->pg_id,
465 				    p->p_cred->p_ruid, p->p_stat, p->p_flag,
466 				    (p->p_wchan && p->p_wmesg) ?
467 					p->p_wmesg : "", p->p_comm);
468 				break;
469 
470 			case 'w':
471 				db_printf("%-16s  %-8s  %18p  %s\n", p->p_comm,
472 				    p->p_emul->e_name, p->p_wchan,
473 				    (p->p_wchan && p->p_wmesg) ?
474 					p->p_wmesg : "");
475 				break;
476 
477 			}
478 		}
479 		p = LIST_NEXT(p, p_list);
480 		if (p == 0 && doingzomb == 0) {
481 			doingzomb = 1;
482 			p = LIST_FIRST(&zombproc);
483 		}
484 	}
485 }
486 #endif
487 
488 #ifdef DEBUG
489 void
490 pgrpdump(void)
491 {
492 	struct pgrp *pgrp;
493 	struct proc *p;
494 	int i;
495 
496 	for (i = 0; i <= pgrphash; i++) {
497 		if (!LIST_EMPTY(&pgrphashtbl[i])) {
498 			printf("\tindx %d\n", i);
499 			LIST_FOREACH(pgrp, &pgrphashtbl[i], pg_hash) {
500 				printf("\tpgrp %p, pgid %d, sess %p, sesscnt %d, mem %p\n",
501 				    pgrp, pgrp->pg_id, pgrp->pg_session,
502 				    pgrp->pg_session->s_count,
503 				    LIST_FIRST(&pgrp->pg_members));
504 				LIST_FOREACH(p, &pgrp->pg_members, p_pglist) {
505 					printf("\t\tpid %d addr %p pgrp %p\n",
506 					    p->p_pid, p, p->p_pgrp);
507 				}
508 			}
509 		}
510 	}
511 }
512 #endif /* DEBUG */
513