Lines Matching full:child
67 void __ptrace_link(struct task_struct *child, struct task_struct *new_parent,
70 BUG_ON(!list_empty(&child->ptrace_entry));
71 list_add(&child->ptrace_entry, &new_parent->ptraced);
72 child->parent = new_parent;
73 child->ptracer_cred = get_cred(ptracer_cred);
82 static void ptrace_link(struct task_struct *child, struct task_struct *new_parent)
84 __ptrace_link(child, new_parent, current_cred());
89 * @child: ptracee to be unlinked
91 * Remove @child from the ptrace list, move it back to the original parent,
115 void __ptrace_unlink(struct task_struct *child)
118 BUG_ON(!child->ptrace);
120 clear_tsk_thread_flag(child, TIF_SYSCALL_TRACE);
122 clear_tsk_thread_flag(child, TIF_SYSCALL_EMU);
125 child->parent = child->real_parent;
126 list_del_init(&child->ptrace_entry);
127 old_cred = child->ptracer_cred;
128 child->ptracer_cred = NULL;
131 spin_lock(&child->sighand->siglock);
132 child->ptrace = 0;
137 task_clear_jobctl_pending(child, JOBCTL_TRAP_MASK);
138 task_clear_jobctl_trapping(child);
142 * @child isn't dead.
144 if (!(child->flags & PF_EXITING) &&
145 (child->signal->flags & SIGNAL_STOP_STOPPED ||
146 child->signal->group_stop_count)) {
147 child->jobctl |= JOBCTL_STOP_PENDING;
156 if (!(child->jobctl & JOBCTL_STOP_SIGMASK))
157 child->jobctl |= SIGSTOP;
162 * @child in the butt. Note that @resume should be used iff @child
166 if (child->jobctl & JOBCTL_STOP_PENDING || task_is_traced(child))
167 ptrace_signal_wake_up(child, true);
169 spin_unlock(&child->sighand->siglock);
214 * @child: ptracee to check for
215 * @ignore_state: don't check whether @child is currently %TASK_TRACED
217 * Check whether @child is being ptraced by %current and ready for further
218 * ptrace operations. If @ignore_state is %false, @child also should be in
219 * %TASK_TRACED state and on return the child is guaranteed to be traced
220 * and not executing. If @ignore_state is %true, @child can be in any
224 * Grabs and releases tasklist_lock and @child->sighand->siglock.
227 * 0 on success, -ESRCH if %child is not ready.
229 static int ptrace_check_attach(struct task_struct *child, bool ignore_state)
235 * possible race where someone else was tracing our child and
237 * we are sure that this is our traced child and that can only
241 if (child->ptrace && child->parent == current) {
242 WARN_ON(child->state == __TASK_TRACED);
244 * child->sighand can't be NULL, release_task()
247 if (ignore_state || ptrace_freeze_traced(child))
253 if (!wait_task_inactive(child, __TASK_TRACED)) {
259 WARN_ON(child->state == __TASK_TRACED);
292 * because setting up the necessary parent/child relationship
420 * will be cleared if the child completes the transition or any
513 * If it's our own child, there is no notification to do. But if our normal
514 * children self-reap, then this child was prevented by ptrace and we must
543 static int ptrace_detach(struct task_struct *child, unsigned int data)
549 ptrace_disable(child);
556 WARN_ON(!child->ptrace || child->exit_state);
561 child->exit_code = data;
562 __ptrace_detach(current, child);
565 proc_ptrace_connector(child, PTRACE_DETACH);
639 static int ptrace_setoptions(struct task_struct *child, unsigned long data)
660 flags = child->ptrace;
663 child->ptrace = flags;
668 static int ptrace_getsiginfo(struct task_struct *child, kernel_siginfo_t *info)
673 if (lock_task_sighand(child, &flags)) {
675 if (likely(child->last_siginfo != NULL)) {
676 copy_siginfo(info, child->last_siginfo);
679 unlock_task_sighand(child, &flags);
684 static int ptrace_setsiginfo(struct task_struct *child, const kernel_siginfo_t *info)
689 if (lock_task_sighand(child, &flags)) {
691 if (likely(child->last_siginfo != NULL)) {
692 copy_siginfo(child->last_siginfo, info);
695 unlock_task_sighand(child, &flags);
700 static int ptrace_peek_siginfo(struct task_struct *child,
725 pending = &child->signal->shared_pending;
727 pending = &child->pending;
734 spin_lock_irq(&child->sighand->siglock);
742 spin_unlock_irq(&child->sighand->siglock);
800 static int ptrace_resume(struct task_struct *child, long request,
809 set_tsk_thread_flag(child, TIF_SYSCALL_TRACE);
811 clear_tsk_thread_flag(child, TIF_SYSCALL_TRACE);
815 set_tsk_thread_flag(child, TIF_SYSCALL_EMU);
817 clear_tsk_thread_flag(child, TIF_SYSCALL_EMU);
823 user_enable_block_step(child);
827 user_enable_single_step(child);
829 user_disable_single_step(child);
847 spin_lock_irq(&child->sighand->siglock);
848 child->exit_code = data;
849 wake_up_state(child, __TASK_TRACED);
851 spin_unlock_irq(&child->sighand->siglock);
903 ptrace_get_syscall_info_entry(struct task_struct *child, struct pt_regs *regs,
910 info->entry.nr = syscall_get_nr(child, regs);
911 syscall_get_arguments(child, regs, args);
920 ptrace_get_syscall_info_seccomp(struct task_struct *child, struct pt_regs *regs,
930 ptrace_get_syscall_info_entry(child, regs, info);
932 info->seccomp.ret_data = child->ptrace_message;
939 ptrace_get_syscall_info_exit(struct task_struct *child, struct pt_regs *regs,
943 info->exit.rval = syscall_get_error(child, regs);
946 info->exit.rval = syscall_get_return_value(child, regs);
953 ptrace_get_syscall_info(struct task_struct *child, unsigned long user_size,
956 struct pt_regs *regs = task_pt_regs(child);
959 .arch = syscall_get_arch(child),
968 * child->last_siginfo because ptrace_freeze_traced()
972 switch (child->last_siginfo ? child->last_siginfo->si_code : 0) {
974 switch (child->ptrace_message) {
976 actual_size = ptrace_get_syscall_info_entry(child, regs,
980 actual_size = ptrace_get_syscall_info_exit(child, regs,
986 actual_size = ptrace_get_syscall_info_seccomp(child, regs,
996 int ptrace_request(struct task_struct *child, long request,
999 bool seized = child->ptrace & PT_SEIZED;
1009 return generic_ptrace_peekdata(child, addr, data);
1012 return generic_ptrace_pokedata(child, addr, data);
1018 ret = ptrace_setoptions(child, data);
1021 ret = put_user(child->ptrace_message, datalp);
1025 ret = ptrace_peek_siginfo(child, addr, data);
1029 ret = ptrace_getsiginfo(child, &siginfo);
1037 ret = ptrace_setsiginfo(child, &siginfo);
1048 if (test_tsk_restore_sigmask(child))
1049 mask = &child->saved_sigmask;
1051 mask = &child->blocked;
1081 spin_lock_irq(&child->sighand->siglock);
1082 child->blocked = new_set;
1083 spin_unlock_irq(&child->sighand->siglock);
1085 clear_tsk_restore_sigmask(child);
1095 * after this request. If @child is already trapped, the
1102 if (unlikely(!seized || !lock_task_sighand(child, &flags)))
1111 if (likely(task_set_jobctl_pending(child, JOBCTL_TRAP_STOP)))
1112 ptrace_signal_wake_up(child, child->jobctl & JOBCTL_LISTENING);
1114 unlock_task_sighand(child, &flags);
1127 if (unlikely(!seized || !lock_task_sighand(child, &flags)))
1130 si = child->last_siginfo;
1132 child->jobctl |= JOBCTL_LISTENING;
1137 if (child->jobctl & JOBCTL_TRAP_NOTIFY)
1138 ptrace_signal_wake_up(child, true);
1141 unlock_task_sighand(child, &flags);
1145 ret = ptrace_detach(child, data);
1150 struct mm_struct *mm = get_task_mm(child);
1186 return ptrace_resume(child, request, data);
1189 if (child->exit_state) /* already dead */
1191 return ptrace_resume(child, request, SIGKILL);
1206 ret = ptrace_regset(child, request, addr, &kiov);
1213 ret = ptrace_get_syscall_info(child, addr, datavp);
1218 ret = seccomp_get_filter(child, addr, datavp);
1222 ret = seccomp_get_metadata(child, addr, datavp);
1233 #define arch_ptrace_attach(child) do { } while (0)
1239 struct task_struct *child;
1249 child = find_get_task_by_vpid(pid);
1250 if (!child) {
1256 ret = ptrace_attach(child, request, addr, data);
1262 arch_ptrace_attach(child);
1266 ret = ptrace_check_attach(child, request == PTRACE_KILL ||
1271 ret = arch_ptrace(child, request, addr, data);
1273 ptrace_unfreeze_traced(child);
1276 put_task_struct(child);
1305 int compat_ptrace_request(struct task_struct *child, compat_long_t request,
1316 ret = ptrace_access_vm(child, addr, &word, sizeof(word),
1326 ret = ptrace_access_vm(child, addr, &data, sizeof(data),
1332 ret = put_user((compat_ulong_t) child->ptrace_message, datap);
1336 ret = ptrace_getsiginfo(child, &siginfo);
1347 ret = ptrace_setsiginfo(child, &siginfo);
1369 ret = ptrace_regset(child, request, addr, &kiov);
1377 ret = ptrace_request(child, request, addr, data);
1386 struct task_struct *child;
1394 child = find_get_task_by_vpid(pid);
1395 if (!child) {
1401 ret = ptrace_attach(child, request, addr, data);
1407 arch_ptrace_attach(child);
1411 ret = ptrace_check_attach(child, request == PTRACE_KILL ||
1414 ret = compat_arch_ptrace(child, request, addr, data);
1416 ptrace_unfreeze_traced(child);
1420 put_task_struct(child);