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

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

содржина

• Потекло на видовите
• Уред за штрајс накратко: Piglet Trace
• Основи: водење програма која работи на траса
• Основи: приклучување на процесот во лет
• Пример: Следење на детски процеси
• Пример: патеки за датотеки наместо рачки
• Пример: Следење на пристап до датотеки
• Пример: Повеќенишки програми
• Мастер класа: обработете го стек во моментот на системски повик
• Мастер класа: вбризгување на грешка
• Поговор

Потекло на видовите

Главниот интерфејс помеѓу програмите и кернелот на ОС во Unix се системските повици. системски повици, syscals), интеракцијата на програмите со надворешниот свет се случува исклучиво преку нив.

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

ptrace беше развиен првенствено за интерактивни дебагери, но до крајот на 80-тите (во ерата на комерцијални Систем V издание 4) на оваа основа, се појавија и станаа широко користени дебагери со тесно фокусирање - системски повици за следење.

Првиот истата верзија на strace беше објавена од Пол Кроненбург на мејлинг листата comp.sources.sun во 1992 година како алтернатива на затворена алатка trace од Сонцето. И клонот и оригиналот беа наменети за SunOS, но до 1994 година strace беше пренесен на System V, Solaris и сè попопуларниот Linux.

Денес strace поддржува само Linux и се потпира на истото ptrace, обраснат со многу проширувања.

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

Исто така, важно е што системскиот повик ptrace и трасерите никогаш не биле вклучени во POSIX, и покрај долгата историја и имплементација во Linux, FreeBSD, OpenBSD и традиционалниот Unix.

Уред за штрајс накратко: Piglet Trace

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

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

За целите на овој напис, неразумно е да се расклопи изворниот код на 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 родител ќе заврши или пред да се изврши системскиот повик или веднаш откако ќе заврши. Помеѓу два повици можете да извршите какви било дејства: заменете го повикот со алтернативен, сменете ги аргументите или повратната вредност.

Треба само двапати да ја повикаме командата 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.

За да не навлегуваме во бескрајната листа на повици на типична програма, пишуваме минимална програма околу 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 ./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 и изобилство системски повици кои не нè интересираат.

Можете да го раздвоите стандардниот излезен тек на програмата и излезот на грешка во трасата користејќи го прекинувачот -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 - основата на сите Unixes. Ајде да видиме како стрејсот работи со процесно дрво користејќи го примерот на едноставно „размножување“ програми:

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 - едноставна и сигурна алатка. Но, покрај системските повици, може да се дебагираат и други аспекти од работењето на програмите и оперативниот систем. На пример, може да ги следи повиците до динамички поврзани библиотеки. трага, тие можат да ја разгледаат работата на оперативниот систем SystemTap и фтраце, и ви овозможува длабоко да ги истражите перформансите на програмата перф. Сепак, тоа е strace - прва линија на одбрана во случај на проблеми со моите и туѓите програми и ја користам барем неколку пати неделно.

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

Извор: www.habr.com