¿Qué es la "expansión automática de la pila"?

getrlimit (2) tiene la siguiente definición en las páginas del manual:

RLIMIT_AS El tamaño máximo de la memoria virtual del proceso (espacio de direcciones) en bytes. Este límite afecta las llamadas a brk (2), mmap (2) y mremap (2), que fallan con el error ENOMEM al exceder este límite. También la expansión automática de la pila fallará (y generará un SIGSEGV que mata el proceso si no se ha puesto a disposición una pila alternativa a través de sigaltstack (2)). Como el valor es largo, en máquinas con una longitud de 32 bits, este límite es como máximo 2 GiB o este recurso es ilimitado.

¿Qué se entiende por "expansión automática de pila" aquí? ¿La pila en un entorno Linux / UNIX crece según sea necesario? En caso afirmativo, ¿cuál es el mecanismo exacto?

Sí, las pilas crecen dinámicamente. La pila está en la parte superior de la memoria creciendo hacia abajo hacia el montón.

--------------
| Stack      |
--------------
| Free memory|
--------------
| Heap       |
--------------
     .
     .

El montón crece hacia arriba (cada vez que haces malloc) y la pila crece hacia abajo a medida que se llaman nuevas funciones. El montón está presente justo encima de la sección BSS del programa. Lo que significa que el tamaño de su programa y la forma en que asigna memoria en el montón también afectan el tamaño máximo de la pila para ese proceso. Por lo general, el tamaño de la pila es ilimitado (hasta que las áreas de montón y pila se encuentran y / o sobrescriben, lo que dará un desbordamiento de pila y SIGSEGV :-)

Esto es solo para los procesos del usuario. La pila del kernel se arregla siempre (generalmente 8 KB)

El mecanismo exacto se da aquí, en Linux: al manejar un error de página en asignaciones anónimas , verifica si es una "asignación de crecimiento" que debe expandirse como una pila. Si el registro del área VM dice que debería hacerlo, entonces ajusta la dirección de inicio para expandir la pila.

Cuando se produce un error de página, dependiendo de la dirección, se puede reparar (y anular el error) mediante la expansión de la pila. Este comportamiento de "crecimiento descendente en caso de falla" para la memoria virtual puede solicitarse mediante programas de usuario arbitrarios con el MAP_GROWSDOWNindicador que se pasa a la mmapllamada al sistema.

También puede jugar con este mecanismo en un programa de usuario:

#include <assert.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/mman.h>

int main() {
        long page_size = sysconf(_SC_PAGE_SIZE);
        void *mem = mmap(NULL, page_size, PROT_READ|PROT_WRITE, MAP_GROWSDOWN|MAP_ANONYMOUS|MAP_PRIVATE, -1, 0);
        if (MAP_FAILED == mem) {
                perror("failed to create growsdown mapping");
                return EXIT_FAILURE;
        }

        volatile char *tos = (char *) mem + page_size;

        int i;
        for (i = 1; i < 10 * page_size; ++i)
                tos[-i] = 42;

        fprintf(stderr, "inspect mappping for originally page-sized %p in /proc... press any key to continue...\n", mem);
        (void) getchar();

        if (munmap(mem, page_size))
                perror("failed munmap");

        return EXIT_SUCCESS;
}

Cuando se le solicite, encuentre el pid del programa (vía ps) y mire /proc/$THAT_PID/mapspara ver cómo ha crecido el área original.