¿Puntos de cancelación en controladores de señal?

Question

¿Qué sucede si un programa llama a una función que es un punto de cancelación de un manejador de señal? Hay una serie de funciones que POSIX especifica como puntos de cancelación y señal de señal asíncrona. Si un manejador de señal llama a dicha función y se actúa sobre la cancelación, el resultado es bastante similar a lo que sucedería si el hilo hubiera habilitado la cancelación asíncrona, en realidad mucho peor, porque todos los controladores de limpieza de cancelación, que probablemente no son de señal asíncrona seguro, se llamaría desde un contexto de controlador de señal.

¿Qué especifica POSIX realmente en este caso, y qué hacen realmente las implementaciones? No puedo encontrar ningún lenguaje en POSIX que prohíba que se actúe sobre los puntos de cancelación en los manejadores de señal, ni ninguna protección en la fuente glibc/nptl.

Answer 1

No soy consciente de que POSIX incluso se atreve a mencionar este tema, pero no he hecho una búsqueda exhaustiva.

Algunos experimentos breves con un sistema gcc/nptl revelan que, como sospechaba y creo que tú también, no existe tal protección en NPTL: los controladores de cancelación son llamados desde el contexto del controlador de señal.

El programa siguiente (disculpas por la hackiness etc) muestra el resultado siguiente:

Signal handler called 
Sent cancellation 
Cleanup called 
In sighandler 

... que indican que:

• el manejador de la señal fue llamado
• el otro hilo a continuación, llamado pthread_cancel()
• se llamó al controlador de cancelación, sin que el manejador de señal haya completado

Aquí está el programa:

#include <stdio.h> 
#include <pthread.h> 
#include <signal.h> 
#include <string.h> 
#include <unistd.h> 
#include <assert.h> 

pthread_t mainthread; 

int in_sighandler = 0; 

void 
cleanup (void *arg) 
{ 
    write(1, "Cleanup called\n", strlen("Cleanup called\n")); 
    if (in_sighandler) { 
     write(1, "In sighandler\n", strlen("In sighandler\n")); 
    } else { 
     write(1, "Not in sighandler\n", strlen("In sighandler\n")); 
    } 
} 


void 
sighandler (int sig, siginfo_t *siginfo, void *arg) 
{ 
    in_sighandler = 1; 
    write(1,"Signal handler called\n", strlen("Signal handler called\n")); // write() is a CP 
    usleep(3000000); // usleep() is a CP; not strictly async-signal-safe but happens to be so in Linux 
    write(1, "Signal handler exit\n", strlen("Signal handler exit\n")); 
    in_sighandler = 0; 
} 

void * 
thread (void *arg) 
{ 
    sleep(1); 
    pthread_kill(mainthread, SIGUSR1); 
    usleep(500000); 
    pthread_cancel(mainthread); 
    printf("Sent cancellation\n"); 
    return (NULL); 
} 

int 
main (int argc, char **argv) 
{ 
    int rc; 
    struct sigaction sa; 
    pthread_t threadid; 

    mainthread = pthread_self(); 

    // Set up a signal handler to test its cancellation properties 
    sa.sa_sigaction = &sighandler; 
    sigemptyset(&sa.sa_mask); 
    sa.sa_flags = SA_SIGINFO; 
    rc = sigaction(SIGUSR1, &sa, NULL); 
    assert(rc == 0); 

    // Set up a thread to send us signals and cancel us 
    rc = pthread_create(&threadid, NULL, &thread, NULL); 
    assert(rc == 0); 

    // Set up cleanup handlers and loop forever 
    pthread_cleanup_push(&cleanup, NULL); 
    while (1) { 
     sleep(60); 
    } 
    pthread_cleanup_pop(0); 
    return (0); 
}