1 /* Multi-threaded debugging support for GNU/Linux (LWP layer).
2 Copyright 2000, 2001 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 #include <sys/ptrace.h>
30 #include "gdbthread.h"
36 static int debug_lin_lwp
;
37 extern const char *strsignal (int sig
);
39 /* On GNU/Linux there are no real LWP's. The closest thing to LWP's
40 are processes sharing the same VM space. A multi-threaded process
41 is basically a group of such processes. However, such a grouping
42 is almost entirely a user-space issue; the kernel doesn't enforce
43 such a grouping at all (this might change in the future). In
44 general, we'll rely on the threads library (i.e. the GNU/Linux
45 Threads library) to provide such a grouping.
47 It is perfectly well possible to write a multi-threaded application
48 without the assistance of a threads library, by using the clone
49 system call directly. This module should be able to give some
50 rudimentary support for debugging such applications if developers
51 specify the CLONE_PTRACE flag in the clone system call, and are
52 using the Linux kernel 2.4 or above.
54 Note that there are some peculiarities in GNU/Linux that affect
57 - In general one should specify the __WCLONE flag to waitpid in
58 order to make it report events for any of the cloned processes
59 (and leave it out for the initial process). However, if a cloned
60 process has exited the exit status is only reported if the
61 __WCLONE flag is absent. Linux kernel 2.4 has a __WALL flag, but
62 we cannot use it since GDB must work on older systems too.
64 - When a traced, cloned process exits and is waited for by the
65 debugger, the kernel reassigns it to the original parent and
66 keeps it around as a "zombie". Somehow, the GNU/Linux Threads
67 library doesn't notice this, which leads to the "zombie problem":
68 When debugged a multi-threaded process that spawns a lot of
69 threads will run out of processes, even if the threads exit,
70 because the "zombies" stay around. */
72 /* Structure describing a LWP. */
75 /* The process id of the LWP. This is a combination of the LWP id
76 and overall process id. */
79 /* Non-zero if this LWP is cloned. In this context "cloned" means
80 that the LWP is reporting to its parent using a signal other than
84 /* Non-zero if we sent this LWP a SIGSTOP (but the LWP didn't report
88 /* Non-zero if this LWP is stopped. */
91 /* Non-zero if this LWP will be/has been resumed. Note that an LWP
92 can be marked both as stopped and resumed at the same time. This
93 happens if we try to resume an LWP that has a wait status
94 pending. We shouldn't let the LWP run until that wait status has
95 been processed, but we should not report that wait status if GDB
96 didn't try to let the LWP run. */
99 /* If non-zero, a pending wait status. */
102 /* Non-zero if we were stepping this LWP. */
105 /* Next LWP in list. */
106 struct lwp_info
*next
;
109 /* List of known LWPs. */
110 static struct lwp_info
*lwp_list
;
112 /* Number of LWPs in the list. */
115 /* Non-zero if we're running in "threaded" mode. */
119 #define GET_LWP(ptid) ptid_get_lwp (ptid)
120 #define GET_PID(ptid) ptid_get_pid (ptid)
121 #define is_lwp(ptid) (GET_LWP (ptid) != 0)
122 #define BUILD_LWP(lwp, pid) ptid_build (pid, lwp, 0)
124 /* If the last reported event was a SIGTRAP, this variable is set to
125 the process id of the LWP/thread that got it. */
129 /* This module's target-specific operations. */
130 static struct target_ops lin_lwp_ops
;
132 /* The standard child operations. */
133 extern struct target_ops child_ops
;
135 /* Since we cannot wait (in lin_lwp_wait) for the initial process and
136 any cloned processes with a single call to waitpid, we have to use
137 the WNOHANG flag and call waitpid in a loop. To optimize
138 things a bit we use `sigsuspend' to wake us up when a process has
139 something to report (it will send us a SIGCHLD if it has). To make
140 this work we have to juggle with the signal mask. We save the
141 original signal mask such that we can restore it before creating a
142 new process in order to avoid blocking certain signals in the
143 inferior. We then block SIGCHLD during the waitpid/sigsuspend
146 /* Original signal mask. */
147 static sigset_t normal_mask
;
149 /* Signal mask for use with sigsuspend in lin_lwp_wait, initialized in
150 _initialize_lin_lwp. */
151 static sigset_t suspend_mask
;
153 /* Signals to block to make that sigsuspend work. */
154 static sigset_t blocked_mask
;
157 /* Prototypes for local functions. */
158 static int stop_wait_callback (struct lwp_info
*lp
, void *data
);
160 /* Convert wait status STATUS to a string. Used for printing debug
164 status_to_str (int status
)
168 if (WIFSTOPPED (status
))
169 snprintf (buf
, sizeof (buf
), "%s (stopped)",
170 strsignal (WSTOPSIG (status
)));
171 else if (WIFSIGNALED (status
))
172 snprintf (buf
, sizeof (buf
), "%s (terminated)",
173 strsignal (WSTOPSIG (status
)));
175 snprintf (buf
, sizeof (buf
), "%d (exited)",
176 WEXITSTATUS (status
));
181 /* Initialize the list of LWPs. Note that this module, contrary to
182 what GDB's generic threads layer does for its thread list,
183 re-initializes the LWP lists whenever we mourn or detach (which
184 doesn't involve mourning) the inferior. */
189 struct lwp_info
*lp
, *lpnext
;
191 for (lp
= lwp_list
; lp
; lp
= lpnext
)
202 /* Add the LWP specified by PID to the list. If this causes the
203 number of LWPs to become larger than one, go into "threaded" mode.
204 Return a pointer to the structure describing the new LWP. */
206 static struct lwp_info
*
207 add_lwp (ptid_t ptid
)
211 gdb_assert (is_lwp (ptid
));
213 lp
= (struct lwp_info
*) xmalloc (sizeof (struct lwp_info
));
215 memset (lp
, 0, sizeof (struct lwp_info
));
227 /* Remove the LWP specified by PID from the list. */
230 delete_lwp (ptid_t ptid
)
232 struct lwp_info
*lp
, *lpprev
;
236 for (lp
= lwp_list
; lp
; lpprev
= lp
, lp
= lp
->next
)
237 if (ptid_equal (lp
->ptid
, ptid
))
243 /* We don't go back to "non-threaded" mode if the number of threads
244 becomes less than two. */
248 lpprev
->next
= lp
->next
;
255 /* Return a pointer to the structure describing the LWP corresponding
256 to PID. If no corresponding LWP could be found, return NULL. */
258 static struct lwp_info
*
259 find_lwp_pid (ptid_t ptid
)
265 lwp
= GET_LWP (ptid
);
267 lwp
= GET_PID (ptid
);
269 for (lp
= lwp_list
; lp
; lp
= lp
->next
)
270 if (lwp
== GET_LWP (lp
->ptid
))
276 /* Call CALLBACK with its second argument set to DATA for every LWP in
277 the list. If CALLBACK returns 1 for a particular LWP, return a
278 pointer to the structure describing that LWP immediately.
279 Otherwise return NULL. */
282 iterate_over_lwps (int (*callback
) (struct lwp_info
*, void *), void *data
)
284 struct lwp_info
*lp
, *lpnext
;
286 for (lp
= lwp_list
; lp
; lp
= lpnext
)
289 if ((*callback
) (lp
, data
))
297 /* Implementation of the PREPARE_TO_PROCEED hook for the GNU/Linux LWP
300 Note that this implementation is potentially redundant now that
301 default_prepare_to_proceed() has been added.
303 FIXME This may not support switching threads after Ctrl-C
304 correctly. The default implementation does support this. */
307 lin_lwp_prepare_to_proceed (void)
309 if (! ptid_equal (trap_ptid
, null_ptid
)
310 && ! ptid_equal (inferior_ptid
, trap_ptid
))
312 /* Switched over from TRAP_PID. */
313 CORE_ADDR stop_pc
= read_pc ();
316 /* Avoid switching where it wouldn't do any good, i.e. if both
317 threads are at the same breakpoint. */
318 trap_pc
= read_pc_pid (trap_ptid
);
319 if (trap_pc
!= stop_pc
&& breakpoint_here_p (trap_pc
))
321 /* User hasn't deleted the breakpoint. Return non-zero, and
322 switch back to TRAP_PID. */
323 inferior_ptid
= trap_ptid
;
325 /* FIXME: Is this stuff really necessary? */
326 flush_cached_frames ();
327 registers_changed ();
339 lin_lwp_open (char *args
, int from_tty
)
341 push_target (&lin_lwp_ops
);
345 /* Attach to the LWP specified by PID. If VERBOSE is non-zero, print
346 a message telling the user that a new LWP has been added to the
350 lin_lwp_attach_lwp (ptid_t ptid
, int verbose
)
354 gdb_assert (is_lwp (ptid
));
356 /* Make sure SIGCHLD is blocked. We don't want SIGCHLD events
357 to interrupt either the ptrace() or waitpid() calls below. */
358 if (! sigismember (&blocked_mask
, SIGCHLD
))
360 sigaddset (&blocked_mask
, SIGCHLD
);
361 sigprocmask (SIG_BLOCK
, &blocked_mask
, NULL
);
365 printf_filtered ("[New %s]\n", target_pid_to_str (ptid
));
367 lp
= find_lwp_pid (ptid
);
371 /* We assume that we're already attached to any LWP that has an
372 id equal to the overall process id. */
373 if (GET_LWP (ptid
) != GET_PID (ptid
))
378 if (ptrace (PTRACE_ATTACH
, GET_LWP (ptid
), 0, 0) < 0)
379 error ("Can't attach %s: %s", target_pid_to_str (ptid
),
380 safe_strerror (errno
));
382 pid
= waitpid (GET_LWP (ptid
), &status
, 0);
383 if (pid
== -1 && errno
== ECHILD
)
385 /* Try again with __WCLONE to check cloned processes. */
386 pid
= waitpid (GET_LWP (ptid
), &status
, __WCLONE
);
390 gdb_assert (pid
== GET_LWP (ptid
)
391 && WIFSTOPPED (status
) && WSTOPSIG (status
));
397 /* We assume that the LWP representing the original process
398 is already stopped. Mark it as stopped in the data structure
399 that the lin-lwp layer uses to keep track of threads. Note
400 that this won't have already been done since the main thread
401 will have, we assume, been stopped by an attach from a
408 lin_lwp_attach (char *args
, int from_tty
)
414 /* FIXME: We should probably accept a list of process id's, and
415 attach all of them. */
416 child_ops
.to_attach (args
, from_tty
);
418 /* Add the initial process as the first LWP to the list. */
419 lp
= add_lwp (BUILD_LWP (GET_PID (inferior_ptid
), GET_PID (inferior_ptid
)));
421 /* Make sure the initial process is stopped. The user-level threads
422 layer might want to poke around in the inferior, and that won't
423 work if things haven't stabilized yet. */
424 pid
= waitpid (GET_PID (inferior_ptid
), &status
, 0);
425 if (pid
== -1 && errno
== ECHILD
)
427 warning ("%s is a cloned process", target_pid_to_str (inferior_ptid
));
429 /* Try again with __WCLONE to check cloned processes. */
430 pid
= waitpid (GET_PID (inferior_ptid
), &status
, __WCLONE
);
434 gdb_assert (pid
== GET_PID (inferior_ptid
)
435 && WIFSTOPPED (status
) && WSTOPSIG (status
) == SIGSTOP
);
439 /* Fake the SIGSTOP that core GDB expects. */
440 lp
->status
= W_STOPCODE (SIGSTOP
);
445 detach_callback (struct lwp_info
*lp
, void *data
)
447 gdb_assert (lp
->status
== 0 || WIFSTOPPED (lp
->status
));
449 if (debug_lin_lwp
&& lp
->status
)
450 fprintf_unfiltered (gdb_stdlog
, "Pending %s for LWP %ld on detach.\n",
451 strsignal (WSTOPSIG (lp
->status
)), GET_LWP (lp
->ptid
));
453 while (lp
->signalled
&& lp
->stopped
)
455 if (ptrace (PTRACE_CONT
, GET_LWP (lp
->ptid
), 0,
456 WSTOPSIG (lp
->status
)) < 0)
457 error ("Can't continue %s: %s", target_pid_to_str (lp
->ptid
),
458 safe_strerror (errno
));
463 stop_wait_callback (lp
, NULL
);
465 gdb_assert (lp
->status
== 0 || WIFSTOPPED (lp
->status
));
468 /* We don't actually detach from the LWP that has an id equal to the
469 overall process id just yet. */
470 if (GET_LWP (lp
->ptid
) != GET_PID (lp
->ptid
))
472 if (ptrace (PTRACE_DETACH
, GET_LWP (lp
->ptid
), 0,
473 WSTOPSIG (lp
->status
)) < 0)
474 error ("Can't detach %s: %s", target_pid_to_str (lp
->ptid
),
475 safe_strerror (errno
));
477 delete_lwp (lp
->ptid
);
484 lin_lwp_detach (char *args
, int from_tty
)
486 iterate_over_lwps (detach_callback
, NULL
);
488 /* Only the initial process should be left right now. */
489 gdb_assert (num_lwps
== 1);
491 trap_ptid
= null_ptid
;
493 /* Destroy LWP info; it's no longer valid. */
496 /* Restore the original signal mask. */
497 sigprocmask (SIG_SETMASK
, &normal_mask
, NULL
);
498 sigemptyset (&blocked_mask
);
500 inferior_ptid
= pid_to_ptid (GET_PID (inferior_ptid
));
501 child_ops
.to_detach (args
, from_tty
);
505 struct private_thread_info
510 /* Return non-zero if TP corresponds to the LWP specified by DATA
511 (which is assumed to be a pointer to a `struct lwp_info'. */
514 find_lwp_callback (struct thread_info
*tp
, void *data
)
516 struct lwp_info
*lp
= data
;
518 if (tp
->private->lwpid
== GET_LWP (lp
->ptid
))
527 resume_callback (struct lwp_info
*lp
, void *data
)
529 if (lp
->stopped
&& lp
->status
== 0)
531 struct thread_info
*tp
;
534 /* FIXME: kettenis/2000-08-26: This should really be handled
535 properly by core GDB. */
537 tp
= find_thread_pid (lp
->ptid
);
539 tp
= iterate_over_threads (find_lwp_callback
, lp
);
542 /* If we were previously stepping the thread, and now continue
543 the thread we must invalidate the stepping range. However,
544 if there is a step_resume breakpoint for this thread, we must
545 preserve the stepping range to make it possible to continue
546 stepping once we hit it. */
547 if (tp
->step_range_end
&& tp
->step_resume_breakpoint
== NULL
)
549 gdb_assert (lp
->step
);
550 tp
->step_range_start
= tp
->step_range_end
= 0;
554 child_resume (pid_to_ptid (GET_LWP (lp
->ptid
)), 0, TARGET_SIGNAL_0
);
563 resume_clear_callback (struct lwp_info
*lp
, void *data
)
570 resume_set_callback (struct lwp_info
*lp
, void *data
)
577 lin_lwp_resume (ptid_t ptid
, int step
, enum target_signal signo
)
582 /* A specific PTID means `step only this process id'. */
583 resume_all
= (PIDGET (ptid
) == -1);
586 iterate_over_lwps (resume_set_callback
, NULL
);
588 iterate_over_lwps (resume_clear_callback
, NULL
);
590 /* If PID is -1, it's the current inferior that should be
591 handled specially. */
592 if (PIDGET (ptid
) == -1)
593 ptid
= inferior_ptid
;
595 lp
= find_lwp_pid (ptid
);
598 ptid
= pid_to_ptid (GET_LWP (lp
->ptid
));
600 /* Remember if we're stepping. */
603 /* Mark this LWP as resumed. */
606 /* If we have a pending wait status for this thread, there is no
607 point in resuming the process. */
610 /* FIXME: What should we do if we are supposed to continue
611 this thread with a signal? */
612 gdb_assert (signo
== TARGET_SIGNAL_0
);
616 /* Mark LWP as not stopped to prevent it from being continued by
622 iterate_over_lwps (resume_callback
, NULL
);
624 child_resume (ptid
, step
, signo
);
628 /* Send a SIGSTOP to LP. */
631 stop_callback (struct lwp_info
*lp
, void *data
)
633 if (! lp
->stopped
&& ! lp
->signalled
)
637 ret
= kill (GET_LWP (lp
->ptid
), SIGSTOP
);
638 gdb_assert (ret
== 0);
641 gdb_assert (lp
->status
== 0);
647 /* Wait until LP is stopped. If DATA is non-null it is interpreted as
648 a pointer to a set of signals to be flushed immediately. */
651 stop_wait_callback (struct lwp_info
*lp
, void *data
)
653 sigset_t
*flush_mask
= data
;
655 if (! lp
->stopped
&& lp
->signalled
)
660 gdb_assert (lp
->status
== 0);
662 pid
= waitpid (GET_LWP (lp
->ptid
), &status
, lp
->cloned
? __WCLONE
: 0);
663 if (pid
== -1 && errno
== ECHILD
)
664 /* OK, the proccess has disappeared. We'll catch the actual
665 exit event in lin_lwp_wait. */
668 gdb_assert (pid
== GET_LWP (lp
->ptid
));
670 if (WIFEXITED (status
) || WIFSIGNALED (status
))
672 gdb_assert (num_lwps
> 1);
674 if (in_thread_list (lp
->ptid
))
676 /* Core GDB cannot deal with us deleting the current
678 if (!ptid_equal (lp
->ptid
, inferior_ptid
))
679 delete_thread (lp
->ptid
);
680 printf_unfiltered ("[%s exited]\n",
681 target_pid_to_str (lp
->ptid
));
684 fprintf_unfiltered (gdb_stdlog
,
685 "%s exited.\n", target_pid_to_str (lp
->ptid
));
687 delete_lwp (lp
->ptid
);
691 gdb_assert (WIFSTOPPED (status
));
693 /* Ignore any signals in FLUSH_MASK. */
694 if (flush_mask
&& sigismember (flush_mask
, WSTOPSIG (status
)))
696 ptrace (PTRACE_CONT
, GET_LWP (lp
->ptid
), 0, 0);
697 return stop_wait_callback (lp
, flush_mask
);
700 if (WSTOPSIG (status
) != SIGSTOP
)
702 if (WSTOPSIG (status
) == SIGTRAP
)
704 /* If a LWP other than the LWP that we're reporting an
705 event for has hit a GDB breakpoint (as opposed to
706 some random trap signal), then just arrange for it to
707 hit it again later. We don't keep the SIGTRAP status
708 and don't forward the SIGTRAP signal to the LWP. We
709 will handle the current event, eventually we will
710 resume all LWPs, and this one will get its breakpoint
713 If we do not do this, then we run the risk that the
714 user will delete or disable the breakpoint, but the
715 thread will have already tripped on it. */
717 /* Now resume this LWP and get the SIGSTOP event. */
718 ptrace (PTRACE_CONT
, GET_LWP (lp
->ptid
), 0, 0);
721 fprintf_unfiltered (gdb_stderr
,
722 "SWC: Candidate SIGTRAP event in %ld\n",
725 /* Hold the SIGTRAP for handling by lin_lwp_wait. */
726 stop_wait_callback (lp
, data
);
727 /* If there's another event, throw it back into the queue. */
729 kill (GET_LWP (lp
->ptid
), WSTOPSIG (lp
->status
));
730 /* Save the sigtrap event. */
736 /* The thread was stopped with a signal other than
737 SIGSTOP, and didn't accidentally trip a breakpoint. */
741 fprintf_unfiltered (gdb_stderr
,
742 "SWC: Pending event %d in %ld\n",
743 WSTOPSIG (status
), GET_LWP (lp
->ptid
));
745 /* Now resume this LWP and get the SIGSTOP event. */
746 ptrace (PTRACE_CONT
, GET_LWP (lp
->ptid
), 0, 0);
748 /* Hold this event/waitstatus while we check to see if
749 there are any more (we still want to get that SIGSTOP). */
750 stop_wait_callback (lp
, data
);
751 /* If the lp->status field is still empty, use it to hold
752 this event. If not, then this event must be returned
753 to the event queue of the LWP. */
757 kill (GET_LWP (lp
->ptid
), WSTOPSIG (status
));
763 /* We caught the SIGSTOP that we intended to catch, so
764 there's no SIGSTOP pending. */
773 /* Return non-zero if LP has a wait status pending. */
776 status_callback (struct lwp_info
*lp
, void *data
)
778 /* Only report a pending wait status if we pretend that this has
779 indeed been resumed. */
780 return (lp
->status
!= 0 && lp
->resumed
);
783 /* Return non-zero if LP isn't stopped. */
786 running_callback (struct lwp_info
*lp
, void *data
)
788 return (lp
->stopped
== 0);
791 /* Count the LWP's that have had events. */
794 count_events_callback (struct lwp_info
*lp
, void *data
)
798 gdb_assert (count
!= NULL
);
800 /* Count only LWPs that have a SIGTRAP event pending. */
802 && WIFSTOPPED (lp
->status
) && WSTOPSIG (lp
->status
) == SIGTRAP
)
808 /* Select the LWP (if any) that is currently being single-stepped. */
811 select_singlestep_lwp_callback (struct lwp_info
*lp
, void *data
)
813 if (lp
->step
&& lp
->status
!= 0)
819 /* Select the Nth LWP that has had a SIGTRAP event. */
822 select_event_lwp_callback (struct lwp_info
*lp
, void *data
)
824 int *selector
= data
;
826 gdb_assert (selector
!= NULL
);
828 /* Select only LWPs that have a SIGTRAP event pending. */
830 && WIFSTOPPED (lp
->status
) && WSTOPSIG (lp
->status
) == SIGTRAP
)
831 if ((*selector
)-- == 0)
838 cancel_breakpoints_callback (struct lwp_info
*lp
, void *data
)
840 struct lwp_info
*event_lp
= data
;
842 /* Leave the LWP that has been elected to receive a SIGTRAP alone. */
846 /* If a LWP other than the LWP that we're reporting an event for has
847 hit a GDB breakpoint (as opposed to some random trap signal),
848 then just arrange for it to hit it again later. We don't keep
849 the SIGTRAP status and don't forward the SIGTRAP signal to the
850 LWP. We will handle the current event, eventually we will resume
851 all LWPs, and this one will get its breakpoint trap again.
853 If we do not do this, then we run the risk that the user will
854 delete or disable the breakpoint, but the LWP will have already
858 && WIFSTOPPED (lp
->status
) && WSTOPSIG (lp
->status
) == SIGTRAP
859 && breakpoint_inserted_here_p (read_pc_pid (lp
->ptid
) -
860 DECR_PC_AFTER_BREAK
))
863 fprintf_unfiltered (gdb_stdlog
,
864 "Push back breakpoint for LWP %ld\n",
867 /* Back up the PC if necessary. */
868 if (DECR_PC_AFTER_BREAK
)
869 write_pc_pid (read_pc_pid (lp
->ptid
) - DECR_PC_AFTER_BREAK
, lp
->ptid
);
871 /* Throw away the SIGTRAP. */
878 /* Select one LWP out of those that have events pending. */
881 select_event_lwp (struct lwp_info
**orig_lp
, int *status
)
885 struct lwp_info
*event_lp
;
887 /* Record the wait status for the origional LWP. */
888 (*orig_lp
)->status
= *status
;
890 /* Give preference to any LWP that is being single-stepped. */
891 event_lp
= iterate_over_lwps (select_singlestep_lwp_callback
, NULL
);
892 if (event_lp
!= NULL
)
895 fprintf_unfiltered (gdb_stdlog
,
896 "Select single-step LWP %ld\n",
897 GET_LWP (event_lp
->ptid
));
901 /* No single-stepping LWP. Select one at random, out of those
902 which have had SIGTRAP events. */
904 /* First see how many SIGTRAP events we have. */
905 iterate_over_lwps (count_events_callback
, &num_events
);
907 /* Now randomly pick a LWP out of those that have had a SIGTRAP. */
908 random_selector
= (int)
909 ((num_events
* (double) rand ()) / (RAND_MAX
+ 1.0));
911 if (debug_lin_lwp
&& num_events
> 1)
912 fprintf_unfiltered (gdb_stdlog
,
913 "Found %d SIGTRAP events, selecting #%d\n",
914 num_events
, random_selector
);
916 event_lp
= iterate_over_lwps (select_event_lwp_callback
,
920 if (event_lp
!= NULL
)
922 /* Switch the event LWP. */
924 *status
= event_lp
->status
;
927 /* Flush the wait status for the event LWP. */
928 (*orig_lp
)->status
= 0;
931 /* Return non-zero if LP has been resumed. */
934 resumed_callback (struct lwp_info
*lp
, void *data
)
941 /* We need to override child_wait to support attaching to cloned
942 processes, since a normal wait (as done by the default version)
943 ignores those processes. */
945 /* Wait for child PTID to do something. Return id of the child,
946 minus_one_ptid in case of error; store status into *OURSTATUS. */
949 child_wait (ptid_t ptid
, struct target_waitstatus
*ourstatus
)
957 set_sigint_trap (); /* Causes SIGINT to be passed on to the
961 pid
= waitpid (GET_PID (ptid
), &status
, 0);
962 if (pid
== -1 && errno
== ECHILD
)
963 /* Try again with __WCLONE to check cloned processes. */
964 pid
= waitpid (GET_PID (ptid
), &status
, __WCLONE
);
968 clear_sigint_trap ();
970 while (pid
== -1 && save_errno
== EINTR
);
974 warning ("Child process unexpectedly missing: %s", safe_strerror (errno
));
976 /* Claim it exited with unknown signal. */
977 ourstatus
->kind
= TARGET_WAITKIND_SIGNALLED
;
978 ourstatus
->value
.sig
= TARGET_SIGNAL_UNKNOWN
;
979 return minus_one_ptid
;
982 store_waitstatus (ourstatus
, status
);
983 return pid_to_ptid (pid
);
989 lin_lwp_wait (ptid_t ptid
, struct target_waitstatus
*ourstatus
)
991 struct lwp_info
*lp
= NULL
;
994 pid_t pid
= PIDGET (ptid
);
997 sigemptyset (&flush_mask
);
999 /* Make sure SIGCHLD is blocked. */
1000 if (! sigismember (&blocked_mask
, SIGCHLD
))
1002 sigaddset (&blocked_mask
, SIGCHLD
);
1003 sigprocmask (SIG_BLOCK
, &blocked_mask
, NULL
);
1008 /* Make sure there is at least one LWP that has been resumed, at
1009 least if there are any LWPs at all. */
1010 gdb_assert (num_lwps
== 0 || iterate_over_lwps (resumed_callback
, NULL
));
1012 /* First check if there is a LWP with a wait status pending. */
1015 /* Any LWP that's been resumed will do. */
1016 lp
= iterate_over_lwps (status_callback
, NULL
);
1019 status
= lp
->status
;
1022 if (debug_lin_lwp
&& status
)
1023 fprintf_unfiltered (gdb_stdlog
,
1024 "Using pending wait status %s for LWP %ld.\n",
1025 status_to_str (status
), GET_LWP (lp
->ptid
));
1028 /* But if we don't fine one, we'll have to wait, and check both
1029 cloned and uncloned processes. We start with the cloned
1031 options
= __WCLONE
| WNOHANG
;
1033 else if (is_lwp (ptid
))
1036 fprintf_unfiltered (gdb_stdlog
,
1037 "Waiting for specific LWP %ld.\n",
1040 /* We have a specific LWP to check. */
1041 lp
= find_lwp_pid (ptid
);
1043 status
= lp
->status
;
1046 if (debug_lin_lwp
&& status
)
1047 fprintf_unfiltered (gdb_stdlog
,
1048 "Using pending wait status %s for LWP %ld.\n",
1049 status_to_str (status
), GET_LWP (lp
->ptid
));
1051 /* If we have to wait, take into account whether PID is a cloned
1052 process or not. And we have to convert it to something that
1053 the layer beneath us can understand. */
1054 options
= lp
->cloned
? __WCLONE
: 0;
1055 pid
= GET_LWP (ptid
);
1058 if (status
&& lp
->signalled
)
1060 /* A pending SIGSTOP may interfere with the normal stream of
1061 events. In a typical case where interference is a problem,
1062 we have a SIGSTOP signal pending for LWP A while
1063 single-stepping it, encounter an event in LWP B, and take the
1064 pending SIGSTOP while trying to stop LWP A. After processing
1065 the event in LWP B, LWP A is continued, and we'll never see
1066 the SIGTRAP associated with the last time we were
1067 single-stepping LWP A. */
1069 /* Resume the thread. It should halt immediately returning the
1071 child_resume (pid_to_ptid (GET_LWP (lp
->ptid
)), lp
->step
,
1074 gdb_assert (lp
->resumed
);
1076 /* This should catch the pending SIGSTOP. */
1077 stop_wait_callback (lp
, NULL
);
1080 set_sigint_trap (); /* Causes SIGINT to be passed on to the
1081 attached process. */
1088 lwpid
= waitpid (pid
, &status
, options
);
1091 gdb_assert (pid
== -1 || lwpid
== pid
);
1093 lp
= find_lwp_pid (pid_to_ptid (lwpid
));
1096 lp
= add_lwp (BUILD_LWP (lwpid
, GET_PID (inferior_ptid
)));
1097 if (options
& __WCLONE
)
1102 gdb_assert (WIFSTOPPED (status
)
1103 && WSTOPSIG (status
) == SIGSTOP
);
1106 if (! in_thread_list (inferior_ptid
))
1108 inferior_ptid
= BUILD_LWP (GET_PID (inferior_ptid
),
1109 GET_PID (inferior_ptid
));
1110 add_thread (inferior_ptid
);
1113 add_thread (lp
->ptid
);
1114 printf_unfiltered ("[New %s]\n",
1115 target_pid_to_str (lp
->ptid
));
1119 /* Make sure we don't report a TARGET_WAITKIND_EXITED or
1120 TARGET_WAITKIND_SIGNALLED event if there are still LWP's
1121 left in the process. */
1122 if ((WIFEXITED (status
) || WIFSIGNALED (status
)) && num_lwps
> 1)
1124 if (in_thread_list (lp
->ptid
))
1126 /* Core GDB cannot deal with us deleting the current
1128 if (! ptid_equal (lp
->ptid
, inferior_ptid
))
1129 delete_thread (lp
->ptid
);
1130 printf_unfiltered ("[%s exited]\n",
1131 target_pid_to_str (lp
->ptid
));
1134 fprintf_unfiltered (gdb_stdlog
,
1136 target_pid_to_str (lp
->ptid
));
1138 delete_lwp (lp
->ptid
);
1140 /* Make sure there is at least one thread running. */
1141 gdb_assert (iterate_over_lwps (running_callback
, NULL
));
1143 /* Discard the event. */
1148 /* Make sure we don't report a SIGSTOP that we sent
1149 ourselves in an attempt to stop an LWP. */
1150 if (lp
->signalled
&& WIFSTOPPED (status
)
1151 && WSTOPSIG (status
) == SIGSTOP
)
1154 fprintf_unfiltered (gdb_stdlog
,
1155 "Delayed SIGSTOP caught for %s.\n",
1156 target_pid_to_str (lp
->ptid
));
1158 /* This is a delayed SIGSTOP. */
1161 child_resume (pid_to_ptid (GET_LWP (lp
->ptid
)), lp
->step
,
1164 gdb_assert (lp
->resumed
);
1166 /* Discard the event. */
1176 /* Alternate between checking cloned and uncloned processes. */
1177 options
^= __WCLONE
;
1179 /* And suspend every time we have checked both. */
1180 if (options
& __WCLONE
)
1181 sigsuspend (&suspend_mask
);
1184 /* We shouldn't end up here unless we want to try again. */
1185 gdb_assert (status
== 0);
1188 clear_sigio_trap ();
1189 clear_sigint_trap ();
1193 /* Don't report signals that GDB isn't interested in, such as
1194 signals that are neither printed nor stopped upon. Stopping all
1195 threads can be a bit time-consuming so if we want decent
1196 performance with heavily multi-threaded programs, especially when
1197 they're using a high frequency timer, we'd better avoid it if we
1200 if (WIFSTOPPED (status
))
1202 int signo
= target_signal_from_host (WSTOPSIG (status
));
1204 if (signal_stop_state (signo
) == 0
1205 && signal_print_state (signo
) == 0
1206 && signal_pass_state (signo
) == 1)
1208 /* FIMXE: kettenis/2001-06-06: Should we resume all threads
1209 here? It is not clear we should. GDB may not expect
1210 other threads to run. On the other hand, not resuming
1211 newly attached threads may cause an unwanted delay in
1212 getting them running. */
1213 child_resume (pid_to_ptid (GET_LWP (lp
->ptid
)), lp
->step
, signo
);
1219 if (signo
== TARGET_SIGNAL_INT
1220 && signal_pass_state (signo
) == 0)
1222 /* If ^C/BREAK is typed at the tty/console, SIGINT gets
1223 forwarded to the entire process group, that is, all LWP's
1224 will receive it. Since we only want to report it once,
1225 we try to flush it from all LWPs except this one. */
1226 sigaddset (&flush_mask
, SIGINT
);
1230 /* This LWP is stopped now. */
1234 fprintf_unfiltered (gdb_stdlog
, "Candidate event %s in LWP %ld.\n",
1235 status_to_str (status
), GET_LWP (lp
->ptid
));
1237 /* Now stop all other LWP's ... */
1238 iterate_over_lwps (stop_callback
, NULL
);
1240 /* ... and wait until all of them have reported back that they're no
1242 iterate_over_lwps (stop_wait_callback
, &flush_mask
);
1244 /* If we're not waiting for a specific LWP, choose an event LWP from
1245 among those that have had events. Giving equal priority to all
1246 LWPs that have had events helps prevent starvation. */
1248 select_event_lwp (&lp
, &status
);
1250 /* Now that we've selected our final event LWP, cancel any
1251 breakpoints in other LWPs that have hit a GDB breakpoint. See
1252 the comment in cancel_breakpoints_callback to find out why. */
1253 iterate_over_lwps (cancel_breakpoints_callback
, lp
);
1255 /* If we're not running in "threaded" mode, we'll report the bare
1258 if (WIFSTOPPED (status
) && WSTOPSIG (status
) == SIGTRAP
)
1260 trap_ptid
= (threaded
? lp
->ptid
: pid_to_ptid (GET_LWP (lp
->ptid
)));
1262 fprintf_unfiltered (gdb_stdlog
,
1263 "LLW: trap_ptid is %ld\n",
1264 GET_LWP (trap_ptid
));
1267 trap_ptid
= null_ptid
;
1269 store_waitstatus (ourstatus
, status
);
1270 return (threaded
? lp
->ptid
: pid_to_ptid (GET_LWP (lp
->ptid
)));
1274 kill_callback (struct lwp_info
*lp
, void *data
)
1276 ptrace (PTRACE_KILL
, GET_LWP (lp
->ptid
), 0, 0);
1281 kill_wait_callback (struct lwp_info
*lp
, void *data
)
1285 /* We must make sure that there are no pending events (delayed
1286 SIGSTOPs, pending SIGTRAPs, etc.) to make sure the current
1287 program doesn't interfere with any following debugging session. */
1289 /* For cloned processes we must check both with __WCLONE and
1290 without, since the exit status of a cloned process isn't reported
1296 pid
= waitpid (GET_LWP (lp
->ptid
), NULL
, __WCLONE
);
1298 while (pid
== GET_LWP (lp
->ptid
));
1300 gdb_assert (pid
== -1 && errno
== ECHILD
);
1305 pid
= waitpid (GET_LWP (lp
->ptid
), NULL
, 0);
1307 while (pid
== GET_LWP (lp
->ptid
));
1309 gdb_assert (pid
== -1 && errno
== ECHILD
);
1316 /* Kill all LWP's ... */
1317 iterate_over_lwps (kill_callback
, NULL
);
1319 /* ... and wait until we've flushed all events. */
1320 iterate_over_lwps (kill_wait_callback
, NULL
);
1322 target_mourn_inferior ();
1326 lin_lwp_create_inferior (char *exec_file
, char *allargs
, char **env
)
1328 child_ops
.to_create_inferior (exec_file
, allargs
, env
);
1332 lin_lwp_mourn_inferior (void)
1334 trap_ptid
= null_ptid
;
1336 /* Destroy LWP info; it's no longer valid. */
1339 /* Restore the original signal mask. */
1340 sigprocmask (SIG_SETMASK
, &normal_mask
, NULL
);
1341 sigemptyset (&blocked_mask
);
1343 child_ops
.to_mourn_inferior ();
1347 lin_lwp_fetch_registers (int regno
)
1349 struct cleanup
*old_chain
= save_inferior_ptid ();
1351 if (is_lwp (inferior_ptid
))
1352 inferior_ptid
= pid_to_ptid (GET_LWP (inferior_ptid
));
1354 fetch_inferior_registers (regno
);
1356 do_cleanups (old_chain
);
1360 lin_lwp_store_registers (int regno
)
1362 struct cleanup
*old_chain
= save_inferior_ptid ();
1364 if (is_lwp (inferior_ptid
))
1365 inferior_ptid
= pid_to_ptid (GET_LWP (inferior_ptid
));
1367 store_inferior_registers (regno
);
1369 do_cleanups (old_chain
);
1373 lin_lwp_xfer_memory (CORE_ADDR memaddr
, char *myaddr
, int len
, int write
,
1374 struct mem_attrib
*attrib
,
1375 struct target_ops
*target
)
1377 struct cleanup
*old_chain
= save_inferior_ptid ();
1380 if (is_lwp (inferior_ptid
))
1381 inferior_ptid
= pid_to_ptid (GET_LWP (inferior_ptid
));
1383 xfer
= linux_proc_xfer_memory (memaddr
, myaddr
, len
, write
, attrib
, target
);
1385 xfer
= child_xfer_memory (memaddr
, myaddr
, len
, write
, attrib
, target
);
1387 do_cleanups (old_chain
);
1392 lin_lwp_thread_alive (ptid_t ptid
)
1394 gdb_assert (is_lwp (ptid
));
1397 ptrace (PTRACE_PEEKUSER
, GET_LWP (ptid
), 0, 0);
1405 lin_lwp_pid_to_str (ptid_t ptid
)
1407 static char buf
[64];
1411 snprintf (buf
, sizeof (buf
), "LWP %ld", GET_LWP (ptid
));
1415 return normal_pid_to_str (ptid
);
1419 init_lin_lwp_ops (void)
1422 lin_lwp_ops
.to_open
= lin_lwp_open
;
1424 lin_lwp_ops
.to_shortname
= "lwp-layer";
1425 lin_lwp_ops
.to_longname
= "lwp-layer";
1426 lin_lwp_ops
.to_doc
= "Low level threads support (LWP layer)";
1427 lin_lwp_ops
.to_attach
= lin_lwp_attach
;
1428 lin_lwp_ops
.to_detach
= lin_lwp_detach
;
1429 lin_lwp_ops
.to_resume
= lin_lwp_resume
;
1430 lin_lwp_ops
.to_wait
= lin_lwp_wait
;
1431 lin_lwp_ops
.to_fetch_registers
= lin_lwp_fetch_registers
;
1432 lin_lwp_ops
.to_store_registers
= lin_lwp_store_registers
;
1433 lin_lwp_ops
.to_xfer_memory
= lin_lwp_xfer_memory
;
1434 lin_lwp_ops
.to_kill
= lin_lwp_kill
;
1435 lin_lwp_ops
.to_create_inferior
= lin_lwp_create_inferior
;
1436 lin_lwp_ops
.to_mourn_inferior
= lin_lwp_mourn_inferior
;
1437 lin_lwp_ops
.to_thread_alive
= lin_lwp_thread_alive
;
1438 lin_lwp_ops
.to_pid_to_str
= lin_lwp_pid_to_str
;
1439 lin_lwp_ops
.to_stratum
= thread_stratum
;
1440 lin_lwp_ops
.to_has_thread_control
= tc_schedlock
;
1441 lin_lwp_ops
.to_magic
= OPS_MAGIC
;
1445 sigchld_handler (int signo
)
1447 /* Do nothing. The only reason for this handler is that it allows
1448 us to use sigsuspend in lin_lwp_wait above to wait for the
1449 arrival of a SIGCHLD. */
1453 _initialize_lin_lwp (void)
1455 struct sigaction action
;
1457 extern void thread_db_init (struct target_ops
*);
1459 init_lin_lwp_ops ();
1460 add_target (&lin_lwp_ops
);
1461 thread_db_init (&lin_lwp_ops
);
1463 /* Save the original signal mask. */
1464 sigprocmask (SIG_SETMASK
, NULL
, &normal_mask
);
1466 action
.sa_handler
= sigchld_handler
;
1467 sigemptyset (&action
.sa_mask
);
1468 action
.sa_flags
= 0;
1469 sigaction (SIGCHLD
, &action
, NULL
);
1471 /* Make sure we don't block SIGCHLD during a sigsuspend. */
1472 sigprocmask (SIG_SETMASK
, NULL
, &suspend_mask
);
1473 sigdelset (&suspend_mask
, SIGCHLD
);
1475 sigemptyset (&blocked_mask
);
1477 add_show_from_set (add_set_cmd ("lin-lwp", no_class
, var_zinteger
,
1478 (char *) &debug_lin_lwp
,
1479 "Set debugging of GNU/Linux lwp module.\n\
1480 Enables printf debugging output.\n",
1486 /* FIXME: kettenis/2000-08-26: The stuff on this page is specific to
1487 the GNU/Linux Threads library and therefore doesn't really belong
1490 /* Read variable NAME in the target and return its value if found.
1491 Otherwise return zero. It is assumed that the type of the variable
1495 get_signo (const char *name
)
1497 struct minimal_symbol
*ms
;
1500 ms
= lookup_minimal_symbol (name
, NULL
, NULL
);
1504 if (target_read_memory (SYMBOL_VALUE_ADDRESS (ms
), (char *) &signo
,
1505 sizeof (signo
)) != 0)
1511 /* Return the set of signals used by the threads library in *SET. */
1514 lin_thread_get_thread_signals (sigset_t
*set
)
1516 struct sigaction action
;
1517 int restart
, cancel
;
1521 restart
= get_signo ("__pthread_sig_restart");
1525 cancel
= get_signo ("__pthread_sig_cancel");
1529 sigaddset (set
, restart
);
1530 sigaddset (set
, cancel
);
1532 /* The GNU/Linux Threads library makes terminating threads send a
1533 special "cancel" signal instead of SIGCHLD. Make sure we catch
1534 those (to prevent them from terminating GDB itself, which is
1535 likely to be their default action) and treat them the same way as
1538 action
.sa_handler
= sigchld_handler
;
1539 sigemptyset (&action
.sa_mask
);
1540 action
.sa_flags
= 0;
1541 sigaction (cancel
, &action
, NULL
);
1543 /* We block the "cancel" signal throughout this code ... */
1544 sigaddset (&blocked_mask
, cancel
);
1545 sigprocmask (SIG_BLOCK
, &blocked_mask
, NULL
);
1547 /* ... except during a sigsuspend. */
1548 sigdelset (&suspend_mask
, cancel
);