1 /* GNU/Linux native-dependent code common to multiple platforms.
3 Copyright (C) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010,
4 2011 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-ptrace.h"
34 #include "linux-procfs.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 */
52 #include "event-loop.h"
53 #include "event-top.h"
55 #include <sys/types.h>
56 #include "gdb_dirent.h"
57 #include "xml-support.h"
61 #include "linux-osdata.h"
62 #include "cli/cli-utils.h"
65 #define SPUFS_MAGIC 0x23c9b64e
68 #ifdef HAVE_PERSONALITY
69 # include <sys/personality.h>
70 # if !HAVE_DECL_ADDR_NO_RANDOMIZE
71 # define ADDR_NO_RANDOMIZE 0x0040000
73 #endif /* HAVE_PERSONALITY */
75 /* This comment documents high-level logic of this file.
77 Waiting for events in sync mode
78 ===============================
80 When waiting for an event in a specific thread, we just use waitpid, passing
81 the specific pid, and not passing WNOHANG.
83 When waiting for an event in all threads, waitpid is not quite good. Prior to
84 version 2.4, Linux can either wait for event in main thread, or in secondary
85 threads. (2.4 has the __WALL flag). So, if we use blocking waitpid, we might
86 miss an event. The solution is to use non-blocking waitpid, together with
87 sigsuspend. First, we use non-blocking waitpid to get an event in the main
88 process, if any. Second, we use non-blocking waitpid with the __WCLONED
89 flag to check for events in cloned processes. If nothing is found, we use
90 sigsuspend to wait for SIGCHLD. When SIGCHLD arrives, it means something
91 happened to a child process -- and SIGCHLD will be delivered both for events
92 in main debugged process and in cloned processes. As soon as we know there's
93 an event, we get back to calling nonblocking waitpid with and without
96 Note that SIGCHLD should be blocked between waitpid and sigsuspend calls,
97 so that we don't miss a signal. If SIGCHLD arrives in between, when it's
98 blocked, the signal becomes pending and sigsuspend immediately
99 notices it and returns.
101 Waiting for events in async mode
102 ================================
104 In async mode, GDB should always be ready to handle both user input
105 and target events, so neither blocking waitpid nor sigsuspend are
106 viable options. Instead, we should asynchronously notify the GDB main
107 event loop whenever there's an unprocessed event from the target. We
108 detect asynchronous target events by handling SIGCHLD signals. To
109 notify the event loop about target events, the self-pipe trick is used
110 --- a pipe is registered as waitable event source in the event loop,
111 the event loop select/poll's on the read end of this pipe (as well on
112 other event sources, e.g., stdin), and the SIGCHLD handler writes a
113 byte to this pipe. This is more portable than relying on
114 pselect/ppoll, since on kernels that lack those syscalls, libc
115 emulates them with select/poll+sigprocmask, and that is racy
116 (a.k.a. plain broken).
118 Obviously, if we fail to notify the event loop if there's a target
119 event, it's bad. OTOH, if we notify the event loop when there's no
120 event from the target, linux_nat_wait will detect that there's no real
121 event to report, and return event of type TARGET_WAITKIND_IGNORE.
122 This is mostly harmless, but it will waste time and is better avoided.
124 The main design point is that every time GDB is outside linux-nat.c,
125 we have a SIGCHLD handler installed that is called when something
126 happens to the target and notifies the GDB event loop. Whenever GDB
127 core decides to handle the event, and calls into linux-nat.c, we
128 process things as in sync mode, except that the we never block in
131 While processing an event, we may end up momentarily blocked in
132 waitpid calls. Those waitpid calls, while blocking, are guarantied to
133 return quickly. E.g., in all-stop mode, before reporting to the core
134 that an LWP hit a breakpoint, all LWPs are stopped by sending them
135 SIGSTOP, and synchronously waiting for the SIGSTOP to be reported.
136 Note that this is different from blocking indefinitely waiting for the
137 next event --- here, we're already handling an event.
142 We stop threads by sending a SIGSTOP. The use of SIGSTOP instead of another
143 signal is not entirely significant; we just need for a signal to be delivered,
144 so that we can intercept it. SIGSTOP's advantage is that it can not be
145 blocked. A disadvantage is that it is not a real-time signal, so it can only
146 be queued once; we do not keep track of other sources of SIGSTOP.
148 Two other signals that can't be blocked are SIGCONT and SIGKILL. But we can't
149 use them, because they have special behavior when the signal is generated -
150 not when it is delivered. SIGCONT resumes the entire thread group and SIGKILL
151 kills the entire thread group.
153 A delivered SIGSTOP would stop the entire thread group, not just the thread we
154 tkill'd. But we never let the SIGSTOP be delivered; we always intercept and
155 cancel it (by PTRACE_CONT without passing SIGSTOP).
157 We could use a real-time signal instead. This would solve those problems; we
158 could use PTRACE_GETSIGINFO to locate the specific stop signals sent by GDB.
159 But we would still have to have some support for SIGSTOP, since PTRACE_ATTACH
160 generates it, and there are races with trying to find a signal that is not
164 #define O_LARGEFILE 0
167 /* Unlike other extended result codes, WSTOPSIG (status) on
168 PTRACE_O_TRACESYSGOOD syscall events doesn't return SIGTRAP, but
169 instead SIGTRAP with bit 7 set. */
170 #define SYSCALL_SIGTRAP (SIGTRAP | 0x80)
172 /* The single-threaded native GNU/Linux target_ops. We save a pointer for
173 the use of the multi-threaded target. */
174 static struct target_ops *linux_ops;
175 static struct target_ops linux_ops_saved;
177 /* The method to call, if any, when a new thread is attached. */
178 static void (*linux_nat_new_thread) (ptid_t);
180 /* The method to call, if any, when the siginfo object needs to be
181 converted between the layout returned by ptrace, and the layout in
182 the architecture of the inferior. */
183 static int (*linux_nat_siginfo_fixup) (struct siginfo *,
187 /* The saved to_xfer_partial method, inherited from inf-ptrace.c.
188 Called by our to_xfer_partial. */
189 static LONGEST (*super_xfer_partial) (struct target_ops *,
191 const char *, gdb_byte *,
195 static int debug_linux_nat;
197 show_debug_linux_nat (struct ui_file *file, int from_tty,
198 struct cmd_list_element *c, const char *value)
200 fprintf_filtered (file, _("Debugging of GNU/Linux lwp module is %s.\n"),
204 struct simple_pid_list
208 struct simple_pid_list *next;
210 struct simple_pid_list *stopped_pids;
212 /* This variable is a tri-state flag: -1 for unknown, 0 if PTRACE_O_TRACEFORK
213 can not be used, 1 if it can. */
215 static int linux_supports_tracefork_flag = -1;
217 /* This variable is a tri-state flag: -1 for unknown, 0 if
218 PTRACE_O_TRACESYSGOOD can not be used, 1 if it can. */
220 static int linux_supports_tracesysgood_flag = -1;
222 /* If we have PTRACE_O_TRACEFORK, this flag indicates whether we also have
223 PTRACE_O_TRACEVFORKDONE. */
225 static int linux_supports_tracevforkdone_flag = -1;
227 /* Stores the current used ptrace() options. */
228 static int current_ptrace_options = 0;
230 /* Async mode support. */
232 /* The read/write ends of the pipe registered as waitable file in the
234 static int linux_nat_event_pipe[2] = { -1, -1 };
236 /* Flush the event pipe. */
239 async_file_flush (void)
246 ret = read (linux_nat_event_pipe[0], &buf, 1);
248 while (ret >= 0 || (ret == -1 && errno == EINTR));
251 /* Put something (anything, doesn't matter what, or how much) in event
252 pipe, so that the select/poll in the event-loop realizes we have
253 something to process. */
256 async_file_mark (void)
260 /* It doesn't really matter what the pipe contains, as long we end
261 up with something in it. Might as well flush the previous
267 ret = write (linux_nat_event_pipe[1], "+", 1);
269 while (ret == -1 && errno == EINTR);
271 /* Ignore EAGAIN. If the pipe is full, the event loop will already
272 be awakened anyway. */
275 static void linux_nat_async (void (*callback)
276 (enum inferior_event_type event_type,
279 static int kill_lwp (int lwpid, int signo);
281 static int stop_callback (struct lwp_info *lp, void *data);
283 static void block_child_signals (sigset_t *prev_mask);
284 static void restore_child_signals_mask (sigset_t *prev_mask);
287 static struct lwp_info *add_lwp (ptid_t ptid);
288 static void purge_lwp_list (int pid);
289 static struct lwp_info *find_lwp_pid (ptid_t ptid);
292 /* Trivial list manipulation functions to keep track of a list of
293 new stopped processes. */
295 add_to_pid_list (struct simple_pid_list **listp, int pid, int status)
297 struct simple_pid_list *new_pid = xmalloc (sizeof (struct simple_pid_list));
300 new_pid->status = status;
301 new_pid->next = *listp;
306 in_pid_list_p (struct simple_pid_list *list, int pid)
308 struct simple_pid_list *p;
310 for (p = list; p != NULL; p = p->next)
317 pull_pid_from_list (struct simple_pid_list **listp, int pid, int *statusp)
319 struct simple_pid_list **p;
321 for (p = listp; *p != NULL; p = &(*p)->next)
322 if ((*p)->pid == pid)
324 struct simple_pid_list *next = (*p)->next;
326 *statusp = (*p)->status;
335 /* A helper function for linux_test_for_tracefork, called after fork (). */
338 linux_tracefork_child (void)
340 ptrace (PTRACE_TRACEME, 0, 0, 0);
341 kill (getpid (), SIGSTOP);
346 /* Wrapper function for waitpid which handles EINTR. */
349 my_waitpid (int pid, int *statusp, int flags)
355 ret = waitpid (pid, statusp, flags);
357 while (ret == -1 && errno == EINTR);
362 /* Determine if PTRACE_O_TRACEFORK can be used to follow fork events.
364 First, we try to enable fork tracing on ORIGINAL_PID. If this fails,
365 we know that the feature is not available. This may change the tracing
366 options for ORIGINAL_PID, but we'll be setting them shortly anyway.
368 However, if it succeeds, we don't know for sure that the feature is
369 available; old versions of PTRACE_SETOPTIONS ignored unknown options. We
370 create a child process, attach to it, use PTRACE_SETOPTIONS to enable
371 fork tracing, and let it fork. If the process exits, we assume that we
372 can't use TRACEFORK; if we get the fork notification, and we can extract
373 the new child's PID, then we assume that we can. */
376 linux_test_for_tracefork (int original_pid)
378 int child_pid, ret, status;
382 /* We don't want those ptrace calls to be interrupted. */
383 block_child_signals (&prev_mask);
385 linux_supports_tracefork_flag = 0;
386 linux_supports_tracevforkdone_flag = 0;
388 ret = ptrace (PTRACE_SETOPTIONS, original_pid, 0, PTRACE_O_TRACEFORK);
391 restore_child_signals_mask (&prev_mask);
397 perror_with_name (("fork"));
400 linux_tracefork_child ();
402 ret = my_waitpid (child_pid, &status, 0);
404 perror_with_name (("waitpid"));
405 else if (ret != child_pid)
406 error (_("linux_test_for_tracefork: waitpid: unexpected result %d."), ret);
407 if (! WIFSTOPPED (status))
408 error (_("linux_test_for_tracefork: waitpid: unexpected status %d."),
411 ret = ptrace (PTRACE_SETOPTIONS, child_pid, 0, PTRACE_O_TRACEFORK);
414 ret = ptrace (PTRACE_KILL, child_pid, 0, 0);
417 warning (_("linux_test_for_tracefork: failed to kill child"));
418 restore_child_signals_mask (&prev_mask);
422 ret = my_waitpid (child_pid, &status, 0);
423 if (ret != child_pid)
424 warning (_("linux_test_for_tracefork: failed "
425 "to wait for killed child"));
426 else if (!WIFSIGNALED (status))
427 warning (_("linux_test_for_tracefork: unexpected "
428 "wait status 0x%x from killed child"), status);
430 restore_child_signals_mask (&prev_mask);
434 /* Check whether PTRACE_O_TRACEVFORKDONE is available. */
435 ret = ptrace (PTRACE_SETOPTIONS, child_pid, 0,
436 PTRACE_O_TRACEFORK | PTRACE_O_TRACEVFORKDONE);
437 linux_supports_tracevforkdone_flag = (ret == 0);
439 ret = ptrace (PTRACE_CONT, child_pid, 0, 0);
441 warning (_("linux_test_for_tracefork: failed to resume child"));
443 ret = my_waitpid (child_pid, &status, 0);
445 if (ret == child_pid && WIFSTOPPED (status)
446 && status >> 16 == PTRACE_EVENT_FORK)
449 ret = ptrace (PTRACE_GETEVENTMSG, child_pid, 0, &second_pid);
450 if (ret == 0 && second_pid != 0)
454 linux_supports_tracefork_flag = 1;
455 my_waitpid (second_pid, &second_status, 0);
456 ret = ptrace (PTRACE_KILL, second_pid, 0, 0);
458 warning (_("linux_test_for_tracefork: "
459 "failed to kill second child"));
460 my_waitpid (second_pid, &status, 0);
464 warning (_("linux_test_for_tracefork: unexpected result from waitpid "
465 "(%d, status 0x%x)"), ret, status);
467 ret = ptrace (PTRACE_KILL, child_pid, 0, 0);
469 warning (_("linux_test_for_tracefork: failed to kill child"));
470 my_waitpid (child_pid, &status, 0);
472 restore_child_signals_mask (&prev_mask);
475 /* Determine if PTRACE_O_TRACESYSGOOD can be used to follow syscalls.
477 We try to enable syscall tracing on ORIGINAL_PID. If this fails,
478 we know that the feature is not available. This may change the tracing
479 options for ORIGINAL_PID, but we'll be setting them shortly anyway. */
482 linux_test_for_tracesysgood (int original_pid)
487 /* We don't want those ptrace calls to be interrupted. */
488 block_child_signals (&prev_mask);
490 linux_supports_tracesysgood_flag = 0;
492 ret = ptrace (PTRACE_SETOPTIONS, original_pid, 0, PTRACE_O_TRACESYSGOOD);
496 linux_supports_tracesysgood_flag = 1;
498 restore_child_signals_mask (&prev_mask);
501 /* Determine wether we support PTRACE_O_TRACESYSGOOD option available.
502 This function also sets linux_supports_tracesysgood_flag. */
505 linux_supports_tracesysgood (int pid)
507 if (linux_supports_tracesysgood_flag == -1)
508 linux_test_for_tracesysgood (pid);
509 return linux_supports_tracesysgood_flag;
512 /* Return non-zero iff we have tracefork functionality available.
513 This function also sets linux_supports_tracefork_flag. */
516 linux_supports_tracefork (int pid)
518 if (linux_supports_tracefork_flag == -1)
519 linux_test_for_tracefork (pid);
520 return linux_supports_tracefork_flag;
524 linux_supports_tracevforkdone (int pid)
526 if (linux_supports_tracefork_flag == -1)
527 linux_test_for_tracefork (pid);
528 return linux_supports_tracevforkdone_flag;
532 linux_enable_tracesysgood (ptid_t ptid)
534 int pid = ptid_get_lwp (ptid);
537 pid = ptid_get_pid (ptid);
539 if (linux_supports_tracesysgood (pid) == 0)
542 current_ptrace_options |= PTRACE_O_TRACESYSGOOD;
544 ptrace (PTRACE_SETOPTIONS, pid, 0, current_ptrace_options);
549 linux_enable_event_reporting (ptid_t ptid)
551 int pid = ptid_get_lwp (ptid);
554 pid = ptid_get_pid (ptid);
556 if (! linux_supports_tracefork (pid))
559 current_ptrace_options |= PTRACE_O_TRACEFORK | PTRACE_O_TRACEVFORK
560 | PTRACE_O_TRACEEXEC | PTRACE_O_TRACECLONE;
562 if (linux_supports_tracevforkdone (pid))
563 current_ptrace_options |= PTRACE_O_TRACEVFORKDONE;
565 /* Do not enable PTRACE_O_TRACEEXIT until GDB is more prepared to support
566 read-only process state. */
568 ptrace (PTRACE_SETOPTIONS, pid, 0, current_ptrace_options);
572 linux_child_post_attach (int pid)
574 linux_enable_event_reporting (pid_to_ptid (pid));
575 linux_enable_tracesysgood (pid_to_ptid (pid));
579 linux_child_post_startup_inferior (ptid_t ptid)
581 linux_enable_event_reporting (ptid);
582 linux_enable_tracesysgood (ptid);
586 linux_child_follow_fork (struct target_ops *ops, int follow_child)
590 int parent_pid, child_pid;
592 block_child_signals (&prev_mask);
594 has_vforked = (inferior_thread ()->pending_follow.kind
595 == TARGET_WAITKIND_VFORKED);
596 parent_pid = ptid_get_lwp (inferior_ptid);
598 parent_pid = ptid_get_pid (inferior_ptid);
599 child_pid = PIDGET (inferior_thread ()->pending_follow.value.related_pid);
602 linux_enable_event_reporting (pid_to_ptid (child_pid));
605 && !non_stop /* Non-stop always resumes both branches. */
606 && (!target_is_async_p () || sync_execution)
607 && !(follow_child || detach_fork || sched_multi))
609 /* The parent stays blocked inside the vfork syscall until the
610 child execs or exits. If we don't let the child run, then
611 the parent stays blocked. If we're telling the parent to run
612 in the foreground, the user will not be able to ctrl-c to get
613 back the terminal, effectively hanging the debug session. */
614 fprintf_filtered (gdb_stderr, _("\
615 Can not resume the parent process over vfork in the foreground while\n\
616 holding the child stopped. Try \"set detach-on-fork\" or \
617 \"set schedule-multiple\".\n"));
618 /* FIXME output string > 80 columns. */
624 struct lwp_info *child_lp = NULL;
626 /* We're already attached to the parent, by default. */
628 /* Detach new forked process? */
631 /* Before detaching from the child, remove all breakpoints
632 from it. If we forked, then this has already been taken
633 care of by infrun.c. If we vforked however, any
634 breakpoint inserted in the parent is visible in the
635 child, even those added while stopped in a vfork
636 catchpoint. This will remove the breakpoints from the
637 parent also, but they'll be reinserted below. */
640 /* keep breakpoints list in sync. */
641 remove_breakpoints_pid (GET_PID (inferior_ptid));
644 if (info_verbose || debug_linux_nat)
646 target_terminal_ours ();
647 fprintf_filtered (gdb_stdlog,
648 "Detaching after fork from "
649 "child process %d.\n",
653 ptrace (PTRACE_DETACH, child_pid, 0, 0);
657 struct inferior *parent_inf, *child_inf;
658 struct cleanup *old_chain;
660 /* Add process to GDB's tables. */
661 child_inf = add_inferior (child_pid);
663 parent_inf = current_inferior ();
664 child_inf->attach_flag = parent_inf->attach_flag;
665 copy_terminal_info (child_inf, parent_inf);
667 old_chain = save_inferior_ptid ();
668 save_current_program_space ();
670 inferior_ptid = ptid_build (child_pid, child_pid, 0);
671 add_thread (inferior_ptid);
672 child_lp = add_lwp (inferior_ptid);
673 child_lp->stopped = 1;
674 child_lp->last_resume_kind = resume_stop;
676 /* If this is a vfork child, then the address-space is
677 shared with the parent. */
680 child_inf->pspace = parent_inf->pspace;
681 child_inf->aspace = parent_inf->aspace;
683 /* The parent will be frozen until the child is done
684 with the shared region. Keep track of the
686 child_inf->vfork_parent = parent_inf;
687 child_inf->pending_detach = 0;
688 parent_inf->vfork_child = child_inf;
689 parent_inf->pending_detach = 0;
693 child_inf->aspace = new_address_space ();
694 child_inf->pspace = add_program_space (child_inf->aspace);
695 child_inf->removable = 1;
696 set_current_program_space (child_inf->pspace);
697 clone_program_space (child_inf->pspace, parent_inf->pspace);
699 /* Let the shared library layer (solib-svr4) learn about
700 this new process, relocate the cloned exec, pull in
701 shared libraries, and install the solib event
702 breakpoint. If a "cloned-VM" event was propagated
703 better throughout the core, this wouldn't be
705 solib_create_inferior_hook (0);
708 /* Let the thread_db layer learn about this new process. */
709 check_for_thread_db ();
711 do_cleanups (old_chain);
716 struct lwp_info *parent_lp;
717 struct inferior *parent_inf;
719 parent_inf = current_inferior ();
721 /* If we detached from the child, then we have to be careful
722 to not insert breakpoints in the parent until the child
723 is done with the shared memory region. However, if we're
724 staying attached to the child, then we can and should
725 insert breakpoints, so that we can debug it. A
726 subsequent child exec or exit is enough to know when does
727 the child stops using the parent's address space. */
728 parent_inf->waiting_for_vfork_done = detach_fork;
729 parent_inf->pspace->breakpoints_not_allowed = detach_fork;
731 parent_lp = find_lwp_pid (pid_to_ptid (parent_pid));
732 gdb_assert (linux_supports_tracefork_flag >= 0);
734 if (linux_supports_tracevforkdone (0))
737 fprintf_unfiltered (gdb_stdlog,
738 "LCFF: waiting for VFORK_DONE on %d\n",
740 parent_lp->stopped = 1;
742 /* We'll handle the VFORK_DONE event like any other
743 event, in target_wait. */
747 /* We can't insert breakpoints until the child has
748 finished with the shared memory region. We need to
749 wait until that happens. Ideal would be to just
751 - ptrace (PTRACE_SYSCALL, parent_pid, 0, 0);
752 - waitpid (parent_pid, &status, __WALL);
753 However, most architectures can't handle a syscall
754 being traced on the way out if it wasn't traced on
757 We might also think to loop, continuing the child
758 until it exits or gets a SIGTRAP. One problem is
759 that the child might call ptrace with PTRACE_TRACEME.
761 There's no simple and reliable way to figure out when
762 the vforked child will be done with its copy of the
763 shared memory. We could step it out of the syscall,
764 two instructions, let it go, and then single-step the
765 parent once. When we have hardware single-step, this
766 would work; with software single-step it could still
767 be made to work but we'd have to be able to insert
768 single-step breakpoints in the child, and we'd have
769 to insert -just- the single-step breakpoint in the
770 parent. Very awkward.
772 In the end, the best we can do is to make sure it
773 runs for a little while. Hopefully it will be out of
774 range of any breakpoints we reinsert. Usually this
775 is only the single-step breakpoint at vfork's return
779 fprintf_unfiltered (gdb_stdlog,
780 "LCFF: no VFORK_DONE "
781 "support, sleeping a bit\n");
785 /* Pretend we've seen a PTRACE_EVENT_VFORK_DONE event,
786 and leave it pending. The next linux_nat_resume call
787 will notice a pending event, and bypasses actually
788 resuming the inferior. */
789 parent_lp->status = 0;
790 parent_lp->waitstatus.kind = TARGET_WAITKIND_VFORK_DONE;
791 parent_lp->stopped = 1;
793 /* If we're in async mode, need to tell the event loop
794 there's something here to process. */
795 if (target_can_async_p ())
802 struct inferior *parent_inf, *child_inf;
803 struct lwp_info *child_lp;
804 struct program_space *parent_pspace;
806 if (info_verbose || debug_linux_nat)
808 target_terminal_ours ();
810 fprintf_filtered (gdb_stdlog,
811 _("Attaching after process %d "
812 "vfork to child process %d.\n"),
813 parent_pid, child_pid);
815 fprintf_filtered (gdb_stdlog,
816 _("Attaching after process %d "
817 "fork to child process %d.\n"),
818 parent_pid, child_pid);
821 /* Add the new inferior first, so that the target_detach below
822 doesn't unpush the target. */
824 child_inf = add_inferior (child_pid);
826 parent_inf = current_inferior ();
827 child_inf->attach_flag = parent_inf->attach_flag;
828 copy_terminal_info (child_inf, parent_inf);
830 parent_pspace = parent_inf->pspace;
832 /* If we're vforking, we want to hold on to the parent until the
833 child exits or execs. At child exec or exit time we can
834 remove the old breakpoints from the parent and detach or
835 resume debugging it. Otherwise, detach the parent now; we'll
836 want to reuse it's program/address spaces, but we can't set
837 them to the child before removing breakpoints from the
838 parent, otherwise, the breakpoints module could decide to
839 remove breakpoints from the wrong process (since they'd be
840 assigned to the same address space). */
844 gdb_assert (child_inf->vfork_parent == NULL);
845 gdb_assert (parent_inf->vfork_child == NULL);
846 child_inf->vfork_parent = parent_inf;
847 child_inf->pending_detach = 0;
848 parent_inf->vfork_child = child_inf;
849 parent_inf->pending_detach = detach_fork;
850 parent_inf->waiting_for_vfork_done = 0;
852 else if (detach_fork)
853 target_detach (NULL, 0);
855 /* Note that the detach above makes PARENT_INF dangling. */
857 /* Add the child thread to the appropriate lists, and switch to
858 this new thread, before cloning the program space, and
859 informing the solib layer about this new process. */
861 inferior_ptid = ptid_build (child_pid, child_pid, 0);
862 add_thread (inferior_ptid);
863 child_lp = add_lwp (inferior_ptid);
864 child_lp->stopped = 1;
865 child_lp->last_resume_kind = resume_stop;
867 /* If this is a vfork child, then the address-space is shared
868 with the parent. If we detached from the parent, then we can
869 reuse the parent's program/address spaces. */
870 if (has_vforked || detach_fork)
872 child_inf->pspace = parent_pspace;
873 child_inf->aspace = child_inf->pspace->aspace;
877 child_inf->aspace = new_address_space ();
878 child_inf->pspace = add_program_space (child_inf->aspace);
879 child_inf->removable = 1;
880 set_current_program_space (child_inf->pspace);
881 clone_program_space (child_inf->pspace, parent_pspace);
883 /* Let the shared library layer (solib-svr4) learn about
884 this new process, relocate the cloned exec, pull in
885 shared libraries, and install the solib event breakpoint.
886 If a "cloned-VM" event was propagated better throughout
887 the core, this wouldn't be required. */
888 solib_create_inferior_hook (0);
891 /* Let the thread_db layer learn about this new process. */
892 check_for_thread_db ();
895 restore_child_signals_mask (&prev_mask);
901 linux_child_insert_fork_catchpoint (int pid)
903 return !linux_supports_tracefork (pid);
907 linux_child_remove_fork_catchpoint (int pid)
913 linux_child_insert_vfork_catchpoint (int pid)
915 return !linux_supports_tracefork (pid);
919 linux_child_remove_vfork_catchpoint (int pid)
925 linux_child_insert_exec_catchpoint (int pid)
927 return !linux_supports_tracefork (pid);
931 linux_child_remove_exec_catchpoint (int pid)
937 linux_child_set_syscall_catchpoint (int pid, int needed, int any_count,
938 int table_size, int *table)
940 if (!linux_supports_tracesysgood (pid))
943 /* On GNU/Linux, we ignore the arguments. It means that we only
944 enable the syscall catchpoints, but do not disable them.
946 Also, we do not use the `table' information because we do not
947 filter system calls here. We let GDB do the logic for us. */
951 /* On GNU/Linux there are no real LWP's. The closest thing to LWP's
952 are processes sharing the same VM space. A multi-threaded process
953 is basically a group of such processes. However, such a grouping
954 is almost entirely a user-space issue; the kernel doesn't enforce
955 such a grouping at all (this might change in the future). In
956 general, we'll rely on the threads library (i.e. the GNU/Linux
957 Threads library) to provide such a grouping.
959 It is perfectly well possible to write a multi-threaded application
960 without the assistance of a threads library, by using the clone
961 system call directly. This module should be able to give some
962 rudimentary support for debugging such applications if developers
963 specify the CLONE_PTRACE flag in the clone system call, and are
964 using the Linux kernel 2.4 or above.
966 Note that there are some peculiarities in GNU/Linux that affect
969 - In general one should specify the __WCLONE flag to waitpid in
970 order to make it report events for any of the cloned processes
971 (and leave it out for the initial process). However, if a cloned
972 process has exited the exit status is only reported if the
973 __WCLONE flag is absent. Linux kernel 2.4 has a __WALL flag, but
974 we cannot use it since GDB must work on older systems too.
976 - When a traced, cloned process exits and is waited for by the
977 debugger, the kernel reassigns it to the original parent and
978 keeps it around as a "zombie". Somehow, the GNU/Linux Threads
979 library doesn't notice this, which leads to the "zombie problem":
980 When debugged a multi-threaded process that spawns a lot of
981 threads will run out of processes, even if the threads exit,
982 because the "zombies" stay around. */
984 /* List of known LWPs. */
985 struct lwp_info *lwp_list;
988 /* Original signal mask. */
989 static sigset_t normal_mask;
991 /* Signal mask for use with sigsuspend in linux_nat_wait, initialized in
992 _initialize_linux_nat. */
993 static sigset_t suspend_mask;
995 /* Signals to block to make that sigsuspend work. */
996 static sigset_t blocked_mask;
998 /* SIGCHLD action. */
999 struct sigaction sigchld_action;
1001 /* Block child signals (SIGCHLD and linux threads signals), and store
1002 the previous mask in PREV_MASK. */
1005 block_child_signals (sigset_t *prev_mask)
1007 /* Make sure SIGCHLD is blocked. */
1008 if (!sigismember (&blocked_mask, SIGCHLD))
1009 sigaddset (&blocked_mask, SIGCHLD);
1011 sigprocmask (SIG_BLOCK, &blocked_mask, prev_mask);
1014 /* Restore child signals mask, previously returned by
1015 block_child_signals. */
1018 restore_child_signals_mask (sigset_t *prev_mask)
1020 sigprocmask (SIG_SETMASK, prev_mask, NULL);
1023 /* Mask of signals to pass directly to the inferior. */
1024 static sigset_t pass_mask;
1026 /* Update signals to pass to the inferior. */
1028 linux_nat_pass_signals (int numsigs, unsigned char *pass_signals)
1032 sigemptyset (&pass_mask);
1034 for (signo = 1; signo < NSIG; signo++)
1036 int target_signo = target_signal_from_host (signo);
1037 if (target_signo < numsigs && pass_signals[target_signo])
1038 sigaddset (&pass_mask, signo);
1044 /* Prototypes for local functions. */
1045 static int stop_wait_callback (struct lwp_info *lp, void *data);
1046 static int linux_thread_alive (ptid_t ptid);
1047 static char *linux_child_pid_to_exec_file (int pid);
1050 /* Convert wait status STATUS to a string. Used for printing debug
1054 status_to_str (int status)
1056 static char buf[64];
1058 if (WIFSTOPPED (status))
1060 if (WSTOPSIG (status) == SYSCALL_SIGTRAP)
1061 snprintf (buf, sizeof (buf), "%s (stopped at syscall)",
1062 strsignal (SIGTRAP));
1064 snprintf (buf, sizeof (buf), "%s (stopped)",
1065 strsignal (WSTOPSIG (status)));
1067 else if (WIFSIGNALED (status))
1068 snprintf (buf, sizeof (buf), "%s (terminated)",
1069 strsignal (WTERMSIG (status)));
1071 snprintf (buf, sizeof (buf), "%d (exited)", WEXITSTATUS (status));
1076 /* Remove all LWPs belong to PID from the lwp list. */
1079 purge_lwp_list (int pid)
1081 struct lwp_info *lp, *lpprev, *lpnext;
1085 for (lp = lwp_list; lp; lp = lpnext)
1089 if (ptid_get_pid (lp->ptid) == pid)
1092 lwp_list = lp->next;
1094 lpprev->next = lp->next;
1103 /* Return the number of known LWPs in the tgid given by PID. */
1109 struct lwp_info *lp;
1111 for (lp = lwp_list; lp; lp = lp->next)
1112 if (ptid_get_pid (lp->ptid) == pid)
1118 /* Add the LWP specified by PID to the list. Return a pointer to the
1119 structure describing the new LWP. The LWP should already be stopped
1120 (with an exception for the very first LWP). */
1122 static struct lwp_info *
1123 add_lwp (ptid_t ptid)
1125 struct lwp_info *lp;
1127 gdb_assert (is_lwp (ptid));
1129 lp = (struct lwp_info *) xmalloc (sizeof (struct lwp_info));
1131 memset (lp, 0, sizeof (struct lwp_info));
1133 lp->last_resume_kind = resume_continue;
1134 lp->waitstatus.kind = TARGET_WAITKIND_IGNORE;
1139 lp->next = lwp_list;
1142 if (num_lwps (GET_PID (ptid)) > 1 && linux_nat_new_thread != NULL)
1143 linux_nat_new_thread (ptid);
1148 /* Remove the LWP specified by PID from the list. */
1151 delete_lwp (ptid_t ptid)
1153 struct lwp_info *lp, *lpprev;
1157 for (lp = lwp_list; lp; lpprev = lp, lp = lp->next)
1158 if (ptid_equal (lp->ptid, ptid))
1165 lpprev->next = lp->next;
1167 lwp_list = lp->next;
1172 /* Return a pointer to the structure describing the LWP corresponding
1173 to PID. If no corresponding LWP could be found, return NULL. */
1175 static struct lwp_info *
1176 find_lwp_pid (ptid_t ptid)
1178 struct lwp_info *lp;
1182 lwp = GET_LWP (ptid);
1184 lwp = GET_PID (ptid);
1186 for (lp = lwp_list; lp; lp = lp->next)
1187 if (lwp == GET_LWP (lp->ptid))
1193 /* Call CALLBACK with its second argument set to DATA for every LWP in
1194 the list. If CALLBACK returns 1 for a particular LWP, return a
1195 pointer to the structure describing that LWP immediately.
1196 Otherwise return NULL. */
1199 iterate_over_lwps (ptid_t filter,
1200 int (*callback) (struct lwp_info *, void *),
1203 struct lwp_info *lp, *lpnext;
1205 for (lp = lwp_list; lp; lp = lpnext)
1209 if (ptid_match (lp->ptid, filter))
1211 if ((*callback) (lp, data))
1219 /* Update our internal state when changing from one checkpoint to
1220 another indicated by NEW_PTID. We can only switch single-threaded
1221 applications, so we only create one new LWP, and the previous list
1225 linux_nat_switch_fork (ptid_t new_ptid)
1227 struct lwp_info *lp;
1229 purge_lwp_list (GET_PID (inferior_ptid));
1231 lp = add_lwp (new_ptid);
1234 /* This changes the thread's ptid while preserving the gdb thread
1235 num. Also changes the inferior pid, while preserving the
1237 thread_change_ptid (inferior_ptid, new_ptid);
1239 /* We've just told GDB core that the thread changed target id, but,
1240 in fact, it really is a different thread, with different register
1242 registers_changed ();
1245 /* Handle the exit of a single thread LP. */
1248 exit_lwp (struct lwp_info *lp)
1250 struct thread_info *th = find_thread_ptid (lp->ptid);
1254 if (print_thread_events)
1255 printf_unfiltered (_("[%s exited]\n"), target_pid_to_str (lp->ptid));
1257 delete_thread (lp->ptid);
1260 delete_lwp (lp->ptid);
1263 /* Detect `T (stopped)' in `/proc/PID/status'.
1264 Other states including `T (tracing stop)' are reported as false. */
1267 pid_is_stopped (pid_t pid)
1273 snprintf (buf, sizeof (buf), "/proc/%d/status", (int) pid);
1274 status_file = fopen (buf, "r");
1275 if (status_file != NULL)
1279 while (fgets (buf, sizeof (buf), status_file))
1281 if (strncmp (buf, "State:", 6) == 0)
1287 if (have_state && strstr (buf, "T (stopped)") != NULL)
1289 fclose (status_file);
1294 /* Wait for the LWP specified by LP, which we have just attached to.
1295 Returns a wait status for that LWP, to cache. */
1298 linux_nat_post_attach_wait (ptid_t ptid, int first, int *cloned,
1301 pid_t new_pid, pid = GET_LWP (ptid);
1304 if (pid_is_stopped (pid))
1306 if (debug_linux_nat)
1307 fprintf_unfiltered (gdb_stdlog,
1308 "LNPAW: Attaching to a stopped process\n");
1310 /* The process is definitely stopped. It is in a job control
1311 stop, unless the kernel predates the TASK_STOPPED /
1312 TASK_TRACED distinction, in which case it might be in a
1313 ptrace stop. Make sure it is in a ptrace stop; from there we
1314 can kill it, signal it, et cetera.
1316 First make sure there is a pending SIGSTOP. Since we are
1317 already attached, the process can not transition from stopped
1318 to running without a PTRACE_CONT; so we know this signal will
1319 go into the queue. The SIGSTOP generated by PTRACE_ATTACH is
1320 probably already in the queue (unless this kernel is old
1321 enough to use TASK_STOPPED for ptrace stops); but since SIGSTOP
1322 is not an RT signal, it can only be queued once. */
1323 kill_lwp (pid, SIGSTOP);
1325 /* Finally, resume the stopped process. This will deliver the SIGSTOP
1326 (or a higher priority signal, just like normal PTRACE_ATTACH). */
1327 ptrace (PTRACE_CONT, pid, 0, 0);
1330 /* Make sure the initial process is stopped. The user-level threads
1331 layer might want to poke around in the inferior, and that won't
1332 work if things haven't stabilized yet. */
1333 new_pid = my_waitpid (pid, &status, 0);
1334 if (new_pid == -1 && errno == ECHILD)
1337 warning (_("%s is a cloned process"), target_pid_to_str (ptid));
1339 /* Try again with __WCLONE to check cloned processes. */
1340 new_pid = my_waitpid (pid, &status, __WCLONE);
1344 gdb_assert (pid == new_pid);
1346 if (!WIFSTOPPED (status))
1348 /* The pid we tried to attach has apparently just exited. */
1349 if (debug_linux_nat)
1350 fprintf_unfiltered (gdb_stdlog, "LNPAW: Failed to stop %d: %s",
1351 pid, status_to_str (status));
1355 if (WSTOPSIG (status) != SIGSTOP)
1358 if (debug_linux_nat)
1359 fprintf_unfiltered (gdb_stdlog,
1360 "LNPAW: Received %s after attaching\n",
1361 status_to_str (status));
1367 /* Attach to the LWP specified by PID. Return 0 if successful, -1 if
1368 the new LWP could not be attached, or 1 if we're already auto
1369 attached to this thread, but haven't processed the
1370 PTRACE_EVENT_CLONE event of its parent thread, so we just ignore
1371 its existance, without considering it an error. */
1374 lin_lwp_attach_lwp (ptid_t ptid)
1376 struct lwp_info *lp;
1380 gdb_assert (is_lwp (ptid));
1382 block_child_signals (&prev_mask);
1384 lp = find_lwp_pid (ptid);
1385 lwpid = GET_LWP (ptid);
1387 /* We assume that we're already attached to any LWP that has an id
1388 equal to the overall process id, and to any LWP that is already
1389 in our list of LWPs. If we're not seeing exit events from threads
1390 and we've had PID wraparound since we last tried to stop all threads,
1391 this assumption might be wrong; fortunately, this is very unlikely
1393 if (lwpid != GET_PID (ptid) && lp == NULL)
1395 int status, cloned = 0, signalled = 0;
1397 if (ptrace (PTRACE_ATTACH, lwpid, 0, 0) < 0)
1399 if (linux_supports_tracefork_flag)
1401 /* If we haven't stopped all threads when we get here,
1402 we may have seen a thread listed in thread_db's list,
1403 but not processed the PTRACE_EVENT_CLONE yet. If
1404 that's the case, ignore this new thread, and let
1405 normal event handling discover it later. */
1406 if (in_pid_list_p (stopped_pids, lwpid))
1408 /* We've already seen this thread stop, but we
1409 haven't seen the PTRACE_EVENT_CLONE extended
1411 restore_child_signals_mask (&prev_mask);
1419 /* See if we've got a stop for this new child
1420 pending. If so, we're already attached. */
1421 new_pid = my_waitpid (lwpid, &status, WNOHANG);
1422 if (new_pid == -1 && errno == ECHILD)
1423 new_pid = my_waitpid (lwpid, &status, __WCLONE | WNOHANG);
1426 if (WIFSTOPPED (status))
1427 add_to_pid_list (&stopped_pids, lwpid, status);
1429 restore_child_signals_mask (&prev_mask);
1435 /* If we fail to attach to the thread, issue a warning,
1436 but continue. One way this can happen is if thread
1437 creation is interrupted; as of Linux kernel 2.6.19, a
1438 bug may place threads in the thread list and then fail
1440 warning (_("Can't attach %s: %s"), target_pid_to_str (ptid),
1441 safe_strerror (errno));
1442 restore_child_signals_mask (&prev_mask);
1446 if (debug_linux_nat)
1447 fprintf_unfiltered (gdb_stdlog,
1448 "LLAL: PTRACE_ATTACH %s, 0, 0 (OK)\n",
1449 target_pid_to_str (ptid));
1451 status = linux_nat_post_attach_wait (ptid, 0, &cloned, &signalled);
1452 if (!WIFSTOPPED (status))
1454 restore_child_signals_mask (&prev_mask);
1458 lp = add_lwp (ptid);
1460 lp->cloned = cloned;
1461 lp->signalled = signalled;
1462 if (WSTOPSIG (status) != SIGSTOP)
1465 lp->status = status;
1468 target_post_attach (GET_LWP (lp->ptid));
1470 if (debug_linux_nat)
1472 fprintf_unfiltered (gdb_stdlog,
1473 "LLAL: waitpid %s received %s\n",
1474 target_pid_to_str (ptid),
1475 status_to_str (status));
1480 /* We assume that the LWP representing the original process is
1481 already stopped. Mark it as stopped in the data structure
1482 that the GNU/linux ptrace layer uses to keep track of
1483 threads. Note that this won't have already been done since
1484 the main thread will have, we assume, been stopped by an
1485 attach from a different layer. */
1487 lp = add_lwp (ptid);
1491 lp->last_resume_kind = resume_stop;
1492 restore_child_signals_mask (&prev_mask);
1497 linux_nat_create_inferior (struct target_ops *ops,
1498 char *exec_file, char *allargs, char **env,
1501 #ifdef HAVE_PERSONALITY
1502 int personality_orig = 0, personality_set = 0;
1503 #endif /* HAVE_PERSONALITY */
1505 /* The fork_child mechanism is synchronous and calls target_wait, so
1506 we have to mask the async mode. */
1508 #ifdef HAVE_PERSONALITY
1509 if (disable_randomization)
1512 personality_orig = personality (0xffffffff);
1513 if (errno == 0 && !(personality_orig & ADDR_NO_RANDOMIZE))
1515 personality_set = 1;
1516 personality (personality_orig | ADDR_NO_RANDOMIZE);
1518 if (errno != 0 || (personality_set
1519 && !(personality (0xffffffff) & ADDR_NO_RANDOMIZE)))
1520 warning (_("Error disabling address space randomization: %s"),
1521 safe_strerror (errno));
1523 #endif /* HAVE_PERSONALITY */
1525 /* Make sure we report all signals during startup. */
1526 linux_nat_pass_signals (0, NULL);
1528 linux_ops->to_create_inferior (ops, exec_file, allargs, env, from_tty);
1530 #ifdef HAVE_PERSONALITY
1531 if (personality_set)
1534 personality (personality_orig);
1536 warning (_("Error restoring address space randomization: %s"),
1537 safe_strerror (errno));
1539 #endif /* HAVE_PERSONALITY */
1543 linux_nat_attach (struct target_ops *ops, char *args, int from_tty)
1545 struct lwp_info *lp;
1549 /* Make sure we report all signals during attach. */
1550 linux_nat_pass_signals (0, NULL);
1552 linux_ops->to_attach (ops, args, from_tty);
1554 /* The ptrace base target adds the main thread with (pid,0,0)
1555 format. Decorate it with lwp info. */
1556 ptid = BUILD_LWP (GET_PID (inferior_ptid), GET_PID (inferior_ptid));
1557 thread_change_ptid (inferior_ptid, ptid);
1559 /* Add the initial process as the first LWP to the list. */
1560 lp = add_lwp (ptid);
1562 status = linux_nat_post_attach_wait (lp->ptid, 1, &lp->cloned,
1564 if (!WIFSTOPPED (status))
1566 if (WIFEXITED (status))
1568 int exit_code = WEXITSTATUS (status);
1570 target_terminal_ours ();
1571 target_mourn_inferior ();
1573 error (_("Unable to attach: program exited normally."));
1575 error (_("Unable to attach: program exited with code %d."),
1578 else if (WIFSIGNALED (status))
1580 enum target_signal signo;
1582 target_terminal_ours ();
1583 target_mourn_inferior ();
1585 signo = target_signal_from_host (WTERMSIG (status));
1586 error (_("Unable to attach: program terminated with signal "
1588 target_signal_to_name (signo),
1589 target_signal_to_string (signo));
1592 internal_error (__FILE__, __LINE__,
1593 _("unexpected status %d for PID %ld"),
1594 status, (long) GET_LWP (ptid));
1599 /* Save the wait status to report later. */
1601 if (debug_linux_nat)
1602 fprintf_unfiltered (gdb_stdlog,
1603 "LNA: waitpid %ld, saving status %s\n",
1604 (long) GET_PID (lp->ptid), status_to_str (status));
1606 lp->status = status;
1608 if (target_can_async_p ())
1609 target_async (inferior_event_handler, 0);
1612 /* Get pending status of LP. */
1614 get_pending_status (struct lwp_info *lp, int *status)
1616 enum target_signal signo = TARGET_SIGNAL_0;
1618 /* If we paused threads momentarily, we may have stored pending
1619 events in lp->status or lp->waitstatus (see stop_wait_callback),
1620 and GDB core hasn't seen any signal for those threads.
1621 Otherwise, the last signal reported to the core is found in the
1622 thread object's stop_signal.
1624 There's a corner case that isn't handled here at present. Only
1625 if the thread stopped with a TARGET_WAITKIND_STOPPED does
1626 stop_signal make sense as a real signal to pass to the inferior.
1627 Some catchpoint related events, like
1628 TARGET_WAITKIND_(V)FORK|EXEC|SYSCALL, have their stop_signal set
1629 to TARGET_SIGNAL_SIGTRAP when the catchpoint triggers. But,
1630 those traps are debug API (ptrace in our case) related and
1631 induced; the inferior wouldn't see them if it wasn't being
1632 traced. Hence, we should never pass them to the inferior, even
1633 when set to pass state. Since this corner case isn't handled by
1634 infrun.c when proceeding with a signal, for consistency, neither
1635 do we handle it here (or elsewhere in the file we check for
1636 signal pass state). Normally SIGTRAP isn't set to pass state, so
1637 this is really a corner case. */
1639 if (lp->waitstatus.kind != TARGET_WAITKIND_IGNORE)
1640 signo = TARGET_SIGNAL_0; /* a pending ptrace event, not a real signal. */
1641 else if (lp->status)
1642 signo = target_signal_from_host (WSTOPSIG (lp->status));
1643 else if (non_stop && !is_executing (lp->ptid))
1645 struct thread_info *tp = find_thread_ptid (lp->ptid);
1647 signo = tp->suspend.stop_signal;
1651 struct target_waitstatus last;
1654 get_last_target_status (&last_ptid, &last);
1656 if (GET_LWP (lp->ptid) == GET_LWP (last_ptid))
1658 struct thread_info *tp = find_thread_ptid (lp->ptid);
1660 signo = tp->suspend.stop_signal;
1666 if (signo == TARGET_SIGNAL_0)
1668 if (debug_linux_nat)
1669 fprintf_unfiltered (gdb_stdlog,
1670 "GPT: lwp %s has no pending signal\n",
1671 target_pid_to_str (lp->ptid));
1673 else if (!signal_pass_state (signo))
1675 if (debug_linux_nat)
1676 fprintf_unfiltered (gdb_stdlog,
1677 "GPT: lwp %s had signal %s, "
1678 "but it is in no pass state\n",
1679 target_pid_to_str (lp->ptid),
1680 target_signal_to_string (signo));
1684 *status = W_STOPCODE (target_signal_to_host (signo));
1686 if (debug_linux_nat)
1687 fprintf_unfiltered (gdb_stdlog,
1688 "GPT: lwp %s has pending signal %s\n",
1689 target_pid_to_str (lp->ptid),
1690 target_signal_to_string (signo));
1697 detach_callback (struct lwp_info *lp, void *data)
1699 gdb_assert (lp->status == 0 || WIFSTOPPED (lp->status));
1701 if (debug_linux_nat && lp->status)
1702 fprintf_unfiltered (gdb_stdlog, "DC: Pending %s for %s on detach.\n",
1703 strsignal (WSTOPSIG (lp->status)),
1704 target_pid_to_str (lp->ptid));
1706 /* If there is a pending SIGSTOP, get rid of it. */
1709 if (debug_linux_nat)
1710 fprintf_unfiltered (gdb_stdlog,
1711 "DC: Sending SIGCONT to %s\n",
1712 target_pid_to_str (lp->ptid));
1714 kill_lwp (GET_LWP (lp->ptid), SIGCONT);
1718 /* We don't actually detach from the LWP that has an id equal to the
1719 overall process id just yet. */
1720 if (GET_LWP (lp->ptid) != GET_PID (lp->ptid))
1724 /* Pass on any pending signal for this LWP. */
1725 get_pending_status (lp, &status);
1728 if (ptrace (PTRACE_DETACH, GET_LWP (lp->ptid), 0,
1729 WSTOPSIG (status)) < 0)
1730 error (_("Can't detach %s: %s"), target_pid_to_str (lp->ptid),
1731 safe_strerror (errno));
1733 if (debug_linux_nat)
1734 fprintf_unfiltered (gdb_stdlog,
1735 "PTRACE_DETACH (%s, %s, 0) (OK)\n",
1736 target_pid_to_str (lp->ptid),
1737 strsignal (WSTOPSIG (status)));
1739 delete_lwp (lp->ptid);
1746 linux_nat_detach (struct target_ops *ops, char *args, int from_tty)
1750 struct lwp_info *main_lwp;
1752 pid = GET_PID (inferior_ptid);
1754 if (target_can_async_p ())
1755 linux_nat_async (NULL, 0);
1757 /* Stop all threads before detaching. ptrace requires that the
1758 thread is stopped to sucessfully detach. */
1759 iterate_over_lwps (pid_to_ptid (pid), stop_callback, NULL);
1760 /* ... and wait until all of them have reported back that
1761 they're no longer running. */
1762 iterate_over_lwps (pid_to_ptid (pid), stop_wait_callback, NULL);
1764 iterate_over_lwps (pid_to_ptid (pid), detach_callback, NULL);
1766 /* Only the initial process should be left right now. */
1767 gdb_assert (num_lwps (GET_PID (inferior_ptid)) == 1);
1769 main_lwp = find_lwp_pid (pid_to_ptid (pid));
1771 /* Pass on any pending signal for the last LWP. */
1772 if ((args == NULL || *args == '\0')
1773 && get_pending_status (main_lwp, &status) != -1
1774 && WIFSTOPPED (status))
1776 /* Put the signal number in ARGS so that inf_ptrace_detach will
1777 pass it along with PTRACE_DETACH. */
1779 sprintf (args, "%d", (int) WSTOPSIG (status));
1780 if (debug_linux_nat)
1781 fprintf_unfiltered (gdb_stdlog,
1782 "LND: Sending signal %s to %s\n",
1784 target_pid_to_str (main_lwp->ptid));
1787 delete_lwp (main_lwp->ptid);
1789 if (forks_exist_p ())
1791 /* Multi-fork case. The current inferior_ptid is being detached
1792 from, but there are other viable forks to debug. Detach from
1793 the current fork, and context-switch to the first
1795 linux_fork_detach (args, from_tty);
1797 if (non_stop && target_can_async_p ())
1798 target_async (inferior_event_handler, 0);
1801 linux_ops->to_detach (ops, args, from_tty);
1807 resume_lwp (struct lwp_info *lp, int step)
1811 struct inferior *inf = find_inferior_pid (GET_PID (lp->ptid));
1813 if (inf->vfork_child != NULL)
1815 if (debug_linux_nat)
1816 fprintf_unfiltered (gdb_stdlog,
1817 "RC: Not resuming %s (vfork parent)\n",
1818 target_pid_to_str (lp->ptid));
1820 else if (lp->status == 0
1821 && lp->waitstatus.kind == TARGET_WAITKIND_IGNORE)
1823 if (debug_linux_nat)
1824 fprintf_unfiltered (gdb_stdlog,
1825 "RC: PTRACE_CONT %s, 0, 0 (resuming sibling)\n",
1826 target_pid_to_str (lp->ptid));
1828 linux_ops->to_resume (linux_ops,
1829 pid_to_ptid (GET_LWP (lp->ptid)),
1830 step, TARGET_SIGNAL_0);
1833 memset (&lp->siginfo, 0, sizeof (lp->siginfo));
1834 lp->stopped_by_watchpoint = 0;
1838 if (debug_linux_nat)
1839 fprintf_unfiltered (gdb_stdlog,
1840 "RC: Not resuming sibling %s (has pending)\n",
1841 target_pid_to_str (lp->ptid));
1846 if (debug_linux_nat)
1847 fprintf_unfiltered (gdb_stdlog,
1848 "RC: Not resuming sibling %s (not stopped)\n",
1849 target_pid_to_str (lp->ptid));
1854 resume_callback (struct lwp_info *lp, void *data)
1861 resume_clear_callback (struct lwp_info *lp, void *data)
1864 lp->last_resume_kind = resume_stop;
1869 resume_set_callback (struct lwp_info *lp, void *data)
1872 lp->last_resume_kind = resume_continue;
1877 linux_nat_resume (struct target_ops *ops,
1878 ptid_t ptid, int step, enum target_signal signo)
1881 struct lwp_info *lp;
1884 if (debug_linux_nat)
1885 fprintf_unfiltered (gdb_stdlog,
1886 "LLR: Preparing to %s %s, %s, inferior_ptid %s\n",
1887 step ? "step" : "resume",
1888 target_pid_to_str (ptid),
1889 (signo != TARGET_SIGNAL_0
1890 ? strsignal (target_signal_to_host (signo)) : "0"),
1891 target_pid_to_str (inferior_ptid));
1893 block_child_signals (&prev_mask);
1895 /* A specific PTID means `step only this process id'. */
1896 resume_many = (ptid_equal (minus_one_ptid, ptid)
1897 || ptid_is_pid (ptid));
1899 /* Mark the lwps we're resuming as resumed. */
1900 iterate_over_lwps (ptid, resume_set_callback, NULL);
1902 /* See if it's the current inferior that should be handled
1905 lp = find_lwp_pid (inferior_ptid);
1907 lp = find_lwp_pid (ptid);
1908 gdb_assert (lp != NULL);
1910 /* Remember if we're stepping. */
1912 lp->last_resume_kind = step ? resume_step : resume_continue;
1914 /* If we have a pending wait status for this thread, there is no
1915 point in resuming the process. But first make sure that
1916 linux_nat_wait won't preemptively handle the event - we
1917 should never take this short-circuit if we are going to
1918 leave LP running, since we have skipped resuming all the
1919 other threads. This bit of code needs to be synchronized
1920 with linux_nat_wait. */
1922 if (lp->status && WIFSTOPPED (lp->status))
1925 && WSTOPSIG (lp->status)
1926 && sigismember (&pass_mask, WSTOPSIG (lp->status)))
1928 if (debug_linux_nat)
1929 fprintf_unfiltered (gdb_stdlog,
1930 "LLR: Not short circuiting for ignored "
1931 "status 0x%x\n", lp->status);
1933 /* FIXME: What should we do if we are supposed to continue
1934 this thread with a signal? */
1935 gdb_assert (signo == TARGET_SIGNAL_0);
1936 signo = target_signal_from_host (WSTOPSIG (lp->status));
1941 if (lp->status || lp->waitstatus.kind != TARGET_WAITKIND_IGNORE)
1943 /* FIXME: What should we do if we are supposed to continue
1944 this thread with a signal? */
1945 gdb_assert (signo == TARGET_SIGNAL_0);
1947 if (debug_linux_nat)
1948 fprintf_unfiltered (gdb_stdlog,
1949 "LLR: Short circuiting for status 0x%x\n",
1952 restore_child_signals_mask (&prev_mask);
1953 if (target_can_async_p ())
1955 target_async (inferior_event_handler, 0);
1956 /* Tell the event loop we have something to process. */
1962 /* Mark LWP as not stopped to prevent it from being continued by
1967 iterate_over_lwps (ptid, resume_callback, NULL);
1969 /* Convert to something the lower layer understands. */
1970 ptid = pid_to_ptid (GET_LWP (lp->ptid));
1972 linux_ops->to_resume (linux_ops, ptid, step, signo);
1973 memset (&lp->siginfo, 0, sizeof (lp->siginfo));
1974 lp->stopped_by_watchpoint = 0;
1976 if (debug_linux_nat)
1977 fprintf_unfiltered (gdb_stdlog,
1978 "LLR: %s %s, %s (resume event thread)\n",
1979 step ? "PTRACE_SINGLESTEP" : "PTRACE_CONT",
1980 target_pid_to_str (ptid),
1981 (signo != TARGET_SIGNAL_0
1982 ? strsignal (target_signal_to_host (signo)) : "0"));
1984 restore_child_signals_mask (&prev_mask);
1985 if (target_can_async_p ())
1986 target_async (inferior_event_handler, 0);
1989 /* Send a signal to an LWP. */
1992 kill_lwp (int lwpid, int signo)
1994 /* Use tkill, if possible, in case we are using nptl threads. If tkill
1995 fails, then we are not using nptl threads and we should be using kill. */
1997 #ifdef HAVE_TKILL_SYSCALL
1999 static int tkill_failed;
2006 ret = syscall (__NR_tkill, lwpid, signo);
2007 if (errno != ENOSYS)
2014 return kill (lwpid, signo);
2017 /* Handle a GNU/Linux syscall trap wait response. If we see a syscall
2018 event, check if the core is interested in it: if not, ignore the
2019 event, and keep waiting; otherwise, we need to toggle the LWP's
2020 syscall entry/exit status, since the ptrace event itself doesn't
2021 indicate it, and report the trap to higher layers. */
2024 linux_handle_syscall_trap (struct lwp_info *lp, int stopping)
2026 struct target_waitstatus *ourstatus = &lp->waitstatus;
2027 struct gdbarch *gdbarch = target_thread_architecture (lp->ptid);
2028 int syscall_number = (int) gdbarch_get_syscall_number (gdbarch, lp->ptid);
2032 /* If we're stopping threads, there's a SIGSTOP pending, which
2033 makes it so that the LWP reports an immediate syscall return,
2034 followed by the SIGSTOP. Skip seeing that "return" using
2035 PTRACE_CONT directly, and let stop_wait_callback collect the
2036 SIGSTOP. Later when the thread is resumed, a new syscall
2037 entry event. If we didn't do this (and returned 0), we'd
2038 leave a syscall entry pending, and our caller, by using
2039 PTRACE_CONT to collect the SIGSTOP, skips the syscall return
2040 itself. Later, when the user re-resumes this LWP, we'd see
2041 another syscall entry event and we'd mistake it for a return.
2043 If stop_wait_callback didn't force the SIGSTOP out of the LWP
2044 (leaving immediately with LWP->signalled set, without issuing
2045 a PTRACE_CONT), it would still be problematic to leave this
2046 syscall enter pending, as later when the thread is resumed,
2047 it would then see the same syscall exit mentioned above,
2048 followed by the delayed SIGSTOP, while the syscall didn't
2049 actually get to execute. It seems it would be even more
2050 confusing to the user. */
2052 if (debug_linux_nat)
2053 fprintf_unfiltered (gdb_stdlog,
2054 "LHST: ignoring syscall %d "
2055 "for LWP %ld (stopping threads), "
2056 "resuming with PTRACE_CONT for SIGSTOP\n",
2058 GET_LWP (lp->ptid));
2060 lp->syscall_state = TARGET_WAITKIND_IGNORE;
2061 ptrace (PTRACE_CONT, GET_LWP (lp->ptid), 0, 0);
2065 if (catch_syscall_enabled ())
2067 /* Always update the entry/return state, even if this particular
2068 syscall isn't interesting to the core now. In async mode,
2069 the user could install a new catchpoint for this syscall
2070 between syscall enter/return, and we'll need to know to
2071 report a syscall return if that happens. */
2072 lp->syscall_state = (lp->syscall_state == TARGET_WAITKIND_SYSCALL_ENTRY
2073 ? TARGET_WAITKIND_SYSCALL_RETURN
2074 : TARGET_WAITKIND_SYSCALL_ENTRY);
2076 if (catching_syscall_number (syscall_number))
2078 /* Alright, an event to report. */
2079 ourstatus->kind = lp->syscall_state;
2080 ourstatus->value.syscall_number = syscall_number;
2082 if (debug_linux_nat)
2083 fprintf_unfiltered (gdb_stdlog,
2084 "LHST: stopping for %s of syscall %d"
2087 == TARGET_WAITKIND_SYSCALL_ENTRY
2088 ? "entry" : "return",
2090 GET_LWP (lp->ptid));
2094 if (debug_linux_nat)
2095 fprintf_unfiltered (gdb_stdlog,
2096 "LHST: ignoring %s of syscall %d "
2098 lp->syscall_state == TARGET_WAITKIND_SYSCALL_ENTRY
2099 ? "entry" : "return",
2101 GET_LWP (lp->ptid));
2105 /* If we had been syscall tracing, and hence used PT_SYSCALL
2106 before on this LWP, it could happen that the user removes all
2107 syscall catchpoints before we get to process this event.
2108 There are two noteworthy issues here:
2110 - When stopped at a syscall entry event, resuming with
2111 PT_STEP still resumes executing the syscall and reports a
2114 - Only PT_SYSCALL catches syscall enters. If we last
2115 single-stepped this thread, then this event can't be a
2116 syscall enter. If we last single-stepped this thread, this
2117 has to be a syscall exit.
2119 The points above mean that the next resume, be it PT_STEP or
2120 PT_CONTINUE, can not trigger a syscall trace event. */
2121 if (debug_linux_nat)
2122 fprintf_unfiltered (gdb_stdlog,
2123 "LHST: caught syscall event "
2124 "with no syscall catchpoints."
2125 " %d for LWP %ld, ignoring\n",
2127 GET_LWP (lp->ptid));
2128 lp->syscall_state = TARGET_WAITKIND_IGNORE;
2131 /* The core isn't interested in this event. For efficiency, avoid
2132 stopping all threads only to have the core resume them all again.
2133 Since we're not stopping threads, if we're still syscall tracing
2134 and not stepping, we can't use PTRACE_CONT here, as we'd miss any
2135 subsequent syscall. Simply resume using the inf-ptrace layer,
2136 which knows when to use PT_SYSCALL or PT_CONTINUE. */
2138 /* Note that gdbarch_get_syscall_number may access registers, hence
2140 registers_changed ();
2141 linux_ops->to_resume (linux_ops, pid_to_ptid (GET_LWP (lp->ptid)),
2142 lp->step, TARGET_SIGNAL_0);
2146 /* Handle a GNU/Linux extended wait response. If we see a clone
2147 event, we need to add the new LWP to our list (and not report the
2148 trap to higher layers). This function returns non-zero if the
2149 event should be ignored and we should wait again. If STOPPING is
2150 true, the new LWP remains stopped, otherwise it is continued. */
2153 linux_handle_extended_wait (struct lwp_info *lp, int status,
2156 int pid = GET_LWP (lp->ptid);
2157 struct target_waitstatus *ourstatus = &lp->waitstatus;
2158 int event = status >> 16;
2160 if (event == PTRACE_EVENT_FORK || event == PTRACE_EVENT_VFORK
2161 || event == PTRACE_EVENT_CLONE)
2163 unsigned long new_pid;
2166 ptrace (PTRACE_GETEVENTMSG, pid, 0, &new_pid);
2168 /* If we haven't already seen the new PID stop, wait for it now. */
2169 if (! pull_pid_from_list (&stopped_pids, new_pid, &status))
2171 /* The new child has a pending SIGSTOP. We can't affect it until it
2172 hits the SIGSTOP, but we're already attached. */
2173 ret = my_waitpid (new_pid, &status,
2174 (event == PTRACE_EVENT_CLONE) ? __WCLONE : 0);
2176 perror_with_name (_("waiting for new child"));
2177 else if (ret != new_pid)
2178 internal_error (__FILE__, __LINE__,
2179 _("wait returned unexpected PID %d"), ret);
2180 else if (!WIFSTOPPED (status))
2181 internal_error (__FILE__, __LINE__,
2182 _("wait returned unexpected status 0x%x"), status);
2185 ourstatus->value.related_pid = ptid_build (new_pid, new_pid, 0);
2187 if (event == PTRACE_EVENT_FORK
2188 && linux_fork_checkpointing_p (GET_PID (lp->ptid)))
2190 /* Handle checkpointing by linux-fork.c here as a special
2191 case. We don't want the follow-fork-mode or 'catch fork'
2192 to interfere with this. */
2194 /* This won't actually modify the breakpoint list, but will
2195 physically remove the breakpoints from the child. */
2196 detach_breakpoints (new_pid);
2198 /* Retain child fork in ptrace (stopped) state. */
2199 if (!find_fork_pid (new_pid))
2202 /* Report as spurious, so that infrun doesn't want to follow
2203 this fork. We're actually doing an infcall in
2205 ourstatus->kind = TARGET_WAITKIND_SPURIOUS;
2206 linux_enable_event_reporting (pid_to_ptid (new_pid));
2208 /* Report the stop to the core. */
2212 if (event == PTRACE_EVENT_FORK)
2213 ourstatus->kind = TARGET_WAITKIND_FORKED;
2214 else if (event == PTRACE_EVENT_VFORK)
2215 ourstatus->kind = TARGET_WAITKIND_VFORKED;
2218 struct lwp_info *new_lp;
2220 ourstatus->kind = TARGET_WAITKIND_IGNORE;
2222 if (debug_linux_nat)
2223 fprintf_unfiltered (gdb_stdlog,
2224 "LHEW: Got clone event "
2225 "from LWP %d, new child is LWP %ld\n",
2228 new_lp = add_lwp (BUILD_LWP (new_pid, GET_PID (lp->ptid)));
2230 new_lp->stopped = 1;
2232 if (WSTOPSIG (status) != SIGSTOP)
2234 /* This can happen if someone starts sending signals to
2235 the new thread before it gets a chance to run, which
2236 have a lower number than SIGSTOP (e.g. SIGUSR1).
2237 This is an unlikely case, and harder to handle for
2238 fork / vfork than for clone, so we do not try - but
2239 we handle it for clone events here. We'll send
2240 the other signal on to the thread below. */
2242 new_lp->signalled = 1;
2246 struct thread_info *tp;
2248 /* When we stop for an event in some other thread, and
2249 pull the thread list just as this thread has cloned,
2250 we'll have seen the new thread in the thread_db list
2251 before handling the CLONE event (glibc's
2252 pthread_create adds the new thread to the thread list
2253 before clone'ing, and has the kernel fill in the
2254 thread's tid on the clone call with
2255 CLONE_PARENT_SETTID). If that happened, and the core
2256 had requested the new thread to stop, we'll have
2257 killed it with SIGSTOP. But since SIGSTOP is not an
2258 RT signal, it can only be queued once. We need to be
2259 careful to not resume the LWP if we wanted it to
2260 stop. In that case, we'll leave the SIGSTOP pending.
2261 It will later be reported as TARGET_SIGNAL_0. */
2262 tp = find_thread_ptid (new_lp->ptid);
2263 if (tp != NULL && tp->stop_requested)
2264 new_lp->last_resume_kind = resume_stop;
2271 /* Add the new thread to GDB's lists as soon as possible
2274 1) the frontend doesn't have to wait for a stop to
2277 2) we tag it with the correct running state. */
2279 /* If the thread_db layer is active, let it know about
2280 this new thread, and add it to GDB's list. */
2281 if (!thread_db_attach_lwp (new_lp->ptid))
2283 /* We're not using thread_db. Add it to GDB's
2285 target_post_attach (GET_LWP (new_lp->ptid));
2286 add_thread (new_lp->ptid);
2291 set_running (new_lp->ptid, 1);
2292 set_executing (new_lp->ptid, 1);
2293 /* thread_db_attach_lwp -> lin_lwp_attach_lwp forced
2295 new_lp->last_resume_kind = resume_continue;
2301 /* We created NEW_LP so it cannot yet contain STATUS. */
2302 gdb_assert (new_lp->status == 0);
2304 /* Save the wait status to report later. */
2305 if (debug_linux_nat)
2306 fprintf_unfiltered (gdb_stdlog,
2307 "LHEW: waitpid of new LWP %ld, "
2308 "saving status %s\n",
2309 (long) GET_LWP (new_lp->ptid),
2310 status_to_str (status));
2311 new_lp->status = status;
2314 /* Note the need to use the low target ops to resume, to
2315 handle resuming with PT_SYSCALL if we have syscall
2319 new_lp->resumed = 1;
2323 gdb_assert (new_lp->last_resume_kind == resume_continue);
2324 if (debug_linux_nat)
2325 fprintf_unfiltered (gdb_stdlog,
2326 "LHEW: resuming new LWP %ld\n",
2327 GET_LWP (new_lp->ptid));
2328 linux_ops->to_resume (linux_ops, pid_to_ptid (new_pid),
2329 0, TARGET_SIGNAL_0);
2330 new_lp->stopped = 0;
2334 if (debug_linux_nat)
2335 fprintf_unfiltered (gdb_stdlog,
2336 "LHEW: resuming parent LWP %d\n", pid);
2337 linux_ops->to_resume (linux_ops, pid_to_ptid (GET_LWP (lp->ptid)),
2338 0, TARGET_SIGNAL_0);
2346 if (event == PTRACE_EVENT_EXEC)
2348 if (debug_linux_nat)
2349 fprintf_unfiltered (gdb_stdlog,
2350 "LHEW: Got exec event from LWP %ld\n",
2351 GET_LWP (lp->ptid));
2353 ourstatus->kind = TARGET_WAITKIND_EXECD;
2354 ourstatus->value.execd_pathname
2355 = xstrdup (linux_child_pid_to_exec_file (pid));
2360 if (event == PTRACE_EVENT_VFORK_DONE)
2362 if (current_inferior ()->waiting_for_vfork_done)
2364 if (debug_linux_nat)
2365 fprintf_unfiltered (gdb_stdlog,
2366 "LHEW: Got expected PTRACE_EVENT_"
2367 "VFORK_DONE from LWP %ld: stopping\n",
2368 GET_LWP (lp->ptid));
2370 ourstatus->kind = TARGET_WAITKIND_VFORK_DONE;
2374 if (debug_linux_nat)
2375 fprintf_unfiltered (gdb_stdlog,
2376 "LHEW: Got PTRACE_EVENT_VFORK_DONE "
2377 "from LWP %ld: resuming\n",
2378 GET_LWP (lp->ptid));
2379 ptrace (PTRACE_CONT, GET_LWP (lp->ptid), 0, 0);
2383 internal_error (__FILE__, __LINE__,
2384 _("unknown ptrace event %d"), event);
2387 /* Return non-zero if LWP is a zombie. */
2390 linux_lwp_is_zombie (long lwp)
2392 char buffer[MAXPATHLEN];
2397 xsnprintf (buffer, sizeof (buffer), "/proc/%ld/status", lwp);
2398 procfile = fopen (buffer, "r");
2399 if (procfile == NULL)
2401 warning (_("unable to open /proc file '%s'"), buffer);
2406 while (fgets (buffer, sizeof (buffer), procfile) != NULL)
2407 if (strncmp (buffer, "State:", 6) == 0)
2412 retval = (have_state
2413 && strcmp (buffer, "State:\tZ (zombie)\n") == 0);
2418 /* Wait for LP to stop. Returns the wait status, or 0 if the LWP has
2422 wait_lwp (struct lwp_info *lp)
2426 int thread_dead = 0;
2429 gdb_assert (!lp->stopped);
2430 gdb_assert (lp->status == 0);
2432 /* Make sure SIGCHLD is blocked for sigsuspend avoiding a race below. */
2433 block_child_signals (&prev_mask);
2437 /* If my_waitpid returns 0 it means the __WCLONE vs. non-__WCLONE kind
2438 was right and we should just call sigsuspend. */
2440 pid = my_waitpid (GET_LWP (lp->ptid), &status, WNOHANG);
2441 if (pid == -1 && errno == ECHILD)
2442 pid = my_waitpid (GET_LWP (lp->ptid), &status, __WCLONE | WNOHANG);
2443 if (pid == -1 && errno == ECHILD)
2445 /* The thread has previously exited. We need to delete it
2446 now because, for some vendor 2.4 kernels with NPTL
2447 support backported, there won't be an exit event unless
2448 it is the main thread. 2.6 kernels will report an exit
2449 event for each thread that exits, as expected. */
2451 if (debug_linux_nat)
2452 fprintf_unfiltered (gdb_stdlog, "WL: %s vanished.\n",
2453 target_pid_to_str (lp->ptid));
2458 /* Bugs 10970, 12702.
2459 Thread group leader may have exited in which case we'll lock up in
2460 waitpid if there are other threads, even if they are all zombies too.
2461 Basically, we're not supposed to use waitpid this way.
2462 __WCLONE is not applicable for the leader so we can't use that.
2463 LINUX_NAT_THREAD_ALIVE cannot be used here as it requires a STOPPED
2464 process; it gets ESRCH both for the zombie and for running processes.
2466 As a workaround, check if we're waiting for the thread group leader and
2467 if it's a zombie, and avoid calling waitpid if it is.
2469 This is racy, what if the tgl becomes a zombie right after we check?
2470 Therefore always use WNOHANG with sigsuspend - it is equivalent to
2471 waiting waitpid but the linux_lwp_is_zombie is safe this way. */
2473 if (GET_PID (lp->ptid) == GET_LWP (lp->ptid)
2474 && linux_lwp_is_zombie (GET_LWP (lp->ptid)))
2477 if (debug_linux_nat)
2478 fprintf_unfiltered (gdb_stdlog,
2479 "WL: Thread group leader %s vanished.\n",
2480 target_pid_to_str (lp->ptid));
2484 /* Wait for next SIGCHLD and try again. This may let SIGCHLD handlers
2485 get invoked despite our caller had them intentionally blocked by
2486 block_child_signals. This is sensitive only to the loop of
2487 linux_nat_wait_1 and there if we get called my_waitpid gets called
2488 again before it gets to sigsuspend so we can safely let the handlers
2489 get executed here. */
2491 sigsuspend (&suspend_mask);
2494 restore_child_signals_mask (&prev_mask);
2498 gdb_assert (pid == GET_LWP (lp->ptid));
2500 if (debug_linux_nat)
2502 fprintf_unfiltered (gdb_stdlog,
2503 "WL: waitpid %s received %s\n",
2504 target_pid_to_str (lp->ptid),
2505 status_to_str (status));
2508 /* Check if the thread has exited. */
2509 if (WIFEXITED (status) || WIFSIGNALED (status))
2512 if (debug_linux_nat)
2513 fprintf_unfiltered (gdb_stdlog, "WL: %s exited.\n",
2514 target_pid_to_str (lp->ptid));
2524 gdb_assert (WIFSTOPPED (status));
2526 /* Handle GNU/Linux's syscall SIGTRAPs. */
2527 if (WIFSTOPPED (status) && WSTOPSIG (status) == SYSCALL_SIGTRAP)
2529 /* No longer need the sysgood bit. The ptrace event ends up
2530 recorded in lp->waitstatus if we care for it. We can carry
2531 on handling the event like a regular SIGTRAP from here
2533 status = W_STOPCODE (SIGTRAP);
2534 if (linux_handle_syscall_trap (lp, 1))
2535 return wait_lwp (lp);
2538 /* Handle GNU/Linux's extended waitstatus for trace events. */
2539 if (WIFSTOPPED (status) && WSTOPSIG (status) == SIGTRAP && status >> 16 != 0)
2541 if (debug_linux_nat)
2542 fprintf_unfiltered (gdb_stdlog,
2543 "WL: Handling extended status 0x%06x\n",
2545 if (linux_handle_extended_wait (lp, status, 1))
2546 return wait_lwp (lp);
2552 /* Save the most recent siginfo for LP. This is currently only called
2553 for SIGTRAP; some ports use the si_addr field for
2554 target_stopped_data_address. In the future, it may also be used to
2555 restore the siginfo of requeued signals. */
2558 save_siginfo (struct lwp_info *lp)
2561 ptrace (PTRACE_GETSIGINFO, GET_LWP (lp->ptid),
2562 (PTRACE_TYPE_ARG3) 0, &lp->siginfo);
2565 memset (&lp->siginfo, 0, sizeof (lp->siginfo));
2568 /* Send a SIGSTOP to LP. */
2571 stop_callback (struct lwp_info *lp, void *data)
2573 if (!lp->stopped && !lp->signalled)
2577 if (debug_linux_nat)
2579 fprintf_unfiltered (gdb_stdlog,
2580 "SC: kill %s **<SIGSTOP>**\n",
2581 target_pid_to_str (lp->ptid));
2584 ret = kill_lwp (GET_LWP (lp->ptid), SIGSTOP);
2585 if (debug_linux_nat)
2587 fprintf_unfiltered (gdb_stdlog,
2588 "SC: lwp kill %d %s\n",
2590 errno ? safe_strerror (errno) : "ERRNO-OK");
2594 gdb_assert (lp->status == 0);
2600 /* Return non-zero if LWP PID has a pending SIGINT. */
2603 linux_nat_has_pending_sigint (int pid)
2605 sigset_t pending, blocked, ignored;
2607 linux_proc_pending_signals (pid, &pending, &blocked, &ignored);
2609 if (sigismember (&pending, SIGINT)
2610 && !sigismember (&ignored, SIGINT))
2616 /* Set a flag in LP indicating that we should ignore its next SIGINT. */
2619 set_ignore_sigint (struct lwp_info *lp, void *data)
2621 /* If a thread has a pending SIGINT, consume it; otherwise, set a
2622 flag to consume the next one. */
2623 if (lp->stopped && lp->status != 0 && WIFSTOPPED (lp->status)
2624 && WSTOPSIG (lp->status) == SIGINT)
2627 lp->ignore_sigint = 1;
2632 /* If LP does not have a SIGINT pending, then clear the ignore_sigint flag.
2633 This function is called after we know the LWP has stopped; if the LWP
2634 stopped before the expected SIGINT was delivered, then it will never have
2635 arrived. Also, if the signal was delivered to a shared queue and consumed
2636 by a different thread, it will never be delivered to this LWP. */
2639 maybe_clear_ignore_sigint (struct lwp_info *lp)
2641 if (!lp->ignore_sigint)
2644 if (!linux_nat_has_pending_sigint (GET_LWP (lp->ptid)))
2646 if (debug_linux_nat)
2647 fprintf_unfiltered (gdb_stdlog,
2648 "MCIS: Clearing bogus flag for %s\n",
2649 target_pid_to_str (lp->ptid));
2650 lp->ignore_sigint = 0;
2654 /* Fetch the possible triggered data watchpoint info and store it in
2657 On some archs, like x86, that use debug registers to set
2658 watchpoints, it's possible that the way to know which watched
2659 address trapped, is to check the register that is used to select
2660 which address to watch. Problem is, between setting the watchpoint
2661 and reading back which data address trapped, the user may change
2662 the set of watchpoints, and, as a consequence, GDB changes the
2663 debug registers in the inferior. To avoid reading back a stale
2664 stopped-data-address when that happens, we cache in LP the fact
2665 that a watchpoint trapped, and the corresponding data address, as
2666 soon as we see LP stop with a SIGTRAP. If GDB changes the debug
2667 registers meanwhile, we have the cached data we can rely on. */
2670 save_sigtrap (struct lwp_info *lp)
2672 struct cleanup *old_chain;
2674 if (linux_ops->to_stopped_by_watchpoint == NULL)
2676 lp->stopped_by_watchpoint = 0;
2680 old_chain = save_inferior_ptid ();
2681 inferior_ptid = lp->ptid;
2683 lp->stopped_by_watchpoint = linux_ops->to_stopped_by_watchpoint ();
2685 if (lp->stopped_by_watchpoint)
2687 if (linux_ops->to_stopped_data_address != NULL)
2688 lp->stopped_data_address_p =
2689 linux_ops->to_stopped_data_address (¤t_target,
2690 &lp->stopped_data_address);
2692 lp->stopped_data_address_p = 0;
2695 do_cleanups (old_chain);
2698 /* See save_sigtrap. */
2701 linux_nat_stopped_by_watchpoint (void)
2703 struct lwp_info *lp = find_lwp_pid (inferior_ptid);
2705 gdb_assert (lp != NULL);
2707 return lp->stopped_by_watchpoint;
2711 linux_nat_stopped_data_address (struct target_ops *ops, CORE_ADDR *addr_p)
2713 struct lwp_info *lp = find_lwp_pid (inferior_ptid);
2715 gdb_assert (lp != NULL);
2717 *addr_p = lp->stopped_data_address;
2719 return lp->stopped_data_address_p;
2722 /* Commonly any breakpoint / watchpoint generate only SIGTRAP. */
2725 sigtrap_is_event (int status)
2727 return WIFSTOPPED (status) && WSTOPSIG (status) == SIGTRAP;
2730 /* SIGTRAP-like events recognizer. */
2732 static int (*linux_nat_status_is_event) (int status) = sigtrap_is_event;
2734 /* Check for SIGTRAP-like events in LP. */
2737 linux_nat_lp_status_is_event (struct lwp_info *lp)
2739 /* We check for lp->waitstatus in addition to lp->status, because we can
2740 have pending process exits recorded in lp->status
2741 and W_EXITCODE(0,0) == 0. We should probably have an additional
2742 lp->status_p flag. */
2744 return (lp->waitstatus.kind == TARGET_WAITKIND_IGNORE
2745 && linux_nat_status_is_event (lp->status));
2748 /* Set alternative SIGTRAP-like events recognizer. If
2749 breakpoint_inserted_here_p there then gdbarch_decr_pc_after_break will be
2753 linux_nat_set_status_is_event (struct target_ops *t,
2754 int (*status_is_event) (int status))
2756 linux_nat_status_is_event = status_is_event;
2759 /* Wait until LP is stopped. */
2762 stop_wait_callback (struct lwp_info *lp, void *data)
2764 struct inferior *inf = find_inferior_pid (GET_PID (lp->ptid));
2766 /* If this is a vfork parent, bail out, it is not going to report
2767 any SIGSTOP until the vfork is done with. */
2768 if (inf->vfork_child != NULL)
2775 status = wait_lwp (lp);
2779 if (lp->ignore_sigint && WIFSTOPPED (status)
2780 && WSTOPSIG (status) == SIGINT)
2782 lp->ignore_sigint = 0;
2785 ptrace (PTRACE_CONT, GET_LWP (lp->ptid), 0, 0);
2786 if (debug_linux_nat)
2787 fprintf_unfiltered (gdb_stdlog,
2788 "PTRACE_CONT %s, 0, 0 (%s) "
2789 "(discarding SIGINT)\n",
2790 target_pid_to_str (lp->ptid),
2791 errno ? safe_strerror (errno) : "OK");
2793 return stop_wait_callback (lp, NULL);
2796 maybe_clear_ignore_sigint (lp);
2798 if (WSTOPSIG (status) != SIGSTOP)
2800 if (linux_nat_status_is_event (status))
2802 /* If a LWP other than the LWP that we're reporting an
2803 event for has hit a GDB breakpoint (as opposed to
2804 some random trap signal), then just arrange for it to
2805 hit it again later. We don't keep the SIGTRAP status
2806 and don't forward the SIGTRAP signal to the LWP. We
2807 will handle the current event, eventually we will
2808 resume all LWPs, and this one will get its breakpoint
2811 If we do not do this, then we run the risk that the
2812 user will delete or disable the breakpoint, but the
2813 thread will have already tripped on it. */
2815 /* Save the trap's siginfo in case we need it later. */
2820 /* Now resume this LWP and get the SIGSTOP event. */
2822 ptrace (PTRACE_CONT, GET_LWP (lp->ptid), 0, 0);
2823 if (debug_linux_nat)
2825 fprintf_unfiltered (gdb_stdlog,
2826 "PTRACE_CONT %s, 0, 0 (%s)\n",
2827 target_pid_to_str (lp->ptid),
2828 errno ? safe_strerror (errno) : "OK");
2830 fprintf_unfiltered (gdb_stdlog,
2831 "SWC: Candidate SIGTRAP event in %s\n",
2832 target_pid_to_str (lp->ptid));
2834 /* Hold this event/waitstatus while we check to see if
2835 there are any more (we still want to get that SIGSTOP). */
2836 stop_wait_callback (lp, NULL);
2838 /* Hold the SIGTRAP for handling by linux_nat_wait. If
2839 there's another event, throw it back into the
2843 if (debug_linux_nat)
2844 fprintf_unfiltered (gdb_stdlog,
2845 "SWC: kill %s, %s\n",
2846 target_pid_to_str (lp->ptid),
2847 status_to_str ((int) status));
2848 kill_lwp (GET_LWP (lp->ptid), WSTOPSIG (lp->status));
2851 /* Save the sigtrap event. */
2852 lp->status = status;
2857 /* The thread was stopped with a signal other than
2858 SIGSTOP, and didn't accidentally trip a breakpoint. */
2860 if (debug_linux_nat)
2862 fprintf_unfiltered (gdb_stdlog,
2863 "SWC: Pending event %s in %s\n",
2864 status_to_str ((int) status),
2865 target_pid_to_str (lp->ptid));
2867 /* Now resume this LWP and get the SIGSTOP event. */
2869 ptrace (PTRACE_CONT, GET_LWP (lp->ptid), 0, 0);
2870 if (debug_linux_nat)
2871 fprintf_unfiltered (gdb_stdlog,
2872 "SWC: PTRACE_CONT %s, 0, 0 (%s)\n",
2873 target_pid_to_str (lp->ptid),
2874 errno ? safe_strerror (errno) : "OK");
2876 /* Hold this event/waitstatus while we check to see if
2877 there are any more (we still want to get that SIGSTOP). */
2878 stop_wait_callback (lp, NULL);
2880 /* If the lp->status field is still empty, use it to
2881 hold this event. If not, then this event must be
2882 returned to the event queue of the LWP. */
2885 if (debug_linux_nat)
2887 fprintf_unfiltered (gdb_stdlog,
2888 "SWC: kill %s, %s\n",
2889 target_pid_to_str (lp->ptid),
2890 status_to_str ((int) status));
2892 kill_lwp (GET_LWP (lp->ptid), WSTOPSIG (status));
2895 lp->status = status;
2901 /* We caught the SIGSTOP that we intended to catch, so
2902 there's no SIGSTOP pending. */
2911 /* Return non-zero if LP has a wait status pending. */
2914 status_callback (struct lwp_info *lp, void *data)
2916 /* Only report a pending wait status if we pretend that this has
2917 indeed been resumed. */
2921 if (lp->waitstatus.kind != TARGET_WAITKIND_IGNORE)
2923 /* A ptrace event, like PTRACE_FORK|VFORK|EXEC, syscall event,
2924 or a pending process exit. Note that `W_EXITCODE(0,0) ==
2925 0', so a clean process exit can not be stored pending in
2926 lp->status, it is indistinguishable from
2927 no-pending-status. */
2931 if (lp->status != 0)
2937 /* Return non-zero if LP isn't stopped. */
2940 running_callback (struct lwp_info *lp, void *data)
2942 return (!lp->stopped
2943 || ((lp->status != 0
2944 || lp->waitstatus.kind != TARGET_WAITKIND_IGNORE)
2948 /* Count the LWP's that have had events. */
2951 count_events_callback (struct lwp_info *lp, void *data)
2955 gdb_assert (count != NULL);
2957 /* Count only resumed LWPs that have a SIGTRAP event pending. */
2958 if (lp->resumed && linux_nat_lp_status_is_event (lp))
2964 /* Select the LWP (if any) that is currently being single-stepped. */
2967 select_singlestep_lwp_callback (struct lwp_info *lp, void *data)
2969 if (lp->last_resume_kind == resume_step
2976 /* Select the Nth LWP that has had a SIGTRAP event. */
2979 select_event_lwp_callback (struct lwp_info *lp, void *data)
2981 int *selector = data;
2983 gdb_assert (selector != NULL);
2985 /* Select only resumed LWPs that have a SIGTRAP event pending. */
2986 if (lp->resumed && linux_nat_lp_status_is_event (lp))
2987 if ((*selector)-- == 0)
2994 cancel_breakpoint (struct lwp_info *lp)
2996 /* Arrange for a breakpoint to be hit again later. We don't keep
2997 the SIGTRAP status and don't forward the SIGTRAP signal to the
2998 LWP. We will handle the current event, eventually we will resume
2999 this LWP, and this breakpoint will trap again.
3001 If we do not do this, then we run the risk that the user will
3002 delete or disable the breakpoint, but the LWP will have already
3005 struct regcache *regcache = get_thread_regcache (lp->ptid);
3006 struct gdbarch *gdbarch = get_regcache_arch (regcache);
3009 pc = regcache_read_pc (regcache) - gdbarch_decr_pc_after_break (gdbarch);
3010 if (breakpoint_inserted_here_p (get_regcache_aspace (regcache), pc))
3012 if (debug_linux_nat)
3013 fprintf_unfiltered (gdb_stdlog,
3014 "CB: Push back breakpoint for %s\n",
3015 target_pid_to_str (lp->ptid));
3017 /* Back up the PC if necessary. */
3018 if (gdbarch_decr_pc_after_break (gdbarch))
3019 regcache_write_pc (regcache, pc);
3027 cancel_breakpoints_callback (struct lwp_info *lp, void *data)
3029 struct lwp_info *event_lp = data;
3031 /* Leave the LWP that has been elected to receive a SIGTRAP alone. */
3035 /* If a LWP other than the LWP that we're reporting an event for has
3036 hit a GDB breakpoint (as opposed to some random trap signal),
3037 then just arrange for it to hit it again later. We don't keep
3038 the SIGTRAP status and don't forward the SIGTRAP signal to the
3039 LWP. We will handle the current event, eventually we will resume
3040 all LWPs, and this one will get its breakpoint trap again.
3042 If we do not do this, then we run the risk that the user will
3043 delete or disable the breakpoint, but the LWP will have already
3046 if (linux_nat_lp_status_is_event (lp)
3047 && cancel_breakpoint (lp))
3048 /* Throw away the SIGTRAP. */
3054 /* Select one LWP out of those that have events pending. */
3057 select_event_lwp (ptid_t filter, struct lwp_info **orig_lp, int *status)
3060 int random_selector;
3061 struct lwp_info *event_lp;
3063 /* Record the wait status for the original LWP. */
3064 (*orig_lp)->status = *status;
3066 /* Give preference to any LWP that is being single-stepped. */
3067 event_lp = iterate_over_lwps (filter,
3068 select_singlestep_lwp_callback, NULL);
3069 if (event_lp != NULL)
3071 if (debug_linux_nat)
3072 fprintf_unfiltered (gdb_stdlog,
3073 "SEL: Select single-step %s\n",
3074 target_pid_to_str (event_lp->ptid));
3078 /* No single-stepping LWP. Select one at random, out of those
3079 which have had SIGTRAP events. */
3081 /* First see how many SIGTRAP events we have. */
3082 iterate_over_lwps (filter, count_events_callback, &num_events);
3084 /* Now randomly pick a LWP out of those that have had a SIGTRAP. */
3085 random_selector = (int)
3086 ((num_events * (double) rand ()) / (RAND_MAX + 1.0));
3088 if (debug_linux_nat && num_events > 1)
3089 fprintf_unfiltered (gdb_stdlog,
3090 "SEL: Found %d SIGTRAP events, selecting #%d\n",
3091 num_events, random_selector);
3093 event_lp = iterate_over_lwps (filter,
3094 select_event_lwp_callback,
3098 if (event_lp != NULL)
3100 /* Switch the event LWP. */
3101 *orig_lp = event_lp;
3102 *status = event_lp->status;
3105 /* Flush the wait status for the event LWP. */
3106 (*orig_lp)->status = 0;
3109 /* Return non-zero if LP has been resumed. */
3112 resumed_callback (struct lwp_info *lp, void *data)
3117 /* Stop an active thread, verify it still exists, then resume it. If
3118 the thread ends up with a pending status, then it is not resumed,
3119 and *DATA (really a pointer to int), is set. */
3122 stop_and_resume_callback (struct lwp_info *lp, void *data)
3124 int *new_pending_p = data;
3128 ptid_t ptid = lp->ptid;
3130 stop_callback (lp, NULL);
3131 stop_wait_callback (lp, NULL);
3133 /* Resume if the lwp still exists, and the core wanted it
3135 lp = find_lwp_pid (ptid);
3138 if (lp->last_resume_kind == resume_stop
3141 /* The core wanted the LWP to stop. Even if it stopped
3142 cleanly (with SIGSTOP), leave the event pending. */
3143 if (debug_linux_nat)
3144 fprintf_unfiltered (gdb_stdlog,
3145 "SARC: core wanted LWP %ld stopped "
3146 "(leaving SIGSTOP pending)\n",
3147 GET_LWP (lp->ptid));
3148 lp->status = W_STOPCODE (SIGSTOP);
3151 if (lp->status == 0)
3153 if (debug_linux_nat)
3154 fprintf_unfiltered (gdb_stdlog,
3155 "SARC: re-resuming LWP %ld\n",
3156 GET_LWP (lp->ptid));
3157 resume_lwp (lp, lp->step);
3161 if (debug_linux_nat)
3162 fprintf_unfiltered (gdb_stdlog,
3163 "SARC: not re-resuming LWP %ld "
3165 GET_LWP (lp->ptid));
3174 /* Check if we should go on and pass this event to common code.
3175 Return the affected lwp if we are, or NULL otherwise. If we stop
3176 all lwps temporarily, we may end up with new pending events in some
3177 other lwp. In that case set *NEW_PENDING_P to true. */
3179 static struct lwp_info *
3180 linux_nat_filter_event (int lwpid, int status, int *new_pending_p)
3182 struct lwp_info *lp;
3186 lp = find_lwp_pid (pid_to_ptid (lwpid));
3188 /* Check for stop events reported by a process we didn't already
3189 know about - anything not already in our LWP list.
3191 If we're expecting to receive stopped processes after
3192 fork, vfork, and clone events, then we'll just add the
3193 new one to our list and go back to waiting for the event
3194 to be reported - the stopped process might be returned
3195 from waitpid before or after the event is.
3197 But note the case of a non-leader thread exec'ing after the
3198 leader having exited, and gone from our lists. The non-leader
3199 thread changes its tid to the tgid. */
3201 if (WIFSTOPPED (status) && lp == NULL
3202 && (WSTOPSIG (status) == SIGTRAP && status >> 16 == PTRACE_EVENT_EXEC))
3204 /* A multi-thread exec after we had seen the leader exiting. */
3205 if (debug_linux_nat)
3206 fprintf_unfiltered (gdb_stdlog,
3207 "LLW: Re-adding thread group leader LWP %d.\n",
3210 lp = add_lwp (BUILD_LWP (lwpid, lwpid));
3213 add_thread (lp->ptid);
3216 if (WIFSTOPPED (status) && !lp)
3218 add_to_pid_list (&stopped_pids, lwpid, status);
3222 /* Make sure we don't report an event for the exit of an LWP not in
3223 our list, i.e. not part of the current process. This can happen
3224 if we detach from a program we originally forked and then it
3226 if (!WIFSTOPPED (status) && !lp)
3229 /* Handle GNU/Linux's syscall SIGTRAPs. */
3230 if (WIFSTOPPED (status) && WSTOPSIG (status) == SYSCALL_SIGTRAP)
3232 /* No longer need the sysgood bit. The ptrace event ends up
3233 recorded in lp->waitstatus if we care for it. We can carry
3234 on handling the event like a regular SIGTRAP from here
3236 status = W_STOPCODE (SIGTRAP);
3237 if (linux_handle_syscall_trap (lp, 0))
3241 /* Handle GNU/Linux's extended waitstatus for trace events. */
3242 if (WIFSTOPPED (status) && WSTOPSIG (status) == SIGTRAP && status >> 16 != 0)
3244 if (debug_linux_nat)
3245 fprintf_unfiltered (gdb_stdlog,
3246 "LLW: Handling extended status 0x%06x\n",
3248 if (linux_handle_extended_wait (lp, status, 0))
3252 if (linux_nat_status_is_event (status))
3254 /* Save the trap's siginfo in case we need it later. */
3260 /* Check if the thread has exited. */
3261 if ((WIFEXITED (status) || WIFSIGNALED (status))
3262 && num_lwps (GET_PID (lp->ptid)) > 1)
3264 /* If this is the main thread, we must stop all threads and verify
3265 if they are still alive. This is because in the nptl thread model
3266 on Linux 2.4, there is no signal issued for exiting LWPs
3267 other than the main thread. We only get the main thread exit
3268 signal once all child threads have already exited. If we
3269 stop all the threads and use the stop_wait_callback to check
3270 if they have exited we can determine whether this signal
3271 should be ignored or whether it means the end of the debugged
3272 application, regardless of which threading model is being
3274 if (GET_PID (lp->ptid) == GET_LWP (lp->ptid))
3277 iterate_over_lwps (pid_to_ptid (GET_PID (lp->ptid)),
3278 stop_and_resume_callback, new_pending_p);
3281 if (debug_linux_nat)
3282 fprintf_unfiltered (gdb_stdlog,
3283 "LLW: %s exited.\n",
3284 target_pid_to_str (lp->ptid));
3286 if (num_lwps (GET_PID (lp->ptid)) > 1)
3288 /* If there is at least one more LWP, then the exit signal
3289 was not the end of the debugged application and should be
3296 /* Check if the current LWP has previously exited. In the nptl
3297 thread model, LWPs other than the main thread do not issue
3298 signals when they exit so we must check whenever the thread has
3299 stopped. A similar check is made in stop_wait_callback(). */
3300 if (num_lwps (GET_PID (lp->ptid)) > 1 && !linux_thread_alive (lp->ptid))
3302 ptid_t ptid = pid_to_ptid (GET_PID (lp->ptid));
3304 if (debug_linux_nat)
3305 fprintf_unfiltered (gdb_stdlog,
3306 "LLW: %s exited.\n",
3307 target_pid_to_str (lp->ptid));
3311 /* Make sure there is at least one thread running. */
3312 gdb_assert (iterate_over_lwps (ptid, running_callback, NULL));
3314 /* Discard the event. */
3318 /* Make sure we don't report a SIGSTOP that we sent ourselves in
3319 an attempt to stop an LWP. */
3321 && WIFSTOPPED (status) && WSTOPSIG (status) == SIGSTOP)
3323 if (debug_linux_nat)
3324 fprintf_unfiltered (gdb_stdlog,
3325 "LLW: Delayed SIGSTOP caught for %s.\n",
3326 target_pid_to_str (lp->ptid));
3330 if (lp->last_resume_kind != resume_stop)
3332 /* This is a delayed SIGSTOP. */
3334 registers_changed ();
3336 linux_ops->to_resume (linux_ops, pid_to_ptid (GET_LWP (lp->ptid)),
3337 lp->step, TARGET_SIGNAL_0);
3338 if (debug_linux_nat)
3339 fprintf_unfiltered (gdb_stdlog,
3340 "LLW: %s %s, 0, 0 (discard SIGSTOP)\n",
3342 "PTRACE_SINGLESTEP" : "PTRACE_CONT",
3343 target_pid_to_str (lp->ptid));
3346 gdb_assert (lp->resumed);
3348 /* Discard the event. */
3353 /* Make sure we don't report a SIGINT that we have already displayed
3354 for another thread. */
3355 if (lp->ignore_sigint
3356 && WIFSTOPPED (status) && WSTOPSIG (status) == SIGINT)
3358 if (debug_linux_nat)
3359 fprintf_unfiltered (gdb_stdlog,
3360 "LLW: Delayed SIGINT caught for %s.\n",
3361 target_pid_to_str (lp->ptid));
3363 /* This is a delayed SIGINT. */
3364 lp->ignore_sigint = 0;
3366 registers_changed ();
3367 linux_ops->to_resume (linux_ops, pid_to_ptid (GET_LWP (lp->ptid)),
3368 lp->step, TARGET_SIGNAL_0);
3369 if (debug_linux_nat)
3370 fprintf_unfiltered (gdb_stdlog,
3371 "LLW: %s %s, 0, 0 (discard SIGINT)\n",
3373 "PTRACE_SINGLESTEP" : "PTRACE_CONT",
3374 target_pid_to_str (lp->ptid));
3377 gdb_assert (lp->resumed);
3379 /* Discard the event. */
3383 /* An interesting event. */
3385 lp->status = status;
3389 /* Detect zombie thread group leaders, and "exit" them. We can't reap
3390 their exits until all other threads in the group have exited. */
3393 check_zombie_leaders (void)
3395 struct inferior *inf;
3399 struct lwp_info *leader_lp;
3404 leader_lp = find_lwp_pid (pid_to_ptid (inf->pid));
3405 if (leader_lp != NULL
3406 /* Check if there are other threads in the group, as we may
3407 have raced with the inferior simply exiting. */
3408 && num_lwps (inf->pid) > 1
3409 && linux_lwp_is_zombie (inf->pid))
3411 if (debug_linux_nat)
3412 fprintf_unfiltered (gdb_stdlog,
3413 "CZL: Thread group leader %d zombie "
3414 "(it exited, or another thread execd).\n",
3417 /* A leader zombie can mean one of two things:
3419 - It exited, and there's an exit status pending
3420 available, or only the leader exited (not the whole
3421 program). In the latter case, we can't waitpid the
3422 leader's exit status until all other threads are gone.
3424 - There are 3 or more threads in the group, and a thread
3425 other than the leader exec'd. On an exec, the Linux
3426 kernel destroys all other threads (except the execing
3427 one) in the thread group, and resets the execing thread's
3428 tid to the tgid. No exit notification is sent for the
3429 execing thread -- from the ptracer's perspective, it
3430 appears as though the execing thread just vanishes.
3431 Until we reap all other threads except the leader and the
3432 execing thread, the leader will be zombie, and the
3433 execing thread will be in `D (disc sleep)'. As soon as
3434 all other threads are reaped, the execing thread changes
3435 it's tid to the tgid, and the previous (zombie) leader
3436 vanishes, giving place to the "new" leader. We could try
3437 distinguishing the exit and exec cases, by waiting once
3438 more, and seeing if something comes out, but it doesn't
3439 sound useful. The previous leader _does_ go away, and
3440 we'll re-add the new one once we see the exec event
3441 (which is just the same as what would happen if the
3442 previous leader did exit voluntarily before some other
3445 if (debug_linux_nat)
3446 fprintf_unfiltered (gdb_stdlog,
3447 "CZL: Thread group leader %d vanished.\n",
3449 exit_lwp (leader_lp);
3455 linux_nat_wait_1 (struct target_ops *ops,
3456 ptid_t ptid, struct target_waitstatus *ourstatus,
3459 static sigset_t prev_mask;
3460 enum resume_kind last_resume_kind;
3461 struct lwp_info *lp;
3464 if (debug_linux_nat)
3465 fprintf_unfiltered (gdb_stdlog, "LLW: enter\n");
3467 /* The first time we get here after starting a new inferior, we may
3468 not have added it to the LWP list yet - this is the earliest
3469 moment at which we know its PID. */
3470 if (ptid_is_pid (inferior_ptid))
3472 /* Upgrade the main thread's ptid. */
3473 thread_change_ptid (inferior_ptid,
3474 BUILD_LWP (GET_PID (inferior_ptid),
3475 GET_PID (inferior_ptid)));
3477 lp = add_lwp (inferior_ptid);
3481 /* Make sure SIGCHLD is blocked. */
3482 block_child_signals (&prev_mask);
3488 /* First check if there is a LWP with a wait status pending. */
3489 if (ptid_equal (ptid, minus_one_ptid) || ptid_is_pid (ptid))
3491 /* Any LWP in the PTID group that's been resumed will do. */
3492 lp = iterate_over_lwps (ptid, status_callback, NULL);
3495 if (debug_linux_nat && lp->status)
3496 fprintf_unfiltered (gdb_stdlog,
3497 "LLW: Using pending wait status %s for %s.\n",
3498 status_to_str (lp->status),
3499 target_pid_to_str (lp->ptid));
3502 else if (is_lwp (ptid))
3504 if (debug_linux_nat)
3505 fprintf_unfiltered (gdb_stdlog,
3506 "LLW: Waiting for specific LWP %s.\n",
3507 target_pid_to_str (ptid));
3509 /* We have a specific LWP to check. */
3510 lp = find_lwp_pid (ptid);
3513 if (debug_linux_nat && lp->status)
3514 fprintf_unfiltered (gdb_stdlog,
3515 "LLW: Using pending wait status %s for %s.\n",
3516 status_to_str (lp->status),
3517 target_pid_to_str (lp->ptid));
3519 /* We check for lp->waitstatus in addition to lp->status,
3520 because we can have pending process exits recorded in
3521 lp->status and W_EXITCODE(0,0) == 0. We should probably have
3522 an additional lp->status_p flag. */
3523 if (lp->status == 0 && lp->waitstatus.kind == TARGET_WAITKIND_IGNORE)
3527 if (lp && lp->signalled && lp->last_resume_kind != resume_stop)
3529 /* A pending SIGSTOP may interfere with the normal stream of
3530 events. In a typical case where interference is a problem,
3531 we have a SIGSTOP signal pending for LWP A while
3532 single-stepping it, encounter an event in LWP B, and take the
3533 pending SIGSTOP while trying to stop LWP A. After processing
3534 the event in LWP B, LWP A is continued, and we'll never see
3535 the SIGTRAP associated with the last time we were
3536 single-stepping LWP A. */
3538 /* Resume the thread. It should halt immediately returning the
3540 registers_changed ();
3541 linux_ops->to_resume (linux_ops, pid_to_ptid (GET_LWP (lp->ptid)),
3542 lp->step, TARGET_SIGNAL_0);
3543 if (debug_linux_nat)
3544 fprintf_unfiltered (gdb_stdlog,
3545 "LLW: %s %s, 0, 0 (expect SIGSTOP)\n",
3546 lp->step ? "PTRACE_SINGLESTEP" : "PTRACE_CONT",
3547 target_pid_to_str (lp->ptid));
3549 gdb_assert (lp->resumed);
3551 /* Catch the pending SIGSTOP. */
3552 status = lp->status;
3555 stop_wait_callback (lp, NULL);
3557 /* If the lp->status field isn't empty, we caught another signal
3558 while flushing the SIGSTOP. Return it back to the event
3559 queue of the LWP, as we already have an event to handle. */
3562 if (debug_linux_nat)
3563 fprintf_unfiltered (gdb_stdlog,
3564 "LLW: kill %s, %s\n",
3565 target_pid_to_str (lp->ptid),
3566 status_to_str (lp->status));
3567 kill_lwp (GET_LWP (lp->ptid), WSTOPSIG (lp->status));
3570 lp->status = status;
3573 if (!target_can_async_p ())
3575 /* Causes SIGINT to be passed on to the attached process. */
3579 /* But if we don't find a pending event, we'll have to wait. */
3585 /* Always use -1 and WNOHANG, due to couple of a kernel/ptrace
3588 - If the thread group leader exits while other threads in the
3589 thread group still exist, waitpid(TGID, ...) hangs. That
3590 waitpid won't return an exit status until the other threads
3591 in the group are reapped.
3593 - When a non-leader thread execs, that thread just vanishes
3594 without reporting an exit (so we'd hang if we waited for it
3595 explicitly in that case). The exec event is reported to
3599 lwpid = my_waitpid (-1, &status, __WCLONE | WNOHANG);
3600 if (lwpid == 0 || (lwpid == -1 && errno == ECHILD))
3601 lwpid = my_waitpid (-1, &status, WNOHANG);
3603 if (debug_linux_nat)
3604 fprintf_unfiltered (gdb_stdlog,
3605 "LNW: waitpid(-1, ...) returned %d, %s\n",
3606 lwpid, errno ? safe_strerror (errno) : "ERRNO-OK");
3610 /* If this is true, then we paused LWPs momentarily, and may
3611 now have pending events to handle. */
3614 if (debug_linux_nat)
3616 fprintf_unfiltered (gdb_stdlog,
3617 "LLW: waitpid %ld received %s\n",
3618 (long) lwpid, status_to_str (status));
3621 lp = linux_nat_filter_event (lwpid, status, &new_pending);
3623 /* STATUS is now no longer valid, use LP->STATUS instead. */
3626 if (lp && !ptid_match (lp->ptid, ptid))
3628 gdb_assert (lp->resumed);
3630 if (debug_linux_nat)
3632 "LWP %ld got an event %06x, leaving pending.\n",
3633 ptid_get_lwp (lp->ptid), lp->status);
3635 if (WIFSTOPPED (lp->status))
3637 if (WSTOPSIG (lp->status) != SIGSTOP)
3639 /* Cancel breakpoint hits. The breakpoint may
3640 be removed before we fetch events from this
3641 process to report to the core. It is best
3642 not to assume the moribund breakpoints
3643 heuristic always handles these cases --- it
3644 could be too many events go through to the
3645 core before this one is handled. All-stop
3646 always cancels breakpoint hits in all
3649 && linux_nat_lp_status_is_event (lp)
3650 && cancel_breakpoint (lp))
3652 /* Throw away the SIGTRAP. */
3655 if (debug_linux_nat)
3657 "LLW: LWP %ld hit a breakpoint while"
3658 " waiting for another process;"
3660 ptid_get_lwp (lp->ptid));
3670 else if (WIFEXITED (lp->status) || WIFSIGNALED (lp->status))
3672 if (debug_linux_nat)
3674 "Process %ld exited while stopping LWPs\n",
3675 ptid_get_lwp (lp->ptid));
3677 /* This was the last lwp in the process. Since
3678 events are serialized to GDB core, and we can't
3679 report this one right now, but GDB core and the
3680 other target layers will want to be notified
3681 about the exit code/signal, leave the status
3682 pending for the next time we're able to report
3685 /* Prevent trying to stop this thread again. We'll
3686 never try to resume it because it has a pending
3690 /* Dead LWP's aren't expected to reported a pending
3694 /* Store the pending event in the waitstatus as
3695 well, because W_EXITCODE(0,0) == 0. */
3696 store_waitstatus (&lp->waitstatus, lp->status);
3705 /* Some LWP now has a pending event. Go all the way
3706 back to check it. */
3712 /* We got an event to report to the core. */
3716 /* Retry until nothing comes out of waitpid. A single
3717 SIGCHLD can indicate more than one child stopped. */
3721 /* Check for zombie thread group leaders. Those can't be reaped
3722 until all other threads in the thread group are. */
3723 check_zombie_leaders ();
3725 /* If there are no resumed children left, bail. We'd be stuck
3726 forever in the sigsuspend call below otherwise. */
3727 if (iterate_over_lwps (ptid, resumed_callback, NULL) == NULL)
3729 if (debug_linux_nat)
3730 fprintf_unfiltered (gdb_stdlog, "LLW: exit (no resumed LWP)\n");
3732 ourstatus->kind = TARGET_WAITKIND_NO_RESUMED;
3734 if (!target_can_async_p ())
3735 clear_sigint_trap ();
3737 restore_child_signals_mask (&prev_mask);
3738 return minus_one_ptid;
3741 /* No interesting event to report to the core. */
3743 if (target_options & TARGET_WNOHANG)
3745 if (debug_linux_nat)
3746 fprintf_unfiltered (gdb_stdlog, "LLW: exit (ignore)\n");
3748 ourstatus->kind = TARGET_WAITKIND_IGNORE;
3749 restore_child_signals_mask (&prev_mask);
3750 return minus_one_ptid;
3753 /* We shouldn't end up here unless we want to try again. */
3754 gdb_assert (lp == NULL);
3756 /* Block until we get an event reported with SIGCHLD. */
3757 sigsuspend (&suspend_mask);
3760 if (!target_can_async_p ())
3761 clear_sigint_trap ();
3765 status = lp->status;
3768 /* Don't report signals that GDB isn't interested in, such as
3769 signals that are neither printed nor stopped upon. Stopping all
3770 threads can be a bit time-consuming so if we want decent
3771 performance with heavily multi-threaded programs, especially when
3772 they're using a high frequency timer, we'd better avoid it if we
3775 if (WIFSTOPPED (status))
3777 enum target_signal signo = target_signal_from_host (WSTOPSIG (status));
3779 /* When using hardware single-step, we need to report every signal.
3780 Otherwise, signals in pass_mask may be short-circuited. */
3782 && WSTOPSIG (status) && sigismember (&pass_mask, WSTOPSIG (status)))
3784 /* FIMXE: kettenis/2001-06-06: Should we resume all threads
3785 here? It is not clear we should. GDB may not expect
3786 other threads to run. On the other hand, not resuming
3787 newly attached threads may cause an unwanted delay in
3788 getting them running. */
3789 registers_changed ();
3790 linux_ops->to_resume (linux_ops, pid_to_ptid (GET_LWP (lp->ptid)),
3792 if (debug_linux_nat)
3793 fprintf_unfiltered (gdb_stdlog,
3794 "LLW: %s %s, %s (preempt 'handle')\n",
3796 "PTRACE_SINGLESTEP" : "PTRACE_CONT",
3797 target_pid_to_str (lp->ptid),
3798 (signo != TARGET_SIGNAL_0
3799 ? strsignal (target_signal_to_host (signo))
3807 /* Only do the below in all-stop, as we currently use SIGINT
3808 to implement target_stop (see linux_nat_stop) in
3810 if (signo == TARGET_SIGNAL_INT && signal_pass_state (signo) == 0)
3812 /* If ^C/BREAK is typed at the tty/console, SIGINT gets
3813 forwarded to the entire process group, that is, all LWPs
3814 will receive it - unless they're using CLONE_THREAD to
3815 share signals. Since we only want to report it once, we
3816 mark it as ignored for all LWPs except this one. */
3817 iterate_over_lwps (pid_to_ptid (ptid_get_pid (ptid)),
3818 set_ignore_sigint, NULL);
3819 lp->ignore_sigint = 0;
3822 maybe_clear_ignore_sigint (lp);
3826 /* This LWP is stopped now. */
3829 if (debug_linux_nat)
3830 fprintf_unfiltered (gdb_stdlog, "LLW: Candidate event %s in %s.\n",
3831 status_to_str (status), target_pid_to_str (lp->ptid));
3835 /* Now stop all other LWP's ... */
3836 iterate_over_lwps (minus_one_ptid, stop_callback, NULL);
3838 /* ... and wait until all of them have reported back that
3839 they're no longer running. */
3840 iterate_over_lwps (minus_one_ptid, stop_wait_callback, NULL);
3842 /* If we're not waiting for a specific LWP, choose an event LWP
3843 from among those that have had events. Giving equal priority
3844 to all LWPs that have had events helps prevent
3846 if (ptid_equal (ptid, minus_one_ptid) || ptid_is_pid (ptid))
3847 select_event_lwp (ptid, &lp, &status);
3849 /* Now that we've selected our final event LWP, cancel any
3850 breakpoints in other LWPs that have hit a GDB breakpoint.
3851 See the comment in cancel_breakpoints_callback to find out
3853 iterate_over_lwps (minus_one_ptid, cancel_breakpoints_callback, lp);
3855 /* We'll need this to determine whether to report a SIGSTOP as
3856 TARGET_WAITKIND_0. Need to take a copy because
3857 resume_clear_callback clears it. */
3858 last_resume_kind = lp->last_resume_kind;
3860 /* In all-stop, from the core's perspective, all LWPs are now
3861 stopped until a new resume action is sent over. */
3862 iterate_over_lwps (minus_one_ptid, resume_clear_callback, NULL);
3867 last_resume_kind = lp->last_resume_kind;
3868 resume_clear_callback (lp, NULL);
3871 if (linux_nat_status_is_event (status))
3873 if (debug_linux_nat)
3874 fprintf_unfiltered (gdb_stdlog,
3875 "LLW: trap ptid is %s.\n",
3876 target_pid_to_str (lp->ptid));
3879 if (lp->waitstatus.kind != TARGET_WAITKIND_IGNORE)
3881 *ourstatus = lp->waitstatus;
3882 lp->waitstatus.kind = TARGET_WAITKIND_IGNORE;
3885 store_waitstatus (ourstatus, status);
3887 if (debug_linux_nat)
3888 fprintf_unfiltered (gdb_stdlog, "LLW: exit\n");
3890 restore_child_signals_mask (&prev_mask);
3892 if (last_resume_kind == resume_stop
3893 && ourstatus->kind == TARGET_WAITKIND_STOPPED
3894 && WSTOPSIG (status) == SIGSTOP)
3896 /* A thread that has been requested to stop by GDB with
3897 target_stop, and it stopped cleanly, so report as SIG0. The
3898 use of SIGSTOP is an implementation detail. */
3899 ourstatus->value.sig = TARGET_SIGNAL_0;
3902 if (ourstatus->kind == TARGET_WAITKIND_EXITED
3903 || ourstatus->kind == TARGET_WAITKIND_SIGNALLED)
3906 lp->core = linux_nat_core_of_thread_1 (lp->ptid);
3911 /* Resume LWPs that are currently stopped without any pending status
3912 to report, but are resumed from the core's perspective. */
3915 resume_stopped_resumed_lwps (struct lwp_info *lp, void *data)
3917 ptid_t *wait_ptid_p = data;
3922 && lp->waitstatus.kind == TARGET_WAITKIND_IGNORE)
3924 gdb_assert (is_executing (lp->ptid));
3926 /* Don't bother if there's a breakpoint at PC that we'd hit
3927 immediately, and we're not waiting for this LWP. */
3928 if (!ptid_match (lp->ptid, *wait_ptid_p))
3930 struct regcache *regcache = get_thread_regcache (lp->ptid);
3931 CORE_ADDR pc = regcache_read_pc (regcache);
3933 if (breakpoint_inserted_here_p (get_regcache_aspace (regcache), pc))
3937 if (debug_linux_nat)
3938 fprintf_unfiltered (gdb_stdlog,
3939 "RSRL: resuming stopped-resumed LWP %s\n",
3940 target_pid_to_str (lp->ptid));
3942 linux_ops->to_resume (linux_ops, pid_to_ptid (GET_LWP (lp->ptid)),
3943 lp->step, TARGET_SIGNAL_0);
3945 memset (&lp->siginfo, 0, sizeof (lp->siginfo));
3946 lp->stopped_by_watchpoint = 0;
3953 linux_nat_wait (struct target_ops *ops,
3954 ptid_t ptid, struct target_waitstatus *ourstatus,
3959 if (debug_linux_nat)
3960 fprintf_unfiltered (gdb_stdlog,
3961 "linux_nat_wait: [%s]\n", target_pid_to_str (ptid));
3963 /* Flush the async file first. */
3964 if (target_can_async_p ())
3965 async_file_flush ();
3967 /* Resume LWPs that are currently stopped without any pending status
3968 to report, but are resumed from the core's perspective. LWPs get
3969 in this state if we find them stopping at a time we're not
3970 interested in reporting the event (target_wait on a
3971 specific_process, for example, see linux_nat_wait_1), and
3972 meanwhile the event became uninteresting. Don't bother resuming
3973 LWPs we're not going to wait for if they'd stop immediately. */
3975 iterate_over_lwps (minus_one_ptid, resume_stopped_resumed_lwps, &ptid);
3977 event_ptid = linux_nat_wait_1 (ops, ptid, ourstatus, target_options);
3979 /* If we requested any event, and something came out, assume there
3980 may be more. If we requested a specific lwp or process, also
3981 assume there may be more. */
3982 if (target_can_async_p ()
3983 && (ourstatus->kind != TARGET_WAITKIND_IGNORE
3984 || !ptid_equal (ptid, minus_one_ptid)))
3987 /* Get ready for the next event. */
3988 if (target_can_async_p ())
3989 target_async (inferior_event_handler, 0);
3995 kill_callback (struct lwp_info *lp, void *data)
3997 /* PTRACE_KILL may resume the inferior. Send SIGKILL first. */
4000 kill (GET_LWP (lp->ptid), SIGKILL);
4001 if (debug_linux_nat)
4002 fprintf_unfiltered (gdb_stdlog,
4003 "KC: kill (SIGKILL) %s, 0, 0 (%s)\n",
4004 target_pid_to_str (lp->ptid),
4005 errno ? safe_strerror (errno) : "OK");
4007 /* Some kernels ignore even SIGKILL for processes under ptrace. */
4010 ptrace (PTRACE_KILL, GET_LWP (lp->ptid), 0, 0);
4011 if (debug_linux_nat)
4012 fprintf_unfiltered (gdb_stdlog,
4013 "KC: PTRACE_KILL %s, 0, 0 (%s)\n",
4014 target_pid_to_str (lp->ptid),
4015 errno ? safe_strerror (errno) : "OK");
4021 kill_wait_callback (struct lwp_info *lp, void *data)
4025 /* We must make sure that there are no pending events (delayed
4026 SIGSTOPs, pending SIGTRAPs, etc.) to make sure the current
4027 program doesn't interfere with any following debugging session. */
4029 /* For cloned processes we must check both with __WCLONE and
4030 without, since the exit status of a cloned process isn't reported
4036 pid = my_waitpid (GET_LWP (lp->ptid), NULL, __WCLONE);
4037 if (pid != (pid_t) -1)
4039 if (debug_linux_nat)
4040 fprintf_unfiltered (gdb_stdlog,
4041 "KWC: wait %s received unknown.\n",
4042 target_pid_to_str (lp->ptid));
4043 /* The Linux kernel sometimes fails to kill a thread
4044 completely after PTRACE_KILL; that goes from the stop
4045 point in do_fork out to the one in
4046 get_signal_to_deliever and waits again. So kill it
4048 kill_callback (lp, NULL);
4051 while (pid == GET_LWP (lp->ptid));
4053 gdb_assert (pid == -1 && errno == ECHILD);
4058 pid = my_waitpid (GET_LWP (lp->ptid), NULL, 0);
4059 if (pid != (pid_t) -1)
4061 if (debug_linux_nat)
4062 fprintf_unfiltered (gdb_stdlog,
4063 "KWC: wait %s received unk.\n",
4064 target_pid_to_str (lp->ptid));
4065 /* See the call to kill_callback above. */
4066 kill_callback (lp, NULL);
4069 while (pid == GET_LWP (lp->ptid));
4071 gdb_assert (pid == -1 && errno == ECHILD);
4076 linux_nat_kill (struct target_ops *ops)
4078 struct target_waitstatus last;
4082 /* If we're stopped while forking and we haven't followed yet,
4083 kill the other task. We need to do this first because the
4084 parent will be sleeping if this is a vfork. */
4086 get_last_target_status (&last_ptid, &last);
4088 if (last.kind == TARGET_WAITKIND_FORKED
4089 || last.kind == TARGET_WAITKIND_VFORKED)
4091 ptrace (PT_KILL, PIDGET (last.value.related_pid), 0, 0);
4095 if (forks_exist_p ())
4096 linux_fork_killall ();
4099 ptid_t ptid = pid_to_ptid (ptid_get_pid (inferior_ptid));
4101 /* Stop all threads before killing them, since ptrace requires
4102 that the thread is stopped to sucessfully PTRACE_KILL. */
4103 iterate_over_lwps (ptid, stop_callback, NULL);
4104 /* ... and wait until all of them have reported back that
4105 they're no longer running. */
4106 iterate_over_lwps (ptid, stop_wait_callback, NULL);
4108 /* Kill all LWP's ... */
4109 iterate_over_lwps (ptid, kill_callback, NULL);
4111 /* ... and wait until we've flushed all events. */
4112 iterate_over_lwps (ptid, kill_wait_callback, NULL);
4115 target_mourn_inferior ();
4119 linux_nat_mourn_inferior (struct target_ops *ops)
4121 purge_lwp_list (ptid_get_pid (inferior_ptid));
4123 if (! forks_exist_p ())
4124 /* Normal case, no other forks available. */
4125 linux_ops->to_mourn_inferior (ops);
4127 /* Multi-fork case. The current inferior_ptid has exited, but
4128 there are other viable forks to debug. Delete the exiting
4129 one and context-switch to the first available. */
4130 linux_fork_mourn_inferior ();
4133 /* Convert a native/host siginfo object, into/from the siginfo in the
4134 layout of the inferiors' architecture. */
4137 siginfo_fixup (struct siginfo *siginfo, gdb_byte *inf_siginfo, int direction)
4141 if (linux_nat_siginfo_fixup != NULL)
4142 done = linux_nat_siginfo_fixup (siginfo, inf_siginfo, direction);
4144 /* If there was no callback, or the callback didn't do anything,
4145 then just do a straight memcpy. */
4149 memcpy (siginfo, inf_siginfo, sizeof (struct siginfo));
4151 memcpy (inf_siginfo, siginfo, sizeof (struct siginfo));
4156 linux_xfer_siginfo (struct target_ops *ops, enum target_object object,
4157 const char *annex, gdb_byte *readbuf,
4158 const gdb_byte *writebuf, ULONGEST offset, LONGEST len)
4161 struct siginfo siginfo;
4162 gdb_byte inf_siginfo[sizeof (struct siginfo)];
4164 gdb_assert (object == TARGET_OBJECT_SIGNAL_INFO);
4165 gdb_assert (readbuf || writebuf);
4167 pid = GET_LWP (inferior_ptid);
4169 pid = GET_PID (inferior_ptid);
4171 if (offset > sizeof (siginfo))
4175 ptrace (PTRACE_GETSIGINFO, pid, (PTRACE_TYPE_ARG3) 0, &siginfo);
4179 /* When GDB is built as a 64-bit application, ptrace writes into
4180 SIGINFO an object with 64-bit layout. Since debugging a 32-bit
4181 inferior with a 64-bit GDB should look the same as debugging it
4182 with a 32-bit GDB, we need to convert it. GDB core always sees
4183 the converted layout, so any read/write will have to be done
4185 siginfo_fixup (&siginfo, inf_siginfo, 0);
4187 if (offset + len > sizeof (siginfo))
4188 len = sizeof (siginfo) - offset;
4190 if (readbuf != NULL)
4191 memcpy (readbuf, inf_siginfo + offset, len);
4194 memcpy (inf_siginfo + offset, writebuf, len);
4196 /* Convert back to ptrace layout before flushing it out. */
4197 siginfo_fixup (&siginfo, inf_siginfo, 1);
4200 ptrace (PTRACE_SETSIGINFO, pid, (PTRACE_TYPE_ARG3) 0, &siginfo);
4209 linux_nat_xfer_partial (struct target_ops *ops, enum target_object object,
4210 const char *annex, gdb_byte *readbuf,
4211 const gdb_byte *writebuf,
4212 ULONGEST offset, LONGEST len)
4214 struct cleanup *old_chain;
4217 if (object == TARGET_OBJECT_SIGNAL_INFO)
4218 return linux_xfer_siginfo (ops, object, annex, readbuf, writebuf,
4221 /* The target is connected but no live inferior is selected. Pass
4222 this request down to a lower stratum (e.g., the executable
4224 if (object == TARGET_OBJECT_MEMORY && ptid_equal (inferior_ptid, null_ptid))
4227 old_chain = save_inferior_ptid ();
4229 if (is_lwp (inferior_ptid))
4230 inferior_ptid = pid_to_ptid (GET_LWP (inferior_ptid));
4232 xfer = linux_ops->to_xfer_partial (ops, object, annex, readbuf, writebuf,
4235 do_cleanups (old_chain);
4240 linux_thread_alive (ptid_t ptid)
4244 gdb_assert (is_lwp (ptid));
4246 /* Send signal 0 instead of anything ptrace, because ptracing a
4247 running thread errors out claiming that the thread doesn't
4249 err = kill_lwp (GET_LWP (ptid), 0);
4251 if (debug_linux_nat)
4252 fprintf_unfiltered (gdb_stdlog,
4253 "LLTA: KILL(SIG0) %s (%s)\n",
4254 target_pid_to_str (ptid),
4255 err ? safe_strerror (tmp_errno) : "OK");
4264 linux_nat_thread_alive (struct target_ops *ops, ptid_t ptid)
4266 return linux_thread_alive (ptid);
4270 linux_nat_pid_to_str (struct target_ops *ops, ptid_t ptid)
4272 static char buf[64];
4275 && (GET_PID (ptid) != GET_LWP (ptid)
4276 || num_lwps (GET_PID (ptid)) > 1))
4278 snprintf (buf, sizeof (buf), "LWP %ld", GET_LWP (ptid));
4282 return normal_pid_to_str (ptid);
4286 linux_nat_thread_name (struct thread_info *thr)
4288 int pid = ptid_get_pid (thr->ptid);
4289 long lwp = ptid_get_lwp (thr->ptid);
4290 #define FORMAT "/proc/%d/task/%ld/comm"
4291 char buf[sizeof (FORMAT) + 30];
4293 char *result = NULL;
4295 snprintf (buf, sizeof (buf), FORMAT, pid, lwp);
4296 comm_file = fopen (buf, "r");
4299 /* Not exported by the kernel, so we define it here. */
4301 static char line[COMM_LEN + 1];
4303 if (fgets (line, sizeof (line), comm_file))
4305 char *nl = strchr (line, '\n');
4322 /* Accepts an integer PID; Returns a string representing a file that
4323 can be opened to get the symbols for the child process. */
4326 linux_child_pid_to_exec_file (int pid)
4328 char *name1, *name2;
4330 name1 = xmalloc (MAXPATHLEN);
4331 name2 = xmalloc (MAXPATHLEN);
4332 make_cleanup (xfree, name1);
4333 make_cleanup (xfree, name2);
4334 memset (name2, 0, MAXPATHLEN);
4336 sprintf (name1, "/proc/%d/exe", pid);
4337 if (readlink (name1, name2, MAXPATHLEN) > 0)
4343 /* Service function for corefiles and info proc. */
4346 read_mapping (FILE *mapfile,
4351 char *device, long long *inode, char *filename)
4353 int ret = fscanf (mapfile, "%llx-%llx %s %llx %s %llx",
4354 addr, endaddr, permissions, offset, device, inode);
4357 if (ret > 0 && ret != EOF)
4359 /* Eat everything up to EOL for the filename. This will prevent
4360 weird filenames (such as one with embedded whitespace) from
4361 confusing this code. It also makes this code more robust in
4362 respect to annotations the kernel may add after the filename.
4364 Note the filename is used for informational purposes
4366 ret += fscanf (mapfile, "%[^\n]\n", filename);
4369 return (ret != 0 && ret != EOF);
4372 /* Fills the "to_find_memory_regions" target vector. Lists the memory
4373 regions in the inferior for a corefile. */
4376 linux_nat_find_memory_regions (find_memory_region_ftype func, void *obfd)
4378 int pid = PIDGET (inferior_ptid);
4379 char mapsfilename[MAXPATHLEN];
4381 long long addr, endaddr, size, offset, inode;
4382 char permissions[8], device[8], filename[MAXPATHLEN];
4383 int read, write, exec;
4384 struct cleanup *cleanup;
4386 /* Compose the filename for the /proc memory map, and open it. */
4387 sprintf (mapsfilename, "/proc/%d/maps", pid);
4388 if ((mapsfile = fopen (mapsfilename, "r")) == NULL)
4389 error (_("Could not open %s."), mapsfilename);
4390 cleanup = make_cleanup_fclose (mapsfile);
4393 fprintf_filtered (gdb_stdout,
4394 "Reading memory regions from %s\n", mapsfilename);
4396 /* Now iterate until end-of-file. */
4397 while (read_mapping (mapsfile, &addr, &endaddr, &permissions[0],
4398 &offset, &device[0], &inode, &filename[0]))
4400 size = endaddr - addr;
4402 /* Get the segment's permissions. */
4403 read = (strchr (permissions, 'r') != 0);
4404 write = (strchr (permissions, 'w') != 0);
4405 exec = (strchr (permissions, 'x') != 0);
4409 fprintf_filtered (gdb_stdout,
4410 "Save segment, %s bytes at %s (%c%c%c)",
4411 plongest (size), paddress (target_gdbarch, addr),
4413 write ? 'w' : ' ', exec ? 'x' : ' ');
4415 fprintf_filtered (gdb_stdout, " for %s", filename);
4416 fprintf_filtered (gdb_stdout, "\n");
4419 /* Invoke the callback function to create the corefile
4421 func (addr, size, read, write, exec, obfd);
4423 do_cleanups (cleanup);
4428 find_signalled_thread (struct thread_info *info, void *data)
4430 if (info->suspend.stop_signal != TARGET_SIGNAL_0
4431 && ptid_get_pid (info->ptid) == ptid_get_pid (inferior_ptid))
4437 static enum target_signal
4438 find_stop_signal (void)
4440 struct thread_info *info =
4441 iterate_over_threads (find_signalled_thread, NULL);
4444 return info->suspend.stop_signal;
4446 return TARGET_SIGNAL_0;
4449 /* Records the thread's register state for the corefile note
4453 linux_nat_do_thread_registers (bfd *obfd, ptid_t ptid,
4454 char *note_data, int *note_size,
4455 enum target_signal stop_signal)
4457 unsigned long lwp = ptid_get_lwp (ptid);
4458 struct gdbarch *gdbarch = target_gdbarch;
4459 struct regcache *regcache = get_thread_arch_regcache (ptid, gdbarch);
4460 const struct regset *regset;
4462 struct cleanup *old_chain;
4463 struct core_regset_section *sect_list;
4466 old_chain = save_inferior_ptid ();
4467 inferior_ptid = ptid;
4468 target_fetch_registers (regcache, -1);
4469 do_cleanups (old_chain);
4471 core_regset_p = gdbarch_regset_from_core_section_p (gdbarch);
4472 sect_list = gdbarch_core_regset_sections (gdbarch);
4474 /* The loop below uses the new struct core_regset_section, which stores
4475 the supported section names and sizes for the core file. Note that
4476 note PRSTATUS needs to be treated specially. But the other notes are
4477 structurally the same, so they can benefit from the new struct. */
4478 if (core_regset_p && sect_list != NULL)
4479 while (sect_list->sect_name != NULL)
4481 regset = gdbarch_regset_from_core_section (gdbarch,
4482 sect_list->sect_name,
4484 gdb_assert (regset && regset->collect_regset);
4485 gdb_regset = xmalloc (sect_list->size);
4486 regset->collect_regset (regset, regcache, -1,
4487 gdb_regset, sect_list->size);
4489 if (strcmp (sect_list->sect_name, ".reg") == 0)
4490 note_data = (char *) elfcore_write_prstatus
4491 (obfd, note_data, note_size,
4492 lwp, target_signal_to_host (stop_signal),
4495 note_data = (char *) elfcore_write_register_note
4496 (obfd, note_data, note_size,
4497 sect_list->sect_name, gdb_regset,
4503 /* For architectures that does not have the struct core_regset_section
4504 implemented, we use the old method. When all the architectures have
4505 the new support, the code below should be deleted. */
4508 gdb_gregset_t gregs;
4509 gdb_fpregset_t fpregs;
4512 && (regset = gdbarch_regset_from_core_section (gdbarch, ".reg",
4514 != NULL && regset->collect_regset != NULL)
4515 regset->collect_regset (regset, regcache, -1,
4516 &gregs, sizeof (gregs));
4518 fill_gregset (regcache, &gregs, -1);
4520 note_data = (char *) elfcore_write_prstatus
4521 (obfd, note_data, note_size, lwp, target_signal_to_host (stop_signal),
4525 && (regset = gdbarch_regset_from_core_section (gdbarch, ".reg2",
4527 != NULL && regset->collect_regset != NULL)
4528 regset->collect_regset (regset, regcache, -1,
4529 &fpregs, sizeof (fpregs));
4531 fill_fpregset (regcache, &fpregs, -1);
4533 note_data = (char *) elfcore_write_prfpreg (obfd,
4536 &fpregs, sizeof (fpregs));
4542 struct linux_nat_corefile_thread_data
4548 enum target_signal stop_signal;
4551 /* Called by gdbthread.c once per thread. Records the thread's
4552 register state for the corefile note section. */
4555 linux_nat_corefile_thread_callback (struct lwp_info *ti, void *data)
4557 struct linux_nat_corefile_thread_data *args = data;
4559 args->note_data = linux_nat_do_thread_registers (args->obfd,
4569 /* Enumerate spufs IDs for process PID. */
4572 iterate_over_spus (int pid, void (*callback) (void *, int), void *data)
4576 struct dirent *entry;
4578 xsnprintf (path, sizeof path, "/proc/%d/fd", pid);
4579 dir = opendir (path);
4584 while ((entry = readdir (dir)) != NULL)
4590 fd = atoi (entry->d_name);
4594 xsnprintf (path, sizeof path, "/proc/%d/fd/%d", pid, fd);
4595 if (stat (path, &st) != 0)
4597 if (!S_ISDIR (st.st_mode))
4600 if (statfs (path, &stfs) != 0)
4602 if (stfs.f_type != SPUFS_MAGIC)
4605 callback (data, fd);
4611 /* Generate corefile notes for SPU contexts. */
4613 struct linux_spu_corefile_data
4621 linux_spu_corefile_callback (void *data, int fd)
4623 struct linux_spu_corefile_data *args = data;
4626 static const char *spu_files[] =
4648 for (i = 0; i < sizeof (spu_files) / sizeof (spu_files[0]); i++)
4650 char annex[32], note_name[32];
4654 xsnprintf (annex, sizeof annex, "%d/%s", fd, spu_files[i]);
4655 spu_len = target_read_alloc (¤t_target, TARGET_OBJECT_SPU,
4659 xsnprintf (note_name, sizeof note_name, "SPU/%s", annex);
4660 args->note_data = elfcore_write_note (args->obfd, args->note_data,
4661 args->note_size, note_name,
4662 NT_SPU, spu_data, spu_len);
4669 linux_spu_make_corefile_notes (bfd *obfd, char *note_data, int *note_size)
4671 struct linux_spu_corefile_data args;
4674 args.note_data = note_data;
4675 args.note_size = note_size;
4677 iterate_over_spus (PIDGET (inferior_ptid),
4678 linux_spu_corefile_callback, &args);
4680 return args.note_data;
4683 /* Fills the "to_make_corefile_note" target vector. Builds the note
4684 section for a corefile, and returns it in a malloc buffer. */
4687 linux_nat_make_corefile_notes (bfd *obfd, int *note_size)
4689 struct linux_nat_corefile_thread_data thread_args;
4690 /* The variable size must be >= sizeof (prpsinfo_t.pr_fname). */
4691 char fname[16] = { '\0' };
4692 /* The variable size must be >= sizeof (prpsinfo_t.pr_psargs). */
4693 char psargs[80] = { '\0' };
4694 char *note_data = NULL;
4695 ptid_t filter = pid_to_ptid (ptid_get_pid (inferior_ptid));
4699 if (get_exec_file (0))
4701 strncpy (fname, lbasename (get_exec_file (0)), sizeof (fname));
4702 strncpy (psargs, get_exec_file (0), sizeof (psargs));
4703 if (get_inferior_args ())
4706 char *psargs_end = psargs + sizeof (psargs);
4708 /* linux_elfcore_write_prpsinfo () handles zero unterminated
4710 string_end = memchr (psargs, 0, sizeof (psargs));
4711 if (string_end != NULL)
4713 *string_end++ = ' ';
4714 strncpy (string_end, get_inferior_args (),
4715 psargs_end - string_end);
4718 note_data = (char *) elfcore_write_prpsinfo (obfd,
4720 note_size, fname, psargs);
4723 /* Dump information for threads. */
4724 thread_args.obfd = obfd;
4725 thread_args.note_data = note_data;
4726 thread_args.note_size = note_size;
4727 thread_args.num_notes = 0;
4728 thread_args.stop_signal = find_stop_signal ();
4729 iterate_over_lwps (filter, linux_nat_corefile_thread_callback, &thread_args);
4730 gdb_assert (thread_args.num_notes != 0);
4731 note_data = thread_args.note_data;
4733 auxv_len = target_read_alloc (¤t_target, TARGET_OBJECT_AUXV,
4737 note_data = elfcore_write_note (obfd, note_data, note_size,
4738 "CORE", NT_AUXV, auxv, auxv_len);
4742 note_data = linux_spu_make_corefile_notes (obfd, note_data, note_size);
4744 make_cleanup (xfree, note_data);
4748 /* Implement the "info proc" command. */
4752 /* Display the default cmdline, cwd and exe outputs. */
4755 /* Display `info proc mappings'. */
4758 /* Display `info proc status'. */
4761 /* Display `info proc stat'. */
4764 /* Display `info proc cmdline'. */
4767 /* Display `info proc exe'. */
4770 /* Display `info proc cwd'. */
4773 /* Display all of the above. */
4778 linux_nat_info_proc_cmd_1 (char *args, enum info_proc_what what, int from_tty)
4780 /* A long is used for pid instead of an int to avoid a loss of precision
4781 compiler warning from the output of strtoul. */
4782 long pid = PIDGET (inferior_ptid);
4784 char buffer[MAXPATHLEN];
4785 char fname1[MAXPATHLEN], fname2[MAXPATHLEN];
4786 int cmdline_f = (what == IP_MINIMAL || what == IP_CMDLINE || what == IP_ALL);
4787 int cwd_f = (what == IP_MINIMAL || what == IP_CWD || what == IP_ALL);
4788 int exe_f = (what == IP_MINIMAL || what == IP_EXE || what == IP_ALL);
4789 int mappings_f = (what == IP_MAPPINGS || what == IP_ALL);
4790 int status_f = (what == IP_STATUS || what == IP_ALL);
4791 int stat_f = (what == IP_STAT || what == IP_ALL);
4794 if (args && isdigit (args[0]))
4795 pid = strtoul (args, &args, 10);
4797 args = skip_spaces (args);
4798 if (args && args[0])
4799 error (_("Too many parameters: %s"), args);
4802 error (_("No current process: you must name one."));
4804 sprintf (fname1, "/proc/%ld", pid);
4805 if (stat (fname1, &dummy) != 0)
4806 error (_("No /proc directory: '%s'"), fname1);
4808 printf_filtered (_("process %ld\n"), pid);
4811 sprintf (fname1, "/proc/%ld/cmdline", pid);
4812 if ((procfile = fopen (fname1, "r")) != NULL)
4814 struct cleanup *cleanup = make_cleanup_fclose (procfile);
4816 if (fgets (buffer, sizeof (buffer), procfile))
4817 printf_filtered ("cmdline = '%s'\n", buffer);
4819 warning (_("unable to read '%s'"), fname1);
4820 do_cleanups (cleanup);
4823 warning (_("unable to open /proc file '%s'"), fname1);
4827 sprintf (fname1, "/proc/%ld/cwd", pid);
4828 memset (fname2, 0, sizeof (fname2));
4829 if (readlink (fname1, fname2, sizeof (fname2)) > 0)
4830 printf_filtered ("cwd = '%s'\n", fname2);
4832 warning (_("unable to read link '%s'"), fname1);
4836 sprintf (fname1, "/proc/%ld/exe", pid);
4837 memset (fname2, 0, sizeof (fname2));
4838 if (readlink (fname1, fname2, sizeof (fname2)) > 0)
4839 printf_filtered ("exe = '%s'\n", fname2);
4841 warning (_("unable to read link '%s'"), fname1);
4845 sprintf (fname1, "/proc/%ld/maps", pid);
4846 if ((procfile = fopen (fname1, "r")) != NULL)
4848 long long addr, endaddr, size, offset, inode;
4849 char permissions[8], device[8], filename[MAXPATHLEN];
4850 struct cleanup *cleanup;
4852 cleanup = make_cleanup_fclose (procfile);
4853 printf_filtered (_("Mapped address spaces:\n\n"));
4854 if (gdbarch_addr_bit (target_gdbarch) == 32)
4856 printf_filtered ("\t%10s %10s %10s %10s %7s\n",
4859 " Size", " Offset", "objfile");
4863 printf_filtered (" %18s %18s %10s %10s %7s\n",
4866 " Size", " Offset", "objfile");
4869 while (read_mapping (procfile, &addr, &endaddr, &permissions[0],
4870 &offset, &device[0], &inode, &filename[0]))
4872 size = endaddr - addr;
4874 /* FIXME: carlton/2003-08-27: Maybe the printf_filtered
4875 calls here (and possibly above) should be abstracted
4876 out into their own functions? Andrew suggests using
4877 a generic local_address_string instead to print out
4878 the addresses; that makes sense to me, too. */
4880 if (gdbarch_addr_bit (target_gdbarch) == 32)
4882 printf_filtered ("\t%#10lx %#10lx %#10x %#10x %7s\n",
4883 (unsigned long) addr, /* FIXME: pr_addr */
4884 (unsigned long) endaddr,
4886 (unsigned int) offset,
4887 filename[0] ? filename : "");
4891 printf_filtered (" %#18lx %#18lx %#10x %#10x %7s\n",
4892 (unsigned long) addr, /* FIXME: pr_addr */
4893 (unsigned long) endaddr,
4895 (unsigned int) offset,
4896 filename[0] ? filename : "");
4900 do_cleanups (cleanup);
4903 warning (_("unable to open /proc file '%s'"), fname1);
4907 sprintf (fname1, "/proc/%ld/status", pid);
4908 if ((procfile = fopen (fname1, "r")) != NULL)
4910 struct cleanup *cleanup = make_cleanup_fclose (procfile);
4912 while (fgets (buffer, sizeof (buffer), procfile) != NULL)
4913 puts_filtered (buffer);
4914 do_cleanups (cleanup);
4917 warning (_("unable to open /proc file '%s'"), fname1);
4921 sprintf (fname1, "/proc/%ld/stat", pid);
4922 if ((procfile = fopen (fname1, "r")) != NULL)
4927 struct cleanup *cleanup = make_cleanup_fclose (procfile);
4929 if (fscanf (procfile, "%d ", &itmp) > 0)
4930 printf_filtered (_("Process: %d\n"), itmp);
4931 if (fscanf (procfile, "(%[^)]) ", &buffer[0]) > 0)
4932 printf_filtered (_("Exec file: %s\n"), buffer);
4933 if (fscanf (procfile, "%c ", &ctmp) > 0)
4934 printf_filtered (_("State: %c\n"), ctmp);
4935 if (fscanf (procfile, "%d ", &itmp) > 0)
4936 printf_filtered (_("Parent process: %d\n"), itmp);
4937 if (fscanf (procfile, "%d ", &itmp) > 0)
4938 printf_filtered (_("Process group: %d\n"), itmp);
4939 if (fscanf (procfile, "%d ", &itmp) > 0)
4940 printf_filtered (_("Session id: %d\n"), itmp);
4941 if (fscanf (procfile, "%d ", &itmp) > 0)
4942 printf_filtered (_("TTY: %d\n"), itmp);
4943 if (fscanf (procfile, "%d ", &itmp) > 0)
4944 printf_filtered (_("TTY owner process group: %d\n"), itmp);
4945 if (fscanf (procfile, "%lu ", <mp) > 0)
4946 printf_filtered (_("Flags: 0x%lx\n"), ltmp);
4947 if (fscanf (procfile, "%lu ", <mp) > 0)
4948 printf_filtered (_("Minor faults (no memory page): %lu\n"),
4949 (unsigned long) ltmp);
4950 if (fscanf (procfile, "%lu ", <mp) > 0)
4951 printf_filtered (_("Minor faults, children: %lu\n"),
4952 (unsigned long) ltmp);
4953 if (fscanf (procfile, "%lu ", <mp) > 0)
4954 printf_filtered (_("Major faults (memory page faults): %lu\n"),
4955 (unsigned long) ltmp);
4956 if (fscanf (procfile, "%lu ", <mp) > 0)
4957 printf_filtered (_("Major faults, children: %lu\n"),
4958 (unsigned long) ltmp);
4959 if (fscanf (procfile, "%ld ", <mp) > 0)
4960 printf_filtered (_("utime: %ld\n"), ltmp);
4961 if (fscanf (procfile, "%ld ", <mp) > 0)
4962 printf_filtered (_("stime: %ld\n"), ltmp);
4963 if (fscanf (procfile, "%ld ", <mp) > 0)
4964 printf_filtered (_("utime, children: %ld\n"), ltmp);
4965 if (fscanf (procfile, "%ld ", <mp) > 0)
4966 printf_filtered (_("stime, children: %ld\n"), ltmp);
4967 if (fscanf (procfile, "%ld ", <mp) > 0)
4968 printf_filtered (_("jiffies remaining in current "
4969 "time slice: %ld\n"), ltmp);
4970 if (fscanf (procfile, "%ld ", <mp) > 0)
4971 printf_filtered (_("'nice' value: %ld\n"), ltmp);
4972 if (fscanf (procfile, "%lu ", <mp) > 0)
4973 printf_filtered (_("jiffies until next timeout: %lu\n"),
4974 (unsigned long) ltmp);
4975 if (fscanf (procfile, "%lu ", <mp) > 0)
4976 printf_filtered (_("jiffies until next SIGALRM: %lu\n"),
4977 (unsigned long) ltmp);
4978 if (fscanf (procfile, "%ld ", <mp) > 0)
4979 printf_filtered (_("start time (jiffies since "
4980 "system boot): %ld\n"), ltmp);
4981 if (fscanf (procfile, "%lu ", <mp) > 0)
4982 printf_filtered (_("Virtual memory size: %lu\n"),
4983 (unsigned long) ltmp);
4984 if (fscanf (procfile, "%lu ", <mp) > 0)
4985 printf_filtered (_("Resident set size: %lu\n"),
4986 (unsigned long) ltmp);
4987 if (fscanf (procfile, "%lu ", <mp) > 0)
4988 printf_filtered (_("rlim: %lu\n"), (unsigned long) ltmp);
4989 if (fscanf (procfile, "%lu ", <mp) > 0)
4990 printf_filtered (_("Start of text: 0x%lx\n"), ltmp);
4991 if (fscanf (procfile, "%lu ", <mp) > 0)
4992 printf_filtered (_("End of text: 0x%lx\n"), ltmp);
4993 if (fscanf (procfile, "%lu ", <mp) > 0)
4994 printf_filtered (_("Start of stack: 0x%lx\n"), ltmp);
4995 #if 0 /* Don't know how architecture-dependent the rest is...
4996 Anyway the signal bitmap info is available from "status". */
4997 if (fscanf (procfile, "%lu ", <mp) > 0) /* FIXME arch? */
4998 printf_filtered (_("Kernel stack pointer: 0x%lx\n"), ltmp);
4999 if (fscanf (procfile, "%lu ", <mp) > 0) /* FIXME arch? */
5000 printf_filtered (_("Kernel instr pointer: 0x%lx\n"), ltmp);
5001 if (fscanf (procfile, "%ld ", <mp) > 0)
5002 printf_filtered (_("Pending signals bitmap: 0x%lx\n"), ltmp);
5003 if (fscanf (procfile, "%ld ", <mp) > 0)
5004 printf_filtered (_("Blocked signals bitmap: 0x%lx\n"), ltmp);
5005 if (fscanf (procfile, "%ld ", <mp) > 0)
5006 printf_filtered (_("Ignored signals bitmap: 0x%lx\n"), ltmp);
5007 if (fscanf (procfile, "%ld ", <mp) > 0)
5008 printf_filtered (_("Catched signals bitmap: 0x%lx\n"), ltmp);
5009 if (fscanf (procfile, "%lu ", <mp) > 0) /* FIXME arch? */
5010 printf_filtered (_("wchan (system call): 0x%lx\n"), ltmp);
5012 do_cleanups (cleanup);
5015 warning (_("unable to open /proc file '%s'"), fname1);
5019 /* Implement `info proc' when given without any futher parameters. */
5022 linux_nat_info_proc_cmd (char *args, int from_tty)
5024 linux_nat_info_proc_cmd_1 (args, IP_MINIMAL, from_tty);
5027 /* Implement `info proc mappings'. */
5030 linux_nat_info_proc_cmd_mappings (char *args, int from_tty)
5032 linux_nat_info_proc_cmd_1 (args, IP_MAPPINGS, from_tty);
5035 /* Implement `info proc stat'. */
5038 linux_nat_info_proc_cmd_stat (char *args, int from_tty)
5040 linux_nat_info_proc_cmd_1 (args, IP_STAT, from_tty);
5043 /* Implement `info proc status'. */
5046 linux_nat_info_proc_cmd_status (char *args, int from_tty)
5048 linux_nat_info_proc_cmd_1 (args, IP_STATUS, from_tty);
5051 /* Implement `info proc cwd'. */
5054 linux_nat_info_proc_cmd_cwd (char *args, int from_tty)
5056 linux_nat_info_proc_cmd_1 (args, IP_CWD, from_tty);
5059 /* Implement `info proc cmdline'. */
5062 linux_nat_info_proc_cmd_cmdline (char *args, int from_tty)
5064 linux_nat_info_proc_cmd_1 (args, IP_CMDLINE, from_tty);
5067 /* Implement `info proc exe'. */
5070 linux_nat_info_proc_cmd_exe (char *args, int from_tty)
5072 linux_nat_info_proc_cmd_1 (args, IP_EXE, from_tty);
5075 /* Implement `info proc all'. */
5078 linux_nat_info_proc_cmd_all (char *args, int from_tty)
5080 linux_nat_info_proc_cmd_1 (args, IP_ALL, from_tty);
5083 /* Implement the to_xfer_partial interface for memory reads using the /proc
5084 filesystem. Because we can use a single read() call for /proc, this
5085 can be much more efficient than banging away at PTRACE_PEEKTEXT,
5086 but it doesn't support writes. */
5089 linux_proc_xfer_partial (struct target_ops *ops, enum target_object object,
5090 const char *annex, gdb_byte *readbuf,
5091 const gdb_byte *writebuf,
5092 ULONGEST offset, LONGEST len)
5098 if (object != TARGET_OBJECT_MEMORY || !readbuf)
5101 /* Don't bother for one word. */
5102 if (len < 3 * sizeof (long))
5105 /* We could keep this file open and cache it - possibly one per
5106 thread. That requires some juggling, but is even faster. */
5107 sprintf (filename, "/proc/%d/mem", PIDGET (inferior_ptid));
5108 fd = open (filename, O_RDONLY | O_LARGEFILE);
5112 /* If pread64 is available, use it. It's faster if the kernel
5113 supports it (only one syscall), and it's 64-bit safe even on
5114 32-bit platforms (for instance, SPARC debugging a SPARC64
5117 if (pread64 (fd, readbuf, len, offset) != len)
5119 if (lseek (fd, offset, SEEK_SET) == -1 || read (fd, readbuf, len) != len)
5130 /* Enumerate spufs IDs for process PID. */
5132 spu_enumerate_spu_ids (int pid, gdb_byte *buf, ULONGEST offset, LONGEST len)
5134 enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch);
5136 LONGEST written = 0;
5139 struct dirent *entry;
5141 xsnprintf (path, sizeof path, "/proc/%d/fd", pid);
5142 dir = opendir (path);
5147 while ((entry = readdir (dir)) != NULL)
5153 fd = atoi (entry->d_name);
5157 xsnprintf (path, sizeof path, "/proc/%d/fd/%d", pid, fd);
5158 if (stat (path, &st) != 0)
5160 if (!S_ISDIR (st.st_mode))
5163 if (statfs (path, &stfs) != 0)
5165 if (stfs.f_type != SPUFS_MAGIC)
5168 if (pos >= offset && pos + 4 <= offset + len)
5170 store_unsigned_integer (buf + pos - offset, 4, byte_order, fd);
5180 /* Implement the to_xfer_partial interface for the TARGET_OBJECT_SPU
5181 object type, using the /proc file system. */
5183 linux_proc_xfer_spu (struct target_ops *ops, enum target_object object,
5184 const char *annex, gdb_byte *readbuf,
5185 const gdb_byte *writebuf,
5186 ULONGEST offset, LONGEST len)
5191 int pid = PIDGET (inferior_ptid);
5198 return spu_enumerate_spu_ids (pid, readbuf, offset, len);
5201 xsnprintf (buf, sizeof buf, "/proc/%d/fd/%s", pid, annex);
5202 fd = open (buf, writebuf? O_WRONLY : O_RDONLY);
5207 && lseek (fd, (off_t) offset, SEEK_SET) != (off_t) offset)
5214 ret = write (fd, writebuf, (size_t) len);
5216 ret = read (fd, readbuf, (size_t) len);
5223 /* Parse LINE as a signal set and add its set bits to SIGS. */
5226 add_line_to_sigset (const char *line, sigset_t *sigs)
5228 int len = strlen (line) - 1;
5232 if (line[len] != '\n')
5233 error (_("Could not parse signal set: %s"), line);
5241 if (*p >= '0' && *p <= '9')
5243 else if (*p >= 'a' && *p <= 'f')
5244 digit = *p - 'a' + 10;
5246 error (_("Could not parse signal set: %s"), line);
5251 sigaddset (sigs, signum + 1);
5253 sigaddset (sigs, signum + 2);
5255 sigaddset (sigs, signum + 3);
5257 sigaddset (sigs, signum + 4);
5263 /* Find process PID's pending signals from /proc/pid/status and set
5267 linux_proc_pending_signals (int pid, sigset_t *pending,
5268 sigset_t *blocked, sigset_t *ignored)
5271 char buffer[MAXPATHLEN], fname[MAXPATHLEN];
5272 struct cleanup *cleanup;
5274 sigemptyset (pending);
5275 sigemptyset (blocked);
5276 sigemptyset (ignored);
5277 sprintf (fname, "/proc/%d/status", pid);
5278 procfile = fopen (fname, "r");
5279 if (procfile == NULL)
5280 error (_("Could not open %s"), fname);
5281 cleanup = make_cleanup_fclose (procfile);
5283 while (fgets (buffer, MAXPATHLEN, procfile) != NULL)
5285 /* Normal queued signals are on the SigPnd line in the status
5286 file. However, 2.6 kernels also have a "shared" pending
5287 queue for delivering signals to a thread group, so check for
5290 Unfortunately some Red Hat kernels include the shared pending
5291 queue but not the ShdPnd status field. */
5293 if (strncmp (buffer, "SigPnd:\t", 8) == 0)
5294 add_line_to_sigset (buffer + 8, pending);
5295 else if (strncmp (buffer, "ShdPnd:\t", 8) == 0)
5296 add_line_to_sigset (buffer + 8, pending);
5297 else if (strncmp (buffer, "SigBlk:\t", 8) == 0)
5298 add_line_to_sigset (buffer + 8, blocked);
5299 else if (strncmp (buffer, "SigIgn:\t", 8) == 0)
5300 add_line_to_sigset (buffer + 8, ignored);
5303 do_cleanups (cleanup);
5307 linux_nat_xfer_osdata (struct target_ops *ops, enum target_object object,
5308 const char *annex, gdb_byte *readbuf,
5309 const gdb_byte *writebuf, ULONGEST offset, LONGEST len)
5311 gdb_assert (object == TARGET_OBJECT_OSDATA);
5313 return linux_common_xfer_osdata (annex, readbuf, offset, len);
5317 linux_xfer_partial (struct target_ops *ops, enum target_object object,
5318 const char *annex, gdb_byte *readbuf,
5319 const gdb_byte *writebuf, ULONGEST offset, LONGEST len)
5323 if (object == TARGET_OBJECT_AUXV)
5324 return memory_xfer_auxv (ops, object, annex, readbuf, writebuf,
5327 if (object == TARGET_OBJECT_OSDATA)
5328 return linux_nat_xfer_osdata (ops, object, annex, readbuf, writebuf,
5331 if (object == TARGET_OBJECT_SPU)
5332 return linux_proc_xfer_spu (ops, object, annex, readbuf, writebuf,
5335 /* GDB calculates all the addresses in possibly larget width of the address.
5336 Address width needs to be masked before its final use - either by
5337 linux_proc_xfer_partial or inf_ptrace_xfer_partial.
5339 Compare ADDR_BIT first to avoid a compiler warning on shift overflow. */
5341 if (object == TARGET_OBJECT_MEMORY)
5343 int addr_bit = gdbarch_addr_bit (target_gdbarch);
5345 if (addr_bit < (sizeof (ULONGEST) * HOST_CHAR_BIT))
5346 offset &= ((ULONGEST) 1 << addr_bit) - 1;
5349 xfer = linux_proc_xfer_partial (ops, object, annex, readbuf, writebuf,
5354 return super_xfer_partial (ops, object, annex, readbuf, writebuf,
5358 /* Create a prototype generic GNU/Linux target. The client can override
5359 it with local methods. */
5362 linux_target_install_ops (struct target_ops *t)
5364 t->to_insert_fork_catchpoint = linux_child_insert_fork_catchpoint;
5365 t->to_remove_fork_catchpoint = linux_child_remove_fork_catchpoint;
5366 t->to_insert_vfork_catchpoint = linux_child_insert_vfork_catchpoint;
5367 t->to_remove_vfork_catchpoint = linux_child_remove_vfork_catchpoint;
5368 t->to_insert_exec_catchpoint = linux_child_insert_exec_catchpoint;
5369 t->to_remove_exec_catchpoint = linux_child_remove_exec_catchpoint;
5370 t->to_set_syscall_catchpoint = linux_child_set_syscall_catchpoint;
5371 t->to_pid_to_exec_file = linux_child_pid_to_exec_file;
5372 t->to_post_startup_inferior = linux_child_post_startup_inferior;
5373 t->to_post_attach = linux_child_post_attach;
5374 t->to_follow_fork = linux_child_follow_fork;
5375 t->to_find_memory_regions = linux_nat_find_memory_regions;
5376 t->to_make_corefile_notes = linux_nat_make_corefile_notes;
5378 super_xfer_partial = t->to_xfer_partial;
5379 t->to_xfer_partial = linux_xfer_partial;
5385 struct target_ops *t;
5387 t = inf_ptrace_target ();
5388 linux_target_install_ops (t);
5394 linux_trad_target (CORE_ADDR (*register_u_offset)(struct gdbarch *, int, int))
5396 struct target_ops *t;
5398 t = inf_ptrace_trad_target (register_u_offset);
5399 linux_target_install_ops (t);
5404 /* target_is_async_p implementation. */
5407 linux_nat_is_async_p (void)
5409 /* NOTE: palves 2008-03-21: We're only async when the user requests
5410 it explicitly with the "set target-async" command.
5411 Someday, linux will always be async. */
5412 return target_async_permitted;
5415 /* target_can_async_p implementation. */
5418 linux_nat_can_async_p (void)
5420 /* NOTE: palves 2008-03-21: We're only async when the user requests
5421 it explicitly with the "set target-async" command.
5422 Someday, linux will always be async. */
5423 return target_async_permitted;
5427 linux_nat_supports_non_stop (void)
5432 /* True if we want to support multi-process. To be removed when GDB
5433 supports multi-exec. */
5435 int linux_multi_process = 1;
5438 linux_nat_supports_multi_process (void)
5440 return linux_multi_process;
5444 linux_nat_supports_disable_randomization (void)
5446 #ifdef HAVE_PERSONALITY
5453 static int async_terminal_is_ours = 1;
5455 /* target_terminal_inferior implementation. */
5458 linux_nat_terminal_inferior (void)
5460 if (!target_is_async_p ())
5462 /* Async mode is disabled. */
5463 terminal_inferior ();
5467 terminal_inferior ();
5469 /* Calls to target_terminal_*() are meant to be idempotent. */
5470 if (!async_terminal_is_ours)
5473 delete_file_handler (input_fd);
5474 async_terminal_is_ours = 0;
5478 /* target_terminal_ours implementation. */
5481 linux_nat_terminal_ours (void)
5483 if (!target_is_async_p ())
5485 /* Async mode is disabled. */
5490 /* GDB should never give the terminal to the inferior if the
5491 inferior is running in the background (run&, continue&, etc.),
5492 but claiming it sure should. */
5495 if (async_terminal_is_ours)
5498 clear_sigint_trap ();
5499 add_file_handler (input_fd, stdin_event_handler, 0);
5500 async_terminal_is_ours = 1;
5503 static void (*async_client_callback) (enum inferior_event_type event_type,
5505 static void *async_client_context;
5507 /* SIGCHLD handler that serves two purposes: In non-stop/async mode,
5508 so we notice when any child changes state, and notify the
5509 event-loop; it allows us to use sigsuspend in linux_nat_wait_1
5510 above to wait for the arrival of a SIGCHLD. */
5513 sigchld_handler (int signo)
5515 int old_errno = errno;
5517 if (debug_linux_nat)
5518 ui_file_write_async_safe (gdb_stdlog,
5519 "sigchld\n", sizeof ("sigchld\n") - 1);
5521 if (signo == SIGCHLD
5522 && linux_nat_event_pipe[0] != -1)
5523 async_file_mark (); /* Let the event loop know that there are
5524 events to handle. */
5529 /* Callback registered with the target events file descriptor. */
5532 handle_target_event (int error, gdb_client_data client_data)
5534 (*async_client_callback) (INF_REG_EVENT, async_client_context);
5537 /* Create/destroy the target events pipe. Returns previous state. */
5540 linux_async_pipe (int enable)
5542 int previous = (linux_nat_event_pipe[0] != -1);
5544 if (previous != enable)
5548 block_child_signals (&prev_mask);
5552 if (pipe (linux_nat_event_pipe) == -1)
5553 internal_error (__FILE__, __LINE__,
5554 "creating event pipe failed.");
5556 fcntl (linux_nat_event_pipe[0], F_SETFL, O_NONBLOCK);
5557 fcntl (linux_nat_event_pipe[1], F_SETFL, O_NONBLOCK);
5561 close (linux_nat_event_pipe[0]);
5562 close (linux_nat_event_pipe[1]);
5563 linux_nat_event_pipe[0] = -1;
5564 linux_nat_event_pipe[1] = -1;
5567 restore_child_signals_mask (&prev_mask);
5573 /* target_async implementation. */
5576 linux_nat_async (void (*callback) (enum inferior_event_type event_type,
5577 void *context), void *context)
5579 if (callback != NULL)
5581 async_client_callback = callback;
5582 async_client_context = context;
5583 if (!linux_async_pipe (1))
5585 add_file_handler (linux_nat_event_pipe[0],
5586 handle_target_event, NULL);
5587 /* There may be pending events to handle. Tell the event loop
5594 async_client_callback = callback;
5595 async_client_context = context;
5596 delete_file_handler (linux_nat_event_pipe[0]);
5597 linux_async_pipe (0);
5602 /* Stop an LWP, and push a TARGET_SIGNAL_0 stop status if no other
5606 linux_nat_stop_lwp (struct lwp_info *lwp, void *data)
5610 ptid_t ptid = lwp->ptid;
5612 if (debug_linux_nat)
5613 fprintf_unfiltered (gdb_stdlog,
5614 "LNSL: running -> suspending %s\n",
5615 target_pid_to_str (lwp->ptid));
5618 if (lwp->last_resume_kind == resume_stop)
5620 if (debug_linux_nat)
5621 fprintf_unfiltered (gdb_stdlog,
5622 "linux-nat: already stopping LWP %ld at "
5624 ptid_get_lwp (lwp->ptid));
5628 stop_callback (lwp, NULL);
5629 lwp->last_resume_kind = resume_stop;
5633 /* Already known to be stopped; do nothing. */
5635 if (debug_linux_nat)
5637 if (find_thread_ptid (lwp->ptid)->stop_requested)
5638 fprintf_unfiltered (gdb_stdlog,
5639 "LNSL: already stopped/stop_requested %s\n",
5640 target_pid_to_str (lwp->ptid));
5642 fprintf_unfiltered (gdb_stdlog,
5643 "LNSL: already stopped/no "
5644 "stop_requested yet %s\n",
5645 target_pid_to_str (lwp->ptid));
5652 linux_nat_stop (ptid_t ptid)
5655 iterate_over_lwps (ptid, linux_nat_stop_lwp, NULL);
5657 linux_ops->to_stop (ptid);
5661 linux_nat_close (int quitting)
5663 /* Unregister from the event loop. */
5664 if (target_is_async_p ())
5665 target_async (NULL, 0);
5667 if (linux_ops->to_close)
5668 linux_ops->to_close (quitting);
5671 /* When requests are passed down from the linux-nat layer to the
5672 single threaded inf-ptrace layer, ptids of (lwpid,0,0) form are
5673 used. The address space pointer is stored in the inferior object,
5674 but the common code that is passed such ptid can't tell whether
5675 lwpid is a "main" process id or not (it assumes so). We reverse
5676 look up the "main" process id from the lwp here. */
5678 struct address_space *
5679 linux_nat_thread_address_space (struct target_ops *t, ptid_t ptid)
5681 struct lwp_info *lwp;
5682 struct inferior *inf;
5685 pid = GET_LWP (ptid);
5686 if (GET_LWP (ptid) == 0)
5688 /* An (lwpid,0,0) ptid. Look up the lwp object to get at the
5690 lwp = find_lwp_pid (ptid);
5691 pid = GET_PID (lwp->ptid);
5695 /* A (pid,lwpid,0) ptid. */
5696 pid = GET_PID (ptid);
5699 inf = find_inferior_pid (pid);
5700 gdb_assert (inf != NULL);
5705 linux_nat_core_of_thread_1 (ptid_t ptid)
5707 struct cleanup *back_to;
5710 char *content = NULL;
5713 int content_read = 0;
5717 filename = xstrprintf ("/proc/%d/task/%ld/stat",
5718 GET_PID (ptid), GET_LWP (ptid));
5719 back_to = make_cleanup (xfree, filename);
5721 f = fopen (filename, "r");
5724 do_cleanups (back_to);
5728 make_cleanup_fclose (f);
5734 content = xrealloc (content, content_read + 1024);
5735 n = fread (content + content_read, 1, 1024, f);
5739 content[content_read] = '\0';
5744 make_cleanup (xfree, content);
5746 p = strchr (content, '(');
5750 p = strchr (p, ')');
5754 /* If the first field after program name has index 0, then core number is
5755 the field with index 36. There's no constant for that anywhere. */
5757 p = strtok_r (p, " ", &ts);
5758 for (i = 0; p != NULL && i != 36; ++i)
5759 p = strtok_r (NULL, " ", &ts);
5761 if (p == NULL || sscanf (p, "%d", &core) == 0)
5764 do_cleanups (back_to);
5769 /* Return the cached value of the processor core for thread PTID. */
5772 linux_nat_core_of_thread (struct target_ops *ops, ptid_t ptid)
5774 struct lwp_info *info = find_lwp_pid (ptid);
5782 linux_nat_add_target (struct target_ops *t)
5784 /* Save the provided single-threaded target. We save this in a separate
5785 variable because another target we've inherited from (e.g. inf-ptrace)
5786 may have saved a pointer to T; we want to use it for the final
5787 process stratum target. */
5788 linux_ops_saved = *t;
5789 linux_ops = &linux_ops_saved;
5791 /* Override some methods for multithreading. */
5792 t->to_create_inferior = linux_nat_create_inferior;
5793 t->to_attach = linux_nat_attach;
5794 t->to_detach = linux_nat_detach;
5795 t->to_resume = linux_nat_resume;
5796 t->to_wait = linux_nat_wait;
5797 t->to_pass_signals = linux_nat_pass_signals;
5798 t->to_xfer_partial = linux_nat_xfer_partial;
5799 t->to_kill = linux_nat_kill;
5800 t->to_mourn_inferior = linux_nat_mourn_inferior;
5801 t->to_thread_alive = linux_nat_thread_alive;
5802 t->to_pid_to_str = linux_nat_pid_to_str;
5803 t->to_thread_name = linux_nat_thread_name;
5804 t->to_has_thread_control = tc_schedlock;
5805 t->to_thread_address_space = linux_nat_thread_address_space;
5806 t->to_stopped_by_watchpoint = linux_nat_stopped_by_watchpoint;
5807 t->to_stopped_data_address = linux_nat_stopped_data_address;
5809 t->to_can_async_p = linux_nat_can_async_p;
5810 t->to_is_async_p = linux_nat_is_async_p;
5811 t->to_supports_non_stop = linux_nat_supports_non_stop;
5812 t->to_async = linux_nat_async;
5813 t->to_terminal_inferior = linux_nat_terminal_inferior;
5814 t->to_terminal_ours = linux_nat_terminal_ours;
5815 t->to_close = linux_nat_close;
5817 /* Methods for non-stop support. */
5818 t->to_stop = linux_nat_stop;
5820 t->to_supports_multi_process = linux_nat_supports_multi_process;
5822 t->to_supports_disable_randomization
5823 = linux_nat_supports_disable_randomization;
5825 t->to_core_of_thread = linux_nat_core_of_thread;
5827 /* We don't change the stratum; this target will sit at
5828 process_stratum and thread_db will set at thread_stratum. This
5829 is a little strange, since this is a multi-threaded-capable
5830 target, but we want to be on the stack below thread_db, and we
5831 also want to be used for single-threaded processes. */
5836 /* Register a method to call whenever a new thread is attached. */
5838 linux_nat_set_new_thread (struct target_ops *t, void (*new_thread) (ptid_t))
5840 /* Save the pointer. We only support a single registered instance
5841 of the GNU/Linux native target, so we do not need to map this to
5843 linux_nat_new_thread = new_thread;
5846 /* Register a method that converts a siginfo object between the layout
5847 that ptrace returns, and the layout in the architecture of the
5850 linux_nat_set_siginfo_fixup (struct target_ops *t,
5851 int (*siginfo_fixup) (struct siginfo *,
5855 /* Save the pointer. */
5856 linux_nat_siginfo_fixup = siginfo_fixup;
5859 /* Return the saved siginfo associated with PTID. */
5861 linux_nat_get_siginfo (ptid_t ptid)
5863 struct lwp_info *lp = find_lwp_pid (ptid);
5865 gdb_assert (lp != NULL);
5867 return &lp->siginfo;
5870 /* Provide a prototype to silence -Wmissing-prototypes. */
5871 extern initialize_file_ftype _initialize_linux_nat;
5874 _initialize_linux_nat (void)
5876 static struct cmd_list_element *info_proc_cmdlist;
5878 add_prefix_cmd ("proc", class_info, linux_nat_info_proc_cmd,
5880 Show /proc process information about any running process.\n\
5881 Specify any process id, or use the program being debugged by default."),
5882 &info_proc_cmdlist, "info proc ",
5883 1/*allow-unknown*/, &infolist);
5885 add_cmd ("mappings", class_info, linux_nat_info_proc_cmd_mappings, _("\
5886 List of mapped memory regions."),
5887 &info_proc_cmdlist);
5889 add_cmd ("stat", class_info, linux_nat_info_proc_cmd_stat, _("\
5890 List a bunch of random process info."),
5891 &info_proc_cmdlist);
5893 add_cmd ("status", class_info, linux_nat_info_proc_cmd_status, _("\
5894 List a different bunch of random process info."),
5895 &info_proc_cmdlist);
5897 add_cmd ("cwd", class_info, linux_nat_info_proc_cmd_cwd, _("\
5898 List a different bunch of random process info."),
5899 &info_proc_cmdlist);
5901 add_cmd ("cmdline", class_info, linux_nat_info_proc_cmd_cmdline, _("\
5902 List a different bunch of random process info."),
5903 &info_proc_cmdlist);
5905 add_cmd ("exe", class_info, linux_nat_info_proc_cmd_exe, _("\
5906 List a different bunch of random process info."),
5907 &info_proc_cmdlist);
5909 add_cmd ("all", class_info, linux_nat_info_proc_cmd_all, _("\
5910 List all available /proc info."),
5911 &info_proc_cmdlist);
5913 add_setshow_zinteger_cmd ("lin-lwp", class_maintenance,
5914 &debug_linux_nat, _("\
5915 Set debugging of GNU/Linux lwp module."), _("\
5916 Show debugging of GNU/Linux lwp module."), _("\
5917 Enables printf debugging output."),
5919 show_debug_linux_nat,
5920 &setdebuglist, &showdebuglist);
5922 /* Save this mask as the default. */
5923 sigprocmask (SIG_SETMASK, NULL, &normal_mask);
5925 /* Install a SIGCHLD handler. */
5926 sigchld_action.sa_handler = sigchld_handler;
5927 sigemptyset (&sigchld_action.sa_mask);
5928 sigchld_action.sa_flags = SA_RESTART;
5930 /* Make it the default. */
5931 sigaction (SIGCHLD, &sigchld_action, NULL);
5933 /* Make sure we don't block SIGCHLD during a sigsuspend. */
5934 sigprocmask (SIG_SETMASK, NULL, &suspend_mask);
5935 sigdelset (&suspend_mask, SIGCHLD);
5937 sigemptyset (&blocked_mask);
5941 /* FIXME: kettenis/2000-08-26: The stuff on this page is specific to
5942 the GNU/Linux Threads library and therefore doesn't really belong
5945 /* Read variable NAME in the target and return its value if found.
5946 Otherwise return zero. It is assumed that the type of the variable
5950 get_signo (const char *name)
5952 struct minimal_symbol *ms;
5955 ms = lookup_minimal_symbol (name, NULL, NULL);
5959 if (target_read_memory (SYMBOL_VALUE_ADDRESS (ms), (gdb_byte *) &signo,
5960 sizeof (signo)) != 0)
5966 /* Return the set of signals used by the threads library in *SET. */
5969 lin_thread_get_thread_signals (sigset_t *set)
5971 struct sigaction action;
5972 int restart, cancel;
5974 sigemptyset (&blocked_mask);
5977 restart = get_signo ("__pthread_sig_restart");
5978 cancel = get_signo ("__pthread_sig_cancel");
5980 /* LinuxThreads normally uses the first two RT signals, but in some legacy
5981 cases may use SIGUSR1/SIGUSR2. NPTL always uses RT signals, but does
5982 not provide any way for the debugger to query the signal numbers -
5983 fortunately they don't change! */
5986 restart = __SIGRTMIN;
5989 cancel = __SIGRTMIN + 1;
5991 sigaddset (set, restart);
5992 sigaddset (set, cancel);
5994 /* The GNU/Linux Threads library makes terminating threads send a
5995 special "cancel" signal instead of SIGCHLD. Make sure we catch
5996 those (to prevent them from terminating GDB itself, which is
5997 likely to be their default action) and treat them the same way as
6000 action.sa_handler = sigchld_handler;
6001 sigemptyset (&action.sa_mask);
6002 action.sa_flags = SA_RESTART;
6003 sigaction (cancel, &action, NULL);
6005 /* We block the "cancel" signal throughout this code ... */
6006 sigaddset (&blocked_mask, cancel);
6007 sigprocmask (SIG_BLOCK, &blocked_mask, NULL);
6009 /* ... except during a sigsuspend. */
6010 sigdelset (&suspend_mask, cancel);