NetBSD/etc/etc.vax/MAKEDEV

589 lines
14 KiB
Bash

#!/bin/sh -
# $NetBSD: MAKEDEV,v 1.48 2002/03/13 01:27:03 simonb Exp $
#
# @(#)MAKEDEV 8.1 (Berkeley) 6/9/93
#
###########################################################################
#
# PLEASE RUN "cd ../share/man/man8 ; perl5 MAKEDEV2manpage.pl"
# AFTER CHANGING THIS FILE, AND COMMIT THE UPDATED MANPAGE!
#
###########################################################################
#
# Device "make" file. Valid arguments:
# std standard devices
# local configuration specific devices
# all create a reasonable amount of all files
# Tapes:
# ht* massbus tm03 and tu??
# tm* unibus tm11 and te10 emulations (e.g. Emulex tc-11)
# mt* MSCP tapes (e.g. TU81, TK50)
# ts* unibus ts11
# ut* unibus tu45 emulations (e.g.si 9700)
# uu* tu58 cassettes on dl11 controller
# st* SCSI tapes
# Disks:
# hp* massbus rm??
# hk* unibus rk06 and rk07
# up* other unibus devices (e.g. on Emulex sc-21v controller)
# ra* MSCP disks (ra??, rd??)
# rx* MSCP floppy disk (rx33/50/...)
# rl* unibus rl02
# rb* 730 idc w/ rb80 and/or rb02
# ccd* "concatenated" pseudo-disks
# raid* RAIDframe disk driver
# vnd* "file" pseudo-disks
# rd* HDC9224 rd disks on VS2000
# sd* SCSI disks
# cd* SCSI CD-ROM
# md* memory pseudo-disk devices
# Terminal multiplexors:
# dz* unibus dz11 and dz32
# dh* unibus dh11 and emulations (e.g. Able dmax, Emulex cs-11)
# dmf* unibus dmf32
# dhu* unibus dhu11
# dmz* unibus dmz32
# dl* unibus dl11
# Pseudo terminals:
# pty* set of 62 master and slave pseudo terminals
# opty first 16 ptys, to save inodes on install media
# Printers:
# ct* unibus parallel interface to CAT typesetter
# lp* unibus lp11 parallel interface
# va* unibus varian parallel interface
# vp* unibus versatec parallel interface
# Call units:
# dn* unibus dn11 and emulations (e.g. Able Quadracall)
# Special purpose devices:
# clockctl clock control for non root users
# ik* unibus interface to ikonas frame buffer
# ps* unibus interface to picture system 2
# ad* unibus interface to data translation a/d converter
# np* unibus ethernet co-processor interface, for downloading.
# qv* qvss (microvax) display
# lkm loadable kernel modules
# bpf* berkeley packet filter
# tun* network tunnel device
# scsibus* SCSI busses, see scsi(4), scsictl(8)
# ss* SCSI scanner
# uk* unknown SCSI device
# ch* SCSI media changer
# random Random number generator
#
PATH=/sbin:/usr/sbin:/bin:/usr/bin
umask 77
# Check if we have fdesc mounted
if [ -d fd ]; then
case "`df fd`" in
*fdesc*) nofdesc=false;;
*) nofdesc=true;;
esac
else
nofdesc=true
fi
makedev()
{
for i
do
case $i in
all)
makedev std fd vnd0 ccd0 pty0 lkm random
makedev bpf0 bpf1 bpf2 bpf3 bpf4 bpf5 bpf6 bpf7
makedev mt0 mt1 ts0 ts1 st0 st1 uk0 ss0 cd0 vt0
makedev ra0 ra1 ra2 ra3 hp0 hp1 hp2 hp3 sd0 sd1 sd2 sd3 rd0 rd1 rd2
makedev dz0 dl0 dhu0 rx0 rx1 md0 md1
makedev raid0 raid1 raid2 raid3 raid4 raid5 raid6 raid7
makedev scsibus0 scsibus1 scsibus2 scsibus3
makedev clockctl
;;
std)
rm -f console drum floppy crl csa1 cas2 tu0 tu1 g0 g1 g2 g3
rm -f kUmem kmem mem null leds zero klog
rm -f ipl ipnat ipstate ipauth
mknod console c 0 0
mknod ttyg0 c 25 0
mknod ttyg1 c 25 1
mknod ttyg2 c 25 2
mknod ttyg3 c 25 3
mknod drum c 7 0 ; chmod 640 drum ; chgrp kmem drum
mknod floppy c 8 0
mknod crl c 35 0
mknod csa1 c 51 0
mknod csa2 c 51 1
mknod tu0 b 8 0
mknod tu1 b 8 1
mknod kUmem c 3 3 ; chmod 600 kUmem
mknod kmem c 3 1 ; chmod 640 kmem ; chgrp kmem kmem
mknod mem c 3 0 ; chmod 640 mem ; chgrp kmem mem
mknod null c 3 2 ; chmod 666 null
mknod zero c 3 12 ; chmod 666 zero
mknod leds c 3 13 ; chmod 666 leds
mknod klog c 33 0 ; chmod 600 klog
if $nofdesc; then
rm -f tty stdin stdout stderr
mknod tty c 2 0 ; chmod 666 tty
mknod stdin c 53 0 ; chmod 666 stdin
mknod stdout c 53 1 ; chmod 666 stdout
mknod stderr c 53 2 ; chmod 666 stderr
fi
mknod ipl c 42 0 ; chmod 600 ipl
mknod ipnat c 42 1 ; chmod 600 ipnat
mknod ipstate c 42 2 ; chmod 600 ipstate
mknod ipauth c 42 3 ; chmod 600 ipauth
;;
fd)
if $nofdesc; then
rm -f fd/*
mkdir fd 2>/dev/null
n=0
while [ $n -lt 64 ]; do
mknod fd/$n c 53 $n
n=$(($n + 1))
done
chmod 755 fd
chmod 666 fd/*
fi
;;
st*)
case $i in
st*) name=st; unit=${i#st}; blk=21; chr=60;;
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
mknod ${name}${unit} b $blk $(($unit * 16+ 0))
mknod n${name}${unit} b $blk $(($unit * 16+ 1))
mknod e${name}${unit} b $blk $(($unit * 16+ 2))
mknod en${name}${unit} b $blk $(($unit * 16+ 3))
mknod r${name}${unit} c $chr $(($unit * 16+ 0))
mknod nr${name}${unit} c $chr $(($unit * 16+ 1))
mknod er${name}${unit} c $chr $(($unit * 16+ 2))
mknod enr${name}${unit} c $chr $(($unit * 16+ 3))
chgrp 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 660 ${name}${unit} n${name}${unit} \
e$name$unit en$name$unit \
r${name}${unit} nr${name}${unit} \
er${name}${unit} enr${name}${unit}
;;
ht*|tm*|mt*|ts*|ut*)
case $i in
ht*) name=ht; unit=${i#ht}; blk=1; chr=5 ;;
mt*) name=mt; unit=${i#mt}; blk=15; chr=38;;
tm*) name=tm; unit=${i#tm}; blk=5; chr=14;;
ts*) name=ts; unit=${i#ts}; blk=6; chr=16;;
ut*) name=ut; unit=${i#ut}; blk=10; chr=17;;
esac
case $unit in
[0-7])
four=$(($unit + 4)) ; eight=$(($unit + 8))
twelve=$(($unit + 12)) ; twenty=$(($unit + 20))
rm -f $name$unit $name$four $name$eight $name$twelve \
n$name$unit n$name$eight nr$name$unit nr$name$eight \
r$name$unit r$name$four r$name$eight r$name$twelve
mknod $name$unit b $blk $unit
mknod $name$four b $blk $four
mknod $name$eight b $blk $eight
mknod $name$twelve b $blk $twelve
mknod n$name$unit b $blk $four ;: sanity w/pdp11 v7
mknod n$name$eight b $blk $twelve ;: ditto
mknod nr$name$unit c $chr $four ;: sanity w/pdp11 v7
mknod nr$name$eight c $chr $twelve ;: ditto
mknod r$name$unit c $chr $unit
mknod r$name$four c $chr $four
mknod r$name$eight c $chr $eight
mknod r$name$twelve c $chr $twelve
chgrp operator $name$unit $name$four $name$eight $name$twelve \
n$name$unit n$name$eight nr$name$unit nr$name$eight \
r$name$unit r$name$four r$name$eight r$name$twelve
chmod 660 $name$unit $name$four $name$eight $name$twelve \
n$name$unit n$name$eight nr$name$unit nr$name$eight \
r$name$unit r$name$four r$name$eight r$name$twelve
if [ $i = ut ]
then
rm -f $name$twenty r$name$twenty
mknod $name$twenty b $blk $twenty
mknod r$name$twenty c $chr $twenty
chgrp operator $name$twenty r$name$twenty
chmod 660 $name$twenty r$name$twenty
fi
if [ ! -e rmt$eight ] # compatibility stuff
then
ln -fs $name$unit mt$unit
ln -fs $name$four mt$four
ln -fs $name$eight mt$eight
ln -fs $name$twelve mt$twelve
ln -fs n$name$unit nmt$unit
ln -fs n$name$eight nmt$eight
ln -fs nr$name$unit nrmt$unit
ln -fs nr$name$eight nrmt$eight
ln -fs r$name$unit rmt$unit
ln -fs r$name$four rmt$four
ln -fs r$name$eight rmt$eight
ln -fs r$name$twelve rmt$twelve
fi
;;
*)
echo bad unit for tape in: $1
;;
esac
;;
random)
rm -f random urandom
mknod random c 67 0
mknod urandom c 67 1
chmod 444 random
chmod 644 urandom
;;
hp*|hk*|up*|ra*|rl*|rb*|ccd*|vnd*|rd*|sd*|rx*|raid*)
umask 2
case $i in
hp*) name=hp; unit=${i#hp}; blk=0; chr=4;;
hk*) name=hk; unit=${i#hk}; blk=3; chr=11;;
up*) name=up; unit=${i#up}; blk=2; chr=13;;
raid*) name=raid; unit=${i#raid}; blk=25; chr=73;;
ra*) name=ra; unit=${i#ra}; blk=9; chr=9;;
rb*) name=rb; unit=${i#rb}; blk=11; chr=23;;
rx*) name=rx; unit=${i#rx}; blk=12; chr=30;;
rl*) name=rl; unit=${i#rl}; blk=14; chr=32;;
ccd*) name=ccd; unit=${i#ccd}; blk=17; chr=54;;
vnd*) name=vnd; unit=${i#vnd}; blk=18; chr=55;;
rd*) name=rd; unit=${i#rd}; blk=19; chr=58;;
sd*) name=sd; unit=${i#sd}; blk=20; chr=59;;
esac
case $unit in
[0-9]|[12][0-9]|3[01])
rm -f ${name}${unit}[a-h] r${name}${unit}[a-h]
mknod ${name}${unit}a b $blk $(($unit * 8 + 0))
mknod ${name}${unit}b b $blk $(($unit * 8 + 1))
mknod ${name}${unit}c b $blk $(($unit * 8 + 2))
mknod ${name}${unit}d b $blk $(($unit * 8 + 3))
mknod ${name}${unit}e b $blk $(($unit * 8 + 4))
mknod ${name}${unit}f b $blk $(($unit * 8 + 5))
mknod ${name}${unit}g b $blk $(($unit * 8 + 6))
mknod ${name}${unit}h b $blk $(($unit * 8 + 7))
mknod r${name}${unit}a c $chr $(($unit * 8 + 0))
mknod r${name}${unit}b c $chr $(($unit * 8 + 1))
mknod r${name}${unit}c c $chr $(($unit * 8 + 2))
mknod r${name}${unit}d c $chr $(($unit * 8 + 3))
mknod r${name}${unit}e c $chr $(($unit * 8 + 4))
mknod r${name}${unit}f c $chr $(($unit * 8 + 5))
mknod r${name}${unit}g c $chr $(($unit * 8 + 6))
mknod r${name}${unit}h c $chr $(($unit * 8 + 7))
chgrp operator ${name}${unit}[a-h] r${name}${unit}[a-h]
chmod 640 ${name}${unit}[a-h] r${name}${unit}[a-h]
;;
*)
echo bad unit for disk in: $i
;;
esac
umask 77
;;
cd*)
case $i in
cd*) name=cd; unit=${i#cd}; chr=61; blk=22;;
esac
rm -f $name$unit? r$name$unit?
mknod ${name}${unit}a b $blk $(($unit * 8 + 0))
mknod ${name}${unit}c b $blk $(($unit * 8 + 2))
mknod r${name}${unit}a c $chr $(($unit * 8 + 0))
mknod r${name}${unit}c c $chr $(($unit * 8 + 2))
chgrp operator $name$unit? r$name$unit?
chmod 640 $name$unit? r$name$unit?
;;
ss*)
case $i in
ss*) name=ss; unit=${i#ss}; chr=64;;
esac
rm -f $name$unit n$name$unit en$name$unit
mknod $name$unit c $chr $(($unit * 16 + 0))
mknod n$name$unit c $chr $(($unit * 16 + 1))
mknod en$name$unit c $chr $(($unit * 16 + 3))
chgrp operator $name$unit n$name$unit en$name$unit
chmod 640 $name$unit n$name$unit en$name$unit
;;
ch*|uk*)
case $i in
ch*) name=ch; unit=${i#ch}; chr=63;;
uk*) name=uk; unit=${i#uk}; chr=65;;
esac
rm -f $name$unit
mknod $name$unit c $chr $unit
chgrp operator $name$unit
chmod 640 $name$unit
;;
md*)
unit=${i#md}; blk=23; chr=62
rm -f md${unit}? rmd${unit}?
mknod md${unit}a b $blk $(($unit * 8 + 0))
mknod md${unit}c b $blk $(($unit * 8 + 2))
# mknod rmd${unit}a c $chr $(($unit * 8 + 0))
# mknod rmd${unit}c c $chr $(($unit * 8 + 2))
chgrp operator md${unit}? #rmd${unit}?
chmod 640 md${unit}? #rmd${unit}?
;;
uu*)
unit=${i#uu}
name=uu; blk=13
case $unit in
[0-3])
mknod ${name}${unit} b $blk $(($unit * 2 + 0))
mknod ${name}${unit}a b $blk $(($unit * 2 + 1))
;;
*)
echo bad unit for uu cassette in: $i
;;
esac
;;
dz*)
unit=${i#dz}
case $unit in
[0-7])
i=0
while [ $i -lt 8 ]; do
no=$(($unit * 8 + $i))
`printf "mknod tty%02d c 1 %d\n" $no $no`
i=$(($i + 1))
done
;;
*)
echo bad unit for dz in: $i
;;
esac
;;
dhu*|dh*|dmf*|dmz*|vt*)
case $i in
vt*) name=vt; major=68; count=8
unit=${i#vt}
case $unit in
0) ch=w ;;
*) echo bad unit for $name in: $i ;;
esac;;
dmz*) name=dmz; major=37; count=24
unit=${i#dmz}
case $unit in
0) ch=a ;; 1) ch=b ;; 2) ch=c ;; 3) ch=e ;; 4) ch=f ;;
*) echo bad unit for $name in: $i ;;
esac;;
dmf*) name=dmf; major=22; count=8
unit=${i#dmf}
case $unit in
0) ch=A ;; 1) ch=B ;; 2) ch=C ;; 3) ch=E ;;
4) ch=F ;; 5) ch=G ;; 6) ch=H ;; 7) ch=I ;;
*) echo bad unit for $name in: $i ;;
esac;;
dhu*) name=dhu; major=34; count=16
unit=${i#dhu}
case $unit in
0) ch=S ;; 1) ch=T ;; 2) ch=U ;; 3) ch=V ;;
4) ch=W ;; 5) ch=X ;; 6) ch=Y ;; 7) ch=Z ;;
*) echo bad unit for $name in: $i ;;
esac;;
dh*) name=dh; major=12; count=16
unit=${i#dh}
case $unit in
0) ch=h ;; 1) ch=i ;; 2) ch=j ;; 3) ch=k ;;
4) ch=l ;; 5) ch=m ;; 6) ch=n ;; 7) ch=o ;;
*) echo bad unit for $name in: $i ;;
esac;;
esac
i=0
while [ $i -lt $count ]; do
`printf "mknod tty%s%x c %d %d\n" \
$ch $i $major $(($unit * $count + $i))`
i=$(($i + 1))
done
;;
dl*)
unit=${i#dl}
major=66
`printf "mknod ttyJ%x c %d %d\n" $unit $major $unit`
;;
lp*|va*|vp*)
case $i in
lp*) name=lp; unit=${i#lp}; major=15;;
va*) name=va; unit=${i#va}; major=10;;
vp*) name=vp; unit=${i#vp}; major=6;;
esac
case $unit in
[0-7])
mknod $i c $major $unit
chmod 666 $i
;;
*)
echo bad unit for $name in: $i
;;
esac
;;
opty)
rm -f ttyp[0-9a-f] ptyp[0-9a-f]
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
mknod ttyp$j c 20 $jn
mknod ptyp$j c 21 $jn
done
chmod 666 ttyp[0-9a-f] ptyp[0-9a-f]
;;
pty*)
class=${i#pty}
name=`echo pqrstuvwxyzPQRST | dd bs=1 count=1 skip=$class 2>/dev/null`
case $name in
w) echo "$0: $i: pty unit conflicts with console ttyw0 device."
continue;;
S|T) echo "$0: $i: pty unit conflicts with dhu11 device."
continue;;
?) ;;
*) echo "$0: $i: pty unit must be between 0 and 15"
continue ;;
esac
rm -f tty$name[0-9a-zA-Z] pty$name[0-9a-zA-Z]
jn=0
while [ $jn -lt 62 ]
do
j=`echo 0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ | dd bs=1 count=1 skip=$jn 2>/dev/null`
skip=0
if [ $jn -ge 16 ]; then
skip=$(($class * 30 + 256 - 16))
fi
unit=$(($class * 16 + $jn + $skip))
mknod tty$name$j c 20 $unit
mknod pty$name$j c 21 $unit
jn=$(($jn + 1))
done
chmod 666 tty$name[0-9a-zA-Z] pty$name[0-9a-zA-Z]
;;
np*)
class=${i#np}
case $class in
0) offset=0 name=0;;
1) offset=16 name=1;;
2) offset=32 name=2;;
*) echo bad unit for np in: $i;;
esac
case $class in
0|1|2)
i=0
while [ $i -lt 4 ]; do
`printf "mknod np%02d c 39 %d\n" $(($offset + $i)) $(($offset + $i))`
i=$(($i + 1))
done
esac
;;
dn*|ik*|ps*|ad*|ct*)
case $i in
ct*) name=ct; unit=${i#ct}; chr=18;;
dn*) name=cu; unit=${i#dn}; chr=24;;
ps*) name=ps; unit=${i#ps}; chr=27;;
ad*) name=ad; unit=${i#ad}; chr=29;;
ik*) name=ik; unit=${i#ik}; chr=31;;
esac
case $unit in
[0-7])
umask 0
mknod ${name}${unit} c ${chr} ${unit}
umask 77
;;
*)
echo bad unit for ${name} in: $i
;;
esac
;;
bpf*)
unit=${i#bpf}
rm -f bpf$unit
mknod bpf$unit c 56 $unit
chmod 600 bpf$unit
;;
qd*)
unit=${i#qd}
rm -f qd$unit
mknod qc$unit c 40 $(($unit * 4))
mknod qd$unit c 40 $(($unit * 4 + 2))
;;
tun*)
unit=${i#tun}
rm -f tun$unit
mknod tun$unit c 57 $unit
chmod 600 tun$unit
;;
lkm)
mknod lkm c 28 0
chgrp kmem lkm
chmod 640 lkm
;;
qv0)
mknod qv0 c 40 0
mknod qvcons c 40 1
mknod mouse c 40 2
;;
scsibus*)
unit=${i#scsibus}
rm -f scsibus$unit
mknod scsibus$unit c 72 $unit
chmod 644 scsibus$unit
;;
clockctl)
rm -f clockctl
mknod clockctl c 75 0
chgrp ntpd clockctl
chmod 660 clockctl
;;
local)
umask 0
sh $0.local all
umask 77
;;
*)
echo $i: invalid device
;;
esac
done
}
makedev $*