Examine and/or specify actions for signals
#include <sys/neutrino.h> int SignalAction( pid_t pid, void (*sigstub)(void), int signo, const struct sigaction *act, struct sigaction *oact ); int SignalAction_r( pid_t pid, void (*sigstub)(void), int signo, const struct sigaction *act, struct sigaction *oact );
If the signal terminates a process, the cleanup of the terminated process occurs by default at the priority of the thread that sent the signal. If you OR the SIG_TERMER_NOINHERIT flag (defined in <signal.h>) into sig, the cleanup occurs at the priority of the thread that received the signal.
Use the -l c option to qcc to link against this library. This library is usually included automatically.
The SignalAction() and SignalAction_r() kernel calls let the calling process examine or specify (or both) the action to be associated with a specific signal in the process pid. If pid is zero, the calling process is used. The argument signo specifies the signal.
|You should call the POSIX sigaction() function or the ANSI signal() function instead of using these kernel calls directly.|
These functions are identical except in the way they indicate errors. See the Returns section for details.
If act isn't NULL, then the specified signal is modified. If oact isn't NULL, the previous action is stored in the structure it points to. You can use various combinations of act and oact to query or set (or both) the action for a signal.
Signal handlers and actions are defined for the process and affect all threads in the process. For example, if one thread ignores a signal, then all threads ignore the signal.
You can target a signal at a thread, process or process group (see SignalKill()). When targeted at a process, at most one thread receives the signal. This thread must have the signal unblocked (see SignalProcmask()) to be a candidate for receiving it. All synchronously generated signals (e.g. SIGSEGV) are always delivered to the thread that caused them.
In a multithreaded process, if a signal terminates a thread, by default all threads and thus the process are terminated. You can override this standard POSIX behavior when you create the thread; see the PTHREAD_MULTISIG_ALLOW and PTHREAD_MULTISIG_DISALLOW flags in the entry for ThreadCreate().
The signals are defined in <signal.h>. The entire range of signals goes from _SIGMIN (1) to _SIGMAX (64):
|1–57||57 POSIX signals (including traditional UNIX signals)|
|41–56||16 POSIX realtime signals (SIGRTMIN to SIGRTMAX)|
|57–64||Eight special-purpose QNX Neutrino signals, some of which are named (SIGSELECT and SIGPHOTON). They're always masked, and attempts to unmask them are ignored.|
The following global variables are also declared in <signal.h>:
|The sys_siglist array doesn't include the QNX Neutrino signals, and strsignal() returns a pointer to an empty string for them.|
The POSIX and UNIX signals include:
|SIGABRT||Abnormal termination, issued by functions such as abort()||Kill the process and write a dump file|
|SIGALRM||Alarm clock, issued by functions such as alarm()||Kill the process|
|SIGBUS||Bus error, or a memory parity error (a QNX Neutrino-specific interpretation). If a second fault occurs while your process is in a signal handler for this fault, the process is terminated.||Kill the process and write a dump file|
|SIGCHLD or SIGCLD||A child process terminated||Ignore the signal, but still let the process's children become zombies|
|SIGCONT||Continue the process. You can't block this signal.||Make the process continue if it's STOPPED; otherwise ignore the signal|
|SIGDEADLK||A mutex deadlock occurred. If a process dies while holding a mutex, and you haven't called SyncMutexEvent() to set up an event to be delivered to the mutex's owner when the mutex dies, the kernel delivers a SIGDEADLK instead to all threads that are waiting on the mutex without a timeout.||Kill the process and write a dump file|
|SIGEMT||EMT instruction (emulation trap)||Kill the process and write a dump file|
|SIGFPE||Floating point exception||Kill the process and write a dump file|
|SIGHUP||Hangup; the session leader died, or the controlling terminal closed||Kill the process|
|SIGILLa||Illegal hardware instruction. If a second fault occurs while your thread is in a signal handler for this fault, the process is terminated.||Kill the process and write a dump file|
|SIGINT||Interrupt; typically generated when you press Ctrl-C or Ctrl-Break (you can change this with stty)||Kill the process|
|SIGIO||Asynchronous I/O||Ignore the signal|
|SIGIOT||I/O trap; a synonym for SIGABRT||Kill the process|
|SIGKILL||Kill. You can't block or catch this signal.||Kill the process|
|SIGPIPE||Write on pipe with no reader||Kill the process|
|SIGPOLL||System V name for SIGIO||Ignore the signal|
|SIGPROF||Profiling timer expired. POSIX has marked this signal as obsolescent; QNX Neutrino doesn't support profiling timers or send this signal.||Kill the process|
|SIGPWR||Power failure||Kill the process|
|SIGQUIT||Quit; typically generated when you press Ctrl-\ (you can change this with stty)||Kill the process and write a dump file|
|SIGSEGV||Segmentation violation; an invalid memory reference was detected. If a second fault occurs while your process is in a signal handler for this fault, the process will be terminated.||Kill the process and write a dump file|
|SIGSTOP||Stop the process. You can't block or catch this signal.||Stop the process|
|SIGSYS||Bad argument to system call||Kill the process and write a dump file|
|SIGTERM||Termination signal||Kill the process|
|SIGTRAP||Trace trap||Kill the process and write a dump file|
|SIGTSTP||Stop signal from tty; typically generated when you press Ctrl-Z (you can change this with stty)||Stop the process|
|SIGTTIN||Background read attempted from control terminal||Stop the process|
|SIGTTOU||Background write attempted to control terminal||Stop the process|
|SIGURG||Urgent condition on I/O channel||Ignore the signal|
|SIGUSR1||User-defined signal 1||Kill the process|
|SIGUSR2||User-defined signal 2||Kill the process|
|SIGVTALRM||Virtual timer expired. POSIX has marked this signal as obsolescent; QNX Neutrino doesn't support virtual timers or send this signal.||Kill the process|
|SIGWINCH||The size of the terminal window changed||Ignore the signal|
|SIGXCPU||Soft CPU time limit exceeded; see the RLIMIT_CPU resource for setrlimit()||Kill the process and write a dump file|
a One possible cause for a SIGILL signal is trying to perform an operation that requires I/O privileges. A thread can request these privileges by calling ThreadCtl(), specifying the _NTO_TCTL_IO flag:
ThreadCtl( _NTO_TCTL_IO, 0 );
These calls don't block.
The only difference between these functions is the way they indicate errors:
abort(), ChannelCreate(), kill(), longjmp(), struct sigaction, siginfo_t, siglongjmp(), signal(), sigaction(), SignalKill(), SignalProcmask(), sigqueue(), sigsetjmp(), SyncMutexLock(), ThreadCreate(), wait(), waitpid()
“Process termination” in the “Processes” chapter of the QNX Neutrino Programmer's Guide