fechando os descritores de arquivos indesejados

Question

Estou tentando entender como os canos funcionam. Este trecho de código é de algum site.

Então, minha compreensão do programa é assim:

Quando fazemos pipe(fd) , então fd[0]=3 e fd[0]=4 (assumindo apenas 0 , 1 & 2 estão abertos até agora). Agora nós bifuramos o pai e então se um filho não é criado então temos erro e ele sai.

Mas, se o filho for criado com êxito, os descritores de arquivo são copiados para o filho, quero dizer também fd[0]=3 e fd[1]=4 do processo filho? fd[0] e fd[1] são identificadores de arquivos para quais arquivos (não especificamos especificamente)?

Vamos supor que queremos que o filho leia pai, pai deve fechar fd[0] e filho deve fechar fd[1] mas por quê? O que acontecerá se não os fecharmos? E eu não entendi On a technical note, the EOF will never be returned if the unnecessary ends of the pipe are not explicitly closed. .

If the parent wants to receive data from the child, it should close fd1, and the child should close fd0. If the parent wants to send data to the child, it should close fd0, and the child should close fd1. Since descriptors are shared between the parent and child, we should always be sure to close the end of pipe we aren't concerned with. On a technical note, the EOF will never be returned if the unnecessary ends of the pipe are not explicitly closed.

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

    main()
    {
            int     fd[2];
            pid_t   childpid;

            pipe(fd);

            if((childpid = fork()) == -1)
            {
                    perror("fork");
                    exit(1);
            }

            if(childpid == 0)
            {
                    /* Child process closes up input side of pipe */
                    close(fd[0]);
            }
            else
            {
                    /* Parent process closes up output side of pipe */
                    close(fd[1]);
            }
            .
            .
    }

    

Answer 1

Um fork é realmente um fork. Você obtém dois processos quase idênticos. A principal diferença é o valor retornado da chamada de sistema fork() que é o pid do filho no que é identificado como pai e 0 no filho (que é como o software pode determinar qual processo é considerado o pai (o pai tem a responsabilidade de cuidar de seus filhos) e que é o filho ).

Em particular, a memória é duplicada, portanto, a matriz fd conterá a mesma coisa (se fd[0] for 3 em um processo, ela será 3 também no outro) e os descritores de arquivo forem duplicados. fd 3 no filho apontará para a mesma descrição do arquivo aberto como fd 3 no pai.

Então fd3 de pai e filho apontará para uma extremidade do canal, e fd4 ( fd[1] ) de pai e filho apontará para a outra extremidade.

Você deseja usar esse pipe para um processo para enviar dados para o outro. Tipicamente, um dos processos gravará em fd 4 e o outro lerá a partir de fd 3 até ver fim do arquivo .

fim do arquivo é atingido quando todos os fds abertos para o outro lado do tubo foram fechados. Então, se o leitor não fechar seu fd para o outro lado, ele nunca verá o fim do arquivo .

Da mesma forma, se o leitor morrer, o escritor nunca saberá que deve parar de escrever se não tiver fechado seu próprio fd para o outro lado do tubo.