Функция, вызываемая от обработчика сигнала, не асинхронного-безопасного, возникает, когда обработчик сигнала вызывает функцию, которая не является асинхронной-безопасной в соответствии со стандартом POSIX. Асинхронно-безопасная функция может быть прервана в любой момент ее выполнения, затем вызвана снова, не вызывая несогласованного состояния. Он также может правильно обрабатывать глобальные данные, которые могут находиться в несогласованном состоянии.

Если обработчик сигнала вызывает другую функцию, которая вызывает асинхронно-небезопасную функцию, дефект появляется при вызове функции в обработчике сигнала. Трассировка дефекта показывает полный путь от обработчика сигнала до асинхронно-небезопасной функции.

Когда вызывается обработчик сигнала, выполнение программы прерывается. После завершения работы обработчика выполнение программы возобновляется в точке прерывания. Если функция выполняется во время прерывания, вызов ее из обработчика сигнала является неопределенным поведением, если только это не асинхронно-безопасно.

Стандарт POSIX определяет эти функции как асинхронно-безопасные. Можно вызвать эти функции из обработчика сигнала.

Функции, не указанные в предыдущей таблице, не являются асинхронно-безопасными и не должны вызываться из сигнальной трубки.

#include <signal.h>
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <setjmp.h>
#include <syslog.h>
#include <unistd.h>

#define SIZE20 20

extern volatile sig_atomic_t e_flag;

void display_info(const char *info)
{
    if (info)
    {
        (void)fputs(info, stderr);
    }
}

void sig_handler(int signum)
{
    /* Call function printf() that is not
	asynchronous-safe */
	printf("signal %d received.", signum); 
    e_flag = 1;
}

int main(void)
{
    e_flag = 0;
    if (signal(SIGINT, sig_handler) == SIG_ERR)
    {
        /* Handle error */
    }
    char *info = (char *)calloc(SIZE20, sizeof(char));
    if (info == NULL)
    {
        /* Handle Error */
    }
    while (!e_flag)
    {
        /* Main loop program code */
        display_info(info);
        /* More program code */
    }
    free(info);
    info = NULL;
    return 0;
}
        
      

В этом примере sig_handler вызывает printf() при захвате сигнала. Если обработчик захватывает другой сигнал во время printf() выполняется, поведение программы не определено.

Используйте обработчик сигнала, чтобы задать только значение флага. e_flag имеет тип «летучий» sig_atomic_t. sig_handler может безопасно получить к нему доступ асинхронно.

#include <signal.h>
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <setjmp.h>
#include <syslog.h>
#include <unistd.h>

#define SIZE20 20

extern volatile sig_atomic_t e_flag;

void display_info(const char *info)
{
    if (info)
    {
        (void)fputs(info, stderr);
    }
}

void sig_handler1(int signum)
{
    int s0 = signum;
    e_flag = 1;       
}

int func(void)
{
    e_flag = 0;
    if (signal(SIGINT, sig_handler1) == SIG_ERR)
    {
        /* Handle error */
    }
    char *info = (char *)calloc(SIZE20, 1);
    if (info == NULL)
    {
        /* Handle error */
    }
    while (!e_flag)
    {
        /* Main loop program code */
        display_info(info);
        /* More program code */
    }
    free(info);
    info = NULL;
    return 0;
} 

Функция, вызываемая от обработчика сигнала, не асинхронно-безопасного (строгого), возникает, когда обработчик сигнала вызывает функцию, которая не асинхронно-безопасна в соответствии со стандартом C. Асинхронно-безопасная функция может быть прервана в любой момент ее выполнения, затем вызвана снова, не вызывая несогласованного состояния. Он также может правильно обрабатывать глобальные данные, которые могут находиться в несогласованном состоянии.

При выборе проверки Function, вызываемой от обработчика сигнала, не асинхронно-безопасного, проверка обнаруживает вызовы функций, которые не являются асинхронно-безопасными в соответствии со стандартом POSIX. Функция, вызываемая от обработчика сигнала, не асинхронно-безопасного (строгого), не вызывает дефект для этих случаев. Функция, вызываемая от обработчика сигнала, не асинхронно-безопасного (строгого), вызывает дефект для функций, которые асинхронно-безопасны в соответствии со стандартом POSIX, но не согласно стандарту C.

Если обработчик сигнала вызывает другую функцию, которая вызывает асинхронно-небезопасную функцию, дефект появляется при вызове функции в обработчике сигнала. Трассировка дефекта показывает полный путь от обработчика сигнала до асинхронно-небезопасной функции.

Когда вызывается обработчик сигнала, выполнение программы прерывается. После завершения работы обработчика выполнение программы возобновляется в точке прерывания. Если функция выполняется во время прерывания, вызов ее из обработчика сигнала является неопределенным поведением, если только это не асинхронно-безопасно.

Стандарт C определяет следующие функции как асинхронно-безопасные. Можно вызвать эти функции из обработчика сигнала:

#include <signal.h>
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <setjmp.h>
#include <syslog.h>
#include <unistd.h>

void SIG_ERR_handler(int signum)
{
    int s0 = signum;
    /* SIGTERM specific handling */
}

void sig_handler(int signum)
{
    int s0 = signum;
	/* Call raise() */ 
    if (raise(SIGTERM) != 0) { 
        /* Handle error */
    }
}

int finc(void)
{
    if (signal(SIGTERM, SIG_ERR_handler) == SIG_ERR)
    {
        /* Handle error */
    }
    if (signal(SIGINT, sig_handler) == SIG_ERR)
    {
        /* Handle error */
    }
    /* Program code */
    if (raise(SIGINT) != 0)
    {
        /* Handle error */
    }
    /* More code */
    return 0;
}
        
      

В этом примере sig_handler вызывает raise() при захвате сигнала. Если обработчик захватывает другой сигнал во время raise() выполняется, поведение программы не определено.

Согласно стандарту C, единственные функции, которые можно безопасно вызвать с обработчика сигнала abort(), _Exit(), quick_exit(), и signal().

#include <signal.h>
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <setjmp.h>
#include <syslog.h>
#include <unistd.h>

void SIG_ERR_handler(int signum)
{
    int s0 = signum;
    /* SIGTERM specific handling */
}
void sig_handler(int signum)
{
    int s0 = signum;
	
  
}

int func(void)
{
    if (signal(SIGTERM, SIG_ERR_handler) == SIG_ERR)
    {
        /* Handle error */
    }
    if (signal(SIGINT, sig_handler) == SIG_ERR)
    {
        /* Handle error */
    }
    /* Program code */
    if (raise(SIGINT) != 0)
    {
        /* Handle error */
    }
    /* More code */
    return 0;
}