Durchführung mehrerer Rohre in C

Ich glaube, das Problem hier ist, dass Ihr wartet und schließen innerhalb der gleichen Schleife, die die Kinder zu erschaffen. Auf der ersten iteration, das Kind exec ("zerstört die Kind-Programm, überschreiben Sie es mit Ihrem ersten Befehl) und dann den Eltern schließt alle seine Dateideskriptoren und wartet, bis das Kind fertig ist, bevor es durchläuft auf der Erstellung des nächsten Kindes. An diesem Punkt, da die Muttergesellschaft geschlossen hat, alle seine Rohre, keine weiteren Kinder haben nichts zu schreiben oder Lesen. Da Sie nicht die überprüfung für den Erfolg Ihrer dup2 ruft, dieses ist gehen un-bemerkt.

Wenn Sie möchten, um die gleiche Schleife, die Sie benötigen um sicherzustellen, dass die Eltern nur schließt die Dateideskriptoren, die bereits verwendet wurden, lässt aber jene, die noch nicht allein. Dann, nachdem alle Kinder geschaffen worden, und Ihre Eltern warten können.

BEARBEITEN: ich mischte die Eltern/Kind in meiner Antwort, aber die Argumentation immer noch gilt: der Prozess, dass sich an der Gabel wieder schließt alle Kopien der Rohre, so dass jeder Prozess nach der ersten Gabel keine gültige Datei-Deskriptoren zu Lesen/schreiben.

pseudo-code, mit einem array von Leitungen erstellt-front:

/* parent creates all needed pipes at the start */
for( i = 0; i < num-pipes; i++ ){
    if( pipe(pipefds + i*2) < 0 ){
        perror and exit
    }
}

commandc = 0
while( command ){
    pid = fork()
    if( pid == 0 ){
        /* child gets input from the previous command,
            if it's not the first command */
        if( not first command ){
            if( dup2(pipefds[(commandc-1)*2], 0) < ){
                perror and exit
            }
        }
        /* child outputs to next command, if it's not
            the last command */
        if( not last command ){
            if( dup2(pipefds[commandc*2+1], 1) < 0 ){
                perror and exit
            }
        }
        close all pipe-fds
        execvp
        perror and exit
    } else if( pid < 0 ){
        perror and exit
    }
    cmd = cmd->next
    commandc++
}

/* parent closes all of its copies at the end */
for( i = 0; i < 2 * num-pipes; i++ ){
    close( pipefds[i] );
}

In diesem code, den ursprünglichen übergeordneten Prozess erstellt ein Kind für jeden Befehl und deshalb überlebt die ganze Angelegenheit. Die Kinder prüfen, um zu sehen, wenn Sie sollten Sie bekommen Ihren input von den vorherigen Befehl, und wenn Sie senden Ihre Ausgabe an den nächsten Befehl. Dann schließen Sie alle Ihre Kopien der pipe-Datei-Deskriptoren und dann exec. Die Eltern nicht alles tun, aber Gabel, bis es ein Kind wird für jeden Befehl. Es schließt sich dann alle Kopien der Deskriptoren und kann gehen, um zu warten.

Erstellen alle Rohre, die Sie zuerst benötigen, und verwalten Sie Sie in der Schleife, ist schwierig und erfordert einige array-Arithmetik. Ziel ist es aber, sieht wie folgt aus:

cmd0    cmd1   cmd2   cmd3   cmd4
   pipe0   pipe1  pipe2  pipe3
   [0,1]   [2,3]  [4,5]  [6,7]

Erkennen, dass zu einem bestimmten Zeitpunkt, müssen Sie nur zwei Sätze von Rohren (die Rohre zu den vorherigen Befehl, und das Rohr, um den nächsten Befehl) vereinfachen Sie Ihren code und machen es ein wenig robuster. Ephemient gibt den pseudo-code für diese hier. Sein code ist sauberer, weil die Eltern und Kind nicht zu tun haben, unnötige Schleifen in der Nähe der UNO-benötigte Datei-Deskriptoren, denn die Eltern können einfach schließen Sie Ihr Kopien der Datei-Deskriptoren, die sofort nach der Gabel.

Als kleiner Hinweis: Sie sollten immer prüfen die Rückgabewerte der pipe, dup2, fork und exec.

EDIT 2: Tippfehler in pseudo-code. OP: num-Rohre würde die Zahl der Rohre. E. g., "ls | grep foo | sort-r" müsste 2 Rohre.

InformationsquelleAutor Christopher Neylan

Den (verkürzten) relevante code:

    if(fork() == 0){
            //do child stuff here
            ....
    }
    else{
            //do parent stuff here
            if(command != NULL)
                command = command->next;

            j += 2;
            for(i = 0; i < (numPipes ); i++){
               close(pipefds[i]);
            }
           while(waitpid(0,0,0) < 0);
    }

Was bedeutet, dass die Eltern (controlling) - Prozesses bedeutet dies:

• Gabel
• schließen Sie alle Rohre
• warten, bis Kind-Prozeß
• next-Schleife - /Kind -

Aber es sollte so etwas wie dieses:

• Gabel
• Gabel
• Gabel
• schließen Sie alle Rohre (sollte alles betrogen wurden nun)
• warten childs

InformationsquelleAutor A.H.

Aufbauend auf der Idee der Verwendung von maximal zwei Rohre auf ein mal erwähnt von Christopher Neylan, den ich zusammen gestellt habe pseudocode für n-Leitungen. args ist ein array von Zeichen Zeigern Größe 'args_size", das ist eine Globale variable.

//MULTIPLE PIPES
//Test case:   char *args[] = {"ls", "-l", "|", "head", "|", "tail", "-4", 
0};//"|", "grep", "Txt", 0};   
enum fileEnd{READ, WRITE};

void multiple pipes( char** args){
pid_t cpid;
//declare pipes
int pipeA[2]
int pipeB[2]
//I have done getNumberofpipes
int numPipes = getNumberOfPipes;
int command_num = numPipes+1;
//holds sub array of args 
//which is a statement to execute
//for example: cmd = {"ls", "-l", NULL}
char** cmd 
//iterate over args
for(i = 0; i < args_size; i++){
  //
  //strip subarray from main array
  // cmd 1 | cmd 2 | cmd3 => cmd
  //cmd = {"ls", "-l", NULL}
  //Open/reopen one pipe

  //if i is even open pipeB
    if(i % 2)  pipe(pipeB);
  //if i is odd open pipeA
    else       pipe(pipeA);


  switch(cpid = fork(){
      case -1: error forking
      case 0: //child process
            childprocess(i);
      default: //parent process
           parentprocess(i, cpid);
  }
}
}
//parent pipes must be closed in parent
void parentprocess(int i, pid_t cpid){

   //if first command
   if(i == 0)  
        close(pipeB[WRITE]);

   //if last command close WRITE
   else if (i == numPipes){
       //if i is even close pipeB[WRITE]
       //if i is odd close pipeA[WRITE]
   }

   //otherwise if in middle close READ and WRITE 
   //for appropriate pipes
      //if i is even
      close(pipeA[READ])
      close(pipeB[WRITE])
      //if i is odd
      close(pipeB[READ])
      close(pipeA[WRITE])
   }

   int returnvalue, status;
   waitpid(cpid, returnvalue, status);
}
void childprocess(int i){

    //if in first command
    if(i == 0)
        dup2(pipeB[WRITE], STDOUT_FILENO);
    //if in last command change stdin for
    //the necessary pipe. Don't touch stdout - 
    //stdout goes to shell
    else if( numPipes == i){
        //if i is even
        dup2(pipeB[READ], STDIN_FILENO)
        //if i is odd
        dup2(pipeA[READ], STDIN_FILENO);        
    }
    //otherwise, we are in middle command where
    //both pipes are used.
    else{
       //if i is even
       dup2(pipeA[READ], STDIN_FILENO)
       dupe(pipeB[WRITE], STDOUT_FILENO)
       //if i is odd
       dup2(pipeB[READ], STDIN_FILENO)
       dup2(pipeA[WRITE], STDOUT_FILENO)
    }

    //execute command for this iteration
    //check for errors!!
    //The exec() functions only return if an error has occurred. The return value is -1, and errno is set to indicate the error.
    if(exec(cmd, cmd) < 0)
        printf("Oh dear, something went wrong with read()! %s\n", strerror(errno));
    }   
}

InformationsquelleAutor Elizabeth Bradley