palacios/src/palacios/vmm_mptable.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) 2010, Peter Dinda <pdinda@cs.northwestern.edu>
  11  * Copyright (c) 2008, The V3VEE Project <http://www.v3vee.org>
  12  * All rights reserved.
  13  *
  14  * Author: Peter Dinda <pdinda@cs.northwestern.edu>
  15  *
  16  * This is free software.  You are permitted to use,
  17  * redistribute, and modify it as specified in the file "V3VEE_LICENSE".
  18  */
  19
  20 #include <palacios/vmm.h>
  21 #include <palacios/vmm_mptable.h>
  22 #include <palacios/vmm_string.h>
  23 #include <palacios/vm_guest_mem.h>
  24
  25 /*
  26   The guest bios is compiled with blank space for am MP table
  27   at a default address.  A cookie value is temporarily placed
  28   there so we can verify it exists.  If it does, we overwrite
  29   the MP table based on the configuration we are given in the
  30   guest info.
  31
  32   Currently, we set up n identical processors (based on
  33   number of cores in guest info), with apics 0..n-1, and
  34   ioapic as n.
  35
  36   The expectation is that the target will have
  37   8 bytes (for ___HVMMP signature) followed by 896 bytes of space
  38   for a total of 904 bytes of space.
  39   We write the floating pointer at target (16 bytes),
  40   immediately followed  by the mp config header, followed by
  41   the entries.
  42
  43 */
  44
  45 #define BIOS_MP_TABLE_DEFAULT_LOCATION 0xfcc00   // guest physical (linear)
  46 #define BIOS_MP_TABLE_COOKIE         "___HVMMP"
  47 #define BIOS_MP_TABLE_COOKIE_LEN     8
  48
  49 #define POINTER_SIGNATURE "_MP_"
  50 #define HEADER_SIGNATURE "PCMP"
  51
  52 #define SPEC_REV ((uchar_t)0x4)
  53 #define OEM_ID   "V3VEE   "
  54 #define PROD_ID  "PALACIOS 1.3 "
  55
  56 #define LAPIC_ADDR 0xfee00000
  57 #define LAPIC_VERSION  0x11
  58
  59 #define ENTRY_PROC 0
  60 #define ENTRY_BUS 1
  61 #define ENTRY_IOAPIC 2
  62 #define ENTRY_IOINT 3
  63 #define ENTRY_LOINT 4
  64
  65 #define IOAPIC_ADDR 0xfec00000
  66 #define IOAPIC_VERSION 0x11
  67
  68 // These are bochs defaults - should really come from cpuid of machne
  69 #define PROC_FAMILY 0x6
  70 #define PROC_STEPPING 0x0
  71 #define PROC_MODEL 0x0
  72 #define PROC_FEATURE_FLAGS 0x00000201
  73
  74
  75 #define BUS_ISA "ISA   "
  76
  77 #define INT_TYPE_INT 0
  78 #define INT_TYPE_NMI 1
  79 #define INT_TYPE_SMI 2
  80 #define INT_TYPE_EXT 3
  81
  82 #define INT_POLARITY_DEFAULT     0
  83 #define INT_POLARITY_ACTIVE_HIGH 1
  84 #define INT_POLARITY_RESERVED    2
  85 #define INT_POLARITY_ACTIVE_LOW  3
  86
  87 #define INT_TRIGGER_DEFAULT      0
  88 #define INT_TRIGGER_EDGE         1
  89 #define INT_TRIGGER_RESERVED     2
  90 #define INT_TRIGGER_LEVEL        3
  91
  92
  93
  94
  95 // This points to the mp table header
  96 struct mp_floating_pointer {
  97     uint32_t signature;          // "_MP_"
  98     uint32_t pointer;            // gpa of MP table (0xfcc00)
  99     uint8_t  length;             // length in 16 byte chunks (paragraphs)
 100     uint8_t  spec_rev;           // 0x4
 101     uint8_t  checksum;
 102     uint8_t  mp_featurebyte[5];  // zero out to indicate mp config table
 103     // first byte nonzero => default configurations (see spec)
 104     // second byte, bit 7 (top bit) = IMCR if set, virtual wire if zero
 105 } __attribute__((packed));
 106
 107
 108 struct mp_table_header {
 109     uint32_t signature;          // "PCMP"
 110     uint16_t base_table_length;  // bytes, starting from header
 111     uint8_t  spec_rev;           // specification rvision (0x4 is the current rev)
 112     uint8_t  checksum;           // sum of all bytes, including checksum, must be zero
 113     uint8_t  oem_id[8];          // OEM ID "V3VEE   "
 114     uint8_t  prod_id[12];        // Product ID "PALACIOS 1.3"
 115     uint32_t oem_table_ptr;      // oem table, if used (zeroed)
 116     uint16_t oem_table_size;     // oem table length, if used
 117     uint16_t entry_count;        // numnber of entries in this table
 118     uint32_t lapic_addr;         // apic address on all processors
 119     uint16_t extended_table_length; // zero by default
 120     uint8_t  extended_table_checksum; // zero by default
 121     uint8_t  reserved;           // zero by default
 122     // this is followed by entries of the various types indicated below
 123 } __attribute__((packed));
 124
 125 struct mp_table_processor {
 126     uint8_t entry_type;          // type 0
 127     uint8_t lapic_id;            // 0..
 128     uint8_t lapic_version;       //
 129     union {
 130         uint8_t data;
 131         struct {
 132             uint8_t en:1;        // 1=processor enabled
 133             uint8_t bp:1;        // 1=bootstrap processor
 134             uint8_t reserved:6;
 135         } fields;
 136     } cpu_flags;
 137     union {
 138         uint32_t data;
 139         struct {
 140             uint8_t stepping:4;
 141             uint8_t model:4;
 142             uint8_t family:4;
 143             uint32_t rest:20;
 144         } fields;
 145     } cpu_signature;
 146     uint32_t cpu_feature_flags;      // result of CPUID
 147     uint32_t reserved[2];
 148 } __attribute__((packed));
 149
 150 struct mp_table_bus {
 151     uint8_t entry_type;          // type 1
 152     uint8_t bus_id;              // 0..
 153     uint8_t bus_type[6];         // "PCI" "INTERN", etc
 154 } __attribute__((packed));
 155
 156
 157 struct mp_table_ioapic {
 158     uint8_t entry_type;          // type 2
 159     uint8_t ioapic_id;           // 0..
 160     uint8_t ioapic_version;      // bits 0..7 of the version register
 161     union {
 162         uint8_t data;
 163         struct {
 164             uint8_t en:1;        // 1=ioapic enabled
 165             uint8_t reserved:7;
 166         } fields;
 167     } ioapic_flags;
 168     uint32_t ioapic_address;     // physical address (same for all procs)
 169 } __attribute__((packed));
 170
 171
 172 struct mp_table_io_interrupt_assignment {
 173     uint8_t entry_type;          // type 3
 174     uint8_t interrupt_type;      // 0=int, 1=nmi, 2=smi, 3=ExtInt(8259)
 175     union {
 176         uint16_t data;
 177         struct {
 178             uint8_t po:2;        // polarity (00=default for bus, 01=active high, 10=reserved, 11=active low
 179             uint8_t el:2;        // trigger mode (00=default for bus, 01=edge, 10=reserved, 11=level)
 180             uint16_t reserved:12;
 181         } fields;
 182     } io_interrupt_flags;
 183     uint8_t source_bus_id;
 184     uint8_t source_bus_irq;
 185     uint8_t dest_ioapic_id;
 186     uint8_t dest_ioapic_intn;
 187 } __attribute__((packed));
 188
 189
 190 struct mp_table_local_interrupt_assignment {
 191     uint8_t entry_type;          // type 4
 192     uint8_t interrupt_type;      // 0=int, 1=nmi, 2=smi, 3=ExtInt(8259)
 193     union {
 194         uint16_t data;
 195         struct {
 196             uint8_t po:2;        // polarity (00=default for bus, 01=active high, 10=reserved, 11=active low
 197             uint8_t el:2;        // trigger mode (00=default for bus, 01=edge, 10=reserved, 11=level)
 198             uint16_t reserved:12;
 199         } fields;
 200     } io_interrupt_flags;
 201     uint8_t source_bus_id;
 202     uint8_t source_bus_irq;
 203     uint8_t dest_ioapic_id;
 204     uint8_t dest_ioapic_intn;
 205 } __attribute__((packed));
 206
 207
 208
 209
 210
 211 static int check_for_cookie(void *target)
 212 {
 213     return 0==memcmp(target,BIOS_MP_TABLE_COOKIE,BIOS_MP_TABLE_COOKIE_LEN);
 214 }
 215
 216 static int check_table(void *target)
 217 {
 218     uint32_t i;
 219     uint8_t sum;
 220     struct mp_table_header *header;
 221
 222
 223     header=(struct mp_table_header *)target;
 224     sum=0;
 225     for (i=0;i<header->base_table_length;i++) {
 226         sum+=((uint8_t *)target)[i];
 227     }
 228     if (sum==0) {
 229         return 1;
 230     } else {
 231         // failed checksum
 232         return 0;
 233     }
 234 }
 235
 236
 237 static int check_pointer(void *target)
 238 {
 239     uint32_t i;
 240     uint8_t sum;
 241     struct mp_floating_pointer *p;
 242
 243     p=(struct mp_floating_pointer *)target;
 244     sum=0;
 245     for (i=0;i<p->length*16;i++) {
 246         sum+=((uint8_t *)target)[i];
 247     }
 248     if (sum==0) {
 249         // passed
 250         return 1;
 251     } else {
 252         // failed
 253         return 0;
 254     }
 255 }
 256
 257
 258 static int write_pointer(void *target, uint32_t mptable_gpa)
 259 {
 260     uint32_t i;
 261     uint8_t sum;
 262     struct mp_floating_pointer *p=(struct mp_floating_pointer*)target;
 263
 264     memset((void*)p,0,sizeof(*p));
 265
 266     memcpy((void*)&(p->signature),POINTER_SIGNATURE,4);
 267
 268     p->pointer=mptable_gpa;
 269     p->length=1;             // length in 16 byte chunks
 270     p->spec_rev=SPEC_REV;
 271
 272     // checksum calculation
 273     p->checksum=0;
 274     sum=0;
 275     for (i=0;i<16;i++) {
 276         sum+=((uint8_t *)target)[i];
 277     }
 278     p->checksum=(255-sum)+1;
 279
 280     return 0;
 281 }
 282
 283
 284
 285
 286 static int write_mptable(void *target, uint32_t numcores)
 287 {
 288     uint32_t i;
 289     uint8_t sum;
 290     uint8_t core;
 291     uint8_t irq;
 292     uint8_t *cur;
 293     struct mp_table_header *header;
 294     struct mp_table_processor *proc;
 295     struct mp_table_bus *bus;
 296     struct mp_table_ioapic *ioapic;
 297     struct mp_table_io_interrupt_assignment *interrupt;
 298
 299
 300     cur=(uint8_t *)target;
 301     header=(struct mp_table_header *)cur;
 302     cur=cur+sizeof(*header);
 303
 304     memset((void*)header,0,sizeof(*header));
 305
 306
 307     memcpy(&(header->signature),HEADER_SIGNATURE,4);
 308     header->spec_rev=SPEC_REV;
 309     memcpy(header->oem_id,OEM_ID,8);
 310     memcpy(header->prod_id,PROD_ID,12);
 311
 312     // n processors, 1 ioapic, 1 isa bus, 16 IRQs = 18+n
 313     header->entry_count=numcores+18;
 314     header->lapic_addr=LAPIC_ADDR;
 315
 316     // now we arrange the processors;
 317
 318     for (core=0;core<numcores;core++, cur+=sizeof(*proc)) {
 319         proc=(struct mp_table_processor *)cur;
 320         memset((void*)proc,0,sizeof(*proc));
 321         proc->entry_type=ENTRY_PROC;
 322         proc->lapic_id=core;
 323         proc->lapic_version=LAPIC_VERSION;
 324         proc->cpu_flags.fields.en=1;
 325         proc->cpu_flags.fields.bp = (core==0);
 326         proc->cpu_signature.fields.family=PROC_FAMILY;
 327         proc->cpu_signature.fields.model=PROC_MODEL;
 328         proc->cpu_signature.fields.stepping=PROC_STEPPING;
 329         proc->cpu_feature_flags=PROC_FEATURE_FLAGS;
 330     }
 331
 332     // next comes the ISA bas
 333     bus=(struct mp_table_bus *)cur;
 334     cur+=sizeof(*bus);
 335
 336     memset((void*)bus,0,sizeof(*bus));
 337     bus->entry_type=ENTRY_BUS;
 338     bus->bus_id=0;
 339     memcpy(bus->bus_type,BUS_ISA,6);
 340
 341     // next comes the IOAPIC
 342     ioapic=(struct mp_table_ioapic *)cur;
 343     cur+=sizeof(*ioapic);
 344
 345     memset((void*)ioapic,0,sizeof(*ioapic));
 346     ioapic->entry_type=ENTRY_IOAPIC;
 347     ioapic->ioapic_id=numcores;
 348     ioapic->ioapic_version=IOAPIC_VERSION;
 349     ioapic->ioapic_flags.fields.en=1;
 350     ioapic->ioapic_address=IOAPIC_ADDR;
 351
 352     for (irq=0;irq<16;irq++, cur+=sizeof(*interrupt)) {
 353         interrupt=(struct mp_table_io_interrupt_assignment *)cur;
 354         memset((void*)interrupt,0,sizeof(*interrupt));
 355         interrupt->entry_type=ENTRY_IOINT;
 356         interrupt->interrupt_type=INT_TYPE_INT;
 357         interrupt->io_interrupt_flags.fields.po=INT_POLARITY_DEFAULT;
 358         interrupt->io_interrupt_flags.fields.el=INT_TRIGGER_DEFAULT;
 359         interrupt->source_bus_id=0;
 360         interrupt->source_bus_irq=irq;
 361         interrupt->dest_ioapic_id=numcores;
 362         interrupt->dest_ioapic_intn=irq;
 363     }
 364
 365     // now we can set the length;
 366
 367     header->base_table_length = (cur-(uint8_t*)header);
 368
 369     // checksum calculation
 370     header->checksum=0;
 371     sum=0;
 372     for (i=0;i<header->base_table_length;i++) {
 373         sum+=((uint8_t *)target)[i];
 374     }
 375     header->checksum=(255-sum)+1;
 376
 377
 378
 379     return 0;
 380 }
 381
 382
 383 int v3_inject_mptable(struct v3_vm_info *vm)
 384 {
 385     void *target;
 386
 387     if (v3_gpa_to_hva(&(vm->cores[0]),BIOS_MP_TABLE_DEFAULT_LOCATION,(addr_t*)&target)==-1) {
 388         PrintError("Cannot inject mptable due to unmapped bios!\n");
 389         return -1;
 390     }
 391
 392     if (!check_for_cookie(target)) {
 393         PrintError("Cookie mismatch in writing mptable, aborting (probably wrong guest BIOS).\n");
 394         return -1;
 395     }
 396
 397     if (vm->num_cores>32) {
 398         PrintError("No support for >32 cores in writing MP table, aborting.\n");
 399         return -1;
 400     }
 401
 402     V3_Print("Constructing mptable for %u cores at %p\n",vm->num_cores,target);
 403
 404     if (-1==write_pointer(target,BIOS_MP_TABLE_DEFAULT_LOCATION+sizeof(struct mp_floating_pointer))) {
 405         PrintError("Unable to write mptable floating pointer, aborting.\n");
 406         return -1;
 407     }
 408
 409     if (!check_pointer(target)) {
 410         PrintError("Failed to inject mptable floating pointer correctly --- checksum fails\n");
 411         return -1;
 412     }
 413
 414     if (-1==write_mptable(target+sizeof(struct mp_floating_pointer),vm->num_cores)) {
 415         PrintError("Cannot inject mptable configuration header and entries\n");
 416         return -1;
 417     }
 418
 419     if (!check_table(target+sizeof(struct mp_floating_pointer))) {
 420         PrintError("Failed to inject mptable configuration header and entries correctly --- checksum fails\n");
 421         return -1;
 422     }
 423
 424
 425     return 0;
 426
 427 }