Communication parentale interprocessus parent avec pipe

Question

J'essaie de comprendre dans la communication entre le parent et l'enfant. Avertissement: Ce qui suit est l'exemple de code fourni par mon professeur en classe pour comprendre la communication interprocessus. Ma principale faiblesse est dans les descripteurs de fichiers. Je comprends que pipe (int array [2]) rend array [0] = fd pour std in et array [1] comme std out. Mais comment est cette communication entre ces deux? Je suis assez nouveau à CS. Merci!

/* 
* This program demonstrates the use of pipes for interprocess communication. 
* The parent process creates a pipe using the "pipe" system call. It then 
* creates a child process and passes the child a file descriptor for one side 
* of the pipe. It then writes a name to its side of the pipe and waits for the 
* child to print a message incorporating the name. 
* 
* Before you attempt to run this program, be sure you've compiled the program 
* named "hw3b.c" and have the executable in a file named "hw3b". 
*/ 

#include <stdlib.h> 
#include <strings.h> 
#include <stdio.h> 

/* 
* The name of the file we plan to run. It's here in a define so that we can 
* change it easily 
*/ 
#define CHILDPROCNAME "hw3b" 

/* 
* The behavior of main() is specified by the previous comment 
*/ 

int main(char* argv) 
{ 
    // store the ids of the two file descriptors that serve as the pipe 
    int mypipe[2]; 

    // make the pipe 
    pipe(mypipe); 

    // child code: 
    if (fork() == 0) { 
     // execv requires us to create a full invocation, consisting of the 
     // string name of the program to run, a string for each command-line 
     // argument, and then a null string. We store all that in this array of 
     // strings 
     char* myargv[3]; 

     // we use this to turn an int into a string 
     char buf[50]; 

     // set up the name of the program to run 
     myargv[0] = calloc(strlen(CHILDPROCNAME) + 1, sizeof(char)); 
     strcpy(myargv[0], CHILDPROCNAME); 

     // write one of the pipe's fds to the second parameter 
     sprintf(buf, "%d", mypipe[0]); 
     myargv[1] = calloc(strlen(buf) + 1, sizeof(char)); 
     strcpy(myargv[1], buf); 

     // third param is null 
     myargv[2] = 0; 

     // switch to child process 
     execv(CHILDPROCNAME, myargv); 

     // NB: this should use fprintf and write to stderr 
     printf("Uh oh, execv didn't work!\n"); 

     // crash on failure 
     exit(-1); 
    } 

    // parent code 
    else { 
     // status variable for storing the result of waitpid 
     int status; 

     // Send a string across the pipe to the child process 
     write(mypipe[1], "Kerry", strlen("Kerry")); 

     // wait for the child process to finish 
     waitpid(-1, &status, 0); 

     // NB: we should use status! 
    } 

    // close our half of the pipe 
    close(mypipe[1]); 
} 

Answer 1

Il remplace simplement childproc dans votre programme avec p1. Il aurait pu signifier que cela dépend de la valeur i.e p1.