¿Qué devuelve exactamente el tenedor?

En caso de éxito, el PID del proceso secundario se devuelve en el hilo de ejecución del padre y se devuelve un 0 en el hilo de ejecución del hijo.

p = fork();

Estoy confundido en su página de manual, es p igual a 0 o PID?

¡No estoy seguro de cómo el manual puede ser más claro! fork() crea un nuevo proceso, por lo que ahora tiene dos idéntico procesos. Para distinguir entre ellos, el valor de retorno de fork() difiere En el proceso original, obtiene el PID del proceso secundario. En el proceso hijo, obtienes 0.

Así que un uso canónico es el siguiente:

p = fork();
if (0 == p)
{
    // We're the child process
}
else if (p > 0)
{
    // We're the parent process
}
else
{
    // We're the parent process, but child couldn't be created
}

                             p = fork();
                        /* assume no errors */
                        /* you now have two */
                        /* programs running */
                         --------------------
      if (p > 0) {                |            if (p == 0) {
        printf("parent\n");       |              printf("child\n");
        ...                       |              ...

Los procesos se estructuran en un árbol dirigido donde solo conoces a tu padre soltero (getppid()). En breve, fork() devoluciones -1 en caso de error, como muchas otras funciones del sistema, el valor distinto de cero es útil para que el iniciador de la llamada de bifurcación (el padre) conozca su pid de nuevo hijo.

Nada es tan bueno como el ejemplo:

/* fork/getpid test */
#include <sys/types.h>
#include <unistd.h>     /* fork(), getpid() */
#include <stdio.h>

int main(int argc, char* argv[])
{
    int pid;

    printf("Entry point: my pid is %d, parent pid is %d\n",
           getpid(), getppid());

    pid = fork();
    if (pid == 0) {
        printf("Child: my pid is %d, parent pid is %d\n",
               getpid(), getppid());
    }
    else if (pid > 0) {
        printf("Parent: my pid is %d, parent pid is %d, my child pid is %d\n",
               getpid(), getppid(), pid);
    }
    else {
        printf("Parent: oops! can not create a child (my pid is %d)\n",
               getpid());
    }

    return 0;
}

Y el resultado (bash es pid 2249, en este caso):

Entry point: my pid is 16051, parent pid is 2249
Parent: my pid is 16051, parent pid is 2249, my child pid is 16052
Child: my pid is 16052, parent pid is 16051

Si necesita compartir algunos recursos (archivos, pid principal, etc.) entre padre e hijo, consulte clone() (para la biblioteca GNU C, y quizás otros)

Una vez fork se ejecuta, tienes dos procesos. La llamada devuelve diferentes valores a cada proceso.

Si haces algo como esto

int f;
f = fork();
if (f == 0) {
  printf("I am the child\n");
} else {
  printf("I am the parent and the childs pid is %d\n",f);

}

Verá ambos mensajes impresos. Están siendo impresos por dos procesos separados. Esta es la forma en que puede diferenciar entre los dos procesos creados.

Esta es la parte genial. Es igual a AMBOS.

Bueno en realidad no. Pero una vez fork devoluciones, ¡ahora tiene dos copias de su programa ejecutándose! Dos procesos. Puedes pensar en ellos como universos alternativos. En uno, el valor de retorno es 0. En el otro, es el ID del nuevo proceso!

Por lo general, tendrá algo como esto:

p = fork();
if (p == 0){
    printf("I am a child process!\n");
    //Do child things
}
else {
    printf("I am the parent process! Child is number %d\n", p);
    //Do parenty things
}

En este caso, ambas cadenas se imprimirán, ¡pero mediante procesos diferentes!

fork() se invoca en el proceso padre. Luego se genera un proceso hijo. En el momento en que se genera el proceso hijo, fork() ha terminado su ejecución.

En este punto, fork() está listo para regresar, pero devuelve un valor diferente dependiendo de si está en el padre o en el hijo. En el proceso secundario, devuelve 0, y en el proceso/subproceso principal, devuelve el ID del proceso secundario.

Fork crea un proceso duplicado y un nuevo contexto de proceso. Cuando devuelve un valor 0, significa que se está ejecutando un proceso secundario, pero cuando devuelve otro valor, significa que se está ejecutando un proceso principal. Por lo general, usamos una declaración de espera para que un proceso secundario se complete y el proceso principal comience a ejecutarse.