Skip to contentSkip to conversation

sched: fix TASK_WAKEKILL vs SIGKILL race

PATCH In review Oleg Nesterov 2 participants 3 messages Jun 8, 2008 – Jun 28, 2008 Scheduler

lore
Share & tools
lore
#0 lore raw

PATCH 1/3 sched: fix TASK_WAKEKILL vs SIGKILL race

schedule() has the special "TASK_INTERRUPTIBLE && signal_pending()" case, this allows us to do

	current->state = TASK_INTERRUPTIBLE;
	schedule();

without fear to sleep with pending signal.

However, the code like

	current->state = TASK_KILLABLE;
	schedule();

is not right, schedule() doesn't take TASK_WAKEKILL into account. This means that mutex_lock_killable(), wait_for_completion_killable(), down_killable(), schedule_timeout_killable() can miss SIGKILL (and btw the second SIGKILL has no effect).

Introduce the new helper, signal_pending_state(), and change schedule() to use it. Hopefully it will have more users, that is why the task's state is passed separately.

Note this "__TASK_STOPPED | __TASK_TRACED" check in signal_pending_state(). This is needed to preserve the current behaviour (ptrace_notify). I hope this check will be removed soon, but this (afaics good) change needs the separate discussion.

The fast path is "(state & (INTERRUPTIBLE | WAKEKILL)) + signal_pending(p)", basically the same that schedule() does now. However, this patch of course bloats schedule().

 include/linux/sched.h |   13 +++++++++++++
 kernel/sched.c        |    6 ++----
 2 files changed, 15 insertions(+), 4 deletions(-)
include/linux/sched.h renamed from include/linux/sched.h~1_SP_STATE +13 -0
@@ -2027,6 +2027,19 @@ static inline int fatal_signal_pending(s
 	return signal_pending(p) && __fatal_signal_pending(p);
 }
 
+static inline int signal_pending_state(long state, struct task_struct *p)
+{
+	if (!(state & (TASK_INTERRUPTIBLE | TASK_WAKEKILL)))
+		return 0;
+	if (!signal_pending(p))
+		return 0;
+
+	if (state & (__TASK_STOPPED | __TASK_TRACED))
+		return 0;
+
+	return (state & TASK_INTERRUPTIBLE) || __fatal_signal_pending(p);
+}
+
 static inline int need_resched(void)
 {
 	return unlikely(test_tsk_need_resched(current));
kernel/sched.c renamed from kernel/sched.c~1_SP_STATE +2 -4
@@ -4510,12 +4510,10 @@ need_resched_nonpreemptible:
 	clear_tsk_need_resched(prev);
 
 	if (prev->state && !(preempt_count() & PREEMPT_ACTIVE)) {
-		if (unlikely((prev->state & TASK_INTERRUPTIBLE) &&
-				signal_pending(prev))) {
+		if (unlikely(signal_pending_state(prev->state, prev)))
 			prev->state = TASK_RUNNING;
-		} else {
+		else
 			deactivate_task(rq, prev, 1);
-		}
 		switch_count = &prev->nvcsw;
 	}
 
#1 lore raw

I was also concerned about perturbing the schedule() hot path with the original patch. With this version making signal_pending_state() inline, I think it's good.

Quoted 4 lines

Note this "__TASK_STOPPED | __TASK_TRACED" check in signal_pending_state(). This is needed to preserve the current behaviour (ptrace_notify). I hope this check will be removed soon, but this (afaics good) change needs the separate discussion.

Agreed. I think it might actually already be safe to drop it, but we can get to that after this settles.

Thanks,
Roland

#2 lore raw
Quoted 1 line · Roland McGrath

^^^^^
Oops, something is wrong! I received this message today, 06/28.

Quoted 7 lines
Quoted 4 lines

Note this "__TASK_STOPPED | __TASK_TRACED" check in signal_pending_state(). This is needed to preserve the current behaviour (ptrace_notify). I hope this check will be removed soon, but this (afaics good) change needs the separate discussion.

Agreed. I think it might actually already be safe to drop it, but we can get to that after this settles.

Great! I'll re-send the patch which drops it in a minute.

Could you also look at other patches?

	[PATCH 2/3] ptrace: never sleep in TASK_TRACED if SIGKILL'ed
	http://marc.info/?l=linux-kernel&m=121362601402886

	[PATCH 3/3] ptrace: kill may_ptrace_stop()
	http://marc.info/?l=linux-kernel&m=121362601702897

I think ptrace_stop() really needs changes. But I don't know what is the supposed behaviour of PT_TRACE_EXIT. Should we sleep even if the task was killed? Should we sleep if the thread was killed because another one does exit_group() or exec() ?

We can use "SIGNAL_GROUP_EXIT && (group_exit_code & 0x7f)" instead of signal_group_exit() to be sure that task was killed by the fatal signal.

Oleg.