added exit reporting to thread exit path

[palacios.git] / linux_module / main.c

diff --git a/linux_module/main.c b/linux_module/main.c
index a6787ce..b24df34 100644 (file)
--- a/linux_module/main.c
+++ b/linux_module/main.c
@@ -5,6 +5,7 @@
 
 
 #include <linux/module.h>
+#include <linux/moduleparam.h>
 #include <linux/errno.h>
 #include <linux/percpu.h>
 #include <linux/fs.h>
@@ -28,6 +29,12 @@
 
 MODULE_LICENSE("GPL");
 
+// Module parameter
+int cpu_list[NR_CPUS] = {};
+int cpu_list_len = 0;
+module_param_array(cpu_list, int, &cpu_list_len, 0644);
+MODULE_PARM_DESC(cpu_list, "Comma-delimited list of CPUs that Palacios will run on");
+
 int mod_allocs = 0;
 int mod_frees = 0;
 
@@ -61,97 +68,68 @@ static long v3_dev_ioctl(struct file * filp,
 
 
     switch (ioctl) {
-       case V3_START_GUEST:{
+       case V3_CREATE_GUEST:{
            int vm_minor = 0;
            struct v3_guest_img user_image;
            struct v3_guest * guest = kmalloc(sizeof(struct v3_guest), GFP_KERNEL);
 
            if (IS_ERR(guest)) {
-               printk("Error allocating Kernel guest_image\n");
+               printk("Palacios: Error allocating Kernel guest_image\n");
                return -EFAULT;
            }
 
            memset(guest, 0, sizeof(struct v3_guest));
 
-           printk("Starting V3 Guest... (%p)\n", guest);
+           printk("Palacios: Creating V3 Guest...\n");
 
            vm_minor = register_vm(guest);
 
            if (vm_minor == -1) {
-               printk("Too many VMs are currently running\n");
+               printk("Palacios Error: Too many VMs are currently running\n");
                return -EFAULT;
            }
 
            guest->vm_dev = MKDEV(v3_major_num, vm_minor);
 
            if (copy_from_user(&user_image, argp, sizeof(struct v3_guest_img))) {
-               printk("copy from user error getting guest image...\n");
+               printk("Palacios Error: copy from user error getting guest image...\n");
                return -EFAULT;
            }
 
            guest->img_size = user_image.size;
 
-           printk("Allocating kernel memory for guest image (%llu bytes)\n", user_image.size);
+           printk("Palacios: Allocating kernel memory for guest image (%llu bytes)\n", user_image.size);
            guest->img = vmalloc(guest->img_size);
 
            if (IS_ERR(guest->img)) {
-               printk("Error: Could not allocate space for guest image\n");
+               printk("Palacios Error: Could not allocate space for guest image\n");
                return -EFAULT;
            }
 
            if (copy_from_user(guest->img, user_image.guest_data, guest->img_size)) {
-               printk("Error loading guest data\n");
+               printk("Palacios: Error loading guest data\n");
                return -EFAULT;
            }      
 
            strncpy(guest->name, user_image.name, 127);
 
-           printk("Launching VM\n");
-
            INIT_LIST_HEAD(&(guest->exts));
 
-           init_completion(&(guest->start_done));
-           init_completion(&(guest->thread_done));
-
-           { 
-               struct task_struct * launch_thread = NULL;
-               // At some point we're going to want to allow the user to specify a CPU mask
-               // But for now, well just launch from the local core, and rely on the global cpu mask
-
-               preempt_disable();
-               launch_thread = kthread_create(start_palacios_vm, guest, guest->name);
-               
-               if (IS_ERR(launch_thread)) {
-                   preempt_enable();
-                   printk("Palacios error creating launch thread for vm (%s)\n", guest->name);
-                   return -EFAULT;
-               }
-
-               kthread_bind(launch_thread, smp_processor_id());
-               preempt_enable();
-
-               wake_up_process(launch_thread);
+           if (create_palacios_vm(guest) == -1) {
+               printk("Palacios: Error creating guest\n");
+               return -EFAULT;
            }
 
-           wait_for_completion(&(guest->start_done));
-
-           return guest->vm_dev;
+           return vm_minor;
            break;
        }
-       case V3_STOP_GUEST: {
+       case V3_FREE_GUEST: {
            unsigned long vm_idx = arg;
            struct v3_guest * guest = guest_map[vm_idx];
 
-           printk("Stopping VM idx=%d\n", vm_idx);
-           printk("Stopping VM (%s) (%p)\n", guest->name, guest);
-
-
-           if (irqs_disabled()) {
-               printk("WHAT!!?? IRQs are disabled??\n");
-               break;
-           }
+           printk("Freeing VM (%s) (%p)\n", guest->name, guest);
 
-           stop_palacios_vm(guest);
+           free_palacios_vm(guest);
            guest_map[vm_idx] = NULL;
            break;
        }
@@ -200,9 +178,7 @@ static int __init v3_init(void) {
 
     palacios_init_mm();
 
-
     // Initialize Palacios
-    
     palacios_vmm_init();