[시스템 프로그래밍] 프로세스(시그널, 이상동작, Race 현상)

 

* 프로세스를 공부하며 헷갈리는 부분을 정리하며 공부한 것입니다. 잘못된 부분은 댓글로 알려주세요

 

 

 

 

프로세스와 프로그램, fork와 execve

 

🔲 프로그램은 코드와 데이터가 합쳐진 것. 디스크 상의 목적파일이나 주소공간에 세그먼트로 존재 가능

 

🔲 프로세스는 실행중인 프로그램의 특정 사례이다.

 

 

+ 프로세서는 CPU이다.

 

 

🔎 fork
부모의 복제를 새로운 자식 프로세스에서 동일한 프로그램을 실행한다.
다른 컨텍스트 - 같은 프로그램
signal mask 상속, signal handler 상속

🔎 execve
새로운 프로그램을 현재 프로세스 컨텍스트 내에서 실행
같은 컨텍스트 - 다른 프로그램
signal mask 동일, signal handler 초기화

 

 

 

 

 

 

 

 

 

 

sleep과 pause의 차이

 

🔶unsigned int sleep(unsigned int secs)

 

🔲 자기 자신을 secs초 동안 정지(suspend) 시킨다.

 

🔲 정상적으로 깨면 0을 리턴하고, 그 외는 잔여 시간을 리턴한다.

 

 

🔶int pause(void)

 

🔲호출하는 프로세스를 시그널을 받을 때까지 잠재운다.

 

 

 

 

 

 

 

 

 

 

wait과 waitpid의 차이

 

🔶 int wait(int *child_status)

 

🔲 현재 프로세스를 자식 프로세스 중 하나가 종료될 때까지 정지한다.

 

🔲 자식 프로세스가 좀비가 되는 것을 막기 위해 부모 프로세스에서 실행한다.

 

🔲 리턴 값은 종료한 자식 프로세스의 PID이다.

 

🔲 child_status가 NULL이 아니면, 자식 프로세스의 종료 이유를 담는다.

 

 

 

 

🔶 waitpid(pid, &status, options)

 

 

🔲 pid는 -1이면 대기 집합은 모든 자식이다.

 

🔲 pid가 > 0 이면 대기 집합은 해당 pid이다.

 

🔲 options가 0이면, 대기 집합의 자식이 종료될 때까지 기다린다.

 

🔲 options가 1이면 자식이 종료되었는지 한번만 확인한다. 1 대신 WNOHANG을 쓰기도 한다.

 

🔲 options가 2이면, 정지되었거나 종료된 자식을 기다린다. 2 대신 WUNTRACED를 사용하기도 한다.

 

 

 

 

 

 

 

시그널 수신 시의 3가지 반응

 

 

 

 

1️⃣ 무시한다 .Ignore the signal

 

2️⃣ 대상 프로세스를 종료한다. (with optional core dump)

 

3️⃣ 시그널 핸들러라고 부르는 유저레벨 함수를 실행하여 시그널을 잡는다.(catch)

(비동기형 인터럽트에 대한 응답으로 호출되는 인터럽트 핸들러 방식과 유사하다.)

 

 

 

 

 

 

 

시그널의 중요한 특징

 

 

🔲 특정 타입의 시그널에 대해서는 최대 한 개의 대기 시그널이 존재한다.

 

🔲 시그널은 큐에 들어가지 않는다.

 

🔲 즉, 이미 k 타입의 대기 시그널을 가지고 있다면, 이후로 들어오는 k 타입의 시그널은 무시된다.

 

🔲 프로세스는 특정 시그널의 수신을 블록할 수 있다. 이후, 블록된 시그널을 전달될 수 있으나 풀리기 전까지는 수신할 수 없다.

 

🔲 블록할 수 없는 유일한 시그널을 SIGKILL이다.

 

🔲 대기 시그널을 나타내기 위해 비트 벡터를 사용한다.

 

🔲 pendding은 대기 시그널, blocked는 블록된 시그널을 의미한다.

 

 

 

 

 

 

/bin/kill의 특징

 

 

🔲 프로세스 또는 임의의 프로세스 그룹에 시그널을 보낸다. SIGKILL을 하는 것이 아니다.

 

🔲 kill -9 24818 : -9가 SIGKILL을 나타내는 시그널 번호이므로, PID가 24818 인 프로세스에 해당 시그널을 전달한다.

 

 

 

 

 

 

 

 

 

 

 

시그널 타입의 기본 동작과 핸들러 설치

 

 

시그널 타입의 기본 동작은 아래와 같다.

 

 

 

🔲  프로세스를 종료한다.

 

🔲 프로세스가 종료되고, core파일을 덤프한다.(디버깅을 위한 파일)

 

🔲 프로세스가 SIGCONT 시그널에 의해 재개될때까지 정지한다.

 

🔲 프로세스는 이 시그널을 무시한다.

 

 

 

이러한 기본동작은 signal() 함수에 의해서 변경이 가능하다. 단, SIGSTOP과 SIGKILL은 예외이다.

 

 

 

🔶 handler_t *signal(int signum, hanlder_t *handler)

 

 

handler에 들어갈 수 있는 값은 아래와 같다.

 

1️⃣ SIG_IGN : signum 타입의 시그널을 무시한다.

 

2️⃣ SIG_DFL : 시그널 타입 signum의 기본 동작으로 복귀

 

3️⃣ 그 외의 경우, handler는 signal_handler의 주소가 된다.

만약 핸들러가 리턴문을 만난다면, 제어권은 시그널에 의해 종료되었던 프로세스의 다음 명령으로 넘어간다.

 

 

 

 

 

 

 

시그널 핸들러의 이상 동작

 

 

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;
    
    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 */
    }
}

 

 

 

위 함수가 이상 동작하는 것는 대기 시그널들은 큐에 들어가지 않기 때문이다.

 

 

 

각 시그널의 대기 여부를 표시하는데는 하나의 비트 벡터가 할당되어 있다고 하였다. 그렇기 때문에 여러 프로세스가 동시에 SIGSHLD를 보내더라도 SIGNAL이 완전히 수신되기 전까지 같은 타입의 시그널은 무시된다.

 

 

 

 

위 문제를 해결하기 위한 전략으로 우리는 waitpid를 사용할 수 있다.

 

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

 

 

모든 자식 프로세스 집합에 대하여 WNOHANG이므로 자식이 종료된 것이 없을 때 즉시 리턴한다. 즉, 모든 자식이 종료될 때까지 기다릴 수 있다.

 

 

 

 

 

 

 

 

동시성 문제

 

void handler(int sig)
{
    int olderrno = errno;
    sigset_t mask_all;
    sigset_t prev_all;
    int n = N; // N = 5;
    
    pid_t pid;
    
    Sigfillset(&mask_all);

    
    while( (pid = waitpid(-1, NULL, 0)) > 0 ) { 
     	// 모든 시그널 Block하기
    	Sigprocmask(SIG_BLOCK, &mask_all, &prev_all);
        deletejob(pid);
         //Block 시그널 복구하기
        Sigprocmask(SIG_SETMASK, &prev_all, NULL);
    }
    
    if (errno != ECHILD) {
    	Sio_error("waitpid error");
    }
    errno = olderrno;
}


int main()
{
    int pid;
    sigset_t mask_all;
    sigset_t prev_all;
    
    Sigfillset(&mask_all);
    
    Signal(SIGCHLD, handler);
    
    initjobs();
    
    while(n--) {
    	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);
}

 

 

 

🔶  무엇과 무엇이 race(경주)하고 있는 가?

 

 

 

부모 프로세스의 main이 진행되며 Sigpromask에서 SIGBLOCK하려는 것과 자식 프로세스가 종료되어 SIGCHLD가 호출되는 것이 경주하고 있다.

 

 

 

즉, Block하기 전에 SIGCHLD가 실행되게 되면 작업을 등록도 하기 전에 좀비 제거를 하게 되버린다. 이는 원하지 않는 동작이다.

 

 

 

나름 베타적으로 addjob과 deletejob을 하려고 샌드위치처럼 sigpromask를 하여도 100만번의 한번 꼴로 이런 race현상이 발생한다는 것이다.

 

 

 

 

void handler(int sig)
{
    int olderrno = errno;
    sigset_t mask_all;
    sigset_t prev_all;
    int n = N; // N = 5;
    
    pid_t pid;
    
    Sigfillset(&mask_all);

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


int main()
{
    int pid;
    sigset_t mask_all;
    sigset_t mask_one;
    sigset_t prev_one;
    
    Sigfillset(&mask_all);
    Sigemptyset(&mask_one);
    
    // SIGCHLD만 1로 만든다.
	Sigaddset(&mask_one, SIGCHLD);
    
    Signal(SIGCHLD, handler);
    
    initjobs();
    
    while(n--) {
    	// SIGNAL에서 SIGCHLD만 Block
    	Sigprocmask(SIG_BLOCK, &mask_one, &prev_one);
        
    	if ((pid = Fork()) == 0 ) {
            // 자식에서는 SIGCHLD UnBlock
	        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);
}

 

 

위에처럼 자식을 생성하기도 전에 냅다 SIGCHLD를 블록해준다. 이후에 자식을 만들면, 그대로 SIGCHLD를 언블록해준다. 자식은 자기 갈길 그대로 가면 되기 때문이다.

 

 

즉, 부모는 그대로 SIGCHLD가 블록된 상태이다.(fork는 signal mask가 상속이기 때문이다.)

그 상태에서 부모는 모든 시그널에 대해 블록을 해주고 addjob을 하여 확실하게 해당 PID를 job에 등록시킨다.

 

 

 

이렇게 하면 "경주" 현상은 없어진다. 왜냐하면, 부모에서 SIGCHLD는 이미 블록된 상태이기 때문이다.

 

 

 

 

 

 

 

 

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

 

 

 

volatile sig_atomic_t pid;

void sigchld_handler(int sig)
{
    int olderrno = errno;
    pid = waitpid(-1, NULL, 0);
    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) {
        	exit(0);
        }
        
        pid = 0;
        
        Sigprocmask(SIG_SETMASK, &prev, NULL);
        
        while(!pid) {} // spin roop
        
        printf(".");        
    }
    printf("\n");
    exit(0);
}

 

 

 

 

while문을 살펴보자. Fork()를 통해 자식을 생성하는데, 자식일 경우 바로 종료한다. 의미하는 바는 SIGCHLD를 발생시키겠다는 뜻이다.

 

 

 

그런데, 바로 윗줄을 보니 Sigprocmask로 SIGCHLD를 Block시켜주었다. 따라서 SIGCHLD에 대한 핸들러가 바로는 실행되지 않을 것이다.

 

 

 

부모 프로세스는 그대로 진행하며, pid를 0으로 설정한다. 그리고는 SIGCHLD를 다시 Unblock시켜주는데, 이때 아까 발생시켜 Block되었던 SIGCHLD를 그대로 맞게 된다.

 

 

 

이로인해 sigchld_hanlder가 실행될 것이고 좀비 제거를 시도하며 pid 값으로 해당 자식 프로세스 아이디를 가진다.

 

 

 

다시 main으로 돌아와보자. 여기서 while(!pid) {}문을 통해 pid가 0이면 무한 루프를 돈다. 즉, 앞서 수행했던 sigchld_handler에서 좀비제거가 완전히 이루어 질 때까지 무한 루프를 돈다는 것이다.(spinning)

 

 

 

그러나 이는 문제가 발생할 수 있다.

 

 

 

왜냐하면 위 코드는 SIGINT로는 빠져나오지 못하기 때문이다. 오직 pid의 값이 변할 때만 빠져나온다. 또한 while로 인한 Instruction은 계속 수행하고 있다. 확실히 좋지 않다..

 

 

 

그래서 while 대신 pause()를 끼워넣는 방법을 생각할 수도 있다. 하지만 이 또한 문제가 있다.

 

 

 

SIGCHLD가 Unblock된 후에 while 조건문 확인 이후 몸체에 진입한다고 해보자. 만약 이때 pause() 가 실행되기 전에 SIGCHLD 시그널 핸들러가 수행되면, 더 이상 시그널은 발생하지 않는다.

 

 

 

즉, 이후에 발생하는 시그널이 없어 무한하게 대기하는 것이다...

 

 

 

한가지 더 sleep(1)을 쓰는 방법도 있다. sleep을 사용하면 pause의 문제점은 해결되나 성능이 대신 느려진다.

 

 

 

그러면 결국 어떤 방법을 사용하여야 하는가? 위 문제들에 대한 모든 해결책으로 sigsuspend를 사용할 수 있다.

 

 

 

 

 

 

 

 

 

 

sigsuspend를 사용한 시그널 기다리기

 

 

 

#include <signal.h>

int sigsuspend(const sigset_t *mask);

 

 

sigsuspend 함수는 mask에 해당하는 집합으로 block 시그널 집합을 일시적으로 교체한다. 그 후, 시그널을 수신할 때까지 pause()한다. 시그널을 수신하고 pause()가 풀리면, 다시 block을 복구한다.

 

 

음.. 아까전에 pause 사용하면 무한 루프돈다고 했다면서 어떻게 가능한 것이냐고 물을 수 있다. 그 이유는 바로 위 과정을 원자적으로 실행하고 있기 때문이다. 즉, 인터럽트가 불가능하다.

 

 

 

코드로 보면 아래의 과정을 원자형으로 구현한 것과 동일하다.

 

 

 

sigprocmask(SIG_SETMASK, &mask, &prev); // blocked |= mask를 수행
pause(); // 시그널을 수신할 때까지 대기
sigprocmask(SIG_SETMASK, &prev, NULL); // sigsuspend 이전의 blocked로 복원

 

 

 

volatile sig_atomic_t pid;

void sigchld_handler(int sig)
{
    int olderrno = errno;
    pid = waitpid(-1, NULL, 0);
    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) {
    	Sigprocmask(SIG_BLOCK, &mask, &prev);
        
        if (Fork() == 0) {
        	exit(0);
        }
        
        pid = 0;
                
        while(!pid) {
        	sigsuspend(&prev);
        }
        
        printf(".");        
    }
    printf("\n");
    exit(0);
}

 

 

 

while문 안에 sigsuspend를 넣으면, 간단하면서 race 없는 코드가 완성되었다.

 

살짝 생각해야 할 것이 prev는 sigsuspend를 호출하기 이전의 blocked 상태이므로 SIG_BLOCK된 상태이다. sigsuspend 내에서의 mask는 prev이므로, unblock 후 block하는 과정임을 알 수 있다.