CYBER WEEK SALE: Get 50% off your Pro annual membership using code [CYBER23](https://www.codecademy.com/checkout?periods=year&plan_id=proGoldAnnualV2&discountCode=CYBER23)


Learn how IO software supports the IO system for executing meaningful tasks on a computer. 

IO Software

This image features a chart split into three sections titled Hardware, Kernel-Space, and User-Space.  In the hardware section is be an image of the barebone hardware of a car (wheels, door, car). The kernel-space section builds off the image of the hardware section, but also includes an engine control unit. In the user-space section, it shows an audio system in a car with a blue tooth symbol in the corner. 

IO software is necessary to the functionality of IO hardware. Consider a car. The car's main structure is the hardware: the wheels, the engine, etc. The hardware isn't solely responsible for making the car functional; user-space and kernel-space play a vital role in the software aspect of this process.

The _user-space_ is the space in memory that holds and runs user processes. Think about when we connect our Bluetooth device to the audio system of a car. The memory in which the Bluetooth mounts to the car can be considered to be the user-space. Pressing play or selecting a song on different phones can be considered independent calls that exist in user libraries that access the kernel through calls, and result in output in the car. User libraries hold more complex, modifiable, user-controlled code that interfaces with the kernel. 
 
The _kernel-space_ is the place in memory where the kernel performs its functionality. The software behind the Engine Control Unit (ECU) of a car is the kernel-space. Just like the ECU controls or manages the electric functions of a car, the kernel manages resources and requests. The kernel manages the scheduling of tasks, buffering (storing data in memory when transferring between a computer and IO devices), spooling (holding output data for an IO device), etc. 


User-space, Kernel-space, & Hardware

A computer is surrounded by hardware and software such as keyboards, printers, a Bluetooth icon, save files, web browsers, and chat icons.

IO devices refer to any physical devices that interact with a CPU. The physical devices send signals to computers and receive information from computers. The role of IO software is to receive signals from physical devices, interpret them and then perform tasks accordingly through the operating system.

_IO software_ refers to the code that interprets those signals and plans the execution of IO requests. There are different types of IO software to handle different tasks. Some IO requests can be processed by software that is more generic and meant for multiple devices. 

For example, the software used to accomplish the request to retrieve and store data to a hard drive is similar to the software used to retrieve and store data from a USB. This type of software is referred to as device-independent software. Other IO requests can be processed by software that is designed for specific devices. This type of software is known as a device driver. An example of a device driver may be the software you install to your computer to be able to connect a printer. 

In this module, we will dive deeper into the many layers of IO software along with its functions.


Introduction to IO Software

Unlike device drivers, _device-independent_ IO software is not specific to any single IO device. It holds functions that are more generic and can be used by all devices. It includes generic interface calls, buffering, providing a generic block size that an IO device and the computer can use to transfer data, etc. Generic interface calls include initializing the hardware, allocating resources, turning off a device, etc. Device-independent sofware calls for _buffering_ refer to storing some data in memory when transferring it from one device to the other.

Device-independent software also has the capability to report errors that occur between the interaction of IO devices and the computer. Due to the fact that device-independent software must be applicable to all devices that connect to a computer, its functionality is not extremely complex or intricately connected to any single device and can be handled in the kernel-space in IO systems.

Consider the following functions of a car: displaying mileage on a dashboard and what song is playing on the media system screen. Both these tasks are different, but a similar subtask they share is retrieving data from memory and outputting it to a screen to be displayed. This subtask can be executed through device-independent IO software. Although both screens are different, the code to retrieve the data to be displayed is the same.


A flow diagram shows how two distinct tasks use one IO component as part of their subtasks.

The task "display mileage" requests data from the device-independent software which requests data from memory. Memory returns this data to the device-independent software which returns the mileage to the original request.

The task "display song title" requests data from the device-independent software which requests data from memory. Memory returns this data to the device-independent software which returns the song title to the original request.

Device-Independent IO Software

A diagram showing the layers of IO software from top to bottom: User-level IO software, device-independent software, device drivers, interrupt handlers, and hardware.

User-level software exists in the userspace. Device-independent software, device drivers, and interrupt handlers exist in the kernel space.

In IO systems, IO software is made up of multiple layers due to the many different responsibilities they have. These layers include the following:
- **User-level IO software or user processes:** This is the level at which IO requests are made. It is at this level that a system call is made in the user-space to be sent to the kernel-space.
- **Device-independent software:** This layer refers to software components that are generic and applicable to multiple devices. These calls are not dependent on or exclusive to any single IO device. 
- **Device drivers:** This layer refers to the software components that are specific to an IO device. They often code snippets that have been developed by the manufacturer of the IO device and must be installed by the user before the IO device can interact with a computer.
- **Interrupt handlers:** Interrupt handlers are snippets of code that provide the functionality to device drivers. They process interrupts made by IO devices. 
- **Hardware:** This layer refers to the physical IO device which interacts with device drivers through input such as pressing a key on a keyboard or output such as displaying data onto a screen. 


Layers of IO Systems

In the IO hardware lesson, we learned that interrupts are hardware mechanisms that send signals when an IO device needs the computer's attention. 

_Interrupt handlers_ refer to the software components that manage the pool of interrupts that are sent to the CPU. Interrupt handlers receive and acknowledge that a signal has been received, place it in a queue, and execute the interrupts by priority. When an interrupt is received the interrupt handler notifies the CPU. The CPU will then halt its current processes, and wait for the execution of the interrupt before continuing.

Consider pressing a keyboard button and trying to turn up the volume on a computer at the same time. Although it may seem to be simultaneous, the computer will place both in a queue based on when the signal is received by the interrupt handler. Once the interrupt by the first is completed (e.g. the keyboard button is displayed on a word processing document), the second one will begin execution (the volume is adjusted).



Test describing slide 1: Spacebar and volume key are pressed almost simultaneously. This can be indicated by the changing color of the keys to green just milliseconds apart from each other. The spacebar key changes first and the volume key second.

Text describing slide 2: Space key appears first in interrupt handler queue, then volume key appears,

Text describing slide 3: The space key moves across to the "completed execution" block as displayed by the arrow

Text describing slide 4: The volume key moves up the interrupt handler queue block after the space key has moved to the completed execution block

Text describing slide 5:The space key moves down to make space for the volume key

Text describing slide 6: The volume key moves to the completed execution block as shown by arrow

Text describing slide 7: final state of the application.

Interrupt Handlers

Great job reaching the end of the lesson! Let’s review what we have learned about IO software: 
- The user-space is the place in memory in which user processes run and the kernel-space is the place in memory in which the kernel functions and manages system calls.
- The user-space interacts with the kernel by sending system calls to the kernel-space.
- Layers of the IO system that support kernel-space include: device-independent software, device drivers, interrupt handlers
- Layers of the IO system that support user-space include: user-level IO software
- Device drivers are device-specific code that is added to a computer so that a device may interact with a computer.
- The interrupt handler is a pool or queue of interrupts being sent to the CPU.
- Device-independent software refers to the software components that handle functions that are not specific to any single IO device.

Now that we have reviewed IO hardware and IO software, we can understand how both are connected and contribute to how we interact with a computer. 


Review

A pictorial representation of a CPU that shows us where device drivers exist

_Device drivers_ are software components, or blocks of code, that are specific to a device. They are often written by the manufacturer of IO devices and must be installed into a computer before an IO device may successfully interface with a computer. The chunks of code are part of the kernel-space because once they are installed, they don’t require user involvement to interact with device controllers.

Unlike device-independent IO software, device drivers are great for taking IO hardware beyond generic functionality. Device drivers allow for an IO device to be used to perform tasks that are specific to its hardware. 
 
There are two types of device drivers:
* **Kernel-mode drivers:** These drivers allow for basic functionality on a CPU. They even contribute to the start-up of an operating system when we turn on our computers.
* **User-mode drivers:** When a user adds additional hardware to their computer, that additional hardware comes with its own set of drivers that need to be installed. For example, when we are in the process of installing a new printer and connecting it to our laptop.
