Específicamente, ¿cómo maneja fork() la memoria dinámicamente asignada de malloc () en Linux?

Tengo un programa con un proceso padre y un proceso hijo. Antes de la bifurcación(), el proceso padre llamó a malloc () y llenó una matriz con algunos datos. Después de la bifurcación (), el hijo necesita esos datos. Sé que podría usar una tubería, pero el siguiente código parece funcionar:

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>

int main( int argc, char *argv[] ) {
    char *array;
    array = malloc( 20 );
    strcpy( array, "Hello" );
    switch( fork() ) {
    case 0:
        printf( "Child array: %s\n", array );
        strcpy( array, "Goodbye" );
        printf( "Child array: %s\n", array );
        free( array );
        break;
    case -1:
        printf( "Error with fork()\n" );
        break;
    default:
        printf( "Parent array: %s\n", array );
        sleep(1);
        printf( "Parent array: %s\n", array );
        free( array );
    }
    return 0;
}

La salida es:

Parent array: Hello
Child array: Hello
Child array: Goodbye
Parent array: Hello

Sé que los datos asignados en la pila están disponibles en el hijo, pero parece que los datos asignados en el montón también están disponibles para el hijo. Y del mismo modo, el niño no se pueden modificar los datos del padre en la pila, el hijo no puede modificar los datos del padre en el montón. Así que asumo que el niño obtiene su propia copia de los datos de pila y montón.

¿Es esto siempre el caso en Linux? Si es así, ¿dónde está la documentación que respalda esto? Revisé la página man de fork (), pero no mencionó específicamente la memoria dinámicamente asignada en el montón.

Gracias