Operating System - I/O Softwares
I/O
software is often organized in the following layers −
· User Level Libraries − This provides simple interface to the user
program to perform input and output. For example, stdio is a library
provided by C and C++ programming languages.
· Kernel Level Modules − This provides device driver to interact with
the device controller and device independent I/O modules used by the device
drivers.
· Hardware − This layer includes actual hardware and
hardware controller which interact with the device drivers and makes hardware
alive.
A key
concept in the design of I/O software is that it should be device independent
where it should be possible to write programs that can access any I/O device
without having to specify the device in advance. For example, a program that
reads a file as input should be able to read a file on a floppy disk, on a hard
disk, or on a CD-ROM, without having to modify the program for each different
device.
Device
Drivers
Device
drivers are software modules that can be plugged into an OS to handle a
particular device. Operating System takes help from device drivers to handle
all I/O devices. Device drivers encapsulate device-dependent code and implement
a standard interface in such a way that code contains device-specific register
reads/writes. Device driver, is generally written by the device's manufacturer
and delivered along with the device on a CD-ROM.
A
device driver performs the following jobs −
- To accept request from the device independent software above to
it.
- Interact with the device controller to take and give I/O and
perform required error handling
- Making sure that the request is executed successfully
How a
device driver handles a request is as follows: Suppose a request comes to read
a block N. If the driver is idle at the time a request arrives, it starts
carrying out the request immediately. Otherwise, if the driver is already busy
with some other request, it places the new request in the queue of pending
requests.
Interrupt
handlers
An
interrupt handler, also known as an interrupt service routine or ISR, is a
piece of software or more specifically a callback function in an operating
system or more specifically in a device driver, whose execution is triggered by
the reception of an interrupt.
When
the interrupt happens, the interrupt procedure does whatever it has to in order
to handle the interrupt, updates data structures and wakes up process that was
waiting for an interrupt to happen.
The
interrupt mechanism accepts an address ─ a number that selects a specific
interrupt handling routine/function from a small set. In most architectures,
this address is an offset stored in a table called the interrupt vector table.
This vector contains the memory addresses of specialized interrupt handlers.
Device-Independent
I/O Software
The
basic function of the device-independent software is to perform the I/O
functions that are common to all devices and to provide a uniform interface to
the user-level software. Though it is difficult to write completely device
independent software but we can write some modules which are common among all
the devices. Following is a list of functions of device-independent I/O
Software −
- Uniform interfacing for device drivers
- Device naming - Mnemonic names mapped to Major and Minor device numbers
- Device protection
- Providing a device-independent block size
- Buffering because data coming off a device cannot be stored in
final destination.
- Storage allocation on block devices
- Allocation and releasing dedicated devices
- Error Reporting
User-Space
I/O Software
These
are the libraries which provide richer and simplified interface to access the
functionality of the kernel or ultimately interactive with the device drivers.
Most of the user-level I/O software consists of library procedures with some
exception like spooling system which is a way of dealing with dedicated I/O
devices in a multiprogramming system.
I/O
Libraries (e.g., stdio) are in user-space to provide an interface to the OS
resident device-independent I/O SW. For example putchar(), getchar(), printf()
and scanf() are example of user level I/O library stdio available in C
programming.
Kernel
I/O Subsystem
Kernel
I/O Subsystem is responsible to provide many services related to I/O. Following
are some of the services provided.
· Scheduling − Kernel schedules a set of I/O requests to
determine a good order in which to execute them. When an application issues a
blocking I/O system call, the request is placed on the queue for that device.
The Kernel I/O scheduler rearranges the order of the queue to improve the
overall system efficiency and the average response time experienced by the
applications.
· Buffering − Kernel I/O Subsystem maintains a memory area
known as buffer that stores data while they are transferred between
two devices or between a device with an application operation. Buffering is
done to cope with a speed mismatch between the producer and consumer of a data
stream or to adapt between devices that have different data transfer sizes.
· Caching − Kernel maintains cache memory which is
region of fast memory that holds copies of data. Access to the cached copy is
more efficient than access to the original.
· Spooling and Device
Reservation − A spool is a buffer that
holds output for a device, such as a printer, that cannot accept interleaved
data streams. The spooling system copies the queued spool files to the printer
one at a time. In some operating systems, spooling is managed by a system
daemon process. In other operating systems, it is handled by an in kernel
thread.
· Error Handling − An operating system that uses protected
memory can guard against many kinds of hardware and application errors.
