中国领先的IT技术网站
|
|

开发一个Linux调试器(三):寄存器和内存

上一篇博文中我们给调试器添加了一个简单的地址断点。这次,我们将添加读写寄存器和内存的功能,这将使我们能够使用我们的程序计数器、观察状态和改变程序的行为。

作者:Simon Brand来源:Linux中国|2017-07-05 14:37

开发一个Linux调试器(三):寄存器和内存

上一篇博文中我们给调试器添加了一个简单的地址断点。这次,我们将添加读写寄存器和内存的功能,这将使我们能够使用我们的程序计数器、观察状态和改变程序的行为。

系列文章索引

随着后面文章的发布,这些链接会逐渐生效。

注册我们的寄存器

在我们真正读取任何寄存器之前,我们需要告诉调试器一些关于我们的目标平台的信息,这里是 x8664 平台。除了多组通用和专用目的寄存器,x8664 还提供浮点和向量寄存器。为了简化,我将跳过后两种寄存器,但是你如果喜欢的话也可以选择支持它们。x86_64 也允许你像访问 32、16 或者 8 位寄存器那样访问一些 64 位寄存器,但我只会介绍 64 位寄存器。由于这些简化,对于每个寄存器我们只需要它的名称、它的 DWARF 寄存器编号以及 ptrace 返回结构体中的存储地址。我使用范围枚举引用这些寄存器,然后我列出了一个全局寄存器描述符数组,其中元素顺序和 ptrace 中寄存器结构体相同。

  1. enum class reg { 
  2.     rax, rbx, rcx, rdx, 
  3.     rdi, rsi, rbp, rsp, 
  4.     r8,  r9,  r10, r11, 
  5.     r12, r13, r14, r15, 
  6.     rip, rflags,    cs, 
  7.     orig_rax, fs_base, 
  8.     gs_base, 
  9.     fs, gs, ss, ds, es 
  10. }; 
  11. constexpr std::size_t n_registers = 27; 
  12. struct reg_descriptor { 
  13.     reg r; 
  14.     int dwarf_r; 
  15.     std::string name
  16. }; 
  17. const std::array<reg_descriptor, n_registers> g_register_descriptors {{ 
  18.     { reg::r15, 15, "r15" }, 
  19.     { reg::r14, 14, "r14" }, 
  20.     { reg::r13, 13, "r13" }, 
  21.     { reg::r12, 12, "r12" }, 
  22.     { reg::rbp, 6, "rbp" }, 
  23.     { reg::rbx, 3, "rbx" }, 
  24.     { reg::r11, 11, "r11" }, 
  25.     { reg::r10, 10, "r10" }, 
  26.     { reg::r9, 9, "r9" }, 
  27.     { reg::r8, 8, "r8" }, 
  28.     { reg::rax, 0, "rax" }, 
  29.     { reg::rcx, 2, "rcx" }, 
  30.     { reg::rdx, 1, "rdx" }, 
  31.     { reg::rsi, 4, "rsi" }, 
  32.     { reg::rdi, 5, "rdi" }, 
  33.     { reg::orig_rax, -1, "orig_rax" }, 
  34.     { reg::rip, -1, "rip" }, 
  35.     { reg::cs, 51, "cs" }, 
  36.     { reg::rflags, 49, "eflags" }, 
  37.     { reg::rsp, 7, "rsp" }, 
  38.     { reg::ss, 52, "ss" }, 
  39.     { reg::fs_base, 58, "fs_base" }, 
  40.     { reg::gs_base, 59, "gs_base" }, 
  41.     { reg::ds, 53, "ds" }, 
  42.     { reg::es, 50, "es" }, 
  43.     { reg::fs, 54, "fs" }, 
  44.     { reg::gs, 55, "gs" }, 
  45. }}; 

如果你想自己看看的话,你通常可以在 /usr/include/sys/user.h 找到寄存器数据结构,另外 DWARF 寄存器编号取自 System V x86_64 ABI。

现在我们可以编写一堆函数来和寄存器交互。我们希望可以读取寄存器、写入数据、根据 DWARF 寄存器编号获取值,以及通过名称查找寄存器,反之类似。让我们先从实现 get_register_value 开始:

  1. uint64_t get_register_value(pid_t pid, reg r) { 
  2.     user_regs_struct regs; 
  3.     ptrace(PTRACE_GETREGS, pid, nullptr, &regs); 
  4.     //... 

ptrace 使得我们可以轻易获得我们想要的数据。我们只需要构造一个 user_regs_struct 实例并把它和 PTRACE_GETREGS 请求传递给 ptrace。

现在根据要请求的寄存器,我们要读取 regs。我们可以写一个很大的 switch 语句,但由于我们 g_register_descriptors 表的布局顺序和 user_regs_struct 相同,我们只需要搜索寄存器描述符的索引,然后作为 uint64_t 数组访问 user_regs_struct 就行。(你也可以重新排序 reg 枚举变量,然后使用索引把它们转换为底层类型,但第一次我就使用这种方式编写,它能正常工作,我也就懒得改它了。)

  1. auto it = std::find_if(begin(g_register_descriptors), end(g_register_descriptors), 
  2.                        [r](auto&& rd) { return rd.r == r; }); 
  3. return *(reinterpret_cast<uint64_t*>(&regs) + (it - begin(g_register_descriptors))); 

到 uint64_t 的转换是安全的,因为 user_regs_struct 是一个标准布局类型,但我认为指针算术技术上是未定义的行为undefined behavior。当前没有编译器会对此产生警告,我也懒得修改,但是如果你想保持最严格的正确性,那就写一个大的 switch 语句。

set_register_value 非常类似,我们只是写入该位置并在最后写回寄存器:

  1. void set_register_value(pid_t pid, reg r, uint64_t value) { 
  2.     user_regs_struct regs; 
  3.     ptrace(PTRACE_GETREGS, pid, nullptr, &regs); 
  4.     auto it = std::find_if(begin(g_register_descriptors), end(g_register_descriptors), 
  5.                            [r](auto&& rd) { return rd.r == r; }); 
  6.     *(reinterpret_cast<uint64_t*>(&regs) + (it - begin(g_register_descriptors))) = value; 
  7.     ptrace(PTRACE_SETREGS, pid, nullptr, &regs); 

下一步是通过 DWARF 寄存器编号查找。这次我会真正检查一个错误条件以防我们得到一些奇怪的 DWARF 信息。

  1. uint64_t get_register_value_from_dwarf_register (pid_t pid, unsigned regnum) { 
  2.     auto it = std::find_if(begin(g_register_descriptors), end(g_register_descriptors), 
  3.                            [regnum](auto&& rd) { return rd.dwarf_r == regnum; }); 
  4.     if (it == end(g_register_descriptors)) { 
  5.         throw std::out_of_range{"Unknown dwarf register"}; 
  6.     } 
  7.     return get_register_value(pid, it->r); 

就快完成啦,现在我们已经有了寄存器名称查找:

  1. std::string get_register_name(reg r) { 
  2.     auto it = std::find_if(begin(g_register_descriptors), end(g_register_descriptors), 
  3.                            [r](auto&& rd) { return rd.r == r; }); 
  4.     return it->name
  5. reg get_register_from_name(const std::string& name) { 
  6.     auto it = std::find_if(begin(g_register_descriptors), end(g_register_descriptors), 
  7.                            [name](auto&& rd) { return rd.name == name; }); 
  8.     return it->r; 

最后我们会添加一个简单的帮助函数用于导出所有寄存器的内容:

  1. void debugger::dump_registers() { 
  2.     for (const auto& rd : g_register_descriptors) { 
  3.         std::cout << rd.name << " 0x" 
  4.                   << std::setfill('0') << std::setw(16) << std::hex << get_register_value(m_pid, rd.r) << std::endl; 
  5.     } 

正如你看到的,iostreams 有非常精确的接口用于美观地输出十六进制数据(啊哈哈哈哈哈哈)。如果你喜欢你也可以通过 I/O 操纵器来摆脱这种混乱。

这些已经足够支持我们在调试器接下来的部分轻松地处理寄存器,所以我们现在可以把这些添加到我们的用户界面。

显示我们的寄存器

这里我们要做的就是给 handle_command 函数添加一个命令。通过下面的代码,用户可以输入 register read rax、 register write rax 0x42 以及类似的语句。

  1. else if (is_prefix(command, "register")) { 
  2.     if (is_prefix(args[1], "dump")) { 
  3.         dump_registers(); 
  4.     } 
  5.     else if (is_prefix(args[1], "read")) { 
  6.         std::cout << get_register_value(m_pid, get_register_from_name(args[2])) << std::endl; 
  7.     } 
  8.     else if (is_prefix(args[1], "write")) { 
  9.         std::string val {args[3], 2}; //assume 0xVAL 
  10.         set_register_value(m_pid, get_register_from_name(args[2]), std::stol(val, 0, 16)); 
  11.     } 

接下来做什么?

设置断点的时候我们已经读取和写入内存,因此我们只需要添加一些函数用于隐藏 ptrace 调用。

  1. uint64_t debugger::read_memory(uint64_t address) { 
  2.     return ptrace(PTRACE_PEEKDATA, m_pid, address, nullptr); 
  3. void debugger::write_memory(uint64_t address, uint64_t value) { 
  4.     ptrace(PTRACE_POKEDATA, m_pid, address, value); 

你可能想要添加支持一次读取或者写入多个字节,你可以在每次希望读取另一个字节时通过递增地址来实现。如果你需要的话,你也可以使用 process_vm_readv 和 process_vm_writev 或 /proc/<pid>/mem 代替 ptrace。

现在我们会给我们的用户界面添加命令:

  1. else if(is_prefix(command, "memory")) { 
  2.         std::string addr {args[2], 2}; //assume 0xADDRESS 
  3.         if (is_prefix(args[1], "read")) { 
  4.             std::cout << std::hex << read_memory(std::stol(addr, 0, 16)) << std::endl; 
  5.         } 
  6.         if (is_prefix(args[1], "write")) { 
  7.             std::string val {args[3], 2}; //assume 0xVAL 
  8.             write_memory(std::stol(addr, 0, 16), std::stol(val, 0, 16)); 
  9.         } 
  10.     } 

给 continue_execution 打补丁

在我们测试我们的更改之前,我们现在可以实现一个更健全的 continue_execution 版本。由于我们可以获取程序计数器,我们可以检查我们的断点映射来判断我们是否处于一个断点。如果是的话,我们可以停用断点并在继续之前跳过它。

为了清晰和简洁起见,首先我们要添加一些帮助函数:

  1. uint64_t debugger::get_pc() { 
  2.     return get_register_value(m_pid, reg::rip); 
  3. void debugger::set_pc(uint64_t pc) { 
  4.     set_register_value(m_pid, reg::rip, pc); 

然后我们可以编写函数来跳过断点:

  1. void debugger::step_over_breakpoint() { 
  2.     // - 1 because execution will go past the breakpoint 
  3.     auto possible_breakpoint_location = get_pc() - 1; 
  4.     if (m_breakpoints.count(possible_breakpoint_location)) { 
  5.         auto& bp = m_breakpoints[possible_breakpoint_location]; 
  6.         if (bp.is_enabled()) { 
  7.             auto previous_instruction_address = possible_breakpoint_location; 
  8.             set_pc(previous_instruction_address); 
  9.             bp.disable(); 
  10.             ptrace(PTRACE_SINGLESTEP, m_pid, nullptr, nullptr); 
  11.             wait_for_signal(); 
  12.             bp.enable(); 
  13.         } 
  14.     } 

首先我们检查当前程序计算器的值是否设置了一个断点。如果有,首先我们把执行返回到断点之前,停用它,跳过原来的指令,再重新启用断点。

wait_for_signal 封装了我们常用的 waitpid 模式:

  1. void debugger::wait_for_signal() { 
  2.     int wait_status; 
  3.     auto options = 0; 
  4.     waitpid(m_pid, &wait_status, options); 

最后我们像下面这样重写 continue_execution:

  1. void debugger::continue_execution() { 
  2.     step_over_breakpoint(); 
  3.     ptrace(PTRACE_CONT, m_pid, nullptr, nullptr); 
  4.     wait_for_signal(); 

测试效果

现在我们可以读取和修改寄存器了,我们可以对我们的 hello world 程序做一些有意思的更改。类似第一次测试,再次尝试在 call 指令处设置断点然后从那里继续执行。你可以看到输出了 Hello world。现在是有趣的部分,在输出调用后设一个断点、继续、将 call 参数设置代码的地址写入程序计数器(rip)并继续。由于程序计数器操纵,你应该再次看到输出了 Hello world。为了以防你不确定在哪里设置断点,下面是我上一篇博文中的 objdump 输出:

  1. 0000000000400936 <main>: 
  2.   400936:   55                      push   rbp 
  3.   400937:   48 89 e5                mov    rbp,rsp 
  4.   40093a:   be 35 0a 40 00          mov    esi,0x400a35 
  5.   40093f:   bf 60 10 60 00          mov    edi,0x601060 
  6.   400944:   e8 d7 fe ff ff          call   400820 <_ZStlsISt11char_traitsIcEERSt13basic_ostreamIcT_ES5_PKc@plt> 
  7.   400949:   b8 00 00 00 00          mov    eax,0x0 
  8.   40094e:   5d                      pop    rbp 
  9.   40094f:   c3                      ret 

你要将程序计数器移回 0x40093a 以便正确设置 esi 和 edi 寄存器。

在下一篇博客中,我们会第一次接触到 DWARF 信息并给我们的调试器添加一系列逐步调试的功能。之后,我们会有一个功能工具,它能逐步执行代码、在想要的地方设置断点、修改数据以及其它。一如以往,如果你有任何问题请留下你的评论!

你可以在这里找到这篇博文的代码。

【编辑推荐】

  1. Linux连接投影仪(ubuntu)失败或显示不正常
  2. uCareSystem:Ubuntu/Linux Mint的一体化系统更新和维护工具
  3. 在Linux中使用shell脚本自动创建/移除并挂载交换文件
  4. 基于Linux的物联网操作系统知多少
  5. Linux下的系统性能调优工具——Perf
【责任编辑:枯木 TEL:(010)68476606】

点赞 0
分享:
大家都在看
猜你喜欢

热门职位+更多

读 书 +更多

数据库系统工程师考试全程指导

为了满足广大考生的需要,我们组织了参与过多年资格考试命题或辅导的教师,以新的考试大纲为依据,编写了《数据库系统工程师考试全程指导》...

订阅51CTO邮刊

点击这里查看样刊

订阅51CTO邮刊
× Python一种神奇的语言