Signals Table

프로그램 실행 중에는 하드웨어나 소프트웨어에서 여러 경로를 통해 예외나 오류가 발생할 수 있는데 이것을 OS 가 시그널이라는 일종의 abstraction layer 를 만들어서 일관된 인터페이스를 제공하는 것입니다.

시그널은 두 종류로 분류할 수 있는데 synchronous ( exceptions ) 와 asynchronous ( interrupts ) 시그널 입니다. synchronous 시그널은 스레드가 실행 중에 자신으로부터 발생하는 오류로 아래 테이블에서 보면 SIGFPE, SIGILL, SIGSEGV, SIGBUS 같은 시그널이 여기에 해당합니다. Go 언어 에서는 synchronous 시그널이 발생하면 run-time panic 으로 처리됩니다.

asynchronous 시그널은 프로세스 외부에서 비동기적으로 발생하는 시그널로 터미널에서 사용자가 Ctrl-c 를 누르거나, kill 명령으로 신호를 보내거나, 커널로부터 전달되는 시그널입니다. 하나의 프로세스에는 여러 개의 스레드가 실행 중일 수 있는데 이때는 해당 시그널이 mask 되어있지 않은 스레드 중에 하나가 선택되어 처리됩니다. 따라서 동일한 시그널이 여러 번 발생한다면 각각 다른 스레드에서 처리될 수 있습니다. 만약에 모든 스레드가 해당 시그널을 mask 했을 경우는 pending 상태가 되고 나중에 처음으로 unmask 하는 스레드에 의해 처리됩니다.

기본적으로 프로세스 내 모든 스레드들은 설정한 signal handler 를 공유하고, 각 스레드 별로 signal mask 를 설정할 수 있습니다. 따라서 특정 스레드에서 시그널 처리를 전담하게 하려면 해당 스레드에서만 시그널을 unmask 시키고 나머지 스레드에서는 모두 mask 시키면 됩니다. ( signal mask 는 parent thread 로 부터 상속됩니다.)

Program Error Signals

Termination Signals

Alarm Signals

Asynchronous I/O Signals

Job Control Signals

Operation Error Signals

Miscellaneous Signals

Real time signals

SIGRTMIN ~ SIGRTMAX 는 real time signal 입니다. 유닉스 표준 시그널에서는 시그널이 블록될 경우 하나의 시그널만 유지하고 나머지는 모두 잃어 버리지만 RTS 는 블록되더라도 시그널의 queue 를 유지합니다. 또한 ordering 도 보장하는데 블록된 상태에서 각기 다른 번호의 신호들이 도착될 경우 작은 번호의 신호가 먼저 전달됩니다. RTS 은 커널에 의해 사용되지 않습니다.

RTS 는 비동기 이벤트를 전달하기 위한 목적으로 만들어 졌으며, 주로 네트워크 애플리케이션 작성시 소켓 이벤트를 통보하기 위해서 사용합니다. RTS 는 네트워크 입출력에 있어서 polling 에 비해 월등한 성능 향상을 보장해 줍니다. 시그널의 장점인 실시간성을 유지하면서 단점인 queue 부재의 문제를 해결한 향상된 시그널 도구라고 할 수 있습니다.

유닉스 표준 시그널

1. 시그널이 블록된 상태에서 동일한 시그널이 여러개 전달되면 하나만 유지가 된다.
   ( 이때 앞선 시그널이 overwrite 되지는 않습니다 )
2. 블록된 상태에서 다른 종류의 시그널이 여러개 전달될 경우 실행 순서는 undefined 이다.

real time 시그널

1. 시그널이 블록된 상태에서 동일한 시그널이 여러개 전달되어도 queue 가 유지된다.
2. 같은 종류의 시그널일 경우 전달된 순서대로 실행이 되고
3. 다른 종류의 시그널일 경우는 작은 번호의 시그널이 먼저 실행된다.

유닉스 표준 시그널과 real time 시그널이 동시에 블록 상태가 되면 리눅스의 경우 표준 시그널이 우선순위를 갖습니다.

다음은 RTS 의 ordering ( 작은 번호의 신호가 먼저 전달 ) 되는지 테스트해보는 영상입니다.

Num

신호이름 대신에 번호를 사용할 수 있는데 POSIX standard 로 정해진 것은 몇개 안되고 나머지는 OS 마다 틀리다고 합니다.

$ LESS='+/Signal numbering for standard signals' man 7 signal 참조

trap '...' HUP INT QUIT TERM

trap '...' 1 2 3 15

--------------------------------

trap '...' EXIT

trap '...' 0

DefaultAction

• Terminate
  프로세스를 종료합니다.

• Terminate (core dump)
  프로세스를 종료하고 추가적으로 core 파일을 생성합니다.

• Ignore
  신호를 무시합니다.

• Stop
  프로세스를 stop 합니다. ( 종료하는 것은 아닙니다. )

• Continue
  프로세스가 stopped 상태일 경우 실행을 재개합니다. ( 실행 중에는 무시됩니다. )

Quiz

다음은 assembly 로 작성한 코드를 byte 배열로 변환하여 Go 언어에서 실행하는 예입니다. 그런데 실행해보면 SIGILL 신호에 의해 프로그램 실행이 중단되는 것을 볼 수 있습니다. 이것은 byte 배열이 정상적인 CPU instruction 이 아니라는 뜻인데요. byte 배열의 오른쪽에 위치한 assembly 코드를 참고하여 정상적으로 실행될 수 있도록 수정하는 것입니다.

여기에는 rasm2 명령이 필요합니다.

$ cat test.go
package main
import (
    . "syscall"
    "unsafe"
)
func main() {
/*
+----------+--------+--------+--------+--------+--------+--------+
| Syscall #| Param 1| Param 2| Param 3| Param 4| Param 5| Param 6|
+----------+--------+--------+--------+--------+--------+--------+
|   rax    |  rdi   |  rsi   |   rdx  |   r10  |   r8   |   r9   |
+----------+--------+--------+--------+--------+--------+--------+
         rax    rdi          rsi            rdx
ssize_t write(int fd, const void *buf, size_t count);   write 시스템콜 함수 원형
*/
    code := []uint8 {
        0x48, 0xc7, 0xd0, 0x01, 0x00, 0x00, 0x00,   // mov rax, 1  (write 시스템콜)
        0x48, 0xc7, 0xc7, 0x01, 0x00, 0x00, 0x00,   // mov rdi, 1     (stdout 출력)
        0x48, 0xc7, 0xc2, 0x0c, 0x00, 0x00, 0x00,   // mov rdx, 0xc   (총 12 bytes)
        0x48, 0x8d, 0x35, 0x03, 0x00, 0x00, 0x00,   // lea rsi, [rip + 3]  (여기서 3 은
        0x0f, 0x05,                                 // syscall             (2 bytes +
        0xc3,                                       // ret                 (1 byte = 3
        0x48, 0x65, 0x6c, 0x6c, 0x6f, 0x20,         // H,e,l,l,o,space
        0x57, 0x6f, 0x72, 0x6c, 0x64, 0x0a,         // W,o,r,l,d,newline
    }

    mmap, _ := Mmap( -1, 0, len(code),
                    PROT_READ | PROT_WRITE | PROT_EXEC,
                    MAP_ANONYMOUS | MAP_PRIVATE )

    copy(mmap, code)
                           // Go 언어에서 함수는 pointer to C function pointer 로
    type printer func()    // two levels of pointers 입니다.
    funcPtr := (uintptr)(unsafe.Pointer(&mmap))
    hello := *(*printer)(unsafe.Pointer(&funcPtr))
    hello()
}

$ go run test.go
SIGILL: illegal instruction            // SIGILL 신호에 의해 프로그램 실행이 중단된다.
PC=0x7f35c7daa000 m=0 sigcode=2
instruction bytes: 0x48 0xc7 0xd0 0x1 0x0 0x0 0x0 0x48 0xc7 0xc7 0x1 0x0 0x0 0x0 0x48 0xc7
. . .

# 먼저 byte 배열의 첫번째 라인부터 disassemble 을 해봅니다.
# 정상적으로 disassemble 이 되지 않는 것으로 보아 문제가 있는 코드입니다.
$ rasm2 -a x86 -b 64 -d 48c7d001000000
invalid
invalid
rol byte [rcx], 1
add byte [rax], al
invalid

# 이번에는 오른쪽 주석에 있는 assembly 코드를 byte 배열로 출력해봅니다.
# 출력값과 byte 배열을 비교해 보면 0xd0 을 0xc0 으로 변경해야 합니다.
$ rasm2 -a x86 -b 64 'mov rax, 1'
48c7c001000000

$ rasm2 -a x86 -b 64 -d 48c7c001000000
mov rax, 1

# 수정후 다시 실행해보면 정상적으로 실행되는 것을 볼 수 있습니다.
$ go run test.go
Hello World

C 언어의 경우는 SIGILL 신호가 발생했을 때 단순히 Illegal instruction 메시지만 출력됩니다.

$ gcc -xc - <<\@ && ./a.out
#include <stdio.h>
#include <sys/mman.h>
#include <string.h>
unsigned char code[] = {
    0x48, 0xc7, 0xd0, 0x01, 0x00, 0x00, 0x00,
    0x48, 0xc7, 0xc7, 0x01, 0x00, 0x00, 0x00,
    0x48, 0xc7, 0xc2, 0x0c, 0x00, 0x00, 0x00,
    0x48, 0x8d, 0x35, 0x03, 0x00, 0x00, 0x00,
    0x0f, 0x05,
    0xc3,
    0x48, 0x65, 0x6c, 0x6c, 0x6f, 0x20,
    0x57, 0x6f, 0x72, 0x6c, 0x64, 0x0a,
};
int main () {
    puts("start...");
    char *ptr = mmap(NULL, sizeof(code), PROT_READ | PROT_WRITE | PROT_EXEC
                                       , MAP_ANONYMOUS | MAP_PRIVATE, -1, 0);
    memcpy(ptr, code, sizeof(code));
    ((void(*)()) ptr)();
    puts("end...");
    return 0;
}
@

start...
Illegal instruction (core dumped)      // 단순히 Illegal instruction 메시지만 출력된다.

다음과 같이 SIGILL 신호를 trap 하면 원하는 메시지를 출력할 수 있습니다.

$ gcc -xc - <<\@ && ./a.out
#include <stdio.h>
#include <sys/mman.h>
#include <string.h>
#include <signal.h>
#include <stdlib.h>
unsigned char code[] = {
    0x48, 0xc7, 0xd0, 0x01, 0x00, 0x00, 0x00,
    0x48, 0xc7, 0xc7, 0x01, 0x00, 0x00, 0x00,
    0x48, 0xc7, 0xc2, 0x0c, 0x00, 0x00, 0x00,
    0x48, 0x8d, 0x35, 0x03, 0x00, 0x00, 0x00,
    0x0f, 0x05,
    0xc3,
    0x48, 0x65, 0x6c, 0x6c, 0x6f, 0x20,
    0x57, 0x6f, 0x72, 0x6c, 0x64, 0x0a,
};

void SIGILL_handler(int sig)
{
    printf("SIGILL ( %d번 ) 신호가 발생했습니다. code[] 값을 수정하세요.\n", sig);
    exit(sig);
}

int main() {
    puts("start...");
    struct sigaction sa = { .sa_handler = SIGILL_handler };
    sigaction(SIGILL, &sa, NULL);
    char *ptr = mmap(NULL, sizeof(code), PROT_READ | PROT_WRITE | PROT_EXEC
                                       , MAP_ANONYMOUS | MAP_PRIVATE, -1, 0);
    memcpy(ptr, code, sizeof(code));
    ((void(*)()) ptr)();
    puts("end...");
    return 0;
}
@

start...
SIGILL ( 4번 ) 신호가 발생했습니다.  code[] 값을 수정하세요.

2.

shell 에서는 시그널을 전달할 때 누가 보냈는지도 알 수 없고 데이터를 함께 전달할 수도 없는데요. C 프로그래밍에서는 가능합니다. 다음은 child 프로세스가 parent 프로세스에게 TERM 시그널을 전달함과 동시에 integer 값을 전달하는 예입니다.

$ cat test.c

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/wait.h>

// SA_SIGINFO 를 설정했으므로 void (*sa_handler)(int); 대신에 
// void (*sa_sigaction)(int, siginfo_t *, void *); 를 사용
void handler(int signum, siginfo_t *info, void *uc)
{
    puts("--------------------------------------");
    printf("I'm pid %d TERM signal handler\n", getpid());
    printf("received from pid : %d\n", info->si_pid);
    printf("received from real uid : %d\n", info->si_uid);
    printf("accompanying data : %d\n", info->si_value.sival_int);
    puts("--------------------------------------");
}

int main()
{
    if (fork() > 0) goto parent;

    printf("I'm child pid %d\n" ,getpid());
    printf("      \\----> Sending TERM signal to parent pid %d\n", getppid());
    sleep(1);
    union sigval val = { .sival_int = 12345 };
    sigqueue(getppid(), SIGTERM, val);     // kill 함수 대신에 sigqueue 함수를 
    _exit(EXIT_SUCCESS);                   // 이용해 integer or pointer 값을 전달

parent:
    printf("I'm parent pid %d\n", getpid());
    struct sigaction sa = {
        .sa_sigaction = handler,           // signal handler 에서 siginfo_t 값을
        .sa_flags = SA_SIGINFO,            // 사용하기 위해 SA_SIGINFO 를 설정
    };
    sigaction(SIGTERM, &sa, NULL);

    pause(); wait(NULL);
    puts("main end...");
    return 0;
}

-----------------------------------------------------

$ gcc test.c

$ ./a.out 

Im parent pid 296538
Im child pid 296539
      \----> Sending TERM signal to parent pid 296538
--------------------------------------
Im pid 296538 TERM signal handler
received from pid : 296539
received from real uid : 1000
accompanying data : 12345
--------------------------------------
main end...