Allocate only one page at a time. Add proc interface.

4 files changed, 228 insertions, 84 deletions

diff --git a/include/litmus/color.h b/include/litmus/color.h
index 3933cf12cf3f..ce182c2e65a7 100644
--- a/include/litmus/color.h
+++ b/include/litmus/color.h
@@ -1,6 +1,9 @@
 #ifndef LITMUS_COLOR_H
 #define LITMUS_COLOR_H
 
+#define ONE_COLOR_LEN 11
+#define ONE_COLOR_FMT "%4lu: %4d\n"
+
 struct color_cache_info {
         unsigned long size;
         unsigned long line_size;
@@ -8,4 +11,13 @@ struct color_cache_info {
         unsigned long sets;
 };
 
+void _add_page_to_color_list(struct page*);
+void add_page_to_color_list(struct page*);
+struct page* _get_colored_page(unsigned long);
+struct page* get_colored_page(unsigned long);
+
+int color_add_pages_handler(struct ctl_table *, int, void __user *,
+                size_t *, loff_t *);
+int color_nr_pages_handler(struct ctl_table *, int, void __user *,
+                size_t *, loff_t *);
 #endif
diff --git a/litmus/Makefile b/litmus/Makefile
index 506fdf9b0c51..e4c937bc2850 100644
--- a/litmus/Makefile
+++ b/litmus/Makefile
@@ -18,7 +18,8 @@ obj-y     = sched_plugin.o litmus.o \
             ctrldev.o \
             sched_gsn_edf.o \
             sched_psn_edf.o \
-            color.o
+            color.o \
+            color_proc.o
 
 obj-$(CONFIG_PLUGIN_CEDF) += sched_cedf.o
 obj-$(CONFIG_PLUGIN_PFAIR) += sched_pfair.o
diff --git a/litmus/color.c b/litmus/color.c
index b74b524655c8..e7aeab8c6598 100644
--- a/litmus/color.c
+++ b/litmus/color.c
@@ -5,9 +5,8 @@
 #include <linux/cpu.h>
 #include <linux/mm_types.h>
 #include <linux/slab.h>
-
-//#include <asm/page.h>
-//#include <asm/io.h>
+#include <linux/page-flags.h>
+#include <linux/sysctl.h>
 
 #include <litmus/color.h>
 
@@ -15,28 +14,139 @@
         printk(KERN_INFO "[%s@%s:%d]: " fmt, \
                         __FUNCTION__, __FILE__, __LINE__, ## args)
 
-#define ALLOC_ORDER (MAX_ORDER - 1)
-#define PAGES_PER_COLOR 1000
-
-struct color_cache_info color_cache_info;
-unsigned long color_mask;
-unsigned long nr_colors;
+#define PAGES_PER_COLOR 2000
 
 struct color_group {
         spinlock_t lock;
         struct list_head list;
-        unsigned long nr_pages;
+        atomic_t nr_pages;
 };
 
-struct color_group *color_groups;
+static unsigned long color_mask;
+static struct color_group *color_groups;
+
+/* non-static: extern'ed in various files */
+unsigned long nr_colors;
+struct color_cache_info color_cache_info;
+int color_sysctl_add_pages_data;
 
-static inline unsigned int page_color(struct page *page)
+static inline unsigned long page_color(struct page *page)
 {
         return ((page_to_phys(page) & color_mask) >> PAGE_SHIFT);
 }
 
+void add_page_to_color_list(struct page *page)
+{
+        const unsigned long color = page_color(page);
+        struct color_group *cgroup = &color_groups[color];
+        spin_lock(&cgroup->lock);
+        list_add_tail(&page->lru, &cgroup->list);
+        atomic_inc(&cgroup->nr_pages);
+        spin_unlock(&cgroup->lock);
+}
+
+struct page* get_colored_page(unsigned long color)
+{
+        struct color_group *cgroup;
+        struct page *page;
+        BUG_ON(color >= nr_colors);
+        cgroup = &color_groups[color];
+        spin_lock(&cgroup->lock);
+        BUG_ON(!atomic_read(&cgroup->nr_pages));
+        page = list_first_entry(&cgroup->list, struct page, lru);
+        list_del(&page->lru);
+        atomic_dec(&cgroup->nr_pages);
+        spin_unlock(&cgroup->lock);
+        return page;
+
+}
+
+static unsigned long smallest_nr_pages(void)
+{
+        unsigned long i, min_pages = -1;
+        struct color_group *cgroup;
+        for (i = 0; i < nr_colors; ++i) {
+                cgroup = &color_groups[i];
+                if (atomic_read(&cgroup->nr_pages) < min_pages)
+                        min_pages = atomic_read(&cgroup->nr_pages);
+        }
+        return min_pages;
+}
+
+static int do_add_pages(void)
+{
+        struct page *page, *page_tmp;
+        struct list_head free_later;
+        unsigned long color;
+        int ret = 0;
+
+        INIT_LIST_HEAD(&free_later);
+
+        while (smallest_nr_pages() < PAGES_PER_COLOR) {
+                page = alloc_page(GFP_HIGHUSER | __GFP_ZERO |
+                                __GFP_MOVABLE);
+                if (!page) {
+                        MPRINT("could not allocate pages\n");
+                        BUG();
+                }
+                color = page_color(page);
+                if (atomic_read(&color_groups[color].nr_pages) < PAGES_PER_COLOR)
+                        add_page_to_color_list(page);
+                else
+                        list_add_tail(&page->lru, &free_later);
+        }
+        list_for_each_entry_safe(page, page_tmp, &free_later, lru) {
+                list_del(&page->lru);
+                __free_page(page);
+        }
+        return ret;
+}
+
+
+/***********************************************************
+ * Proc
+***********************************************************/
+
+int color_add_pages_handler(struct ctl_table *table, int write, void __user *buffer,
+                size_t *lenp, loff_t *ppos)
+{
+        int ret;
+
+        ret = proc_dointvec_minmax(table, write, buffer, lenp, ppos);
+        if (ret)
+                return ret;
+        if (write && color_sysctl_add_pages_data)
+                do_add_pages();
+        return 0;
+}
+
+
+int color_nr_pages_handler(struct ctl_table *table, int write, void __user *buffer,
+                size_t *lenp, loff_t *ppos)
+{
+        struct color_group *cgroup;
+        char *buf;
+        unsigned long i;
+        int used = 0;
+
+        if (write)
+                return -EPERM;
+
+        for (i = 0; i < nr_colors; ++i) {
+                cgroup = &color_groups[i];
+                buf = ((char*)table->data) + used;
+                used += snprintf(buf, table->maxlen - used, ONE_COLOR_FMT,
+                                i, atomic_read(&cgroup->nr_pages));
+        }
+        return proc_dostring(table, write, buffer, lenp, ppos);
+}
+
+/***********************************************************
+ * Initialization
+***********************************************************/
+
 /* slowest possible way to find a log, but we only do this once on boot */
-static unsigned int slow_log(unsigned int v)
+static unsigned int __init slow_log(unsigned int v)
 {
         unsigned int r = 0;
         while (v >>= 1)
@@ -44,7 +154,7 @@ static unsigned int slow_log(unsigned int v)
         return r;
 }
 
-static void __init setup_mask(void)
+static void __init init_mask(void)
 {
         const unsigned int line_size_log = slow_log(color_cache_info.line_size);
 
@@ -58,103 +168,45 @@ static void __init setup_mask(void)
                         nr_colors);
 }
 
-/* don't trust nr_pages returned from here. it's just used on startup */
-static void _add_page_to_color_list(struct page *page)
-{
-        const unsigned long color = page_color(page);
-        struct color_group *cgroup = &color_groups[color];
-        spin_lock(&cgroup->lock);
-        list_add_tail(&page->lru, &cgroup->list);
-        cgroup->nr_pages++;
-        spin_unlock(&cgroup->lock);
-}
-
-static void add_page_to_color_list(struct page *page)
-{
-        unsigned long flags;
-        local_irq_save(flags);
-        _add_page_to_color_list(page);
-        local_irq_restore(flags);
-}
-
-static unsigned long __init smallest_nr_pages(void)
-{
-        unsigned long flags, i, min_pages = -1;
-        struct color_group *cgroup;
-        local_irq_save(flags);
-        for (i = 0; i < nr_colors; ++i) {
-                cgroup = &color_groups[i];
-                spin_lock(&cgroup->lock);
-                if (cgroup->nr_pages < min_pages)
-                        min_pages = cgroup->nr_pages;
-                spin_unlock(&cgroup->lock);
-        }
-        local_irq_restore(flags);
-        return min_pages;
-}
-
 static int __init init_color_groups(void)
 {
         struct color_group *cgroup;
-        unsigned long i, flags;
-        int ret = 0;
+        unsigned long i;
 
         color_groups = kmalloc(nr_colors * sizeof(struct color_group), GFP_KERNEL);
         if (!color_groups) {
                 printk(KERN_WARNING "Could not allocate color groups.\n");
-                ret = -ENOMEM;
-                goto out;
+                return -ENOMEM;
         }
 
         for (i = 0; i < nr_colors; ++i) {
                 cgroup = &color_groups[i];
-                cgroup->nr_pages = 0;
+                atomic_set(&cgroup->nr_pages, 0);
                 INIT_LIST_HEAD(&cgroup->list);
                 spin_lock_init(&cgroup->lock);
         }
-
-        while (smallest_nr_pages() < PAGES_PER_COLOR) {
-                struct page *page = alloc_pages(
-                                GFP_KERNEL | __GFP_HIGHMEM | __GFP_REPEAT,
-                                ALLOC_ORDER);
-                if (!page) {
-                        MPRINT("could not allocate pages\n");
-                        BUG();
-                }
-                local_irq_save(flags);
-                for (i = 0; i < (1UL << ALLOC_ORDER); ++i)
-                        _add_page_to_color_list(&page[i]);
-                local_irq_restore(flags);
-        }
-
-        local_irq_save(flags);
-        for (i = 0; i < nr_colors; ++i) {
-                cgroup = &color_groups[i];
-                spin_lock(&cgroup->lock);
-                MPRINT("color %3lu: %4lu pages\n", i, cgroup->nr_pages);
-                spin_unlock(&cgroup->lock);
-        }
-        local_irq_restore(flags);
-out:
-        return ret;
+        return 0;
 }
 
 static int __init init_color(void)
 {
+        int ret = 0;
 
-        MPRINT("ALLOC_ORDER is %d\n", ALLOC_ORDER);
         MPRINT("Cache size: %lu  line-size: %lu  ways: %lu  sets: %lu\n",
                         color_cache_info.size, color_cache_info.line_size,
                         color_cache_info.ways, color_cache_info.sets);
         if (!color_cache_info.size){
                 printk(KERN_WARNING "No cache information found.\n");
-                return -EINVAL;
+                ret = -EINVAL;
+                goto out;
         }
         BUG_ON(color_cache_info.size <= 1048576 ||
                         color_cache_info.ways < 15 ||
                         color_cache_info.line_size != 64);
-        setup_mask();
-        return init_color_groups();
+        init_mask();
+        ret = init_color_groups();
+out:
+        return ret;
 }
 
 module_init(init_color);
diff --git a/litmus/color_proc.c b/litmus/color_proc.c
new file mode 100644
index 000000000000..1eba0740db9d
--- /dev/null
+++ b/litmus/color_proc.c
@@ -0,0 +1,79 @@
+#include <linux/module.h>
+#include <linux/sysctl.h>
+#include <linux/slab.h>
+
+#include <litmus/color.h>
+
+extern int color_sysctl_add_pages_data; /* litmus/color.c */
+
+static int zero = 0;
+static int one = 1;
+
+#define NR_PAGES_INDEX 1 /* location of nr_pages in the table below */
+static struct ctl_table color_table[] =
+{
+        {
+                .procname       = "add_pages",
+                .data           = &color_sysctl_add_pages_data,
+                .maxlen         = sizeof(int),
+                .mode           = 0644,
+                .proc_handler   = color_add_pages_handler,
+                .extra1         = &zero,
+                .extra2         = &one,
+        },
+        {
+                .procname       = "nr_pages",
+                .mode           = 0444,
+                .proc_handler   = color_nr_pages_handler,
+                .data           = NULL, /* dynamically later */
+                .maxlen         = 0,    /* also set later */
+        },
+        { }
+};
+
+static struct ctl_table litmus_table[] =
+{
+        {
+                .procname       = "color",
+                .mode           = 0555,
+                .child          = color_table,
+        },
+        { }
+};
+static struct ctl_table litmus_dir_table[] = {
+        {
+                .procname       = "litmus",
+                .mode           = 0555,
+                .child          = litmus_table,
+        },
+        { }
+};
+
+extern unsigned long nr_colors; /* litmus/color.c */
+
+/* must be called AFTER nr_colors is set */
+static int __init init_sysctl_nr_colors(void)
+{
+        int maxlen = ONE_COLOR_LEN * nr_colors;
+        color_table[NR_PAGES_INDEX].data = kmalloc(maxlen, GFP_KERNEL);
+        if (!color_table[NR_PAGES_INDEX].data) {
+                printk(KERN_WARNING "Could not allocate nr_pages buffer.\n");
+                return -ENOMEM;
+        }
+        color_table[NR_PAGES_INDEX].maxlen = maxlen;
+        return 0;
+}
+
+static struct ctl_table_header *litmus_sysctls;
+
+static int __init litmus_sysctl_init(void)
+{
+        litmus_sysctls = register_sysctl_table(litmus_dir_table);
+        if (!litmus_sysctls) {
+                printk(KERN_WARNING "Could not register LITMUS^RT sysctl.\n");
+                return -EFAULT;
+        }
+        return init_sysctl_nr_colors();
+}
+
+module_init(litmus_sysctl_init);