Module 1

Chapter 2

Operating System Services

Operating-System Services
• An operating system provides an environment for the
execution of programs. It provides certain services to
programs and to the users of those programs.
• OS provide services for the users of the system, including:
– User interface
– Program Execution
– I/O Operations
– File System manipulation
– Communications
– Error Detection
– Resource allocation
– Protection and security
– Accounting
 User Operating-System Interface

• There are several ways for users to interface with the

operating system.
• i) Command-line interface, or command interpreter:
– allows users to directly enter commands to be performed by the
operating system.
• ii) Graphical user interface (GUI):
– allows users to interface with the operating system using pointer
device and menu system.
 Command Interpreter

• Command Interpreters are used to give commands to the OS.

• There are multiple command interpreters known as shells.
• In UNIX and Linux systems, there are several different shells,
like the Bourne shell, C shell, Bourne-Again shell, Korn shell,
and others.
• The main function of the command interpreter is to get and
execute the user-specified command.
• Many of the commands manipulate files: create, delete, list,
print, copy, execute, and so on.
• The commands can be implemented in two general ways
1. The command interpreter itself contains the code to execute the
command.
– For example, a command to delete a file may cause the command interpreter to
jump to a particular section of its code that sets up the parameters and makes
the appropriate system call.
ii)The code to implement the command is in a function in a separate file.
--The interpreter searches for the file and loads it into the memory and
executes it by passing the parameter.
--Thus by adding new functions new commands can be added easily to
the interpreter without disturbing it.
 Graphical User Interfaces-GUI
• A second strategy for interfacing with the operating system is through
a user friendly graphical user interface or GUI.
• Rather than having users directly enter commands via a command-
line interface, a GUI allows provides a mouse-based window-and-
menu system as an interface.
• A GUI provides a desktop metaphor where the mouse is moved to
position its pointer on images, or icons, on the screen (the desktop)
that represent programs, files, directories, and system functions.
• Depending on the mouse pointer's location, clicking a button on the
mouse can invoke a program, select a file or directory—known as a
folder— or pull down a menu that contains commands.
 System Calls

• System calls provides an interface to the services of

the operating system.
• These are generally written in C or C++, although some
are written in assembly for optimal performance.
• The below figure illustrates the sequence of system
calls required to copy a file content from one file (input
file) to another file (output file).
• An example to illustrate how system calls are used:
writing a simple program to read data from one file
and copy them to another file
• There are number of system calls used to finish this task. The first system call is
to write a message on the screen (monitor).
• Then to accept the input filename. Then another system call to write message on
the screen, then to accept the output filename.
• 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 print a message on the console (another system call) and then terminate
abnormally (another system call) and create a new one (another system call).
• Now that both the files are opened, we enter a loop that reads from the input
file (another system call) and writes to output file (another system call).
• Finally, after the entire file is copied, the program may close both files (another
system call), write a message to the console or window (system call), and finally
terminate normally (final system call).
• Most programmers do not use the low-level system calls directly, but
instead use an "Application Programming Interface", API.
• Instead of direct system calls provides for greater program portability
between different systems.
• The API then makes the appropriate system calls through the system call
interface, using a system call table to access specific numbered system
calls.
• Each system call has a specific numbered system call. The system call
table (consisting of system call number and address of the particular
service) invokes a particular service routine for a specific system call.
• The caller need know nothing about how the system call is implemented
or what it does during execution.
Figure : The handling of a user application invoking the open() system
• Three general methods used to pass parameters to OS are –
1. To pass parameters in registers
2. If parameters are large blocks, address of block (where
parameters are stored in memory) is sent to OS in the
register. (Linux & Solaris).
3. Parameters can be pushed onto the stack by program and
popped off the stack by OS.
Figure: Passing of parameters as a table.
 Types of System Calls

• The system calls can be categorized into six major

categories:
1. Process Control
2. File management
3. Device management
4. Information management
5. Communications
6. Protection
 1. Process Control

• Process control system calls include end, abort, load, execute,

create process, terminate process, get/set process
attributes, wait for time or event, signal event, and allocate
and free memory.
• Processes must be created, launched, monitored, paused,
resumed, and eventually stopped.
• When one process pauses or stops, then another must be
launched or resumed
• Process attributes like process priority, max. allowable
execution time etc. are set and retrieved by OS.
• After creating the new process, the parent process may have
to wait (wait time), or wait for an event to occur (wait event)
• The process sends back a signal when the event has occurred
(signal event)
 2. File Management

• File management system calls include create file, delete file,

open, close, read, write, reposition, get file attributes, and
set file attributes.
• After creating a file, the file is opened. Data is read or written
to a file.
• The file pointer may need to be repositioned to a point.
• The file attributes like file name, file type, permissions, etc.
are set and retrieved using system calls.
• These operations may also be supported for directories as
well as ordinary files.
 3. Device Management

• Device management system calls include request device, release

device, read, write, reposition, get/set device attributes, and
logically attach or detach devices.
• When a process needs a resource, a request for resource is done.
Then the control is granted to the process. If requested resource is
already attached to some other process, the requesting process has
to wait.
• In multiprogramming systems, after a process uses the device, it has
to be returned to OS, so that another process can use the device.
• Devices may be physical (e.g. disk drives ), or virtual / abstract ( e.g.
files, partitions, and RAM disks ).
 4. Information Maintenance

• Information maintenance system calls include calls to get/set

the time, date, system data, and process, file, or device
attributes.
• These system calls care used to transfer the information
between user and the OS.
• Information like current time & date, no. of current users,
version no. of OS, amount of free memory, disk space etc. are
passed from OS to the user.
 5. Communication

• Communication system calls:

– create/delete communication connection,
– send/receive messages, transfer status information,
– attach/detach remote devices.
• The message passing model must support calls to:
– Identify a remote process and/or host with which to
communicate.
– Establish a connection between the two processes.
– Open and close the connection as needed.
– Transmit messages along the connection.
– Wait for incoming messages, in either a blocking or non-blocking
state.
– Delete the connection when no longer needed.
• The shared memory model must support calls to:
– Create and access memory that is shared amongst processes (and threads. )
– Free up shared memory and/or dynamically allocate it as needed.
• Message passing:
– is simpler and easier, (particularly for inter-computer communications), and
– is generally appropriate for small amounts of data.
– It is easy to implement,
– but there are system calls for each read and write process.
• Shared memory is faster, and is generally the better approach where
large amounts of data are to be shared.
• This model is difficult to implement, and it consists of only few system
calls.
 6. Protection

• Protection provides mechanisms for controlling which users /

processes have access to which system resources.
• System calls allow the access mechanisms to be adjusted as
needed, and for non- privileged users to be granted elevated
access permissions under carefully controlled temporary
circumstances.
 System Programs

• A collection of programs that provide a convenient environment for program

development and execution (other than OS) are called system programs or system
utilities.
• System programs may be divided into six categories:
1. File management
programs to create, delete, copy, rename, print, list, and generally manipulate files
and directories.
2. Status information
Utilities to check on the date, time, number of users, processes running, data logging,
etc. System registries are used to store and recall configuration information for
particular applications.
3. File modification
e.g. text editors and other tools which can change file contents.
4. Programming-language support
E.g. Compilers, linkers, debuggers, profilers, assemblers, library archive management,
interpreters for common languages, and support for make.
5. Program loading and execution
loaders, dynamic loaders, overlay loaders, etc., as well as interactive debuggers.
6. Communications
Programs for providing connectivity between processes and users, including mail,
web browsers, remote logins, file transfers, and remote command execution.
 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: batch, time shared, single user, multi
user, distributed, real time, or general purpose.
• Beyond this highest design level, the requirements may be much harder to
specify.
• The requirements can, however, be divided into two basic groups
1. User goals (User requirements)
2. System goals (system requirements)
• User requirements are the features that user care about and understand
like system should be convenient to use, easy to learn, reliable, safe and
fast.
• System requirements are written for the developers, ie. People who design
the OS. Their requirements are like easy to design, implement and
maintain, flexible, reliable, error free and efficient.
Mechanisms and Policies

• Policies determine what is to be done.

• Mechanisms determine how it is to be implemented. Example: in
timer- counter and decrementing counter is the mechanism and
deciding how long the time has to be set is the policies.
• Policies change overtime. In the worst case, each change in policy
would require a change in the underlying mechanism.
• If properly separated and implemented, policy changes can be
easily adjusted without rewriting the code, just by adjusting
parameters or possibly loading new data / configuration files.
Implementation

• Traditionally OS were written in assembly language.

• In recent years, OS are written in C, or C++.
• Critical sections of code are still written in assembly language.
• The first OS that was not written in assembly language, it was the Master
Control Program (MCP).
• The advantages of using a higher-level language for implementing
operating systems are:
– The code can be written faster,
– more compact,
– easy to port to other systems and
– is easier to understand and debug.
• The only disadvantages of implementing an operating system in a higher-
level language are reduced speed and increased storage requirements.
 Operating-System Structure

Simple Structure
• Many operating systems do not have well-defined structures.
• They started as small, simple, and limited systems and then grew beyond
their original scope. Eg: MS-DOS.
• In MS-DOS, the interfaces and levels of functionality are not well
separated. Application programs can access basic I/O routines to write
directly to the display and disk drives. Such freedom leaves MS-DOS in bad
state and the entire system can crash down when user programs fail.
• UNIX OS consists of two separable parts: the kernel and the system
programs. The kernel is further separated into a series of interfaces and
device drivers. The kernel provides the file system, CPU scheduling,
memory management, and other operating-system functions through
system calls.
Figure: MS-DOS layer structure.
Figure: traditional unix system structure
Layered Approach

• The OS is broken into number of layers (levels). Each layer rests on the
layer below it, and relies on the services provided by the next lower layer.
• Bottom layer (layer 0) is the hardware and the topmost layer is the user
interface.
• A typical layer, consists of data structure and routines that can be invoked by
higher-level layer.
• Advantage of layered approach is simplicity of construction and debugging.
∙ The layers are selected so that each uses functions and services of only
lower-level layers. So simplifies debugging and system verification. The
layers are debugged one by one from the lowest and if any layer doesn’t
work, then error is due to that layer only, as the lower layers are already
debugged. Thus, the design and implementation are simplified.
• A layer need not know how its lower-level layers are implemented. Thus
hides the operations from higher layers.
 Figure: A layered Operating System
:
Disadvantages of layered approach:
• The various layers must be appropriately defined, as a layer can use
only lower-level layers.
• Less efficient than other types, because any interaction with layer 0
required from top layer.The system call should pass through all the
layers and finally to layer 0. This is an overhead.
Microkernels
• This method structures the operating system by removing all nonessential components
from the kernel and implementing them as system and user-level programs thus
making the kernel as small and efficient as possible.
• The removed services are implemented as system applications.
• Most microkernels provide basic process and memory management, and message
passing between other services.
• The main function of the microkernel is to provide a communication facility between
the client program and the various services that are also running in user space.
• System expansion can also be easier, because it only involves adding more
system applications, not rebuilding a new kernel.
• Mach was the first and most widely known microkernel, and now forms a major
component of Mac OS.

Disadvantage of Microkernel -
∙ Performance overhead of user space to kernel space communication
Modules

Figure: Solaris loadable modules

∙ Modern OS development is object-oriented, with a relatively small core kernel and a set of modules which can be linked
in dynamically.
∙ Modules are similar to layers in that each subsystem has clearly defined tasks and interfaces, but any module is free to
contact any other module, eliminating the problems of going through multiple intermediary layers.
∙ The kernel is relatively small in this architecture, similar to microkernels, but the kernel does not have to implement
message passing since modules are free to contact each other directly. Eg: Solaris, Linux and MacOSX.

∙ The Max OSX architecture relies on the Mach microkernel for basic system management services, and the BSD kernel
for additional services. Application services and dynamically loadable modules (kernel extensions ) provide the rest of the
OS functionality. ∙ Resembles layered system, but a module can call any other module.
∙ Resembles microkernel, the primary module has only core functions and the knowledge of how to load and communicate
with other modules.
• Q) List and explain the different categories of
system program?
• Q) What are system calls? Briefly point out its
types.