vmrunkernel: fix formatting
[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 unsigned long long *p512, *p1, *p2m;
141
142 void **my_retvals;
143 int nr_threads = 4;
144 int debug = 0;
145 int resumeprompt = 0;
146 /* unlike Linux, this shared struct is for both host and guest. */
147 //      struct virtqueue *constoguest =
148 //              vring_new_virtqueue(0, 512, 8192, 0, inpages, NULL, NULL, "test");
149
150 void vapic_status_dump(FILE *f, void *vapic);
151
152 #if __GNUC__ < 4 || (__GNUC__ == 4 && __GNUC_MINOR__ < 1)
153 #error "Get a gcc newer than 4.4.0"
154 #else
155 #define BITOP_ADDR(x) "+m" (*(volatile long *) (x))
156 #endif
157
158 #define LOCK_PREFIX "lock "
159 #define ADDR                            BITOP_ADDR(addr)
160 static inline int test_and_set_bit(int nr, volatile unsigned long *addr);
161 static int default_nic = 1;
162
163 pthread_t timerthread_struct;
164
165 void timer_thread(void *arg)
166 {
167         uint8_t vector;
168         uint32_t initial_count;
169         while (1) {
170                 vector = ((uint32_t *)gpci.vapic_addr)[0x32] & 0xff;
171                 initial_count = ((uint32_t *)gpci.vapic_addr)[0x38];
172                 if (vector && initial_count)
173                         vmm_interrupt_guest(vm, 0, vector);
174                 uthread_usleep(100000);
175         }
176         fprintf(stderr, "SENDING TIMER\n");
177 }
178
179
180 // FIXME.
181 volatile int consdata = 0;
182
183 /* TODO: pass a core id to poke_guest */
184 static void virtio_poke_guest(uint8_t vec)
185 {
186         vmm_interrupt_guest(vm, 0, vec);
187 }
188
189 static struct virtio_mmio_dev cons_mmio_dev = {
190         .poke_guest = virtio_poke_guest,
191 };
192
193 static struct virtio_console_config cons_cfg;
194 static struct virtio_console_config cons_cfg_d;
195
196 static struct virtio_vq_dev cons_vqdev = {
197         .name = "console",
198         .dev_id = VIRTIO_ID_CONSOLE,
199         .dev_feat =
200         (1ULL << VIRTIO_F_VERSION_1) | (1 << VIRTIO_RING_F_INDIRECT_DESC),
201         .num_vqs = 2,
202         .cfg = &cons_cfg,
203         .cfg_d = &cons_cfg_d,
204         .cfg_sz = sizeof(struct virtio_console_config),
205         .transport_dev = &cons_mmio_dev,
206         .vqs = {
207                 {
208                         .name = "cons_receiveq",
209                         .qnum_max = 64,
210                         .srv_fn = cons_receiveq_fn,
211                         .vqdev = &cons_vqdev
212                 },
213                 {
214                         .name = "cons_transmitq",
215                         .qnum_max = 64,
216                         .srv_fn = cons_transmitq_fn,
217                         .vqdev = &cons_vqdev
218                 },
219         }
220 };
221
222 static struct virtio_mmio_dev net_mmio_dev = {
223         .poke_guest = virtio_poke_guest,
224 };
225
226 static struct virtio_net_config net_cfg = {
227         .max_virtqueue_pairs = 1
228 };
229 static struct virtio_net_config net_cfg_d = {
230         .max_virtqueue_pairs = 1
231 };
232
233 static struct virtio_vq_dev net_vqdev = {
234         .name = "network",
235         .dev_id = VIRTIO_ID_NET,
236         .dev_feat = (1ULL << VIRTIO_F_VERSION_1 | 1 << VIRTIO_NET_F_MAC),
237
238         .num_vqs = 2,
239         .cfg = &net_cfg,
240         .cfg_d = &net_cfg_d,
241         .cfg_sz = sizeof(struct virtio_net_config),
242         .transport_dev = &net_mmio_dev,
243         .vqs = {
244                 {
245                         .name = "net_receiveq",
246                         .qnum_max = 64,
247                         .srv_fn = net_receiveq_fn,
248                         .vqdev = &net_vqdev
249                 },
250                 {
251                         .name = "net_transmitq",
252                         .qnum_max = 64,
253                         .srv_fn = net_transmitq_fn,
254                         .vqdev = &net_vqdev
255                 },
256         }
257 };
258
259 static struct virtio_mmio_dev blk_mmio_dev = {
260         .poke_guest = virtio_poke_guest,
261 };
262
263 static struct virtio_blk_config blk_cfg = {
264 };
265
266 static struct virtio_blk_config blk_cfg_d = {
267 };
268
269 static struct virtio_vq_dev blk_vqdev = {
270         .name = "block",
271         .dev_id = VIRTIO_ID_BLOCK,
272         .dev_feat = (1ULL << VIRTIO_F_VERSION_1),
273
274         .num_vqs = 1,
275         .cfg = &blk_cfg,
276         .cfg_d = &blk_cfg_d,
277         .cfg_sz = sizeof(struct virtio_blk_config),
278         .transport_dev = &blk_mmio_dev,
279         .vqs = {
280                 {
281                         .name = "blk_request",
282                         .qnum_max = 64,
283                         .srv_fn = blk_request,
284                         .vqdev = &blk_vqdev
285                 },
286         }
287 };
288
289 void lowmem() {
290         __asm__ __volatile__ (".section .lowmem, \"aw\"\n\tlow: \n\t.=0x1000\n\t.align 0x100000\n\t.previous\n");
291 }
292
293 static uint8_t acpi_tb_checksum(uint8_t *buffer, uint32_t length)
294 {
295         uint8_t sum = 0;
296         uint8_t *end = buffer + length;
297         fprintf(stderr, "tbchecksum %p for %d", buffer, length);
298         while (buffer < end) {
299                 if (end - buffer < 2)
300                         fprintf(stderr, "%02x\n", sum);
301                 sum = (uint8_t)(sum + *(buffer++));
302         }
303         fprintf(stderr, " is %02x\n", sum);
304         return (sum);
305 }
306
307 static void gencsum(uint8_t *target, void *data, int len)
308 {
309         uint8_t csum;
310         // blast target to zero so it does not get counted
311         // (it might be in the struct we checksum) And, yes, it is, goodness.
312         fprintf(stderr, "gencsum %p target %p source %d bytes\n", target, data, len);
313         *target = 0;
314         csum  = acpi_tb_checksum((uint8_t *)data, len);
315         *target = ~csum + 1;
316         fprintf(stderr, "Cmoputed is %02x\n", *target);
317 }
318
319 static inline int test_and_set_bit(int nr, volatile unsigned long *addr)
320 {
321         int oldbit;
322
323         asm volatile(LOCK_PREFIX "bts %2,%1\n\t"
324                      "sbb %0,%0" : "=r" (oldbit), ADDR : "Ir" (nr) : "memory");
325
326         return oldbit;
327 }
328
329 /* load_kernel loads an ELF file as a kernel. */
330 uintptr_t
331 load_kernel(char *filename, uintptr_t *kernstart, uintptr_t *kernend)
332 {
333         Elf64_Ehdr *ehdr;
334         Elf *elf;
335         size_t phnum = 0;
336         Elf64_Phdr *hdrs;
337         int fd;
338
339         elf_version(EV_CURRENT);
340         fd = open(filename, O_RDONLY);
341         if (fd < 0) {
342                 fprintf(stderr, "Can't open %s: %r\n", filename);
343                 return 0;
344         }
345
346         elf = elf_begin(fd, ELF_C_READ, NULL);
347         if (elf == NULL) {
348                 fprintf(stderr, "%s: cannot read %s ELF file.\n", __func__, filename);
349                 close(fd);
350                 return 0;
351         }
352
353         ehdr = elf64_getehdr(elf);
354         if (ehdr == NULL) {
355                 fprintf(stderr, "%s: cannot get exec header of %s.\n",
356                         __func__, filename);
357                 goto fail;
358         }
359         fprintf(stderr, "%s ELF entry point is %p\n", filename,
360                 (void *)ehdr->e_entry);
361
362         if (elf_getphdrnum(elf, &phnum) < 0) {
363                 fprintf(stderr, "%s: cannot get program header num of %s.\n",
364                         __func__, filename);
365                 goto fail;
366         }
367         fprintf(stderr, "%s has %p program headers\n", filename, phnum);
368
369         hdrs = elf64_getphdr(elf);
370         if (hdrs == NULL) {
371                 fprintf(stderr, "%s: cannot get program headers of %s.\n",
372                         __func__, filename);
373                 goto fail;
374         }
375
376         for (int i = 0; i < phnum; i++) {
377                 size_t tot;
378                 Elf64_Phdr *h = &hdrs[i];
379                 uintptr_t pa;
380
381                 fprintf(stderr,
382                         "%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",
383                         i,
384                         h->p_type,              /* Segment type */
385                         h->p_flags,             /* Segment flags */
386                         h->p_offset,            /* Segment file offset */
387                         h->p_vaddr,             /* Segment virtual address */
388                         h->p_paddr,             /* Segment physical address */
389                         h->p_filesz,            /* Segment size in file */
390                         h->p_memsz,             /* Segment size in memory */
391                         h->p_align              /* Segment alignment */);
392                 if (h->p_type != PT_LOAD)
393                         continue;
394                 if ((h->p_flags & (PF_R | PF_W | PF_X)) == 0)
395                         continue;
396
397                 pa = h->p_paddr;
398                 if (*kernstart > pa)
399                         *kernstart = pa;
400                 if (*kernend < pa + h->p_memsz)
401                         *kernend = pa + h->p_memsz;
402                 fprintf(stderr,
403                         "Read header %d @offset %p to %p (elf PA is %p) %d bytes:",
404                         i, h->p_offset, pa, h->p_paddr, h->p_filesz);
405                 tot = 0;
406                 while (tot < h->p_filesz) {
407                         int amt = pread(fd, (void *)(pa + tot), h->p_filesz - tot,
408                                         h->p_offset + tot);
409                         if (amt < 1)
410                                 break;
411                         tot += amt;
412                 }
413                 fprintf(stderr, "read a total of %d bytes\n", tot);
414                 if (tot < h->p_filesz) {
415                         fprintf(stderr, "%s: got %d bytes, wanted %d bytes\n",
416                                 filename, tot, h->p_filesz);
417                         goto fail;
418                 }
419         }
420
421         close(fd);
422         elf_end(elf);
423         return ehdr->e_entry;
424 fail:
425         close(fd);
426         elf_end(elf);
427         return 0;
428 }
429
430 int main(int argc, char **argv)
431 {
432         struct boot_params *bp;
433         char cmdline_default[512] = {0};
434         char *cmdline_extra = "\0";
435         char *cmdline;
436         void *a = (void *)0xe0000;
437         struct acpi_table_rsdp *r;
438         struct acpi_table_fadt *f;
439         struct acpi_table_madt *m;
440         struct acpi_table_xsdt *x;
441         int vmmflags = 0; // Disabled probably forever. VMM_VMCALL_PRINTF;
442         uint64_t entry = 0;
443         int ret;
444         uintptr_t size;
445         uint8_t csum;
446         void *a_page;
447         struct vm_trapframe *vm_tf;
448         uint64_t tsc_freq_khz;
449         char *cmdlinep;
450         int cmdlinesz, len, cmdline_fd;
451         char *disk_image_file = NULL;
452         int c;
453         struct stat stat_result;
454         int num_read;
455         int option_index;
456         uintptr_t kernstart = (uintptr_t)~1, kernend = 0;
457         static struct option long_options[] = {
458                 {"debug",         no_argument,       0, 'd'},
459                 {"vmm_vmcall",    no_argument,       0, 'v'},
460                 {"maxresume",     required_argument, 0, 'R'},
461                 {"memsize",       required_argument, 0, 'm'},
462                 {"memstart",      required_argument, 0, 'M'},
463                 {"stack",         required_argument, 0, 'S'},
464                 {"cmdline_extra", required_argument, 0, 'c'},
465                 {"greedy",        no_argument,       0, 'g'},
466                 {"scp",           no_argument,       0, 's'},
467                 {"image_file",    required_argument, 0, 'f'},
468                 {"cmdline",       required_argument, 0, 'k'},
469                 {"nic",           required_argument, 0, 'n'},
470                 {"help",          no_argument,       0, 'h'},
471                 {0, 0, 0, 0}
472         };
473
474         fprintf(stderr, "%p %p %p %p\n", PGSIZE, PGSHIFT, PML1_SHIFT,
475                 PML1_PTE_REACH);
476
477         if ((uintptr_t)__procinfo.program_end >= MinMemory) {
478                 fprintf(stderr,
479                         "Panic: vmrunkernel binary extends into guest memory\n");
480                 exit(1);
481         }
482
483         vm->low4k = malloc(PGSIZE);
484         memset(vm->low4k, 0xff, PGSIZE);
485         vm->low4k[0x40e] = 0;
486         vm->low4k[0x40f] = 0;
487
488         //Place mmap(Gan)
489         a_page = mmap((void *)0xfee00000, PGSIZE, PROT_READ | PROT_WRITE,
490                       MAP_POPULATE | MAP_ANONYMOUS, -1, 0);
491         fprintf(stderr, "a_page mmap pointer %p\n", a_page);
492
493         if (a_page != (void *)0xfee00000) {
494                 perror("Could not mmap APIC");
495                 exit(1);
496         }
497         if (((uint64_t)a_page & 0xfff) != 0) {
498                 perror("APIC page mapping is not page aligned");
499                 exit(1);
500         }
501
502         ((uint32_t *)a_page)[0x30/4] = 0x01060015;
503         //((uint32_t *)a_page)[0x30/4] = 0xDEADBEEF;
504
505         while ((c = getopt_long(argc, argv, "dvm:M:S:c:gsf:k:n:hR:", long_options,
506                                 &option_index)) != -1) {
507                 switch (c) {
508                 case 'd':
509                         debug++;
510                         break;
511                 case 'v':
512                         vmmflags |= VMM_VMCALL_PRINTF;
513                         break;
514                 case 'm':
515                         memsize = strtoull(optarg, 0, 0);
516                         break;
517                 case 'M':
518                         memstart = strtoull(optarg, 0, 0);
519                         break;
520                 case 'S':
521                         stack = strtoull(optarg, 0, 0);
522                         break;
523                 case 'R':
524                         maxresume = strtoull(optarg, 0, 0);
525                         break;
526                 case 'c':
527                         cmdline_extra = optarg;
528                 case 'g':       /* greedy */
529                         parlib_never_yield = TRUE;
530                         break;
531                 case 's':       /* scp */
532                         parlib_wants_to_be_mcp = FALSE;
533                         break;
534                 case 'f':       /* file to pass to blk_init */
535                         disk_image_file = optarg;
536                         break;
537                 case 'k':       /* specify file to get cmdline args from */
538                         cmdline_fd = open(optarg, O_RDONLY);
539                         if (cmdline_fd < 0) {
540                                 fprintf(stderr, "failed to open file: %s\n", optarg);
541                                 exit(1);
542                         }
543                         if (stat(optarg, &stat_result) == -1) {
544                                 fprintf(stderr, "stat of %s failed\n", optarg);
545                                 exit(1);
546                         }
547                         len = stat_result.st_size;
548                         if (len > 512) {
549                                 fprintf(stderr, "command line options exceed 512 bytes!");
550                                 exit(1);
551                         }
552                         num_read = read(cmdline_fd, cmdline_default, len);
553                         if (num_read != len) {
554                                 fprintf(stderr, "read failed len was : %d, num_read was: %d\n",
555                                         len, num_read);
556                                 exit(1);
557                         }
558                         close(cmdline_fd);
559                         break;
560                 case 'n':
561                         default_nic = strtoull(optarg, 0, 0);
562                         break;
563                 case 'h':
564                 default:
565                         // Sadly, the getopt_long struct does
566                         // not have a pointer to help text.
567                         for (int i = 0;
568                              i < sizeof(long_options)/sizeof(long_options[0]) - 1;
569                              i++) {
570                                 struct option *l = &long_options[i];
571
572                                 fprintf(stderr, "%s or %c%s\n", l->name, l->val,
573                                         l->has_arg ? " <arg>" : "");
574                         }
575                         exit(0);
576                 }
577         }
578         if (strlen(cmdline_default) == 0) {
579                 fprintf(stderr, "WARNING: No command line parameter file specified.\n");
580         }
581         argc -= optind;
582         argv += optind;
583         if (argc < 1) {
584                 fprintf(stderr, "Usage: %s vmimage [-n (no vmcall printf)]\n", argv[0]);
585                 exit(1);
586         }
587
588         if ((uintptr_t)(memstart + memsize) >= (uintptr_t)BRK_START) {
589                 fprintf(stderr,
590                         "memstart 0x%lx memsize 0x%lx -> 0x%lx is too large; overlaps BRK_START at %p\n",
591                         memstart, memsize, memstart + memsize, BRK_START);
592                 exit(1);
593         }
594
595         kernel = mmap((void *)memstart, memsize,
596                       PROT_READ | PROT_WRITE | PROT_EXEC,
597                       MAP_POPULATE | MAP_ANONYMOUS, -1, 0);
598         if (kernel != (void *)memstart) {
599                 fprintf(stderr, "Could not mmap 0x%lx bytes at 0x%lx\n",
600                         memsize, memstart);
601                 exit(1);
602         }
603
604         entry = load_kernel(argv[0], &kernstart, &kernend);
605         if (entry == 0) {
606                 fprintf(stderr, "Unable to load kernel %s\n", argv[0]);
607                 exit(1);
608         }
609
610
611         // The low 1m so we can fill in bullshit like ACPI. */
612         // And, sorry, due to the STUPID format of the RSDP for now we need the low 1M.
613         low1m = mmap((int*)4096, MiB-4096, PROT_READ | PROT_WRITE,
614                      MAP_ANONYMOUS, -1, 0);
615         if (low1m != (void *)4096) {
616                 perror("Unable to mmap low 1m");
617                 exit(1);
618         }
619         r = a;
620         fprintf(stderr, "install rsdp to %p\n", r);
621         *r = rsdp;
622         a += sizeof(*r);
623         r->xsdt_physical_address = (uint64_t)a;
624         gencsum(&r->checksum, r, ACPI_RSDP_CHECKSUM_LENGTH);
625         if ((csum = acpi_tb_checksum((uint8_t *) r, ACPI_RSDP_CHECKSUM_LENGTH)) != 0) {
626                 fprintf(stderr, "RSDP has bad checksum; summed to %x\n", csum);
627                 exit(1);
628         }
629
630         /* Check extended checksum if table version >= 2 */
631         gencsum(&r->extended_checksum, r, ACPI_RSDP_XCHECKSUM_LENGTH);
632         if ((rsdp.revision >= 2) &&
633             (acpi_tb_checksum((uint8_t *) r, ACPI_RSDP_XCHECKSUM_LENGTH) != 0)) {
634                 fprintf(stderr, "RSDP has bad checksum v2\n");
635                 exit(1);
636         }
637
638         /* just leave a bunch of space for the xsdt. */
639         /* we need to zero the area since it has pointers. */
640         x = a;
641         a += sizeof(*x) + 8*sizeof(void *);
642         memset(x, 0, a - (void *)x);
643         fprintf(stderr, "install xsdt to %p\n", x);
644         *x = xsdt;
645         x->table_offset_entry[0] = 0;
646         x->table_offset_entry[1] = 0;
647         x->header.length = a - (void *)x;
648
649         f = a;
650         fprintf(stderr, "install fadt to %p\n", f);
651         *f = fadt;
652         x->table_offset_entry[0] = (uint64_t)f; // fadt MUST be first in xsdt!
653         a += sizeof(*f);
654         f->header.length = a - (void *)f;
655
656         f->Xdsdt = (uint64_t) a;
657         fprintf(stderr, "install dsdt to %p\n", a);
658         memcpy(a, &DSDT_DSDTTBL_Header, 36);
659         a += 36;
660
661         gencsum(&f->header.checksum, f, f->header.length);
662         if (acpi_tb_checksum((uint8_t *)f, f->header.length) != 0) {
663                 fprintf(stderr, "fadt has bad checksum v2\n");
664                 exit(1);
665         }
666
667         m = a;
668         *m = madt;
669         x->table_offset_entry[3] = (uint64_t) m;
670         a += sizeof(*m);
671         fprintf(stderr, "install madt to %p\n", m);
672         memmove(a, &Apic0, sizeof(Apic0));
673         a += sizeof(Apic0);
674         memmove(a, &Apic1, sizeof(Apic1));
675         a += sizeof(Apic1);
676         memmove(a, &X2Apic0, sizeof(X2Apic0));
677         a += sizeof(X2Apic0);
678         memmove(a, &isor, sizeof(isor));
679         a += sizeof(isor);
680         m->header.length = a - (void *)m;
681
682         gencsum(&m->header.checksum, m, m->header.length);
683         if (acpi_tb_checksum((uint8_t *) m, m->header.length) != 0) {
684                 fprintf(stderr, "madt has bad checksum v2\n");
685                 exit(1);
686         }
687
688         gencsum(&x->header.checksum, x, x->header.length);
689         if ((csum = acpi_tb_checksum((uint8_t *) x, x->header.length)) != 0) {
690                 fprintf(stderr, "XSDT has bad checksum; summed to %x\n", csum);
691                 exit(1);
692         }
693
694         fprintf(stderr, "allchecksums ok\n");
695
696         hexdump(stdout, r, a-(void *)r);
697
698         a = (void *)(((unsigned long)a + 0xfff) & ~0xfff);
699         gpci.posted_irq_desc = a;
700         memset(a, 0, 4096);
701         a += 4096;
702         gpci.vapic_addr = a;
703         memset(a, 0, 4096);
704         ((uint32_t *)a)[0x30/4] = 0x01060014;
705         // set up apic values? do we need to?
706         // qemu does this.
707         //((uint8_t *)a)[4] = 1;
708         a += 4096;
709         gpci.apic_addr = (void*)0xfee00000;
710
711         /* Allocate memory for, and zero the bootparams
712          * page before writing to it, or Linux thinks
713          * we're talking crazy.
714          */
715         a += 4096;
716         bp = a;
717         memset(bp, 0, 4096);
718
719         /* Put the e820 memory region information in the boot_params */
720         bp->e820_entries = 5;
721         int e820i = 0;
722
723         /* Give it just a tiny bit of memory -- 60k -- at low memory. */
724         bp->e820_map[e820i].addr = 0;
725         bp->e820_map[e820i].size = 4 * 1024;
726         bp->e820_map[e820i++].type = E820_RESERVED;
727
728         bp->e820_map[e820i].addr = 4 * 1024;
729         bp->e820_map[e820i].size = 64 * 1024 - 4 * 1024;
730         bp->e820_map[e820i++].type = E820_RAM;
731
732         bp->e820_map[e820i].addr = 64 * 1024;
733         bp->e820_map[e820i].size = memstart - 64 * 1024;
734         bp->e820_map[e820i++].type = E820_RESERVED;
735
736         bp->e820_map[e820i].addr = memstart;
737         bp->e820_map[e820i].size = memsize;
738         bp->e820_map[e820i++].type = E820_RAM;
739
740         bp->e820_map[e820i].addr = 0xf0000000;
741         bp->e820_map[e820i].size = 0x10000000;
742         bp->e820_map[e820i++].type = E820_RESERVED;
743
744         /* The MMIO address of the console device is really the address of an
745          * unbacked EPT page: accesses to this page will cause a page fault that
746          * traps to the host, which will examine the fault, see it was for the
747          * known MMIO address, and fulfill the MMIO read or write on the guest's
748          * behalf accordingly. We place the virtio space at 512 GB higher than the
749          * guest physical memory to avoid a full page table walk. */
750         uint64_t virtio_mmio_base_addr = ROUNDUP((bp->e820_map[e820i - 1].addr +
751                                                   bp->e820_map[e820i - 1].size),
752                                                  512 * GiB);
753
754         cons_mmio_dev.addr =
755                 virtio_mmio_base_addr + PGSIZE * VIRTIO_MMIO_CONSOLE_DEV;
756         cons_mmio_dev.vqdev = &cons_vqdev;
757         vm->virtio_mmio_devices[VIRTIO_MMIO_CONSOLE_DEV] = &cons_mmio_dev;
758
759         net_mmio_dev.addr =
760                 virtio_mmio_base_addr + PGSIZE * VIRTIO_MMIO_NETWORK_DEV;
761         net_mmio_dev.vqdev = &net_vqdev;
762         vm->virtio_mmio_devices[VIRTIO_MMIO_NETWORK_DEV] = &net_mmio_dev;
763
764         if (disk_image_file != NULL) {
765                 blk_mmio_dev.addr =
766                         virtio_mmio_base_addr + PGSIZE * VIRTIO_MMIO_BLOCK_DEV;
767                 blk_mmio_dev.vqdev = &blk_vqdev;
768                 vm->virtio_mmio_devices[VIRTIO_MMIO_BLOCK_DEV] = &blk_mmio_dev;
769                 blk_init_fn(&blk_vqdev, disk_image_file);
770         }
771         net_init_fn(&net_vqdev, default_nic);
772
773         /* Set the kernel command line parameters */
774         a += 4096;
775         cmdline = a;
776         a += 4096;
777         bp->hdr.cmd_line_ptr = (uintptr_t) cmdline;
778
779         tsc_freq_khz = get_tsc_freq()/1000;
780         len = snprintf(cmdline, 4096, "%s tscfreq=%lld %s", cmdline_default,
781                        tsc_freq_khz, cmdline_extra);
782
783         cmdlinesz = 4096 - len;
784         cmdlinep = cmdline + len;
785
786         for (int i = 0; i < VIRTIO_MMIO_MAX_NUM_DEV; i++) {
787                 if (vm->virtio_mmio_devices[i] == NULL)
788                         continue;
789
790                 /* Append all the virtio mmio base addresses. */
791
792                 /* Since the lower number irqs are no longer being used, the irqs
793                  * can now be assigned starting from 0.
794                  */
795                 vm->virtio_mmio_devices[i]->irq = i;
796                 len = snprintf(cmdlinep, cmdlinesz,
797                                " virtio_mmio.device=1K@0x%llx:%lld",
798                                vm->virtio_mmio_devices[i]->addr,
799                                vm->virtio_mmio_devices[i]->irq);
800                 if (len >= cmdlinesz) {
801                         fprintf(stderr, "Too many arguments to the linux command line.");
802                         exit(1);
803                 }
804                 cmdlinesz -= len;
805                 cmdlinep += len;
806         }
807
808         vm->nr_gpcs = 1;
809         vm->gpcis = &gpci;
810         ret = vmm_init(vm, vmmflags);
811         assert(!ret);
812
813         /* Allocate 3 pages for page table pages: a page of 512 GiB
814          * PTEs with only one entry filled to point to a page of 1 GiB
815          * PTEs; a page of 1 GiB PTEs with only one entry filled to
816          * point to a page of 2 MiB PTEs; and a page of 2 MiB PTEs,
817          * only a subset of which will be filled. */
818         ret = posix_memalign((void **)&p512, PGSIZE, 3 * PGSIZE);
819         if (ret) {
820                 perror("ptp alloc");
821                 exit(1);
822         }
823
824         /* Set up a 1:1 ("identity") page mapping from guest virtual
825          * to guest physical using the (host virtual)
826          * `kerneladdress`. This mapping is used for only a short
827          * time, until the guest sets up its own page tables. Be aware
828          * that the values stored in the table are physical addresses.
829          * This is subtle and mistakes are easily disguised due to the
830          * identity mapping, so take care when manipulating these
831          * mappings. */
832         p1 = &p512[NPTENTRIES];
833         p2m = &p512[2 * NPTENTRIES];
834
835         size = kernend - kernstart;
836         fprintf(stderr, "Map %p for %zu bytes\n", kernstart, size);
837         p512[PML4(kernstart)] = (uint64_t)p1 | PTE_KERN_RW;
838         p1[PML3(kernstart)] = (uint64_t)p2m | PTE_KERN_RW;
839         for (uintptr_t i = 0; i < size; i += PML2_PTE_REACH) {
840                 p2m[PML2(kernstart + i)] =
841                         (uint64_t)(kernstart + i) | PTE_KERN_RW | PTE_PS;
842         }
843
844         fprintf(stderr, "p512 %p p512[0] is 0x%lx p1 %p p1[0] is 0x%x\n", p512, p512[0], p1, p1[0]);
845
846         vmm_run_task(vm, timer_thread, 0);
847
848         vm_tf = gth_to_vmtf(vm->gths[0]);
849         vm_tf->tf_cr3 = (uint64_t) p512;
850         vm_tf->tf_rip = entry;
851         vm_tf->tf_rsp = stack;
852         vm_tf->tf_rsi = (uint64_t) bp;
853         start_guest_thread(vm->gths[0]);
854
855         uthread_sleep_forever();
856         return 0;
857 }