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
));
327 child_post_attach (pid
);
333 fprintf_unfiltered (gdb_stdlog
,
334 "LLAL: waitpid %s received %s\n",
335 target_pid_to_str (ptid
),
336 status_to_str (status
));
341 /* We assume that the LWP representing the original process
342 is already stopped. Mark it as stopped in the data structure
343 that the lin-lwp layer uses to keep track of threads. Note
344 that this won't have already been done since the main thread
345 will have, we assume, been stopped by an attach from a
352 lin_lwp_attach (char *args
, int from_tty
)
358 /* FIXME: We should probably accept a list of process id's, and
359 attach all of them. */
360 child_ops
.to_attach (args
, from_tty
);
362 /* Add the initial process as the first LWP to the list. */
363 lp
= add_lwp (BUILD_LWP (GET_PID (inferior_ptid
), GET_PID (inferior_ptid
)));
365 /* Make sure the initial process is stopped. The user-level threads
366 layer might want to poke around in the inferior, and that won't
367 work if things haven't stabilized yet. */
368 pid
= waitpid (GET_PID (inferior_ptid
), &status
, 0);
369 if (pid
== -1 && errno
== ECHILD
)
371 warning ("%s is a cloned process", target_pid_to_str (inferior_ptid
));
373 /* Try again with __WCLONE to check cloned processes. */
374 pid
= waitpid (GET_PID (inferior_ptid
), &status
, __WCLONE
);
378 gdb_assert (pid
== GET_PID (inferior_ptid
)
379 && WIFSTOPPED (status
) && WSTOPSIG (status
) == SIGSTOP
);
383 /* Fake the SIGSTOP that core GDB expects. */
384 lp
->status
= W_STOPCODE (SIGSTOP
);
388 fprintf_unfiltered (gdb_stdlog
,
389 "LLA: waitpid %ld, faking SIGSTOP\n", (long) pid
);
394 detach_callback (struct lwp_info
*lp
, void *data
)
396 gdb_assert (lp
->status
== 0 || WIFSTOPPED (lp
->status
));
398 if (debug_lin_lwp
&& lp
->status
)
399 fprintf_unfiltered (gdb_stdlog
, "DC: Pending %s for %s on detach.\n",
400 strsignal (WSTOPSIG (lp
->status
)),
401 target_pid_to_str (lp
->ptid
));
403 while (lp
->signalled
&& lp
->stopped
)
406 if (ptrace (PTRACE_CONT
, GET_LWP (lp
->ptid
), 0,
407 WSTOPSIG (lp
->status
)) < 0)
408 error ("Can't continue %s: %s", target_pid_to_str (lp
->ptid
),
409 safe_strerror (errno
));
412 fprintf_unfiltered (gdb_stdlog
,
413 "DC: PTRACE_CONTINUE (%s, 0, %s) (OK)\n",
414 target_pid_to_str (lp
->ptid
),
415 status_to_str (lp
->status
));
420 /* FIXME drow/2003-08-26: There was a call to stop_wait_callback
421 here. But since lp->signalled was cleared above,
422 stop_wait_callback didn't do anything; the process was left
423 running. Shouldn't we be waiting for it to stop?
424 I've removed the call, since stop_wait_callback now does do
425 something when called with lp->signalled == 0. */
427 gdb_assert (lp
->status
== 0 || WIFSTOPPED (lp
->status
));
430 /* We don't actually detach from the LWP that has an id equal to the
431 overall process id just yet. */
432 if (GET_LWP (lp
->ptid
) != GET_PID (lp
->ptid
))
435 if (ptrace (PTRACE_DETACH
, GET_LWP (lp
->ptid
), 0,
436 WSTOPSIG (lp
->status
)) < 0)
437 error ("Can't detach %s: %s", target_pid_to_str (lp
->ptid
),
438 safe_strerror (errno
));
441 fprintf_unfiltered (gdb_stdlog
,
442 "PTRACE_DETACH (%s, %s, 0) (OK)\n",
443 target_pid_to_str (lp
->ptid
),
444 strsignal (WSTOPSIG (lp
->status
)));
446 delete_lwp (lp
->ptid
);
453 lin_lwp_detach (char *args
, int from_tty
)
455 iterate_over_lwps (detach_callback
, NULL
);
457 /* Only the initial process should be left right now. */
458 gdb_assert (num_lwps
== 1);
460 trap_ptid
= null_ptid
;
462 /* Destroy LWP info; it's no longer valid. */
465 /* Restore the original signal mask. */
466 sigprocmask (SIG_SETMASK
, &normal_mask
, NULL
);
467 sigemptyset (&blocked_mask
);
469 inferior_ptid
= pid_to_ptid (GET_PID (inferior_ptid
));
470 child_ops
.to_detach (args
, from_tty
);
477 resume_callback (struct lwp_info
*lp
, void *data
)
479 if (lp
->stopped
&& lp
->status
== 0)
481 struct thread_info
*tp
;
483 child_resume (pid_to_ptid (GET_LWP (lp
->ptid
)), 0, TARGET_SIGNAL_0
);
485 fprintf_unfiltered (gdb_stdlog
,
486 "RC: PTRACE_CONT %s, 0, 0 (resume sibling)\n",
487 target_pid_to_str (lp
->ptid
));
496 resume_clear_callback (struct lwp_info
*lp
, void *data
)
503 resume_set_callback (struct lwp_info
*lp
, void *data
)
510 lin_lwp_resume (ptid_t ptid
, int step
, enum target_signal signo
)
515 /* A specific PTID means `step only this process id'. */
516 resume_all
= (PIDGET (ptid
) == -1);
519 iterate_over_lwps (resume_set_callback
, NULL
);
521 iterate_over_lwps (resume_clear_callback
, NULL
);
523 /* If PID is -1, it's the current inferior that should be
524 handled specially. */
525 if (PIDGET (ptid
) == -1)
526 ptid
= inferior_ptid
;
528 lp
= find_lwp_pid (ptid
);
531 ptid
= pid_to_ptid (GET_LWP (lp
->ptid
));
533 /* Remember if we're stepping. */
536 /* Mark this LWP as resumed. */
539 /* If we have a pending wait status for this thread, there is no
540 point in resuming the process. */
543 /* FIXME: What should we do if we are supposed to continue
544 this thread with a signal? */
545 gdb_assert (signo
== TARGET_SIGNAL_0
);
549 /* Mark LWP as not stopped to prevent it from being continued by
555 iterate_over_lwps (resume_callback
, NULL
);
557 child_resume (ptid
, step
, signo
);
559 fprintf_unfiltered (gdb_stdlog
,
560 "LLR: %s %s, %s (resume event thread)\n",
561 step
? "PTRACE_SINGLESTEP" : "PTRACE_CONT",
562 target_pid_to_str (ptid
),
563 signo
? strsignal (signo
) : "0");
567 /* Issue kill to specified lwp. */
569 static int tkill_failed
;
572 kill_lwp (int lwpid
, int signo
)
576 /* Use tkill, if possible, in case we are using nptl threads. If tkill
577 fails, then we are not using nptl threads and we should be using kill. */
579 #ifdef HAVE_TKILL_SYSCALL
582 int ret
= syscall (__NR_tkill
, lwpid
, signo
);
590 return kill (lwpid
, signo
);
593 /* Wait for LP to stop. Returns the wait status, or 0 if the LWP has
597 wait_lwp (struct lwp_info
*lp
)
603 gdb_assert (!lp
->stopped
);
604 gdb_assert (lp
->status
== 0);
606 pid
= waitpid (GET_LWP (lp
->ptid
), &status
, 0);
607 if (pid
== -1 && errno
== ECHILD
)
609 pid
= waitpid (GET_LWP (lp
->ptid
), &status
, __WCLONE
);
610 if (pid
== -1 && errno
== ECHILD
)
612 /* The thread has previously exited. We need to delete it now
613 because in the case of NPTL threads, there won't be an
614 exit event unless it is the main thread. */
617 fprintf_unfiltered (gdb_stdlog
, "WL: %s vanished.\n",
618 target_pid_to_str (lp
->ptid
));
624 gdb_assert (pid
== GET_LWP (lp
->ptid
));
628 fprintf_unfiltered (gdb_stdlog
,
629 "WL: waitpid %s received %s\n",
630 target_pid_to_str (lp
->ptid
),
631 status_to_str (status
));
635 /* Check if the thread has exited. */
636 if (WIFEXITED (status
) || WIFSIGNALED (status
))
640 fprintf_unfiltered (gdb_stdlog
, "WL: %s exited.\n",
641 target_pid_to_str (lp
->ptid
));
646 if (in_thread_list (lp
->ptid
))
648 /* Core GDB cannot deal with us deleting the current thread. */
649 if (!ptid_equal (lp
->ptid
, inferior_ptid
))
650 delete_thread (lp
->ptid
);
651 printf_unfiltered ("[%s exited]\n",
652 target_pid_to_str (lp
->ptid
));
655 delete_lwp (lp
->ptid
);
659 gdb_assert (WIFSTOPPED (status
));
664 /* Send a SIGSTOP to LP. */
667 stop_callback (struct lwp_info
*lp
, void *data
)
669 if (!lp
->stopped
&& !lp
->signalled
)
675 fprintf_unfiltered (gdb_stdlog
,
676 "SC: kill %s **<SIGSTOP>**\n",
677 target_pid_to_str (lp
->ptid
));
680 ret
= kill_lwp (GET_LWP (lp
->ptid
), SIGSTOP
);
683 fprintf_unfiltered (gdb_stdlog
,
684 "SC: lwp kill %d %s\n",
686 errno
? safe_strerror (errno
) : "ERRNO-OK");
690 gdb_assert (lp
->status
== 0);
696 /* Wait until LP is stopped. If DATA is non-null it is interpreted as
697 a pointer to a set of signals to be flushed immediately. */
700 stop_wait_callback (struct lwp_info
*lp
, void *data
)
702 sigset_t
*flush_mask
= data
;
708 status
= wait_lwp (lp
);
712 /* Ignore any signals in FLUSH_MASK. */
713 if (flush_mask
&& sigismember (flush_mask
, WSTOPSIG (status
)))
722 ptrace (PTRACE_CONT
, GET_LWP (lp
->ptid
), 0, 0);
724 fprintf_unfiltered (gdb_stdlog
,
725 "PTRACE_CONT %s, 0, 0 (%s)\n",
726 target_pid_to_str (lp
->ptid
),
727 errno
? safe_strerror (errno
) : "OK");
729 return stop_wait_callback (lp
, flush_mask
);
732 if (WSTOPSIG (status
) != SIGSTOP
)
734 if (WSTOPSIG (status
) == SIGTRAP
)
736 /* If a LWP other than the LWP that we're reporting an
737 event for has hit a GDB breakpoint (as opposed to
738 some random trap signal), then just arrange for it to
739 hit it again later. We don't keep the SIGTRAP status
740 and don't forward the SIGTRAP signal to the LWP. We
741 will handle the current event, eventually we will
742 resume all LWPs, and this one will get its breakpoint
745 If we do not do this, then we run the risk that the
746 user will delete or disable the breakpoint, but the
747 thread will have already tripped on it. */
749 /* Now resume this LWP and get the SIGSTOP event. */
751 ptrace (PTRACE_CONT
, GET_LWP (lp
->ptid
), 0, 0);
754 fprintf_unfiltered (gdb_stdlog
,
755 "PTRACE_CONT %s, 0, 0 (%s)\n",
756 target_pid_to_str (lp
->ptid
),
757 errno
? safe_strerror (errno
) : "OK");
759 fprintf_unfiltered (gdb_stdlog
,
760 "SWC: Candidate SIGTRAP event in %s\n",
761 target_pid_to_str (lp
->ptid
));
763 /* Hold the SIGTRAP for handling by lin_lwp_wait. */
764 stop_wait_callback (lp
, data
);
765 /* If there's another event, throw it back into the queue. */
770 fprintf_unfiltered (gdb_stdlog
,
771 "SWC: kill %s, %s\n",
772 target_pid_to_str (lp
->ptid
),
773 status_to_str ((int) status
));
775 kill_lwp (GET_LWP (lp
->ptid
), WSTOPSIG (lp
->status
));
777 /* Save the sigtrap event. */
783 /* The thread was stopped with a signal other than
784 SIGSTOP, and didn't accidentally trip a breakpoint. */
788 fprintf_unfiltered (gdb_stdlog
,
789 "SWC: Pending event %s in %s\n",
790 status_to_str ((int) status
),
791 target_pid_to_str (lp
->ptid
));
793 /* Now resume this LWP and get the SIGSTOP event. */
795 ptrace (PTRACE_CONT
, GET_LWP (lp
->ptid
), 0, 0);
797 fprintf_unfiltered (gdb_stdlog
,
798 "SWC: PTRACE_CONT %s, 0, 0 (%s)\n",
799 target_pid_to_str (lp
->ptid
),
800 errno
? safe_strerror (errno
) : "OK");
802 /* Hold this event/waitstatus while we check to see if
803 there are any more (we still want to get that SIGSTOP). */
804 stop_wait_callback (lp
, data
);
805 /* If the lp->status field is still empty, use it to hold
806 this event. If not, then this event must be returned
807 to the event queue of the LWP. */
814 fprintf_unfiltered (gdb_stdlog
,
815 "SWC: kill %s, %s\n",
816 target_pid_to_str (lp
->ptid
),
817 status_to_str ((int) status
));
819 kill_lwp (GET_LWP (lp
->ptid
), WSTOPSIG (status
));
826 /* We caught the SIGSTOP that we intended to catch, so
827 there's no SIGSTOP pending. */
836 /* Check whether PID has any pending signals in FLUSH_MASK. If so set
837 the appropriate bits in PENDING, and return 1 - otherwise return 0. */
840 lin_lwp_has_pending (int pid
, sigset_t
*pending
, sigset_t
*flush_mask
)
842 sigset_t blocked
, ignored
;
845 linux_proc_pending_signals (pid
, pending
, &blocked
, &ignored
);
850 for (i
= 1; i
< NSIG
; i
++)
851 if (sigismember (pending
, i
))
852 if (!sigismember (flush_mask
, i
)
853 || sigismember (&blocked
, i
)
854 || sigismember (&ignored
, i
))
855 sigdelset (pending
, i
);
857 if (sigisemptyset (pending
))
863 /* DATA is interpreted as a mask of signals to flush. If LP has
864 signals pending, and they are all in the flush mask, then arrange
865 to flush them. LP should be stopped, as should all other threads
866 it might share a signal queue with. */
869 flush_callback (struct lwp_info
*lp
, void *data
)
871 sigset_t
*flush_mask
= data
;
872 sigset_t pending
, intersection
, blocked
, ignored
;
875 /* Normally, when an LWP exits, it is removed from the LWP list. The
876 last LWP isn't removed till later, however. So if there is only
877 one LWP on the list, make sure it's alive. */
878 if (lwp_list
== lp
&& lp
->next
== NULL
)
879 if (!lin_lwp_thread_alive (lp
->ptid
))
882 /* Just because the LWP is stopped doesn't mean that new signals
883 can't arrive from outside, so this function must be careful of
884 race conditions. However, because all threads are stopped, we
885 can assume that the pending mask will not shrink unless we resume
886 the LWP, and that it will then get another signal. We can't
887 control which one, however. */
892 printf_unfiltered ("FC: LP has pending status %06x\n", lp
->status
);
893 if (WIFSTOPPED (lp
->status
) && sigismember (flush_mask
, WSTOPSIG (lp
->status
)))
897 while (lin_lwp_has_pending (GET_LWP (lp
->ptid
), &pending
, flush_mask
))
902 ret
= ptrace (PTRACE_CONT
, GET_LWP (lp
->ptid
), 0, 0);
904 fprintf_unfiltered (gdb_stderr
,
905 "FC: Sent PTRACE_CONT, ret %d %d\n", ret
, errno
);
908 stop_wait_callback (lp
, flush_mask
);
910 fprintf_unfiltered (gdb_stderr
,
911 "FC: Wait finished; saved status is %d\n",
918 /* Return non-zero if LP has a wait status pending. */
921 status_callback (struct lwp_info
*lp
, void *data
)
923 /* Only report a pending wait status if we pretend that this has
924 indeed been resumed. */
925 return (lp
->status
!= 0 && lp
->resumed
);
928 /* Return non-zero if LP isn't stopped. */
931 running_callback (struct lwp_info
*lp
, void *data
)
933 return (lp
->stopped
== 0);
936 /* Count the LWP's that have had events. */
939 count_events_callback (struct lwp_info
*lp
, void *data
)
943 gdb_assert (count
!= NULL
);
945 /* Count only LWPs that have a SIGTRAP event pending. */
947 && WIFSTOPPED (lp
->status
) && WSTOPSIG (lp
->status
) == SIGTRAP
)
953 /* Select the LWP (if any) that is currently being single-stepped. */
956 select_singlestep_lwp_callback (struct lwp_info
*lp
, void *data
)
958 if (lp
->step
&& lp
->status
!= 0)
964 /* Select the Nth LWP that has had a SIGTRAP event. */
967 select_event_lwp_callback (struct lwp_info
*lp
, void *data
)
969 int *selector
= data
;
971 gdb_assert (selector
!= NULL
);
973 /* Select only LWPs that have a SIGTRAP event pending. */
975 && WIFSTOPPED (lp
->status
) && WSTOPSIG (lp
->status
) == SIGTRAP
)
976 if ((*selector
)-- == 0)
983 cancel_breakpoints_callback (struct lwp_info
*lp
, void *data
)
985 struct lwp_info
*event_lp
= data
;
987 /* Leave the LWP that has been elected to receive a SIGTRAP alone. */
991 /* If a LWP other than the LWP that we're reporting an event for has
992 hit a GDB breakpoint (as opposed to some random trap signal),
993 then just arrange for it to hit it again later. We don't keep
994 the SIGTRAP status and don't forward the SIGTRAP signal to the
995 LWP. We will handle the current event, eventually we will resume
996 all LWPs, and this one will get its breakpoint trap again.
998 If we do not do this, then we run the risk that the user will
999 delete or disable the breakpoint, but the LWP will have already
1003 && WIFSTOPPED (lp
->status
) && WSTOPSIG (lp
->status
) == SIGTRAP
1004 && breakpoint_inserted_here_p (read_pc_pid (lp
->ptid
) -
1005 DECR_PC_AFTER_BREAK
))
1008 fprintf_unfiltered (gdb_stdlog
,
1009 "CBC: Push back breakpoint for %s\n",
1010 target_pid_to_str (lp
->ptid
));
1012 /* Back up the PC if necessary. */
1013 if (DECR_PC_AFTER_BREAK
)
1014 write_pc_pid (read_pc_pid (lp
->ptid
) - DECR_PC_AFTER_BREAK
, lp
->ptid
);
1016 /* Throw away the SIGTRAP. */
1023 /* Select one LWP out of those that have events pending. */
1026 select_event_lwp (struct lwp_info
**orig_lp
, int *status
)
1029 int random_selector
;
1030 struct lwp_info
*event_lp
;
1032 /* Record the wait status for the origional LWP. */
1033 (*orig_lp
)->status
= *status
;
1035 /* Give preference to any LWP that is being single-stepped. */
1036 event_lp
= iterate_over_lwps (select_singlestep_lwp_callback
, NULL
);
1037 if (event_lp
!= NULL
)
1040 fprintf_unfiltered (gdb_stdlog
,
1041 "SEL: Select single-step %s\n",
1042 target_pid_to_str (event_lp
->ptid
));
1046 /* No single-stepping LWP. Select one at random, out of those
1047 which have had SIGTRAP events. */
1049 /* First see how many SIGTRAP events we have. */
1050 iterate_over_lwps (count_events_callback
, &num_events
);
1052 /* Now randomly pick a LWP out of those that have had a SIGTRAP. */
1053 random_selector
= (int)
1054 ((num_events
* (double) rand ()) / (RAND_MAX
+ 1.0));
1056 if (debug_lin_lwp
&& num_events
> 1)
1057 fprintf_unfiltered (gdb_stdlog
,
1058 "SEL: Found %d SIGTRAP events, selecting #%d\n",
1059 num_events
, random_selector
);
1061 event_lp
= iterate_over_lwps (select_event_lwp_callback
,
1065 if (event_lp
!= NULL
)
1067 /* Switch the event LWP. */
1068 *orig_lp
= event_lp
;
1069 *status
= event_lp
->status
;
1072 /* Flush the wait status for the event LWP. */
1073 (*orig_lp
)->status
= 0;
1076 /* Return non-zero if LP has been resumed. */
1079 resumed_callback (struct lwp_info
*lp
, void *data
)
1086 /* We need to override child_wait to support attaching to cloned
1087 processes, since a normal wait (as done by the default version)
1088 ignores those processes. */
1090 /* Wait for child PTID to do something. Return id of the child,
1091 minus_one_ptid in case of error; store status into *OURSTATUS. */
1094 child_wait (ptid_t ptid
, struct target_waitstatus
*ourstatus
)
1102 set_sigint_trap (); /* Causes SIGINT to be passed on to the
1103 attached process. */
1106 pid
= waitpid (GET_PID (ptid
), &status
, 0);
1107 if (pid
== -1 && errno
== ECHILD
)
1108 /* Try again with __WCLONE to check cloned processes. */
1109 pid
= waitpid (GET_PID (ptid
), &status
, __WCLONE
);
1113 fprintf_unfiltered (gdb_stdlog
,
1114 "CW: waitpid %ld received %s\n",
1115 (long) pid
, status_to_str (status
));
1120 /* Make sure we don't report an event for the exit of the
1121 original program, if we've detached from it. */
1122 if (pid
!= -1 && !WIFSTOPPED (status
) && pid
!= GET_PID (inferior_ptid
))
1128 /* Check for stop events reported by a process we didn't already
1129 know about - in this case, anything other than inferior_ptid.
1131 If we're expecting to receive stopped processes after fork,
1132 vfork, and clone events, then we'll just add the new one to
1133 our list and go back to waiting for the event to be reported
1134 - the stopped process might be returned from waitpid before
1135 or after the event is. If we want to handle debugging of
1136 CLONE_PTRACE processes we need to do more here, i.e. switch
1137 to multi-threaded mode. */
1138 if (pid
!= -1 && WIFSTOPPED (status
) && WSTOPSIG (status
) == SIGSTOP
1139 && pid
!= GET_PID (inferior_ptid
))
1141 linux_record_stopped_pid (pid
);
1146 clear_sigio_trap ();
1147 clear_sigint_trap ();
1149 while (pid
== -1 && save_errno
== EINTR
);
1153 warning ("Child process unexpectedly missing: %s",
1154 safe_strerror (errno
));
1156 /* Claim it exited with unknown signal. */
1157 ourstatus
->kind
= TARGET_WAITKIND_SIGNALLED
;
1158 ourstatus
->value
.sig
= TARGET_SIGNAL_UNKNOWN
;
1159 return minus_one_ptid
;
1162 /* Handle GNU/Linux's extended waitstatus for trace events. */
1163 if (WIFSTOPPED (status
) && WSTOPSIG (status
) == SIGTRAP
&& status
>> 16 != 0)
1164 return linux_handle_extended_wait (pid
, status
, ourstatus
);
1166 store_waitstatus (ourstatus
, status
);
1167 return pid_to_ptid (pid
);
1172 /* Stop an active thread, verify it still exists, then resume it. */
1175 stop_and_resume_callback (struct lwp_info
*lp
, void *data
)
1177 struct lwp_info
*ptr
;
1179 if (!lp
->stopped
&& !lp
->signalled
)
1181 stop_callback (lp
, NULL
);
1182 stop_wait_callback (lp
, NULL
);
1183 /* Resume if the lwp still exists. */
1184 for (ptr
= lwp_list
; ptr
; ptr
= ptr
->next
)
1186 resume_callback (lp
, NULL
);
1192 lin_lwp_wait (ptid_t ptid
, struct target_waitstatus
*ourstatus
)
1194 struct lwp_info
*lp
= NULL
;
1197 pid_t pid
= PIDGET (ptid
);
1198 sigset_t flush_mask
;
1200 sigemptyset (&flush_mask
);
1202 /* Make sure SIGCHLD is blocked. */
1203 if (!sigismember (&blocked_mask
, SIGCHLD
))
1205 sigaddset (&blocked_mask
, SIGCHLD
);
1206 sigprocmask (SIG_BLOCK
, &blocked_mask
, NULL
);
1211 /* Make sure there is at least one LWP that has been resumed, at
1212 least if there are any LWPs at all. */
1213 gdb_assert (num_lwps
== 0 || iterate_over_lwps (resumed_callback
, NULL
));
1215 /* First check if there is a LWP with a wait status pending. */
1218 /* Any LWP that's been resumed will do. */
1219 lp
= iterate_over_lwps (status_callback
, NULL
);
1222 status
= lp
->status
;
1225 if (debug_lin_lwp
&& status
)
1226 fprintf_unfiltered (gdb_stdlog
,
1227 "LLW: Using pending wait status %s for %s.\n",
1228 status_to_str (status
),
1229 target_pid_to_str (lp
->ptid
));
1232 /* But if we don't fine one, we'll have to wait, and check both
1233 cloned and uncloned processes. We start with the cloned
1235 options
= __WCLONE
| WNOHANG
;
1237 else if (is_lwp (ptid
))
1240 fprintf_unfiltered (gdb_stdlog
,
1241 "LLW: Waiting for specific LWP %s.\n",
1242 target_pid_to_str (ptid
));
1244 /* We have a specific LWP to check. */
1245 lp
= find_lwp_pid (ptid
);
1247 status
= lp
->status
;
1250 if (debug_lin_lwp
&& status
)
1251 fprintf_unfiltered (gdb_stdlog
,
1252 "LLW: Using pending wait status %s for %s.\n",
1253 status_to_str (status
),
1254 target_pid_to_str (lp
->ptid
));
1256 /* If we have to wait, take into account whether PID is a cloned
1257 process or not. And we have to convert it to something that
1258 the layer beneath us can understand. */
1259 options
= lp
->cloned
? __WCLONE
: 0;
1260 pid
= GET_LWP (ptid
);
1263 if (status
&& lp
->signalled
)
1265 /* A pending SIGSTOP may interfere with the normal stream of
1266 events. In a typical case where interference is a problem,
1267 we have a SIGSTOP signal pending for LWP A while
1268 single-stepping it, encounter an event in LWP B, and take the
1269 pending SIGSTOP while trying to stop LWP A. After processing
1270 the event in LWP B, LWP A is continued, and we'll never see
1271 the SIGTRAP associated with the last time we were
1272 single-stepping LWP A. */
1274 /* Resume the thread. It should halt immediately returning the
1276 registers_changed ();
1277 child_resume (pid_to_ptid (GET_LWP (lp
->ptid
)), lp
->step
,
1280 fprintf_unfiltered (gdb_stdlog
,
1281 "LLW: %s %s, 0, 0 (expect SIGSTOP)\n",
1282 lp
->step
? "PTRACE_SINGLESTEP" : "PTRACE_CONT",
1283 target_pid_to_str (lp
->ptid
));
1285 gdb_assert (lp
->resumed
);
1287 /* This should catch the pending SIGSTOP. */
1288 stop_wait_callback (lp
, NULL
);
1291 set_sigint_trap (); /* Causes SIGINT to be passed on to the
1292 attached process. */
1299 lwpid
= waitpid (pid
, &status
, options
);
1302 gdb_assert (pid
== -1 || lwpid
== pid
);
1306 fprintf_unfiltered (gdb_stdlog
,
1307 "LLW: waitpid %ld received %s\n",
1308 (long) lwpid
, status_to_str (status
));
1311 lp
= find_lwp_pid (pid_to_ptid (lwpid
));
1313 /* Check for stop events reported by a process we didn't
1314 already know about - anything not already in our LWP
1317 If we're expecting to receive stopped processes after
1318 fork, vfork, and clone events, then we'll just add the
1319 new one to our list and go back to waiting for the event
1320 to be reported - the stopped process might be returned
1321 from waitpid before or after the event is. */
1322 if (WIFSTOPPED (status
) && !lp
)
1324 linux_record_stopped_pid (lwpid
);
1329 /* Make sure we don't report an event for the exit of an LWP not in
1330 our list, i.e. not part of the current process. This can happen
1331 if we detach from a program we original forked and then it
1333 if (!WIFSTOPPED (status
) && !lp
)
1339 /* NOTE drow/2003-06-17: This code seems to be meant for debugging
1340 CLONE_PTRACE processes which do not use the thread library -
1341 otherwise we wouldn't find the new LWP this way. That doesn't
1342 currently work, and the following code is currently unreachable
1343 due to the two blocks above. If it's fixed some day, this code
1344 should be broken out into a function so that we can also pick up
1345 LWPs from the new interface. */
1348 lp
= add_lwp (BUILD_LWP (lwpid
, GET_PID (inferior_ptid
)));
1349 if (options
& __WCLONE
)
1354 gdb_assert (WIFSTOPPED (status
)
1355 && WSTOPSIG (status
) == SIGSTOP
);
1358 if (!in_thread_list (inferior_ptid
))
1360 inferior_ptid
= BUILD_LWP (GET_PID (inferior_ptid
),
1361 GET_PID (inferior_ptid
));
1362 add_thread (inferior_ptid
);
1365 add_thread (lp
->ptid
);
1366 printf_unfiltered ("[New %s]\n",
1367 target_pid_to_str (lp
->ptid
));
1371 /* Check if the thread has exited. */
1372 if ((WIFEXITED (status
) || WIFSIGNALED (status
)) && num_lwps
> 1)
1374 if (in_thread_list (lp
->ptid
))
1376 /* Core GDB cannot deal with us deleting the current
1378 if (!ptid_equal (lp
->ptid
, inferior_ptid
))
1379 delete_thread (lp
->ptid
);
1380 printf_unfiltered ("[%s exited]\n",
1381 target_pid_to_str (lp
->ptid
));
1384 /* If this is the main thread, we must stop all threads and
1385 verify if they are still alive. This is because in the nptl
1386 thread model, there is no signal issued for exiting LWPs
1387 other than the main thread. We only get the main thread
1388 exit signal once all child threads have already exited.
1389 If we stop all the threads and use the stop_wait_callback
1390 to check if they have exited we can determine whether this
1391 signal should be ignored or whether it means the end of the
1392 debugged application, regardless of which threading model
1394 if (GET_PID (lp
->ptid
) == GET_LWP (lp
->ptid
))
1397 iterate_over_lwps (stop_and_resume_callback
, NULL
);
1401 fprintf_unfiltered (gdb_stdlog
,
1402 "LLW: %s exited.\n",
1403 target_pid_to_str (lp
->ptid
));
1405 delete_lwp (lp
->ptid
);
1407 /* If there is at least one more LWP, then the exit signal
1408 was not the end of the debugged application and should be
1412 /* Make sure there is at least one thread running. */
1413 gdb_assert (iterate_over_lwps (running_callback
, NULL
));
1415 /* Discard the event. */
1421 /* Check if the current LWP has previously exited. In the nptl
1422 thread model, LWPs other than the main thread do not issue
1423 signals when they exit so we must check whenever the thread
1424 has stopped. A similar check is made in stop_wait_callback(). */
1425 if (num_lwps
> 1 && !lin_lwp_thread_alive (lp
->ptid
))
1427 if (in_thread_list (lp
->ptid
))
1429 /* Core GDB cannot deal with us deleting the current
1431 if (!ptid_equal (lp
->ptid
, inferior_ptid
))
1432 delete_thread (lp
->ptid
);
1433 printf_unfiltered ("[%s exited]\n",
1434 target_pid_to_str (lp
->ptid
));
1437 fprintf_unfiltered (gdb_stdlog
,
1438 "LLW: %s exited.\n",
1439 target_pid_to_str (lp
->ptid
));
1441 delete_lwp (lp
->ptid
);
1443 /* Make sure there is at least one thread running. */
1444 gdb_assert (iterate_over_lwps (running_callback
, NULL
));
1446 /* Discard the event. */
1451 /* Make sure we don't report a SIGSTOP that we sent
1452 ourselves in an attempt to stop an LWP. */
1454 && WIFSTOPPED (status
) && WSTOPSIG (status
) == SIGSTOP
)
1457 fprintf_unfiltered (gdb_stdlog
,
1458 "LLW: Delayed SIGSTOP caught for %s.\n",
1459 target_pid_to_str (lp
->ptid
));
1461 /* This is a delayed SIGSTOP. */
1464 registers_changed ();
1465 child_resume (pid_to_ptid (GET_LWP (lp
->ptid
)), lp
->step
,
1468 fprintf_unfiltered (gdb_stdlog
,
1469 "LLW: %s %s, 0, 0 (discard SIGSTOP)\n",
1471 "PTRACE_SINGLESTEP" : "PTRACE_CONT",
1472 target_pid_to_str (lp
->ptid
));
1475 gdb_assert (lp
->resumed
);
1477 /* Discard the event. */
1487 /* Alternate between checking cloned and uncloned processes. */
1488 options
^= __WCLONE
;
1490 /* And suspend every time we have checked both. */
1491 if (options
& __WCLONE
)
1492 sigsuspend (&suspend_mask
);
1495 /* We shouldn't end up here unless we want to try again. */
1496 gdb_assert (status
== 0);
1499 clear_sigio_trap ();
1500 clear_sigint_trap ();
1504 /* Don't report signals that GDB isn't interested in, such as
1505 signals that are neither printed nor stopped upon. Stopping all
1506 threads can be a bit time-consuming so if we want decent
1507 performance with heavily multi-threaded programs, especially when
1508 they're using a high frequency timer, we'd better avoid it if we
1511 if (WIFSTOPPED (status
))
1513 int signo
= target_signal_from_host (WSTOPSIG (status
));
1515 if (signal_stop_state (signo
) == 0
1516 && signal_print_state (signo
) == 0
1517 && signal_pass_state (signo
) == 1)
1519 /* FIMXE: kettenis/2001-06-06: Should we resume all threads
1520 here? It is not clear we should. GDB may not expect
1521 other threads to run. On the other hand, not resuming
1522 newly attached threads may cause an unwanted delay in
1523 getting them running. */
1524 registers_changed ();
1525 child_resume (pid_to_ptid (GET_LWP (lp
->ptid
)), lp
->step
, signo
);
1527 fprintf_unfiltered (gdb_stdlog
,
1528 "LLW: %s %s, %s (preempt 'handle')\n",
1530 "PTRACE_SINGLESTEP" : "PTRACE_CONT",
1531 target_pid_to_str (lp
->ptid
),
1532 signo
? strsignal (signo
) : "0");
1538 if (signo
== TARGET_SIGNAL_INT
&& signal_pass_state (signo
) == 0)
1540 /* If ^C/BREAK is typed at the tty/console, SIGINT gets
1541 forwarded to the entire process group, that is, all LWP's
1542 will receive it. Since we only want to report it once,
1543 we try to flush it from all LWPs except this one. */
1544 sigaddset (&flush_mask
, SIGINT
);
1548 /* This LWP is stopped now. */
1552 fprintf_unfiltered (gdb_stdlog
, "LLW: Candidate event %s in %s.\n",
1553 status_to_str (status
), target_pid_to_str (lp
->ptid
));
1555 /* Now stop all other LWP's ... */
1556 iterate_over_lwps (stop_callback
, NULL
);
1558 /* ... and wait until all of them have reported back that they're no
1560 iterate_over_lwps (stop_wait_callback
, &flush_mask
);
1561 iterate_over_lwps (flush_callback
, &flush_mask
);
1563 /* If we're not waiting for a specific LWP, choose an event LWP from
1564 among those that have had events. Giving equal priority to all
1565 LWPs that have had events helps prevent starvation. */
1567 select_event_lwp (&lp
, &status
);
1569 /* Now that we've selected our final event LWP, cancel any
1570 breakpoints in other LWPs that have hit a GDB breakpoint. See
1571 the comment in cancel_breakpoints_callback to find out why. */
1572 iterate_over_lwps (cancel_breakpoints_callback
, lp
);
1574 /* If we're not running in "threaded" mode, we'll report the bare
1577 if (WIFSTOPPED (status
) && WSTOPSIG (status
) == SIGTRAP
)
1579 trap_ptid
= (threaded
? lp
->ptid
: pid_to_ptid (GET_LWP (lp
->ptid
)));
1581 fprintf_unfiltered (gdb_stdlog
,
1582 "LLW: trap_ptid is %s.\n",
1583 target_pid_to_str (trap_ptid
));
1586 trap_ptid
= null_ptid
;
1588 /* Handle GNU/Linux's extended waitstatus for trace events. */
1589 if (WIFSTOPPED (status
) && WSTOPSIG (status
) == SIGTRAP
&& status
>> 16 != 0)
1591 linux_handle_extended_wait (ptid_get_pid (trap_ptid
),
1596 store_waitstatus (ourstatus
, status
);
1597 return (threaded
? lp
->ptid
: pid_to_ptid (GET_LWP (lp
->ptid
)));
1601 kill_callback (struct lwp_info
*lp
, void *data
)
1604 ptrace (PTRACE_KILL
, GET_LWP (lp
->ptid
), 0, 0);
1606 fprintf_unfiltered (gdb_stdlog
,
1607 "KC: PTRACE_KILL %s, 0, 0 (%s)\n",
1608 target_pid_to_str (lp
->ptid
),
1609 errno
? safe_strerror (errno
) : "OK");
1615 kill_wait_callback (struct lwp_info
*lp
, void *data
)
1619 /* We must make sure that there are no pending events (delayed
1620 SIGSTOPs, pending SIGTRAPs, etc.) to make sure the current
1621 program doesn't interfere with any following debugging session. */
1623 /* For cloned processes we must check both with __WCLONE and
1624 without, since the exit status of a cloned process isn't reported
1630 pid
= waitpid (GET_LWP (lp
->ptid
), NULL
, __WCLONE
);
1631 if (pid
!= (pid_t
) -1 && debug_lin_lwp
)
1633 fprintf_unfiltered (gdb_stdlog
,
1634 "KWC: wait %s received unknown.\n",
1635 target_pid_to_str (lp
->ptid
));
1638 while (pid
== GET_LWP (lp
->ptid
));
1640 gdb_assert (pid
== -1 && errno
== ECHILD
);
1645 pid
= waitpid (GET_LWP (lp
->ptid
), NULL
, 0);
1646 if (pid
!= (pid_t
) -1 && debug_lin_lwp
)
1648 fprintf_unfiltered (gdb_stdlog
,
1649 "KWC: wait %s received unk.\n",
1650 target_pid_to_str (lp
->ptid
));
1653 while (pid
== GET_LWP (lp
->ptid
));
1655 gdb_assert (pid
== -1 && errno
== ECHILD
);
1662 /* Kill all LWP's ... */
1663 iterate_over_lwps (kill_callback
, NULL
);
1665 /* ... and wait until we've flushed all events. */
1666 iterate_over_lwps (kill_wait_callback
, NULL
);
1668 target_mourn_inferior ();
1672 lin_lwp_create_inferior (char *exec_file
, char *allargs
, char **env
)
1674 child_ops
.to_create_inferior (exec_file
, allargs
, env
);
1678 lin_lwp_mourn_inferior (void)
1680 trap_ptid
= null_ptid
;
1682 /* Destroy LWP info; it's no longer valid. */
1685 /* Restore the original signal mask. */
1686 sigprocmask (SIG_SETMASK
, &normal_mask
, NULL
);
1687 sigemptyset (&blocked_mask
);
1689 child_ops
.to_mourn_inferior ();
1693 lin_lwp_xfer_memory (CORE_ADDR memaddr
, char *myaddr
, int len
, int write
,
1694 struct mem_attrib
*attrib
, struct target_ops
*target
)
1696 struct cleanup
*old_chain
= save_inferior_ptid ();
1699 if (is_lwp (inferior_ptid
))
1700 inferior_ptid
= pid_to_ptid (GET_LWP (inferior_ptid
));
1702 xfer
= linux_proc_xfer_memory (memaddr
, myaddr
, len
, write
, attrib
, target
);
1704 xfer
= child_xfer_memory (memaddr
, myaddr
, len
, write
, attrib
, target
);
1706 do_cleanups (old_chain
);
1711 lin_lwp_thread_alive (ptid_t ptid
)
1713 gdb_assert (is_lwp (ptid
));
1716 ptrace (PTRACE_PEEKUSER
, GET_LWP (ptid
), 0, 0);
1718 fprintf_unfiltered (gdb_stdlog
,
1719 "LLTA: PTRACE_PEEKUSER %s, 0, 0 (%s)\n",
1720 target_pid_to_str (ptid
),
1721 errno
? safe_strerror (errno
) : "OK");
1729 lin_lwp_pid_to_str (ptid_t ptid
)
1731 static char buf
[64];
1735 snprintf (buf
, sizeof (buf
), "LWP %ld", GET_LWP (ptid
));
1739 return normal_pid_to_str (ptid
);
1743 init_lin_lwp_ops (void)
1746 lin_lwp_ops
.to_open
= lin_lwp_open
;
1748 lin_lwp_ops
.to_shortname
= "lwp-layer";
1749 lin_lwp_ops
.to_longname
= "lwp-layer";
1750 lin_lwp_ops
.to_doc
= "Low level threads support (LWP layer)";
1751 lin_lwp_ops
.to_attach
= lin_lwp_attach
;
1752 lin_lwp_ops
.to_detach
= lin_lwp_detach
;
1753 lin_lwp_ops
.to_resume
= lin_lwp_resume
;
1754 lin_lwp_ops
.to_wait
= lin_lwp_wait
;
1755 /* fetch_inferior_registers and store_inferior_registers will
1756 honor the LWP id, so we can use them directly. */
1757 lin_lwp_ops
.to_fetch_registers
= fetch_inferior_registers
;
1758 lin_lwp_ops
.to_store_registers
= store_inferior_registers
;
1759 lin_lwp_ops
.to_xfer_memory
= lin_lwp_xfer_memory
;
1760 lin_lwp_ops
.to_kill
= lin_lwp_kill
;
1761 lin_lwp_ops
.to_create_inferior
= lin_lwp_create_inferior
;
1762 lin_lwp_ops
.to_mourn_inferior
= lin_lwp_mourn_inferior
;
1763 lin_lwp_ops
.to_thread_alive
= lin_lwp_thread_alive
;
1764 lin_lwp_ops
.to_pid_to_str
= lin_lwp_pid_to_str
;
1765 lin_lwp_ops
.to_post_startup_inferior
= child_post_startup_inferior
;
1766 lin_lwp_ops
.to_post_attach
= child_post_attach
;
1767 lin_lwp_ops
.to_insert_fork_catchpoint
= child_insert_fork_catchpoint
;
1768 lin_lwp_ops
.to_insert_vfork_catchpoint
= child_insert_vfork_catchpoint
;
1769 lin_lwp_ops
.to_insert_exec_catchpoint
= child_insert_exec_catchpoint
;
1771 lin_lwp_ops
.to_stratum
= thread_stratum
;
1772 lin_lwp_ops
.to_has_thread_control
= tc_schedlock
;
1773 lin_lwp_ops
.to_magic
= OPS_MAGIC
;
1777 sigchld_handler (int signo
)
1779 /* Do nothing. The only reason for this handler is that it allows
1780 us to use sigsuspend in lin_lwp_wait above to wait for the
1781 arrival of a SIGCHLD. */
1785 _initialize_lin_lwp (void)
1787 struct sigaction action
;
1789 extern void thread_db_init (struct target_ops
*);
1791 init_lin_lwp_ops ();
1792 add_target (&lin_lwp_ops
);
1793 thread_db_init (&lin_lwp_ops
);
1795 /* Save the original signal mask. */
1796 sigprocmask (SIG_SETMASK
, NULL
, &normal_mask
);
1798 action
.sa_handler
= sigchld_handler
;
1799 sigemptyset (&action
.sa_mask
);
1800 action
.sa_flags
= 0;
1801 sigaction (SIGCHLD
, &action
, NULL
);
1803 /* Make sure we don't block SIGCHLD during a sigsuspend. */
1804 sigprocmask (SIG_SETMASK
, NULL
, &suspend_mask
);
1805 sigdelset (&suspend_mask
, SIGCHLD
);
1807 sigemptyset (&blocked_mask
);
1809 add_show_from_set (add_set_cmd ("lin-lwp", no_class
, var_zinteger
,
1810 (char *) &debug_lin_lwp
,
1811 "Set debugging of GNU/Linux lwp module.\n\
1812 Enables printf debugging output.\n", &setdebuglist
), &showdebuglist
);
1816 /* FIXME: kettenis/2000-08-26: The stuff on this page is specific to
1817 the GNU/Linux Threads library and therefore doesn't really belong
1820 /* Read variable NAME in the target and return its value if found.
1821 Otherwise return zero. It is assumed that the type of the variable
1825 get_signo (const char *name
)
1827 struct minimal_symbol
*ms
;
1830 ms
= lookup_minimal_symbol (name
, NULL
, NULL
);
1834 if (target_read_memory (SYMBOL_VALUE_ADDRESS (ms
), (char *) &signo
,
1835 sizeof (signo
)) != 0)
1841 /* Return the set of signals used by the threads library in *SET. */
1844 lin_thread_get_thread_signals (sigset_t
*set
)
1846 struct sigaction action
;
1847 int restart
, cancel
;
1851 restart
= get_signo ("__pthread_sig_restart");
1855 cancel
= get_signo ("__pthread_sig_cancel");
1859 sigaddset (set
, restart
);
1860 sigaddset (set
, cancel
);
1862 /* The GNU/Linux Threads library makes terminating threads send a
1863 special "cancel" signal instead of SIGCHLD. Make sure we catch
1864 those (to prevent them from terminating GDB itself, which is
1865 likely to be their default action) and treat them the same way as
1868 action
.sa_handler
= sigchld_handler
;
1869 sigemptyset (&action
.sa_mask
);
1870 action
.sa_flags
= 0;
1871 sigaction (cancel
, &action
, NULL
);
1873 /* We block the "cancel" signal throughout this code ... */
1874 sigaddset (&blocked_mask
, cancel
);
1875 sigprocmask (SIG_BLOCK
, &blocked_mask
, NULL
);
1877 /* ... except during a sigsuspend. */
1878 sigdelset (&suspend_mask
, cancel
);