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"
26 #include <sys/ptrace.h>
29 #include "gdbthread.h"
35 static int debug_lin_lwp
;
36 extern const char *strsignal (int sig
);
38 /* On GNU/Linux there are no real LWP's. The closest thing to LWP's
39 are processes sharing the same VM space. A multi-threaded process
40 is basically a group of such processes. However, such a grouping
41 is almost entirely a user-space issue; the kernel doesn't enforce
42 such a grouping at all (this might change in the future). In
43 general, we'll rely on the threads library (i.e. the GNU/Linux
44 Threads library) to provide such a grouping.
46 It is perfectly well possible to write a multi-threaded application
47 without the assistance of a threads library, by using the clone
48 system call directly. This module should be able to give some
49 rudimentary support for debugging such applications if developers
50 specify the CLONE_PTRACE flag in the clone system call, and are
51 using the Linux kernel 2.4 or above.
53 Note that there are some peculiarities in GNU/Linux that affect
56 - In general one should specify the __WCLONE flag to waitpid in
57 order to make it report events for any of the cloned processes
58 (and leave it out for the initial process). However, if a cloned
59 process has exited the exit status is only reported if the
60 __WCLONE flag is absent. Linux kernel 2.4 has a __WALL flag, but
61 we cannot use it since GDB must work on older systems too.
63 - When a traced, cloned process exits and is waited for by the
64 debugger, the kernel reassigns it to the original parent and
65 keeps it around as a "zombie". Somehow, the GNU/Linux Threads
66 library doesn't notice this, which leads to the "zombie problem":
67 When debugged a multi-threaded process that spawns a lot of
68 threads will run out of processes, even if the threads exit,
69 because the "zombies" stay around. */
71 /* Structure describing a LWP. */
74 /* The process id of the LWP. This is a combination of the LWP id
75 and overall process id. */
78 /* Non-zero if this LWP is cloned. In this context "cloned" means
79 that the LWP is reporting to its parent using a signal other than
83 /* Non-zero if we sent this LWP a SIGSTOP (but the LWP didn't report
87 /* Non-zero if this LWP is stopped. */
90 /* Non-zero if this LWP will be/has been resumed. Note that an LWP
91 can be marked both as stopped and resumed at the same time. This
92 happens if we try to resume an LWP that has a wait status
93 pending. We shouldn't let the LWP run until that wait status has
94 been processed, but we should not report that wait status if GDB
95 didn't try to let the LWP run. */
98 /* If non-zero, a pending wait status. */
101 /* Non-zero if we were stepping this LWP. */
104 /* Next LWP in list. */
105 struct lwp_info
*next
;
108 /* List of known LWPs. */
109 static struct lwp_info
*lwp_list
;
111 /* Number of LWPs in the list. */
114 /* Non-zero if we're running in "threaded" mode. */
118 #define GET_LWP(ptid) ptid_get_lwp (ptid)
119 #define GET_PID(ptid) ptid_get_pid (ptid)
120 #define is_lwp(ptid) (GET_LWP (ptid) != 0)
121 #define BUILD_LWP(lwp, pid) ptid_build (pid, lwp, 0)
123 /* If the last reported event was a SIGTRAP, this variable is set to
124 the process id of the LWP/thread that got it. */
128 /* This module's target-specific operations. */
129 static struct target_ops lin_lwp_ops
;
131 /* The standard child operations. */
132 extern struct target_ops child_ops
;
134 /* Since we cannot wait (in lin_lwp_wait) for the initial process and
135 any cloned processes with a single call to waitpid, we have to use
136 the WNOHANG flag and call waitpid in a loop. To optimize
137 things a bit we use `sigsuspend' to wake us up when a process has
138 something to report (it will send us a SIGCHLD if it has). To make
139 this work we have to juggle with the signal mask. We save the
140 original signal mask such that we can restore it before creating a
141 new process in order to avoid blocking certain signals in the
142 inferior. We then block SIGCHLD during the waitpid/sigsuspend
145 /* Original signal mask. */
146 static sigset_t normal_mask
;
148 /* Signal mask for use with sigsuspend in lin_lwp_wait, initialized in
149 _initialize_lin_lwp. */
150 static sigset_t suspend_mask
;
152 /* Signals to block to make that sigsuspend work. */
153 static sigset_t blocked_mask
;
156 /* Prototypes for local functions. */
157 static int stop_wait_callback (struct lwp_info
*lp
, void *data
);
159 /* Convert wait status STATUS to a string. Used for printing debug
163 status_to_str (int status
)
167 if (WIFSTOPPED (status
))
168 snprintf (buf
, sizeof (buf
), "%s (stopped)",
169 strsignal (WSTOPSIG (status
)));
170 else if (WIFSIGNALED (status
))
171 snprintf (buf
, sizeof (buf
), "%s (terminated)",
172 strsignal (WSTOPSIG (status
)));
174 snprintf (buf
, sizeof (buf
), "%d (exited)",
175 WEXITSTATUS (status
));
180 /* Initialize the list of LWPs. Note that this module, contrary to
181 what GDB's generic threads layer does for its thread list,
182 re-initializes the LWP lists whenever we mourn or detach (which
183 doesn't involve mourning) the inferior. */
188 struct lwp_info
*lp
, *lpnext
;
190 for (lp
= lwp_list
; lp
; lp
= lpnext
)
201 /* Add the LWP specified by PID to the list. If this causes the
202 number of LWPs to become larger than one, go into "threaded" mode.
203 Return a pointer to the structure describing the new LWP. */
205 static struct lwp_info
*
206 add_lwp (ptid_t ptid
)
210 gdb_assert (is_lwp (ptid
));
212 lp
= (struct lwp_info
*) xmalloc (sizeof (struct lwp_info
));
214 memset (lp
, 0, sizeof (struct lwp_info
));
226 /* Remove the LWP specified by PID from the list. */
229 delete_lwp (ptid_t ptid
)
231 struct lwp_info
*lp
, *lpprev
;
235 for (lp
= lwp_list
; lp
; lpprev
= lp
, lp
= lp
->next
)
236 if (ptid_equal (lp
->ptid
, ptid
))
242 /* We don't go back to "non-threaded" mode if the number of threads
243 becomes less than two. */
247 lpprev
->next
= lp
->next
;
254 /* Return a pointer to the structure describing the LWP corresponding
255 to PID. If no corresponding LWP could be found, return NULL. */
257 static struct lwp_info
*
258 find_lwp_pid (ptid_t ptid
)
264 lwp
= GET_LWP (ptid
);
266 lwp
= GET_PID (ptid
);
268 for (lp
= lwp_list
; lp
; lp
= lp
->next
)
269 if (lwp
== GET_LWP (lp
->ptid
))
275 /* Call CALLBACK with its second argument set to DATA for every LWP in
276 the list. If CALLBACK returns 1 for a particular LWP, return a
277 pointer to the structure describing that LWP immediately.
278 Otherwise return NULL. */
281 iterate_over_lwps (int (*callback
) (struct lwp_info
*, void *), void *data
)
283 struct lwp_info
*lp
, *lpnext
;
285 for (lp
= lwp_list
; lp
; lp
= lpnext
)
288 if ((*callback
) (lp
, data
))
296 /* Implementation of the PREPARE_TO_PROCEED hook for the GNU/Linux LWP
299 Note that this implementation is potentially redundant now that
300 default_prepare_to_proceed() has been added.
302 FIXME This may not support switching threads after Ctrl-C
303 correctly. The default implementation does support this. */
306 lin_lwp_prepare_to_proceed (void)
308 if (! ptid_equal (trap_ptid
, null_ptid
)
309 && ! ptid_equal (inferior_ptid
, trap_ptid
))
311 /* Switched over from TRAP_PID. */
312 CORE_ADDR stop_pc
= read_pc ();
315 /* Avoid switching where it wouldn't do any good, i.e. if both
316 threads are at the same breakpoint. */
317 trap_pc
= read_pc_pid (trap_ptid
);
318 if (trap_pc
!= stop_pc
&& breakpoint_here_p (trap_pc
))
320 /* User hasn't deleted the breakpoint. Return non-zero, and
321 switch back to TRAP_PID. */
322 inferior_ptid
= trap_ptid
;
324 /* FIXME: Is this stuff really necessary? */
325 flush_cached_frames ();
326 registers_changed ();
338 lin_lwp_open (char *args
, int from_tty
)
340 push_target (&lin_lwp_ops
);
344 /* Attach to the LWP specified by PID. If VERBOSE is non-zero, print
345 a message telling the user that a new LWP has been added to the
349 lin_lwp_attach_lwp (ptid_t ptid
, int verbose
)
353 gdb_assert (is_lwp (ptid
));
355 /* Make sure SIGCHLD is blocked. We don't want SIGCHLD events
356 to interrupt either the ptrace() or waitpid() calls below. */
357 if (! sigismember (&blocked_mask
, SIGCHLD
))
359 sigaddset (&blocked_mask
, SIGCHLD
);
360 sigprocmask (SIG_BLOCK
, &blocked_mask
, NULL
);
364 printf_filtered ("[New %s]\n", target_pid_to_str (ptid
));
366 lp
= find_lwp_pid (ptid
);
370 /* We assume that we're already attached to any LWP that has an
371 id equal to the overall process id. */
372 if (GET_LWP (ptid
) != GET_PID (ptid
))
377 if (ptrace (PTRACE_ATTACH
, GET_LWP (ptid
), 0, 0) < 0)
378 error ("Can't attach %s: %s", target_pid_to_str (ptid
),
379 safe_strerror (errno
));
381 pid
= waitpid (GET_LWP (ptid
), &status
, 0);
382 if (pid
== -1 && errno
== ECHILD
)
384 /* Try again with __WCLONE to check cloned processes. */
385 pid
= waitpid (GET_LWP (ptid
), &status
, __WCLONE
);
389 gdb_assert (pid
== GET_LWP (ptid
)
390 && WIFSTOPPED (status
) && WSTOPSIG (status
));
396 /* We assume that the LWP representing the original process
397 is already stopped. Mark it as stopped in the data structure
398 that the lin-lwp layer uses to keep track of threads. Note
399 that this won't have already been done since the main thread
400 will have, we assume, been stopped by an attach from a
407 lin_lwp_attach (char *args
, int from_tty
)
413 /* FIXME: We should probably accept a list of process id's, and
414 attach all of them. */
415 child_ops
.to_attach (args
, from_tty
);
417 /* Add the initial process as the first LWP to the list. */
418 lp
= add_lwp (BUILD_LWP (GET_PID (inferior_ptid
), GET_PID (inferior_ptid
)));
420 /* Make sure the initial process is stopped. The user-level threads
421 layer might want to poke around in the inferior, and that won't
422 work if things haven't stabilized yet. */
423 pid
= waitpid (GET_PID (inferior_ptid
), &status
, 0);
424 if (pid
== -1 && errno
== ECHILD
)
426 warning ("%s is a cloned process", target_pid_to_str (inferior_ptid
));
428 /* Try again with __WCLONE to check cloned processes. */
429 pid
= waitpid (GET_PID (inferior_ptid
), &status
, __WCLONE
);
433 gdb_assert (pid
== GET_PID (inferior_ptid
)
434 && WIFSTOPPED (status
) && WSTOPSIG (status
) == SIGSTOP
);
438 /* Fake the SIGSTOP that core GDB expects. */
439 lp
->status
= W_STOPCODE (SIGSTOP
);
444 detach_callback (struct lwp_info
*lp
, void *data
)
446 gdb_assert (lp
->status
== 0 || WIFSTOPPED (lp
->status
));
448 if (debug_lin_lwp
&& lp
->status
)
449 fprintf_unfiltered (gdb_stdlog
, "Pending %s for LWP %ld on detach.\n",
450 strsignal (WSTOPSIG (lp
->status
)), GET_LWP (lp
->ptid
));
452 while (lp
->signalled
&& lp
->stopped
)
454 if (ptrace (PTRACE_CONT
, GET_LWP (lp
->ptid
), 0,
455 WSTOPSIG (lp
->status
)) < 0)
456 error ("Can't continue %s: %s", target_pid_to_str (lp
->ptid
),
457 safe_strerror (errno
));
462 stop_wait_callback (lp
, NULL
);
464 gdb_assert (lp
->status
== 0 || WIFSTOPPED (lp
->status
));
467 /* We don't actually detach from the LWP that has an id equal to the
468 overall process id just yet. */
469 if (GET_LWP (lp
->ptid
) != GET_PID (lp
->ptid
))
471 if (ptrace (PTRACE_DETACH
, GET_LWP (lp
->ptid
), 0,
472 WSTOPSIG (lp
->status
)) < 0)
473 error ("Can't detach %s: %s", target_pid_to_str (lp
->ptid
),
474 safe_strerror (errno
));
476 delete_lwp (lp
->ptid
);
483 lin_lwp_detach (char *args
, int from_tty
)
485 iterate_over_lwps (detach_callback
, NULL
);
487 /* Only the initial process should be left right now. */
488 gdb_assert (num_lwps
== 1);
490 trap_ptid
= null_ptid
;
492 /* Destroy LWP info; it's no longer valid. */
495 /* Restore the original signal mask. */
496 sigprocmask (SIG_SETMASK
, &normal_mask
, NULL
);
497 sigemptyset (&blocked_mask
);
499 inferior_ptid
= pid_to_ptid (GET_PID (inferior_ptid
));
500 child_ops
.to_detach (args
, from_tty
);
504 struct private_thread_info
509 /* Return non-zero if TP corresponds to the LWP specified by DATA
510 (which is assumed to be a pointer to a `struct lwp_info'. */
513 find_lwp_callback (struct thread_info
*tp
, void *data
)
515 struct lwp_info
*lp
= data
;
517 if (tp
->private->lwpid
== GET_LWP (lp
->ptid
))
526 resume_callback (struct lwp_info
*lp
, void *data
)
528 if (lp
->stopped
&& lp
->status
== 0)
530 struct thread_info
*tp
;
533 /* FIXME: kettenis/2000-08-26: This should really be handled
534 properly by core GDB. */
536 tp
= find_thread_pid (lp
->ptid
);
538 tp
= iterate_over_threads (find_lwp_callback
, lp
);
541 /* If we were previously stepping the thread, and now continue
542 the thread we must invalidate the stepping range. However,
543 if there is a step_resume breakpoint for this thread, we must
544 preserve the stepping range to make it possible to continue
545 stepping once we hit it. */
546 if (tp
->step_range_end
&& tp
->step_resume_breakpoint
== NULL
)
548 gdb_assert (lp
->step
);
549 tp
->step_range_start
= tp
->step_range_end
= 0;
553 child_resume (pid_to_ptid (GET_LWP (lp
->ptid
)), 0, TARGET_SIGNAL_0
);
562 resume_clear_callback (struct lwp_info
*lp
, void *data
)
569 resume_set_callback (struct lwp_info
*lp
, void *data
)
576 lin_lwp_resume (ptid_t ptid
, int step
, enum target_signal signo
)
581 /* Apparently the interpretation of PID is dependent on STEP: If
582 STEP is non-zero, a specific PID means `step only this process
583 id'. But if STEP is zero, then PID means `continue *all*
584 processes, but give the signal only to this one'. */
585 resume_all
= (PIDGET (ptid
) == -1) || !step
;
588 iterate_over_lwps (resume_set_callback
, NULL
);
590 iterate_over_lwps (resume_clear_callback
, NULL
);
592 /* If PID is -1, it's the current inferior that should be
593 handled specially. */
594 if (PIDGET (ptid
) == -1)
595 ptid
= inferior_ptid
;
597 lp
= find_lwp_pid (ptid
);
600 ptid
= pid_to_ptid (GET_LWP (lp
->ptid
));
602 /* Remember if we're stepping. */
605 /* Mark this LWP as resumed. */
608 /* If we have a pending wait status for this thread, there is no
609 point in resuming the process. */
612 /* FIXME: What should we do if we are supposed to continue
613 this thread with a signal? */
614 gdb_assert (signo
== TARGET_SIGNAL_0
);
618 /* Mark LWP as not stopped to prevent it from being continued by
624 iterate_over_lwps (resume_callback
, NULL
);
626 child_resume (ptid
, step
, signo
);
630 /* Send a SIGSTOP to LP. */
633 stop_callback (struct lwp_info
*lp
, void *data
)
635 if (! lp
->stopped
&& ! lp
->signalled
)
639 ret
= kill (GET_LWP (lp
->ptid
), SIGSTOP
);
640 gdb_assert (ret
== 0);
643 gdb_assert (lp
->status
== 0);
649 /* Wait until LP is stopped. If DATA is non-null it is interpreted as
650 a pointer to a set of signals to be flushed immediately. */
653 stop_wait_callback (struct lwp_info
*lp
, void *data
)
655 sigset_t
*flush_mask
= data
;
657 if (! lp
->stopped
&& lp
->signalled
)
662 gdb_assert (lp
->status
== 0);
664 pid
= waitpid (GET_LWP (lp
->ptid
), &status
, lp
->cloned
? __WCLONE
: 0);
665 if (pid
== -1 && errno
== ECHILD
)
666 /* OK, the proccess has disappeared. We'll catch the actual
667 exit event in lin_lwp_wait. */
670 gdb_assert (pid
== GET_LWP (lp
->ptid
));
672 if (WIFEXITED (status
) || WIFSIGNALED (status
))
674 gdb_assert (num_lwps
> 1);
676 if (in_thread_list (lp
->ptid
))
678 /* Core GDB cannot deal with us deleting the current
680 if (!ptid_equal (lp
->ptid
, inferior_ptid
))
681 delete_thread (lp
->ptid
);
682 printf_unfiltered ("[%s exited]\n",
683 target_pid_to_str (lp
->ptid
));
686 fprintf_unfiltered (gdb_stdlog
,
687 "%s exited.\n", target_pid_to_str (lp
->ptid
));
689 delete_lwp (lp
->ptid
);
693 gdb_assert (WIFSTOPPED (status
));
695 /* Ignore any signals in FLUSH_MASK. */
696 if (flush_mask
&& sigismember (flush_mask
, WSTOPSIG (status
)))
698 ptrace (PTRACE_CONT
, GET_LWP (lp
->ptid
), 0, 0);
699 return stop_wait_callback (lp
, flush_mask
);
702 if (WSTOPSIG (status
) != SIGSTOP
)
704 if (WSTOPSIG (status
) == SIGTRAP
)
706 /* If a LWP other than the LWP that we're reporting an
707 event for has hit a GDB breakpoint (as opposed to
708 some random trap signal), then just arrange for it to
709 hit it again later. We don't keep the SIGTRAP status
710 and don't forward the SIGTRAP signal to the LWP. We
711 will handle the current event, eventually we will
712 resume all LWPs, and this one will get its breakpoint
715 If we do not do this, then we run the risk that the
716 user will delete or disable the breakpoint, but the
717 thread will have already tripped on it. */
719 /* Now resume this LWP and get the SIGSTOP event. */
720 ptrace (PTRACE_CONT
, GET_LWP (lp
->ptid
), 0, 0);
723 fprintf_unfiltered (gdb_stderr
,
724 "SWC: Candidate SIGTRAP event in %ld\n",
727 /* Hold the SIGTRAP for handling by lin_lwp_wait. */
728 stop_wait_callback (lp
, data
);
729 /* If there's another event, throw it back into the queue. */
731 kill (GET_LWP (lp
->ptid
), WSTOPSIG (lp
->status
));
732 /* Save the sigtrap event. */
738 /* The thread was stopped with a signal other than
739 SIGSTOP, and didn't accidentally trip a breakpoint. */
743 fprintf_unfiltered (gdb_stderr
,
744 "SWC: Pending event %d in %ld\n",
745 WSTOPSIG (status
), GET_LWP (lp
->ptid
));
747 /* Now resume this LWP and get the SIGSTOP event. */
748 ptrace (PTRACE_CONT
, GET_LWP (lp
->ptid
), 0, 0);
750 /* Hold this event/waitstatus while we check to see if
751 there are any more (we still want to get that SIGSTOP). */
752 stop_wait_callback (lp
, data
);
753 /* If the lp->status field is still empty, use it to hold
754 this event. If not, then this event must be returned
755 to the event queue of the LWP. */
759 kill (GET_LWP (lp
->ptid
), WSTOPSIG (status
));
765 /* We caught the SIGSTOP that we intended to catch, so
766 there's no SIGSTOP pending. */
775 /* Return non-zero if LP has a wait status pending. */
778 status_callback (struct lwp_info
*lp
, void *data
)
780 /* Only report a pending wait status if we pretend that this has
781 indeed been resumed. */
782 return (lp
->status
!= 0 && lp
->resumed
);
785 /* Return non-zero if LP isn't stopped. */
788 running_callback (struct lwp_info
*lp
, void *data
)
790 return (lp
->stopped
== 0);
793 /* Count the LWP's that have had events. */
796 count_events_callback (struct lwp_info
*lp
, void *data
)
800 gdb_assert (count
!= NULL
);
802 /* Count only LWPs that have a SIGTRAP event pending. */
804 && WIFSTOPPED (lp
->status
) && WSTOPSIG (lp
->status
) == SIGTRAP
)
810 /* Select the LWP (if any) that is currently being single-stepped. */
813 select_singlestep_lwp_callback (struct lwp_info
*lp
, void *data
)
815 if (lp
->step
&& lp
->status
!= 0)
821 /* Select the Nth LWP that has had a SIGTRAP event. */
824 select_event_lwp_callback (struct lwp_info
*lp
, void *data
)
826 int *selector
= data
;
828 gdb_assert (selector
!= NULL
);
830 /* Select only LWPs that have a SIGTRAP event pending. */
832 && WIFSTOPPED (lp
->status
) && WSTOPSIG (lp
->status
) == SIGTRAP
)
833 if ((*selector
)-- == 0)
840 cancel_breakpoints_callback (struct lwp_info
*lp
, void *data
)
842 struct lwp_info
*event_lp
= data
;
844 /* Leave the LWP that has been elected to receive a SIGTRAP alone. */
848 /* If a LWP other than the LWP that we're reporting an event for has
849 hit a GDB breakpoint (as opposed to some random trap signal),
850 then just arrange for it to hit it again later. We don't keep
851 the SIGTRAP status and don't forward the SIGTRAP signal to the
852 LWP. We will handle the current event, eventually we will resume
853 all LWPs, and this one will get its breakpoint trap again.
855 If we do not do this, then we run the risk that the user will
856 delete or disable the breakpoint, but the LWP will have already
860 && WIFSTOPPED (lp
->status
) && WSTOPSIG (lp
->status
) == SIGTRAP
861 && breakpoint_inserted_here_p (read_pc_pid (lp
->ptid
) -
862 DECR_PC_AFTER_BREAK
))
865 fprintf_unfiltered (gdb_stdlog
,
866 "Push back breakpoint for LWP %ld\n",
869 /* Back up the PC if necessary. */
870 if (DECR_PC_AFTER_BREAK
)
871 write_pc_pid (read_pc_pid (lp
->ptid
) - DECR_PC_AFTER_BREAK
, lp
->ptid
);
873 /* Throw away the SIGTRAP. */
880 /* Select one LWP out of those that have events pending. */
883 select_event_lwp (struct lwp_info
**orig_lp
, int *status
)
887 struct lwp_info
*event_lp
;
889 /* Record the wait status for the origional LWP. */
890 (*orig_lp
)->status
= *status
;
892 /* Give preference to any LWP that is being single-stepped. */
893 event_lp
= iterate_over_lwps (select_singlestep_lwp_callback
, NULL
);
894 if (event_lp
!= NULL
)
897 fprintf_unfiltered (gdb_stdlog
,
898 "Select single-step LWP %ld\n",
899 GET_LWP (event_lp
->ptid
));
903 /* No single-stepping LWP. Select one at random, out of those
904 which have had SIGTRAP events. */
906 /* First see how many SIGTRAP events we have. */
907 iterate_over_lwps (count_events_callback
, &num_events
);
909 /* Now randomly pick a LWP out of those that have had a SIGTRAP. */
910 random_selector
= (int)
911 ((num_events
* (double) rand ()) / (RAND_MAX
+ 1.0));
913 if (debug_lin_lwp
&& num_events
> 1)
914 fprintf_unfiltered (gdb_stdlog
,
915 "Found %d SIGTRAP events, selecting #%d\n",
916 num_events
, random_selector
);
918 event_lp
= iterate_over_lwps (select_event_lwp_callback
,
922 if (event_lp
!= NULL
)
924 /* Switch the event LWP. */
926 *status
= event_lp
->status
;
929 /* Flush the wait status for the event LWP. */
930 (*orig_lp
)->status
= 0;
933 /* Return non-zero if LP has been resumed. */
936 resumed_callback (struct lwp_info
*lp
, void *data
)
943 /* We need to override child_wait to support attaching to cloned
944 processes, since a normal wait (as done by the default version)
945 ignores those processes. */
947 /* Wait for child PTID to do something. Return id of the child,
948 minus_one_ptid in case of error; store status into *OURSTATUS. */
951 child_wait (ptid_t ptid
, struct target_waitstatus
*ourstatus
)
959 set_sigint_trap (); /* Causes SIGINT to be passed on to the
963 pid
= waitpid (GET_PID (ptid
), &status
, 0);
964 if (pid
== -1 && errno
== ECHILD
)
965 /* Try again with __WCLONE to check cloned processes. */
966 pid
= waitpid (GET_PID (ptid
), &status
, __WCLONE
);
970 clear_sigint_trap ();
972 while (pid
== -1 && errno
== EINTR
);
976 warning ("Child process unexpectedly missing: %s", safe_strerror (errno
));
978 /* Claim it exited with unknown signal. */
979 ourstatus
->kind
= TARGET_WAITKIND_SIGNALLED
;
980 ourstatus
->value
.sig
= TARGET_SIGNAL_UNKNOWN
;
981 return minus_one_ptid
;
984 store_waitstatus (ourstatus
, status
);
985 return pid_to_ptid (pid
);
991 lin_lwp_wait (ptid_t ptid
, struct target_waitstatus
*ourstatus
)
993 struct lwp_info
*lp
= NULL
;
996 pid_t pid
= PIDGET (ptid
);
999 sigemptyset (&flush_mask
);
1001 /* Make sure SIGCHLD is blocked. */
1002 if (! sigismember (&blocked_mask
, SIGCHLD
))
1004 sigaddset (&blocked_mask
, SIGCHLD
);
1005 sigprocmask (SIG_BLOCK
, &blocked_mask
, NULL
);
1010 /* Make sure there is at least one LWP that has been resumed, at
1011 least if there are any LWPs at all. */
1012 gdb_assert (num_lwps
== 0 || iterate_over_lwps (resumed_callback
, NULL
));
1014 /* First check if there is a LWP with a wait status pending. */
1017 /* Any LWP that's been resumed will do. */
1018 lp
= iterate_over_lwps (status_callback
, NULL
);
1021 status
= lp
->status
;
1024 if (debug_lin_lwp
&& status
)
1025 fprintf_unfiltered (gdb_stdlog
,
1026 "Using pending wait status %s for LWP %ld.\n",
1027 status_to_str (status
), GET_LWP (lp
->ptid
));
1030 /* But if we don't fine one, we'll have to wait, and check both
1031 cloned and uncloned processes. We start with the cloned
1033 options
= __WCLONE
| WNOHANG
;
1035 else if (is_lwp (ptid
))
1038 fprintf_unfiltered (gdb_stdlog
,
1039 "Waiting for specific LWP %ld.\n",
1042 /* We have a specific LWP to check. */
1043 lp
= find_lwp_pid (ptid
);
1045 status
= lp
->status
;
1048 if (debug_lin_lwp
&& status
)
1049 fprintf_unfiltered (gdb_stdlog
,
1050 "Using pending wait status %s for LWP %ld.\n",
1051 status_to_str (status
), GET_LWP (lp
->ptid
));
1053 /* If we have to wait, take into account whether PID is a cloned
1054 process or not. And we have to convert it to something that
1055 the layer beneath us can understand. */
1056 options
= lp
->cloned
? __WCLONE
: 0;
1057 pid
= GET_LWP (ptid
);
1060 if (status
&& lp
->signalled
)
1062 /* A pending SIGSTOP may interfere with the normal stream of
1063 events. In a typical case where interference is a problem,
1064 we have a SIGSTOP signal pending for LWP A while
1065 single-stepping it, encounter an event in LWP B, and take the
1066 pending SIGSTOP while trying to stop LWP A. After processing
1067 the event in LWP B, LWP A is continued, and we'll never see
1068 the SIGTRAP associated with the last time we were
1069 single-stepping LWP A. */
1071 /* Resume the thread. It should halt immediately returning the
1073 child_resume (pid_to_ptid (GET_LWP (lp
->ptid
)), lp
->step
,
1076 gdb_assert (lp
->resumed
);
1078 /* This should catch the pending SIGSTOP. */
1079 stop_wait_callback (lp
, NULL
);
1082 set_sigint_trap (); /* Causes SIGINT to be passed on to the
1083 attached process. */
1090 lwpid
= waitpid (pid
, &status
, options
);
1093 gdb_assert (pid
== -1 || lwpid
== pid
);
1095 lp
= find_lwp_pid (pid_to_ptid (lwpid
));
1098 lp
= add_lwp (BUILD_LWP (lwpid
, GET_PID (inferior_ptid
)));
1099 if (options
& __WCLONE
)
1104 gdb_assert (WIFSTOPPED (status
)
1105 && WSTOPSIG (status
) == SIGSTOP
);
1108 if (! in_thread_list (inferior_ptid
))
1110 inferior_ptid
= BUILD_LWP (GET_PID (inferior_ptid
),
1111 GET_PID (inferior_ptid
));
1112 add_thread (inferior_ptid
);
1115 add_thread (lp
->ptid
);
1116 printf_unfiltered ("[New %s]\n",
1117 target_pid_to_str (lp
->ptid
));
1121 /* Make sure we don't report a TARGET_WAITKIND_EXITED or
1122 TARGET_WAITKIND_SIGNALLED event if there are still LWP's
1123 left in the process. */
1124 if ((WIFEXITED (status
) || WIFSIGNALED (status
)) && num_lwps
> 1)
1126 if (in_thread_list (lp
->ptid
))
1128 /* Core GDB cannot deal with us deleting the current
1130 if (! ptid_equal (lp
->ptid
, inferior_ptid
))
1131 delete_thread (lp
->ptid
);
1132 printf_unfiltered ("[%s exited]\n",
1133 target_pid_to_str (lp
->ptid
));
1136 fprintf_unfiltered (gdb_stdlog
,
1138 target_pid_to_str (lp
->ptid
));
1140 delete_lwp (lp
->ptid
);
1142 /* Make sure there is at least one thread running. */
1143 gdb_assert (iterate_over_lwps (running_callback
, NULL
));
1145 /* Discard the event. */
1150 /* Make sure we don't report a SIGSTOP that we sent
1151 ourselves in an attempt to stop an LWP. */
1152 if (lp
->signalled
&& WIFSTOPPED (status
)
1153 && WSTOPSIG (status
) == SIGSTOP
)
1156 fprintf_unfiltered (gdb_stdlog
,
1157 "Delayed SIGSTOP caught for %s.\n",
1158 target_pid_to_str (lp
->ptid
));
1160 /* This is a delayed SIGSTOP. */
1163 child_resume (pid_to_ptid (GET_LWP (lp
->ptid
)), lp
->step
,
1166 gdb_assert (lp
->resumed
);
1168 /* Discard the event. */
1178 /* Alternate between checking cloned and uncloned processes. */
1179 options
^= __WCLONE
;
1181 /* And suspend every time we have checked both. */
1182 if (options
& __WCLONE
)
1183 sigsuspend (&suspend_mask
);
1186 /* We shouldn't end up here unless we want to try again. */
1187 gdb_assert (status
== 0);
1190 clear_sigio_trap ();
1191 clear_sigint_trap ();
1195 /* Don't report signals that GDB isn't interested in, such as
1196 signals that are neither printed nor stopped upon. Stopping all
1197 threads can be a bit time-consuming so if we want decent
1198 performance with heavily multi-threaded programs, especially when
1199 they're using a high frequency timer, we'd better avoid it if we
1202 if (WIFSTOPPED (status
))
1204 int signo
= target_signal_from_host (WSTOPSIG (status
));
1206 if (signal_stop_state (signo
) == 0
1207 && signal_print_state (signo
) == 0
1208 && signal_pass_state (signo
) == 1)
1210 /* FIMXE: kettenis/2001-06-06: Should we resume all threads
1211 here? It is not clear we should. GDB may not expect
1212 other threads to run. On the other hand, not resuming
1213 newly attached threads may cause an unwanted delay in
1214 getting them running. */
1215 child_resume (pid_to_ptid (GET_LWP (lp
->ptid
)), lp
->step
, signo
);
1221 if (signo
== TARGET_SIGNAL_INT
1222 && signal_pass_state (signo
) == 0)
1224 /* If ^C/BREAK is typed at the tty/console, SIGINT gets
1225 forwarded to the entire process group, that is, all LWP's
1226 will receive it. Since we only want to report it once,
1227 we try to flush it from all LWPs except this one. */
1228 sigaddset (&flush_mask
, SIGINT
);
1232 /* This LWP is stopped now. */
1236 fprintf_unfiltered (gdb_stdlog
, "Candidate event %s in LWP %ld.\n",
1237 status_to_str (status
), GET_LWP (lp
->ptid
));
1239 /* Now stop all other LWP's ... */
1240 iterate_over_lwps (stop_callback
, NULL
);
1242 /* ... and wait until all of them have reported back that they're no
1244 iterate_over_lwps (stop_wait_callback
, &flush_mask
);
1246 /* If we're not waiting for a specific LWP, choose an event LWP from
1247 among those that have had events. Giving equal priority to all
1248 LWPs that have had events helps prevent starvation. */
1250 select_event_lwp (&lp
, &status
);
1252 /* Now that we've selected our final event LWP, cancel any
1253 breakpoints in other LWPs that have hit a GDB breakpoint. See
1254 the comment in cancel_breakpoints_callback to find out why. */
1255 iterate_over_lwps (cancel_breakpoints_callback
, lp
);
1257 /* If we're not running in "threaded" mode, we'll report the bare
1260 if (WIFSTOPPED (status
) && WSTOPSIG (status
) == SIGTRAP
)
1262 trap_ptid
= (threaded
? lp
->ptid
: pid_to_ptid (GET_LWP (lp
->ptid
)));
1264 fprintf_unfiltered (gdb_stdlog
,
1265 "LLW: trap_ptid is %ld\n",
1266 GET_LWP (trap_ptid
));
1269 trap_ptid
= null_ptid
;
1271 store_waitstatus (ourstatus
, status
);
1272 return (threaded
? lp
->ptid
: pid_to_ptid (GET_LWP (lp
->ptid
)));
1276 kill_callback (struct lwp_info
*lp
, void *data
)
1278 ptrace (PTRACE_KILL
, GET_LWP (lp
->ptid
), 0, 0);
1283 kill_wait_callback (struct lwp_info
*lp
, void *data
)
1287 /* We must make sure that there are no pending events (delayed
1288 SIGSTOPs, pending SIGTRAPs, etc.) to make sure the current
1289 program doesn't interfere with any following debugging session. */
1291 /* For cloned processes we must check both with __WCLONE and
1292 without, since the exit status of a cloned process isn't reported
1298 pid
= waitpid (GET_LWP (lp
->ptid
), NULL
, __WCLONE
);
1300 while (pid
== GET_LWP (lp
->ptid
));
1302 gdb_assert (pid
== -1 && errno
== ECHILD
);
1307 pid
= waitpid (GET_LWP (lp
->ptid
), NULL
, 0);
1309 while (pid
== GET_LWP (lp
->ptid
));
1311 gdb_assert (pid
== -1 && errno
== ECHILD
);
1318 /* Kill all LWP's ... */
1319 iterate_over_lwps (kill_callback
, NULL
);
1321 /* ... and wait until we've flushed all events. */
1322 iterate_over_lwps (kill_wait_callback
, NULL
);
1324 target_mourn_inferior ();
1328 lin_lwp_create_inferior (char *exec_file
, char *allargs
, char **env
)
1330 child_ops
.to_create_inferior (exec_file
, allargs
, env
);
1334 lin_lwp_mourn_inferior (void)
1336 trap_ptid
= null_ptid
;
1338 /* Destroy LWP info; it's no longer valid. */
1341 /* Restore the original signal mask. */
1342 sigprocmask (SIG_SETMASK
, &normal_mask
, NULL
);
1343 sigemptyset (&blocked_mask
);
1345 child_ops
.to_mourn_inferior ();
1349 lin_lwp_fetch_registers (int regno
)
1351 struct cleanup
*old_chain
= save_inferior_ptid ();
1353 if (is_lwp (inferior_ptid
))
1354 inferior_ptid
= pid_to_ptid (GET_LWP (inferior_ptid
));
1356 fetch_inferior_registers (regno
);
1358 do_cleanups (old_chain
);
1362 lin_lwp_store_registers (int regno
)
1364 struct cleanup
*old_chain
= save_inferior_ptid ();
1366 if (is_lwp (inferior_ptid
))
1367 inferior_ptid
= pid_to_ptid (GET_LWP (inferior_ptid
));
1369 store_inferior_registers (regno
);
1371 do_cleanups (old_chain
);
1375 lin_lwp_xfer_memory (CORE_ADDR memaddr
, char *myaddr
, int len
, int write
,
1376 struct mem_attrib
*attrib
,
1377 struct target_ops
*target
)
1379 struct cleanup
*old_chain
= save_inferior_ptid ();
1382 if (is_lwp (inferior_ptid
))
1383 inferior_ptid
= pid_to_ptid (GET_LWP (inferior_ptid
));
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
);