posix-cpu-timers: use ->sighand instead of ->signal to check the task is alive
PATCH 2/2 posix-cpu-timers: use ->sighand instead of ->signal to check the task is alive
No functional changes.
It doesn't matter which pointer to check under tasklist to ensure the task was not released, ->signal or ->sighand. But we are going to make ->signal refcountable, change the code to use ->sighand.
Sadly, it is not trivial to audit kernel/posix-cpu-timers.c, but it really abuses tasklist_lock. I believe it doesn't need this lock at all, but the changes are not easy to test.
kernel/posix-cpu-timers.c renamed from kernel/posix-cpu-timers.c~2_CPU_TIMERS +6 -6
@@ -297,7 +297,7 @@ int posix_cpu_clock_get(const clockid_t } }else {read_lock (&tasklist_lock); -if (thread_group_leader (p) && p->signal) { +if (thread_group_leader (p) && p->sighand) { error =cpu_clock_sample_group (which_clock, p, &rtn);
@@ -374,7 +374,7 @@ int posix_cpu_timer_del(struct k_itimerif (likely (p !=NULL )) {read_lock (&tasklist_lock); -if (unlikely (p->signal ==NULL )) { +if (unlikely (p->sighand ==NULL )) {/* * We raced with the reaping of the task. * The deletion should have cleared us off the list.
@@ -640,10 +640,10 @@ int posix_cpu_timer_set(struct k_itimerread_lock (&tasklist_lock);/* * We need the tasklist_lock to protect against reaping that -* clears p->signal. If p has just been reaped, we can no +* clears p->sighand. If p has just been reaped, we can no * longer get any information about it at all. */ -if (unlikely (p->signal ==NULL )) { +if (unlikely (p->sighand ==NULL )) {read_unlock (&tasklist_lock);put_task_struct (p); timer->it.cpu.task =NULL ;
@@ -812,7 +812,7 @@ void posix_cpu_timer_get(struct k_itimer clear_dead = p->exit_state; }else {read_lock (&tasklist_lock); -if (unlikely (p->signal ==NULL )) { +if (unlikely (p->sighand ==NULL )) {/* * The process has been reaped. * We can't even collect a sample any more.
@@ -1146,7 +1146,7 @@ void posix_cpu_timer_schedule(struct k_iread_lock (&tasklist_lock);/* arm_timer needs it. */ }else {read_lock (&tasklist_lock); -if (unlikely (p->signal ==NULL )) { +if (unlikely (p->sighand ==NULL )) {/* * The process has been reaped. * We can't even collect a sample any more.
Quoted 3 lines · Oleg Nesterov
Sadly, it is not trivial to audit
kernel/posix-cpu-timers.c, but it really abusestasklist_lock. I believe it doesn't need this lock at all, but the changes are not easy to test.
It uses that to hold of task reaping so ->signal doesn't go away.
If we make ->signal refcountable, and rcu freed along with the tasks I think we can get away without tasklist_lock.
Quoted 7 lines · Peter Zijlstra
Quoted 3 lines · Oleg Nesterov
Sadly, it is not trivial to audit
kernel/posix-cpu-timers.c, but it really abusestasklist_lock. I believe it doesn't need this lock at all, but the changes are not easy to test.It uses that to hold of task reaping so ->signal doesn't go away.
Yes sure, but ->siglock alone is enough (this was not true when this code was written, as far as I know). It is not trivial to remove tasklist completely, but some places are trivial.
Quoted 2 lines
If we make ->signal refcountable, and rcu freed along with the tasks I think we can get away without
tasklist_lock.
I think this is possible even without this change (which is good anyway). But the problem is not only that ->signal can go away. For example, posix_cpu_timer_set/posix_cpu_timer_schedule should not proceed if the task was already released, even if it had the valid ->signal.
Oleg.
Quoted 3 lines
It doesn't matter which pointer to check under tasklist to ensure the task was not released, ->signal or ->sighand. But we are going to make ->signal refcountable, change the code to use ->sighand.
I haven't been following what that's about (signal_struct already has two atomic counts!). Uses here protecting cpu_clock_sample_group() e.g., are around looking at ->signal->foobar, so if ->signal is still there, why not look at it and be able to get the sample in whatever small window this is?
I don't really understand what this new case might mean though. Most things that look at ->signal need to lock it, so access doesn't make any sense if there is no siglock because ->sighand is clear while ->signal is not.
Thanks,
Roland
Quoted 7 lines · Roland McGrath
Quoted 4 lines
It doesn't matter which pointer to check under tasklist to ensure the task was not released, ->signal or ->sighand. But we are going to make ->signal refcountable, change the code to use ->sighand.
I haven't been following what that's about (
signal_structalready has two atomic counts!).
We can't use them as refcounts. You can't bump ->live or ->count without breaking group_dead or exec logic. Perhaps we can use ->count, but then we need other changes. But this has nothing to do with this patch.
The goal is to keep task->signal after release_task(), it will be freed by __put_task_struct(). This allows a lot of simplifications and we can move some fields from task_struct to signal_struct.
But first we should change the code which does
lock(tasklist); if (task->signal != NULL) /* Great! the task was not released */ do_something(task);
This patch does not change the current behaviour, but makes possible to change the "scope" of ->signal without breaking the current code.
Quoted 3 lines
Uses here protecting
cpu_clock_sample_group()e.g., are
around looking at ->signal->foobar, so if ->signal is still there, why not look at it and be able to get the sample in whatever small window this is?
What if arm_timer() sees ->signal != NULL, proceeds, and attaches the timer to the signal_struct of the already dead task? This signal_strcut will be released with the pending timer.
Even cpu_clock_sample_group() is not safe, unless we add other changes.
Quoted 3 lines
I don't really understand what this new case might mean though. Most things that look at ->signal need to lock it, so access doesn't make any sense if there is no siglock because ->sighand is clear while ->signal is not.
For example. __sched_setscheduler() needs to read a single word, signal->rlim[RLIMIT_RTPRIO].rlim_cur, but it has to lock ->siglock to access ->signal.
Worse. Please look at __exit_signal()->task_rq_unlock_wait(). This hack is absolutely stupid and mmust die.
But in any case. Even if we don't need the further changes, do you agree this patch is correct and doesn't change the behaviour?
Oleg.
Quoted 3 lines
We can't use them as refcounts. You can't bump ->live or ->count without breaking
group_deador exec logic. Perhaps we can use ->count, but then we need other changes.
We certainly need to clean up exec anyway.
Quoted 1 line
But this has nothing to do with this patch.
Agreed.
Quoted 3 lines
The goal is to keep
task->signalafterrelease_task(), it will be freed by__put_task_struct(). This allows a lot of simplifications and we can move some fields fromtask_structtosignal_struct.
That sounds fine to me in theory, but I still wonder what the story will be about the use of siglock.
Quoted 1 line
But first we should change the code which does [...]
I did understand the rationale given the signal_struct lifetime change.
Quoted 7 lines
Quoted 3 lines
Uses here protecting
cpu_clock_sample_group()e.g., are
around looking at ->signal->foobar, so if ->signal is still there, why not look at it and be able to get the sample in whatever small window this is?What if
arm_timer()sees ->signal != NULL, proceeds, and attaches the timer to thesignal_structof the already dead task? Thissignal_strcutwill be released with the pending timer.
Of course. I distinctly mentioned the read-only uses (sample).
Quoted 1 line
Even
cpu_clock_sample_group()is not safe, unless we add other changes.
Why? It does no locking and only relies on the signal_struct lifetime.
Quoted 2 lines
But in any case. Even if we don't need the further changes, do you agree this patch is correct and doesn't change the behaviour?
Yes.
Thanks,
Roland
Quoted 6 lines · Roland McGrath
Quoted 4 lines
We can't use them as refcounts. You can't bump ->live or ->count without breaking
group_deador exec logic. Perhaps we can use ->count, but then we need other changes.We certainly need to clean up exec anyway.
Agreed.
Quoted 6 lines
Quoted 3 lines
The goal is to keep
task->signalafterrelease_task(), it will be freed by__put_task_struct(). This allows a lot of simplifications and we can move some fields fromtask_structtosignal_struct.That sounds fine to me in theory, but I still wonder what the story will be about the use of siglock.
I think we should change nothing with the usage of siglock for now?
Quoted 3 lines
Quoted 1 line
But first we should change the code which does [...]
I did understand the rationale given the
signal_structlifetime change.
Ah, sorry for noise then.
Quoted 3 lines
Quoted 1 line
Even
cpu_clock_sample_group()is not safe, unless we add other changes.Why? It does no locking and only relies on the
signal_structlifetime.
Yes, I was wrong, thanks. I forgot we should always have a reference to task_struct anyway.
Oleg.