В Unix-подобни операционни системи комуникацията на програмата с външния свят и операционната система се осъществява чрез малък набор от функции - системни повиквания. Това означава, че за целите на отстраняването на грешки може да бъде полезно да шпионирате системните повиквания, изпълнявани от процеси.

Помощна програма ви помага да наблюдавате „интимния живот“ на програмите в Linux strace, което е предмет на тази статия. Примери за използване на шпионско оборудване са придружени с кратка история strace и описание на дизайна на такива програми.

Съдържание

• Произход на видовете
• Устройство Strace накратко: Piglet Trace
• Основи: стартиране на програма, изпълняваща strace
• Основи: присъединяване към процеса в движение
• Пример: Проследяване на дъщерни процеси
• Пример: файлови пътища вместо манипулатори
• Пример: Проследяване на достъп до файлове
• Пример: Многонишкови програми
• Майсторски клас: процес стек по време на системно повикване
• Майсторски клас: инжектиране на грешки
• послеслов

Произход на видовете

Основният интерфейс между програмите и ядрото на ОС в Unix е системните повиквания. системни повиквания, системни извиквания), взаимодействието на програмите с външния свят се осъществява изключително чрез тях.

Но в първата публична версия на Unix (Версия 6 Unix, 1975) не е имало удобни начини за проследяване на поведението на потребителските процеси. За да разреши този проблем, Bell Labs ще актуализира до следващата версия (Версия 7 Unix, 1979) предложи ново системно повикване - ptrace.

ptrace е разработен основно за интерактивни дебъгери, но в края на 80-те години (в ерата на комерсиалните System V издание 4) на тази основа се появиха и широко използвани тясно фокусирани програми за отстраняване на грешки - проследяващи системни повиквания.

Първи същата версия на strace беше публикувана от Paul Cronenburg в пощенския списък comp.sources.sun през 1992 г. като алтернатива на затворена помощна програма trace от Слънце. И клонингът, и оригиналът бяха предназначени за SunOS, но до 1994г strace беше пренесен към System V, Solaris и все по-популярния Linux.

Днес strace поддържа само Linux и разчита на същото ptrace, обрасло с множество разширения.

Модерен (и много активен) поддържащ strace - Дмитрий Левин. Благодарение на него помощната програма придоби разширени функции като инжектиране на грешки в системни повиквания, поддръжка за широк набор от архитектури и, най-важното, талисман. Неофициални източници твърдят, че изборът е паднал върху щрауса заради съзвучието между руската дума „щраус“ и английската дума „страце“.

Също така е важно, че системното извикване на ptrace и трасиращите програми никога не са били включени в POSIX, въпреки дългата история и внедряване в Linux, FreeBSD, OpenBSD и традиционния Unix.

Устройство Strace накратко: Piglet Trace

„Не се очаква да разберете това“ (Денис Ричи, коментар във версия 6 Unix изходен код)

От ранно детство не мога да понасям черни кутии: не си играех с играчки, но се опитвах да разбера структурата им (възрастните използваха думата „счупени“, но не вярвайте на злите езици). Може би затова неформалната култура на първия Unix и модерното движение с отворен код е толкова близка до мен.

За целите на тази статия е неразумно да се разглобява изходният код на strace, който се разраства с десетилетия. Но не трябва да остават тайни за читателите. Ето защо, за да покажа принципа на работа на такива strace програми, ще предоставя кода за миниатюрен трасиращ - Следа на прасенце (ptr). Не знае как да направи нищо специално, но основното са системните извиквания на програмата - извежда:

$ gcc examples/piglet-trace.c -o ptr
$ ptr echo test > /dev/null
BRK(12) -> 94744690540544
ACCESS(21) -> 18446744073709551614
ACCESS(21) -> 18446744073709551614
unknown(257) -> 3
FSTAT(5) -> 0
MMAP(9) -> 140694657216512
CLOSE(3) -> 0
ACCESS(21) -> 18446744073709551614
unknown(257) -> 3
READ(0) -> 832
FSTAT(5) -> 0
MMAP(9) -> 140694657208320
MMAP(9) -> 140694650953728
MPROTECT(10) -> 0
MMAP(9) -> 140694655045632
MMAP(9) -> 140694655070208
CLOSE(3) -> 0
unknown(158) -> 0
MPROTECT(10) -> 0
MPROTECT(10) -> 0
MPROTECT(10) -> 0
MUNMAP(11) -> 0
BRK(12) -> 94744690540544
BRK(12) -> 94744690675712
unknown(257) -> 3
FSTAT(5) -> 0
MMAP(9) -> 140694646390784
CLOSE(3) -> 0
FSTAT(5) -> 0
IOCTL(16) -> 18446744073709551591
WRITE(1) -> 5
CLOSE(3) -> 0
CLOSE(3) -> 0
unknown(231)
Tracee terminated

Piglet Trace разпознава около стотици системни повиквания на Linux (вижте. масата) и работи само на x86-64 архитектура. Това е достатъчно за образователни цели.

Нека да разгледаме работата на нашия клонинг. В случая на Linux, програмите за отстраняване на грешки и проследяване използват, както беше споменато по-горе, системното извикване ptrace. Работи, като в първия аргумент предава идентификаторите на командата, от които се нуждаем само PTRACE_TRACEME, PTRACE_SYSCALL и PTRACE_GETREGS.

Проследяването започва в обичайния Unix стил: fork(2) стартира дъщерен процес, който от своя страна използва exec(3) стартира изследваната програма. Единствената тънкост тук е предизвикателството ptrace(PTRACE_TRACEME) преди exec: Дъщерният процес очаква родителският процес да го наблюдава:

pid_t child_pid = fork();
switch (child_pid) {
case -1:
    err(EXIT_FAILURE, "fork");
case 0:
    /* Child here */
    /* A traced mode has to be enabled. A parent will have to wait(2) for it
     * to happen. */
    ptrace(PTRACE_TRACEME, 0, NULL, NULL);
    /* Replace itself with a program to be run. */
    execvp(argv[1], argv + 1);
    err(EXIT_FAILURE, "exec");
}

Процесът-родител сега трябва да извика wait(2) в дъщерния процес, т.е. уверете се, че е настъпило превключване към режим на проследяване:

/* Parent */

/* First we wait for the child to set the traced mode (see
 * ptrace(PTRACE_TRACEME) above) */
if (waitpid(child_pid, NULL, 0) == -1)
    err(EXIT_FAILURE, "traceme -> waitpid");

На този етап подготовката е завършена и можете да продължите директно към проследяване на системни повиквания в безкраен цикъл.

повикване ptrace(PTRACE_SYSCALL) гарантира, че последващите wait parent ще завърши или преди системното повикване да бъде изпълнено, или веднага след като завърши. Между две извиквания можете да извършвате всякакви действия: да замените извикването с алтернативно, да промените аргументите или върнатата стойност.

Просто трябва да извикаме командата два пъти ptrace(PTRACE_GETREGS)за да получите състоянието на регистъра rax преди повикването (номер на системно повикване) и непосредствено след (върната стойност).

Всъщност цикълът:

/* A system call tracing loop, one interation per call. */
for (;;) {
    /* A non-portable structure defined for ptrace/GDB/strace usage mostly.
     * It allows to conveniently dump and access register state using
     * ptrace. */
    struct user_regs_struct registers;

    /* Enter syscall: continue execution until the next system call
     * beginning. Stop right before syscall.
     *
     * It's possible to change the system call number, system call
     * arguments, return value or even avoid executing the system call
     * completely. */
  if (ptrace(PTRACE_SYSCALL, child_pid, NULL, NULL) == -1)
      err(EXIT_FAILURE, "enter_syscall");
  if (waitpid(child_pid, NULL, 0) == -1)
      err(EXIT_FAILURE, "enter_syscall -> waitpid");

  /* According to the x86-64 system call convention on Linux (see man 2
   * syscall) the number identifying a syscall should be put into the rax
   * general purpose register, with the rest of the arguments residing in
   * other general purpose registers (rdi,rsi, rdx, r10, r8, r9). */
  if (ptrace(PTRACE_GETREGS, child_pid, NULL, &registers) == -1)
      err(EXIT_FAILURE, "enter_syscall -> getregs");

  /* Note how orig_rax is used here. That's because on x86-64 rax is used
   * both for executing a syscall, and returning a value from it. To
   * differentiate between the cases both rax and orig_rax are updated on
   * syscall entry/exit, and only rax is updated on exit. */
  print_syscall_enter(registers.orig_rax);

  /* Exit syscall: execute of the syscall, and stop on system
   * call exit.
   *
   * More system call tinkering possible: change the return value, record
   * time it took to finish the system call, etc. */
  if (ptrace(PTRACE_SYSCALL, child_pid, NULL, NULL) == -1)
      err(EXIT_FAILURE, "exit_syscall");
  if (waitpid(child_pid, NULL, 0) == -1)
      err(EXIT_FAILURE, "exit_syscall -> waitpid");

  /* Retrieve register state again as we want to inspect system call
   * return value. */
  if (ptrace(PTRACE_GETREGS, child_pid, NULL, &registers) == -1) {
      /* ESRCH is returned when a child terminates using a syscall and no
       * return value is possible, e.g. as a result of exit(2). */
      if (errno == ESRCH) {
          fprintf(stderr, "nTracee terminatedn");
          break;
      }
      err(EXIT_FAILURE, "exit_syscall -> getregs");
  }

  /* Done with this system call, let the next iteration handle the next
   * one */
  print_syscall_exit(registers.rax);
}

Това е целият трайсер. Сега знаете откъде да започнете следващото пренасяне DTrace на Linux.

Основи: стартиране на програма, изпълняваща strace

Като първи случай на употреба strace, може би си струва да цитираме най-простия метод - стартиране на работещо приложение strace.

За да не се задълбочаваме в безкрайния списък с обаждания на типична програма, ние пишем минимална програма около write:

int main(int argc, char *argv[])
{
    char str[] = "write me to stdoutn";
    /* write(2) is a simple wrapper around a syscall so it should be easy to
     * find in the syscall trace. */
    if (sizeof(str) != write(STDOUT_FILENO, str, sizeof(str))){
        perror("write");
        return EXIT_FAILURE;
    }
    return EXIT_SUCCESS;
}

Нека изградим програмата и се уверим, че работи:

$ gcc examples/write-simple.c -o write-simple
$ ./write-simple
write me to stdout

И накрая, нека го стартираме под strace контрол:

$ strace ./write-simple
pexecve("./write", ["./write"], 0x7ffebd6145b0 /* 71 vars */) = 0
brk(NULL)                               = 0x55ff5489e000
access("/etc/ld.so.nohwcap", F_OK)      = -1 ENOENT (No such file or directory)
access("/etc/ld.so.preload", R_OK)      = -1 ENOENT (No such file or directory)
openat(AT_FDCWD, "/etc/ld.so.cache", O_RDONLY|O_CLOEXEC) = 3
fstat(3, {st_mode=S_IFREG|0644, st_size=197410, ...}) = 0
mmap(NULL, 197410, PROT_READ, MAP_PRIVATE, 3, 0) = 0x7f7a2a633000
close(3)                                = 0
access("/etc/ld.so.nohwcap", F_OK)      = -1 ENOENT (No such file or directory)
openat(AT_FDCWD, "/lib/x86_64-linux-gnu/libc.so.6", O_RDONLY|O_CLOEXEC) = 3
read(3, "177ELF21133>1260342"..., 832) = 832
fstat(3, {st_mode=S_IFREG|0755, st_size=2030544, ...}) = 0
mmap(NULL, 8192, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_ANONYMOUS, -1, 0) = 0x7f7a2a631000
mmap(NULL, 4131552, PROT_READ|PROT_EXEC, MAP_PRIVATE|MAP_DENYWRITE, 3, 0) = 0x7f7a2a04c000
mprotect(0x7f7a2a233000, 2097152, PROT_NONE) = 0
mmap(0x7f7a2a433000, 24576, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_FIXED|MAP_DENYWRITE, 3, 0x1e7000) = 0x7f7a2a433000
mmap(0x7f7a2a439000, 15072, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_FIXED|MAP_ANONYMOUS, -1, 0) = 0x7f7a2a439000
close(3)                                = 0
arch_prctl(ARCH_SET_FS, 0x7f7a2a6324c0) = 0
mprotect(0x7f7a2a433000, 16384, PROT_READ) = 0
mprotect(0x55ff52b52000, 4096, PROT_READ) = 0
mprotect(0x7f7a2a664000, 4096, PROT_READ) = 0
munmap(0x7f7a2a633000, 197410)          = 0
write(1, "write me to stdoutn", 20write me to stdout
)  = 20
exit_group(0)                           = ?

Много „многословен“ и не много образователен. Тук има два проблема: изходът на програмата се смесва с изхода strace и изобилие от системни повиквания, които не ни интересуват.

Можете да разделите стандартния изходен поток на програмата и изхода за грешка на strace, като използвате ключа -o, който пренасочва списъка със системни извиквания към файл с аргументи.

Остава да се справим с проблема с „допълнителните“ разговори. Да приемем, че се интересуваме само от обаждания write. Ключ -e ви позволява да посочите изрази, чрез които системните повиквания ще бъдат филтрирани. Най-популярната опция за условие е, естествено, trace=*, с който можете да оставите само разговорите, които ни интересуват.

Когато се използва едновременно -o и -e ще получим:

$ strace -e trace=write -owrite-simple.log ./write-simple
write me to stdout
$ cat write-simple.log
write(1, "write me to stdoutn", 20
)  = 20
+++ exited with 0 +++

Така че, виждате, че е много по-лесно за четене.

Можете също да премахнете системни повиквания, например тези, свързани с разпределяне и освобождаване на памет:

$ strace -e trace=!brk,mmap,mprotect,munmap -owrite-simple.log ./write-simple
write me to stdout
$ cat write-simple.log
execve("./write-simple", ["./write-simple"], 0x7ffe9972a498 /* 69 vars */) = 0
access("/etc/ld.so.nohwcap", F_OK)      = -1 ENOENT (No such file or directory)
access("/etc/ld.so.preload", R_OK)      = -1 ENOENT (No such file or directory)
openat(AT_FDCWD, "/etc/ld.so.cache", O_RDONLY|O_CLOEXEC) = 3
fstat(3, {st_mode=S_IFREG|0644, st_size=124066, ...}) = 0
close(3)                                = 0
access("/etc/ld.so.nohwcap", F_OK)      = -1 ENOENT (No such file or directory)
openat(AT_FDCWD, "/lib/x86_64-linux-gnu/libc.so.6", O_RDONLY|O_CLOEXEC) = 3
read(3, "177ELF21133>1260342"..., 832) = 832
fstat(3, {st_mode=S_IFREG|0755, st_size=2030544, ...}) = 0
close(3)                                = 0
arch_prctl(ARCH_SET_FS, 0x7f00f0be74c0) = 0
write(1, "write me to stdoutn", 20)  = 20
exit_group(0)                           = ?
+++ exited with 0 +++

Обърнете внимание на екранирания удивителен знак в списъка с изключени повиквания: това се изисква от командната обвивка. черупка).

В моята версия на glibc системно повикване прекратява процеса exit_group, не традиционно _exit. Това е трудността при работа със системни повиквания: интерфейсът, с който работи програмистът, не е пряко свързан със системните повиквания. Освен това, той се променя редовно в зависимост от изпълнението и платформата.

Основи: присъединяване към процеса в движение

Първоначално системното извикване на ptrace, върху което е изградено strace, може да се използва само при стартиране на програмата в специален режим. Това ограничение може да е звучало разумно в дните на версия 6 Unix. В наши дни това вече не е достатъчно: понякога трябва да проучите проблемите на работеща програма. Типичен пример е процес, блокиран на манипулатор или спящ. Следователно модерен strace може да се присъединява към процеси в движение.

Пример за замразяване програми:

int main(int argc, char *argv[])
{
    (void) argc; (void) argv;

    char str[] = "write men";

    write(STDOUT_FILENO, str, sizeof(str));

    /* Sleep indefinitely or until a signal arrives */
    pause();

    write(STDOUT_FILENO, str, sizeof(str));

    return EXIT_SUCCESS;
}

Нека да изградим програмата и да се уверим, че е замразена:

$ gcc examples/write-sleep.c -o write-sleep
$ ./write-sleep
./write-sleep
write me
^C
$

Сега нека се опитаме да се присъединим към него:

$ ./write-sleep &
[1] 15329
write me
$ strace -p 15329
strace: Process 15329 attached
pause(
^Cstrace: Process 15329 detached
 <detached ...>

Програмата е блокирана от повикване pause. Нека да видим как тя реагира на сигналите:

$ strace -o write-sleep.log -p 15329 &
strace: Process 15329 attached
$
$ kill -CONT 15329
$ cat write-sleep.log
pause()                                 = ? ERESTARTNOHAND (To be restarted if no handler)
--- SIGCONT {si_signo=SIGCONT, si_code=SI_USER, si_pid=14989, si_uid=1001} ---
pause(
$
$ kill -TERM 15329
$ cat write-sleep.log
pause()                                 = ? ERESTARTNOHAND (To be restarted if no handler)
--- SIGCONT {si_signo=SIGCONT, si_code=SI_USER, si_pid=14989, si_uid=1001} ---
pause()                                 = ? ERESTARTNOHAND (To be restarted if no handler)
--- SIGTERM {si_signo=SIGTERM, si_code=SI_USER, si_pid=14989, si_uid=1001} ---
+++ killed by SIGTERM +++

Стартирахме замразената програма и се присъединихме към нея, използвайки strace. Две неща станаха ясни: системното повикване на пауза игнорира сигнали без манипулатори и, което е по-интересно, strace следи не само системните повиквания, но и входящите сигнали.

Пример: Проследяване на дъщерни процеси

Работа с процеси чрез повикване fork - основата на всички Unix-и. Нека да видим как strace работи с дърво на процеса, използвайки примера на просто „размножаване“ програми:

int main(int argc, char *argv[])
{
    pid_t parent_pid = getpid();
    pid_t child_pid = fork();
    if (child_pid == 0) {
        /* A child is born! */
        child_pid = getpid();

        /* In the end of the day printf is just a call to write(2). */
        printf("child (self=%d)n", child_pid);
        exit(EXIT_SUCCESS);
    }

    printf("parent (self=%d, child=%d)n", parent_pid, child_pid);

    wait(NULL);

    exit(EXIT_SUCCESS);
}

Тук оригиналният процес създава дъщерен процес, като и двата записват на стандартен изход:

$ gcc examples/fork-write.c -o fork-write
$ ./fork-write
parent (self=11274, child=11275)
child (self=11275)

По подразбиране ще виждаме само системни извиквания от родителския процес:

$ strace -e trace=write -ofork-write.log ./fork-write
child (self=22049)
parent (self=22048, child=22049)
$ cat fork-write.log
write(1, "parent (self=22048, child=22049)"..., 33) = 33
--- SIGCHLD {si_signo=SIGCHLD, si_code=CLD_EXITED, si_pid=22049, si_uid=1001, si_status=0, si_utime=0, si_stime=0} ---
+++ exited with 0 +++

Флагът ви помага да проследите цялото дърво на процеса -f, който strace следи системните извиквания в дъщерните процеси. Това добавя към всеки ред на изхода pid процес, който прави системен изход:

$ strace -f -e trace=write -ofork-write.log ./fork-write
parent (self=22710, child=22711)
child (self=22711)
$ cat fork-write.log
22710 write(1, "parent (self=22710, child=22711)"..., 33) = 33
22711 write(1, "child (self=22711)n", 19) = 19
22711 +++ exited with 0 +++
22710 --- SIGCHLD {si_signo=SIGCHLD, si_code=CLD_EXITED, si_pid=22711, si_uid=1001, si_status=0, si_utime=0, si_stime=0} ---
22710 +++ exited with 0 +++

В този контекст филтрирането по група системни повиквания може да бъде полезно:

$ strace -f -e trace=%process -ofork-write.log ./fork-write
parent (self=23610, child=23611)
child (self=23611)
$ cat fork-write.log
23610 execve("./fork-write", ["./fork-write"], 0x7fff696ff720 /* 63 vars */) = 0
23610 arch_prctl(ARCH_SET_FS, 0x7f3d03ba44c0) = 0
23610 clone(child_stack=NULL, flags=CLONE_CHILD_CLEARTID|CLONE_CHILD_SETTID|SIGCHLD, child_tidptr=0x7f3d03ba4790) = 23611
23610 wait4(-1,  <unfinished ...>
23611 exit_group(0)                     = ?
23611 +++ exited with 0 +++
23610 <... wait4 resumed> NULL, 0, NULL) = 23611
23610 --- SIGCHLD {si_signo=SIGCHLD, si_code=CLD_EXITED, si_pid=23611, si_uid=1001, si_status=0, si_utime=0, si_stime=0} ---
23610 exit_group(0)                     = ?
23610 +++ exited with 0 +++

Между другото, какво системно извикване се използва за създаване на нов процес?

Пример: файлови пътища вместо манипулатори

Познаването на файловите дескриптори със сигурност е полезно, но имената на конкретните файлове, до които програмата има достъп, също могат да бъдат полезни.

До програма записва реда във временен файл:

void do_write(int out_fd)
{
    char str[] = "write me to a filen";

    if (sizeof(str) != write(out_fd, str, sizeof(str))){
        perror("write");
        exit(EXIT_FAILURE);
    }
}

int main(int argc, char *argv[])
{
    char tmp_filename_template[] = "/tmp/output_fileXXXXXX";

    int out_fd = mkstemp(tmp_filename_template);
    if (out_fd == -1) {
        perror("mkstemp");
        exit(EXIT_FAILURE);
    }

    do_write(out_fd);

    return EXIT_SUCCESS;
}

По време на нормален разговор strace ще покаже стойността на номера на дескриптора, предадена на системното извикване:

$ strace -e trace=write -o write-tmp-file.log ./write-tmp-file
$ cat write-tmp-file.log
write(3, "write me to a filen", 20)  = 20
+++ exited with 0 +++

Със знаме -y Помощната програма показва пътя до файла, на който съответства дескрипторът:

$ strace -y -e trace=write -o write-tmp-file.log ./write-tmp-file
$ cat write-tmp-file.log
write(3</tmp/output_fileCf5MyW>, "write me to a filen", 20) = 20
+++ exited with 0 +++

Пример: Проследяване на достъп до файлове

Друга полезна функция: показва само системни повиквания, свързани с конкретен файл. Следващия програма добавя ред към произволен файл, предаден като аргумент:

void do_write(int out_fd)
{
    char str[] = "write me to a filen";

    if (sizeof(str) != write(out_fd, str, sizeof(str))){
        perror("write");
        exit(EXIT_FAILURE);
    }
}

int main(int argc, char *argv[])
{
    /*
     * Path will be provided by the first program argument.
     *  */
    const char *path = argv[1];

    /*
     * Open an existing file for writing in append mode.
     *  */
    int out_fd = open(path, O_APPEND | O_WRONLY);
    if (out_fd == -1) {
        perror("open");
        exit(EXIT_FAILURE);
    }

    do_write(out_fd);

    return EXIT_SUCCESS;
}

По подразбиране strace показва много ненужна информация. Флаг -P с аргумент кара strace да отпечатва само извиквания към посочения файл:

$ strace -y -P/tmp/test_file.log -o write-file.log ./write-file /tmp/test_file.log
$ cat write-file.log
openat(AT_FDCWD, "/tmp/test_file.log", O_WRONLY|O_APPEND) = 3</tmp/test_file.log>
write(3</tmp/test_file.log>, "write me to a filen", 20) = 20
+++ exited with 0 +++

Пример: Многонишкови програми

Полезност strace също може да помогне при работа с многонишкови програмата. Следната програма записва в стандартен изход от два потока:

void *thread(void *arg)
{
    (void) arg;

    printf("Secondary thread: workingn");
    sleep(1);
    printf("Secondary thread: donen");

    return NULL;
}

int main(int argc, char *argv[])
{
    printf("Initial thread: launching a threadn");

    pthread_t thr;
    if (0 != pthread_create(&thr, NULL, thread, NULL)) {
        fprintf(stderr, "Initial thread: failed to create a thread");
        exit(EXIT_FAILURE);
    }

    printf("Initial thread: joining a threadn");
    if (0 != pthread_join(thr, NULL)) {
        fprintf(stderr, "Initial thread: failed to join a thread");
        exit(EXIT_FAILURE);
    };

    printf("Initial thread: done");

    exit(EXIT_SUCCESS);
}

Естествено, той трябва да бъде компилиран със специален поздрав към линкера - флага -pthread:

$ gcc examples/thread-write.c -pthread -o thread-write
$ ./thread-write
/thread-write
Initial thread: launching a thread
Initial thread: joining a thread
Secondary thread: working
Secondary thread: done
Initial thread: done
$

флаг -f, както в случая с обикновените процеси, ще добави pid на процеса в началото на всеки ред.

Естествено, не говорим за идентификатор на нишка в смисъла на внедряването на стандарта POSIX Threads, а за номера, използван от планировчика на задачи в Linux. От гледна точка на последния няма процеси или нишки - има задачи, които трябва да бъдат разпределени между наличните ядра на машината.

Когато работите в множество нишки, системните извиквания стават твърде много:

$ strace -f -othread-write.log ./thread-write
$ wc -l thread-write.log
60 thread-write.log

Има смисъл да се ограничите само до управление на процеси и системни повиквания write:

$ strace -f -e trace="%process,write" -othread-write.log ./thread-write
$ cat thread-write.log
18211 execve("./thread-write", ["./thread-write"], 0x7ffc6b8d58f0 /* 64 vars */) = 0
18211 arch_prctl(ARCH_SET_FS, 0x7f38ea3b7740) = 0
18211 write(1, "Initial thread: launching a thre"..., 35) = 35
18211 clone(child_stack=0x7f38e9ba2fb0, flags=CLONE_VM|CLONE_FS|CLONE_FILES|CLONE_SIGHAND|CLONE_THREAD|CLONE_SYSVSEM|CLONE_SETTLS|CLONE_PARENT_SETTID|CLONE_CHILD_CLEARTID, parent_tidptr=0x7f38e9ba39d0, tls=0x7f38e9ba3700, child_tidptr=0x7f38e9ba39d0) = 18212
18211 write(1, "Initial thread: joining a thread"..., 33) = 33
18212 write(1, "Secondary thread: workingn", 26) = 26
18212 write(1, "Secondary thread: donen", 23) = 23
18212 exit(0)                           = ?
18212 +++ exited with 0 +++
18211 write(1, "Initial thread: done", 20) = 20
18211 exit_group(0)                     = ?
18211 +++ exited with 0 +++

Между другото, въпроси. Какво системно извикване се използва за създаване на нова нишка? Как това извикване на нишки се различава от извикването на процеси?

Майсторски клас: процес стек по време на системно повикване

Един от появилите се наскоро strace възможности - показване на стека от извиквания на функции по време на системното извикване. просто пример:

void do_write(void)
{
    char str[] = "write me to stdoutn";
    if (sizeof(str) != write(STDOUT_FILENO, str, sizeof(str))){
        perror("write");
        exit(EXIT_FAILURE);
    }
}

int main(int argc, char *argv[])
{
    do_write();
    return EXIT_SUCCESS;
}

Естествено, изходът на програмата става много обемен и в допълнение към флага -k (показване на стека на повикванията), има смисъл системните извиквания да се филтрират по име:

$ gcc examples/write-simple.c -o write-simple
$ strace -k -e trace=write -o write-simple.log ./write-simple
write me to stdout
$ cat write-simple.log
write(1, "write me to stdoutn", 20)  = 20
 > /lib/x86_64-linux-gnu/libc-2.27.so(__write+0x14) [0x110154]
 > /home/vkazanov/projects-my/strace-post/write-simple(do_write+0x50) [0x78a]
 > /home/vkazanov/projects-my/strace-post/write-simple(main+0x14) [0x7d1]
 > /lib/x86_64-linux-gnu/libc-2.27.so(__libc_start_main+0xe7) [0x21b97]
 > /home/vkazanov/projects-my/strace-post/write-simple(_start+0x2a) [0x65a]
+++ exited with 0 +++

Майсторски клас: инжектиране на грешки

И още една нова и много полезна функция: инжектиране на грешки. Тук програма, записвайки два реда в изходния поток:

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

void do_write(const char *str, ssize_t len)
{
    if (len != write(STDOUT_FILENO, str, (size_t)len)){
        perror("write");
        exit(EXIT_FAILURE);
    }
}

int main(int argc, char *argv[])
{
    (void) argc; (void) argv;

    char str1[] = "write me 1n";
    do_write(str1, sizeof(str1));

    char str2[] = "write me 2n";
    do_write(str2, sizeof(str2));

    return EXIT_SUCCESS;
}

Нека проследим и двете обаждания за писане:

$ gcc examples/write-twice.c -o write-twice
$ ./write-twice
write me 1
write me 2
$ strace -e trace=write -owrite-twice.log ./write-twice
write me 1
write me 2
$ cat write-twice.log
write(1, "write me 1n", 12)          = 12
write(1, "write me 2n", 12)          = 12
+++ exited with 0 +++

Сега използваме израза injectза вмъкване на грешка EBADF във всички обаждания за писане:

$ strace -e trace=write -e inject=write:error=EBADF -owrite-twice.log ./write-twice
$ cat write-twice.log
write(1, "write me 1n", 12)          = -1 EBADF (Bad file descriptor) (INJECTED)
write(3, "write: Bad file descriptorn", 27) = -1 EBADF (Bad file descriptor) (INJECTED)
+++ exited with 1 +++

Интересно какви грешки се връщат всички предизвикателства write, включително обаждането, скрито зад грешка. Има смисъл да върнете грешка само за първото от извикванията:

$ strace -e trace=write -e inject=write:error=EBADF:when=1 -owrite-twice.log ./write-twice
write: Bad file descriptor
$ cat write-twice.log
write(1, "write me 1n", 12)          = -1 EBADF (Bad file descriptor) (INJECTED)
write(3, "write: Bad file descriptorn", 27) = 27
+++ exited with 1 +++

Или второто:

$ strace -e trace=write -e inject=write:error=EBADF:when=2 -owrite-twice.log ./write-twice
write me 1
write: Bad file descriptor
$ cat write-twice.log
write(1, "write me 1n", 12)          = 12
write(1, "write me 2n", 12)          = -1 EBADF (Bad file descriptor) (INJECTED)
write(3, "write: Bad file descriptorn", 27) = 27
+++ exited with 1 +++

Не е необходимо да посочвате вида на грешката:

$ strace -e trace=write -e fault=write:when=1 -owrite-twice.log ./write-twice
$ cat write-twice.log
write(1, "write me 1n", 12)          = -1 ENOSYS (Function not implemented) (INJECTED)
write(3, "write: Function not implementedn", 32) = 32
+++ exited with 1 +++

В комбинация с други флагове можете да „прекъснете“ достъпа до конкретен файл. Пример:

$ strace -y -P/tmp/test_file.log -e inject=file:error=ENOENT -o write-file.log ./write-file /tmp/test_file.log
open: No such file or directory
$ cat write-file.log
openat(AT_FDCWD, "/tmp/test_file.log", O_WRONLY|O_APPEND) = -1 ENOENT (No such file or directory) (INJECTED)
+++ exited with 1 +++

Освен инжектиране на грешки, може да въвеждат забавяния при извършване на повиквания или получаване на сигнали.

послеслов

Полезност strace - прост и надежден инструмент. Но в допълнение към системните повиквания могат да се отстраняват грешки и в други аспекти на работата на програмите и операционната система. Например, може да проследява повиквания към динамично свързани библиотеки. ltrace, те могат да разгледат работата на операционната система SystemTap и ftraceи ви позволява да проучите задълбочено ефективността на програмата PERF. Въпреки това е така strace - първата линия на защита в случай на проблеми с моите собствени и чужди програми и го използвам поне няколко пъти седмично.

Накратко, ако обичате Unix, прочетете man 1 strace и не се колебайте да надникнете в програмите си!

Източник: www.habr.com