Comment fonctionne l'allocation de pile sous Linux?

Le système d'exploitation réserve-t-il la quantité fixe d'espace virtuel valide pour la pile ou autre chose? Suis-je capable de produire un débordement de pile simplement en utilisant de grandes variables locales?

J'ai écrit un petit Cprogramme pour tester mon hypothèse. Il fonctionne sur X86-64 CentOS 6.5.

#include <string.h>
#include <stdio.h>
int main()
{
    int n = 10240 * 1024;
    char a[n];
    memset(a, 'x', n);
    printf("%x\n%x\n", &a[0], &a[n-1]);
    getchar();
    return 0;
}

L'exécution du programme donne &a[0] = f0ceabe0et&a[n-1] = f16eabdf

Les cartes proc montrent la pile: 7ffff0cea000-7ffff16ec000. (10248 * 1024B)

J'ai ensuite essayé d'augmenter n = 11240 * 1024

L'exécution du programme donne &a[0] = b6b36690et&a[n-1] = b763068f

Les cartes proc montrent la pile: 7fffb6b35000-7fffb7633000. (11256 * 1024B)

ulimit -simprime 10240sur mon PC.

Comme vous pouvez le voir, dans les deux cas, la taille de la pile est plus grande que ce qui ulimit -sdonne. Et la pile grandit avec une plus grande variable locale. Le haut de la pile est en quelque sorte de 3 à 5 Ko de plus &a[0](AFAIK, la zone rouge est de 128B).

Alors, comment cette carte de pile est-elle allouée?

Il semble que la limite de mémoire de la pile ne soit pas allouée (de toute façon, elle ne pouvait pas avec une pile illimitée). https://www.kernel.org/doc/Documentation/vm/overcommit-accounting dit:

La croissance de la pile du langage C fait un mremap implicite. Si vous voulez des garanties absolues et courez près du bord, vous DEVEZ mmapper votre pile pour la plus grande taille dont vous pensez avoir besoin. Pour une utilisation typique de la pile, cela n'a pas beaucoup d'importance, mais c'est un cas d'angle si vous vous souciez vraiment

Cependant, le mappage de la pile serait l'objectif d'un compilateur (s'il a une option pour cela).

EDIT: Après quelques tests sur une machine Debian x84_64, j'ai constaté que la pile se développe sans aucun appel système (selon strace). Donc, cela signifie que le noyau le fait croître automatiquement (c'est ce que signifie "implicite" ci-dessus), c'est-à-dire sans explicite mmap/ mremapdu processus.

Il était assez difficile de trouver des informations détaillées le confirmant. Je recommande de comprendre le gestionnaire de mémoire virtuelle Linux par Mel Gorman. Je suppose que la réponse se trouve dans la section 4.6.1 Gestion d'un défaut de page , à l'exception de "Région non valide mais à côté d'une région extensible comme la pile" et de l'action correspondante "Développez la région et allouez une page". Voir aussi D.5.2 Extension de la pile .

Autres références sur la gestion de la mémoire Linux (mais avec presque rien sur la pile):

• FAQ sur la mémoire
• Ce que tout programmeur doit savoir sur la mémoire par Ulrich Drepper

EDIT 2: Cette implémentation a un inconvénient: dans les cas d'angle, une collision pile-tas peut ne pas être détectée, même dans le cas où la pile serait plus grande que la limite! La raison en est qu'une écriture dans une variable de la pile peut se retrouver dans la mémoire de tas allouée, auquel cas il n'y a pas de défaut de page et le noyau ne peut pas savoir que la pile devait être étendue. Voir mon exemple dans la discussion Collision pile-tas silencieuse sous GNU / Linux que j'ai commencée dans la liste d'aide gcc. Pour éviter cela, le compilateur doit ajouter du code lors de l'appel de fonction; cela peut être fait avec -fstack-checkpour GCC (voir la réponse de Ian Lance Taylor et la page de manuel de GCC pour plus de détails).

Noyau Linux 4.2

• mm / mmap.c # acct_stack_growth décide s'il s'agit d'une erreur de segmentation ou non. Il utilise rlim[RLIMIT_STACK]ce qui correspond au POSIXgerlimit(RLIMIT_STACK)
• arch / x86 / mm / fault.c # do_page_fault est le gestionnaire d'interruption qui démarre une chaîne qui finit par appeleracct_stack_growth
• arch / x86 / entry / entry_64.S configure le gestionnaire de défauts de page. Vous devez en savoir un peu sur la pagination pour comprendre cette partie: Comment fonctionne la pagination x86? | Débordement de pile

Programme de test minimal

Nous pouvons ensuite le tester avec un programme NASM 64 bits minimal:

global _start
_start:
    sub rsp, 0x7FF000
    mov [rsp], rax
    mov rax, 60
    mov rdi, 0
    syscall

Assurez-vous que vous désactivez ASLR et supprimez les variables d'environnement car celles-ci iront sur la pile et prendront de l'espace:

echo 0 | sudo tee /proc/sys/kernel/randomize_va_space
env -i ./main.out

La limite est quelque part légèrement en dessous de ma ulimit -s(8 Mo pour moi). Il semble que cela soit dû aux données supplémentaires spécifiées par System V initialement placées sur la pile en plus de l'environnement: Paramètres de ligne de commande Linux 64 dans Assembly | Débordement de pile

Si vous êtes sérieux à ce sujet, TODO crée une image initrd minimale qui commence à écrire à partir du haut de la pile et descend, puis exécutez-la avec QEMU + GDB . Mettez un dprintfsur la boucle imprimant l'adresse de la pile et un point d'arrêt à acct_stack_growth. Ce sera glorieux.

En relation:

• /software/207386/how-are-the-size-of-the-stack-and-heap-limited-by-the-os
• D'où la mémoire de pile est-elle allouée pour un processus Linux? | Débordement de pile
• Qu'est-ce que la pile Linux? | Débordement de pile
• Quelle est la profondeur de récursivité maximale en Python et comment l'augmenter? sur Stack Overflow

Par défaut, la taille maximale de la pile est configurée pour être de 8 Mo par processus,
mais elle peut être modifiée à l'aide de ulimit:

Affichage de la valeur par défaut en Ko:

$ ulimit -s
8192

Réglez sur illimité:

ulimit -s unlimited

affectant le shell et les sous-shell actuels et leurs processus enfants.
( ulimitest une commande intégrée au shell)

Vous pouvez afficher la plage d'adresses de pile réelle utilisée avec:
cat /proc/$PID/maps | grep -F '[stack]'
sous Linux.