比较2个GDB-Core Dumps

Question

我遇到了严重的问题，堆栈损坏。为了能够设置一个数据断点并找到问题的根源，我想用gdb做两个核心转储，然后比较它们。第一张是在我认为堆和栈仍然正常的时候，第二张是在我的程序崩溃前不久。

我怎样才能比较这两个转储？

关于我的项目信息。

• 使用gcc 5. x
• 遗留的、支持RT的第三方程序的插件。该项目没有可用的源代码（对我来说）。
• 传统项目是C，我的Plugin是C++。

其他的事情我都试过了。

• 使用地址清除器 -> 不能工作，因为遗留程序不会用它们启动。
• 使用未定义的行为清除器->也一样。
• 弄清楚什么内存会被破坏数据断点->没有成功，因为被破坏的内存不属于我的代码。
• 运行Valgrind -> 我的代码周围没有错误。

谢谢您的帮助

Answer 1

与你的根本动机无关，我想说说你的问题。你问如何识别两个核心转储的区别。这将是漫长的，但希望能给你答案。

核心转储是由ELF文件表示的，它包含了元数据和一组特定的内存区域（在Linux上，这可以通过控制 /proc/[pid]/coredump_filter)，在创建转储时被映射到给定进程中。

比较转储的显而易见的方法是比较一个十六进制表示法。

$ diff -u <(hexdump -C dump1) <(hexdump -C dump2)
--- /dev/fd/63  2020-05-17 10:01:40.370524170 +0000
+++ /dev/fd/62  2020-05-17 10:01:40.370524170 +0000
@@ -90,8 +90,9 @@
 000005e0  00 00 00 00 00 00 00 00  00 00 00 00 80 1f 00 00  |................|
 000005f0  00 00 00 00 00 00 00 00  00 00 00 00 00 00 00 00  |................|

但结果很少有用，因为你缺少了上下文。更具体地说，没有直接的方法从文件中的值变化偏移到进程虚拟内存地址空间对应的偏移。

所以，如果需要的话，多了解一些背景。最佳的输出是一个包括前后值的虚拟内存地址列表。

在上这个问题之前，我们需要一个与你大致相似的测试场景。下面的应用程序包括一个使用后的免费内存问题，一开始并不会导致分段故障（具有相同大小的新分配会隐藏这个问题）。这里的想法是使用gdb创建一个核心转储(generate)在每个阶段中，根据代码触发的断点。

1. 正确的状态
2. dump2：状态不正确，没有分段故障。
3. dump3: 分段故障

的代码。

#include <stdlib.h>
#include <unistd.h>
#include <signal.h>
#include <stdio.h>

int **g_state;

int main()
{
  int value = 1;
  g_state = malloc(sizeof(int*));
  *g_state = &value;
  if (g_state && *g_state) {
    printf("state: %d\n", **g_state);
  }
  printf("no corruption\n");
  raise(SIGTRAP);
  free(g_state);
  char **unrelated = malloc(sizeof(int*));
  *unrelated = "val";
  if (g_state && *g_state) {
    printf("state: %d\n", **g_state);
  }
  printf("use-after-free hidden by new allocation (invalid value)\n");
  raise(SIGTRAP);
  printf("use-after-free (segfault)\n");
  free(unrelated);
  int *unrelated2 = malloc(sizeof(intptr_t));
  *unrelated2 = 1;
  if (g_state && *g_state) {
    printf("state: %d\n", **g_state);
  }
  return 0;
}

现在，转储可以生成了。

Starting program: test 
state: 1
no corruption

Program received signal SIGTRAP, Trace/breakpoint trap.
0x00007ffff7a488df in raise () from /lib64/libc.so.6
(gdb) generate dump1
Saved corefile dump1
(gdb) cont
Continuing.
state: 7102838
use-after-free hidden by new allocation (invalid value)

Program received signal SIGTRAP, Trace/breakpoint trap.
0x00007ffff7a488df in raise () from /lib64/libc.so.6
(gdb) generate dump2
Saved corefile dump2
(gdb) cont
Continuing.
use-after-free (segfault)

Program received signal SIGSEGV, Segmentation fault.
main () at test.c:31
31          printf("state: %d\n", **g_state);
(gdb) generate dump3
Saved corefile dump3

快速的手动检查显示了相关的差异。

# dump1
(gdb) print g_state
$1 = (int **) 0x602260
(gdb) print *g_state
$2 = (int *) 0x7fffffffe2bc
# dump2
(gdb) print g_state
$1 = (int **) 0x602260
(gdb) print *g_state
$2 = (int *) 0x4008c1
# dump3
$2 = (int **) 0x602260
(gdb) print *g_state
$3 = (int *) 0x1

根据这些输出，我们可以清楚地看到 *g_state 变了，但在 dump2. 在 dump3，指针变得无效。当然，我们希望能自动进行这种比较。

由于知道核心转储是一个ELF文件，我们可以简单地解析它并自己生成一个diff。我们要做的是

1. 打开一个转储
2. 识别 PROGBITS 垃圾场
3. 记住数据和地址信息
4. 重复第二个转储的过程
5. 比较两个数据集并打印出差异

基于 elf.h，解析ELF文件相对容易。我创建了一个比较两个转储的示例实现，并打印出一个类似于比较两个转储的差异。hexdump 的输出，使用 diff. 样本做了一些假设（x86_64，映射要么在地址和大小上匹配，要么只存在于dump1或dump2中），省略了大部分的错误处理，为了简洁起见，总是选择简单的实现方法。

#include <elf.h>
#include <fcntl.h>
#include <stdio.h>
#include <sys/mman.h>
#include <sys/stat.h>

#define MAX_MAPPINGS 1024

struct dump
{
  char *base;
  Elf64_Shdr *mappings[MAX_MAPPINGS];
};

unsigned readdump(const char *path, struct dump *dump)
{
  unsigned count = 0;
  int fd = open(path, O_RDONLY);
  if (fd != -1) {
    struct stat stat;
    fstat(fd, &stat);
    dump->base = mmap(NULL, stat.st_size, PROT_READ, MAP_PRIVATE, fd, 0);
    Elf64_Ehdr *header = (Elf64_Ehdr *)dump->base;
    Elf64_Shdr *secs = (Elf64_Shdr*)(dump->base+header->e_shoff);
    for (unsigned secinx = 0; secinx < header->e_shnum; secinx++) {
      if (secs[secinx].sh_type == SHT_PROGBITS) {
        if (count == MAX_MAPPINGS) {
          count = 0;
          break;
        }
        dump->mappings[count] = &secs[secinx];
        count++;
      }
    }
    dump->mappings[count] = NULL;
  }
  return count;
}

#define DIFFWINDOW 16

void printsection(struct dump *dump, Elf64_Shdr *sec, const char mode,
  unsigned offset, unsigned sizelimit)
{
  unsigned char *data = (unsigned char *)(dump->base+sec->sh_offset);
  uintptr_t addr = sec->sh_addr+offset;
  unsigned size = sec->sh_size;
  data += offset;
  if (sizelimit) {
    size = sizelimit;
  }
  unsigned start = 0;
  for (unsigned i = 0; i < size; i++) {
    if (i%DIFFWINDOW == 0) {
      printf("%c%016x ", mode, addr+i);
      start = i;
    }
    printf(" %02x", data[i]);
    if ((i+1)%DIFFWINDOW == 0 || i + 1 == size) {
      printf(" [");
      for (unsigned j = start; j <= i; j++) {
        putchar((data[j] >= 32 && data[j] < 127)?data[j]:'.');
      }
      printf("]\n");
    }
    addr++;
  }
}

void printdiff(struct dump *dump1, Elf64_Shdr *sec1,
  struct dump *dump2, Elf64_Shdr *sec2)
{
  unsigned char *data1 = (unsigned char *)(dump1->base+sec1->sh_offset);
  unsigned char *data2 = (unsigned char *)(dump2->base+sec2->sh_offset);
  unsigned difffound = 0;
  unsigned start = 0;
  for (unsigned i = 0; i < sec1->sh_size; i++) {
    if (i%DIFFWINDOW == 0) {
      start = i;
      difffound = 0;
    }
    if (!difffound && data1[i] != data2[i]) {
      difffound = 1;
    }
    if ((i+1)%DIFFWINDOW == 0 || i + 1 == sec1->sh_size) {
      if (difffound) {
        printsection(dump1, sec1, '-', start, DIFFWINDOW);
        printsection(dump2, sec2, '+', start, DIFFWINDOW);
      }
    }
  }
}

int main(int argc, char **argv)
{
  if (argc != 3) {
    fprintf(stderr, "Usage: compare DUMP1 DUMP2\n");
    return 1;
  }
  struct dump dump1;
  struct dump dump2;
  if (readdump(argv[1], &dump1) == 0 ||
      readdump(argv[2], &dump2) == 0) {
    fprintf(stderr, "Failed to read dumps\n");
    return 1;
  }
  unsigned sinx1 = 0;
  unsigned sinx2 = 0;
  while (dump1.mappings[sinx1] || dump2.mappings[sinx2]) {
    Elf64_Shdr *sec1 = dump1.mappings[sinx1];
    Elf64_Shdr *sec2 = dump2.mappings[sinx2];
    if (sec1 && sec2) {
      if (sec1->sh_addr == sec2->sh_addr) {
        // in both
        printdiff(&dump1, sec1, &dump2, sec2);
        sinx1++;
        sinx2++;
      }
      else if (sec1->sh_addr < sec2->sh_addr) {
        // in 1, not 2
        printsection(&dump1, sec1, '-', 0, 0);
        sinx1++;
      }
      else {
        // in 2, not 1
        printsection(&dump2, sec2, '+', 0, 0);
        sinx2++;
      }
    }
    else if (sec1) {
      // in 1, not 2
      printsection(&dump1, sec1, '-', 0, 0);
      sinx1++;
    }
    else {
      // in 2, not 1
      printsection(&dump2, sec2, '+', 0, 0);
      sinx2++;
    }
  } 
  return 0;
}

有了样本实现，我们可以重新评估我们上面的方案。A除了从第一个diff。

$ ./compare dump1 dump2
-0000000000601020  86 05 40 00 00 00 00 00 50 3e a8 f7 ff 7f 00 00 [[email protected]>......]
+0000000000601020  00 6f a9 f7 ff 7f 00 00 50 3e a8 f7 ff 7f 00 00 [.o......P>......]
-0000000000602260  bc e2 ff ff ff 7f 00 00 00 00 00 00 00 00 00 00 [................]
+0000000000602260  c1 08 40 00 00 00 00 00 00 00 00 00 00 00 00 00 [..@.............]
-0000000000602280  6e 6f 20 63 6f 72 72 75 70 74 69 6f 6e 0a 00 00 [no corruption...]
+0000000000602280  75 73 65 2d 61 66 74 65 72 2d 66 72 65 65 20 68 [use-after-free h]
-0000000000602290  00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 [................]
+0000000000602290  69 64 64 65 6e 20 62 79 20 6e 65 77 20 61 6c 6c [idden by new all]

差异显示 *gstate (地址 0x602260)改为 0x7fffffffe2bc 到 0x4008c1:

-0000000000602260  bc e2 ff ff ff 7f 00 00 00 00 00 00 00 00 00 00 [................]
+0000000000602260  c1 08 40 00 00 00 00 00 00 00 00 00 00 00 00 00 [..@.............]

第二次比较，只有相关的偏移量。

$ ./compare dump1 dump2
-0000000000602260  c1 08 40 00 00 00 00 00 00 00 00 00 00 00 00 00 [..@.............]
+0000000000602260  01 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 [................]

差别显示： *gstate (地址 0x602260)改为 0x4008c1 到 0x1.

有你有它，一个核心转储差异。现在，是否能证明在你的方案中是有用的取决于各种因素，其中之一是两个dump之间的时间框架和该窗口内发生的活动。一个大的diff可能会很难分析，所以我们的目标必须是通过仔细选择diff窗口来最小化它的大小。

你拥有的背景越多，分析就越容易。例如，可以将diff的相关范围缩小，将diff限制在 .data 和 .bss 的部分，如果那里的变化与你的情况有关。

另一种减少范围的方法：排除不被库引用的内存的变化。任意堆分配和特定库之间的关系并不是很明显。根据你的初始diff中的变化地址，你可以搜索在 .data 和 .bss 库的各个部分都在diff实现中。这并没有考虑到每一个可能的引用（最明显的是来自其他分配的间接引用、库所属线程的寄存器和堆栈引用），但这是一个开始。