Professional Documents
Culture Documents
This section discusses the treatment of devices and I/O under DSI. We
describe the stream I/O interface and its integration with DSI's process
model. We then describe an implementation of input and output device
drivers and their interaction with other system processes. We conclude with
a discussion of the strengths and limitations of I/O in DSI.
Unlike many operating systems, UNIX is not limited to specific
computers using a particular microprocessor as a CPU. Instead, UNIX
systems run on all sizes of computers using a wide range of
microprocessors. In addition, current versions of many other operating
systems have been revised to include the capability to run UNIX
applications and connect smoothly with UNIX networks.
This chapter begins by presenting the evolution of UNIX operating systems.
It then discusses design goals. The roles of the Memory, Device, Processor,
and File Managers in UNIX systems are discussed. The chapter concludes
with a discussion on the user interface in the UNIX operating system.
Device Management
1 1. Discuss the important features of device management in UNIX
operating systems.
Device Classifications
1 1. List the two categories into which UNIX divides the I/O system,
namely the “block I/O” system (sometimes called the “structured I/O”
system) and the “character I/O” system (sometimes called the
“unstructured I/O” system).
1 2. Explain the hierarchy of I/O devices in UNIX using Figure 13.7 on page
415 as a guide. Discuss the roles of the major device number, minor device
number, and block I/O system.
DSI uses a character stream I/O interface; all data is presented to, or issued from, the device
drivers using character streams. An input device driver appears as a producer, reading bytes
from the device and injecting a corresponding stream of characters into the heap. An output
device driver consumes a stream of characters and writes raw bytes to the device. An input-
output or bidirectional device driver both produces and consumes streams of characters. The
drivers convert between raw bytes and DSI characters because the character representation is
better suited for manipulation by programs dealing with lists and atoms.
Device Drivers
Streams are naturally implemented in DSI using suspensions, so a system with drivers
reading characters from a keyboard and echoing it to a terminal would look something like that
depicted in figure . In the figure, DSI characters are shown as c's; character substructure has
been omitted for the sake of simplicity.
Input Devices
All input devices are handled by a single generic driver, the input device manager. When a
DSI input primitive is invoked, it calls the appropriate host I/O routine to obtain a native I/O
handle (e.g. dski calls H_input). It uses this handle to build a corresponding DSI descriptor. The
primitive then calls a device manager subroutine to make the descriptor known to the device
manager.
The device manager maintains a list of descriptor/stream associations on the device list
(DVCLST). The stream part of the descriptor/stream pair is a reference to the tail of the input
stream of characters associated with the device. When DVISCAN wakes up it scans the device
list and polls each descriptor in turn:
If there is data pending, DVISCAN will enter an input loop, reading raw bytes from the
descriptor, converting them into DSI characters and appending them onto the associated input
stream. When there is no more pending data to be read from a descriptor, DVISCAN updates the tail
reference in the descriptor/stream pair and moves on to test the next descriptor in the device list.
If the descriptor indicates an end-of-file or error condition DVISCAN closes the descriptor,
terminates the input stream and deletes the device/stream pair from the device list.
I/O Signals
There are three signals reserved for device handling. SIG_IO should be implemented by a
hardware interrupt or host operating system exception that is asserted when there is data ready
to be read from an input device. If the device is attached to a single processor, then only that
processor should receive the SIG_IO. Otherwise, the signal may be multicast, and the processor
which "owns" the device manager suspension will activate it. If there are multiple I/O channels
that can be serviced concurrently (perhaps on a processor network), it might be desirable to
have more than one instance of DVISCAN running. This is not conceptually difficult, and would
simply require that each instance of DVISCAN manage a separate device list, or that they
coordinate to avoid corrupting a single shared device list. The current implementation assumes
a single instantiation of DVISCAN.
Occasionally an input stream may become unreferenced while the device or file is still
open. The device manager operates in conjunction with the garbage collector to close these
dangling file descriptors.
This section describes the differences between the various kinds of of input devices
supported by DSI.
Disk Input
DSI relies on the host filesystem to manage files. Disk input is handled on a per-file basis. dski
takes a host filesystem path as argument and creates a new descriptor and DVISCAN stream for
each open file. It returns a stream of characters read from the file.
Keyboard Input
Output devices are symmetrically constructed to input devices. An output driver is a stream
consumer of characters. Each character is converted to a raw byte and written to the output
channel using the host I/O primitives which handle the proper buffering for the device type
(e.g. disks are written in blocks, terminals are unbuffered. etc.).
This section describes the differences between the various kinds of of output devices supported
by DSI.
Disk Output
Terminal Output
Terminal output is the complement to keyboard input; screen takes an input stream and writes
it to the terminal, returning NIL after the last character has been written. Terminal output is not
implemented at the same level of detail as keyboard input, however. If it were, multiple output
streams would be merged by a MERGE process into a single output stream before being
delivered to a single (tty) instantiation of DVCOUT.
T he effect of output devices is more than just to output characters. Because the output device
driver is infinitely strict, it presents a point source of continuous demand that propagates down
through its input stream and through the data space to the fringes of the computation (and
ultimately, to any input drivers). It is the output devices which ultimately provide the impetus
for DSI's demand-driven behaviour. In between the output drivers and the inputs, the user
program controls the direction of this demand flow.
Bidirectional Devices
In addition to input-only and output-only devices, DSI also supports bidirectional devices. A
bidirectional device is one that can be modelled as having both input and output channels. For
example, although the display and keyboard are actually two separate physical devices, under
Unix they are integrated into a single logical device (e.g. /dev/tty) from which you can read and
to which you can write
Sockets
UNIX Pipes
DSI's I/O model reflects its roots in functional programming research. The stream
representation provides a non-temporal, applicative interface to asynchronous device I/O that
integrates well with DSI's process model. The stream interface is useful for a wide variety of
devices, but some devices work better with stream model than others. In this section we will
explore some of the limitations of stream I/O under DSI.
Stateful Devices
For serial "stateless" devices, such as keyboards, mice, terminals, or network sockets, the
stream interface is a reasonably accurate model of the underlying events. For "stateful"
devices, such as disks, the stream interface provides only a limited subset of the device's
capabilities. Some devices, such as bitmapped displays, seem very unlikely to be handled by a
stream I/O interface under current technology, other than at a high level, such as the xdsi
interface. Part of the problem is the large, stateful nature of a bitmapped display memory and
part can be attributed to processor speed and bandwidth limitations of serializing a bitstream to
the display.