Process management 1

Transcription

1 Process management 1

2 The kernel The core set of service that the OS provides 2

3 User Mode & kernel mode User mode apps delegate to system APIs in order to access hardware User space Kernel space User Utilities Standard library o.s compile / shell 3

4 What is a Shell? A user app running in user space. An interface to the kernel. Shell kernel. Shell ó OS. Shell commands delegate to system calls. 4

5 Bash shell Bash - the classical Unix shell. Probably the most widly shell in use. There are many other shells for Linux 5

6 System Calls Definition: Internal kernel routines that are exposed to user applications directly, through the C library, or via any other user mode interfaces are called system calls. System call = the programmatic way to requests a service from the kernel. (!) System calls are implemented in the kernel and are not part of the C library. 6

7 System Calls Typically system call may be used to perform: process control operations file management device manipulation information maintenance communication 7

8 Linux process management 8

9 The process ID Each process is represented by a unique identifier, the process ID (pid). It guaranteed to be unique at any single point in time. The process ID is represented by the pid_t type. 9

10 process ID Allocation By default, the kernel imposes a maximum process ID value of The kernel allocates process IDs to processes in a strictly linear fashion. The kernel does not reuse process ID values until it wraps around from the top. That is, earlier values will not be reused until the values will allocate. 10

11 The type pid_t Used for process IDs (and process group IDs). 11

12 System() execute shell command. System( ) # include <stdlib.h> int system (const char *string); The system function runs the command passed to it as a string and waits for it to complete. Example: #include <stdio.h> #include <string.h> int main (){ char command [50]; strcpy(command, ls l ); system(command); return(0); 12

13 The exec family The exec family are system calls (and not C library function), that executing a new program. #include <unistd.h> int execl(const char *path, const char *arg,...); int execlp(const char *file, const char *arg,...); int execle(const char *path, const char *arg,..., char * const envp[]); int execv(const char *path, char *const argv[]); int execvp(const char *file, char *const argv[]); int execvpe(const char *file, char *const argv[], char *const envp[]); 13

14 execvp() - Definition replaces the program in the current process with a new program. return value: on error, returns -1. on success, there is no process to return values to. int execvp(const char* filename,char* const argv[]) 14

15 main.c execvp() -Example #include <stdio.h> int main(){ char** args = {0; exevp("/home/ubuntu/workspace/ kid", args); printf("no one will print it \n"); return 0; kid.c $ gcc main.c -o main $ gcc kid.c -o kid $./main hello! I am the same process (: #include <stdio.h> int main(){ printf("hello! I am the same process (:\n"); return 0; 15

16 The fork() A System call that create a process by duplicating the invoking process 16

17 The fork() #include <sys/types.h> #include <unistd.h> Pid_t fork (void); When a process invokes fork() it is duplicated and a child process is created. fork() is a system call and not a C library function. Return value: Upon success: 0 to the childand the PID ot the child to the parent. Upon failure: no process is created, -1 returned to the parent. 17

18 fork() Example 1 pid_t new_pid; new_pid = fork(); switch(new_pid){ case -1: /*Error*/ break; case 0: /*We are child*/ break; default: /*We are parent*/ break; 18

19 fork() Example 2 #include <sys/types.h> #include <unistd.h> #include <stdio.h> #include <stdlib.h> int main() { pid_t pid; char *message; int n; printf( fork program starting\n ); pid = fork(); switch(pid) (Code cont.) { case -1: perror( fork failed ); exit(1); case 0: message = This is the child ; n = 5; break; default: message = This is the parent ; n = 3; break; for(; n > 0; n--) { puts(message); sleep(1); exit(0); 19

20 fork() introduces non-determinism example: pid_t x = fork(); if(x){ printf("1"); else{ printf("2"); two possible outputs: Note: In this code we have no control over the scheduling. 20

21 An example: int i = 1; printf("my process pid is %d\n",getpid()); fork_id=fork(); if (fork_id==0){ i= 2; printf( child pid %d, i=%d \n",getpid(),i); else printf( parent pid %d, i=%d \n",getpid(),i); return 0; fork() Example 3 Program flow: PID = 8864 i = 1 fork () Possible Output: my process pid is 8864 child pid 8865, i=2 parent pid 8864, i=1 fork_id = 8865 i=1 PID = 8864 fork_id=0 i = 2 PID =

22 int main(void) { pid_t parentpid; pid_t childpid; getpid() vs. getppid() childpid = fork(); if (childpid >= 0) { if (childpid == 0) getppid()); else // fork was successful // child process printf("\n Child Process :: childpid %d parentpid %d\n", getpid(), // parent process printf("\n Parent Process :: childpid %d parentpid %d\n", getpid(), getppid()); else { // fork failed printf("\n Fork failed, quitting!!!!\n"); return 1; return 0; Possible output: Parent Process :: childpid 4672 parentpid 2251 Child Process :: childpid 4673 parentpid

23 What is a possible output? (1) int main(void) { fork(); printf( fork 1.\n ); fork(); printf( fork 2.\n ); return 0; Possible output: fork 1. fork 2. fork 2. fork 1. fork 2. fork 2. Possible output: fork 1. fork 2. fork 1. fork 2. fork 2. fork 2. Possible output: fork 1. fork 1. fork 2. fork 2. fork 2. fork 2. a b c 23

24 What is a possible output? (2) What will be printed in each code? a b 24

25 What is a possible output? (3) 25

26 What is a possible output? (4) How many lines of Hello will be printed in the following example: int main(void) { int i; for (i=0; i<10; i++){ fork(); printf( Hello \n ); return 0; int main(void) { int i; for (i=0; i<10; i++){ printf( Hello \n ); fork(); return 0; int main(void) { int i; for (i=0; i<10; i++) fork(); printf( Hello \n ); return 0; a b c 26

27 Tree of processes (1) Draw the tree of process that will result: int x; fork(); x = fork(); if(x!= 0) fork(); printf( pid= %d,getpid()); Solution: What are possible outputs of the code?

28 Tree of processes(2) Write code that creates this tree:

29 Solution: Tree of processes(2) int main(void) { pid_t id= = fork(); if (id == 0) { // if this is process #2 fork(); return 0;

30 Tree of processes(3) Write code that creates this tree:

31 Tree of processes(3) Solution: 1 int main(void) { pid_t first_id= = fork(); fork(); fork(); if (first_id == 0) { fork(); fork(); fork(); Naive solution, Does not work! return 0; 31

32 Tree of processes(3) Solution: int main(void) { first_id = fork(); // create #2 if (first_id!= 0) //if you re the father { second_id = fork(); // create #3 if (second_id!= 0) //if you re the father fork(); // create #4 if (first_id == 0) //if you re #2 (a child) { forth_id = fork(); // create # if (forth_id!= 0) { //if you re the father (#2) fifth_id = fork(); // create #6 if (fifth_id!= 0) //if you re the father (#2) fork(); // create #7 return 0; 32

33 fork() and Binary Tree fork() && fork() 33

34 fork() and Binary Tree fork() && fork() lazy evaluation - if && left side evaluated to be false, right side will not executed. if left side evaluated to be true, right side will not executed. sometimes, computers are almost as lazy as humans :P 34

35 fork() and Binary Tree fork() && fork() first fork: return true for the parent return false for the child second fork: Lazy evaluation - the child has false, so it won t execute the right hand first fork 1 second fork

36 fork() and Binary Tree fork() fork() 36

37 fork() and Binary Tree fork() fork() Lazy evaluation - the parent recieved true, so it won t execute the right hand first fork 1 second fork

38 fork() and Binary Tree fork() && fork() fork() 38

39 fork() and Binary Tree fork() && fork() fork() fork 1 true false fork 3 fork 2 true && false == false true && true == true fork 3 39

40 fork() and Binary Tree REAL TEST QUESTION! fork(); fork() && fork() fork(); fork(); printf( I <3 the fork command!\n ); how many lines will be printed? 40

41 fork() and Binary Tree fork(); fork() && fork() fork(); fork(); 41

42 fork() & for loops (1) int i; for( i=0; i<3 && fork() ; i++ ); printf("line\n"); 42

43 fork() & for loops (2) int i; for( i=0; i<3 fork() ; i++ ){ printf("line %d\n", i); 43

44 fork-exec combination main.c #include <stdio.h> int main(){ char** args = {0; if(!fork()) execvp("/home/ubuntu/workspace/ kid", args); else printf("i am the parent!\n"); printf("only parent, will print it \n"); return 0; kid.c #include <stdio.h> int main(){ printf("hello! I am just a child (:\n"); return 0; $ gcc main.c -o main $ gcc kid.c -o kid $./main I am the parent! only parent, will print it hello! I am just a child (: 44

45 wait() #include <sys/types.h> #include <sys/wait.h> pid_t wait(int *stat_loc); The wait() system call causes a parent process to pause until one of its child processes is stopped. Returns : PID of the child process(normally be a child process that has terminated). 45

46 wait() You can interpret the status information using macros defined in sys/ wait.h, shown in the following table. Macro (WIFEXITED(stat_val (WEXITSTATUS(stat_val (WIFSIGNALED(stat_val (WTERMSIG(stat_val (WIFSTOPPED(stat_val (WSTOPSIG(stat_val Definition Nonzero if the child is terminated normally If WIFEXITED is nonzero, this return child exit code Nonzero if the child is terminated on an uncaught signal If WIFSIGNALED is nonzero, this returns a signal number.nonzero if the child has stopped If WIFSTOPPED is nonzero, this returns a signal number 46

47 wait()- Example #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) (Code cont.) { 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); (Code cont. next slide) 47

48 wait()- Example This section of the program waits for the child process to finish. (Code cont.) if (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); 48

49 Zombie Process When a child process terminates, an association with its parent survives until the parent in turn either terminates normally or calls wait(). 49

50 Zombie Process- Example #include <sys/types.h> #include <unistd.h> #include <stdio.h> #include <stdlib.h> int main() { pid_t pid; char *message; int n; printf( fork program starting\n ); pid = fork(); switch(pid) (Code cont.) { 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; for(; n > 0; n--) { puts(message); sleep(1); exit(0); 50

51 exit() #include <stdlib.h> void exit (int status); A call to exit() performs some basic shutdown steps, then instructs the kernel to terminate the process. This function has no way of returning an error, in fact, it never returns at all. The status parameter is used to denote the processes exit status. 51

52 waitpid() #include <sys/types.h> #include <sys/wait.h> pid_t waitpid(pid_t pid, int *status, int options); The waitpid() call is more powerful of wait(). The pid parameter specifies exactly which processes to wait for. Its values fall into four camps: I. <-1. II. -1. III. 0. IV. >0. 52

53 Daemon process A daemon is a process that runs in the background, not connecting to any controlling terminal. Daemons are normally started at boot time, are run as root or some other special user,and handle system-level tasks. As a convention, the name of a daemon often ends in d, but this is not required or even universal. A daemon has two general requirements: it must run as a child of init and it must not be connected to a terminal. 53

54 Session and Process Groups Each process is a member of a process group, which is a collection of one or more processes generally associated with each other for the purposes of job control. The primary attribute of a process group is that signals may be sent to all processes in the group. Each process group is identified by a process group ID(pgid) and has a process group leader. 54

55 You have to learn the following functions on your own vfork() getsid() setsid() getuid() getgid() 55