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 /* On GNU/Linux there are no real LWP's. The closest thing to LWP's
44 are processes sharing the same VM space. A multi-threaded process
45 is basically a group of such processes. However, such a grouping
46 is almost entirely a user-space issue; the kernel doesn't enforce
47 such a grouping at all (this might change in the future). In
48 general, we'll rely on the threads library (i.e. the GNU/Linux
49 Threads library) to provide such a grouping.
51 It is perfectly well possible to write a multi-threaded application
52 without the assistance of a threads library, by using the clone
53 system call directly. This module should be able to give some
54 rudimentary support for debugging such applications if developers
55 specify the CLONE_PTRACE flag in the clone system call, and are
56 using the Linux kernel 2.4 or above.
58 Note that there are some peculiarities in GNU/Linux that affect
61 - In general one should specify the __WCLONE flag to waitpid in
62 order to make it report events for any of the cloned processes
63 (and leave it out for the initial process). However, if a cloned
64 process has exited the exit status is only reported if the
65 __WCLONE flag is absent. Linux kernel 2.4 has a __WALL flag, but
66 we cannot use it since GDB must work on older systems too.
68 - When a traced, cloned process exits and is waited for by the
69 debugger, the kernel reassigns it to the original parent and
70 keeps it around as a "zombie". Somehow, the GNU/Linux Threads
71 library doesn't notice this, which leads to the "zombie problem":
72 When debugged a multi-threaded process that spawns a lot of
73 threads will run out of processes, even if the threads exit,
74 because the "zombies" stay around. */
76 /* Structure describing a LWP. */
79 /* The process id of the LWP. This is a combination of the LWP id
80 and overall process id. */
83 /* Non-zero if this LWP is cloned. In this context "cloned" means
84 that the LWP is reporting to its parent using a signal other than
88 /* Non-zero if we sent this LWP a SIGSTOP (but the LWP didn't report
92 /* Non-zero if this LWP is stopped. */
95 /* Non-zero if this LWP will be/has been resumed. Note that an LWP
96 can be marked both as stopped and resumed at the same time. This
97 happens if we try to resume an LWP that has a wait status
98 pending. We shouldn't let the LWP run until that wait status has
99 been processed, but we should not report that wait status if GDB
100 didn't try to let the LWP run. */
103 /* If non-zero, a pending wait status. */
106 /* Non-zero if we were stepping this LWP. */
109 /* Next LWP in list. */
110 struct lwp_info
*next
;
113 /* List of known LWPs. */
114 static struct lwp_info
*lwp_list
;
116 /* Number of LWPs in the list. */
119 /* Non-zero if we're running in "threaded" mode. */
123 #define GET_LWP(ptid) ptid_get_lwp (ptid)
124 #define GET_PID(ptid) ptid_get_pid (ptid)
125 #define is_lwp(ptid) (GET_LWP (ptid) != 0)
126 #define BUILD_LWP(lwp, pid) ptid_build (pid, lwp, 0)
128 /* If the last reported event was a SIGTRAP, this variable is set to
129 the process id of the LWP/thread that got it. */
133 /* This module's target-specific operations. */
134 static struct target_ops lin_lwp_ops
;
136 /* The standard child operations. */
137 extern struct target_ops child_ops
;
139 /* Since we cannot wait (in lin_lwp_wait) for the initial process and
140 any cloned processes with a single call to waitpid, we have to use
141 the WNOHANG flag and call waitpid in a loop. To optimize
142 things a bit we use `sigsuspend' to wake us up when a process has
143 something to report (it will send us a SIGCHLD if it has). To make
144 this work we have to juggle with the signal mask. We save the
145 original signal mask such that we can restore it before creating a
146 new process in order to avoid blocking certain signals in the
147 inferior. We then block SIGCHLD during the waitpid/sigsuspend
150 /* Original signal mask. */
151 static sigset_t normal_mask
;
153 /* Signal mask for use with sigsuspend in lin_lwp_wait, initialized in
154 _initialize_lin_lwp. */
155 static sigset_t suspend_mask
;
157 /* Signals to block to make that sigsuspend work. */
158 static sigset_t blocked_mask
;
161 /* Prototypes for local functions. */
162 static int stop_wait_callback (struct lwp_info
*lp
, void *data
);
163 static int lin_lwp_thread_alive (ptid_t ptid
);
165 /* Convert wait status STATUS to a string. Used for printing debug
169 status_to_str (int status
)
173 if (WIFSTOPPED (status
))
174 snprintf (buf
, sizeof (buf
), "%s (stopped)",
175 strsignal (WSTOPSIG (status
)));
176 else if (WIFSIGNALED (status
))
177 snprintf (buf
, sizeof (buf
), "%s (terminated)",
178 strsignal (WSTOPSIG (status
)));
180 snprintf (buf
, sizeof (buf
), "%d (exited)", WEXITSTATUS (status
));
185 /* Initialize the list of LWPs. Note that this module, contrary to
186 what GDB's generic threads layer does for its thread list,
187 re-initializes the LWP lists whenever we mourn or detach (which
188 doesn't involve mourning) the inferior. */
193 struct lwp_info
*lp
, *lpnext
;
195 for (lp
= lwp_list
; lp
; lp
= lpnext
)
206 /* Add the LWP specified by PID to the list. If this causes the
207 number of LWPs to become larger than one, go into "threaded" mode.
208 Return a pointer to the structure describing the new LWP. */
210 static struct lwp_info
*
211 add_lwp (ptid_t ptid
)
215 gdb_assert (is_lwp (ptid
));
217 lp
= (struct lwp_info
*) xmalloc (sizeof (struct lwp_info
));
219 memset (lp
, 0, sizeof (struct lwp_info
));
231 /* Remove the LWP specified by PID from the list. */
234 delete_lwp (ptid_t ptid
)
236 struct lwp_info
*lp
, *lpprev
;
240 for (lp
= lwp_list
; lp
; lpprev
= lp
, lp
= lp
->next
)
241 if (ptid_equal (lp
->ptid
, ptid
))
247 /* We don't go back to "non-threaded" mode if the number of threads
248 becomes less than two. */
252 lpprev
->next
= lp
->next
;
259 /* Return a pointer to the structure describing the LWP corresponding
260 to PID. If no corresponding LWP could be found, return NULL. */
262 static struct lwp_info
*
263 find_lwp_pid (ptid_t ptid
)
269 lwp
= GET_LWP (ptid
);
271 lwp
= GET_PID (ptid
);
273 for (lp
= lwp_list
; lp
; lp
= lp
->next
)
274 if (lwp
== GET_LWP (lp
->ptid
))
280 /* Call CALLBACK with its second argument set to DATA for every LWP in
281 the list. If CALLBACK returns 1 for a particular LWP, return a
282 pointer to the structure describing that LWP immediately.
283 Otherwise return NULL. */
286 iterate_over_lwps (int (*callback
) (struct lwp_info
*, void *), void *data
)
288 struct lwp_info
*lp
, *lpnext
;
290 for (lp
= lwp_list
; lp
; lp
= lpnext
)
293 if ((*callback
) (lp
, data
))
303 lin_lwp_open (char *args
, int from_tty
)
305 push_target (&lin_lwp_ops
);
309 /* Attach to the LWP specified by PID. If VERBOSE is non-zero, print
310 a message telling the user that a new LWP has been added to the
314 lin_lwp_attach_lwp (ptid_t ptid
, int verbose
)
318 gdb_assert (is_lwp (ptid
));
320 /* Make sure SIGCHLD is blocked. We don't want SIGCHLD events
321 to interrupt either the ptrace() or waitpid() calls below. */
322 if (!sigismember (&blocked_mask
, SIGCHLD
))
324 sigaddset (&blocked_mask
, SIGCHLD
);
325 sigprocmask (SIG_BLOCK
, &blocked_mask
, NULL
);
329 printf_filtered ("[New %s]\n", target_pid_to_str (ptid
));
331 lp
= find_lwp_pid (ptid
);
335 /* We assume that we're already attached to any LWP that has an
336 id equal to the overall process id. */
337 if (GET_LWP (ptid
) != GET_PID (ptid
))
342 if (ptrace (PTRACE_ATTACH
, GET_LWP (ptid
), 0, 0) < 0)
343 error ("Can't attach %s: %s", target_pid_to_str (ptid
),
344 safe_strerror (errno
));
347 fprintf_unfiltered (gdb_stdlog
,
348 "LLAL: PTRACE_ATTACH %s, 0, 0 (OK)\n",
349 target_pid_to_str (ptid
));
351 pid
= waitpid (GET_LWP (ptid
), &status
, 0);
352 if (pid
== -1 && errno
== ECHILD
)
354 /* Try again with __WCLONE to check cloned processes. */
355 pid
= waitpid (GET_LWP (ptid
), &status
, __WCLONE
);
359 gdb_assert (pid
== GET_LWP (ptid
)
360 && WIFSTOPPED (status
) && WSTOPSIG (status
));
366 fprintf_unfiltered (gdb_stdlog
,
367 "LLAL: waitpid %s received %s\n",
368 target_pid_to_str (ptid
),
369 status_to_str (status
));
374 /* We assume that the LWP representing the original process
375 is already stopped. Mark it as stopped in the data structure
376 that the lin-lwp layer uses to keep track of threads. Note
377 that this won't have already been done since the main thread
378 will have, we assume, been stopped by an attach from a
385 lin_lwp_attach (char *args
, int from_tty
)
391 /* FIXME: We should probably accept a list of process id's, and
392 attach all of them. */
393 child_ops
.to_attach (args
, from_tty
);
395 /* Add the initial process as the first LWP to the list. */
396 lp
= add_lwp (BUILD_LWP (GET_PID (inferior_ptid
), GET_PID (inferior_ptid
)));
398 /* Make sure the initial process is stopped. The user-level threads
399 layer might want to poke around in the inferior, and that won't
400 work if things haven't stabilized yet. */
401 pid
= waitpid (GET_PID (inferior_ptid
), &status
, 0);
402 if (pid
== -1 && errno
== ECHILD
)
404 warning ("%s is a cloned process", target_pid_to_str (inferior_ptid
));
406 /* Try again with __WCLONE to check cloned processes. */
407 pid
= waitpid (GET_PID (inferior_ptid
), &status
, __WCLONE
);
411 gdb_assert (pid
== GET_PID (inferior_ptid
)
412 && WIFSTOPPED (status
) && WSTOPSIG (status
) == SIGSTOP
);
416 /* Fake the SIGSTOP that core GDB expects. */
417 lp
->status
= W_STOPCODE (SIGSTOP
);
421 fprintf_unfiltered (gdb_stdlog
,
422 "LLA: waitpid %ld, faking SIGSTOP\n", (long) pid
);
427 detach_callback (struct lwp_info
*lp
, void *data
)
429 gdb_assert (lp
->status
== 0 || WIFSTOPPED (lp
->status
));
431 if (debug_lin_lwp
&& lp
->status
)
432 fprintf_unfiltered (gdb_stdlog
, "DC: Pending %s for %s on detach.\n",
433 strsignal (WSTOPSIG (lp
->status
)),
434 target_pid_to_str (lp
->ptid
));
436 while (lp
->signalled
&& lp
->stopped
)
439 if (ptrace (PTRACE_CONT
, GET_LWP (lp
->ptid
), 0,
440 WSTOPSIG (lp
->status
)) < 0)
441 error ("Can't continue %s: %s", target_pid_to_str (lp
->ptid
),
442 safe_strerror (errno
));
445 fprintf_unfiltered (gdb_stdlog
,
446 "DC: PTRACE_CONTINUE (%s, 0, %s) (OK)\n",
447 target_pid_to_str (lp
->ptid
),
448 status_to_str (lp
->status
));
453 stop_wait_callback (lp
, NULL
);
455 gdb_assert (lp
->status
== 0 || WIFSTOPPED (lp
->status
));
458 /* We don't actually detach from the LWP that has an id equal to the
459 overall process id just yet. */
460 if (GET_LWP (lp
->ptid
) != GET_PID (lp
->ptid
))
463 if (ptrace (PTRACE_DETACH
, GET_LWP (lp
->ptid
), 0,
464 WSTOPSIG (lp
->status
)) < 0)
465 error ("Can't detach %s: %s", target_pid_to_str (lp
->ptid
),
466 safe_strerror (errno
));
469 fprintf_unfiltered (gdb_stdlog
,
470 "PTRACE_DETACH (%s, %s, 0) (OK)\n",
471 target_pid_to_str (lp
->ptid
),
472 strsignal (WSTOPSIG (lp
->status
)));
474 delete_lwp (lp
->ptid
);
481 lin_lwp_detach (char *args
, int from_tty
)
483 iterate_over_lwps (detach_callback
, NULL
);
485 /* Only the initial process should be left right now. */
486 gdb_assert (num_lwps
== 1);
488 trap_ptid
= null_ptid
;
490 /* Destroy LWP info; it's no longer valid. */
493 /* Restore the original signal mask. */
494 sigprocmask (SIG_SETMASK
, &normal_mask
, NULL
);
495 sigemptyset (&blocked_mask
);
497 inferior_ptid
= pid_to_ptid (GET_PID (inferior_ptid
));
498 child_ops
.to_detach (args
, from_tty
);
505 resume_callback (struct lwp_info
*lp
, void *data
)
507 if (lp
->stopped
&& lp
->status
== 0)
509 struct thread_info
*tp
;
511 child_resume (pid_to_ptid (GET_LWP (lp
->ptid
)), 0, TARGET_SIGNAL_0
);
513 fprintf_unfiltered (gdb_stdlog
,
514 "RC: PTRACE_CONT %s, 0, 0 (resume sibling)\n",
515 target_pid_to_str (lp
->ptid
));
524 resume_clear_callback (struct lwp_info
*lp
, void *data
)
531 resume_set_callback (struct lwp_info
*lp
, void *data
)
538 lin_lwp_resume (ptid_t ptid
, int step
, enum target_signal signo
)
543 /* A specific PTID means `step only this process id'. */
544 resume_all
= (PIDGET (ptid
) == -1);
547 iterate_over_lwps (resume_set_callback
, NULL
);
549 iterate_over_lwps (resume_clear_callback
, NULL
);
551 /* If PID is -1, it's the current inferior that should be
552 handled specially. */
553 if (PIDGET (ptid
) == -1)
554 ptid
= inferior_ptid
;
556 lp
= find_lwp_pid (ptid
);
559 ptid
= pid_to_ptid (GET_LWP (lp
->ptid
));
561 /* Remember if we're stepping. */
564 /* Mark this LWP as resumed. */
567 /* If we have a pending wait status for this thread, there is no
568 point in resuming the process. */
571 /* FIXME: What should we do if we are supposed to continue
572 this thread with a signal? */
573 gdb_assert (signo
== TARGET_SIGNAL_0
);
577 /* Mark LWP as not stopped to prevent it from being continued by
583 iterate_over_lwps (resume_callback
, NULL
);
585 child_resume (ptid
, step
, signo
);
587 fprintf_unfiltered (gdb_stdlog
,
588 "LLR: %s %s, %s (resume event thread)\n",
589 step
? "PTRACE_SINGLESTEP" : "PTRACE_CONT",
590 target_pid_to_str (ptid
),
591 signo
? strsignal (signo
) : "0");
595 /* Issue kill to specified lwp. */
597 static int tkill_failed
;
600 kill_lwp (int lwpid
, int signo
)
604 /* Use tkill, if possible, in case we are using nptl threads. If tkill
605 fails, then we are not using nptl threads and we should be using kill. */
607 #ifdef HAVE_TKILL_SYSCALL
610 int ret
= syscall (__NR_tkill
, lwpid
, signo
);
618 return kill (lwpid
, signo
);
621 /* Send a SIGSTOP to LP. */
624 stop_callback (struct lwp_info
*lp
, void *data
)
626 if (!lp
->stopped
&& !lp
->signalled
)
632 fprintf_unfiltered (gdb_stdlog
,
633 "SC: kill %s **<SIGSTOP>**\n",
634 target_pid_to_str (lp
->ptid
));
637 ret
= kill_lwp (GET_LWP (lp
->ptid
), SIGSTOP
);
640 fprintf_unfiltered (gdb_stdlog
,
641 "SC: lwp kill %d %s\n",
643 errno
? safe_strerror (errno
) : "ERRNO-OK");
647 gdb_assert (lp
->status
== 0);
653 /* Wait until LP is stopped. If DATA is non-null it is interpreted as
654 a pointer to a set of signals to be flushed immediately. */
657 stop_wait_callback (struct lwp_info
*lp
, void *data
)
659 sigset_t
*flush_mask
= data
;
661 if (!lp
->stopped
&& lp
->signalled
)
666 gdb_assert (lp
->status
== 0);
668 pid
= waitpid (GET_LWP (lp
->ptid
), &status
, 0);
669 if (pid
== -1 && errno
== ECHILD
)
671 pid
= waitpid (GET_LWP (lp
->ptid
), &status
, __WCLONE
);
672 if (pid
== -1 && errno
== ECHILD
)
674 /* The thread has previously exited. We need to delete it now
675 because in the case of nptl threads, there won't be an
676 exit event unless it is the main thread. */
678 fprintf_unfiltered (gdb_stdlog
,
680 target_pid_to_str (lp
->ptid
));
681 delete_lwp (lp
->ptid
);
686 gdb_assert (pid
== GET_LWP (lp
->ptid
));
690 fprintf_unfiltered (gdb_stdlog
,
691 "SWC: waitpid %s received %s\n",
692 target_pid_to_str (lp
->ptid
),
693 status_to_str (status
));
696 /* Check if the thread has exited. */
697 if (WIFEXITED (status
) || WIFSIGNALED (status
))
699 gdb_assert (num_lwps
> 1);
701 if (in_thread_list (lp
->ptid
))
703 /* Core GDB cannot deal with us deleting the current
705 if (!ptid_equal (lp
->ptid
, inferior_ptid
))
706 delete_thread (lp
->ptid
);
707 printf_unfiltered ("[%s exited]\n",
708 target_pid_to_str (lp
->ptid
));
711 fprintf_unfiltered (gdb_stdlog
,
713 target_pid_to_str (lp
->ptid
));
715 delete_lwp (lp
->ptid
);
719 /* Check if the current LWP has previously exited. For nptl threads,
720 there is no exit signal issued for LWPs that are not the
721 main thread so we should check whenever the thread is stopped. */
722 if (!lin_lwp_thread_alive (lp
->ptid
))
724 if (in_thread_list (lp
->ptid
))
726 /* Core GDB cannot deal with us deleting the current
728 if (!ptid_equal (lp
->ptid
, inferior_ptid
))
729 delete_thread (lp
->ptid
);
730 printf_unfiltered ("[%s exited]\n",
731 target_pid_to_str (lp
->ptid
));
734 fprintf_unfiltered (gdb_stdlog
,
735 "SWC: %s already exited.\n",
736 target_pid_to_str (lp
->ptid
));
738 delete_lwp (lp
->ptid
);
742 gdb_assert (WIFSTOPPED (status
));
744 /* Ignore any signals in FLUSH_MASK. */
745 if (flush_mask
&& sigismember (flush_mask
, WSTOPSIG (status
)))
748 ptrace (PTRACE_CONT
, GET_LWP (lp
->ptid
), 0, 0);
750 fprintf_unfiltered (gdb_stdlog
,
751 "PTRACE_CONT %s, 0, 0 (%s)\n",
752 target_pid_to_str (lp
->ptid
),
753 errno
? safe_strerror (errno
) : "OK");
755 return stop_wait_callback (lp
, flush_mask
);
758 if (WSTOPSIG (status
) != SIGSTOP
)
760 if (WSTOPSIG (status
) == SIGTRAP
)
762 /* If a LWP other than the LWP that we're reporting an
763 event for has hit a GDB breakpoint (as opposed to
764 some random trap signal), then just arrange for it to
765 hit it again later. We don't keep the SIGTRAP status
766 and don't forward the SIGTRAP signal to the LWP. We
767 will handle the current event, eventually we will
768 resume all LWPs, and this one will get its breakpoint
771 If we do not do this, then we run the risk that the
772 user will delete or disable the breakpoint, but the
773 thread will have already tripped on it. */
775 /* Now resume this LWP and get the SIGSTOP event. */
777 ptrace (PTRACE_CONT
, GET_LWP (lp
->ptid
), 0, 0);
780 fprintf_unfiltered (gdb_stdlog
,
781 "PTRACE_CONT %s, 0, 0 (%s)\n",
782 target_pid_to_str (lp
->ptid
),
783 errno
? safe_strerror (errno
) : "OK");
785 fprintf_unfiltered (gdb_stdlog
,
786 "SWC: Candidate SIGTRAP event in %s\n",
787 target_pid_to_str (lp
->ptid
));
789 /* Hold the SIGTRAP for handling by lin_lwp_wait. */
790 stop_wait_callback (lp
, data
);
791 /* If there's another event, throw it back into the queue. */
796 fprintf_unfiltered (gdb_stdlog
,
797 "SWC: kill %s, %s\n",
798 target_pid_to_str (lp
->ptid
),
799 status_to_str ((int) status
));
801 kill_lwp (GET_LWP (lp
->ptid
), WSTOPSIG (lp
->status
));
803 /* Save the sigtrap event. */
809 /* The thread was stopped with a signal other than
810 SIGSTOP, and didn't accidentally trip a breakpoint. */
814 fprintf_unfiltered (gdb_stdlog
,
815 "SWC: Pending event %s in %s\n",
816 status_to_str ((int) status
),
817 target_pid_to_str (lp
->ptid
));
819 /* Now resume this LWP and get the SIGSTOP event. */
821 ptrace (PTRACE_CONT
, GET_LWP (lp
->ptid
), 0, 0);
823 fprintf_unfiltered (gdb_stdlog
,
824 "SWC: PTRACE_CONT %s, 0, 0 (%s)\n",
825 target_pid_to_str (lp
->ptid
),
826 errno
? safe_strerror (errno
) : "OK");
828 /* Hold this event/waitstatus while we check to see if
829 there are any more (we still want to get that SIGSTOP). */
830 stop_wait_callback (lp
, data
);
831 /* If the lp->status field is still empty, use it to hold
832 this event. If not, then this event must be returned
833 to the event queue of the LWP. */
840 fprintf_unfiltered (gdb_stdlog
,
841 "SWC: kill %s, %s\n",
842 target_pid_to_str (lp
->ptid
),
843 status_to_str ((int) status
));
845 kill_lwp (GET_LWP (lp
->ptid
), WSTOPSIG (status
));
852 /* We caught the SIGSTOP that we intended to catch, so
853 there's no SIGSTOP pending. */
862 /* Return non-zero if LP has a wait status pending. */
865 status_callback (struct lwp_info
*lp
, void *data
)
867 /* Only report a pending wait status if we pretend that this has
868 indeed been resumed. */
869 return (lp
->status
!= 0 && lp
->resumed
);
872 /* Return non-zero if LP isn't stopped. */
875 running_callback (struct lwp_info
*lp
, void *data
)
877 return (lp
->stopped
== 0);
880 /* Count the LWP's that have had events. */
883 count_events_callback (struct lwp_info
*lp
, void *data
)
887 gdb_assert (count
!= NULL
);
889 /* Count only LWPs that have a SIGTRAP event pending. */
891 && WIFSTOPPED (lp
->status
) && WSTOPSIG (lp
->status
) == SIGTRAP
)
897 /* Select the LWP (if any) that is currently being single-stepped. */
900 select_singlestep_lwp_callback (struct lwp_info
*lp
, void *data
)
902 if (lp
->step
&& lp
->status
!= 0)
908 /* Select the Nth LWP that has had a SIGTRAP event. */
911 select_event_lwp_callback (struct lwp_info
*lp
, void *data
)
913 int *selector
= data
;
915 gdb_assert (selector
!= NULL
);
917 /* Select only LWPs that have a SIGTRAP event pending. */
919 && WIFSTOPPED (lp
->status
) && WSTOPSIG (lp
->status
) == SIGTRAP
)
920 if ((*selector
)-- == 0)
927 cancel_breakpoints_callback (struct lwp_info
*lp
, void *data
)
929 struct lwp_info
*event_lp
= data
;
931 /* Leave the LWP that has been elected to receive a SIGTRAP alone. */
935 /* If a LWP other than the LWP that we're reporting an event for has
936 hit a GDB breakpoint (as opposed to some random trap signal),
937 then just arrange for it to hit it again later. We don't keep
938 the SIGTRAP status and don't forward the SIGTRAP signal to the
939 LWP. We will handle the current event, eventually we will resume
940 all LWPs, and this one will get its breakpoint trap again.
942 If we do not do this, then we run the risk that the user will
943 delete or disable the breakpoint, but the LWP will have already
947 && WIFSTOPPED (lp
->status
) && WSTOPSIG (lp
->status
) == SIGTRAP
948 && breakpoint_inserted_here_p (read_pc_pid (lp
->ptid
) -
949 DECR_PC_AFTER_BREAK
))
952 fprintf_unfiltered (gdb_stdlog
,
953 "CBC: Push back breakpoint for %s\n",
954 target_pid_to_str (lp
->ptid
));
956 /* Back up the PC if necessary. */
957 if (DECR_PC_AFTER_BREAK
)
958 write_pc_pid (read_pc_pid (lp
->ptid
) - DECR_PC_AFTER_BREAK
, lp
->ptid
);
960 /* Throw away the SIGTRAP. */
967 /* Select one LWP out of those that have events pending. */
970 select_event_lwp (struct lwp_info
**orig_lp
, int *status
)
974 struct lwp_info
*event_lp
;
976 /* Record the wait status for the origional LWP. */
977 (*orig_lp
)->status
= *status
;
979 /* Give preference to any LWP that is being single-stepped. */
980 event_lp
= iterate_over_lwps (select_singlestep_lwp_callback
, NULL
);
981 if (event_lp
!= NULL
)
984 fprintf_unfiltered (gdb_stdlog
,
985 "SEL: Select single-step %s\n",
986 target_pid_to_str (event_lp
->ptid
));
990 /* No single-stepping LWP. Select one at random, out of those
991 which have had SIGTRAP events. */
993 /* First see how many SIGTRAP events we have. */
994 iterate_over_lwps (count_events_callback
, &num_events
);
996 /* Now randomly pick a LWP out of those that have had a SIGTRAP. */
997 random_selector
= (int)
998 ((num_events
* (double) rand ()) / (RAND_MAX
+ 1.0));
1000 if (debug_lin_lwp
&& num_events
> 1)
1001 fprintf_unfiltered (gdb_stdlog
,
1002 "SEL: Found %d SIGTRAP events, selecting #%d\n",
1003 num_events
, random_selector
);
1005 event_lp
= iterate_over_lwps (select_event_lwp_callback
,
1009 if (event_lp
!= NULL
)
1011 /* Switch the event LWP. */
1012 *orig_lp
= event_lp
;
1013 *status
= event_lp
->status
;
1016 /* Flush the wait status for the event LWP. */
1017 (*orig_lp
)->status
= 0;
1020 /* Return non-zero if LP has been resumed. */
1023 resumed_callback (struct lwp_info
*lp
, void *data
)
1030 /* We need to override child_wait to support attaching to cloned
1031 processes, since a normal wait (as done by the default version)
1032 ignores those processes. */
1034 /* Wait for child PTID to do something. Return id of the child,
1035 minus_one_ptid in case of error; store status into *OURSTATUS. */
1038 child_wait (ptid_t ptid
, struct target_waitstatus
*ourstatus
)
1046 set_sigint_trap (); /* Causes SIGINT to be passed on to the
1047 attached process. */
1050 pid
= waitpid (GET_PID (ptid
), &status
, 0);
1051 if (pid
== -1 && errno
== ECHILD
)
1052 /* Try again with __WCLONE to check cloned processes. */
1053 pid
= waitpid (GET_PID (ptid
), &status
, __WCLONE
);
1057 fprintf_unfiltered (gdb_stdlog
,
1058 "CW: waitpid %ld received %s\n",
1059 (long) pid
, status_to_str (status
));
1064 /* Make sure we don't report an event for the exit of the
1065 original program, if we've detached from it. */
1066 if (pid
!= -1 && !WIFSTOPPED (status
) && pid
!= GET_PID (inferior_ptid
))
1072 /* Check for stop events reported by a process we didn't already
1073 know about - in this case, anything other than inferior_ptid.
1075 If we're expecting to receive stopped processes after fork,
1076 vfork, and clone events, then we'll just add the new one to
1077 our list and go back to waiting for the event to be reported
1078 - the stopped process might be returned from waitpid before
1079 or after the event is. If we want to handle debugging of
1080 CLONE_PTRACE processes we need to do more here, i.e. switch
1081 to multi-threaded mode. */
1082 if (pid
!= -1 && WIFSTOPPED (status
) && WSTOPSIG (status
) == SIGSTOP
1083 && pid
!= GET_PID (inferior_ptid
))
1089 clear_sigio_trap ();
1090 clear_sigint_trap ();
1092 while (pid
== -1 && save_errno
== EINTR
);
1096 warning ("Child process unexpectedly missing: %s",
1097 safe_strerror (errno
));
1099 /* Claim it exited with unknown signal. */
1100 ourstatus
->kind
= TARGET_WAITKIND_SIGNALLED
;
1101 ourstatus
->value
.sig
= TARGET_SIGNAL_UNKNOWN
;
1102 return minus_one_ptid
;
1105 store_waitstatus (ourstatus
, status
);
1106 return pid_to_ptid (pid
);
1111 /* Stop an active thread, verify it still exists, then resume it. */
1114 stop_and_resume_callback (struct lwp_info
*lp
, void *data
)
1116 struct lwp_info
*ptr
;
1118 if (!lp
->stopped
&& !lp
->signalled
)
1120 stop_callback (lp
, NULL
);
1121 stop_wait_callback (lp
, NULL
);
1122 /* Resume if the lwp still exists. */
1123 for (ptr
= lwp_list
; ptr
; ptr
= ptr
->next
)
1125 resume_callback (lp
, NULL
);
1131 lin_lwp_wait (ptid_t ptid
, struct target_waitstatus
*ourstatus
)
1133 struct lwp_info
*lp
= NULL
;
1136 pid_t pid
= PIDGET (ptid
);
1137 sigset_t flush_mask
;
1139 sigemptyset (&flush_mask
);
1141 /* Make sure SIGCHLD is blocked. */
1142 if (!sigismember (&blocked_mask
, SIGCHLD
))
1144 sigaddset (&blocked_mask
, SIGCHLD
);
1145 sigprocmask (SIG_BLOCK
, &blocked_mask
, NULL
);
1150 /* Make sure there is at least one LWP that has been resumed, at
1151 least if there are any LWPs at all. */
1152 gdb_assert (num_lwps
== 0 || iterate_over_lwps (resumed_callback
, NULL
));
1154 /* First check if there is a LWP with a wait status pending. */
1157 /* Any LWP that's been resumed will do. */
1158 lp
= iterate_over_lwps (status_callback
, NULL
);
1161 status
= lp
->status
;
1164 if (debug_lin_lwp
&& status
)
1165 fprintf_unfiltered (gdb_stdlog
,
1166 "LLW: Using pending wait status %s for %s.\n",
1167 status_to_str (status
),
1168 target_pid_to_str (lp
->ptid
));
1171 /* But if we don't fine one, we'll have to wait, and check both
1172 cloned and uncloned processes. We start with the cloned
1174 options
= __WCLONE
| WNOHANG
;
1176 else if (is_lwp (ptid
))
1179 fprintf_unfiltered (gdb_stdlog
,
1180 "LLW: Waiting for specific LWP %s.\n",
1181 target_pid_to_str (ptid
));
1183 /* We have a specific LWP to check. */
1184 lp
= find_lwp_pid (ptid
);
1186 status
= lp
->status
;
1189 if (debug_lin_lwp
&& status
)
1190 fprintf_unfiltered (gdb_stdlog
,
1191 "LLW: Using pending wait status %s for %s.\n",
1192 status_to_str (status
),
1193 target_pid_to_str (lp
->ptid
));
1195 /* If we have to wait, take into account whether PID is a cloned
1196 process or not. And we have to convert it to something that
1197 the layer beneath us can understand. */
1198 options
= lp
->cloned
? __WCLONE
: 0;
1199 pid
= GET_LWP (ptid
);
1202 if (status
&& lp
->signalled
)
1204 /* A pending SIGSTOP may interfere with the normal stream of
1205 events. In a typical case where interference is a problem,
1206 we have a SIGSTOP signal pending for LWP A while
1207 single-stepping it, encounter an event in LWP B, and take the
1208 pending SIGSTOP while trying to stop LWP A. After processing
1209 the event in LWP B, LWP A is continued, and we'll never see
1210 the SIGTRAP associated with the last time we were
1211 single-stepping LWP A. */
1213 /* Resume the thread. It should halt immediately returning the
1215 registers_changed ();
1216 child_resume (pid_to_ptid (GET_LWP (lp
->ptid
)), lp
->step
,
1219 fprintf_unfiltered (gdb_stdlog
,
1220 "LLW: %s %s, 0, 0 (expect SIGSTOP)\n",
1221 lp
->step
? "PTRACE_SINGLESTEP" : "PTRACE_CONT",
1222 target_pid_to_str (lp
->ptid
));
1224 gdb_assert (lp
->resumed
);
1226 /* This should catch the pending SIGSTOP. */
1227 stop_wait_callback (lp
, NULL
);
1230 set_sigint_trap (); /* Causes SIGINT to be passed on to the
1231 attached process. */
1238 lwpid
= waitpid (pid
, &status
, options
);
1241 gdb_assert (pid
== -1 || lwpid
== pid
);
1245 fprintf_unfiltered (gdb_stdlog
,
1246 "LLW: waitpid %ld received %s\n",
1247 (long) lwpid
, status_to_str (status
));
1250 lp
= find_lwp_pid (pid_to_ptid (lwpid
));
1252 /* Check for stop events reported by a process we didn't
1253 already know about - anything not already in our LWP
1256 If we're expecting to receive stopped processes after
1257 fork, vfork, and clone events, then we'll just add the
1258 new one to our list and go back to waiting for the event
1259 to be reported - the stopped process might be returned
1260 from waitpid before or after the event is. */
1261 if (WIFSTOPPED (status
) && !lp
)
1263 linux_record_stopped_pid (lwpid
);
1268 /* Make sure we don't report an event for the exit of an LWP not in
1269 our list, i.e. not part of the current process. This can happen
1270 if we detach from a program we original forked and then it
1272 if (!WIFSTOPPED (status
) && !lp
)
1278 /* NOTE drow/2003-06-17: This code seems to be meant for debugging
1279 CLONE_PTRACE processes which do not use the thread library -
1280 otherwise we wouldn't find the new LWP this way. That doesn't
1281 currently work, and the following code is currently unreachable
1282 due to the two blocks above. If it's fixed some day, this code
1283 should be broken out into a function so that we can also pick up
1284 LWPs from the new interface. */
1287 lp
= add_lwp (BUILD_LWP (lwpid
, GET_PID (inferior_ptid
)));
1288 if (options
& __WCLONE
)
1293 gdb_assert (WIFSTOPPED (status
)
1294 && WSTOPSIG (status
) == SIGSTOP
);
1297 if (!in_thread_list (inferior_ptid
))
1299 inferior_ptid
= BUILD_LWP (GET_PID (inferior_ptid
),
1300 GET_PID (inferior_ptid
));
1301 add_thread (inferior_ptid
);
1304 add_thread (lp
->ptid
);
1305 printf_unfiltered ("[New %s]\n",
1306 target_pid_to_str (lp
->ptid
));
1310 /* Check if the thread has exited. */
1311 if ((WIFEXITED (status
) || WIFSIGNALED (status
)) && num_lwps
> 1)
1313 if (in_thread_list (lp
->ptid
))
1315 /* Core GDB cannot deal with us deleting the current
1317 if (!ptid_equal (lp
->ptid
, inferior_ptid
))
1318 delete_thread (lp
->ptid
);
1319 printf_unfiltered ("[%s exited]\n",
1320 target_pid_to_str (lp
->ptid
));
1323 /* If this is the main thread, we must stop all threads and
1324 verify if they are still alive. This is because in the nptl
1325 thread model, there is no signal issued for exiting LWPs
1326 other than the main thread. We only get the main thread
1327 exit signal once all child threads have already exited.
1328 If we stop all the threads and use the stop_wait_callback
1329 to check if they have exited we can determine whether this
1330 signal should be ignored or whether it means the end of the
1331 debugged application, regardless of which threading model
1333 if (GET_PID (lp
->ptid
) == GET_LWP (lp
->ptid
))
1336 iterate_over_lwps (stop_and_resume_callback
, NULL
);
1340 fprintf_unfiltered (gdb_stdlog
,
1341 "LLW: %s exited.\n",
1342 target_pid_to_str (lp
->ptid
));
1344 delete_lwp (lp
->ptid
);
1346 /* If there is at least one more LWP, then the exit signal
1347 was not the end of the debugged application and should be
1351 /* Make sure there is at least one thread running. */
1352 gdb_assert (iterate_over_lwps (running_callback
, NULL
));
1354 /* Discard the event. */
1360 /* Check if the current LWP has previously exited. In the nptl
1361 thread model, LWPs other than the main thread do not issue
1362 signals when they exit so we must check whenever the thread
1363 has stopped. A similar check is made in stop_wait_callback(). */
1364 if (num_lwps
> 1 && !lin_lwp_thread_alive (lp
->ptid
))
1366 if (in_thread_list (lp
->ptid
))
1368 /* Core GDB cannot deal with us deleting the current
1370 if (!ptid_equal (lp
->ptid
, inferior_ptid
))
1371 delete_thread (lp
->ptid
);
1372 printf_unfiltered ("[%s exited]\n",
1373 target_pid_to_str (lp
->ptid
));
1376 fprintf_unfiltered (gdb_stdlog
,
1377 "LLW: %s exited.\n",
1378 target_pid_to_str (lp
->ptid
));
1380 delete_lwp (lp
->ptid
);
1382 /* Make sure there is at least one thread running. */
1383 gdb_assert (iterate_over_lwps (running_callback
, NULL
));
1385 /* Discard the event. */
1390 /* Make sure we don't report a SIGSTOP that we sent
1391 ourselves in an attempt to stop an LWP. */
1393 && WIFSTOPPED (status
) && WSTOPSIG (status
) == SIGSTOP
)
1396 fprintf_unfiltered (gdb_stdlog
,
1397 "LLW: Delayed SIGSTOP caught for %s.\n",
1398 target_pid_to_str (lp
->ptid
));
1400 /* This is a delayed SIGSTOP. */
1403 registers_changed ();
1404 child_resume (pid_to_ptid (GET_LWP (lp
->ptid
)), lp
->step
,
1407 fprintf_unfiltered (gdb_stdlog
,
1408 "LLW: %s %s, 0, 0 (discard SIGSTOP)\n",
1410 "PTRACE_SINGLESTEP" : "PTRACE_CONT",
1411 target_pid_to_str (lp
->ptid
));
1414 gdb_assert (lp
->resumed
);
1416 /* Discard the event. */
1426 /* Alternate between checking cloned and uncloned processes. */
1427 options
^= __WCLONE
;
1429 /* And suspend every time we have checked both. */
1430 if (options
& __WCLONE
)
1431 sigsuspend (&suspend_mask
);
1434 /* We shouldn't end up here unless we want to try again. */
1435 gdb_assert (status
== 0);
1438 clear_sigio_trap ();
1439 clear_sigint_trap ();
1443 /* Don't report signals that GDB isn't interested in, such as
1444 signals that are neither printed nor stopped upon. Stopping all
1445 threads can be a bit time-consuming so if we want decent
1446 performance with heavily multi-threaded programs, especially when
1447 they're using a high frequency timer, we'd better avoid it if we
1450 if (WIFSTOPPED (status
))
1452 int signo
= target_signal_from_host (WSTOPSIG (status
));
1454 if (signal_stop_state (signo
) == 0
1455 && signal_print_state (signo
) == 0
1456 && signal_pass_state (signo
) == 1)
1458 /* FIMXE: kettenis/2001-06-06: Should we resume all threads
1459 here? It is not clear we should. GDB may not expect
1460 other threads to run. On the other hand, not resuming
1461 newly attached threads may cause an unwanted delay in
1462 getting them running. */
1463 registers_changed ();
1464 child_resume (pid_to_ptid (GET_LWP (lp
->ptid
)), lp
->step
, signo
);
1466 fprintf_unfiltered (gdb_stdlog
,
1467 "LLW: %s %s, %s (preempt 'handle')\n",
1469 "PTRACE_SINGLESTEP" : "PTRACE_CONT",
1470 target_pid_to_str (lp
->ptid
),
1471 signo
? strsignal (signo
) : "0");
1477 if (signo
== TARGET_SIGNAL_INT
&& signal_pass_state (signo
) == 0)
1479 /* If ^C/BREAK is typed at the tty/console, SIGINT gets
1480 forwarded to the entire process group, that is, all LWP's
1481 will receive it. Since we only want to report it once,
1482 we try to flush it from all LWPs except this one. */
1483 sigaddset (&flush_mask
, SIGINT
);
1487 /* This LWP is stopped now. */
1491 fprintf_unfiltered (gdb_stdlog
, "LLW: Candidate event %s in %s.\n",
1492 status_to_str (status
), target_pid_to_str (lp
->ptid
));
1494 /* Now stop all other LWP's ... */
1495 iterate_over_lwps (stop_callback
, NULL
);
1497 /* ... and wait until all of them have reported back that they're no
1499 iterate_over_lwps (stop_wait_callback
, &flush_mask
);
1501 /* If we're not waiting for a specific LWP, choose an event LWP from
1502 among those that have had events. Giving equal priority to all
1503 LWPs that have had events helps prevent starvation. */
1505 select_event_lwp (&lp
, &status
);
1507 /* Now that we've selected our final event LWP, cancel any
1508 breakpoints in other LWPs that have hit a GDB breakpoint. See
1509 the comment in cancel_breakpoints_callback to find out why. */
1510 iterate_over_lwps (cancel_breakpoints_callback
, lp
);
1512 /* If we're not running in "threaded" mode, we'll report the bare
1515 if (WIFSTOPPED (status
) && WSTOPSIG (status
) == SIGTRAP
)
1517 trap_ptid
= (threaded
? lp
->ptid
: pid_to_ptid (GET_LWP (lp
->ptid
)));
1519 fprintf_unfiltered (gdb_stdlog
,
1520 "LLW: trap_ptid is %s.\n",
1521 target_pid_to_str (trap_ptid
));
1524 trap_ptid
= null_ptid
;
1526 store_waitstatus (ourstatus
, status
);
1527 return (threaded
? lp
->ptid
: pid_to_ptid (GET_LWP (lp
->ptid
)));
1531 kill_callback (struct lwp_info
*lp
, void *data
)
1534 ptrace (PTRACE_KILL
, GET_LWP (lp
->ptid
), 0, 0);
1536 fprintf_unfiltered (gdb_stdlog
,
1537 "KC: PTRACE_KILL %s, 0, 0 (%s)\n",
1538 target_pid_to_str (lp
->ptid
),
1539 errno
? safe_strerror (errno
) : "OK");
1545 kill_wait_callback (struct lwp_info
*lp
, void *data
)
1549 /* We must make sure that there are no pending events (delayed
1550 SIGSTOPs, pending SIGTRAPs, etc.) to make sure the current
1551 program doesn't interfere with any following debugging session. */
1553 /* For cloned processes we must check both with __WCLONE and
1554 without, since the exit status of a cloned process isn't reported
1560 pid
= waitpid (GET_LWP (lp
->ptid
), NULL
, __WCLONE
);
1561 if (pid
!= (pid_t
) -1 && debug_lin_lwp
)
1563 fprintf_unfiltered (gdb_stdlog
,
1564 "KWC: wait %s received unknown.\n",
1565 target_pid_to_str (lp
->ptid
));
1568 while (pid
== GET_LWP (lp
->ptid
));
1570 gdb_assert (pid
== -1 && errno
== ECHILD
);
1575 pid
= waitpid (GET_LWP (lp
->ptid
), NULL
, 0);
1576 if (pid
!= (pid_t
) -1 && debug_lin_lwp
)
1578 fprintf_unfiltered (gdb_stdlog
,
1579 "KWC: wait %s received unk.\n",
1580 target_pid_to_str (lp
->ptid
));
1583 while (pid
== GET_LWP (lp
->ptid
));
1585 gdb_assert (pid
== -1 && errno
== ECHILD
);
1592 /* Kill all LWP's ... */
1593 iterate_over_lwps (kill_callback
, NULL
);
1595 /* ... and wait until we've flushed all events. */
1596 iterate_over_lwps (kill_wait_callback
, NULL
);
1598 target_mourn_inferior ();
1602 lin_lwp_create_inferior (char *exec_file
, char *allargs
, char **env
)
1604 child_ops
.to_create_inferior (exec_file
, allargs
, env
);
1608 lin_lwp_mourn_inferior (void)
1610 trap_ptid
= null_ptid
;
1612 /* Destroy LWP info; it's no longer valid. */
1615 /* Restore the original signal mask. */
1616 sigprocmask (SIG_SETMASK
, &normal_mask
, NULL
);
1617 sigemptyset (&blocked_mask
);
1619 child_ops
.to_mourn_inferior ();
1623 lin_lwp_xfer_memory (CORE_ADDR memaddr
, char *myaddr
, int len
, int write
,
1624 struct mem_attrib
*attrib
, struct target_ops
*target
)
1626 struct cleanup
*old_chain
= save_inferior_ptid ();
1629 if (is_lwp (inferior_ptid
))
1630 inferior_ptid
= pid_to_ptid (GET_LWP (inferior_ptid
));
1632 xfer
= linux_proc_xfer_memory (memaddr
, myaddr
, len
, write
, attrib
, target
);
1634 xfer
= child_xfer_memory (memaddr
, myaddr
, len
, write
, attrib
, target
);
1636 do_cleanups (old_chain
);
1641 lin_lwp_thread_alive (ptid_t ptid
)
1643 gdb_assert (is_lwp (ptid
));
1646 ptrace (PTRACE_PEEKUSER
, GET_LWP (ptid
), 0, 0);
1648 fprintf_unfiltered (gdb_stdlog
,
1649 "LLTA: PTRACE_PEEKUSER %s, 0, 0 (%s)\n",
1650 target_pid_to_str (ptid
),
1651 errno
? safe_strerror (errno
) : "OK");
1659 lin_lwp_pid_to_str (ptid_t ptid
)
1661 static char buf
[64];
1665 snprintf (buf
, sizeof (buf
), "LWP %ld", GET_LWP (ptid
));
1669 return normal_pid_to_str (ptid
);
1673 init_lin_lwp_ops (void)
1676 lin_lwp_ops
.to_open
= lin_lwp_open
;
1678 lin_lwp_ops
.to_shortname
= "lwp-layer";
1679 lin_lwp_ops
.to_longname
= "lwp-layer";
1680 lin_lwp_ops
.to_doc
= "Low level threads support (LWP layer)";
1681 lin_lwp_ops
.to_attach
= lin_lwp_attach
;
1682 lin_lwp_ops
.to_detach
= lin_lwp_detach
;
1683 lin_lwp_ops
.to_resume
= lin_lwp_resume
;
1684 lin_lwp_ops
.to_wait
= lin_lwp_wait
;
1685 /* fetch_inferior_registers and store_inferior_registers will
1686 honor the LWP id, so we can use them directly. */
1687 lin_lwp_ops
.to_fetch_registers
= fetch_inferior_registers
;
1688 lin_lwp_ops
.to_store_registers
= store_inferior_registers
;
1689 lin_lwp_ops
.to_xfer_memory
= lin_lwp_xfer_memory
;
1690 lin_lwp_ops
.to_kill
= lin_lwp_kill
;
1691 lin_lwp_ops
.to_create_inferior
= lin_lwp_create_inferior
;
1692 lin_lwp_ops
.to_mourn_inferior
= lin_lwp_mourn_inferior
;
1693 lin_lwp_ops
.to_thread_alive
= lin_lwp_thread_alive
;
1694 lin_lwp_ops
.to_pid_to_str
= lin_lwp_pid_to_str
;
1695 lin_lwp_ops
.to_stratum
= thread_stratum
;
1696 lin_lwp_ops
.to_has_thread_control
= tc_schedlock
;
1697 lin_lwp_ops
.to_magic
= OPS_MAGIC
;
1701 sigchld_handler (int signo
)
1703 /* Do nothing. The only reason for this handler is that it allows
1704 us to use sigsuspend in lin_lwp_wait above to wait for the
1705 arrival of a SIGCHLD. */
1709 _initialize_lin_lwp (void)
1711 struct sigaction action
;
1713 extern void thread_db_init (struct target_ops
*);
1715 init_lin_lwp_ops ();
1716 add_target (&lin_lwp_ops
);
1717 thread_db_init (&lin_lwp_ops
);
1719 /* Save the original signal mask. */
1720 sigprocmask (SIG_SETMASK
, NULL
, &normal_mask
);
1722 action
.sa_handler
= sigchld_handler
;
1723 sigemptyset (&action
.sa_mask
);
1724 action
.sa_flags
= 0;
1725 sigaction (SIGCHLD
, &action
, NULL
);
1727 /* Make sure we don't block SIGCHLD during a sigsuspend. */
1728 sigprocmask (SIG_SETMASK
, NULL
, &suspend_mask
);
1729 sigdelset (&suspend_mask
, SIGCHLD
);
1731 sigemptyset (&blocked_mask
);
1733 add_show_from_set (add_set_cmd ("lin-lwp", no_class
, var_zinteger
,
1734 (char *) &debug_lin_lwp
,
1735 "Set debugging of GNU/Linux lwp module.\n\
1736 Enables printf debugging output.\n", &setdebuglist
), &showdebuglist
);
1740 /* FIXME: kettenis/2000-08-26: The stuff on this page is specific to
1741 the GNU/Linux Threads library and therefore doesn't really belong
1744 /* Read variable NAME in the target and return its value if found.
1745 Otherwise return zero. It is assumed that the type of the variable
1749 get_signo (const char *name
)
1751 struct minimal_symbol
*ms
;
1754 ms
= lookup_minimal_symbol (name
, NULL
, NULL
);
1758 if (target_read_memory (SYMBOL_VALUE_ADDRESS (ms
), (char *) &signo
,
1759 sizeof (signo
)) != 0)
1765 /* Return the set of signals used by the threads library in *SET. */
1768 lin_thread_get_thread_signals (sigset_t
*set
)
1770 struct sigaction action
;
1771 int restart
, cancel
;
1775 restart
= get_signo ("__pthread_sig_restart");
1779 cancel
= get_signo ("__pthread_sig_cancel");
1783 sigaddset (set
, restart
);
1784 sigaddset (set
, cancel
);
1786 /* The GNU/Linux Threads library makes terminating threads send a
1787 special "cancel" signal instead of SIGCHLD. Make sure we catch
1788 those (to prevent them from terminating GDB itself, which is
1789 likely to be their default action) and treat them the same way as
1792 action
.sa_handler
= sigchld_handler
;
1793 sigemptyset (&action
.sa_mask
);
1794 action
.sa_flags
= 0;
1795 sigaction (cancel
, &action
, NULL
);
1797 /* We block the "cancel" signal throughout this code ... */
1798 sigaddset (&blocked_mask
, cancel
);
1799 sigprocmask (SIG_BLOCK
, &blocked_mask
, NULL
);
1801 /* ... except during a sigsuspend. */
1802 sigdelset (&suspend_mask
, cancel
);