linux OOM处理机制

void out_of_memory(struct zonelist *zonelist, gfp_t gfp_mask,
                int order, nodemask_t *nodemask, bool force_kill)
{
  ...
   //得到分值最高的进程
  p = select_bad_process(&points, totalpages, mpol_mask, force_kill);
  /* Found nothing?!?! Either we hang forever, or we panic. */
        if (!p) {
                dump_header(NULL, gfp_mask, order, NULL, mpol_mask);
                panic("Out of memory and no killable processes...\n");
        }
        if (PTR_ERR(p) != -1UL) {//kill 掉被选中得分最高的进程
                oom_kill_process(p, gfp_mask, order, points, totalpages, NULL,
                                 nodemask, "Out of memory");
                killed = 1;
        }
out:
        /*
         * Give the killed threads a good chance of exiting before trying to
         * allocate memory again.
         */
        if (killed)
                schedule_timeout_killable(1);
}

/*
 * Simple selection loop. We chose the process with the highest
 * number of 'points'.
 *
 * (not docbooked, we don't want this one cluttering up the manual)
 */
static struct task_struct *select_bad_process(unsigned int *ppoints,
                unsigned long totalpages, const nodemask_t *nodemask,
                bool force_kill)
{
        struct task_struct *g, *p;
        struct task_struct *chosen = NULL;
        unsigned long chosen_points = 0;

        rcu_read_lock();
        for_each_process_thread(g, p) {
                unsigned int points;

                switch (oom_scan_process_thread(p, totalpages, nodemask,
                                                force_kill)) {
                case OOM_SCAN_SELECT:
                        chosen = p;
                        chosen_points = ULONG_MAX;
                        /* fall through */
                case OOM_SCAN_CONTINUE:
                        continue;
                case OOM_SCAN_ABORT:
                        rcu_read_unlock();
                        return ERR_PTR(-1UL);
                case OOM_SCAN_OK:
                        break;
                };
                 //计算进程oom score adj分值
                points = oom_badness(p, NULL, nodemask, totalpages);
                if (points > chosen_points) {//得到的分值比之前遍历的进程高
                        chosen = p;//替换得分最高的进程
                        chosen_points = points;
                }
        }
        if (chosen)
                get_task_struct(chosen);
        rcu_read_unlock();
        //若points值很小，此处得到的points将为0,这里不影响选中kill掉的进程,
        //只是作为OOM时的输出信息score值    
        *ppoints = chosen_points * 1000 / totalpages;
        return chosen;
}