夜雨聆风学习资料网

ARTICLE · 1364720

教你一招,不改一行 C++ 源码,如何采集指定函数的输入输出

教你一招,不改一行 C++ 源码,如何采集指定函数的输入输出

在 Linux C++ 项目中,有时会遇到这样一种情况:

第三方 SDK 提供了一个动态库,业务程序调用里面的函数完成推理、数据处理或者其他任务。

程序能够正常运行,但某次调用的结果却不符合预期。

这时候,我们可能想知道:

  • • 调用函数时,实际传入了什么参数?
  • • 函数执行后,返回了什么结果?
  • • 某次异常调用对应的输入数据究竟是什么?
  • • 能不能在不修改原有业务代码的情况下,把这些信息记录下来?

如果能够直接在函数调用前后增加日志,当然是最简单的办法。

但现实中,代码可能属于第三方 SDK,源码不可用;也可能是已经部署的业务程序,修改、重新编译和发布都不方便。

有没有一种办法,可以不修改原有业务代码,直接在函数调用过程中采集输入和输出?

有。

在 Linux 下,可以利用动态链接器提供的 LD_PRELOAD 机制,编写一个 Shim 动态库,对指定函数进行拦截,在调用真正的函数之前和之后,分别记录输入参数和返回结果。

这篇文章就从一个简单的例子开始,看看它是如何工作的,以及在实际 C++ 工程中需要注意哪些问题。

一、什么是 Shim?为什么可以拦截函数?

先说一个概念:Shim。

Shim 可以理解为一个中间层,放在原有调用者和真正的函数实现之间。

原本的调用关系是:

业务程序   |   v目标动态库   |   v执行目标函数

现在增加一个 Shim 动态库:

业务程序   |   vShim 动态库   |   |-- 记录函数输入   |   v目标动态库   |   |-- 执行真正的函数   |   vShim 动态库   |   |-- 记录函数输出   |   v业务程序

业务程序仍然调用原来的函数,只不过函数符号的解析过程发生了变化。

Shim 先接收到调用,完成必要的输入采集,然后再转发给真正的函数。等真正的函数执行完成后,Shim 再记录返回结果,最后把结果返回给调用者。

这样就能在不修改原有业务源码的情况下,观察函数调用过程。

当然,这里的“不改源码”有一个前提:

不修改原有业务程序和第三方动态库的源码,并不意味着完全不需要写代码。

我们仍然需要编写自己的 Shim 动态库,并将它编译成 .so 文件。

二、LD_PRELOAD:让动态链接器优先加载自己的库

Linux 程序运行时,通常需要通过动态链接器加载依赖的共享库。

例如,一个程序依赖:

libc.solibstdc++.solibexample.so

动态链接器会根据 ELF 动态链接信息、符号查找范围以及库的加载顺序,解析程序需要的函数符号。

Linux 提供了一个环境变量:

LD_PRELOAD

它可以指定在其他共享库之前加载的动态库。

例如:

LD_PRELOAD=./libcapture.so ./main

这样启动程序时,动态链接器会优先加载 libcapture.so。

如果这个库中定义了与目标动态库中相同的、适用于当前符号查找路径的函数符号,就有机会由 Shim 中的函数接收调用。

这就是函数拦截的基础。

不过需要注意,LD_PRELOAD 并不是无条件覆盖进程中所有同名函数。

它主要影响通过动态符号查找路径解析的调用。对于主程序自身定义的符号、静态链接的代码、隐藏符号、内部绑定等情况,普通的符号抢占机制可能无法生效。

因此,能否拦截成功,首先取决于目标函数是否经过了可被动态链接器介入的符号解析过程。

三、先用一个完整例子跑通函数拦截

理论说起来比较抽象,我们先做一个最小实验。

准备三个文件:

demo/├── target.cpp├── main.cpp└── shim.cpp

1. 编写目标动态库

target.cpp:

#include <cstdio>extern "C"int calculate(int a, int b){    fprintf(stderr, "[Target] calculate called\n");    return a + b;}

这里定义了一个简单的函数 calculate,接收两个整数,返回它们的和。

使用 extern "C" 是为了让函数使用 C 链接方式,避免 C++ 名称修饰,方便后面通过函数名称查找。

编译成动态库:

g++ -shared -fPIC -o libtarget.so target.cpp

2. 编写调用程序

main.cpp:

#include <cstdio>extern "C"int calculate(int a, int b);int main(){    int result = calculate(10, 20);    fprintf(stderr, "[Main] result = %d\n", result);    return 0;}

编译:

g++ main.cpp -L. -ltarget \    -Wl,-rpath,'$ORIGIN' \    -o main

这里通过 -L. 指定动态库搜索目录,通过 -ltarget 链接目标库。

-Wl,-rpath,'$ORIGIN' 则让程序在运行时能够从自身所在目录查找依赖库。

先直接运行:

./main

输出:

[Target] calculate called[Main] result = 30

到这里,程序已经能够正常调用目标动态库。

3. 编写 Shim 动态库

接下来是关键部分。

shim.cpp:

#define _GNU_SOURCE#include <dlfcn.h>#include <cstdio>#include <cstdlib>using CalculateFunc = int (*)(int, int);extern "C"int calculate(int a, int b){    // 保存真正函数的地址    static CalculateFunc real_calculate = []() {        // 清除之前可能存在的动态链接错误        dlerror();        auto func = reinterpret_cast<CalculateFunc>(            dlsym(RTLD_NEXT, "calculate")        );        // 检查本次符号查找是否发生错误        const char* error = dlerror();        if (error != nullptr || func == nullptr)        {            fprintf(stderr,                    "[Shim] dlsym failed: %s\n",                    error ? error : "null function address");            std::abort();        }        return func;    }();    // 记录输入参数    fprintf(stderr,            "[Shim] input: a=%d, b=%d\n",            a, b);    // 调用真正的函数    int result = real_calculate(a, b);    // 记录输出结果    fprintf(stderr,            "[Shim] output: result=%d\n",            result);    return result;}

编译:

g++ -shared -fPIC -o libcapture.so shim.cpp -ldl

这里使用了 dlsym,所以需要链接动态加载库 libdl。

_GNU_SOURCE 用于启用 GNU 扩展相关声明。也可以在编译时增加:

-D_GNU_SOURCE

4. 使用 LD_PRELOAD 启动程序

执行:

LD_PRELOAD=./libcapture.so ./main

输出:

[Shim] input: a=10, b=20[Target] calculate called[Shim] output: result=30[Main] result = 30

可以看到,原本由 main 直接调用 libtarget.so 中的 calculate,现在先进入了 Shim 中的同名函数。

Shim 记录输入参数,再调用真正的 calculate,拿到结果后记录输出,最后将结果返回给调用者。

整个过程中,main.cpp 和 target.cpp 都没有发生任何修改。

这就是一个完整的函数拦截过程。

四、关键点:dlsym(RTLD_NEXT) 到底做了什么?

上面的代码中,有一个非常关键的调用:

dlsym(RTLD_NEXT, "calculate");

它的作用是:

从当前 Shim 动态库之后的符号查找范围中,继续查找名为 calculate 的符号。

为什么不能直接调用:

calculate(a, b);

因为当前 Shim 本身就定义了 calculate。

如果直接调用同名函数,很容易再次进入 Shim,形成递归调用,最终导致栈溢出。

而 RTLD_NEXT 可以让我们跳过当前 Shim,继续寻找后面的真正实现。

可以简单理解为:

当前调用进入 Shim       |       vShim 需要调用真正函数       |       vdlsym(RTLD_NEXT, "calculate")       |       v从当前 Shim 之后继续查找       |       v找到目标动态库中的 calculate

这里还有几个细节值得注意。

1. 为什么使用 static 保存函数地址?

代码中:

static CalculateFunc real_calculate = []() {    // ...}();

目的是在第一次调用时解析真正函数的地址,后续调用直接复用,避免每次都执行 dlsym。

C++11 及之后版本,函数局部静态变量的初始化具有线程安全保证。

因此,不应该简单地把普通局部静态变量初始化描述成存在普遍的多线程初始化竞争问题。

但如果初始化过程间接再次进入同一个 Shim 函数,就可能出现递归初始化等问题。实际工程中还需要关注日志函数、动态库初始化以及其他依赖是否会反过来触发被拦截的符号。

2. 为什么先调用 dlerror()?

代码中有:

dlerror();auto func = reinterpret_cast<CalculateFunc>(    dlsym(RTLD_NEXT, "calculate"));const char* error = dlerror();

这是为了正确判断符号查找是否失败。

dlsym 返回空指针,并不总是意味着查找失败。某些符号的值本身也可能是空地址。

因此,通常应该先调用 dlerror() 清除之前的错误状态,再调用 dlsym(),最后通过 dlerror() 判断本次查找是否产生错误。

不过,在我们的例子中,返回空地址的函数指针也无法正常转发调用,因此代码仍然将它作为失败情况处理。

3. 为什么找不到真正函数时不能继续执行?

如果 Shim 找不到真正的函数地址,就无法完成正常转发。

实验代码使用:

std::abort();

是为了让问题在调试时明确暴露出来。

但这并不意味着生产环境也应该直接终止业务进程。

实际工程中,应该根据业务要求处理,例如输出错误信息、停止当前功能或采用其他明确的降级策略。

不能在没有真正执行目标函数的情况下,随意返回一个伪造的成功结果。

4. 多个 Shim 同时存在时会怎样?

例如:

LD_PRELOAD="./libfirst.so ./libsecond.so" ./main

多个预加载库可能形成一条函数转发链。

每个 Shim 都可以通过 RTLD_NEXT 将调用继续传递给后面的实现。

这意味着预加载库的顺序会影响实际调用路径。

如果多个库都拦截了同一个符号,就需要特别关注加载顺序以及每一层是否正确转发。

五、实际 C++ 项目中,函数名称没有这么简单

前面的例子使用了:

extern "C"int calculate(int a, int b);

它的符号名称比较简单。

但实际项目大多使用 C++,函数可能属于某个命名空间、类或者模板。

例如:

namespace VisionSDK{class Engine{public:int Init(const Config& config);int Run(const Input& input, Output& output);};}

如果直接通过:

dlsym(RTLD_NEXT, "Run");

通常是找不到目标函数的。

原因是 C++ 存在 Name Mangling,也就是名称修饰机制。

1. 什么是 Name Mangling?

C++ 支持函数重载。

例如:

int process(int value);int process(float value);

两个函数名称相同,但参数类型不同。

为了让动态链接器能够区分它们,编译器会将函数名称转换为包含命名空间、类名、参数类型等信息的符号名称。

例如:

_Z7processi_Z7processf

这是 GCC 常见 ABI 下的修饰名称示例。

因此,在拦截 C++ 函数时,不能想当然地认为源代码中的函数名称就是动态库里的符号名称。

2. 如何查看真实符号名称?

Linux 下可以使用以下工具。

查看动态库导出的符号:

nm -D libexample.so

查看未解析符号和动态符号表:

readelf -Ws libexample.so

查看动态符号及反汇编信息:

objdump -T libexample.so

如果想把 C++ 修饰名称转换成人类更容易理解的形式,可以使用:

nm -D libexample.so | c++filt

例如:

_ZN9VisionSDK6Engine3RunERK5InputR6Output

经过反修饰后,可能得到类似:

VisionSDK::Engine::Run(Input const&, Output&)

具体名称取决于真实的命名空间、类名和参数类型。

这里需要说明:对于普通的非模板函数,返回类型通常不参与 Itanium C++ ABI 的函数名称修饰;模板函数和函数类型等场景则存在更复杂的规则。

因此,不能仅凭函数名称就判断 ABI 一定兼容。

3. C++ 成员函数能不能直接拦截?

可以尝试,但比 C 函数复杂得多。

例如:

int VisionSDK::Engine::Run(    const Input& input,    Output& output);

它并不是一个普通的全局函数。

在常见的 C++ ABI 实现中,非静态成员函数调用时会隐式传入一个 this 指针。

从 ABI 的角度,可以把它近似理解为:

int Run(    VisionSDK::Engine* this_ptr,    const Input& input,    Output& output);

但这只是便于理解的概念模型,并不是可以直接照搬的可移植 C++ 函数声明。

尤其是成员函数指针、虚函数和多继承等场景,ABI 可能涉及 this 指针调整、虚表偏移等信息。

不能简单地把所有成员函数都当成普通函数指针处理。

如果目标是拦截 C++ 成员函数,必须结合编译器、平台 ABI、函数签名和实际符号信息进行适配。

对于复杂的 C++ SDK,建议先通过 nm、readelf 等工具确认目标符号,再编写对应的 Shim。

六、从实验走向工程:如何采集复杂函数的输入输出?

简单的整数参数很容易打印。

但在真实 C++ 工程中,函数可能接收结构体、对象、指针、图像数据或者配置对象。

例如,我们假设某个 SDK 提供了如下接口:

namespace VisionSDK{class Engine{public:int Init(const Config& config);int Run(const Input& input, Output& output);};}

我们希望在不修改原有业务代码的情况下,采集:

  • • 初始化时使用的配置;
  • • 每次调用时的输入信息;
  • • 函数执行后的返回状态;
  • • 输出对象中的关键结果;
  • • 每次调用对应的请求标识。

这时就需要把前面的简单 Shim 思路扩展成一套轻量级采集机制。

1. 先明确采集边界

不要一上来就尝试把整个 C++ 对象的内存全部打印出来。

例如:

fprintf(stderr, "%p", &input);

这只能得到对象地址,并不能得到真正的输入内容。

如果直接把对象内存按字节导出,也不一定有意义。

复杂 C++ 对象内部可能包含:

  • • 指针;
  • • STL 容器内部结构;
  • • 虚函数表指针;
  • • 内存对齐产生的填充字节;
  • • 动态分配的数据;
  • • 与编译器 ABI 相关的布局信息。

这些内容既不适合直接作为业务数据保存,也可能因为对象生命周期结束而失效。

更合理的方式是:

只采集明确知道含义、并且能够安全读取的字段。

例如:

输入对象  |  |-- 输入宽度  |-- 输入高度  |-- 数据类型  |-- 数据长度  |-- 关键配置  |  v序列化为 JSON

如果参数中包含指针,还需要确认数据长度、内存是否可读以及数据生命周期。

不能只记录一个指针地址,就认为已经完成了输入数据采集。

2. 在函数调用前后分别采集

整个流程可以分成三个阶段:

收到函数调用      |      v提取并记录输入参数      |      v调用真正的 SDK 函数      |      v提取并记录返回值和输出参数      |      v返回原始调用结果

例如,采集结果可以设计为:

{  "function": "VisionSDK::Engine::Run",  "request_id": "req_000001",  "phase": "input",  "data": {    "width": 1920,    "height": 1080,    "format": "example"  }}

函数执行完成后,再记录一条:

{  "function": "VisionSDK::Engine::Run",  "request_id": "req_000001",  "phase": "output",  "data": {    "status": 0,    "result_count": 3  }}

这里使用 JSONL 格式,即每条记录占一行。

与把所有请求信息写入一个很大的 JSON 文件相比,JSONL 更适合持续追加、逐行分析和后续处理。

3. 输入和输出如何关联?

实际工程中,函数可能被多个线程同时调用。

如果只是分别记录输入和输出,很容易出现这种情况:

线程 A:记录输入线程 B:记录输入线程 B:记录输出线程 A:记录输出

后续分析时,如果没有关联标识,就很难判断哪条输出对应哪条输入。

因此,可以为每次调用生成一个请求标识:

request_id = req_000001

在进入目标函数之前生成标识,记录输入;函数返回后,继续使用相同标识记录输出。

最终形成:

req_000001 -> input -> outputreq_000002 -> input -> outputreq_000003 -> input -> output

如果调用链本身已经有请求 ID,优先使用已有的上下文信息。

如果只能通过 Shim 自己维护上下文,可以考虑线程局部存储(TLS)。

但需要特别注意:

TLS 是线程级别的,不是请求级别的。

如果请求在执行过程中发生线程切换,例如线程池任务、异步回调或者协程调度,单纯依赖 TLS 可能无法正确传递请求上下文。

这种情况下,应当使用显式上下文传递机制,或者在任务切换时同步更新上下文。

不能把 TLS 简单等同于完整的请求追踪机制。

4. 采集逻辑不能影响原有业务执行

Shim 的目标是观察函数调用,而不是改变原有业务行为。

因此,采集逻辑应尽可能轻量。

例如:

  • • 不在函数拦截路径中执行复杂计算;
  • • 避免大量同步磁盘写入;
  • • 对日志数据设置大小上限;
  • • 对高频调用进行采样或限流;
  • • 避免日志组件再次触发被拦截的函数;
  • • 对敏感字段进行脱敏;
  • • 明确采集文件的保存周期。

另外,采集失败时,应尽可能避免影响真正函数的执行。

例如,日志文件打开失败,可以记录错误并继续调用真正的函数,而不是直接改变业务返回结果。

但这里也不能过度承诺所谓的“完全无侵入”。

如果采集代码错误地解引用了无效指针,或者发生严重内存错误,仍然可能导致进程崩溃。

因此,采集代码本身也必须进行充分测试。

5. 注意 C++ 异常传播

如果目标函数可能抛出 C++ 异常,Shim 不应该随意吞掉异常或者改变异常传播行为。

例如,目标函数抛出异常后,Shim 如果没有正确处理,就可能导致原有调用者无法按预期捕获异常。

对于需要保持原有行为的拦截代码,应当让异常按照原来的调用路径继续传播,并确保采集逻辑不会意外改变异常语义。

七、LD_PRELOAD 并不是万能的:这些情况可能拦截不到

虽然 LD_PRELOAD 使用起来比较方便,但它有明确的适用范围。

在实际使用之前,最好先了解以下限制。

1. 静态链接

如果目标函数已经被静态链接进可执行文件,运行时就不需要通过动态链接器查找对应的共享库符号。

这种情况下,普通的 LD_PRELOAD 通常无法拦截它。

2. 主程序自身定义的函数

如果目标函数由主程序自身定义,主程序的符号通常会优先于预加载库中的同名符号。

因此,不能认为只要在 Shim 中定义了同名函数,就一定能够覆盖主程序中的实现。

3. 符号可见性和内部绑定

如果函数使用了隐藏符号可见性,或者动态库通过 -Bsymbolic 等方式将内部引用绑定到自身定义,普通的符号抢占机制可能无法生效。

可以通过:

readelf -Ws libexample.so

检查符号表中的可见性等信息。

4. 编译器优化和内联

如果函数调用在编译时已经被内联,或者经过优化后不再通过原来的动态符号调用路径,就可能绕过 Shim。

因此,源码中存在某个函数,并不意味着运行时一定存在可以拦截的动态符号调用。

5. 安全执行模式

在 setuid、setgid 等安全执行场景中,动态链接器可能限制或忽略 LD_PRELOAD。

这是出于安全考虑,不能把普通用户环境下的行为直接套用到所有程序。

6. 函数签名和 ABI 不匹配

拦截函数必须与真正函数的调用约定和 ABI 保持兼容。

如果参数类型、返回类型、结构体布局、调用约定或者异常处理方式不匹配,就可能产生难以定位的问题。

尤其是复杂 C++ 对象,不应该仅凭反修饰后的函数名称就直接编写函数指针类型。

7. 动态库加载方式和符号查找范围

对于通过 dlopen() 动态加载的库,还需要考虑加载标志、符号查找范围以及 RTLD_LOCAL 等因素。

RTLD_NEXT 也不是无条件地搜索进程中的所有动态库,而是在当前对象之后的适用查找范围内继续解析。

因此,如果 Shim 没有拦截到目标函数,需要结合实际加载关系和符号解析路径进行分析。

八、除了 LD_PRELOAD,还有哪些方案?

如果 LD_PRELOAD 不适合当前场景,还可以考虑其他技术。

方案
主要用途
特点
LD_PRELOAD
动态符号拦截
实现简单,可以包装函数并转发调用
LD_AUDIT
动态链接过程审计
关注动态链接和符号绑定,不是通用函数替换方案
eBPF uprobe
用户态函数观测
可以观测函数执行,但参数解析依赖架构、编译器和 ABI
GDB
调试和临时分析
适合断点、查看参数和返回值,不适合长期高频采集

1. LD_AUDIT

Linux 动态链接器还提供了 LD_AUDIT 机制。

它可以在动态库加载、符号绑定等环节提供审计能力。

如果关注的是动态链接过程本身,LD_AUDIT 值得研究。

但它与 LD_PRELOAD 的定位不同,不能简单把它当成一个可以直接替换任意业务函数的工具。

2. eBPF uprobe

如果希望在不修改程序的情况下观测用户态函数,可以考虑 eBPF uprobe。

它可以在指定的用户态函数地址设置探针,观察函数执行过程。

不过,参数和返回值的解析需要结合目标架构、调用约定、编译器 ABI 等信息。

对于复杂 C++ 对象,仍然需要额外处理,不能直接认为探针能够自动理解所有对象内容。

3. GDB

如果只是临时排查某个函数的参数和返回值,GDB 也很实用。

通过断点、单步执行和变量查看,可以直接观察函数调用过程。

但如果需要长期运行、批量采集或者在生产环境中持续记录,GDB 通常不是最合适的方案。

九、总结

回到文章开头的问题:

能不能不修改原有 C++ 源码,采集指定函数的输入和输出?

在满足动态链接和符号解析条件的情况下,可以。

Linux 下的 LD_PRELOAD 提供了一种比较直接的实现方式:

  1. 1. 编写一个 Shim 动态库;
  2. 2. 在 Shim 中定义与目标函数匹配的符号;
  3. 3. 通过 dlsym(RTLD_NEXT, ...) 找到真正的函数;
  4. 4. 调用前记录输入参数;
  5. 5. 调用真正函数;
  6. 6. 调用后记录返回值和输出参数;
  7. 7. 通过 LD_PRELOAD 加载 Shim,完成函数拦截。

对于简单的 C 接口,实现起来并不复杂。

但如果目标是复杂的 C++ SDK,就需要进一步考虑 Name Mangling、成员函数 ABI、对象布局、线程上下文、异常传播和动态库加载关系等问题。

还有一点值得强调:

Shim 更适合做有边界的观测和诊断,不应该把它当成一个可以无条件拦截任意 C++ 函数的万能工具。

在实际工程中,先确认符号是否可见、调用是否经过动态链接器,再决定是否使用 LD_PRELOAD,往往比直接写拦截代码更重要。

对于需要排查第三方 SDK、定位输入输出异常,或者在无法修改原有业务源码的情况下补充运行时观测能力的场景,这是一种值得掌握的 Linux 工程技巧。

参考资料

  1. 1. Linux man-pages:ld.so(8),动态链接器、LD_PRELOAD 和 LD_AUDIT 相关说明https://man7.org/linux/man-pages/man8/ld.so.8.html
  2. 2. Linux man-pages:dlsym(3),动态符号查找、RTLD_NEXT 和 dlerror() 使用说明https://man7.org/linux/man-pages/man3/dlsym.3.html
  3. 3. Itanium C++ ABI,C++ 名称修饰、成员函数调用约定、成员函数指针等 ABI 规则https://itanium-cxx-abi.github.io/cxx-abi/abi.html
  4. 4. GCC 官方文档:Common Attributes,函数和类型的符号可见性说明https://gcc.gnu.org/onlinedocs/gcc/Common-Attributes.html
  5. 5. Linux man-pages:dlerror(3),动态链接错误处理接口https://man7.org/linux/man-pages/man3/dlerror.3.html

回首页,搜索你想要的文档

在首页搜索框输入关键词,快速定位资料

文库首页搜索指引 立即搜索

相关学习资料