Unix-ის მსგავს ოპერაციულ სისტემებში პროგრამის კომუნიკაცია გარე სამყაროსთან და ოპერაციულ სისტემასთან ხდება ფუნქციების მცირე ნაკრების - სისტემური ზარების მეშვეობით. ეს ნიშნავს, რომ გამართვის მიზნებისთვის შეიძლება სასარგებლო იყოს პროცესების მიერ შესრულებული სისტემური ზარების თვალთვალი.

პროგრამა დაგეხმარებათ აკონტროლოთ პროგრამების „ინტიმური ცხოვრება“ Linux-ზე strace, რომელიც ამ სტატიის თემაა. ჯაშუშური აღჭურვილობის გამოყენების მაგალითებს ახლავს მოკლე ისტორია strace და ასეთი პროგრამების დიზაინის აღწერა.

ინფორმაციის

• სახეობების წარმოშობა
• სტრაის მოწყობილობა მოკლედ: Piglet Trace
• საფუძვლები: გაშვებული პროგრამის გაშვება strace
• საფუძვლები: პროცესის გაწევრიანება
• მაგალითი: ბავშვის პროცესების თვალყურის დევნება
• მაგალითი: ფაილის ბილიკები სახელურების ნაცვლად
• მაგალითი: ფაილზე წვდომის თვალყურის დევნება
• მაგალითი: მრავალძალიანი პროგრამები
• მასტერკლასი: დამუშავების დასტა სისტემური ზარის დროს
• მასტერკლასი: შეცდომის ინექცია
• Afterword

სახეობების წარმოშობა

Unix-ში პროგრამებსა და OS ბირთვს შორის მთავარი ინტერფეისი არის სისტემური ზარები. სისტემური ზარები, syscals), პროგრამების ურთიერთქმედება გარე სამყაროსთან ხდება ექსკლუზიურად მათი მეშვეობით.

მაგრამ Unix-ის პირველ საჯარო ვერსიაში (Unix ვერსია 6, 1975) არ არსებობდა მოსახერხებელი გზები მომხმარებლის პროცესების ქცევის თვალყურის დევნებისთვის. ამ პრობლემის გადასაჭრელად Bell Labs განახლდება შემდეგ ვერსიაზე (Unix ვერსია 7, 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-ის და თანამედროვე ღია წყაროს მოძრაობის არაფორმალური კულტურა ასე ახლოსაა ჩემთან.

ამ სტატიის მიზნებისთვის, მიზანშეწონილი არ არის ათწლეულების განმავლობაში გაზრდილი სტრასის წყაროს კოდის დაშლა. მაგრამ მკითხველისთვის საიდუმლო არ უნდა დარჩეს. მაშასადამე, ასეთი სტრატეს პროგრამების მუშაობის პრინციპის საჩვენებლად, მე მივცემ კოდს მინიატურული ტრასერის - გოჭის კვალი (პტრ). მან არ იცის როგორ გააკეთოს რაიმე განსაკუთრებული, მაგრამ მთავარია პროგრამის სისტემური ზარები - გამოდის:

$ 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-ის შემთხვევაში, debugger და tracers იყენებენ, როგორც ზემოთ აღინიშნა, 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, ალბათ ღირს უმარტივესი ხერხის მითითება - აპლიკაციის გაშვება 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 და სისტემური ზარების სიმრავლე, რომლებიც არ გვაინტერესებს.

თქვენ შეგიძლიათ განასხვავოთ პროგრამის სტანდარტული გამომავალი ნაკადი და 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 +++

გაითვალისწინეთ გამორიცხული ძახილის ნიშანი გამორიცხული ზარების სიაში: ამას მოითხოვს ბრძანების გარსი. shell).

glibc-ის ჩემს ვერსიაში სისტემური ზარი წყვეტს პროცესს exit_group, არა ტრადიციული _exit. ეს არის სისტემურ ზარებთან მუშაობის სირთულე: ინტერფეისი, რომლითაც მუშაობს პროგრამისტი, პირდაპირ არ არის დაკავშირებული სისტემურ ზარებთან. უფრო მეტიც, ის რეგულარულად იცვლება განხორციელებისა და პლატფორმის მიხედვით.

საფუძვლები: პროცესის გაწევრიანება

თავდაპირველად, ptrace სისტემის ზარი, რომელზეც ის აშენდა strace, შეიძლება გამოყენებულ იქნას მხოლოდ პროგრამის სპეციალურ რეჟიმში გაშვებისას. ეს შეზღუდვა შეიძლება გონივრულად ჟღერდა Unix 6 ვერსიის დღეებში. დღესდღეობით ეს საკმარისი აღარ არის: ხანდახან საჭიროა სამუშაო პროგრამის პრობლემების გამოკვლევა. ტიპიური მაგალითია სახელურზე დაბლოკილი პროცესი ან ძილი. ამიტომ თანამედროვე 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. ორი რამ ცხადი გახდა: პაუზის სისტემური ზარი უგულებელყოფს სიგნალებს დამმუშავებლების გარეშე და რაც უფრო საინტერესოა, სტრაისი მონიტორირებს არა მხოლოდ სისტემურ ზარებს, არამედ შემომავალ სიგნალებსაც.

მაგალითი: ბავშვის პროცესების თვალყურის დევნება

პროცესებთან მუშაობა ზარის საშუალებით 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 flag:

$ 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, როგორც რეგულარული პროცესების შემთხვევაში, დაამატებს პროცესის პიდს თითოეული ხაზის დასაწყისში.

ბუნებრივია, ჩვენ არ ვსაუბრობთ ძაფების იდენტიფიკატორზე 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 +++

შეცდომის ინექციის გარდა, შეიძლება ზარების განხორციელებისას ან სიგნალების მიღებისას შეფერხებების დანერგვა.

Afterword

კომუნალური strace - მარტივი და საიმედო ინსტრუმენტი. მაგრამ სისტემური ზარების გარდა, პროგრამებისა და ოპერაციული სისტემის მუშაობის სხვა ასპექტები შეიძლება გამართული იყოს. მაგალითად, მას შეუძლია თვალყური ადევნოს ზარებს დინამიურად დაკავშირებულ ბიბლიოთეკებში. კვალი, მათ შეუძლიათ დაათვალიერონ ოპერაციული სისტემის მუშაობა SystemTap и ფტერასიდა საშუალებას გაძლევთ ღრმად გამოიკვლიოთ პროგრამის შესრულება perf. მიუხედავად ამისა, ეს არის strace - თავდაცვის პირველი ხაზი საკუთარ და სხვის პროგრამებთან დაკავშირებით პრობლემების შემთხვევაში და კვირაში ორჯერ მაინც ვიყენებ.

მოკლედ, თუ გიყვართ Unix, წაიკითხეთ man 1 strace და თავისუფლად გადახედეთ თქვენს პროგრამებს!

წყარო: www.habr.com