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