p71924506
/
linux_old1
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

mm, oom: tighten task_will_free_mem() locking 

"mm, oom: fortify task_will_free_mem" has dropped task_lock around
task_will_free_mem in oom_kill_process bacause it assumed that a
potential race when the selected task exits will not be a problem as the
oom_reaper will call exit_oom_victim.

Tetsuo was objecting that nommu doesn't have oom_reaper so the race
would be still possible.  The code would be racy and lockup prone
theoretically in other aspects without the oom reaper anyway so I didn't
considered this a big deal.  But it seems that further changes I am
planning in this area will benefit from stable task->mm in this path as
well.  So let's drop find_lock_task_mm from task_will_free_mem and call
it from under task_lock as we did previously.  Just pull the task->mm !=
NULL check inside the function.

Link: http://lkml.kernel.org/r/1467201562-6709-1-git-send-email-mhocko@kernel.org
Signed-off-by: Michal Hocko <mhocko@suse.com>
Cc: Tetsuo Handa <penguin-kernel@I-love.SAKURA.ne.jp>
Cc: Oleg Nesterov <oleg@redhat.com>
Cc: Vladimir Davydov <vdavydov@parallels.com>
Cc: David Rientjes <rientjes@google.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
This commit is contained in:
Michal Hocko 2016-07-28 15:45:04 -07:00 committed by Linus Torvalds
parent a373966d1f
commit 091f362c53
1 changed files with 17 additions and 28 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

45
mm/oom_kill.c
View File

@ -757,45 +757,35 @@ static inline bool __task_will_free_mem(struct task_struct *task)
* Checks whether the given task is dying or exiting and likely to * Checks whether the given task is dying or exiting and likely to
* release its address space. This means that all threads and processes * release its address space. This means that all threads and processes
* sharing the same mm have to be killed or exiting. * sharing the same mm have to be killed or exiting.
* Caller has to make sure that task->mm is stable (hold task_lock or
* it operates on the current).
*/ */
bool task_will_free_mem(struct task_struct *task) bool task_will_free_mem(struct task_struct *task)
{ {
struct mm_struct *mm; struct mm_struct *mm = task->mm;
struct task_struct *p; struct task_struct *p;
bool ret; bool ret;
/*
* Skip tasks without mm because it might have passed its exit_mm and
* exit_oom_victim. oom_reaper could have rescued that but do not rely
* on that for now. We can consider find_lock_task_mm in future.
*/
if (!mm)
return false;
if (!__task_will_free_mem(task)) if (!__task_will_free_mem(task))
return false; return false;
/*
* If the process has passed exit_mm we have to skip it because
* we have lost a link to other tasks sharing this mm, we do not
* have anything to reap and the task might then get stuck waiting
* for parent as zombie and we do not want it to hold TIF_MEMDIE
*/
p = find_lock_task_mm(task);
if (!p)
return false;
mm = p->mm;
/* /*
* This task has already been drained by the oom reaper so there are * This task has already been drained by the oom reaper so there are
* only small chances it will free some more * only small chances it will free some more
*/ */
if (test_bit(MMF_OOM_REAPED, &mm->flags)) { if (test_bit(MMF_OOM_REAPED, &mm->flags))
task_unlock(p);
return false; return false;
}
if (atomic_read(&mm->mm_users) <= 1) { if (atomic_read(&mm->mm_users) <= 1)
task_unlock(p);
return true; return true;
}
/* pin the mm to not get freed and reused */
atomic_inc(&mm->mm_count);
task_unlock(p);
/* /*
* This is really pessimistic but we do not have any reliable way * This is really pessimistic but we do not have any reliable way
@ -812,7 +802,6 @@ bool task_will_free_mem(struct task_struct *task)
break; break;
} }
rcu_read_unlock(); rcu_read_unlock();
mmdrop(mm);
return ret; return ret;
} }
@ -838,12 +827,15 @@ void oom_kill_process(struct oom_control *oc, struct task_struct *p,
* If the task is already exiting, don't alarm the sysadmin or kill * If the task is already exiting, don't alarm the sysadmin or kill
* its children or threads, just set TIF_MEMDIE so it can die quickly * its children or threads, just set TIF_MEMDIE so it can die quickly
*/ */
task_lock(p);
if (task_will_free_mem(p)) { if (task_will_free_mem(p)) {
mark_oom_victim(p); mark_oom_victim(p);
wake_oom_reaper(p); wake_oom_reaper(p);
task_unlock(p);
put_task_struct(p); put_task_struct(p);
return; return;
} }
task_unlock(p);
if (__ratelimit(&oom_rs)) if (__ratelimit(&oom_rs))
dump_header(oc, p); dump_header(oc, p);
@ -1014,11 +1006,8 @@ bool out_of_memory(struct oom_control *oc)
* If current has a pending SIGKILL or is exiting, then automatically * If current has a pending SIGKILL or is exiting, then automatically
* select it. The goal is to allow it to allocate so that it may * select it. The goal is to allow it to allocate so that it may
* quickly exit and free its memory. * quickly exit and free its memory.
*
* But don't select if current has already released its mm and cleared
* TIF_MEMDIE flag at exit_mm(), otherwise an OOM livelock may occur.
*/ */
if (current->mm && task_will_free_mem(current)) { if (task_will_free_mem(current)) {
mark_oom_victim(current); mark_oom_victim(current);
wake_oom_reaper(current); wake_oom_reaper(current);
return true; return true;