OPERATING SYSTEMS

TOPIC: IO SYSTEM AND MEMORY MANAGEMENT

160120733137–Srihitha Voruganti
160120733138-Sunshine Penumaka
160120733142-Yashasvi Chanda
INPUT-OUTPUT SYSTEM IN UNIX

 The I/O system defines a common interface to the other parts of the
operating system
 An important function for the I/O system is to hide the details in the different
hardware units from the main part of the kernel
 All I/O devices in the UNIX are treated as files and considered as objects in
the file system.
 The system administrator can create special files within a file system that is
referred to a specific device driver, and a user opening such a file will be able
to read from and write to the device referenced.
 The administrator can set access permissions for each device by using the
normal file-protection system.
DEVICE DRIVER SYSTEM

 In UNIX, hardware devices are accessed by the user through special device
files.
 These files are grouped into the /dev directory, and system calls open, read,
write, close, lseek etc. are redirected by the operating system to the device
driver associated with the physical device.
 The device driver is a kernel component (usually a module) that interacts
with a hardware device.
 SCSI devices under Linux are often named to help the user identify the
device. For example, the first SCSI CD-ROM is /dev/scd0.
 There are three main categories of I/O units in UNIX, block devices and
character devices, Network devices.
OVERALL STRUCTURE OF THE DEVICE
DRIVER SYSTEM
 TYPES OF I/O UNITS IN UNIX
BLOCK DEVICES
 Block devices are the devices that allow random access to completely
independent, fixed-sized blocks of data.
 Hard disks, floppy disks, and CD-ROMs are examples of block devices.
 ‘Block’ represents the unit with which the kernel performs I/O. When a block
is read into memory, it is stored in a buffer
 The request manager manages the reading and writing of buffer contents to
and from a block-device driver.
 Block-device system must provide functionality to ensure that disk access is
as fast as possible. This is achieved through the scheduling of I/O operations.
 TYPES OF I/O UNITS IN UNIX
BLOCK DEVICES
 Disk access has always been considered the slowest method of accessing data.
 The reason for this is because traditional spinning disks write data based on
locations on a spinning platter. When reading data from a spinning disk it is
necessary for the physical drive to spin the disk platters to a specific location
to read the data. This process is known as "seeking" and in terms of
computing, this process can take a long time.I/O schedulers exist as a way to
optimize disk access requests.
 In traditional scheduling methods, an unidirectional-elevator (C-SCAN)
algorithm where, separate list of requests is kept for each block-device
driver.The request lists are maintained in sorted order of increasing starting-
sector number. When a request is accepted it is removed only after the I/O is
complete. As new I/O requests are made, the request manager attempts to
merge requests in the lists.
 TYPES OF I/O UNITS IN UNIX
BLOCK DEVICES
 Linux kernel version 2.6 introduced a new I/O scheduling algorithm
 The Complete Fairness Queueing (CFQ) I/O scheduler works by creating a
per-process I/O queue. Instead of sorting requests into a list, CFQ maintains a
set of lists—by default, one for each process. The lists are maintained
according to the C-SCAN algorithm
 The goal of this I/O scheduler is to provide a fair I/O priority to each process
after ordering the queues to reduce disk seeking, it services these per-process
I/O queues in a round-robin fashion.
 TYPES OF I/O UNITS IN UNIX
CHARACTER DEVICES
 A character-device driver can be any device driver that offers serial access to
fixed blocks of data.
 Character devices include most other devices, such as mice, mouse and
keyboards
 For character devices, no need of preprocessing a file read or write request
instead the request is simply passed to the device and lets the device deal
with the request.
 The kernel maintains a standard interface to these drivers by means of a set
of tty_struct structures. struct tty_struct is allocated by the TTY layer upon
the first open of the TTY device and released after the last close
 TTY (teletypewriter) is an abstract device in UNIX and Linux which allows
users to interact with the system (reference).
 TYPES OF I/O UNITS IN UNIX
CHARACTER DEVICES
 Each of these structures provides buffering and flow control on the data
stream from the terminal device and feeds those data to a line discipline.
 A line discipline is an interpreter for the information from the terminal
device.
 tty_line discipline is responsible for attaching and detaching the terminal’s
input and output from the various processes connected to it as those
processes are suspended or awakened by the user.
 TYPES OF I/O UNITS IN UNIX
NETWORKING DEVICES
 Network devices are dealt with differently from block and character devices.
Users cannot directly transfer data to network devices. Instead, they must
communicate indirectly by opening a connection to the kernel’s networking
subsystem
 PPP or Point-to-Point Protocol, It is a protocol used to exchange IP frames (and
others) over a serial link.
 SLIP (Serial Line Internet Protocol) is a protocol that allows you to make single,
physical serial line connection between serial ports.
 PPP and SLIP networking protocols are implemented as drivers that at one end
appear to the terminal system as line disciplines and at the other end appear to
the networking system as network-device drivers. After one of these line
disciplines has been enabled on a terminal device, any data appearing on that
terminal will be routed directly to the appropriate network-device driver.
MEMORY MANAGEMENT

 Memory management is the process of controlling and coordinating a computer's

main memory.

 Memory management keeps track of each and every memory location, regardless of
either it is allocated to some process or it is free.

 Memory management under Linux has two components.

1. The first deals with allocating and freeing physical memory—pages, groups of pages,
and small blocks of RAM.

2. The second handles virtual memory, which is memory-mapped into the address
space of running processes.
Management of Physical Memory

 Due to specific hardware constraints, Linux separates physical memory into

four different zones, or regions:
• ZONE DMA
• ZONE DMA32
• ZONE NORMAL
• ZONE HIGHMEM

These zones are architecture specific.

 For example, on the Intel x86-32 architecture, certain ISA (industry standard architecture)
devices can only access the lower 16 MB of physical memory using DMA. On these systems,
the first 16 MB of physical memory comprise ZONE DMA.
 On other systems, certain devices can only access the first 4 GB of physical memory,
despite supporting 64- bit addresses. On such systems, the first 4 GB of physical memory
comprise ZONE DMA32.
 ZONE HIGHMEM (for “high memory”) refers to physical memory that is not mapped into the
kernel address space. For example, on the 32-bit Intel architecture (where 232 provides a
4-GB address space), the kernel is mapped into the first 896 MB of the address space; the
remaining memory is referred to as high memory and is allocated from ZONE HIGHMEM.
 Finally, ZONE NORMAL comprises everything else—the normal, regularly mapped pages.
Whether an architecture has a given zone depends on its constraints. A modern, 64-bit
architecture such as Intel x86-64 has a small 16 MB ZONE DMA (for legacy devices) and all
the rest of its memory in ZONE NORMAL, with no “high memory”. The relationship of zones
and physical addresses on the Intel x86-32 architecture is shown in Figure below. The kernel
maintains a list of free pages for each zone. When a request for physical memory arrives,
the kernel satisfies the request using the appropriate zone.
 The primary physical-memory manager in the Linux kernel is the page
allocator. Each zone has its own allocator, which is responsible for allocating
and freeing all physical pages for the zone and is capable of allocating ranges
of physically contiguous pages on request. The allocator uses a buddy system
to keep track of available physical pages.
 In this scheme, adjacent units of allocatable memory are paired together
(hence its name). Each allocatable memory region has an adjacent partner (or
buddy). Whenever two allocated partner regions are freed up, they are
combined to form a larger region—a buddy heap. That larger region also has a
partner, with which it can combine to form a still larger free region.
 Let’s consider a simple example. Assume the size of a memory segment is
initially 256 KB and the kernel requests 21 KB of memory. The segment is
initially divided into two buddies—which we will call AL and AR—each 128 KB in
size. One of these buddies is further divided into two 64-KB buddies— BL and
BR. However, the next-highest power of 2 from 21 KB is 32 KB so either BL or
BR is again divided into two 32-KB buddies, CL and CR. One of these buddies is
used to satisfy the 21-KB request. This scheme is illustrated in Figure below,
where CL is the segment allocated to the 21-KB request.
 All memory allocations in the Linux kernel are made either statically, by
drivers that reserve a contiguous area of memory during system boot time, or
dynamically, by the page allocator.
 However, kernel functions do not have to use the basic allocator to reserve
memory. Several specialized memory-management subsystems use the
underlying page allocator to manage their own pools of memory.
 The most important are the virtual memory system; the kmalloc() variable-
length allocator; the slab allocator, used for allocating memory for kernel
data structures; and the page cache, used for caching pages belonging to files
kmalloc() variable-length allocator

 The kernel provides an additional allocator for arbitrary-sized requests,

where the size of a request is not known in advance and may be only a few
bytes. Analogous to the C language’s malloc() function, this kmalloc() service
allocates entire physical pages on demand but then splits them into smaller
pieces. The kernel maintains lists of pages in use by the kmalloc() service.
 Memory regions claimed by the kmalloc() system are allocated permanently
until they are freed explicitly with a corresponding call to kfree(); the
kmalloc() system cannot reallocate or reclaim these regions in response to
memory shortages.
slab allocator

 Another strategy adopted by Linux for allocating kernel memory is known as

slab allocation.
 A slab is used for allocating memory for kernel data structures and is made up
of one or more physically contiguous pages.
 A cache consists of one or more slabs.
 There is a single cache for each unique kernel data structure—for example, a
cache for the data structure representing process descriptors, a cache for file
objects, a cache for inodes, and so forth.
 Each cache is populated with objects that are instantiations of the kernel data
structure the cache represents. For example, the cache representing inodes stores
instances of inode structures, and the cache representing process descriptors
stores instances of process descriptor structures. The relationship among slabs,
caches, and objects is shown in Figure 18.5. The figure shows two kernel objects 3
KB in size and three objects 7 KB in size. These objects are stored in the respective
caches for 3-KB and 7-KB objects.
 The slab-allocation algorithm uses caches to store kernel objects. When a
cache is created, a number of objects are allocated to the cache. The
number of objects in the cache depends on the size of the associated slab.
For example, a 12-KB slab (made up of three contiguous 4-KB pages) could
store six 2-KB objects. Initially, all the objects in the cache are marked as
free. When a new object for a kernel data structure is needed, the allocator
can assign any free object from the cache to satisfy the request. The object
assigned from the cache is marked as used.
 In Linux, a slab may be in one of three possible states:
1. Full. All objects in the slab are marked as used.
2. Empty. All objects in the slab are marked as free.
3. Partial. The slab consists of both used and free objects.
The slab allocator first attempts to satisfy the request with a free object in a
partial slab. If none exist, a free object is assigned from an empty slab. If no
empty slabs are available, a new slab is allocated from contiguous physical 804
Chapter 18 The Linux System pages and assigned to a cache; memory for the
object is allocated from this slab.
Page cache

 Twpages: the page cache and the virtual memory system. These systems are
closely related to each other. The page cache is the kernel’s main cache for
files and is the main mechanism through which I/O to block devices is
performed. File systems of all types, including the native Linux disk-based file
systems and the NFS networked file system, perform their I/O through the
page cache. The page cache stores entire pages of file contents and is not
limited to block devices. It can also cache networked data. The virtual
memory system manages the contents of each process’s virtual address space.
These two systems interact closely with each other because reading a page of
data into the page cache requires mapping pages in the page cache using the
virtual memory system. o other main subsystems in Linux do their own
management of physical
VIRTUAL MEMORY

 Virtual memory is a section of volatile memory created temporarily on the storage

drive. It is created when a computer is running many processes at once and RAM is
running low.
 The Linux virtual memory system is responsible for maintaining the address space
accessible to each process.
 It creates pages of virtual memory on demand and manages loading those pages from
disk and swapping them back out to disk as required.
 Under Linux, the virtual memory manager maintains two separate views of a
process’s address space: as a set of separate regions and as a set of pages.
 The first view of an address space is the logical view, describing
instructions that the virtual memory system has received concerning the
layout of the address space.
 In this view, the address space consists of a set of nonoverlapping
regions, each region representing a continuous, page-aligned subset of
the address space.
 Each region is described internally by a single vm area struct structure
that defines the properties of the region, including the process’s read,
write, and execute permissions in the region as well as information
about any files associated with the region.
 The regions for each address space are linked into a balanced binary
tree to allow fast lookup of the region corresponding to any virtual
address.
 The kernel also maintains a second, physical view of each address space. This
view is stored in the hardware page tables for the process.
 The page table entries identify the exact current location of each page of
virtual memory, whether it is on disk or in physical memory.
 The physical view is managed by a set of routines, which are invoked from
the kernel’s software-interrupt handlers whenever a process tries to access a
page that is not currently present in the page tables.
Lifetime of a Virtual Address Space

 The kernel creates a new virtual address space in two situations: when a
process runs a new program with the exec() system call and when a new
process is created by the fork() system call.
 The first case is easy. When a new program is executed, the process is given a
new, completely empty virtual address space.
 The second case, creating a new process with fork(), involves creating a
complete copy of the existing process’s virtual address space.
Swapping

 An important task for a virtual memory system is to relocate pages of memory

from physical memory out to disk when that memory is needed.
 Early UNIX systems performed this relocation by swapping out the contents of
entire processes at once, but modern versions of UNIX rely more on paging—
the movement of individual pages of virtual memory between physical
memory and disk.
 Linux does not implement whole-process swapping; it uses the newer paging
mechanism exclusively
 The paging system can be divided into two sections.
 First, the policy algorithm decides which pages to write out to disk and when
to write them.
 Second, the paging mechanism carries out the transfer and pages data back
into physical memory when they are needed again.
 Decisions regarding which processes to swap in or swap out are made by the
final scheduler process also known as the swapper.
 A Process is more likely to be swapped out if is idle or has been in main
memory for a long time.
Swapping of two processes using a disk as a backing store
Paging

 Paging was introduced as a solution to the inefficiency of swapping entire

processes in and out of memory at once.
 With paging, when the kernel requires more main memory for an active
process, only the least recently used pages of processes are moved to the
swap space.
 It allows more number of processes to fit in the main memory simultaneously
and allows the greater process size than the available physical memory.
 In kernel virtual memory, the page-table entries that map to these kernel
pages are marked as protected, so that the pages are not visible or
modifiable when the processor is running in user mode.
Mapping of Programs into Memory

 When an exec() system call is invoked,the kernel invokes a loader routine to

start running the program. The loader does not necessarily load the contents of
the program file into physical memory, but it does at least set up the mapping
of the program into virtual memory.
 Rather, the pages of the binary file are mapped into regions of virtual memory.
 It is the responsibility of the kernel’s binary loader to set up the initial memory
mapping. An ELF-format binary file consists of a header followed by several
page-aligned sections. The ELF loader works by reading the header and
mapping the sections of the file into separate regions of virtual memory.
 Once these mappings have been set up, the loader initializes the process’s
program-counter register with the starting point recorded in the ELF header,
and the process can be scheduled.
Memory Layout for ELF programs
Static and Dynamic Linking

 Once the program has been loaded and has started running, all the necessary
contents of the binary file have been loaded into the process’s virtual address space.
 However, most programs also need to run functions from the system libraries, and
these library functions must also be loaded. In the simplest case, the necessary
library functions are embedded directly in the program’s executable binary file.
 Such a program is statically linked to its libraries, and statically linked executables
can commence running as soon as they are loaded.
 The main disadvantage of static linking is that every program generated must
contain copies of exactly the same common system library functions.
 Linux implements dynamic linking in user mode through a special linker library.
Every dynamically linked program contains a small, statically linked function that is
called when the program starts. This static function just maps the link library into
memory and runs the code that the function contains.