strace 是什么？

按照strace官网的描述, strace是一个可用于诊断、调试和教学的Linux用户空间跟踪器。我们用它来监控用户空间进程和内核的交互，比如系统调用、信号传递、进程状态变更等。

strace底层使用内核的ptrace特性来实现其功能。

在运维的日常工作中，故障处理和问题诊断是个主要的内容，也是必备的技能。strace作为一种动态跟踪工具，能够帮助运维高效地定位进程和服务故障。它像是一个侦探，通过系统调用的蛛丝马迹，告诉你异常的真相。

最简单的方式，它可以从头到尾跟踪binary的执行，然后以一行文本输出系统调用的名字，参数和返回值。
其实它可以做的更多：

• 可以对特定的系统调用或者几组系统调用进行过滤
• 可以通过统计特定系统调用的调用次数、耗费的时间、成功和失败的次数来配置(profile)系统调用的使用I
• 跟踪发送给进程的信号量
• 可以通过pid附着(attach)到任何运行的进程

如果你使用的是其它Unix系统，它类似于”truss”。其它更复杂的是Sun的Dtrace.

strace 怎么用？

既然strace是用来跟踪用户空间进程的系统调用和信号的，在进入strace使用的主题之前，我们的先理解什么是系统调用。

关于系统调用：
按维基百科中的解释，在计算机中，系统调用（英语：system call），又称为系统呼叫，指运行在用户空间的程序向操作系统内核请求需要更高权限运行的服务**。
系统调用提供用户程序与操作系统之间的接口。

操作系统的进程空间分为用户空间和内核空间：**

• 操作系统内核直接运行在硬件上，提供设备管理、内存管理、任务调度等功能。
• 用户空间通过API请求内核空间的服务来完成其功能——内核提供给用户空间的这些API, 就是系统调用。

在Linux系统上，应用代码通过glibc库封装的函数，间接使用系统调用。
Linux内核目前有300多个系统调用，详细的列表可以通过syscalls手册页查看。这些系统调用主要分为几类：

1. 文件和设备访问类 比如 open/close/read/write/chmod 等
2. 进程管理类 fork/clone/execve/exit/getpid 等
3. 信号类 signal/sigaction/kill 等
4. 内存管理 brk/mmap/mlock 等
5. 进程间通信IPC shmget/semget * 信号量，共享内存，消息队列等
6. 网络通信 socket/connect/sendto/sendmsg 等
7. 其他

熟悉Linux系统调用/系统编程，能够让我们在使用strace时得心应手。不过，对于运维的问题定位来说，知道strace这个工具，会查系统调用手册，就差不多够了。
我们回到strace的使用上来。strace有两种运行模式。
一种是通过它启动要跟踪的进程。用法很简单，在原本的命令前加上strace即可。比如我们要跟踪 “ls -lh /var/log/messages” 这个命令的执行，可以这样：
strace ls -lh /var/log/messages

另外一种运行模式，是跟踪已经在运行的进程，在不中断进程执行的情况下，理解它在干嘛。 这种情况，给strace传递个-p pid 选项即可**。
比如，有个在运行的some_server服务，第一步，查看pid:
pidof some_server 17553

得到其pid 17553然后就可以用strace跟踪其执行:
strace -p 17553

完成跟踪时，按ctrl + C 结束strace即可。
strace有一些选项可以调整其行为，我们这里介绍下其中几个比较常用的，然后通过示例讲解其实际应用效果。

strace 问题定位案例

1、定位进程异常退出

问题：机器上有个叫做run.sh的常驻脚本，运行一分钟后会死掉。需要查出死因。
定位：进程还在运行时，通过ps命令获取其pid, 假设我们得到的pid是24298
strace -o strace.log -tt -p 24298

查看strace.log, 我们在最后2行看到如下内容:
22:47:42.803937 wait4(-1, 22:47:43.228422 +++ killed by SIGKILL +++

这里可以看出，进程是被其他进程用KILL信号杀死的。
实际上，通过分析，我们发现机器上别的服务有个监控脚本，它监控一个也叫做run.sh的进程，当发现run.sh进程数大于2时，就会把它杀死重启。结果导致我们这个run.sh脚本被误杀。
进程被杀退出时，strace会输出killed by SIGX(SIGX代表发送给进程的信号)等，那么，进程自己退出时会输出什么呢？

这里有个叫做test_exit的程序，其代码如下:

#include <stdio.h>
#include <stdlib.h>
int main(int argc, char **argv) {
       exit(1);
}

我们strace看下它退出时strace上能看到什么痕迹。
strace -tt -e trace=process -f ./test_exit
说明: -e trace=process 表示只跟踪和进程管理相关的系统调用。
输出：

23:07:24.672849 execve("./test_exit", ["./test_exit"], [/* 35 vars */]) = 0
23:07:24.674665 arch_prctl(ARCH_SET_FS, 0x7f1c0eca7740) = 0
23:07:24.675108 exit_group(1)           = ?
23:07:24.675259 +++ exited with 1 +++

可以看出，进程自己退出时（调用exit函数，或者从main函数返回）, 最终调用的是exit_group系统调用， 并且strace会输出exited with X（X为退出码）。

可能有人会疑惑，代码里面明明调用的是exit, 怎么显示为exit_group?

这是因为这里的exit函数不是系统调用，而是glibc库提供的一个函数，exit函数的调用最终会转化为exit_group系统调用，它会退出当前进程的所有线程。实际上，有一个叫做_exit()的系统调用(注意exit前面的下划线), 线程退出时最终会调用它。

2、定位共享内存异常

有个服务启动时报错：
shmget 267264 30097568: Invalid argument
Can not get shm…exit!

错误日志大概告诉我们是获取共享内存出错，通过strace看下：
strace -tt -f -e trace=ipc ./a_mon_svr ../conf/a_mon_svr.conf
输出：

22:46:36.351798 shmget(0x5feb, 12000, 0666) = 0
22:46:36.351939 shmat(0, 0, 0)          = ?
Process 21406 attached
22:46:36.355439 shmget(0x41400, 30097568, 0666) = -1 EINVAL (Invalid argument)
shmget 267264 30097568: Invalid argument
Can not get shm...exit!

这里，我们通过-e trace=ipc 选项，让strace只跟踪和进程通信相关的系统调用。
从strace输出，我们知道是shmget系统调用出错了，errno是EINVAL。同样， 查询下shmget手册页，搜索EINVAL的错误码的说明:
EINVAL A new segment was to be created and size < SHMMIN or size > SHMMAX, or no new segment was to be created, a segment with given key existed, but size is greater than the size of that segment

翻译下，shmget设置EINVAL错误码的原因为下列之一：

• 要创建的共享内存段比 SHMMIN小 (一般是1个字节)
• 要创建的共享内存段比 SHMMAX 大 (内核参数kernel.shmmax配置)
• 指定key的共享内存段已存在，其大小和调用shmget时传递的值不同。

从strace输出看，我们要连的共享内存key 0x41400, 指定的大小是30097568字节，明显与第1、2种情况不匹配。那只剩下第三种情况。使用ipcs看下是否真的是大小不匹配：

ipcs  -m | grep 41400
key        shmid      owner      perms      bytes      nattch     status    
0x00041400 1015822    root       666        30095516   1

可以看到，已经0x41400这个key已经存在，并且其大小为30095516字节，和我们调用参数中的30097568不匹配，于是产生了这个错误。
在我们这个案例里面，导致共享内存大小不一致的原因，是一组程序中，其中一个编译为32位，另外一个编译为64位,代码里面使用了long这个变长int数据类型。

把两个程序都编译为64解决了这个问题。

这里特别说下strace的-e trace选项。
要跟踪某个具体的系统调用，-e trace=xxx即可**。但有时候我们要跟踪一类系统调用，比如所有和文件名有关的调用、所有和内存分配有关的调用。

如果人工输入每一个具体的系统调用名称，可能容易遗漏。于是strace提供了几类常用的系统调用组合名字。

-e trace=file      跟踪和文件访问相关的调用(参数中有文件名)
-e trace=process   和进程管理相关的调用，比如fork/exec/exit_group
-e trace=network   和网络通信相关的调用，比如socket/sendto/connect
-e trace=signal    信号发送和处理相关，比如kill/sigaction
-e trace=desc      和文件描述符相关，比如write/read/select/epoll等
-e trace=ipc       进程见同学相关，比如shmget等

绝大多数情况，我们使用上面的组合名字就够了。实在需要跟踪具体的系统调用时，可能需要注意C库实现的差异。

比如我们知道创建进程使用的是fork系统调用，但在glibc里面，fork的调用实际上映射到了更底层的clone系统调用。使用strace时，得指定-e trace=clone, 指定-e trace=fork什么也匹配不上。

3、性能分析

假如有个需求，统计Linux 4.5.4 版本内核中的代码行数(包含汇编和C代码)。这里提供两个Shell脚本实现：
poor_script.sh

!/bin/bash
total_line=0
while read filename; do
   line=$(wc -l $filename | awk ‘{print $1}’)
   (( total_line += line ))
done < <( find linux-4.5.4 -type f  ( -iname ‘.c’ -o -iname ‘.h’ -o -iname ‘*.S’ ) )
echo “total line: $total_line”

good_script.sh

!/bin/bash
find linux-4.5.4 -type f  ( -iname ‘.c’ -o -iname ‘.h’ -o -iname ‘*.S’ ) -print0 \
| wc -l —files0-from - | tail -n 1

两段代码实现的目的是一样的。 我们通过 strace 的 -c 选项来分别统计两种版本的系统调用情况和其所花的时间(使用-f同时统计子进程的情况)
从两个输出可以看出，good_script.sh 只需要2秒就可以得到结果：19613114行。它大部分的调用(calls)开销是文件操作(read/open/write/close)等，统计代码行数本来就是干这些事情。

而poor_script.sh完成同样的任务则花了539秒。它大部分的调用开销都在进程和内存管理上(wait4/mmap/getpid…)。
实际上，从两个图中clone系统调用的次数,我们可以看出good_script.sh只需要启动3个进程，而poor_script.sh完成整个任务居然启动了126335个进程！

而进程创建和销毁的代价是相当高的，性能不差才怪。

4、找出程序在startup的时候读取的哪个config文件？

有没有尝过解决为什么某些程序不读取你认为它应该读取的config文件的问题？

1. $ strace php 2>&1 | grep php.ini
2. open(“/usr/local/bin/php.ini”, O_RDONLY) = -1 ENOENT (No such file or directory)
3. open(“/usr/local/lib/php.ini”, O_RDONLY) = 4
4. lstat64(“/usr/local/lib/php.ini”, {st_mode=S_IFLNK|0777, st_size=27, …}) = 0
5. readlink(“/usr/local/lib/php.ini”, “/usr/local/Zend/etc/php.ini”, 4096) = 27
6. lstat64(“/usr/local/Zend/etc/php.ini”, {st_mode=S_IFREG|0664, st_size=40971, …}) = 0

可以看出这个版本的PHP从/usr/local/lib/php.init读取config文件（但是先尝试/usr/locl/bin)
如果只关心特定的系统调用，有更精致的方法

1. $ strace -e open php 2>&1 | grep php.ini
2. open(“/usr/local/bin/php.ini”, O_RDONLY) = -1 ENOENT (No such file or directory)
3. open(“/usr/local/lib/php.ini”, O_RDONLY) = 4

相同的方法适用于很多其它类似的问题。比如说，安装了不同版本的library，不确定实际上加载了哪一个版本。
-e expr — a qualifying expression: option=[!]all or option=[!]val1[,val2]…
options: trace, abbrev, verbose, raw, signal, read, write

5、为什么这个程序没有打开我的文件？

是否曾经碰到过一个程序拒绝读取它没有权限的文件，但是你发誓原因是它没有真正找到那个文件？对程序跟踪open,access调用，注意失败的情况

1. $ strace -e open,access 2>&1 | grep your-filename
   

   6、是谁偷走了时间？

   你可以重新编译app，打开profiling，以获取精确的信息。但是通常利用strace附着(attach）一个进程以快速地看一下当前时间花费在哪里非常有用。可以看下是否90%的CPU用在真正的工作，或者用在其它方面了。

2. root@dev:~# strace -c -p 11084

3. Process 11084 attached - interrupt to quit
4. Process 11084 detached
5. % time seconds usecs/call calls errors syscall

6. ---

7. 94.59 0.001014 48 21 select
8. 2.89 0.000031 1 21 getppid
9. 2.52 0.000027 1 21 time

10. ---

11. 100.00 0.001072 63 total

12. root@dev:~#

    
    -c — count time, calls, and errors for each syscall and report summary
    -C — like -c but also print regular output
    
    在执行 strace -c -p 命令以后，等到你关注的时间到了后，按 ctrl-c 退出，strace 会列出如上的 profiling 数据。
    在这个例子中，程序花了绝大部分时间在等待select()。它在每一个slect()调用这件调用getpid()和time()，这是一种典型的事件循环。
    After you’ve started strace with -c -p you just wait for as long as you care to, and then exit with ctrl-c. Strace will spit out profiling data as above. In this case, it’s an idle Postgres “postmaster” process that’s spending most of it’s time quietly waiting in select(). In this case it’s calling getppid() and time() in between each select() call, which is a fairly standard event loop. You can also run this “start to finish”, here with “ls”:

13. root@dev:~# strace -c >/dev/null ls

14. % time seconds usecs/call calls errors syscall

15. ---

16. 23.62 0.000205 103 2 getdents64
17. 18.78 0.000163 15 11 1 open
18. 15.09 0.000131 19 7 read
19. 12.79 0.000111 7 16 old_mmap
20. 7.03 0.000061 6 11 close
21. 4.84 0.000042 11 4 munmap
22. 4.84 0.000042 11 4 mmap2
23. 4.03 0.000035 6 6 6 access
24. 3.80 0.000033 3 11 fstat64
25. 1.38 0.000012 3 4 brk
26. 0.92 0.000008 3 3 3 ioctl
27. 0.69 0.000006 6 1 uname
28. 0.58 0.000005 5 1 set_thread_area
29. 0.35 0.000003 3 1 write
30. 0.35 0.000003 3 1 rt_sigaction
31. 0.35 0.000003 3 1 fcntl64
32. 0.23 0.000002 2 1 getrlimit
33. 0.23 0.000002 2 1 set_tid_address
34. 0.12 0.000001 1 1 rt_sigprocmask

35. ---

36. 100.00 0.000868 87 10 total

正如你的预期，它耗费了大部分时间在两次调用来读取目录条目上（因为运行于一个小的目录上，所有只有两次）

7、为什么 无法连接到服务器?

调试进程无法连接到远端服务器有时候是件非常头痛的事。DNS会失败，connect会挂起，server有可能返回一些意料之外的数据。
可以使用tcpdump来分析这些情况，它是一个非常棒的工作。
但是有时候你strace可以给你更简单，耿直借的角度，因为strace只返回你的进程相关的系统调用产生的数据。
如果你要从100个连接到统一个数据服务器的运行进程里面找出一个连接所做的事情，用strace就比tcpdump简单得多。

下面是跟踪”nc”连接到www.news.com 80端口的例子

1. $ strace -e poll,select,connect,recvfrom,sendto nc www.news.com 80
2. sendto(3, “\24\0\0\0\26\0\1\3\255\373NH\0\0\0\0\0\0\0\0”, 20, 0, {sa_family=AF_NETLINK, pid=0, groups=00000000}, 12) = 20
3. connect(3, {sa_family=AF_FILE, path=”/var/run/nscd/socket”}, 110) = -1 ENOENT (No such file or directory) //连接失败
4. connect(3, {sa_family=AF_FILE, path=”/var/run/nscd/socket”}, 110) = -1 ENOENT (No such file or directory)
5. connect(3, {sa_family=AF_INET, sin_port=htons(53), sin_addr=inet_addr(“62.30.112.39”)}, 28) = 0 //连接DNS
6. poll([{fd=3, events=POLLOUT, revents=POLLOUT}], 1, 0) = 1
7. sendto(3, “\213\321\1\0\0\1\0\0\0\0\0\0\3www\4news\3com\0\0\34\0\1”, 30, MSG_NOSIGNAL, NULL, 0) = 30
8. poll([{fd=3, events=POLLIN, revents=POLLIN}], 1, 5000) = 1
9. recvfrom(3, “\213\321\201\200\0\1\0\1\0\1\0\0\3www\4news\3com\0\0\34\0\1\300\f”…, 1024, 0, {sa_family=AF_INET, sin_port=htons(53), sin_addr=inet_addr(“62.30.112.39”)}, [16]) = 153
10. connect(3, {sa_family=AF_INET, sin_port=htons(53), sin_addr=inet_addr(“62.30.112.39”)}, 28) = 0
11. poll([{fd=3, events=POLLOUT, revents=POLLOUT}], 1, 0) = 1
12. sendto(3, “k\374\1\0\0\1\0\0\0\0\0\0\3www\4news\3com\0\0\1\0\1”, 30, MSG_NOSIGNAL, NULL, 0) = 30
13. poll([{fd=3, events=POLLIN, revents=POLLIN}], 1, 5000) = 1
14. recvfrom(3, “k\374\201\200\0\1\0\2\0\0\0\0\3www\4news\3com\0\0\1\0\1\300\f”…, 1024, 0, {sa_family=AF_INET, sin_port=htons(53), sin_addr=inet_addr(“62.30.112.39”)}, [16]) = 106
15. connect(3, {sa_family=AF_INET, sin_port=htons(53), sin_addr=inet_addr(“62.30.112.39”)}, 28) = 0
16. poll([{fd=3, events=POLLOUT, revents=POLLOUT}], 1, 0) = 1
17. sendto(3, “\\\2\1\0\0\1\0\0\0\0\0\0\3www\4news\3com\0\0\1\0\1”, 30, MSG_NOSIGNAL, NULL, 0) = 30
18. poll([{fd=3, events=POLLIN, revents=POLLIN}], 1, 5000) = 1
19. recvfrom(3, “\\\2\201\200\0\1\0\2\0\0\0\0\3www\4news\3com\0\0\1\0\1\300\f”…, 1024, 0, {sa_family=AF_INET, sin_port=htons(53), sin_addr=inet_addr(“62.30.112.39”)}, [16]) = 106
20. connect(3, {sa_family=AF_INET, sin_port=htons(80), sin_addr=inet_addr(“216.239.122.102”)}, 16) = -1 EINPROGRESS (Operation now in progress)
21. select(4, NULL, [3], NULL, NULL) = 1 (out [3])

发生了什么？**
注意到尝试连接 /var/run/nscd/socket? 这意味着 nc 首先尝试连接 NSCD—the Name Service Cache Daemon— 它通常用来基于 NIS,YP,LDAP 或者类似的目录协议提供域名查询。在这里它失败了。

然后它连接DNS（DNS是port 53,所以”sin_port=htons(53)”)。然后它调用了”sendto（）“,发送包含www.news.com的DNS 包。然后读回响应。不知为何，它尝试了三次，最后一次有细微的却别，我猜是它www.news.com是一个CNAME（别名），多次请求可能是nc故意的。

最后，它发起一个connect()请求到得到的IP地址，注意到返回值是EINPROGRESS。这意味这connect是非阻塞的，nc希望继续处理，然后它调用slect()，连接建立后，select返回成功。

添加”read”,”write”到过滤系统调用列表中，连接时输入一个字串，可能会得到如下：

1. read(0, “test\n”, 1024) = 5
2. write(3, “test\n”, 5) = 5
3. poll([{fd=3, events=POLLIN, revents=POLLIN}, {fd=0, events=POLLIN}], 2, -1) = 1
4. read(3, “

这表示从标准输入读入”test”+换行符，并写到网络连接中，然后调用poll等待响应，读取响应，写回标准输出。
一切看起来都正常工作。

英文原文： Notice the connection attempts to /var/run/nscd/socket? They mean nc first tries to connect to NSCD - the Name Service Cache Daemon - which is usually used in setups that rely on NIS, YP, LDAP or similar directory protocols for name lookups. In this case the connects fails. It then moves on to DNS (DNS is port 53, hence the “sin_port=htons(53)” in the following connect. You can see it then does a “sendto()” call, sending a DNS packet that contains www.news.com. It then reads back a packet. For whatever reason it tries three times, the last with a slightly different request. My best guess why in this case is that www.news.com is a CNAME (an “alias”), and the multiple requests may just be an artifact of how nc deals with that. Then in the end, it finally issues a connect() to the IP it found. Notice it returns EINPROGRESS. That means the connect was non-blocking - nc wants to go on processing. It then calls select(), which succeeds when the connection was successful. Try adding “read” and “write” to the list of syscalls given to strace and enter a string when connected, and you’ll get something like this:

strace 参数

-c     统计每一系统调用的所执行的时间,次数和出错的次数等.  【=====重要=====】
-d     输出strace关于标准错误的调试信息. 
-f     跟踪由fork调用所产生的子进程. 
-ff     如果提供-o filename,则所有进程的跟踪结果输出到相应的filename.pid中,pid是各进程的进程号. 
-F     尝试跟踪vfork调用.在-f时,vfork不被跟踪. 
-h     输出简要的帮助信息. 
-i     输出系统调用的入口指针. 
-q     禁止输出关于脱离的消息. 
-r     打印出相对时间关于,每一个系统调用. 
-t     在输出中的每一行前加上时间信息. 
-tt     在输出中的每一行前加上时间信息,微秒级. 
-ttt     微秒级输出,以秒了表示时间. 
-T     显示每一调用所耗的时间. 
-v     输出所有的系统调用.一些调用关于环境变量,状态,输入输出等调用由于使用频繁,默认不输出. 
-V     输出strace的版本信息. 
-x     以十六进制形式输出非标准字符串 
-xx     所有字符串以十六进制形式输出. 
-a column 
    设置返回值的输出位置.默认 为40. 
-e expr    只跟踪指定的系统调用（-e $func） 【=====重要=====】
    指定一个表达式,用来控制如何跟踪.格式如下: 
    [qualifier=][!]value1[,value2]... 
    qualifier只能是 trace,abbrev,verbose,raw,signal,read,write其中之一.value是用来限定的符号或数字.默认的 qualifier                是 trace.感叹号是否定符号.例如: 
    -eopen等价于 -e trace=open,表示只跟踪open调用.而-etrace!=open表示跟踪除了open以外的其他调用.有两个特殊的符号 all 和 none. 
    注意有些shell使用!来执行历史记录里的命令,所以要使用\\. 
-e trace= 
    只跟踪指定的系统 调用.例如:-e trace=open,close,rean,write表示只跟踪这四个系统调用.默认的为set=all. 
-e trace=file 
    只跟踪有关文件操作的系统调用. 
-e trace=process 
    只跟踪有关进程控制的系统调用. 
-e trace=network 
    跟踪与网络有关的所有系统调用. 
-e strace=signal 
    跟踪所有与系统信号有关的 系统调用 
-e trace=ipc 
    跟踪所有与进程通讯有关的系统调用 
-e abbrev= 
    设定 strace输出的系统调用的结果集.-v 等与 abbrev=none.默认为abbrev=all. 
-e raw= 
    将指 定的系统调用的参数以十六进制显示. 
-e signal= 
    指定跟踪的系统信号.默认为all.如 signal=!SIGIO(或者signal=!io),表示不跟踪SIGIO信号. 
-e read= 
    输出从指定文件中读出 的数据.例如: 
-e read=, 
-e write= 
    输出写入到指定文件中的数据. 
-o filename 
    将strace的输出写入文件filename 
-p pid 【=====重要=====】
    跟踪指定的进程pid. 
-s strsize 
    指定输出的字符串的最大长度.默认为32.文件名一直全部输出. 
-u username 
    以username 的UID和GID执行被跟踪的命令

strace 示例

示例一

sudo strace -e read,write -p 8599
监控所有的 read, write 调用了

示例二

strace -tt -T -v -f -e trace=file -o /data/log/strace.log -s 1024 -p 23489
-tt 在每行输出的前面，显示毫秒级别的时间
-T 显示每次系统调用所花费的时间
-v 对于某些相关调用，把完整的环境变量，文件stat结构等打出来。
-f 跟踪目标进程，以及目标进程创建的所有子进程
-e 控制要跟踪的事件和跟踪行为,比如指定要跟踪的系统调用名称
-o 把strace的输出单独写到指定的文件
-s 当系统调用的某个参数是字符串时，最多输出指定长度的内容，默认是32个字节
-p 指定要跟踪的进程pid, 要同时跟踪多个pid, 重复多次-p选项即可。

实例：跟踪nginx, 看其启动时都访问了哪些文件**
strace -tt -T -f -e trace=file -o /data/log/strace.log -s 1024 ./nginx
部分输出:


输出中，第一列显示的是进程的pid, 接着是毫秒级别的时间，这个是-tt 选项的效果。
每一行的最后一列，显示了该调用所花的时间，是-T选项的结果。
这里的输出只显示和文件访问有关的内容，这是因为我们通过-e trace=file 选项指定了。

总结

当发现进程或服务异常时，我们可以通过strace来跟踪其系统调用，“看看它在干啥”，进而找到异常的原因。熟悉常用系统调用，能够更好地理解和使用strace。
当然，万能的strace也不是真正的万能。当目标进程卡死在用户态时，strace就没有输出了。
这个时候我们需要其他的跟踪手段，比如 gdb/perf/SystemTap等。

备注：
1、perf原因kernel支持
2、ftrace kernel支持可编程
3、systemtap 功能强大，RedHat系统支持，对用户态，内核态逻辑都能探查，使用范围更广
本文永久更新链接地址：http://www.linuxidc.com/Linux/2018-01/150654.htm