SystemTap使用指南

朱雀 2023-06-19 13:26 165阅读 0赞

# **1.简介** #

SystemTap是一个Linux非常有用的调试（跟踪/探测）工具，常用于Linux
     内核或者应用程序的信息采集，比如：获取一个函数里面运行时的变
     量、调用堆栈，甚至可以直接修改变量的值，对诊断性能或功能问题非
     常有帮助。SystemTap提供非常简单的命令行接口和很简洁的脚本语
     言，以及非常丰富的tapset和例子。

# **2.何时使用** #

定位（内核）函数位置
    查看函数被调用时的调用堆栈、局部变量、参数
    查看函数指针变量实际指的是哪个函数
    查看代码的执行轨迹（哪些行被执行了）
    查看内核或者进程的执行流程
    调试内存泄露或者内存重复释放
    统计函数调用次数
    ......

# **3.原理** #

在网上找了个原理图：

![systemtap][]

SystemTap的处理流程有5个步骤：解析script文件(parse)、细化（elaborate）、script文件翻译成C语言代码（translate）、编译C语言代码（生成内核模块）（build）、加载内核模块（run）

![systemtap\_phase][systemtap_phase]

# **4.安装** #

SystemTap依赖的package：  
elfutils、gcc、kernel-devel、kernel-debuginfo  
如果调用用户态进程，还需要该程序有调试符号，否则无法调试。  
推荐使用最新稳定版的SystemTap，目前最新稳定版为：systemtap-2.9.tar.gz

# **5.入门** #

**5.1 stap命令**

stap [OPTIONS] FILENAME [ARGUMENTS]
    stap [OPTIONS] - [ARGUMENTS]
    stap [OPTIONS] –e SCRIPT [ARGUMENTS]
    
    比较常用和有用的参数：
    -e SCRIPT               Run given script.
    -l PROBE                List matching probes.
    -L PROBE                List matching probes and local variables.
    -g                      guru mode 
    -D NM=VAL               emit macro definition into generated C code
    -o FILE                 send script output to file, instead of stdout.
    -x PID                  sets target() to PID

Hello World:

root@j9 ~/stp# cat hello-world.stp
    probe begin {
        print("===Hello World===\n")
    }
    
    probe end {
        print("===GunLe===\n")
    }
    root@j9 ~/stp# stap hello-world.stp 
    ===Hello World===
    ^C===GunLe===
    root@j9 ~/stp# stap -e 'probe begin { printf("Hello World!\n") exit() }'   
    Hello World!
    root@j9 ~/stp#

**5.2 staprun命令**

staprun [OPTIONS] MODULE [MODULE-OPTIONS]

stap命令与staprun命令的区别在于：  
stap命令的操作对象是stp文件或script命令等，而staprun命令的操作对象是编译生成的内核模块。

# 6.脚本语言 #

**6.1 probe**

“probe” <=> “探测”, 是SystemTap进行具体地收集数据的关键字。  
![systemtap\_probe][systemtap_probe]

“probe point” 是probe动作的时机，也称探测点。也就是probe程序监视的某事件点，一旦侦测的事件触发了，则probe将从此处插入内核或者用户进程中。  
“probe handle” 是当probe插入内核或者用户进程后所做的具体动作。

probe用法：

probe probe-point { statement }

在Hello World例子中begin和end就是probe-point， statement就是该探测点的处理逻辑，在Hello World例子中statement只有一行print，statement可以是复杂的代码块。  
探测点语法：

kernel.function(PATTERN)
    kernel.function(PATTERN).call
    kernel.function(PATTERN).return
    kernel.function(PATTERN).return.maxactive(VALUE)
    kernel.function(PATTERN).inline
    kernel.function(PATTERN).label(LPATTERN)
    module(MPATTERN).function(PATTERN)
    module(MPATTERN).function(PATTERN).call
    module(MPATTERN).function(PATTERN).return.maxactive(VALUE)
    module(MPATTERN).function(PATTERN).inline
    kernel.statement(PATTERN)
    kernel.statement(ADDRESS).absolute
    module(MPATTERN).statement(PATTERN)
    process(PROCESSPATH).function(PATTERN)
    process(PROCESSPATH).function(PATTERN).call
    process(PROCESSPATH).function(PATTERN).return
    process(PROCESSPATH).function(PATTERN).inline
    process(PROCESSPATH).statement(PATTERN)

PATTERN语法为：

func[@file]
    func@file:linenumber

例如：

kernel.function("*init*")
    module("ext3").function("*")
    kernel.statement("*@kernel/time.c:296")
    process("/home/admin/tengine/bin/nginx").function("ngx_http_process_request")

在return探测点可以用&dollar;return获取该函数的返回值。  
inline函数无法安装.return探测点，也无法用$return获取其返回值。

**6.2 基本语法**

SystemTap脚本语法比较简单，与C语言类似，只是每一行结尾";"是可选的。主要语句如下：  
if/else、while、for/foreach、break/continue、return、next、delete、try/catch  
其中：  
next：主要在probe探测点逻辑处理中使用，调用此语句时，立刻从调用函数中退出。不同于exit()的是，next只是退出当前的调用函数，而此SystemTap并没有终了，但exit()则会终止SystemTap。

**6.2.1 变量**

不需要明确声明变量类型，脚本语言会根据函数参数等自动判断变量是什么类型的。  
局部变量：在声明的probe和block（”\{ \}“范围内的部分）内有效。  
全局变量：用”global“声明的变量，在此SystemTap的整个动作过程中都有效。全局变量的声明位置没有具体要求。需要注意的是，全局变量默认有锁保护，使用过多会有性能损失，如果用全局变量保存指针，可能出现指针所指的内容被进程修改，在探测点中拿不到真正的数据。  
获取进程中的变量（全局变量、局部变量、参数）直接在变量名前面加$即可（后面会有例子）

**6.2.2 注释**

# ...... ： Shell语言风格    
    //...... ： C++语言风格    
     /*......*/ ： C语言风格

**6.2.3 操作符**

比较运算符、算数运算符基本上与C语言一样，需要特别指出的是：  
(1)、.操作符：连接两个字符串，类似于php；  
(2)、=~和!~：正则匹配和正则不匹配；

**6.2.4 函数**

函数定义例子：

function indent:string (delta:long){
      return _generic_indent(-1, "",  delta)
    }
    
    function _generic_indent (idx, desc, delta)
    {
      ts = __indent_timestamp ()
      if (! _indent_counters[idx]) _indent_timestamps[idx] = ts
      depth = _generic_indent_depth(idx, delta)
      return sprintf("%6d (%d:%d) %s:%-*s", (ts - _indent_timestamps[idx]), depth, delta, desc, depth, "")
    }  
    
    function strlen:long(s:string) %{
        STAP_RETURN(strlen(STAP_ARG_s));
    %}

官方有很多很有用的函数，详情请参考：[https://sourceware.org/systemtap/tapsets/][https_sourceware.org_systemtap_tapsets]  
以及在本机安装了SystemTap之后在目录/usr/local/share/systemtap/tapset/下也可以看具体函数的实现以及一些奇特的用法。

# 7.技巧 #

**7.1 定位函数位置**

在一个大型项目中找出函数在哪里定义有时很有用，特别是一些比较难找出在哪里定义的函数，比如内核或者glibc中的某个函数想要看其实现时，首先得找出其在哪个文件的哪一行定义，用SystemTap一行命令就可以搞定。  
比如要看printf在glibc中哪里定义的：

root@j9 ~# stap -l 'process("/lib/x86_64-linux-gnu/libc.so.6").function("printf")' 
    process("/lib/x86_64-linux-gnu/libc-2.15.so").function("__printf@/build/buildd/eglibc-2.15/stdio-common/printf.c:29")

可以看出printf是在printf.c第29行定义的。  
再比如要看内核中recv系统的调用是在哪里定义的：

root@j9 ~# stap -l 'kernel.function("sys_recv")'
    kernel.function("sys_recv@/build/buildd/linux-lts-trusty-3.13.0/net/socket.c:1868")

可以看出recv是在socket.c第1868行定义的。  
甚至可以\*号来模糊查找：

root@j9 ~# stap -l 'kernel.function("*recv")'   
    kernel.function("__audit_mq_sendrecv@/build/buildd/linux-lts-trusty-3.13.0/kernel/auditsc.c:2062")
    kernel.function("audit_mq_sendrecv@/build/buildd/linux-lts-trusty-3.13.0/include/linux/audit.h:263")
    kernel.function("compat_sys_recv@/build/buildd/linux-lts-trusty-3.13.0/net/compat.c:762")
    kernel.function("i2c_master_recv@/build/buildd/linux-lts-trusty-3.13.0/drivers/i2c/i2c-core.c:1827")
    kernel.function("ip_cmsg_recv@/build/buildd/linux-lts-trusty-3.13.0/net/ipv4/ip_sockglue.c:147")
    kernel.function("kgdb_tty_recv@/build/buildd/linux-lts-trusty-3.13.0/drivers/tty/serial/kgdb_nmi.c:109")
    kernel.function("ppp_do_recv@/build/buildd/linux-lts-trusty-3.13.0/drivers/net/ppp/ppp_generic.c:1617")
    kernel.function("scm_recv@/build/buildd/linux-lts-trusty-3.13.0/include/net/scm.h:109")
    kernel.function("sys_recv@/build/buildd/linux-lts-trusty-3.13.0/net/socket.c:1868")
    kernel.function("tcp_event_data_recv@/build/buildd/linux-lts-trusty-3.13.0/net/ipv4/tcp_input.c:615")
    kernel.function("tcp_splice_data_recv@/build/buildd/linux-lts-trusty-3.13.0/net/ipv4/tcp.c:637")
    kernel.function("tpm_tis_recv@/build/buildd/linux-lts-trusty-3.13.0/drivers/char/tpm/tpm_tis.c:231")
    kernel.function("try_fill_recv@/build/buildd/linux-lts-trusty-3.13.0/drivers/net/virtio_net.c:615")

同理，也可以用来定位用户进程的函数位置：  
比如tengine的文件ngx\_shmem.c里面为了兼容各个操作系统而实现了三个版本的ngx\_shm\_alloc，用\#if (NGX\_HAVE\_MAP\_ANON)、\#elif (NGX\_HAVE\_MAP\_DEVZERO)、\#elif (NGX\_HAVE\_SYSVSHM)、\#endif来做条件编译，那怎么知道编译出来的是哪个版本呢，用SystemTap的话就很简单了，否则要去grep一下这几宏有没有定义才知道了。

[root@cache4 tengine]# stap -l 'process("/home/admin/tengine/bin/nginx").function("ngx_shm_alloc")'
    process("/home/admin/tengine/bin/nginx").function("ngx_shm_alloc@src/os/unix/ngx_shmem.c:15")

**7.2 查看可用探测点以及该探测点上可用的变量**

在一些探测点上能获取的变量比较有限，这是因为这些变量可能已经被编译器优化掉了，优化掉的变量就获取不到了。一般先用-L参数来看看有哪些变量可以直接使用：

[root@cache4 tengine]# stap -L 'process("/home/admin/tengine/bin/nginx").function("ngx_shm_alloc")' 
    process("/home/admin/tengine/bin/nginx").function("ngx_shm_alloc@src/os/unix/ngx_shmem.c:15") $shm:ngx_shm_t*

可见在该探测点上可以直接使用$shm这个变量，其类型是ngx\_shm\_t\*。  
statement探测点也类似：

[root@cache4 tengine]# stap -L 'process("/home/admin/tengine/bin/nginx").statement("ngx_pcalloc@src/core/ngx_palloc.c:*")'                   
    process("/home/admin/tengine/bin/nginx").statement("ngx_pcalloc@src/core/ngx_palloc.c:395") $pool:ngx_pool_t* $size:size_t
    process("/home/admin/tengine/bin/nginx").statement("ngx_pcalloc@src/core/ngx_palloc.c:398") $pool:ngx_pool_t* $size:size_t
    process("/home/admin/tengine/bin/nginx").statement("ngx_pcalloc@src/core/ngx_palloc.c:399") $size:size_t
    process("/home/admin/tengine/bin/nginx").statement("ngx_pcalloc@src/core/ngx_palloc.c:404") $size:size_t $p:void*

**7.3 输出调用堆栈**

用户态探测点堆栈：print\_ubacktrace()、sprint\_ubacktrace()  
内核态探测点堆栈：print\_backtrace()、sprint\_backtrace()  
不带s和带s的区别是前者直接输出，后者是返回堆栈字符串。  
这几个函数非常有用，在排查问题时可以根据一些特定条件来过滤函数被执行时是怎么调用进来的，比如排查tengine返回5xx时的调用堆栈是怎样的：

#cat debug_tengine_5xx.stp 
    probe process("/home/admin/tengine/bin/nginx").function("ngx_http_finalize_request").call {
        if ($rc >= 500) {
            printf("rc: %d\n", $rc)
            print_ubacktrace()
        }
    }
    
    #stap debug_tengine_5xx.stp 
    rc: 502
     0x49af2e : ngx_http_finalize_request+0xe/0x480 [/home/admin/tengine/bin/nginx]
     0x543305 : ngx_http_video_flv_send_rest+0xf5/0x380 [/home/admin/tengine/bin/nginx]
     0x543187 : ngx_http_video_finalize_request+0x57/0xe0 [/home/admin/tengine/bin/nginx]
     0x49828f : ngx_http_terminate_request+0x4f/0xc0 [/home/admin/tengine/bin/nginx]
     0x49b760 : ngx_http_test_reading+0x50/0x130 [/home/admin/tengine/bin/nginx]
     0x49779f : ngx_http_request_handler+0x1f/0x40 [/home/admin/tengine/bin/nginx]
     0x47ea8f : ngx_epoll_process_events+0x2df/0x330 [/home/admin/tengine/bin/nginx]
     0x4753f9 : ngx_process_events_and_timers+0x69/0x1c0 [/home/admin/tengine/bin/nginx]
     0x47d4d8 : ngx_worker_process_cycle+0x138/0x260 [/home/admin/tengine/bin/nginx]
     0x47a38a : ngx_spawn_process+0x1ca/0x5e0 [/home/admin/tengine/bin/nginx]
     0x47c73c : ngx_start_worker_processes+0x7c/0x100 [/home/admin/tengine/bin/nginx]
     0x47db5f : ngx_master_process_cycle+0x3af/0x9b0 [/home/admin/tengine/bin/nginx]
     0x45a740 : main+0xa90/0xb50 [/home/admin/tengine/bin/nginx]
     0x3623e1ecdd [/lib64/libc-2.12.so+0x1ecdd/0x38d000]

比如看看内核是怎么收包的：

root@jusse ~# cat netif_receive_skb.stp 
    probe kernel.function("netif_receive_skb") 
    { 
        printf("--------------------------------------------------------\n"); 
        print_backtrace(); 
        printf("--------------------------------------------------------\n"); 
    } 
    root@jusse ~# stap netif_receive_skb.stp
    --------------------------------------------------------
     0xffffffff8164dc00 : netif_receive_skb+0x0/0x90 [kernel]
     0xffffffff8164e280 : napi_gro_receive+0xb0/0x130 [kernel]
     0xffffffff81554537 : handle_incoming_queue+0xe7/0x100 [kernel]
     0xffffffff815555d9 : xennet_poll+0x279/0x430 [kernel]
     0xffffffff8164ee09 : net_rx_action+0x139/0x250 [kernel]
     0xffffffff810702cd : __do_softirq+0xdd/0x300 [kernel]
     0xffffffff8107088e : irq_exit+0x11e/0x140 [kernel]
     0xffffffff8144e785 : xen_evtchn_do_upcall+0x35/0x50 [kernel]
     0xffffffff8176c9ed : xen_hvm_callback_vector+0x6d/0x80 [kernel]
    --------------------------------------------------------

**7.4 获取函数参数**

一些被编译器优化掉的函数参数用-L去看的时候没有找到，这样的话在探测点里面也不能直接用$方式获取该参数变量，这时可以使用SystemTap提供的*\_arg函数接口，*是根据类型指定的，比如pointer\_arg是获取指针类型参数，int\_arg是获取整型参数，类似的还有long\_arg、longlong\_arg、uint\_arg、ulong\_arg、ulonglong\_arg、s32\_arg、s64\_arg、u32\_arg、u64\_arg：

![image][]

root@j9 ~# stap -L 'kernel.function("sys_open")' 
    kernel.function("SyS_open@/build/buildd/linux-lts-trusty-3.13.0/fs/open.c:1011") $ret:long int
    root@j9 ~# cat sys_open.stp 
    probe kernel.function("sys_open").call
    {
        printf("filename: %p(%s), flags: %d, mode: %x\n", pointer_arg(1), kernel_string(pointer_arg(1)), int_arg(2), int_arg(3));
    }
    root@j9 ~# stap sys_open.stp 
    filename: 0xc2081d2120(/proc/stat), flags: 524288, mode: 0
    filename: 0x7facec00e838(/root/opt/libexec/systemtap/stapio), flags: 0, mode: 1b6
    filename: 0x2219488(/var/log/auth.log), flags: 0, mode: 1b6
    filename: 0x7facec00e838(/root/opt/libexec/systemtap/stapio), flags: 0, mode: 1b6
    filename: 0x7fad10172c29(/etc/passwd), flags: 524288, mode: 1b6
    ^C

再比如两个函数的函数参数类型兼容也可以使用这种方法获取：  
![image][image 1]

这两个函数的参数完全兼容，只是第二个参数命名不一样而已，可以像下面这么用：

#cat debug_tengine_5xx.stp 
    probe process("/home/admin/tengine/bin/nginx").function("ngx_http_finalize_request").call, process("/home/admin/tengine/bin/nginx").function("ngx_http_special_response_handler").call {
        rc = int_arg(2)
        if (rc >= 500) {
            printf("rc: %d\n", rc)
            print_ubacktrace()
        }
    }

**7.5 获取全局变量**

有时候用$可以直接获取到全局变量，但有时候又获取不到，那可以试试@var：  
比如获取nginx的全局变量ngx\_cycyle：

root@j9 ~# cat get_ngx_cycle.stp
    probe process("/home/admin/tengine/bin/nginx").function("ngx_process_events_and_timers").call {
        printf("ngx_cycle->connections: %d\n", $ngx_cycle->connections)
        exit()
    }
    
    root@j9 ~# stap get_ngx_cycle.stp
    semantic error: while processing probe process("/home/admin/tengine/bin/nginx").function("ngx_process_events_and_timers@src/event/ngx_event.c:225").call from: process("/home/admin/tengine/bin/nginx").function("ngx_process_events_and_timers").call
    
    semantic error: unable to find local 'ngx_cycle', [man error::dwarf] dieoffset 0x73ca8 in /home/admin/tengine/bin/nginx, near pc 0x434152 in ngx_process_events_and_timers src/event/ngx_event.c (alternatives: $cycle, $delta, $timer, $flags)): identifier '$ngx_cycle' at get_ngx_cycle.stp:3:44
            source:     printf("ngx_cycle->connections: %d\n", $ngx_cycle->connections)
                                                               ^
    
    Pass 2: analysis failed.  [man error::pass2]
    
    root@j9 ~# cat get_ngx_cycle.stp
    probe process("/home/admin/tengine/bin/nginx").function("ngx_process_events_and_timers").call {
        ngx_cycle = @var("ngx_cycle@src/core/ngx_cycle.c")
        printf("ngx_cycle->connections: %d\n", ngx_cycle->connections)
        exit()
    }
    
    root@j9 ~# stap get_ngx_cycle.stp
    ngx_cycle->connections: 19507312

**7.6 获取数据结构成员用法**

typedef struct {
        size_t      len;
        u_char     *data;
    } ngx_str_t;
    
    struct ngx_http_request_s {
        ......
        ngx_uint_t                        method;
        ngx_uint_t                        http_version;
    
        ngx_str_t                         request_line;
        ngx_str_t                         raw_uri;
        ngx_str_t                         uri;
        ......
    };

上面这个是nginx里面的http请求结构里面的几个成员，在C语言里，如果r是struct ngx\_http\_request\_t \*，那么要获取uri的data是这样的：r->uri.data，但在SystemTap里面，不管是指针还是数据结构，都是用->访问其成员：

#cat get_http_uri.stp
    probe process("/home/admin/tengine/bin/nginx").function("ngx_http_process_request").call {
        printf("r->uri.len: %d, r->uri.data: %p\n", $r->uri.len, $r->uri.data)
    }
    #stap get_http_uri.stp
    WARNING: never-assigned local variable 'len' (similar: data): identifier 'len' at get_http_uri.stp:2:57
     source:     printf("r->uri.len: %d, r->uri.data: %p\n", $r->uri.len, $r->uri.data)
                                                                     ^
    WARNING: never-assigned local variable 'data' (similar: len): identifier 'data' at :2:70
     source:     printf("r->uri.len: %d, r->uri.data: %p\n", $r->uri.len, $r->uri.data)
                                                                                  ^
    semantic error: invalid operator: operator '.' at :2:56
            source:     printf("r->uri.len: %d, r->uri.data: %p\n", $r->uri.len, $r->uri.data)
                                                                           ^
    
    semantic error: type mismatch: expected long but found string: operator '.' at :2:56
            source:     printf("r->uri.len: %d, r->uri.data: %p\n", $r->uri.len, $r->uri.data)
                                                                           ^
    
    Pass 2: analysis failed.  [man error::pass2]
    
    #cat get_http_uri.stp
    probe process("/home/admin/tengine/bin/nginx").function("ngx_http_process_request").call {
        printf("r->uri.len: %d, r->uri.data: %p\n", $r->uri->len, $r->uri->data)
    }
    
    #stap get_http_uri.stp
    r->uri.len: 1, r->uri.data: 0x1276f94
    r->uri.len: 1, r->uri.data: 0x11d5fc4
    r->uri.len: 1, r->uri.data: 0x124fd24
    ^C

**7.7 输出整个数据结构**

SystemTap有两个语法可以输出整个数据结构：在变量的后面加一个或者两个

$即可，例子如下：

#cat get_r_pool.stp
    probe process("/home/admin/tengine/bin/nginx").function("ngx_http_process_request").call {
        printf("$r->pool$: %s\n$r->pool$$: %s\n", $r->pool$, $r->pool$$)
    }
    #stap get_r_pool.stp
    $r->pool$: {.d={...}, .max=4016, .current=0x161acd0, .chain=0x0, .large=0x0, .cleanup=0x0, .log=0x161c690}
    $r->pool$$: {.d={.last="a", .end="", .next=0x1617650, .failed=0}, .max=4016, .current=0x161acd0, .chain=0x0, .large=0x0, .cleanup=0x0, .log=0x161c690}

其中r->pool的结构如下：

typedef struct {
        u_char               *last;
        u_char               *end;
        ngx_pool_t           *next;
        ngx_uint_t            failed;
    } ngx_pool_data_t;
    
    struct ngx_pool_s {
        ngx_pool_data_t       d;
        size_t                max;
        ngx_pool_t           *current;
        ngx_chain_t          *chain;
        ngx_pool_large_t     *large;
        ngx_pool_cleanup_t   *cleanup;
        ngx_log_t            *log;
    #if  (NGX_DEBUG_POOL)
        size_t                size;
        ngx_pool_stat_t      *stat;
    #endif
    };

ngx\_pool\_s包含了结构ngx\_pool\_data\_t。变量后面加和$的区别是后者展开了里面的结构而前者不展开，此用法只输出基本数据类型的值。

**7.8 输出字符串指针**

用户态使用：user\_string、user\_string\_n  
内核态使用：kernel\_string、kernel\_string\_n、user\_string\_quoted

#cat get_http_uri.stp
    probe process("/home/admin/tengine/bin/nginx").function("ngx_http_process_request").call {
        printf("r->uri: %s\nr->uri(n): %s\n", user_string($r->uri->data), user_string_n($r->uri->data, $r->uri->len))
    }
    
    #stap get_http_uri.stp
    r->uri: /?id=1 HTTP/1.1
    User-Agent
    r->uri(n): /

user\_string\_quoted是获取用户态传给内核的字符串，代码中一般有\_\_user宏标记：  
![image][image 2]

#cat sys_open.stp
    probe kernel.function("sys_open")
    {
        printf("filename: %s\n", user_string_quoted(pointer_arg(1)));
    }
    #stap sys_open.stp 
    filename: "/var/log/auth.log"
    filename: "/proc/stat"
    filename: "/proc/uptime"

**7.9 指针类型转换**

SystemTap提供@cast来实现指针类型转换，比如可以将void \*转成自己需要的类型：  
![image][image 3]  
![image][image 4]

#cat get_c_fd.stp 
    probe process("/home/admin/tengine/bin/nginx").function("ngx_http_process_request_line").call {
        printf("c->fd: %d\n", @cast($rev->data, "ngx_connection_t")->fd)
    }
    
    #stap get_c_fd.stp 
    c->fd: 3
    c->fd: 28
    c->fd: 30
    c->fd: 32
    c->fd: 34
    ^C

**7.10 定义某个类型的变量**

同样是用@cast，定义一个变量用来保存其转换后的地址即可，用法如下：

#cat get_c.stp 
    probe process("/home/admin/tengine/bin/nginx").function("ngx_http_process_request_line").call {
        c = &@cast($rev->data, "ngx_connection_t")
        printf("c->fd: %d, c->requests: %d\n", c->fd, c->requests)
    }
    
    #stap get_c.stp 
    c->fd: 3, c->requests: 1
    c->fd: 28, c->requests: 1
    c->fd: 30, c->requests: 1
    ^C

**7.11 多级指针用法**

root@j9 ~# cat cc_multi_pointer.c
    #include <stdio.h>
    
    struct test {
        int count;
    };
    
    int main(int argc, char *argv[])
    {   
        struct test t = {.count = 5566};
        struct test *pt = &t;
        struct test **ppt = &pt;
    
        printf("t.count: %d, pt->count: %d, ppt->count: %d\n", t.count, pt->count, (*ppt)->count);
    
        return 0;
    }
    
    root@j9 ~# gcc -Wall -g -o cc_multi_pointer ./cc_multi_pointer.c
    
    root@j9 ~# cat cc_multi_pointer.stp
    probe process("./cc_multi_pointer").statement("main@./cc_multi_pointer.c:13")
    {   
        printf("$t->count: %d, $pt->count: %d, $ppt->count: %d", $t->count, $pt->count, $ppt[0]->count);
    }
    
    root@j9 ~# ./cc_multi_pointer
    t.count: 5566, pt->count: 5566, ppt->count: 5566
    
    root@j9 ~# stap ./cc_multi_pointer.stp -c './cc_multi_pointer'
    t.count: 5566, pt->count: 5566, ppt->count: 5566
    $t->count: 5566, $pt->count: 5566, $ppt->count: 5566

简言之：通过\[0\]去解引用即可。

**7.12 遍历C语言数组**

下面是在nginx处理请求关闭时遍历请求头的例子：

#cat debug_http_header.stp
    probe process("/home/admin/tengine/bin/nginx").function("ngx_http_finalize_request").call {
        i = 0
        headers_in_part = &$r->headers_in->headers->part
        headers = &@cast(headers_in_part->elts, "ngx_table_elt_t")[0]
        while (headers) {
            if (i >= headers_in_part->nelts) {
                if (!headers_in_part->next) {
                    break
                }
                headers_in_part = headers_in_part->next;
                headers = &@cast(headers_in_part->elts, "ngx_table_elt_t")[0]
                i = 0
            }
            h = &@cast(headers, "ngx_table_elt_t")[i]
            printf("%s: %s\n", user_string_n(h->key->data, h->key->len), user_string_n(h->value->data, h->value->len))
            i += 1
        }
    }
    
    #stap debug_http_header.stp
    User-Agent: curl/7.29.0
    Host: 127.0.0.1:20090
    Accept: */*

**7.13 查看函数指针所指的函数名**

获取一个地址所对应的符号：  
用户态：usymname  
内核态：symname

#cat get_c_handler.stp
    probe process("/home/admin/tengine/bin/nginx").function("ngx_http_process_request_line").call {
        c = &@cast($rev->data, "ngx_connection_t")
        printf("c->read->handlers: %s, c->write->handler: %s\n", usymname(c->read->handler), usymname(c->write->handler))
    }
    
    #stap get_c_handler.stp
    c->read->handlers: ngx_http_process_request_line, c->write->handler: ngx_http_empty_handler
    ^C

**7.14 修改进程中的变量**

root@j9 ~# cat stap_set_var.c -n     
         1  #include <stdio.h>
         2
         3  typedef struct policy {
         4      int     id;
         5  } policy_t;
         6
         7  int main(int argc, char *argv[])
         8  {
         9      policy_t policy;
        10      policy_t *p = &policy;
        11      policy_t **pp;
        12
        13      p->id = 111;
        14
        15      printf("before stap set, p->id: %d\n", p->id);
        16
        17      pp = &p;
        18
        19      printf("after stap set, p->id: %d, (*pp)->id: %d\n", p->id, (*pp)->id);
        20
        21      return 0;
        22  }
    
    root@j9 ~# gcc -Wall -g -o ./stap_set_var ./stap_set_var.c      
    
    root@j9 ~# cat stap_set_var.stp
    probe process("./stap_set_var").statement("main@./stap_set_var.c:17")
    {
        $p->id = 222;
        printf("$p$: %s\n", $p$)
    }
    
    root@j9 ~# stap -g stap_set_var.stp -c ./stap_set_var         
    before stap set, p->id: 111
    after stap set, p->id: 222, (*pp)->id: 222
    $p$: {.id=222}
    
    root@j9 ~#

可以看出在第17行用SystemTap修改后的值在第19行就生效了。  
需要注意的是stap要加-g参数在guru模式下才能修改变量的值。

**7.15 跟踪进程执行流程**

thread\_indent(n): 补充空格  
ppfunc(): 当前探测点所在的函数  
在call探测点调用thread\_indent(4)补充4个空格，在return探测点调用thread\_indent(-4)回退4个空格，效果如下：

#cat trace_nginx.stp
    probe process("/home/admin/tengine/bin/nginx").function("*@src/http/ngx_http_*").call
    {
        printf("%s -> %s\n", thread_indent(4), ppfunc());
    }
    
    probe process("/home/admin/tengine/bin/nginx").function("*@src/http/ngx_http_*").return
    {
        printf("%s <- %s\n", thread_indent(-4), ppfunc());
    }
    
    #stap trace_nginx.stp
         0 nginx(11368):    -> ngx_http_init_connection
        21 nginx(11368):    <- ngx_http_init_connection
         0 nginx(11368):    -> ngx_http_wait_request_handler
        30 nginx(11368):        -> ngx_http_create_request
        41 nginx(11368):        <- ngx_http_create_request
        55 nginx(11368):        -> ngx_http_process_request_line
        72 nginx(11368):            -> ngx_http_read_request_header
        78 nginx(11368):            <- ngx_http_read_request_header
        91 nginx(11368):            -> ngx_http_parse_request_line
        99 nginx(11368):            <- ngx_http_parse_request_line
       109 nginx(11368):            -> ngx_http_process_request_uri
       115 nginx(11368):            <- ngx_http_process_request_uri
       127 nginx(11368):            -> ngx_http_process_request_headers
       138 nginx(11368):                -> ngx_http_read_request_header
       143 nginx(11368):                <- ngx_http_read_request_header
       155 nginx(11368):                -> ngx_http_parse_header_line
       163 nginx(11368):                <- ngx_http_parse_header_line
       178 nginx(11368):                -> ngx_http_process_user_agent
       185 nginx(11368):                <- ngx_http_process_user_agent
       192 nginx(11368):                -> ngx_http_parse_header_line
       198 nginx(11368):                <- ngx_http_parse_header_line
       208 nginx(11368):                -> ngx_http_process_host
       222 nginx(11368):                    -> ngx_http_validate_host
       229 nginx(11368):                    <- ngx_http_validate_host
       239 nginx(11368):                    -> ngx_http_set_virtual_server
       252 nginx(11368):                        -> ngx_http_find_virtual_server
       259 nginx(11368):                        <- ngx_http_find_virtual_server
       263 nginx(11368):                    <- ngx_http_set_virtual_server
       266 nginx(11368):                <- ngx_http_process_host
       274 nginx(11368):                -> ngx_http_parse_header_line
       279 nginx(11368):                <- ngx_http_parse_header_line
       287 nginx(11368):                -> ngx_http_parse_header_line
       292 nginx(11368):                <- ngx_http_parse_header_line
    
       .....
    
      2072 nginx(11368):                                <- ngx_http_finalize_request
      2076 nginx(11368):                            <- ngx_http_core_content_phase
      2079 nginx(11368):                        <- ngx_http_core_run_phases
      2083 nginx(11368):                    <- ngx_http_handler
      2093 nginx(11368):                    -> ngx_http_run_posted_requests
      2100 nginx(11368):                    <- ngx_http_run_posted_requests
      2103 nginx(11368):                <- ngx_http_process_request
      2107 nginx(11368):            <- ngx_http_process_request_headers
      2111 nginx(11368):        <- ngx_http_process_request_line
      2114 nginx(11368):    <- ngx_http_wait_request_handler
         0 nginx(11368):    -> ngx_http_keepalive_handler
        26 nginx(11368):        -> ngx_http_close_connection
        79 nginx(11368):        <- ngx_http_close_connection
        83 nginx(11368):    <- ngx_http_keepalive_handler

**7.16 查看代码执行路径**

pp(): 输出当前被激活的探测点

#cat ngx_http_process_request.stp
    probe process("/home/admin/tengine/bin/nginx").statement("ngx_http_process_request@src/http/ngx_http_request.c:*") {
        printf("%s\n", pp())
    }
    
    #stap ngx_http_process_request.stp 
    process("/home/admin/tengine/bin/nginx").statement("ngx_http_process_request@src/http/ngx_http_request.c:2762")
    process("/home/admin/tengine/bin/nginx").statement("ngx_http_process_request@src/http/ngx_http_request.c:2768")
    process("/home/admin/tengine/bin/nginx").statement("ngx_http_process_request@src/http/ngx_http_request.c:2771")
    process("/home/admin/tengine/bin/nginx").statement("ngx_http_process_request@src/http/ngx_http_request.c:2773")
    process("/home/admin/tengine/bin/nginx").statement("ngx_http_process_request@src/http/ngx_http_request.c:2774")
    process("/home/admin/tengine/bin/nginx").statement("ngx_http_process_request@src/http/ngx_http_request.c:2783")
    process("/home/admin/tengine/bin/nginx").statement("ngx_http_process_request@src/http/ngx_http_request.c:2835")
    process("/home/admin/tengine/bin/nginx").statement("ngx_http_process_request@src/http/ngx_http_request.c:2840")
    process("/home/admin/tengine/bin/nginx").statement("ngx_http_process_request@src/http/ngx_http_request.c:2841")
    process("/home/admin/tengine/bin/nginx").statement("ngx_http_process_request@src/http/ngx_http_request.c:2842")
    process("/home/admin/tengine/bin/nginx").statement("ngx_http_process_request@src/http/ngx_http_request.c:2843")
    process("/home/admin/tengine/bin/nginx").statement("ngx_http_process_request@src/http/ngx_http_request.c:2846")
    process("/home/admin/tengine/bin/nginx").statement("ngx_http_process_request@src/http/ngx_http_request.c:2847")
    process("/home/admin/tengine/bin/nginx").statement("ngx_http_process_request@src/http/ngx_http_request.c:2848")
    process("/home/admin/tengine/bin/nginx").statement("ngx_http_process_request@src/http/ngx_http_request.c:2850")
    process("/home/admin/tengine/bin/nginx").statement("ngx_http_process_request@src/http/ngx_http_request.c:2852")
    process("/home/admin/tengine/bin/nginx").statement("ngx_http_process_request@src/http/ngx_http_request.c:2853")
    ^C

可以看出该函数哪些行被执行了。

**7.17 巧用正则匹配过滤**

在排查问题时，可以利用一些正则匹配来获取自己想要的信息，比如下面是只收集\*.j9.com的堆栈：

#
    cat debug_tengine_5xx.stp 
    probe process("/home/admin/tengine/bin/t-coresystem-tengine-cdn").function("ngx_http_finalize_request").call {
        rc = $rc
        if (rc < 0) {
            host = "(null)"
            if ($r->headers_in->server->len != 0) {
                host = user_string_n($r->headers_in->server->data, $r->headers_in->server->len)
            } else {
                cscf = &@cast($r->srv_conf, "ngx_http_core_srv_conf_t")[@var("ngx_http_core_module@src/http/ngx_http_core_module.c")->ctx_index]
                if (cscf->server_name->len != 0) {
                     host = user_string_n(cscf->server_name->data, cscf->server_name->len)
                }
            }
    
            if (host =~ ".*\.j9\.com") {
                printf("rc: %d, host: %s\n", rc, host)
                print_ubacktrace()
            }
        }
    }
    
    #stap debug_tengine_5xx.stp
    WARNING: Missing unwind data for module, rerun with 'stap -d /lib64/libc-2.12.so'
    rc: -4, host: www.j9.com
     0x49af2e : ngx_http_finalize_request+0xe/0x480 [/home/admin/tengine/bin/t-coresystem-tengine-cdn]
     0x492eab : ngx_http_core_content_phase+0x2b/0x130 [/home/admin/tengine/bin/t-coresystem-tengine-cdn]
     0x48e74d : ngx_http_core_run_phases+0x3d/0x50 [/home/admin/tengine/bin/t-coresystem-tengine-cdn]
     0x514c3c : ngx_http_lua_socket_tcp_read+0x44c/0x590 [/home/admin/tengine/bin/t-coresystem-tengine-cdn]
     0x513150 : ngx_http_lua_socket_tcp_handler+0x30/0x50 [/home/admin/tengine/bin/t-coresystem-tengine-cdn]
     0x475b96 : ngx_event_process_posted+0x36/0x40 [/home/admin/tengine/bin/t-coresystem-tengine-cdn]
     0x47d4d8 : ngx_worker_process_cycle+0x138/0x260 [/home/admin/tengine/bin/t-coresystem-tengine-cdn]
     0x47a38a : ngx_spawn_process+0x1ca/0x5e0 [/home/admin/tengine/bin/t-coresystem-tengine-cdn]
     0x47c73c : ngx_start_worker_processes+0x7c/0x100 [/home/admin/tengine/bin/t-coresystem-tengine-cdn]
     0x47db5f : ngx_master_process_cycle+0x3af/0x9b0 [/home/admin/tengine/bin/t-coresystem-tengine-cdn]
     0x45a740 : main+0xa90/0xb50 [/home/admin/tengine/bin/t-coresystem-tengine-cdn]
     0x3623e1ecdd [/lib64/libc-2.12.so+0x1ecdd/0x38d000]
    rc: -4, host: cdn.j9.com
     0x49af2e : ngx_http_finalize_request+0xe/0x480 [/home/admin/tengine/bin/t-coresystem-tengine-cdn]
     0x492eab : ngx_http_core_content_phase+0x2b/0x130 [/home/admin/tengine/bin/t-coresystem-tengine-cdn]
     0x48e74d : ngx_http_core_run_phases+0x3d/0x50 [/home/admin/tengine/bin/t-coresystem-tengine-cdn]
     0x514c3c : ngx_http_lua_socket_tcp_read+0x44c/0x590 [/home/admin/tengine/bin/t-coresystem-tengine-cdn]
     0x513150 : ngx_http_lua_socket_tcp_handler+0x30/0x50 [/home/admin/tengine/bin/t-coresystem-tengine-cdn]
     0x475b96 : ngx_event_process_posted+0x36/0x40 [/home/admin/tengine/bin/t-coresystem-tengine-cdn]
     0x47d4d8 : ngx_worker_process_cycle+0x138/0x260 [/home/admin/tengine/bin/t-coresystem-tengine-cdn]
     0x47a38a : ngx_spawn_process+0x1ca/0x5e0 [/home/admin/tengine/bin/t-coresystem-tengine-cdn]
     0x47c73c : ngx_start_worker_processes+0x7c/0x100 [/home/admin/tengine/bin/t-coresystem-tengine-cdn]
     0x47db5f : ngx_master_process_cycle+0x3af/0x9b0 [/home/admin/tengine/bin/t-coresystem-tengine-cdn]
     0x45a740 : main+0xa90/0xb50 [/home/admin/tengine/bin/t-coresystem-tengine-cdn]
     0x3623e1ecdd [/lib64/libc-2.12.so+0x1ecdd/0x38d000]

**7.18 关联数组用法**

SystemTap的关联数组必须是全局变量，需要用global进行声明，其索引可以支持多达9项索引域,各域间以逗号隔开。支持 =, ++ 与 +=操作,其默认的初始值为0。  
例如：

root@j9 ~# cat stap_array.stp 
    global reads
    probe vfs.read {
        reads[execname(), pid()] ++
    }
    probe timer.s(3) {
        foreach ([execname, pid] in reads) {
            printf("%s(%d) : %d \n", execname, pid, reads[execname, pid])
        }
        print("============================\n")
        delete reads
    }
    
    root@j9 ~# stap stap_array.stp 
    stapio(18716) : 16 
    rsyslogd(770) : 1 
    docker(743) : 3 
    IFSWatch(5594) : 30 
    QThread(5594) : 6 
    AliYunDunUpdate(1057) : 4 
    sshd(15118) : 1 
    sshd(15191) : 1 
    ============================
    stapio(18716) : 16 
    sshd(15191) : 3 
    docker(743) : 3 
    IFSWatch(5594) : 30 
    sshd(15118) : 2 
    QThread(5594) : 12 
    AliYunDunUpdate(1057) : 8 
    ============================
    ^C
    root@j9 ~/systemtap#

也可以用+、-进行排序：

root@j9 ~# cat stap_array.stp
    global reads
    probe vfs.read {
        reads[execname(), pid()] ++
    }
    probe timer.s(3) {
        foreach ([execname, pid+] in reads) {
            printf("%s(%d) : %d \n", execname, pid, reads[execname, pid])
        }
        print("============================\n")
        delete reads
    }
    
    root@j9 ~# stap stap_array.stp 
    docker(743) : 3 
    rsyslogd(770) : 1 
    AliYunDunUpdate(1057) : 12 
    IFSWatch(5594) : 30 
    QThread(5594) : 12 
    sshd(15118) : 2 
    sshd(15191) : 2 
    stapio(19021) : 16 
    ============================
    docker(743) : 3 
    AliYunDunUpdate(1057) : 12 
    IFSWatch(5594) : 30 
    QThread(5594) : 6 
    sshd(15118) : 1 
    sshd(15191) : 19 
    stapio(19021) : 16 
    ============================
    ^C
    root@j9 ~#

**7.19 调试内存泄漏以及内存重复释放**

probe begin {
        printf("=============begin============\n")
    }
    
    //记录内存分配和释放的计数关联数组
    global g_mem_ref_tbl
    //记录内存分配和释放的调用堆栈关联数组
    global g_mem_bt_tbl
    
    probe process("/lib/x86_64-linux-gnu/libc.so.6").function("__libc_malloc").return, process("/lib/x86_64-linux-gnu/libc.so.6").function("__libc_calloc").return {
        if (target() == pid()) {
            if (g_mem_ref_tbl[$return] == 0) {
                g_mem_ref_tbl[$return]++
                g_mem_bt_tbl[$return] = sprint_ubacktrace()
            }
        }
    }
    
    probe process("/lib/x86_64-linux-gnu/libc.so.6").function("__libc_free").call {
        if (target() == pid()) {
            g_mem_ref_tbl[$mem]--
    
            if (g_mem_ref_tbl[$mem] == 0) {
                if ($mem != 0) {
                    //记录上次释放的调用堆栈
                    g_mem_bt_tbl[$mem] = sprint_ubacktrace()
                }
            } else if (g_mem_ref_tbl[$mem] < 0 && $mem != 0) {
                //如果调用free已经失衡，那就出现了重复释放内存的问题，这里输出当前调用堆栈，以及这个地址上次释放的调用堆栈
                printf("MMMMMMMMMMMMMMMMMMMMMMMMMMMM\n")
                printf("g_mem_ref_tbl[%p]: %d\n", $mem, g_mem_ref_tbl[$mem])
                print_ubacktrace()
                printf("last free backtrace:\n%s\n", g_mem_bt_tbl[$mem])
                printf("WWWWWWWWWWWWWWWWWWWWWWWWWWWW\n")
            }
        }
    }
    
    probe end {
        //最后输出产生泄漏的内存是在哪里分配的
        printf("=============end============\n")
        foreach(mem in g_mem_ref_tbl) {
            if (g_mem_ref_tbl[mem] > 0) {
                printf("%s\n", g_mem_bt_tbl[mem])
            }
        }
    }

详细请看：[http://blog.csdn.net/wangzuxi/article/details/44901285][http_blog.csdn.net_wangzuxi_article_details_44901285]

**7.20 嵌入C代码**

在进程fork出子进程时打印出进程id和进程名:

root@jusse ~/systemtap# cat copy_process.stp
    function getprocname:string(task:long)
    %{
        struct task_struct *task = (struct task_struct *)STAP_ARG_task;
        snprintf(STAP_RETVALUE, MAXSTRINGLEN, "pid: %d, comm: %s", task->pid, task->comm);
    %}
    
    function getprocid:long(task:long)
    %{
        struct task_struct *task = (struct task_struct *)STAP_ARG_task;
        STAP_RETURN(task->pid);
    %}
    
    probe kernel.function("copy_process").return
    {
        printf("copy_process return: %p, pid: %d, getprocname: %s, getprocid: %d\n", $return, $return->pid, getprocname($return), getprocid($return));
    }
    root@jusse ~/systemtap# stap -g copy_process.stp
    copy_process return: 0xffff880039f61800, pid: 12212, getprocname: pid: 12212, comm: bash, getprocid: 12212
    copy_process return: 0xffff880039f61800, pid: 12212, getprocname: pid: 12212, comm: bash, getprocid: 12212
    copy_process return: 0xffff880039f63000, pid: 12213, getprocname: pid: 12213, comm: cc_epoll, getprocid: 12213
    copy_process return: 0xffff880039f63000, pid: 12213, getprocname: pid: 12213, comm: cc_epoll, getprocid: 12213
    copy_process return: 0xffff8800081a9800, pid: 12214, getprocname: pid: 12214, comm: cc_epoll, getprocid: 12214
    copy_process return: 0xffff8800081a9800, pid: 12214, getprocname: pid: 12214, comm: cc_epoll, getprocid: 12214
    copy_process return: 0xffff8800004d8000, pid: 12215, getprocname: pid: 12215, comm: cc_epoll, getprocid: 12215
    copy_process return: 0xffff8800004d8000, pid: 12215, getprocname: pid: 12215, comm: cc_epoll, getprocid: 12215
    copy_process return: 0xffff880000564800, pid: 12216, getprocname: pid: 12216, comm: cc_epoll, getprocid: 12216
    copy_process return: 0xffff880000564800, pid: 12216, getprocname: pid: 12216, comm: cc_epoll, getprocid: 12216
    copy_process return: 0xffff880000566000, pid: 12217, getprocname: pid: 12217, comm: cc_epoll, getprocid: 12217
    copy_process return: 0xffff880000566000, pid: 12217, getprocname: pid: 12217, comm: cc_epoll, getprocid: 12217

**有三个需要注意的地方：**  
1）、SystemTap脚本里面嵌入C语言代码要在每个大括号前加%前缀，是%\{…… %\} 而不是%\{ …… \}%；  
2）、获取脚本函数参数要用STAP\_ARG\_前缀；  
3）、一般long等返回值用STAP\_RETURN，而string类型返回值要用snprintf、strncat等方式把字符串复制到STAP\_RETVALUE里面。

**7.21 调试内核模块**

这小节就不细讲了，这篇博客 ([http://blog.chinaunix.net/uid-14528823-id-4726046.html][http_blog.chinaunix.net_uid-14528823-id-4726046.html]) 写得很详细，这里只copy两个关键点过来记录一下：  
要调试自己的内核模块，需要注意的有两个关键点：  
1)、使用SystemTap调试内核模块，探测点的编写格式示例为：  
module("ext3").function("ext3\_\*")  
2)、需要将自己的模块cp到/lib/modules/uname -r/extra目录中，否则找不到符号，如果/lib/modules/uname -r/目录下没有extra这个目录，自己mkdir一下就可以。

**7.22 一些错误提示及解决办法**

错误提示1：

ERROR: MAXACTION exceeded near keyword at debug_connection.stp:86:9
    ERROR: MAXACTION exceeded near operator '->' at debug_connection.stp:84:30

解决办法：  
加上stap参数：-DMAXACTION=102400，如果还报这种类型的错误，只需把102400调成更大的值即可。

错误提示2：

WARNING: Number of errors: 0, skipped probes: 82

解决办法：  
加上-DMAXSKIPPED=102400和-DSTP\_NO\_OVERLOAD参数

还有一些可以去掉限制的宏：

MAXSTRINGLEN：这个宏会影响sprintf的buffer大小，默认为512字节。  
MAXTRYLOCK：对全局变量进行try lock操作的次数，超过则次数还拿不到锁则放弃和跳过该探测点，默认值为1000.全局变量多的时候可以把这个宏开大一点。

[systemtap]: https://imgconvert.csdnimg.cn/aHR0cHM6Ly95cWZpbGUuYWxpY2RuLmNvbS82ZGYyNGY3YWE2ZDRiOWFmMzJkM2VmZjMwMWE0M2VlMTQ1MjVhYjA1LnBuZw?x-oss-process=image/format,png
[systemtap_phase]: https://imgconvert.csdnimg.cn/aHR0cHM6Ly95cWZpbGUuYWxpY2RuLmNvbS83N2QxOWJiZjkyZDI4M2Y1NTJiNDU2YmJhYjY1YzE2ZTFiZGUzNTNhLnBuZw?x-oss-process=image/format,png
[systemtap_probe]: https://imgconvert.csdnimg.cn/aHR0cHM6Ly95cWZpbGUuYWxpY2RuLmNvbS9mZjA1ZTlkNmFmODQzZWNkNTcxNTQ2MWZlMTlkOTgxZGZmYzc0YjhmLnBuZw?x-oss-process=image/format,png
[https_sourceware.org_systemtap_tapsets]: https://yq.aliyun.com/go/articleRenderRedirect?url=https%3A%2F%2Fsourceware.org%2Fsystemtap%2Ftapsets%2F
[image]: https://imgconvert.csdnimg.cn/aHR0cHM6Ly95cWZpbGUuYWxpY2RuLmNvbS8wNjVlMjI1YzkyODVhNzU2YTI5MWUyYWRhMjlkYzhiYjY5OWI5YWE5LnBuZw?x-oss-process=image/format,png
[image 1]: https://imgconvert.csdnimg.cn/aHR0cHM6Ly95cWZpbGUuYWxpY2RuLmNvbS9iNjhhYjYwMGJiM2NmMWEwYmFlYjYzZmVlY2NhZmVjZjA5MDExNDcwLnBuZw?x-oss-process=image/format,png
[image 2]: https://imgconvert.csdnimg.cn/aHR0cHM6Ly95cWZpbGUuYWxpY2RuLmNvbS8yYzNjOWQ2MjQ5YTM4MzdiNDM5NDAyM2I1ZTE5OTBiODBjMmYxNDBlLnBuZw?x-oss-process=image/format,png
[image 3]: https://imgconvert.csdnimg.cn/aHR0cHM6Ly95cWZpbGUuYWxpY2RuLmNvbS9hOTUzYjZjZDFmZThkMjhlNTdhMmJiYjg0YmQ0ZWY2N2ZhMDAxNTE2LnBuZw?x-oss-process=image/format,png
[image 4]: https://imgconvert.csdnimg.cn/aHR0cHM6Ly95cWZpbGUuYWxpY2RuLmNvbS84Mzc1M2E2ZTA1NDQ2Mjc4ZmQwYmUxODNiMjhkZTIwZDk2OTkxN2Q3LnBuZw?x-oss-process=image/format,png
[http_blog.csdn.net_wangzuxi_article_details_44901285]: https://yq.aliyun.com/go/articleRenderRedirect?url=http%3A%2F%2Fblog.csdn.net%2Fwangzuxi%2Farticle%2Fdetails%2F44901285
[http_blog.chinaunix.net_uid-14528823-id-4726046.html]: https://yq.aliyun.com/go/articleRenderRedirect?url=http%3A%2F%2Fblog.chinaunix.net%2Fuid-14528823-id-4726046.html