linux_module/palacios-dev.c

   1 /*
   2    Palacios main control interface
   3    (c) Jack Lange, 2010
   4  */
   5
   6
   7 #include <linux/module.h>
   8 #include <linux/errno.h>
   9 #include <linux/percpu.h>
  10 #include <linux/fs.h>
  11 #include <linux/uaccess.h>
  12 #include <linux/device.h>
  13 #include <linux/cdev.h>
  14
  15 #include <linux/io.h>
  16
  17 #include <linux/file.h>
  18 #include <linux/spinlock.h>
  19 #include <linux/kthread.h>
  20
  21 #include "palacios.h"
  22 #include "palacios-mm.h"
  23 #include "palacios-vm.h"
  24 #include "palacios-serial.h"
  25 #include "palacios-vnet.h"
  26
  27 #include "linux-exts.h"
  28
  29
  30 #ifdef V3_CONFIG_KEYED_STREAMS
  31 #include "palacios-keyed-stream.h"
  32 #endif
  33
  34
  35 MODULE_LICENSE("GPL");
  36
  37 int mod_allocs = 0;
  38 int mod_frees = 0;
  39
  40
  41 static int v3_major_num = 0;
  42
  43 static u8 v3_minor_map[MAX_VMS / 8] = {[0 ... (MAX_VMS / 8) - 1] = 0};
  44
  45
  46 struct class * v3_class = NULL;
  47 static struct cdev ctrl_dev;
  48
  49 static int register_vm( void ) {
  50     int i, j = 0;
  51     int avail = 0;
  52
  53     for (i = 0; i < sizeof(v3_minor_map); i++) {
  54         if (v3_minor_map[i] != 0xff) {
  55             for (j = 0; j < 8; j++) {
  56                 if (!(v3_minor_map[i] & (0x1 << j))) {
  57                     avail = 1;
  58                     v3_minor_map[i] |= (0x1 << j);
  59                     break;
  60                 }
  61             }
  62
  63             if (avail == 1) {
  64                 break;
  65             }
  66         }
  67     }
  68
  69     if (avail == 0) {
  70         return -1;
  71     }
  72
  73     return (i * 8) + j;
  74 }
  75
  76
  77
  78 static long v3_dev_ioctl(struct file * filp,
  79                          unsigned int ioctl, unsigned long arg) {
  80     void __user * argp = (void __user *)arg;
  81     printk("V3 IOCTL %d\n", ioctl);
  82
  83
  84     switch (ioctl) {
  85         case V3_START_GUEST:{
  86             int vm_minor = 0;
  87             struct v3_guest_img user_image;
  88             struct v3_guest * guest = kmalloc(sizeof(struct v3_guest), GFP_KERNEL);
  89
  90             if (IS_ERR(guest)) {
  91                 printk("Error allocating Kernel guest_image\n");
  92                 return -EFAULT;
  93             }
  94
  95             memset(guest, 0, sizeof(struct v3_guest));
  96
  97             printk("Starting V3 Guest...\n");
  98
  99             vm_minor = register_vm();
 100
 101             if (vm_minor == -1) {
 102                 printk("Too many VMs are currently running\n");
 103                 return -EFAULT;
 104             }
 105
 106             guest->vm_dev = MKDEV(v3_major_num, vm_minor);
 107
 108             if (copy_from_user(&user_image, argp, sizeof(struct v3_guest_img))) {
 109                 printk("copy from user error getting guest image...\n");
 110                 return -EFAULT;
 111             }
 112
 113             guest->img_size = user_image.size;
 114
 115             printk("Allocating kernel memory for guest image (%llu bytes)\n", user_image.size);
 116             guest->img = vmalloc(guest->img_size);
 117
 118             if (IS_ERR(guest->img)) {
 119                 printk("Error: Could not allocate space for guest image\n");
 120                 return -EFAULT;
 121             }
 122
 123             if (copy_from_user(guest->img, user_image.guest_data, guest->img_size)) {
 124                 printk("Error loading guest data\n");
 125                 return -EFAULT;
 126             }
 127
 128             strncpy(guest->name, user_image.name, 127);
 129
 130             printk("Launching VM\n");
 131
 132             INIT_LIST_HEAD(&(guest->exts));
 133
 134
 135 #ifdef V3_CONFIG_HOST_DEVICE
 136             INIT_LIST_HEAD(&(guest->hostdev.devs));
 137 #endif
 138             init_completion(&(guest->start_done));
 139             init_completion(&(guest->thread_done));
 140
 141             {
 142                 struct task_struct * launch_thread = NULL;
 143                 // At some point we're going to want to allow the user to specify a CPU mask
 144                 // But for now, well just launch from the local core, and rely on the global cpu mask
 145
 146                 preempt_disable();
 147                 launch_thread = kthread_create(start_palacios_vm, guest, guest->name);
 148
 149                 if (IS_ERR(launch_thread)) {
 150                     preempt_enable();
 151                     printk("Palacios error creating launch thread for vm (%s)\n", guest->name);
 152                     return -EFAULT;
 153                 }
 154
 155                 kthread_bind(launch_thread, smp_processor_id());
 156                 preempt_enable();
 157
 158                 wake_up_process(launch_thread);
 159             }
 160
 161             wait_for_completion(&(guest->start_done));
 162
 163             return guest->vm_dev;
 164             break;
 165         }
 166         case V3_ADD_MEMORY: {
 167             struct v3_mem_region mem;
 168
 169             memset(&mem, 0, sizeof(struct v3_mem_region));
 170
 171             if (copy_from_user(&mem, argp, sizeof(struct v3_mem_region))) {
 172                 printk("copy from user error getting mem_region...\n");
 173                 return -EFAULT;
 174             }
 175
 176             printk("Adding %llu pages to Palacios memory\n", mem.num_pages);
 177
 178             if (add_palacios_memory(mem.base_addr, mem.num_pages) == -1) {
 179                 printk("Error adding memory to Palacios\n");
 180                 return -EFAULT;
 181             }
 182
 183             break;
 184         }
 185
 186         default:
 187             printk("\tUnhandled\n");
 188             return -EINVAL;
 189     }
 190
 191     return 0;
 192 }
 193
 194
 195
 196 static struct file_operations v3_ctrl_fops = {
 197     .owner = THIS_MODULE,
 198     .unlocked_ioctl = v3_dev_ioctl,
 199     .compat_ioctl = v3_dev_ioctl,
 200 };
 201
 202
 203
 204 static int __init v3_init(void) {
 205     dev_t dev = MKDEV(0, 0); // We dynamicallly assign the major number
 206     int ret = 0;
 207
 208
 209     palacios_init_mm();
 210
 211
 212     // Initialize Palacios
 213
 214     palacios_vmm_init();
 215
 216
 217     // initialize extensions
 218     init_lnx_extensions();
 219
 220
 221     v3_class = class_create(THIS_MODULE, "vms");
 222     if (IS_ERR(v3_class)) {
 223         printk("Failed to register V3 VM device class\n");
 224         return PTR_ERR(v3_class);
 225     }
 226
 227     printk("intializing V3 Control device\n");
 228
 229     ret = alloc_chrdev_region(&dev, 0, MAX_VMS + 1, "v3vee");
 230
 231     if (ret < 0) {
 232         printk("Error registering device region for V3 devices\n");
 233         goto failure2;
 234     }
 235
 236     v3_major_num = MAJOR(dev);
 237
 238     dev = MKDEV(v3_major_num, MAX_VMS + 1);
 239
 240
 241     printk("Creating V3 Control device: Major %d, Minor %d\n", v3_major_num, MINOR(dev));
 242     cdev_init(&ctrl_dev, &v3_ctrl_fops);
 243     ctrl_dev.owner = THIS_MODULE;
 244     ctrl_dev.ops = &v3_ctrl_fops;
 245     cdev_add(&ctrl_dev, dev, 1);
 246
 247     device_create(v3_class, NULL, dev, NULL, "v3vee");
 248
 249     if (ret != 0) {
 250         printk("Error adding v3 control device\n");
 251         goto failure1;
 252     }
 253
 254
 255
 256
 257 #ifdef V3_CONFIG_KEYED_STREAMS
 258     palacios_init_keyed_streams();
 259 #endif
 260
 261 #ifdef V3_CONFIG_GRAPHICS_CONSOLE
 262     palacios_init_graphics_console();
 263 #endif
 264
 265 #ifdef V3_CONFIG_VNET
 266     palacios_vnet_init();
 267 #endif
 268
 269 #ifdef V3_CONFIG_HOST_DEVICE
 270     palacios_init_host_dev();
 271 #endif
 272
 273     return 0;
 274
 275  failure1:
 276     unregister_chrdev_region(MKDEV(v3_major_num, 0), MAX_VMS + 1);
 277  failure2:
 278     class_destroy(v3_class);
 279
 280     return ret;
 281 }
 282
 283
 284 static void __exit v3_exit(void) {
 285     extern u32 pg_allocs;
 286     extern u32 pg_frees;
 287     extern u32 mallocs;
 288     extern u32 frees;
 289
 290
 291     // should probably try to stop any guests
 292
 293
 294
 295     dev_t dev = MKDEV(v3_major_num, MAX_VMS + 1);
 296
 297     printk("Removing V3 Control device\n");
 298
 299
 300     palacios_vmm_exit();
 301
 302     printk("Palacios Mallocs = %d, Frees = %d\n", mallocs, frees);
 303     printk("Palacios Page Allocs = %d, Page Frees = %d\n", pg_allocs, pg_frees);
 304
 305     unregister_chrdev_region(MKDEV(v3_major_num, 0), MAX_VMS + 1);
 306
 307     cdev_del(&ctrl_dev);
 308
 309     device_destroy(v3_class, dev);
 310     class_destroy(v3_class);
 311
 312
 313     deinit_lnx_extensions();
 314
 315
 316
 317 #ifdef V3_CONFIG_VNET
 318     palacios_vnet_deinit();
 319 #endif
 320
 321     palacios_deinit_mm();
 322
 323     printk("Palacios Module Mallocs = %d, Frees = %d\n", mod_allocs, mod_frees);
 324 }
 325
 326
 327
 328 module_init(v3_init);
 329 module_exit(v3_exit);
 330
 331
 332
 333 void * trace_malloc(size_t size, gfp_t flags) {
 334     void * addr = NULL;
 335
 336     mod_allocs++;
 337     addr = kmalloc(size, flags);
 338
 339     return addr;
 340 }
 341
 342
 343 void trace_free(const void * objp) {
 344     mod_frees++;
 345     kfree(objp);
 346 }