Linux C's signal and sigaction differences

http://blog.csdn.net/muge0913/article/details/7331129

To process a signal, you need to give the processing function called by the system when this signal occurs. The corresponding processing function can be registered for a specific signal (except for the Sigkill and Sigstop signals). After registering a signal's handler function, when the process receives this signal, no matter what state the process is in, it will stop the current task to execute the signal processing function.

1, register the signal function.

[CPP]View Plaincopyprint?

1. #include <signal.h>
3. void (*signal (int signumber,void (*FUNC) (int)) (int)

The signumber represents the signal that the signal processing function corresponds to. Func is a function pointer. This function has an integer parameter and returns a void type. In fact, Func can also take other fixed values such as: SIG_IGN,SIG_DFL.

Sig_ign said: Ignore the signal indicated by Signumber. The SIG_DFL represents a call to the system's default handler function. The return value type of the signal function is the same as the parameter func, which is a pointer to a function that has a null return value with an integer argument. Its correct return value should be the last time the signal was processed. Error returning Sig_err

The signal example is as follows:

[CPP]View Plaincopyprint?

2. #include <stdio.h>
6. #include <sys/types.h>
10. #include <stdlib.h>
14. #include <signal.h>
18. void func (int sig)
20. {
22. printf ("I get asignal!\n");
24. }
26. int main ()
28. {charbuffer[100];
32. if (Signal (SIGINT, func) = = Sig_err)
34. {
36. printf ("Signalerror exit now\n");
38. Exit (0);
40. }
42. printf ("pid:%ld\n", (long) getpid ());
46. for (;;)
50. {
54. Fgets (buffer,sizeof (buffer), stdin);
58. printf ("bufferis:%s\n", buffer);
62. }
64. return 0;
66. }

Typically, a user process needs to process multiple signals. You can register multiple signal processing functions in one program. A signal can correspond to a processing function, while multiple signals can correspond to a processing function.

For SIGINT signals we can use CTRL + C or CTRL + Z to interrupt the process to execute SIGINT registered functions.

2, advanced signal processing.

A more powerful system call is provided on the Linux system.

[CPP]View Plaincopyprint?

1. #include <signal.h>
3. int sigaction (int signumbet,const structsigaction *act,struct sigaction *oldact)

This function, in addition to registering the signal function, provides more detailed information about the exact details of the process receiving the signal.

The struct sigaction is defined as follows: implemented in Linux2.6.39/include/asm-generic/signal.h

[CPP]View Plaincopyprint?

1. struct sigaction
3. {
5. void (*sa_handler) (int);
7. void (*sa_sigaction) (int,siginfo_t *,void *);
9. Sigset_tsa_mask;
11. Intsa_flags;
13. }

Siginfo_t is implemented in Linux2.6.39/include/asm-generic/siginfo.h:

The value of Sa_flags is the following table, with 0 indicating all default options are selected.

Sa_nocldstop: Used to represent the signal sigchld, which does not produce this signal when the child process is interrupted, and only when the child process has ended.

Sa_nocldwati: When the signal is SIGCHLD, the child process can be avoided zombie.

Sa_nodefer: When the signal processing function is in progress, do not block the signal processing function itself signal function.

Sa_nomask: With Sa_nodefer

Sa_oneshot: When the signal processing function of the user registration is executed once, the processing function of the signal is set to the system default handler function.

Sa_resethand: With Sa_oneshot

Sa_restart: A system call that could not be rerun is automatically rerun.

Sa_siginfo: Indicates that the signal processing function is specified by sa_sigaction and not by Sa_handler, it will display more signal processing function information.

Actually, sinaction can replace the signal function completely.

[CPP]View Plaincopyprint?

2. #include <stdio.h>
4. #include <sys/types.h>
6. #include <stdlib.h>
8. #include <signal.h>
14. void func (int sig)
18. {
22. printf ("I get a signal!\n");
26. }
30. int main ()
34. {char buffer[100];
38. struct Sigaction Act;
40. Act.sa_handler=func;
42. Sigemptyset (&act.sa_mask);
44. act.sa_flags = 0;
48. if (Sigaction (sigint,&act, NULL) = =-1)
50. {
52. printf ("Sigaction Error exit now\n");
54. Exit (0);
56. }
60. printf ("pid:%ld\n", (long) getpid ());
64. for (;;)
66. {
68. Fgets (buffer,sizeof (buffer), stdin);
70. printf ("Buffer is:%s\n", buffer);
72. }
76. return 0;
80. }

Linux C's signal and sigaction differences