ti-enxame.com

Implementação de vários pipes em C

Eu estou tentando implementar vários pipes no meu Shell em C. Eu encontrei um tutorial sobre este site ea função que fiz baseia-se neste exemplo. Aqui está a função

void executePipes(cmdLine* command, char* userInput) {
    int numPipes = 2 * countPipes(userInput);
    int status;
    int i = 0, j = 0;
    int pipefds[numPipes];

    for(i = 0; i < (numPipes); i += 2)
        pipe(pipefds + i);

    while(command != NULL) {
        if(fork() == 0){

            if(j != 0){
                dup2(pipefds[j - 2], 0);
            }

            if(command->next != NULL){
                dup2(pipefds[j + 1], 1);
            }    

            for(i = 0; i < (numPipes); i++){
                close(pipefds[i]);
            }
            if( execvp(*command->arguments, command->arguments) < 0 ){
                perror(*command->arguments);
                exit(EXIT_FAILURE);
            }
        }

        else{
                if(command != NULL)
                    command = command->next;

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

}

Depois de executá-lo e digitar um comando como, por exemplo, ls | grep bin, o Shell simplesmente fica parado e não produz nenhum resultado. Eu me certifiquei de fechar todos os canos. Mas apenas fica pendurado lá. Eu pensei que era o waitpid que era o problema. Eu removi o waitpid e depois de executar não recebo resultados. O que eu fiz errado? Obrigado.

Código adicionado:

void runPipedCommands(cmdLine* command, char* userInput) {
    int numPipes = countPipes(userInput);

    int status;
    int i = 0, j = 0;

    pid_t pid;

    int pipefds[2*numPipes];

    for(i = 0; i < 2*(numPipes); i++){
        if(pipe(pipefds + i*2) < 0) {
            perror("pipe");
            exit(EXIT_FAILURE);
        }
    }

    while(command) {
        pid = fork();
        if(pid == 0) {

            //if not first command
            if(j != 0){
                if(dup2(pipefds[(j-1) * 2], 0) < 0){
                    perror(" dup2");///j-2 0 j+1 1
                    exit(EXIT_FAILURE);
                    //printf("j != 0  dup(pipefd[%d], 0])\n", j-2);
                }
            //if not last command
            if(command->next){
                if(dup2(pipefds[j * 2 + 1], 1) < 0){
                    perror("dup2");
                    exit(EXIT_FAILURE);
                }
            }

            for(i = 0; i < 2*numPipes; i++){
                    close(pipefds[i]);
            }

            if( execvp(*command->arguments, command->arguments) < 0 ){
                    perror(*command->arguments);
                    exit(EXIT_FAILURE);
            }
        } else if(pid < 0){
            perror("error");
            exit(EXIT_FAILURE);
        }

        command = command->next;
        j++;
    }
        for(i = 0; i < 2 * numPipes; i++){
            close(pipefds[i]);
            puts("closed pipe in parent");
        }

        while(waitpid(0,0,0) <= 0);

    }

}
12
mkab

Eu acredito que a questão aqui é que você está esperando e fechando dentro do mesmo ciclo que está criando crianças. Na primeira iteração, o filho executará (o que destruirá o programa filho, sobrescrevendo-o com seu primeiro comando) e, em seguida, o pai fechará todos os descritores de arquivo e aguardará que o filho termine antes de iterar para criar o próximo filho . Nesse ponto, uma vez que o pai fechou todos os seus canais, qualquer outro filho não terá nada para escrever ou ler. Como você não está verificando o sucesso de suas chamadas dup2, isso não será percebido.

Se você quiser manter a mesma estrutura de loop, será necessário certificar-se de que o pai apenas feche os descritores de arquivo que já foram usados, mas deixe os que não foram usados ​​sozinhos. Então, depois que todas as crianças tiverem sido criadas, seus pais podem esperar.

EDIT: Eu misturei o pai/filho na minha resposta, mas o raciocínio ainda é válido: o processo que vai para o fork novamente fecha todas as suas cópias dos pipes, então qualquer processo após o primeiro fork não terá descritores de arquivo válidos para ler/escrever.

pseudo código, usando uma matriz de pipes criada antecipadamente:

/* 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] );
}

Nesse código, o processo pai original cria um filho para cada comando e, portanto, sobrevive a toda a provação. As crianças verificam se devem receber sua entrada do comando anterior e se devem enviar sua saída para o próximo comando. Em seguida, eles fecham todas as suas cópias dos descritores de arquivo de pipe e, em seguida, exec. O pai não faz nada além de bifurcar até que seja criado um filho para cada comando. Em seguida, fecha todas as cópias dos descritores e pode esperar.

Criar todos os canais de que você precisa primeiro e, em seguida, gerenciá-los no loop, é complicado e requer alguma aritmética de matriz. O objetivo, porém, é assim:

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

Percebendo que, a qualquer momento, você só precisa de dois conjuntos de tubos (o pipe para o comando anterior e o pipe para o próximo comando) irá simplificar seu código e torná-lo um pouco mais robusto. Ephemient dá pseudo-código para este aqui . Seu código é mais limpo, porque o pai e o filho não precisam fazer um loop desnecessário para fechar os descritores de arquivo desnecessários e porque o pai pode fechar facilmente suas cópias dos descritores de arquivo imediatamente após a bifurcação.

Como uma nota lateral: você deve sempre verificar os valores de retorno de pipe, dup2, fork e exec.

EDIT 2 : typo no pseudocódigo. OP: num-pipes seria o número de pipes. Por exemplo, "ls | grep foo | sort -r" teria 2 canais.

14
Christopher Neylan

Aqui está o código correto em funcionamento

void runPipedCommands(cmdLine* command, char* userInput) {
    int numPipes = countPipes(userInput);


    int status;
    int i = 0;
    pid_t pid;

    int pipefds[2*numPipes];

    for(i = 0; i < (numPipes); i++){
        if(pipe(pipefds + i*2) < 0) {
            perror("couldn't pipe");
            exit(EXIT_FAILURE);
        }
    }


    int j = 0;
    while(command) {
        pid = fork();
        if(pid == 0) {

            //if not last command
            if(command->next){
                if(dup2(pipefds[j + 1], 1) < 0){
                    perror("dup2");
                    exit(EXIT_FAILURE);
                }
            }

            //if not first command&& j!= 2*numPipes
            if(j != 0 ){
                if(dup2(pipefds[j-2], 0) < 0){
                    perror(" dup2");///j-2 0 j+1 1
                    exit(EXIT_FAILURE);

                }
            }


            for(i = 0; i < 2*numPipes; i++){
                    close(pipefds[i]);
            }

            if( execvp(*command->arguments, command->arguments) < 0 ){
                    perror(*command->arguments);
                    exit(EXIT_FAILURE);
            }
        } else if(pid < 0){
            perror("error");
            exit(EXIT_FAILURE);
        }

        command = command->next;
        j+=2;
    }
    /**Parent closes the pipes and wait for children*/

    for(i = 0; i < 2 * numPipes; i++){
        close(pipefds[i]);
    }

    for(i = 0; i < numPipes + 1; i++)
        wait(&status);
}
7
mkab

O código relevante (abreviado) é:

    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);
    }

O que significa que o processo pai (controlador) faz isso:

  • fork
  • feche todos os canos
  • esperar pelo processo filho
  • próximo ciclo/criança

Mas deve ser algo assim:

  • fork
  • fork
  • fork
  • feche todos os tubos (tudo deveria ter sido enganado agora)
  • esperar por childs
2
A.H.

Com base na idéia de usar um máximo de dois tubos em um determinado momento mencionado por Christopher Neylan, eu coloquei o pseudocódigo para n-pipes. args é uma matriz de ponteiros de caracteres de tamanho 'args_size', que é uma variável global.

// 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));
    }   
}
0
Elizabeth Bradley

Basicamente, o que você quer fazer é uma função recursiva em que o filho executa o primeiro comando e o pai executa o segundo se nenhum outro comando for deixado ou chama a função novamente.

0
Mathieu_Du