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