1 chapter 11 process management. 2 objectives create a child process execute a new program within a...

1

Chapter 11 Process Management

2

Objectives

create a child process

execute a new program within a process

terminate a process

wait for a child process to terminate

3

What is a process ?

a process is an executing program together with – information about the program in some table entries in

kernel– the program's stack and system stacks

the user area which contains information about a process

a process image is the layout of a process in memory

a process is not a program by itself

4

Components of Process code area

- the executable code of a process

data area - static and global variables- heap area

stack area - runtime stack to hold activation records including local variables

kernel data structures to keep information– one process table in kernel– a user area per process

information like open fds, signal actions, etc

5

Components of Process

main(){ … TEXT ...}

DATA

STACK

USER AREA

6

Kernel processes and user processes

user process

process in user mode

a system call make it into kernel mode

kernel process

process in kernel mode

the code is linked directly into the kernel ( no executable file)

7

System Calls : Creating a new process

int fork( )

– create a new process (child process)

– an almost-exact duplicate of the parent process

code, data, stack, open file descriptors, etc.

– return value

success

parent process : child process id

child process :0

fail -1

8

System Calls : Creating a new process

main() {...rtn = fork();...}

DATA

STACK

USER AREA

TEXT

main() {...rtn = fork();...}

DATA

STACK

USER AREA

TEXT

main() {...rtn = fork();...}

DATA

STACK

USER AREA

TEXT

BEFORE fork()

AFTER fork()

pid: 12791

pid: 12791 pid: 12793

9

System Calls Process id

int getpid()

return a process's id

int getppid()

return a parent process's id

int exit (int status)– a process may terminate process by executing exit()

– closes a process's fds, deallocate its code, data, and stack

– sends its parent a SIGCHLD signal and waiting for its termination code to be accepted (zombie process)

10

System Calls

Orphan process

– If a parent dies before its child, the child is called an orphan process and is adopted by "init" process, PID 1.

– it is dangerous for a parent to terminate without waiting for the death of its child.

11

System Calls

int wait(int* status)– wait() causes a process to suspend until one of its children

terminate

– a successful call to wait() returns the pid of the child that

terminated and places a status code into status

fork()

exit()exec()

wait()

12

Example : fork and wait#include <stdio.h>main( ){

int pid, status, childPid;printf(“I’m the parent process and my PID is %d\n”, getpid( ));pid = fork( );if (pid != 0) { printf(“I’m the parent process with PID %d and PPID %d\n”

getpid( ), getppid( )); childPid = wait(&status); printf(“A child with PID %d terminated with exit code %d\n”

childPid, status>>8);} else {

printf(“I’m the child process with PID %d and PPID %d\n”,getpid( ), getppid( ));

exit(42);}

printf(“PID %d terminates\n”);}

13

System Calls:Exec

int execl(char* path, char* arg0, char* arg1, ... , char* argn, NULL)

int execv ( char* path, char* argv[])

– replace the calling process's code, data, and stack with the executable whose pathname is path and starts to execute the new code.

– return : a successful exec() never returns

failure : -1

main() {...execl("newpgm", ...);...}

DATA

STACK

USER AREA

CODE

main() {

...

}

DATA

STACK

USER AREA

CODE

BEFORE exec()pid: 12791 pid: 12791

AFTER exec()

/*newpgm*/

14

Example : fork and exec

call exec( ) after calling fork( ) create a new process and execute a program

#include <stdio.h>main( ){

int fork( );if (fork( ) == 0) {

execl("/bin/echo", "echo", "this is message one", NULL);perror("exec one faild"); exit(1);

}if (fork( ) == 0) {

execl("/bin/echo", "echo", "this is message two", NULL);perror("exec two faild"); exit(2);

}if (fork( ) == 0) {

execl("/bin/echo","echo", "this is message three",NULL);perror("exec three faild"); exit(3);

}printf("Parent program ending\n");

}

15

Etc

Changing directories

int chdir (char* pathname)– set a process's current working directory tot he directory pathname– the process must have execute permission from the directory to succeed– returns 0 if successful; otherwise -1

Accessing user and group ids int getuid() int setuid(int id) int geteuid() int seteuid(int id) int getgid() int setgid(int id) int getegid() int setgid(int id)

– returns the calling process's real and effective user or group ids

16

Example

#include <stdio.h>

main( )

{

system(“pwd”);

chdir(“/”);

system(“pwd”);

chdir(“/user/faculty/chang”);

system(“pwd”);

}

17

Example: Background Processing

Execute a program in the background using fork( ) and exec( )

#include <stdio.h>

main(argc, argv)

int argc, argv[ ];

{

if (fork( ) == 0) {

execvp(argv[1], &argv[1]);

fprintf(stderr, “Could not execute %s\n”,argv[1]);

}

}

18

Example: Redirection

%redirect out ls -l– duplicate the fd of “out” file to the std. Output file(fd=1)– execute the command– then all standard output will be redirected to the “ls.out” file

#include <stdio.h>main(argc, argv)int argc, argv[ ];{

int fd;fd=open(argv[1], O_CREAT|O_TRUNC|O_WRONLY, 0600)dup2(fd, 1);close(fd);execvp(argv[2], &argv[2]);perror(“main”);

}

19

Example: Redirection

%command > output

1) The parent shell forks and then waits for the child shell to terminate

2) The child shell opens the file "output" and

3) The child shell duplicates the fd of "command" to the standard output fd, and close the fd of the original file

4) The child shell then exec's the “command”. All of the standard output of the command goes to "output"

5) When the child shell terminates, the parent resumes

20

Signals

Unexpected events– a floating-point error– a power failure– an alarm clock– the death of a child process– a termination request from a user (Ctrl-C)– a suspend request from a user (Ctrl-Z)

ProcessSignal #8

21

Predefined signals

31 signals– /usr/include/signal.h– See the table in page 427

Actions of the default signal handler– terminate the process and generate a core(dump)– ignores and discards the signal(ignore)– suspends the process (suspend)– resume the process

22

Terminal signal

Terminal signals– Control-C

• SIGINT signal– Control-Z

• SIGSTP signal

Requesting an alarm signal– SIGALRM signal– Default handler

• display message “Alarm clock”

23

Example : Alarm

Alarm.c#include <stdio.h>

main( )

{

alarm(3);

printf(“Looping forever …\n”);

while (1);

printf(“This line should never be

executed\n”);

}

24

Handling Signals: signal( )

signal(int sigCode, void (*func)( )))

– specify the action for a signal• sigCode func

– func• SIG_IGN

• SIG_DFL

• user-defined function

– return• the previous func

25

Handling Signals: Example

#include <stdio.h>#include <signal.h>int alarmFlag=0;alarmHandler( );main( ) {

signal(SIGALRM,alarmHandler);alarm(3);printf(“Looping …\n”);while(!alarmFlag) {

pause( ); } printf(“Loop ends due to alarm signal \n”);} /* main */

alarmHandler( ) {printf(“An alarm clock signal was received\n”);alarmFlag = 1;

}

26

Example: Protecting Critical Code

#include <stdio.h>#include <signal.h>main ( ) {

int (*oldHandler)( );printf(“I can be Control-C’ed\n”);sleep(3);oldHandler = signal(SIGINT, SIG_IGN);printf(“I’m proctected from Control-C now\n”);sleep(3);signal(SIGINT, oldHandler);printf(“I can be Control-C’ed again\n”);sleep(3);

}

27

Sending signals: kill()

int kill(int pid, int sigCode)

– send signal with value sigCode to the process with PID pid

– condition for success• the owner of the sending process = the owner of pid• the owner of the sending process = super-user

28

Example: Time Limit #include <stdio.h>#include <signal.h>int delay;childHandler( );main(argc, argv)int argc; char *argv[ ];{int pid;signal(SIGCHLD,childHandler);pid = fork();if (pid == 0) {

execvp(argv[2], *argv[2]);perror(“Limit”);

} else {sscanf(argv[1], “%d”, &delay);sleep(delay);printf(“Child %d exceeded limit and is being killed\n”, pid);kill(pid, SIGINT); }

}

29

Example: Time Limit childHandler( ) /* Executed if the child dies

before the parent */

{

int childPid, childStatus;

childPid = wait(&childStatus);

printf(“Child %d terminated within %d seconds\n”, childPid, delay);

exit(0);

}

Usage

%limit 5 ls

%limit 4 sleep 100

30

Example: Suspending and Resume#include <signal.h>#include <stdio.h>main( ) {

int pid1, pid2;pid1 = fork( );if (pid1 == 0) {

while(1) {printf(“pid1 isalive\n”);sleep(1);}

}pid2 = fork( );if (pid2 == 0) {

while (1) {printf(“pid2 is alive\n”);sleep(1); }

}sleep(3); kill (pid1, SIGSTOP);sleep(3); kill(pid1, SIGCONT);sleep(3); kill(pid1, SIGINT);kill(pid2, SIGINT);

}

31

Booting Procedure

The First Process

the first process with pid =0, called sched, is created by UNIX during boot time, and fork/exec twice immediately

PID Name

0 sched

1 init

2 pagedaemon

init process(/etc/init) is the root process– creates processes based upon script files /etc/inittab,

/etc/rc

login process, mouting file systems, start daemon processes

– create getty's on each line that a user may login.

32

The process hierarchy

getty process(/etc/getty)– detects line activity and prompts with login– exec /bin/login, after entering a response to the login prompt.

login process– checks a user's login and password against /etc/passwd– exec /bin/sh or /bin/csh– set the evnironment variables like HOME, LOGNAME,

PATH...

shell process– initially read commands form start-up files like /etc/.cshrc and

$HOME/.cshrc– shell starts its job

33

The process hierarchy

Init process(1)

fork/exec

sh(83) login(129)

vi:95

getty(43)lpsched(7)

swapper(0)