Add LITMUS^RT core implementation

This patch adds the core of LITMUS^RT:

 - library functionality (heaps, rt_domain, prioritization, etc.)
 - budget enforcement logic
 - job management
 - system call backends
 - virtual devices (control page, etc.)
 - scheduler plugin API (and dummy plugin)

This code compiles, but is not yet integrated with the rest of Linux.

1 files changed, 102 insertions, 0 deletions

diff --git a/litmus/uncachedev.c b/litmus/uncachedev.c
new file mode 100644
index 000000000000..06a6a7c17983
--- /dev/null
+++ b/litmus/uncachedev.c
@@ -0,0 +1,102 @@
+#include <linux/sched.h>
+#include <linux/kernel.h>
+#include <linux/mm.h>
+#include <linux/fs.h>
+#include <linux/errno.h>
+#include <linux/highmem.h>
+#include <asm/page.h>
+#include <linux/miscdevice.h>
+#include <linux/module.h>
+
+#include <litmus/litmus.h>
+
+/* device for allocating pages not cached by the CPU */
+
+#define UNCACHE_NAME        "litmus/uncache"
+
+void litmus_uncache_vm_open(struct vm_area_struct *vma)
+{
+}
+
+void litmus_uncache_vm_close(struct vm_area_struct *vma)
+{
+}
+
+int litmus_uncache_vm_fault(struct vm_area_struct* vma,
+                                                        struct vm_fault* vmf)
+{
+        /* modeled after SG DMA video4linux, but without DMA. */
+        /* (see drivers/media/video/videobuf-dma-sg.c) */
+        struct page *page;
+
+        page = alloc_page(GFP_USER);
+        if (!page)
+                return VM_FAULT_OOM;
+
+        clear_user_highpage(page, (unsigned long)vmf->virtual_address);
+        vmf->page = page;
+
+        return 0;
+}
+
+static struct vm_operations_struct litmus_uncache_vm_ops = {
+        .open = litmus_uncache_vm_open,
+        .close = litmus_uncache_vm_close,
+        .fault = litmus_uncache_vm_fault,
+};
+
+static int litmus_uncache_mmap(struct file* filp, struct vm_area_struct* vma)
+{
+        /* first make sure mapper knows what he's doing */
+
+        /* 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;
+
+        /* cannot be expanded, and is not a "normal" page. */
+        vma->vm_flags |= VM_DONTEXPAND;
+
+        /* noncached pages are not explicitly locked in memory (for now). */
+        vma->vm_page_prot = pgprot_noncached(vma->vm_page_prot);
+
+        vma->vm_ops = &litmus_uncache_vm_ops;
+
+        return 0;
+}
+
+static struct file_operations litmus_uncache_fops = {
+        .owner = THIS_MODULE,
+        .mmap  = litmus_uncache_mmap,
+};
+
+static struct miscdevice litmus_uncache_dev = {
+        .name  = UNCACHE_NAME,
+        .minor = MISC_DYNAMIC_MINOR,
+        .fops  = &litmus_uncache_fops,
+        /* pages are not locked, so there is no reason why
+           anyone cannot allocate an uncache pages */
+        .mode  = (S_IRUGO | S_IWUGO),
+};
+
+static int __init init_litmus_uncache_dev(void)
+{
+        int err;
+
+        printk("Initializing LITMUS^RT uncache device.\n");
+        err = misc_register(&litmus_uncache_dev);
+        if (err)
+                printk("Could not allocate %s device (%d).\n", UNCACHE_NAME, err);
+        return err;
+}
+
+static void __exit exit_litmus_uncache_dev(void)
+{
+        misc_deregister(&litmus_uncache_dev);
+}
+
+module_init(init_litmus_uncache_dev);
+module_exit(exit_litmus_uncache_dev);