3.1. The Design of scull
first step of driver
is defining the capabilities (the
mechanism) the driver will offer to user programs. Since our
"device" is part of the
computer's memory, we're free to do
what we want with it. It can be a sequential or random-access device,
one device or many, and so on.
To make scull useful as a template for writing
real drivers for real devices, we'll show you how to
implement several device abstractions on top of the computer memory,
each with a different personality.
The scull source implements the following
devices. Each kind of device implemented by the module is referred to
as a type .
- scull0 to scull3
Four devices, each consisting of
a memory area that is both global and
persistent. Global means that if the device is opened multiple times,
the data contained within the device is shared by all the file
descriptors that opened it. Persistent means that if the device is
closed and reopened, data isn't lost. This device
can be fun to work with, because it can be accessed and tested using
conventional commands, such as cp,
cat, and shell I/O redirection.
- scullpipe0 to scullpipe3
(first-in-first-out) devices, which act like pipes. One process reads
what another process writes. If multiple processes read the same
device, they contend for data. The internals of
scullpipe will show how blocking and nonblocking
read and write can be
implemented without having to resort to interrupts. Although real
drivers synchronize with their devices using hardware interrupts, the
topic of blocking and nonblocking operations is an important one and
is separate from interrupt handling (covered in Chapter 10).
These devices are similar to scull0 but with
some limitations on when an open is permitted.
The first (scullsingle) allows only one process
at a time to use the driver, whereas scullpriv
is private to each virtual console (or X terminal session), because
processes on each console/terminal get different memory areas.
sculluid and scullwuid can
be opened multiple times, but only by one user at a time; the former
returns an error of "Device Busy"
if another user is locking the device, whereas the latter implements
blocking open. These variations of
scull would appear to be confusing policy and
mechanism, but they are worth looking at, because some real-life
devices require this sort of management.
Each of the scull devices demonstrates different
features of a driver and presents different difficulties. This
chapter covers the internals of scull0 to
scull3; the more advanced devices are covered in
scullpipe is described in the section Section 3.4 and the others are described in Section 6.6