11 files changed, 573 insertions, 5 deletions

diff --git a/include/litmus/litmus_proc.h b/include/litmus/litmus_proc.h
index 6800e725d48c..a5db24c03ec0 100644
--- a/include/litmus/litmus_proc.h
+++ b/include/litmus/litmus_proc.h
@@ -4,6 +4,22 @@
 int __init init_litmus_proc(void);
 void exit_litmus_proc(void);
 
+struct cd_mapping
+{
+        int id;
+        cpumask_var_t mask;
+        struct proc_dir_entry *proc_file;
+};
+
+struct domain_proc_info
+{
+        int num_cpus;
+        int num_domains;
+
+        struct cd_mapping *cpu_to_domains;
+        struct cd_mapping *domain_to_cpus;
+};
+
 /*
  * On success, returns 0 and sets the pointer to the location of the new
  * proc dir entry, otherwise returns an error code and sets pde to NULL.
@@ -17,6 +33,28 @@ long make_plugin_proc_dir(struct sched_plugin* plugin,
  */
 void remove_plugin_proc_dir(struct sched_plugin* plugin);
 
+/*
+ * Setup the CPU <-> sched domain mappings in proc
+ */
+long activate_domain_proc(struct domain_proc_info* map);
+
+/*
+ * Remove the CPU <-> sched domain mappings from proc
+ */
+long deactivate_domain_proc(void);
+
+/*
+ * Alloc memory for the mapping
+ * Note: Does not set up proc files. Use make_sched_domain_maps for that.
+ */
+long init_domain_proc_info(struct domain_proc_info* map,
+        int num_cpus, int num_domains);
+
+/*
+ * Free memory of the mapping
+ * Note: Does not clean up proc files. Use deactivate_domain_proc for that.
+ */
+void destroy_domain_proc_info(struct domain_proc_info* map);
 
 /* Copy at most size-1 bytes from ubuf into kbuf, null-terminate buf, and
  * remove a '\n' if present. Returns the number of bytes that were read or
diff --git a/include/litmus/sched_plugin.h b/include/litmus/sched_plugin.h
index 0f2fe90123db..f173dca7cd65 100644
--- a/include/litmus/sched_plugin.h
+++ b/include/litmus/sched_plugin.h
@@ -16,6 +16,8 @@
 typedef long (*activate_plugin_t) (void);
 typedef long (*deactivate_plugin_t) (void);
 
+struct domain_proc_info;
+typedef long (*get_domain_proc_info_t) (struct domain_proc_info **info);
 
 
 /********************* scheduler invocation ******************/
@@ -69,6 +71,9 @@ typedef long (*admit_task_t)(struct task_struct* tsk);
 
 typedef void (*release_at_t)(struct task_struct *t, lt_t start);
 
+/************************ misc routines ***********************/
+
+
 struct sched_plugin {
         struct list_head        list;
         /*      basic info              */
@@ -77,6 +82,7 @@ struct sched_plugin {
         /*      setup                   */
         activate_plugin_t       activate_plugin;
         deactivate_plugin_t     deactivate_plugin;
+        get_domain_proc_info_t  get_domain_proc_info;
 
         /*      scheduler invocation    */
         scheduler_tick_t        tick;
diff --git a/litmus/litmus.c b/litmus/litmus.c
index 76378ce34c2b..058cb956fb44 100644
--- a/litmus/litmus.c
+++ b/litmus/litmus.c
@@ -424,20 +424,30 @@ static int do_plugin_switch(void *_plugin)
 {
         int ret;
         struct sched_plugin* plugin = _plugin;
+        struct domain_proc_info* domain_info;
 
         /* don't switch if there are active real-time tasks */
         if (atomic_read(&rt_task_count) == 0) {
+                deactivate_domain_proc();
                 ret = litmus->deactivate_plugin();
-                if (0 != ret)
+                if (0 != ret) {
+                        /* reactivate the old proc info */
+                        if(!litmus->get_domain_proc_info(&domain_info))
+                                activate_domain_proc(domain_info);
                         goto out;
+                }
                 ret = plugin->activate_plugin();
                 if (0 != ret) {
                         printk(KERN_INFO "Can't activate %s (%d).\n",
                                plugin->plugin_name, ret);
                         plugin = &linux_sched_plugin;
                 }
+
                 printk(KERN_INFO "Switching to LITMUS^RT plugin %s.\n", plugin->plugin_name);
                 litmus = plugin;
+
+                if(!litmus->get_domain_proc_info(&domain_info))
+                        activate_domain_proc(domain_info);
         } else
                 ret = -EBUSY;
 out:
diff --git a/litmus/litmus_proc.c b/litmus/litmus_proc.c
index 1ebf1277f5d3..4db3fe2a672d 100644
--- a/litmus/litmus_proc.c
+++ b/litmus/litmus_proc.c
@@ -3,6 +3,7 @@
  */
 
 #include <linux/sched.h>
+#include <linux/slab.h>
 #include <linux/uaccess.h>
 #include <linux/seq_file.h>
 
@@ -21,7 +22,10 @@ static struct proc_dir_entry *litmus_dir = NULL,
 #ifdef CONFIG_RELEASE_MASTER
         *release_master_file = NULL,
 #endif
-        *plugs_file = NULL;
+        *plugs_file = NULL,
+        *domains_dir = NULL,
+        *cpus_dir = NULL;
+
 
 /* in litmus/sync.c */
 int count_tasks_waiting_for_release(void);
@@ -218,11 +222,32 @@ int __init init_litmus_proc(void)
         plugs_file = proc_create("loaded", 0444, plugs_dir,
                                  &litmus_loaded_proc_fops);
 
+        domains_dir = proc_mkdir("domains", litmus_dir);
+        if (!domains_dir) {
+                printk(KERN_ERR "Could not allocate domains directory "
+                                "procfs entry.\n");
+                return -ENOMEM;
+        }
+
+        cpus_dir = proc_mkdir("cpus", litmus_dir);
+        if (!cpus_dir) {
+                printk(KERN_ERR "Could not allocate cpus directory "
+                                "procfs entry.\n");
+                return -ENOMEM;
+        }
+
         return 0;
 }
 
 void exit_litmus_proc(void)
 {
+        if (cpus_dir || domains_dir) {
+                deactivate_domain_proc();
+                if (cpus_dir)
+                        remove_proc_entry("cpus", litmus_dir);
+                if (domains_dir)
+                        remove_proc_entry("domains", litmus_dir);
+        }
         if (plugs_file)
                 remove_proc_entry("loaded", plugs_dir);
         if (plugs_dir)
@@ -405,3 +430,147 @@ struct proc_dir_entry* create_cluster_file(struct proc_dir_entry* parent,
         }
         return cluster_file;
 }
+
+static struct domain_proc_info* active_mapping = NULL;
+
+static int litmus_mapping_proc_show(struct seq_file *m, void *v)
+{
+        struct cd_mapping *mapping = (struct cd_mapping*) m->private;
+        char buf[256];
+
+        if(!mapping)
+                return 0;
+
+        cpumask_scnprintf(buf, sizeof(buf), mapping->mask);
+        buf[255] = '\0'; /* just in case... */
+        seq_printf(m, "%s\n", buf);
+        return 0;
+}
+
+static int litmus_mapping_proc_open(struct inode *inode, struct file *file)
+{
+        return single_open(file, litmus_mapping_proc_show, PDE_DATA(inode));
+}
+
+static const struct file_operations litmus_domain_proc_fops = {
+        .open           = litmus_mapping_proc_open,
+        .read           = seq_read,
+        .llseek         = seq_lseek,
+        .release        = single_release,
+};
+
+long activate_domain_proc(struct domain_proc_info* map)
+{
+        int i;
+        char name[8];
+
+        if (!map)
+                return -EINVAL;
+        if (cpus_dir == NULL || domains_dir == NULL)
+                return -EINVAL;
+
+        if (active_mapping)
+                deactivate_domain_proc();
+
+        active_mapping = map;
+
+        for (i = 0; i < map->num_cpus; ++i) {
+                struct cd_mapping* m = &map->cpu_to_domains[i];
+                snprintf(name, sizeof(name), "%d", m->id);
+                m->proc_file = proc_create_data(name, 0444, cpus_dir,
+                        &litmus_domain_proc_fops, (void*)m);
+        }
+
+        for (i = 0; i < map->num_domains; ++i) {
+                struct cd_mapping* m = &map->domain_to_cpus[i];
+                snprintf(name, sizeof(name), "%d", m->id);
+                m->proc_file = proc_create_data(name, 0444, domains_dir,
+                        &litmus_domain_proc_fops, (void*)m);
+        }
+
+        return 0;
+}
+
+long deactivate_domain_proc()
+{
+        int i;
+        char name[65];
+
+        struct domain_proc_info* map = active_mapping;
+
+        if (!map)
+                return -EINVAL;
+
+        for (i = 0; i < map->num_cpus; ++i) {
+                struct cd_mapping* m = &map->cpu_to_domains[i];
+                snprintf(name, sizeof(name), "%d", m->id);
+                remove_proc_entry(name, cpus_dir);
+                m->proc_file = NULL;
+        }
+        for (i = 0; i < map->num_domains; ++i) {
+                struct cd_mapping* m = &map->domain_to_cpus[i];
+                snprintf(name, sizeof(name), "%d", m->id);
+                remove_proc_entry(name, domains_dir);
+                m->proc_file = NULL;
+        }
+
+        active_mapping = NULL;
+
+        return 0;
+}
+
+long init_domain_proc_info(struct domain_proc_info* m,
+                                int num_cpus, int num_domains)
+{
+        int i;
+        int num_alloced_cpu_masks = 0;
+        int num_alloced_domain_masks = 0;
+
+        m->cpu_to_domains =
+                kmalloc(sizeof(*(m->cpu_to_domains))*num_cpus,
+                        GFP_ATOMIC);
+        if(!m->cpu_to_domains)
+                goto failure;
+
+        m->domain_to_cpus =
+                kmalloc(sizeof(*(m->domain_to_cpus))*num_domains,
+                        GFP_ATOMIC);
+        if(!m->domain_to_cpus)
+                goto failure;
+
+        for(i = 0; i < num_cpus; ++i) {
+                if(!zalloc_cpumask_var(&m->cpu_to_domains[i].mask, GFP_ATOMIC))
+                        goto failure;
+                ++num_alloced_cpu_masks;
+        }
+        for(i = 0; i < num_domains; ++i) {
+                if(!zalloc_cpumask_var(&m->domain_to_cpus[i].mask, GFP_ATOMIC))
+                        goto failure;
+                ++num_alloced_domain_masks;
+        }
+
+        return 0;
+
+failure:
+        for(i = 0; i < num_alloced_cpu_masks; ++i)
+                free_cpumask_var(m->cpu_to_domains[i].mask);
+        for(i = 0; i < num_alloced_domain_masks; ++i)
+                free_cpumask_var(m->domain_to_cpus[i].mask);
+        if(m->cpu_to_domains)
+                kfree(m->cpu_to_domains);
+        if(m->domain_to_cpus)
+                kfree(m->domain_to_cpus);
+        return -ENOMEM;
+}
+
+void destroy_domain_proc_info(struct domain_proc_info* m)
+{
+        int i;
+        for(i = 0; i < m->num_cpus; ++i)
+                free_cpumask_var(m->cpu_to_domains[i].mask);
+        for(i = 0; i < m->num_domains; ++i)
+                free_cpumask_var(m->domain_to_cpus[i].mask);
+        kfree(m->cpu_to_domains);
+        kfree(m->domain_to_cpus);
+        memset(m, sizeof(*m), 0);
+}
diff --git a/litmus/sched_cedf.c b/litmus/sched_cedf.c
index 10ada7edadf2..33ea89e81eff 100644
--- a/litmus/sched_cedf.c
+++ b/litmus/sched_cedf.c
@@ -753,6 +753,55 @@ static void cleanup_cedf(void)
         }
 }
 
+static struct domain_proc_info cedf_domain_proc_info;
+static long cedf_get_domain_proc_info(struct domain_proc_info **ret)
+{
+        *ret = &cedf_domain_proc_info;
+        return 0;
+}
+
+static void cedf_setup_domain_proc(void)
+{
+        int i, cpu, domain;
+#ifdef CONFIG_RELEASE_MASTER
+        int release_master = atomic_read(&release_master_cpu);
+        /* skip over the domain with the release master if cluster size is 1 */
+        int skip_domain = (1 == cluster_size && release_master != NO_CPU) ?
+                        release_master : NO_CPU;
+#else
+        int release_master = NO_CPU;
+        int skip_domain = NO_CPU;
+#endif
+        int num_rt_cpus = num_online_cpus() - (release_master != NO_CPU);
+        int num_rt_domains = num_clusters - (skip_domain != NO_CPU);
+        struct cd_mapping *map;
+
+        memset(&cedf_domain_proc_info, sizeof(cedf_domain_proc_info), 0);
+        init_domain_proc_info(&cedf_domain_proc_info, num_rt_cpus, num_rt_domains);
+        cedf_domain_proc_info.num_cpus = num_rt_cpus;
+        cedf_domain_proc_info.num_domains = num_rt_domains;
+
+        for (cpu = 0, i = 0; cpu < num_online_cpus(); ++cpu) {
+                if (cpu == release_master)
+                        continue;
+                map = &cedf_domain_proc_info.cpu_to_domains[i];
+                /* pointer math to figure out the domain index */
+                domain = remote_cluster(cpu) - cedf;
+                map->id = cpu;
+                cpumask_set_cpu(domain, map->mask);
+                ++i;
+        }
+
+        for (domain = 0, i = 0; domain < num_clusters; ++domain) {
+                if (domain == skip_domain)
+                        continue;
+                map = &cedf_domain_proc_info.domain_to_cpus[i];
+                map->id = i;
+                cpumask_copy(map->mask, cedf[domain].cpu_map);
+                ++i;
+        }
+}
+
 static long cedf_activate_plugin(void)
 {
         int i, j, cpu, ccpu, cpu_count;
@@ -771,7 +820,7 @@ static long cedf_activate_plugin(void)
         if(!zalloc_cpumask_var(&mask, GFP_ATOMIC))
                 return -ENOMEM;
 
-        if (unlikely(cluster_config == GLOBAL_CLUSTER)) {
+        if (cluster_config == GLOBAL_CLUSTER) {
                 cluster_size = num_online_cpus();
         } else {
                 chk = get_shared_cpu_map(mask, 0, cluster_config);
@@ -869,8 +918,17 @@ static long cedf_activate_plugin(void)
                 }
         }
 
-        free_cpumask_var(mask);
         clusters_allocated = 1;
+        free_cpumask_var(mask);
+
+        cedf_setup_domain_proc();
+
+        return 0;
+}
+
+static long cedf_deactivate_plugin(void)
+{
+        destroy_domain_proc_info(&cedf_domain_proc_info);
         return 0;
 }
 
@@ -887,6 +945,8 @@ static struct sched_plugin cedf_plugin __cacheline_aligned_in_smp = {
         .task_block             = cedf_task_block,
         .admit_task             = cedf_admit_task,
         .activate_plugin        = cedf_activate_plugin,
+        .deactivate_plugin      = cedf_deactivate_plugin,
+        .get_domain_proc_info   = cedf_get_domain_proc_info,
 };
 
 static struct proc_dir_entry *cluster_file = NULL, *cedf_dir = NULL;
diff --git a/litmus/sched_cfl_split.c b/litmus/sched_cfl_split.c
index 8dc72c39dcb2..eef10f46c7e1 100644
--- a/litmus/sched_cfl_split.c
+++ b/litmus/sched_cfl_split.c
@@ -914,6 +914,55 @@ static void cleanup_cflsplit(void)
         }
 }
 
+static struct domain_proc_info cflsplit_domain_proc_info;
+static long cflsplit_get_domain_proc_info(struct domain_proc_info **ret)
+{
+        *ret = &cflsplit_domain_proc_info;
+        return 0;
+}
+
+static void cflsplit_setup_domain_proc(void)
+{
+        int i, cpu, domain;
+#ifdef CONFIG_RELEASE_MASTER
+        int release_master = atomic_read(&release_master_cpu);
+        /* skip over the domain with the release master if cluster size is 1 */
+        int skip_domain = (1 == cluster_size && release_master != NO_CPU) ?
+                        release_master : NO_CPU;
+#else
+        int release_master = NO_CPU;
+        int skip_domain = NO_CPU;
+#endif
+        int num_rt_cpus = num_online_cpus() - (release_master != NO_CPU);
+        int num_rt_domains = num_clusters - (skip_domain != NO_CPU);
+        struct cd_mapping *map;
+
+        memset(&cflsplit_domain_proc_info, sizeof(cflsplit_domain_proc_info), 0);
+        init_domain_proc_info(&cflsplit_domain_proc_info, num_rt_cpus, num_rt_domains);
+        cflsplit_domain_proc_info.num_cpus = num_rt_cpus;
+        cflsplit_domain_proc_info.num_domains = num_rt_domains;
+
+        for (cpu = 0, i = 0; cpu < num_online_cpus(); ++cpu) {
+                if (cpu == release_master)
+                        continue;
+                map = &cflsplit_domain_proc_info.cpu_to_domains[i];
+                /* pointer math to figure out the domain index */
+                domain = remote_cluster(cpu) - cflsplit;
+                map->id = cpu;
+                cpumask_set_cpu(domain, map->mask);
+                ++i;
+        }
+
+        for (domain = 0, i = 0; domain < num_clusters; ++domain) {
+                if (domain == skip_domain)
+                        continue;
+                map = &cflsplit_domain_proc_info.domain_to_cpus[i];
+                map->id = i;
+                cpumask_copy(map->mask, cflsplit[domain].cpu_map);
+                ++i;
+        }
+}
+
 static long cflsplit_activate_plugin(void)
 {
         int i, j, cpu, ccpu, cpu_count;
@@ -1035,8 +1084,17 @@ static long cflsplit_activate_plugin(void)
                 }
         }
 
-        free_cpumask_var(mask);
         clusters_allocated = 1;
+        free_cpumask_var(mask);
+
+        cflsplit_setup_domain_proc();
+
+        return 0;
+}
+
+static long cflsplit_deactivate_plugin(void)
+{
+        destroy_domain_proc_info(&cflsplit_domain_proc_info);
         return 0;
 }
 
@@ -1054,6 +1112,8 @@ static struct sched_plugin cflsplit_plugin __cacheline_aligned_in_smp = {
         .task_block             = cflsplit_task_block,
         .admit_task             = cflsplit_admit_task,
         .activate_plugin        = cflsplit_activate_plugin,
+        .deactivate_plugin  = cflsplit_deactivate_plugin,
+        .get_domain_proc_info   = cflsplit_get_domain_proc_info,
 };
 
 static struct proc_dir_entry *cluster_file = NULL, *cflsplit_dir = NULL;
diff --git a/litmus/sched_gsn_edf.c b/litmus/sched_gsn_edf.c
index 073f0f4db821..207f4b65bcbc 100644
--- a/litmus/sched_gsn_edf.c
+++ b/litmus/sched_gsn_edf.c
@@ -28,6 +28,12 @@
 #ifdef CONFIG_SCHED_CPU_AFFINITY
 #include <litmus/affinity.h>
 #endif
+/* to set up domain/cpu mappings */
+#include <litmus/litmus_proc.h>
+
+#ifdef CONFIG_SCHED_PGM
+#include <litmus/pgm.h>
+#endif
 
 #ifdef CONFIG_SCHED_PGM
 #include <litmus/pgm.h>
@@ -1034,6 +1040,44 @@ static long gsnedf_allocate_lock(struct litmus_lock **lock, int type,
 
 #endif
 
+static struct domain_proc_info gsnedf_domain_proc_info;
+static long gsnedf_get_domain_proc_info(struct domain_proc_info **ret)
+{
+        *ret = &gsnedf_domain_proc_info;
+        return 0;
+}
+
+static void gsnedf_setup_domain_proc(void)
+{
+        int i, cpu;
+        int release_master =
+#ifdef CONFIG_RELEASE_MASTER
+                        atomic_read(&release_master_cpu);
+#else
+                NO_CPU;
+#endif
+        int num_rt_cpus = num_online_cpus() - (release_master != NO_CPU);
+        struct cd_mapping *map;
+
+        memset(&gsnedf_domain_proc_info, sizeof(gsnedf_domain_proc_info), 0);
+        init_domain_proc_info(&gsnedf_domain_proc_info, num_rt_cpus, 1);
+        gsnedf_domain_proc_info.num_cpus = num_rt_cpus;
+        gsnedf_domain_proc_info.num_domains = 1;
+
+        gsnedf_domain_proc_info.domain_to_cpus[0].id = 0;
+        for (cpu = 0, i = 0; cpu < num_online_cpus(); ++cpu) {
+                if (cpu == release_master)
+                        continue;
+                map = &gsnedf_domain_proc_info.cpu_to_domains[i];
+                map->id = cpu;
+                cpumask_set_cpu(0, map->mask);
+                ++i;
+
+                /* add cpu to the domain */
+                cpumask_set_cpu(cpu,
+                        gsnedf_domain_proc_info.domain_to_cpus[0].mask);
+        }
+}
 
 static long gsnedf_activate_plugin(void)
 {
@@ -1061,6 +1105,15 @@ static long gsnedf_activate_plugin(void)
                 }
 #endif
         }
+
+        gsnedf_setup_domain_proc();
+
+        return 0;
+}
+
+static long gsnedf_deactivate_plugin(void)
+{
+        destroy_domain_proc_info(&gsnedf_domain_proc_info);
         return 0;
 }
 
@@ -1077,6 +1130,8 @@ static struct sched_plugin gsn_edf_plugin __cacheline_aligned_in_smp = {
         .task_block             = gsnedf_task_block,
         .admit_task             = gsnedf_admit_task,
         .activate_plugin        = gsnedf_activate_plugin,
+        .deactivate_plugin      = gsnedf_deactivate_plugin,
+        .get_domain_proc_info   = gsnedf_get_domain_proc_info,
 #ifdef CONFIG_LITMUS_LOCKING
         .allocate_lock          = gsnedf_allocate_lock,
 #endif
diff --git a/litmus/sched_pfair.c b/litmus/sched_pfair.c
index efe5e130da15..269049861362 100644
--- a/litmus/sched_pfair.c
+++ b/litmus/sched_pfair.c
@@ -940,6 +940,66 @@ static void cleanup_clusters(void)
         }
 }
 
+static struct domain_proc_info pfair_domain_proc_info;
+static long pfair_get_domain_proc_info(struct domain_proc_info **ret)
+{
+        *ret = &pfair_domain_proc_info;
+        return 0;
+}
+
+static void pfair_setup_domain_proc(void)
+{
+        int i, cpu, domain;
+#ifdef CONFIG_RELEASE_MASTER
+        int release_master = atomic_read(&release_master_cpu);
+        /* skip over the domain with the release master if cluster size is 1 */
+        int cluster_size = num_online_cpus() / num_pfair_clusters;
+        int skip_domain = (1 == cluster_size && release_master != NO_CPU) ?
+                        release_master : NO_CPU;
+#else
+        int release_master = NO_CPU;
+        int skip_domain = NO_CPU;
+#endif
+        int num_rt_cpus = num_online_cpus() - (release_master != NO_CPU);
+        int num_rt_domains = num_pfair_clusters - (skip_domain != NO_CPU);
+        struct cd_mapping *map;
+
+        memset(&pfair_domain_proc_info, sizeof(pfair_domain_proc_info), 0);
+        init_domain_proc_info(&pfair_domain_proc_info, num_rt_cpus, num_pfair_clusters);
+        pfair_domain_proc_info.num_cpus = num_rt_cpus;
+        pfair_domain_proc_info.num_domains = num_rt_domains;
+
+        for (cpu = 0, i = 0; cpu < num_online_cpus(); ++cpu) {
+                if (cpu == release_master)
+                        continue;
+                map = &pfair_domain_proc_info.cpu_to_domains[i];
+                /* pointer math to figure out the domain index */
+                domain = cpu_cluster(&per_cpu(pfair_state, cpu)) - pfair_clusters;
+                map->id = cpu;
+                cpumask_set_cpu(domain, map->mask);
+                ++i;
+        }
+
+        for (domain = 0, i = 0; domain < num_pfair_clusters; ++domain) {
+                struct pfair_cluster *cluster;
+                struct list_head *pos;
+
+                if (domain == skip_domain)
+                        continue;
+
+                cluster = &pfair_clusters[domain];
+                map = &pfair_domain_proc_info.domain_to_cpus[i];
+                map->id = i;
+
+                list_for_each(pos, &cluster->topology.cpus) {
+                        cpu = cpu_id(from_cluster_list(pos));
+                        if (cpu != release_master)
+                                cpumask_set_cpu(cpu, map->mask);
+                }
+                ++i;
+        }
+}
+
 static long pfair_activate_plugin(void)
 {
         int err, i;
@@ -994,6 +1054,8 @@ static long pfair_activate_plugin(void)
 
         if (err < 0)
                 cleanup_clusters();
+        else
+                pfair_setup_domain_proc();
 
         return err;
 }
@@ -1001,6 +1063,7 @@ static long pfair_activate_plugin(void)
 static long pfair_deactivate_plugin(void)
 {
         cleanup_clusters();
+        destroy_domain_proc_info(&pfair_domain_proc_info);
         return 0;
 }
 
@@ -1018,6 +1081,7 @@ static struct sched_plugin pfair_plugin __cacheline_aligned_in_smp = {
         .complete_job           = complete_job,
         .activate_plugin        = pfair_activate_plugin,
         .deactivate_plugin      = pfair_deactivate_plugin,
+        .get_domain_proc_info   = pfair_get_domain_proc_info,
 };
 
 
diff --git a/litmus/sched_pfp.c b/litmus/sched_pfp.c
index 01ac97d7f161..3a0157851702 100644
--- a/litmus/sched_pfp.c
+++ b/litmus/sched_pfp.c
@@ -21,6 +21,8 @@
 #include <litmus/trace.h>
 #include <litmus/budget.h>
 
+/* to set up domain/cpu mappings */
+#include <litmus/litmus_proc.h>
 #include <linux/uaccess.h>
 
 
@@ -1681,6 +1683,43 @@ static long pfp_admit_task(struct task_struct* tsk)
                 return -EINVAL;
 }
 
+static struct domain_proc_info pfp_domain_proc_info;
+static long pfp_get_domain_proc_info(struct domain_proc_info **ret)
+{
+        *ret = &pfp_domain_proc_info;
+        return 0;
+}
+
+static void pfp_setup_domain_proc(void)
+{
+        int i, cpu;
+        int release_master =
+#ifdef CONFIG_RELEASE_MASTER
+                atomic_read(&release_master_cpu);
+#else
+                NO_CPU;
+#endif
+        int num_rt_cpus = num_online_cpus() - (release_master != NO_CPU);
+        struct cd_mapping *cpu_map, *domain_map;
+
+        memset(&pfp_domain_proc_info, sizeof(pfp_domain_proc_info), 0);
+        init_domain_proc_info(&pfp_domain_proc_info, num_rt_cpus, num_rt_cpus);
+        pfp_domain_proc_info.num_cpus = num_rt_cpus;
+        pfp_domain_proc_info.num_domains = num_rt_cpus;
+        for (cpu = 0, i = 0; cpu < num_online_cpus(); ++cpu) {
+                if (cpu == release_master)
+                        continue;
+                cpu_map = &pfp_domain_proc_info.cpu_to_domains[i];
+                domain_map = &pfp_domain_proc_info.domain_to_cpus[i];
+
+                cpu_map->id = cpu;
+                domain_map->id = i; /* enumerate w/o counting the release master */
+                cpumask_set_cpu(i, cpu_map->mask);
+                cpumask_set_cpu(cpu, domain_map->mask);
+                ++i;
+        }
+}
+
 static long pfp_activate_plugin(void)
 {
 #if defined(CONFIG_RELEASE_MASTER) || defined(CONFIG_LITMUS_LOCKING)
@@ -1706,9 +1745,16 @@ static long pfp_activate_plugin(void)
 
 #endif
 
+        pfp_setup_domain_proc();
+
         return 0;
 }
 
+static long pfp_deactivate_plugin(void)
+{
+        destroy_domain_proc_info(&pfp_domain_proc_info);
+        return 0;
+}
 
 /*      Plugin object   */
 static struct sched_plugin pfp_plugin __cacheline_aligned_in_smp = {
@@ -1722,6 +1768,8 @@ static struct sched_plugin pfp_plugin __cacheline_aligned_in_smp = {
         .task_block             = pfp_task_block,
         .admit_task             = pfp_admit_task,
         .activate_plugin        = pfp_activate_plugin,
+        .deactivate_plugin      = pfp_deactivate_plugin,
+        .get_domain_proc_info   = pfp_get_domain_proc_info,
 #ifdef CONFIG_LITMUS_LOCKING
         .allocate_lock          = pfp_allocate_lock,
         .finish_switch          = pfp_finish_switch,
diff --git a/litmus/sched_plugin.c b/litmus/sched_plugin.c
index c4747e0ef2ab..592489629105 100644
--- a/litmus/sched_plugin.c
+++ b/litmus/sched_plugin.c
@@ -111,6 +111,12 @@ static long litmus_dummy_deactivate_plugin(void)
         return 0;
 }
 
+static long litmus_dummy_get_domain_proc_info(struct domain_proc_info **d)
+{
+        *d = NULL;
+        return 0;
+}
+
 #ifdef CONFIG_LITMUS_LOCKING
 
 static long litmus_dummy_allocate_lock(struct litmus_lock **lock, int type,
@@ -137,6 +143,7 @@ struct sched_plugin linux_sched_plugin = {
         .finish_switch = litmus_dummy_finish_switch,
         .activate_plugin = litmus_dummy_activate_plugin,
         .deactivate_plugin = litmus_dummy_deactivate_plugin,
+        .get_domain_proc_info = litmus_dummy_get_domain_proc_info,
 #ifdef CONFIG_LITMUS_LOCKING
         .allocate_lock = litmus_dummy_allocate_lock,
 #endif
@@ -175,6 +182,7 @@ int register_sched_plugin(struct sched_plugin* plugin)
         CHECK(complete_job);
         CHECK(activate_plugin);
         CHECK(deactivate_plugin);
+        CHECK(get_domain_proc_info);
 #ifdef CONFIG_LITMUS_LOCKING
         CHECK(allocate_lock);
 #endif
diff --git a/litmus/sched_psn_edf.c b/litmus/sched_psn_edf.c
index 0873dc172651..7546dcb95317 100644
--- a/litmus/sched_psn_edf.c
+++ b/litmus/sched_psn_edf.c
@@ -23,6 +23,9 @@
 #include <litmus/sched_trace.h>
 #include <litmus/trace.h>
 
+/* to set up domain/cpu mappings */
+#include <litmus/litmus_proc.h>
+
 typedef struct {
         rt_domain_t             domain;
         int                     cpu;
@@ -599,6 +602,43 @@ static long psnedf_allocate_lock(struct litmus_lock **lock, int type,
 
 #endif
 
+static struct domain_proc_info psnedf_domain_proc_info;
+static long psnedf_get_domain_proc_info(struct domain_proc_info **ret)
+{
+        *ret = &psnedf_domain_proc_info;
+        return 0;
+}
+
+static void psnedf_setup_domain_proc(void)
+{
+        int i, cpu;
+        int release_master =
+#ifdef CONFIG_RELEASE_MASTER
+                atomic_read(&release_master_cpu);
+#else
+                NO_CPU;
+#endif
+        int num_rt_cpus = num_online_cpus() - (release_master != NO_CPU);
+        struct cd_mapping *cpu_map, *domain_map;
+
+        memset(&psnedf_domain_proc_info, sizeof(psnedf_domain_proc_info), 0);
+        init_domain_proc_info(&psnedf_domain_proc_info, num_rt_cpus, num_rt_cpus);
+        psnedf_domain_proc_info.num_cpus = num_rt_cpus;
+        psnedf_domain_proc_info.num_domains = num_rt_cpus;
+
+        for (cpu = 0, i = 0; cpu < num_online_cpus(); ++cpu) {
+                if (cpu == release_master)
+                        continue;
+                cpu_map = &psnedf_domain_proc_info.cpu_to_domains[i];
+                domain_map = &psnedf_domain_proc_info.domain_to_cpus[i];
+
+                cpu_map->id = cpu;
+                domain_map->id = i; /* enumerate w/o counting the release master */
+                cpumask_set_cpu(i, cpu_map->mask);
+                cpumask_set_cpu(cpu, domain_map->mask);
+                ++i;
+        }
+}
 
 static long psnedf_activate_plugin(void)
 {
@@ -614,6 +654,14 @@ static long psnedf_activate_plugin(void)
         get_srp_prio = psnedf_get_srp_prio;
 #endif
 
+        psnedf_setup_domain_proc();
+
+        return 0;
+}
+
+static long psnedf_deactivate_plugin(void)
+{
+        destroy_domain_proc_info(&psnedf_domain_proc_info);
         return 0;
 }
 
@@ -642,6 +690,8 @@ static struct sched_plugin psn_edf_plugin __cacheline_aligned_in_smp = {
         .task_block             = psnedf_task_block,
         .admit_task             = psnedf_admit_task,
         .activate_plugin        = psnedf_activate_plugin,
+        .deactivate_plugin      = psnedf_deactivate_plugin,
+        .get_domain_proc_info   = psnedf_get_domain_proc_info,
 #ifdef CONFIG_LITMUS_LOCKING
         .allocate_lock          = psnedf_allocate_lock,
 #endif