SYNOPSIS
#include <signal.h>
void ( * signal(int sig, void(*func)(int)) )(int);
void ( * _signal_r(void *reent, int sig, void(*func)(int)) )(int);
int raise (int sig);
int _raise_r (void *reent, int sig);
DESCRIPTION signal,
raise
provide a simple signal/raise implementation for embedded targets.
signal
allows you to request changed treatment for a particular signal sig.
You can use one of the predefined macros, SIG_DFL
(select system default handling) or SIG_IGN
(ignore this signal) as the value of func;
otherwise, func
is a function pointer that identifies a subroutine in your program as the
handler for this signal.
Some of the execution environment
for signal handlers is unpredictable; notably, the only library function
required to work correctly from within a signal handler is signal
itself, and only when used to redefine the handler for the current signal
value.
Static storage is likewise
unreliable for signal handlers, with one exception: if you declare a static
storage location as volatile
sig_atomic_t,
then you may use that location in a signal handler to store signal values.
If your signal handler terminates
using return
(or implicit return), your program’s execution continues at the point where
it was when the signal was raised (whether by your program itself, or by
an external event). Signal handlers can also use functions such as exit
and abort
to avoid returning.
raise
sends the signal sig
to the executing program. It returns zero if successful, non-zero if unsuccessful.
The alternate functions,
_signal_r,
_raise_r,
are the reentrant
versions. The extra argument, reent,
is a pointer to a reentrancy structure.
RETURNS If your request for a signal handler cannot be honored, the result
is SIG_ERR;
a specific error number is also recorded in errno.
Otherwise, the result is
the previous handler (a function pointer or one of the predefined macros).
COMPLIANCE ANSI C requires raise
and signal.
No supporting OS subroutines are required to link with signal,
but it will not have any useful effects, except for software generated
signals, without an operating system that can actually raise exceptions.
