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 && ourstatus
->kind
!= TARGET_WAITKIND_NO_RESUMED
)
3985 || !ptid_equal (ptid
, minus_one_ptid
)))
3988 /* Get ready for the next event. */
3989 if (target_can_async_p ())
3990 target_async (inferior_event_handler
, 0);
3996 kill_callback (struct lwp_info
*lp
, void *data
)
3998 /* PTRACE_KILL may resume the inferior. Send SIGKILL first. */
4001 kill (GET_LWP (lp
->ptid
), SIGKILL
);
4002 if (debug_linux_nat
)
4003 fprintf_unfiltered (gdb_stdlog
,
4004 "KC: kill (SIGKILL) %s, 0, 0 (%s)\n",
4005 target_pid_to_str (lp
->ptid
),
4006 errno
? safe_strerror (errno
) : "OK");
4008 /* Some kernels ignore even SIGKILL for processes under ptrace. */
4011 ptrace (PTRACE_KILL
, GET_LWP (lp
->ptid
), 0, 0);
4012 if (debug_linux_nat
)
4013 fprintf_unfiltered (gdb_stdlog
,
4014 "KC: PTRACE_KILL %s, 0, 0 (%s)\n",
4015 target_pid_to_str (lp
->ptid
),
4016 errno
? safe_strerror (errno
) : "OK");
4022 kill_wait_callback (struct lwp_info
*lp
, void *data
)
4026 /* We must make sure that there are no pending events (delayed
4027 SIGSTOPs, pending SIGTRAPs, etc.) to make sure the current
4028 program doesn't interfere with any following debugging session. */
4030 /* For cloned processes we must check both with __WCLONE and
4031 without, since the exit status of a cloned process isn't reported
4037 pid
= my_waitpid (GET_LWP (lp
->ptid
), NULL
, __WCLONE
);
4038 if (pid
!= (pid_t
) -1)
4040 if (debug_linux_nat
)
4041 fprintf_unfiltered (gdb_stdlog
,
4042 "KWC: wait %s received unknown.\n",
4043 target_pid_to_str (lp
->ptid
));
4044 /* The Linux kernel sometimes fails to kill a thread
4045 completely after PTRACE_KILL; that goes from the stop
4046 point in do_fork out to the one in
4047 get_signal_to_deliever and waits again. So kill it
4049 kill_callback (lp
, NULL
);
4052 while (pid
== GET_LWP (lp
->ptid
));
4054 gdb_assert (pid
== -1 && errno
== ECHILD
);
4059 pid
= my_waitpid (GET_LWP (lp
->ptid
), NULL
, 0);
4060 if (pid
!= (pid_t
) -1)
4062 if (debug_linux_nat
)
4063 fprintf_unfiltered (gdb_stdlog
,
4064 "KWC: wait %s received unk.\n",
4065 target_pid_to_str (lp
->ptid
));
4066 /* See the call to kill_callback above. */
4067 kill_callback (lp
, NULL
);
4070 while (pid
== GET_LWP (lp
->ptid
));
4072 gdb_assert (pid
== -1 && errno
== ECHILD
);
4077 linux_nat_kill (struct target_ops
*ops
)
4079 struct target_waitstatus last
;
4083 /* If we're stopped while forking and we haven't followed yet,
4084 kill the other task. We need to do this first because the
4085 parent will be sleeping if this is a vfork. */
4087 get_last_target_status (&last_ptid
, &last
);
4089 if (last
.kind
== TARGET_WAITKIND_FORKED
4090 || last
.kind
== TARGET_WAITKIND_VFORKED
)
4092 ptrace (PT_KILL
, PIDGET (last
.value
.related_pid
), 0, 0);
4096 if (forks_exist_p ())
4097 linux_fork_killall ();
4100 ptid_t ptid
= pid_to_ptid (ptid_get_pid (inferior_ptid
));
4102 /* Stop all threads before killing them, since ptrace requires
4103 that the thread is stopped to sucessfully PTRACE_KILL. */
4104 iterate_over_lwps (ptid
, stop_callback
, NULL
);
4105 /* ... and wait until all of them have reported back that
4106 they're no longer running. */
4107 iterate_over_lwps (ptid
, stop_wait_callback
, NULL
);
4109 /* Kill all LWP's ... */
4110 iterate_over_lwps (ptid
, kill_callback
, NULL
);
4112 /* ... and wait until we've flushed all events. */
4113 iterate_over_lwps (ptid
, kill_wait_callback
, NULL
);
4116 target_mourn_inferior ();
4120 linux_nat_mourn_inferior (struct target_ops
*ops
)
4122 purge_lwp_list (ptid_get_pid (inferior_ptid
));
4124 if (! forks_exist_p ())
4125 /* Normal case, no other forks available. */
4126 linux_ops
->to_mourn_inferior (ops
);
4128 /* Multi-fork case. The current inferior_ptid has exited, but
4129 there are other viable forks to debug. Delete the exiting
4130 one and context-switch to the first available. */
4131 linux_fork_mourn_inferior ();
4134 /* Convert a native/host siginfo object, into/from the siginfo in the
4135 layout of the inferiors' architecture. */
4138 siginfo_fixup (struct siginfo
*siginfo
, gdb_byte
*inf_siginfo
, int direction
)
4142 if (linux_nat_siginfo_fixup
!= NULL
)
4143 done
= linux_nat_siginfo_fixup (siginfo
, inf_siginfo
, direction
);
4145 /* If there was no callback, or the callback didn't do anything,
4146 then just do a straight memcpy. */
4150 memcpy (siginfo
, inf_siginfo
, sizeof (struct siginfo
));
4152 memcpy (inf_siginfo
, siginfo
, sizeof (struct siginfo
));
4157 linux_xfer_siginfo (struct target_ops
*ops
, enum target_object object
,
4158 const char *annex
, gdb_byte
*readbuf
,
4159 const gdb_byte
*writebuf
, ULONGEST offset
, LONGEST len
)
4162 struct siginfo siginfo
;
4163 gdb_byte inf_siginfo
[sizeof (struct siginfo
)];
4165 gdb_assert (object
== TARGET_OBJECT_SIGNAL_INFO
);
4166 gdb_assert (readbuf
|| writebuf
);
4168 pid
= GET_LWP (inferior_ptid
);
4170 pid
= GET_PID (inferior_ptid
);
4172 if (offset
> sizeof (siginfo
))
4176 ptrace (PTRACE_GETSIGINFO
, pid
, (PTRACE_TYPE_ARG3
) 0, &siginfo
);
4180 /* When GDB is built as a 64-bit application, ptrace writes into
4181 SIGINFO an object with 64-bit layout. Since debugging a 32-bit
4182 inferior with a 64-bit GDB should look the same as debugging it
4183 with a 32-bit GDB, we need to convert it. GDB core always sees
4184 the converted layout, so any read/write will have to be done
4186 siginfo_fixup (&siginfo
, inf_siginfo
, 0);
4188 if (offset
+ len
> sizeof (siginfo
))
4189 len
= sizeof (siginfo
) - offset
;
4191 if (readbuf
!= NULL
)
4192 memcpy (readbuf
, inf_siginfo
+ offset
, len
);
4195 memcpy (inf_siginfo
+ offset
, writebuf
, len
);
4197 /* Convert back to ptrace layout before flushing it out. */
4198 siginfo_fixup (&siginfo
, inf_siginfo
, 1);
4201 ptrace (PTRACE_SETSIGINFO
, pid
, (PTRACE_TYPE_ARG3
) 0, &siginfo
);
4210 linux_nat_xfer_partial (struct target_ops
*ops
, enum target_object object
,
4211 const char *annex
, gdb_byte
*readbuf
,
4212 const gdb_byte
*writebuf
,
4213 ULONGEST offset
, LONGEST len
)
4215 struct cleanup
*old_chain
;
4218 if (object
== TARGET_OBJECT_SIGNAL_INFO
)
4219 return linux_xfer_siginfo (ops
, object
, annex
, readbuf
, writebuf
,
4222 /* The target is connected but no live inferior is selected. Pass
4223 this request down to a lower stratum (e.g., the executable
4225 if (object
== TARGET_OBJECT_MEMORY
&& ptid_equal (inferior_ptid
, null_ptid
))
4228 old_chain
= save_inferior_ptid ();
4230 if (is_lwp (inferior_ptid
))
4231 inferior_ptid
= pid_to_ptid (GET_LWP (inferior_ptid
));
4233 xfer
= linux_ops
->to_xfer_partial (ops
, object
, annex
, readbuf
, writebuf
,
4236 do_cleanups (old_chain
);
4241 linux_thread_alive (ptid_t ptid
)
4245 gdb_assert (is_lwp (ptid
));
4247 /* Send signal 0 instead of anything ptrace, because ptracing a
4248 running thread errors out claiming that the thread doesn't
4250 err
= kill_lwp (GET_LWP (ptid
), 0);
4252 if (debug_linux_nat
)
4253 fprintf_unfiltered (gdb_stdlog
,
4254 "LLTA: KILL(SIG0) %s (%s)\n",
4255 target_pid_to_str (ptid
),
4256 err
? safe_strerror (tmp_errno
) : "OK");
4265 linux_nat_thread_alive (struct target_ops
*ops
, ptid_t ptid
)
4267 return linux_thread_alive (ptid
);
4271 linux_nat_pid_to_str (struct target_ops
*ops
, ptid_t ptid
)
4273 static char buf
[64];
4276 && (GET_PID (ptid
) != GET_LWP (ptid
)
4277 || num_lwps (GET_PID (ptid
)) > 1))
4279 snprintf (buf
, sizeof (buf
), "LWP %ld", GET_LWP (ptid
));
4283 return normal_pid_to_str (ptid
);
4287 linux_nat_thread_name (struct thread_info
*thr
)
4289 int pid
= ptid_get_pid (thr
->ptid
);
4290 long lwp
= ptid_get_lwp (thr
->ptid
);
4291 #define FORMAT "/proc/%d/task/%ld/comm"
4292 char buf
[sizeof (FORMAT
) + 30];
4294 char *result
= NULL
;
4296 snprintf (buf
, sizeof (buf
), FORMAT
, pid
, lwp
);
4297 comm_file
= fopen (buf
, "r");
4300 /* Not exported by the kernel, so we define it here. */
4302 static char line
[COMM_LEN
+ 1];
4304 if (fgets (line
, sizeof (line
), comm_file
))
4306 char *nl
= strchr (line
, '\n');
4323 /* Accepts an integer PID; Returns a string representing a file that
4324 can be opened to get the symbols for the child process. */
4327 linux_child_pid_to_exec_file (int pid
)
4329 char *name1
, *name2
;
4331 name1
= xmalloc (MAXPATHLEN
);
4332 name2
= xmalloc (MAXPATHLEN
);
4333 make_cleanup (xfree
, name1
);
4334 make_cleanup (xfree
, name2
);
4335 memset (name2
, 0, MAXPATHLEN
);
4337 sprintf (name1
, "/proc/%d/exe", pid
);
4338 if (readlink (name1
, name2
, MAXPATHLEN
) > 0)
4344 /* Service function for corefiles and info proc. */
4347 read_mapping (FILE *mapfile
,
4352 char *device
, long long *inode
, char *filename
)
4354 int ret
= fscanf (mapfile
, "%llx-%llx %s %llx %s %llx",
4355 addr
, endaddr
, permissions
, offset
, device
, inode
);
4358 if (ret
> 0 && ret
!= EOF
)
4360 /* Eat everything up to EOL for the filename. This will prevent
4361 weird filenames (such as one with embedded whitespace) from
4362 confusing this code. It also makes this code more robust in
4363 respect to annotations the kernel may add after the filename.
4365 Note the filename is used for informational purposes
4367 ret
+= fscanf (mapfile
, "%[^\n]\n", filename
);
4370 return (ret
!= 0 && ret
!= EOF
);
4373 /* Fills the "to_find_memory_regions" target vector. Lists the memory
4374 regions in the inferior for a corefile. */
4377 linux_nat_find_memory_regions (find_memory_region_ftype func
, void *obfd
)
4379 int pid
= PIDGET (inferior_ptid
);
4380 char mapsfilename
[MAXPATHLEN
];
4382 long long addr
, endaddr
, size
, offset
, inode
;
4383 char permissions
[8], device
[8], filename
[MAXPATHLEN
];
4384 int read
, write
, exec
;
4385 struct cleanup
*cleanup
;
4387 /* Compose the filename for the /proc memory map, and open it. */
4388 sprintf (mapsfilename
, "/proc/%d/maps", pid
);
4389 if ((mapsfile
= fopen (mapsfilename
, "r")) == NULL
)
4390 error (_("Could not open %s."), mapsfilename
);
4391 cleanup
= make_cleanup_fclose (mapsfile
);
4394 fprintf_filtered (gdb_stdout
,
4395 "Reading memory regions from %s\n", mapsfilename
);
4397 /* Now iterate until end-of-file. */
4398 while (read_mapping (mapsfile
, &addr
, &endaddr
, &permissions
[0],
4399 &offset
, &device
[0], &inode
, &filename
[0]))
4401 size
= endaddr
- addr
;
4403 /* Get the segment's permissions. */
4404 read
= (strchr (permissions
, 'r') != 0);
4405 write
= (strchr (permissions
, 'w') != 0);
4406 exec
= (strchr (permissions
, 'x') != 0);
4410 fprintf_filtered (gdb_stdout
,
4411 "Save segment, %s bytes at %s (%c%c%c)",
4412 plongest (size
), paddress (target_gdbarch
, addr
),
4414 write
? 'w' : ' ', exec
? 'x' : ' ');
4416 fprintf_filtered (gdb_stdout
, " for %s", filename
);
4417 fprintf_filtered (gdb_stdout
, "\n");
4420 /* Invoke the callback function to create the corefile
4422 func (addr
, size
, read
, write
, exec
, obfd
);
4424 do_cleanups (cleanup
);
4429 find_signalled_thread (struct thread_info
*info
, void *data
)
4431 if (info
->suspend
.stop_signal
!= TARGET_SIGNAL_0
4432 && ptid_get_pid (info
->ptid
) == ptid_get_pid (inferior_ptid
))
4438 static enum target_signal
4439 find_stop_signal (void)
4441 struct thread_info
*info
=
4442 iterate_over_threads (find_signalled_thread
, NULL
);
4445 return info
->suspend
.stop_signal
;
4447 return TARGET_SIGNAL_0
;
4450 /* Records the thread's register state for the corefile note
4454 linux_nat_do_thread_registers (bfd
*obfd
, ptid_t ptid
,
4455 char *note_data
, int *note_size
,
4456 enum target_signal stop_signal
)
4458 unsigned long lwp
= ptid_get_lwp (ptid
);
4459 struct gdbarch
*gdbarch
= target_gdbarch
;
4460 struct regcache
*regcache
= get_thread_arch_regcache (ptid
, gdbarch
);
4461 const struct regset
*regset
;
4463 struct cleanup
*old_chain
;
4464 struct core_regset_section
*sect_list
;
4467 old_chain
= save_inferior_ptid ();
4468 inferior_ptid
= ptid
;
4469 target_fetch_registers (regcache
, -1);
4470 do_cleanups (old_chain
);
4472 core_regset_p
= gdbarch_regset_from_core_section_p (gdbarch
);
4473 sect_list
= gdbarch_core_regset_sections (gdbarch
);
4475 /* The loop below uses the new struct core_regset_section, which stores
4476 the supported section names and sizes for the core file. Note that
4477 note PRSTATUS needs to be treated specially. But the other notes are
4478 structurally the same, so they can benefit from the new struct. */
4479 if (core_regset_p
&& sect_list
!= NULL
)
4480 while (sect_list
->sect_name
!= NULL
)
4482 regset
= gdbarch_regset_from_core_section (gdbarch
,
4483 sect_list
->sect_name
,
4485 gdb_assert (regset
&& regset
->collect_regset
);
4486 gdb_regset
= xmalloc (sect_list
->size
);
4487 regset
->collect_regset (regset
, regcache
, -1,
4488 gdb_regset
, sect_list
->size
);
4490 if (strcmp (sect_list
->sect_name
, ".reg") == 0)
4491 note_data
= (char *) elfcore_write_prstatus
4492 (obfd
, note_data
, note_size
,
4493 lwp
, target_signal_to_host (stop_signal
),
4496 note_data
= (char *) elfcore_write_register_note
4497 (obfd
, note_data
, note_size
,
4498 sect_list
->sect_name
, gdb_regset
,
4504 /* For architectures that does not have the struct core_regset_section
4505 implemented, we use the old method. When all the architectures have
4506 the new support, the code below should be deleted. */
4509 gdb_gregset_t gregs
;
4510 gdb_fpregset_t fpregs
;
4513 && (regset
= gdbarch_regset_from_core_section (gdbarch
, ".reg",
4515 != NULL
&& regset
->collect_regset
!= NULL
)
4516 regset
->collect_regset (regset
, regcache
, -1,
4517 &gregs
, sizeof (gregs
));
4519 fill_gregset (regcache
, &gregs
, -1);
4521 note_data
= (char *) elfcore_write_prstatus
4522 (obfd
, note_data
, note_size
, lwp
, target_signal_to_host (stop_signal
),
4526 && (regset
= gdbarch_regset_from_core_section (gdbarch
, ".reg2",
4528 != NULL
&& regset
->collect_regset
!= NULL
)
4529 regset
->collect_regset (regset
, regcache
, -1,
4530 &fpregs
, sizeof (fpregs
));
4532 fill_fpregset (regcache
, &fpregs
, -1);
4534 note_data
= (char *) elfcore_write_prfpreg (obfd
,
4537 &fpregs
, sizeof (fpregs
));
4543 struct linux_nat_corefile_thread_data
4549 enum target_signal stop_signal
;
4552 /* Called by gdbthread.c once per thread. Records the thread's
4553 register state for the corefile note section. */
4556 linux_nat_corefile_thread_callback (struct lwp_info
*ti
, void *data
)
4558 struct linux_nat_corefile_thread_data
*args
= data
;
4560 args
->note_data
= linux_nat_do_thread_registers (args
->obfd
,
4570 /* Enumerate spufs IDs for process PID. */
4573 iterate_over_spus (int pid
, void (*callback
) (void *, int), void *data
)
4577 struct dirent
*entry
;
4579 xsnprintf (path
, sizeof path
, "/proc/%d/fd", pid
);
4580 dir
= opendir (path
);
4585 while ((entry
= readdir (dir
)) != NULL
)
4591 fd
= atoi (entry
->d_name
);
4595 xsnprintf (path
, sizeof path
, "/proc/%d/fd/%d", pid
, fd
);
4596 if (stat (path
, &st
) != 0)
4598 if (!S_ISDIR (st
.st_mode
))
4601 if (statfs (path
, &stfs
) != 0)
4603 if (stfs
.f_type
!= SPUFS_MAGIC
)
4606 callback (data
, fd
);
4612 /* Generate corefile notes for SPU contexts. */
4614 struct linux_spu_corefile_data
4622 linux_spu_corefile_callback (void *data
, int fd
)
4624 struct linux_spu_corefile_data
*args
= data
;
4627 static const char *spu_files
[] =
4649 for (i
= 0; i
< sizeof (spu_files
) / sizeof (spu_files
[0]); i
++)
4651 char annex
[32], note_name
[32];
4655 xsnprintf (annex
, sizeof annex
, "%d/%s", fd
, spu_files
[i
]);
4656 spu_len
= target_read_alloc (¤t_target
, TARGET_OBJECT_SPU
,
4660 xsnprintf (note_name
, sizeof note_name
, "SPU/%s", annex
);
4661 args
->note_data
= elfcore_write_note (args
->obfd
, args
->note_data
,
4662 args
->note_size
, note_name
,
4663 NT_SPU
, spu_data
, spu_len
);
4670 linux_spu_make_corefile_notes (bfd
*obfd
, char *note_data
, int *note_size
)
4672 struct linux_spu_corefile_data args
;
4675 args
.note_data
= note_data
;
4676 args
.note_size
= note_size
;
4678 iterate_over_spus (PIDGET (inferior_ptid
),
4679 linux_spu_corefile_callback
, &args
);
4681 return args
.note_data
;
4684 /* Fills the "to_make_corefile_note" target vector. Builds the note
4685 section for a corefile, and returns it in a malloc buffer. */
4688 linux_nat_make_corefile_notes (bfd
*obfd
, int *note_size
)
4690 struct linux_nat_corefile_thread_data thread_args
;
4691 /* The variable size must be >= sizeof (prpsinfo_t.pr_fname). */
4692 char fname
[16] = { '\0' };
4693 /* The variable size must be >= sizeof (prpsinfo_t.pr_psargs). */
4694 char psargs
[80] = { '\0' };
4695 char *note_data
= NULL
;
4696 ptid_t filter
= pid_to_ptid (ptid_get_pid (inferior_ptid
));
4700 if (get_exec_file (0))
4702 strncpy (fname
, lbasename (get_exec_file (0)), sizeof (fname
));
4703 strncpy (psargs
, get_exec_file (0), sizeof (psargs
));
4704 if (get_inferior_args ())
4707 char *psargs_end
= psargs
+ sizeof (psargs
);
4709 /* linux_elfcore_write_prpsinfo () handles zero unterminated
4711 string_end
= memchr (psargs
, 0, sizeof (psargs
));
4712 if (string_end
!= NULL
)
4714 *string_end
++ = ' ';
4715 strncpy (string_end
, get_inferior_args (),
4716 psargs_end
- string_end
);
4719 note_data
= (char *) elfcore_write_prpsinfo (obfd
,
4721 note_size
, fname
, psargs
);
4724 /* Dump information for threads. */
4725 thread_args
.obfd
= obfd
;
4726 thread_args
.note_data
= note_data
;
4727 thread_args
.note_size
= note_size
;
4728 thread_args
.num_notes
= 0;
4729 thread_args
.stop_signal
= find_stop_signal ();
4730 iterate_over_lwps (filter
, linux_nat_corefile_thread_callback
, &thread_args
);
4731 gdb_assert (thread_args
.num_notes
!= 0);
4732 note_data
= thread_args
.note_data
;
4734 auxv_len
= target_read_alloc (¤t_target
, TARGET_OBJECT_AUXV
,
4738 note_data
= elfcore_write_note (obfd
, note_data
, note_size
,
4739 "CORE", NT_AUXV
, auxv
, auxv_len
);
4743 note_data
= linux_spu_make_corefile_notes (obfd
, note_data
, note_size
);
4745 make_cleanup (xfree
, note_data
);
4749 /* Implement the "info proc" command. */
4753 /* Display the default cmdline, cwd and exe outputs. */
4756 /* Display `info proc mappings'. */
4759 /* Display `info proc status'. */
4762 /* Display `info proc stat'. */
4765 /* Display `info proc cmdline'. */
4768 /* Display `info proc exe'. */
4771 /* Display `info proc cwd'. */
4774 /* Display all of the above. */
4779 linux_nat_info_proc_cmd_1 (char *args
, enum info_proc_what what
, int from_tty
)
4781 /* A long is used for pid instead of an int to avoid a loss of precision
4782 compiler warning from the output of strtoul. */
4783 long pid
= PIDGET (inferior_ptid
);
4785 char buffer
[MAXPATHLEN
];
4786 char fname1
[MAXPATHLEN
], fname2
[MAXPATHLEN
];
4787 int cmdline_f
= (what
== IP_MINIMAL
|| what
== IP_CMDLINE
|| what
== IP_ALL
);
4788 int cwd_f
= (what
== IP_MINIMAL
|| what
== IP_CWD
|| what
== IP_ALL
);
4789 int exe_f
= (what
== IP_MINIMAL
|| what
== IP_EXE
|| what
== IP_ALL
);
4790 int mappings_f
= (what
== IP_MAPPINGS
|| what
== IP_ALL
);
4791 int status_f
= (what
== IP_STATUS
|| what
== IP_ALL
);
4792 int stat_f
= (what
== IP_STAT
|| what
== IP_ALL
);
4795 if (args
&& isdigit (args
[0]))
4796 pid
= strtoul (args
, &args
, 10);
4798 args
= skip_spaces (args
);
4799 if (args
&& args
[0])
4800 error (_("Too many parameters: %s"), args
);
4803 error (_("No current process: you must name one."));
4805 sprintf (fname1
, "/proc/%ld", pid
);
4806 if (stat (fname1
, &dummy
) != 0)
4807 error (_("No /proc directory: '%s'"), fname1
);
4809 printf_filtered (_("process %ld\n"), pid
);
4812 sprintf (fname1
, "/proc/%ld/cmdline", pid
);
4813 if ((procfile
= fopen (fname1
, "r")) != NULL
)
4815 struct cleanup
*cleanup
= make_cleanup_fclose (procfile
);
4817 if (fgets (buffer
, sizeof (buffer
), procfile
))
4818 printf_filtered ("cmdline = '%s'\n", buffer
);
4820 warning (_("unable to read '%s'"), fname1
);
4821 do_cleanups (cleanup
);
4824 warning (_("unable to open /proc file '%s'"), fname1
);
4828 sprintf (fname1
, "/proc/%ld/cwd", pid
);
4829 memset (fname2
, 0, sizeof (fname2
));
4830 if (readlink (fname1
, fname2
, sizeof (fname2
)) > 0)
4831 printf_filtered ("cwd = '%s'\n", fname2
);
4833 warning (_("unable to read link '%s'"), fname1
);
4837 sprintf (fname1
, "/proc/%ld/exe", pid
);
4838 memset (fname2
, 0, sizeof (fname2
));
4839 if (readlink (fname1
, fname2
, sizeof (fname2
)) > 0)
4840 printf_filtered ("exe = '%s'\n", fname2
);
4842 warning (_("unable to read link '%s'"), fname1
);
4846 sprintf (fname1
, "/proc/%ld/maps", pid
);
4847 if ((procfile
= fopen (fname1
, "r")) != NULL
)
4849 long long addr
, endaddr
, size
, offset
, inode
;
4850 char permissions
[8], device
[8], filename
[MAXPATHLEN
];
4851 struct cleanup
*cleanup
;
4853 cleanup
= make_cleanup_fclose (procfile
);
4854 printf_filtered (_("Mapped address spaces:\n\n"));
4855 if (gdbarch_addr_bit (target_gdbarch
) == 32)
4857 printf_filtered ("\t%10s %10s %10s %10s %7s\n",
4860 " Size", " Offset", "objfile");
4864 printf_filtered (" %18s %18s %10s %10s %7s\n",
4867 " Size", " Offset", "objfile");
4870 while (read_mapping (procfile
, &addr
, &endaddr
, &permissions
[0],
4871 &offset
, &device
[0], &inode
, &filename
[0]))
4873 size
= endaddr
- addr
;
4875 /* FIXME: carlton/2003-08-27: Maybe the printf_filtered
4876 calls here (and possibly above) should be abstracted
4877 out into their own functions? Andrew suggests using
4878 a generic local_address_string instead to print out
4879 the addresses; that makes sense to me, too. */
4881 if (gdbarch_addr_bit (target_gdbarch
) == 32)
4883 printf_filtered ("\t%#10lx %#10lx %#10x %#10x %7s\n",
4884 (unsigned long) addr
, /* FIXME: pr_addr */
4885 (unsigned long) endaddr
,
4887 (unsigned int) offset
,
4888 filename
[0] ? filename
: "");
4892 printf_filtered (" %#18lx %#18lx %#10x %#10x %7s\n",
4893 (unsigned long) addr
, /* FIXME: pr_addr */
4894 (unsigned long) endaddr
,
4896 (unsigned int) offset
,
4897 filename
[0] ? filename
: "");
4901 do_cleanups (cleanup
);
4904 warning (_("unable to open /proc file '%s'"), fname1
);
4908 sprintf (fname1
, "/proc/%ld/status", pid
);
4909 if ((procfile
= fopen (fname1
, "r")) != NULL
)
4911 struct cleanup
*cleanup
= make_cleanup_fclose (procfile
);
4913 while (fgets (buffer
, sizeof (buffer
), procfile
) != NULL
)
4914 puts_filtered (buffer
);
4915 do_cleanups (cleanup
);
4918 warning (_("unable to open /proc file '%s'"), fname1
);
4922 sprintf (fname1
, "/proc/%ld/stat", pid
);
4923 if ((procfile
= fopen (fname1
, "r")) != NULL
)
4928 struct cleanup
*cleanup
= make_cleanup_fclose (procfile
);
4930 if (fscanf (procfile
, "%d ", &itmp
) > 0)
4931 printf_filtered (_("Process: %d\n"), itmp
);
4932 if (fscanf (procfile
, "(%[^)]) ", &buffer
[0]) > 0)
4933 printf_filtered (_("Exec file: %s\n"), buffer
);
4934 if (fscanf (procfile
, "%c ", &ctmp
) > 0)
4935 printf_filtered (_("State: %c\n"), ctmp
);
4936 if (fscanf (procfile
, "%d ", &itmp
) > 0)
4937 printf_filtered (_("Parent process: %d\n"), itmp
);
4938 if (fscanf (procfile
, "%d ", &itmp
) > 0)
4939 printf_filtered (_("Process group: %d\n"), itmp
);
4940 if (fscanf (procfile
, "%d ", &itmp
) > 0)
4941 printf_filtered (_("Session id: %d\n"), itmp
);
4942 if (fscanf (procfile
, "%d ", &itmp
) > 0)
4943 printf_filtered (_("TTY: %d\n"), itmp
);
4944 if (fscanf (procfile
, "%d ", &itmp
) > 0)
4945 printf_filtered (_("TTY owner process group: %d\n"), itmp
);
4946 if (fscanf (procfile
, "%lu ", <mp
) > 0)
4947 printf_filtered (_("Flags: 0x%lx\n"), ltmp
);
4948 if (fscanf (procfile
, "%lu ", <mp
) > 0)
4949 printf_filtered (_("Minor faults (no memory page): %lu\n"),
4950 (unsigned long) ltmp
);
4951 if (fscanf (procfile
, "%lu ", <mp
) > 0)
4952 printf_filtered (_("Minor faults, children: %lu\n"),
4953 (unsigned long) ltmp
);
4954 if (fscanf (procfile
, "%lu ", <mp
) > 0)
4955 printf_filtered (_("Major faults (memory page faults): %lu\n"),
4956 (unsigned long) ltmp
);
4957 if (fscanf (procfile
, "%lu ", <mp
) > 0)
4958 printf_filtered (_("Major faults, children: %lu\n"),
4959 (unsigned long) ltmp
);
4960 if (fscanf (procfile
, "%ld ", <mp
) > 0)
4961 printf_filtered (_("utime: %ld\n"), ltmp
);
4962 if (fscanf (procfile
, "%ld ", <mp
) > 0)
4963 printf_filtered (_("stime: %ld\n"), ltmp
);
4964 if (fscanf (procfile
, "%ld ", <mp
) > 0)
4965 printf_filtered (_("utime, children: %ld\n"), ltmp
);
4966 if (fscanf (procfile
, "%ld ", <mp
) > 0)
4967 printf_filtered (_("stime, children: %ld\n"), ltmp
);
4968 if (fscanf (procfile
, "%ld ", <mp
) > 0)
4969 printf_filtered (_("jiffies remaining in current "
4970 "time slice: %ld\n"), ltmp
);
4971 if (fscanf (procfile
, "%ld ", <mp
) > 0)
4972 printf_filtered (_("'nice' value: %ld\n"), ltmp
);
4973 if (fscanf (procfile
, "%lu ", <mp
) > 0)
4974 printf_filtered (_("jiffies until next timeout: %lu\n"),
4975 (unsigned long) ltmp
);
4976 if (fscanf (procfile
, "%lu ", <mp
) > 0)
4977 printf_filtered (_("jiffies until next SIGALRM: %lu\n"),
4978 (unsigned long) ltmp
);
4979 if (fscanf (procfile
, "%ld ", <mp
) > 0)
4980 printf_filtered (_("start time (jiffies since "
4981 "system boot): %ld\n"), ltmp
);
4982 if (fscanf (procfile
, "%lu ", <mp
) > 0)
4983 printf_filtered (_("Virtual memory size: %lu\n"),
4984 (unsigned long) ltmp
);
4985 if (fscanf (procfile
, "%lu ", <mp
) > 0)
4986 printf_filtered (_("Resident set size: %lu\n"),
4987 (unsigned long) ltmp
);
4988 if (fscanf (procfile
, "%lu ", <mp
) > 0)
4989 printf_filtered (_("rlim: %lu\n"), (unsigned long) ltmp
);
4990 if (fscanf (procfile
, "%lu ", <mp
) > 0)
4991 printf_filtered (_("Start of text: 0x%lx\n"), ltmp
);
4992 if (fscanf (procfile
, "%lu ", <mp
) > 0)
4993 printf_filtered (_("End of text: 0x%lx\n"), ltmp
);
4994 if (fscanf (procfile
, "%lu ", <mp
) > 0)
4995 printf_filtered (_("Start of stack: 0x%lx\n"), ltmp
);
4996 #if 0 /* Don't know how architecture-dependent the rest is...
4997 Anyway the signal bitmap info is available from "status". */
4998 if (fscanf (procfile
, "%lu ", <mp
) > 0) /* FIXME arch? */
4999 printf_filtered (_("Kernel stack pointer: 0x%lx\n"), ltmp
);
5000 if (fscanf (procfile
, "%lu ", <mp
) > 0) /* FIXME arch? */
5001 printf_filtered (_("Kernel instr pointer: 0x%lx\n"), ltmp
);
5002 if (fscanf (procfile
, "%ld ", <mp
) > 0)
5003 printf_filtered (_("Pending signals bitmap: 0x%lx\n"), ltmp
);
5004 if (fscanf (procfile
, "%ld ", <mp
) > 0)
5005 printf_filtered (_("Blocked signals bitmap: 0x%lx\n"), ltmp
);
5006 if (fscanf (procfile
, "%ld ", <mp
) > 0)
5007 printf_filtered (_("Ignored signals bitmap: 0x%lx\n"), ltmp
);
5008 if (fscanf (procfile
, "%ld ", <mp
) > 0)
5009 printf_filtered (_("Catched signals bitmap: 0x%lx\n"), ltmp
);
5010 if (fscanf (procfile
, "%lu ", <mp
) > 0) /* FIXME arch? */
5011 printf_filtered (_("wchan (system call): 0x%lx\n"), ltmp
);
5013 do_cleanups (cleanup
);
5016 warning (_("unable to open /proc file '%s'"), fname1
);
5020 /* Implement `info proc' when given without any futher parameters. */
5023 linux_nat_info_proc_cmd (char *args
, int from_tty
)
5025 linux_nat_info_proc_cmd_1 (args
, IP_MINIMAL
, from_tty
);
5028 /* Implement `info proc mappings'. */
5031 linux_nat_info_proc_cmd_mappings (char *args
, int from_tty
)
5033 linux_nat_info_proc_cmd_1 (args
, IP_MAPPINGS
, from_tty
);
5036 /* Implement `info proc stat'. */
5039 linux_nat_info_proc_cmd_stat (char *args
, int from_tty
)
5041 linux_nat_info_proc_cmd_1 (args
, IP_STAT
, from_tty
);
5044 /* Implement `info proc status'. */
5047 linux_nat_info_proc_cmd_status (char *args
, int from_tty
)
5049 linux_nat_info_proc_cmd_1 (args
, IP_STATUS
, from_tty
);
5052 /* Implement `info proc cwd'. */
5055 linux_nat_info_proc_cmd_cwd (char *args
, int from_tty
)
5057 linux_nat_info_proc_cmd_1 (args
, IP_CWD
, from_tty
);
5060 /* Implement `info proc cmdline'. */
5063 linux_nat_info_proc_cmd_cmdline (char *args
, int from_tty
)
5065 linux_nat_info_proc_cmd_1 (args
, IP_CMDLINE
, from_tty
);
5068 /* Implement `info proc exe'. */
5071 linux_nat_info_proc_cmd_exe (char *args
, int from_tty
)
5073 linux_nat_info_proc_cmd_1 (args
, IP_EXE
, from_tty
);
5076 /* Implement `info proc all'. */
5079 linux_nat_info_proc_cmd_all (char *args
, int from_tty
)
5081 linux_nat_info_proc_cmd_1 (args
, IP_ALL
, from_tty
);
5084 /* Implement the to_xfer_partial interface for memory reads using the /proc
5085 filesystem. Because we can use a single read() call for /proc, this
5086 can be much more efficient than banging away at PTRACE_PEEKTEXT,
5087 but it doesn't support writes. */
5090 linux_proc_xfer_partial (struct target_ops
*ops
, enum target_object object
,
5091 const char *annex
, gdb_byte
*readbuf
,
5092 const gdb_byte
*writebuf
,
5093 ULONGEST offset
, LONGEST len
)
5099 if (object
!= TARGET_OBJECT_MEMORY
|| !readbuf
)
5102 /* Don't bother for one word. */
5103 if (len
< 3 * sizeof (long))
5106 /* We could keep this file open and cache it - possibly one per
5107 thread. That requires some juggling, but is even faster. */
5108 sprintf (filename
, "/proc/%d/mem", PIDGET (inferior_ptid
));
5109 fd
= open (filename
, O_RDONLY
| O_LARGEFILE
);
5113 /* If pread64 is available, use it. It's faster if the kernel
5114 supports it (only one syscall), and it's 64-bit safe even on
5115 32-bit platforms (for instance, SPARC debugging a SPARC64
5118 if (pread64 (fd
, readbuf
, len
, offset
) != len
)
5120 if (lseek (fd
, offset
, SEEK_SET
) == -1 || read (fd
, readbuf
, len
) != len
)
5131 /* Enumerate spufs IDs for process PID. */
5133 spu_enumerate_spu_ids (int pid
, gdb_byte
*buf
, ULONGEST offset
, LONGEST len
)
5135 enum bfd_endian byte_order
= gdbarch_byte_order (target_gdbarch
);
5137 LONGEST written
= 0;
5140 struct dirent
*entry
;
5142 xsnprintf (path
, sizeof path
, "/proc/%d/fd", pid
);
5143 dir
= opendir (path
);
5148 while ((entry
= readdir (dir
)) != NULL
)
5154 fd
= atoi (entry
->d_name
);
5158 xsnprintf (path
, sizeof path
, "/proc/%d/fd/%d", pid
, fd
);
5159 if (stat (path
, &st
) != 0)
5161 if (!S_ISDIR (st
.st_mode
))
5164 if (statfs (path
, &stfs
) != 0)
5166 if (stfs
.f_type
!= SPUFS_MAGIC
)
5169 if (pos
>= offset
&& pos
+ 4 <= offset
+ len
)
5171 store_unsigned_integer (buf
+ pos
- offset
, 4, byte_order
, fd
);
5181 /* Implement the to_xfer_partial interface for the TARGET_OBJECT_SPU
5182 object type, using the /proc file system. */
5184 linux_proc_xfer_spu (struct target_ops
*ops
, enum target_object object
,
5185 const char *annex
, gdb_byte
*readbuf
,
5186 const gdb_byte
*writebuf
,
5187 ULONGEST offset
, LONGEST len
)
5192 int pid
= PIDGET (inferior_ptid
);
5199 return spu_enumerate_spu_ids (pid
, readbuf
, offset
, len
);
5202 xsnprintf (buf
, sizeof buf
, "/proc/%d/fd/%s", pid
, annex
);
5203 fd
= open (buf
, writebuf
? O_WRONLY
: O_RDONLY
);
5208 && lseek (fd
, (off_t
) offset
, SEEK_SET
) != (off_t
) offset
)
5215 ret
= write (fd
, writebuf
, (size_t) len
);
5217 ret
= read (fd
, readbuf
, (size_t) len
);
5224 /* Parse LINE as a signal set and add its set bits to SIGS. */
5227 add_line_to_sigset (const char *line
, sigset_t
*sigs
)
5229 int len
= strlen (line
) - 1;
5233 if (line
[len
] != '\n')
5234 error (_("Could not parse signal set: %s"), line
);
5242 if (*p
>= '0' && *p
<= '9')
5244 else if (*p
>= 'a' && *p
<= 'f')
5245 digit
= *p
- 'a' + 10;
5247 error (_("Could not parse signal set: %s"), line
);
5252 sigaddset (sigs
, signum
+ 1);
5254 sigaddset (sigs
, signum
+ 2);
5256 sigaddset (sigs
, signum
+ 3);
5258 sigaddset (sigs
, signum
+ 4);
5264 /* Find process PID's pending signals from /proc/pid/status and set
5268 linux_proc_pending_signals (int pid
, sigset_t
*pending
,
5269 sigset_t
*blocked
, sigset_t
*ignored
)
5272 char buffer
[MAXPATHLEN
], fname
[MAXPATHLEN
];
5273 struct cleanup
*cleanup
;
5275 sigemptyset (pending
);
5276 sigemptyset (blocked
);
5277 sigemptyset (ignored
);
5278 sprintf (fname
, "/proc/%d/status", pid
);
5279 procfile
= fopen (fname
, "r");
5280 if (procfile
== NULL
)
5281 error (_("Could not open %s"), fname
);
5282 cleanup
= make_cleanup_fclose (procfile
);
5284 while (fgets (buffer
, MAXPATHLEN
, procfile
) != NULL
)
5286 /* Normal queued signals are on the SigPnd line in the status
5287 file. However, 2.6 kernels also have a "shared" pending
5288 queue for delivering signals to a thread group, so check for
5291 Unfortunately some Red Hat kernels include the shared pending
5292 queue but not the ShdPnd status field. */
5294 if (strncmp (buffer
, "SigPnd:\t", 8) == 0)
5295 add_line_to_sigset (buffer
+ 8, pending
);
5296 else if (strncmp (buffer
, "ShdPnd:\t", 8) == 0)
5297 add_line_to_sigset (buffer
+ 8, pending
);
5298 else if (strncmp (buffer
, "SigBlk:\t", 8) == 0)
5299 add_line_to_sigset (buffer
+ 8, blocked
);
5300 else if (strncmp (buffer
, "SigIgn:\t", 8) == 0)
5301 add_line_to_sigset (buffer
+ 8, ignored
);
5304 do_cleanups (cleanup
);
5308 linux_nat_xfer_osdata (struct target_ops
*ops
, enum target_object object
,
5309 const char *annex
, gdb_byte
*readbuf
,
5310 const gdb_byte
*writebuf
, ULONGEST offset
, LONGEST len
)
5312 gdb_assert (object
== TARGET_OBJECT_OSDATA
);
5314 return linux_common_xfer_osdata (annex
, readbuf
, offset
, len
);
5318 linux_xfer_partial (struct target_ops
*ops
, enum target_object object
,
5319 const char *annex
, gdb_byte
*readbuf
,
5320 const gdb_byte
*writebuf
, ULONGEST offset
, LONGEST len
)
5324 if (object
== TARGET_OBJECT_AUXV
)
5325 return memory_xfer_auxv (ops
, object
, annex
, readbuf
, writebuf
,
5328 if (object
== TARGET_OBJECT_OSDATA
)
5329 return linux_nat_xfer_osdata (ops
, object
, annex
, readbuf
, writebuf
,
5332 if (object
== TARGET_OBJECT_SPU
)
5333 return linux_proc_xfer_spu (ops
, object
, annex
, readbuf
, writebuf
,
5336 /* GDB calculates all the addresses in possibly larget width of the address.
5337 Address width needs to be masked before its final use - either by
5338 linux_proc_xfer_partial or inf_ptrace_xfer_partial.
5340 Compare ADDR_BIT first to avoid a compiler warning on shift overflow. */
5342 if (object
== TARGET_OBJECT_MEMORY
)
5344 int addr_bit
= gdbarch_addr_bit (target_gdbarch
);
5346 if (addr_bit
< (sizeof (ULONGEST
) * HOST_CHAR_BIT
))
5347 offset
&= ((ULONGEST
) 1 << addr_bit
) - 1;
5350 xfer
= linux_proc_xfer_partial (ops
, object
, annex
, readbuf
, writebuf
,
5355 return super_xfer_partial (ops
, object
, annex
, readbuf
, writebuf
,
5359 /* Create a prototype generic GNU/Linux target. The client can override
5360 it with local methods. */
5363 linux_target_install_ops (struct target_ops
*t
)
5365 t
->to_insert_fork_catchpoint
= linux_child_insert_fork_catchpoint
;
5366 t
->to_remove_fork_catchpoint
= linux_child_remove_fork_catchpoint
;
5367 t
->to_insert_vfork_catchpoint
= linux_child_insert_vfork_catchpoint
;
5368 t
->to_remove_vfork_catchpoint
= linux_child_remove_vfork_catchpoint
;
5369 t
->to_insert_exec_catchpoint
= linux_child_insert_exec_catchpoint
;
5370 t
->to_remove_exec_catchpoint
= linux_child_remove_exec_catchpoint
;
5371 t
->to_set_syscall_catchpoint
= linux_child_set_syscall_catchpoint
;
5372 t
->to_pid_to_exec_file
= linux_child_pid_to_exec_file
;
5373 t
->to_post_startup_inferior
= linux_child_post_startup_inferior
;
5374 t
->to_post_attach
= linux_child_post_attach
;
5375 t
->to_follow_fork
= linux_child_follow_fork
;
5376 t
->to_find_memory_regions
= linux_nat_find_memory_regions
;
5377 t
->to_make_corefile_notes
= linux_nat_make_corefile_notes
;
5379 super_xfer_partial
= t
->to_xfer_partial
;
5380 t
->to_xfer_partial
= linux_xfer_partial
;
5386 struct target_ops
*t
;
5388 t
= inf_ptrace_target ();
5389 linux_target_install_ops (t
);
5395 linux_trad_target (CORE_ADDR (*register_u_offset
)(struct gdbarch
*, int, int))
5397 struct target_ops
*t
;
5399 t
= inf_ptrace_trad_target (register_u_offset
);
5400 linux_target_install_ops (t
);
5405 /* target_is_async_p implementation. */
5408 linux_nat_is_async_p (void)
5410 /* NOTE: palves 2008-03-21: We're only async when the user requests
5411 it explicitly with the "set target-async" command.
5412 Someday, linux will always be async. */
5413 return target_async_permitted
;
5416 /* target_can_async_p implementation. */
5419 linux_nat_can_async_p (void)
5421 /* NOTE: palves 2008-03-21: We're only async when the user requests
5422 it explicitly with the "set target-async" command.
5423 Someday, linux will always be async. */
5424 return target_async_permitted
;
5428 linux_nat_supports_non_stop (void)
5433 /* True if we want to support multi-process. To be removed when GDB
5434 supports multi-exec. */
5436 int linux_multi_process
= 1;
5439 linux_nat_supports_multi_process (void)
5441 return linux_multi_process
;
5445 linux_nat_supports_disable_randomization (void)
5447 #ifdef HAVE_PERSONALITY
5454 static int async_terminal_is_ours
= 1;
5456 /* target_terminal_inferior implementation. */
5459 linux_nat_terminal_inferior (void)
5461 if (!target_is_async_p ())
5463 /* Async mode is disabled. */
5464 terminal_inferior ();
5468 terminal_inferior ();
5470 /* Calls to target_terminal_*() are meant to be idempotent. */
5471 if (!async_terminal_is_ours
)
5474 delete_file_handler (input_fd
);
5475 async_terminal_is_ours
= 0;
5479 /* target_terminal_ours implementation. */
5482 linux_nat_terminal_ours (void)
5484 if (!target_is_async_p ())
5486 /* Async mode is disabled. */
5491 /* GDB should never give the terminal to the inferior if the
5492 inferior is running in the background (run&, continue&, etc.),
5493 but claiming it sure should. */
5496 if (async_terminal_is_ours
)
5499 clear_sigint_trap ();
5500 add_file_handler (input_fd
, stdin_event_handler
, 0);
5501 async_terminal_is_ours
= 1;
5504 static void (*async_client_callback
) (enum inferior_event_type event_type
,
5506 static void *async_client_context
;
5508 /* SIGCHLD handler that serves two purposes: In non-stop/async mode,
5509 so we notice when any child changes state, and notify the
5510 event-loop; it allows us to use sigsuspend in linux_nat_wait_1
5511 above to wait for the arrival of a SIGCHLD. */
5514 sigchld_handler (int signo
)
5516 int old_errno
= errno
;
5518 if (debug_linux_nat
)
5519 ui_file_write_async_safe (gdb_stdlog
,
5520 "sigchld\n", sizeof ("sigchld\n") - 1);
5522 if (signo
== SIGCHLD
5523 && linux_nat_event_pipe
[0] != -1)
5524 async_file_mark (); /* Let the event loop know that there are
5525 events to handle. */
5530 /* Callback registered with the target events file descriptor. */
5533 handle_target_event (int error
, gdb_client_data client_data
)
5535 (*async_client_callback
) (INF_REG_EVENT
, async_client_context
);
5538 /* Create/destroy the target events pipe. Returns previous state. */
5541 linux_async_pipe (int enable
)
5543 int previous
= (linux_nat_event_pipe
[0] != -1);
5545 if (previous
!= enable
)
5549 block_child_signals (&prev_mask
);
5553 if (pipe (linux_nat_event_pipe
) == -1)
5554 internal_error (__FILE__
, __LINE__
,
5555 "creating event pipe failed.");
5557 fcntl (linux_nat_event_pipe
[0], F_SETFL
, O_NONBLOCK
);
5558 fcntl (linux_nat_event_pipe
[1], F_SETFL
, O_NONBLOCK
);
5562 close (linux_nat_event_pipe
[0]);
5563 close (linux_nat_event_pipe
[1]);
5564 linux_nat_event_pipe
[0] = -1;
5565 linux_nat_event_pipe
[1] = -1;
5568 restore_child_signals_mask (&prev_mask
);
5574 /* target_async implementation. */
5577 linux_nat_async (void (*callback
) (enum inferior_event_type event_type
,
5578 void *context
), void *context
)
5580 if (callback
!= NULL
)
5582 async_client_callback
= callback
;
5583 async_client_context
= context
;
5584 if (!linux_async_pipe (1))
5586 add_file_handler (linux_nat_event_pipe
[0],
5587 handle_target_event
, NULL
);
5588 /* There may be pending events to handle. Tell the event loop
5595 async_client_callback
= callback
;
5596 async_client_context
= context
;
5597 delete_file_handler (linux_nat_event_pipe
[0]);
5598 linux_async_pipe (0);
5603 /* Stop an LWP, and push a TARGET_SIGNAL_0 stop status if no other
5607 linux_nat_stop_lwp (struct lwp_info
*lwp
, void *data
)
5611 ptid_t ptid
= lwp
->ptid
;
5613 if (debug_linux_nat
)
5614 fprintf_unfiltered (gdb_stdlog
,
5615 "LNSL: running -> suspending %s\n",
5616 target_pid_to_str (lwp
->ptid
));
5619 if (lwp
->last_resume_kind
== resume_stop
)
5621 if (debug_linux_nat
)
5622 fprintf_unfiltered (gdb_stdlog
,
5623 "linux-nat: already stopping LWP %ld at "
5625 ptid_get_lwp (lwp
->ptid
));
5629 stop_callback (lwp
, NULL
);
5630 lwp
->last_resume_kind
= resume_stop
;
5634 /* Already known to be stopped; do nothing. */
5636 if (debug_linux_nat
)
5638 if (find_thread_ptid (lwp
->ptid
)->stop_requested
)
5639 fprintf_unfiltered (gdb_stdlog
,
5640 "LNSL: already stopped/stop_requested %s\n",
5641 target_pid_to_str (lwp
->ptid
));
5643 fprintf_unfiltered (gdb_stdlog
,
5644 "LNSL: already stopped/no "
5645 "stop_requested yet %s\n",
5646 target_pid_to_str (lwp
->ptid
));
5653 linux_nat_stop (ptid_t ptid
)
5656 iterate_over_lwps (ptid
, linux_nat_stop_lwp
, NULL
);
5658 linux_ops
->to_stop (ptid
);
5662 linux_nat_close (int quitting
)
5664 /* Unregister from the event loop. */
5665 if (target_is_async_p ())
5666 target_async (NULL
, 0);
5668 if (linux_ops
->to_close
)
5669 linux_ops
->to_close (quitting
);
5672 /* When requests are passed down from the linux-nat layer to the
5673 single threaded inf-ptrace layer, ptids of (lwpid,0,0) form are
5674 used. The address space pointer is stored in the inferior object,
5675 but the common code that is passed such ptid can't tell whether
5676 lwpid is a "main" process id or not (it assumes so). We reverse
5677 look up the "main" process id from the lwp here. */
5679 struct address_space
*
5680 linux_nat_thread_address_space (struct target_ops
*t
, ptid_t ptid
)
5682 struct lwp_info
*lwp
;
5683 struct inferior
*inf
;
5686 pid
= GET_LWP (ptid
);
5687 if (GET_LWP (ptid
) == 0)
5689 /* An (lwpid,0,0) ptid. Look up the lwp object to get at the
5691 lwp
= find_lwp_pid (ptid
);
5692 pid
= GET_PID (lwp
->ptid
);
5696 /* A (pid,lwpid,0) ptid. */
5697 pid
= GET_PID (ptid
);
5700 inf
= find_inferior_pid (pid
);
5701 gdb_assert (inf
!= NULL
);
5706 linux_nat_core_of_thread_1 (ptid_t ptid
)
5708 struct cleanup
*back_to
;
5711 char *content
= NULL
;
5714 int content_read
= 0;
5718 filename
= xstrprintf ("/proc/%d/task/%ld/stat",
5719 GET_PID (ptid
), GET_LWP (ptid
));
5720 back_to
= make_cleanup (xfree
, filename
);
5722 f
= fopen (filename
, "r");
5725 do_cleanups (back_to
);
5729 make_cleanup_fclose (f
);
5735 content
= xrealloc (content
, content_read
+ 1024);
5736 n
= fread (content
+ content_read
, 1, 1024, f
);
5740 content
[content_read
] = '\0';
5745 make_cleanup (xfree
, content
);
5747 p
= strchr (content
, '(');
5751 p
= strchr (p
, ')');
5755 /* If the first field after program name has index 0, then core number is
5756 the field with index 36. There's no constant for that anywhere. */
5758 p
= strtok_r (p
, " ", &ts
);
5759 for (i
= 0; p
!= NULL
&& i
!= 36; ++i
)
5760 p
= strtok_r (NULL
, " ", &ts
);
5762 if (p
== NULL
|| sscanf (p
, "%d", &core
) == 0)
5765 do_cleanups (back_to
);
5770 /* Return the cached value of the processor core for thread PTID. */
5773 linux_nat_core_of_thread (struct target_ops
*ops
, ptid_t ptid
)
5775 struct lwp_info
*info
= find_lwp_pid (ptid
);
5783 linux_nat_add_target (struct target_ops
*t
)
5785 /* Save the provided single-threaded target. We save this in a separate
5786 variable because another target we've inherited from (e.g. inf-ptrace)
5787 may have saved a pointer to T; we want to use it for the final
5788 process stratum target. */
5789 linux_ops_saved
= *t
;
5790 linux_ops
= &linux_ops_saved
;
5792 /* Override some methods for multithreading. */
5793 t
->to_create_inferior
= linux_nat_create_inferior
;
5794 t
->to_attach
= linux_nat_attach
;
5795 t
->to_detach
= linux_nat_detach
;
5796 t
->to_resume
= linux_nat_resume
;
5797 t
->to_wait
= linux_nat_wait
;
5798 t
->to_pass_signals
= linux_nat_pass_signals
;
5799 t
->to_xfer_partial
= linux_nat_xfer_partial
;
5800 t
->to_kill
= linux_nat_kill
;
5801 t
->to_mourn_inferior
= linux_nat_mourn_inferior
;
5802 t
->to_thread_alive
= linux_nat_thread_alive
;
5803 t
->to_pid_to_str
= linux_nat_pid_to_str
;
5804 t
->to_thread_name
= linux_nat_thread_name
;
5805 t
->to_has_thread_control
= tc_schedlock
;
5806 t
->to_thread_address_space
= linux_nat_thread_address_space
;
5807 t
->to_stopped_by_watchpoint
= linux_nat_stopped_by_watchpoint
;
5808 t
->to_stopped_data_address
= linux_nat_stopped_data_address
;
5810 t
->to_can_async_p
= linux_nat_can_async_p
;
5811 t
->to_is_async_p
= linux_nat_is_async_p
;
5812 t
->to_supports_non_stop
= linux_nat_supports_non_stop
;
5813 t
->to_async
= linux_nat_async
;
5814 t
->to_terminal_inferior
= linux_nat_terminal_inferior
;
5815 t
->to_terminal_ours
= linux_nat_terminal_ours
;
5816 t
->to_close
= linux_nat_close
;
5818 /* Methods for non-stop support. */
5819 t
->to_stop
= linux_nat_stop
;
5821 t
->to_supports_multi_process
= linux_nat_supports_multi_process
;
5823 t
->to_supports_disable_randomization
5824 = linux_nat_supports_disable_randomization
;
5826 t
->to_core_of_thread
= linux_nat_core_of_thread
;
5828 /* We don't change the stratum; this target will sit at
5829 process_stratum and thread_db will set at thread_stratum. This
5830 is a little strange, since this is a multi-threaded-capable
5831 target, but we want to be on the stack below thread_db, and we
5832 also want to be used for single-threaded processes. */
5837 /* Register a method to call whenever a new thread is attached. */
5839 linux_nat_set_new_thread (struct target_ops
*t
, void (*new_thread
) (ptid_t
))
5841 /* Save the pointer. We only support a single registered instance
5842 of the GNU/Linux native target, so we do not need to map this to
5844 linux_nat_new_thread
= new_thread
;
5847 /* Register a method that converts a siginfo object between the layout
5848 that ptrace returns, and the layout in the architecture of the
5851 linux_nat_set_siginfo_fixup (struct target_ops
*t
,
5852 int (*siginfo_fixup
) (struct siginfo
*,
5856 /* Save the pointer. */
5857 linux_nat_siginfo_fixup
= siginfo_fixup
;
5860 /* Return the saved siginfo associated with PTID. */
5862 linux_nat_get_siginfo (ptid_t ptid
)
5864 struct lwp_info
*lp
= find_lwp_pid (ptid
);
5866 gdb_assert (lp
!= NULL
);
5868 return &lp
->siginfo
;
5871 /* Provide a prototype to silence -Wmissing-prototypes. */
5872 extern initialize_file_ftype _initialize_linux_nat
;
5875 _initialize_linux_nat (void)
5877 static struct cmd_list_element
*info_proc_cmdlist
;
5879 add_prefix_cmd ("proc", class_info
, linux_nat_info_proc_cmd
,
5881 Show /proc process information about any running process.\n\
5882 Specify any process id, or use the program being debugged by default."),
5883 &info_proc_cmdlist
, "info proc ",
5884 1/*allow-unknown*/, &infolist
);
5886 add_cmd ("mappings", class_info
, linux_nat_info_proc_cmd_mappings
, _("\
5887 List of mapped memory regions."),
5888 &info_proc_cmdlist
);
5890 add_cmd ("stat", class_info
, linux_nat_info_proc_cmd_stat
, _("\
5891 List process info from /proc/PID/stat."),
5892 &info_proc_cmdlist
);
5894 add_cmd ("status", class_info
, linux_nat_info_proc_cmd_status
, _("\
5895 List process info from /proc/PID/status."),
5896 &info_proc_cmdlist
);
5898 add_cmd ("cwd", class_info
, linux_nat_info_proc_cmd_cwd
, _("\
5899 List current working directory of the process."),
5900 &info_proc_cmdlist
);
5902 add_cmd ("cmdline", class_info
, linux_nat_info_proc_cmd_cmdline
, _("\
5903 List command line arguments of the process."),
5904 &info_proc_cmdlist
);
5906 add_cmd ("exe", class_info
, linux_nat_info_proc_cmd_exe
, _("\
5907 List absolute filename for executable of the process."),
5908 &info_proc_cmdlist
);
5910 add_cmd ("all", class_info
, linux_nat_info_proc_cmd_all
, _("\
5911 List all available /proc info."),
5912 &info_proc_cmdlist
);
5914 add_setshow_zinteger_cmd ("lin-lwp", class_maintenance
,
5915 &debug_linux_nat
, _("\
5916 Set debugging of GNU/Linux lwp module."), _("\
5917 Show debugging of GNU/Linux lwp module."), _("\
5918 Enables printf debugging output."),
5920 show_debug_linux_nat
,
5921 &setdebuglist
, &showdebuglist
);
5923 /* Save this mask as the default. */
5924 sigprocmask (SIG_SETMASK
, NULL
, &normal_mask
);
5926 /* Install a SIGCHLD handler. */
5927 sigchld_action
.sa_handler
= sigchld_handler
;
5928 sigemptyset (&sigchld_action
.sa_mask
);
5929 sigchld_action
.sa_flags
= SA_RESTART
;
5931 /* Make it the default. */
5932 sigaction (SIGCHLD
, &sigchld_action
, NULL
);
5934 /* Make sure we don't block SIGCHLD during a sigsuspend. */
5935 sigprocmask (SIG_SETMASK
, NULL
, &suspend_mask
);
5936 sigdelset (&suspend_mask
, SIGCHLD
);
5938 sigemptyset (&blocked_mask
);
5942 /* FIXME: kettenis/2000-08-26: The stuff on this page is specific to
5943 the GNU/Linux Threads library and therefore doesn't really belong
5946 /* Read variable NAME in the target and return its value if found.
5947 Otherwise return zero. It is assumed that the type of the variable
5951 get_signo (const char *name
)
5953 struct minimal_symbol
*ms
;
5956 ms
= lookup_minimal_symbol (name
, NULL
, NULL
);
5960 if (target_read_memory (SYMBOL_VALUE_ADDRESS (ms
), (gdb_byte
*) &signo
,
5961 sizeof (signo
)) != 0)
5967 /* Return the set of signals used by the threads library in *SET. */
5970 lin_thread_get_thread_signals (sigset_t
*set
)
5972 struct sigaction action
;
5973 int restart
, cancel
;
5975 sigemptyset (&blocked_mask
);
5978 restart
= get_signo ("__pthread_sig_restart");
5979 cancel
= get_signo ("__pthread_sig_cancel");
5981 /* LinuxThreads normally uses the first two RT signals, but in some legacy
5982 cases may use SIGUSR1/SIGUSR2. NPTL always uses RT signals, but does
5983 not provide any way for the debugger to query the signal numbers -
5984 fortunately they don't change! */
5987 restart
= __SIGRTMIN
;
5990 cancel
= __SIGRTMIN
+ 1;
5992 sigaddset (set
, restart
);
5993 sigaddset (set
, cancel
);
5995 /* The GNU/Linux Threads library makes terminating threads send a
5996 special "cancel" signal instead of SIGCHLD. Make sure we catch
5997 those (to prevent them from terminating GDB itself, which is
5998 likely to be their default action) and treat them the same way as
6001 action
.sa_handler
= sigchld_handler
;
6002 sigemptyset (&action
.sa_mask
);
6003 action
.sa_flags
= SA_RESTART
;
6004 sigaction (cancel
, &action
, NULL
);
6006 /* We block the "cancel" signal throughout this code ... */
6007 sigaddset (&blocked_mask
, cancel
);
6008 sigprocmask (SIG_BLOCK
, &blocked_mask
, NULL
);
6010 /* ... except during a sigsuspend. */
6011 sigdelset (&suspend_mask
, cancel
);