|
|
#!/bin/sh -
|
|
|
# $OpenBSD: MAKEDEV,v 1.32 2000/09/10 16:39:42 rahnds Exp $
|
|
|
#
|
|
|
# Copyright (c) 1990 The Regents of the University of California.
|
|
|
# All rights reserved.
|
|
|
#
|
|
|
# Written and contributed by W. Jolitz 12/90
|
|
|
#
|
|
|
# Redistribution and use in source and binary forms are permitted provided
|
|
|
# that: (1) source distributions retain this entire copyright notice and
|
|
|
# comment, and (2) distributions including binaries display the following
|
|
|
# acknowledgement: ``This product includes software developed by the
|
|
|
# University of California, Berkeley and its contributors'' in the
|
|
|
# documentation or other materials provided with the distribution and in
|
|
|
# all advertising materials mentioning features or use of this software.
|
|
|
# Neither the name of the University nor the names of its contributors may
|
|
|
# be used to endorse or promote products derived from this software without
|
|
|
# specific prior written permission.
|
|
|
# THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR IMPLIED
|
|
|
# WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF
|
|
|
# MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
|
|
|
#
|
|
|
# from: @(#)MAKEDEV 5.2 (Berkeley) 6/22/90
|
|
|
# $NetBSD: MAKEDEV,v 1.17 1996/02/03 15:02:42 briggs Exp $
|
|
|
#
|
|
|
# Device "make" file. Valid arguments:
|
|
|
# all makes all known devices, including local devices.
|
|
|
# Tries to make the ``standard'' number of each type.
|
|
|
# std standard devices
|
|
|
# fd makes fd/* for the fdescfs.
|
|
|
# local configuration specific devices
|
|
|
# ramdisk makes all devices for a ramdisk kernel
|
|
|
#
|
|
|
# Tapes:
|
|
|
# st* SCSI tapes
|
|
|
#
|
|
|
# Disks:
|
|
|
# fd* Floppy disk drives (3 1/2", 5 1/4")
|
|
|
# wd* IDE disks
|
|
|
# sd* SCSI disks
|
|
|
# cd* SCSI cdrom drives
|
|
|
# vnd* "file" pseudo-disks
|
|
|
# rd* "ramdisk" pseudo-disks
|
|
|
# ccd* concatenated disk devices
|
|
|
#
|
|
|
# Terminal ports:
|
|
|
# ttyE* wscons
|
|
|
# tty* standard built-in serial ports (2)
|
|
|
#
|
|
|
# Pointing devices:
|
|
|
# wsmouse* wscons mouse events
|
|
|
#
|
|
|
# Keyboard devices:
|
|
|
# wskbd* wscons keyboard events
|
|
|
#
|
|
|
# Pseudo terminals:
|
|
|
# pty* set of 16 master and slave pseudo terminals
|
|
|
#
|
|
|
# Graphics devices:
|
|
|
# grf* custom chip (grf0), Retina Z2/Z3 (grf1/grf2),
|
|
|
# Cirrus boards (grf3), A2410 (grf4) video or
|
|
|
# CyberVision 64 (grf5)
|
|
|
#
|
|
|
# USB devices:
|
|
|
# usb* Bus control devices used by usbd for attach/detach
|
|
|
# uhid* Generic HID devices
|
|
|
# ulpt* Printer devices
|
|
|
# urio* Diamond Multimedia Rio 500
|
|
|
# ugen* Generic device
|
|
|
# utty* Serial ports
|
|
|
#
|
|
|
# Special purpose devices:
|
|
|
# ch* SCSI media changer
|
|
|
# bpf* Berkeley Packet Filter
|
|
|
# tun* network tunnel driver
|
|
|
# lkm loadable kernel modules interface
|
|
|
# *random inkernal random data source
|
|
|
#
|
|
|
|
|
|
PATH=/sbin:/bin:/usr/bin:/usr/sbin
|
|
|
this=$0
|
|
|
umask 77
|
|
|
|
|
|
# default shell support functions
|
|
|
add ()
|
|
|
{
|
|
|
tmp=0
|
|
|
while [ "$1" ]
|
|
|
do
|
|
|
tmp=$(( $1 + $tmp ))
|
|
|
shift
|
|
|
done
|
|
|
echo $tmp
|
|
|
}
|
|
|
mult ()
|
|
|
{
|
|
|
echo "$(( $1 * $2 ))"
|
|
|
}
|
|
|
hex ()
|
|
|
{
|
|
|
case $1 in
|
|
|
[0-9]) echo -n $1;;
|
|
|
10) echo -n a;;
|
|
|
11) echo -n b;;
|
|
|
12) echo -n c;;
|
|
|
13) echo -n d;;
|
|
|
14) echo -n e;;
|
|
|
15) echo -n f;;
|
|
|
esac
|
|
|
}
|
|
|
trunc ()
|
|
|
{
|
|
|
# XXX pdksh can't seem to deal with locally scoped variables
|
|
|
# in ${foo#$bar} expansions
|
|
|
arg1="$1"
|
|
|
arg2="$2"
|
|
|
echo ${arg1#$arg2}
|
|
|
}
|
|
|
unt()
|
|
|
{
|
|
|
# XXX pdksh can't seem to deal with locally scoped variables
|
|
|
# in ${foo#$bar} expansions
|
|
|
arg1="$1"
|
|
|
tmp="${arg1#[a-z]*}"
|
|
|
while [ "$tmp" != "$arg1" ]
|
|
|
do
|
|
|
arg1=$tmp
|
|
|
tmp="${arg1#[a-z]*}"
|
|
|
done
|
|
|
tmp="${arg1%*[a-z]}"
|
|
|
while [ "$tmp" != "$arg1" ]
|
|
|
do
|
|
|
arg1=$tmp
|
|
|
tmp="${arg1%*[a-z]}"
|
|
|
done
|
|
|
echo $arg1
|
|
|
}
|
|
|
|
|
|
for i
|
|
|
do
|
|
|
|
|
|
unit=`unt $1`
|
|
|
[ "$unit" ] || unit=0
|
|
|
|
|
|
case $i in
|
|
|
|
|
|
all)
|
|
|
sh $this std fd
|
|
|
sh $this wd0 wd1 wd2 wd3
|
|
|
sh $this sd0 sd1 sd2 sd3 st0 st1 cd0 cd1
|
|
|
sh $this vnd0 vnd1 vnd2 vnd3
|
|
|
sh $this ccd0 ccd1 ccd2 ccd3
|
|
|
sh $this rd0 ipl
|
|
|
sh $this ttyo0 ttyE0
|
|
|
sh $this tty00 tty01 tty02 tty03 pty0
|
|
|
sh $this bpf0 bpf1 bpf2 bpf3 bpf4 bpf5 bpf6 bpf7 bpf8 bpf9
|
|
|
sh $this tun0 tun1 tun2 tun3
|
|
|
sh $this random uk0 uk1 ss0 ss1
|
|
|
sh $this wscons0
|
|
|
sh $this lkm xfs0
|
|
|
sh $this usbs
|
|
|
sh $this local
|
|
|
;;
|
|
|
|
|
|
ramdisk)
|
|
|
sh $this std
|
|
|
sh $this wd0 wd1 wd2 wd3
|
|
|
sh $this sd0 sd1 sd2 sd3 sd4 st0 st1 cd0 cd1
|
|
|
sh $this rd0
|
|
|
sh $this ttyo0
|
|
|
sh $this random
|
|
|
sh $this tty00 tty01 pty0
|
|
|
sh $this wscons0
|
|
|
;;
|
|
|
|
|
|
std)
|
|
|
rm -f console drum kmem mem reload zero null tty
|
|
|
rm -f klog stdin stdout stderr # ksyms
|
|
|
mknod console c 0 0
|
|
|
mknod drum c 3 0 ; chmod 640 drum ; chgrp kmem drum
|
|
|
mknod kmem c 2 1 ; chmod 640 kmem ; chgrp kmem kmem
|
|
|
mknod mem c 2 0 ; chmod 640 mem ; chgrp kmem mem
|
|
|
mknod reload c 2 20 ; chmod 640 reload ; chgrp kmem reload
|
|
|
mknod zero c 2 12 ; chmod 666 zero
|
|
|
mknod null c 2 2 ; chmod 666 null
|
|
|
mknod tty c 1 0 ; chmod 666 tty
|
|
|
mknod klog c 6 0 ; chmod 600 klog
|
|
|
mknod stdin c 21 0 ; chmod 666 stdin
|
|
|
mknod stdout c 21 1 ; chmod 666 stdout
|
|
|
mknod stderr c 21 2 ; chmod 666 stderr
|
|
|
# mknod ksyms c 43 0 ; chmod 640 ksyms ; chown root.kmem ksyms
|
|
|
;;
|
|
|
|
|
|
usbs)
|
|
|
sh $this usb0 usb1
|
|
|
sh $this uhid0 uhid1 uhid2 uhid3
|
|
|
sh $this ulpt0 ulpt1
|
|
|
sh $this urio0
|
|
|
sh $this utty0 utty1
|
|
|
;;
|
|
|
|
|
|
fd)
|
|
|
rm -f fd/*
|
|
|
mkdir fd > /dev/null 2>&1
|
|
|
n=0
|
|
|
(cd fd && while [ $n -lt 64 ]; do mknod $n c 21 $n; n="$(( $n + 1 ))"; done)
|
|
|
chown -R root.wheel fd
|
|
|
chmod 555 fd
|
|
|
chmod 666 fd/*
|
|
|
;;
|
|
|
|
|
|
sd*|wd*|ccd*|ofdisk*)
|
|
|
umask 2 ; unit=${i##*[a-z]}
|
|
|
case $i in
|
|
|
sd*) name=sd; blk=2; chr=8;;
|
|
|
wd*) name=wd; blk=0; chr=11;;
|
|
|
ofdisk*) name=ofdisk; blk=4; chr=13;;
|
|
|
ccd*) name=ccd; blk=16; chr=18;;
|
|
|
esac
|
|
|
rm -f $name$unit? r$name$unit?
|
|
|
case $unit in
|
|
|
0|1|2|3|4|5|6|7|8|9)
|
|
|
mknod ${name}${unit}a b $blk $(( $unit * 16 + 0 ))
|
|
|
mknod ${name}${unit}b b $blk $(( $unit * 16 + 1 ))
|
|
|
mknod ${name}${unit}c b $blk $(( $unit * 16 + 2 ))
|
|
|
mknod ${name}${unit}d b $blk $(( $unit * 16 + 3 ))
|
|
|
mknod ${name}${unit}e b $blk $(( $unit * 16 + 4 ))
|
|
|
mknod ${name}${unit}f b $blk $(( $unit * 16 + 5 ))
|
|
|
mknod ${name}${unit}g b $blk $(( $unit * 16 + 6 ))
|
|
|
mknod ${name}${unit}h b $blk $(( $unit * 16 + 7 ))
|
|
|
mknod ${name}${unit}i b $blk $(( $unit * 16 + 8 ))
|
|
|
mknod ${name}${unit}j b $blk $(( $unit * 16 + 9 ))
|
|
|
mknod ${name}${unit}k b $blk $(( $unit * 16 + 10 ))
|
|
|
mknod ${name}${unit}l b $blk $(( $unit * 16 + 11 ))
|
|
|
mknod ${name}${unit}m b $blk $(( $unit * 16 + 12 ))
|
|
|
mknod ${name}${unit}n b $blk $(( $unit * 16 + 13 ))
|
|
|
mknod ${name}${unit}o b $blk $(( $unit * 16 + 14 ))
|
|
|
mknod ${name}${unit}p b $blk $(( $unit * 16 + 15 ))
|
|
|
mknod r${name}${unit}a c $chr $(( $unit * 16 + 0 ))
|
|
|
mknod r${name}${unit}b c $chr $(( $unit * 16 + 1 ))
|
|
|
mknod r${name}${unit}c c $chr $(( $unit * 16 + 2 ))
|
|
|
mknod r${name}${unit}d c $chr $(( $unit * 16 + 3 ))
|
|
|
mknod r${name}${unit}e c $chr $(( $unit * 16 + 4 ))
|
|
|
mknod r${name}${unit}f c $chr $(( $unit * 16 + 5 ))
|
|
|
mknod r${name}${unit}g c $chr $(( $unit * 16 + 6 ))
|
|
|
mknod r${name}${unit}h c $chr $(( $unit * 16 + 7 ))
|
|
|
mknod r${name}${unit}i c $chr $(( $unit * 16 + 8 ))
|
|
|
mknod r${name}${unit}j c $chr $(( $unit * 16 + 9 ))
|
|
|
mknod r${name}${unit}k c $chr $(( $unit * 16 + 10 ))
|
|
|
mknod r${name}${unit}l c $chr $(( $unit * 16 + 11 ))
|
|
|
mknod r${name}${unit}m c $chr $(( $unit * 16 + 12 ))
|
|
|
mknod r${name}${unit}n c $chr $(( $unit * 16 + 13 ))
|
|
|
mknod r${name}${unit}o c $chr $(( $unit * 16 + 14 ))
|
|
|
mknod r${name}${unit}p c $chr $(( $unit * 16 + 15 ))
|
|
|
chgrp operator ${name}${unit}[a-p] r${name}${unit}[a-p]
|
|
|
chmod 640 ${name}${unit}[a-p] r${name}${unit}[a-p]
|
|
|
;;
|
|
|
*)
|
|
|
echo bad unit for disk in: $i
|
|
|
;;
|
|
|
esac
|
|
|
umask 77
|
|
|
;;
|
|
|
|
|
|
vnd*)
|
|
|
umask 2 ; unit=${i##*[a-z]}
|
|
|
for name in vnd svnd; do
|
|
|
blk=14; chr=19;
|
|
|
case $name in
|
|
|
vnd) off=0;;
|
|
|
svnd) off=128;;
|
|
|
esac
|
|
|
rm -f $name$unit? r$name$unit?
|
|
|
mknod ${name}${unit}a b $blk $(( $unit * 16 + $off + 0 ))
|
|
|
mknod ${name}${unit}b b $blk $(( $unit * 16 + $off + 1 ))
|
|
|
mknod ${name}${unit}c b $blk $(( $unit * 16 + $off + 2 ))
|
|
|
mknod ${name}${unit}d b $blk $(( $unit * 16 + $off + 3 ))
|
|
|
mknod ${name}${unit}e b $blk $(( $unit * 16 + $off + 4 ))
|
|
|
mknod ${name}${unit}f b $blk $(( $unit * 16 + $off + 5 ))
|
|
|
mknod ${name}${unit}g b $blk $(( $unit * 16 + $off + 6 ))
|
|
|
mknod ${name}${unit}h b $blk $(( $unit * 16 + $off + 7 ))
|
|
|
mknod ${name}${unit}i b $blk $(( $unit * 16 + $off + 8 ))
|
|
|
mknod ${name}${unit}j b $blk $(( $unit * 16 + $off + 9 ))
|
|
|
mknod ${name}${unit}k b $blk $(( $unit * 16 + $off + 10 ))
|
|
|
mknod ${name}${unit}l b $blk $(( $unit * 16 + $off + 11 ))
|
|
|
mknod ${name}${unit}m b $blk $(( $unit * 16 + $off + 12 ))
|
|
|
mknod ${name}${unit}n b $blk $(( $unit * 16 + $off + 13 ))
|
|
|
mknod ${name}${unit}o b $blk $(( $unit * 16 + $off + 14 ))
|
|
|
mknod ${name}${unit}p b $blk $(( $unit * 16 + $off + 15 ))
|
|
|
mknod r${name}${unit}a c $chr $(( $unit * 16 + $off + 0 ))
|
|
|
mknod r${name}${unit}b c $chr $(( $unit * 16 + $off + 1 ))
|
|
|
mknod r${name}${unit}c c $chr $(( $unit * 16 + $off + 2 ))
|
|
|
mknod r${name}${unit}d c $chr $(( $unit * 16 + $off + 3 ))
|
|
|
mknod r${name}${unit}e c $chr $(( $unit * 16 + $off + 4 ))
|
|
|
mknod r${name}${unit}f c $chr $(( $unit * 16 + $off + 5 ))
|
|
|
mknod r${name}${unit}g c $chr $(( $unit * 16 + $off + 6 ))
|
|
|
mknod r${name}${unit}h c $chr $(( $unit * 16 + $off + 7 ))
|
|
|
mknod r${name}${unit}i c $chr $(( $unit * 16 + $off + 8 ))
|
|
|
mknod r${name}${unit}j c $chr $(( $unit * 16 + $off + 9 ))
|
|
|
mknod r${name}${unit}k c $chr $(( $unit * 16 + $off + 10 ))
|
|
|
mknod r${name}${unit}l c $chr $(( $unit * 16 + $off + 11 ))
|
|
|
mknod r${name}${unit}m c $chr $(( $unit * 16 + $off + 12 ))
|
|
|
mknod r${name}${unit}n c $chr $(( $unit * 16 + $off + 13 ))
|
|
|
mknod r${name}${unit}o c $chr $(( $unit * 16 + $off + 14 ))
|
|
|
mknod r${name}${unit}p c $chr $(( $unit * 16 + $off + 15 ))
|
|
|
chown root.operator ${name}${unit}[a-p] r${name}${unit}[a-p]
|
|
|
chmod 640 ${name}${unit}[a-p] r${name}${unit}[a-p]
|
|
|
done
|
|
|
umask 77
|
|
|
;;
|
|
|
|
|
|
ttyo*)
|
|
|
unit=${i##*[a-z]}
|
|
|
rm -f ser${unit} tty${unit} ttyo${unit}
|
|
|
case ${unit} in
|
|
|
0|1)
|
|
|
mknod ttyo${unit} c 14 ${unit}
|
|
|
chown uucp.dialer ttyo${unit}
|
|
|
chmod 660 ttyo${unit}
|
|
|
;;
|
|
|
*)
|
|
|
echo bad unit for serial tty in: $i
|
|
|
;;
|
|
|
esac
|
|
|
;;
|
|
|
tty0*)
|
|
|
unit=${i##tty0}
|
|
|
rm -f tty0$unit cua0$unit
|
|
|
mknod tty0$unit c 7 $unit
|
|
|
mknod cua0$unit c 7 `expr $unit + 128`
|
|
|
chown uucp.dialer tty0$unit cua0$unit
|
|
|
chmod 660 tty0$unit cua0$unit
|
|
|
;;
|
|
|
|
|
|
pty*)
|
|
|
class=${i##*[a-z]}
|
|
|
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;;
|
|
|
6) offset=96 name=v;;
|
|
|
7) offset=112 name=w;;
|
|
|
8) offset=128 name=x;;
|
|
|
9) offset=144 name=y;;
|
|
|
10) offset=160 name=z;;
|
|
|
11) offset=176 name=P;;
|
|
|
12) offset=192 name=Q;;
|
|
|
13) offset=208 name=R;;
|
|
|
14) offset=224 name=S;;
|
|
|
15) offset=240 name=T;;
|
|
|
*) echo bad unit for pty in: $i;;
|
|
|
esac
|
|
|
case $class in
|
|
|
0|1|2|3|4|5|6|7|8|9|10|11|12|13|14|15)
|
|
|
umask 0
|
|
|
n=0
|
|
|
while [ $n -lt 16 ]
|
|
|
do
|
|
|
nam=$name`hex $n`
|
|
|
rm -f {tty,pty}$nam
|
|
|
mknod tty$nam c 4 $(( $offset + $n ))
|
|
|
mknod pty$nam c 5 $(( $offset + $n ))
|
|
|
n="$(( $n + 1 ))"
|
|
|
done
|
|
|
umask 77
|
|
|
;;
|
|
|
esac
|
|
|
;;
|
|
|
|
|
|
st*)
|
|
|
umask 2 ; unit=${i##*[a-z]}
|
|
|
case $i in
|
|
|
st*) name=st; chr=20; blk=5;;
|
|
|
esac
|
|
|
rm -f $name$unit n$name$unit e$name$unit en$name$unit \
|
|
|
r$name$unit nr$name$unit er$name$unit enr$name$unit
|
|
|
case $unit in
|
|
|
0|1|2|3|4|5|6)
|
|
|
mknod ${name}${unit} b $blk $(( $unit * 16 + 0 ))
|
|
|
mknod n${name}${unit} b $blk $(( $unit * 16 + 1 ))
|
|
|
mknod e${name}${unit} b $blk $(( $unit * 16 + 2 ))
|
|
|
mknod en${name}${unit} b $blk $(( $unit * 16 + 3 ))
|
|
|
mknod r${name}${unit} c $chr $(( $unit * 16 + 0 ))
|
|
|
mknod nr${name}${unit} c $chr $(( $unit * 16 + 1 ))
|
|
|
mknod er${name}${unit} c $chr $(( $unit * 16 + 2 ))
|
|
|
mknod enr${name}${unit} c $chr $(( $unit * 16 + 3 ))
|
|
|
chown root.operator ${name}${unit} n${name}${unit} \
|
|
|
e$name$unit en$name$unit \
|
|
|
r${name}${unit} nr${name}${unit} \
|
|
|
er${name}${unit} enr${name}${unit}
|
|
|
chmod 660 ${name}${unit} n${name}${unit} \
|
|
|
e$name$unit en$name$unit \
|
|
|
r${name}${unit} nr${name}${unit} \
|
|
|
er${name}${unit} enr${name}${unit}
|
|
|
;;
|
|
|
*)
|
|
|
echo bad unit for tape in: $i
|
|
|
;;
|
|
|
esac
|
|
|
umask 77
|
|
|
;;
|
|
|
|
|
|
ch*)
|
|
|
umask 2 ; unit=${i##*[a-z]}
|
|
|
case $i in
|
|
|
ch*) name=ch; chr=10;;
|
|
|
esac
|
|
|
rm -f $name$unit
|
|
|
case $unit in
|
|
|
0|1|2|3|4|5|6)
|
|
|
mknod ${name}${unit} c $chr $unit
|
|
|
chown root.operator ${name}${unit}
|
|
|
chmod 660 ${name}${unit}
|
|
|
;;
|
|
|
*)
|
|
|
echo bad unit for media changer in: $i
|
|
|
;;
|
|
|
esac
|
|
|
umask 77
|
|
|
;;
|
|
|
|
|
|
cd*)
|
|
|
umask 2 ; unit=${i##*[a-z]}
|
|
|
case $i in
|
|
|
cd*) name=cd; blk=3; chr=9;;
|
|
|
esac
|
|
|
rm -f $name$unit? r$name$unit?
|
|
|
case $unit in
|
|
|
0|1|2|3|4|5|6)
|
|
|
mknod ${name}${unit}a b $blk $(( $unit * 8 + 0 ))
|
|
|
mknod ${name}${unit}c b $blk $(( $unit * 8 + 2 ))
|
|
|
mknod r${name}${unit}a c $chr $(( $unit * 8 + 0 ))
|
|
|
mknod r${name}${unit}c c $chr $(( $unit * 8 + 2 ))
|
|
|
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
|
|
|
;;
|
|
|
|
|
|
usb*)
|
|
|
rm -f usb$unit
|
|
|
mknod usb$unit c 61 $unit
|
|
|
chown root.wheel usb$unit
|
|
|
chmod 660 usb$unit
|
|
|
;;
|
|
|
|
|
|
uhid*)
|
|
|
rm -f uhid$unit
|
|
|
mknod uhid$unit c 62 $unit
|
|
|
chown root.wheel uhid$unit
|
|
|
chmod 660 uhid$unit
|
|
|
;;
|
|
|
|
|
|
ugen*)
|
|
|
for j in 00 01 02 03 04 05 06 07 08 09 10 11 12 13 14 15
|
|
|
do
|
|
|
rm -f ugen$unit.$j
|
|
|
mknod ugen$unit.$j c 63 $(( $unit * 16 + $j ))
|
|
|
chown root.wheel ugen$unit.$j
|
|
|
chmod 660 ugen$unit.$j
|
|
|
done
|
|
|
;;
|
|
|
|
|
|
ulpt*)
|
|
|
rm -f ulpt$unit
|
|
|
mknod ulpt$unit c 64 $unit
|
|
|
chown root.wheel ulpt$unit
|
|
|
chmod 660 ulpt$unit
|
|
|
;;
|
|
|
|
|
|
urio*)
|
|
|
rm -f urio$unit
|
|
|
mknod urio$unit c 65 $unit
|
|
|
chown root.wheel urio$unit
|
|
|
chmod 660 urio$unit
|
|
|
;;
|
|
|
|
|
|
utty*)
|
|
|
rm -f utty$unit
|
|
|
mknod utty$unit c 66 $unit
|
|
|
chown root.wheel utty$unit
|
|
|
chmod 660 utty$unit
|
|
|
;;
|
|
|
|
|
|
ttyEcfg)
|
|
|
type=Ecfg
|
|
|
major=67
|
|
|
minor=255
|
|
|
unit=${i##ttyE}
|
|
|
rm -f tty$type$unit
|
|
|
mknod tty$type$unit c $major $minor
|
|
|
chown root.wheel tty$type$unit
|
|
|
;;
|
|
|
|
|
|
ttyE*)
|
|
|
type=E
|
|
|
unit=${i##ttyE}
|
|
|
major=67
|
|
|
minor=$unit
|
|
|
rm -f tty$type$unit
|
|
|
mknod tty$type$unit c $major $minor
|
|
|
chown root.wheel tty$type$unit
|
|
|
;;
|
|
|
|
|
|
bpf*)
|
|
|
unit=${i##*[a-z]}
|
|
|
rm -f bpf${unit}
|
|
|
mknod bpf${unit} c 22 ${unit}
|
|
|
chown root.wheel bpf${unit}
|
|
|
;;
|
|
|
|
|
|
ipl)
|
|
|
rm -f ipl ipnat ipstate ipauth
|
|
|
mknod ipl c 39 0
|
|
|
mknod ipnat c 39 1
|
|
|
mknod ipstate c 39 2
|
|
|
mknod ipauth c 39 3
|
|
|
chown root.wheel ipl ipnat ipstate ipauth
|
|
|
;;
|
|
|
|
|
|
tun*)
|
|
|
unit=${i##*[a-z]}
|
|
|
rm -f tun$unit
|
|
|
mknod tun$unit c 23 $unit
|
|
|
chmod 600 tun$unit
|
|
|
chown root.wheel tun$unit
|
|
|
;;
|
|
|
|
|
|
rd*)
|
|
|
blk=17; chr=17;
|
|
|
umask 2 ; unit=${i##*[a-z]}
|
|
|
rm -f rd${unit}a rd${unit}c rrd${unit}a rrd${unit}c
|
|
|
mknod rd${unit}a b ${blk} $(( $unit * 16 + 0 ))
|
|
|
mknod rd${unit}c b ${blk} $(( $unit * 16 + 2 ))
|
|
|
mknod rrd${unit}a c ${chr} $(( $unit * 16 + 0 ))
|
|
|
mknod rrd${unit}c c ${chr} $(( $unit * 16 + 2 ))
|
|
|
chown root.operator rd${unit}[ac] rrd${unit}[ac]
|
|
|
chmod 640 rd${unit}[ac] rrd${unit}[ac]
|
|
|
umask 77
|
|
|
;;
|
|
|
|
|
|
lkm)
|
|
|
rm -f lkm
|
|
|
mknod lkm c 24 0
|
|
|
chown root.kmem lkm
|
|
|
chmod 640 lkm
|
|
|
;;
|
|
|
|
|
|
random|srandom|urandom|prandom|arandom)
|
|
|
rm -f random urandom srandom prandom arandom
|
|
|
mknod random c 40 0
|
|
|
mknod srandom c 40 1
|
|
|
mknod urandom c 40 2
|
|
|
mknod prandom c 40 3
|
|
|
mknod arandom c 40 4
|
|
|
chown root.wheel random srandom urandom prandom arandom
|
|
|
chmod 644 random srandom urandom prandom arandom
|
|
|
;;
|
|
|
uk*)
|
|
|
unit=${i##*[a-z]}
|
|
|
rm -f uk$unit
|
|
|
mknod uk$unit c 41 $unit
|
|
|
chown root.operator uk$unit
|
|
|
chmod 640 uk$unit
|
|
|
;;
|
|
|
|
|
|
ss*)
|
|
|
unit=${i##*[a-z]}
|
|
|
rm -f ss$unit
|
|
|
mknod ss$unit c 42 $unit
|
|
|
chown root.operator ss$unit
|
|
|
chmod 440 ss$unit
|
|
|
# backwards compatibility with older PINTs
|
|
|
rm -f scan$unit
|
|
|
ln -s ss$unit scan$unit
|
|
|
;;
|
|
|
wscons*)
|
|
|
unit=${i##*[a-z]}
|
|
|
sh $this ttyE${unit} wskbd${unit} wsmouse${unit}
|
|
|
;;
|
|
|
wskbd*)
|
|
|
unit=${i##*[a-z]}
|
|
|
rm -f wskbd${unit}
|
|
|
mknod wskbd${unit} c 68 ${unit}
|
|
|
# XXX
|
|
|
chmod 660 wskbd${unit}
|
|
|
chown root.wheel wskbd${unit}
|
|
|
;;
|
|
|
wsmouse*)
|
|
|
unit=${i##*[a-z]}
|
|
|
rm -f wsmouse${unit}
|
|
|
mknod wsmouse${unit} c 69 ${unit}
|
|
|
# XXX
|
|
|
chmod 660 wsmouse${unit}
|
|
|
chown root.wheel wsmouse${unit}
|
|
|
;;
|
|
|
|
|
|
xfs*)
|
|
|
rm -f xfs$unit
|
|
|
mknod xfs$unit c 51 $unit
|
|
|
chmod 600 xfs$unit
|
|
|
chown root.wheel xfs$unit
|
|
|
;;
|
|
|
|
|
|
local)
|
|
|
umask 0
|
|
|
test -s MAKEDEV.local && sh $this.local
|
|
|
;;
|
|
|
|
|
|
*)
|
|
|
echo $i: unknown device
|
|
|
esac
|
|
|
done
|
|
|
|