用Ftrace跟踪kernel函数调用栈和某个函数内部调用流程

最新推荐文章于 2024-03-10 18:19:00 发布
最新推荐文章于 2024-03-10 18:19:00 发布
阅读量1.9k 收藏 10
点赞数
文章标签： ftrace function function_graph
原文链接：https://blog.csdn.net/maybeYoc/article/details/121659003
版权

转载自：

(10条消息) ftrace之function及function_graph使用_HugoVus的博客-CSDN博客_function_graphicon-default.png?t=M4ADhttps://blog.csdn.net/M120674/article/details/122309654(10条消息) Ftrace debugfs接口详细使用说明_张衡天的博客-CSDN博客icon-default.png?t=M4ADhttps://blog.csdn.net/maybeYoc/article/details/121659003

一 用途

（1）function 主要用于跟踪内核函数的调用栈（其被调用过程）

（2）function_graph 主要用于跟踪内核函数内部调用流程及耗时

这两个对内核性能分析的作用不大，主要用来梳理内核模块的逻辑

二 使用

（1）function 使用

 
/sys/kernel/debug/tracing # echo nop > current_tracer           ----清空跟踪器
/sys/kernel/debug/tracing # echo drm_open > set_ftrace_filter   ----设置跟踪函数为drm_open
/sys/kernel/debug/tracing # echo function > current_tracer      ----设置当前跟踪器
/sys/kernel/debug/tracing # echo 1 > options/func_stack_trace   ----跟踪函数调用栈
/sys/kernel/debug/tracing # echo 1 > tracing_on                 ----开始跟踪
/sys/kernel/debug/tracing # /mnt/vkms_test ---运行vkms_test程序，其会调用到内核drm_open函数
/sys/kernel/debug/tracing # echo 0 > tracing_on                 ----关闭跟踪
/sys/kernel/debug/tracing # cat trace                           ----查看跟踪结果
# tracer: function
#
# entries-in-buffer/entries-written: 2/2   #P:4
#
#                                _-----=> irqs-off
#                               / _----=> need-resched
#                              | / _---=> hardirq/softirq
#                              || / _--=> preempt-depth
#                              ||| /     delay
#           TASK-PID     CPU#  ||||   TIMESTAMP  FUNCTION
#              | |         |   ||||      |         |
       vkms_test-90      [001] ....  5408.290697: drm_open <-drm_stub_open
       vkms_test-90      [001] ....  5408.291126: <stack trace>
 => drm_stub_open
 => chrdev_open
 => do_dentry_open
 => vfs_open
 => path_openat
 => do_filp_open
 => do_sys_openat2
 => do_sys_open
 => sys_open
 => ret_fast_syscall
 => 0xbebc3cdc
/sys/kernel/debug/tracing #

shell脚本：

/mnt # cat trace_fun.sh 
# !/bin/sh
 
 
if [ $# -lt 2 ]; then
    echo "usage:"
    echo "  sh trace_func.sh function exec_file"
    exit -1
fi
 
cd /sys/kernel/debug/tracing/
echo nop > current_tracer
echo $1 > set_ftrace_filter
echo function > current_tracer
echo 1 > options/func_stack_trace
echo 1 > tracing_on
$2
echo 0 > tracing_on
cat trace
 
cd -

（2）function_graph使用

/sys/kernel/debug/tracing # echo nop > current_tracer
/sys/kernel/debug/tracing # echo function_graph > current_tracer
/sys/kernel/debug/tracing # echo drm_open > set_graph_function
/sys/kernel/debug/tracing # echo 1 > options/funcgraph-tail ----增加函数尾部注释
/sys/kernel/debug/tracing # echo > set_ftrace_filter        ----清空，否则无法显示调用栈
/sys/kernel/debug/tracing # echo 1 > tracing_on 
/sys/kernel/debug/tracing # /mnt/vkms_test 
/sys/kernel/debug/tracing # echo 0 > tracing_on
/sys/kernel/debug/tracing # cat trace
# tracer: function_graph
#
# CPU  DURATION                  FUNCTION CALLS
# |     |   |                     |   |   |   |
 2)               |  drm_open() {
 2)               |    drm_minor_acquire() {
 2)   8.625 us    |      _raw_spin_lock_irqsave();
 2)   4.709 us    |      _raw_spin_unlock_irqrestore();
 2)               |      drm_dev_enter() {
 2)   5.750 us    |        __srcu_read_lock();
 2) + 17.167 us   |      } /* drm_dev_enter */
 2)   5.791 us    |      __srcu_read_unlock();
 2) + 75.458 us   |    } /* drm_minor_acquire */
 2)   6.833 us    |    __drm_dbg();
 2)               |    drm_file_alloc() {
 2)               |      kmem_cache_alloc_trace() {
 2)   5.583 us    |        should_failslab();
 2)               |        __slab_alloc.constprop.19() {
 2)               |          ___slab_alloc.constprop.20() {
 2)   3.583 us    |            _raw_spin_lock();
 2)               |            alloc_debug_processing() {
 2)               |              check_slab() {
 2)   4.750 us    |                slab_pad_check.part.8();
 2) + 12.375 us   |              } /* check_slab */
 2)               |              check_object() {
 2)   4.250 us    |                check_bytes_and_report();
 2)   4.166 us    |                check_bytes_and_report();
 2)   3.709 us    |                check_bytes_and_report();
 2)   3.250 us    |                check_bytes_and_report();
 2)   3.417 us    |                check_bytes_and_report();
 2) + 39.792 us   |              } /* check_object */
 2)               |              set_track() {
 2)               |                stack_trace_save() {
 2)               |                  save_stack_trace() {
 2)               |                    __save_stack_trace() {
 2)   3.042 us    |                      save_trace();
 2)   2.958 us    |                      save_trace();
 2)   2.959 us    |                      save_trace();
 2)   2.959 us    |                      save_trace();
 2)   2.958 us    |                      save_trace();
 2)   3.000 us    |                      save_trace();
 2)   3.166 us    |                      save_trace();
 2)   3.042 us    |                      save_trace();
 2)   3.000 us    |                      save_trace();
 2)   3.000 us    |                      save_trace();
 2)   3.042 us    |                      save_trace();
 2)   3.041 us    |                      save_trace();
 2)   3.041 us    |                      save_trace();
 2)   3.000 us    |                      save_trace();
 2)   3.125 us    |                      save_trace();
 2)   3.000 us    |                      save_trace();
 2)   3.042 us    |                      save_trace();
 2)   3.042 us    |                      save_trace();
 2)   3.042 us    |                      save_trace();
 2)   3.083 us    |                      save_trace();
 2) ! 125.875 us  |                    } /* __save_stack_trace */
 2) ! 132.041 us  |                  } /* save_stack_trace */
 2) ! 138.375 us  |                } /* stack_trace_save */
 2) ! 145.208 us  |              } /* set_track */
 2)   4.375 us    |              init_object();
 2) ! 218.625 us  |            } /* alloc_debug_processing */
 2)               |            deactivate_slab() {
 2)   4.042 us    |              _raw_spin_lock();
 2) + 16.833 us   |            } /* deactivate_slab */
 2) ! 257.708 us  |          } /* ___slab_alloc.constprop.20 */
 2) ! 272.709 us  |        } /* __slab_alloc.constprop.19 */
 2) ! 319.792 us  |      } /* kmem_cache_alloc_trace */
 2)               |      capable() {
 2)               |        ns_capable_common() {
 2)   6.500 us    |          cap_capable();
 2) + 20.375 us   |        } /* ns_capable_common */
 2) + 40.959 us   |      } /* capable */
 2)   5.958 us    |      __mutex_init();
 2)   6.792 us    |      __init_waitqueue_head();
 2)   5.791 us    |      __mutex_init();
 2)   7.084 us    |      drm_gem_open();
 2)               |      drm_prime_init_file_private() {
 2)   6.958 us    |        __mutex_init();
 2) + 32.208 us   |      } /* drm_prime_init_file_private */
 2) ! 492.709 us  |    } /* drm_file_alloc */
 2)               |    drm_master_open() {
 2)   7.667 us    |      mutex_lock();
 2)               |      drm_new_set_master() {
 2)               |        drm_master_create() {
 2)               |          kmem_cache_alloc_trace() {
 2)   5.709 us    |            should_failslab();
 2)               |            __slab_alloc.constprop.19() {
 2)               |              ___slab_alloc.constprop.20() {
 2)   3.792 us    |                _raw_spin_lock();
 2)               |                alloc_debug_processing() {
 2)               |                  check_slab() {
 2)   3.417 us    |                    slab_pad_check.part.8();
 2) + 10.291 us   |                  } /* check_slab */
 2)               |                  check_object() {
 2)   3.834 us    |                    check_bytes_and_report();
 2)   3.208 us    |                    check_bytes_and_report();
 2)   3.958 us    |                    check_bytes_and_report();
 2)   3.375 us    |                    check_bytes_and_report();
 2)   3.375 us    |                    check_bytes_and_report();
 2) + 53.583 us   |                  } /* check_object */
 2)               |                  set_track() {
 2)               |                    stack_trace_save() {
 2)               |                      save_stack_trace() {
 2)               |                        __save_stack_trace() {
 2)   3.416 us    |                          save_trace();
 2)   3.042 us    |                          save_trace();
 2)   3.000 us    |                          save_trace();
 2)   3.000 us    |                          save_trace();
 2)   2.958 us    |                          save_trace();
 2)   2.959 us    |                          save_trace();
 2)   3.042 us    |                          save_trace();
 2)   3.000 us    |                          save_trace();
 2)   3.125 us    |                          save_trace();
 2)   3.042 us    |                          save_trace();
 2)   3.000 us    |                          save_trace();
 2)   3.292 us    |                          save_trace();
 2)   3.083 us    |                          save_trace();
 2)   3.042 us    |                          save_trace();
 2)   2.959 us    |                          save_trace();
 2)   3.000 us    |                          save_trace();
 2)   3.000 us    |                          save_trace();
 2)   3.000 us    |                          save_trace();
 2)   3.000 us    |                          save_trace();
 2)   3.000 us    |                          save_trace();
 2)   3.000 us    |                          save_trace();
 2)   3.083 us    |                          save_trace();
 2) ! 137.583 us  |                        } /* __save_stack_trace */
 2) ! 143.833 us  |                      } /* save_stack_trace */
 2) ! 149.875 us  |                    } /* stack_trace_save */
 2) ! 156.166 us  |                  } /* set_track */
 2)   3.833 us    |                  init_object();
 2) ! 240.416 us  |                } /* alloc_debug_processing */
 2)               |                deactivate_slab() {
 2)   3.458 us    |                  _raw_spin_lock();
 2) + 12.000 us   |                } /* deactivate_slab */
 2) ! 273.333 us  |              } /* ___slab_alloc.constprop.20 */
 2) ! 285.708 us  |            } /* __slab_alloc.constprop.19 */
 2) ! 310.667 us  |          } /* kmem_cache_alloc_trace */
 2) ! 324.167 us  |        } /* drm_master_create */
 2) + 10.917 us   |        drm_set_master();
 2) ! 382.250 us  |      } /* drm_new_set_master */
 2)   6.333 us    |      mutex_unlock();
 2) ! 429.625 us  |    } /* drm_master_open */
 2)   6.500 us    |    mutex_lock();
 2)   5.708 us    |    mutex_unlock();
 2) # 1116.667 us |  } /* drm_open */
/sys/kernel/debug/tracing #

shell脚本：

/mnt # cat trace_fun_graph.sh 
# !/bin/sh
 
 
if [ $# -lt 2 ]; then
    echo "usage:"
    echo "  sh trace_func_graph.sh function exec_file"
    exit -1
fi
 
cd /sys/kernel/debug/tracing/
echo nop > current_tracer
echo function_graph > current_tracer
echo $1 > set_graph_function
echo 1 > options/funcgraph-tail
echo > set_ftrace_filter
echo 1 > tracing_on
$2
echo 0 > tracing_on
cat trace
 
cd -

三  使用过程中遇到的问题及其解决方案

在我们指定要抓的function调用信息之外，多抓了很多无用信息（目前不需要关注），严重妨碍了我们的分析，如何关闭这些irq相关的trace信息？

echo 0 > options/funcgraph-irqs

 更详细的使用参考：

(10条消息) Ftrace debugfs接口详细使用说明_张衡天的博客-CSDN博客icon-default.png?t=M4ADhttps://blog.csdn.net/maybeYoc/article/details/121659003

denglin12315
关注
  • 0
    点赞
  • 踩
  • 10
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
cpp-ftrace简单函数调用示踪器
08-16
ftrace - 简单函数调用示踪器
ftrace-kernel-hooks-2014-More than just tracing.pdf | 注释
05-13
ftrace-kernel-hooks-2014-More than just tracing.pdf | 注释
【Linux】Ftrace 基本用法
shanzhuli的博客
03-06 882
Ftrace 使用
ftrace:一个跟踪函数调用的简单库
06-18
跟踪 一个跟踪函数调用的简单库。 用法 例如，为了使用它，您可以简单地： #!/usr/bin/env node var ftrace = require("ftrace"); function Foo() { console.log("hello from foo"); } function Moo() { console.log("hello from moo"); Foo(); } Foo = ftrace.wrap("Foo", "file.js:4", Foo); Moo = ftrace.wrap("Moo", "file.js:8", Moo); Moo(3, 4); // ftrace also displays the arguments nicely. 你应该得到类似的东西： => Moo(3, 4) : file.js:4 => F
Linux动态追踪——ftrace
最新发布
Fireplusplus的博客
03-10 1296
动态跟踪工具 ftrace 的使用~
ftrace一个内核中的追踪器
maimang1001的专栏
05-20 847
GitHub - aliyun/surftrace: surftrace is a tool that allows you to surf the linux kernelsurftrace is a tool that allows you to surf the linux kernel - GitHub - aliyun/surftrace: surftrace is a tool that allows you to surf the linux kernelhttps://github.com/
【linux内核】使用ftrace追踪函数调用
墨染锦年的博客
08-23 437
Ftrace是Linux内核中的一种跟踪工具，用于分析和调试内核代码的执行过程和性能。它可以帮助开发人员识别性能瓶颈、系统调用和函数调用路径，从而优化系统的运行。Ftrace提供了多种跟踪事件和功能，使开发人员能够深入了解内核的运行情况。以下是Ftrace的一些主要组件和功能：Tracepoints: 这是内核中一些关键点的预定义位置，用于在代码执行时插入跟踪事件。开发人员可以选择在特定的tracepoints上收集跟踪数据，以便分析内核的行为。
Ftrace查看函数向上的调用栈
本末实验室
01-18 438
学习 ftrace 的过程中，也整理和分享一些笔记，方便以后即查即用。
Linux内核堆栈实现分析 save_stack_trace
bin_linux96的专栏
12-13 8333
1 内核线程 Linux 内核为每个线程分配THREAD_SIZE(16k)的栈空间, 在每个堆栈的顶部放着struct thread_info 结构体，用来保存线程相关信息. 其中有几个重要变量： Preempt_count : 此变量分为四部分 0-7bit ：当前进程是否能抢占的标志 8-15bit:softirq 使能标志 16-23bit :hardirq 使能标志...
如何打印堆栈
sydyh43的博客
08-14 4455
一、打印堆栈可以方便问题定位，找到具体的函数调用流程。 二、打印堆栈的方法 2.1、用户态 #include <stdio.h> #include <stdlib.h> #include <stddef.h> #include <execinfo.h> #define DUMP_DEPTH 20 void dump(void) { int i = 0; size_t size = 0; char **strings = N
Linux中对程序的性能分析——使用trace查看函数调用关系即耗时
Imagine Miracle的博客
05-05 2549
1、背景 相信很多读者在学习或者工作过程中，往往会遇到这样的问题。需要分析某个用户态程序的性能或者是分析某个用户态程序实现的原理（这里一般指代码量较大或使用到的内核调用较为复杂的工程），一般需要分析程序的原因有这些，要学习程序的实现原理以及内核中的实现过程或是首先查看函数在底层的调用关系、与其他平台使用的性能相比过差分析其原因、需要改进该程序或重新实现等。 1.1、实现途径 起初各位小伙伴需要分析源代码时往往会通过“函数插桩”的方法来分析代码的执行流程，当然这种方法在代码量较小、调用层级不深的情况下使用起来
ipftrace2:面向数据包Linux内核函数调用跟踪器
03-20
它类似于ftrace在某种意义上，但是，你可以跟踪哪些流已经通过该功能了这通常是网络的人比函数的调用提供的信息更重要的信息在内核中ftrace 。 受支持的环境 架构：（当前）仅x86_64 Linux版本：v4.17或更高版本 ...
ftrace-hook:在Linux内核中使用ftrace进行函数挂钩
05-04
Linux内核模块演示了如何使用ftrace框架进行函数挂钩：就像在挂钩函数周围执行任意代码一样。 该代码已根据许可。 如何建造 请考虑使用虚拟机（VirtulBox，VMWare，QEMU等）进行实验。 （不变的）模块是完全无害的...
Linux 原生跟踪工具 Ftrace
legend050709的专栏
12-12 1129
ftrace
ftrace分析程序的调用栈
lxb122435677的博客
12-27 812
文章目录ftrace能干什么ftrace怎么用配置文件说明ftrace怎么实现的 ftrace能干什么 能够对内核函数以及用户态函数进行trace。获取函数的调用栈以及函数的性能。 ftrace怎么用 ftrace依赖于内核中的debugfs，debugfs是将内核态和用户态联通的手段。 /sys/kernel/debug/tracing是总的入口。 配置文件说明 available_trace...
使用ftrace跟踪函数
qq_15759745的博客
10-05 940
在阅读Linux源码的过程中我们常常要花时间去梳理函数的调用关系，由于linux中存在各种分支，分析函数的调用关系成为一件很难的事情。除了死磕源码外，还有很多手段有助于我们梳理函数关系，比如：使用qemu + gdb，ftrace，ebpf等，linux的trace系统是一个很庞大的分支，一时很难梳理清楚，这篇文章重点列举使用ftrace跟踪函数的方式，尽量给出最短的demo脚本。
ftrace命令调试内核详细总结（快速掌握附实例讲解）
Luckiers的博客
05-08 3920
文章目录一、简介二、ftrace的相关配置2.1 ftrace主要配置流程2.2 具体配置详解三、ftracing目录内容详解3.1 通用配置解析3.2 支持的跟踪器解析3.3 其他配置文件四、实例操作五、其他相关博客链接 一、简介 Ftrace是一个专门针对linux kernel内核空间的debug工具，用于帮助开发者弄清kernel正在发生的行为，对用户空间对内核低延时，内核性能等方面的问题进行调试分析。 Ftrace最开始设计时主要是为了追踪函数的调用栈，但随着功能的增强，已经演变成一个跟踪框架，支
学内核之二十一：系统调用栈结构分析
wwwyuewww的专栏
09-17 389
主要是内核栈占用两个页面，共8KB，一头上threadinfo，一头是内核栈栈底。关于汇编里的伪代码 标记 头文件引入 指令集选择 新旧ABI兼容处理 等等，就不记录了，可以结合最终汇编代码，确定一些条件编译的情况。r4 和 r5之后，使用r8保存系统调用表，使用7中的中断号，右移两位，每个调用占用4字节，修改pc寄存器，直接跳转到系统调用中。这个反汇编中，虚拟地址开始位置调整为c0000000了，且上述表的内容也有具体内容了。这个函数里，入栈7个位置，并预留9个位置，这也跟上述栈标记及栈回溯对应上了。
利用save_stack(),print_stack()查linux内核的内存泄露
tianqishi的专栏
09-13 473
在之前公司搞了5年的linux内核和驱动，打算翻翻笔记拿点东西出来写。 查内存泄露时自己想的一个办法，经过多次考验是有效的，在32位，64位的arm上都试过，检查出来过原生内核的内存泄露bug，后来在mips系统也用过一次。 简单的原理是，在内存分配的入口函数__alloc_pages_nodemask调用save_stack()把内存分配的堆栈保存下来，然后每隔一段时间比如两分钟，统计一下已分配出去的页是通过怎样的堆栈分配出去的， 比如以下例子，如果统计出来非常多的页是通过下面堆栈分..
安卓系统内kernel 调用probe流程
06-13
安卓系统内Kernel调用Probe的流程如下： 1.开发者编写内核模块并在其中定义Probe函数。 2.在内核中注册Probe函数，通常使用内核Trace API中的register_trace_*函数。 3.当Probe所监控的事件被触发时，内核会调用Probe函数。 4.Probe函数会收集相关的数据并将其传递给Trace API。 5.Trace API会将数据传递给ftrace框架，最终写入trace_pipe文件。 6.用户空间的perf工具可以读取trace_pipe文件中的数据进行分析和处理。 需要注意的是，Kernel调用Probe的流程需要开发者对内核Trace API和Probe函数的编写有一定的了解，同时也需要在安卓系统中具备root权限。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值