www.es-minix.org

[efutch]

El enunciado del miniproyecto #1 ya está disponible en el Skydrive del curso. La fecha de entrega es el 31/Agosto/2008, a las 11:59PM en este foro.

Saludos,

efutch

[guillermo]

La primera parte del proyecto realiza un fork para imprimir dentro de un while cuantos segundos quedan para responder la pregunta mientras que el otro proceso espera la respuesta del usuario para terminar. Es un simple fork con una sincronizacion al final que puede suceder si el usuario ingresa una respuesta o si se acaba el tiempo. El tiempo se mide usando la funcion sleep por 5 segundos y luego imprimiendo el mensaje correspondiente en la pantalla para luego seguir con el loop hasta cumplir
con el tiempo establecido.

La segunda parte del proyecto es muy similar al ejemplo, siempre tenemos un manejador para la señal SIGINT para que al presionar DEL se pregunte al usuario si se quiere terminar el programa pero ademas agregamos el manejador de la señal SIGALRM que es la señal 14 producida por el sistema luego de hacer la llamada a alarm (tambien se puede enviar directamente al proceso haciendo un kill -14 pid_proceso). Para probar el manejador podemos realizar la prueba con otra sesion en minix (alt+f2) y enviándole al proceso una señal 14 y veremos en pantalla la impresion de el tiempo transucurrido. La medicion del tiempo que ha pasado se realiza usando una variable de tipo time_t definido en time.h que se guarda al iniciar el programa y luego cada vez que se encuentre una señal SIGALRM se pide al sistema la hora usando la funcion time() y se le resta el tiempo al iniciar el programa para tener la cantidad de segundos transcurridos.

===========
Implementacion
===========
La primera parte no tiene nada complicado solo es el uso del fork y de la funcion kill que recibe de parametros el numero de la señal que queremos enviar y el pid del proceso al cual se la enviamos para terminar el otro proceso si se termina con uno de ellos ya que se puede ingresar una respuesta o se puede terminar el tiempo.
Para la segunda parte solo hace falta crear un nuevo manejador de señales especificamente para la señal SIGALRM que tambien debe ignorar la señal una vez dentro de la funcion mandandole a la funcion signal como parámetro el numero de la señal asi como SIG_IGN, y al final de la funcion restableciendo el manejador como la funcion misma para que si se da de nuevo la señal SIGALRM, se le vuelva a llamar.
**Ambos programas funcionan y fueron probados varias veces la unica forma de hacer que no realicen su funcion del todo correcta es dando DEL en la segunda parte y dandole 'n' y luego dandole DEL de nuevo en cuyo caso puede que no salga del programa incluso si le enviamos como respuesta una 's', problema que no he podido resolver incluso en el ejemplo de la descripcion del mini proyecto
Para la segunda parte las pruebas se realizaron mandado la señal 14 usando un kill desde otra sesion en minix.

===========
INVESTIGACION
===========
fork() crea una copia del proceso y retorna el pid del hijo y al hijo le da un pid de cero, lo que puede usarse para diferenciar los dos procesos
sleep() recibe un parametro que es el numero de segundos que pasaran antes que el proceso siga ejecuntandose
getpid() retorna el pid del proceso que llama a la funcion
kill() recibe primero el pid del proceso al que le queremos enviar una señal y luego la señal que le queremos enviar

Los comandos...
ps nos muestra los procesos del usuario que estan corriendo su pid y el nombre del programa
top nos muestra los procesos que consumen mas CPU y el porcentaje del consumo del mismo
kill recibe como parametro -señal, donde la señal es lo que deseamos enviar y luego el pid del proceso

======
PARTE 1
======

[jensenzelaya]

Descripcion, Funcionamiento, Status e Implementacion de los Programas

El primer programa utiliza la función fork() para poder crear un proceso hijo con pid igual a cero. Asi en este punto tenemos dos procesos pesados creados, en el cual uno controla el ingreso de la respuesta del usuario, mientras que el otro proceso controla el tiempo de respuesta. Este proceso imprime un mensaje cada 5 segundos, para recordar al usuario que solo tiene 30 segundos para contestar. Esto se logra con la función sleep(int), donde el int especificado es el tiempo que el proceso se detiene, en este caso 5 segundos. El programa terminara el cualquiera de dos casos, el primero que el usuario conteste la pregunta antes de 30 segundos y presione Enter, o que hayan pasado los 30 segundos de respuesta del usuario. En dados casos se utiliza la función kill(pid,sig) para terminar el proceso especificado por pid y la señal sig que en este caso es SIGKILL que corresponde a un numero se señal 9.

El segundo programa puede recibir dos señales del usuario, SIGINT y SIGALRM, las cuales corresponden a un 2 y 14 respectivamente según sigaction en man(2). Las señales son controladas por dos signalhandlers, intHandler(int) y alarmHandler(int), donde int especifica el número de la señal. La primera señal, SIGINT, corresponde a una interrupción del proceso el cual se ejecuta al presionar la tecla Delete, en cuyo caso pregunta si se desea terminar la aplicación. La segunda señal se puede ejecutar desde otra sesión de minix utilizando el comando ps para ver el pid del proceso y luego utilizar el comando kill –n pid en man(1), donde n es el numero de la senal y pid es el id del proceso, para enviar una senal 14 al proceso, en lo que el programa imprimirá el tiempo en segundos que la aplicación ha estado en ejecución; dichos mensajes se imprimirán en la sesión donde se inicio la aplicación. Esto se logra utilizando la función time() que devuelve un valor de tipo time_t, por lo que se especifica una variable tiempoInicio de tipo time_t, luego solo se resta el valor actual con el tiempo de inicio.

Ambos programas han sido ejecutados exitosamente, con un único inconveniente al compilar el primer programa, ya que da un warning al utilizar la función kill(pid,sig), pero el mismo puede ser ignorado, y el programa funciona normalmente.


Parte 1

[JoseRS]

=========
parte uno (1)
=========
#define _POSIX-SOURCE
#include <stdio.h>
#include <sys/types.h>
#include <unistd.h>
#include <stdlib.h>
#include <signal.h>

int main(void){
int pid;
int padrePID;
char answer[2048];
padrePID = getpid();
pid = fork();

if (pid < 0)
{
printf("Cannot fork()\n");
exit(1);
}
if (pid == 0){
int segundos;
segundos=30;
do{
sleep(5);
segundos=segundos-5;
printf("\n\nOye, solamente tienes solamente %d segundos... para contestar ok?\n",segundos);
}while(segundos>0);
printf("Bueno... tu tiempo ha terminado, suerte. \n\n");
kill(padrePID,SIGKILL);
}
else
{

printf("\nExplicame en pocas palabras, que es un proceso concurrente.\n");
gets(answer);
kill(pid,SIGKILL);
}
printf("\nOK: ZERO KILLS... ok bye\n");
}


=========
parte dos (2)
=========
#define _POSIX_SOURCE
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <signal.h>
#include <time.h>

void inthandler(int);
void ALRMhandler(int);
time_t start;
time_t present;
void main(void){
start=time(NULL);
printf("Press DEL (Supr) to invoke handler\n");
printf("Send a signal SIGALRM (14) to view the elapsed time\n");
signal(SIGINT,inthandler);
signal(SIGALRM,ALRMhandler);
while(1)
pause();
}
void ALRMhandler(int sig){
signal(sig,SIG_IGN);
present=time(NULL);
present=present-start;
printf("\n%d seconds is the elapsed time\n",(int)present);
signal(SIGALRM,ALRMhandler);
}
void inthandler(int sig){
char c;
signal(sig,SIG_IGN);
printf("End thy process? [y/n]");
c=getchar();
if (c=='y'||c=='Y')
exit(0);
else
signal(SIGINT,inthandler);
}


=========
primera parte
=========
Para la primera parte, el programa de pregunta y tiempo, se hace un fork() y asi obtener dos procesos, padre e hijo. El proceso que hace la pregunta es el proceso hijo, siendo el proceso cronometro el padre que lleva el tiempo disponible para contestar la pregunta. El proceso cronometro da el aviso de cuanto tiempo disponible tiene el usuario para contestar la pregunta, este aviso es cada 5 segundos. el tiempo limite son 30 segundo que al transcurrir ambos procesos terminan.
Para terminar ambos procesos utilice la funcion kill(), ambos procesos terminan ya sea por recibir la respuesta, que se recibe con la funcion gets(), o al terminar los 30 segundos. Para hacer la cuenta del tiempo dando el aviso cada 5 segundos utilice la funcion sleep().
Para desarrollar este programa use la herramienta vi de minix y le puse prgntn.c. Fue algo interesante el compilar este programa, me gui con el manual de gcc, y al final escribi cc prgntn.c -o prgntn, de modo que al final la corrida sea ./prgntn.

=========
segunda parte
=========

En esta segunda parte asimismo se hace un fork() para un padre e hijo, donde el padre es el loop infinito y que espera la SIGALRM, y el hijo que espera DEL, la senal. La funcion importante es signal(), como se menciono, este programa esta en un loop infinito y solo se detiene contestando y o Y en la pregunta de terminar que hace el hijo que aparece cuando se preciona DEL, al recibir el DEL el padre despliega los segundos trascurrido. Al contestar esta pregunta el hijo envia un kill(pid,SIGTERM) que termina con el padre.

==========
Observaciones
==========

En la primera parte, todo funciono muy bien, mas que el investigar un poco el uso de kill() y fork(). Del mismo modo hubo que leer un poco sobre de las senales. Sin embargo en la segunda parte no podia desplegar los segundos transcurridos. Al recibir el DEL despliega la pregunta pero no el tiempo transcurrido, ademas doy 'n' en la respuesta despues doy DEL y no aparece la pregunta ni el tiempo transcurrido. Doy ENTER y de nuevo DEL y me aparece dos veces seguidas la pregunta.

[adtabora]

Parte 1

[Miriam Rivera]

PARTE 1

Código fuente

#include <stdio.h>
#include <sys/types.h>
#include <unistd.h>
#include <stdlib.h>

Int main(void){

int pid;
int ParentPID;
char response[2048];

int timer;

ParentPID = getpid();
pid = fork();

if (pid < 0) {
printf("No puedo hacer fork()\n");
exit(1);
}
if (pid == 0) {
/* Proceso hijo: Proceso pregunton*/
printf("Explique en pocas palabras la funcionalidad de un proceso concurrente\n\n");
gets(response);
kill(ParentPID, 9);
/* exit */
exit(0);
}
else {
/* Proceso padre : Proceso Cronometro */
timer = 30;
printf("Tiene 30 segundos para dar su respuesta. Gracias !\n\n");
do{
sleep(5);
timer = timer - 5;
printf("Tiene %d segundos para responder!!!\n", timer);
}while (cont > 0);
printf("Buen Intento!! Su tiempo ha terminado!!!\n");
kill(ParentPID, 9);
/* exit */
exit(0);
}
}

Bueno la primera parte del proyecto fue algo muy sencillo; lo que hice fue ejecutar un fork() que me creara dos procesos. El proceso hijo en este caso era el proceso pregunton que realiza la pregunta y aguarda a que el usuario teclee una respuesta; si el usuario teclea una respuesta antes de los 30 segundos entonces el proceso hace una llamada al sistema kill() para matar al proceso.
El proceso padre en este caso se encarga de llevar un control del tiempo que va transcurriendo desde que el proceso hijo hace la pregunta. Tiene un ciclo donde se utiliza sleep() que suspende la ejecucucion del programa por un intervalo de tiempo dado que en nuestro caso es 5 segundos, para que cada 5 segundos vaya imprimiendo un mensaje
con el tiempo restante que tiene para contestar la pregunta. Si se pasa de 30 segundos y no ha contestado se manda a llamar a la funcion kill() y se matan los procesos.

[JOKA]

#1
#include <stdio.h>
#include <sys/types.h>
#include <unistd.h>
#include <stdlib.h>
#include <signal.h>

INT MAIN (VOID)
{
INT PID;
INT PIDP;
CHAR RESP [2048];
PIDP = GETPID();
PID = FORK();
IF(PID < 0)
{
PRINTF("NO SE PUEDE REALIZAR EL FORK()\n");
EXIT(1);
}
ELSE
{
IF (PID == 0)
{
INT TIEMPO_RESTANTE;
TIEMPO_RESTANTE = 30;
WHILE(TIEMPO_RESTANTE > 0)
{
SLEEP(5);
PRINTF("OJO CON EL TIEMPO!! \n");
PRINTF("TIEMPO RESTANTE = \n", TIEMPO_RESTANTE);
TIEMPO_RESTANTE = TIEMPO_RESTANTE - 5;
}
PRINTF("EL TIEMPO TERMINO \n");
kILL(PIDP,9);
}
ELSE
{
PRINT("DE FORMA BREVE EXPLIQUE QUE ES UN PROCESO CONCURRENTE \n");
GETS(RESP);
KILL(PID,9);
EXIT(0);
}
}
}

SE CREAN DOS PROCESOS UNO QUE PREGUNTA Y EL OTRO QUE LLEVA EL TIEMPO RESTANTE, LA PREGUNTA SE HACE Y CADA 5 SEGUNDOS SE LE RECUERDA AL USUARIO QUE EL TIEMPO SE ACABA. BASICAMENTE LO QUE LLEVO TIEMPO FUE INVESTIGAR DEL FORK KILL Y SLEEP Y PODERLS ENTENDER SU FUNCIONAMIENTO DE MANERA ADECUADA.

#2
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <signal.h>
#include <time.h>

VOID MANEJADORINT(INT);
VOID MANEJADORALRM(INT);
TIME_T START;


VOID MAIN(VOID)
{
START = TIME(NULL);
PRINTF("PRECIONE DEL PARA TERMINAR\n");
SIGNAL(SIGINT, MANEJADORINT);
SIGNAL(SIGALRM, MANEJADORALRM);
while (1)
{
PAUSE();

}
}

VOID MANEJADORINT(INT SIG)
{
CHAR C;
SIGNAL(SIG,SIG_IGN);
PRINTF("RECIBI UN DEL, FINALIZAR EL PROCESO? [S/N] \n");
C = GETCHAR();
IF (C == 's' || C == 'S')
{
EXIT(0);
}
else
{
SIGNAL(SIGINT, MANEJADORINT);
}
}

VOID MANEJADORALRM(INT SIG)
{
SIGNAL(SIG, SIG_IGN);
PRINFTf("TIEMPO TRASCURRIDOS DESDE EJECUCION\n", (INT)(TIME(NULL)-START));
SIGNAL(SIG, MANEJADORALRM);
}

ESTE ES BASICAMENTE EL LLAMADO A DOS PROCESOS EN UN PROCESO INICIAL QUE SE ENCUENTRA EN UN LOOP INFINITO QUE MANDA LA SEÑAL A OTROS DOS PROCESOS. MANEJADORINT TERMINAN CUANDO SE PRECIONA "DEL" DE L CONTRARIO SOLO LLAMA EL MANEJADORALRM EL CUAL IMPRIME EL TIEMPO TRASCURRIDO DE EJECUCION Y LE MANDA LA SEÑAL DE NUEVO AL MANEJADORINT

[MARTINEZBAYRON]

La primera parte del mini proyecto utiliza una función llamada FORK () esta es útil para crear un proceso hijo y un PID =0.
Ha este nivel hemos creado dos procesos pesados, de la cual el primero se encarga del control del ingreso de la respuesta del usuario, mientras el segundo proceso se encarga de llevar el conteo del tiempo de ingreso de la respuesta; este nos muestra cada 5 S. un mensaje, el cual hace recordar al usuario que solo tiene un tiempo de respuesta de 30 S. Esto es posible gracias a la utilización de la función Sleep(int), int es el tiempo que se detiene, 5 S.
Lógicamente el programa terminara cuando alguna se acabe los 30 S. o cuando responda la pregunta el usuario. Esto será posible gracias a la Funcion KILL(PID,SIG).


Esta segunda parte la he podido realizar como guía el ejemplo ya que necesitamos un manejador para la señal SIGINT Y SIGALARM. Esta función pregunta si se desea terminar la aplicación.

INVESTIGACIONFORK () crea una copia del proceso y retorna el pid del hijo y al hijo le da un pid de cero, lo que puede usarse para diferenciar los dos procesos
GETPID () retorna el pid del proceso que llama a la función
SLEEP () recibe un parámetro que es el numero de segundos que pasaran antes que el proceso siga ejecutándose
KILL () recibe primero el pid del proceso al que le queremos enviar una señal y luego la señal que le queremos enviar

COMANDOS
KILL recibe como parámetro -señal, donde la señal es lo que deseamos enviar y luego el pid del proceso
PS nos muestra los procesos del usuario que están corriendo su pid y el nombre del programa
TOP nos muestra los procesos que consumen mas CPU y el porcentaje del consumo del mismo

********
PARTE1
********
[img] Aloja: Alojamiento de imagenes[/img]


********
PARTE2
********


[img] Aloja: Alojamiento de imagenes[/img]