MENU
  1. ホーム
  2. C 언어
  3. C 언어에서 시그널 핸들러로 비정상 종료 처리 방법

C 언어에서 시그널 핸들러로 비정상 종료 처리 방법

C 언어

C 언어에서 프로그램의 비정상 종료는 시스템 자원의 누수나 데이터 손상을 초래할 수 있습니다. 이를 방지하기 위해 시그널 핸들러를 사용하면 특정 종료 상황에서 적절한 처리를 수행할 수 있습니다. 본 기사에서는 C 언어의 시그널 핸들러를 활용하여 프로그램의 안정성을 높이는 방법을 알아봅니다.

목차

시그널과 시그널 핸들러 개념


시그널은 운영 체제에서 프로세스에 특정 이벤트를 알리기 위한 메커니즘입니다. 예를 들어, 사용자가 Ctrl+C를 눌렀을 때 운영 체제는 실행 중인 프로세스에 SIGINT 시그널을 보냅니다.

시그널의 정의


시그널은 소프트웨어 인터럽트로서, 프로세스가 특정 이벤트를 감지하거나 응답할 수 있도록 설계된 일종의 알림입니다.

시그널 핸들러란?


시그널 핸들러는 시그널이 발생했을 때 실행되는 사용자 정의 함수입니다. 개발자는 특정 시그널에 대해 핸들러를 등록함으로써 이벤트 발생 시 원하는 동작을 지정할 수 있습니다.
예를 들어, SIGINT 시그널에 대한 핸들러를 설정하여 프로그램이 강제 종료되기 전에 데이터를 저장하거나 리소스를 정리할 수 있습니다.

핸들러 등록의 기본 구조


C 언어에서 시그널 핸들러를 등록하려면 signal() 함수를 사용합니다.

#include <signal.h>

void handler(int signum) {
    printf("Received signal %d\n", signum);
}

int main() {
    signal(SIGINT, handler);
    while (1) {
        // 무한 루프
    }
    return 0;
}


위 코드에서 SIGINT 시그널이 발생하면 handler 함수가 호출됩니다. 이를 통해 프로세스 종료 전에 필요한 작업을 수행할 수 있습니다.

C 언어에서의 주요 시그널


C 언어에서 시그널은 운영 체제와 프로세스 간의 통신 수단으로 활용되며, 각 시그널은 특정한 상황을 나타냅니다. 다음은 주요 시그널과 그 역할에 대한 설명입니다.

SIGINT


SIGINT는 인터럽트 신호로, 사용자가 키보드에서 Ctrl+C를 누를 때 발생합니다. 이 시그널은 일반적으로 프로세스를 종료하는 데 사용됩니다.

SIGTERM


SIGTERM은 종료 요청 시그널로, 프로세스가 종료되기 전에 필요한 정리 작업을 수행할 기회를 제공합니다. 이 시그널은 강제 종료(SIGHUP, SIGKILL)와 달리 프로세스가 종료를 준비할 시간을 줍니다.

SIGSEGV


SIGSEGV는 세그먼테이션 오류가 발생했을 때 전달되는 시그널입니다. 이는 메모리 접근 위반으로 인한 충돌을 나타내며, 프로그램의 비정상 종료를 방지하기 위해 디버깅이 필요합니다.

SIGKILL


SIGKILL은 프로세스를 즉시 종료하는 강제 신호입니다. 이 시그널은 프로세스가 종료되지 않을 경우 운영 체제가 강제로 프로세스를 종료하기 위해 사용됩니다. 프로세스는 이 시그널을 무시할 수 없습니다.

SIGALRM


SIGALRM은 알람 신호로, alarm() 함수에 의해 특정 시간이 지난 후 전달됩니다. 이 시그널은 타이머 기반의 이벤트 처리에 유용합니다.

기타 시그널

  • SIGHUP: 터미널 연결이 끊어질 때 발생
  • SIGUSR1, SIGUSR2: 사용자 정의 시그널로 특정 동작을 정의 가능
  • SIGCHLD: 자식 프로세스 종료 시 부모 프로세스에 전달

시그널은 각각 고유한 역할을 가지고 있으며, 이를 적절히 처리함으로써 프로그램의 안정성과 유연성을 높일 수 있습니다.

시그널 핸들러 작성 방법


C 언어에서 시그널 핸들러를 작성하고 등록하려면 signal() 함수 또는 sigaction 구조를 활용합니다. 다음은 시그널 핸들러를 구현하는 기본적인 절차와 예제입니다.

기본적인 시그널 핸들러 작성


핸들러 함수는 시그널 번호를 매개변수로 받는 반환값이 없는 함수로 정의됩니다.

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

void signal_handler(int signum) {
    printf("Received signal: %d\n", signum);
}

int main() {
    // SIGINT 시그널 핸들러 등록
    signal(SIGINT, signal_handler);

    printf("Press Ctrl+C to trigger the signal handler.\n");
    while (1) {
        // 무한 루프
    }

    return 0;
}


위 코드에서 사용자가 Ctrl+C를 누르면 SIGINT 시그널이 발생하며, signal_handler 함수가 호출됩니다.

`sigaction`을 활용한 고급 핸들러 등록


sigaction은 더 세밀한 제어가 필요한 경우 사용됩니다.

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

void signal_handler(int signum) {
    printf("Handled signal: %d\n", signum);
}

int main() {
    struct sigaction sa;
    memset(&sa, 0, sizeof(sa));
    sa.sa_handler = signal_handler;

    // SIGTERM 시그널 핸들러 등록
    sigaction(SIGTERM, &sa, NULL);

    printf("Send SIGTERM to this process to trigger the handler.\n");
    while (1) {
        // 무한 루프
    }

    return 0;
}


위 예제는 SIGTERM 시그널을 처리하도록 설계되었으며, 기존 signal() 함수보다 더 안정적이고 유연한 방법을 제공합니다.

핸들러 등록 해제


시그널 핸들러를 해제하려면 signal() 또는 sigaction을 사용해 기본 동작으로 재설정합니다.

signal(SIGINT, SIG_DFL);  // 기본 동작으로 재설정
signal(SIGINT, SIG_IGN);  // 시그널 무시

주의사항

  • 시그널 핸들러 내부에서는 printf와 같은 비동기 안전 함수 사용에 주의가 필요합니다.
  • 핸들러는 가능한 간결하게 작성하여 빠르게 반환되도록 설계해야 합니다.

이러한 방법을 활용해 비정상 종료 시 필요한 동작을 수행하는 견고한 프로그램을 작성할 수 있습니다.

비정상 종료 처리의 필요성


프로그램이 비정상적으로 종료되면 시스템 자원 누수, 데이터 손상, 사용자 경험 저하 등의 문제가 발생할 수 있습니다. 이러한 문제를 사전에 방지하기 위해 비정상 종료를 감지하고 적절히 처리하는 것은 소프트웨어 개발의 핵심 과제 중 하나입니다.

비정상 종료가 발생하는 이유

  • 시그널 발생: SIGINT, SIGTERM, SIGKILL 등 시그널에 의해 강제 종료
  • 예외 상황: 메모리 접근 오류(SIGSEGV), 산술 연산 오류(SIGFPE) 등
  • 시스템 리소스 부족: 메모리, 파일 핸들 등의 자원 고갈

비정상 종료의 주요 문제점

  • 리소스 누수: 파일이나 소켓이 닫히지 않은 채로 방치될 수 있음
  • 데이터 무결성 손상: 파일 쓰기 중단으로 인해 데이터가 손상될 위험
  • 사용자 경험 저하: 예상치 못한 종료로 인해 신뢰도가 낮아짐

비정상 종료 처리가 중요한 이유

  1. 시스템 안정성 보장
    비정상 종료 시 리소스를 정리함으로써 운영 체제의 안정성을 유지할 수 있습니다.
  2. 데이터 보호
    데이터를 안전하게 저장하거나 미완료 작업을 롤백하여 데이터 손실을 방지할 수 있습니다.
  3. 유지보수 및 디버깅 지원
    비정상 종료 시 로깅과 같은 진단 작업을 수행하면 문제 원인을 쉽게 파악할 수 있습니다.

비정상 종료 처리의 기본 원칙

  • 비정상 종료 상황을 감지하고, 사용자 정의 시그널 핸들러를 통해 적절히 대응
  • 종료 전에 모든 열려 있는 파일 및 네트워크 연결 닫기
  • 실행 중인 트랜잭션 롤백 및 임시 파일 삭제

적절한 종료 처리를 통해 소프트웨어의 안정성을 향상시키고 사용자 신뢰를 확보할 수 있습니다.

실행 중 발생 가능한 시그널 예시


프로그램 실행 중 다양한 시그널이 발생할 수 있으며, 이는 하드웨어 이벤트, 사용자 동작, 소프트웨어 오류 등으로 인해 트리거됩니다. 주요 시그널의 발생 상황과 원인을 이해하면 적절한 대응을 설계할 수 있습니다.

사용자 입력으로 인한 시그널

  • SIGINT: 사용자가 키보드에서 Ctrl+C를 누르면 발생합니다. 일반적으로 프로그램을 종료할 때 사용됩니다.
  • SIGTSTP: 사용자가 Ctrl+Z를 누르면 프로세스가 일시 정지됩니다.

소프트웨어 오류로 인한 시그널

  • SIGSEGV: 잘못된 메모리 접근(예: NULL 포인터 참조)으로 인해 발생하는 세그먼테이션 오류입니다.
  • SIGFPE: 0으로 나누기 또는 오버플로와 같은 산술 연산 오류가 발생할 때 전달됩니다.
  • SIGABRT: 프로그램이 abort() 함수 호출로 종료될 때 발생합니다.

시스템에 의한 시그널

  • SIGTERM: 시스템이나 다른 프로세스에서 종료를 요청할 때 발생합니다. 이를 통해 프로세스가 안전하게 종료 준비를 할 수 있습니다.
  • SIGHUP: 터미널 연결이 끊어질 때 발생하며, 데몬 프로세스에서 재구성을 트리거하는 데 사용되기도 합니다.
  • SIGPIPE: 프로세스가 닫힌 파이프에 데이터를 쓰려고 할 때 발생합니다.

타이머와 리소스 관련 시그널

  • SIGALRM: 타이머가 만료되었을 때 발생하며, alarm() 함수를 사용해 설정합니다.
  • SIGCHLD: 자식 프로세스가 종료되거나 상태가 변경될 때 부모 프로세스에 전달됩니다.

사용자 정의 시그널

  • SIGUSR1, SIGUSR2: 개발자가 정의한 특정 동작을 트리거하는 데 사용됩니다.

발생 상황 예시

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

void signal_handler(int signum) {
    printf("Caught signal %d\n", signum);
}

int main() {
    signal(SIGINT, signal_handler);  // Ctrl+C 처리
    signal(SIGSEGV, signal_handler);  // 세그멘테이션 오류 처리

    printf("Triggering SIGSEGV\n");
    int *p = NULL;
    *p = 42;  // SIGSEGV 발생

    return 0;
}

위 예제는 SIGINT와 SIGSEGV 발생 시 이를 감지하고 처리할 수 있도록 설계되었습니다. 다양한 시그널 발생 상황을 이해하고 대비하는 것은 안정적이고 견고한 프로그램을 작성하는 데 필수적입니다.

안전한 리소스 정리 방법


프로그램이 비정상적으로 종료될 경우, 열려 있는 파일, 메모리, 네트워크 연결 등 리소스가 제대로 정리되지 않으면 시스템에 심각한 문제가 발생할 수 있습니다. 시그널 핸들러를 활용하면 비정상 종료 시에도 안전하게 리소스를 정리할 수 있습니다.

파일 및 네트워크 연결 닫기


파일이나 소켓이 열려 있는 상태로 프로그램이 종료되면 데이터 손상이나 리소스 누수가 발생할 수 있습니다.

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

FILE *file;

void signal_handler(int signum) {
    if (file) {
        fclose(file);  // 열린 파일 닫기
        printf("File closed safely.\n");
    }
    printf("Signal %d caught. Cleaning up resources.\n", signum);
    _exit(0);
}

int main() {
    file = fopen("example.txt", "w");
    if (!file) {
        perror("File opening failed");
        return 1;
    }

    signal(SIGINT, signal_handler);  // Ctrl+C 처리

    while (1) {
        fprintf(file, "Writing to file...\n");
        fflush(file);
        sleep(1);
    }

    return 0;
}


위 코드는 SIGINT 시그널이 발생했을 때 열린 파일을 안전하게 닫습니다.

메모리 해제


동적 메모리를 할당한 후 해제하지 않고 프로그램이 종료되면 메모리 누수가 발생할 수 있습니다.

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

void *memory;

void signal_handler(int signum) {
    if (memory) {
        free(memory);  // 동적 메모리 해제
        printf("Memory freed safely.\n");
    }
    printf("Signal %d caught. Exiting.\n", signum);
    _exit(0);
}

int main() {
    memory = malloc(1024);  // 동적 메모리 할당
    if (!memory) {
        perror("Memory allocation failed");
        return 1;
    }

    signal(SIGTERM, signal_handler);  // SIGTERM 처리

    while (1) {
        sleep(1);
    }

    return 0;
}

임시 파일 삭제


프로그램이 종료되기 전에 임시 파일을 삭제하지 않으면 시스템에 불필요한 파일이 남을 수 있습니다.

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

void signal_handler(int signum) {
    unlink("tempfile.txt");  // 임시 파일 삭제
    printf("Temporary file deleted.\n");
    _exit(0);
}

int main() {
    FILE *file = fopen("tempfile.txt", "w");
    if (!file) {
        perror("File creation failed");
        return 1;
    }
    fprintf(file, "Temporary data.\n");
    fclose(file);

    signal(SIGINT, signal_handler);  // Ctrl+C 처리

    while (1) {
        sleep(1);
    }

    return 0;
}

리소스 정리의 중요성

  • 시스템 안정성: 리소스를 적절히 정리함으로써 시스템 자원을 낭비하지 않음
  • 데이터 보호: 파일 쓰기 중단 등으로 인한 데이터 손상 방지
  • 유지보수성: 코드 품질 향상 및 디버깅 용이

시그널 핸들러에서 리소스를 안전하게 정리하면 프로그램 종료 시 발생할 수 있는 문제를 최소화할 수 있습니다.

시그널 핸들러에서의 제약


시그널 핸들러는 비동기적으로 실행되기 때문에 일반적인 함수와 다르게 제약이 따릅니다. 이러한 제약을 이해하고 올바르게 처리하지 않으면 프로그램의 안정성이 저하될 수 있습니다.

비동기 안전 함수만 사용


시그널 핸들러 내부에서는 비동기 안전 함수만 호출해야 합니다. 비동기 안전 함수는 호출 도중 다른 시그널로 인해 중단되더라도 데이터가 손상되지 않는 함수입니다.

비동기 안전 함수의 예

  • write
  • _exit
  • signal

사용하면 안 되는 함수의 예

  • printf
  • malloc
  • free

다음 코드는 잘못된 예시입니다:

void signal_handler(int signum) {
    printf("Caught signal %d\n", signum);  // printf는 비동기 안전하지 않음
}

다음은 수정된 코드입니다:

#include <unistd.h>

void signal_handler(int signum) {
    const char *message = "Signal caught\n";
    write(STDOUT_FILENO, message, sizeof("Signal caught\n") - 1);  // write는 안전
}

전역 변수와 데이터 동기화


시그널 핸들러에서 전역 변수를 수정하면 예상치 못한 동작이 발생할 수 있습니다. 전역 변수는 핸들러 외부에서도 사용되므로, 경쟁 상태가 발생할 위험이 있습니다.

잘못된 사용 예

int counter = 0;

void signal_handler(int signum) {
    counter++;  // 경쟁 상태 발생 가능
}

올바른 사용 예

volatile sig_atomic_t counter = 0;

void signal_handler(int signum) {
    counter++;  // sig_atomic_t는 원자적으로 처리
}

핸들러 실행 시간 최소화


시그널 핸들러는 가능한 빠르게 실행을 종료해야 합니다. 핸들러에서 복잡한 작업을 수행하면 다른 시그널의 처리가 지연될 수 있습니다.

예시

void signal_handler(int signum) {
    // 복잡한 작업 수행은 지양
    perform_complex_operation();  // 비효율적
}

개선된 예시

void signal_handler(int signum) {
    // 플래그를 설정하여 작업을 나중에 처리
    set_flag_for_processing();
}

재진입 문제 방지


시그널 핸들러가 실행 중일 때 동일한 시그널이 발생하면 핸들러가 재진입될 수 있습니다. 이를 방지하려면 시그널 블록킹을 활용합니다.

예시

#include <signal.h>

void signal_handler(int signum) {
    signal(signum, SIG_IGN);  // 시그널 임시 무시
    // 처리 로직
    signal(signum, signal_handler);  // 시그널 다시 등록
}

핸들러에서의 제약 요약

  • 비동기 안전 함수만 사용
  • 전역 변수 접근 시 동기화 고려
  • 실행 시간을 최소화하여 처리
  • 재진입 문제를 방지하기 위한 시그널 블록킹 활용

이러한 제약을 준수하면 시그널 핸들러가 보다 안전하고 안정적으로 동작할 수 있습니다.

확장 예시: 사용자 정의 시그널


C 언어에서는 SIGUSR1과 SIGUSR2 시그널을 활용해 특정 동작을 사용자 정의할 수 있습니다. 이 기능을 사용하면 프로세스 간 통신이나 맞춤형 동작을 쉽게 구현할 수 있습니다.

사용자 정의 시그널의 활용


SIGUSR1과 SIGUSR2는 표준으로 정의된 시그널로, 특정 상황에서 사용자가 직접 동작을 정의할 수 있습니다. 이들은 일반적으로 프로그램 로직에 따라 특정 기능을 트리거하는 데 활용됩니다.

사용자 정의 시그널 등록 예제


다음은 SIGUSR1과 SIGUSR2를 사용해 간단한 동작을 정의하는 코드입니다.

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

void handle_usr1(int signum) {
    printf("SIGUSR1 received: Performing Task 1\n");
}

void handle_usr2(int signum) {
    printf("SIGUSR2 received: Performing Task 2\n");
}

int main() {
    // SIGUSR1과 SIGUSR2에 대한 핸들러 등록
    signal(SIGUSR1, handle_usr1);
    signal(SIGUSR2, handle_usr2);

    printf("Process ID: %d\n", getpid());
    printf("Send SIGUSR1 or SIGUSR2 to trigger the handlers.\n");

    // 무한 루프에서 신호 대기
    while (1) {
        pause();  // 시그널 대기
    }

    return 0;
}


이 코드에서 pause() 함수는 시그널이 발생할 때까지 프로세스를 멈춥니다. kill 명령어를 사용해 특정 시그널을 프로세스에 전달할 수 있습니다.

kill -SIGUSR1 <프로세스 ID>
kill -SIGUSR2 <프로세스 ID>

고급 활용 예제: 사용자 정의 상태 관리


사용자 정의 시그널을 활용해 간단한 상태 전환 프로그램을 구현할 수 있습니다.

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

volatile sig_atomic_t current_state = 0;

void toggle_state(int signum) {
    current_state = (current_state + 1) % 2;
    printf("State changed to: %d\n", current_state);
}

int main() {
    // SIGUSR1에 상태 전환 핸들러 등록
    signal(SIGUSR1, toggle_state);

    printf("Process ID: %d\n", getpid());
    printf("Send SIGUSR1 to toggle the state.\n");

    while (1) {
        sleep(1);
    }

    return 0;
}


이 코드는 SIGUSR1 시그널을 받을 때마다 상태를 전환하며, 상태 변화는 전역 변수 current_state를 통해 관리됩니다.

사용자 정의 시그널 활용의 장점

  • 프로세스 간 통신: SIGUSR1과 SIGUSR2를 통해 간단한 통신 구현
  • 동적 동작 변경: 런타임 중 특정 기능 트리거 가능
  • 코드 단순화: 이벤트 기반 동작 처리로 복잡성 감소

주의사항

  • 사용자 정의 시그널의 핸들러에서 비동기 안전 함수만 사용해야 합니다.
  • 시그널 핸들러 실행 중 동일 시그널이 중첩되지 않도록 설계해야 합니다.

사용자 정의 시그널은 프로그램의 유연성과 기능성을 크게 향상시키며, 다양한 응용 프로그램에서 활용할 수 있는 강력한 도구입니다.

요약


본 기사에서는 C 언어에서 시그널 핸들러를 활용해 비정상 종료를 처리하는 방법을 다루었습니다. 주요 시그널과 핸들러 작성법, 리소스 정리 전략, 사용자 정의 시그널 활용 예제를 통해 안정적이고 견고한 프로그램 개발 방법을 제시했습니다. 이를 통해 비정상 종료 시 발생할 수 있는 문제를 효과적으로 관리하고 소프트웨어의 안정성을 높일 수 있습니다.

C 언어
C 언어 비정상 종료 시그널 핸들러
목차