#!/bin/sh - # # $OpenBSD: MAKEDEV,v 1.29 1997/06/06 09:53:52 grr Exp $ # # Copyright (c) 1990 The Regents of the University of California. # 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. # 3. 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, Berkeley and its contributors. # 4. 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. # # @(#)MAKEDEV 5.5 (Berkeley) 5/28/91 # # Device "make" file. Valid arguments: # std standard devices # local configuration specific devices # Tapes: # st* ? tape # Disks: # sd* SCSI disks # cd* SCSI cdrom drives # st* SCSI tape # ch* SCSI changer # uk* unknown SCSI # ss* SCSI scanners # xy* Xylogic 450/451 disks # rd* "ramdisk" pseudo-disks # xd* Xylogic 753/7053 disks # fd* Floppies # vnd* "file" pseudo-disks # ccd* concatenated disk devices # Pseudo terminals: # pty* set of 16 master and slave pseudo terminals # Printers: # Call units: # Special purpose devices: # audio # openprom # bwtwo* # cgthree* # cgfour* # cgsix* # cgeight* # bpf* packet filter # lkm loadable kernel modules interface # tun* network tunnel driver # *random random data source PATH=/sbin:/bin/:/usr/bin:/usr/sbin:/usr/etc this=$0 umask 77 case "$os" in # set os in the environment if not OpenBSD SunOS) add () { expr $1 + $2 } mult () { expr $1 '*' $2 } hex () { case $1 in [0-9]) echo $1;; 10) echo a;; 11) echo b;; 12) echo c;; 13) echo d;; 14) echo e;; 15) echo f;; esac } trunc () { expr $1 : $2'\(.*\)' } unt () { expr $1 : '[a-z]*\([0-9]*\)[a-p]*' } ;; *) add () { echo "$(( $1 + $2 ))" } mult () { echo "$(( $1 * $2 ))" } hex () { case $1 in [0-9]) echo -n $1 ;; 10) echo -n a;; 11) echo -n b;; 12) echo -n c;; 13) echo -n d;; 14) echo -n e;; 15) echo -n f;; esac } trunc () { # XXX pdksh can't seem to deal with locally scoped variables # in ${foo#$bar} expansions arg1="$1" arg2="$2" echo ${arg1#$arg2} } unt () { # XXX pdksh can't seem to deal with locally scoped variables # in ${foo#$bar} expansions arg1="$1" if [ "${arg1#xy}" != "$arg1" ] then unt=${arg1#xy} else unt=${arg1#*d} fi echo ${unt%*[a-p]} } ;; esac for i do unit=`expr $i : '[a-z][a-z]*\([0-9][0-9]*\)'` [ "$unit" ] || unit=0 case $i in all) sh ${this} std sd0 sd1 sd2 sd3 sd4 xd0 xd1 xd2 xd3 xy0 xy1 xy2 xy3 sh ${this} cd0 st0 st1 rd0 sh ${this} fd0 fdB0 fdC0 fdD0 fdE0 fdF0 fdG0 fdH0 sh ${this} uk0 uk1 sh ${this} ss0 ss1 sh ${this} pty0 vnd0 vnd1 vnd2 vnd3 audio tun0 tun1 tun2 tun3 sh ${this} ccd0 ccd1 ccd2 ccd3 sh ${this} bpf0 bpf1 bpf2 bpf3 sh ${this} ipl sh ${this} bwtwo0 cgthree0 cgfour0 cgsix0 sh ${this} cgeight0 sh ${this} lkm random local ;; floppy) sh ${this} std random sh ${this} fd0 sd0 sd1 ;; ramdisk) sh ${this} std random sh ${this} fd0 sd0 sd1 sd2 sd3 rd0 cd0 ;; std) mknod console c 0 0 mknod tty c 2 0 ; chmod 666 tty mknod kmem c 3 1 ; chmod 640 kmem ; chown root.kmem kmem mknod mem c 3 0 ; chmod 640 mem ; chown root.kmem mem mknod null c 3 2 ; chmod 666 null mknod zero c 3 12 ; chmod 666 zero mknod eeprom c 3 11 ; chmod 640 eeprom ; chown root.kmem eeprom mknod openprom c 70 0 ; chmod 644 openprom mknod drum c 7 0 ; chmod 640 drum ; chown root.kmem drum mknod klog c 16 0 ; chmod 600 klog mknod stdin c 24 0 ; chmod 666 stdin mknod stdout c 24 1 ; chmod 666 stdout mknod stderr c 24 2 ; chmod 666 stderr mknod ttya c 12 0 mknod ttyb c 12 1 mknod fb c 22 0 ; chmod 666 fb mknod mouse c 13 0 ; chmod 666 mouse mknod kbd c 29 0 ; chmod 666 kbd ;; fd) rm -f fd/* mkdir fd > /dev/null 2>&1 n=0 (cd fd && while [ $n -lt 64 ]; do mknod $n c 24 $n; n=`add $n 1`; done ) chown -R root.wheel fd chmod 555 fd chmod 666 fd/* ;; bwtwo*) mknod bwtwo$unit c 27 $unit; chmod 666 bwtwo$unit ;; cgthree*) mknod cgthree$unit c 55 $unit; chmod 666 cgthree$unit ;; cgfour*) mknod cgfour$unit c 39 $unit; chmod 666 cgfour$unit ;; cgsix*) mknod cgsix$unit c 67 $unit; chmod 666 cgsix$unit ;; cgeight*) mknod cgeight$unit c 64 $unit; chmod 666 cgeight$unit ;; audio) mknod audio c 69 0; chmod 666 audio ;; openprom) mknod openprom c 70 0; chmod 600 openprom ;; bpf*) rm -f bpf$unit mknod bpf$unit c 105 $unit chmod 600 bpf$unit chown root.wheel bpf$unit ;; ipl) rm -f ipl mknod ipl c 59 0 chown root.wheel ipl ;; tun*) rm -f tun$unit mknod tun$unit c 111 $unit chmod 600 tun$unit chown root.wheel tun$unit ;; fd*) umask 2 ; unit=`expr $i : 'fd.*\(.\)$'` typnam=`expr $i : 'fd\(.\).*'` case $typnam in 0|1) typnam=; typnum=0;; # no type specified, assume A A) typnam=; typnum=0;; B) typnum=1;; C) typnum=2;; D) typnum=3;; E) typnum=4;; F) typnum=5;; G) typnum=6;; H) typnum=7;; *) echo bad type $typnam for $i; exit 1;; esac case $unit in 0|1) blk=16; chr=54;; *) echo bad unit $unit for $i; exit 1;; esac nam=fd${typnam}$unit rm -f ${nam}? r${nam}? basenum=`expr $unit '*' 128 + $typnum '*' 16` mknod ${nam}a b $blk `expr $basenum + 0` mknod ${nam}b b $blk `expr $basenum + 1` mknod ${nam}c b $blk `expr $basenum + 2` #mknod ${nam}d b $blk `expr $basenum + 3` #mknod ${nam}e b $blk `expr $basenum + 4` #mknod ${nam}f b $blk `expr $basenum + 5` #mknod ${nam}g b $blk `expr $basenum + 6` #mknod ${nam}h b $blk `expr $basenum + 7` #mknod ${nam}i b $blk `expr $basenum + 8` #mknod ${nam}j b $blk `expr $basenum + 9` #mknod ${nam}k b $blk `expr $basenum + 10` #mknod ${nam}l b $blk `expr $basenum + 11` #mknod ${nam}m b $blk `expr $basenum + 12` #mknod ${nam}n b $blk `expr $basenum + 13` #mknod ${nam}o b $blk `expr $basenum + 14` #mknod ${nam}p b $blk `expr $basenum + 15` mknod r${nam}a c $chr `expr $basenum + 0` mknod r${nam}b c $chr `expr $basenum + 1` mknod r${nam}c c $chr `expr $basenum + 2` #mknod r${nam}d c $chr `expr $basenum + 3` #mknod r${nam}e c $chr `expr $basenum + 4` #mknod r${nam}f c $chr `expr $basenum + 5` #mknod r${nam}g c $chr `expr $basenum + 6` #mknod r${nam}h c $chr `expr $basenum + 7` #mknod r${nam}i c $chr `expr $basenum + 8` #mknod r${nam}j c $chr `expr $basenum + 9` #mknod r${nam}k c $chr `expr $basenum + 10` #mknod r${nam}l c $chr `expr $basenum + 11` #mknod r${nam}m c $chr `expr $basenum + 12` #mknod r${nam}n c $chr `expr $basenum + 13` #mknod r${nam}o c $chr `expr $basenum + 14` #mknod r${nam}p c $chr `expr $basenum + 15` chown root.operator ${nam}[a-p] r${nam}[a-p] chmod 640 ${nam}[a-p] r${nam}[a-p] umask 77 ;; ccd*|sd*|xd*|xy*|cd*) umask 2 unit=`unt $i` if [ 0$unit -gt 15 ] then echo bad disk unit: $i - $unit exit 127 fi case $i in ccd*) name=ccd; blk=9; chr=23;; sd*) name=sd; blk=7; chr=17;; xd*) name=xd; blk=10; chr=42;; xy*) name=xy; blk=3; chr=9;; cd*) name=cd; blk=18; chr=58;; *) echo bad unit for disk in: $i;; esac if [ "$unit" = "" ] then n=0 while [ $n -lt 32 ] do sh ${this} $name$n n=`add $n 1` done fi rm -f $name$unit? r$name$unit? minor=`mult $unit 16` for slice in a b c d e f g h i j k l m n o p do dev=$name$unit$slice mknod $dev b $blk $minor mknod r$dev c $chr $minor minor=`add $minor 1` done chown root.operator $name$unit? r$name$unit? chmod 640 $name$unit? r$name$unit? umask 77 ;; vnd*) umask 2 unit=`unt $i` if [ 0$unit -gt 15 ] then echo bad disk unit: $i - $unit exit 127 fi blk=8; chr=110; for name in vnd svnd; do case $name in vnd) off=0;; svnd) off=128;; esac if [ "$unit" = "" ] then n=0 while [ $n -lt 32 ] do sh ${this} $name$n n=`add $n 1` done fi rm -f $name$unit? r$name$unit? minor=`mult $unit 16` minor=`add $minor $off` for slice in a b c d e f g h i j k l m n o p do dev=$name$unit$slice mknod $dev b $blk $minor mknod r$dev c $chr $minor minor=`add $minor 1` done chown root.operator $name$unit? r$name$unit? chmod 640 $name$unit? r$name$unit? done umask 77 ;; rd*) umask 2 ; unit=`expr $i : '.*d\(.*\)'` mknod rd${unit}a b 17 `expr $unit '*' 16 + 0` mknod rd${unit}c b 17 `expr $unit '*' 16 + 2` mknod rrd${unit}a c 106 `expr $unit '*' 16 + 0` mknod rrd${unit}c c 106 `expr $unit '*' 16 + 2` chown root.operator rd${unit}[ac] rrd${unit}[ac] chmod 640 rd${unit}[ac] rrd${unit}[ac] umask 77 ;; st*) umask 2 case $i in st*) name=st; blk=11; chr=18;; esac rm -f $name$unit n$name$unit e$name$unit en$name$unit \ r$name$unit nr$name$unit er$name$unit enr$name$unit sixt=`mult $unit 16` mknod $name$unit b $blk `add $sixt 0` mknod n$name$unit b $blk `add $sixt 1` mknod e$name$unit b $blk `add $sixt 2` mknod en$name$unit b $blk `add $sixt 3` mknod r$name$unit c $chr `add $sixt 0` mknod nr$name$unit c $chr `add $sixt 1` mknod er$name$unit c $chr `add $sixt 2` mknod enr$name$unit c $chr `add $sixt 3` chown root.operator $name$unit n$name$unit \ e$name$unit en$name$unit \ r$name$unit nr$name$unit \ er$name$unit enr$name$unit chmod 640 $name$unit n$name$unit \ e$name$unit en$name$unit \ r$name$unit nr$name$unit \ er$name$unit enr$name$unit umask 77 ;; ch*) umask 2 case $i in ch*) name=ch; chr=19;; esac rm -f $name$unit sixt=`mult $unit 16` mknod $name$unit c $chr `add $sixt 0` chown root.operator $name$unit chmod 640 $name$unit umask 77 ;; lkm) rm -f lkm mknod lkm c 112 0 chown root.kmem lkm chmod 640 lkm ;; pty*) case $unit in 0) offset=0 name=p;; 1) offset=16 name=q;; 2) offset=32 name=r;; 3) offset=48 name=s;; # Note that telnetd, rlogind, and xterm (at least) only look at p-s. 4) offset=64 name=t;; *) echo bad unit for pty in: $i;; esac case $unit in 0|1|2|3|4) umask 0 n=0 while [ $n -lt 16 ] do nam=$name`hex $n` rm -rf {tty,pty}$n mknod tty$nam c 20 `add $offset $n` mknod pty$nam c 21 `add $offset $n` n=`add $n 1` done umask 77 ;; esac ;; random|srandom|urandom|prandom|arandom) rm -f random urandom srandom prandom arandom mknod random c 119 0 mknod srandom c 119 1 mknod urandom c 119 2 mknod prandom c 119 3 mknod arandom c 119 4 chown root.wheel random srandom urandom prandom arandom chmod 644 random srandom urandom prandom arandom ;; uk*) unit=`trunc $i uk` rm -f uk$unit mknod uk$unit c 120 $unit chown root.operator uk$unit chmod 640 uk$unit ;; ss*) unit=`trunc $i ss` rm -f ss$unit mknod ss$unit c 121 $unit chown root.operator ss$unit chmod 440 ss$unit # backwards compatibility with older PINTs rm -f scan$unit ln -s ss$unit scan$unit ;; local) umask 0 test -s MAKEDEV.local && sh MAKEDEV.local ;; *) echo $i: unknown device ;; esac done