cpuset: remove sched domain hooks from cpusets

Remove the cpuset hooks that defined sched domains depending on the setting
of the 'cpu_exclusive' flag.

The cpu_exclusive flag can only be set on a child if it is set on the
parent.

This made that flag painfully unsuitable for use as a flag defining a
partitioning of a system.

It was entirely unobvious to a cpuset user what partitioning of sched
domains they would be causing when they set that one cpu_exclusive bit on
one cpuset, because it depended on what CPUs were in the remainder of that
cpusets siblings and child cpusets, after subtracting out other
cpu_exclusive cpusets.

Furthermore, there was no way on production systems to query the
result.

Using the cpu_exclusive flag for this was simply wrong from the get go.

Fortunately, it was sufficiently borked that so far as I know, almost no
successful use has been made of this.  One real time group did use it to
affectively isolate CPUs from any load balancing efforts.  They are willing
to adapt to alternative mechanisms for this, such as someway to manipulate
the list of isolated CPUs on a running system.  They can do without this
present cpu_exclusive based mechanism while we develop an alternative.

There is a real risk, to the best of my understanding, of users
accidentally setting up a partitioned scheduler domains, inhibiting desired
load balancing across all their CPUs, due to the nonobvious (from the
cpuset perspective) side affects of the cpu_exclusive flag.

Furthermore, since there was no way on a running system to see what one was
doing with sched domains, this change will be invisible to any using code.
Unless they have real insight to the scheduler load balancing choices, they
will be unable to detect that this change has been made in the kernel's
behaviour.

Initial discussion on lkml of this patch has generated much comment.  My
(probably controversial) take on that discussion is that it has reached a
rough concensus that the current cpuset cpu_exclusive mechanism for
defining sched domains is borked.  There is no concensus on the
replacement.  But since we can remove this mechanism, and since its
continued presence risks causing unwanted partitioning of the schedulers
load balancing, we should remove it while we can, as we proceed to work the
replacement scheduler domain mechanisms.

Signed-off-by: Paul Jackson <pj@sgi.com>
Cc: Ingo Molnar <mingo@elte.hu>
Cc: Nick Piggin <nickpiggin@yahoo.com.au>
Cc: Christoph Lameter <clameter@engr.sgi.com>
Cc: Dinakar Guniguntala <dino@in.ibm.com>
Cc: Thomas Gleixner <tglx@linutronix.de>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>

2 files changed, 2 insertions, 111 deletions

diff --git a/kernel/cpuset.c b/kernel/cpuset.c
index e196510aa40f..0864f4097930 100644
--- a/kernel/cpuset.c
+++ b/kernel/cpuset.c
@@ -755,68 +755,13 @@ static int validate_change(const struct cpuset *cur, const struct cpuset *trial)
 }
 
 /*
- * For a given cpuset cur, partition the system as follows
- * a. All cpus in the parent cpuset's cpus_allowed that are not part of any
- *    exclusive child cpusets
- * b. All cpus in the current cpuset's cpus_allowed that are not part of any
- *    exclusive child cpusets
- * Build these two partitions by calling partition_sched_domains
- *
- * Call with manage_mutex held.  May nest a call to the
- * lock_cpu_hotplug()/unlock_cpu_hotplug() pair.
- * Must not be called holding callback_mutex, because we must
- * not call lock_cpu_hotplug() while holding callback_mutex.
- */
-
-static void update_cpu_domains(struct cpuset *cur)
-{
-        struct cpuset *c, *par = cur->parent;
-        cpumask_t pspan, cspan;
-
-        if (par == NULL || cpus_empty(cur->cpus_allowed))
-                return;
-
-        /*
-         * Get all cpus from parent's cpus_allowed not part of exclusive
-         * children
-         */
-        pspan = par->cpus_allowed;
-        list_for_each_entry(c, &par->children, sibling) {
-                if (is_cpu_exclusive(c))
-                        cpus_andnot(pspan, pspan, c->cpus_allowed);
-        }
-        if (!is_cpu_exclusive(cur)) {
-                cpus_or(pspan, pspan, cur->cpus_allowed);
-                if (cpus_equal(pspan, cur->cpus_allowed))
-                        return;
-                cspan = CPU_MASK_NONE;
-        } else {
-                if (cpus_empty(pspan))
-                        return;
-                cspan = cur->cpus_allowed;
-                /*
-                 * Get all cpus from current cpuset's cpus_allowed not part
-                 * of exclusive children
-                 */
-                list_for_each_entry(c, &cur->children, sibling) {
-                        if (is_cpu_exclusive(c))
-                                cpus_andnot(cspan, cspan, c->cpus_allowed);
-                }
-        }
-
-        lock_cpu_hotplug();
-        partition_sched_domains(&pspan, &cspan);
-        unlock_cpu_hotplug();
-}
-
-/*
  * Call with manage_mutex held.  May take callback_mutex during call.
  */
 
 static int update_cpumask(struct cpuset *cs, char *buf)
 {
         struct cpuset trialcs;
-        int retval, cpus_unchanged;
+        int retval;
 
         /* top_cpuset.cpus_allowed tracks cpu_online_map; it's read-only */
         if (cs == &top_cpuset)
@@ -843,12 +788,9 @@ static int update_cpumask(struct cpuset *cs, char *buf)
         retval = validate_change(cs, &trialcs);
         if (retval < 0)
                 return retval;
-        cpus_unchanged = cpus_equal(cs->cpus_allowed, trialcs.cpus_allowed);
         mutex_lock(&callback_mutex);
         cs->cpus_allowed = trialcs.cpus_allowed;
         mutex_unlock(&callback_mutex);
-        if (is_cpu_exclusive(cs) && !cpus_unchanged)
-                update_cpu_domains(cs);
         return 0;
 }
 
@@ -1085,7 +1027,7 @@ static int update_flag(cpuset_flagbits_t bit, struct cpuset *cs, char *buf)
 {
         int turning_on;
         struct cpuset trialcs;
-        int err, cpu_exclusive_changed;
+        int err;
 
         turning_on = (simple_strtoul(buf, NULL, 10) != 0);
 
@@ -1098,14 +1040,10 @@ static int update_flag(cpuset_flagbits_t bit, struct cpuset *cs, char *buf)
         err = validate_change(cs, &trialcs);
         if (err < 0)
                 return err;
-        cpu_exclusive_changed =
-                (is_cpu_exclusive(cs) != is_cpu_exclusive(&trialcs));
         mutex_lock(&callback_mutex);
         cs->flags = trialcs.flags;
         mutex_unlock(&callback_mutex);
 
-        if (cpu_exclusive_changed)
-                update_cpu_domains(cs);
         return 0;
 }
 
@@ -1965,17 +1903,6 @@ static int cpuset_mkdir(struct inode *dir, struct dentry *dentry, int mode)
         return cpuset_create(c_parent, dentry->d_name.name, mode | S_IFDIR);
 }
 
-/*
- * Locking note on the strange update_flag() call below:
- *
- * If the cpuset being removed is marked cpu_exclusive, then simulate
- * turning cpu_exclusive off, which will call update_cpu_domains().
- * The lock_cpu_hotplug() call in update_cpu_domains() must not be
- * made while holding callback_mutex.  Elsewhere the kernel nests
- * callback_mutex inside lock_cpu_hotplug() calls.  So the reverse
- * nesting would risk an ABBA deadlock.
- */
-
 static int cpuset_rmdir(struct inode *unused_dir, struct dentry *dentry)
 {
         struct cpuset *cs = dentry->d_fsdata;
@@ -1995,13 +1922,6 @@ static int cpuset_rmdir(struct inode *unused_dir, struct dentry *dentry)
                 mutex_unlock(&manage_mutex);
                 return -EBUSY;
         }
-        if (is_cpu_exclusive(cs)) {
-                int retval = update_flag(CS_CPU_EXCLUSIVE, cs, "0");
-                if (retval < 0) {
-                        mutex_unlock(&manage_mutex);
-                        return retval;
-                }
-        }
         parent = cs->parent;
         mutex_lock(&callback_mutex);
         set_bit(CS_REMOVED, &cs->flags);
diff --git a/kernel/sched.c b/kernel/sched.c
index 78c8fbd373a3..0da2b2635c54 100644
--- a/kernel/sched.c
+++ b/kernel/sched.c
@@ -6348,35 +6348,6 @@ static void detach_destroy_domains(const cpumask_t *cpu_map)
         arch_destroy_sched_domains(cpu_map);
 }
 
-/*
- * Partition sched domains as specified by the cpumasks below.
- * This attaches all cpus from the cpumasks to the NULL domain,
- * waits for a RCU quiescent period, recalculates sched
- * domain information and then attaches them back to the
- * correct sched domains
- * Call with hotplug lock held
- */
-int partition_sched_domains(cpumask_t *partition1, cpumask_t *partition2)
-{
-        cpumask_t change_map;
-        int err = 0;
-
-        cpus_and(*partition1, *partition1, cpu_online_map);
-        cpus_and(*partition2, *partition2, cpu_online_map);
-        cpus_or(change_map, *partition1, *partition2);
-
-        /* Detach sched domains from all of the affected cpus */
-        detach_destroy_domains(&change_map);
-        if (!cpus_empty(*partition1))
-                err = build_sched_domains(partition1);
-        if (!err && !cpus_empty(*partition2))
-                err = build_sched_domains(partition2);
-
-        register_sched_domain_sysctl();
-
-        return err;
-}
-
 #if defined(CONFIG_SCHED_MC) || defined(CONFIG_SCHED_SMT)
 static int arch_reinit_sched_domains(void)
 {