lkmc v2-rc

Unsquashed version at v2-rc-unsquashed, but that cannot be merged as it
breaks bisects at several points. All bugs will not bisect to this
humongous change.

It all started with a conversion of the Bash scripts to Python, mainly
because I couldn't stand not being able to properly use --options for
run which has a million options.

Then since that required a full testing, I decided to do all the
refactorings that I had in mind at once, and so I did and it became
v2-rc.

This is the largest patch I have ever done! OMG a few weeks of extra time.
I'm never writing a Bash script for anything that starts getting big again.

Some of the features are:

* separate build-qemu and build-gem5 commands
* common: convert scripts to python. Add --option for everything
* rename build to build-buildroot now that we are splitting all the build
  commands, Linux kernel to follow
* move all git submodules to submodules/ and all buildroot packages to
  packages/
* refactor the out/ structure. Keep projects on toplevel, because guest
  projects separate archs and host ones don't, making a toplevel arch wrong
* do-release: rename to just release
  https://stackoverflow.com/questions/16174992/cant-get-argparse-to-read-quoted-string-with-dashes-in-it
* run: add --terminal and explain gem5 pdb
* just track the lvimrc
* store CLI kernel config fragment inside buildlroot to avoid conflicts
* gem5: document m5 initparam
* readme: make a bunch of things awesomer
* readme: fix broken refs
* parsec-benchmark: update to 75d55ac446a43c47efb1044844a108c6c330184c
  Could not fetch otherwise.
* gem5: M5_OVERRIDE_PY_SOURCE

packages/kernel_modules/mmap.c

@@ -0,0 +1,139 @@
+/* https://github.com/cirosantilli/linux-kernel-module-cheat#mmap */
+
+#include <linux/fs.h>
+#include <linux/init.h>
+#include <linux/kernel.h> /* min */
+#include <linux/mm.h>
+#include <linux/module.h>
+#include <linux/proc_fs.h>
+#include <linux/uaccess.h> /* copy_from_user, copy_to_user */
+#include <linux/slab.h>
+
+static const char *filename = "lkmc_mmap";
+
+enum { BUFFER_SIZE = 4 };
+
+struct mmap_info {
+	char *data;
+};
+
+/* After unmap. */
+static void vm_close(struct vm_area_struct *vma)
+{
+	pr_info("vm_close\n");
+}
+
+/* First page access. */
+	int (*fault)(struct vm_fault *vmf);
+static int vm_fault(struct vm_fault *vmf)
+{
+	struct page *page;
+	struct mmap_info *info;
+
+	pr_info("vm_fault\n");
+	info = (struct mmap_info *)vmf->vma->vm_private_data;
+	if (info->data) {
+		page = virt_to_page(info->data);
+		get_page(page);
+		vmf->page = page;
+	}
+	return 0;
+}
+
+/* Aftr mmap. TODO vs mmap, when can this happen at a different time than mmap? */
+static void vm_open(struct vm_area_struct *vma)
+{
+	pr_info("vm_open\n");
+}
+
+static struct vm_operations_struct vm_ops =
+{
+	.close = vm_close,
+	.fault = vm_fault,
+	.open = vm_open,
+};
+
+static int mmap(struct file *filp, struct vm_area_struct *vma)
+{
+	pr_info("mmap\n");
+	vma->vm_ops = &vm_ops;
+	vma->vm_flags |= VM_DONTEXPAND | VM_DONTDUMP;
+	vma->vm_private_data = filp->private_data;
+	vm_open(vma);
+	return 0;
+}
+
+static int open(struct inode *inode, struct file *filp)
+{
+	struct mmap_info *info;
+
+	pr_info("open\n");
+	info = kmalloc(sizeof(struct mmap_info), GFP_KERNEL);
+	pr_info("virt_to_phys = 0x%llx\n", (unsigned long long)virt_to_phys((void *)info));
+	info->data = (char *)get_zeroed_page(GFP_KERNEL);
+	memcpy(info->data, "asdf", BUFFER_SIZE);
+	filp->private_data = info;
+	return 0;
+}
+
+static ssize_t read(struct file *filp, char __user *buf, size_t len, loff_t *off)
+{
+	struct mmap_info *info;
+    int ret;
+
+	pr_info("read\n");
+	info = filp->private_data;
+    ret = min(len, (size_t)BUFFER_SIZE);
+    if (copy_to_user(buf, info->data, ret)) {
+        ret = -EFAULT;
+	}
+	return ret;
+}
+
+static ssize_t write(struct file *filp, const char __user *buf, size_t len, loff_t *off)
+{
+	struct mmap_info *info;
+
+	pr_info("write\n");
+	info = filp->private_data;
+    if (copy_from_user(info->data, buf, min(len, (size_t)BUFFER_SIZE))) {
+        return -EFAULT;
+    } else {
+        return len;
+    }
+}
+
+static int release(struct inode *inode, struct file *filp)
+{
+	struct mmap_info *info;
+
+	pr_info("release\n");
+	info = filp->private_data;
+	free_page((unsigned long)info->data);
+	kfree(info);
+	filp->private_data = NULL;
+	return 0;
+}
+
+static const struct file_operations fops = {
+	.mmap = mmap,
+	.open = open,
+	.release = release,
+	.read = read,
+	.write = write,
+};
+
+static int myinit(void)
+{
+	proc_create(filename, 0, NULL, &fops);
+	return 0;
+}
+
+static void myexit(void)
+{
+	remove_proc_entry(filename, NULL);
+}
+
+module_init(myinit)
+module_exit(myexit)
+MODULE_LICENSE("GPL");