cgroup oom引发Pod重建问题分析

static void mem_cgroup_out_of_memory(struct mem_cgroup *memcg, gfp_t gfp_mask,
                                     int order)
{
         ....
         //遍历cgroup下的所有进程
        for_each_mem_cgroup_tree(iter, memcg) {
                struct cgroup *cgroup = iter->css.cgroup;
                struct cgroup_iter it;
                struct task_struct *task;

                cgroup_iter_start(cgroup, &it);
                while ((task = cgroup_iter_next(cgroup, &it))) {
                        switch (oom_scan_process_thread(task, totalpages, NULL,
                                                        false)) {
                        case OOM_SCAN_SELECT:
                                if (chosen)
                                        put_task_struct(chosen);
                                chosen = task;
                                chosen_points = ULONG_MAX;
                                get_task_struct(chosen);
                                /* fall through */
                        case OOM_SCAN_CONTINUE:
                                continue;
                        case OOM_SCAN_ABORT:
                                cgroup_iter_end(cgroup, &it);
                                mem_cgroup_iter_break(memcg, iter);
                                if (chosen)
                                        put_task_struct(chosen);
                                return;
                        case OOM_SCAN_OK:
                                break;
                        };
                        //计算进程oom score adj分值
                        points = oom_badness(task, memcg, NULL, totalpages);
                        if (points > chosen_points) {//得到的分值比之前遍历的进程高
                                if (chosen)
                                        put_task_struct(chosen);
                                chosen = task;//替换得分最高的进程
                                chosen_points = points;
                                get_task_struct(chosen);
                        }
                }
                cgroup_iter_end(cgroup, &it);
        }

        if (!chosen)
                return;

        //若points值很小，此处得到的points将为0,这里不影响选中kill掉的进程,
        //只是作为OOM时的输出信息score值     
        points = chosen_points * 1000 / totalpages;
        //kill掉得分最高的进程，参数chosen
        oom_kill_process(chosen, gfp_mask, order, points, totalpages, memcg,
                         NULL, "Memory cgroup out of memory");
}

unsigned long oom_badness(struct task_struct *p, struct mem_cgroup *memcg,
                          const nodemask_t *nodemask, unsigned long totalpages)
{
        long points;
        long adj;
          //如果进程不能被kill，则得分为0
        if (oom_unkillable_task(p, memcg, nodemask))
                return 0;
        //确认进程是否还存在
        p = find_lock_task_mm(p);
        if (!p)
                return 0;
        //若oom_score_adj为OOM_SCORE_ADJ_MIN则得分为0，表示不选择kill该进程
        adj = (long)p->signal->oom_score_adj;
        if (adj == OOM_SCORE_ADJ_MIN) {
                task_unlock(p);
                return 0;
        }

        /*
         * The baseline for the badness score is the proportion of RAM that each
         * task's rss, pagetable and swap space use.
         */
        //分数=rss+pte数（页表占用的内存）+交换分区内存,rss也就是进程自身使用的物理内存
        points = get_mm_rss(p->mm) + atomic_long_read(&p->mm->nr_ptes) +
                 get_mm_counter(p->mm, MM_SWAPENTS);
        task_unlock(p);

        /*
         * Root processes get 3% bonus, just like the __vm_enough_memory()
         * implementation used by LSMs.
         */
         //若是root用户的进程则比其他用户进程多3% bonus
        if (has_capability_noaudit(p, CAP_SYS_ADMIN))
                points -= (points * 3) / 100;

        /* Normalize to oom_score_adj units */
        adj *= totalpages / 1000;
        points += adj;

        /*
         * Never return 0 for an eligible task regardless of the root bonus and
         * oom_score_adj (oom_score_adj can't be OOM_SCORE_ADJ_MIN here).
         */
        return points > 0 ? points : 1;
}