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