1 /* Multi-threaded debugging support for GNU/Linux (LWP layer).
2 Copyright 2000, 2001, 2002, 2003, 2004 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
));
186 lp
->waitstatus
.kind
= TARGET_WAITKIND_IGNORE
;
198 /* Remove the LWP specified by PID from the list. */
201 delete_lwp (ptid_t ptid
)
203 struct lwp_info
*lp
, *lpprev
;
207 for (lp
= lwp_list
; lp
; lpprev
= lp
, lp
= lp
->next
)
208 if (ptid_equal (lp
->ptid
, ptid
))
214 /* We don't go back to "non-threaded" mode if the number of threads
215 becomes less than two. */
219 lpprev
->next
= lp
->next
;
226 /* Return a pointer to the structure describing the LWP corresponding
227 to PID. If no corresponding LWP could be found, return NULL. */
229 static struct lwp_info
*
230 find_lwp_pid (ptid_t ptid
)
236 lwp
= GET_LWP (ptid
);
238 lwp
= GET_PID (ptid
);
240 for (lp
= lwp_list
; lp
; lp
= lp
->next
)
241 if (lwp
== GET_LWP (lp
->ptid
))
247 /* Call CALLBACK with its second argument set to DATA for every LWP in
248 the list. If CALLBACK returns 1 for a particular LWP, return a
249 pointer to the structure describing that LWP immediately.
250 Otherwise return NULL. */
253 iterate_over_lwps (int (*callback
) (struct lwp_info
*, void *), void *data
)
255 struct lwp_info
*lp
, *lpnext
;
257 for (lp
= lwp_list
; lp
; lp
= lpnext
)
260 if ((*callback
) (lp
, data
))
270 lin_lwp_open (char *args
, int from_tty
)
272 push_target (&lin_lwp_ops
);
276 /* Attach to the LWP specified by PID. If VERBOSE is non-zero, print
277 a message telling the user that a new LWP has been added to the
281 lin_lwp_attach_lwp (ptid_t ptid
, int verbose
)
283 struct lwp_info
*lp
, *found_lp
;
285 gdb_assert (is_lwp (ptid
));
287 /* Make sure SIGCHLD is blocked. We don't want SIGCHLD events
288 to interrupt either the ptrace() or waitpid() calls below. */
289 if (!sigismember (&blocked_mask
, SIGCHLD
))
291 sigaddset (&blocked_mask
, SIGCHLD
);
292 sigprocmask (SIG_BLOCK
, &blocked_mask
, NULL
);
296 printf_filtered ("[New %s]\n", target_pid_to_str (ptid
));
298 found_lp
= lp
= find_lwp_pid (ptid
);
302 /* We assume that we're already attached to any LWP that has an id
303 equal to the overall process id, and to any LWP that is already
304 in our list of LWPs. If we're not seeing exit events from threads
305 and we've had PID wraparound since we last tried to stop all threads,
306 this assumption might be wrong; fortunately, this is very unlikely
308 if (GET_LWP (ptid
) != GET_PID (ptid
) && found_lp
== NULL
)
313 if (ptrace (PTRACE_ATTACH
, GET_LWP (ptid
), 0, 0) < 0)
314 error ("Can't attach %s: %s", target_pid_to_str (ptid
),
315 safe_strerror (errno
));
318 fprintf_unfiltered (gdb_stdlog
,
319 "LLAL: PTRACE_ATTACH %s, 0, 0 (OK)\n",
320 target_pid_to_str (ptid
));
322 pid
= waitpid (GET_LWP (ptid
), &status
, 0);
323 if (pid
== -1 && errno
== ECHILD
)
325 /* Try again with __WCLONE to check cloned processes. */
326 pid
= waitpid (GET_LWP (ptid
), &status
, __WCLONE
);
330 gdb_assert (pid
== GET_LWP (ptid
)
331 && WIFSTOPPED (status
) && WSTOPSIG (status
));
333 child_post_attach (pid
);
339 fprintf_unfiltered (gdb_stdlog
,
340 "LLAL: waitpid %s received %s\n",
341 target_pid_to_str (ptid
),
342 status_to_str (status
));
347 /* We assume that the LWP representing the original process
348 is already stopped. Mark it as stopped in the data structure
349 that the lin-lwp layer uses to keep track of threads. Note
350 that this won't have already been done since the main thread
351 will have, we assume, been stopped by an attach from a
358 lin_lwp_attach (char *args
, int from_tty
)
364 /* FIXME: We should probably accept a list of process id's, and
365 attach all of them. */
366 child_ops
.to_attach (args
, from_tty
);
368 /* Add the initial process as the first LWP to the list. */
369 lp
= add_lwp (BUILD_LWP (GET_PID (inferior_ptid
), GET_PID (inferior_ptid
)));
371 /* Make sure the initial process is stopped. The user-level threads
372 layer might want to poke around in the inferior, and that won't
373 work if things haven't stabilized yet. */
374 pid
= waitpid (GET_PID (inferior_ptid
), &status
, 0);
375 if (pid
== -1 && errno
== ECHILD
)
377 warning ("%s is a cloned process", target_pid_to_str (inferior_ptid
));
379 /* Try again with __WCLONE to check cloned processes. */
380 pid
= waitpid (GET_PID (inferior_ptid
), &status
, __WCLONE
);
384 gdb_assert (pid
== GET_PID (inferior_ptid
)
385 && WIFSTOPPED (status
) && WSTOPSIG (status
) == SIGSTOP
);
389 /* Fake the SIGSTOP that core GDB expects. */
390 lp
->status
= W_STOPCODE (SIGSTOP
);
394 fprintf_unfiltered (gdb_stdlog
,
395 "LLA: waitpid %ld, faking SIGSTOP\n", (long) pid
);
400 detach_callback (struct lwp_info
*lp
, void *data
)
402 gdb_assert (lp
->status
== 0 || WIFSTOPPED (lp
->status
));
404 if (debug_lin_lwp
&& lp
->status
)
405 fprintf_unfiltered (gdb_stdlog
, "DC: Pending %s for %s on detach.\n",
406 strsignal (WSTOPSIG (lp
->status
)),
407 target_pid_to_str (lp
->ptid
));
409 while (lp
->signalled
&& lp
->stopped
)
412 if (ptrace (PTRACE_CONT
, GET_LWP (lp
->ptid
), 0,
413 WSTOPSIG (lp
->status
)) < 0)
414 error ("Can't continue %s: %s", target_pid_to_str (lp
->ptid
),
415 safe_strerror (errno
));
418 fprintf_unfiltered (gdb_stdlog
,
419 "DC: PTRACE_CONTINUE (%s, 0, %s) (OK)\n",
420 target_pid_to_str (lp
->ptid
),
421 status_to_str (lp
->status
));
426 /* FIXME drow/2003-08-26: There was a call to stop_wait_callback
427 here. But since lp->signalled was cleared above,
428 stop_wait_callback didn't do anything; the process was left
429 running. Shouldn't we be waiting for it to stop?
430 I've removed the call, since stop_wait_callback now does do
431 something when called with lp->signalled == 0. */
433 gdb_assert (lp
->status
== 0 || WIFSTOPPED (lp
->status
));
436 /* We don't actually detach from the LWP that has an id equal to the
437 overall process id just yet. */
438 if (GET_LWP (lp
->ptid
) != GET_PID (lp
->ptid
))
441 if (ptrace (PTRACE_DETACH
, GET_LWP (lp
->ptid
), 0,
442 WSTOPSIG (lp
->status
)) < 0)
443 error ("Can't detach %s: %s", target_pid_to_str (lp
->ptid
),
444 safe_strerror (errno
));
447 fprintf_unfiltered (gdb_stdlog
,
448 "PTRACE_DETACH (%s, %s, 0) (OK)\n",
449 target_pid_to_str (lp
->ptid
),
450 strsignal (WSTOPSIG (lp
->status
)));
452 delete_lwp (lp
->ptid
);
459 lin_lwp_detach (char *args
, int from_tty
)
461 iterate_over_lwps (detach_callback
, NULL
);
463 /* Only the initial process should be left right now. */
464 gdb_assert (num_lwps
== 1);
466 trap_ptid
= null_ptid
;
468 /* Destroy LWP info; it's no longer valid. */
471 /* Restore the original signal mask. */
472 sigprocmask (SIG_SETMASK
, &normal_mask
, NULL
);
473 sigemptyset (&blocked_mask
);
475 inferior_ptid
= pid_to_ptid (GET_PID (inferior_ptid
));
476 child_ops
.to_detach (args
, from_tty
);
483 resume_callback (struct lwp_info
*lp
, void *data
)
485 if (lp
->stopped
&& lp
->status
== 0)
487 struct thread_info
*tp
;
489 child_resume (pid_to_ptid (GET_LWP (lp
->ptid
)), 0, TARGET_SIGNAL_0
);
491 fprintf_unfiltered (gdb_stdlog
,
492 "RC: PTRACE_CONT %s, 0, 0 (resume sibling)\n",
493 target_pid_to_str (lp
->ptid
));
502 resume_clear_callback (struct lwp_info
*lp
, void *data
)
509 resume_set_callback (struct lwp_info
*lp
, void *data
)
516 lin_lwp_resume (ptid_t ptid
, int step
, enum target_signal signo
)
521 /* A specific PTID means `step only this process id'. */
522 resume_all
= (PIDGET (ptid
) == -1);
525 iterate_over_lwps (resume_set_callback
, NULL
);
527 iterate_over_lwps (resume_clear_callback
, NULL
);
529 /* If PID is -1, it's the current inferior that should be
530 handled specially. */
531 if (PIDGET (ptid
) == -1)
532 ptid
= inferior_ptid
;
534 lp
= find_lwp_pid (ptid
);
537 ptid
= pid_to_ptid (GET_LWP (lp
->ptid
));
539 /* Remember if we're stepping. */
542 /* Mark this LWP as resumed. */
545 /* If we have a pending wait status for this thread, there is no
546 point in resuming the process. */
549 /* FIXME: What should we do if we are supposed to continue
550 this thread with a signal? */
551 gdb_assert (signo
== TARGET_SIGNAL_0
);
555 /* Mark LWP as not stopped to prevent it from being continued by
561 iterate_over_lwps (resume_callback
, NULL
);
563 child_resume (ptid
, step
, signo
);
565 fprintf_unfiltered (gdb_stdlog
,
566 "LLR: %s %s, %s (resume event thread)\n",
567 step
? "PTRACE_SINGLESTEP" : "PTRACE_CONT",
568 target_pid_to_str (ptid
),
569 signo
? strsignal (signo
) : "0");
573 /* Issue kill to specified lwp. */
575 static int tkill_failed
;
578 kill_lwp (int lwpid
, int signo
)
582 /* Use tkill, if possible, in case we are using nptl threads. If tkill
583 fails, then we are not using nptl threads and we should be using kill. */
585 #ifdef HAVE_TKILL_SYSCALL
588 int ret
= syscall (__NR_tkill
, lwpid
, signo
);
596 return kill (lwpid
, signo
);
599 /* Handle a GNU/Linux extended wait response. Most of the work we
600 just pass off to linux_handle_extended_wait, but if it reports a
601 clone event we need to add the new LWP to our list (and not report
602 the trap to higher layers). This function returns non-zero if
603 the event should be ignored and we should wait again. */
606 lin_lwp_handle_extended (struct lwp_info
*lp
, int status
)
608 linux_handle_extended_wait (GET_LWP (lp
->ptid
), status
,
611 /* TARGET_WAITKIND_SPURIOUS is used to indicate clone events. */
612 if (lp
->waitstatus
.kind
== TARGET_WAITKIND_SPURIOUS
)
614 struct lwp_info
*new_lp
;
615 new_lp
= add_lwp (BUILD_LWP (lp
->waitstatus
.value
.related_pid
,
616 GET_PID (inferior_ptid
)));
620 lp
->waitstatus
.kind
= TARGET_WAITKIND_IGNORE
;
623 fprintf_unfiltered (gdb_stdlog
,
624 "LLHE: Got clone event from LWP %ld, resuming\n",
626 ptrace (PTRACE_CONT
, GET_LWP (lp
->ptid
), 0, 0);
634 /* Wait for LP to stop. Returns the wait status, or 0 if the LWP has
638 wait_lwp (struct lwp_info
*lp
)
644 gdb_assert (!lp
->stopped
);
645 gdb_assert (lp
->status
== 0);
647 pid
= waitpid (GET_LWP (lp
->ptid
), &status
, 0);
648 if (pid
== -1 && errno
== ECHILD
)
650 pid
= waitpid (GET_LWP (lp
->ptid
), &status
, __WCLONE
);
651 if (pid
== -1 && errno
== ECHILD
)
653 /* The thread has previously exited. We need to delete it
654 now because, for some vendor 2.4 kernels with NPTL
655 support backported, there won't be an exit event unless
656 it is the main thread. 2.6 kernels will report an exit
657 event for each thread that exits, as expected. */
660 fprintf_unfiltered (gdb_stdlog
, "WL: %s vanished.\n",
661 target_pid_to_str (lp
->ptid
));
667 gdb_assert (pid
== GET_LWP (lp
->ptid
));
671 fprintf_unfiltered (gdb_stdlog
,
672 "WL: waitpid %s received %s\n",
673 target_pid_to_str (lp
->ptid
),
674 status_to_str (status
));
678 /* Check if the thread has exited. */
679 if (WIFEXITED (status
) || WIFSIGNALED (status
))
683 fprintf_unfiltered (gdb_stdlog
, "WL: %s exited.\n",
684 target_pid_to_str (lp
->ptid
));
689 if (in_thread_list (lp
->ptid
))
691 /* Core GDB cannot deal with us deleting the current thread. */
692 if (!ptid_equal (lp
->ptid
, inferior_ptid
))
693 delete_thread (lp
->ptid
);
694 printf_unfiltered ("[%s exited]\n",
695 target_pid_to_str (lp
->ptid
));
698 delete_lwp (lp
->ptid
);
702 gdb_assert (WIFSTOPPED (status
));
704 /* Handle GNU/Linux's extended waitstatus for trace events. */
705 if (WIFSTOPPED (status
) && WSTOPSIG (status
) == SIGTRAP
&& status
>> 16 != 0)
708 fprintf_unfiltered (gdb_stdlog
,
709 "WL: Handling extended status 0x%06x\n",
711 if (lin_lwp_handle_extended (lp
, status
))
712 return wait_lwp (lp
);
718 /* Send a SIGSTOP to LP. */
721 stop_callback (struct lwp_info
*lp
, void *data
)
723 if (!lp
->stopped
&& !lp
->signalled
)
729 fprintf_unfiltered (gdb_stdlog
,
730 "SC: kill %s **<SIGSTOP>**\n",
731 target_pid_to_str (lp
->ptid
));
734 ret
= kill_lwp (GET_LWP (lp
->ptid
), SIGSTOP
);
737 fprintf_unfiltered (gdb_stdlog
,
738 "SC: lwp kill %d %s\n",
740 errno
? safe_strerror (errno
) : "ERRNO-OK");
744 gdb_assert (lp
->status
== 0);
750 /* Wait until LP is stopped. If DATA is non-null it is interpreted as
751 a pointer to a set of signals to be flushed immediately. */
754 stop_wait_callback (struct lwp_info
*lp
, void *data
)
756 sigset_t
*flush_mask
= data
;
762 status
= wait_lwp (lp
);
766 /* Ignore any signals in FLUSH_MASK. */
767 if (flush_mask
&& sigismember (flush_mask
, WSTOPSIG (status
)))
776 ptrace (PTRACE_CONT
, GET_LWP (lp
->ptid
), 0, 0);
778 fprintf_unfiltered (gdb_stdlog
,
779 "PTRACE_CONT %s, 0, 0 (%s)\n",
780 target_pid_to_str (lp
->ptid
),
781 errno
? safe_strerror (errno
) : "OK");
783 return stop_wait_callback (lp
, flush_mask
);
786 if (WSTOPSIG (status
) != SIGSTOP
)
788 if (WSTOPSIG (status
) == SIGTRAP
)
790 /* If a LWP other than the LWP that we're reporting an
791 event for has hit a GDB breakpoint (as opposed to
792 some random trap signal), then just arrange for it to
793 hit it again later. We don't keep the SIGTRAP status
794 and don't forward the SIGTRAP signal to the LWP. We
795 will handle the current event, eventually we will
796 resume all LWPs, and this one will get its breakpoint
799 If we do not do this, then we run the risk that the
800 user will delete or disable the breakpoint, but the
801 thread will have already tripped on it. */
803 /* Now resume this LWP and get the SIGSTOP event. */
805 ptrace (PTRACE_CONT
, GET_LWP (lp
->ptid
), 0, 0);
808 fprintf_unfiltered (gdb_stdlog
,
809 "PTRACE_CONT %s, 0, 0 (%s)\n",
810 target_pid_to_str (lp
->ptid
),
811 errno
? safe_strerror (errno
) : "OK");
813 fprintf_unfiltered (gdb_stdlog
,
814 "SWC: Candidate SIGTRAP event in %s\n",
815 target_pid_to_str (lp
->ptid
));
817 /* Hold the SIGTRAP for handling by lin_lwp_wait. */
818 stop_wait_callback (lp
, data
);
819 /* If there's another event, throw it back into the queue. */
824 fprintf_unfiltered (gdb_stdlog
,
825 "SWC: kill %s, %s\n",
826 target_pid_to_str (lp
->ptid
),
827 status_to_str ((int) status
));
829 kill_lwp (GET_LWP (lp
->ptid
), WSTOPSIG (lp
->status
));
831 /* Save the sigtrap event. */
837 /* The thread was stopped with a signal other than
838 SIGSTOP, and didn't accidentally trip a breakpoint. */
842 fprintf_unfiltered (gdb_stdlog
,
843 "SWC: Pending event %s in %s\n",
844 status_to_str ((int) status
),
845 target_pid_to_str (lp
->ptid
));
847 /* Now resume this LWP and get the SIGSTOP event. */
849 ptrace (PTRACE_CONT
, GET_LWP (lp
->ptid
), 0, 0);
851 fprintf_unfiltered (gdb_stdlog
,
852 "SWC: PTRACE_CONT %s, 0, 0 (%s)\n",
853 target_pid_to_str (lp
->ptid
),
854 errno
? safe_strerror (errno
) : "OK");
856 /* Hold this event/waitstatus while we check to see if
857 there are any more (we still want to get that SIGSTOP). */
858 stop_wait_callback (lp
, data
);
859 /* If the lp->status field is still empty, use it to hold
860 this event. If not, then this event must be returned
861 to the event queue of the LWP. */
868 fprintf_unfiltered (gdb_stdlog
,
869 "SWC: kill %s, %s\n",
870 target_pid_to_str (lp
->ptid
),
871 status_to_str ((int) status
));
873 kill_lwp (GET_LWP (lp
->ptid
), WSTOPSIG (status
));
880 /* We caught the SIGSTOP that we intended to catch, so
881 there's no SIGSTOP pending. */
890 /* Check whether PID has any pending signals in FLUSH_MASK. If so set
891 the appropriate bits in PENDING, and return 1 - otherwise return 0. */
894 lin_lwp_has_pending (int pid
, sigset_t
*pending
, sigset_t
*flush_mask
)
896 sigset_t blocked
, ignored
;
899 linux_proc_pending_signals (pid
, pending
, &blocked
, &ignored
);
904 for (i
= 1; i
< NSIG
; i
++)
905 if (sigismember (pending
, i
))
906 if (!sigismember (flush_mask
, i
)
907 || sigismember (&blocked
, i
)
908 || sigismember (&ignored
, i
))
909 sigdelset (pending
, i
);
911 if (sigisemptyset (pending
))
917 /* DATA is interpreted as a mask of signals to flush. If LP has
918 signals pending, and they are all in the flush mask, then arrange
919 to flush them. LP should be stopped, as should all other threads
920 it might share a signal queue with. */
923 flush_callback (struct lwp_info
*lp
, void *data
)
925 sigset_t
*flush_mask
= data
;
926 sigset_t pending
, intersection
, blocked
, ignored
;
929 /* Normally, when an LWP exits, it is removed from the LWP list. The
930 last LWP isn't removed till later, however. So if there is only
931 one LWP on the list, make sure it's alive. */
932 if (lwp_list
== lp
&& lp
->next
== NULL
)
933 if (!lin_lwp_thread_alive (lp
->ptid
))
936 /* Just because the LWP is stopped doesn't mean that new signals
937 can't arrive from outside, so this function must be careful of
938 race conditions. However, because all threads are stopped, we
939 can assume that the pending mask will not shrink unless we resume
940 the LWP, and that it will then get another signal. We can't
941 control which one, however. */
946 printf_unfiltered ("FC: LP has pending status %06x\n", lp
->status
);
947 if (WIFSTOPPED (lp
->status
) && sigismember (flush_mask
, WSTOPSIG (lp
->status
)))
951 while (lin_lwp_has_pending (GET_LWP (lp
->ptid
), &pending
, flush_mask
))
956 ret
= ptrace (PTRACE_CONT
, GET_LWP (lp
->ptid
), 0, 0);
958 fprintf_unfiltered (gdb_stderr
,
959 "FC: Sent PTRACE_CONT, ret %d %d\n", ret
, errno
);
962 stop_wait_callback (lp
, flush_mask
);
964 fprintf_unfiltered (gdb_stderr
,
965 "FC: Wait finished; saved status is %d\n",
972 /* Return non-zero if LP has a wait status pending. */
975 status_callback (struct lwp_info
*lp
, void *data
)
977 /* Only report a pending wait status if we pretend that this has
978 indeed been resumed. */
979 return (lp
->status
!= 0 && lp
->resumed
);
982 /* Return non-zero if LP isn't stopped. */
985 running_callback (struct lwp_info
*lp
, void *data
)
987 return (lp
->stopped
== 0 || (lp
->status
!= 0 && lp
->resumed
));
990 /* Count the LWP's that have had events. */
993 count_events_callback (struct lwp_info
*lp
, void *data
)
997 gdb_assert (count
!= NULL
);
999 /* Count only LWPs that have a SIGTRAP event pending. */
1001 && WIFSTOPPED (lp
->status
) && WSTOPSIG (lp
->status
) == SIGTRAP
)
1007 /* Select the LWP (if any) that is currently being single-stepped. */
1010 select_singlestep_lwp_callback (struct lwp_info
*lp
, void *data
)
1012 if (lp
->step
&& lp
->status
!= 0)
1018 /* Select the Nth LWP that has had a SIGTRAP event. */
1021 select_event_lwp_callback (struct lwp_info
*lp
, void *data
)
1023 int *selector
= data
;
1025 gdb_assert (selector
!= NULL
);
1027 /* Select only LWPs that have a SIGTRAP event pending. */
1029 && WIFSTOPPED (lp
->status
) && WSTOPSIG (lp
->status
) == SIGTRAP
)
1030 if ((*selector
)-- == 0)
1037 cancel_breakpoints_callback (struct lwp_info
*lp
, void *data
)
1039 struct lwp_info
*event_lp
= data
;
1041 /* Leave the LWP that has been elected to receive a SIGTRAP alone. */
1045 /* If a LWP other than the LWP that we're reporting an event for has
1046 hit a GDB breakpoint (as opposed to some random trap signal),
1047 then just arrange for it to hit it again later. We don't keep
1048 the SIGTRAP status and don't forward the SIGTRAP signal to the
1049 LWP. We will handle the current event, eventually we will resume
1050 all LWPs, and this one will get its breakpoint trap again.
1052 If we do not do this, then we run the risk that the user will
1053 delete or disable the breakpoint, but the LWP will have already
1057 && WIFSTOPPED (lp
->status
) && WSTOPSIG (lp
->status
) == SIGTRAP
1058 && breakpoint_inserted_here_p (read_pc_pid (lp
->ptid
) -
1059 DECR_PC_AFTER_BREAK
))
1062 fprintf_unfiltered (gdb_stdlog
,
1063 "CBC: Push back breakpoint for %s\n",
1064 target_pid_to_str (lp
->ptid
));
1066 /* Back up the PC if necessary. */
1067 if (DECR_PC_AFTER_BREAK
)
1068 write_pc_pid (read_pc_pid (lp
->ptid
) - DECR_PC_AFTER_BREAK
, lp
->ptid
);
1070 /* Throw away the SIGTRAP. */
1077 /* Select one LWP out of those that have events pending. */
1080 select_event_lwp (struct lwp_info
**orig_lp
, int *status
)
1083 int random_selector
;
1084 struct lwp_info
*event_lp
;
1086 /* Record the wait status for the origional LWP. */
1087 (*orig_lp
)->status
= *status
;
1089 /* Give preference to any LWP that is being single-stepped. */
1090 event_lp
= iterate_over_lwps (select_singlestep_lwp_callback
, NULL
);
1091 if (event_lp
!= NULL
)
1094 fprintf_unfiltered (gdb_stdlog
,
1095 "SEL: Select single-step %s\n",
1096 target_pid_to_str (event_lp
->ptid
));
1100 /* No single-stepping LWP. Select one at random, out of those
1101 which have had SIGTRAP events. */
1103 /* First see how many SIGTRAP events we have. */
1104 iterate_over_lwps (count_events_callback
, &num_events
);
1106 /* Now randomly pick a LWP out of those that have had a SIGTRAP. */
1107 random_selector
= (int)
1108 ((num_events
* (double) rand ()) / (RAND_MAX
+ 1.0));
1110 if (debug_lin_lwp
&& num_events
> 1)
1111 fprintf_unfiltered (gdb_stdlog
,
1112 "SEL: Found %d SIGTRAP events, selecting #%d\n",
1113 num_events
, random_selector
);
1115 event_lp
= iterate_over_lwps (select_event_lwp_callback
,
1119 if (event_lp
!= NULL
)
1121 /* Switch the event LWP. */
1122 *orig_lp
= event_lp
;
1123 *status
= event_lp
->status
;
1126 /* Flush the wait status for the event LWP. */
1127 (*orig_lp
)->status
= 0;
1130 /* Return non-zero if LP has been resumed. */
1133 resumed_callback (struct lwp_info
*lp
, void *data
)
1140 /* We need to override child_wait to support attaching to cloned
1141 processes, since a normal wait (as done by the default version)
1142 ignores those processes. */
1144 /* Wait for child PTID to do something. Return id of the child,
1145 minus_one_ptid in case of error; store status into *OURSTATUS. */
1148 child_wait (ptid_t ptid
, struct target_waitstatus
*ourstatus
)
1154 ourstatus
->kind
= TARGET_WAITKIND_IGNORE
;
1158 set_sigint_trap (); /* Causes SIGINT to be passed on to the
1159 attached process. */
1162 pid
= waitpid (GET_PID (ptid
), &status
, 0);
1163 if (pid
== -1 && errno
== ECHILD
)
1164 /* Try again with __WCLONE to check cloned processes. */
1165 pid
= waitpid (GET_PID (ptid
), &status
, __WCLONE
);
1169 fprintf_unfiltered (gdb_stdlog
,
1170 "CW: waitpid %ld received %s\n",
1171 (long) pid
, status_to_str (status
));
1176 /* Make sure we don't report an event for the exit of the
1177 original program, if we've detached from it. */
1178 if (pid
!= -1 && !WIFSTOPPED (status
) && pid
!= GET_PID (inferior_ptid
))
1184 /* Check for stop events reported by a process we didn't already
1185 know about - in this case, anything other than inferior_ptid.
1187 If we're expecting to receive stopped processes after fork,
1188 vfork, and clone events, then we'll just add the new one to
1189 our list and go back to waiting for the event to be reported
1190 - the stopped process might be returned from waitpid before
1191 or after the event is. If we want to handle debugging of
1192 CLONE_PTRACE processes we need to do more here, i.e. switch
1193 to multi-threaded mode. */
1194 if (pid
!= -1 && WIFSTOPPED (status
) && WSTOPSIG (status
) == SIGSTOP
1195 && pid
!= GET_PID (inferior_ptid
))
1197 linux_record_stopped_pid (pid
);
1202 /* Handle GNU/Linux's extended waitstatus for trace events. */
1203 if (pid
!= -1 && WIFSTOPPED (status
) && WSTOPSIG (status
) == SIGTRAP
1204 && status
>> 16 != 0)
1206 linux_handle_extended_wait (pid
, status
, ourstatus
);
1208 /* If we see a clone event, detach the child, and don't
1209 report the event. It would be nice to offer some way to
1210 switch into a non-thread-db based threaded mode at this
1212 if (ourstatus
->kind
== TARGET_WAITKIND_SPURIOUS
)
1214 ptrace (PTRACE_DETACH
, ourstatus
->value
.related_pid
, 0, 0);
1215 ourstatus
->kind
= TARGET_WAITKIND_IGNORE
;
1216 ptrace (PTRACE_CONT
, pid
, 0, 0);
1222 clear_sigio_trap ();
1223 clear_sigint_trap ();
1225 while (pid
== -1 && save_errno
== EINTR
);
1229 warning ("Child process unexpectedly missing: %s",
1230 safe_strerror (errno
));
1232 /* Claim it exited with unknown signal. */
1233 ourstatus
->kind
= TARGET_WAITKIND_SIGNALLED
;
1234 ourstatus
->value
.sig
= TARGET_SIGNAL_UNKNOWN
;
1235 return minus_one_ptid
;
1238 if (ourstatus
->kind
== TARGET_WAITKIND_IGNORE
)
1239 store_waitstatus (ourstatus
, status
);
1241 return pid_to_ptid (pid
);
1246 /* Stop an active thread, verify it still exists, then resume it. */
1249 stop_and_resume_callback (struct lwp_info
*lp
, void *data
)
1251 struct lwp_info
*ptr
;
1253 if (!lp
->stopped
&& !lp
->signalled
)
1255 stop_callback (lp
, NULL
);
1256 stop_wait_callback (lp
, NULL
);
1257 /* Resume if the lwp still exists. */
1258 for (ptr
= lwp_list
; ptr
; ptr
= ptr
->next
)
1261 resume_callback (lp
, NULL
);
1262 resume_set_callback (lp
, NULL
);
1269 lin_lwp_wait (ptid_t ptid
, struct target_waitstatus
*ourstatus
)
1271 struct lwp_info
*lp
= NULL
;
1274 pid_t pid
= PIDGET (ptid
);
1275 sigset_t flush_mask
;
1277 sigemptyset (&flush_mask
);
1279 /* Make sure SIGCHLD is blocked. */
1280 if (!sigismember (&blocked_mask
, SIGCHLD
))
1282 sigaddset (&blocked_mask
, SIGCHLD
);
1283 sigprocmask (SIG_BLOCK
, &blocked_mask
, NULL
);
1288 /* Make sure there is at least one LWP that has been resumed, at
1289 least if there are any LWPs at all. */
1290 gdb_assert (num_lwps
== 0 || iterate_over_lwps (resumed_callback
, NULL
));
1292 /* First check if there is a LWP with a wait status pending. */
1295 /* Any LWP that's been resumed will do. */
1296 lp
= iterate_over_lwps (status_callback
, NULL
);
1299 status
= lp
->status
;
1302 if (debug_lin_lwp
&& status
)
1303 fprintf_unfiltered (gdb_stdlog
,
1304 "LLW: Using pending wait status %s for %s.\n",
1305 status_to_str (status
),
1306 target_pid_to_str (lp
->ptid
));
1309 /* But if we don't fine one, we'll have to wait, and check both
1310 cloned and uncloned processes. We start with the cloned
1312 options
= __WCLONE
| WNOHANG
;
1314 else if (is_lwp (ptid
))
1317 fprintf_unfiltered (gdb_stdlog
,
1318 "LLW: Waiting for specific LWP %s.\n",
1319 target_pid_to_str (ptid
));
1321 /* We have a specific LWP to check. */
1322 lp
= find_lwp_pid (ptid
);
1324 status
= lp
->status
;
1327 if (debug_lin_lwp
&& status
)
1328 fprintf_unfiltered (gdb_stdlog
,
1329 "LLW: Using pending wait status %s for %s.\n",
1330 status_to_str (status
),
1331 target_pid_to_str (lp
->ptid
));
1333 /* If we have to wait, take into account whether PID is a cloned
1334 process or not. And we have to convert it to something that
1335 the layer beneath us can understand. */
1336 options
= lp
->cloned
? __WCLONE
: 0;
1337 pid
= GET_LWP (ptid
);
1340 if (status
&& lp
->signalled
)
1342 /* A pending SIGSTOP may interfere with the normal stream of
1343 events. In a typical case where interference is a problem,
1344 we have a SIGSTOP signal pending for LWP A while
1345 single-stepping it, encounter an event in LWP B, and take the
1346 pending SIGSTOP while trying to stop LWP A. After processing
1347 the event in LWP B, LWP A is continued, and we'll never see
1348 the SIGTRAP associated with the last time we were
1349 single-stepping LWP A. */
1351 /* Resume the thread. It should halt immediately returning the
1353 registers_changed ();
1354 child_resume (pid_to_ptid (GET_LWP (lp
->ptid
)), lp
->step
,
1357 fprintf_unfiltered (gdb_stdlog
,
1358 "LLW: %s %s, 0, 0 (expect SIGSTOP)\n",
1359 lp
->step
? "PTRACE_SINGLESTEP" : "PTRACE_CONT",
1360 target_pid_to_str (lp
->ptid
));
1362 gdb_assert (lp
->resumed
);
1364 /* This should catch the pending SIGSTOP. */
1365 stop_wait_callback (lp
, NULL
);
1368 set_sigint_trap (); /* Causes SIGINT to be passed on to the
1369 attached process. */
1376 lwpid
= waitpid (pid
, &status
, options
);
1379 gdb_assert (pid
== -1 || lwpid
== pid
);
1383 fprintf_unfiltered (gdb_stdlog
,
1384 "LLW: waitpid %ld received %s\n",
1385 (long) lwpid
, status_to_str (status
));
1388 lp
= find_lwp_pid (pid_to_ptid (lwpid
));
1390 /* Check for stop events reported by a process we didn't
1391 already know about - anything not already in our LWP
1394 If we're expecting to receive stopped processes after
1395 fork, vfork, and clone events, then we'll just add the
1396 new one to our list and go back to waiting for the event
1397 to be reported - the stopped process might be returned
1398 from waitpid before or after the event is. */
1399 if (WIFSTOPPED (status
) && !lp
)
1401 linux_record_stopped_pid (lwpid
);
1406 /* Make sure we don't report an event for the exit of an LWP not in
1407 our list, i.e. not part of the current process. This can happen
1408 if we detach from a program we original forked and then it
1410 if (!WIFSTOPPED (status
) && !lp
)
1416 /* NOTE drow/2003-06-17: This code seems to be meant for debugging
1417 CLONE_PTRACE processes which do not use the thread library -
1418 otherwise we wouldn't find the new LWP this way. That doesn't
1419 currently work, and the following code is currently unreachable
1420 due to the two blocks above. If it's fixed some day, this code
1421 should be broken out into a function so that we can also pick up
1422 LWPs from the new interface. */
1425 lp
= add_lwp (BUILD_LWP (lwpid
, GET_PID (inferior_ptid
)));
1426 if (options
& __WCLONE
)
1431 gdb_assert (WIFSTOPPED (status
)
1432 && WSTOPSIG (status
) == SIGSTOP
);
1435 if (!in_thread_list (inferior_ptid
))
1437 inferior_ptid
= BUILD_LWP (GET_PID (inferior_ptid
),
1438 GET_PID (inferior_ptid
));
1439 add_thread (inferior_ptid
);
1442 add_thread (lp
->ptid
);
1443 printf_unfiltered ("[New %s]\n",
1444 target_pid_to_str (lp
->ptid
));
1448 /* Handle GNU/Linux's extended waitstatus for trace events. */
1449 if (WIFSTOPPED (status
) && WSTOPSIG (status
) == SIGTRAP
&& status
>> 16 != 0)
1452 fprintf_unfiltered (gdb_stdlog
,
1453 "LLW: Handling extended status 0x%06x\n",
1455 if (lin_lwp_handle_extended (lp
, status
))
1462 /* Check if the thread has exited. */
1463 if ((WIFEXITED (status
) || WIFSIGNALED (status
)) && num_lwps
> 1)
1465 if (in_thread_list (lp
->ptid
))
1467 /* Core GDB cannot deal with us deleting the current
1469 if (!ptid_equal (lp
->ptid
, inferior_ptid
))
1470 delete_thread (lp
->ptid
);
1471 printf_unfiltered ("[%s exited]\n",
1472 target_pid_to_str (lp
->ptid
));
1475 /* If this is the main thread, we must stop all threads and
1476 verify if they are still alive. This is because in the nptl
1477 thread model, there is no signal issued for exiting LWPs
1478 other than the main thread. We only get the main thread
1479 exit signal once all child threads have already exited.
1480 If we stop all the threads and use the stop_wait_callback
1481 to check if they have exited we can determine whether this
1482 signal should be ignored or whether it means the end of the
1483 debugged application, regardless of which threading model
1485 if (GET_PID (lp
->ptid
) == GET_LWP (lp
->ptid
))
1488 iterate_over_lwps (stop_and_resume_callback
, NULL
);
1492 fprintf_unfiltered (gdb_stdlog
,
1493 "LLW: %s exited.\n",
1494 target_pid_to_str (lp
->ptid
));
1496 delete_lwp (lp
->ptid
);
1498 /* If there is at least one more LWP, then the exit signal
1499 was not the end of the debugged application and should be
1503 /* Make sure there is at least one thread running. */
1504 gdb_assert (iterate_over_lwps (running_callback
, NULL
));
1506 /* Discard the event. */
1512 /* Check if the current LWP has previously exited. In the nptl
1513 thread model, LWPs other than the main thread do not issue
1514 signals when they exit so we must check whenever the thread
1515 has stopped. A similar check is made in stop_wait_callback(). */
1516 if (num_lwps
> 1 && !lin_lwp_thread_alive (lp
->ptid
))
1518 if (in_thread_list (lp
->ptid
))
1520 /* Core GDB cannot deal with us deleting the current
1522 if (!ptid_equal (lp
->ptid
, inferior_ptid
))
1523 delete_thread (lp
->ptid
);
1524 printf_unfiltered ("[%s exited]\n",
1525 target_pid_to_str (lp
->ptid
));
1528 fprintf_unfiltered (gdb_stdlog
,
1529 "LLW: %s exited.\n",
1530 target_pid_to_str (lp
->ptid
));
1532 delete_lwp (lp
->ptid
);
1534 /* Make sure there is at least one thread running. */
1535 gdb_assert (iterate_over_lwps (running_callback
, NULL
));
1537 /* Discard the event. */
1542 /* Make sure we don't report a SIGSTOP that we sent
1543 ourselves in an attempt to stop an LWP. */
1545 && WIFSTOPPED (status
) && WSTOPSIG (status
) == SIGSTOP
)
1548 fprintf_unfiltered (gdb_stdlog
,
1549 "LLW: Delayed SIGSTOP caught for %s.\n",
1550 target_pid_to_str (lp
->ptid
));
1552 /* This is a delayed SIGSTOP. */
1555 registers_changed ();
1556 child_resume (pid_to_ptid (GET_LWP (lp
->ptid
)), lp
->step
,
1559 fprintf_unfiltered (gdb_stdlog
,
1560 "LLW: %s %s, 0, 0 (discard SIGSTOP)\n",
1562 "PTRACE_SINGLESTEP" : "PTRACE_CONT",
1563 target_pid_to_str (lp
->ptid
));
1566 gdb_assert (lp
->resumed
);
1568 /* Discard the event. */
1578 /* Alternate between checking cloned and uncloned processes. */
1579 options
^= __WCLONE
;
1581 /* And suspend every time we have checked both. */
1582 if (options
& __WCLONE
)
1583 sigsuspend (&suspend_mask
);
1586 /* We shouldn't end up here unless we want to try again. */
1587 gdb_assert (status
== 0);
1590 clear_sigio_trap ();
1591 clear_sigint_trap ();
1595 /* Don't report signals that GDB isn't interested in, such as
1596 signals that are neither printed nor stopped upon. Stopping all
1597 threads can be a bit time-consuming so if we want decent
1598 performance with heavily multi-threaded programs, especially when
1599 they're using a high frequency timer, we'd better avoid it if we
1602 if (WIFSTOPPED (status
))
1604 int signo
= target_signal_from_host (WSTOPSIG (status
));
1606 if (signal_stop_state (signo
) == 0
1607 && signal_print_state (signo
) == 0
1608 && signal_pass_state (signo
) == 1)
1610 /* FIMXE: kettenis/2001-06-06: Should we resume all threads
1611 here? It is not clear we should. GDB may not expect
1612 other threads to run. On the other hand, not resuming
1613 newly attached threads may cause an unwanted delay in
1614 getting them running. */
1615 registers_changed ();
1616 child_resume (pid_to_ptid (GET_LWP (lp
->ptid
)), lp
->step
, signo
);
1618 fprintf_unfiltered (gdb_stdlog
,
1619 "LLW: %s %s, %s (preempt 'handle')\n",
1621 "PTRACE_SINGLESTEP" : "PTRACE_CONT",
1622 target_pid_to_str (lp
->ptid
),
1623 signo
? strsignal (signo
) : "0");
1629 if (signo
== TARGET_SIGNAL_INT
&& signal_pass_state (signo
) == 0)
1631 /* If ^C/BREAK is typed at the tty/console, SIGINT gets
1632 forwarded to the entire process group, that is, all LWP's
1633 will receive it. Since we only want to report it once,
1634 we try to flush it from all LWPs except this one. */
1635 sigaddset (&flush_mask
, SIGINT
);
1639 /* This LWP is stopped now. */
1643 fprintf_unfiltered (gdb_stdlog
, "LLW: Candidate event %s in %s.\n",
1644 status_to_str (status
), target_pid_to_str (lp
->ptid
));
1646 /* Now stop all other LWP's ... */
1647 iterate_over_lwps (stop_callback
, NULL
);
1649 /* ... and wait until all of them have reported back that they're no
1651 iterate_over_lwps (stop_wait_callback
, &flush_mask
);
1652 iterate_over_lwps (flush_callback
, &flush_mask
);
1654 /* If we're not waiting for a specific LWP, choose an event LWP from
1655 among those that have had events. Giving equal priority to all
1656 LWPs that have had events helps prevent starvation. */
1658 select_event_lwp (&lp
, &status
);
1660 /* Now that we've selected our final event LWP, cancel any
1661 breakpoints in other LWPs that have hit a GDB breakpoint. See
1662 the comment in cancel_breakpoints_callback to find out why. */
1663 iterate_over_lwps (cancel_breakpoints_callback
, lp
);
1665 /* If we're not running in "threaded" mode, we'll report the bare
1668 if (WIFSTOPPED (status
) && WSTOPSIG (status
) == SIGTRAP
)
1670 trap_ptid
= (threaded
? lp
->ptid
: pid_to_ptid (GET_LWP (lp
->ptid
)));
1672 fprintf_unfiltered (gdb_stdlog
,
1673 "LLW: trap_ptid is %s.\n",
1674 target_pid_to_str (trap_ptid
));
1677 trap_ptid
= null_ptid
;
1679 if (lp
->waitstatus
.kind
!= TARGET_WAITKIND_IGNORE
)
1681 *ourstatus
= lp
->waitstatus
;
1682 lp
->waitstatus
.kind
= TARGET_WAITKIND_IGNORE
;
1685 store_waitstatus (ourstatus
, status
);
1687 return (threaded
? lp
->ptid
: pid_to_ptid (GET_LWP (lp
->ptid
)));
1691 kill_callback (struct lwp_info
*lp
, void *data
)
1694 ptrace (PTRACE_KILL
, GET_LWP (lp
->ptid
), 0, 0);
1696 fprintf_unfiltered (gdb_stdlog
,
1697 "KC: PTRACE_KILL %s, 0, 0 (%s)\n",
1698 target_pid_to_str (lp
->ptid
),
1699 errno
? safe_strerror (errno
) : "OK");
1705 kill_wait_callback (struct lwp_info
*lp
, void *data
)
1709 /* We must make sure that there are no pending events (delayed
1710 SIGSTOPs, pending SIGTRAPs, etc.) to make sure the current
1711 program doesn't interfere with any following debugging session. */
1713 /* For cloned processes we must check both with __WCLONE and
1714 without, since the exit status of a cloned process isn't reported
1720 pid
= waitpid (GET_LWP (lp
->ptid
), NULL
, __WCLONE
);
1721 if (pid
!= (pid_t
) -1 && debug_lin_lwp
)
1723 fprintf_unfiltered (gdb_stdlog
,
1724 "KWC: wait %s received unknown.\n",
1725 target_pid_to_str (lp
->ptid
));
1728 while (pid
== GET_LWP (lp
->ptid
));
1730 gdb_assert (pid
== -1 && errno
== ECHILD
);
1735 pid
= waitpid (GET_LWP (lp
->ptid
), NULL
, 0);
1736 if (pid
!= (pid_t
) -1 && debug_lin_lwp
)
1738 fprintf_unfiltered (gdb_stdlog
,
1739 "KWC: wait %s received unk.\n",
1740 target_pid_to_str (lp
->ptid
));
1743 while (pid
== GET_LWP (lp
->ptid
));
1745 gdb_assert (pid
== -1 && errno
== ECHILD
);
1752 /* Kill all LWP's ... */
1753 iterate_over_lwps (kill_callback
, NULL
);
1755 /* ... and wait until we've flushed all events. */
1756 iterate_over_lwps (kill_wait_callback
, NULL
);
1758 target_mourn_inferior ();
1762 lin_lwp_create_inferior (char *exec_file
, char *allargs
, char **env
,
1765 child_ops
.to_create_inferior (exec_file
, allargs
, env
, from_tty
);
1769 lin_lwp_mourn_inferior (void)
1771 trap_ptid
= null_ptid
;
1773 /* Destroy LWP info; it's no longer valid. */
1776 /* Restore the original signal mask. */
1777 sigprocmask (SIG_SETMASK
, &normal_mask
, NULL
);
1778 sigemptyset (&blocked_mask
);
1780 child_ops
.to_mourn_inferior ();
1784 lin_lwp_xfer_memory (CORE_ADDR memaddr
, char *myaddr
, int len
, int write
,
1785 struct mem_attrib
*attrib
, struct target_ops
*target
)
1787 struct cleanup
*old_chain
= save_inferior_ptid ();
1790 if (is_lwp (inferior_ptid
))
1791 inferior_ptid
= pid_to_ptid (GET_LWP (inferior_ptid
));
1793 xfer
= linux_proc_xfer_memory (memaddr
, myaddr
, len
, write
, attrib
, target
);
1795 xfer
= child_xfer_memory (memaddr
, myaddr
, len
, write
, attrib
, target
);
1797 do_cleanups (old_chain
);
1802 lin_lwp_thread_alive (ptid_t ptid
)
1804 gdb_assert (is_lwp (ptid
));
1807 ptrace (PTRACE_PEEKUSER
, GET_LWP (ptid
), 0, 0);
1809 fprintf_unfiltered (gdb_stdlog
,
1810 "LLTA: PTRACE_PEEKUSER %s, 0, 0 (%s)\n",
1811 target_pid_to_str (ptid
),
1812 errno
? safe_strerror (errno
) : "OK");
1820 lin_lwp_pid_to_str (ptid_t ptid
)
1822 static char buf
[64];
1826 snprintf (buf
, sizeof (buf
), "LWP %ld", GET_LWP (ptid
));
1830 return normal_pid_to_str (ptid
);
1834 init_lin_lwp_ops (void)
1837 lin_lwp_ops
.to_open
= lin_lwp_open
;
1839 lin_lwp_ops
.to_shortname
= "lwp-layer";
1840 lin_lwp_ops
.to_longname
= "lwp-layer";
1841 lin_lwp_ops
.to_doc
= "Low level threads support (LWP layer)";
1842 lin_lwp_ops
.to_attach
= lin_lwp_attach
;
1843 lin_lwp_ops
.to_detach
= lin_lwp_detach
;
1844 lin_lwp_ops
.to_resume
= lin_lwp_resume
;
1845 lin_lwp_ops
.to_wait
= lin_lwp_wait
;
1846 /* fetch_inferior_registers and store_inferior_registers will
1847 honor the LWP id, so we can use them directly. */
1848 lin_lwp_ops
.to_fetch_registers
= fetch_inferior_registers
;
1849 lin_lwp_ops
.to_store_registers
= store_inferior_registers
;
1850 lin_lwp_ops
.to_xfer_memory
= lin_lwp_xfer_memory
;
1851 lin_lwp_ops
.to_kill
= lin_lwp_kill
;
1852 lin_lwp_ops
.to_create_inferior
= lin_lwp_create_inferior
;
1853 lin_lwp_ops
.to_mourn_inferior
= lin_lwp_mourn_inferior
;
1854 lin_lwp_ops
.to_thread_alive
= lin_lwp_thread_alive
;
1855 lin_lwp_ops
.to_pid_to_str
= lin_lwp_pid_to_str
;
1856 lin_lwp_ops
.to_post_startup_inferior
= child_post_startup_inferior
;
1857 lin_lwp_ops
.to_post_attach
= child_post_attach
;
1858 lin_lwp_ops
.to_insert_fork_catchpoint
= child_insert_fork_catchpoint
;
1859 lin_lwp_ops
.to_insert_vfork_catchpoint
= child_insert_vfork_catchpoint
;
1860 lin_lwp_ops
.to_insert_exec_catchpoint
= child_insert_exec_catchpoint
;
1862 lin_lwp_ops
.to_stratum
= thread_stratum
;
1863 lin_lwp_ops
.to_has_thread_control
= tc_schedlock
;
1864 lin_lwp_ops
.to_magic
= OPS_MAGIC
;
1868 sigchld_handler (int signo
)
1870 /* Do nothing. The only reason for this handler is that it allows
1871 us to use sigsuspend in lin_lwp_wait above to wait for the
1872 arrival of a SIGCHLD. */
1876 _initialize_lin_lwp (void)
1878 struct sigaction action
;
1880 extern void thread_db_init (struct target_ops
*);
1882 init_lin_lwp_ops ();
1883 add_target (&lin_lwp_ops
);
1884 thread_db_init (&lin_lwp_ops
);
1886 /* Save the original signal mask. */
1887 sigprocmask (SIG_SETMASK
, NULL
, &normal_mask
);
1889 action
.sa_handler
= sigchld_handler
;
1890 sigemptyset (&action
.sa_mask
);
1891 action
.sa_flags
= 0;
1892 sigaction (SIGCHLD
, &action
, NULL
);
1894 /* Make sure we don't block SIGCHLD during a sigsuspend. */
1895 sigprocmask (SIG_SETMASK
, NULL
, &suspend_mask
);
1896 sigdelset (&suspend_mask
, SIGCHLD
);
1898 sigemptyset (&blocked_mask
);
1900 deprecated_add_show_from_set
1901 (add_set_cmd ("lin-lwp", no_class
, var_zinteger
,
1902 (char *) &debug_lin_lwp
,
1903 "Set debugging of GNU/Linux lwp module.\n\
1904 Enables printf debugging output.\n", &setdebuglist
), &showdebuglist
);
1908 /* FIXME: kettenis/2000-08-26: The stuff on this page is specific to
1909 the GNU/Linux Threads library and therefore doesn't really belong
1912 /* Read variable NAME in the target and return its value if found.
1913 Otherwise return zero. It is assumed that the type of the variable
1917 get_signo (const char *name
)
1919 struct minimal_symbol
*ms
;
1922 ms
= lookup_minimal_symbol (name
, NULL
, NULL
);
1926 if (target_read_memory (SYMBOL_VALUE_ADDRESS (ms
), (char *) &signo
,
1927 sizeof (signo
)) != 0)
1933 /* Return the set of signals used by the threads library in *SET. */
1936 lin_thread_get_thread_signals (sigset_t
*set
)
1938 struct sigaction action
;
1939 int restart
, cancel
;
1943 restart
= get_signo ("__pthread_sig_restart");
1947 cancel
= get_signo ("__pthread_sig_cancel");
1951 sigaddset (set
, restart
);
1952 sigaddset (set
, cancel
);
1954 /* The GNU/Linux Threads library makes terminating threads send a
1955 special "cancel" signal instead of SIGCHLD. Make sure we catch
1956 those (to prevent them from terminating GDB itself, which is
1957 likely to be their default action) and treat them the same way as
1960 action
.sa_handler
= sigchld_handler
;
1961 sigemptyset (&action
.sa_mask
);
1962 action
.sa_flags
= 0;
1963 sigaction (cancel
, &action
, NULL
);
1965 /* We block the "cancel" signal throughout this code ... */
1966 sigaddset (&blocked_mask
, cancel
);
1967 sigprocmask (SIG_BLOCK
, &blocked_mask
, NULL
);
1969 /* ... except during a sigsuspend. */
1970 sigdelset (&suspend_mask
, cancel
);