SEÑALES

Las señales son mecanismos para comunicarse y manipular procesos en Linux.

Una señal es un “aviso” que puede enviar un proceso a otro proceso. El sistema
operativo UNIX se encarga de que el proceso que recibe la señal la trate
inmediatamente. De hecho, termina la línea de código que este ejecutando y salta
a la función de tratamiento de señales adecuada. Cuando termina de ejecutar esa
función de tratamiento de señales, continua con la ejecución en la línea de código
donde lo había dibujado.

El sistema operativo envía señales en determinadas circunstancias. Por ejemplo, si

en el programa que se está ejecutando apretamos Ctrl + C, se está enviando una
señal de terminación al proceso. Este la trata inmediatamente y sale.

Hay varias docenas de señales diferentes, cada uno con un significado diferente.
Cada tipo de señal se especifica por su número de señal, pero en los programas,
usualmente se refiere a una señal por su nombre.

En Linux, estos son definidos en la dirección /usr/include/bits/signum.h. Para utilizar

estas funciones de debe incluir la librería <signal.h>.

Cuando un proceso recibe una señal, puede hacer una de varias cosas,
dependiendo de la disposición de la señal. Para cada señal, hay una disposición por
defecto, que determina qué sucede al proceso si el programa no especifica algún
otro comportamiento. Para la mayoría de los tipos de señal, un programa puede
especificar algún otro comportamiento, ya sea para ignorar la señal o para llamar a
una función especial de manejador de señal para responder a la señal. Si un
controlador de señal es utilizado, el programa actualmente en ejecución se pausa,
se ejecuta el controlador de señales y, cuando el controlador de señal regresa, el
programa se reanuda.

Todas las señales pueden ser ignoradas o bloqueadas, a excepción de SIGSTOP y

SIGKILL, que son imposibles de ignorar.

Algunas de las señales más importantes son:

Una limitación importante de las señales es que no tienen prioridades relativas, es

decir, si dos señales llegan al mismo tiempo a un proceso puede que sean tratadas
en cualquier orden, no se puede asegurar la prioridad de una en concreto. Otra
limitación es la imposibilidad de tratar múltiples señales iguales: si nos llegan 14
señales iguales al mismo tiempo, el proceso funcionará como si hubiera recibido
una sola señal.

Una de las funciones que contiene esta librería(signal.h) es la función pause(). Esta
función provoca que el proceso en cuestión “duerma” hasta que le llegue una señal.
Para capturar esa señal, el proceso deberá haber establecido un tratamiento de la
misma con la función signal(). Como se muestra en el ejemplo:

La función pause() no recibe ningún parámetro y retorna -1 cuando la llamada a la

función que captura la señal ha terminado.
La función signal() recibe dos parámetros, el número de señal que queremos
capturar, y un puntero a una función que se encargará de tratar la señal
especificada.

Inicialmente declaramos una función que va a recibir un entero como parámetro y

se encargará de capturar una señal ( trapper() ). Seguidamente capturamos todas
las señales de 1 a 64 haciendo 64 llamadas a signal(), pasando como primer
parámetro el número de la señal (i) y como segundo parámetro la función que se
hará cargo de dicha señal (trapper). Seguidamente el programa indica su PID
llamando a getpid() y espera a que le llegue una señal con la función pause(). El
programa esperará indefinidamente la llegada de esa señal, y cuando le enviemos
una (por ejemplo, pulsando Control+C), la función encargada de gestionarla (
trapper() ) será invocada. Lo primero que hace trapper() es volver a enlazar la señal
en cuestión a la función encargada de gestionarla, es decir, ella misma, y luego saca
por la salida estándar la señal recibida. Al terminal la ejecución de trapper(), se
vuelve al punto donde estábamos ( pause() ) y se continua:
 TERMINACION DE PROCESOS
Normalmente, un proceso termina de una de dos maneras. El programa ejecuta
llamadas a la función de salida o la función principal del programa. Cada proceso
tiene una salida código: un número que el proceso vuelve a su padre. El código de
salida es el argumento que se le pasa a la función de salida, o el valor devuelto
desde main.

Un proceso también puede terminar anormalmente, en respuesta a una señal. Por

ejemplo, el SIGBUS, SIGSEGV y SIGFPE mencionadas anteriormente hacen que
el proceso termine. Se utilizan otras señales para finalizar un proceso
explícitamente. La señal SIGINT se envía a un proceso cuando el usuario intenta
terminarlo tecleando Ctrl + C en su terminal. La señal SIGTERM es enviada por el
comando kill. La disposición por defecto para ambos es terminar el proceso.

En algunas situaciones, sin embargo, es deseable que el proceso padre espere

hasta que uno o más procesos de niño han terminado. Esto se puede hacer con la
familia de la espera del sistema estas funciones le permiten esperar a que finalice
un proceso y activar el proceso padre para recuperar información sobre la
terminación de su hijo. Hay cuatro diferentes llamadas de sistema en la familia de
espera; Usted puede elegir obtener un poco o mucha información sobre el proceso
que salió, y usted puede elegir si le interesa cuyo proceso secundario terminó.

WAIT

La función más simple de este tipo se llama simplemente esperar. Bloquea el

proceso de llamada hasta que uno de su hijo procesa las salidas (o se produce un
error). Devuelve un código de estado a través de un número entero puntero, desde
el que puede extraer información sobre cómo el proceso hijo salió, Por ejemplo, la
macro WEXITSTATUS extrae el código de salida del proceso secundario.
WEXITSTATUS

Extrae el código del proceso secundario

WIFEXITED

Determina desde el estado de salida de un proceso secundario, si ese proceso

salió normalmente o murió por una señal no controlada.

WTERMSIG

Extrae desde su estado de salida el numero de la señal por la cual murió

PROCESO ZOMBIE

Cuando un proceso padre termina, antes de que los procesos hijo terminen.