Annotation of cci/dev/MAKEDEV, revision 1.1.1.1

1.1       root        1: #! /bin/sh
                      2: #      @(#)MAKEDEV     4.16    7/23/83
                      3: #
                      4: # Device "make" file.  Valid arguments:
                      5: #      std     standard devices
                      6: #      local   configuration specific devices
                      7: # Tapes:
                      8: #      cy*     Cipher
                      9: # Disks:
                     10: #      fsd*    VDDC 160Mb FSD
                     11: #      smd*    VDDC 300Mb SMD
                     12: #      xfd*    VDDC 340Mb XFSD
                     13: #      fuj*    VDDC 360Mb Fujitsu
                     14: #      xsd*    VDDC 515Mb XFSD
                     15: # Terminal multiplexors:
                     16: #      vx*     VIOC
                     17: # Pseudo terminals:
                     18: #      pty*    set of 32 master and slave pseudo terminals
                     19: # Printers:
                     20: # Call units:
                     21: # Special purpose devices:
                     22: umask 77
                     23: for i
                     24: do
                     25: case $i in
                     26: 
                     27: std)
                     28:        /etc/mknod CP           c 0 0
                     29:        /etc/mknod console      c 0 1
                     30:        /etc/mknod remote       c 0 2
                     31:        /etc/mknod drum         c 8 0   ; chmod 644 drum
                     32:        /etc/mknod vmem         c 3 3   ; chmod 644 vmem
                     33:        /etc/mknod kmem         c 3 1   ; chmod 644 kmem
                     34:        /etc/mknod mem          c 3 0   ; chmod 644 mem
                     35:        /etc/mknod null         c 3 2   ; chmod 666 null
                     36:        /etc/mknod tty          c 2 0   ; chmod 666 tty
                     37:        ;;
                     38: 
                     39: cy*)
                     40:        umask 0 ; unit=`expr $i : '..\(.*\)'`
                     41:        case $i in
                     42:        cy*) blk=3; chr=7 ;;
                     43:        esac
                     44:        case $unit in
                     45:        0|1|2|3|4|5|6|7|8|9|10|11|12|13|14|15)
                     46:                u8=`expr $unit + 128`
                     47:                /etc/mknod cy"$unit"s   b $blk $unit; ln cy"$unit"s mt$unit
                     48:                /etc/mknod ncy"$unit"s  b $blk $u8; ln ncy"$unit"s nmt$unit
                     49:                /etc/mknod rcy"$unit"s  c $chr $unit; ln rcy"$unit"s rmt$unit
                     50:                /etc/mknod rncy"$unit"s c $chr $u8; ln rncy"$unit"s nrmt$unit
                     51:                umask 77
                     52:                ;;
                     53:        *)
                     54:                echo bad unit for tape in: $1
                     55:                ;;
                     56:        esac
                     57:        ;;
                     58: 
                     59: fsd*|smd*|xfd*|fuj*|xsd*)
                     60:        unit=`expr $i : '...\(.*\)'`
                     61:        case $i in
                     62:        fsd*) name=fsd; blk=1; chr=5;;
                     63:        smd*) name=smd; blk=1; chr=5;;
                     64:        xfd*) name=xfd; blk=1; chr=5;;
                     65:        fuj*) name=fuj; blk=1; chr=5;;
                     66:        xsd*) name=xsd; blk=1; chr=5;;
                     67:        esac
                     68:        case $unit in
                     69:        0|1|2|3|4|5|6|7|8|9|a|b|c|d|e|f)
                     70:                case $unit in
                     71:                a) u=10 ;;
                     72:                b) u=11 ;;
                     73:                c) u=12 ;;
                     74:                d) u=13 ;;
                     75:                e) u=14 ;;
                     76:                f) u=15 ;;
                     77:                *) u=$unit ;;
                     78:                esac
                     79: 
                     80:                /etc/mknod ${name}${unit}a      b $blk `expr $u '*' 8 + 0`
                     81:                /etc/mknod ${name}${unit}b      b $blk `expr $u '*' 8 + 1`
                     82:                /etc/mknod ${name}${unit}c      b $blk `expr $u '*' 8 + 2`
                     83:                /etc/mknod ${name}${unit}d      b $blk `expr $u '*' 8 + 3`
                     84:                /etc/mknod ${name}${unit}e      b $blk `expr $u '*' 8 + 4`
                     85:                /etc/mknod ${name}${unit}f      b $blk `expr $u '*' 8 + 5`
                     86:                /etc/mknod r${name}${unit}a     c $chr `expr $u '*' 8 + 0`
                     87:                /etc/mknod r${name}${unit}b     c $chr `expr $u '*' 8 + 1`
                     88:                /etc/mknod r${name}${unit}c     c $chr `expr $u '*' 8 + 2`
                     89:                /etc/mknod r${name}${unit}d     c $chr `expr $u '*' 8 + 3`
                     90:                /etc/mknod r${name}${unit}e     c $chr `expr $u '*' 8 + 4`
                     91:                /etc/mknod r${name}${unit}f     c $chr `expr $u '*' 8 + 5`
                     92: 
                     93:                chmod 644 ${name}${unit}a
                     94:                chmod 644 ${name}${unit}b
                     95:                chmod 644 ${name}${unit}c
                     96:                chmod 644 ${name}${unit}d
                     97:                chmod 644 ${name}${unit}e
                     98:                chmod 644 ${name}${unit}f
                     99:                chmod 644 r${name}${unit}a
                    100:                chmod 644 r${name}${unit}b
                    101:                chmod 644 r${name}${unit}c
                    102:                chmod 644 r${name}${unit}d
                    103:                chmod 644 r${name}${unit}e
                    104:                chmod 644 r${name}${unit}f
                    105:                ;;
                    106:        *)
                    107:                echo bad unit for disk in: $i
                    108:                ;;
                    109:        esac
                    110:        ;;
                    111: 
                    112: vx*)
                    113:        unit=`expr $i : 'vx\(.*\)'`
                    114:        case $unit in
                    115:        0|1|2|3|4|5|6|7|8|9|a|b|c|d|e|f)
                    116:                case $unit in
                    117:                a) un=10 ;;
                    118:                b) un=11 ;;
                    119:                c) un=12 ;;
                    120:                d) un=13 ;;
                    121:                e) un=14 ;;
                    122:                f) un=15 ;;
                    123:                *) un=$unit ;;
                    124:                esac
                    125:                eval `echo $un | awk ' { u = $1 } END {
                    126:                    for (i = 0; i < 16; i++)
                    127:                        printf("/etc/mknod tty%02x c 1 %d; ",u*16+i,u*16+i); }'`
                    128:                ls -1 tty?? | grep [A-F] | while read x; do
                    129:                        y=`echo $x | tr [A-F] [a-f]`
                    130:                        mv $x $y
                    131:                done
                    132:                ;;
                    133:        *)
                    134:                echo bad unit for vx in: $i
                    135:                ;;
                    136:        esac
                    137:        ;;
                    138: 
                    139: pty*)
                    140:        class=`expr $i : 'pty\(.*\)'`
                    141:        case $class in
                    142:        0) offset=0 name=p;;
                    143:        1) offset=16 name=q;;
                    144:        2) offset=32 name=r;;
                    145:        *) echo bad unit for pty in: $i;;
                    146:        esac
                    147:        case $class in
                    148:        0|1|2)
                    149:                umask 0
                    150:                eval `echo $offset $name | awk ' { b=$1; n=$2 } END {
                    151:                        for (i = 0; i < 16; i++)
                    152:                                printf("/etc/mknod tty%s%x c 9 %d; \
                    153:                                        /etc/mknod pty%s%x c 10 %d; ", \
                    154:                                        n, i, b+i, n, i, b+i); }'`
                    155:                ls -1 tty?? | grep [A-F] | while read x; do
                    156:                        y=`echo $x | tr [A-F] [a-f]`
                    157:                        mv $x $y
                    158:                done
                    159:                ls -1 pty?? | grep [A-F] | while read x; do
                    160:                        y=`echo $x | tr [A-F] [a-f]`
                    161:                        mv $x $y
                    162:                done
                    163:                umask 77
                    164:                ;;
                    165:        esac
                    166:        ;;
                    167: 
                    168: lock)
                    169:        /etc/mknod iilock c 14 0
                    170:        chmod 600  iilock
                    171:        ;;
                    172: 
                    173: local)
                    174:        sh MAKEDEV.local
                    175:        ;;
                    176: esac
                    177: done

unix.superglobalmegacorp.com

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