במערכות הפעלה דמויות יוניקס, התקשורת של תוכנית עם העולם החיצון ועם מערכת ההפעלה מתבצעת באמצעות סט קטן של פונקציות - קריאות מערכת. המשמעות היא שלמטרות איתור באגים, זה יכול להיות שימושי לרגל אחר קריאות מערכת שמתבצעות על ידי תהליכים.

כלי עזר עוזר לך לנטר את "החיים האינטימיים" של תוכניות בלינוקס strace, שהוא נושא המאמר הזה. דוגמאות לשימוש בציוד ריגול מלוות בהיסטוריה קצרה strace ותיאור העיצוב של תוכניות כאלה.

תוכן

• מוצא המינים
• מכשיר Strace בקצרה: Piglet Trace
• יסודות: הפעלת תוכנית רצה
• יסודות: הצטרפות לתהליך תוך כדי תנועה
• דוגמה: מעקב אחר תהליכי ילדים
• דוגמה: נתיבי קבצים במקום ידיות
• דוגמה: מעקב אחר גישה לקבצים
• דוגמה: תוכניות מרובות הליכים
• כיתת אמן: מחסנית תהליכים בזמן קריאת מערכת
• כיתת אמן: הזרקת שגיאה
• אחרית דבר

מוצא המינים

הממשק העיקרי בין תוכניות וליבת מערכת ההפעלה ביוניקס הוא קריאות מערכת. שיחות מערכת, שיחות מערכות), האינטראקציה של תוכניות עם העולם החיצון מתרחשת אך ורק דרכן.

אבל בגרסה הציבורית הראשונה של יוניקס (גרסה 6 יוניקס, 1975) לא היו דרכים נוחות לעקוב אחר התנהגות תהליכי המשתמש. כדי לפתור בעיה זו, Bell Labs תעדכן לגרסה הבאה (גרסה 7 יוניקס, 1979) הציע קריאת מערכת חדשה - ptrace.

ptrace פותחה בעיקר עבור מאפי באגים אינטראקטיביים, אך עד סוף שנות ה-80 (בעידן המסחרי מערכת V מהדורה 4) על בסיס זה, ניפוי באגים ממוקדים - מעקבי קריאות מערכת - הופיעו והפכו לשימוש נרחב.

Первая אותה גרסה של strace פורסמה על ידי פול קרוננבורג ברשימת התפוצה comp.sources.sun בשנת 1992 כחלופה לשירות סגור trace מ- Sun. גם השיבוט וגם המקור נועדו עבור SunOS, אך עד 1994 strace הועבר ל-System V, Solaris ולינוקס הפופולרי יותר ויותר.

כיום strace תומך רק בלינוקס ומסתמך על אותו הדבר ptrace, מגודל עם הרחבות רבות.

מתחזק מודרני (ואקטיבי מאוד). strace - דמיטרי לוין. הודות לו, כלי השירות רכש תכונות מתקדמות כמו הזרקת שגיאות לשיחות מערכת, תמיכה במגוון רחב של ארכיטקטורות, והכי חשוב, קָמִיעַ. מקורות לא רשמיים טוענים שהבחירה נפלה על יען בגלל העידוד בין המילה הרוסית "יען" למילה האנגלית "סטרס".

חשוב גם שהקריאה למערכת ptrace והמעקבים מעולם לא נכללו ב-POSIX, למרות היסטוריה ארוכה והטמעה בלינוקס, FreeBSD, OpenBSD ו-Unix המסורתית.

מכשיר Strace בקצרה: Piglet Trace

"לא מצפים ממך להבין את זה" (דניס ריצ'י, הערה בקוד המקור של גרסה 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 מזהה בערך מאות קריאות מערכת לינוקס (ראה. את השולחן) ועובד רק על ארכיטקטורת x86-64. זה מספיק למטרות חינוכיות.

בואו נסתכל על עבודת השיבוט שלנו. במקרה של לינוקס, מאפי באגים ומעקבים משתמשים, כאמור לעיל, בקריאה למערכת ptrace. זה עובד על ידי העברת בארגומנט הראשון את מזהי הפקודות, שאנחנו צריכים רק מהם 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);
}

זה כל הנותב. עכשיו אתה יודע איפה להתחיל את ההעברה הבאה DTrace על לינוקס.

יסודות: הפעלת תוכנית רצה

בתור מקרה שימוש ראשון 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 call עליה היא נבנתה 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 - הבסיס של כל יוניקס. בוא נראה איך סטראס עובד עם עץ תהליך תוך שימוש בדוגמה של "גידול" פשוט программы:

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, אלא על המספר שבו משתמש מתזמן המשימות בלינוקס. מנקודת המבט של האחרון, אין תהליכים או חוטים - יש משימות שצריך להפיץ בין הליבות הזמינות של המכונה.

כאשר עובדים במספר שרשורים, קריאות המערכת הופכות ליותר מדי:

$ 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 и ftrace, ומאפשר לך לחקור לעומק את ביצועי התוכנית perf. למרות זאת, זה כן strace - קו ההגנה הראשון במקרה של בעיות בתוכניות שלי ושל אנשים אחרים, ואני משתמש בו לפחות כמה פעמים בשבוע.

בקיצור, אם אתה אוהב יוניקס, קרא man 1 strace ואל תהסס להציץ בתוכניות שלך!

מקור: www.habr.com