文章目录
openssl3.2 - crypto-mdebug被弃用后, 内存泄漏检查的替代方法
概述
调用openssl接口后, 如果用到了openssl对象, 需要释放, 否则会发生内存泄漏.
即使不是新手, 也不能保证释放函数都调用了. 想想我们自己写程序, new后, 没有delete的情况就知道, 可以理解.
谁能保证自己手搓的应用实现100%没内存泄漏呢?
看资料时, 发现openssl本身有这个检查库本身发生内存泄漏的特性, 大概就是申请内存时, openssl自己记录了一下, free内存时, 将对应记录删掉.
这样, 在程序退出前, 再调用一下内存分配记录列表接口, 就知道哪里的内存没释放.
那试试, 加入crypto-mdebug特性, 模拟一下内存泄漏(调用openssl_new(), 不调用openssl_free()), 看看啥效果.
笔记
查看特性列表
perl configdata.pm --dump > my_log.txt
查看my_log.txt, 就有openssl 特性列表.
有启用的特性列表, 也有被禁掉的特性列表.
如果要加入特性, 就看禁止列表中的特性.
怎么打开crypto-mdebug特性呢?
看Configure可知, 只要带上参数 enable-crypto-mdebug即可.
结合我最后实验可用的编译脚本, 加入 enable-crypto-mdebug
openssl3.2编译脚本 - 加入enable-crypto-mdebug
解开官方源码包
打开vs2019x64本地命令行, 选择管理员身份运行
cd /d D:\3rd_prj\crypt\openssl-3.2.0
set path=c:\nasm;%path%
perl Configure VC-WIN64A --debug enable-crypto-mdebug zlib-dynamic --with-zlib-include=D:\my_dev\lib\zlib_1d3 --with-zlib-lib=.\my_zlib_1d3.dll --prefix=c:\openssl_3d2 --openssldir=c:\openssl_3d2\common
nmake
手工拷贝, 将 my_zlib_1d3.dll 拷贝到以下4个目录
.\
.\apps
.\fuzz
.\test
nmake test
nmake install
手工拷贝
D:\my_dev\lib\zlib_1d3\my_zlib_1d3.dll => C:\openssl_3d2\bin\my_zlib_1d3.dll
归档
C:\openssl_3d2 剪切到自己的库目录 => D:\my_dev\lib\openssl_3d2
写个测试程序, 调用一下内存泄漏检查的相关接口, 看看能否编译过, 然后试试接口怎么用.
/*!
* \file main.cpp
*/
#include "my_openSSL_lib.h"
#include <openssl/crypto.h> // for mem leak API
int main(int argc, char** argv)
{
CRYPTO_mem_leaks(NULL);
return 0;
}
/*!
编译错误
已启动重新生成…
1>------ 已启动全部重新生成: 项目: prj_template, 配置: Debug x64 ------
1>main.cpp
1>D:\my_dev\my_local_git_prj\study\openSSL\exp\call_mem_leak_API\main.cpp(12,2): error C4996: 'CRYPTO_mem_leaks': Since OpenSSL 3.0
1>已完成生成项目“prj_template.vcxproj”的操作 - 失败。
========== 全部重新生成: 成功 0 个，失败 1 个，跳过 0 个 ==========
*/
直接编译不过…
看官方说明 file:///D:/3rd_prj/crypt/openssl-3.2.0/doc/html/man3/OPENSSL_malloc.html
The following functions have been deprecated since OpenSSL 3.0, and can be hidden entirely by defining OPENSSL_API_COMPAT with a suitable version value, see openssl_user_macros(7):
int CRYPTO_mem_leaks(BIO *b);
int CRYPTO_mem_leaks_fp(FILE *fp);
int CRYPTO_mem_leaks_cb(int (*cb)(const char *str, size_t len, void *u),
void *u);
int CRYPTO_set_mem_debug(int onoff);
int CRYPTO_mem_ctrl(int mode);
int OPENSSL_mem_debug_push(const char *info);
int OPENSSL_mem_debug_pop(void);
int CRYPTO_mem_debug_push(const char *info, const char *file, int line);
int CRYPTO_mem_debug_pop(void);
DESCRIPTION
看到官方说, 这些内存诊断函数已经弃用了, 用clang的检查代替(忘了是哪个文档了, 反正是官方文档中说的).
去看内存诊断函数的实现, 都是空的, 官方确实已经弃用了.
尝试将vs2019的工具链改为clang, 看不到效果, 且不能单步进入库函数内部.
用clang工具链编译, 可以编译过, 也可以运行, 不过无法进入调试版的pdb实现中.
已启动重新生成…
1>------ 已启动全部重新生成: 项目: prj_template, 配置: Debug x64 ------
1>main.cpp(12,2): warning : 'CRYPTO_mem_leaks' is deprecated: Since OpenSSL 3.0 [-Wdeprecated-declarations]
1>D:\my_dev\lib\openssl_3d2\include\openssl/crypto.h(411,1): message : 'CRYPTO_mem_leaks' has been explicitly marked deprecated here
1>D:\my_dev\lib\openssl_3d2\include\openssl/macros.h(194,49): message : expanded from macro 'OSSL_DEPRECATEDIN_3_0'
1>D:\my_dev\lib\openssl_3d2\include\openssl/macros.h(44,22): message : expanded from macro 'OSSL_DEPRECATED'
1>prj_template.vcxproj -> D:\my_dev\my_local_git_prj\study\openSSL\exp\call_mem_leak_API\x64\Debug\prj_template.exe
1>'pwsh.exe' 不是内部或外部命令，也不是可运行的程序
1>或批处理文件。
1>已完成生成项目“prj_template.vcxproj”的操作。
========== 全部重新生成: 成功 1 个，失败 0 个，跳过 0 个 ==========
那就不用clang来编译.
看看有没有替代内存诊断的方法?
找到一个opensslAPI CRYPTO_get_alloc_counts(), 可以取当前内存分配次数.
将这个API封装一下, 卡在openssl应用函数外边, 就可以间接的知道是否有内存泄漏, 如果有opensslAPI调用引起的内存泄漏, 可以迅速的缩小排查范围.
main.cpp
/*!
* \file main.cpp
*/
#include "my_openSSL_lib.h"
#include <openssl/crypto.h>
bool is_OSSL_mem_leak();
void test_mem_leak(bool b_have_mem_leak);
int main(int argc, char** argv)
{
openssl_mdebug_begin();
test_mem_leak(true);
openssl_mdebug_end(true, false); // 如果需要断言, 参数2为true
openssl_mdebug_begin();
test_mem_leak(false);
openssl_mdebug_end(true, true);
/*
run result
test_mem_leak(test have mem leak)
>> malloc_count = 0, realloc_count = 0, free_count = 0
<< malloc_count = 1, realloc_count = 0, free_count = 0
err : !!! mem leak happen
test_mem_leak(test no mem leak)
*/
return 0;
}
void test_mem_leak(bool b_have_mem_leak)
{
void* pBuf = NULL;
printf("test_mem_leak(%s)\n", (b_have_mem_leak ? "test have mem leak" : "test no mem leak"));
pBuf = OPENSSL_malloc(2);
// do some task ...
if (!b_have_mem_leak)
{
OPENSSL_free(pBuf);
pBuf = NULL;
}
}
my_openSSL_lib.h
/*!
\file my_openSSL_lib.h
*/
#ifndef __MY_OPENSSL_LIB_H__
#define __MY_OPENSSL_LIB_H__
#ifdef __cplusplus
extern "C" {
#endif
#ifdef _WIN32
#include <WinSock2.h>
#pragma comment(lib, "ws2_32.lib") // for select()
#include <windows.h>
#include <stdbool.h>
#pragma comment(lib, "libcrypto.lib")
#pragma comment(lib, "libssl.lib")
#endif /* #ifdef _WIN32 */
// --------------------------------------------------------------------------------
// 开关宏 - begin
// --------------------------------------------------------------------------------
#define MY_USE_APPLINK
// --------------------------------------------------------------------------------
// 开关宏 - END
// --------------------------------------------------------------------------------
typedef struct _tag_openssl_mem_counter{
int malloc_count_begin;
int realloc_count_begin;
int free_count_begin;
int malloc_count_end;
int realloc_count_end;
int free_count_end;
} TAG_OPENSSL_MEM_COUNTER;
void openssl_mdebug_begin();
bool openssl_mdebug_end(bool show_tip, bool b_assert);
#ifdef __cplusplus
}
#endif
#endif /* #ifndef __MY_OPENSSL_LIB_H__ */
my_openSSL_lib.c
/*!
* \file D:\my_dev\my_local_git_prj\study\openSSL\nmake_test\test_c\prj_005_afalgtest.c\my_openSSL_lib.c
*/
#include "my_openSSL_lib.h"
#include "openssl/crypto.h" // for CRYPTO_get_alloc_counts
#include <assert.h>
#ifdef MY_USE_APPLINK
#include <openssl/applink.c> /*! for OPENSSL_Uplink(00007FF8B7EF0FE8,08): no OPENSSL_Applink */
#endif // #ifdef MY_USE_APPLINK
static TAG_OPENSSL_MEM_COUNTER gs_openssl_mdebug;
void openssl_mdebug_begin()
{
CRYPTO_get_alloc_counts(&gs_openssl_mdebug.malloc_count_begin, &gs_openssl_mdebug.realloc_count_begin, &gs_openssl_mdebug.free_count_begin);
}
bool openssl_mdebug_end(bool show_tip, bool b_assert)
{
bool b_rc = false;
long lCntBegin = 0;
long lCntEnd = 0;
CRYPTO_get_alloc_counts(&gs_openssl_mdebug.malloc_count_end, &gs_openssl_mdebug.realloc_count_end, &gs_openssl_mdebug.free_count_end);
lCntBegin = gs_openssl_mdebug.malloc_count_begin + gs_openssl_mdebug.realloc_count_begin - gs_openssl_mdebug.free_count_begin;
lCntEnd = gs_openssl_mdebug.malloc_count_end + gs_openssl_mdebug.realloc_count_end - gs_openssl_mdebug.free_count_end;
b_rc = (lCntBegin == lCntEnd);
if (!b_rc && show_tip)
{
printf(">> malloc_count = %d, realloc_count = %d, free_count = %d\n", gs_openssl_mdebug.malloc_count_begin, gs_openssl_mdebug.realloc_count_begin, gs_openssl_mdebug.free_count_begin);
printf("<< malloc_count = %d, realloc_count = %d, free_count = %d\n", gs_openssl_mdebug.malloc_count_end, gs_openssl_mdebug.realloc_count_end, gs_openssl_mdebug.free_count_end);
printf("err : !!! mem leak happen\n");
}
if (b_assert)
{
assert(true == b_rc);
}
return b_rc;
}
备注
以后有机缘再查查怎么用clang来查openssl应用是否有内存泄漏.
查资料时, 很多情况下都不是想查就能查到的.
很多时候, 是心里带着问题, 查其他资料时, 突然给了启发, 才将以前的问题搞掉.
这种调用CRYPTO_get_alloc_counts()来间接的排查是否调用opensslAPI时, 是否没有成对的分配,释放内存.
没有那么直接和方便, 不过也算是一种方法了. 有总比没有强.
希望以后能找到其他更好的方法来定位opensslAPI调用时的内存泄漏点.
备注
openssl的编译检查, 测试用例还是很严格的.
对外提供的API, 都有测试程序.
CRYPTO_get_alloc_counts()这个API的调用, 也能找到至少一处.
用SI将openssl源码编译的目录中的能识别的东东都包进来搜索, 必然能看到测试用例或者API调用的痕迹.
如果某个API虽然定义, 但是官方源码编译目录的实现中都没有用到, 那么咱么就不能用这个API.
这招不行啊
今天正好写个测试程序, 用到了这种内存泄漏检测方法. 有断言, 不好使.
int main(int argc, char** argv)
{
BIO* bio = NULL;
openssl_mdebug_begin();
test_bio_mem_leak();
// test_bio_new_mem_buf();
openssl_mdebug_end(false, true);
return 0;
}
void test_bio_mem_leak(void)
{
BIO* bio = BIO_new_mem_buf("Hello World\n", 12);
BIO_free(bio);
}
只能先关注这事, 以后再想办法了.
跟了一下openssl代码, 是产生默认库上下文中有很多openssl_malloc()引起的内存分配.
后续再看看, 自己显势调用产生销毁默认上下文的API, 是否可以继续用这种方法.
显势调用默认上下文也不行
int main(int argc, char** argv)
{
OSSL_LIB_CTX* _ossl_lib_ctx = NULL;
BIO* bio = NULL;
do {
openssl_mdebug_begin();
_ossl_lib_ctx = OSSL_LIB_CTX_get0_global_default();
if (NULL == _ossl_lib_ctx)
{
assert(false);
break;
}
test_bio_mem_leak();
// test_bio_new_mem_buf();
OSSL_LIB_CTX_free(_ossl_lib_ctx);
openssl_mdebug_end(true, false); // 到这里, 还是报错
} while (false);
return 0;
}
void test_bio_mem_leak(void)
{
BIO* bio = BIO_new_mem_buf("Hello World\n", 12);
BIO_free(bio);
}
报错原因, openssl函数调用中, 会有其他默认的上下文建立会调用内存分配.
具体是啥函数, 要去单步.
这种用内存分配计数的方法, 不能真实的间接观察到openssl内部的内存泄漏, 做了一个没用的实验…
还是要老老实实的看官方例子, 手工调用对应API的释放函数.
找到一种还可以的解决方法, 现在看来可以准确观测到openssl内存泄漏点
openssl设计的可以, 预留了很多有用的API.
翻翻openssl提供的API, 找到了以下有用的API.
CRYPTO_get_mem_functions()
CRYPTO_set_mem_functions()
OPENSSL_init_crypto()
OPENSSL_cleanup()
这些可以用于辅助观测openssl内存泄漏点, 不止是openssl API, openssl内部发生的内存泄漏也能观测到(如果有的话)
内存泄漏观测的程序实现
main.cpp
/*!
* \file main.cpp
*/
#include "my_openSSL_lib.h"
#include <openssl/crypto.h>
#include <openssl/bio.h>
#include <stdlib.h>
#include <stdio.h>
#include <assert.h>
#include "CMemHookRec.h"
void test_bio_mem_leak(bool b_have_mem_leak);
int main(int argc, char** argv)
{
setvbuf(stdout, NULL, _IONBF, 0); // 清掉stdout缓存, 防止调用printf时阻塞
// mem IF hook, 必须在执行任何openssl API之前替换
mem_hook();
// 自己的openssl接口应用
test_bio_mem_leak(true);
test_bio_mem_leak(false);
// mem IF un hook, 必须在openssl结束后, 再恢复原始函数
mem_unhook();
/* run result, 如果有openssl应用接口没释放引起的内存泄漏, 有断言, stdout有输出
一个openssl API引起的内存泄漏可能对应这多条内存分配记录, 不过排查范围缩小多了, 线索也清晰多了
结合对自己的openssl调用代码块的注释排除法, 很容易找到自己哪里没调用正确的openssl释放API.
free map, g_mem_hook_map.size() = 4
2AAA2F36560 128 crypto\bio\bio_lib.c:83
2AAA2F4EC40 16 crypto\bio\bss_mem.c:111
2AAA2FEA470 32 crypto\bio\bss_mem.c:119
2AAA2FEAA10 32 crypto\buffer\buffer.c:35
error : !!! find openssl call memory leak
Assertion failed: false, file D:\my_dev\my_local_git_prj\soft\xx\src\case\exp002_mem_hook\main.cpp, line 57
*/
return 0;
}
void test_bio_mem_leak(bool b_have_mem_leak)
{
BIO* bio = BIO_new_mem_buf("Hello World\n", 12);
if (false == b_have_mem_leak)
{
BIO_free(bio);
}
}
找内存泄漏时很方便, 只要在程序入口处调用mem_hook(), 然后自己正常调用openssl API, 程序结束前调用mem_unhook()
如果有openssl 释放API没调用引起的内存泄漏, 就会有断言.
如果是控制台程序, 就可以直接看到内存泄漏点.
如果不是控制台程序, 将mem_unhook()中的内存泄漏改写到其他输出(e.g. 文件).
这排查起来就容易多了.
CMemHookRec.h
/*!
\file CMemHookRec.h
\note openssl 分配API hook 之后, 记录的内存分配记录
*/
#ifndef __CMEMHOOKREC_H__
#define __CMEMHOOKREC_H__
void mem_hook();
void mem_unhook();
#endif // #ifndef __CMEMHOOKREC_H__
CMemHookRec.cpp
/// \file CMemHookRec.cpp
#include "pch.h"
#include <cstdint>
#include <stdio.h>
#include <map>
#include <openssl/crypto.h>
#include "CMemHookRec.h"
#include <assert.h>
#ifndef SAFE_DELETE
#define SAFE_DELETE(p) \
do { \
if (NULL != (p)) { \
delete (p);\
} \
(p)=NULL; \
} while (0);
#endif // #ifndef SAFE_DELETE
class CMemHookRec
{
public:
void show_info();
public:
uint64_t u64_addr;
size_t num;
const char* file;
int line;
uint64_t rec_sn;
};
static std::map<uint64_t, CMemHookRec*> g_mem_hook_map;
typedef std::pair<uint64_t, CMemHookRec*> Map_Pair_mem_hook;
typedef std::map<uint64_t, CMemHookRec*>::iterator It_mem_hook;
// malloc_fn_org 0x00007ffb0796614f {libcrypto-3-x64.dll!CRYPTO_malloc} void *(*)(unsigned __int64, const char *, int)
static CRYPTO_malloc_fn malloc_fn_org = NULL;
// realloc_fn_org 0x00007ffb07967a1d {libcrypto-3-x64.dll!CRYPTO_realloc} void *(*)(void *, unsigned __int64, const char *, int)
static CRYPTO_realloc_fn realloc_fn_org = NULL;
// free_fn_org 0x00007ffb079631b1 {libcrypto-3-x64.dll!CRYPTO_free} void(*)(void *, const char *, int)
static CRYPTO_free_fn free_fn_org = NULL;
static OPENSSL_INIT_SETTINGS* gp_ossl_init_setting = NULL;
static uint64_t g_u64_malloc_cnt_all = 0;
static void* my_CRYPTO_malloc(size_t num, const char* file, int line);
static void* my_CRYPTO_realloc(void* addr, size_t num, const char* file, int line);
static void my_CRYPTO_free(void* ptr, const char* file, int line);
static bool free_map();
static std::wstring my_A2W(std::string str);
void CMemHookRec::show_info()
{
#ifdef _MFC_VER
TRACE(TEXT("entry sn = [%I64d], %I64X %zu %s:%d\n"), this->rec_sn, u64_addr, num, ((NULL != file) ? my_A2W(file).data() : TEXT("NULL")), line);
#else
printf("entry sn = [%I64d], %I64X %zu %s:%d\n", this->rec_sn, u64_addr, num, ((NULL != file) ? file : "NULL"), line);
#endif // #ifdef _MFC_VER
}
void mem_hook()
{
int i_rc = 0;
uint64_t u64_init_opt = 0;
CRYPTO_get_mem_functions(&malloc_fn_org, &realloc_fn_org, &free_fn_org);
CRYPTO_set_mem_functions(my_CRYPTO_malloc, my_CRYPTO_realloc, my_CRYPTO_free);
// openssl init all
gp_ossl_init_setting = OPENSSL_INIT_new(); // 必须用OPENSSL_INIT_free()释放， 否则有24个字节的泄漏
u64_init_opt = OPENSSL_INIT_LOAD_CRYPTO_STRINGS |
OPENSSL_INIT_ADD_ALL_CIPHERS |
OPENSSL_INIT_ADD_ALL_DIGESTS |
OPENSSL_INIT_LOAD_CONFIG |
OPENSSL_INIT_ASYNC |
OPENSSL_INIT_NO_ATEXIT;
// 将openssl库中的静态初始化函数显势调用一下, 免得在我们手工调用API时(因为有些openssl对象或变量没初始化)自动调用静态初始化函数引起多余的非我们应用产生的内存分配
// 初始化函数在应用中只能调用一次.
i_rc = OPENSSL_init_crypto(u64_init_opt, gp_ossl_init_setting);
assert(1 == i_rc);
}
void mem_unhook()
{
// openssl uninit all
// 只能调用一次
OPENSSL_cleanup();
// 必须在openssl cleanup之后调用map显示, 这样才能过滤掉系统自动分配的内存.
// 如果map不为空, 这些记录才是我们自己应用没释放的内存
// 在free_map()时, 如果看到多条未被释放的内存, 也一定是那么多个API调用没释放, 因为一条openssl API会对应者多个openssl_mallc(), e.g. BIO_new_mem_buf() 就有4个内存分配动作.
if (!free_map())
{
printf("error : !!! find openssl call memory leak\r\n");
assert(false);
/* run result
free map, g_mem_hook_map.size() = 4
2AAA2F36560 128 crypto\bio\bio_lib.c:83
2AAA2F4EC40 16 crypto\bio\bss_mem.c:111
2AAA2FEA470 32 crypto\bio\bss_mem.c:119
2AAA2FEAA10 32 crypto\buffer\buffer.c:35
error : !!! find openssl call memory leak
Assertion failed: false, file D:\my_dev\my_local_git_prj\soft\krgy_software_protect\src\case\exp002_mem_hook\main.cpp, line 57
*/
}
if (NULL != gp_ossl_init_setting)
{
OPENSSL_INIT_free(gp_ossl_init_setting);
gp_ossl_init_setting = NULL;
}
CRYPTO_set_mem_functions(malloc_fn_org, realloc_fn_org, free_fn_org);
}
static std::wstring my_A2W(std::string str)
{
USES_CONVERSION;
std::wstring str_rc = A2W(str.c_str());
return str_rc;
}
static bool free_map()
{
It_mem_hook it = g_mem_hook_map.end();
size_t size = g_mem_hook_map.size();
#ifdef _MFC_VER
TRACE(TEXT("free mem_hook map, g_mem_hook_map.size() = %zd, %s openssl API call memory leak\n"), size, ((size > 0) ? TEXT("have") : TEXT("no")));
#else
printf("free mem_hook map, g_mem_hook_map.size() = %zd, %s openssl API call memory leak\n", size, ((size > 0) ? "have" : "no"));
#endif // #ifdef _AFXDLL
for (it = g_mem_hook_map.begin(); it != g_mem_hook_map.end(); it++) {
if (NULL != it->second) {
it->second->show_info();
}
SAFE_DELETE(it->second);
}
g_mem_hook_map.clear();
return (0 == size);
}
static void* my_CRYPTO_malloc(size_t num, const char* file, int line)
{
void* p = NULL;
It_mem_hook it;
CMemHookRec* rec = NULL;
p = malloc(num);
if (NULL != p)
{
it = g_mem_hook_map.find((uint64_t)p);
if (it != g_mem_hook_map.end()) {
// printf("find key\n");
assert(false);
}
else {
// printf("not find key\n");
rec = new CMemHookRec();
if (NULL != rec)
{
rec->rec_sn = ++g_u64_malloc_cnt_all;
if (2225 == rec->rec_sn)
{
rec->rec_sn = rec->rec_sn; // for debug mem leak
}
rec->u64_addr = (uint64_t)p;
rec->num = num;
rec->file = file;
rec->line = line;
g_mem_hook_map.insert(Map_Pair_mem_hook(rec->u64_addr, rec));
}
}
}
return p;
}
static void* my_CRYPTO_realloc(void* addr, size_t num, const char* file, int line)
{
void* p = NULL;
It_mem_hook it;
CMemHookRec* rec = NULL;
p = realloc(addr, num);
if (NULL != p)
{
it = g_mem_hook_map.find((uint64_t)addr);
if (it != g_mem_hook_map.end()) {
// printf("find key\n");
SAFE_DELETE(it->second);
g_mem_hook_map.erase(it);
}
rec = new CMemHookRec();
if (NULL != rec)
{
rec->rec_sn = ++g_u64_malloc_cnt_all;
rec->u64_addr = (uint64_t)p;
rec->num = num;
rec->file = file;
rec->line = line;
g_mem_hook_map.insert(Map_Pair_mem_hook(rec->u64_addr, rec));
}
}
return p;
}
static void my_CRYPTO_free(void* ptr, const char* file, int line)
{
It_mem_hook it;
CMemHookRec* rec = NULL;
if (NULL != ptr)
{
free(ptr);
it = g_mem_hook_map.find((uint64_t)ptr);
if (it != g_mem_hook_map.end()) {
// printf("find key\n");
SAFE_DELETE(it->second);
g_mem_hook_map.erase(it);
}
else {
// printf("not find key\n");
assert(false);
}
}
}
备注
此笔记前面实验的CRYPTO_get_alloc_counts()方法, 在mem_hook中用不了了, 因为将内存分配函数换掉了.
不过, 可以在上面这个实验上改改, 不hook内存分配函数, 只用 OPENSSL_init_crypto() + OPENSSL_cleanup() + CRYPTO_get_alloc_counts(), 应该也能看到内存泄漏的计数, 但是看不到哪个文件哪行发生的泄漏.
因为这个想法不好, 我就没去再实验.
毕竟有多个解决方法, 只取最优的那个.
mem_hook()这个方法好, 能看到发生泄漏的具体库文件和行数, 排查起来可操作性强.
备注
将 void CMemHookRec::show_info()的输出改了一下, 上面的实验代码已经更新.
void CMemHookRec::show_info()
{
printf("entry sn = [%I64d], %I64X %zu %s:%d\n", this->rec_sn, u64_addr, num, ((NULL != file) ? file : "NULL"), line);
}
这样的话, 等观测到内存泄漏时, 号码连续的就是一个openssl API的调用引起的内存泄漏, 更方便调试排查.
备注
- 修正了内存泄漏 add OPENSSL_INIT_free(gp_ossl_init_setting);
- 更新了输出格式，适应控制台和MFC程序
800
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
