Mercurial > ecos-v2_0-branch

comparison packages/language/c/libc/signals/current/src/siginit.cxx @ 115:6ed91473a1cd ecos-sw-2000-08-21

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Merge from eCos master repository on 2000-08-21-22:40:54-BST
author jlarmour
date Fri, 25 Aug 2000 17:32:38 +0000
parents
children e0c0827131d1
comparison
equal deleted inserted replaced
114:5ad2b71d525e 115:6ed91473a1cd
1 //========================================================================
2 //
3 // siginit.cxx
4 //
5 // ISO C and POSIX 1003.1 signals implementation
6 //
7 //========================================================================
8 //####COPYRIGHTBEGIN####
9 //
10 // -------------------------------------------
11 // The contents of this file are subject to the Red Hat eCos Public License
12 // Version 1.1 (the "License"); you may not use this file except in
13 // compliance with the License. You may obtain a copy of the License at
14 // http://www.redhat.com/
15 //
16 // Software distributed under the License is distributed on an "AS IS"
17 // basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See the
18 // License for the specific language governing rights and limitations under
19 // the License.
20 //
21 // The Original Code is eCos - Embedded Configurable Operating System,
22 // released September 30, 1998.
23 //
24 // The Initial Developer of the Original Code is Red Hat.
25 // Portions created by Red Hat are
26 // Copyright (C) 1998, 1999, 2000 Red Hat, Inc.
27 // All Rights Reserved.
28 // -------------------------------------------
29 //
30 //####COPYRIGHTEND####
31 //========================================================================
32 //#####DESCRIPTIONBEGIN####
33 //
34 // Author(s): jlarmour
35 // Contributors:
36 // Date: 2000-04-18
37 // Purpose: Provide implementation of ISO C and POSIX 1003.1 signals
38 // Description: This file initializes all hardware exceptions,
39 // initializes the signal handler table and provides the
40 // default action function for signals
41 // Usage:
42 //
43 //####DESCRIPTIONEND####
44 //
45 //========================================================================
46
47 // CONFIGURATION
48
49 #include <pkgconf/libc_signals.h> // libc signals configuration
50
51 // INCLUDES
52
53 #include <cyg/infra/cyg_type.h> // Common type definitions and support
54 #include <signal.h> // Main signals definitions
55 #include <cyg/infra/cyg_ass.h> // Assertion infrastructure
56 #include <cyg/infra/cyg_trac.h> // Tracing infrastructure
57 #include <stdlib.h> // exit()
58
59 #ifdef CYGSEM_LIBC_SIGNALS_HWEXCEPTIONS
60 # include <pkgconf/kernel.h> // required for kernel includes
61 # include <cyg/kernel/except.hxx> // Kernel exception API
62 # include <cyg/kernel/thread.hxx> // Cyg_Thread::self()
63 # include <cyg/kernel/thread.inl> // inline definitions for above
64 # include <cyg/kernel/intr.hxx> // Interrupt enable
65 # include <cyg/hal/hal_intr.h> // HAL interrupt control
66 #endif
67
68 #ifdef CYGSEM_LIBC_SIGNALS_THREAD_SAFE
69 # include <pkgconf/kernel.h> // required for kernel includes
70 # include <cyg/kernel/mutex.hxx>
71 #endif
72
73 // TYPE DEFINITIONS
74
75 // define dummy class to allow initialization of cyg_libc_signal_handlers
76
77 class Cyg_libc_signals_dummy_init_class {
78 public:
79 Cyg_libc_signals_dummy_init_class();
80 };
81
82 #ifdef CYGSEM_LIBC_SIGNALS_HWEXCEPTIONS
83
84 struct exception_signal_mapping_t {
85 cyg_code exception;
86 int signal;
87 };
88
89 // EXTERNS
90
91 extern cyg_exception_handler cyg_null_exception_handler;
92
93 #endif // ifdef CYGSEM_LIBC_SIGNALS_HWEXCEPTIONS
94
95 // GLOBALS
96
97 // main signal handlers
98 __sighandler_t cyg_libc_signal_handlers[CYGNUM_LIBC_SIGNALS];
99
100 #ifdef CYGSEM_LIBC_SIGNALS_THREAD_SAFE
101 Cyg_Mutex cyg_libc_signal_handlers_mutex CYG_INIT_PRIORITY(LIBC);
102 #endif
103
104 // STATICS
105
106 // dummy object to invoke constructor
107 static Cyg_libc_signals_dummy_init_class
108 cyg_libc_signals_dummy_init_obj CYG_INIT_PRIORITY(LIBC);
109
110 #ifdef CYGSEM_LIBC_SIGNALS_HWEXCEPTIONS
111
112 # ifdef CYGDBG_USE_TRACING
113 static cyg_uint8 cyg_libc_signals_hwhandler_trace_level =
114 CYGNUM_LIBC_SIGNALS_HWHANDLER_TRACE_LEVEL;
115 # define TL1 (0 < cyg_libc_signals_hwhandler_trace_level)
116 # endif
117
118 # ifdef CYGSEM_LIBC_SIGNALS_CHAIN_HWEXCEPTIONS
119 // old exception info so we can chain
120 // FIXME: consider malloced linked list config option
121 static struct {
122 cyg_exception_handler *old_handler;
123 CYG_ADDRWORD old_data;
124 } exception_chain_data[CYGNUM_HAL_EXCEPTION_COUNT];
125 # endif
126
127 // struct that maps exceptions to signals
128 static const struct exception_signal_mapping_t
129 exception_signal_mapping[] = {
130
131 #ifdef CYGNUM_HAL_EXCEPTION_DATA_ACCESS
132 {CYGNUM_HAL_EXCEPTION_DATA_ACCESS, SIGBUS},
133 #endif
134 #ifdef CYGNUM_HAL_EXCEPTION_DATA_WRITE
135 {CYGNUM_HAL_EXCEPTION_DATA_WRITE, SIGBUS},
136 #endif
137 #ifdef CYGNUM_HAL_EXCEPTION_CODE_ACCESS
138 {CYGNUM_HAL_EXCEPTION_CODE_ACCESS, SIGBUS},
139 #endif
140 #ifdef CYGNUM_HAL_EXCEPTION_CODE_WRITE
141 {CYGNUM_HAL_EXCEPTION_CODE_WRITE, SIGBUS},
142 #endif
143 #ifdef CYGNUM_HAL_EXCEPTION_CODE_EXECUTE
144 {CYGNUM_HAL_EXCEPTION_CODE_EXECUTE, SIGBUS},
145 #endif
146 #ifdef CYGNUM_HAL_EXCEPTION_IO_ACCESS
147 {CYGNUM_HAL_EXCEPTION_IO_ACCESS, SIGBUS},
148 #endif
149 #ifdef CYGNUM_HAL_EXCEPTION_IO_WRITE
150 {CYGNUM_HAL_EXCEPTION_IO_ACCESS, SIGBUS},
151 #endif
152 #ifdef CYGNUM_HAL_EXCEPTION_DATA_TLBMISS_ACCESS
153 {CYGNUM_HAL_EXCEPTION_DATA_TLBMISS_ACCESS, SIGSEGV},
154 #endif
155 #ifdef CYGNUM_HAL_EXCEPTION_DATA_TLBMISS_WRITE
156 {CYGNUM_HAL_EXCEPTION_DATA_TLBMISS_WRITE, SIGSEGV},
157 #endif
158 #ifdef CYGNUM_HAL_EXCEPTION_CODE_TLBMISS_ACCESS
159 {CYGNUM_HAL_EXCEPTION_CODE_TLBMISS_ACCESS, SIGSEGV},
160 #endif
161 #ifdef CYGNUM_HAL_EXCEPTION_CODE_TLBMISS_WRITE
162 {CYGNUM_HAL_EXCEPTION_CODE_TLBMISS_WRITE, SIGSEGV},
163 #endif
164 #ifdef CYGNUM_HAL_EXCEPTION_DATA_TLBERROR_ACCESS
165 {CYGNUM_HAL_EXCEPTION_DATA_TLBERROR_ACCESS, SIGSEGV},
166 #endif
167 #ifdef CYGNUM_HAL_EXCEPTION_DATA_TLBERROR_WRITE
168 {CYGNUM_HAL_EXCEPTION_DATA_TLBERROR_WRITE, SIGSEGV},
169 #endif
170 #ifdef CYGNUM_HAL_EXCEPTION_CODE_TLBERROR_ACCESS
171 {CYGNUM_HAL_EXCEPTION_CODE_TLBERROR_ACCESS, SIGSEGV},
172 #endif
173 #ifdef CYGNUM_HAL_EXCEPTION_CODE_TLBERROR_WRITE
174 {CYGNUM_HAL_EXCEPTION_CODE_TLBERROR_WRITE, SIGSEGV},
175 #endif
176 #ifdef CYGNUM_HAL_EXCEPTION_DATA_UNALIGNED_ACCESS
177 {CYGNUM_HAL_EXCEPTION_DATA_UNALIGNED_ACCESS, SIGBUS},
178 #endif
179 #ifdef CYGNUM_HAL_EXCEPTION_DATA_UNALIGNED_WRITE
180 {CYGNUM_HAL_EXCEPTION_DATA_UNALIGNED_WRITE, SIGBUS},
181 #endif
182 #ifdef CYGNUM_HAL_EXCEPTION_IO_UNALIGNED_ACCESS
183 {CYGNUM_HAL_EXCEPTION_IO_UNALIGNED_ACCESS, SIGBUS},
184 #endif
185 #ifdef CYGNUM_HAL_EXCEPTION_IO_UNALIGNED_WRITE
186 {CYGNUM_HAL_EXCEPTION_IO_UNALIGNED_WRITE, SIGBUS},
187 #endif
188 #ifdef CYGNUM_HAL_EXCEPTION_ILLEGAL_INSTRUCTION
189 {CYGNUM_HAL_EXCEPTION_ILLEGAL_INSTRUCTION, SIGILL},
190 #endif
191 #ifdef CYGNUM_HAL_EXCEPTION_INTERRUPT
192 {CYGNUM_HAL_EXCEPTION_INTERRUPT, SIGINT},
193 #endif
194 #ifdef CYGNUM_HAL_EXCEPTION_TRAP
195 {CYGNUM_HAL_EXCEPTION_TRAP, SIGTRAP},
196 #endif
197 #ifdef CYGNUM_HAL_EXCEPTION_DIV_BY_ZERO
198 {CYGNUM_HAL_EXCEPTION_DIV_BY_ZERO, SIGFPE},
199 #endif
200 #ifdef CYGNUM_HAL_EXCEPTION_OVERFLOW
201 {CYGNUM_HAL_EXCEPTION_OVERFLOW, SIGFPE},
202 #endif
203 #ifdef CYGNUM_HAL_EXCEPTION_BOUNDS
204 {CYGNUM_HAL_EXCEPTION_BOUNDS, SIGSEGV},
205 #endif
206 #ifdef CYGNUM_HAL_EXCEPTION_SINGLE_STEP
207 {CYGNUM_HAL_EXCEPTION_SINGLE_STEP, SIGTRAP},
208 #endif
209 #ifdef CYGNUM_HAL_EXCEPTION_INSTRUCTION_BP
210 {CYGNUM_HAL_EXCEPTION_INSTRUCTION_BP, SIGTRAP},
211 #endif
212 #ifdef CYGNUM_HAL_EXCEPTION_PERIPHERAL_BP
213 {CYGNUM_HAL_EXCEPTION_PERIPHERAL_BP, SIGTRAP},
214 #endif
215 #ifdef CYGNUM_HAL_EXCEPTION_DATA_BP
216 {CYGNUM_HAL_EXCEPTION_DATA_BP, SIGTRAP},
217 #endif
218 #ifdef CYGNUM_HAL_EXCEPTION_DEVELOPMENT_BP
219 {CYGNUM_HAL_EXCEPTION_DEVELOPMENT_BP, SIGTRAP},
220 #endif
221 #ifdef CYGNUM_HAL_EXCEPTION_STACK_OVERFLOW
222 {CYGNUM_HAL_EXCEPTION_STACK_OVERFLOW, SIGSEGV},
223 #endif
224 #ifdef CYGNUM_HAL_EXCEPTION_STACK_FAULT
225 {CYGNUM_HAL_EXCEPTION_STACK_FAULT, SIGSEGV},
226 #endif
227 #ifdef CYGNUM_HAL_EXCEPTION_PARITY
228 {CYGNUM_HAL_EXCEPTION_PARITY, SIGBUS},
229 #endif
230 #ifdef CYGNUM_HAL_EXCEPTION_FPU
231 {CYGNUM_HAL_EXCEPTION_FPU, SIGFPE},
232 #endif
233 #ifdef CYGNUM_HAL_EXCEPTION_FPU_NOT_AVAIL
234 {CYGNUM_HAL_EXCEPTION_FPU_NOT_AVAIL, SIGFPE},
235 #endif
236 #ifdef CYGNUM_HAL_EXCEPTION_FPU_OVERFLOW
237 {CYGNUM_HAL_EXCEPTION_FPU_OVERFLOW, SIGFPE},
238 #endif
239 #ifdef CYGNUM_HAL_EXCEPTION_FPU_UNDERFLOW
240 {CYGNUM_HAL_EXCEPTION_FPU_UNDERFLOW, SIGFPE},
241 #endif
242 #ifdef CYGNUM_HAL_EXCEPTION_FPU_DIV_BY_ZERO
243 {CYGNUM_HAL_EXCEPTION_FPU_DIV_BY_ZERO, SIGFPE},
244 #endif
245 #ifdef CYGNUM_HAL_EXCEPTION_SYSTEM_CALL
246 {CYGNUM_HAL_EXCEPTION_SYSTEM_CALL, SIGSYS},
247 #endif
248 {0, 0} // dummy value to ensure compiler is happy
249 };
250
251
252 // FUNCTIONS
253
254 /////////////////////////////////////////
255 // cyg_libc_signals_hwexcept_handler() //
256 /////////////////////////////////////////
257
258 // FIXME: should be able to get this work with
259 // CYGSEM_KERNEL_EXCEPTIONS_DECODE disabled as well as enabled
260 static void
261 cyg_libc_signals_hwexcept_handler( CYG_ADDRWORD data, cyg_code exception,
262 CYG_ADDRWORD info)
263 {
264 int signal = (int)data;
265 int ret;
266
267 CYG_REPORT_FUNCNAME("cyg_libc_signals_hwexcept_handler");
268
269 CYG_REPORT_FUNCARG3( "data = %08x, exception = %d, info = %08x",
270 data, exception, info );
271
272 #ifdef CYGSEM_LIBC_SIGNALS_BAD_SIGNAL_FATAL
273 CYG_PRECONDITION((signal > 0) && (signal < CYGNUM_LIBC_SIGNALS),
274 "Signal number not valid!");
275 #endif
276
277 // chain first as it may be more useful more low-level stuff needed
278 #ifdef CYGSEM_LIBC_SIGNALS_CHAIN_HWEXCEPTIONS
279 // map exception to 0..CYGNUM_HAL_EXCEPTION_COUNT
280 exception -= CYGNUM_HAL_EXCEPTION_MIN;
281
282 // special case for null handler since it is only for uncaught exceptions
283
284 if (exception_chain_data[exception].old_handler !=
285 cyg_null_exception_handler) {
286 (*exception_chain_data[exception].old_handler)(
287 exception_chain_data[exception].old_data, exception, info);
288 CYG_TRACE0(TL1, "Chained exception handler returned");
289 } // if
290 #endif
291
292 #ifndef CYGSEM_LIBC_SIGNALS_BAD_SIGNAL_FATAL
293 // if not fatal, silently return
294 if ((signal <= 0) || (signal >= CYGNUM_LIBC_SIGNALS)) {
295 CYG_REPORT_RETURN();
296 return;
297 }
298 #endif
299
300 CYG_TRACE0(TL1, "Enabling interrupts");
301 HAL_ENABLE_INTERRUPTS();
302
303 CYG_TRACE0(TL1, "Raising signal");
304 ret = raise(signal);
305
306 if (ret) {
307 CYG_TRACE1(TL1, "raise() returned non-zero value %d!!!", ret);
308 } // if
309
310 CYG_REPORT_RETURN();
311 } // cyg_libc_signals_hwexcept_handler()
312
313
314 //////////////////
315 // reg_except() //
316 //////////////////
317
318 static void inline
319 reg_except( cyg_code exception, int signal )
320 {
321 Cyg_Thread::self()->register_exception(
322 exception, &cyg_libc_signals_hwexcept_handler, (CYG_ADDRWORD)signal,
323 #ifdef CYGSEM_LIBC_SIGNALS_CHAIN_HWEXCEPTIONS
324 &exception_chain_data[exception -
325 CYGNUM_HAL_EXCEPTION_MIN].old_handler,
326 &exception_chain_data[exception - CYGNUM_HAL_EXCEPTION_MIN].old_data
327 #else
328 NULL, NULL
329 #endif
330 );
331
332 } // reg_except();
333
334 #endif // ifdef CYGSEM_LIBC_SIGNALS_HWEXCEPTIONS
335
336 ///////////////////////////////////////////////////
337 // Cyg_libc_signals_dummy_init_class constructor //
338 ///////////////////////////////////////////////////
339
340 Cyg_libc_signals_dummy_init_class::Cyg_libc_signals_dummy_init_class()
341 {
342 cyg_ucount8 i;
343
344 CYG_REPORT_FUNCNAME("Cyg_libc_signals_dummy_init_class constructor");
345
346 // FIXME: some should be SIG_IGN?
347 for (i=0; i<CYGNUM_LIBC_SIGNALS; i++)
348 cyg_libc_signal_handlers[i] = SIG_DFL;
349
350 #ifdef CYGSEM_LIBC_SIGNALS_HWEXCEPTIONS
351 // go through the entire array of exceptions, _but_ subtract 1 for
352 // the dummy at the end
353 for (i=0; i < (sizeof(exception_signal_mapping) /
354 sizeof(exception_signal_mapping_t) - 1); i++) {
355 CYG_ASSERT( (exception_signal_mapping[i].exception <=
356 CYGNUM_HAL_EXCEPTION_MAX) &&
357 (exception_signal_mapping[i].exception >=
358 CYGNUM_HAL_EXCEPTION_MIN),
359 "Asked to register bad exception");
360
361 CYG_ASSERT( (exception_signal_mapping[i].signal > 0) &&
362 (exception_signal_mapping[i].signal <
363 CYGNUM_LIBC_SIGNALS), "Asked to register bad signal" );
364
365 reg_except( exception_signal_mapping[i].exception,
366 exception_signal_mapping[i].signal);
367 }
368 #endif
369
370 CYG_REPORT_RETURN();
371 } // Cyg_libc_signals_dummy_init_class() constructor
372
373
374 ////////////////////////////////////////
375 // cyg_libc_signals_default_handler() //
376 ////////////////////////////////////////
377
378 // Default signal handler - SIG_DFL
379 externC void
380 cyg_libc_signals_default_handler(int sig)
381 {
382 CYG_REPORT_FUNCNAME( "cyg_libc_signals_default_handler" );
383
384 CYG_REPORT_FUNCARG1( "signal number = %d", sig );
385
386 exit(1000 + sig); // FIXME
387
388 CYG_REPORT_RETURN();
389 } // cyg_libc_signals_default_handler()
390
391 #ifdef CYGSEM_LIBC_SIGNALS_THREAD_SAFE
392 /////////////////////////////////////
393 // cyg_libc_signals_lock_do_lock() //
394 /////////////////////////////////////
395
396 externC cyg_bool
397 cyg_libc_signals_lock_do_lock(void)
398 {
399 cyg_bool ret;
400 CYG_REPORT_FUNCNAMETYPE("cyg_libc_signals_lock_do_lock", "returning %d");
401
402 ret = cyg_libc_signal_handlers_mutex.lock();
403
404 CYG_REPORT_RETVAL(ret);
405
406 return ret;
407 } // cyg_libc_signals_lock_do_lock()
408
409 ///////////////////////////////////////
410 // cyg_libc_signals_lock_do_unlock() //
411 ///////////////////////////////////////
412
413 externC void
414 cyg_libc_signals_lock_do_unlock(void)
415 {
416 CYG_REPORT_FUNCNAME("cyg_libc_signals_lock_do_unlock");
417
418 cyg_libc_signal_handlers_mutex.unlock();
419
420 CYG_REPORT_RETURN();
421 } // cyg_libc_signals_lock_do_unlock()
422
423 #endif // ifdef CYGSEM_LIBC_SIGNALS_THREAD_SAFE
424
425 // EOF siginit.cxx