Signals and how to control the program behavior in handling signals Terminal IO Signal A form of interprocess communication tells a process that some event occurs the kill command kill l ID: 362414
Download Presentation The PPT/PDF document "Today’s topics" is the property of its rightful owner. Permission is granted to download and print the materials on this web site for personal, non-commercial use only, and to display it on your personal computer provided you do not modify the materials and that you retain all copyright notices contained in the materials. By downloading content from our website, you accept the terms of this agreement.
Slide1
Today’s topics
Signals and how to control the program behavior in handling signals.
Terminal I/OSlide2
Signal
A form of inter-process communication
tells a process that some event occurs
the kill command
“kill –l”
“kill –s INT pid”
Type “ctrl-C” when a program is running
Memory violation, etc
Divided by 0.
A process dies (SIGHUP and SIGCHLD).
a packet arrives
……Slide3
Some commonly used signals:
SIGABRT, SIGALRM, SIGCHLD, SIGHUP, SIGINT, SIGUSR1, SIGUSR2, SIGTERM, SIGKILL, SIGSTOP, SIGSEGV, SIGILL
All defined in signal.h
more /usr/include/bits/signum.h on linprog to see all signals.
Try ‘man –s 7 signal’ on linprogSlide4
Signal
When a process receives a signal, it has the following options:
Block the signal
Do not disturb (no signal until allowed) – kernel delivers the signal only after the signal is unblocked by the process.
Ignore the signal
I see the signal, I won’t do anything.
Perform the default operation
Ignore the signal
exit
Catch the signal (perform user defined operations).Slide5
Catch a signal:
similar to interrupt (software interrupt)
when a process receives a signal:
stop execution
call the signal handler routine
resume execution
Signal can be received at any point in the program.
Catching a signal is like inserting a signal handler routine call dynamically (at any point of the program).Slide6
Controlling the reaction to signals in a program:
Block the signal:
sigprocmask
Ignore the signal:
signal
,
sigaction
Perform the default operation (do nothing):
Most likely ignore the signal, or quit
Catch the signal (perform user-defined operations): signal, sigactionSlide7
ANSI C signal function:
syntax:
#include <signal.h>
void (*signal(int sig, void (*disp)(int)))(int);
semantic:
sig -- signal (defined in signal.h)
disp: SIG_IGN, SIG_DFL or the address of a signal handler routine.
Handler may be erased after one invocation.
How to get continuous coverage?
Still have problems – may lose signals
See example1.c (lingprog and program): semantic not well defined
Signal handler has a prototype of
void handler(int signo)Slide8
Block/unblock signal: sigprocmask
Manipulate signal sets
#include <signal.h>
int sigemptyset(sigset_t *set);
int sigfillset(sigset_t *set);
int sigaddset(sigset_t *set, int signo);
int sigdelset(sigset_t *set, int signo);
int sigismember(const sigset_t *set, int signo);
Manipulate signal mask of a process
Int sigprocmask(int how, const sigset_t *set, sigset_t *oset);
How: SIG_BLOCK, SIG_UNBLOCK, SIG_SETMASK
See example2.c, example2a.c, example3.c Slide9
For a critical region where you don’t want certain signal to come, the program will look like:
sigprocmask(SIG_BLOCK, &newmask, &oldmask);
……. /* critical region */
sigprocmask(SIG_SETMASK, &oldmask, NULL);Slide10
Sigaction
Supersedes the signal function + signal blocking
#include <signal.h>
Int sigaction(int signo, const struct sigaction * act, struct sigaction *oact)
Struct sigaction {
void (*sa_handler)(); /* signal handler */
sigset_t sa_mask; /*additional signal to be block */
int sa_flags; /* various options for handling signal */
};
See example4.c (noted the program behavior with multiple signals).Slide11
Kill:
Send a signal to a process
#include <signal.h>
#include <sys/types.h>
Int kill(pid_t pid, int signo);
Pid > 0, normal
Pid == 0, all processes whose group ID is the current process’s group ID.
Pid <0, all processes whose group ID = |pid|
See example5.cSlide12
Alarm in a program
#include <unistd.h>
Unsigned int alarm(unsigned int seconds)
Arrange to have a signal (SIGALRM) to be delivered to the process in
seconds
seconds.
Stop running this program in 2 days.
See example6.c for the use of alarm.Slide13
Impact of signals on system calls
A system call may return prematurely
See example7.c
How to deal with this problem?
Check the return value of the system call and act accordingly, and check
errno
to decide the error type (see man –a read)Slide14
Compiling C program with POSIX routines using ‘-Wall –pedantic –
ansi
’
Try ‘
gcc
–Wall –pedantic –
ansi
example7.c’
Do ‘man
sigaction
’
‘more /
usr
/include/
signal.h
’
‘more /
usr
/include/
features.h
’
Specify the code is a POSIX code with flag
‘-D_POSIX_SOURCE’
‘-D_POSIX_C_SOURCE=200112L’
‘
gcc
–Wall –pedantic –
ansi
example7.c -D_POSIX_C_SOURCE=200112L’Slide15
Terminal I/O:
The semantics of an output operation is relatively simple. Input is rather messy.
Two input modes:
Canonical mode: the default mode, input line by line
Noncanonical mode: input characters are not assembled.
We will focus on noncanonical mode
When do we use it?
What should we expect when using this mode for input?
Example: Which input mode does a regular shell use?Slide16
In POSIX.1, all the characteristics of a terminal device that we can examine and change are in a termios structure (termios.h)
Struct termios {
tcflag_t c_iflag; /* input flag */
tcflag_t c_oflag; /* output flag */
tcflag_t c_cflag; /* control flags */
tcflag_t c_lflag; /* local flags */
cc_t c_cc[NCCS]; /* control characters */
} Slide17
Functions to get and set the fields in the termios structure
tcgetattr and tcsetattr;
#include <termios.h>
int tcgetattr(int fildes, struct termios *termios_p)
int tcsetattr(int fildes, int optional_actions, const struct termios *termios_p)
optional_actions: TCSANOW, TCSADRAIN, TCSAFLUSH Slide18
Turn on the noncanonical mode:
Unset the ICANON flag in c_lflag
Myterm.c_lflag & = ~ICANON
When will a read return using the noncanonical mode for input?
Number of characters(VMIN)
Time (VTIME)
Specified in the c_cc field
c_cc[VMIN] = ???, c_cc[VTIME] = ???
VMIN > 0, VTIME > 0
VMIN = 0, VTIME > 0
VMIN > 0, VTIME = 0
VMIN = 0, VTIME = 0 Slide19
See example8.c and example9.cSlide20
Review
Name a few commonly used signals.
What is the typical behavior when a signal is received?
Name different ways a program can deal with a signal
Which routine can be used to block a signal?
Which routine can be used to ignore a signal
Which routine can be used to establish a user-defined signal handler?
What to do to set up a code region that no-signals are allowed?
Give two routines where signals are sent to a process
What is the potential impact of signal on system calls?
Is tcsh using canonical mode of input?
How to turn on non-canonical mode of input?
In non-canonical mode of input, how to decide when to return from a input routine?