android 性能分析工具(04)Asan 内存检测工具

embedded/2024/11/22 18:58:37/

1 Asan工具简介

1.1 Asan工具历史背景

AddressSanitizer(ASan)最初由Google开发,并作为LLVM项目的一部分。ASan的设计目的是帮助开发者检测并修复内存错误,如堆栈和全局缓冲区溢出、使用已释放的内存等,这些问题可能会影响程序的正确性和安全性。ASan通过在编译时插入额外的代码来检查每次内存访问,并在运行时监控这些访问,从而发现错误。

ASan的实现基于"shadow memory"技术,它为程序的内存分配创建了一个影子区域,用于跟踪内存的使用情况。当程序试图访问未初始化或已释放的内存时,ASan能够检测到这些非法访问并报告错误。这项技术使得ASan能够在不牺牲太多性能的情况下,有效地发现难以察觉的内存错误。

随着时间的推移,ASan已经成为GCC和Clang编译器的标准组成部分,广泛用于提高软件质量,特别是在内存安全性方面。此外,ASan的集成和易用性也得到了不断改进,例如在Visual Studio中,从2019版本16.9开始,MSVC编译器和IDE支持AddressSanitizer,并且提供了与IDE的集成,使得开发者可以更容易地在Windows平台上使用ASan。

1.2 Asan工具软件定位

AddressSanitizer(ASan)主要用于C和C++程序。它通过在编译时插入额外的检查代码,运行时监控程序的内存访问,来定位常见的内存错误,包括但不限于:

  • 堆缓冲区溢出:检测堆上分配的内存是否被越界访问。
  • 栈缓冲区溢出:检测栈上分配的局部变量是否超出其声明的范围。
  • 全局变量溢出:检测全局或静态变量的内存是否被越界访问。
  • 使用已释放的内存:检测程序是否尝试访问已经被释放的内存。
  • 内存泄漏:实验性地检测内存泄漏问题。
  • 初始化顺序问题:检测由于不正确的初始化顺序导致的问题。
  • 内存越界访问:检测对内存的读写操作是否超出了其分配的范围。
  • 函数返回局部变量:检测函数返回局部变量的引用,这通常会导致悬挂指针问题。

Asan的工作原理是在编译时对代码进行插桩,即在内存访问点周围添加额外的检查代码。运行时,Asan的运行时库会接管标准的内存管理函数,如mallocfree,以跟踪内存分配和释放的状态。当检测到内存错误时,Asan会立即报告错误并提供详细的错误信息,包括错误类型、发生错误的代码位置、调用栈信息等。

Asan的使用可以显著提高软件的内存安全性,帮助开发者在开发阶段就发现并修复潜在的内存问题。然而,由于ASan会引入额外的性能开销,它通常用于调试和测试阶段,而不推荐在生产环境中启用。

总的来说,ASan是一个功能强大且广泛使用的内存错误检测工具,能够有效地帮助开发者定位和解决C/C++程序中的内存问题,提高软件的稳定性和安全性。

接下来我们看看如何使用Asan工具。

2 Asan工具使用

2.1 如何使用Asan工具

使用ASan,你需要使用支持ASan的编译器。比如Clang或GCC,并开启ASan相关的编译选项。

如果使用Clang编译器,在终端执行以下命令:

$clang -fsanitize=address -g hellp.c -o hello

如果使用GCC编译器,在终端执行以下命令:

$gcc -fsanitize=address -g hello.c -o hello

在上述命令中,-fsanitize=address是ASan的编译选项,用于开启ASan。但在大型工程(使用makefile方式进行编译)中我们一般通过环境变量的方式加入ASan编译选项,然后编译额时候需要加上环境变量,一般是CFLAGS或者CXXFLAGS

2.2 -fsanitize选项常见的sanitizer解读

以下是一些常见的sanitizer选项及其含义:

  • -fsanitize=address:这个选项启用了地址sanitizer,它是一个运行时检测工具,用于检测C/C++程序中的内存错误,如缓冲区溢出、使用后释放(use-after-free)错误等。地址sanitizer会在程序运行时监控内存操作,当检测到错误时,它会提供详细的错误报告,包括错误类型、发生位置和堆栈跟踪信息。
  • -fsanitize-recover=address:这个选项与-fsanitize=address一起使用,它告诉地址sanitizer在检测到内存错误时,尝试恢复程序的执行,而不是立即终止程序。这可以使得程序在检测到某些内存错误后继续运行,这对于调试和分析程序的行为非常有用。
  • -fsanitize=memory:MemorySanitizer(MSan)用于检测未初始化的内存读取。它通过为每个值关联一个“起源”来工作,如果一个值被读取时其起源是未知的,MSAN就会报告一个错误。
  • -fsanitize=undefined:UndefinedBehaviorSanitizer(UBSan)用于检测未定义行为,例如整数溢出、空指针解引用、除以零等问题。
  • -fsanitize=thread:ThreadSanitizer(TSan)用于检测多线程程序中的数据竞争和死锁问题。
  • -fsanitize=leak:这个选项已经被弃用,取而代之的是使用-fsanitize=address,它现在包含了内存泄漏检测功能。
  • -fsanitize=coverage:CoverageSanitizer(CovSan)用于生成代码覆盖率报告,检测程序中哪些部分被执行过。
  • -fsanitize=kernel-address:Kernel Address Sanitizer(KASan)是AddressSanitizer的一个变种,专门用于检测Linux内核中的内存错误。
  • -fsanitize=dataflow:这个选项允许开发者定义自己的数据流问题,并在运行时检测它们。
  • -fsanitize=cfi:Control Flow Integrity(CFI)Sanitizer用于检测控制流相关的安全问题,比如虚拟函数表破坏攻击。
  • -fsanitize=safe-stack:SafeStack通过将安全关键的栈数据移动到堆上来保护程序,从而防止栈溢出攻击。
  • -fsanitize=hwaddress:Hardware Address Sanitizer(HWASAN)用于检测硬件级别的内存错误,比如加载无效的地址。

这些sanitizer工具是查找隐藏bug的利器,它们可以帮助开发者在开发和测试阶段发现和修复潜在的错误。需要注意的是,这些工具会增加程序的运行时间和内存开销,因此主要用于调试和测试阶段,不推荐在生产环境中启用。

3 asan部分实战解读

这里给出一些asan的具体使用方法,当然,限于常用的一些场景。其他场景参考即可。分析问题和解决问题的思路是类似的。

3.1 堆缓冲区溢出(Heap Buffer Overflow)

案例描述:检测对堆分配的缓冲区边界以外的内存写入操作。

参考代码如下:

#include <stdio.h>
#include <stdlib.h>int main() {char *buffer = (char *)malloc(5 * sizeof(char));if (buffer == NULL) {fprintf(stderr, "Memory allocation failed\n");return 1;}sprintf(buffer, "Hello, World!");printf("Buffer contents: %s\n", buffer);free(buffer);return 0;
}

使用以下命令编译程序,并启用AddressSanitizer:

$gcc -fsanitize=address -g -o heap_overflow heap_overflow.c

然后使用gdb运行编译出的程序:

$gdb ./heap_overflow

执行后 得到如下调试信息:

[Thread debugging using libthread_db enabled]
Using host libthread_db library "/lib/x86_64-linux-gnu/libthread_db.so.1".
=================================================================
==1346454==ERROR: AddressSanitizer: heap-buffer-overflow on address 0x602000000015 at pc 0x7ffff745f04f bp 0x7fffffffdaf0 sp 0x7fffffffd280
WRITE of size 14 at 0x602000000015 thread T0#0 0x7ffff745f04e in __interceptor_vsprintf ../../../../src/libsanitizer/sanitizer_common/sanitizer_common_interceptors.inc:1687#1 0x7ffff745f27e in __interceptor_sprintf ../../../../src/libsanitizer/sanitizer_common/sanitizer_common_interceptors.inc:1730#2 0x5555555552f2 in main /media/wangdaosheng/data/backup/tmp/test2/heap_overflow.c:14#3 0x7ffff7029d8f in __libc_start_call_main ../sysdeps/nptl/libc_start_call_main.h:58#4 0x7ffff7029e3f in __libc_start_main_impl ../csu/libc-start.c:392#5 0x5555555551a4 in _start (/media/wangdaosheng/data/backup/tmp/test2/heap_overflow+0x11a4)0x602000000015 is located 0 bytes to the right of 5-byte region [0x602000000010,0x602000000015)
allocated by thread T0 here:#0 0x7ffff74b4887 in __interceptor_malloc ../../../../src/libsanitizer/asan/asan_malloc_linux.cpp:145#1 0x55555555527e in main /media/wangdaosheng/data/backup/tmp/test2/heap_overflow.c:6#2 0x7ffff7029d8f in __libc_start_call_main ../sysdeps/nptl/libc_start_call_main.h:58SUMMARY: AddressSanitizer: heap-buffer-overflow ../../../../src/libsanitizer/sanitizer_common/sanitizer_common_interceptors.inc:1687 in __interceptor_vsprintf
Shadow bytes around the buggy address: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[05]fa 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
==1346454==ABORTING
[Inferior 1 (process 1346454) exited with code 01]

这个错误信息是由 AddressSanitizer(ASan)提供的。根据提供的信息,我们可以分析出以下关键信息:

  1. 错误类型AddressSanitizer: heap-buffer-overflow 表示发生了堆缓冲区溢出。

  2. 错误位置:错误发生在地址 0x602000000015,这是一个堆内存地址。

  3. 出错指令WRITE of size 14 at 0x602000000015 表示在地址 0x602000000015 处尝试写入 14 个字节的数据。

  4. 程序计数器(PC)和基指针(BP)pc 0x7ffff745f04fbp 0x7fffffffdaf0 提供了出错时的程序计数器和基指针的值,这对于调试器来说是有用的。

  5. 出错函数:错误发生在 __interceptor_vsprintf 函数中,这是 ASan 对 vsprintf 函数的拦截实现。

  6. 调用栈:调用栈显示了错误发生时的函数调用顺序。在这里,我们看到 sprintf 函数(第2行)被 main 函数(第3行)调用,这是错误发生的源头。

  7. 内存分配位置:出错的内存是在 main 函数的第6行分配的,由 __interceptor_malloc 拦截。

  8. Shadow Bytes:Shadow Bytes 是 ASan 使用的一块内存区域,用于跟踪实际内存的状态。这里的 Shadow Bytes 显示了出错地址附近的内存状态。

  9. 错误摘要SUMMARY: AddressSanitizer: heap-buffer-overflow 再次总结了错误类型。

  10. 程序退出==1346454==ABORTING 表示由于这个严重错误,程序被ASan中止执行。

在这个案例中,错误是由于 sprintf 写入的数据超出了分配的5字节大小的缓冲区,导致堆缓冲区溢出。

3.2 栈缓冲区溢出(Stack Buffer Overflow)

案例描述:检测对栈分配的缓冲区边界以外的内存写入操作。

参考代码如下:

#include <stdio.h>
#include <string.h>int main() {char buffer[4];strcpy(buffer, "Hello");printf("Buffer contents: %s\n", buffer);return 0;
}

使用以下命令编译程序,并启用AddressSanitizer:

$gcc -fsanitize=address -g -o stack_overflow stack_overflow.c

然后使用gdb运行编译出的程序:

$gdb ./stack_overflow

执行后 得到如下调试信息:

[Thread debugging using libthread_db enabled]
Using host libthread_db library "/lib/x86_64-linux-gnu/libthread_db.so.1".
=================================================================
==1680994==ERROR: AddressSanitizer: stack-buffer-overflow on address 0x7fffffffdba4 at pc 0x7ffff743a2c3 bp 0x7fffffffdb70 sp 0x7fffffffd318
WRITE of size 6 at 0x7fffffffdba4 thread T0#0 0x7ffff743a2c2 in __interceptor_memcpy ../../../../src/libsanitizer/sanitizer_common/sanitizer_common_interceptors.inc:827#1 0x5555555552ca in main /media/wangdaosheng/data/backup/tmp/test2/stack_overflow.c:6#2 0x7ffff7029d8f in __libc_start_call_main ../sysdeps/nptl/libc_start_call_main.h:58#3 0x7ffff7029e3f in __libc_start_main_impl ../csu/libc-start.c:392#4 0x555555555164 in _start (/media/wangdaosheng/data/backup/tmp/test2/stack_overflow+0x1164)Address 0x7fffffffdba4 is located in stack of thread T0 at offset 36 in frame#0 0x555555555238 in main /media/wangdaosheng/data/backup/tmp/test2/stack_overflow.c:4This frame has 1 object(s):[32, 36) 'buffer' (line 5) <== Memory access at offset 36 overflows this variable
HINT: this may be a false positive if your program uses some custom stack unwind mechanism, swapcontext or vfork(longjmp and C++ exceptions *are* supported)
SUMMARY: AddressSanitizer: stack-buffer-overflow ../../../../src/libsanitizer/sanitizer_common/sanitizer_common_interceptors.inc:827 in __interceptor_memcpy
Shadow bytes around the buggy address:0x10007fff7b20: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 000x10007fff7b30: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 000x10007fff7b40: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 000x10007fff7b50: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 000x10007fff7b60: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
=>0x10007fff7b70: f1 f1 f1 f1[04]f3 f3 f3 00 00 00 00 00 00 00 000x10007fff7b80: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 000x10007fff7b90: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 000x10007fff7ba0: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 000x10007fff7bb0: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 000x10007fff7bc0: 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
==1680994==ABORTING
[Inferior 1 (process 1680994) exited with code 01]

这个错误信息是由 AddressSanitizer(ASan)提供的。根据提供的信息,我们可以分析出以下关键信息:

  1. 错误类型AddressSanitizer: stack-buffer-overflow 表示发生了栈缓冲区溢出。
  2. 错误位置:错误发生在地址 0x7fffffffdba4,这是一个栈内存地址。
  3. 出错指令WRITE of size 6 at 0x7fffffffdba4 表示在地址 0x7fffffffdba4 处尝试写入 6 个字节的数据。
  4. 程序计数器(PC)和基指针(BP)以及栈指针(SP)pc 0x7ffff743a2c3, bp 0x7fffffffdb70, sp 0x7fffffffd318 提供了出错时的程序计数器、基指针和栈指针的值,这对于调试器来说是有用的。
  5. 出错函数:错误发生在 __interceptor_memcpy 函数中,这是 ASan 对 memcpy 函数的拦截实现。
  6. 调用栈:调用栈显示了错误发生时的函数调用顺序。在这里,我们看到 memcpy 函数(第1行)被 main 函数(第2行)调用,这是错误发生的源头。
  7. 内存分配位置:出错的内存是在 main 函数的第4行分配的,由栈帧信息指出。
  8. Shadow Bytes:Shadow Bytes 是 ASan 使用的一块内存区域,用于跟踪实际内存的状态。这里的 Shadow Bytes 显示了出错地址附近的内存状态。
  9. 错误摘要SUMMARY: AddressSanitizer: stack-buffer-overflow 再次总结了错误类型。
  10. 程序退出==1680994==ABORTING 表示由于这个严重错误,程序被ASan中止执行。

在这个案例中,错误是由于 memcpy 写入的数据超出了分配的缓冲区大小,导致栈缓冲区溢出。

3.3 全局缓冲区溢出(Global Buffer Overflow)

案例描述:检测对全局变量边界以外的内存写入操作。

参考代码如下:

#include <stdio.h>
#include <string.h>char globalBuffer[5];int main() {strcpy(globalBuffer, "Hello, World!");printf("Global Buffer contents: %s\n", globalBuffer);return 0;
}

使用以下命令编译程序,并启用AddressSanitizer:

$gcc -fsanitize=address -g -o global_overflow global_overflow.c

然后运行编译出的程序:

$gdb ./global_overflow

执行后 得到如下调试信息:

[Thread debugging using libthread_db enabled]
Using host libthread_db library "/lib/x86_64-linux-gnu/libthread_db.so.1".
=================================================================
==1681772==ERROR: AddressSanitizer: global-buffer-overflow on address 0x555555558125 at pc 0x7ffff743a2c3 bp 0x7fffffffdbf0 sp 0x7fffffffd398
WRITE of size 14 at 0x555555558125 thread T0#0 0x7ffff743a2c2 in __interceptor_memcpy ../../../../src/libsanitizer/sanitizer_common/sanitizer_common_interceptors.inc:827#1 0x55555555520e in main /media/wangdaosheng/data/backup/tmp/test2/global_overflow.c:7#2 0x7ffff7029d8f in __libc_start_call_main ../sysdeps/nptl/libc_start_call_main.h:58#3 0x7ffff7029e3f in __libc_start_main_impl ../csu/libc-start.c:392#4 0x555555555124 in _start (/media/wangdaosheng/data/backup/tmp/test2/global_overflow+0x1124)0x555555558125 is located 0 bytes to the right of global variable 'globalBuffer' defined in 'global_overflow.c:4:6' (0x555555558120) of size 5
SUMMARY: AddressSanitizer: global-buffer-overflow ../../../../src/libsanitizer/sanitizer_common/sanitizer_common_interceptors.inc:827 in __interceptor_memcpy
Shadow bytes around the buggy address:0x0aab2aaa2fd0: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 000x0aab2aaa2fe0: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 000x0aab2aaa2ff0: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 000x0aab2aaa3000: 00 00 00 00 00 00 00 00 f9 f9 f9 f9 f9 f9 f9 f90x0aab2aaa3010: f9 f9 f9 f9 f9 f9 f9 f9 f9 f9 f9 f9 f9 f9 f9 f9
=>0x0aab2aaa3020: 00 00 00 00[05]f9 f9 f9 f9 f9 f9 f9 00 00 00 000x0aab2aaa3030: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 000x0aab2aaa3040: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 000x0aab2aaa3050: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 000x0aab2aaa3060: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 000x0aab2aaa3070: 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
==1681772==ABORTING
[Inferior 1 (process 1681772) exited with code 01]

这个错误信息是由 AddressSanitizer(ASan)提供的。根据提供的信息,我们可以分析出以下关键信息:

  1. 错误类型AddressSanitizer: global-buffer-overflow 表示发生了全局缓冲区溢出。
  2. 错误位置:错误发生在地址 0x555555558125,这是一个全局变量的地址。
  3. 出错指令WRITE of size 14 at 0x555555558125 表示在地址 0x555555558125 处尝试写入 14 个字节的数据。
  4. 程序计数器(PC)、基指针(BP)和栈指针(SP)pc 0x7ffff743a2c3, bp 0x7fffffffdbf0, sp 0x7fffffffd398 提供了出错时的程序计数器、基指针和栈指针的值,这对于调试器来说是有用的。
  5. 出错函数:错误发生在 __interceptor_memcpy 函数中,这是 ASan 对 memcpy 函数的拦截实现。
  6. 调用栈:调用栈显示了错误发生时的函数调用顺序。在这里,我们看到 memcpy 函数(第1行)被 main 函数(第2行)调用,这是错误发生的源头。
  7. 内存分配位置:出错的内存是全局变量 globalBuffer,定义在 global_overlap.c:4:6,大小为 5 字节。
  8. Shadow Bytes:Shadow Bytes 是 ASan 使用的一块内存区域,用于跟踪实际内存的状态。这里的 Shadow Bytes 显示了出错地址附近的内存状态。
  9. 错误摘要SUMMARY: AddressSanitizer: global-buffer-overflow 再次总结了错误类型。
  10. 程序退出==1681772==ABORTING 表示由于这个严重错误,程序被ASan中止执行。

在这个案例中,错误是由于 memcpy 写入的数据超出了全局变量 globalBuffer 分配的大小,导致全局缓冲区溢出。

3.4 使用后释放(Use After Free)

案例描述:检测已经释放的内存被再次访问的情况。

参考代码如下:

#include <stdio.h>
#include <stdlib.h>int main() {int *ptr = (int *)malloc(sizeof(int));if (ptr == NULL) {fprintf(stderr, "Memory allocation failed\n");return 1;}*ptr = 42;printf("Value at ptr: %d\n", *ptr);free(ptr);printf("Value at ptr after free: %d\n", *ptr);return 0;
}

使用以下命令编译程序,并启用AddressSanitizer:

$gcc -fsanitize=address -g -o use_after_free use_after_free.c

然后运行编译出的程序:

$gdb ./use_after_free

执行后 得到如下调试信息:

[Thread debugging using libthread_db enabled]
Using host libthread_db library "/lib/x86_64-linux-gnu/libthread_db.so.1".
Value at ptr: 42
=================================================================
==1682910==ERROR: AddressSanitizer: heap-use-after-free on address 0x602000000010 at pc 0x55555555539b bp 0x7fffffffd7a0 sp 0x7fffffffd790
READ of size 4 at 0x602000000010 thread T0#0 0x55555555539a in main /media/wangdaosheng/data/backup/tmp/test2/use_after_free.c:14#1 0x7ffff7029d8f in __libc_start_call_main ../sysdeps/nptl/libc_start_call_main.h:58#2 0x7ffff7029e3f in __libc_start_main_impl ../csu/libc-start.c:392#3 0x5555555551c4 in _start (/media/wangdaosheng/data/backup/tmp/test2/use_after_free+0x11c4)0x602000000010 is located 0 bytes inside of 4-byte region [0x602000000010,0x602000000014)
freed by thread T0 here:#0 0x7ffff74b4537 in __interceptor_free ../../../../src/libsanitizer/asan/asan_malloc_linux.cpp:127#1 0x555555555363 in main /media/wangdaosheng/data/backup/tmp/test2/use_after_free.c:13#2 0x7ffff7029d8f in __libc_start_call_main ../sysdeps/nptl/libc_start_call_main.h:58previously allocated by thread T0 here:#0 0x7ffff74b4887 in __interceptor_malloc ../../../../src/libsanitizer/asan/asan_malloc_linux.cpp:145#1 0x55555555529e in main /media/wangdaosheng/data/backup/tmp/test2/use_after_free.c:5#2 0x7ffff7029d8f in __libc_start_call_main ../sysdeps/nptl/libc_start_call_main.h:58SUMMARY: AddressSanitizer: heap-use-after-free /media/wangdaosheng/data/backup/tmp/test2/use_after_free.c:14 in main
Shadow bytes around the buggy address: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[fd]fa 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
==1682910==ABORTING
[Inferior 1 (process 1682910) exited with code 01]

这个错误信息是由 AddressSanitizer(ASan)提供的。根据提供的信息,我们可以分析出以下关键信息:

  1. 错误类型AddressSanitizer: heap-use-after-free 表示发生了堆使用后释放的错误。
  2. 错误位置:错误发生在地址 0x602000000010,这是一个堆内存地址。
  3. 出错指令READ of size 4 at 0x602000000010 表示在地址 0x602000000010 处尝试读取 4 个字节的数据。
  4. 程序计数器(PC)、基指针(BP)和栈指针(SP)pc 0x55555555539b, bp 0x7fffffffd7a0, sp 0x7fffffffd790 提供了出错时的程序计数器、基指针和栈指针的值,这对于调试器来说是有用的。
  5. 出错函数:错误发生在 main 函数的第14行。
  6. 内存释放位置:出错的内存是在 main 函数的第13行被释放的。
  7. 内存分配位置:出错的内存是在 main 函数的第5行被分配的。
  8. Shadow Bytes:Shadow Bytes 是 ASan 使用的一块内存区域,用于跟踪实际内存的状态。这里的 Shadow Bytes 显示了出错地址附近的内存状态,其中 fd 表示已释放的堆内存区域。
  9. 错误摘要SUMMARY: AddressSanitizer: heap-use-after-free 再次总结了错误类型。
  10. 程序退出==1682910==ABORTING 表示由于这个严重错误,程序被ASan中止执行。

3.5 多线程数据竞争(Data Race)

案例描述:检测多线程程序中不同线程对同一数据的竞态访问。

参考代码如下:

#include <stdio.h>
#include <pthread.h>int global_var = 0;void* increment(void* arg) {int i;for (i = 0; i < 100; ++i) {global_var++; // 此处存在数据竞争}return NULL;
}int main() {pthread_t thread1, thread2;pthread_create(&thread1, NULL, increment, NULL);pthread_create(&thread2, NULL, increment, NULL);pthread_join(thread1, NULL);pthread_join(thread2, NULL);printf("Result: %d\n", global_var);return 0;
}

使用以下命令编译程序,并启用AddressSanitizer:

$gcc -fsanitize=thread -g -o data_race data_race.c -lpthread

然后运行编译出的程序:

$gdb ./data_race

执行后 得到如下调试信息:

[Thread debugging using libthread_db enabled]
Using host libthread_db library "/lib/x86_64-linux-gnu/libthread_db.so.1".
[New Thread 0x7ffff51ff640 (LWP 2156986)]
[New Thread 0x7ffff49fe640 (LWP 2156987)]
[Thread 0x7ffff49fe640 (LWP 2156987) exited]
[New Thread 0x7ffff41fd640 (LWP 2156988)]
==================
WARNING: ThreadSanitizer: data race (pid=2156978)Read of size 4 at 0x555555558014 by thread T2:#0 increment /media/wangdaosheng/data/backup/tmp/test2/data_race.c:9 (data_race+0x129d)Previous write of size 4 at 0x555555558014 by thread T1:#0 increment /media/wangdaosheng/data/backup/tmp/test2/data_race.c:9 (data_race+0x12b5)Location is global 'global_var' of size 4 at 0x555555558014 (data_race+0x000000004014)Thread T2 (tid=2156988, running) created by main thread at:#0 pthread_create ../../../../src/libsanitizer/tsan/tsan_interceptors_posix.cpp:969 (libtsan.so.0+0x605b8)#1 main /media/wangdaosheng/data/backup/tmp/test2/data_race.c:18 (data_race+0x133a)Thread T1 (tid=2156987, finished) created by main thread at:#0 pthread_create ../../../../src/libsanitizer/tsan/tsan_interceptors_posix.cpp:969 (libtsan.so.0+0x605b8)#1 main /media/wangdaosheng/data/backup/tmp/test2/data_race.c:17 (data_race+0x131d)SUMMARY: ThreadSanitizer: data race /media/wangdaosheng/data/backup/tmp/test2/data_race.c:9 in increment
==================
Result: 200
ThreadSanitizer: reported 1 warnings
[Thread 0x7ffff41fd640 (LWP 2156988) exited]
[Thread 0x7ffff51ff640 (LWP 2156986) exited]
[Inferior 1 (process 2156978) exited with code 0102]

这个错误信息是由 ThreadSanitizer(TSan)提供的,它帮助检测多线程程序中的数据竞争问题。根据提供的信息,我们可以分析出以下关键点:

  1. 错误类型WARNING: ThreadSanitizer: data race 表示检测到数据竞争。
  2. 竞争位置:数据竞争发生在地址 0x555555558014,这是全局变量 global_var 的地址。
  3. 出错指令Read of size 4 at 0x555555558014 by thread T2Previous write of size 4 at 0x555555558014 by thread T1 表示线程 T2 读取了 global_var,而线程 T1 在之前写了 global_var
  4. 竞争变量:竞争的变量是全局变量 global_var,大小为 4 字节。
  5. 线程信息:线程 T2(tid=2156988)和线程 T1(tid=2156987)都参与了这次数据竞争。
  6. 线程创建:两个线程都是由主线程(main thread)创建的,创建位置在 main 函数中。
  7. 错误摘要SUMMARY: ThreadSanitizer: data race 再次总结了错误类型。
  8. 程序退出[Inferior 1 (process 2156978) exited with code 0102] 表示程序由于TSan报告的错误而退出。

在这个案例中,错误是由于两个线程同时访问和修改全局变量 global_var 导致的。


http://www.ppmy.cn/embedded/139679.html

相关文章

论文 | Learning to Transfer Prompts for Text Generation

1. 总结与提问 论文摘要总结&#xff1a; 论文提出了一种创新的PTG&#xff08;Prompt Transfer Generation&#xff09;方法&#xff0c;旨在通过迁移提示的方式解决传统预训练语言模型&#xff08;PLM&#xff09;在数据稀缺情况下微调的问题。通过将一组已在源任务中训练好…

ts: 定义一个对象接收后端返回对象数据,但是报错了有红色的红线为什么

问&#xff1a; const backendProgressData ref<object>&#xff08;{}&#xff09; 这是我的代码&#xff0c;但是当我进行使用的时候&#xff1a; backendProgressData.value xxxx接口返回数据progressData:{percentage:123,text:"文字"} 在template中{{…

移动应用开发:Android Studio实现简易注册页(数据存放以SharedPreferences形式)

文章目录 简介步骤 1&#xff1a;创建新活动步骤 2&#xff1a;设计UI布局步骤 3&#xff1a;编写活动代码注意事项 步骤 4&#xff1a;运行应用程序步骤 5&#xff1a;查看存放数据注意事项 简介 使用Android Studio编写的简单Android 注册应用程序&#xff0c;该应用程序包含…

云原生学习

1、云原生学习 文章目录 1、云原生学习1. 介绍2. Docker容器化 1. 介绍 什么是云原生&#xff1f;原生指使用JAVA等语言编写的项目&#xff0c;云是指将项目部署到云服务器上云平台&#xff1a;公有云、私有云 本地平台是指直接部署在自己计算机&#xff0c;而开发的应用一定要…

小试牛刀-Anchor安装和基础测试

目录 一、编写目的 二、安装步骤 2.1 安装Rust 设置rustup镜像 安装Rust 2.2 安装node.js 2.3 安装Solana-CLI 2.4 安装Anchor CLI 三、Program测试 四、可能出现的问题 Welcome to Code Blocks blog 本篇文章主要介绍了 [Anchor安装和基础测试] 博主广交技术好友&…

pnpm : 无法加载文件 D:\Tool\environment\NodeAndNvm\node\pnpm.ps1,因为在此系统上禁止运行脚本。

问题 在终端(cmd)输入 pnpm -v&#xff0c;报错如下 pnpm : 无法加载文件 D:\Tool\environment\NodeAndNvm\node\pnpm.ps1&#xff0c;因为在此系统上禁止运行脚本。解决 1. 在终端输入get-ExecutionPolicy(查看执行策略/权限) 输出如下&#xff1a; # (受限的) Restricte…

【PGCCC】Postgresql 缓存替换算法

前言 postgresql 使用缓存来作为与磁盘读写的中间层&#xff0c;但是缓存的大小是有限的&#xff0c;当缓存不够用时需要剔除一些不常用的。但是如何高效的选出那些需要剔除的缓存呢&#xff0c;postgresql 针对不同的应用场景&#xff0c;提供了简单高效的不同算法。 替换算…

pcap_set_buffer_size()函数

功能简介 pcap_set_buffer_size()函数主要用于设置数据包捕获的内核缓冲区大小。这个缓冲区是操作系统内核用于临时存储捕获到的数据包的区域。通过调整缓冲区大小&#xff0c;可以在一定程度上优化数据包捕获的性能&#xff0c;特别是在高流量网络环境或者需要长时间捕获数据包…