UNIT-IV Process and Signals - PowerPoint Presentation

349 views
Uploaded On 2018-11-10

UNIT-IV Process and Signals - PPT Presentation

httpswwwjkmaterialsyolasitecom httpswwwjkdirectoryyolasitecom Process and Signals It control almost all activities performed by Linux Process IEEE Std 10031 2004 Edition an address space with one or more threads executing within that address space and the required system r ID: 725869

yolasite www signal https www yolasite https signal process jkmaterials jkdirectory int include signals set pid char const processes

Link:

Copy

Embed:

<iframe width="560" height="315" src="https://www.docslides.com/embed/725869" frameborder="0" allowfullscreen></iframe>

Download Presentation from below link

Download Presentation The PPT/PDF document "UNIT-IV Process and Signals" is the property of its rightful owner. Permission is granted to download and print the materials on this web site for personal, non-commercial use only, and to display it on your personal computer provided you do not modify the materials and that you retain all copyright notices contained in the materials. By downloading content from our website, you accept the terms of this agreement.

Presentation Transcript

Slide1

UNIT-IVProcess and Signals

https://www.jkmaterials.yolasite.com https://www.jkdirectory.yolasite.comSlide2

Process and Signals

control

almost all activities performed by Linux ProcessIEEE Std 1003.1, 2004 Editionan address space with one or more threads executing within that address space, and the required system resources for those threadsProgram / process  running – consistsProgram codeDataVariablesOpen filesEnvironment

https://www.jkmaterials.yolasite.com https://www.jkdirectory.yolasite.comSlide3

Process Structure

Users

 Neil and Rick

rungrephttps://www.jkmaterials.yolasite.com https://www.jkdirectory.yolasite.comSlide4

$ ps -ef

PID ranges

2 to 32768

1  init processhttps://www.jkmaterials.yolasite.com https://www.jkdirectory.yolasite.comSlide5

Process Table

data

structure

 describesAll processes currently loaded  withPIDStatusCommand stringO/P  psLimited sizeEarly UNIX  256 processesmodern implementations have relaxed Limited by

memory

available

https://www.jkmaterials.yolasite.com https://www.jkdirectory.yolasite.comSlide6

Viewing Processes

https://www.jkmaterials.yolasite.com https://www.jkdirectory.yolasite.comSlide7

Viewing Processes

TTY

Terminal

Process started fromTIMETimeUsed  process so farCMDCommandUsed  process startCUsage %  CPU STIMEStart time  process

https://www.jkmaterials.yolasite.com https://www.jkdirectory.yolasite.comSlide8

System Processes

STAT Code

Description

Sleeping

Running

Uninterruptible Sleep (Waiting

)

Stopped

Defunct or “zombie” process.

Low priority task, “nice.”

Paging

Process is a session

leader

Process is in the foreground process

group

lProcess is multithreaded<High priority task

how to view the status of a process

 STAT O/P  PS

↓

https://www.jkmaterials.yolasite.com https://www.jkdirectory.yolasite.comSlide9

System Processes

https://www.jkmaterials.yolasite.com https://www.jkdirectory.yolasite.comSlide10

Process Scheduling

 O/P

21475 pts/2 R+ 0:00 ps ax2145  PIDpts/2  terminalR+  Running ForegroundWell-behaved programs  termed nice programsNiceness  measured

Based

 Nice Value

Default  0

Programs



run

for long periods

pausing



lower

priorities

Pause



high priority

↓

https://www.jkmaterials.yolasite.com https://www.jkdirectory.yolasite.comSlide11

Process Scheduling

process

nice value

set niceExample nice value  10adjustreniceExample: renice 10 1362

https://www.jkmaterials.yolasite.com https://www.jkdirectory.yolasite.comSlide12

Process Scheduling

1362: old priority 0, new priority

Status  process 1362ps x

https://www.jkmaterials.yolasite.com https://www.jkdirectory.yolasite.comSlide13

Starting New Processes

Cause program

 run from

Inside another program#include <stdlib.h>int system (const char *string);system()runs  command passed  stringcommand is executedAs if the command $ sh -c stringGiven

 shell

system() returns

127  can’t be started

-1  error

Exit code  command  success

https://www.jkmaterials.yolasite.com https://www.jkdirectory.yolasite.comSlide14

Starting New Processes

run

 background

system(“ps ax &“);

https://www.jkmaterials.yolasite.com https://www.jkdirectory.yolasite.comSlide15

Starting New Processes

Replacing a Process

Image

#include <unistd.h>char **environ;int execl(const char *path, const char *arg0, ..., (char *)0);int execlp(const char *file, const char *arg0, ..., (char *)0);int execle(const char *path, const char *arg0, ..., (char *)0, char *const envp[]);int execv

(const char *path, char *const argv[]);

int

execvp

(const char *file, char *const argv[]);

int

execve

(const char *path, char *const argv[], char *const

envp

[]);

https://www.jkmaterials.yolasite.com https://www.jkdirectory.yolasite.comSlide16

Starting New Processes

https://www.jkmaterials.yolasite.com https://www.jkdirectory.yolasite.comSlide17

Starting New Processes

Running this will get . . .

https://www.jkmaterials.yolasite.com https://www.jkdirectory.yolasite.comSlide18

Starting New Processes

As Usual ps output but

Done message at allhttps://www.jkmaterials.yolasite.com https://www.jkdirectory.yolasite.comSlide19

Waiting for a Process

Waiting for a

Process

#include <sys/types.h>#include <sys/wait.h>pid_t wait(int *stat_loc);causes a parent process pause Until  1 of itschild processes  stoppedReturnsChild process

 PID

https://www.jkmaterials.yolasite.com https://www.jkdirectory.yolasite.comSlide20

Waiting for a Process

Status information

Macros

wait() https://www.jkmaterials.yolasite.com https://www.jkdirectory.yolasite.comSlide21

Waiting for a Process

#include <sys/

types.h

> #include <sys/wait.h>#include <unistd.h> #include <stdio.h> #include <stdlib.h>int main() {pid_t pid; char *message; int n; int exit_code;printf(“fork program starting\n”);pid = fork();switch(

pid

)

{

case -1:

perror(“fork failed”); exit(1);

case 0:

message = “This is the child”; n = 5; exit_code = 37;

break;

default:

message = “This is the parent”; n = 3; exit_code = 0;

break;

}

for(; n > 0; n--) {

puts(message); sleep(1);

}

https://www.jkmaterials.yolasite.com https://www.jkdirectory.yolasite.comSlide22

Waiting for a Process

↓

Waits

 child process  finishif (pid != 0) {int stat_val;pid_t child_pid;child_pid

= wait(&

stat_val

);

printf(“Child has finished: PID = %d\n”,

child_pid

);

if(WIFEXITED(

stat_val

))

printf(“Child exited with code %d\n”, WEXITSTATUS(

stat_val

));

else

printf(“Child terminated abnormally\n”);

}

exit(exit_code);

}

Run this

fork program starting

This is the child

This is the parentThis is the parentThis is the childThis is the parentThis is the childThis is the childThis is the childChild has finished: PID = 1582Child exited with code 37https://www.jkmaterials.yolasite.com https://www.jkdirectory.yolasite.comSlide23

Waiting for a Process

Another

waitpid()

Specific process  terminate#include <sys/types.h>#include <sys/wait.h>pid_t waitpid(pid_t pid, int *stat_loc, int options);Particular child processWrite status information to it

Modify behavior



waitpid

()

WNOHANG

Call



waitpid

– suspending execution  caller

https://www.jkmaterials.yolasite.com https://www.jkdirectory.yolasite.comSlide24

Zombie Processes

Child process

terminated

Parent processStill surviveUntil  in turn calls wait / terminates normallyThereforeChild process entry  availableProcess tableBut

active

https://www.jkmaterials.yolasite.com https://www.jkdirectory.yolasite.comSlide25

Zombie Processes

switch(

pid

){case -1:perror(“fork failed”);exit(1);case 0:message = “This is the child”;n = 3;break;default:message = “This is the parent”;n = 5;break;}

https://www.jkmaterials.yolasite.com https://www.jkdirectory.yolasite.comSlide26

Zombie Processes

–alParent normallyChild process  process PID 1 (init) = parenthttps://www.jkmaterials.yolasite.com https://www.jkdirectory.yolasite.comSlide27

Input and Output Redirection

Knowledge of process

 alter behavior  programs One File descriptors = preserved across calls  fork and execExample involvesFilter programRead – standard inputWrite  standard outputperforming some useful transformation

https://www.jkmaterials.yolasite.com https://www.jkdirectory.yolasite.comSlide28

Input and Output Redirection

Example:

upper.c

#include <stdio.h>#include <ctype.h>#include <stdlib.h>int main(){int ch;while((ch =

getchar

()) != EOF) {

putchar

(

toupper

(

));

}

exit(0);

}

Run this

https://www.jkmaterials.yolasite.com https://www.jkdirectory.yolasite.comSlide29

Input and Output Redirection

Another possibility with previous program

cat file.txtthis is the file, file.txt, it is all lower case.$ ./upper < file.txtTHIS IS THE FILE, FILE.TXT, IT IS ALL LOWER CASE.What if you want to use this filter from within another program?upper.caccepts a filename = argument &respond with an error  incorrectly.https://www.jkmaterials.yolasite.com https://www.jkdirectory.yolasite.comSlide30

Input and Output Redirection

#include <

unistd.h

>#include <stdio.h>#include <stdlib.h>int main(int argc, char *argv[]){char *filename;if (argc != 2)

{

fprintf

(

stderr

, “usage:

useupper

file\n”);

exit(1);

}

filename =

argv

[1];

freopen

(filename, “r”,

stdin

)) {

fprintf

(

stderr, “could not redirect stdin from file %s\n”, filename);exit(2);}execl(“./upper”, “upper”, 0);perror(“could not exec ./upper”);exit(3);}You reopen the standard input, again checking for any errors as you do so, and then use execl to call upper.Don’t forget that execl replaces the current process; if there is no error, the remaining lines are not executed.$ ./useupper file.txtTHIS IS THE FILE, FILE.TXT, IT IS ALL LOWER CASE.Run thishttps://www.jkmaterials.yolasite.com https://www.jkdirectory.yolasite.comSlide31

Threads

Processes

Cooperate

Send & receive messagesInterruptArrange  share segments (memory)class of process known as a threadSequence of control (process)Difficult to programDifference between fork system call & creation of threadfork()  process created (own variables and PID)thread created (in contrast to process)

https://www.jkmaterials.yolasite.com https://www.jkdirectory.yolasite.comSlide32

Threads – Advantages

make a program appear to do two things at once

performance

 application that mixes input, calculation, and output = improvedSwitching between threadshttps://www.jkmaterials.yolasite.com https://www.jkdirectory.yolasite.comSlide33

Threads – Disadvantages

Need very careful design (multithreaded programs)

Debugging – difficult (multithreaded)

https://www.jkmaterials.yolasite.com https://www.jkdirectory.yolasite.comSlide34

Signals

event generated by the UNIX and Linux systems

Take action (process)

The term raisegeneration of a signalcatchreceipt of a signalSignals are raised (error condition)memory segment violationsfloating-point processor errorsillegal instructionshttps://www.jkmaterials.yolasite.com https://www.jkdirectory.yolasite.comSlide35

Signals

Signal Name

Description

SIGABORT

Process abort

SIGALRM

Alarm clock

SIGFPE

Floating-point exception

SIGHUP

Hangup

SIGILL

Illegal Instruction

SIGINT

Terminal interrupt

SIGKILL

Kill

SIGPIPE

Write on a pipe with no reader

SIGQUIT

Terminal quit

SIGSEGV

Invalid memory segment access

SIGTERM

TerminationSIGUSR1User-defined signal 1SIGUSR2User-defined signal 2

https://www.jkmaterials.yolasite.com https://www.jkdirectory.yolasite.comSlide36

Signals

Signal Name

Description

SIGCHLD

Child process has stopped or exited.

SIGCONT

Continue executing, if stopped.

SIGSTOP

Stop executing.

SIGTSTP

Terminal stop signal.

SIGTTIN

Background process trying to read.

SIGTTOU

Background process trying to write.

https://www.jkmaterials.yolasite.com https://www.jkdirectory.yolasite.comSlide37

Signals

Handle signals

signal library function

#include <signal.h>void (*signal(int sig, void (*func)(int)))(int);SIG_IGNSIG_DFLhttps://www.jkmaterials.yolasite.com https://www.jkdirectory.yolasite.comSlide38

Signals

Example

Signal Handling

ouch()Reacts  signal = sig (parameter)#include <signal.h>#include <stdio.h>#include <unistd.h>void ouch(int sig){printf

(“OUCH! - I got signal %d\n”, sig);

(void) signal(SIGINT, SIG_DFL);

}

int

main()

{

(void) signal(SIGINT, ouch);

while(1) {

printf

(“Hello World!\n”);

sleep(1); } }

./ctrlc1

Hello World!

OUCH! - I got signal 2

Hello World!

Hello World!Hello World!Hello World!^C$Run thishttps://www.jkmaterials.yolasite.com https://www.jkdirectory.yolasite.comSlide39

Sending signals

Process

 another process

Including itself (kill)Call failNo permissions  signals#include <sys/types.h>#include <signal.h>int kill(pid_t pid, int sig);Sends specified signals (sig)



pid

Returns

0 (success)

-1 (fail)

errno

= EINVAL(

valid

signal)

errno = EPERM (

permissions

)

https://www.jkmaterials.yolasite.com https://www.jkdirectory.yolasite.comSlide40

Sending signals

Signals provide

Alarm clock facility

Schedule SIGALRM (future)#include <unistd.h>unsigned int alarm(unsigned int seconds);alarm call schedulesSIGALRM in secondsValue 0 outstanding alarm requestCalling alarm before signal received Rescheduledhttps://www.jkmaterials.yolasite.com https://www.jkdirectory.yolasite.comSlide41

Sending Signals

Run this

Suspend execution until signal occurs

#include <

unistd.h

int pause(void);

https://www.jkmaterials.yolasite.com https://www.jkdirectory.yolasite.comSlide42

Sending Signals - sigaction

A Robust Signals Interface:

newer programming interface (signals)

#include <signal.h>int sigaction(int sig, const struct sigaction *act, struct sigaction *oact);sigaction structure defineAction to be taken  signalvoid (*) (int) sa_handler /* function, SIG_DFL or SIG_IGNsigset_t sa_mask /* signals to block in sa_handlerint sa_flags /* signal action modifiersSigaction – example

https://www.jkmaterials.yolasite.com https://www.jkdirectory.yolasite.comSlide43

Sending Signals - sigaction

Run this

Ctrl + c

Ctrl + z

https://www.jkmaterials.yolasite.com https://www.jkdirectory.yolasite.comSlide44

Signal Sets

signal.h

sigset_t

& functions (defines)Used (sets)sigaction & Other functionsModify behavior (process)#include <signal.h>int sigaddset(sigset_t *set, int signo); /* add specified signal to signal set */int sigemptyset(sigset_t *set); /* initializes a signal set to be empty */int sigfillset(sigset_t *set);

/* initializes a signal set to contain all defined signals */

int sigdelset(sigset_t *set, int signo);

/* delete specified signal from signal set */

https://www.jkmaterials.yolasite.com https://www.jkdirectory.yolasite.comSlide45

Signal Sets

sigismember()

given signal is a member of a signal set?

#include <signal.h>int sigismember(sigset_t *set, int signo);Returns1 (signal = member of signal set)0 (signal ≠ member of signal set)-1 (error)Process signal maskSet or examinedsigprocmask()set of signals that are currently blocked thereforenot be received by the current process#include <signal.h>int sigprocmask(int

how

, const sigset_t *

set

, sigset_t *

oset

);

Change process signal mask

New values for signal mask are passed

Previous signal mask will be written

SIG_BLOCK

The signals in set are added to the signal mask.

SIG_SETMASK

The signal mask is set from set.

SIG_UNBLOCK

The signals in set are removed from the signal mask.

https://www.jkmaterials.yolasite.com https://www.jkdirectory.yolasite.comSlide46

Signal Sets

Set

= null pointer; value of how

usedOnly purpose  sigprocmask()Fetch current signal mask = osetsigprocmask()Return0 (success)-1 (how  invalid) with errno = EINVAL)https://www.jkmaterials.yolasite.com https://www.jkdirectory.yolasite.comSlide47

Signal Sets

Identify

Blocked signals (pending)

sigpending()#include <signal.h>int sigpending(sigset_t *set);Writes set of signals blocked  pendingsetReturns0 (success)-1 with errnohttps://www.jkmaterials.yolasite.com https://www.jkdirectory.yolasite.comSlide48

Signal Sets

Process

Suspended execution

UntilDelivery of one of a set of signalssigsuspend() – calling it#include <signal.h>int sigsuspend(const sigset_t *sigmask);replaces the process signal mask with the signal set given by sigmaskThen suspend executionReturnsNever return(success)-1 with errno = EINTR

https://www.jkmaterials.yolasite.com https://www.jkdirectory.yolasite.comSlide49

Signal Sets – sigaction flags

SA_NOCLDSTOP

Don’t generate SIGCHLD when child processes stop.

SA_RESETHAND

Reset signal action to SIG_DFL on receipt.

SA_RESTART

Restart interruptible functions rather than error with EINTR.

SA_NODEFER

Don’t add the signal to the signal mask when caught.

https://www.jkmaterials.yolasite.com https://www.jkdirectory.yolasite.comSlide50

Topic Beyond Syllabus