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