Recitation: Signaling 15213-S04, Recitation, Section A

1. Recitation: Signaling15213-S04, Recitation, Section A Debug Multiple Processes using GDB Dup2 Signaling L5 Due: This Wednesday

2. Debug Multiple Proc’s Using GDB • attach pid • pid: the process id of a running process • set follow_fork_mode <parent | child> • only work in HP-UX and GNU/Linux (kernel >= 2.5.60) • Fish machines: Linux with kernel 2.2.20

3. $ gdb tsh <pid> Attach to a Running Process • Run the parent code and create the process tsh • Directly in the shell • In GDB • Get the pid • $ ps [-e | axu] | grep tsh • Run gdb • $ gdb tsh • Attach to the process • (gdb) attach <pid>

4. Demo! Really that Easy? • The process must be started outside GDB • If you want to debug both the parent process and the child process, you need start another gdb (in another xterm) • You have to type in the gdb & attach commands fast enough --- before the process actually finishes • You have to modify the source code to let it wait • Two methods • sleep(10); • int gdbf = 0; while (!gdbf); • For Lab 5, it is more troublesome • sdriver  runtrace  tsh/tshref  mycat

5. $ gdb tsh <pid> Attach to a Running Process • Run runtrace and create the process tsh • Directly in the shell • In GDB • Get the pid • $ ps [-e | axu] | grep tsh • Run gdb • $ gdb tsh • Attach to the process • (gdb) attach <pid>

6. Dup2() • Basic concepts on file handler • File descriptor, file table, v-node table • File sharing --- dup2() • Practice problems

7. How the Unix Kernel Represents Open Files • Two descriptors referencing two distinct open disk files. Descriptor 1 (stdout) points to terminal, and descriptor 4 points to open disk file. Open file table [shared by all processes] v-node table [shared by all processes] Descriptor table [one table per process] File A (terminal) stdin File access fd 0 stdout Info in stat struct fd 1 File size File pos stderr fd 2 File type refcnt=1 fd 3 ... ... fd 4 File B (disk) File access File size File pos File type refcnt=1 ... ...

8. How Processes Share Files • A child process inherits its parent’s open files. Here is the situation immediately after a fork Open file table (shared by all processes) v-node table (shared by all processes) Descriptor tables Parent's table File A File access fd 0 fd 1 File size File pos fd 2 File type refcnt=2 fd 3 ... ... fd 4 Child's table File B File access fd 0 File size fd 1 File pos fd 2 File type refcnt=2 fd 3 ... ... fd 4

9. File Sharing • Two distinct descriptors sharing the same disk file through two distinct open file table entries • E.g., Calling open twice with the same filename argument Open file table (shared by all processes) v-node table (shared by all processes) Descriptor table (one table per process) File A File access fd 0 fd 1 File size File pos fd 2 File type refcnt=1 fd 3 ... ... fd 4 File B File pos refcnt=1 ...

10. I/O Redirection • dup2(oldfd, newfd) • Copies (per-process) descriptor table entry oldfd to entry newfd Descriptor table before dup2(4,1) Descriptor table after dup2(4,1) fd 0 fd 0 fd 1 a fd 1 b fd 2 fd 2 fd 3 fd 3 fd 4 b fd 4 b

11. I/O Redirection Example • Before calling dup2(4,1), stdout (descriptor 1) points to a terminal and descriptor 4 points to an open disk file. Open file table (shared by all processes) v-node table (shared by all processes) Descriptor table (one table per process) File A stdin File access fd 0 stdout fd 1 File size File pos stderr fd 2 File type refcnt=1 fd 3 ... ... fd 4 File B File access File size File pos File type refcnt=1 ... ...

12. I/O Redirection Example (cont) • After calling dup2(4,1), stdout is now redirected to the disk file pointed at by descriptor 4. Open file table (shared by all processes) v-node table (shared by all processes) Descriptor table (one table per process) File A File access fd 0 fd 1 File size File pos fd 2 File type refcnt=0 fd 3 ... ... fd 4 File B File access File size File pos File type refcnt=2 ... ...

13. File Sharing • Descriptor table • Each process has its own • Child inherits from parents • File Table • set of all open files • Shared by all processes • Reference count of number of file descriptors pointing to each entry • File position • V-node table • Contains information in the stat structure • Shared by all processes

14. Problem 11.2 • Suppose that foobar.txt consists of the 6 ASCII characters "foobar". Then what is the output of the following program? #include "csapp.h" int main() { int fd1, fd2; char c; fd1 = Open("foobar.txt", O_RDONLY, 0); fd2 = Open("foobar.txt", O_RDONLY, 0); Read(fd1, &c, 1); Read(fd2, &c, 1); printf("c = %c\n", c); exit(0); }

15. Answer to 11.2 • The descriptors fd1 and fd2 each have their own open file table entry, so each descriptor has its own file position for foobar.txt. Thus, the read from fd2 reads the first byte of foobar.txt, and the output isc = fand notc = oas you might have thought initially.

16. Problem 11.3 • As before, suppose foobar.txt consists of 6 ASCII characters "foobar". Then what is the output of the following program? #include "csapp.h" int main() { int fd; char c; fd = Open("foobar.txt", O_RDONLY, 0); if(Fork() == 0) {Read(fd, &c, 1); exit(0);} Wait(NULL); Read(fd, &c, 1); printf("c = %c\n", c); exit(0); }

17. Answer to 11.3 • Child inherit’s the parent’s descriptor table. So child and parent share an open file table entry (refcount = 2). Hence they share a file position. • c = o

18. Problem 11.4 • How would you use dup2 to redirect standard input to descriptor 5? • int dup2(int oldfd, int newfd); • copies descriptor table entry oldfd to descriptor table entry newfd

19. Answer to 11.4 • dup2(5,0); • or • dup2(5,STDIN_FILENO);

20. Problem 11.5 • Assuming that foobar.txt consists of 6 ASCII characters “foobar”. Then what is the output of the following program? #include "csapp.h" int main() { int fd1, fd2; char c; fd1 = Open("foobar.txt", O_RDONLY, 0); fd2 = Open("foobar.txt", O_RDONLY, 0); Read(fd2, &c, 1); Dup2(fd2, fd1); Read(fd1, &c, 1); printf("c = %c\n", c); exit(0); }

21. Answer to 11.5 • We are redirecting fd1 to fd2. (fd1 now points to the same open file table entry as fd2). So the second Read uses the file position offset of fd2. • c = o

22. Signaling • Busy wait • waitpid() • Racing hazard

23. Busy Wait • if(fork() != 0) { /* parent */ • addjob(…); • while(fg process still alive){ • /* do nothing */ • } • }

24. If signal handled before call to pause, then pause will not return when foreground process sends SIGCHLD Pause • if(fork() != 0) { /* parent */ • addjob(…); • while(fg process still alive){ • pause(); • } • }

25. Sleep • if(fork() != 0) { /* parent */ • addjob(…); • while(fg process still alive){ • sleep(1); • } • }

26. waitpid () • pid_t waitpid(pid_t pid, int *status, int options) • pid: wait until child process with pid has terminated • -1: wait for any child process • status: tells why child terminated • options: • WNOHANG: return immediately if no children zombied • returns -1 • WUNTRACED: report status of stopped children too

27. Status in Waitpid int status; waitpid(pid, &status, NULL); • Macros to evaluate status: • WIFEXITED(status): child exited normally • WEXITSTATUS(status): return code when child exits • WIFSIGNALED(status): child exited because of a signal not caught • WTERMSIG(status): gives the terminating signal number • WIFSTOPPED(status): child is currently stopped • WSTOPSIG(status): gives the stop signal number

28. Race Hazard • A data structure is shared by two pieces of code that can run concurrently • Different behaviors of program depending upon how the schedule interleaves the execution of code.

29. eval & sigchld_handler Race Hazard • sigchld_handler() { pid = waitpid(…); deletejob(pid); • } • eval() { pid = fork(); if(pid == 0) { /* child */ execve(…); } /* parent */ /* signal handler might run BEFORE addjob() */ addjob(…); • }

30. An OK Schedule Signal Handler Child time Shell fork() addjob() execve() exit() sigchld_handler() deletejobs()

31. Job added to job list after the signal handler tried to delete it! A Problematic Schedule Signal Handler Child time Shell fork() execve() exit() sigchld_handler() deletejobs() addjob()

32. Blocking Signals • sigchld_handler() { pid = waitpid(…); deletejob(pid); • } • eval() { sigprocmask(SIG_BLOCK, …) pid = fork(); if(pid == 0) { /* child */ sigprocmask(SIG_UNBLOCK, …) execve(…); } /* parent */ /* signal handler might run BEFORE addjob() */ addjob(…); sigprocmask(SIG_UNBLOCK, …) • } More details 8.5.6 (page 633)

33. x sigemptyset(&mask); sigaddset(&mask, SIGCHLD); sigaddset(&mask, SIGINT); sigaddset(&mask, SIGTSTP); sigprocmask(SIG_BLOCK, &mask, NULL); Blocking Signals • sigprocmask(SIG_BLOCK, (sigset_t *)SIGCHLD, NULL); • sigprocmask(SIG_BLOCK, (sigset_t *)SIGINT, NULL); • sigprocmask(SIG_BLOCK, (sigset_t *)SIGTSTP, NULL);

34. Blocking Signals • if (sigemptyset(&mask) < 0) • unix_error("sigemptyset error"); • if (sigaddset(&mask, SIGCHLD)) • unix_error("sigaddset error"); • if (sigaddset(&mask, SIGINT)) • unix_error("sigaddset error"); • if (sigaddset(&mask, SIGTSTP)) • unix_error("sigaddset error"); • if (sigprocmask(SIG_BLOCK, &mask, NULL) < 0) • unix_error("sigprocmask error");

35. Summary • Debug Multiple Processes using GDB • Dup2 • Signaling