Documenti di Didattica
Documenti di Professioni
Documenti di Cultura
SESIÓN 08:
Señales
I
OBJETIVOS
II
TEMAS A TRATAR
Señales
Captura
Envio
Alarmas
Ejercicios
III
MARCO TEORICO
Las señales
Cada proceso en Unix puede reaccionar a las señales que se le envían. Existen 31 señales
diferentes. Para cada una de estas señales el proceso puede redefinir el comportamiento
predeterminado, excepto para dos de ellas: la señal número 9 (KILL), y la señal número
19 (STOP).
La señal 9 mata un proceso, sin darle tiempo de terminar correctamente. Esta es la señal
que deberá enviar a un proceso cuando este está trabado o exhibe otros problemas. Está
disponible una lista completa de las señales usando el comando kill -l.
Una señal es un evento que debe ser procesado y que puede interrumpir el flujo normal
de un programa.
En nuestros programas utilizaremos la subrutina signal, la cual asocia una de las tres
acciones antes mencionadas con una señal.
Sintaxis:
#include <signal.h>
void (*signal (senial, accion))( )
int senial;
void (*accion )( )
Parámetros:
senial: número de señal, excepto SIGKILL.
accion: Puntero a la rutina asociada con la señal o uno de los siguientes valores:
o SIG_DFL: acción por defecto para dicha señal.
o SIG_IGN: para ignorar la señal .
Devuelve:
Valor de la acción anteriormente asociada; -1, en caso de error.
Supongamos que quiere matar un proceso del cual usted conoce el nombre del comando.
En vez de encontrar el número de proceso usando ps, puede matar el proceso
directamente de la siguiente forma:
$ killall -9 netscape
Pase lo que pase, usted sólo matará sus propios procesos (a menos que sea root), por lo
que no debe preocuparse acerca de los procesos de los demás usuarios, incluso si tiene el
mismo nombre, ellos no serán afectados.
Función kill()
La función kill() incluida en un programa va a permitir que un proceso pueda enviar
señales a otro proceso. Admite dos parámetros:
pid_t que es el identificador del proceso al cual vamos a enviar una
determinada señal.
int indica el literal o el número de la señal a enviar.
Alarmas
Una alarma es una señal que es activada por los temporizadores del sistema a través de
SIGALRM.
IV
ACTIVIDADES
Escriba los siguientes programas, compílelos y luego ejecútelos y observe su
comportamiento
01. Uso de la señal CTRL+C y la señal alarma
#include <signal.h>
#include <stdlib.h>
#include <stdio.h>
int ncortes=0;
int bucle=1;
void alarma();
void cortar();
int main() {
signal (SIGINT, cortar);
signal (SIGALRM, alarma);
printf(“Ejemplo de signal.\n”);
printf(“Pulsa varias veces CTRL C durante 15 segundo.\n”);
alarm(15);
while(bucle);
signal (SIGINT,SIG_IGN);
printf(“Has intentado cortar %d veces.\n”,ncortes);
printf(“Hasta luego…..\n”);
exit(0);
}
void cortar( ) {
signal (SIGINT, SIG_IGN);
printf("Has pulsado CTRL C \n");
ncortes++;
signal (SIGINT, cortar);
}
void alarma ( ) {
signal (SIGALRM, SIG_IGN);
bucle=0;
printf("!Alarma! \n");
}
02. Comunicación entre procesos por medio del envío de señales: función kill
#include <sys/types.h>
#include <signal.h>
#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>
main()
{
pid_t idProceso;
idProceso = fork();
if (idProceso==-1) {
perror("No se puede lanzar proceso”);
exit(-1);
}
if (idProceso == 0) {
signal (SIGUSR1, tratasenial);
while (1)
pause();
}
if (idProceso > 0) {
while (1) {
sleep(1);
kill (idProceso, SIGUSR1);
}
}
}
La función pause() hace que el proceso quede suspendido hasta que llegue una señal.
main( )
{
if (signal (SIGINT, manejador) == SIG_ERR )
perror (“No se puede cambiar signal”);
while (1)
pause ();
}
V
EJERCICIOS
01. Escriba un programa que cree un programa hijo y espere 4 segundos. Si después de
ese tiempo el hijo aún no ha terminado, el programa lo mata enviándole una señal.
Antes de resolver este ejercicio intente resolver la siguiente pregunta, ¿sería posible
saber si un proceso hijo ha terminado enviando una señal 0 mediante kill (como
hemos hecho en el ejercicio 2)?. Piense que, aunque el proceso haya terminado, si el
proceso padre sigue activo y no ha llamado a wait o a waitpid el proceso hijo sigue
existiendo en el sistema.
02. Escriba un programa que haga uso de las alarmas para mostrar el valor de un
contador cada 2 segundos. El contador se incrementará en uno cada vez que se
muestre su valor. Por ejemplo, si este programa estuviera en ejecución durante 11
segundos, su resultado sería el que se muestra a continuación.
$ ./vivo
Contador: 0
Contador: 1
Contador: 2
Contador: 3
Contador: 4
^C
$_
03. Una entidad bancaria almacena todas las operaciones de transferencias de fondos de
una cuenta a otra en un único fichero maestro. Las operaciones de transferencia se
reciben de varios ordenadores locales con capacidad de procesamiento autónomo.
Como pasa siempre en la vida real, el sistema no es perfecto y hay veces que los
ordenadores locales no pueden acceder al fichero maestro: fallos en la red, alta carga
de trabajo, mantenimiento del servidor, etc. Para la entidad es impensable que se
detengan las transacciones o que se pierda información de alguna de ellas. La
solución adoptada consiste en aprovechar las capacidades de procesamiento de los
ordenadores locales. Así, si un ordenador local no puede acceder al fichero maestro,
almacenará la transacción en un fichero local. Por las noches, un proceso recolector
sondea los ordenadores locales y añade al fichero maestro todas las operaciones
pendientes.
En este ejercicio vamos a implementar el código del proceso local cuya misión
enviar al recolector todas las operaciones almacenadas en su máquina. Su
funcionamiento se describe a continuación:
1. El proceso local esperará hasta recibir la señal USR1.
2. Después, el proceso local leerá el archivo de operaciones (llamado ‘operaciones’).
Éste es un archivo binario que contiene una estructura de tipo s_operacion por
cada operación almacenada en el ordenador local. Cada operación la enviará a la
salida estándar y leerá otra operación del proceso recolector. Si el identificador
de la operación leída es distinto del identificador de la operación que acaba de
enviar mostrará un mensaje de error de verificación.
3. Cuando el proceso local haya enviado todas las operaciones, terminará la
transmisión enviando una nueva operación con identificador.
VI
CUESTIONARIO
VII
BIBLIOGRAFIA Y REFERENCIAS
Blanco, V., “Linux Instalación, Administración y uso del Sistema”, Ed. Ra-Ma,
México, 2001.
http://users.exa.unicen.edu.ar/~hcurti/linux/index.html