VMM: perform per-guest-pcore init at setup (XCC)
[akaros.git] / tests / vmm / vmrunkernel.c
1 #include <stdio.h> 
2 #include <pthread.h>
3 #include <sys/types.h>
4 #include <sys/stat.h>
5 #include <fcntl.h>
6 #include <parlib/arch/arch.h>
7 #include <parlib/ros_debug.h>
8 #include <unistd.h>
9 #include <errno.h>
10 #include <dirent.h>
11 #include <stdlib.h>
12 #include <string.h>
13 #include <ros/syscall.h>
14 #include <sys/mman.h>
15 #include <vmm/coreboot_tables.h>
16 #include <vmm/vmm.h>
17 #include <vmm/acpi/acpi.h>
18 #include <ros/arch/mmu.h>
19 #include <ros/vmm.h>
20 #include <parlib/uthread.h>
21 #include <vmm/virtio.h>
22 #include <vmm/virtio_mmio.h>
23 #include <vmm/virtio_ids.h>
24 #include <vmm/virtio_config.h>
25
26 int msrio(struct vmctl *vcpu, uint32_t opcode);
27
28 struct vmctl vmctl;
29 struct vmm_gpcore_init gpci;
30
31 /* Kind of sad what a total clusterf the pc world is. By 1999, you could just scan the hardware 
32  * and work it out. But 2005, that was no longer possible. How sad. 
33  * so we have to fake acpi to make it all work. !@#$!@#$#.
34  * This will be copied to memory at 0xe0000, so the kernel can find it.
35  */
36 /* assume they're all 256 bytes long just to make it easy. Just have pointers that point to aligned things. */
37
38 struct acpi_table_rsdp rsdp = {
39         .signature = "RSD PTR ",
40         .oem_id = "AKAROS",
41         .revision = 2,
42         .length = 36,
43 };
44
45 struct acpi_table_xsdt xsdt = {
46         .header = {
47                 .signature= "XSDT",
48                 // This is so stupid. Incredibly stupid.
49                 .revision = 0,
50                 .oem_id = "AKAROS",
51                 .oem_table_id = "ALPHABET",
52                 .oem_revision = 0,
53                 .asl_compiler_id = "RON ",
54                 .asl_compiler_revision = 0,
55         },
56 };
57 struct acpi_table_fadt fadt = {
58         .header = {
59                 .signature= "FADT",
60                 // This is so stupid. Incredibly stupid.
61                 .revision = 0,
62                 .oem_id = "AKAROS",
63                 .oem_table_id = "ALPHABET",
64                 .oem_revision = 0,
65                 .asl_compiler_id = "RON ",
66                 .asl_compiler_revision = 0,
67         },
68 };
69
70 /* This has to be dropped into memory, then the other crap just follows it.
71  */
72 struct acpi_table_madt madt = {
73         .header = {
74                 .signature = "APIC",
75                 .revision = 0,
76                 .oem_id = "AKAROS",
77                 .oem_table_id = "ALPHABET",
78                 .oem_revision = 0,
79                 .asl_compiler_id = "RON ",
80                 .asl_compiler_revision = 0,
81         },
82         
83         .address = 0xfee00000ULL,
84 };
85
86 struct acpi_madt_local_apic Apic0 = {.header = {.type = ACPI_MADT_TYPE_LOCAL_APIC, .length = sizeof(struct acpi_madt_local_apic)},
87                                      .processor_id = 0, .id = 0};
88 struct acpi_madt_io_apic Apic1 = {.header = {.type = ACPI_MADT_TYPE_IO_APIC, .length = sizeof(struct acpi_madt_io_apic)},
89                                   .id = 1, .address = 0xfec00000, .global_irq_base = 0};
90 struct acpi_madt_interrupt_override isor[] = {
91         /* I have no idea if it should be source irq 2, global 0, or global 2, source 0. Shit. */
92         {.header = {.type = ACPI_MADT_TYPE_INTERRUPT_OVERRIDE, .length = sizeof(struct acpi_madt_interrupt_override)},
93          .bus = 0, .source_irq = 2, .global_irq = 0, .inti_flags = 0},
94         {.header = {.type = ACPI_MADT_TYPE_INTERRUPT_OVERRIDE, .length = sizeof(struct acpi_madt_interrupt_override)},
95          .bus = 0, .source_irq = 1, .global_irq = 1, .inti_flags = 0},
96         //{.header = {.type = ACPI_MADT_TYPE_INTERRUPT_OVERRIDE, .length = sizeof(struct acpi_madt_interrupt_override)},
97          //.bus = 0, .source_irq = 2, .global_irq = 2, .inti_flags = 0},
98         {.header = {.type = ACPI_MADT_TYPE_INTERRUPT_OVERRIDE, .length = sizeof(struct acpi_madt_interrupt_override)},
99          .bus = 0, .source_irq = 3, .global_irq = 3, .inti_flags = 0},
100         {.header = {.type = ACPI_MADT_TYPE_INTERRUPT_OVERRIDE, .length = sizeof(struct acpi_madt_interrupt_override)},
101          .bus = 0, .source_irq = 4, .global_irq = 4, .inti_flags = 0},
102         {.header = {.type = ACPI_MADT_TYPE_INTERRUPT_OVERRIDE, .length = sizeof(struct acpi_madt_interrupt_override)},
103          .bus = 0, .source_irq = 5, .global_irq = 5, .inti_flags = 0},
104         {.header = {.type = ACPI_MADT_TYPE_INTERRUPT_OVERRIDE, .length = sizeof(struct acpi_madt_interrupt_override)},
105          .bus = 0, .source_irq = 6, .global_irq = 6, .inti_flags = 0},
106         {.header = {.type = ACPI_MADT_TYPE_INTERRUPT_OVERRIDE, .length = sizeof(struct acpi_madt_interrupt_override)},
107          .bus = 0, .source_irq = 7, .global_irq = 7, .inti_flags = 0},
108         {.header = {.type = ACPI_MADT_TYPE_INTERRUPT_OVERRIDE, .length = sizeof(struct acpi_madt_interrupt_override)},
109          .bus = 0, .source_irq = 8, .global_irq = 8, .inti_flags = 0},
110         {.header = {.type = ACPI_MADT_TYPE_INTERRUPT_OVERRIDE, .length = sizeof(struct acpi_madt_interrupt_override)},
111          .bus = 0, .source_irq = 9, .global_irq = 9, .inti_flags = 0},
112         {.header = {.type = ACPI_MADT_TYPE_INTERRUPT_OVERRIDE, .length = sizeof(struct acpi_madt_interrupt_override)},
113          .bus = 0, .source_irq = 10, .global_irq = 10, .inti_flags = 0},
114         {.header = {.type = ACPI_MADT_TYPE_INTERRUPT_OVERRIDE, .length = sizeof(struct acpi_madt_interrupt_override)},
115          .bus = 0, .source_irq = 11, .global_irq = 11, .inti_flags = 0},
116         {.header = {.type = ACPI_MADT_TYPE_INTERRUPT_OVERRIDE, .length = sizeof(struct acpi_madt_interrupt_override)},
117          .bus = 0, .source_irq = 12, .global_irq = 12, .inti_flags = 0},
118         {.header = {.type = ACPI_MADT_TYPE_INTERRUPT_OVERRIDE, .length = sizeof(struct acpi_madt_interrupt_override)},
119          .bus = 0, .source_irq = 13, .global_irq = 13, .inti_flags = 0},
120         {.header = {.type = ACPI_MADT_TYPE_INTERRUPT_OVERRIDE, .length = sizeof(struct acpi_madt_interrupt_override)},
121          .bus = 0, .source_irq = 14, .global_irq = 14, .inti_flags = 0},
122         {.header = {.type = ACPI_MADT_TYPE_INTERRUPT_OVERRIDE, .length = sizeof(struct acpi_madt_interrupt_override)},
123          .bus = 0, .source_irq = 15, .global_irq = 15, .inti_flags = 0},
124         // VMMCP routes irq 32 to gsi 17
125         {.header = {.type = ACPI_MADT_TYPE_INTERRUPT_OVERRIDE, .length = sizeof(struct acpi_madt_interrupt_override)},
126          .bus = 0, .source_irq = 32, .global_irq = 17, .inti_flags = 5},
127 };
128
129
130 /* this test will run the "kernel" in the negative address space. We hope. */
131 void *low1m;
132 uint8_t low4k[4096];
133 unsigned long long stack[1024];
134 volatile int shared = 0;
135 volatile int quit = 0;
136 int mcp = 1;
137 int virtioirq = 17;
138
139 /* total hack. If the vm runs away we want to get control again. */
140 unsigned int maxresume = (unsigned int) -1;
141
142 #define MiB 0x100000u
143 #define GiB (1u<<30)
144 #define GKERNBASE (16*MiB)
145 #define KERNSIZE (128*MiB+GKERNBASE)
146 uint8_t _kernel[KERNSIZE];
147
148 unsigned long long *p512, *p1, *p2m;
149
150 void **my_retvals;
151 int nr_threads = 4;
152 int debug = 0;
153 int resumeprompt = 0;
154 /* unlike Linux, this shared struct is for both host and guest. */
155 //      struct virtqueue *constoguest = 
156 //              vring_new_virtqueue(0, 512, 8192, 0, inpages, NULL, NULL, "test");
157 uint64_t virtio_mmio_base = 0x100000000ULL;
158
159 void vapic_status_dump(FILE *f, void *vapic);
160 static void set_posted_interrupt(int vector);
161
162 #if __GNUC__ < 4 || (__GNUC__ == 4 && __GNUC_MINOR__ < 1)
163 #error "Get a gcc newer than 4.4.0"
164 #else
165 #define BITOP_ADDR(x) "+m" (*(volatile long *) (x))
166 #endif
167
168 #define LOCK_PREFIX "lock "
169 #define ADDR                            BITOP_ADDR(addr)
170 static inline int test_and_set_bit(int nr, volatile unsigned long *addr);
171
172 void *timer_thread(void *arg)
173 {
174         int fd = open("#cons/vmctl", O_RDWR), ret;
175
176         while (1) {
177                 set_posted_interrupt(0xef);
178                 pwrite(fd, &vmctl, sizeof(vmctl), 1<<12);
179                 uthread_usleep(1);
180         }
181 }
182
183 void *consout(void *arg)
184 {
185         char *line, *consline, *outline;
186         static struct scatterlist out[] = { {NULL, sizeof(outline)}, };
187         static struct scatterlist in[] = { {NULL, sizeof(line)}, };
188         static struct scatterlist iov[32];
189         struct virtio_threadarg *a = arg;
190         static unsigned int inlen, outlen, conslen;
191         struct virtqueue *v = a->arg->virtio;
192         fprintf(stderr, "talk thread ..\n");
193         uint16_t head, gaveit = 0, gotitback = 0;
194         uint32_t vv;
195         int i;
196         int num;
197         if (debug) {
198                 fprintf(stderr, "----------------------- TT a %p\n", a);
199                 fprintf(stderr, "talk thread ttargs %x v %x\n", a, v);
200         }
201         
202         for(num = 0;;num++) {
203                 //int debug = 1;
204                 /* host: use any buffers we should have been sent. */
205                 head = wait_for_vq_desc(v, iov, &outlen, &inlen);
206                 if (debug)
207                         fprintf(stderr, "CCC: vq desc head %d, gaveit %d gotitback %d\n", head, gaveit, gotitback);
208                 for(i = 0; debug && i < outlen + inlen; i++)
209                         fprintf(stderr, "CCC: v[%d/%d] v %p len %d\n", i, outlen + inlen, iov[i].v, iov[i].length);
210                 /* host: if we got an output buffer, just output it. */
211                 for(i = 0; i < outlen; i++) {
212                         num++;
213                         int j;
214                         if (debug) {
215                                 fprintf(stderr, "CCC: IOV length is %d\n", iov[i].length);
216                         }
217                         for (j = 0; j < iov[i].length; j++)
218                                 printf("%c", ((char *)iov[i].v)[j]);
219                 }
220                 fflush(stdout);
221                 if (debug)
222                         fprintf(stderr, "CCC: outlen is %d; inlen is %d\n", outlen, inlen);
223                 /* host: fill in the writeable buffers. */
224                 /* why we're getting these I don't know. */
225                 for (i = outlen; i < outlen + inlen; i++) {
226                         if (debug) fprintf(stderr, "CCC: send back empty writeable");
227                         iov[i].length = 0;
228                 }
229                 if (debug) fprintf(stderr, "CCC: call add_used\n");
230                 /* host: now ack that we used them all. */
231                 add_used(v, head, outlen+inlen);
232                 if (debug) fprintf(stderr, "CCC: DONE call add_used\n");
233         }
234         fprintf(stderr, "All done\n");
235         return NULL;
236 }
237
238 // FIXME. 
239 volatile int consdata = 0;
240
241 void *consin(void *arg)
242 {
243         struct virtio_threadarg *a = arg;
244         char *line, *outline;
245         static char consline[128];
246         static struct scatterlist iov[32];
247         static struct scatterlist out[] = { {NULL, sizeof(outline)}, };
248         static struct scatterlist in[] = { {NULL, sizeof(line)}, };
249
250         static unsigned int inlen, outlen, conslen;
251         struct virtqueue *v = a->arg->virtio;
252         fprintf(stderr, "consin thread ..\n");
253         uint16_t head, gaveit = 0, gotitback = 0;
254         uint32_t vv;
255         int i;
256         int num;
257         //char c[1];
258         int timer_started = 0;
259         pthread_t timerthread_struct;
260
261         int fd = open("#cons/vmctl", O_RDWR), ret;
262         
263         if (debug) fprintf(stderr, "Spin on console being read, print num queues, halt\n");
264
265         for(num = 0;! quit;num++) {
266                 //int debug = 1;
267                 /* host: use any buffers we should have been sent. */
268                 head = wait_for_vq_desc(v, iov, &outlen, &inlen);
269                 if (debug)
270                         fprintf(stderr, "vq desc head %d, gaveit %d gotitback %d\n", head, gaveit, gotitback);
271                 for(i = 0; debug && i < outlen + inlen; i++)
272                         fprintf(stderr, "v[%d/%d] v %p len %d\n", i, outlen + inlen, iov[i].v, iov[i].length);
273                 if (debug)
274                         fprintf(stderr, "outlen is %d; inlen is %d\n", outlen, inlen);
275                 /* host: fill in the writeable buffers. */
276                 for (i = outlen; i < outlen + inlen; i++) {
277                         /* host: read a line. */
278                         memset(consline, 0, 128);
279                         if (read(0, consline, 1) < 0) {
280                                 exit(0);
281                         } 
282                         if (debug) fprintf(stderr, "CONSIN: GOT A LINE:%s:\n", consline);
283                         if (debug) fprintf(stderr, "CONSIN: OUTLEN:%d:\n", outlen);
284                         if (strlen(consline) < 3 && consline[0] == 'q' ) {
285                                 quit = 1;
286                                 break;
287                         }
288
289                         memmove(iov[i].v, consline, strlen(consline)+ 1);
290                         iov[i].length = strlen(consline) + 1;
291                 }
292                 if (debug) fprintf(stderr, "call add_used\n");
293                 /* host: now ack that we used them all. */
294                 add_used(v, head, outlen+inlen);
295                 consdata = 1;
296                 if (debug) fprintf(stderr, "DONE call add_used\n");
297
298                 // Send spurious for testing (Gan)
299                 set_posted_interrupt(0xE5);
300                 virtio_mmio_set_vring_irq();
301
302                 pwrite(fd, &vmctl, sizeof(vmctl), 1<<12);
303                 /*if (!timer_started && mcp) {
304                         // Start up timer thread
305                         if (pthread_create(&timerthread_struct, NULL, timer_thread, NULL)) {
306                                 fprintf(stderr, "pth_create failed for timer thread.");
307                                 perror("pth_create");
308                         } else {
309                                 timer_started = 1;
310                         }
311                 }*/
312         }
313         fprintf(stderr, "All done\n");
314         return NULL;
315 }
316
317 static struct vqdev vqdev= {
318 name: "console",
319 dev: VIRTIO_ID_CONSOLE,
320 device_features: 0, /* Can't do it: linux console device does not support it. VIRTIO_F_VERSION_1*/
321 numvqs: 2,
322 vqs: {
323                 {name: "consin", maxqnum: 64, f: consin, arg: (void *)0},
324                 {name: "consout", maxqnum: 64, f: consout, arg: (void *)0},
325         }
326 };
327
328 void lowmem() {
329         __asm__ __volatile__ (".section .lowmem, \"aw\"\n\tlow: \n\t.=0x1000\n\t.align 0x100000\n\t.previous\n");
330 }
331
332 static uint8_t acpi_tb_checksum(uint8_t *buffer, uint32_t length)
333 {
334         uint8_t sum = 0;
335         uint8_t *end = buffer + length;
336         fprintf(stderr, "tbchecksum %p for %d", buffer, length);
337         while (buffer < end) {
338                 if (end - buffer < 2)
339                         fprintf(stderr, "%02x\n", sum);
340                 sum = (uint8_t)(sum + *(buffer++));
341         }
342         fprintf(stderr, " is %02x\n", sum);
343         return (sum);
344 }
345
346 static void gencsum(uint8_t *target, void *data, int len)
347 {
348         uint8_t csum;
349         // blast target to zero so it does not get counted (it might be in the struct we checksum) 
350         // And, yes, it is, goodness.
351         fprintf(stderr, "gencsum %p target %p source %d bytes\n", target, data, len);
352         *target = 0;
353         csum  = acpi_tb_checksum((uint8_t *)data, len);
354         *target = ~csum + 1;
355         fprintf(stderr, "Cmoputed is %02x\n", *target);
356 }
357
358 static inline int test_and_set_bit(int nr, volatile unsigned long *addr)
359 {
360         int oldbit;
361
362         asm volatile(LOCK_PREFIX "bts %2,%1\n\t"
363                      "sbb %0,%0" : "=r" (oldbit), ADDR : "Ir" (nr) : "memory");
364
365         return oldbit;
366 }
367
368 static void pir_dump()
369 {
370         unsigned long *pir_ptr = (unsigned long *)gpci.pir_addr;
371         int i;
372         fprintf(stderr, "-------Begin PIR dump-------\n");
373         for (i = 0; i < 8; i++){
374                 fprintf(stderr, "Byte %d: 0x%016x\n", i, pir_ptr[i]);
375         }
376         fprintf(stderr, "-------End PIR dump-------\n");
377 }
378
379 static void set_posted_interrupt(int vector)
380 {
381         unsigned long *bit_vec;
382         int bit_offset;
383         int i, j;
384         unsigned long *pir = (unsigned long *)gpci.pir_addr;
385         // Move to the correct location to set our bit.
386         bit_vec = pir + vector/(sizeof(unsigned long)*8);
387         bit_offset = vector%(sizeof(unsigned long)*8);
388         if(debug) fprintf(stderr, "%s: Pre set PIR dump\n", __func__);
389         if(debug) pir_dump();
390         if (debug)
391                 vapic_status_dump(stderr, gpci.vapic_addr);
392         if(debug) fprintf(stderr, "%s: Setting pir bit offset %d at 0x%p\n", __func__,
393                         bit_offset, bit_vec);
394         test_and_set_bit(bit_offset, bit_vec);
395
396         // Set outstanding notification bit
397         /*bit_vec = pir + 4;
398         fprintf(stderr, "%s: Setting pir bit offset 0 at 0x%p", __func__,
399                         bit_vec);
400         test_and_set_bit(0, bit_vec);*/
401
402         if(debug) pir_dump();
403 }
404
405 int main(int argc, char **argv)
406 {
407         uint64_t *p64;
408         void *a = (void *)0xe0000;
409         struct acpi_table_rsdp *r;
410         struct acpi_table_fadt *f;
411         struct acpi_table_madt *m;
412         struct acpi_table_xsdt *x;
413         uint64_t virtiobase = 0x100000000ULL;
414         // lowmem is a bump allocated pointer to 2M at the "physbase" of memory 
415         void *lowmem = (void *) 0x1000000;
416         //struct vmctl vmctl;
417         int amt;
418         int vmmflags = 0; // Disabled probably forever. VMM_VMCALL_PRINTF;
419         uint64_t entry = 0x1200000, kerneladdress = 0x1200000;
420         int nr_gpcs = 1;
421         int fd = open("#cons/vmctl", O_RDWR), ret;
422         void * xp;
423         int kfd = -1;
424         static char cmd[512];
425         int i;
426         uint8_t csum;
427         void *coreboot_tables = (void *) 0x1165000;
428         void *a_page;
429
430
431         fprintf(stderr, "%p %p %p %p\n", PGSIZE, PGSHIFT, PML1_SHIFT,
432                         PML1_PTE_REACH);
433
434         // mmap is not working for us at present.
435         if ((uint64_t)_kernel > GKERNBASE) {
436                 fprintf(stderr, "kernel array @%p is above , GKERNBASE@%p sucks\n", _kernel, GKERNBASE);
437                 exit(1);
438         }
439         memset(_kernel, 0, sizeof(_kernel));
440         memset(lowmem, 0xff, 2*1048576);
441         memset(low4k, 0xff, 4096);
442         // avoid at all costs, requires too much instruction emulation.
443         //low4k[0x40e] = 0;
444         //low4k[0x40f] = 0xe0;
445
446         //Place mmap(Gan)
447         a_page = mmap((void *)0xfee00000, PGSIZE, PROT_READ | PROT_WRITE,
448                               MAP_POPULATE | MAP_ANONYMOUS, -1, 0);
449         fprintf(stderr, "a_page mmap pointer %p", a_page);
450
451         if (a_page == (void *) -1) {
452                 perror("Could not mmap APIC");
453                 exit(1);
454         }
455         if (((uint64_t)a_page & 0xfff) != 0) {
456                 perror("APIC page mapping is not page aligned");
457                 exit(1);
458         }
459
460         memset(a_page, 0, 4096);
461         //((uint32_t *)a_page)[0x30/4] = 0x01060015;
462         ((uint32_t *)a_page)[0x30/4] = 0xDEADBEEF;
463
464
465         if (fd < 0) {
466                 perror("#cons/sysctl");
467                 exit(1);
468         }
469         argc--,argv++;
470         // switches ...
471         // Sorry, I don't much like the gnu opt parsing code.
472         while (1) {
473                 if (*argv[0] != '-')
474                         break;
475                 switch(argv[0][1]) {
476                 case 'd':
477                         debug++;
478                         break;
479                 case 'v':
480                         vmmflags |= VMM_VMCALL_PRINTF;
481                         break;
482                 case 'm':
483                         argc--,argv++;
484                         maxresume = strtoull(argv[0], 0, 0);
485                         break;
486                 case 'i':
487                         argc--,argv++;
488                         virtioirq = strtoull(argv[0], 0, 0);
489                         break;
490                 default:
491                         fprintf(stderr, "BMAFR\n");
492                         break;
493                 }
494                 argc--,argv++;
495         }
496         if (argc < 1) {
497                 fprintf(stderr, "Usage: %s vmimage [-n (no vmcall printf)] [coreboot_tables [loadaddress [entrypoint]]]\n", argv[0]);
498                 exit(1);
499         }
500         if (argc > 1)
501                 coreboot_tables = (void *) strtoull(argv[1], 0, 0);
502         if (argc > 2)
503                 kerneladdress = strtoull(argv[2], 0, 0);
504         if (argc > 3)
505                 entry = strtoull(argv[3], 0, 0);
506         kfd = open(argv[0], O_RDONLY);
507         if (kfd < 0) {
508                 perror(argv[0]);
509                 exit(1);
510         }
511         // read in the kernel.
512         xp = (void *)kerneladdress;
513         for(;;) {
514                 amt = read(kfd, xp, 1048576);
515                 if (amt < 0) {
516                         perror("read");
517                         exit(1);
518                 }
519                 if (amt == 0) {
520                         break;
521                 }
522                 xp += amt;
523         }
524         fprintf(stderr, "Read in %d bytes\n", xp-kerneladdress);
525         close(kfd);
526
527         // The low 1m so we can fill in bullshit like ACPI. */
528         // And, sorry, due to the STUPID format of the RSDP for now we need the low 1M.
529         low1m = mmap((int*)4096, MiB-4096, PROT_READ | PROT_WRITE,
530                          MAP_ANONYMOUS, -1, 0);
531         if (low1m != (void *)4096) {
532                 perror("Unable to mmap low 1m");
533                 exit(1);
534         }
535         memset(low1m, 0xff, MiB-4096);
536         r = a;
537         fprintf(stderr, "install rsdp to %p\n", r);
538         *r = rsdp;
539         a += sizeof(*r);
540         memmove(&r->xsdt_physical_address, &a, sizeof(a));
541         gencsum(&r->checksum, r, ACPI_RSDP_CHECKSUM_LENGTH);
542         if ((csum = acpi_tb_checksum((uint8_t *) r, ACPI_RSDP_CHECKSUM_LENGTH)) != 0) {
543                 fprintf(stderr, "RSDP has bad checksum; summed to %x\n", csum);
544                 exit(1);
545         }
546
547         /* Check extended checksum if table version >= 2 */
548         gencsum(&r->extended_checksum, r, ACPI_RSDP_XCHECKSUM_LENGTH);
549         if ((rsdp.revision >= 2) &&
550             (acpi_tb_checksum((uint8_t *) r, ACPI_RSDP_XCHECKSUM_LENGTH) != 0)) {
551                 fprintf(stderr, "RSDP has bad checksum v2\n");
552                 exit(1);
553         }
554
555         /* just leave a bunch of space for the xsdt. */
556         /* we need to zero the area since it has pointers. */
557         x = a;
558         a += sizeof(*x) + 8*sizeof(void *);
559         memset(x, 0, a - (void *)x);
560         fprintf(stderr, "install xsdt to %p\n", x);
561         *x = xsdt;
562         x->table_offset_entry[0] = 0;
563         x->table_offset_entry[1] = 0;
564         x->header.length = a - (void *)x;
565
566         f = a;
567         fprintf(stderr, "install fadt to %p\n", f);
568         *f = fadt;
569         x->table_offset_entry[2] = (uint64_t) f;
570         a += sizeof(*f);
571         f->header.length = a - (void *)f;
572         gencsum(&f->header.checksum, f, f->header.length);
573         if (acpi_tb_checksum((uint8_t *)f, f->header.length) != 0) {
574                 fprintf(stderr, "ffadt has bad checksum v2\n");
575                 exit(1);
576         }
577
578         m = a;
579         *m = madt;
580         x->table_offset_entry[3] = (uint64_t) m;
581         a += sizeof(*m);
582         fprintf(stderr, "install madt to %p\n", m);
583         memmove(a, &Apic0, sizeof(Apic0));
584         a += sizeof(Apic0);
585         memmove(a, &Apic1, sizeof(Apic1));
586         a += sizeof(Apic1);
587         memmove(a, &isor, sizeof(isor));
588         a += sizeof(isor);
589         m->header.length = a - (void *)m;
590         gencsum(&m->header.checksum, m, m->header.length);
591         if (acpi_tb_checksum((uint8_t *) m, m->header.length) != 0) {
592                 fprintf(stderr, "madt has bad checksum v2\n");
593                 exit(1);
594         }
595         fprintf(stderr, "allchecksums ok\n");
596
597         gencsum(&x->header.checksum, x, x->header.length);
598         if ((csum = acpi_tb_checksum((uint8_t *) x, x->header.length)) != 0) {
599                 fprintf(stderr, "XSDT has bad checksum; summed to %x\n", csum);
600                 exit(1);
601         }
602
603         hexdump(stdout, r, a-(void *)r);
604
605         a = (void *)(((unsigned long)a + 0xfff) & ~0xfff);
606         gpci.pir_addr = a;
607         memset(a, 0, 4096);
608         a += 4096;
609         gpci.vapic_addr = a;
610         //vmctl.vapic = (uint64_t) a_page;      
611         memset(a, 0, 4096);
612         ((uint32_t *)a)[0x30/4] = 0x01060014;
613         p64 = a;
614         // set up apic values? do we need to?
615         // qemu does this.
616         //((uint8_t *)a)[4] = 1;
617         a += 4096;
618         gpci.apic_addr = (void*)0xfee00000;
619
620         if (ros_syscall(SYS_setup_vmm, nr_gpcs, &gpci, vmmflags, 0, 0, 0) !=
621             nr_gpcs) {
622                 perror("Guest pcore setup failed");
623                 exit(1);
624         }
625
626         fprintf(stderr, "Run with %d cores and vmmflags 0x%x\n", nr_gpcs, vmmflags);
627         mcp = 1;
628         if (mcp) {
629                 my_retvals = malloc(sizeof(void*) * nr_threads);
630                 if (!my_retvals)
631                         perror("Init threads/malloc");
632
633                 pthread_can_vcore_request(FALSE);       /* 2LS won't manage vcores */
634                 pthread_need_tls(FALSE);
635                 pthread_mcp_init();                                     /* gives us one vcore */
636                 vcore_request(nr_threads - 1);          /* ghetto incremental interface */
637                 for (int i = 0; i < nr_threads; i++) {
638                         xp = __procinfo.vcoremap;
639                         fprintf(stderr, "%p\n", __procinfo.vcoremap);
640                         fprintf(stderr, "Vcore %d mapped to pcore %d\n", i,
641                                 __procinfo.vcoremap[i].pcoreid);
642                 }
643         }
644
645         ret = syscall(33, 1);
646         if (ret < 0) {
647                 perror("vm setup");
648                 exit(1);
649         }
650         ret = posix_memalign((void **)&p512, 4096, 3*4096);
651         fprintf(stderr, "memalign is %p\n", p512);
652         if (ret) {
653                 perror("ptp alloc");
654                 exit(1);
655         }
656         p1 = &p512[512];
657         p2m = &p512[1024];
658         uint64_t kernbase = 0; //0xffffffff80000000;
659         uint64_t highkernbase = 0xffffffff80000000;
660         p512[PML4(kernbase)] = (unsigned long long)p1 | 7;
661         p1[PML3(kernbase)] = /*0x87; */(unsigned long long)p2m | 7;
662         p512[PML4(highkernbase)] = (unsigned long long)p1 | 7;
663         p1[PML3(highkernbase)] = /*0x87; */(unsigned long long)p2m | 7;
664 #define _2MiB (0x200000)
665
666         for (i = 0; i < 512; i++) {
667                 p2m[PML2(kernbase + i * _2MiB)] = 0x87 | i * _2MiB;
668         }
669
670         kernbase >>= (0+12);
671         kernbase <<= (0 + 12);
672         uint8_t *kernel = (void *)GKERNBASE;
673         //write_coreboot_table(coreboot_tables, ((void *)VIRTIOBASE) /*kernel*/, KERNSIZE + 1048576);
674         hexdump(stdout, coreboot_tables, 512);
675         fprintf(stderr, "kernbase for pml4 is 0x%llx and entry is %llx\n", kernbase, entry);
676         fprintf(stderr, "p512 %p p512[0] is 0x%lx p1 %p p1[0] is 0x%x\n", p512, p512[0], p1, p1[0]);
677         vmctl.interrupt = 0;
678         vmctl.command = REG_RSP_RIP_CR3;
679         vmctl.cr3 = (uint64_t) p512;
680         vmctl.regs.tf_rip = entry;
681         vmctl.regs.tf_rsp = (uint64_t) &stack[1024];
682         if (mcp) {
683                 /* set up virtio bits, which depend on threads being enabled. */
684                 register_virtio_mmio(&vqdev, virtio_mmio_base);
685         }
686         fprintf(stderr, "threads started\n");
687         fprintf(stderr, "Writing command :%s:\n", cmd);
688         
689         if (debug)
690                 vapic_status_dump(stderr, (void *)gpci.vapic_addr);
691
692         ret = pwrite(fd, &vmctl, sizeof(vmctl), 0);
693
694         if (debug)
695                 vapic_status_dump(stderr, (void *)gpci.vapic_addr);
696
697         if (ret != sizeof(vmctl)) {
698                 perror(cmd);
699         }
700         while (1) {
701                 void showstatus(FILE *f, struct vmctl *v);
702                 int c;
703                 uint8_t byte;
704                 vmctl.command = REG_RIP;
705                 if (maxresume-- == 0) {
706                         debug = 1;
707                         resumeprompt = 1;
708                 }
709                 if (debug) {
710                         fprintf(stderr, "RIP %p, shutdown 0x%x\n", vmctl.regs.tf_rip, vmctl.shutdown);
711                         showstatus(stderr, &vmctl);
712                 }
713                 if (resumeprompt) {
714                         fprintf(stderr, "RESUME?\n");
715                         c = getchar();
716                         if (c == 'q')
717                                 break;
718                 }
719                 if (vmctl.shutdown == SHUTDOWN_EPT_VIOLATION) {
720                         uint64_t gpa, *regp, val;
721                         uint8_t regx;
722                         int store, size;
723                         int advance;
724                         if (decode(&vmctl, &gpa, &regx, &regp, &store, &size, &advance)) {
725                                 fprintf(stderr, "RIP %p, shutdown 0x%x\n", vmctl.regs.tf_rip, vmctl.shutdown);
726                                 showstatus(stderr, &vmctl);
727                                 quit = 1;
728                                 break;
729                         }
730                         if (debug) fprintf(stderr, "%p %p %p %p %p %p\n", gpa, regx, regp, store, size, advance);
731                         if ((gpa & ~0xfffULL) == virtiobase) {
732                                 if (debug) fprintf(stderr, "DO SOME VIRTIO\n");
733                                 // Lucky for us the various virtio ops are well-defined.
734                                 virtio_mmio(&vmctl, gpa, regx, regp, store);
735                                 if (debug) fprintf(stderr, "store is %d:\n", store);
736                                 if (debug) fprintf(stderr, "REGP IS %16x:\n", *regp);
737                         } else if ((gpa & 0xfee00000) == 0xfee00000) {
738                                 // until we fix our include mess, just put the proto here.
739                                 //int apic(struct vmctl *v, uint64_t gpa, int destreg, uint64_t *regp, int store);
740                                 //apic(&vmctl, gpa, regx, regp, store);
741                         } else if ((gpa & 0xfec00000) == 0xfec00000) {
742                                 // until we fix our include mess, just put the proto here.
743                                 int do_ioapic(struct vmctl *v, uint64_t gpa, int destreg, uint64_t *regp, int store);
744                                 do_ioapic(&vmctl, gpa, regx, regp, store);
745                         } else if (gpa < 4096) {
746                                 uint64_t val = 0;
747                                 memmove(&val, &low4k[gpa], size);
748                                 hexdump(stdout, &low4k[gpa], size);
749                                 fprintf(stderr, "Low 1m, code %p read @ %p, size %d, val %p\n", vmctl.regs.tf_rip, gpa, size, val);
750                                 memmove(regp, &low4k[gpa], size);
751                                 hexdump(stdout, regp, size);
752                         } else {
753                                 fprintf(stderr, "EPT violation: can't handle %p\n", gpa);
754                                 fprintf(stderr, "RIP %p, shutdown 0x%x\n", vmctl.regs.tf_rip, vmctl.shutdown);
755                                 fprintf(stderr, "Returning 0xffffffff\n");
756                                 showstatus(stderr, &vmctl);
757                                 // Just fill the whole register for now.
758                                 *regp = (uint64_t) -1;
759                         }
760                         vmctl.regs.tf_rip += advance;
761                         if (debug) fprintf(stderr, "Advance rip by %d bytes to %p\n", advance, vmctl.regs.tf_rip);
762                         vmctl.shutdown = 0;
763                         vmctl.gpa = 0;
764                         vmctl.command = REG_ALL;
765                 } else if (vmctl.shutdown == SHUTDOWN_UNHANDLED_EXIT_REASON) {
766                         switch(vmctl.ret_code){
767                         case  EXIT_REASON_VMCALL:
768                                 byte = vmctl.regs.tf_rdi;
769                                 printf("%c", byte);
770                                 if (byte == '\n') printf("%c", '%');
771                                 vmctl.regs.tf_rip += 3;
772                                 break;
773                         case EXIT_REASON_EXTERNAL_INTERRUPT:
774                                 //debug = 1;
775                                 if (debug) fprintf(stderr, "XINT 0x%x 0x%x\n", vmctl.intrinfo1, vmctl.intrinfo2);
776                                 if (debug) pir_dump();
777                                 vmctl.command = RESUME;
778                                 break;
779                         case EXIT_REASON_IO_INSTRUCTION:
780                                 fprintf(stderr, "IO @ %p\n", vmctl.regs.tf_rip);
781                                 io(&vmctl);
782                                 vmctl.shutdown = 0;
783                                 vmctl.gpa = 0;
784                                 vmctl.command = REG_ALL;
785                                 break;
786                         case EXIT_REASON_INTERRUPT_WINDOW:
787                                 if (consdata) {
788                                         if (debug) fprintf(stderr, "inject an interrupt\n");
789                                         virtio_mmio_set_vring_irq();
790                                         vmctl.interrupt = 0x80000000 | virtioirq;
791                                         vmctl.command = RESUME;
792                                         consdata = 0;
793                                 }
794                                 break;
795                         case EXIT_REASON_MSR_WRITE:
796                         case EXIT_REASON_MSR_READ:
797                                 fprintf(stderr, "Do an msr\n");
798                                 quit = msrio(&vmctl, vmctl.ret_code);
799                                 if (quit) {
800                                         fprintf(stderr, "MSR FAILED: RIP %p, shutdown 0x%x\n", vmctl.regs.tf_rip, vmctl.shutdown);
801                                         showstatus(stderr, &vmctl);
802                                 }
803                                 break;
804                         case EXIT_REASON_MWAIT_INSTRUCTION:
805                           fflush(stdout);
806                                 if (debug)fprintf(stderr, "\n================== Guest MWAIT. =======================\n");
807                                 if (debug)fprintf(stderr, "Wait for cons data\n");
808                                 while (!consdata)
809                                         ;
810                                 //debug = 1;
811                                 if (debug)
812                                         vapic_status_dump(stderr, gpci.vapic_addr);
813                                 if (debug)fprintf(stderr, "Resume with consdata ...\n");
814                                 vmctl.regs.tf_rip += 3;
815                                 ret = pwrite(fd, &vmctl, sizeof(vmctl), 0);
816                                 if (ret != sizeof(vmctl)) {
817                                         perror(cmd);
818                                 }
819                                 //fprintf(stderr, "RIP %p, shutdown 0x%x\n", vmctl.regs.tf_rip, vmctl.shutdown);
820                                 //showstatus(stderr, &vmctl);
821                                 break;
822                         case EXIT_REASON_HLT:
823                                 fflush(stdout);
824                                 if (debug)fprintf(stderr, "\n================== Guest halted. =======================\n");
825                                 if (debug)fprintf(stderr, "Wait for cons data\n");
826                                 while (!consdata)
827                                         ;
828                                 //debug = 1;
829                                 if (debug)fprintf(stderr, "Resume with consdata ...\n");
830                                 vmctl.regs.tf_rip += 1;
831                                 ret = pwrite(fd, &vmctl, sizeof(vmctl), 0);
832                                 if (ret != sizeof(vmctl)) {
833                                         perror(cmd);
834                                 }
835                                 //fprintf(stderr, "RIP %p, shutdown 0x%x\n", vmctl.regs.tf_rip, vmctl.shutdown);
836                                 //showstatus(stderr, &vmctl);
837                                 break;
838                         case EXIT_REASON_APIC_ACCESS:                           
839                                 if (1 || debug)fprintf(stderr, "APIC READ EXIT\n");
840                                 
841                                 uint64_t gpa, *regp, val;
842                                 uint8_t regx;
843                                 int store, size;
844                                 int advance;
845                                 if (decode(&vmctl, &gpa, &regx, &regp, &store, &size, &advance)) {
846                                         fprintf(stderr, "RIP %p, shutdown 0x%x\n", vmctl.regs.tf_rip, vmctl.shutdown);
847                                         showstatus(stderr, &vmctl);
848                                         quit = 1;
849                                         break;
850                                 }
851
852                                 int apic(struct vmctl *v, uint64_t gpa, int destreg, uint64_t *regp, int store);
853                                 apic(&vmctl, gpa, regx, regp, store);
854                                 vmctl.regs.tf_rip += advance;
855                                 if (debug) fprintf(stderr, "Advance rip by %d bytes to %p\n", advance, vmctl.regs.tf_rip);
856                                 vmctl.shutdown = 0;
857                                 vmctl.gpa = 0;
858                                 vmctl.command = REG_ALL;
859                                 break;
860                         case EXIT_REASON_APIC_WRITE:
861                                 if (1 || debug)fprintf(stderr, "APIC WRITE EXIT\n");
862                                 break;
863                         default:
864                                 fprintf(stderr, "Don't know how to handle exit %d\n", vmctl.ret_code);
865                                 fprintf(stderr, "RIP %p, shutdown 0x%x\n", vmctl.regs.tf_rip, vmctl.shutdown);
866                                 showstatus(stderr, &vmctl);
867                                 quit = 1;
868                                 break;
869                         }
870                 }
871                 if (debug) fprintf(stderr, "at bottom of switch, quit is %d\n", quit);
872                 if (quit)
873                         break;
874                 if (consdata) {
875                         if (debug) fprintf(stderr, "inject an interrupt\n");
876                         if (debug) fprintf(stderr, "XINT 0x%x 0x%x\n", vmctl.intrinfo1, vmctl.intrinfo2);
877                         vmctl.interrupt = 0x80000000 | virtioirq;
878                         virtio_mmio_set_vring_irq();
879                         consdata = 0;
880                         //debug = 1;
881                         vmctl.command = RESUME;
882                 }
883                 if (debug) fprintf(stderr, "NOW DO A RESUME\n");
884                 ret = pwrite(fd, &vmctl, sizeof(vmctl), 0);
885                 if (ret != sizeof(vmctl)) {
886                         perror(cmd);
887                 }
888         }
889
890         /* later. 
891         for (int i = 0; i < nr_threads-1; i++) {
892                 int ret;
893                 if (pthread_join(my_threads[i], &my_retvals[i]))
894                         perror("pth_join failed");
895                 fprintf(stderr, "%d %d\n", i, ret);
896         }
897  */
898
899         fflush(stdout);
900         exit(0);
901 }