gdb/linux-nat.c - gdb

Global variables defined

Data types defined

Functions defined

Macros defined

Source code

  1. /* GNU/Linux native-dependent code common to multiple platforms.

  3.    Copyright (C) 2001-2015 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/>.  */

  20. #include "defs.h"
  21. #include "inferior.h"
  22. #include "infrun.h"
  23. #include "target.h"
  24. #include "nat/linux-nat.h"
  25. #include "nat/linux-waitpid.h"
  26. #include "gdb_wait.h"
  27. #ifdef HAVE_TKILL_SYSCALL
  28. #include <unistd.h>
  29. #include <sys/syscall.h>
  30. #endif
  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"
  37. #include "gdbcmd.h"
  38. #include "regcache.h"
  39. #include "regset.h"
  40. #include "inf-child.h"
  41. #include "inf-ptrace.h"
  42. #include "auxv.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 */
  50. #include "inf-loop.h"
  51. #include "event-loop.h"
  52. #include "event-top.h"
  53. #include <pwd.h>
  54. #include <sys/types.h>
  55. #include <dirent.h>
  56. #include "xml-support.h"
  57. #include <sys/vfs.h>
  58. #include "solib.h"
  59. #include "nat/linux-osdata.h"
  60. #include "linux-tdep.h"
  61. #include "symfile.h"
  62. #include "agent.h"
  63. #include "tracepoint.h"
  64. #include "buffer.h"
  65. #include "target-descriptions.h"
  66. #include "filestuff.h"
  67. #include "objfiles.h"

  69. #ifndef SPUFS_MAGIC
  70. ‌#define SPUFS_MAGIC 0x23c9b64e
  71. #endif

  73. #ifdef HAVE_PERSONALITY
  74. # include <sys/personality.h>
  75. # if !HAVE_DECL_ADDR_NO_RANDOMIZE
  76. ‌#  define ADDR_NO_RANDOMIZE 0x0040000
  77. # endif
  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
  99. __WCLONED.

  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
  134. sigsuspend.

  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.

  144. Use of signals
  145. ==============

  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
  166. blocked.  */

  168. #ifndef O_LARGEFILE
  169. ‌#define O_LARGEFILE 0
  170. #endif

  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
  184.    attached.  */
  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 *,
  194.                                        gdb_byte *,
  195.                                        int);

  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;
  206. static void
  207. ‌show_debug_linux_nat (struct ui_file *file, int from_tty,
  208.                       struct cmd_list_element *c, const char *value)
  209. {
  210.   fprintf_filtered (file, _("Debugging of GNU/Linux lwp module is %s.\n"),
  211.                     value);
  212. }

  214. ‌struct simple_pid_list
  215. {
  216.   int pid;
  217.   int status;
  218.   struct simple_pid_list *next;
  219. };
  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
  225.    event loop.  */
  226. ‌static int linux_nat_event_pipe[2] = { -1, -1 };

  228. /* Flush the event pipe.  */

  230. static void
  231. ‌async_file_flush (void)
  232. {
  233.   int ret;
  234.   char buf;

  236.   do
  237.     {
  238.       ret = read (linux_nat_event_pipe[0], &buf, 1);
  239.     }
  240.   while (ret >= 0 || (ret == -1 && errno == EINTR));
  241. }

  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.  */

  247. static void
  248. ‌async_file_mark (void)
  249. {
  250.   int ret;

  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
  254.      left-overs.  */
  255.   async_file_flush ();

  257.   do
  258.     {
  259.       ret = write (linux_nat_event_pipe[1], "+", 1);
  260.     }
  261.   while (ret == -1 && errno == EINTR);

  263.   /* Ignore EAGAIN.  If the pipe is full, the event loop will already
  264.      be awakened anyway.  */
  265. }

  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);

  274. struct lwp_info;
  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);

  280. static int lwp_status_pending_p (struct lwp_info *lp);

  282. static int check_stopped_by_breakpoint (struct lwp_info *lp);
  283. static int sigtrap_is_event (int status);
  284. ‌static int (*linux_nat_status_is_event) (int status) = sigtrap_is_event;


  287. /* Trivial list manipulation functions to keep track of a list of
  288.    new stopped processes.  */
  289. static void
  290. ‌add_to_pid_list (struct simple_pid_list **listp, int pid, int status)
  291. {
  292.   struct simple_pid_list *new_pid = xmalloc (sizeof (struct simple_pid_list));

  294.   new_pid->pid = pid;
  295.   new_pid->status = status;
  296.   new_pid->next = *listp;
  297.   *listp = new_pid;
  298. }

  300. static int
  301. ‌in_pid_list_p (struct simple_pid_list *list, int pid)
  302. {
  303.   struct simple_pid_list *p;

  305.   for (p = list; p != NULL; p = p->next)
  306.     if (p->pid == pid)
  307.       return 1;
  308.   return 0;
  309. }

  311. static int
  312. ‌pull_pid_from_list (struct simple_pid_list **listp, int pid, int *statusp)
  313. {
  314.   struct simple_pid_list **p;

  316.   for (p = listp; *p != NULL; p = &(*p)->next)
  317.     if ((*p)->pid == pid)
  318.       {
  319.         struct simple_pid_list *next = (*p)->next;

  321.         *statusp = (*p)->status;
  322.         xfree (*p);
  323.         *p = next;
  324.         return 1;
  325.       }
  326.   return 0;
  327. }

  329. /* Initialize ptrace warnings and check for supported ptrace
  330.    features given PID.

  332.    ATTACHED should be nonzero iff we attached to the inferior.  */

  334. static void
  335. ‌linux_init_ptrace (pid_t pid, int attached)
  336. {
  337.   linux_enable_event_reporting (pid, attached);
  338.   linux_ptrace_init_warnings ();
  339. }

  341. static void
  342. ‌linux_child_post_attach (struct target_ops *self, int pid)
  343. {
  344.   linux_init_ptrace (pid, 1);
  345. }

  347. static void
  348. ‌linux_child_post_startup_inferior (struct target_ops *self, ptid_t ptid)
  349. {
  350.   linux_init_ptrace (ptid_get_pid (ptid), 0);
  351. }

  353. /* Return the number of known LWPs in the tgid given by PID.  */

  355. static int
  356. ‌num_lwps (int pid)
  357. {
  358.   int count = 0;
  359.   struct lwp_info *lp;

  361.   for (lp = lwp_list; lp; lp = lp->next)
  362.     if (ptid_get_pid (lp->ptid) == pid)
  363.       count++;

  365.   return count;
  366. }

  368. /* Call delete_lwp with prototype compatible for make_cleanup.  */

  370. static void
  371. ‌delete_lwp_cleanup (void *lp_voidp)
  372. {
  373.   struct lwp_info *lp = lp_voidp;

  375.   delete_lwp (lp->ptid);
  376. }

  378. /* Target hook for follow_fork.  On entry inferior_ptid must be the
  379.    ptid of the followed inferior.  At return, inferior_ptid will be
  380.    unchanged.  */

  382. static int
  383. ‌linux_child_follow_fork (struct target_ops *ops, int follow_child,
  384.                          int detach_fork)
  385. {
  386.   if (!follow_child)
  387.     {
  388.       struct lwp_info *child_lp = NULL;
  389.       int status = W_STOPCODE (0);
  390.       struct cleanup *old_chain;
  391.       int has_vforked;
  392.       int parent_pid, child_pid;

  394.       has_vforked = (inferior_thread ()->pending_follow.kind
  395.                      == TARGET_WAITKIND_VFORKED);
  396.       parent_pid = ptid_get_lwp (inferior_ptid);
  397.       if (parent_pid == 0)
  398.         parent_pid = ptid_get_pid (inferior_ptid);
  399.       child_pid
  400.         = ptid_get_pid (inferior_thread ()->pending_follow.value.related_pid);


  403.       /* We're already attached to the parent, by default.  */
  404.       old_chain = save_inferior_ptid ();
  405.       inferior_ptid = ptid_build (child_pid, child_pid, 0);
  406.       child_lp = add_lwp (inferior_ptid);
  407.       child_lp->stopped = 1;
  408.       child_lp->last_resume_kind = resume_stop;

  410.       /* Detach new forked process?  */
  411.       if (detach_fork)
  412.         {
  413.           make_cleanup (delete_lwp_cleanup, child_lp);

  415.           if (linux_nat_prepare_to_resume != NULL)
  416.             linux_nat_prepare_to_resume (child_lp);

  418.           /* When debugging an inferior in an architecture that supports
  419.              hardware single stepping on a kernel without commit
  420.              6580807da14c423f0d0a708108e6df6ebc8bc83d, the vfork child
  421.              process starts with the TIF_SINGLESTEP/X86_EFLAGS_TF bits
  422.              set if the parent process had them set.
  423.              To work around this, single step the child process
  424.              once before detaching to clear the flags.  */

  426.           if (!gdbarch_software_single_step_p (target_thread_architecture
  427.                                                    (child_lp->ptid)))
  428.             {
  429.               linux_disable_event_reporting (child_pid);
  430.               if (ptrace (PTRACE_SINGLESTEP, child_pid, 0, 0) < 0)
  431.                 perror_with_name (_("Couldn't do single step"));
  432.               if (my_waitpid (child_pid, &status, 0) < 0)
  433.                 perror_with_name (_("Couldn't wait vfork process"));
  434.             }

  436.           if (WIFSTOPPED (status))
  437.             {
  438.               int signo;

  440.               signo = WSTOPSIG (status);
  441.               if (signo != 0
  442.                   && !signal_pass_state (gdb_signal_from_host (signo)))
  443.                 signo = 0;
  444.               ptrace (PTRACE_DETACH, child_pid, 0, signo);
  445.             }

  447.           /* Resets value of inferior_ptid to parent ptid.  */
  448.           do_cleanups (old_chain);
  449.         }
  450.       else
  451.         {
  452.           /* Let the thread_db layer learn about this new process.  */
  453.           check_for_thread_db ();
  454.         }

  456.       do_cleanups (old_chain);

  458.       if (has_vforked)
  459.         {
  460.           struct lwp_info *parent_lp;

  462.           parent_lp = find_lwp_pid (pid_to_ptid (parent_pid));
  463.           gdb_assert (linux_supports_tracefork () >= 0);

  465.           if (linux_supports_tracevforkdone ())
  466.             {
  467.                 if (debug_linux_nat)
  468.                   fprintf_unfiltered (gdb_stdlog,
  469.                                       "LCFF: waiting for VFORK_DONE on %d\n",
  470.                                       parent_pid);
  471.               parent_lp->stopped = 1;

  473.               /* We'll handle the VFORK_DONE event like any other
  474.                  event, in target_wait.  */
  475.             }
  476.           else
  477.             {
  478.               /* We can't insert breakpoints until the child has
  479.                  finished with the shared memory region.  We need to
  480.                  wait until that happens.  Ideal would be to just
  481.                  call:
  482.                  - ptrace (PTRACE_SYSCALL, parent_pid, 0, 0);
  483.                  - waitpid (parent_pid, &status, __WALL);
  484.                  However, most architectures can't handle a syscall
  485.                  being traced on the way out if it wasn't traced on
  486.                  the way in.

  488.                  We might also think to loop, continuing the child
  489.                  until it exits or gets a SIGTRAP.  One problem is
  490.                  that the child might call ptrace with PTRACE_TRACEME.

  492.                  There's no simple and reliable way to figure out when
  493.                  the vforked child will be done with its copy of the
  494.                  shared memory.  We could step it out of the syscall,
  495.                  two instructions, let it go, and then single-step the
  496.                  parent once.  When we have hardware single-step, this
  497.                  would work; with software single-step it could still
  498.                  be made to work but we'd have to be able to insert
  499.                  single-step breakpoints in the child, and we'd have
  500.                  to insert -just- the single-step breakpoint in the
  501.                  parent.  Very awkward.

  503.                  In the end, the best we can do is to make sure it
  504.                  runs for a little while.  Hopefully it will be out of
  505.                  range of any breakpoints we reinsert.  Usually this
  506.                  is only the single-step breakpoint at vfork's return
  507.                  point.  */

  509.                 if (debug_linux_nat)
  510.                   fprintf_unfiltered (gdb_stdlog,
  511.                                     "LCFF: no VFORK_DONE "
  512.                                     "support, sleeping a bit\n");

  514.               usleep (10000);

  516.               /* Pretend we've seen a PTRACE_EVENT_VFORK_DONE event,
  517.                  and leave it pending.  The next linux_nat_resume call
  518.                  will notice a pending event, and bypasses actually
  519.                  resuming the inferior.  */
  520.               parent_lp->status = 0;
  521.               parent_lp->waitstatus.kind = TARGET_WAITKIND_VFORK_DONE;
  522.               parent_lp->stopped = 1;

  524.               /* If we're in async mode, need to tell the event loop
  525.                  there's something here to process.  */
  526.               if (target_can_async_p ())
  527.                 async_file_mark ();
  528.             }
  529.         }
  530.     }
  531.   else
  532.     {
  533.       struct lwp_info *child_lp;

  535.       child_lp = add_lwp (inferior_ptid);
  536.       child_lp->stopped = 1;
  537.       child_lp->last_resume_kind = resume_stop;

  539.       /* Let the thread_db layer learn about this new process.  */
  540.       check_for_thread_db ();
  541.     }

  543.   return 0;
  544. }


  547. static int
  548. ‌linux_child_insert_fork_catchpoint (struct target_ops *self, int pid)
  549. {
  550.   return !linux_supports_tracefork ();
  551. }

  553. static int
  554. ‌linux_child_remove_fork_catchpoint (struct target_ops *self, int pid)
  555. {
  556.   return 0;
  557. }

  559. static int
  560. ‌linux_child_insert_vfork_catchpoint (struct target_ops *self, int pid)
  561. {
  562.   return !linux_supports_tracefork ();
  563. }

  565. static int
  566. ‌linux_child_remove_vfork_catchpoint (struct target_ops *self, int pid)
  567. {
  568.   return 0;
  569. }

  571. static int
  572. ‌linux_child_insert_exec_catchpoint (struct target_ops *self, int pid)
  573. {
  574.   return !linux_supports_tracefork ();
  575. }

  577. static int
  578. ‌linux_child_remove_exec_catchpoint (struct target_ops *self, int pid)
  579. {
  580.   return 0;
  581. }

  583. static int
  584. ‌linux_child_set_syscall_catchpoint (struct target_ops *self,
  585.                                     int pid, int needed, int any_count,
  586.                                     int table_size, int *table)
  587. {
  588.   if (!linux_supports_tracesysgood ())
  589.     return 1;

  591.   /* On GNU/Linux, we ignore the arguments.  It means that we only
  592.      enable the syscall catchpoints, but do not disable them.

  594.      Also, we do not use the `table' information because we do not
  595.      filter system calls here.  We let GDB do the logic for us.  */
  596.   return 0;
  597. }

  599. /* On GNU/Linux there are no real LWP's.  The closest thing to LWP's
  600.    are processes sharing the same VM space.  A multi-threaded process
  601.    is basically a group of such processes.  However, such a grouping
  602.    is almost entirely a user-space issue; the kernel doesn't enforce
  603.    such a grouping at all (this might change in the future).  In
  604.    general, we'll rely on the threads library (i.e. the GNU/Linux
  605.    Threads library) to provide such a grouping.

  607.    It is perfectly well possible to write a multi-threaded application
  608.    without the assistance of a threads library, by using the clone
  609.    system call directly.  This module should be able to give some
  610.    rudimentary support for debugging such applications if developers
  611.    specify the CLONE_PTRACE flag in the clone system call, and are
  612.    using the Linux kernel 2.4 or above.

  614.    Note that there are some peculiarities in GNU/Linux that affect
  615.    this code:

  617.    - In general one should specify the __WCLONE flag to waitpid in
  618.      order to make it report events for any of the cloned processes
  619.      (and leave it out for the initial process).  However, if a cloned
  620.      process has exited the exit status is only reported if the
  621.      __WCLONE flag is absent.  Linux kernel 2.4 has a __WALL flag, but
  622.      we cannot use it since GDB must work on older systems too.

  624.    - When a traced, cloned process exits and is waited for by the
  625.      debugger, the kernel reassigns it to the original parent and
  626.      keeps it around as a "zombie".  Somehow, the GNU/Linux Threads
  627.      library doesn't notice this, which leads to the "zombie problem":
  628.      When debugged a multi-threaded process that spawns a lot of
  629.      threads will run out of processes, even if the threads exit,
  630.      because the "zombies" stay around.  */

  632. /* List of known LWPs.  */
  633. ‌struct lwp_info *lwp_list;


  636. /* Original signal mask.  */
  637. ‌static sigset_t normal_mask;

  639. /* Signal mask for use with sigsuspend in linux_nat_wait, initialized in
  640.    _initialize_linux_nat.  */
  641. ‌static sigset_t suspend_mask;

  643. /* Signals to block to make that sigsuspend work.  */
  644. ‌static sigset_t blocked_mask;

  646. /* SIGCHLD action.  */
  647. ‌struct sigaction sigchld_action;

  649. /* Block child signals (SIGCHLD and linux threads signals), and store
  650.    the previous mask in PREV_MASK.  */

  652. static void
  653. ‌block_child_signals (sigset_t *prev_mask)
  654. {
  655.   /* Make sure SIGCHLD is blocked.  */
  656.   if (!sigismember (&blocked_mask, SIGCHLD))
  657.     sigaddset (&blocked_mask, SIGCHLD);

  659.   sigprocmask (SIG_BLOCK, &blocked_mask, prev_mask);
  660. }

  662. /* Restore child signals mask, previously returned by
  663.    block_child_signals.  */

  665. static void
  666. ‌restore_child_signals_mask (sigset_t *prev_mask)
  667. {
  668.   sigprocmask (SIG_SETMASK, prev_mask, NULL);
  669. }

  671. /* Mask of signals to pass directly to the inferior.  */
  672. ‌static sigset_t pass_mask;

  674. /* Update signals to pass to the inferior.  */
  675. static void
  676. ‌linux_nat_pass_signals (struct target_ops *self,
  677.                         int numsigs, unsigned char *pass_signals)
  678. {
  679.   int signo;

  681.   sigemptyset (&pass_mask);

  683.   for (signo = 1; signo < NSIG; signo++)
  684.     {
  685.       int target_signo = gdb_signal_from_host (signo);
  686.       if (target_signo < numsigs && pass_signals[target_signo])
  687.         sigaddset (&pass_mask, signo);
  688.     }
  689. }



  693. /* Prototypes for local functions.  */
  694. static int stop_wait_callback (struct lwp_info *lp, void *data);
  695. static int linux_thread_alive (ptid_t ptid);
  696. static char *linux_child_pid_to_exec_file (struct target_ops *self, int pid);



  700. /* Destroy and free LP.  */

  702. static void
  703. ‌lwp_free (struct lwp_info *lp)
  704. {
  705.   xfree (lp->arch_private);
  706.   xfree (lp);
  707. }

  709. /* Remove all LWPs belong to PID from the lwp list.  */

  711. static void
  712. ‌purge_lwp_list (int pid)
  713. {
  714.   struct lwp_info *lp, *lpprev, *lpnext;

  716.   lpprev = NULL;

  718.   for (lp = lwp_list; lp; lp = lpnext)
  719.     {
  720.       lpnext = lp->next;

  722.       if (ptid_get_pid (lp->ptid) == pid)
  723.         {
  724.           if (lp == lwp_list)
  725.             lwp_list = lp->next;
  726.           else
  727.             lpprev->next = lp->next;

  729.           lwp_free (lp);
  730.         }
  731.       else
  732.         lpprev = lp;
  733.     }
  734. }

  736. /* Add the LWP specified by PTID to the list.  PTID is the first LWP
  737.    in the process.  Return a pointer to the structure describing the
  738.    new LWP.

  740.    This differs from add_lwp in that we don't let the arch specific
  741.    bits know about this new thread.  Current clients of this callback
  742.    take the opportunity to install watchpoints in the new thread, and
  743.    we shouldn't do that for the first thread.  If we're spawning a
  744.    child ("run"), the thread executes the shell wrapper first, and we
  745.    shouldn't touch it until it execs the program we want to debug.
  746.    For "attach", it'd be okay to call the callback, but it's not
  747.    necessary, because watchpoints can't yet have been inserted into
  748.    the inferior.  */

  750. static struct lwp_info *
  751. ‌add_initial_lwp (ptid_t ptid)
  752. {
  753.   struct lwp_info *lp;

  755.   gdb_assert (ptid_lwp_p (ptid));

  757.   lp = (struct lwp_info *) xmalloc (sizeof (struct lwp_info));

  759.   memset (lp, 0, sizeof (struct lwp_info));

  761.   lp->last_resume_kind = resume_continue;
  762.   lp->waitstatus.kind = TARGET_WAITKIND_IGNORE;

  764.   lp->ptid = ptid;
  765.   lp->core = -1;

  767.   lp->next = lwp_list;
  768.   lwp_list = lp;

  770.   return lp;
  771. }

  773. /* Add the LWP specified by PID to the list.  Return a pointer to the
  774.    structure describing the new LWP.  The LWP should already be
  775.    stopped.  */

  777. static struct lwp_info *
  778. ‌add_lwp (ptid_t ptid)
  779. {
  780.   struct lwp_info *lp;

  782.   lp = add_initial_lwp (ptid);

  784.   /* Let the arch specific bits know about this new thread.  Current
  785.      clients of this callback take the opportunity to install
  786.      watchpoints in the new thread.  We don't do this for the first
  787.      thread though.  See add_initial_lwp.  */
  788.   if (linux_nat_new_thread != NULL)
  789.     linux_nat_new_thread (lp);

  791.   return lp;
  792. }

  794. /* Remove the LWP specified by PID from the list.  */

  796. static void
  797. ‌delete_lwp (ptid_t ptid)
  798. {
  799.   struct lwp_info *lp, *lpprev;

  801.   lpprev = NULL;

  803.   for (lp = lwp_list; lp; lpprev = lp, lp = lp->next)
  804.     if (ptid_equal (lp->ptid, ptid))
  805.       break;

  807.   if (!lp)
  808.     return;

  810.   if (lpprev)
  811.     lpprev->next = lp->next;
  812.   else
  813.     lwp_list = lp->next;

  815.   lwp_free (lp);
  816. }

  818. /* Return a pointer to the structure describing the LWP corresponding
  819.    to PID.  If no corresponding LWP could be found, return NULL.  */

  821. static struct lwp_info *
  822. ‌find_lwp_pid (ptid_t ptid)
  823. {
  824.   struct lwp_info *lp;
  825.   int lwp;

  827.   if (ptid_lwp_p (ptid))
  828.     lwp = ptid_get_lwp (ptid);
  829.   else
  830.     lwp = ptid_get_pid (ptid);

  832.   for (lp = lwp_list; lp; lp = lp->next)
  833.     if (lwp == ptid_get_lwp (lp->ptid))
  834.       return lp;

  836.   return NULL;
  837. }

  839. /* Call CALLBACK with its second argument set to DATA for every LWP in
  840.    the list.  If CALLBACK returns 1 for a particular LWP, return a
  841.    pointer to the structure describing that LWP immediately.
  842.    Otherwise return NULL.  */

  844. struct lwp_info *
  845. ‌iterate_over_lwps (ptid_t filter,
  846.                    int (*callback) (struct lwp_info *, void *),
  847.                    void *data)
  848. {
  849.   struct lwp_info *lp, *lpnext;

  851.   for (lp = lwp_list; lp; lp = lpnext)
  852.     {
  853.       lpnext = lp->next;

  855.       if (ptid_match (lp->ptid, filter))
  856.         {
  857.           if ((*callback) (lp, data))
  858.             return lp;
  859.         }
  860.     }

  862.   return NULL;
  863. }

  865. /* Update our internal state when changing from one checkpoint to
  866.    another indicated by NEW_PTID.  We can only switch single-threaded
  867.    applications, so we only create one new LWP, and the previous list
  868.    is discarded.  */

  870. void
  871. ‌linux_nat_switch_fork (ptid_t new_ptid)
  872. {
  873.   struct lwp_info *lp;

  875.   purge_lwp_list (ptid_get_pid (inferior_ptid));

  877.   lp = add_lwp (new_ptid);
  878.   lp->stopped = 1;

  880.   /* This changes the thread's ptid while preserving the gdb thread
  881.      num.  Also changes the inferior pid, while preserving the
  882.      inferior num.  */
  883.   thread_change_ptid (inferior_ptid, new_ptid);

  885.   /* We've just told GDB core that the thread changed target id, but,
  886.      in fact, it really is a different thread, with different register
  887.      contents.  */
  888.   registers_changed ();
  889. }

  891. /* Handle the exit of a single thread LP.  */

  893. static void
  894. ‌exit_lwp (struct lwp_info *lp)
  895. {
  896.   struct thread_info *th = find_thread_ptid (lp->ptid);

  898.   if (th)
  899.     {
  900.       if (print_thread_events)
  901.         printf_unfiltered (_("[%s exited]\n"), target_pid_to_str (lp->ptid));

  903.       delete_thread (lp->ptid);
  904.     }

  906.   delete_lwp (lp->ptid);
  907. }

  909. /* Wait for the LWP specified by LP, which we have just attached to.
  910.    Returns a wait status for that LWP, to cache.  */

  912. static int
  913. ‌linux_nat_post_attach_wait (ptid_t ptid, int first, int *cloned,
  914.                             int *signalled)
  915. {
  916.   pid_t new_pid, pid = ptid_get_lwp (ptid);
  917.   int status;

  919.   if (linux_proc_pid_is_stopped (pid))
  920.     {
  921.       if (debug_linux_nat)
  922.         fprintf_unfiltered (gdb_stdlog,
  923.                             "LNPAW: Attaching to a stopped process\n");

  925.       /* The process is definitely stopped.  It is in a job control
  926.          stop, unless the kernel predates the TASK_STOPPED /
  927.          TASK_TRACED distinction, in which case it might be in a
  928.          ptrace stop.  Make sure it is in a ptrace stop; from there we
  929.          can kill it, signal it, et cetera.

  931.          First make sure there is a pending SIGSTOP.  Since we are
  932.          already attached, the process can not transition from stopped
  933.          to running without a PTRACE_CONT; so we know this signal will
  934.          go into the queue.  The SIGSTOP generated by PTRACE_ATTACH is
  935.          probably already in the queue (unless this kernel is old
  936.          enough to use TASK_STOPPED for ptrace stops); but since SIGSTOP
  937.          is not an RT signal, it can only be queued once.  */
  938.       kill_lwp (pid, SIGSTOP);

  940.       /* Finally, resume the stopped process.  This will deliver the SIGSTOP
  941.          (or a higher priority signal, just like normal PTRACE_ATTACH).  */
  942.       ptrace (PTRACE_CONT, pid, 0, 0);
  943.     }

  945.   /* Make sure the initial process is stopped.  The user-level threads
  946.      layer might want to poke around in the inferior, and that won't
  947.      work if things haven't stabilized yet.  */
  948.   new_pid = my_waitpid (pid, &status, 0);
  949.   if (new_pid == -1 && errno == ECHILD)
  950.     {
  951.       if (first)
  952.         warning (_("%s is a cloned process"), target_pid_to_str (ptid));

  954.       /* Try again with __WCLONE to check cloned processes.  */
  955.       new_pid = my_waitpid (pid, &status, __WCLONE);
  956.       *cloned = 1;
  957.     }

  959.   gdb_assert (pid == new_pid);

  961.   if (!WIFSTOPPED (status))
  962.     {
  963.       /* The pid we tried to attach has apparently just exited.  */
  964.       if (debug_linux_nat)
  965.         fprintf_unfiltered (gdb_stdlog, "LNPAW: Failed to stop %d: %s",
  966.                             pid, status_to_str (status));
  967.       return status;
  968.     }

  970.   if (WSTOPSIG (status) != SIGSTOP)
  971.     {
  972.       *signalled = 1;
  973.       if (debug_linux_nat)
  974.         fprintf_unfiltered (gdb_stdlog,
  975.                             "LNPAW: Received %s after attaching\n",
  976.                             status_to_str (status));
  977.     }

  979.   return status;
  980. }

  982. /* Attach to the LWP specified by PID.  Return 0 if successful, -1 if
  983.    the new LWP could not be attached, or 1 if we're already auto
  984.    attached to this thread, but haven't processed the
  985.    PTRACE_EVENT_CLONE event of its parent thread, so we just ignore
  986.    its existance, without considering it an error.  */

  988. int
  989. ‌lin_lwp_attach_lwp (ptid_t ptid)
  990. {
  991.   struct lwp_info *lp;
  992.   int lwpid;

  994.   gdb_assert (ptid_lwp_p (ptid));

  996.   lp = find_lwp_pid (ptid);
  997.   lwpid = ptid_get_lwp (ptid);

  999.   /* We assume that we're already attached to any LWP that has an id
  1000.      equal to the overall process id, and to any LWP that is already
  1001.      in our list of LWPs.  If we're not seeing exit events from threads
  1002.      and we've had PID wraparound since we last tried to stop all threads,
  1003.      this assumption might be wrong; fortunately, this is very unlikely
  1004.      to happen.  */
  1005.   if (lwpid != ptid_get_pid (ptid) && lp == NULL)
  1006.     {
  1007.       int status, cloned = 0, signalled = 0;

  1009.       if (ptrace (PTRACE_ATTACH, lwpid, 0, 0) < 0)
  1010.         {
  1011.           if (linux_supports_tracefork ())
  1012.             {
  1013.               /* If we haven't stopped all threads when we get here,
  1014.                  we may have seen a thread listed in thread_db's list,
  1015.                  but not processed the PTRACE_EVENT_CLONE yet.  If
  1016.                  that's the case, ignore this new thread, and let
  1017.                  normal event handling discover it later.  */
  1018.               if (in_pid_list_p (stopped_pids, lwpid))
  1019.                 {
  1020.                   /* We've already seen this thread stop, but we
  1021.                      haven't seen the PTRACE_EVENT_CLONE extended
  1022.                      event yet.  */
  1023.                   return 0;
  1024.                 }
  1025.               else
  1026.                 {
  1027.                   int new_pid;
  1028.                   int status;

  1030.                   /* See if we've got a stop for this new child
  1031.                      pending.  If so, we're already attached.  */
  1032.                   gdb_assert (lwpid > 0);
  1033.                   new_pid = my_waitpid (lwpid, &status, WNOHANG);
  1034.                   if (new_pid == -1 && errno == ECHILD)
  1035.                     new_pid = my_waitpid (lwpid, &status, __WCLONE | WNOHANG);
  1036.                   if (new_pid != -1)
  1037.                     {
  1038.                       if (WIFSTOPPED (status))
  1039.                         add_to_pid_list (&stopped_pids, lwpid, status);
  1040.                       return 1;
  1041.                     }
  1042.                 }
  1043.             }

  1045.           /* If we fail to attach to the thread, issue a warning,
  1046.              but continue.  One way this can happen is if thread
  1047.              creation is interrupted; as of Linux kernel 2.6.19, a
  1048.              bug may place threads in the thread list and then fail
  1049.              to create them.  */
  1050.           warning (_("Can't attach %s: %s"), target_pid_to_str (ptid),
  1051.                    safe_strerror (errno));
  1052.           return -1;
  1053.         }

  1055.       if (debug_linux_nat)
  1056.         fprintf_unfiltered (gdb_stdlog,
  1057.                             "LLAL: PTRACE_ATTACH %s, 0, 0 (OK)\n",
  1058.                             target_pid_to_str (ptid));

  1060.       status = linux_nat_post_attach_wait (ptid, 0, &cloned, &signalled);
  1061.       if (!WIFSTOPPED (status))
  1062.         return 1;

  1064.       lp = add_lwp (ptid);
  1065.       lp->stopped = 1;
  1066.       lp->cloned = cloned;
  1067.       lp->signalled = signalled;
  1068.       if (WSTOPSIG (status) != SIGSTOP)
  1069.         {
  1070.           lp->resumed = 1;
  1071.           lp->status = status;
  1072.         }

  1074.       target_post_attach (ptid_get_lwp (lp->ptid));

  1076.       if (debug_linux_nat)
  1077.         {
  1078.           fprintf_unfiltered (gdb_stdlog,
  1079.                               "LLAL: waitpid %s received %s\n",
  1080.                               target_pid_to_str (ptid),
  1081.                               status_to_str (status));
  1082.         }
  1083.     }
  1084.   else
  1085.     {
  1086.       /* We assume that the LWP representing the original process is
  1087.          already stopped.  Mark it as stopped in the data structure
  1088.          that the GNU/linux ptrace layer uses to keep track of
  1089.          threads.  Note that this won't have already been done since
  1090.          the main thread will have, we assume, been stopped by an
  1091.          attach from a different layer.  */
  1092.       if (lp == NULL)
  1093.         lp = add_lwp (ptid);
  1094.       lp->stopped = 1;
  1095.     }

  1097.   lp->last_resume_kind = resume_stop;
  1098.   return 0;
  1099. }

  1101. static void
  1102. ‌linux_nat_create_inferior (struct target_ops *ops,
  1103.                            char *exec_file, char *allargs, char **env,
  1104.                            int from_tty)
  1105. {
  1106. #ifdef HAVE_PERSONALITY
  1107.   int personality_orig = 0, personality_set = 0;
  1108. #endif /* HAVE_PERSONALITY */

  1110.   /* The fork_child mechanism is synchronous and calls target_wait, so
  1111.      we have to mask the async mode.  */

  1113. #ifdef HAVE_PERSONALITY
  1114.   if (disable_randomization)
  1115.     {
  1116.       errno = 0;
  1117.       personality_orig = personality (0xffffffff);
  1118.       if (errno == 0 && !(personality_orig & ADDR_NO_RANDOMIZE))
  1119.         {
  1120.           personality_set = 1;
  1121.           personality (personality_orig | ADDR_NO_RANDOMIZE);
  1122.         }
  1123.       if (errno != 0 || (personality_set
  1124.                          && !(personality (0xffffffff) & ADDR_NO_RANDOMIZE)))
  1125.         warning (_("Error disabling address space randomization: %s"),
  1126.                  safe_strerror (errno));
  1127.     }
  1128. #endif /* HAVE_PERSONALITY */

  1130.   /* Make sure we report all signals during startup.  */
  1131.   linux_nat_pass_signals (ops, 0, NULL);

  1133.   linux_ops->to_create_inferior (ops, exec_file, allargs, env, from_tty);

  1135. #ifdef HAVE_PERSONALITY
  1136.   if (personality_set)
  1137.     {
  1138.       errno = 0;
  1139.       personality (personality_orig);
  1140.       if (errno != 0)
  1141.         warning (_("Error restoring address space randomization: %s"),
  1142.                  safe_strerror (errno));
  1143.     }
  1144. #endif /* HAVE_PERSONALITY */
  1145. }

  1147. /* Callback for linux_proc_attach_tgid_threads.  Attach to PTID if not
  1148.    already attached.  Returns true if a new LWP is found, false
  1149.    otherwise.  */

  1151. static int
  1152. ‌attach_proc_task_lwp_callback (ptid_t ptid)
  1153. {
  1154.   struct lwp_info *lp;

  1156.   /* Ignore LWPs we're already attached to.  */
  1157.   lp = find_lwp_pid (ptid);
  1158.   if (lp == NULL)
  1159.     {
  1160.       int lwpid = ptid_get_lwp (ptid);

  1162.       if (ptrace (PTRACE_ATTACH, lwpid, 0, 0) < 0)
  1163.         {
  1164.           int err = errno;

  1166.           /* Be quiet if we simply raced with the thread exiting.
  1167.              EPERM is returned if the thread's task still exists, and
  1168.              is marked as exited or zombie, as well as other
  1169.              conditions, so in that case, confirm the status in
  1170.              /proc/PID/status.  */
  1171.           if (err == ESRCH
  1172.               || (err == EPERM && linux_proc_pid_is_gone (lwpid)))
  1173.             {
  1174.               if (debug_linux_nat)
  1175.                 {
  1176.                   fprintf_unfiltered (gdb_stdlog,
  1177.                                       "Cannot attach to lwp %d: "
  1178.                                       "thread is gone (%d: %s)\n",
  1179.                                       lwpid, err, safe_strerror (err));
  1180.                 }
  1181.             }
  1182.           else
  1183.             {
  1184.               warning (_("Cannot attach to lwp %d: %s\n"),
  1185.                        lwpid,
  1186.                        linux_ptrace_attach_fail_reason_string (ptid,
  1187.                                                                err));
  1188.             }
  1189.         }
  1190.       else
  1191.         {
  1192.           if (debug_linux_nat)
  1193.             fprintf_unfiltered (gdb_stdlog,
  1194.                                 "PTRACE_ATTACH %s, 0, 0 (OK)\n",
  1195.                                 target_pid_to_str (ptid));

  1197.           lp = add_lwp (ptid);
  1198.           lp->cloned = 1;

  1200.           /* The next time we wait for this LWP we'll see a SIGSTOP as
  1201.              PTRACE_ATTACH brings it to a halt.  */
  1202.           lp->signalled = 1;

  1204.           /* We need to wait for a stop before being able to make the
  1205.              next ptrace call on this LWP.  */
  1206.           lp->must_set_ptrace_flags = 1;
  1207.         }

  1209.       return 1;
  1210.     }
  1211.   return 0;
  1212. }

  1214. static void
  1215. ‌linux_nat_attach (struct target_ops *ops, const char *args, int from_tty)
  1216. {
  1217.   struct lwp_info *lp;
  1218.   int status;
  1219.   ptid_t ptid;
  1220.   volatile struct gdb_exception ex;

  1222.   /* Make sure we report all signals during attach.  */
  1223.   linux_nat_pass_signals (ops, 0, NULL);

  1225.   TRY_CATCH (ex, RETURN_MASK_ERROR)
  1226.     {
  1227.       linux_ops->to_attach (ops, args, from_tty);
  1228.     }
  1229.   if (ex.reason < 0)
  1230.     {
  1231.       pid_t pid = parse_pid_to_attach (args);
  1232.       struct buffer buffer;
  1233.       char *message, *buffer_s;

  1235.       message = xstrdup (ex.message);
  1236.       make_cleanup (xfree, message);

  1238.       buffer_init (&buffer);
  1239.       linux_ptrace_attach_fail_reason (pid, &buffer);

  1241.       buffer_grow_str0 (&buffer, "");
  1242.       buffer_s = buffer_finish (&buffer);
  1243.       make_cleanup (xfree, buffer_s);

  1245.       if (*buffer_s != '\0')
  1246.         throw_error (ex.error, "warning: %s\n%s", buffer_s, message);
  1247.       else
  1248.         throw_error (ex.error, "%s", message);
  1249.     }

  1251.   /* The ptrace base target adds the main thread with (pid,0,0)
  1252.      format.  Decorate it with lwp info.  */
  1253.   ptid = ptid_build (ptid_get_pid (inferior_ptid),
  1254.                      ptid_get_pid (inferior_ptid),
  1255.                      0);
  1256.   thread_change_ptid (inferior_ptid, ptid);

  1258.   /* Add the initial process as the first LWP to the list.  */
  1259.   lp = add_initial_lwp (ptid);

  1261.   status = linux_nat_post_attach_wait (lp->ptid, 1, &lp->cloned,
  1262.                                        &lp->signalled);
  1263.   if (!WIFSTOPPED (status))
  1264.     {
  1265.       if (WIFEXITED (status))
  1266.         {
  1267.           int exit_code = WEXITSTATUS (status);

  1269.           target_terminal_ours ();
  1270.           target_mourn_inferior ();
  1271.           if (exit_code == 0)
  1272.             error (_("Unable to attach: program exited normally."));
  1273.           else
  1274.             error (_("Unable to attach: program exited with code %d."),
  1275.                    exit_code);
  1276.         }
  1277.       else if (WIFSIGNALED (status))
  1278.         {
  1279.           enum gdb_signal signo;

  1281.           target_terminal_ours ();
  1282.           target_mourn_inferior ();

  1284.           signo = gdb_signal_from_host (WTERMSIG (status));
  1285.           error (_("Unable to attach: program terminated with signal "
  1286.                    "%s, %s."),
  1287.                  gdb_signal_to_name (signo),
  1288.                  gdb_signal_to_string (signo));
  1289.         }

  1291.       internal_error (__FILE__, __LINE__,
  1292.                       _("unexpected status %d for PID %ld"),
  1293.                       status, (long) ptid_get_lwp (ptid));
  1294.     }

  1296.   lp->stopped = 1;

  1298.   /* Save the wait status to report later.  */
  1299.   lp->resumed = 1;
  1300.   if (debug_linux_nat)
  1301.     fprintf_unfiltered (gdb_stdlog,
  1302.                         "LNA: waitpid %ld, saving status %s\n",
  1303.                         (long) ptid_get_pid (lp->ptid), status_to_str (status));

  1305.   lp->status = status;

  1307.   /* We must attach to every LWP.  If /proc is mounted, use that to
  1308.      find them now.  The inferior may be using raw clone instead of
  1309.      using pthreads.  But even if it is using pthreads, thread_db
  1310.      walks structures in the inferior's address space to find the list
  1311.      of threads/LWPs, and those structures may well be corrupted.
  1312.      Note that once thread_db is loaded, we'll still use it to list
  1313.      threads and associate pthread info with each LWP.  */
  1314.   linux_proc_attach_tgid_threads (ptid_get_pid (lp->ptid),
  1315.                                   attach_proc_task_lwp_callback);

  1317.   if (target_can_async_p ())
  1318.     target_async (inferior_event_handler, 0);
  1319. }

  1321. /* Get pending status of LP.  */
  1322. static int
  1323. ‌get_pending_status (struct lwp_info *lp, int *status)
  1324. {
  1325.   enum gdb_signal signo = GDB_SIGNAL_0;

  1327.   /* If we paused threads momentarily, we may have stored pending
  1328.      events in lp->status or lp->waitstatus (see stop_wait_callback),
  1329.      and GDB core hasn't seen any signal for those threads.
  1330.      Otherwise, the last signal reported to the core is found in the
  1331.      thread object's stop_signal.

  1333.      There's a corner case that isn't handled here at present.  Only
  1334.      if the thread stopped with a TARGET_WAITKIND_STOPPED does
  1335.      stop_signal make sense as a real signal to pass to the inferior.
  1336.      Some catchpoint related events, like
  1337.      TARGET_WAITKIND_(V)FORK|EXEC|SYSCALL, have their stop_signal set
  1338.      to GDB_SIGNAL_SIGTRAP when the catchpoint triggers.  But,
  1339.      those traps are debug API (ptrace in our case) related and
  1340.      induced; the inferior wouldn't see them if it wasn't being
  1341.      traced.  Hence, we should never pass them to the inferior, even
  1342.      when set to pass state.  Since this corner case isn't handled by
  1343.      infrun.c when proceeding with a signal, for consistency, neither
  1344.      do we handle it here (or elsewhere in the file we check for
  1345.      signal pass state).  Normally SIGTRAP isn't set to pass state, so
  1346.      this is really a corner case.  */

  1348.   if (lp->waitstatus.kind != TARGET_WAITKIND_IGNORE)
  1349.     signo = GDB_SIGNAL_0; /* a pending ptrace event, not a real signal.  */
  1350.   else if (lp->status)
  1351.     signo = gdb_signal_from_host (WSTOPSIG (lp->status));
  1352.   else if (non_stop && !is_executing (lp->ptid))
  1353.     {
  1354.       struct thread_info *tp = find_thread_ptid (lp->ptid);

  1356.       signo = tp->suspend.stop_signal;
  1357.     }
  1358.   else if (!non_stop)
  1359.     {
  1360.       struct target_waitstatus last;
  1361.       ptid_t last_ptid;

  1363.       get_last_target_status (&last_ptid, &last);

  1365.       if (ptid_get_lwp (lp->ptid) == ptid_get_lwp (last_ptid))
  1366.         {
  1367.           struct thread_info *tp = find_thread_ptid (lp->ptid);

  1369.           signo = tp->suspend.stop_signal;
  1370.         }
  1371.     }

  1373.   *status = 0;

  1375.   if (signo == GDB_SIGNAL_0)
  1376.     {
  1377.       if (debug_linux_nat)
  1378.         fprintf_unfiltered (gdb_stdlog,
  1379.                             "GPT: lwp %s has no pending signal\n",
  1380.                             target_pid_to_str (lp->ptid));
  1381.     }
  1382.   else if (!signal_pass_state (signo))
  1383.     {
  1384.       if (debug_linux_nat)
  1385.         fprintf_unfiltered (gdb_stdlog,
  1386.                             "GPT: lwp %s had signal %s, "
  1387.                             "but it is in no pass state\n",
  1388.                             target_pid_to_str (lp->ptid),
  1389.                             gdb_signal_to_string (signo));
  1390.     }
  1391.   else
  1392.     {
  1393.       *status = W_STOPCODE (gdb_signal_to_host (signo));

  1395.       if (debug_linux_nat)
  1396.         fprintf_unfiltered (gdb_stdlog,
  1397.                             "GPT: lwp %s has pending signal %s\n",
  1398.                             target_pid_to_str (lp->ptid),
  1399.                             gdb_signal_to_string (signo));
  1400.     }

  1402.   return 0;
  1403. }

  1405. static int
  1406. ‌detach_callback (struct lwp_info *lp, void *data)
  1407. {
  1408.   gdb_assert (lp->status == 0 || WIFSTOPPED (lp->status));

  1410.   if (debug_linux_nat && lp->status)
  1411.     fprintf_unfiltered (gdb_stdlog, "DC:  Pending %s for %s on detach.\n",
  1412.                         strsignal (WSTOPSIG (lp->status)),
  1413.                         target_pid_to_str (lp->ptid));

  1415.   /* If there is a pending SIGSTOP, get rid of it.  */
  1416.   if (lp->signalled)
  1417.     {
  1418.       if (debug_linux_nat)
  1419.         fprintf_unfiltered (gdb_stdlog,
  1420.                             "DC: Sending SIGCONT to %s\n",
  1421.                             target_pid_to_str (lp->ptid));

  1423.       kill_lwp (ptid_get_lwp (lp->ptid), SIGCONT);
  1424.       lp->signalled = 0;
  1425.     }

  1427.   /* We don't actually detach from the LWP that has an id equal to the
  1428.      overall process id just yet.  */
  1429.   if (ptid_get_lwp (lp->ptid) != ptid_get_pid (lp->ptid))
  1430.     {
  1431.       int status = 0;

  1433.       /* Pass on any pending signal for this LWP.  */
  1434.       get_pending_status (lp, &status);

  1436.       if (linux_nat_prepare_to_resume != NULL)
  1437.         linux_nat_prepare_to_resume (lp);
  1438.       errno = 0;
  1439.       if (ptrace (PTRACE_DETACH, ptid_get_lwp (lp->ptid), 0,
  1440.                   WSTOPSIG (status)) < 0)
  1441.         error (_("Can't detach %s: %s"), target_pid_to_str (lp->ptid),
  1442.                safe_strerror (errno));

  1444.       if (debug_linux_nat)
  1445.         fprintf_unfiltered (gdb_stdlog,
  1446.                             "PTRACE_DETACH (%s, %s, 0) (OK)\n",
  1447.                             target_pid_to_str (lp->ptid),
  1448.                             strsignal (WSTOPSIG (status)));

  1450.       delete_lwp (lp->ptid);
  1451.     }

  1453.   return 0;
  1454. }

  1456. static void
  1457. ‌linux_nat_detach (struct target_ops *ops, const char *args, int from_tty)
  1458. {
  1459.   int pid;
  1460.   int status;
  1461.   struct lwp_info *main_lwp;

  1463.   pid = ptid_get_pid (inferior_ptid);

  1465.   /* Don't unregister from the event loop, as there may be other
  1466.      inferiors running. */

  1468.   /* Stop all threads before detaching.  ptrace requires that the
  1469.      thread is stopped to sucessfully detach.  */
  1470.   iterate_over_lwps (pid_to_ptid (pid), stop_callback, NULL);
  1471.   /* ... and wait until all of them have reported back that
  1472.      they're no longer running.  */
  1473.   iterate_over_lwps (pid_to_ptid (pid), stop_wait_callback, NULL);

  1475.   iterate_over_lwps (pid_to_ptid (pid), detach_callback, NULL);

  1477.   /* Only the initial process should be left right now.  */
  1478.   gdb_assert (num_lwps (ptid_get_pid (inferior_ptid)) == 1);

  1480.   main_lwp = find_lwp_pid (pid_to_ptid (pid));

  1482.   /* Pass on any pending signal for the last LWP.  */
  1483.   if ((args == NULL || *args == '\0')
  1484.       && get_pending_status (main_lwp, &status) != -1
  1485.       && WIFSTOPPED (status))
  1486.     {
  1487.       char *tem;

  1489.       /* Put the signal number in ARGS so that inf_ptrace_detach will
  1490.          pass it along with PTRACE_DETACH.  */
  1491.       tem = alloca (8);
  1492.       xsnprintf (tem, 8, "%d", (int) WSTOPSIG (status));
  1493.       args = tem;
  1494.       if (debug_linux_nat)
  1495.         fprintf_unfiltered (gdb_stdlog,
  1496.                             "LND: Sending signal %s to %s\n",
  1497.                             args,
  1498.                             target_pid_to_str (main_lwp->ptid));
  1499.     }

  1501.   if (linux_nat_prepare_to_resume != NULL)
  1502.     linux_nat_prepare_to_resume (main_lwp);
  1503.   delete_lwp (main_lwp->ptid);

  1505.   if (forks_exist_p ())
  1506.     {
  1507.       /* Multi-fork case.  The current inferior_ptid is being detached
  1508.          from, but there are other viable forks to debug.  Detach from
  1509.          the current fork, and context-switch to the first
  1510.          available.  */
  1511.       linux_fork_detach (args, from_tty);
  1512.     }
  1513.   else
  1514.     linux_ops->to_detach (ops, args, from_tty);
  1515. }

  1517. /* Resume execution of the inferior process.  If STEP is nonzero,
  1518.    single-step it.  If SIGNAL is nonzero, give it that signal.  */

  1520. static void
  1521. ‌linux_resume_one_lwp (struct lwp_info *lp, int step, enum gdb_signal signo)
  1522. {
  1523.   ptid_t ptid;

  1525.   lp->step = step;

  1527.   /* stop_pc doubles as the PC the LWP had when it was last resumed.
  1528.      We only presently need that if the LWP is stepped though (to
  1529.      handle the case of stepping a breakpoint instruction).  */
  1530.   if (step)
  1531.     {
  1532.       struct regcache *regcache = get_thread_regcache (lp->ptid);

  1534.       lp->stop_pc = regcache_read_pc (regcache);
  1535.     }
  1536.   else
  1537.     lp->stop_pc = 0;

  1539.   if (linux_nat_prepare_to_resume != NULL)
  1540.     linux_nat_prepare_to_resume (lp);
  1541.   /* Convert to something the lower layer understands.  */
  1542.   ptid = pid_to_ptid (ptid_get_lwp (lp->ptid));
  1543.   linux_ops->to_resume (linux_ops, ptid, step, signo);
  1544.   lp->stop_reason = LWP_STOPPED_BY_NO_REASON;
  1545.   lp->stopped = 0;
  1546.   registers_changed_ptid (lp->ptid);
  1547. }

  1549. /* Resume LP.  */

  1551. static void
  1552. ‌resume_lwp (struct lwp_info *lp, int step, enum gdb_signal signo)
  1553. {
  1554.   if (lp->stopped)
  1555.     {
  1556.       struct inferior *inf = find_inferior_ptid (lp->ptid);

  1558.       if (inf->vfork_child != NULL)
  1559.         {
  1560.           if (debug_linux_nat)
  1561.             fprintf_unfiltered (gdb_stdlog,
  1562.                                 "RC: Not resuming %s (vfork parent)\n",
  1563.                                 target_pid_to_str (lp->ptid));
  1564.         }
  1565.       else if (!lwp_status_pending_p (lp))
  1566.         {
  1567.           if (debug_linux_nat)
  1568.             fprintf_unfiltered (gdb_stdlog,
  1569.                                 "RC: Resuming sibling %s, %s, %s\n",
  1570.                                 target_pid_to_str (lp->ptid),
  1571.                                 (signo != GDB_SIGNAL_0
  1572.                                  ? strsignal (gdb_signal_to_host (signo))
  1573.                                  : "0"),
  1574.                                 step ? "step" : "resume");

  1576.           linux_resume_one_lwp (lp, step, signo);
  1577.         }
  1578.       else
  1579.         {
  1580.           if (debug_linux_nat)
  1581.             fprintf_unfiltered (gdb_stdlog,
  1582.                                 "RC: Not resuming sibling %s (has pending)\n",
  1583.                                 target_pid_to_str (lp->ptid));
  1584.         }
  1585.     }
  1586.   else
  1587.     {
  1588.       if (debug_linux_nat)
  1589.         fprintf_unfiltered (gdb_stdlog,
  1590.                             "RC: Not resuming sibling %s (not stopped)\n",
  1591.                             target_pid_to_str (lp->ptid));
  1592.     }
  1593. }

  1595. /* Callback for iterate_over_lwps.  If LWP is EXCEPT, do nothing.
  1596.    Resume LWP with the last stop signal, if it is in pass state.  */

  1598. static int
  1599. ‌linux_nat_resume_callback (struct lwp_info *lp, void *except)
  1600. {
  1601.   enum gdb_signal signo = GDB_SIGNAL_0;

  1603.   if (lp == except)
  1604.     return 0;

  1606.   if (lp->stopped)
  1607.     {
  1608.       struct thread_info *thread;

  1610.       thread = find_thread_ptid (lp->ptid);
  1611.       if (thread != NULL)
  1612.         {
  1613.           signo = thread->suspend.stop_signal;
  1614.           thread->suspend.stop_signal = GDB_SIGNAL_0;
  1615.         }
  1616.     }

  1618.   resume_lwp (lp, 0, signo);
  1619.   return 0;
  1620. }

  1622. static int
  1623. ‌resume_clear_callback (struct lwp_info *lp, void *data)
  1624. {
  1625.   lp->resumed = 0;
  1626.   lp->last_resume_kind = resume_stop;
  1627.   return 0;
  1628. }

  1630. static int
  1631. ‌resume_set_callback (struct lwp_info *lp, void *data)
  1632. {
  1633.   lp->resumed = 1;
  1634.   lp->last_resume_kind = resume_continue;
  1635.   return 0;
  1636. }

  1638. static void
  1639. ‌linux_nat_resume (struct target_ops *ops,
  1640.                   ptid_t ptid, int step, enum gdb_signal signo)
  1641. {
  1642.   struct lwp_info *lp;
  1643.   int resume_many;

  1645.   if (debug_linux_nat)
  1646.     fprintf_unfiltered (gdb_stdlog,
  1647.                         "LLR: Preparing to %s %s, %s, inferior_ptid %s\n",
  1648.                         step ? "step" : "resume",
  1649.                         target_pid_to_str (ptid),
  1650.                         (signo != GDB_SIGNAL_0
  1651.                          ? strsignal (gdb_signal_to_host (signo)) : "0"),
  1652.                         target_pid_to_str (inferior_ptid));

  1654.   /* A specific PTID means `step only this process id'.  */
  1655.   resume_many = (ptid_equal (minus_one_ptid, ptid)
  1656.                  || ptid_is_pid (ptid));

  1658.   /* Mark the lwps we're resuming as resumed.  */
  1659.   iterate_over_lwps (ptid, resume_set_callback, NULL);

  1661.   /* See if it's the current inferior that should be handled
  1662.      specially.  */
  1663.   if (resume_many)
  1664.     lp = find_lwp_pid (inferior_ptid);
  1665.   else
  1666.     lp = find_lwp_pid (ptid);
  1667.   gdb_assert (lp != NULL);

  1669.   /* Remember if we're stepping.  */
  1670.   lp->last_resume_kind = step ? resume_step : resume_continue;

  1672.   /* If we have a pending wait status for this thread, there is no
  1673.      point in resuming the process.  But first make sure that
  1674.      linux_nat_wait won't preemptively handle the event - we
  1675.      should never take this short-circuit if we are going to
  1676.      leave LP running, since we have skipped resuming all the
  1677.      other threads.  This bit of code needs to be synchronized
  1678.      with linux_nat_wait.  */

  1680.   if (lp->status && WIFSTOPPED (lp->status))
  1681.     {
  1682.       if (!lp->step
  1683.           && WSTOPSIG (lp->status)
  1684.           && sigismember (&pass_mask, WSTOPSIG (lp->status)))
  1685.         {
  1686.           if (debug_linux_nat)
  1687.             fprintf_unfiltered (gdb_stdlog,
  1688.                                 "LLR: Not short circuiting for ignored "
  1689.                                 "status 0x%x\n", lp->status);

  1691.           /* FIXME: What should we do if we are supposed to continue
  1692.              this thread with a signal?  */
  1693.           gdb_assert (signo == GDB_SIGNAL_0);
  1694.           signo = gdb_signal_from_host (WSTOPSIG (lp->status));
  1695.           lp->status = 0;
  1696.         }
  1697.     }

  1699.   if (lwp_status_pending_p (lp))
  1700.     {
  1701.       /* FIXME: What should we do if we are supposed to continue
  1702.          this thread with a signal?  */
  1703.       gdb_assert (signo == GDB_SIGNAL_0);

  1705.       if (debug_linux_nat)
  1706.         fprintf_unfiltered (gdb_stdlog,
  1707.                             "LLR: Short circuiting for status 0x%x\n",
  1708.                             lp->status);

  1710.       if (target_can_async_p ())
  1711.         {
  1712.           target_async (inferior_event_handler, 0);
  1713.           /* Tell the event loop we have something to process.  */
  1714.           async_file_mark ();
  1715.         }
  1716.       return;
  1717.     }

  1719.   if (resume_many)
  1720.     iterate_over_lwps (ptid, linux_nat_resume_callback, lp);

  1722.   linux_resume_one_lwp (lp, step, signo);

  1724.   if (debug_linux_nat)
  1725.     fprintf_unfiltered (gdb_stdlog,
  1726.                         "LLR: %s %s, %s (resume event thread)\n",
  1727.                         step ? "PTRACE_SINGLESTEP" : "PTRACE_CONT",
  1728.                         target_pid_to_str (ptid),
  1729.                         (signo != GDB_SIGNAL_0
  1730.                          ? strsignal (gdb_signal_to_host (signo)) : "0"));

  1732.   if (target_can_async_p ())
  1733.     target_async (inferior_event_handler, 0);
  1734. }

  1736. /* Send a signal to an LWP.  */

  1738. static int
  1739. ‌kill_lwp (int lwpid, int signo)
  1740. {
  1741.   /* Use tkill, if possible, in case we are using nptl threads.  If tkill
  1742.      fails, then we are not using nptl threads and we should be using kill.  */

  1744. #ifdef HAVE_TKILL_SYSCALL
  1745.   {
  1746.     static int tkill_failed;

  1748.     if (!tkill_failed)
  1749.       {
  1750.         int ret;

  1752.         errno = 0;
  1753.         ret = syscall (__NR_tkill, lwpid, signo);
  1754.         if (errno != ENOSYS)
  1755.           return ret;
  1756.         tkill_failed = 1;
  1757.       }
  1758.   }
  1759. #endif

  1761.   return kill (lwpid, signo);
  1762. }

  1764. /* Handle a GNU/Linux syscall trap wait response.  If we see a syscall
  1765.    event, check if the core is interested in it: if not, ignore the
  1766.    event, and keep waiting; otherwise, we need to toggle the LWP's
  1767.    syscall entry/exit status, since the ptrace event itself doesn't
  1768.    indicate it, and report the trap to higher layers.  */

  1770. static int
  1771. ‌linux_handle_syscall_trap (struct lwp_info *lp, int stopping)
  1772. {
  1773.   struct target_waitstatus *ourstatus = &lp->waitstatus;
  1774.   struct gdbarch *gdbarch = target_thread_architecture (lp->ptid);
  1775.   int syscall_number = (int) gdbarch_get_syscall_number (gdbarch, lp->ptid);

  1777.   if (stopping)
  1778.     {
  1779.       /* If we're stopping threads, there's a SIGSTOP pending, which
  1780.          makes it so that the LWP reports an immediate syscall return,
  1781.          followed by the SIGSTOP.  Skip seeing that "return" using
  1782.          PTRACE_CONT directly, and let stop_wait_callback collect the
  1783.          SIGSTOP.  Later when the thread is resumed, a new syscall
  1784.          entry event.  If we didn't do this (and returned 0), we'd
  1785.          leave a syscall entry pending, and our caller, by using
  1786.          PTRACE_CONT to collect the SIGSTOP, skips the syscall return
  1787.          itself.  Later, when the user re-resumes this LWP, we'd see
  1788.          another syscall entry event and we'd mistake it for a return.

  1790.          If stop_wait_callback didn't force the SIGSTOP out of the LWP
  1791.          (leaving immediately with LWP->signalled set, without issuing
  1792.          a PTRACE_CONT), it would still be problematic to leave this
  1793.          syscall enter pending, as later when the thread is resumed,
  1794.          it would then see the same syscall exit mentioned above,
  1795.          followed by the delayed SIGSTOP, while the syscall didn't
  1796.          actually get to execute.  It seems it would be even more
  1797.          confusing to the user.  */

  1799.       if (debug_linux_nat)
  1800.         fprintf_unfiltered (gdb_stdlog,
  1801.                             "LHST: ignoring syscall %d "
  1802.                             "for LWP %ld (stopping threads), "
  1803.                             "resuming with PTRACE_CONT for SIGSTOP\n",
  1804.                             syscall_number,
  1805.                             ptid_get_lwp (lp->ptid));

  1807.       lp->syscall_state = TARGET_WAITKIND_IGNORE;
  1808.       ptrace (PTRACE_CONT, ptid_get_lwp (lp->ptid), 0, 0);
  1809.       lp->stopped = 0;
  1810.       return 1;
  1811.     }

  1813.   if (catch_syscall_enabled ())
  1814.     {
  1815.       /* Always update the entry/return state, even if this particular
  1816.          syscall isn't interesting to the core now.  In async mode,
  1817.          the user could install a new catchpoint for this syscall
  1818.          between syscall enter/return, and we'll need to know to
  1819.          report a syscall return if that happens.  */
  1820.       lp->syscall_state = (lp->syscall_state == TARGET_WAITKIND_SYSCALL_ENTRY
  1821.                            ? TARGET_WAITKIND_SYSCALL_RETURN
  1822.                            : TARGET_WAITKIND_SYSCALL_ENTRY);

  1824.       if (catching_syscall_number (syscall_number))
  1825.         {
  1826.           /* Alright, an event to report.  */
  1827.           ourstatus->kind = lp->syscall_state;
  1828.           ourstatus->value.syscall_number = syscall_number;

  1830.           if (debug_linux_nat)
  1831.             fprintf_unfiltered (gdb_stdlog,
  1832.                                 "LHST: stopping for %s of syscall %d"
  1833.                                 " for LWP %ld\n",
  1834.                                 lp->syscall_state
  1835.                                 == TARGET_WAITKIND_SYSCALL_ENTRY
  1836.                                 ? "entry" : "return",
  1837.                                 syscall_number,
  1838.                                 ptid_get_lwp (lp->ptid));
  1839.           return 0;
  1840.         }

  1842.       if (debug_linux_nat)
  1843.         fprintf_unfiltered (gdb_stdlog,
  1844.                             "LHST: ignoring %s of syscall %d "
  1845.                             "for LWP %ld\n",
  1846.                             lp->syscall_state == TARGET_WAITKIND_SYSCALL_ENTRY
  1847.                             ? "entry" : "return",
  1848.                             syscall_number,
  1849.                             ptid_get_lwp (lp->ptid));
  1850.     }
  1851.   else
  1852.     {
  1853.       /* If we had been syscall tracing, and hence used PT_SYSCALL
  1854.          before on this LWP, it could happen that the user removes all
  1855.          syscall catchpoints before we get to process this event.
  1856.          There are two noteworthy issues here:

  1858.          - When stopped at a syscall entry event, resuming with
  1859.            PT_STEP still resumes executing the syscall and reports a
  1860.            syscall return.

  1862.          - Only PT_SYSCALL catches syscall enters.  If we last
  1863.            single-stepped this thread, then this event can't be a
  1864.            syscall enter.  If we last single-stepped this thread, this
  1865.            has to be a syscall exit.

  1867.          The points above mean that the next resume, be it PT_STEP or
  1868.          PT_CONTINUE, can not trigger a syscall trace event.  */
  1869.       if (debug_linux_nat)
  1870.         fprintf_unfiltered (gdb_stdlog,
  1871.                             "LHST: caught syscall event "
  1872.                             "with no syscall catchpoints."
  1873.                             " %d for LWP %ld, ignoring\n",
  1874.                             syscall_number,
  1875.                             ptid_get_lwp (lp->ptid));
  1876.       lp->syscall_state = TARGET_WAITKIND_IGNORE;
  1877.     }

  1879.   /* The core isn't interested in this event.  For efficiency, avoid
  1880.      stopping all threads only to have the core resume them all again.
  1881.      Since we're not stopping threads, if we're still syscall tracing
  1882.      and not stepping, we can't use PTRACE_CONT here, as we'd miss any
  1883.      subsequent syscall.  Simply resume using the inf-ptrace layer,
  1884.      which knows when to use PT_SYSCALL or PT_CONTINUE.  */

  1886.   linux_resume_one_lwp (lp, lp->step, GDB_SIGNAL_0);
  1887.   return 1;
  1888. }

  1890. /* Handle a GNU/Linux extended wait response.  If we see a clone
  1891.    event, we need to add the new LWP to our list (and not report the
  1892.    trap to higher layers).  This function returns non-zero if the
  1893.    event should be ignored and we should wait again.  If STOPPING is
  1894.    true, the new LWP remains stopped, otherwise it is continued.  */

  1896. static int
  1897. ‌linux_handle_extended_wait (struct lwp_info *lp, int status,
  1898.                             int stopping)
  1899. {
  1900.   int pid = ptid_get_lwp (lp->ptid);
  1901.   struct target_waitstatus *ourstatus = &lp->waitstatus;
  1902.   int event = linux_ptrace_get_extended_event (status);

  1904.   if (event == PTRACE_EVENT_FORK || event == PTRACE_EVENT_VFORK
  1905.       || event == PTRACE_EVENT_CLONE)
  1906.     {
  1907.       unsigned long new_pid;
  1908.       int ret;

  1910.       ptrace (PTRACE_GETEVENTMSG, pid, 0, &new_pid);

  1912.       /* If we haven't already seen the new PID stop, wait for it now.  */
  1913.       if (! pull_pid_from_list (&stopped_pids, new_pid, &status))
  1914.         {
  1915.           /* The new child has a pending SIGSTOP.  We can't affect it until it
  1916.              hits the SIGSTOP, but we're already attached.  */
  1917.           ret = my_waitpid (new_pid, &status,
  1918.                             (event == PTRACE_EVENT_CLONE) ? __WCLONE : 0);
  1919.           if (ret == -1)
  1920.             perror_with_name (_("waiting for new child"));
  1921.           else if (ret != new_pid)
  1922.             internal_error (__FILE__, __LINE__,
  1923.                             _("wait returned unexpected PID %d"), ret);
  1924.           else if (!WIFSTOPPED (status))
  1925.             internal_error (__FILE__, __LINE__,
  1926.                             _("wait returned unexpected status 0x%x"), status);
  1927.         }

  1929.       ourstatus->value.related_pid = ptid_build (new_pid, new_pid, 0);

  1931.       if (event == PTRACE_EVENT_FORK || event == PTRACE_EVENT_VFORK)
  1932.         {
  1933.           /* The arch-specific native code may need to know about new
  1934.              forks even if those end up never mapped to an
  1935.              inferior.  */
  1936.           if (linux_nat_new_fork != NULL)
  1937.             linux_nat_new_fork (lp, new_pid);
  1938.         }

  1940.       if (event == PTRACE_EVENT_FORK
  1941.           && linux_fork_checkpointing_p (ptid_get_pid (lp->ptid)))
  1942.         {
  1943.           /* Handle checkpointing by linux-fork.c here as a special
  1944.              case.  We don't want the follow-fork-mode or 'catch fork'
  1945.              to interfere with this.  */

  1947.           /* This won't actually modify the breakpoint list, but will
  1948.              physically remove the breakpoints from the child.  */
  1949.           detach_breakpoints (ptid_build (new_pid, new_pid, 0));

  1951.           /* Retain child fork in ptrace (stopped) state.  */
  1952.           if (!find_fork_pid (new_pid))
  1953.             add_fork (new_pid);

  1955.           /* Report as spurious, so that infrun doesn't want to follow
  1956.              this fork.  We're actually doing an infcall in
  1957.              linux-fork.c.  */
  1958.           ourstatus->kind = TARGET_WAITKIND_SPURIOUS;

  1960.           /* Report the stop to the core.  */
  1961.           return 0;
  1962.         }

  1964.       if (event == PTRACE_EVENT_FORK)
  1965.         ourstatus->kind = TARGET_WAITKIND_FORKED;
  1966.       else if (event == PTRACE_EVENT_VFORK)
  1967.         ourstatus->kind = TARGET_WAITKIND_VFORKED;
  1968.       else
  1969.         {
  1970.           struct lwp_info *new_lp;

  1972.           ourstatus->kind = TARGET_WAITKIND_IGNORE;

  1974.           if (debug_linux_nat)
  1975.             fprintf_unfiltered (gdb_stdlog,
  1976.                                 "LHEW: Got clone event "
  1977.                                 "from LWP %d, new child is LWP %ld\n",
  1978.                                 pid, new_pid);

  1980.           new_lp = add_lwp (ptid_build (ptid_get_pid (lp->ptid), new_pid, 0));
  1981.           new_lp->cloned = 1;
  1982.           new_lp->stopped = 1;

  1984.           if (WSTOPSIG (status) != SIGSTOP)
  1985.             {
  1986.               /* This can happen if someone starts sending signals to
  1987.                  the new thread before it gets a chance to run, which
  1988.                  have a lower number than SIGSTOP (e.g. SIGUSR1).
  1989.                  This is an unlikely case, and harder to handle for
  1990.                  fork / vfork than for clone, so we do not try - but
  1991.                  we handle it for clone events here.  We'll send
  1992.                  the other signal on to the thread below.  */

  1994.               new_lp->signalled = 1;
  1995.             }
  1996.           else
  1997.             {
  1998.               struct thread_info *tp;

  2000.               /* When we stop for an event in some other thread, and
  2001.                  pull the thread list just as this thread has cloned,
  2002.                  we'll have seen the new thread in the thread_db list
  2003.                  before handling the CLONE event (glibc's
  2004.                  pthread_create adds the new thread to the thread list
  2005.                  before clone'ing, and has the kernel fill in the
  2006.                  thread's tid on the clone call with
  2007.                  CLONE_PARENT_SETTID).  If that happened, and the core
  2008.                  had requested the new thread to stop, we'll have
  2009.                  killed it with SIGSTOP.  But since SIGSTOP is not an
  2010.                  RT signal, it can only be queued once.  We need to be
  2011.                  careful to not resume the LWP if we wanted it to
  2012.                  stop.  In that case, we'll leave the SIGSTOP pending.
  2013.                  It will later be reported as GDB_SIGNAL_0.  */
  2014.               tp = find_thread_ptid (new_lp->ptid);
  2015.               if (tp != NULL && tp->stop_requested)
  2016.                 new_lp->last_resume_kind = resume_stop;
  2017.               else
  2018.                 status = 0;
  2019.             }

  2021.           if (non_stop)
  2022.             {
  2023.               /* Add the new thread to GDB's lists as soon as possible
  2024.                  so that:

  2026.                  1) the frontend doesn't have to wait for a stop to
  2027.                  display them, and,

  2029.                  2) we tag it with the correct running state.  */

  2031.               /* If the thread_db layer is active, let it know about
  2032.                  this new thread, and add it to GDB's list.  */
  2033.               if (!thread_db_attach_lwp (new_lp->ptid))
  2034.                 {
  2035.                   /* We're not using thread_db.  Add it to GDB's
  2036.                      list.  */
  2037.                   target_post_attach (ptid_get_lwp (new_lp->ptid));
  2038.                   add_thread (new_lp->ptid);
  2039.                 }

  2041.               if (!stopping)
  2042.                 {
  2043.                   set_running (new_lp->ptid, 1);
  2044.                   set_executing (new_lp->ptid, 1);
  2045.                   /* thread_db_attach_lwp -> lin_lwp_attach_lwp forced
  2046.                      resume_stop.  */
  2047.                   new_lp->last_resume_kind = resume_continue;
  2048.                 }
  2049.             }

  2051.           if (status != 0)
  2052.             {
  2053.               /* We created NEW_LP so it cannot yet contain STATUS.  */
  2054.               gdb_assert (new_lp->status == 0);

  2056.               /* Save the wait status to report later.  */
  2057.               if (debug_linux_nat)
  2058.                 fprintf_unfiltered (gdb_stdlog,
  2059.                                     "LHEW: waitpid of new LWP %ld, "
  2060.                                     "saving status %s\n",
  2061.                                     (long) ptid_get_lwp (new_lp->ptid),
  2062.                                     status_to_str (status));
  2063.               new_lp->status = status;
  2064.             }

  2066.           /* Note the need to use the low target ops to resume, to
  2067.              handle resuming with PT_SYSCALL if we have syscall
  2068.              catchpoints.  */
  2069.           if (!stopping)
  2070.             {
  2071.               new_lp->resumed = 1;

  2073.               if (status == 0)
  2074.                 {
  2075.                   gdb_assert (new_lp->last_resume_kind == resume_continue);
  2076.                   if (debug_linux_nat)
  2077.                     fprintf_unfiltered (gdb_stdlog,
  2078.                                         "LHEW: resuming new LWP %ld\n",
  2079.                                         ptid_get_lwp (new_lp->ptid));
  2080.                   linux_resume_one_lwp (new_lp, 0, GDB_SIGNAL_0);
  2081.                 }
  2082.             }

  2084.           if (debug_linux_nat)
  2085.             fprintf_unfiltered (gdb_stdlog,
  2086.                                 "LHEW: resuming parent LWP %d\n", pid);
  2087.           linux_resume_one_lwp (lp, 0, GDB_SIGNAL_0);
  2088.           return 1;
  2089.         }

  2091.       return 0;
  2092.     }

  2094.   if (event == PTRACE_EVENT_EXEC)
  2095.     {
  2096.       if (debug_linux_nat)
  2097.         fprintf_unfiltered (gdb_stdlog,
  2098.                             "LHEW: Got exec event from LWP %ld\n",
  2099.                             ptid_get_lwp (lp->ptid));

  2101.       ourstatus->kind = TARGET_WAITKIND_EXECD;
  2102.       ourstatus->value.execd_pathname
  2103.         = xstrdup (linux_child_pid_to_exec_file (NULL, pid));

  2105.       /* The thread that execed must have been resumed, but, when a
  2106.          thread execs, it changes its tid to the tgid, and the old
  2107.          tgid thread might have not been resumed.  */
  2108.       lp->resumed = 1;
  2109.       return 0;
  2110.     }

  2112.   if (event == PTRACE_EVENT_VFORK_DONE)
  2113.     {
  2114.       if (current_inferior ()->waiting_for_vfork_done)
  2115.         {
  2116.           if (debug_linux_nat)
  2117.             fprintf_unfiltered (gdb_stdlog,
  2118.                                 "LHEW: Got expected PTRACE_EVENT_"
  2119.                                 "VFORK_DONE from LWP %ld: stopping\n",
  2120.                                 ptid_get_lwp (lp->ptid));

  2122.           ourstatus->kind = TARGET_WAITKIND_VFORK_DONE;
  2123.           return 0;
  2124.         }

  2126.       if (debug_linux_nat)
  2127.         fprintf_unfiltered (gdb_stdlog,
  2128.                             "LHEW: Got PTRACE_EVENT_VFORK_DONE "
  2129.                             "from LWP %ld: resuming\n",
  2130.                             ptid_get_lwp (lp->ptid));
  2131.       ptrace (PTRACE_CONT, ptid_get_lwp (lp->ptid), 0, 0);
  2132.       return 1;
  2133.     }

  2135.   internal_error (__FILE__, __LINE__,
  2136.                   _("unknown ptrace event %d"), event);
  2137. }

  2139. /* Wait for LP to stop.  Returns the wait status, or 0 if the LWP has
  2140.    exited.  */

  2142. static int
  2143. ‌wait_lwp (struct lwp_info *lp)
  2144. {
  2145.   pid_t pid;
  2146.   int status = 0;
  2147.   int thread_dead = 0;
  2148.   sigset_t prev_mask;

  2150.   gdb_assert (!lp->stopped);
  2151.   gdb_assert (lp->status == 0);

  2153.   /* Make sure SIGCHLD is blocked for sigsuspend avoiding a race below.  */
  2154.   block_child_signals (&prev_mask);

  2156.   for (;;)
  2157.     {
  2158.       /* If my_waitpid returns 0 it means the __WCLONE vs. non-__WCLONE kind
  2159.          was right and we should just call sigsuspend.  */

  2161.       pid = my_waitpid (ptid_get_lwp (lp->ptid), &status, WNOHANG);
  2162.       if (pid == -1 && errno == ECHILD)
  2163.         pid = my_waitpid (ptid_get_lwp (lp->ptid), &status, __WCLONE | WNOHANG);
  2164.       if (pid == -1 && errno == ECHILD)
  2165.         {
  2166.           /* The thread has previously exited.  We need to delete it
  2167.              now because, for some vendor 2.4 kernels with NPTL
  2168.              support backported, there won't be an exit event unless
  2169.              it is the main thread.  2.6 kernels will report an exit
  2170.              event for each thread that exits, as expected.  */
  2171.           thread_dead = 1;
  2172.           if (debug_linux_nat)
  2173.             fprintf_unfiltered (gdb_stdlog, "WL: %s vanished.\n",
  2174.                                 target_pid_to_str (lp->ptid));
  2175.         }
  2176.       if (pid != 0)
  2177.         break;

  2179.       /* Bugs 10970, 12702.
  2180.          Thread group leader may have exited in which case we'll lock up in
  2181.          waitpid if there are other threads, even if they are all zombies too.
  2182.          Basically, we're not supposed to use waitpid this way.
  2183.          __WCLONE is not applicable for the leader so we can't use that.
  2184.          LINUX_NAT_THREAD_ALIVE cannot be used here as it requires a STOPPED
  2185.          process; it gets ESRCH both for the zombie and for running processes.

  2187.          As a workaround, check if we're waiting for the thread group leader and
  2188.          if it's a zombie, and avoid calling waitpid if it is.

  2190.          This is racy, what if the tgl becomes a zombie right after we check?
  2191.          Therefore always use WNOHANG with sigsuspend - it is equivalent to
  2192.          waiting waitpid but linux_proc_pid_is_zombie is safe this way.  */

  2194.       if (ptid_get_pid (lp->ptid) == ptid_get_lwp (lp->ptid)
  2195.           && linux_proc_pid_is_zombie (ptid_get_lwp (lp->ptid)))
  2196.         {
  2197.           thread_dead = 1;
  2198.           if (debug_linux_nat)
  2199.             fprintf_unfiltered (gdb_stdlog,
  2200.                                 "WL: Thread group leader %s vanished.\n",
  2201.                                 target_pid_to_str (lp->ptid));
  2202.           break;
  2203.         }

  2205.       /* Wait for next SIGCHLD and try again.  This may let SIGCHLD handlers
  2206.          get invoked despite our caller had them intentionally blocked by
  2207.          block_child_signals.  This is sensitive only to the loop of
  2208.          linux_nat_wait_1 and there if we get called my_waitpid gets called
  2209.          again before it gets to sigsuspend so we can safely let the handlers
  2210.          get executed here.  */

  2212.       if (debug_linux_nat)
  2213.         fprintf_unfiltered (gdb_stdlog, "WL: about to sigsuspend\n");
  2214.       sigsuspend (&suspend_mask);
  2215.     }

  2217.   restore_child_signals_mask (&prev_mask);

  2219.   if (!thread_dead)
  2220.     {
  2221.       gdb_assert (pid == ptid_get_lwp (lp->ptid));

  2223.       if (debug_linux_nat)
  2224.         {
  2225.           fprintf_unfiltered (gdb_stdlog,
  2226.                               "WL: waitpid %s received %s\n",
  2227.                               target_pid_to_str (lp->ptid),
  2228.                               status_to_str (status));
  2229.         }

  2231.       /* Check if the thread has exited.  */
  2232.       if (WIFEXITED (status) || WIFSIGNALED (status))
  2233.         {
  2234.           thread_dead = 1;
  2235.           if (debug_linux_nat)
  2236.             fprintf_unfiltered (gdb_stdlog, "WL: %s exited.\n",
  2237.                                 target_pid_to_str (lp->ptid));
  2238.         }
  2239.     }

  2241.   if (thread_dead)
  2242.     {
  2243.       exit_lwp (lp);
  2244.       return 0;
  2245.     }

  2247.   gdb_assert (WIFSTOPPED (status));
  2248.   lp->stopped = 1;

  2250.   if (lp->must_set_ptrace_flags)
  2251.     {
  2252.       struct inferior *inf = find_inferior_pid (ptid_get_pid (lp->ptid));

  2254.       linux_enable_event_reporting (ptid_get_lwp (lp->ptid), inf->attach_flag);
  2255.       lp->must_set_ptrace_flags = 0;
  2256.     }

  2258.   /* Handle GNU/Linux's syscall SIGTRAPs.  */
  2259.   if (WIFSTOPPED (status) && WSTOPSIG (status) == SYSCALL_SIGTRAP)
  2260.     {
  2261.       /* No longer need the sysgood bit.  The ptrace event ends up
  2262.          recorded in lp->waitstatus if we care for it.  We can carry
  2263.          on handling the event like a regular SIGTRAP from here
  2264.          on.  */
  2265.       status = W_STOPCODE (SIGTRAP);
  2266.       if (linux_handle_syscall_trap (lp, 1))
  2267.         return wait_lwp (lp);
  2268.     }

  2270.   /* Handle GNU/Linux's extended waitstatus for trace events.  */
  2271.   if (WIFSTOPPED (status) && WSTOPSIG (status) == SIGTRAP
  2272.       && linux_is_extended_waitstatus (status))
  2273.     {
  2274.       if (debug_linux_nat)
  2275.         fprintf_unfiltered (gdb_stdlog,
  2276.                             "WL: Handling extended status 0x%06x\n",
  2277.                             status);
  2278.       if (linux_handle_extended_wait (lp, status, 1))
  2279.         return wait_lwp (lp);
  2280.     }

  2282.   return status;
  2283. }

  2285. /* Send a SIGSTOP to LP.  */

  2287. static int
  2288. ‌stop_callback (struct lwp_info *lp, void *data)
  2289. {
  2290.   if (!lp->stopped && !lp->signalled)
  2291.     {
  2292.       int ret;

  2294.       if (debug_linux_nat)
  2295.         {
  2296.           fprintf_unfiltered (gdb_stdlog,
  2297.                               "SC:  kill %s **<SIGSTOP>**\n",
  2298.                               target_pid_to_str (lp->ptid));
  2299.         }
  2300.       errno = 0;
  2301.       ret = kill_lwp (ptid_get_lwp (lp->ptid), SIGSTOP);
  2302.       if (debug_linux_nat)
  2303.         {
  2304.           fprintf_unfiltered (gdb_stdlog,
  2305.                               "SC:  lwp kill %d %s\n",
  2306.                               ret,
  2307.                               errno ? safe_strerror (errno) : "ERRNO-OK");
  2308.         }

  2310.       lp->signalled = 1;
  2311.       gdb_assert (lp->status == 0);
  2312.     }

  2314.   return 0;
  2315. }

  2317. /* Request a stop on LWP.  */

  2319. void
  2320. ‌linux_stop_lwp (struct lwp_info *lwp)
  2321. {
  2322.   stop_callback (lwp, NULL);
  2323. }

  2325. /* Return non-zero if LWP PID has a pending SIGINT.  */

  2327. static int
  2328. ‌linux_nat_has_pending_sigint (int pid)
  2329. {
  2330.   sigset_t pending, blocked, ignored;

  2332.   linux_proc_pending_signals (pid, &pending, &blocked, &ignored);

  2334.   if (sigismember (&pending, SIGINT)
  2335.       && !sigismember (&ignored, SIGINT))
  2336.     return 1;

  2338.   return 0;
  2339. }

  2341. /* Set a flag in LP indicating that we should ignore its next SIGINT.  */

  2343. static int
  2344. ‌set_ignore_sigint (struct lwp_info *lp, void *data)
  2345. {
  2346.   /* If a thread has a pending SIGINT, consume it; otherwise, set a
  2347.      flag to consume the next one.  */
  2348.   if (lp->stopped && lp->status != 0 && WIFSTOPPED (lp->status)
  2349.       && WSTOPSIG (lp->status) == SIGINT)
  2350.     lp->status = 0;
  2351.   else
  2352.     lp->ignore_sigint = 1;

  2354.   return 0;
  2355. }

  2357. /* If LP does not have a SIGINT pending, then clear the ignore_sigint flag.
  2358.    This function is called after we know the LWP has stopped; if the LWP
  2359.    stopped before the expected SIGINT was delivered, then it will never have
  2360.    arrived.  Also, if the signal was delivered to a shared queue and consumed
  2361.    by a different thread, it will never be delivered to this LWP.  */

  2363. static void
  2364. ‌maybe_clear_ignore_sigint (struct lwp_info *lp)
  2365. {
  2366.   if (!lp->ignore_sigint)
  2367.     return;

  2369.   if (!linux_nat_has_pending_sigint (ptid_get_lwp (lp->ptid)))
  2370.     {
  2371.       if (debug_linux_nat)
  2372.         fprintf_unfiltered (gdb_stdlog,
  2373.                             "MCIS: Clearing bogus flag for %s\n",
  2374.                             target_pid_to_str (lp->ptid));
  2375.       lp->ignore_sigint = 0;
  2376.     }
  2377. }

  2379. /* Fetch the possible triggered data watchpoint info and store it in
  2380.    LP.

  2382.    On some archs, like x86, that use debug registers to set
  2383.    watchpoints, it's possible that the way to know which watched
  2384.    address trapped, is to check the register that is used to select
  2385.    which address to watch.  Problem is, between setting the watchpoint
  2386.    and reading back which data address trapped, the user may change
  2387.    the set of watchpoints, and, as a consequence, GDB changes the
  2388.    debug registers in the inferior.  To avoid reading back a stale
  2389.    stopped-data-address when that happens, we cache in LP the fact
  2390.    that a watchpoint trapped, and the corresponding data address, as
  2391.    soon as we see LP stop with a SIGTRAP.  If GDB changes the debug
  2392.    registers meanwhile, we have the cached data we can rely on.  */

  2394. static int
  2395. ‌check_stopped_by_watchpoint (struct lwp_info *lp)
  2396. {
  2397.   struct cleanup *old_chain;

  2399.   if (linux_ops->to_stopped_by_watchpoint == NULL)
  2400.     return 0;

  2402.   old_chain = save_inferior_ptid ();
  2403.   inferior_ptid = lp->ptid;

  2405.   if (linux_ops->to_stopped_by_watchpoint (linux_ops))
  2406.     {
  2407.       lp->stop_reason = LWP_STOPPED_BY_WATCHPOINT;

  2409.       if (linux_ops->to_stopped_data_address != NULL)
  2410.         lp->stopped_data_address_p =
  2411.           linux_ops->to_stopped_data_address (&current_target,
  2412.                                               &lp->stopped_data_address);
  2413.       else
  2414.         lp->stopped_data_address_p = 0;
  2415.     }

  2417.   do_cleanups (old_chain);

  2419.   return lp->stop_reason == LWP_STOPPED_BY_WATCHPOINT;
  2420. }

  2422. /* Called when the LWP stopped for a trap that could be explained by a
  2423.    watchpoint or a breakpoint.  */

  2425. static void
  2426. ‌save_sigtrap (struct lwp_info *lp)
  2427. {
  2428.   gdb_assert (lp->stop_reason == LWP_STOPPED_BY_NO_REASON);
  2429.   gdb_assert (lp->status != 0);

  2431.   if (check_stopped_by_watchpoint (lp))
  2432.     return;

  2434.   if (linux_nat_status_is_event (lp->status))
  2435.     check_stopped_by_breakpoint (lp);
  2436. }

  2438. /* Returns true if the LWP had stopped for a watchpoint.  */

  2440. static int
  2441. ‌linux_nat_stopped_by_watchpoint (struct target_ops *ops)
  2442. {
  2443.   struct lwp_info *lp = find_lwp_pid (inferior_ptid);

  2445.   gdb_assert (lp != NULL);

  2447.   return lp->stop_reason == LWP_STOPPED_BY_WATCHPOINT;
  2448. }

  2450. static int
  2451. ‌linux_nat_stopped_data_address (struct target_ops *ops, CORE_ADDR *addr_p)
  2452. {
  2453.   struct lwp_info *lp = find_lwp_pid (inferior_ptid);

  2455.   gdb_assert (lp != NULL);

  2457.   *addr_p = lp->stopped_data_address;

  2459.   return lp->stopped_data_address_p;
  2460. }

  2462. /* Commonly any breakpoint / watchpoint generate only SIGTRAP.  */

  2464. static int
  2465. ‌sigtrap_is_event (int status)
  2466. {
  2467.   return WIFSTOPPED (status) && WSTOPSIG (status) == SIGTRAP;
  2468. }

  2470. /* Set alternative SIGTRAP-like events recognizer.  If
  2471.    breakpoint_inserted_here_p there then gdbarch_decr_pc_after_break will be
  2472.    applied.  */

  2474. void
  2475. ‌linux_nat_set_status_is_event (struct target_ops *t,
  2476.                                int (*status_is_event) (int status))
  2477. {
  2478.   linux_nat_status_is_event = status_is_event;
  2479. }

  2481. /* Wait until LP is stopped.  */

  2483. static int
  2484. ‌stop_wait_callback (struct lwp_info *lp, void *data)
  2485. {
  2486.   struct inferior *inf = find_inferior_ptid (lp->ptid);

  2488.   /* If this is a vfork parent, bail out, it is not going to report
  2489.      any SIGSTOP until the vfork is done with.  */
  2490.   if (inf->vfork_child != NULL)
  2491.     return 0;

  2493.   if (!lp->stopped)
  2494.     {
  2495.       int status;

  2497.       status = wait_lwp (lp);
  2498.       if (status == 0)
  2499.         return 0;

  2501.       if (lp->ignore_sigint && WIFSTOPPED (status)
  2502.           && WSTOPSIG (status) == SIGINT)
  2503.         {
  2504.           lp->ignore_sigint = 0;

  2506.           errno = 0;
  2507.           ptrace (PTRACE_CONT, ptid_get_lwp (lp->ptid), 0, 0);
  2508.           lp->stopped = 0;
  2509.           if (debug_linux_nat)
  2510.             fprintf_unfiltered (gdb_stdlog,
  2511.                                 "PTRACE_CONT %s, 0, 0 (%s) "
  2512.                                 "(discarding SIGINT)\n",
  2513.                                 target_pid_to_str (lp->ptid),
  2514.                                 errno ? safe_strerror (errno) : "OK");

  2516.           return stop_wait_callback (lp, NULL);
  2517.         }

  2519.       maybe_clear_ignore_sigint (lp);

  2521.       if (WSTOPSIG (status) != SIGSTOP)
  2522.         {
  2523.           /* The thread was stopped with a signal other than SIGSTOP.  */

  2525.           if (debug_linux_nat)
  2526.             fprintf_unfiltered (gdb_stdlog,
  2527.                                 "SWC: Pending event %s in %s\n",
  2528.                                 status_to_str ((int) status),
  2529.                                 target_pid_to_str (lp->ptid));

  2531.           /* Save the sigtrap event.  */
  2532.           lp->status = status;
  2533.           gdb_assert (lp->signalled);
  2534.           save_sigtrap (lp);
  2535.         }
  2536.       else
  2537.         {
  2538.           /* We caught the SIGSTOP that we intended to catch, so
  2539.              there's no SIGSTOP pending.  */

  2541.           if (debug_linux_nat)
  2542.             fprintf_unfiltered (gdb_stdlog,
  2543.                                 "SWC: Delayed SIGSTOP caught for %s.\n",
  2544.                                 target_pid_to_str (lp->ptid));

  2546.           /* Reset SIGNALLED only after the stop_wait_callback call
  2547.              above as it does gdb_assert on SIGNALLED.  */
  2548.           lp->signalled = 0;
  2549.         }
  2550.     }

  2552.   return 0;
  2553. }

  2555. /* Return non-zero if LP has a wait status pending.  Discard the
  2556.    pending event and resume the LWP if the event that originally
  2557.    caused the stop became uninteresting.  */

  2559. static int
  2560. ‌status_callback (struct lwp_info *lp, void *data)
  2561. {
  2562.   /* Only report a pending wait status if we pretend that this has
  2563.      indeed been resumed.  */
  2564.   if (!lp->resumed)
  2565.     return 0;

  2567.   if (lp->stop_reason == LWP_STOPPED_BY_SW_BREAKPOINT
  2568.       || lp->stop_reason == LWP_STOPPED_BY_HW_BREAKPOINT)
  2569.     {
  2570.       struct regcache *regcache = get_thread_regcache (lp->ptid);
  2571.       struct gdbarch *gdbarch = get_regcache_arch (regcache);
  2572.       CORE_ADDR pc;
  2573.       int discard = 0;

  2575.       gdb_assert (lp->status != 0);

  2577.       pc = regcache_read_pc (regcache);

  2579.       if (pc != lp->stop_pc)
  2580.         {
  2581.           if (debug_linux_nat)
  2582.             fprintf_unfiltered (gdb_stdlog,
  2583.                                 "SC: PC of %s changed.  was=%s, now=%s\n",
  2584.                                 target_pid_to_str (lp->ptid),
  2585.                                 paddress (target_gdbarch (), lp->stop_pc),
  2586.                                 paddress (target_gdbarch (), pc));
  2587.           discard = 1;
  2588.         }
  2589.       else if (!breakpoint_inserted_here_p (get_regcache_aspace (regcache), pc))
  2590.         {
  2591.           if (debug_linux_nat)
  2592.             fprintf_unfiltered (gdb_stdlog,
  2593.                                 "SC: previous breakpoint of %s, at %s gone\n",
  2594.                                 target_pid_to_str (lp->ptid),
  2595.                                 paddress (target_gdbarch (), lp->stop_pc));

  2597.           discard = 1;
  2598.         }

  2600.       if (discard)
  2601.         {
  2602.           if (debug_linux_nat)
  2603.             fprintf_unfiltered (gdb_stdlog,
  2604.                                 "SC: pending event of %s cancelled.\n",
  2605.                                 target_pid_to_str (lp->ptid));

  2607.           lp->status = 0;
  2608.           linux_resume_one_lwp (lp, lp->step, GDB_SIGNAL_0);
  2609.           return 0;
  2610.         }
  2611.       return 1;
  2612.     }

  2614.   return lwp_status_pending_p (lp);
  2615. }

  2617. /* Return non-zero if LP isn't stopped.  */

  2619. static int
  2620. ‌running_callback (struct lwp_info *lp, void *data)
  2621. {
  2622.   return (!lp->stopped
  2623.           || (lwp_status_pending_p (lp) && lp->resumed));
  2624. }

  2626. /* Count the LWP's that have had events.  */

  2628. static int
  2629. ‌count_events_callback (struct lwp_info *lp, void *data)
  2630. {
  2631.   int *count = data;

  2633.   gdb_assert (count != NULL);

  2635.   /* Select only resumed LWPs that have an event pending.  */
  2636.   if (lp->resumed && lwp_status_pending_p (lp))
  2637.     (*count)++;

  2639.   return 0;
  2640. }

  2642. /* Select the LWP (if any) that is currently being single-stepped.  */

  2644. static int
  2645. ‌select_singlestep_lwp_callback (struct lwp_info *lp, void *data)
  2646. {
  2647.   if (lp->last_resume_kind == resume_step
  2648.       && lp->status != 0)
  2649.     return 1;
  2650.   else
  2651.     return 0;
  2652. }

  2654. /* Returns true if LP has a status pending.  */

  2656. static int
  2657. ‌lwp_status_pending_p (struct lwp_info *lp)
  2658. {
  2659.   /* We check for lp->waitstatus in addition to lp->status, because we
  2660.      can have pending process exits recorded in lp->status and
  2661.      W_EXITCODE(0,0) happens to be 0.  */
  2662.   return lp->status != 0 || lp->waitstatus.kind != TARGET_WAITKIND_IGNORE;
  2663. }

  2665. /* Select the Nth LWP that has had a SIGTRAP event.  */

  2667. static int
  2668. ‌select_event_lwp_callback (struct lwp_info *lp, void *data)
  2669. {
  2670.   int *selector = data;

  2672.   gdb_assert (selector != NULL);

  2674.   /* Select only resumed LWPs that have an event pending.  */
  2675.   if (lp->resumed && lwp_status_pending_p (lp))
  2676.     if ((*selector)-- == 0)
  2677.       return 1;

  2679.   return 0;
  2680. }

  2682. /* Called when the LWP got a signal/trap that could be explained by a
  2683.    software or hardware breakpoint.  */

  2685. static int
  2686. ‌check_stopped_by_breakpoint (struct lwp_info *lp)
  2687. {
  2688.   /* Arrange for a breakpoint to be hit again later.  We don't keep
  2689.      the SIGTRAP status and don't forward the SIGTRAP signal to the
  2690.      LWP.  We will handle the current event, eventually we will resume
  2691.      this LWP, and this breakpoint will trap again.

  2693.      If we do not do this, then we run the risk that the user will
  2694.      delete or disable the breakpoint, but the LWP will have already
  2695.      tripped on it.  */

  2697.   struct regcache *regcache = get_thread_regcache (lp->ptid);
  2698.   struct gdbarch *gdbarch = get_regcache_arch (regcache);
  2699.   CORE_ADDR pc;
  2700.   CORE_ADDR sw_bp_pc;

  2702.   pc = regcache_read_pc (regcache);
  2703.   sw_bp_pc = pc - target_decr_pc_after_break (gdbarch);

  2705.   if ((!lp->step || lp->stop_pc == sw_bp_pc)
  2706.       && software_breakpoint_inserted_here_p (get_regcache_aspace (regcache),
  2707.                                               sw_bp_pc))
  2708.     {
  2709.       /* The LWP was either continued, or stepped a software
  2710.          breakpoint instruction.  */
  2711.       if (debug_linux_nat)
  2712.         fprintf_unfiltered (gdb_stdlog,
  2713.                             "CB: Push back software breakpoint for %s\n",
  2714.                             target_pid_to_str (lp->ptid));

  2716.       /* Back up the PC if necessary.  */
  2717.       if (pc != sw_bp_pc)
  2718.         regcache_write_pc (regcache, sw_bp_pc);

  2720.       lp->stop_pc = sw_bp_pc;
  2721.       lp->stop_reason = LWP_STOPPED_BY_SW_BREAKPOINT;
  2722.       return 1;
  2723.     }

  2725.   if (hardware_breakpoint_inserted_here_p (get_regcache_aspace (regcache), pc))
  2726.     {
  2727.       if (debug_linux_nat)
  2728.         fprintf_unfiltered (gdb_stdlog,
  2729.                             "CB: Push back hardware breakpoint for %s\n",
  2730.                             target_pid_to_str (lp->ptid));

  2732.       lp->stop_pc = pc;
  2733.       lp->stop_reason = LWP_STOPPED_BY_HW_BREAKPOINT;
  2734.       return 1;
  2735.     }

  2737.   return 0;
  2738. }

  2740. /* Select one LWP out of those that have events pending.  */

  2742. static void
  2743. ‌select_event_lwp (ptid_t filter, struct lwp_info **orig_lp, int *status)
  2744. {
  2745.   int num_events = 0;
  2746.   int random_selector;
  2747.   struct lwp_info *event_lp = NULL;

  2749.   /* Record the wait status for the original LWP.  */
  2750.   (*orig_lp)->status = *status;

  2752.   /* In all-stop, give preference to the LWP that is being
  2753.      single-stepped.  There will be at most one, and it will be the
  2754.      LWP that the core is most interested in.  If we didn't do this,
  2755.      then we'd have to handle pending step SIGTRAPs somehow in case
  2756.      the core later continues the previously-stepped thread, as
  2757.      otherwise we'd report the pending SIGTRAP then, and the core, not
  2758.      having stepped the thread, wouldn't understand what the trap was
  2759.      for, and therefore would report it to the user as a random
  2760.      signal.  */
  2761.   if (!non_stop)
  2762.     {
  2763.       event_lp = iterate_over_lwps (filter,
  2764.                                     select_singlestep_lwp_callback, NULL);
  2765.       if (event_lp != NULL)
  2766.         {
  2767.           if (debug_linux_nat)
  2768.             fprintf_unfiltered (gdb_stdlog,
  2769.                                 "SEL: Select single-step %s\n",
  2770.                                 target_pid_to_str (event_lp->ptid));
  2771.         }
  2772.     }

  2774.   if (event_lp == NULL)
  2775.     {
  2776.       /* Pick one at random, out of those which have had events.  */

  2778.       /* First see how many events we have.  */
  2779.       iterate_over_lwps (filter, count_events_callback, &num_events);

  2781.       /* Now randomly pick a LWP out of those that have had
  2782.          events.  */
  2783.       random_selector = (int)
  2784.         ((num_events * (double) rand ()) / (RAND_MAX + 1.0));

  2786.       if (debug_linux_nat && num_events > 1)
  2787.         fprintf_unfiltered (gdb_stdlog,
  2788.                             "SEL: Found %d events, selecting #%d\n",
  2789.                             num_events, random_selector);

  2791.       event_lp = iterate_over_lwps (filter,
  2792.                                     select_event_lwp_callback,
  2793.                                     &random_selector);
  2794.     }

  2796.   if (event_lp != NULL)
  2797.     {
  2798.       /* Switch the event LWP.  */
  2799.       *orig_lp = event_lp;
  2800.       *status = event_lp->status;
  2801.     }

  2803.   /* Flush the wait status for the event LWP.  */
  2804.   (*orig_lp)->status = 0;
  2805. }

  2807. /* Return non-zero if LP has been resumed.  */

  2809. static int
  2810. ‌resumed_callback (struct lwp_info *lp, void *data)
  2811. {
  2812.   return lp->resumed;
  2813. }

  2815. /* Stop an active thread, verify it still exists, then resume it.  If
  2816.    the thread ends up with a pending status, then it is not resumed,
  2817.    and *DATA (really a pointer to int), is set.  */

  2819. static int
  2820. ‌stop_and_resume_callback (struct lwp_info *lp, void *data)
  2821. {
  2822.   if (!lp->stopped)
  2823.     {
  2824.       ptid_t ptid = lp->ptid;

  2826.       stop_callback (lp, NULL);
  2827.       stop_wait_callback (lp, NULL);

  2829.       /* Resume if the lwp still exists, and the core wanted it
  2830.          running.  */
  2831.       lp = find_lwp_pid (ptid);
  2832.       if (lp != NULL)
  2833.         {
  2834.           if (lp->last_resume_kind == resume_stop
  2835.               && !lwp_status_pending_p (lp))
  2836.             {
  2837.               /* The core wanted the LWP to stop.  Even if it stopped
  2838.                  cleanly (with SIGSTOP), leave the event pending.  */
  2839.               if (debug_linux_nat)
  2840.                 fprintf_unfiltered (gdb_stdlog,
  2841.                                     "SARC: core wanted LWP %ld stopped "
  2842.                                     "(leaving SIGSTOP pending)\n",
  2843.                                     ptid_get_lwp (lp->ptid));
  2844.               lp->status = W_STOPCODE (SIGSTOP);
  2845.             }

  2847.           if (!lwp_status_pending_p (lp))
  2848.             {
  2849.               if (debug_linux_nat)
  2850.                 fprintf_unfiltered (gdb_stdlog,
  2851.                                     "SARC: re-resuming LWP %ld\n",
  2852.                                     ptid_get_lwp (lp->ptid));
  2853.               resume_lwp (lp, lp->step, GDB_SIGNAL_0);
  2854.             }
  2855.           else
  2856.             {
  2857.               if (debug_linux_nat)
  2858.                 fprintf_unfiltered (gdb_stdlog,
  2859.                                     "SARC: not re-resuming LWP %ld "
  2860.                                     "(has pending)\n",
  2861.                                     ptid_get_lwp (lp->ptid));
  2862.             }
  2863.         }
  2864.     }
  2865.   return 0;
  2866. }

  2868. /* Check if we should go on and pass this event to common code.
  2869.    Return the affected lwp if we are, or NULL otherwise.  */

  2871. static struct lwp_info *
  2872. ‌linux_nat_filter_event (int lwpid, int status)
  2873. {
  2874.   struct lwp_info *lp;
  2875.   int event = linux_ptrace_get_extended_event (status);

  2877.   lp = find_lwp_pid (pid_to_ptid (lwpid));

  2879.   /* Check for stop events reported by a process we didn't already
  2880.      know about - anything not already in our LWP list.

  2882.      If we're expecting to receive stopped processes after
  2883.      fork, vfork, and clone events, then we'll just add the
  2884.      new one to our list and go back to waiting for the event
  2885.      to be reported - the stopped process might be returned
  2886.      from waitpid before or after the event is.

  2888.      But note the case of a non-leader thread exec'ing after the
  2889.      leader having exited, and gone from our lists.  The non-leader
  2890.      thread changes its tid to the tgid.  */

  2892.   if (WIFSTOPPED (status) && lp == NULL
  2893.       && (WSTOPSIG (status) == SIGTRAP && event == PTRACE_EVENT_EXEC))
  2894.     {
  2895.       /* A multi-thread exec after we had seen the leader exiting.  */
  2896.       if (debug_linux_nat)
  2897.         fprintf_unfiltered (gdb_stdlog,
  2898.                             "LLW: Re-adding thread group leader LWP %d.\n",
  2899.                             lwpid);

  2901.       lp = add_lwp (ptid_build (lwpid, lwpid, 0));
  2902.       lp->stopped = 1;
  2903.       lp->resumed = 1;
  2904.       add_thread (lp->ptid);
  2905.     }

  2907.   if (WIFSTOPPED (status) && !lp)
  2908.     {
  2909.       add_to_pid_list (&stopped_pids, lwpid, status);
  2910.       return NULL;
  2911.     }

  2913.   /* Make sure we don't report an event for the exit of an LWP not in
  2914.      our list, i.e. not part of the current process.  This can happen
  2915.      if we detach from a program we originally forked and then it
  2916.      exits.  */
  2917.   if (!WIFSTOPPED (status) && !lp)
  2918.     return NULL;

  2920.   /* This LWP is stopped now.  (And if dead, this prevents it from
  2921.      ever being continued.)  */
  2922.   lp->stopped = 1;

  2924.   if (WIFSTOPPED (status) && lp->must_set_ptrace_flags)
  2925.     {
  2926.       struct inferior *inf = find_inferior_pid (ptid_get_pid (lp->ptid));

  2928.       linux_enable_event_reporting (ptid_get_lwp (lp->ptid), inf->attach_flag);
  2929.       lp->must_set_ptrace_flags = 0;
  2930.     }

  2932.   /* Handle GNU/Linux's syscall SIGTRAPs.  */
  2933.   if (WIFSTOPPED (status) && WSTOPSIG (status) == SYSCALL_SIGTRAP)
  2934.     {
  2935.       /* No longer need the sysgood bit.  The ptrace event ends up
  2936.          recorded in lp->waitstatus if we care for it.  We can carry
  2937.          on handling the event like a regular SIGTRAP from here
  2938.          on.  */
  2939.       status = W_STOPCODE (SIGTRAP);
  2940.       if (linux_handle_syscall_trap (lp, 0))
  2941.         return NULL;
  2942.     }

  2944.   /* Handle GNU/Linux's extended waitstatus for trace events.  */
  2945.   if (WIFSTOPPED (status) && WSTOPSIG (status) == SIGTRAP
  2946.       && linux_is_extended_waitstatus (status))
  2947.     {
  2948.       if (debug_linux_nat)
  2949.         fprintf_unfiltered (gdb_stdlog,
  2950.                             "LLW: Handling extended status 0x%06x\n",
  2951.                             status);
  2952.       if (linux_handle_extended_wait (lp, status, 0))
  2953.         return NULL;
  2954.     }

  2956.   /* Check if the thread has exited.  */
  2957.   if (WIFEXITED (status) || WIFSIGNALED (status))
  2958.     {
  2959.       if (num_lwps (ptid_get_pid (lp->ptid)) > 1)
  2960.         {
  2961.           /* If this is the main thread, we must stop all threads and
  2962.              verify if they are still alive.  This is because in the
  2963.              nptl thread model on Linux 2.4, there is no signal issued
  2964.              for exiting LWPs other than the main thread.  We only get
  2965.              the main thread exit signal once all child threads have
  2966.              already exited.  If we stop all the threads and use the
  2967.              stop_wait_callback to check if they have exited we can
  2968.              determine whether this signal should be ignored or
  2969.              whether it means the end of the debugged application,
  2970.              regardless of which threading model is being used.  */
  2971.           if (ptid_get_pid (lp->ptid) == ptid_get_lwp (lp->ptid))
  2972.             {
  2973.               iterate_over_lwps (pid_to_ptid (ptid_get_pid (lp->ptid)),
  2974.                                  stop_and_resume_callback, NULL);
  2975.             }

  2977.           if (debug_linux_nat)
  2978.             fprintf_unfiltered (gdb_stdlog,
  2979.                                 "LLW: %s exited.\n",
  2980.                                 target_pid_to_str (lp->ptid));

  2982.           if (num_lwps (ptid_get_pid (lp->ptid)) > 1)
  2983.             {
  2984.               /* If there is at least one more LWP, then the exit signal
  2985.                  was not the end of the debugged application and should be
  2986.                  ignored.  */
  2987.               exit_lwp (lp);
  2988.               return NULL;
  2989.             }
  2990.         }

  2992.       gdb_assert (lp->resumed);

  2994.       if (debug_linux_nat)
  2995.         fprintf_unfiltered (gdb_stdlog,
  2996.                             "Process %ld exited\n",
  2997.                             ptid_get_lwp (lp->ptid));

  2999.       /* This was the last lwp in the process.  Since events are
  3000.          serialized to GDB core, we may not be able report this one
  3001.          right now, but GDB core and the other target layers will want
  3002.          to be notified about the exit code/signal, leave the status
  3003.          pending for the next time we're able to report it.  */

  3005.       /* Dead LWP's aren't expected to reported a pending sigstop.  */
  3006.       lp->signalled = 0;

  3008.       /* Store the pending event in the waitstatus, because
  3009.          W_EXITCODE(0,0) == 0.  */
  3010.       store_waitstatus (&lp->waitstatus, status);
  3011.       return lp;
  3012.     }

  3014.   /* Check if the current LWP has previously exited.  In the nptl
  3015.      thread model, LWPs other than the main thread do not issue
  3016.      signals when they exit so we must check whenever the thread has
  3017.      stopped.  A similar check is made in stop_wait_callback().  */
  3018.   if (num_lwps (ptid_get_pid (lp->ptid)) > 1 && !linux_thread_alive (lp->ptid))
  3019.     {
  3020.       ptid_t ptid = pid_to_ptid (ptid_get_pid (lp->ptid));

  3022.       if (debug_linux_nat)
  3023.         fprintf_unfiltered (gdb_stdlog,
  3024.                             "LLW: %s exited.\n",
  3025.                             target_pid_to_str (lp->ptid));

  3027.       exit_lwp (lp);

  3029.       /* Make sure there is at least one thread running.  */
  3030.       gdb_assert (iterate_over_lwps (ptid, running_callback, NULL));

  3032.       /* Discard the event.  */
  3033.       return NULL;
  3034.     }

  3036.   /* Make sure we don't report a SIGSTOP that we sent ourselves in
  3037.      an attempt to stop an LWP.  */
  3038.   if (lp->signalled
  3039.       && WIFSTOPPED (status) && WSTOPSIG (status) == SIGSTOP)
  3040.     {
  3041.       if (debug_linux_nat)
  3042.         fprintf_unfiltered (gdb_stdlog,
  3043.                             "LLW: Delayed SIGSTOP caught for %s.\n",
  3044.                             target_pid_to_str (lp->ptid));

  3046.       lp->signalled = 0;

  3048.       if (lp->last_resume_kind != resume_stop)
  3049.         {
  3050.           /* This is a delayed SIGSTOP.  */

  3052.           linux_resume_one_lwp (lp, lp->step, GDB_SIGNAL_0);
  3053.           if (debug_linux_nat)
  3054.             fprintf_unfiltered (gdb_stdlog,
  3055.                                 "LLW: %s %s, 0, 0 (discard SIGSTOP)\n",
  3056.                                 lp->step ?
  3057.                                 "PTRACE_SINGLESTEP" : "PTRACE_CONT",
  3058.                                 target_pid_to_str (lp->ptid));

  3060.           gdb_assert (lp->resumed);

  3062.           /* Discard the event.  */
  3063.           return NULL;
  3064.         }
  3065.     }

  3067.   /* Make sure we don't report a SIGINT that we have already displayed
  3068.      for another thread.  */
  3069.   if (lp->ignore_sigint
  3070.       && WIFSTOPPED (status) && WSTOPSIG (status) == SIGINT)
  3071.     {
  3072.       if (debug_linux_nat)
  3073.         fprintf_unfiltered (gdb_stdlog,
  3074.                             "LLW: Delayed SIGINT caught for %s.\n",
  3075.                             target_pid_to_str (lp->ptid));

  3077.       /* This is a delayed SIGINT.  */
  3078.       lp->ignore_sigint = 0;

  3080.       linux_resume_one_lwp (lp, lp->step, GDB_SIGNAL_0);
  3081.       if (debug_linux_nat)
  3082.         fprintf_unfiltered (gdb_stdlog,
  3083.                             "LLW: %s %s, 0, 0 (discard SIGINT)\n",
  3084.                             lp->step ?
  3085.                             "PTRACE_SINGLESTEP" : "PTRACE_CONT",
  3086.                             target_pid_to_str (lp->ptid));
  3087.       gdb_assert (lp->resumed);

  3089.       /* Discard the event.  */
  3090.       return NULL;
  3091.     }

  3093.   /* Don't report signals that GDB isn't interested in, such as
  3094.      signals that are neither printed nor stopped upon.  Stopping all
  3095.      threads can be a bit time-consuming so if we want decent
  3096.      performance with heavily multi-threaded programs, especially when
  3097.      they're using a high frequency timer, we'd better avoid it if we
  3098.      can.  */
  3099.   if (WIFSTOPPED (status))
  3100.     {
  3101.       enum gdb_signal signo = gdb_signal_from_host (WSTOPSIG (status));

  3103.       if (!non_stop)
  3104.         {
  3105.           /* Only do the below in all-stop, as we currently use SIGSTOP
  3106.              to implement target_stop (see linux_nat_stop) in
  3107.              non-stop.  */
  3108.           if (signo == GDB_SIGNAL_INT && signal_pass_state (signo) == 0)
  3109.             {
  3110.               /* If ^C/BREAK is typed at the tty/console, SIGINT gets
  3111.                  forwarded to the entire process group, that is, all LWPs
  3112.                  will receive it - unless they're using CLONE_THREAD to
  3113.                  share signals.  Since we only want to report it once, we
  3114.                  mark it as ignored for all LWPs except this one.  */
  3115.               iterate_over_lwps (pid_to_ptid (ptid_get_pid (lp->ptid)),
  3116.                                               set_ignore_sigint, NULL);
  3117.               lp->ignore_sigint = 0;
  3118.             }
  3119.           else
  3120.             maybe_clear_ignore_sigint (lp);
  3121.         }

  3123.       /* When using hardware single-step, we need to report every signal.
  3124.          Otherwise, signals in pass_mask may be short-circuited.  */
  3125.       if (!lp->step
  3126.           && WSTOPSIG (status) && sigismember (&pass_mask, WSTOPSIG (status)))
  3127.         {
  3128.           linux_resume_one_lwp (lp, lp->step, signo);
  3129.           if (debug_linux_nat)
  3130.             fprintf_unfiltered (gdb_stdlog,
  3131.                                 "LLW: %s %s, %s (preempt 'handle')\n",
  3132.                                 lp->step ?
  3133.                                 "PTRACE_SINGLESTEP" : "PTRACE_CONT",
  3134.                                 target_pid_to_str (lp->ptid),
  3135.                                 (signo != GDB_SIGNAL_0
  3136.                                  ? strsignal (gdb_signal_to_host (signo))
  3137.                                  : "0"));
  3138.           return NULL;
  3139.         }
  3140.     }

  3142.   /* An interesting event.  */
  3143.   gdb_assert (lp);
  3144.   lp->status = status;
  3145.   save_sigtrap (lp);
  3146.   return lp;
  3147. }

  3149. /* Detect zombie thread group leaders, and "exit" them.  We can't reap
  3150.    their exits until all other threads in the group have exited.  */

  3152. static void
  3153. ‌check_zombie_leaders (void)
  3154. {
  3155.   struct inferior *inf;

  3157.   ALL_INFERIORS (inf)
  3158.     {
  3159.       struct lwp_info *leader_lp;

  3161.       if (inf->pid == 0)
  3162.         continue;

  3164.       leader_lp = find_lwp_pid (pid_to_ptid (inf->pid));
  3165.       if (leader_lp != NULL
  3166.           /* Check if there are other threads in the group, as we may
  3167.              have raced with the inferior simply exiting.  */
  3168.           && num_lwps (inf->pid) > 1
  3169.           && linux_proc_pid_is_zombie (inf->pid))
  3170.         {
  3171.           if (debug_linux_nat)
  3172.             fprintf_unfiltered (gdb_stdlog,
  3173.                                 "CZL: Thread group leader %d zombie "
  3174.                                 "(it exited, or another thread execd).\n",
  3175.                                 inf->pid);

  3177.           /* A leader zombie can mean one of two things:

  3179.              - It exited, and there's an exit status pending
  3180.              available, or only the leader exited (not the whole
  3181.              program).  In the latter case, we can't waitpid the
  3182.              leader's exit status until all other threads are gone.

  3184.              - There are 3 or more threads in the group, and a thread
  3185.              other than the leader exec'd.  On an exec, the Linux
  3186.              kernel destroys all other threads (except the execing
  3187.              one) in the thread group, and resets the execing thread's
  3188.              tid to the tgid.  No exit notification is sent for the
  3189.              execing thread -- from the ptracer's perspective, it
  3190.              appears as though the execing thread just vanishes.
  3191.              Until we reap all other threads except the leader and the
  3192.              execing thread, the leader will be zombie, and the
  3193.              execing thread will be in `D (disc sleep)'.  As soon as
  3194.              all other threads are reaped, the execing thread changes
  3195.              it's tid to the tgid, and the previous (zombie) leader
  3196.              vanishes, giving place to the "new" leader.  We could try
  3197.              distinguishing the exit and exec cases, by waiting once
  3198.              more, and seeing if something comes out, but it doesn't
  3199.              sound useful.  The previous leader _does_ go away, and
  3200.              we'll re-add the new one once we see the exec event
  3201.              (which is just the same as what would happen if the
  3202.              previous leader did exit voluntarily before some other
  3203.              thread execs).  */

  3205.           if (debug_linux_nat)
  3206.             fprintf_unfiltered (gdb_stdlog,
  3207.                                 "CZL: Thread group leader %d vanished.\n",
  3208.                                 inf->pid);
  3209.           exit_lwp (leader_lp);
  3210.         }
  3211.     }
  3212. }

  3214. static ptid_t
  3215. ‌linux_nat_wait_1 (struct target_ops *ops,
  3216.                   ptid_t ptid, struct target_waitstatus *ourstatus,
  3217.                   int target_options)
  3218. {
  3219.   sigset_t prev_mask;
  3220.   enum resume_kind last_resume_kind;
  3221.   struct lwp_info *lp;
  3222.   int status;

  3224.   if (debug_linux_nat)
  3225.     fprintf_unfiltered (gdb_stdlog, "LLW: enter\n");

  3227.   /* The first time we get here after starting a new inferior, we may
  3228.      not have added it to the LWP list yet - this is the earliest
  3229.      moment at which we know its PID.  */
  3230.   if (ptid_is_pid (inferior_ptid))
  3231.     {
  3232.       /* Upgrade the main thread's ptid.  */
  3233.       thread_change_ptid (inferior_ptid,
  3234.                           ptid_build (ptid_get_pid (inferior_ptid),
  3235.                                       ptid_get_pid (inferior_ptid), 0));

  3237.       lp = add_initial_lwp (inferior_ptid);
  3238.       lp->resumed = 1;
  3239.     }

  3241.   /* Make sure SIGCHLD is blocked until the sigsuspend below.  */
  3242.   block_child_signals (&prev_mask);

  3244.   /* First check if there is a LWP with a wait status pending.  */
  3245.   lp = iterate_over_lwps (ptid, status_callback, NULL);
  3246.   if (lp != NULL)
  3247.     {
  3248.       if (debug_linux_nat)
  3249.         fprintf_unfiltered (gdb_stdlog,
  3250.                             "LLW: Using pending wait status %s for %s.\n",
  3251.                             status_to_str (lp->status),
  3252.                             target_pid_to_str (lp->ptid));
  3253.     }

  3255.   if (!target_can_async_p ())
  3256.     {
  3257.       /* Causes SIGINT to be passed on to the attached process.  */
  3258.       set_sigint_trap ();
  3259.     }

  3261.   /* But if we don't find a pending event, we'll have to wait.  Always
  3262.      pull all events out of the kernel.  We'll randomly select an
  3263.      event LWP out of all that have events, to prevent starvation.  */

  3265.   while (lp == NULL)
  3266.     {
  3267.       pid_t lwpid;

  3269.       /* Always use -1 and WNOHANG, due to couple of a kernel/ptrace
  3270.          quirks:

  3272.          - If the thread group leader exits while other threads in the
  3273.            thread group still exist, waitpid(TGID, ...) hangs.  That
  3274.            waitpid won't return an exit status until the other threads
  3275.            in the group are reapped.

  3277.          - When a non-leader thread execs, that thread just vanishes
  3278.            without reporting an exit (so we'd hang if we waited for it
  3279.            explicitly in that case).  The exec event is reported to
  3280.            the TGID pid.  */

  3282.       errno = 0;
  3283.       lwpid = my_waitpid (-1, &status,  __WCLONE | WNOHANG);
  3284.       if (lwpid == 0 || (lwpid == -1 && errno == ECHILD))
  3285.         lwpid = my_waitpid (-1, &status, WNOHANG);

  3287.       if (debug_linux_nat)
  3288.         fprintf_unfiltered (gdb_stdlog,
  3289.                             "LNW: waitpid(-1, ...) returned %d, %s\n",
  3290.                             lwpid, errno ? safe_strerror (errno) : "ERRNO-OK");

  3292.       if (lwpid > 0)
  3293.         {
  3294.           if (debug_linux_nat)
  3295.             {
  3296.               fprintf_unfiltered (gdb_stdlog,
  3297.                                   "LLW: waitpid %ld received %s\n",
  3298.                                   (long) lwpid, status_to_str (status));
  3299.             }

  3301.           linux_nat_filter_event (lwpid, status);
  3302.           /* Retry until nothing comes out of waitpid.  A single
  3303.              SIGCHLD can indicate more than one child stopped.  */
  3304.           continue;
  3305.         }

  3307.       /* Now that we've pulled all events out of the kernel, check if
  3308.          there's any LWP with a status to report to the core.  */
  3309.       lp = iterate_over_lwps (ptid, status_callback, NULL);
  3310.       if (lp != NULL)
  3311.         break;

  3313.       /* Check for zombie thread group leaders.  Those can't be reaped
  3314.          until all other threads in the thread group are.  */
  3315.       check_zombie_leaders ();

  3317.       /* If there are no resumed children left, bail.  We'd be stuck
  3318.          forever in the sigsuspend call below otherwise.  */
  3319.       if (iterate_over_lwps (ptid, resumed_callback, NULL) == NULL)
  3320.         {
  3321.           if (debug_linux_nat)
  3322.             fprintf_unfiltered (gdb_stdlog, "LLW: exit (no resumed LWP)\n");

  3324.           ourstatus->kind = TARGET_WAITKIND_NO_RESUMED;

  3326.           if (!target_can_async_p ())
  3327.             clear_sigint_trap ();

  3329.           restore_child_signals_mask (&prev_mask);
  3330.           return minus_one_ptid;
  3331.         }

  3333.       /* No interesting event to report to the core.  */

  3335.       if (target_options & TARGET_WNOHANG)
  3336.         {
  3337.           if (debug_linux_nat)
  3338.             fprintf_unfiltered (gdb_stdlog, "LLW: exit (ignore)\n");

  3340.           ourstatus->kind = TARGET_WAITKIND_IGNORE;
  3341.           restore_child_signals_mask (&prev_mask);
  3342.           return minus_one_ptid;
  3343.         }

  3345.       /* We shouldn't end up here unless we want to try again.  */
  3346.       gdb_assert (lp == NULL);

  3348.       /* Block until we get an event reported with SIGCHLD.  */
  3349.       if (debug_linux_nat)
  3350.         fprintf_unfiltered (gdb_stdlog, "LNW: about to sigsuspend\n");
  3351.       sigsuspend (&suspend_mask);
  3352.     }

  3354.   if (!target_can_async_p ())
  3355.     clear_sigint_trap ();

  3357.   gdb_assert (lp);

  3359.   status = lp->status;
  3360.   lp->status = 0;

  3362.   if (!non_stop)
  3363.     {
  3364.       /* Now stop all other LWP's ...  */
  3365.       iterate_over_lwps (minus_one_ptid, stop_callback, NULL);

  3367.       /* ... and wait until all of them have reported back that
  3368.          they're no longer running.  */
  3369.       iterate_over_lwps (minus_one_ptid, stop_wait_callback, NULL);
  3370.     }

  3372.   /* If we're not waiting for a specific LWP, choose an event LWP from
  3373.      among those that have had events.  Giving equal priority to all
  3374.      LWPs that have had events helps prevent starvation.  */
  3375.   if (ptid_equal (ptid, minus_one_ptid) || ptid_is_pid (ptid))
  3376.     select_event_lwp (ptid, &lp, &status);

  3378.   gdb_assert (lp != NULL);

  3380.   /* Now that we've selected our final event LWP, un-adjust its PC if
  3381.      it was a software breakpoint.  */
  3382.   if (lp->stop_reason == LWP_STOPPED_BY_SW_BREAKPOINT)
  3383.     {
  3384.       struct regcache *regcache = get_thread_regcache (lp->ptid);
  3385.       struct gdbarch *gdbarch = get_regcache_arch (regcache);
  3386.       int decr_pc = target_decr_pc_after_break (gdbarch);

  3388.       if (decr_pc != 0)
  3389.         {
  3390.           CORE_ADDR pc;

  3392.           pc = regcache_read_pc (regcache);
  3393.           regcache_write_pc (regcache, pc + decr_pc);
  3394.         }
  3395.     }

  3397.   /* We'll need this to determine whether to report a SIGSTOP as
  3398.      GDB_SIGNAL_0.  Need to take a copy because resume_clear_callback
  3399.      clears it.  */
  3400.   last_resume_kind = lp->last_resume_kind;

  3402.   if (!non_stop)
  3403.     {
  3404.       /* In all-stop, from the core's perspective, all LWPs are now
  3405.          stopped until a new resume action is sent over.  */
  3406.       iterate_over_lwps (minus_one_ptid, resume_clear_callback, NULL);
  3407.     }
  3408.   else
  3409.     {
  3410.       resume_clear_callback (lp, NULL);
  3411.     }

  3413.   if (linux_nat_status_is_event (status))
  3414.     {
  3415.       if (debug_linux_nat)
  3416.         fprintf_unfiltered (gdb_stdlog,
  3417.                             "LLW: trap ptid is %s.\n",
  3418.                             target_pid_to_str (lp->ptid));
  3419.     }

  3421.   if (lp->waitstatus.kind != TARGET_WAITKIND_IGNORE)
  3422.     {
  3423.       *ourstatus = lp->waitstatus;
  3424.       lp->waitstatus.kind = TARGET_WAITKIND_IGNORE;
  3425.     }
  3426.   else
  3427.     store_waitstatus (ourstatus, status);

  3429.   if (debug_linux_nat)
  3430.     fprintf_unfiltered (gdb_stdlog, "LLW: exit\n");

  3432.   restore_child_signals_mask (&prev_mask);

  3434.   if (last_resume_kind == resume_stop
  3435.       && ourstatus->kind == TARGET_WAITKIND_STOPPED
  3436.       && WSTOPSIG (status) == SIGSTOP)
  3437.     {
  3438.       /* A thread that has been requested to stop by GDB with
  3439.          target_stop, and it stopped cleanly, so report as SIG0.  The
  3440.          use of SIGSTOP is an implementation detail.  */
  3441.       ourstatus->value.sig = GDB_SIGNAL_0;
  3442.     }

  3444.   if (ourstatus->kind == TARGET_WAITKIND_EXITED
  3445.       || ourstatus->kind == TARGET_WAITKIND_SIGNALLED)
  3446.     lp->core = -1;
  3447.   else
  3448.     lp->core = linux_common_core_of_thread (lp->ptid);

  3450.   return lp->ptid;
  3451. }

  3453. /* Resume LWPs that are currently stopped without any pending status
  3454.    to report, but are resumed from the core's perspective.  */

  3456. static int
  3457. ‌resume_stopped_resumed_lwps (struct lwp_info *lp, void *data)
  3458. {
  3459.   ptid_t *wait_ptid_p = data;

  3461.   if (lp->stopped
  3462.       && lp->resumed
  3463.       && !lwp_status_pending_p (lp))
  3464.     {
  3465.       struct regcache *regcache = get_thread_regcache (lp->ptid);
  3466.       struct gdbarch *gdbarch = get_regcache_arch (regcache);
  3467.       CORE_ADDR pc = regcache_read_pc (regcache);

  3469.       gdb_assert (is_executing (lp->ptid));

  3471.       /* Don't bother if there's a breakpoint at PC that we'd hit
  3472.          immediately, and we're not waiting for this LWP.  */
  3473.       if (!ptid_match (lp->ptid, *wait_ptid_p))
  3474.         {
  3475.           if (breakpoint_inserted_here_p (get_regcache_aspace (regcache), pc))
  3476.             return 0;
  3477.         }

  3479.       if (debug_linux_nat)
  3480.         fprintf_unfiltered (gdb_stdlog,
  3481.                             "RSRL: resuming stopped-resumed LWP %s at %s: step=%d\n",
  3482.                             target_pid_to_str (lp->ptid),
  3483.                             paddress (gdbarch, pc),
  3484.                             lp->step);

  3486.       linux_resume_one_lwp (lp, lp->step, GDB_SIGNAL_0);
  3487.     }

  3489.   return 0;
  3490. }

  3492. static ptid_t
  3493. ‌linux_nat_wait (struct target_ops *ops,
  3494.                 ptid_t ptid, struct target_waitstatus *ourstatus,
  3495.                 int target_options)
  3496. {
  3497.   ptid_t event_ptid;

  3499.   if (debug_linux_nat)
  3500.     {
  3501.       char *options_string;

  3503.       options_string = target_options_to_string (target_options);
  3504.       fprintf_unfiltered (gdb_stdlog,
  3505.                           "linux_nat_wait: [%s], [%s]\n",
  3506.                           target_pid_to_str (ptid),
  3507.                           options_string);
  3508.       xfree (options_string);
  3509.     }

  3511.   /* Flush the async file first.  */
  3512.   if (target_can_async_p ())
  3513.     async_file_flush ();

  3515.   /* Resume LWPs that are currently stopped without any pending status
  3516.      to report, but are resumed from the core's perspective.  LWPs get
  3517.      in this state if we find them stopping at a time we're not
  3518.      interested in reporting the event (target_wait on a
  3519.      specific_process, for example, see linux_nat_wait_1), and
  3520.      meanwhile the event became uninteresting.  Don't bother resuming
  3521.      LWPs we're not going to wait for if they'd stop immediately.  */
  3522.   if (non_stop)
  3523.     iterate_over_lwps (minus_one_ptid, resume_stopped_resumed_lwps, &ptid);

  3525.   event_ptid = linux_nat_wait_1 (ops, ptid, ourstatus, target_options);

  3527.   /* If we requested any event, and something came out, assume there
  3528.      may be more.  If we requested a specific lwp or process, also
  3529.      assume there may be more.  */
  3530.   if (target_can_async_p ()
  3531.       && ((ourstatus->kind != TARGET_WAITKIND_IGNORE
  3532.            && ourstatus->kind != TARGET_WAITKIND_NO_RESUMED)
  3533.           || !ptid_equal (ptid, minus_one_ptid)))
  3534.     async_file_mark ();

  3536.   /* Get ready for the next event.  */
  3537.   if (target_can_async_p ())
  3538.     target_async (inferior_event_handler, 0);

  3540.   return event_ptid;
  3541. }

  3543. static int
  3544. ‌kill_callback (struct lwp_info *lp, void *data)
  3545. {
  3546.   /* PTRACE_KILL may resume the inferior.  Send SIGKILL first.  */

  3548.   errno = 0;
  3549.   kill_lwp (ptid_get_lwp (lp->ptid), SIGKILL);
  3550.   if (debug_linux_nat)
  3551.     {
  3552.       int save_errno = errno;

  3554.       fprintf_unfiltered (gdb_stdlog,
  3555.                           "KC:  kill (SIGKILL) %s, 0, 0 (%s)\n",
  3556.                           target_pid_to_str (lp->ptid),
  3557.                           save_errno ? safe_strerror (save_errno) : "OK");
  3558.     }

  3560.   /* Some kernels ignore even SIGKILL for processes under ptrace.  */

  3562.   errno = 0;
  3563.   ptrace (PTRACE_KILL, ptid_get_lwp (lp->ptid), 0, 0);
  3564.   if (debug_linux_nat)
  3565.     {
  3566.       int save_errno = errno;

  3568.       fprintf_unfiltered (gdb_stdlog,
  3569.                           "KC:  PTRACE_KILL %s, 0, 0 (%s)\n",
  3570.                           target_pid_to_str (lp->ptid),
  3571.                           save_errno ? safe_strerror (save_errno) : "OK");
  3572.     }

  3574.   return 0;
  3575. }

  3577. static int
  3578. ‌kill_wait_callback (struct lwp_info *lp, void *data)
  3579. {
  3580.   pid_t pid;

  3582.   /* We must make sure that there are no pending events (delayed
  3583.      SIGSTOPs, pending SIGTRAPs, etc.) to make sure the current
  3584.      program doesn't interfere with any following debugging session.  */

  3586.   /* For cloned processes we must check both with __WCLONE and
  3587.      without, since the exit status of a cloned process isn't reported
  3588.      with __WCLONE.  */
  3589.   if (lp->cloned)
  3590.     {
  3591.       do
  3592.         {
  3593.           pid = my_waitpid (ptid_get_lwp (lp->ptid), NULL, __WCLONE);
  3594.           if (pid != (pid_t) -1)
  3595.             {
  3596.               if (debug_linux_nat)
  3597.                 fprintf_unfiltered (gdb_stdlog,
  3598.                                     "KWC: wait %s received unknown.\n",
  3599.                                     target_pid_to_str (lp->ptid));
  3600.               /* The Linux kernel sometimes fails to kill a thread
  3601.                  completely after PTRACE_KILL; that goes from the stop
  3602.                  point in do_fork out to the one in
  3603.                  get_signal_to_deliever and waits again.  So kill it
  3604.                  again.  */
  3605.               kill_callback (lp, NULL);
  3606.             }
  3607.         }
  3608.       while (pid == ptid_get_lwp (lp->ptid));

  3610.       gdb_assert (pid == -1 && errno == ECHILD);
  3611.     }

  3613.   do
  3614.     {
  3615.       pid = my_waitpid (ptid_get_lwp (lp->ptid), NULL, 0);
  3616.       if (pid != (pid_t) -1)
  3617.         {
  3618.           if (debug_linux_nat)
  3619.             fprintf_unfiltered (gdb_stdlog,
  3620.                                 "KWC: wait %s received unk.\n",
  3621.                                 target_pid_to_str (lp->ptid));
  3622.           /* See the call to kill_callback above.  */
  3623.           kill_callback (lp, NULL);
  3624.         }
  3625.     }
  3626.   while (pid == ptid_get_lwp (lp->ptid));

  3628.   gdb_assert (pid == -1 && errno == ECHILD);
  3629.   return 0;
  3630. }

  3632. static void
  3633. ‌linux_nat_kill (struct target_ops *ops)
  3634. {
  3635.   struct target_waitstatus last;
  3636.   ptid_t last_ptid;
  3637.   int status;

  3639.   /* If we're stopped while forking and we haven't followed yet,
  3640.      kill the other task.  We need to do this first because the
  3641.      parent will be sleeping if this is a vfork.  */

  3643.   get_last_target_status (&last_ptid, &last);

  3645.   if (last.kind == TARGET_WAITKIND_FORKED
  3646.       || last.kind == TARGET_WAITKIND_VFORKED)
  3647.     {
  3648.       ptrace (PT_KILL, ptid_get_pid (last.value.related_pid), 0, 0);
  3649.       wait (&status);

  3651.       /* Let the arch-specific native code know this process is
  3652.          gone.  */
  3653.       linux_nat_forget_process (ptid_get_pid (last.value.related_pid));
  3654.     }

  3656.   if (forks_exist_p ())
  3657.     linux_fork_killall ();
  3658.   else
  3659.     {
  3660.       ptid_t ptid = pid_to_ptid (ptid_get_pid (inferior_ptid));

  3662.       /* Stop all threads before killing them, since ptrace requires
  3663.          that the thread is stopped to sucessfully PTRACE_KILL.  */
  3664.       iterate_over_lwps (ptid, stop_callback, NULL);
  3665.       /* ... and wait until all of them have reported back that
  3666.          they're no longer running.  */
  3667.       iterate_over_lwps (ptid, stop_wait_callback, NULL);

  3669.       /* Kill all LWP's ...  */
  3670.       iterate_over_lwps (ptid, kill_callback, NULL);

  3672.       /* ... and wait until we've flushed all events.  */
  3673.       iterate_over_lwps (ptid, kill_wait_callback, NULL);
  3674.     }

  3676.   target_mourn_inferior ();
  3677. }

  3679. static void
  3680. ‌linux_nat_mourn_inferior (struct target_ops *ops)
  3681. {
  3682.   int pid = ptid_get_pid (inferior_ptid);

  3684.   purge_lwp_list (pid);

  3686.   if (! forks_exist_p ())
  3687.     /* Normal case, no other forks available.  */
  3688.     linux_ops->to_mourn_inferior (ops);
  3689.   else
  3690.     /* Multi-fork case.  The current inferior_ptid has exited, but
  3691.        there are other viable forks to debug.  Delete the exiting
  3692.        one and context-switch to the first available.  */
  3693.     linux_fork_mourn_inferior ();

  3695.   /* Let the arch-specific native code know this process is gone.  */
  3696.   linux_nat_forget_process (pid);
  3697. }

  3699. /* Convert a native/host siginfo object, into/from the siginfo in the
  3700.    layout of the inferiors' architecture.  */

  3702. static void
  3703. ‌siginfo_fixup (siginfo_t *siginfo, gdb_byte *inf_siginfo, int direction)
  3704. {
  3705.   int done = 0;

  3707.   if (linux_nat_siginfo_fixup != NULL)
  3708.     done = linux_nat_siginfo_fixup (siginfo, inf_siginfo, direction);

  3710.   /* If there was no callback, or the callback didn't do anything,
  3711.      then just do a straight memcpy.  */
  3712.   if (!done)
  3713.     {
  3714.       if (direction == 1)
  3715.         memcpy (siginfo, inf_siginfo, sizeof (siginfo_t));
  3716.       else
  3717.         memcpy (inf_siginfo, siginfo, sizeof (siginfo_t));
  3718.     }
  3719. }

  3721. static enum target_xfer_status
  3722. ‌linux_xfer_siginfo (struct target_ops *ops, enum target_object object,
  3723.                     const char *annex, gdb_byte *readbuf,
  3724.                     const gdb_byte *writebuf, ULONGEST offset, ULONGEST len,
  3725.                     ULONGEST *xfered_len)
  3726. {
  3727.   int pid;
  3728.   siginfo_t siginfo;
  3729.   gdb_byte inf_siginfo[sizeof (siginfo_t)];

  3731.   gdb_assert (object == TARGET_OBJECT_SIGNAL_INFO);
  3732.   gdb_assert (readbuf || writebuf);

  3734.   pid = ptid_get_lwp (inferior_ptid);
  3735.   if (pid == 0)
  3736.     pid = ptid_get_pid (inferior_ptid);

  3738.   if (offset > sizeof (siginfo))
  3739.     return TARGET_XFER_E_IO;

  3741.   errno = 0;
  3742.   ptrace (PTRACE_GETSIGINFO, pid, (PTRACE_TYPE_ARG3) 0, &siginfo);
  3743.   if (errno != 0)
  3744.     return TARGET_XFER_E_IO;

  3746.   /* When GDB is built as a 64-bit application, ptrace writes into
  3747.      SIGINFO an object with 64-bit layout.  Since debugging a 32-bit
  3748.      inferior with a 64-bit GDB should look the same as debugging it
  3749.      with a 32-bit GDB, we need to convert it.  GDB core always sees
  3750.      the converted layout, so any read/write will have to be done
  3751.      post-conversion.  */
  3752.   siginfo_fixup (&siginfo, inf_siginfo, 0);

  3754.   if (offset + len > sizeof (siginfo))
  3755.     len = sizeof (siginfo) - offset;

  3757.   if (readbuf != NULL)
  3758.     memcpy (readbuf, inf_siginfo + offset, len);
  3759.   else
  3760.     {
  3761.       memcpy (inf_siginfo + offset, writebuf, len);

  3763.       /* Convert back to ptrace layout before flushing it out.  */
  3764.       siginfo_fixup (&siginfo, inf_siginfo, 1);

  3766.       errno = 0;
  3767.       ptrace (PTRACE_SETSIGINFO, pid, (PTRACE_TYPE_ARG3) 0, &siginfo);
  3768.       if (errno != 0)
  3769.         return TARGET_XFER_E_IO;
  3770.     }

  3772.   *xfered_len = len;
  3773.   return TARGET_XFER_OK;
  3774. }

  3776. static enum target_xfer_status
  3777. ‌linux_nat_xfer_partial (struct target_ops *ops, enum target_object object,
  3778.                         const char *annex, gdb_byte *readbuf,
  3779.                         const gdb_byte *writebuf,
  3780.                         ULONGEST offset, ULONGEST len, ULONGEST *xfered_len)
  3781. {
  3782.   struct cleanup *old_chain;
  3783.   enum target_xfer_status xfer;

  3785.   if (object == TARGET_OBJECT_SIGNAL_INFO)
  3786.     return linux_xfer_siginfo (ops, object, annex, readbuf, writebuf,
  3787.                                offset, len, xfered_len);

  3789.   /* The target is connected but no live inferior is selected.  Pass
  3790.      this request down to a lower stratum (e.g., the executable
  3791.      file).  */
  3792.   if (object == TARGET_OBJECT_MEMORY && ptid_equal (inferior_ptid, null_ptid))
  3793.     return TARGET_XFER_EOF;

  3795.   old_chain = save_inferior_ptid ();

  3797.   if (ptid_lwp_p (inferior_ptid))
  3798.     inferior_ptid = pid_to_ptid (ptid_get_lwp (inferior_ptid));

  3800.   xfer = linux_ops->to_xfer_partial (ops, object, annex, readbuf, writebuf,
  3801.                                      offset, len, xfered_len);

  3803.   do_cleanups (old_chain);
  3804.   return xfer;
  3805. }

  3807. static int
  3808. ‌linux_thread_alive (ptid_t ptid)
  3809. {
  3810.   int err, tmp_errno;

  3812.   gdb_assert (ptid_lwp_p (ptid));

  3814.   /* Send signal 0 instead of anything ptrace, because ptracing a
  3815.      running thread errors out claiming that the thread doesn't
  3816.      exist.  */
  3817.   err = kill_lwp (ptid_get_lwp (ptid), 0);
  3818.   tmp_errno = errno;
  3819.   if (debug_linux_nat)
  3820.     fprintf_unfiltered (gdb_stdlog,
  3821.                         "LLTA: KILL(SIG0) %s (%s)\n",
  3822.                         target_pid_to_str (ptid),
  3823.                         err ? safe_strerror (tmp_errno) : "OK");

  3825.   if (err != 0)
  3826.     return 0;

  3828.   return 1;
  3829. }

  3831. static int
  3832. ‌linux_nat_thread_alive (struct target_ops *ops, ptid_t ptid)
  3833. {
  3834.   return linux_thread_alive (ptid);
  3835. }

  3837. static char *
  3838. ‌linux_nat_pid_to_str (struct target_ops *ops, ptid_t ptid)
  3839. {
  3840.   static char buf[64];

  3842.   if (ptid_lwp_p (ptid)
  3843.       && (ptid_get_pid (ptid) != ptid_get_lwp (ptid)
  3844.           || num_lwps (ptid_get_pid (ptid)) > 1))
  3845.     {
  3846.       snprintf (buf, sizeof (buf), "LWP %ld", ptid_get_lwp (ptid));
  3847.       return buf;
  3848.     }

  3850.   return normal_pid_to_str (ptid);
  3851. }

  3853. static char *
  3854. ‌linux_nat_thread_name (struct target_ops *self, struct thread_info *thr)
  3855. {
  3856.   int pid = ptid_get_pid (thr->ptid);
  3857.   long lwp = ptid_get_lwp (thr->ptid);
  3858. ‌#define FORMAT "/proc/%d/task/%ld/comm"
  3859.   char buf[sizeof (FORMAT) + 30];
  3860.   FILE *comm_file;
  3861.   char *result = NULL;

  3863.   snprintf (buf, sizeof (buf), FORMAT, pid, lwp);
  3864.   comm_file = gdb_fopen_cloexec (buf, "r");
  3865.   if (comm_file)
  3866.     {
  3867.       /* Not exported by the kernel, so we define it here.  */
  3868. ‌#define COMM_LEN 16
  3869.       static char line[COMM_LEN + 1];

  3871.       if (fgets (line, sizeof (line), comm_file))
  3872.         {
  3873.           char *nl = strchr (line, '\n');

  3875.           if (nl)
  3876.             *nl = '\0';
  3877.           if (*line != '\0')
  3878.             result = line;
  3879.         }

  3881.       fclose (comm_file);
  3882.     }

  3884. ‌#undef COMM_LEN
  3885. ‌#undef FORMAT

  3887.   return result;
  3888. }

  3890. /* Accepts an integer PID; Returns a string representing a file that
  3891.    can be opened to get the symbols for the child process.  */

  3893. static char *
  3894. ‌linux_child_pid_to_exec_file (struct target_ops *self, int pid)
  3895. {
  3896.   static char buf[PATH_MAX];
  3897.   char name[PATH_MAX];

  3899.   xsnprintf (name, PATH_MAX, "/proc/%d/exe", pid);
  3900.   memset (buf, 0, PATH_MAX);
  3901.   if (readlink (name, buf, PATH_MAX - 1) <= 0)
  3902.     strcpy (buf, name);

  3904.   return buf;
  3905. }

  3907. /* Implement the to_xfer_partial interface for memory reads using the /proc
  3908.    filesystem.  Because we can use a single read() call for /proc, this
  3909.    can be much more efficient than banging away at PTRACE_PEEKTEXT,
  3910.    but it doesn't support writes.  */

  3912. static enum target_xfer_status
  3913. ‌linux_proc_xfer_partial (struct target_ops *ops, enum target_object object,
  3914.                          const char *annex, gdb_byte *readbuf,
  3915.                          const gdb_byte *writebuf,
  3916.                          ULONGEST offset, LONGEST len, ULONGEST *xfered_len)
  3917. {
  3918.   LONGEST ret;
  3919.   int fd;
  3920.   char filename[64];

  3922.   if (object != TARGET_OBJECT_MEMORY || !readbuf)
  3923.     return 0;

  3925.   /* Don't bother for one word.  */
  3926.   if (len < 3 * sizeof (long))
  3927.     return TARGET_XFER_EOF;

  3929.   /* We could keep this file open and cache it - possibly one per
  3930.      thread.  That requires some juggling, but is even faster.  */
  3931.   xsnprintf (filename, sizeof filename, "/proc/%d/mem",
  3932.              ptid_get_pid (inferior_ptid));
  3933.   fd = gdb_open_cloexec (filename, O_RDONLY | O_LARGEFILE, 0);
  3934.   if (fd == -1)
  3935.     return TARGET_XFER_EOF;

  3937.   /* If pread64 is available, use it.  It's faster if the kernel
  3938.      supports it (only one syscall), and it's 64-bit safe even on
  3939.      32-bit platforms (for instance, SPARC debugging a SPARC64
  3940.      application).  */
  3941. #ifdef HAVE_PREAD64
  3942.   if (pread64 (fd, readbuf, len, offset) != len)
  3943. #else
  3944.   if (lseek (fd, offset, SEEK_SET) == -1 || read (fd, readbuf, len) != len)
  3945. #endif
  3946.     ret = 0;
  3947.   else
  3948.     ret = len;

  3950.   close (fd);

  3952.   if (ret == 0)
  3953.     return TARGET_XFER_EOF;
  3954.   else
  3955.     {
  3956.       *xfered_len = ret;
  3957.       return TARGET_XFER_OK;
  3958.     }
  3959. }


  3962. /* Enumerate spufs IDs for process PID.  */
  3963. static LONGEST
  3964. ‌spu_enumerate_spu_ids (int pid, gdb_byte *buf, ULONGEST offset, ULONGEST len)
  3965. {
  3966.   enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch ());
  3967.   LONGEST pos = 0;
  3968.   LONGEST written = 0;
  3969.   char path[128];
  3970.   DIR *dir;
  3971.   struct dirent *entry;

  3973.   xsnprintf (path, sizeof path, "/proc/%d/fd", pid);
  3974.   dir = opendir (path);
  3975.   if (!dir)
  3976.     return -1;

  3978.   rewinddir (dir);
  3979.   while ((entry = readdir (dir)) != NULL)
  3980.     {
  3981.       struct stat st;
  3982.       struct statfs stfs;
  3983.       int fd;

  3985.       fd = atoi (entry->d_name);
  3986.       if (!fd)
  3987.         continue;

  3989.       xsnprintf (path, sizeof path, "/proc/%d/fd/%d", pid, fd);
  3990.       if (stat (path, &st) != 0)
  3991.         continue;
  3992.       if (!S_ISDIR (st.st_mode))
  3993.         continue;

  3995.       if (statfs (path, &stfs) != 0)
  3996.         continue;
  3997.       if (stfs.f_type != SPUFS_MAGIC)
  3998.         continue;

  4000.       if (pos >= offset && pos + 4 <= offset + len)
  4001.         {
  4002.           store_unsigned_integer (buf + pos - offset, 4, byte_order, fd);
  4003.           written += 4;
  4004.         }
  4005.       pos += 4;
  4006.     }

  4008.   closedir (dir);
  4009.   return written;
  4010. }

  4012. /* Implement the to_xfer_partial interface for the TARGET_OBJECT_SPU
  4013.    object type, using the /proc file system.  */

  4015. static enum target_xfer_status
  4016. ‌linux_proc_xfer_spu (struct target_ops *ops, enum target_object object,
  4017.                      const char *annex, gdb_byte *readbuf,
  4018.                      const gdb_byte *writebuf,
  4019.                      ULONGEST offset, ULONGEST len, ULONGEST *xfered_len)
  4020. {
  4021.   char buf[128];
  4022.   int fd = 0;
  4023.   int ret = -1;
  4024.   int pid = ptid_get_pid (inferior_ptid);

  4026.   if (!annex)
  4027.     {
  4028.       if (!readbuf)
  4029.         return TARGET_XFER_E_IO;
  4030.       else
  4031.         {
  4032.           LONGEST l = spu_enumerate_spu_ids (pid, readbuf, offset, len);

  4034.           if (l < 0)
  4035.             return TARGET_XFER_E_IO;
  4036.           else if (l == 0)
  4037.             return TARGET_XFER_EOF;
  4038.           else
  4039.             {
  4040.               *xfered_len = (ULONGEST) l;
  4041.               return TARGET_XFER_OK;
  4042.             }
  4043.         }
  4044.     }

  4046.   xsnprintf (buf, sizeof buf, "/proc/%d/fd/%s", pid, annex);
  4047.   fd = gdb_open_cloexec (buf, writebuf? O_WRONLY : O_RDONLY, 0);
  4048.   if (fd <= 0)
  4049.     return TARGET_XFER_E_IO;

  4051.   if (offset != 0
  4052.       && lseek (fd, (off_t) offset, SEEK_SET) != (off_t) offset)
  4053.     {
  4054.       close (fd);
  4055.       return TARGET_XFER_EOF;
  4056.     }

  4058.   if (writebuf)
  4059.     ret = write (fd, writebuf, (size_t) len);
  4060.   else if (readbuf)
  4061.     ret = read (fd, readbuf, (size_t) len);

  4063.   close (fd);

  4065.   if (ret < 0)
  4066.     return TARGET_XFER_E_IO;
  4067.   else if (ret == 0)
  4068.     return TARGET_XFER_EOF;
  4069.   else
  4070.     {
  4071.       *xfered_len = (ULONGEST) ret;
  4072.       return TARGET_XFER_OK;
  4073.     }
  4074. }


  4077. /* Parse LINE as a signal set and add its set bits to SIGS.  */

  4079. static void
  4080. ‌add_line_to_sigset (const char *line, sigset_t *sigs)
  4081. {
  4082.   int len = strlen (line) - 1;
  4083.   const char *p;
  4084.   int signum;

  4086.   if (line[len] != '\n')
  4087.     error (_("Could not parse signal set: %s"), line);

  4089.   p = line;
  4090.   signum = len * 4;
  4091.   while (len-- > 0)
  4092.     {
  4093.       int digit;

  4095.       if (*p >= '0' && *p <= '9')
  4096.         digit = *p - '0';
  4097.       else if (*p >= 'a' && *p <= 'f')
  4098.         digit = *p - 'a' + 10;
  4099.       else
  4100.         error (_("Could not parse signal set: %s"), line);

  4102.       signum -= 4;

  4104.       if (digit & 1)
  4105.         sigaddset (sigs, signum + 1);
  4106.       if (digit & 2)
  4107.         sigaddset (sigs, signum + 2);
  4108.       if (digit & 4)
  4109.         sigaddset (sigs, signum + 3);
  4110.       if (digit & 8)
  4111.         sigaddset (sigs, signum + 4);

  4113.       p++;
  4114.     }
  4115. }

  4117. /* Find process PID's pending signals from /proc/pid/status and set
  4118.    SIGS to match.  */

  4120. void
  4121. ‌linux_proc_pending_signals (int pid, sigset_t *pending,
  4122.                             sigset_t *blocked, sigset_t *ignored)
  4123. {
  4124.   FILE *procfile;
  4125.   char buffer[PATH_MAX], fname[PATH_MAX];
  4126.   struct cleanup *cleanup;

  4128.   sigemptyset (pending);
  4129.   sigemptyset (blocked);
  4130.   sigemptyset (ignored);
  4131.   xsnprintf (fname, sizeof fname, "/proc/%d/status", pid);
  4132.   procfile = gdb_fopen_cloexec (fname, "r");
  4133.   if (procfile == NULL)
  4134.     error (_("Could not open %s"), fname);
  4135.   cleanup = make_cleanup_fclose (procfile);

  4137.   while (fgets (buffer, PATH_MAX, procfile) != NULL)
  4138.     {
  4139.       /* Normal queued signals are on the SigPnd line in the status
  4140.          file.  However, 2.6 kernels also have a "shared" pending
  4141.          queue for delivering signals to a thread group, so check for
  4142.          a ShdPnd line also.

  4144.          Unfortunately some Red Hat kernels include the shared pending
  4145.          queue but not the ShdPnd status field.  */

  4147.       if (strncmp (buffer, "SigPnd:\t", 8) == 0)
  4148.         add_line_to_sigset (buffer + 8, pending);
  4149.       else if (strncmp (buffer, "ShdPnd:\t", 8) == 0)
  4150.         add_line_to_sigset (buffer + 8, pending);
  4151.       else if (strncmp (buffer, "SigBlk:\t", 8) == 0)
  4152.         add_line_to_sigset (buffer + 8, blocked);
  4153.       else if (strncmp (buffer, "SigIgn:\t", 8) == 0)
  4154.         add_line_to_sigset (buffer + 8, ignored);
  4155.     }

  4157.   do_cleanups (cleanup);
  4158. }

  4160. static enum target_xfer_status
  4161. ‌linux_nat_xfer_osdata (struct target_ops *ops, enum target_object object,
  4162.                        const char *annex, gdb_byte *readbuf,
  4163.                        const gdb_byte *writebuf, ULONGEST offset, ULONGEST len,
  4164.                        ULONGEST *xfered_len)
  4165. {
  4166.   gdb_assert (object == TARGET_OBJECT_OSDATA);

  4168.   *xfered_len = linux_common_xfer_osdata (annex, readbuf, offset, len);
  4169.   if (*xfered_len == 0)
  4170.     return TARGET_XFER_EOF;
  4171.   else
  4172.     return TARGET_XFER_OK;
  4173. }

  4175. static enum target_xfer_status
  4176. ‌linux_xfer_partial (struct target_ops *ops, enum target_object object,
  4177.                     const char *annex, gdb_byte *readbuf,
  4178.                     const gdb_byte *writebuf, ULONGEST offset, ULONGEST len,
  4179.                     ULONGEST *xfered_len)
  4180. {
  4181.   enum target_xfer_status xfer;

  4183.   if (object == TARGET_OBJECT_AUXV)
  4184.     return memory_xfer_auxv (ops, object, annex, readbuf, writebuf,
  4185.                              offset, len, xfered_len);

  4187.   if (object == TARGET_OBJECT_OSDATA)
  4188.     return linux_nat_xfer_osdata (ops, object, annex, readbuf, writebuf,
  4189.                                   offset, len, xfered_len);

  4191.   if (object == TARGET_OBJECT_SPU)
  4192.     return linux_proc_xfer_spu (ops, object, annex, readbuf, writebuf,
  4193.                                 offset, len, xfered_len);

  4195.   /* GDB calculates all the addresses in possibly larget width of the address.
  4196.      Address width needs to be masked before its final use - either by
  4197.      linux_proc_xfer_partial or inf_ptrace_xfer_partial.

  4199.      Compare ADDR_BIT first to avoid a compiler warning on shift overflow.  */

  4201.   if (object == TARGET_OBJECT_MEMORY)
  4202.     {
  4203.       int addr_bit = gdbarch_addr_bit (target_gdbarch ());

  4205.       if (addr_bit < (sizeof (ULONGEST) * HOST_CHAR_BIT))
  4206.         offset &= ((ULONGEST) 1 << addr_bit) - 1;
  4207.     }

  4209.   xfer = linux_proc_xfer_partial (ops, object, annex, readbuf, writebuf,
  4210.                                   offset, len, xfered_len);
  4211.   if (xfer != TARGET_XFER_EOF)
  4212.     return xfer;

  4214.   return super_xfer_partial (ops, object, annex, readbuf, writebuf,
  4215.                              offset, len, xfered_len);
  4216. }

  4218. static void
  4219. ‌cleanup_target_stop (void *arg)
  4220. {
  4221.   ptid_t *ptid = (ptid_t *) arg;

  4223.   gdb_assert (arg != NULL);

  4225.   /* Unpause all */
  4226.   target_resume (*ptid, 0, GDB_SIGNAL_0);
  4227. }

  4229. ‌static VEC(static_tracepoint_marker_p) *
  4230. linux_child_static_tracepoint_markers_by_strid (struct target_ops *self,
  4231.                                                 const char *strid)
  4232. {
  4233.   char s[IPA_CMD_BUF_SIZE];
  4234.   struct cleanup *old_chain;
  4235.   int pid = ptid_get_pid (inferior_ptid);
  4236.   VEC(static_tracepoint_marker_p) *markers = NULL;
  4237.   struct static_tracepoint_marker *marker = NULL;
  4238.   char *p = s;
  4239.   ptid_t ptid = ptid_build (pid, 0, 0);

  4241.   /* Pause all */
  4242.   target_stop (ptid);

  4244.   memcpy (s, "qTfSTM", sizeof ("qTfSTM"));
  4245.   s[sizeof ("qTfSTM")] = 0;

  4247.   agent_run_command (pid, s, strlen (s) + 1);

  4249.   old_chain = make_cleanup (free_current_marker, &marker);
  4250.   make_cleanup (cleanup_target_stop, &ptid);

  4252.   while (*p++ == 'm')
  4253.     {
  4254.       if (marker == NULL)
  4255.         marker = XCNEW (struct static_tracepoint_marker);

  4257.       do
  4258.         {
  4259.           parse_static_tracepoint_marker_definition (p, &p, marker);

  4261.           if (strid == NULL || strcmp (strid, marker->str_id) == 0)
  4262.             {
  4263.               VEC_safe_push (static_tracepoint_marker_p,
  4264.                              markers, marker);
  4265.               marker = NULL;
  4266.             }
  4267.           else
  4268.             {
  4269.               release_static_tracepoint_marker (marker);
  4270.               memset (marker, 0, sizeof (*marker));
  4271.             }
  4272.         }
  4273.       while (*p++ == ',');        /* comma-separated list */

  4275.       memcpy (s, "qTsSTM", sizeof ("qTsSTM"));
  4276.       s[sizeof ("qTsSTM")] = 0;
  4277.       agent_run_command (pid, s, strlen (s) + 1);
  4278.       p = s;
  4279.     }

  4281.   do_cleanups (old_chain);

  4283.   return markers;
  4284. }

  4286. /* Create a prototype generic GNU/Linux target.  The client can override
  4287.    it with local methods.  */

  4289. static void
  4290. ‌linux_target_install_ops (struct target_ops *t)
  4291. {
  4292.   t->to_insert_fork_catchpoint = linux_child_insert_fork_catchpoint;
  4293.   t->to_remove_fork_catchpoint = linux_child_remove_fork_catchpoint;
  4294.   t->to_insert_vfork_catchpoint = linux_child_insert_vfork_catchpoint;
  4295.   t->to_remove_vfork_catchpoint = linux_child_remove_vfork_catchpoint;
  4296.   t->to_insert_exec_catchpoint = linux_child_insert_exec_catchpoint;
  4297.   t->to_remove_exec_catchpoint = linux_child_remove_exec_catchpoint;
  4298.   t->to_set_syscall_catchpoint = linux_child_set_syscall_catchpoint;
  4299.   t->to_pid_to_exec_file = linux_child_pid_to_exec_file;
  4300.   t->to_post_startup_inferior = linux_child_post_startup_inferior;
  4301.   t->to_post_attach = linux_child_post_attach;
  4302.   t->to_follow_fork = linux_child_follow_fork;

  4304.   super_xfer_partial = t->to_xfer_partial;
  4305.   t->to_xfer_partial = linux_xfer_partial;

  4307.   t->to_static_tracepoint_markers_by_strid
  4308.     = linux_child_static_tracepoint_markers_by_strid;
  4309. }

  4311. struct target_ops *
  4312. ‌linux_target (void)
  4313. {
  4314.   struct target_ops *t;

  4316.   t = inf_ptrace_target ();
  4317.   linux_target_install_ops (t);

  4319.   return t;
  4320. }

  4322. struct target_ops *
  4323. ‌linux_trad_target (CORE_ADDR (*register_u_offset)(struct gdbarch *, int, int))
  4324. {
  4325.   struct target_ops *t;

  4327.   t = inf_ptrace_trad_target (register_u_offset);
  4328.   linux_target_install_ops (t);

  4330.   return t;
  4331. }

  4333. /* target_is_async_p implementation.  */

  4335. static int
  4336. ‌linux_nat_is_async_p (struct target_ops *ops)
  4337. {
  4338.   /* NOTE: palves 2008-03-21: We're only async when the user requests
  4339.      it explicitly with the "set target-async" command.
  4340.      Someday, linux will always be async.  */
  4341.   return target_async_permitted;
  4342. }

  4344. /* target_can_async_p implementation.  */

  4346. static int
  4347. ‌linux_nat_can_async_p (struct target_ops *ops)
  4348. {
  4349.   /* NOTE: palves 2008-03-21: We're only async when the user requests
  4350.      it explicitly with the "set target-async" command.
  4351.      Someday, linux will always be async.  */
  4352.   return target_async_permitted;
  4353. }

  4355. static int
  4356. ‌linux_nat_supports_non_stop (struct target_ops *self)
  4357. {
  4358.   return 1;
  4359. }

  4361. /* True if we want to support multi-process.  To be removed when GDB
  4362.    supports multi-exec.  */

  4364. ‌int linux_multi_process = 1;

  4366. static int
  4367. ‌linux_nat_supports_multi_process (struct target_ops *self)
  4368. {
  4369.   return linux_multi_process;
  4370. }

  4372. static int
  4373. ‌linux_nat_supports_disable_randomization (struct target_ops *self)
  4374. {
  4375. #ifdef HAVE_PERSONALITY
  4376.   return 1;
  4377. #else
  4378.   return 0;
  4379. #endif
  4380. }

  4382. ‌static int async_terminal_is_ours = 1;

  4384. /* target_terminal_inferior implementation.

  4386.    This is a wrapper around child_terminal_inferior to add async support.  */

  4388. static void
  4389. ‌linux_nat_terminal_inferior (struct target_ops *self)
  4390. {
  4391.   if (!target_is_async_p ())
  4392.     {
  4393.       /* Async mode is disabled.  */
  4394.       child_terminal_inferior (self);
  4395.       return;
  4396.     }

  4398.   child_terminal_inferior (self);

  4400.   /* Calls to target_terminal_*() are meant to be idempotent.  */
  4401.   if (!async_terminal_is_ours)
  4402.     return;

  4404.   delete_file_handler (input_fd);
  4405.   async_terminal_is_ours = 0;
  4406.   set_sigint_trap ();
  4407. }

  4409. /* target_terminal_ours implementation.

  4411.    This is a wrapper around child_terminal_ours to add async support (and
  4412.    implement the target_terminal_ours vs target_terminal_ours_for_output
  4413.    distinction).  child_terminal_ours is currently no different than
  4414.    child_terminal_ours_for_output.
  4415.    We leave target_terminal_ours_for_output alone, leaving it to
  4416.    child_terminal_ours_for_output.  */

  4418. static void
  4419. ‌linux_nat_terminal_ours (struct target_ops *self)
  4420. {
  4421.   if (!target_is_async_p ())
  4422.     {
  4423.       /* Async mode is disabled.  */
  4424.       child_terminal_ours (self);
  4425.       return;
  4426.     }

  4428.   /* GDB should never give the terminal to the inferior if the
  4429.      inferior is running in the background (run&, continue&, etc.),
  4430.      but claiming it sure should.  */
  4431.   child_terminal_ours (self);

  4433.   if (async_terminal_is_ours)
  4434.     return;

  4436.   clear_sigint_trap ();
  4437.   add_file_handler (input_fd, stdin_event_handler, 0);
  4438.   async_terminal_is_ours = 1;
  4439. }

  4441. ‌static void (*async_client_callback) (enum inferior_event_type event_type,
  4442.                                       void *context);
  4443. ‌static void *async_client_context;

  4445. /* SIGCHLD handler that serves two purposes: In non-stop/async mode,
  4446.    so we notice when any child changes state, and notify the
  4447.    event-loop; it allows us to use sigsuspend in linux_nat_wait_1
  4448.    above to wait for the arrival of a SIGCHLD.  */

  4450. static void
  4451. ‌sigchld_handler (int signo)
  4452. {
  4453.   int old_errno = errno;

  4455.   if (debug_linux_nat)
  4456.     ui_file_write_async_safe (gdb_stdlog,
  4457.                               "sigchld\n", sizeof ("sigchld\n") - 1);

  4459.   if (signo == SIGCHLD
  4460.       && linux_nat_event_pipe[0] != -1)
  4461.     async_file_mark (); /* Let the event loop know that there are
  4462.                            events to handle.  */

  4464.   errno = old_errno;
  4465. }

  4467. /* Callback registered with the target events file descriptor.  */

  4469. static void
  4470. ‌handle_target_event (int error, gdb_client_data client_data)
  4471. {
  4472.   (*async_client_callback) (INF_REG_EVENT, async_client_context);
  4473. }

  4475. /* Create/destroy the target events pipe.  Returns previous state.  */

  4477. static int
  4478. ‌linux_async_pipe (int enable)
  4479. {
  4480.   int previous = (linux_nat_event_pipe[0] != -1);

  4482.   if (previous != enable)
  4483.     {
  4484.       sigset_t prev_mask;

  4486.       /* Block child signals while we create/destroy the pipe, as
  4487.          their handler writes to it.  */
  4488.       block_child_signals (&prev_mask);

  4490.       if (enable)
  4491.         {
  4492.           if (gdb_pipe_cloexec (linux_nat_event_pipe) == -1)
  4493.             internal_error (__FILE__, __LINE__,
  4494.                             "creating event pipe failed.");

  4496.           fcntl (linux_nat_event_pipe[0], F_SETFL, O_NONBLOCK);
  4497.           fcntl (linux_nat_event_pipe[1], F_SETFL, O_NONBLOCK);
  4498.         }
  4499.       else
  4500.         {
  4501.           close (linux_nat_event_pipe[0]);
  4502.           close (linux_nat_event_pipe[1]);
  4503.           linux_nat_event_pipe[0] = -1;
  4504.           linux_nat_event_pipe[1] = -1;
  4505.         }

  4507.       restore_child_signals_mask (&prev_mask);
  4508.     }

  4510.   return previous;
  4511. }

  4513. /* target_async implementation.  */

  4515. static void
  4516. ‌linux_nat_async (struct target_ops *ops,
  4517.                  void (*callback) (enum inferior_event_type event_type,
  4518.                                    void *context),
  4519.                  void *context)
  4520. {
  4521.   if (callback != NULL)
  4522.     {
  4523.       async_client_callback = callback;
  4524.       async_client_context = context;
  4525.       if (!linux_async_pipe (1))
  4526.         {
  4527.           add_file_handler (linux_nat_event_pipe[0],
  4528.                             handle_target_event, NULL);
  4529.           /* There may be pending events to handle.  Tell the event loop
  4530.              to poll them.  */
  4531.           async_file_mark ();
  4532.         }
  4533.     }
  4534.   else
  4535.     {
  4536.       async_client_callback = callback;
  4537.       async_client_context = context;
  4538.       delete_file_handler (linux_nat_event_pipe[0]);
  4539.       linux_async_pipe (0);
  4540.     }
  4541.   return;
  4542. }

  4544. /* Stop an LWP, and push a GDB_SIGNAL_0 stop status if no other
  4545.    event came out.  */

  4547. static int
  4548. ‌linux_nat_stop_lwp (struct lwp_info *lwp, void *data)
  4549. {
  4550.   if (!lwp->stopped)
  4551.     {
  4552.       if (debug_linux_nat)
  4553.         fprintf_unfiltered (gdb_stdlog,
  4554.                             "LNSL: running -> suspending %s\n",
  4555.                             target_pid_to_str (lwp->ptid));


  4558.       if (lwp->last_resume_kind == resume_stop)
  4559.         {
  4560.           if (debug_linux_nat)
  4561.             fprintf_unfiltered (gdb_stdlog,
  4562.                                 "linux-nat: already stopping LWP %ld at "
  4563.                                 "GDB's request\n",
  4564.                                 ptid_get_lwp (lwp->ptid));
  4565.           return 0;
  4566.         }

  4568.       stop_callback (lwp, NULL);
  4569.       lwp->last_resume_kind = resume_stop;
  4570.     }
  4571.   else
  4572.     {
  4573.       /* Already known to be stopped; do nothing.  */

  4575.       if (debug_linux_nat)
  4576.         {
  4577.           if (find_thread_ptid (lwp->ptid)->stop_requested)
  4578.             fprintf_unfiltered (gdb_stdlog,
  4579.                                 "LNSL: already stopped/stop_requested %s\n",
  4580.                                 target_pid_to_str (lwp->ptid));
  4581.           else
  4582.             fprintf_unfiltered (gdb_stdlog,
  4583.                                 "LNSL: already stopped/no "
  4584.                                 "stop_requested yet %s\n",
  4585.                                 target_pid_to_str (lwp->ptid));
  4586.         }
  4587.     }
  4588.   return 0;
  4589. }

  4591. static void
  4592. ‌linux_nat_stop (struct target_ops *self, ptid_t ptid)
  4593. {
  4594.   if (non_stop)
  4595.     iterate_over_lwps (ptid, linux_nat_stop_lwp, NULL);
  4596.   else
  4597.     linux_ops->to_stop (linux_ops, ptid);
  4598. }

  4600. static void
  4601. ‌linux_nat_close (struct target_ops *self)
  4602. {
  4603.   /* Unregister from the event loop.  */
  4604.   if (linux_nat_is_async_p (self))
  4605.     linux_nat_async (self, NULL, NULL);

  4607.   if (linux_ops->to_close)
  4608.     linux_ops->to_close (linux_ops);

  4610.   super_close (self);
  4611. }

  4613. /* When requests are passed down from the linux-nat layer to the
  4614.    single threaded inf-ptrace layer, ptids of (lwpid,0,0) form are
  4615.    used.  The address space pointer is stored in the inferior object,
  4616.    but the common code that is passed such ptid can't tell whether
  4617.    lwpid is a "main" process id or not (it assumes so).  We reverse
  4618.    look up the "main" process id from the lwp here.  */

  4620. static struct address_space *
  4621. ‌linux_nat_thread_address_space (struct target_ops *t, ptid_t ptid)
  4622. {
  4623.   struct lwp_info *lwp;
  4624.   struct inferior *inf;
  4625.   int pid;

  4627.   if (ptid_get_lwp (ptid) == 0)
  4628.     {
  4629.       /* An (lwpid,0,0) ptid.  Look up the lwp object to get at the
  4630.          tgid.  */
  4631.       lwp = find_lwp_pid (ptid);
  4632.       pid = ptid_get_pid (lwp->ptid);
  4633.     }
  4634.   else
  4635.     {
  4636.       /* A (pid,lwpid,0) ptid.  */
  4637.       pid = ptid_get_pid (ptid);
  4638.     }

  4640.   inf = find_inferior_pid (pid);
  4641.   gdb_assert (inf != NULL);
  4642.   return inf->aspace;
  4643. }

  4645. /* Return the cached value of the processor core for thread PTID.  */

  4647. static int
  4648. ‌linux_nat_core_of_thread (struct target_ops *ops, ptid_t ptid)
  4649. {
  4650.   struct lwp_info *info = find_lwp_pid (ptid);

  4652.   if (info)
  4653.     return info->core;
  4654.   return -1;
  4655. }

  4657. void
  4658. ‌linux_nat_add_target (struct target_ops *t)
  4659. {
  4660.   /* Save the provided single-threaded target.  We save this in a separate
  4661.      variable because another target we've inherited from (e.g. inf-ptrace)
  4662.      may have saved a pointer to T; we want to use it for the final
  4663.      process stratum target.  */
  4664.   linux_ops_saved = *t;
  4665.   linux_ops = &linux_ops_saved;

  4667.   /* Override some methods for multithreading.  */
  4668.   t->to_create_inferior = linux_nat_create_inferior;
  4669.   t->to_attach = linux_nat_attach;
  4670.   t->to_detach = linux_nat_detach;
  4671.   t->to_resume = linux_nat_resume;
  4672.   t->to_wait = linux_nat_wait;
  4673.   t->to_pass_signals = linux_nat_pass_signals;
  4674.   t->to_xfer_partial = linux_nat_xfer_partial;
  4675.   t->to_kill = linux_nat_kill;
  4676.   t->to_mourn_inferior = linux_nat_mourn_inferior;
  4677.   t->to_thread_alive = linux_nat_thread_alive;
  4678.   t->to_pid_to_str = linux_nat_pid_to_str;
  4679.   t->to_thread_name = linux_nat_thread_name;
  4680.   t->to_has_thread_control = tc_schedlock;
  4681.   t->to_thread_address_space = linux_nat_thread_address_space;
  4682.   t->to_stopped_by_watchpoint = linux_nat_stopped_by_watchpoint;
  4683.   t->to_stopped_data_address = linux_nat_stopped_data_address;

  4685.   t->to_can_async_p = linux_nat_can_async_p;
  4686.   t->to_is_async_p = linux_nat_is_async_p;
  4687.   t->to_supports_non_stop = linux_nat_supports_non_stop;
  4688.   t->to_async = linux_nat_async;
  4689.   t->to_terminal_inferior = linux_nat_terminal_inferior;
  4690.   t->to_terminal_ours = linux_nat_terminal_ours;

  4692.   super_close = t->to_close;
  4693.   t->to_close = linux_nat_close;

  4695.   /* Methods for non-stop support.  */
  4696.   t->to_stop = linux_nat_stop;

  4698.   t->to_supports_multi_process = linux_nat_supports_multi_process;

  4700.   t->to_supports_disable_randomization
  4701.     = linux_nat_supports_disable_randomization;

  4703.   t->to_core_of_thread = linux_nat_core_of_thread;

  4705.   /* We don't change the stratum; this target will sit at
  4706.      process_stratum and thread_db will set at thread_stratum.  This
  4707.      is a little strange, since this is a multi-threaded-capable
  4708.      target, but we want to be on the stack below thread_db, and we
  4709.      also want to be used for single-threaded processes.  */

  4711.   add_target (t);
  4712. }

  4714. /* Register a method to call whenever a new thread is attached.  */
  4715. void
  4716. ‌linux_nat_set_new_thread (struct target_ops *t,
  4717.                           void (*new_thread) (struct lwp_info *))
  4718. {
  4719.   /* Save the pointer.  We only support a single registered instance
  4720.      of the GNU/Linux native target, so we do not need to map this to
  4721.      T.  */
  4722.   linux_nat_new_thread = new_thread;
  4723. }

  4725. /* See declaration in linux-nat.h.  */

  4727. void
  4728. ‌linux_nat_set_new_fork (struct target_ops *t,
  4729.                         linux_nat_new_fork_ftype *new_fork)
  4730. {
  4731.   /* Save the pointer.  */
  4732.   linux_nat_new_fork = new_fork;
  4733. }

  4735. /* See declaration in linux-nat.h.  */

  4737. void
  4738. ‌linux_nat_set_forget_process (struct target_ops *t,
  4739.                               linux_nat_forget_process_ftype *fn)
  4740. {
  4741.   /* Save the pointer.  */
  4742.   linux_nat_forget_process_hook = fn;
  4743. }

  4745. /* See declaration in linux-nat.h.  */

  4747. void
  4748. ‌linux_nat_forget_process (pid_t pid)
  4749. {
  4750.   if (linux_nat_forget_process_hook != NULL)
  4751.     linux_nat_forget_process_hook (pid);
  4752. }

  4754. /* Register a method that converts a siginfo object between the layout
  4755.    that ptrace returns, and the layout in the architecture of the
  4756.    inferior.  */
  4757. void
  4758. ‌linux_nat_set_siginfo_fixup (struct target_ops *t,
  4759.                              int (*siginfo_fixup) (siginfo_t *,
  4760.                                                    gdb_byte *,
  4761.                                                    int))
  4762. {
  4763.   /* Save the pointer.  */
  4764.   linux_nat_siginfo_fixup = siginfo_fixup;
  4765. }

  4767. /* Register a method to call prior to resuming a thread.  */

  4769. void
  4770. ‌linux_nat_set_prepare_to_resume (struct target_ops *t,
  4771.                                  void (*prepare_to_resume) (struct lwp_info *))
  4772. {
  4773.   /* Save the pointer.  */
  4774.   linux_nat_prepare_to_resume = prepare_to_resume;
  4775. }

  4777. /* See linux-nat.h.  */

  4779. int
  4780. ‌linux_nat_get_siginfo (ptid_t ptid, siginfo_t *siginfo)
  4781. {
  4782.   int pid;

  4784.   pid = ptid_get_lwp (ptid);
  4785.   if (pid == 0)
  4786.     pid = ptid_get_pid (ptid);

  4788.   errno = 0;
  4789.   ptrace (PTRACE_GETSIGINFO, pid, (PTRACE_TYPE_ARG3) 0, siginfo);
  4790.   if (errno != 0)
  4791.     {
  4792.       memset (siginfo, 0, sizeof (*siginfo));
  4793.       return 0;
  4794.     }
  4795.   return 1;
  4796. }

  4798. /* Provide a prototype to silence -Wmissing-prototypes.  */
  4799. extern initialize_file_ftype _initialize_linux_nat;

  4801. void
  4802. ‌_initialize_linux_nat (void)
  4803. {
  4804.   add_setshow_zuinteger_cmd ("lin-lwp", class_maintenance,
  4805.                              &debug_linux_nat, _("\
  4806. Set debugging of GNU/Linux lwp module."), _("\
  4807. Show debugging of GNU/Linux lwp module."), _("\
  4808. Enables printf debugging output."),
  4809.                              NULL,
  4810.                              show_debug_linux_nat,
  4811.                              &setdebuglist, &showdebuglist);

  4813.   /* Save this mask as the default.  */
  4814.   sigprocmask (SIG_SETMASK, NULL, &normal_mask);

  4816.   /* Install a SIGCHLD handler.  */
  4817.   sigchld_action.sa_handler = sigchld_handler;
  4818.   sigemptyset (&sigchld_action.sa_mask);
  4819.   sigchld_action.sa_flags = SA_RESTART;

  4821.   /* Make it the default.  */
  4822.   sigaction (SIGCHLD, &sigchld_action, NULL);

  4824.   /* Make sure we don't block SIGCHLD during a sigsuspend.  */
  4825.   sigprocmask (SIG_SETMASK, NULL, &suspend_mask);
  4826.   sigdelset (&suspend_mask, SIGCHLD);

  4828.   sigemptyset (&blocked_mask);

  4830.   /* Do not enable PTRACE_O_TRACEEXIT until GDB is more prepared to
  4831.      support read-only process state.  */
  4832.   linux_ptrace_set_additional_flags (PTRACE_O_TRACESYSGOOD
  4833.                                      | PTRACE_O_TRACEVFORKDONE
  4834.                                      | PTRACE_O_TRACEVFORK
  4835.                                      | PTRACE_O_TRACEFORK
  4836.                                      | PTRACE_O_TRACEEXEC);
  4837. }


  4840. /* FIXME: kettenis/2000-08-26: The stuff on this page is specific to
  4841.    the GNU/Linux Threads library and therefore doesn't really belong
  4842.    here.  */

  4844. /* Read variable NAME in the target and return its value if found.
  4845.    Otherwise return zero.  It is assumed that the type of the variable
  4846.    is `int'.  */

  4848. static int
  4849. ‌get_signo (const char *name)
  4850. {
  4851.   struct bound_minimal_symbol ms;
  4852.   int signo;

  4854.   ms = lookup_minimal_symbol (name, NULL, NULL);
  4855.   if (ms.minsym == NULL)
  4856.     return 0;

  4858.   if (target_read_memory (BMSYMBOL_VALUE_ADDRESS (ms), (gdb_byte *) &signo,
  4859.                           sizeof (signo)) != 0)
  4860.     return 0;

  4862.   return signo;
  4863. }

  4865. /* Return the set of signals used by the threads library in *SET.  */

  4867. void
  4868. ‌lin_thread_get_thread_signals (sigset_t *set)
  4869. {
  4870.   struct sigaction action;
  4871.   int restart, cancel;

  4873.   sigemptyset (&blocked_mask);
  4874.   sigemptyset (set);

  4876.   restart = get_signo ("__pthread_sig_restart");
  4877.   cancel = get_signo ("__pthread_sig_cancel");

  4879.   /* LinuxThreads normally uses the first two RT signals, but in some legacy
  4880.      cases may use SIGUSR1/SIGUSR2.  NPTL always uses RT signals, but does
  4881.      not provide any way for the debugger to query the signal numbers -
  4882.      fortunately they don't change!  */

  4884.   if (restart == 0)
  4885.     restart = __SIGRTMIN;

  4887.   if (cancel == 0)
  4888.     cancel = __SIGRTMIN + 1;

  4890.   sigaddset (set, restart);
  4891.   sigaddset (set, cancel);

  4893.   /* The GNU/Linux Threads library makes terminating threads send a
  4894.      special "cancel" signal instead of SIGCHLD.  Make sure we catch
  4895.      those (to prevent them from terminating GDB itself, which is
  4896.      likely to be their default action) and treat them the same way as
  4897.      SIGCHLD.  */

  4899.   action.sa_handler = sigchld_handler;
  4900.   sigemptyset (&action.sa_mask);
  4901.   action.sa_flags = SA_RESTART;
  4902.   sigaction (cancel, &action, NULL);

  4904.   /* We block the "cancel" signal throughout this code ...  */
  4905.   sigaddset (&blocked_mask, cancel);
  4906.   sigprocmask (SIG_BLOCK, &blocked_mask, NULL);

  4908.   /* ... except during a sigsuspend.  */
  4909.   sigdelset (&suspend_mask, cancel);
  4910. }