![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to sigmask.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv9 / jtools / src / pi|
Return to sigmask.c CVS log | Up to [Research Unix] / researchv9 / jtools / src / pi |
1.1 root 1: #include "hostcore.h"
2: #include "process.pri"
3: #include "srctext.pub"
4: #include "sigmask.h"
5: SRCFILE("sigmask.c")
6:
7: char *SignalName(int sig)
8: {
9: switch( sig ){
10: case 0: return "0 (no signal)";
11: case SIGHUP: return "hangup";
12: case SIGINT: return "interrupt";
13: case SIGQUIT: return "quit";
14: case SIGILL: return "illegal instruction";
15: case SIGTRAP: return "trace/BPT";
16: case SIGIOT: return "IOT instruction";
17: case SIGEMT: return "EMT instruction";
18: case SIGFPE: return "floating exception";
19: case SIGKILL: return "kill";
20: case SIGBUS: return "bus error";
21: case SIGSEGV: return "memory fault";
22: case SIGSYS: return "bad system call";
23: case SIGPIPE: return "broken pipe";
24: case SIGALRM: return "alarm call";
25: case SIGTERM: return "terminated";
26: case SIGSTOP: return "stop";
27: case SIGCONT: return "continue";
28: case SIGTSTP: return "stop tty";
29: case SIGCHLD: return "child termination";
30: case SIGTTIN: return "stop tty input";
31: case SIGTTOU: return "stop tty output";
32: case SIGXCPU: return "cpu timelimit";
33: case SIGXFSZ: return "file sizelimit";
34: #ifdef V9
35: case SIGTINT: return "input available";
36: #else
37: case SIGIO: return "i/o possible";
38: case SIGURG: return "urgent condition";
39: case SIGVTALRM: return "virtual alarm";
40: case SIGPROF: return "profiling alarm";
41: case SIGWINCH: return "window changed";
42: #endif
43: }
44: return Name( "signal %d", sig );
45: }
46:
47: void SigMask::banner()
48: {
49: trace( "%d.banner()", this ); VOK;
50: if( pad ){
51: pad->banner( "Signals: %s", core->procpath() );
52: pad->name( "Signals" );
53: }
54: }
55:
56: SigMask::SigMask(HostCore *c)
57: {
58: trace( "%d.SigMask(%d)", this, c ); VOK;
59: core = c;
60: pad = 0;
61: mask = bit(SIGILL)
62: |bit(SIGINT)
63: |bit(SIGTRAP)
64: |bit(SIGIOT)
65: |bit(SIGEMT)
66: |bit(SIGFPE)
67: |bit(SIGBUS)
68: |bit(SIGSEGV)
69: |bit(SIGSYS)
70: |bit(SIGPIPE)
71: |bit(SIGSTOP);
72: #ifdef V9
73: exechang = 0;
74: #else
75: exechang = 1;
76: #endif
77: updatecore();
78: }
79:
80: const long EXECKEY = 33;
81:
82: void SigMask::open()
83: {
84: Menu m;
85: int i;
86: trace( "%d.open()", this ); VOK;
87: if( !pad ){
88: pad = new Pad( (PadRcv*) this );
89: #ifdef V9
90: pad->lines(EXECKEY);
91: #endif
92: banner();
93: m.last( "clear pending signal", (Action)&SigMask::clrcurrsig, 0 );
94: m.last( "clear pending and go", (Action)&SigMask::clrcurrsig, 1 );
95: pad->menu(m);
96: pad->options(TRUNCATE);
97: #ifdef V9
98: for( i = 1; i <= EXECKEY; ++i ) linereq( i, 0 );
99: #else
100: for( i = 1; i <= EXECKEY-1; ++i ) linereq( i, 0 );
101: #endif
102: }
103: pad->makecurrent();
104: }
105:
106: void SigMask::updatecore(char *error)
107: {
108: if( !error ) error = core->exechang(exechang);
109: if( !error ) error = core->signalmask(mask);
110: core->process()->pad->error(error);
111: }
112:
113: void SigMask::execline(long e)
114: {
115: static char *i[] = { "clear", "hang" };
116: static char *l[] = { "", ">>> " };
117: Menu m;
118: trace( "%d.execline(%d,ox%X)", this, e, a ); VOK;
119: exechang = e &= 1;
120: updatecore();
121: long comp = e^1;
122: m.last( i[comp], (Action) &SigMask::execline, comp );
123: Attrib a = 0;
124: pad->insert( EXECKEY, a, (PadRcv*)this, m, "%sexec()", l[e] );
125: }
126:
127: void SigBit::set(SigMask *s) { s->setsig(bit); }
128: void SigBit::clr(SigMask *s) { s->clrsig(bit); }
129: void SigBit::send(SigMask *s) { s->sendsig(bit); }
130:
131: void SigMask::linereq(long sig, Attrib a )
132: {
133: Menu m;
134: static SigBit *sigbit;
135: if( !sigbit )
136: sigbit = new SigBit[33];
137: trace( "%d.linereq(%d,0x%X)", this, sig, a ); VOK;
138: if( sig == EXECKEY ){
139: execline(exechang);
140: return;
141: }
142: char *on = mask&bit(sig) ? ">>> " : "";
143: m.last( "send signal", (Action)&SigBit::send, (long)this );
144: if( on[0] == '>' )
145: m.first("trace off", (Action)&SigBit::clr, (long)this);
146: else
147: m.first("trace on", (Action)&SigBit::set, (long)this);
148: sigbit[sig].bit = sig;
149: pad->insert(sig, a, (PadRcv*)(sigbit+sig), m, "%s%s", on, SignalName(sig));
150: }
151:
152: void SigMask::signalmask(long sig)
153: {
154: trace( "%d.signalmask(%d)", this, sig ); VOK;
155: linereq(sig, SELECTLINE);
156: updatecore();
157: }
158:
159: void SigMask::sendsig(long sig)
160: {
161: trace( "%d.sendsig(%d)", this, sig ); VOK;
162: updatecore(core->sendsig(sig));
163: }
164:
165: void SigMask::setsig(long sig)
166: {
167: trace( "%d.setsig(%d)", this, sig ); VOK;
168: mask |= bit(sig);
169: signalmask( sig );
170: }
171:
172: void SigMask::clrsig(long sig)
173: {
174: trace( "%d.clrsig(%d)", this, sig ); VOK;
175: mask &= ~bit(sig);
176: if( sig==SIGSTOP || sig==SIGTRAP )
177: updatecore( "warning: debugging signal disabled" );
178: signalmask( sig );
179: }
180:
181: void SigMask::hostclose()
182: {
183: trace( "%d.hostclose()", this ); VOK;
184: if( pad ){
185: delete pad;
186: pad = 0;
187: }
188: }
189:
190: void SigMask::clrcurrsig(long andgo)
191: {
192: trace( "%d.clrcurrsig()", this ); VOK;
193: updatecore(core->clrcurrsig());
194: if( andgo ) core->process()->go();
195: else core->process()->cycle();
196: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.