FreeBSD/Linux Kernel Cross Reference
sys/kern/kern_subr.c

     /*      $NetBSD: kern_subr.c,v 1.192.4.1 2008/11/17 18:56:05 snj Exp $  */
     
     /*-
      * Copyright (c) 1997, 1998, 1999, 2002, 2007, 2008 The NetBSD Foundation, Inc.
      * All rights reserved.
      *
      * This code is derived from software contributed to The NetBSD Foundation
      * by Jason R. Thorpe of the Numerical Aerospace Simulation Facility,
      * NASA Ames Research Center, and by Luke Mewburn.
     *
     * Redistribution and use in source and binary forms, with or without
     * modification, are permitted provided that the following conditions
     * are met:
     * 1. Redistributions of source code must retain the above copyright
     *    notice, this list of conditions and the following disclaimer.
     * 2. Redistributions in binary form must reproduce the above copyright
     *    notice, this list of conditions and the following disclaimer in the
     *    documentation and/or other materials provided with the distribution.
     *
     * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
     * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
     * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
     * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
     * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
     * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
     * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
     * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
     * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
     * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
     * POSSIBILITY OF SUCH DAMAGE.
     */
    
    /*
     * Copyright (c) 1982, 1986, 1991, 1993
     *      The Regents of the University of California.  All rights reserved.
     * (c) UNIX System Laboratories, Inc.
     * All or some portions of this file are derived from material licensed
     * to the University of California by American Telephone and Telegraph
     * Co. or Unix System Laboratories, Inc. and are reproduced herein with
     * the permission of UNIX System Laboratories, Inc.
     *
     * Copyright (c) 1992, 1993
     *      The Regents of the University of California.  All rights reserved.
     *
     * This software was developed by the Computer Systems Engineering group
     * at Lawrence Berkeley Laboratory under DARPA contract BG 91-66 and
     * contributed to Berkeley.
     *
     * All advertising materials mentioning features or use of this software
     * must display the following acknowledgement:
     *      This product includes software developed by the University of
     *      California, Lawrence Berkeley Laboratory.
     *
     * Redistribution and use in source and binary forms, with or without
     * modification, are permitted provided that the following conditions
     * are met:
     * 1. Redistributions of source code must retain the above copyright
     *    notice, this list of conditions and the following disclaimer.
     * 2. Redistributions in binary form must reproduce the above copyright
     *    notice, this list of conditions and the following disclaimer in the
     *    documentation and/or other materials provided with the distribution.
     * 3. Neither the name of the University nor the names of its contributors
     *    may be used to endorse or promote products derived from this software
     *    without specific prior written permission.
     *
     * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
     * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
     * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
     * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
     * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
     * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
     * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
     * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
     * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
     * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
     * SUCH DAMAGE.
     *
     *      @(#)kern_subr.c 8.4 (Berkeley) 2/14/95
     */
    
    #include <sys/cdefs.h>
    __KERNEL_RCSID(0, "$NetBSD: kern_subr.c,v 1.192.4.1 2008/11/17 18:56:05 snj Exp $");
    
    #include "opt_ddb.h"
    #include "opt_md.h"
    #include "opt_syscall_debug.h"
    #include "opt_ktrace.h"
    #include "opt_ptrace.h"
    #include "opt_powerhook.h"
    #include "opt_tftproot.h"
    
    #include <sys/param.h>
    #include <sys/systm.h>
    #include <sys/proc.h>
    #include <sys/malloc.h>
    #include <sys/mount.h>
    #include <sys/device.h>
    #include <sys/reboot.h>
    #include <sys/conf.h>
   #include <sys/disk.h>
   #include <sys/disklabel.h>
   #include <sys/queue.h>
   #include <sys/ktrace.h>
   #include <sys/ptrace.h>
   #include <sys/fcntl.h>
   #include <sys/kauth.h>
   #include <sys/vnode.h>
   #include <sys/pmf.h>
   
   #include <uvm/uvm_extern.h>
   
   #include <dev/cons.h>
   
   #include <net/if.h>
   
   /* XXX these should eventually move to subr_autoconf.c */
   static struct device *finddevice(const char *);
   static struct device *getdisk(char *, int, int, dev_t *, int);
   static struct device *parsedisk(char *, int, int, dev_t *);
   static const char *getwedgename(const char *, int);
   
   /*
    * A generic linear hook.
    */
   struct hook_desc {
           LIST_ENTRY(hook_desc) hk_list;
           void    (*hk_fn)(void *);
           void    *hk_arg;
   };
   typedef LIST_HEAD(, hook_desc) hook_list_t;
   
   #ifdef TFTPROOT
   int tftproot_dhcpboot(struct device *);
   #endif
   
   dev_t   dumpcdev;       /* for savecore */
   
   void
   uio_setup_sysspace(struct uio *uio)
   {
   
           uio->uio_vmspace = vmspace_kernel();
   }
   
   int
   uiomove(void *buf, size_t n, struct uio *uio)
   {
           struct vmspace *vm = uio->uio_vmspace;
           struct iovec *iov;
           size_t cnt;
           int error = 0;
           char *cp = buf;
   
           ASSERT_SLEEPABLE();
   
   #ifdef DIAGNOSTIC
           if (uio->uio_rw != UIO_READ && uio->uio_rw != UIO_WRITE)
                   panic("uiomove: mode");
   #endif
           while (n > 0 && uio->uio_resid) {
                   iov = uio->uio_iov;
                   cnt = iov->iov_len;
                   if (cnt == 0) {
                           KASSERT(uio->uio_iovcnt > 0);
                           uio->uio_iov++;
                           uio->uio_iovcnt--;
                           continue;
                   }
                   if (cnt > n)
                           cnt = n;
                   if (!VMSPACE_IS_KERNEL_P(vm)) {
                           if (curcpu()->ci_schedstate.spc_flags &
                               SPCF_SHOULDYIELD)
                                   preempt();
                   }
   
                   if (uio->uio_rw == UIO_READ) {
                           error = copyout_vmspace(vm, cp, iov->iov_base,
                               cnt);
                   } else {
                           error = copyin_vmspace(vm, iov->iov_base, cp,
                               cnt);
                   }
                   if (error) {
                           break;
                   }
                   iov->iov_base = (char *)iov->iov_base + cnt;
                   iov->iov_len -= cnt;
                   uio->uio_resid -= cnt;
                   uio->uio_offset += cnt;
                   cp += cnt;
                   KDASSERT(cnt <= n);
                   n -= cnt;
           }
   
           return (error);
   }
   
   /*
    * Wrapper for uiomove() that validates the arguments against a known-good
    * kernel buffer.
    */
   int
   uiomove_frombuf(void *buf, size_t buflen, struct uio *uio)
   {
           size_t offset;
   
           if (uio->uio_offset < 0 || /* uio->uio_resid < 0 || */
               (offset = uio->uio_offset) != uio->uio_offset)
                   return (EINVAL);
           if (offset >= buflen)
                   return (0);
           return (uiomove((char *)buf + offset, buflen - offset, uio));
   }
   
   /*
    * Give next character to user as result of read.
    */
   int
   ureadc(int c, struct uio *uio)
   {
           struct iovec *iov;
   
           if (uio->uio_resid <= 0)
                   panic("ureadc: non-positive resid");
   again:
           if (uio->uio_iovcnt <= 0)
                   panic("ureadc: non-positive iovcnt");
           iov = uio->uio_iov;
           if (iov->iov_len <= 0) {
                   uio->uio_iovcnt--;
                   uio->uio_iov++;
                   goto again;
           }
           if (!VMSPACE_IS_KERNEL_P(uio->uio_vmspace)) {
                   if (subyte(iov->iov_base, c) < 0)
                           return (EFAULT);
           } else {
                   *(char *)iov->iov_base = c;
           }
           iov->iov_base = (char *)iov->iov_base + 1;
           iov->iov_len--;
           uio->uio_resid--;
           uio->uio_offset++;
           return (0);
   }
   
   /*
    * Like copyin(), but operates on an arbitrary vmspace.
    */
   int
   copyin_vmspace(struct vmspace *vm, const void *uaddr, void *kaddr, size_t len)
   {
           struct iovec iov;
           struct uio uio;
           int error;
   
           if (len == 0)
                   return (0);
   
           if (VMSPACE_IS_KERNEL_P(vm)) {
                   return kcopy(uaddr, kaddr, len);
           }
           if (__predict_true(vm == curproc->p_vmspace)) {
                   return copyin(uaddr, kaddr, len);
           }
   
           iov.iov_base = kaddr;
           iov.iov_len = len;
           uio.uio_iov = &iov;
           uio.uio_iovcnt = 1;
           uio.uio_offset = (off_t)(uintptr_t)uaddr;
           uio.uio_resid = len;
           uio.uio_rw = UIO_READ;
           UIO_SETUP_SYSSPACE(&uio);
           error = uvm_io(&vm->vm_map, &uio);
   
           return (error);
   }
   
   /*
    * Like copyout(), but operates on an arbitrary vmspace.
    */
   int
   copyout_vmspace(struct vmspace *vm, const void *kaddr, void *uaddr, size_t len)
   {
           struct iovec iov;
           struct uio uio;
           int error;
   
           if (len == 0)
                   return (0);
   
           if (VMSPACE_IS_KERNEL_P(vm)) {
                   return kcopy(kaddr, uaddr, len);
           }
           if (__predict_true(vm == curproc->p_vmspace)) {
                   return copyout(kaddr, uaddr, len);
           }
   
           iov.iov_base = __UNCONST(kaddr); /* XXXUNCONST cast away const */
           iov.iov_len = len;
           uio.uio_iov = &iov;
           uio.uio_iovcnt = 1;
           uio.uio_offset = (off_t)(uintptr_t)uaddr;
           uio.uio_resid = len;
           uio.uio_rw = UIO_WRITE;
           UIO_SETUP_SYSSPACE(&uio);
           error = uvm_io(&vm->vm_map, &uio);
   
           return (error);
   }
   
   /*
    * Like copyin(), but operates on an arbitrary process.
    */
   int
   copyin_proc(struct proc *p, const void *uaddr, void *kaddr, size_t len)
   {
           struct vmspace *vm;
           int error;
   
           error = proc_vmspace_getref(p, &vm);
           if (error) {
                   return error;
           }
           error = copyin_vmspace(vm, uaddr, kaddr, len);
           uvmspace_free(vm);
   
           return error;
   }
   
   /*
    * Like copyout(), but operates on an arbitrary process.
    */
   int
   copyout_proc(struct proc *p, const void *kaddr, void *uaddr, size_t len)
   {
           struct vmspace *vm;
           int error;
   
           error = proc_vmspace_getref(p, &vm);
           if (error) {
                   return error;
           }
           error = copyout_vmspace(vm, kaddr, uaddr, len);
           uvmspace_free(vm);
   
           return error;
   }
   
   /*
    * Like copyin(), except it operates on kernel addresses when the FKIOCTL
    * flag is passed in `ioctlflags' from the ioctl call.
    */
   int
   ioctl_copyin(int ioctlflags, const void *src, void *dst, size_t len)
   {
           if (ioctlflags & FKIOCTL)
                   return kcopy(src, dst, len);
           return copyin(src, dst, len);
   }
   
   /*
    * Like copyout(), except it operates on kernel addresses when the FKIOCTL
    * flag is passed in `ioctlflags' from the ioctl call.
    */
   int
   ioctl_copyout(int ioctlflags, const void *src, void *dst, size_t len)
   {
           if (ioctlflags & FKIOCTL)
                   return kcopy(src, dst, len);
           return copyout(src, dst, len);
   }
   
   static void *
   hook_establish(hook_list_t *list, void (*fn)(void *), void *arg)
   {
           struct hook_desc *hd;
   
           hd = malloc(sizeof(*hd), M_DEVBUF, M_NOWAIT);
           if (hd == NULL)
                   return (NULL);
   
           hd->hk_fn = fn;
           hd->hk_arg = arg;
           LIST_INSERT_HEAD(list, hd, hk_list);
   
           return (hd);
   }
   
   static void
   hook_disestablish(hook_list_t *list, void *vhook)
   {
   #ifdef DIAGNOSTIC
           struct hook_desc *hd;
   
           LIST_FOREACH(hd, list, hk_list) {
                   if (hd == vhook)
                           break;
           }
   
           if (hd == NULL)
                   panic("hook_disestablish: hook %p not established", vhook);
   #endif
           LIST_REMOVE((struct hook_desc *)vhook, hk_list);
           free(vhook, M_DEVBUF);
   }
   
   static void
   hook_destroy(hook_list_t *list)
   {
           struct hook_desc *hd;
   
           while ((hd = LIST_FIRST(list)) != NULL) {
                   LIST_REMOVE(hd, hk_list);
                   free(hd, M_DEVBUF);
           }
   }
   
   static void
   hook_proc_run(hook_list_t *list, struct proc *p)
   {
           struct hook_desc *hd;
   
           LIST_FOREACH(hd, list, hk_list)
                   ((void (*)(struct proc *, void *))*hd->hk_fn)(p, hd->hk_arg);
   }
   
   /*
    * "Shutdown hook" types, functions, and variables.
    *
    * Should be invoked immediately before the
    * system is halted or rebooted, i.e. after file systems unmounted,
    * after crash dump done, etc.
    *
    * Each shutdown hook is removed from the list before it's run, so that
    * it won't be run again.
    */
   
   static hook_list_t shutdownhook_list;
   
   void *
   shutdownhook_establish(void (*fn)(void *), void *arg)
   {
           return hook_establish(&shutdownhook_list, fn, arg);
   }
   
   void
   shutdownhook_disestablish(void *vhook)
   {
           hook_disestablish(&shutdownhook_list, vhook);
   }
   
   /*
    * Run shutdown hooks.  Should be invoked immediately before the
    * system is halted or rebooted, i.e. after file systems unmounted,
    * after crash dump done, etc.
    *
    * Each shutdown hook is removed from the list before it's run, so that
    * it won't be run again.
    */
   void
   doshutdownhooks(void)
   {
           struct hook_desc *dp;
   
           while ((dp = LIST_FIRST(&shutdownhook_list)) != NULL) {
                   LIST_REMOVE(dp, hk_list);
                   (*dp->hk_fn)(dp->hk_arg);
   #if 0
                   /*
                    * Don't bother freeing the hook structure,, since we may
                    * be rebooting because of a memory corruption problem,
                    * and this might only make things worse.  It doesn't
                    * matter, anyway, since the system is just about to
                    * reboot.
                    */
                   free(dp, M_DEVBUF);
   #endif
           }
   
           pmf_system_shutdown(boothowto);
   }
   
   /*
    * "Mountroot hook" types, functions, and variables.
    */
   
   static hook_list_t mountroothook_list;
   
   void *
   mountroothook_establish(void (*fn)(struct device *), struct device *dev)
   {
           return hook_establish(&mountroothook_list, (void (*)(void *))fn, dev);
   }
   
   void
   mountroothook_disestablish(void *vhook)
   {
           hook_disestablish(&mountroothook_list, vhook);
   }
   
   void
   mountroothook_destroy(void)
   {
           hook_destroy(&mountroothook_list);
   }
   
   void
   domountroothook(void)
   {
           struct hook_desc *hd;
   
           LIST_FOREACH(hd, &mountroothook_list, hk_list) {
                   if (hd->hk_arg == (void *)root_device) {
                           (*hd->hk_fn)(hd->hk_arg);
                           return;
                   }
           }
   }
   
   static hook_list_t exechook_list;
   
   void *
   exechook_establish(void (*fn)(struct proc *, void *), void *arg)
   {
           return hook_establish(&exechook_list, (void (*)(void *))fn, arg);
   }
   
   void
   exechook_disestablish(void *vhook)
   {
           hook_disestablish(&exechook_list, vhook);
   }
   
   /*
    * Run exec hooks.
    */
   void
   doexechooks(struct proc *p)
   {
           hook_proc_run(&exechook_list, p);
   }
   
   static hook_list_t exithook_list;
   extern krwlock_t exec_lock;
   
   void *
   exithook_establish(void (*fn)(struct proc *, void *), void *arg)
   {
           void *rv;
   
           rw_enter(&exec_lock, RW_WRITER);
           rv = hook_establish(&exithook_list, (void (*)(void *))fn, arg);
           rw_exit(&exec_lock);
           return rv;
   }
   
   void
   exithook_disestablish(void *vhook)
   {
   
           rw_enter(&exec_lock, RW_WRITER);
           hook_disestablish(&exithook_list, vhook);
           rw_exit(&exec_lock);
   }
   
   /*
    * Run exit hooks.
    */
   void
   doexithooks(struct proc *p)
   {
           hook_proc_run(&exithook_list, p);
   }
   
   static hook_list_t forkhook_list;
   
   void *
   forkhook_establish(void (*fn)(struct proc *, struct proc *))
   {
           return hook_establish(&forkhook_list, (void (*)(void *))fn, NULL);
   }
   
   void
   forkhook_disestablish(void *vhook)
   {
           hook_disestablish(&forkhook_list, vhook);
   }
   
   /*
    * Run fork hooks.
    */
   void
   doforkhooks(struct proc *p2, struct proc *p1)
   {
           struct hook_desc *hd;
   
           LIST_FOREACH(hd, &forkhook_list, hk_list) {
                   ((void (*)(struct proc *, struct proc *))*hd->hk_fn)
                       (p2, p1);
           }
   }
   
   /*
    * "Power hook" types, functions, and variables.
    * The list of power hooks is kept ordered with the last registered hook
    * first.
    * When running the hooks on power down the hooks are called in reverse
    * registration order, when powering up in registration order.
    */
   struct powerhook_desc {
           CIRCLEQ_ENTRY(powerhook_desc) sfd_list;
           void    (*sfd_fn)(int, void *);
           void    *sfd_arg;
           char    sfd_name[16];
   };
   
   static CIRCLEQ_HEAD(, powerhook_desc) powerhook_list =
       CIRCLEQ_HEAD_INITIALIZER(powerhook_list);
   
   void *
   powerhook_establish(const char *name, void (*fn)(int, void *), void *arg)
   {
           struct powerhook_desc *ndp;
   
           ndp = (struct powerhook_desc *)
               malloc(sizeof(*ndp), M_DEVBUF, M_NOWAIT);
           if (ndp == NULL)
                   return (NULL);
   
           ndp->sfd_fn = fn;
           ndp->sfd_arg = arg;
           strlcpy(ndp->sfd_name, name, sizeof(ndp->sfd_name));
           CIRCLEQ_INSERT_HEAD(&powerhook_list, ndp, sfd_list);
   
           aprint_error("%s: WARNING: powerhook_establish is deprecated\n", name);
           return (ndp);
   }
   
   void
   powerhook_disestablish(void *vhook)
   {
   #ifdef DIAGNOSTIC
           struct powerhook_desc *dp;
   
           CIRCLEQ_FOREACH(dp, &powerhook_list, sfd_list)
                   if (dp == vhook)
                           goto found;
           panic("powerhook_disestablish: hook %p not established", vhook);
    found:
   #endif
   
           CIRCLEQ_REMOVE(&powerhook_list, (struct powerhook_desc *)vhook,
               sfd_list);
           free(vhook, M_DEVBUF);
   }
   
   /*
    * Run power hooks.
    */
   void
   dopowerhooks(int why)
   {
           struct powerhook_desc *dp;
   
   #ifdef POWERHOOK_DEBUG
           const char *why_name;
           static const char * pwr_names[] = {PWR_NAMES};
           why_name = why < __arraycount(pwr_names) ? pwr_names[why] : "???";
   #endif
   
           if (why == PWR_RESUME || why == PWR_SOFTRESUME) {
                   CIRCLEQ_FOREACH_REVERSE(dp, &powerhook_list, sfd_list) {
   #ifdef POWERHOOK_DEBUG
                           printf("dopowerhooks %s: %s (%p)\n", why_name, dp->sfd_name, dp);
   #endif
                           (*dp->sfd_fn)(why, dp->sfd_arg);
                   }
           } else {
                   CIRCLEQ_FOREACH(dp, &powerhook_list, sfd_list) {
   #ifdef POWERHOOK_DEBUG
                           printf("dopowerhooks %s: %s (%p)\n", why_name, dp->sfd_name, dp);
   #endif
                           (*dp->sfd_fn)(why, dp->sfd_arg);
                   }
           }
   
   #ifdef POWERHOOK_DEBUG
           printf("dopowerhooks: %s done\n", why_name);
   #endif
   }
   
   static int
   isswap(struct device *dv)
   {
           struct dkwedge_info wi;
           struct vnode *vn;
           int error;
   
           if (device_class(dv) != DV_DISK || !device_is_a(dv, "dk"))
                   return 0;
   
           if ((vn = opendisk(dv)) == NULL)
                   return 0;
   
           error = VOP_IOCTL(vn, DIOCGWEDGEINFO, &wi, FREAD, NOCRED);
           VOP_CLOSE(vn, FREAD, NOCRED);
           vput(vn);
           if (error) {
   #ifdef DEBUG_WEDGE
                   printf("%s: Get wedge info returned %d\n", device_xname(dv), error);
   #endif
                   return 0;
           }
           return strcmp(wi.dkw_ptype, DKW_PTYPE_SWAP) == 0;
   }
   
   /*
    * Determine the root device and, if instructed to, the root file system.
    */
   
   #include "md.h"
   
   #if NMD > 0
   extern struct cfdriver md_cd;
   #ifdef MEMORY_DISK_IS_ROOT
   int md_is_root = 1;
   #else
   int md_is_root = 0;
   #endif
   #endif
   
   /*
    * The device and wedge that we booted from.  If booted_wedge is NULL,
    * the we might consult booted_partition.
    */
   struct device *booted_device;
   struct device *booted_wedge;
   int booted_partition;
   
   /*
    * Use partition letters if it's a disk class but not a wedge.
    * XXX Check for wedge is kinda gross.
    */
   #define DEV_USES_PARTITIONS(dv)                                         \
           (device_class((dv)) == DV_DISK &&                               \
            !device_is_a((dv), "dk"))
   
   void
   setroot(struct device *bootdv, int bootpartition)
   {
           struct device *dv;
           int len, majdev;
           dev_t nrootdev;
           dev_t ndumpdev = NODEV;
           char buf[128];
           const char *rootdevname;
           const char *dumpdevname;
           struct device *rootdv = NULL;           /* XXX gcc -Wuninitialized */
           struct device *dumpdv = NULL;
           struct ifnet *ifp;
           const char *deffsname;
           struct vfsops *vops;
   
   #ifdef TFTPROOT
           if (tftproot_dhcpboot(bootdv) != 0)
                   boothowto |= RB_ASKNAME;
   #endif
   
   #if NMD > 0
           if (md_is_root) {
                   /*
                    * XXX there should be "root on md0" in the config file,
                    * but it isn't always
                    */
                   bootdv = md_cd.cd_devs[0];
                   bootpartition = 0;
           }
   #endif
   
           /*
            * If NFS is specified as the file system, and we found
            * a DV_DISK boot device (or no boot device at all), then
            * find a reasonable network interface for "rootspec".
            */
           vops = vfs_getopsbyname("nfs");
           if (vops != NULL && vops->vfs_mountroot == mountroot &&
               rootspec == NULL &&
               (bootdv == NULL || device_class(bootdv) != DV_IFNET)) {
                   IFNET_FOREACH(ifp) {
                           if ((ifp->if_flags &
                                (IFF_LOOPBACK|IFF_POINTOPOINT)) == 0)
                                   break;
                   }
                   if (ifp == NULL) {
                           /*
                            * Can't find a suitable interface; ask the
                            * user.
                            */
                           boothowto |= RB_ASKNAME;
                   } else {
                           /*
                            * Have a suitable interface; behave as if
                            * the user specified this interface.
                            */
                           rootspec = (const char *)ifp->if_xname;
                   }
           }
           if (vops != NULL)
                   vfs_delref(vops);
   
           /*
            * If wildcarded root and we the boot device wasn't determined,
            * ask the user.
            */
           if (rootspec == NULL && bootdv == NULL)
                   boothowto |= RB_ASKNAME;
   
    top:
           if (boothowto & RB_ASKNAME) {
                   struct device *defdumpdv;
   
                   for (;;) {
                           printf("root device");
                           if (bootdv != NULL) {
                                   printf(" (default %s", device_xname(bootdv));
                                   if (DEV_USES_PARTITIONS(bootdv))
                                           printf("%c", bootpartition + 'a');
                                   printf(")");
                           }
                           printf(": ");
                           len = cngetsn(buf, sizeof(buf));
                           if (len == 0 && bootdv != NULL) {
                                   strlcpy(buf, device_xname(bootdv), sizeof(buf));
                                   len = strlen(buf);
                           }
                           if (len > 0 && buf[len - 1] == '*') {
                                   buf[--len] = '\0';
                                   dv = getdisk(buf, len, 1, &nrootdev, 0);
                                   if (dv != NULL) {
                                           rootdv = dv;
                                           break;
                                   }
                           }
                           dv = getdisk(buf, len, bootpartition, &nrootdev, 0);
                           if (dv != NULL) {
                                   rootdv = dv;
                                   break;
                           }
                   }
   
                   /*
                    * Set up the default dump device.  If root is on
                    * a network device, there is no default dump
                    * device, since we don't support dumps to the
                    * network.
                    */
                   if (DEV_USES_PARTITIONS(rootdv) == 0)
                           defdumpdv = NULL;
                   else
                           defdumpdv = rootdv;
   
                   for (;;) {
                           printf("dump device");
                           if (defdumpdv != NULL) {
                                   /*
                                    * Note, we know it's a disk if we get here.
                                    */
                                   printf(" (default %sb)", device_xname(defdumpdv));
                           }
                           printf(": ");
                           len = cngetsn(buf, sizeof(buf));
                           if (len == 0) {
                                   if (defdumpdv != NULL) {
                                           ndumpdev = MAKEDISKDEV(major(nrootdev),
                                               DISKUNIT(nrootdev), 1);
                                   }
                                   dumpdv = defdumpdv;
                                   break;
                           }
                           if (len == 4 && strcmp(buf, "none") == 0) {
                                   dumpdv = NULL;
                                   break;
                           }
                           dv = getdisk(buf, len, 1, &ndumpdev, 1);
                           if (dv != NULL) {
                                   dumpdv = dv;
                                   break;
                           }
                   }
   
                   rootdev = nrootdev;
                   dumpdev = ndumpdev;
   
                   for (vops = LIST_FIRST(&vfs_list); vops != NULL;
                        vops = LIST_NEXT(vops, vfs_list)) {
                           if (vops->vfs_mountroot != NULL &&
                               vops->vfs_mountroot == mountroot)
                           break;
                   }
   
                   if (vops == NULL) {
                           mountroot = NULL;
                           deffsname = "generic";
                   } else
                           deffsname = vops->vfs_name;
   
                   for (;;) {
                           printf("file system (default %s): ", deffsname);
                           len = cngetsn(buf, sizeof(buf));
                           if (len == 0)
                                   break;
                           if (len == 4 && strcmp(buf, "halt") == 0)
                                   cpu_reboot(RB_HALT, NULL);
                           else if (len == 6 && strcmp(buf, "reboot") == 0)
                                   cpu_reboot(0, NULL);
   #if defined(DDB)
                           else if (len == 3 && strcmp(buf, "ddb") == 0) {
                                   console_debugger();
                           }
   #endif
                           else if (len == 7 && strcmp(buf, "generic") == 0) {
                                   mountroot = NULL;
                                   break;
                           }
                           vops = vfs_getopsbyname(buf);
                           if (vops == NULL || vops->vfs_mountroot == NULL) {
                                   printf("use one of: generic");
                                   for (vops = LIST_FIRST(&vfs_list);
                                        vops != NULL;
                                        vops = LIST_NEXT(vops, vfs_list)) {
                                           if (vops->vfs_mountroot != NULL)
                                                   printf(" %s", vops->vfs_name);
                                   }
   #if defined(DDB)
                                   printf(" ddb");
   #endif
                                   printf(" halt reboot\n");
                           } else {
                                   mountroot = vops->vfs_mountroot;
                                   vfs_delref(vops);
                                   break;
                           }
                   }
   
           } else if (rootspec == NULL) {
                   /*
                    * Wildcarded root; use the boot device.
                    */
                   rootdv = bootdv;
   
                   if (bootdv)
                           majdev = devsw_name2blk(device_xname(bootdv), NULL, 0);
                   else
                           majdev = -1;
                   if (majdev >= 0) {
                           /*
                            * Root is on a disk.  `bootpartition' is root,
                            * unless the device does not use partitions.
                            */
                           if (DEV_USES_PARTITIONS(bootdv))
                                   rootdev = MAKEDISKDEV(majdev,
                                                         device_unit(bootdv),
                                                         bootpartition);
                           else
                                   rootdev = makedev(majdev, device_unit(bootdv));
                   }
           } else {
   
                   /*
                    * `root on <dev> ...'
                    */
   
                   /*
                    * If it's a network interface, we can bail out
                    * early.
                    */
                   dv = finddevice(rootspec);
                   if (dv != NULL && device_class(dv) == DV_IFNET) {
                           rootdv = dv;
                           goto haveroot;
                   }
   
                   if (rootdev == NODEV &&
                       device_class(dv) == DV_DISK && device_is_a(dv, "dk") &&
                       (majdev = devsw_name2blk(device_xname(dv), NULL, 0)) >= 0)
                           rootdev = makedev(majdev, device_unit(dv));
   
                   rootdevname = devsw_blk2name(major(rootdev));
                   if (rootdevname == NULL) {
                           printf("unknown device major 0x%x\n", rootdev);
                           boothowto |= RB_ASKNAME;
                           goto top;
                   }
                   memset(buf, 0, sizeof(buf));
                   snprintf(buf, sizeof(buf), "%s%d", rootdevname,
                       DISKUNIT(rootdev));
  
                  rootdv = finddevice(buf);
                  if (rootdv == NULL) {
                          printf("device %s (0x%x) not configured\n",
                              buf, rootdev);
                          boothowto |= RB_ASKNAME;
                          goto top;
                  }
          }
  
   haveroot:
  
          root_device = rootdv;
  
          switch (device_class(rootdv)) {
          case DV_IFNET:
          case DV_DISK:
                  aprint_normal("root on %s", device_xname(rootdv));
                  if (DEV_USES_PARTITIONS(rootdv))
                          aprint_normal("%c", DISKPART(rootdev) + 'a');
                  break;
  
          default:
                  printf("can't determine root device\n");
                  boothowto |= RB_ASKNAME;
                  goto top;
          }
  
          /*
           * Now configure the dump device.
           *
           * If we haven't figured out the dump device, do so, with
           * the following rules:
           *
           *      (a) We already know dumpdv in the RB_ASKNAME case.
           *
           *      (b) If dumpspec is set, try to use it.  If the device
           *          is not available, punt.
           *
           *      (c) If dumpspec is not set, the dump device is
           *          wildcarded or unspecified.  If the root device
           *          is DV_IFNET, punt.  Otherwise, use partition b
           *          of the root device.
           */
  
          if (boothowto & RB_ASKNAME) {           /* (a) */
                  if (dumpdv == NULL)
                          goto nodumpdev;
          } else if (dumpspec != NULL) {          /* (b) */
                  if (strcmp(dumpspec, "none") == 0 || dumpdev == NODEV) {
                          /*
                           * Operator doesn't want a dump device.
                           * Or looks like they tried to pick a network
                           * device.  Oops.
                           */
                          goto nodumpdev;
                  }
  
                  dumpdevname = devsw_blk2name(major(dumpdev));
                  if (dumpdevname == NULL)
                          goto nodumpdev;
                  memset(buf, 0, sizeof(buf));
                  snprintf(buf, sizeof(buf), "%s%d", dumpdevname,
                      DISKUNIT(dumpdev));
  
                  dumpdv = finddevice(buf);
                  if (dumpdv == NULL) {
                          /*
                           * Device not configured.
                           */
                          goto nodumpdev;
                  }
          } else {                                /* (c) */
                  if (DEV_USES_PARTITIONS(rootdv) == 0) {
                          for (dv = TAILQ_FIRST(&alldevs); dv != NULL;
                              dv = TAILQ_NEXT(dv, dv_list))
                                  if (isswap(dv))
                                          break;
                          if (dv == NULL)
                                  goto nodumpdev;
  
                          majdev = devsw_name2blk(device_xname(dv), NULL, 0);
                          if (majdev < 0)
                                  goto nodumpdev;
                          dumpdv = dv;
                          dumpdev = makedev(majdev, device_unit(dumpdv));
                  } else {
                          dumpdv = rootdv;
                          dumpdev = MAKEDISKDEV(major(rootdev),
                              device_unit(dumpdv), 1);
                  }
          }
  
          dumpcdev = devsw_blk2chr(dumpdev);
          aprint_normal(" dumps on %s", device_xname(dumpdv));
          if (DEV_USES_PARTITIONS(dumpdv))
                  aprint_normal("%c", DISKPART(dumpdev) + 'a');
          aprint_normal("\n");
          return;
  
   nodumpdev:
          dumpdev = NODEV;
          dumpcdev = NODEV;
          aprint_normal("\n");
  }
  
  static struct device *
  finddevice(const char *name)
  {
          const char *wname;
  
          if ((wname = getwedgename(name, strlen(name))) != NULL)
                  return dkwedge_find_by_wname(wname);
  
          return device_find_by_xname(name);
  }
  
  static struct device *
  getdisk(char *str, int len, int defpart, dev_t *devp, int isdump)
  {
          struct device   *dv;
  
          if ((dv = parsedisk(str, len, defpart, devp)) == NULL) {
                  printf("use one of:");
                  TAILQ_FOREACH(dv, &alldevs, dv_list) {
                          if (DEV_USES_PARTITIONS(dv))
                                  printf(" %s[a-%c]", device_xname(dv),
                                      'a' + MAXPARTITIONS - 1);
                          else if (device_class(dv) == DV_DISK)
                                  printf(" %s", device_xname(dv));
                          if (isdump == 0 && device_class(dv) == DV_IFNET)
                                  printf(" %s", device_xname(dv));
                  }
                  dkwedge_print_wnames();
                  if (isdump)
                          printf(" none");
  #if defined(DDB)
                  printf(" ddb");
  #endif
                  printf(" halt reboot\n");
          }
          return dv;
  }
  
  static const char *
  getwedgename(const char *name, int namelen)
  {
          const char *wpfx = "wedge:";
          const int wpfxlen = strlen(wpfx);
  
          if (namelen < wpfxlen || strncmp(name, wpfx, wpfxlen) != 0)
                  return NULL;
  
          return name + wpfxlen;
  }
  
  static struct device *
  parsedisk(char *str, int len, int defpart, dev_t *devp)
  {
          struct device *dv;
          const char *wname;
          char *cp, c;
          int majdev, part;
          if (len == 0)
                  return (NULL);
  
          if (len == 4 && strcmp(str, "halt") == 0)
                  cpu_reboot(RB_HALT, NULL);
          else if (len == 6 && strcmp(str, "reboot") == 0)
                  cpu_reboot(0, NULL);
  #if defined(DDB)
          else if (len == 3 && strcmp(str, "ddb") == 0)
                  console_debugger();
  #endif
  
          cp = str + len - 1;
          c = *cp;
  
          if ((wname = getwedgename(str, len)) != NULL) {
                  if ((dv = dkwedge_find_by_wname(wname)) == NULL)
                          return NULL;
                  part = defpart;
                  goto gotdisk;
          } else if (c >= 'a' && c <= ('a' + MAXPARTITIONS - 1)) {
                  part = c - 'a';
                  *cp = '\0';
          } else
                  part = defpart;
  
          dv = finddevice(str);
          if (dv != NULL) {
                  if (device_class(dv) == DV_DISK) {
   gotdisk:
                          majdev = devsw_name2blk(device_xname(dv), NULL, 0);
                          if (majdev < 0)
                                  panic("parsedisk");
                          if (DEV_USES_PARTITIONS(dv))
                                  *devp = MAKEDISKDEV(majdev, device_unit(dv),
                                                      part);
                          else
                                  *devp = makedev(majdev, device_unit(dv));
                  }
  
                  if (device_class(dv) == DV_IFNET)
                          *devp = NODEV;
          }
  
          *cp = c;
          return (dv);
  }
  
  /*
   * snprintf() `bytes' into `buf', reformatting it so that the number,
   * plus a possible `x' + suffix extension) fits into len bytes (including
   * the terminating NUL).
   * Returns the number of bytes stored in buf, or -1 if there was a problem.
   * E.g, given a len of 9 and a suffix of `B':
   *      bytes           result
   *      -----           ------
   *      99999           `99999 B'
   *      100000          `97 kB'
   *      66715648        `65152 kB'
   *      252215296       `240 MB'
   */
  int
  humanize_number(char *buf, size_t len, uint64_t bytes, const char *suffix,
      int divisor)
  {
          /* prefixes are: (none), kilo, Mega, Giga, Tera, Peta, Exa */
          const char *prefixes;
          int             r;
          uint64_t        umax;
          size_t          i, suffixlen;
  
          if (buf == NULL || suffix == NULL)
                  return (-1);
          if (len > 0)
                  buf[0] = '\0';
          suffixlen = strlen(suffix);
          /* check if enough room for `x y' + suffix + `\0' */
          if (len < 4 + suffixlen)
                  return (-1);
  
          if (divisor == 1024) {
                  /*
                   * binary multiplies
                   * XXX IEC 60027-2 recommends Ki, Mi, Gi...
                   */
                  prefixes = " KMGTPE";
          } else
                  prefixes = " kMGTPE"; /* SI for decimal multiplies */
  
          umax = 1;
          for (i = 0; i < len - suffixlen - 3; i++)
                  umax *= 10;
          for (i = 0; bytes >= umax && prefixes[i + 1]; i++)
                  bytes /= divisor;
  
          r = snprintf(buf, len, "%qu%s%c%s", (unsigned long long)bytes,
              i == 0 ? "" : " ", prefixes[i], suffix);
  
          return (r);
  }
  
  int
  format_bytes(char *buf, size_t len, uint64_t bytes)
  {
          int     rv;
          size_t  nlen;
  
          rv = humanize_number(buf, len, bytes, "B", 1024);
          if (rv != -1) {
                          /* nuke the trailing ` B' if it exists */
                  nlen = strlen(buf) - 2;
                  if (strcmp(&buf[nlen], " B") == 0)
                          buf[nlen] = '\0';
          }
          return (rv);
  }
  
  /*
   * Return true if system call tracing is enabled for the specified process.
   */
  bool
  trace_is_enabled(struct proc *p)
  {
  #ifdef SYSCALL_DEBUG
          return (true);
  #endif
  #ifdef KTRACE
          if (ISSET(p->p_traceflag, (KTRFAC_SYSCALL | KTRFAC_SYSRET)))
                  return (true);
  #endif
  #ifdef PTRACE
          if (ISSET(p->p_slflag, PSL_SYSCALL))
                  return (true);
  #endif
  
          return (false);
  }
  
  /*
   * Start trace of particular system call. If process is being traced,
   * this routine is called by MD syscall dispatch code just before
   * a system call is actually executed.
   */
  int
  trace_enter(register_t code, const register_t *args, int narg)
  {
  #ifdef SYSCALL_DEBUG
          scdebug_call(code, args);
  #endif /* SYSCALL_DEBUG */
  
          ktrsyscall(code, args, narg);
  
  #ifdef PTRACE
          if ((curlwp->l_proc->p_slflag & (PSL_SYSCALL|PSL_TRACED)) ==
              (PSL_SYSCALL|PSL_TRACED))
                  process_stoptrace();
  #endif
          return 0;
  }
  
  /*
   * End trace of particular system call. If process is being traced,
   * this routine is called by MD syscall dispatch code just after
   * a system call finishes.
   * MD caller guarantees the passed 'code' is within the supported
   * system call number range for emulation the process runs under.
   */
  void
  trace_exit(register_t code, register_t rval[], int error)
  {
  #ifdef SYSCALL_DEBUG
          scdebug_ret(code, error, rval);
  #endif /* SYSCALL_DEBUG */
  
          ktrsysret(code, error, rval);
          
  #ifdef PTRACE
          if ((curlwp->l_proc->p_slflag & (PSL_SYSCALL|PSL_TRACED)) ==
              (PSL_SYSCALL|PSL_TRACED))
                  process_stoptrace();
  #endif
  }

Cache object: 50686ff2967690375e75f52298fe8d12