1 /* Multi-threaded debugging support for GNU/Linux (LWP layer).
2 Copyright 2000, 2001, 2002, 2003 Free Software Foundation, Inc.
4 This file is part of GDB.
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 2 of the License, or
9 (at your option) any later version.
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with this program; if not, write to the Free Software
18 Foundation, Inc., 59 Temple Place - Suite 330,
19 Boston, MA 02111-1307, USA. */
23 #include "gdb_assert.h"
24 #include "gdb_string.h"
27 #ifdef HAVE_TKILL_SYSCALL
29 #include <sys/syscall.h>
31 #include <sys/ptrace.h>
34 #include "gdbthread.h"
40 static int debug_lin_lwp
;
41 extern char *strsignal (int sig
);
43 #include "linux-nat.h"
45 /* On GNU/Linux there are no real LWP's. The closest thing to LWP's
46 are processes sharing the same VM space. A multi-threaded process
47 is basically a group of such processes. However, such a grouping
48 is almost entirely a user-space issue; the kernel doesn't enforce
49 such a grouping at all (this might change in the future). In
50 general, we'll rely on the threads library (i.e. the GNU/Linux
51 Threads library) to provide such a grouping.
53 It is perfectly well possible to write a multi-threaded application
54 without the assistance of a threads library, by using the clone
55 system call directly. This module should be able to give some
56 rudimentary support for debugging such applications if developers
57 specify the CLONE_PTRACE flag in the clone system call, and are
58 using the Linux kernel 2.4 or above.
60 Note that there are some peculiarities in GNU/Linux that affect
63 - In general one should specify the __WCLONE flag to waitpid in
64 order to make it report events for any of the cloned processes
65 (and leave it out for the initial process). However, if a cloned
66 process has exited the exit status is only reported if the
67 __WCLONE flag is absent. Linux kernel 2.4 has a __WALL flag, but
68 we cannot use it since GDB must work on older systems too.
70 - When a traced, cloned process exits and is waited for by the
71 debugger, the kernel reassigns it to the original parent and
72 keeps it around as a "zombie". Somehow, the GNU/Linux Threads
73 library doesn't notice this, which leads to the "zombie problem":
74 When debugged a multi-threaded process that spawns a lot of
75 threads will run out of processes, even if the threads exit,
76 because the "zombies" stay around. */
78 /* List of known LWPs. */
79 static struct lwp_info
*lwp_list
;
81 /* Number of LWPs in the list. */
84 /* Non-zero if we're running in "threaded" mode. */
88 #define GET_LWP(ptid) ptid_get_lwp (ptid)
89 #define GET_PID(ptid) ptid_get_pid (ptid)
90 #define is_lwp(ptid) (GET_LWP (ptid) != 0)
91 #define BUILD_LWP(lwp, pid) ptid_build (pid, lwp, 0)
93 /* If the last reported event was a SIGTRAP, this variable is set to
94 the process id of the LWP/thread that got it. */
98 /* This module's target-specific operations. */
99 static struct target_ops lin_lwp_ops
;
101 /* The standard child operations. */
102 extern struct target_ops child_ops
;
104 /* Since we cannot wait (in lin_lwp_wait) for the initial process and
105 any cloned processes with a single call to waitpid, we have to use
106 the WNOHANG flag and call waitpid in a loop. To optimize
107 things a bit we use `sigsuspend' to wake us up when a process has
108 something to report (it will send us a SIGCHLD if it has). To make
109 this work we have to juggle with the signal mask. We save the
110 original signal mask such that we can restore it before creating a
111 new process in order to avoid blocking certain signals in the
112 inferior. We then block SIGCHLD during the waitpid/sigsuspend
115 /* Original signal mask. */
116 static sigset_t normal_mask
;
118 /* Signal mask for use with sigsuspend in lin_lwp_wait, initialized in
119 _initialize_lin_lwp. */
120 static sigset_t suspend_mask
;
122 /* Signals to block to make that sigsuspend work. */
123 static sigset_t blocked_mask
;
126 /* Prototypes for local functions. */
127 static int stop_wait_callback (struct lwp_info
*lp
, void *data
);
128 static int lin_lwp_thread_alive (ptid_t ptid
);
130 /* Convert wait status STATUS to a string. Used for printing debug
134 status_to_str (int status
)
138 if (WIFSTOPPED (status
))
139 snprintf (buf
, sizeof (buf
), "%s (stopped)",
140 strsignal (WSTOPSIG (status
)));
141 else if (WIFSIGNALED (status
))
142 snprintf (buf
, sizeof (buf
), "%s (terminated)",
143 strsignal (WSTOPSIG (status
)));
145 snprintf (buf
, sizeof (buf
), "%d (exited)", WEXITSTATUS (status
));
150 /* Initialize the list of LWPs. Note that this module, contrary to
151 what GDB's generic threads layer does for its thread list,
152 re-initializes the LWP lists whenever we mourn or detach (which
153 doesn't involve mourning) the inferior. */
158 struct lwp_info
*lp
, *lpnext
;
160 for (lp
= lwp_list
; lp
; lp
= lpnext
)
171 /* Add the LWP specified by PID to the list. If this causes the
172 number of LWPs to become larger than one, go into "threaded" mode.
173 Return a pointer to the structure describing the new LWP. */
175 static struct lwp_info
*
176 add_lwp (ptid_t ptid
)
180 gdb_assert (is_lwp (ptid
));
182 lp
= (struct lwp_info
*) xmalloc (sizeof (struct lwp_info
));
184 memset (lp
, 0, sizeof (struct lwp_info
));
196 /* Remove the LWP specified by PID from the list. */
199 delete_lwp (ptid_t ptid
)
201 struct lwp_info
*lp
, *lpprev
;
205 for (lp
= lwp_list
; lp
; lpprev
= lp
, lp
= lp
->next
)
206 if (ptid_equal (lp
->ptid
, ptid
))
212 /* We don't go back to "non-threaded" mode if the number of threads
213 becomes less than two. */
217 lpprev
->next
= lp
->next
;
224 /* Return a pointer to the structure describing the LWP corresponding
225 to PID. If no corresponding LWP could be found, return NULL. */
227 static struct lwp_info
*
228 find_lwp_pid (ptid_t ptid
)
234 lwp
= GET_LWP (ptid
);
236 lwp
= GET_PID (ptid
);
238 for (lp
= lwp_list
; lp
; lp
= lp
->next
)
239 if (lwp
== GET_LWP (lp
->ptid
))
245 /* Call CALLBACK with its second argument set to DATA for every LWP in
246 the list. If CALLBACK returns 1 for a particular LWP, return a
247 pointer to the structure describing that LWP immediately.
248 Otherwise return NULL. */
251 iterate_over_lwps (int (*callback
) (struct lwp_info
*, void *), void *data
)
253 struct lwp_info
*lp
, *lpnext
;
255 for (lp
= lwp_list
; lp
; lp
= lpnext
)
258 if ((*callback
) (lp
, data
))
268 lin_lwp_open (char *args
, int from_tty
)
270 push_target (&lin_lwp_ops
);
274 /* Attach to the LWP specified by PID. If VERBOSE is non-zero, print
275 a message telling the user that a new LWP has been added to the
279 lin_lwp_attach_lwp (ptid_t ptid
, int verbose
)
283 gdb_assert (is_lwp (ptid
));
285 /* Make sure SIGCHLD is blocked. We don't want SIGCHLD events
286 to interrupt either the ptrace() or waitpid() calls below. */
287 if (!sigismember (&blocked_mask
, SIGCHLD
))
289 sigaddset (&blocked_mask
, SIGCHLD
);
290 sigprocmask (SIG_BLOCK
, &blocked_mask
, NULL
);
294 printf_filtered ("[New %s]\n", target_pid_to_str (ptid
));
296 lp
= find_lwp_pid (ptid
);
300 /* We assume that we're already attached to any LWP that has an
301 id equal to the overall process id. */
302 if (GET_LWP (ptid
) != GET_PID (ptid
))
307 if (ptrace (PTRACE_ATTACH
, GET_LWP (ptid
), 0, 0) < 0)
308 error ("Can't attach %s: %s", target_pid_to_str (ptid
),
309 safe_strerror (errno
));
312 fprintf_unfiltered (gdb_stdlog
,
313 "LLAL: PTRACE_ATTACH %s, 0, 0 (OK)\n",
314 target_pid_to_str (ptid
));
316 pid
= waitpid (GET_LWP (ptid
), &status
, 0);
317 if (pid
== -1 && errno
== ECHILD
)
319 /* Try again with __WCLONE to check cloned processes. */
320 pid
= waitpid (GET_LWP (ptid
), &status
, __WCLONE
);
324 gdb_assert (pid
== GET_LWP (ptid
)
325 && WIFSTOPPED (status
) && WSTOPSIG (status
));
331 fprintf_unfiltered (gdb_stdlog
,
332 "LLAL: waitpid %s received %s\n",
333 target_pid_to_str (ptid
),
334 status_to_str (status
));
339 /* We assume that the LWP representing the original process
340 is already stopped. Mark it as stopped in the data structure
341 that the lin-lwp layer uses to keep track of threads. Note
342 that this won't have already been done since the main thread
343 will have, we assume, been stopped by an attach from a
350 lin_lwp_attach (char *args
, int from_tty
)
356 /* FIXME: We should probably accept a list of process id's, and
357 attach all of them. */
358 child_ops
.to_attach (args
, from_tty
);
360 /* Add the initial process as the first LWP to the list. */
361 lp
= add_lwp (BUILD_LWP (GET_PID (inferior_ptid
), GET_PID (inferior_ptid
)));
363 /* Make sure the initial process is stopped. The user-level threads
364 layer might want to poke around in the inferior, and that won't
365 work if things haven't stabilized yet. */
366 pid
= waitpid (GET_PID (inferior_ptid
), &status
, 0);
367 if (pid
== -1 && errno
== ECHILD
)
369 warning ("%s is a cloned process", target_pid_to_str (inferior_ptid
));
371 /* Try again with __WCLONE to check cloned processes. */
372 pid
= waitpid (GET_PID (inferior_ptid
), &status
, __WCLONE
);
376 gdb_assert (pid
== GET_PID (inferior_ptid
)
377 && WIFSTOPPED (status
) && WSTOPSIG (status
) == SIGSTOP
);
381 /* Fake the SIGSTOP that core GDB expects. */
382 lp
->status
= W_STOPCODE (SIGSTOP
);
386 fprintf_unfiltered (gdb_stdlog
,
387 "LLA: waitpid %ld, faking SIGSTOP\n", (long) pid
);
392 detach_callback (struct lwp_info
*lp
, void *data
)
394 gdb_assert (lp
->status
== 0 || WIFSTOPPED (lp
->status
));
396 if (debug_lin_lwp
&& lp
->status
)
397 fprintf_unfiltered (gdb_stdlog
, "DC: Pending %s for %s on detach.\n",
398 strsignal (WSTOPSIG (lp
->status
)),
399 target_pid_to_str (lp
->ptid
));
401 while (lp
->signalled
&& lp
->stopped
)
404 if (ptrace (PTRACE_CONT
, GET_LWP (lp
->ptid
), 0,
405 WSTOPSIG (lp
->status
)) < 0)
406 error ("Can't continue %s: %s", target_pid_to_str (lp
->ptid
),
407 safe_strerror (errno
));
410 fprintf_unfiltered (gdb_stdlog
,
411 "DC: PTRACE_CONTINUE (%s, 0, %s) (OK)\n",
412 target_pid_to_str (lp
->ptid
),
413 status_to_str (lp
->status
));
418 stop_wait_callback (lp
, NULL
);
420 gdb_assert (lp
->status
== 0 || WIFSTOPPED (lp
->status
));
423 /* We don't actually detach from the LWP that has an id equal to the
424 overall process id just yet. */
425 if (GET_LWP (lp
->ptid
) != GET_PID (lp
->ptid
))
428 if (ptrace (PTRACE_DETACH
, GET_LWP (lp
->ptid
), 0,
429 WSTOPSIG (lp
->status
)) < 0)
430 error ("Can't detach %s: %s", target_pid_to_str (lp
->ptid
),
431 safe_strerror (errno
));
434 fprintf_unfiltered (gdb_stdlog
,
435 "PTRACE_DETACH (%s, %s, 0) (OK)\n",
436 target_pid_to_str (lp
->ptid
),
437 strsignal (WSTOPSIG (lp
->status
)));
439 delete_lwp (lp
->ptid
);
446 lin_lwp_detach (char *args
, int from_tty
)
448 iterate_over_lwps (detach_callback
, NULL
);
450 /* Only the initial process should be left right now. */
451 gdb_assert (num_lwps
== 1);
453 trap_ptid
= null_ptid
;
455 /* Destroy LWP info; it's no longer valid. */
458 /* Restore the original signal mask. */
459 sigprocmask (SIG_SETMASK
, &normal_mask
, NULL
);
460 sigemptyset (&blocked_mask
);
462 inferior_ptid
= pid_to_ptid (GET_PID (inferior_ptid
));
463 child_ops
.to_detach (args
, from_tty
);
470 resume_callback (struct lwp_info
*lp
, void *data
)
472 if (lp
->stopped
&& lp
->status
== 0)
474 struct thread_info
*tp
;
476 child_resume (pid_to_ptid (GET_LWP (lp
->ptid
)), 0, TARGET_SIGNAL_0
);
478 fprintf_unfiltered (gdb_stdlog
,
479 "RC: PTRACE_CONT %s, 0, 0 (resume sibling)\n",
480 target_pid_to_str (lp
->ptid
));
489 resume_clear_callback (struct lwp_info
*lp
, void *data
)
496 resume_set_callback (struct lwp_info
*lp
, void *data
)
503 lin_lwp_resume (ptid_t ptid
, int step
, enum target_signal signo
)
508 /* A specific PTID means `step only this process id'. */
509 resume_all
= (PIDGET (ptid
) == -1);
512 iterate_over_lwps (resume_set_callback
, NULL
);
514 iterate_over_lwps (resume_clear_callback
, NULL
);
516 /* If PID is -1, it's the current inferior that should be
517 handled specially. */
518 if (PIDGET (ptid
) == -1)
519 ptid
= inferior_ptid
;
521 lp
= find_lwp_pid (ptid
);
524 ptid
= pid_to_ptid (GET_LWP (lp
->ptid
));
526 /* Remember if we're stepping. */
529 /* Mark this LWP as resumed. */
532 /* If we have a pending wait status for this thread, there is no
533 point in resuming the process. */
536 /* FIXME: What should we do if we are supposed to continue
537 this thread with a signal? */
538 gdb_assert (signo
== TARGET_SIGNAL_0
);
542 /* Mark LWP as not stopped to prevent it from being continued by
548 iterate_over_lwps (resume_callback
, NULL
);
550 child_resume (ptid
, step
, signo
);
552 fprintf_unfiltered (gdb_stdlog
,
553 "LLR: %s %s, %s (resume event thread)\n",
554 step
? "PTRACE_SINGLESTEP" : "PTRACE_CONT",
555 target_pid_to_str (ptid
),
556 signo
? strsignal (signo
) : "0");
560 /* Issue kill to specified lwp. */
562 static int tkill_failed
;
565 kill_lwp (int lwpid
, int signo
)
569 /* Use tkill, if possible, in case we are using nptl threads. If tkill
570 fails, then we are not using nptl threads and we should be using kill. */
572 #ifdef HAVE_TKILL_SYSCALL
575 int ret
= syscall (__NR_tkill
, lwpid
, signo
);
583 return kill (lwpid
, signo
);
586 /* Send a SIGSTOP to LP. */
589 stop_callback (struct lwp_info
*lp
, void *data
)
591 if (!lp
->stopped
&& !lp
->signalled
)
597 fprintf_unfiltered (gdb_stdlog
,
598 "SC: kill %s **<SIGSTOP>**\n",
599 target_pid_to_str (lp
->ptid
));
602 ret
= kill_lwp (GET_LWP (lp
->ptid
), SIGSTOP
);
605 fprintf_unfiltered (gdb_stdlog
,
606 "SC: lwp kill %d %s\n",
608 errno
? safe_strerror (errno
) : "ERRNO-OK");
612 gdb_assert (lp
->status
== 0);
618 /* Wait until LP is stopped. If DATA is non-null it is interpreted as
619 a pointer to a set of signals to be flushed immediately. */
622 stop_wait_callback (struct lwp_info
*lp
, void *data
)
624 sigset_t
*flush_mask
= data
;
626 if (!lp
->stopped
&& lp
->signalled
)
631 gdb_assert (lp
->status
== 0);
633 pid
= waitpid (GET_LWP (lp
->ptid
), &status
, 0);
634 if (pid
== -1 && errno
== ECHILD
)
636 pid
= waitpid (GET_LWP (lp
->ptid
), &status
, __WCLONE
);
637 if (pid
== -1 && errno
== ECHILD
)
639 /* The thread has previously exited. We need to delete it now
640 because in the case of nptl threads, there won't be an
641 exit event unless it is the main thread. */
643 fprintf_unfiltered (gdb_stdlog
,
645 target_pid_to_str (lp
->ptid
));
646 delete_lwp (lp
->ptid
);
651 gdb_assert (pid
== GET_LWP (lp
->ptid
));
655 fprintf_unfiltered (gdb_stdlog
,
656 "SWC: waitpid %s received %s\n",
657 target_pid_to_str (lp
->ptid
),
658 status_to_str (status
));
661 /* Check if the thread has exited. */
662 if (WIFEXITED (status
) || WIFSIGNALED (status
))
664 gdb_assert (num_lwps
> 1);
666 if (in_thread_list (lp
->ptid
))
668 /* Core GDB cannot deal with us deleting the current
670 if (!ptid_equal (lp
->ptid
, inferior_ptid
))
671 delete_thread (lp
->ptid
);
672 printf_unfiltered ("[%s exited]\n",
673 target_pid_to_str (lp
->ptid
));
676 fprintf_unfiltered (gdb_stdlog
,
678 target_pid_to_str (lp
->ptid
));
680 delete_lwp (lp
->ptid
);
684 /* Check if the current LWP has previously exited. For nptl threads,
685 there is no exit signal issued for LWPs that are not the
686 main thread so we should check whenever the thread is stopped. */
687 if (!lin_lwp_thread_alive (lp
->ptid
))
689 if (in_thread_list (lp
->ptid
))
691 /* Core GDB cannot deal with us deleting the current
693 if (!ptid_equal (lp
->ptid
, inferior_ptid
))
694 delete_thread (lp
->ptid
);
695 printf_unfiltered ("[%s exited]\n",
696 target_pid_to_str (lp
->ptid
));
699 fprintf_unfiltered (gdb_stdlog
,
700 "SWC: %s already exited.\n",
701 target_pid_to_str (lp
->ptid
));
703 delete_lwp (lp
->ptid
);
707 gdb_assert (WIFSTOPPED (status
));
709 /* Ignore any signals in FLUSH_MASK. */
710 if (flush_mask
&& sigismember (flush_mask
, WSTOPSIG (status
)))
713 ptrace (PTRACE_CONT
, GET_LWP (lp
->ptid
), 0, 0);
715 fprintf_unfiltered (gdb_stdlog
,
716 "PTRACE_CONT %s, 0, 0 (%s)\n",
717 target_pid_to_str (lp
->ptid
),
718 errno
? safe_strerror (errno
) : "OK");
720 return stop_wait_callback (lp
, flush_mask
);
723 if (WSTOPSIG (status
) != SIGSTOP
)
725 if (WSTOPSIG (status
) == SIGTRAP
)
727 /* If a LWP other than the LWP that we're reporting an
728 event for has hit a GDB breakpoint (as opposed to
729 some random trap signal), then just arrange for it to
730 hit it again later. We don't keep the SIGTRAP status
731 and don't forward the SIGTRAP signal to the LWP. We
732 will handle the current event, eventually we will
733 resume all LWPs, and this one will get its breakpoint
736 If we do not do this, then we run the risk that the
737 user will delete or disable the breakpoint, but the
738 thread will have already tripped on it. */
740 /* Now resume this LWP and get the SIGSTOP event. */
742 ptrace (PTRACE_CONT
, GET_LWP (lp
->ptid
), 0, 0);
745 fprintf_unfiltered (gdb_stdlog
,
746 "PTRACE_CONT %s, 0, 0 (%s)\n",
747 target_pid_to_str (lp
->ptid
),
748 errno
? safe_strerror (errno
) : "OK");
750 fprintf_unfiltered (gdb_stdlog
,
751 "SWC: Candidate SIGTRAP event in %s\n",
752 target_pid_to_str (lp
->ptid
));
754 /* Hold the SIGTRAP for handling by lin_lwp_wait. */
755 stop_wait_callback (lp
, data
);
756 /* If there's another event, throw it back into the queue. */
761 fprintf_unfiltered (gdb_stdlog
,
762 "SWC: kill %s, %s\n",
763 target_pid_to_str (lp
->ptid
),
764 status_to_str ((int) status
));
766 kill_lwp (GET_LWP (lp
->ptid
), WSTOPSIG (lp
->status
));
768 /* Save the sigtrap event. */
774 /* The thread was stopped with a signal other than
775 SIGSTOP, and didn't accidentally trip a breakpoint. */
779 fprintf_unfiltered (gdb_stdlog
,
780 "SWC: Pending event %s in %s\n",
781 status_to_str ((int) status
),
782 target_pid_to_str (lp
->ptid
));
784 /* Now resume this LWP and get the SIGSTOP event. */
786 ptrace (PTRACE_CONT
, GET_LWP (lp
->ptid
), 0, 0);
788 fprintf_unfiltered (gdb_stdlog
,
789 "SWC: PTRACE_CONT %s, 0, 0 (%s)\n",
790 target_pid_to_str (lp
->ptid
),
791 errno
? safe_strerror (errno
) : "OK");
793 /* Hold this event/waitstatus while we check to see if
794 there are any more (we still want to get that SIGSTOP). */
795 stop_wait_callback (lp
, data
);
796 /* If the lp->status field is still empty, use it to hold
797 this event. If not, then this event must be returned
798 to the event queue of the LWP. */
805 fprintf_unfiltered (gdb_stdlog
,
806 "SWC: kill %s, %s\n",
807 target_pid_to_str (lp
->ptid
),
808 status_to_str ((int) status
));
810 kill_lwp (GET_LWP (lp
->ptid
), WSTOPSIG (status
));
817 /* We caught the SIGSTOP that we intended to catch, so
818 there's no SIGSTOP pending. */
827 /* Return non-zero if LP has a wait status pending. */
830 status_callback (struct lwp_info
*lp
, void *data
)
832 /* Only report a pending wait status if we pretend that this has
833 indeed been resumed. */
834 return (lp
->status
!= 0 && lp
->resumed
);
837 /* Return non-zero if LP isn't stopped. */
840 running_callback (struct lwp_info
*lp
, void *data
)
842 return (lp
->stopped
== 0);
845 /* Count the LWP's that have had events. */
848 count_events_callback (struct lwp_info
*lp
, void *data
)
852 gdb_assert (count
!= NULL
);
854 /* Count only LWPs that have a SIGTRAP event pending. */
856 && WIFSTOPPED (lp
->status
) && WSTOPSIG (lp
->status
) == SIGTRAP
)
862 /* Select the LWP (if any) that is currently being single-stepped. */
865 select_singlestep_lwp_callback (struct lwp_info
*lp
, void *data
)
867 if (lp
->step
&& lp
->status
!= 0)
873 /* Select the Nth LWP that has had a SIGTRAP event. */
876 select_event_lwp_callback (struct lwp_info
*lp
, void *data
)
878 int *selector
= data
;
880 gdb_assert (selector
!= NULL
);
882 /* Select only LWPs that have a SIGTRAP event pending. */
884 && WIFSTOPPED (lp
->status
) && WSTOPSIG (lp
->status
) == SIGTRAP
)
885 if ((*selector
)-- == 0)
892 cancel_breakpoints_callback (struct lwp_info
*lp
, void *data
)
894 struct lwp_info
*event_lp
= data
;
896 /* Leave the LWP that has been elected to receive a SIGTRAP alone. */
900 /* If a LWP other than the LWP that we're reporting an event for has
901 hit a GDB breakpoint (as opposed to some random trap signal),
902 then just arrange for it to hit it again later. We don't keep
903 the SIGTRAP status and don't forward the SIGTRAP signal to the
904 LWP. We will handle the current event, eventually we will resume
905 all LWPs, and this one will get its breakpoint trap again.
907 If we do not do this, then we run the risk that the user will
908 delete or disable the breakpoint, but the LWP will have already
912 && WIFSTOPPED (lp
->status
) && WSTOPSIG (lp
->status
) == SIGTRAP
913 && breakpoint_inserted_here_p (read_pc_pid (lp
->ptid
) -
914 DECR_PC_AFTER_BREAK
))
917 fprintf_unfiltered (gdb_stdlog
,
918 "CBC: Push back breakpoint for %s\n",
919 target_pid_to_str (lp
->ptid
));
921 /* Back up the PC if necessary. */
922 if (DECR_PC_AFTER_BREAK
)
923 write_pc_pid (read_pc_pid (lp
->ptid
) - DECR_PC_AFTER_BREAK
, lp
->ptid
);
925 /* Throw away the SIGTRAP. */
932 /* Select one LWP out of those that have events pending. */
935 select_event_lwp (struct lwp_info
**orig_lp
, int *status
)
939 struct lwp_info
*event_lp
;
941 /* Record the wait status for the origional LWP. */
942 (*orig_lp
)->status
= *status
;
944 /* Give preference to any LWP that is being single-stepped. */
945 event_lp
= iterate_over_lwps (select_singlestep_lwp_callback
, NULL
);
946 if (event_lp
!= NULL
)
949 fprintf_unfiltered (gdb_stdlog
,
950 "SEL: Select single-step %s\n",
951 target_pid_to_str (event_lp
->ptid
));
955 /* No single-stepping LWP. Select one at random, out of those
956 which have had SIGTRAP events. */
958 /* First see how many SIGTRAP events we have. */
959 iterate_over_lwps (count_events_callback
, &num_events
);
961 /* Now randomly pick a LWP out of those that have had a SIGTRAP. */
962 random_selector
= (int)
963 ((num_events
* (double) rand ()) / (RAND_MAX
+ 1.0));
965 if (debug_lin_lwp
&& num_events
> 1)
966 fprintf_unfiltered (gdb_stdlog
,
967 "SEL: Found %d SIGTRAP events, selecting #%d\n",
968 num_events
, random_selector
);
970 event_lp
= iterate_over_lwps (select_event_lwp_callback
,
974 if (event_lp
!= NULL
)
976 /* Switch the event LWP. */
978 *status
= event_lp
->status
;
981 /* Flush the wait status for the event LWP. */
982 (*orig_lp
)->status
= 0;
985 /* Return non-zero if LP has been resumed. */
988 resumed_callback (struct lwp_info
*lp
, void *data
)
995 /* We need to override child_wait to support attaching to cloned
996 processes, since a normal wait (as done by the default version)
997 ignores those processes. */
999 /* Wait for child PTID to do something. Return id of the child,
1000 minus_one_ptid in case of error; store status into *OURSTATUS. */
1003 child_wait (ptid_t ptid
, struct target_waitstatus
*ourstatus
)
1011 set_sigint_trap (); /* Causes SIGINT to be passed on to the
1012 attached process. */
1015 pid
= waitpid (GET_PID (ptid
), &status
, 0);
1016 if (pid
== -1 && errno
== ECHILD
)
1017 /* Try again with __WCLONE to check cloned processes. */
1018 pid
= waitpid (GET_PID (ptid
), &status
, __WCLONE
);
1022 fprintf_unfiltered (gdb_stdlog
,
1023 "CW: waitpid %ld received %s\n",
1024 (long) pid
, status_to_str (status
));
1029 /* Make sure we don't report an event for the exit of the
1030 original program, if we've detached from it. */
1031 if (pid
!= -1 && !WIFSTOPPED (status
) && pid
!= GET_PID (inferior_ptid
))
1037 /* Check for stop events reported by a process we didn't already
1038 know about - in this case, anything other than inferior_ptid.
1040 If we're expecting to receive stopped processes after fork,
1041 vfork, and clone events, then we'll just add the new one to
1042 our list and go back to waiting for the event to be reported
1043 - the stopped process might be returned from waitpid before
1044 or after the event is. If we want to handle debugging of
1045 CLONE_PTRACE processes we need to do more here, i.e. switch
1046 to multi-threaded mode. */
1047 if (pid
!= -1 && WIFSTOPPED (status
) && WSTOPSIG (status
) == SIGSTOP
1048 && pid
!= GET_PID (inferior_ptid
))
1054 clear_sigio_trap ();
1055 clear_sigint_trap ();
1057 while (pid
== -1 && save_errno
== EINTR
);
1061 warning ("Child process unexpectedly missing: %s",
1062 safe_strerror (errno
));
1064 /* Claim it exited with unknown signal. */
1065 ourstatus
->kind
= TARGET_WAITKIND_SIGNALLED
;
1066 ourstatus
->value
.sig
= TARGET_SIGNAL_UNKNOWN
;
1067 return minus_one_ptid
;
1070 store_waitstatus (ourstatus
, status
);
1071 return pid_to_ptid (pid
);
1076 /* Stop an active thread, verify it still exists, then resume it. */
1079 stop_and_resume_callback (struct lwp_info
*lp
, void *data
)
1081 struct lwp_info
*ptr
;
1083 if (!lp
->stopped
&& !lp
->signalled
)
1085 stop_callback (lp
, NULL
);
1086 stop_wait_callback (lp
, NULL
);
1087 /* Resume if the lwp still exists. */
1088 for (ptr
= lwp_list
; ptr
; ptr
= ptr
->next
)
1090 resume_callback (lp
, NULL
);
1096 lin_lwp_wait (ptid_t ptid
, struct target_waitstatus
*ourstatus
)
1098 struct lwp_info
*lp
= NULL
;
1101 pid_t pid
= PIDGET (ptid
);
1102 sigset_t flush_mask
;
1104 sigemptyset (&flush_mask
);
1106 /* Make sure SIGCHLD is blocked. */
1107 if (!sigismember (&blocked_mask
, SIGCHLD
))
1109 sigaddset (&blocked_mask
, SIGCHLD
);
1110 sigprocmask (SIG_BLOCK
, &blocked_mask
, NULL
);
1115 /* Make sure there is at least one LWP that has been resumed, at
1116 least if there are any LWPs at all. */
1117 gdb_assert (num_lwps
== 0 || iterate_over_lwps (resumed_callback
, NULL
));
1119 /* First check if there is a LWP with a wait status pending. */
1122 /* Any LWP that's been resumed will do. */
1123 lp
= iterate_over_lwps (status_callback
, NULL
);
1126 status
= lp
->status
;
1129 if (debug_lin_lwp
&& status
)
1130 fprintf_unfiltered (gdb_stdlog
,
1131 "LLW: Using pending wait status %s for %s.\n",
1132 status_to_str (status
),
1133 target_pid_to_str (lp
->ptid
));
1136 /* But if we don't fine one, we'll have to wait, and check both
1137 cloned and uncloned processes. We start with the cloned
1139 options
= __WCLONE
| WNOHANG
;
1141 else if (is_lwp (ptid
))
1144 fprintf_unfiltered (gdb_stdlog
,
1145 "LLW: Waiting for specific LWP %s.\n",
1146 target_pid_to_str (ptid
));
1148 /* We have a specific LWP to check. */
1149 lp
= find_lwp_pid (ptid
);
1151 status
= lp
->status
;
1154 if (debug_lin_lwp
&& status
)
1155 fprintf_unfiltered (gdb_stdlog
,
1156 "LLW: Using pending wait status %s for %s.\n",
1157 status_to_str (status
),
1158 target_pid_to_str (lp
->ptid
));
1160 /* If we have to wait, take into account whether PID is a cloned
1161 process or not. And we have to convert it to something that
1162 the layer beneath us can understand. */
1163 options
= lp
->cloned
? __WCLONE
: 0;
1164 pid
= GET_LWP (ptid
);
1167 if (status
&& lp
->signalled
)
1169 /* A pending SIGSTOP may interfere with the normal stream of
1170 events. In a typical case where interference is a problem,
1171 we have a SIGSTOP signal pending for LWP A while
1172 single-stepping it, encounter an event in LWP B, and take the
1173 pending SIGSTOP while trying to stop LWP A. After processing
1174 the event in LWP B, LWP A is continued, and we'll never see
1175 the SIGTRAP associated with the last time we were
1176 single-stepping LWP A. */
1178 /* Resume the thread. It should halt immediately returning the
1180 registers_changed ();
1181 child_resume (pid_to_ptid (GET_LWP (lp
->ptid
)), lp
->step
,
1184 fprintf_unfiltered (gdb_stdlog
,
1185 "LLW: %s %s, 0, 0 (expect SIGSTOP)\n",
1186 lp
->step
? "PTRACE_SINGLESTEP" : "PTRACE_CONT",
1187 target_pid_to_str (lp
->ptid
));
1189 gdb_assert (lp
->resumed
);
1191 /* This should catch the pending SIGSTOP. */
1192 stop_wait_callback (lp
, NULL
);
1195 set_sigint_trap (); /* Causes SIGINT to be passed on to the
1196 attached process. */
1203 lwpid
= waitpid (pid
, &status
, options
);
1206 gdb_assert (pid
== -1 || lwpid
== pid
);
1210 fprintf_unfiltered (gdb_stdlog
,
1211 "LLW: waitpid %ld received %s\n",
1212 (long) lwpid
, status_to_str (status
));
1215 lp
= find_lwp_pid (pid_to_ptid (lwpid
));
1217 /* Check for stop events reported by a process we didn't
1218 already know about - anything not already in our LWP
1221 If we're expecting to receive stopped processes after
1222 fork, vfork, and clone events, then we'll just add the
1223 new one to our list and go back to waiting for the event
1224 to be reported - the stopped process might be returned
1225 from waitpid before or after the event is. */
1226 if (WIFSTOPPED (status
) && !lp
)
1228 linux_record_stopped_pid (lwpid
);
1233 /* Make sure we don't report an event for the exit of an LWP not in
1234 our list, i.e. not part of the current process. This can happen
1235 if we detach from a program we original forked and then it
1237 if (!WIFSTOPPED (status
) && !lp
)
1243 /* NOTE drow/2003-06-17: This code seems to be meant for debugging
1244 CLONE_PTRACE processes which do not use the thread library -
1245 otherwise we wouldn't find the new LWP this way. That doesn't
1246 currently work, and the following code is currently unreachable
1247 due to the two blocks above. If it's fixed some day, this code
1248 should be broken out into a function so that we can also pick up
1249 LWPs from the new interface. */
1252 lp
= add_lwp (BUILD_LWP (lwpid
, GET_PID (inferior_ptid
)));
1253 if (options
& __WCLONE
)
1258 gdb_assert (WIFSTOPPED (status
)
1259 && WSTOPSIG (status
) == SIGSTOP
);
1262 if (!in_thread_list (inferior_ptid
))
1264 inferior_ptid
= BUILD_LWP (GET_PID (inferior_ptid
),
1265 GET_PID (inferior_ptid
));
1266 add_thread (inferior_ptid
);
1269 add_thread (lp
->ptid
);
1270 printf_unfiltered ("[New %s]\n",
1271 target_pid_to_str (lp
->ptid
));
1275 /* Check if the thread has exited. */
1276 if ((WIFEXITED (status
) || WIFSIGNALED (status
)) && num_lwps
> 1)
1278 if (in_thread_list (lp
->ptid
))
1280 /* Core GDB cannot deal with us deleting the current
1282 if (!ptid_equal (lp
->ptid
, inferior_ptid
))
1283 delete_thread (lp
->ptid
);
1284 printf_unfiltered ("[%s exited]\n",
1285 target_pid_to_str (lp
->ptid
));
1288 /* If this is the main thread, we must stop all threads and
1289 verify if they are still alive. This is because in the nptl
1290 thread model, there is no signal issued for exiting LWPs
1291 other than the main thread. We only get the main thread
1292 exit signal once all child threads have already exited.
1293 If we stop all the threads and use the stop_wait_callback
1294 to check if they have exited we can determine whether this
1295 signal should be ignored or whether it means the end of the
1296 debugged application, regardless of which threading model
1298 if (GET_PID (lp
->ptid
) == GET_LWP (lp
->ptid
))
1301 iterate_over_lwps (stop_and_resume_callback
, NULL
);
1305 fprintf_unfiltered (gdb_stdlog
,
1306 "LLW: %s exited.\n",
1307 target_pid_to_str (lp
->ptid
));
1309 delete_lwp (lp
->ptid
);
1311 /* If there is at least one more LWP, then the exit signal
1312 was not the end of the debugged application and should be
1316 /* Make sure there is at least one thread running. */
1317 gdb_assert (iterate_over_lwps (running_callback
, NULL
));
1319 /* Discard the event. */
1325 /* Check if the current LWP has previously exited. In the nptl
1326 thread model, LWPs other than the main thread do not issue
1327 signals when they exit so we must check whenever the thread
1328 has stopped. A similar check is made in stop_wait_callback(). */
1329 if (num_lwps
> 1 && !lin_lwp_thread_alive (lp
->ptid
))
1331 if (in_thread_list (lp
->ptid
))
1333 /* Core GDB cannot deal with us deleting the current
1335 if (!ptid_equal (lp
->ptid
, inferior_ptid
))
1336 delete_thread (lp
->ptid
);
1337 printf_unfiltered ("[%s exited]\n",
1338 target_pid_to_str (lp
->ptid
));
1341 fprintf_unfiltered (gdb_stdlog
,
1342 "LLW: %s exited.\n",
1343 target_pid_to_str (lp
->ptid
));
1345 delete_lwp (lp
->ptid
);
1347 /* Make sure there is at least one thread running. */
1348 gdb_assert (iterate_over_lwps (running_callback
, NULL
));
1350 /* Discard the event. */
1355 /* Make sure we don't report a SIGSTOP that we sent
1356 ourselves in an attempt to stop an LWP. */
1358 && WIFSTOPPED (status
) && WSTOPSIG (status
) == SIGSTOP
)
1361 fprintf_unfiltered (gdb_stdlog
,
1362 "LLW: Delayed SIGSTOP caught for %s.\n",
1363 target_pid_to_str (lp
->ptid
));
1365 /* This is a delayed SIGSTOP. */
1368 registers_changed ();
1369 child_resume (pid_to_ptid (GET_LWP (lp
->ptid
)), lp
->step
,
1372 fprintf_unfiltered (gdb_stdlog
,
1373 "LLW: %s %s, 0, 0 (discard SIGSTOP)\n",
1375 "PTRACE_SINGLESTEP" : "PTRACE_CONT",
1376 target_pid_to_str (lp
->ptid
));
1379 gdb_assert (lp
->resumed
);
1381 /* Discard the event. */
1391 /* Alternate between checking cloned and uncloned processes. */
1392 options
^= __WCLONE
;
1394 /* And suspend every time we have checked both. */
1395 if (options
& __WCLONE
)
1396 sigsuspend (&suspend_mask
);
1399 /* We shouldn't end up here unless we want to try again. */
1400 gdb_assert (status
== 0);
1403 clear_sigio_trap ();
1404 clear_sigint_trap ();
1408 /* Don't report signals that GDB isn't interested in, such as
1409 signals that are neither printed nor stopped upon. Stopping all
1410 threads can be a bit time-consuming so if we want decent
1411 performance with heavily multi-threaded programs, especially when
1412 they're using a high frequency timer, we'd better avoid it if we
1415 if (WIFSTOPPED (status
))
1417 int signo
= target_signal_from_host (WSTOPSIG (status
));
1419 if (signal_stop_state (signo
) == 0
1420 && signal_print_state (signo
) == 0
1421 && signal_pass_state (signo
) == 1)
1423 /* FIMXE: kettenis/2001-06-06: Should we resume all threads
1424 here? It is not clear we should. GDB may not expect
1425 other threads to run. On the other hand, not resuming
1426 newly attached threads may cause an unwanted delay in
1427 getting them running. */
1428 registers_changed ();
1429 child_resume (pid_to_ptid (GET_LWP (lp
->ptid
)), lp
->step
, signo
);
1431 fprintf_unfiltered (gdb_stdlog
,
1432 "LLW: %s %s, %s (preempt 'handle')\n",
1434 "PTRACE_SINGLESTEP" : "PTRACE_CONT",
1435 target_pid_to_str (lp
->ptid
),
1436 signo
? strsignal (signo
) : "0");
1442 if (signo
== TARGET_SIGNAL_INT
&& signal_pass_state (signo
) == 0)
1444 /* If ^C/BREAK is typed at the tty/console, SIGINT gets
1445 forwarded to the entire process group, that is, all LWP's
1446 will receive it. Since we only want to report it once,
1447 we try to flush it from all LWPs except this one. */
1448 sigaddset (&flush_mask
, SIGINT
);
1452 /* This LWP is stopped now. */
1456 fprintf_unfiltered (gdb_stdlog
, "LLW: Candidate event %s in %s.\n",
1457 status_to_str (status
), target_pid_to_str (lp
->ptid
));
1459 /* Now stop all other LWP's ... */
1460 iterate_over_lwps (stop_callback
, NULL
);
1462 /* ... and wait until all of them have reported back that they're no
1464 iterate_over_lwps (stop_wait_callback
, &flush_mask
);
1466 /* If we're not waiting for a specific LWP, choose an event LWP from
1467 among those that have had events. Giving equal priority to all
1468 LWPs that have had events helps prevent starvation. */
1470 select_event_lwp (&lp
, &status
);
1472 /* Now that we've selected our final event LWP, cancel any
1473 breakpoints in other LWPs that have hit a GDB breakpoint. See
1474 the comment in cancel_breakpoints_callback to find out why. */
1475 iterate_over_lwps (cancel_breakpoints_callback
, lp
);
1477 /* If we're not running in "threaded" mode, we'll report the bare
1480 if (WIFSTOPPED (status
) && WSTOPSIG (status
) == SIGTRAP
)
1482 trap_ptid
= (threaded
? lp
->ptid
: pid_to_ptid (GET_LWP (lp
->ptid
)));
1484 fprintf_unfiltered (gdb_stdlog
,
1485 "LLW: trap_ptid is %s.\n",
1486 target_pid_to_str (trap_ptid
));
1489 trap_ptid
= null_ptid
;
1491 store_waitstatus (ourstatus
, status
);
1492 return (threaded
? lp
->ptid
: pid_to_ptid (GET_LWP (lp
->ptid
)));
1496 kill_callback (struct lwp_info
*lp
, void *data
)
1499 ptrace (PTRACE_KILL
, GET_LWP (lp
->ptid
), 0, 0);
1501 fprintf_unfiltered (gdb_stdlog
,
1502 "KC: PTRACE_KILL %s, 0, 0 (%s)\n",
1503 target_pid_to_str (lp
->ptid
),
1504 errno
? safe_strerror (errno
) : "OK");
1510 kill_wait_callback (struct lwp_info
*lp
, void *data
)
1514 /* We must make sure that there are no pending events (delayed
1515 SIGSTOPs, pending SIGTRAPs, etc.) to make sure the current
1516 program doesn't interfere with any following debugging session. */
1518 /* For cloned processes we must check both with __WCLONE and
1519 without, since the exit status of a cloned process isn't reported
1525 pid
= waitpid (GET_LWP (lp
->ptid
), NULL
, __WCLONE
);
1526 if (pid
!= (pid_t
) -1 && debug_lin_lwp
)
1528 fprintf_unfiltered (gdb_stdlog
,
1529 "KWC: wait %s received unknown.\n",
1530 target_pid_to_str (lp
->ptid
));
1533 while (pid
== GET_LWP (lp
->ptid
));
1535 gdb_assert (pid
== -1 && errno
== ECHILD
);
1540 pid
= waitpid (GET_LWP (lp
->ptid
), NULL
, 0);
1541 if (pid
!= (pid_t
) -1 && debug_lin_lwp
)
1543 fprintf_unfiltered (gdb_stdlog
,
1544 "KWC: wait %s received unk.\n",
1545 target_pid_to_str (lp
->ptid
));
1548 while (pid
== GET_LWP (lp
->ptid
));
1550 gdb_assert (pid
== -1 && errno
== ECHILD
);
1557 /* Kill all LWP's ... */
1558 iterate_over_lwps (kill_callback
, NULL
);
1560 /* ... and wait until we've flushed all events. */
1561 iterate_over_lwps (kill_wait_callback
, NULL
);
1563 target_mourn_inferior ();
1567 lin_lwp_create_inferior (char *exec_file
, char *allargs
, char **env
)
1569 child_ops
.to_create_inferior (exec_file
, allargs
, env
);
1573 lin_lwp_mourn_inferior (void)
1575 trap_ptid
= null_ptid
;
1577 /* Destroy LWP info; it's no longer valid. */
1580 /* Restore the original signal mask. */
1581 sigprocmask (SIG_SETMASK
, &normal_mask
, NULL
);
1582 sigemptyset (&blocked_mask
);
1584 child_ops
.to_mourn_inferior ();
1588 lin_lwp_xfer_memory (CORE_ADDR memaddr
, char *myaddr
, int len
, int write
,
1589 struct mem_attrib
*attrib
, struct target_ops
*target
)
1591 struct cleanup
*old_chain
= save_inferior_ptid ();
1594 if (is_lwp (inferior_ptid
))
1595 inferior_ptid
= pid_to_ptid (GET_LWP (inferior_ptid
));
1597 xfer
= linux_proc_xfer_memory (memaddr
, myaddr
, len
, write
, attrib
, target
);
1599 xfer
= child_xfer_memory (memaddr
, myaddr
, len
, write
, attrib
, target
);
1601 do_cleanups (old_chain
);
1606 lin_lwp_thread_alive (ptid_t ptid
)
1608 gdb_assert (is_lwp (ptid
));
1611 ptrace (PTRACE_PEEKUSER
, GET_LWP (ptid
), 0, 0);
1613 fprintf_unfiltered (gdb_stdlog
,
1614 "LLTA: PTRACE_PEEKUSER %s, 0, 0 (%s)\n",
1615 target_pid_to_str (ptid
),
1616 errno
? safe_strerror (errno
) : "OK");
1624 lin_lwp_pid_to_str (ptid_t ptid
)
1626 static char buf
[64];
1630 snprintf (buf
, sizeof (buf
), "LWP %ld", GET_LWP (ptid
));
1634 return normal_pid_to_str (ptid
);
1638 init_lin_lwp_ops (void)
1641 lin_lwp_ops
.to_open
= lin_lwp_open
;
1643 lin_lwp_ops
.to_shortname
= "lwp-layer";
1644 lin_lwp_ops
.to_longname
= "lwp-layer";
1645 lin_lwp_ops
.to_doc
= "Low level threads support (LWP layer)";
1646 lin_lwp_ops
.to_attach
= lin_lwp_attach
;
1647 lin_lwp_ops
.to_detach
= lin_lwp_detach
;
1648 lin_lwp_ops
.to_resume
= lin_lwp_resume
;
1649 lin_lwp_ops
.to_wait
= lin_lwp_wait
;
1650 /* fetch_inferior_registers and store_inferior_registers will
1651 honor the LWP id, so we can use them directly. */
1652 lin_lwp_ops
.to_fetch_registers
= fetch_inferior_registers
;
1653 lin_lwp_ops
.to_store_registers
= store_inferior_registers
;
1654 lin_lwp_ops
.to_xfer_memory
= lin_lwp_xfer_memory
;
1655 lin_lwp_ops
.to_kill
= lin_lwp_kill
;
1656 lin_lwp_ops
.to_create_inferior
= lin_lwp_create_inferior
;
1657 lin_lwp_ops
.to_mourn_inferior
= lin_lwp_mourn_inferior
;
1658 lin_lwp_ops
.to_thread_alive
= lin_lwp_thread_alive
;
1659 lin_lwp_ops
.to_pid_to_str
= lin_lwp_pid_to_str
;
1660 lin_lwp_ops
.to_stratum
= thread_stratum
;
1661 lin_lwp_ops
.to_has_thread_control
= tc_schedlock
;
1662 lin_lwp_ops
.to_magic
= OPS_MAGIC
;
1666 sigchld_handler (int signo
)
1668 /* Do nothing. The only reason for this handler is that it allows
1669 us to use sigsuspend in lin_lwp_wait above to wait for the
1670 arrival of a SIGCHLD. */
1674 _initialize_lin_lwp (void)
1676 struct sigaction action
;
1678 extern void thread_db_init (struct target_ops
*);
1680 init_lin_lwp_ops ();
1681 add_target (&lin_lwp_ops
);
1682 thread_db_init (&lin_lwp_ops
);
1684 /* Save the original signal mask. */
1685 sigprocmask (SIG_SETMASK
, NULL
, &normal_mask
);
1687 action
.sa_handler
= sigchld_handler
;
1688 sigemptyset (&action
.sa_mask
);
1689 action
.sa_flags
= 0;
1690 sigaction (SIGCHLD
, &action
, NULL
);
1692 /* Make sure we don't block SIGCHLD during a sigsuspend. */
1693 sigprocmask (SIG_SETMASK
, NULL
, &suspend_mask
);
1694 sigdelset (&suspend_mask
, SIGCHLD
);
1696 sigemptyset (&blocked_mask
);
1698 add_show_from_set (add_set_cmd ("lin-lwp", no_class
, var_zinteger
,
1699 (char *) &debug_lin_lwp
,
1700 "Set debugging of GNU/Linux lwp module.\n\
1701 Enables printf debugging output.\n", &setdebuglist
), &showdebuglist
);
1705 /* FIXME: kettenis/2000-08-26: The stuff on this page is specific to
1706 the GNU/Linux Threads library and therefore doesn't really belong
1709 /* Read variable NAME in the target and return its value if found.
1710 Otherwise return zero. It is assumed that the type of the variable
1714 get_signo (const char *name
)
1716 struct minimal_symbol
*ms
;
1719 ms
= lookup_minimal_symbol (name
, NULL
, NULL
);
1723 if (target_read_memory (SYMBOL_VALUE_ADDRESS (ms
), (char *) &signo
,
1724 sizeof (signo
)) != 0)
1730 /* Return the set of signals used by the threads library in *SET. */
1733 lin_thread_get_thread_signals (sigset_t
*set
)
1735 struct sigaction action
;
1736 int restart
, cancel
;
1740 restart
= get_signo ("__pthread_sig_restart");
1744 cancel
= get_signo ("__pthread_sig_cancel");
1748 sigaddset (set
, restart
);
1749 sigaddset (set
, cancel
);
1751 /* The GNU/Linux Threads library makes terminating threads send a
1752 special "cancel" signal instead of SIGCHLD. Make sure we catch
1753 those (to prevent them from terminating GDB itself, which is
1754 likely to be their default action) and treat them the same way as
1757 action
.sa_handler
= sigchld_handler
;
1758 sigemptyset (&action
.sa_mask
);
1759 action
.sa_flags
= 0;
1760 sigaction (cancel
, &action
, NULL
);
1762 /* We block the "cancel" signal throughout this code ... */
1763 sigaddset (&blocked_mask
, cancel
);
1764 sigprocmask (SIG_BLOCK
, &blocked_mask
, NULL
);
1766 /* ... except during a sigsuspend. */
1767 sigdelset (&suspend_mask
, cancel
);