Утечка памяти остаётся одной из самых коварных неисправностей серверного ПО: процесс исправно отвечает на запросы, тесты зелёные, а через неделю работы контейнер упирается в лимит и его добивает OOM killer. Особенно остро проблема стоит в C и C++, где за каждый байт отвечает программист, однако подтекает и Go при удержании горутин, и Python с циклическими ссылками, и Java при неудачном кэшировании. В статье собран рабочий набор инструментов от procfs и pmap до Valgrind, AddressSanitizer и heaptrack, а также методика, которая помогает локализовать утечку и в лаборатории, и на работающем сервисе без долгого простоя.
Первые симптомы утечки в работающем процессе
Классическая картина: потребление RSS растёт линейно со временем и не возвращается после снижения нагрузки. Если бы память освобождалась под давлением аллокатора, график напоминал бы пилу с просадками, но при утечке линия ползёт вверх ровно и безучастно к пикам трафика. Косвенные признаки: рост времени отклика из-за давления на страничный кэш, уход процесса в swap, участившиеся сборки мусора в рантаймах с GC, записи об убийстве в dmesg.
dmesg -T | grep -i "killed process"
journalctl -k --since "1 day ago" | grep -i oom
В контейнерах лимит cgroup делает утечку заметной раньше: при подходе к границе ядро убивает процесс, и в журнале видна оценка потребления на момент гибели. Для быстрого осмотра годятся top с сортировкой по резидентной памяти, htop и atop с записью истории, но для точных значений лучше сразу идти в procfs.
Перед дальнейшей работой стоит отделить настоящую утечку от безобидного роста. Память может занимать прогретый кэш ответов, пул соединений, раздутые арены glibc malloc при большой многопоточности, страницы под содержимое mmap-файлов. Надёжный признак утечки: Resident Set Size монотонно растёт даже на неизменной нагрузке, не уменьшается после часа простоя, а его производная по времени остаётся положительной в течение суток. Отдельная история - медленные утечки по нескольку мегабайт в сутки: в коротком тесте их не видно, зато на графике за месяц они очевидны, поэтому системе мониторинга полезен алерт не только на абсолютный лимит, но и на наклон линии за последние сутки.
Счётчики procfs и утилита pmap для наблюдения
Базовые метрики лежат в procfs и доступны без установки чего-либо. В файле /proc/PID/status ключевые поля: VmRSS показывает резидентную память, VmHWM пик за жизнь процесса, VmSwap выгруженные страницы. VSZ отличается от RSS тем, что включает зарезервированные отображения и адресные пространства потоков, поэтому ровный VSZ при растущем RSS точнее указывает на кучу, а растущий VSZ при ровном RSS часто означает лишь новые арены malloc или стеки потоков.
grep -E "VmRSS|VmHWM|VmSwap|Threads" /proc/$PID/status
watch -n 30 "grep -E 'VmRSS|VmHWM' /proc/$PID/status"
Карта отображений из pmap помогает понять, какая именно область растёт:
pmap -x $PID | sort -k3 -n | tail -25
awk "/^Rss:/ {rss+=\$2} END {print rss}" /proc/$PID/smaps
Развёрнутая версия тех же значений живёт в /proc/PID/smaps_rollup: там суммарные Rss, Pss, Private_Dirty и Anonymous по всему процессу, а файл /proc/PID/smaps даёт разбивку по каждому отображению. Рост анонимной частной памяти почти всегда означает кучу или аллокации через mmap, рост в файловых отображениях говорит о работе с большими файлами. Показатель Pss учитывает разделяемые страницы пропорционально числу процессов и хорошо ложится на графики агрегированного потребления хоста, утилита smem выводит те же величины с удобной сортировкой.
Разница между Private_Dirty и Shared_Dirty подсказывает природу роста: частные грязные страницы копит аллокатор процесса, разделяемые принадлежат общим библиотекам и mmap-файлам. Для сравнения удобно снять smaps в файл до и после нагрузочного прогона и посмотреть разницу:
cp /proc/$PID/smaps /tmp/before.txt
# run the load here
cp /proc/$PID/smaps /tmp/after.txt
diff /tmp/before.txt /tmp/after.txt | grep -B4 Rss
Отображения, у которых Rss подрос на сотни мегабайт, сразу выдают адрес, размер и права, а по адресу уже видно, куча это или отдельный mmap. Для истории метрики собирают node_exporter, telegraf или простой cron-скрипт, пишущий значения в rrd. Утечка в 10 МБ в час на глаз не видна, зато на графике за сутки она превращается в наклонную линию.
Valgrind Memcheck и Massif для тщательного офлайн разбора
Valgrind исполняет программу на собственной виртуальной машине и потому даёт максимально точную картину, хоть и замедляет её в десятки раз. Memcheck перехватывает каждый вызов malloc, calloc, realloc и free, отслеживает обращения к неинициализированной памяти, двойные освобождения и чтения за границей блока:
valgrind --tool=memcheck --leak-check=full --show-leak-kinds=all \
--track-origins=yes --num-callers=25 --log-file=memcheck.log ./app --port 8080
Итоговый отчёт делит потерянные блоки на категории: definitely lost указывает на настоящую утечку без сохранившихся ссылок, indirectly lost связана с ней, still reachable означает, что указатель жив до конца процесса, например в статическом кэше, а possible lost подсвечивает вероятные потери с частично разрушенными цепочками. Для каждого блока печатается полный стек аллокации, поэтому место в коде находится за минуты. В глубоких библиотеках со своими аллокаторами помогают файлы подавлений --suppressions, флаг --fair-sched=yes стабилизирует поведение многопоточных программ, а --leak-check=summary ускоряет прогон, когда интересует только величина потерь.
Massif отвечает на вопрос, кто именно раздувает пик потребления:
valgrind --tool=massif --time-unit=B ./app
ms_print massif.out.12345 | less
Профиль представляет собой серию снапшотов кучи и стека по ходу выполнения с деревьями вызовов. Приём, экономящий часы: снять профиль на коротком интервале в начале и после суточного прогона, затем сравнить стеки на верхушке графика, разница покажет, какой код накопил новые мегабайты. Запуск под Valgrind хорошо сочетается с реальным трафиком: стенд получает копию рабочего профиля, а флаг --vgdb=yes позволяет в любой момент подсоединить gdb и осмотреть состояние программы, не прерывая запись отчёта. Воспроизводимость здесь важнее скорости: фиксированный seed генератора, стабильный сценарий и одинаковый порядок запросов делают сравнение двух прогонов осмысленным.
Адресные санитайзеры GCC и Clang для быстрой проверки
AddressSanitizer встраивается компилятором в бинарник и ловит ошибки на скорости, близкой к обычной, что делает его главным инструментом в CI:
gcc -fsanitize=address -g -O1 -o app app.c
ASAN_OPTIONS=detect_leaks=1:halt_on_error=0 ./app
LeakSanitizer входит в состав ASan на Linux и включён по умолчанию: при завершении процесса он сканирует память, регистры и стек, ищет указатели на блоки, которые никто не освободил, и печатает стек аллокации каждого блока. Для программ, которым полный ASan не подходит, существует отдельный режим -fsanitize=leak, требующий лишь перехвата аллокатора. Типовой отчёт выглядит так:
==12345==ERROR: LeakSanitizer: detected memory leaks
Direct leak of 4096 byte(s) in 1 object(s) allocated from:
#0 0x4011e9 in malloc
#1 0x402a1c in buf_new src/buf.c:27
Механика детектора стоит внимания: вокруг каждого блока создаётся красная зона, освободившиеся блоки попадают в карантин и не переиспользуются сразу, поэтому запись за границей или обращение к мёртвому объекту ловится в моменте, а не спустя часы. Опция malloc_context_size=30 удлиняет стеки в отчётах, log_path уводит их в файл, что удобно для фоновых прогонов. Накладные расходы примерно двукратные по времени и заметные по памяти, зато нагрузочные тесты, которые под Valgrind шли бы часами, проходят минуты. Санитайзер ловит не только утечки, но и use-after-free, что часто вскрывает первопричину: блок освобождён, а указатель на него остался в глобальном кэше. Полезны опции LSAN_OPTIONS для порога отчёта и списка подавлений, а также функция __lsan_do_recoverable_leak_check() для проверки посреди работы программы без её остановки. Сторонние бинарники без инструментирования ASan не проверяет, для них остаются Valgrind и heaptrack.
Heaptrack и графики пламени для живых аллокаций
heaptrack отслеживает каждую аллокацию с небольшим оверхедом через LD_PRELOAD и разворачивание стека, не требуя пересборки приложения:
heaptrack -o /tmp/app ./app
heaptrack_print heaptrack.app.12345.gz | less
heaptrack_gui heaptrack.app.12345.gz
Инструмент показывает пиковое потребление с точным стеком, где пик достигнут, число живых блоков и суммарно утёкшие байты, а также временные ряды. Отчёты heaptrack_print и heaptrack_gui строят деревья вызовов и графы пламени, где сразу видно, какая функция накопила гигабайты, а какие лишь шуршат кратковременными буферами. Скорость работы позволяет гонять инструмент под реальной нагрузкой в стенде, а фильтры по стекам отсеивают шум от библиотечных аллокаций. Отдельный плюс heaptrack: он сохраняет все события в файл, поэтому один прогон можно разбирать многократно и передавать файл коллегам для самостоятельного изучения.
Ключевые метрики отчёта стоит различать: peak отвечает за потенциал сжатия рабочей области, leaked - за настоящие потери, а временные всплески показывают, какие буферы живут секунды и не опасны. Сравнение двух файлов после правки кода служит объективной проверкой: стеки из списка утёкших должны перейти в список кратковременных. Для других рантаймов работают аналоги с той же идеей: memray для Python с живыми графиками, pprof для Go, async-profiler с захватом malloc для JVM. Общий принцип один: смотреть не на моментальные счётчики, а на стеки живых объектов и их динамику между снапшотами.
Аллокаторы jemalloc и tcmalloc с готовой статистикой
Если приложение собрано с jemalloc, сэмплирующий профилировщик уже внутри и включается переменной окружения:
export MALLOC_CONF=prof:true,lg_prof_interval:30,lg_prof_sample:17
./app
jeprof --show_bytes --pdf ./app jeprof.12345.0.i0.heap > prof.pdf
jemalloc сэмплирует часть аллокаций и строит стеки живых блоков, дампы снимаются автоматически по достижении интервала или вручную через mallctl("prof.dump"). tcmalloc предлагает симметричное решение: переменная HEAPPROFILE включает запись снапшотов, а утилита pprof разбирает их и строит графы с процентами. Оверхед сэмплирования обычно доли процента, поэтому профилирование можно держать включённым на стенде неделями, накапливая доказательную базу вместо догадок. Текущую статистику jemalloc в рантайме читают через mallctl("stats.allocated") и экспортируют в мониторинг, что даёт быстрый ответ на вопрос, растёт ли куча прямо сейчас.
Для бинарников, собранных с системным glibc, аллокатор подменяется без пересборки:
LD_PRELOAD=/usr/lib/x86_64-linux-gnu/libjemalloc.so.2 ./app
Такой приём выручает и на стороннем ПО, исходники которого недоступны: статистика арен, пик потребления и возврат страниц появляются сразу после запуска. Бонус к профилированию: те же аллокаторы дают управление числом арен и агрессивный возврат памяти системе, что снижает шум от фрагментации при многопоточной нагрузке и делает график RSS честнее.
Методика локализации утечки на работающем сервисе
Порядок действий, который сходится в большинстве инцидентов:
- Зафиксировать базовую линию: снять VmRSS, VmHWM, VmSwap и объём анонимной памяти, настроить непрерывную запись в мониторинг; без истории рост в 5 МБ в час не отличить от суточных колебаний.
- Воспроизвести утечку под нагрузкой: прогнать типовой профиль трафика в стенде и наблюдать наклон графика; повторяемость резко сужает круг подозреваемых модулей.
- Снять два снапшота аллокаций с интервалом и сравнить: разность стеков между точками показывает, какой код копит память; для этого подходят heaptrack, профили jemalloc или повторный запуск под Valgrind на коротком интервале.
- Подключиться к живому процессу минимально инвазивно: gcore для снимка памяти, gdb для осмотра арен и очередей, pmap в динамике; рестарт по возможности отложить, чтобы не потерять воспроизводимое состояние.
- Исправить и проверить: закрыть утечку, затем прогнать тот же сценарий под ASan или Valgrind, убедиться, что definitely lost равен нулю, а график RSS вышел на плато;
- Закрепить результат в коде: завести регрессионный тест, воспроизводящий сценарий под ASan, и включить его в CI, чтобы похожая ошибка была поймана до релиза.
Гибридная стратегия экономит время: тяжёлые точные инструменты работают в лаборатории, лёгкие сэмплирующие держат рядом с продом. Типичные ловушки, на которых заканчиваются все сроки: фрагментация арен glibc при сотнях потоков, лечащаяся mallopt(M_ARENA_MAX) или переходом на jemalloc; рост кэшей стандартных библиотек и рантаймов; статические буферы, размноженные по числу потоков; задержанный возврат страниц, когда glibc отдаёт память системе через madvise не сразу. При медленной утечке выручает регрессия по точкам за неделю: наклон линии даёт оценку скорости роста, из которой видно, сколько у сервиса запаса до лимита и когда планировать перезапуск или патч.
Отдельная ветка касается сервисов с GC: там настоящая утечка выглядит как неуклонный рост живого множества объектов, поэтому к списку инструментов добавляются экспортёры метрик рантайма, периодические дампы кучи и их разбор на предмет классов, число экземпляров которых растёт от прогона к прогону. Связка из мониторинга procfs, санитайзеров в тестовом контуре и сэмплирующих профилировщиков на стенде превращает поиск утечки из искусства в рутинную инженерную задачу. Чем раньше эти инструменты встроены в цикл разработки, тем дешевле обходится каждый следующий инцидент и тем спокойнее спится дежурному инженеру.