signal: SIGALRM

[GagleKas]

Holas.

La pregunta es sencilla, a ver si alguien me lo confirma.

Supongamos que quiero hacer un contador un poco especial. Es un contador que inicialmente vale 0 y que cada vez que se recibe un signal SIGALRM incrementa en 1 el valor y lo pinta por pantalla.

La pregunta es: Es obligatorio tener como variable global el contador o hay alguna otra solucion sin usar variables globales?

Este codigo implementa lo que he dicho pero usando una variable global.

Código C:

#include <signal.h>
#include <sys/time.h>
#include <stdio.h>
 
int i = 0;
 
void intSIGALRM (){
        i++;
        printf ("%d\n", i);
        signal (SIGALRM, intSIGALRM);
        alarm (1);
}
 
int main (){
        signal (SIGALRM, intSIGALRM);
        alarm (1);
        while (1);
 
        return 0;
}
 

Gracias.

[Eternal Idol]

¿TLS? De cualquier manera deberias proteger el recurso (esa variable en este caso) para que se accediera de manera atomica al mismo.

[GagleKas]

Quizas no te entendi, pero es unicamente una variable global que se usa unicamente en un proceso, es decir, no es memoria compartida por mas procesos y por tanto no hace falta protegerla para que se ejecute en exclusion mutua.

Y sobre lo del thread, pues veo que la cosa se complica demasiado para lo que quiero hacer.

No se puede pasarle parametros a la funcion que se llama con el alarm, no?

[Eternal Idol]

Lo siento, estoy acostumbrado al Kernel y recibir eventos de cualquier hilo de cualquier proceso en cualquier momento, en tu caso el tratamiento de i ocurre cuando el manejador de SIGALRM es el por defecto en un proceso con un solo hilo, entonces no puede haber problemas de sincronizacion.

No, solo podes especificar el numero de señal y su manejador.

[GagleKas]

Gracias, como siempre dando soluciones :)

Mi aplicacion es un servidor que atiende a clientes. Cada cierto tiempo debe enviar tramas de timeout al cliente y si este no le responde entonces corta la conexion y cierra el socket. Este "cada cierto tiempo" lo implemento con un sigalrm de la misma forma que he hecho el contador anterior.

El problema esta que dentro de la funcion que es llamada por sigalrm no dispongo de la variable socket y, por tanto, no puedo escribir en el. Lo unico que se me ocurre es poner la variable socket (la que se crea con la funcion socket ()) como global, entonces si que podria escribir en el socket.

[Eternal Idol]

¿Sockets bloqueantes en una aplicacion de un solo hilo? ¿Estamos hablando de TCP o UDP? Si es TCP cada cliente tiene un socket ... que devuelve la funcion accept. ¿Como distinguirias a cada cliente en ese caso?

La verdad es que *NIX no es mi campo pero me parece que estas tratando de usar algo que no esta preparado para esto (multiples timers - uno por cada cliente - ejecutandose a la vez):

http://users.evtek.fi/~tk/rtp/signals-programming.html

[GagleKas]

Iniciado por Eternal Idol

La verdad es que *NIX no es mi campo pero me parece que estas tratando de usar algo que no esta preparado para esto (multiples timers - uno por cada cliente - ejecutandose a la vez):

http://users.evtek.fi/~tk/rtp/signals-programming.html

Pues si, eso es justo lo que quiero hacer. Una vez el cliente se conecta al servidor , el servidor crea un hijo para atender al cliente. Dentro de este hijo es donde quiero enviar la trama timeout cada cierto tiempo usando el signal alrm.

En procesos diferentes (hijos del server que atienden los clientes) se pueden usar las mismas interrupciones, no?

Voy a probar esto porque ahora me has hecho dudar.

[Eternal Idol]

Entonces si, no deberia haber problema si cada proceso del servidor solo tiene un cliente.

[GagleKas]

El siguiente codigo es solo un ejemplo para ver que si que se puede usar la misma interrupcion con diferentes procesos, porque al hacer el fork se crea una copia identica (menos el pid), por lo que las variables globales e interrupciones no generan problemas.

No he hecho 2 contadores con un unico SIGALRM porque para ver el resultado por pantalla tendria que modificar ciertas cosas que podrian causar confusion con el objetivo del programa.

Código C:

#include <signal.h>
#include <stdio.h>
 
int n = 0;
 
void intSIGUSR1 (){
        printf ("%d\n", n);
}
 
int main (){
        int pidHijo1, pidHijo2;
 
        pidHijo1 = fork ();
 
        if (pidHijo1 == 0){
                //Hijo
                signal (SIGUSR1, intSIGUSR1);
                n = 1;
                kill (getpid (), SIGUSR1);
 
                exit (0);
        }else if (pidHijo1 < 0){
                //Error
                exit (-1);
        }
 
        pidHijo2 = fork ();
 
        if (pidHijo2 == 0){
                //Hijo
                signal (SIGUSR1, intSIGUSR1);
                n = 2;
                kill (getpid (), SIGUSR1);
 
                exit (0);
        }else if (pidHijo2 > 0){
                //Padre
                waitpid (pidHijo1, NULL, 0);
                waitpid (pidHijo2, NULL, 0);
        }else{
                //Error
                exit (-1);
        }
 
        return 0;
}
 

Este programa solo muestra 1 y 2 por pantalla, o 2 y 1, si el scheduler asi lo decide.

En lugar de la variable global n, ahi pondria la variable del socket.

Primero haria el accept (). Una vez llega un cliente esta funcion me devuelve el fd del socket. Este fd lo copio en la variable global y genero un hijo para atender al cliente. Listo, el hijo tendra el fd del socket en la variable global con el que se comunicara con el cliente y a la vez se podra usar para enviar timeouts.

Si llegan mas conexiones de clientes pues no pasa nada. De la misma forma se guarda en la variable global el fd del socket creado con accept () y se crea el hijo, el cual tendra en esta variable global el fd del socket con el que se comunicara con el cliente.

Puede que al principio se piense que se esta usando memoria compartida (la variable global) entre proceso padre e hijo, pero no es asi. El siguiente codigo lo deja mas claro:

Código C:

#include <stdio.h>
 
int main (){
        int x = 0, pidHijo;
 
        pidHijo = fork ();
 
        if (pidHijo == 0){
                //Hijo
                printf ("Hijo: %d\n", x); //muestra 0 por pantalla
                exit (0);
        }else if (pidHijo > 0){
                //Padre
                x = 1;
                printf ("Padre: %d\n", x); //muestra 1 por pantalla
                waitpid (pidHijo, NULL, 0);
        }else{
                //Error
                return -1;
        }
 
        return 0;
}
 

Ahora en lugar de la x pon la variable global. La idea es la misma.




Bueno, espero que quien tenga el mismo problema que yo y use el google, le salga este post. xDDD


Saludos.