1 /* GNU/Linux native-dependent code common to multiple platforms.
3 Copyright (C) 2001-2014 Free Software Foundation, Inc.
5 This file is part of GDB.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program. If not, see <http://www.gnu.org/licenses/>. */
24 #include "nat/linux-nat.h"
25 #include "nat/linux-waitpid.h"
27 #ifdef HAVE_TKILL_SYSCALL
29 #include <sys/syscall.h>
31 #include <sys/ptrace.h>
32 #include "linux-nat.h"
33 #include "nat/linux-ptrace.h"
34 #include "nat/linux-procfs.h"
35 #include "linux-fork.h"
36 #include "gdbthread.h"
40 #include "inf-child.h"
41 #include "inf-ptrace.h"
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 <sys/stat.h> /* for struct stat */
49 #include <fcntl.h> /* for O_RDONLY */
51 #include "event-loop.h"
52 #include "event-top.h"
54 #include <sys/types.h>
56 #include "xml-support.h"
59 #include "nat/linux-osdata.h"
60 #include "linux-tdep.h"
63 #include "tracepoint.h"
65 #include "target-descriptions.h"
66 #include "filestuff.h"
70 #define SPUFS_MAGIC 0x23c9b64e
73 #ifdef HAVE_PERSONALITY
74 # include <sys/personality.h>
75 # if !HAVE_DECL_ADDR_NO_RANDOMIZE
76 # define ADDR_NO_RANDOMIZE 0x0040000
78 #endif /* HAVE_PERSONALITY */
80 /* This comment documents high-level logic of this file.
82 Waiting for events in sync mode
83 ===============================
85 When waiting for an event in a specific thread, we just use waitpid, passing
86 the specific pid, and not passing WNOHANG.
88 When waiting for an event in all threads, waitpid is not quite good. Prior to
89 version 2.4, Linux can either wait for event in main thread, or in secondary
90 threads. (2.4 has the __WALL flag). So, if we use blocking waitpid, we might
91 miss an event. The solution is to use non-blocking waitpid, together with
92 sigsuspend. First, we use non-blocking waitpid to get an event in the main
93 process, if any. Second, we use non-blocking waitpid with the __WCLONED
94 flag to check for events in cloned processes. If nothing is found, we use
95 sigsuspend to wait for SIGCHLD. When SIGCHLD arrives, it means something
96 happened to a child process -- and SIGCHLD will be delivered both for events
97 in main debugged process and in cloned processes. As soon as we know there's
98 an event, we get back to calling nonblocking waitpid with and without
101 Note that SIGCHLD should be blocked between waitpid and sigsuspend calls,
102 so that we don't miss a signal. If SIGCHLD arrives in between, when it's
103 blocked, the signal becomes pending and sigsuspend immediately
104 notices it and returns.
106 Waiting for events in async mode
107 ================================
109 In async mode, GDB should always be ready to handle both user input
110 and target events, so neither blocking waitpid nor sigsuspend are
111 viable options. Instead, we should asynchronously notify the GDB main
112 event loop whenever there's an unprocessed event from the target. We
113 detect asynchronous target events by handling SIGCHLD signals. To
114 notify the event loop about target events, the self-pipe trick is used
115 --- a pipe is registered as waitable event source in the event loop,
116 the event loop select/poll's on the read end of this pipe (as well on
117 other event sources, e.g., stdin), and the SIGCHLD handler writes a
118 byte to this pipe. This is more portable than relying on
119 pselect/ppoll, since on kernels that lack those syscalls, libc
120 emulates them with select/poll+sigprocmask, and that is racy
121 (a.k.a. plain broken).
123 Obviously, if we fail to notify the event loop if there's a target
124 event, it's bad. OTOH, if we notify the event loop when there's no
125 event from the target, linux_nat_wait will detect that there's no real
126 event to report, and return event of type TARGET_WAITKIND_IGNORE.
127 This is mostly harmless, but it will waste time and is better avoided.
129 The main design point is that every time GDB is outside linux-nat.c,
130 we have a SIGCHLD handler installed that is called when something
131 happens to the target and notifies the GDB event loop. Whenever GDB
132 core decides to handle the event, and calls into linux-nat.c, we
133 process things as in sync mode, except that the we never block in
136 While processing an event, we may end up momentarily blocked in
137 waitpid calls. Those waitpid calls, while blocking, are guarantied to
138 return quickly. E.g., in all-stop mode, before reporting to the core
139 that an LWP hit a breakpoint, all LWPs are stopped by sending them
140 SIGSTOP, and synchronously waiting for the SIGSTOP to be reported.
141 Note that this is different from blocking indefinitely waiting for the
142 next event --- here, we're already handling an event.
147 We stop threads by sending a SIGSTOP. The use of SIGSTOP instead of another
148 signal is not entirely significant; we just need for a signal to be delivered,
149 so that we can intercept it. SIGSTOP's advantage is that it can not be
150 blocked. A disadvantage is that it is not a real-time signal, so it can only
151 be queued once; we do not keep track of other sources of SIGSTOP.
153 Two other signals that can't be blocked are SIGCONT and SIGKILL. But we can't
154 use them, because they have special behavior when the signal is generated -
155 not when it is delivered. SIGCONT resumes the entire thread group and SIGKILL
156 kills the entire thread group.
158 A delivered SIGSTOP would stop the entire thread group, not just the thread we
159 tkill'd. But we never let the SIGSTOP be delivered; we always intercept and
160 cancel it (by PTRACE_CONT without passing SIGSTOP).
162 We could use a real-time signal instead. This would solve those problems; we
163 could use PTRACE_GETSIGINFO to locate the specific stop signals sent by GDB.
164 But we would still have to have some support for SIGSTOP, since PTRACE_ATTACH
165 generates it, and there are races with trying to find a signal that is not
169 #define O_LARGEFILE 0
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) (struct lwp_info *);
180 /* The method to call, if any, when a new fork is attached. */
181 static linux_nat_new_fork_ftype *linux_nat_new_fork;
183 /* The method to call, if any, when a process is no longer
185 static linux_nat_forget_process_ftype *linux_nat_forget_process_hook;
187 /* Hook to call prior to resuming a thread. */
188 static void (*linux_nat_prepare_to_resume) (struct lwp_info *);
190 /* The method to call, if any, when the siginfo object needs to be
191 converted between the layout returned by ptrace, and the layout in
192 the architecture of the inferior. */
193 static int (*linux_nat_siginfo_fixup) (siginfo_t *,
197 /* The saved to_xfer_partial method, inherited from inf-ptrace.c.
198 Called by our to_xfer_partial. */
199 static target_xfer_partial_ftype *super_xfer_partial;
201 /* The saved to_close method, inherited from inf-ptrace.c.
202 Called by our to_close. */
203 static void (*super_close) (struct target_ops *);
205 static unsigned int debug_linux_nat;
207 show_debug_linux_nat (struct ui_file *file, int from_tty,
208 struct cmd_list_element *c, const char *value)
210 fprintf_filtered (file, _("Debugging of GNU/Linux lwp module is %s.\n"),
214 struct simple_pid_list
218 struct simple_pid_list *next;
220 struct simple_pid_list *stopped_pids;
222 /* Async mode support. */
224 /* The read/write ends of the pipe registered as waitable file in the
226 static int linux_nat_event_pipe[2] = { -1, -1 };
228 /* Flush the event pipe. */
231 async_file_flush (void)
238 ret = read (linux_nat_event_pipe[0], &buf, 1);
240 while (ret >= 0 || (ret == -1 && errno == EINTR));
243 /* Put something (anything, doesn't matter what, or how much) in event
244 pipe, so that the select/poll in the event-loop realizes we have
245 something to process. */
248 async_file_mark (void)
252 /* It doesn't really matter what the pipe contains, as long we end
253 up with something in it. Might as well flush the previous
259 ret = write (linux_nat_event_pipe[1], "+", 1);
261 while (ret == -1 && errno == EINTR);
263 /* Ignore EAGAIN. If the pipe is full, the event loop will already
264 be awakened anyway. */
267 static int kill_lwp (int lwpid, int signo);
269 static int stop_callback (struct lwp_info *lp, void *data);
271 static void block_child_signals (sigset_t *prev_mask);
272 static void restore_child_signals_mask (sigset_t *prev_mask);
275 static struct lwp_info *add_lwp (ptid_t ptid);
276 static void purge_lwp_list (int pid);
277 static void delete_lwp (ptid_t ptid);
278 static struct lwp_info *find_lwp_pid (ptid_t ptid);
281 /* Trivial list manipulation functions to keep track of a list of
282 new stopped processes. */
284 add_to_pid_list (struct simple_pid_list **listp, int pid, int status)
286 struct simple_pid_list *new_pid = xmalloc (sizeof (struct simple_pid_list));
289 new_pid->status = status;
290 new_pid->next = *listp;
295 in_pid_list_p (struct simple_pid_list *list, int pid)
297 struct simple_pid_list *p;
299 for (p = list; p != NULL; p = p->next)
306 pull_pid_from_list (struct simple_pid_list **listp, int pid, int *statusp)
308 struct simple_pid_list **p;
310 for (p = listp; *p != NULL; p = &(*p)->next)
311 if ((*p)->pid == pid)
313 struct simple_pid_list *next = (*p)->next;
315 *statusp = (*p)->status;
323 /* Initialize ptrace warnings and check for supported ptrace
326 ATTACHED should be nonzero iff we attached to the inferior. */
329 linux_init_ptrace (pid_t pid, int attached)
331 linux_enable_event_reporting (pid, attached);
332 linux_ptrace_init_warnings ();
336 linux_child_post_attach (struct target_ops *self, int pid)
338 linux_init_ptrace (pid, 1);
342 linux_child_post_startup_inferior (struct target_ops *self, ptid_t ptid)
344 linux_init_ptrace (ptid_get_pid (ptid), 0);
347 /* Return the number of known LWPs in the tgid given by PID. */
355 for (lp = lwp_list; lp; lp = lp->next)
356 if (ptid_get_pid (lp->ptid) == pid)
362 /* Call delete_lwp with prototype compatible for make_cleanup. */
365 delete_lwp_cleanup (void *lp_voidp)
367 struct lwp_info *lp = lp_voidp;
369 delete_lwp (lp->ptid);
372 /* Target hook for follow_fork. On entry inferior_ptid must be the
373 ptid of the followed inferior. At return, inferior_ptid will be
377 linux_child_follow_fork (struct target_ops *ops, int follow_child,
382 struct lwp_info *child_lp = NULL;
383 int status = W_STOPCODE (0);
384 struct cleanup *old_chain;
386 int parent_pid, child_pid;
388 has_vforked = (inferior_thread ()->pending_follow.kind
389 == TARGET_WAITKIND_VFORKED);
390 parent_pid = ptid_get_lwp (inferior_ptid);
392 parent_pid = ptid_get_pid (inferior_ptid);
394 = ptid_get_pid (inferior_thread ()->pending_follow.value.related_pid);
397 /* We're already attached to the parent, by default. */
398 old_chain = save_inferior_ptid ();
399 inferior_ptid = ptid_build (child_pid, child_pid, 0);
400 child_lp = add_lwp (inferior_ptid);
401 child_lp->stopped = 1;
402 child_lp->last_resume_kind = resume_stop;
404 /* Detach new forked process? */
407 make_cleanup (delete_lwp_cleanup, child_lp);
409 if (linux_nat_prepare_to_resume != NULL)
410 linux_nat_prepare_to_resume (child_lp);
412 /* When debugging an inferior in an architecture that supports
413 hardware single stepping on a kernel without commit
414 6580807da14c423f0d0a708108e6df6ebc8bc83d, the vfork child
415 process starts with the TIF_SINGLESTEP/X86_EFLAGS_TF bits
416 set if the parent process had them set.
417 To work around this, single step the child process
418 once before detaching to clear the flags. */
420 if (!gdbarch_software_single_step_p (target_thread_architecture
423 linux_disable_event_reporting (child_pid);
424 if (ptrace (PTRACE_SINGLESTEP, child_pid, 0, 0) < 0)
425 perror_with_name (_("Couldn't do single step"));
426 if (my_waitpid (child_pid, &status, 0) < 0)
427 perror_with_name (_("Couldn't wait vfork process"));
430 if (WIFSTOPPED (status))
434 signo = WSTOPSIG (status);
436 && !signal_pass_state (gdb_signal_from_host (signo)))
438 ptrace (PTRACE_DETACH, child_pid, 0, signo);
441 /* Resets value of inferior_ptid to parent ptid. */
442 do_cleanups (old_chain);
446 /* Let the thread_db layer learn about this new process. */
447 check_for_thread_db ();
450 do_cleanups (old_chain);
454 struct lwp_info *parent_lp;
456 parent_lp = find_lwp_pid (pid_to_ptid (parent_pid));
457 gdb_assert (linux_supports_tracefork () >= 0);
459 if (linux_supports_tracevforkdone ())
462 fprintf_unfiltered (gdb_stdlog,
463 "LCFF: waiting for VFORK_DONE on %d\n",
465 parent_lp->stopped = 1;
467 /* We'll handle the VFORK_DONE event like any other
468 event, in target_wait. */
472 /* We can't insert breakpoints until the child has
473 finished with the shared memory region. We need to
474 wait until that happens. Ideal would be to just
476 - ptrace (PTRACE_SYSCALL, parent_pid, 0, 0);
477 - waitpid (parent_pid, &status, __WALL);
478 However, most architectures can't handle a syscall
479 being traced on the way out if it wasn't traced on
482 We might also think to loop, continuing the child
483 until it exits or gets a SIGTRAP. One problem is
484 that the child might call ptrace with PTRACE_TRACEME.
486 There's no simple and reliable way to figure out when
487 the vforked child will be done with its copy of the
488 shared memory. We could step it out of the syscall,
489 two instructions, let it go, and then single-step the
490 parent once. When we have hardware single-step, this
491 would work; with software single-step it could still
492 be made to work but we'd have to be able to insert
493 single-step breakpoints in the child, and we'd have
494 to insert -just- the single-step breakpoint in the
495 parent. Very awkward.
497 In the end, the best we can do is to make sure it
498 runs for a little while. Hopefully it will be out of
499 range of any breakpoints we reinsert. Usually this
500 is only the single-step breakpoint at vfork's return
504 fprintf_unfiltered (gdb_stdlog,
505 "LCFF: no VFORK_DONE "
506 "support, sleeping a bit\n");
510 /* Pretend we've seen a PTRACE_EVENT_VFORK_DONE event,
511 and leave it pending. The next linux_nat_resume call
512 will notice a pending event, and bypasses actually
513 resuming the inferior. */
514 parent_lp->status = 0;
515 parent_lp->waitstatus.kind = TARGET_WAITKIND_VFORK_DONE;
516 parent_lp->stopped = 1;
518 /* If we're in async mode, need to tell the event loop
519 there's something here to process. */
520 if (target_can_async_p ())
527 struct lwp_info *child_lp;
529 child_lp = add_lwp (inferior_ptid);
530 child_lp->stopped = 1;
531 child_lp->last_resume_kind = resume_stop;
533 /* Let the thread_db layer learn about this new process. */
534 check_for_thread_db ();
542 linux_child_insert_fork_catchpoint (struct target_ops *self, int pid)
544 return !linux_supports_tracefork ();
548 linux_child_remove_fork_catchpoint (struct target_ops *self, int pid)
554 linux_child_insert_vfork_catchpoint (struct target_ops *self, int pid)
556 return !linux_supports_tracefork ();
560 linux_child_remove_vfork_catchpoint (struct target_ops *self, int pid)
566 linux_child_insert_exec_catchpoint (struct target_ops *self, int pid)
568 return !linux_supports_tracefork ();
572 linux_child_remove_exec_catchpoint (struct target_ops *self, int pid)
578 linux_child_set_syscall_catchpoint (struct target_ops *self,
579 int pid, int needed, int any_count,
580 int table_size, int *table)
582 if (!linux_supports_tracesysgood ())
585 /* On GNU/Linux, we ignore the arguments. It means that we only
586 enable the syscall catchpoints, but do not disable them.
588 Also, we do not use the `table' information because we do not
589 filter system calls here. We let GDB do the logic for us. */
593 /* On GNU/Linux there are no real LWP's. The closest thing to LWP's
594 are processes sharing the same VM space. A multi-threaded process
595 is basically a group of such processes. However, such a grouping
596 is almost entirely a user-space issue; the kernel doesn't enforce
597 such a grouping at all (this might change in the future). In
598 general, we'll rely on the threads library (i.e. the GNU/Linux
599 Threads library) to provide such a grouping.
601 It is perfectly well possible to write a multi-threaded application
602 without the assistance of a threads library, by using the clone
603 system call directly. This module should be able to give some
604 rudimentary support for debugging such applications if developers
605 specify the CLONE_PTRACE flag in the clone system call, and are
606 using the Linux kernel 2.4 or above.
608 Note that there are some peculiarities in GNU/Linux that affect
611 - In general one should specify the __WCLONE flag to waitpid in
612 order to make it report events for any of the cloned processes
613 (and leave it out for the initial process). However, if a cloned
614 process has exited the exit status is only reported if the
615 __WCLONE flag is absent. Linux kernel 2.4 has a __WALL flag, but
616 we cannot use it since GDB must work on older systems too.
618 - When a traced, cloned process exits and is waited for by the
619 debugger, the kernel reassigns it to the original parent and
620 keeps it around as a "zombie". Somehow, the GNU/Linux Threads
621 library doesn't notice this, which leads to the "zombie problem":
622 When debugged a multi-threaded process that spawns a lot of
623 threads will run out of processes, even if the threads exit,
624 because the "zombies" stay around. */
626 /* List of known LWPs. */
627 struct lwp_info *lwp_list;
630 /* Original signal mask. */
631 static sigset_t normal_mask;
633 /* Signal mask for use with sigsuspend in linux_nat_wait, initialized in
634 _initialize_linux_nat. */
635 static sigset_t suspend_mask;
637 /* Signals to block to make that sigsuspend work. */
638 static sigset_t blocked_mask;
640 /* SIGCHLD action. */
641 struct sigaction sigchld_action;
643 /* Block child signals (SIGCHLD and linux threads signals), and store
644 the previous mask in PREV_MASK. */
647 block_child_signals (sigset_t *prev_mask)
649 /* Make sure SIGCHLD is blocked. */
650 if (!sigismember (&blocked_mask, SIGCHLD))
651 sigaddset (&blocked_mask, SIGCHLD);
653 sigprocmask (SIG_BLOCK, &blocked_mask, prev_mask);
656 /* Restore child signals mask, previously returned by
657 block_child_signals. */
660 restore_child_signals_mask (sigset_t *prev_mask)
662 sigprocmask (SIG_SETMASK, prev_mask, NULL);
665 /* Mask of signals to pass directly to the inferior. */
666 static sigset_t pass_mask;
668 /* Update signals to pass to the inferior. */
670 linux_nat_pass_signals (struct target_ops *self,
671 int numsigs, unsigned char *pass_signals)
675 sigemptyset (&pass_mask);
677 for (signo = 1; signo < NSIG; signo++)
679 int target_signo = gdb_signal_from_host (signo);
680 if (target_signo < numsigs && pass_signals[target_signo])
681 sigaddset (&pass_mask, signo);
687 /* Prototypes for local functions. */
688 static int stop_wait_callback (struct lwp_info *lp, void *data);
689 static int linux_thread_alive (ptid_t ptid);
690 static char *linux_child_pid_to_exec_file (struct target_ops *self, int pid);
694 /* Destroy and free LP. */
697 lwp_free (struct lwp_info *lp)
699 xfree (lp->arch_private);
703 /* Remove all LWPs belong to PID from the lwp list. */
706 purge_lwp_list (int pid)
708 struct lwp_info *lp, *lpprev, *lpnext;
712 for (lp = lwp_list; lp; lp = lpnext)
716 if (ptid_get_pid (lp->ptid) == pid)
721 lpprev->next = lp->next;
730 /* Add the LWP specified by PTID to the list. PTID is the first LWP
731 in the process. Return a pointer to the structure describing the
734 This differs from add_lwp in that we don't let the arch specific
735 bits know about this new thread. Current clients of this callback
736 take the opportunity to install watchpoints in the new thread, and
737 we shouldn't do that for the first thread. If we're spawning a
738 child ("run"), the thread executes the shell wrapper first, and we
739 shouldn't touch it until it execs the program we want to debug.
740 For "attach", it'd be okay to call the callback, but it's not
741 necessary, because watchpoints can't yet have been inserted into
744 static struct lwp_info *
745 add_initial_lwp (ptid_t ptid)
749 gdb_assert (ptid_lwp_p (ptid));
751 lp = (struct lwp_info *) xmalloc (sizeof (struct lwp_info));
753 memset (lp, 0, sizeof (struct lwp_info));
755 lp->last_resume_kind = resume_continue;
756 lp->waitstatus.kind = TARGET_WAITKIND_IGNORE;
767 /* Add the LWP specified by PID to the list. Return a pointer to the
768 structure describing the new LWP. The LWP should already be
771 static struct lwp_info *
772 add_lwp (ptid_t ptid)
776 lp = add_initial_lwp (ptid);
778 /* Let the arch specific bits know about this new thread. Current
779 clients of this callback take the opportunity to install
780 watchpoints in the new thread. We don't do this for the first
781 thread though. See add_initial_lwp. */
782 if (linux_nat_new_thread != NULL)
783 linux_nat_new_thread (lp);
788 /* Remove the LWP specified by PID from the list. */
791 delete_lwp (ptid_t ptid)
793 struct lwp_info *lp, *lpprev;
797 for (lp = lwp_list; lp; lpprev = lp, lp = lp->next)
798 if (ptid_equal (lp->ptid, ptid))
805 lpprev->next = lp->next;
812 /* Return a pointer to the structure describing the LWP corresponding
813 to PID. If no corresponding LWP could be found, return NULL. */
815 static struct lwp_info *
816 find_lwp_pid (ptid_t ptid)
821 if (ptid_lwp_p (ptid))
822 lwp = ptid_get_lwp (ptid);
824 lwp = ptid_get_pid (ptid);
826 for (lp = lwp_list; lp; lp = lp->next)
827 if (lwp == ptid_get_lwp (lp->ptid))
833 /* Call CALLBACK with its second argument set to DATA for every LWP in
834 the list. If CALLBACK returns 1 for a particular LWP, return a
835 pointer to the structure describing that LWP immediately.
836 Otherwise return NULL. */
839 iterate_over_lwps (ptid_t filter,
840 int (*callback) (struct lwp_info *, void *),
843 struct lwp_info *lp, *lpnext;
845 for (lp = lwp_list; lp; lp = lpnext)
849 if (ptid_match (lp->ptid, filter))
851 if ((*callback) (lp, data))
859 /* Update our internal state when changing from one checkpoint to
860 another indicated by NEW_PTID. We can only switch single-threaded
861 applications, so we only create one new LWP, and the previous list
865 linux_nat_switch_fork (ptid_t new_ptid)
869 purge_lwp_list (ptid_get_pid (inferior_ptid));
871 lp = add_lwp (new_ptid);
874 /* This changes the thread's ptid while preserving the gdb thread
875 num. Also changes the inferior pid, while preserving the
877 thread_change_ptid (inferior_ptid, new_ptid);
879 /* We've just told GDB core that the thread changed target id, but,
880 in fact, it really is a different thread, with different register
882 registers_changed ();
885 /* Handle the exit of a single thread LP. */
888 exit_lwp (struct lwp_info *lp)
890 struct thread_info *th = find_thread_ptid (lp->ptid);
894 if (print_thread_events)
895 printf_unfiltered (_("[%s exited]\n"), target_pid_to_str (lp->ptid));
897 delete_thread (lp->ptid);
900 delete_lwp (lp->ptid);
903 /* Wait for the LWP specified by LP, which we have just attached to.
904 Returns a wait status for that LWP, to cache. */
907 linux_nat_post_attach_wait (ptid_t ptid, int first, int *cloned,
910 pid_t new_pid, pid = ptid_get_lwp (ptid);
913 if (linux_proc_pid_is_stopped (pid))
916 fprintf_unfiltered (gdb_stdlog,
917 "LNPAW: Attaching to a stopped process\n");
919 /* The process is definitely stopped. It is in a job control
920 stop, unless the kernel predates the TASK_STOPPED /
921 TASK_TRACED distinction, in which case it might be in a
922 ptrace stop. Make sure it is in a ptrace stop; from there we
923 can kill it, signal it, et cetera.
925 First make sure there is a pending SIGSTOP. Since we are
926 already attached, the process can not transition from stopped
927 to running without a PTRACE_CONT; so we know this signal will
928 go into the queue. The SIGSTOP generated by PTRACE_ATTACH is
929 probably already in the queue (unless this kernel is old
930 enough to use TASK_STOPPED for ptrace stops); but since SIGSTOP
931 is not an RT signal, it can only be queued once. */
932 kill_lwp (pid, SIGSTOP);
934 /* Finally, resume the stopped process. This will deliver the SIGSTOP
935 (or a higher priority signal, just like normal PTRACE_ATTACH). */
936 ptrace (PTRACE_CONT, pid, 0, 0);
939 /* Make sure the initial process is stopped. The user-level threads
940 layer might want to poke around in the inferior, and that won't
941 work if things haven't stabilized yet. */
942 new_pid = my_waitpid (pid, &status, 0);
943 if (new_pid == -1 && errno == ECHILD)
946 warning (_("%s is a cloned process"), target_pid_to_str (ptid));
948 /* Try again with __WCLONE to check cloned processes. */
949 new_pid = my_waitpid (pid, &status, __WCLONE);
953 gdb_assert (pid == new_pid);
955 if (!WIFSTOPPED (status))
957 /* The pid we tried to attach has apparently just exited. */
959 fprintf_unfiltered (gdb_stdlog, "LNPAW: Failed to stop %d: %s",
960 pid, status_to_str (status));
964 if (WSTOPSIG (status) != SIGSTOP)
968 fprintf_unfiltered (gdb_stdlog,
969 "LNPAW: Received %s after attaching\n",
970 status_to_str (status));
976 /* Attach to the LWP specified by PID. Return 0 if successful, -1 if
977 the new LWP could not be attached, or 1 if we're already auto
978 attached to this thread, but haven't processed the
979 PTRACE_EVENT_CLONE event of its parent thread, so we just ignore
980 its existance, without considering it an error. */
983 lin_lwp_attach_lwp (ptid_t ptid)
988 gdb_assert (ptid_lwp_p (ptid));
990 lp = find_lwp_pid (ptid);
991 lwpid = ptid_get_lwp (ptid);
993 /* We assume that we're already attached to any LWP that has an id
994 equal to the overall process id, and to any LWP that is already
995 in our list of LWPs. If we're not seeing exit events from threads
996 and we've had PID wraparound since we last tried to stop all threads,
997 this assumption might be wrong; fortunately, this is very unlikely
999 if (lwpid != ptid_get_pid (ptid) && lp == NULL)
1001 int status, cloned = 0, signalled = 0;
1003 if (ptrace (PTRACE_ATTACH, lwpid, 0, 0) < 0)
1005 if (linux_supports_tracefork ())
1007 /* If we haven't stopped all threads when we get here,
1008 we may have seen a thread listed in thread_db's list,
1009 but not processed the PTRACE_EVENT_CLONE yet. If
1010 that's the case, ignore this new thread, and let
1011 normal event handling discover it later. */
1012 if (in_pid_list_p (stopped_pids, lwpid))
1014 /* We've already seen this thread stop, but we
1015 haven't seen the PTRACE_EVENT_CLONE extended
1024 /* See if we've got a stop for this new child
1025 pending. If so, we're already attached. */
1026 new_pid = my_waitpid (lwpid, &status, WNOHANG);
1027 if (new_pid == -1 && errno == ECHILD)
1028 new_pid = my_waitpid (lwpid, &status, __WCLONE | WNOHANG);
1031 if (WIFSTOPPED (status))
1032 add_to_pid_list (&stopped_pids, lwpid, status);
1038 /* If we fail to attach to the thread, issue a warning,
1039 but continue. One way this can happen is if thread
1040 creation is interrupted; as of Linux kernel 2.6.19, a
1041 bug may place threads in the thread list and then fail
1043 warning (_("Can't attach %s: %s"), target_pid_to_str (ptid),
1044 safe_strerror (errno));
1048 if (debug_linux_nat)
1049 fprintf_unfiltered (gdb_stdlog,
1050 "LLAL: PTRACE_ATTACH %s, 0, 0 (OK)\n",
1051 target_pid_to_str (ptid));
1053 status = linux_nat_post_attach_wait (ptid, 0, &cloned, &signalled);
1054 if (!WIFSTOPPED (status))
1057 lp = add_lwp (ptid);
1059 lp->cloned = cloned;
1060 lp->signalled = signalled;
1061 if (WSTOPSIG (status) != SIGSTOP)
1064 lp->status = status;
1067 target_post_attach (ptid_get_lwp (lp->ptid));
1069 if (debug_linux_nat)
1071 fprintf_unfiltered (gdb_stdlog,
1072 "LLAL: waitpid %s received %s\n",
1073 target_pid_to_str (ptid),
1074 status_to_str (status));
1079 /* We assume that the LWP representing the original process is
1080 already stopped. Mark it as stopped in the data structure
1081 that the GNU/linux ptrace layer uses to keep track of
1082 threads. Note that this won't have already been done since
1083 the main thread will have, we assume, been stopped by an
1084 attach from a different layer. */
1086 lp = add_lwp (ptid);
1090 lp->last_resume_kind = resume_stop;
1095 linux_nat_create_inferior (struct target_ops *ops,
1096 char *exec_file, char *allargs, char **env,
1099 #ifdef HAVE_PERSONALITY
1100 int personality_orig = 0, personality_set = 0;
1101 #endif /* HAVE_PERSONALITY */
1103 /* The fork_child mechanism is synchronous and calls target_wait, so
1104 we have to mask the async mode. */
1106 #ifdef HAVE_PERSONALITY
1107 if (disable_randomization)
1110 personality_orig = personality (0xffffffff);
1111 if (errno == 0 && !(personality_orig & ADDR_NO_RANDOMIZE))
1113 personality_set = 1;
1114 personality (personality_orig | ADDR_NO_RANDOMIZE);
1116 if (errno != 0 || (personality_set
1117 && !(personality (0xffffffff) & ADDR_NO_RANDOMIZE)))
1118 warning (_("Error disabling address space randomization: %s"),
1119 safe_strerror (errno));
1121 #endif /* HAVE_PERSONALITY */
1123 /* Make sure we report all signals during startup. */
1124 linux_nat_pass_signals (ops, 0, NULL);
1126 linux_ops->to_create_inferior (ops, exec_file, allargs, env, from_tty);
1128 #ifdef HAVE_PERSONALITY
1129 if (personality_set)
1132 personality (personality_orig);
1134 warning (_("Error restoring address space randomization: %s"),
1135 safe_strerror (errno));
1137 #endif /* HAVE_PERSONALITY */
1141 linux_nat_attach (struct target_ops *ops, const char *args, int from_tty)
1143 struct lwp_info *lp;
1146 volatile struct gdb_exception ex;
1148 /* Make sure we report all signals during attach. */
1149 linux_nat_pass_signals (ops, 0, NULL);
1151 TRY_CATCH (ex, RETURN_MASK_ERROR)
1153 linux_ops->to_attach (ops, args, from_tty);
1157 pid_t pid = parse_pid_to_attach (args);
1158 struct buffer buffer;
1159 char *message, *buffer_s;
1161 message = xstrdup (ex.message);
1162 make_cleanup (xfree, message);
1164 buffer_init (&buffer);
1165 linux_ptrace_attach_fail_reason (pid, &buffer);
1167 buffer_grow_str0 (&buffer, "");
1168 buffer_s = buffer_finish (&buffer);
1169 make_cleanup (xfree, buffer_s);
1171 if (*buffer_s != '\0')
1172 throw_error (ex.error, "warning: %s\n%s", buffer_s, message);
1174 throw_error (ex.error, "%s", message);
1177 /* The ptrace base target adds the main thread with (pid,0,0)
1178 format. Decorate it with lwp info. */
1179 ptid = ptid_build (ptid_get_pid (inferior_ptid),
1180 ptid_get_pid (inferior_ptid),
1182 thread_change_ptid (inferior_ptid, ptid);
1184 /* Add the initial process as the first LWP to the list. */
1185 lp = add_initial_lwp (ptid);
1187 status = linux_nat_post_attach_wait (lp->ptid, 1, &lp->cloned,
1189 if (!WIFSTOPPED (status))
1191 if (WIFEXITED (status))
1193 int exit_code = WEXITSTATUS (status);
1195 target_terminal_ours ();
1196 target_mourn_inferior ();
1198 error (_("Unable to attach: program exited normally."));
1200 error (_("Unable to attach: program exited with code %d."),
1203 else if (WIFSIGNALED (status))
1205 enum gdb_signal signo;
1207 target_terminal_ours ();
1208 target_mourn_inferior ();
1210 signo = gdb_signal_from_host (WTERMSIG (status));
1211 error (_("Unable to attach: program terminated with signal "
1213 gdb_signal_to_name (signo),
1214 gdb_signal_to_string (signo));
1217 internal_error (__FILE__, __LINE__,
1218 _("unexpected status %d for PID %ld"),
1219 status, (long) ptid_get_lwp (ptid));
1224 /* Save the wait status to report later. */
1226 if (debug_linux_nat)
1227 fprintf_unfiltered (gdb_stdlog,
1228 "LNA: waitpid %ld, saving status %s\n",
1229 (long) ptid_get_pid (lp->ptid), status_to_str (status));
1231 lp->status = status;
1233 if (target_can_async_p ())
1234 target_async (inferior_event_handler, 0);
1237 /* Get pending status of LP. */
1239 get_pending_status (struct lwp_info *lp, int *status)
1241 enum gdb_signal signo = GDB_SIGNAL_0;
1243 /* If we paused threads momentarily, we may have stored pending
1244 events in lp->status or lp->waitstatus (see stop_wait_callback),
1245 and GDB core hasn't seen any signal for those threads.
1246 Otherwise, the last signal reported to the core is found in the
1247 thread object's stop_signal.
1249 There's a corner case that isn't handled here at present. Only
1250 if the thread stopped with a TARGET_WAITKIND_STOPPED does
1251 stop_signal make sense as a real signal to pass to the inferior.
1252 Some catchpoint related events, like
1253 TARGET_WAITKIND_(V)FORK|EXEC|SYSCALL, have their stop_signal set
1254 to GDB_SIGNAL_SIGTRAP when the catchpoint triggers. But,
1255 those traps are debug API (ptrace in our case) related and
1256 induced; the inferior wouldn't see them if it wasn't being
1257 traced. Hence, we should never pass them to the inferior, even
1258 when set to pass state. Since this corner case isn't handled by
1259 infrun.c when proceeding with a signal, for consistency, neither
1260 do we handle it here (or elsewhere in the file we check for
1261 signal pass state). Normally SIGTRAP isn't set to pass state, so
1262 this is really a corner case. */
1264 if (lp->waitstatus.kind != TARGET_WAITKIND_IGNORE)
1265 signo = GDB_SIGNAL_0; /* a pending ptrace event, not a real signal. */
1266 else if (lp->status)
1267 signo = gdb_signal_from_host (WSTOPSIG (lp->status));
1268 else if (non_stop && !is_executing (lp->ptid))
1270 struct thread_info *tp = find_thread_ptid (lp->ptid);
1272 signo = tp->suspend.stop_signal;
1276 struct target_waitstatus last;
1279 get_last_target_status (&last_ptid, &last);
1281 if (ptid_get_lwp (lp->ptid) == ptid_get_lwp (last_ptid))
1283 struct thread_info *tp = find_thread_ptid (lp->ptid);
1285 signo = tp->suspend.stop_signal;
1291 if (signo == GDB_SIGNAL_0)
1293 if (debug_linux_nat)
1294 fprintf_unfiltered (gdb_stdlog,
1295 "GPT: lwp %s has no pending signal\n",
1296 target_pid_to_str (lp->ptid));
1298 else if (!signal_pass_state (signo))
1300 if (debug_linux_nat)
1301 fprintf_unfiltered (gdb_stdlog,
1302 "GPT: lwp %s had signal %s, "
1303 "but it is in no pass state\n",
1304 target_pid_to_str (lp->ptid),
1305 gdb_signal_to_string (signo));
1309 *status = W_STOPCODE (gdb_signal_to_host (signo));
1311 if (debug_linux_nat)
1312 fprintf_unfiltered (gdb_stdlog,
1313 "GPT: lwp %s has pending signal %s\n",
1314 target_pid_to_str (lp->ptid),
1315 gdb_signal_to_string (signo));
1322 detach_callback (struct lwp_info *lp, void *data)
1324 gdb_assert (lp->status == 0 || WIFSTOPPED (lp->status));
1326 if (debug_linux_nat && lp->status)
1327 fprintf_unfiltered (gdb_stdlog, "DC: Pending %s for %s on detach.\n",
1328 strsignal (WSTOPSIG (lp->status)),
1329 target_pid_to_str (lp->ptid));
1331 /* If there is a pending SIGSTOP, get rid of it. */
1334 if (debug_linux_nat)
1335 fprintf_unfiltered (gdb_stdlog,
1336 "DC: Sending SIGCONT to %s\n",
1337 target_pid_to_str (lp->ptid));
1339 kill_lwp (ptid_get_lwp (lp->ptid), SIGCONT);
1343 /* We don't actually detach from the LWP that has an id equal to the
1344 overall process id just yet. */
1345 if (ptid_get_lwp (lp->ptid) != ptid_get_pid (lp->ptid))
1349 /* Pass on any pending signal for this LWP. */
1350 get_pending_status (lp, &status);
1352 if (linux_nat_prepare_to_resume != NULL)
1353 linux_nat_prepare_to_resume (lp);
1355 if (ptrace (PTRACE_DETACH, ptid_get_lwp (lp->ptid), 0,
1356 WSTOPSIG (status)) < 0)
1357 error (_("Can't detach %s: %s"), target_pid_to_str (lp->ptid),
1358 safe_strerror (errno));
1360 if (debug_linux_nat)
1361 fprintf_unfiltered (gdb_stdlog,
1362 "PTRACE_DETACH (%s, %s, 0) (OK)\n",
1363 target_pid_to_str (lp->ptid),
1364 strsignal (WSTOPSIG (status)));
1366 delete_lwp (lp->ptid);
1373 linux_nat_detach (struct target_ops *ops, const char *args, int from_tty)
1377 struct lwp_info *main_lwp;
1379 pid = ptid_get_pid (inferior_ptid);
1381 /* Don't unregister from the event loop, as there may be other
1382 inferiors running. */
1384 /* Stop all threads before detaching. ptrace requires that the
1385 thread is stopped to sucessfully detach. */
1386 iterate_over_lwps (pid_to_ptid (pid), stop_callback, NULL);
1387 /* ... and wait until all of them have reported back that
1388 they're no longer running. */
1389 iterate_over_lwps (pid_to_ptid (pid), stop_wait_callback, NULL);
1391 iterate_over_lwps (pid_to_ptid (pid), detach_callback, NULL);
1393 /* Only the initial process should be left right now. */
1394 gdb_assert (num_lwps (ptid_get_pid (inferior_ptid)) == 1);
1396 main_lwp = find_lwp_pid (pid_to_ptid (pid));
1398 /* Pass on any pending signal for the last LWP. */
1399 if ((args == NULL || *args == '\0')
1400 && get_pending_status (main_lwp, &status) != -1
1401 && WIFSTOPPED (status))
1405 /* Put the signal number in ARGS so that inf_ptrace_detach will
1406 pass it along with PTRACE_DETACH. */
1408 xsnprintf (tem, 8, "%d", (int) WSTOPSIG (status));
1410 if (debug_linux_nat)
1411 fprintf_unfiltered (gdb_stdlog,
1412 "LND: Sending signal %s to %s\n",
1414 target_pid_to_str (main_lwp->ptid));
1417 if (linux_nat_prepare_to_resume != NULL)
1418 linux_nat_prepare_to_resume (main_lwp);
1419 delete_lwp (main_lwp->ptid);
1421 if (forks_exist_p ())
1423 /* Multi-fork case. The current inferior_ptid is being detached
1424 from, but there are other viable forks to debug. Detach from
1425 the current fork, and context-switch to the first
1427 linux_fork_detach (args, from_tty);
1430 linux_ops->to_detach (ops, args, from_tty);
1436 resume_lwp (struct lwp_info *lp, int step, enum gdb_signal signo)
1440 struct inferior *inf = find_inferior_ptid (lp->ptid);
1442 if (inf->vfork_child != NULL)
1444 if (debug_linux_nat)
1445 fprintf_unfiltered (gdb_stdlog,
1446 "RC: Not resuming %s (vfork parent)\n",
1447 target_pid_to_str (lp->ptid));
1449 else if (lp->status == 0
1450 && lp->waitstatus.kind == TARGET_WAITKIND_IGNORE)
1452 if (debug_linux_nat)
1453 fprintf_unfiltered (gdb_stdlog,
1454 "RC: Resuming sibling %s, %s, %s\n",
1455 target_pid_to_str (lp->ptid),
1456 (signo != GDB_SIGNAL_0
1457 ? strsignal (gdb_signal_to_host (signo))
1459 step ? "step" : "resume");
1461 if (linux_nat_prepare_to_resume != NULL)
1462 linux_nat_prepare_to_resume (lp);
1463 linux_ops->to_resume (linux_ops,
1464 pid_to_ptid (ptid_get_lwp (lp->ptid)),
1468 lp->stopped_by_watchpoint = 0;
1472 if (debug_linux_nat)
1473 fprintf_unfiltered (gdb_stdlog,
1474 "RC: Not resuming sibling %s (has pending)\n",
1475 target_pid_to_str (lp->ptid));
1480 if (debug_linux_nat)
1481 fprintf_unfiltered (gdb_stdlog,
1482 "RC: Not resuming sibling %s (not stopped)\n",
1483 target_pid_to_str (lp->ptid));
1487 /* Callback for iterate_over_lwps. If LWP is EXCEPT, do nothing.
1488 Resume LWP with the last stop signal, if it is in pass state. */
1491 linux_nat_resume_callback (struct lwp_info *lp, void *except)
1493 enum gdb_signal signo = GDB_SIGNAL_0;
1500 struct thread_info *thread;
1502 thread = find_thread_ptid (lp->ptid);
1505 signo = thread->suspend.stop_signal;
1506 thread->suspend.stop_signal = GDB_SIGNAL_0;
1510 resume_lwp (lp, 0, signo);
1515 resume_clear_callback (struct lwp_info *lp, void *data)
1518 lp->last_resume_kind = resume_stop;
1523 resume_set_callback (struct lwp_info *lp, void *data)
1526 lp->last_resume_kind = resume_continue;
1531 linux_nat_resume (struct target_ops *ops,
1532 ptid_t ptid, int step, enum gdb_signal signo)
1534 struct lwp_info *lp;
1537 if (debug_linux_nat)
1538 fprintf_unfiltered (gdb_stdlog,
1539 "LLR: Preparing to %s %s, %s, inferior_ptid %s\n",
1540 step ? "step" : "resume",
1541 target_pid_to_str (ptid),
1542 (signo != GDB_SIGNAL_0
1543 ? strsignal (gdb_signal_to_host (signo)) : "0"),
1544 target_pid_to_str (inferior_ptid));
1546 /* A specific PTID means `step only this process id'. */
1547 resume_many = (ptid_equal (minus_one_ptid, ptid)
1548 || ptid_is_pid (ptid));
1550 /* Mark the lwps we're resuming as resumed. */
1551 iterate_over_lwps (ptid, resume_set_callback, NULL);
1553 /* See if it's the current inferior that should be handled
1556 lp = find_lwp_pid (inferior_ptid);
1558 lp = find_lwp_pid (ptid);
1559 gdb_assert (lp != NULL);
1561 /* Remember if we're stepping. */
1563 lp->last_resume_kind = step ? resume_step : resume_continue;
1565 /* If we have a pending wait status for this thread, there is no
1566 point in resuming the process. But first make sure that
1567 linux_nat_wait won't preemptively handle the event - we
1568 should never take this short-circuit if we are going to
1569 leave LP running, since we have skipped resuming all the
1570 other threads. This bit of code needs to be synchronized
1571 with linux_nat_wait. */
1573 if (lp->status && WIFSTOPPED (lp->status))
1576 && WSTOPSIG (lp->status)
1577 && sigismember (&pass_mask, WSTOPSIG (lp->status)))
1579 if (debug_linux_nat)
1580 fprintf_unfiltered (gdb_stdlog,
1581 "LLR: Not short circuiting for ignored "
1582 "status 0x%x\n", lp->status);
1584 /* FIXME: What should we do if we are supposed to continue
1585 this thread with a signal? */
1586 gdb_assert (signo == GDB_SIGNAL_0);
1587 signo = gdb_signal_from_host (WSTOPSIG (lp->status));
1592 if (lp->status || lp->waitstatus.kind != TARGET_WAITKIND_IGNORE)
1594 /* FIXME: What should we do if we are supposed to continue
1595 this thread with a signal? */
1596 gdb_assert (signo == GDB_SIGNAL_0);
1598 if (debug_linux_nat)
1599 fprintf_unfiltered (gdb_stdlog,
1600 "LLR: Short circuiting for status 0x%x\n",
1603 if (target_can_async_p ())
1605 target_async (inferior_event_handler, 0);
1606 /* Tell the event loop we have something to process. */
1613 iterate_over_lwps (ptid, linux_nat_resume_callback, lp);
1615 /* Convert to something the lower layer understands. */
1616 ptid = pid_to_ptid (ptid_get_lwp (lp->ptid));
1618 if (linux_nat_prepare_to_resume != NULL)
1619 linux_nat_prepare_to_resume (lp);
1620 linux_ops->to_resume (linux_ops, ptid, step, signo);
1621 lp->stopped_by_watchpoint = 0;
1624 if (debug_linux_nat)
1625 fprintf_unfiltered (gdb_stdlog,
1626 "LLR: %s %s, %s (resume event thread)\n",
1627 step ? "PTRACE_SINGLESTEP" : "PTRACE_CONT",
1628 target_pid_to_str (ptid),
1629 (signo != GDB_SIGNAL_0
1630 ? strsignal (gdb_signal_to_host (signo)) : "0"));
1632 if (target_can_async_p ())
1633 target_async (inferior_event_handler, 0);
1636 /* Send a signal to an LWP. */
1639 kill_lwp (int lwpid, int signo)
1641 /* Use tkill, if possible, in case we are using nptl threads. If tkill
1642 fails, then we are not using nptl threads and we should be using kill. */
1644 #ifdef HAVE_TKILL_SYSCALL
1646 static int tkill_failed;
1653 ret = syscall (__NR_tkill, lwpid, signo);
1654 if (errno != ENOSYS)
1661 return kill (lwpid, signo);
1664 /* Handle a GNU/Linux syscall trap wait response. If we see a syscall
1665 event, check if the core is interested in it: if not, ignore the
1666 event, and keep waiting; otherwise, we need to toggle the LWP's
1667 syscall entry/exit status, since the ptrace event itself doesn't
1668 indicate it, and report the trap to higher layers. */
1671 linux_handle_syscall_trap (struct lwp_info *lp, int stopping)
1673 struct target_waitstatus *ourstatus = &lp->waitstatus;
1674 struct gdbarch *gdbarch = target_thread_architecture (lp->ptid);
1675 int syscall_number = (int) gdbarch_get_syscall_number (gdbarch, lp->ptid);
1679 /* If we're stopping threads, there's a SIGSTOP pending, which
1680 makes it so that the LWP reports an immediate syscall return,
1681 followed by the SIGSTOP. Skip seeing that "return" using
1682 PTRACE_CONT directly, and let stop_wait_callback collect the
1683 SIGSTOP. Later when the thread is resumed, a new syscall
1684 entry event. If we didn't do this (and returned 0), we'd
1685 leave a syscall entry pending, and our caller, by using
1686 PTRACE_CONT to collect the SIGSTOP, skips the syscall return
1687 itself. Later, when the user re-resumes this LWP, we'd see
1688 another syscall entry event and we'd mistake it for a return.
1690 If stop_wait_callback didn't force the SIGSTOP out of the LWP
1691 (leaving immediately with LWP->signalled set, without issuing
1692 a PTRACE_CONT), it would still be problematic to leave this
1693 syscall enter pending, as later when the thread is resumed,
1694 it would then see the same syscall exit mentioned above,
1695 followed by the delayed SIGSTOP, while the syscall didn't
1696 actually get to execute. It seems it would be even more
1697 confusing to the user. */
1699 if (debug_linux_nat)
1700 fprintf_unfiltered (gdb_stdlog,
1701 "LHST: ignoring syscall %d "
1702 "for LWP %ld (stopping threads), "
1703 "resuming with PTRACE_CONT for SIGSTOP\n",
1705 ptid_get_lwp (lp->ptid));
1707 lp->syscall_state = TARGET_WAITKIND_IGNORE;
1708 ptrace (PTRACE_CONT, ptid_get_lwp (lp->ptid), 0, 0);
1713 if (catch_syscall_enabled ())
1715 /* Always update the entry/return state, even if this particular
1716 syscall isn't interesting to the core now. In async mode,
1717 the user could install a new catchpoint for this syscall
1718 between syscall enter/return, and we'll need to know to
1719 report a syscall return if that happens. */
1720 lp->syscall_state = (lp->syscall_state == TARGET_WAITKIND_SYSCALL_ENTRY
1721 ? TARGET_WAITKIND_SYSCALL_RETURN
1722 : TARGET_WAITKIND_SYSCALL_ENTRY);
1724 if (catching_syscall_number (syscall_number))
1726 /* Alright, an event to report. */
1727 ourstatus->kind = lp->syscall_state;
1728 ourstatus->value.syscall_number = syscall_number;
1730 if (debug_linux_nat)
1731 fprintf_unfiltered (gdb_stdlog,
1732 "LHST: stopping for %s of syscall %d"
1735 == TARGET_WAITKIND_SYSCALL_ENTRY
1736 ? "entry" : "return",
1738 ptid_get_lwp (lp->ptid));
1742 if (debug_linux_nat)
1743 fprintf_unfiltered (gdb_stdlog,
1744 "LHST: ignoring %s of syscall %d "
1746 lp->syscall_state == TARGET_WAITKIND_SYSCALL_ENTRY
1747 ? "entry" : "return",
1749 ptid_get_lwp (lp->ptid));
1753 /* If we had been syscall tracing, and hence used PT_SYSCALL
1754 before on this LWP, it could happen that the user removes all
1755 syscall catchpoints before we get to process this event.
1756 There are two noteworthy issues here:
1758 - When stopped at a syscall entry event, resuming with
1759 PT_STEP still resumes executing the syscall and reports a
1762 - Only PT_SYSCALL catches syscall enters. If we last
1763 single-stepped this thread, then this event can't be a
1764 syscall enter. If we last single-stepped this thread, this
1765 has to be a syscall exit.
1767 The points above mean that the next resume, be it PT_STEP or
1768 PT_CONTINUE, can not trigger a syscall trace event. */
1769 if (debug_linux_nat)
1770 fprintf_unfiltered (gdb_stdlog,
1771 "LHST: caught syscall event "
1772 "with no syscall catchpoints."
1773 " %d for LWP %ld, ignoring\n",
1775 ptid_get_lwp (lp->ptid));
1776 lp->syscall_state = TARGET_WAITKIND_IGNORE;
1779 /* The core isn't interested in this event. For efficiency, avoid
1780 stopping all threads only to have the core resume them all again.
1781 Since we're not stopping threads, if we're still syscall tracing
1782 and not stepping, we can't use PTRACE_CONT here, as we'd miss any
1783 subsequent syscall. Simply resume using the inf-ptrace layer,
1784 which knows when to use PT_SYSCALL or PT_CONTINUE. */
1786 /* Note that gdbarch_get_syscall_number may access registers, hence
1788 registers_changed ();
1789 if (linux_nat_prepare_to_resume != NULL)
1790 linux_nat_prepare_to_resume (lp);
1791 linux_ops->to_resume (linux_ops, pid_to_ptid (ptid_get_lwp (lp->ptid)),
1792 lp->step, GDB_SIGNAL_0);
1797 /* Handle a GNU/Linux extended wait response. If we see a clone
1798 event, we need to add the new LWP to our list (and not report the
1799 trap to higher layers). This function returns non-zero if the
1800 event should be ignored and we should wait again. If STOPPING is
1801 true, the new LWP remains stopped, otherwise it is continued. */
1804 linux_handle_extended_wait (struct lwp_info *lp, int status,
1807 int pid = ptid_get_lwp (lp->ptid);
1808 struct target_waitstatus *ourstatus = &lp->waitstatus;
1809 int event = linux_ptrace_get_extended_event (status);
1811 if (event == PTRACE_EVENT_FORK || event == PTRACE_EVENT_VFORK
1812 || event == PTRACE_EVENT_CLONE)
1814 unsigned long new_pid;
1817 ptrace (PTRACE_GETEVENTMSG, pid, 0, &new_pid);
1819 /* If we haven't already seen the new PID stop, wait for it now. */
1820 if (! pull_pid_from_list (&stopped_pids, new_pid, &status))
1822 /* The new child has a pending SIGSTOP. We can't affect it until it
1823 hits the SIGSTOP, but we're already attached. */
1824 ret = my_waitpid (new_pid, &status,
1825 (event == PTRACE_EVENT_CLONE) ? __WCLONE : 0);
1827 perror_with_name (_("waiting for new child"));
1828 else if (ret != new_pid)
1829 internal_error (__FILE__, __LINE__,
1830 _("wait returned unexpected PID %d"), ret);
1831 else if (!WIFSTOPPED (status))
1832 internal_error (__FILE__, __LINE__,
1833 _("wait returned unexpected status 0x%x"), status);
1836 ourstatus->value.related_pid = ptid_build (new_pid, new_pid, 0);
1838 if (event == PTRACE_EVENT_FORK || event == PTRACE_EVENT_VFORK)
1840 /* The arch-specific native code may need to know about new
1841 forks even if those end up never mapped to an
1843 if (linux_nat_new_fork != NULL)
1844 linux_nat_new_fork (lp, new_pid);
1847 if (event == PTRACE_EVENT_FORK
1848 && linux_fork_checkpointing_p (ptid_get_pid (lp->ptid)))
1850 /* Handle checkpointing by linux-fork.c here as a special
1851 case. We don't want the follow-fork-mode or 'catch fork'
1852 to interfere with this. */
1854 /* This won't actually modify the breakpoint list, but will
1855 physically remove the breakpoints from the child. */
1856 detach_breakpoints (ptid_build (new_pid, new_pid, 0));
1858 /* Retain child fork in ptrace (stopped) state. */
1859 if (!find_fork_pid (new_pid))
1862 /* Report as spurious, so that infrun doesn't want to follow
1863 this fork. We're actually doing an infcall in
1865 ourstatus->kind = TARGET_WAITKIND_SPURIOUS;
1867 /* Report the stop to the core. */
1871 if (event == PTRACE_EVENT_FORK)
1872 ourstatus->kind = TARGET_WAITKIND_FORKED;
1873 else if (event == PTRACE_EVENT_VFORK)
1874 ourstatus->kind = TARGET_WAITKIND_VFORKED;
1877 struct lwp_info *new_lp;
1879 ourstatus->kind = TARGET_WAITKIND_IGNORE;
1881 if (debug_linux_nat)
1882 fprintf_unfiltered (gdb_stdlog,
1883 "LHEW: Got clone event "
1884 "from LWP %d, new child is LWP %ld\n",
1887 new_lp = add_lwp (ptid_build (ptid_get_pid (lp->ptid), new_pid, 0));
1889 new_lp->stopped = 1;
1891 if (WSTOPSIG (status) != SIGSTOP)
1893 /* This can happen if someone starts sending signals to
1894 the new thread before it gets a chance to run, which
1895 have a lower number than SIGSTOP (e.g. SIGUSR1).
1896 This is an unlikely case, and harder to handle for
1897 fork / vfork than for clone, so we do not try - but
1898 we handle it for clone events here. We'll send
1899 the other signal on to the thread below. */
1901 new_lp->signalled = 1;
1905 struct thread_info *tp;
1907 /* When we stop for an event in some other thread, and
1908 pull the thread list just as this thread has cloned,
1909 we'll have seen the new thread in the thread_db list
1910 before handling the CLONE event (glibc's
1911 pthread_create adds the new thread to the thread list
1912 before clone'ing, and has the kernel fill in the
1913 thread's tid on the clone call with
1914 CLONE_PARENT_SETTID). If that happened, and the core
1915 had requested the new thread to stop, we'll have
1916 killed it with SIGSTOP. But since SIGSTOP is not an
1917 RT signal, it can only be queued once. We need to be
1918 careful to not resume the LWP if we wanted it to
1919 stop. In that case, we'll leave the SIGSTOP pending.
1920 It will later be reported as GDB_SIGNAL_0. */
1921 tp = find_thread_ptid (new_lp->ptid);
1922 if (tp != NULL && tp->stop_requested)
1923 new_lp->last_resume_kind = resume_stop;
1930 /* Add the new thread to GDB's lists as soon as possible
1933 1) the frontend doesn't have to wait for a stop to
1936 2) we tag it with the correct running state. */
1938 /* If the thread_db layer is active, let it know about
1939 this new thread, and add it to GDB's list. */
1940 if (!thread_db_attach_lwp (new_lp->ptid))
1942 /* We're not using thread_db. Add it to GDB's
1944 target_post_attach (ptid_get_lwp (new_lp->ptid));
1945 add_thread (new_lp->ptid);
1950 set_running (new_lp->ptid, 1);
1951 set_executing (new_lp->ptid, 1);
1952 /* thread_db_attach_lwp -> lin_lwp_attach_lwp forced
1954 new_lp->last_resume_kind = resume_continue;
1960 /* We created NEW_LP so it cannot yet contain STATUS. */
1961 gdb_assert (new_lp->status == 0);
1963 /* Save the wait status to report later. */
1964 if (debug_linux_nat)
1965 fprintf_unfiltered (gdb_stdlog,
1966 "LHEW: waitpid of new LWP %ld, "
1967 "saving status %s\n",
1968 (long) ptid_get_lwp (new_lp->ptid),
1969 status_to_str (status));
1970 new_lp->status = status;
1973 /* Note the need to use the low target ops to resume, to
1974 handle resuming with PT_SYSCALL if we have syscall
1978 new_lp->resumed = 1;
1982 gdb_assert (new_lp->last_resume_kind == resume_continue);
1983 if (debug_linux_nat)
1984 fprintf_unfiltered (gdb_stdlog,
1985 "LHEW: resuming new LWP %ld\n",
1986 ptid_get_lwp (new_lp->ptid));
1987 if (linux_nat_prepare_to_resume != NULL)
1988 linux_nat_prepare_to_resume (new_lp);
1989 linux_ops->to_resume (linux_ops, pid_to_ptid (new_pid),
1991 new_lp->stopped = 0;
1995 if (debug_linux_nat)
1996 fprintf_unfiltered (gdb_stdlog,
1997 "LHEW: resuming parent LWP %d\n", pid);
1998 if (linux_nat_prepare_to_resume != NULL)
1999 linux_nat_prepare_to_resume (lp);
2000 linux_ops->to_resume (linux_ops,
2001 pid_to_ptid (ptid_get_lwp (lp->ptid)),
2010 if (event == PTRACE_EVENT_EXEC)
2012 if (debug_linux_nat)
2013 fprintf_unfiltered (gdb_stdlog,
2014 "LHEW: Got exec event from LWP %ld\n",
2015 ptid_get_lwp (lp->ptid));
2017 ourstatus->kind = TARGET_WAITKIND_EXECD;
2018 ourstatus->value.execd_pathname
2019 = xstrdup (linux_child_pid_to_exec_file (NULL, pid));
2024 if (event == PTRACE_EVENT_VFORK_DONE)
2026 if (current_inferior ()->waiting_for_vfork_done)
2028 if (debug_linux_nat)
2029 fprintf_unfiltered (gdb_stdlog,
2030 "LHEW: Got expected PTRACE_EVENT_"
2031 "VFORK_DONE from LWP %ld: stopping\n",
2032 ptid_get_lwp (lp->ptid));
2034 ourstatus->kind = TARGET_WAITKIND_VFORK_DONE;
2038 if (debug_linux_nat)
2039 fprintf_unfiltered (gdb_stdlog,
2040 "LHEW: Got PTRACE_EVENT_VFORK_DONE "
2041 "from LWP %ld: resuming\n",
2042 ptid_get_lwp (lp->ptid));
2043 ptrace (PTRACE_CONT, ptid_get_lwp (lp->ptid), 0, 0);
2047 internal_error (__FILE__, __LINE__,
2048 _("unknown ptrace event %d"), event);
2051 /* Wait for LP to stop. Returns the wait status, or 0 if the LWP has
2055 wait_lwp (struct lwp_info *lp)
2059 int thread_dead = 0;
2062 gdb_assert (!lp->stopped);
2063 gdb_assert (lp->status == 0);
2065 /* Make sure SIGCHLD is blocked for sigsuspend avoiding a race below. */
2066 block_child_signals (&prev_mask);
2070 /* If my_waitpid returns 0 it means the __WCLONE vs. non-__WCLONE kind
2071 was right and we should just call sigsuspend. */
2073 pid = my_waitpid (ptid_get_lwp (lp->ptid), &status, WNOHANG);
2074 if (pid == -1 && errno == ECHILD)
2075 pid = my_waitpid (ptid_get_lwp (lp->ptid), &status, __WCLONE | WNOHANG);
2076 if (pid == -1 && errno == ECHILD)
2078 /* The thread has previously exited. We need to delete it
2079 now because, for some vendor 2.4 kernels with NPTL
2080 support backported, there won't be an exit event unless
2081 it is the main thread. 2.6 kernels will report an exit
2082 event for each thread that exits, as expected. */
2084 if (debug_linux_nat)
2085 fprintf_unfiltered (gdb_stdlog, "WL: %s vanished.\n",
2086 target_pid_to_str (lp->ptid));
2091 /* Bugs 10970, 12702.
2092 Thread group leader may have exited in which case we'll lock up in
2093 waitpid if there are other threads, even if they are all zombies too.
2094 Basically, we're not supposed to use waitpid this way.
2095 __WCLONE is not applicable for the leader so we can't use that.
2096 LINUX_NAT_THREAD_ALIVE cannot be used here as it requires a STOPPED
2097 process; it gets ESRCH both for the zombie and for running processes.
2099 As a workaround, check if we're waiting for the thread group leader and
2100 if it's a zombie, and avoid calling waitpid if it is.
2102 This is racy, what if the tgl becomes a zombie right after we check?
2103 Therefore always use WNOHANG with sigsuspend - it is equivalent to
2104 waiting waitpid but linux_proc_pid_is_zombie is safe this way. */
2106 if (ptid_get_pid (lp->ptid) == ptid_get_lwp (lp->ptid)
2107 && linux_proc_pid_is_zombie (ptid_get_lwp (lp->ptid)))
2110 if (debug_linux_nat)
2111 fprintf_unfiltered (gdb_stdlog,
2112 "WL: Thread group leader %s vanished.\n",
2113 target_pid_to_str (lp->ptid));
2117 /* Wait for next SIGCHLD and try again. This may let SIGCHLD handlers
2118 get invoked despite our caller had them intentionally blocked by
2119 block_child_signals. This is sensitive only to the loop of
2120 linux_nat_wait_1 and there if we get called my_waitpid gets called
2121 again before it gets to sigsuspend so we can safely let the handlers
2122 get executed here. */
2124 if (debug_linux_nat)
2125 fprintf_unfiltered (gdb_stdlog, "WL: about to sigsuspend\n");
2126 sigsuspend (&suspend_mask);
2129 restore_child_signals_mask (&prev_mask);
2133 gdb_assert (pid == ptid_get_lwp (lp->ptid));
2135 if (debug_linux_nat)
2137 fprintf_unfiltered (gdb_stdlog,
2138 "WL: waitpid %s received %s\n",
2139 target_pid_to_str (lp->ptid),
2140 status_to_str (status));
2143 /* Check if the thread has exited. */
2144 if (WIFEXITED (status) || WIFSIGNALED (status))
2147 if (debug_linux_nat)
2148 fprintf_unfiltered (gdb_stdlog, "WL: %s exited.\n",
2149 target_pid_to_str (lp->ptid));
2159 gdb_assert (WIFSTOPPED (status));
2162 /* Handle GNU/Linux's syscall SIGTRAPs. */
2163 if (WIFSTOPPED (status) && WSTOPSIG (status) == SYSCALL_SIGTRAP)
2165 /* No longer need the sysgood bit. The ptrace event ends up
2166 recorded in lp->waitstatus if we care for it. We can carry
2167 on handling the event like a regular SIGTRAP from here
2169 status = W_STOPCODE (SIGTRAP);
2170 if (linux_handle_syscall_trap (lp, 1))
2171 return wait_lwp (lp);
2174 /* Handle GNU/Linux's extended waitstatus for trace events. */
2175 if (WIFSTOPPED (status) && WSTOPSIG (status) == SIGTRAP
2176 && linux_is_extended_waitstatus (status))
2178 if (debug_linux_nat)
2179 fprintf_unfiltered (gdb_stdlog,
2180 "WL: Handling extended status 0x%06x\n",
2182 if (linux_handle_extended_wait (lp, status, 1))
2183 return wait_lwp (lp);
2189 /* Send a SIGSTOP to LP. */
2192 stop_callback (struct lwp_info *lp, void *data)
2194 if (!lp->stopped && !lp->signalled)
2198 if (debug_linux_nat)
2200 fprintf_unfiltered (gdb_stdlog,
2201 "SC: kill %s **<SIGSTOP>**\n",
2202 target_pid_to_str (lp->ptid));
2205 ret = kill_lwp (ptid_get_lwp (lp->ptid), SIGSTOP);
2206 if (debug_linux_nat)
2208 fprintf_unfiltered (gdb_stdlog,
2209 "SC: lwp kill %d %s\n",
2211 errno ? safe_strerror (errno) : "ERRNO-OK");
2215 gdb_assert (lp->status == 0);
2221 /* Request a stop on LWP. */
2224 linux_stop_lwp (struct lwp_info *lwp)
2226 stop_callback (lwp, NULL);
2229 /* Return non-zero if LWP PID has a pending SIGINT. */
2232 linux_nat_has_pending_sigint (int pid)
2234 sigset_t pending, blocked, ignored;
2236 linux_proc_pending_signals (pid, &pending, &blocked, &ignored);
2238 if (sigismember (&pending, SIGINT)
2239 && !sigismember (&ignored, SIGINT))
2245 /* Set a flag in LP indicating that we should ignore its next SIGINT. */
2248 set_ignore_sigint (struct lwp_info *lp, void *data)
2250 /* If a thread has a pending SIGINT, consume it; otherwise, set a
2251 flag to consume the next one. */
2252 if (lp->stopped && lp->status != 0 && WIFSTOPPED (lp->status)
2253 && WSTOPSIG (lp->status) == SIGINT)
2256 lp->ignore_sigint = 1;
2261 /* If LP does not have a SIGINT pending, then clear the ignore_sigint flag.
2262 This function is called after we know the LWP has stopped; if the LWP
2263 stopped before the expected SIGINT was delivered, then it will never have
2264 arrived. Also, if the signal was delivered to a shared queue and consumed
2265 by a different thread, it will never be delivered to this LWP. */
2268 maybe_clear_ignore_sigint (struct lwp_info *lp)
2270 if (!lp->ignore_sigint)
2273 if (!linux_nat_has_pending_sigint (ptid_get_lwp (lp->ptid)))
2275 if (debug_linux_nat)
2276 fprintf_unfiltered (gdb_stdlog,
2277 "MCIS: Clearing bogus flag for %s\n",
2278 target_pid_to_str (lp->ptid));
2279 lp->ignore_sigint = 0;
2283 /* Fetch the possible triggered data watchpoint info and store it in
2286 On some archs, like x86, that use debug registers to set
2287 watchpoints, it's possible that the way to know which watched
2288 address trapped, is to check the register that is used to select
2289 which address to watch. Problem is, between setting the watchpoint
2290 and reading back which data address trapped, the user may change
2291 the set of watchpoints, and, as a consequence, GDB changes the
2292 debug registers in the inferior. To avoid reading back a stale
2293 stopped-data-address when that happens, we cache in LP the fact
2294 that a watchpoint trapped, and the corresponding data address, as
2295 soon as we see LP stop with a SIGTRAP. If GDB changes the debug
2296 registers meanwhile, we have the cached data we can rely on. */
2299 save_sigtrap (struct lwp_info *lp)
2301 struct cleanup *old_chain;
2303 if (linux_ops->to_stopped_by_watchpoint == NULL)
2305 lp->stopped_by_watchpoint = 0;
2309 old_chain = save_inferior_ptid ();
2310 inferior_ptid = lp->ptid;
2312 lp->stopped_by_watchpoint = linux_ops->to_stopped_by_watchpoint (linux_ops);
2314 if (lp->stopped_by_watchpoint)
2316 if (linux_ops->to_stopped_data_address != NULL)
2317 lp->stopped_data_address_p =
2318 linux_ops->to_stopped_data_address (¤t_target,
2319 &lp->stopped_data_address);
2321 lp->stopped_data_address_p = 0;
2324 do_cleanups (old_chain);
2327 /* See save_sigtrap. */
2330 linux_nat_stopped_by_watchpoint (struct target_ops *ops)
2332 struct lwp_info *lp = find_lwp_pid (inferior_ptid);
2334 gdb_assert (lp != NULL);
2336 return lp->stopped_by_watchpoint;
2340 linux_nat_stopped_data_address (struct target_ops *ops, CORE_ADDR *addr_p)
2342 struct lwp_info *lp = find_lwp_pid (inferior_ptid);
2344 gdb_assert (lp != NULL);
2346 *addr_p = lp->stopped_data_address;
2348 return lp->stopped_data_address_p;
2351 /* Commonly any breakpoint / watchpoint generate only SIGTRAP. */
2354 sigtrap_is_event (int status)
2356 return WIFSTOPPED (status) && WSTOPSIG (status) == SIGTRAP;
2359 /* SIGTRAP-like events recognizer. */
2361 static int (*linux_nat_status_is_event) (int status) = sigtrap_is_event;
2363 /* Check for SIGTRAP-like events in LP. */
2366 linux_nat_lp_status_is_event (struct lwp_info *lp)
2368 /* We check for lp->waitstatus in addition to lp->status, because we can
2369 have pending process exits recorded in lp->status
2370 and W_EXITCODE(0,0) == 0. We should probably have an additional
2371 lp->status_p flag. */
2373 return (lp->waitstatus.kind == TARGET_WAITKIND_IGNORE
2374 && linux_nat_status_is_event (lp->status));
2377 /* Set alternative SIGTRAP-like events recognizer. If
2378 breakpoint_inserted_here_p there then gdbarch_decr_pc_after_break will be
2382 linux_nat_set_status_is_event (struct target_ops *t,
2383 int (*status_is_event) (int status))
2385 linux_nat_status_is_event = status_is_event;
2388 /* Wait until LP is stopped. */
2391 stop_wait_callback (struct lwp_info *lp, void *data)
2393 struct inferior *inf = find_inferior_ptid (lp->ptid);
2395 /* If this is a vfork parent, bail out, it is not going to report
2396 any SIGSTOP until the vfork is done with. */
2397 if (inf->vfork_child != NULL)
2404 status = wait_lwp (lp);
2408 if (lp->ignore_sigint && WIFSTOPPED (status)
2409 && WSTOPSIG (status) == SIGINT)
2411 lp->ignore_sigint = 0;
2414 ptrace (PTRACE_CONT, ptid_get_lwp (lp->ptid), 0, 0);
2416 if (debug_linux_nat)
2417 fprintf_unfiltered (gdb_stdlog,
2418 "PTRACE_CONT %s, 0, 0 (%s) "
2419 "(discarding SIGINT)\n",
2420 target_pid_to_str (lp->ptid),
2421 errno ? safe_strerror (errno) : "OK");
2423 return stop_wait_callback (lp, NULL);
2426 maybe_clear_ignore_sigint (lp);
2428 if (WSTOPSIG (status) != SIGSTOP)
2430 /* The thread was stopped with a signal other than SIGSTOP. */
2434 if (debug_linux_nat)
2435 fprintf_unfiltered (gdb_stdlog,
2436 "SWC: Pending event %s in %s\n",
2437 status_to_str ((int) status),
2438 target_pid_to_str (lp->ptid));
2440 /* Save the sigtrap event. */
2441 lp->status = status;
2442 gdb_assert (lp->signalled);
2446 /* We caught the SIGSTOP that we intended to catch, so
2447 there's no SIGSTOP pending. */
2449 if (debug_linux_nat)
2450 fprintf_unfiltered (gdb_stdlog,
2451 "SWC: Delayed SIGSTOP caught for %s.\n",
2452 target_pid_to_str (lp->ptid));
2454 /* Reset SIGNALLED only after the stop_wait_callback call
2455 above as it does gdb_assert on SIGNALLED. */
2463 /* Return non-zero if LP has a wait status pending. */
2466 status_callback (struct lwp_info *lp, void *data)
2468 /* Only report a pending wait status if we pretend that this has
2469 indeed been resumed. */
2473 if (lp->waitstatus.kind != TARGET_WAITKIND_IGNORE)
2475 /* A ptrace event, like PTRACE_FORK|VFORK|EXEC, syscall event,
2476 or a pending process exit. Note that `W_EXITCODE(0,0) ==
2477 0', so a clean process exit can not be stored pending in
2478 lp->status, it is indistinguishable from
2479 no-pending-status. */
2483 if (lp->status != 0)
2489 /* Return non-zero if LP isn't stopped. */
2492 running_callback (struct lwp_info *lp, void *data)
2494 return (!lp->stopped
2495 || ((lp->status != 0
2496 || lp->waitstatus.kind != TARGET_WAITKIND_IGNORE)
2500 /* Count the LWP's that have had events. */
2503 count_events_callback (struct lwp_info *lp, void *data)
2507 gdb_assert (count != NULL);
2509 /* Count only resumed LWPs that have a SIGTRAP event pending. */
2510 if (lp->resumed && linux_nat_lp_status_is_event (lp))
2516 /* Select the LWP (if any) that is currently being single-stepped. */
2519 select_singlestep_lwp_callback (struct lwp_info *lp, void *data)
2521 if (lp->last_resume_kind == resume_step
2528 /* Select the Nth LWP that has had a SIGTRAP event. */
2531 select_event_lwp_callback (struct lwp_info *lp, void *data)
2533 int *selector = data;
2535 gdb_assert (selector != NULL);
2537 /* Select only resumed LWPs that have a SIGTRAP event pending. */
2538 if (lp->resumed && linux_nat_lp_status_is_event (lp))
2539 if ((*selector)-- == 0)
2546 cancel_breakpoint (struct lwp_info *lp)
2548 /* Arrange for a breakpoint to be hit again later. We don't keep
2549 the SIGTRAP status and don't forward the SIGTRAP signal to the
2550 LWP. We will handle the current event, eventually we will resume
2551 this LWP, and this breakpoint will trap again.
2553 If we do not do this, then we run the risk that the user will
2554 delete or disable the breakpoint, but the LWP will have already
2557 struct regcache *regcache = get_thread_regcache (lp->ptid);
2558 struct gdbarch *gdbarch = get_regcache_arch (regcache);
2561 pc = regcache_read_pc (regcache) - target_decr_pc_after_break (gdbarch);
2562 if (breakpoint_inserted_here_p (get_regcache_aspace (regcache), pc))
2564 if (debug_linux_nat)
2565 fprintf_unfiltered (gdb_stdlog,
2566 "CB: Push back breakpoint for %s\n",
2567 target_pid_to_str (lp->ptid));
2569 /* Back up the PC if necessary. */
2570 if (target_decr_pc_after_break (gdbarch))
2571 regcache_write_pc (regcache, pc);
2579 cancel_breakpoints_callback (struct lwp_info *lp, void *data)
2581 struct lwp_info *event_lp = data;
2583 /* Leave the LWP that has been elected to receive a SIGTRAP alone. */
2587 /* If a LWP other than the LWP that we're reporting an event for has
2588 hit a GDB breakpoint (as opposed to some random trap signal),
2589 then just arrange for it to hit it again later. We don't keep
2590 the SIGTRAP status and don't forward the SIGTRAP signal to the
2591 LWP. We will handle the current event, eventually we will resume
2592 all LWPs, and this one will get its breakpoint trap again.
2594 If we do not do this, then we run the risk that the user will
2595 delete or disable the breakpoint, but the LWP will have already
2598 if (linux_nat_lp_status_is_event (lp)
2599 && cancel_breakpoint (lp))
2600 /* Throw away the SIGTRAP. */
2606 /* Select one LWP out of those that have events pending. */
2609 select_event_lwp (ptid_t filter, struct lwp_info **orig_lp, int *status)
2612 int random_selector;
2613 struct lwp_info *event_lp;
2615 /* Record the wait status for the original LWP. */
2616 (*orig_lp)->status = *status;
2618 /* Give preference to any LWP that is being single-stepped. */
2619 event_lp = iterate_over_lwps (filter,
2620 select_singlestep_lwp_callback, NULL);
2621 if (event_lp != NULL)
2623 if (debug_linux_nat)
2624 fprintf_unfiltered (gdb_stdlog,
2625 "SEL: Select single-step %s\n",
2626 target_pid_to_str (event_lp->ptid));
2630 /* No single-stepping LWP. Select one at random, out of those
2631 which have had SIGTRAP events. */
2633 /* First see how many SIGTRAP events we have. */
2634 iterate_over_lwps (filter, count_events_callback, &num_events);
2636 /* Now randomly pick a LWP out of those that have had a SIGTRAP. */
2637 random_selector = (int)
2638 ((num_events * (double) rand ()) / (RAND_MAX + 1.0));
2640 if (debug_linux_nat && num_events > 1)
2641 fprintf_unfiltered (gdb_stdlog,
2642 "SEL: Found %d SIGTRAP events, selecting #%d\n",
2643 num_events, random_selector);
2645 event_lp = iterate_over_lwps (filter,
2646 select_event_lwp_callback,
2650 if (event_lp != NULL)
2652 /* Switch the event LWP. */
2653 *orig_lp = event_lp;
2654 *status = event_lp->status;
2657 /* Flush the wait status for the event LWP. */
2658 (*orig_lp)->status = 0;
2661 /* Return non-zero if LP has been resumed. */
2664 resumed_callback (struct lwp_info *lp, void *data)
2669 /* Stop an active thread, verify it still exists, then resume it. If
2670 the thread ends up with a pending status, then it is not resumed,
2671 and *DATA (really a pointer to int), is set. */
2674 stop_and_resume_callback (struct lwp_info *lp, void *data)
2676 int *new_pending_p = data;
2680 ptid_t ptid = lp->ptid;
2682 stop_callback (lp, NULL);
2683 stop_wait_callback (lp, NULL);
2685 /* Resume if the lwp still exists, and the core wanted it
2687 lp = find_lwp_pid (ptid);
2690 if (lp->last_resume_kind == resume_stop
2693 /* The core wanted the LWP to stop. Even if it stopped
2694 cleanly (with SIGSTOP), leave the event pending. */
2695 if (debug_linux_nat)
2696 fprintf_unfiltered (gdb_stdlog,
2697 "SARC: core wanted LWP %ld stopped "
2698 "(leaving SIGSTOP pending)\n",
2699 ptid_get_lwp (lp->ptid));
2700 lp->status = W_STOPCODE (SIGSTOP);
2703 if (lp->status == 0)
2705 if (debug_linux_nat)
2706 fprintf_unfiltered (gdb_stdlog,
2707 "SARC: re-resuming LWP %ld\n",
2708 ptid_get_lwp (lp->ptid));
2709 resume_lwp (lp, lp->step, GDB_SIGNAL_0);
2713 if (debug_linux_nat)
2714 fprintf_unfiltered (gdb_stdlog,
2715 "SARC: not re-resuming LWP %ld "
2717 ptid_get_lwp (lp->ptid));
2726 /* Check if we should go on and pass this event to common code.
2727 Return the affected lwp if we are, or NULL otherwise. If we stop
2728 all lwps temporarily, we may end up with new pending events in some
2729 other lwp. In that case set *NEW_PENDING_P to true. */
2731 static struct lwp_info *
2732 linux_nat_filter_event (int lwpid, int status, int *new_pending_p)
2734 struct lwp_info *lp;
2735 int event = linux_ptrace_get_extended_event (status);
2739 lp = find_lwp_pid (pid_to_ptid (lwpid));
2741 /* Check for stop events reported by a process we didn't already
2742 know about - anything not already in our LWP list.
2744 If we're expecting to receive stopped processes after
2745 fork, vfork, and clone events, then we'll just add the
2746 new one to our list and go back to waiting for the event
2747 to be reported - the stopped process might be returned
2748 from waitpid before or after the event is.
2750 But note the case of a non-leader thread exec'ing after the
2751 leader having exited, and gone from our lists. The non-leader
2752 thread changes its tid to the tgid. */
2754 if (WIFSTOPPED (status) && lp == NULL
2755 && (WSTOPSIG (status) == SIGTRAP && event == PTRACE_EVENT_EXEC))
2757 /* A multi-thread exec after we had seen the leader exiting. */
2758 if (debug_linux_nat)
2759 fprintf_unfiltered (gdb_stdlog,
2760 "LLW: Re-adding thread group leader LWP %d.\n",
2763 lp = add_lwp (ptid_build (lwpid, lwpid, 0));
2766 add_thread (lp->ptid);
2769 if (WIFSTOPPED (status) && !lp)
2771 add_to_pid_list (&stopped_pids, lwpid, status);
2775 /* Make sure we don't report an event for the exit of an LWP not in
2776 our list, i.e. not part of the current process. This can happen
2777 if we detach from a program we originally forked and then it
2779 if (!WIFSTOPPED (status) && !lp)
2782 /* This LWP is stopped now. (And if dead, this prevents it from
2783 ever being continued.) */
2786 /* Handle GNU/Linux's syscall SIGTRAPs. */
2787 if (WIFSTOPPED (status) && WSTOPSIG (status) == SYSCALL_SIGTRAP)
2789 /* No longer need the sysgood bit. The ptrace event ends up
2790 recorded in lp->waitstatus if we care for it. We can carry
2791 on handling the event like a regular SIGTRAP from here
2793 status = W_STOPCODE (SIGTRAP);
2794 if (linux_handle_syscall_trap (lp, 0))
2798 /* Handle GNU/Linux's extended waitstatus for trace events. */
2799 if (WIFSTOPPED (status) && WSTOPSIG (status) == SIGTRAP
2800 && linux_is_extended_waitstatus (status))
2802 if (debug_linux_nat)
2803 fprintf_unfiltered (gdb_stdlog,
2804 "LLW: Handling extended status 0x%06x\n",
2806 if (linux_handle_extended_wait (lp, status, 0))
2810 if (linux_nat_status_is_event (status))
2813 /* Check if the thread has exited. */
2814 if ((WIFEXITED (status) || WIFSIGNALED (status))
2815 && num_lwps (ptid_get_pid (lp->ptid)) > 1)
2817 /* If this is the main thread, we must stop all threads and verify
2818 if they are still alive. This is because in the nptl thread model
2819 on Linux 2.4, there is no signal issued for exiting LWPs
2820 other than the main thread. We only get the main thread exit
2821 signal once all child threads have already exited. If we
2822 stop all the threads and use the stop_wait_callback to check
2823 if they have exited we can determine whether this signal
2824 should be ignored or whether it means the end of the debugged
2825 application, regardless of which threading model is being
2827 if (ptid_get_pid (lp->ptid) == ptid_get_lwp (lp->ptid))
2829 iterate_over_lwps (pid_to_ptid (ptid_get_pid (lp->ptid)),
2830 stop_and_resume_callback, new_pending_p);
2833 if (debug_linux_nat)
2834 fprintf_unfiltered (gdb_stdlog,
2835 "LLW: %s exited.\n",
2836 target_pid_to_str (lp->ptid));
2838 if (num_lwps (ptid_get_pid (lp->ptid)) > 1)
2840 /* If there is at least one more LWP, then the exit signal
2841 was not the end of the debugged application and should be
2848 /* Check if the current LWP has previously exited. In the nptl
2849 thread model, LWPs other than the main thread do not issue
2850 signals when they exit so we must check whenever the thread has
2851 stopped. A similar check is made in stop_wait_callback(). */
2852 if (num_lwps (ptid_get_pid (lp->ptid)) > 1 && !linux_thread_alive (lp->ptid))
2854 ptid_t ptid = pid_to_ptid (ptid_get_pid (lp->ptid));
2856 if (debug_linux_nat)
2857 fprintf_unfiltered (gdb_stdlog,
2858 "LLW: %s exited.\n",
2859 target_pid_to_str (lp->ptid));
2863 /* Make sure there is at least one thread running. */
2864 gdb_assert (iterate_over_lwps (ptid, running_callback, NULL));
2866 /* Discard the event. */
2870 /* Make sure we don't report a SIGSTOP that we sent ourselves in
2871 an attempt to stop an LWP. */
2873 && WIFSTOPPED (status) && WSTOPSIG (status) == SIGSTOP)
2875 if (debug_linux_nat)
2876 fprintf_unfiltered (gdb_stdlog,
2877 "LLW: Delayed SIGSTOP caught for %s.\n",
2878 target_pid_to_str (lp->ptid));
2882 if (lp->last_resume_kind != resume_stop)
2884 /* This is a delayed SIGSTOP. */
2886 registers_changed ();
2888 if (linux_nat_prepare_to_resume != NULL)
2889 linux_nat_prepare_to_resume (lp);
2890 linux_ops->to_resume (linux_ops,
2891 pid_to_ptid (ptid_get_lwp (lp->ptid)),
2892 lp->step, GDB_SIGNAL_0);
2893 if (debug_linux_nat)
2894 fprintf_unfiltered (gdb_stdlog,
2895 "LLW: %s %s, 0, 0 (discard SIGSTOP)\n",
2897 "PTRACE_SINGLESTEP" : "PTRACE_CONT",
2898 target_pid_to_str (lp->ptid));
2901 gdb_assert (lp->resumed);
2903 /* Discard the event. */
2908 /* Make sure we don't report a SIGINT that we have already displayed
2909 for another thread. */
2910 if (lp->ignore_sigint
2911 && WIFSTOPPED (status) && WSTOPSIG (status) == SIGINT)
2913 if (debug_linux_nat)
2914 fprintf_unfiltered (gdb_stdlog,
2915 "LLW: Delayed SIGINT caught for %s.\n",
2916 target_pid_to_str (lp->ptid));
2918 /* This is a delayed SIGINT. */
2919 lp->ignore_sigint = 0;
2921 registers_changed ();
2922 if (linux_nat_prepare_to_resume != NULL)
2923 linux_nat_prepare_to_resume (lp);
2924 linux_ops->to_resume (linux_ops, pid_to_ptid (ptid_get_lwp (lp->ptid)),
2925 lp->step, GDB_SIGNAL_0);
2926 if (debug_linux_nat)
2927 fprintf_unfiltered (gdb_stdlog,
2928 "LLW: %s %s, 0, 0 (discard SIGINT)\n",
2930 "PTRACE_SINGLESTEP" : "PTRACE_CONT",
2931 target_pid_to_str (lp->ptid));
2934 gdb_assert (lp->resumed);
2936 /* Discard the event. */
2940 /* An interesting event. */
2942 lp->status = status;
2946 /* Detect zombie thread group leaders, and "exit" them. We can't reap
2947 their exits until all other threads in the group have exited. */
2950 check_zombie_leaders (void)
2952 struct inferior *inf;
2956 struct lwp_info *leader_lp;
2961 leader_lp = find_lwp_pid (pid_to_ptid (inf->pid));
2962 if (leader_lp != NULL
2963 /* Check if there are other threads in the group, as we may
2964 have raced with the inferior simply exiting. */
2965 && num_lwps (inf->pid) > 1
2966 && linux_proc_pid_is_zombie (inf->pid))
2968 if (debug_linux_nat)
2969 fprintf_unfiltered (gdb_stdlog,
2970 "CZL: Thread group leader %d zombie "
2971 "(it exited, or another thread execd).\n",
2974 /* A leader zombie can mean one of two things:
2976 - It exited, and there's an exit status pending
2977 available, or only the leader exited (not the whole
2978 program). In the latter case, we can't waitpid the
2979 leader's exit status until all other threads are gone.
2981 - There are 3 or more threads in the group, and a thread
2982 other than the leader exec'd. On an exec, the Linux
2983 kernel destroys all other threads (except the execing
2984 one) in the thread group, and resets the execing thread's
2985 tid to the tgid. No exit notification is sent for the
2986 execing thread -- from the ptracer's perspective, it
2987 appears as though the execing thread just vanishes.
2988 Until we reap all other threads except the leader and the
2989 execing thread, the leader will be zombie, and the
2990 execing thread will be in `D (disc sleep)'. As soon as
2991 all other threads are reaped, the execing thread changes
2992 it's tid to the tgid, and the previous (zombie) leader
2993 vanishes, giving place to the "new" leader. We could try
2994 distinguishing the exit and exec cases, by waiting once
2995 more, and seeing if something comes out, but it doesn't
2996 sound useful. The previous leader _does_ go away, and
2997 we'll re-add the new one once we see the exec event
2998 (which is just the same as what would happen if the
2999 previous leader did exit voluntarily before some other
3002 if (debug_linux_nat)
3003 fprintf_unfiltered (gdb_stdlog,
3004 "CZL: Thread group leader %d vanished.\n",
3006 exit_lwp (leader_lp);
3012 linux_nat_wait_1 (struct target_ops *ops,
3013 ptid_t ptid, struct target_waitstatus *ourstatus,
3017 enum resume_kind last_resume_kind;
3018 struct lwp_info *lp;
3021 if (debug_linux_nat)
3022 fprintf_unfiltered (gdb_stdlog, "LLW: enter\n");
3024 /* The first time we get here after starting a new inferior, we may
3025 not have added it to the LWP list yet - this is the earliest
3026 moment at which we know its PID. */
3027 if (ptid_is_pid (inferior_ptid))
3029 /* Upgrade the main thread's ptid. */
3030 thread_change_ptid (inferior_ptid,
3031 ptid_build (ptid_get_pid (inferior_ptid),
3032 ptid_get_pid (inferior_ptid), 0));
3034 lp = add_initial_lwp (inferior_ptid);
3038 /* Make sure SIGCHLD is blocked until the sigsuspend below. */
3039 block_child_signals (&prev_mask);
3045 /* First check if there is a LWP with a wait status pending. */
3046 if (ptid_equal (ptid, minus_one_ptid) || ptid_is_pid (ptid))
3048 /* Any LWP in the PTID group that's been resumed will do. */
3049 lp = iterate_over_lwps (ptid, status_callback, NULL);
3052 if (debug_linux_nat && lp->status)
3053 fprintf_unfiltered (gdb_stdlog,
3054 "LLW: Using pending wait status %s for %s.\n",
3055 status_to_str (lp->status),
3056 target_pid_to_str (lp->ptid));
3059 else if (ptid_lwp_p (ptid))
3061 if (debug_linux_nat)
3062 fprintf_unfiltered (gdb_stdlog,
3063 "LLW: Waiting for specific LWP %s.\n",
3064 target_pid_to_str (ptid));
3066 /* We have a specific LWP to check. */
3067 lp = find_lwp_pid (ptid);
3070 if (debug_linux_nat && lp->status)
3071 fprintf_unfiltered (gdb_stdlog,
3072 "LLW: Using pending wait status %s for %s.\n",
3073 status_to_str (lp->status),
3074 target_pid_to_str (lp->ptid));
3076 /* We check for lp->waitstatus in addition to lp->status,
3077 because we can have pending process exits recorded in
3078 lp->status and W_EXITCODE(0,0) == 0. We should probably have
3079 an additional lp->status_p flag. */
3080 if (lp->status == 0 && lp->waitstatus.kind == TARGET_WAITKIND_IGNORE)
3084 if (!target_can_async_p ())
3086 /* Causes SIGINT to be passed on to the attached process. */
3090 /* But if we don't find a pending event, we'll have to wait. */
3096 /* Always use -1 and WNOHANG, due to couple of a kernel/ptrace
3099 - If the thread group leader exits while other threads in the
3100 thread group still exist, waitpid(TGID, ...) hangs. That
3101 waitpid won't return an exit status until the other threads
3102 in the group are reapped.
3104 - When a non-leader thread execs, that thread just vanishes
3105 without reporting an exit (so we'd hang if we waited for it
3106 explicitly in that case). The exec event is reported to
3110 lwpid = my_waitpid (-1, &status, __WCLONE | WNOHANG);
3111 if (lwpid == 0 || (lwpid == -1 && errno == ECHILD))
3112 lwpid = my_waitpid (-1, &status, WNOHANG);
3114 if (debug_linux_nat)
3115 fprintf_unfiltered (gdb_stdlog,
3116 "LNW: waitpid(-1, ...) returned %d, %s\n",
3117 lwpid, errno ? safe_strerror (errno) : "ERRNO-OK");
3121 /* If this is true, then we paused LWPs momentarily, and may
3122 now have pending events to handle. */
3125 if (debug_linux_nat)
3127 fprintf_unfiltered (gdb_stdlog,
3128 "LLW: waitpid %ld received %s\n",
3129 (long) lwpid, status_to_str (status));
3132 lp = linux_nat_filter_event (lwpid, status, &new_pending);
3134 /* STATUS is now no longer valid, use LP->STATUS instead. */
3137 if (lp && !ptid_match (lp->ptid, ptid))
3139 gdb_assert (lp->resumed);
3141 if (debug_linux_nat)
3142 fprintf_unfiltered (gdb_stdlog,
3143 "LWP %ld got an event %06x, "
3144 "leaving pending.\n",
3145 ptid_get_lwp (lp->ptid), lp->status);
3147 if (WIFSTOPPED (lp->status))
3149 if (WSTOPSIG (lp->status) != SIGSTOP)
3151 /* Cancel breakpoint hits. The breakpoint may
3152 be removed before we fetch events from this
3153 process to report to the core. It is best
3154 not to assume the moribund breakpoints
3155 heuristic always handles these cases --- it
3156 could be too many events go through to the
3157 core before this one is handled. All-stop
3158 always cancels breakpoint hits in all
3161 && linux_nat_lp_status_is_event (lp)
3162 && cancel_breakpoint (lp))
3164 /* Throw away the SIGTRAP. */
3167 if (debug_linux_nat)
3168 fprintf_unfiltered (gdb_stdlog,
3169 "LLW: LWP %ld hit a "
3171 "waiting for another "
3174 ptid_get_lwp (lp->ptid));
3180 else if (WIFEXITED (lp->status) || WIFSIGNALED (lp->status))
3182 if (debug_linux_nat)
3183 fprintf_unfiltered (gdb_stdlog,
3184 "Process %ld exited while stopping "
3186 ptid_get_lwp (lp->ptid));
3188 /* This was the last lwp in the process. Since
3189 events are serialized to GDB core, and we can't
3190 report this one right now, but GDB core and the
3191 other target layers will want to be notified
3192 about the exit code/signal, leave the status
3193 pending for the next time we're able to report
3196 /* Dead LWP's aren't expected to reported a pending
3200 /* Store the pending event in the waitstatus as
3201 well, because W_EXITCODE(0,0) == 0. */
3202 store_waitstatus (&lp->waitstatus, lp->status);
3211 /* Some LWP now has a pending event. Go all the way
3212 back to check it. */
3218 /* We got an event to report to the core. */
3222 /* Retry until nothing comes out of waitpid. A single
3223 SIGCHLD can indicate more than one child stopped. */
3227 /* Check for zombie thread group leaders. Those can't be reaped
3228 until all other threads in the thread group are. */
3229 check_zombie_leaders ();
3231 /* If there are no resumed children left, bail. We'd be stuck
3232 forever in the sigsuspend call below otherwise. */
3233 if (iterate_over_lwps (ptid, resumed_callback, NULL) == NULL)
3235 if (debug_linux_nat)
3236 fprintf_unfiltered (gdb_stdlog, "LLW: exit (no resumed LWP)\n");
3238 ourstatus->kind = TARGET_WAITKIND_NO_RESUMED;
3240 if (!target_can_async_p ())
3241 clear_sigint_trap ();
3243 restore_child_signals_mask (&prev_mask);
3244 return minus_one_ptid;
3247 /* No interesting event to report to the core. */
3249 if (target_options & TARGET_WNOHANG)
3251 if (debug_linux_nat)
3252 fprintf_unfiltered (gdb_stdlog, "LLW: exit (ignore)\n");
3254 ourstatus->kind = TARGET_WAITKIND_IGNORE;
3255 restore_child_signals_mask (&prev_mask);
3256 return minus_one_ptid;
3259 /* We shouldn't end up here unless we want to try again. */
3260 gdb_assert (lp == NULL);
3262 /* Block until we get an event reported with SIGCHLD. */
3263 if (debug_linux_nat)
3264 fprintf_unfiltered (gdb_stdlog, "LNW: about to sigsuspend\n");
3265 sigsuspend (&suspend_mask);
3268 if (!target_can_async_p ())
3269 clear_sigint_trap ();
3273 status = lp->status;
3276 /* Don't report signals that GDB isn't interested in, such as
3277 signals that are neither printed nor stopped upon. Stopping all
3278 threads can be a bit time-consuming so if we want decent
3279 performance with heavily multi-threaded programs, especially when
3280 they're using a high frequency timer, we'd better avoid it if we
3283 if (WIFSTOPPED (status))
3285 enum gdb_signal signo = gdb_signal_from_host (WSTOPSIG (status));
3287 /* When using hardware single-step, we need to report every signal.
3288 Otherwise, signals in pass_mask may be short-circuited. */
3290 && WSTOPSIG (status) && sigismember (&pass_mask, WSTOPSIG (status)))
3292 /* FIMXE: kettenis/2001-06-06: Should we resume all threads
3293 here? It is not clear we should. GDB may not expect
3294 other threads to run. On the other hand, not resuming
3295 newly attached threads may cause an unwanted delay in
3296 getting them running. */
3297 registers_changed ();
3298 if (linux_nat_prepare_to_resume != NULL)
3299 linux_nat_prepare_to_resume (lp);
3300 linux_ops->to_resume (linux_ops,
3301 pid_to_ptid (ptid_get_lwp (lp->ptid)),
3303 if (debug_linux_nat)
3304 fprintf_unfiltered (gdb_stdlog,
3305 "LLW: %s %s, %s (preempt 'handle')\n",
3307 "PTRACE_SINGLESTEP" : "PTRACE_CONT",
3308 target_pid_to_str (lp->ptid),
3309 (signo != GDB_SIGNAL_0
3310 ? strsignal (gdb_signal_to_host (signo))
3318 /* Only do the below in all-stop, as we currently use SIGINT
3319 to implement target_stop (see linux_nat_stop) in
3321 if (signo == GDB_SIGNAL_INT && signal_pass_state (signo) == 0)
3323 /* If ^C/BREAK is typed at the tty/console, SIGINT gets
3324 forwarded to the entire process group, that is, all LWPs
3325 will receive it - unless they're using CLONE_THREAD to
3326 share signals. Since we only want to report it once, we
3327 mark it as ignored for all LWPs except this one. */
3328 iterate_over_lwps (pid_to_ptid (ptid_get_pid (ptid)),
3329 set_ignore_sigint, NULL);
3330 lp->ignore_sigint = 0;
3333 maybe_clear_ignore_sigint (lp);
3337 /* This LWP is stopped now. */
3340 if (debug_linux_nat)
3341 fprintf_unfiltered (gdb_stdlog, "LLW: Candidate event %s in %s.\n",
3342 status_to_str (status), target_pid_to_str (lp->ptid));
3346 /* Now stop all other LWP's ... */
3347 iterate_over_lwps (minus_one_ptid, stop_callback, NULL);
3349 /* ... and wait until all of them have reported back that
3350 they're no longer running. */
3351 iterate_over_lwps (minus_one_ptid, stop_wait_callback, NULL);
3353 /* If we're not waiting for a specific LWP, choose an event LWP
3354 from among those that have had events. Giving equal priority
3355 to all LWPs that have had events helps prevent
3357 if (ptid_equal (ptid, minus_one_ptid) || ptid_is_pid (ptid))
3358 select_event_lwp (ptid, &lp, &status);
3360 /* Now that we've selected our final event LWP, cancel any
3361 breakpoints in other LWPs that have hit a GDB breakpoint.
3362 See the comment in cancel_breakpoints_callback to find out
3364 iterate_over_lwps (minus_one_ptid, cancel_breakpoints_callback, lp);
3366 /* We'll need this to determine whether to report a SIGSTOP as
3367 TARGET_WAITKIND_0. Need to take a copy because
3368 resume_clear_callback clears it. */
3369 last_resume_kind = lp->last_resume_kind;
3371 /* In all-stop, from the core's perspective, all LWPs are now
3372 stopped until a new resume action is sent over. */
3373 iterate_over_lwps (minus_one_ptid, resume_clear_callback, NULL);
3378 last_resume_kind = lp->last_resume_kind;
3379 resume_clear_callback (lp, NULL);
3382 if (linux_nat_status_is_event (status))
3384 if (debug_linux_nat)
3385 fprintf_unfiltered (gdb_stdlog,
3386 "LLW: trap ptid is %s.\n",
3387 target_pid_to_str (lp->ptid));
3390 if (lp->waitstatus.kind != TARGET_WAITKIND_IGNORE)
3392 *ourstatus = lp->waitstatus;
3393 lp->waitstatus.kind = TARGET_WAITKIND_IGNORE;
3396 store_waitstatus (ourstatus, status);
3398 if (debug_linux_nat)
3399 fprintf_unfiltered (gdb_stdlog, "LLW: exit\n");
3401 restore_child_signals_mask (&prev_mask);
3403 if (last_resume_kind == resume_stop
3404 && ourstatus->kind == TARGET_WAITKIND_STOPPED
3405 && WSTOPSIG (status) == SIGSTOP)
3407 /* A thread that has been requested to stop by GDB with
3408 target_stop, and it stopped cleanly, so report as SIG0. The
3409 use of SIGSTOP is an implementation detail. */
3410 ourstatus->value.sig = GDB_SIGNAL_0;
3413 if (ourstatus->kind == TARGET_WAITKIND_EXITED
3414 || ourstatus->kind == TARGET_WAITKIND_SIGNALLED)
3417 lp->core = linux_common_core_of_thread (lp->ptid);
3422 /* Resume LWPs that are currently stopped without any pending status
3423 to report, but are resumed from the core's perspective. */
3426 resume_stopped_resumed_lwps (struct lwp_info *lp, void *data)
3428 ptid_t *wait_ptid_p = data;
3433 && lp->waitstatus.kind == TARGET_WAITKIND_IGNORE)
3435 struct regcache *regcache = get_thread_regcache (lp->ptid);
3436 struct gdbarch *gdbarch = get_regcache_arch (regcache);
3437 CORE_ADDR pc = regcache_read_pc (regcache);
3439 gdb_assert (is_executing (lp->ptid));
3441 /* Don't bother if there's a breakpoint at PC that we'd hit
3442 immediately, and we're not waiting for this LWP. */
3443 if (!ptid_match (lp->ptid, *wait_ptid_p))
3445 if (breakpoint_inserted_here_p (get_regcache_aspace (regcache), pc))
3449 if (debug_linux_nat)
3450 fprintf_unfiltered (gdb_stdlog,
3451 "RSRL: resuming stopped-resumed LWP %s at %s: step=%d\n",
3452 target_pid_to_str (lp->ptid),
3453 paddress (gdbarch, pc),
3456 registers_changed ();
3457 if (linux_nat_prepare_to_resume != NULL)
3458 linux_nat_prepare_to_resume (lp);
3459 linux_ops->to_resume (linux_ops, pid_to_ptid (ptid_get_lwp (lp->ptid)),
3460 lp->step, GDB_SIGNAL_0);
3462 lp->stopped_by_watchpoint = 0;
3469 linux_nat_wait (struct target_ops *ops,
3470 ptid_t ptid, struct target_waitstatus *ourstatus,
3475 if (debug_linux_nat)
3477 char *options_string;
3479 options_string = target_options_to_string (target_options);
3480 fprintf_unfiltered (gdb_stdlog,
3481 "linux_nat_wait: [%s], [%s]\n",
3482 target_pid_to_str (ptid),
3484 xfree (options_string);
3487 /* Flush the async file first. */
3488 if (target_can_async_p ())
3489 async_file_flush ();
3491 /* Resume LWPs that are currently stopped without any pending status
3492 to report, but are resumed from the core's perspective. LWPs get
3493 in this state if we find them stopping at a time we're not
3494 interested in reporting the event (target_wait on a
3495 specific_process, for example, see linux_nat_wait_1), and
3496 meanwhile the event became uninteresting. Don't bother resuming
3497 LWPs we're not going to wait for if they'd stop immediately. */
3499 iterate_over_lwps (minus_one_ptid, resume_stopped_resumed_lwps, &ptid);
3501 event_ptid = linux_nat_wait_1 (ops, ptid, ourstatus, target_options);
3503 /* If we requested any event, and something came out, assume there
3504 may be more. If we requested a specific lwp or process, also
3505 assume there may be more. */
3506 if (target_can_async_p ()
3507 && ((ourstatus->kind != TARGET_WAITKIND_IGNORE
3508 && ourstatus->kind != TARGET_WAITKIND_NO_RESUMED)
3509 || !ptid_equal (ptid, minus_one_ptid)))
3512 /* Get ready for the next event. */
3513 if (target_can_async_p ())
3514 target_async (inferior_event_handler, 0);
3520 kill_callback (struct lwp_info *lp, void *data)
3522 /* PTRACE_KILL may resume the inferior. Send SIGKILL first. */
3525 kill_lwp (ptid_get_lwp (lp->ptid), SIGKILL);
3526 if (debug_linux_nat)
3528 int save_errno = errno;
3530 fprintf_unfiltered (gdb_stdlog,
3531 "KC: kill (SIGKILL) %s, 0, 0 (%s)\n",
3532 target_pid_to_str (lp->ptid),
3533 save_errno ? safe_strerror (save_errno) : "OK");
3536 /* Some kernels ignore even SIGKILL for processes under ptrace. */
3539 ptrace (PTRACE_KILL, ptid_get_lwp (lp->ptid), 0, 0);
3540 if (debug_linux_nat)
3542 int save_errno = errno;
3544 fprintf_unfiltered (gdb_stdlog,
3545 "KC: PTRACE_KILL %s, 0, 0 (%s)\n",
3546 target_pid_to_str (lp->ptid),
3547 save_errno ? safe_strerror (save_errno) : "OK");
3554 kill_wait_callback (struct lwp_info *lp, void *data)
3558 /* We must make sure that there are no pending events (delayed
3559 SIGSTOPs, pending SIGTRAPs, etc.) to make sure the current
3560 program doesn't interfere with any following debugging session. */
3562 /* For cloned processes we must check both with __WCLONE and
3563 without, since the exit status of a cloned process isn't reported
3569 pid = my_waitpid (ptid_get_lwp (lp->ptid), NULL, __WCLONE);
3570 if (pid != (pid_t) -1)
3572 if (debug_linux_nat)
3573 fprintf_unfiltered (gdb_stdlog,
3574 "KWC: wait %s received unknown.\n",
3575 target_pid_to_str (lp->ptid));
3576 /* The Linux kernel sometimes fails to kill a thread
3577 completely after PTRACE_KILL; that goes from the stop
3578 point in do_fork out to the one in
3579 get_signal_to_deliever and waits again. So kill it
3581 kill_callback (lp, NULL);
3584 while (pid == ptid_get_lwp (lp->ptid));
3586 gdb_assert (pid == -1 && errno == ECHILD);
3591 pid = my_waitpid (ptid_get_lwp (lp->ptid), NULL, 0);
3592 if (pid != (pid_t) -1)
3594 if (debug_linux_nat)
3595 fprintf_unfiltered (gdb_stdlog,
3596 "KWC: wait %s received unk.\n",
3597 target_pid_to_str (lp->ptid));
3598 /* See the call to kill_callback above. */
3599 kill_callback (lp, NULL);
3602 while (pid == ptid_get_lwp (lp->ptid));
3604 gdb_assert (pid == -1 && errno == ECHILD);
3609 linux_nat_kill (struct target_ops *ops)
3611 struct target_waitstatus last;
3615 /* If we're stopped while forking and we haven't followed yet,
3616 kill the other task. We need to do this first because the
3617 parent will be sleeping if this is a vfork. */
3619 get_last_target_status (&last_ptid, &last);
3621 if (last.kind == TARGET_WAITKIND_FORKED
3622 || last.kind == TARGET_WAITKIND_VFORKED)
3624 ptrace (PT_KILL, ptid_get_pid (last.value.related_pid), 0, 0);
3627 /* Let the arch-specific native code know this process is
3629 linux_nat_forget_process (ptid_get_pid (last.value.related_pid));
3632 if (forks_exist_p ())
3633 linux_fork_killall ();
3636 ptid_t ptid = pid_to_ptid (ptid_get_pid (inferior_ptid));
3638 /* Stop all threads before killing them, since ptrace requires
3639 that the thread is stopped to sucessfully PTRACE_KILL. */
3640 iterate_over_lwps (ptid, stop_callback, NULL);
3641 /* ... and wait until all of them have reported back that
3642 they're no longer running. */
3643 iterate_over_lwps (ptid, stop_wait_callback, NULL);
3645 /* Kill all LWP's ... */
3646 iterate_over_lwps (ptid, kill_callback, NULL);
3648 /* ... and wait until we've flushed all events. */
3649 iterate_over_lwps (ptid, kill_wait_callback, NULL);
3652 target_mourn_inferior ();
3656 linux_nat_mourn_inferior (struct target_ops *ops)
3658 int pid = ptid_get_pid (inferior_ptid);
3660 purge_lwp_list (pid);
3662 if (! forks_exist_p ())
3663 /* Normal case, no other forks available. */
3664 linux_ops->to_mourn_inferior (ops);
3666 /* Multi-fork case. The current inferior_ptid has exited, but
3667 there are other viable forks to debug. Delete the exiting
3668 one and context-switch to the first available. */
3669 linux_fork_mourn_inferior ();
3671 /* Let the arch-specific native code know this process is gone. */
3672 linux_nat_forget_process (pid);
3675 /* Convert a native/host siginfo object, into/from the siginfo in the
3676 layout of the inferiors' architecture. */
3679 siginfo_fixup (siginfo_t *siginfo, gdb_byte *inf_siginfo, int direction)
3683 if (linux_nat_siginfo_fixup != NULL)
3684 done = linux_nat_siginfo_fixup (siginfo, inf_siginfo, direction);
3686 /* If there was no callback, or the callback didn't do anything,
3687 then just do a straight memcpy. */
3691 memcpy (siginfo, inf_siginfo, sizeof (siginfo_t));
3693 memcpy (inf_siginfo, siginfo, sizeof (siginfo_t));
3697 static enum target_xfer_status
3698 linux_xfer_siginfo (struct target_ops *ops, enum target_object object,
3699 const char *annex, gdb_byte *readbuf,
3700 const gdb_byte *writebuf, ULONGEST offset, ULONGEST len,
3701 ULONGEST *xfered_len)
3705 gdb_byte inf_siginfo[sizeof (siginfo_t)];
3707 gdb_assert (object == TARGET_OBJECT_SIGNAL_INFO);
3708 gdb_assert (readbuf || writebuf);
3710 pid = ptid_get_lwp (inferior_ptid);
3712 pid = ptid_get_pid (inferior_ptid);
3714 if (offset > sizeof (siginfo))
3715 return TARGET_XFER_E_IO;
3718 ptrace (PTRACE_GETSIGINFO, pid, (PTRACE_TYPE_ARG3) 0, &siginfo);
3720 return TARGET_XFER_E_IO;
3722 /* When GDB is built as a 64-bit application, ptrace writes into
3723 SIGINFO an object with 64-bit layout. Since debugging a 32-bit
3724 inferior with a 64-bit GDB should look the same as debugging it
3725 with a 32-bit GDB, we need to convert it. GDB core always sees
3726 the converted layout, so any read/write will have to be done
3728 siginfo_fixup (&siginfo, inf_siginfo, 0);
3730 if (offset + len > sizeof (siginfo))
3731 len = sizeof (siginfo) - offset;
3733 if (readbuf != NULL)
3734 memcpy (readbuf, inf_siginfo + offset, len);
3737 memcpy (inf_siginfo + offset, writebuf, len);
3739 /* Convert back to ptrace layout before flushing it out. */
3740 siginfo_fixup (&siginfo, inf_siginfo, 1);
3743 ptrace (PTRACE_SETSIGINFO, pid, (PTRACE_TYPE_ARG3) 0, &siginfo);
3745 return TARGET_XFER_E_IO;
3749 return TARGET_XFER_OK;
3752 static enum target_xfer_status
3753 linux_nat_xfer_partial (struct target_ops *ops, enum target_object object,
3754 const char *annex, gdb_byte *readbuf,
3755 const gdb_byte *writebuf,
3756 ULONGEST offset, ULONGEST len, ULONGEST *xfered_len)
3758 struct cleanup *old_chain;
3759 enum target_xfer_status xfer;
3761 if (object == TARGET_OBJECT_SIGNAL_INFO)
3762 return linux_xfer_siginfo (ops, object, annex, readbuf, writebuf,
3763 offset, len, xfered_len);
3765 /* The target is connected but no live inferior is selected. Pass
3766 this request down to a lower stratum (e.g., the executable
3768 if (object == TARGET_OBJECT_MEMORY && ptid_equal (inferior_ptid, null_ptid))
3769 return TARGET_XFER_EOF;
3771 old_chain = save_inferior_ptid ();
3773 if (ptid_lwp_p (inferior_ptid))
3774 inferior_ptid = pid_to_ptid (ptid_get_lwp (inferior_ptid));
3776 xfer = linux_ops->to_xfer_partial (ops, object, annex, readbuf, writebuf,
3777 offset, len, xfered_len);
3779 do_cleanups (old_chain);
3784 linux_thread_alive (ptid_t ptid)
3788 gdb_assert (ptid_lwp_p (ptid));
3790 /* Send signal 0 instead of anything ptrace, because ptracing a
3791 running thread errors out claiming that the thread doesn't
3793 err = kill_lwp (ptid_get_lwp (ptid), 0);
3795 if (debug_linux_nat)
3796 fprintf_unfiltered (gdb_stdlog,
3797 "LLTA: KILL(SIG0) %s (%s)\n",
3798 target_pid_to_str (ptid),
3799 err ? safe_strerror (tmp_errno) : "OK");
3808 linux_nat_thread_alive (struct target_ops *ops, ptid_t ptid)
3810 return linux_thread_alive (ptid);
3814 linux_nat_pid_to_str (struct target_ops *ops, ptid_t ptid)
3816 static char buf[64];
3818 if (ptid_lwp_p (ptid)
3819 && (ptid_get_pid (ptid) != ptid_get_lwp (ptid)
3820 || num_lwps (ptid_get_pid (ptid)) > 1))
3822 snprintf (buf, sizeof (buf), "LWP %ld", ptid_get_lwp (ptid));
3826 return normal_pid_to_str (ptid);
3830 linux_nat_thread_name (struct target_ops *self, struct thread_info *thr)
3832 int pid = ptid_get_pid (thr->ptid);
3833 long lwp = ptid_get_lwp (thr->ptid);
3834 #define FORMAT "/proc/%d/task/%ld/comm"
3835 char buf[sizeof (FORMAT) + 30];
3837 char *result = NULL;
3839 snprintf (buf, sizeof (buf), FORMAT, pid, lwp);
3840 comm_file = gdb_fopen_cloexec (buf, "r");
3843 /* Not exported by the kernel, so we define it here. */
3845 static char line[COMM_LEN + 1];
3847 if (fgets (line, sizeof (line), comm_file))
3849 char *nl = strchr (line, '\n');
3866 /* Accepts an integer PID; Returns a string representing a file that
3867 can be opened to get the symbols for the child process. */
3870 linux_child_pid_to_exec_file (struct target_ops *self, int pid)
3872 static char buf[PATH_MAX];
3873 char name[PATH_MAX];
3875 xsnprintf (name, PATH_MAX, "/proc/%d/exe", pid);
3876 memset (buf, 0, PATH_MAX);
3877 if (readlink (name, buf, PATH_MAX - 1) <= 0)
3883 /* Implement the to_xfer_partial interface for memory reads using the /proc
3884 filesystem. Because we can use a single read() call for /proc, this
3885 can be much more efficient than banging away at PTRACE_PEEKTEXT,
3886 but it doesn't support writes. */
3888 static enum target_xfer_status
3889 linux_proc_xfer_partial (struct target_ops *ops, enum target_object object,
3890 const char *annex, gdb_byte *readbuf,
3891 const gdb_byte *writebuf,
3892 ULONGEST offset, LONGEST len, ULONGEST *xfered_len)
3898 if (object != TARGET_OBJECT_MEMORY || !readbuf)
3901 /* Don't bother for one word. */
3902 if (len < 3 * sizeof (long))
3903 return TARGET_XFER_EOF;
3905 /* We could keep this file open and cache it - possibly one per
3906 thread. That requires some juggling, but is even faster. */
3907 xsnprintf (filename, sizeof filename, "/proc/%d/mem",
3908 ptid_get_pid (inferior_ptid));
3909 fd = gdb_open_cloexec (filename, O_RDONLY | O_LARGEFILE, 0);
3911 return TARGET_XFER_EOF;
3913 /* If pread64 is available, use it. It's faster if the kernel
3914 supports it (only one syscall), and it's 64-bit safe even on
3915 32-bit platforms (for instance, SPARC debugging a SPARC64
3918 if (pread64 (fd, readbuf, len, offset) != len)
3920 if (lseek (fd, offset, SEEK_SET) == -1 || read (fd, readbuf, len) != len)
3929 return TARGET_XFER_EOF;
3933 return TARGET_XFER_OK;
3938 /* Enumerate spufs IDs for process PID. */
3940 spu_enumerate_spu_ids (int pid, gdb_byte *buf, ULONGEST offset, ULONGEST len)
3942 enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch ());
3944 LONGEST written = 0;
3947 struct dirent *entry;
3949 xsnprintf (path, sizeof path, "/proc/%d/fd", pid);
3950 dir = opendir (path);
3955 while ((entry = readdir (dir)) != NULL)
3961 fd = atoi (entry->d_name);
3965 xsnprintf (path, sizeof path, "/proc/%d/fd/%d", pid, fd);
3966 if (stat (path, &st) != 0)
3968 if (!S_ISDIR (st.st_mode))
3971 if (statfs (path, &stfs) != 0)
3973 if (stfs.f_type != SPUFS_MAGIC)
3976 if (pos >= offset && pos + 4 <= offset + len)
3978 store_unsigned_integer (buf + pos - offset, 4, byte_order, fd);
3988 /* Implement the to_xfer_partial interface for the TARGET_OBJECT_SPU
3989 object type, using the /proc file system. */
3991 static enum target_xfer_status
3992 linux_proc_xfer_spu (struct target_ops *ops, enum target_object object,
3993 const char *annex, gdb_byte *readbuf,
3994 const gdb_byte *writebuf,
3995 ULONGEST offset, ULONGEST len, ULONGEST *xfered_len)
4000 int pid = ptid_get_pid (inferior_ptid);
4005 return TARGET_XFER_E_IO;
4008 LONGEST l = spu_enumerate_spu_ids (pid, readbuf, offset, len);
4011 return TARGET_XFER_E_IO;
4013 return TARGET_XFER_EOF;
4016 *xfered_len = (ULONGEST) l;
4017 return TARGET_XFER_OK;
4022 xsnprintf (buf, sizeof buf, "/proc/%d/fd/%s", pid, annex);
4023 fd = gdb_open_cloexec (buf, writebuf? O_WRONLY : O_RDONLY, 0);
4025 return TARGET_XFER_E_IO;
4028 && lseek (fd, (off_t) offset, SEEK_SET) != (off_t) offset)
4031 return TARGET_XFER_EOF;
4035 ret = write (fd, writebuf, (size_t) len);
4037 ret = read (fd, readbuf, (size_t) len);
4042 return TARGET_XFER_E_IO;
4044 return TARGET_XFER_EOF;
4047 *xfered_len = (ULONGEST) ret;
4048 return TARGET_XFER_OK;
4053 /* Parse LINE as a signal set and add its set bits to SIGS. */
4056 add_line_to_sigset (const char *line, sigset_t *sigs)
4058 int len = strlen (line) - 1;
4062 if (line[len] != '\n')
4063 error (_("Could not parse signal set: %s"), line);
4071 if (*p >= '0' && *p <= '9')
4073 else if (*p >= 'a' && *p <= 'f')
4074 digit = *p - 'a' + 10;
4076 error (_("Could not parse signal set: %s"), line);
4081 sigaddset (sigs, signum + 1);
4083 sigaddset (sigs, signum + 2);
4085 sigaddset (sigs, signum + 3);
4087 sigaddset (sigs, signum + 4);
4093 /* Find process PID's pending signals from /proc/pid/status and set
4097 linux_proc_pending_signals (int pid, sigset_t *pending,
4098 sigset_t *blocked, sigset_t *ignored)
4101 char buffer[PATH_MAX], fname[PATH_MAX];
4102 struct cleanup *cleanup;
4104 sigemptyset (pending);
4105 sigemptyset (blocked);
4106 sigemptyset (ignored);
4107 xsnprintf (fname, sizeof fname, "/proc/%d/status", pid);
4108 procfile = gdb_fopen_cloexec (fname, "r");
4109 if (procfile == NULL)
4110 error (_("Could not open %s"), fname);
4111 cleanup = make_cleanup_fclose (procfile);
4113 while (fgets (buffer, PATH_MAX, procfile) != NULL)
4115 /* Normal queued signals are on the SigPnd line in the status
4116 file. However, 2.6 kernels also have a "shared" pending
4117 queue for delivering signals to a thread group, so check for
4120 Unfortunately some Red Hat kernels include the shared pending
4121 queue but not the ShdPnd status field. */
4123 if (strncmp (buffer, "SigPnd:\t", 8) == 0)
4124 add_line_to_sigset (buffer + 8, pending);
4125 else if (strncmp (buffer, "ShdPnd:\t", 8) == 0)
4126 add_line_to_sigset (buffer + 8, pending);
4127 else if (strncmp (buffer, "SigBlk:\t", 8) == 0)
4128 add_line_to_sigset (buffer + 8, blocked);
4129 else if (strncmp (buffer, "SigIgn:\t", 8) == 0)
4130 add_line_to_sigset (buffer + 8, ignored);
4133 do_cleanups (cleanup);
4136 static enum target_xfer_status
4137 linux_nat_xfer_osdata (struct target_ops *ops, enum target_object object,
4138 const char *annex, gdb_byte *readbuf,
4139 const gdb_byte *writebuf, ULONGEST offset, ULONGEST len,
4140 ULONGEST *xfered_len)
4142 gdb_assert (object == TARGET_OBJECT_OSDATA);
4144 *xfered_len = linux_common_xfer_osdata (annex, readbuf, offset, len);
4145 if (*xfered_len == 0)
4146 return TARGET_XFER_EOF;
4148 return TARGET_XFER_OK;
4151 static enum target_xfer_status
4152 linux_xfer_partial (struct target_ops *ops, enum target_object object,
4153 const char *annex, gdb_byte *readbuf,
4154 const gdb_byte *writebuf, ULONGEST offset, ULONGEST len,
4155 ULONGEST *xfered_len)
4157 enum target_xfer_status xfer;
4159 if (object == TARGET_OBJECT_AUXV)
4160 return memory_xfer_auxv (ops, object, annex, readbuf, writebuf,
4161 offset, len, xfered_len);
4163 if (object == TARGET_OBJECT_OSDATA)
4164 return linux_nat_xfer_osdata (ops, object, annex, readbuf, writebuf,
4165 offset, len, xfered_len);
4167 if (object == TARGET_OBJECT_SPU)
4168 return linux_proc_xfer_spu (ops, object, annex, readbuf, writebuf,
4169 offset, len, xfered_len);
4171 /* GDB calculates all the addresses in possibly larget width of the address.
4172 Address width needs to be masked before its final use - either by
4173 linux_proc_xfer_partial or inf_ptrace_xfer_partial.
4175 Compare ADDR_BIT first to avoid a compiler warning on shift overflow. */
4177 if (object == TARGET_OBJECT_MEMORY)
4179 int addr_bit = gdbarch_addr_bit (target_gdbarch ());
4181 if (addr_bit < (sizeof (ULONGEST) * HOST_CHAR_BIT))
4182 offset &= ((ULONGEST) 1 << addr_bit) - 1;
4185 xfer = linux_proc_xfer_partial (ops, object, annex, readbuf, writebuf,
4186 offset, len, xfered_len);
4187 if (xfer != TARGET_XFER_EOF)
4190 return super_xfer_partial (ops, object, annex, readbuf, writebuf,
4191 offset, len, xfered_len);
4195 cleanup_target_stop (void *arg)
4197 ptid_t *ptid = (ptid_t *) arg;
4199 gdb_assert (arg != NULL);
4202 target_resume (*ptid, 0, GDB_SIGNAL_0);
4205 static VEC(static_tracepoint_marker_p) *
4206 linux_child_static_tracepoint_markers_by_strid (struct target_ops *self,
4209 char s[IPA_CMD_BUF_SIZE];
4210 struct cleanup *old_chain;
4211 int pid = ptid_get_pid (inferior_ptid);
4212 VEC(static_tracepoint_marker_p) *markers = NULL;
4213 struct static_tracepoint_marker *marker = NULL;
4215 ptid_t ptid = ptid_build (pid, 0, 0);
4220 memcpy (s, "qTfSTM", sizeof ("qTfSTM"));
4221 s[sizeof ("qTfSTM")] = 0;
4223 agent_run_command (pid, s, strlen (s) + 1);
4225 old_chain = make_cleanup (free_current_marker, &marker);
4226 make_cleanup (cleanup_target_stop, &ptid);
4231 marker = XCNEW (struct static_tracepoint_marker);
4235 parse_static_tracepoint_marker_definition (p, &p, marker);
4237 if (strid == NULL || strcmp (strid, marker->str_id) == 0)
4239 VEC_safe_push (static_tracepoint_marker_p,
4245 release_static_tracepoint_marker (marker);
4246 memset (marker, 0, sizeof (*marker));
4249 while (*p++ == ','); /* comma-separated list */
4251 memcpy (s, "qTsSTM", sizeof ("qTsSTM"));
4252 s[sizeof ("qTsSTM")] = 0;
4253 agent_run_command (pid, s, strlen (s) + 1);
4257 do_cleanups (old_chain);
4262 /* Create a prototype generic GNU/Linux target. The client can override
4263 it with local methods. */
4266 linux_target_install_ops (struct target_ops *t)
4268 t->to_insert_fork_catchpoint = linux_child_insert_fork_catchpoint;
4269 t->to_remove_fork_catchpoint = linux_child_remove_fork_catchpoint;
4270 t->to_insert_vfork_catchpoint = linux_child_insert_vfork_catchpoint;
4271 t->to_remove_vfork_catchpoint = linux_child_remove_vfork_catchpoint;
4272 t->to_insert_exec_catchpoint = linux_child_insert_exec_catchpoint;
4273 t->to_remove_exec_catchpoint = linux_child_remove_exec_catchpoint;
4274 t->to_set_syscall_catchpoint = linux_child_set_syscall_catchpoint;
4275 t->to_pid_to_exec_file = linux_child_pid_to_exec_file;
4276 t->to_post_startup_inferior = linux_child_post_startup_inferior;
4277 t->to_post_attach = linux_child_post_attach;
4278 t->to_follow_fork = linux_child_follow_fork;
4280 super_xfer_partial = t->to_xfer_partial;
4281 t->to_xfer_partial = linux_xfer_partial;
4283 t->to_static_tracepoint_markers_by_strid
4284 = linux_child_static_tracepoint_markers_by_strid;
4290 struct target_ops *t;
4292 t = inf_ptrace_target ();
4293 linux_target_install_ops (t);
4299 linux_trad_target (CORE_ADDR (*register_u_offset)(struct gdbarch *, int, int))
4301 struct target_ops *t;
4303 t = inf_ptrace_trad_target (register_u_offset);
4304 linux_target_install_ops (t);
4309 /* target_is_async_p implementation. */
4312 linux_nat_is_async_p (struct target_ops *ops)
4314 /* NOTE: palves 2008-03-21: We're only async when the user requests
4315 it explicitly with the "set target-async" command.
4316 Someday, linux will always be async. */
4317 return target_async_permitted;
4320 /* target_can_async_p implementation. */
4323 linux_nat_can_async_p (struct target_ops *ops)
4325 /* NOTE: palves 2008-03-21: We're only async when the user requests
4326 it explicitly with the "set target-async" command.
4327 Someday, linux will always be async. */
4328 return target_async_permitted;
4332 linux_nat_supports_non_stop (struct target_ops *self)
4337 /* True if we want to support multi-process. To be removed when GDB
4338 supports multi-exec. */
4340 int linux_multi_process = 1;
4343 linux_nat_supports_multi_process (struct target_ops *self)
4345 return linux_multi_process;
4349 linux_nat_supports_disable_randomization (struct target_ops *self)
4351 #ifdef HAVE_PERSONALITY
4358 static int async_terminal_is_ours = 1;
4360 /* target_terminal_inferior implementation.
4362 This is a wrapper around child_terminal_inferior to add async support. */
4365 linux_nat_terminal_inferior (struct target_ops *self)
4367 if (!target_is_async_p ())
4369 /* Async mode is disabled. */
4370 child_terminal_inferior (self);
4374 child_terminal_inferior (self);
4376 /* Calls to target_terminal_*() are meant to be idempotent. */
4377 if (!async_terminal_is_ours)
4380 delete_file_handler (input_fd);
4381 async_terminal_is_ours = 0;
4385 /* target_terminal_ours implementation.
4387 This is a wrapper around child_terminal_ours to add async support (and
4388 implement the target_terminal_ours vs target_terminal_ours_for_output
4389 distinction). child_terminal_ours is currently no different than
4390 child_terminal_ours_for_output.
4391 We leave target_terminal_ours_for_output alone, leaving it to
4392 child_terminal_ours_for_output. */
4395 linux_nat_terminal_ours (struct target_ops *self)
4397 if (!target_is_async_p ())
4399 /* Async mode is disabled. */
4400 child_terminal_ours (self);
4404 /* GDB should never give the terminal to the inferior if the
4405 inferior is running in the background (run&, continue&, etc.),
4406 but claiming it sure should. */
4407 child_terminal_ours (self);
4409 if (async_terminal_is_ours)
4412 clear_sigint_trap ();
4413 add_file_handler (input_fd, stdin_event_handler, 0);
4414 async_terminal_is_ours = 1;
4417 static void (*async_client_callback) (enum inferior_event_type event_type,
4419 static void *async_client_context;
4421 /* SIGCHLD handler that serves two purposes: In non-stop/async mode,
4422 so we notice when any child changes state, and notify the
4423 event-loop; it allows us to use sigsuspend in linux_nat_wait_1
4424 above to wait for the arrival of a SIGCHLD. */
4427 sigchld_handler (int signo)
4429 int old_errno = errno;
4431 if (debug_linux_nat)
4432 ui_file_write_async_safe (gdb_stdlog,
4433 "sigchld\n", sizeof ("sigchld\n") - 1);
4435 if (signo == SIGCHLD
4436 && linux_nat_event_pipe[0] != -1)
4437 async_file_mark (); /* Let the event loop know that there are
4438 events to handle. */
4443 /* Callback registered with the target events file descriptor. */
4446 handle_target_event (int error, gdb_client_data client_data)
4448 (*async_client_callback) (INF_REG_EVENT, async_client_context);
4451 /* Create/destroy the target events pipe. Returns previous state. */
4454 linux_async_pipe (int enable)
4456 int previous = (linux_nat_event_pipe[0] != -1);
4458 if (previous != enable)
4462 /* Block child signals while we create/destroy the pipe, as
4463 their handler writes to it. */
4464 block_child_signals (&prev_mask);
4468 if (gdb_pipe_cloexec (linux_nat_event_pipe) == -1)
4469 internal_error (__FILE__, __LINE__,
4470 "creating event pipe failed.");
4472 fcntl (linux_nat_event_pipe[0], F_SETFL, O_NONBLOCK);
4473 fcntl (linux_nat_event_pipe[1], F_SETFL, O_NONBLOCK);
4477 close (linux_nat_event_pipe[0]);
4478 close (linux_nat_event_pipe[1]);
4479 linux_nat_event_pipe[0] = -1;
4480 linux_nat_event_pipe[1] = -1;
4483 restore_child_signals_mask (&prev_mask);
4489 /* target_async implementation. */
4492 linux_nat_async (struct target_ops *ops,
4493 void (*callback) (enum inferior_event_type event_type,
4497 if (callback != NULL)
4499 async_client_callback = callback;
4500 async_client_context = context;
4501 if (!linux_async_pipe (1))
4503 add_file_handler (linux_nat_event_pipe[0],
4504 handle_target_event, NULL);
4505 /* There may be pending events to handle. Tell the event loop
4512 async_client_callback = callback;
4513 async_client_context = context;
4514 delete_file_handler (linux_nat_event_pipe[0]);
4515 linux_async_pipe (0);
4520 /* Stop an LWP, and push a GDB_SIGNAL_0 stop status if no other
4524 linux_nat_stop_lwp (struct lwp_info *lwp, void *data)
4528 if (debug_linux_nat)
4529 fprintf_unfiltered (gdb_stdlog,
4530 "LNSL: running -> suspending %s\n",
4531 target_pid_to_str (lwp->ptid));
4534 if (lwp->last_resume_kind == resume_stop)
4536 if (debug_linux_nat)
4537 fprintf_unfiltered (gdb_stdlog,
4538 "linux-nat: already stopping LWP %ld at "
4540 ptid_get_lwp (lwp->ptid));
4544 stop_callback (lwp, NULL);
4545 lwp->last_resume_kind = resume_stop;
4549 /* Already known to be stopped; do nothing. */
4551 if (debug_linux_nat)
4553 if (find_thread_ptid (lwp->ptid)->stop_requested)
4554 fprintf_unfiltered (gdb_stdlog,
4555 "LNSL: already stopped/stop_requested %s\n",
4556 target_pid_to_str (lwp->ptid));
4558 fprintf_unfiltered (gdb_stdlog,
4559 "LNSL: already stopped/no "
4560 "stop_requested yet %s\n",
4561 target_pid_to_str (lwp->ptid));
4568 linux_nat_stop (struct target_ops *self, ptid_t ptid)
4571 iterate_over_lwps (ptid, linux_nat_stop_lwp, NULL);
4573 linux_ops->to_stop (linux_ops, ptid);
4577 linux_nat_close (struct target_ops *self)
4579 /* Unregister from the event loop. */
4580 if (linux_nat_is_async_p (self))
4581 linux_nat_async (self, NULL, NULL);
4583 if (linux_ops->to_close)
4584 linux_ops->to_close (linux_ops);
4589 /* When requests are passed down from the linux-nat layer to the
4590 single threaded inf-ptrace layer, ptids of (lwpid,0,0) form are
4591 used. The address space pointer is stored in the inferior object,
4592 but the common code that is passed such ptid can't tell whether
4593 lwpid is a "main" process id or not (it assumes so). We reverse
4594 look up the "main" process id from the lwp here. */
4596 static struct address_space *
4597 linux_nat_thread_address_space (struct target_ops *t, ptid_t ptid)
4599 struct lwp_info *lwp;
4600 struct inferior *inf;
4603 if (ptid_get_lwp (ptid) == 0)
4605 /* An (lwpid,0,0) ptid. Look up the lwp object to get at the
4607 lwp = find_lwp_pid (ptid);
4608 pid = ptid_get_pid (lwp->ptid);
4612 /* A (pid,lwpid,0) ptid. */
4613 pid = ptid_get_pid (ptid);
4616 inf = find_inferior_pid (pid);
4617 gdb_assert (inf != NULL);
4621 /* Return the cached value of the processor core for thread PTID. */
4624 linux_nat_core_of_thread (struct target_ops *ops, ptid_t ptid)
4626 struct lwp_info *info = find_lwp_pid (ptid);
4634 linux_nat_add_target (struct target_ops *t)
4636 /* Save the provided single-threaded target. We save this in a separate
4637 variable because another target we've inherited from (e.g. inf-ptrace)
4638 may have saved a pointer to T; we want to use it for the final
4639 process stratum target. */
4640 linux_ops_saved = *t;
4641 linux_ops = &linux_ops_saved;
4643 /* Override some methods for multithreading. */
4644 t->to_create_inferior = linux_nat_create_inferior;
4645 t->to_attach = linux_nat_attach;
4646 t->to_detach = linux_nat_detach;
4647 t->to_resume = linux_nat_resume;
4648 t->to_wait = linux_nat_wait;
4649 t->to_pass_signals = linux_nat_pass_signals;
4650 t->to_xfer_partial = linux_nat_xfer_partial;
4651 t->to_kill = linux_nat_kill;
4652 t->to_mourn_inferior = linux_nat_mourn_inferior;
4653 t->to_thread_alive = linux_nat_thread_alive;
4654 t->to_pid_to_str = linux_nat_pid_to_str;
4655 t->to_thread_name = linux_nat_thread_name;
4656 t->to_has_thread_control = tc_schedlock;
4657 t->to_thread_address_space = linux_nat_thread_address_space;
4658 t->to_stopped_by_watchpoint = linux_nat_stopped_by_watchpoint;
4659 t->to_stopped_data_address = linux_nat_stopped_data_address;
4661 t->to_can_async_p = linux_nat_can_async_p;
4662 t->to_is_async_p = linux_nat_is_async_p;
4663 t->to_supports_non_stop = linux_nat_supports_non_stop;
4664 t->to_async = linux_nat_async;
4665 t->to_terminal_inferior = linux_nat_terminal_inferior;
4666 t->to_terminal_ours = linux_nat_terminal_ours;
4668 super_close = t->to_close;
4669 t->to_close = linux_nat_close;
4671 /* Methods for non-stop support. */
4672 t->to_stop = linux_nat_stop;
4674 t->to_supports_multi_process = linux_nat_supports_multi_process;
4676 t->to_supports_disable_randomization
4677 = linux_nat_supports_disable_randomization;
4679 t->to_core_of_thread = linux_nat_core_of_thread;
4681 /* We don't change the stratum; this target will sit at
4682 process_stratum and thread_db will set at thread_stratum. This
4683 is a little strange, since this is a multi-threaded-capable
4684 target, but we want to be on the stack below thread_db, and we
4685 also want to be used for single-threaded processes. */
4690 /* Register a method to call whenever a new thread is attached. */
4692 linux_nat_set_new_thread (struct target_ops *t,
4693 void (*new_thread) (struct lwp_info *))
4695 /* Save the pointer. We only support a single registered instance
4696 of the GNU/Linux native target, so we do not need to map this to
4698 linux_nat_new_thread = new_thread;
4701 /* See declaration in linux-nat.h. */
4704 linux_nat_set_new_fork (struct target_ops *t,
4705 linux_nat_new_fork_ftype *new_fork)
4707 /* Save the pointer. */
4708 linux_nat_new_fork = new_fork;
4711 /* See declaration in linux-nat.h. */
4714 linux_nat_set_forget_process (struct target_ops *t,
4715 linux_nat_forget_process_ftype *fn)
4717 /* Save the pointer. */
4718 linux_nat_forget_process_hook = fn;
4721 /* See declaration in linux-nat.h. */
4724 linux_nat_forget_process (pid_t pid)
4726 if (linux_nat_forget_process_hook != NULL)
4727 linux_nat_forget_process_hook (pid);
4730 /* Register a method that converts a siginfo object between the layout
4731 that ptrace returns, and the layout in the architecture of the
4734 linux_nat_set_siginfo_fixup (struct target_ops *t,
4735 int (*siginfo_fixup) (siginfo_t *,
4739 /* Save the pointer. */
4740 linux_nat_siginfo_fixup = siginfo_fixup;
4743 /* Register a method to call prior to resuming a thread. */
4746 linux_nat_set_prepare_to_resume (struct target_ops *t,
4747 void (*prepare_to_resume) (struct lwp_info *))
4749 /* Save the pointer. */
4750 linux_nat_prepare_to_resume = prepare_to_resume;
4753 /* See linux-nat.h. */
4756 linux_nat_get_siginfo (ptid_t ptid, siginfo_t *siginfo)
4760 pid = ptid_get_lwp (ptid);
4762 pid = ptid_get_pid (ptid);
4765 ptrace (PTRACE_GETSIGINFO, pid, (PTRACE_TYPE_ARG3) 0, siginfo);
4768 memset (siginfo, 0, sizeof (*siginfo));
4774 /* Provide a prototype to silence -Wmissing-prototypes. */
4775 extern initialize_file_ftype _initialize_linux_nat;
4778 _initialize_linux_nat (void)
4780 add_setshow_zuinteger_cmd ("lin-lwp", class_maintenance,
4781 &debug_linux_nat, _("\
4782 Set debugging of GNU/Linux lwp module."), _("\
4783 Show debugging of GNU/Linux lwp module."), _("\
4784 Enables printf debugging output."),
4786 show_debug_linux_nat,
4787 &setdebuglist, &showdebuglist);
4789 /* Save this mask as the default. */
4790 sigprocmask (SIG_SETMASK, NULL, &normal_mask);
4792 /* Install a SIGCHLD handler. */
4793 sigchld_action.sa_handler = sigchld_handler;
4794 sigemptyset (&sigchld_action.sa_mask);
4795 sigchld_action.sa_flags = SA_RESTART;
4797 /* Make it the default. */
4798 sigaction (SIGCHLD, &sigchld_action, NULL);
4800 /* Make sure we don't block SIGCHLD during a sigsuspend. */
4801 sigprocmask (SIG_SETMASK, NULL, &suspend_mask);
4802 sigdelset (&suspend_mask, SIGCHLD);
4804 sigemptyset (&blocked_mask);
4806 /* Do not enable PTRACE_O_TRACEEXIT until GDB is more prepared to
4807 support read-only process state. */
4808 linux_ptrace_set_additional_flags (PTRACE_O_TRACESYSGOOD
4809 | PTRACE_O_TRACEVFORKDONE
4810 | PTRACE_O_TRACEVFORK
4811 | PTRACE_O_TRACEFORK
4812 | PTRACE_O_TRACEEXEC);
4816 /* FIXME: kettenis/2000-08-26: The stuff on this page is specific to
4817 the GNU/Linux Threads library and therefore doesn't really belong
4820 /* Read variable NAME in the target and return its value if found.
4821 Otherwise return zero. It is assumed that the type of the variable
4825 get_signo (const char *name)
4827 struct bound_minimal_symbol ms;
4830 ms = lookup_minimal_symbol (name, NULL, NULL);
4831 if (ms.minsym == NULL)
4834 if (target_read_memory (BMSYMBOL_VALUE_ADDRESS (ms), (gdb_byte *) &signo,
4835 sizeof (signo)) != 0)
4841 /* Return the set of signals used by the threads library in *SET. */
4844 lin_thread_get_thread_signals (sigset_t *set)
4846 struct sigaction action;
4847 int restart, cancel;
4849 sigemptyset (&blocked_mask);
4852 restart = get_signo ("__pthread_sig_restart");
4853 cancel = get_signo ("__pthread_sig_cancel");
4855 /* LinuxThreads normally uses the first two RT signals, but in some legacy
4856 cases may use SIGUSR1/SIGUSR2. NPTL always uses RT signals, but does
4857 not provide any way for the debugger to query the signal numbers -
4858 fortunately they don't change! */
4861 restart = __SIGRTMIN;
4864 cancel = __SIGRTMIN + 1;
4866 sigaddset (set, restart);
4867 sigaddset (set, cancel);
4869 /* The GNU/Linux Threads library makes terminating threads send a
4870 special "cancel" signal instead of SIGCHLD. Make sure we catch
4871 those (to prevent them from terminating GDB itself, which is
4872 likely to be their default action) and treat them the same way as
4875 action.sa_handler = sigchld_handler;
4876 sigemptyset (&action.sa_mask);
4877 action.sa_flags = SA_RESTART;
4878 sigaction (cancel, &action, NULL);
4880 /* We block the "cancel" signal throughout this code ... */
4881 sigaddset (&blocked_mask, cancel);
4882 sigprocmask (SIG_BLOCK, &blocked_mask, NULL);
4884 /* ... except during a sigsuspend. */
4885 sigdelset (&suspend_mask, cancel);