1 /* GNU/Linux native-dependent code common to multiple platforms.
3 Copyright (C) 2001, 2002, 2003, 2004, 2005, 2006, 2007
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 2 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, write to the Free Software
20 Foundation, Inc., 51 Franklin Street, Fifth Floor,
21 Boston, MA 02110-1301, USA. */
26 #include "gdb_string.h"
28 #include "gdb_assert.h"
29 #ifdef HAVE_TKILL_SYSCALL
31 #include <sys/syscall.h>
33 #include <sys/ptrace.h>
34 #include "linux-nat.h"
35 #include "linux-fork.h"
36 #include "gdbthread.h"
40 #include "inf-ptrace.h"
42 #include <sys/param.h> /* for MAXPATHLEN */
43 #include <sys/procfs.h> /* for elf_gregset etc. */
44 #include "elf-bfd.h" /* for elfcore_write_* */
45 #include "gregset.h" /* for gregset */
46 #include "gdbcore.h" /* for get_exec_file */
47 #include <ctype.h> /* for isdigit */
48 #include "gdbthread.h" /* for struct thread_info etc. */
49 #include "gdb_stat.h" /* for struct stat */
50 #include <fcntl.h> /* for O_RDONLY */
56 /* If the system headers did not provide the constants, hard-code the normal
58 #ifndef PTRACE_EVENT_FORK
60 #define PTRACE_SETOPTIONS 0x4200
61 #define PTRACE_GETEVENTMSG 0x4201
63 /* options set using PTRACE_SETOPTIONS */
64 #define PTRACE_O_TRACESYSGOOD 0x00000001
65 #define PTRACE_O_TRACEFORK 0x00000002
66 #define PTRACE_O_TRACEVFORK 0x00000004
67 #define PTRACE_O_TRACECLONE 0x00000008
68 #define PTRACE_O_TRACEEXEC 0x00000010
69 #define PTRACE_O_TRACEVFORKDONE 0x00000020
70 #define PTRACE_O_TRACEEXIT 0x00000040
72 /* Wait extended result codes for the above trace options. */
73 #define PTRACE_EVENT_FORK 1
74 #define PTRACE_EVENT_VFORK 2
75 #define PTRACE_EVENT_CLONE 3
76 #define PTRACE_EVENT_EXEC 4
77 #define PTRACE_EVENT_VFORK_DONE 5
78 #define PTRACE_EVENT_EXIT 6
80 #endif /* PTRACE_EVENT_FORK */
82 /* We can't always assume that this flag is available, but all systems
83 with the ptrace event handlers also have __WALL, so it's safe to use
86 #define __WALL 0x40000000 /* Wait for any child. */
89 /* The single-threaded native GNU/Linux target_ops. We save a pointer for
90 the use of the multi-threaded target. */
91 static struct target_ops *linux_ops;
92 static struct target_ops linux_ops_saved;
94 /* The saved to_xfer_partial method, inherited from inf-ptrace.c.
95 Called by our to_xfer_partial. */
96 static LONGEST (*super_xfer_partial) (struct target_ops *,
98 const char *, gdb_byte *,
102 static int debug_linux_nat;
104 show_debug_linux_nat (struct ui_file *file, int from_tty,
105 struct cmd_list_element *c, const char *value)
107 fprintf_filtered (file, _("Debugging of GNU/Linux lwp module is %s.\n"),
111 static int linux_parent_pid;
113 struct simple_pid_list
117 struct simple_pid_list *next;
119 struct simple_pid_list *stopped_pids;
121 /* This variable is a tri-state flag: -1 for unknown, 0 if PTRACE_O_TRACEFORK
122 can not be used, 1 if it can. */
124 static int linux_supports_tracefork_flag = -1;
126 /* If we have PTRACE_O_TRACEFORK, this flag indicates whether we also have
127 PTRACE_O_TRACEVFORKDONE. */
129 static int linux_supports_tracevforkdone_flag = -1;
132 /* Trivial list manipulation functions to keep track of a list of
133 new stopped processes. */
135 add_to_pid_list (struct simple_pid_list **listp, int pid, int status)
137 struct simple_pid_list *new_pid = xmalloc (sizeof (struct simple_pid_list));
139 new_pid->status = status;
140 new_pid->next = *listp;
145 pull_pid_from_list (struct simple_pid_list **listp, int pid, int *status)
147 struct simple_pid_list **p;
149 for (p = listp; *p != NULL; p = &(*p)->next)
150 if ((*p)->pid == pid)
152 struct simple_pid_list *next = (*p)->next;
153 *status = (*p)->status;
162 linux_record_stopped_pid (int pid, int status)
164 add_to_pid_list (&stopped_pids, pid, status);
168 /* A helper function for linux_test_for_tracefork, called after fork (). */
171 linux_tracefork_child (void)
175 ptrace (PTRACE_TRACEME, 0, 0, 0);
176 kill (getpid (), SIGSTOP);
181 /* Wrapper function for waitpid which handles EINTR. */
184 my_waitpid (int pid, int *status, int flags)
189 ret = waitpid (pid, status, flags);
191 while (ret == -1 && errno == EINTR);
196 /* Determine if PTRACE_O_TRACEFORK can be used to follow fork events.
198 First, we try to enable fork tracing on ORIGINAL_PID. If this fails,
199 we know that the feature is not available. This may change the tracing
200 options for ORIGINAL_PID, but we'll be setting them shortly anyway.
202 However, if it succeeds, we don't know for sure that the feature is
203 available; old versions of PTRACE_SETOPTIONS ignored unknown options. We
204 create a child process, attach to it, use PTRACE_SETOPTIONS to enable
205 fork tracing, and let it fork. If the process exits, we assume that we
206 can't use TRACEFORK; if we get the fork notification, and we can extract
207 the new child's PID, then we assume that we can. */
210 linux_test_for_tracefork (int original_pid)
212 int child_pid, ret, status;
215 linux_supports_tracefork_flag = 0;
216 linux_supports_tracevforkdone_flag = 0;
218 ret = ptrace (PTRACE_SETOPTIONS, original_pid, 0, PTRACE_O_TRACEFORK);
224 perror_with_name (("fork"));
227 linux_tracefork_child ();
229 ret = my_waitpid (child_pid, &status, 0);
231 perror_with_name (("waitpid"));
232 else if (ret != child_pid)
233 error (_("linux_test_for_tracefork: waitpid: unexpected result %d."), ret);
234 if (! WIFSTOPPED (status))
235 error (_("linux_test_for_tracefork: waitpid: unexpected status %d."), status);
237 ret = ptrace (PTRACE_SETOPTIONS, child_pid, 0, PTRACE_O_TRACEFORK);
240 ret = ptrace (PTRACE_KILL, child_pid, 0, 0);
243 warning (_("linux_test_for_tracefork: failed to kill child"));
247 ret = my_waitpid (child_pid, &status, 0);
248 if (ret != child_pid)
249 warning (_("linux_test_for_tracefork: failed to wait for killed child"));
250 else if (!WIFSIGNALED (status))
251 warning (_("linux_test_for_tracefork: unexpected wait status 0x%x from "
252 "killed child"), status);
257 /* Check whether PTRACE_O_TRACEVFORKDONE is available. */
258 ret = ptrace (PTRACE_SETOPTIONS, child_pid, 0,
259 PTRACE_O_TRACEFORK | PTRACE_O_TRACEVFORKDONE);
260 linux_supports_tracevforkdone_flag = (ret == 0);
262 ret = ptrace (PTRACE_CONT, child_pid, 0, 0);
264 warning (_("linux_test_for_tracefork: failed to resume child"));
266 ret = my_waitpid (child_pid, &status, 0);
268 if (ret == child_pid && WIFSTOPPED (status)
269 && status >> 16 == PTRACE_EVENT_FORK)
272 ret = ptrace (PTRACE_GETEVENTMSG, child_pid, 0, &second_pid);
273 if (ret == 0 && second_pid != 0)
277 linux_supports_tracefork_flag = 1;
278 my_waitpid (second_pid, &second_status, 0);
279 ret = ptrace (PTRACE_KILL, second_pid, 0, 0);
281 warning (_("linux_test_for_tracefork: failed to kill second child"));
282 my_waitpid (second_pid, &status, 0);
286 warning (_("linux_test_for_tracefork: unexpected result from waitpid "
287 "(%d, status 0x%x)"), ret, status);
289 ret = ptrace (PTRACE_KILL, child_pid, 0, 0);
291 warning (_("linux_test_for_tracefork: failed to kill child"));
292 my_waitpid (child_pid, &status, 0);
295 /* Return non-zero iff we have tracefork functionality available.
296 This function also sets linux_supports_tracefork_flag. */
299 linux_supports_tracefork (int pid)
301 if (linux_supports_tracefork_flag == -1)
302 linux_test_for_tracefork (pid);
303 return linux_supports_tracefork_flag;
307 linux_supports_tracevforkdone (int pid)
309 if (linux_supports_tracefork_flag == -1)
310 linux_test_for_tracefork (pid);
311 return linux_supports_tracevforkdone_flag;
316 linux_enable_event_reporting (ptid_t ptid)
318 int pid = ptid_get_lwp (ptid);
322 pid = ptid_get_pid (ptid);
324 if (! linux_supports_tracefork (pid))
327 options = PTRACE_O_TRACEFORK | PTRACE_O_TRACEVFORK | PTRACE_O_TRACEEXEC
328 | PTRACE_O_TRACECLONE;
329 if (linux_supports_tracevforkdone (pid))
330 options |= PTRACE_O_TRACEVFORKDONE;
332 /* Do not enable PTRACE_O_TRACEEXIT until GDB is more prepared to support
333 read-only process state. */
335 ptrace (PTRACE_SETOPTIONS, pid, 0, options);
339 linux_child_post_attach (int pid)
341 linux_enable_event_reporting (pid_to_ptid (pid));
342 check_for_thread_db ();
346 linux_child_post_startup_inferior (ptid_t ptid)
348 linux_enable_event_reporting (ptid);
349 check_for_thread_db ();
353 linux_child_follow_fork (struct target_ops *ops, int follow_child)
356 struct target_waitstatus last_status;
358 int parent_pid, child_pid;
360 get_last_target_status (&last_ptid, &last_status);
361 has_vforked = (last_status.kind == TARGET_WAITKIND_VFORKED);
362 parent_pid = ptid_get_lwp (last_ptid);
364 parent_pid = ptid_get_pid (last_ptid);
365 child_pid = last_status.value.related_pid;
369 /* We're already attached to the parent, by default. */
371 /* Before detaching from the child, remove all breakpoints from
372 it. (This won't actually modify the breakpoint list, but will
373 physically remove the breakpoints from the child.) */
374 /* If we vforked this will remove the breakpoints from the parent
375 also, but they'll be reinserted below. */
376 detach_breakpoints (child_pid);
378 /* Detach new forked process? */
383 target_terminal_ours ();
384 fprintf_filtered (gdb_stdlog,
385 "Detaching after fork from child process %d.\n",
389 ptrace (PTRACE_DETACH, child_pid, 0, 0);
393 struct fork_info *fp;
394 /* Retain child fork in ptrace (stopped) state. */
395 fp = find_fork_pid (child_pid);
397 fp = add_fork (child_pid);
398 fork_save_infrun_state (fp, 0);
403 gdb_assert (linux_supports_tracefork_flag >= 0);
404 if (linux_supports_tracevforkdone (0))
408 ptrace (PTRACE_CONT, parent_pid, 0, 0);
409 my_waitpid (parent_pid, &status, __WALL);
410 if ((status >> 16) != PTRACE_EVENT_VFORK_DONE)
411 warning (_("Unexpected waitpid result %06x when waiting for "
412 "vfork-done"), status);
416 /* We can't insert breakpoints until the child has
417 finished with the shared memory region. We need to
418 wait until that happens. Ideal would be to just
420 - ptrace (PTRACE_SYSCALL, parent_pid, 0, 0);
421 - waitpid (parent_pid, &status, __WALL);
422 However, most architectures can't handle a syscall
423 being traced on the way out if it wasn't traced on
426 We might also think to loop, continuing the child
427 until it exits or gets a SIGTRAP. One problem is
428 that the child might call ptrace with PTRACE_TRACEME.
430 There's no simple and reliable way to figure out when
431 the vforked child will be done with its copy of the
432 shared memory. We could step it out of the syscall,
433 two instructions, let it go, and then single-step the
434 parent once. When we have hardware single-step, this
435 would work; with software single-step it could still
436 be made to work but we'd have to be able to insert
437 single-step breakpoints in the child, and we'd have
438 to insert -just- the single-step breakpoint in the
439 parent. Very awkward.
441 In the end, the best we can do is to make sure it
442 runs for a little while. Hopefully it will be out of
443 range of any breakpoints we reinsert. Usually this
444 is only the single-step breakpoint at vfork's return
450 /* Since we vforked, breakpoints were removed in the parent
451 too. Put them back. */
452 reattach_breakpoints (parent_pid);
457 char child_pid_spelling[40];
459 /* Needed to keep the breakpoint lists in sync. */
461 detach_breakpoints (child_pid);
463 /* Before detaching from the parent, remove all breakpoints from it. */
464 remove_breakpoints ();
468 target_terminal_ours ();
469 fprintf_filtered (gdb_stdlog,
470 "Attaching after fork to child process %d.\n",
474 /* If we're vforking, we may want to hold on to the parent until
475 the child exits or execs. At exec time we can remove the old
476 breakpoints from the parent and detach it; at exit time we
477 could do the same (or even, sneakily, resume debugging it - the
478 child's exec has failed, or something similar).
480 This doesn't clean up "properly", because we can't call
481 target_detach, but that's OK; if the current target is "child",
482 then it doesn't need any further cleanups, and lin_lwp will
483 generally not encounter vfork (vfork is defined to fork
486 The holding part is very easy if we have VFORKDONE events;
487 but keeping track of both processes is beyond GDB at the
488 moment. So we don't expose the parent to the rest of GDB.
489 Instead we quietly hold onto it until such time as we can
493 linux_parent_pid = parent_pid;
494 else if (!detach_fork)
496 struct fork_info *fp;
497 /* Retain parent fork in ptrace (stopped) state. */
498 fp = find_fork_pid (parent_pid);
500 fp = add_fork (parent_pid);
501 fork_save_infrun_state (fp, 0);
505 target_detach (NULL, 0);
508 inferior_ptid = pid_to_ptid (child_pid);
510 /* Reinstall ourselves, since we might have been removed in
511 target_detach (which does other necessary cleanup). */
515 /* Reset breakpoints in the child as appropriate. */
516 follow_inferior_reset_breakpoints ();
524 linux_child_insert_fork_catchpoint (int pid)
526 if (! linux_supports_tracefork (pid))
527 error (_("Your system does not support fork catchpoints."));
531 linux_child_insert_vfork_catchpoint (int pid)
533 if (!linux_supports_tracefork (pid))
534 error (_("Your system does not support vfork catchpoints."));
538 linux_child_insert_exec_catchpoint (int pid)
540 if (!linux_supports_tracefork (pid))
541 error (_("Your system does not support exec catchpoints."));
544 /* On GNU/Linux there are no real LWP's. The closest thing to LWP's
545 are processes sharing the same VM space. A multi-threaded process
546 is basically a group of such processes. However, such a grouping
547 is almost entirely a user-space issue; the kernel doesn't enforce
548 such a grouping at all (this might change in the future). In
549 general, we'll rely on the threads library (i.e. the GNU/Linux
550 Threads library) to provide such a grouping.
552 It is perfectly well possible to write a multi-threaded application
553 without the assistance of a threads library, by using the clone
554 system call directly. This module should be able to give some
555 rudimentary support for debugging such applications if developers
556 specify the CLONE_PTRACE flag in the clone system call, and are
557 using the Linux kernel 2.4 or above.
559 Note that there are some peculiarities in GNU/Linux that affect
562 - In general one should specify the __WCLONE flag to waitpid in
563 order to make it report events for any of the cloned processes
564 (and leave it out for the initial process). However, if a cloned
565 process has exited the exit status is only reported if the
566 __WCLONE flag is absent. Linux kernel 2.4 has a __WALL flag, but
567 we cannot use it since GDB must work on older systems too.
569 - When a traced, cloned process exits and is waited for by the
570 debugger, the kernel reassigns it to the original parent and
571 keeps it around as a "zombie". Somehow, the GNU/Linux Threads
572 library doesn't notice this, which leads to the "zombie problem":
573 When debugged a multi-threaded process that spawns a lot of
574 threads will run out of processes, even if the threads exit,
575 because the "zombies" stay around. */
577 /* List of known LWPs. */
578 static struct lwp_info *lwp_list;
580 /* Number of LWPs in the list. */
584 #define GET_LWP(ptid) ptid_get_lwp (ptid)
585 #define GET_PID(ptid) ptid_get_pid (ptid)
586 #define is_lwp(ptid) (GET_LWP (ptid) != 0)
587 #define BUILD_LWP(lwp, pid) ptid_build (pid, lwp, 0)
589 /* If the last reported event was a SIGTRAP, this variable is set to
590 the process id of the LWP/thread that got it. */
594 /* Since we cannot wait (in linux_nat_wait) for the initial process and
595 any cloned processes with a single call to waitpid, we have to use
596 the WNOHANG flag and call waitpid in a loop. To optimize
597 things a bit we use `sigsuspend' to wake us up when a process has
598 something to report (it will send us a SIGCHLD if it has). To make
599 this work we have to juggle with the signal mask. We save the
600 original signal mask such that we can restore it before creating a
601 new process in order to avoid blocking certain signals in the
602 inferior. We then block SIGCHLD during the waitpid/sigsuspend
605 /* Original signal mask. */
606 static sigset_t normal_mask;
608 /* Signal mask for use with sigsuspend in linux_nat_wait, initialized in
609 _initialize_linux_nat. */
610 static sigset_t suspend_mask;
612 /* Signals to block to make that sigsuspend work. */
613 static sigset_t blocked_mask;
616 /* Prototypes for local functions. */
617 static int stop_wait_callback (struct lwp_info *lp, void *data);
618 static int linux_nat_thread_alive (ptid_t ptid);
619 static char *linux_child_pid_to_exec_file (int pid);
621 /* Convert wait status STATUS to a string. Used for printing debug
625 status_to_str (int status)
629 if (WIFSTOPPED (status))
630 snprintf (buf, sizeof (buf), "%s (stopped)",
631 strsignal (WSTOPSIG (status)));
632 else if (WIFSIGNALED (status))
633 snprintf (buf, sizeof (buf), "%s (terminated)",
634 strsignal (WSTOPSIG (status)));
636 snprintf (buf, sizeof (buf), "%d (exited)", WEXITSTATUS (status));
641 /* Initialize the list of LWPs. Note that this module, contrary to
642 what GDB's generic threads layer does for its thread list,
643 re-initializes the LWP lists whenever we mourn or detach (which
644 doesn't involve mourning) the inferior. */
649 struct lwp_info *lp, *lpnext;
651 for (lp = lwp_list; lp; lp = lpnext)
661 /* Add the LWP specified by PID to the list. Return a pointer to the
662 structure describing the new LWP. */
664 static struct lwp_info *
665 add_lwp (ptid_t ptid)
669 gdb_assert (is_lwp (ptid));
671 lp = (struct lwp_info *) xmalloc (sizeof (struct lwp_info));
673 memset (lp, 0, sizeof (struct lwp_info));
675 lp->waitstatus.kind = TARGET_WAITKIND_IGNORE;
686 /* Remove the LWP specified by PID from the list. */
689 delete_lwp (ptid_t ptid)
691 struct lwp_info *lp, *lpprev;
695 for (lp = lwp_list; lp; lpprev = lp, lp = lp->next)
696 if (ptid_equal (lp->ptid, ptid))
705 lpprev->next = lp->next;
712 /* Return a pointer to the structure describing the LWP corresponding
713 to PID. If no corresponding LWP could be found, return NULL. */
715 static struct lwp_info *
716 find_lwp_pid (ptid_t ptid)
722 lwp = GET_LWP (ptid);
724 lwp = GET_PID (ptid);
726 for (lp = lwp_list; lp; lp = lp->next)
727 if (lwp == GET_LWP (lp->ptid))
733 /* Call CALLBACK with its second argument set to DATA for every LWP in
734 the list. If CALLBACK returns 1 for a particular LWP, return a
735 pointer to the structure describing that LWP immediately.
736 Otherwise return NULL. */
739 iterate_over_lwps (int (*callback) (struct lwp_info *, void *), void *data)
741 struct lwp_info *lp, *lpnext;
743 for (lp = lwp_list; lp; lp = lpnext)
746 if ((*callback) (lp, data))
753 /* Update our internal state when changing from one fork (checkpoint,
754 et cetera) to another indicated by NEW_PTID. We can only switch
755 single-threaded applications, so we only create one new LWP, and
756 the previous list is discarded. */
759 linux_nat_switch_fork (ptid_t new_ptid)
764 lp = add_lwp (new_ptid);
768 /* Record a PTID for later deletion. */
773 struct saved_ptids *next;
775 static struct saved_ptids *threads_to_delete;
778 record_dead_thread (ptid_t ptid)
780 struct saved_ptids *p = xmalloc (sizeof (struct saved_ptids));
782 p->next = threads_to_delete;
783 threads_to_delete = p;
786 /* Delete any dead threads which are not the current thread. */
791 struct saved_ptids **p = &threads_to_delete;
794 if (! ptid_equal ((*p)->ptid, inferior_ptid))
796 struct saved_ptids *tmp = *p;
797 delete_thread (tmp->ptid);
805 /* Callback for iterate_over_threads that finds a thread corresponding
809 find_thread_from_lwp (struct thread_info *thr, void *dummy)
811 ptid_t *ptid_p = dummy;
813 if (GET_LWP (thr->ptid) && GET_LWP (thr->ptid) == GET_LWP (*ptid_p))
819 /* Handle the exit of a single thread LP. */
822 exit_lwp (struct lwp_info *lp)
824 if (in_thread_list (lp->ptid))
826 /* Core GDB cannot deal with us deleting the current thread. */
827 if (!ptid_equal (lp->ptid, inferior_ptid))
828 delete_thread (lp->ptid);
830 record_dead_thread (lp->ptid);
831 printf_unfiltered (_("[%s exited]\n"),
832 target_pid_to_str (lp->ptid));
836 /* Even if LP->PTID is not in the global GDB thread list, the
837 LWP may be - with an additional thread ID. We don't need
838 to print anything in this case; thread_db is in use and
839 already took care of that. But it didn't delete the thread
840 in order to handle zombies correctly. */
842 struct thread_info *thr;
844 thr = iterate_over_threads (find_thread_from_lwp, &lp->ptid);
847 if (!ptid_equal (thr->ptid, inferior_ptid))
848 delete_thread (thr->ptid);
850 record_dead_thread (thr->ptid);
854 delete_lwp (lp->ptid);
857 /* Attach to the LWP specified by PID. If VERBOSE is non-zero, print
858 a message telling the user that a new LWP has been added to the
859 process. Return 0 if successful or -1 if the new LWP could not
863 lin_lwp_attach_lwp (ptid_t ptid, int verbose)
867 gdb_assert (is_lwp (ptid));
869 /* Make sure SIGCHLD is blocked. We don't want SIGCHLD events
870 to interrupt either the ptrace() or waitpid() calls below. */
871 if (!sigismember (&blocked_mask, SIGCHLD))
873 sigaddset (&blocked_mask, SIGCHLD);
874 sigprocmask (SIG_BLOCK, &blocked_mask, NULL);
877 lp = find_lwp_pid (ptid);
879 /* We assume that we're already attached to any LWP that has an id
880 equal to the overall process id, and to any LWP that is already
881 in our list of LWPs. If we're not seeing exit events from threads
882 and we've had PID wraparound since we last tried to stop all threads,
883 this assumption might be wrong; fortunately, this is very unlikely
885 if (GET_LWP (ptid) != GET_PID (ptid) && lp == NULL)
890 if (ptrace (PTRACE_ATTACH, GET_LWP (ptid), 0, 0) < 0)
892 /* If we fail to attach to the thread, issue a warning,
893 but continue. One way this can happen is if thread
894 creation is interrupted; as of Linux 2.6.19, a kernel
895 bug may place threads in the thread list and then fail
897 warning (_("Can't attach %s: %s"), target_pid_to_str (ptid),
898 safe_strerror (errno));
906 fprintf_unfiltered (gdb_stdlog,
907 "LLAL: PTRACE_ATTACH %s, 0, 0 (OK)\n",
908 target_pid_to_str (ptid));
910 pid = my_waitpid (GET_LWP (ptid), &status, 0);
911 if (pid == -1 && errno == ECHILD)
913 /* Try again with __WCLONE to check cloned processes. */
914 pid = my_waitpid (GET_LWP (ptid), &status, __WCLONE);
918 gdb_assert (pid == GET_LWP (ptid)
919 && WIFSTOPPED (status) && WSTOPSIG (status));
921 target_post_attach (pid);
927 fprintf_unfiltered (gdb_stdlog,
928 "LLAL: waitpid %s received %s\n",
929 target_pid_to_str (ptid),
930 status_to_str (status));
935 /* We assume that the LWP representing the original process is
936 already stopped. Mark it as stopped in the data structure
937 that the GNU/linux ptrace layer uses to keep track of
938 threads. Note that this won't have already been done since
939 the main thread will have, we assume, been stopped by an
940 attach from a different layer. */
947 printf_filtered (_("[New %s]\n"), target_pid_to_str (ptid));
953 linux_nat_attach (char *args, int from_tty)
959 /* FIXME: We should probably accept a list of process id's, and
960 attach all of them. */
961 linux_ops->to_attach (args, from_tty);
963 /* Add the initial process as the first LWP to the list. */
964 inferior_ptid = BUILD_LWP (GET_PID (inferior_ptid), GET_PID (inferior_ptid));
965 lp = add_lwp (inferior_ptid);
967 /* Make sure the initial process is stopped. The user-level threads
968 layer might want to poke around in the inferior, and that won't
969 work if things haven't stabilized yet. */
970 pid = my_waitpid (GET_PID (inferior_ptid), &status, 0);
971 if (pid == -1 && errno == ECHILD)
973 warning (_("%s is a cloned process"), target_pid_to_str (inferior_ptid));
975 /* Try again with __WCLONE to check cloned processes. */
976 pid = my_waitpid (GET_PID (inferior_ptid), &status, __WCLONE);
980 gdb_assert (pid == GET_PID (inferior_ptid)
981 && WIFSTOPPED (status) && WSTOPSIG (status) == SIGSTOP);
985 /* Fake the SIGSTOP that core GDB expects. */
986 lp->status = W_STOPCODE (SIGSTOP);
990 fprintf_unfiltered (gdb_stdlog,
991 "LLA: waitpid %ld, faking SIGSTOP\n", (long) pid);
996 detach_callback (struct lwp_info *lp, void *data)
998 gdb_assert (lp->status == 0 || WIFSTOPPED (lp->status));
1000 if (debug_linux_nat && lp->status)
1001 fprintf_unfiltered (gdb_stdlog, "DC: Pending %s for %s on detach.\n",
1002 strsignal (WSTOPSIG (lp->status)),
1003 target_pid_to_str (lp->ptid));
1005 while (lp->signalled && lp->stopped)
1008 if (ptrace (PTRACE_CONT, GET_LWP (lp->ptid), 0,
1009 WSTOPSIG (lp->status)) < 0)
1010 error (_("Can't continue %s: %s"), target_pid_to_str (lp->ptid),
1011 safe_strerror (errno));
1013 if (debug_linux_nat)
1014 fprintf_unfiltered (gdb_stdlog,
1015 "DC: PTRACE_CONTINUE (%s, 0, %s) (OK)\n",
1016 target_pid_to_str (lp->ptid),
1017 status_to_str (lp->status));
1022 /* FIXME drow/2003-08-26: There was a call to stop_wait_callback
1023 here. But since lp->signalled was cleared above,
1024 stop_wait_callback didn't do anything; the process was left
1025 running. Shouldn't we be waiting for it to stop?
1026 I've removed the call, since stop_wait_callback now does do
1027 something when called with lp->signalled == 0. */
1029 gdb_assert (lp->status == 0 || WIFSTOPPED (lp->status));
1032 /* We don't actually detach from the LWP that has an id equal to the
1033 overall process id just yet. */
1034 if (GET_LWP (lp->ptid) != GET_PID (lp->ptid))
1037 if (ptrace (PTRACE_DETACH, GET_LWP (lp->ptid), 0,
1038 WSTOPSIG (lp->status)) < 0)
1039 error (_("Can't detach %s: %s"), target_pid_to_str (lp->ptid),
1040 safe_strerror (errno));
1042 if (debug_linux_nat)
1043 fprintf_unfiltered (gdb_stdlog,
1044 "PTRACE_DETACH (%s, %s, 0) (OK)\n",
1045 target_pid_to_str (lp->ptid),
1046 strsignal (WSTOPSIG (lp->status)));
1048 delete_lwp (lp->ptid);
1055 linux_nat_detach (char *args, int from_tty)
1057 iterate_over_lwps (detach_callback, NULL);
1059 /* Only the initial process should be left right now. */
1060 gdb_assert (num_lwps == 1);
1062 trap_ptid = null_ptid;
1064 /* Destroy LWP info; it's no longer valid. */
1067 /* Restore the original signal mask. */
1068 sigprocmask (SIG_SETMASK, &normal_mask, NULL);
1069 sigemptyset (&blocked_mask);
1071 inferior_ptid = pid_to_ptid (GET_PID (inferior_ptid));
1072 linux_ops->to_detach (args, from_tty);
1078 resume_callback (struct lwp_info *lp, void *data)
1080 if (lp->stopped && lp->status == 0)
1082 struct thread_info *tp;
1084 linux_ops->to_resume (pid_to_ptid (GET_LWP (lp->ptid)),
1085 0, TARGET_SIGNAL_0);
1086 if (debug_linux_nat)
1087 fprintf_unfiltered (gdb_stdlog,
1088 "RC: PTRACE_CONT %s, 0, 0 (resume sibling)\n",
1089 target_pid_to_str (lp->ptid));
1098 resume_clear_callback (struct lwp_info *lp, void *data)
1105 resume_set_callback (struct lwp_info *lp, void *data)
1112 linux_nat_resume (ptid_t ptid, int step, enum target_signal signo)
1114 struct lwp_info *lp;
1117 if (debug_linux_nat)
1118 fprintf_unfiltered (gdb_stdlog,
1119 "LLR: Preparing to %s %s, %s, inferior_ptid %s\n",
1120 step ? "step" : "resume",
1121 target_pid_to_str (ptid),
1122 signo ? strsignal (signo) : "0",
1123 target_pid_to_str (inferior_ptid));
1127 /* A specific PTID means `step only this process id'. */
1128 resume_all = (PIDGET (ptid) == -1);
1131 iterate_over_lwps (resume_set_callback, NULL);
1133 iterate_over_lwps (resume_clear_callback, NULL);
1135 /* If PID is -1, it's the current inferior that should be
1136 handled specially. */
1137 if (PIDGET (ptid) == -1)
1138 ptid = inferior_ptid;
1140 lp = find_lwp_pid (ptid);
1143 ptid = pid_to_ptid (GET_LWP (lp->ptid));
1145 /* Remember if we're stepping. */
1148 /* Mark this LWP as resumed. */
1151 /* If we have a pending wait status for this thread, there is no
1152 point in resuming the process. But first make sure that
1153 linux_nat_wait won't preemptively handle the event - we
1154 should never take this short-circuit if we are going to
1155 leave LP running, since we have skipped resuming all the
1156 other threads. This bit of code needs to be synchronized
1157 with linux_nat_wait. */
1159 if (lp->status && WIFSTOPPED (lp->status))
1161 int saved_signo = target_signal_from_host (WSTOPSIG (lp->status));
1163 if (signal_stop_state (saved_signo) == 0
1164 && signal_print_state (saved_signo) == 0
1165 && signal_pass_state (saved_signo) == 1)
1167 if (debug_linux_nat)
1168 fprintf_unfiltered (gdb_stdlog,
1169 "LLR: Not short circuiting for ignored "
1170 "status 0x%x\n", lp->status);
1172 /* FIXME: What should we do if we are supposed to continue
1173 this thread with a signal? */
1174 gdb_assert (signo == TARGET_SIGNAL_0);
1175 signo = saved_signo;
1182 /* FIXME: What should we do if we are supposed to continue
1183 this thread with a signal? */
1184 gdb_assert (signo == TARGET_SIGNAL_0);
1186 if (debug_linux_nat)
1187 fprintf_unfiltered (gdb_stdlog,
1188 "LLR: Short circuiting for status 0x%x\n",
1194 /* Mark LWP as not stopped to prevent it from being continued by
1200 iterate_over_lwps (resume_callback, NULL);
1202 linux_ops->to_resume (ptid, step, signo);
1203 if (debug_linux_nat)
1204 fprintf_unfiltered (gdb_stdlog,
1205 "LLR: %s %s, %s (resume event thread)\n",
1206 step ? "PTRACE_SINGLESTEP" : "PTRACE_CONT",
1207 target_pid_to_str (ptid),
1208 signo ? strsignal (signo) : "0");
1211 /* Issue kill to specified lwp. */
1213 static int tkill_failed;
1216 kill_lwp (int lwpid, int signo)
1220 /* Use tkill, if possible, in case we are using nptl threads. If tkill
1221 fails, then we are not using nptl threads and we should be using kill. */
1223 #ifdef HAVE_TKILL_SYSCALL
1226 int ret = syscall (__NR_tkill, lwpid, signo);
1227 if (errno != ENOSYS)
1234 return kill (lwpid, signo);
1237 /* Handle a GNU/Linux extended wait response. If we see a clone
1238 event, we need to add the new LWP to our list (and not report the
1239 trap to higher layers). This function returns non-zero if the
1240 event should be ignored and we should wait again. If STOPPING is
1241 true, the new LWP remains stopped, otherwise it is continued. */
1244 linux_handle_extended_wait (struct lwp_info *lp, int status,
1247 int pid = GET_LWP (lp->ptid);
1248 struct target_waitstatus *ourstatus = &lp->waitstatus;
1249 struct lwp_info *new_lp = NULL;
1250 int event = status >> 16;
1252 if (event == PTRACE_EVENT_FORK || event == PTRACE_EVENT_VFORK
1253 || event == PTRACE_EVENT_CLONE)
1255 unsigned long new_pid;
1258 ptrace (PTRACE_GETEVENTMSG, pid, 0, &new_pid);
1260 /* If we haven't already seen the new PID stop, wait for it now. */
1261 if (! pull_pid_from_list (&stopped_pids, new_pid, &status))
1263 /* The new child has a pending SIGSTOP. We can't affect it until it
1264 hits the SIGSTOP, but we're already attached. */
1265 ret = my_waitpid (new_pid, &status,
1266 (event == PTRACE_EVENT_CLONE) ? __WCLONE : 0);
1268 perror_with_name (_("waiting for new child"));
1269 else if (ret != new_pid)
1270 internal_error (__FILE__, __LINE__,
1271 _("wait returned unexpected PID %d"), ret);
1272 else if (!WIFSTOPPED (status))
1273 internal_error (__FILE__, __LINE__,
1274 _("wait returned unexpected status 0x%x"), status);
1277 ourstatus->value.related_pid = new_pid;
1279 if (event == PTRACE_EVENT_FORK)
1280 ourstatus->kind = TARGET_WAITKIND_FORKED;
1281 else if (event == PTRACE_EVENT_VFORK)
1282 ourstatus->kind = TARGET_WAITKIND_VFORKED;
1285 ourstatus->kind = TARGET_WAITKIND_IGNORE;
1286 new_lp = add_lwp (BUILD_LWP (new_pid, GET_PID (inferior_ptid)));
1289 if (WSTOPSIG (status) != SIGSTOP)
1291 /* This can happen if someone starts sending signals to
1292 the new thread before it gets a chance to run, which
1293 have a lower number than SIGSTOP (e.g. SIGUSR1).
1294 This is an unlikely case, and harder to handle for
1295 fork / vfork than for clone, so we do not try - but
1296 we handle it for clone events here. We'll send
1297 the other signal on to the thread below. */
1299 new_lp->signalled = 1;
1305 new_lp->stopped = 1;
1308 new_lp->resumed = 1;
1309 ptrace (PTRACE_CONT, lp->waitstatus.value.related_pid, 0,
1310 status ? WSTOPSIG (status) : 0);
1313 if (debug_linux_nat)
1314 fprintf_unfiltered (gdb_stdlog,
1315 "LHEW: Got clone event from LWP %ld, resuming\n",
1316 GET_LWP (lp->ptid));
1317 ptrace (PTRACE_CONT, GET_LWP (lp->ptid), 0, 0);
1325 if (event == PTRACE_EVENT_EXEC)
1327 ourstatus->kind = TARGET_WAITKIND_EXECD;
1328 ourstatus->value.execd_pathname
1329 = xstrdup (linux_child_pid_to_exec_file (pid));
1331 if (linux_parent_pid)
1333 detach_breakpoints (linux_parent_pid);
1334 ptrace (PTRACE_DETACH, linux_parent_pid, 0, 0);
1336 linux_parent_pid = 0;
1342 internal_error (__FILE__, __LINE__,
1343 _("unknown ptrace event %d"), event);
1346 /* Wait for LP to stop. Returns the wait status, or 0 if the LWP has
1350 wait_lwp (struct lwp_info *lp)
1354 int thread_dead = 0;
1356 gdb_assert (!lp->stopped);
1357 gdb_assert (lp->status == 0);
1359 pid = my_waitpid (GET_LWP (lp->ptid), &status, 0);
1360 if (pid == -1 && errno == ECHILD)
1362 pid = my_waitpid (GET_LWP (lp->ptid), &status, __WCLONE);
1363 if (pid == -1 && errno == ECHILD)
1365 /* The thread has previously exited. We need to delete it
1366 now because, for some vendor 2.4 kernels with NPTL
1367 support backported, there won't be an exit event unless
1368 it is the main thread. 2.6 kernels will report an exit
1369 event for each thread that exits, as expected. */
1371 if (debug_linux_nat)
1372 fprintf_unfiltered (gdb_stdlog, "WL: %s vanished.\n",
1373 target_pid_to_str (lp->ptid));
1379 gdb_assert (pid == GET_LWP (lp->ptid));
1381 if (debug_linux_nat)
1383 fprintf_unfiltered (gdb_stdlog,
1384 "WL: waitpid %s received %s\n",
1385 target_pid_to_str (lp->ptid),
1386 status_to_str (status));
1390 /* Check if the thread has exited. */
1391 if (WIFEXITED (status) || WIFSIGNALED (status))
1394 if (debug_linux_nat)
1395 fprintf_unfiltered (gdb_stdlog, "WL: %s exited.\n",
1396 target_pid_to_str (lp->ptid));
1405 gdb_assert (WIFSTOPPED (status));
1407 /* Handle GNU/Linux's extended waitstatus for trace events. */
1408 if (WIFSTOPPED (status) && WSTOPSIG (status) == SIGTRAP && status >> 16 != 0)
1410 if (debug_linux_nat)
1411 fprintf_unfiltered (gdb_stdlog,
1412 "WL: Handling extended status 0x%06x\n",
1414 if (linux_handle_extended_wait (lp, status, 1))
1415 return wait_lwp (lp);
1421 /* Send a SIGSTOP to LP. */
1424 stop_callback (struct lwp_info *lp, void *data)
1426 if (!lp->stopped && !lp->signalled)
1430 if (debug_linux_nat)
1432 fprintf_unfiltered (gdb_stdlog,
1433 "SC: kill %s **<SIGSTOP>**\n",
1434 target_pid_to_str (lp->ptid));
1437 ret = kill_lwp (GET_LWP (lp->ptid), SIGSTOP);
1438 if (debug_linux_nat)
1440 fprintf_unfiltered (gdb_stdlog,
1441 "SC: lwp kill %d %s\n",
1443 errno ? safe_strerror (errno) : "ERRNO-OK");
1447 gdb_assert (lp->status == 0);
1453 /* Wait until LP is stopped. If DATA is non-null it is interpreted as
1454 a pointer to a set of signals to be flushed immediately. */
1457 stop_wait_callback (struct lwp_info *lp, void *data)
1459 sigset_t *flush_mask = data;
1465 status = wait_lwp (lp);
1469 /* Ignore any signals in FLUSH_MASK. */
1470 if (flush_mask && sigismember (flush_mask, WSTOPSIG (status)))
1479 ptrace (PTRACE_CONT, GET_LWP (lp->ptid), 0, 0);
1480 if (debug_linux_nat)
1481 fprintf_unfiltered (gdb_stdlog,
1482 "PTRACE_CONT %s, 0, 0 (%s)\n",
1483 target_pid_to_str (lp->ptid),
1484 errno ? safe_strerror (errno) : "OK");
1486 return stop_wait_callback (lp, flush_mask);
1489 if (WSTOPSIG (status) != SIGSTOP)
1491 if (WSTOPSIG (status) == SIGTRAP)
1493 /* If a LWP other than the LWP that we're reporting an
1494 event for has hit a GDB breakpoint (as opposed to
1495 some random trap signal), then just arrange for it to
1496 hit it again later. We don't keep the SIGTRAP status
1497 and don't forward the SIGTRAP signal to the LWP. We
1498 will handle the current event, eventually we will
1499 resume all LWPs, and this one will get its breakpoint
1502 If we do not do this, then we run the risk that the
1503 user will delete or disable the breakpoint, but the
1504 thread will have already tripped on it. */
1506 /* Now resume this LWP and get the SIGSTOP event. */
1508 ptrace (PTRACE_CONT, GET_LWP (lp->ptid), 0, 0);
1509 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 fprintf_unfiltered (gdb_stdlog,
1517 "SWC: Candidate SIGTRAP event in %s\n",
1518 target_pid_to_str (lp->ptid));
1520 /* Hold the SIGTRAP for handling by linux_nat_wait. */
1521 stop_wait_callback (lp, data);
1522 /* If there's another event, throw it back into the queue. */
1525 if (debug_linux_nat)
1527 fprintf_unfiltered (gdb_stdlog,
1528 "SWC: kill %s, %s\n",
1529 target_pid_to_str (lp->ptid),
1530 status_to_str ((int) status));
1532 kill_lwp (GET_LWP (lp->ptid), WSTOPSIG (lp->status));
1534 /* Save the sigtrap event. */
1535 lp->status = status;
1540 /* The thread was stopped with a signal other than
1541 SIGSTOP, and didn't accidentally trip a breakpoint. */
1543 if (debug_linux_nat)
1545 fprintf_unfiltered (gdb_stdlog,
1546 "SWC: Pending event %s in %s\n",
1547 status_to_str ((int) status),
1548 target_pid_to_str (lp->ptid));
1550 /* Now resume this LWP and get the SIGSTOP event. */
1552 ptrace (PTRACE_CONT, GET_LWP (lp->ptid), 0, 0);
1553 if (debug_linux_nat)
1554 fprintf_unfiltered (gdb_stdlog,
1555 "SWC: PTRACE_CONT %s, 0, 0 (%s)\n",
1556 target_pid_to_str (lp->ptid),
1557 errno ? safe_strerror (errno) : "OK");
1559 /* Hold this event/waitstatus while we check to see if
1560 there are any more (we still want to get that SIGSTOP). */
1561 stop_wait_callback (lp, data);
1562 /* If the lp->status field is still empty, use it to hold
1563 this event. If not, then this event must be returned
1564 to the event queue of the LWP. */
1565 if (lp->status == 0)
1566 lp->status = status;
1569 if (debug_linux_nat)
1571 fprintf_unfiltered (gdb_stdlog,
1572 "SWC: kill %s, %s\n",
1573 target_pid_to_str (lp->ptid),
1574 status_to_str ((int) status));
1576 kill_lwp (GET_LWP (lp->ptid), WSTOPSIG (status));
1583 /* We caught the SIGSTOP that we intended to catch, so
1584 there's no SIGSTOP pending. */
1593 /* Check whether PID has any pending signals in FLUSH_MASK. If so set
1594 the appropriate bits in PENDING, and return 1 - otherwise return 0. */
1597 linux_nat_has_pending (int pid, sigset_t *pending, sigset_t *flush_mask)
1599 sigset_t blocked, ignored;
1602 linux_proc_pending_signals (pid, pending, &blocked, &ignored);
1607 for (i = 1; i < NSIG; i++)
1608 if (sigismember (pending, i))
1609 if (!sigismember (flush_mask, i)
1610 || sigismember (&blocked, i)
1611 || sigismember (&ignored, i))
1612 sigdelset (pending, i);
1614 if (sigisemptyset (pending))
1620 /* DATA is interpreted as a mask of signals to flush. If LP has
1621 signals pending, and they are all in the flush mask, then arrange
1622 to flush them. LP should be stopped, as should all other threads
1623 it might share a signal queue with. */
1626 flush_callback (struct lwp_info *lp, void *data)
1628 sigset_t *flush_mask = data;
1629 sigset_t pending, intersection, blocked, ignored;
1632 /* Normally, when an LWP exits, it is removed from the LWP list. The
1633 last LWP isn't removed till later, however. So if there is only
1634 one LWP on the list, make sure it's alive. */
1635 if (lwp_list == lp && lp->next == NULL)
1636 if (!linux_nat_thread_alive (lp->ptid))
1639 /* Just because the LWP is stopped doesn't mean that new signals
1640 can't arrive from outside, so this function must be careful of
1641 race conditions. However, because all threads are stopped, we
1642 can assume that the pending mask will not shrink unless we resume
1643 the LWP, and that it will then get another signal. We can't
1644 control which one, however. */
1648 if (debug_linux_nat)
1649 printf_unfiltered (_("FC: LP has pending status %06x\n"), lp->status);
1650 if (WIFSTOPPED (lp->status) && sigismember (flush_mask, WSTOPSIG (lp->status)))
1654 /* While there is a pending signal we would like to flush, continue
1655 the inferior and collect another signal. But if there's already
1656 a saved status that we don't want to flush, we can't resume the
1657 inferior - if it stopped for some other reason we wouldn't have
1658 anywhere to save the new status. In that case, we must leave the
1659 signal unflushed (and possibly generate an extra SIGINT stop).
1660 That's much less bad than losing a signal. */
1661 while (lp->status == 0
1662 && linux_nat_has_pending (GET_LWP (lp->ptid), &pending, flush_mask))
1667 ret = ptrace (PTRACE_CONT, GET_LWP (lp->ptid), 0, 0);
1668 if (debug_linux_nat)
1669 fprintf_unfiltered (gdb_stderr,
1670 "FC: Sent PTRACE_CONT, ret %d %d\n", ret, errno);
1673 stop_wait_callback (lp, flush_mask);
1674 if (debug_linux_nat)
1675 fprintf_unfiltered (gdb_stderr,
1676 "FC: Wait finished; saved status is %d\n",
1683 /* Return non-zero if LP has a wait status pending. */
1686 status_callback (struct lwp_info *lp, void *data)
1688 /* Only report a pending wait status if we pretend that this has
1689 indeed been resumed. */
1690 return (lp->status != 0 && lp->resumed);
1693 /* Return non-zero if LP isn't stopped. */
1696 running_callback (struct lwp_info *lp, void *data)
1698 return (lp->stopped == 0 || (lp->status != 0 && lp->resumed));
1701 /* Count the LWP's that have had events. */
1704 count_events_callback (struct lwp_info *lp, void *data)
1708 gdb_assert (count != NULL);
1710 /* Count only LWPs that have a SIGTRAP event pending. */
1712 && WIFSTOPPED (lp->status) && WSTOPSIG (lp->status) == SIGTRAP)
1718 /* Select the LWP (if any) that is currently being single-stepped. */
1721 select_singlestep_lwp_callback (struct lwp_info *lp, void *data)
1723 if (lp->step && lp->status != 0)
1729 /* Select the Nth LWP that has had a SIGTRAP event. */
1732 select_event_lwp_callback (struct lwp_info *lp, void *data)
1734 int *selector = data;
1736 gdb_assert (selector != NULL);
1738 /* Select only LWPs that have a SIGTRAP event pending. */
1740 && WIFSTOPPED (lp->status) && WSTOPSIG (lp->status) == SIGTRAP)
1741 if ((*selector)-- == 0)
1748 cancel_breakpoints_callback (struct lwp_info *lp, void *data)
1750 struct lwp_info *event_lp = data;
1752 /* Leave the LWP that has been elected to receive a SIGTRAP alone. */
1756 /* If a LWP other than the LWP that we're reporting an event for has
1757 hit a GDB breakpoint (as opposed to some random trap signal),
1758 then just arrange for it to hit it again later. We don't keep
1759 the SIGTRAP status and don't forward the SIGTRAP signal to the
1760 LWP. We will handle the current event, eventually we will resume
1761 all LWPs, and this one will get its breakpoint trap again.
1763 If we do not do this, then we run the risk that the user will
1764 delete or disable the breakpoint, but the LWP will have already
1768 && WIFSTOPPED (lp->status) && WSTOPSIG (lp->status) == SIGTRAP
1769 && breakpoint_inserted_here_p (read_pc_pid (lp->ptid) -
1770 gdbarch_decr_pc_after_break
1773 if (debug_linux_nat)
1774 fprintf_unfiltered (gdb_stdlog,
1775 "CBC: Push back breakpoint for %s\n",
1776 target_pid_to_str (lp->ptid));
1778 /* Back up the PC if necessary. */
1779 if (gdbarch_decr_pc_after_break (current_gdbarch))
1780 write_pc_pid (read_pc_pid (lp->ptid) - gdbarch_decr_pc_after_break
1784 /* Throw away the SIGTRAP. */
1791 /* Select one LWP out of those that have events pending. */
1794 select_event_lwp (struct lwp_info **orig_lp, int *status)
1797 int random_selector;
1798 struct lwp_info *event_lp;
1800 /* Record the wait status for the original LWP. */
1801 (*orig_lp)->status = *status;
1803 /* Give preference to any LWP that is being single-stepped. */
1804 event_lp = iterate_over_lwps (select_singlestep_lwp_callback, NULL);
1805 if (event_lp != NULL)
1807 if (debug_linux_nat)
1808 fprintf_unfiltered (gdb_stdlog,
1809 "SEL: Select single-step %s\n",
1810 target_pid_to_str (event_lp->ptid));
1814 /* No single-stepping LWP. Select one at random, out of those
1815 which have had SIGTRAP events. */
1817 /* First see how many SIGTRAP events we have. */
1818 iterate_over_lwps (count_events_callback, &num_events);
1820 /* Now randomly pick a LWP out of those that have had a SIGTRAP. */
1821 random_selector = (int)
1822 ((num_events * (double) rand ()) / (RAND_MAX + 1.0));
1824 if (debug_linux_nat && num_events > 1)
1825 fprintf_unfiltered (gdb_stdlog,
1826 "SEL: Found %d SIGTRAP events, selecting #%d\n",
1827 num_events, random_selector);
1829 event_lp = iterate_over_lwps (select_event_lwp_callback,
1833 if (event_lp != NULL)
1835 /* Switch the event LWP. */
1836 *orig_lp = event_lp;
1837 *status = event_lp->status;
1840 /* Flush the wait status for the event LWP. */
1841 (*orig_lp)->status = 0;
1844 /* Return non-zero if LP has been resumed. */
1847 resumed_callback (struct lwp_info *lp, void *data)
1852 /* Stop an active thread, verify it still exists, then resume it. */
1855 stop_and_resume_callback (struct lwp_info *lp, void *data)
1857 struct lwp_info *ptr;
1859 if (!lp->stopped && !lp->signalled)
1861 stop_callback (lp, NULL);
1862 stop_wait_callback (lp, NULL);
1863 /* Resume if the lwp still exists. */
1864 for (ptr = lwp_list; ptr; ptr = ptr->next)
1867 resume_callback (lp, NULL);
1868 resume_set_callback (lp, NULL);
1875 linux_nat_wait (ptid_t ptid, struct target_waitstatus *ourstatus)
1877 struct lwp_info *lp = NULL;
1880 pid_t pid = PIDGET (ptid);
1881 sigset_t flush_mask;
1883 /* The first time we get here after starting a new inferior, we may
1884 not have added it to the LWP list yet - this is the earliest
1885 moment at which we know its PID. */
1888 gdb_assert (!is_lwp (inferior_ptid));
1890 inferior_ptid = BUILD_LWP (GET_PID (inferior_ptid),
1891 GET_PID (inferior_ptid));
1892 lp = add_lwp (inferior_ptid);
1896 sigemptyset (&flush_mask);
1898 /* Make sure SIGCHLD is blocked. */
1899 if (!sigismember (&blocked_mask, SIGCHLD))
1901 sigaddset (&blocked_mask, SIGCHLD);
1902 sigprocmask (SIG_BLOCK, &blocked_mask, NULL);
1907 /* Make sure there is at least one LWP that has been resumed. */
1908 gdb_assert (iterate_over_lwps (resumed_callback, NULL));
1910 /* First check if there is a LWP with a wait status pending. */
1913 /* Any LWP that's been resumed will do. */
1914 lp = iterate_over_lwps (status_callback, NULL);
1917 status = lp->status;
1920 if (debug_linux_nat && status)
1921 fprintf_unfiltered (gdb_stdlog,
1922 "LLW: Using pending wait status %s for %s.\n",
1923 status_to_str (status),
1924 target_pid_to_str (lp->ptid));
1927 /* But if we don't fine one, we'll have to wait, and check both
1928 cloned and uncloned processes. We start with the cloned
1930 options = __WCLONE | WNOHANG;
1932 else if (is_lwp (ptid))
1934 if (debug_linux_nat)
1935 fprintf_unfiltered (gdb_stdlog,
1936 "LLW: Waiting for specific LWP %s.\n",
1937 target_pid_to_str (ptid));
1939 /* We have a specific LWP to check. */
1940 lp = find_lwp_pid (ptid);
1942 status = lp->status;
1945 if (debug_linux_nat && status)
1946 fprintf_unfiltered (gdb_stdlog,
1947 "LLW: Using pending wait status %s for %s.\n",
1948 status_to_str (status),
1949 target_pid_to_str (lp->ptid));
1951 /* If we have to wait, take into account whether PID is a cloned
1952 process or not. And we have to convert it to something that
1953 the layer beneath us can understand. */
1954 options = lp->cloned ? __WCLONE : 0;
1955 pid = GET_LWP (ptid);
1958 if (status && lp->signalled)
1960 /* A pending SIGSTOP may interfere with the normal stream of
1961 events. In a typical case where interference is a problem,
1962 we have a SIGSTOP signal pending for LWP A while
1963 single-stepping it, encounter an event in LWP B, and take the
1964 pending SIGSTOP while trying to stop LWP A. After processing
1965 the event in LWP B, LWP A is continued, and we'll never see
1966 the SIGTRAP associated with the last time we were
1967 single-stepping LWP A. */
1969 /* Resume the thread. It should halt immediately returning the
1971 registers_changed ();
1972 linux_ops->to_resume (pid_to_ptid (GET_LWP (lp->ptid)),
1973 lp->step, TARGET_SIGNAL_0);
1974 if (debug_linux_nat)
1975 fprintf_unfiltered (gdb_stdlog,
1976 "LLW: %s %s, 0, 0 (expect SIGSTOP)\n",
1977 lp->step ? "PTRACE_SINGLESTEP" : "PTRACE_CONT",
1978 target_pid_to_str (lp->ptid));
1980 gdb_assert (lp->resumed);
1982 /* This should catch the pending SIGSTOP. */
1983 stop_wait_callback (lp, NULL);
1986 set_sigint_trap (); /* Causes SIGINT to be passed on to the
1987 attached process. */
1994 lwpid = my_waitpid (pid, &status, options);
1997 gdb_assert (pid == -1 || lwpid == pid);
1999 if (debug_linux_nat)
2001 fprintf_unfiltered (gdb_stdlog,
2002 "LLW: waitpid %ld received %s\n",
2003 (long) lwpid, status_to_str (status));
2006 lp = find_lwp_pid (pid_to_ptid (lwpid));
2008 /* Check for stop events reported by a process we didn't
2009 already know about - anything not already in our LWP
2012 If we're expecting to receive stopped processes after
2013 fork, vfork, and clone events, then we'll just add the
2014 new one to our list and go back to waiting for the event
2015 to be reported - the stopped process might be returned
2016 from waitpid before or after the event is. */
2017 if (WIFSTOPPED (status) && !lp)
2019 linux_record_stopped_pid (lwpid, status);
2024 /* Make sure we don't report an event for the exit of an LWP not in
2025 our list, i.e. not part of the current process. This can happen
2026 if we detach from a program we original forked and then it
2028 if (!WIFSTOPPED (status) && !lp)
2034 /* NOTE drow/2003-06-17: This code seems to be meant for debugging
2035 CLONE_PTRACE processes which do not use the thread library -
2036 otherwise we wouldn't find the new LWP this way. That doesn't
2037 currently work, and the following code is currently unreachable
2038 due to the two blocks above. If it's fixed some day, this code
2039 should be broken out into a function so that we can also pick up
2040 LWPs from the new interface. */
2043 lp = add_lwp (BUILD_LWP (lwpid, GET_PID (inferior_ptid)));
2044 if (options & __WCLONE)
2047 gdb_assert (WIFSTOPPED (status)
2048 && WSTOPSIG (status) == SIGSTOP);
2051 if (!in_thread_list (inferior_ptid))
2053 inferior_ptid = BUILD_LWP (GET_PID (inferior_ptid),
2054 GET_PID (inferior_ptid));
2055 add_thread (inferior_ptid);
2058 add_thread (lp->ptid);
2059 printf_unfiltered (_("[New %s]\n"),
2060 target_pid_to_str (lp->ptid));
2063 /* Handle GNU/Linux's extended waitstatus for trace events. */
2064 if (WIFSTOPPED (status) && WSTOPSIG (status) == SIGTRAP && status >> 16 != 0)
2066 if (debug_linux_nat)
2067 fprintf_unfiltered (gdb_stdlog,
2068 "LLW: Handling extended status 0x%06x\n",
2070 if (linux_handle_extended_wait (lp, status, 0))
2077 /* Check if the thread has exited. */
2078 if ((WIFEXITED (status) || WIFSIGNALED (status)) && num_lwps > 1)
2080 /* If this is the main thread, we must stop all threads and
2081 verify if they are still alive. This is because in the nptl
2082 thread model, there is no signal issued for exiting LWPs
2083 other than the main thread. We only get the main thread
2084 exit signal once all child threads have already exited.
2085 If we stop all the threads and use the stop_wait_callback
2086 to check if they have exited we can determine whether this
2087 signal should be ignored or whether it means the end of the
2088 debugged application, regardless of which threading model
2090 if (GET_PID (lp->ptid) == GET_LWP (lp->ptid))
2093 iterate_over_lwps (stop_and_resume_callback, NULL);
2096 if (debug_linux_nat)
2097 fprintf_unfiltered (gdb_stdlog,
2098 "LLW: %s exited.\n",
2099 target_pid_to_str (lp->ptid));
2103 /* If there is at least one more LWP, then the exit signal
2104 was not the end of the debugged application and should be
2108 /* Make sure there is at least one thread running. */
2109 gdb_assert (iterate_over_lwps (running_callback, NULL));
2111 /* Discard the event. */
2117 /* Check if the current LWP has previously exited. In the nptl
2118 thread model, LWPs other than the main thread do not issue
2119 signals when they exit so we must check whenever the thread
2120 has stopped. A similar check is made in stop_wait_callback(). */
2121 if (num_lwps > 1 && !linux_nat_thread_alive (lp->ptid))
2123 if (debug_linux_nat)
2124 fprintf_unfiltered (gdb_stdlog,
2125 "LLW: %s exited.\n",
2126 target_pid_to_str (lp->ptid));
2130 /* Make sure there is at least one thread running. */
2131 gdb_assert (iterate_over_lwps (running_callback, NULL));
2133 /* Discard the event. */
2138 /* Make sure we don't report a SIGSTOP that we sent
2139 ourselves in an attempt to stop an LWP. */
2141 && WIFSTOPPED (status) && WSTOPSIG (status) == SIGSTOP)
2143 if (debug_linux_nat)
2144 fprintf_unfiltered (gdb_stdlog,
2145 "LLW: Delayed SIGSTOP caught for %s.\n",
2146 target_pid_to_str (lp->ptid));
2148 /* This is a delayed SIGSTOP. */
2151 registers_changed ();
2152 linux_ops->to_resume (pid_to_ptid (GET_LWP (lp->ptid)),
2153 lp->step, TARGET_SIGNAL_0);
2154 if (debug_linux_nat)
2155 fprintf_unfiltered (gdb_stdlog,
2156 "LLW: %s %s, 0, 0 (discard SIGSTOP)\n",
2158 "PTRACE_SINGLESTEP" : "PTRACE_CONT",
2159 target_pid_to_str (lp->ptid));
2162 gdb_assert (lp->resumed);
2164 /* Discard the event. */
2174 /* Alternate between checking cloned and uncloned processes. */
2175 options ^= __WCLONE;
2177 /* And suspend every time we have checked both. */
2178 if (options & __WCLONE)
2179 sigsuspend (&suspend_mask);
2182 /* We shouldn't end up here unless we want to try again. */
2183 gdb_assert (status == 0);
2186 clear_sigio_trap ();
2187 clear_sigint_trap ();
2191 /* Don't report signals that GDB isn't interested in, such as
2192 signals that are neither printed nor stopped upon. Stopping all
2193 threads can be a bit time-consuming so if we want decent
2194 performance with heavily multi-threaded programs, especially when
2195 they're using a high frequency timer, we'd better avoid it if we
2198 if (WIFSTOPPED (status))
2200 int signo = target_signal_from_host (WSTOPSIG (status));
2202 /* If we get a signal while single-stepping, we may need special
2203 care, e.g. to skip the signal handler. Defer to common code. */
2205 && signal_stop_state (signo) == 0
2206 && signal_print_state (signo) == 0
2207 && signal_pass_state (signo) == 1)
2209 /* FIMXE: kettenis/2001-06-06: Should we resume all threads
2210 here? It is not clear we should. GDB may not expect
2211 other threads to run. On the other hand, not resuming
2212 newly attached threads may cause an unwanted delay in
2213 getting them running. */
2214 registers_changed ();
2215 linux_ops->to_resume (pid_to_ptid (GET_LWP (lp->ptid)),
2217 if (debug_linux_nat)
2218 fprintf_unfiltered (gdb_stdlog,
2219 "LLW: %s %s, %s (preempt 'handle')\n",
2221 "PTRACE_SINGLESTEP" : "PTRACE_CONT",
2222 target_pid_to_str (lp->ptid),
2223 signo ? strsignal (signo) : "0");
2229 if (signo == TARGET_SIGNAL_INT && signal_pass_state (signo) == 0)
2231 /* If ^C/BREAK is typed at the tty/console, SIGINT gets
2232 forwarded to the entire process group, that is, all LWP's
2233 will receive it. Since we only want to report it once,
2234 we try to flush it from all LWPs except this one. */
2235 sigaddset (&flush_mask, SIGINT);
2239 /* This LWP is stopped now. */
2242 if (debug_linux_nat)
2243 fprintf_unfiltered (gdb_stdlog, "LLW: Candidate event %s in %s.\n",
2244 status_to_str (status), target_pid_to_str (lp->ptid));
2246 /* Now stop all other LWP's ... */
2247 iterate_over_lwps (stop_callback, NULL);
2249 /* ... and wait until all of them have reported back that they're no
2251 iterate_over_lwps (stop_wait_callback, &flush_mask);
2252 iterate_over_lwps (flush_callback, &flush_mask);
2254 /* If we're not waiting for a specific LWP, choose an event LWP from
2255 among those that have had events. Giving equal priority to all
2256 LWPs that have had events helps prevent starvation. */
2258 select_event_lwp (&lp, &status);
2260 /* Now that we've selected our final event LWP, cancel any
2261 breakpoints in other LWPs that have hit a GDB breakpoint. See
2262 the comment in cancel_breakpoints_callback to find out why. */
2263 iterate_over_lwps (cancel_breakpoints_callback, lp);
2265 if (WIFSTOPPED (status) && WSTOPSIG (status) == SIGTRAP)
2267 trap_ptid = lp->ptid;
2268 if (debug_linux_nat)
2269 fprintf_unfiltered (gdb_stdlog,
2270 "LLW: trap_ptid is %s.\n",
2271 target_pid_to_str (trap_ptid));
2274 trap_ptid = null_ptid;
2276 if (lp->waitstatus.kind != TARGET_WAITKIND_IGNORE)
2278 *ourstatus = lp->waitstatus;
2279 lp->waitstatus.kind = TARGET_WAITKIND_IGNORE;
2282 store_waitstatus (ourstatus, status);
2288 kill_callback (struct lwp_info *lp, void *data)
2291 ptrace (PTRACE_KILL, GET_LWP (lp->ptid), 0, 0);
2292 if (debug_linux_nat)
2293 fprintf_unfiltered (gdb_stdlog,
2294 "KC: PTRACE_KILL %s, 0, 0 (%s)\n",
2295 target_pid_to_str (lp->ptid),
2296 errno ? safe_strerror (errno) : "OK");
2302 kill_wait_callback (struct lwp_info *lp, void *data)
2306 /* We must make sure that there are no pending events (delayed
2307 SIGSTOPs, pending SIGTRAPs, etc.) to make sure the current
2308 program doesn't interfere with any following debugging session. */
2310 /* For cloned processes we must check both with __WCLONE and
2311 without, since the exit status of a cloned process isn't reported
2317 pid = my_waitpid (GET_LWP (lp->ptid), NULL, __WCLONE);
2318 if (pid != (pid_t) -1 && debug_linux_nat)
2320 fprintf_unfiltered (gdb_stdlog,
2321 "KWC: wait %s received unknown.\n",
2322 target_pid_to_str (lp->ptid));
2325 while (pid == GET_LWP (lp->ptid));
2327 gdb_assert (pid == -1 && errno == ECHILD);
2332 pid = my_waitpid (GET_LWP (lp->ptid), NULL, 0);
2333 if (pid != (pid_t) -1 && debug_linux_nat)
2335 fprintf_unfiltered (gdb_stdlog,
2336 "KWC: wait %s received unk.\n",
2337 target_pid_to_str (lp->ptid));
2340 while (pid == GET_LWP (lp->ptid));
2342 gdb_assert (pid == -1 && errno == ECHILD);
2347 linux_nat_kill (void)
2349 struct target_waitstatus last;
2353 /* If we're stopped while forking and we haven't followed yet,
2354 kill the other task. We need to do this first because the
2355 parent will be sleeping if this is a vfork. */
2357 get_last_target_status (&last_ptid, &last);
2359 if (last.kind == TARGET_WAITKIND_FORKED
2360 || last.kind == TARGET_WAITKIND_VFORKED)
2362 ptrace (PT_KILL, last.value.related_pid, 0, 0);
2366 if (forks_exist_p ())
2367 linux_fork_killall ();
2370 /* Kill all LWP's ... */
2371 iterate_over_lwps (kill_callback, NULL);
2373 /* ... and wait until we've flushed all events. */
2374 iterate_over_lwps (kill_wait_callback, NULL);
2377 target_mourn_inferior ();
2381 linux_nat_mourn_inferior (void)
2383 trap_ptid = null_ptid;
2385 /* Destroy LWP info; it's no longer valid. */
2388 /* Restore the original signal mask. */
2389 sigprocmask (SIG_SETMASK, &normal_mask, NULL);
2390 sigemptyset (&blocked_mask);
2392 if (! forks_exist_p ())
2393 /* Normal case, no other forks available. */
2394 linux_ops->to_mourn_inferior ();
2396 /* Multi-fork case. The current inferior_ptid has exited, but
2397 there are other viable forks to debug. Delete the exiting
2398 one and context-switch to the first available. */
2399 linux_fork_mourn_inferior ();
2403 linux_nat_xfer_partial (struct target_ops *ops, enum target_object object,
2404 const char *annex, gdb_byte *readbuf,
2405 const gdb_byte *writebuf,
2406 ULONGEST offset, LONGEST len)
2408 struct cleanup *old_chain = save_inferior_ptid ();
2411 if (is_lwp (inferior_ptid))
2412 inferior_ptid = pid_to_ptid (GET_LWP (inferior_ptid));
2414 xfer = linux_ops->to_xfer_partial (ops, object, annex, readbuf, writebuf,
2417 do_cleanups (old_chain);
2422 linux_nat_thread_alive (ptid_t ptid)
2424 gdb_assert (is_lwp (ptid));
2427 ptrace (PTRACE_PEEKUSER, GET_LWP (ptid), 0, 0);
2428 if (debug_linux_nat)
2429 fprintf_unfiltered (gdb_stdlog,
2430 "LLTA: PTRACE_PEEKUSER %s, 0, 0 (%s)\n",
2431 target_pid_to_str (ptid),
2432 errno ? safe_strerror (errno) : "OK");
2434 /* Not every Linux kernel implements PTRACE_PEEKUSER. But we can
2435 handle that case gracefully since ptrace will first do a lookup
2436 for the process based upon the passed-in pid. If that fails we
2437 will get either -ESRCH or -EPERM, otherwise the child exists and
2439 if (errno == ESRCH || errno == EPERM)
2446 linux_nat_pid_to_str (ptid_t ptid)
2448 static char buf[64];
2450 if (lwp_list && lwp_list->next && is_lwp (ptid))
2452 snprintf (buf, sizeof (buf), "LWP %ld", GET_LWP (ptid));
2456 return normal_pid_to_str (ptid);
2460 sigchld_handler (int signo)
2462 /* Do nothing. The only reason for this handler is that it allows
2463 us to use sigsuspend in linux_nat_wait above to wait for the
2464 arrival of a SIGCHLD. */
2467 /* Accepts an integer PID; Returns a string representing a file that
2468 can be opened to get the symbols for the child process. */
2471 linux_child_pid_to_exec_file (int pid)
2473 char *name1, *name2;
2475 name1 = xmalloc (MAXPATHLEN);
2476 name2 = xmalloc (MAXPATHLEN);
2477 make_cleanup (xfree, name1);
2478 make_cleanup (xfree, name2);
2479 memset (name2, 0, MAXPATHLEN);
2481 sprintf (name1, "/proc/%d/exe", pid);
2482 if (readlink (name1, name2, MAXPATHLEN) > 0)
2488 /* Service function for corefiles and info proc. */
2491 read_mapping (FILE *mapfile,
2496 char *device, long long *inode, char *filename)
2498 int ret = fscanf (mapfile, "%llx-%llx %s %llx %s %llx",
2499 addr, endaddr, permissions, offset, device, inode);
2502 if (ret > 0 && ret != EOF)
2504 /* Eat everything up to EOL for the filename. This will prevent
2505 weird filenames (such as one with embedded whitespace) from
2506 confusing this code. It also makes this code more robust in
2507 respect to annotations the kernel may add after the filename.
2509 Note the filename is used for informational purposes
2511 ret += fscanf (mapfile, "%[^\n]\n", filename);
2514 return (ret != 0 && ret != EOF);
2517 /* Fills the "to_find_memory_regions" target vector. Lists the memory
2518 regions in the inferior for a corefile. */
2521 linux_nat_find_memory_regions (int (*func) (CORE_ADDR,
2523 int, int, int, void *), void *obfd)
2525 long long pid = PIDGET (inferior_ptid);
2526 char mapsfilename[MAXPATHLEN];
2528 long long addr, endaddr, size, offset, inode;
2529 char permissions[8], device[8], filename[MAXPATHLEN];
2530 int read, write, exec;
2533 /* Compose the filename for the /proc memory map, and open it. */
2534 sprintf (mapsfilename, "/proc/%lld/maps", pid);
2535 if ((mapsfile = fopen (mapsfilename, "r")) == NULL)
2536 error (_("Could not open %s."), mapsfilename);
2539 fprintf_filtered (gdb_stdout,
2540 "Reading memory regions from %s\n", mapsfilename);
2542 /* Now iterate until end-of-file. */
2543 while (read_mapping (mapsfile, &addr, &endaddr, &permissions[0],
2544 &offset, &device[0], &inode, &filename[0]))
2546 size = endaddr - addr;
2548 /* Get the segment's permissions. */
2549 read = (strchr (permissions, 'r') != 0);
2550 write = (strchr (permissions, 'w') != 0);
2551 exec = (strchr (permissions, 'x') != 0);
2555 fprintf_filtered (gdb_stdout,
2556 "Save segment, %lld bytes at 0x%s (%c%c%c)",
2557 size, paddr_nz (addr),
2559 write ? 'w' : ' ', exec ? 'x' : ' ');
2561 fprintf_filtered (gdb_stdout, " for %s", filename);
2562 fprintf_filtered (gdb_stdout, "\n");
2565 /* Invoke the callback function to create the corefile
2567 func (addr, size, read, write, exec, obfd);
2573 /* Records the thread's register state for the corefile note
2577 linux_nat_do_thread_registers (bfd *obfd, ptid_t ptid,
2578 char *note_data, int *note_size)
2580 gdb_gregset_t gregs;
2581 gdb_fpregset_t fpregs;
2582 #ifdef FILL_FPXREGSET
2583 gdb_fpxregset_t fpxregs;
2585 unsigned long lwp = ptid_get_lwp (ptid);
2586 struct gdbarch *gdbarch = current_gdbarch;
2587 const struct regset *regset;
2590 core_regset_p = gdbarch_regset_from_core_section_p (gdbarch);
2592 && (regset = gdbarch_regset_from_core_section (gdbarch, ".reg",
2593 sizeof (gregs))) != NULL
2594 && regset->collect_regset != NULL)
2595 regset->collect_regset (regset, current_regcache, -1,
2596 &gregs, sizeof (gregs));
2598 fill_gregset (current_regcache, &gregs, -1);
2600 note_data = (char *) elfcore_write_prstatus (obfd,
2604 stop_signal, &gregs);
2607 && (regset = gdbarch_regset_from_core_section (gdbarch, ".reg2",
2608 sizeof (fpregs))) != NULL
2609 && regset->collect_regset != NULL)
2610 regset->collect_regset (regset, current_regcache, -1,
2611 &fpregs, sizeof (fpregs));
2613 fill_fpregset (current_regcache, &fpregs, -1);
2615 note_data = (char *) elfcore_write_prfpreg (obfd,
2618 &fpregs, sizeof (fpregs));
2620 #ifdef FILL_FPXREGSET
2622 && (regset = gdbarch_regset_from_core_section (gdbarch, ".reg-xfp",
2623 sizeof (fpxregs))) != NULL
2624 && regset->collect_regset != NULL)
2625 regset->collect_regset (regset, current_regcache, -1,
2626 &fpxregs, sizeof (fpxregs));
2628 fill_fpxregset (current_regcache, &fpxregs, -1);
2630 note_data = (char *) elfcore_write_prxfpreg (obfd,
2633 &fpxregs, sizeof (fpxregs));
2638 struct linux_nat_corefile_thread_data
2646 /* Called by gdbthread.c once per thread. Records the thread's
2647 register state for the corefile note section. */
2650 linux_nat_corefile_thread_callback (struct lwp_info *ti, void *data)
2652 struct linux_nat_corefile_thread_data *args = data;
2653 ptid_t saved_ptid = inferior_ptid;
2655 inferior_ptid = ti->ptid;
2656 registers_changed ();
2657 /* FIXME should not be necessary; fill_gregset should do it automatically. */
2658 target_fetch_registers (current_regcache, -1);
2659 args->note_data = linux_nat_do_thread_registers (args->obfd,
2664 inferior_ptid = saved_ptid;
2665 registers_changed ();
2666 /* FIXME should not be necessary; fill_gregset should do it automatically. */
2667 target_fetch_registers (current_regcache, -1);
2672 /* Records the register state for the corefile note section. */
2675 linux_nat_do_registers (bfd *obfd, ptid_t ptid,
2676 char *note_data, int *note_size)
2678 registers_changed ();
2679 /* FIXME should not be necessary; fill_gregset should do it automatically. */
2680 target_fetch_registers (current_regcache, -1);
2681 return linux_nat_do_thread_registers (obfd,
2682 ptid_build (ptid_get_pid (inferior_ptid),
2683 ptid_get_pid (inferior_ptid),
2685 note_data, note_size);
2689 /* Fills the "to_make_corefile_note" target vector. Builds the note
2690 section for a corefile, and returns it in a malloc buffer. */
2693 linux_nat_make_corefile_notes (bfd *obfd, int *note_size)
2695 struct linux_nat_corefile_thread_data thread_args;
2696 struct cleanup *old_chain;
2697 char fname[16] = { '\0' };
2698 char psargs[80] = { '\0' };
2699 char *note_data = NULL;
2700 ptid_t current_ptid = inferior_ptid;
2704 if (get_exec_file (0))
2706 strncpy (fname, strrchr (get_exec_file (0), '/') + 1, sizeof (fname));
2707 strncpy (psargs, get_exec_file (0), sizeof (psargs));
2708 if (get_inferior_args ())
2710 strncat (psargs, " ", sizeof (psargs) - strlen (psargs));
2711 strncat (psargs, get_inferior_args (),
2712 sizeof (psargs) - strlen (psargs));
2714 note_data = (char *) elfcore_write_prpsinfo (obfd,
2716 note_size, fname, psargs);
2719 /* Dump information for threads. */
2720 thread_args.obfd = obfd;
2721 thread_args.note_data = note_data;
2722 thread_args.note_size = note_size;
2723 thread_args.num_notes = 0;
2724 iterate_over_lwps (linux_nat_corefile_thread_callback, &thread_args);
2725 if (thread_args.num_notes == 0)
2727 /* iterate_over_threads didn't come up with any threads; just
2728 use inferior_ptid. */
2729 note_data = linux_nat_do_registers (obfd, inferior_ptid,
2730 note_data, note_size);
2734 note_data = thread_args.note_data;
2737 auxv_len = target_read_alloc (¤t_target, TARGET_OBJECT_AUXV,
2741 note_data = elfcore_write_note (obfd, note_data, note_size,
2742 "CORE", NT_AUXV, auxv, auxv_len);
2746 make_cleanup (xfree, note_data);
2750 /* Implement the "info proc" command. */
2753 linux_nat_info_proc_cmd (char *args, int from_tty)
2755 long long pid = PIDGET (inferior_ptid);
2758 char buffer[MAXPATHLEN];
2759 char fname1[MAXPATHLEN], fname2[MAXPATHLEN];
2772 /* Break up 'args' into an argv array. */
2773 if ((argv = buildargv (args)) == NULL)
2776 make_cleanup_freeargv (argv);
2778 while (argv != NULL && *argv != NULL)
2780 if (isdigit (argv[0][0]))
2782 pid = strtoul (argv[0], NULL, 10);
2784 else if (strncmp (argv[0], "mappings", strlen (argv[0])) == 0)
2788 else if (strcmp (argv[0], "status") == 0)
2792 else if (strcmp (argv[0], "stat") == 0)
2796 else if (strcmp (argv[0], "cmd") == 0)
2800 else if (strncmp (argv[0], "exe", strlen (argv[0])) == 0)
2804 else if (strcmp (argv[0], "cwd") == 0)
2808 else if (strncmp (argv[0], "all", strlen (argv[0])) == 0)
2814 /* [...] (future options here) */
2819 error (_("No current process: you must name one."));
2821 sprintf (fname1, "/proc/%lld", pid);
2822 if (stat (fname1, &dummy) != 0)
2823 error (_("No /proc directory: '%s'"), fname1);
2825 printf_filtered (_("process %lld\n"), pid);
2826 if (cmdline_f || all)
2828 sprintf (fname1, "/proc/%lld/cmdline", pid);
2829 if ((procfile = fopen (fname1, "r")) != NULL)
2831 fgets (buffer, sizeof (buffer), procfile);
2832 printf_filtered ("cmdline = '%s'\n", buffer);
2836 warning (_("unable to open /proc file '%s'"), fname1);
2840 sprintf (fname1, "/proc/%lld/cwd", pid);
2841 memset (fname2, 0, sizeof (fname2));
2842 if (readlink (fname1, fname2, sizeof (fname2)) > 0)
2843 printf_filtered ("cwd = '%s'\n", fname2);
2845 warning (_("unable to read link '%s'"), fname1);
2849 sprintf (fname1, "/proc/%lld/exe", pid);
2850 memset (fname2, 0, sizeof (fname2));
2851 if (readlink (fname1, fname2, sizeof (fname2)) > 0)
2852 printf_filtered ("exe = '%s'\n", fname2);
2854 warning (_("unable to read link '%s'"), fname1);
2856 if (mappings_f || all)
2858 sprintf (fname1, "/proc/%lld/maps", pid);
2859 if ((procfile = fopen (fname1, "r")) != NULL)
2861 long long addr, endaddr, size, offset, inode;
2862 char permissions[8], device[8], filename[MAXPATHLEN];
2864 printf_filtered (_("Mapped address spaces:\n\n"));
2865 if (TARGET_ADDR_BIT == 32)
2867 printf_filtered ("\t%10s %10s %10s %10s %7s\n",
2870 " Size", " Offset", "objfile");
2874 printf_filtered (" %18s %18s %10s %10s %7s\n",
2877 " Size", " Offset", "objfile");
2880 while (read_mapping (procfile, &addr, &endaddr, &permissions[0],
2881 &offset, &device[0], &inode, &filename[0]))
2883 size = endaddr - addr;
2885 /* FIXME: carlton/2003-08-27: Maybe the printf_filtered
2886 calls here (and possibly above) should be abstracted
2887 out into their own functions? Andrew suggests using
2888 a generic local_address_string instead to print out
2889 the addresses; that makes sense to me, too. */
2891 if (TARGET_ADDR_BIT == 32)
2893 printf_filtered ("\t%#10lx %#10lx %#10x %#10x %7s\n",
2894 (unsigned long) addr, /* FIXME: pr_addr */
2895 (unsigned long) endaddr,
2897 (unsigned int) offset,
2898 filename[0] ? filename : "");
2902 printf_filtered (" %#18lx %#18lx %#10x %#10x %7s\n",
2903 (unsigned long) addr, /* FIXME: pr_addr */
2904 (unsigned long) endaddr,
2906 (unsigned int) offset,
2907 filename[0] ? filename : "");
2914 warning (_("unable to open /proc file '%s'"), fname1);
2916 if (status_f || all)
2918 sprintf (fname1, "/proc/%lld/status", pid);
2919 if ((procfile = fopen (fname1, "r")) != NULL)
2921 while (fgets (buffer, sizeof (buffer), procfile) != NULL)
2922 puts_filtered (buffer);
2926 warning (_("unable to open /proc file '%s'"), fname1);
2930 sprintf (fname1, "/proc/%lld/stat", pid);
2931 if ((procfile = fopen (fname1, "r")) != NULL)
2936 if (fscanf (procfile, "%d ", &itmp) > 0)
2937 printf_filtered (_("Process: %d\n"), itmp);
2938 if (fscanf (procfile, "%s ", &buffer[0]) > 0)
2939 printf_filtered (_("Exec file: %s\n"), buffer);
2940 if (fscanf (procfile, "%c ", &ctmp) > 0)
2941 printf_filtered (_("State: %c\n"), ctmp);
2942 if (fscanf (procfile, "%d ", &itmp) > 0)
2943 printf_filtered (_("Parent process: %d\n"), itmp);
2944 if (fscanf (procfile, "%d ", &itmp) > 0)
2945 printf_filtered (_("Process group: %d\n"), itmp);
2946 if (fscanf (procfile, "%d ", &itmp) > 0)
2947 printf_filtered (_("Session id: %d\n"), itmp);
2948 if (fscanf (procfile, "%d ", &itmp) > 0)
2949 printf_filtered (_("TTY: %d\n"), itmp);
2950 if (fscanf (procfile, "%d ", &itmp) > 0)
2951 printf_filtered (_("TTY owner process group: %d\n"), itmp);
2952 if (fscanf (procfile, "%u ", &itmp) > 0)
2953 printf_filtered (_("Flags: 0x%x\n"), itmp);
2954 if (fscanf (procfile, "%u ", &itmp) > 0)
2955 printf_filtered (_("Minor faults (no memory page): %u\n"),
2956 (unsigned int) itmp);
2957 if (fscanf (procfile, "%u ", &itmp) > 0)
2958 printf_filtered (_("Minor faults, children: %u\n"),
2959 (unsigned int) itmp);
2960 if (fscanf (procfile, "%u ", &itmp) > 0)
2961 printf_filtered (_("Major faults (memory page faults): %u\n"),
2962 (unsigned int) itmp);
2963 if (fscanf (procfile, "%u ", &itmp) > 0)
2964 printf_filtered (_("Major faults, children: %u\n"),
2965 (unsigned int) itmp);
2966 if (fscanf (procfile, "%d ", &itmp) > 0)
2967 printf_filtered ("utime: %d\n", itmp);
2968 if (fscanf (procfile, "%d ", &itmp) > 0)
2969 printf_filtered ("stime: %d\n", itmp);
2970 if (fscanf (procfile, "%d ", &itmp) > 0)
2971 printf_filtered ("utime, children: %d\n", itmp);
2972 if (fscanf (procfile, "%d ", &itmp) > 0)
2973 printf_filtered ("stime, children: %d\n", itmp);
2974 if (fscanf (procfile, "%d ", &itmp) > 0)
2975 printf_filtered (_("jiffies remaining in current time slice: %d\n"),
2977 if (fscanf (procfile, "%d ", &itmp) > 0)
2978 printf_filtered ("'nice' value: %d\n", itmp);
2979 if (fscanf (procfile, "%u ", &itmp) > 0)
2980 printf_filtered (_("jiffies until next timeout: %u\n"),
2981 (unsigned int) itmp);
2982 if (fscanf (procfile, "%u ", &itmp) > 0)
2983 printf_filtered ("jiffies until next SIGALRM: %u\n",
2984 (unsigned int) itmp);
2985 if (fscanf (procfile, "%d ", &itmp) > 0)
2986 printf_filtered (_("start time (jiffies since system boot): %d\n"),
2988 if (fscanf (procfile, "%u ", &itmp) > 0)
2989 printf_filtered (_("Virtual memory size: %u\n"),
2990 (unsigned int) itmp);
2991 if (fscanf (procfile, "%u ", &itmp) > 0)
2992 printf_filtered (_("Resident set size: %u\n"), (unsigned int) itmp);
2993 if (fscanf (procfile, "%u ", &itmp) > 0)
2994 printf_filtered ("rlim: %u\n", (unsigned int) itmp);
2995 if (fscanf (procfile, "%u ", &itmp) > 0)
2996 printf_filtered (_("Start of text: 0x%x\n"), itmp);
2997 if (fscanf (procfile, "%u ", &itmp) > 0)
2998 printf_filtered (_("End of text: 0x%x\n"), itmp);
2999 if (fscanf (procfile, "%u ", &itmp) > 0)
3000 printf_filtered (_("Start of stack: 0x%x\n"), itmp);
3001 #if 0 /* Don't know how architecture-dependent the rest is...
3002 Anyway the signal bitmap info is available from "status". */
3003 if (fscanf (procfile, "%u ", &itmp) > 0) /* FIXME arch? */
3004 printf_filtered (_("Kernel stack pointer: 0x%x\n"), itmp);
3005 if (fscanf (procfile, "%u ", &itmp) > 0) /* FIXME arch? */
3006 printf_filtered (_("Kernel instr pointer: 0x%x\n"), itmp);
3007 if (fscanf (procfile, "%d ", &itmp) > 0)
3008 printf_filtered (_("Pending signals bitmap: 0x%x\n"), itmp);
3009 if (fscanf (procfile, "%d ", &itmp) > 0)
3010 printf_filtered (_("Blocked signals bitmap: 0x%x\n"), itmp);
3011 if (fscanf (procfile, "%d ", &itmp) > 0)
3012 printf_filtered (_("Ignored signals bitmap: 0x%x\n"), itmp);
3013 if (fscanf (procfile, "%d ", &itmp) > 0)
3014 printf_filtered (_("Catched signals bitmap: 0x%x\n"), itmp);
3015 if (fscanf (procfile, "%u ", &itmp) > 0) /* FIXME arch? */
3016 printf_filtered (_("wchan (system call): 0x%x\n"), itmp);
3021 warning (_("unable to open /proc file '%s'"), fname1);
3025 /* Implement the to_xfer_partial interface for memory reads using the /proc
3026 filesystem. Because we can use a single read() call for /proc, this
3027 can be much more efficient than banging away at PTRACE_PEEKTEXT,
3028 but it doesn't support writes. */
3031 linux_proc_xfer_partial (struct target_ops *ops, enum target_object object,
3032 const char *annex, gdb_byte *readbuf,
3033 const gdb_byte *writebuf,
3034 ULONGEST offset, LONGEST len)
3040 if (object != TARGET_OBJECT_MEMORY || !readbuf)
3043 /* Don't bother for one word. */
3044 if (len < 3 * sizeof (long))
3047 /* We could keep this file open and cache it - possibly one per
3048 thread. That requires some juggling, but is even faster. */
3049 sprintf (filename, "/proc/%d/mem", PIDGET (inferior_ptid));
3050 fd = open (filename, O_RDONLY | O_LARGEFILE);
3054 /* If pread64 is available, use it. It's faster if the kernel
3055 supports it (only one syscall), and it's 64-bit safe even on
3056 32-bit platforms (for instance, SPARC debugging a SPARC64
3059 if (pread64 (fd, readbuf, len, offset) != len)
3061 if (lseek (fd, offset, SEEK_SET) == -1 || read (fd, readbuf, len) != len)
3071 /* Parse LINE as a signal set and add its set bits to SIGS. */
3074 add_line_to_sigset (const char *line, sigset_t *sigs)
3076 int len = strlen (line) - 1;
3080 if (line[len] != '\n')
3081 error (_("Could not parse signal set: %s"), line);
3089 if (*p >= '0' && *p <= '9')
3091 else if (*p >= 'a' && *p <= 'f')
3092 digit = *p - 'a' + 10;
3094 error (_("Could not parse signal set: %s"), line);
3099 sigaddset (sigs, signum + 1);
3101 sigaddset (sigs, signum + 2);
3103 sigaddset (sigs, signum + 3);
3105 sigaddset (sigs, signum + 4);
3111 /* Find process PID's pending signals from /proc/pid/status and set
3115 linux_proc_pending_signals (int pid, sigset_t *pending, sigset_t *blocked, sigset_t *ignored)
3118 char buffer[MAXPATHLEN], fname[MAXPATHLEN];
3121 sigemptyset (pending);
3122 sigemptyset (blocked);
3123 sigemptyset (ignored);
3124 sprintf (fname, "/proc/%d/status", pid);
3125 procfile = fopen (fname, "r");
3126 if (procfile == NULL)
3127 error (_("Could not open %s"), fname);
3129 while (fgets (buffer, MAXPATHLEN, procfile) != NULL)
3131 /* Normal queued signals are on the SigPnd line in the status
3132 file. However, 2.6 kernels also have a "shared" pending
3133 queue for delivering signals to a thread group, so check for
3136 Unfortunately some Red Hat kernels include the shared pending
3137 queue but not the ShdPnd status field. */
3139 if (strncmp (buffer, "SigPnd:\t", 8) == 0)
3140 add_line_to_sigset (buffer + 8, pending);
3141 else if (strncmp (buffer, "ShdPnd:\t", 8) == 0)
3142 add_line_to_sigset (buffer + 8, pending);
3143 else if (strncmp (buffer, "SigBlk:\t", 8) == 0)
3144 add_line_to_sigset (buffer + 8, blocked);
3145 else if (strncmp (buffer, "SigIgn:\t", 8) == 0)
3146 add_line_to_sigset (buffer + 8, ignored);
3153 linux_xfer_partial (struct target_ops *ops, enum target_object object,
3154 const char *annex, gdb_byte *readbuf,
3155 const gdb_byte *writebuf, ULONGEST offset, LONGEST len)
3159 if (object == TARGET_OBJECT_AUXV)
3160 return procfs_xfer_auxv (ops, object, annex, readbuf, writebuf,
3163 xfer = linux_proc_xfer_partial (ops, object, annex, readbuf, writebuf,
3168 return super_xfer_partial (ops, object, annex, readbuf, writebuf,
3172 /* Create a prototype generic Linux target. The client can override
3173 it with local methods. */
3176 linux_target_install_ops (struct target_ops *t)
3178 t->to_insert_fork_catchpoint = linux_child_insert_fork_catchpoint;
3179 t->to_insert_vfork_catchpoint = linux_child_insert_vfork_catchpoint;
3180 t->to_insert_exec_catchpoint = linux_child_insert_exec_catchpoint;
3181 t->to_pid_to_exec_file = linux_child_pid_to_exec_file;
3182 t->to_post_startup_inferior = linux_child_post_startup_inferior;
3183 t->to_post_attach = linux_child_post_attach;
3184 t->to_follow_fork = linux_child_follow_fork;
3185 t->to_find_memory_regions = linux_nat_find_memory_regions;
3186 t->to_make_corefile_notes = linux_nat_make_corefile_notes;
3188 super_xfer_partial = t->to_xfer_partial;
3189 t->to_xfer_partial = linux_xfer_partial;
3195 struct target_ops *t;
3197 t = inf_ptrace_target ();
3198 linux_target_install_ops (t);
3204 linux_trad_target (CORE_ADDR (*register_u_offset)(struct gdbarch *, int, int))
3206 struct target_ops *t;
3208 t = inf_ptrace_trad_target (register_u_offset);
3209 linux_target_install_ops (t);
3215 linux_nat_add_target (struct target_ops *t)
3217 /* Save the provided single-threaded target. We save this in a separate
3218 variable because another target we've inherited from (e.g. inf-ptrace)
3219 may have saved a pointer to T; we want to use it for the final
3220 process stratum target. */
3221 linux_ops_saved = *t;
3222 linux_ops = &linux_ops_saved;
3224 /* Override some methods for multithreading. */
3225 t->to_attach = linux_nat_attach;
3226 t->to_detach = linux_nat_detach;
3227 t->to_resume = linux_nat_resume;
3228 t->to_wait = linux_nat_wait;
3229 t->to_xfer_partial = linux_nat_xfer_partial;
3230 t->to_kill = linux_nat_kill;
3231 t->to_mourn_inferior = linux_nat_mourn_inferior;
3232 t->to_thread_alive = linux_nat_thread_alive;
3233 t->to_pid_to_str = linux_nat_pid_to_str;
3234 t->to_has_thread_control = tc_schedlock;
3236 /* We don't change the stratum; this target will sit at
3237 process_stratum and thread_db will set at thread_stratum. This
3238 is a little strange, since this is a multi-threaded-capable
3239 target, but we want to be on the stack below thread_db, and we
3240 also want to be used for single-threaded processes. */
3244 /* TODO: Eliminate this and have libthread_db use
3245 find_target_beneath. */
3250 _initialize_linux_nat (void)
3252 struct sigaction action;
3254 add_info ("proc", linux_nat_info_proc_cmd, _("\
3255 Show /proc process information about any running process.\n\
3256 Specify any process id, or use the program being debugged by default.\n\
3257 Specify any of the following keywords for detailed info:\n\
3258 mappings -- list of mapped memory regions.\n\
3259 stat -- list a bunch of random process info.\n\
3260 status -- list a different bunch of random process info.\n\
3261 all -- list all available /proc info."));
3263 /* Save the original signal mask. */
3264 sigprocmask (SIG_SETMASK, NULL, &normal_mask);
3266 action.sa_handler = sigchld_handler;
3267 sigemptyset (&action.sa_mask);
3268 action.sa_flags = SA_RESTART;
3269 sigaction (SIGCHLD, &action, NULL);
3271 /* Make sure we don't block SIGCHLD during a sigsuspend. */
3272 sigprocmask (SIG_SETMASK, NULL, &suspend_mask);
3273 sigdelset (&suspend_mask, SIGCHLD);
3275 sigemptyset (&blocked_mask);
3277 add_setshow_zinteger_cmd ("lin-lwp", no_class, &debug_linux_nat, _("\
3278 Set debugging of GNU/Linux lwp module."), _("\
3279 Show debugging of GNU/Linux lwp module."), _("\
3280 Enables printf debugging output."),
3282 show_debug_linux_nat,
3283 &setdebuglist, &showdebuglist);
3287 /* FIXME: kettenis/2000-08-26: The stuff on this page is specific to
3288 the GNU/Linux Threads library and therefore doesn't really belong
3291 /* Read variable NAME in the target and return its value if found.
3292 Otherwise return zero. It is assumed that the type of the variable
3296 get_signo (const char *name)
3298 struct minimal_symbol *ms;
3301 ms = lookup_minimal_symbol (name, NULL, NULL);
3305 if (target_read_memory (SYMBOL_VALUE_ADDRESS (ms), (gdb_byte *) &signo,
3306 sizeof (signo)) != 0)
3312 /* Return the set of signals used by the threads library in *SET. */
3315 lin_thread_get_thread_signals (sigset_t *set)
3317 struct sigaction action;
3318 int restart, cancel;
3322 restart = get_signo ("__pthread_sig_restart");
3323 cancel = get_signo ("__pthread_sig_cancel");
3325 /* LinuxThreads normally uses the first two RT signals, but in some legacy
3326 cases may use SIGUSR1/SIGUSR2. NPTL always uses RT signals, but does
3327 not provide any way for the debugger to query the signal numbers -
3328 fortunately they don't change! */
3331 restart = __SIGRTMIN;
3334 cancel = __SIGRTMIN + 1;
3336 sigaddset (set, restart);
3337 sigaddset (set, cancel);
3339 /* The GNU/Linux Threads library makes terminating threads send a
3340 special "cancel" signal instead of SIGCHLD. Make sure we catch
3341 those (to prevent them from terminating GDB itself, which is
3342 likely to be their default action) and treat them the same way as
3345 action.sa_handler = sigchld_handler;
3346 sigemptyset (&action.sa_mask);
3347 action.sa_flags = SA_RESTART;
3348 sigaction (cancel, &action, NULL);
3350 /* We block the "cancel" signal throughout this code ... */
3351 sigaddset (&blocked_mask, cancel);
3352 sigprocmask (SIG_BLOCK, &blocked_mask, NULL);
3354 /* ... except during a sigsuspend. */
3355 sigdelset (&suspend_mask, cancel);