自学教程：C++ user_disable_single_step函数代码示例

static int ptrace_resume(struct task_struct *child, long request,			 unsigned long data){	if (!valid_signal(data))		return -EIO;	if (request == PTRACE_SYSCALL)		set_tsk_thread_flag(child, TIF_SYSCALL_TRACE);	else		clear_tsk_thread_flag(child, TIF_SYSCALL_TRACE);#ifdef TIF_SYSCALL_EMU	if (request == PTRACE_SYSEMU || request == PTRACE_SYSEMU_SINGLESTEP)		set_tsk_thread_flag(child, TIF_SYSCALL_EMU);	else		clear_tsk_thread_flag(child, TIF_SYSCALL_EMU);#endif	if (is_singleblock(request)) {		if (unlikely(!arch_has_block_step()))			return -EIO;		user_enable_block_step(child);	} else if (is_singlestep(request) || is_sysemu_singlestep(request)) {		if (unlikely(!arch_has_single_step()))			return -EIO;		user_enable_single_step(child);	} else {		user_disable_single_step(child);	}	child->exit_code = data;	wake_up_state(child, __TASK_TRACED);	return 0;}

/* * This function gets called when XOL instruction either gets trapped or * the thread has a fatal signal, so reset the instruction pointer to its * probed address. */void arch_uprobe_abort_xol(struct arch_uprobe *auprobe, struct pt_regs *regs){	struct uprobe_task *utask = current->utask;	current->thread.trap_nr = utask->autask.saved_trap_nr;	instruction_pointer_set(regs, utask->vaddr);	user_disable_single_step(current);}

/* * Called by kernel/ptrace.c when detaching.. */void ptrace_disable(struct task_struct *child){	/*	 * This would be better off in core code, but PTRACE_DETACH has	 * grown its fair share of arch-specific worts and changing it	 * is likely to cause regressions on obscure architectures.	 */	user_disable_single_step(child);}

/* * Called by kernel/ptrace.c when detaching. * * Make sure the single step bit is not set. */voidptrace_disable(struct task_struct *child){	/* Deconfigure SPC and S-bit. */	user_disable_single_step(child);	put_reg(child, PT_SPC, 0);	/* Deconfigure any watchpoints associated with the child. */	deconfigure_bp(child->pid);}

/* * Handle single-step exception. */int reinstall_suspended_bps(struct pt_regs *regs){	struct debug_info *debug_info = &current->thread.debug;	int handled_exception = 0, *kernel_step;	kernel_step = this_cpu_ptr(&stepping_kernel_bp);	/*	 * Called from single-step exception handler.	 * Return 0 if execution can resume, 1 if a SIGTRAP should be	 * reported.	 */	if (user_mode(regs)) {		if (debug_info->bps_disabled) {			debug_info->bps_disabled = 0;			toggle_bp_registers(AARCH64_DBG_REG_BCR, DBG_ACTIVE_EL0, 1);			handled_exception = 1;		}		if (debug_info->wps_disabled) {			debug_info->wps_disabled = 0;			toggle_bp_registers(AARCH64_DBG_REG_WCR, DBG_ACTIVE_EL0, 1);			handled_exception = 1;		}		if (handled_exception) {			if (debug_info->suspended_step) {				debug_info->suspended_step = 0;				/* Allow exception handling to fall-through. */				handled_exception = 0;			} else {				user_disable_single_step(current);			}		}	} else if (*kernel_step != ARM_KERNEL_STEP_NONE) {		toggle_bp_registers(AARCH64_DBG_REG_BCR, DBG_ACTIVE_EL1, 1);		toggle_bp_registers(AARCH64_DBG_REG_WCR, DBG_ACTIVE_EL1, 1);		if (!debug_info->wps_disabled)			toggle_bp_registers(AARCH64_DBG_REG_WCR, DBG_ACTIVE_EL0, 1);		if (*kernel_step != ARM_KERNEL_STEP_SUSPEND) {			kernel_disable_single_step();			handled_exception = 1;		} else {			handled_exception = 0;		}		*kernel_step = ARM_KERNEL_STEP_NONE;	}	return !handled_exception;}

void arch_uprobe_abort_xol(struct arch_uprobe *auprobe, struct pt_regs *regs){	struct uprobe_task *utask = current->utask;	/*	 * Task has received a fatal signal, so reset back to probbed	 * address.	 */	instruction_pointer_set(regs, utask->vaddr);	user_disable_single_step(current);}

int arch_uprobe_post_xol(struct arch_uprobe *auprobe, struct pt_regs *regs){	struct uprobe_task *utask = current->utask;	WARN_ON_ONCE(current->thread.fault_code != UPROBE_INV_FAULT_CODE);	/* Instruction points to execute next to breakpoint address */	instruction_pointer_set(regs, utask->vaddr + 4);	user_disable_single_step(current);	return 0;}

/* * Called after single-stepping. To avoid the SMP problems that can * occur when we temporarily put back the original opcode to * single-step, we single-stepped a copy of the instruction. * * This function prepares to resume execution after the single-step. */int arch_uprobe_post_xol(struct arch_uprobe *auprobe, struct pt_regs *regs){	struct uprobe_task *utask = current->utask;	WARN_ON_ONCE(current->thread.trap_nr != UPROBE_TRAP_NR);	current->thread.trap_nr = utask->autask.saved_trap_nr;	/*	 * On powerpc, except for loads and stores, most instructions	 * including ones that alter code flow (branches, calls, returns)	 * are emulated in the kernel. We get here only if the emulation	 * support doesn't exist and have to fix-up the next instruction	 * to be executed.	 */	regs->nip = utask->vaddr + MAX_UINSN_BYTES;	user_disable_single_step(current);	return 0;}

asmlinkage void do_ri(struct pt_regs *regs){	unsigned long epc_insn;	unsigned long epc = regs->cp0_epc;	read_tsk_long(current, epc, &epc_insn);	if (current->thread.single_step == 1) {		if ((epc == current->thread.addr1) ||		    (epc == current->thread.addr2)) {			user_disable_single_step(current);			force_sig(SIGTRAP, current);			return;		} else			BUG();	} else if ((epc_insn == BREAKPOINT32_INSN) ||		   ((epc_insn & 0x0000FFFF) == 0x7002) ||		   ((epc_insn & 0xFFFF0000) == 0x70020000)) {			force_sig(SIGTRAP, current);			return;	} else {		die_if_kernel("do_ri execution Exception", regs);		force_sig(SIGILL, current);	}}

/* * Called by kernel/ptrace.c when detaching.. */void ptrace_disable(struct task_struct *child){	user_disable_single_step(child);}

/* * Called by kernel/ptrace.c when detaching.. * * Make sure single step bits etc are not set. */voidptrace_disable(struct task_struct *child){	/* make sure the single step bit is not set. */	user_disable_single_step(child);}

void ptrace_disable(struct task_struct *child){	/* Boilerplate - resolves to null inline if no HW single-step */	user_disable_single_step(child);}

//.........这里部分代码省略.........		goto bad_fork_cleanup_namespaces;	retval = copy_thread(clone_flags, stack_start, stack_size, p, regs);	if (retval)		goto bad_fork_cleanup_io;	if (pid != &init_struct_pid) {		retval = -ENOMEM;		pid = alloc_pid(p->nsproxy->pid_ns);		if (!pid)			goto bad_fork_cleanup_io;	}	p->pid = pid_nr(pid);	p->tgid = p->pid;	if (clone_flags & CLONE_THREAD)		p->tgid = current->tgid;	p->set_child_tid = (clone_flags & CLONE_CHILD_SETTID) ? child_tidptr : NULL;	p->clear_child_tid = (clone_flags & CLONE_CHILD_CLEARTID) ? child_tidptr : NULL;#ifdef CONFIG_BLOCK	p->plug = NULL;#endif#ifdef CONFIG_FUTEX	p->robust_list = NULL;#ifdef CONFIG_COMPAT	p->compat_robust_list = NULL;#endif	INIT_LIST_HEAD(&p->pi_state_list);	p->pi_state_cache = NULL;#endif	if ((clone_flags & (CLONE_VM|CLONE_VFORK)) == CLONE_VM)		p->sas_ss_sp = p->sas_ss_size = 0;	user_disable_single_step(p);	clear_tsk_thread_flag(p, TIF_SYSCALL_TRACE);#ifdef TIF_SYSCALL_EMU	clear_tsk_thread_flag(p, TIF_SYSCALL_EMU);#endif	clear_all_latency_tracing(p);		if (clone_flags & CLONE_THREAD)		p->exit_signal = -1;	else if (clone_flags & CLONE_PARENT)		p->exit_signal = current->group_leader->exit_signal;	else		p->exit_signal = (clone_flags & CSIGNAL);	p->pdeath_signal = 0;	p->exit_state = 0;	p->nr_dirtied = 0;	p->nr_dirtied_pause = 128 >> (PAGE_SHIFT - 10);	p->dirty_paused_when = 0;	p->group_leader = p;	INIT_LIST_HEAD(&p->thread_group);	cgroup_fork_callbacks(p);	cgroup_callbacks_done = 1;		write_lock_irq(&tasklist_lock);		if (clone_flags & (CLONE_PARENT|CLONE_THREAD)) {