I/O Software

Introduction

I/O software is organized in layers, each providing a higher level of abstraction. At the bottom, interrupt handlers deal with raw hardware signals. Above them, device drivers translate between OS commands and specific hardware. Higher still, device-independent software provides uniform file and device access to all applications. This layered design means applications can read from a file, network, or keyboard using the same system calls — true device independence.

Goals of I/O Software Design

1. Device Independence: Programs work without modification regardless of the specific device (read from SSD or HDD using the same call)
2. Uniform Naming: Devices and files accessed through the same namespace (Unix: /dev/sda, /dev/ttyUSB0)
3. Error Handling: Handle errors as close to the hardware as possible, report meaningful messages to applications
4. Buffering: Smooth data flow between devices operating at different speeds
5. Shared vs Dedicated Devices: Allow sharing where possible (disk), exclusive access where needed (printer)

The I/O Software Layers

Layer 1: Interrupt Handlers

Lowest level. Triggered by hardware when a device needs attention. Saves device status, acknowledges the interrupt, and wakes up the waiting driver. Should be as fast as possible.

Layer 2: Device Drivers

Translates I/O requests from the generic layer above into specific device commands. Each device type has its own driver. Drivers know register addresses, timing requirements, and error codes specific to their device.

Layer 3: Device-Independent OS Software

Provides functionality common to all devices: buffering and caching, access control and permissions, device naming and mapping, error reporting, block size handling, and device allocation.

Layer 4: User-Space I/O Software

Libraries and utilities that format I/O for user convenience: printf() formats text before calling write(), scanf() parses input after calling read(), spooling daemons manage shared devices like printers.

Buffering Strategies

Double buffering allows the CPU to process one buffer while the device fills the other — overlap of computation and I/O improves throughput significantly.

Spooling (Simultaneous Peripheral Operations On-Line)

For devices that cannot be shared (printers), spooling provides virtual sharing. Each process writes to a spool file (on disk). A dedicated daemon sends spool files to the device one at a time. Users see immediate "print complete" even though their job may wait in the queue.

Error Handling

I/O errors are handled at the lowest possible layer:

1. Hardware retries (disk controller retries failed reads automatically)
2. Driver recovery (driver resets device and retries)
3. OS notification (report error to application via return code)
4. User notification (error dialog, log message)

The principle: handle errors locally when possible, escalate only when necessary.

Real-World Analogy

The I/O software stack is like international shipping. User-space software is the customer placing an order (high-level, simple interface). Device-independent software is the logistics company's central office (standard processes regardless of delivery method). Device drivers are the local delivery services (know specific routes and vehicles). Interrupt handlers are the package tracking sensors (detect events in real-time). Each layer hides complexity from the layer above while providing reliable service.

Key Takeaways

• I/O software is organized in layers: interrupt handlers → drivers → device-independent → user libraries
• Device independence lets programs work with any device through the same API
• Buffering strategies (single, double, circular) overlap I/O with computation for better performance
• Spooling provides virtual sharing for devices that cannot handle simultaneous access
• Error handling occurs at the lowest possible layer, escalating only when needed
• The layered design allows adding new devices (new driver) without changing applications
• Understanding the I/O stack helps diagnose performance problems and design efficient I/O patterns