Señal
Una señal es un evento que se genera para notificar a un proceso o hilo que ha llegado alguna situación importante. Cuando un proceso o subproceso ha recibido una señal, el proceso o subproceso detendrá lo que está haciendo y tomará alguna acción. La señal puede ser útil para la comunicación entre procesos.
Señales estándar
Las señales se definen en el archivo de encabezado señal.h como una macro constante. El nombre de la señal ha comenzado con un SIG y seguido de una breve descripción de la señal. Entonces, cada señal tiene un valor numérico único. Su programa siempre debe usar el nombre de las señales, no el número de señales. La razón es que el número de señal puede diferir según el sistema, pero el significado de los nombres será estándar.
La macro NSIG es el número total de señales definidas. El valor de NSIG es uno mayor que el número total de señales definidas (todos los números de señales se asignan consecutivamente).
A continuación se muestran las señales estándar:
| Nombre de la señal | Descripción |
| SIGHUP | Cuelgue el proceso. La señal SIGHUP se usa para informar la desconexión del terminal del usuario, posiblemente porque una conexión remota se pierde o se cuelga. |
| SIGINT | Interrumpa el proceso. Cuando el usuario escribe el carácter INTR (normalmente Ctrl + C), se envía la señal SIGINT. |
| SIGQUIT | Sal del proceso. Cuando el usuario escribe el carácter SALIR (normalmente Ctrl + ), se envía la señal SIGQUIT. |
| SELLO | Instrucción ilegal. Cuando se intenta ejecutar una instrucción basura o privilegiada, se genera la señal SIGILL. Además, SIGILL se puede generar cuando la pila se desborda o cuando el sistema tiene problemas para ejecutar un manejador de señales. |
| SIGTRAP | Trampa de rastreo. Una instrucción de punto de interrupción y otra instrucción de captura generarán la señal SIGTRAP. El depurador usa esta señal. |
| SIGABRT | Abortar. La señal SIGABRT se genera cuando se llama a la función abort (). Esta señal indica un error que es detectado por el propio programa y reportado por la llamada a la función abort (). |
| SIGFPE | Excepción de coma flotante. Cuando ocurre un error aritmético fatal, se genera la señal SIGFPE. |
| SIGUSR1 y SIGUSR2 | Las señales SIGUSR1 y SIGUSR2 se pueden utilizar como desee. Es útil escribir un manejador de señales para ellos en el programa que recibe la señal para una comunicación simple entre procesos. |
Acción predeterminada de las señales
Cada señal tiene una acción predeterminada, una de las siguientes:
Término: El proceso terminará.
Centro: El proceso terminará y producirá un archivo de volcado del núcleo.
Ign: El proceso ignorará la señal.
Parada: El proceso se detendrá.
Cuenta: El proceso continuará desde que se detenga.
La acción predeterminada se puede cambiar utilizando la función de controlador. La acción predeterminada de algunas señales no se puede cambiar. SIGKILL y SIGABRT La acción predeterminada de la señal no se puede cambiar ni ignorar.
Manejo de señales
Si un proceso recibe una señal, el proceso tiene una opción de acción para ese tipo de señal. El proceso puede ignorar la señal, puede especificar una función de controlador o aceptar la acción predeterminada para ese tipo de señal.
- Si se ignora la acción especificada para la señal, la señal se descarta inmediatamente.
- El programa puede registrar una función de controlador usando una función como señal o sigaction . A esto se le llama un manejador que capta la señal.
- Si la señal no se ha manejado ni ignorado, se lleva a cabo su acción predeterminada.
Podemos manejar la señal usando señal o sigaction función. Aqui vemos como el mas simple señal() La función se utiliza para manejar señales.
En tseñal() (En tfirmar, vacío (*función)(En t))los señal() llamará al función función si el proceso recibe una señal firmar . los señal() devuelve un puntero a la función función si tiene éxito o devuelve un error a errno y -1 en caso contrario.
los función puntero puede tener tres valores:
- SIG_DFL : Es un puntero a la función predeterminada del sistema SIG_DFL () , declarado en h archivo de cabecera. Se utiliza para realizar una acción predeterminada de la señal.
- SIG_IGN : Es un puntero a la función de ignorar del sistema. SIG_IGN () , declarado en h archivo de cabecera.
- Puntero de función de controlador definido por el usuario : El tipo de función del controlador definido por el usuario es vacío (*) (int) , significa que el tipo de retorno es nulo y un argumento de tipo int.
Ejemplo de controlador de señal básico
#incluir#incluir
#incluir
vacíosig_handler(En tfirmar){
// El tipo de retorno de la función del controlador debe ser nulo
printf (' orteFunción de controlador interno orte');
}
En tprincipal(){
señal(SIGINT,sig_handler); // Registrar manejador de señales
por(En tI=1;;I++){ //Bucle infinito
printf ('% d: Dentro de la función principal orte',I);
dormir(1); // Retraso de 1 segundo
}
regreso 0;
}
En la captura de pantalla de la salida de Example1.c, podemos ver que en la función principal se está ejecutando un bucle infinito. Cuando el usuario escribe Ctrl + C, se detiene la ejecución de la función principal y se invoca la función de controlador de la señal. Una vez completada la función de controlador, se reanudó la ejecución de la función principal. Cuando el usuario escribe Ctrl + , el proceso se cierra.
Ejemplo de ignorar señales
#incluir#incluir
#incluir
En tprincipal(){
señal(SIGINT,SIG_IGN); // Registrar manejador de señales para ignorar la señal
por(En tI=1;;I++){ //Bucle infinito
printf ('% d: Dentro de la función principal orte',I);
dormir(1); // Retraso de 1 segundo
}
regreso 0;
}
Aquí la función del controlador se registra en SIG_IGN () función para ignorar la acción de la señal. Entonces, cuando el usuario escribió Ctrl + C, SIGINT se está generando una señal, pero la acción se ignora.
Volver a registrar el ejemplo del controlador de señales
#incluir#incluir
#incluir
vacíosig_handler(En tfirmar){
printf (' orteFunción de controlador interno orte');
señal(SIGINT,SIG_DFL); // Registre el controlador de señales para la acción predeterminada
}
En tprincipal(){
señal(SIGINT,sig_handler); // Registrar manejador de señales
por(En tI=1;;I++){ //Bucle infinito
printf ('% d: Dentro de la función principal orte',I);
dormir(1); // Retraso de 1 segundo
}
regreso 0;
}
En la captura de pantalla de la salida de Example3.c, podemos ver que cuando el usuario escribió Ctrl + C por primera vez, se invocó la función del controlador. En la función de manejador, el manejador de señales se vuelve a registrar en SIG_DFL para la acción predeterminada de la señal. Cuando el usuario escribió Ctrl + C por segunda vez, el proceso finaliza, que es la acción predeterminada de SIGINT señal.
Envío de señales:
Un proceso también puede enviarse señales explícitamente a sí mismo oa otro proceso. Las funciones raise () y kill () se pueden usar para enviar señales. Ambas funciones se declaran en el archivo de encabezado signal.h.
En t aumentar (En tfirmar)La función raise () utilizada para enviar señal firmar al proceso de llamada (en sí mismo). Devuelve cero si tiene éxito y un valor distinto de cero si falla.
En tmatar(pid_t pid, En tfirmar)La función de matar utilizada para enviar una señal. firmar a un proceso o grupo de procesos especificado por pid .
Ejemplo de controlador de señal SIGUSR1
#incluir#incluir
vacíosig_handler(En tfirmar){
printf ('Función de controlador interno orte');
}
En tprincipal(){
señal(SIGUSR1,sig_handler); // Registrar manejador de señales
printf ('Dentro de la función principal orte');
aumentar (SIGUSR1);
printf ('Dentro de la función principal orte');
regreso 0;
}
Aquí, el proceso se envía la señal SIGUSR1 a sí mismo usando la función raise ().
Programa de ejemplo Raise with Kill
#incluir#incluir
#incluir
vacíosig_handler(En tfirmar){
printf ('Función de controlador interno orte');
}
En tprincipal(){
pid_t pid;
señal(SIGUSR1,sig_handler); // Registrar manejador de señales
printf ('Dentro de la función principal orte');
pid=getpid(); // ID de proceso de sí mismo
matar(pid,SIGUSR1); // Envía SIGUSR1 a sí mismo
printf ('Dentro de la función principal orte');
regreso 0;
}
Aquí, el proceso envía SIGUSR1 señal a sí mismo usando matar() función. getpid () se utiliza para obtener el ID de proceso de sí mismo.
En el siguiente ejemplo veremos cómo los procesos padre e hijo se comunican (Comunicación entre procesos) usando matar() y función de señal.
Comunicación entre padres e hijos con señales
#incluir#incluir
#incluir
#incluir
vacíosig_handler_parent(En tfirmar){
printf ('Padre: recibió una señal de respuesta del niño orte');
}
vacíosig_handler_child(En tfirmar){
printf ('Niño: recibió una señal de los padres orte');
dormir(1);
matar(getppid(),SIGUSR1);
}
En tprincipal(){
pid_t pid;
si((pid=tenedor())<0){
printf ('Error de horquilla orte');
Salida (1);
}
/ * Proceso hijo * /
demás si(pid==0){
señal(SIGUSR1,sig_handler_child); // Registrar manejador de señales
printf ('Niño: esperando la señal orte');
pausa();
}
/ * Proceso principal * /
demás{
señal(SIGUSR1,sig_handler_parent); // Registrar manejador de señales
dormir(1);
printf ('Padre: enviando señal al niño orte');
matar(pid,SIGUSR1);
printf (Padre: esperando respuesta orte');
pausa();
}
regreso 0;
}
Aquí, tenedor() La función crea un proceso hijo y devuelve cero al proceso hijo y la ID del proceso hijo al proceso padre. Entonces, pid se ha verificado para decidir el proceso padre e hijo. En el proceso padre, se duerme durante 1 segundo para que el proceso hijo pueda registrar la función del controlador de señales y esperar la señal del padre. Después de 1 segundo proceso padre enviar SIGUSR1 señal al proceso del niño y espere la señal de respuesta del niño. En el proceso hijo, primero está esperando la señal del padre y cuando se recibe la señal, se invoca la función de controlador. Desde la función del controlador, el proceso hijo envía otro SIGUSR1 señal a los padres. Aquí getppid () La función se utiliza para obtener la identificación del proceso principal.
Conclusión
Signal en Linux es un gran tema. En este artículo hemos visto cómo manejar la señal desde lo más básico, y también obtener un conocimiento de cómo se genera la señal, cómo un proceso puede enviarse una señal a sí mismo y a otros procesos, cómo la señal se puede utilizar para la comunicación entre procesos.