Unix 계열 운영 체제에서 프로그램과 외부 세계 및 운영 체제와의 통신은 시스템 호출이라는 작은 기능 집합을 통해 이루어집니다. 이는 디버깅 목적으로 프로세스에서 실행되는 시스템 호출을 감시하는 것이 유용할 수 있음을 의미합니다.

Linux에서 프로그램의 "친밀한 수명"을 모니터링하는 데 도움이 되는 유틸리티 strace, 이것이 이 기사의 주제입니다. 스파이 장비의 사용 사례는 간략한 역사를 동반합니다. strace 그리고 그러한 프로그램의 설계에 대한 설명.

내용

• 종의 기원
• 간단히 말해서 Strace 장치: Piglet Trace
• 기본 사항: strace를 실행하는 프로그램 실행
• 기본 사항: 즉석에서 프로세스에 참여
• 예: 하위 프로세스 추적
• 예: 핸들 대신 파일 경로
• 예: 파일 액세스 추적
• 예: 다중 스레드 프로그램
• 마스터 클래스: 시스템 호출 시 프로세스 스택
• 마스터 클래스: 오류 주입
• 사후

종의 기원

Unix에서 프로그램과 OS 커널 간의 주요 인터페이스는 시스템 호출입니다. 시스템 호출, 시스템 호출), 프로그램과 외부 세계의 상호 작용은 이를 통해서만 발생합니다.

그러나 최초의 공개 유닉스 버전에서는 (버전 6 유닉스, 1975) 사용자 프로세스의 동작을 추적하는 편리한 방법이 없었습니다. 이 문제를 해결하기 위해 Bell Labs는 다음 버전(버전 7 유닉스, 1979)은 새로운 시스템 호출을 제안했습니다. ptrace.

ptrace는 주로 대화형 디버거를 위해 개발되었으나 80년대 말(상업화 시대)에 시스템 V 릴리스 4) 이를 바탕으로 좁게 초점을 맞춘 디버거(시스템 호출 추적기)가 등장하여 널리 사용되었습니다.

처음으로 동일한 버전의 strace가 폐쇄형 유틸리티의 대안으로 Paul Cronenburg에 의해 1992년 comp.sources.sun 메일링 리스트에 게시되었습니다. trace 태양에서. 복제품과 원본 모두 SunOS용으로 제작되었지만 1994년에는 strace System V, Solaris 및 점점 더 인기를 얻고 있는 Linux로 포팅되었습니다.

현재 strace는 Linux만 지원하며 동일한 Linux에 의존합니다. ptrace, 많은 확장으로 자란다.

현대적이고 매우 활동적인 관리자 strace - 드미트리 레빈. 그 덕분에 유틸리티는 시스템 호출에 오류 삽입, 광범위한 아키텍처 지원, 그리고 가장 중요한 기능과 같은 고급 기능을 획득했습니다. 마스코트. 비공식 소식통은 러시아어 단어 "타조"와 영어 단어 "strace" 사이의 자음 때문에 선택이 타조에 이르렀다고 주장합니다.

Linux, FreeBSD, OpenBSD 및 기존 Unix에서의 오랜 역사와 구현에도 불구하고 ptrace 시스템 호출 및 추적 프로그램이 POSIX에 포함되지 않았다는 점도 중요합니다.

간단히 말해서 Strace 장치: Piglet Trace

"당신은 이것을 이해하지 못할 것으로 예상됩니다"(Dennis Ritchie, 버전 6 Unix 소스 코드의 주석)

어린 시절부터 나는 블랙 박스를 참을 수 없었습니다. 장난감을 가지고 놀지는 않았지만 그 구조를 이해하려고 노력했습니다 (성인들은 "부서졌다"라는 단어를 사용했지만 사악한 방언을 믿지 않았습니다). 아마도 이것이 최초의 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 parent는 시스템 호출이 실행되기 전이나 완료된 직후에 완료됩니다. 두 호출 사이에서 호출을 대체 호출로 대체하거나 인수 또는 반환 값을 변경하는 등 모든 작업을 수행할 수 있습니다.

명령을 두 번만 호출하면 됩니다. ptrace(PTRACE_GETREGS)레지스터 상태를 얻으려면 rax 호출 전(시스템 호출 번호) 및 직후(반환 값).

실제로 주기는 다음과 같습니다.

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

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

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

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

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

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

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

그것이 전체 추적자입니다. 이제 다음 포팅을 시작할 위치를 알았습니다. DTrace 리눅스에서.

기본 사항: strace를 실행하는 프로그램 실행

첫 번째 사용 사례로 strace, 아마도 가장 간단한 방법을 인용할 가치가 있을 것입니다. 실행 중인 애플리케이션을 시작하는 것입니다. strace.

일반적인 프로그램의 끝없는 호출 목록을 조사하지 않기 위해 다음과 같이 작성합니다. 최소 프로그램 주위에 write:

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

프로그램을 빌드하고 작동하는지 확인해 보겠습니다.

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

마지막으로 strace 제어 하에서 실행해 보겠습니다.

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

매우 "말이 많고" 별로 교육적이지 않습니다. 여기에는 두 가지 문제가 있습니다. 프로그램 출력이 출력과 혼합됩니다. strace 그리고 우리에게 관심이 없는 풍부한 시스템 호출이 있습니다.

시스템 호출 목록을 인수 파일로 리디렉션하는 -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 - 모든 유닉스의 기초. 간단한 "번식"의 예를 사용하여 프로세스 트리에서 strace가 어떻게 작동하는지 살펴보겠습니다. 프로그램:

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

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

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

    wait(NULL);

    exit(EXIT_SUCCESS);
}

여기서 원래 프로세스는 표준 출력에 쓰는 하위 프로세스를 생성합니다.

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

기본적으로 상위 프로세스의 시스템 호출만 볼 수 있습니다.

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

플래그는 전체 프로세스 트리를 추적하는 데 도움이 됩니다. -f, 어느 strace 하위 프로세스의 시스템 호출을 모니터링합니다. 이것은 각 출력 라인에 추가됩니다. pid 시스템 출력을 만드는 프로세스:

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

이러한 맥락에서 시스템 호출 그룹별로 필터링하는 것이 유용할 수 있습니다.

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

그런데 새로운 프로세스를 생성하는 데 어떤 시스템 호출이 사용됩니까?

예: 핸들 대신 파일 경로

파일 설명자를 아는 것은 확실히 유용하지만 프로그램이 액세스하는 특정 파일의 이름도 유용할 수 있습니다.

다음 프로그램 임시 파일에 다음 줄을 씁니다.

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

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

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

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

    do_write(out_fd);

    return EXIT_SUCCESS;
}

일반 통화 중 strace 시스템 호출에 전달된 설명자 번호의 값을 표시합니다.

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

깃발로 -y 유틸리티는 설명자가 해당하는 파일의 경로를 표시합니다.

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

예: 파일 액세스 추적

또 다른 유용한 기능: 특정 파일과 관련된 시스템 호출만 표시합니다. 다음 프로그램 인수로 전달된 임의의 파일에 한 줄을 추가합니다.

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

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

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

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

    do_write(out_fd);

    return EXIT_SUCCESS;
}

기본적으로 strace 불필요한 정보를 많이 표시합니다. 깃발 -P 인수를 사용하면 strace는 지정된 파일에 대한 호출만 인쇄합니다.

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

예: 다중 스레드 프로그램

공익 사업 strace 멀티스레드 작업 시에도 도움이 될 수 있습니다. 프로그램. 다음 프로그램은 두 스트림의 표준 출력에 씁니다.

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

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

    return NULL;
}

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

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

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

    printf("Initial thread: done");

    exit(EXIT_SUCCESS);
}

당연히 링커에 대한 특별한 인사말인 -pthread 플래그를 사용하여 컴파일해야 합니다.

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

깃발 -f, 일반 프로세스의 경우와 마찬가지로 각 줄의 시작 부분에 프로세스의 pid를 추가합니다.

당연히 우리는 POSIX Threads 표준 구현이라는 의미에서 스레드 식별자에 대해 이야기하는 것이 아니라 Linux의 작업 스케줄러에서 사용하는 숫자에 대해 이야기하고 있습니다. 후자의 관점에서는 프로세스나 스레드가 없습니다. 즉, 시스템의 사용 가능한 코어 간에 분산되어야 하는 작업이 있습니다.

여러 스레드에서 작업할 때 시스템 호출이 너무 많아집니다.

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

프로세스 관리와 시스템 호출로만 자신을 제한하는 것이 합리적입니다. write:

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

그건 그렇고, 질문. 새 스레드를 생성하는 데 어떤 시스템 호출이 사용됩니까? 스레드 호출은 프로세스 호출과 어떻게 다릅니까?

마스터 클래스: 시스템 호출 시 프로세스 스택

최근에 등장한 것 중 하나 strace 기능 - 시스템 호출 시 함수 호출 스택을 표시합니다. 단순한 예:

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

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

당연히 프로그램 출력은 매우 방대해지며 플래그 외에도 -k (호출 스택 표시) 이름별로 시스템 호출을 필터링하는 것이 좋습니다.

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

마스터 클래스: 오류 주입

그리고 또 하나의 새롭고 매우 유용한 기능은 바로 오류 주입입니다. 여기 프로그램, 출력 스트림에 두 줄을 씁니다.

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

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

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

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

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

    return EXIT_SUCCESS;
}

두 가지 쓰기 호출을 모두 추적해 보겠습니다.

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

이제 우리는 표현을 사용합니다 inject오류를 삽입하려면 EBADF 모든 쓰기 호출에서:

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

어떤 오류가 반환되는지 흥미롭습니다. 모든 도전들 write, perror 뒤에 숨겨진 호출을 포함합니다. 첫 번째 호출에 대해서만 오류를 반환하는 것이 합리적입니다.

$ 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 - 간단하고 안정적인 도구입니다. 그러나 시스템 호출 외에도 프로그램 작동 및 운영 체제의 다른 측면도 디버깅할 수 있습니다. 예를 들어 동적으로 연결된 라이브러리에 대한 호출을 추적할 수 있습니다. 추적, 운영 체제의 작동을 조사할 수 있습니다. 시스템탭 и ftrace, 프로그램 성능을 심층적으로 조사할 수 있습니다. 반환 한. 그럼에도 불구하고 그것은 strace - 내 프로그램과 다른 사람의 프로그램에 문제가 있을 경우의 첫 번째 방어선이며 일주일에 적어도 두 번 이상 사용합니다.

간단히 말해서, Unix를 좋아한다면 이 책을 읽어보세요. man 1 strace 그리고 자유롭게 프로그램을 엿보세요!

출처 : habr.com