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

1 files changed, 135 insertions, 83 deletions

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);