Sigprocmask blocks the process.

This series of articles written by muge0913, reproduced please note the Source: http://blog.csdn.net/muge0913/article/details/7334771

1. Sometimes you do not want to stop the current execution immediately when receiving a signal to process the signal, or ignore the signal, but call the signal processing function for a period of time. This is achieved through blocking signals.

 

2. Differences between signal blocking and ignoring signals.

The concept of blocking is different from that of ignoring signals. The operating system will not talk about signal transmission before the signal is blocked by the process. The blocked signal will not affect the process. The signal is only temporarily blocked. When a process ignores a signal, the signal is transmitted, but the process discards the signal.

 

3. Signal blocking system calls all play a blocking role. They are not used in collaboration.

[CPP]
View plaincopyprint?

1. # Include <signal. h>
3. Int sigprocmask (UBT how, const sigset_t * Set, sigset_t * oldset );
5. Int sigsuspend (const sigset_t * sigmask );

#include <signal.h>int sigprocmask(ubt how,const sigset_t*set,sigset_t *oldset);int sigsuspend(const sigset_t*sigmask);

Sigprocmask sets the signal processing method (blocking or not blocking) in the signal shield set ).

Parameters:

How: used to specify the signal modification method. Three methods may be selected.

Sig_block // Add the signals in the Set signal set to the current signal mask. That is, the signal mask and the Set signal set are used or operated.

Sig_unblock // Delete the signal contained in the signal set to which the set points from the current signal mask. That is, the signal mask and set operations.

Sig_setmask // set the set value to the new process signal mask. That is, set assigns values to the signal mask.

 

Set: indicates the pointer to the signal set. This refers to the new signal set. If you only want to read the current shielding value, you can set it to null.

Oldset: a pointer to the signal set, where the original signal set is stored. It can be used to detect the signal in the signal mask.

Return description:

0 is returned when execution is successful. -1 is returned for failure, and errno is set to einval.

 

Sigprocmask example (demonstrate adding a signal mask ):

[CPP]
View plaincopyprint?

1. # Include <stdio. h>
2. # Include <signal. h>
3. Void checkset ();
5. Void main ()
6. {
7. Sigset_tblockset;
8. Sigemptyset (& blockset );
9. Sigaddset (& blockset, SIGINT );
10. Sigaddset (& blockset, sigtstp );
12. Checkset ();
14. Sigprocmask (sig_setmask, & blockset, null );
15. Checkset ();
17. Sigaddset (& blockset, sigterm );
18. Sigprocmask (sig_block, & blockset, null );
19. Checkset ();
21. Sigdelset (& blockset, sigterm );
22. Sigprocmask (sig_unblock, & blockset, null );
23. Checkset ();
24. }
26. Void checkset ()
27. {
29. Sigset_tset set;
30. Printf ("checksetstart: \ n ");
32. If (sigprocmask (0, null, & set) <0)
33. {
34. Printf ("checksetsigprocmask Error !! \ N ");
35. Exit (0 );
36. }
38. If (sigismember (& set, SIGINT ))
39. Printf ("SIGINT \ n ");
40. If (sigismember (& set, sigtstp ))
41. Printf ("sigtstp \ n ");
43. If (sigismember (& set, sigterm ))
44. Printf ("sigterm \ n ");
45. Printf ("checksetend \ n ");
46. }

#include <stdio.h>#include <signal.h>void checkset();void main(){     sigset_tblockset;     sigemptyset(&blockset);     sigaddset(&blockset,SIGINT);     sigaddset(&blockset,SIGTSTP);     checkset();     sigprocmask(SIG_SETMASK,&blockset,NULL);     checkset();     sigaddset(&blockset,SIGTERM);     sigprocmask(SIG_BLOCK,&blockset,NULL);     checkset();     sigdelset(&blockset,SIGTERM);     sigprocmask(SIG_UNBLOCK,&blockset,NULL);     checkset();}void checkset(){     sigset_tset set;     printf("checksetstart:\n");     if(sigprocmask(0,NULL,&set)<0)     {     printf("checksetsigprocmask error!!\n");     exit(0);     }     if(sigismember(&set,SIGINT))     printf("sigint\n");     if(sigismember(&set,SIGTSTP))     printf("sigtstp\n");     if(sigismember(&set,SIGTERM))     printf("sigterm\n");      printf("checksetend\n");}

Sigprocmask example (to demonstrate that some code is not disturbed by signals ):

 

[CPP]
View plaincopyprint?

1. # Include <stdio. h>
2. # Include <signal. h>
3. Void checkset ();
5. Void func ();
6. Void main ()
7. {
8. Sigset_tblockset, oldblockset, pendmask;
9. Printf ("PID: % LD \ n", (long) getpid ());
11. Signal (SIGINT, func); // semaphore capture function, capture SIGINT, jump to function pointer func to execute
    
13. Sigemptyset (& blockset); // initializes the semaphore set
    
14. Sigaddset (& blockset, sigtstp); // Add sigtstp to the semaphore set
    
15. Sigaddset (& blockset, SIGINT); // Add SIGINT to the semaphore set
    
17. Sigprocmask (sig_setmask, & blockset, & oldblockset); // block SIGINT and sigtstp in blockset, and save the current signal shielding characters
    
19. /* The following program will not be disturbed by signals */
20. Checkset ();
21. Sleep (5 );
22. Sigpending (& pendmask); // check the signal is pending
    
23. If (sigismember (& pendmask, SIGINT) // SIGINT is pending. Pending means that sigquit is blocked and not processed
    
24. Printf ("sigintpending \ n ");
26. /* End without disturbing */
28. Sigprocmask (sig_setmask, & oldblockset, null); // restores blocked SIGINT sigtstp
    
29. Printf ("sigintunblocked \ n ");
30. Sleep (6 );
31. }
33. Void checkset ()
34. {
35. Sigset_tset;
36. Printf ("checksetstart: \ n ");
37. If (sigprocmask (0, null, & set) <0)
38. {
39. Printf ("checksetsigprocmask Error !! \ N ");
40. Exit (0 );
41. }
42. If (sigismember (& set, SIGINT ))
43. Printf ("SIGINT \ n ");
45. If (sigismember (& set, sigtstp ))
46. Printf ("sigtstp \ n ");
48. If (sigismember (& set, sigterm ))
49. Printf ("sigterm \ n ");
51. Printf ("checksetend \ n ");
53. }
54. Void func ()
55. {
56. Printf ("hellofunc \ n ");
57. }