1 / 34

Operating Systems 371-1-1631 Winter Semester 2011

Operating Systems 371-1-1631 Winter Semester 2011. Practical Session 2, Signals. 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 . Reacting to Signals.

loyal
Télécharger la présentation

Operating Systems 371-1-1631 Winter Semester 2011

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript

  1. Operating Systems371-1-1631Winter Semester 2011 Practical Session 2, Signals

  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 processesor by the kernel.

  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).

  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

  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?

  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).

  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.

  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*/sigactionsystem 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.

  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 stoppedprocess.

  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?

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

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

  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.

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

  15. System call Signals Kill(pid_t pid,int sig) #include <unistd.h> /* standard unix functions, like getpid() */ #include <sys/types.h> /* various type definitions, like pid_t */ #include <signal.h> /* 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);

  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)

  17. Manipulation of Signals sighandler_t signal(intsignum, sighandler_thandler) • 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.

  18. Manipulation of Signalssigaction intsigaction(intsignum, const structsigaction *act,structsigaction *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 Example

  19. Example 1 #include <stdio.h> /* standard I/O functions */ #include <unistd.h> /* standard unix functions, like getpid() */ #include <sys/types.h> /* various type definitions, like pid_t*/ #include <signal.h> /* signal name macros, and the signal() prototype */ /* first, here is the signal handler */ voidcatch_int(intsig_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.

  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 } 

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

  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); }

  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

  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.

  25. Process ID • Each process has an ID(pid). • Each process has a group ID (pgid). • One process in the group is the group leaderand 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.

  26. Process Group ID • A process groupis a collection of related processes • 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.

  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.

  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 (ניתן להוסיף/לשנות שורה או שתיים בקוד לכל היותר)?

  29. Question from midterm 2004 my_prog.c #include… voidcntl_c_handler(int dummy){ signal(SIGINT, cntl_c_handler); } main (intargc,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); } }

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

  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

  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.

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

  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

More Related