Purchase  Copyright © 2002 Paul Sheer. Click here for copying permissions.  Home 

next up previous contents
Next: 19. Partitions, File Systems, Up: rute Previous: 17. Overview of the   Contents


18. UNIX Devices

UNIX was designed to allow transparent access to hardware devices across all CPU architectures. UNIX also supports the philosophy that all devices be accessible using the same set of command-line utilities.

18.1 Device Files

UNIX has a beautifully consistent method of allowing programs to access hardware. Under UNIX, every piece of hardware is a file. To demonstrate this novelty, try viewing the file /dev/hda (you will have to be root to run this command):

less -f /dev/hda

/dev/hda is not really a file at all. When you read from it, you are actually reading directly from the first physical hard disk of your machine. /dev/hda is known as a device file, and all of them are stored under the /dev directory.

Device files allow access to hardware. If you have a sound card installed and configured, you can try:

cat /dev/dsp > my_recording

Say something into your microphone and then type:

cat my_recording > /dev/dsp

The system will play out the sound through your speakers. (Note that this does not always work, since the recording volume or the recording speed may not be set correctly.)

If no programs are currently using your mouse, you can also try:

cat /dev/mouse

If you now move the mouse, the mouse protocol commands will be written directly to your screen (it will look like garbage). This is an easy way to see if your mouse is working, and is especially useful for testing a serial port. Occasionally this test doesn't work because some command has previously configured the serial port in some odd way. In that case, also try:

cu -s 1200 -l /dev/mouse

At a lower level, programs that access device files do so in two basic ways:

Because every kind of device that one can think of (except for network cards) can be twisted to fit these two modes of operation, UNIX's scheme has endured since its inception and is the universal method of accessing hardware.

18.2 Block and Character Devices

Hardware devices can generally be categorized into random access devices like disk and tape drives, and serial devices like mouse devices, sound cards, and terminals.

Random access devices are usually accessed in large contiguous blocks of data that are stored persistently. They are read from in discrete units (for most disks, 1024 bytes at a time). These are known as block devices. Running an ls -l /dev/hda shows a b on the far left of the listing, which means that your hard disk is a block device:

brw-r-----   1 root     disk       3,  64 Apr 27  1995 /dev/hdb

Serial devices, on the other hand, are accessed one byte at a time. Data can be read or written only once. For example, after a byte has been read from your mouse, the same byte cannot be read by some other program. Serial devices are called character devices and are indicated by a c on the far left of the listing. Your /dev/dsp (Digital Signal Processor--that is, your sound card) device looks like:

crw-r--r--   1 root     sys       14,   3 Jul 18  1994 /dev/dsp

18.3 Major and Minor Device Numbers

Devices are divided into sets called major device numbers. For instance, all SCSI disks are major number 8. Further, each individual device has a minor device number like /dev/sda, which is minor device 0. Major and minor device numbers identify the device to the kernel. The file name of the device is arbitrary and is chosen for convenience and consistency. You can see the major and minor device number ( 8,   0) in the ls listing for /dev/sda:

brw-rw----   1 root     disk       8,   0 May  5  1998 /dev/sda

18.4 Common Device Names

A list of common devices and their descriptions follows. The major numbers are shown in parentheses. The complete reference for devices is the file /usr/src/linux/Documentation/devices.txt.

hd stands for hard disk, but refers here only to IDE devices--that is, common hard disks. The first letter after the hd dictates the physical disk drive:
/dev/hda (3)
First drive, or primary master.
/dev/hdb (3)
Second drive, or primary slave.
/dev/hdc (22)
Third drive, or secondary master.
/dev/hdd (22)
Fourth drive, or secondary slave.
When accessing any of these devices (with, say, less /dev/hda), you would be reading raw from the actual physical disk starting at the first sector of the first track, sequentially, until the last sector of the last track.

Partitions [With all operating systems, disk drives are divided into sections called partitions. A typical disk might have 2 to 10 partitions. Each partition acts as a whole disk on its own, giving the effect of having more than one disk. For instance, you might have Windows installed on one partition and LINUX installed on another. More details come in Chapter 19.]are named /dev/hda1, /dev/hda2, etc., indicating the first, second, etc., partition on physical drive a.

/dev/sd?? (8)
sd stands for SCSI disk, the high-end drives mostly used by servers. sda is the first physical disk probed, and so on. Probing goes by SCSI ID and has a system completely different from that of IDE devices. /dev/sda1 is the first partition on the first drive, etc.
/dev/ttyS? (4)
These are serial devices numbered from 0 up. /dev/ttyS0 is your first serial port (COM1 under MS-DOS or Windows). If you have a multiport card, these can go to 32, 64, and up.
/dev/psaux (10)
PS/2 mouse.
A symlink to /dev/ttyS0 or /dev/psaux. Other mouse devices are also supported.
A symlink to /dev/ttyS1 or whatever port your modem is on.
/dev/cua? (4)
Identical to ttyS? but now fallen out of use.
/dev/fd? (2)
Floppy disk. fd0 is equivalent to your A: drive and fd1 your B: drive. The fd0 and fd1 devices autodetect the format of the floppy disk, but you can explicitly specify a higher density by using a device name like /dev/fd0H1920, which gives you access to 1.88 MB, formatted, 3.5-inch floppies. Other floppy devices are shown in Table 18.1.

See Section 19.3.4 on how to format these devices.

Table 18.1: Floppy device names
\begin{tabularx}{\textwidth}{\vert l \vert p{24ex} \...
you are most interested in.

/dev/par? (6)
Parallel port. /dev/par0 is your first parallel port or LPT1 under DOS.
/dev/lp? (6)
Line printer. Identical to /dev/par?.
Random number generator. Reading from this device gives pseudo-random numbers.
/dev/st? (9)
SCSI tape. SCSI backup tape drive.
/dev/zero (1)
Produces zero bytes, and as many of them as you need. This is useful if you need to generate a block of zeros for some reason. Use dd (see Section 18.5.2) to read a specific number of zeros.
/dev/null (1)
Null device. Reads nothing. Anything you write to the device is discarded. This is very useful for discarding output.
Parallel port IDE disk.
Parallel port ATAPI CD-ROM.
Parallel port ATAPI disk.
SCSI CD-ROM (Identical, alternate name).
SCSI generic. This is a general-purpose SCSI command interface for devices like scanners.
/dev/fb? (29)
Frame buffer. This represents the kernel's attempt at a graphics driver.
A symlink to /dev/hda, /dev/hdb, or /dev/hdc. It can also be linked to your SCSI CD-ROM.
ISDN modems.
/dev/tty? (4)
Virtual console. This is the terminal device for the virtual console itself and is numbered /dev/tty1 through /dev/tty63.
/dev/tty?? (3) and /dev/pty?? (2)
Other TTY devices used for emulating a terminal. These are called pseudo-TTYs and are identified by two lowercase letters and numbers, such as ttyq3. To nondevelopers, these are mostly of theoretical interest.

The file /usr/src/linux/Documentation/devices.txt also has this to say (quoted verbatim):

                Recommended links

It is recommended that these links exist on all systems:

\begin{tabular}{l \vert l \vert l \vert l}
...}{sr}}}\emph{?} & hard & Alternate SCSI CD-ROM \\
& & & name \\

                Locally defined links

The following links may be established locally to conform to the configuration of the system. This is merely a tabulation of existing practice, and does not constitute a recommendation. However, if they exist, they should have the following uses:

\begin{tabular}{l \vert l \vert l \vert l}
...e}{/dev/swap}}} & swap device & symbolic & Current swap device \\

/dev/modem should not be used for a modem which supports dial-in as well as dialout, as it tends to cause lock file problems. If it exists, /dev/modem should point to the appropriate primary TTY device (the use of the alternate callout devices is deprecated).

For SCSI devices, /dev/tape and /dev/cdrom should point to the ``cooked'' devices ( /dev/st* and /dev/sr*, respectively), whereas /dev/cdwriter and /dev/scanner should point to the appropriate generic SCSI devices ( /dev/sg*).

/dev/mouse may point to a primary serial TTY device, a hardware mouse device, or a socket for a mouse driver program (e.g. /dev/gpmdata).

                Sockets and pipes

Non-transient sockets and named pipes may exist in /dev. Common entries are:

\begin{tabular}{l \vert l \vert l}
...mode{\color{blue}{/dev/gpmdata}}} & socket & mouse multiplexer \\

18.5 dd, tar, and Tricks with Block Devices

dd probably originally stood for disk dump. It is actually just like cat except it can read and write in discrete blocks. It essentially reads and writes between devices while converting the data in some way. It is generally used in one of these ways:

dd if=<in-file> of=<out-file> [bs=<block-size>] \
       [count=<number-of-blocks>] [seek=<output-offset>] \
dd if=<in-file> [bs=<block-size>] [count=<number-of-blocks>] \
       [skip=<input-offset>] > <outfile>
dd of=<out-file> [bs=<block-size>] [count=<number-of-blocks>] \
       [seek=<output-offset>] < <infile>

To use dd, you must specify an input file and an output file with the if= and of= options. If the of= option is omitted, then dd writes to stdout. If the if= option is omitted, then dd reads from stdin. [If you are confused, remember that dd thinks of in and out with respect to itself.]

Note that dd is an unforgiving and destructive command that should be used with caution.

18.5.1 Creating boot disks from boot images

To create a new RedHat boot floppy, find the boot.img file on ftp.redhat.com, and with a new floppy, run:

dd if=boot.img of=/dev/fd0

This command writes the raw disk image directly to the floppy disk. All distributions will have similar disk images for creating installation floppies (and sometimes rescue floppies).

18.5.2 Erasing disks

If you have ever tried to repartition a LINUX disk back into a DOS/Windows disk, you will know that DOS/Windows FDISK has bugs in it that prevent it from recreating the partition table. A quick

dd if=/dev/zero of=/dev/hda bs=1024 count=10240

will write zeros to the first 10 megabytes of your first IDE drive. This will wipe out the partition table as well as any file system information and give you a ``brand new'' disk.

To zero a floppy disk is just as easy:

dd if=/dev/zero of=/dev/fd0 bs=1024 count=1440

Even writing zeros to a floppy may not be sufficient. Specialized equipment can probably still read magnetic media after it has been erased several times. If, however, you write random bits to the floppy, it becomes completely impossible to determine what was on it:

mknod /dev/urandom c 1 9
for i in 1 2 3 4 ; do
    dd if=/dev/urandom of=/dev/fd0 bs=1024 count=1440

18.5.3 Identifying data on raw disks

Here is a nice trick to find out something about a hard drive:

dd if=/dev/hda1 count=1 bs=512 | file -

gives x86 boot sector.

To discover what a floppy disk is, try

dd if=/dev/fd0 count=1 bs=512 | file -

which gives x86 boot sector, system )k?/bIHC, FAT (12 bit) for DOS floppies.

18.5.4 Duplicating a disk

If you have two IDE drives that are of identical size, and provided that you are sure they contain no bad sectors and provided neither are mounted, you can run

dd if=/dev/hdc of=/dev/hdd

to copy the entire disk and avoid having to install an operating system from scratch. It doesn't matter what is on the original (Windows, LINUX, or whatever) since each sector is identically duplicated; the new system will work perfectly.

(If they are not the same size, you will have to use tar or mirrordir to replicate the file system exactly.)

18.5.5 Backing up to floppies

You can use tar to back up to any device. Consider periodic backups to an ordinary IDE drive instead of a tape. Here we back up to the secondary slave:

tar -cvzf /dev/hdd /bin /boot /dev /etc /home /lib /sbin /usr /var

tar can also back up across multiple floppy disks:

tar -cvMf /dev/fd0 /home/simon

18.5.6 Tape backups

tar traditionally backs up onto tape drives. The commands

mt -f /dev/st0 rewind
tar -cvf /dev/st0 /home

rewind scsi tape 0 and archive the /home directory onto it. You should not try to use compression with tape drives because they are error prone, and a single error could make the entire archive unrecoverable. The mt command stands for magnetic tape and controls generic SCSI tape devices. See also mt(1).

18.5.7 Hiding program output, creating blocks of zeros

If you don't want to see any program output, just append > /dev/null to the command. For example, we aren't often interested in the output of make. [ make is discussed later.]Here we absorb everything save for error messages.

make > /dev/null

Then, of course, we can absorb all output including error messages with either

make >& /dev/null


make > /dev/null 2>&1

The device /dev/null finds innumerable uses in shell scripting to suppress the output of a command or to feed a command dummy (empty) input. /dev/null is a safe file from a security point of view. It is often used when a file is required for some feature in a configuration script, and you would like the particular feature disabled. For instance, specifying the users shell to /dev/null inside the password file will certainly prevent insecure use of a shell, and is an explicit way of saying that that account does not allow shell logins.

You can also use /dev/null to create a file containing nothing:

cat /dev/null > myfile

or alternatively, to create a file containing only zeros. Try

dd if=/dev/zero bs=1024 count=<number-of-kilobytes> > myfile

18.6 Creating Devices with mknod and /dev/MAKEDEV

Although all devices are listed in the /dev directory, you can create a device anywhere in the file system by using the mknod command:

mknod [-m <mode>] <file-name> [b|c] <major-number> <minor-number>

The letters b and c are for creating a block or character device, respectively.

To demonstrate, try

mknod -m 0600 ~/my-floppy b 2 0
ls -al /dev/fd0 ~/my-floppy

my-floppy can be used just like /dev/fd0

Note carefully the mode (i.e., the permissions) of /dev/fd0. /dev/fd0 should be readable and writable only to root and to users belonging to the floppy group, since we obviously don't want an arbitrary user to be able to log in (remotely) and overwrite a floppy disk.

In fact, this is the reason for having devices represented as files in the first place. UNIX files naturally support group access control, and therefore so do devices.

To create devices that are missing from your /dev directory (some esoteric devices will not be present by default), simply look up the device's major and minor number in /usr/src/linux/Documentation/devices.txt and use the mknod command. This procedure is, however, somewhat tedious, and the script /dev/MAKEDEV is usually available for convenience. You must be in the /dev directory before you run this script.

Typical usage of MAKEDEV is

cd /dev
./MAKEDEV -v fd0
./MAKEDEV -v fd1

to create a complete set of floppy disk devices.

The man page for MAKEDEV contains more details. In particular, it states:

Note that programs giving the error ``ENOENT: No such file or directory'' normally means that the device file is missing, whereas ``ENODEV: No such device'' normally means the kernel does not have the driver configured or loaded.

next up previous contents
Next: 19. Partitions, File Systems, Up: rute Previous: 17. Overview of the   Contents