The Operating System Manages the Hardware
When the shell loaded and ran the hello program, and when the hello
program printed its message,
neither program accessed the keyboard, display, disk, or main memory
directly.
Rather, they relied on the services provided by the operating system.
We can think of the operating system as a layer of software
interposed between the application program and the hardware, as shown
in Figure 1.10.
The Operating System Manages the Hardware
All attempts by an application program to manipulate the hardware must
go through the operating system.
The Operating System Manages the Hardware
The operating system has two primary purposes:
(1) To protect the hardware from misuse by runaway applications.
(2) To provide applications with simple and uniform mechanisms for
manipulating complicated and often wildly different low-level hardware
devices.
The operating system achieves both goals via the fundamental abstractions
shown in Figure 1.11: processes, virtual memory, and files.
The Operating System Manages the Hardware
As this figure suggests, files are abstractions for I/O devices,
virtual memory is an abstraction for both the main memory and disk I/O
devices, and
Processes are abstractions for the processor, main memory, and I/O
devices.
The Operating System Manages the Hardware
Processes
A process is the operating system’s abstraction for a running program.
Multiple processes can run concurrently on the same system, and
each process appears to have exclusive use of the hardware.
By concurrently, we mean that the instructions of one process are
interleaved with the instructions of another process.
In most systems, there are more processes to run than there are CPUs to
run them.
The Operating System Manages the Hardware
Processes
Traditional systems could only execute one program at a time,
While newer multicore processors can execute several programs
simultaneously.
In either case, a single CPU can appear to execute multiple processes
concurrently by having the processor switch among them.
The operating system performs this interleaving with a mechanism known
as context switching.
The Operating System Manages the Hardware
Processes
The operating system keeps track of all the state information that the
process needs in order to run.
This state, which is known as the context,
includes information such as the current values of the PC, the register file,
and the contents of main memory.
At any point in time, a uniprocessor system can only execute the code for a
single process.
The Operating System Manages the Hardware
Processes
When the operating system decides to transfer control from the current
process to some new process,
it performs a context switch by saving the context of the current process,
restoring the context of the new process,
and then passing control to the new process.
The new process picks up exactly where it left off.
The Operating System Manages the Hardware
Processes
Figure 1.12 shows this basic idea.
As Figure indicates, the transition from one process to another is managed
by the operating system kernel.
The Operating System Manages the Hardware
Processes
The kernel is the portion of the operating system code that is always
resident in memory.
When an application program requires some action by the operating
system, such as to read or write a file,
It executes a special system call instruction, transferring control to the
kernel.
The kernel then performs the requested operation and returns back to the
application program.
The Operating System Manages the Hardware
Processes
Note that the kernel is not a separate process.
Instead, it is a collection of code and data structures that the system uses
to manage all the processes.
Implementing the process abstraction
requires close cooperation between both the low-level hardware and the
operating system software.
The Operating System Manages the Hardware
Threads
Although we normally think of a process as having a single control flow,
in modern systems a process can actually consist of multiple execution
units, called threads,
each running in the context of the process and sharing the same code and
global data.
Threads are an increasingly important programming model
because of the requirement for concurrency in network servers,
The Operating System Manages the Hardware
Threads
because it is easier to share data between multiple threads than between
multiple processes,
and because threads are typically more efficient than processes.
Multi-threading is also one way to make programs run faster when
multiple processors are available.
The Operating System Manages the Hardware
Virtual Memory
Virtual memory is an abstraction that provides each process with the
illusion that it has exclusive use of the main memory.
Each process has the same uniform view of memory,
Which is known as its virtual address space.
The virtual address space for Linux processes is shown in Figure 1.13.
(Other Unix systems use a similar layout.).
The Operating System Manages the Hardware
Virtual Memory
The Operating System Manages the Hardware
Virtual Memory
In Linux, the topmost region of the address space is reserved for code and
data in the operating system that is common to all processes.
The lower region of the address space holds the code and data defined by
the user’s process.
Note that addresses in the figure increase from the bottom to the top.
The virtual address space seen by each process consists of a number of
well defined areas, each with a specific purpose.
The Operating System Manages the Hardware
Program code and data
Code begins at the same fixed address for all processes,
followed by data locations that correspond to global C variables.
The code and data areas are initialized directly from the contents of an
executable object file.
Heap
The code and data areas are followed immediately by the run-time heap.
Unlike the code and data areas, which are fixed in size.
The Operating System Manages the Hardware
Heap
Once the process begins running,
The heap expands and contracts dynamically at run time,
as a result of calls to C standard library routines such as malloc and free.
Shared libraries
Near the middle of the address space is an area that holds the code and
data for shared libraries
such as the C standard library and the math library.
The Operating System Manages the Hardware
Stack.
At the top of the user’s virtual address space is the user stack
That the compiler uses to implement function calls.
Like the heap, the user stack expands and contracts dynamically during the
execution of the program.
In particular, each time we call a function, the stack grows.
Each time we return from a function, it contracts.
The Operating System Manages the Hardware
Kernel virtual memory.
The top region of the address space is reserved for the kernel.
Application programs are not allowed to read or write the contents of this
area
or to directly call functions defined in the kernel code.
Instead, they must invoke the kernel to perform these operations.
The Operating System Manages the Hardware
Files
A file is a sequence of bytes.
Every I/O device, including disks, keyboards, displays, and even networks,
is modeled as a file.
All input and output in the system is performed by reading and writing
files,
using a small set of system calls known as Unix I/O.
Systems Communicate with Other Systems Using Networks
Modern systems are often linked to other systems by networks.
From the point of view of an individual system,
The network can be viewed as just another I/O device, as shown in Figure
1.14.
When the system copies a sequence of bytes from main memory to the
network adapter,
The data flow across the network to another machine.
Similarly, the system can read data sent from other machines and copy
these data to its main memory.
Systems Communicate with Other Systems Using Networks
