Chip 1995 March/CHIP3.mdf/slackwar/a/util/util-lin.2/util-lin/util-linux-2.2/sys-utils/MAKEDEV

Text File | 1995-02-22 | 11.6 KB | 487 lines

#! /bin/sh -

RCSID='MAKEDEV,v 1.1.1.1 1995/02/22 19:09:11 faith Exp'

#---#---#---#---#---#---#---#---#---#---#---#---#---#---#---#---#---#---#---#
# Customisation:
#   The devices fall into various classes.  This section contains the mapping
# from a class name into a group name and permission.
#   You will almost certainly need to edit the group name to match your
# system, and you may change the permissions to suit your preference.  These
# lines _must_ be of the format "user group perm".

 public="  root system 666"
 system="  root system 660"
   kmem="  root kmem   660"
    tty="  root tty    666"
   cons="  root tty    622"    # 622 for console?
dialout="  root uucp   660"
  mouse="  root system 666"
printer="  root daemon 660"
 floppy="  root floppy 660"
   disk="  root disk   660"
   scsi="  root system 600"
  cdrom="  root disk   660"
   tape="  root disk   660"
  audio="  root system 666"
  ibcs2="  root system 666"
scanner="  root system 666"

#---#---#---#---#---#---#---#---#---#---#---#---#---#---#---#---#---#---#---#

procfs=/proc

opt_v=
opt_d=
opt_n=

while [ $# -ge 1 ]
do
    case $1 in
        --)    shift; break ;;
        -v)    shift; opt_v=1 ;;
        -d)    shift; opt_d=1 ;;
        -n)    shift; opt_n=1; opt_v=1 ;;
        -V)    shift; opt_V=1 ;;
        -*)    echo "$0: unknown flag \"$1\"" >&2; exit 1 ;;
        *)    break ;;
    esac
done

if [ "$opt_V" ]
then
    echo "$RCSID"
    exit 0
fi

opts="${opt_n:+-n} ${opt_v:+-v} ${opt_d:+-d}"

makedev () {    # usage: makedev name [bcu] major minor owner group mode
    if [ "$opt_v" ]
    then    if [ "$opt_d" ]
        then    echo "delete $1"
        else    echo "create $1    $2 $3 $4 $5:$6 $7"
        fi
    fi
    if [ ! "$opt_n" ]
    then    if [ "$opt_d" ]
        then
            rm -f $1
        else
            mknod $1- $2 $3 $4 &&
            chown $5:$6 $1- &&
            chmod $7 $1- &&
            mv $1- $1
        fi
    fi
}
symlink () {    # usage: symlink name target
    if [ "$opt_v" ]
    then    if [ "$opt_d" ]
        then    echo "delete $1"
        else    echo "create $1    -> $2"
        fi
    fi
    [ ! "$opt_n" ] && rm -f $1 &&
    [ ! "$opt_d" ] && ln -s $2 $1
}

devices=
if [ ! -f $procfs/devices ]
then
    echo "$0: warning: can't read $procfs/devices" >&2
else
    exec 3<$procfs/devices
    while read major device <&3
    do
        case "$major" in
            Character|Block|'')
                ;;
            *)
                eval "major_$device=$major"
                devices="$devices $device"
                ;;
        esac
    done
    exec 3<&-
fi

Major () {
    device=$2
    if [ "$opt_d" ]
    then
        echo -1    # don't care
    else
        eval echo \${major_$1:-\${device:?\"unknown major number for $1\"}}
    fi
}

cvt () {
    while [ $# -ne 0 ]
    do
        case "$1" in
            mem|tty|ttyp|cua|cub)    ;;
            hd)    echo hda hdb ;;
            xd)    echo xda xdb ;;
            fd)    echo fd0 fd1 ;;
            lp)    echo lp0 lp1 lp2 ;;
            mt)    echo ftape ;;
            loop)    echo loop ;;
            ibcs2)    echo ibcs2 ;;
            tpqic02)    echo qic ;;
            sound)        echo audio ;;
            logiscan)    echo logiscan ;;
            ac4096)        echo ac4096 ;;
            idecd)    echo idecd ;;
            hw)    echo helloworld ;;
            sbpcd | sbpcd[123])    echo $1 ;;
            Joystick)    echo js ;;
            apm_bios)    echo apm ;;
            dcf)        echo dcf ;;
            pcmcia)    ;; # taken care of by its own driver
            ttyC)    echo cyclades ;;
            *)    echo "$0: don't know what \"$1\" is" >&2 ;;
        esac
        shift
    done
}

for arg
do
    case $arg in
    generic)
        $0 $opts std
        $0 $opts fd0 fd1
        $0 $opts hda hdb
        $0 $opts xda xdb
        $0 $opts sda sdb
        $0 $opts ptyp ptyq ptyr ptys
        $0 $opts console tty1 tty2 tty3 tty4 tty5 tty6 tty7 tty8
        $0 $opts ttyS0 ttyS1 ttyS2 ttyS3
        $0 $opts busmice
        $0 $opts lp0 lp1 lp2
        $0 $opts par0 par1 par2
        $0 $opts fd
        ;;
    local)
        $0.local $opts
        ;;
    std)
        makedev mem  c 1 1 $kmem
        makedev kmem c 1 2 $kmem
        makedev null c 1 3 $public
        makedev port c 1 4 $kmem
        makedev zero c 1 5 $public
        symlink core $procfs/kcore
        makedev full c 1 7 $public
        makedev ram  b 1 1 $disk
        makedev tty  c 5 0 $tty
        ;;
    console|tty0)
        makedev $arg c 4 0 $cons
        ;;
    tty[1-9]|tty[1-5][0-9]|tty[6][0-3])
        line=`expr $arg : "tty\(.*\)"`
        makedev tty$line c 4 $line $tty
        ;;
    ttyS[0-9]|ttyS[1-5][0-9]|ttyS[6][0-3])
        line=`expr $arg : "ttyS\(.*\)"`
        minor=`expr 64 + $line`
        makedev ttyS$line c 4 $minor $tty
        makedev cua$line c 5 $minor $dialout
        ;;
    pty[p-s])
        # Currently limited to 64 master/slave pairs.
        bank=`expr $arg : "pty\(.\)"`
        base=`expr \( pqrs : ".*$bank" - 1 \) \* 16`
        for i in 0 1 2 3 4 5 6 7 8 9 a b c d e f
        do
            j=`expr 0123456789abcdef : ".*$i" - 1`
            makedev pty$bank$i c 4 `expr 128 + $base + $j` $tty
            makedev tty$bank$i c 4 `expr 192 + $base + $j` $tty
        done
        ;;
    cyclades)
        major1=`Major ttyC` || continue
        major2=`Major cub` || continue
        for i in 0 1 2 3 4 5 6 7 # 8 9 10 11 12 13 14 15
        do
            makedev ttyC$i c $major1 `expr 32 + $i` $tty
            makedev cub$i c $major2 `expr 32 + $i` $dialout
        done
        ;;
    par[0-2])
        major=`Major lp 6` || continue
        port=`expr $arg : "par\(.\)"`
        makedev $arg c $major $port $printer
        ;;
    lp[0-2])
        major=`Major lp 6` || continue
        port=`expr $arg : "lp\(.\)"`
        makedev $arg c $major $port $printer
        ;;
    busmice)
        major=`Major mouse 10` || continue
        makedev logibm   c $major 0 $mouse
        makedev psaux    c $major 1 $mouse
        makedev inportbm c $major 2 $mouse
        makedev atibm    c $major 3 $mouse
        # makedev sejin    c $major 4 $mouse
        ;;
    js)
        major=`Major Joystick` || continue
        makedev js0 c $major 0 $mouse
        makedev js1 c $major 1 $mouse
        ;;
    fd[0-4])
        major=`Major fd 2` || continue
        unit=`expr $arg : "fd\(.\)"`
        makedev fd${unit} b $major $unit $floppy
        makedev fd${unit}d360  b $major `expr $unit +  4` $floppy
        makedev fd${unit}h1200 b $major `expr $unit +  8` $floppy
        makedev fd${unit}D360  b $major `expr $unit + 12` $floppy
        symlink fd${unit}H360 fd${unit}D360
        makedev fd${unit}D720  b $major `expr $unit + 16` $floppy
        symlink fd${unit}H720 fd${unit}D720
        makedev fd${unit}h360  b $major `expr $unit + 20` $floppy
        makedev fd${unit}h720  b $major `expr $unit + 24` $floppy
        makedev fd${unit}H1440 b $major `expr $unit + 28` $floppy
        makedev fd${unit}E2880 b $major `expr $unit + 32` $floppy
        makedev fd${unit}CompaQ b $major `expr $unit + 36` $floppy

        makedev fd${unit}h1440 b $major `expr $unit + 40` $floppy
        makedev fd${unit}H1680 b $major `expr $unit + 44` $floppy
        makedev fd${unit}h410  b $major `expr $unit + 48` $floppy
        makedev fd${unit}H820  b $major `expr $unit + 52` $floppy
        makedev fd${unit}h1476 b $major `expr $unit + 56` $floppy
        makedev fd${unit}H1722 b $major `expr $unit + 60` $floppy
        makedev fd${unit}h420  b $major `expr $unit + 64` $floppy
        makedev fd${unit}H830  b $major `expr $unit + 68` $floppy
        makedev fd${unit}h1494 b $major `expr $unit + 72` $floppy
        makedev fd${unit}H1743 b $major `expr $unit + 76` $floppy
        ;;
    hd[a-d])
        major=`Major hd 3` || continue
        unit=`expr $arg : "hd\(.\)"`
        base=`expr \( abcd : ".*$unit" - 1 \) \* 64`
        makedev hd$unit b $major $base $disk
        for part in 1 2 3 4 5 6 7 8 # 9 10 11 12 13 14 15 16
        do
            makedev hd$unit$part b $major `expr $base + $part` $disk
        done
        ;;
    hd1[a-d])
        unit=`expr $arg : "hd1\(.\)"`
        base=`expr \( abcd : ".*$unit" - 1 \) \* 64`
        makedev hd1$unit b 22 $base $disk
        for part in 1 2 3 4 5 6 7 8 # 9 10 11 12 13 14 15 16
        do
            makedev hd1$unit$part b 22 `expr $base + $part` $disk
        done
        ;;
    xd[a-d])
        major=`Major xd 13` || continue
        unit=`expr $arg : "xd\(.\)"`
        base=`expr \( abcd : ".*$unit" - 1 \) \* 64`
        makedev xd$unit b $major $base $disk
        for part in 1 2 3 4 5 6 7 8 # 9 10 11 12 13 14 15 16
        do
            makedev xd$unit$part b $major `expr $base + $part` $disk
        done
        ;;
    sd[a-h])
        major=`Major sd 8` || continue
        unit=`expr $arg : "sd\(.\)"`
        base=`expr \( abcdefgh : ".*$unit" - 1 \) \* 16`
        makedev sd$unit b $major $base $disk
        for part in 1 2 3 4 5 6 7 8 # 9 10 11 12 13 14 15
        do
            minor=`expr $base + $part`
            makedev sd$unit$part b $major $minor $disk
        done
        ;;
    loop)
        major=`Major loop` || continue
        for part in 0 1 2 3 4 5 6 7
        do
            makedev loop$part b $major $part $disk
        done
        ;;
    st[0-7])
        major=`Major st 9`
        unit=`expr $arg : "st\(.\)"`
        makedev st$unit c $major $unit $tape
        makedev nst$unit c $major `expr 128 + $unit` $tape
        ;;
    qic)
        major=`Major tpqic02 12`
        makedev rmt8       c $major   6 $tape
        makedev rmt16      c $major   8 $tape
        makedev tape-d     c $major 136 $tape
        makedev tape-reset c $major 255 $tape
        ;;
    ftape)
        major=`Major mt 27` || continue
        for unit in 0 1 2 3
        do
            makedev rft$unit c $major $unit $tape
            makedev nrft$unit c $major `expr $unit + 4` $tape
        done
        symlink ftape rft0
        symlink nftape nrft0
        ;;
    scd[0-7])
        major=`Major sr 11` || continue
        unit=`expr $arg : "scd\(.\)"`
        makedev scd$unit b $major $unit $cdrom
        ;;
    sonycd)
        major=`Major cdu31a` || continue
        makedev $arg b $major 0 $cdrom
        ;;
    mcd)
        major=`Major mcd 23` || continue
        makedev $arg b $major 0 $cdrom
        ;;
    cdu535)
        makedev $arg b 24 0 $cdrom
        ;;
    lmscd)
        makedev $arg b 24 0 $cdrom
        ;;
    sbpcd|sbpcd[123])
        major=`Major $arg` || continue
        base=`expr ${arg}0 : "sbpcd\(.\)"`
        for minor in 0 1 2 3
        do
            unit=`expr substr 0123456789abcdef \( $base \* 4 + $minor + 1 \) 1`
            makedev spbcd$unit b $major $minor $cdrom
        done
        [ $arg = sbpcd ] && symlink $arg ${arg}0
        ;;
    idecd)
        major=`Major idecd` || continue
        makedev $arg c $major 0 $cdrom
        ;;
    logiscan)
        major=`Major logiscan` || continue
        makedev $arg c $major 0 $scanner
        ;;
    m105scan)
        major=`Major m105` || continue
        makedev $arg c $major 0 $scanner
        ;;
    ac4096)
        major=`Major ac4096` || continue
        makedev $arg c $major 0 $scanner
        ;;
    audio)
        major=`Major sound 14`
        makedev mixer      c $major  0 $audio
        makedev sequencer  c $major  1 $audio
        makedev midi00     c $major  2 $audio
        makedev dsp        c $major  3 $audio
        makedev audio      c $major  4 $audio
        makedev sndstat    c $major  6 $audio
#        makedev sequencer2 c $major  8 $audio
        makedev mixer1     c $major 16 $audio
#        makedev patmgr0    c $major 17 $audio
        makedev midi01     c $major 18 $audio
        makedev dsp1       c $major 19 $audio
        makedev audio1     c $major 20 $audio
#        makedev patmgr1    c $major 33 $audio
        makedev midi02     c $major 34 $audio
        makedev midi03     c $major 50 $audio
        ;;
    pcaudio)
        major=`Major pcsp` || continue
        makedev pcmixer c $major 0 $audio
        makedev pcsp    c $major 3 $audio
        makedev pcaudio c $major 4 $audio
        ;;
    sg)
        major=`Major sg 21`
        for unit in a b c d e f g h
        do
            minor=`expr abcdefgh : ".*$unit" - 1`
            makedev $arg$unit c $major $minor $scsi
        done
        ;;
    fd)
        # not really devices, we use the /proc filesystem
        symlink fd     $procfs/self/fd
        symlink stdin  fd/0
        symlink stdout fd/1
        symlink stderr fd/2
        ;;
    ibcs2)
        major=`Major ibcs2` || continue
        makedev socksys c $major 0 $ibcs2
        symlink nfsd socksys
        makedev spx     c $major 1 $ibcs2
        symlink X0R null
        ;;
    apm)
        major=`Major apm_bios` || continue
        makedev $arg c $major 0 $system
        ;;
    dcf)
        major=`Major dcf` || continue
        makedev $arg c $major 0 $system
        ;;
    helloworld)
        major=`Major hw` || continue
        makedev helloworld c $major 0 $public
        ;;
    update)
        if [ ! "$devices" ]
        then
            echo "$0: don't appear to have any devices" >&2
            continue
        fi
        if [ "$opt_d" ]
        then
            echo "$0: can't delete an update" >&2
            continue
        fi
        create=
        delete=
        devs="$devices"
        if [ -f DEVICES ]
        then
            exec 3<DEVICES
            while read device major <&3
            do
                eval now=\$major_$device
                if [ "$now" = "" ]
                then
                    delete="$delete `cvt $device`"
                    continue
                elif [ "$now" != $major ]
                then
                    create="$create "`cvt $device`
                fi
                devs=`expr "$devs" : "\(.*\) $device"``expr "$devs" : ".* $device\(.*\)"`
            done
            exec 3<&-
        fi
        create="$create "`cvt $devs`
        $0 $opts -d $delete
        $0 $opts $create
        [ "$opt_n" ] && continue
        for device in $devices
        do
            if [ "`cvt $device`" ]
            then
                eval echo $device \$major_$device
            fi
        done > DEVICES
        ;;
    *)
        echo "$0: don't know how to make device \"$arg\"" >&2
        ;;
    esac
done

exit 0