palacios/src/palacios/vmm_cpu_mapper.c

   1 /*
   2  * This file is part of the Palacios Virtual Machine Monitor developed
   3  * by the V3VEE Project with funding from the United States National
   4  * Science Foundation and the Department of Energy.
   5  *
   6  * The V3VEE Project is a joint project between Northwestern University
   7  * and the University of New Mexico.  You can find out more at
   8  * http://www.v3vee.org
   9  *
  10  * Copyright (c) 2013, Oscar Mondragon <omondrag@cs.unm.edu>
  11  * Copyright (c) 2013, Patrick G. Bridges <bridges@cs.unm.edu>
  12  * Copyright (c) 2013, The V3VEE Project <http://www.v3vee.org>
  13  * All rights reserved.
  14  *
  15  * Author: Oscar Mondragon <omondrag@cs.unm.edu>
  16  *         Patrick G. Bridges <bridges@cs.unm.edu>
  17  *
  18  * This is free software.  You are permitted to use,
  19  * redistribute, and modify it as specified in the file "V3VEE_LICENSE".
  20  */
  21
  22 #include <palacios/vmm.h>
  23 #include <palacios/vm_guest.h>
  24 #include <palacios/vmm_cpu_mapper.h>
  25 #include <palacios/vmm_hashtable.h>
  26
  27 #ifndef V3_CONFIG_DEBUG_CPU_MAPPER
  28 #undef PrintDebug
  29 #define PrintDebug(fmt, args...)
  30 #endif
  31
  32 static char default_strategy[] = "default";
  33 static struct hashtable * master_cpu_mapper_table = NULL;
  34 static int create_default_cpu_mapper();
  35 static int destroy_default_cpu_mapper();
  36
  37 static struct vm_cpu_mapper_impl *cpu_mapper = NULL;
  38
  39 static uint_t cpu_mapper_hash_fn(addr_t key) {
  40     char * name = (char *)key;
  41     return v3_hash_buffer((uint8_t *)name, strlen(name));
  42 }
  43
  44 static int cpu_mapper_eq_fn(addr_t key1, addr_t key2) {
  45     char * name1 = (char *)key1;
  46     char * name2 = (char *)key2;
  47
  48     return (strcmp(name1, name2) == 0);
  49 }
  50
  51 int V3_init_cpu_mapper() {
  52
  53      PrintDebug(VM_NONE, VCORE_NONE,"Initializing cpu_mapper");
  54
  55     master_cpu_mapper_table = v3_create_htable(0, cpu_mapper_hash_fn, cpu_mapper_eq_fn);
  56     return create_default_cpu_mapper();
  57 }
  58
  59
  60 int V3_deinit_cpu_mapper() {
  61
  62     destroy_default_cpu_mapper();
  63     // we must leave the keys and values unfreed
  64     // since we have no idea whether they are heap or otherwise
  65     // the user must have done appropriate unregisters before this
  66     v3_free_htable(master_cpu_mapper_table, 0, 0);
  67     return 0;
  68 }
  69
  70 int v3_register_cpu_mapper(struct vm_cpu_mapper_impl *s) {
  71
  72     PrintDebug(VM_NONE, VCORE_NONE,"Registering cpu_mapper (%s)\n", s->name);
  73
  74     if (v3_htable_search(master_cpu_mapper_table, (addr_t)(s->name))) {
  75         PrintError(VM_NONE, VCORE_NONE, "Multiple instances of cpu_mapper (%s)\n", s->name);
  76         return -1;
  77     }
  78
  79     if (v3_htable_insert(master_cpu_mapper_table,
  80                          (addr_t)(s->name),
  81                          (addr_t)(s)) == 0) {
  82         PrintError(VM_NONE, VCORE_NONE, "Could not register cpu_mapper (%s)\n", s->name);
  83         return -1;
  84     }
  85
  86     return 0;
  87 }
  88
  89 struct vm_cpu_mapper_impl *v3_unregister_cpu_mapper(char *name) {
  90
  91     PrintDebug(VM_NONE, VCORE_NONE,"Unregistering cpu_mapper (%s)\n",name);
  92
  93     struct vm_cpu_mapper_impl *f = (struct vm_cpu_mapper_impl *) v3_htable_remove(master_cpu_mapper_table,(addr_t)(name),0);
  94
  95     if (!f) {
  96         PrintError(VM_NONE,VCORE_NONE,"Could not find cpu_mapper (%s)\n",name);
  97         return NULL;
  98     } else {
  99         return f;
 100     }
 101 }
 102
 103
 104 struct vm_cpu_mapper_impl *v3_cpu_mapper_lookup(char *name)
 105 {
 106     return (struct vm_cpu_mapper_impl *)v3_htable_search(master_cpu_mapper_table, (addr_t)(name));
 107 }
 108
 109 int V3_enable_cpu_mapper() {
 110     char *mapper_name;
 111
 112     cpu_mapper = NULL;
 113     mapper_name = v3_lookup_option("cpu_mapper");
 114
 115     if (mapper_name) {
 116         cpu_mapper = v3_cpu_mapper_lookup(mapper_name);
 117     }
 118
 119     if (!cpu_mapper) {
 120         cpu_mapper = v3_cpu_mapper_lookup(default_strategy);
 121     }
 122
 123     if (!cpu_mapper) {
 124         PrintError(VM_NONE, VCORE_NONE,"Specified Palacios cpu_mapper \"%s\" not found.\n", default_strategy);
 125         return -1;
 126     }
 127
 128     PrintDebug(VM_NONE, VCORE_NONE,"cpu_mapper %s found",cpu_mapper->name);
 129
 130     if (cpu_mapper->init) {
 131         return cpu_mapper->init();
 132     } else {
 133         return 0;
 134     }
 135 }
 136
 137 int V3_disable_cpu_mapper()
 138 {
 139     if (cpu_mapper->deinit) {
 140         return cpu_mapper->deinit();
 141     } else {
 142         return 0;
 143     }
 144 }
 145
 146 int v3_cpu_mapper_register_vm(struct v3_vm_info *vm) {
 147     if (cpu_mapper->vm_init) {
 148         return cpu_mapper->vm_init(vm);
 149     } else {
 150         return 0;
 151     }
 152 }
 153
 154 int v3_cpu_mapper_admit_vm(struct v3_vm_info *vm, unsigned int cpu_mask) {
 155     if (cpu_mapper->admit) {
 156         return cpu_mapper->admit(vm,cpu_mask);
 157     } else {
 158         return 0;
 159     }
 160 }
 161
 162
 163 int v3_cpu_mapper_admit_core(struct v3_vm_info * vm, int vcore_id, int target_cpu) {
 164     if (cpu_mapper->admit_core) {
 165         return cpu_mapper->admit_core(vm,vcore_id,target_cpu);
 166     } else {
 167         return 0;
 168     }
 169 }
 170
 171 int default_mapper_vm_init(struct v3_vm_info *vm){
 172     return 0;
 173 }
 174
 175 int default_mapper_admit_core(struct v3_vm_info * vm, int vcore_id, int target_cpu){
 176     return 0;
 177 }
 178
 179
 180 int default_mapper_admit(struct v3_vm_info *vm, unsigned int cpu_mask){
 181
 182     uint32_t i;
 183     int vcore_id = 0;
 184     uint8_t * core_mask = (uint8_t *)&cpu_mask;
 185
 186     for (i = 0, vcore_id = vm->num_cores - 1; vcore_id >= 0; i++) {
 187
 188         int major = 0;
 189         int minor = 0;
 190         struct guest_info * core = &(vm->cores[vcore_id]);
 191         char * specified_cpu = v3_cfg_val(core->core_cfg_data, "target_cpu");
 192         uint32_t core_idx = 0;
 193
 194         if (specified_cpu != NULL) {
 195             core_idx = atoi(specified_cpu);
 196
 197             if (core_idx < 0) {
 198                 PrintError(vm, VCORE_NONE, "Target CPU out of bounds (%d) \n", core_idx);
 199             }
 200
 201             i--; // We reset the logical core idx. Not strictly necessary I guess...
 202         } else {
 203             core_idx = i;
 204         }
 205
 206         major = core_idx / 8;
 207         minor = core_idx % 8;
 208
 209         if ((core_mask[major] & (0x1 << minor)) == 0) {
 210             PrintError(vm, VCORE_NONE, "Logical CPU %d not available for virtual core %d; not started\n",
 211                        core_idx, vcore_id);
 212
 213             if (specified_cpu != NULL) {
 214                 PrintError(vm, VCORE_NONE, "CPU was specified explicitly (%d). HARD ERROR\n", core_idx);
 215                 v3_stop_vm(vm);
 216                 return -1;
 217             }
 218
 219             continue;
 220
 221         }
 222
 223     core->pcpu_id = core_idx;
 224     vcore_id--;
 225     }
 226
 227     if (vcore_id >= 0) { // dead code...
 228         v3_stop_vm(vm);
 229         return -1;
 230     }
 231
 232     return 0;
 233 }
 234
 235
 236 static struct vm_cpu_mapper_impl default_mapper_impl = {
 237     .name = "default",
 238     .init = NULL,
 239     .deinit = NULL,
 240     .vm_init = default_mapper_vm_init,
 241     .vm_deinit = NULL,
 242     .admit_core = default_mapper_admit_core,
 243     .admit = default_mapper_admit
 244
 245 };
 246
 247 static int create_default_cpu_mapper()
 248 {
 249         v3_register_cpu_mapper(&default_mapper_impl);
 250         return 0;
 251 }
 252
 253 static int destroy_default_cpu_mapper()
 254 {
 255         v3_unregister_cpu_mapper(default_mapper_impl.name);
 256         // note - is not deleted since it's a global...
 257         return 0;
 258 }