目录
一、gdb跟踪被调试程序的fork、pthread_create操作
（代码：linux 6.3.1，架构：arm64）
One look is worth a thousand words. —— Tess Flanders
相关链接：
linux ptrace 图文详解（二） PTRACE_TRACEME 跟踪程序
linux ptrace 图文详解（三） PTRACE_ATTACH 跟踪程序
linux ptrace 图文详解（五） gdb设置硬断点、观察点
linux ptrace 图文详解（七） gdb、strace跟踪系统调用
在开始之前，我们先思考几个问题：
1）gdb调试一个程序，该程序所创建的子进程、子线程，是否同样会被gdb跟踪？
2）若gdb可以跟踪被调试程序的子进程、子线程，这是如何实现的？gdb如何获取到子进程、子线程的信息？
3）gdb一定要跟踪被调试程序的子线程、子进程么？
一、gdb跟踪被调试程序的fork、pthread_create操作
GDB 从 版本 7.0 开始支持用户显式控制是否监控被调试程序创建的子进程和子线程。以下是一些gdb控制调试子进程、子线程的一些常见指令：
1）gdb控制子进程调试
set follow-fork-mode <mode>
mode选项：
- parent（默认）：仅调试父进程，子进程继续运行不受监控
- child：切换到调试子进程，父进程继续运行
set detach-on-fork <on/off>
- on：分离非调试的进程（若选择跟踪子进程时，父进程会被分离）
- off：同时调试父子进程（需配合inferior命令切换）
2）gdb控制子线程调试
set scheduler-locking <mode>
mode选项：
- off（默认）：所有线程自由运行；
- on：仅当前调试的线程运行，其他线程暂停；
- setp：单步执行时仅当前线程运行（避免其他线程干扰）；
使用示例：
# 启动gdb设置调试模式
gdb ./test
(gdb) set follow-fork-mode child # 跟踪子进程
(gdb) set detach-on-fork off # 不分离父进程
(gdb) break child_function # 在子进程函数设断点
(gdb) run
# 切换进程
(gdb) info inferiors
Num Description Executable
1 process 1234 ./test (父进程)
2 process 1235 ./test (子进程)
(gdb) inferior 2 # 切换到子进程二、实现原理
gdb跟踪被调试程序创建的子进程/子线程的原理如下：
1）被调试程序（父进程）调用fork、pthread_create后，陷入内核的系统调用都是kernel_clone；
2）为 子进程/子线程 创建对应的task_struct对象，并且dup相应的内核对象；
3）子进程/子线程 的task_struct对象，继承父进程的ptrace字段（该字段的用途：控制当前进程的哪些行为需要被gdb接管，该字段通常是由gdb通过ptrace进行设置的）；
4）父进程 给 子进程/子线程 的task对象添加一个SIGSTOP信号，目的是让子进程/子线程被调度运行时将自己挂起；
5）父进程通过wake_up_new_task 将 子进程/子线程 添加到就绪队列等待被调度运行；
6）子进程/子线程被调度运行时，返回用户态前夕，检查是否存在pending信号，发现有SIGSTOP，于是将自己挂起，并通知gdb；
7）父进程 将 子进程/子线程 的pid，记录到自己的ptrace_message字段中（后续gdb会来拿这个信息）；
8）父进程发现自己的task->ptrace字段包含了 PTRACE_EVENT_CLONE、PTRACE_EVENT_FORK，代表当前任务的fork、pthread_create动作需要通知gdb，于是调用ptrace_stop，通知父进程并将自己挂起；
9）gdb被唤醒后，通过wait的status参数得知被调试程序执行了fork、pthread_create动作；
10）gdb通过ptrace(PTRACE_GETEVENTMSG)，陷入内核获取记录在父进程task->ptrace_message中的信息，该信息就是父进程创建的 子进程/子线程 的 pid；
12）gdb 为 被调试程序创建的 子进程/子线程 创建对应的数据结构，记录在gdb中，至此gdb侧就掌握了被调试程序的所有子线程、子进程相关信息；
13）最后，gdb通过ptrace(PTRACE_CONT)将被调试程序（父进程）、及其创建的 子进程/子线程 唤醒继续运行；
14）父进程 以及其创建的 子进程/子线程 被调度继续运行；
三、代码实现
1、gdb为被调试程序设置对应的ptrace字段（告知子进程其哪些动作需要被gdb拦截）
// Case1
linux_process_target::post_create_inferior
linux_enable_event_reporting
supported_ptrace_options = (PTRACE_O_TRACESYSGOOD | PTRACE_O_TRACECLONE | PTRACE_O_TRACEFORK
| PTRACE_O_TRACEVFORK | PTRACE_O_TRACEVFORKDONE | PTRACE_O_TRACEEXEC)
options &= supported_ptrace_options
ptrace(PTRACE_SETOPTIONS, pid, ..., options)
flags = task->ptrace
flags &= ~(PTRACE_O_MASK << PT_OPT_FLAG_SHIFT)
flags |= (options << PT_OPT_FLAG_SHIFT)
task->ptrace = flags
// Case2
linux_enable_event_reporting (pid_t pid, int options) {
if (supported_ptrace_options == -1) {
linux_check_ptrace_features() {
supported_ptrace_options = (PTRACE_O_TRACESYSGOOD | PTRACE_O_TRACECLONE | PTRACE_O_TRACEFORK
| PTRACE_O_TRACEVFORK | PTRACE_O_TRACEVFORKDONE | PTRACE_O_TRACEEXEC)
...
}
}
/* We always want clone events. */
options |= PTRACE_O_TRACECLONE
/* Filter out unsupported options. */
options &= supported_ptrace_options
ptrace(PTRACE_SETOPTIONS, pid, (PTRACE_TYPE_ARG3) 0, (PTRACE_TYPE_ARG4) (uintptr_t) options) {
sys_ptrace(request, pid, addr, data) {
ptrace_request(struct task_struct *child, long request, unsigned long addr, unsigned long data) {
switch (request)
case PTRACE_SETOPTIONS:
ptrace_setoptions(child, data) {
flags = child->ptrace
flags &= ~(PTRACE_O_MASK << PT_OPT_FLAG_SHIFT)
flags |= (data << PT_OPT_FLAG_SHIFT) // 即: flag |= data << 3
child->ptrace = flags // <<<<<< 将 PTRACE_O_TRACEFORK 等event, 设置给目标任务task_struct->ptrace字段
}
}
}
}
}2、父进程执行fork/pthread_create，在内核中的kernel_clone实现
SYSCALL_DEFINE0(fork) {
kernel_clone(struct kernel_clone_args *args)
int trace = 0
u64 clone_flags = args->flags
/* Determine whether and which event to report to ptracer. */
if (!(clone_flags & CLONE_UNTRACED)) {
if (clone_flags & CLONE_VFORK)
trace = PTRACE_EVENT_VFORK
else if (args->exit_signal != SIGCHLD) // pthread_create
trace = PTRACE_EVENT_CLONE
else
trace = PTRACE_EVENT_FORK
/******** 判断current是否包含对应trace event *********/
ret = ptrace_event_enabled(struct task_struct *task = current, int event = trace) {
return task->ptrace & PT_EVENT_FLAG(event)
}
if (likely(!ret))
trace = 0
}
struct task_struct *p = copy_process(NULL, trace, NUMA_NO_NODE, args) {
p = dup_task_struct(current, node) // 为新创建的任务生成一个新的task_struct
ptrace_init_task(p, bool ptrace = (clone_flags & CLONE_PTRACE) || trace) // initialize ptrace state for a new child
if (unlikely(ptrace) && current->ptrace)
child->ptrace = current->ptrace /* Set ptrace event to new child task's ptrace, which will be checked later */
__ptrace_link(child, current->parent, current->ptracer_cred)
sigaddset(&child->pending.signal, SIGSTOP) // Add SIGSTOP to new task's pending.signal
}
wake_up_new_task(p) // new task will stop when go back to user space a.k.a do_signal
if (unlikely(trace)) { /* forking complete and child started to run, tell ptracer */
ptrace_event_pid(event = trace, pid) {
message = pid_nr_ns(pid, ns) /* message: new task's pid. 保存在父进程的task_struct->ptrace_message中 */
ptrace_event(event, message)
if (unlikely(ptrace_event_enabled(current, event)))
current->ptrace_message = message
ptrace_notify(exit_code = (event << 8) | SIGTRAP) // event: PTRACE_EVENT_FORK / PTRACE_EVENT_CLONE / PTRACE_EVENT_VFORK
ptrace_do_notify(SIGTRAP, exit_code, CLD_TRAPPED)
ptrace_stop(exit_code, why, 1, &info)
}
}
}3、gdb收集被调试程序fork/pthread_create创建的子进程/子线程信息
linux_process_target::wait_for_event_filtered { // 3) *** gdb获取子线程/子进程 pid信息 ***
/* Always pull all events out of the kernel */
while (event_child == NULL) {
ret = my_waitpid(wstatp)
if (ret > 0) {
linux_process_target::filter_event(int lwpid = ret, int wstat = *wstatp) {
ret = linux_is_extended_waitstatus (wstat) // 该函数用于check wait返回后的入参，是否有event事件, 即: PTRACE_EVENT_FORK、PTRACE_EVENT_CLONE 这类事件
return (linux_ptrace_get_extended_event (wstat) != 0)
return (wstat >> 16)
if (WIFSTOPPED (wstat) && WSTOPSIG (wstat) == SIGTRAP && ret) {
linux_process_target::handle_extended_wait {
int event = linux_ptrace_get_extended_event (wstat)
return (wstat >> 16)
if ((event == PTRACE_EVENT_FORK) || (event == PTRACE_EVENT_VFORK) || (event == PTRACE_EVENT_CLONE)) {
/* Get the pid of the new lwp. */
ptrace (PTRACE_GETEVENTMSG, lwpid_of (event_thr), (PTRACE_TYPE_ARG3) 0, &new_pid)
*(unsigned long *)data = child->ptrace_message
A.K.A
*new_pid = child->ptrace_message // 获取新的task的pid
/* If we haven't already seen the new PID stop, wait for it now. */
if (!pull_pid_from_list (&stopped_pids, new_pid, &status)) {
ret = my_waitpid (new_pid, &status, __WALL)
}
}
if (event == PTRACE_EVENT_FORK || event == PTRACE_EVENT_VFORK) {
ptid = ptid_t (new_pid, new_pid)
/* Add the new process to the tables and clone the breakpoint lists of the parent. */
child_proc = add_linux_process (new_pid, 0)
child_lwp = add_lwp (ptid)
child_lwp->stopped = 1
clone_all_breakpoints (child_thr, event_thr)
...
}
}
}
}
/* Retry until nothing comes out of waitpid. */
continue
}
/* Now that we've pulled all events out of the kernel, resume
* LWPs that don't have an interesting event to report. */
for_each_thread ([this] (thread_info *thread) {
linux_process_target::resume_stopped_resumed_lwps(thread)
resume_one_lwp {
resume_one_lwp_throw
/* 将fork/pthread_create的调用者及新创建的任务重新唤醒 */
ptrace (PTRACE_CONT, lwpid_of (thread),...)
}
}
}
}四、总结
被调试程序tracee创建新进程/线程时, 会给新任务添加SIGSTOP信号，同时将新创建子任务的pid记录到被调试任务的task->ptrace_message中（用于后续gdb通过ptrace GETEVENTMSG来获取新创建任务的pid），然后通过ptrace_stop将自己及新创建的子任务都挂起并通知gdb, 待gdb收集好相关信息后, 会将被调试程序及其创建的子任务再次唤醒。
至于被调试程序如何知道自己执行fork、pthread_create的时候需要通知gdb，是由gdb通过ptrace(PTRACE_SETOPTIONS)进行设置的。由gdb控制，是否需要跟踪被调试程序创建的子进程、子线程。
最后，回答下文章开头的几个问题：
1）被调试程序通过fork/pthread_create创建的子进程/子线程，同样会被gdb跟踪，不过gdb可以控制是否需要跟踪，也可以设置为不跟踪；
2）在kernel_clone中，会将被调试程序以及其创建的子进程/子线程通过不同方式将其挂起，然后通知gdb；
3）gdb通过ptrace(PTRACE_GETEVENTMSG)获取子进程/子线程的pid信息；