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