fix core dump caused by writing to read-only memory

[unix-history] / usr / src / etc / etc.vax / MAKEDEV

#!/bin/sh -
#
#       @(#)MAKEDEV     8.1 (Berkeley) %G%
#

# Device "make" file.  Valid arguments:
#       std     standard devices
#       local   configuration specific devices
# Tapes:
#       ht*     massbus tm03 & tu??
#       tm*     unibus tm11 & te10 emulations (e.g. Emulex tc-11)
#       tms*    unibus/qbus TMSCP (e.g. TU81, TK50)
#       ts*     unibus ts11
#       mt*     massbus tu78
#       ut*     unibus tu45 emulations (e.g.si 9700)
#       uu*     tu58 cassettes on dl11 controller
# Disks:
#       hp*     massbus rm??
#       hk*     unibus rk06 and rk07
#       up*     other unibus devices (e.g. on Emulex sc-21v controller)
#       ra*     unibus uda50 w/ ra??
#       kra*    bi kdb50 w/ ra??
#       rl*     unibus rl02
#       rb*     730 idc w/ rb80 and/or rb02
#       rx*     unibus rx211 floppy disk 
# 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
# Pseudo terminals:
#       pty*    set of 16 master and slave pseudo terminals
# 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:
#       ik*     unibus interface to ikonas frame buffer
#       ps*     unibus interface to e&s picture system 2
#       ad*     unibus interface to data translation a/d converter
#       np*     unibus ethernet co-processor interface, for downloading.
#       qv*     qvss (microvax) display
#       ttyv0   qvss (microvax) display reserved pty
PATH=/sbin:/bin:/usr/bin
umask 77
for i
do
case $i in

std)
       mknod console           c 0 0
       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 tty               c 2 0   ; chmod 666 tty
       mknod klog              c 33 0  ; chmod 600 klog
       mknod stdin             c 53 0  ; chmod 666 stdin
       mknod stdout            c 53 1  ; chmod 666 stdout
       mknod stderr            c 53 2  ; chmod 666 stderr
       mkdir fd > /dev/null 2>&1
       (cd fd && eval `echo "" | awk ' BEGIN { \
               for (i = 0; i < 64; i++) \
                       printf("mknod %d c 53 %d;", i, i)}'`)
       chown -R bin.bin fd
       chmod 555 fd
       chmod 666 fd/*
       ;;

ht*|tm*|tms*|ts*|ut*)
       umask 0 ; unit=`expr $i : '[^0-9]*\(.*\)'`
       case $i in
       ht*) blk=1; chr=5 ;;
       tms*) blk=15; chr=38;;
       tm*) blk=5; chr=14;;
       ts*) blk=6; chr=16;;
       ut*) blk=10; chr=17;;
       esac
       case $unit in
       0|1|2|3|4|5|6|7)
               four=`expr $unit + 4` ; eight=`expr $unit + 8`
               twelve=`expr $unit + 12`; twenty=`expr $unit + 20`
               mknod mt$unit           b $blk $unit
               mknod mt$four           b $blk $four
               mknod mt$eight          b $blk $eight
               mknod mt$twelve         b $blk $twelve
               mknod nmt$unit          b $blk $four ;: sanity w/pdp11 v7
               mknod nmt$eight         b $blk $twelve ;: ditto
               mknod nrmt$unit         c $chr $four ;: sanity w/pdp11 v7
               mknod nrmt$eight        c $chr $twelve ;: ditto
               mknod rmt$unit          c $chr $unit
               mknod rmt$four          c $chr $four
               mknod rmt$eight         c $chr $eight
               mknod rmt$twelve        c $chr $twelve
               if [ $i = ut ] 
               then
                       mknod mt$twenty         b $blk $twenty
                       mknod rmt$twenty        c $chr $twenty
               fi
               ;;
       *)
               echo bad unit for tape in: $1
               ;;
       esac
       umask 77
       ;;

mt*)
       umask 0 ; unit=`expr $i : '..\(.*\)'`
       case $i in
       mt*) blk=7; chr=19;;
       esac
       case $unit in
       0|1|2|3|4|5|6|7)
               eight=`expr $unit + 0`;
               twelve=`expr $unit + 4`; 
               sixteen=`expr $unit + 8`;
               twenty=`expr $unit + 12`;
               mknod mt8               b $blk $eight
               mknod mt12              b $blk $twelve
               mknod mt16              b $blk $sixteen
               mknod mt20              b $blk $twenty
               mknod nmt8              b $blk $twelve ;: ditto
               mknod nrmt8             c $chr $twelve ;: ditto
               mknod rmt8              c $chr $eight
               mknod rmt12             c $chr $twelve
               mknod rmt16             c $chr $sixteen
               mknod rmt20             c $chr $twenty
               mknod nmt16             b $blk $twenty ;: ditto
               mknod nrmt16            c $chr $twenty ;: ditto
               ;;
       *)
               echo bad unit for tape in: $1
               ;;
       esac
       umask 77
       ;;

hp*|hk*|up*|ra*|kra*|rl*|rb*)
       umask 2 ; unit=`expr $i : '..\(.*\)'`
       case $i in
       hp*) name=hp; blk=0; chr=4;;
       hk*) name=hk; blk=3; chr=11;;
       up*) name=up; blk=2; chr=13;;
       ra*) name=ra; blk=9; chr=9;;
       kra*) name=kra; blk=16; chr=52;;
       rb*) name=rb; blk=11; chr=23;;
       rl*) name=rl; blk=14; chr=32;;
       esac
       case $unit in
       0|1|2|3|4|5|6|7|8|9|10|11|12|13|14|15|16|\
       17|18|19|20|21|22|23|24|25|26|27|28|29|30|31)
               mknod ${name}${unit}a   b $blk `expr $unit '*' 8 + 0`
               mknod ${name}${unit}b   b $blk `expr $unit '*' 8 + 1`
               mknod ${name}${unit}c   b $blk `expr $unit '*' 8 + 2`
               mknod ${name}${unit}g   b $blk `expr $unit '*' 8 + 6`
               mknod r${name}${unit}a  c $chr `expr $unit '*' 8 + 0`
               mknod r${name}${unit}b  c $chr `expr $unit '*' 8 + 1`
               mknod r${name}${unit}c  c $chr `expr $unit '*' 8 + 2`
               mknod r${name}${unit}g  c $chr `expr $unit '*' 8 + 6`
               if [ $name != hk ]
               then
               mknod ${name}${unit}d   b $blk `expr $unit '*' 8 + 3`
               mknod ${name}${unit}e   b $blk `expr $unit '*' 8 + 4`
               mknod ${name}${unit}f   b $blk `expr $unit '*' 8 + 5`
               mknod ${name}${unit}h   b $blk `expr $unit '*' 8 + 7`
               mknod r${name}${unit}d  c $chr `expr $unit '*' 8 + 3`
               mknod r${name}${unit}e  c $chr `expr $unit '*' 8 + 4`
               mknod r${name}${unit}f  c $chr `expr $unit '*' 8 + 5`
               mknod r${name}${unit}h  c $chr `expr $unit '*' 8 + 7`
               fi
               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
       ;;

rx*)
       unit=`expr $i : '..\(.*\)'`
       name=rx; chr=30; blk=12;
       case $unit in
       0|1|2|3|4|5|6|7)
               mknod ${name}${unit}    b $blk `expr $unit '*' 8 + 0`
               mknod r${name}${unit}a  c $chr `expr $unit '*' 8 + 0`
               mknod r${name}${unit}b  c $chr `expr $unit '*' 8 + 1`
               mknod r${name}${unit}c  c $chr `expr $unit '*' 8 + 2`
               mknod r${name}${unit}d  c $chr `expr $unit '*' 8 + 3`
               ;;
       *)
               echo bad unit for floppy disk in: $i
               ;;
       esac
       ;;

uu*)
       unit=`expr $i : '..\(.*\)'`
       name=uu; blk=13;
       case $unit in
       0|1|2|3)
               mknod ${name}${unit}    b $blk `expr $unit '*' 2 + 0`
               mknod ${name}${unit}a   b $blk `expr $unit '*' 2 + 1`
               ;;
       *)
               echo bad unit for uu cassette in: $i
               ;;
       esac
       ;;

dz*)
       unit=`expr $i : 'dz\(.*\)'`
       case $unit in
       0|1|2|3|4|5|6|7)
               eval `echo $unit | awk ' { u = $1 } END {
                   for (i = 0; i < 8; i++)
                       printf("mknod tty%02d c 1 %d; ",u*8+i,u*8+i); }'`
               ;;
       *)
               echo bad unit for dz in: $i
               ;;
       esac
       ;;

dhu*|dh*|dmf*|dmz*)
       case $i in
       dmz*)   name=dmz; major=37; count=24;
               unit=`expr $i : "$name\(.*\)"`
               case $unit in
               0) ch=a ;; 1) ch=b ;; 2) ch=c ;; 3) ch=e ;;
               4) ch=f ;; 5) ch=g ;;
               *) echo bad unit for $name in: $i ;;
               esac;;
       dmf*)   name=dmf; major=22; count=8;
               unit=`expr $i : "$name\(.*\)"`
               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=`expr $i : "$name\(.*\)"`;
               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=`expr $i : "$name\(.*\)"`
               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
       eval `echo $ch $unit $major $count |
         awk ' { ch = $1; u = $4 * $2; m = $3; cnt = $4 } END {
           for (i = 0; i < cnt; i++)
             if (i < 10)
               printf("mknod tty%s%x c %d %d; ",ch,i,m,u+i);
             else
               printf("mknod tty%s%c c %d %d; ",ch,87+i,m,u+i); }'`
       ;;

lp*|va*|vp*)
       case $i in
       lp*) name=lp; major=15;;
       va*) name=va; major=10;;
       vp*) name=vp; major=6;;
       esac
       unit=`expr $i : "$name\(.*\)"`
       case $unit in
       0|1|2|3|4|5|6|7)
               mknod $i c $major $unit;
               chmod 666 $i
               ;;
       *)
               echo bad unit for $name in: $i
               ;;
       esac
       ;;

pty*)
       class=`expr $i : 'pty\(.*\)'`
       case $class in
       0) offset=0 name=p;;
       1) offset=16 name=q;;
       2) offset=32 name=r;;
       3) offset=48 name=s;;
       4) offset=64 name=t;;
       5) offset=80 name=u;;
       *) echo bad unit for pty in: $i;;
       esac
       case $class in
       0|1|2|3|4|5)
               umask 0
               eval `echo $offset $name | awk ' { b=$1; n=$2 } END {
                       for (i = 0; i < 16; i++)
                               printf("mknod tty%s%x c 20 %d; \
                                       mknod pty%s%x c 21 %d; ", \
                                       n, i, b+i, n, i, b+i); }'`
               umask 77
               ;;
       esac
       ;;

np*)
       class=`expr $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)
               eval `echo $offset | awk ' { b=$1 } END {
                       for (i = 0; i < 4; i++)
                               printf("mknod np%02d c 39 %d;", \
                                       b+i, b+i); }'`
               ;;
       esac
       ;;

dn*|ik*|ps*|ad*|ct*)
       unit=`expr $i : '..\(.*\)'`
       case $i in
       ct*) name=ct; chr=18;;
       dn*) name=cu; chr=24;;
       ps*) name=ps; chr=27;;
       ad*) name=ad; chr=29;;
       ik*) name=ik; chr=31;;
       esac
       case $unit in
       0|1|2|3|4|5|6|7)
               umask 0
               mknod ${name}${unit} c ${chr} ${unit}
               umask 77
               ;;
       *)
               echo bad unit for ${name} in: $i
               ;;
       esac
       ;;

qv0)
       mknod qv0 c 40 0
       mknod qvcons c 40 1
       mknod mouse c 40 2
       ;;

ttyv0)
       if [ ! -f ttyqe ]; then sh ./MAKEDEV pty1; fi
       mv ttyqf ttyv0
       mv ptyqf ptyv0
       ;;

local)
       sh MAKEDEV.local
       ;;
esac
done