do_pages

/*
 * Migrate an array of page address onto an array of nodes and fill
 * the corresponding array of status.
 */
static int do_pages_move(struct mm_struct *mm, nodemask_t task_nodes,
             unsigned long nr_pages,
             const void __user * __user *pages,
             const int __user *nodes,
             int __user *status, int flags)
{
    int current_node = NUMA_NO_NODE;
    LIST_HEAD(pagelist);
    int start, i;
    int err = 0, err1;
 
    migrate_prep();
 
    for (i = start = 0; i < nr_pages; i++) {
        const void __user *p;
        unsigned long addr;
        int node;
 
        err = -EFAULT;
        if (get_user(p, pages + i))
            goto out_flush;
        if (get_user(node, nodes + i))
            goto out_flush;
        addr = (unsigned long)untagged_addr(p);
 
        err = -ENODEV;
        if (node < 0 || node >= MAX_NUMNODES)
            goto out_flush;
        if (!node_state(node, N_MEMORY))
            goto out_flush;
 
        err = -EACCES;
        if (!node_isset(node, task_nodes))
            goto out_flush;
 
        if (current_node == NUMA_NO_NODE) {
            current_node = node;
            start = i;
        } else if (node != current_node) {
            err = do_move_pages_to_node(mm, &pagelist, current_node);
            if (err) {
                /*
                 * Positive err means the number of failed
                 * pages to migrate.  Since we are going to
                 * abort and return the number of non-migrated
                 * pages, so need to incude the rest of the
                 * nr_pages that have not been attempted as
                 * well.
                 */
                if (err > 0)
                    err += nr_pages - i - 1;
                goto out;
            }
            err = store_status(status, start, current_node, i - start);
            if (err)
                goto out;
            start = i;
            current_node = node;
        }
 
        /*
         * Errors in the page lookup or isolation are not fatal and we simply
         * report them via status
         */
        err = add_page_for_migration(mm, addr, current_node,
                &pagelist, flags & MPOL_MF_MOVE_ALL);
 
        if (!err) {
            /* The page is already on the target node */
            err = store_status(status, i, current_node, 1);
            if (err)
                goto out_flush;
            continue;
        } else if (err > 0) {
            /* The page is successfully queued for migration */
            continue;
        }
 
        err = store_status(status, i, err, 1);
        if (err)
            goto out_flush;
 
        err = do_move_pages_to_node(mm, &pagelist, current_node);
        if (err) {
            if (err > 0)
                err += nr_pages - i - 1;
            goto out;
        }
        if (i > start) {
            err = store_status(status, start, current_node, i - start);
            if (err)
                goto out;
        }
        current_node = NUMA_NO_NODE;
    }
out_flush:
    if (list_empty(&pagelist))
        return err;
 
    /* Make sure we do not overwrite the existing error */
    err1 = do_move_pages_to_node(mm, &pagelist, current_node);
    /*
     * Don't have to report non-attempted pages here since:
     *     - If the above loop is done gracefully all pages have been
     *       attempted.
     *     - If the above loop is aborted it means a fatal error
     *       happened, should return ret.
     */
    if (!err1)
        err1 = store_status(status, start, current_node, i - start);
    if (err >= 0)
        err = err1;
out:
    return err;
}
函数源码
