forget_original_parent: split out the un-ptrace part
Subsystems (2)
Oleg Nesterov
maintainerPATCH 1/4 forget_original_parent: split out the un-ptrace part
By discussion with Roland.
- Rename ptrace_exit() to exit_ptrace(), and change it to do all the necessary work with ->ptraced list by its own.
- Move this code from exit.c to ptrace.c
- Update the comment in ptrace_detach() to explain the rechecking of the child->ptrace.
include/linux/ptrace.h | 2 - include/linux/sched.h | 5 ++ kernel/exit.c | 95 +++---------------------------------------------- kernel/ptrace.c | 78 +++++++++++++++++++++++++++++++++++++++- 4 files changed, 88 insertions(+), 92 deletions(-)
include/linux/ptrace.h renamed from include/linux/ptrace.h~1_UNTRACE +1 -1
@@ -94,7 +94,7 @@ extern void ptrace_notify(int exit_code)extern void __ptrace_link (struct task_struct *child,struct task_struct *new_parent);extern void __ptrace_unlink (struct task_struct *child); -extern int __ptrace_detach (struct task_struct *tracer,struct task_struct *p); +extern void exit_ptrace (struct task_struct *tracer);extern void ptrace_fork (struct task_struct *task,unsigned long clone_flags);#define PTRACE_MODE_READ 1#define PTRACE_MODE_ATTACH 2
include/linux/sched.h renamed from include/linux/sched.h~1_UNTRACE +5 -0
@@ -2014,6 +2014,11 @@ static inline int thread_group_empty(str#define delay_group_leader (p) \ (thread_group_leader(p) && !thread_group_empty(p)) +static inline int task_detached (struct task_struct *p) +{ +return p->exit_signal ==-1 ; +} +/* * Protects ->fs, ->files, ->mm, ->group_info, ->comm, keyring * subscriptions and synchronises with wait4(). Also used in procfs. Also
kernel/exit.c renamed from kernel/exit.c~1_UNTRACE +6 -89
121 lines not on this page · raw message
kernel/ptrace.c renamed from kernel/ptrace.c~1_UNTRACE +76 -2
98 lines not on this page · raw message
Quoted 1 line
+static inline int
task_detached(struct task_struct *p)
Maybe take the opportunity to make it bool?
Clearly trivial, but a bit of implicit documentation that doesn't hurt.
Review static void forget_original_parent(struc · line 832
Quoted 10 lines
(quoted diff) +4
-1@@ -911,7 +825,10 @@ static void forget_original_parent(struc write_unlock_irq(&tasklist_lock); BUG_ON(!list_empty(&father->children)); - ptrace_exit_finish(father, &ptrace_dead); + list_for_each_entry_safe(p, n, &ptrace_dead, ptrace_entry) { + list_del_init(&p->ptrace_entry); + release_task(p); + } }
I know it's removed by the next patch anyway. But I wouldn't mind a comment in this patch saying "kludge overload of ptrace_entry should go away soon".
Review static void forget_original_parent(struc · line 834
Quoted 2 lines
(quoted diff) +2
-0+/* + * Called with irqs disabled, returns true if childs should reap themselves.
s/childs/children/
Make this bool too.
Review static void forget_original_parent(struc
Quoted 7 lines
(quoted diff) +7
-0+/* + * Detach all tasks we were using ptrace on. + */ +void exit_ptrace(struct task_struct *tracer) +{ + struct task_struct *p, *n; + LIST_HEAD(ptrace_dead);
I think this can do a short-circuit for the common case and avoid the lock:
if (list_empty(&tracer->ptraced)) return;
It might even be worthwhile making it an inline that does the short-circuit check before calling out to ptrace.c at all.
I see your patch 4/4 on this. In fact, I think the short-circuit optimization of these two cases should be two separate patches. They are for the same motivation and the same kind of optimization, but the details of what the race issues might be are quite distinct between the two.
Moreover, the exit_ptrace optimization is removing the new lock overhead we introduce in this patch. The real-child optimization is just a new optimization beyond the status quo. It can really be considered wholly after this whole series (and probably just punted because it gets so hairy).
For the ptrace case, I started out thinking it was trivially clear that no false positives are possible here. The tracer can't do ptrace_attach() or do_fork(), it's exiting. But ptrace_traceme() can sneak in here. (I don't see how release_task() could be a problem at all. Going from nonempty to empty could only cause false negatives--which are always harmless--not false positives.)
You didn't mention ptrace_traceme() in your 4/4 message. Off hand I don't see what keeps it safe when we go to dropping the tasklist_lock between exit_ptrace and changing children's real_parent links. In fact, that seems like a new hole, period--without the short-circuit optimization. Am I overlooking something here?
That seems addressed by e.g.:
kernel/ptrace.c +1 -1
@@ -534,7 +534,7 @@ repeat:* Set the ptrace bit in the process ptrace flags. * Then link us on our parent's ptraced list. */ -if (!ret) { +if (!ret && !(current->real_parent->flags &PF_EXITING )) { current->ptrace |=PT_PTRACED ;__ptrace_link (current, current->real_parent); }
Thanks,
Roland
Oleg Nesterov
maintainerQuoted 5 lines · Roland McGrath
Quoted 2 lines
+static inline int
task_detached(struct task_struct *p)Maybe take the opportunity to make it bool?
Clearly trivial, but a bit of implicit documentation that doesn't hurt.
Agreed. Actually I was going to do this, but forgot.
I'll send the cleanup patch.
Quoted 9 lines
Review
Quoted 4 lines
(quoted diff) +4
-0+void exit_ptrace(struct task_struct *tracer) +{ + struct task_struct *p, *n; + LIST_HEAD(ptrace_dead);I think this can do a short-circuit for the common case and avoid the lock:
if (list_empty(&tracer->ptraced)) return;
4/4 does this, but
Quoted 2 lines
I see your patch 4/4 on this. In fact, I think the short-circuit optimization of these two cases should be two separate patches.
agreed,
Quoted 3 lines
The real-child optimization is just a new
optimization beyond the status quo. It can really be considered wholly after this whole series (and probably just punted because it gets so hairy).
Yes. You can see from the changelog that I don't actually like this optimizatio very much. Because it complicates the code, adds the barrier, but needs thread_group_empty().
If we are going to optimize out tasklist in forget_original_parent(), then I'd prefer http://marc.info/?l=linux-kernel&m=123438710725342
But this needs a fat comment. And I didn't think carefully about this code.
Quoted 2 lines
(I don't
see howrelease_task()could be a problem at all.
This was mostly about forget_original_parent...
But from the _pure theoretical_ pov, it is not correct to assume that list_empty(&tracer->ptraced) == T means that current can not be used somehow as tracee->parent. Another subthread can release a dead tracee.
For example, list_empty(&tracer->ptraced) == T doesn't mean that the STOREs to this task_struct are finished, list_del_init(->ptrace_entry) can still be in progress.
But since we take tasklist before release_task(current) we are safe, even in theory.
Quoted 1 line
You didn't mention
ptrace_traceme()in your 4/4 message.
And I guess you want to know why I didn't...
Because I forgot completely about traceme! Thanks Roland.
Quoted 2 lines
In fact, that seems
like a new hole, period--without the short-circuit optimization.
I think you are right, the current code looks racy too.
kernel/ptrace.c repeat: · line 538
Quoted 11 lines
That seems addressed by e.g.:
kernel/ptrace.c +1
-1@@ -534,7 +534,7 @@ repeat:* Set the ptrace bit in the process ptrace flags. * Then link us on our parent's ptraced list. */ -if (!ret) { +if (!ret && !(current->real_parent->flags &PF_EXITING )) { current->ptrace |=PT_PTRACED ;
Yes sure.
But this means exit_ptrace() must always take tasklist, otherwise we don't have the necessary barriers.
I am still feeling bad, will try to think more later.
Oleg.
Oleg Nesterov
maintainerQuoted 5 lines · Oleg Nesterov
If we are going to optimize out tasklist in
forget_original_parent(), then I'd prefer http://marc.info/?l=linux-kernel&m=123438710725342But this needs a fat comment. And I didn't think carefully about this code.
No, this won't work.
When ->child_reaper exits, it must take tasklist and call find_new_reaper() even if it has no children.
Oleg.
Oleg Nesterov
maintainerArgh. Sorry to all for the noise, I should not have replied today...
Quoted 7 lines · Oleg Nesterov
Quoted 3 lines · Roland McGrath
In fact, that seems
like a new hole, period--without the short-circuit optimization.I think you are right, the current code looks racy too.
No, the current code is fine. And I just misunderstood you.
Oleg.
Quoted 3 lines
But from the
_puretheoretical_pov, it is not correct to assume thatlist_empty(&tracer->ptraced)== T means that current can not be used somehow astracee->parent. Another subthread can release a dead tracee.
I don't follow how that's relevant. If list_empty(), then it was empty or is becoming empty. It can't then become nonempty again (because the thread doing the check is the only one that adds to that list). That's all we're assuming.
Quoted 3 lines
For example,
list_empty(&tracer->ptraced)== T doesn't mean that the STOREs to thistask_structare finished,list_del_init(->ptrace_entry)can still be in progress.
Sure, but so what? The check is to verify that some new list_del* (and related cleanup work, of course) doesn't need to be *started*.
Quoted 12 lines
kernel/ptrace.c repeat: · line 538
Quoted 9 lines
kernel/ptrace.c +1
-1@@ -534,7 +534,7 @@ repeat:* Set the ptrace bit in the process ptrace flags. * Then link us on our parent's ptraced list. */ -if (!ret) { +if (!ret && !(current->real_parent->flags &PF_EXITING )) { current->ptrace |=PT_PTRACED ;Yes sure.
Quoted 2 lines
But this means
exit_ptrace()must always take tasklist, otherwise we don't have the necessary barriers.
Really?
exit_signals(tsk); /* sets PF_EXITING */ /* * tsk->flags are checked in the futex code to protect against * an exiting task cleaning up the robust pi futexes. */ smp_mb();
This is an exactly analogous use, isn't it? So exit_ptrace() just has to follow this same existing barrier. Right?
Thanks,
Roland
Oleg Nesterov
maintainerQuoted 25 lines · Roland McGrath
Quoted 13 lines
kernel/ptrace.c repeat: · line 538
Quoted 10 lines
kernel/ptrace.c +1
-1@@ -534,7 +534,7 @@ repeat:* Set the ptrace bit in the process ptrace flags. * Then link us on our parent's ptraced list. */ -if (!ret) { +if (!ret && !(current->real_parent->flags &PF_EXITING )) { current->ptrace |=PT_PTRACED ;Yes sure.
Quoted 2 lines
But this means
exit_ptrace()must always take tasklist, otherwise we don't have the necessary barriers.Really?
exit_signals(tsk); /* sets PF_EXITING */ /* * tsk->flags are checked in the futex code to protect against * an exiting task cleaning up the robust pi futexes. */ smp_mb();
Quoted 2 lines
This is an exactly analogous use, isn't it? So
exit_ptrace()just has to follow this same existing barrier. Right?
Yes, we do have the barrier between "flags |= PF_EXITING" and "if (list_empty(ptraced))" in exit_ptrace(), but it is not enough.
Because the exiting ->real_parent can both set PF_EXITING and return from exit_ptrace() (without taking tasklist because it sees ->ptraced is empty) right after the child checks ->real_parent->flags & PF_EXITING.
I am still thinking what can we do here (and btw my apologies for delay, some stupid reasons distract me).
Quoted 9 lines
Quoted 3 lines
But from the
_puretheoretical_pov, it is not correct to assume thatlist_empty(&tracer->ptraced)== T means that current can not be used somehow astracee->parent. Another subthread can release a dead tracee.I don't follow how that's relevant. If
list_empty(), then it was empty or is becoming empty. It can't then become nonempty again (because the thread doing the check is the only one that adds to that list). That's all we're assuming.
Quoted 6 lines
Quoted 3 lines
For example,
list_empty(&tracer->ptraced)== T doesn't mean that the STOREs to thistask_structare finished,list_del_init(->ptrace_entry)can still be in progress.Sure, but so what? The check is to verify that some new list_del* (and related cleanup work, of course) doesn't need to be *started*.
Well. I am starting to regret I mentioned this "problem" ;) Because even if I am right (it is very possible I am not), this all is _absolutely_ theoretical. Let me try again to explain what I meant.
First of all, in theory write_lock_irq() does not imply rcu_read_lock().
Now let's suppose that the exiting task T does exit_ptrace(), sees the empty ->ptraced list, and then can do release_task()->call_rcu(put_task_struct) without taking the tasklist_lock on this path.
Let's also suppose that we race with another sub-thread which reaps a zombie tracee and does __ptrace_unlink()->list_del_init(ptrace_entry). __list_del does 1) next->prev = prev and 2) prev->next = next.
Let's suppose 2 is completed, but 1 is not.
T checks list_empty(->ptraced) and sees head->next == head. It proceeds and calls call_rcu(put_task_struct).
Since (in theory!) we do not have rcu_read_lock(), it is possible that task_struct is already freed when 1 write to the memory.
But actually I meant that this is not really safe "in general". Let's suppose we change __ptrace_unlink() so that it does, say, BUG_ON(child->parent->exit_state != 0) before untracing. Yes, sure, this is ugly, but correct. Or BUG_ON(!child->parent->signal), or whatever else.
But this is only correct because T takes tasklist before it actually starts to "destroy" itself.
In short, my point is: even if exit_ptrace() sees list_empty(->ptraced), it is possible that the just-untraced tracee "looks" at us and expects that the former tracer is "alive" enough.
Oleg.