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