Документ взят из кэша поисковой машины. Адрес
оригинального документа
: http://www.sao.ru/hq/sts/linux/book/c_marshall/node24.html
Дата изменения: Unknown Дата индексирования: Tue Oct 2 15:48:19 2012 Кодировка: Поисковые слова: п п п п п п п п п п п п п п п п п п п |
Signals are software generated interrupts that are sent to a process when a event happens. Signals can be synchronously generated by an error in an application, such as SIGFPE and SIGSEGV, but most signals are asynchronous. Signals can be posted to a process when the system detects a software event, such as a user entering an interrupt or stop or a kill request from another process. Signals can also be come directly from the OS kernel when a hardware event such as a bus error or an illegal instruction is encountered. The system defines a set of signals that can be posted to a process. Signal delivery is analogous to hardware interrupts in that a signal can be blocked from being delivered in the future. Most signals cause termination of the receiving process if no action is taken by the process in response to the signal. Some signals stop the receiving process and other signals can be ignored. Each signal has a default action which is one of the following:
Each signal defined by the system falls into one of five classes:
Macros are defined in
<signal.h> header file for common signals.
These include:
SIGHUP 1 /* hangup */ | SIGINT 2 /* interrupt */ |
SIGQUIT 3 /* quit */ | SIGILL 4 /* illegal instruction */ |
SIGABRT 6 /* used by abort */ | SIGKILL 9 /* hard kill */ |
SIGALRM 14 /* alarm clock */ | |
SIGCONT 19 /* continue a stopped process */ | |
SIGCHLD 20 /* to parent on child stop or exit */ |
Signals can be numbered from 0 to 31.
There are two common functions used to send signals
int kill(int pid, int signal) - a system call that send a signal to a process,
pid. If pid is greater than zero, the signal is sent to the process whose
process ID is equal to pid. If pid is 0, the signal is sent to all processes,
except system processes.
kill() returns 0 for a successful call, -1 otherwise and sets errno
accordingly.
int raise(int sig) sends the signal sig to the executing program. raise() actually uses kill() to send the signal to the executing program:
kill(getpid(), sig);
There is also a UNIX command called kill that can be used to send signals from the command line - see man pages.
NOTE: that unless caught or ignored, the kill signal terminates the
process. Therefore protection is built into the system.
Only processes with certain access
privileges can be killed off.
Basic rule: only processes that have the same user
can send/receive messages.
The SIGKILL signal cannot be caught or ignored and will always terminate a process.
For examplekill(getpid(),SIGINT); would send the interrupt
signal to the id of the calling process.
This would have a similar effect to
exit() command. Also ctrl-c typed from the command sends a
SIGINT to the process currently being.
unsigned int alarm(unsigned int seconds) -- sends the signal SIGALRM to the invoking process after seconds seconds.
An application program can specify a function called a signal handler to be invoked when a specific signal is received. When a signal handler is invoked on receipt of a signal, it is said to catch the signal. A process can deal with a signal in one of the following ways:
Receiving signals is straighforward with the function:
int (*signal(int sig, void (*func)()))() -- that is to say the function signal() will call the func functions if the process receives a signal sig. Signal returns a pointer to function func if successful or it returns an error to errno and -1 otherwise.
func() can have three values:
SIG_DFL and SIG_IGN are defined in signal.h (standard
library) header file.
Thus to ignore a ctrl-c command from the command line. we could
do:
signal(SIGINT, SIG_IGN);
TO reset system so that SIGINT causes a termination at any place
in our program, we would do:
signal(SIGINT, SIG_DFL);
So lets write a program to trap a ctrl-c but not quit on this signal. We
have a function sigproc() that is executed when we trap a
ctrl-c. We will also set another function to quit the program if it traps the
SIGQUIT signal so we can terminate our program:
#include <stdio.h>
void sigproc(void);
void quitproc(void);
main()
{ signal(SIGINT, sigproc);
signal(SIGQUIT, quitproc);
printf(``ctrl-c disabled use ctrl-
to quit
n'');
for(;;); /* infinite loop */}
void sigproc()
{ signal(SIGINT, sigproc); /* */
/* NOTE some versions of UNIX will reset signal to default
after each call. So for portability reset signal each time */
printf(``you have pressed ctrl-c
n'');
}
void quitproc()
{ printf(``ctrl-
pressed to quit
n'');
exit(0); /* normal exit status */
}
Let us now write a program that communicates between child and parent
processes using kill() and signal().
fork() creates the child process from the parent. The pid can be
checked to decide whether it is the child (== 0) or the parent (pid = child
process id).
The parent can then send messages to child using the pid and kill().
The child picks up these signals with signal() and calls appropriate
functions.
An example of communicating process using signals is sig_talk.c:
/* sig_talk.c --- Example of how 2 processes can talk */ /* to each other using kill() and signal() */ /* We will fork() 2 process and let the parent send a few */ /* signals to it`s child */ /* cc sig_talk.c -o sig_talk */ #include <stdio.h> #include <signal.h> void sighup(); /* routines child will call upon sigtrap */ void sigint(); void sigquit(); main() { int pid; /* get child process */ if ((pid = fork()) < 0) { perror("fork"); exit(1); } if (pid == 0) { /* child */ signal(SIGHUP,sighup); /* set function calls */ signal(SIGINT,sigint); signal(SIGQUIT, sigquit); for(;;); /* loop for ever */ } else /* parent */ { /* pid hold id of child */ printf("\nPARENT: sending SIGHUP\n\n"); kill(pid,SIGHUP); sleep(3); /* pause for 3 secs */ printf("\nPARENT: sending SIGINT\n\n"); kill(pid,SIGINT); sleep(3); /* pause for 3 secs */ printf("\nPARENT: sending SIGQUIT\n\n"); kill(pid,SIGQUIT); sleep(3); } } void sighup() { signal(SIGHUP,sighup); /* reset signal */ printf("CHILD: I have received a SIGHUP\n"); } void sigint() { signal(SIGINT,sigint); /* reset signal */ printf("CHILD: I have received a SIGINT\n"); } void sigquit() { printf("My DADDY has Killed me!!!\n"); exit(0); }
There are a few other functions defined in signal.h:
int sighold(int sig) -- adds sig to the calling process's signal mask
int sigrelse(int sig) -- removes sig from the calling process's signal mask
int sigignore(int sig) -- sets the disposition of sig to SIG_IGN
int sigpause(int sig) -- removes sig from the calling process's signal mask and suspends the calling process until a signal is received