En informática, sigactiones una función API definida por POSIX para brindarle al programador acceso a cuál debería ser el comportamiento de un programa al recibir señales específicas del sistema operativo .
En los sistemas operativos tipo Unix , un medio de comunicación entre procesos es a través de señales. Cuando una unidad de ejecución ( proceso o subproceso ) recibe una señal del sistema operativo, debe reaccionar de alguna manera definida por la hoja de datos y el significado convencional de esta señal (es decir, volcando sus datos, deteniendo la ejecución, sincronizando algo...).
La sigaction()llamada al sistema se utiliza para declarar el comportamiento del programa en caso de que reciba una señal particular no reservada por el sistema. Esto se hace proporcionando junto con la llamada al sistema una estructura que contiene, entre otros, un puntero de función a la rutina de manejo de señales. Algunas señales predefinidas (como SIGKILL) tienen un comportamiento bloqueado que es manejado por el sistema y no puede ser anulado por dichas llamadas al sistema.
El estándar POSIX requiere que la estructura sigaction se defina como se muestra a continuación en el archivo de encabezado <signal.h> y debe contener al menos los siguientes campos:
estructura sigaction { void ( * sa_handler )( int ); /* dirección del manejador de señales */ sigset_t sa_mask ; /* señales adicionales para bloquear */ int sa_flags ; /* opciones de señal */ /* manejador de señales alternativo */ void ( * sa_sigaction )( int , siginfo_t * , void * ); }; Las implementaciones son libres de definir campos adicionales, posiblemente no portátiles. El miembro sa_handler especifica la dirección de una función que se llamará cuando el proceso reciba la señal. El número de señal se pasa como argumento entero a esta función. El miembro sa_mask especifica señales adicionales que se bloquearán durante la ejecución del controlador de señales. sa_mask debe inicializarse con sigemptyset(3). El miembro sa_flags especifica algunas banderas adicionales. sa_sigaction es un controlador de señales alternativo con un conjunto diferente de parámetros. Sólo se debe especificar un controlador de señales, ya sea sa_handler o sa_sigaction. Si se desea utilizar sa_sigaction en lugar de sa_handler, se debe configurar el indicador SA_SIGINFO.
La sigaction()función proporciona una interfaz para señales confiables en reemplazo de la signal()función no confiable. Los manejadores de señales instalados por la signal()interfaz se desinstalarán inmediatamente antes de la ejecución del manejador. Por lo tanto, los controladores permanentes deben reinstalarse mediante una llamada a signal()durante la ejecución del controlador, lo que provoca falta de confiabilidad en caso de que se reciba una señal del mismo tipo durante la ejecución del controlador pero antes de la reinstalación. Los controladores instalados por la sigaction()interfaz se pueden instalar de forma permanente y se puede bloquear un conjunto personalizado de señales durante la ejecución del controlador. Estas señales se desbloquearán inmediatamente después de la terminación normal del controlador (pero no en el caso de una terminación anormal, como una excepción de C++).
En C++, la try {/* ... */} catch {/* ... */}estructura de programación puede basarse (dependiendo de las plataformas de host) en la señalización. Para catchtraducir las señales en excepciones de C++, pueden ser necesarios modificadores de compilador especiales en algunas plataformas, como -fnon-call-exceptionsGCC y el compilador Intel C. [1]
#incluir <stdio.h> #incluir <stdlib.h> #incluir <cadena.h> #incluir <unistd.h> #incluir <sys/wait.h> #incluir <señal.h> #definir NUMCHLDS 10vacío sigchld_handler ( int , siginfo_t * , vacío * ); sig_atomic_t nextedchlds = 0 ; int principal ( int argc , char * argv []) { estructura sigaction acto ; memset ( & act , 0 , sizeof ( struct sigaction )); sigemptyset ( & act . sa_mask ); acto . sa_sigaction = sigchld_handler ; acto . sa_flags = SA_SIGINFO ; if ( -1 == sigaction ( SIGCHLD , & act , NULL )) { perror ( "sigaction()" ); salir ( EXIT_FAILURE ); } for ( int i = 0 ; i < NUMCHLDS ; i ++ ) { switch ( fork ()) { case 0 : /* * Implementaciones de sistemas operativos más antiguos que no se implementan correctamente * la estructura siginfo truncará el código de salida * enmascarándolo con 0xFF. */ devolver 1234567890 ; /* NOTREACHED */ case -1 : escribir ( STDERR_FILENO , "¡ERROR de bifurcación!" , 11 ); salir ( EXIT_FAILURE ); /* NO ALCANZADO */ predeterminado : printf ( "Niño creado \n " ); } } while ( 1 ) { if ( nexitechlds < NUMCHLDS ) pausa (); de lo contrario, salir ( EXIT_SUCCESS ); } /* NO ALCANZADO */ return 0 ; } void sigchld_handler ( int signo , siginfo_t * sinfo , void * contexto ) { proceso pid_t ; while (( proc = waitpid ( -1 , NULL , WNOHANG )) > 0 ) { /* señal del hilo principal */ nexitedchlds ++ ; /* * nota: ¡printf() no es seguro para señales! * no lo use en un manejador de señales. * si_code es el código de salida completo de 32 bits del niño (ver también waitid()). */ printf ( "sinfo->si_pid = %ld \n proc = %ld \n código de salida %d motivo de salida %d \n " , ( long ) sinfo -> si_pid , ( long ) proc , sinfo -> si_status , sinfo -> si_code ); } }