PRACTICA5

#include <stdlib.h>
#include <time.h>
#include <unistd.h>
#include <stdlib.h>
#include <stdio.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <errno.h>
#include <string.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
 
#define lectura 0
#define escritura 1
 
 
int aleatorio(void)
{
       int semilla = (int)time(NULL);
       srand(semilla);
}
 
int hijo(int tub1[2], int tub2[2]){
    int ret;
    int mi_num;
 
    int nu_byte;
    char buf[256]={};
 
    ret = fork();
 
        if (ret == 0){
            /*Tratamiento del nieto*/
            //minumero = aleatorio();
            mi_num= 10;
 
            printf("%d\n",mi_num);
            sprintf(buf,"%d",mi_num);
 
            if( write (tub1[escritura],buf, sizeof(buf)) == -1){
                perror("Fallo write nieto");
                exit(EXIT_FAILURE);
            }
 
            nu_byte = read(tub2[lectura],buf,sizeof(buf));
 
            if (nu_byte == -1){
                perror("Fallo read nieto");
                exit(EXIT_FAILURE);
            }
 
 
 
            close(tub1[escritura]);
            close(tub2[lectura]);
 
            printf("Soy hijo1 con PID=%d, mi numero aleatorio es %d y el del otro proceso es %s\n\n",getpid(),mi_num,buf);
 
 
        }
 
        else if (ret > 0){
            /*Tratamiento del padre*/
 
            //minumero = aleatorio();
            mi_num=12;
 
            printf("%d\n",mi_num);
            sprintf(buf,"%d",mi_num);
 
            if( write (tub2[escritura],buf, sizeof(buf)) == -1){
                perror("Fallo write padre");
                exit(EXIT_FAILURE);
            }
 
            nu_byte = read(tub1[lectura],buf,sizeof(buf));
 
            if (nu_byte == -1){
                perror("Fallo read padre");
                exit(EXIT_FAILURE);
            }
 
 
 
 
            close(tub1[lectura]);
            close(tub2[escritura]);
 
            printf("Soy hijo2 con PID=%d, mi numero aleatorio es %d y el del otro proceso es %s\n\n",getpid(),mi_num,buf);
        }
 
        else if (ret == -1){
           
            perror("Fallo en el segundo fork");
            exit(EXIT_FAILURE);           
        }
}
 
int main (void){
    int ret;
    int ret2;
    int tub1[2];
    int tub2[2];
    int temp;
    int e;
    char buf[256]={};
 
    if (pipe(tub1) == -1){
        perror("Fallo pipe1");
        exit(EXIT_FAILURE);
    }
 
    if (pipe(tub2) == -1){
        perror("Fallo pipe2");
        exit(EXIT_FAILURE);
    }
 
    ret = fork();
 
    if (ret == 0){
       
        hijo(tub1,tub2);
 
    }
 
    else if( ret > 0){
       
 
 
    }
 
    else if (ret == -1){
        perror("Fallo en fork");
        exit(EXIT_FAILURE);
    }
 
    ret = wait (NULL);
 
    while (ret > 0){
        ret = wait(NULL);
    }
 
    if (ret == -1 && errno != ECHILD){
        perror("Fallo en wait");
        exit (EXIT_FAILURE);
    }
 
}

POSIX

¿QUE ES POSIX ?

Se define una interfase portable para aplicaciones basadas en el popular sistema operativo UNIX

del UNIX. Una parte importante del POSIX aborda las necesidades de las aplicaciones de tiempo real. La portabilidad de estas aplicaciones es hoy en día prácticamente imposible

debido a la gran cantidad de sistemas operativos y núcleos de tiempo real existentes.

(Portable Operating System Interface para UNIX). Familia de estándares relacionados especificados por la IEEE para definir APIs para la compatibilidad de software  entre los diferentes sistemas operativos Unix. El término "POSIX" fue sugerido por Richard Stallman en respuesta a un requerimiento de la IEEE, que deseaba un nombre memorable.

La familia  de estándares POSIX es formalmente designada como IEEE 1003, y el nombre del estándar internacional ISO es ISO/IEC 9945.

Si los diseñadores de programas se adecúan a POSIX, sus aplicaciones podrán ejecutarse en cualquier sistema operativo compatible con POSIX.

Los sistemas operativos que soportan POSIX son:
* A/UX
* AIX
* BSD/OS
* HP-UX
* INTEGRITY
* Irix
* LynxOS
* Mac OS X
* MINIX
* OpenVMS
* QNX
* RTEMS (POSIX 1003.1-2003 Profile 52)
* Solaris
* OpenSolaris
* UnixWare
* VxWorks
* Windows con kernel NT (usados en Windows NT, 2000, 2003; XP, Vista): sólo en algunas ediciones o con determinadas aplicaciones instaladas.

¿DONDE SE USA?

Se estableció en el POSIX un grupo de trabajo de tiempo real. Este grupo desarrolla estándares para añadir al POSIX básico (o UNIX) los servicios de sistema operativo necesarios para poder desarrollar aplicaciones de tiempo real. Estas aplicaciones se

caracterizan porque el funcionamiento correcto no sólo depende de los resultados del cálculo, sino también del instante en el que se generan estos resultados. Con objeto de garantizar que los cálculos se realizan en los instantes requeridos, es preciso que el sistema de tiempo real tenga un comportamiento temporal predecible, y para ello, es preciso también que los servicios del sistema operativo sean capaces de proporcionar el nivel de servicio requerido con un tiempo de respuesta acotado. El objetivo principal del grupo de trabajo de tiempo real del POSIX es "desarrollar estándares que sean los mínimos cambios y adiciones a los estándares POSIX para soportar la portabilidad de

aplicaciones con requerimientos de tiempo real".

EJEMPLO

#include <pthread.h>
#include <stdlib.h>
#include <unistd.h>

void *thread_function(void *arg) {
  int i;
  for ( i=0; i<20; i++ ) {
    printf("Thread says hi!\n");
    sleep(1);
  }
  return NULL;
}

int main(void) {

  pthread_t mythread;

  if ( pthread_create( &mythread, NULL, thread_function, NULL) ) {
    printf("error creating thread.");
    abort();
  }

  if ( pthread_join ( mythread, NULL ) ) {
    printf("error joining thread.");
    abort();
  }

  exit(0);

}

2. El principal objetivo de este estándar es la portabilidad de las aplicaciones a nivel de código fuente, mediante la unificación de las diferentes versiones

NUMERO DEL EJERCICIO A ESCOGER

ESCOJO ES NUMERO 7 DE LOS EJERCICIOS

PRACTICA4

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


#define NUM_HIJOS 2//
int main(void)
{
int ret,i;

    for(i=1;i<=NUM_HIJOS;i++)
    {
    ret=fork();
    if(ret==0)
    {
printf("Yosoy el hijo %d mi padre es PID: %d,Yo soy PID= %d \n\n",i,getppid(),getpid());

if(i==2){
printf("Soy el hijo 3 mi proceso es= %d ", getpid());}

}
else if(ret>0)
{
ret=wait(NULL);
while(ret>0){
ret=wait(NULL);
}
if (ret==-1 && errno != ECHILD)
{
perror("fallo en wait");
exit(EXIT_FAILURE);
}
exit(EXIT_SUCCESS);
}
else if(ret== -1){
perror("fallo el fork");
exit(EXIT_FAILURE);
}
}
}

PRACTICA 3

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


#define NUM_HIJOS 3//
int main(void)
{
int ret,i;

    for(i=0;i<NUM_HIJOS;i++)
    {
    ret=fork();
    if(ret==0)
    {
printf("Yosoy el hijo %d mi padre es PID: %d,Yo soy PID= %d",i,getppid(),getpid());
}
else if(ret>0)
{
ret=wait(NULL);
while(ret>0){
ret=wait(NULL);
}
if (ret==-1 && errno != ECHILD)
{
perror("fallo en wait");
exit(EXIT_FAILURE);
}
exit(EXIT_SUCCESS);
}
else if(ret== -1){
perror("fallo el fork");
exit(EXIT_FAILURE);
}
}
}

PROGRAMA DIBUJARARBOL

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

int main (void) {

/**ATENCIÓN: Declaración de variables del programa a probar. Es sólo un exemplo**/
    int i;
    int n = 4;
    int childpid;

/**El resto de variables son para que la presentación de los resultados por pantalla sea posible**/
 
    int a, p;
    int ret;
    FILE *fpipe;
    char comanda[50]; /*String dónde se guarda el comando a ejecutar por el 1r hijo*/
    char line[256];        
    p = getpid();

    sprintf(comanda,"pstree -n -p %d\n",getpid()); /*Concatenamos el comando pstree con el pid del padre*/

    ret = fork();

    if (ret == 0) { /*Este es el primer hijo del padre*/
        if ( !(fpipe = (FILE*)popen(comanda,"r")) ) {  /* Si el pipe falla*/
            perror("Problemas con el pipe!!!");
            exit(1);
        }
        while ( fgets( line, sizeof line, fpipe))
        {
            printf("%s", line); /*Escribimos por pantalla lo que retorna el hijo. La salida del pstree*/
        }
        pclose(fpipe);

     
    } else {
        /*El primer hijo sólo se crea para hacer un pstree y poder ver por pantalla */
        /*el árbol de procesos generado*/

        /*El código que viene a continuación, lo podéis substituir por lo que se tercie*/
        /*¡¡Las variables han de ir declaradas arriba!!!*/

     
        for (i = 1; i < n; i++) {
            if ((childpid = fork()) == -1) {
                break;
                }
            fprintf(stderr, "Este es el proceso %ld com padre %ld\n", (long)getpid(), (long)getppid());     
                    }
        sleep(1); /*Es sólo para dar tiempo a terminar a todos los hijos*/

    }
exit(0);
}

¿POR QUE APARECE MUCHAS VECES EL MENSAJES?

POR QUE SE CREAN PROCESOS PADRES A TRAVÉS DEL FORK() , LA UTILIZACIÓN DE LOS PIPES QUE PERMITEN LA COMUNICACIÓN CON EL SHELL  Y EL GETPIDD.

¿QUE OBSERVAS?

EL PAPEL IMPORTANTE DE EL FORK(), DE LOS PIPES 

¿POR QUE?

PUES  SON FUNCIONES IMPORTANTES PARA LA CREACIÓN DE LOS PROCESOS Y SU USO .

PROGRAMA EN C

#include<sys/types.h>

#include<sys/wait.h>

#include<unistd.h>

#include<stdio.h>

#include<stdlib.h>

int main(int argc, char *argv[]){

int num;

pid_t pid;

for(num=0;num<3;num++){

pid=fork();

printf("Soy el proceso PID %d, y mi padre tiene %d, de PID \n",getpid(),getppid());

if(pid!=0)

break;

srandom(getpid());

sleep(random() %3);

}

if(pid!=0)

printf("fin del proceso PID %d \n", wait(NULL));

return 0;

}

¿Por que aparecen los mensajes repetidos?

Con fork() es el encargado de crear un nuevo porceso ,se  crea  una cadena de procesos de N, donde N es el parámetro de línea de comandos. Cada proceso crea un proceso hijo, imprime su propio PID y el PID de su padre,la funcion wait()  espera a su hijo a terminar llamando a la espera () función. 

El sramdon interviene inicializando  el generador de números aleatorios mediante el establecimiento de los valores de la tabla de estado sobre la base de la semilla.

Con el   getpid devuelve el identificador de proceso del proceso actual. (Esto es usado normalmente por rutinas que generan nombres únicos de ficheros temporales.) getppid devuelve el identificador de proceso del padre del proceso actual.

¿Que observas?

A la hora de ejecutar el programa desde la consola pude observar  como se crea un proceso padre y un proceso hijo uno cada diferente por cada padre e hijo y al final muestra el fin de los procesos creados.

¿Por que?

Esto se debe a la utilizacion de un ciclo, la funcion fork() y wait() que son parte importante durante la ejecucion de nuestro programa, la funcion getpid que nos muestra el identificador del proceso y el getppid el identificador del proceso padre.