1 chapter 11 process management. 2 objectives create a child process execute a new program within a...
TRANSCRIPT
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)