Annotation of 43BSDTahoe/sys/vaxdist/MAKEDEV, revision 1.1.1.1

1.1       root        1: #!/bin/sh -
                      2: #
                      3: # Copyright (c) 1980 Regents of the University of California.
                      4: # All rights reserved.  The Berkeley software License Agreement
                      5: # specifies the terms and conditions for redistribution.
                      6: #
                      7: #      @(#)MAKEDEV     4.31 (Berkeley) 7/16/88
                      8: #
                      9: # Device "make" file.  Valid arguments:
                     10: #      std     standard devices
                     11: #      local   configuration specific devices
                     12: # Tapes:
                     13: #      ht*     massbus tm03 & tu??
                     14: #      tm*     unibus tm11 & te10 emulations (e.g. Emulex tc-11)
                     15: #      tms*    unibus/qbus TMSCP (e.g. TU81, TK50)
                     16: #      ts*     unibus ts11
                     17: #      mt*     massbus tu78
                     18: #      ut*     unibus tu45 emulations (e.g.si 9700)
                     19: #      uu*     tu58 cassettes on dl11 controller
                     20: # Disks:
                     21: #      hp*     massbus rm??
                     22: #      hk*     unibus rk06 and rk07
                     23: #      up*     other unibus devices (e.g. on Emulex sc-21v controller)
                     24: #      ra*     unibus uda50 w/ ra??
                     25: #      kra*    bi kdb50 w/ ra??
                     26: #      rl*     unibus rl02
                     27: #      rb*     730 idc w/ rb80 and/or rb02
                     28: #      rx*     unibus rx211 floppy disk 
                     29: # Terminal multiplexors:
                     30: #      dz*     unibus dz11 and dz32
                     31: #      dh*     unibus dh11 and emulations (e.g. Able dmax, Emulex cs-11)
                     32: #      dmf*    unibus dmf32
                     33: #      dhu*    unibus dhu11
                     34: #      dmz*    unibus dmz32
                     35: # Pseudo terminals:
                     36: #      pty*    set of 16 master and slave pseudo terminals
                     37: # Printers:
                     38: #      ct*     unibus parallel interface to CAT typesetter
                     39: #      lp*     unibus lp11 parallel interface
                     40: #      va*     unibus varian parallel interface
                     41: #      vp*     unibus versatec parallel interface
                     42: # Call units:
                     43: #      dn*     unibus dn11 and emulations (e.g. Able Quadracall)
                     44: # Special purpose devices:
                     45: #      ik*     unibus interface to ikonas frame buffer
                     46: #      ps*     unibus interface to e&s picture system 2
                     47: #      ad*     unibus interface to data translation a/d converter
                     48: #      np*     unibus ethernet co-processor interface, for downloading.
                     49: #      qv*     qvss (microvax) display
                     50: #      ttyv0   qvss (microvax) display reserved pty
                     51: umask 77
                     52: for i
                     53: do
                     54: case $i in
                     55: 
                     56: std)
                     57:        /etc/mknod console      c 0 0
                     58:        /etc/mknod drum         c 7 0   ; chmod 640 drum ; chgrp kmem drum
                     59:        /etc/mknod floppy       c 8 0
                     60:        /etc/mknod crl          c 35 0
                     61:        /etc/mknod csa1         c 51 0
                     62:        /etc/mknod csa2         c 51 1
                     63:        /etc/mknod tu0          b 8 0
                     64:        /etc/mknod tu1          b 8 1
                     65:        /etc/mknod kUmem        c 3 3   ; chmod 600 kUmem
                     66:        /etc/mknod kmem         c 3 1   ; chmod 640 kmem ; chgrp kmem kmem
                     67:        /etc/mknod mem          c 3 0   ; chmod 640 mem ; chgrp kmem mem
                     68:        /etc/mknod null         c 3 2   ; chmod 666 null
                     69:        /etc/mknod tty          c 2 0   ; chmod 666 tty
                     70:        /etc/mknod klog         c 33 0  ; chmod 600 klog
                     71:        ;;
                     72: 
                     73: ht*|tm*|tms*|ts*|ut*)
                     74:        umask 0 ; unit=`expr $i : '[^0-9]*\(.*\)'`
                     75:        case $i in
                     76:        ht*) blk=1; chr=5 ;;
                     77:        tms*) blk=15; chr=38;;
                     78:        tm*) blk=5; chr=14;;
                     79:        ts*) blk=6; chr=16;;
                     80:        ut*) blk=10; chr=17;;
                     81:        esac
                     82:        case $unit in
                     83:        0|1|2|3|4|5|6|7)
                     84:                four=`expr $unit + 4` ; eight=`expr $unit + 8`
                     85:                twelve=`expr $unit + 12`; twenty=`expr $unit + 20`
                     86:                /etc/mknod mt$unit      b $blk $unit
                     87:                /etc/mknod mt$four      b $blk $four
                     88:                /etc/mknod mt$eight     b $blk $eight
                     89:                /etc/mknod mt$twelve    b $blk $twelve
                     90:                /etc/mknod nmt$unit     b $blk $four ;: sanity w/pdp11 v7
                     91:                /etc/mknod nmt$eight    b $blk $twelve ;: ditto
                     92:                /etc/mknod nrmt$unit    c $chr $four ;: sanity w/pdp11 v7
                     93:                /etc/mknod nrmt$eight   c $chr $twelve ;: ditto
                     94:                /etc/mknod rmt$unit     c $chr $unit
                     95:                /etc/mknod rmt$four     c $chr $four
                     96:                /etc/mknod rmt$eight    c $chr $eight
                     97:                /etc/mknod rmt$twelve   c $chr $twelve
                     98:                if [ $i = ut ] 
                     99:                then
                    100:                        /etc/mknod mt$twenty    b $blk $twenty
                    101:                        /etc/mknod rmt$twenty   c $chr $twenty
                    102:                fi
                    103:                ;;
                    104:        *)
                    105:                echo bad unit for tape in: $1
                    106:                ;;
                    107:        esac
                    108:        umask 77
                    109:        ;;
                    110: 
                    111: mt*)
                    112:        umask 0 ; unit=`expr $i : '..\(.*\)'`
                    113:        case $i in
                    114:        mt*) blk=7; chr=19;;
                    115:        esac
                    116:        case $unit in
                    117:        0|1|2|3|4|5|6|7)
                    118:                eight=`expr $unit + 0`;
                    119:                twelve=`expr $unit + 4`; 
                    120:                sixteen=`expr $unit + 8`;
                    121:                twenty=`expr $unit + 12`;
                    122:                /etc/mknod mt8          b $blk $eight
                    123:                /etc/mknod mt12         b $blk $twelve
                    124:                /etc/mknod mt16         b $blk $sixteen
                    125:                /etc/mknod mt20         b $blk $twenty
                    126:                /etc/mknod nmt8         b $blk $twelve ;: ditto
                    127:                /etc/mknod nrmt8        c $chr $twelve ;: ditto
                    128:                /etc/mknod rmt8         c $chr $eight
                    129:                /etc/mknod rmt12        c $chr $twelve
                    130:                /etc/mknod rmt16        c $chr $sixteen
                    131:                /etc/mknod rmt20        c $chr $twenty
                    132:                /etc/mknod nmt16        b $blk $twenty ;: ditto
                    133:                /etc/mknod nrmt16       c $chr $twenty ;: ditto
                    134:                ;;
                    135:        *)
                    136:                echo bad unit for tape in: $1
                    137:                ;;
                    138:        esac
                    139:        umask 77
                    140:        ;;
                    141: 
                    142: hp*|hk*|up*|ra*|kra*|rl*|rb*)
                    143:        umask 2 ; unit=`expr $i : '..\(.*\)'`
                    144:        case $i in
                    145:        hp*) name=hp; blk=0; chr=4;;
                    146:        hk*) name=hk; blk=3; chr=11;;
                    147:        up*) name=up; blk=2; chr=13;;
                    148:        ra*) name=ra; blk=9; chr=9;;
                    149:        kra*) name=kra; blk=16; chr=52;;
                    150:        rb*) name=rb; blk=11; chr=23;;
                    151:        rl*) name=rl; blk=14; chr=32;;
                    152:        esac
                    153:        case $unit in
                    154:        0|1|2|3|4|5|6|7|8|9|10|11|12|13|14|15|16|\
                    155:        17|18|19|20|21|22|23|24|25|26|27|28|29|30|31)
                    156:                /etc/mknod ${name}${unit}a      b $blk `expr $unit '*' 8 + 0`
                    157:                /etc/mknod ${name}${unit}b      b $blk `expr $unit '*' 8 + 1`
                    158:                /etc/mknod ${name}${unit}c      b $blk `expr $unit '*' 8 + 2`
                    159:                /etc/mknod ${name}${unit}g      b $blk `expr $unit '*' 8 + 6`
                    160:                /etc/mknod r${name}${unit}a     c $chr `expr $unit '*' 8 + 0`
                    161:                /etc/mknod r${name}${unit}b     c $chr `expr $unit '*' 8 + 1`
                    162:                /etc/mknod r${name}${unit}c     c $chr `expr $unit '*' 8 + 2`
                    163:                /etc/mknod r${name}${unit}g     c $chr `expr $unit '*' 8 + 6`
                    164:                if [ $name != hk ]
                    165:                then
                    166:                /etc/mknod ${name}${unit}d      b $blk `expr $unit '*' 8 + 3`
                    167:                /etc/mknod ${name}${unit}e      b $blk `expr $unit '*' 8 + 4`
                    168:                /etc/mknod ${name}${unit}f      b $blk `expr $unit '*' 8 + 5`
                    169:                /etc/mknod ${name}${unit}h      b $blk `expr $unit '*' 8 + 7`
                    170:                /etc/mknod r${name}${unit}d     c $chr `expr $unit '*' 8 + 3`
                    171:                /etc/mknod r${name}${unit}e     c $chr `expr $unit '*' 8 + 4`
                    172:                /etc/mknod r${name}${unit}f     c $chr `expr $unit '*' 8 + 5`
                    173:                /etc/mknod r${name}${unit}h     c $chr `expr $unit '*' 8 + 7`
                    174:                fi
                    175:                chgrp operator ${name}${unit}[a-h] r${name}${unit}[a-h]
                    176:                chmod 640 ${name}${unit}[a-h] r${name}${unit}[a-h]
                    177:                ;;
                    178:        *)
                    179:                echo bad unit for disk in: $i
                    180:                ;;
                    181:        esac
                    182:        umask 77
                    183:        ;;
                    184: 
                    185: rx*)
                    186:        unit=`expr $i : '..\(.*\)'`
                    187:        name=rx; chr=30; blk=12;
                    188:        case $unit in
                    189:        0|1|2|3|4|5|6|7)
                    190:                /etc/mknod ${name}${unit}       b $blk `expr $unit '*' 8 + 0`
                    191:                /etc/mknod r${name}${unit}a     c $chr `expr $unit '*' 8 + 0`
                    192:                /etc/mknod r${name}${unit}b     c $chr `expr $unit '*' 8 + 1`
                    193:                /etc/mknod r${name}${unit}c     c $chr `expr $unit '*' 8 + 2`
                    194:                /etc/mknod r${name}${unit}d     c $chr `expr $unit '*' 8 + 3`
                    195:                ;;
                    196:        *)
                    197:                echo bad unit for floppy disk in: $i
                    198:                ;;
                    199:        esac
                    200:        ;;
                    201: 
                    202: uu*)
                    203:        unit=`expr $i : '..\(.*\)'`
                    204:        name=uu; blk=13;
                    205:        case $unit in
                    206:        0|1|2|3)
                    207:                /etc/mknod ${name}${unit}       b $blk `expr $unit '*' 2 + 0`
                    208:                /etc/mknod ${name}${unit}a      b $blk `expr $unit '*' 2 + 1`
                    209:                ;;
                    210:        *)
                    211:                echo bad unit for uu cassette in: $i
                    212:                ;;
                    213:        esac
                    214:        ;;
                    215: 
                    216: dz*)
                    217:        unit=`expr $i : 'dz\(.*\)'`
                    218:        case $unit in
                    219:        0|1|2|3|4|5|6|7)
                    220:                eval `echo $unit | awk ' { u = $1 } END {
                    221:                    for (i = 0; i < 8; i++)
                    222:                        printf("/etc/mknod tty%02d c 1 %d; ",u*8+i,u*8+i); }'`
                    223:                ;;
                    224:        *)
                    225:                echo bad unit for dz in: $i
                    226:                ;;
                    227:        esac
                    228:        ;;
                    229: 
                    230: dhu*|dh*|dmf*|dmz*)
                    231:        case $i in
                    232:        dmz*)   name=dmz; major=37; count=24;
                    233:                unit=`expr $i : "$name\(.*\)"`
                    234:                case $unit in
                    235:                0) ch=a ;; 1) ch=b ;; 2) ch=c ;; 3) ch=e ;;
                    236:                4) ch=f ;; 5) ch=g ;;
                    237:                *) echo bad unit for $name in: $i ;;
                    238:                esac;;
                    239:        dmf*)   name=dmf; major=22; count=8;
                    240:                unit=`expr $i : "$name\(.*\)"`
                    241:                case $unit in
                    242:                0) ch=A ;; 1) ch=B ;; 2) ch=C ;; 3) ch=E ;;
                    243:                4) ch=F ;; 5) ch=G ;; 6) ch=H ;; 7) ch=I ;;
                    244:                *) echo bad unit for $name in: $i ;;
                    245:                esac;;
                    246:        dhu*)   name=dhu; major=34; count=16;
                    247:                unit=`expr $i : "$name\(.*\)"`;
                    248:                case $unit in
                    249:                0) ch=S ;; 1) ch=T ;; 2) ch=U ;; 3) ch=V ;;
                    250:                4) ch=W ;; 5) ch=X ;; 6) ch=Y ;; 7) ch=Z ;;
                    251:                *) echo bad unit for $name in: $i ;;
                    252:                esac;;
                    253:        dh*)    name=dh; major=12; count=16;
                    254:                unit=`expr $i : "$name\(.*\)"`
                    255:                case $unit in
                    256:                0) ch=h ;; 1) ch=i ;; 2) ch=j ;; 3) ch=k ;;
                    257:                4) ch=l ;; 5) ch=m ;; 6) ch=n ;; 7) ch=o ;;
                    258:                *) echo bad unit for $name in: $i ;;
                    259:                esac;;
                    260:        esac
                    261:        eval `echo $ch $unit $major $count |
                    262:          awk ' { ch = $1; u = $4 * $2; m = $3; cnt = $4 } END {
                    263:            for (i = 0; i < cnt; i++)
                    264:              if (i < 10)
                    265:                printf("/etc/mknod tty%s%x c %d %d; ",ch,i,m,u+i);
                    266:              else
                    267:                printf("/etc/mknod tty%s%c c %d %d; ",ch,87+i,m,u+i); }'`
                    268:        ;;
                    269: 
                    270: lp*|va*|vp*)
                    271:        case $i in
                    272:        lp*) name=lp; major=15;;
                    273:        va*) name=va; major=10;;
                    274:        vp*) name=vp; major=6;;
                    275:        esac
                    276:        unit=`expr $i : "$name\(.*\)"`
                    277:        case $unit in
                    278:        0|1|2|3|4|5|6|7)
                    279:                /etc/mknod $i c $major $unit;
                    280:                chmod 666 $i
                    281:                ;;
                    282:        *)
                    283:                echo bad unit for $name in: $i
                    284:                ;;
                    285:        esac
                    286:        ;;
                    287: 
                    288: pty*)
                    289:        class=`expr $i : 'pty\(.*\)'`
                    290:        case $class in
                    291:        0) offset=0 name=p;;
                    292:        1) offset=16 name=q;;
                    293:        2) offset=32 name=r;;
                    294:        3) offset=48 name=s;;
                    295:        4) offset=64 name=t;;
                    296:        5) offset=80 name=u;;
                    297:        *) echo bad unit for pty in: $i;;
                    298:        esac
                    299:        case $class in
                    300:        0|1|2|3|4|5)
                    301:                umask 0
                    302:                eval `echo $offset $name | awk ' { b=$1; n=$2 } END {
                    303:                        for (i = 0; i < 16; i++)
                    304:                                printf("/etc/mknod tty%s%x c 20 %d; \
                    305:                                        /etc/mknod pty%s%x c 21 %d; ", \
                    306:                                        n, i, b+i, n, i, b+i); }'`
                    307:                umask 77
                    308:                ;;
                    309:        esac
                    310:        ;;
                    311: 
                    312: np*)
                    313:        class=`expr $i : 'np\(.*\)'`
                    314:        case $class in
                    315:        0) offset=0 name=0;;
                    316:        1) offset=16 name=1;;
                    317:        2) offset=32 name=2;;
                    318:        *) echo bad unit for np in: $i;;
                    319:        esac
                    320:        case $class in
                    321:        0|1|2)
                    322:                eval `echo $offset | awk ' { b=$1 } END {
                    323:                        for (i = 0; i < 4; i++)
                    324:                                printf("/etc/mknod np%02d c 39 %d;", \
                    325:                                        b+i, b+i); }'`
                    326:                ;;
                    327:        esac
                    328:        ;;
                    329: 
                    330: dn*|ik*|ps*|ad*|ct*)
                    331:        unit=`expr $i : '..\(.*\)'`
                    332:        case $i in
                    333:        ct*) name=ct; chr=18;;
                    334:        dn*) name=cu; chr=24;;
                    335:        ps*) name=ps; chr=27;;
                    336:        ad*) name=ad; chr=29;;
                    337:        ik*) name=ik; chr=31;;
                    338:        esac
                    339:        case $unit in
                    340:        0|1|2|3|4|5|6|7)
                    341:                umask 0
                    342:                /etc/mknod ${name}${unit} c ${chr} ${unit}
                    343:                umask 77
                    344:                ;;
                    345:        *)
                    346:                echo bad unit for ${name} in: $i
                    347:                ;;
                    348:        esac
                    349:        ;;
                    350: 
                    351: qv0)
                    352:        /etc/mknod qv0 c 40 0
                    353:        /etc/mknod qvcons c 40 1
                    354:        /etc/mknod mouse c 40 2
                    355:        ;;
                    356: 
                    357: ttyv0)
                    358:        if [ ! -f ttyqe ]; then sh ./MAKEDEV pty1; fi
                    359:        mv ttyqf ttyv0
                    360:        mv ptyqf ptyv0
                    361:        ;;
                    362: 
                    363: local)
                    364:        sh MAKEDEV.local
                    365:        ;;
                    366: esac
                    367: done

unix.superglobalmegacorp.com

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.