¿Por qué bifurcar mi proceso hace que el archivo se lea infinitamente?

Hay una descripción de archivo abierto y un descriptor de archivo abierto detrás de cada transmisión. Cuando el proceso se bifurca, el hijo tiene su propio conjunto de descriptores de archivos abiertos (y secuencias de archivos), pero cada descriptor de archivos en el hijo comparte la descripción del archivo abierto con el padre. SI (y eso es un gran 'si') el proceso secundario que cerró los descriptores de archivo primero hizo el equivalente a lseek(fd, 0, SEEK_SET) , entonces eso también posicionaría el descriptor de archivo para el proceso principal, y eso podría conducir a un bucle infinito. Sin embargo, nunca he oído hablar de una biblioteca que haga esa búsqueda; no hay razón para hacerlo.

Ver POSIX open() y fork() para obtener más información sobre descriptores de archivos abiertos y descripciones de archivos abiertos.

Los descriptores de archivos abiertos son privados para un proceso; las descripciones de archivo abierto son compartidas por todas las copias del descriptor de archivo creado por una operación inicial de 'archivo abierto'. Una de las propiedades clave de la descripción del archivo abierto es la posición de búsqueda actual. Eso significa que un proceso hijo puede cambiar la posición de búsqueda actual para un padre, porque está en la descripción del archivo abierto compartido.

neof97.c

Usé el siguiente código, una versión levemente adaptada del original que se compila limpiamente con opciones de compilación rigurosas:

#include "posixver.h"
#include <stdio.h>
#include <stdlib.h>
#include <sys/wait.h>
#include <unistd.h>

enum { MAX = 100 };

int main(void)
{
    if (freopen("input.txt", "r", stdin) == 0)
        return 1;
    char s[MAX];
    for (int i = 0; i < 30 && fgets(s, MAX, stdin) != NULL; i++)
    {
        // Commenting out this region fixes the issue
        int status;
        pid_t pid = fork();
        if (pid == 0)
        {
            exit(0);
        }
        else
        {
            waitpid(pid, &status, 0);
        }
        // End region
        printf("%s", s);
    }
    return 0;
}

Una de las modificaciones limita la cantidad de ciclos (hijos) a solo 30. Usé un archivo de datos con 4 líneas de 20 letras aleatorias más una nueva línea (84 bytes en total):

ywYaGKiRtAwzaBbuzvNb
eRsjPoBaIdxZZtJWfSty
uGnxGhSluywhlAEBIXNP
plRXLszVvPgZhAdTLlYe

Ejecuté el comando bajo strace en Ubuntu:

$ strace -ff -o st-out -- neof97
ywYaGKiRtAwzaBbuzvNb
eRsjPoBaIdxZZtJWfSty
uGnxGhSluywhlAEBIXNP
plRXLszVvPgZhAdTLlYe
…
uGnxGhSluywhlAEBIXNP
plRXLszVvPgZhAdTLlYe
ywYaGKiRtAwzaBbuzvNb
eRsjPoBaIdxZZtJWfSty
$

Había 31 archivos con nombres de la forma st-out.808## donde los hashes eran números de 2 dígitos. El archivo del proceso principal era bastante grande; los otros eran pequeños, con uno de los tamaños 66, 110, 111 o 137:

$ cat st-out.80833
lseek(0, -63, SEEK_CUR)                 = 21
exit_group(0)                           = ?
+++ exited with 0 +++
$ cat st-out.80834
lseek(0, -42, SEEK_CUR)                 = -1 EINVAL (Invalid argument)
exit_group(0)                           = ?
+++ exited with 0 +++
$ cat st-out.80835
lseek(0, -21, SEEK_CUR)                 = 0
exit_group(0)                           = ?
+++ exited with 0 +++
$ cat st-out.80836
exit_group(0)                           = ?
+++ exited with 0 +++
$

Dio la casualidad de que los primeros 4 niños exhibieron cada uno de los cuatro comportamientos, y cada grupo adicional de 4 niños exhibió el mismo patrón.

Esto muestra que tres de cada cuatro de los niños estaban haciendo un lseek() en la entrada estándar antes de salir. Obviamente, ahora he visto una biblioteca hacerlo. Sin embargo, no tengo idea de por qué se cree que es una buena idea, pero empíricamente, eso es lo que está sucediendo.

neof67.c

Esta versión del código, usando un flujo de archivo separado (y un descriptor de archivo) y fopen() en lugar de freopen() también se encuentra con el problema.

#include "posixver.h"
#include <stdio.h>
#include <stdlib.h>
#include <sys/wait.h>
#include <unistd.h>

enum { MAX = 100 };

int main(void)
{
    FILE *fp = fopen("input.txt", "r");
    if (fp == 0)
        return 1;
    char s[MAX];
    for (int i = 0; i < 30 && fgets(s, MAX, fp) != NULL; i++)
    {
        // Commenting out this region fixes the issue
        int status;
        pid_t pid = fork();
        if (pid == 0)
        {
            exit(0);
        }
        else
        {
            waitpid(pid, &status, 0);
        }
        // End region
        printf("%s", s);
    }
    return 0;
}

Esto también exhibe el mismo comportamiento, excepto que el descriptor de archivo en el que ocurre la búsqueda es 3 en lugar de 0 . Entonces, dos de mis hipótesis están refutadas:está relacionado con freopen() y stdin; ambos se muestran incorrectos por el segundo código de prueba.

Diagnóstico preliminar

En mi opinión, esto es un error. No debería poder encontrarse con este problema. Lo más probable es que se trate de un error en la biblioteca de Linux (GNU C) en lugar del kernel. Es causado por el lseek() en los procesos hijo. No está claro (porque no he ido a mirar el código fuente) qué está haciendo la biblioteca o por qué.

Error GLIBC 23151

Error de GLIBC 23151:un proceso bifurcado con un archivo sin cerrar busca antes de salir y puede provocar un bucle infinito en la E/S principal.

El error se creó el 2018-05-08 EE. UU./Pacífico y se cerró como NO VÁLIDO el 2018-05-09. La razón dada fue:

  int main(){
        freopen("input.txt", "r", stdin);
        char s[MAX];
        prompt(s);
        int i = 0;
        char* ret = fgets(s, MAX, stdin);
        while (ret != NULL) {
            //Commenting out this region fixes the issue
            int status;
            pid_t pid = fork();   // At this point both processes has a copy of the filehandle
            if (pid == 0) {
                exit(0);          // At this point the child closes the filehandle
            } else {
                waitpid(pid, &status, 0);
            }
            //End region
            printf("%s", s);
            ret = fgets(s, MAX, stdin);
        }
    }