![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to ker_data.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [MW Coherent from dump] / coherent / b / STREAMS / coh.386|
Return to ker_data.c CVS log | Up to [MW Coherent from dump] / coherent / b / STREAMS / coh.386 |
1.1 root 1: /* $Header: /src386/STREAMS/coh.386/RCS/ker_data.c,v 2.1 93/08/09 13:35:41 bin Exp Locker: bin $ */
2: /*
3: * This file contains definitions for the functions which support the Coherent
4: * internal binary-compatibility scheme. We select _SYSV3 to get some old
5: * definitions like makedev () visible.
6: */
7: /*
8: * $Log: ker_data.c,v $
9: * Revision 2.1 93/08/09 13:35:41 bin
10: * Kernel 82 changes
11: *
12: * Revision 2.2 93/07/26 14:55:28 nigel
13: * Nigel's R80
14: *
15: */
16:
17: #define _SYSV3 1
18:
19: #include <common/ccompat.h>
20: #include <common/_tricks.h>
21: #include <common/_gregset.h>
22: #include <kernel/sigproc.h>
23: #include <kernel/v_types.h>
24: #include <sys/debug.h>
25: #include <string.h>
26:
27: /*
28: * These two pull in all the old-style trash.
29: */
30:
31: #include <sys/coherent.h>
32: #include <sys/uproc.h>
33: #include <sys/proc.h>
34:
35: /*
36: * Stubs for the multiprocessor locking functions.
37: */
38:
39: #define PROC_STATE_LOCK(proc) sphi ()
40: #define PROC_STATE_UNLOCK(proc,pl) spl (pl)
41: #define PROC_ASSERT_LOCKED(proc) ((void) 0)
42:
43:
44: /*
45: * Initialize a freshly-allocated process structure to a copy of the current
46: * process. As a special case, if there is no current process, the new process
47: * is given some default values.
48: */
49:
50: #if __USE_PROTO__
51: void PROC_INIT (__proc_t * process)
52: #else
53: void
54: PROC_INIT (process)
55: __proc_t * process;
56: #endif
57: {
58: process->p_event = NULL; /* Wakeup event channel */
59: process->p_alarm = 0; /* Timer for alarms */
60:
61: process->p_utime = 0L; /* User time (HZ) */
62: process->p_stime = 0L; /* System time */
63: process->p_cutime = 0L; /* Sum of childs user time */
64: process->p_cstime = 0L; /* Sum of childs system time */
65: process->p_exit = 0; /* Exit status */
66: process->p_polls = NULL; /* Enabled polls */
67:
68: /* Poll timer */
69: process->p_polltim.t_next = NULL;
70: process->p_polltim.t_last = NULL;
71: process->p_polltim.t_lbolt = 0L;
72: process->p_polltim.t_func = NULL;
73: process->p_polltim.t_farg = NULL;
74:
75: /* Alarm timer */
76: process->p_alrmtim.t_next = NULL;
77: process->p_alrmtim.t_last = NULL;
78: process->p_alrmtim.t_lbolt = 0L;
79: process->p_alrmtim.t_func = NULL;
80: process->p_alrmtim.t_farg = NULL;
81:
82: process->p_prl = NULL; /* Pending record lock */
83: process->p_semu = NULL; /* Semaphore undo */
84:
85: process->p_flags = PFCORE;
86: process->p_state = PSRUN;
87: process->p_ttdev = NODEV;
88:
89: process->p_pid = 0;
90:
91: __SIGSET_EMPTY (process->p_pending_signals);
92:
93: if (SELF == NULL) {
94: process->p_ppid = 0;
95: process->p_nice = 0;
96: process->p_schedPri = 0;
97:
98: process->p_uid = 0;
99: process->p_group = 0;
100: process->p_ruid = 0;
101: process->p_rgid = 0;
102:
103: /*
104: * Set ttdev to null so that we do not accidentally set a tty
105: * for init.
106: */
107: process->p_ttdev = makedev (0, 0);
108:
109: __SIGSET_EMPTY (process->p_signal_mask);
110: __SIGSET_EMPTY (process->p_queued_signals);
111:
112: /*
113: * The default action for the following signals is to ignore
114: * them.
115: */
116:
117: #if _SIGNAL_MAX <= __LONG_BIT
118: process->p_ignored_signals._sigbits [0] =
119: __SIGSET_MASK (SIGCHLD) | __SIGSET_MASK (SIGPWR) |
120: __SIGSET_MASK (SIGWINCH) | __SIGSET_MASK (SIGURG) |
121: __SIGSET_MASK (SIGPOLL) | __SIGSET_MASK (SIGCONT);
122: #else
123: __SIGSET_EMPTY (process->p_ignored_signals);
124: __SIGSET_CLRBIT (process->p_ignored, SIGCHLD);
125: __SIGSET_CLRBIT (process->p_ignored, SIGPWR);
126: __SIGSET_CLRBIT (process->p_ignored, SIGWINCH);
127: __SIGSET_CLRBIT (process->p_ignored, SIGURG);
128: __SIGSET_CLRBIT (process->p_ignored, SIGPOLL);
129: __SIGSET_CLRBIT (process->p_ignored, SIGCONT);
130: #endif
131:
132: process->p_sigflags = 0;
133: } else {
134: process->p_ppid = SELF->p_pid;
135: process->p_nice = SELF->p_nice;
136: process->p_schedPri = SELF->p_schedPri;
137:
138: process->p_uid = SELF->p_uid;
139: process->p_group = SELF->p_group;
140: process->p_ruid = SELF->p_ruid;
141: process->p_rgid = SELF->p_rgid;
142:
143: process->p_ttdev = SELF->p_ttdev;
144:
145: process->p_signal_mask = SELF->p_signal_mask;
146: process->p_ignored_signals = SELF->p_ignored_signals;
147: process->p_queued_signals = SELF->p_queued_signals;
148:
149: process->p_sigflags = SELF->p_sigflags;
150: }
151: }
152:
153:
154: /*
155: * Wake a process from a sleep state, with the indicated "reason" code so that
156: * the process can know whether sleep was interrupted or not.
157: */
158:
159: #if __USE_PROTO__
160: void PROC_WAKE (__proc_t * process, int reason)
161: #else
162: void
163: PROC_WAKE (process, reason)
164: __proc_t * process;
165: int reason;
166: #endif
167: {
168: PROC_ASSERT_LOCKED (process);
169:
170: /*
171: * Dequeue the process from the hash list used for old-style sleep ().
172: */
173:
174: process->p_lback->p_lforw = process->p_lforw;
175: process->p_lforw->p_lback = process->p_lback;
176:
177: /*
178: * Change the process state to runnable and queue the process on the
179: * appropriate run queue.
180: */
181:
182: setrun (process);
183: }
184:
185: #define PROC_WAKE_SIGNAL(proc) PROC_WAKE (proc, PROCESS_SIGNALLED)
186:
187:
188: /*
189: * Internal version of sigaction (), which allows retrieval and optional
190: * replacement of the current signal information.
191: *
192: * Note that we take a copy of the current information in a temporary before
193: * trying to fiddle the new information; this allows the "act" and "oact"
194: * pointers to point to the same space.
195: */
196:
197: #if __USE_PROTO__
198: void curr_signal_action (int signal, __CONST__ __sigaction_t * act,
199: __sigaction_t * oact)
200: #else
201: void
202: curr_signal_action (signal, act, oact)
203: int signal;
204: __CONST__ __sigaction_t
205: * act;
206: __sigaction_t * oact;
207: #endif
208: {
209: __sigaction_t * proc_act;
210:
211: ASSERT (oact != NULL || act != NULL);
212: ASSERT (signal > 0 && signal <= _SIGNAL_MAX);
213:
214: proc_act = & u.u_sigact [signal - 1];
215:
216: if (act != NULL) {
217: __sigmask_t mask = __SIGSET_MASK (signal);
218: __sigaction_t temp;
219:
220: /*
221: * Exchange the "action" data.
222: */
223:
224: temp = * proc_act;
225: * proc_act = * act;
226: if (oact != NULL)
227: * oact = temp;
228:
229: /*
230: * The SIGILL, SIGTRAP and SIGPWR signals do not have their
231: * handlers reset to SIG_DFL even if the user requests this.
232: * Again, this is "silently enforced" so it happens at this
233: * layer.
234: */
235:
236: #if _SIGNAL_MAX <= __LONG_BIT
237: if ((mask & (__SIGSET_MASK (SIGILL) | __SIGSET_MASK (SIGTRAP) |
238: __SIGSET_MASK (SIGPWR))) == 0)
239: #else
240: if (signal == SIGILL || signal == SIGTRAP || signal == SIGPWR)
241: #endif
242: proc_act->sa_flags &= ~ __SA_RESETHAND;
243:
244: /*
245: * Set the ignore flags to match handler. Note that we do not
246: * clear the pending signals for the current process here;
247: * that will happen on the way out of the system call we are
248: * in during the check for signals to deliver.
249: */
250:
251: if (proc_act->sa_handler == SIG_IGN)
252: __SIGSET_ADDMASK (SELF->p_ignored_signals, signal,
253: mask);
254: else
255: __SIGSET_CLRMASK (SELF->p_ignored_signals, signal,
256: mask);
257:
258: /*
259: * Existing System V, Release 4 systems zero the mask if the
260: * signal is defaulted or ignored, so we copy them.
261: */
262:
263: if (proc_act->sa_handler == SIG_IGN ||
264: proc_act->sa_handler == SIG_DFL)
265: __SIGSET_EMPTY (proc_act->sa_mask);
266:
267: /*
268: * The default action for the following signals is for them to
269: * be ignored: SIGCHLD, SIGPWR, SIGWINCH, SIGURG, SIGPOLL,
270: * SIGCONT.
271: */
272:
273: #if _SIGNAL_MAX <= __LONG_BIT
274: if (((__SIGSET_MASK (SIGCHLD) | __SIGSET_MASK (SIGPWR) |
275: __SIGSET_MASK (SIGWINCH) | __SIGSET_MASK (SIGURG) |
276: __SIGSET_MASK (SIGPOLL) | __SIGSET_MASK (SIGCONT))
277: & mask) != 0
278: #else
279: if ((signal == SIGCHLD || signal == SIGPWR ||
280: signal == SIGWINCH || signal == SIGURG ||
281: signal == SIGPOLL || signal == SIGCONT)
282: #endif
283: && proc_act->sa_handler == SIG_DFL)
284: __SIGSET_ADDMASK (SELF->p_ignored_signals, signal,
285: mask);
286:
287: if ((proc_act->sa_flags & __SA_SIGINFO) != 0)
288: __SIGSET_ADDMASK (SELF->p_queued_signals, signal,
289: mask);
290: } else
291: * oact = * proc_act;
292: }
293:
294:
295: /*
296: * Obtain and possibly change the current process's signal mask. Note that
297: * we capture the current mask to a temporary before beginning, thus allowing
298: * "mask" and "omask" to point to the same storage.
299: */
300:
301: #if __USE_PROTO__
302: void curr_signal_mask (__CONST__ __sigset_t * mask, __sigset_t * omask)
303: #else
304: void
305: curr_signal_mask (mask, omask)
306: __CONST__ __sigset_t
307: * mask;
308: __sigset_t * omask;
309: #endif
310: {
311: ASSERT (omask != NULL || mask != NULL);
312:
313: if (mask != NULL) {
314: __sigset_t temp;
315:
316: /*
317: * The caller of this function should arrange for collateral
318: * actions such as checking for newly-unmasked signals in such
319: * as way as to ensure that signal actions are dealt with
320: * promptly and to ensure that locking is not needed.
321: *
322: * For instance, at this point signals may be briefly held
323: * which in fact "cannot" be. We don't care about this; the
324: * above constraint on our callers will ensure that this has
325: * no effect.
326: */
327:
328: temp = SELF->p_signal_mask;
329: SELF->p_signal_mask = * mask;
330: if (omask != NULL)
331: * omask = temp;
332:
333: /*
334: * SIGKILL and SIGSTOP may never be blocked or caught. Here we
335: * enforce the blocking part, which as the SVR4 PRM says is
336: * "silently enforced" by the system.
337: */
338:
339: __SIGSET_CLRBIT (SELF->p_signal_mask, SIGKILL);
340: __SIGSET_CLRBIT (SELF->p_signal_mask, SIGSTOP);
341: } else
342: * omask = SELF->p_signal_mask;
343: }
344:
345:
346: /*
347: * Test the signal mask of the given process to determine whether the given
348: * signal is masked.
349: */
350:
351: #if __USE_PROTO__
352: int proc_signal_masked (__proc_t * process, int signal)
353: #else
354: int
355: proc_signal_masked (process, signal)
356: __proc_t * process;
357: int signal;
358: #endif
359: {
360: ASSERT (process != NULL && signal > 0 && signal <= _SIGNAL_MAX);
361: return __SIGSET_TSTBIT (process->p_signal_mask, signal);
362: }
363:
364:
365: /*
366: * Return a zero value if there are no signals pending, otherwise return the
367: * number of the first unmasked, non-ignored signal.
368: *
369: * NOTE: The code here interacts with curr_signal_action () and
370: * proc_send_signal () in some ways that need comment; specifically, the
371: * treatment of ignored signals may seem sloppy. However, the System V usage
372: * of allowing ignored signals to be blocked, and then caught if a handler is
373: * subsequently attached means that the approach of clearing pending, ignored
374: * signals at this point is much simpler than dealing with them at all the
375: * other points (arrival, unblocking, handler attach).
376: */
377:
378: #if __USE_PROTO__
379: int curr_signal_pending (void)
380: #else
381: int
382: curr_signal_pending ()
383: #endif
384: {
385: int signo;
386:
387: /*
388: * If any signals have arrived, but which are not held, figure out
389: * what they are. This takes a little doing.
390: */
391:
392: for (signo = 0 ;
393: signo < __ARRAY_LENGTH (SELF->p_pending_signals._sigbits) ;
394: signo ++) {
395: __sigmask_t mask;
396:
397: mask = (SELF->p_pending_signals._sigbits [signo] &=
398: ~ SELF->p_ignored_signals._sigbits [signo]) &
399: ~ SELF->p_signal_mask._sigbits [signo];
400: if (mask == 0)
401: continue;
402:
403: /*
404: * There is at least one signal. Extract its number
405: * from the signal bits.
406: */
407:
408: T_HAL(8, printf ("curr_signal_pending () = %d ",
409: signo * sizeof (__sigmask_t) * __CHAR_BIT +
410: __SIGSET_FIRSTBIT (mask)));
411:
412: return signo * sizeof (__sigmask_t) * __CHAR_BIT +
413: __SIGSET_FIRSTBIT (mask);
414: }
415: return 0;
416: }
417:
418:
419: #if _SIGNAL_MAX <= __LONG_BIT
420: /*
421: * For optimizing handling of job-control signals.
422: */
423:
424: #define STOP_SIGNALS (__SIGSET_MASK (SIGSTOP) | __SIGSET_MASK (SIGTSTP) |\
425: __SIGSET_MASK (SIGTTIN) | __SIGSET_MASK (SIGTTOU))
426: #endif
427:
428: /*
429: * Add the given signal to the indicated process's pending-signal mask and if
430: * the process requires some notification (such as being woken if asleep, or
431: * interrupted if scheduled on another processor) then perform that.
432: *
433: * This function can only be called from base level, but we must be aware of
434: * the fact that process state-changes can happen at interrupt level and that
435: * we can be interacting with multiple processors.
436: */
437:
438: #if __USE_PROTO__
439: void proc_send_signal (__proc_t * process, __CONST__ __siginfo_t * siginfo)
440: #else
441: void
442: proc_send_signal (process, siginfo)
443: __proc_t * process;
444: __CONST__ __siginfo_t
445: * siginfo;
446: #endif
447: {
448: __sigmask_t mask;
449: pl_t prev_pl;
450:
451: ASSERT (process != NULL && siginfo != NULL);
452: ASSERT (siginfo->__si_signo > 0 && siginfo->__si_signo <= _SIGNAL_MAX);
453:
454: mask = __SIGSET_MASK (siginfo->__si_signo);
455:
456: if (siginfo->__si_signo == SIGCONT) {
457: /*
458: * When a SIGCONT is received, all pending stop signals are
459: * discarded and if the process is stopped, it is continued.
460: */
461:
462: #if _SIGNAL_MAX <= __LONG_BIT
463: __SIGSET_CLRMASK (process->p_pending_signals, 0,
464: STOP_SIGNALS);
465: #else
466: __SIGSET_CLRBIT (process->p_pending_signals, SIGSTOP);
467: __SIGSET_CLRBIT (process->p_pending_signals, SIGTSTP);
468: __SIGSET_CLRBIT (process->p_pending_signals, SIGTTIN);
469: __SIGSET_CLRBIT (process->p_pending_signals, SIGTTOU);
470: #endif
471:
472: #ifdef PROC_IS_STOPPED
473: if (PROC_IS_STOPPED (process))
474: PROC_CONTINUE (process);
475: #endif
476: }
477:
478: #if _SIGNAL_MAX <= __LONG_BIT
479: if ((mask & STOP_SIGNALS) != 0) {
480: #else
481: if (siginfo->__si_signo == SIGSTOP ||
482: siginfo->__si_signo == SIGTSTP ||
483: siginfo->__si_signo == SIGTTIN ||
484: siginfo->__si_signo == SIGTTOU) {
485: #endif
486: /*
487: * When a stop signal is received, any pending SIGCONT signal
488: * is discarded.
489: */
490:
491: __SIGSET_CLRBIT (process->p_pending_signals, SIGCONT);
492: }
493:
494:
495: #if 0
496: if (__SIGSET_TSTMASK (process->p_queued_signals, siginfo->__si_signo,
497: mask) != 0) {
498: /*
499: * Reliable signal-queueing is in effect, so we must stash
500: * away a copy of the structure pointed at by "siginfo" so we
501: * can deliver the information as an additional argument to
502: * the signal-catching function.
503: */
504: ASSERT ("Not implemented" == NULL);
505: }
506: #endif /* NOT IMPLEMENTED */
507:
508:
509: /*
510: * Here we are about to modify some shared per-process state; now is a
511: * good time to take a lock, so we structure the code so it can be
512: * released. We require a basic lock for the state-change code, so we
513: * use that lock to cover the process-level guard as well. In a uni-
514: * processor system, the process-level guard is not necessary, but the
515: * extra area covered is small enough that it doesn't matter.
516: */
517:
518: prev_pl = PROC_STATE_LOCK (process);
519:
520: __SIGSET_ADDMASK (process->p_pending_signals,
521: siginfo->__si_signo, mask);
522:
523: if (! __SIGSET_TSTMASK (process->p_signal_mask,
524: siginfo->__si_signo, mask) &&
525: ! __SIGSET_TSTMASK (process->p_ignored_signals,
526: siginfo->__si_signo, mask) &&
527: process->p_state == PSSLSIG) {
528: /*
529: * The process is sleeping and wants to be woken by
530: * signals, arrange for it to come out of sleep so it
531: * can get to user-level and process the signal.
532: */
533:
534: PROC_WAKE_SIGNAL (process);
535: }
536:
537: PROC_STATE_UNLOCK (process, prev_pl);
538:
539: T_HAL (8, printf (" ign = %x hold = %x pend = %x ",
540: process->p_ignored_signals._sigbits [0],
541: process->p_signal_mask._sigbits [0],
542: process->p_pending_signals._sigbits [0]));
543: }
544:
545:
546: /*
547: * Obtain and/or modify the current process's miscellaneous signal-flags. The
548: * previous flags are returned, making "curr_signal_misc (0, 0)" the fetch.
549: */
550:
551: #if __USE_PROTO__
552: __sigmiscfl_t curr_signal_misc (__sigmiscfl_t clear, __sigmiscfl_t set)
553: #else
554: __sigmiscfl_t
555: curr_signal_misc (clear, set)
556: __sigmiscfl_t clear;
557: __sigmiscfl_t set;
558: #endif
559: {
560: __sigmiscfl_t temp = SELF->p_sigflags;
561:
562: SELF->p_sigflags = (temp & ~ clear) | set;
563: return temp;
564: }
565:
566:
567: /*
568: * Return the given process's miscellaneous signal information. Note that we
569: * don't try and deal with synchronization issues here, so whatever code tests
570: * this data has to find some way of being multi-processor safe (concretely,
571: * it means that the uses of the signal information here are not atomic at the
572: * system-call level).
573: */
574:
575: #if __USE_PROTO__
576: __sigmiscfl_t proc_signal_misc (__proc_t * process)
577: #else
578: __sigmiscfl_t
579: proc_signal_misc (process)
580: __proc_t * process;
581: #endif
582: {
583: return process->p_sigflags;
584: }
585:
586:
587: /*
588: * Remove a signal from the pending signal mask.
589: */
590:
591: #if __USE_PROTO__
592: void proc_unkill (__proc_t * process, int signal)
593: #else
594: void
595: proc_unkill (process, signal)
596: __proc_t * process;
597: int signal;
598: #endif
599: {
600: __SIGSET_CLRBIT (process->p_pending_signals, signal);
601: }
602:
603:
604: /*
605: * Perform a register dump from a gregset_t, plus any useful data from the
606: * current process.
607: */
608:
609: #if __USE_PROTO__
610: void curr_register_dump (gregset_t * regsetp)
611: #else
612: void
613: curr_register_dump (regsetp)
614: gregset_t * regsetp;
615: #endif
616: {
617: printf ("\neax=%x ebx=%x ecx=%x edx=%x\n", regsetp->_i386._eax,
618: regsetp->_i386._ebx, regsetp->_i386._ecx, regsetp->_i386._edx);
619: printf ("esi=%x edi=%x ebp=%x esp=%x\n", regsetp->_i386._esi,
620: regsetp->_i386._edi, regsetp->_i386._ebp, regsetp->_i386._esp);
621: printf ("cs=%x ds=%x es=%x ss=%x fs=%x gs=%x\n",
622: regsetp->_i386._cs, regsetp->_i386._ds, regsetp->_i386._es,
623: regsetp->_i386._ss, regsetp->_i386._fs, regsetp->_i386._gs);
624: printf ("err #%d eip=%x uesp=%x cmd=%s\n", regsetp->_i386._err,
625: regsetp->_i386._eip, regsetp->_i386._uesp, u.u_comm);
626: printf ("efl=%x ", regsetp->_i386._eflags);
627:
628: if ((regsetp->_i386._cs & R_USR) != R_USR) {
629: /*
630: * This register set is indicating something that happened in
631: * the kernel, so do a call backtrace. To make this a little
632: * more robust, we only go upwards in the stack from the frame
633: * where we are, so that a smashed %ebp or frame causes no
634: * problems.
635: */
636:
637: __ulong_t * ebp = (__ulong_t *) regsetp->_i386._ebp;
638: __ulong_t * prev = & regsetp->_i386._ebp;
639: while (ebp > prev) {
640: printf (" -> %x", * (ebp + 1));
641: ebp = (__ulong_t *) * (prev = ebp);
642: }
643: printf ("\n");
644: }
645: }
646:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.