65

我正在寻找像ltracestrace这样可以跟踪可执行文件中本地定义的函数的工具。ltrace 只跟踪动态库调用,strace 只跟踪系统调用。例如,给定以下 C 程序:

#include <stdio.h>

int triple ( int x )
{
  return 3 * x;
}

int main (void)
{
  printf("%d\n", triple(10));
  return 0;
}

运行程序ltrace将显示调用,printf因为这是一个标准库函数(这是我系统上的动态库),strace并将显示来自启动代码的所有系统调用、用于实现 printf 的系统调用和关闭代码,但我想要一些能告诉我该函数triple已被调用的东西。假设本地函数没有被优化编译器内联并且二进制文件没有被剥离(符号被删除),有没有工具可以做到这一点?

编辑

一些澄清:

  • 如果该工具还为非本地函数提供跟踪信息,那也没关系。
  • 我不想重新编译支持特定工具的程序,可执行文件中的符号信息应该足够了。
  • 如果我可以像使用 ltrace/strace 一样使用该工具附加到现有进程,我会非常好。
4

13 回答 13

54

假设您只想收到特定功能的通知,您可以这样做:

用调试信息编译(因为你已经有符号信息,你可能也有足够的调试)

给定

#include <iostream>

int fac(int n) {
    if(n == 0)
        return 1;
    return n * fac(n-1);
}

int main()
{
    for(int i=0;i<4;i++)
        std::cout << fac(i) << std::endl;
}

使用 gdb 进行跟踪:

[js@HOST2 cpp]$ g++ -g3 test.cpp
[js@HOST2 cpp]$ gdb ./a.out
(gdb) b fac
Breakpoint 1 at 0x804866a: file test.cpp, line 4.
(gdb) commands 1
Type commands for when breakpoint 1 is hit, one per line.
End with a line saying just "end".
>silent
>bt 1
>c
>end
(gdb) run
Starting program: /home/js/cpp/a.out
#0  fac (n=0) at test.cpp:4
1
#0  fac (n=1) at test.cpp:4
#0  fac (n=0) at test.cpp:4
1
#0  fac (n=2) at test.cpp:4
#0  fac (n=1) at test.cpp:4
#0  fac (n=0) at test.cpp:4
2
#0  fac (n=3) at test.cpp:4
#0  fac (n=2) at test.cpp:4
#0  fac (n=1) at test.cpp:4
#0  fac (n=0) at test.cpp:4
6

Program exited normally.
(gdb)

这是我收集所有函数地址的方法:

tmp=$(mktemp)
readelf -s ./a.out | gawk '
{ 
  if($4 == "FUNC" && $2 != 0) { 
    print "# code for " $NF; 
    print "b *0x" $2; 
    print "commands"; 
    print "silent"; 
    print "bt 1"; 
    print "c"; 
    print "end"; 
    print ""; 
  } 
}' > $tmp; 
gdb --command=$tmp ./a.out; 
rm -f $tmp

请注意,除了打印当前帧(bt 1)之外,您还可以做任何您喜欢的事情,打印一些全局的值,执行一些 shell 命令或在遇到fatal_bomb_exploded函数时发送一些东西:) 可悲的是,gcc 输出一些“当前语言已更改”之间的消息。但这很容易被发现。没什么大不了的。

于 2008-11-22T23:44:06.560 回答
23

System Tap可用于现代 Linux 机器(Fedora 10、RHEL 5 等)。

首先下载para-callgraph.stp脚本。

然后运行:

$ sudo stap para-callgraph.stp 'process("/bin/ls").function("*")' -c /bin/ls
0    ls(12631):->main argc=0x1 argv=0x7fff1ec3b038
276  ls(12631): ->human_options spec=0x0 opts=0x61a28c block_size=0x61a290
365  ls(12631): <-human_options return=0x0
496  ls(12631): ->clone_quoting_options o=0x0
657  ls(12631):  ->xmemdup p=0x61a600 s=0x28
815  ls(12631):   ->xmalloc n=0x28
908  ls(12631):   <-xmalloc return=0x1efe540
950  ls(12631):  <-xmemdup return=0x1efe540
990  ls(12631): <-clone_quoting_options return=0x1efe540
1030 ls(12631): ->get_quoting_style o=0x1efe540

另请参阅:观察、systemtap 和 oprofile 更新

于 2008-11-27T21:54:57.853 回答
11

使用Uprobes(自 Linux 3.5 起)

假设您想在~/Desktop/datalog-2.2/datalog使用参数调用它时跟踪所有函数-l ~/Desktop/datalog-2.2/add.lua ~/Desktop/datalog-2.2/test.dl

  1. cd /usr/src/linux-`uname -r`/tools/perf
  2. for i in `./perf probe -F -x ~/Desktop/datalog-2.2/datalog`; do sudo ./perf probe -x ~/Desktop/datalog-2.2/datalog $i; done
  3. sudo ./perf record -agR $(for j in $(sudo ./perf probe -l | cut -d' ' -f3); do echo "-e $j"; done) ~/Desktop/datalog-2.2/datalog -l ~/Desktop/datalog-2.2/add.lua ~/Desktop/datalog-2.2/test.dl
  4. sudo ./perf report -G

datalog 二进制文件中的函数列表 选择 dl_pushlstring 时的调用树,显示 main 调用 loadfile 调用 dl_load 调用程序调用 rule 调用literal 依次调用其他函数最终调用 dl_pushlstring,scan(父级:程序,即从顶部开始的第三个扫描)调用dl_pushstring 等等

于 2012-09-12T13:51:49.177 回答
9

假设您可以使用 gcc 选项重新编译(无需更改源代码)要跟踪的代码-finstrument-functions,您可以使用etrace获取函数调用图。

这是输出的样子:

\-- main
|   \-- Crumble_make_apple_crumble
|   |   \-- Crumble_buy_stuff
|   |   |   \-- Crumble_buy
|   |   |   \-- Crumble_buy
|   |   |   \-- Crumble_buy
|   |   |   \-- Crumble_buy
|   |   |   \-- Crumble_buy
|   |   \-- Crumble_prepare_apples
|   |   |   \-- Crumble_skin_and_dice
|   |   \-- Crumble_mix
|   |   \-- Crumble_finalize
|   |   |   \-- Crumble_put
|   |   |   \-- Crumble_put
|   |   \-- Crumble_cook
|   |   |   \-- Crumble_put
|   |   |   \-- Crumble_bake

在 Solaris 上,truss(strace 等效项)能够过滤要跟踪的库。当我发现 strace 没有这样的能力时,我感到很惊讶。

于 2008-11-23T14:42:37.450 回答
4
$ sudo yum install frysk
$ ftrace -sym:'*' -- ./a.out

更多:ftrace.1

于 2008-11-23T02:56:49.527 回答
3

KcacheGrind

https://kcachegrind.github.io/html/Home.html

测试程序:

int f2(int i) { return i + 2; }
int f1(int i) { return f2(2) + i + 1; }
int f0(int i) { return f1(1) + f2(2); }
int pointed(int i) { return i; }
int not_called(int i) { return 0; }

int main(int argc, char **argv) {
    int (*f)(int);
    f0(1);
    f1(1);
    f = pointed;
    if (argc == 1)
        f(1);
    if (argc == 2)
        not_called(1);
    return 0;
}

用法:

sudo apt-get install -y kcachegrind valgrind

# Compile the program as usual, no special flags.
gcc -ggdb3 -O0 -o main -std=c99 main.c

# Generate a callgrind.out.<PID> file.
valgrind --tool=callgrind ./main

# Open a GUI tool to visualize callgrind data.
kcachegrind callgrind.out.1234

您现在被留在了一个很棒的 GUI 程序中,其中包含许多有趣的性能数据。

在右下角,选择“调用图”选项卡。这显示了一个交互式调用图,当您单击函数时,该图与其他窗口中的性能指标相关。

要导出图表,请右键单击它并选择“导出图表”。导出的 PNG 如下所示:

从中我们可以看出:

  • 根节点是_start,它是实际的 ELF 入口点,包含 glibc 初始化样板
  • f0,f1并按f2预期相互调用
  • pointed也显示了,即使我们用函数指针调用它。如果我们传递了命令行参数,它可能不会被调用。
  • not_called没有显示,因为它没有在运行中被调用,因为我们没有传递额外的命令行参数。

很酷的valgrind是它不需要任何特殊的编译选项。

因此,即使您没有源代码,只有可执行文件,您也可以使用它。

valgrind设法通过轻量级“虚拟机”运行您的代码来做到这一点。

在 Ubuntu 18.04 上测试。

于 2015-08-04T16:25:35.520 回答
2

如果您将该函数外部化到外部库中,您还应该能够看到它被调用(使用 ltrace )。

之所以可行,是因为 ltrace 将自己置于您的应用程序和库之间,并且当所有代码都使用一个文件内部化时,它无法拦截调用。

即:ltrace xterm

从 X 库中吐出东西,而 X 几乎不是系统。

除此之外,唯一真正的方法是通过 prof 标志或调试符号进行编译时拦截。

我刚刚跑过这个应用程序,它看起来很有趣:

http://www.gnu.org/software/cflow/

但我不认为那是你想要的。

于 2008-11-22T23:44:36.747 回答
2

如果函数没有内联,你甚至可能会幸运地使用objdump -d <program>.

举个例子,让我们在 GCC 4.3.2 的main例程开始时掠夺一下:

$ objdump `which gcc` -d | grep '\(call\|main\)' 

08053270 <main>:
8053270:    8d 4c 24 04             lea    0x4(%esp),%ecx
--
8053299:    89 1c 24                mov    %ebx,(%esp)
805329c:    e8 8f 60 ff ff          call   8049330 <strlen@plt>
80532a1:    8d 04 03                lea    (%ebx,%eax,1),%eax
--
80532cf:    89 04 24                mov    %eax,(%esp)
80532d2:    e8 b9 c9 00 00          call   805fc90 <xmalloc_set_program_name>
80532d7:    8b 5d 9c                mov    0xffffff9c(%ebp),%ebx
--
80532e4:    89 04 24                mov    %eax,(%esp)
80532e7:    e8 b4 a7 00 00          call   805daa0 <expandargv>
80532ec:    8b 55 9c                mov    0xffffff9c(%ebp),%edx
--
8053302:    89 0c 24                mov    %ecx,(%esp)
8053305:    e8 d6 2a 00 00          call   8055de0 <prune_options>
805330a:    e8 71 ac 00 00          call   805df80 <unlock_std_streams>
805330f:    e8 4c 2f 00 00          call   8056260 <gcc_init_libintl>
8053314:    c7 44 24 04 01 00 00    movl   $0x1,0x4(%esp)
--
805331c:    c7 04 24 02 00 00 00    movl   $0x2,(%esp)
8053323:    e8 78 5e ff ff          call   80491a0 <signal@plt>
8053328:    83 e8 01                sub    $0x1,%eax

遍历所有的汇编器需要一些努力,但是您可以看到来自给定函数的所有可能调用。gprof它不像提到的其他一些实用程序那样容易使用,但它有几个明显的优点:

  • 您通常不需要重新编译应用程序即可使用它
  • 它显示了所有可能的函数调用,而类似的东西gprof只会显示执行的函数调用。
于 2008-11-28T03:15:34.057 回答
2

有一个用于使用 gdb 自动跟踪函数调用的 shell 脚本。但它不能附加到正在运行的进程。

blog.superadditive.com/2007/12/01/call-graphs-using-the-gnu-project-debugger/

页面副本 - http://web.archive.org/web/20090317091725/http://blog.superadditive.com/2007/12/01/call-graphs-using-the-gnu-project-debugger/

工具的副本 - callgraph.tar.gz

http://web.archive.org/web/20090317091725/http://superadditive.com/software/callgraph.tar.gz

它从程序中转储所有函数,并在每个函数上生成一个带有断点的 gdb 命令文件。在每个断点处,都会执行“backtrace 2”和“continue”。

这个脚本在大型项目(〜数千个函数)上相当慢,所以我在函数列表上添加了一个过滤器(通过 egrep)。这很容易,我几乎每天都使用这个脚本。

于 2009-12-30T15:37:13.157 回答
1

Gprof可能是你想要的

于 2008-11-22T22:27:05.233 回答
1

请参阅 traces,一个用于 Linux C/C++ 应用程序的跟踪框架: https ://github.com/baruch/traces#readme

它需要使用其工具重新编译您的代码,但会提供所有函数、它们的参数和返回值的列表。有一个交互式功能可以轻松导航大型数据样本。

于 2012-04-13T18:46:56.833 回答
0

希望Valgrind的callgrind 或 cachegrind 工具能为您提供所需的信息。

于 2008-11-22T22:20:32.517 回答
0

注意:这不是基于 linux 内核的 ftrace,而是我最近设计的用于完成本地函数跟踪和控制流的工具。公开支持 Linux ELF x86_64/x86_32。

https://github.com/leviathansecurity/ftrace

于 2014-03-13T20:06:44.687 回答