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