[시스템 프로그래밍] 프로세스 [3] - 시그널

 

 

 

 

 

🧐 시그널

이벤트가 시스템에 발생했다는 것을 프로세스에게 알려주는 짧은 메세지

시그널은 상위수준의 소프트웨어 형태의 예외적인 제어흐름으로써, 시그널은 프로세스와 커널이 다른 프로세스를 중단하도록 합니다.

 

시그널은 예외상황과 인터럽트를 커널에서 추상화한 개념으로써, 대부분의 경우 커널이 프로세스에게로 시그널을 보내주는 형태를 가집니다.

 

시그널에는 30개의 종류가 있으며, 각 시그널은 정수 아이디로 구분합니다.(1 - 30)

 

시그널에 포함된 정보는 시그널의 아이디와 시그널이 도착했다는 사실입니다.

 

다음은 주로 사용되는 몇몇 시그널들입니다.

 

 

 

 

 

 

 

 

시그널을 목적지 프로세스로 전달하는 것은 시그널 송신과 시그널 수신의 두 단계로 이루어집니다.

 

 

 

 

 

 

 

 

 

🧐 시그널 송신

커널은 목적지 프로세스의 컨텍스트 내에 있는 일부 상태를 갱신해서 시그널을 목적지 프로세스로 보냅니다.

 

커널은 다음과 같은 경우 시그널을 보냅니다.

• 커널이 divide by zero(SIGFPE)나 자식 프로세스의 종료(SIGCHLD)와 같은 시스템 이벤트를 감지했을 때
• 다른 프로세스가 kill 시스템 콜을 호출해서 커널이 목적지 프로세스로 시그널을 보낼 것을 요청했을 때

 

 

 

 

 

 

 

 

🧐 시그널 수신

목적지 프로세스는 전달된 신호에 대해서 커널이 어떤 방식으로든 반응하여야 할 때 시그널을 수신한다고 합니다.

 

다음은 시그널을 받았을 때 취할 수 있는 세가지 반응입니다.

• 무시(Ignore) : 아무것도 하지 않습니다.
• 대상 프로세스를 종료 (with optinal core dump)
• 시그널 핸들러(사용자 수준의 함수)를 호출하여 시그널을 처리합니다.
  • 이는 비동기형 인터럽트에 대한 응답으로 호출되는 인터럽트 핸들러 방식과 유사합니다. (즉 시그널 핸들러를 실행시킨 후 기존 프로세스에서 실행한 명령어의 바로 다음 명령어로 반환합니다.)

 

 

 

 

 

 

 

 

 

 

🧐 Pending

송신(전송)하였지만 아직 수신되지 않은 시그널을 펜딩(Pending) 시그널이라 부릅니다.
(pending은 대기중이라는 뜻입니다.)

어느 특정한 시그널에 대해서는 최대 한 개의 시그널만이 존재할 수 있습니다.

 

즉 시그널은 큐 같은 곳에 들어가 대기하는 것이 아니므로, 만일 어떤 프로세스가 특정 타입의 pending 시그널을 가지고 있다면, 다음에 해당 프로세스로 전달되는 k 타입의 시그널들은 무시됩니다.

 

 

 

프로세스는 특정 시그널의 수신을 블록(block)할 수 있습니다.

block된 시그널들은 전달될 수 있지만, 해당 시그널의 block이 풀릴 때까지는 수신될 수 없습니다.

 

이때 SIGKILL(9), SIGSTOP(19)은 프로세스에서 block될 수 없는 시그널입니다.

 

 

pending 시그널은 최대 한번만 수신할 수 있습니다.

 

각 프로세스에 대하여 커널은 pending 비트 벡터내에 대기하고 있는(pending) 시그널의 집합을 관리하며,

blocked 비트 벡터 내에서 block된 시그널의 집합을 관리합지다.

 

 

 

 

 

 

 

 

 

 

 

🧐  시그널의 구현

커널은 각 프로세스의 컨텍스트에 pending과 blocked 비트 벡터를 가지고 있습니다.

 

pending은 대기 시그널들을 표시합니다.

커널은 id = k인 시그널이 도착할 때마다, pending 값의 k번째 비트가 1로 설정됩니다.

커널은 id = k인 시그널을 수신할 때마다, pending 값의 k번째 비트를 0으로 설정합니다.

 

 

blocked는 블록된 시그널들을 표시합니다.

sigprocmask 함수를 사용하여 응용 프로그램이 1 또는 0으로 설정합니다.

 

 

 

 

 

 

 

 

 

 

 

🧐  프로세스 그룹

Unix 시스템은 시그널을 프로세스로 보내는 여러 가지 메커니즘을 제공합니다.

이때 모든 메커니즘은 프로세스 그룹 개념을 사용합니다.

 

모든 프로세스는 정확히 한 개의 프로세스 그룹에 속하며, 이것은 양수 process group ID(pgid)로 식별합니다.

 

기본적으로 자식은 부모와 같은 프로세스 그룹에 속하며, 쉘은 각각의 job(쉘이 제공하는 프로세스에 대한 추상화)마다 별도의 프로세스 그룹을 만듭니다.

 

 

 

#include <unistd.h>

pid_t getpgrp(void);

getpgrp() 함수는 현재 프로세스의 프로세스 그룹 ID를 리턴합니다.

 

 

 

#include <unistd.h>

int setpgid(pid_t pid, pid_t pgid);

setpgid() 함수를 통해 프로세스 pid의 프로세스 그룹을 pgid로 변경할 수 있습니다.

이때 만약 pid로 넘어가는 값이 0인 경우 현재 프로세스의 PID가 사용됩니다.

만약 pgid가 0이라면 pid로 명시된 프로세스의 PID가 프로세스 그룹 ID로 사용됩니다.

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

🧐 kill 명령을 이용한 시그널 보내기

/bin/kill 프로그램은 다른 프로세스 혹은 프로세스 그룹으로 임의의 시그널을 보냅니다.

예를 들어 다음의 명령은 시그널 9번(SIGKILL)을 프로세스 15213에 보냅니다.

linux> /bin/kill -9 15213

 

PID 번호에 -를 붙이게 되면, 시그널이 프로세스 그룹 ID 내의 모든 프로세스로 보내지도록 합니다.

linux> /bin/kill -9 -15213

SIGKILL 시그널이 프로세스 그룹 15213 내의 모든 프로세스에게 보내지도록 하였습니다.

 

여기서 /bin/kill 과 같이 완전한 경로를 사용하고 있는 점에 주목해야 하는데, 이것은 일부 Unix 쉘이 자신만의 내장 kill 명령어를 가지고 있기 때문입니다.

kill 명령어를 사용헸기 때문에 프로세스가 종료되는 것이 아닌,
kill로 인해 보내지는 임의의 시그널의 종류가 9(SIGKILL)이었기 때문에 프로세스가 종료된 것입니다.

 

 

 

 

 

 

 

 

 

👉 키보드로 시그널 보내기

키보드로 ctrl + c (ctrl + z)를 누르면, SIGINT(SIGTSTP) 시그널이 포그라운드 프로세스 그룹의 모든 작업으로 전송됩니다.

SIGINT : 기본동작은 각 프로세스를 종료시킵니다.
SIGTSTP : 기본동작은 각 프로세스를 정지시킵니다.

SIGSTOP과 SIGTSTP는 다릅니다.

 

 

 

 

 

👉 ctrl + c, ctrl + z 예제

ctrl + z에 의하여 포그라운드에서 실행중인 실행중인 모든 프로세스가 중지(STAT : T)된 이후,

ctrl + c에 의하여 종료되었음을 알 수 있습니다.

 

 

STAT은 다음과 같은 상태들이 있습니다.

S : sleeping
T : stopped
R : running

 

 

예시는 다음과 같습니다.

void fork()
{

    pid_t pid[N];
    int i;
    int child_status;
    
    /* child process를 N개 생성합니다. */
    for (i = 0; i < N; i++) {
    	if ((pid[i] = fork()) == 0) {  // 자식 프로세스인 경우
        	while(1);  // 무한 루프 실행 (종료되지 않음)
        }
    }
    
   
   /* 생성된 프로세스들 모두에게 kill SIGINT(2)를 보냅니다. */
   for (i = 0; i < N; i++) {
    	printf("Killing proecess %d\n", pid[i]);
        kill(pid[i], SIGINT);
    }
    
    
    for (i = 0; i < N; i++) {
    	pid_t wpid = wait(&child_status);
        
        /* WIFEXITED 는 exit 호출 또는 return을 통해서 
         * 자식이 정상적으로 종료되었는지 체크합니다.(정상 종료 : true)*/
        if (WIFEXITED(child_status)) {
        	printf(
            "Child %d terminated with exit status %d\n", 
            wpid,
            /* WEXITSTATUS 는 정상적으로 종료된 자식의 exit staus를 리턴합니다.*/
            WEXITSTATUS(child_status));  
        }
        else {
        	printf("Child %d terminated abnormally\n", wpid);
        }
    }

}

정상 종료가 아닌 시그널을 통한 종료이므로 다음과 같이 출력됩니다.

 

 

 

 

 

 

🧐 kill 함수로 시그널 보내기

#include <sys/types.h>
#include <signal.h>

int kill(pid_t pid, int sig);

만일 pid가 0보다 크면, kill 함수는 시그널 번호 sig를 프로세스 pid로 보냅니다.

만일 pid가 0이면 kill은 호출하는 프로세스인 자신을 포함해서 프로세스 그룹 내 모든 프로세스에 시그널 sig를 보냅니다.

만일 pid가 0보다 작으면 kill은 프로세스 그룹 |pid|(절대값) 내의 모든 프로세스로 보냅니다.

 

 

 

 

 

 

 

 

 

 

 

 

 

🧐 시그널 받기

커널이 프로세스 p를 커널 모드에서 사용자 모드로 돌아오는 경우(즉 예외처리 핸들러에서 돌아오는 경우, 혹은 문맥 전환을 끝마치는 경우 등)를 생각해 보도록 하겠습니다.

1. 커널은 프로세스 p에 대하여 블록되지 않은 펜딩 시그널(pending & ~blocked)의 집합을 체크합니다.

2. 만약 하나라도 존재하는 경우, pending&~blocked 의 결과(블록되지 않은 펜딩 시그널들)에서 0이 아닌 비트에 대하여, 해당 비트가 k번째 비트인 경우 프로세스 p가 시그널 k를 수신하도록 합니다.

프로세스 p는 시그널을 수신하면 시그널 처리 작업을 수행합니다.

3. 블록되지 않은 펜딩 시그널들이 존재하지 않을 때까지 위 과정을 반복합니다.

4. 만일 해당 집합이 비어 있다면(모두 0) 커널은 제어를 p의 $I_{next}$로 전달합니다.

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

🧐 시그널 타입의 기본(Default) 동작

각 시그널 타입은 사전에 정의된 기본 동작을 가지고 있으며, 종류는 다음과 같습니다.

프로세스를 종료합니다.

프로세스는 종료하고 코어를 덤프합니다.

프로세스는 SIGCONT 시그널에 의해 재시작될 때까지 정지합니다.

프로세스는 시그널을 무시합니다.

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

🧐 시그널의 기본 동작 변경 - signal()

위에서 살펴본 기본 동작은 signal() 함수에 의해 변경이 가능한데, 함수는 다음과 같습니다.

#include <signal.h>
typedef void (* sighandler_t)(int);

sighandler_t signal(int signum, sighandler_t handler);

그러나 SIGSTOP과 SIGKILL은 기본 동작을 변경할 수 없습니다.

 

 

인자로 넘어가는 handler에 따라 기본 동작을 다음 세 가지 방법 중의 하나로 바꿀 수 있습니다.

SIG_IGN : signum 타입의 시그널을 무시합니다.

SIG_DFL : 시그널 타입 signum의 기본 동작으로 복귀합니다.

이 외의 경우 handler로 넘어가는 값은 시그널 핸들러의 주소가 되어 signum 시그널을 수신할 때마다 실행됩니다.
핸들러의 주소를 signal 함수로 넘겨주는 방법은 기본 동작을 변경하는 것이므로 핸들러를 설치한다라고 말합니다.

핸들러의 호출은 시그널을 붙잡는다(catching)고 부르며,
핸들러의 실행은 시그널을 처리한다(handling)고 합니다.

 

 

 

 

 

 

👉 시그널 핸들러 예제

void int_handler(int sig)
{
    printf("Process %d received signal %d\n", getpid(), sig);
    exit(0);
}

void fork() 
{
    pid_t pid[N];
    
    int i;
    int child_status;
   
    /* SIGINT(2) 의 처리를 int_handler으로 변경 */   
    signal(SIGINT, int_handler);
}

이제는 exit(0)으로 종료되기 때문에 정상 종료입니다.

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

🧐 시그널 핸들러의 이상동작

int ccount = 0;

void child_handler(int sig) 
{
    int child_status;
    pid_t pid = wait(&child_status);
	
    ccount--;
	
    printf("Received signal %d from process %d\n", sig, pid);
    
    sleep(2);
}

void fork14()
{
    pid_t pid[N];
    int i;
    int child_status;
    
    ccount = N;
    
    /* SIGCHLD : 자식이 정지 또는 종료시 발생 */
    signal(SIGCHLD, child_handler); 
    
    for (i = 0; i < N; i++) {
        if ((pid[i] = fork()) == 0) {
            sleep(1);
            /* Child: Exit */
            exit(0); 
        }
    }
     
    while (ccount > 0) {
        pause();/* Suspend until signal occurs */
    }
}

 

위 프로램은 종료되지 않습니다.

시그널은 큐를 사용하지 않기 때문에 무시되는 시그널이 생기므로 발생하는 문제점입니다.

 

이는 다음과 같이 해결할 수 있습니다.

void child_handler2(int sig) 
{
    int child_status;
    pid_t pid;
   
    while ((pid = waitpid(-1, &child_status, WNOHANG)) > 0) {
        ccount--;
        printf("Received signal %d from process %d\n", sig, pid);
    }
}

void fork() {
    ...
    signal(SIGCHLD, child_handler2); 
    ...
}

 

 

 

 

 

 

 

 

🧐 예시 - 외부에서 생성된 이벤트를 처리하는 프로그램(ctrl + c)

#include <stdlib.h> 
#include <stdio.h> 
#include <signal.h>

void handler(int sig) 
{
    printf("You think hitting ctrl-c will stop the bomb?\n"); sleep(2);
    printf("Well...");
    fflush(stdout);
    sleep(1);
    printf("OK\n");
    exit(0);
}

main() 
{    
    /* installs ctl-c handler */
    signal(SIGINT, handler); 
    
    while(1) { }
}

 

 

 

 

 

 

 

 

🧐 예시 - 내부에서 발생된 이벤트를 처리하는 프로그램

#include <stdio.h>
#include <signal.h>

int beeps = 0;

/* SIGALRM handler */ 
void handler(int sig) 
{
    printf("BEEP\n");
    fflush(stdout);

    if (++beeps < 5) {
        alarm(1);
    }
    else {
        printf("BOOM!\n");
        exit(0);
    }
}



main() 
{
    signal(SIGALRM, handler); 
    /* send SIGALRM in 1 second */
    alarm(1); 
    
    while (1) {
    /* handler returns here */
    } 
}

 

위 실행 결과는 BEEP가 5번 출력된 이후 BOOM이 터지면서 종료됩니다.

 

 

 

 

 

 

 

 

 

 

🧐 핸들러의 중단

핸들러는 다른 핸들러에 의해 중단될 수 있습니다.

아래는 Main Process에서 시그널 s에 의해 핸들러 S가 실행되고,

핸들러 S가 실행되는 중간에 시그널 t가 발생하여 핸들러 T가 발생하는 상황을 표현한 것입니다.

 

핸들러 실행 도중 다른 핸들러가 실행되더라도, 모든 작업을 마친 후에는 되돌아와서 나머지 작업을 수행합니다.

 

 

 

 

 

 

 

 

 

🧐 시그널 블록하기와 해제하기

리눅스는 일반적으로 시그널을 묵시적으로 블록합니다.

커널은 현재 처리중인 시그널과 동일한 대기(pendding)시그널을 블록합니다.

예를 들어 SIGINT 핸들러는 추가적인 SIGINT에 의해서 중단되지 않습니다.

 

 

 

 

그러나 명시적으로 시그널을 블록하는 방법도 제공하기 위해 sigprocmask 함수와, 해당 함수의 지원함수들을 제공합니다.

#include <signal.h>

int sigprocmask(int how, const sigset_t * set, sigset_t * oldset);

/* 모든 시그널이 비어 있는 집합을 생성합니다. */
int sigemptyset(sigset_t * set);

/* 모든 시그널 번호를 1로 설정합니다. */
int sigfillset(sigset_t * set);

/* 특정 시그널 번호를 1로 설정합니다. */
int sigaddset(sigset_t * set, int signum);

/* 특정 시그널 번호를 0으로 설정합니다. */
int sigdelset(sigset_t * set, int signum);

 

sigprocmask 함수는 how 값에 따라 동작이 결정되는데, 다음과 같습니다.

SIG_BLOCK(0) : set에 있는 시그널들을 blocked에 추가합니다.
blocked = (blocked | set)

SIG_UNBLOCK(1) :set에 있는 시그널들을 blocked에서 제거합니다.
blocked = (blocked & ~set) 

SIG_SETMASK(2) : blocked = set

 

sigprocmask에서 oldset이 NULL이 아닌 경우 이전에 사용되던 blocked 비트 백터의 값이 저장됩니다.

 

 

 

 

 

👉 참고 : 시그널 블락과 execve

 

https://man7.org/linux/man-pages/man2/sigprocmask.2.html

 

위 사진을 통해 알 수 있듯이 시그널의 블락 상태는 execve를 수행하더라도 보존됩니다.

 

그러나 시그널 핸들러는 보존되지 않고 초기화됩니다.

 

 

 

 

 

 

 

 

 

 

 

🧐 동시성 문제의 발생

다음 예시 코드를 보며 문제점을 확인해 보도록 하겠습니다.

void handler(int sig)
{
    int olderrno = errno;
    sigset_t mask_all; // 모든 시그널 1로 만들 mask
    sigset_t prev_all; // 이전 시그널 정보를 가진 mask
    
    pid_t pid;
    
    Sigfillset(&mask_all);

    // 좀비 제거한 경우
    while( (pid = waitpid(-1, NULL, 0)) > 0 ) { 
    	Sigprocmask(SIG_BLOCK, &mask_all, &prev_all); // 모든 시그널 Block
        deletejob(pid); // pid를 job list에서 제거
        Sigprocmask(SIG_SETMASK, &prev_all, NULL); //Block 시그널 복구
    }
    
    if (errno != ECHILD) {
    	Sio_error("waitpid error");
    }
    errno = olderrno;
}


int main()
{
    int pid;
    sigset_t mask_all; // 모든 시그널 1로 만들 mask
    sigset_t prev_all; // 이전 시그널 정보를 가진 mask
    
    Sigfillset(&mask_all); // 1로 채우기
    
    Signal(SIGCHLD, handler); // 핸들러 설치
    
    initjobs();
    
    while(1) {
    	if ((pid = Fork()) == 0 ) {
        	Execve("/bin/date", argv, NULL);
        }
        Sigprocmask(SIG_BLOCK, &mask_all, &prev_all);
        addjob(pid);
        Sigprocmask(SIG_SETMASK, &prev_all, NULL);
    }
    exit(0);
}

 

이는 부모에서 addjob을 하기 전에 Child가 먼저 종료되어 SIGCHLD 신호가 발생하면 문제가 발생합니다.

이 경우 Handler에서는 deletejob을 해주게 되는데, 부모에서 addjob을 하기 전이라 아무 일도 발생하지 않으며,

이후 Handler가 종료된 후 부모에서 addjob을 실행하여 존재하지 않는 자식을 작업 리스트해 추가할 가능성이 있습니다.

 

 

 

 

이를 해결하기 위해 다음과 같이 코드를 변경할 수 있습니다.

void handler(int sig)
{
    int olderrno = errno;
    sigset_t mask_all; // 모든 시그널 1로 만들 mask
    sigset_t prev_all; // 이전 시그널 정보를 가진 mask
    
    pid_t pid;
    
    Sigfillset(&mask_all);

    // 좀비 제거한 경우
    while( (pid = waitpid(-1, NULL, 0)) > 0 ) { 
    	Sigprocmask(SIG_BLOCK, &mask_all, &prev_all); // 모든 시그널 Block
        deletejob(pid); // pid를 job list에서 제거
        Sigprocmask(SIG_SETMASK, &prev_all, NULL); //Block 시그널 복구
    }
    
    if (errno != ECHILD) {
    	Sio_error("waitpid error");
    }
    errno = olderrno;
}


int main()
{
    int pid;
    sigset_t mask_all; // 모든 시그널 1로 만들 mask
    sigset_t mask_one; // 모든 시그널 1로 만들 mask
    sigset_t prev_one; // 이전 시그널 정보를 가진 mask
    
    Sigfillset(&mask_all); // 1로 채우기
    Sigemptyset(&mask_one); // 모두 0
	Sigaddset(&mask_one, SIGCHLD); // SIGCHLD만 1
    
    Signal(SIGCHLD, handler); // 핸들러 설치
    
    initjobs();
    
    while(1) {
    	// 기존 SIGNAL에 추가로 SIGCHLD만 Block
    	Sigprocmask(SIG_BLOCK, &mask_one, &prev_one);
        
    	if ((pid = Fork()) == 0 ) {
            // SIGCHLD Block 해제
	        Sigprocmask(SIG_SETMASK, &prev_one, NULL);
        	Execve("/bin/date", argv, NULL);
        }
        // 모든 SIGNAL Block
        Sigprocmask(SIG_BLOCK, &mask_all, &prev_all);
        addjob(pid);
        Sigprocmask(SIG_SETMASK, &prev_all, NULL);
    }
    exit(0);
}

 

 

 

 

 

 

 

 

 

🧐 명시적으로 시그널 대기하기

종종 메인 프로그램은 특정 시그널 핸들러의 동작을 명시적으로 기다려야 할 필요가 있습니다.

예를 들어 쉘이 어떠한 foreground job을 생서할 때, 커널은 이 작업이 종료되고 SIGCHLD 핸들러에 의해 삭제될 때가지 기다려야 합니다.

 

아래는 이에 해당하는 예시 코드입니다.

volatile sig_atomic_t pid;

void sigchld_handler(int sig)
{
    int olderrno = errno;
    pid = waitpid(-1, NULL, 0);   //(2) pid 값 변경
    errno = olderrno;
}


void sigint_hanlder(int sig) {}

int main(int argc, char ** argv)
{
    sigset_t mask;
    sigset_t prev;
    
    Signal(SIGCHLD, sigchld_handler);
    Signal(SIGINT, sigint_handler);
    Sigemptyset(&mask);
    Sigaddset(&mask, SIGCHLD);
    
    while(1) {
    	// SIGCHLD Block
    	Sigprocmask(SIG_BLOCK, &mask, &prev);
        
        if (Fork() == 0) {
        	// 자식인 경우 바로 종료 -> SIGCHLD 발생
        	exit(0);
        }
        
        // Parent 인 경우
        pid = 0;             //(1) : pid = 0 으로 설정
        
        // Unblock SIGCHLD
        Sigprocmask(SIG_SETMASK, &prev, NULL);
        
        // SIGCHLD 기다리기
        while(!pid) {} // spin roop
        
        printf(".");        
    }
    printf("\n");
    exit(0);
}

이는 정상적으로 작동하지만 spin roop는 자원을 낭비합니다.

 

이를 해결하기 위해 스핀 루프 속에 pause()를 끼워 넣는 방법을 취할 수 있습니다.

 

그러나 이는 아래의 경우 문제가 발생합니다.

'SIGCHLD Unblock -> while 조건문 확인 이후 몸체 진입 -> SIGCHLD 시그널 핸들러 수행 -> pause() -> 이후 시그널이 없어서 무한 대기' 

 

이를 pause 대신 sleep(1)을 사용하면 문제가 해결되지만, 이는 성능이 너무 느려집니다.

 

 

이와 같은 문제점의 적절한 해결책은 sigsuspend를 사용하는 것입니다.

 

 

 

 

🧐 sigsuspend

#include <signal.h>

int sigsuspend(const sigset_t *mask);

sigsuspend 함수는 현재 blocked 시그널 집합을 일시적으로 mask로 교체한 뒤,

시그널을 수신할 때까지 정지시킵니다.

 

이때 시그널의 동작이 종료하는 것이라면, 해당 프로세서는 sigsuspend로부터 리턴하지 않고 종료합니다.

만약 그렇지 않다면 sigsuspend는 해당 시그널의 핸들러에서 리턴된 후 blocked 시그널 집합을 이전의 집합으로 복구합니다.

 

즉 이는 아래 코드를 원자적으로 실행시킵니다.

sigprocmask(SIG_SETMASK, &mask, &prev); // mask에 해당하는 집합으로 blocked 교체

pause(); // 시그널 수신할 때까지 대기

sigprocmask(SIG_SETMASK, &prev, NULL); // blocked 복구

 

 

이를 사용한 코드는 다음과 같습니다.

 

volatile sig_atomic_t pid;

void sigchld_handler(int sig)
{
    int olderrno = errno;
    pid = waitpid(-1, NULL, 0);   //(2) pid 값 변경
    errno = olderrno;
}


void sigint_hanlder(int sig) {}

int main(int argc, char ** argv)
{
    sigset_t mask;
    sigset_t prev;
    
    Signal(SIGCHLD, sigchld_handler);
    Signal(SIGINT, sigint_handler);
    Sigemptyset(&mask);
    Sigaddset(&mask, SIGCHLD);
    
    while(1) {
    	// SIGCHLD Block
    	Sigprocmask(SIG_BLOCK, &mask, &prev);
        
        if (Fork() == 0) {
        	// 자식인 경우 바로 종료 -> SIGCHLD 발생
        	exit(0);
        }
        
        // Parent 인 경우
        pid = 0;             //(1) : pid = 0 으로 설정
        
        // Unblock SIGCHLD -> sigsuspend 사용 시 필요 없어짐
        // Sigprocmask(SIG_SETMASK, &prev, NULL);
        
        // SIGCHLD 기다리기
        while(!pid) {
        	// sigsuspend 사용
			// 먼저 SIGCHLD를 unblock하고, pause후에 
			// 다시 SIGCHLD를 block한다
        	sigsuspend(&prev);
        }
        
        
        // Optinally unblock SIGCHLD
        // Sigprocmask(SIG_SETMASK, &prev, NULL);
        
        printf(".");        
    }
    printf("\n");
    exit(0);
}