Post on 23-Dec-2015
Process ControlProcess Control
Major Requirements of anMajor Requirements of anOperating SystemOperating System
Interleave the execution of several Interleave the execution of several processes to maximize processor processes to maximize processor utilization while providing reasonable utilization while providing reasonable response timeresponse time
Allocate resources to processesAllocate resources to processes
Support interprocess communication and Support interprocess communication and user creation of processesuser creation of processes
ProcessProcess
A program in executionA program in execution
Consists of three componentsConsists of three components– An executable programAn executable program– Associated data needed by the programAssociated data needed by the program– Execution context of the programExecution context of the program
All information the operating system needs to All information the operating system needs to manage the processmanage the process
UNIX Process StatesUNIX Process States
Process CreationProcess Creation
Submission of a batch jobSubmission of a batch job
User logs onUser logs on
Created to provide a service such as Created to provide a service such as printingprinting
Process creates another processProcess creates another process
Process CreationProcess Creation
A process may create other processesA process may create other processes– parent - childparent - child– process treeprocess tree
Each process needs resourcesEach process needs resources– CPU timeCPU time– memorymemory
Deciding how to allocate the resources is Deciding how to allocate the resources is a policy that is determined by the OSa policy that is determined by the OS
Process Creation DecisionsProcess Creation Decisions
Resource AllocationResource Allocation– Treat as a new processTreat as a new process– Divide parent’s resources among childrenDivide parent’s resources among children
ExecutionExecution– child runs concurrently with parentchild runs concurrently with parent– parent waits until some or all children terminateparent waits until some or all children terminate
Address SpaceAddress Space– copy of parentcopy of parent– new program loaded into address spacenew program loaded into address space
Unix process creationUnix process creation
A new process is created by the fork callA new process is created by the fork call
Child and parent are identical Child and parent are identical – child returns a 0child returns a 0– parent returns nonzeroparent returns nonzero
Both parent and child execute next lineBoth parent and child execute next line
Often the child executes an execOften the child executes an exec– creates a brand new process in its spacecreates a brand new process in its space
Parent can execute a waitParent can execute a wait
Example: Process Creation in Example: Process Creation in UnixUnix
int pid;int status = 0;
pid = fork()if (pid != 0) {
/* parent */…..pid = wait(&status);
} else {
/* child */…..exit(status);
}
int pid;int status = 0;
pid = fork()if (pid != 0) {
/* parent */…..pid = wait(&status);
} else {
/* child */…..exit(status);
}
Parent uses wait to sleep until the child exits; wait returns child pid and status.
Wait variants allow wait on a specific child, or notification of stops and other signals.
Wait has the effect of cleaning up the process out of the system – removes it from the zombie state.
Parent uses wait to sleep until the child exits; wait returns child pid and status.
Wait variants allow wait on a specific child, or notification of stops and other signals.
Wait has the effect of cleaning up the process out of the system – removes it from the zombie state.
The fork syscall returns twice: it returns a zero to the child and the child process ID (pid) to the parent.
The fork syscall returns twice: it returns a zero to the child and the child process ID (pid) to the parent.
Unix Unix Fork/Exec/Exit/WaitFork/Exec/Exit/Wait ExampleExample
fork parent fork child
wait exit
int pid = fork();Create a new process that is a clone of its parent.
exec*(“program” [, argvp, envp]);Overlay the calling process virtual memory with a new program, and transfer control to it.
exit(status);Exit with status, destroying the process.
int pid = wait*(&status);Wait for exit (or other status change) of a child.
exec
initialize child context
child1 = fork();if (child1 == 0){
/* I am the child process */child1P(one2two, two2one);
}else{
child2 = fork();if (child2 == 0){
/* I am the child process */child2P(one2two, two2one);
}else{
/* I am the parent *//* Wait for child one */waitpid(child1, status1, options); /* Wait for child two */ waitpid(child2, status2, options); printf("The children are finally finished\n");fflush(stdout);
}}
#include <iostream>#include <string>#include <sys/types.h>#include <unistd.h>using namespace std;
int globalVariable = 2;
main(){
string sIdentifier; int iStackVariable = 20;
pid_t pID = fork();
if (pID == 0) // child {
// Code only executed by child process sIdentifier = "Child Process: "; globalVariable++; iStackVariable++;
} else if (pID < 0) // failed to fork {
cerr << "Failed to fork" << endl; exit(1); // Throw exception
} else // parent {
// Code only executed by parent process sIdentifier = "Parent Process:";
}
// Code executed by both parent and child. cout << sIdentifier; cout << " Global variable: " << globalVariable; cout << " Stack variable: " << iStackVariable << endl;
}
Potential PitfallsPotential Pitfalls
Unintended File SharingUnintended File Sharing– Child process is a copy of parentChild process is a copy of parent– Includes files and other OS structuresIncludes files and other OS structures– Intermixed outputIntermixed output– File close on terminationFile close on termination
Race conditionsRace conditions– Each process is scheduled independentlyEach process is scheduled independently
ExecExec
Fork creates a copy of the parentFork creates a copy of the parent
Use exec() to launch another programUse exec() to launch another program– Initiate a program from within a programInitiate a program from within a program– Transforms the calling process into a new Transforms the calling process into a new
processprocess
Family of functionsFamily of functions– execl, execlp, execle, execv, execvp, execvPexecl, execlp, execle, execv, execvp, execvP– Front ends to the function execve Front ends to the function execve
execveexecve
Executes a process in an environment Executes a process in an environment which it assignswhich it assignsProcess arguments and the environment Process arguments and the environment are passed as null terminated arrays of are passed as null terminated arrays of character pointerscharacter pointers– char *env[] = {“USER=qos”,”PATH=/usr/bin:/bin”, (char *)0 };char *env[] = {“USER=qos”,”PATH=/usr/bin:/bin”, (char *)0 };– char *args[] = {“/bin/someprog”, “-r”, “-verbose”, (char *)0 };char *args[] = {“/bin/someprog”, “-r”, “-verbose”, (char *)0 };
– execve(args[0], args, env);execve(args[0], args, env);
execl and execlpexecl and execlp
Creates a new program in the same Creates a new program in the same environment environment
execl requires a fully qualified pathexecl requires a fully qualified path
execlp will use the environment variable execlp will use the environment variable PATH to search for the filePATH to search for the file
Takes a null terminated list of arguments Takes a null terminated list of arguments
execv and execvpexecv and execvp
Same as execl Same as execl – Arguments are passed as a null terminated Arguments are passed as a null terminated
array of character pointersarray of character pointers
#include <sys/types.h>
#include <unistd.h>
int pid;int status = 0;
pid = fork();if (pid != 0) {
/* parent */…..pid = wait(&status);
} else {
/* child */// Allocate and fill in argv and envp
//execve(const char *filename, char *const argv [], char *const envp[]);execve(argv[0], argv, envp);
// exec shouldn’t return return(ERROR);
}
Setting up the environmentSetting up the environment
// Set up the environment variable arrayenv = (char **)malloc((headerLines.size() + 1) * sizeof(char *));for (i = 0; i < headerLines.size(); i++){
env[i] = (char *)malloc(headerLength * sizeof(char));strcpy(env[i], headerLines[i]);if (strstr(env[i], "CONTENT_LENGTH")){
sscanf(env[i], "CONTENT_LENGTH=%d", &contentLength);//fprintf(stderr, "Scanned CONTENT_LENGTH is %d\n", contentLength);
}//fprintf(stderr, "Header --> [%s]\n", env[i]);
}env[i] = NULL;