13. 시그널

시그널 개요

시그널(Signal)이란?

시그널은 일반적으로 유닉스 계열의 POSIX 호환 운영체제에서 사용되는 제한된 형태의 프로세스 간 통신(IPC)이다.
시그널은 발생한 이벤트를 알리기 위해 프로세스 또는 동일한 프로세스 내의 특정 스레드로 전송되는 비동기 알람이다.
시그널이 전송되면 운영체제는 대상 프로세스의 정상적인 실행 흐름을 중단해 시그널을 전달한다.
프로세스가 시그널 핸들러를 등록한 경우 해당 루틴이 실행되고 그렇지 않으면 기본 핸들러가 실행된다.

# kill -l 명령을 통해 제공하는 전체 시그널 목록을 확인할 수 있다.

시그널 전송

권한이 허용되는 경우 kill() 시스템 콜은 지정된 신호를 지정된 프로세스에 전송한다.
kill 명령을 사용하면 사용자가 프로세스에 신호를 전송한다.
raise() 라이브러리 함수는 지정된 신호를 현재 프로세스에 전송한다.
0으로 나누기(SIGFPE) 또는 세그멘테이션 폴드(SIGSEGV)와 같은 예외는 신호를 생성한다.
커널은 프로세스에 이벤트를 알리기 위해 신호를 생성할 수 있다. (SIGPIPE 등)
실행 중인 프로세스의 제어 터미널에 특정 키 조합 (ex) Ctrl + C)을 입력하면 시스템이 특정 신호를 전송한다. (SIGINT 등)

시그널 처리

커널은 프로세스의 현재 코드 실행을 중단하고, 이전에 등록했던 시그널 핸들러 함수로 건너뛴다.
시그널 핸들러 함수 실행 후 리턴되면 프로세스는 시그널을 붙잡은 시점으로 돌아간다.
시그널 핸들러는 signal() 또는 sigaction() 시스템 콜과 함께 지정할 수 있다.
시그널 핸들러가 특정 시그널에 대해 지정되지 않은 경우 기본 핸들러가 사용된다.
프로세스는 시그널 핸들러를 지정하지 않고 두 가지 기본 동작을 지정할 수 있다.
- SIG_IGN : 시그널 무시
- SIG_DFN : 기본 시그널 핸들러
SIGKILL과 SIGSTOP 시그널은 시스템 관리자가 프로세스를 종료하거나 멈출 수 있어야 하므로 가로채거나 무시할 수 없다.

시그널 경쟁

시그널 처리는 경쟁 조건에 취약하다.
시그널은 비동기이므로 시그널 핸들러 루틴을 실행하는 동안 다른 시그널이 프로세스에 전달될 수 있다.
이를 위해 sigprocmask() 호출을 이용해 시그널 전달을 차단하거나 차단 해제할 수 있다.
차단된 시그널은 차단이 해제될 때까지 프로세스로 전달되지 않는다.
- 무시할 수 없는 신호(SIGKILL, SIGSTOP)는 차단할 수 없다.
주요 시그널

시그널 핸들러

#include <signal.h>

typedef void (*sighandler_t)(int);

sighandler_t signal(int signo, sighandler_t handler);

signal()은 signo 시그널을 받았을 때 수행할 시그널 핸들러로 handler를 지정한다.
SIGKILL, SIGSTOP 시그널을 붙잡을 수 없으므로 이에 대한 처리 설정은 아무 의미가 없다.
핸들러 함수는 아래와 같은 형식으로 signo을 인지로 받아 리턴은 처리되는 겂이 없다.
- void handler (int signo);
handler 인자로 현재 프로세스에 대해 시그널을 무시하게 하거나 기본 동작으로 재설정하는 용도로 다음을 지정할 수 있다.
- SIG_IGN : signo 시그널을 무시한다.
- SIG_DFL : signo 시그널에 대한 동작을 기본값으로 설정한다.
signal() 함수는 정상 동작 시 시그널 핸들러에 대한 포인터 또는 SIG_DFL, SIG_IGN을 리턴한다.
에러 발생 시 SIG_ERR를 리턴하고 errno는 설정하지 않는다.

signal_example.c 의 코드

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

int loop = 1;

static void sigint_handler(int signo)
{
    printf("SIGINT received!\n");
    loop = 0;
}

int main()
{
    if (signal(SIGINT, sigint_handler) == SIG_ERR) {
        printf("register SIGINT handler fail!\n");
        return -1;
    }

    if (signal(SIGTSTP, SIG_IGN) == SIG_ERR) {
        printf("register SIGTSTP handler fail!\n");
        return -1;
    }

    while (loop)
        sleep(1);

    printf("loop exit.\n");

    return 0;
}

수행 결과

시그널 전송

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

int kill (pid_t pid, int signo);

pid 의미
- pid > 0 : pid가 가르키는 프로세스에 signo 시그널을 전송한다.
- pid = 0 : 호출한 프로세스의 프로세스 그룹에 속한 모든 프로세스에 signo 시그널을 전송한다.
- pid = -1 : 호출한 프로세스가 시그널을 보낼 권한이 있는 모든 프로세스에 signo 시그널을 전송한다.
- pid < -1 : 프로세스 그룹 -pid에 signo 시그널을 전송한다.
성공하면 0을 반환하고, 실패하면 -1 반환하고 errno를 설정한다.
- EINVAL : 유효하지 않은 signo
- EPERM : 권한이 없다.
- ESRCH : 유요하지 않은 pid

#include <signal.h>

int raise (int signo);

raise() 함수는 자기 자신에게 signo 시그널을 전송한다.
kill(getpid(), signo); 구문과 동일한 역할을 수행한다.

kill_example.c의 코드


#include <signal.h>
#include <stdlib.h> /* for atoi() */
#include <sys/types.h>
#include <signal.h>

int main(int argc, char *argv[]) { if (argc < 3) { printf("Usage: %s \n", argv[0]); return -1; }

if (kill(atoi(argv[2]), atoi(argv[1])) == -1) {
    perror("kill error: ");
    return -1;
}

return 0;

}


<br>

- 수행 결과

<img width="566" alt="image" src="https://user-images.githubusercontent.com/86760744/181876315-302a8771-e183-4134-895c-eb4f02203674.png">

<br><br>

## 시그널 차단
- 프로세스가 코드 어딘가에서 실행 중인 상태에서, 시그널을 수신하게 되면 실행 중인 부분에서 중단되고, 등록된 시그널 핸들러 함수가 수행되게 된다.
- 핸들러 수행이 완료된 후 중단된 지점으로 돌아와 코드를 계속 수행한다.
- 그런데 수행 중인 코드가 수정 중인 데이터를 핸들러에서 참조하거나 수정하게 되면 문제가 발생할 수 있다.

<br>

- 주기적으로 설정 파일에서 읽어들인 데이터를 이용해 어떤 연산을 수행하는 프로세스가 있다고 가정해보자.
- 이 프로세스는 SIGHUP 시그널을 수신 받으면 설정 파일에서 데이터를 다시 읽어오는 핸들러가 등록되어 있다.
- 그런데 10개의 설정 중 3개의 데이터를 읽어와 연산을 수행했는데, 이 시점에 SIGHUP 시그널을 수신 받게 되면,
- 시그널 핸들러가 다시 설정 파일을 읽어오게 되는데, 중단된 시점으로 복귀하게 되면,
- 앞에 읽어온 3개의 시점과, 핸들러 복귀 이후 나머지 7개의 데이터 시점이 달라지게 된다.
- 시그널 핸들러의 복귀 시에, 이와 같이 의도하지 않은 문제가 발생할 수 있다.

<br>

- 이를 위해 10개의 데어티가 다 처리되는 동안은 시그널을 수신 받지 못하게 차단하여 문제를 해결할 수 있다.
- 즉, 프로그램에서 시그널 핸들러와 프로그램의 다른 부분이 데이터를 공유할 필요가 있을 때,
- 공유되는 부분을 크리티컬 섹션이라 하고, 일시적으로 시그널을 보류하여 이 영역을 보호할 수 있다.

<br>

``` c
#include <signal.h>

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

how
- SIG_SETMASK : 호출한 프로세스의 시그널 마스크를 set으로 변경
- SIG_BLOCK : 현재 마스크에 set을 포함
- SIG_UNBLOCK : 현재 마스크에서 set을 제거
oldset값이 NULL이 아니면 변경 전의 현재 마스크 값을 oldset에 기록한다.
set값이 NULL인 경우 how를 무시하지만 현재 마스크 값을 획득할 수 있다.
호출에 성공 시 0을 반환하고, 실패 시 -1을 반환 후, errno를 설정한다.
- EINVAL : 유효하지 않은 how
- EFAULT : 유요하지 않은 set/oldset

#include <signal.h>에 대해
- int sigemptyset (sigset_t *set);
  - 시그널 집합 set을 비우며 초기화한다.
- int sigfillset (sigset_t *set);
  - 시그널 집합 set에 모든 시그널을 추가하며 초기화한다.
- int sigaddset (sigset_t *set, int signo);
  - 시그널 집합 set에 signo 시그널을 추가한다.
- int sigdelset (sigset_t *set, int signo);
  - 시그널 집합 set에 signo 시그널을 제거한다.
- int sigismemeber (const sigset_t *set, int signo);
  - 시그널 집합 set에 signo 시그널이 포함되어 있으면 1을 반환, 않으면 0을 반환한다.
- 성공 시 0을 반환, 실패 시 -1을 반환 후, errno를 설정한다.
  - EINVAL : 유효하지 않은 signo

sigprocmask_example.c의 코드이다.


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

int wakeup = 0;

static void sig_handler(int signo) { if (signo == SIGINT) printf("signal SIGINT received!\n"); else if (signo == SIGTSTP) printf("signal SIGTSTP received!\n"); else if (signo == SIGQUIT) printf("signal SIGQUIT received!\n"); else printf("signal %d received!\n");

    wakeup = 1;

}

static void wait_for_signal(void) { printf("sleep 10 sec\n"); sleep(10); printf("wakeup!\n"); }

int main() { sigset_t set, oldset;

    if (signal(SIGINT, sig_handler) == SIG_ERR) {
            printf("signal handler(SIGINT) error!\n");
            return -1;
    }

    if (signal(SIGTSTP, sig_handler) == SIG_ERR) {
            printf("signal handler(SIGTSTP) error!\n");
            return -1;
    }

    if (signal(SIGQUIT, sig_handler) == SIG_ERR) {
            printf("signal handler(SIGQUIT) error!\n");
            return -1;
    }

    sigemptyset(&set);
    sigemptyset(&oldset);

    sigaddset(&set, SIGINT);
    sigaddset(&set, SIGTSTP);

    sigprocmask(SIG_BLOCK, &set, NULL);
    printf("Block SIGINT and SIGTSTP\n");

    wait_for_signal();

    sigdelset(&set, SIGINT);

    sigprocmask(SIG_UNBLOCK, &set, &oldset);
    printf("Block only SIGINT\n");

    wait_for_signal();

    sigprocmask(SIG_SETMASK, &oldset, NULL);
    printf("Block SIGINT and SIGTSTP\n");

    wait_for_signal();

    return 0;

}


<br>

- 수행 결과
<img width="377" alt="image" src="https://user-images.githubusercontent.com/86760744/181876379-9c78d575-724e-4a62-b8f5-9b376da145be.png">

<br><br>

## 시그널 고급 관리
- signal() 함수의 대안으로 POSIX는 훨씬 더 강력한 시그널 관리 능력을 제공하는 sigaction() 시스템 콜을 표준화했다.

``` c 
#include <signal.h>

int sigaction (int signo, const struct sigaction *act, struct sigaction *oldact);

sigaction()은 act가 NULL이 아닐 경우, signo 시그널에 대한 동작 방식을 지정한다.
oldact는 NULL이 아닐 경우 이전의 동작 방식을 oldact에 저장한다.

struct sigaction {
    void (*sa_handler)(int);                /* 시그널 핸들러 */
    void (*sa_sigaction)(int, siginfo_t *, void *);    
    sigset_t sa_mask;                        /* 블록할 시그널 */
    int sa_flags;                                  /* 플래그 */
    void (*sa_restorer)(void);            /* 사용하지 않음 */
};

sa_handler 필드는 signal()의 핸들러 함수 인자와 동일하다.
sa_mask 필드는 시그널 핸들러를 실행하는 동안 블록해야할 시그널 set을 의미한다.
sa_flags에 SA_SIGINFO를 설정하면 sa_handler가 아니라 sa_sigaction이 시그널을 처리하는 함수를 명시한다.

void sa_sigaction (int signo, siginfo_t *si, void *ucontext);

#include <sys/signal.h>

typedef struct siginfo_t {
    int si_signo; /* 시그널 번호 */
    int si_errno; /* errno 값 */
    int si_code; /* 시그널을 일으킨 원인을 알려준다.(ex. SI_KERNEL 커널에서 보낸 시그널) */ 
    pid_t si_pid; /* 보내는 프로세스 pid */
    uid_t si_uid; /* 보내는 프로세스 uid */
    int si_status; /* 종료된 값이나 시그널 */
    clock_t si_utime; /* 소비된 사용자 시간 */
    clock_t si_stime; /* 소비된 시스템 시간 */
    sigval_t si_value; /* si_int와 si_ptr의 유니온 */
    int si_int;/* sigqueue() /* 페이로드 정수 타입 */
    void *si_ptr; /* sigqueue() 페이로드 void 포인터 타입 */ 
    void *si_addr; /* 장애가 발생한 메모리 위치 */
    int si_band;
    int si_fd; /* 파일 디스크립터 */
};

si_code 값 등은 sigaction man-page를 참고하면 된다.
sigqueue() 함수를 이용하면 페이로드, 즉 어떤 특정한 데이터를 담아서 시그널을 보낼 수 있다.
수신 받는 프로세스에서 SA_SIGINFO 핸들러로 해당 시그널을 처리하면 보낸 시그널과 데이터를 수신 받을 수 있다.

#inclue <signal.h>

int sigqueue (pid_t pid, int signo, const union sigval value);

union sigval {
    int sival_int;
    void *sival_ptr;
};

성공 시 0을 반환, 실패 시 -1 반환 후 errno를 설정한다.

tonykang22 / study

[리눅스 개발환경] 13. 시그널 #84

13. 시그널

시그널 개요

시그널(Signal)이란?

시그널 전송

시그널 처리

시그널 경쟁

시그널 핸들러

시그널 전송