CSC209H Lecture 8. Dan Zingaro. March 4, 2015

Transcription

1 CSC209H Lecture 8 Dan Zingaro March 4, 2015

2 Signals you Already Know Like pipes, signals are a form of inter-process communication You ve already sent signals using the shell When you hit ctrl+c to terminate a program, what really happens? Kernel is told by the terminal driver that you ve hit the interrupt character, and sends SIGINT to the process By default, SIGINT terminates the process Similarly: ctrl+z sends a SIGTSTP to a process By default, SIGTSTP stops the process There is also a SIGSTOP, which is guaranteed to stop a process (the process can t prevent it)

3 Other Signals (Kerrisk 20.2) The kernel sends several other signals to terminate processes when bad things happen, such as: SIGBUS: hardware fault SIGFPE: floating-point error SIGILL: illegal instruction There are also two special signals, SIGUSR1 and SIGUSR2 We can use these for our own purposes (kernel doesn t use them) By default, they terminate the process

4 Sending Signals from the Shell Use kill -SIGNAME pid... to send signal SIGNAME to one or more processes e.g. kill -SIGINT e.g. kill -SIGKILL Unlike with SIGINT, no program can do anything about a SIGKILL

5 Ignoring and Catching Signals Signals are unexpected, asynchronous events: they can happen at any time Unless you make special arrangements, most signals terminate your process Three options Write a signal handler function (called automatically upon the receipt of the signal), or Ignore the signal (the signal does nothing to your process), or Use the default action sigaction is used for all of these purposes

6 sigaction (Kerrisk 20.13) int sigaction(int sig, const struct sigaction *act, struct sigaction *oldact); sig: signal whose handling you want to change (e.g. SIGINT) act: set its sa_handler field to The address of a handler function (i.e. a function pointer), or SIG_IGN (ignore signal), or SIG_DFL (default action) oldact: if not NULL, it will hold the handler information for signal sig before this sigaction call changes it

7 Example: sigaction (sigaction.c) int i = 0; void handler(int signo) { fprintf(stderr, "Sig %d; total %d.\n", signo, ++i); } int main(void) { struct sigaction newact; sigemptyset (&newact.sa_mask); newact.sa_flags = 0; newact.sa_handler = handler; if (sigaction(sigint, &newact, NULL) == -1) exit(1); if (sigaction(sigtstp, &newact, NULL) == -1) exit(1); for(;;) ; //Infinite loop }

8 Sending Signals Between Processes (Kerrisk 20.5) One process can send a signal to another process using the misleadingly-named kill function. int kill(int pid, int sig); kill sends the signal sig to the process pid Signalling between processes can be used for many purposes; e.g. Killing out-of-control processes Temporarily suspending execution of a process Making a process aware of the passage of time Synchronizing the actions of processes

9 Blocking Signals Signals can be generated at any time To temporarily prevent a signal from being delivered at an inopportune moment, it can be blocked The signal is delivered when the process later unblocks the signal This is different from ignoring a signal! Ignoring a signal throws the signal away so the process never sees it

10 Signal Sets (Kerrisk 20.9) Signal sets are used to store the set of signals that you want to block or unblock Here are the operations on signal sets int sigemptyset(sigset_t *set); //empty a set int sigfillset(sigset_t *set); //fill a set int sigaddset(sigset_t *set, int signo); //add signal int sigdelset(sigset_t *set, int signo); //remove signal int sigismember(const sigset_t *set, int signo); // in

11 sigprocmask (Kerrisk 20.10) int sigprocmask(int how, const sigset_t *set, sigset_t *oldset); how: indicates how the set of blocked signals will be modified SIG_BLOCK: add to those currently blocked (+) SIG_UNBLOCK: remove from those currently blocked ( ) SIG_SETMASK: set the collection of signals being blocked (=) set: points to the set of signals to be used for modifying the currently-blocked signals oldset: will hold the set of signals that were blocked before sigprocmask changes it

12 Example: sigprocmask (blockint.c) During a critical operation, you might want to block SIGINT: sigset_t set, oldset; sigemptyset(&set); sigaddset(&set, SIGINT); sigprocmask(sig_block, &set, &oldset); /*... Critical operation...*/ sigprocmask(sig_setmask, &oldset, NULL);

13 Pending Signals (Kerrisk ) A signal that is generated while it is being blocked is referred to as a pending signal. int sigpending(sigset t *set); sigpending modifies set to contain the currently pending signals We know only whether or not a signal is pending, not how many signals of that type were sent When we unblock a signal that is pending, we receive one signal of that type (i.e. signals do not queue)

14 pause (Kerrisk 20.14) If you are awaiting the arrival of a signal, it s very inefficient to busy-wait in a loop e.g. while (1) or for (; ;) pause suspends execution until a handled signal arrives However, pause can result in you missing a signal...

15 pause... Here is an attempt to write a program that Blocks SIGINT while doing some important work, then Unblocks SIGINT and waits for a SIGINT to be sent before terminating Any SIGINT sent during the important work should count (i.e. terminate the program after SIGINT is unblocked) Problem: signal can sneak in after the unblock and before the pause

16 pause... (pause.c) int main(void) { time_t starttime; sigset_t mask, oldmask; struct sigaction newact; sigemptyset(&mask); sigaddset(&mask, SIGINT); if(sigprocmask(sig_block, &mask, &oldmask) == -1) exit(1); sigemptyset(&newact.sa_mask); newact.sa_flags = 0; newact.sa_handler = handler; if (sigaction(sigint, &newact, NULL) == -1) exit(1);

17 pause... (pause.c) fprintf(stderr, "SIGINT blocked. Doing important work\n"); starttime = time(null); while (time(null) < starttime + 10) ; //infinite fprintf(stderr, "Now unblocking SIGINT\n"); if (sigprocmask(sig_setmask, &oldmask, NULL) == -1) exit(1); pause(); fprintf(stderr, "Got the SIGINT. Exiting...\n"); return 0; }

18 sigpipe SIGPIPE is sent when a process tries to write to a pipe that has no readers. void handler(int signo) { fprintf(stderr, "No readers, exiting...\n"); exit(1); } int main(void) { int fd[2]; struct sigaction newact; sigemptyset (&newact.sa_mask); newact.sa_flags = 0; newact.sa_handler = handler; if (sigaction(sigpipe, &newact, NULL) == -1) exit(1); if (pipe(fd) == -1) exit (1); close(fd[0]); write(fd[1], "hello", 5); printf("done!\n"); }

19 Limitations of Signals Signals carry no information All you know is the type of signal (e.g. SIGINT, SIGUSR1) that interrupted you Signals don t stack (no queueing) If I send you signal X while you have a previously-sent signal X pending, the second X is lost Signals are unreliable communication mechanisms Usually used to indicate abnormal conditions, not for data exchange