Merge branch 'nfsd-next' of git://linux-nfs.org/~bfields/linux

[~andy/linux] / kernel / cpuset.c

diff --git a/kernel/cpuset.c b/kernel/cpuset.c
index 4772034b4b17062a4506bc4f437c599b8d5f2ac3..e6b1b66afe526acfa2a9ecbfc5bad9da76e8d9b4 100644 (file)
--- a/kernel/cpuset.c
+++ b/kernel/cpuset.c
@@ -974,12 +974,6 @@ static int update_cpumask(struct cpuset *cs, struct cpuset *trialcs,
  *    Temporarilly set tasks mems_allowed to target nodes of migration,
  *    so that the migration code can allocate pages on these nodes.
  *
- *    Call holding cpuset_mutex, so current's cpuset won't change
- *    during this call, as manage_mutex holds off any cpuset_attach()
- *    calls.  Therefore we don't need to take task_lock around the
- *    call to guarantee_online_mems(), as we know no one is changing
- *    our task's cpuset.
- *
  *    While the mm_struct we are migrating is typically from some
  *    other task, the task_struct mems_allowed that we are hacking
  *    is for our current task, which must allocate new pages for that
@@ -996,8 +990,10 @@ static void cpuset_migrate_mm(struct mm_struct *mm, const nodemask_t *from,
 
        do_migrate_pages(mm, from, to, MPOL_MF_MOVE_ALL);
 
+       rcu_read_lock();
        mems_cs = effective_nodemask_cpuset(task_cs(tsk));
        guarantee_online_mems(mems_cs, &tsk->mems_allowed);
+       rcu_read_unlock();
 }
 
 /*
@@ -1731,66 +1727,41 @@ out_unlock:
  * used, list of ranges of sequential numbers, is variable length,
  * and since these maps can change value dynamically, one could read
  * gibberish by doing partial reads while a list was changing.
- * A single large read to a buffer that crosses a page boundary is
- * ok, because the result being copied to user land is not recomputed
- * across a page fault.
  */
-
-static size_t cpuset_sprintf_cpulist(char *page, struct cpuset *cs)
+static int cpuset_common_seq_show(struct seq_file *sf, void *v)
 {
-       size_t count;
+       struct cpuset *cs = css_cs(seq_css(sf));
+       cpuset_filetype_t type = seq_cft(sf)->private;
+       ssize_t count;
+       char *buf, *s;
+       int ret = 0;
 
-       mutex_lock(&callback_mutex);
-       count = cpulist_scnprintf(page, PAGE_SIZE, cs->cpus_allowed);
-       mutex_unlock(&callback_mutex);
-
-       return count;
-}
-
-static size_t cpuset_sprintf_memlist(char *page, struct cpuset *cs)
-{
-       size_t count;
+       count = seq_get_buf(sf, &buf);
+       s = buf;
 
        mutex_lock(&callback_mutex);
-       count = nodelist_scnprintf(page, PAGE_SIZE, cs->mems_allowed);
-       mutex_unlock(&callback_mutex);
-
-       return count;
-}
-
-static ssize_t cpuset_common_file_read(struct cgroup_subsys_state *css,
-                                      struct cftype *cft, struct file *file,
-                                      char __user *buf, size_t nbytes,
-                                      loff_t *ppos)
-{
-       struct cpuset *cs = css_cs(css);
-       cpuset_filetype_t type = cft->private;
-       char *page;
-       ssize_t retval = 0;
-       char *s;
-
-       if (!(page = (char *)__get_free_page(GFP_TEMPORARY)))
-               return -ENOMEM;
-
-       s = page;
 
        switch (type) {
        case FILE_CPULIST:
-               s += cpuset_sprintf_cpulist(s, cs);
+               s += cpulist_scnprintf(s, count, cs->cpus_allowed);
                break;
        case FILE_MEMLIST:
-               s += cpuset_sprintf_memlist(s, cs);
+               s += nodelist_scnprintf(s, count, cs->mems_allowed);
                break;
        default:
-               retval = -EINVAL;
-               goto out;
+               ret = -EINVAL;
+               goto out_unlock;
        }
-       *s++ = '\n';
 
-       retval = simple_read_from_buffer(buf, nbytes, ppos, page, s - page);
-out:
-       free_page((unsigned long)page);
-       return retval;
+       if (s < buf + count - 1) {
+               *s++ = '\n';
+               seq_commit(sf, s - buf);
+       } else {
+               seq_commit(sf, -1);
+       }
+out_unlock:
+       mutex_unlock(&callback_mutex);
+       return ret;
 }
 
 static u64 cpuset_read_u64(struct cgroup_subsys_state *css, struct cftype *cft)
@@ -1847,7 +1818,7 @@ static s64 cpuset_read_s64(struct cgroup_subsys_state *css, struct cftype *cft)
 static struct cftype files[] = {
        {
                .name = "cpus",
-               .read = cpuset_common_file_read,
+               .seq_show = cpuset_common_seq_show,
                .write_string = cpuset_write_resmask,
                .max_write_len = (100U + 6 * NR_CPUS),
                .private = FILE_CPULIST,
@@ -1855,7 +1826,7 @@ static struct cftype files[] = {
 
        {
                .name = "mems",
-               .read = cpuset_common_file_read,
+               .seq_show = cpuset_common_seq_show,
                .write_string = cpuset_write_resmask,
                .max_write_len = (100U + 6 * MAX_NUMNODES),
                .private = FILE_MEMLIST,
@@ -2511,9 +2482,9 @@ int __cpuset_node_allowed_softwall(int node, gfp_t gfp_mask)
 
        task_lock(current);
        cs = nearest_hardwall_ancestor(task_cs(current));
+       allowed = node_isset(node, cs->mems_allowed);
        task_unlock(current);
 
-       allowed = node_isset(node, cs->mems_allowed);
        mutex_unlock(&callback_mutex);
        return allowed;
 }