Operating System Principles

Module – 2

Dr. Rabindra Kumar Singh CSE2005

Operating-System Principles
 System Calls
 System/Application Call Interface
 Protection User/Kernel modes
 Interrupts
 Processes and Threads
 Structures (Process Control Block, Ready List etc)

Dr. Rabindra Kumar Singh CSE2005 2

Operating Systems and Kernels

Operating system boundary?

Kernels
Device drivers
Boot loader
Command Shell or other UI
Basic File Systems and Utilities

Dr. Rabindra Kumar Singh CSE2005 3

Components of a Kernel
Interrupt handlers
ISRs
Schedulers
Memory management
N/w and Inter-process communication

Dr. Rabindra Kumar Singh CSE2005 4

Where does a kernel reside?
Protected memory space
Full access to the hardware resources

This system state and memory space

collectively called – Kernel Space

User Space – Applications

How they access hardware resources?

Dr. Rabindra Kumar Singh CSE2005 5

How user applications access hardware?

Dr. Rabindra Kumar Singh CSE2005 6

System Calls
Enables
Abstraction
Protection
Fault Isolation
Some Libraries shares one to one relation with
system calls (open)
Some Libraries shares many to one relation
with system calls (printf)

Dr. Rabindra Kumar Singh CSE2005 7

Points to Ponder
Identify what happens when a user C program
calls printf()?

How many other calls it make to eventually

access the display? (Hardware resource)

Similarly you can explore for many different c

library function calls

Dr. Rabindra Kumar Singh CSE2005 8

…System Calls…
Can an application execute system call?
How is protection ensured if applications can
execute system calls?

Applications requests kernel to execute system

calls (executing in kernel space)
Kernels actually execute system calls on behalf of
applications (executing in process context)

Dr. Rabindra Kumar Singh CSE2005 9

API – System Call – OS Relationship

Dr. Rabindra Kumar Singh CSE2005 10

Standard C Library Example
 C program invoking printf() library call, which calls write()
system call

Dr. Rabindra Kumar Singh CSE2005 11

Types of System Calls
 Process control
 end, abort
 load, execute
 create process, terminate process
 get process attributes, set process attributes
 wait for time
 wait event, signal event
 allocate and free memory
 File management
 create file, delete file
 open, close file
 read, write, reposition
 get and set file attributes

Dr. Rabindra Kumar Singh CSE2005 12

Types of System Calls (Cont.)
 Device management
 request device, release device
 read, write, reposition
 get device attributes, set device attributes
 logically attach or detach devices
 Information maintenance
 get time or date, set time or date
 get system data, set system data
 get and set process, file, or device attributes
 Communications
 create, delete communication connection
 send, receive messages
 transfer status information
 attach and detach remote devices

Dr. Rabindra Kumar Singh CSE2005 13

Examples of Windows and Unix System Calls

Dr. Rabindra Kumar Singh CSE2005 14

 Interrupts

Dr. Rabindra Kumar Singh CSE2005 15

How can any device talk to the processor?

Interrupts

Polling

DMA
(Devices include I/O and Disks)

Dr. Rabindra Kumar Singh CSE2005 16

How OS handles interrupts?

So when a hardware interrupt occurs, will the

OS creates process?
No, Instead interrupts run in a special context
called “Interrupt Context”

Dr. Rabindra Kumar Singh CSE2005 17

State of processor with respect to OS

One of the three

Executing user code in user space (process
context)
Executing system calls in kernel space (process
context)
Executing system call in kernel space (interrupt
context)

Dr. Rabindra Kumar Singh CSE2005 18

 Process

Dr. Rabindra Kumar Singh CSE2005 19

Process
A program in execution

Process is an entity
A thing with distinct and independent existence

Each process has its own address space

Text region
Data region
Stack region

Dr. Rabindra Kumar Singh CSE2005 20

Continued…
Text Region
Stores the code that the processor executes.

Data Region
Stores variables and dynamically allocated memory that
the process uses during execution.

Stack Region
Stores instruction and local variables for active procedure
calls

Dr. Rabindra Kumar Singh CSE2005 21

Program Vs Process

Program is an inanimate entity

Process is a program in execution

Dr. Rabindra Kumar Singh CSE2005 22

Question for Thought

Why is a process’s address space divided into

multiple regions?

Dr. Rabindra Kumar Singh CSE2005 23

Process States: Life cycle of a process

OS must ensure that each process receives a

sufficient amount of processor time

During its lifetime, process moves through a

series of discrete process states

Various events can cause a process to change

state

Dr. Rabindra Kumar Singh CSE2005 24

continued…
Running
If a process is executing in the processor
Ready
I If a process could execute on a processor if it is
available
Blocked
If its waiting for some event to happen before it
can proceed

Dr. Rabindra Kumar Singh CSE2005 25

Continued….
When a user runs a program, processes are created
and inserted in the ready list

A process moves towards the head of the list as

other processes complete their turns using a
processor

When a processor reaches the head of the list and

when a processor becomes available, that process is
given the processor

Dr. Rabindra Kumar Singh CSE2005 26

Continued….
It is said to make the state transition from
ready to running

Dispatching: The act of assigning the

processor to the first process in the list

Dispatching is done by an entity called

dispatchers

Dr. Rabindra Kumar Singh CSE2005 27

Continued….
To prevent process to monopolize the
hardware, interrupting clocks are used
(also called interval timer)

A process can voluntarily relinquish its

resource and the process goes into Blocked
states

Dr. Rabindra Kumar Singh CSE2005 28

Process State

Dr. Rabindra Kumar Singh CSE2005 29

Process control blocks(PCB)
The operating system performs several operation
when it creates the process

To identify each process, PID numbers are

assigned

OS creates a PCB also called process descriptor

which maintains information that the OS needs to
manage the process

Dr. Rabindra Kumar Singh CSE2005 30

Continued…
The information in PCB are
PID
Process state
Program Counter
Scheduling priority
Credentials(the data that determines the resources
this process can access)
A pointer to the parent process
Pointers to the child processes
Pointers to allocated resources(like files)

Dr. Rabindra Kumar Singh CSE2005 31

Continued…
PCB also contains the register contents called
the execution context of the processor on
which the process was last running

Process Table:
Pointer to per-user process table to access PCB
quickly

Dr. Rabindra Kumar Singh CSE2005 32

Dr. Rabindra Kumar Singh CSE2005 33
Question

At any given time, only one process can be

executing instructions on a computer.-
True/False?

Name some events that might cause a process

to enter the blocked state

Dr. Rabindra Kumar Singh CSE2005 34

Process management
Creating process

Destroying process

Suspending process

Resuming process

Changing a process’s priority

Enable IPC

Dr. Rabindra Kumar Singh CSE2005 35

Process creation

A process may spawn a new process

The creating process is called :Parent

The created process/processes : Child

Each child process is created exactly by one

parent( Hierarchical)

Dr. Rabindra Kumar Singh CSE2005 36

Process creation in unix
Many processes are spawned from the init
process
Init process is created when the kernel loads

INIT

Kswapd khubd pdflush login xfs Klogd

bash

vi mypgm

Dr. Rabindra Kumar Singh CSE2005 37

Printing process id

Int main(void)
{
printf("hello world from process ID %d\n",
getpid());
exit(0);
}

Dr. Rabindra Kumar Singh CSE2005 38

In unix - fork()

We call fork to create a new process, which is

a copy of the caller
The caller is the parent and that the newly
created process is the child.
fork returns the non-negative process ID of
the new child process to the parent, and
returns 0 to the child
fork is called once by the parent but returns
twice in the parent and in the child

Dr. Rabindra Kumar Singh CSE2005 39

What will the child do?
The Child and the Parent will have separate
PIDs
The child will inherit all of the open
descriptors from the Parent
Internally the pages i.e. the stack regions
which can be modified unlike the text region,
will be shared until one of them tries to
modify the contents.

Dr. Rabindra Kumar Singh CSE2005 40

#include <unistd.h>
#include <sys/types.h>
#include <stdio.h>
int main( )
{ pid_t child_pid;
child_pid = fork (); // Create a new child process;
if (child_pid < 0) { printf("fork failed"); return 1; }
else
if (child_pid == 0)
{ printf ("child process successfully created!\n");
printf ("child_PID = %d,parent_PID = %d\n", getpid(), getppid( ) ); } else
{
wait(NULL);
printf ("parent process successfully created!\n");
printf ("child_PID = %d, parent_PID = %d", getpid( ), getppid( ) );
}
return 0;
}
Output
child process successfully created! child_PID = 31497,
parent_PID = 31496 parent process successfully created!
child_PID = 31496, parent_PID = 31491

Dr. Rabindra Kumar Singh CSE2005 41

void main(void)
{
fork();
pid = getpid();
for (i = 1; i <= 100; i++) {
printf("This line is from pid %d, value = %d\n", pid, i);
}}

Dr. Rabindra Kumar Singh CSE2005 42

Continued…

Dr. Rabindra Kumar Singh CSE2005 43

Continued…

Dr. Rabindra Kumar Singh CSE2005 44

Continued…
These processes are run concurrently, their
output lines are intermixed in a rather
unpredictable way

The order of these lines are determined by the

CPU scheduler.

Dr. Rabindra Kumar Singh CSE2005 45

Dr. Rabindra Kumar Singh CSE2005 46
Process control functions in Unix

fork()

exec()

waitpid()

Dr. Rabindra Kumar Singh CSE2005 47

exec()

exec is a functionality of an operating system

that runs an executable file in the context of
an already existing process, replacing the
previous executable.

The current process is overlaid with the new

function

Dr. Rabindra Kumar Singh CSE2005 48

Sample code
if ((pid = fork()) < 0) {
err_sys("fork error");
}
else if (pid == 0)
{ /* child */
execlp(buf, buf, (char *)0);
err_ret("couldn't execute: %s", buf);
exit();
}

Dr. Rabindra Kumar Singh CSE2005 49

Six variants of exec()

execl
execle
execlp
execv
execvp
execve

Dr. Rabindra Kumar Singh CSE2005 50

execve
int execve(char *path, char **argv, char **envp);
path is the name of an executable file

Execve() overwrites the current process so

that it executes the file in path with the
arguments in argv, and the environment
variables in envp.

Dr. Rabindra Kumar Singh CSE2005 51

Continued…
main(int argc, char **argv, char **envp)
{
char *newargv[3];
int i;
newargv[0] = "cat";
newargv[1] = "exec2.c";
newargv[2] = NULL;
i = execve("/bin/cat", newargv, envp);
perror("exec2: execve() failed");
exit(1);
}

Dr. Rabindra Kumar Singh CSE2005 52

Process Termination

There are eight ways for a process to

terminate

Normal termination occurs in five ways:

1. Return from main
2. Calling exit
3. Calling _exit or _Exit
4. Return of the last thread from its start routine
5. Calling pthread_exit

Dr. Rabindra Kumar Singh CSE2005 53

Continued…

Abnormal termination occurs in three ways:

Calling abort
Receipt of a signal
Response of the last thread to a cancellation
request

Dr. Rabindra Kumar Singh CSE2005 54

Exit() in unix

Three functions terminate a program normally

#include <stdlib.h>
void exit(int status);
void _Exit(int status);
#include <unistd.h>
void _exit(int status);
_exit and _Exit return to the kernel immediately
exit performs certain clean up processing and
then returns to the kernel

Dr. Rabindra Kumar Singh CSE2005 55

Continued…

exit and _Exit are specified by ISO C

_exit is specified by POSIX.1

exit()
Performs a clean shutdown of the standard I/O
library
fclose function is called for all open streams
This causes all buffered output data to be flushed

Dr. Rabindra Kumar Singh CSE2005 56

Continued…
All three exit functions expect a single integer
argument, which we call the exit status

Both the following functions are equal

exit(0);
return(0); (From the main function)

Dr. Rabindra Kumar Singh CSE2005 57

How a program in C starts and how it terminates?

Dr. Rabindra Kumar Singh CSE2005 58

Exit Handler in C
Every process can register for exit handlers

There can be at the most 32 exit handlers for the process

Exit handlers are functions written to perform something

The exit handlers are executed in the same order as they

are registered

Exit Handler  atexit()

Dr. Rabindra Kumar Singh CSE2005 59

Sample Exit Program
#include "apue.h"
static void my_exit1(void);
static void my_exit2(void);
int main(void)
{
if (atexit(my_exit2) != 0)
err_sys("can't register my_exit2");

if (atexit(my_exit1) != 0)
err_sys("can't register my_exit1");

if (atexit(my_exit1) != 0)
err_sys("can't register my_exit1");

printf("main is done\n");
return(0);
}

Dr. Rabindra Kumar Singh CSE2005 60

Continued…
static void my_exit1(void)
{
printf("first exit handler\n");
}

static void my_exit2(void)

{
printf("second exit handler\n");
}

Dr. Rabindra Kumar Singh CSE2005 61

Exit Status
For any of the exit cases, we want the terminating
process to be able to notify its parent how it
terminated
For the three exit functions (exit, _exit, and
_Exit), this is done by passing an exit status as the
argument to the function
In the case of an abnormal termination, however,
the kernel, not the process, generates a
termination status to indicate the reason for the
abnormal termination

Dr. Rabindra Kumar Singh CSE2005 62

Continued…

The parent of the process can obtain the

termination status from either the wait or the
waitpid function

Dr. Rabindra Kumar Singh CSE2005 63

What happens if parent terminates before?

init process becomes the parent process of any

process whose parent terminates

whenever a process terminates, the kernel goes

through all active processes to see whether the
terminating process is the parent of any process
that still exists
If so, the parent process ID of the surviving
process is changed to be 1 (the process ID of init).

Dr. Rabindra Kumar Singh CSE2005 64

When a child disappeared

The parent wouldn't be able to fetch its termination

status
The kernel keeps a small amount of information for
every terminating process, so that the information is
available when the parent of the terminating process
calls wait or waitpid
Minimally, this information consists of the process ID,
the termination status of the process, and the
amount of CPU time taken by the process

Dr. Rabindra Kumar Singh CSE2005 65

Continued…

The kernel can discard all the memory used by

the process and close its open files

In UNIX System terminology, a process that

has terminated, but whose parent has not yet
waited for it, is called a zombie

Dr. Rabindra Kumar Singh CSE2005 66

Wait()

When a process terminates, either normally or

abnormally, the kernel notifies the parent by
sending the SIGCHLD signal to the parent.

Because the termination of a child is an

asynchronous event.

It can happen at any time while the parent is

running

Dr. Rabindra Kumar Singh CSE2005 67

Continued…

This signal is the asynchronous notification

from the kernel to the parent

The parent can choose to ignore this signal, or

it can provide a function that is called when
the signal occurs: a signal handler

The default action for this signal is to be

ignored.

Dr. Rabindra Kumar Singh CSE2005 68

Continued…
A process that calls wait or waitpid can
Block, if all of its children are still running
Return immediately with the termination status of
a child, if a child has terminated and is waiting for
its termination status to be fetched
Return immediately with an error, if it doesn't
have any child processes

Dr. Rabindra Kumar Singh CSE2005 69

Continued…
If the process is calling wait because it
received the SIGCHLD signal, we expect wait
to return immediately

But if we call it at any random point in time, it

can block

Dr. Rabindra Kumar Singh CSE2005 70

Continued…
#include <sys/wait.h>
pid_t wait(int *statloc);
pid_t waitpid(pid_t pid, int *statloc, int options);

Returns process ID if OK or 1 on error

statloc is a pointer to an integer

Dr. Rabindra Kumar Singh CSE2005 71

Continued…
If this argument is not a null pointer, the
termination status of the terminated process
is stored in the location pointed to by the
argument
If a child has already terminated and is a
zombie, wait returns immediately with that
child's status
Otherwise, it blocks the caller until a child
terminates

Dr. Rabindra Kumar Singh CSE2005 72

Continued…
If the caller blocks and has multiple children,
wait returns when one terminates

We can always tell which child terminated,

because the process ID is returned by the
function

Dr. Rabindra Kumar Singh CSE2005 73

Wait Vs waitpid

The wait function can block the caller until a

child process terminates, whereas waitpid has
an option that prevents it from blocking.

The waitpid function doesn't wait for the child

that terminates first; it has a number of
options that control which process it waits for.

Dr. Rabindra Kumar Singh CSE2005 74

Example

Void pr_exit(int status)

{
if (WIFEXITED(status))
printf("normal termination:%d”,WEXITSTATUS(status));
else if (WIFSIGNALED(status))
{printf("abnormal termination:%d”, WTERMSIG(status));
else if (WIFSTOPPED(status))
printf("child stopped:%d\n", WSTOPSIG(status));
}

Dr. Rabindra Kumar Singh CSE2005 75

Continued…
#include <sys/wait.h>
Int main(void)
{
pid_t pid;
int status;
if ((pid = fork()) < 0)
printf("fork error");
else if (pid == 0) /* child */
exit(0);
Dr. Rabindra Kumar Singh CSE2005 76
Continued…
if (wait(&status) != pid)
printf("wait error");
pr_exit(status);
if ((pid = fork()) < 0)
printf("fork error");
else if (pid == 0)
abort(); //Generates SIGABRT

Dr. Rabindra Kumar Singh CSE2005 77

Continued…
if (wait(&status) != pid)
printf("wait error");
pr_exit(status);
}

Dr. Rabindra Kumar Singh CSE2005 78

 Macro Description
WIFEXITED(status) True if status was returned for a child that terminated normally. In this case, we can
execute
WEXITSTATUS (status)
to fetch the low-order 8 bits of the argument that the child passed to exit, _exit,or _Exit.
WIFSIGNALED (status) True if status was returned for a child that terminated abnormally, by receipt of a signal
that it didn't catch. In this case, we can execute
WTERMSIG (status)
to fetch the signal number that caused the termination.
Additionally, some implementations (but not the Single UNIX Specification) define the
macro
WCOREDUMP (status)
that returns true if a core file of the terminated process was generated.
WIFSTOPPED (status) True if status was returned for a child that is currently stopped. In this case, we can
execute
WSTOPSIG (status)
to fetch the signal number that caused the child to stop.
WIFCONTINUED (status) True if status was returned for a child that has been continued after a job control stop
(XSI extension to POSIX.1; waitpid only).

Dr. Rabindra Kumar Singh CSE2005 79

Waitpid

Waits for a specific process

pid == 1
Waits for any child process. In this respect, waitpid
is equivalent to wait.
pid > 0
Waits for the child whose process ID equals pid
pid == 0
Waits for any child whose process group ID equals
that of the calling process

Dr. Rabindra Kumar Singh CSE2005 80

Self Suspension
A process must obtain its process ID and then
pass the ID as an argument to suspend itself.
Pause function
int pause(void);
Causes the invoking process (or thread) to sleep
until a signal is received that either terminates it
or causes it to call a signal-catching function.
Since pause() suspends thread execution
indefinitely unless interrupted by a signal, there is
no successful completion return value.

Dr. Rabindra Kumar Singh CSE2005 81

Continued…
Kill
int kill(pid_t pid, int sig);
If pid is greater than 0, sig shall be sent to the process
whose process ID is equal to pid.
If pid is 0, sig shall be sent to all processes (excluding
an unspecified set of system processes)
If pid is -1, sig shall be sent to all processes (excluding
an unspecified set of system processes) for which the
process has permission to send that signal.

Dr. Rabindra Kumar Singh CSE2005 82

Continued…
Sigaction()
#include <signal.h>
int sigaction(int sig, const struct sigaction
*restrict act, struct sigaction *restrict oact);
The sigaction() function allows the calling
process to examine and/or specify the action
to be associated with a specific signal.

Dr. Rabindra Kumar Singh CSE2005 83

Continued…
Alarm Function:
The alarm function allows us to set a timer that
will expire at a specified time in the future
When the timer expires, the SIGALRM signal is
generated
If we ignore or don't catch this signal, its default
action is to terminate the process.

Dr. Rabindra Kumar Singh CSE2005 84

Continued…
#include <unistd.h>
unsigned int alarm(unsigned int seconds);
The seconds value is the number of clock
seconds in the future when the signal should
be generated.
There is only one of these alarm clocks per
process

Dr. Rabindra Kumar Singh CSE2005 85

Continued…
If, when we call alarm, a previously registered
alarm clock for the process has not yet
expired, the number of seconds left for that
alarm clock is returned as the value of this
function.
That previously registered alarm clock is
replaced by the new value.

Dr. Rabindra Kumar Singh CSE2005 86

Information Hiding

Implementation details are not generally

revealed

Hiding such details makes it possible to

change the implementation of a function
without rewriting code that uses the function.

Dr. Rabindra Kumar Singh CSE2005 87

References

Silberschatz, Gagne, Galvin: Operating System Concepts, 6th Edition

Dr. Rabindra Kumar Singh CSE2005 88

Dr. Rabindra Kumar Singh 89