Что делает системный вызов brk ()?

Согласно руководству для программистов Linux:

brk () и sbrk () изменяют место остановки программы, которое определяет конец сегмента данных процесса.

Что означает сегмент данных здесь? Это просто сегмент данных или данные, BSS и куча вместе взятые?

Согласно вики:

Иногда данные, BSS и области кучи вместе называются «сегментом данных».

Я не вижу причин для изменения размера только сегмента данных. Если это данные, BSS и куча вместе, то это имеет смысл, поскольку куча получит больше места.

Что подводит меня ко второму вопросу. Во всех статьях, которые я до сих пор читал, автор говорит, что куча растет вверх, а стек - вниз. Но они не объясняют, что происходит, когда куча занимает все пространство между кучей и стеком?

На диаграмме, которую вы разместили, «разрыв» - адрес, которым манипулирует brkи sbrk- это пунктирная линия в верхней части кучи.

В прочитанной вами документации это описывается как конец «сегмента данных», потому что в традиционном (pre-shared-library, pre- mmap) Unix сегмент данных был непрерывным с кучей; перед запуском программы ядро ​​загружало бы блоки «текст» и «данные» в ОЗУ, начиная с нулевого адреса (фактически немного выше нулевого адреса, чтобы указатель NULL действительно ни на что не указывал), и устанавливал адрес прерывания равным конец сегмента данных. Первый вызов mallocзатем будет использоваться sbrkдля перемещения разбиения и создания кучи между вершиной сегмента данных и новым, более высоким адресом разбиения, как показано на схеме, а последующее использование mallocбудет использовать его для увеличения кучи. как надо.

Тем временем, стек начинается с верхней части памяти и уменьшается. Стек не нуждается в явных системных вызовах, чтобы увеличить его; либо он запускается с выделением для него столько оперативной памяти, сколько он может иметь (это был традиционный подход), либо область зарезервированных адресов под стеком, для которой ядро ​​автоматически выделяет ОЗУ, когда замечает попытку записи туда (это современный подход). В любом случае, в нижней части адресного пространства может быть или не быть «защитная» область, которую можно использовать для стека. Если этот регион существует (все современные системы делают это), он постоянно не отображается; если либостек или куча пытаются врасти в него, вы получаете ошибку сегментации. Традиционно, однако, ядро ​​не предпринимало попыток установить границы; стек может вырасти в кучу, или куча может вырасти в стек, и в любом случае они будут перебирать данные друг друга, и программа будет аварийно завершать работу. Если вам очень повезет, он сразу же потерпит крах.

Я не уверен, откуда исходит число 512 ГБ в этой диаграмме. Это подразумевает 64-битное виртуальное адресное пространство, которое несовместимо с очень простой картой памяти, которая у вас есть. Настоящее 64-битное адресное пространство выглядит примерно так:

              Legend:  t: text, d: data, b: BSS

Это не для удаленного масштабирования, и его не следует интерпретировать как то, что делает любая конкретная ОС (после того, как я нарисовал ее, я обнаружил, что Linux фактически помещает исполняемый файл гораздо ближе к нулевому адресу, чем я думал, и разделяемые библиотеки). по удивительно высоким адресам). Черные области на этой диаграмме не отображены - любой доступ вызывает немедленный сбой - и они гигантские по отношению к серым областям. Светло-серые области - это программа и ее общие библиотеки (могут быть десятки общих библиотек); у каждого есть независимыйсегмент текста и данных (и сегмент «bss», который также содержит глобальные данные, но инициализируется нулевыми битами, а не занимает место в исполняемом файле или библиотеке на диске). Куча больше не обязательно непрерывна с сегментом данных исполняемого файла - я нарисовал его таким образом, но, похоже, Linux, по крайней мере, этого не делает. Стек больше не привязан к вершине виртуального адресного пространства, а расстояние между кучей и стеком настолько велико, что вам не нужно беспокоиться о его пересечении.

Разрыв по-прежнему является верхним пределом кучи. Однако то, что я не показал, это то, что где-то в черном может быть множество независимых распределений памяти, сделанных mmapвместо brk. (ОС будет стараться держать их подальше от brkобласти, чтобы они не сталкивались.)

Минимальный исполняемый пример

Что делает системный вызов brk ()?

Просит ядро ​​разрешить вам читать и записывать в непрерывный кусок памяти, называемый кучей.

Если вы не спросите, это может вас обидеть.

Без 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;
}

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

GitHub вверх по течению .

Вышеприведенное может не попасть на новую страницу и не использовать segfault даже без brk, так что вот более агрессивная версия, которая выделяет 16MiB и очень вероятно, что segfault без brk:

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

int main(void) {
    void *b;
    char *p, *end;

    b = sbrk(0);
    p = (char *)b;
    end = p + 0x1000000;
    brk(end);
    while (p < end) {
        *(p++) = 1;
    }
    brk(b);
    return 0;
}

Проверено на Ubuntu 18.04.

Визуализация виртуального адресного пространства

До brk:

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

После brk(p + 2):

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

После brk(b):

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

Чтобы лучше понять адресные пространства, вы должны ознакомиться с подкачкой: как работает подкачка x86? ,

Зачем нам и то brkи другое sbrk?

brkконечно, может быть реализовано с помощью sbrkрасчетов + смещения, оба существуют просто для удобства.

В бэкэнде ядро ​​Linux v5.0 имеет единственный системный вызов, brkкоторый используется для реализации обоих: https://github.com/torvalds/linux/blob/v5.0/arch/x86/entry/syscalls/syscall_64. TBL # L23

12  common  brk         __x64_sys_brk

Такое brkPOSIX?

brkРаньше это был POSIX, но он был удален в POSIX 2001, поэтому необходимо _GNU_SOURCEбыло получить доступ к оболочке glibc.

Удаление, вероятно, связано с введением mmap, которое является надмножеством, позволяющим распределять несколько диапазонов и иметь больше возможностей выделения.

Я думаю, что нет действительного случая, когда вы должны использовать brkвместо mallocили в mmapнастоящее время.

brk против malloc

brkэто одна старая возможность реализации malloc.

mmapэто новый, более мощный механизм, который в настоящее время используют для реализации все системы POSIX malloc. Вот пример минимального выделения mmapпамяти для запуска .

Могу ли я смешать brkи Malloc?

Если ваш mallocреализован с помощью brk, я понятия не имею, как это может не взорвать вещи, так как brkуправляет только один диапазон памяти.

Однако я не смог найти что-либо об этом в документации по glibc, например:

• https://www.gnu.org/software/libc/manual/html_mono/libc.html#Resizing-the-Data-Segment

Вещи, скорее всего, просто будут работать там, я думаю, так mmapкак, вероятно, используется дляmalloc .

Смотрите также:

• Что небезопасно / наследие в brk / sbrk?
• Почему двойной вызов sbrk (0) дает другое значение?

Больше информации

Внутренне ядро ​​решает, может ли процесс иметь столько памяти, и выделяет страницы памяти для этого использования.

Это объясняет, как стек сравнивается с кучей: Какова функция инструкций push / pop, используемых для регистров в сборке x86?

Вы можете использовать brkи sbrkсебя, чтобы избежать "накладных расходов на malloc", на которые все всегда жалуются. Но вы не можете легко использовать этот метод в сочетании с, mallocтак что он подходит только тогда, когда вам ничего не нужно free. Потому что ты не можешь. Кроме того, вы должны избегать любых библиотечных вызовов, которые могут использоваться mallocвнутри. То есть. strlenвероятно безопасно, но fopenвероятно нет.

Звоните так sbrkже, как вы звоните malloc. Он возвращает указатель на текущий разрыв и увеличивает его на эту величину.

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

Несмотря на то, что вы не можете освободить отдельные выделения (потому что нет служебных данных malloc , помните), вы можете освободить все пространство , вызвав brkзначение, возвращаемое первым вызовом sbrk, таким образом, перематывая brk .

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

Вы могли бы даже сложить эти регионы, отбросив самый последний регион, перемотав разрыв в начало региона.

Еще кое-что ...

sbrkтакже полезно в коде гольф, потому что это на 2 символа короче, чем malloc.

Существует специальное обозначенное анонимное сопоставление частной памяти (традиционно расположенное сразу за data / bss, но современный Linux фактически отрегулирует местоположение с помощью ASLR). В принципе, это не лучше, чем любое другое сопоставление, которое вы могли бы создать mmap, но в Linux есть некоторые оптимизации, которые позволяют расширить конец этого сопоставления (с помощью brkсистемного вызова) вверх с уменьшенной стоимостью блокировки относительно того, что mmapили mremapможет возникнуть. Это делает его привлекательным для mallocреализации при реализации основной кучи.

Я могу ответить на ваш второй вопрос. Malloc потерпит неудачу и возвратит нулевой указатель. Вот почему вы всегда проверяете нулевой указатель при динамическом выделении памяти.

Куча помещается последней в сегменте данных программы. brk()используется для изменения (расширения) размера кучи. Когда куча больше не может расти, любой mallocвызов потерпит неудачу.

Сегмент данных - это часть памяти, которая содержит все ваши статические данные, считанные из исполняемого файла при запуске и обычно заполненные нулями.

malloc использует системный вызов brk для выделения памяти.

включают

int main(void){

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

запустите эту простую программу с помощью strace, она вызовет систему brk.