signal 함수는 간단하게 사용할 수 있기는 하지만 시그널을 객체로 보지 않고, 단일 대상으로 본다는 문제점을 가진다. sigaction을 사용하면 시그널을 객체로 다룰 수 있는데, 이 객체에는 다음과 같은 것들이 포함된다.

• 시그널 set
  
• 시그널에 대한 정책
  
• 시그널 함수
  

이러한 요소들을 하나의 객체로 볼 경우 분명히 더 쉽게 시그널을 관리할 수 있을 것이다. 리눅스는 이들을 객체로 다루기 위해서 sigaction() 함수를 제공한다. 이 함수는 struct sigaction을 이용해서 시그널 객체요소를 다룬다.

#include <signal.h> 
int sigaction(int signum,  const  struct  sigaction  *act, 
    struct sigaction *oldact); 
 

1. signum : 제어할 시그널의 번호
   
2. act : 시그널을 제어하기위한 정책을 정의할 수 있다. 이 구조체는 다음과 같이 정의되어 있다.
   
   
   

   struct sigaction  
   { 
       void (*sa_handler) (int); 
       void (*sa_sigaction) (int, siginfo_t *, void *); 
       sigset_t sa_mask; 
       int sa_flags; 
       void (*sa_restorer) (void); 
   } 
    

구조체의 각 멤버에 대한 자세한 내용은 sigaction(2) 문서를 확인해 보기 바란다. 여기에서는 간단하게 소개만 하고 넘어가겠다.

1. sa_handler : sigaction의 signum에 해당되는 시그널이 전달되었을 때 실행될 시그널 핸들러
   
2. sa_mask : sa_handler에 등록된 시그널 핸들러가 실행되는 동안 블럭되어야 하는 시그널마스크
   
   

sigaction은 시그널을 객체단위로 제어할 수 있음을 알게 되었다. 이때 중요한 시그널 정책이, 시그널 핸들러가 수행되는 도중에 발생하는 시그널들을 set로 묶어서 관리하는 것이다. 이렇게 시그널을 set 으로 관리하기 위해서 다음의 함수들을 제공한다.

int sigprocmask(int  how,  const  sigset_t *set, sigset_t *oldset); 
int sigpending(sigset_t *set); 
int sigismember(sigset_t *set, int signum); 
int sigsuspend(const sigset_t *mask); 
int sigfillset(sigset_t *set); 
int sigaddset(sigset_t *set, int signum); 
int sigemptyset(sigset_t *set); 
int sigdelset(sigset_t *set, int signo); 
 

1. sigprocmask : 이것은 현재 set으로 등록된 시그널의 블럭 정책을 변경하기 위해서 사용한다. 블럭정책에는 다음의 3가지가 있다. 블럭set에 추가되어 있다면, 시그널은 바로 전달되지 않고 handler가 끝날때까지 블럭된다.
   
   1. SIG_BLOCK : set에 설정된 시그널셋을 기존 블럭set에 추가한다.
      
   2. SIG_UNBLOCK : set에 설정된 시그널 셋을 기존 블럭set에서 뺀다.
      
   3. SIG_SETMASK : set의 시그널셋을 블럭set 정책으로 한다.
      
2. sigpending : 시그널이 블록된 상태에서 어떤 시그널이 발생해서 블록되었는지를 알 수 있다.
   
3. sigismember : signum이 시그널 set에 포함되어 있는지 확인한다. sigpending와 함께 사용하면, 어떤 시그널에 대해서 블록되었는지를 알고 이에 대한 처리를 할 수 있다.
   
   
   

   #include <stdio.h> 
   #include <unistd.h> 
   #include <signal.h> 
    
   int main(int argc, char **argv) 
   { 
     sigset_t sigset; 
     sigset_t pendingset; 
     int i = 0; 
    
     // 모든 시그널에 대해서 BLOCK 한다. 
     sigfillset(&sigset); 
     sigprocmask(SIG_BLOCK, &sigset, NULL); 
    
     printf("My PID  %d\n", getpid()); 
     while(1) 
     { 
       printf("%d\n", i); 
       i++; 
       sleep(1); 
       // BLOCK된 시그널이 있다면 
       if (sigpending(&pendingset) == 0) 
       { 
         // 그리고 BLOCK된 시그널이 SIGUSR1 이라면 
         // 루프를 빠져나간다. 
         if (sigismember(&pendingset, SIGUSR1)) 
         { 
           printf("BLOCKED Signal : SIGUSR1\n"); 
           break; 
         } 
       } 
     } 
     return 0; 
   } 
    

4. sigfillset : 모든 시그널셋의 bit flag를 on으로 한다. 예를들어 모든 시그널에 대해서 SIG_BLOCK를 적용하길 원한다면, 아래와 같이 하면 된다.
   
   
   

   sigset_t sigset, oldset; 
   sigfillset(&sigset); 
   sigprocmask(SIG_BLOCK, &sigset, &oldset); 
    

5. sigaddset : signum 번호를 가지는 시그널을 set에 추가한다.
   
6. sigemptyset : set을 모두 비운다.
   
7. sigdelset : signum 번호를 가지는 시그널을 set에서 지운다.
   
   

그럼 간단한 프로그램을 하나 만들어보도록 하겠다.

001  #include <signal.h> 
002  #include <unistd.h> 
003  #include <string.h> 
004  #include <stdio.h> 
005  
006  void sig_int(int signo);
007  void sig_usr(int signo);
008  
009  int main()
010  {
011      int i = 0;
012      struct sigaction intsig, usrsig;
013  
014      printf("PID : %d\n", getpid());
015      // SIGUSR2 시그널의 처리 ----------
016      usrsig.sa_handler = sig_usr;  // 시그널 핸들러 등록
017      sigemptyset(&usrsig.sa_mask); // 시그널 마스크 초기화
018      usrsig.sa_flags = 0;
019      if (sigaction(SIGUSR2, &usrsig, 0) == -1)
020      {
021          printf ("signal(SIGUSR2) error");
022          return -1;
023      }    
024      // ---------------------------------
025  
026      // SIGINT (CTRL+C) 시그널의 처리 ---
027      intsig.sa_handler = sig_int;
028      sigemptyset(&intsig.sa_mask);
029      intsig.sa_flags = 0;
030      if (sigaction(SIGINT, &intsig, 0) == -1)
031      {
032          printf ("signal(SIGINT) error");
033          return -1;
034      }    
035      // ---------------------------------
036  
037      while(1)
038      {
039          printf("%d\n", i);
040          i++;
041          sleep(1);
042      }
043  }
044  
045  void sig_int(int signo)
046  {
047      sigset_t sigset, oldset;
048      sigemptyset(&oldset);
049  
050      // SIGUSR2와 SIGUSR1은 블럭된다.
051      // 이들 시그널은 핸들러가 종료되면 전달된다.
052      sigemptyset(&sigset);
053      sigaddset(&sigset, SIGUSR2);
054      sigaddset(&sigset, SIGUSR1);
055      if (sigprocmask(SIG_BLOCK, &sigset, &oldset) < 0)
056      {
057          printf("sigprocmask %d error \n", signo);
058      }
059  
060      // SIGINT 를 UNBLOCK 한다.
061      // 핸들러가 수행중이더라도 즉시 전달된다.
062      sigemptyset(&sigset);
063      sigaddset(&sigset, SIGINT);
064      if (sigprocmask(SIG_UNBLOCK, &sigset, &oldset) < 0)
065      {
066          printf("sigprocmask %d error \n", signo);
067      }
068  
069      printf("sig_int\n");
070      sleep(5);
071  }
072  
073  void sig_usr(int signo)
074  {
075      printf("sig_usr2\n");
076  }
077  

• 50~58 : SIGUSR1과 SIGUSR2 시그널을 블럭시켰다. 핸들러가 수행되는 5초동안 이들 시그널이 도착하면, 시그널은 BLOCK이 된다. 그러다가 시그널핸들러가 종료하면, 전달이 된다.
  
• 60 ~68 : SIGINT를 UNBLOCK로 했다. 시그널핸들러가 수행되는 동안 동일한 시그널이 발생하게 되면, 시그널은 BLOCK이 된다. SIGINT에 대해서 UNBLOCK를 했으므로 SIGINT가 도착하게 되면, 곧바로 시그널이 전달되고 sig_int 시그널핸들러가 수행이 된다. 이 코드를 주석처리 한다음에 SIGINT를 여러번 발생시켜보기 바란다.