Merge branch 'ptrace-cleanup' of... (42fea1f3) · Commits · EulixOS / Software / Kernel

include/linux/init_task.h

+2 −2

Original line number	Original line	Diff line number	Diff line
	@@ -140,8 +140,8 @@ extern struct group_info init_groups;
	.nr_cpus_allowed = NR_CPUS, \		.nr_cpus_allowed = NR_CPUS, \
	}, \		}, \
	.tasks = LIST_HEAD_INIT(tsk.tasks), \		.tasks = LIST_HEAD_INIT(tsk.tasks), \
	.ptrace_children= LIST_HEAD_INIT(tsk.ptrace_children), \		.ptraced = LIST_HEAD_INIT(tsk.ptraced), \
	.ptrace_list = LIST_HEAD_INIT(tsk.ptrace_list), \		.ptrace_entry = LIST_HEAD_INIT(tsk.ptrace_entry), \
	.real_parent = &tsk, \		.real_parent = &tsk, \
	.parent = &tsk, \		.parent = &tsk, \
	.children = LIST_HEAD_INIT(tsk.children), \		.children = LIST_HEAD_INIT(tsk.children), \

include/linux/sched.h

+12 −14

Original line number	Original line	Diff line number	Diff line
	@@ -1062,12 +1062,6 @@ struct task_struct {
	#endif		#endif

	struct list_head tasks;		struct list_head tasks;
	/*
	* ptrace_list/ptrace_children forms the list of my children
	* that were stolen by a ptracer.
	*/
	struct list_head ptrace_children;
	struct list_head ptrace_list;

	struct mm_struct mm, active_mm;		struct mm_struct mm, active_mm;

	@@ -1089,18 +1083,25 @@ struct task_struct {
	/*		/*
	* pointers to (original) parent process, youngest child, younger sibling,		* pointers to (original) parent process, youngest child, younger sibling,
	* older sibling, respectively. (p->father can be replaced with		* older sibling, respectively. (p->father can be replaced with
	* p->parent->pid)		* p->real_parent->pid)
	*/		*/
	struct task_struct real_parent; / real parent process (when being debugged) */		struct task_struct real_parent; / real parent process */
	struct task_struct parent; / parent process */		struct task_struct parent; / recipient of SIGCHLD, wait4() reports */
	/*		/*
	* children/sibling forms the list of my children plus the		* children/sibling forms the list of my natural children
	* tasks I'm ptracing.
	*/		*/
	struct list_head children; /* list of my children */		struct list_head children; /* list of my children */
	struct list_head sibling; /* linkage in my parent's children list */		struct list_head sibling; /* linkage in my parent's children list */
	struct task_struct group_leader; / threadgroup leader */		struct task_struct group_leader; / threadgroup leader */

			/*
			* ptraced is the list of tasks this task is using ptrace on.
			* This includes both natural children and PTRACE_ATTACH targets.
			* p->ptrace_entry is p's link on the p->parent->ptraced list.
			*/
			struct list_head ptraced;
			struct list_head ptrace_entry;

	/* PID/PID hash table linkage. */		/* PID/PID hash table linkage. */
	struct pid_link pids[PIDTYPE_MAX];		struct pid_link pids[PIDTYPE_MAX];
	struct list_head thread_group;		struct list_head thread_group;
	@@ -1876,9 +1877,6 @@ extern void wait_task_inactive(struct task_struct * p);
	#define wait_task_inactive(p) do { } while (0)		#define wait_task_inactive(p) do { } while (0)
	#endif		#endif

	#define remove_parent(p) list_del_init(&(p)->sibling)
	#define add_parent(p) list_add_tail(&(p)->sibling,&(p)->parent->children)

	#define next_task(p) list_entry(rcu_dereference((p)->tasks.next), struct task_struct, tasks)		#define next_task(p) list_entry(rcu_dereference((p)->tasks.next), struct task_struct, tasks)

	#define for_each_process(p) \		#define for_each_process(p) \

kernel/exit.c

+277 −174

Original line number	Original line	Diff line number	Diff line
	@@ -71,7 +71,7 @@ static void __unhash_process(struct task_struct *p)
	__get_cpu_var(process_counts)--;		__get_cpu_var(process_counts)--;
	}		}
	list_del_rcu(&p->thread_group);		list_del_rcu(&p->thread_group);
	remove_parent(p);		list_del_init(&p->sibling);
	}		}

	/*		/*
	@@ -152,6 +152,18 @@ static void delayed_put_task_struct(struct rcu_head *rhp)
	put_task_struct(container_of(rhp, struct task_struct, rcu));		put_task_struct(container_of(rhp, struct task_struct, rcu));
	}		}

			/*
			* Do final ptrace-related cleanup of a zombie being reaped.
			*
			* Called with write_lock(&tasklist_lock) held.
			*/
			static void ptrace_release_task(struct task_struct *p)
			{
			BUG_ON(!list_empty(&p->ptraced));
			ptrace_unlink(p);
			BUG_ON(!list_empty(&p->ptrace_entry));
			}

	void release_task(struct task_struct * p)		void release_task(struct task_struct * p)
	{		{
	struct task_struct *leader;		struct task_struct *leader;
	@@ -160,8 +172,7 @@ void release_task(struct task_struct * p)
	atomic_dec(&p->user->processes);		atomic_dec(&p->user->processes);
	proc_flush_task(p);		proc_flush_task(p);
	write_lock_irq(&tasklist_lock);		write_lock_irq(&tasklist_lock);
	ptrace_unlink(p);		ptrace_release_task(p);
	BUG_ON(!list_empty(&p->ptrace_list) \|\| !list_empty(&p->ptrace_children));
	__exit_signal(p);		__exit_signal(p);

	/*		/*
	@@ -315,9 +326,8 @@ static void reparent_to_kthreadd(void)

	ptrace_unlink(current);		ptrace_unlink(current);
	/* Reparent to init */		/* Reparent to init */
	remove_parent(current);
	current->real_parent = current->parent = kthreadd_task;		current->real_parent = current->parent = kthreadd_task;
	add_parent(current);		list_move_tail(&current->sibling, &current->real_parent->children);

	/* Set the exit signal to SIGCHLD so we signal init on exit */		/* Set the exit signal to SIGCHLD so we signal init on exit */
	current->exit_signal = SIGCHLD;		current->exit_signal = SIGCHLD;
	@@ -692,38 +702,98 @@ static void exit_mm(struct task_struct * tsk)
	mmput(mm);		mmput(mm);
	}		}

	static void		/*
	reparent_thread(struct task_struct p, struct task_struct father, int traced)		* Return nonzero if @parent's children should reap themselves.
			*
			* Called with write_lock_irq(&tasklist_lock) held.
			*/
			static int ignoring_children(struct task_struct *parent)
	{		{
	if (p->pdeath_signal)		int ret;
	/* We already hold the tasklist_lock here. */		struct sighand_struct *psig = parent->sighand;
	group_send_sig_info(p->pdeath_signal, SEND_SIG_NOINFO, p);		unsigned long flags;
			spin_lock_irqsave(&psig->siglock, flags);
			ret = (psig->action[SIGCHLD-1].sa.sa_handler == SIG_IGN \|\|
			(psig->action[SIGCHLD-1].sa.sa_flags & SA_NOCLDWAIT));
			spin_unlock_irqrestore(&psig->siglock, flags);
			return ret;
			}

	/* Move the child from its dying parent to the new one. */		/*
	if (unlikely(traced)) {		* Detach all tasks we were using ptrace on.
	/* Preserve ptrace links if someone else is tracing this child. */		* Any that need to be release_task'd are put on the @dead list.
	list_del_init(&p->ptrace_list);		*
	if (ptrace_reparented(p))		* Called with write_lock(&tasklist_lock) held.
	list_add(&p->ptrace_list, &p->real_parent->ptrace_children);
	} else {
	/* If this child is being traced, then we're the one tracing it
	* anyway, so let go of it.
	*/		*/
	p->ptrace = 0;		static void ptrace_exit(struct task_struct parent, struct list_head dead)
	remove_parent(p);		{
	p->parent = p->real_parent;		struct task_struct p, n;
	add_parent(p);		int ign = -1;

			list_for_each_entry_safe(p, n, &parent->ptraced, ptrace_entry) {
			__ptrace_unlink(p);

			if (p->exit_state != EXIT_ZOMBIE)
			continue;

			/*
			* If it's a zombie, our attachedness prevented normal
			* parent notification or self-reaping. Do notification
			* now if it would have happened earlier. If it should
			* reap itself, add it to the @dead list. We can't call
			* release_task() here because we already hold tasklist_lock.
			*
			* If it's our own child, there is no notification to do.
			* But if our normal children self-reap, then this child
			* was prevented by ptrace and we must reap it now.
			*/
			if (!task_detached(p) && thread_group_empty(p)) {
			if (!same_thread_group(p->real_parent, parent))
			do_notify_parent(p, p->exit_signal);
			else {
			if (ign < 0)
			ign = ignoring_children(parent);
			if (ign)
			p->exit_signal = -1;
			}
			}

			if (task_detached(p)) {
			/*
			* Mark it as in the process of being reaped.
			*/
			p->exit_state = EXIT_DEAD;
			list_add(&p->ptrace_entry, dead);
			}
			}
			}

	if (task_is_traced(p)) {
	/*		/*
	* If it was at a trace stop, turn it into		* Finish up exit-time ptrace cleanup.
	* a normal stop since it's no longer being		*
	* traced.		* Called without locks.
	*/		*/
	ptrace_untrace(p);		static void ptrace_exit_finish(struct task_struct *parent,
			struct list_head *dead)
			{
			struct task_struct p, n;

			BUG_ON(!list_empty(&parent->ptraced));

			list_for_each_entry_safe(p, n, dead, ptrace_entry) {
			list_del_init(&p->ptrace_entry);
			release_task(p);
	}		}
	}		}

			static void reparent_thread(struct task_struct p, struct task_struct father)
			{
			if (p->pdeath_signal)
			/* We already hold the tasklist_lock here. */
			group_send_sig_info(p->pdeath_signal, SEND_SIG_NOINFO, p);

			list_move_tail(&p->sibling, &p->real_parent->children);

	/* If this is a threaded reparent there is no need to		/* If this is a threaded reparent there is no need to
	* notify anyone anything has happened.		* notify anyone anything has happened.
	*/		*/
	@@ -737,7 +807,8 @@ reparent_thread(struct task_struct p, struct task_struct father, int traced)
	/* If we'd notified the old parent about this child's death,		/* If we'd notified the old parent about this child's death,
	* also notify the new parent.		* also notify the new parent.
	*/		*/
	if (!traced && p->exit_state == EXIT_ZOMBIE &&		if (!ptrace_reparented(p) &&
			p->exit_state == EXIT_ZOMBIE &&
	!task_detached(p) && thread_group_empty(p))		!task_detached(p) && thread_group_empty(p))
	do_notify_parent(p, p->exit_signal);		do_notify_parent(p, p->exit_signal);

	@@ -754,12 +825,15 @@ reparent_thread(struct task_struct p, struct task_struct father, int traced)
	static void forget_original_parent(struct task_struct *father)		static void forget_original_parent(struct task_struct *father)
	{		{
	struct task_struct p, n, *reaper = father;		struct task_struct p, n, *reaper = father;
	struct list_head ptrace_dead;		LIST_HEAD(ptrace_dead);

	INIT_LIST_HEAD(&ptrace_dead);

	write_lock_irq(&tasklist_lock);		write_lock_irq(&tasklist_lock);

			/*
			* First clean up ptrace if we were using it.
			*/
			ptrace_exit(father, &ptrace_dead);

	do {		do {
	reaper = next_thread(reaper);		reaper = next_thread(reaper);
	if (reaper == father) {		if (reaper == father) {
	@@ -768,58 +842,19 @@ static void forget_original_parent(struct task_struct *father)
	}		}
	} while (reaper->flags & PF_EXITING);		} while (reaper->flags & PF_EXITING);

	/*
	* There are only two places where our children can be:
	*
	* - in our child list
	* - in our ptraced child list
	*
	* Search them and reparent children.
	*/
	list_for_each_entry_safe(p, n, &father->children, sibling) {		list_for_each_entry_safe(p, n, &father->children, sibling) {
	int ptrace;

	ptrace = p->ptrace;

	/* if father isn't the real parent, then ptrace must be enabled */
	BUG_ON(father != p->real_parent && !ptrace);

	if (father == p->real_parent) {
	/* reparent with a reaper, real father it's us */
	p->real_parent = reaper;		p->real_parent = reaper;
	reparent_thread(p, father, 0);		if (p->parent == father) {
	} else {		BUG_ON(p->ptrace);
	/* reparent ptraced task to its real parent */		p->parent = p->real_parent;
	__ptrace_unlink (p);
	if (p->exit_state == EXIT_ZOMBIE && !task_detached(p) &&
	thread_group_empty(p))
	do_notify_parent(p, p->exit_signal);
	}

	/*
	* if the ptraced child is a detached zombie we must collect
	* it before we exit, or it will remain zombie forever since
	* we prevented it from self-reap itself while it was being
	* traced by us, to be able to see it in wait4.
	*/
	if (unlikely(ptrace && p->exit_state == EXIT_ZOMBIE && task_detached(p)))
	list_add(&p->ptrace_list, &ptrace_dead);
	}		}
			reparent_thread(p, father);
	list_for_each_entry_safe(p, n, &father->ptrace_children, ptrace_list) {
	p->real_parent = reaper;
	reparent_thread(p, father, 1);
	}		}

	write_unlock_irq(&tasklist_lock);		write_unlock_irq(&tasklist_lock);
	BUG_ON(!list_empty(&father->children));		BUG_ON(!list_empty(&father->children));
	BUG_ON(!list_empty(&father->ptrace_children));

	list_for_each_entry_safe(p, n, &ptrace_dead, ptrace_list) {
	list_del_init(&p->ptrace_list);
	release_task(p);
	}

			ptrace_exit_finish(father, &ptrace_dead);
	}		}

	/*		/*
	@@ -1180,13 +1215,6 @@ static int eligible_child(enum pid_type type, struct pid *pid, int options,
	return 0;		return 0;
	}		}

	/*
	* Do not consider detached threads that are
	* not ptraced:
	*/
	if (task_detached(p) && !p->ptrace)
	return 0;

	/* Wait for all children (clone and not) if __WALL is set;		/* Wait for all children (clone and not) if __WALL is set;
	* otherwise, wait for clone children only if __WCLONE is		* otherwise, wait for clone children only if __WCLONE is
	* set; otherwise, wait for non-clone children only. (Note:		* set; otherwise, wait for non-clone children only. (Note:
	@@ -1197,14 +1225,10 @@ static int eligible_child(enum pid_type type, struct pid *pid, int options,
	return 0;		return 0;

	err = security_task_wait(p);		err = security_task_wait(p);
	if (likely(!err))		if (err)
	return 1;

	if (type != PIDTYPE_PID)
	return 0;
	/* This child was explicitly requested, abort */
	read_unlock(&tasklist_lock);
	return err;		return err;

			return 1;
	}		}

	static int wait_noreap_copyout(struct task_struct *p, pid_t pid, uid_t uid,		static int wait_noreap_copyout(struct task_struct *p, pid_t pid, uid_t uid,
	@@ -1238,7 +1262,7 @@ static int wait_noreap_copyout(struct task_struct *p, pid_t pid, uid_t uid,
	* the lock and this task is uninteresting. If we return nonzero, we have		* the lock and this task is uninteresting. If we return nonzero, we have
	* released the lock and the system call should return.		* released the lock and the system call should return.
	*/		*/
	static int wait_task_zombie(struct task_struct *p, int noreap,		static int wait_task_zombie(struct task_struct *p, int options,
	struct siginfo __user *infop,		struct siginfo __user *infop,
	int __user stat_addr, struct rusage __user ru)		int __user stat_addr, struct rusage __user ru)
	{		{
	@@ -1246,7 +1270,10 @@ static int wait_task_zombie(struct task_struct *p, int noreap,
	int retval, status, traced;		int retval, status, traced;
	pid_t pid = task_pid_vnr(p);		pid_t pid = task_pid_vnr(p);

	if (unlikely(noreap)) {		if (!likely(options & WEXITED))
			return 0;

			if (unlikely(options & WNOWAIT)) {
	uid_t uid = p->uid;		uid_t uid = p->uid;
	int exit_code = p->exit_code;		int exit_code = p->exit_code;
	int why, status;		int why, status;
	@@ -1396,21 +1423,24 @@ static int wait_task_zombie(struct task_struct *p, int noreap,
	* the lock and this task is uninteresting. If we return nonzero, we have		* the lock and this task is uninteresting. If we return nonzero, we have
	* released the lock and the system call should return.		* released the lock and the system call should return.
	*/		*/
	static int wait_task_stopped(struct task_struct *p,		static int wait_task_stopped(int ptrace, struct task_struct *p,
	int noreap, struct siginfo __user *infop,		int options, struct siginfo __user *infop,
	int __user stat_addr, struct rusage __user ru)		int __user stat_addr, struct rusage __user ru)
	{		{
	int retval, exit_code, why;		int retval, exit_code, why;
	uid_t uid = 0; /* unneeded, required by compiler */		uid_t uid = 0; /* unneeded, required by compiler */
	pid_t pid;		pid_t pid;

			if (!(options & WUNTRACED))
			return 0;

	exit_code = 0;		exit_code = 0;
	spin_lock_irq(&p->sighand->siglock);		spin_lock_irq(&p->sighand->siglock);

	if (unlikely(!task_is_stopped_or_traced(p)))		if (unlikely(!task_is_stopped_or_traced(p)))
	goto unlock_sig;		goto unlock_sig;

	if (!(p->ptrace & PT_PTRACED) && p->signal->group_stop_count > 0)		if (!ptrace && p->signal->group_stop_count > 0)
	/*		/*
	* A group stop is in progress and this is the group leader.		* A group stop is in progress and this is the group leader.
	* We won't report until all threads have stopped.		* We won't report until all threads have stopped.
	@@ -1421,7 +1451,7 @@ static int wait_task_stopped(struct task_struct *p,
	if (!exit_code)		if (!exit_code)
	goto unlock_sig;		goto unlock_sig;

	if (!noreap)		if (!unlikely(options & WNOWAIT))
	p->exit_code = 0;		p->exit_code = 0;

	uid = p->uid;		uid = p->uid;
	@@ -1439,10 +1469,10 @@ static int wait_task_stopped(struct task_struct *p,
	*/		*/
	get_task_struct(p);		get_task_struct(p);
	pid = task_pid_vnr(p);		pid = task_pid_vnr(p);
	why = (p->ptrace & PT_PTRACED) ? CLD_TRAPPED : CLD_STOPPED;		why = ptrace ? CLD_TRAPPED : CLD_STOPPED;
	read_unlock(&tasklist_lock);		read_unlock(&tasklist_lock);

	if (unlikely(noreap))		if (unlikely(options & WNOWAIT))
	return wait_noreap_copyout(p, pid, uid,		return wait_noreap_copyout(p, pid, uid,
	why, exit_code,		why, exit_code,
	infop, ru);		infop, ru);
	@@ -1476,7 +1506,7 @@ static int wait_task_stopped(struct task_struct *p,
	* the lock and this task is uninteresting. If we return nonzero, we have		* the lock and this task is uninteresting. If we return nonzero, we have
	* released the lock and the system call should return.		* released the lock and the system call should return.
	*/		*/
	static int wait_task_continued(struct task_struct *p, int noreap,		static int wait_task_continued(struct task_struct *p, int options,
	struct siginfo __user *infop,		struct siginfo __user *infop,
	int __user stat_addr, struct rusage __user ru)		int __user stat_addr, struct rusage __user ru)
	{		{
	@@ -1484,6 +1514,9 @@ static int wait_task_continued(struct task_struct *p, int noreap,
	pid_t pid;		pid_t pid;
	uid_t uid;		uid_t uid;

			if (!unlikely(options & WCONTINUED))
			return 0;

	if (!(p->signal->flags & SIGNAL_STOP_CONTINUED))		if (!(p->signal->flags & SIGNAL_STOP_CONTINUED))
	return 0;		return 0;

	@@ -1493,7 +1526,7 @@ static int wait_task_continued(struct task_struct *p, int noreap,
	spin_unlock_irq(&p->sighand->siglock);		spin_unlock_irq(&p->sighand->siglock);
	return 0;		return 0;
	}		}
	if (!noreap)		if (!unlikely(options & WNOWAIT))
	p->signal->flags &= ~SIGNAL_STOP_CONTINUED;		p->signal->flags &= ~SIGNAL_STOP_CONTINUED;
	spin_unlock_irq(&p->sighand->siglock);		spin_unlock_irq(&p->sighand->siglock);

	@@ -1519,89 +1552,161 @@ static int wait_task_continued(struct task_struct *p, int noreap,
	return retval;		return retval;
	}		}

			/*
			* Consider @p for a wait by @parent.
			*
			* -ECHILD should be in *@notask_error before the first call.
			* Returns nonzero for a final return, when we have unlocked tasklist_lock.
			* Returns zero if the search for a child should continue;
			* then *@notask_error is 0 if @p is an eligible child,
			* or another error from security_task_wait(), or still -ECHILD.
			*/
			static int wait_consider_task(struct task_struct *parent, int ptrace,
			struct task_struct p, int notask_error,
			enum pid_type type, struct pid *pid, int options,
			struct siginfo __user *infop,
			int __user stat_addr, struct rusage __user ru)
			{
			int ret = eligible_child(type, pid, options, p);
			if (!ret)
			return ret;

			if (unlikely(ret < 0)) {
			/*
			* If we have not yet seen any eligible child,
			* then let this error code replace -ECHILD.
			* A permission error will give the user a clue
			* to look for security policy problems, rather
			* than for mysterious wait bugs.
			*/
			if (*notask_error)
			*notask_error = ret;
			}

			if (likely(!ptrace) && unlikely(p->ptrace)) {
			/*
			* This child is hidden by ptrace.
			* We aren't allowed to see it now, but eventually we will.
			*/
			*notask_error = 0;
			return 0;
			}

			if (p->exit_state == EXIT_DEAD)
			return 0;

			/*
			* We don't reap group leaders with subthreads.
			*/
			if (p->exit_state == EXIT_ZOMBIE && !delay_group_leader(p))
			return wait_task_zombie(p, options, infop, stat_addr, ru);

			/*
			* It's stopped or running now, so it might
			* later continue, exit, or stop again.
			*/
			*notask_error = 0;

			if (task_is_stopped_or_traced(p))
			return wait_task_stopped(ptrace, p, options,
			infop, stat_addr, ru);

			return wait_task_continued(p, options, infop, stat_addr, ru);
			}

			/*
			* Do the work of do_wait() for one thread in the group, @tsk.
			*
			* -ECHILD should be in *@notask_error before the first call.
			* Returns nonzero for a final return, when we have unlocked tasklist_lock.
			* Returns zero if the search for a child should continue; then
			* *@notask_error is 0 if there were any eligible children,
			* or another error from security_task_wait(), or still -ECHILD.
			*/
			static int do_wait_thread(struct task_struct tsk, int notask_error,
			enum pid_type type, struct pid *pid, int options,
			struct siginfo __user infop, int __user stat_addr,
			struct rusage __user *ru)
			{
			struct task_struct *p;

			list_for_each_entry(p, &tsk->children, sibling) {
			/*
			* Do not consider detached threads.
			*/
			if (!task_detached(p)) {
			int ret = wait_consider_task(tsk, 0, p, notask_error,
			type, pid, options,
			infop, stat_addr, ru);
			if (ret)
			return ret;
			}
			}

			return 0;
			}

			static int ptrace_do_wait(struct task_struct tsk, int notask_error,
			enum pid_type type, struct pid *pid, int options,
			struct siginfo __user infop, int __user stat_addr,
			struct rusage __user *ru)
			{
			struct task_struct *p;

			/*
			* Traditionally we see ptrace'd stopped tasks regardless of options.
			*/
			options \|= WUNTRACED;

			list_for_each_entry(p, &tsk->ptraced, ptrace_entry) {
			int ret = wait_consider_task(tsk, 1, p, notask_error,
			type, pid, options,
			infop, stat_addr, ru);
			if (ret)
			return ret;
			}

			return 0;
			}

	static long do_wait(enum pid_type type, struct pid *pid, int options,		static long do_wait(enum pid_type type, struct pid *pid, int options,
	struct siginfo __user infop, int __user stat_addr,		struct siginfo __user infop, int __user stat_addr,
	struct rusage __user *ru)		struct rusage __user *ru)
	{		{
	DECLARE_WAITQUEUE(wait, current);		DECLARE_WAITQUEUE(wait, current);
	struct task_struct *tsk;		struct task_struct *tsk;
	int flag, retval;		int retval;

	add_wait_queue(&current->signal->wait_chldexit,&wait);		add_wait_queue(&current->signal->wait_chldexit,&wait);
	repeat:		repeat:
	/* If there is nothing that can match our critier just get out */		/*
			* If there is nothing that can match our critiera just get out.
			* We will clear @retval to zero if we see any child that might later
			* match our criteria, even if we are not able to reap it yet.
			*/
	retval = -ECHILD;		retval = -ECHILD;
	if ((type < PIDTYPE_MAX) && (!pid \|\| hlist_empty(&pid->tasks[type])))		if ((type < PIDTYPE_MAX) && (!pid \|\| hlist_empty(&pid->tasks[type])))
	goto end;		goto end;

	/*
	* We will set this flag if we see any child that might later
	* match our criteria, even if we are not able to reap it yet.
	*/
	flag = retval = 0;
	current->state = TASK_INTERRUPTIBLE;		current->state = TASK_INTERRUPTIBLE;
	read_lock(&tasklist_lock);		read_lock(&tasklist_lock);
	tsk = current;		tsk = current;
	do {		do {
	struct task_struct *p;		int tsk_result = do_wait_thread(tsk, &retval,
			type, pid, options,
	list_for_each_entry(p, &tsk->children, sibling) {		infop, stat_addr, ru);
	int ret = eligible_child(type, pid, options, p);		if (!tsk_result)
	if (!ret)		tsk_result = ptrace_do_wait(tsk, &retval,
	continue;		type, pid, options,
			infop, stat_addr, ru);
	if (unlikely(ret < 0)) {		if (tsk_result) {
	retval = ret;
	} else if (task_is_stopped_or_traced(p)) {
	/*
	* It's stopped now, so it might later
	* continue, exit, or stop again.
	*/
	flag = 1;
	if (!(p->ptrace & PT_PTRACED) &&
	!(options & WUNTRACED))
	continue;

	retval = wait_task_stopped(p,
	(options & WNOWAIT), infop,
	stat_addr, ru);
	} else if (p->exit_state == EXIT_ZOMBIE &&
	!delay_group_leader(p)) {
	/*
	* We don't reap group leaders with subthreads.
	*/
	if (!likely(options & WEXITED))
	continue;
	retval = wait_task_zombie(p,
	(options & WNOWAIT), infop,
	stat_addr, ru);
	} else if (p->exit_state != EXIT_DEAD) {
	/*		/*
	* It's running now, so it might later		* tasklist_lock is unlocked and we have a final result.
	* exit, stop, or stop and then continue.
	*/		*/
	flag = 1;		retval = tsk_result;
	if (!unlikely(options & WCONTINUED))
	continue;
	retval = wait_task_continued(p,
	(options & WNOWAIT), infop,
	stat_addr, ru);
	}
	if (retval != 0) /* tasklist_lock released */
	goto end;
	}
	if (!flag) {
	list_for_each_entry(p, &tsk->ptrace_children,
	ptrace_list) {
	flag = eligible_child(type, pid, options, p);
	if (!flag)
	continue;
	if (likely(flag > 0))
	break;
	retval = flag;
	goto end;		goto end;
	}		}
	}
	if (options & __WNOTHREAD)		if (options & __WNOTHREAD)
	break;		break;
	tsk = next_thread(tsk);		tsk = next_thread(tsk);
	@@ -1609,16 +1714,14 @@ static long do_wait(enum pid_type type, struct pid *pid, int options,
	} while (tsk != current);		} while (tsk != current);
	read_unlock(&tasklist_lock);		read_unlock(&tasklist_lock);

	if (flag) {		if (!retval && !(options & WNOHANG)) {
	if (options & WNOHANG)
	goto end;
	retval = -ERESTARTSYS;		retval = -ERESTARTSYS;
	if (signal_pending(current))		if (!signal_pending(current)) {
	goto end;
	schedule();		schedule();
	goto repeat;		goto repeat;
	}		}
	retval = -ECHILD;		}

	end:		end:
	current->state = TASK_RUNNING;		current->state = TASK_RUNNING;
	remove_wait_queue(&current->signal->wait_chldexit,&wait);		remove_wait_queue(&current->signal->wait_chldexit,&wait);

kernel/fork.c

+3 −3

Original line number	Original line	Diff line number	Diff line
	@@ -1125,8 +1125,8 @@ static struct task_struct *copy_process(unsigned long clone_flags,
	*/		*/
	p->group_leader = p;		p->group_leader = p;
	INIT_LIST_HEAD(&p->thread_group);		INIT_LIST_HEAD(&p->thread_group);
	INIT_LIST_HEAD(&p->ptrace_children);		INIT_LIST_HEAD(&p->ptrace_entry);
	INIT_LIST_HEAD(&p->ptrace_list);		INIT_LIST_HEAD(&p->ptraced);

	/* Now that the task is set up, run cgroup callbacks if		/* Now that the task is set up, run cgroup callbacks if
	* necessary. We need to run them before the task is visible		* necessary. We need to run them before the task is visible
	@@ -1198,7 +1198,7 @@ static struct task_struct *copy_process(unsigned long clone_flags,
	}		}

	if (likely(p->pid)) {		if (likely(p->pid)) {
	add_parent(p);		list_add_tail(&p->sibling, &p->real_parent->children);
	if (unlikely(p->ptrace & PT_PTRACED))		if (unlikely(p->ptrace & PT_PTRACED))
	__ptrace_link(p, current->parent);		__ptrace_link(p, current->parent);

kernel/ptrace.c

+24 −13

Original line number	Original line	Diff line number	Diff line
	@@ -33,13 +33,9 @@
	*/		*/
	void __ptrace_link(struct task_struct child, struct task_struct new_parent)		void __ptrace_link(struct task_struct child, struct task_struct new_parent)
	{		{
	BUG_ON(!list_empty(&child->ptrace_list));		BUG_ON(!list_empty(&child->ptrace_entry));
	if (child->parent == new_parent)		list_add(&child->ptrace_entry, &new_parent->ptraced);
	return;
	list_add(&child->ptrace_list, &child->parent->ptrace_children);
	remove_parent(child);
	child->parent = new_parent;		child->parent = new_parent;
	add_parent(child);
	}		}

	/*		/*
	@@ -73,12 +69,8 @@ void __ptrace_unlink(struct task_struct *child)
	BUG_ON(!child->ptrace);		BUG_ON(!child->ptrace);

	child->ptrace = 0;		child->ptrace = 0;
	if (ptrace_reparented(child)) {
	list_del_init(&child->ptrace_list);
	remove_parent(child);
	child->parent = child->real_parent;		child->parent = child->real_parent;
	add_parent(child);		list_del_init(&child->ptrace_entry);
	}

	if (task_is_traced(child))		if (task_is_traced(child))
	ptrace_untrace(child);		ptrace_untrace(child);
	@@ -492,15 +484,34 @@ int ptrace_traceme(void)
	/*		/*
	* Are we already being traced?		* Are we already being traced?
	*/		*/
			repeat:
	task_lock(current);		task_lock(current);
	if (!(current->ptrace & PT_PTRACED)) {		if (!(current->ptrace & PT_PTRACED)) {
			/*
			* See ptrace_attach() comments about the locking here.
			*/
			unsigned long flags;
			if (!write_trylock_irqsave(&tasklist_lock, flags)) {
			task_unlock(current);
			do {
			cpu_relax();
			} while (!write_can_lock(&tasklist_lock));
			goto repeat;
			}

	ret = security_ptrace(current->parent, current,		ret = security_ptrace(current->parent, current,
	PTRACE_MODE_ATTACH);		PTRACE_MODE_ATTACH);

	/*		/*
	* Set the ptrace bit in the process ptrace flags.		* Set the ptrace bit in the process ptrace flags.
			* Then link us on our parent's ptraced list.
	*/		*/
	if (!ret)		if (!ret) {
	current->ptrace \|= PT_PTRACED;		current->ptrace \|= PT_PTRACED;
			__ptrace_link(current, current->real_parent);
			}

			write_unlock_irqrestore(&tasklist_lock, flags);
	}		}
	task_unlock(current);		task_unlock(current);
	return ret;		return ret;