http://tedlab.mit.edu/~dr/gdbintro.html

GDB Tutorial
More about breakpoints
Breakpoints by themselves may seem too tedious. You have to
keep stepping, and stepping, and stepping. . .
Basic idea
Once we develop an idea for what the error could be (like dereferencing a
NULL pointer, or going past the bounds of an array), we probably only
care if such an event happens; we don’t want to break at each iteration
regardless.
So ideally, we’d like to condition on a particular requirement (or set
of requirements). Using conditional breakpoints allow us to
accomplish this goal. . .
GDB Tutorial
Conditional breakpoints
Just like regular breakpoints, except that you get to specify some
criterion that must be met for the breakpoint to trigger. We use
the same break command as before:
(gdb) break file1.c:6 if i >= ARRAYSIZE
This command sets a breakpoint at line 6 of file file1.c, which
triggers only if the variable i is greater than or equal to the size of
the array (which probably is bad if line 6 does something like
arr[i]). Conditional breakpoints can most likely avoid all the
unnecessary stepping, etc.
GDB

void SIGINT_handler(int);
void SIGQUIT_handler(int);
int
pid_t
ShmID;
*ShmPTR;
used to save shared memory ID
my PID will be stored here
19
Kill Example: process-a (2)
void main(void)
{
int
i;
pid_t pid = getpid();
key_y MyKey;
signal(SIGINT, SIGINT_handler);
signal(SIGQUIT, SIGQUIT_handler);
MyKey = ftok(“./”, ‘a’);
ShmID = shmget(MyKey, sizeof(pid_t), IPC_CREAT|0666);
ShmPTR = (pid_t *) shmat(shmID, NULL, 0);
*ShmPTR = pid;
for (i = 0; ; i++) {
printf(“From process %d: %d\n”, pid, i);
sleep(1);
}
}
20
Kill Example: process-a (2)
use Ctrl-C to interrupt
void SIGINT_handler(int sig)
{
signal(sig, SIG_IGN);
printf(“From SIGINT: got a Ctrl-C signal %d\n”, sig);
signal(sig, SIGINT_handler);
}
void SIGQUIT_handler(int sig) use Ctrl-\ to kill this program
{
signal(sig, SIG_IGN);
printf(“From SIGQUIT: got a Ctrl-\\ signal %d\n”, sig);
printf(“From SIGQUIT: quitting\n”);
shmdt(ShmPTR);
shmctl(ShmID, IPC_RMID, NULL);
exit(0);
}
21
Kill Example: process-b (1)
#include
#include
#include
#include
#include

Void main(void)
{
pid_t pid, *ShmPTR;
key_t MyKey;
int
ShmID;
char
c;
detach the shared memory
after taking the pid
MyKey = ftok(“./”, ‘a’);
ShmID = shmget(MyKey, sizeof(pid_t), 0666);
ShmPTR = (pid_t *) shmat(ShmID, NULL, 0);
pid
= *ShmPTR;
shmdt(ShmPTR); /* see next page */
22
Kill Example: process-b (2)
while (1) {
printf(“(i for interrupt or k for kill)? ”);
c = getchar();
if (c == ‘i’ || c == ‘I’) {
kill(pid, SIGINT);
printf(“A SIGKILL signal has been sent\n”);
}
else if (c == ‘k’ || c == ‘K’) {
printf(“About to sent a SIGQUIT signal\n”);
kill(pid, SIGQUIT);
exit(0);
}
else
printf(“Wrong keypress (%c). Try again!\n”, c);
}
}
23
You can kill process-a from within process-b!
The Unix Kill Command
The kill command can also be used to send a signal
to a process:
kill –l /* list all signals */
kill –XXX pid1 pid …… pid
In the above XXX is the signal name without the
initial letters SIG.
kill –KILL 1357 2468 kills process 1357 and
2468.
kill –INT 6421 sends a SIGINT to process 6421.
A kill without a signal name is equivalent to
SIGTERM.
-9 is equal to –SIGKILL.
24