Untested proc code added.

1 files changed, 293 insertions, 9 deletions

diff --git a/litmus/sched_mc_ce.c b/litmus/sched_mc_ce.c
index b44012822532..8ed960c8729c 100644
--- a/litmus/sched_mc_ce.c
+++ b/litmus/sched_mc_ce.c
@@ -6,27 +6,31 @@
  */
 
 #include <asm/atomic.h>
+#include <asm/uaccess.h>
 
 #include <linux/module.h>
 #include <linux/percpu.h>
 #include <linux/hrtimer.h>
 #include <linux/pid.h>
 #include <linux/sched.h>
+#include <linux/proc_fs.h>
 
 #include <litmus/litmus.h>
 #include <litmus/sched_plugin.h>
 #include <litmus/rt_domain.h>
 #include <litmus/rt_param.h>
 #include <litmus/sched_mc.h>
+#include <litmus/litmus_proc.h>
 
 static struct sched_plugin mc_ce_plugin __cacheline_aligned_in_smp;
 
 #define tsk_mc_data(t) (tsk_rt(t)->mc_data)
 #define tsk_mc_crit(t) (tsk_mc_data(t)->mc_task.crit)
-#define is_active_plugin() (litmus == mc_ce_plugin)
+#define is_active_plugin() (litmus == &mc_ce_plugin)
 
 static atomic_t start_time_set = ATOMIC_INIT(0);
 static atomic64_t start_time = ATOMIC64_INIT(0);
+static struct proc_dir_entry *mc_ce_dir = NULL, *ce_file = NULL;
 
 /*
  * Cache the budget along with the struct PID for a task so that we don't need
@@ -35,7 +39,9 @@ static atomic64_t start_time = ATOMIC64_INIT(0);
  */
 struct ce_dom_pid_entry {
         struct pid *pid;
+        /* execution cost (sometimes called budget) */
         lt_t exec_cost;
+        /* accumulated (summed) exec costs, including this one */
         lt_t acc_time;
 };
 
@@ -470,12 +476,38 @@ static struct sched_plugin mc_ce_plugin __cacheline_aligned_in_smp = {
         .deactivate_plugin      = mc_ce_deactivate_plugin,
 };
 
+static void clear_pid_entries(void)
+{
+        int cpu, entry;
+        domain_t *dom;
+        struct ce_dom_data *ce_data;
+
+        for_each_online_cpu(cpu) {
+                dom = &per_cpu(mc_ce_doms, cpu);
+                ce_data = dom->data;
+                ce_data->num_pid_entries = 0;
+                ce_data->cycle_time = 0;
+                for (entry = 0; entry < CONFIG_PLUGIN_MC_LEVEL_A_MAX_TASKS;
+                                ++entry) {
+                        if (NULL != ce_data->pid_entries[entry].pid) {
+                                put_pid(ce_data->pid_entries[entry].pid);
+                                ce_data->pid_entries[entry].pid = NULL;
+                        }
+                        ce_data->pid_entries[entry].exec_cost = 0;
+                        ce_data->pid_entries[entry].acc_time = 0;
+                }
+        }
+}
+
+static int setup_proc(void);
+
 static int __init init_sched_mc_ce(void)
 {
         struct ce_dom_data *ce_data;
         domain_t *dom;
-        int cpu, i;
+        int cpu, err;
 
+        clear_pid_entries();
         for_each_online_cpu(cpu) {
                 dom = &per_cpu(mc_ce_doms, cpu);
                 pd_domain_init(dom, NULL, NULL, NULL, NULL);
@@ -484,17 +516,269 @@ static int __init init_sched_mc_ce(void)
                 hrtimer_init(&ce_data->timer, CLOCK_MONOTONIC, HRTIMER_MODE_ABS);
                 hrtimer_start_on_info_init(&ce_data->timer_info);
                 ce_data->cpu = cpu;
-                ce_data->num_pid_entries = 0;
-                ce_data->cycle_time = 0;
                 ce_data->timer.function = timer_callback;
+        }
+        err = setup_proc();
+        if (!err)
+                err = register_sched_plugin(&mc_ce_plugin);
+        return err;
+}
+
+#define BUF_SIZE PAGE_SIZE
+static int write_into_proc(char *proc_buf, const int proc_size, char *fmt, ...)
+{
+        static char buf[BUF_SIZE];
+        int n;
+        va_list args;
+
+        va_start(args, fmt);
+        n = vscnprintf(buf, BUF_SIZE, fmt, args);
+        va_end(args);
+        if (BUF_SIZE <= n || proc_size <= n - 1) {
+                /* too big for formatting buffer or proc (less null byte) */
+                n = -EINVAL;
+                goto out;
+        }
+        memcpy(proc_buf, buf, n - 1);
+out:
+        return n;
+}
+#undef BUF_SIZE
+
+/*
+ * Writes a PID entry to the procfs.
+ */
+#define PID_SPACE 15
+#define TASK_INFO_BUF (PID_SPACE + TASK_COMM_LEN)
+static int write_pid_entry(char *page, const int count, const int cpu,
+                const int task, struct ce_dom_pid_entry *pid_entry)
+{
+        static char task_info[TASK_INFO_BUF];
+        struct task_struct *ts;
+        int n = 0, err, ti_n;
+        char *ti_b;
+
+        if (pid_entry->pid) {
+                rcu_read_lock();
+                ts = pid_task(pid_entry->pid, PIDTYPE_PID);
+                rcu_read_unlock();
+
+                /* get some information about the task */
+                if (ts) {
+                        ti_b = task_info;
+                        ti_n = snprintf(ti_b, PID_SPACE, "%d", ts->pid);
+                        if (PID_SPACE <= ti_n)
+                                ti_n = PID_SPACE - 1;
+                        ti_b += ti_n;
+                        *ti_b = ' '; /* nuke the null byte */
+                        ti_b++;
+                        get_task_comm(ti_b, ts);
+                        task_info[TASK_INFO_BUF - 1] = '\0';
+                } else {
+                        const char *msg = "pid_task() failed :(";
+                        strncpy(task_info, msg, sizeof(msg));
+                }
+
+        } else
+                strncpy(task_info, "no", 3);
+
+        err = write_into_proc(page, count - n, "# task: %s\n", task_info);
+        if (err < 0) {
+                n = -ENOSPC;
+                goto out;
+        }
+        n += err;
+        err = write_into_proc(page, count - n, "%d, %d, %llu\n",
+                        cpu, task, pid_entry->exec_cost);
+        if (err < 0) {
+                n = -ENOSPC;
+                goto out;
+        }
+        n =+ err;
+out:
+        return n;
+}
+#undef PID_SPACE
+#undef TASK_INFO_BUF
 
-                for (i = 0; i < CONFIG_PLUGIN_MC_LEVEL_A_MAX_TASKS; ++i) {
-                        ce_data->pid_entries[i].pid = NULL;
-                        ce_data->pid_entries[i].exec_cost = 0;
-                        ce_data->pid_entries[i].acc_time = 0;
+/*
+ * Called when the user-land reads from proc.
+ */
+static int proc_read_ce_file(char *page, char **start, off_t off, int count,
+                int *eof, void *data)
+{
+        int n = 0, err, cpu, t;
+        struct ce_dom_data *ce_data;
+        domain_t *dom;
+
+        if (off > 0) {
+                *eof = 1;
+                return 0;
+        }
+
+        for_each_online_cpu(cpu) {
+                dom = &per_cpu(mc_ce_doms, cpu);
+                ce_data = dom->data;
+                for (t = 0; t < ce_data->num_pid_entries; ++t) {
+                        err = write_pid_entry(page, count - n,
+                                        cpu, t, &ce_data->pid_entries[t]);
+                        if (err < 0) {
+                                n = -ENOSPC;
+                                goto out;
+                        }
+                        n += err;
                 }
         }
-        return register_sched_plugin(&mc_ce_plugin);
+        *eof = 1;
+out:
+        return n;
+}
+
+/*
+ * Skip a commented line.
+ */
+static int skip_comment(const char *buf, const unsigned long max)
+{
+        unsigned long i = 0;
+        const char *c = buf;
+        if (0 == max || !c || *c != '#')
+                return 0;
+        ++c; ++i;
+        for (; i < max; ++i) {
+                if (*c == '\n') {
+                        ++c; ++i;
+                        break;
+                }
+                ++c;
+        }
+        return i;
+}
+
+/* a budget of 1 millisecond is probably reasonable */
+#define BUDGET_THRESHOLD 1000000ULL
+static int setup_pid_entry(const int cpu, const int task, const lt_t budget)
+{
+        domain_t *dom = &per_cpu(mc_ce_doms, cpu);
+        struct ce_dom_data *ce_data = dom->data;
+        struct ce_dom_pid_entry *new_entry;
+        int err = 0;
+
+        /* check the inputs */
+        if (cpu < 0 || cpu >= NR_CPUS || task < 1 || task > PID_MAX_DEFAULT ||
+                        budget < 1) {
+                printk(KERN_INFO "litmus: bad cpu or task ID sent to "
+                                "MC-CE proc\n");
+                err = -EINVAL;
+                goto out;
+        }
+        /* check for small budgets */
+        if (BUDGET_THRESHOLD > budget) {
+                printk(KERN_CRIT "litmus: you gave a small budget for an "
+                                "MC-CE task; that might be an issue.\n");
+        }
+        /* check that we have space for a new entry */
+        if (CONFIG_PLUGIN_MC_LEVEL_A_MAX_TASKS <= ce_data->num_pid_entries) {
+                printk(KERN_INFO "litmus: too many MC-CE tasks for cpu "
+                                "%d\n", cpu);
+                err = -EINVAL;
+                goto out;
+        }
+        /* add the new entry */
+        new_entry = &ce_data->pid_entries[ce_data->num_pid_entries];
+        BUG_ON(NULL != new_entry->pid);
+        new_entry->exec_cost = budget;
+        new_entry->acc_time = ce_data->cycle_time + budget;
+        /* update the domain entry */
+        ce_data->cycle_time += budget;
+        ce_data->num_pid_entries++;
+out:
+        return err;
+}
+#undef BUDGET_THRESHOLD
+
+/*
+ * Called when the user-land writes to proc.
+ *
+ * Error checking is quite minimal. Format is:
+ * <cpu>, <process ID>, <budget>
+ */
+#define PROCFS_MAX_SIZE PAGE_SIZE
+static int proc_write_ce_file(struct file *file, const char __user *buffer,
+                unsigned long count, void *data)
+{
+        static char kbuf[PROCFS_MAX_SIZE];
+        char *c = kbuf, *c_skipped;
+        int cpu, task, cnt = 0, chars_read, converted, err;
+        lt_t budget;
+
+        if (is_active_plugin()) {
+                printk(KERN_INFO "litmus: can't edit MC-CE proc when plugin "
+                                "active\n");
+                cnt = -EINVAL;
+                goto out;
+        }
+
+        if (count > PROCFS_MAX_SIZE) {
+                cnt = -EINVAL;
+                goto out;
+        }
+
+        if (copy_from_user(kbuf, buffer, count)) {
+                cnt = -EFAULT;
+                goto out;
+        }
+        clear_pid_entries();
+        while (cnt < count) {
+                c_skipped = skip_spaces(c);
+                if (c_skipped != c) {
+                        chars_read = c_skipped - c;
+                        cnt += chars_read;
+                        c += chars_read;
+                        continue;
+                }
+                if (*c == '#') {
+                        chars_read = skip_comment(c, count - cnt);
+                        cnt += chars_read;
+                        c += chars_read;
+                        continue;
+                }
+                chars_read = sscanf(c, "%d, %d, %llu%n", &cpu, &task, &budget,
+                                &converted);
+                if (3 != converted) {
+                        cnt = -EINVAL;
+                        goto out;
+                }
+                cnt += chars_read;
+                c += chars_read;
+                err = setup_pid_entry(cpu, task, budget);
+                if (err) {
+                        cnt = -EINVAL;
+                        goto out;
+                }
+        }
+out:
+        return cnt;
+}
+#undef PROCFS_MAX_SIZE
+
+static int setup_proc(void)
+{
+        int err;
+        err = make_plugin_proc_dir(&mc_ce_plugin, &mc_ce_dir);
+        if (err) {
+                printk(KERN_ERR "could not create MC-CE procfs dir.\n");
+                goto out;
+        }
+        ce_file = create_proc_entry("ce_file", 0644, mc_ce_dir);
+        if (!ce_file) {
+                printk(KERN_ERR "could not create MC-CE procfs file.\n");
+                err = -EIO;
+                goto out;
+        }
+        ce_file->read_proc = proc_read_ce_file;
+        ce_file->write_proc = proc_write_ce_file;
+out:
+        return err;
 }
 
 module_init(init_sched_mc_ce);