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