面向开发的内存调试神器，如何使用ASAN检测内存泄漏、堆栈溢出等问题
- GreatSQL社区原创内容未经授权不得随意使用，转载请联系小编并注明来源。
[toc]
介绍
首先，先介绍一下 Sanitizer 项目，该项目是谷歌出品的一个开源项目，该项目包含了 ASAN、LSAN、MSAN、TSAN等内存、线程错误的检测工具，这里简单介绍一下这几个工具的作用：
ASAN: 内存错误检测工具，在编译命令中添加
-fsanitize=address启用LSAN: 内存泄漏检测工具，已经集成到 ASAN 中，可以通过设置环境变量
ASAN_OPTIONS=detect_leaks=0来关闭ASAN上的LSAN，也可以使用-fsanitize=leak编译选项代替-fsanitize=address来关闭ASAN的内存错误检测，只开启内存泄漏检查。MSAN: 对程序中未初始化内存读取的检测工具，可以在编译命令中添加
-fsanitize=memory -fPIE -pie启用，还可以添加-fsanitize-memory-track-origins选项来追溯到创建内存的位置TSAN: 对线程间数据竞争的检测工具，在编译命令中添加
-fsanitize=thread启用 其中ASAN就是我们今天要介绍的重头戏。
ASAN，全称 AddressSanitizer，可以用来检测内存问题，例如缓冲区溢出或对悬空指针的非法访问等。
根据谷歌的工程师介绍 ASAN 已经在 chromium 项目上检测出了300多个潜在的未知bug，而且在使用 ASAN 作为内存错误检测工具对程序性能损耗也是及其可观的。
根据检测结果显示可能导致性能降低2倍左右，比Valgrind（官方给的数据大概是降低10-50倍）快了一个数量级。
而且相比于Valgrind只能检查到堆内存的越界访问和悬空指针的访问，ASAN 不仅可以检测到堆内存的越界和悬空指针的访问，还能检测到栈和全局对象的越界访问。
这也是 ASAN 在众多内存检测工具的比较上出类拔萃的重要原因，基本上现在 C/C++ 项目都会使用ASAN来保证产品质量，尤其是大项目中更为需要。
如何使用 ASAN
作为如此强大的神兵利器，自然是不会在程序员的战场上失宠的。
从LLVM3.1、GCC4.8、XCode7.0、MSVC16.9开始ASAN就已经成为众多主流编译器的内置工具了，因此，要在项目中使用ASAN也是十分方便。
现在只需要在编译命令中加上-fsanitize=address检测选项就可以让ASAN在你的项目中大展神通，接下来通过几个例子来看一下 ASAN 到底有哪些本领。
注意：
- 在下面的例子中打开了调试标志
-g，这是因为当发现内存错误时调试符号可以帮助错误报告更准确的告知错误发生位置的堆栈信息，如果错误报告中的堆栈信息看起来不太正确，请尝试使用-fno-omit-frame-pointer来改善堆栈信息的生成情况。- 如果构建代码时，编译和链接阶段分开执行，则必须在编译和链接阶段都添加
-fsanitize=address选项。
检测内存泄漏
// leak.c
#include <stdio.h>
#include <stdlib.h>
#include <string.h>int main(int argc, const char *argv[]) {char *s = (char*)malloc(100);strcpy(s, "Hello world!");printf("string is: %s\n", s);return 0;
}上述代码中我们分配了100个字节的内存空间，但在main函数返回前始终没有释放，接下来我们使用ASAN看一下是否能够检测出来，添加-fsanitize=address -g参数构建代码并执行：
~/Code/test$ gcc noleak.c -o noleak -fsanitize=address -g
~/Code/test$ ./leak
string is: Hello world!=================================================================
==1621572==ERROR: LeakSanitizer: detected memory leaks // 1)Direct leak of 100 byte(s) in 1 object(s) allocated from: // 2)#0 0x7f5b986bc808 in __interceptor_malloc ../../../../src/libsanitizer/ASAN/ASAN_malloc_linux.cc:144#1 0x562d866b5225 in main /home/chenbing/Code/test/leak.c:7#2 0x7f5b983e1082 in __libc_start_main ../csu/libc-start.c:308SUMMARY: AddressSanitizer: 100 byte(s) leaked in 1 allocation(s).这里，ASAN 提供的报告说明了错误原因是detected memory leaks内存泄漏了1），同时，2)说明ASAN检测到应用程序分配了100个字节，并捕获到了内存分配位置的堆栈信息，还告诉了我们内存是在leak.c:7分配的。
有了这么详细的且准确的错误报告，内存问题是不是不那么头疼了？
检测悬空指针访问
// uaf.c
#include <stdio.h>
#include <stdlib.h>
#include <string.h>int main(int argc, const char *argv[]) {char *s = (char*)malloc(100);free(s);strcpy(s, "Hello world!"); // use-after-freeprintf("string is: %s\n", s);return 0;
}上述代码中我们分配了100个字节的内存空间，紧接着将其释放，但接下来我们对之前分配的内存地址执行写入操作，这是典型的悬空指针非法访问，同样，让我们使用ASAN看一下是否能够检测出来，添加-fsanitize=address -g参数构建代码并执行：
~/Code/test$ gcc uaf.c -o uaf -fsanitize=address -g
~/Code/test$ ./uaf
=================================================================
==1624341==ERROR: AddressSanitizer: heap-use-after-free on address 0x60b0000000f0 at pc 0x7f9f776bb58d bp 0x7fffabad8280 sp 0x7fffabad7a28 // 1)
WRITE of size 13 at 0x60b0000000f0 thread T0 // 2)#0 0x7f9f776bb58c in __interceptor_memcpy ../../../../src/libsanitizer/sanitizer_common/sanitizer_common_interceptors.inc:790#1 0x55b9cf56e26d in main /home/chenbing/Code/test/uaf.c:9#2 0x7f9f77452082 in __libc_start_main ../csu/libc-start.c:308#3 0x55b9cf56e16d in _start (/home/chenbing/Code/test/uaf+0x116d)0x60b0000000f0 is located 0 bytes inside of 100-byte region [0x60b0000000f0,0x60b000000154) // 3)
freed by thread T0 here:#0 0x7f9f7772d40f in __interceptor_free ../../../../src/libsanitizer/ASAN/ASAN_malloc_linux.cc:122#1 0x55b9cf56e255 in main /home/chenbing/Code/test/uaf.c:8#2 0x7f9f77452082 in __libc_start_main ../csu/libc-start.c:308previously allocated by thread T0 here: // 4)#0 0x7f9f7772d808 in __interceptor_malloc ../../../../src/libsanitizer/ASAN/ASAN_malloc_linux.cc:144#1 0x55b9cf56e245 in main /home/chenbing/Code/test/uaf.c:7#2 0x7f9f77452082 in __libc_start_main ../csu/libc-start.c:308SUMMARY: AddressSanitizer: heap-use-after-free ../../../../src/libsanitizer/sanitizer_common/sanitizer_common_interceptors.inc:790 in __interceptor_memcpy
Shadow bytes around the buggy address: // 5)0x0c167fff7fc0: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 000x0c167fff7fd0: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 000x0c167fff7fe0: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 000x0c167fff7ff0: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 000x0c167fff8000: fa fa fa fa fa fa fa fa fd fd fd fd fd fd fd fd
=>0x0c167fff8010: fd fd fd fd fd fa fa fa fa fa fa fa fa fa[fd]fd0x0c167fff8020: fd fd fd fd fd fd fd fd fd fd fd fa fa fa fa fa0x0c167fff8030: fa fa fa fa fa fa fa fa fa fa fa fa fa fa fa fa0x0c167fff8040: fa fa fa fa fa fa fa fa fa fa fa fa fa fa fa fa0x0c167fff8050: fa fa fa fa fa fa fa fa fa fa fa fa fa fa fa fa0x0c167fff8060: fa fa fa fa fa fa fa fa fa fa fa fa fa fa fa fa
Shadow byte legend (one shadow byte represents 8 application bytes):Addressable: 00Partially addressable: 01 02 03 04 05 06 07 Heap left redzone: faFreed heap region: fdStack left redzone: f1Stack mid redzone: f2Stack right redzone: f3Stack after return: f5Stack use after scope: f8Global redzone: f9Global init order: f6Poisoned by user: f7Container overflow: fcArray cookie: acIntra object redzone: bbASAN internal: feLeft alloca redzone: caRight alloca redzone: cbShadow gap: cc
==1624341==ABORTING这个错误报告看起来很长，但实际上并不复杂，
1）告诉我们错误的原因是：heap-use-after-free，访问了悬空指针，该内存的地址是：0x60b0000000f0，同时还告诉我们发生错误时的PC、BP、SP寄存器的内容，这些我们可以不关心，因为接下来的报告让我们可以忽略这些寄存器就可以定位到问题。
接下来是2）, 3）, 4），分别报告了访问悬空指针的位置、内存被释放位置、内存的分配位置的堆栈信息以及线程信息，从2)可以看到错误发生在
uaf.c文件的第8行代码。报告中的其他部分5)提供了错误访问的内存地址对应的
shadow 内存的详细，其中fa表示堆区内存的red zone，fd表示已经释放的堆区内存。
检测堆溢出
// overflow.c
#include <stdio.h>
#include <stdlib.h>
#include <string.h>int main(int argc, const char *argv[]) {char *s = (char*)malloc(12);strcpy(s, "Hello world!");printf("string is: %s\n", s);free(s);return 0;
}上面这段代码我们只分配了2个字节，但在随后操作中写入了13字节的数据（字符串还包含\0做为终止符），此时，数据的写入显然是溢出分配的内存块了，同样，添加-fsanitize=address -g参数构建代码并执行：
~/Code/test$ gcc overflow.c -o overflow -fsanitize=address -g
~/Code/test$ ./overflow
=================================================================
==2172878==ERROR: AddressSanitizer: heap-buffer-overflow on address 0x60200000001c at pc 0x7f1cd3d3d58d bp 0x7ffee78e6500 sp 0x7ffee78e5ca8 //1)
WRITE of size 13 at 0x60200000001c thread T0 // 2)#0 0x7f1cd3d3d58c in __interceptor_memcpy ../../../../src/libsanitizer/sanitizer_common/sanitizer_common_interceptors.inc:790#1 0x555593131261 in main /home/chenbing/Code/test/overflow.c:7#2 0x7f1cd3ad4082 in __libc_start_main ../csu/libc-start.c:308#3 0x55559313116d in _start (/home/chenbing/Code/test/overflow+0x116d)0x60200000001c is located 0 bytes to the right of 12-byte region [0x602000000010,0x60200000001c) // 3)
allocated by thread T0 here:#0 0x7f1cd3daf808 in __interceptor_malloc ../../../../src/libsanitizer/ASAN/ASAN_malloc_linux.cc:144#1 0x555593131245 in main /home/chenbing/Code/test/overflow.c:6#2 0x7f1cd3ad4082 in __libc_start_main ../csu/libc-start.c:308SUMMARY: AddressSanitizer: heap-buffer-overflow ../../../../src/libsanitizer/sanitizer_common/sanitizer_common_interceptors.inc:790 in __interceptor_memcpy
Shadow bytes around the buggy address: // 4)0x0c047fff7fb0: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 000x0c047fff7fc0: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 000x0c047fff7fd0: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 000x0c047fff7fe0: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 000x0c047fff7ff0: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
=>0x0c047fff8000: fa fa 00[04]fa fa fa fa fa fa fa fa fa fa fa fa0x0c047fff8010: fa fa fa fa fa fa fa fa fa fa fa fa fa fa fa fa0x0c047fff8020: fa fa fa fa fa fa fa fa fa fa fa fa fa fa fa fa0x0c047fff8030: fa fa fa fa fa fa fa fa fa fa fa fa fa fa fa fa0x0c047fff8040: fa fa fa fa fa fa fa fa fa fa fa fa fa fa fa fa0x0c047fff8050: fa fa fa fa fa fa fa fa fa fa fa fa fa fa fa fa
Shadow byte legend (one shadow byte represents 8 application bytes):Addressable: 00Partially addressable: 01 02 03 04 05 06 07 Heap left redzone: faFreed heap region: fdStack left redzone: f1Stack mid redzone: f2Stack right redzone: f3Stack after return: f5Stack use after scope: f8Global redzone: f9Global init order: f6Poisoned by user: f7Container overflow: fcArray cookie: acIntra object redzone: bbASAN internal: feLeft alloca redzone: caRight alloca redzone: cbShadow gap: cc
==2172878==ABORTING上面的报告访问悬空指针的错误报告很相似，同样
1)告诉我们错误的原因是：heap-buffer-overflow，堆区内存溢出了，该内存的地址是：0x60200000001c。
2)描述了写入数据导致溢出的位置堆栈，
3)则是对应的内存分配位置堆栈，4)还是shadow内存快照。
C++ 中的new/delete不匹配
// bad_delete.cpp
#include <iostream>
#include <cstring>int main(int argc, const char *argv[]) {char *cstr = new char[100];strcpy(cstr, "Hello World");std::cout << cstr << std::endl;delete cstr;return 0;
}这段代码通过new[]关键字分配了一块内存，但是在函数返回前却是使用delete堆内存进行释放，而不是delete[]，这将导致分配的内存没有被完全释放，还是添加-fsanitize=address -g参数构建代码并执行：
~/Code/test$ g++ bad_delete.cpp -o bad_delete -fsanitize=address -g
~/Code/test$ ./bad_delete
Hello World
=================================================================
==2180936==ERROR: AddressSanitizer: alloc-dealloc-mismatch (operator new [] vs operator delete) on 0x60b0000000f0 // 1#0 0x7fa9f877cc65 in operator delete(void*, unsigned long) ../../../../src/libsanitizer/ASAN/ASAN_new_delete.cc:177#1 0x55d09d3fe33f in main /home/chenbing/Code/test/bad_delete.cpp:10#2 0x7fa9f8152082 in __libc_start_main ../csu/libc-start.c:308#3 0x55d09d3fe20d in _start (/home/chenbing/Code/test/bad_delete+0x120d)0x60b0000000f0 is located 0 bytes inside of 100-byte region [0x60b0000000f0,0x60b000000154) // 2
allocated by thread T0 here:#0 0x7fa9f877b787 in operator new[](unsigned long) ../../../../src/libsanitizer/ASAN/ASAN_new_delete.cc:107#1 0x55d09d3fe2e5 in main /home/chenbing/Code/test/bad_delete.cpp:6#2 0x7fa9f8152082 in __libc_start_main ../csu/libc-start.c:308SUMMARY: AddressSanitizer: alloc-dealloc-mismatch ../../../../src/libsanitizer/ASAN/ASAN_new_delete.cc:177 in operator delete(void*, unsigned long)
==2180936==HINT: if you don't care about these errors you may set ASAN_OPTIONS=alloc_dealloc_mismatch=0
==2180936==ABORTING
这份错误报告比上面两个要简要的多，但提供的信息已经完全足够定位问题了:
1)汇报了错误类型：alloc-dealloc-mismatch，分配和释放操作不匹配，该内存的地址是：0x60b0000000f0，
2)是对应的内存分配位置堆栈，该报告不会明确告诉错误的位置应该使用delete[]对内存进行释放，因为在C++中分配和释放关键字可以被重写或者其他特定场景不匹配的关键字也能完全释放内存。
因此，ASAN不能保证alloc-dealloc-mismatch一定符合用户的期望，所以，在该报告中ASAN说明了：如果这对用户来说这是一个误报的错误，那么可以使用ASAN_OPTIONS=alloc_dealloc_mismatch=0来禁用该报告的触发，
例如：
~/Code/test$ ASAN_OPTIONS=alloc_dealloc_mismatch=0 ./bad_delete
Hello World上面执行代码时添加了ASAN_OPTIONS=alloc_dealloc_mismatch=0参数，因此，ASAN不会认为alloc-dealloc-mismatch是一个错误，从而发出错误报告。
检测栈溢出
// sbo.c
#include <stdio.h>int main(int argc, const char *argv[]) {int stack_array[100];stack_array[101] = 1;return 0;
}上面的代码，我们在栈上创建了一个容量为100的数组，但在随后的写入操作中在超过数据容量的地址上写入数据，导致了栈溢出，添加-fsanitize=address -g参数构建代码并执行：
~/Code/test$ g++ sbo.c -o sbo -fsanitize=address -g
chenbing@GreatDB-CB:~/Code/test$ ./sbo
=================================================================
==2196928==ERROR: AddressSanitizer: stack-buffer-overflow on address 0x7ffc33777f24 at pc 0x562dccb592b6 bp 0x7ffc33777d40 sp 0x7ffc33777d30 1)
WRITE of size 4 at 0x7ffc33777f24 thread T0#0 0x562dccb592b5 in main /home/chenbing/Code/test/sbo.c:6#1 0x7f45bf52d082 in __libc_start_main ../csu/libc-start.c:308#2 0x562dccb5910d in _start (/home/chenbing/Code/test/sbo+0x110d)Address 0x7ffc33777f24 is located in stack of thread T0 at offset 452 in frame 2)#0 0x562dccb591d8 in main /home/chenbing/Code/test/sbo.c:4This frame has 1 object(s): 3)[48, 448) 'stack_array' (line 5) <== Memory access at offset 452 overflows this variable
HINT: this may be a false positive if your program uses some custom stack unwind mechanism, swapcontext or vfork 4)(longjmp and C++ exceptions *are* supported)
SUMMARY: AddressSanitizer: stack-buffer-overflow /home/chenbing/Code/test/sbo.c:6 in main
Shadow bytes around the buggy address: 5)0x1000066e6f90: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 000x1000066e6fa0: 00 00 00 00 00 00 00 00 00 00 00 00 f1 f1 f1 f10x1000066e6fb0: f1 f1 00 00 00 00 00 00 00 00 00 00 00 00 00 000x1000066e6fc0: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 000x1000066e6fd0: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
=>0x1000066e6fe0: 00 00 00 00[f3]f3 f3 f3 f3 f3 f3 f3 00 00 00 000x1000066e6ff0: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 000x1000066e7000: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 000x1000066e7010: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 000x1000066e7020: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 000x1000066e7030: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
Shadow byte legend (one shadow byte represents 8 application bytes):Addressable: 00Partially addressable: 01 02 03 04 05 06 07 Heap left redzone: faFreed heap region: fdStack left redzone: f1Stack mid redzone: f2Stack right redzone: f3Stack after return: f5Stack use after scope: f8Global redzone: f9Global init order: f6Poisoned by user: f7Container overflow: fcArray cookie: acIntra object redzone: bbASAN internal: feLeft alloca redzone: caRight alloca redzone: cbShadow gap: cc
==2196928==ABORTING这份报告的内容基本与上面几本报告的内容相似，这里不再做过多解释，我们来关注几个不同的地方，
3)说明了栈对象的在函数栈区的偏移范围是[48, 448)(左闭右开)，而代码中通过栈对象访问的位置却是512导致了栈溢出。
还有一个地方需要在注意：报告中提到了一个可能错报的栈溢出场景：如果程序使用一些特殊的堆栈展开机制，swapcontext或者vfork则可能出现误报，关于误报的更多说明可以参阅下面两个issue:
support swapcontext
Replace vfork() with fork()
检测全局缓冲区溢出
// gbo.c
#include <stdio.h>int global_array[100] = {-1};int main(int argc, char **argv) {global_array[101] = 1;return 0;
}上面的代码与栈溢出案例的代码相似，不同仅仅只是的是我们在全局数据段上创建了一个容量为100的数组，接下来添加-fsanitize=address -g参数构建代码并执行：
~/Code/test$ g++ gbo.c -o gbo -fsanitize=address -g
~/Code/test$ ./gbo
=================================================================
==2213117==ERROR: AddressSanitizer: global-buffer-overflow on address 0x558855e231b4 at pc 0x558855e20216 bp 0x7ffd9569d280 sp 0x7ffd9569d270
WRITE of size 4 at 0x558855e231b4 thread T0#0 0x558855e20215 in main /home/chenbing/Code/test/gbo.c:7#1 0x7efd3da4f082 in __libc_start_main ../csu/libc-start.c:308#2 0x558855e2010d in _start (/home/chenbing/Code/test/gbo+0x110d)0x558855e231b4 is located 4 bytes to the right of global variable 'global_array' defined in 'gbo.c:4:5' (0x558855e23020) of size 400
SUMMARY: AddressSanitizer: global-buffer-overflow /home/chenbing/Code/test/gbo.c:7 in main
Shadow bytes around the buggy address:0x0ab18abbc5e0: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 000x0ab18abbc5f0: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 000x0ab18abbc600: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 000x0ab18abbc610: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 000x0ab18abbc620: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
=>0x0ab18abbc630: 00 00 00 00 00 00[f9]f9 f9 f9 f9 f9 00 00 00 000x0ab18abbc640: f9 f9 f9 f9 f9 f9 f9 f9 00 00 00 00 00 00 00 000x0ab18abbc650: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 000x0ab18abbc660: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 000x0ab18abbc670: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 000x0ab18abbc680: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
Shadow byte legend (one shadow byte represents 8 application bytes):Addressable: 00Partially addressable: 01 02 03 04 05 06 07 Heap left redzone: faFreed heap region: fdStack left redzone: f1Stack mid redzone: f2Stack right redzone: f3Stack after return: f5Stack use after scope: f8Global redzone: f9Global init order: f6Poisoned by user: f7Container overflow: fcArray cookie: acIntra object redzone: bbASAN internal: feLeft alloca redzone: caRight alloca redzone: cbShadow gap: cc
==2213117==ABORTING上面的报告基本与栈溢出案例的报告相同，不同的只是错误类型和全局对象代码位置的报告方式，这里不再过多介绍。
好了，关于 ASAN 的使用案例我们就介绍到这里，更多内容可以自行到ASAN的项目中去寻找
ASAN 的基本原理
ASAN的内存检测方法与Valgrind的AddrCheck工具很像，都是使用shadow内存来记录应用程序的每个字节是否可以被安全的访问，在访问内存时都对其映射的shadow内存进行检查。
但是，ASAN使用一个更具效率的shadow内存映射机制和更加紧凑的内存编码来实现，并且除了堆内存外还能检测栈和全局对象中的错误访问，且比AddrCheck快一个数量级。
ASAN由两部分组成：代码插桩模块和运行时库。
- 代码插桩模块会修改代码使其在访问内存时检查每块内存访问状态，称为
shadow 状态，以及在内存两侧创建redzone的内存区域。 - 运行时库则提供一组接口用来替代
malloc和free以及相关的函数，使得在分配堆空间时在其周围创建redzone，并在内存出错时报告错误。
首先，我们先介绍一下什么是shadow 内存 和 redzone。
shadow 内存
在
ASAN中malloc函数返回的内存地址通常至少是8个字节对齐，比如malloc(15)将分配得到2块大小为8字节的内存，在这个场景中，第二块8字节内存的前5个字节是可以访问，但剩下的3个字节是不能访问的。所谓的
shadow 内存就是在应用程序的虚拟地址空间中预留一段地址空间，用来存储映射应用程序访问的内存块中哪些字节可以被使用的信息，这些信息就是shadow 状态。其中每1个字节的shadow 内存，映射到8个字节的应用程序内存，因此，shadow状态可能有3种：0: 表示映射的
8个字节均可以使用k(1<=k<=7): 表示表示映射的8个字节中只有前
k个字节可以使用负值: 表示映射的
8个字节均不可使用，且不同的值表示所映射不同的内存类型（堆、栈、全局对象或已释放内存）ASAN使用带有比例和偏移量的直接映射将应用程序地址转换为其对应的shadow内存地址：shadow_address = (addr >> 3) + offset假设
max - 1是虚拟地址空间中的最大有效地址，则offset的值应选择为在启动时不被占用的从offset到offset+Max/8的区域。
- 在 32 位 linux 系统中，虚拟地址空间为：
0x00000000-0xffffffff，offset = 0x20000000(2^29)。 - 在 64 位系统中，
ofsset = 0x0000100000000000(2^44)。 - 在某些情况下（例如，在 Linux 上使用
-fPIE/-pie编译器标志）可以使用零偏移来进一步简化检测。
以下是 32 位 linux 系统中的地址空间分布
0x1 0000 0000 ---------------| HIGH || MEMORY |0x4000 0000 ---------------| HIGH SHADOW |0x2800 0000 ---------------| BAD REGION |0x2400 0000 ---------------| LOW SHADOW |0x2000 0000 ---------------| LOW MEMORY |0x0000 0000 ---------------虚拟地址空间被划分为高低两部分，每个部分的内存地址映射到相应的
shadow 内存。注意：将shadow 内存中的地址进行映射会得到Bad 区域中的地址，Bad 区域是被页面保护标记为不可访问的地址空间。shadow映射方式可以推导为(addr >> scale) + offset的形式，其中scale是的取值范围是1～7，当scale=N时，shadow 内存占用虚拟地址空间的1/2^N,red-zone的最小大小为2^N字节（保证malloc()的对齐要求）。shadow 内存中的每个字节描述了2^N个内存字节的状态并有2^N + 1个不同的值。redzone
ASAN会在应用程序使用的堆、栈、全局对象的内存周围分配额外内存，这个额外的内存叫做redzone，redzone会被shadow 内存标记为不可使用状态，当应用程序访问redzone内存时说明已经溢出访问了，此时，ASAN检测redzone的shadow 状态后就会报告相应错误。readzone越大，检测内存下溢和上溢的范围越大。具体的分配策略将在下面涉及。
代码插桩
ASAN 会在应用程序访问内存的位置进行插桩，对于访问完整8字节内存的位置，插入以下代码检查内存对应的 shadow 内存，以此判断是否访问异常：
ShadowAddr = (Addr >> 3) + Offset;if (*ShadowAddr != 0)ReportAndCrash(Addr);由于应用程序访问8字节的内存，因此，其映射的shadow 内存的存储值必须是0，表示该8字节内存完全可用，否则，报错。
应用程序对 1、2、或者 4 字节内存的访问要复杂一些，如果访问的内存块对应的shadow 内存的存储值如果不是负数，且不为0，或者将要访问内存块超过了shadow 内存表示的可用范围，意味着本次将访问到不可使用的内存：
ShadowAddr = (Addr >> 3) + Offset;
k = *ShadowAddr;
if (k != 0 && ((Addr & 7) + AccessSize > k))ReportAndCrash(Addr);需要注意的是，ASAN对源代码的插桩时机是在LLVM对代码编译优化之后，也就意味着ASAN只能检测 LLVM 优化后幸存下来的内存访问，例如：被 LLVM 优化掉的对栈对象进行访问的代码将不会被ASAN所识别。
同时，ASAN也不会对 LLVM 生成的内存访问代码进行插桩，例如：寄存器溢出检查等等。
另外，即使错误报告代码ReportAndCrash(Addr)只会被调用一次，但由于会在代码中的许多位置进行插入，因此，错误报告代码也必须相当紧凑。
目前 ASAN 使用了一个简单的函数调用来处理错误报告，当然还有另一个选择是插入一个硬件异常。
运行时库
在应用程序启动时，将映射整个shadow 内存，因此程序的其他部分不能使用它。BAD 区域也是受保护的，应用程序也不能访问。
在 linux 操作系统中，shadow 内存区域不会被占用，因此，映射总是成功的。但在 MacOS 中可能需要禁用地址空间布局（ASLR）。
另外，根据 GOOGLE 工程师介绍，shadow 内存区域的布局也适用于 windows 操作系统。
启用 ASAN 时，源代码中的 malloc 和 free 函数将会被替换为运行时库中的 malloc 和 free 函数。
malloc 分配的内存区域被组织为为一个与对象大小相对应的空闲列表数组。当对应于所请求内存大小的空闲列表为空时，从操作系统（例如，使用mmap）分配带有redzone的内存区域。n个内存块，将分配n+1个redzone：
| redzone-1 | memory-1 | redzone-2 | memory-2 | redzone-3 |free 函数会将整个内存区域置成不可使用并将其放入隔离区，这样该区域就不会马上被 malloc 分配给应用程序。
目前，隔离区是使用一个 FIFO 队列实现的，它在任何时候都拥有一定数量的内存。
默认情况下，malloc 和 free 记录当前调用堆栈，以便提供更多信息的错误报告。 malloc 调用堆栈存储在左侧 redzone 中（redzone 越大，可以存储的帧数越多），而 free 调用堆栈存储在内存区域本身的开头。
到这里你应该已经明白了对于动态分配的内存，ASAN是怎么实现检测的，但你可能会产生疑惑：动态分配是通过 malloc 函数分配redzone来支持错误检测，那栈对象和全局对象这类没有malloc分类内存的对象是怎么实现的呢？其实原理也很简单：
对于全局变量，
redzone在编译时创建，redzone的地址在应用程序启动时传递给运行时库。 运行时库函数会将redzone设置为不可使用并记录地址以供进一步错误报告。对于栈对象，
redzone是在运行时创建和置为不可使用。 目前，使用32字节的redzone。例如以下代码片段：void foo() {char a[10];<function body> }经
ASAN处理后的代码大致如下：void foo() {char rz1[32]char arr[10];char rz2[32-10+32];unsigned * shadow = (unsigned*)(((long)rz1>>8)+Offset);// 将 redzone 设置为不可使用shadow[0] = 0xffffffff; // rz1shadow[1] = 0xffff0200; // arr and rz2shadow[2] = 0xffffffff; // rz2<function body>// 将所有内存设置成可以使用shadow[0] = shadow[1] = shadow[2] = 0; }
总结
ASAN 使用shadow 内存和redzone来提供准确和即时的错误检测。
传统观点认为，shadow 内存和redzone要么通过多级映射方案产生高开销，要么占用大量的程序内存。但，ASAN的使用的shadow映射机制和shadow 状态编码减少了对内存空间占用。
最后，如果你觉得ASAN插桩代码和检测的对你某些的代码来说太慢了，那么可以使用编译器标志来禁用特定函数的，使ASAN跳过对代码中某个函数的插桩和检测， 跳过分析函数的编译器指令是：
__attribute__((no_sanitize_address))Enjoy GreatSQL :)
文章推荐：
面向金融级应用的GreatSQL正式开源 https://mp.weixin.qq.com/s/cI_wPKQJuXItVWpOx_yNTg
Changes in GreatSQL 8.0.25 (2021-8-18) https://mp.weixin.qq.com/s/qcn0lmsMoLtaGO9hbpnhVg
MGR及GreatSQL资源汇总 https://mp.weixin.qq.com/s/qXMct_pOVN5FGoLsXSD0MA
GreatSQL MGR FAQ https://mp.weixin.qq.com/s/J6wkUpGXw3YkyEUJXiZ9xA
在Linux下源码编译安装GreatSQL/MySQL https://mp.weixin.qq.com/s/WZZOWKqSaGSy-mpD2GdNcA
关于 GreatSQL
GreatSQL是由万里数据库维护的MySQL分支，专注于提升MGR可靠性及性能，支持InnoDB并行查询特性，是适用于金融级应用的MySQL分支版本。
Gitee:
https://gitee.com/GreatSQL/GreatSQL
GitHub:
https://github.com/GreatSQL/GreatSQL
Bilibili：
https://space.bilibili.com/1363850082/video
微信&QQ群：
可搜索添加GreatSQL社区助手微信好友，发送验证信息“加群”加入GreatSQL/MGR交流微信群
QQ群：533341697
微信小助手：wanlidbc
本文由博客一文多发平台 OpenWrite 发布！
面向开发的内存调试神器，如何使用ASAN检测内存泄漏、堆栈溢出等问题相关推荐
- ASAN 检测内存错误 debug
ASAN 检测内存错误 debug 编译时添加选项 -fsanitize=address -fno-omit-frame-pointer 或在封装器中处理-c时添加编译选项,在链接阶段添加-lasan ...
- iOS开发笔记 - 界面调试神器Reveal
http://blog.csdn.net/jackfrued/article/details/50934092 Reveal是iOS开发工具中的神器之一,它能够在应用程序运行过程中调试应用程序界面. ...
- 内存调试神器- ASan详解及实例分析
ASan,即Address Sanitizer,是一个适用于c/c++程序的动态内存错误检测器,它由一个编译器检测模块(LLVM pass)和一个替换malloc函数的运行时库组成,在性能及检测内存错 ...
- 使用asan检测内存泄漏、堆栈溢出等问题
一.使用过程 操作过程参考:链接 缘起:程序在移动端崩溃,mac端复现不了,于是在写个崩溃位置函数的调用demo,使用ASAN工具进行排查. 验证过程 1.代码 main.cpp #include & ...
- 使用android studio查看内存,Android Studio Profiler使用心得 检测内存泄露问题
最近在分析app的内存泄露问题研究了下as的profiler功能 这里记录下个人心得 下面是个人心得 1.首先得出结论profiler不详细提供分析c或c++库进行的内存占用 其中包括android ...
- Windows程序调试----第三部分 调试技术----第9章 内存调试
第9章内存调试 能够方便高效地进行动态内存分配,是C++编程语言的重要优点之一:而调试时容易错误使用动态分配的内存也是其最大的缺点之一.Windows程序也可能同样存在与系统资源泄漏或者堆栈相关的内存 ...
- 鸿蒙轻内核的得力助手：带你掌握4种内存调试方法
摘要:内存调测方法旨在辅助定位动态内存相关问题,提供了内存池信息统计.内存泄漏检测和踩内存检测三种调测手段. 本文分享自华为云社区<鸿蒙轻内核-内存调测-内存信息统计>,作者:zhushy ...
- Valgrind ---内存调试，内存泄漏检测以及性能分析的软件开发工具
Valgrind是一款用于内存调试.内存泄漏检测以及性能分析的软件开发工具.Valgrind这个名字取自北欧神话中英灵殿的入口. 一般使用方式 valgrind --leak-check=full ...
- python 如何边改代码边调试_Python 代码调试神器：PySnooper
给大家推荐本我自己写的电子书<PyCharm中文指南>,把各种 PyCharm 的高效的使用技巧用GIF动态图的形式展示出来.有兴趣的可以看它的在线文档: http://pycharm.i ...
- dw上的php代码如何预览在浏览器_13个面向开发人员的JavaScript代码编辑器和IDE
根据知乎的说法,JavaScript(JS)是一种解释性的计算机编程语言.它最初是作为Web浏览器的一部分实现的,这样客户端脚本就可以与用户交互.控制浏览器.异步通信以及更改显示的文档内容. 在本文中 ...
最新文章
- xcode4发布测试-打包（Archive）
- Java中的多线程编程（超详细总结）
- 【区块链】Truffle 部署 编译 测试 智能合约 的 完整实践操作
- Linux - Sysstat [ All-in-One System Performance and Usage Activity Monitoring Tool For Linux]
- 数学建模——智能优化之粒子群模型详解Python代码
- Tensorflow源码解析3 -- TensorFlow核心对象 - Graph
- Mysql的分库分表(基于shardingsphere)
- std::unique_lock与std::lock_guard区别示例
- python含多个附件的邮件_Python发送带有多个图像附件的电子邮件
- java代码复数包括虚部和实部,Java中编写Applet程序验证复数类(在问题补充中)实现接收用户输入的复数的实部和虚部,计算复数与复数,复数与实数的加减,乘除操作...
- cypress离线安装_【拆一个高端货】 美国NI公司 GPIB-USB转接卡 长标题
- 计算机顶级会议Rankings 英文投稿的一点经验
- 51单片机定时器 TMOD、TCON设置_codestorm_新浪博客
- 7-1 sdut-Collection(Map)-1 读中国载人航天史，汇航天员数量，向航天员致敬
- 在虚拟机上跑vxworks的总结
- 回溯法——回溯法的算法思想
- java获取前五分钟时间,java计算下一个整5分钟时间点
- Android:这是一份非常详细的MVP+Rxjava2.0+Retrofit2.0相结合举例RecyclerView的实战篇章
- 最新Git 版本在Windows系统中的安装详解过程
- linux安装 宋体