![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to sig.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv10dc / lsys / os|
Return to sig.c CVS log | Up to [Research Unix] / researchv10dc / lsys / os |
1.1 root 1: #include "sys/param.h"
2: #include "sys/systm.h"
3: #include "sys/user.h"
4: #include "sys/proc.h"
5: #include "sys/inode.h"
6: #include "sys/mtpr.h"
7: #include "sys/conf.h"
8: #include "sys/vlimit.h"
9:
10: /*
11: * Send the specified signal to
12: * all processes with 'pgrp' as
13: * process group.
14: * Called by tty code for quits and
15: * interrupts.
16: */
17: gsignal(pgrp, sig)
18: register pgrp;
19: {
20: register struct proc *p;
21:
22: if(pgrp == 0)
23: return;
24: for(p = proc; p < procNPROC; p++)
25: if (p->p_stat != 0 && p->p_pgrp == pgrp)
26: psignal(p, sig);
27: }
28:
29: /*
30: * Send the specified signal to
31: * the specified process.
32: */
33: psignal(p, sig)
34: register struct proc *p;
35: register int sig;
36: {
37: register s;
38: register int (*action)();
39: long sigmask;
40:
41: if ((unsigned)sig >= NSIG
42: || p->p_stat == 0 || p->p_stat == SZOMB)
43: return;
44: sigmask = SIGMASK(sig);
45:
46: /*
47: * If proc is traced, always give parent a chance.
48: * Otherwise get the signal action from the bits in the proc table.
49: */
50: if (p->p_flag & STRC)
51: action = SIG_DFL;
52: else
53: action = P_SIGVAL(p, sigmask);
54: if (action == SIG_IGN)
55: return;
56: #define stops (SIGMASK(SIGSTOP)|SIGMASK(SIGTSTP)|SIGMASK(SIGTTIN)|SIGMASK(SIGTTOU))
57: if (sig) {
58: p->p_sig |= sigmask;
59: switch (sig) {
60:
61: case SIGTERM:
62: if ((p->p_flag&STRC) != 0 || action != SIG_DFL)
63: break;
64: /* fall into ... */
65:
66: case SIGKILL:
67: if (p->p_nice > NZERO)
68: p->p_nice = NZERO;
69: break;
70:
71: case SIGCONT:
72: p->p_sig &= ~stops;
73: break;
74:
75: case SIGSTOP:
76: case SIGTSTP:
77: case SIGTTIN:
78: case SIGTTOU:
79: p->p_sig &= ~SIGMASK(SIGCONT);
80: break;
81: }
82: }
83: #undef stops
84: /*
85: * Defer further processing for signals which are held.
86: */
87: if (action == SIG_HOLD)
88: return;
89: s = spl6();
90: switch (p->p_stat) {
91:
92: case SSLEEP:
93: /*
94: * If process is sleeping at negative priority
95: * we can't interrupt the sleep... the signal will
96: * be noticed when the process returns through
97: * trap() or syscall().
98: */
99: if (p->p_pri <= PZERO)
100: goto out;
101: /*
102: * Process is sleeping and traced... make it runnable
103: * so it can discover the signal in issig() and stop
104: * for the parent.
105: */
106: if (p->p_flag&STRC)
107: goto run;
108: switch (sig) {
109:
110: case SIGSTOP:
111: case SIGTSTP:
112: case SIGTTIN:
113: case SIGTTOU:
114: /*
115: * These are the signals which by default
116: * stop a process.
117: */
118: if (action != SIG_DFL)
119: goto run;
120: /*
121: * Don't clog system with children of init
122: * stopped from the keyboard.
123: */
124: if (sig != SIGSTOP && p->p_pptr == &proc[INITPID]) {
125: psignal(p, SIGKILL);
126: p->p_sig &= ~sigmask;
127: splx(s);
128: return;
129: }
130: p->p_sig &= ~sigmask;
131: p->p_cursig = sig;
132: stop(p);
133: goto out;
134:
135: case SIGTINT:
136: case SIGCHLD:
137: /*
138: * These signals are special in that they
139: * don't get propogated... if the process
140: * isn't interested, forget it.
141: */
142: if (action != SIG_DFL)
143: goto run;
144: p->p_sig &= ~sigmask; /* take it away */
145: goto out;
146:
147: default:
148: /*
149: * All other signals cause the process to run
150: */
151: goto run;
152: }
153: /*NOTREACHED*/
154:
155: case SSTOP:
156: /*
157: * If traced process is already stopped,
158: * then no further action is necessary,
159: * except to guarantee a sure SIGKILL and
160: * prevent multiple SIGSTOP's.
161: */
162: if ((p->p_flag&STRC) && sig != SIGKILL && sig != SIGSTOP)
163: goto out;
164: switch (sig) {
165:
166: case SIGKILL:
167: /*
168: * Kill signal always sets processes running.
169: */
170: goto run;
171:
172: case SIGCONT:
173: /*
174: * If the process catches SIGCONT, let it handle
175: * the signal itself. If it isn't waiting on
176: * an event, then it goes back to run state.
177: * Otherwise, process goes back to sleep state.
178: */
179: if (action != SIG_DFL || p->p_wchan == 0)
180: goto run;
181: p->p_stat = SSLEEP;
182: goto out;
183:
184: case SIGSTOP:
185: case SIGTSTP:
186: case SIGTTIN:
187: case SIGTTOU:
188: /*
189: * Already stopped, don't need to stop again.
190: * (If we did the shell could get confused.)
191: */
192: p->p_sig &= ~sigmask; /* take it away */
193: goto out;
194:
195: default:
196: /*
197: * If process is sleeping interruptibly, then
198: * unstick it so that when it is continued
199: * it can look at the signal.
200: * But don't setrun the process as its not to
201: * be unstopped by the signal alone.
202: */
203: if (p->p_wchan && p->p_pri > PZERO)
204: unsleep(p);
205: goto out;
206: }
207: /*NOTREACHED*/
208:
209: default:
210: /*
211: * SRUN, SIDL, SZOMB do nothing with the signal,
212: * other than kicking ourselves if we are running.
213: * It will either never be noticed, or noticed very soon.
214: */
215: if (p == u.u_procp && !noproc)
216: aston();
217: goto out;
218: }
219: /*NOTREACHED*/
220: run:
221: /*
222: * Raise priority to at least PUSER.
223: */
224: if (p->p_pri > PUSER)
225: if ((p != u.u_procp || noproc) && p->p_stat == SRUN &&
226: (p->p_flag & SLOAD)) {
227: remrq(p);
228: p->p_pri = PUSER;
229: setrq(p);
230: } else
231: p->p_pri = PUSER;
232: setrun(p);
233: out:
234: splx(s);
235: }
236:
237: /*
238: * Returns true if the current
239: * process has a signal to process.
240: * The signal to process is put in p_cursig.
241: * This is asked at least once each time a process enters the
242: * system (though this can usually be done without actually
243: * calling issig by checking the pending signal masks.)
244: * A signal does not do anything
245: * directly to a process; it sets
246: * a flag that asks the process to
247: * do something to itself.
248: */
249: issig()
250: {
251: register struct proc *p = u.u_procp;
252: register int sig;
253: long sigbits, sigmask, trmask;
254: int (*action)();
255:
256: for (;;) {
257: sigbits = p->p_sig;
258: if ((p->p_flag&STRC) == 0)
259: sigbits &= ~p->p_ignsig;
260: if (sigbits == 0)
261: break;
262: sig = (sigbits & SIGMASK(SIGKILL)) ? SIGKILL : ffs(sigbits);
263: sigmask = SIGMASK(sig);
264: p->p_sig &= ~sigmask; /* take the signal! */
265: p->p_cursig = sig;
266: trmask = SIGMASK(SIGSTOP); /* SIGSTOP always traced */
267: if (p->p_flag&STRC) {
268: register struct proc *pp = p;
269: do if (pp->p_trace) {
270: trmask |= pp->p_trace->i_un.i_sigmask;
271: break;
272: } while ((pp = pp->p_pptr) && pp->p_flag&STRC);
273: }
274: trmask &= sigmask & (~SIGMASK(SIGKILL));
275: if (trmask) {
276: /*
277: * If traced, always stop.
278: */
279: stop(p);
280: swtch();
281: /*
282: * If debugger wants us to take the signal,
283: * then it will leave it in p->p_cursig;
284: * otherwise we just look for signals again.
285: */
286: if ((sig = p->p_cursig) == 0)
287: continue;
288: }
289: if ((action = u.u_signal[sig]) == SIG_DFL) {
290: /*
291: * Don't take default actions on system processes.
292: */
293: if (p->p_flag & SSYS)
294: break;
295: switch (sig) {
296: case SIGTSTP:
297: case SIGTTIN:
298: case SIGTTOU:
299: /*
300: * Children of init aren't allowed to stop
301: * on signals from the keyboard.
302: */
303: if (p->p_pptr == &proc[INITPID]) {
304: psignal(p, SIGKILL);
305: continue;
306: }
307: /* fall into ... */
308:
309: case SIGSTOP:
310: if (trmask)
311: continue;
312: stop(p);
313: swtch();
314: continue;
315:
316: case SIGTINT:
317: case SIGCONT:
318: case SIGCHLD:
319: /*
320: * These signals are normally not
321: * sent if the action is the default.
322: * This can happen only if you reset the
323: * signal action from an action which was
324: * not deferred to SIG_DFL before the
325: * system gets a chance to post the signal.
326: */
327: continue; /* == ignore */
328:
329: default:
330: goto send;
331: }
332: } else if (action == SIG_IGN || action == SIG_HOLD) {
333: /*
334: * shouldn't happen unless process traced;
335: * see psignal
336: */
337: if ((p->p_flag&STRC) == 0)
338: printf("issig %d\n", sig);
339: continue;
340: } else {
341: /*
342: * This signal has an action, let
343: * psig process it.
344: */
345: goto send;
346: }
347: }
348: /*
349: * Didn't find a signal to send.
350: */
351: p->p_cursig = 0;
352: return (0);
353:
354: send:
355: /*
356: * Let psig process the signal.
357: */
358: return (sig);
359: }
360:
361: #ifndef vax
362: ffs(mask)
363: register long mask;
364: {
365: register int i;
366:
367: for(i=1; i<NSIG; i++) {
368: if(mask & 1)
369: return(i);
370: mask >>= 1;
371: }
372: return(0);
373: }
374: #endif
375:
376: /*
377: * Put the argument process into the stopped
378: * state and notify the parent via wakeup and/or signal.
379: */
380: stop(p)
381: register struct proc *p;
382: {
383:
384: p->p_stat = SSTOP;
385: p->p_flag &= ~SWTED;
386: wakeup((caddr_t)p->p_pptr);
387: wakeup((caddr_t)p->p_trace);
388: /*
389: * Avoid sending signal to parent if process is traced
390: */
391: if (p->p_flag&STRC)
392: return;
393: psignal(p->p_pptr, SIGCHLD);
394: }
395:
396: /*
397: * Perform the action specified by
398: * the current signal.
399: * The usual sequence is:
400: * if(issig())
401: * psig();
402: * The signal bit has already been cleared by issig,
403: * and the current signal number stored in p->p_cursig.
404: */
405: psig()
406: {
407: register struct proc *rp = u.u_procp;
408: register int n = rp->p_cursig;
409: long sigmask = SIGMASK(n);
410: register int (*action)();
411:
412: if (rp->p_cursig == 0)
413: panic("psig");
414: action = u.u_signal[n];
415: if (action != SIG_DFL) {
416: if (action == SIG_IGN || action == SIG_HOLD)
417: panic("psig action");
418: u.u_error = 0;
419: if(n != SIGILL && n != SIGTRAP)
420: u.u_signal[n] = 0;
421: /*
422: * If this catch value indicates automatic holding of
423: * subsequent signals, set the hold value.
424: */
425: if (SIGISDEFER(action)) {
426: (void) spl6();
427: P_SETHOLD(rp, sigmask);
428: u.u_signal[n] = SIG_HOLD;
429: (void) spl0();
430: action = SIGUNDEFER(action);
431: }
432: sendsig(action, n);
433: rp->p_cursig = 0;
434: return;
435: }
436: switch (n) {
437:
438: case SIGILL:
439: case SIGIOT:
440: case SIGBUS:
441: case SIGQUIT:
442: case SIGTRAP:
443: case SIGEMT:
444: case SIGFPE:
445: case SIGSEGV:
446: case SIGSYS:
447: u.u_arg[0] = n;
448: if(core())
449: n += 0200;
450: }
451: exit(n);
452: }
453:
454: /*
455: * Create a core image on the file "core"
456: * If you are looking for protection glitches,
457: * there are probably a wealth of them here
458: * when this occurs to a suid command.
459: *
460: * It writes UPAGES block of the
461: * user.h area followed by the entire
462: * data+stack segments.
463: */
464: core()
465: {
466: register struct inode *ip;
467: struct argnamei nmarg;
468: struct proc coreproc;
469:
470: if (ctob(UPAGES+u.u_dsize+u.u_ssize) >= u.u_limit[LIM_CORE])
471: return (0);
472: coreproc = *u.u_procp;
473: u.u_stack[0] = (int)&coreproc;
474: u.u_error = 0;
475: u.u_uid = u.u_ruid;
476: u.u_gid = u.u_rgid;
477: nmarg = nilargnamei;
478: nmarg.flag = NI_CREAT;
479: nmarg.un.mode = 0666 &~ u.u_cmask;
480: ip = namei("core", SEGSYS, &nmarg, 1);
481: if(ip == NULL)
482: return(0);
483: if(!access(ip, IWRITE) &&
484: (ip->i_mode&IFMT) == IFREG && ip->i_nlink==1) {
485: (*fstypsw[ip->i_fstyp]->t_trunc)(ip);
486: u.u_offset = ltoL(0);
487: u.u_base = (caddr_t)&u;
488: u.u_count = ctob(UPAGES);
489: u.u_segflg = SEGSYS;
490: writei(ip);
491: u.u_base = (char *)ctob(u.u_tsize);
492: u.u_count = ctob(u.u_dsize);
493: u.u_segflg = SEGUDATA;
494: writei(ip);
495: u.u_base = (char *)(USRSTACK - ctob(u.u_ssize));
496: u.u_count = ctob(u.u_ssize);
497: writei(ip);
498: } else
499: u.u_error = EFAULT;
500: iput(ip);
501: return(u.u_error==0);
502: }
503:
504: /*
505: * grow the stack to include the SP
506: * true return if successful.
507: */
508: grow(sp)
509: unsigned sp;
510: {
511: register si;
512:
513: if(sp >= USRSTACK-ctob(u.u_ssize))
514: return(0);
515: si = clrnd(btoc((USRSTACK-sp)) - u.u_ssize + SINCR);
516: if (ctob(u.u_ssize+si) > u.u_limit[LIM_STACK])
517: return(0);
518: if (chksize(u.u_tsize, u.u_dsize, u.u_ssize+si))
519: return(0);
520: if (swpexpand(u.u_dsize, u.u_ssize+si, &u.u_dmap, &u.u_smap)==0)
521: return(0);
522:
523: expand(si, P1BR);
524: return(1);
525: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.