Unix のようなオペレーティング システムでは、プログラムとオペレーティング システムとの外部の通信は、システム コールという小さな関数セットを通じて行われます。 これは、デバッグ目的で、プロセスによって実行されているシステム コールをスパイすることが役立つ可能性があることを意味します。

Linux 上のプログラムの「密接な生活」を監視するのに役立つユーティリティ strace、それがこの記事の主題です。 スパイ機器の使用例には簡単な歴史が添えられています strace およびそのようなプログラムの設計の説明。

ページ内容

• 種の起源
• Strace デバイスの概要: Piglet Trace
• 基本: プログラムの実行 strace の実行
• 基本: オンザフライでプロセスに参加する
• 例: 子プロセスの追跡
• 例: ハンドルの代わりにファイルパス
• 例: ファイルアクセス追跡
• 例: マルチスレッドプログラム
• マスタークラス：システムコール時のプロセススタック
• マスタークラス: エラー挿入
• 後書き

種の起源

Unix におけるプログラムと OS カーネル間の主なインターフェイスはシステム コールです。 システムコール, システムコール)、プログラムと外部世界との相互作用は、プログラムを通じてのみ行われます。

しかし、Unix の最初の公開バージョンでは (バージョン 6 Unix、1975) ユーザー プロセスの動作を追跡する便利な方法はありませんでした。 この問題を解決するために、ベル研究所は次のバージョンにアップデートします (バージョン 7 Unix、1979) 新しいシステムコールを提案しました - ptrace.

ptrace は主に対話型デバッガ用に開発されましたが、80 年代の終わりまでに (商用の時代には) システム V リリース 4) これに基づいて、対象を絞ったデバッガ (システム コール トレーサ) が登場し、広く使用されるようになりました。

最初の strace の同じバージョンは、閉鎖されたユーティリティの代替として、1992 年に Paul Cronenburg によって comp.sources.sun メーリング リストで公開されました。 trace サンから。 クローンとオリジナルはどちらも SunOS 向けでしたが、1994 年までに strace System V、Solaris、そして人気が高まっている Linux に移植されました。

現在、strace は Linux のみをサポートしており、同じものに依存しています。 ptrace、多くの拡張子が生い茂っています。

最新の (そして非常にアクティブな) メンテナ strace - ドミトリー・レビン。 彼のおかげで、このユーティリティは、システム コールへのエラー挿入、幅広いアーキテクチャのサポート、そして最も重要なこととして、高度な機能を獲得しました。 マスコット。 非公式情報筋によると、ロシア語の「ダチョウ」と英語の「ストラス」の調和のため、選択はダチョウに委ねられたという。

また、ptrace システム コールとトレーサは、Linux、FreeBSD、OpenBSD、および従来の Unix での長い歴史と実装にもかかわらず、POSIX には決して含まれていなかったことも重要です。

Strace デバイスの概要: Piglet Trace

「これを理解することは期待されていません」 (デニス・リッチー、バージョン 6 Unix ソース コードのコメント)

幼い頃から、私はブラックボックスが嫌いでした。おもちゃで遊ぶことはしませんでしたが、その構造を理解しようとしました（大人は「壊れた」という言葉を使いましたが、邪悪な言葉は信じていません）。 おそらくこれが、最初の Unix の非公式文化と現代のオープンソース運動が私にとって非常に身近な理由です。

この記事の目的のために、数十年にわたって成長した strace のソース コードを逆アセンブルするのは無理があります。 しかし、読者に秘密を残すべきではありません。 したがって、このような 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 親は、システム コールが実行される前、またはシステム コールが完了した直後に完了します。 XNUMX つの呼び出しの間では、呼び出しを別の呼び出しに置き換えたり、引数や戻り値を変更したりするなど、あらゆるアクションを実行できます。

コマンドを XNUMX 回呼び出すだけです 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 制御下で実行してみましょう。

$ 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)                           = ?

非常に「くどい」し、あまり教育的ではありません。 ここには XNUMX つの問題があります。プログラムの出力が出力と混合されることです。 strace そして私たちには興味のないシステムコールがたくさんあります。

-o スイッチを使用すると、プログラムの標準出力ストリームと 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 +++

除外された呼び出しのリストにあるエスケープされた感嘆符に注意してください。これはコマンド シェルで必要です。 shell).

私のバージョンの 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。 XNUMX つのことが明らかになりました。pause システム コールはハンドラーのないシグナルを無視すること、そしてさらに興味深いことに、strace はシステム コールだけでなく受信シグナルも監視することです。

例: 子プロセスの追跡

呼び出しを通じてプロセスを操作する fork - すべての Unix の基礎。 単純な「繁殖」の例を使用して、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 +++

例: ファイルアクセス追跡

もう XNUMX つの便利な機能: 特定のファイルに関連付けられたシステム コールのみを表示します。 次 プログラム 引数として渡された任意のファイルに行を追加します。

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 マルチスレッドで作業する場合にも役立ちます プログラム。 次のプログラムは、XNUMX つのストリームから標準出力に書き込みます。

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 スレッド標準の実装という意味でのスレッド識別子のことではなく、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 +++

マスタークラス: エラー挿入

そして、もう XNUMX つの非常に便利な新機能、エラー インジェクションです。 ここ プログラム、出力ストリームに XNUMX 行を書き込みます。

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

または XNUMX 番目:

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

エラー挿入以外にも、 1ことができます 電話をかけたり信号を受信したりするときに遅延が発生します。

後書き

ユーティリティ strace - シンプルで信頼性の高いツール。 ただし、システム コールに加えて、プログラムやオペレーティング システムの動作の他の側面もデバッグできます。 たとえば、動的にリンクされたライブラリへの呼び出しを追跡できます。 追跡する、オペレーティング システムの動作を調べることができます。 システムタップ и ftrace、プログラムのパフォーマンスを深く調査できます。 perf。 それにもかかわらず、それは strace - 私自身や他の人のプログラムに問題が発生した場合の防御の第一線であり、私は少なくとも週に数回はこれを使用します。

つまり、Unix が好きなら読んでください。 man 1 strace ぜひあなたのプログラムを覗いてみてください!

出所： habr.com