UNIT- I INTRODUCTION TO COMPUTER SYSTEMS

Computer System – Elements and organization; Operating System Overview –

Objectives and Functions – Evolution of Operating System; Operating System
Structures – Operating System Services – User
Operating System Interface – System Calls – System Programs – Design and
Implementation–Structuring methods.

INTRODUCTION

Operating System is a program that acts as an interface between a user of a computer and the
computer hardware. Eg. Windows (Microsoft), iOS (Apple), Android (Google), Linux/Ubuntu (open
source)
Goals of Operating System:

 Execute user programs and make solving the user problems easier
 Make the computer system convenient to use
 Use the computer hardware in an efficient manner

1. COMPUTER SYSTEM

A computer system can be divided roughly into four components: the hardware, the
operating system, the application programs, and a user
Hardware: The Central Processing Unit (CPU), the Memory, and the Input/output (I/O) devices
provides the basic computing resources for the system.
Application Programs: Such as word processors, spreadsheets, compilers, and web browsers
define the ways in which these resources are used to solve users’ computing problems.
Operating System: Controls the hardware and coordinates its use among the various application
programs for the various users.

1
 Figure : Computer System

The operating system provides the means for proper use of these resources in the operation of
the computer system.
Operating Systems from two viewpoints:

 User View
 System View

 User View

The user’s view of the computer varies according to the interface being used. Many
computer users sit with a laptop or in front of a PC consisting of a monitor, keyboard, and mouse.
Such a system is designed for one user to control its resources. For this, the operating system is
designed mostly for ease of use, performance and security and not to resource utilization.
Many users interact with mobile devices such as smartphones and tablets. These devices
are connected to networks through cellular or other wireless technologies. The user interface for
mobile computers generally features a touch screen, where the user interacts with the system by
pressing and swiping fingers across the screen rather than using a physical keyboard and mouse.
Many mobile devices also allow users to interact through a voice recognition interface, such as
Apple’s Siri.

 System View

From the computer’s point of view, the operating system is the program most intimately
involved with the hardware. It is a resource allocator. A computer system has many resources
that may be required to solve a problem: CPU time, memory space, storage space, I/O devices,
and so on. The operating system acts as the manager of these resources. The operating system
must decide how to allocate the resources to specific programs and users so that it can operate
the computer system efficiently and fairly.

2
Components of Operating System

Shell :
 Environment that gives a user an interface to access the
operating system’s services.
 Launch Applications
 User Mode
Kernel :
 Keep track of the hardware and computer’s operations.
 Kernel Mode

3
 2. COMPUTER SYSTEM – ELEMENTS AND ORGANIZATION

A computer system consists of CPU and a number of device controllers connected

through a common bus that provides access between components and shared memory. Each
device controller is in charge of a specific type of device, more than one device may be attached.
For example, one system USB port can connect to a USB hub, to which several devices can be
connected. A device controller maintains some local buffer storage and a set of special purpose
registers. The device controller is responsible for moving the data between the peripheral
devices that it controls and its local buffer storage.
Operating systems have a device driver for each device controller. This device driver
understands the device controller and provides the rest of the operating system with a uniform
interface to the device. The CPU and the device controllers can execute in parallel.

Three key aspects of the system are

 Interrupts
 Storage Structure
 I/O Structure

 Interrupts
Hardware may trigger an interrupt by sending a signal to the CPU. Software may trigger
an interrupt by executing a special operation called a system call. When the CPU is interrupted,
it stops what it is doing and immediately transfers execution to a fixed location. The fixed
location usually contains the starting address where the service routine for the interrupt is
located. The interrupt service routine executes; on completion, the CPU resumes the interrupted
computation. A time line of this operation is shown below

4
 The interrupt routine is called indirectly through the table, The table holds the addresses
of the interrupt service routines for the various devices. This array, or interrupt vector, of
addresses is then indexed by a unique device number, given with the interrupt request, to
provide the address of the interrupt service routine for the interrupting device.
The interrupt architecture must also save the address of the interrupted instruction.
After the interrupt is serviced, the saved return address is loaded into the program counter, and
the interrupted computation resumes as though the interrupt had not occurred. The device
controller raises an interrupt by asserting a signal on the interrupt request line, the CPU catches
the interrupt and dispatches it to the interrupt handler, and the handler clears the interrupt by
servicing the device.

Most CPUs have two interrupt request lines. One is the nonmaskable interrupt, which is
reserved for events such as unrecoverable memory errors. The second interrupt line is
maskable: it can be turned off by the CPU before the execution of critical instruction sequences
that must not be interrupted. The maskable interrupt is used by device controllers to request
service.

 Storage Structure
 KB : 1024 Bytes
 MB : 1024 2 Bytes
 GB : 1024 3 Bytes (1 Million Bytes )
 TB : 1024 4 Bytes (1 Billion Bytes )
 PB : 1024 5 Bytes

5
 The CPU load the instructions from memory. General-purpose computers run most of
their programs from rewritable memory, called main memory (RAM).
The first program to run on computer to power ON is a bootstrap program, which then
loads the operating system. Since RAM is volatile, loses its content when power is turned off or
otherwise lost. So the bootstrap program cannot be stored in RAM. So the computer uses
electrically erasable programmable read-only memory (EEPROM) and other forms of firmware,
storage that is infrequently written to and is nonvolatile. EEPROM can be changed but cannot be
changed frequently. In addition, it is low speed, and so it contains mostly static programs and
data that aren’t frequently used. For example, the iPhone uses EEPROM to store serial numbers
and hardware information about the device.
All forms of memory provide an array of bytes. Each byte has its own address. Interaction
is achieved through a sequence of load or store instructions to specific memory addresses. The
load instruction moves a byte or word from main memory to an internal register within the CPU,
whereas the store instruction moves the content of a register to main memory.
The CPU automatically loads instructions from main memory for execution from the
location stored in the program counter. First fetches an instruction from memory and stores that
instruction in the instruction register. The instruction is then decoded and may cause operands
to be fetched from memory and stored in some internal register. After the instruction on the
operands has been executed, the result may be stored back in memory.

The programs and data must be in main memory permanently. This arrangement is not
possible on most systems for two reasons:

 Main memory is usually too small to store all needed programs and data permanently.
 Main memory, is volatile, it loses its contents when power is turned off or otherwise lost.

Most computer systems provide secondary storage as an extension of main memory.

The main requirement for secondary storage is that it be able to hold large quantities of data
permanently. The most common secondary-storage devices are hard-disk drives (HDDs) and
nonvolatile memory (NVM) devices, which provide storage for both programs and data. Most
programs are stored in secondary storage until they are loaded into memory.
Secondary storage is also much slower than main memory. Other possible components
include cache memory, CD-ROM, magnetic tapes, and so on. Those that are slow enough and
large enough that they are used only for special purposes, to store backup copies of material
stored on other devices, are called tertiary storage.
The wide variety of storage systems can be organized in a hierarchy according to storage
capacity and access time.
Smaller and faster memory closer to the CPU. Various storage systems are either volatile
or nonvolatile. Volatile storage, loses its contents when the power to the device is removed, so
data must be written to nonvolatile storage for safekeeping.
The top four levels of memory are constructed using semiconductor memory, which
consists of semiconductor based electronic circuits. Non Volatile Memory devices, at the fourth
level, are faster than hard disks. The most common form of NVM device is flash memory, which
is popular in mobile devices such as smartphones and tablets. Increasingly, flash memory is
being used for long term storage on laptops, desktops, and servers as well.

6
 Volatile storage will be referred to simply as memory. Nonvolatile storage retains its
contents when power is lost. This type of storage can be classified into two distinct types:

 Mechanical : Storage systems are HDDs, optical disks, holographic storage, and magnetic
tape.
 Electrical : Storage systems are flash memory, FRAM, NRAM, and SSD.

Mechanical storage is generally larger and less expensive per byte than electrical storage.
Conversely, electrical storage is typically costly, smaller, and faster than mechanical storage.

 I/O Structure

A large portion of operating system code is dedicated to manage I/O. General purpose
computer system consists of multiple devices, all of which exchange data via a common bus. The
form of interrupt driven I/O is fine for moving small amounts of data, direct memory access
(DMA) is used for bulk data transfer.

7
 Normal DMA Data Transfer
Data Transfer

After setting up buffers, pointers, and counters for the I/O device, the device controller
transfers an entire block of data directly to or from the device and main memory, with no
intervention by the CPU. Only one interrupt is generated per block, to tell the device driver that
the operation has completed, rather than the one interrupt per byte generated for low speed
devices. While the device controller is performing these operations, the CPU is available to
accomplish other work.
Some high-end systems use switch rather than bus architecture. On these systems,
multiple components can talk to other components concurrently, rather than competing for
cycles on a shared bus.

8
 3. EVOLUTION OF OPERATING SYSTEM

CPU : The hardware that executes instructions.

Processor : A physical chip that contains one or more
CPUs. Core : The basic computation unit of the CPU.
Multicore : Including multiple computing cores on the same
CPU. Multiprocessor : Including multiple processors.

According to the number of general-purpose processors used it is divided into

 Single Processor Systems

 Multiprocessor Systems
 Clustered Systems

 Single Processor Systems

On a single-processor system, there is one main CPU capable of executing the

instructions. Most computer systems use a single processor containing one CPU with a single
processing core. The core is the component that executes instructions and registers for storing
data locally. The one main CPU with its core is capable of executing a general-purpose
instruction set, including instructions from processes.

 Multiprocessor Systems

9
 They have more processors, each with a single-core CPU. The processors share the
computer bus and sometimes the clock, memory, and peripheral devices. The main advantages
are
 Increased throughput
 Economy of scale
 Increased reliability – graceful degradation or fault tolerance

The advantage of multiprocessor systems is increased throughput. By increasing the

number of processors, more work will be done in less time. The most common multiprocessor
systems use symmetric multiprocessing (SMP), in which each peer CPU processor performs all
tasks, including operating-system functions and user processes.

The Figure illustrates a typical SMP architecture with two processors, each with its own CPU.
Each CPU processor has its own set of registers, and local cache. Main Memory is shared. The
benefit is that many processes can run simultaneously N processes can run if there are N CPUs
without causing performance to deteriorate significantly. However, since the CPUs are separate,
one may be sitting idle while another is overloaded, resulting in inefficiencies. These
inefficiencies can be avoided if the processors share certain data structures. The definition of
multiprocessor has evolved over time and now includes multicore systems, in which multiple
computing cores reside on a single chip. Multicore systems can be more efficient than multiple
chips with single cores.

10
In a dual-core design with two cores on the same processor chip. In this design, each core has its
own register set, as well as its own local cache, often known as a level 1, or L1, cache. Notice, too,
that a level 2 (L2) cache is local to the chip but is shared by the two processing cores.

NUMA Multiprocessing Architecture

Adding additional CPUs to a multiprocessor system will increase computing power; and
adding too many CPUs, becomes a bottleneck and performance begins to degrade. Instead to
provide each CPU (or group of CPUs) with its own local memory that is accessed via a small, fast
local bus. The CPUs are connected by a shared system interconnect, so that all CPUs share one
physical address space. This approach known as Non-Uniform Memory Access, or NUMA

The advantage is that, when a CPU accesses its local memory, it is fast, and no contention
over the system interconnect. Thus, NUMA systems can scale more effectively as more
processors are added. A drawback is increased latency. For example, CPU0 cannot access the
local memory of CPU3 as quickly as it can access its own local memory, slowing down
performance.
Because NUMA systems can scale to accommodate a large number of processors, they are
becoming increasingly popular on servers as well as high-performance computing systems.

11
 Clustered Systems

Clustered computers share storage and are closely linked via a local-area network LAN or
a faster interconnect. Clustering is usually used to provide high availability service that is,
service that will continue even if one or more systems in the cluster fail.
A layer of cluster software runs on the cluster nodes. Each node can monitor one or more
of the others (over the network). If the monitored machine fails, the monitoring machine can
take ownership of its storage and restart the applications that were running on the failed
machine. High availability provides increased reliability, which is crucial in many applications.
The ability to continue providing service proportional to the level of surviving hardware is called
graceful degradation. Some systems go beyond graceful degradation and are called fault
tolerant, because they can suffer a failure of any single component and still continue operation.
Fault tolerance requires a mechanism to allow the failure to be detected, diagnosed, and, if
possible, corrected.

Clustering can be structured asymmetrically or symmetrically.

In Asymmetric Clustering, one machine is in hot standby mode while the other is running the
applications. The hot standby host machine does nothing but monitor the active server. If that
server fails, the hot standby host becomes the active server.

In symmetric clustering, two or more hosts are running applications and are monitoring each
other. This structure is obviously more efficient, as it uses all of the available hardware.

12
 4. OPERATING SYSTEM OPERATIONS

 Multiprogramming and Multitasking

 Dual-Mode and Multimode Operation
 Timer

 Multiprogramming
Multiprogramming increases CPU utilization, so that the CPU always has one to execute.
In a multiprogrammed system, a program in execution is termed as process.

Max
Operating System

Process 1

Process 2

Process 3
0

Memory Layout of a Multiprogramming System

The operating system picks and begins to execute one of these processes. Eventually, the
process may have to wait for some task, such as an I/O operation, to complete. In a non-
multiprogrammed System, the CPU would sit idle. In a multiprogrammed system, the operating
system simply switches to, and executes, another process. When that process needs to wait, the
CPU switches to another process, and so on. Eventually, the first process finishes waiting and
gets the CPU back. As long as at least one process needs to execute, the CPU is never idle.

 Multitasking
CPU switches jobs so frequently that users can interact with each job while it is running,
creating interactive computing
 Response time should be < 1 second
 Each user has at least one program executing in memory
 If several jobs ready to run at the same time [ CPU scheduling]
 If processes don’t fit in memory, swapping moves them in and out to run
 Virtual memory allows execution of processes not completely in memory

 Dual-Mode and Multimode Operation

The following are the modes
13
 User Mode:

Operating system running a user application such as handling a text editor. The transition
from user mode to kernel mode occurs when the application requests the help of operating
system or an interrupt or a system call occurs. The mode bit is set to 1 in the user mode. It is
changed from 1 to 0 when switching from user mode to kernel mode.
 Kernel Mode

The system starts in kernel mode when it boots and after the operating system is loaded,
it executes applications in user mode. There are some privileged instructions that can only be
executed in kernel mode. These are interrupt instructions, input output management etc. If the
privileged instructions are executed in user mode, it is illegal and a trap is generated. The mode
bit is set to 0 in the kernel mode. It is changed from 0 to 1 when switching from kernel mode to
user mode.
The concept of modes of operation in operating system can be extended beyond the dual
mode. Known as the multimode system. In those cases more than 1 bit is used by the CPU to set
and handle the mode.
 Timer
A user program cannot get stuck in an infinite loop or to fail to call system services and
never return control to the operating system. A timer is used to accomplish this goal. A timer
can be set to interrupt the computer after a specified period. A variable timer is generally
implemented by a fixed-rate clock and a counter. The operating system sets the counter. Every
time the clock ticks, the counter is decremented. When the counter reaches 0, an interrupt
occurs.

5. OPERATING SYSTEM SERVICES

Furthermore, the operating system, in one form or another, provides certain services to the
computer system.

 User Interface
 Program Execution
 I/O Operations
 File System Manipulation
 Communications
 Error Detection
 Resource Allocation
 Accounting
 Protection and Security

14
 User Interface
Almost all operating systems have a user interface (UI). Two types of User Interface are
Command Based Interface and Graphical User Interface

Command Based Interface

Requires a user to enter the commands to perform different tasks like creating, opening,
editing or deleting a file, etc. The user has to remember the names of all such programs or
specific commands which the operating system supports. The primary input device used by
the user for command based interface is the keyboard. Command-based interface is often less
interactive and usually allows a user to run a single program at a time. Examples of operating
systems with command-based interfaces include MS-DOS and Unix.

Command Based Interface Graphical User Interface

Graphical User Interface (GUI)

The interface is a window system with a mouse that serves as a pointing device to direct
I/O, choose from menus, and make selections and a keyboard to enter text. Mobile systems such
as phones and tablets provide a touch-screen interface, enabling users to slide their fingers
across the screen or press buttons on the screen to select choices.

15
 Program Execution:
The OS is in charge of running all types of programs, whether they are user or system
programs. The operating system makes use of a variety of resources to ensure that all types of
functions perform smoothly.

 Input/Output Operations:
The operating system is in charge of handling various types of inputs, such as those from
the keyboard, mouse, and desktop. Regarding all types of inputs and outputs, the operating
system handles all interfaces in the most appropriate manner.

For instance, the nature of all types of peripheral devices, such as mice or keyboards, differs, and
the operating system is responsible for transferring data between them.
 File System Manipulation:
The OS is in charge of deciding where data or files should be stored, such as on a floppy
disk, hard disk, or pen drive. The operating system determines how data should be stored and
handled.
 Communications :

There are many circumstances in which one process needs to exchange information with
another process. Such communication may occur between processes that are executing on the
same computer or between processes that are executing on different computer systems tied
together by a network. Communications may be implemented via shared memory, in which two
or more processes read and write to a shared section of memory, or message passing, in which
packets of information in predefined formats are moved between processes by the operating
system.

16
 Error Detection:

The operating system needs to be detecting and correcting errors constantly. Errors may
occur in the CPU and memory hardware (such as a memory error or a power failure), in I/O
devices (such as a parity error on disk, a connection failure on a network, or lack of paper in the
printer), and in the user program (such as an arithmetic overflow or an attempt to access an
illegal memory location). For each type of error, the operating system should take the
appropriate action to ensure correct and consistent computing. Sometimes, it has no choice but
to halt the system. At other times, it might terminate an error-causing process or return an error
code to a process for the process to detect and possibly correct.

 Resource Allocation:

The operating system guarantees that all available resources are properly utilized by
determining which resource should be used by whom and for how long. The operating system
makes all of the choices.

 Accounting:

The operating system keeps track of all the functions that are active in the computer
system at any one time. The operating system keeps track of all the facts, including the types of
mistakes that happened.

 Protection and Security :

The operating system is in charge of making the most secure use of all the data and
resources available on the machine. Any attempt by an external resource to obstruct data or
information must be foiled by the operating system.

6. USER AND OPERATING SYSTEM INTERFACE

There are different types of user interfaces each of which provides a different functionality:

 Command Based Interface

 Graphical User Interface
 Touch Based Interface
 Voice Based Interface
 Gesture Based Interface

 Command Based Interface

Command based interface requires a user to enter the commands to perform different
tasks like creating, opening, editing or deleting a file, etc. The user has to remember the names of
all such programs or specific commands which the operating system supports. The primary
input
17
device used by the user for command based interface is the keyboard. Command-based interface
is often less interactive and usually allows a user to run a single program at a time. Examples of
operating systems with command-based interfaces include MS-DOS and Unix.

Command Based Interface Graphical User Interface

 Graphical User Interface

Users run programs or give instructions to the computer in the form of icons, menus and
other visual options. Icons usually represent files and programs stored on the computer and
windows represent running programs that the user has launched through the operating system.
The input devices used to interact with the GUI commonly include the mouse and the keyboard.
Examples of operating systems with GUI interfaces include Microsoft Windows, Ubuntu, Fedora
and Macintosh, among others.

 Touch Based Interface

Today smartphones, tablets, and PCs allow users to interact with the system simply using
the touch input. Using the touchscreen, a user provides inputs to the operating system, which
are interpreted by the OS as commands like opening an app, closing an app, dialing a number,
scrolling across apps, etc.
Examples of popular operating systems with touch-based interfaces are Android and iOS.
Windows 8.1 and 10 also support touch-based interfaces on touchscreen devices.

Touch Based Interface Voice Based Interface

 Voice Based Interface

Modern computers have been designed to address the needs of all types of users
including people with special needs and people who want to interact with computers or
smartphones while
18
doing some other task. For users who cannot use input devices like the mouse, keyboard, and
touchscreens, modern operating systems provide other means of human-computer interaction.
Users today can use voice-based commands to make a computer work in the desired way. Some
operating systems which provide voice-based control to users include iOS (Siri), Android (Google
Now or “OK Google”), Microsoft Windows 10 (Cortana), and so on.

 Gesture Based Interface

Some smartphones based on Android and iOS as well as laptops let users interact with
the devices using gestures like waving, tilting, eye motion, and shaking. This technology is
evolving faster and it has promising potential for application in gaming, medicine, and other
areas.

7. SYSTEM CALLS
A system call is a mechanism that provides the interface between a process and the
operating system. It is a programmatic method in which a computer program requests a service
from the kernel of the OS. System call offers the services of the operating system to the user
programs via API (Application Programming Interface). System calls are the only entry points
for the kernel system.
Working of System Call

19
Step 1) The processes executed in the user mode till the time a system call interrupts it.
Step 2) After that, the system call is executed in the kernel-mode on a priority basis.
Step 3) Once system call execution is over, control returns to the user mode.,
Step 4) The execution of user processes resumed in Kernel mode.

Need of System Call

 Reading and writing from files demand system calls.

 If a file system wants to create or delete files, system calls are required.
 System calls are used for the creation and management of new processes.
 Network connections need system calls for sending and receiving packets.
 Access to hardware devices like scanner, printer, need a system call.

Example of how system calls are used.

For Example
Writing a simple program to read data from one file and copy them to another file.
The first input that the program will need is the names of the two files: the input file and
the output file. These names can be specified in many ways, depending on the operating-system
design.
One approach is to pass the names of the two files as part of the
command For example, the UNIX cp command:
cp in.txt out.txt
This command copies the input file in.txt to the output file out.txt.

A second approach is for the program to ask the user for the names.

In an interactive system, this approach will require a sequence of system calls, first to
write a prompting message on the screen and then to read from the keyboard the characters that
define the two files. On mouse-based and icon-based systems, a menu of file names is usually
displayed in a window. The user can then use the mouse to select the source name, and a
window can be opened for the destination name to be specified. This sequence requires many
I/O system calls.
Once the two file names have been obtained, the program must open the input file and create
and open the output file. Each of these operations requires another system call. Possible error
conditions for each system call must be handled. For example, when the program tries to open
the input file, it may find that there is no file of that name or that the file is protected against
access.

In these cases, the program should output an error message (another sequence of system
calls) and then terminate abnormally (another system call). If the input file exists, then we must
create a new output file. We may find that there is already an output file with the same name.
This situation may cause the program to abort (a system call), or we may delete the existing file
(another system call) and create a new one (yet another system call). Another option, in an
interactive system, is to ask the user (via a sequence of system calls to output the prompting
message and to read the response from the terminal) whether to replace the existing file or to
abort the program.

20
 When both files are set up, we enter a loop that reads from the input file (a system call)
and writes to the output file (another system call). Each read and write must return status
information regarding various possible error conditions. On input, the program may find that the
end of the file has been reached or that there was a hardware failure in the read (such as a parity
error). The write operation may encounter various errors, depending on the output device (for
example, no more available disk space).
Finally, after the entire file is copied, the program may close both files (two system calls),
write a message to the console or window (more system calls), and finally terminate normally
(the final system call).

Passing of Parameters as a table

21
Rules for passing Parameters for System Call

Here are general common rules for passing parameters to the System Call:

 Parameters should be pushed on or popped off the stack by the operating system.
 Parameters can be passed in registers. For five or fewer parameters, registers are used.
 More than five parameters, the block method is used. The parameters are generally
stored in a block, or table, in memory, and the address of the block is passed as a
parameter in a register

Types of System calls

Here are the five types of System Calls in OS:

 Process Control
 File Management
 Device Management
 Information Maintenance
 Communications

Process Control
This system calls perform the task of process creation, process termination, etc.
Functions:
 End and Abort
 Load and Execute
 Create Process and Terminate Process
 Wait and Signal Event
 Allocate and free memory

File Management
File management system calls handle file manipulation jobs like creating a file, reading, and
writing, etc.

Functions:
 Create a file
 Delete file
 Open and close file
 Read, write, and reposition
 Get and set file attributes
Device Management
Device management does the job of device manipulation like reading from device buffers, writing
into device buffers, etc.

22
Functions:
 Request and release device
 Logically attach/ detach devices
 Get and Set device attributes
Information Maintenance
It handles information and its transfer between the OS and the user program.
Functions:
 Get or set time and date
 Get process and device attributes

Communication:
These types of system calls are specially used for interprocess communications.
Functions:
 Create, delete communications connections
 Send, receive message
 Help OS to transfer status information
 Attach or detach remote devices

Important System Calls Used in OS

wait()
A process needs to wait for another process to complete its execution. This occurs when a
parent process creates a child process, and the execution of the parent process remains
suspended until its child process executes. The suspension of the parent process automatically
occurs with a wait() system call. When the child process ends execution, the control moves back
to the parent process.
fork()
Processes use this system call to create processes that are a copy of themselves. With the
help of this system Call parent process creates a child process, and the execution of the parent
process will be suspended till the child process executes.
exec()
This system call runs when an executable file in the context of an already running process
that replaces the older executable file. However, the original process identifier remains as a new
process is not built, but stack, data, head, data, etc. are replaced by the new process.
kill():
The kill() system call is used by OS to send a termination signal to a process that urges
the process to exit. However, a kill system call does not necessarily mean killing the process and
can have various meanings.
exit():
The exit() system call is used to terminate program execution. Specially in the multi-
threaded environment, this call defines that the thread execution is complete. The OS reclaims
resources that were used by the process after the use of exit() system call.

23
 8. SYSTEM PROGRAMS

System programs provide a convenient environment for program development and execution. It
can be divided into:

 File manipulation
 Status information
 File modification
 Programming language support
 Program loading and execution
 Communications
 Application programs

 File management.
These programs create, delete, copy, rename, print, list, and generally access and
manipulate files and directories.

 Status information.
Some programs simply ask the system for the date, time, amount of available memory or
disk space, number of users, or similar status information. Others are more complex, providing
detailed performance, logging, and debugging information. Typically, these programs format and
print the output to the terminal or other output devices or files or display it in a window of the
GUI. Some systems also support a registry, which is used to store and retrieve configuration
information.

 File modification: .
Several text editors may be available to create and modify the content of files stored on
disk or other storage devices. There may also be special commands to search contents of files or
perform transformations of the text.

 Programming-language support:
Compilers, assemblers, debuggers, and interpreters for common programming languages
(such as C, C++, Java, and Python) are often provided with the operating system or
available as a separate download.

 Program loading and execution:

Once a program is assembled or compiled, it must be loaded into memory to be executed.
The system may provide absolute loaders, relocatable loaders, linkage editors, and overlay
loaders. Debugging systems for either higher-level languages or machine language are needed as
well.

 Communications:
These programs provide the mechanism for creating virtual connections among processes,
users, and computer systems. They allow users to send messages to one another’s screens, to
24
browse web pages, to send e-mail messages, to log in remotely, or to transfer files from one
machine to another.

 Background services:
All general-purpose systems have methods for launching certain system-program
processes at boot time. Some of these processes terminate after completing their tasks, while
others continue to run until the system is halted. Constantly running system-program processes
are known as services, subsystems, or daemons

9. OPERATING SYSTEM DESIGN AND IMPLEMENTATION

DESIGN GOALS

The first problem in designing a system is to define goals and specifications. At the
highest level, the design of the system will be affected by the choice of hardware and the type of
system: traditional desktop/laptop, mobile, distributed, or real time. Beyond this highest design
level, the requirements may be much harder to specify.
The requirements can, however, be divided into two basic groups:

User goals and system goals.

 User goals
Convenience and efficiency , Easy to learn , Reliable , Safe and Fast

 System goals
Easy to design, implement, and maintain , Flexible, reliable, error-free, and efficient

Mechanisms and Policies

Mechanisms determine how to do something; policies determine what will be done.

For example, the timer construct is a mechanism for ensuring CPU protection, but deciding how
long the timer is to be set for a particular user is a policy decision.

• Early OS in assembly language, Now C, C++

• Using emulators of the target hardware, particularly if the real hardware is
unavailable ( e.g. not built yet ), or not a suitable platform for development, ( e.g.
smart phones, game consoles, or other similar devices. )
• Android
Library : C, C++
Application Frameworks : JAVA

25
 10. OPERATING SYSTEM STRUCTURE
Operating system can be implemented with the help of various structures. The structure of the
OS depends mainly on how the various common components of the operating system are
interconnected and melded into the kernel.
Depending on this we have following structures of the operating system:

 Monolithic Structure
 Layered Approach
 Microkernels
 Modules
 Hybrid Systems
 macOS and iOS
 Android

 Monolithic structure:

Such operating systems do not have well defined structure and are small, simple and limited
systems. The interfaces and levels of functionality are not well separated. MS-DOS is an example
of such operating system. In MS-DOS application programs are able to access the basic I/O
routines. These types of operating system cause the entire system to crash if one of the user
programs fails. Diagram of the structure of MS-DOS is shown below.

An example of such limited structuring is the original UNIX operating system, which
consists of two separable parts: the kernel and the system programs. The kernel is further
separated into a series of interfaces and device drivers, which have been added and expanded
over the years as UNIX has evolved. Everything below the system-call interface and above the
physical hardware is the kernel. The kernel provides the file system, CPU scheduling, memory
management, and other operating system functions through system calls. Taken in sum, that is
an enormous amount of functionality to be combined into one single address space. UNIX
Structure is shown below
26
The Linux operating system is based on UNIX shown in the figure below. Applications typically
use the glibc standard C library when communicating with the system call interface to the
kernel. The Linux kernel is monolithic in that it runs entirely in kernel mode in a single address
space, it does have a modular design that allows the kernel to be modified during run time.

 Layered Approach

An OS can be broken into pieces and retain much more control on system. In this
structure the OS is broken into number of layers (levels). The bottom layer (layer 0) is the
hardware and the topmost layer (layer N) is the user interface. These layers are so designed that
each layer uses the functions of the lower level layers only. This simplifies the debugging process
as if lower level layers are debugged and an error occurs during debugging then the error must
be on that layer only as the lower level layers have already been debugged. The main
27
disadvantage of this structure is that at each layer, the data needs to be modified and passed on
which adds overhead to the system. Moreover careful planning of the layers is necessary as a
layer can use only lower level layers. UNIX is an example of this structure.

 Micro-kernel:

This structure designs the operating system by removing all non-essential components
from the kernel and implementing them as system and user programs. This result in a smaller
kernel called the micro-kernel.

Advantages of this structure are that all new services need to be added to user space and
does not require the kernel to be modified. Thus it is more secure and reliable as if a service fails
then rest of the operating system remains untouched. Mac OS is an example of this type of OS.

28
 Modular structure or approach:

The best approach for an OS. It involves designing of a modular kernel. The kernel has
only set of core components and other services are added as dynamically loadable modules to
the kernel either during run time or boot time. It resembles layered structure due to the fact
that each kernel has defined and protected interfaces but it is more flexible than the layered
structure as a module can call any other module. For example Solaris OS is organized as shown
in the figure.

 Hybrid Systems
The Apple macOS operating system and the two mobile operating systems—iOS and Android.

macOS and iOS

Apple’s macOS operating system is designed to run primarily on desktop and laptop
computer systems, whereas iOS is a mobile operating system designed for the iPhone
smartphone and iPad tablet computer. Highlights of the various layers include the following:

 User experience layer. This layer defines the software interface that allows users to
interact with the computing devices. macOS uses the Aqua user interface, which is
designed for a mouse or trackpad, whereas iOS uses the Springboard user interface,
which is designed for touch devices.

 Application frameworks layer. This layer includes the Cocoa and Cocoa Touch
frameworks, which provide an API for the Objective-C and Swift programming languages.
The primary difference between Cocoa and Cocoa Touch is that the former is used for
developing macOS applications, and the latter by iOS to provide support for hardware
features unique to mobile devices, such as touch screens.

29
  Core frameworks. This layer defines frameworks that support graphics and media
including, Quicktime and OpenGL.

 Kernel environment. This environment, also known as Darwin, includes the Mach
microkernel and the BSD UNIX kernel.

Applications can be designed to take advantage of user-experience features or to bypass them

and interact directly with either the application framework or the core framework. Additionally,
an application can forego frameworks entirely and communicate directly with the kernel
environment.
Some significant distinctions between macOS and iOS include the following:
 Because macOS is intended for desktop and laptop computer systems, it is compiled to run
on Intel architectures. iOS is designed for mobile devices and thus is compiled for ARM-based
architectures. Similarly, the iOS kernel has been modified somewhat to address specific
features and needs of mobile systems, such as power management and aggressive memory
management. Additionally, iOS has more stringent security settings than macOS.
 The iOS operating system is generally much more restricted to developers than macOS and
may even be closed to developers. For example, iOS restricts access to POSIX and BSD APIs
on iOS, whereas they are openly available to developers on macOS.

Darwin OS

Darwin OS is a layered system that consists primarily of the Mach microkernel and the
BSD UNIX kernel. Darwin’s structure is shown below

Darwin provides two system-call interfaces: Mach system calls (known as traps) and BSD
system calls (which provide POSIX functionality). The interface to these system calls is a rich set

30
of libraries that includes not only the standard C library but also libraries that provide networking,
security, and programming language support.

Beneath the system-call interface, Mach provides fundamental operating system services,
including memory management, CPU scheduling, and inter process communication (IPC)
facilities such as message passing and remote procedure calls (RPCs). Much of the functionality
provided by Mach is available through kernel abstractions, which include tasks (a Mach
process), threads, memory objects, and ports (used for IPC). As an example, an application may
create a new process using the BSD POSIX fork() system call. Mach will, in turn, use a task kernel
abstraction to represent the process in the kernel.
In addition to Mach and BSD, the kernel environment provides an I/O kit for development
of device drivers and dynamically loadable modules (which macOS refers to as kernel
extensions, or kexts).

Android
Developed for Android smartphones and tablet computers. Whereas iOS is designed to
run on Apple mobile devices and is close-sourced, Android runs on a variety of mobile platforms
and is open sourced, partly explaining its rapid rise in popularity. Android is similar to iOS in
that it is a layered stack of software that provides a rich set of frameworks supporting graphics,
audio, and hardware features. These features, in turn, provide a platform for developing mobile
applications that run on a multitude of Android-enabled devices.
Software designers for Android devices develop applications in the Java language, but
they do not generally use the standard Java API. Google has designed a separate Android API for
Java development. Java applications are compiled into a form that can execute on the Android
RunTime ART, a virtual machine designed for Android and optimized for mobile devices
with limited
31
memory and CPU processing capabilities. Java programs are first compiled to a Java bytecode
.class file and then translated into an executable .dex file. Whereas many Java virtual machines
perform just-in-time (JIT) compilation to improve application efficiency, ART performs ahead-
of- time (AOT) compilation
The structure of Android appears is shown below

.dex files are compiled into native machine code when they are installed on a device, from
which they can execute on the ART. AOT compilation allows more efficient application execution
as well as reduced power consumption, features that are crucial for mobile systems.
Programs written using Java native interface JNI are generally not portable from one
hardware device to another. The set of native libraries available for Android applications
includes frameworks for developing web browsers (webkit), database support (SQLite), and
network support, such as secure sockets (SSLs). Android can run on an almost unlimited number
of hardware devices, Google has chosen to abstract the physical hardware through the hardware
abstraction layer, or HAL. By abstracting all hardware, such as the camera, GPS chip, and other
sensors, the HAL provides applications with a consistent view independent of specific hardware.
This feature, of course, allows developers to write programs that are portable across different
hardware platforms.
The standard C library used by Linux systems is the GNU C library (glibc). Google instead
developed the Bionic standard C library for Android. Not only does Bionic have a smaller
memory footprint than glibc, but it also has been designed for the slower CPUs that characterize
mobile devices. At the bottom of Android’s software stack is the Linux kernel. Google has
modified the Linux kernel used in Android in a variety of areas to support the special needs of
mobile systems, such as power management. It has also made changes in memory management
and allocation.

32
 Introduction to Operating Systems

Unit I: Introduction
Computer System | Operating System Overview | Evolution of
Operating System | Multiprocessor System | Cluster System | Distributed
System | Network Operating System | Real Time System | Operating System
Structures | Operating System Services | User and Operating System
Interface | System Calls | System Programs | Design and Implementation |
Two marks Questions with Answers |

Unit II(a): Process Management

Process Management | Process Scheduling | Operation on Processes | Inter-
Process Communication | CPU Scheduling | Scheduling Algorithms | Threads
| Types of Threads | Multithread Models | Process
Synchronization | Synchronization Hardware |
Semaphores | Classical Problem Synchronization | Monitors | Two marks
Questions with Answers |
Unit II(b): Deadlock
System Model | Deadlock Characteristics | Deadlock Solution |
Deadlock Prevention | Deadlock Avoidance |
Deadlock Detection | Deadlock Recovery | Comparison
Between Detection, Prevention and Methods of Handling Deadlock | Two
marks Questions with Answers |

Unit III: Memory Management

Main Memory | Swapping | Contiguous Memory Allocation with Fixed
Size Partitions | Contiguous Memory Allocation with Variable
Size Partitions | Paging | Structure of the Page Table | Segmentation |
Segmentation with Paging | Virtual Memory | Demand Paging |
Copy on Write | Page Replacement |
Allocation of Frames | Thrashing | Two marks Questions with Answers |

Unit IV(a): Storage Management

Mass Storage System | Data Structure | Disk Performance Parameters |
Disk Scheduling | Disk Management | Input-Output Device | I/O Hardware |
Application I/O Interface | Kernel I/O Subsystem | Two marks Questions with
Answers |
Unit IV(b): File System
Basic File Concepts | File Access Methods | File Directory and Directory
Structure | File System Mounting | File Sharing | Protection | File System
Structure | File System Implementation | Directory Implementation |
Allocation Methods | Free Space Management | Two marks Questions with
Answers |
Unit V: Virtual Machines and Mobile OS
Virtual Machines | History | Building Blocks | Types of Virtual Machines and
their Implementations | Virtualization Operating-System Components |
Mobile OS: Android | iOS Technology | Android File Management | Two
marks Questions with Answers |
 2nd Semester 3rd Semester
1st Semester
Professional English II Discrete Mathematics
Professional English I
Statistics and Numerical
Methods Digital Principles and
Matrices and Calculus
Computer Organization
Engineering Graphics
Engineering Physics
Foundation of Data
Physics for Information
Science
Engineering Chemistry Science

Basic Electrical and Data Structure

Problem Solving and Electronics Engineering
Python Programming Object Oriented
Programming in C
Programming

4th Semester 5th Semester 6th Semester

Theory of Computation Computer Networks Object Oriented Software
Engineering
Artificial Intelligence Compiler Design
and Machine Learning Embedded Systems IoT
Cryptography and
Database Management Cyber Security Open Elective I
System
Professional Elective III
Algorithms Distributed Computing
Professional Elective IV
Professional Elective I Professional Elective V
Introduction to Operating
Systems
Professional Elective II Professional Elective VI
Environmental Sciences
and sustainability Mandatory Course I Mandatory Course II

7th Semester 8th Semester

Human Values and Ethics Project Work/Internship

Elective-Management

Professional Elective II

Professional Elective III

Professional Elective IV