Commit b5740f4b authored Jan 17, 2012 by Yasunori Goto Committed by Ingo Molnar Jan 27, 2012

sched: Fix ancient race in do_exit()



try_to_wake_up() has a problem which may change status from TASK_DEAD to
TASK_RUNNING in race condition with SMI or guest environment of virtual
machine. As a result, exited task is scheduled() again and panic occurs.

Here is the sequence how it occurs:

 ----------------------------------+-----------------------------
                                   |
            CPU A                  |             CPU B
 ----------------------------------+-----------------------------

TASK A calls exit()....

do_exit()

  exit_mm()
    down_read(mm->mmap_sem);

    rwsem_down_failed_common()

      set TASK_UNINTERRUPTIBLE
      set waiter.task <= task A
      list_add to sem->wait_list
           :
      raw_spin_unlock_irq()
      (I/O interruption occured)

                                      __rwsem_do_wake(mmap_sem)

                                        list_del(&waiter->list);
                                        waiter->task = NULL
                                        wake_up_process(task A)
                                          try_to_wake_up()
                                             (task is still
                                               TASK_UNINTERRUPTIBLE)
                                              p->on_rq is still 1.)

                                              ttwu_do_wakeup()
                                                 (*A)
                                                   :
     (I/O interruption handler finished)

      if (!waiter.task)
          schedule() is not called
          due to waiter.task is NULL.

      tsk->state = TASK_RUNNING

          :
                                              check_preempt_curr();
                                                  :
  task->state = TASK_DEAD
                                              (*B)
                                        <---    set TASK_RUNNING (*C)

     schedule()
     (exit task is running again)
     BUG_ON() is called!
 --------------------------------------------------------

The execution time between (*A) and (*B) is usually very short,
because the interruption is disabled, and setting TASK_RUNNING at (*C)
must be executed before setting TASK_DEAD.

HOWEVER, if SMI is interrupted between (*A) and (*B),
(*C) is able to execute AFTER setting TASK_DEAD!
Then, exited task is scheduled again, and BUG_ON() is called....

If the system works on guest system of virtual machine, the time
between (*A) and (*B) may be also long due to scheduling of hypervisor,
and same phenomenon can occur.

By this patch, do_exit() waits for releasing task->pi_lock which is used
in try_to_wake_up(). It guarantees the task becomes TASK_DEAD after
waking up.

Signed-off-by: Yasunori Goto <y-goto@jp.fujitsu.com>
Acked-by: Oleg Nesterov <oleg@redhat.com>
Signed-off-by: Peter Zijlstra <a.p.zijlstra@chello.nl>
Cc: Linus Torvalds <torvalds@linux-foundation.org>
Cc: Andrew Morton <akpm@linux-foundation.org>
Link: http://lkml.kernel.org/r/20120117174031.3118.E1E9C6FF@jp.fujitsu.com


Signed-off-by: Ingo Molnar <mingo@elte.hu>

parent 71325960

kernel/exit.c

+16 −0

Original line number	Original line	Diff line number	Diff line
	@@ -1038,6 +1038,22 @@ void do_exit(long code)
	if (tsk->nr_dirtied)		if (tsk->nr_dirtied)
	__this_cpu_add(dirty_throttle_leaks, tsk->nr_dirtied);		__this_cpu_add(dirty_throttle_leaks, tsk->nr_dirtied);
	exit_rcu();		exit_rcu();

			/*
			* The setting of TASK_RUNNING by try_to_wake_up() may be delayed
			* when the following two conditions become true.
			* - There is race condition of mmap_sem (It is acquired by
			* exit_mm()), and
			* - SMI occurs before setting TASK_RUNINNG.
			* (or hypervisor of virtual machine switches to other guest)
			* As a result, we may become TASK_RUNNING after becoming TASK_DEAD
			*
			* To avoid it, we have to wait for releasing tsk->pi_lock which
			* is held by try_to_wake_up()
			*/
			smp_mb();
			raw_spin_unlock_wait(&tsk->pi_lock);

	/* causes final put_task_struct in finish_task_switch(). */		/* causes final put_task_struct in finish_task_switch(). */
	tsk->state = TASK_DEAD;		tsk->state = TASK_DEAD;
	tsk->flags \|= PF_NOFREEZE; /* tell freezer to ignore us */		tsk->flags \|= PF_NOFREEZE; /* tell freezer to ignore us */

Admin message