一、demo演示

.section .data
message:.string "Hello, World!\n"
len = . - message.section .text
.globl _start
_start:# 调用 write() 函数输出 "Hello, World!"mov $1, %rax            # 系统调用号为 1 表示 write()mov $1, %rdi            # 文件描述符为 1 表示标准输出lea message(%rip), %rsi # 输出的字符串地址mov $len, %rdx          # 输出的字符串长度syscall                 # 调用系统调用# 调用 exit() 函数退出程序mov $60, %rax           # 系统调用号为 60 表示 exit()xor %rdi, %rdi          # 返回值为 0syscall                 # 调用系统调用

这段汇编代码是在标准输出上输出 “Hello, World!”，然后退出程序：

as -o hello.o hello.s
ld -o hello hello.o
# ./hello
Hello, World!

#include <unistd.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <sys/ptrace.h>
#include <errno.h>
#include <sys/user.h>
#include <stdint.h>void fprint_wait_status(FILE *stream, int status)
{if( WIFSTOPPED(status) ) {fprintf(stream, "Child stopped: %d\n", WSTOPSIG(status));}if( WIFEXITED(status) ) {fprintf(stream, "Child exited: %d\n", WEXITSTATUS(status));}if( WIFSIGNALED(status) ) {fprintf(stream, "Child signaled: %d\n", WTERMSIG(status));}if( WCOREDUMP(status) ) {fprintf(stream, "Core dumped.\n");}
}int ptrace_instruction_pointer(int pid, uint64_t *rip)
{//获取指令指令的值struct user_regs_struct regs;if( ptrace(PTRACE_GETREGS, pid, NULL, (void*)&regs) ) {fprintf(stderr, "Error fetching registers from child process: %s\n",strerror(errno));return -1;}if(rip)*rip = regs.rip;return 0;
}int singlestep(int pid)
{int retval, status;//通过ptrace发送单步调试的指令retval = ptrace(PTRACE_SINGLESTEP, pid, 0, 0);if( retval ) {return retval;}//阻塞在这里--等待子进程停止//子进程停止发送信号唤醒父进程 -- 父进程对子进程进行调试waitpid(pid, &status, 0);return status;
}int main(int argc, char ** argv)
{uint64_t rip;pid_t pid;int status;char *program;if (argc < 2) {fprintf(stderr, "Usage: %s elffile arg0 arg1 ...\n", argv[0]);exit(-1);}pid = fork();if( pid == -1 ) {fprintf(stderr, "Error forking: %s\n", strerror(errno));exit(-1);}if( pid == 0 ) {/* child */if( ptrace(PTRACE_TRACEME, 0, 0, 0) ) {fprintf(stderr, "Error setting TRACEME: %s\n", strerror(errno));exit(-1);}execvp(argv[1], argv + 1);} else {/* parent *///阻塞在这里--等待子进程停止waitpid(pid, &status, 0);fprint_wait_status(stderr,status);//WIFSTOPPED在处理子进程状态时判断子进程是否处于停止状态while( WIFSTOPPED(status) ) {if(ptrace_instruction_pointer(pid, &rip) ) {break;}fprintf(stderr, "RIP: %p\n", (void*)rip);status = singlestep(pid);}fprint_wait_status(stderr, status);fprintf(stderr, "Detaching\n");ptrace(PTRACE_DETACH, pid, 0, 0);}return 0;
}

在这里插入图片描述

二、原理分析

PTRACE_SINGLESTEP：重新启动被跟踪进程，并在执行一条指令后停止。当使用PTRACE_SINGLESTEP选项时，被跟踪进程将在执行完一条指令后立即停止，以供跟踪进程进行单步调试或其他操作。

这个选项都会使被跟踪进程看起来好像是接收到了一个SIGTRAP信号而停止执行。跟踪进程可以在被跟踪进程停止时进行进一步的检查或操作。

以下是这个选项的使用方式：

ptrace(PTRACE_SINGLESTEP, pid, NULL, data);

pid是被跟踪进程的进程ID。
data参数如果非零，表示要发送给被跟踪进程的信号编号；如果为零，表示不发送任何信号。

在停止时，被跟踪进程会看起来好像是接收到了一个SIGTRAP信号。

原理图如下：
在这里插入图片描述

内核源码分析：

SYSCALL_DEFINE4(ptrace, long, request, long, pid, unsigned long, addr,unsigned long, data)
{//根据被跟踪进程的pid获取其struct task_struct结构体struct task_struct *child;child = ptrace_get_task_struct(pid);if (IS_ERR(child)) {ret = PTR_ERR(child);goto out;}//对被跟踪进程发起request请求arch_ptrace(child, request, addr, data);}

这是一个和处理器架构相关的函数：

long arch_ptrace(struct task_struct *child, long request,unsigned long addr, unsigned long data)
{ptrace_request(child, request, addr, data);
}

int ptrace_request(struct task_struct *child, long request,unsigned long addr, unsigned long data)
{#ifdef PTRACE_SINGLESTEPcase PTRACE_SINGLESTEP:#endifreturn ptrace_resume(child, request, data);
}

#ifdef PTRACE_SINGLESTEP
#define is_singlestep(request)		((request) == PTRACE_SINGLESTEP)static int ptrace_resume(struct task_struct *child, long request,unsigned long data)
{//设置单步调试标志if (is_singlestep(request){user_enable_single_step(child);}//唤醒子进程wake_up_state(child, __TASK_TRACED);}

void user_enable_single_step(struct task_struct *child)
{//这里传递的参数是0enable_step(child, 0);
}

user_enable_single_step 函数接受一个参数 child，表示要启用单步调试的任务结构体指针。该函数调用 enable_step 函数，并将 block 参数设置为 0，即不启用块步调试。这样，enable_step 函数将尝试启用任务的单步调试，而不启用块步调试。

/** Enable single or block step.*/
static void enable_step(struct task_struct *child, bool block)
{//传入的参数 block = 0/** Make sure block stepping (BTF) is not enabled unless it should be.* Note that we don't try to worry about any is_setting_trap_flag()* instructions after the first when using block stepping.* So no one should try to use debugger block stepping in a program* that uses user-mode single stepping itself.*/if (enable_single_step(child) && block)set_task_blockstep(child, true);else if (test_tsk_thread_flag(child, TIF_BLOCKSTEP))set_task_blockstep(child, false);
}

#define TIF_SINGLESTEP		4	/* reenable singlestep on user return*/#define X86_EFLAGS_TF	0x00000100 /* Trap Flag */#define TIF_FORCED_TF		24	/* true if TF in eflags artificially *//** Enable single-stepping.  Return nonzero if user mode is not using TF itself.*/
static int enable_single_step(struct task_struct *child)
{struct pt_regs *regs = task_pt_regs(child);unsigned long oflags;/** If we stepped into a sysenter/syscall insn, it trapped in* kernel mode; do_debug() cleared TF and set TIF_SINGLESTEP.* If user-mode had set TF itself, then it's still clear from* do_debug() and we need to set it again to restore the user* state so we don't wrongly set TIF_FORCED_TF below.* If enable_single_step() was used last and that is what* set TIF_SINGLESTEP, then both TF and TIF_FORCED_TF are* already set and our bookkeeping is fine.*/if (unlikely(test_tsk_thread_flag(child, TIF_SINGLESTEP)))regs->flags |= X86_EFLAGS_TF;/** Always set TIF_SINGLESTEP - this guarantees that* we single-step system calls etc..  This will also* cause us to set TF when returning to user mode.*/// 设置子进程的thread_info实例的flags字段对应的标志位为TIF_SINGLESTEPset_tsk_thread_flag(child, TIF_SINGLESTEP);oflags = regs->flags;/* Set TF on the kernel stack.. */regs->flags |= X86_EFLAGS_TF;/** ..but if TF is changed by the instruction we will trace,* don't mark it as being "us" that set it, so that we* won't clear it by hand later.** Note that if we don't actually execute the popf because* of a signal arriving right now or suchlike, we will lose* track of the fact that it really was "us" that set it.*/if (is_setting_trap_flag(child, regs)) {clear_tsk_thread_flag(child, TIF_FORCED_TF);return 0;}/** If TF was already set, check whether it was us who set it.* If not, we should never attempt a block step.*/if (oflags & X86_EFLAGS_TF)return test_tsk_thread_flag(child, TIF_FORCED_TF);set_tsk_thread_flag(child, TIF_FORCED_TF);return 1;
}

enable_single_step 函数，用于启用单步调试模式。以下是代码说明：

（1）调用 task_pt_regs 宏获取子进程任务的struct pt_regs：

struct pt_regs 是一个在Linux内核中用于保存进程或线程上下文中寄存器值的数据结构。

它定义了一个包含了各种寄存器的成员的结构体，用于保存任务在进行上下文切换时的寄存器状态，以及在进行异常处理或调试时用于保存当前执行指令的上下文信息。

struct pt_regs {unsigned long r15;unsigned long r14;unsigned long r13;unsigned long r12;unsigned long rbp;unsigned long rbx;
/* arguments: non interrupts/non tracing syscalls only save up to here*/unsigned long r11;unsigned long r10;unsigned long r9;unsigned long r8;unsigned long rax;unsigned long rcx;unsigned long rdx;unsigned long rsi;unsigned long rdi;unsigned long orig_rax;
/* end of arguments */
/* cpu exception frame or undefined */unsigned long rip;unsigned long cs;unsigned long eflags;unsigned long rsp;unsigned long ss;
/* top of stack page */
};

struct pt_regs *regs = task_pt_regs(child);

struct thread_struct {/* Cached TLS descriptors: */struct desc_struct	tls_array[GDT_ENTRY_TLS_ENTRIES];unsigned long		sp0;unsigned long		sp;......
};struct task_struct {
/* CPU-specific state of this task */struct thread_struct thread;
}#define task_pt_regs(tsk)	((struct pt_regs *)(tsk)->thread.sp0 - 1)

将 tsk 的内核栈指针减去 1，然后将结果转换为 struct pt_regs* 类型的指针。
在给定的宏定义中，将任务的内核栈指针 (tsk)->thread.sp0 减去 1 的目的是将指针向前移动一个偏移量，使其指向寄存器上下文结构体 pt_regs 的起始位置。

在x86架构中，寄存器上下文结构体 pt_regs 被存储在任务的内核栈的顶部。所以，通过将内核栈指针减去 1，指针将移动到 pt_regs 结构体的位置。这种偏移一般是由于栈的增长方向的约定造成的。在x86架构中，栈从高地址向低地址增长，而栈顶部位于较高的地址。因此，为了指向位于栈顶的 pt_regs 结构体，需要将栈指针减去 1。

函数检查任务的 TIF_SINGLESTEP 线程标志。这里用 unlikely 修饰表示这是一个小概率事件。
如果该标志已设置，说明在内核模式下发生了 sysenter/syscall 指令，do_debug() 函数已经清除了 TF（Trap Flag）并设置了 TIF_SINGLESTEP 标志。但如果用户模式自己设置了 TF 标志，那么 TF 仍然被 do_debug() 清除，因此需要重新设置 TF 标志来恢复用户模式的状态，以避免错误地设置 TIF_FORCED_TF。

（2）函数使用 set_tsk_thread_flag 函数将任务的 TIF_SINGLESTEP 线程标志设置为真，以确保在系统调用等情况下仍能进行单步调试。

（3）保存当前子进程寄存器 flags 的值到 oflags 变量中。

（4）在内核栈上设置 TF 标志，即将 TF 标志设置为 1。

（5）如果要执行的指令改变了 TF 标志的值，说明不是由我们自己设置的，所以不应该将其标记为 “us” 设置的，以免后续手动清除该标志。如果发生这种情况，函数通过 clear_tsk_thread_flag 函数清除 TIF_FORCED_TF 标志，并返回 0。

（6）如果 TF 标志已经设置，并且之前设置 TF 的不是我们自己，说明我们不应该尝试 block step ，因此返回 0。

（7）如果 TF 标志之前未设置，函数使用 set_tsk_thread_flag 函数将任务的 TIF_FORCED_TF 标志设置为真，并返回 1。

struct thread_info {__u32			flags;
}

/** flag set/clear/test wrappers* - pass TIF_xxxx constants to these functions*/static inline void set_ti_thread_flag(struct thread_info *ti, int flag)
{set_bit(flag, (unsigned long *)&ti->flags);
}

#define task_thread_info(task)	((struct thread_info *)(task)->stack)

// arch/x86/include/asm/thread_info.h/** thread information flags* - these are process state flags that various assembly files*   may need to access* - pending work-to-be-done flags are in LSW* - other flags in MSW* Warning: layout of LSW is hardcoded in entry.S*/#define TIF_SINGLESTEP		4	/* reenable singlestep on user return*/

// include/linux/sched.h/* set thread flags in other task's structures* - see asm/thread_info.h for TIF_xxxx flags available*/
static inline void set_tsk_thread_flag(struct task_struct *tsk, int flag)
{set_ti_thread_flag(task_thread_info(tsk), flag);
}

其中上述的代码我们需要关心的是：

/** Enable single-stepping.  Return nonzero if user mode is not using TF itself.*/
static int enable_single_step(struct task_struct *child)
{/** Always set TIF_SINGLESTEP - this guarantees that* we single-step system calls etc..  This will also* cause us to set TF when returning to user mode.*/set_tsk_thread_flag(child, TIF_SINGLESTEP);
}