Пользовательский дизайн заголовка реализации malloc()

Для отладки malloc рассмотрите возможность добавления пробела между вашей управляющей структурой и началом пользовательских данных, а также между концом пользовательских данных и контрольной суммой. Один байт заполнения должен быть нулевым байтом 0x00, поэтому строковые операции останавливаются; подумайте о том, чтобы поставить другой как 0xFF. Если у вас есть фиксированный шаблон и вы заметили, что он изменился, вы знаете, что что-то вышло за пределы границ, но есть большая вероятность, что ваши конфиденциальные управляющие данные не были растоптаны. Если вы используете 16 байтов заполнения по обе стороны от пространства, выделенного пользователю, вы можете дойти до того, что поместите 4 байта нулей с соответствующим выравниванием (следовательно, нулевое 4-байтовое целое число) и, возможно, 0xFFFFFFFF для -1. Кроме того, поскольку вы, вероятно, округлите запрошенный размер до кратного размера вашего базового блока, установите известное значение для байтов, которые не предназначены для использования пользователем, и убедитесь, что они остаются неизменными. Это обнаружит модификации «один сверх выделенной длины» или всего несколько байтов сверх выделенной длины, которые в противном случае могут остаться незамеченными.

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

Другой вариант, который следует рассмотреть, — это попытка полностью отделить ваши управляющие данные от памяти, возвращаемой пользователю. Конечно, полное разделение невозможно, но, по крайней мере, поддерживайте список выделений (с размерами и указателями) отдельно от выделенных блоков. Опять же, это дает вам защиту, помещая ваши драгоценные управляющие данные дальше от неконтролируемых операций по вытаптыванию памяти. Вы не полностью защищены от ошибочных указателей, но вы защищены лучше. (И вы все еще можете обеспечить буферные зоны вокруг выделенного пространства для обнаружения неконтролируемой записи.) Однако этот дизайн заметно отличается от вопроса.

Предполагая, что вы получаете свой блок памяти от 'malloc()', вы должны сделать - примерно:

void *my_malloc(size_t nbytes)
{
    size_t reqblocks = (nbytes + sizeof(header) - 1) / sizeof(header);
    size_t reqspace  = (reqblocks + 2) * sizeof(header) + 2 * sizeof(padding);
    void *space = malloc(reqspace);
    if (space == 0)
        return space;
    void *retval = (char *)space + sizeof(header) + sizeof(padding);
    header *head = space;
    head->next = ...next...;
    head->size = nbytes;
    ...set head padding to chosen value...
    ...set tail padding to chosen value...
    ...set gap between nbytes and block boundary to chosen value...
    return retval;
}

Осталось интерпретировать...

я бы сделал что-то вроде

#define MEM_ALIGN 4 // 8 on 64b eventually

struct header {
    union aligned_header {
        struct _s {
            union aligned_header* next;
            size_t size;
        } data;
        char dummy_align_var[sizeof(struct _s) + sizeof(struct _s)%MEM_ALIGN];
    } header_data;
    char user_address;
};

и вернуть &user_address.

Почему вы используете союз? Просто используйте struct и верните &dummy_align_var пользователю в качестве начала свободного блока.

Да, и так как это для отладки, я предлагаю вам добавить mungwall: поместите 16 байт с каждой стороны пользовательской области и заполните их каким-нибудь шаблоном (например, 0xdeadbeef, повторенным четыре раза). Во время free() проверьте, чтобы эти байты не изменились.

[EDIT] Вот некоторый псевдокод:

struct header {
    struct header * next;
    unsigned size;
    // put mungwall here
    double user_data;
};

init()
    int blockSize = 1024;
    char * bigMem = original_malloc(blockSize);
    struct header * first = (struct header *)bigMem;
    first->next = NULL;
    first->size = blockSize - (sizeof(struct header) - sizeof(double));

Вы также можете объявить dummy_align_var как union header* prev, чтобы поместить свободные блоки памяти в двусвязный список.

Это очень помогает производительности, когда вы хотите объединить освобожденный блок с предыдущим и следующим черным цветом, если они тоже свободны.

Наконец, вы не упоминаете об этом, сохранение списка, отсортированного по размеру, позволяет быстрее найти лучший блок для выделения для данного запроса, в то время как сортировка по адресу упрощает объединение освобожденных блоков. Если вы хотите сделать и то, и другое, сделайте пользовательскую часть как минимум 3 header* большой, она будет соответствовать указателям, необходимым при освобождении блока.

В дополнение к границам, упомянутым Аароном, перезапишите освободившиеся буферы тем же шаблоном. Это облегчает распознавание кода, использующего уже освобожденные буферы.

Я предполагаю, что это было бы полезно: несколько лет назад мне нужно было сделать резервную копию средства malloc() для целей отладки (трассировщик распределения и т. Д.) ... И было довольно просто взять реализацию FreeBSD из их libstdc. Насколько я помню поздние выпуски FreeBSSD 5.0 ​​или даже 4.x, но забавно было то, что их средства были изолированы в простом библиотечном модуле malloc.o, поэтому перегрузка этого уровня была очень простой копией и вставкой, а реализация была действительно хорошей.

Вы действительно делаете всю эту работу? Да, это только для проверки, я не претендую на то, что это решение лучшее.

Вы можете использовать свой исходный союз, если хотите, например:

union header *hdr = malloc(total_size);
void *user_ptr = hdr + 1;
char *trailer_ptr = (char *)user_ptr + user_size;

Это установит user_ptr там, где начнется следующий union header, если блок malloced будет рассматриваться как массив этих объединений. Так что это значение, которое вы возвращаете пользователю.

Он также устанавливает trailer_ptr для указания на первый байт после выделения пользователем, где вы можете поместить свою контрольную сумму.

Если вы не хотите использовать malloc(), посмотрите на sbrk