Operating systems system structures

2
An Operating System provides services to both the users
and to the programs.
It provides programs an environment to execute.
It provides users the services to execute the programs in
a convenient manner.

Almost all operating systems have a user interface (UI), which can
take several forms.
Uses text commands and a method
for entering them.
: commands and directives to control those
commands are entered into files, and those files are executed.
It is a window system with a
pointing device (like mouse) to point to the I/O, choose from
menus driven interface and to make choices viewing from a
number of lists and a keyboard to entry the texts.
3
O
S
S
E
R
V
I
C
E
S

The system must be able to load a program into memory and
to run that program. The program must be able to end its
execution, either normally or abnormally (indicating error).
4
O
S
S
E
R
V
I
C
E
S
A running program may require I/O, which may involve a file
or an I/O device. For efficiency and protection, users usually
cannot control I/O devices directly. Therefore, the operating
system must provide a means to do I/O.
Programs need to read and write files and directories. They
also need to create, delete, search and list file information.
Many operating systems provide a variety of file systems,
sometimes to allow personal choice and sometimes to provide
specific features or performance characteristics.

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 computer network.
Communications may be implemented via , in
which two or more processes read and write to a shared section of
memory, or , in which packets of information in
predefined formats are moved between processes by the
operating system.
5
The OS needs to be detecting and correcting errors constantly.
Errors may occur in the CPU and memory hardware, in I/O devices
and in the user program. For each type of error, the operating
system should take the appropriate action to ensure correct and
consistent computing. Sometimes, the OS has to halt the system or
terminate an error-causing process or return an error code.
O
S
S
E
R
V
I
C
E
S

When there are multiple users or multiple jobs running at
the same time, resources must be allocated to each of them.
The operating system manages many different types of
resources. Some (such as CPU cycles, main memory, and file
storage) may have special allocation code, whereas others
(such as I/O devices) may have much more general request
and release code.
6
A track is to be maintained of which users use how much
and what kinds of computer resources. This record keeping
may be used for accounting (so that users can be billed) or
simply for accumulating usage statistics. Usage statistics may
be a valuable tool for researchers who wish to reconfigure
the system to improve computing services.
O
S
S
E
R
V
I
C
E
S

The owners of information stored in a multiuser or networked
computer system may want to control use of that information.
When several separate processes execute concurrently, it should not be
possible for one process to interfere with the others or with the
operating system itself.
Protection involves ensuring that all access to system resources is
controlled. Security of the system from outsiders is also important.
Such security starts with requiring each user to authenticate
themselves to the system, usually by means of a password, to gain
access to system resources.
It extends to defending external I/O devices, including network
adapters, from invalid access attempts and to recording all such
connections for detection of break-ins. If a system is to be protected
and secure, precautions must be instituted throughout it. A chain is
only as strong as its weakest link.
7
O
S
S
E
R
V
I
C
E
S

Two fundamental approaches are used by the users to
interface with the operating system.
1. One provides a command-line interface, or command interpreter,
that allows users to directly enter commands to be performed by
the operating system.
2. The other approach allows users to interface with the operating
system via a graphical user interface, or GUI.
8

 A command line interpreter is any program that allows the entering
of commands and then executes those commands to the operating
system.
Some operating systems include the command interpreter in the
kernel. Others, such as Windows and UNIX, treat the command
interpreter as a special program that is running when a job is initiated
or when a user first logs on.
On systems with multiple command interpreters to choose from, the
interpreters are known as . For example, on UNIX and Linux
systems, a user may choose among several different shells, including
the Bourne shell, C shell, Bourne-Again shell, Korn shell, and others.
Third-party shells and free user-written shells are also available. Most
shells provide similar functionality, and a user’s choice of which shell
to use is generally based on personal preference.
9
Command Interpreters
O
S
I
N
T
E
R
F
A
C
E
S

The main function of the command interpreter is to get and execute
the next user-specified command. Many of the commands given at this
level manipulate files: create, delete, list, print, copy, execute, and so
on. The MS-DOS and UNIX shells operate in this way. These
commands can be implemented in two general ways.
1. In one approach, 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 section of its code that sets up the
parameters and makes the appropriate system call.
2. An alternative approach—used by UNIX, among other operating systems —
implements most commands through system programs. In this case, the
command interpreter does not understand the command in any way; it
merely uses the command to identify a file to be loaded into memory and
executed.
10
Command Interpreters
O
S
I
N
T
E
R
F
A
C
E
S

A second strategy for interfacing with the operating system is through
a user friendly graphical user interface, or GUI.
Here, rather than entering commands directly via a command-line
interface, users employ a
characterized by a desktop metaphor.
The user moves the mouse 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
— or pull down a menu that contains commands.
Because a mouse is impractical for most mobile systems, smartphones
and handheld tablet computers typically use a touchscreen interface.
Here, users interact by making on the touchscreen—for
example, pressing and swiping fingers across the screen.
11
Graphical User Interfaces
O
S
I
N
T
E
R
F
A
C
E
S

System administrators who manage computers and power users who
have deep knowledge of a system frequently use the command-line
interface. For them, it is more efficient, giving them faster access to
the activities they need to perform.
Further, command line interfaces usually make repetitive tasks easier,
in part because they have their own programmability.
Shell scripts (set of command-line steps recorded into a file) are very
common on systems that are command-line oriented, such as UNIX
and Linux.
In contrast, most Windows users are happy to use the Windows GUI
environment and almost never use the MS-DOS shell interface.
The user interface can vary from system to system and even from user
to user within a system. It typically is substantially removed from the
actual system structure.
12
Choice of Interface
O
S
I
N
T
E
R
F
A
C
E
S

SYSTEM CALLS
In computing, a system call is the programmatic way in which a
computer program requests a service from the kernel of the
operating system it is executed on.
This may include hardware-related services (for example,
accessing a hard disk drive), creation and execution of new
processes, and communication with integral kernel services
such as process scheduling.
System calls provide an essential interface between a process
and the operating system.
System calls provide an interface to the services made available
by an operating system. These calls are generally available as
routines written in C and C++, although certain low-level tasks
may have to be written using assembly-language instructions.
13

14
Example System Call Sequence
Acquire input file name
Write prompt to screen
Accept input
Acquire output file name
Write prompt to screen
Accept input
Open the input file
if file doesn't exits, abort
Create out file
if file exits, abort
Loop
Read from input file
Write to output file
Until read fails
Close output file
Write completion message to screen
Terminate normally
source file
destination file
Example of how system calls are used
Writing a simple program to read data from one file and copy
them to another file.
Even simple
programs may
make heavy use
of the operating
system.
Frequently,
systems execute
thousands of
system calls per
second.

15
 Application developers design programs according to an
 The API specifies a set of functions that are available to an
application programmer, including the parameters that are passed
to each function and the return values the programmer can expect.
 Three of the most common APIs available to application
programmers are the Windows API for Windows systems, the
POSIX API for POSIX-based systems (which include virtually all
versions of UNIX, Linux, and Mac OSX), and the Java API for
programs that run on the Java virtual machine.
 A programmer accesses an API via a library of code provided by
the operating system. The functions that make up an API typically
invoke the actual system calls on behalf of the application
programmer.

17
Several reasons are present as to why an application programmer prefer
programming according to an API rather than invoking actual system
calls.
 First benefit is portability. A programmer designing a program using
an API can expect her program to compile and run on any system
that supports the same API.
 Furthermore, actual system calls can often be more detailed and
difficult to work with than the API available to an application
programmer.
For most programming languages, the run-time support system
(a set of functions built into libraries included with a compiler)
provides a system-call interface that serves as the link to
system calls made available by the operating system. The
system-call interface intercepts function calls in the API and
invokes the necessary system calls within the operating system.

System Call Implementation
Typically, a number associated with each system call
• System-call interface maintains a table indexed according to
these numbers
The system call interface invokes the intended system call in
OS kernel and returns status of the system call and any return
values
The caller need know nothing about how the system call is
implemented
• Just needs to obey API and understand what OS will do as a
result of execution of that system call
• Most details of OS interface hidden from programmer by
API
Managed by run-time support library (set of functions
built into libraries included with compiler)
18

19
operating system handling a user application invoking the open()
system call

20
System Call Parameter Passing
 System calls occur in different ways. Often, more information is
required than simply identity of desired system call
 Exact type and amount of information vary according to OS
and call
 Three general methods used to pass parameters to the OS
 Simplest: pass the parameters in registers
 In some cases, may be more parameters than registers
 Parameters stored in a block, or table, in memory, and address of
block passed as a parameter in a register
This approach taken by Linux and Solaris
 Parameters can also be placed, or pushed, onto the stack by the
program and popped off the stack by the operating system
 Sometimes, Block and stack methods are preferred as they do not
limit the number or length of parameters being passed

22
 System calls can be grouped roughly into six major categories:
process control, file manipulation, device manipulation,
information maintenance, communications, and protection.

A running program needs to be able to halt its execution either
normally (end()) or abnormally (abort()).
If the program is terminated abruptly, a memory dump is taken and
written to a disk. This dump is examined by a debugger system
program designed to aid the programmer in finding and correcting
errors, or bugs—to determine the cause of the problem.
A process or job executing one program may want to load() and
execute() another program. This feature allows the command
interpreter to execute a program as directed by mouse, or a batch
command.
A running program can effectively call another program. If both
programs continue concurrently, we have created a new job or process
to be multiprogrammed. Often, there is a system call specifically for
this purpose (create process() or submit job()).
23
S
Y
S
T
E
M
C
A
L
L
S

If a new job or process is created, its execution is to be controlled.
This control requires the ability to determine and reset the attributes of
a job or process, including the job’s priority, its maximum allowable
execution time, and so on (get process attributes() and set process
attributes()).
If a process is to be terminated (incorrect or no longer
needed),terminate process() is used.
Once new jobs or processes are created, we have to wait for them to
finish their execution. To wait for a certain amount of time to pass
(wait time()), wait for a specific event to occur (wait event()). The
jobs or processes should then signal when that event has occurred
(signal event()).
To ensure the integrity of the data being shared, operating systems
often provide system calls allowing a process to lock shared data.
Then, no other process can access the data until the lock is released.
Typically, such system calls include acquire lock() and release lock().
24
S
Y
S
T
E
M
C
A
L
L
S

We first need to be able to create() and delete() files. Either system call
requires the name of the file and perhaps some of the file’s attributes.
Once the file is created, we need to open() it and to use it. We may also
read(), write(), or reposition() (rewind or skip to the end of the file, for
example). Finally, we need to close() the file, indicating that we are no
longer using it.
We may need these same sets of operations for directories if we have a
directory structure for organizing files in the file system.
In addition, for either files or directories, we need to be able to determine
the values of various attributes and perhaps to reset them if necessary.
File attributes include the file name, file type, protection codes,
accounting information, and so on. At least two system calls, get file
attributes() and set file attributes(), are required for this function. Some
operating systems provide many more calls, such as calls for file move()
and copy().
25
S
Y
S
T
E
M
C
A
L
L
S

The various resources controlled by the operating system can be
thought of as devices. Some of these devices are physical devices (for
example, disk drives), while others can be thought of as abstract or
virtual devices (for example, files).
A system with multiple users may require us to first request() a device,
to ensure exclusive use of it. After we are finished with the device, we
release() it. These functions are similar to the open() and close()
system calls for files.
Once the device has been requested (and allocated to us), we can
read(), write(), and (possibly) reposition() the device, just as we can
with files.
In fact, the similarity between I/O devices and files is so great that
many operating systems, including UNIX, merge the two into a
combined file–device structure.
26
S
Y
S
T
E
M
C
A
L
L
S

Many system calls exist simply for the purpose of transferring
information between the user program and the operating system. For
example, most systems have a system call to return the current time()
and date(). Other system calls may return information about the system,
such as the number of current users, the version number of the operating
system, the amount of free memory or disk space, and so on.
Many systems provide system calls to dump() memory. This provision is
useful for debugging. A program trace lists each system call as it is
executed. Even microprocessors provide a CPU mode known as single
step, in which a trap is executed by the CPU after every instruction. The
trap is usually caught by a debugger.
In addition, the operating system keeps information about all its
processes, and system calls are used to access this information. Generally,
calls are also used to reset the process information (get process
attributes() and set process attributes()).
27
S
Y
S
T
E
M
C
A
L
L
S

 There are two common models of interprocess communication: the message-
passing model and the shared-memory model. In the message-passing
model, the communicating processes exchange messages with one another to
transfer information.
 Each computer in a network has a host name by which it is commonly known. A host
also has a network identifier, such as an IP address. Similarly, each process has a
process name, and this name is translated into an identifier by which the operating
system can refer to the process. The get hostid() and get processid() system calls do
this translation. The identifiers are then passed to the general purpose open() and
close() calls provided by the file system or to specific open connection() and close
connection() system calls, depending on the system’s model of communication. The
recipient process usually must give its permission for communication to take place
with an accept connection() call.
 Most processes that will be receiving connections are special-purpose daemons, which
are system programs provided for that purpose. They execute a wait for connection()
call and are awakened when a connection is made. The source of the communication,
known as the client, and the receiving daemon, known as a server, then exchange
messages by using read message() and write message() system calls. The close
connection() call terminates the communication.
28
S
Y
S
T
E
M
C
A
L
L
S

 In the shared-memory model, processes use shared memory create() and shared
memory attach() system calls to create and gain access to regions of memory
owned by other processes.
 Normally, the operating system tries to prevent one process from accessing
another process’s memory. Shared memory requires that two or more processes
agree to remove this restriction. They can then exchange information by reading
and writing data in the shared areas. The form of the data is determined by the
processes and is not under the operating system’s control. The processes are also
responsible for ensuring that they are not writing to the same location
simultaneously.
 Both of the models are common in operating systems, and most systems
implement both. Message passing is useful for exchanging smaller amounts of
data, because no conflicts need be avoided. It is also easier to implement than is
shared memory for intercomputer communication. Shared memory allows
maximum speed and convenience of communication, since it can be done at
memory transfer speeds when it takes place within a computer. Problems exist,
however, in the areas of protection and synchronization between the processes
sharing memory.
29
S
Y
S
T
E
M
C
A
L
L
S

Protection provides a mechanism for controlling access to the
resources provided by a computer system.
Historically, protection was a concern only on multiprogrammed
computer systems with several users.
However, with the advent of networking and the Internet, all
computer systems, from servers to mobile handheld devices,
must be concerned with protection.
Typically, system calls providing protection include set
permission() and get permission(), which manipulate the
permission settings of resources such as files and disks. The
allow user() and deny user() system calls specify whether
particular users can—or cannot—be allowed access to certain
resources.
30
S
Y
S
T
E
M
C
A
L
L
S

31
Examples of Windows and Unix System Calls

SYSTEM PROGRAMS
System programs, also known as system utilities, provide
a convenient environment for program development and
execution. Some of them are simply user interfaces to
system calls. Others are considerably more complex.
32
It may include command
interpreter (shell), compiler,
editor, and similar application
independent program. This
program deals with
application program to run it
efficiently.

33
: These programs create, delete, copy, rename, print,
dump, list, and generally manipulate files and directories.
: Some programs simply request the date and time, and
other simple requests. Others provide detailed performance, logging, and
debugging information. The output of these files is often sent to a terminal
window or GUI window
: Programs such as text editors are used to create, and
modify files.
: Compilers, assemblers, debuggers, and
interpreters for common programming languages (such as C, C++, Java,
and PERL) are often provided with the operating system.
The system may provide absolute loaders,
relocatable loaders, linkage editors, and overlay loaders.
These programs provide the mechanism for creating a
virtual connect among processes, users, and other computers. Email and
web browsers are a couple of examples.

34
: 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.
ꙮ Along with system programs, most operating systems are supplied
with programs that are useful in solving common problems or
performing common operations. Such application programs include
Web browsers, word processors and text formatters, spreadsheets,
database systems, compilers, plotting and statistical-analysis
packages, and games.

Operating systems system structures

Recommended

More Related Content

What's hot (20)

Similar to Operating systems system structures (20)

More from Mukesh Chinta (20)

Recently uploaded (20)

Operating systems system structures