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 <ros/vmm.h>
  17 #include <vmm/virtio.h>
  18 #include <vmm/virtio_mmio.h>
  19 #include <vmm/virtio_ids.h>
  20
  21 /* this test will run the "kernel" in the negative address space. We hope. */
  22 int *mmap_blob;
  23 unsigned long long stack[1024];
  24 volatile int shared = 0;
  25 volatile int quit = 0;
  26 int mcp = 1;
  27
  28 #define MiB 0x100000u
  29 #define GiB (1u<<30)
  30 #define VIRTIOBASE (15*MiB)
  31 #define GKERNBASE (16*MiB)
  32 #define KERNSIZE (128*MiB+GKERNBASE)
  33 uint8_t _kernel[KERNSIZE];
  34
  35 unsigned long long *p512, *p1, *p2m;
  36
  37 pthread_t *my_threads;
  38 void **my_retvals;
  39 int nr_threads = 2;
  40 char *line, *consline, *outline;
  41 struct scatterlist iov[32];
  42 unsigned int inlen, outlen, conslen;
  43 /* unlike Linux, this shared struct is for both host and guest. */
  44 //      struct virtqueue *constoguest =
  45 //              vring_new_virtqueue(0, 512, 8192, 0, inpages, NULL, NULL, "test");
  46 volatile int gaveit = 0, gotitback = 0;
  47 struct virtqueue *guesttocons;
  48 struct scatterlist out[] = { {NULL, sizeof(outline)}, };
  49 struct scatterlist in[] = { {NULL, sizeof(line)}, };
  50
  51 static inline uint32_t read32(const volatile void *addr)
  52 {
  53         return *(const volatile uint32_t *)addr;
  54 }
  55
  56 static inline void write32(volatile void *addr, uint32_t value)
  57 {
  58         *(volatile uint32_t *)addr = value;
  59 }
  60
  61 void dumpvirtio_mmio(FILE *f, void *v)
  62 {
  63         fprintf(f, "VIRTIO_MMIO_MAGIC_VALUE: 0x%x\n", read32(v+VIRTIO_MMIO_MAGIC_VALUE));
  64         fprintf(f, "VIRTIO_MMIO_VERSION: 0x%x\n", read32(v+VIRTIO_MMIO_VERSION));
  65         fprintf(f, "VIRTIO_MMIO_DEVICE_ID: 0x%x\n", read32(v+VIRTIO_MMIO_DEVICE_ID));
  66         fprintf(f, "VIRTIO_MMIO_VENDOR_ID: 0x%x\n", read32(v+VIRTIO_MMIO_VENDOR_ID));
  67         fprintf(f, "VIRTIO_MMIO_DEVICE_FEATURES: 0x%x\n", read32(v+VIRTIO_MMIO_DEVICE_FEATURES));
  68         fprintf(f, "VIRTIO_MMIO_DEVICE_FEATURES_SEL: 0x%x\n", read32(v+VIRTIO_MMIO_DEVICE_FEATURES_SEL));
  69         fprintf(f, "VIRTIO_MMIO_DRIVER_FEATURES: 0x%x\n", read32(v+VIRTIO_MMIO_DRIVER_FEATURES));
  70         fprintf(f, "VIRTIO_MMIO_DRIVER_FEATURES_SEL: 0x%x\n", read32(v+VIRTIO_MMIO_DRIVER_FEATURES_SEL));
  71         fprintf(f, "VIRTIO_MMIO_GUEST_PAGE_SIZE: 0x%x\n", read32(v+VIRTIO_MMIO_GUEST_PAGE_SIZE));
  72         fprintf(f, "VIRTIO_MMIO_QUEUE_SEL: 0x%x\n", read32(v+VIRTIO_MMIO_QUEUE_SEL));
  73         fprintf(f, "VIRTIO_MMIO_QUEUE_NUM_MAX: 0x%x\n", read32(v+VIRTIO_MMIO_QUEUE_NUM_MAX));
  74         fprintf(f, "VIRTIO_MMIO_QUEUE_NUM: 0x%x\n", read32(v+VIRTIO_MMIO_QUEUE_NUM));
  75         fprintf(f, "VIRTIO_MMIO_QUEUE_ALIGN: 0x%x\n", read32(v+VIRTIO_MMIO_QUEUE_ALIGN));
  76         fprintf(f, "VIRTIO_MMIO_QUEUE_PFN: 0x%x\n", read32(v+VIRTIO_MMIO_QUEUE_PFN));
  77         fprintf(f, "VIRTIO_MMIO_QUEUE_READY: 0x%x\n", read32(v+VIRTIO_MMIO_QUEUE_READY));
  78         fprintf(f, "VIRTIO_MMIO_QUEUE_NOTIFY: 0x%x\n", read32(v+VIRTIO_MMIO_QUEUE_NOTIFY));
  79         fprintf(f, "VIRTIO_MMIO_INTERRUPT_STATUS: 0x%x\n", read32(v+VIRTIO_MMIO_INTERRUPT_STATUS));
  80         fprintf(f, "VIRTIO_MMIO_INTERRUPT_ACK: 0x%x\n", read32(v+VIRTIO_MMIO_INTERRUPT_ACK));
  81         fprintf(f, "VIRTIO_MMIO_STATUS: 0x%x\n", read32(v+VIRTIO_MMIO_STATUS));
  82         fprintf(f, "VIRTIO_MMIO_QUEUE_DESC_LOW: 0x%x\n", read32(v+VIRTIO_MMIO_QUEUE_DESC_LOW));
  83         fprintf(f, "VIRTIO_MMIO_QUEUE_DESC_HIGH: 0x%x\n", read32(v+VIRTIO_MMIO_QUEUE_DESC_HIGH));
  84         fprintf(f, "VIRTIO_MMIO_QUEUE_AVAIL_LOW: 0x%x\n", read32(v+VIRTIO_MMIO_QUEUE_AVAIL_LOW));
  85         fprintf(f, "VIRTIO_MMIO_QUEUE_AVAIL_HIGH: 0x%x\n", read32(v+VIRTIO_MMIO_QUEUE_AVAIL_HIGH));
  86         fprintf(f, "VIRTIO_MMIO_QUEUE_USED_LOW: 0x%x\n", read32(v+VIRTIO_MMIO_QUEUE_USED_LOW));
  87         fprintf(f, "VIRTIO_MMIO_QUEUE_USED_HIGH: 0x%x\n", read32(v+VIRTIO_MMIO_QUEUE_USED_HIGH));
  88         fprintf(f, "VIRTIO_MMIO_CONFIG_GENERATION: 0x%x\n", read32(v+VIRTIO_MMIO_CONFIG_GENERATION));
  89 }
  90 static void setupconsole(void *v)
  91 {
  92         // try to make linux happy.
  93         // this is not really endian safe but ... well ... WE'RE ON THE SAME MACHINE
  94         write32(v+VIRTIO_MMIO_MAGIC_VALUE, ('v' | 'i' << 8 | 'r' << 16 | 't' << 24));
  95         // no constant for this is defined anywhere. It's just 1.
  96         write32(v+VIRTIO_MMIO_VERSION, 1);
  97         write32(v+VIRTIO_MMIO_DEVICE_ID, VIRTIO_ID_CONSOLE);
  98         write32(v+VIRTIO_MMIO_QUEUE_NUM_MAX, 1);
  99         write32(v+VIRTIO_MMIO_QUEUE_PFN, 0);
 100 }
 101
 102 int debug = 1;
 103
 104 struct ttargs {
 105         void *virtio;
 106 };
 107
 108 void *talk_thread(void *arg)
 109 {
 110         struct ttargs *a = arg;
 111         void *v = a->virtio;
 112         fprintf(stderr, "talk thread ..\n");
 113         uint16_t head;
 114         uint32_t vv;
 115         int i;
 116         int num;
 117         return;
 118         printf("Sleep 15 seconds\n");
 119         uthread_sleep(15);
 120         printf("----------------------- TT a %p\n", a);
 121         printf("talk thread ttargs %x v %x\n", a, v);
 122
 123         if (debug) printf("Spin on console being read, print num queues, halt\n");
 124         while ((vv = read32(v+VIRTIO_MMIO_DRIVER_FEATURES)) == 0) {
 125                 printf("no ready ... \n");
 126                 if (debug) {
 127                         dumpvirtio_mmio(stdout, v);
 128                 }
 129                 printf("sleep 1 second\n");
 130                 uthread_sleep(1);
 131         }
 132         if (debug)printf("vv %x, set selector %x\n", vv, read32(v + VIRTIO_MMIO_DRIVER_FEATURES_SEL));
 133         if (debug) printf("loop forever");
 134         while (! quit)
 135                 ;
 136         for(num = 0;;num++) {
 137                 /* host: use any buffers we should have been sent. */
 138                 head = wait_for_vq_desc(guesttocons, iov, &outlen, &inlen);
 139                 if (debug)
 140                         printf("vq desc head %d, gaveit %d gotitback %d\n", head, gaveit, gotitback);
 141                 for(i = 0; debug && i < outlen + inlen; i++)
 142                         printf("v[%d/%d] v %p len %d\n", i, outlen + inlen, iov[i].v, iov[i].length);
 143                 /* host: if we got an output buffer, just output it. */
 144                 for(i = 0; i < outlen; i++) {
 145                         num++;
 146                         printf("Host:%s:\n", (char *)iov[i].v);
 147                 }
 148
 149                 if (debug)
 150                         printf("outlen is %d; inlen is %d\n", outlen, inlen);
 151                 /* host: fill in the writeable buffers. */
 152                 for (i = outlen; i < outlen + inlen; i++) {
 153                         /* host: read a line. */
 154                         memset(consline, 0, 128);
 155                         if (1) {
 156                                 if (fgets(consline, 4096-256, stdin) == NULL) {
 157                                         exit(0);
 158                                 }
 159                                 if (debug) printf("GOT A LINE:%s:\n", consline);
 160                         } else {
 161                                 sprintf(consline, "hi there. %d\n", i);
 162                         }
 163                         memmove(iov[i].v, consline, strlen(consline)+ 1);
 164                         iov[i].length = strlen(consline) + 1;
 165                 }
 166                 if (debug) printf("call add_used\n");
 167                 /* host: now ack that we used them all. */
 168                 add_used(guesttocons, head, outlen+inlen);
 169                 if (debug) printf("DONE call add_used\n");
 170         }
 171         fprintf(stderr, "All done\n");
 172         return NULL;
 173 }
 174
 175 struct ttargs t;
 176
 177
 178 int main(int argc, char **argv)
 179 {
 180         struct vmctl vmctl;
 181         int amt;
 182         int vmmflags = VMM_VMCALL_PRINTF;
 183         uint64_t entry = 0x1000000, kerneladdress = 0x1000000;
 184         int nr_gpcs = 1;
 185         int fd = open("#c/vmctl", O_RDWR), ret;
 186         void * x;
 187         int kfd = -1;
 188         static char cmd[512];
 189         void *coreboot_tables = (void *) 0x1165000;
 190         /* kernel has to be in the range VIRTIOBASE to KERNSIZE+GKERNBASE for now. */
 191         // mmap is not working for us at present.
 192         if ((uint64_t)_kernel > VIRTIOBASE) {
 193                 printf("kernel array @%p is above , VIRTIOBASE@%p sucks\n", _kernel, VIRTIOBASE);
 194                 exit(1);
 195         }
 196         memset(_kernel, 0, sizeof(_kernel));
 197
 198         if (fd < 0) {
 199                 perror("#cons/sysctl");
 200                 exit(1);
 201         }
 202         argc--,argv++;
 203         // switches ...
 204         // Sorry, I don't much like the gnu opt parsing code.
 205         while (1) {
 206                 if (*argv[0] != '-')
 207                         break;
 208                 switch(argv[0][1]) {
 209                 case 'n':
 210                         vmmflags &= ~VMM_VMCALL_PRINTF;
 211                         break;
 212                 default:
 213                         printf("BMAFR\n");
 214                         break;
 215                 }
 216                 argc--,argv++;
 217         }
 218         if (argc < 1) {
 219                 fprintf(stderr, "Usage: %s vmimage [-n (no vmcall printf)] [coreboot_tables [loadaddress [entrypoint]]]\n", argv[0]);
 220                 exit(1);
 221         }
 222         if (argc > 1)
 223                 coreboot_tables = (void *) strtoull(argv[1], 0, 0);
 224         if (argc > 2)
 225                 kerneladdress = strtoull(argv[2], 0, 0);
 226         if (argc > 3)
 227                 entry = strtoull(argv[3], 0, 0);
 228         kfd = open(argv[0], O_RDONLY);
 229         if (kfd < 0) {
 230                 perror(argv[0]);
 231                 exit(1);
 232         }
 233         // read in the kernel.
 234         x = (void *)kerneladdress;
 235         for(;;) {
 236                 amt = read(kfd, x, 1048576);
 237                 if (amt < 0) {
 238                         perror("read");
 239                         exit(1);
 240                 }
 241                 if (amt == 0) {
 242                         break;
 243                 }
 244                 x += amt;
 245         }
 246         fprintf(stderr, "Read in %d bytes\n", x-kerneladdress);
 247
 248         fprintf(stderr, "Run with %d cores and vmmflags 0x%x\n", nr_gpcs, vmmflags);
 249         if (ros_syscall(SYS_setup_vmm, nr_gpcs, vmmflags, 0, 0, 0, 0) != nr_gpcs) {
 250                 perror("Guest pcore setup failed");
 251                 exit(1);
 252         }
 253         /* blob that is faulted in from the EPT first.  we need this to be in low
 254          * memory (not above the normal mmap_break), so the EPT can look it up.
 255          * Note that we won't get 4096.  The min is 1MB now, and ld is there. */
 256         mmap_blob = mmap((int*)4096, PGSIZE, PROT_READ | PROT_WRITE,
 257                          MAP_ANONYMOUS, -1, 0);
 258         if (mmap_blob == MAP_FAILED) {
 259                 perror("Unable to mmap");
 260                 exit(1);
 261         }
 262
 263         mcp = 1;
 264         if (mcp) {
 265                 my_threads = malloc(sizeof(pthread_t) * nr_threads);
 266                 my_retvals = malloc(sizeof(void*) * nr_threads);
 267                 if (!(my_retvals && my_threads))
 268                         perror("Init threads/malloc");
 269
 270                 pthread_can_vcore_request(FALSE);       /* 2LS won't manage vcores */
 271                 pthread_need_tls(FALSE);
 272                 pthread_mcp_init();                                     /* gives us one vcore */
 273                 vcore_request(nr_threads - 1);          /* ghetto incremental interface */
 274                 for (int i = 0; i < nr_threads; i++) {
 275                         x = __procinfo.vcoremap;
 276                         printf("%p\n", __procinfo.vcoremap);
 277                         printf("Vcore %d mapped to pcore %d\n", i,
 278                                 __procinfo.vcoremap[i].pcoreid);
 279                 }
 280         }
 281
 282         t.virtio = (void *)VIRTIOBASE;
 283
 284         ret = syscall(33, 1);
 285         if (ret < 0) {
 286                 perror("vm setup");
 287                 exit(1);
 288         }
 289         ret = posix_memalign((void **)&p512, 4096, 3*4096);
 290         printf("memalign is %p\n", p512);
 291         if (ret) {
 292                 perror("ptp alloc");
 293                 exit(1);
 294         }
 295         p1 = &p512[512];
 296         p2m = &p512[1024];
 297         uint64_t kernbase = 0; //0xffffffff80000000;
 298         uint64_t highkernbase = 0xffffffff80000000;
 299         p512[PML4(kernbase)] = (unsigned long long)p1 | 7;
 300         p1[PML3(kernbase)] = /*0x87; */(unsigned long long)p2m | 7;
 301         p512[PML4(highkernbase)] = (unsigned long long)p1 | 7;
 302         p1[PML3(highkernbase)] = /*0x87; */(unsigned long long)p2m | 7;
 303 #define _2MiB (0x200000)
 304         int i;
 305         for (i = 0; i < 512; i++) {
 306                 p2m[PML2(kernbase + i * _2MiB)] = 0x87 | i * _2MiB;
 307         }
 308
 309         kernbase >>= (0+12);
 310         kernbase <<= (0 + 12);
 311         uint8_t *kernel = (void *)GKERNBASE;
 312         write_coreboot_table(coreboot_tables, ((void *)VIRTIOBASE) /*kernel*/, KERNSIZE + 1048576);
 313         hexdump(stdout, coreboot_tables, 512);
 314         setupconsole((void *)VIRTIOBASE);
 315         hexdump(stdout, (void *)VIRTIOBASE, 128);
 316         printf("kernbase for pml4 is 0x%llx and entry is %llx\n", kernbase, entry);
 317         printf("p512 %p p512[0] is 0x%lx p1 %p p1[0] is 0x%x\n", p512, p512[0], p1, p1[0]);
 318         vmctl.command = REG_RSP_RIP_CR3;
 319         vmctl.cr3 = (uint64_t) p512;
 320         vmctl.regs.tf_rip = entry;
 321         vmctl.regs.tf_rsp = (uint64_t) &stack[1024];
 322         if (mcp) {
 323                 if (pthread_create(&my_threads[0], NULL, &talk_thread, &t))
 324                         perror("pth_create failed");
 325         }
 326         printf("threads started\n");
 327         printf("Writing command :%s:\n", cmd);
 328         // sys_getpcoreid
 329         ret = write(fd, &vmctl, sizeof(vmctl));
 330         if (ret != sizeof(vmctl)) {
 331                 perror(cmd);
 332         }
 333         vmctl.command = RESUME;
 334         while (1) {
 335                 int c;
 336                 printf("RESUME?\n");
 337                 c = getchar();
 338                 if (c == 'q')
 339                         break;
 340                 ret = write(fd, &vmctl, sizeof(vmctl));
 341                 if (ret != sizeof(vmctl)) {
 342                         perror(cmd);
 343                 }
 344                 printf("RIP %p\n", vmctl.regs.tf_rip);
 345         }
 346         dumpvirtio_mmio(stdout, (void *)VIRTIOBASE);
 347         printf("shared is %d, blob is %d\n", shared, *mmap_blob);
 348
 349         quit = 1;
 350         for (int i = 0; i < nr_threads-1; i++) {
 351                 int ret;
 352                 if (pthread_join(my_threads[i], &my_retvals[i]))
 353                         perror("pth_join failed");
 354                 printf("%d %d\n", i, ret);
 355         }
 356
 357         return 0;
 358 }