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.
6 * The V3VEE Project is a joint project between Northwestern University
7 * and the University of New Mexico. You can find out more at
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.
14 * Author: Peter Dinda <pdinda@cs.northwestern.edu>
16 * This is free software. You are permitted to use,
17 * redistribute, and modify it as specified in the file "V3VEE_LICENSE".
20 #include <palacios/vmm.h>
21 #include <palacios/vmm_string.h>
22 #include <palacios/vm_guest_mem.h>
25 The guest bios is compiled with blank space for am MP table
26 at a default address. A cookie value is temporarily placed
27 there so we can verify it exists. If it does, we overwrite
28 the MP table based on the configuration we are given in the
31 Currently, we set up n identical processors (based on
32 number of cores in guest info), with apics 0..n-1, and
33 ioapic as n. The ISA interrupt lines map to pins 0..15
34 of the first ioapic. PCI bus lines map to pins 16..19
35 of the first ioapic. The system supports virtual wire
36 compability mode and symmetric mode. PIC mode is not supported.
38 The expectation is that the target will have
39 8 bytes (for ___HVMMP signature) followed by 896 bytes of space
40 for a total of 904 bytes of space.
41 We write the floating pointer at target (16 bytes),
42 immediately followed by the mp config header, followed by
47 #define BIOS_MP_TABLE_DEFAULT_LOCATION 0xfcc00 // guest physical (linear)
48 #define BIOS_MP_TABLE_COOKIE "___HVMMP"
49 #define BIOS_MP_TABLE_COOKIE_LEN 8
51 #define POINTER_SIGNATURE "_MP_"
52 #define HEADER_SIGNATURE "PCMP"
54 #define SPEC_REV ((uint8_t)0x4)
55 #define OEM_ID "V3VEE "
56 #define PROD_ID "PALACIOS 1.3 "
58 #define LAPIC_ADDR 0xfee00000
59 #define LAPIC_VERSION 0x11
63 #define ENTRY_IOAPIC 2
67 #define IOAPIC_ADDR 0xfec00000
68 #define IOAPIC_VERSION 0x11
70 // These are bochs defaults - should really come from cpuid of machne
71 #define PROC_FAMILY 0x6
72 #define PROC_STEPPING 0x0
73 #define PROC_MODEL 0x0
74 #define PROC_FEATURE_FLAGS 0x00000201
77 #define BUS_ISA "ISA "
78 #define BUS_PCI "PCI "
80 #define INT_TYPE_INT 0
81 #define INT_TYPE_NMI 1
82 #define INT_TYPE_SMI 2
83 #define INT_TYPE_EXT 3
85 #define INT_POLARITY_DEFAULT 0
86 #define INT_POLARITY_ACTIVE_HIGH 1
87 #define INT_POLARITY_RESERVED 2
88 #define INT_POLARITY_ACTIVE_LOW 3
90 #define INT_TRIGGER_DEFAULT 0
91 #define INT_TRIGGER_EDGE 1
92 #define INT_TRIGGER_RESERVED 2
93 #define INT_TRIGGER_LEVEL 3
98 // This points to the mp table header
99 struct mp_floating_pointer {
100 uint32_t signature; /* "_MP_" */
101 uint32_t pointer; /* gpa of MP table (0xfcc00) */
102 uint8_t length; /* length in 16 byte chunks (paragraphs) */
103 uint8_t spec_rev; /* 0x4 */
105 uint8_t mp_featurebyte[5]; /* zero out to indicate mp config table
106 first byte nonzero => default configurations (see spec)
107 second byte, bit 7 (top bit) = IMCR if set, virtual wire if zero */
108 } __attribute__((packed));
111 struct mp_table_header {
112 uint32_t signature; /* "PCMP" */
113 uint16_t base_table_length; /* bytes, starting from header */
114 uint8_t spec_rev; /* specification rvision (0x4 is the current rev) */
115 uint8_t checksum; /* sum of all bytes, including checksum, must be zero */
116 uint8_t oem_id[8]; /* OEM ID "V3VEE " */
117 uint8_t prod_id[12]; /* Product ID "PALACIOS 1.3" */
118 uint32_t oem_table_ptr; /* oem table, if used (zeroed) */
119 uint16_t oem_table_size; /* oem table length, if used */
120 uint16_t entry_count; /* numnber of entries in this table */
121 uint32_t lapic_addr; /* apic address on all processors */
122 uint16_t extended_table_length; /* zero by default */
123 uint8_t extended_table_checksum; /* zero by default */
124 uint8_t reserved; /* zero by default */
125 /* this is followed by entries of the various types indicated below */
126 } __attribute__((packed));
128 struct mp_table_processor {
129 uint8_t entry_type; // type 0
130 uint8_t lapic_id; // 0..
131 uint8_t lapic_version; //
136 uint8_t en : 1; /* 1 = processor enabled */
137 uint8_t bp : 1; /* 1 = bootstrap processor */
138 uint8_t reserved : 6;
139 } __attribute__((packed));
140 } __attribute__((packed)) cpu_flags;
145 uint8_t stepping : 4;
149 } __attribute__((packed));
150 } __attribute__((packed)) cpu_signature;
152 uint32_t cpu_feature_flags; /* result of CPUID */
153 uint32_t reserved[2];
154 } __attribute__((packed));
156 struct mp_table_bus {
157 uint8_t entry_type; /* type 1 */
158 uint8_t bus_id; /* 0.. */
159 uint8_t bus_type[6]; /* "PCI" "INTERN", etc */
160 } __attribute__((packed));
163 struct mp_table_ioapic {
164 uint8_t entry_type; /* type 2 */
165 uint8_t ioapic_id; /* 0.. */
166 uint8_t ioapic_version; /* bits 0..7 of the version register */
171 uint8_t en : 1; /* 1=ioapic enabled */
172 uint8_t reserved : 7;
173 } __attribute__((packed));
174 } __attribute__((packed)) ioapic_flags;
176 uint32_t ioapic_address; /* physical address (same for all procs) */
177 } __attribute__((packed));
180 struct mp_table_io_interrupt_assignment {
181 uint8_t entry_type; /* type 3 */
182 uint8_t interrupt_type; /* 0=int, 1=nmi, 2=smi, 3=ExtInt(8259) */
187 uint8_t po : 2; /* polarity (00 = default for bus, 01 = active high, 10 = reserved, 11 = active low */
188 uint8_t el : 2; /* trigger mode (00 = default for bus, 01 = edge, 10 = reserved, 11 = level) */
189 uint16_t reserved : 12;
190 } __attribute__((packed));
191 } __attribute__((packed)) flags;
193 uint8_t source_bus_id;
194 uint8_t source_bus_irq;
195 uint8_t dest_ioapic_id;
196 uint8_t dest_ioapic_intn;
197 } __attribute__((packed));
200 struct mp_table_local_interrupt_assignment {
201 uint8_t entry_type; /* type 4 */
202 uint8_t interrupt_type; /* 0 = int, 1 = nmi, 2 = smi, 3 = ExtInt(8259) */
207 uint8_t po : 2; /* polarity (00 = default for bus, 01 = active high, 10 = reserved, 11 = active low */
208 uint8_t el : 2; /* trigger mode (00 = default for bus, 01 = edge, 10 = reserved, 11 = level) */
209 uint16_t reserved : 12;
210 } __attribute__((packed));
211 } __attribute__((packed)) flags;
213 uint8_t source_bus_id;
214 uint8_t source_bus_irq;
215 uint8_t dest_ioapic_id;
216 uint8_t dest_ioapic_intn;
217 } __attribute__((packed));
222 #define NUM_PCI_SLOTS 8
225 static inline int check_for_cookie(void * target) {
226 return (memcmp(target, BIOS_MP_TABLE_COOKIE, BIOS_MP_TABLE_COOKIE_LEN) == 0);
229 static inline int check_table(void * target) {
232 struct mp_table_header * header;
234 header = (struct mp_table_header *)target;
237 for (i = 0; i < header->base_table_length; i++) {
238 sum += ((uint8_t *)target)[i];
250 static inline int check_pointer(void * target) {
253 struct mp_floating_pointer * p;
255 p = (struct mp_floating_pointer *)target;
258 for (i = 0; i < p->length * 16; i++) {
259 sum += ((uint8_t *)target)[i];
272 static int write_pointer(void * target, uint32_t mptable_gpa) {
275 struct mp_floating_pointer * p = (struct mp_floating_pointer *)target;
277 memset((void *)p, 0, sizeof(struct mp_floating_pointer));
279 memcpy((void *)&(p->signature), POINTER_SIGNATURE, 4);
281 p->pointer = mptable_gpa;
282 p->length = 1; // length in 16 byte chunks
283 p->spec_rev = SPEC_REV;
285 // The remaining zeros indicate that an MP config table is present
286 // and that virtual wire mode is implemented (not PIC mode)
287 // Either virtual wire or PIC must be implemented in addition to
288 // symmetric I/O mode
290 // checksum calculation
294 for (i = 0; i < 16; i++) {
295 sum += ((uint8_t *)target)[i];
298 p->checksum = (255 - sum) + 1;
306 static int write_mptable(void * target, uint32_t numcores) {
311 struct mp_table_header * header = NULL;
312 struct mp_table_processor * proc = NULL;
313 struct mp_table_bus * bus = NULL;
314 struct mp_table_ioapic * ioapic = NULL;
315 struct mp_table_io_interrupt_assignment * interrupt = NULL;
316 uint8_t * cur = target;
318 header = (struct mp_table_header *)cur;
319 cur = cur + sizeof(struct mp_table_header);
321 memset((void *)header, 0, sizeof(struct mp_table_header));
324 memcpy(&(header->signature), HEADER_SIGNATURE, 4);
325 header->spec_rev = SPEC_REV;
326 memcpy(header->oem_id, OEM_ID, 8);
327 memcpy(header->prod_id, PROD_ID, 12);
330 // n processors, 1 ioapic, 1 pci bus, 1 isa bus, 16 IRQ, 4*NUM_SLOTS = 19 + 4*numslots+ n
331 header->entry_count = numcores + 19 + 4 * NUM_PCI_SLOTS;
333 // n processors, 1 ioapic, 1 isa bus, 16 IRQ INTs = 18+n
334 header->entry_count = numcores + 18;
337 header->lapic_addr = LAPIC_ADDR;
339 // now we arrange the processors;
341 for (core = 0; core < numcores; core++) {
342 proc = (struct mp_table_processor *)cur;
343 memset((void *)proc, 0, sizeof(struct mp_table_processor));
344 proc->entry_type = ENTRY_PROC;
345 proc->lapic_id = core;
346 proc->lapic_version = LAPIC_VERSION;
347 proc->cpu_flags.en = 1;
350 proc->cpu_flags.bp = 1;
352 proc->cpu_flags.bp = 0;
355 proc->cpu_signature.family = PROC_FAMILY;
356 proc->cpu_signature.model = PROC_MODEL;
357 proc->cpu_signature.stepping = PROC_STEPPING;
358 proc->cpu_feature_flags = PROC_FEATURE_FLAGS;
360 cur += sizeof(struct mp_table_processor);
364 // PCI bus is always zero
365 bus = (struct mp_table_bus *)cur;
366 cur += sizeof(struct mp_table_bus);
368 memset((void *)bus, 0, sizeof(struct mp_table_bus));
369 bus->entry_type = ENTRY_BUS;
371 memcpy(bus->bus_type, BUS_PCI, 6);
374 // next comes the ISA bus (bus one)
375 bus = (struct mp_table_bus *)cur;
376 cur += sizeof(struct mp_table_bus);
378 memset((void *)bus, 0, sizeof(struct mp_table_bus));
379 bus->entry_type = ENTRY_BUS;
381 memcpy(bus->bus_type, BUS_ISA, 6);
384 // next comes the IOAPIC
385 ioapic = (struct mp_table_ioapic *)cur;
386 cur += sizeof(struct mp_table_ioapic);
388 memset((void *)ioapic, 0, sizeof(struct mp_table_ioapic));
389 ioapic->entry_type = ENTRY_IOAPIC;
390 ioapic->ioapic_id = numcores;
391 ioapic->ioapic_version = IOAPIC_VERSION;
392 ioapic->ioapic_flags.en = 1;
393 ioapic->ioapic_address = IOAPIC_ADDR;
397 // LEGACY ISA IRQ mappings
398 // The MPTABLE IRQ mappings are kind of odd.
399 // We don't include a bus IRQ 2, and instead remap Bus IRQ 0 to dest irq 2
400 // The idea here is that the timer hooks to 2, while the PIC hooks
401 // to zero in ExtInt mode. This makes it possible to do virtual wire
402 // mode via the ioapic.
404 // Note that the timer connects to pin 2 of the IOAPIC. Sadly,
405 // the timer is unaware of this and just raises irq 0. The ioapic
406 // transforms this to a pin 2 interrupt. If we want the PIC
407 // to be able to channel interrupts via pin 0, we need a separate
409 for (irq = 0; irq < 16; irq++) {
410 uint8_t dst_irq = irq;
414 } else if (irq == 2) {
418 interrupt = (struct mp_table_io_interrupt_assignment *)cur;
419 memset((void *)interrupt, 0, sizeof(struct mp_table_io_interrupt_assignment));
421 interrupt->entry_type = ENTRY_IOINT;
422 interrupt->interrupt_type = INT_TYPE_INT;
423 interrupt->flags.po = INT_POLARITY_DEFAULT;
424 interrupt->flags.el = INT_TRIGGER_DEFAULT;
425 interrupt->source_bus_id = 1;
426 interrupt->source_bus_irq = irq;
427 interrupt->dest_ioapic_id = numcores;
428 interrupt->dest_ioapic_intn = dst_irq;
430 cur += sizeof(struct mp_table_io_interrupt_assignment);
435 // Interrupt redirection entries for PCI bus
437 // We need an entry for each slot+pci interrupt
438 // There can be 32 slots, each of which can use 4 interrupts
439 // Thus there are 128 entries
441 // In this simple setup, we map
442 // slot i, intr j (both zero based) to pci_irq[(i+j)%4]
445 static uint8_t pci_irq[4] = {16,17,18,19};
447 for (slot=0;slot<NUM_PCI_SLOTS;slot++) {
448 for (intr=0;intr<4;intr++) {
450 uint8_t dst_irq = pci_irq[(slot+intr)%4];
452 interrupt = (struct mp_table_io_interrupt_assignment *)cur;
453 memset((void *)interrupt, 0, sizeof(struct mp_table_io_interrupt_assignment));
455 interrupt->entry_type = ENTRY_IOINT;
456 interrupt->interrupt_type = INT_TYPE_INT;
457 interrupt->flags.po = INT_POLARITY_DEFAULT;
458 interrupt->flags.el = INT_TRIGGER_DEFAULT;
459 interrupt->source_bus_id = 0;
460 // Yes, this is how you encode the slot and pin of a PCI device
461 // As we all know, bits are expensive
462 // We can have as many as 32 slots, but to get that large,
463 // we would need to tweak the bios's landing zone for the mptable
464 interrupt->source_bus_irq = (slot<<2) | intr ;
465 interrupt->dest_ioapic_id = numcores;
466 interrupt->dest_ioapic_intn = dst_irq;
468 cur += sizeof(struct mp_table_io_interrupt_assignment);
470 //V3_Print("PCI0, slot %d, irq %d maps to irq %d\n",slot,intr,dst_irq);
476 // now we can set the length;
478 header->base_table_length = (cur - (uint8_t *)header);
480 V3_Print("MPtable size: %u\n",header->base_table_length);
482 // checksum calculation
483 header->checksum = 0;
485 for (i = 0; i < header->base_table_length; i++) {
486 sum += ((uint8_t *)target)[i];
488 header->checksum = (255 - sum) + 1;
493 static int mptable_init(struct v3_vm_info * vm, v3_cfg_tree_t * cfg) {
494 void * target = NULL;
496 if (v3_gpa_to_hva(&(vm->cores[0]), BIOS_MP_TABLE_DEFAULT_LOCATION, (addr_t *)&target) == -1) {
497 PrintError("Cannot inject mptable due to unmapped bios!\n");
501 if (!check_for_cookie(target)) {
502 PrintError("Cookie mismatch in writing mptable, aborting (probably wrong guest BIOS).\n");
506 if (vm->num_cores > 32) {
507 PrintError("No support for >32 cores in writing MP table, aborting.\n");
511 V3_Print("Constructing mptable for %u cores at %p\n", vm->num_cores, target);
513 if (write_pointer(target, BIOS_MP_TABLE_DEFAULT_LOCATION + sizeof(struct mp_floating_pointer)) == -1) {
514 PrintError("Unable to write mptable floating pointer, aborting.\n");
518 if (!check_pointer(target)) {
519 PrintError("Failed to inject mptable floating pointer correctly --- checksum fails\n");
523 if (write_mptable(target + sizeof(struct mp_floating_pointer), vm->num_cores) == -1) {
524 PrintError("Cannot inject mptable configuration header and entries\n");
528 if (!check_table(target + sizeof(struct mp_floating_pointer))) {
529 PrintError("Failed to inject mptable configuration header and entries correctly --- checksum fails\n");
539 device_register("MPTABLE", mptable_init)