У оперативним системима сличним Уник-у, комуникација програма са спољним светом и оперативним системом одвија се кроз мали скуп функција – системске позиве. То значи да у сврху отклањања грешака може бити корисно шпијунирати системске позиве које извршавају процеси.

Услужни програм вам помаже да надгледате „интимни живот“ програма на Линук-у strace, што је тема овог чланка. Примере употребе шпијунске опреме прати кратак историјат strace и опис дизајна таквих програма.

Садржина

• Порекло врсте
• Страце уређај укратко: Прасад прасад
• Основе: покретање програма који се покреће страце
• Основе: придруживање процесу у ходу
• Пример: Праћење дечјих процеса
• Пример: путање датотека уместо ручица
• Пример: Праћење приступа датотекама
• Пример: Програми са више нити
• Мастер класа: процесни стог у време системског позива
• Мастер класа: убризгавање грешке
• Афтерворд

Порекло врсте

Главни интерфејс између програма и језгра ОС у Уник-у су системски позиви. системски позиви, сисцаллс), интеракција програма са спољним светом се одвија искључиво преко њих.

Али у првој јавној верзији Уник-а (Верзија 6 Уник, 1975) није било згодних начина за праћење понашања корисничких процеса. Да би решио овај проблем, Белл Лабс ће ажурирати на следећу верзију (Верзија 7 Уник, 1979) предложио нови системски позив - ptrace.

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

Прво исту верзију страце је објавио Паул Цроненбург на цомп.соурцес.сун маилинг листи 1992. године као алтернативу затвореном услужном програму trace од Сунца. И клон и оригинал су били намењени за СунОС, али до 1994 strace је пренет на Систем В, Соларис и све популарнији Линук.

Данас страце подржава само Линук и ослања се на исти ptrace, обрастао многим проширењима.

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

Такође је важно да птраце системски позив и трагачи никада нису били укључени у ПОСИКС, упркос дугој историји и имплементацији у Линук, ФрееБСД, ОпенБСД и традиционалном Унику.

Страце уређај укратко: Прасад прасад

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

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

За потребе овог чланка, неразумно је растављати изворни код страце-а, који је растао деценијама. Али за читаоце не би требало да остане никаквих тајни. Стога, да бих показао принцип рада таквих програма за праћење, пружићу код за минијатурни трагач - Прасад Траце (птр). Не зна како да уради ништа посебно, али главна ствар су системски позиви програма - он даје:

$ 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

Пиглет Траце препознаје стотине Линук системских позива (види. сто) и ради само на архитектури к86-64. Ово је довољно за образовне сврхе.

Хајде да погледамо рад нашег клона. У случају Линука, програми за отклањање грешака и трагачи користе, као што је горе поменуто, системски позив птраце. Функционише тако што се у првом аргументу прослеђују идентификатори команди, од којих су нам само потребни PTRACE_TRACEME, PTRACE_SYSCALL и PTRACE_GETREGS.

Трацер почиње у уобичајеном Уник стилу: 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);
}

То је цео трагач. Сада знате где да започнете следеће преношење ДТраце на Линук-у.

Основе: покретање програма који се покреће страце

Као први случај употребе 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 и обиље системских позива који нас не занимају.

Можете да одвојите стандардни излазни ток програма и излаз грешке страце користећи -о прекидач, који преусмерава листу системских позива у датотеку са аргументима.

Остаје да се позабавимо проблемом „додатних“ позива. Претпоставимо да нас занимају само позиви 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 +++

Обратите пажњу на неискључени узвичник на листи искључених позива: ово захтева командна шкољка. граната).

У мојој верзији глибц-а, системски позив прекида процес exit_group, не традиционално _exit. Ово је тешкоћа рада са системским позивима: интерфејс са којим програмер ради није директно повезан са системским позивима. Штавише, редовно се мења у зависности од имплементације и платформе.

Основе: придруживање процесу у ходу

У почетку, системски позив птраце на којем је изграђен strace, могао се користити само када се програм покреће у посебном режиму. Ово ограничење је можда звучало разумно у данима верзије 6 Уник-а. Данас то више није довољно: понекад морате истражити проблеме радног програма. Типичан пример је процес блокиран на ручки или спавање. Стога модерно strace може да се придружи процесима у ходу.

Пример замрзавања programi:

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

Пример: Праћење дечјих процеса

Рад са процесима преко позива fork - основа свих Уник-ова. Хајде да видимо како страце ради са процесним стаблом користећи пример једноставног „узгоја“ programi:

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 +++

Узгред, који системски позив се користи за креирање новог процеса?

Пример: путање датотека уместо ручица

Познавање дескриптора датотека је свакако корисно, али имена одређених датотека којима програм приступа такође могу бити од користи.

naredni програм уписује линију у привремену датотеку:

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 -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);
}

Наравно, мора се саставити са посебним поздравом за линкер - заставицом -птхреад:

$ 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, као иу случају редовних процеса, додаће пид процеса на почетак сваког реда.

Наравно, не говоримо о идентификатору нити у смислу имплементације стандарда ПОСИКС Тхреадс, већ о броју који користи планер задатака у Линуку. Са тачке гледишта последњег, не постоје процеси или нити - постоје задаци који треба да се распореде између доступних језгара машине.

Када радите у више нити, системски позиви постају превише:

$ 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 - једноставан и поуздан алат. Али поред системских позива, могу се отклонити и други аспекти рада програма и оперативног система. На пример, може да прати позиве ка динамички повезаним библиотекама. лтраце, могу да испитају рад оперативног система СистемТап и фтраце, и омогућава вам да дубоко истражите перформансе програма перф. Ипак, јесте strace - прва линија одбране у случају проблема са сопственим и туђим програмима и користим је бар пар пута недељно.

Укратко, ако волите Уник, читајте man 1 strace и слободно завирите у своје програме!

Извор: ввв.хабр.цом