Merge branch 'akpm' (Andrew's incoming - part two)

Says Andrew:

 "60 patches.  That's good enough for -rc1 I guess.  I have quite a lot
  of detritus to be rechecked, work through maintainers, etc.

 - most of the remains of MM
 - rtc
 - various misc
 - cgroups
 - memcg
 - cpusets
 - procfs
 - ipc
 - rapidio
 - sysctl
 - pps
 - w1
 - drivers/misc
 - aio"

* akpm: (60 commits)
  memcg: replace ss->id_lock with a rwlock
  aio: allocate kiocbs in batches
  drivers/misc/vmw_balloon.c: fix typo in code comment
  drivers/misc/vmw_balloon.c: determine page allocation flag can_sleep outside loop
  w1: disable irqs in critical section
  drivers/w1/w1_int.c: multiple masters used same init_name
  drivers/power/ds2780_battery.c: fix deadlock upon insertion and removal
  drivers/power/ds2780_battery.c: add a nolock function to w1 interface
  drivers/power/ds2780_battery.c: create central point for calling w1 interface
  w1: ds2760 and ds2780, use ida for id and ida_simple_get() to get it
  pps gpio client: add missing dependency
  pps: new client driver using GPIO
  pps: default echo function
  include/linux/dma-mapping.h: add dma_zalloc_coherent()
  sysctl: make CONFIG_SYSCTL_SYSCALL default to n
  sysctl: add support for poll()
  RapidIO: documentation update
  drivers/net/rionet.c: fix ethernet address macros for LE platforms
  RapidIO: fix potential null deref in rio_setup_device()
  RapidIO: add mport driver for Tsi721 bridge
  ...

4 files changed, 52 insertions, 21 deletions

diff --git a/kernel/cgroup.c b/kernel/cgroup.c
index 453100a4159d..d9d5648f3cdc 100644
--- a/kernel/cgroup.c
+++ b/kernel/cgroup.c
@@ -2027,7 +2027,7 @@ int cgroup_attach_proc(struct cgroup *cgrp, struct task_struct *leader)
                 goto out_free_group_list;
 
         /* prevent changes to the threadgroup list while we take a snapshot. */
-        rcu_read_lock();
+        read_lock(&tasklist_lock);
         if (!thread_group_leader(leader)) {
                 /*
                  * a race with de_thread from another thread's exec() may strip
@@ -2036,7 +2036,7 @@ int cgroup_attach_proc(struct cgroup *cgrp, struct task_struct *leader)
                  * throw this task away and try again (from cgroup_procs_write);
                  * this is "double-double-toil-and-trouble-check locking".
                  */
-                rcu_read_unlock();
+                read_unlock(&tasklist_lock);
                 retval = -EAGAIN;
                 goto out_free_group_list;
         }
@@ -2057,7 +2057,7 @@ int cgroup_attach_proc(struct cgroup *cgrp, struct task_struct *leader)
         } while_each_thread(leader, tsk);
         /* remember the number of threads in the array for later. */
         group_size = i;
-        rcu_read_unlock();
+        read_unlock(&tasklist_lock);
 
         /*
          * step 1: check that we can legitimately attach to the cgroup.
@@ -2135,14 +2135,17 @@ int cgroup_attach_proc(struct cgroup *cgrp, struct task_struct *leader)
                 oldcgrp = task_cgroup_from_root(tsk, root);
                 if (cgrp == oldcgrp)
                         continue;
-                /* attach each task to each subsystem */
-                for_each_subsys(root, ss) {
-                        if (ss->attach_task)
-                                ss->attach_task(cgrp, tsk);
-                }
                 /* if the thread is PF_EXITING, it can just get skipped. */
                 retval = cgroup_task_migrate(cgrp, oldcgrp, tsk, true);
-                BUG_ON(retval != 0 && retval != -ESRCH);
+                if (retval == 0) {
+                        /* attach each task to each subsystem */
+                        for_each_subsys(root, ss) {
+                                if (ss->attach_task)
+                                        ss->attach_task(cgrp, tsk);
+                        }
+                } else {
+                        BUG_ON(retval != -ESRCH);
+                }
         }
         /* nothing is sensitive to fork() after this point. */
 
@@ -4880,9 +4883,9 @@ void free_css_id(struct cgroup_subsys *ss, struct cgroup_subsys_state *css)
 
         rcu_assign_pointer(id->css, NULL);
         rcu_assign_pointer(css->id, NULL);
-        spin_lock(&ss->id_lock);
+        write_lock(&ss->id_lock);
         idr_remove(&ss->idr, id->id);
-        spin_unlock(&ss->id_lock);
+        write_unlock(&ss->id_lock);
         kfree_rcu(id, rcu_head);
 }
 EXPORT_SYMBOL_GPL(free_css_id);
@@ -4908,10 +4911,10 @@ static struct css_id *get_new_cssid(struct cgroup_subsys *ss, int depth)
                 error = -ENOMEM;
                 goto err_out;
         }
-        spin_lock(&ss->id_lock);
+        write_lock(&ss->id_lock);
         /* Don't use 0. allocates an ID of 1-65535 */
         error = idr_get_new_above(&ss->idr, newid, 1, &myid);
-        spin_unlock(&ss->id_lock);
+        write_unlock(&ss->id_lock);
 
         /* Returns error when there are no free spaces for new ID.*/
         if (error) {
@@ -4926,9 +4929,9 @@ static struct css_id *get_new_cssid(struct cgroup_subsys *ss, int depth)
         return newid;
 remove_idr:
         error = -ENOSPC;
-        spin_lock(&ss->id_lock);
+        write_lock(&ss->id_lock);
         idr_remove(&ss->idr, myid);
-        spin_unlock(&ss->id_lock);
+        write_unlock(&ss->id_lock);
 err_out:
         kfree(newid);
         return ERR_PTR(error);
@@ -4940,7 +4943,7 @@ static int __init_or_module cgroup_init_idr(struct cgroup_subsys *ss,
 {
         struct css_id *newid;
 
-        spin_lock_init(&ss->id_lock);
+        rwlock_init(&ss->id_lock);
         idr_init(&ss->idr);
 
         newid = get_new_cssid(ss, 0);
@@ -5035,9 +5038,9 @@ css_get_next(struct cgroup_subsys *ss, int id,
                  * scan next entry from bitmap(tree), tmpid is updated after
                  * idr_get_next().
                  */
-                spin_lock(&ss->id_lock);
+                read_lock(&ss->id_lock);
                 tmp = idr_get_next(&ss->idr, &tmpid);
-                spin_unlock(&ss->id_lock);
+                read_unlock(&ss->id_lock);
 
                 if (!tmp)
                         break;
diff --git a/kernel/cpuset.c b/kernel/cpuset.c
index 10131fdaff70..ed0ff443f036 100644
--- a/kernel/cpuset.c
+++ b/kernel/cpuset.c
@@ -949,6 +949,8 @@ static void cpuset_migrate_mm(struct mm_struct *mm, const nodemask_t *from,
 static void cpuset_change_task_nodemask(struct task_struct *tsk,
                                         nodemask_t *newmems)
 {
+        bool masks_disjoint = !nodes_intersects(*newmems, tsk->mems_allowed);
+
 repeat:
         /*
          * Allow tasks that have access to memory reserves because they have
@@ -963,7 +965,6 @@ repeat:
         nodes_or(tsk->mems_allowed, tsk->mems_allowed, *newmems);
         mpol_rebind_task(tsk, newmems, MPOL_REBIND_STEP1);
 
-
         /*
          * ensure checking ->mems_allowed_change_disable after setting all new
          * allowed nodes.
@@ -980,9 +981,11 @@ repeat:
 
         /*
          * Allocation of memory is very fast, we needn't sleep when waiting
-         * for the read-side.
+         * for the read-side.  No wait is necessary, however, if at least one
+         * node remains unchanged.
          */
-        while (ACCESS_ONCE(tsk->mems_allowed_change_disable)) {
+        while (masks_disjoint &&
+                        ACCESS_ONCE(tsk->mems_allowed_change_disable)) {
                 task_unlock(tsk);
                 if (!task_curr(tsk))
                         yield();
diff --git a/kernel/sys.c b/kernel/sys.c
index 58459509b14c..d06c091e0345 100644
--- a/kernel/sys.c
+++ b/kernel/sys.c
@@ -1286,6 +1286,7 @@ SYSCALL_DEFINE2(sethostname, char __user *, name, int, len)
                 memset(u->nodename + len, 0, sizeof(u->nodename) - len);
                 errno = 0;
         }
+        uts_proc_notify(UTS_PROC_HOSTNAME);
         up_write(&uts_sem);
         return errno;
 }
@@ -1336,6 +1337,7 @@ SYSCALL_DEFINE2(setdomainname, char __user *, name, int, len)
                 memset(u->domainname + len, 0, sizeof(u->domainname) - len);
                 errno = 0;
         }
+        uts_proc_notify(UTS_PROC_DOMAINNAME);
         up_write(&uts_sem);
         return errno;
 }
diff --git a/kernel/utsname_sysctl.c b/kernel/utsname_sysctl.c
index a2cd77e70d4d..3b0d48ebf81d 100644
--- a/kernel/utsname_sysctl.c
+++ b/kernel/utsname_sysctl.c
@@ -13,6 +13,7 @@
 #include <linux/uts.h>
 #include <linux/utsname.h>
 #include <linux/sysctl.h>
+#include <linux/wait.h>
 
 static void *get_uts(ctl_table *table, int write)
 {
@@ -51,12 +52,19 @@ static int proc_do_uts_string(ctl_table *table, int write,
         uts_table.data = get_uts(table, write);
         r = proc_dostring(&uts_table,write,buffer,lenp, ppos);
         put_uts(table, write, uts_table.data);
+
+        if (write)
+                proc_sys_poll_notify(table->poll);
+
         return r;
 }
 #else
 #define proc_do_uts_string NULL
 #endif
 
+static DEFINE_CTL_TABLE_POLL(hostname_poll);
+static DEFINE_CTL_TABLE_POLL(domainname_poll);
+
 static struct ctl_table uts_kern_table[] = {
         {
                 .procname       = "ostype",
@@ -85,6 +93,7 @@ static struct ctl_table uts_kern_table[] = {
                 .maxlen         = sizeof(init_uts_ns.name.nodename),
                 .mode           = 0644,
                 .proc_handler   = proc_do_uts_string,
+                .poll           = &hostname_poll,
         },
         {
                 .procname       = "domainname",
@@ -92,6 +101,7 @@ static struct ctl_table uts_kern_table[] = {
                 .maxlen         = sizeof(init_uts_ns.name.domainname),
                 .mode           = 0644,
                 .proc_handler   = proc_do_uts_string,
+                .poll           = &domainname_poll,
         },
         {}
 };
@@ -105,6 +115,19 @@ static struct ctl_table uts_root_table[] = {
         {}
 };
 
+#ifdef CONFIG_PROC_SYSCTL
+/*
+ * Notify userspace about a change in a certain entry of uts_kern_table,
+ * identified by the parameter proc.
+ */
+void uts_proc_notify(enum uts_proc proc)
+{
+        struct ctl_table *table = &uts_kern_table[proc];
+
+        proc_sys_poll_notify(table->poll);
+}
+#endif
+
 static int __init utsname_sysctl_init(void)
 {
         register_sysctl_table(uts_root_table);