Temas

Hola todo el mundo,
me he estado machacando buscando información sobre señales por google, pero lo que encuentro esta siempre a medias y no me explica como usar las señales y sus funcione.

Basicamente lo que me gustaria saber es que hacen y como se usan ciertas señales en c.
La funciones que tengo que usar son:
1-sigqueue (no me queda claro para que sirve la variable sig).
2-sigaction ( he leido que se pueden enviar datos con esta, aunque tampoco entiendo como)
3-sigwaitinfo(entiendo que es para esperar la señal pero la variables nose como se usan).
4-sigemptyset ( Para que sirven los sets?)
5-sigaddset
6-sigprocmask (Para que sirven la mascaras?)

También he visto que para usar ciertas variables de las funciones se han de declarar estructuras he inicializar no se que cosas.
Llevo toda la tarde leyendo paginas con ejemplos raros que no hacen nada y no encuentro nada que tenga una función util o que explique como se usa de verdad cada función. Espero que alguien tenga un momento para explicarme como funcionan, aunque sean algunas, o por lo menos recomendarme alguna página donde tengan información sobre como se usan.

Para lo que necesito estas funciones es para comunicar dos procesos, el main con un hijo creado con fork y ejecutando execlp para ejecutar al hijo. Solo necesito enviar una variable al otro proceso y matarlo cuando transcurra un tiempo.

Espero que alguién me pueda echar un cable, si hace falta mas información estare pendiente del post así que diganme y lo cuelgo cuanto antes.

Un saludo

Hola todo el mundo, llevo rato intentado hacer una practica estupida pero soy incapaza de realizarla de forma que funcione correctamente.
Mi principal problema es que tengo que implementarlo para linux y la entrada de datos es por main, o sea usando ./sim.exe "datos".
Se me compila perfectamente, pero al quere ejecutarlo me tira de error de segmentación.

Sospecho que el problema es la validación de la variable tiempo, o su extracción de la cadena, pero ya no se como modificar el código para que corra correctamente.

Se que pido mucho ya que es un coñazo mirar el código de otra persona e intentar entenderlo, pero lo he blindado con comentarios espero que eso ayuda.

Si se os ocurre cualquier cosa, os lo agradecería mil veces.

Código (c) [Seleccionar] Expandir


/***********************************************
Nombre: Simulador
Descripción: Primera parte de la creación de un simulador
de sistema operativo RR.
Fecha:13-01-09
Autor:Bruno Kröller da Silva
************************************************/

// Cabecera de librerías
#include <stdio.h> // Uso de printf,...
#include <stdlib.h> //Uso de atoi,...
#include <unistd.h> //Uso de waitpid,...
#include <sys/types.h> // Uso de rand,...
#include <string.h> // Uso de

//VARIABLES GLOBALES
#define N_MAX 15
#define T_MAX 30
#define T_MIN 5
//FUNCIONES
int hijos(int n_maximo,int quantum,int tiempo);



// Función main que recive parametros de entrada
int main (int argc, char *argv[])
{

// Variables de entorno.
int resultado; // 0 error 1 correcto
int tiempo;
int n_maximo;
int quantum;

//Valores predefinidos de las variables.
n_maximo=5;
quantum=80;
resultado=0;
/*
Controlamos que el número de argumentos sea correcto, en caso contrario
no empezamos a ejecutar las funciones principales.
*/
if(argc==1 || argc==3 || argc==5 || argc>6)
{

printf("\t\n Error, el formato es n p m q t");


}
else
{
/*
Si entran dos argumentos, nombre + tiempo
*/


if(argc==2)
{
tiempo=atoi(argv[2]);

if(1<=tiempo<=120)
{
resultado=1;
}


}
/*
Si entran 4 argumentos, nombre+ numero+ p + tiempo o nombre+ quantum+ q + tiempo
*/
else if(argc==4)
{
tiempo=atoi(argv[4]);
if(*argv[2]=='p' && 1<=tiempo<=120)
{
n_maximo=atoi(argv[1]);
resultado=1;
}
if(*argv[2]=='q' && 1<=tiempo<=120)
{
quantum=atoi(argv[1]);
resultado=1;
}


}
/*
Si entran6argumentos, nombre+ numero+ p+ quantum+ q + tiempo
*/
else if(argc==6)
{
tiempo=atoi(argv[6]);

if(*argv[2]=='p' && *argv[4]=='q' && 1<=tiempo<=120)
{

n_maximo=atoi(argv[1]);
quantum=atoi(argv[3]);
resultado=1;

}

}
// SAlIDA DEl PROGRAMA
if(resultado==1)
{
printf("\t\n Simulador: ");
printf("\t\n       Numero maximo de programas: %d ",n_maximo);
printf("\t\n       Quantum : %d",quantum);
printf("\t\n       Tiempo de ejecución: %d ",tiempo);
}
else
{
printf("\t\n Error al introducir los parametros:");
printf("\t\n [numero_prog] [p] [quantum] [q] [tiempo] ");
}

}

return 0;
}
int hijos(int n_maximo,int quantum,int tiempo)
{
int error; // 1 correcto, 0 error.
pid_t pid_h; // Variable donde almacenaremos el pid del hijo
int numero;
int i;
int tiempo_max;
//INICIALIZACIÓN DE VALORES
i=0;
error=1;

/*
LANZAMIENTO DEL SISTEMA OPERATIVO
*/
//Creamos un hijo
pid_t fork();
//Pedimos que nos diga su pid
pid_h=getpid();
//Comprobamos que el hijo se ha creado
if(pid_h==-1)
{
error=0;
}
else
{
//Ejecutado por el padre
if(pid_h!=0)
{
waitpid(pid_h,NULL,0);
}
//Ejecutado por el hijo
else
{
//Ejecutar el S.O.

//Aquí termina el hijo
exit(0);
}
}
/*
LANZAMIENTO DE LA TEMPORIZACIÓN.
*/
//Creamos un hijo
pid_t fork();
//Pedimos que nos diga su pid
pid_h=getpid();
//Comprobamos que el hijo se ha creado
if(pid_h==-1)
{
error=0;
}
else
{
//Ejecutado por el padre
if(pid_h!=0)
{
waitpid(pid_h,NULL,0);
}
//Ejecutado por el hijo
else
{
sleep(tiempo);
printf("\t\n Temporizador: Finalizado el tiempo de simulación ");
//Aquí termina el hijo
exit(0);
}
}
/*
LANZAMIENTO DE LA TEMPORIZACIÓN.
*/
//CREARCIÓN DE LOS 10 HIJOS

while(i<10)
{

srand(time(0));
//Generamos un numero no mayor que N_MAX
//Le sumamos 1 para que empiece en 1.
numero=1+rand()%(N_MAX);
//Generamos el tiempo de espera de cada hijo.
//Crea números en un intervalo de 5 a 30.
tiempo_max=5+rand()%21;
//Tiempo de espera para crear el siguiente hijo.
sleep(numero);
//CREAR HIJO
pid_t fork();

}
pid_h=getpid();
if(pid_h==0)
{
sleep(tiempo_max);
printf("\n\t Simulador: Lanzando programa- Tiempo ejecución %d ",tiempo_max);
exit(0);
}
//El padre espera a que todos los hijos mueran.
wait();

return(error);
}



/*
CHULETA DE VARIABLES

Valores mínimos y máximos de:
 mínimo  máximo
Tiempo : 1 120
Quantum : 20 200
Programas : 1 5

numero esta entre [1,30]






*/




Hola todo el mundo, hace siglos que no me pasaba por aquí. En todo caso a sido en el primer foro que he pensado .

Bueno os cuento, mi duda es: si yo creo un hijo en linux con pid_t fork(); y este es creado dentro de un bucle, el también ejecutara el bucle o saldra de él??. La duda viene a raiz de que yo quiero que salga directamente o se me fastidia el invento .

Os copio el código que sera más comprensible supongo.

//DATOS ADICIONALES
N_MAX=15
numero es cada cuanto se genera un hijo
tiempo_max es lo que duerme el hijo

      while(i<10)
      {
         
         srand(time(0));
         //Generamos un numero no mayor que N_MAX
         //Le sumamos 1 para que empiece en 1.
         numero=1+rand()%(N_MAX);
         //Generamos el tiempo de espera de cada hijo.
         //Crea números en un intervalo de 5 a 30.
         tiempo_max=5+rand()%21;
      //Tiempo de espera para crear el siguiente hijo.
         sleep(numero);
         //CREAR HIJO
         pid_t fork(); <-Creo el hijo, va a salir o va a comprobar el while?????
         
      }
      pid_h=getpid();
      if(pid_h==0)      //Solo si es hijo.
      {
         sleep(tiempo_max);
         printf("\n\t Simulador: Lanzando programa- Tiempo ejecución %d ",tiempo_max);
                       exit(0);
      }
      //El padre espera a que todos los hijos mueran.
      wait();

Cualquier cosa que se os ocurra sera de gran ayuda.

Un saludo