C-EDF: move /proc/litmus/cluster_cache to /proc/litmus/plugins/C-EDF/cluster

Make use of the new per-plugin proc file infrastructure to avoid
littering the global namespace. While at it, also move all the
relevant bits to sched_cedf.c. In the future, each plugin's parameters
should be handled in the respective plugin file.

4 files changed, 100 insertions, 88 deletions

diff --git a/include/litmus/sched_plugin.h b/include/litmus/sched_plugin.h
index 9c1c9f28ba79..2d856d587041 100644
--- a/include/litmus/sched_plugin.h
+++ b/include/litmus/sched_plugin.h
@@ -133,9 +133,6 @@ struct sched_plugin {
 
 extern struct sched_plugin *litmus;
 
-/* cluster size: cache_index = 2 L2, cache_index = 3 L3 */
-extern int cluster_cache_index;
-
 int register_sched_plugin(struct sched_plugin* plugin);
 struct sched_plugin* find_sched_plugin(const char* name);
 int print_sched_plugins(char* buf, int max);
diff --git a/litmus/litmus_proc.c b/litmus/litmus_proc.c
index ee0ad56d445c..c10a6a6d3975 100644
--- a/litmus/litmus_proc.c
+++ b/litmus/litmus_proc.c
@@ -4,6 +4,7 @@
 
 #include <linux/uaccess.h>
 
+#include <litmus/litmus.h>
 #include <litmus/litmus_proc.h>
 
 /* in litmus/litmus.c */
@@ -13,11 +14,10 @@ static struct proc_dir_entry *litmus_dir = NULL,
         *curr_file = NULL,
         *stat_file = NULL,
         *plugs_dir = NULL,
-        *plugs_file = NULL,
 #ifdef CONFIG_RELEASE_MASTER
         *release_master_file = NULL,
 #endif
-        *clus_cache_idx_file = NULL;
+        *plugs_file = NULL;
 
 /* in litmus/sync.c */
 int count_tasks_waiting_for_release(void);
@@ -93,60 +93,6 @@ static int proc_write_curr(struct file *file,
         return len;
 }
 
-static int proc_read_cluster_size(char *page, char **start,
-                          off_t off, int count,
-                          int *eof, void *data)
-{
-        int len;
-        if (cluster_cache_index == 2)
-                len = snprintf(page, PAGE_SIZE, "L2\n");
-        else if (cluster_cache_index == 3)
-                len = snprintf(page, PAGE_SIZE, "L3\n");
-        else if (cluster_cache_index == 1)
-                len = snprintf(page, PAGE_SIZE, "L1\n");
-        else
-                len = snprintf(page, PAGE_SIZE, "ALL\n");
-
-        return len;
-}
-
-static int proc_write_cluster_size(struct file *file,
-                           const char *buffer,
-                           unsigned long count,
-                           void *data)
-{
-        int len;
-        /* L2, L3 */
-        char cache_name[33];
-
-        if(count > 32)
-                len = 32;
-        else
-                len = count;
-
-        if(copy_from_user(cache_name, buffer, len))
-                return -EFAULT;
-
-        cache_name[len] = '\0';
-        /* chomp name */
-        if (len > 1 && cache_name[len - 1] == '\n')
-                cache_name[len - 1] = '\0';
-
-        /* do a quick and dirty comparison to find the cluster size */
-        if (!strcmp(cache_name, "L2"))
-                cluster_cache_index = 2;
-        else if (!strcmp(cache_name, "L3"))
-                cluster_cache_index = 3;
-        else if (!strcmp(cache_name, "L1"))
-                cluster_cache_index = 1;
-        else if (!strcmp(cache_name, "ALL"))
-                cluster_cache_index = num_online_cpus();
-        else
-                printk(KERN_INFO "Cluster '%s' is unknown.\n", cache_name);
-
-        return len;
-}
-
 #ifdef CONFIG_RELEASE_MASTER
 static int proc_read_release_master(char *page, char **start,
                                     off_t off, int count,
@@ -229,16 +175,6 @@ int __init init_litmus_proc(void)
         release_master_file->write_proc  = proc_write_release_master;
 #endif
 
-        clus_cache_idx_file = create_proc_entry("cluster_cache",
-                                                0644, litmus_dir);
-        if (!clus_cache_idx_file) {
-                printk(KERN_ERR "Could not allocate cluster_cache "
-                       "procfs entry.\n");
-                return -ENOMEM;
-        }
-        clus_cache_idx_file->read_proc = proc_read_cluster_size;
-        clus_cache_idx_file->write_proc = proc_write_cluster_size;
-
         stat_file = create_proc_read_entry("stats", 0444, litmus_dir,
                                            proc_read_stats, NULL);
 
@@ -265,8 +201,6 @@ void exit_litmus_proc(void)
                 remove_proc_entry("stats", litmus_dir);
         if (curr_file)
                 remove_proc_entry("active_plugin", litmus_dir);
-        if (clus_cache_idx_file)
-                remove_proc_entry("cluster_cache", litmus_dir);
 #ifdef CONFIG_RELEASE_MASTER
         if (release_master_file)
                 remove_proc_entry("release_master", litmus_dir);
diff --git a/litmus/sched_cedf.c b/litmus/sched_cedf.c
index f5b77080cc4f..a729d97535e9 100644
--- a/litmus/sched_cedf.c
+++ b/litmus/sched_cedf.c
@@ -30,6 +30,8 @@
 #include <linux/sched.h>
 #include <linux/slab.h>
 
+#include <linux/module.h>
+
 #include <litmus/litmus.h>
 #include <litmus/jobs.h>
 #include <litmus/sched_plugin.h>
@@ -38,7 +40,16 @@
 
 #include <litmus/bheap.h>
 
-#include <linux/module.h>
+/* to configure the cluster size */
+#include <litmus/litmus_proc.h>
+#include <linux/uaccess.h>
+
+/*
+ * It makes sense only to cluster around L2 or L3, so if cluster_index = 2
+ * (default) we cluster all the CPUs that shares a L2 cache, while
+ * cluster_cache_index = 3 we cluster all CPs that shares a L3 cache
+ */
+int cluster_index = 2;
 
 /* forward declaration... a funny thing with C ;) */
 struct clusterdomain;
@@ -641,25 +652,25 @@ static long cedf_activate_plugin(void)
         cleanup_cedf();
 
         printk(KERN_INFO "C-EDF: Activate Plugin, cache index = %d\n",
-                        cluster_cache_index);
+                        cluster_index);
 
         /* need to get cluster_size first */
         if(!zalloc_cpumask_var(&mask, GFP_ATOMIC))
                 return -ENOMEM;
 
-        if (unlikely(cluster_cache_index == num_online_cpus())) {
+        if (unlikely(cluster_index == num_online_cpus())) {
 
                 cluster_size = num_online_cpus();
         } else {
 
-                chk = get_shared_cpu_map(mask, 0, cluster_cache_index);
+                chk = get_shared_cpu_map(mask, 0, cluster_index);
                 if (chk) {
                         /* if chk != 0 then it is the max allowed index */
                         printk(KERN_INFO "C-EDF: Cannot support cache index = %d\n",
-                                        cluster_cache_index);
+                                        cluster_index);
                         printk(KERN_INFO "C-EDF: Using cache index = %d\n",
                                         chk);
-                        cluster_cache_index = chk;
+                        cluster_index = chk;
                 }
 
                 cluster_size = cpumask_weight(mask);
@@ -706,10 +717,10 @@ static long cedf_activate_plugin(void)
 
                         /* this cpu isn't in any cluster */
                         /* get the shared cpus */
-                        if (unlikely(cluster_cache_index == num_online_cpus()))
+                        if (unlikely(cluster_index == num_online_cpus()))
                                 cpumask_copy(mask, cpu_online_mask);
                         else
-                                get_shared_cpu_map(mask, cpu, cluster_cache_index);
+                                get_shared_cpu_map(mask, cpu, cluster_index);
 
                         cpumask_copy(cedf[i].cpu_map, mask);
 #ifdef VERBOSE_INIT
@@ -759,14 +770,92 @@ static struct sched_plugin cedf_plugin __cacheline_aligned_in_smp = {
 };
 
 
+/* proc file interface to configure the cluster size */
+
+static int proc_read_cluster_size(char *page, char **start,
+                                  off_t off, int count,
+                                  int *eof, void *data)
+{
+        int len;
+        if (cluster_index >= 1 && cluster_index <= 3)
+                len = snprintf(page, PAGE_SIZE, "L%d\n", cluster_index);
+        else
+                len = snprintf(page, PAGE_SIZE, "ALL\n");
+
+        return len;
+}
+
+static int proc_write_cluster_size(struct file *file,
+                                   const char *buffer,
+                                   unsigned long count,
+                                   void *data)
+{
+        int len;
+        /* L2, L3 */
+        char cache_name[33];
+
+        if(count > 32)
+                len = 32;
+        else
+                len = count;
+
+        if(copy_from_user(cache_name, buffer, len))
+                return -EFAULT;
+
+        cache_name[len] = '\0';
+        /* chomp name */
+        if (len > 1 && cache_name[len - 1] == '\n')
+                cache_name[len - 1] = '\0';
+
+        /* do a quick and dirty comparison to find the cluster size */
+        if (!strcmp(cache_name, "L2"))
+                cluster_index = 2;
+        else if (!strcmp(cache_name, "L3"))
+                cluster_index = 3;
+        else if (!strcmp(cache_name, "L1"))
+                cluster_index = 1;
+        else if (!strcmp(cache_name, "ALL"))
+                cluster_index = num_online_cpus();
+        else
+                printk(KERN_INFO "Cluster '%s' is unknown.\n", cache_name);
+
+        return len;
+}
+
+
+static struct proc_dir_entry *cluster_file = NULL, *cedf_dir = NULL;
+
+
 static int __init init_cedf(void)
 {
-        return register_sched_plugin(&cedf_plugin);
+        int err, fs;
+
+        err = register_sched_plugin(&cedf_plugin);
+        if (!err) {
+                fs = make_plugin_proc_dir(&cedf_plugin, &cedf_dir);
+                if (!fs) {
+                        cluster_file = create_proc_entry("cluster", 0644, cedf_dir);
+                        if (!cluster_file) {
+                                printk(KERN_ERR "Could not allocate C-EDF/cluster "
+                                       "procfs entry.\n");
+                        } else {
+                                cluster_file->read_proc = proc_read_cluster_size;
+                                cluster_file->write_proc = proc_write_cluster_size;
+                        }
+                } else {
+                        printk(KERN_ERR "Could not allocate C-EDF procfs dir.\n");
+                }
+        }
+        return err;
 }
 
 static void clean_cedf(void)
 {
         cleanup_cedf();
+        if (cluster_file)
+                remove_proc_entry("cluster", cedf_dir);
+        if (cedf_dir)
+                remove_plugin_proc_dir(&cedf_plugin);
 }
 
 module_init(init_cedf);
diff --git a/litmus/sched_plugin.c b/litmus/sched_plugin.c
index 3543b7baff53..d706a08fb313 100644
--- a/litmus/sched_plugin.c
+++ b/litmus/sched_plugin.c
@@ -171,14 +171,6 @@ struct sched_plugin linux_sched_plugin = {
 };
 
 /*
- * The cluster size is needed in C-EDF: it makes sense only to cluster
- * around L2 or L3, so if cluster_cache_index = 2 (default) we cluster
- * all the CPUs that shares a L2 cache, while cluster_cache_index = 3
- * we cluster all CPs that shares a L3 cache
- */
-int cluster_cache_index = 2;
-
-/*
  *      The reference to current plugin that is used to schedule tasks within
  *      the system. It stores references to actual function implementations
  *      Should be initialized by calling "init_***_plugin()"