Annotation of 43BSDReno/etc/etc.vax/MAKEDEV, revision 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.33 (Berkeley) 3/16/90
        !             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: PATH=/sbin:/bin:/usr/bin
        !            52: umask 77
        !            53: for i
        !            54: do
        !            55: case $i in
        !            56: 
        !            57: std)
        !            58:        mknod console           c 0 0
        !            59:        mknod drum              c 7 0   ; chmod 640 drum ; chgrp kmem drum
        !            60:        mknod floppy            c 8 0
        !            61:        mknod crl               c 35 0
        !            62:        mknod csa1              c 51 0
        !            63:        mknod csa2              c 51 1
        !            64:        mknod tu0               b 8 0
        !            65:        mknod tu1               b 8 1
        !            66:        mknod kUmem             c 3 3   ; chmod 600 kUmem
        !            67:        mknod kmem              c 3 1   ; chmod 640 kmem ; chgrp kmem kmem
        !            68:        mknod mem               c 3 0   ; chmod 640 mem ; chgrp kmem mem
        !            69:        mknod null              c 3 2   ; chmod 666 null
        !            70:        mknod tty               c 2 0   ; chmod 666 tty
        !            71:        mknod klog              c 33 0  ; chmod 600 klog
        !            72:        mknod stdin             c 53 0  ; chmod 666 stdin
        !            73:        mknod stdout            c 53 1  ; chmod 666 stdout
        !            74:        mknod stderr            c 53 2  ; chmod 666 stderr
        !            75:        mkdir fd > /dev/null 2>&1
        !            76:        (cd fd && eval `echo "" | awk ' BEGIN { \
        !            77:                for (i = 0; i < 64; i++) \
        !            78:                        printf("mknod %d c 53 %d;", i, i)}'`)
        !            79:        chown -R bin.bin fd
        !            80:        chmod 555 fd
        !            81:        chmod 666 fd/*
        !            82:        ;;
        !            83: 
        !            84: ht*|tm*|tms*|ts*|ut*)
        !            85:        umask 0 ; unit=`expr $i : '[^0-9]*\(.*\)'`
        !            86:        case $i in
        !            87:        ht*) blk=1; chr=5 ;;
        !            88:        tms*) blk=15; chr=38;;
        !            89:        tm*) blk=5; chr=14;;
        !            90:        ts*) blk=6; chr=16;;
        !            91:        ut*) blk=10; chr=17;;
        !            92:        esac
        !            93:        case $unit in
        !            94:        0|1|2|3|4|5|6|7)
        !            95:                four=`expr $unit + 4` ; eight=`expr $unit + 8`
        !            96:                twelve=`expr $unit + 12`; twenty=`expr $unit + 20`
        !            97:                mknod mt$unit           b $blk $unit
        !            98:                mknod mt$four           b $blk $four
        !            99:                mknod mt$eight          b $blk $eight
        !           100:                mknod mt$twelve         b $blk $twelve
        !           101:                mknod nmt$unit          b $blk $four ;: sanity w/pdp11 v7
        !           102:                mknod nmt$eight         b $blk $twelve ;: ditto
        !           103:                mknod nrmt$unit         c $chr $four ;: sanity w/pdp11 v7
        !           104:                mknod nrmt$eight        c $chr $twelve ;: ditto
        !           105:                mknod rmt$unit          c $chr $unit
        !           106:                mknod rmt$four          c $chr $four
        !           107:                mknod rmt$eight         c $chr $eight
        !           108:                mknod rmt$twelve        c $chr $twelve
        !           109:                if [ $i = ut ] 
        !           110:                then
        !           111:                        mknod mt$twenty         b $blk $twenty
        !           112:                        mknod rmt$twenty        c $chr $twenty
        !           113:                fi
        !           114:                ;;
        !           115:        *)
        !           116:                echo bad unit for tape in: $1
        !           117:                ;;
        !           118:        esac
        !           119:        umask 77
        !           120:        ;;
        !           121: 
        !           122: mt*)
        !           123:        umask 0 ; unit=`expr $i : '..\(.*\)'`
        !           124:        case $i in
        !           125:        mt*) blk=7; chr=19;;
        !           126:        esac
        !           127:        case $unit in
        !           128:        0|1|2|3|4|5|6|7)
        !           129:                eight=`expr $unit + 0`;
        !           130:                twelve=`expr $unit + 4`; 
        !           131:                sixteen=`expr $unit + 8`;
        !           132:                twenty=`expr $unit + 12`;
        !           133:                mknod mt8               b $blk $eight
        !           134:                mknod mt12              b $blk $twelve
        !           135:                mknod mt16              b $blk $sixteen
        !           136:                mknod mt20              b $blk $twenty
        !           137:                mknod nmt8              b $blk $twelve ;: ditto
        !           138:                mknod nrmt8             c $chr $twelve ;: ditto
        !           139:                mknod rmt8              c $chr $eight
        !           140:                mknod rmt12             c $chr $twelve
        !           141:                mknod rmt16             c $chr $sixteen
        !           142:                mknod rmt20             c $chr $twenty
        !           143:                mknod nmt16             b $blk $twenty ;: ditto
        !           144:                mknod nrmt16            c $chr $twenty ;: ditto
        !           145:                ;;
        !           146:        *)
        !           147:                echo bad unit for tape in: $1
        !           148:                ;;
        !           149:        esac
        !           150:        umask 77
        !           151:        ;;
        !           152: 
        !           153: hp*|hk*|up*|ra*|kra*|rl*|rb*)
        !           154:        umask 2 ; unit=`expr $i : '..\(.*\)'`
        !           155:        case $i in
        !           156:        hp*) name=hp; blk=0; chr=4;;
        !           157:        hk*) name=hk; blk=3; chr=11;;
        !           158:        up*) name=up; blk=2; chr=13;;
        !           159:        ra*) name=ra; blk=9; chr=9;;
        !           160:        kra*) name=kra; blk=16; chr=52;;
        !           161:        rb*) name=rb; blk=11; chr=23;;
        !           162:        rl*) name=rl; blk=14; chr=32;;
        !           163:        esac
        !           164:        case $unit in
        !           165:        0|1|2|3|4|5|6|7|8|9|10|11|12|13|14|15|16|\
        !           166:        17|18|19|20|21|22|23|24|25|26|27|28|29|30|31)
        !           167:                mknod ${name}${unit}a   b $blk `expr $unit '*' 8 + 0`
        !           168:                mknod ${name}${unit}b   b $blk `expr $unit '*' 8 + 1`
        !           169:                mknod ${name}${unit}c   b $blk `expr $unit '*' 8 + 2`
        !           170:                mknod ${name}${unit}g   b $blk `expr $unit '*' 8 + 6`
        !           171:                mknod r${name}${unit}a  c $chr `expr $unit '*' 8 + 0`
        !           172:                mknod r${name}${unit}b  c $chr `expr $unit '*' 8 + 1`
        !           173:                mknod r${name}${unit}c  c $chr `expr $unit '*' 8 + 2`
        !           174:                mknod r${name}${unit}g  c $chr `expr $unit '*' 8 + 6`
        !           175:                if [ $name != hk ]
        !           176:                then
        !           177:                mknod ${name}${unit}d   b $blk `expr $unit '*' 8 + 3`
        !           178:                mknod ${name}${unit}e   b $blk `expr $unit '*' 8 + 4`
        !           179:                mknod ${name}${unit}f   b $blk `expr $unit '*' 8 + 5`
        !           180:                mknod ${name}${unit}h   b $blk `expr $unit '*' 8 + 7`
        !           181:                mknod r${name}${unit}d  c $chr `expr $unit '*' 8 + 3`
        !           182:                mknod r${name}${unit}e  c $chr `expr $unit '*' 8 + 4`
        !           183:                mknod r${name}${unit}f  c $chr `expr $unit '*' 8 + 5`
        !           184:                mknod r${name}${unit}h  c $chr `expr $unit '*' 8 + 7`
        !           185:                fi
        !           186:                chgrp operator ${name}${unit}[a-h] r${name}${unit}[a-h]
        !           187:                chmod 640 ${name}${unit}[a-h] r${name}${unit}[a-h]
        !           188:                ;;
        !           189:        *)
        !           190:                echo bad unit for disk in: $i
        !           191:                ;;
        !           192:        esac
        !           193:        umask 77
        !           194:        ;;
        !           195: 
        !           196: rx*)
        !           197:        unit=`expr $i : '..\(.*\)'`
        !           198:        name=rx; chr=30; blk=12;
        !           199:        case $unit in
        !           200:        0|1|2|3|4|5|6|7)
        !           201:                mknod ${name}${unit}    b $blk `expr $unit '*' 8 + 0`
        !           202:                mknod r${name}${unit}a  c $chr `expr $unit '*' 8 + 0`
        !           203:                mknod r${name}${unit}b  c $chr `expr $unit '*' 8 + 1`
        !           204:                mknod r${name}${unit}c  c $chr `expr $unit '*' 8 + 2`
        !           205:                mknod r${name}${unit}d  c $chr `expr $unit '*' 8 + 3`
        !           206:                ;;
        !           207:        *)
        !           208:                echo bad unit for floppy disk in: $i
        !           209:                ;;
        !           210:        esac
        !           211:        ;;
        !           212: 
        !           213: uu*)
        !           214:        unit=`expr $i : '..\(.*\)'`
        !           215:        name=uu; blk=13;
        !           216:        case $unit in
        !           217:        0|1|2|3)
        !           218:                mknod ${name}${unit}    b $blk `expr $unit '*' 2 + 0`
        !           219:                mknod ${name}${unit}a   b $blk `expr $unit '*' 2 + 1`
        !           220:                ;;
        !           221:        *)
        !           222:                echo bad unit for uu cassette in: $i
        !           223:                ;;
        !           224:        esac
        !           225:        ;;
        !           226: 
        !           227: dz*)
        !           228:        unit=`expr $i : 'dz\(.*\)'`
        !           229:        case $unit in
        !           230:        0|1|2|3|4|5|6|7)
        !           231:                eval `echo $unit | awk ' { u = $1 } END {
        !           232:                    for (i = 0; i < 8; i++)
        !           233:                        printf("mknod tty%02d c 1 %d; ",u*8+i,u*8+i); }'`
        !           234:                ;;
        !           235:        *)
        !           236:                echo bad unit for dz in: $i
        !           237:                ;;
        !           238:        esac
        !           239:        ;;
        !           240: 
        !           241: dhu*|dh*|dmf*|dmz*)
        !           242:        case $i in
        !           243:        dmz*)   name=dmz; major=37; count=24;
        !           244:                unit=`expr $i : "$name\(.*\)"`
        !           245:                case $unit in
        !           246:                0) ch=a ;; 1) ch=b ;; 2) ch=c ;; 3) ch=e ;;
        !           247:                4) ch=f ;; 5) ch=g ;;
        !           248:                *) echo bad unit for $name in: $i ;;
        !           249:                esac;;
        !           250:        dmf*)   name=dmf; major=22; count=8;
        !           251:                unit=`expr $i : "$name\(.*\)"`
        !           252:                case $unit in
        !           253:                0) ch=A ;; 1) ch=B ;; 2) ch=C ;; 3) ch=E ;;
        !           254:                4) ch=F ;; 5) ch=G ;; 6) ch=H ;; 7) ch=I ;;
        !           255:                *) echo bad unit for $name in: $i ;;
        !           256:                esac;;
        !           257:        dhu*)   name=dhu; major=34; count=16;
        !           258:                unit=`expr $i : "$name\(.*\)"`;
        !           259:                case $unit in
        !           260:                0) ch=S ;; 1) ch=T ;; 2) ch=U ;; 3) ch=V ;;
        !           261:                4) ch=W ;; 5) ch=X ;; 6) ch=Y ;; 7) ch=Z ;;
        !           262:                *) echo bad unit for $name in: $i ;;
        !           263:                esac;;
        !           264:        dh*)    name=dh; major=12; count=16;
        !           265:                unit=`expr $i : "$name\(.*\)"`
        !           266:                case $unit in
        !           267:                0) ch=h ;; 1) ch=i ;; 2) ch=j ;; 3) ch=k ;;
        !           268:                4) ch=l ;; 5) ch=m ;; 6) ch=n ;; 7) ch=o ;;
        !           269:                *) echo bad unit for $name in: $i ;;
        !           270:                esac;;
        !           271:        esac
        !           272:        eval `echo $ch $unit $major $count |
        !           273:          awk ' { ch = $1; u = $4 * $2; m = $3; cnt = $4 } END {
        !           274:            for (i = 0; i < cnt; i++)
        !           275:              if (i < 10)
        !           276:                printf("mknod tty%s%x c %d %d; ",ch,i,m,u+i);
        !           277:              else
        !           278:                printf("mknod tty%s%c c %d %d; ",ch,87+i,m,u+i); }'`
        !           279:        ;;
        !           280: 
        !           281: lp*|va*|vp*)
        !           282:        case $i in
        !           283:        lp*) name=lp; major=15;;
        !           284:        va*) name=va; major=10;;
        !           285:        vp*) name=vp; major=6;;
        !           286:        esac
        !           287:        unit=`expr $i : "$name\(.*\)"`
        !           288:        case $unit in
        !           289:        0|1|2|3|4|5|6|7)
        !           290:                mknod $i c $major $unit;
        !           291:                chmod 666 $i
        !           292:                ;;
        !           293:        *)
        !           294:                echo bad unit for $name in: $i
        !           295:                ;;
        !           296:        esac
        !           297:        ;;
        !           298: 
        !           299: pty*)
        !           300:        class=`expr $i : 'pty\(.*\)'`
        !           301:        case $class in
        !           302:        0) offset=0 name=p;;
        !           303:        1) offset=16 name=q;;
        !           304:        2) offset=32 name=r;;
        !           305:        3) offset=48 name=s;;
        !           306:        4) offset=64 name=t;;
        !           307:        5) offset=80 name=u;;
        !           308:        *) echo bad unit for pty in: $i;;
        !           309:        esac
        !           310:        case $class in
        !           311:        0|1|2|3|4|5)
        !           312:                umask 0
        !           313:                eval `echo $offset $name | awk ' { b=$1; n=$2 } END {
        !           314:                        for (i = 0; i < 16; i++)
        !           315:                                printf("mknod tty%s%x c 20 %d; \
        !           316:                                        mknod pty%s%x c 21 %d; ", \
        !           317:                                        n, i, b+i, n, i, b+i); }'`
        !           318:                umask 77
        !           319:                ;;
        !           320:        esac
        !           321:        ;;
        !           322: 
        !           323: np*)
        !           324:        class=`expr $i : 'np\(.*\)'`
        !           325:        case $class in
        !           326:        0) offset=0 name=0;;
        !           327:        1) offset=16 name=1;;
        !           328:        2) offset=32 name=2;;
        !           329:        *) echo bad unit for np in: $i;;
        !           330:        esac
        !           331:        case $class in
        !           332:        0|1|2)
        !           333:                eval `echo $offset | awk ' { b=$1 } END {
        !           334:                        for (i = 0; i < 4; i++)
        !           335:                                printf("mknod np%02d c 39 %d;", \
        !           336:                                        b+i, b+i); }'`
        !           337:                ;;
        !           338:        esac
        !           339:        ;;
        !           340: 
        !           341: dn*|ik*|ps*|ad*|ct*)
        !           342:        unit=`expr $i : '..\(.*\)'`
        !           343:        case $i in
        !           344:        ct*) name=ct; chr=18;;
        !           345:        dn*) name=cu; chr=24;;
        !           346:        ps*) name=ps; chr=27;;
        !           347:        ad*) name=ad; chr=29;;
        !           348:        ik*) name=ik; chr=31;;
        !           349:        esac
        !           350:        case $unit in
        !           351:        0|1|2|3|4|5|6|7)
        !           352:                umask 0
        !           353:                mknod ${name}${unit} c ${chr} ${unit}
        !           354:                umask 77
        !           355:                ;;
        !           356:        *)
        !           357:                echo bad unit for ${name} in: $i
        !           358:                ;;
        !           359:        esac
        !           360:        ;;
        !           361: 
        !           362: qv0)
        !           363:        mknod qv0 c 40 0
        !           364:        mknod qvcons c 40 1
        !           365:        mknod mouse c 40 2
        !           366:        ;;
        !           367: 
        !           368: ttyv0)
        !           369:        if [ ! -f ttyqe ]; then sh ./MAKEDEV pty1; fi
        !           370:        mv ttyqf ttyv0
        !           371:        mv ptyqf ptyv0
        !           372:        ;;
        !           373: 
        !           374: local)
        !           375:        sh MAKEDEV.local
        !           376:        ;;
        !           377: esac
        !           378: done

unix.superglobalmegacorp.com

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