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

#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); 
   } 
    

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

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에서 지운다.
   
   

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77

#include <signal.h>  
#include <unistd.h>  
#include <string.h>  
#include <stdio.h>  
 
void sig_int(int signo); 
void sig_usr(int signo); 
 
int main() 
{ 
    int i = 0; 
    struct sigaction intsig, usrsig; 
 
    printf("PID : %d\n", getpid()); 
    // SIGUSR2 시그널의 처리 ---------- 
    usrsig.sa_handler = sig_usr;  // 시그널 핸들러 등록 
    sigemptyset(&usrsig.sa_mask); // 시그널 마스크 초기화 
    usrsig.sa_flags = 0; 
    if (sigaction(SIGUSR2, &usrsig, 0) == -1) 
    { 
        printf ("signal(SIGUSR2) error"); 
        return -1; 
    }     
    // --------------------------------- 
 
    // SIGINT (CTRL+C) 시그널의 처리 --- 
    intsig.sa_handler = sig_int; 
    sigemptyset(&intsig.sa_mask); 
    intsig.sa_flags = 0; 
    if (sigaction(SIGINT, &intsig, 0) == -1) 
    { 
        printf ("signal(SIGINT) error"); 
        return -1; 
    }     
    // --------------------------------- 
 
    while(1) 
    { 
        printf("%d\n", i); 
        i++; 
        sleep(1); 
    } 
} 
 
void sig_int(int signo) 
{ 
    sigset_t sigset, oldset; 
    sigemptyset(&oldset); 
 
    // SIGUSR2와 SIGUSR1은 블럭된다. 
    // 이들 시그널은 핸들러가 종료되면 전달된다. 
    sigemptyset(&sigset); 
    sigaddset(&sigset, SIGUSR2); 
    sigaddset(&sigset, SIGUSR1); 
    if (sigprocmask(SIG_BLOCK, &sigset, &oldset) < 0) 
    { 
        printf("sigprocmask %d error \n", signo); 
    } 
 
    // SIGINT 를 UNBLOCK 한다. 
    // 핸들러가 수행중이더라도 즉시 전달된다. 
    sigemptyset(&sigset); 
    sigaddset(&sigset, SIGINT); 
    if (sigprocmask(SIG_UNBLOCK, &sigset, &oldset) < 0) 
    { 
        printf("sigprocmask %d error \n", signo); 
    } 
 
    printf("sig_int\n"); 
    sleep(5); 
} 
 
void sig_usr(int signo) 
{ 
    printf("sig_usr2\n"); 
} 
 

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

10 마치며

이상 간단하게 시그널에 대해서 알아보았다. 시그널의 활용과 관련된 내용은 thread를 설명하는 장을 비롯한 다른 몇몇 장에서, 다루게 될 것이다.

이글은 joinc 블로그로 발행되었습니다. 댓글은 블로그에서 입력할 수 있습니다.