1 /* GNU/Linux native-dependent code common to multiple platforms.
3 Copyright (C) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008
4 Free Software Foundation, Inc.
6 This file is part of GDB.
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 3 of the License, or
11 (at your option) any later version.
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program. If not, see <http://www.gnu.org/licenses/>. */
24 #include "gdb_string.h"
26 #include "gdb_assert.h"
27 #ifdef HAVE_TKILL_SYSCALL
29 #include <sys/syscall.h>
31 #include <sys/ptrace.h>
32 #include "linux-nat.h"
33 #include "linux-fork.h"
34 #include "gdbthread.h"
38 #include "inf-ptrace.h"
40 #include <sys/param.h> /* for MAXPATHLEN */
41 #include <sys/procfs.h> /* for elf_gregset etc. */
42 #include "elf-bfd.h" /* for elfcore_write_* */
43 #include "gregset.h" /* for gregset */
44 #include "gdbcore.h" /* for get_exec_file */
45 #include <ctype.h> /* for isdigit */
46 #include "gdbthread.h" /* for struct thread_info etc. */
47 #include "gdb_stat.h" /* for struct stat */
48 #include <fcntl.h> /* for O_RDONLY */
54 /* If the system headers did not provide the constants, hard-code the normal
56 #ifndef PTRACE_EVENT_FORK
58 #define PTRACE_SETOPTIONS 0x4200
59 #define PTRACE_GETEVENTMSG 0x4201
61 /* options set using PTRACE_SETOPTIONS */
62 #define PTRACE_O_TRACESYSGOOD 0x00000001
63 #define PTRACE_O_TRACEFORK 0x00000002
64 #define PTRACE_O_TRACEVFORK 0x00000004
65 #define PTRACE_O_TRACECLONE 0x00000008
66 #define PTRACE_O_TRACEEXEC 0x00000010
67 #define PTRACE_O_TRACEVFORKDONE 0x00000020
68 #define PTRACE_O_TRACEEXIT 0x00000040
70 /* Wait extended result codes for the above trace options. */
71 #define PTRACE_EVENT_FORK 1
72 #define PTRACE_EVENT_VFORK 2
73 #define PTRACE_EVENT_CLONE 3
74 #define PTRACE_EVENT_EXEC 4
75 #define PTRACE_EVENT_VFORK_DONE 5
76 #define PTRACE_EVENT_EXIT 6
78 #endif /* PTRACE_EVENT_FORK */
80 /* We can't always assume that this flag is available, but all systems
81 with the ptrace event handlers also have __WALL, so it's safe to use
84 #define __WALL 0x40000000 /* Wait for any child. */
87 #ifndef PTRACE_GETSIGINFO
88 #define PTRACE_GETSIGINFO 0x4202
91 /* The single-threaded native GNU/Linux target_ops. We save a pointer for
92 the use of the multi-threaded target. */
93 static struct target_ops *linux_ops;
94 static struct target_ops linux_ops_saved;
96 /* The method to call, if any, when a new thread is attached. */
97 static void (*linux_nat_new_thread) (ptid_t);
99 /* The saved to_xfer_partial method, inherited from inf-ptrace.c.
100 Called by our to_xfer_partial. */
101 static LONGEST (*super_xfer_partial) (struct target_ops *,
103 const char *, gdb_byte *,
107 static int debug_linux_nat;
109 show_debug_linux_nat (struct ui_file *file, int from_tty,
110 struct cmd_list_element *c, const char *value)
112 fprintf_filtered (file, _("Debugging of GNU/Linux lwp module is %s.\n"),
116 static int linux_parent_pid;
118 struct simple_pid_list
122 struct simple_pid_list *next;
124 struct simple_pid_list *stopped_pids;
126 /* This variable is a tri-state flag: -1 for unknown, 0 if PTRACE_O_TRACEFORK
127 can not be used, 1 if it can. */
129 static int linux_supports_tracefork_flag = -1;
131 /* If we have PTRACE_O_TRACEFORK, this flag indicates whether we also have
132 PTRACE_O_TRACEVFORKDONE. */
134 static int linux_supports_tracevforkdone_flag = -1;
137 /* Trivial list manipulation functions to keep track of a list of
138 new stopped processes. */
140 add_to_pid_list (struct simple_pid_list **listp, int pid, int status)
142 struct simple_pid_list *new_pid = xmalloc (sizeof (struct simple_pid_list));
144 new_pid->status = status;
145 new_pid->next = *listp;
150 pull_pid_from_list (struct simple_pid_list **listp, int pid, int *status)
152 struct simple_pid_list **p;
154 for (p = listp; *p != NULL; p = &(*p)->next)
155 if ((*p)->pid == pid)
157 struct simple_pid_list *next = (*p)->next;
158 *status = (*p)->status;
167 linux_record_stopped_pid (int pid, int status)
169 add_to_pid_list (&stopped_pids, pid, status);
173 /* A helper function for linux_test_for_tracefork, called after fork (). */
176 linux_tracefork_child (void)
180 ptrace (PTRACE_TRACEME, 0, 0, 0);
181 kill (getpid (), SIGSTOP);
186 /* Wrapper function for waitpid which handles EINTR. */
189 my_waitpid (int pid, int *status, int flags)
194 ret = waitpid (pid, status, flags);
196 while (ret == -1 && errno == EINTR);
201 /* Determine if PTRACE_O_TRACEFORK can be used to follow fork events.
203 First, we try to enable fork tracing on ORIGINAL_PID. If this fails,
204 we know that the feature is not available. This may change the tracing
205 options for ORIGINAL_PID, but we'll be setting them shortly anyway.
207 However, if it succeeds, we don't know for sure that the feature is
208 available; old versions of PTRACE_SETOPTIONS ignored unknown options. We
209 create a child process, attach to it, use PTRACE_SETOPTIONS to enable
210 fork tracing, and let it fork. If the process exits, we assume that we
211 can't use TRACEFORK; if we get the fork notification, and we can extract
212 the new child's PID, then we assume that we can. */
215 linux_test_for_tracefork (int original_pid)
217 int child_pid, ret, status;
220 linux_supports_tracefork_flag = 0;
221 linux_supports_tracevforkdone_flag = 0;
223 ret = ptrace (PTRACE_SETOPTIONS, original_pid, 0, PTRACE_O_TRACEFORK);
229 perror_with_name (("fork"));
232 linux_tracefork_child ();
234 ret = my_waitpid (child_pid, &status, 0);
236 perror_with_name (("waitpid"));
237 else if (ret != child_pid)
238 error (_("linux_test_for_tracefork: waitpid: unexpected result %d."), ret);
239 if (! WIFSTOPPED (status))
240 error (_("linux_test_for_tracefork: waitpid: unexpected status %d."), status);
242 ret = ptrace (PTRACE_SETOPTIONS, child_pid, 0, PTRACE_O_TRACEFORK);
245 ret = ptrace (PTRACE_KILL, child_pid, 0, 0);
248 warning (_("linux_test_for_tracefork: failed to kill child"));
252 ret = my_waitpid (child_pid, &status, 0);
253 if (ret != child_pid)
254 warning (_("linux_test_for_tracefork: failed to wait for killed child"));
255 else if (!WIFSIGNALED (status))
256 warning (_("linux_test_for_tracefork: unexpected wait status 0x%x from "
257 "killed child"), status);
262 /* Check whether PTRACE_O_TRACEVFORKDONE is available. */
263 ret = ptrace (PTRACE_SETOPTIONS, child_pid, 0,
264 PTRACE_O_TRACEFORK | PTRACE_O_TRACEVFORKDONE);
265 linux_supports_tracevforkdone_flag = (ret == 0);
267 ret = ptrace (PTRACE_CONT, child_pid, 0, 0);
269 warning (_("linux_test_for_tracefork: failed to resume child"));
271 ret = my_waitpid (child_pid, &status, 0);
273 if (ret == child_pid && WIFSTOPPED (status)
274 && status >> 16 == PTRACE_EVENT_FORK)
277 ret = ptrace (PTRACE_GETEVENTMSG, child_pid, 0, &second_pid);
278 if (ret == 0 && second_pid != 0)
282 linux_supports_tracefork_flag = 1;
283 my_waitpid (second_pid, &second_status, 0);
284 ret = ptrace (PTRACE_KILL, second_pid, 0, 0);
286 warning (_("linux_test_for_tracefork: failed to kill second child"));
287 my_waitpid (second_pid, &status, 0);
291 warning (_("linux_test_for_tracefork: unexpected result from waitpid "
292 "(%d, status 0x%x)"), ret, status);
294 ret = ptrace (PTRACE_KILL, child_pid, 0, 0);
296 warning (_("linux_test_for_tracefork: failed to kill child"));
297 my_waitpid (child_pid, &status, 0);
300 /* Return non-zero iff we have tracefork functionality available.
301 This function also sets linux_supports_tracefork_flag. */
304 linux_supports_tracefork (int pid)
306 if (linux_supports_tracefork_flag == -1)
307 linux_test_for_tracefork (pid);
308 return linux_supports_tracefork_flag;
312 linux_supports_tracevforkdone (int pid)
314 if (linux_supports_tracefork_flag == -1)
315 linux_test_for_tracefork (pid);
316 return linux_supports_tracevforkdone_flag;
321 linux_enable_event_reporting (ptid_t ptid)
323 int pid = ptid_get_lwp (ptid);
327 pid = ptid_get_pid (ptid);
329 if (! linux_supports_tracefork (pid))
332 options = PTRACE_O_TRACEFORK | PTRACE_O_TRACEVFORK | PTRACE_O_TRACEEXEC
333 | PTRACE_O_TRACECLONE;
334 if (linux_supports_tracevforkdone (pid))
335 options |= PTRACE_O_TRACEVFORKDONE;
337 /* Do not enable PTRACE_O_TRACEEXIT until GDB is more prepared to support
338 read-only process state. */
340 ptrace (PTRACE_SETOPTIONS, pid, 0, options);
344 linux_child_post_attach (int pid)
346 linux_enable_event_reporting (pid_to_ptid (pid));
347 check_for_thread_db ();
351 linux_child_post_startup_inferior (ptid_t ptid)
353 linux_enable_event_reporting (ptid);
354 check_for_thread_db ();
358 linux_child_follow_fork (struct target_ops *ops, int follow_child)
361 struct target_waitstatus last_status;
363 int parent_pid, child_pid;
365 get_last_target_status (&last_ptid, &last_status);
366 has_vforked = (last_status.kind == TARGET_WAITKIND_VFORKED);
367 parent_pid = ptid_get_lwp (last_ptid);
369 parent_pid = ptid_get_pid (last_ptid);
370 child_pid = last_status.value.related_pid;
374 /* We're already attached to the parent, by default. */
376 /* Before detaching from the child, remove all breakpoints from
377 it. (This won't actually modify the breakpoint list, but will
378 physically remove the breakpoints from the child.) */
379 /* If we vforked this will remove the breakpoints from the parent
380 also, but they'll be reinserted below. */
381 detach_breakpoints (child_pid);
383 /* Detach new forked process? */
388 target_terminal_ours ();
389 fprintf_filtered (gdb_stdlog,
390 "Detaching after fork from child process %d.\n",
394 ptrace (PTRACE_DETACH, child_pid, 0, 0);
398 struct fork_info *fp;
399 /* Retain child fork in ptrace (stopped) state. */
400 fp = find_fork_pid (child_pid);
402 fp = add_fork (child_pid);
403 fork_save_infrun_state (fp, 0);
408 gdb_assert (linux_supports_tracefork_flag >= 0);
409 if (linux_supports_tracevforkdone (0))
413 ptrace (PTRACE_CONT, parent_pid, 0, 0);
414 my_waitpid (parent_pid, &status, __WALL);
415 if ((status >> 16) != PTRACE_EVENT_VFORK_DONE)
416 warning (_("Unexpected waitpid result %06x when waiting for "
417 "vfork-done"), status);
421 /* We can't insert breakpoints until the child has
422 finished with the shared memory region. We need to
423 wait until that happens. Ideal would be to just
425 - ptrace (PTRACE_SYSCALL, parent_pid, 0, 0);
426 - waitpid (parent_pid, &status, __WALL);
427 However, most architectures can't handle a syscall
428 being traced on the way out if it wasn't traced on
431 We might also think to loop, continuing the child
432 until it exits or gets a SIGTRAP. One problem is
433 that the child might call ptrace with PTRACE_TRACEME.
435 There's no simple and reliable way to figure out when
436 the vforked child will be done with its copy of the
437 shared memory. We could step it out of the syscall,
438 two instructions, let it go, and then single-step the
439 parent once. When we have hardware single-step, this
440 would work; with software single-step it could still
441 be made to work but we'd have to be able to insert
442 single-step breakpoints in the child, and we'd have
443 to insert -just- the single-step breakpoint in the
444 parent. Very awkward.
446 In the end, the best we can do is to make sure it
447 runs for a little while. Hopefully it will be out of
448 range of any breakpoints we reinsert. Usually this
449 is only the single-step breakpoint at vfork's return
455 /* Since we vforked, breakpoints were removed in the parent
456 too. Put them back. */
457 reattach_breakpoints (parent_pid);
462 char child_pid_spelling[40];
464 /* Needed to keep the breakpoint lists in sync. */
466 detach_breakpoints (child_pid);
468 /* Before detaching from the parent, remove all breakpoints from it. */
469 remove_breakpoints ();
473 target_terminal_ours ();
474 fprintf_filtered (gdb_stdlog,
475 "Attaching after fork to child process %d.\n",
479 /* If we're vforking, we may want to hold on to the parent until
480 the child exits or execs. At exec time we can remove the old
481 breakpoints from the parent and detach it; at exit time we
482 could do the same (or even, sneakily, resume debugging it - the
483 child's exec has failed, or something similar).
485 This doesn't clean up "properly", because we can't call
486 target_detach, but that's OK; if the current target is "child",
487 then it doesn't need any further cleanups, and lin_lwp will
488 generally not encounter vfork (vfork is defined to fork
491 The holding part is very easy if we have VFORKDONE events;
492 but keeping track of both processes is beyond GDB at the
493 moment. So we don't expose the parent to the rest of GDB.
494 Instead we quietly hold onto it until such time as we can
498 linux_parent_pid = parent_pid;
499 else if (!detach_fork)
501 struct fork_info *fp;
502 /* Retain parent fork in ptrace (stopped) state. */
503 fp = find_fork_pid (parent_pid);
505 fp = add_fork (parent_pid);
506 fork_save_infrun_state (fp, 0);
510 target_detach (NULL, 0);
513 inferior_ptid = ptid_build (child_pid, child_pid, 0);
515 /* Reinstall ourselves, since we might have been removed in
516 target_detach (which does other necessary cleanup). */
519 linux_nat_switch_fork (inferior_ptid);
521 /* Reset breakpoints in the child as appropriate. */
522 follow_inferior_reset_breakpoints ();
530 linux_child_insert_fork_catchpoint (int pid)
532 if (! linux_supports_tracefork (pid))
533 error (_("Your system does not support fork catchpoints."));
537 linux_child_insert_vfork_catchpoint (int pid)
539 if (!linux_supports_tracefork (pid))
540 error (_("Your system does not support vfork catchpoints."));
544 linux_child_insert_exec_catchpoint (int pid)
546 if (!linux_supports_tracefork (pid))
547 error (_("Your system does not support exec catchpoints."));
550 /* On GNU/Linux there are no real LWP's. The closest thing to LWP's
551 are processes sharing the same VM space. A multi-threaded process
552 is basically a group of such processes. However, such a grouping
553 is almost entirely a user-space issue; the kernel doesn't enforce
554 such a grouping at all (this might change in the future). In
555 general, we'll rely on the threads library (i.e. the GNU/Linux
556 Threads library) to provide such a grouping.
558 It is perfectly well possible to write a multi-threaded application
559 without the assistance of a threads library, by using the clone
560 system call directly. This module should be able to give some
561 rudimentary support for debugging such applications if developers
562 specify the CLONE_PTRACE flag in the clone system call, and are
563 using the Linux kernel 2.4 or above.
565 Note that there are some peculiarities in GNU/Linux that affect
568 - In general one should specify the __WCLONE flag to waitpid in
569 order to make it report events for any of the cloned processes
570 (and leave it out for the initial process). However, if a cloned
571 process has exited the exit status is only reported if the
572 __WCLONE flag is absent. Linux kernel 2.4 has a __WALL flag, but
573 we cannot use it since GDB must work on older systems too.
575 - When a traced, cloned process exits and is waited for by the
576 debugger, the kernel reassigns it to the original parent and
577 keeps it around as a "zombie". Somehow, the GNU/Linux Threads
578 library doesn't notice this, which leads to the "zombie problem":
579 When debugged a multi-threaded process that spawns a lot of
580 threads will run out of processes, even if the threads exit,
581 because the "zombies" stay around. */
583 /* List of known LWPs. */
584 struct lwp_info *lwp_list;
586 /* Number of LWPs in the list. */
590 #define GET_LWP(ptid) ptid_get_lwp (ptid)
591 #define GET_PID(ptid) ptid_get_pid (ptid)
592 #define is_lwp(ptid) (GET_LWP (ptid) != 0)
593 #define BUILD_LWP(lwp, pid) ptid_build (pid, lwp, 0)
595 /* If the last reported event was a SIGTRAP, this variable is set to
596 the process id of the LWP/thread that got it. */
600 /* Since we cannot wait (in linux_nat_wait) for the initial process and
601 any cloned processes with a single call to waitpid, we have to use
602 the WNOHANG flag and call waitpid in a loop. To optimize
603 things a bit we use `sigsuspend' to wake us up when a process has
604 something to report (it will send us a SIGCHLD if it has). To make
605 this work we have to juggle with the signal mask. We save the
606 original signal mask such that we can restore it before creating a
607 new process in order to avoid blocking certain signals in the
608 inferior. We then block SIGCHLD during the waitpid/sigsuspend
611 /* Original signal mask. */
612 static sigset_t normal_mask;
614 /* Signal mask for use with sigsuspend in linux_nat_wait, initialized in
615 _initialize_linux_nat. */
616 static sigset_t suspend_mask;
618 /* Signals to block to make that sigsuspend work. */
619 static sigset_t blocked_mask;
622 /* Prototypes for local functions. */
623 static int stop_wait_callback (struct lwp_info *lp, void *data);
624 static int linux_nat_thread_alive (ptid_t ptid);
625 static char *linux_child_pid_to_exec_file (int pid);
627 /* Convert wait status STATUS to a string. Used for printing debug
631 status_to_str (int status)
635 if (WIFSTOPPED (status))
636 snprintf (buf, sizeof (buf), "%s (stopped)",
637 strsignal (WSTOPSIG (status)));
638 else if (WIFSIGNALED (status))
639 snprintf (buf, sizeof (buf), "%s (terminated)",
640 strsignal (WSTOPSIG (status)));
642 snprintf (buf, sizeof (buf), "%d (exited)", WEXITSTATUS (status));
647 /* Initialize the list of LWPs. Note that this module, contrary to
648 what GDB's generic threads layer does for its thread list,
649 re-initializes the LWP lists whenever we mourn or detach (which
650 doesn't involve mourning) the inferior. */
655 struct lwp_info *lp, *lpnext;
657 for (lp = lwp_list; lp; lp = lpnext)
667 /* Add the LWP specified by PID to the list. Return a pointer to the
668 structure describing the new LWP. The LWP should already be stopped
669 (with an exception for the very first LWP). */
671 static struct lwp_info *
672 add_lwp (ptid_t ptid)
676 gdb_assert (is_lwp (ptid));
678 lp = (struct lwp_info *) xmalloc (sizeof (struct lwp_info));
680 memset (lp, 0, sizeof (struct lwp_info));
682 lp->waitstatus.kind = TARGET_WAITKIND_IGNORE;
690 if (num_lwps > 1 && linux_nat_new_thread != NULL)
691 linux_nat_new_thread (ptid);
696 /* Remove the LWP specified by PID from the list. */
699 delete_lwp (ptid_t ptid)
701 struct lwp_info *lp, *lpprev;
705 for (lp = lwp_list; lp; lpprev = lp, lp = lp->next)
706 if (ptid_equal (lp->ptid, ptid))
715 lpprev->next = lp->next;
722 /* Return a pointer to the structure describing the LWP corresponding
723 to PID. If no corresponding LWP could be found, return NULL. */
725 static struct lwp_info *
726 find_lwp_pid (ptid_t ptid)
732 lwp = GET_LWP (ptid);
734 lwp = GET_PID (ptid);
736 for (lp = lwp_list; lp; lp = lp->next)
737 if (lwp == GET_LWP (lp->ptid))
743 /* Call CALLBACK with its second argument set to DATA for every LWP in
744 the list. If CALLBACK returns 1 for a particular LWP, return a
745 pointer to the structure describing that LWP immediately.
746 Otherwise return NULL. */
749 iterate_over_lwps (int (*callback) (struct lwp_info *, void *), void *data)
751 struct lwp_info *lp, *lpnext;
753 for (lp = lwp_list; lp; lp = lpnext)
756 if ((*callback) (lp, data))
763 /* Update our internal state when changing from one fork (checkpoint,
764 et cetera) to another indicated by NEW_PTID. We can only switch
765 single-threaded applications, so we only create one new LWP, and
766 the previous list is discarded. */
769 linux_nat_switch_fork (ptid_t new_ptid)
774 lp = add_lwp (new_ptid);
778 /* Record a PTID for later deletion. */
783 struct saved_ptids *next;
785 static struct saved_ptids *threads_to_delete;
788 record_dead_thread (ptid_t ptid)
790 struct saved_ptids *p = xmalloc (sizeof (struct saved_ptids));
792 p->next = threads_to_delete;
793 threads_to_delete = p;
796 /* Delete any dead threads which are not the current thread. */
801 struct saved_ptids **p = &threads_to_delete;
804 if (! ptid_equal ((*p)->ptid, inferior_ptid))
806 struct saved_ptids *tmp = *p;
807 delete_thread (tmp->ptid);
815 /* Callback for iterate_over_threads that finds a thread corresponding
819 find_thread_from_lwp (struct thread_info *thr, void *dummy)
821 ptid_t *ptid_p = dummy;
823 if (GET_LWP (thr->ptid) && GET_LWP (thr->ptid) == GET_LWP (*ptid_p))
829 /* Handle the exit of a single thread LP. */
832 exit_lwp (struct lwp_info *lp)
834 if (in_thread_list (lp->ptid))
836 /* Core GDB cannot deal with us deleting the current thread. */
837 if (!ptid_equal (lp->ptid, inferior_ptid))
838 delete_thread (lp->ptid);
840 record_dead_thread (lp->ptid);
841 printf_unfiltered (_("[%s exited]\n"),
842 target_pid_to_str (lp->ptid));
846 /* Even if LP->PTID is not in the global GDB thread list, the
847 LWP may be - with an additional thread ID. We don't need
848 to print anything in this case; thread_db is in use and
849 already took care of that. But it didn't delete the thread
850 in order to handle zombies correctly. */
852 struct thread_info *thr;
854 thr = iterate_over_threads (find_thread_from_lwp, &lp->ptid);
857 if (!ptid_equal (thr->ptid, inferior_ptid))
858 delete_thread (thr->ptid);
860 record_dead_thread (thr->ptid);
864 delete_lwp (lp->ptid);
867 /* Attach to the LWP specified by PID. If VERBOSE is non-zero, print
868 a message telling the user that a new LWP has been added to the
869 process. Return 0 if successful or -1 if the new LWP could not
873 lin_lwp_attach_lwp (ptid_t ptid, int verbose)
877 gdb_assert (is_lwp (ptid));
879 /* Make sure SIGCHLD is blocked. We don't want SIGCHLD events
880 to interrupt either the ptrace() or waitpid() calls below. */
881 if (!sigismember (&blocked_mask, SIGCHLD))
883 sigaddset (&blocked_mask, SIGCHLD);
884 sigprocmask (SIG_BLOCK, &blocked_mask, NULL);
887 lp = find_lwp_pid (ptid);
889 /* We assume that we're already attached to any LWP that has an id
890 equal to the overall process id, and to any LWP that is already
891 in our list of LWPs. If we're not seeing exit events from threads
892 and we've had PID wraparound since we last tried to stop all threads,
893 this assumption might be wrong; fortunately, this is very unlikely
895 if (GET_LWP (ptid) != GET_PID (ptid) && lp == NULL)
901 if (ptrace (PTRACE_ATTACH, GET_LWP (ptid), 0, 0) < 0)
903 /* If we fail to attach to the thread, issue a warning,
904 but continue. One way this can happen is if thread
905 creation is interrupted; as of Linux kernel 2.6.19, a
906 bug may place threads in the thread list and then fail
908 warning (_("Can't attach %s: %s"), target_pid_to_str (ptid),
909 safe_strerror (errno));
914 fprintf_unfiltered (gdb_stdlog,
915 "LLAL: PTRACE_ATTACH %s, 0, 0 (OK)\n",
916 target_pid_to_str (ptid));
918 pid = my_waitpid (GET_LWP (ptid), &status, 0);
919 if (pid == -1 && errno == ECHILD)
921 /* Try again with __WCLONE to check cloned processes. */
922 pid = my_waitpid (GET_LWP (ptid), &status, __WCLONE);
926 gdb_assert (pid == GET_LWP (ptid)
927 && WIFSTOPPED (status) && WSTOPSIG (status));
933 target_post_attach (pid);
939 fprintf_unfiltered (gdb_stdlog,
940 "LLAL: waitpid %s received %s\n",
941 target_pid_to_str (ptid),
942 status_to_str (status));
947 /* We assume that the LWP representing the original process is
948 already stopped. Mark it as stopped in the data structure
949 that the GNU/linux ptrace layer uses to keep track of
950 threads. Note that this won't have already been done since
951 the main thread will have, we assume, been stopped by an
952 attach from a different layer. */
959 printf_filtered (_("[New %s]\n"), target_pid_to_str (ptid));
965 linux_nat_attach (char *args, int from_tty)
972 /* FIXME: We should probably accept a list of process id's, and
973 attach all of them. */
974 linux_ops->to_attach (args, from_tty);
976 /* Make sure the initial process is stopped. The user-level threads
977 layer might want to poke around in the inferior, and that won't
978 work if things haven't stabilized yet. */
979 pid = my_waitpid (GET_PID (inferior_ptid), &status, 0);
980 if (pid == -1 && errno == ECHILD)
982 warning (_("%s is a cloned process"), target_pid_to_str (inferior_ptid));
984 /* Try again with __WCLONE to check cloned processes. */
985 pid = my_waitpid (GET_PID (inferior_ptid), &status, __WCLONE);
989 gdb_assert (pid == GET_PID (inferior_ptid)
990 && WIFSTOPPED (status) && WSTOPSIG (status) == SIGSTOP);
992 /* Add the initial process as the first LWP to the list. */
993 inferior_ptid = BUILD_LWP (GET_PID (inferior_ptid), GET_PID (inferior_ptid));
994 lp = add_lwp (inferior_ptid);
999 /* Fake the SIGSTOP that core GDB expects. */
1000 lp->status = W_STOPCODE (SIGSTOP);
1002 if (debug_linux_nat)
1004 fprintf_unfiltered (gdb_stdlog,
1005 "LLA: waitpid %ld, faking SIGSTOP\n", (long) pid);
1010 detach_callback (struct lwp_info *lp, void *data)
1012 gdb_assert (lp->status == 0 || WIFSTOPPED (lp->status));
1014 if (debug_linux_nat && lp->status)
1015 fprintf_unfiltered (gdb_stdlog, "DC: Pending %s for %s on detach.\n",
1016 strsignal (WSTOPSIG (lp->status)),
1017 target_pid_to_str (lp->ptid));
1019 while (lp->signalled && lp->stopped)
1022 if (ptrace (PTRACE_CONT, GET_LWP (lp->ptid), 0,
1023 WSTOPSIG (lp->status)) < 0)
1024 error (_("Can't continue %s: %s"), target_pid_to_str (lp->ptid),
1025 safe_strerror (errno));
1027 if (debug_linux_nat)
1028 fprintf_unfiltered (gdb_stdlog,
1029 "DC: PTRACE_CONTINUE (%s, 0, %s) (OK)\n",
1030 target_pid_to_str (lp->ptid),
1031 status_to_str (lp->status));
1036 /* FIXME drow/2003-08-26: There was a call to stop_wait_callback
1037 here. But since lp->signalled was cleared above,
1038 stop_wait_callback didn't do anything; the process was left
1039 running. Shouldn't we be waiting for it to stop?
1040 I've removed the call, since stop_wait_callback now does do
1041 something when called with lp->signalled == 0. */
1043 gdb_assert (lp->status == 0 || WIFSTOPPED (lp->status));
1046 /* We don't actually detach from the LWP that has an id equal to the
1047 overall process id just yet. */
1048 if (GET_LWP (lp->ptid) != GET_PID (lp->ptid))
1051 if (ptrace (PTRACE_DETACH, GET_LWP (lp->ptid), 0,
1052 WSTOPSIG (lp->status)) < 0)
1053 error (_("Can't detach %s: %s"), target_pid_to_str (lp->ptid),
1054 safe_strerror (errno));
1056 if (debug_linux_nat)
1057 fprintf_unfiltered (gdb_stdlog,
1058 "PTRACE_DETACH (%s, %s, 0) (OK)\n",
1059 target_pid_to_str (lp->ptid),
1060 strsignal (WSTOPSIG (lp->status)));
1062 delete_lwp (lp->ptid);
1069 linux_nat_detach (char *args, int from_tty)
1071 iterate_over_lwps (detach_callback, NULL);
1073 /* Only the initial process should be left right now. */
1074 gdb_assert (num_lwps == 1);
1076 trap_ptid = null_ptid;
1078 /* Destroy LWP info; it's no longer valid. */
1081 /* Restore the original signal mask. */
1082 sigprocmask (SIG_SETMASK, &normal_mask, NULL);
1083 sigemptyset (&blocked_mask);
1085 inferior_ptid = pid_to_ptid (GET_PID (inferior_ptid));
1086 linux_ops->to_detach (args, from_tty);
1092 resume_callback (struct lwp_info *lp, void *data)
1094 if (lp->stopped && lp->status == 0)
1096 linux_ops->to_resume (pid_to_ptid (GET_LWP (lp->ptid)),
1097 0, TARGET_SIGNAL_0);
1098 if (debug_linux_nat)
1099 fprintf_unfiltered (gdb_stdlog,
1100 "RC: PTRACE_CONT %s, 0, 0 (resume sibling)\n",
1101 target_pid_to_str (lp->ptid));
1104 memset (&lp->siginfo, 0, sizeof (lp->siginfo));
1111 resume_clear_callback (struct lwp_info *lp, void *data)
1118 resume_set_callback (struct lwp_info *lp, void *data)
1125 linux_nat_resume (ptid_t ptid, int step, enum target_signal signo)
1127 struct lwp_info *lp;
1130 if (debug_linux_nat)
1131 fprintf_unfiltered (gdb_stdlog,
1132 "LLR: Preparing to %s %s, %s, inferior_ptid %s\n",
1133 step ? "step" : "resume",
1134 target_pid_to_str (ptid),
1135 signo ? strsignal (signo) : "0",
1136 target_pid_to_str (inferior_ptid));
1140 /* A specific PTID means `step only this process id'. */
1141 resume_all = (PIDGET (ptid) == -1);
1144 iterate_over_lwps (resume_set_callback, NULL);
1146 iterate_over_lwps (resume_clear_callback, NULL);
1148 /* If PID is -1, it's the current inferior that should be
1149 handled specially. */
1150 if (PIDGET (ptid) == -1)
1151 ptid = inferior_ptid;
1153 lp = find_lwp_pid (ptid);
1154 gdb_assert (lp != NULL);
1156 ptid = pid_to_ptid (GET_LWP (lp->ptid));
1158 /* Remember if we're stepping. */
1161 /* Mark this LWP as resumed. */
1164 /* If we have a pending wait status for this thread, there is no
1165 point in resuming the process. But first make sure that
1166 linux_nat_wait won't preemptively handle the event - we
1167 should never take this short-circuit if we are going to
1168 leave LP running, since we have skipped resuming all the
1169 other threads. This bit of code needs to be synchronized
1170 with linux_nat_wait. */
1172 if (lp->status && WIFSTOPPED (lp->status))
1174 int saved_signo = target_signal_from_host (WSTOPSIG (lp->status));
1176 if (signal_stop_state (saved_signo) == 0
1177 && signal_print_state (saved_signo) == 0
1178 && signal_pass_state (saved_signo) == 1)
1180 if (debug_linux_nat)
1181 fprintf_unfiltered (gdb_stdlog,
1182 "LLR: Not short circuiting for ignored "
1183 "status 0x%x\n", lp->status);
1185 /* FIXME: What should we do if we are supposed to continue
1186 this thread with a signal? */
1187 gdb_assert (signo == TARGET_SIGNAL_0);
1188 signo = saved_signo;
1195 /* FIXME: What should we do if we are supposed to continue
1196 this thread with a signal? */
1197 gdb_assert (signo == TARGET_SIGNAL_0);
1199 if (debug_linux_nat)
1200 fprintf_unfiltered (gdb_stdlog,
1201 "LLR: Short circuiting for status 0x%x\n",
1207 /* Mark LWP as not stopped to prevent it from being continued by
1212 iterate_over_lwps (resume_callback, NULL);
1214 linux_ops->to_resume (ptid, step, signo);
1215 memset (&lp->siginfo, 0, sizeof (lp->siginfo));
1217 if (debug_linux_nat)
1218 fprintf_unfiltered (gdb_stdlog,
1219 "LLR: %s %s, %s (resume event thread)\n",
1220 step ? "PTRACE_SINGLESTEP" : "PTRACE_CONT",
1221 target_pid_to_str (ptid),
1222 signo ? strsignal (signo) : "0");
1225 /* Issue kill to specified lwp. */
1227 static int tkill_failed;
1230 kill_lwp (int lwpid, int signo)
1234 /* Use tkill, if possible, in case we are using nptl threads. If tkill
1235 fails, then we are not using nptl threads and we should be using kill. */
1237 #ifdef HAVE_TKILL_SYSCALL
1240 int ret = syscall (__NR_tkill, lwpid, signo);
1241 if (errno != ENOSYS)
1248 return kill (lwpid, signo);
1251 /* Handle a GNU/Linux extended wait response. If we see a clone
1252 event, we need to add the new LWP to our list (and not report the
1253 trap to higher layers). This function returns non-zero if the
1254 event should be ignored and we should wait again. If STOPPING is
1255 true, the new LWP remains stopped, otherwise it is continued. */
1258 linux_handle_extended_wait (struct lwp_info *lp, int status,
1261 int pid = GET_LWP (lp->ptid);
1262 struct target_waitstatus *ourstatus = &lp->waitstatus;
1263 struct lwp_info *new_lp = NULL;
1264 int event = status >> 16;
1266 if (event == PTRACE_EVENT_FORK || event == PTRACE_EVENT_VFORK
1267 || event == PTRACE_EVENT_CLONE)
1269 unsigned long new_pid;
1272 ptrace (PTRACE_GETEVENTMSG, pid, 0, &new_pid);
1274 /* If we haven't already seen the new PID stop, wait for it now. */
1275 if (! pull_pid_from_list (&stopped_pids, new_pid, &status))
1277 /* The new child has a pending SIGSTOP. We can't affect it until it
1278 hits the SIGSTOP, but we're already attached. */
1279 ret = my_waitpid (new_pid, &status,
1280 (event == PTRACE_EVENT_CLONE) ? __WCLONE : 0);
1282 perror_with_name (_("waiting for new child"));
1283 else if (ret != new_pid)
1284 internal_error (__FILE__, __LINE__,
1285 _("wait returned unexpected PID %d"), ret);
1286 else if (!WIFSTOPPED (status))
1287 internal_error (__FILE__, __LINE__,
1288 _("wait returned unexpected status 0x%x"), status);
1291 ourstatus->value.related_pid = new_pid;
1293 if (event == PTRACE_EVENT_FORK)
1294 ourstatus->kind = TARGET_WAITKIND_FORKED;
1295 else if (event == PTRACE_EVENT_VFORK)
1296 ourstatus->kind = TARGET_WAITKIND_VFORKED;
1299 ourstatus->kind = TARGET_WAITKIND_IGNORE;
1300 new_lp = add_lwp (BUILD_LWP (new_pid, GET_PID (inferior_ptid)));
1303 if (WSTOPSIG (status) != SIGSTOP)
1305 /* This can happen if someone starts sending signals to
1306 the new thread before it gets a chance to run, which
1307 have a lower number than SIGSTOP (e.g. SIGUSR1).
1308 This is an unlikely case, and harder to handle for
1309 fork / vfork than for clone, so we do not try - but
1310 we handle it for clone events here. We'll send
1311 the other signal on to the thread below. */
1313 new_lp->signalled = 1;
1319 new_lp->stopped = 1;
1322 new_lp->resumed = 1;
1323 ptrace (PTRACE_CONT, lp->waitstatus.value.related_pid, 0,
1324 status ? WSTOPSIG (status) : 0);
1327 if (debug_linux_nat)
1328 fprintf_unfiltered (gdb_stdlog,
1329 "LHEW: Got clone event from LWP %ld, resuming\n",
1330 GET_LWP (lp->ptid));
1331 ptrace (PTRACE_CONT, GET_LWP (lp->ptid), 0, 0);
1339 if (event == PTRACE_EVENT_EXEC)
1341 ourstatus->kind = TARGET_WAITKIND_EXECD;
1342 ourstatus->value.execd_pathname
1343 = xstrdup (linux_child_pid_to_exec_file (pid));
1345 if (linux_parent_pid)
1347 detach_breakpoints (linux_parent_pid);
1348 ptrace (PTRACE_DETACH, linux_parent_pid, 0, 0);
1350 linux_parent_pid = 0;
1356 internal_error (__FILE__, __LINE__,
1357 _("unknown ptrace event %d"), event);
1360 /* Wait for LP to stop. Returns the wait status, or 0 if the LWP has
1364 wait_lwp (struct lwp_info *lp)
1368 int thread_dead = 0;
1370 gdb_assert (!lp->stopped);
1371 gdb_assert (lp->status == 0);
1373 pid = my_waitpid (GET_LWP (lp->ptid), &status, 0);
1374 if (pid == -1 && errno == ECHILD)
1376 pid = my_waitpid (GET_LWP (lp->ptid), &status, __WCLONE);
1377 if (pid == -1 && errno == ECHILD)
1379 /* The thread has previously exited. We need to delete it
1380 now because, for some vendor 2.4 kernels with NPTL
1381 support backported, there won't be an exit event unless
1382 it is the main thread. 2.6 kernels will report an exit
1383 event for each thread that exits, as expected. */
1385 if (debug_linux_nat)
1386 fprintf_unfiltered (gdb_stdlog, "WL: %s vanished.\n",
1387 target_pid_to_str (lp->ptid));
1393 gdb_assert (pid == GET_LWP (lp->ptid));
1395 if (debug_linux_nat)
1397 fprintf_unfiltered (gdb_stdlog,
1398 "WL: waitpid %s received %s\n",
1399 target_pid_to_str (lp->ptid),
1400 status_to_str (status));
1404 /* Check if the thread has exited. */
1405 if (WIFEXITED (status) || WIFSIGNALED (status))
1408 if (debug_linux_nat)
1409 fprintf_unfiltered (gdb_stdlog, "WL: %s exited.\n",
1410 target_pid_to_str (lp->ptid));
1419 gdb_assert (WIFSTOPPED (status));
1421 /* Handle GNU/Linux's extended waitstatus for trace events. */
1422 if (WIFSTOPPED (status) && WSTOPSIG (status) == SIGTRAP && status >> 16 != 0)
1424 if (debug_linux_nat)
1425 fprintf_unfiltered (gdb_stdlog,
1426 "WL: Handling extended status 0x%06x\n",
1428 if (linux_handle_extended_wait (lp, status, 1))
1429 return wait_lwp (lp);
1435 /* Save the most recent siginfo for LP. This is currently only called
1436 for SIGTRAP; some ports use the si_addr field for
1437 target_stopped_data_address. In the future, it may also be used to
1438 restore the siginfo of requeued signals. */
1441 save_siginfo (struct lwp_info *lp)
1444 ptrace (PTRACE_GETSIGINFO, GET_LWP (lp->ptid),
1445 (PTRACE_TYPE_ARG3) 0, &lp->siginfo);
1448 memset (&lp->siginfo, 0, sizeof (lp->siginfo));
1451 /* Send a SIGSTOP to LP. */
1454 stop_callback (struct lwp_info *lp, void *data)
1456 if (!lp->stopped && !lp->signalled)
1460 if (debug_linux_nat)
1462 fprintf_unfiltered (gdb_stdlog,
1463 "SC: kill %s **<SIGSTOP>**\n",
1464 target_pid_to_str (lp->ptid));
1467 ret = kill_lwp (GET_LWP (lp->ptid), SIGSTOP);
1468 if (debug_linux_nat)
1470 fprintf_unfiltered (gdb_stdlog,
1471 "SC: lwp kill %d %s\n",
1473 errno ? safe_strerror (errno) : "ERRNO-OK");
1477 gdb_assert (lp->status == 0);
1483 /* Wait until LP is stopped. If DATA is non-null it is interpreted as
1484 a pointer to a set of signals to be flushed immediately. */
1487 stop_wait_callback (struct lwp_info *lp, void *data)
1489 sigset_t *flush_mask = data;
1495 status = wait_lwp (lp);
1499 /* Ignore any signals in FLUSH_MASK. */
1500 if (flush_mask && sigismember (flush_mask, WSTOPSIG (status)))
1509 ptrace (PTRACE_CONT, GET_LWP (lp->ptid), 0, 0);
1510 if (debug_linux_nat)
1511 fprintf_unfiltered (gdb_stdlog,
1512 "PTRACE_CONT %s, 0, 0 (%s)\n",
1513 target_pid_to_str (lp->ptid),
1514 errno ? safe_strerror (errno) : "OK");
1516 return stop_wait_callback (lp, flush_mask);
1519 if (WSTOPSIG (status) != SIGSTOP)
1521 if (WSTOPSIG (status) == SIGTRAP)
1523 /* If a LWP other than the LWP that we're reporting an
1524 event for has hit a GDB breakpoint (as opposed to
1525 some random trap signal), then just arrange for it to
1526 hit it again later. We don't keep the SIGTRAP status
1527 and don't forward the SIGTRAP signal to the LWP. We
1528 will handle the current event, eventually we will
1529 resume all LWPs, and this one will get its breakpoint
1532 If we do not do this, then we run the risk that the
1533 user will delete or disable the breakpoint, but the
1534 thread will have already tripped on it. */
1536 /* Save the trap's siginfo in case we need it later. */
1539 /* Now resume this LWP and get the SIGSTOP event. */
1541 ptrace (PTRACE_CONT, GET_LWP (lp->ptid), 0, 0);
1542 if (debug_linux_nat)
1544 fprintf_unfiltered (gdb_stdlog,
1545 "PTRACE_CONT %s, 0, 0 (%s)\n",
1546 target_pid_to_str (lp->ptid),
1547 errno ? safe_strerror (errno) : "OK");
1549 fprintf_unfiltered (gdb_stdlog,
1550 "SWC: Candidate SIGTRAP event in %s\n",
1551 target_pid_to_str (lp->ptid));
1553 /* Hold the SIGTRAP for handling by linux_nat_wait. */
1554 stop_wait_callback (lp, data);
1555 /* If there's another event, throw it back into the queue. */
1558 if (debug_linux_nat)
1560 fprintf_unfiltered (gdb_stdlog,
1561 "SWC: kill %s, %s\n",
1562 target_pid_to_str (lp->ptid),
1563 status_to_str ((int) status));
1565 kill_lwp (GET_LWP (lp->ptid), WSTOPSIG (lp->status));
1567 /* Save the sigtrap event. */
1568 lp->status = status;
1573 /* The thread was stopped with a signal other than
1574 SIGSTOP, and didn't accidentally trip a breakpoint. */
1576 if (debug_linux_nat)
1578 fprintf_unfiltered (gdb_stdlog,
1579 "SWC: Pending event %s in %s\n",
1580 status_to_str ((int) status),
1581 target_pid_to_str (lp->ptid));
1583 /* Now resume this LWP and get the SIGSTOP event. */
1585 ptrace (PTRACE_CONT, GET_LWP (lp->ptid), 0, 0);
1586 if (debug_linux_nat)
1587 fprintf_unfiltered (gdb_stdlog,
1588 "SWC: PTRACE_CONT %s, 0, 0 (%s)\n",
1589 target_pid_to_str (lp->ptid),
1590 errno ? safe_strerror (errno) : "OK");
1592 /* Hold this event/waitstatus while we check to see if
1593 there are any more (we still want to get that SIGSTOP). */
1594 stop_wait_callback (lp, data);
1595 /* If the lp->status field is still empty, use it to hold
1596 this event. If not, then this event must be returned
1597 to the event queue of the LWP. */
1598 if (lp->status == 0)
1599 lp->status = status;
1602 if (debug_linux_nat)
1604 fprintf_unfiltered (gdb_stdlog,
1605 "SWC: kill %s, %s\n",
1606 target_pid_to_str (lp->ptid),
1607 status_to_str ((int) status));
1609 kill_lwp (GET_LWP (lp->ptid), WSTOPSIG (status));
1616 /* We caught the SIGSTOP that we intended to catch, so
1617 there's no SIGSTOP pending. */
1626 /* Check whether PID has any pending signals in FLUSH_MASK. If so set
1627 the appropriate bits in PENDING, and return 1 - otherwise return 0. */
1630 linux_nat_has_pending (int pid, sigset_t *pending, sigset_t *flush_mask)
1632 sigset_t blocked, ignored;
1635 linux_proc_pending_signals (pid, pending, &blocked, &ignored);
1640 for (i = 1; i < NSIG; i++)
1641 if (sigismember (pending, i))
1642 if (!sigismember (flush_mask, i)
1643 || sigismember (&blocked, i)
1644 || sigismember (&ignored, i))
1645 sigdelset (pending, i);
1647 if (sigisemptyset (pending))
1653 /* DATA is interpreted as a mask of signals to flush. If LP has
1654 signals pending, and they are all in the flush mask, then arrange
1655 to flush them. LP should be stopped, as should all other threads
1656 it might share a signal queue with. */
1659 flush_callback (struct lwp_info *lp, void *data)
1661 sigset_t *flush_mask = data;
1662 sigset_t pending, intersection, blocked, ignored;
1665 /* Normally, when an LWP exits, it is removed from the LWP list. The
1666 last LWP isn't removed till later, however. So if there is only
1667 one LWP on the list, make sure it's alive. */
1668 if (lwp_list == lp && lp->next == NULL)
1669 if (!linux_nat_thread_alive (lp->ptid))
1672 /* Just because the LWP is stopped doesn't mean that new signals
1673 can't arrive from outside, so this function must be careful of
1674 race conditions. However, because all threads are stopped, we
1675 can assume that the pending mask will not shrink unless we resume
1676 the LWP, and that it will then get another signal. We can't
1677 control which one, however. */
1681 if (debug_linux_nat)
1682 printf_unfiltered (_("FC: LP has pending status %06x\n"), lp->status);
1683 if (WIFSTOPPED (lp->status) && sigismember (flush_mask, WSTOPSIG (lp->status)))
1687 /* While there is a pending signal we would like to flush, continue
1688 the inferior and collect another signal. But if there's already
1689 a saved status that we don't want to flush, we can't resume the
1690 inferior - if it stopped for some other reason we wouldn't have
1691 anywhere to save the new status. In that case, we must leave the
1692 signal unflushed (and possibly generate an extra SIGINT stop).
1693 That's much less bad than losing a signal. */
1694 while (lp->status == 0
1695 && linux_nat_has_pending (GET_LWP (lp->ptid), &pending, flush_mask))
1700 ret = ptrace (PTRACE_CONT, GET_LWP (lp->ptid), 0, 0);
1701 if (debug_linux_nat)
1702 fprintf_unfiltered (gdb_stderr,
1703 "FC: Sent PTRACE_CONT, ret %d %d\n", ret, errno);
1706 stop_wait_callback (lp, flush_mask);
1707 if (debug_linux_nat)
1708 fprintf_unfiltered (gdb_stderr,
1709 "FC: Wait finished; saved status is %d\n",
1716 /* Return non-zero if LP has a wait status pending. */
1719 status_callback (struct lwp_info *lp, void *data)
1721 /* Only report a pending wait status if we pretend that this has
1722 indeed been resumed. */
1723 return (lp->status != 0 && lp->resumed);
1726 /* Return non-zero if LP isn't stopped. */
1729 running_callback (struct lwp_info *lp, void *data)
1731 return (lp->stopped == 0 || (lp->status != 0 && lp->resumed));
1734 /* Count the LWP's that have had events. */
1737 count_events_callback (struct lwp_info *lp, void *data)
1741 gdb_assert (count != NULL);
1743 /* Count only LWPs that have a SIGTRAP event pending. */
1745 && WIFSTOPPED (lp->status) && WSTOPSIG (lp->status) == SIGTRAP)
1751 /* Select the LWP (if any) that is currently being single-stepped. */
1754 select_singlestep_lwp_callback (struct lwp_info *lp, void *data)
1756 if (lp->step && lp->status != 0)
1762 /* Select the Nth LWP that has had a SIGTRAP event. */
1765 select_event_lwp_callback (struct lwp_info *lp, void *data)
1767 int *selector = data;
1769 gdb_assert (selector != NULL);
1771 /* Select only LWPs that have a SIGTRAP event pending. */
1773 && WIFSTOPPED (lp->status) && WSTOPSIG (lp->status) == SIGTRAP)
1774 if ((*selector)-- == 0)
1781 cancel_breakpoints_callback (struct lwp_info *lp, void *data)
1783 struct lwp_info *event_lp = data;
1785 /* Leave the LWP that has been elected to receive a SIGTRAP alone. */
1789 /* If a LWP other than the LWP that we're reporting an event for has
1790 hit a GDB breakpoint (as opposed to some random trap signal),
1791 then just arrange for it to hit it again later. We don't keep
1792 the SIGTRAP status and don't forward the SIGTRAP signal to the
1793 LWP. We will handle the current event, eventually we will resume
1794 all LWPs, and this one will get its breakpoint trap again.
1796 If we do not do this, then we run the risk that the user will
1797 delete or disable the breakpoint, but the LWP will have already
1801 && WIFSTOPPED (lp->status) && WSTOPSIG (lp->status) == SIGTRAP
1802 && breakpoint_inserted_here_p (read_pc_pid (lp->ptid) -
1803 gdbarch_decr_pc_after_break
1806 if (debug_linux_nat)
1807 fprintf_unfiltered (gdb_stdlog,
1808 "CBC: Push back breakpoint for %s\n",
1809 target_pid_to_str (lp->ptid));
1811 /* Back up the PC if necessary. */
1812 if (gdbarch_decr_pc_after_break (current_gdbarch))
1813 write_pc_pid (read_pc_pid (lp->ptid) - gdbarch_decr_pc_after_break
1817 /* Throw away the SIGTRAP. */
1824 /* Select one LWP out of those that have events pending. */
1827 select_event_lwp (struct lwp_info **orig_lp, int *status)
1830 int random_selector;
1831 struct lwp_info *event_lp;
1833 /* Record the wait status for the original LWP. */
1834 (*orig_lp)->status = *status;
1836 /* Give preference to any LWP that is being single-stepped. */
1837 event_lp = iterate_over_lwps (select_singlestep_lwp_callback, NULL);
1838 if (event_lp != NULL)
1840 if (debug_linux_nat)
1841 fprintf_unfiltered (gdb_stdlog,
1842 "SEL: Select single-step %s\n",
1843 target_pid_to_str (event_lp->ptid));
1847 /* No single-stepping LWP. Select one at random, out of those
1848 which have had SIGTRAP events. */
1850 /* First see how many SIGTRAP events we have. */
1851 iterate_over_lwps (count_events_callback, &num_events);
1853 /* Now randomly pick a LWP out of those that have had a SIGTRAP. */
1854 random_selector = (int)
1855 ((num_events * (double) rand ()) / (RAND_MAX + 1.0));
1857 if (debug_linux_nat && num_events > 1)
1858 fprintf_unfiltered (gdb_stdlog,
1859 "SEL: Found %d SIGTRAP events, selecting #%d\n",
1860 num_events, random_selector);
1862 event_lp = iterate_over_lwps (select_event_lwp_callback,
1866 if (event_lp != NULL)
1868 /* Switch the event LWP. */
1869 *orig_lp = event_lp;
1870 *status = event_lp->status;
1873 /* Flush the wait status for the event LWP. */
1874 (*orig_lp)->status = 0;
1877 /* Return non-zero if LP has been resumed. */
1880 resumed_callback (struct lwp_info *lp, void *data)
1885 /* Stop an active thread, verify it still exists, then resume it. */
1888 stop_and_resume_callback (struct lwp_info *lp, void *data)
1890 struct lwp_info *ptr;
1892 if (!lp->stopped && !lp->signalled)
1894 stop_callback (lp, NULL);
1895 stop_wait_callback (lp, NULL);
1896 /* Resume if the lwp still exists. */
1897 for (ptr = lwp_list; ptr; ptr = ptr->next)
1900 resume_callback (lp, NULL);
1901 resume_set_callback (lp, NULL);
1908 linux_nat_wait (ptid_t ptid, struct target_waitstatus *ourstatus)
1910 struct lwp_info *lp = NULL;
1913 pid_t pid = PIDGET (ptid);
1914 sigset_t flush_mask;
1916 /* The first time we get here after starting a new inferior, we may
1917 not have added it to the LWP list yet - this is the earliest
1918 moment at which we know its PID. */
1921 gdb_assert (!is_lwp (inferior_ptid));
1923 inferior_ptid = BUILD_LWP (GET_PID (inferior_ptid),
1924 GET_PID (inferior_ptid));
1925 lp = add_lwp (inferior_ptid);
1929 sigemptyset (&flush_mask);
1931 /* Make sure SIGCHLD is blocked. */
1932 if (!sigismember (&blocked_mask, SIGCHLD))
1934 sigaddset (&blocked_mask, SIGCHLD);
1935 sigprocmask (SIG_BLOCK, &blocked_mask, NULL);
1940 /* Make sure there is at least one LWP that has been resumed. */
1941 gdb_assert (iterate_over_lwps (resumed_callback, NULL));
1943 /* First check if there is a LWP with a wait status pending. */
1946 /* Any LWP that's been resumed will do. */
1947 lp = iterate_over_lwps (status_callback, NULL);
1950 status = lp->status;
1953 if (debug_linux_nat && status)
1954 fprintf_unfiltered (gdb_stdlog,
1955 "LLW: Using pending wait status %s for %s.\n",
1956 status_to_str (status),
1957 target_pid_to_str (lp->ptid));
1960 /* But if we don't fine one, we'll have to wait, and check both
1961 cloned and uncloned processes. We start with the cloned
1963 options = __WCLONE | WNOHANG;
1965 else if (is_lwp (ptid))
1967 if (debug_linux_nat)
1968 fprintf_unfiltered (gdb_stdlog,
1969 "LLW: Waiting for specific LWP %s.\n",
1970 target_pid_to_str (ptid));
1972 /* We have a specific LWP to check. */
1973 lp = find_lwp_pid (ptid);
1975 status = lp->status;
1978 if (debug_linux_nat && status)
1979 fprintf_unfiltered (gdb_stdlog,
1980 "LLW: Using pending wait status %s for %s.\n",
1981 status_to_str (status),
1982 target_pid_to_str (lp->ptid));
1984 /* If we have to wait, take into account whether PID is a cloned
1985 process or not. And we have to convert it to something that
1986 the layer beneath us can understand. */
1987 options = lp->cloned ? __WCLONE : 0;
1988 pid = GET_LWP (ptid);
1991 if (status && lp->signalled)
1993 /* A pending SIGSTOP may interfere with the normal stream of
1994 events. In a typical case where interference is a problem,
1995 we have a SIGSTOP signal pending for LWP A while
1996 single-stepping it, encounter an event in LWP B, and take the
1997 pending SIGSTOP while trying to stop LWP A. After processing
1998 the event in LWP B, LWP A is continued, and we'll never see
1999 the SIGTRAP associated with the last time we were
2000 single-stepping LWP A. */
2002 /* Resume the thread. It should halt immediately returning the
2004 registers_changed ();
2005 linux_ops->to_resume (pid_to_ptid (GET_LWP (lp->ptid)),
2006 lp->step, TARGET_SIGNAL_0);
2007 if (debug_linux_nat)
2008 fprintf_unfiltered (gdb_stdlog,
2009 "LLW: %s %s, 0, 0 (expect SIGSTOP)\n",
2010 lp->step ? "PTRACE_SINGLESTEP" : "PTRACE_CONT",
2011 target_pid_to_str (lp->ptid));
2013 gdb_assert (lp->resumed);
2015 /* This should catch the pending SIGSTOP. */
2016 stop_wait_callback (lp, NULL);
2019 set_sigint_trap (); /* Causes SIGINT to be passed on to the
2020 attached process. */
2027 lwpid = my_waitpid (pid, &status, options);
2030 gdb_assert (pid == -1 || lwpid == pid);
2032 if (debug_linux_nat)
2034 fprintf_unfiltered (gdb_stdlog,
2035 "LLW: waitpid %ld received %s\n",
2036 (long) lwpid, status_to_str (status));
2039 lp = find_lwp_pid (pid_to_ptid (lwpid));
2041 /* Check for stop events reported by a process we didn't
2042 already know about - anything not already in our LWP
2045 If we're expecting to receive stopped processes after
2046 fork, vfork, and clone events, then we'll just add the
2047 new one to our list and go back to waiting for the event
2048 to be reported - the stopped process might be returned
2049 from waitpid before or after the event is. */
2050 if (WIFSTOPPED (status) && !lp)
2052 linux_record_stopped_pid (lwpid, status);
2057 /* Make sure we don't report an event for the exit of an LWP not in
2058 our list, i.e. not part of the current process. This can happen
2059 if we detach from a program we original forked and then it
2061 if (!WIFSTOPPED (status) && !lp)
2067 /* NOTE drow/2003-06-17: This code seems to be meant for debugging
2068 CLONE_PTRACE processes which do not use the thread library -
2069 otherwise we wouldn't find the new LWP this way. That doesn't
2070 currently work, and the following code is currently unreachable
2071 due to the two blocks above. If it's fixed some day, this code
2072 should be broken out into a function so that we can also pick up
2073 LWPs from the new interface. */
2076 lp = add_lwp (BUILD_LWP (lwpid, GET_PID (inferior_ptid)));
2077 if (options & __WCLONE)
2080 gdb_assert (WIFSTOPPED (status)
2081 && WSTOPSIG (status) == SIGSTOP);
2084 if (!in_thread_list (inferior_ptid))
2086 inferior_ptid = BUILD_LWP (GET_PID (inferior_ptid),
2087 GET_PID (inferior_ptid));
2088 add_thread (inferior_ptid);
2091 add_thread (lp->ptid);
2092 printf_unfiltered (_("[New %s]\n"),
2093 target_pid_to_str (lp->ptid));
2096 /* Save the trap's siginfo in case we need it later. */
2097 if (WIFSTOPPED (status) && WSTOPSIG (status) == SIGTRAP)
2100 /* Handle GNU/Linux's extended waitstatus for trace events. */
2101 if (WIFSTOPPED (status) && WSTOPSIG (status) == SIGTRAP && status >> 16 != 0)
2103 if (debug_linux_nat)
2104 fprintf_unfiltered (gdb_stdlog,
2105 "LLW: Handling extended status 0x%06x\n",
2107 if (linux_handle_extended_wait (lp, status, 0))
2114 /* Check if the thread has exited. */
2115 if ((WIFEXITED (status) || WIFSIGNALED (status)) && num_lwps > 1)
2117 /* If this is the main thread, we must stop all threads and
2118 verify if they are still alive. This is because in the nptl
2119 thread model, there is no signal issued for exiting LWPs
2120 other than the main thread. We only get the main thread
2121 exit signal once all child threads have already exited.
2122 If we stop all the threads and use the stop_wait_callback
2123 to check if they have exited we can determine whether this
2124 signal should be ignored or whether it means the end of the
2125 debugged application, regardless of which threading model
2127 if (GET_PID (lp->ptid) == GET_LWP (lp->ptid))
2130 iterate_over_lwps (stop_and_resume_callback, NULL);
2133 if (debug_linux_nat)
2134 fprintf_unfiltered (gdb_stdlog,
2135 "LLW: %s exited.\n",
2136 target_pid_to_str (lp->ptid));
2140 /* If there is at least one more LWP, then the exit signal
2141 was not the end of the debugged application and should be
2145 /* Make sure there is at least one thread running. */
2146 gdb_assert (iterate_over_lwps (running_callback, NULL));
2148 /* Discard the event. */
2154 /* Check if the current LWP has previously exited. In the nptl
2155 thread model, LWPs other than the main thread do not issue
2156 signals when they exit so we must check whenever the thread
2157 has stopped. A similar check is made in stop_wait_callback(). */
2158 if (num_lwps > 1 && !linux_nat_thread_alive (lp->ptid))
2160 if (debug_linux_nat)
2161 fprintf_unfiltered (gdb_stdlog,
2162 "LLW: %s exited.\n",
2163 target_pid_to_str (lp->ptid));
2167 /* Make sure there is at least one thread running. */
2168 gdb_assert (iterate_over_lwps (running_callback, NULL));
2170 /* Discard the event. */
2175 /* Make sure we don't report a SIGSTOP that we sent
2176 ourselves in an attempt to stop an LWP. */
2178 && WIFSTOPPED (status) && WSTOPSIG (status) == SIGSTOP)
2180 if (debug_linux_nat)
2181 fprintf_unfiltered (gdb_stdlog,
2182 "LLW: Delayed SIGSTOP caught for %s.\n",
2183 target_pid_to_str (lp->ptid));
2185 /* This is a delayed SIGSTOP. */
2188 registers_changed ();
2189 linux_ops->to_resume (pid_to_ptid (GET_LWP (lp->ptid)),
2190 lp->step, TARGET_SIGNAL_0);
2191 if (debug_linux_nat)
2192 fprintf_unfiltered (gdb_stdlog,
2193 "LLW: %s %s, 0, 0 (discard SIGSTOP)\n",
2195 "PTRACE_SINGLESTEP" : "PTRACE_CONT",
2196 target_pid_to_str (lp->ptid));
2199 gdb_assert (lp->resumed);
2201 /* Discard the event. */
2211 /* Alternate between checking cloned and uncloned processes. */
2212 options ^= __WCLONE;
2214 /* And suspend every time we have checked both. */
2215 if (options & __WCLONE)
2216 sigsuspend (&suspend_mask);
2219 /* We shouldn't end up here unless we want to try again. */
2220 gdb_assert (status == 0);
2223 clear_sigio_trap ();
2224 clear_sigint_trap ();
2228 /* Don't report signals that GDB isn't interested in, such as
2229 signals that are neither printed nor stopped upon. Stopping all
2230 threads can be a bit time-consuming so if we want decent
2231 performance with heavily multi-threaded programs, especially when
2232 they're using a high frequency timer, we'd better avoid it if we
2235 if (WIFSTOPPED (status))
2237 int signo = target_signal_from_host (WSTOPSIG (status));
2239 /* If we get a signal while single-stepping, we may need special
2240 care, e.g. to skip the signal handler. Defer to common code. */
2242 && signal_stop_state (signo) == 0
2243 && signal_print_state (signo) == 0
2244 && signal_pass_state (signo) == 1)
2246 /* FIMXE: kettenis/2001-06-06: Should we resume all threads
2247 here? It is not clear we should. GDB may not expect
2248 other threads to run. On the other hand, not resuming
2249 newly attached threads may cause an unwanted delay in
2250 getting them running. */
2251 registers_changed ();
2252 linux_ops->to_resume (pid_to_ptid (GET_LWP (lp->ptid)),
2254 if (debug_linux_nat)
2255 fprintf_unfiltered (gdb_stdlog,
2256 "LLW: %s %s, %s (preempt 'handle')\n",
2258 "PTRACE_SINGLESTEP" : "PTRACE_CONT",
2259 target_pid_to_str (lp->ptid),
2260 signo ? strsignal (signo) : "0");
2266 if (signo == TARGET_SIGNAL_INT && signal_pass_state (signo) == 0)
2268 /* If ^C/BREAK is typed at the tty/console, SIGINT gets
2269 forwarded to the entire process group, that is, all LWP's
2270 will receive it. Since we only want to report it once,
2271 we try to flush it from all LWPs except this one. */
2272 sigaddset (&flush_mask, SIGINT);
2276 /* This LWP is stopped now. */
2279 if (debug_linux_nat)
2280 fprintf_unfiltered (gdb_stdlog, "LLW: Candidate event %s in %s.\n",
2281 status_to_str (status), target_pid_to_str (lp->ptid));
2283 /* Now stop all other LWP's ... */
2284 iterate_over_lwps (stop_callback, NULL);
2286 /* ... and wait until all of them have reported back that they're no
2288 iterate_over_lwps (stop_wait_callback, &flush_mask);
2289 iterate_over_lwps (flush_callback, &flush_mask);
2291 /* If we're not waiting for a specific LWP, choose an event LWP from
2292 among those that have had events. Giving equal priority to all
2293 LWPs that have had events helps prevent starvation. */
2295 select_event_lwp (&lp, &status);
2297 /* Now that we've selected our final event LWP, cancel any
2298 breakpoints in other LWPs that have hit a GDB breakpoint. See
2299 the comment in cancel_breakpoints_callback to find out why. */
2300 iterate_over_lwps (cancel_breakpoints_callback, lp);
2302 if (WIFSTOPPED (status) && WSTOPSIG (status) == SIGTRAP)
2304 trap_ptid = lp->ptid;
2305 if (debug_linux_nat)
2306 fprintf_unfiltered (gdb_stdlog,
2307 "LLW: trap_ptid is %s.\n",
2308 target_pid_to_str (trap_ptid));
2311 trap_ptid = null_ptid;
2313 if (lp->waitstatus.kind != TARGET_WAITKIND_IGNORE)
2315 *ourstatus = lp->waitstatus;
2316 lp->waitstatus.kind = TARGET_WAITKIND_IGNORE;
2319 store_waitstatus (ourstatus, status);
2325 kill_callback (struct lwp_info *lp, void *data)
2328 ptrace (PTRACE_KILL, GET_LWP (lp->ptid), 0, 0);
2329 if (debug_linux_nat)
2330 fprintf_unfiltered (gdb_stdlog,
2331 "KC: PTRACE_KILL %s, 0, 0 (%s)\n",
2332 target_pid_to_str (lp->ptid),
2333 errno ? safe_strerror (errno) : "OK");
2339 kill_wait_callback (struct lwp_info *lp, void *data)
2343 /* We must make sure that there are no pending events (delayed
2344 SIGSTOPs, pending SIGTRAPs, etc.) to make sure the current
2345 program doesn't interfere with any following debugging session. */
2347 /* For cloned processes we must check both with __WCLONE and
2348 without, since the exit status of a cloned process isn't reported
2354 pid = my_waitpid (GET_LWP (lp->ptid), NULL, __WCLONE);
2355 if (pid != (pid_t) -1 && debug_linux_nat)
2357 fprintf_unfiltered (gdb_stdlog,
2358 "KWC: wait %s received unknown.\n",
2359 target_pid_to_str (lp->ptid));
2362 while (pid == GET_LWP (lp->ptid));
2364 gdb_assert (pid == -1 && errno == ECHILD);
2369 pid = my_waitpid (GET_LWP (lp->ptid), NULL, 0);
2370 if (pid != (pid_t) -1 && debug_linux_nat)
2372 fprintf_unfiltered (gdb_stdlog,
2373 "KWC: wait %s received unk.\n",
2374 target_pid_to_str (lp->ptid));
2377 while (pid == GET_LWP (lp->ptid));
2379 gdb_assert (pid == -1 && errno == ECHILD);
2384 linux_nat_kill (void)
2386 struct target_waitstatus last;
2390 /* If we're stopped while forking and we haven't followed yet,
2391 kill the other task. We need to do this first because the
2392 parent will be sleeping if this is a vfork. */
2394 get_last_target_status (&last_ptid, &last);
2396 if (last.kind == TARGET_WAITKIND_FORKED
2397 || last.kind == TARGET_WAITKIND_VFORKED)
2399 ptrace (PT_KILL, last.value.related_pid, 0, 0);
2403 if (forks_exist_p ())
2404 linux_fork_killall ();
2407 /* Kill all LWP's ... */
2408 iterate_over_lwps (kill_callback, NULL);
2410 /* ... and wait until we've flushed all events. */
2411 iterate_over_lwps (kill_wait_callback, NULL);
2414 target_mourn_inferior ();
2418 linux_nat_mourn_inferior (void)
2420 trap_ptid = null_ptid;
2422 /* Destroy LWP info; it's no longer valid. */
2425 /* Restore the original signal mask. */
2426 sigprocmask (SIG_SETMASK, &normal_mask, NULL);
2427 sigemptyset (&blocked_mask);
2429 if (! forks_exist_p ())
2430 /* Normal case, no other forks available. */
2431 linux_ops->to_mourn_inferior ();
2433 /* Multi-fork case. The current inferior_ptid has exited, but
2434 there are other viable forks to debug. Delete the exiting
2435 one and context-switch to the first available. */
2436 linux_fork_mourn_inferior ();
2440 linux_nat_xfer_partial (struct target_ops *ops, enum target_object object,
2441 const char *annex, gdb_byte *readbuf,
2442 const gdb_byte *writebuf,
2443 ULONGEST offset, LONGEST len)
2445 struct cleanup *old_chain = save_inferior_ptid ();
2448 if (is_lwp (inferior_ptid))
2449 inferior_ptid = pid_to_ptid (GET_LWP (inferior_ptid));
2451 xfer = linux_ops->to_xfer_partial (ops, object, annex, readbuf, writebuf,
2454 do_cleanups (old_chain);
2459 linux_nat_thread_alive (ptid_t ptid)
2461 gdb_assert (is_lwp (ptid));
2464 ptrace (PTRACE_PEEKUSER, GET_LWP (ptid), 0, 0);
2465 if (debug_linux_nat)
2466 fprintf_unfiltered (gdb_stdlog,
2467 "LLTA: PTRACE_PEEKUSER %s, 0, 0 (%s)\n",
2468 target_pid_to_str (ptid),
2469 errno ? safe_strerror (errno) : "OK");
2471 /* Not every Linux kernel implements PTRACE_PEEKUSER. But we can
2472 handle that case gracefully since ptrace will first do a lookup
2473 for the process based upon the passed-in pid. If that fails we
2474 will get either -ESRCH or -EPERM, otherwise the child exists and
2476 if (errno == ESRCH || errno == EPERM)
2483 linux_nat_pid_to_str (ptid_t ptid)
2485 static char buf[64];
2487 if (lwp_list && lwp_list->next && is_lwp (ptid))
2489 snprintf (buf, sizeof (buf), "LWP %ld", GET_LWP (ptid));
2493 return normal_pid_to_str (ptid);
2497 sigchld_handler (int signo)
2499 /* Do nothing. The only reason for this handler is that it allows
2500 us to use sigsuspend in linux_nat_wait above to wait for the
2501 arrival of a SIGCHLD. */
2504 /* Accepts an integer PID; Returns a string representing a file that
2505 can be opened to get the symbols for the child process. */
2508 linux_child_pid_to_exec_file (int pid)
2510 char *name1, *name2;
2512 name1 = xmalloc (MAXPATHLEN);
2513 name2 = xmalloc (MAXPATHLEN);
2514 make_cleanup (xfree, name1);
2515 make_cleanup (xfree, name2);
2516 memset (name2, 0, MAXPATHLEN);
2518 sprintf (name1, "/proc/%d/exe", pid);
2519 if (readlink (name1, name2, MAXPATHLEN) > 0)
2525 /* Service function for corefiles and info proc. */
2528 read_mapping (FILE *mapfile,
2533 char *device, long long *inode, char *filename)
2535 int ret = fscanf (mapfile, "%llx-%llx %s %llx %s %llx",
2536 addr, endaddr, permissions, offset, device, inode);
2539 if (ret > 0 && ret != EOF)
2541 /* Eat everything up to EOL for the filename. This will prevent
2542 weird filenames (such as one with embedded whitespace) from
2543 confusing this code. It also makes this code more robust in
2544 respect to annotations the kernel may add after the filename.
2546 Note the filename is used for informational purposes
2548 ret += fscanf (mapfile, "%[^\n]\n", filename);
2551 return (ret != 0 && ret != EOF);
2554 /* Fills the "to_find_memory_regions" target vector. Lists the memory
2555 regions in the inferior for a corefile. */
2558 linux_nat_find_memory_regions (int (*func) (CORE_ADDR,
2560 int, int, int, void *), void *obfd)
2562 long long pid = PIDGET (inferior_ptid);
2563 char mapsfilename[MAXPATHLEN];
2565 long long addr, endaddr, size, offset, inode;
2566 char permissions[8], device[8], filename[MAXPATHLEN];
2567 int read, write, exec;
2570 /* Compose the filename for the /proc memory map, and open it. */
2571 sprintf (mapsfilename, "/proc/%lld/maps", pid);
2572 if ((mapsfile = fopen (mapsfilename, "r")) == NULL)
2573 error (_("Could not open %s."), mapsfilename);
2576 fprintf_filtered (gdb_stdout,
2577 "Reading memory regions from %s\n", mapsfilename);
2579 /* Now iterate until end-of-file. */
2580 while (read_mapping (mapsfile, &addr, &endaddr, &permissions[0],
2581 &offset, &device[0], &inode, &filename[0]))
2583 size = endaddr - addr;
2585 /* Get the segment's permissions. */
2586 read = (strchr (permissions, 'r') != 0);
2587 write = (strchr (permissions, 'w') != 0);
2588 exec = (strchr (permissions, 'x') != 0);
2592 fprintf_filtered (gdb_stdout,
2593 "Save segment, %lld bytes at 0x%s (%c%c%c)",
2594 size, paddr_nz (addr),
2596 write ? 'w' : ' ', exec ? 'x' : ' ');
2598 fprintf_filtered (gdb_stdout, " for %s", filename);
2599 fprintf_filtered (gdb_stdout, "\n");
2602 /* Invoke the callback function to create the corefile
2604 func (addr, size, read, write, exec, obfd);
2610 /* Records the thread's register state for the corefile note
2614 linux_nat_do_thread_registers (bfd *obfd, ptid_t ptid,
2615 char *note_data, int *note_size)
2617 gdb_gregset_t gregs;
2618 gdb_fpregset_t fpregs;
2619 #ifdef FILL_FPXREGSET
2620 gdb_fpxregset_t fpxregs;
2622 unsigned long lwp = ptid_get_lwp (ptid);
2623 struct regcache *regcache = get_thread_regcache (ptid);
2624 struct gdbarch *gdbarch = get_regcache_arch (regcache);
2625 const struct regset *regset;
2627 struct cleanup *old_chain;
2629 old_chain = save_inferior_ptid ();
2630 inferior_ptid = ptid;
2631 target_fetch_registers (regcache, -1);
2632 do_cleanups (old_chain);
2634 core_regset_p = gdbarch_regset_from_core_section_p (gdbarch);
2636 && (regset = gdbarch_regset_from_core_section (gdbarch, ".reg",
2637 sizeof (gregs))) != NULL
2638 && regset->collect_regset != NULL)
2639 regset->collect_regset (regset, regcache, -1,
2640 &gregs, sizeof (gregs));
2642 fill_gregset (regcache, &gregs, -1);
2644 note_data = (char *) elfcore_write_prstatus (obfd,
2648 stop_signal, &gregs);
2651 && (regset = gdbarch_regset_from_core_section (gdbarch, ".reg2",
2652 sizeof (fpregs))) != NULL
2653 && regset->collect_regset != NULL)
2654 regset->collect_regset (regset, regcache, -1,
2655 &fpregs, sizeof (fpregs));
2657 fill_fpregset (regcache, &fpregs, -1);
2659 note_data = (char *) elfcore_write_prfpreg (obfd,
2662 &fpregs, sizeof (fpregs));
2664 #ifdef FILL_FPXREGSET
2666 && (regset = gdbarch_regset_from_core_section (gdbarch, ".reg-xfp",
2667 sizeof (fpxregs))) != NULL
2668 && regset->collect_regset != NULL)
2669 regset->collect_regset (regset, regcache, -1,
2670 &fpxregs, sizeof (fpxregs));
2672 fill_fpxregset (regcache, &fpxregs, -1);
2674 note_data = (char *) elfcore_write_prxfpreg (obfd,
2677 &fpxregs, sizeof (fpxregs));
2682 struct linux_nat_corefile_thread_data
2690 /* Called by gdbthread.c once per thread. Records the thread's
2691 register state for the corefile note section. */
2694 linux_nat_corefile_thread_callback (struct lwp_info *ti, void *data)
2696 struct linux_nat_corefile_thread_data *args = data;
2698 args->note_data = linux_nat_do_thread_registers (args->obfd,
2707 /* Records the register state for the corefile note section. */
2710 linux_nat_do_registers (bfd *obfd, ptid_t ptid,
2711 char *note_data, int *note_size)
2713 return linux_nat_do_thread_registers (obfd,
2714 ptid_build (ptid_get_pid (inferior_ptid),
2715 ptid_get_pid (inferior_ptid),
2717 note_data, note_size);
2720 /* Fills the "to_make_corefile_note" target vector. Builds the note
2721 section for a corefile, and returns it in a malloc buffer. */
2724 linux_nat_make_corefile_notes (bfd *obfd, int *note_size)
2726 struct linux_nat_corefile_thread_data thread_args;
2727 struct cleanup *old_chain;
2728 /* The variable size must be >= sizeof (prpsinfo_t.pr_fname). */
2729 char fname[16] = { '\0' };
2730 /* The variable size must be >= sizeof (prpsinfo_t.pr_psargs). */
2731 char psargs[80] = { '\0' };
2732 char *note_data = NULL;
2733 ptid_t current_ptid = inferior_ptid;
2737 if (get_exec_file (0))
2739 strncpy (fname, strrchr (get_exec_file (0), '/') + 1, sizeof (fname));
2740 strncpy (psargs, get_exec_file (0), sizeof (psargs));
2741 if (get_inferior_args ())
2744 char *psargs_end = psargs + sizeof (psargs);
2746 /* linux_elfcore_write_prpsinfo () handles zero unterminated
2748 string_end = memchr (psargs, 0, sizeof (psargs));
2749 if (string_end != NULL)
2751 *string_end++ = ' ';
2752 strncpy (string_end, get_inferior_args (),
2753 psargs_end - string_end);
2756 note_data = (char *) elfcore_write_prpsinfo (obfd,
2758 note_size, fname, psargs);
2761 /* Dump information for threads. */
2762 thread_args.obfd = obfd;
2763 thread_args.note_data = note_data;
2764 thread_args.note_size = note_size;
2765 thread_args.num_notes = 0;
2766 iterate_over_lwps (linux_nat_corefile_thread_callback, &thread_args);
2767 if (thread_args.num_notes == 0)
2769 /* iterate_over_threads didn't come up with any threads; just
2770 use inferior_ptid. */
2771 note_data = linux_nat_do_registers (obfd, inferior_ptid,
2772 note_data, note_size);
2776 note_data = thread_args.note_data;
2779 auxv_len = target_read_alloc (¤t_target, TARGET_OBJECT_AUXV,
2783 note_data = elfcore_write_note (obfd, note_data, note_size,
2784 "CORE", NT_AUXV, auxv, auxv_len);
2788 make_cleanup (xfree, note_data);
2792 /* Implement the "info proc" command. */
2795 linux_nat_info_proc_cmd (char *args, int from_tty)
2797 long long pid = PIDGET (inferior_ptid);
2800 char buffer[MAXPATHLEN];
2801 char fname1[MAXPATHLEN], fname2[MAXPATHLEN];
2814 /* Break up 'args' into an argv array. */
2815 if ((argv = buildargv (args)) == NULL)
2818 make_cleanup_freeargv (argv);
2820 while (argv != NULL && *argv != NULL)
2822 if (isdigit (argv[0][0]))
2824 pid = strtoul (argv[0], NULL, 10);
2826 else if (strncmp (argv[0], "mappings", strlen (argv[0])) == 0)
2830 else if (strcmp (argv[0], "status") == 0)
2834 else if (strcmp (argv[0], "stat") == 0)
2838 else if (strcmp (argv[0], "cmd") == 0)
2842 else if (strncmp (argv[0], "exe", strlen (argv[0])) == 0)
2846 else if (strcmp (argv[0], "cwd") == 0)
2850 else if (strncmp (argv[0], "all", strlen (argv[0])) == 0)
2856 /* [...] (future options here) */
2861 error (_("No current process: you must name one."));
2863 sprintf (fname1, "/proc/%lld", pid);
2864 if (stat (fname1, &dummy) != 0)
2865 error (_("No /proc directory: '%s'"), fname1);
2867 printf_filtered (_("process %lld\n"), pid);
2868 if (cmdline_f || all)
2870 sprintf (fname1, "/proc/%lld/cmdline", pid);
2871 if ((procfile = fopen (fname1, "r")) != NULL)
2873 fgets (buffer, sizeof (buffer), procfile);
2874 printf_filtered ("cmdline = '%s'\n", buffer);
2878 warning (_("unable to open /proc file '%s'"), fname1);
2882 sprintf (fname1, "/proc/%lld/cwd", pid);
2883 memset (fname2, 0, sizeof (fname2));
2884 if (readlink (fname1, fname2, sizeof (fname2)) > 0)
2885 printf_filtered ("cwd = '%s'\n", fname2);
2887 warning (_("unable to read link '%s'"), fname1);
2891 sprintf (fname1, "/proc/%lld/exe", pid);
2892 memset (fname2, 0, sizeof (fname2));
2893 if (readlink (fname1, fname2, sizeof (fname2)) > 0)
2894 printf_filtered ("exe = '%s'\n", fname2);
2896 warning (_("unable to read link '%s'"), fname1);
2898 if (mappings_f || all)
2900 sprintf (fname1, "/proc/%lld/maps", pid);
2901 if ((procfile = fopen (fname1, "r")) != NULL)
2903 long long addr, endaddr, size, offset, inode;
2904 char permissions[8], device[8], filename[MAXPATHLEN];
2906 printf_filtered (_("Mapped address spaces:\n\n"));
2907 if (gdbarch_addr_bit (current_gdbarch) == 32)
2909 printf_filtered ("\t%10s %10s %10s %10s %7s\n",
2912 " Size", " Offset", "objfile");
2916 printf_filtered (" %18s %18s %10s %10s %7s\n",
2919 " Size", " Offset", "objfile");
2922 while (read_mapping (procfile, &addr, &endaddr, &permissions[0],
2923 &offset, &device[0], &inode, &filename[0]))
2925 size = endaddr - addr;
2927 /* FIXME: carlton/2003-08-27: Maybe the printf_filtered
2928 calls here (and possibly above) should be abstracted
2929 out into their own functions? Andrew suggests using
2930 a generic local_address_string instead to print out
2931 the addresses; that makes sense to me, too. */
2933 if (gdbarch_addr_bit (current_gdbarch) == 32)
2935 printf_filtered ("\t%#10lx %#10lx %#10x %#10x %7s\n",
2936 (unsigned long) addr, /* FIXME: pr_addr */
2937 (unsigned long) endaddr,
2939 (unsigned int) offset,
2940 filename[0] ? filename : "");
2944 printf_filtered (" %#18lx %#18lx %#10x %#10x %7s\n",
2945 (unsigned long) addr, /* FIXME: pr_addr */
2946 (unsigned long) endaddr,
2948 (unsigned int) offset,
2949 filename[0] ? filename : "");
2956 warning (_("unable to open /proc file '%s'"), fname1);
2958 if (status_f || all)
2960 sprintf (fname1, "/proc/%lld/status", pid);
2961 if ((procfile = fopen (fname1, "r")) != NULL)
2963 while (fgets (buffer, sizeof (buffer), procfile) != NULL)
2964 puts_filtered (buffer);
2968 warning (_("unable to open /proc file '%s'"), fname1);
2972 sprintf (fname1, "/proc/%lld/stat", pid);
2973 if ((procfile = fopen (fname1, "r")) != NULL)
2979 if (fscanf (procfile, "%d ", &itmp) > 0)
2980 printf_filtered (_("Process: %d\n"), itmp);
2981 if (fscanf (procfile, "(%[^)]) ", &buffer[0]) > 0)
2982 printf_filtered (_("Exec file: %s\n"), buffer);
2983 if (fscanf (procfile, "%c ", &ctmp) > 0)
2984 printf_filtered (_("State: %c\n"), ctmp);
2985 if (fscanf (procfile, "%d ", &itmp) > 0)
2986 printf_filtered (_("Parent process: %d\n"), itmp);
2987 if (fscanf (procfile, "%d ", &itmp) > 0)
2988 printf_filtered (_("Process group: %d\n"), itmp);
2989 if (fscanf (procfile, "%d ", &itmp) > 0)
2990 printf_filtered (_("Session id: %d\n"), itmp);
2991 if (fscanf (procfile, "%d ", &itmp) > 0)
2992 printf_filtered (_("TTY: %d\n"), itmp);
2993 if (fscanf (procfile, "%d ", &itmp) > 0)
2994 printf_filtered (_("TTY owner process group: %d\n"), itmp);
2995 if (fscanf (procfile, "%lu ", <mp) > 0)
2996 printf_filtered (_("Flags: 0x%lx\n"), ltmp);
2997 if (fscanf (procfile, "%lu ", <mp) > 0)
2998 printf_filtered (_("Minor faults (no memory page): %lu\n"),
2999 (unsigned long) ltmp);
3000 if (fscanf (procfile, "%lu ", <mp) > 0)
3001 printf_filtered (_("Minor faults, children: %lu\n"),
3002 (unsigned long) ltmp);
3003 if (fscanf (procfile, "%lu ", <mp) > 0)
3004 printf_filtered (_("Major faults (memory page faults): %lu\n"),
3005 (unsigned long) ltmp);
3006 if (fscanf (procfile, "%lu ", <mp) > 0)
3007 printf_filtered (_("Major faults, children: %lu\n"),
3008 (unsigned long) ltmp);
3009 if (fscanf (procfile, "%ld ", <mp) > 0)
3010 printf_filtered (_("utime: %ld\n"), ltmp);
3011 if (fscanf (procfile, "%ld ", <mp) > 0)
3012 printf_filtered (_("stime: %ld\n"), ltmp);
3013 if (fscanf (procfile, "%ld ", <mp) > 0)
3014 printf_filtered (_("utime, children: %ld\n"), ltmp);
3015 if (fscanf (procfile, "%ld ", <mp) > 0)
3016 printf_filtered (_("stime, children: %ld\n"), ltmp);
3017 if (fscanf (procfile, "%ld ", <mp) > 0)
3018 printf_filtered (_("jiffies remaining in current time slice: %ld\n"),
3020 if (fscanf (procfile, "%ld ", <mp) > 0)
3021 printf_filtered (_("'nice' value: %ld\n"), ltmp);
3022 if (fscanf (procfile, "%lu ", <mp) > 0)
3023 printf_filtered (_("jiffies until next timeout: %lu\n"),
3024 (unsigned long) ltmp);
3025 if (fscanf (procfile, "%lu ", <mp) > 0)
3026 printf_filtered (_("jiffies until next SIGALRM: %lu\n"),
3027 (unsigned long) ltmp);
3028 if (fscanf (procfile, "%ld ", <mp) > 0)
3029 printf_filtered (_("start time (jiffies since system boot): %ld\n"),
3031 if (fscanf (procfile, "%lu ", <mp) > 0)
3032 printf_filtered (_("Virtual memory size: %lu\n"),
3033 (unsigned long) ltmp);
3034 if (fscanf (procfile, "%lu ", <mp) > 0)
3035 printf_filtered (_("Resident set size: %lu\n"), (unsigned long) ltmp);
3036 if (fscanf (procfile, "%lu ", <mp) > 0)
3037 printf_filtered (_("rlim: %lu\n"), (unsigned long) ltmp);
3038 if (fscanf (procfile, "%lu ", <mp) > 0)
3039 printf_filtered (_("Start of text: 0x%lx\n"), ltmp);
3040 if (fscanf (procfile, "%lu ", <mp) > 0)
3041 printf_filtered (_("End of text: 0x%lx\n"), ltmp);
3042 if (fscanf (procfile, "%lu ", <mp) > 0)
3043 printf_filtered (_("Start of stack: 0x%lx\n"), ltmp);
3044 #if 0 /* Don't know how architecture-dependent the rest is...
3045 Anyway the signal bitmap info is available from "status". */
3046 if (fscanf (procfile, "%lu ", <mp) > 0) /* FIXME arch? */
3047 printf_filtered (_("Kernel stack pointer: 0x%lx\n"), ltmp);
3048 if (fscanf (procfile, "%lu ", <mp) > 0) /* FIXME arch? */
3049 printf_filtered (_("Kernel instr pointer: 0x%lx\n"), ltmp);
3050 if (fscanf (procfile, "%ld ", <mp) > 0)
3051 printf_filtered (_("Pending signals bitmap: 0x%lx\n"), ltmp);
3052 if (fscanf (procfile, "%ld ", <mp) > 0)
3053 printf_filtered (_("Blocked signals bitmap: 0x%lx\n"), ltmp);
3054 if (fscanf (procfile, "%ld ", <mp) > 0)
3055 printf_filtered (_("Ignored signals bitmap: 0x%lx\n"), ltmp);
3056 if (fscanf (procfile, "%ld ", <mp) > 0)
3057 printf_filtered (_("Catched signals bitmap: 0x%lx\n"), ltmp);
3058 if (fscanf (procfile, "%lu ", <mp) > 0) /* FIXME arch? */
3059 printf_filtered (_("wchan (system call): 0x%lx\n"), ltmp);
3064 warning (_("unable to open /proc file '%s'"), fname1);
3068 /* Implement the to_xfer_partial interface for memory reads using the /proc
3069 filesystem. Because we can use a single read() call for /proc, this
3070 can be much more efficient than banging away at PTRACE_PEEKTEXT,
3071 but it doesn't support writes. */
3074 linux_proc_xfer_partial (struct target_ops *ops, enum target_object object,
3075 const char *annex, gdb_byte *readbuf,
3076 const gdb_byte *writebuf,
3077 ULONGEST offset, LONGEST len)
3083 if (object != TARGET_OBJECT_MEMORY || !readbuf)
3086 /* Don't bother for one word. */
3087 if (len < 3 * sizeof (long))
3090 /* We could keep this file open and cache it - possibly one per
3091 thread. That requires some juggling, but is even faster. */
3092 sprintf (filename, "/proc/%d/mem", PIDGET (inferior_ptid));
3093 fd = open (filename, O_RDONLY | O_LARGEFILE);
3097 /* If pread64 is available, use it. It's faster if the kernel
3098 supports it (only one syscall), and it's 64-bit safe even on
3099 32-bit platforms (for instance, SPARC debugging a SPARC64
3102 if (pread64 (fd, readbuf, len, offset) != len)
3104 if (lseek (fd, offset, SEEK_SET) == -1 || read (fd, readbuf, len) != len)
3114 /* Parse LINE as a signal set and add its set bits to SIGS. */
3117 add_line_to_sigset (const char *line, sigset_t *sigs)
3119 int len = strlen (line) - 1;
3123 if (line[len] != '\n')
3124 error (_("Could not parse signal set: %s"), line);
3132 if (*p >= '0' && *p <= '9')
3134 else if (*p >= 'a' && *p <= 'f')
3135 digit = *p - 'a' + 10;
3137 error (_("Could not parse signal set: %s"), line);
3142 sigaddset (sigs, signum + 1);
3144 sigaddset (sigs, signum + 2);
3146 sigaddset (sigs, signum + 3);
3148 sigaddset (sigs, signum + 4);
3154 /* Find process PID's pending signals from /proc/pid/status and set
3158 linux_proc_pending_signals (int pid, sigset_t *pending, sigset_t *blocked, sigset_t *ignored)
3161 char buffer[MAXPATHLEN], fname[MAXPATHLEN];
3164 sigemptyset (pending);
3165 sigemptyset (blocked);
3166 sigemptyset (ignored);
3167 sprintf (fname, "/proc/%d/status", pid);
3168 procfile = fopen (fname, "r");
3169 if (procfile == NULL)
3170 error (_("Could not open %s"), fname);
3172 while (fgets (buffer, MAXPATHLEN, procfile) != NULL)
3174 /* Normal queued signals are on the SigPnd line in the status
3175 file. However, 2.6 kernels also have a "shared" pending
3176 queue for delivering signals to a thread group, so check for
3179 Unfortunately some Red Hat kernels include the shared pending
3180 queue but not the ShdPnd status field. */
3182 if (strncmp (buffer, "SigPnd:\t", 8) == 0)
3183 add_line_to_sigset (buffer + 8, pending);
3184 else if (strncmp (buffer, "ShdPnd:\t", 8) == 0)
3185 add_line_to_sigset (buffer + 8, pending);
3186 else if (strncmp (buffer, "SigBlk:\t", 8) == 0)
3187 add_line_to_sigset (buffer + 8, blocked);
3188 else if (strncmp (buffer, "SigIgn:\t", 8) == 0)
3189 add_line_to_sigset (buffer + 8, ignored);
3196 linux_xfer_partial (struct target_ops *ops, enum target_object object,
3197 const char *annex, gdb_byte *readbuf,
3198 const gdb_byte *writebuf, ULONGEST offset, LONGEST len)
3202 if (object == TARGET_OBJECT_AUXV)
3203 return procfs_xfer_auxv (ops, object, annex, readbuf, writebuf,
3206 xfer = linux_proc_xfer_partial (ops, object, annex, readbuf, writebuf,
3211 return super_xfer_partial (ops, object, annex, readbuf, writebuf,
3215 /* Create a prototype generic GNU/Linux target. The client can override
3216 it with local methods. */
3219 linux_target_install_ops (struct target_ops *t)
3221 t->to_insert_fork_catchpoint = linux_child_insert_fork_catchpoint;
3222 t->to_insert_vfork_catchpoint = linux_child_insert_vfork_catchpoint;
3223 t->to_insert_exec_catchpoint = linux_child_insert_exec_catchpoint;
3224 t->to_pid_to_exec_file = linux_child_pid_to_exec_file;
3225 t->to_post_startup_inferior = linux_child_post_startup_inferior;
3226 t->to_post_attach = linux_child_post_attach;
3227 t->to_follow_fork = linux_child_follow_fork;
3228 t->to_find_memory_regions = linux_nat_find_memory_regions;
3229 t->to_make_corefile_notes = linux_nat_make_corefile_notes;
3231 super_xfer_partial = t->to_xfer_partial;
3232 t->to_xfer_partial = linux_xfer_partial;
3238 struct target_ops *t;
3240 t = inf_ptrace_target ();
3241 linux_target_install_ops (t);
3247 linux_trad_target (CORE_ADDR (*register_u_offset)(struct gdbarch *, int, int))
3249 struct target_ops *t;
3251 t = inf_ptrace_trad_target (register_u_offset);
3252 linux_target_install_ops (t);
3258 linux_nat_add_target (struct target_ops *t)
3260 /* Save the provided single-threaded target. We save this in a separate
3261 variable because another target we've inherited from (e.g. inf-ptrace)
3262 may have saved a pointer to T; we want to use it for the final
3263 process stratum target. */
3264 linux_ops_saved = *t;
3265 linux_ops = &linux_ops_saved;
3267 /* Override some methods for multithreading. */
3268 t->to_attach = linux_nat_attach;
3269 t->to_detach = linux_nat_detach;
3270 t->to_resume = linux_nat_resume;
3271 t->to_wait = linux_nat_wait;
3272 t->to_xfer_partial = linux_nat_xfer_partial;
3273 t->to_kill = linux_nat_kill;
3274 t->to_mourn_inferior = linux_nat_mourn_inferior;
3275 t->to_thread_alive = linux_nat_thread_alive;
3276 t->to_pid_to_str = linux_nat_pid_to_str;
3277 t->to_has_thread_control = tc_schedlock;
3279 /* We don't change the stratum; this target will sit at
3280 process_stratum and thread_db will set at thread_stratum. This
3281 is a little strange, since this is a multi-threaded-capable
3282 target, but we want to be on the stack below thread_db, and we
3283 also want to be used for single-threaded processes. */
3287 /* TODO: Eliminate this and have libthread_db use
3288 find_target_beneath. */
3292 /* Register a method to call whenever a new thread is attached. */
3294 linux_nat_set_new_thread (struct target_ops *t, void (*new_thread) (ptid_t))
3296 /* Save the pointer. We only support a single registered instance
3297 of the GNU/Linux native target, so we do not need to map this to
3299 linux_nat_new_thread = new_thread;
3302 /* Return the saved siginfo associated with PTID. */
3304 linux_nat_get_siginfo (ptid_t ptid)
3306 struct lwp_info *lp = find_lwp_pid (ptid);
3308 gdb_assert (lp != NULL);
3310 return &lp->siginfo;
3314 _initialize_linux_nat (void)
3316 struct sigaction action;
3318 add_info ("proc", linux_nat_info_proc_cmd, _("\
3319 Show /proc process information about any running process.\n\
3320 Specify any process id, or use the program being debugged by default.\n\
3321 Specify any of the following keywords for detailed info:\n\
3322 mappings -- list of mapped memory regions.\n\
3323 stat -- list a bunch of random process info.\n\
3324 status -- list a different bunch of random process info.\n\
3325 all -- list all available /proc info."));
3327 /* Save the original signal mask. */
3328 sigprocmask (SIG_SETMASK, NULL, &normal_mask);
3330 action.sa_handler = sigchld_handler;
3331 sigemptyset (&action.sa_mask);
3332 action.sa_flags = SA_RESTART;
3333 sigaction (SIGCHLD, &action, NULL);
3335 /* Make sure we don't block SIGCHLD during a sigsuspend. */
3336 sigprocmask (SIG_SETMASK, NULL, &suspend_mask);
3337 sigdelset (&suspend_mask, SIGCHLD);
3339 sigemptyset (&blocked_mask);
3341 add_setshow_zinteger_cmd ("lin-lwp", no_class, &debug_linux_nat, _("\
3342 Set debugging of GNU/Linux lwp module."), _("\
3343 Show debugging of GNU/Linux lwp module."), _("\
3344 Enables printf debugging output."),
3346 show_debug_linux_nat,
3347 &setdebuglist, &showdebuglist);
3351 /* FIXME: kettenis/2000-08-26: The stuff on this page is specific to
3352 the GNU/Linux Threads library and therefore doesn't really belong
3355 /* Read variable NAME in the target and return its value if found.
3356 Otherwise return zero. It is assumed that the type of the variable
3360 get_signo (const char *name)
3362 struct minimal_symbol *ms;
3365 ms = lookup_minimal_symbol (name, NULL, NULL);
3369 if (target_read_memory (SYMBOL_VALUE_ADDRESS (ms), (gdb_byte *) &signo,
3370 sizeof (signo)) != 0)
3376 /* Return the set of signals used by the threads library in *SET. */
3379 lin_thread_get_thread_signals (sigset_t *set)
3381 struct sigaction action;
3382 int restart, cancel;
3386 restart = get_signo ("__pthread_sig_restart");
3387 cancel = get_signo ("__pthread_sig_cancel");
3389 /* LinuxThreads normally uses the first two RT signals, but in some legacy
3390 cases may use SIGUSR1/SIGUSR2. NPTL always uses RT signals, but does
3391 not provide any way for the debugger to query the signal numbers -
3392 fortunately they don't change! */
3395 restart = __SIGRTMIN;
3398 cancel = __SIGRTMIN + 1;
3400 sigaddset (set, restart);
3401 sigaddset (set, cancel);
3403 /* The GNU/Linux Threads library makes terminating threads send a
3404 special "cancel" signal instead of SIGCHLD. Make sure we catch
3405 those (to prevent them from terminating GDB itself, which is
3406 likely to be their default action) and treat them the same way as
3409 action.sa_handler = sigchld_handler;
3410 sigemptyset (&action.sa_mask);
3411 action.sa_flags = SA_RESTART;
3412 sigaction (cancel, &action, NULL);
3414 /* We block the "cancel" signal throughout this code ... */
3415 sigaddset (&blocked_mask, cancel);
3416 sigprocmask (SIG_BLOCK, &blocked_mask, NULL);
3418 /* ... except during a sigsuspend. */
3419 sigdelset (&suspend_mask, cancel);