Page reclaiming, control devices, cleanup.

Track allocated pages and add a proc handler to reclaim free pages and
add control device for allocating colored memory with mmap.

1 files changed, 312 insertions, 0 deletions

diff --git a/litmus/color_dev.c b/litmus/color_dev.c
new file mode 100644
index 000000000000..b8218b6d1d9c
--- /dev/null
+++ b/litmus/color_dev.c
@@ -0,0 +1,312 @@
+#include <linux/sched.h>
+#include <linux/mm.h>
+#include <linux/fs.h>
+#include <linux/miscdevice.h>
+#include <linux/spinlock.h>
+#include <linux/module.h>
+
+#include <litmus/litmus.h>
+#include <litmus/color.h>
+
+#define ALLOC_NAME      "litmus/color_alloc"
+#define CTRL_NAME       "litmus/color_ctrl"
+
+static struct non_rt_colors {
+        spinlock_t lock;
+        unsigned long color;
+} non_rt_colors;
+
+extern unsigned long nr_colors;
+
+/***********************************************************
+ * Control device
+***********************************************************/
+
+static void litmus_color_ctrl_vm_close(struct vm_area_struct *vma)
+{
+        TRACE_CUR("%s flags=0x%lx prot=0x%lx\n", __FUNCTION__,
+                        vma->vm_flags, pgprot_val(vma->vm_page_prot));
+
+        TRACE_CUR(CTRL_NAME ": %p:%p vma:%p vma->vm_private_data:%p closed.\n",
+                        (void*) vma->vm_start, (void*) vma->vm_end, vma,
+                        vma->vm_private_data);
+}
+
+static int litmus_color_ctrl_vm_fault(struct vm_area_struct *vma,
+                struct vm_fault *vmf)
+{
+        /* This function should never be called, since
+         * all pages should have been mapped by mmap()
+         * already. */
+        TRACE_CUR("%s flags=0x%lx\n", __FUNCTION__, vma->vm_flags);
+        printk(KERN_WARNING "fault: %s flags=0x%lx\n", __FUNCTION__,
+                        vma->vm_flags);
+
+        /* nope, you only get one page */
+        return VM_FAULT_SIGBUS;
+}
+
+static struct vm_operations_struct litmus_color_ctrl_vm_ops = {
+        .close  = litmus_color_ctrl_vm_close,
+        .fault  = litmus_color_ctrl_vm_fault,
+};
+
+static int mmap_common_checks(struct vm_area_struct *vma)
+{
+        /* you can only map the "first" page */
+        if (vma->vm_pgoff != 0)
+                return -EINVAL;
+
+        /* you can't share it with anyone */
+        if (vma->vm_flags & (VM_MAYSHARE | VM_SHARED))
+                return -EINVAL;
+
+        return 0;
+}
+
+static int alloc_color_ctrl_page(void)
+{
+        struct task_struct *t;
+        int err = 0;
+
+        t = current;
+        /* only allocate if the task doesn't have one yet */
+        if (!tsk_rt(t)->color_ctrl_page) {
+                tsk_rt(t)->color_ctrl_page = (void*) get_zeroed_page(GFP_KERNEL);
+                if (!tsk_rt(t)->color_ctrl_page)
+                        err = -ENOMEM;
+                /* will get de-allocated in task teardown */
+                TRACE_TASK(t, "%s color_ctrl_page = %p\n", __FUNCTION__,
+                           tsk_rt(t)->color_ctrl_page);
+        }
+        return err;
+}
+
+static int map_color_ctrl_page(struct vm_area_struct *vma)
+{
+        int err;
+        unsigned long pfn;
+        struct task_struct *t = current;
+        struct page *color_ctrl = virt_to_page(tsk_rt(t)->color_ctrl_page);
+
+        t = current;
+        /* Increase ref count. Is decreased when vma is destroyed. */
+        get_page(color_ctrl);
+        pfn = page_to_pfn(color_ctrl);
+
+        TRACE_CUR(CTRL_NAME
+                  ": mapping %p (pfn:%lx, %lx) to 0x%lx (prot:%lx)\n",
+                  tsk_rt(t)->color_ctrl_page, pfn, page_to_pfn(color_ctrl),
+                  vma->vm_start, vma->vm_page_prot);
+
+        /* Map it into the vma. Make sure to use PAGE_SHARED, otherwise
+         * userspace actually gets a copy-on-write page. */
+        err = remap_pfn_range(vma, vma->vm_start, pfn, PAGE_SIZE, PAGE_SHARED);
+        TRACE_CUR("page shared: guess:0x1(63)...1??111  actual:0x%lx\n", PAGE_SHARED);
+        /* present, RW, user, accessed, NX=63 */
+
+        if (err)
+                TRACE_CUR(CTRL_NAME ": remap_pfn_range() failed (%d)\n", err);
+
+        return err;
+}
+
+static int litmus_color_ctrl_mmap(struct file *filp, struct vm_area_struct *vma)
+{
+        int err = 0;
+
+        /* you can only get one page */
+        if (vma->vm_end - vma->vm_start != PAGE_SIZE) {
+                err = -EINVAL;
+                goto out;
+        }
+
+        err = mmap_common_checks(vma);
+        if (err)
+                goto out;
+
+        vma->vm_ops = &litmus_color_ctrl_vm_ops;
+        /* this mapping should not be kept across forks,
+         * and cannot be expanded */
+        vma->vm_flags |= VM_DONTCOPY | VM_DONTEXPAND;
+
+        err = alloc_color_ctrl_page();
+        if (!err)
+                err = map_color_ctrl_page(vma);
+
+        TRACE_CUR("%s flags=0x%lx prot=0x%lx\n", __FUNCTION__, vma->vm_flags,
+                        pgprot_val(vma->vm_page_prot));
+out:
+        return err;
+}
+
+
+/***********************************************************
+ * Allocation device
+***********************************************************/
+
+static int map_colored_pages_non_rt(struct vm_area_struct *vma)
+{
+        unsigned long color, mapped;
+        int err;
+        const unsigned long nr_pages = (vma->vm_end - vma->vm_start) >> PAGE_SHIFT;
+
+        spin_lock(&non_rt_colors.lock);
+        color = non_rt_colors.color;
+        non_rt_colors.color = (non_rt_colors.color + nr_pages) % nr_colors;
+        spin_unlock(&non_rt_colors.lock);
+
+        TRACE_CUR(ALLOC_NAME ": allocating %lu pages from color %lu.\n",
+                        nr_pages, color);
+
+        for (mapped = 0; mapped < nr_pages;
+                        mapped++, color = (color + 1) % nr_colors)
+        {
+                struct page *page = get_colored_page(color);
+                const unsigned long addr = vma->vm_start + PAGE_SIZE * mapped;
+
+                if (!page) {
+                        TRACE_CUR(ALLOC_NAME ": Could not get page with "
+                                        " color %lu.\n", color);
+                        /* TODO unmap mapped pages */
+                        break;
+                }
+                TRACE_CUR(ALLOC_NAME ": insert page (pa:0x%llx, pfn:%lu, "
+                                "color:%lu count:%d LRU:%d) at 0x%lx "
+                                "(prot: 0x%lx)\n",
+                                page_to_phys(page), page_to_pfn(page), color,
+                                page_count(page), PageLRU(page), addr,
+                                pgprot_val(vma->vm_page_prot));
+                err = vm_insert_page(vma, addr, page);
+                if (err) {
+                        TRACE_CUR(ALLOC_NAME ": vm_insert_page() failed "
+                                        "(%d)\n", err);
+                        /* TODO unmap mapped pages */
+                        break;
+                }
+                add_page_to_alloced_list(page);
+        }
+        return err;
+}
+
+static int map_colored_pages_rt(struct vm_area_struct *vma)
+{
+        /* TODO */
+        return -EINVAL;
+}
+
+static int map_colored_pages(struct vm_area_struct *vma)
+{
+        if (likely(is_realtime(current)))
+                return map_colored_pages_rt(vma);
+        return map_colored_pages_non_rt(vma);
+}
+
+static void litmus_color_alloc_vm_close(struct vm_area_struct *vma)
+{
+        TRACE_CUR("%s flags=0x%lx prot=0x%lx\n", __FUNCTION__,
+                        vma->vm_flags, pgprot_val(vma->vm_page_prot));
+
+        TRACE_CUR(ALLOC_NAME ": %p:%p vma:%p vma->vm_private_data:%p closed.\n",
+                        (void*) vma->vm_start, (void*) vma->vm_end, vma,
+                        vma->vm_private_data);
+}
+
+static int litmus_color_alloc_vm_fault(struct vm_area_struct *vma,
+                struct vm_fault *vmf)
+{
+        /* This function should never be called, since
+         * all pages should have been mapped by mmap()
+         * already. */
+        TRACE_CUR("%s flags=0x%lx\n", __FUNCTION__, vma->vm_flags);
+        printk(KERN_WARNING "fault: %s flags=0x%lx\n", __FUNCTION__,
+                        vma->vm_flags);
+
+        /* nope, you only get one page */
+        return VM_FAULT_SIGBUS;
+}
+
+static struct vm_operations_struct litmus_color_alloc_vm_ops = {
+        .close  = litmus_color_alloc_vm_close,
+        .fault  = litmus_color_alloc_vm_fault,
+};
+
+static int litmus_color_alloc_mmap(struct file *filp, struct vm_area_struct *vma)
+{
+        int err = 0;
+
+        /* you may only request integer multiple of PAGE_SIZE */
+        if (offset_in_page(vma->vm_end - vma->vm_start)) {
+                err = -EINVAL;
+                goto out;
+        }
+
+        err = mmap_common_checks(vma);
+        if (err)
+                goto out;
+
+        vma->vm_ops = &litmus_color_alloc_vm_ops;
+        /* this mapping should not be kept across forks,
+         * and cannot be expanded */
+        vma->vm_flags |= VM_DONTCOPY | VM_DONTEXPAND;
+
+        err = map_colored_pages(vma);
+
+        TRACE_CUR("%s flags=0x%lx prot=0x%lx\n", __FUNCTION__, vma->vm_flags,
+                        pgprot_val(vma->vm_page_prot));
+out:
+        return err;
+}
+
+/***********************************************************
+ * Initilization
+***********************************************************/
+
+static struct file_operations litmus_color_ctrl_fops = {
+        .owner  = THIS_MODULE,
+        .mmap   = litmus_color_ctrl_mmap,
+};
+
+static struct miscdevice litmus_color_ctrl_dev = {
+        .name   = CTRL_NAME,
+        .minor  = MISC_DYNAMIC_MINOR,
+        .fops   = &litmus_color_ctrl_fops,
+};
+
+static struct file_operations litmus_color_alloc_fops = {
+        .owner  = THIS_MODULE,
+        .mmap   = litmus_color_alloc_mmap,
+};
+
+static struct miscdevice litmus_color_alloc_dev = {
+        .name   = ALLOC_NAME,
+        .minor  = MISC_DYNAMIC_MINOR,
+        .fops   = &litmus_color_alloc_fops,
+};
+
+static int __init init_dev(const char* name, struct miscdevice *dev)
+{
+        int err;
+        err = misc_register(dev);
+        if (err)
+                printk(KERN_WARNING "Could not allocate %s device (%d).\n",
+                                name, err);
+        return err;
+}
+
+static int __init init_color_devices(void)
+{
+        int err;
+        spin_lock_init(&non_rt_colors.lock);
+        non_rt_colors.color = 0;
+
+        printk("Allocating LITMUS^RT color devices.\n");
+        err = init_dev(ALLOC_NAME, &litmus_color_alloc_dev);
+        if (err)
+                goto out;
+        err = init_dev(CTRL_NAME, &litmus_color_ctrl_dev);
+out:
+        return err;
+}
+
+module_init(init_color_devices);