xref: /netbsd/src/etc/MAKEDEV.tmpl

#!/bin/sh -
#         $NetBSD: MAKEDEV.tmpl,v 1.237 2025/03/28 18:41:25 riastradh Exp $
#
# Copyright (c) 2003,2007,2008 The NetBSD Foundation, Inc.
# All rights reserved.
#
# 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.
#
#
###########################################################################
#
#   PLEASE RUN "cd ../share/man/man8 ; make makedevs"
#   AFTER CHANGING THIS FILE, AND COMMIT THE UPDATED MANPAGE!
#
###########################################################################
#
# Device "make" file.  Valid special arguments:
#         all       makes all known devices, including local devices.
#                   Tries to make the 'standard' number of each type.
#         init      A set of devices that is used for MFS /dev by init.
#                   May be equal to "all".
#         floppy    devices to be put on install floppies
#         ramdisk   devices to be put into INSTALL kernel ramdisks.
#         std       standard devices
#         local     configuration specific devices
#         lua       Lua device
#         wscons    make wscons devices
#         usbs      make USB devices
#         virtio    virtio(4)-related devices
#
# Tapes:
#         st*       SCSI tapes
#         wt*       QIC-interfaced (e.g. not SCSI) 3M cartridge tape
#         ht*       MASSBUS TM03 and TU??
#         mt*       MSCP tapes (e.g. TU81, TK50)
#         tm*       UNIBUS TM11 and TE10 emulations (e.g. Emulex TC-11)
#         ts*       UNIBUS TS11
#         ut*       UNIBUS TU45 emulations (e.g. si 9700)
#         uu*       TU58 cassettes on DL11 controller
#
# Disks:
#         dk*       wedge disk slices
#         ccd*      concatenated disk devices
#         cd*       SCSI or ATAPI CD-ROM
#         cgd*      cryptographic disk devices
#         raid*     RAIDframe disk devices
#         sd*       SCSI disks
#         wd*       "winchester" disk drives (ST506,IDE,ESDI,RLL,...)
#         bmd*      Nereid bank memory disks
#         ed*       IBM PS/2 ESDI disk devices
#         fd*       "floppy" disk drives (3 1/2", 5 1/4")
#         fss*      Files system snapshot devices
#         gdrom*    Dreamcast "gigadisc" CD-ROM drive
#         hk*       UNIBUS RK06 and RK07
#         hp*       MASSBUS RM??
#         ld*       Logical disk devices (e.g., hardware RAID)
#         mcd*      Mitsumi CD-ROM
#         md*       memory pseudo-disk devices
#         ofdisk*   OpenFirmware disk devices
#         ra*       MSCP disks (RA??, RD??)
#         rb*       730 IDC w/ RB80 and/or RB02
#         rd*       HDC9224 RD disks on VS2000
#         rl*       UNIBUS RL02
#         rx*       MSCP floppy disk (RX33/50/...)
#         up*       other UNIBUS devices (e.g. on Emulex SC-21V controller)
#         vnd*      "file" pseudo-disks
#         xbd*      Xen virtual disks
#         xd*       Xylogic 753/7053 disks
#         xy*       Xylogic 450/451 disks
#
# Pointing devices:
#         wsmouse* wscons mouse events
#         lms*      Logitech bus mouse
#         mms*      Microsoft bus mouse
#         qms*      "quadrature mouse"
#         pms*      PS/2 mouse
#         mouse     mouse (provides events, for X11)
#
# Keyboard devices:
#         wskbd*    wscons keyboard events
#         kbd       raw keyboard (provides events, for X11)
#         kbdctl    keyboard control
#
# Terminals/Console ports:
#         tty[01]*  standard serial ports
#         tty0*     SB1250 ("sbscn") serial ports (sbmips)
#         ttyE*     wscons - Workstation console ("wscons") glass-tty emulators
#         ttyCZ?    Cyclades-Z multiport serial boards.  Each "unit"
#                   makes 64 ports.
#         ttyCY?    Cyclom-Y multiport serial boards. Each "unit" makes
#                   32 ports.
#         ttye*     ITE bitmapped consoles
#         ttyv0     pccons
#         ttyC?     NS16550 ("com") serial ports
#         ttyS*     SA1110 serial port (hpcarm)
#         ttyTX?    TX39 internal serial ports (hpcmips)
#         ttyB?     DEC 3000 ZS8530 ("scc") serial ports (alpha)
#         ttyA*     mfc serial ports (amiga)
#         ttyB*     msc serial ports (amiga)
#         ttyC*     com style serial ports (DraCo, HyperCom) (amiga)
#                   On the DraCo, units 0 and 1 are the built-in "modem" and
#                   "mouse" ports, if configured.
#         ttyA0   8530 Channel A (formerly ser02) (atari)
#         ttyA1     8530 Channel B (formerly mdm02) (atari)
#         ttyB0     UART on first 68901 (formerly mdm01) (atari)
#         ixpcom    IXP12x0 COM ports
#         epcom     EP93xx COM ports
#         plcom     ARM PL01[01] serial ports
#         wmcom     EPOC Windermere COM ports
#         ttyM?     HP200/300 4 port serial mux interface (hp300)
#         ttya      "ttya" system console (luna68k)
#         ttyb      second system serial port (luna68k)
#         tty*      Onboard serial ports (mvme68k)
#                   On the mvme147 these are: ttyZ1, ttyZ2 and ttyZ3.
#                   On the mvme167, and '177: ttyC1, ttyC2 and ttyC3.
#                   Note that tty[CZ]0 is grabbed by the console device
#                   so is not created by default
#         dc*       PMAX 4 channel serial interface (kbd, mouse, modem, printer)
#         scc*      82530 serial interface (pmax)
#         ttyZ*     Zilog 8530 ("zstty") serial ports
#         tty[abcd] Built-in serial ports (sparc)
#         tty*      Z88530 serial controllers (sparc64)
#         ttyh*     SAB82532 serial controllers (sparc64)
#         tty[a-j]  Built-in serial ports (sun2, sun3)
#         ttyC?     pccons (arc)
#         dz*       UNIBUS DZ11 and DZ32 (vax)
#         dh*       UNIBUS DH11 and emulations (e.g. Able DMAX, Emulex CS-11) (vax)
#         dmf*      UNIBUS DMF32 (vax)
#         dhu*    UNIBUS DHU11 (vax)
#         dmz*    UNIBUS DMZ32 (vax)
#         dl*       UNIBUS DL11 (vax)
#         xencons   Xen virtual console
#         ttyVI??   viocon(4)
#
# Terminal multiplexors:
#         dc*       4 channel serial interface (keyboard, mouse, modem, printer)
#         dh*       UNIBUS DH11 and emulations (e.g. Able DMAX, Emulex CS-11)
#         dhu*      UNIBUS DHU11
#         dl*       UNIBUS DL11
#         dmf*      UNIBUS DMF32
#         dmz*      UNIBUS DMZ32
#         dz*       UNIBUS DZ11 and DZ32
#         scc*      82530 serial interface
#
# Call units:
#         dn*       UNIBUS DN11 and emulations (e.g. Able Quadracall)
#
# Pseudo terminals:
#         ptm       pty multiplexor device, and pts directory
#         pty*      set of 16 master and slave pseudo terminals
#         opty      first 16 ptys, to save inodes on install media
#         ipty      first 2 ptys, for install media use only
#
# Printers:
#         arcpp*    Archimedes parallel port
#         lpt*      stock lp
#         lpa*      interruptless lp
#         par*      Amiga motherboard parallel port
#         cpi*      Macintosh Nubus CSI parallel printer card
#
# USB devices:
#         usb*      USB control devices
#         uhid*     USB generic HID devices
#         ulpt*     USB printer devices
#         ugen*     USB generic devices
#         ttyHS*    USB Option N.V. modems
#         ttyU*     USB modems
#         ttyY*     USB serial adapters
#
# Video devices:
#         bwtwo*    monochromatic frame buffer
#         cgtwo*    8-bit color frame buffer
#         cgthree*  8-bit color frame buffer
#         cgfour*   8-bit color frame buffer
#         cgsix*    accelerated 8-bit color frame buffer
#         cgeight*  24-bit color frame buffer
#         etvme     Tseng et-compatible cards on VME (atari)
#         ik*       UNIBUS interface to Ikonas frame buffer
#         leo       Circad Leonardo VME-bus true color (atari)
#         ps*       UNIBUS interface to Picture System 2
#         qv*       QVSS (MicroVAX) display
#         tcx*      accelerated 8/24-bit color frame buffer
#
# Maple bus devices:
#         maple     Maple bus control devices
#         mlcd*     Maple bus LCD devices
#         mmem*     Maple bus storage devices
#
# IEEE1394 bus devices:
#         fw*       IEEE1394 bus generic node access devices
#         fwmem*    IEEE1394 bus physical memory of the remote node access devices
#
# Special purpose devices:
#         ad*       UNIBUS interface to Data Translation A/D converter
#         agp*      AGP GART devices
#         altq      ALTQ control interface
#         amr*      AMI MegaRaid control device
#         apm       power management device
#         audio*    audio devices
#         bell*     OPM bell device (x68k)
#         bktr      Brooktree 848/849/878/879 based TV cards
#         bpf       packet filter
#         bthub     Bluetooth Device Hub control interface
#         cfs*      Coda file system device
#         ch*       SCSI media changer
#         cir*      Consumer IR
#         clockctl clock control for non root users
#         cpuctl    CPU control
#         crypto    hardware crypto access driver
#         dmoverio hardware-assisted data movers
#         dpt*      DPT/Adaptec EATA RAID management interface
#         dpti*     DPT/Adaptec I2O RAID management interface
#         drm*      Direct Rendering Manager interface
#         dtv*      Digital TV interface
#         fb*       PMAX generic framebuffer pseudo-device
#         fd        file descriptors
#         gpioirq* Interrupts on GPIO pins
#         gpiopps* 1PPS signals on GPIO pins
#         grf*      graphics frame buffer device
#         hdaudio* High Definition audio control device
#         hdmicec* HDMI CEC devices
#         hil       HP300 HIL input devices
#         icp       ICP-Vortex/Intel RAID control interface
#         iic*      IIC bus device
#         io        x86 IOPL access for COMPAT_10, COMPAT_FREEBSD
#         iop*      I2O IOP control interface
#         ipmi*     OpenIPMI compatible interface
#         ipl       IP Filter
#         irframe* IrDA physical frame
#         ite*      terminal emulator interface to HP300 graphics devices
#         joy*      joystick device
#         kttcp     kernel ttcp helper device
#         lockstat kernel locking statistics
#         magma*    Magma multiport serial/parallel cards
#         midi*     MIDI
#         mfi*      LSI MegaRAID/MegaSAS control interface
#         mlx*      Mylex DAC960 control interface
#         mly*      Mylex AcceleRAID/eXtremeRAID control interface
#         np*       UNIBUS Ethernet co-processor interface, for downloading.
#         npf       NPF packet filter
#         nvme*     Non-Volatile Memory Host Controller Interface device driver
#         nvme*ns* Non-Volatile Memory namespace
#         nvmm      NetBSD Virtual Machine Monitor
#         openfirm OpenFirmware accessor
#         pad*      Pseudo-audio device driver
#         pci*      PCI bus access devices
#         pf        PF packet filter
#         putter    Pass-to-Userspace Transporter
#         px*       PixelStamp Xserver access
#         qemufwcfg* QEMU Firmware Configuration
#         radio*    radio devices
#         random    Random number generator
#         rtc*      RealTimeClock
#         scmd*     Sparkfun Serial Controlled Motor Driver
#         scsibus* SCSI busses
#         se*       SCSI Ethernet
#         ses*      SES/SAF-TE SCSI Devices
#         sht3xtemp*          Sensirion SHT3X temperature and humidity device driver
#         speaker   PC speaker                    (XXX - installed)
#         spi*      SPI bus device
#         sram      battery backuped memory (x68k)
#         srt*      source-address based routing
#         ss*       SCSI scanner
#         stic*     PixelStamp interface chip
#         sysmon    System Monitoring hardware
#         tap*      virtual Ethernet device
#         tprof     task profiler
#         tun*      network tunnel driver
#         twa       3ware Apache control interface
#         twe       3ware Escalade control interface
#         uk*       unknown SCSI device
#         veriexec Veriexec fingerprint loader
#         vhci      virtual host controller interface
#         video*    video capture devices
#         view*     generic interface to graphic displays (Amiga)
#         wsfont*   console font control
#         wsmux*    wscons event multiplexor
#         xenevt    Xen event interface
#
# iSCSI communication devices
#         iscsi*    iSCSI driver and /sbin/iscsid communication
#
# Trusted Computing devices
#         tpm       Trusted Platform Module
#
# Debugging and tracing
#         dtrace    Dynamic tracing framework


#
# NOTE:
#
# * MAKEDEV is used both as a standalone script (via "sh ./MAKEDEV
#   all" or similar), and as a function library for MAKEDEV.local (via
#   "MAKEDEV_AS_LIBRARY=1 . MAKEDEV").  Because of this, the script
#   should consist almost entirely of function definitions, apart from a
#   few lines right at the end.
#
# * MAKEDEV may be executed in an environment that is missing some
#   common commands.  For example, it may be executed from a minimal
#   system used during installation, or it may be executed early in the
#   boot sequence before most file systems have been mounted.  It may
#   also be executed in a cross-build environment on a non-NetBSD host.
#

usage()
{
          cat 1>&2 << _USAGE_
Usage: ${0##*/} [-fMsu] [-m mknod] [-p pax] [-t mtree] special [...]
          Create listed special devices.  Options:
          -f                  Force permissions to be updated on existing devices.
          -M                  Create memory file system.
          -m mknod  Name of mknod(8) program.  [\$TOOL_MKNOD or mknod]
          -p pax    Name of pax(1) program.  [\$TOOL_PAX or pax]
          -s                  Generate mtree(8) specfile instead of creating devices.
          -t mtree  Name of mtree(8) program.  [\$TOOL_MTREE or mtree]
          -u                  Don't re-create devices that already exist.

_USAGE_
          exit 1
}

# zeropad width number
#         display number with a zero (`0') padding of width digits.
#
zeropad()
{
          case $(($1 - ${#2})) in
          5)        echo 00000$2;;
          4)        echo 0000$2;;
          3)        echo 000$2;;
          2)        echo 00$2;;
          1)        echo 0$2;;
          0)        echo $2;;
          *)        die "bad padding" ;;
          esac
}

# hexprint number
#         display (base10) number as hexadecimal
#
hexprint()
{
          val="$(($1 + 0))"
          hex=
          set -- 0 1 2 3 4 5 6 7 8 9 a b c d e f
          while [ "$val" -gt 0 ]; do
                    eval hex=\${$(($val % 16 + 1))}\$hex
                    val="$(($val / 16))"
          done
          echo "${hex:-0}"
}

# linecount multiline_string
#         count the number of lines in the string
#
linecount()
{
          local IFS='
' # just a newline, no other white space between the quotes
          set -- $1
          echo $#
}

# nooutput -12 cmd [args...]
#         run a command with stdout and/or stderr ignored.
#         "nooutput -1 cmd" is like "cmd >/dev/null";
#         "nooutput -2 cmd" is like "{ cmd ; } 2>/dev/null";
#         "nooutput -12 cmd" is like "{ cmd ; } >/dev/null 2>&1";
#         except they should work even if /dev/null doesn't [yet] exist.
#
#         The "{...}" wrapper used in cases where stderr is redirected
#         serves to capture shell error messages such as "cmd: not found".
#
nooutput()
{
          local flags="$1" ; shift
          local junk
          case "$flags" in
          "-1")     junk="$( "$@" )" ;;
          "-2")     ( exec 4>&1 ; junk="$( { "$@" ; } 2>&1 1>&4 )" ) ;;
          "-12")    junk="$( { "$@" ; } 2>&1 )" ;;
          *)        warn "Incorrect use of nooutput" ;;
          esac
}

# check_pax path_to_pax
#         Check whether pax exists and supports the command line options
#         and input format that we will want to use.
#
check_pax()
{
          local pax="$1"
          echo ". type=dir optional" | nooutput -12 "${pax}" -r -w -M -pe .
}

# check_mtree path_to_mtree
#         Check whether mtree exists and supports the command line options
#         and input format that we will want to use.
#
check_mtree()
{
          local mtree="$1"
          echo ". type=dir optional" | nooutput -12 "${mtree}" -e -U
}

# setup args...
#         Parse command line arguments, exit on error.
#         Callers should shift $((OPTIND - 1)) afterwards.
#
setup()
{
          PATH=/sbin:/usr/sbin:/bin:/usr/bin:/rescue

          : ${HOST_SH:=sh}
          : ${TOOL_MKNOD:=mknod}
          : ${TOOL_MTREE:=mtree}
          : ${TOOL_PAX:=pax}
          status=0
          do_create_mfs=false
          do_force=false
          do_mknod=false
          do_pax=false
          do_mtree=false
          do_redirect=false
          do_specfile=false
          do_update=false
          opts=
          while getopts Mfm:p:st:u ch; do
                    # Note that $opts is only for options passed through to
                    # MAKEDEV.local, not for all options.
                    case ${ch} in
                    M)
                              # "-M" sets do_create_mfs;
                              # "-M -M" is for use from init(8), and sets do_redirect
                              do_redirect=$do_create_mfs
                              do_create_mfs=true
                              ;;
                    f)        do_force=true
                              opts="${opts} -f"
                              ;;
                    m)        TOOL_MKNOD=${OPTARG}
                              do_mknod=true
                              opts="${opts} -m ${OPTARG}"
                              ;;
                    p)        TOOL_PAX="${OPTARG}"
                              if check_pax "${TOOL_PAX}"; then
                                        do_pax=true
                                        # do not add this to $opts; we will later
                                        # add "-s" instead.
                              else
                                        warn "Ignored -p option:" \
                                                  "${TOOL_PAX} is missing or broken"
                                        do_mknod=true
                              fi
                              ;;
                    s)        do_specfile=true
                              opts="${opts} -s"
                              ;;
                    t)        TOOL_MTREE="${OPTARG}"
                              if check_mtree "${TOOL_MTREE}"; then
                                        do_mtree=true
                                        # do not add this to $opts; we will later
                                        # add "-s" instead.
                              else
                                        warn "Ignored -t option:" \
                                                  "${TOOL_MTREE} is missing or broken"
                                        do_mknod=true
                              fi
                              ;;
                    u)
                              do_update=true
                              opts="${opts} -u"
                              ;;
                    *)        usage ;;
                    esac
          done

          shift $((${OPTIND} - 1))
          [ $# -gt 0 ] || usage

          u_root="%uid_root%"
          u_uucp="%uid_uucp%"
          g_gpio="%gid__gpio%"
          g_kmem="%gid_kmem%"
          g_ntpd="%gid_ntpd%"
          g_nvmm="%gid_nvmm%"
          g_operator="%gid_operator%"
          g_wheel="%gid_wheel%"
          dialin=0
          dialout=524288
          callunit=262144

          # only allow read&write for owner by default
          umask 077

          # Set fdesc_mounted=true if the fdesc file system is mounted
          # on the current directory (typically "/dev").
          # Later, this will be used to suppress creation of device nodes
          # that are supplied by the fdesc file system.
          #
          fdesc_mounted=false
          if [ -d fd ]; then
                    # Parse the output from "mount -u -o nosuchoption .".
                    # We don't parse the output from df(1) because that's
                    # less likely to be available on install media.
                    #
                    # If the current directory is a mount point for the
                    # fdesc file system, then the expected output (whether
                    # or not the current user is root) is:
                    #         mount_fdesc: -o suchoption: option not supported.
                    #
                    # If the current directory is not a mount point, then
                    # the expected output is:
                    #         mount: .: unknown special file or file system.
                    #
                    # If we are not running on NetBSD, or mount(8) is not
                    # found, then we should get some other error message.
                    #
                    case "$({ LC_ALL=C mount -u -o nosuchoption . ; } 2>&1)" in
                    *mount_fdesc*)      fdesc_mounted=true ;;
                    esac
          fi

          # do_force requires mknod
          if $do_force; then
                    if $do_mtree || $do_pax || $do_specfile; then
                              die "-f option works only with mknod"
                    fi
                    do_mknod=true
          fi

          # do_force and do_update do not work together
          if $do_force && $do_update; then
                    die "-f and -u options do not work together"
          fi

          # If no explicit method was specified on the command line or
          # forced above, then use one of mtree, pax, or mknod, in that
          # order of preference.
          #
          # mtree is preferred because it's fast and designed for the
          # purpose.  However, it's unlikely to be available early in the
          # boot sequence, when init(8) may invoke MAKEDEV(8).
          #
          # pax is usually acceptable, and it's likely to be available
          # early in the boot sequence.  However, it's much slower than mtree.
          #
          # mknod is just very slow, because the shell has to fork for
          # each device node.
          #

          case ",${do_mtree},,${do_pax},,${do_mknod},,${do_specfile}," in
          ( ,false,,false,,false,,false, )
                    if check_mtree "${TOOL_MTREE}"; then
                              do_mtree=true
                    elif check_pax "${TOOL_PAX}"; then
                              do_pax=true
                    else
                              do_mknod=true
                    fi
                    ;;
          ( *,true,*,true,* )
                    die "-m, -p, -s, and -t options are mutually exclusive"
                    ;;
          esac

          # If we are using mknod, then decide what options to pass it.
          MKNOD="${TOOL_MKNOD:-mknod} -F netbsd"
          if $do_mknod; then
                    if $do_force; then
                              MKNOD="${MKNOD} -R"
                    else
                              MKNOD="${MKNOD} -r"
                    fi
          fi

          # do_mtree or do_pax internally implies do_specfile.
          # This happens after checking for mutually-exclusive options.
          if $do_mtree || $do_pax && ! $do_specfile; then
                    do_specfile=true
                    opts="${opts} -s"
          fi
}

# specfile_before
#         This is called before the bulk of the makedev processing,
#         if do_specfile is set.
#
#         It simply prints ". type=dir optional", which must be the
#         first line of the specfile.
#
specfile_before()
{
          echo ". type=dir optional"
}

# mtree_after
#         Output in specfile format is piped into this function.
#
#         It uses mtree to create the devices defined in the specfile.
#
mtree_after()
{
          nooutput -1 "${TOOL_MTREE}" -e -U
}

# pax_after
#         Output in specfile format is piped into this function.
#
#         It uses pax to create the devices defined in the specfile.
#
pax_after()
{
          # Run pax in an empty directory, so it pays
          # attention only to the specfile, without being
          # confused by the existing contents of the target
          # directory.  Without this, pax would complain "file
          # would overwrite itself" for already-existing
          # device nodes.
          tmpdir=./tmp.$$
          mkdir "${tmpdir}" || die "can't create temporary directory"
          cd "${tmpdir}" || die "can't cd to temporary directory"
          "${TOOL_PAX}" -r -w -M -pe ..
          pax_status=$?
          cd .. # back to where we started
          rmdir "${tmpdir}"
          return $pax_status
}

# makedev_main makedev_name args...
#         Perform most of the work of the main program.  makedev_name
#         is typically "makedev", but may be the name of some other
#         makedev-like function (if we are invoked from MAKEDEV.local or
#         some other script).  The other args to this function are the
#         command line args with which the MAKEDEV (or MAKEDEV.local)
#         script was invoked.
#
makedev_main()
{
          local makedev="$1" ; shift

          # Parse command line args
          setup ${1+"$@"}
          shift $((${OPTIND}-1))

          if $do_create_mfs; then
                    # Count inodes and create mfs file system.
                    # The makedev call merely updates $count_nodes.
                    count_nodes=0
                    $makedev ${1+"$@"}
                    create_mfs_dev $count_nodes
                    unset count_nodes
          fi

          # Set before, middle, and after variables, so we can do
          # something like "( $before && $middle ) | $after",
          # except it will have to be more complex so we can capture
          # the exit status from both sides of the pipe.
          #
          if $do_specfile; then
                    before=specfile_before
          else
                    before=:
          fi
          middle='$makedev ${1+"$@"} && (exit $status)'
          if $do_mtree; then
                    after=mtree_after
          elif $do_pax ; then
                    after=pax_after
          else
                    after=cat
          fi

          # Actually perform the "{ $before && $middle } | $after" commands.
          #
          # We go to some trouble to ensure that, if any of
          # $before, $middle, or $after fails, then we also
          # exit with a non-zero status.
          #
          # In the block below, fd 3 is a copy of the original stdout,
          # and fd 4 goes to a subshell that analyses the exit status
          # status from the other commands.
          #
          {
                    exec 3>&1;
                    {
                              { eval "$before" && eval "$middle"; echo $? >&4; } \
                              | { eval "$after"; echo $? >&4; } \
                    } 4>&1 1>&3 \
                    | (
                              read status1;
                              read status2;
                              case "$status1,$status2" in
                              0,0) exit 0;;
                              0,*) exit $status2;;
                              *,*) exit $status1;;
                              esac
                    )
          }
}

#
# functions available to create nodes:
#
# mkdev name [b|c] major minor [mode{=600} [gid{=0} [uid{=0}]]]
#         create device node `name' with the appropriate permissions
#
# lndev src target
#         create a symlink from src to target
#
# makedir dir mode
#         create directory with appropriate mode
#

mkdev()
{
          if [ -n "$count_nodes" ]; then
                    count_nodes=$((count_nodes + 1))
                    return
          fi
          if $do_update && test -e $1; then
                    return
          fi
          if $do_specfile; then
                    case $2 in
                    b)        type=block ;;
                    c)        type=char ;;
                    esac
                    echo "./$1 type=${type} device=netbsd,$3,$4 mode=${5:-600} gid=${6:-$g_wheel} uid=${7:-$u_root}"
          else
                    ${MKNOD} -m ${5:-600} -g \#${6:-$g_wheel} -u \#${7:-$u_root} $1 $2 $3 $4
          fi
}

lndev()
{
          if [ -n "$count_nodes" ]; then
                    count_nodes=$((count_nodes + 1))
                    return
          fi
          if $do_update && test -e $2; then
                    return
          fi
          if $do_specfile; then
                    echo "./$2 type=link link=$1 mode=0700 gid=$g_wheel uid=$u_root"
          else
                    ln -f -s $1 $2
          fi
}

makedir()
{
          if [ -n "$count_nodes" ]; then
                    count_nodes=$((count_nodes + 1))
                    return
          fi
          if $do_update && test -e $1; then
                    return
          fi
          if $do_specfile; then
                    echo "./$1 type=dir mode=$2 gid=$g_wheel uid=$u_root"
          else
                    nooutput -2 mkdir $1
                    chmod $2 $1
          fi
}

warn()
{
          echo 1>&2 "$0: $*"
          status=1
}

die()
{
          echo 1>&2 "$0: $*"
          exit 1
}

# makedev special [...]
#         the main loop
#
makedev()
{

for i
do

case $i in

%MD_DEVICES%

all)
          makedev all_md
          makedev std fd ptm
          makedev dk0 dk1 dk2 dk3 dk4 dk5 dk6 dk7
          makedev dk8 dk9 dk10 dk11 dk12 dk13 dk14 dk15
          makedev dk16 dk17 dk18 dk19 dk20 dk21 dk22 dk23
          makedev dk24 dk25 dk26 dk27 dk28 dk29 dk30 dk31
          makedev ccd0 ccd1 ccd2 ccd3
          makedev cgd0 cgd1 cgd2 cgd3 cgd4 cgd5 cgd6 cgd7
          makedev fss0 fss1 fss2 fss3
          makedev md0 md1
          makedev raid0 raid1 raid2 raid3 raid4 raid5 raid6 raid7
          makedev vnd0 vnd1 vnd2 vnd3
          makedev iscsi0
          makedev bpf npf
          makedev tun0 tun1 tun2 tun3
          makedev ipl pf crypto random
          makedev lockstat clockctl cpuctl
          makedev atabus0 atabus1 atabus2 atabus3 atabus4 atabus5 atabus6 atabus7
          makedev srt0 srt1 srt2 srt3
          makedev tap tap0 tap1 tap2 tap3
          makedev gpio gpio0 gpio1 gpio2 gpio3 gpio4 gpio5 gpio6 gpio7
          makedev gpioirq0 gpiopps0
          makedev pad pad0 pad1 pad2 pad3
          makedev bthub
          makedev putter
          makedev drvctl
          makedev video
          makedev dtv
          makedev drm0 drm1 drm2 drm3
          makedev altmem
          makedev zfs
          makedev lua
          makedev hdmicec0
          makedev dtrace
          makedev veriexec
          makedev autofs
          makedev fw0 fw1 fw2 fw3
          makedev ipmi0
          makedev qemufwcfg
          makedev sht3xtemp0
          makedev scmd0
          makedev local # do this last
          ;;

init)
          # unless overridden by MD entry, this is equal to 'all'
          makedev all opty
          ;;

%MI_DEVICES_BEGIN%
audio)
          makedev audio0 audio1 audio2 audio3
          makedev hdaudio0 hdaudio1 hdaudio2 hdaudio3
          lndev sound0 sound
          lndev audio0 audio
          lndev mixer0 mixer
          lndev audioctl0 audioctl
          ;;

emcfan[0-9]*)
          unit=${i#emcfan}
          mkdev emcfan$unit c %emcfan_chr% $unit 660
          ;;

gpio)
          makedev gpio0 gpio1 gpio2 gpio3 gpio4 gpio5 gpio6 gpio7
          lndev gpio0 gpio
          ;;

gpioirq)
          makedev gpioirq0
          ;;

gpiopps)
          makedev gpiopps0
          lndev gpiopps0 gpiopps
          ;;

lua)
          makedev lua0
          lndev lua0 lua
          ;;

pad)
          makedev pad0 pad1 pad2 pad3
          lndev pad0 pad
          ;;

qemufwcfg)
          makedev qemufwcfg0
          lndev qemufwcfg0 qemufwcfg
          ;;

radio)
          makedev radio0 radio1
          lndev radio0 radio
          ;;

video)
          makedev video0 video1 video2 video3
          ;;

dtv)
          makedev dtv0 dtv1 dtv2 dtv3
          ;;

iic)
          makedev iic0 iic1 iic2 iic3
          ;;

altmem)
          makedev altmem0 altmem1
          ;;

ramdisk)
          makedev floppy md0
          ;;

sht3xtemp)
          makedev sht3xtemp0
          ;;

scmd)
          makedev scmd0
          ;;

usbs)
          makedev usb usb0 usb1 usb2 usb3 usb4 usb5 usb6 usb7
          makedev usb8 usb9 usb10 usb11 usb12 usb13 usb14 usb15
          makedev uhid0 uhid1 uhid2 uhid3 uhid4 uhid5
          makedev uhid6 uhid7 uhid8 uhid9 uhid10 uhid11
          makedev uhid12 uhid13 uhid14 uhid15
          makedev ulpt0 ulpt1
          makedev ttyU0 ttyU1 ttyU2 ttyU3 ttyU4 ttyU5 ttyU6 ttyU7
          makedev ttyY0 ttyY1
          makedev ttyHS0
          makedev utoppy0 utoppy1
          makedev ugen0 ugen1 ugen2 ugen3
          ;;

virtio)
          makedev ttyVI
          makedev vio9p0 vio9p1 vio9p2 vio9p3
          makedev vio9p4 vio9p5 vio9p6 vio9p7
          ;;

std)
          mkdev               console c %cons_chr% 0        600
          mkdev               constty c %cons_chr% 1        600
          mkdev               drum      c %swap_chr% 0      640 $g_kmem
          mkdev               kmem      c %mem_chr% 1       640 $g_kmem
          mkdev               mem       c %mem_chr% 0       640 $g_kmem
          mkdev               null      c %mem_chr% 2       666
          mkdev               full      c %mem_chr% 11      666
          mkdev               zero      c %mem_chr% 12      666
          mkdev               klog      c %log_chr% 0       600
          mkdev               ksyms     c %ksyms_chr% 0 440 $g_kmem
          mkdev               random    c %rnd_chr% 0       444
          mkdev               urandom   c %rnd_chr% 1       644
          if ! $fdesc_mounted; then
                    mkdev     tty       c %ctty_chr% 0                666
                    mkdev     stdin     c %filedesc_chr% 0  666
                    mkdev     stdout    c %filedesc_chr% 1  666
                    mkdev     stderr    c %filedesc_chr% 2  666
          fi
          ;;

usb)
          mkdev usb c %usb_chr% 255 444
          ;;

usb[0-9]*)
          unit=${i#usb}
          usb=usb$unit
          mkdev usb$unit c %usb_chr% $unit
          ;;

uhid[0-9]*)
          unit=${i#uhid}
          mkdev uhid$unit c %uhid_chr% $unit 666
          ;;

ulpt[0-9]*)
          unit=${i#ulpt}
          mkdev ulpt$unit c %ulpt_chr% $unit
          mkdev ulpn$unit c %ulpt_chr% $(($unit + 64))
          ;;

utoppy[0-9]*)
          unit=${i#utoppy}
          mkdev utoppy$unit c %utoppy_chr% $unit
          ;;

ttyHS[0-9]*)
          unit=${i#ttyHS}
          for j in 00 01 02 03 04 05 06 07 08 09 10
          do
                    base=$(($unit * 16 + ${j#0}))
                    mkdev ttyHS$unit.$j c %uhso_chr% $(($base + $dialin  )) "" "" $u_uucp
                    mkdev dtyHS$unit.$j c %uhso_chr% $(($base + $dialout )) "" "" $u_uucp
                    mkdev ctyHS$unit.$j c %uhso_chr% $(($base + $callunit)) "" "" $u_uucp
          done
          ;;

ttyY[0-9]*)
          unit=${i#ttyY}
          mkdev ttyY$unit c %ucycom_chr% $(($unit + $dialin  )) "" "" $u_uucp
          mkdev dtyY$unit c %ucycom_chr% $(($unit + $dialout )) "" "" $u_uucp
          mkdev ctyY$unit c %ucycom_chr% $(($unit + $callunit)) "" "" $u_uucp
          ;;

ucom[0-9]*)
          makedev ttyU${i#ucom}
          ;;

ttyU[0-9]*)
          unit=${i#ttyU}
          mkdev ttyU$unit c %ucom_chr% $(($unit + $dialin    )) "" "" $u_uucp
          mkdev dtyU$unit c %ucom_chr% $(($unit + $dialout )) "" "" $u_uucp
          mkdev ctyU$unit c %ucom_chr% $(($unit + $callunit)) "" "" $u_uucp
          ;;

ugen[0-9]*)
          unit=${i#ugen}
          for j in 00 01 02 03 04 05 06 07 08 09 10 11 12 13 14 15
          do
                    mkdev ugen$unit.$j c %ugen_chr% $(($unit * 16 + ${j#0}))
          done
          ;;

umcpmio[0-9]*)
        unit=${i#umcpmio}
        mkdev umcpmio${unit}ctl c %umcpmio_chr% $unit 660
        for j in 0 1 2
        do
                mkdev umcpmio${unit}GP$(($j + 1)) c %umcpmio_chr% $(($unit * 3 + 128 + ${j#})) 666
        done
        ;;

wscons)
          makedev ttyE0 ttyE1 ttyE2 ttyE3 ttyE4 ttyE5 ttyE6 ttyE7
          makedev ttyF0 ttyF1 ttyF2 ttyF3 ttyF4 ttyF5 ttyF6 ttyF7
          makedev ttyG0 ttyG1 ttyG2 ttyG3 ttyG4 ttyG5 ttyG6 ttyG7
          makedev ttyH0 ttyH1 ttyH2 ttyH3 ttyH4 ttyH5 ttyH6 ttyH7
          makedev wsmouse0 wsmouse1 wsmouse2 wsmouse3
          makedev wskbd0 wskbd1 wskbd2 wskbd3
          makedev wsmux0 wsmux1 wsmux2 wsmux3
          makedev wsmouse wskbd
          makedev ttyEcfg ttyEstat
          makedev ttyFcfg ttyFstat
          makedev ttyGcfg ttyGstat
          makedev ttyHcfg ttyHstat
          makedev wsfont
          ;;

wsmouse)
          mkdev wsmouse c %wsmux_chr% 0
          ;;

wskbd)
          mkdev wskbd c %wsmux_chr% 1
          ;;

wsmux[0-9]*)
          unit=${i#wsmux}
          mkdev wsmux$unit    c %wsmux_chr% $unit
          mkdev wsmuxctl$unit c %wsmux_chr% $(($unit + 128)) 200
          ;;

xenevt)
          mkdev xenevt c %xenevt_chr% 0
          ;;

xsd_kva)
          mkdev xsd_kva c %xenevt_chr% 1
          ;;

xencons)
          mkdev xencons c %xencons_chr% 0
          ;;

ttyEstat)
          mkdev ttyEstat c %wsdisplay_chr% 254
          ;;

ttyEcfg)
          mkdev ttyEcfg c %wsdisplay_chr% 255
          ;;

ttyE[0-9]*)
          unit=${i#ttyE}
          mkdev ttyE$unit c %wsdisplay_chr% $unit
          ;;

ttyFstat)
          mkdev ttyFstat c %wsdisplay_chr% 510
          ;;

ttyFcfg)
          mkdev ttyFcfg c %wsdisplay_chr% 511
          ;;

ttyF[0-9]*)
          unit=${i#ttyF}
          mkdev ttyF$unit c %wsdisplay_chr% $(($unit + 256))
          ;;

ttyGstat)
          mkdev ttyGstat c %wsdisplay_chr% 766
          ;;

ttyGcfg)
          mkdev ttyGcfg c %wsdisplay_chr% 767
          ;;

ttyG[0-9]*)
          unit=${i#ttyG}
          mkdev ttyG$unit c %wsdisplay_chr% $(($unit + 512))
          ;;

ttyHstat)
          mkdev ttyHstat c %wsdisplay_chr% 1022
          ;;

ttyHcfg)
          mkdev ttyHcfg c %wsdisplay_chr% 1023
          ;;

ttyH[0-9]*)
          unit=${i#ttyH}
          mkdev ttyH$unit c %wsdisplay_chr% $(($unit + 768))
          ;;

wsmouse[0-9]*)
          unit=${i#wsmouse}
          mkdev wsmouse$unit c %wsmouse_chr% $unit
          ;;

wskbd[0-9]*)
          unit=${i#wskbd}
          mkdev wskbd$unit c %wskbd_chr% $unit
          ;;

fd)
          if ! $fdesc_mounted; then
                    # Create the "fd" subdirectory, and devices "fd/0" to "fd/63"
                    makedir fd 755
                    n=0
                    while [ $n -lt 64 ]
                    do
                              mkdev fd/$n c %filedesc_chr% $n 666
                              n=$(($n + 1))
                    done
          fi
          ;;

wt[0-9]*)
          name=wt;  unit=${i#wt};       chr=%wt_chr%;       blk=%wt_blk%
          for sub in $unit $(($unit+8)) $(($unit+16))
          do
                    mkdev $name$sub               b $blk $(($sub + 0)) 660 $g_operator
                    mkdev n$name$sub    b $blk $(($sub + 4)) 660 $g_operator
                    mkdev r$name$sub    c $chr $(($sub + 0)) 660 $g_operator
                    mkdev nr$name$sub   c $chr $(($sub + 4)) 660 $g_operator
          done
          ;;

md[0-9]*)
          makedisk_minimal md ${i#md} %md_blk% %md_chr%
          ;;

fss[0-9]*)
          name=fss; unit=${i#fss};      blk=%fss_blk%;      chr=%fss_chr%
          mkdev $name$unit    b $blk $unit 660 $g_operator
          mkdev r$name$unit   c $chr $unit 660 $g_operator
          ;;

ss[0-9]*)
          name=ss;  unit=${i#ss};       chr=%ss_chr%
          mkdev $name$unit    c $chr $(($unit * 16 + 0)) 640 $g_operator
          mkdev n$name$unit   c $chr $(($unit * 16 + 1)) 640 $g_operator
          mkdev en$name$unit  c $chr $(($unit * 16 + 3)) 640 $g_operator
          ;;

ccd[0-9]*|cgd[0-9]*|raid[0-9]*|vnd[0-9]*)
          case $i in
          ccd*)     name=ccd; unit=${i#ccd};      blk=%ccd_blk%;      chr=%ccd_chr%;;
          cgd*)     name=cgd; unit=${i#cgd};      blk=%cgd_blk%;      chr=%cgd_chr%;;
          raid*)    name=raid;          unit=${i#raid}; blk=%raid_blk%; chr=%raid_chr%;;
          vnd*)     name=vnd; unit=${i#vnd};      blk=%vnd_blk%;      chr=%vnd_chr%;;
          esac
          %MKDISK% $name $unit $blk $chr
          ;;

sd[0-9]*)
          name=sd; unit=${i#sd};        blk=%sd_blk%;       chr=%sd_chr%
          %MKDISK% $name $unit $blk $chr
          ;;

ace[0-9]*)
          name=ace; unit=${i#ace};      blk=%ace_blk%;                chr=%ace_chr%
          %MKDISK% $name $unit $blk $chr
          ;;

eflash[0-9]*)
          name=eflash; unit=${i#eflash};          blk=%eflash_blk%;   chr=%eflash_chr%
          %MKDISK% $name $unit $blk $chr
          ;;

wd[0-9]*)
          name=wd; unit=${i#wd}; blk=%wd_blk%; chr=%wd_chr%
          %MKDISK% $name $unit $blk $chr
          ;;

fd[0-9]*)
          name=fd; unit=${i#fd}; blk=%fd_blk%; chr=%fd_chr%
          %MKDISK% $name $unit $blk $chr
          ;;

ld[0-9]*)
          name=ld; unit=${i#ld}; blk=%ld_blk%; chr=%ld_chr%
          %MKDISK% $name $unit $blk $chr
          ;;

flash[0-9]*)
          unit=${i#flash}
          flash=flash$unit
          mkdev flash$unit b %flash_blk% $unit
          mkdev rflash$unit c %flash_chr% $unit
          ;;

spiflash[0-9]*)
          unit=${i#spiflash}
          spiflash=spiflash$unit
          mkdev spiflash$unit b %spiflash_blk% $unit
          mkdev rspiflash$unit c %spiflash_chr% $unit
          ;;

altmem[0-9]*)
          name=altmem; unit=${i#altmem}; blk=%altmem_blk%; chr=%altmem_chr%
          %MKDISK% $name $unit $blk $chr
          ;;

bio)
          mkdev bio c %bio_chr% 0
          ;;

ed[0-9]*)
          name=ed; unit=${i#ed}; blk=%ed_blk%; chr=%ed_chr%
          %MKDISK% $name $unit $blk $chr
          ;;

ofdisk[0-9]*)
          name=ofdisk; unit=${i#ofdisk}; blk=%ofdisk_blk%; chr=%ofdisk_chr%
          %MKDISK% $name $unit $blk $chr
          ;;

xbd[0-9]*)
          name=xbd; unit=${i#xbd}; blk=%xbd_blk%; chr=%xbd_chr%
          %MKDISK% $name $unit $blk $chr
          ;;

dk[0-9]*)
          name=dk; unit=${i#dk}; blk=%dk_blk%; chr=%dk_chr%
          mkdev r$name$unit c $chr $unit 0640 $g_operator
          mkdev $name$unit b $blk  $unit 0640 $g_operator
          ;;

tprof)
          mkdev tprof c %tprof_chr% 0
          ;;

ttyCY[0-9]*)
          # Each unit number creates 32 pairs of {tty,dty} device nodes:
          # ttyCY0 => device nodes [td]tyCY000 to [td]tyCY031;
          # ttyCY1 => device nodes [td]tyCY032 to [td]tyCY063;
          name=tyCY; chr=%cy_chr%; off=32
          unit=${i#t${name}}
          minor=$(($unit * $off))
          eminor=$(($minor + $off))
          while [ $minor -lt $eminor ]
          do
                    nminor=000$minor
                    nminor=${nminor#${nminor%???}}
                    mkdev t$name$nminor c $chr $(($minor + $dialin )) "" "" $u_uucp
                    mkdev d$name$nminor c $chr $(($minor + $dialout)) "" "" $u_uucp
                    minor=$(($minor + 1))
          done
          ;;

ttyCZ[0-9]*)
          # Each unit number creates 64 pairs of {tty,dty} device nodes:
          # ttyCZ0 => device nodes [td]tyCZ0000 to [td]tyCZ0063;
          # ttyCZ1 => device nodes [td]tyCZ0064 to [td]tyCZ0127;
          name=tyCZ; chr=%cz_chr%; off=64
          unit=${i#t${name}}
          minor=$(($unit * $off))
          eminor=$(($minor + $off))
          while [ $minor -lt $eminor ]
          do
                    nminor=0000$minor
                    nminor=${nminor#${nminor%????}}
                    mkdev t$name$nminor c $chr $(($minor + $dialin )) "" "" $u_uucp
                    mkdev d$name$nminor c $chr $(($minor + $dialout)) "" "" $u_uucp
                    minor=$(($minor + 1))
          done
          ;;


tty[0-9]|tty0[0-9])
          # some archs have built-in zstty (major %zstty_chr%) instead
          # of NS16550; create ttyZ* and hardlink as [dt]ty0*; this
          # needs to be before com entry, for archs which have both
          unit=${i#tty}
          unit=$(($unit + 0))
          makedev ttyZ${unit}
          lndev ttyZ$unit tty0${unit}
          lndev dtyZ$unit dty0${unit}
          ;;

tty[0-9]*)
          unit=${i#tty}
          ounit=00$unit
          ounit=${ounit#${ounit%??}}
          mkdev tty$ounit c %com_chr% $(($unit + $dialin )) "" "" $u_uucp
          mkdev dty$ounit c %com_chr% $(($unit + $dialout)) "" "" $u_uucp
          ;;

ttyC[0-9]*)
                    # some archs call com_chr ttyC traditionally
          unit=${i#ttyC}; name=ttyC; dname=dtyC; chr=%com_chr%
          mkdev  $name$unit c $chr $(($unit + $dialin )) "" "" $u_uucp
          mkdev $dname$unit c $chr $(($unit + $dialout)) "" "" $u_uucp
          ;;

ttyh[0-9]*)
          unit=${i#ttyh}; name=ttyh; dname=dtyh; chr=%sabtty_chr%
          mkdev  $name$unit c $chr $(($unit + $dialin )) "" "" $u_uucp
          mkdev $dname$unit c $chr $(($unit + $dialout)) "" "" $u_uucp
          ;;

ttyTX[0-9]*)
          unit=${i#ttyTX}; name=ttyTX0; dname=dtyTX0; chr=%txcom_chr%
          mkdev  $name$unit c $chr $(($unit + $dialin )) "" "" $u_uucp
          mkdev $dname$unit c $chr $(($unit + $dialout)) "" "" $u_uucp
          ;;

ttyZ[0-9]*)
          unit=${i#ttyZ}; name=ttyZ; dname=dtyZ; chr=%zstty_chr%
          mkdev  $name$unit c $chr $(($unit + $dialin )) "" "" $u_uucp
          mkdev $dname$unit c $chr $(($unit + $dialout)) "" "" $u_uucp
          ;;

opty)
          # Create 16 device nodes, [pt]typ0 to [pt]typf,
          # same as "MAKEDEV pty0".
          for j in 0 1 2 3 4 5 6 7 8 9 a b c d e f
          do
                    case $j in
                    [0-9])    jn=$j ;;
                    a)        jn=10 ;;
                    b)        jn=11 ;;
                    c)        jn=12 ;;
                    d)        jn=13 ;;
                    e)        jn=14 ;;
                    f)        jn=15 ;;
                    esac
                    mkdev ttyp$j c %pts_chr% $jn 666
                    mkdev ptyp$j c %ptc_chr% $jn 666
          done
          ;;

pty[0-9]*)
          # Each unit number creates up to 16 pairs of {tty,pty} device nodes:
          # pty0 => 16 pairs, [tp]typ0 to [tp]typf
          # pty1 => 16 pairs, [tp]tyq0 to [tp]tyqf
          # pty16 => 16 pairs, [tp]typg to [tp]typv
          # pty17 => 16 pairs, [tp]typw to [tp]typL
          # pty18 => 14 pairs, [tp]typM to [tp]typZ
          warn "$i: creating BSD style tty nodes with ptyfs is a security issue"
          class=${i#pty}
          d1="p q r s t u v w x y z P Q R S T"
          if [ "$class" -ge 64 ]
          then
                    warn "$i: pty unit must be between 0 and 63"
                    continue
          elif [ "$class" -lt 16 ]
          then
                    # pty[p-zP-T][0-9a-f]
                    offset=0
                    mult=0
                    d2="0 1 2 3 4 5 6 7 8 9 a b c d e f"
          else
                    # pty[p-zP-T][g-zA-Z]
                    class=$(($class - 16))
                    offset=256
                    mult=2
                    d2="g h i j k l m n o p q r s t u v w x y z A B C D E F G H I J K L M N O P Q R S T U V W X Y Z"
          fi
          start=$(($class * 16))
          set -- $d2
          nt=$#
          s1=$(($start / $nt))
          set -- $d1
          shift $s1
          t1=$1
          if [ "$t1" = v ]; then
                    warn "$i: pty unit conflicts with console ttyv0 device"
                    continue
          fi
          s2=$(($start % ($nt - $s1 * $mult)))
          set -- $d2
          shift $s2
          t2=$1
          unit=$(($start + $offset - $s1 * $mult))
          end=$(($unit + 16))
          while [ "$unit" -lt "$end" ]
          do
                    mkdev tty$t1$t2 c %pts_chr% $unit 666
                    mkdev pty$t1$t2 c %ptc_chr% $unit 666
                    shift
                    t2=$1
                    if [ -z "$t2" ]
                    then
                              break
                    fi
                    unit=$(($unit + 1))
          done
          ;;

stic[0-9]*)
          unit=${i#stic}
          mkdev stic$unit c %stic_chr% $unit
          ;;

st[0-9]*)
          name=st;  unit=${i#st};       chr=%st_chr%;       blk=%st_blk%
          mkdev $name$unit    b $blk $(($unit * 16 + 0)) 660 $g_operator
          mkdev n$name$unit   b $blk $(($unit * 16 + 1)) 660 $g_operator
          mkdev e$name$unit   b $blk $(($unit * 16 + 2)) 660 $g_operator
          mkdev en$name$unit  b $blk $(($unit * 16 + 3)) 660 $g_operator
          mkdev r$name$unit   c $chr $(($unit * 16 + 0)) 660 $g_operator
          mkdev nr$name$unit  c $chr $(($unit * 16 + 1)) 660 $g_operator
          mkdev er$name$unit  c $chr $(($unit * 16 + 2)) 660 $g_operator
          mkdev enr$name$unit c $chr $(($unit * 16 + 3)) 660 $g_operator
          ;;

ses[0-9]*|ch[0-9]*|uk[0-9]*)
          case $i in
          ch*)      name=ch;  unit=${i#ch};       chr=%ch_chr%;;
          uk*)      name=uk;  unit=${i#uk};       chr=%uk_chr%;;
          ses*)     name=ses; unit=${i#ses};      chr=%ses_chr%;;
          esac
          mkdev $name$unit c $chr $unit 640 $g_operator
          ;;

cd[0-9]*)
          makedisk_minimal cd ${i#cd} %cd_blk% %cd_chr%
          ;;

mcd[0-9]*)
          makedisk_minimal mcd ${i#mcd} %mcd_blk% %mcd_chr%
          ;;

gdrom[0-9]*)
          makedisk_minimal gdrom ${i#gdrom} %gdrom_blk% %gdrom_chr%
          ;;

lpt[0-9]*|lpa[0-9]*)
          case $i in
          lpt*) name=lpt; unit=${i#lpt};          chr=%lpt_chr%;      flags=0;;
          lpa*) name=lpa; unit=${i#lpa};          chr=%lpt_chr%;      flags=128;;
          esac
          mkdev $name$unit c $chr $(($unit + $flags))
          mkdev lpt${unit}ctl c $chr $(($unit + 256))
          ;;

bpf)
          mkdev bpf c %bpf_chr% 0
          lndev bpf bpf0
          ;;

npf)
          mkdev npf c %npf_chr% 0
          ;;

bthub)
          mkdev bthub c %bthub_chr% 0
          ;;

tun[0-9]*)
          unit=${i#tun}
          mkdev tun$unit c %tun_chr% $unit
          ;;

joy[0-9]*)
          unit=${i#joy}
          mkdev joy$unit c %joy_chr% $unit
          ;;

ipl)
          mkdev ipl c %ipl_chr% 0
          mkdev ipnat         c %ipl_chr% 1
          mkdev ipstate       c %ipl_chr% 2
          mkdev ipauth        c %ipl_chr% 3
          mkdev ipsync        c %ipl_chr% 4
          mkdev ipscan        c %ipl_chr% 5
          mkdev iplookup      c %ipl_chr% 6
          ;;

pf)
          mkdev pf c %pf_chr% 0
          ;;

crypto)
          mkdev crypto c %crypto_chr% 0 666
          ;;

cmos)
          mkdev cmos c %cmos_chr% 0 644
          ;;

speaker)
          mkdev speaker c %spkr_chr% 0
          ;;

lockstat)
          mkdev lockstat c %lockstat_chr% 0
          ;;

cpuctl)
          mkdev cpuctl c %cpuctl_chr% 0 666
          ;;

audio|audio[0-9]*)
          unit=${i#audio}
          audio=audio$unit
          sound=sound$unit
          mixer=mixer$unit
          audioctl=audioctl$unit
          : ${unit:-0}
          mkdev $sound        c %audio_chr% $(($unit + 0))  666
          mkdev $audio        c %audio_chr% $(($unit + 128))          666
          mkdev $mixer        c %audio_chr% $(($unit + 16)) 666
          mkdev $audioctl c %audio_chr% $(($unit + 192))    666
          ;;

hdaudio[0-9]*)
          unit=${i#hdaudio}
          mkdev hdaudio$unit c %hdaudio_chr% $unit 644
          ;;

hdmicec[0-9]*)
          uint=${i#hdmicec}
          mkdev hdmicec$unit c %hdmicec_chr% $unit 644
          ;;

gpio[0-9]*)
          unit=${i#gpio}
          mkdev gpio$unit c %gpio_chr% $unit 664 $g_gpio
          ;;

gpioirq[0-9]*)
          unit=${i#gpioirq}
          mkdev gpioirq$unit c %gpioirq_chr% $unit 444 $g_gpio
          ;;

gpiopps[0-9]*)
          unit=${i#gpiopps}
          mkdev gpiopps$unit c %gpiopps_chr% $unit 664 $g_gpio
          ;;

lua[0-9]*)
          unit=${i#lua}
          mkdev lua$unit c %lua_chr% $unit 664
          ;;

rmidi[0-9]*)
          unit=${i#rmidi}
          mkdev rmidi$unit c %midi_chr% $unit 666
          ;;

music|music[0-9]*)
          unit=${i#music}
          : ${unit:-0}
          mkdev music$unit     c %sequencer_chr% $(($unit + 0))       666
          mkdev sequencer$unit c %sequencer_chr% $(($unit + 128)) 666
          ;;

radio|radio[0-9]*)
          unit=${i#radio}
          : ${unit:-0}
          mkdev radio$unit c %radio_chr% $unit 666
          ;;

video|video[0-9]*)
          unit=${i#video}
          : ${unit:-0}
          mkdev video$unit c %video_chr% $unit 666
          ;;

dtv[0-9]*)
          unit=${i#dtv}
          makedir dvb 755
          makedir dvb/adapter$unit 755
          mkdev dvb/adapter$unit/frontend0 c %dtv_chr% $(($unit + 0)) 666
          mkdev dvb/adapter$unit/demux0 c %dtv_chr% $(($unit + 16)) 666
          mkdev dvb/adapter$unit/dvr0 c %dtv_chr% $(($unit + 32)) 666
          ;;

iic[0-9]*)
          unit=${i#iic}
          : ${unit:-0}
          mkdev iic$unit c %iic_chr% $unit 600
          ;;

spi[0-9]*)
          unit=${i#spi}
          : ${unit:-0}
          mkdev spi$unit c %spi_chr% $unit 600
          ;;

amr[0-9]*)
          unit=${i#amr}
          mkdev amr$unit c %amr_chr% $unit
          ;;

apm)
          mkdev apm c %apm_chr% 0 644
          mkdev apmctl        c %apm_chr% 8 644
          ;;

apm)
                    # hpcmips uses `apmdev_chr' instead of `apm_chr'
          mkdev apm c %apmdev_chr% 0 644
          mkdev apmctl        c %apmdev_chr% 8 644
          ;;

random)
          mkdev random        c %rnd_chr% 0 444
          mkdev urandom       c %rnd_chr% 1 644
          ;;

cfs)
          makedev cfs0
          ;;

cfs[0-9]*)
          unit=${i#cfs}
          mkdev cfs$unit c %vcoda_chr% $unit
          ;;

sysmon)
          mkdev sysmon        c %sysmon_chr% 0 644
          mkdev watchdog      c %sysmon_chr% 1 644
          mkdev power         c %sysmon_chr% 2 640
          ;;

scsibus[0-9]*)
          unit=${i#scsibus}
          mkdev scsibus$unit c %scsibus_chr% $unit 644
          ;;

bktr)
          makedev bktr0 bktr1
          lndev     bktr0     bktr
          lndev     tuner0    tuner
          lndev     vbi0      vbi
          ;;

bktr[0-9]*)
          unit=${i#bktr}
          mkdev bktr$unit               c %bktr_chr% $(($unit + 0))   444
          mkdev tuner$unit    c %bktr_chr% $(($unit + 16))  444
          mkdev vbi$unit                c %bktr_chr% $(($unit + 32))  444
          ;;

io)
          mkdev               io        c %mem_chr% 14      600
          ;;

iop[0-9]*)
          unit=${i#iop}
          mkdev iop$unit c %iop_chr% $unit
          ;;

mfi[0-9]*)
          unit=${i#mfi}
          mkdev mfi$unit c %mfi_chr% $unit
          ;;

mlx[0-9]*)
          unit=${i#mlx}
          mkdev mlx$unit c %mlx_chr% $unit
          ;;

mly[0-9]*)
          unit=${i#mly}
          mkdev mly$unit c %mly_chr% $unit
          ;;

twa[0-9]*)
          unit=${i#twa}
          mkdev twa$unit c %twa_chr% $unit
          ;;

twe[0-9]*)
          unit=${i#twe}
          mkdev twe$unit c %twe_chr% $unit
          ;;

icp[0-9]*)
          unit=${i#icp}
          mkdev icp$unit c %icp_chr% $unit
          ;;

agp[0-9]*)
          unit=${i#agp}
          mkdev agp$unit c %agp_chr% $unit 644
          if [ "$unit" = "0" ]; then
                    lndev agp$unit agpgart
          fi
          ;;

pci[0-9]*)
          unit=${i#pci}
          mkdev pci$unit c %pci_chr% $unit 640
          ;;

dpti[0-9]*)
          unit=${i#dpti}
          mkdev dpti$unit c %dpti_chr% $unit
          ;;

dpt[0-9]*)
          unit=${i#dpt}
          mkdev dpt$unit c %dpt_chr% $unit
          ;;

altq)
          makedir altq 755
          unit=0
          for dev in altq cbq wfq afm fifoq red rio localq hfsc cdnr blue priq jobs
          do
                    mkdev altq/$dev c %altq_chr% $unit 644
                    unit=$(($unit + 1))
          done
          ;;

wsfont)
          mkdev wsfont c %wsfont_chr% 0 644
          ;;

cir[0-9]*)
          unit=${i#cir}
          mkdev cir$unit c %cir_chr% $unit 666
          ;;

irframe[0-9]*)
          unit=${i#irframe}
          mkdev irframe$unit c %irframe_chr% $unit
          ;;

fcom[0-9]*)
          unit=${i#fcom}
          mkdev fcom$unit c %fcom_chr% $unit "" "" $u_uucp
          ;;

openfirm)
          mkdev openfirm c %openfirm_chr% 0 444
          ;;

pad[0-9]*)
          unit=${i#pad}
          mkdev pad$unit c %pad_chr% $unit 444
          ;;

qemufwcfg[0-9]*)
          unit=${i#qemufwcfg}
          mkdev qemufwcfg$unit c %qemufwcfg_chr% $unit 660
          ;;

vio9p[0-9]*)
          unit=${i#vio9p}
          mkdev vio9p$unit c %vio9p_chr% $unit 660
          ;;

fault)
          mkdev fault c %fault_chr% 0
          ;;

nvram)
          mkdev nvram c %nvram_chr% 0 644
          ;;

rtc)
          mkdev rtc c %rtc_chr% 0 644
          ;;

clockctl)
          mkdev clockctl c %clockctl_chr% 0 660 $g_ntpd
          ;;

kttcp)
          mkdev kttcp c %kttcp_chr% 0
          ;;

dmoverio)
          mkdev dmoverio c %dmoverio_chr% 0 644
          ;;

veriexec)
          mkdev veriexec c %veriexec_chr% 0 600
          ;;

vhci[0-7]*)
          unit=${i#vhci}
          mkdev vhci$unit c %vhci_chr% $unit
          ;;

ttyv[0-9]*)
          unit=${i#ttyv}
          mkdev ttyv$unit c %pc_chr% $unit
          ;;

# arm, acorn32
ttyv[0-9]*)
          unit=${i#ttyv}
          mkdev ttyv$unit c %physcon_chr% $unit
          ;;

arcpp[0-9]*)
          unit=${i#arcpp}
          mkdev arcpp$unit c %arcpp_chr% $unit
          ;;

par[0-9]*)
          unit=${i#par}
          case $unit in
          0)
                    mkdev par$unit c %par_chr% $unit
                    ;;
          *)
                    warn "bad unit for par in: $i"
                    ;;
          esac
          ;;

cpi[0-9]*)
          unit=${i#cpi}
          mkdev cpi$unit c %cpi_chr% $unit
          ;;

ite[0-9]*|ttye[0-9]*)
          case $i in
          ite*)     unit=${i#ite};;
          ttye*)    unit=${i#ttye};;
          esac
          mkdev ttye$unit c %ite_chr% $unit
          ;;

pms[0-9]*)
          unit=${i#pms}
          mkdev pms$unit c %opms_chr% $unit
          ;;

qms[0-9]*)
          unit=${i#qms}
          mkdev qms$unit c %qms_chr% $unit
          ;;

lms[0-9]*)
          unit=${i#lms}
          mkdev lms$unit c %lms_chr% $unit
          ;;

mms[0-9]*)
          unit=${i#mms}
          mkdev mms$unit c %mms_chr% $unit
          ;;

mouse-pms[0-9]*|mouse-qms[0-9]*)
          case $i in
          mouse-pms*) name=pms ;;
          mouse-qms*) name=qms ;;
          esac
          unit=${i#mouse-${name}}
          lndev $name$unit mouse
          ;;

kbd)
          mkdev kbd c %kbd_chr% 0
          ;;

kbdctl)
          mkdev kbdctl c %kbd_chr% 1
          ;;

vidcconsole0)
          mkdev vidcconsole0 c %vidcconsole_chr% 0 640
          ;;

view[0-9]*)
          unit=${i#view}
          mkdev view$unit c %view_chr% $unit 666
          ;;

mouse[0-9]*)
          unit=${i#mouse}
          case $unit in
          0|1)
                    mkdev mouse$unit c %ms_chr% $unit 666
                    if [ $unit = 0 ]; then
                              lndev mouse$unit mouse
                    fi
                    ;;
          *)
                    warn "bad unit for mouse in: $i"
                    ;;
          esac
          ;;

panel)
          mkdev panel0 c %panel_chr% 0 660
          ;;

tslcd)
          mkdev tslcd0 c %tslcd_chr% 0 660
          ;;

ipty)
          mkdev ttyp0 c %pts_chr% 0 666
          mkdev ttyp1 c %pts_chr% 1 666
          mkdev ptyp0 c %ptc_chr% 0 666
          mkdev ptyp1 c %ptc_chr% 1 666
          ;;

ptm)
          makedir pts 755
          mkdev ptmx c %ptm_chr% 0 666
          mkdev ptm c %ptm_chr% 1 666
          ;;

grf[0-9]*)
          unit=${i#grf}
          mkdev grf$unit c %grf_chr% $unit 666
          ;;

etvme)
          mkdev etvme c %et_chr% 0
          ;;

leo[0-9]*)
          unit=${i#leo}
          mkdev leo$unit c %leo_chr% $unit
          ;;

scif[0-9]*)
          unit=${i#scif}
          mkdev scif$unit c %scif_chr% $(($unit + $dialin )) "" "" $u_uucp
          mkdev dscif$unit c %scif_chr% $(($unit + $dialout)) "" "" $u_uucp
          ;;

sci[0-9]*)
          unit=${i#sci}
          mkdev sci$unit c %sci_chr% $(($unit + $dialin )) "" "" $u_uucp
          mkdev dsci$unit c %sci_chr% $(($unit + $dialout)) "" "" $u_uucp
          ;;

maple[ABCD]|maple[ABCD][0-9]*)
          case $i in
          mapleA*) name="mapleA"; unit=0;;
          mapleB*) name="mapleB"; unit=1;;
          mapleC*) name="mapleC"; unit=2;;
          mapleD*) name="mapleD"; unit=3;;
          esac
          subunit=${i#$name}
          mkdev $name$subunit c %maple_chr% $(($unit * 8 + 0$subunit))
          ;;

mmem[0-9]*)
          unit=${i#mmem}
          for pt in 0         # 1 2 3 4 ... 255
          do
#                   mkdev mmem${unit}.${pt}a  b %mmem_blk% $(($unit * 4096 + $pt * 16 + 0)) 640 $g_operator
                    mkdev mmem${unit}.${pt}c  b %mmem_blk% $(($unit * 4096 + $pt * 16 + 2)) 640 $g_operator
#                   mkdev rmmem${unit}.${pt}a c %mmem_chr% $(($unit * 4096 + $pt * 16 + 0)) 640 $g_operator
                    mkdev rmmem${unit}.${pt}c c %mmem_chr% $(($unit * 4096 + $pt * 16 + 2)) 640 $g_operator
          done
          ;;

mlcd[0-9]*)
          unit=${i#mlcd}
          for pt in 0         # 1 2 3 4 ... 255
          do
                    mkdev mlcd${unit}.${pt} c %mlcd_chr% $(($unit * 256 + $pt)) 640 $g_operator
          done
          ;;

ixpcom[0-9]*)
          unit=${i#ixpcom}
          mkdev ixpcom$unit c %ixpcom_chr% $unit "" "" $u_uucp
          ;;

epcom[0-9]*)
          unit=${i#epcom}
          mkdev epcom$unit c %epcom_chr% $unit "" "" $u_uucp
          ;;

plcom[0-9]*)
          unit=${i#plcom}
          mkdev plcom$unit c %plcom_chr% $unit "" "" $u_uucp
          mkdev dplcom$unit c %plcom_chr% $(($unit + $dialout)) "" "" $u_uucp
          ;;

wmcom[0-9]*)
          unit=${i#wmcom}
          mkdev wmcom$unit c %wmcom_chr% $unit "" "" $u_uucp
          ;;

ucbsnd)
          mkdev ucbsnd c %ucbsnd_chr% 0 666
          ;;

adb)
          mkdev adb c %aed_chr% 0 666
          ;;

asc[0-9]*)
          unit=${i#asc}
          mkdev asc$unit c %asc_chr% $unit 666
          ;;

bwtwo[0-9]*)
          unit=${i#bwtwo}
          mkdev bwtwo$unit c %bwtwo_chr% $unit 666
          ;;

cgtwo[0-9]*)
          unit=${i#cgtwo}
          mkdev cgtwo$unit c %cgtwo_chr% $unit 666
          ;;

cgthree[0-9]*)
          unit=${i#cgthree}
          mkdev cgthree$unit c %cgthree_chr% $unit 666
          ;;

cgfour[0-9]*)
          unit=${i#cgfour}
          mkdev cgfour$unit c %cgfour_chr% $unit 666
          ;;

cgsix[0-9]*)
          unit=${i#cgsix}
          mkdev cgsix$unit c %cgsix_chr% $unit 666
          ;;

cgeight[0-9]*)
          unit=${i#cgeight}
          mkdev cgeight$unit c %cgeight_chr% $unit 666
          ;;

tcx[0-9]*)
          unit=${i#tcx}
          mkdev tcx$unit c %tcx_chr% $unit 666
          ;;

xd[0-9]*|xy[0-9]*)
          case $i in
          xd*)      name=xd; unit=${i#xd}; blk=%xd_blk%;    chr=%xd_chr%;;
          xy*)      name=xy; unit=${i#xy}; blk=%xy_blk%;    chr=%xy_chr%;;
          esac
          %MKDISK% $name $unit $blk $chr
          ;;

magma[0-9]*)
          unit=${i#magma}
          if [ 0$unit -gt 3 ]; then
                    warn "bad unit for $i: $unit"
                    break
          fi
          for j in 0 1 2 3 4 5 6 7 8 9 a b c d e f
          do
                    case $j in
                    [0-9])    jn=$j ;;
                    a)        jn=10 ;;
                    b)        jn=11 ;;
                    c)        jn=12 ;;
                    d)        jn=13 ;;
                    e)        jn=14 ;;
                    f)        jn=15 ;;
                    esac
                    mkdev tty$unit$j c %mtty_chr% $(($unit * 64 + $jn))
          done
          mkdev bpp${unit}0 c %mbpp_chr% $(($unit * 64 + 0))
          mkdev bpp${unit}1 c %mbpp_chr% $(($unit * 64 + 1))
          ;;

clcd[0-9]*)
          unit=${i#clcd}
          if [ 0$unit -gt 7 ]; then
                    warn "bad unit for $i: $unit"
                    break
          fi
          for j in 0 1 2 3 4 5 6 7
          do
                    mkdev ttyA$unit$j c %clcd_chr% $(($unit * 8 + $j + $dialin)) "" "" $u_uucp
                    mkdev dtyA$unit$j c %clcd_chr% $(($unit * 8 + $j + $dialout)) "" "" $u_uucp
          done
          ;;

spif[0-9]*)
          unit=${i#spif}
          if [ 0$unit -gt 3 ]; then
                    warn "bad unit for $i: $unit"
                    break
          fi
          for j in 0 1 2 3 4 5 6 7; do
                    mkdev ttyS$unit$j c %stty_chr% $(($unit * 64 + $j)) "" "" $u_uucp
          done
          mkdev bppS${unit}0 c %sbpp_chr% $(($unit * 64 + 0))
          mkdev bppS${unit}1 c %sbpp_chr% $(($unit * 64 + 1))
          ;;

bpp|bpp[0-9]*)
          unit=${i#bpp}
          mkdev bpp$unit c %bpp_chr% $(($unit + 0))
          ;;

tctrl[0-9]*)
          unit=${i#tctrl}
          mkdev tctrl$unit c %tctrl_chr% $unit 666
          ;;

bmd[0-9]*)
          unit=${i#bmd}
          mkdev bmd${unit}a  b %bmd_blk% $(($unit * 8 + 0)) 640 $g_operator
          mkdev bmd${unit}c  b %bmd_blk% $(($unit * 8 + 2)) 640 $g_operator
          mkdev rbmd${unit}a c %bmd_chr% $(($unit * 8 + 0)) 640 $g_operator
          mkdev rbmd${unit}c c %bmd_chr% $(($unit * 8 + 2)) 640 $g_operator
          ;;

sram)
          mkdev sram c %sram_chr% 0 644
          ;;

ttyS[0-9]*)
          unit=${i#ttyS}
          mkdev ttyS$unit c %sacom_chr% $(($unit + $dialin )) "" "" $u_uucp
          mkdev dtyS$unit c %sacom_chr% $(($unit + $dialout)) "" "" $u_uucp
          ;;

atabus[0-9]*)
          unit=${i#atabus}
          mkdev atabus$unit c %atabus_chr% $unit 644
          ;;

drm[0-9]*)
          unit=${i#drm}
          unit2=$((unit + 128))
          makedir dri 755
          mkdev dri/card$unit c %drm_chr% $unit 660
          mkdev dri/renderD${unit2} c %drm_chr% ${unit2} 660
          ;;

drvctl)
          mkdev drvctl c %drvctl_chr% 0 644
          ;;

isv)
          mkdev isv c %isv_chr% 0 644
          ;;

tap|tap[0-9]*)
          unit=${i#tap}
          case "$unit" in
          [0-9]*)
                    mkdev tap${unit} c %tap_chr% ${unit} 600
                    ;;
          "")
                    mkdev tap c %tap_chr% 0xfffff 600
                    ;;
          esac
          ;;

srt[0-9]*)
          unit=${i#srt}
          mkdev srt$unit c %srt_chr% $unit 600
          ;;

tpm)
          mkdev tpm c %tpm_chr% 0 600
          ;;

dtrace)
          makedir dtrace 755
          mkdev dtrace/dtrace c %dtrace_chr% 0 600
          ;;

fw[0-9]*)
          unit=${i#fw}
          for j in 0 1 2 3
          do
                    mkdev fw${unit}.${j} c %fw_chr% $((${unit} * 256 + ${j})) 660 ${g_operator}
                    mkdev fwmem${unit}.${j} c %fw_chr% $((65536 + ${unit} * 256 + ${j})) 660 ${g_operator}
          done
          ;;

# create putter device and symlinks for all subsystems using it
putter)
          mkdev putter c %putter_chr% 0 600
          mkdev pud c %putter_chr% 1 600
          lndev putter puffs
          ;;

zfs)
          mkdev zfs c %zfs_chr% 0 600
          makedir zpool 755
          ;;

iscsi[0-9]*)
          unit=${i#iscsi}
          mkdev iscsi${unit} c %iscsi_chr% $unit 600
          ;;

vchiq)
          mkdev vchiq c %vchiq_chr% 0 600
          ;;

nvme[0-9]*ns[0-9]*)
          unit=${i#nvme}
          unit=${unit%ns*}
          subunit=${i#nvme${unit}ns}
          if [ 0$subunit -le 0 ] || [ 0$subunit -ge 65536 ]; then
                    warn "bad nsid for $i: $subunit"
                    break
          fi
          mkdev nvme${unit}ns$subunit c %nvme_chr% $(($unit * 65536 + $subunit))
          ;;

nvme[0-9]*)
          unit=${i#nvme}
          mkdev nvme$unit c %nvme_chr% $(($unit * 65536))
          ;;

nvmm)
          mkdev nvmm c %nvmm_chr% 0 660 $g_nvmm
          ;;

autofs)
          mkdev autofs c %autofs_chr% 0 600
          ;;

kcov)
        mkdev kcov c %kcov_chr% 0
        ;;

ipmi[0-9]*)
          unit=${i#ipmi}
          mkdev ipmi${unit} c %ipmi_chr% $unit 600
          ;;

xmm[0-9])
          unit=${i#xmm}
          makedir xmm${unit} 755
          mkdev xmm${unit}/rpc c %wwanc_chr% $(($unit * 65536 + 1))
          mkdev ttyXMM${unit}0 c %wwanc_chr% $(($unit * 65536 + 2))
          mkdev ttyXMM${unit}1 c %wwanc_chr% $(($unit * 65536 + 4))
          ;;

acpi)
          mkdev acpi c %acpi_chr% 0
          ;;

smbios)
          mkdev smbios c %smbios_chr% 0
          ;;

efi)
          mkdev efi c %efi_chr% 0 660
          ;;

sht3xtemp[0-9]*)
          unit=${i#sht3xtemp}
          mkdev sht3xtemp$unit c %sht3xtemp_chr% $unit 664
          ;;

scmd[0-9]*)
          unit=${i#scmd}
          mkdev scmd$unit c %scmd_chr% $unit 666
          ;;

ttyVI[0-9][0-9])
          port=${i#ttyVI?}
          devunit=${i%$port}
          unit=${devunit#ttyVI}
          mkdev ttyVI$unit$port c %viocon_chr% $((16*$unit + $port))
          ;;

ttyVI)
          makedev ttyVI00 ttyVI10 ttyVI20 ttyVI30
          ;;

midevend)
%MI_DEVICES_END%
local)
          if [ -f "$0.local" ]; then
                    umask 0
                    if [ -n "$count_nodes" ]; then
                              count_nodes=$((count_nodes + \
                                  $(linecount "$("$HOST_SH" "$0.local" $opts -s all)") ))
                    else
                              "$HOST_SH" "$0.local" $opts all
                    fi
                    umask 077
          fi
          ;;

*)
          warn "$i: unknown device"
          ;;

esac
done

}


# three variants of disk partitions - max 8, max 16, max 16 with highpartoffset
# hack; only the one used by port is retained in final MAKEDEV script
# routine is called as:
# makedisk name unit blk chr
makedisk_p8()
{
          name="$1"; unit="$2"; blk="$3"; chr="$4"

          ro=%RAWDISK_OFF%
          mkdev ${name}${unit}          b $blk $(($unit * 8 + $ro))   640 $g_operator
          mkdev r${name}${unit}         c $chr $(($unit * 8 + $ro))   640 $g_operator

          mkdev ${name}${unit}a         b $blk $(($unit * 8 + 0))     640 $g_operator
          mkdev ${name}${unit}b         b $blk $(($unit * 8 + 1))     640 $g_operator
          mkdev ${name}${unit}c         b $blk $(($unit * 8 + 2))     640 $g_operator
          mkdev ${name}${unit}d         b $blk $(($unit * 8 + 3))     640 $g_operator
          mkdev ${name}${unit}e         b $blk $(($unit * 8 + 4))     640 $g_operator
          mkdev ${name}${unit}f         b $blk $(($unit * 8 + 5))     640 $g_operator
          mkdev ${name}${unit}g         b $blk $(($unit * 8 + 6))     640 $g_operator
          mkdev ${name}${unit}h         b $blk $(($unit * 8 + 7))     640 $g_operator
          mkdev r${name}${unit}a        c $chr $(($unit * 8 + 0))     640 $g_operator
          mkdev r${name}${unit}b        c $chr $(($unit * 8 + 1))     640 $g_operator
          mkdev r${name}${unit}c        c $chr $(($unit * 8 + 2))     640 $g_operator
          mkdev r${name}${unit}d        c $chr $(($unit * 8 + 3))     640 $g_operator
          mkdev r${name}${unit}e        c $chr $(($unit * 8 + 4))     640 $g_operator
          mkdev r${name}${unit}f        c $chr $(($unit * 8 + 5))     640 $g_operator
          mkdev r${name}${unit}g        c $chr $(($unit * 8 + 6))     640 $g_operator
          mkdev r${name}${unit}h        c $chr $(($unit * 8 + 7))     640 $g_operator
}

makedisk_p12high()
{
          ho=524280 # offset for partition 9 to 11 (same as ...p16high)
          name="$1"; unit="$2"; blk="$3"; chr="$4"

          ro=%RAWDISK_OFF%
          mkdev ${name}${unit}          b $blk $(($unit * 8 + $ro))   640 $g_operator
          mkdev r${name}${unit}         c $chr $(($unit * 8 + $ro))   640 $g_operator

          mkdev ${name}${unit}a         b $blk $(($unit * 8 + 0))     640 $g_operator
          mkdev ${name}${unit}b         b $blk $(($unit * 8 + 1))     640 $g_operator
          mkdev ${name}${unit}c         b $blk $(($unit * 8 + 2))     640 $g_operator
          mkdev ${name}${unit}d         b $blk $(($unit * 8 + 3))     640 $g_operator
          mkdev ${name}${unit}e         b $blk $(($unit * 8 + 4))     640 $g_operator
          mkdev ${name}${unit}f         b $blk $(($unit * 8 + 5))     640 $g_operator
          mkdev ${name}${unit}g         b $blk $(($unit * 8 + 6))     640 $g_operator
          mkdev ${name}${unit}h         b $blk $(($unit * 8 + 7))     640 $g_operator
          mkdev ${name}${unit}i         b $blk $(($unit * 8 + $ho + 8)) 640 $g_operator
          mkdev ${name}${unit}j         b $blk $(($unit * 8 + $ho + 9)) 640 $g_operator
          mkdev ${name}${unit}k         b $blk $(($unit * 8 + $ho + 10)) 640 $g_operator
          mkdev ${name}${unit}l         b $blk $(($unit * 8 + $ho + 11)) 640 $g_operator
          mkdev r${name}${unit}a        c $chr $(($unit * 8 + 0))     640 $g_operator
          mkdev r${name}${unit}b        c $chr $(($unit * 8 + 1))     640 $g_operator
          mkdev r${name}${unit}c        c $chr $(($unit * 8 + 2))     640 $g_operator
          mkdev r${name}${unit}d        c $chr $(($unit * 8 + 3))     640 $g_operator
          mkdev r${name}${unit}e        c $chr $(($unit * 8 + 4))     640 $g_operator
          mkdev r${name}${unit}f        c $chr $(($unit * 8 + 5))     640 $g_operator
          mkdev r${name}${unit}g        c $chr $(($unit * 8 + 6))     640 $g_operator
          mkdev r${name}${unit}h        c $chr $(($unit * 8 + 7))     640 $g_operator
          mkdev r${name}${unit}i        c $chr $(($unit * 8 + $ho + 8)) 640 $g_operator
          mkdev r${name}${unit}j        c $chr $(($unit * 8 + $ho + 9)) 640 $g_operator
          mkdev r${name}${unit}k        c $chr $(($unit * 8 + $ho + 10)) 640 $g_operator
          mkdev r${name}${unit}l        c $chr $(($unit * 8 + $ho + 11)) 640 $g_operator
}

makedisk_p16()
{
          name="$1"; unit="$2"; blk="$3"; chr="$4"

          ro=%RAWDISK_OFF%
          mkdev ${name}${unit}          b $blk $(($unit * 16 + $ro))  640 $g_operator
          mkdev r${name}${unit}         c $chr $(($unit * 16 + $ro))  640 $g_operator

          mkdev ${name}${unit}a         b $blk $(($unit * 16 + 0))    640 $g_operator
          mkdev ${name}${unit}b         b $blk $(($unit * 16 + 1))    640 $g_operator
          mkdev ${name}${unit}c         b $blk $(($unit * 16 + 2))    640 $g_operator
          mkdev ${name}${unit}d         b $blk $(($unit * 16 + 3))    640 $g_operator
          mkdev ${name}${unit}e         b $blk $(($unit * 16 + 4))    640 $g_operator
          mkdev ${name}${unit}f         b $blk $(($unit * 16 + 5))    640 $g_operator
          mkdev ${name}${unit}g         b $blk $(($unit * 16 + 6))    640 $g_operator
          mkdev ${name}${unit}h         b $blk $(($unit * 16 + 7))    640 $g_operator
          mkdev ${name}${unit}i         b $blk $(($unit * 16 + 8))    640 $g_operator
          mkdev ${name}${unit}j         b $blk $(($unit * 16 + 9))    640 $g_operator
          mkdev ${name}${unit}k         b $blk $(($unit * 16 + 10))   640 $g_operator
          mkdev ${name}${unit}l         b $blk $(($unit * 16 + 11))   640 $g_operator
          mkdev ${name}${unit}m         b $blk $(($unit * 16 + 12))   640 $g_operator
          mkdev ${name}${unit}n         b $blk $(($unit * 16 + 13))   640 $g_operator
          mkdev ${name}${unit}o         b $blk $(($unit * 16 + 14))   640 $g_operator
          mkdev ${name}${unit}p         b $blk $(($unit * 16 + 15))   640 $g_operator
          mkdev r${name}${unit}a        c $chr $(($unit * 16 + 0))    640 $g_operator
          mkdev r${name}${unit}b        c $chr $(($unit * 16 + 1))    640 $g_operator
          mkdev r${name}${unit}c        c $chr $(($unit * 16 + 2))    640 $g_operator
          mkdev r${name}${unit}d        c $chr $(($unit * 16 + 3))    640 $g_operator
          mkdev r${name}${unit}e        c $chr $(($unit * 16 + 4))    640 $g_operator
          mkdev r${name}${unit}f        c $chr $(($unit * 16 + 5))    640 $g_operator
          mkdev r${name}${unit}g        c $chr $(($unit * 16 + 6))    640 $g_operator
          mkdev r${name}${unit}h        c $chr $(($unit * 16 + 7))    640 $g_operator
          mkdev r${name}${unit}i        c $chr $(($unit * 16 + 8))    640 $g_operator
          mkdev r${name}${unit}j        c $chr $(($unit * 16 + 9))    640 $g_operator
          mkdev r${name}${unit}k        c $chr $(($unit * 16 + 10))   640 $g_operator
          mkdev r${name}${unit}l        c $chr $(($unit * 16 + 11))   640 $g_operator
          mkdev r${name}${unit}m        c $chr $(($unit * 16 + 12))   640 $g_operator
          mkdev r${name}${unit}n        c $chr $(($unit * 16 + 13))   640 $g_operator
          mkdev r${name}${unit}o        c $chr $(($unit * 16 + 14))   640 $g_operator
          mkdev r${name}${unit}p        c $chr $(($unit * 16 + 15))   640 $g_operator
}

makedisk_p16high()
{
          ho=524280 # offset for partition 9 to 16
          name="$1"; unit="$2"; blk="$3"; chr="$4"

          ro=%RAWDISK_OFF%
          mkdev ${name}${unit}          b $blk $(($unit * 8 + $ro))   640 $g_operator
          mkdev r${name}${unit}         c $chr $(($unit * 8 + $ro))   640 $g_operator

          mkdev ${name}${unit}a         b $blk $(($unit * 8 + 0))     640 $g_operator
          mkdev ${name}${unit}b         b $blk $(($unit * 8 + 1))     640 $g_operator
          mkdev ${name}${unit}c         b $blk $(($unit * 8 + 2))     640 $g_operator
          mkdev ${name}${unit}d         b $blk $(($unit * 8 + 3))     640 $g_operator
          mkdev ${name}${unit}e         b $blk $(($unit * 8 + 4))     640 $g_operator
          mkdev ${name}${unit}f         b $blk $(($unit * 8 + 5))     640 $g_operator
          mkdev ${name}${unit}g         b $blk $(($unit * 8 + 6))     640 $g_operator
          mkdev ${name}${unit}h         b $blk $(($unit * 8 + 7))     640 $g_operator
          mkdev ${name}${unit}i         b $blk $(($unit * 8 + $ho + 8)) 640 $g_operator
          mkdev ${name}${unit}j         b $blk $(($unit * 8 + $ho + 9)) 640 $g_operator
          mkdev ${name}${unit}k         b $blk $(($unit * 8 + $ho + 10)) 640 $g_operator
          mkdev ${name}${unit}l         b $blk $(($unit * 8 + $ho + 11)) 640 $g_operator
          mkdev ${name}${unit}m         b $blk $(($unit * 8 + $ho + 12)) 640 $g_operator
          mkdev ${name}${unit}n         b $blk $(($unit * 8 + $ho + 13)) 640 $g_operator
          mkdev ${name}${unit}o         b $blk $(($unit * 8 + $ho + 14)) 640 $g_operator
          mkdev ${name}${unit}p         b $blk $(($unit * 8 + $ho + 15)) 640 $g_operator
          mkdev r${name}${unit}a        c $chr $(($unit * 8 + 0))     640 $g_operator
          mkdev r${name}${unit}b        c $chr $(($unit * 8 + 1))     640 $g_operator
          mkdev r${name}${unit}c        c $chr $(($unit * 8 + 2))     640 $g_operator
          mkdev r${name}${unit}d        c $chr $(($unit * 8 + 3))     640 $g_operator
          mkdev r${name}${unit}e        c $chr $(($unit * 8 + 4))     640 $g_operator
          mkdev r${name}${unit}f        c $chr $(($unit * 8 + 5))     640 $g_operator
          mkdev r${name}${unit}g        c $chr $(($unit * 8 + 6))     640 $g_operator
          mkdev r${name}${unit}h        c $chr $(($unit * 8 + 7))     640 $g_operator
          mkdev r${name}${unit}i        c $chr $(($unit * 8 + $ho + 8)) 640 $g_operator
          mkdev r${name}${unit}j        c $chr $(($unit * 8 + $ho + 9)) 640 $g_operator
          mkdev r${name}${unit}k        c $chr $(($unit * 8 + $ho + 10)) 640 $g_operator
          mkdev r${name}${unit}l        c $chr $(($unit * 8 + $ho + 11)) 640 $g_operator
          mkdev r${name}${unit}m        c $chr $(($unit * 8 + $ho + 12)) 640 $g_operator
          mkdev r${name}${unit}n        c $chr $(($unit * 8 + $ho + 13)) 640 $g_operator
          mkdev r${name}${unit}o        c $chr $(($unit * 8 + $ho + 14)) 640 $g_operator
          mkdev r${name}${unit}p        c $chr $(($unit * 8 + $ho + 15)) 640 $g_operator
}

# make only the very few basic disk device nodes - 'a' partition
# and raw partition
makedisk_minimal()
{
          name=$1; unit=$2; blk=$3; chr=$4
          doff=%DISKMINOROFFSET%
          ro=%RAWDISK_OFF%
          rn=%RAWDISK_NAME%

          mkdev ${name}${unit}          b $blk $(($unit * $doff + $ro))         640 $g_operator
          mkdev r${name}${unit}         c $chr $(($unit * $doff + $ro))         640 $g_operator

          mkdev ${name}${unit}a         b $blk $(($unit * $doff + 0)) 640 $g_operator
          mkdev ${name}${unit}$rn b $blk $(($unit * $doff + $ro)) 640 $g_operator
          mkdev r${name}${unit}a        c $chr $(($unit * $doff + 0)) 640 $g_operator
          mkdev r${name}${unit}$rn c $chr $(($unit * $doff + $ro)) 640 $g_operator
}

# create_mfs_dev nodes
#         Create a memory file system for a given number of device nodes,
#         and mount it.  Attempts to use mount_tmpfs, or falls back to
#         mount_mfs.
#
#         If do_redirect, then also redirect output to the console.
#
create_mfs_dev()
{
          ndevnodes=${1-1200}
          dev_mountpoint=${PWD:-/dev}

          # Number of inodes is the specified number of device nodes, plus
          # a margin to allow for extra device nodes created later.
          ninode=$((ndevnodes * 11 / 10))
          # Add 2 reserved inodes (needed for both mfs and tmpfs), and round
          # up to a multiple of 32 (needed for mfs, not needed for tmpfs).
          ninode=$(( (ninode + 2 + 31) / 32 * 32 ))
          # Try tmpfs; if that fails try mfs.
          #
          # For tmpfs, allocate 16KB and 512 byte per node.
          # Actual requirements are much lower, but the size limit
          # is only intended to avoid accidental writing to /dev.
          fs_bytes=$((16384 + ninode * 512))
          if mount_tmpfs -s $fs_bytes -n $ninode -m 0755 \
                    -o union tmpfs "$dev_mountpoint"
          then
                    fstype=tmpfs
          else
                    # This file system size calculation is exact for mount_mfs(8)
                    # with 512-byte sectors.  40960 bytes (80 blocks) is the
                    # minimum size allowed by mount_mfs.
                    fs_bytes=$((8192 + 2 * 8192 + 4096 + ninode*512 + 8192))
                    [ "$fs_bytes" -lt 40960 ] && fs_bytes=40960
                    fs_blocks=$((fs_bytes/512))
                    if mount_mfs -b 4096 -f 512 -s $fs_blocks -n $ninode -p 0755 \
                        -o union swap "$dev_mountpoint"
                    then
                              fstype=mfs
                    else
                              die "Failed to create memory file system"
                    fi
          fi

          # Our current directory was in the lower file system; change it to
          # the newly mounted upper file system.
          cd "$dev_mountpoint"

          if $do_redirect; then
                    # Redirect stdout and stderr to console
                    ${MKNOD} -m 600 -g 0 -u 0 temp_console c %CONSOLE_CMAJOR% 0
                    exec >temp_console 2>&1
                    rm temp_console
          fi

          echo "Created $fstype $dev_mountpoint" \
                    "($fs_bytes byte, $ninode inodes)"
}

#
# MAIN: If MAKEDEV_AS_LIBRARY is set, then we are being used as a
# function library, so just return.  Otherwise, do all the real work.
#
[ -n "${MAKEDEV_AS_LIBRARY}" ] && return
makedev_main makedev ${1+"$@"}