Merge branch 'master' into wip-edzl-critique

5 files changed, 215 insertions, 81 deletions

diff --git a/include/litmus/ftdev.h b/include/litmus/ftdev.h
index 7697b4616699..348387e9adf9 100644
--- a/include/litmus/ftdev.h
+++ b/include/litmus/ftdev.h
@@ -6,8 +6,6 @@
 #include <linux/mutex.h>
 #include <linux/cdev.h>
 
-#define MAX_FTDEV_MINORS NR_CPUS
-
 #define FTDEV_ENABLE_CMD        0
 #define FTDEV_DISABLE_CMD       1
 
@@ -28,12 +26,15 @@ struct ftdev_minor {
         struct mutex            lock;
         /* FIXME: filter for authorized events */
         struct ftdev_event*     events;
+        struct device*          device;
 };
 
 struct ftdev {
+        dev_t                   major;
         struct cdev             cdev;
-        /* FIXME: don't waste memory, allocate dynamically */
-        struct ftdev_minor      minor[MAX_FTDEV_MINORS];
+        struct class*           class;
+        const char*             name;
+        struct ftdev_minor*     minor;
         unsigned int            minor_cnt;
         ftdev_alloc_t           alloc;
         ftdev_free_t            free;
@@ -43,7 +44,9 @@ struct ftdev {
 struct ft_buffer* alloc_ft_buffer(unsigned int count, size_t size);
 void free_ft_buffer(struct ft_buffer* buf);
 
-void ftdev_init(struct ftdev* ftdev, struct module* owner);
-int register_ftdev(struct ftdev* ftdev, const char* name, int major);
+int ftdev_init( struct ftdev* ftdev, struct module* owner,
+                const int minor_cnt, const char* name);
+void ftdev_exit(struct ftdev* ftdev);
+int register_ftdev(struct ftdev* ftdev);
 
 #endif
diff --git a/litmus/ftdev.c b/litmus/ftdev.c
index 51dafaebf8a6..4a4b2e3e56c2 100644
--- a/litmus/ftdev.c
+++ b/litmus/ftdev.c
@@ -4,6 +4,7 @@
 #include <linux/cdev.h>
 #include <asm/uaccess.h>
 #include <linux/module.h>
+#include <linux/device.h>
 
 #include <litmus/litmus.h>
 #include <litmus/feather_trace.h>
@@ -309,52 +310,131 @@ struct file_operations ftdev_fops = {
         .read    = ftdev_read,
 };
 
-
-void ftdev_init(struct ftdev* ftdev, struct module* owner)
+int ftdev_init( struct ftdev* ftdev, struct module* owner,
+                const int minor_cnt, const char* name)
 {
-        int i;
+        int i, err;
+
+        BUG_ON(minor_cnt < 1);
+
         cdev_init(&ftdev->cdev, &ftdev_fops);
+        ftdev->name = name;
+        ftdev->minor_cnt = minor_cnt;
         ftdev->cdev.owner = owner;
         ftdev->cdev.ops = &ftdev_fops;
-        ftdev->minor_cnt  = 0;
-        for (i = 0; i < MAX_FTDEV_MINORS; i++) {
+        ftdev->alloc    = NULL;
+        ftdev->free     = NULL;
+        ftdev->can_open = NULL;
+
+        ftdev->minor = kcalloc(ftdev->minor_cnt, sizeof(*ftdev->minor),
+                        GFP_KERNEL);
+        if (!ftdev->minor) {
+                printk(KERN_WARNING "ftdev(%s): Could not allocate memory\n",
+                        ftdev->name);
+                err = -ENOMEM;
+                goto err_out;
+        }
+
+        for (i = 0; i < ftdev->minor_cnt; i++) {
                 mutex_init(&ftdev->minor[i].lock);
                 ftdev->minor[i].readers = 0;
                 ftdev->minor[i].buf     = NULL;
                 ftdev->minor[i].events  = NULL;
         }
-        ftdev->alloc    = NULL;
-        ftdev->free     = NULL;
-        ftdev->can_open = NULL;
+
+        ftdev->class = class_create(owner, ftdev->name);
+        if (IS_ERR(ftdev->class)) {
+                err = PTR_ERR(ftdev->class);
+                printk(KERN_WARNING "ftdev(%s): "
+                        "Could not create device class.\n", ftdev->name);
+                goto err_dealloc;
+        }
+
+        return 0;
+
+err_dealloc:
+        kfree(ftdev->minor);
+err_out:
+        return err;
 }
 
-int register_ftdev(struct ftdev* ftdev, const char* name, int major)
+/*
+ * Destroy minor devices up to, but not including, up_to.
+ */
+static void ftdev_device_destroy(struct ftdev* ftdev, unsigned int up_to)
 {
-        dev_t   trace_dev;
-        int error = 0;
-
-        if(major) {
-                trace_dev = MKDEV(major, 0);
-                error = register_chrdev_region(trace_dev, ftdev->minor_cnt,
-                                               name);
-        } else {
-                error = alloc_chrdev_region(&trace_dev, 0, ftdev->minor_cnt,
-                                name);
-                major = MAJOR(trace_dev);
-        }
-        if (error)
-        {
+        dev_t minor_cntr;
+
+        if (up_to < 1)
+                up_to = (ftdev->minor_cnt < 1) ? 0 : ftdev->minor_cnt;
+
+        for (minor_cntr = 0; minor_cntr < up_to; ++minor_cntr)
+                device_destroy(ftdev->class, MKDEV(ftdev->major, minor_cntr));
+}
+
+void ftdev_exit(struct ftdev* ftdev)
+{
+        printk("ftdev(%s): Exiting\n", ftdev->name);
+        ftdev_device_destroy(ftdev, -1);
+        cdev_del(&ftdev->cdev);
+        unregister_chrdev_region(MKDEV(ftdev->major, 0), ftdev->minor_cnt);
+        class_destroy(ftdev->class);
+        kfree(ftdev->minor);
+}
+
+int register_ftdev(struct ftdev* ftdev)
+{
+        struct device **device;
+        dev_t trace_dev_tmp, minor_cntr;
+        int err;
+
+        err = alloc_chrdev_region(&trace_dev_tmp, 0, ftdev->minor_cnt,
+                        ftdev->name);
+        if (err) {
                 printk(KERN_WARNING "ftdev(%s): "
-                       "Could not register major/minor number %d/%u\n",
-                       name, major, ftdev->minor_cnt);
-                return error;
+                       "Could not allocate char. device region (%d minors)\n",
+                       ftdev->name, ftdev->minor_cnt);
+                goto err_out;
         }
-        error = cdev_add(&ftdev->cdev, trace_dev, ftdev->minor_cnt);
-        if (error) {
+
+        ftdev->major = MAJOR(trace_dev_tmp);
+
+        err = cdev_add(&ftdev->cdev, trace_dev_tmp, ftdev->minor_cnt);
+        if (err) {
                 printk(KERN_WARNING "ftdev(%s): "
-                       "Could not add cdev for major/minor = %d/%u.\n",
-                       name, major, ftdev->minor_cnt);
-                return error;
+                       "Could not add cdev for major %u with %u minor(s).\n",
+                       ftdev->name, ftdev->major, ftdev->minor_cnt);
+                goto err_unregister;
         }
-        return error;
+
+        /* create the minor device(s) */
+        for (minor_cntr = 0; minor_cntr < ftdev->minor_cnt; ++minor_cntr)
+        {
+                trace_dev_tmp = MKDEV(ftdev->major, minor_cntr);
+                device = &ftdev->minor[minor_cntr].device;
+
+                *device = device_create(ftdev->class, NULL, trace_dev_tmp, NULL,
+                                "litmus/%s%d", ftdev->name, minor_cntr);
+                if (IS_ERR(*device)) {
+                        err = PTR_ERR(*device);
+                        printk(KERN_WARNING "ftdev(%s): "
+                                "Could not create device major/minor number "
+                                "%u/%u\n", ftdev->name, ftdev->major,
+                                minor_cntr);
+                        printk(KERN_WARNING "ftdev(%s): "
+                                "will attempt deletion of allocated devices.\n",
+                                ftdev->name);
+                        goto err_minors;
+                }
+        }
+
+        return 0;
+
+err_minors:
+        ftdev_device_destroy(ftdev, minor_cntr);
+        cdev_del(&ftdev->cdev);
+err_unregister:
+        unregister_chrdev_region(MKDEV(ftdev->major, 0), ftdev->minor_cnt);
+err_out:
+        return err;
 }
diff --git a/litmus/sched_cedf.c b/litmus/sched_cedf.c
index 8c9513d33f59..098a449c2490 100644
--- a/litmus/sched_cedf.c
+++ b/litmus/sched_cedf.c
@@ -45,14 +45,17 @@
 #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
+/* Reference configuration variable. Determines which cache level is used to
+ * group CPUs into clusters.  GLOBAL_CLUSTER, which is the default, means that
+ * all CPUs form a single cluster (just like GSN-EDF).
  */
-int cluster_index = 2;
+static enum {
+        GLOBAL_CLUSTER = 0,
+        L1_CLUSTER     = 1,
+        L2_CLUSTER     = 2,
+        L3_CLUSTER     = 3
+} cluster_config = GLOBAL_CLUSTER;
 
-/* forward declaration... a funny thing with C ;) */
 struct clusterdomain;
 
 /* cpu_entry_t - maintain the linked and scheduled state
@@ -587,7 +590,9 @@ static void cedf_task_exit(struct task_struct * t)
         raw_spin_lock_irqsave(&cluster->lock, flags);
         unlink(t);
         if (tsk_rt(t)->scheduled_on != NO_CPU) {
-                cluster->cpus[tsk_rt(t)->scheduled_on]->scheduled = NULL;
+                cpu_entry_t *cpu;
+                cpu = &per_cpu(cedf_cpu_entries, tsk_rt(t)->scheduled_on);
+                cpu->scheduled = NULL;
                 tsk_rt(t)->scheduled_on = NO_CPU;
         }
         raw_spin_unlock_irqrestore(&cluster->lock, flags);
@@ -647,26 +652,25 @@ static long cedf_activate_plugin(void)
         /* de-allocate old clusters, if any */
         cleanup_cedf();
 
-        printk(KERN_INFO "C-EDF: Activate Plugin, cache index = %d\n",
-                        cluster_index);
+        printk(KERN_INFO "C-EDF: Activate Plugin, cluster configuration = %d\n",
+                        cluster_config);
 
         /* need to get cluster_size first */
         if(!zalloc_cpumask_var(&mask, GFP_ATOMIC))
                 return -ENOMEM;
 
-        if (unlikely(cluster_index == num_online_cpus())) {
-
+        if (unlikely(cluster_config == GLOBAL_CLUSTER)) {
                 cluster_size = num_online_cpus();
         } else {
-
-                chk = get_shared_cpu_map(mask, 0, cluster_index);
+                chk = get_shared_cpu_map(mask, 0, cluster_config);
                 if (chk) {
                         /* if chk != 0 then it is the max allowed index */
-                        printk(KERN_INFO "C-EDF: Cannot support cache index = %d\n",
-                                        cluster_index);
-                        printk(KERN_INFO "C-EDF: Using cache index = %d\n",
-                                        chk);
-                        cluster_index = chk;
+                        printk(KERN_INFO "C-EDF: Cluster configuration = %d "
+                               "is not supported on this hardware.\n",
+                               cluster_config);
+                        /* User should notice that the configuration failed, so
+                         * let's bail out. */
+                        return -EINVAL;
                 }
 
                 cluster_size = cpumask_weight(mask);
@@ -714,10 +718,10 @@ static long cedf_activate_plugin(void)
 
                         /* this cpu isn't in any cluster */
                         /* get the shared cpus */
-                        if (unlikely(cluster_index == num_online_cpus()))
+                        if (unlikely(cluster_config == GLOBAL_CLUSTER))
                                 cpumask_copy(mask, cpu_online_mask);
                         else
-                                get_shared_cpu_map(mask, cpu, cluster_index);
+                                get_shared_cpu_map(mask, cpu, cluster_config);
 
                         cpumask_copy(cedf[i].cpu_map, mask);
 #ifdef VERBOSE_INIT
@@ -774,11 +778,21 @@ static int proc_read_cluster_size(char *page, char **start,
                                   int *eof, void *data)
 {
         int len;
-        if (cluster_index >= 1 && cluster_index <= 3)
-                len = snprintf(page, PAGE_SIZE, "L%d\n", cluster_index);
-        else
+        switch (cluster_config) {
+        case GLOBAL_CLUSTER:
                 len = snprintf(page, PAGE_SIZE, "ALL\n");
-
+                break;
+        case L1_CLUSTER:
+        case L2_CLUSTER:
+        case L3_CLUSTER:
+                len = snprintf(page, PAGE_SIZE, "L%d\n", cluster_config);
+                break;
+        default:
+                /* This should be impossible, but let's be paranoid. */
+                len = snprintf(page, PAGE_SIZE, "INVALID (%d)\n",
+                               cluster_config);
+                break;
+        }
         return len;
 }
 
@@ -806,13 +820,13 @@ static int proc_write_cluster_size(struct file *file,
 
         /* do a quick and dirty comparison to find the cluster size */
         if (!strcmp(cache_name, "L2"))
-                cluster_index = 2;
+                cluster_config = L2_CLUSTER;
         else if (!strcmp(cache_name, "L3"))
-                cluster_index = 3;
+                cluster_config = L3_CLUSTER;
         else if (!strcmp(cache_name, "L1"))
-                cluster_index = 1;
+                cluster_config = L1_CLUSTER;
         else if (!strcmp(cache_name, "ALL"))
-                cluster_index = num_online_cpus();
+                cluster_config = GLOBAL_CLUSTER;
         else
                 printk(KERN_INFO "Cluster '%s' is unknown.\n", cache_name);
 
diff --git a/litmus/sched_task_trace.c b/litmus/sched_task_trace.c
index e5098ddb1ec9..a15b25d21a89 100644
--- a/litmus/sched_task_trace.c
+++ b/litmus/sched_task_trace.c
@@ -16,8 +16,6 @@
 #include <litmus/ftdev.h>
 
 
-/* set MAJOR to 0 to have it dynamically assigned */
-#define FT_TASK_TRACE_MAJOR     253
 #define NO_EVENTS               (1 << CONFIG_SCHED_TASK_TRACE_SHIFT)
 
 #define now() litmus_clock()
@@ -40,12 +38,17 @@ static int st_dev_can_open(struct ftdev *dev, unsigned int cpu)
 static int __init init_sched_task_trace(void)
 {
         struct local_buffer* buf;
-        int i, ok = 0;
+        int i, ok = 0, err;
         printk("Allocated %u sched_trace_xxx() events per CPU "
                "(buffer size: %d bytes)\n",
                NO_EVENTS, (int) sizeof(struct local_buffer));
-        ftdev_init(&st_dev, THIS_MODULE);
-        for (i = 0; i < NR_CPUS; i++) {
+
+        err = ftdev_init(&st_dev, THIS_MODULE,
+                        num_online_cpus(), "sched_trace");
+        if (err)
+                goto err_out;
+
+        for (i = 0; i < st_dev.minor_cnt; i++) {
                 buf = &per_cpu(st_event_buffer, i);
                 ok += init_ft_buffer(&buf->ftbuf, NO_EVENTS,
                                      sizeof(struct st_event_record),
@@ -53,16 +56,32 @@ static int __init init_sched_task_trace(void)
                                      buf->record);
                 st_dev.minor[i].buf = &buf->ftbuf;
         }
-        if (ok == NR_CPUS) {
-                st_dev.minor_cnt = NR_CPUS;
+        if (ok == st_dev.minor_cnt) {
                 st_dev.can_open = st_dev_can_open;
-                return register_ftdev(&st_dev, "sched_trace", FT_TASK_TRACE_MAJOR);
+                err = register_ftdev(&st_dev);
+                if (err)
+                        goto err_dealloc;
         } else {
-                return -EINVAL;
+                err = -EINVAL;
+                goto err_dealloc;
         }
+
+        return 0;
+
+err_dealloc:
+        ftdev_exit(&st_dev);
+err_out:
+        printk(KERN_WARNING "Could not register sched_trace module\n");
+        return err;
+}
+
+static void __exit exit_sched_task_trace(void)
+{
+        ftdev_exit(&st_dev);
 }
 
 module_init(init_sched_task_trace);
+module_exit(exit_sched_task_trace);
 
 
 static inline struct st_event_record* get_record(u8 type, struct task_struct* t)
diff --git a/litmus/trace.c b/litmus/trace.c
index b3a6b47aad6e..e7ea1c2ab3e4 100644
--- a/litmus/trace.c
+++ b/litmus/trace.c
@@ -71,9 +71,6 @@ feather_callback void save_timestamp_cpu(unsigned long event,
  */
 #define NO_TIMESTAMPS (2 << 11)
 
-/* set MAJOR to 0 to have it dynamically assigned */
-#define FT_TRACE_MAJOR  252
-
 static int alloc_timestamp_buffer(struct ftdev* ftdev, unsigned int idx)
 {
         unsigned int count = NO_TIMESTAMPS;
@@ -93,12 +90,33 @@ static void free_timestamp_buffer(struct ftdev* ftdev, unsigned int idx)
 
 static int __init init_ft_overhead_trace(void)
 {
+        int err;
+
         printk("Initializing Feather-Trace overhead tracing device.\n");
-        ftdev_init(&overhead_dev, THIS_MODULE);
-        overhead_dev.minor_cnt = 1; /* only one buffer */
+        err = ftdev_init(&overhead_dev, THIS_MODULE, 1, "ft_trace");
+        if (err)
+                goto err_out;
+
         overhead_dev.alloc = alloc_timestamp_buffer;
         overhead_dev.free  = free_timestamp_buffer;
-        return register_ftdev(&overhead_dev, "ft_trace", FT_TRACE_MAJOR);
+
+        err = register_ftdev(&overhead_dev);
+        if (err)
+                goto err_dealloc;
+
+        return 0;
+
+err_dealloc:
+        ftdev_exit(&overhead_dev);
+err_out:
+        printk(KERN_WARNING "Could not register ft_trace module.\n");
+        return err;
+}
+
+static void __exit exit_ft_overhead_trace(void)
+{
+        ftdev_exit(&overhead_dev);
 }
 
 module_init(init_ft_overhead_trace);
+module_exit(exit_ft_overhead_trace);