¿Qué hace la llamada al sistema brk ()?

Ejemplo ejecutable mínimo

¿Qué hace la llamada al sistema brk ()?

Le pide al núcleo que le permita leer y escribir en un trozo de memoria contiguo llamado heap.

Si no preguntas, podría segmentarte.

Sin 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;
}

Con 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;
}

Probado en Ubuntu 14.04.

Visualización del espacio de direcciones virtuales

Antes de brk:

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

Después brk(p + 2):

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

Después de brk(b):

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

Para comprender mejor los espacios de direcciones, debe familiarizarse con la paginación: ¿Cómo funciona la paginación x86?

Más información

brk solía ser POSIX, pero fue eliminado en POSIX 2001, por lo tanto la necesidad de _GNU_SOURCE para acceder a la envoltura glibc.

Es probable que la eliminación se deba a la introducción mmap, que es un superconjunto que permite asignar múltiples rangos y más asignaciones opcion.

Internamente, el núcleo decide si el proceso puede tener esa cantidad de memoria, y asigna páginas de memoria para ese uso.

brk y mmap son los mecanismos subyacentes comunes que libc utiliza para implementar malloc en sistemas POSIX.

Esto explica cómo se compara la pila con el montón: ¿Cuál es la función de las instrucciones push / pop utilizadas en los registros en el ensamblaje x86?

Puede usar brk y sbrk usted mismo para evitar la "sobrecarga malloc" de la que todos se quejan. Pero no puede usar fácilmente este método en conjunción con malloc, por lo que solo es apropiado cuando no tiene que free nada. Además, debe evitar cualquier llamada a la biblioteca que pueda usar malloc internamente. IE. strlen es probablemente seguro, pero fopen probablemente no lo es.

Llama a sbrk al igual que llamarías a malloc. Devuelve un puntero al salto actual e incrementa el descanso por esa cantidad.

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

Mientras que no puedes liberar asignaciones individuales (porque no hay malloc-overhead, recuerda), puedes liberar todo el espacio llamando a brk con el valor devuelto por la primera llamada a sbrk, por lo tanto rebobinando el brk.

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

Incluso podría apilar estas regiones, descartando la región más reciente rebobinando la ruptura al inicio de la región.

Una cosa más ...

sbrk también es útil en code golf porque es 2 caracteres más corto que malloc.

Hay una asignación de memoria privada anónima designada especial (tradicionalmente ubicada justo más allá de los datos/bss, pero Linux moderno realmente ajustará la ubicación con ASLR). En principio no es mejor que cualquier otra asignación que pueda crear con mmap, pero Linux tiene algunas optimizaciones que permiten expandir el final de esta asignación (usando la llamada syscall brk) hacia arriba con un costo de bloqueo reducido en relación con lo que incurriría mmap o mremap. Esto lo hace atractivo para malloc implementaciones a utilizar al implementar el montón principal.

Puedo responder a su segunda pregunta. Malloc fallará y devolverá un puntero nulo. Es por eso que siempre busca un puntero nulo cuando asigna memoria dinámicamente.

El montón se coloca en último lugar en el segmento de datos del programa. brk() se usa para cambiar (expandir) el tamaño del montón. Cuando el montón no puede crecer más, cualquier llamada malloc fallará.

El segmento de datos es la porción de memoria que contiene todos sus datos estáticos, leídos desde el ejecutable en el lanzamiento y generalmente llenos de cero.

Malloc utiliza la llamada al sistema brk para asignar memoria.

Incluye

int main(void){

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

Ejecute este sencillo programa con strace, llamará al sistema brk.

1. La llamada al sistema que maneja la asignación de memoria es sbrk(2). Aumenta o disminuye el espacio de direcciones del proceso en un número especificado de bytes.

2. La función de asignación de memoria, malloc(3), implementa un tipo particular de asignación. malloc() función, que probablemente utilizará la llamada al sistema sbrk().

La llamada al sistema sbrk(2) en el núcleo asigna una porción adicional de espacio en nombre del proceso. La función de biblioteca malloc() administra este espacio desde nivel de usuario.