1. Operating Systems 371-1-1631 Summer Semester 2011 Practical Session 2, Signals 1

2. Signals Signals are a way of sending simple messages to processes Used to notify a process of important events Signals can be sent by other processes or by the kernel. 2

3. Reacting to Signals Signals are processed after a process returns from an interrupt (e.g. returning from a system call). On finishing a system call, before returning to application code, signals are dealt with (if there are any). On returning from a timer interrupt (interrupt sent by the hardware clock). 3

4. Signals-Asynchronous mode Programs are synchronous: executed line by line Signals can be synchronous or asynchronous – Synchronous: Dividing by zero – Asynchronous: receiving a termination signal from a different process.  It is not safe to call all functions, such as printf, from within a signal handler. A useful technique is to use a signal handler to set a flag and then check that flag from the main program and print a message if required 4

5. Signals-Examples SIGSEGV - Segmentation Faults SIGFPE- Floating Point Error SIGTSTP – Causes process to suspend itself SIGCONT – Causes suspended process to resume execution. Which are synchronous? 5

6. Signal Table Each process has a signal table Each signal has an entry in the table Each signal has a column whether to ignore the signal or not (SIG_IGN). Each signal has a column of what to do on receiving the signal (if not ignoring it). 6 ActionSIG_IGNSig_Num 1 2

7. Blocking and Ignoring Blocking: The signal is received but not dealt with. It is kept in the signal table until the block is removed. Ignoring: The signal is received and discarded without any action being taken. 7

8. Signal Handlers Each signal has a default action – SIGTERM – Terminate process. – SIGFPE (floating point exception) –dump core and exit. The action can be changed by the process using the signal * /sigaction system call. *It is highly recommended you refrain from using the signal call in your code. Nonetheless it is important to know it since it appears in many older programs. 8

9. Signal Handlers Five default options: – Exit: forces the process to exit. – Core: forces the process to exit and create a core file. – Stop: stops the process. – Ignore: ignores the signal; no action taken. – Continue: Resume execution of stopped process. 9

10. Signal Handlers Two signals cannot be ignored or have their associated action changed: – SIGKILL – SIGSTOP (not the same as SIGTSTP used for suspension) When calling execvp() all signals are set to their default action. The bit that specifies whether to ignore the signal or not is preserved. Why? 10

11. Scheme of signal processing 11 User Mode Kernel Mode Normal program flow do_signal() handle_signal() setup_frame() Signal handler Return code on the stack system_call() sys_sigreturn() restore_sigcontext()

12. Sending Signals Signals can be sent: – From the keyboard – From the command line via the shell – Using system calls 12

13. Keyboard Signals Ctrl–C – Sends a SIGINT signal. By default this causes the process to terminate Ctrl-\ - Sends a SIGABRT signal. Causes the process to terminate. Ctrl-Z – Sends a SIGTSTP signal. By default this causes the process to suspend execution. 13

14. Command line Signals kill kill - – Sends the specified signal to the specified PID. A Negative PID specifies a whole process group. – Kill -9 is SIGKILL which kills a process. killall killall can be used to send multiple signals to processes running specific commands fg fg - Resumes the execution of a suspended process (sends a SIGCONT). 14

15. System call Signals Kill(pid_t pid,int sig) #include /* standard unix functions, like getpid() */ #include /* various type definitions, like pid_t */ #include /* signal name macros, and the kill() prototype */ /* first, find my own process ID */ pid_t my_pid = getpid(); /* now that i got my PID, send myself the STOP signal. */ kill(my_pid, SIGSTOP); 15

16. Signal Priority Each pending signal is marked by a bit in a 32 bit word. Therefore there can only be one signal pending of each type. A process can’t know which signal came first. The process executes the signals starting at the lowest numbered signal. POSIX 2001 also defines a set of Real Time Signals which behave differently: Multiple instances may be queued Provide richer information Delivered in guaranteed order Use SIGRTMIN+n up to SIGRTMAX to refer to these signals (32 in Linux) 16

17. Manipulation of Signals sighandler_t signal(int signum, sighandler_t handler) Installs a new signal handler for the signal with number signum. The signal handler is set to sighandler which may be a user specified function, or either SIG_IGN or SIG_DFL. If the corresponding handler is set to SIG_IGN, then the signal is ignored. If the handler is set to SIG_DFL, then the default action associated with the signal occurs. 17

18. sigaction Manipulation of Signals sigaction int sigaction(int signum, const struct sigaction *act, struct sigaction *oldact); A more sophisticated (and safe) way of manipulating signals. Doesn’t restore signal handler to default after calling signal. signum is the number of the signal act is a pointer to a struct containing much information including the new signal handler oldact if not null will receive the old signal handler. For more details and another example see: http://www.opengroup.org/onlinepubs/009695399/functions/sigaction.html 18 Example

19. Example 1 #include /* standard I/O functions */ #include /* standard unix functions, like getpid() */ #include /* various type definitions, like pid_t*/ #include /* signal name macros, and the signal() prototype */ /* first, here is the signal handler */ void catch_int(int sig_num){ /* re-set the signal handler again to catch_int, for next time */ signal(SIGINT, catch_int); /* and print the message */ printf("Don't do that\n"); } int main(){ /* set the INT (Ctrl-C) signal handler to 'catch_int' */ signal(SIGINT, catch_int); /* now, lets get into an infinite loop of doing nothing. */ while (true) { pause(); } Causes the process to halt execution until it receives a signal. 19

20. Example 2 int cpid[5]; //holds the pids of the children int j; //pointer to cpid int sigCatcher(){ // function to activate when a signal is caught signal(SIGINT,sigCatcher); //reset the signal catcher printf("PID %d caught one\n",getpid()); if(j>-1) kill(cpid[j],SIGINT); //send signal to next child in cpid } 20

21. Example 2-Continued int main(){ int i; int zombie; int status; int pid; signal(SIGINT,sigCatcher); // set the signal catcher to sigCatcher 21

22. Example 2-Continued for(i=0;i<5;i++){ if((pid=fork())== 0){ // create new child printf("PID %d ready\n",getpid()); j=i-1; pause(); // wait for signal exit(0); // end process (become a zombie) } else // Only father updates the cpid array. cpid[i]=pid; } sleep(2); // allow children time to enter pause kill(cpid[4],SIGINT); // send signal to first child sleep(2); // wait for children to become zombies for(i=0;i<5;i++){ zombie = wait(&status); // collect zombies printf("%d is dead\n",zombie); } exit(0); } 22

23. Output PID 22899 ready PID 22900 ready PID 22901 ready PID 22902 ready PID 22903 ready PID 22903 caught one PID 22902 caught one PID 22901 caught one PID 22900 caught one PID 22899 caught one 22903 is dead 22901 is dead 22902 is dead 22899 is dead 22900 is dead 23

24. Security Issues Not all processes can send signals to all processes. Only the kernel and super user can send signals to all processes. Normal processes can only send signals to processes owned by the same user. 24

25. Process ID ID Each process has an ID (pid). group ID Each process has a group ID (pgid). group leader One process in the group is the group leader and all member’s group ID is equal to the leaders pid. A signal can be sent to a single process or to a process group. 25

26. Process Group ID process group A process group is a collection of related processes process-group identifier (pgid) All processes in a process group are assigned the same process-group identifier (pgid). The process-group identifier is the same as the PID of the process group's initial member. Used by the shell to control different tasks executed by it. 26

27. Process ID int getpid() – return the process’s PID. int getpgrp() – return the process’s PGID. setpgrp() – set this process’s PGID to be equal to his PID. setpgrp(int pid1, int pid2) – set process’s pid1 PGID to be equal to pid2’s PID. 27

28. Question from midterm 2004 תלמיד קיבל משימה לכתוב תכנית שמטרתה להריץ תכנית נתונה ( ברשותו רק הקובץ הבינארי ) prompt ע " י שימוש ב -fork ו -execvp. בנוסף נדרש התלמיד למנוע מן המשתמש " להרוג " את התכנית ע " י הקשת ctrl-c ( שים לב כי התכנית prompt אינה מסתיימת לעולם ). מצורף פתרון שהוצע ע " י תלמיד (my_prog.c) וכן התכנית prompt. א-תאר במדויק את פלט התכנית כאשר הקלט הנו : Good luck in the ^c midterm exam. ב-האם הפתרון המוצע עונה על הגדרת התרגיל ? ג-אם תשובתך ל - ב ' היא לא, כיצד היית משנה את התכנית my_prog.c ( ניתן להוסיף / לשנות שורה או שתיים בקוד לכל היותר )? 28

29. Question from midterm 2004 #include… void cntl_c_handler(int dummy){ signal(SIGINT, cntl_c_handler); } main (int argc,char **argv){ int waited; int stat; argv[0]=“prompt”; signal (SIGINT, cntl_c_handler); if (fork()==0){ //son execvp(“prompt”,argv[0]); } else{ //father waited=wait(&stat); printf(“My son (%d) has terminated \n”,waited); } my_prog.c 29

30. Question from midterm 2004 main(int argc, char** argv){ char buf[20]; while(1){ printf(“Type something: “); gets(buf); printf(“\nYou typed: %s\n”,buf); } prompt.c (זכרי כי קוד זה אינו ניתן לשינוי ע"י התלמיד) 30

31. Sample execution of code א-תאר במדויק את פלט התכנית כאשר הקלט הנו : Good luck in the ^c midterm exam. Type something: Good luck You typed: Good luck Type something: in the ^c My son 139 has terminated 31

32. Code is incorrect האם הפתרון המוצע עונה על הגדרת התרגיל ? Execvp doesn’t save signal handles Therefore prompt.c doesn’t ignore ^c This means that the process can be terminated. 32

33. Code correction אם תשובתך ל - ב ' היא לא, כיצד היית משנה את התכנית my_prog.c ( ניתן להוסיף / לשנות שורה או שתיים בקוד לכל היותר )? 1.Change signal (SIGINT, cntl_c_handler); in my_prog.c With signal (SIGINT, SIG_IGN); 2.Add if (fork()==0){ signal (SIGINT, SIG_IGN); execvp(“prompt”,argv[0]); 33

34. More Information http://www.linuxjournal.com/article/3985 http://www.linux-security.cn/ebooks/ulk3-html/0596005652/understandlk-CHP-11.html http://cs-pub.bu.edu/fac/richwest/cs591_w1/notes/wk3_pt2.PDF http://books.google.com/books?id=9yIEji1UheIC&pg=PA156&lpg=PA156&dq=linux+ret_from _intr()&source=bl&ots=JCjEvqiVM- &sig=z8CtaNgkFpa1MPQaCWjJuU5tq4g&hl=en&ei=zf3zSZsvjJOwBs- UxYkB&sa=X&oi=book_result&ct=result&resnum=22#PPA159,M1 man signal, sigaction… man kill… Process groups: http://www.win.tue.nl/~aeb/linux/lk/lk-10.html http://www.informit.com/articles/article.aspx?p=366888&seqNum=8 34