sys/platform/vkernel/platform/init.c

   1 /*
   2  * Copyright (c) 2006 The DragonFly Project.  All rights reserved.
   3  *
   4  * This code is derived from software contributed to The DragonFly Project
   5  * by Matthew Dillon <dillon@backplane.com>
   6  *
   7  * Redistribution and use in source and binary forms, with or without
   8  * modification, are permitted provided that the following conditions
   9  * are met:
  10  *
  11  * 1. Redistributions of source code must retain the above copyright
  12  *    notice, this list of conditions and the following disclaimer.
  13  * 2. Redistributions in binary form must reproduce the above copyright
  14  *    notice, this list of conditions and the following disclaimer in
  15  *    the documentation and/or other materials provided with the
  16  *    distribution.
  17  * 3. Neither the name of The DragonFly Project nor the names of its
  18  *    contributors may be used to endorse or promote products derived
  19  *    from this software without specific, prior written permission.
  20  *
  21  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  22  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  23  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
  24  * FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE
  25  * COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
  26  * INCIDENTAL, SPECIAL, EXEMPLARY OR CONSEQUENTIAL DAMAGES (INCLUDING,
  27  * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  28  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
  29  * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
  30  * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
  31  * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  32  * SUCH DAMAGE.
  33  *
  34  * $DragonFly: src/sys/platform/vkernel/platform/init.c,v 1.14 2007/01/08 03:33:43 dillon Exp $
  35  */
  36
  37 #include <sys/types.h>
  38 #include <sys/systm.h>
  39 #include <sys/kernel.h>
  40 #include <sys/stat.h>
  41 #include <sys/mman.h>
  42 #include <sys/cons.h>
  43 #include <sys/random.h>
  44 #include <sys/vkernel.h>
  45 #include <sys/tls.h>
  46 #include <sys/proc.h>
  47 #include <sys/msgbuf.h>
  48 #include <sys/vmspace.h>
  49 #include <vm/vm_page.h>
  50
  51 #include <machine/globaldata.h>
  52 #include <machine/tls.h>
  53 #include <machine/md_var.h>
  54 #include <machine/vmparam.h>
  55
  56 #include <stdio.h>
  57 #include <stdlib.h>
  58 #include <unistd.h>
  59 #include <fcntl.h>
  60 #include <string.h>
  61 #include <err.h>
  62 #include <errno.h>
  63 #include <assert.h>
  64
  65 vm_paddr_t phys_avail[16];
  66 vm_paddr_t Maxmem;
  67 vm_paddr_t Maxmem_bytes;
  68 int MemImageFd = -1;
  69 int RootImageFd = -1;
  70 vm_offset_t KvaStart;
  71 vm_offset_t KvaEnd;
  72 vm_offset_t KvaSize;
  73 vm_offset_t virtual_start;
  74 vm_offset_t virtual_end;
  75 vm_offset_t kernel_vm_end;
  76 vm_offset_t crashdumpmap;
  77 vm_offset_t clean_sva;
  78 vm_offset_t clean_eva;
  79 struct msgbuf *msgbufp;
  80 caddr_t ptvmmap;
  81 vpte_t  *KernelPTD;
  82 vpte_t  *KernelPTA;     /* Warning: Offset for direct VA translation */
  83 u_int cpu_feature;      /* XXX */
  84 u_int tsc_present;      /* XXX */
  85
  86 struct privatespace *CPU_prvspace;
  87
  88 static struct trapframe proc0_tf;
  89 static void *proc0paddr;
  90
  91 static void init_sys_memory(char *imageFile);
  92 static void init_kern_memory(void);
  93 static void init_globaldata(void);
  94 static void init_vkernel(void);
  95 static void init_rootdevice(char *imageFile);
  96 static void usage(const char *ctl);
  97
  98 /*
  99  * Kernel startup for virtual kernels - standard main()
 100  */
 101 int
 102 main(int ac, char **av)
 103 {
 104         char *memImageFile = NULL;
 105         char *rootImageFile = NULL;
 106         char *suffix;
 107         int c;
 108
 109         /*
 110          * Process options
 111          */
 112         while ((c = getopt(ac, av, "vm:r:")) != -1) {
 113                 switch(c) {
 114                 case 'v':
 115                         bootverbose = 1;
 116                         break;
 117                 case 'i':
 118                         memImageFile = optarg;
 119                         break;
 120                 case 'r':
 121                         rootImageFile = optarg;
 122                         break;
 123                 case 'm':
 124                         Maxmem_bytes = strtoull(optarg, &suffix, 0);
 125                         if (suffix) {
 126                                 switch(*suffix) {
 127                                 case 'g':
 128                                 case 'G':
 129                                         Maxmem_bytes <<= 30;
 130                                         break;
 131                                 case 'm':
 132                                 case 'M':
 133                                         Maxmem_bytes <<= 20;
 134                                         break;
 135                                 case 'k':
 136                                 case 'K':
 137                                         Maxmem_bytes <<= 10;
 138                                         break;
 139                                 default:
 140                                         Maxmem_bytes = 0;
 141                                         usage("Bad maxmem option");
 142                                         /* NOT REACHED */
 143                                         break;
 144                                 }
 145                         }
 146                         break;
 147                 }
 148         }
 149
 150         init_sys_memory(memImageFile);
 151         init_kern_memory();
 152         init_globaldata();
 153         init_vkernel();
 154         init_rootdevice(rootImageFile);
 155         init_exceptions();
 156         mi_startup();
 157         /* NOT REACHED */
 158         exit(1);
 159 }
 160
 161 /*
 162  * Initialize system memory.  This is the virtual kernel's 'RAM'.
 163  */
 164 static
 165 void
 166 init_sys_memory(char *imageFile)
 167 {
 168         struct stat st;
 169         int i;
 170         int fd;
 171
 172         /*
 173          * Figure out the system memory image size.  If an image file was
 174          * specified and -m was not specified, use the image file's size.
 175          */
 176
 177         if (imageFile && stat(imageFile, &st) == 0 && Maxmem_bytes == 0)
 178                 Maxmem_bytes = (vm_paddr_t)st.st_size;
 179         if ((imageFile == NULL || stat(imageFile, &st) < 0) &&
 180             Maxmem_bytes == 0) {
 181                 err(1, "Cannot create new memory file %s unless "
 182                        "system memory size is specified with -m",
 183                        imageFile);
 184                 /* NOT REACHED */
 185         }
 186
 187         /*
 188          * Maxmem must be known at this time
 189          */
 190         if (Maxmem_bytes < 32 * 1024 * 1024 || (Maxmem_bytes & SEG_MASK)) {
 191                 err(1, "Bad maxmem specification: 32MB minimum, "
 192                        "multiples of %dMB only",
 193                        SEG_SIZE / 1024 / 1024);
 194                 /* NOT REACHED */
 195         }
 196
 197         /*
 198          * Generate an image file name if necessary, then open/create the
 199          * file exclusively locked.  Do not allow multiple virtual kernels
 200          * to use the same image file.
 201          */
 202         if (imageFile == NULL) {
 203                 for (i = 0; i < 1000000; ++i) {
 204                         asprintf(&imageFile, "/var/vkernel/memimg.%06d", i);
 205                         fd = open(imageFile,
 206                                   O_RDWR|O_CREAT|O_EXLOCK|O_NONBLOCK, 0644);
 207                         if (fd < 0 && errno == EWOULDBLOCK) {
 208                                 free(imageFile);
 209                                 continue;
 210                         }
 211                         break;
 212                 }
 213         } else {
 214                 fd = open(imageFile, O_RDWR|O_CREAT|O_EXLOCK|O_NONBLOCK, 0644);
 215         }
 216         printf("Using memory file: %s\n", imageFile);
 217         if (fd < 0 || fstat(fd, &st) < 0) {
 218                 err(1, "Unable to open/create %s: %s",
 219                       imageFile, strerror(errno));
 220                 /* NOT REACHED */
 221         }
 222
 223         /*
 224          * Truncate or extend the file as necessary.
 225          */
 226         if (st.st_size > Maxmem_bytes) {
 227                 ftruncate(fd, Maxmem_bytes);
 228         } else if (st.st_size < Maxmem_bytes) {
 229                 char *zmem;
 230                 off_t off = st.st_size & ~SEG_MASK;
 231
 232                 kprintf("%s: Reserving blocks for memory image\n", imageFile);
 233                 zmem = malloc(SEG_SIZE);
 234                 bzero(zmem, SEG_SIZE);
 235                 lseek(fd, off, 0);
 236                 while (off < Maxmem_bytes) {
 237                         if (write(fd, zmem, SEG_SIZE) != SEG_SIZE) {
 238                                 err(1, "Unable to reserve blocks for memory image");
 239                                 /* NOT REACHED */
 240                         }
 241                         off += SEG_SIZE;
 242                 }
 243                 if (fsync(fd) < 0)
 244                         err(1, "Unable to reserve blocks for memory image");
 245                 free(zmem);
 246         }
 247         MemImageFd = fd;
 248         Maxmem = Maxmem_bytes >> PAGE_SHIFT;
 249 }
 250
 251 /*
 252  * Initialize kernel memory.  This reserves kernel virtual memory by using
 253  * MAP_VPAGETABLE
 254  */
 255 static
 256 void
 257 init_kern_memory(void)
 258 {
 259         void *base;
 260         char *zero;
 261         vpte_t pte;
 262         int i;
 263
 264         /*
 265          * Memory map our kernel virtual memory space.  Note that the
 266          * kernel image itself is not made part of this memory for the
 267          * moment.
 268          *
 269          * The memory map must be segment-aligned so we can properly
 270          * offset KernelPTD.
 271          */
 272         base = mmap((void *)0x40000000, KERNEL_KVA_SIZE, PROT_READ|PROT_WRITE,
 273                     MAP_FILE|MAP_SHARED|MAP_VPAGETABLE, MemImageFd, 0);
 274         if (base == MAP_FAILED) {
 275                 err(1, "Unable to mmap() kernel virtual memory!");
 276                 /* NOT REACHED */
 277         }
 278         KvaStart = (vm_offset_t)base;
 279         KvaSize = KERNEL_KVA_SIZE;
 280         KvaEnd = KvaStart + KvaSize;
 281
 282         /*
 283          * Create a top-level page table self-mapping itself.
 284          *
 285          * Initialize the page directory at physical page index 0 to point
 286          * to an array of page table pages starting at physical page index 1
 287          */
 288         lseek(MemImageFd, 0L, 0);
 289         for (i = 0; i < KERNEL_KVA_SIZE / SEG_SIZE; ++i) {
 290                 pte = ((i + 1) * PAGE_SIZE) | VPTE_V | VPTE_R | VPTE_W;
 291                 write(MemImageFd, &pte, sizeof(pte));
 292         }
 293
 294         /*
 295          * Initialize the PTEs in the page table pages required to map the
 296          * page table itself.  This includes mapping the page directory page
 297          * at the base so we go one more loop then normal.
 298          */
 299         lseek(MemImageFd, PAGE_SIZE, 0);
 300         for (i = 0; i <= KERNEL_KVA_SIZE / SEG_SIZE * sizeof(vpte_t); ++i) {
 301                 pte = (i * PAGE_SIZE) | VPTE_V | VPTE_R | VPTE_W;
 302                 write(MemImageFd, &pte, sizeof(pte));
 303         }
 304
 305         /*
 306          * Initialize remaining PTEs to 0.  We may be reusing a memory image
 307          * file.  This is approximately a megabyte.
 308          */
 309         i = (KERNEL_KVA_SIZE / PAGE_SIZE - i) * sizeof(pte);
 310         zero = malloc(PAGE_SIZE);
 311         while (i) {
 312                 write(MemImageFd, zero, (i > PAGE_SIZE) ? PAGE_SIZE : i);
 313                 i = i - ((i > PAGE_SIZE) ? PAGE_SIZE : i);
 314         }
 315         free(zero);
 316
 317         /*
 318          * Enable the page table and calculate pointers to our self-map
 319          * for easy kernel page table manipulation.
 320          *
 321          * KernelPTA must be offset so we can do direct VA translations
 322          */
 323         mcontrol(base, KERNEL_KVA_SIZE, MADV_SETMAP,
 324                  0 | VPTE_R | VPTE_W | VPTE_V);
 325         KernelPTD = (vpte_t *)base;                       /* pg directory */
 326         KernelPTA = (vpte_t *)((char *)base + PAGE_SIZE); /* pg table pages */
 327         KernelPTA -= KvaStart >> PAGE_SHIFT;
 328
 329         /*
 330          * phys_avail[] represents unallocated physical memory.  MI code
 331          * will use phys_avail[] to create the vm_page array.
 332          */
 333         phys_avail[0] = PAGE_SIZE +
 334                         KERNEL_KVA_SIZE / PAGE_SIZE * sizeof(vpte_t);
 335         phys_avail[0] = (phys_avail[0] + PAGE_MASK) & ~(vm_paddr_t)PAGE_MASK;
 336         phys_avail[1] = Maxmem_bytes;
 337
 338         /*
 339          * (virtual_start, virtual_end) represent unallocated kernel virtual
 340          * memory.  MI code will create kernel_map using these parameters.
 341          */
 342         virtual_start = KvaStart + PAGE_SIZE +
 343                         KERNEL_KVA_SIZE / PAGE_SIZE * sizeof(vpte_t);
 344         virtual_start = (virtual_start + PAGE_MASK) & ~(vm_offset_t)PAGE_MASK;
 345         virtual_end = KvaStart + KERNEL_KVA_SIZE;
 346
 347         /*
 348          * Because we just pre-allocate the entire page table the demark used
 349          * to determine when KVM must be grown is just set to the end of
 350          * KVM.  pmap_growkernel() simply panics.
 351          */
 352         kernel_vm_end = virtual_end;
 353
 354         /*
 355          * Allocate space for process 0's UAREA.
 356          */
 357         proc0paddr = (void *)virtual_start;
 358         for (i = 0; i < UPAGES; ++i) {
 359                 pmap_kenter_quick(virtual_start, phys_avail[0]);
 360                 virtual_start += PAGE_SIZE;
 361                 phys_avail[0] += PAGE_SIZE;
 362         }
 363
 364         /*
 365          * crashdumpmap
 366          */
 367         crashdumpmap = virtual_start;
 368         virtual_start += MAXDUMPPGS * PAGE_SIZE;
 369
 370         /*
 371          * msgbufp maps the system message buffer
 372          */
 373         assert((MSGBUF_SIZE & PAGE_MASK) == 0);
 374         msgbufp = (void *)virtual_start;
 375         for (i = 0; i < (MSGBUF_SIZE >> PAGE_SHIFT); ++i) {
 376                 pmap_kenter_quick(virtual_start, phys_avail[0]);
 377                 virtual_start += PAGE_SIZE;
 378                 phys_avail[0] += PAGE_SIZE;
 379         }
 380         msgbufinit(msgbufp, MSGBUF_SIZE);
 381
 382         /*
 383          * used by kern_memio for /dev/mem access
 384          */
 385         ptvmmap = (caddr_t)virtual_start;
 386         virtual_start += PAGE_SIZE;
 387
 388         /*
 389          * Bootstrap the kernel_pmap
 390          */
 391         pmap_bootstrap();
 392 }
 393
 394 /*
 395  * Map the per-cpu globaldata for cpu #0.  Allocate the space using
 396  * virtual_start and phys_avail[0]
 397  */
 398 static
 399 void
 400 init_globaldata(void)
 401 {
 402         int i;
 403         vm_paddr_t pa;
 404         vm_offset_t va;
 405
 406         /*
 407          * Reserve enough KVA to cover possible cpus.  This is a considerable
 408          * amount of KVA since the privatespace structure includes two
 409          * whole page table mappings.
 410          */
 411         virtual_start = (virtual_start + SEG_MASK) & ~(vm_offset_t)SEG_MASK;
 412         CPU_prvspace = (void *)virtual_start;
 413         virtual_start += sizeof(struct privatespace) * SMP_MAXCPU;
 414
 415         /*
 416          * Allocate enough physical memory to cover the mdglobaldata
 417          * portion of the space and the idle stack and map the pages
 418          * into KVA.  For cpu #0 only.
 419          */
 420         for (i = 0; i < sizeof(struct mdglobaldata); i += PAGE_SIZE) {
 421                 pa = phys_avail[0];
 422                 va = (vm_offset_t)&CPU_prvspace[0].mdglobaldata + i;
 423                 pmap_kenter_quick(va, pa);
 424                 phys_avail[0] += PAGE_SIZE;
 425         }
 426         for (i = 0; i < sizeof(CPU_prvspace[0].idlestack); i += PAGE_SIZE) {
 427                 pa = phys_avail[0];
 428                 va = (vm_offset_t)&CPU_prvspace[0].idlestack + i;
 429                 pmap_kenter_quick(va, pa);
 430                 phys_avail[0] += PAGE_SIZE;
 431         }
 432
 433         /*
 434          * Setup the %gs for cpu #0.  The mycpu macro works after this
 435          * point.
 436          */
 437         tls_set_fs(&CPU_prvspace[0], sizeof(struct privatespace));
 438 }
 439
 440 /*
 441  * Initialize very low level systems including thread0, proc0, etc.
 442  */
 443 static
 444 void
 445 init_vkernel(void)
 446 {
 447         struct mdglobaldata *gd;
 448
 449         gd = &CPU_prvspace[0].mdglobaldata;
 450         bzero(gd, sizeof(*gd));
 451
 452         gd->mi.gd_curthread = &thread0;
 453         thread0.td_gd = &gd->mi;
 454         ncpus = 1;
 455         ncpus2 = 1;
 456         init_param1();
 457         gd->mi.gd_prvspace = &CPU_prvspace[0];
 458         mi_gdinit(&gd->mi, 0);
 459         cpu_gdinit(gd, 0);
 460         mi_proc0init(&gd->mi, proc0paddr);
 461         proc0.p_lwp.lwp_md.md_regs = &proc0_tf;
 462
 463         /*init_locks();*/
 464         cninit();
 465         rand_initialize();
 466 #if 0   /* #ifdef DDB */
 467         kdb_init();
 468         if (boothowto & RB_KDB)
 469                 Debugger("Boot flags requested debugger");
 470 #endif
 471 #if 0
 472         initializecpu();        /* Initialize CPU registers */
 473 #endif
 474         init_param2((phys_avail[1] - phys_avail[0]) / PAGE_SIZE);
 475
 476 #if 0
 477         /*
 478          * Map the message buffer
 479          */
 480         for (off = 0; off < round_page(MSGBUF_SIZE); off += PAGE_SIZE)
 481                 pmap_kenter((vm_offset_t)msgbufp + off, avail_end + off);
 482         msgbufinit(msgbufp, MSGBUF_SIZE);
 483 #endif
 484 #if 0
 485         thread0.td_pcb_cr3 ... MMU
 486         proc0.p_lwp.lwp_md.md_regs = &proc0_tf;
 487 #endif
 488 }
 489
 490 /*
 491  * The root filesystem path for the virtual kernel is optional.  If specified
 492  * it points to a filesystem image.
 493  */
 494 static
 495 void
 496 init_rootdevice(char *imageFile)
 497 {
 498         struct stat st;
 499
 500         if (imageFile) {
 501                 RootImageFd = open(imageFile, O_RDWR, 0644);
 502                 if (RootImageFd < 0 || fstat(RootImageFd, &st) < 0) {
 503                         err(1, "Unable to open/create %s: %s",
 504                             imageFile, strerror(errno));
 505                         /* NOT REACHED */
 506                 }
 507                 rootdevnames[0] = "ufs:vd0a";
 508         }
 509 }
 510
 511 static
 512 void
 513 usage(const char *ctl)
 514 {
 515
 516 }
 517
 518 void
 519 cpu_reset(void)
 520 {
 521         kprintf("cpu reset\n");
 522         exit(0);
 523 }
 524
 525 void
 526 cpu_halt(void)
 527 {
 528         kprintf("cpu halt\n");
 529         for (;;)
 530                 __asm__ __volatile("hlt");
 531 }