1 /*
2 * Copyright (c) 1982, 1986, 1989, 1991, 1993
3 * The Regents of the University of California. All rights reserved.
4 * (c) UNIX System Laboratories, Inc.
5 * All or some portions of this file are derived from material licensed
6 * to the University of California by American Telephone and Telegraph
7 * Co. or Unix System Laboratories, Inc. and are reproduced herein with
8 * the permission of UNIX System Laboratories, Inc.
9 *
10 * %sccs.include.redist.c%
11 *
12 * @(#)kern_exit.c 8.10 (Berkeley) 02/23/95
13 */
14
15 #include <sys/param.h>
16 #include <sys/systm.h>
17 #include <sys/map.h>
18 #include <sys/ioctl.h>
19 #include <sys/proc.h>
20 #include <sys/tty.h>
21 #include <sys/time.h>
22 #include <sys/resource.h>
23 #include <sys/kernel.h>
24 #include <sys/buf.h>
25 #include <sys/wait.h>
26 #include <sys/file.h>
27 #include <sys/vnode.h>
28 #include <sys/syslog.h>
29 #include <sys/malloc.h>
30 #include <sys/resourcevar.h>
31 #include <sys/ptrace.h>
32
33 #include <machine/cpu.h>
34 #ifdef COMPAT_43
35 #include <machine/reg.h>
36 #include <machine/psl.h>
37 #endif
38
39 #include <vm/vm.h>
40 #include <vm/vm_kern.h>
41
42 __dead void cpu_exit __P((struct proc *));
43 __dead void exit1 __P((struct proc *, int));
44
45 /*
46 * exit --
47 * Death of process.
48 */
49 struct rexit_args {
50 int rval;
51 };
52 __dead void
exit(p,uap,retval)53 exit(p, uap, retval)
54 struct proc *p;
55 struct rexit_args *uap;
56 int *retval;
57 {
58
59 exit1(p, W_EXITCODE(uap->rval, 0));
60 /* NOTREACHED */
61 }
62
63 /*
64 * Exit: deallocate address space and other resources, change proc state
65 * to zombie, and unlink proc from allproc and parent's lists. Save exit
66 * status and rusage for wait(). Check for child processes and orphan them.
67 */
68 __dead void
exit1(p,rv)69 exit1(p, rv)
70 register struct proc *p;
71 int rv;
72 {
73 register struct proc *q, *nq;
74 register struct proc **pp;
75 register struct vmspace *vm;
76
77 if (p->p_pid == 1)
78 panic("init died (signal %d, exit %d)",
79 WTERMSIG(rv), WEXITSTATUS(rv));
80 #ifdef PGINPROF
81 vmsizmon();
82 #endif
83 if (p->p_flag & P_PROFIL)
84 stopprofclock(p);
85 MALLOC(p->p_ru, struct rusage *, sizeof(struct rusage),
86 M_ZOMBIE, M_WAITOK);
87 /*
88 * If parent is waiting for us to exit or exec,
89 * P_PPWAIT is set; we will wakeup the parent below.
90 */
91 p->p_flag &= ~(P_TRACED | P_PPWAIT);
92 p->p_flag |= P_WEXIT;
93 p->p_sigignore = ~0;
94 p->p_siglist = 0;
95 untimeout(realitexpire, (caddr_t)p);
96
97 /*
98 * Close open files and release open-file table.
99 * This may block!
100 */
101 fdfree(p);
102
103 /* The next two chunks should probably be moved to vmspace_exit. */
104 vm = p->p_vmspace;
105 #ifdef SYSVSHM
106 if (vm->vm_shm)
107 shmexit(p);
108 #endif
109 /*
110 * Release user portion of address space.
111 * This releases references to vnodes,
112 * which could cause I/O if the file has been unlinked.
113 * Need to do this early enough that we can still sleep.
114 * Can't free the entire vmspace as the kernel stack
115 * may be mapped within that space also.
116 */
117 if (vm->vm_refcnt == 1)
118 (void) vm_map_remove(&vm->vm_map, VM_MIN_ADDRESS,
119 VM_MAXUSER_ADDRESS);
120
121 if (SESS_LEADER(p)) {
122 register struct session *sp = p->p_session;
123
124 if (sp->s_ttyvp) {
125 /*
126 * Controlling process.
127 * Signal foreground pgrp,
128 * drain controlling terminal
129 * and revoke access to controlling terminal.
130 */
131 if (sp->s_ttyp->t_session == sp) {
132 if (sp->s_ttyp->t_pgrp)
133 pgsignal(sp->s_ttyp->t_pgrp, SIGHUP, 1);
134 (void) ttywait(sp->s_ttyp);
135 /*
136 * The tty could have been revoked
137 * if we blocked.
138 */
139 if (sp->s_ttyvp)
140 VOP_REVOKE(sp->s_ttyvp, REVOKEALL);
141 }
142 if (sp->s_ttyvp)
143 vrele(sp->s_ttyvp);
144 sp->s_ttyvp = NULL;
145 /*
146 * s_ttyp is not zero'd; we use this to indicate
147 * that the session once had a controlling terminal.
148 * (for logging and informational purposes)
149 */
150 }
151 sp->s_leader = NULL;
152 }
153 fixjobc(p, p->p_pgrp, 0);
154 p->p_rlimit[RLIMIT_FSIZE].rlim_cur = RLIM_INFINITY;
155 (void)acct_process(p);
156 #ifdef KTRACE
157 /*
158 * release trace file
159 */
160 p->p_traceflag = 0; /* don't trace the vrele() */
161 if (p->p_tracep)
162 vrele(p->p_tracep);
163 #endif
164 /*
165 * Remove proc from allproc queue and pidhash chain.
166 * Place onto zombproc. Unlink from parent's child list.
167 */
168 LIST_REMOVE(p, p_list);
169 LIST_INSERT_HEAD(&zombproc, p, p_list);
170 p->p_stat = SZOMB;
171
172 LIST_REMOVE(p, p_hash);
173
174 q = p->p_children.lh_first;
175 if (q) /* only need this if any child is S_ZOMB */
176 wakeup((caddr_t) initproc);
177 for (; q != 0; q = nq) {
178 nq = q->p_sibling.le_next;
179 LIST_REMOVE(q, p_sibling);
180 LIST_INSERT_HEAD(&initproc->p_children, q, p_sibling);
181 q->p_pptr = initproc;
182 /*
183 * Traced processes are killed
184 * since their existence means someone is screwing up.
185 */
186 if (q->p_flag & P_TRACED) {
187 q->p_flag &= ~P_TRACED;
188 psignal(q, SIGKILL);
189 }
190 }
191
192 /*
193 * Save exit status and final rusage info, adding in child rusage
194 * info and self times.
195 */
196 p->p_xstat = rv;
197 *p->p_ru = p->p_stats->p_ru;
198 calcru(p, &p->p_ru->ru_utime, &p->p_ru->ru_stime, NULL);
199 ruadd(p->p_ru, &p->p_stats->p_cru);
200
201 /*
202 * Notify parent that we're gone.
203 */
204 psignal(p->p_pptr, SIGCHLD);
205 wakeup((caddr_t)p->p_pptr);
206 #if defined(tahoe)
207 /* move this to cpu_exit */
208 p->p_addr->u_pcb.pcb_savacc.faddr = (float *)NULL;
209 #endif
210 /*
211 * Clear curproc after we've done all operations
212 * that could block, and before tearing down the rest
213 * of the process state that might be used from clock, etc.
214 * Also, can't clear curproc while we're still runnable,
215 * as we're not on a run queue (we are current, just not
216 * a proper proc any longer!).
217 *
218 * Other substructures are freed from wait().
219 */
220 curproc = NULL;
221 if (--p->p_limit->p_refcnt == 0)
222 FREE(p->p_limit, M_SUBPROC);
223
224 /*
225 * Finally, call machine-dependent code to release the remaining
226 * resources including address space, the kernel stack and pcb.
227 * The address space is released by "vmspace_free(p->p_vmspace)";
228 * This is machine-dependent, as we may have to change stacks
229 * or ensure that the current one isn't reallocated before we
230 * finish. cpu_exit will end with a call to cpu_swtch(), finishing
231 * our execution (pun intended).
232 */
233 cpu_exit(p);
234 }
235
236 struct wait_args {
237 int pid;
238 int *status;
239 int options;
240 struct rusage *rusage;
241 #ifdef COMPAT_43
242 int compat; /* pseudo */
243 #endif
244 };
245
246 #ifdef COMPAT_43
247 #if defined(hp300) || defined(luna68k)
248 #include <machine/frame.h>
249 #define GETPS(rp) ((struct frame *)(rp))->f_sr
250 #else
251 #define GETPS(rp) (rp)[PS]
252 #endif
253
254 compat_43_wait(p, uap, retval)
255 struct proc *p;
256 register struct wait_args *uap;
257 int *retval;
258 {
259
260 #ifdef PSL_ALLCC
261 if ((GETPS(p->p_md.md_regs) & PSL_ALLCC) != PSL_ALLCC) {
262 uap->options = 0;
263 uap->rusage = NULL;
264 } else {
265 uap->options = p->p_md.md_regs[R0];
266 uap->rusage = (struct rusage *)p->p_md.md_regs[R1];
267 }
268 #else
269 uap->options = 0;
270 uap->rusage = NULL;
271 #endif
272 uap->pid = WAIT_ANY;
273 uap->status = NULL;
274 uap->compat = 1;
275 return (wait1(p, uap, retval));
276 }
277
278 wait4(p, uap, retval)
279 struct proc *p;
280 struct wait_args *uap;
281 int *retval;
282 {
283
284 uap->compat = 0;
285 return (wait1(p, uap, retval));
286 }
287 #else
288 #define wait1 wait4
289 #endif
290
291 int
wait1(q,uap,retval)292 wait1(q, uap, retval)
293 register struct proc *q;
294 register struct wait_args *uap;
295 int retval[];
296 {
297 register int nfound;
298 register struct proc *p, *t;
299 int status, error;
300
301 if (uap->pid == 0)
302 uap->pid = -q->p_pgid;
303 #ifdef notyet
304 if (uap->options &~ (WUNTRACED|WNOHANG))
305 return (EINVAL);
306 #endif
307 loop:
308 nfound = 0;
309 for (p = q->p_children.lh_first; p != 0; p = p->p_sibling.le_next) {
310 if (uap->pid != WAIT_ANY &&
311 p->p_pid != uap->pid && p->p_pgid != -uap->pid)
312 continue;
313 nfound++;
314 if (p->p_stat == SZOMB) {
315 retval[0] = p->p_pid;
316 #ifdef COMPAT_43
317 if (uap->compat)
318 retval[1] = p->p_xstat;
319 else
320 #endif
321 if (uap->status) {
322 status = p->p_xstat; /* convert to int */
323 if (error = copyout((caddr_t)&status,
324 (caddr_t)uap->status, sizeof(status)))
325 return (error);
326 }
327 if (uap->rusage && (error = copyout((caddr_t)p->p_ru,
328 (caddr_t)uap->rusage, sizeof (struct rusage))))
329 return (error);
330 /*
331 * If we got the child via a ptrace 'attach',
332 * we need to give it back to the old parent.
333 */
334 if (p->p_oppid && (t = pfind(p->p_oppid))) {
335 p->p_oppid = 0;
336 proc_reparent(p, t);
337 psignal(t, SIGCHLD);
338 wakeup((caddr_t)t);
339 return (0);
340 }
341 p->p_xstat = 0;
342 ruadd(&q->p_stats->p_cru, p->p_ru);
343 FREE(p->p_ru, M_ZOMBIE);
344
345 /*
346 * Decrement the count of procs running with this uid.
347 */
348 (void)chgproccnt(p->p_cred->p_ruid, -1);
349
350 /*
351 * Free up credentials.
352 */
353 if (--p->p_cred->p_refcnt == 0) {
354 crfree(p->p_cred->pc_ucred);
355 FREE(p->p_cred, M_SUBPROC);
356 }
357
358 /*
359 * Release reference to text vnode
360 */
361 if (p->p_textvp)
362 vrele(p->p_textvp);
363
364 /*
365 * Finally finished with old proc entry.
366 * Unlink it from its process group and free it.
367 */
368 leavepgrp(p);
369 LIST_REMOVE(p, p_list); /* off zombproc */
370 LIST_REMOVE(p, p_sibling);
371
372 /*
373 * Give machine-dependent layer a chance
374 * to free anything that cpu_exit couldn't
375 * release while still running in process context.
376 */
377 cpu_wait(p);
378 FREE(p, M_PROC);
379 nprocs--;
380 return (0);
381 }
382 if (p->p_stat == SSTOP && (p->p_flag & P_WAITED) == 0 &&
383 (p->p_flag & P_TRACED || uap->options & WUNTRACED)) {
384 p->p_flag |= P_WAITED;
385 retval[0] = p->p_pid;
386 #ifdef COMPAT_43
387 if (uap->compat) {
388 retval[1] = W_STOPCODE(p->p_xstat);
389 error = 0;
390 } else
391 #endif
392 if (uap->status) {
393 status = W_STOPCODE(p->p_xstat);
394 error = copyout((caddr_t)&status,
395 (caddr_t)uap->status, sizeof(status));
396 } else
397 error = 0;
398 return (error);
399 }
400 }
401 if (nfound == 0)
402 return (ECHILD);
403 if (uap->options & WNOHANG) {
404 retval[0] = 0;
405 return (0);
406 }
407 if (error = tsleep((caddr_t)q, PWAIT | PCATCH, "wait", 0))
408 return (error);
409 goto loop;
410 }
411
412 /*
413 * make process 'parent' the new parent of process 'child'.
414 */
415 void
proc_reparent(child,parent)416 proc_reparent(child, parent)
417 register struct proc *child;
418 register struct proc *parent;
419 {
420
421 if (child->p_pptr == parent)
422 return;
423
424 LIST_REMOVE(child, p_sibling);
425 LIST_INSERT_HEAD(&parent->p_children, child, p_sibling);
426 child->p_pptr = parent;
427 }
428