Que fait l'appel de système brk ()?

Minimal praticable exemple

Qu'est-brk( ) de l'appel système?

demande au noyau de vous laisser lire et écrire à un morceau contigu de mémoire appelé le tas.

si vous ne le demandez pas, il pourrait vous segfault.

sans brk :

#define _GNU_SOURCE
#include <unistd.h>

int main(void) {
    /* Get the first address beyond the end of the heap. */
    void *b = sbrk(0);
    int *p = (int *)b;
    /* May segfault because it is outside of the heap. */
    *p = 1;
    return 0;
}

avec brk :

#define _GNU_SOURCE
#include <assert.h>
#include <unistd.h>

int main(void) {
    void *b = sbrk(0);
    int *p = (int *)b;

    /* Move it 2 ints forward */
    brk(p + 2);

    /* Use the ints. */
    *p = 1;
    *(p + 1) = 2;
    assert(*p == 1);
    assert(*(p + 1) == 2);

    /* Deallocate back. */
    brk(b);

    return 0;
}

testé sur Ubuntu 14.04.

l'espace d'adressage Virtuel de visualisation

avant brk :

+------+ <-- Heap Start == Heap End

après brk(p + 2) :

+------+ <-- Heap Start + 2 * sizof(int) == Heap End 
|      |
| You can now write your ints
| in this memory area.
|      |
+------+ <-- Heap Start

après brk(b) :

+------+ <-- Heap Start == Heap End

pour mieux comprendre les espaces d'adresse, vous devez vous familiariser avec la pagination: Comment fonctionne la pagination x86?

plus d'informations

brk utilisé pour être POSIX, mais il a été supprimé dans POSIX 2001, donc la nécessité de _GNU_SOURCE pour accéder à l'emballage glibc.

la suppression est probablement due à l'introduction mmap , qui est un super-ensemble qui permet d'attribuer plusieurs plages et plus d'options d'attribution.

à l'intérieur, le noyau décide si le processus peut avoir beaucoup de mémoire, et consacre pages de mémoire pour cet usage.

brk et mmap , telles sont les mécanismes sous-jacents de la libc utilise pour mettre en œuvre malloc dans POSIX systèmes.

cela explique comment la pile se compare au tas: Quelle est la fonction des instructions push / pop utilisées sur les registres dans l'assemblage x86?

vous pouvez utiliser brk et sbrk vous-même pour éviter le" malloc overhead " dont tout le monde se plaint. Mais vous ne pouvez pas facilement utiliser cette méthode en conjonction avec malloc donc il est seulement approprié quand vous n'avez pas à free quoi que ce soit. Parce que tu ne peux pas. De plus, vous devez éviter tout appel de bibliothèque qui pourrait utiliser malloc en interne. IE. strlen est probablement sans danger, mais fopen ne l'est probablement pas.

Appel sbrk tout comme vous appelleriez malloc . Elle renvoie un pointeur sur l'actuel et incrémente la rupture de ce montant.

void *myallocate(int n){
    return sbrk(n);
}

alors que vous ne pouvez pas libérer des allocations individuelles (parce qu'il n'y a pas de malloc-overhead , rappelez-vous), vous can libre l'espace entier en appelant brk avec la valeur retournée par le premier appel à sbrk , donc rembobinage de la brk .

void *memorypool;
void initmemorypool(void){
    memorypool = sbrk(0);
}
void resetmemorypool(void){
    brk(memorypool);
}

vous pourriez même empiler ces régions, en rejetant la région la plus récente en rembobinant la pause au début de la région.

une dernière chose ...

sbrk est également utile dans code golf parce que c'est 2 caractères plus court que malloc .

il y a une carte mémoire privée anonyme spéciale désignée (traditionnellement situé juste au-delà des données/bss, mais Linux moderne va effectivement ajuster l'emplacement avec ASLR). En principe , ce n'est pas mieux que n'importe quelle autre cartographie que vous pourriez créer avec mmap , mais Linux a quelques optimisations qui permettent d'étendre la fin de cette cartographie (en utilisant le brk syscall) vers le haut avec un coût de verrouillage réduit par rapport à ce que mmap ou mremap entraînerait. Cela rend attrayant pour les implémentations malloc d'utiliser lors de la mise en œuvre du tas principal.

je peux répondre à votre deuxième question. Malloc échouera et retournera un pointeur nul. C'est pourquoi vous vérifiez toujours un pointeur null lors de l'allocation dynamique de la mémoire.

le tas est placé en dernier dans le segment de données du programme. brk() est utilisé pour changer (étendre) la taille du tas. Lorsque le tas ne peut plus croître, tout appel malloc échouera.

le segment de données est la partie de la mémoire qui contient toutes vos données statiques, lue à partir de l'exécutable au lancement et généralement remplie de zéro.

malloc utilise l'appel système brk pour allouer la mémoire.

inclure

int main(void){

char *a = malloc(10); 
return 0;
}

exécuter ce programme simple avec strace, il appellera système brk.

1. l'appel système qui traite l'allocation de mémoire est sbrk(2) . Il augmente ou diminue l'espace d'adressage du processus par un nombre spécifié d'octets.

2. la fonction d'allocation de mémoire, malloc(3) , implémente un type particulier d'allocation. La fonction malloc() , qui utilisera probablement l'appel système sbrk() .

l'appel système sbrk(2) dans le kernel attribue un morceau supplémentaire d'espace au nom du processus. La fonction de bibliothèque malloc() gère cet espace à partir de niveau utilisateur .