吃土记之GDB调试原理

NAME
       ptrace - process trace

SYNOPSIS
       #include <sys/ptrace.h>

       long ptrace(enum __ptrace_request request, pid_t pid,
                   void *addr, void *data);

DESCRIPTION
       The  ptrace()  system  call  provides a means by which one process (the
       "tracer") may observe and control the execution of another process (the
       "tracee"),  and  examine  and change the tracee's memory and registers.
       It is primarily used to implement breakpoint debugging and system  call
       tracing.
       
DESCRIPTION
       The ptrace() system call provides a means by which a parent process may observe and control the execution of another process,
       and examine and change its core image and registers.  It is primarily used to implement breakpoint debugging and system  call
       tracing.
       

/ 在linux/kernel/ptrace.c文件中
SYSCALL_DEFINE4(ptrace, long, request, long, pid, long, addr, long, data)



asmlinkage int sys_ptrace(long request, long pid, long addr, long data)
{
    struct task_struct *child;
    struct user *dummy = NULL;
    int i, ret;

    ...

    read_lock(&tasklist_lock);
    child = find_task_by_pid(pid); // 获取 pid 对应的进程 task_struct 对象
    if (child)
        get_task_struct(child);
    read_unlock(&tasklist_lock);
    if (!child)
        goto out;

    if (request == PTRACE_ATTACH) {
        ret = ptrace_attach(child);
        goto out_tsk;
    }

    ...

    switch (request) {
    case PTRACE_PEEKTEXT:
    case PTRACE_PEEKDATA:
        ...
    case PTRACE_PEEKUSR:
        ...
    case PTRACE_POKETEXT:
    case PTRACE_POKEDATA:
        ...
    case PTRACE_POKEUSR:
        ...
    case PTRACE_SYSCALL:
    case PTRACE_CONT:
        ...
    case PTRACE_KILL: 
        ...
    case PTRACE_SINGLESTEP:
        ...
    case PTRACE_DETACH:
        ...
    }
out_tsk:
    free_task_struct(child);
out:
    unlock_kernel();
    return ret;
}

#define PTRACE_TRACEME         0

进入被追踪模式（PTRACE_TRACEME操作）
当要调试一个进程时，需要使进程进入被追踪模式，怎么使进程进入被追踪模式呢？

有两个方法：

被调试的进程调用 ptrace(PTRACE_TRACEME, ...) 来使自己进入被追踪模式。

调试进程（如GDB）调用 ptrace(PTRACE_ATTACH, pid, ...) 来使指定的进程进入被追踪模式。


#define PTRACE_PEEKTEXT        1
#define PTRACE_PEEKDATA        2
#define PTRACE_PEEKUSR         3
#define PTRACE_POKETEXT        4
#define PTRACE_POKEDATA        5
#define PTRACE_POKEUSR         6
#define PTRACE_CONT            7
#define PTRACE_KILL            8
#define PTRACE_SINGLESTEP      9
#define PTRACE_ATTACH       0x10
#define PTRACE_DETACH       0x11
#define PTRACE_SYSCALL        24
#define PTRACE_GETREGS        12
#define PTRACE_SETREGS        13
#define PTRACE_GETFPREGS      14
#define PTRACE_SETFPREGS      15
#define PTRACE_GETFPXREGS     18
#define PTRACE_SETFPXREGS     19
#define PTRACE_SETOPTIONS     21

asmlinkage int sys_ptrace(long request, long pid, long addr, long data)
{
    ...
    switch (request) {
    case PTRACE_SINGLESTEP: {  /* set the trap flag. */
        long tmp;
        ...
        tmp = get_stack_long(child, EFL_OFFSET) | TRAP_FLAG;
        put_stack_long(child, EFL_OFFSET, tmp);
        child->exit_code = data;
        /* give it a chance to run. */
        wake_up_process(child);
        ret = 0;
        break;
    }
    ...
}


  process.
       D    Uninterruptible sleep (usually IO)
       R    Running or runnable (on run queue)
       S    Interruptible sleep (waiting for an event to complete)
       T    Stopped, either by a job control signal or because it is being traced.
       
       https://stackoverflow.com/questions/7844569/ptrace-single-step-in-the-kernel-from-process-context
       W    paging (not valid since the 2.6.xx kernel)
       X    dead (should never be seen)
       Z    Defunct ("zombie") process, terminated but not reaped by its parent.
D (TASK_UNINTERRUPTIBLE)，不可中断的睡眠状态。
R (TASK_RUNNING)，进程执行中。
S (TASK_INTERRUPTIBLE)，可中断的睡眠状态。
T (TASK_STOPPED)，暂停状态。
t (TASK_TRACED)，进程被追踪。
w (TASK_PAGING)，进程调页中，2.6以上版本的内核中已经被移除。
X (TASK_DEAD – EXIT_DEAD)，退出状态，进程即将被销毁。
Z (TASK_DEAD – EXIT_ZOMBIE)，退出状态，进程成为僵尸进程。

系统调用的分类
系统调用大体上可分为5类：

进程控制
加载
执行
结束，中止
创建进程
结束进程
得到/设置进程属性
等待（时间、时间、信号）
内存的分配和去配
文件管理
文件的创建和删除
打开和关闭
读、写和重定位
得到/设置文件属性
设备管理
设备的请求和释放
读、写和重定位
得到/设置设备属性
设备的逻辑关联或去关联
信息维护
得到/设置时间或日期
得到/设置系统数据
得到/设置进程、文件或设备属性
通信
通信连接的创建和删除
发送、接收信息
转换状态信息
远程设备的关联或去关联

Linux系统调用：使用 int 0x80
Linux提供了200多个系统调用，通过汇编指令 int 0x80 实现，用系统调用号来区分入口函数。

Linux实现系统调用的基本过程是：

应用程序准备参数，发出调用请求；
C库封装函数引导。该函数在Linux提供的标准C库，即 glibc 中。对应的封装函数由下列汇编指令实现（以读函数调用为例）：
; NASM
; read(int fd, void *buffer, size_t nbytes)
mov eax, 3          ; read系统调用号为3
mov ebx, fd
mov ecx, buffer
mov edx, nbytes
int 0x80            ; 触发系统调用

write(2, "Hello", 5)
roughly would translate into

大致可以理解为

movl   $4, %eax
movl   $2, %ebx
movl   $hello,%ecx
movl   $5, %edx
int    $0x80

root@money:~/code/c++/temo# cat ptrace.c
#include <sys/ptrace.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <unistd.h>
#include <sys/user.h>
#include <stdio.h>

int main()
{   pid_t child;
    struct user_regs_struct regs;

    child = fork();  // 创建一个子进程
    if(child == 0) { // 子进程
        ptrace(PTRACE_TRACEME, 0, NULL, NULL); // 表示当前进程进入被追踪状态
        execl("/bin/ls", "ls", NULL);          // 执行 `/bin/ls` 程序
    } 
    else { // 父进程
        wait(NULL); // 等待子进程发送一个 SIGCHLD 信号
        ptrace(PTRACE_GETREGS, child, NULL, &regs); // 获取子进程的各个寄存器的值
 
  printf("Register: rdi[%ld], rsi[%ld], rdx[%ld], rax[%ld], orig_rax[%ld]\n",
                regs.rdi, regs.rsi, regs.rdx,regs.rax, regs.orig_rax); // 打印寄存器的值
        ptrace(PTRACE_CONT, child, NULL, NULL); // 继续运行子进程
        sleep(1);
    }
    return 0;
}

root@money:~/code/c++/temo# ./ptrace 
Register: rdi[0], rsi[0], rdx[0], rax[0], orig_rax[59]
1.cpp  ptrace  ptrace.c

asmlinkage int sys_ptrace(long request, long pid, long addr, long data)
{
    ...
    if (request == PTRACE_TRACEME) {
        if (current->ptrace & PT_PTRACED)
            goto out;
        current->ptrace |= PT_PTRACED; // 标志 PTRACE 状态
        ret = 0;
        goto out;
    }
    ...
}

static int load_elf_binary(struct linux_binprm * bprm, struct pt_regs * regs)
{
    ...
    if (current->ptrace & PT_PTRACED)
        send_sig(SIGTRAP, current, 0);
    ...
}

int do_signal(struct pt_regs *regs, sigset_t *oldset) 
{
    for (;;) {
        unsigned long signr;

        spin_lock_irq(&current->sigmask_lock);
        signr = dequeue_signal(&current->blocked, &info);
        spin_unlock_irq(&current->sigmask_lock);

        // 如果进程被标记为 PTRACE 状态
        if ((current->ptrace & PT_PTRACED) && signr != SIGKILL) {
            /* 让调试器运行  */
            current->exit_code = signr;
            current->state = TASK_STOPPED;   // 让自己进入停止运行状态
            notify_parent(current, SIGCHLD); // 发送 SIGCHLD 信号给父进程
            schedule();                      // 让出CPU的执行权限
            ...
        }
    }
}