update_tasks_nodemask

/**
 * update_tasks_nodemask - Update the nodemasks of tasks in the cpuset.
 * @cs: the cpuset in which each task's mems_allowed mask needs to be changed
 *
 * Iterate through each task of @cs updating its mems_allowed to the
 * effective cpuset's.  As this function is called with cpuset_mutex held,
 * cpuset membership stays stable.
 */
static void update_tasks_nodemask(struct cpuset *cs)
{
    static nodemask_t newmems;  /* protected by cpuset_mutex */
    struct css_task_iter it;
    struct task_struct *task;
 
    cpuset_being_rebound = cs;      /* causes mpol_dup() rebind */
 
    guarantee_online_mems(cs, &newmems);
 
    /*
     * The mpol_rebind_mm() call takes mmap_sem, which we couldn't
     * take while holding tasklist_lock.  Forks can happen - the
     * mpol_dup() cpuset_being_rebound check will catch such forks,
     * and rebind their vma mempolicies too.  Because we still hold
     * the global cpuset_mutex, we know that no other rebind effort
     * will be contending for the global variable cpuset_being_rebound.
     * It's ok if we rebind the same mm twice; mpol_rebind_mm()
     * is idempotent.  Also migrate pages in each mm to new nodes.
     */
    css_task_iter_start(&cs->css, 0, &it);
    while ((task = css_task_iter_next(&it))) {
        struct mm_struct *mm;
        bool migrate;
 
        cpuset_change_task_nodemask(task, &newmems);
 
        mm = get_task_mm(task);
        if (!mm)
            continue;
 
        migrate = is_memory_migrate(cs);
 
        mpol_rebind_mm(mm, &cs->mems_allowed);
        if (migrate)
            cpuset_migrate_mm(mm, &cs->old_mems_allowed, &newmems);
        else
            mmput(mm);
    }
    css_task_iter_end(&it);
 
    /*
     * All the tasks' nodemasks have been updated, update
     * cs->old_mems_allowed.
     */
    cs->old_mems_allowed = newmems;
 
    /* We're done rebinding vmas to this cpuset's new mems_allowed. */
    cpuset_being_rebound = NULL;
}
函数源码
