1. 1 Exceptional Control Flow III

2. 2 Outline Loading and Running Programs Multitasking, shells Suggested reading 8.4

3. 3 execve : Loading and Running Programs Loads and runs in current process –the executable object file filename –with the argument list argv –the environment variable list envp. #include int execve(char *filename, char *argv[], char *envp); does not return if OK, returns -1 on error

4. execve : Loading and Running Programs Does not return (unless error) –cannot find filename Overwrites code, data, and stack –keeps pid, open files and signal context Environment variables: –“name=value” strings –getenv and putenv Null-terminated env var strings unused Null-terminated cmd line arg strings envp[n] == NULL envp[n-1] envp[0] … Linker vars argv[argc] == NULL argv[argc-1] argv[0] … envp argc argv Stack bottom Stack frame for main Stack top environ 4

5. 5 Loading and Running #include char *getenv(const char *name); returns: ptr to name if exists, NULL if no match. int putenv(char *string); returns: 0 on success, nonzero on error. int setenv(const char *name, const char *newvalue, int overwrite); returns: 0 on success, -1 on error. void unsetenv(const char *name); returns: nothing.

6. execve Example if ((pid = Fork()) == 0) { /* Child runs user job */ if (execve(argv[0], argv, environ) < 0) { printf("%s: Command not found.\n", argv[0]); exit(0); } envp[n] = NULL envp[n-1] envp[0] … argv[argc] = NULL argv[argc-1] argv[0] … “ls” “-lt” “/usr/include” “USER=droh” “PRINTER=iron” “PWD=/usr/droh” environ argv 6

7. The World of Multitasking System runs many processes concurrently Process: executing program –State includes memory image + register values + program counter Regularly switches from one process to another –Suspend process when it needs I/O resource or timer event occurs –Resume process when I/O available or given scheduling priority 7

8. The World of Multitasking Appears to user(s) as if all processes executing simultaneously –Even though most systems can only execute one process at a time –Except possibly with lower performance than if running alone Exceptions –Events that require nonstandard control flow –Generated externally (interrupts) or internally (traps and faults) 8

9. Programmer’s Model of Multitasking Basic functions –fork spawns new process Called once, returns twice –exit terminates own process Called once, never returns Puts it into “zombie” status –wait and waitpid wait for and reap terminated children –execve runs new program in existing process Called once, (normally) never returns 9

10. Programmer’s Model of Multitasking Programming challenge –Understanding the nonstandard semantics of the functions –Avoiding improper use of system resources E.g. “Fork bombs” can disable a system 10

11. Unix Process Hierarchy Login shell Child Grandchild [0] Daemon e.g. httpd init [1] 11

12. Shell Programs A shell is an application program that runs programs on behalf of the user. –sh Original Unix shell (Stephen Bourne, AT&T Bell Labs, 1977) –csh BSD Unix C shell ( tcsh: enhanced csh at CMU and elsewhere ) –bash “ Bourne-Again” Shell int main() { char cmdline[MAXLINE]; while (1) { /* read */ printf("> "); Fgets(cmdline, MAXLINE, stdin); if (feof(stdin)) exit(0); /* evaluate */ eval(cmdline); } Execution is a sequence of read/evaluate steps 12

13. Simple Shell eval Function void eval(char *cmdline) { char *argv[MAXARGS]; /* argv for execve() */ int bg; /* should the job run in bg or fg? */ pid_t pid; /* process id */ bg = parseline(cmdline, argv); if (!builtin_command(argv)) { if ((pid = Fork()) == 0) { /* child runs user job */ if (execve(argv[0], argv, environ) < 0) { printf("%s: Command not found.\n", argv[0]); exit(0); } if (!bg) { /* parent waits for fg job to terminate */ int status; if (waitpid(pid, &status, 0) < 0) unix_error("waitfg: waitpid error"); } else /* otherwise, don’t wait for bg job */ printf("%d %s", pid, cmdline); } 13

14. What Is a “Background Job”? Users generally run one command at a time –Type command, read output, type another command Some programs run “for a long time” –Example: “delete this file in two hours” A “background” job is a process we don't want to wait for unix> sleep 7200; rm /tmp/junk # shell stuck for 2 hours unix> (sleep 7200 ; rm /tmp/junk) & [1] 907 unix> # ready for next command 14

15. 15 Foreground and Background If the last argument is a “&” character –parseline returns 1 –indicating the program should be executed in the background (the shell returns to the top of the loop and waits for the next command) Otherwise –returns 0 –indicating that the program should be run in the foreground (the shell waits for it to complete)

16. 16 Parsing command line Parse the space separated command-line arguments Builds the argv vector –which will eventually be passed to execve The first argument is assumed to be –either the name of a built-in shell command that is interpreted immediately –or an executable object file that will be loaded and run in the context of a new child process

17. Problem with Simple Shell Example Our example shell correctly waits for and reaps foreground jobs But what about background jobs? –Will become zombies when they terminate –Will never be reaped because shell (typically) will not terminate –Will create a memory leak that could run the kernel out of memory –Modern Unix: once you exceed your process quota, your shell can't run any new commands for you: fork() returns -1 unix> limit maxproc # csh syntax maxproc 202752 unix> ulimit -u # bash syntax 202752 17

18. ECF to the Rescue! Problem –The shell doesn't know when a background job will finish –By nature, it could happen at any time –The shell's regular control flow can't reap exited background processes in a timely fashion –Regular control flow is “wait until running job completes, then reap it” Solution: Exceptional control flow –The kernel will interrupt regular processing to alert us when a background process completes –In Unix, the alert mechanism is called a signal 18

19. 19 Outline Signals –Signal Terminology –Sending Signals Suggested reading 8.5

20. 20 Signals Unix signal –A higher-level software form of exception –That allows processes to interrupt other processes

21. 21 The kill Program Kill program –is located in directory /bin/ –sends an arbitrary signal to another process unix> kill -9 15213 –sends signal 9 (SIGKILL) to process 15213.

22. 22 Signals Type Signal is a message that notifies a process –that an event of some type has occurred in the system. Each type corresponds to some kind of system event –Low-level hardware exceptions are processed by the kernel’s exception handlers would not normally be visible to user processes. Signals provide a mechanism for exposing the occurrence of such exceptions to user processes. –Higher-level software events in the kernel in other user processes

23. 23 Hardware Events SIGFPE signal (number 8) –If a process attempts to divide by zero, then the kernel sends it a SIGFPE signal SIGILL signal (number 4) –If a process executes an illegal instruction, the kernel sends it a SIGILL signal. SIGSEGV signal (number 11) –If a process makes an illegal memory reference, the kernel sends it a SIGSEGV signal.

24. 24 Software Events SIGINT signal (number 2) –While a process is running in the foreground –if you type a ctrl-c –then the kernel sends a SIGINT signal to the process SIGKILL signal (number 9) –A process can forcibly terminate another process –by sending it a SIGKILL signal SIGCHLD signal (number 17) –When a child process terminates or stops, –the kernel sends a SIGCHLD signal to the parent.

25. 25 Signal Terminology Two steps to transfer a signal to a destination process –Sending a signal –Receiving a signal

26. 26 Sending a signal The kernel –sends (delivers) a signal to a destination process by updating some state in the context of the destination process. The signal is delivered for one of two reasons: –The kernel has detected a system event –A process has invoked the kill function to explicitly request the kernel to send a signal to the destination process. A process can send a signal to itself.

27. 27 Receiving a signal A destination process receives a signal –when it is forced by the kernel –to react in some way to the delivery of the signal The process can –Ignore the signal –Terminate –Catch the signal by executing a user-level function called a signal handler

28. 28 Pending Signal Pending signal –A signal that has been sent but not yet received Only one –At any point in time, –there can be at most one pending signal of a particular type Not queued –If a process has a pending signal of type k –then any subsequent signals of type k sent to that process are not queued –they are simply discarded. A pending signal is received at most once.

29. 29 Blocking a Signal A process can selectively block the receipt of certain signals. When a signal is blocked –it can be delivered –but the resulting pending signal will not be received –until the process unblocks the signal

30. 30 Internal Data Structures For each process, the kernel maintains –the set of pending signals in the pending bit vector –the set of blocked signals in the blocked bit vector The kernel sets bit k in pending –whenever a signal of type k is delivered The kernel clears bit k in pending –whenever a signal of type k is received.

31. 31 Process Groups To send signals to processes –Unix systems provide a number of mechanisms –All of them rely on the notion of a process group Every process belongs to exactly one process group –which is identified by a positive integer process group ID. By default, a child process belongs to the same process group as its parent.

32. Process Groups Every process belongs to exactly one process group Fore- ground job Back- ground job #1 Back- ground job #2 Shell Child pid=10 pgid=10 Foreground process group 20 Background process group 32 Background process group 40 pid=20 pgid=20 pid=32 pgid=32 pid=40 pgid=40 pid=21 pgid=20 pid=22 pgid=20 getpgrp() Return process group of current process setpgid() Change process group of a process 32

33. 33 Process Groups The getpgrp function: #include pid_t getpgrp(void); returns: process group ID of calling process The setpgrp function: #include pid_t setpgid(pid_t pid, pid_t pgid); returns: 0 on success, -1 on error

34. 34 setpgid Function Changes the process group of process pid to pgid If pid is zero, the PID of the current process is used If pgid is zero, the PID of the process specified by pid is used for the process group ID

35. 35 setpgid Function setpgid(0, 0) ; –Suppose process 15213 is the calling process, –then this function call creates a new process group whose process group ID is 15213 adds process 15213 to this new group.

36. Sending Signals with /bin/ kill Program /bin/kill program sends arbitrary signal to a process or process group Examples –/bin/kill –9 24818 Send SIGKILL to process 24818 –/bin/kill –9 –24817 Send SIGKILL to every process in process group 24817 linux>./forks 16 Child1: pid=24818 pgrp=24817 Child2: pid=24819 pgrp=24817 linux> ps PID TTY TIME CMD 24788 pts/2 00:00:00 tcsh 24818 pts/2 00:00:02 forks 24819 pts/2 00:00:02 forks 24820 pts/2 00:00:00 ps linux> /bin/kill -9 -24817 linux> ps PID TTY TIME CMD 24788 pts/2 00:00:00 tcsh 24823 pts/2 00:00:00 ps linux> 36

37. 37 Sending Signals from the Keyboard Job –An abstraction used by Unix shells –To represent the processes that are created as a result of evaluating a single command line –Foreground –Background –unix> ls | sort

38. 38 Sending Signals from the Keyboard The shell creates a separate process group for each job –Typically, the process group ID is taken from one of the parent processes in the job

39. 39 Sending Signals from the Keyboard Fore- ground job Back- ground job #1 Back- ground job #2 Shell Child pid=10 pgid=10 Foreground process group 20 Background process group 32 Background process group 40 pid=20 pgid=20 pid=32 pgid=32 pid=40 pgid=40 pid=21 pgid=20 pid=22 pgid=20

40. 40 Sending Signals from the Keyboard Typing ctrl-c at the keyboard –causes a SIGINT signal to be sent to the shell –The shell catches the signal –Then sends a SIGINT to every process in the foreground process group –The result is to terminate the foreground job (default)

41. 41 Sending Signals from the Keyboard Typing crtl-z –sends a SIGTSTP signal to the shell –The shell catches the signal –Sends a SIGTSTP signal to every process in the foreground process group –The result is to stop (suspend) the foreground job (default)

42. Example of ctrl-c and ctrl-z bluefish>./forks 17 Child: pid=28108 pgrp=28107 Parent: pid=28107 pgrp=28107 Suspended bluefish> ps w PID TTY STAT TIME COMMAND 27699 pts/8 Ss 0:00 -tcsh 28107 pts/8 T 0:01./forks 17 28108 pts/8 T 0:01./forks 17 28109 pts/8 R+ 0:00 ps w bluefish> fg./forks 17 bluefish> ps w PID TTY STAT TIME COMMAND 27699 pts/8 Ss 0:00 -tcsh 28110 pts/8 R+ 0:00 ps w STAT (process state) Legend: First letter: S: sleeping T: stopped R: running Second letter: s: session leader +: foreground proc group See “man ps” for more details 42

43. 43 Sending Signals with kill Function If pid is greater than zero, –then the kill function sends signal number sig to process pid If pid is less than zero –then kill sends signal sig to every process in process group abs(pid) #include int kill(pid_t pid, int sig); returns: 0 if OK, -1 on error

44. Sending Signals with kill Function void fork12() { pid_t pid[N]; int i, child_status; for (i = 0; i < N; i++) if ((pid[i] = fork()) == 0) while(1); /* Child infinite loop */ /* Parent terminates the child processes */ for (i = 0; i < N; i++) { printf("Killing process %d\n", pid[i]); kill(pid[i], SIGINT); } /* Parent reaps terminated children */ for (i = 0; i < N; i++) { pid_t wpid = wait(&child_status); if (WIFEXITED(child_status)) printf("Child %d terminated with exit status %d\n", wpid, WEXITSTATUS(child_status)); else printf("Child %d terminated abnormally\n", wpid); } 44

45. 45 Next Signals –Receiving Signals –Signal Handling –Blocking Signals –Suggested reading 8.5 Nonlocal Jumps –Suggested reading 8.6