Skip to content

L
linux
Commit 42fea1f3 authored by Linus Torvalds's avatar Linus Torvalds
Browse files
Options

Merge branch 'ptrace-cleanup' of... 

Merge branch 'ptrace-cleanup' of git://git.kernel.org/pub/scm/linux/kernel/git/frob/linux-2.6-utrace

* 'ptrace-cleanup' of git://git.kernel.org/pub/scm/linux/kernel/git/frob/linux-2.6-utrace:
  fix dangling zombie when new parent ignores children
  do_wait: return security_task_wait() error code in place of -ECHILD
  ptrace children revamp
  do_wait reorganization
parents 7259d936 666f164f
Hide whitespace changes
Inline Side-by-side
Showing with 318 additions and 206 deletions
include/linux/init_task.h
View file @ 42fea1f3
...@@ -140,8 +140,8 @@ extern struct group_info init_groups; ...@@ -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
View file @ 42fea1f3
...@@ -1062,12 +1062,6 @@ struct task_struct { ...@@ -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 { ...@@ -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); ...@@ -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
View file @ 42fea1f3
...@@ -71,7 +71,7 @@ static void __unhash_process(struct task_struct *p) ...@@ -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) ...@@ -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) ...@@ -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) ...@@ -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,37 +702,97 @@ static void exit_mm(struct task_struct * tsk) ...@@ -692,37 +702,97 @@ 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 { static void ptrace_exit(struct task_struct *parent, struct list_head *dead)
/* If this child is being traced, then we're the one tracing it {
* anyway, so let go of it. struct task_struct *p, *n;
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.
*/ */
p->ptrace = 0; if (!task_detached(p) && thread_group_empty(p)) {
remove_parent(p); if (!same_thread_group(p->real_parent, parent))
p->parent = p->real_parent; do_notify_parent(p, p->exit_signal);
add_parent(p); else {
if (ign < 0)
ign = ignoring_children(parent);
if (ign)
p->exit_signal = -1;
}
}
if (task_is_traced(p)) { if (task_detached(p)) {
/* /*
* If it was at a trace stop, turn it into * Mark it as in the process of being reaped.
* a normal stop since it's no longer being
* traced.
*/ */
ptrace_untrace(p); p->exit_state = EXIT_DEAD;
list_add(&p->ptrace_entry, dead);
} }
} }
}
/*
* Finish up exit-time ptrace cleanup.
*
* Called without locks.
*/
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) ...@@ -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) ...@@ -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) ...@@ -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;
reparent_thread(p, father, 0);
} else {
/* reparent ptraced task to its 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);
}
list_for_each_entry_safe(p, n, &father->ptrace_children, ptrace_list) {
p->real_parent = reaper; p->real_parent = reaper;
reparent_thread(p, father, 1); if (p->parent == father) {
BUG_ON(p->ptrace);
p->parent = p->real_parent;
}
reparent_thread(p, father);
} }
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, ...@@ -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, ...@@ -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; return err;
if (type != PIDTYPE_PID) return 1;
return 0;
/* This child was explicitly requested, abort */
read_unlock(&tasklist_lock);
return err;
} }
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, ...@@ -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, ...@@ -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, ...@@ -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, ...@@ -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, ...@@ -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, ...@@ -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, ...@@ -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, ...@@ -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, ...@@ -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)) { * tasklist_lock is unlocked and we have a final result.
/* */
* It's stopped now, so it might later retval = tsk_result;
* continue, exit, or stop again. goto end;
*/
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
* exit, stop, or stop and then continue.
*/
flag = 1;
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;
}
} }
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, ...@@ -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
View file @ 42fea1f3
...@@ -1125,8 +1125,8 @@ static struct task_struct *copy_process(unsigned long clone_flags, ...@@ -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, ...@@ -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
View file @ 42fea1f3
...@@ -33,13 +33,9 @@ ...@@ -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) ...@@ -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)) { child->parent = child->real_parent;
list_del_init(&child->ptrace_list); list_del_init(&child->ptrace_entry);
remove_parent(child);
child->parent = child->real_parent;
add_parent(child);
}
if (task_is_traced(child)) if (task_is_traced(child))
ptrace_untrace(child); ptrace_untrace(child);
...@@ -492,15 +484,34 @@ int ptrace_traceme(void) ...@@ -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;
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment
GitLab Nexedi Edition | About GitLab | About Nexedi | 沪ICP备2021021310号-2 | 沪ICP备2021021310号-7