sys/arch/xen/x86/autoconf.c

   1 /*      $NetBSD: autoconf.c,v 1.12 2009/11/21 05:54:04 rmind Exp $      */
   2 /*      NetBSD: autoconf.c,v 1.75 2003/12/30 12:33:22 pk Exp    */
   3
   4 /*-
   5  * Copyright (c) 1990 The Regents of the University of California.
   6  * All rights reserved.
   7  *
   8  * This code is derived from software contributed to Berkeley by
   9  * William Jolitz.
  10  *
  11  * Redistribution and use in source and binary forms, with or without
  12  * modification, are permitted provided that the following conditions
  13  * are met:
  14  * 1. Redistributions of source code must retain the above copyright
  15  *    notice, this list of conditions and the following disclaimer.
  16  * 2. Redistributions in binary form must reproduce the above copyright
  17  *    notice, this list of conditions and the following disclaimer in the
  18  *    documentation and/or other materials provided with the distribution.
  19  * 3. Neither the name of the University nor the names of its contributors
  20  *    may be used to endorse or promote products derived from this software
  21  *    without specific prior written permission.
  22  *
  23  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  24  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  25  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  26  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  27  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  28  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  29  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  30  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  31  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  32  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  33  * SUCH DAMAGE.
  34  *
  35  *      @(#)autoconf.c  7.1 (Berkeley) 5/9/91
  36  */
  37
  38 /*
  39  * Setup the system to run on the current machine.
  40  *
  41  * Configure() is called at boot time and initializes the vba
  42  * device tables and the memory controller monitoring.  Available
  43  * devices are determined (from possibilities mentioned in ioconf.c),
  44  * and the drivers are initialized.
  45  */
  46
  47 #include <sys/cdefs.h>
  48 __KERNEL_RCSID(0, "$NetBSD: autoconf.c,v 1.12 2009/11/21 05:54:04 rmind Exp $");
  49
  50 #include "opt_xen.h"
  51 #include "opt_compat_oldboot.h"
  52 #include "opt_multiprocessor.h"
  53 #include "opt_nfs_boot.h"
  54
  55 #include <sys/param.h>
  56 #include <sys/systm.h>
  57 #include <sys/buf.h>
  58 #include <sys/disklabel.h>
  59 #include <sys/disk.h>
  60 #include <sys/conf.h>
  61 #ifdef COMPAT_OLDBOOT
  62 #include <sys/reboot.h>
  63 #endif
  64 #include <sys/device.h>
  65 #include <sys/vnode.h>
  66 #include <sys/fcntl.h>
  67 #include <sys/dkio.h>
  68 #include <sys/proc.h>
  69 #include <sys/kauth.h>
  70
  71 #ifdef NFS_BOOT_BOOTSTATIC
  72 #include <net/if.h>
  73 #include <net/if_ether.h>
  74 #include <netinet/in.h>
  75 #include <nfs/rpcv2.h>
  76 #include <nfs/nfsproto.h>
  77 #include <nfs/nfs.h>
  78 #include <nfs/nfsmount.h>
  79 #include <nfs/nfsdiskless.h>
  80 #include <xen/if_xennetvar.h>
  81 #endif
  82
  83 #include <machine/pte.h>
  84 #include <machine/cpu.h>
  85 #include <machine/gdt.h>
  86 #include <machine/pcb.h>
  87 #include <machine/bootinfo.h>
  88
  89 static void findroot(void);
  90 static int is_valid_disk(device_t);
  91 static void handle_wedges(device_t, int);
  92
  93 struct disklist *x86_alldisks;
  94 int x86_ndisks;
  95
  96 #include "bios32.h"
  97 #if NBIOS32 > 0
  98 #include <machine/bios32.h>
  99 #endif
 100
 101 #include "opt_pcibios.h"
 102 #ifdef PCIBIOS
 103 #include <dev/pci/pcireg.h>
 104 #include <dev/pci/pcivar.h>
 105 #include <i386/pci/pcibios.h>
 106 #endif
 107
 108 #include "opt_kvm86.h"
 109 #ifdef KVM86
 110 #include <machine/kvm86.h>
 111 #endif
 112
 113 /*
 114  * Determine i/o configuration for a machine.
 115  */
 116 void
 117 cpu_configure(void)
 118 {
 119         struct pcb *pcb;
 120
 121         startrtclock();
 122
 123 #if NBIOS32 > 0 && defined(DOM0OPS)
 124         if (xendomain_is_dom0())
 125                 bios32_init();
 126 #endif /* NBIOS32 > 0 && DOM0OPS */
 127 #ifdef PCIBIOS
 128         pcibios_init();
 129 #endif
 130
 131 #ifdef KVM86
 132         kvm86_init();
 133 #endif
 134
 135         if (config_rootfound("mainbus", NULL) == NULL)
 136                 panic("configure: mainbus not configured");
 137
 138 #ifdef INTRDEBUG
 139         intr_printconfig();
 140 #endif
 141
 142         /* resync cr0 after FPU configuration */
 143         pcb = lwp_getpcb(&lwp0);
 144         pcb->pcb_cr0 = rcr0();
 145 #ifdef MULTIPROCESSOR
 146         /* propagate this to the idle pcb's. */
 147         cpu_init_idle_lwps();
 148 #endif
 149
 150         spl0();
 151 }
 152
 153 void
 154 cpu_rootconf(void)
 155 {
 156         findroot();
 157
 158         if (booted_wedge) {
 159                 KASSERT(booted_device != NULL);
 160                 printf("boot device: %s (%s)\n",
 161                     device_xname(booted_wedge), device_xname(booted_device));
 162                 setroot(booted_wedge, 0);
 163         } else {
 164                 printf("boot device: %s\n",
 165                     booted_device ? device_xname(booted_device) : "<unknown>");
 166                 setroot(booted_device, booted_partition);
 167         }
 168 }
 169
 170
 171 /*
 172  * Attempt to find the device from which we were booted.
 173  * If we can do so, and not instructed not to do so,
 174  * change rootdev to correspond to the load device.
 175  */
 176 void
 177 findroot(void)
 178 {
 179         device_t dv;
 180         deviter_t di;
 181         union xen_cmdline_parseinfo xcp;
 182
 183         if (booted_device)
 184                 return;
 185
 186         xen_parse_cmdline(XEN_PARSE_BOOTDEV, &xcp);
 187
 188         for (dv = deviter_first(&di, DEVITER_F_ROOT_FIRST);
 189              dv != NULL;
 190              dv = deviter_next(&di)) {
 191                 bool is_ifnet, is_disk;
 192                 const char *devname;
 193
 194                 is_ifnet = (device_class(dv) == DV_IFNET);
 195                 is_disk = is_valid_disk(dv);
 196                 devname = device_xname(dv);
 197
 198                 if (!is_ifnet && !is_disk)
 199                         continue;
 200
 201                 if (is_disk && xcp.xcp_bootdev[0] == 0) {
 202                         handle_wedges(dv, 0);
 203                         break;
 204                 }
 205
 206                 if (strncmp(xcp.xcp_bootdev, devname, strlen(devname)))
 207                         continue;
 208
 209                 if (is_disk && strlen(xcp.xcp_bootdev) > strlen(devname)) {
 210                         booted_partition = toupper(
 211                                 xcp.xcp_bootdev[strlen(devname)]) - 'A';
 212                 }
 213
 214                 booted_device = dv;
 215                 break;
 216         }
 217         deviter_release(&di);
 218 }
 219
 220 #include "pci.h"
 221
 222 #include <dev/isa/isavar.h>
 223 #if NPCI > 0
 224 #include <dev/pci/pcivar.h>
 225 #endif
 226
 227
 228 #if defined(NFS_BOOT_BOOTSTATIC) && defined(DOM0OPS)
 229 static int
 230 dom0_bootstatic_callback(struct nfs_diskless *nd)
 231 {
 232 #if 0
 233         struct ifnet *ifp = nd->nd_ifp;
 234 #endif
 235         int flags = 0;
 236         union xen_cmdline_parseinfo xcp;
 237         struct sockaddr_in *sin;
 238
 239         memset(&xcp, 0, sizeof(xcp.xcp_netinfo));
 240         xcp.xcp_netinfo.xi_ifno = 0; /* XXX first interface hardcoded */
 241         xcp.xcp_netinfo.xi_root = nd->nd_root.ndm_host;
 242         xen_parse_cmdline(XEN_PARSE_NETINFO, &xcp);
 243
 244         if (xcp.xcp_netinfo.xi_root[0] != '\0') {
 245                 flags |= NFS_BOOT_HAS_SERVER;
 246                 if (strchr(xcp.xcp_netinfo.xi_root, ':') != NULL)
 247                         flags |= NFS_BOOT_HAS_ROOTPATH;
 248         }
 249
 250         nd->nd_myip.s_addr = ntohl(xcp.xcp_netinfo.xi_ip[0]);
 251         nd->nd_gwip.s_addr = ntohl(xcp.xcp_netinfo.xi_ip[2]);
 252         nd->nd_mask.s_addr = ntohl(xcp.xcp_netinfo.xi_ip[3]);
 253
 254         sin = (struct sockaddr_in *) &nd->nd_root.ndm_saddr;
 255         memset((void *)sin, 0, sizeof(*sin));
 256         sin->sin_len = sizeof(*sin);
 257         sin->sin_family = AF_INET;
 258         sin->sin_addr.s_addr = ntohl(xcp.xcp_netinfo.xi_ip[1]);
 259
 260         if (nd->nd_myip.s_addr)
 261                 flags |= NFS_BOOT_HAS_MYIP;
 262         if (nd->nd_gwip.s_addr)
 263                 flags |= NFS_BOOT_HAS_GWIP;
 264         if (nd->nd_mask.s_addr)
 265                 flags |= NFS_BOOT_HAS_MASK;
 266         if (sin->sin_addr.s_addr)
 267                 flags |= NFS_BOOT_HAS_SERVADDR;
 268
 269         return flags;
 270 }
 271 #endif
 272
 273 void
 274 device_register(device_t dev, void *aux)
 275 {
 276         /*
 277          * Handle network interfaces here, the attachment information is
 278          * not available driver independently later.
 279          * For disks, there is nothing useful available at attach time.
 280          */
 281 #if NXENNET_HYPERVISOR > 0 || NXENNET_XENBUS > 0 || defined(DOM0OPS)
 282         if (device_class(dev) == DV_IFNET) {
 283                 union xen_cmdline_parseinfo xcp;
 284
 285 #ifdef NFS_BOOT_BOOTSTATIC
 286 #ifdef DOM0OPS
 287                 if (xendomain_is_privileged()) {
 288                         nfs_bootstatic_callback = dom0_bootstatic_callback;
 289                 } else
 290 #endif
 291 #if NXENNET_HYPERVISOR > 0 || NXENNET_XENBUS > 0
 292                 nfs_bootstatic_callback = xennet_bootstatic_callback;
 293 #endif
 294 #endif
 295                 xen_parse_cmdline(XEN_PARSE_BOOTDEV, &xcp);
 296                 if (strncmp(xcp.xcp_bootdev, device_xname(dev),
 297                     sizeof(xcp.xcp_bootdev)) == 0)
 298                 {
 299                         goto found;
 300                 }
 301         }
 302 #endif
 303         if (device_class(dev) == DV_IFNET) {
 304                 struct btinfo_netif *bin = lookup_bootinfo(BTINFO_NETIF);
 305                 if (bin == NULL)
 306                         return;
 307
 308                 /*
 309                  * We don't check the driver name against the device name
 310                  * passed by the boot ROM. The ROM should stay usable
 311                  * if the driver gets obsoleted.
 312                  * The physical attachment information (checked below)
 313                  * must be sufficient to identify the device.
 314                  */
 315
 316                 if (bin->bus == BI_BUS_ISA &&
 317                     device_is_a(device_parent(dev), "isa")) {
 318                         struct isa_attach_args *iaa = aux;
 319
 320                         /* compare IO base address */
 321                         /* XXXJRT what about multiple I/O addrs? */
 322                         if (iaa->ia_nio > 0 &&
 323                             bin->addr.iobase == iaa->ia_io[0].ir_addr)
 324                                 goto found;
 325                 }
 326 #if NPCI > 0
 327                 if (bin->bus == BI_BUS_PCI &&
 328                     device_is_a(device_parent(dev), "pci")) {
 329                         struct pci_attach_args *paa = aux;
 330                         int b, d, f;
 331
 332                         /*
 333                          * Calculate BIOS representation of:
 334                          *
 335                          *      <bus,device,function>
 336                          *
 337                          * and compare.
 338                          */
 339                         pci_decompose_tag(paa->pa_pc, paa->pa_tag, &b, &d, &f);
 340                         if (bin->addr.tag == ((b << 8) | (d << 3) | f))
 341                                 goto found;
 342                 }
 343 #endif
 344         }
 345         return;
 346
 347 found:
 348         if (booted_device) {
 349                 /* XXX should be a "panic()" */
 350                 printf("warning: double match for boot device (%s, %s)\n",
 351                     device_xname(booted_device), device_xname(dev));
 352                 return;
 353         }
 354         booted_device = dev;
 355 }
 356
 357 static void
 358 handle_wedges(device_t dv, int par)
 359 {
 360         if (config_handle_wedges(dv, par) == 0)
 361                 return;
 362         booted_device = dv;
 363         booted_partition = par;
 364 }
 365
 366 static int
 367 is_valid_disk(device_t dv)
 368 {
 369
 370         if (device_class(dv) != DV_DISK)
 371                 return (0);
 372
 373         return (device_is_a(dv, "dk") ||
 374                 device_is_a(dv, "sd") ||
 375                 device_is_a(dv, "wd") ||
 376                 device_is_a(dv, "ld") ||
 377                 device_is_a(dv, "ed") ||
 378                 device_is_a(dv, "xbd"));
 379 }