vmrunkernel: correctly set up page tables for all of memory
[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 <gelf.h>
10 #include <errno.h>
11 #include <libelf.h>
12 #include <dirent.h>
13 #include <stdlib.h>
14 #include <string.h>
15 #include <ros/syscall.h>
16 #include <sys/mman.h>
17 #include <vmm/vmm.h>
18 #include <vmm/acpi/acpi.h>
19 #include <vmm/acpi/vmm_simple_dsdt.h>
20 #include <ros/arch/mmu.h>
21 #include <ros/arch/membar.h>
22 #include <ros/vmm.h>
23 #include <parlib/uthread.h>
24 #include <vmm/linux_bootparam.h>
25 #include <getopt.h>
26
27 #include <vmm/virtio.h>
28 #include <vmm/virtio_blk.h>
29 #include <vmm/virtio_mmio.h>
30 #include <vmm/virtio_ids.h>
31 #include <vmm/virtio_config.h>
32 #include <vmm/virtio_console.h>
33 #include <vmm/virtio_net.h>
34 #include <vmm/virtio_lguest_console.h>
35
36 #include <vmm/sched.h>
37 #include <sys/eventfd.h>
38 #include <sys/uio.h>
39
40 struct virtual_machine local_vm, *vm = &local_vm;
41
42 struct vmm_gpcore_init gpci;
43
44 /* By 1999, you could just scan the hardware
45  * and work it out. But 2005, that was no longer possible. How sad.
46  * so we have to fake acpi to make it all work.
47  * This will be copied to memory at 0xe0000, so the kernel can find it.
48  */
49
50 /* assume they're all 256 bytes long just to make it easy.
51  * Just have pointers that point to aligned things.
52  */
53
54 struct acpi_table_rsdp rsdp = {
55         .signature = ACPI_SIG_RSDP,
56         .oem_id = "AKAROS",
57         .revision = 2,
58         .length = 36,
59 };
60
61 struct acpi_table_xsdt xsdt = {
62         .header = {
63                 .signature = ACPI_SIG_DSDT,
64                 .revision = 2,
65                 .oem_id = "AKAROS",
66                 .oem_table_id = "ALPHABET",
67                 .oem_revision = 0,
68                 .asl_compiler_id = "RON ",
69                 .asl_compiler_revision = 0,
70         },
71 };
72 struct acpi_table_fadt fadt = {
73         .header = {
74                 .signature = ACPI_SIG_FADT,
75                 .revision = 2,
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
84
85 /* This has to be dropped into memory, then the other crap just follows it.
86  */
87 struct acpi_table_madt madt = {
88         .header = {
89                 .signature = ACPI_SIG_MADT,
90                 .revision = 2,
91                 .oem_id = "AKAROS",
92                 .oem_table_id = "ALPHABET",
93                 .oem_revision = 0,
94                 .asl_compiler_id = "RON ",
95                 .asl_compiler_revision = 0,
96         },
97
98         .address = 0xfee00000ULL,
99         .flags = 0,
100 };
101
102 struct acpi_madt_local_apic Apic0 = {.header = {.type = ACPI_MADT_TYPE_LOCAL_APIC, .length = sizeof(struct acpi_madt_local_apic)},
103                                      .processor_id = 0, .id = 0, .lapic_flags = 1};
104 struct acpi_madt_io_apic Apic1 = {.header = {.type = ACPI_MADT_TYPE_IO_APIC, .length = sizeof(struct acpi_madt_io_apic)},
105                                   .id = 0, .address = 0xfec00000, .global_irq_base = 0};
106 struct acpi_madt_local_x2apic X2Apic0 = {
107         .header = {
108                 .type = ACPI_MADT_TYPE_LOCAL_X2APIC,
109                 .length = sizeof(struct acpi_madt_local_x2apic)
110         },
111         .local_apic_id = 0,
112         .uid = 0
113 };
114
115 struct acpi_madt_interrupt_override isor[] = {
116         /* From the ACPI Specification Version 6.1:
117          * For example, if your machine has the ISA Programmable Interrupt Timer
118          * (PIT) connected to ISA IRQ 0, but in APIC mode, it is connected to I/O
119          * APIC interrupt input 2, then you would need an Interrupt Source Override
120          * where the source entry is ‘0’ and the Global System Interrupt is ‘2.’
121          */
122 };
123
124
125 /* this test will run the "kernel" in the negative address space. We hope. */
126 void *low1m;
127 volatile int shared = 0;
128 volatile int quit = 0;
129
130 /* total hack. If the vm runs away we want to get control again. */
131 unsigned int maxresume = (unsigned int) -1;
132
133 #define MiB 0x100000ull
134 #define GiB (1ull << 30)
135 #define MinMemory (16*MiB)
136 void *kernel;
137 unsigned long long memsize = GiB;
138 uintptr_t memstart = MinMemory;
139 uintptr_t stack;
140
141 typedef struct {
142         uint64_t pte[512];
143 } ptp;
144
145 ptp *p512, *p1, *p2m;
146
147 void **my_retvals;
148 int nr_threads = 4;
149 int debug = 0;
150 int resumeprompt = 0;
151 /* unlike Linux, this shared struct is for both host and guest. */
152 //      struct virtqueue *constoguest =
153 //              vring_new_virtqueue(0, 512, 8192, 0, inpages, NULL, NULL, "test");
154
155 void vapic_status_dump(FILE *f, void *vapic);
156
157 #if __GNUC__ < 4 || (__GNUC__ == 4 && __GNUC_MINOR__ < 1)
158 #error "Get a gcc newer than 4.4.0"
159 #else
160 #define BITOP_ADDR(x) "+m" (*(volatile long *) (x))
161 #endif
162
163 #define LOCK_PREFIX "lock "
164 #define ADDR                            BITOP_ADDR(addr)
165 static inline int test_and_set_bit(int nr, volatile unsigned long *addr);
166 static int default_nic = 1;
167
168 pthread_t timerthread_struct;
169
170 void timer_thread(void *arg)
171 {
172         uint8_t vector;
173         uint32_t initial_count;
174         while (1) {
175                 vector = ((uint32_t *)gpci.vapic_addr)[0x32] & 0xff;
176                 initial_count = ((uint32_t *)gpci.vapic_addr)[0x38];
177                 if (vector && initial_count)
178                         vmm_interrupt_guest(vm, 0, vector);
179                 uthread_usleep(100000);
180         }
181         fprintf(stderr, "SENDING TIMER\n");
182 }
183
184
185 // FIXME.
186 volatile int consdata = 0;
187
188 /* TODO: pass a core id to poke_guest */
189 static void virtio_poke_guest(uint8_t vec)
190 {
191         vmm_interrupt_guest(vm, 0, vec);
192 }
193
194 static struct virtio_mmio_dev cons_mmio_dev = {
195         .poke_guest = virtio_poke_guest,
196 };
197
198 static struct virtio_console_config cons_cfg;
199 static struct virtio_console_config cons_cfg_d;
200
201 static struct virtio_vq_dev cons_vqdev = {
202         .name = "console",
203         .dev_id = VIRTIO_ID_CONSOLE,
204         .dev_feat =
205         (1ULL << VIRTIO_F_VERSION_1) | (1 << VIRTIO_RING_F_INDIRECT_DESC),
206         .num_vqs = 2,
207         .cfg = &cons_cfg,
208         .cfg_d = &cons_cfg_d,
209         .cfg_sz = sizeof(struct virtio_console_config),
210         .transport_dev = &cons_mmio_dev,
211         .vqs = {
212                 {
213                         .name = "cons_receiveq",
214                         .qnum_max = 64,
215                         .srv_fn = cons_receiveq_fn,
216                         .vqdev = &cons_vqdev
217                 },
218                 {
219                         .name = "cons_transmitq",
220                         .qnum_max = 64,
221                         .srv_fn = cons_transmitq_fn,
222                         .vqdev = &cons_vqdev
223                 },
224         }
225 };
226
227 static struct virtio_mmio_dev net_mmio_dev = {
228         .poke_guest = virtio_poke_guest,
229 };
230
231 static struct virtio_net_config net_cfg = {
232         .max_virtqueue_pairs = 1
233 };
234 static struct virtio_net_config net_cfg_d = {
235         .max_virtqueue_pairs = 1
236 };
237
238 static struct virtio_vq_dev net_vqdev = {
239         .name = "network",
240         .dev_id = VIRTIO_ID_NET,
241         .dev_feat = (1ULL << VIRTIO_F_VERSION_1 | 1 << VIRTIO_NET_F_MAC),
242
243         .num_vqs = 2,
244         .cfg = &net_cfg,
245         .cfg_d = &net_cfg_d,
246         .cfg_sz = sizeof(struct virtio_net_config),
247         .transport_dev = &net_mmio_dev,
248         .vqs = {
249                 {
250                         .name = "net_receiveq",
251                         .qnum_max = 64,
252                         .srv_fn = net_receiveq_fn,
253                         .vqdev = &net_vqdev
254                 },
255                 {
256                         .name = "net_transmitq",
257                         .qnum_max = 64,
258                         .srv_fn = net_transmitq_fn,
259                         .vqdev = &net_vqdev
260                 },
261         }
262 };
263
264 static struct virtio_mmio_dev blk_mmio_dev = {
265         .poke_guest = virtio_poke_guest,
266 };
267
268 static struct virtio_blk_config blk_cfg = {
269 };
270
271 static struct virtio_blk_config blk_cfg_d = {
272 };
273
274 static struct virtio_vq_dev blk_vqdev = {
275         .name = "block",
276         .dev_id = VIRTIO_ID_BLOCK,
277         .dev_feat = (1ULL << VIRTIO_F_VERSION_1),
278
279         .num_vqs = 1,
280         .cfg = &blk_cfg,
281         .cfg_d = &blk_cfg_d,
282         .cfg_sz = sizeof(struct virtio_blk_config),
283         .transport_dev = &blk_mmio_dev,
284         .vqs = {
285                 {
286                         .name = "blk_request",
287                         .qnum_max = 64,
288                         .srv_fn = blk_request,
289                         .vqdev = &blk_vqdev
290                 },
291         }
292 };
293
294 void lowmem() {
295         __asm__ __volatile__ (".section .lowmem, \"aw\"\n\tlow: \n\t.=0x1000\n\t.align 0x100000\n\t.previous\n");
296 }
297
298 static uint8_t acpi_tb_checksum(uint8_t *buffer, uint32_t length)
299 {
300         uint8_t sum = 0;
301         uint8_t *end = buffer + length;
302         fprintf(stderr, "tbchecksum %p for %d", buffer, length);
303         while (buffer < end) {
304                 if (end - buffer < 2)
305                         fprintf(stderr, "%02x\n", sum);
306                 sum = (uint8_t)(sum + *(buffer++));
307         }
308         fprintf(stderr, " is %02x\n", sum);
309         return (sum);
310 }
311
312 static void gencsum(uint8_t *target, void *data, int len)
313 {
314         uint8_t csum;
315         // blast target to zero so it does not get counted
316         // (it might be in the struct we checksum) And, yes, it is, goodness.
317         fprintf(stderr, "gencsum %p target %p source %d bytes\n", target, data, len);
318         *target = 0;
319         csum  = acpi_tb_checksum((uint8_t *)data, len);
320         *target = ~csum + 1;
321         fprintf(stderr, "Cmoputed is %02x\n", *target);
322 }
323
324 static inline int test_and_set_bit(int nr, volatile unsigned long *addr)
325 {
326         int oldbit;
327
328         asm volatile(LOCK_PREFIX "bts %2,%1\n\t"
329                      "sbb %0,%0" : "=r" (oldbit), ADDR : "Ir" (nr) : "memory");
330
331         return oldbit;
332 }
333
334 /* load_kernel loads an ELF file as a kernel. */
335 uintptr_t
336 load_kernel(char *filename)
337 {
338         Elf64_Ehdr *ehdr;
339         Elf *elf;
340         size_t phnum = 0;
341         Elf64_Phdr *hdrs;
342         int fd;
343
344         elf_version(EV_CURRENT);
345         fd = open(filename, O_RDONLY);
346         if (fd < 0) {
347                 fprintf(stderr, "Can't open %s: %r\n", filename);
348                 return 0;
349         }
350
351         elf = elf_begin(fd, ELF_C_READ, NULL);
352         if (elf == NULL) {
353                 fprintf(stderr, "%s: cannot read %s ELF file.\n", __func__, filename);
354                 close(fd);
355                 return 0;
356         }
357
358         ehdr = elf64_getehdr(elf);
359         if (ehdr == NULL) {
360                 fprintf(stderr, "%s: cannot get exec header of %s.\n",
361                         __func__, filename);
362                 goto fail;
363         }
364         fprintf(stderr, "%s ELF entry point is %p\n", filename,
365                 (void *)ehdr->e_entry);
366
367         if (elf_getphdrnum(elf, &phnum) < 0) {
368                 fprintf(stderr, "%s: cannot get program header num of %s.\n",
369                         __func__, filename);
370                 goto fail;
371         }
372         fprintf(stderr, "%s has %p program headers\n", filename, phnum);
373
374         hdrs = elf64_getphdr(elf);
375         if (hdrs == NULL) {
376                 fprintf(stderr, "%s: cannot get program headers of %s.\n",
377                         __func__, filename);
378                 goto fail;
379         }
380
381         for (int i = 0; i < phnum; i++) {
382                 size_t tot;
383                 Elf64_Phdr *h = &hdrs[i];
384                 uintptr_t pa;
385
386                 fprintf(stderr,
387                         "%d: type 0x%lx flags 0x%lx  offset 0x%lx vaddr 0x%lx paddr 0x%lx size 0x%lx  memsz 0x%lx align 0x%lx\n",
388                         i,
389                         h->p_type,              /* Segment type */
390                         h->p_flags,             /* Segment flags */
391                         h->p_offset,            /* Segment file offset */
392                         h->p_vaddr,             /* Segment virtual address */
393                         h->p_paddr,             /* Segment physical address */
394                         h->p_filesz,            /* Segment size in file */
395                         h->p_memsz,             /* Segment size in memory */
396                         h->p_align              /* Segment alignment */);
397                 if (h->p_type != PT_LOAD)
398                         continue;
399                 if ((h->p_flags & (PF_R | PF_W | PF_X)) == 0)
400                         continue;
401
402                 pa = h->p_paddr;
403                 fprintf(stderr,
404                         "Read header %d @offset %p to %p (elf PA is %p) %d bytes:",
405                         i, h->p_offset, pa, h->p_paddr, h->p_filesz);
406                 tot = 0;
407                 while (tot < h->p_filesz) {
408                         int amt = pread(fd, (void *)(pa + tot), h->p_filesz - tot,
409                                         h->p_offset + tot);
410                         if (amt < 1)
411                                 break;
412                         tot += amt;
413                 }
414                 fprintf(stderr, "read a total of %d bytes\n", tot);
415                 if (tot < h->p_filesz) {
416                         fprintf(stderr, "%s: got %d bytes, wanted %d bytes\n",
417                                 filename, tot, h->p_filesz);
418                         goto fail;
419                 }
420         }
421
422         close(fd);
423         elf_end(elf);
424         return ehdr->e_entry;
425 fail:
426         close(fd);
427         elf_end(elf);
428         return 0;
429 }
430
431 /* TODO: put this in a library somewhere */
432 int cat(char *file, void *where)
433 {
434         int fd;
435         int amt, tot = 0;
436
437         fd = open(file, O_RDONLY);
438         if (fd < 0)
439                 return -1;
440
441         while (amt = read(fd, where, 4096)) {
442                 if (amt < 0) {
443                         close(fd);
444                         return -1;
445                 }
446                 tot += amt;
447                 where += amt;
448         }
449         close(fd);
450         return tot;
451 }
452
453 int smbios(char *smbiostable, void *esegment)
454 {
455         int amt;
456
457         amt = cat(smbiostable, esegment);
458         if (amt < 0) {
459                 fprintf(stderr, "%s: %r\n", smbiostable);
460                 exit(1);
461         }
462
463         return amt;
464 }
465
466 int main(int argc, char **argv)
467 {
468         struct boot_params *bp;
469         char cmdline_default[512] = {0};
470         char *cmdline_extra = "\0";
471         char *cmdline;
472         void *a = (void *)0xe0000;
473         struct acpi_table_rsdp *r;
474         struct acpi_table_fadt *f;
475         struct acpi_table_madt *m;
476         struct acpi_table_xsdt *x;
477         int vmmflags = 0; // Disabled probably forever. VMM_VMCALL_PRINTF;
478         uint64_t entry = 0;
479         int ret;
480         uint8_t csum;
481         void *a_page;
482         struct vm_trapframe *vm_tf;
483         uint64_t tsc_freq_khz;
484         char *cmdlinep;
485         int cmdlinesz, len, cmdline_fd;
486         char *disk_image_file = NULL;
487         int c;
488         struct stat stat_result;
489         int num_read;
490         int option_index;
491         char *smbiostable = NULL;
492         int nptp, npml4, npml3, npml2;
493
494         static struct option long_options[] = {
495                 {"debug",         no_argument,       0, 'd'},
496                 {"vmm_vmcall",    no_argument,       0, 'v'},
497                 {"maxresume",     required_argument, 0, 'R'},
498                 {"memsize",       required_argument, 0, 'm'},
499                 {"memstart",      required_argument, 0, 'M'},
500                 {"stack",         required_argument, 0, 'S'},
501                 {"cmdline_extra", required_argument, 0, 'c'},
502                 {"greedy",        no_argument,       0, 'g'},
503                 {"scp",           no_argument,       0, 's'},
504                 {"image_file",    required_argument, 0, 'f'},
505                 {"cmdline",       required_argument, 0, 'k'},
506                 {"nic",           required_argument, 0, 'n'},
507                 {"smbiostable",   required_argument, 0, 't'},
508                 {"help",          no_argument,       0, 'h'},
509                 {0, 0, 0, 0}
510         };
511
512         fprintf(stderr, "%p %p %p %p\n", PGSIZE, PGSHIFT, PML1_SHIFT,
513                 PML1_PTE_REACH);
514
515         if ((uintptr_t)__procinfo.program_end >= MinMemory) {
516                 fprintf(stderr,
517                         "Panic: vmrunkernel binary extends into guest memory\n");
518                 exit(1);
519         }
520
521         vm->low4k = malloc(PGSIZE);
522         memset(vm->low4k, 0xff, PGSIZE);
523         vm->low4k[0x40e] = 0;
524         vm->low4k[0x40f] = 0;
525
526         //Place mmap(Gan)
527         a_page = mmap((void *)0xfee00000, PGSIZE, PROT_READ | PROT_WRITE,
528                       MAP_POPULATE | MAP_ANONYMOUS, -1, 0);
529         fprintf(stderr, "a_page mmap pointer %p\n", a_page);
530
531         if (a_page != (void *)0xfee00000) {
532                 perror("Could not mmap APIC");
533                 exit(1);
534         }
535         if (((uint64_t)a_page & 0xfff) != 0) {
536                 perror("APIC page mapping is not page aligned");
537                 exit(1);
538         }
539
540         ((uint32_t *)a_page)[0x30/4] = 0x01060015;
541         //((uint32_t *)a_page)[0x30/4] = 0xDEADBEEF;
542
543         while ((c = getopt_long(argc, argv, "dvm:M:S:c:gsf:k:n:t:hR:",
544                                 long_options, &option_index)) != -1) {
545                 switch (c) {
546                 case 'd':
547                         debug++;
548                         break;
549                 case 'v':
550                         vmmflags |= VMM_VMCALL_PRINTF;
551                         break;
552                 case 'm':
553                         memsize = strtoull(optarg, 0, 0);
554                         break;
555                 case 'M':
556                         memstart = strtoull(optarg, 0, 0);
557                         break;
558                 case 'S':
559                         stack = strtoull(optarg, 0, 0);
560                         break;
561                 case 'R':
562                         maxresume = strtoull(optarg, 0, 0);
563                         break;
564                 case 'c':
565                         cmdline_extra = optarg;
566                 case 'g':       /* greedy */
567                         parlib_never_yield = TRUE;
568                         break;
569                 case 's':       /* scp */
570                         parlib_wants_to_be_mcp = FALSE;
571                         break;
572                 case 'f':       /* file to pass to blk_init */
573                         disk_image_file = optarg;
574                         break;
575                 case 'k':       /* specify file to get cmdline args from */
576                         cmdline_fd = open(optarg, O_RDONLY);
577                         if (cmdline_fd < 0) {
578                                 fprintf(stderr, "failed to open file: %s\n", optarg);
579                                 exit(1);
580                         }
581                         if (stat(optarg, &stat_result) == -1) {
582                                 fprintf(stderr, "stat of %s failed\n", optarg);
583                                 exit(1);
584                         }
585                         len = stat_result.st_size;
586                         if (len > 512) {
587                                 fprintf(stderr, "command line options exceed 512 bytes!");
588                                 exit(1);
589                         }
590                         num_read = read(cmdline_fd, cmdline_default, len);
591                         if (num_read != len) {
592                                 fprintf(stderr, "read failed len was : %d, num_read was: %d\n",
593                                         len, num_read);
594                                 exit(1);
595                         }
596                         close(cmdline_fd);
597                         break;
598                 case 't':
599                         smbiostable = optarg;
600                         break;
601                 case 'n':
602                         default_nic = strtoull(optarg, 0, 0);
603                         break;
604                 case 'h':
605                 default:
606                         // Sadly, the getopt_long struct does
607                         // not have a pointer to help text.
608                         for (int i = 0;
609                              i < sizeof(long_options)/sizeof(long_options[0]) - 1;
610                              i++) {
611                                 struct option *l = &long_options[i];
612
613                                 fprintf(stderr, "%s or %c%s\n", l->name, l->val,
614                                         l->has_arg ? " <arg>" : "");
615                         }
616                         exit(0);
617                 }
618         }
619         if (strlen(cmdline_default) == 0) {
620                 fprintf(stderr, "WARNING: No command line parameter file specified.\n");
621         }
622         argc -= optind;
623         argv += optind;
624         if (argc < 1) {
625                 fprintf(stderr, "Usage: %s vmimage [-n (no vmcall printf)]\n", argv[0]);
626                 exit(1);
627         }
628
629         if ((uintptr_t)(memstart + memsize) >= (uintptr_t)BRK_START) {
630                 fprintf(stderr,
631                         "memstart 0x%lx memsize 0x%lx -> 0x%lx is too large; overlaps BRK_START at %p\n",
632                         memstart, memsize, memstart + memsize, BRK_START);
633                 exit(1);
634         }
635
636         kernel = mmap((void *)memstart, memsize,
637                       PROT_READ | PROT_WRITE | PROT_EXEC,
638                       MAP_POPULATE | MAP_ANONYMOUS, -1, 0);
639         if (kernel != (void *)memstart) {
640                 fprintf(stderr, "Could not mmap 0x%lx bytes at 0x%lx\n",
641                         memsize, memstart);
642                 exit(1);
643         }
644
645         entry = load_kernel(argv[0]);
646         if (entry == 0) {
647                 fprintf(stderr, "Unable to load kernel %s\n", argv[0]);
648                 exit(1);
649         }
650
651
652         // The low 1m so we can fill in bullshit like ACPI. */
653         // And, sorry, due to the STUPID format of the RSDP for now we need the low 1M.
654         low1m = mmap((int*)4096, MiB-4096, PROT_READ | PROT_WRITE,
655                      MAP_ANONYMOUS, -1, 0);
656         if (low1m != (void *)4096) {
657                 perror("Unable to mmap low 1m");
658                 exit(1);
659         }
660         r = a;
661         fprintf(stderr, "install rsdp to %p\n", r);
662         *r = rsdp;
663         a += sizeof(*r);
664         r->xsdt_physical_address = (uint64_t)a;
665         gencsum(&r->checksum, r, ACPI_RSDP_CHECKSUM_LENGTH);
666         if ((csum = acpi_tb_checksum((uint8_t *) r, ACPI_RSDP_CHECKSUM_LENGTH)) != 0) {
667                 fprintf(stderr, "RSDP has bad checksum; summed to %x\n", csum);
668                 exit(1);
669         }
670
671         /* Check extended checksum if table version >= 2 */
672         gencsum(&r->extended_checksum, r, ACPI_RSDP_XCHECKSUM_LENGTH);
673         if ((rsdp.revision >= 2) &&
674             (acpi_tb_checksum((uint8_t *) r, ACPI_RSDP_XCHECKSUM_LENGTH) != 0)) {
675                 fprintf(stderr, "RSDP has bad checksum v2\n");
676                 exit(1);
677         }
678
679         /* just leave a bunch of space for the xsdt. */
680         /* we need to zero the area since it has pointers. */
681         x = a;
682         a += sizeof(*x) + 8*sizeof(void *);
683         memset(x, 0, a - (void *)x);
684         fprintf(stderr, "install xsdt to %p\n", x);
685         *x = xsdt;
686         x->table_offset_entry[0] = 0;
687         x->table_offset_entry[1] = 0;
688         x->header.length = a - (void *)x;
689
690         f = a;
691         fprintf(stderr, "install fadt to %p\n", f);
692         *f = fadt;
693         x->table_offset_entry[0] = (uint64_t)f; // fadt MUST be first in xsdt!
694         a += sizeof(*f);
695         f->header.length = a - (void *)f;
696
697         f->Xdsdt = (uint64_t) a;
698         fprintf(stderr, "install dsdt to %p\n", a);
699         memcpy(a, &DSDT_DSDTTBL_Header, 36);
700         a += 36;
701
702         gencsum(&f->header.checksum, f, f->header.length);
703         if (acpi_tb_checksum((uint8_t *)f, f->header.length) != 0) {
704                 fprintf(stderr, "fadt has bad checksum v2\n");
705                 exit(1);
706         }
707
708         m = a;
709         *m = madt;
710         x->table_offset_entry[3] = (uint64_t) m;
711         a += sizeof(*m);
712         fprintf(stderr, "install madt to %p\n", m);
713         memmove(a, &Apic0, sizeof(Apic0));
714         a += sizeof(Apic0);
715         memmove(a, &Apic1, sizeof(Apic1));
716         a += sizeof(Apic1);
717         memmove(a, &X2Apic0, sizeof(X2Apic0));
718         a += sizeof(X2Apic0);
719         memmove(a, &isor, sizeof(isor));
720         a += sizeof(isor);
721         m->header.length = a - (void *)m;
722
723         gencsum(&m->header.checksum, m, m->header.length);
724         if (acpi_tb_checksum((uint8_t *) m, m->header.length) != 0) {
725                 fprintf(stderr, "madt has bad checksum v2\n");
726                 exit(1);
727         }
728
729         gencsum(&x->header.checksum, x, x->header.length);
730         if ((csum = acpi_tb_checksum((uint8_t *) x, x->header.length)) != 0) {
731                 fprintf(stderr, "XSDT has bad checksum; summed to %x\n", csum);
732                 exit(1);
733         }
734
735         fprintf(stderr, "allchecksums ok\n");
736
737         hexdump(stdout, r, a-(void *)r);
738
739         a = (void *)(((unsigned long)a + 0xfff) & ~0xfff);
740         gpci.posted_irq_desc = a;
741         memset(a, 0, 4096);
742         a += 4096;
743         gpci.vapic_addr = a;
744         memset(a, 0, 4096);
745         ((uint32_t *)a)[0x30/4] = 0x01060014;
746         // set up apic values? do we need to?
747         // qemu does this.
748         //((uint8_t *)a)[4] = 1;
749         a += 4096;
750         gpci.apic_addr = (void*)0xfee00000;
751
752         /* Allocate memory for, and zero the bootparams
753          * page before writing to it, or Linux thinks
754          * we're talking crazy.
755          */
756         a += 4096;
757         bp = a;
758         memset(bp, 0, 4096);
759
760         /* Put the e820 memory region information in the boot_params */
761         bp->e820_entries = 5;
762         int e820i = 0;
763
764         /* Give it just a tiny bit of memory -- 60k -- at low memory. */
765         bp->e820_map[e820i].addr = 0;
766         bp->e820_map[e820i].size = 4 * 1024;
767         bp->e820_map[e820i++].type = E820_RESERVED;
768
769         bp->e820_map[e820i].addr = 4 * 1024;
770         bp->e820_map[e820i].size = 64 * 1024 - 4 * 1024;
771         bp->e820_map[e820i++].type = E820_RAM;
772
773         bp->e820_map[e820i].addr = 64 * 1024;
774         bp->e820_map[e820i].size = memstart - 64 * 1024;
775         bp->e820_map[e820i++].type = E820_RESERVED;
776
777         bp->e820_map[e820i].addr = memstart;
778         bp->e820_map[e820i].size = memsize;
779         bp->e820_map[e820i++].type = E820_RAM;
780
781         bp->e820_map[e820i].addr = 0xf0000000;
782         bp->e820_map[e820i].size = 0x10000000;
783         bp->e820_map[e820i++].type = E820_RESERVED;
784
785         /* The MMIO address of the console device is really the address of an
786          * unbacked EPT page: accesses to this page will cause a page fault that
787          * traps to the host, which will examine the fault, see it was for the
788          * known MMIO address, and fulfill the MMIO read or write on the guest's
789          * behalf accordingly. We place the virtio space at 512 GB higher than the
790          * guest physical memory to avoid a full page table walk. */
791         uint64_t virtio_mmio_base_addr = ROUNDUP((bp->e820_map[e820i - 1].addr +
792                                                   bp->e820_map[e820i - 1].size),
793                                                  512 * GiB);
794
795         cons_mmio_dev.addr =
796                 virtio_mmio_base_addr + PGSIZE * VIRTIO_MMIO_CONSOLE_DEV;
797         cons_mmio_dev.vqdev = &cons_vqdev;
798         vm->virtio_mmio_devices[VIRTIO_MMIO_CONSOLE_DEV] = &cons_mmio_dev;
799
800         net_mmio_dev.addr =
801                 virtio_mmio_base_addr + PGSIZE * VIRTIO_MMIO_NETWORK_DEV;
802         net_mmio_dev.vqdev = &net_vqdev;
803         vm->virtio_mmio_devices[VIRTIO_MMIO_NETWORK_DEV] = &net_mmio_dev;
804
805         if (disk_image_file != NULL) {
806                 blk_mmio_dev.addr =
807                         virtio_mmio_base_addr + PGSIZE * VIRTIO_MMIO_BLOCK_DEV;
808                 blk_mmio_dev.vqdev = &blk_vqdev;
809                 vm->virtio_mmio_devices[VIRTIO_MMIO_BLOCK_DEV] = &blk_mmio_dev;
810                 blk_init_fn(&blk_vqdev, disk_image_file);
811         }
812         net_init_fn(&net_vqdev, default_nic);
813
814         /* Set the kernel command line parameters */
815         a += 4096;
816         cmdline = a;
817         a += 4096;
818
819         if (smbiostable) {
820                 if (a > (void *)0xf0000) {
821                         fprintf(stderr, "No room for SMBIOS table: current table pointer is %p\n",
822                                 a);
823                         exit(1);
824                 }
825                 a = (void *)0xf0000;
826                 fprintf(stderr, "Using SMBIOS table %s\n", smbiostable);
827                 a += smbios(smbiostable, a);
828         }
829
830         bp->hdr.cmd_line_ptr = (uintptr_t) cmdline;
831
832         tsc_freq_khz = get_tsc_freq()/1000;
833         len = snprintf(cmdline, 4096, "%s tscfreq=%lld %s", cmdline_default,
834                        tsc_freq_khz, cmdline_extra);
835
836         cmdlinesz = 4096 - len;
837         cmdlinep = cmdline + len;
838
839         for (int i = 0; i < VIRTIO_MMIO_MAX_NUM_DEV; i++) {
840                 if (vm->virtio_mmio_devices[i] == NULL)
841                         continue;
842
843                 /* Append all the virtio mmio base addresses. */
844
845                 /* Since the lower number irqs are no longer being used, the irqs
846                  * can now be assigned starting from 0.
847                  */
848                 vm->virtio_mmio_devices[i]->irq = i;
849                 len = snprintf(cmdlinep, cmdlinesz,
850                                " virtio_mmio.device=1K@0x%llx:%lld",
851                                vm->virtio_mmio_devices[i]->addr,
852                                vm->virtio_mmio_devices[i]->irq);
853                 if (len >= cmdlinesz) {
854                         fprintf(stderr, "Too many arguments to the linux command line.");
855                         exit(1);
856                 }
857                 cmdlinesz -= len;
858                 cmdlinep += len;
859         }
860
861         vm->nr_gpcs = 1;
862         vm->gpcis = &gpci;
863         ret = vmm_init(vm, vmmflags);
864         assert(!ret);
865
866         /* How many page table pages do we need?  We conservatively
867          * assume that we are in low memory, and hence assume a
868          * 0-based range.  Note that in many cases, kernels will
869          * immediately set up their own map. But for "dune" like
870          * applications, it's necessary. Note also that in most cases,
871          * the total number of pages will be < 16 or so. */
872         npml4 = DIV_ROUND_UP(memstart + memsize, PML4_REACH);
873         nptp = npml4;
874
875         npml3 = DIV_ROUND_UP(memstart + memsize, PML3_REACH);
876         nptp += npml3;
877
878         /* and 1 for each 2 MiB of memory */
879         npml2 = DIV_ROUND_UP(memstart + memsize, PML2_REACH);
880         nptp += npml2;
881
882         fprintf(stderr, "Memstart + memsize is %llx; %d pml4 %d pml3 %d pml2\n",
883                 memstart + memsize, npml4, npml3, npml2);
884
885         /* Place these page tables right after VM memory. We
886          * used to use posix_memalign but that puts them
887          * outside EPT-accessible space on some CPUs. */
888         p512 = mmap((void *)memstart + memsize, nptp * 4096, PROT_READ | PROT_WRITE,
889                      MAP_POPULATE | MAP_ANONYMOUS, -1, 0);
890         if (p512 == MAP_FAILED) {
891                 perror("page table page alloc");
892                 exit(1);
893         }
894         p1 = &p512[npml4];
895         p2m = &p1[npml3];
896
897         /* Set up a 1:1 ("identity") page mapping from guest virtual
898          * to guest physical using the (host virtual)
899          * `kerneladdress`. This mapping may be used for only a short
900          * time, until the guest sets up its own page tables. Be aware
901          * that the values stored in the table are physical addresses.
902          * This is subtle and mistakes are easily disguised due to the
903          * identity mapping, so take care when manipulating these
904          * mappings. */
905
906         p2m->pte[PML2(0)] = (uint64_t)0 | PTE_KERN_RW | PTE_PS;
907
908         fprintf(stderr, "Map %p for %zu bytes\n", memstart, memsize);
909         for (uintptr_t p4 = memstart; p4 < memstart + memsize;
910              p4 += PML4_PTE_REACH, p1++) {
911                 p512->pte[PML4(p4)] = (uint64_t)p1 | PTE_KERN_RW;
912                 if (debug)
913                         fprintf(stderr, "l4@%p: %p set index 0x%x to 0x%llx\n",
914                                 &p512->pte[PML4(p4)],
915                                 p4, PML4(p4), p512->pte[PML4(p4)]);
916                 for (uintptr_t p3 = p4; p3 < memstart + memsize;
917                      p3 += PML3_PTE_REACH, p2m++) {
918                         p1->pte[PML3(p3)] = (uint64_t)p2m | PTE_KERN_RW;
919                         if (debug)
920                                 fprintf(stderr, "\tl3@%p: %p set index 0x%x to 0x%llx\n",
921                                 &p1->pte[PML3(p3)],
922                                 p3, PML3(p3), p1->pte[PML3(p3)]);
923                         for (uintptr_t p2 = p3; p2 < memstart + memsize;
924                              p2 += PML2_PTE_REACH) {
925                                 p2m->pte[PML2(p2)] = (uint64_t)p2 | PTE_KERN_RW | PTE_PS;
926                                 if (debug)
927                                         fprintf(stderr, "\t\tl2@%p: %p set index 0x%x to 0x%llx\n",
928                                                 &p2m->pte[PML2(p2)],
929                                                 p2, PML2(p2), p2m->pte[PML2(p2)]);
930                         }
931                 }
932
933         }
934
935         vmm_run_task(vm, timer_thread, 0);
936
937         vm_tf = gth_to_vmtf(vm->gths[0]);
938         vm_tf->tf_cr3 = (uint64_t) p512;
939         vm_tf->tf_rip = entry;
940         vm_tf->tf_rsp = stack;
941         vm_tf->tf_rsi = (uint64_t) bp;
942         start_guest_thread(vm->gths[0]);
943
944         uthread_sleep_forever();
945         return 0;
946 }