Когда сервис падает под нагрузкой, зависает на ровном месте или ведет себя иначе только на боевом сервере, разработчику нужны инструменты, показывающие реальное поведение программы, а не догадки по логам. В Linux эту задачу традиционно решают gdb, strace и разбор core dump. Все три опираются на механизмы ядра, не требуют переписывания кода и позволяют заглянуть внутрь живого или уже погибшего процесса. Разговор пойдет о том, как эти инструменты применяют вместе, с какими настройками и в каком порядке, чтобы от симптома до причины оставался один шаг.

Ptrace как системный фундамент всех инструментов отладки

Оба инструмента построены на системном вызове ptrace(2). Трассер подключается к процессу цели, после чего целевой процесс останавливается при каждом сигнале, а трассер получает право читать и писать его память, менять регистры и вести пошаговое исполнение. Gdb размещает точку останова, записывая в код команду int3, байт 0xCC, по нужному адресу; при срабатывании процессор передает управление трассеру, тот восстанавливает исходный байт и показывает соответствующую строку исходника. Strace устроен иначе: он использует PTRACE_SYSCALL и останавливает трассируемый процесс дважды на каждом системном вызове, на входе и на выходе, чтобы показать аргументы и результат.

У механизма есть ограничения, о которых стоит помнить заранее. Параметр ядра /proc/sys/kernel/yama/ptrace_scope в большинстве дистрибутивов по умолчанию равен 1: подключаться разрешено только к собственным прямым потомкам, а для работы с чужим процессом нужен флаг CAP_SYS_PTRACE. Попытка gdb -p на процесс другого пользователя закончится сообщением "Operation not permitted". Сервисы, запускаемые systemd, дополнительно ограничивают директивой LimitCORE размер дампов, а в контейнерах ptrace нередко запрещен профилем безопасности. Перед сеансом отладки имеет смысл проверить ptrace_scope, ulimit и политику контейнера, иначе время уйдет на борьбу с защитой, а не с багом.

Первые шаги в gdb, запуск и подключение к процессу

Толковая отладка начинается со сборки. Компилятор должен сохранить таблицы соответствия машинного кода и строк исходников, поэтому в флаги добавляется -g, а уровень оптимизации на время расследования обычно сбрасывают до -O0, чтобы шаги не прыгали из-за встраивания функций:

gcc -g -O0 -o app app.c
gdb ./app

Команда run запускает программу, аргументы передают через set args либо сразу после run. Вариант start выполняет то же самое, но останавливается на входе в main, избавляя от ручной точки останова. Если процесс уже работает и его нельзя перезапускать, gdb подключается к нему по идентификатору:

gdb -p $(pidof app)

С момента подключения целевой процесс замирает: можно читать bt, проверять переменные, а затем продолжить выполнение через continue. Команда detach отключает трассер и возвращает процессу самостоятельность. Для коротких сценариев удобен пакетный режим, gdb -batch -ex bt -p 1234 напечатает backtrace без интерактивного сеанса, что годится для скриптов мониторинга и автоматических отчетов о падении. Часто используемые настройки переносят в ~/.gdbinit, а внутри отладчика работает интерпретатор Python: им автоматизируют разбор сложных структур, и pretty printers рисуют контейнеры стандартной библиотеки читаемым видом вместо простыни полей.

Точки останова и инспекция состояния выполняемой программы

Breakpoint ставится на имя функции, на строку исходника или по условию:

break worker.c:42
break process_packet if len > 1500
tbreak init

tbreak срабатывает один раз и снимается сама, полный список активных точек показывает info breakpoints, где любую точку гасят командами disable, enable или delete. После run и continue программа доходит до точки, дальше навигацию ведут next, шаг без входа в функции, step, шаг с входом, и finish, выход из текущего кадра. Команда bt печатает стек вызовов:

#0  0x00007f2e34a11d90 in raise () from /lib64/libc.so.6
#1  0x0000000000401168 in parse_header (buf=0x7ffd1c4a2e10 "\x16") at parser.c:88
#2  0x00000000004012ab in main (argc=2, argv=0x7ffd1c4a2f68) at server.c:210

Кадр номер ноль показывает текущее место, кадры выше ведут к точкам вызова, и по такому стеку за секунды видно, что падение случилось в parse_header при разборе буфера. bt full добавляет к каждому кадру локальные переменные, перемещение по кадрам идет через frame, up и down.

Состояние программы смотрят командами print и info. print переменная печатает значение, print/x показывает его в шестнадцатеричном виде, info locals перечисляет локальные переменные текущего кадра, info args раскрывает аргументы функции, ptype показывает тип. Регистры процессора доступны через info registers и info all-registers, отдельный регистр печатается как print $rax, а память исследует команда x: x/16bx $rsp выводит шестнадцать байт стека, x/s читает строку по указателю. Точка наблюдения watch срабатывает при изменении переменной и часто находит порчу значений быстрее, чем десяток обычных точек останова, потому что останавливает программу в момент записи, а не при уже заметных последствиях. Для машинного кода есть disassemble, а текстовый интерфейс TUI с исходником и дизассемблером рядом включается через layout src.

Strace показывает системные вызовы живого процесса

Strace отвечает на вопрос, чем именно программа занята на границе с ядром: какие файлы открывает, к чему подключается по сети, откуда читает и куда пишет. Запуск трассировки нового процесса и подключение к работающему выглядят так:

strace -f -tt -T -s 256 -o trace.log ./app
strace -p 1234 -o attach.log

Флаг -f захватывает порожденные дочерние процессы и потоки, -tt снабжает каждую строку точной меткой времени, -T показывает длительность каждого вызова, -s снимает стандартное ограничение на длину печатаемых строк, а -o отправляет отчет в файл вместо stderr, чтобы не мешать выводу самой программы.

Типичный фрагмент трассировки сразу рассказывает историю:

openat(AT_FDCWD, "/etc/app/app.conf", O_RDONLY) = -1 ENOENT (No such file or directory)
connect(AF_INET, {sa_family=AF_INET, sin_port=htons(5432), ...}) = -1 ETIMEDOUT (Connection timed out)

Из двух строк понятно, что приложение не нашло конфигурационный файл и не смогло соединиться с базой на порту 5432. Такой вывод экономит часы чтения исходников, потому что показывает не ожидания автора, а фактические запросы процесса к ядру. По кодам ошибок даже без справочника ясно направление поиска: ENOENT говорит о пути, EACCES о правах, EAGAIN о том, что неблокирующая операция пока невозможна.

Отдельно полезен каталог /proc: файл /proc/1234/status сообщает состояние процесса и маски сигналов, /proc/1234/stack показывает, в какой функции ядра процесс спит прямо сейчас, а /proc/1234/maps перечисляет загруженные библиотеки и их диапазоны адресов. Сопоставив адрес из стека падения с этими диапазонами, определяют модуль, которому принадлежит сбойный участок кода.

Фильтрация вызовов и статистика производительности в strace

Полная трассировка шумного сервиса порождает гигабайты вывода, поэтому вызовы сразу фильтруют. Опция -e trace принимает перечисление вызовов и готовые классы: %file для файловых операций, %network для сетевых, %process для fork, clone и exec, %signal для сигналов:

strace -e trace=%file -y -p 1234
strace -e trace=connect,sendto,recvfrom -f ./app

Флаг -y подписывает файловые дескрипторы путями, превращая безликие write(3, ...) в write(3</var/log/app.log>, ...). Ключ -c вместо потока строк печатает сводную таблицу: сколько раз вызван каждый системный вызов, сколько из них завершилось ошибкой, сколько суммарного времени ушло. Такой отчет мгновенно показывает, что процесс почти все время проводит в poll или безостановочно перечитывает один и тот же каталог. Полезны и точечные средства: -P 4321 привязывает трассировку к одному конкретному потомку, а опция inject подмешивает отказы, например -e inject=openat:error=ENOENT заставит каждую попытку открыть файл завершиться ошибкой, и так проверяют, как программа переживает недоступность ресурсов.

Затраты на трассировку существенны: под strace процесс может замедлиться в разы, поэтому на нагруженной системе фильтры обязательны, а для постоянного наблюдения лучше подходят утилиты на eBPF вроде opensnoop и execsnoop, которые смотрят на системные вызовы со стороны ядра и почти не тормозят задачи. Родственный инструмент ltrace показывает вызовы библиотечных функций, прежде всего malloc и free, и помогает искать лишние аллокации и утечки:

ltrace -e 'malloc+free' -p 1234
ltrace -c ./app

Хотя ltrace работает медленнее и подходит скорее для коротких сеансов, при поиске утечек он экономит много времени.

Core dump и посмертный разбор упавшей программы

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

ulimit -c unlimited
cat /proc/sys/kernel/core_pattern
echo '/var/crash/core.%e.%p.%s' > /proc/sys/kernel/core_pattern

Шаблон %e подставляет имя исполняемого файла, %p идентификатор процесса, %s номер сигнала. В системах с systemd файл core_pattern обычно перенаправляет на systemd-coredump: дампы сжимаются в /var/lib/systemd/coredump, список аварий показывает coredumpctl list, а вытащить конкретный дамп помогает coredumpctl dump. Если же в файле путь с маской, ядро пишет дампы напрямую, и за их попадание на диск отвечает файловая система и свободное место.

Полный разбор сбоя обычно выглядит так:
1. воспроизвести падение и убедиться, что дамп записан;
2. снять ограничение ulimit -c и проверить core_pattern;
3. открыть дамп в gdb вместе с бинарником, собранным с -g;
4. прочитать bt и bt full, найти ближайший кадр с собственным кодом;
5. перейти к строке исходника через frame и list и проверить значения переменных.

gdb ./app /var/crash/core.app.4242.11
(gdb) bt
(gdb) bt full
(gdb) thread apply all bt

Сегфолт означает сигнал SIGSEGV с номером 11, а SIGABRT с номером 6 чаще приходит от проверок glibc, например при повреждении кучи или двойном освобождении памяти. Кадр внутри libc малоинформативен: интересен ближайший кадр из собственного проекта, именно его и берут за отправную точку.

Многопоточность, дочерние процессы и воспроизводимая отладка

Многопоточная программа в gdb выглядит как набор нитей: info threads перечисляет их с текущим состоянием, thread N переключает внимание, thread apply all bt печатает стеки всех нитей сразу. Опция set scheduler-locking on замораживает остальные нити на время пошаговой отладки, что спасает при гонках, когда чужая нить успевает изменить переменную между двумя соседними шагами. Для fork-модели служат set follow-fork-mode child, чтобы уйти за потомком, и set detach-on-fork off, чтобы держать под контролем оба процесса; переключение между ними идет через info inferiors. Точки захвата событий catch fork и catch exec срабатывают в момент порождения процесса, а catch signal SIGSEGV останавливает программу прямо перед гибелью.

Современный ответ на неуловимые баги, проявляющиеся раз в неделю, это запись выполнения. Встроенный механизм gdb включается командой record, после чего доступны reverse-step и reverse-continue, отладка назад по времени, пока не встретится момент порчи значения. Инструмент rr снимает весь процесс в файл и воспроизводит его детерминированно, включая порядок планирования нитей:

rr record ./app
rr replay

Сбой удается разобрать на ноутбуке, а не на боевом сервере, причем многократно, с новыми точками останова при каждом повторе. Для наблюдения за сотнями процессов без остановки каждого применяют трассировку на eBPF: bpftrace одной строкой показывает, кто и когда открывает файлы или порождает процессы, почти без замедления системы.

Из практики полезны две привычки. Сначала сбой воспроизводят на тестовой машине с тем же дистрибутивом и версиями библиотек, фиксируют версию ядра и окружение, и только затем подключают отладчик, потому что заметная часть загадочных падений объясняется не багом в коде, а обновлением libc или сменой переменных окружения. Вторая привычка касается символов: без debuginfo пакетов стек в gdb распадается на голые адреса без имен, и половина информации о кадрах теряется на ровном месте.

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