Valgrind: как найти утечку памяти и ошибку в работе с памятью

Как запустить valgrind, читать Invalid read и Invalid write, найти неинициализированное значение и утечку и что делать на Mac, где valgrind не работает.

Программа на C печатает правильный ответ, а преподаватель запускает её под valgrind и возвращает с пометкой «утечка памяти» или «Invalid read». Ошибки с памятью часто не видны при обычном запуске: запись на байт дальше массива ничего не ломает сегодня, а завтра на другой машине программа падает. Valgrind (точнее, его инструмент Memcheck) следит за каждым обращением к памяти и сообщает о таких ошибках с номером строки. Ниже настоящий отчёт по программе с четырьмя типичными ошибками из лабораторных про динамическую память, разбор каждого сообщения и исправление. Отчёты сняты в Debian 12 с valgrind 3.19; адреса и номера процессов у вас будут другими.

Установка и первый запуск

sudo apt install valgrind
gcc -g -O0 -Wall -Wextra marks.c -o marks
valgrind --leak-check=full ./marks

Флаг -g нужен, чтобы в отчёте были имена файлов и номера строк. -O0 убирает оптимизации, с ними номера строк бывают неточными. Аргументы и ввод передаются как обычно: valgrind --leak-check=full ./marks data.txt < input.txt.

Под valgrind программа работает примерно в 20–30 раз медленнее (Valgrind Quick Start), поэтому проверяйте её на маленьких входных данных. Строки отчёта начинаются с номера процесса вида ==16==, вывод самой программы идёт вперемешку с ними. Длинный отчёт удобно писать в файл: --log-file=vg.txt.

Программа с ошибками

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

struct student {
    char *name;
    int *marks;
    int count;
};

struct student *make_student(const char *name, int count) {
    struct student *s = malloc(sizeof *s);
    s->name = malloc(strlen(name));
    strcpy(s->name, name);
    s->marks = malloc(count * sizeof(int));
    s->count = count;
    return s;
}

double average(const struct student *s) {
    int sum = 0;
    for (int i = 0; i <= s->count; i++)
        sum += s->marks[i];
    return (double) sum / s->count;
}

int main(void) {
    struct student *s = make_student("Vera", 3);
    s->marks[0] = 5;
    s->marks[1] = 4;
    printf("%s: %.2f\n", s->name, average(s));
    return 0;
}

Компилятор с -Wall -Wextra молчит, программа печатает Vera: 3.00 и завершается с кодом 0. Под valgrind у нас вышло ERROR SUMMARY: 87 errors from 63 contexts, на другой системе число будет другим. Разберём отчёт сверху вниз: нижние сообщения часто оказываются следствием верхних.

Invalid write: запись за концом блока

==16== Invalid write of size 1
==16==    at 0x488B408: strcpy (in /usr/libexec/valgrind/vgpreload_memcheck-arm64-linux.so)
==16==    by 0x108897: make_student (marks.c:14)
==16==    by 0x10895B: main (marks.c:28)
==16==  Address 0x4a6f0a4 is 0 bytes after a block of size 4 alloc'd
==16==    at 0x48850C8: malloc (in /usr/libexec/valgrind/vgpreload_memcheck-arm64-linux.so)
==16==    by 0x10887B: make_student (marks.c:13)
==16==    by 0x10895B: main (marks.c:28)

Каждое сообщение устроено одинаково:

  1. Что случилось: запись (write) размером 1 байт туда, куда нельзя.
  2. Стек вызовов: at там, где это произошло, by кто вызвал. Ищите первую строку со своим файлом: make_student (marks.c:14).
  3. Где эта память: 0 bytes after a block of size 4, то есть сразу за концом блока из 4 байт, выделенного в строке 13.

В строке 13 выделено strlen("Vera"), то есть 4 байта, а strcpy копирует 5: четыре буквы и завершающий '\0'. Исправление: malloc(strlen(name) + 1).

Чуть ниже в отчёте есть Invalid read of size 1 внутри strlen и printf с адресом того же блока. Это та же ошибка: строка без места под '\0', и printf читает за её концом. После первого исправления она исчезнет сама.

Invalid read: чтение за концом массива

==16== Invalid read of size 4
==16==    at 0x1088F0: average (marks.c:23)
==16==    by 0x108993: main (marks.c:31)
==16==  Address 0x4a6f0fc is 0 bytes after a block of size 12 alloc'd
==16==    at 0x48850C8: malloc (in /usr/libexec/valgrind/vgpreload_memcheck-arm64-linux.so)
==16==    by 0x1088A3: make_student (marks.c:15)
==16==    by 0x10895B: main (marks.c:28)

Читаем 4 байта, это один int, сразу за блоком в 12 байт. Блок на три оценки, а цикл i <= s->count берёт четвёртую, marks[3]. Нужно i < s->count. Без valgrind эта ошибка просто подмешивает в сумму случайное число.

Неинициализированное значение и --track-origins

Дальше идут десятки сообщений вида:

==16== Conditional jump or move depends on uninitialised value(s)
==16==    at 0x490D830: __printf_fp_l (printf_fp.c:396)
==16==    by 0x49169C7: __printf_fp_spec (vfprintf-internal.c:354)
==16==    by 0x49169C7: __vfprintf_internal (vfprintf-internal.c:1061)
==16==    by 0x490D077: printf (printf.c:33)
==16==    by 0x1089A3: main (marks.c:31)

Внутри printf ошибки нет. Memcheck не ругается, когда неинициализированное значение копируют или складывают. Он сообщает, когда от такого значения зависит условный переход, адрес памяти или системный вызов (руководство Memcheck). Мусор попал в sum, оттуда в результат average, и всплыл только при печати числа. Похожие сообщения Use of uninitialised value of size 8 и Syscall param write(buf) points to uninitialised byte(s) в этом отчёте значат то же самое.

Откуда взялся мусор, показывает флаг --track-origins=yes:

valgrind --leak-check=full --track-origins=yes ./marks
==15== Conditional jump or move depends on uninitialised value(s)
==15==    at 0x490D830: __printf_fp_l (printf_fp.c:396)
...
==15==    by 0x1089A3: main (marks.c:31)
==15==  Uninitialised value was created by a heap allocation
==15==    at 0x48850C8: malloc (in /usr/libexec/valgrind/vgpreload_memcheck-arm64-linux.so)
==15==    by 0x1088A3: make_student (marks.c:15)

Мусор пришёл из блока оценок, выделенного в строке 15: marks[2] никто не заполнил, а malloc память не обнуляет. Исправление: заполнить все оценки или выделять через calloc, который обнуляет блок. Если переменная локальная, например int max; без начального значения, valgrind напишет created by a stack allocation и укажет функцию. Флаг замедляет проверку примерно вдвое, поэтому по умолчанию он выключен.

Утечки: definitely, indirectly, possibly, still reachable

Бумажные коробки привязаны нитками к колышкам, одна нитка оборвана, и коробка улетает, как воздушный шар

В конце отчёта сводка по куче:

==16== HEAP SUMMARY:
==16==     in use at exit: 40 bytes in 3 blocks
==16==   total heap usage: 4 allocs, 1 frees, 4,136 bytes allocated
==16==
==16== 40 (24 direct, 16 indirect) bytes in 1 blocks are definitely lost in loss record 3 of 3
==16==    at 0x48850C8: malloc (in /usr/libexec/valgrind/vgpreload_memcheck-arm64-linux.so)
==16==    by 0x10886B: make_student (marks.c:12)
==16==    by 0x10895B: main (marks.c:28)
==16==
==16== LEAK SUMMARY:
==16==    definitely lost: 24 bytes in 1 blocks
==16==    indirectly lost: 16 bytes in 2 blocks
==16==      possibly lost: 0 bytes in 0 blocks
==16==    still reachable: 0 bytes in 0 blocks

Структура student занимает 24 байта, на неё указывала только переменная s в main, и при выходе этот указатель пропал. Это definitely lost. Имя (4 байта) и оценки (12 байт) не потеряны сами по себе: указатели на них лежат внутри потерянной структуры. Поэтому они indirectly lost. Одно free(s) не поможет: тогда имя и оценки станут definitely lost. Освобождать нужно изнутри наружу.

Одна аллокация из четырёх в total heap usage не ваша: 4096 байт это буфер, который printf выделяет под стандартный вывод. Библиотека освобождает его сама.

Вид Что значит Что делать
definitely lost на блок не осталось ни одного указателя настоящая утечка, добавьте free
indirectly lost указатели на блок есть только внутри потерянных блоков исправьте утечку «родителя» и освободите вложенное
possibly lost остался указатель только в середину блока проверьте, не сдвигали ли вы указатель, полученный от malloc
still reachable указатель жив до конца программы, но free не вызван формально не ошибка, но в учебных задачах обычно требуют освобождать всё

possibly lost получается, например, если сохранить buf + 10 в глобальную переменную, а сам buf потерять. still reachable бывает у глобальных указателей на неосвобождённую память. Подробности по нему valgrind по умолчанию не печатает, их включает --show-leak-kinds=all.

Обращение к освобождённой памяти

Ещё две ошибки, которые встречаются постоянно: чтение после free и повторный free.

==21== Invalid read of size 4
==21==    at 0x108840: main (uaf.c:7)
==21==  Address 0x4a6f040 is 0 bytes inside a block of size 12 free'd
==21==    at 0x4887B40: free (in /usr/libexec/valgrind/vgpreload_memcheck-arm64-linux.so)
==21==    by 0x10883B: main (uaf.c:6)
==21==  Block was alloc'd at
==21==    at 0x48850C8: malloc (in /usr/libexec/valgrind/vgpreload_memcheck-arm64-linux.so)
==21==    by 0x108823: main (uaf.c:4)
==21==
==21== Invalid free() / delete / delete[] / realloc()

Здесь три места сразу: где читали (строка 7), где освободили (строка 6) и где выделили (строка 4). Привычка, которая убирает обе ошибки: после free(p) писать p = NULL. Разыменование NULL падает сразу и честно, а free(NULL) ничего не делает.

Исправленная программа

struct student *make_student(const char *name, int count) {
    struct student *s = malloc(sizeof *s);
    s->name = malloc(strlen(name) + 1);
    strcpy(s->name, name);
    s->marks = calloc(count, sizeof(int));
    s->count = count;
    return s;
}

void free_student(struct student *s) {
    free(s->name);
    free(s->marks);
    free(s);
}

double average(const struct student *s) {
    int sum = 0;
    for (int i = 0; i < s->count; i++)
        sum += s->marks[i];
    return (double) sum / s->count;
}

int main(void) {
    struct student *s = make_student("Vera", 3);
    s->marks[0] = 5;
    s->marks[1] = 4;
    s->marks[2] = 5;
    printf("%s: %.2f\n", s->name, average(s));
    free_student(s);
    return 0;
}
Vera: 4.67
==15== HEAP SUMMARY:
==15==     in use at exit: 0 bytes in 0 blocks
==15==   total heap usage: 4 allocs, 4 frees, 4,137 bytes allocated
==15==
==15== All heap blocks were freed -- no leaks are possible
==15==
==15== ERROR SUMMARY: 0 errors from 0 contexts (suppressed: 0 from 0)

Вот такой отчёт и нужен: ноль ошибок и All heap blocks were freed. В реальной программе стоит ещё проверять, что malloc не вернул NULL.

Флаги, которые пригодятся

valgrind --leak-check=full --show-leak-kinds=all --track-origins=yes \
         --error-exitcode=1 --log-file=vg.txt ./marks
  • --leak-check=full показывает, где выделена каждая утечка;
  • --show-leak-kinds=all добавляет still reachable;
  • --track-origins=yes ищет источник неинициализированных значений;
  • --error-exitcode=1 делает код выхода 1, если ошибки нашлись. Удобно в скрипте или Makefile: проверка «упадёт», а не пролистнётся;
  • -q печатает только ошибки, без шапки и сводки.

Почему не вместе с -fsanitize

Санитайзер -fsanitize=address (ASan) встраивает проверки в саму программу и подменяет malloc. Valgrind тоже подменяет malloc и следит за памятью по-своему. Вместе они не работают. Мы собрали marks.c с -fsanitize=address и запустили под valgrind:

==28== ASan runtime does not come first in initial library list; you should either link runtime to your application or manually preload it with LD_PRELOAD.
==28== HEAP SUMMARY:
==28==     in use at exit: 0 bytes in 0 blocks
==28==   total heap usage: 0 allocs, 0 frees, 0 bytes allocated
==28==
==28== All heap blocks were freed -- no leaks are possible

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

У каждого инструмента своя сильная сторона. ASan замедляет программу примерно в 2 раза (документация Clang) и ловит выход за границы массивов в куче, на стеке и в глобальных переменных. Чтения неинициализированной памяти в этом списке нет, его находит valgrind. Если есть время, прогоните программу обоими способами по очереди.

Valgrind на Mac и в Windows

Valgrind официально поддерживает macOS только на Intel и только старые версии, Mac на процессорах Apple в списке нет (платформы Valgrind). Что работает на Mac (мы проверили на macOS 26 с Apple Silicon):

  • clang -g -fsanitize=address marks.c -o marks находит запись за границей и обращение к освобождённой памяти. Поиск утечек в ASan здесь не включается: ASAN_OPTIONS=detect_leaks=1 отвечает detect_leaks is not supported on this platform.
  • Утечки показывает утилита leaks из инструментов Xcode: leaks --atExit -- ./marks. На маленькой программе с одним забытым malloc(32) она напечатала 1 leak for 48 total leaked bytes и строку main + 32 leak.c:4. Размер округлил системный аллокатор, поэтому вместо 32 байт показано 48.

В Windows проще всего поставить WSL: внутри обычный Linux, и valgrind ставится той же командой sudo apt install valgrind.

Как это решает Tilpi

Исполнитель Tilpi собирает и запускает программу в отдельной изолированной машине, где уже стоят gcc, g++, gdb и valgrind, так что проверка памяти доступна и с Mac, и с телефона. Он ищет ошибки, предлагает исправления и собирает отчёт о проверке в Word и PDF. Исполнитель входит во все тарифы: в «Лайт» и «Стандарт» на уровне «Быстрая», в «Плюс» на всех уровнях, а без тарифа работает на «Быстрой» из бесплатных ежемесячных кредитов, общих с чатом.

Запустим ваш код. Даже с телефона.

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

Проверить программу на утечки в Tilpi