linux-nat: Eliminate custom target_terminal_{inferior,ours}, stop using set_sigint_trap
[external/binutils.git] / gdb / linux-nat.c
1 /* GNU/Linux native-dependent code common to multiple platforms.
2
3    Copyright (C) 2001-2018 Free Software Foundation, Inc.
4
5    This file is part of GDB.
6
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.
11
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.
16
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/>.  */
19
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 #include <unistd.h>
28 #include <sys/syscall.h>
29 #include "nat/gdb_ptrace.h"
30 #include "linux-nat.h"
31 #include "nat/linux-ptrace.h"
32 #include "nat/linux-procfs.h"
33 #include "nat/linux-personality.h"
34 #include "linux-fork.h"
35 #include "gdbthread.h"
36 #include "gdbcmd.h"
37 #include "regcache.h"
38 #include "regset.h"
39 #include "inf-child.h"
40 #include "inf-ptrace.h"
41 #include "auxv.h"
42 #include <sys/procfs.h>         /* for elf_gregset etc.  */
43 #include "elf-bfd.h"            /* for elfcore_write_* */
44 #include "gregset.h"            /* for gregset */
45 #include "gdbcore.h"            /* for get_exec_file */
46 #include <ctype.h>              /* for isdigit */
47 #include <sys/stat.h>           /* for struct stat */
48 #include <fcntl.h>              /* for O_RDONLY */
49 #include "inf-loop.h"
50 #include "event-loop.h"
51 #include "event-top.h"
52 #include <pwd.h>
53 #include <sys/types.h>
54 #include <dirent.h>
55 #include "xml-support.h"
56 #include <sys/vfs.h>
57 #include "solib.h"
58 #include "nat/linux-osdata.h"
59 #include "linux-tdep.h"
60 #include "symfile.h"
61 #include "agent.h"
62 #include "tracepoint.h"
63 #include "buffer.h"
64 #include "target-descriptions.h"
65 #include "filestuff.h"
66 #include "objfiles.h"
67 #include "nat/linux-namespaces.h"
68 #include "fileio.h"
69
70 #ifndef SPUFS_MAGIC
71 #define SPUFS_MAGIC 0x23c9b64e
72 #endif
73
74 /* This comment documents high-level logic of this file.
75
76 Waiting for events in sync mode
77 ===============================
78
79 When waiting for an event in a specific thread, we just use waitpid,
80 passing the specific pid, and not passing WNOHANG.
81
82 When waiting for an event in all threads, waitpid is not quite good:
83
84 - If the thread group leader exits while other threads in the thread
85   group still exist, waitpid(TGID, ...) hangs.  That waitpid won't
86   return an exit status until the other threads in the group are
87   reaped.
88
89 - When a non-leader thread execs, that thread just vanishes without
90   reporting an exit (so we'd hang if we waited for it explicitly in
91   that case).  The exec event is instead reported to the TGID pid.
92
93 The solution is to always use -1 and WNOHANG, together with
94 sigsuspend.
95
96 First, we use non-blocking waitpid to check for events.  If nothing is
97 found, we use sigsuspend to wait for SIGCHLD.  When SIGCHLD arrives,
98 it means something happened to a child process.  As soon as we know
99 there's an event, we get back to calling nonblocking waitpid.
100
101 Note that SIGCHLD should be blocked between waitpid and sigsuspend
102 calls, so that we don't miss a signal.  If SIGCHLD arrives in between,
103 when it's blocked, the signal becomes pending and sigsuspend
104 immediately notices it and returns.
105
106 Waiting for events in async mode (TARGET_WNOHANG)
107 =================================================
108
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).
122
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.
128
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.
135
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.
143
144 Use of signals
145 ==============
146
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.
152
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.
157
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).
161
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.
167
168 Exec events
169 ===========
170
171 The case of a thread group (process) with 3 or more threads, and a
172 thread other than the leader execs is worth detailing:
173
174 On an exec, the Linux kernel destroys all threads except the execing
175 one in the thread group, and resets the execing thread's tid to the
176 tgid.  No exit notification is sent for the execing thread -- from the
177 ptracer's perspective, it appears as though the execing thread just
178 vanishes.  Until we reap all other threads except the leader and the
179 execing thread, the leader will be zombie, and the execing thread will
180 be in `D (disc sleep)' state.  As soon as all other threads are
181 reaped, the execing thread changes its tid to the tgid, and the
182 previous (zombie) leader vanishes, giving place to the "new"
183 leader.  */
184
185 #ifndef O_LARGEFILE
186 #define O_LARGEFILE 0
187 #endif
188
189 /* Does the current host support PTRACE_GETREGSET?  */
190 enum tribool have_ptrace_getregset = TRIBOOL_UNKNOWN;
191
192 /* The single-threaded native GNU/Linux target_ops.  We save a pointer for
193    the use of the multi-threaded target.  */
194 static struct target_ops *linux_ops;
195 static struct target_ops linux_ops_saved;
196
197 /* The method to call, if any, when a new thread is attached.  */
198 static void (*linux_nat_new_thread) (struct lwp_info *);
199
200 /* The method to call, if any, when a thread is destroyed.  */
201 static void (*linux_nat_delete_thread) (struct arch_lwp_info *);
202
203 /* The method to call, if any, when a new fork is attached.  */
204 static linux_nat_new_fork_ftype *linux_nat_new_fork;
205
206 /* The method to call, if any, when a process is no longer
207    attached.  */
208 static linux_nat_forget_process_ftype *linux_nat_forget_process_hook;
209
210 /* Hook to call prior to resuming a thread.  */
211 static void (*linux_nat_prepare_to_resume) (struct lwp_info *);
212
213 /* The method to call, if any, when the siginfo object needs to be
214    converted between the layout returned by ptrace, and the layout in
215    the architecture of the inferior.  */
216 static int (*linux_nat_siginfo_fixup) (siginfo_t *,
217                                        gdb_byte *,
218                                        int);
219
220 /* The saved to_xfer_partial method, inherited from inf-ptrace.c.
221    Called by our to_xfer_partial.  */
222 static target_xfer_partial_ftype *super_xfer_partial;
223
224 /* The saved to_close method, inherited from inf-ptrace.c.
225    Called by our to_close.  */
226 static void (*super_close) (struct target_ops *);
227
228 static unsigned int debug_linux_nat;
229 static void
230 show_debug_linux_nat (struct ui_file *file, int from_tty,
231                       struct cmd_list_element *c, const char *value)
232 {
233   fprintf_filtered (file, _("Debugging of GNU/Linux lwp module is %s.\n"),
234                     value);
235 }
236
237 struct simple_pid_list
238 {
239   int pid;
240   int status;
241   struct simple_pid_list *next;
242 };
243 struct simple_pid_list *stopped_pids;
244
245 /* Whether target_thread_events is in effect.  */
246 static int report_thread_events;
247
248 /* Async mode support.  */
249
250 /* The read/write ends of the pipe registered as waitable file in the
251    event loop.  */
252 static int linux_nat_event_pipe[2] = { -1, -1 };
253
254 /* True if we're currently in async mode.  */
255 #define linux_is_async_p() (linux_nat_event_pipe[0] != -1)
256
257 /* Flush the event pipe.  */
258
259 static void
260 async_file_flush (void)
261 {
262   int ret;
263   char buf;
264
265   do
266     {
267       ret = read (linux_nat_event_pipe[0], &buf, 1);
268     }
269   while (ret >= 0 || (ret == -1 && errno == EINTR));
270 }
271
272 /* Put something (anything, doesn't matter what, or how much) in event
273    pipe, so that the select/poll in the event-loop realizes we have
274    something to process.  */
275
276 static void
277 async_file_mark (void)
278 {
279   int ret;
280
281   /* It doesn't really matter what the pipe contains, as long we end
282      up with something in it.  Might as well flush the previous
283      left-overs.  */
284   async_file_flush ();
285
286   do
287     {
288       ret = write (linux_nat_event_pipe[1], "+", 1);
289     }
290   while (ret == -1 && errno == EINTR);
291
292   /* Ignore EAGAIN.  If the pipe is full, the event loop will already
293      be awakened anyway.  */
294 }
295
296 static int kill_lwp (int lwpid, int signo);
297
298 static int stop_callback (struct lwp_info *lp, void *data);
299 static int resume_stopped_resumed_lwps (struct lwp_info *lp, void *data);
300
301 static void block_child_signals (sigset_t *prev_mask);
302 static void restore_child_signals_mask (sigset_t *prev_mask);
303
304 struct lwp_info;
305 static struct lwp_info *add_lwp (ptid_t ptid);
306 static void purge_lwp_list (int pid);
307 static void delete_lwp (ptid_t ptid);
308 static struct lwp_info *find_lwp_pid (ptid_t ptid);
309
310 static int lwp_status_pending_p (struct lwp_info *lp);
311
312 static int sigtrap_is_event (int status);
313 static int (*linux_nat_status_is_event) (int status) = sigtrap_is_event;
314
315 static void save_stop_reason (struct lwp_info *lp);
316
317 \f
318 /* LWP accessors.  */
319
320 /* See nat/linux-nat.h.  */
321
322 ptid_t
323 ptid_of_lwp (struct lwp_info *lwp)
324 {
325   return lwp->ptid;
326 }
327
328 /* See nat/linux-nat.h.  */
329
330 void
331 lwp_set_arch_private_info (struct lwp_info *lwp,
332                            struct arch_lwp_info *info)
333 {
334   lwp->arch_private = info;
335 }
336
337 /* See nat/linux-nat.h.  */
338
339 struct arch_lwp_info *
340 lwp_arch_private_info (struct lwp_info *lwp)
341 {
342   return lwp->arch_private;
343 }
344
345 /* See nat/linux-nat.h.  */
346
347 int
348 lwp_is_stopped (struct lwp_info *lwp)
349 {
350   return lwp->stopped;
351 }
352
353 /* See nat/linux-nat.h.  */
354
355 enum target_stop_reason
356 lwp_stop_reason (struct lwp_info *lwp)
357 {
358   return lwp->stop_reason;
359 }
360
361 /* See nat/linux-nat.h.  */
362
363 int
364 lwp_is_stepping (struct lwp_info *lwp)
365 {
366   return lwp->step;
367 }
368
369 \f
370 /* Trivial list manipulation functions to keep track of a list of
371    new stopped processes.  */
372 static void
373 add_to_pid_list (struct simple_pid_list **listp, int pid, int status)
374 {
375   struct simple_pid_list *new_pid = XNEW (struct simple_pid_list);
376
377   new_pid->pid = pid;
378   new_pid->status = status;
379   new_pid->next = *listp;
380   *listp = new_pid;
381 }
382
383 static int
384 pull_pid_from_list (struct simple_pid_list **listp, int pid, int *statusp)
385 {
386   struct simple_pid_list **p;
387
388   for (p = listp; *p != NULL; p = &(*p)->next)
389     if ((*p)->pid == pid)
390       {
391         struct simple_pid_list *next = (*p)->next;
392
393         *statusp = (*p)->status;
394         xfree (*p);
395         *p = next;
396         return 1;
397       }
398   return 0;
399 }
400
401 /* Return the ptrace options that we want to try to enable.  */
402
403 static int
404 linux_nat_ptrace_options (int attached)
405 {
406   int options = 0;
407
408   if (!attached)
409     options |= PTRACE_O_EXITKILL;
410
411   options |= (PTRACE_O_TRACESYSGOOD
412               | PTRACE_O_TRACEVFORKDONE
413               | PTRACE_O_TRACEVFORK
414               | PTRACE_O_TRACEFORK
415               | PTRACE_O_TRACEEXEC);
416
417   return options;
418 }
419
420 /* Initialize ptrace warnings and check for supported ptrace
421    features given PID.
422
423    ATTACHED should be nonzero iff we attached to the inferior.  */
424
425 static void
426 linux_init_ptrace (pid_t pid, int attached)
427 {
428   int options = linux_nat_ptrace_options (attached);
429
430   linux_enable_event_reporting (pid, options);
431   linux_ptrace_init_warnings ();
432 }
433
434 static void
435 linux_child_post_attach (struct target_ops *self, int pid)
436 {
437   linux_init_ptrace (pid, 1);
438 }
439
440 static void
441 linux_child_post_startup_inferior (struct target_ops *self, ptid_t ptid)
442 {
443   linux_init_ptrace (ptid_get_pid (ptid), 0);
444 }
445
446 /* Return the number of known LWPs in the tgid given by PID.  */
447
448 static int
449 num_lwps (int pid)
450 {
451   int count = 0;
452   struct lwp_info *lp;
453
454   for (lp = lwp_list; lp; lp = lp->next)
455     if (ptid_get_pid (lp->ptid) == pid)
456       count++;
457
458   return count;
459 }
460
461 /* Call delete_lwp with prototype compatible for make_cleanup.  */
462
463 static void
464 delete_lwp_cleanup (void *lp_voidp)
465 {
466   struct lwp_info *lp = (struct lwp_info *) lp_voidp;
467
468   delete_lwp (lp->ptid);
469 }
470
471 /* Target hook for follow_fork.  On entry inferior_ptid must be the
472    ptid of the followed inferior.  At return, inferior_ptid will be
473    unchanged.  */
474
475 static int
476 linux_child_follow_fork (struct target_ops *ops, int follow_child,
477                          int detach_fork)
478 {
479   if (!follow_child)
480     {
481       struct lwp_info *child_lp = NULL;
482       int status = W_STOPCODE (0);
483       int has_vforked;
484       ptid_t parent_ptid, child_ptid;
485       int parent_pid, child_pid;
486
487       has_vforked = (inferior_thread ()->pending_follow.kind
488                      == TARGET_WAITKIND_VFORKED);
489       parent_ptid = inferior_ptid;
490       child_ptid = inferior_thread ()->pending_follow.value.related_pid;
491       parent_pid = ptid_get_lwp (parent_ptid);
492       child_pid = ptid_get_lwp (child_ptid);
493
494       /* We're already attached to the parent, by default.  */
495       child_lp = add_lwp (child_ptid);
496       child_lp->stopped = 1;
497       child_lp->last_resume_kind = resume_stop;
498
499       /* Detach new forked process?  */
500       if (detach_fork)
501         {
502           struct cleanup *old_chain = make_cleanup (delete_lwp_cleanup,
503                                                     child_lp);
504
505           if (linux_nat_prepare_to_resume != NULL)
506             linux_nat_prepare_to_resume (child_lp);
507
508           /* When debugging an inferior in an architecture that supports
509              hardware single stepping on a kernel without commit
510              6580807da14c423f0d0a708108e6df6ebc8bc83d, the vfork child
511              process starts with the TIF_SINGLESTEP/X86_EFLAGS_TF bits
512              set if the parent process had them set.
513              To work around this, single step the child process
514              once before detaching to clear the flags.  */
515
516           /* Note that we consult the parent's architecture instead of
517              the child's because there's no inferior for the child at
518              this point.  */
519           if (!gdbarch_software_single_step_p (target_thread_architecture
520                                                (parent_ptid)))
521             {
522               linux_disable_event_reporting (child_pid);
523               if (ptrace (PTRACE_SINGLESTEP, child_pid, 0, 0) < 0)
524                 perror_with_name (_("Couldn't do single step"));
525               if (my_waitpid (child_pid, &status, 0) < 0)
526                 perror_with_name (_("Couldn't wait vfork process"));
527             }
528
529           if (WIFSTOPPED (status))
530             {
531               int signo;
532
533               signo = WSTOPSIG (status);
534               if (signo != 0
535                   && !signal_pass_state (gdb_signal_from_host (signo)))
536                 signo = 0;
537               ptrace (PTRACE_DETACH, child_pid, 0, signo);
538             }
539
540           do_cleanups (old_chain);
541         }
542       else
543         {
544           scoped_restore save_inferior_ptid
545             = make_scoped_restore (&inferior_ptid);
546           inferior_ptid = child_ptid;
547
548           /* Let the thread_db layer learn about this new process.  */
549           check_for_thread_db ();
550         }
551
552       if (has_vforked)
553         {
554           struct lwp_info *parent_lp;
555
556           parent_lp = find_lwp_pid (parent_ptid);
557           gdb_assert (linux_supports_tracefork () >= 0);
558
559           if (linux_supports_tracevforkdone ())
560             {
561               if (debug_linux_nat)
562                 fprintf_unfiltered (gdb_stdlog,
563                                     "LCFF: waiting for VFORK_DONE on %d\n",
564                                     parent_pid);
565               parent_lp->stopped = 1;
566
567               /* We'll handle the VFORK_DONE event like any other
568                  event, in target_wait.  */
569             }
570           else
571             {
572               /* We can't insert breakpoints until the child has
573                  finished with the shared memory region.  We need to
574                  wait until that happens.  Ideal would be to just
575                  call:
576                  - ptrace (PTRACE_SYSCALL, parent_pid, 0, 0);
577                  - waitpid (parent_pid, &status, __WALL);
578                  However, most architectures can't handle a syscall
579                  being traced on the way out if it wasn't traced on
580                  the way in.
581
582                  We might also think to loop, continuing the child
583                  until it exits or gets a SIGTRAP.  One problem is
584                  that the child might call ptrace with PTRACE_TRACEME.
585
586                  There's no simple and reliable way to figure out when
587                  the vforked child will be done with its copy of the
588                  shared memory.  We could step it out of the syscall,
589                  two instructions, let it go, and then single-step the
590                  parent once.  When we have hardware single-step, this
591                  would work; with software single-step it could still
592                  be made to work but we'd have to be able to insert
593                  single-step breakpoints in the child, and we'd have
594                  to insert -just- the single-step breakpoint in the
595                  parent.  Very awkward.
596
597                  In the end, the best we can do is to make sure it
598                  runs for a little while.  Hopefully it will be out of
599                  range of any breakpoints we reinsert.  Usually this
600                  is only the single-step breakpoint at vfork's return
601                  point.  */
602
603               if (debug_linux_nat)
604                 fprintf_unfiltered (gdb_stdlog,
605                                     "LCFF: no VFORK_DONE "
606                                     "support, sleeping a bit\n");
607
608               usleep (10000);
609
610               /* Pretend we've seen a PTRACE_EVENT_VFORK_DONE event,
611                  and leave it pending.  The next linux_nat_resume call
612                  will notice a pending event, and bypasses actually
613                  resuming the inferior.  */
614               parent_lp->status = 0;
615               parent_lp->waitstatus.kind = TARGET_WAITKIND_VFORK_DONE;
616               parent_lp->stopped = 1;
617
618               /* If we're in async mode, need to tell the event loop
619                  there's something here to process.  */
620               if (target_is_async_p ())
621                 async_file_mark ();
622             }
623         }
624     }
625   else
626     {
627       struct lwp_info *child_lp;
628
629       child_lp = add_lwp (inferior_ptid);
630       child_lp->stopped = 1;
631       child_lp->last_resume_kind = resume_stop;
632
633       /* Let the thread_db layer learn about this new process.  */
634       check_for_thread_db ();
635     }
636
637   return 0;
638 }
639
640 \f
641 static int
642 linux_child_insert_fork_catchpoint (struct target_ops *self, int pid)
643 {
644   return !linux_supports_tracefork ();
645 }
646
647 static int
648 linux_child_remove_fork_catchpoint (struct target_ops *self, int pid)
649 {
650   return 0;
651 }
652
653 static int
654 linux_child_insert_vfork_catchpoint (struct target_ops *self, int pid)
655 {
656   return !linux_supports_tracefork ();
657 }
658
659 static int
660 linux_child_remove_vfork_catchpoint (struct target_ops *self, int pid)
661 {
662   return 0;
663 }
664
665 static int
666 linux_child_insert_exec_catchpoint (struct target_ops *self, int pid)
667 {
668   return !linux_supports_tracefork ();
669 }
670
671 static int
672 linux_child_remove_exec_catchpoint (struct target_ops *self, int pid)
673 {
674   return 0;
675 }
676
677 static int
678 linux_child_set_syscall_catchpoint (struct target_ops *self,
679                                     int pid, bool needed, int any_count,
680                                     gdb::array_view<const int> syscall_counts)
681 {
682   if (!linux_supports_tracesysgood ())
683     return 1;
684
685   /* On GNU/Linux, we ignore the arguments.  It means that we only
686      enable the syscall catchpoints, but do not disable them.
687
688      Also, we do not use the `syscall_counts' information because we do not
689      filter system calls here.  We let GDB do the logic for us.  */
690   return 0;
691 }
692
693 /* List of known LWPs, keyed by LWP PID.  This speeds up the common
694    case of mapping a PID returned from the kernel to our corresponding
695    lwp_info data structure.  */
696 static htab_t lwp_lwpid_htab;
697
698 /* Calculate a hash from a lwp_info's LWP PID.  */
699
700 static hashval_t
701 lwp_info_hash (const void *ap)
702 {
703   const struct lwp_info *lp = (struct lwp_info *) ap;
704   pid_t pid = ptid_get_lwp (lp->ptid);
705
706   return iterative_hash_object (pid, 0);
707 }
708
709 /* Equality function for the lwp_info hash table.  Compares the LWP's
710    PID.  */
711
712 static int
713 lwp_lwpid_htab_eq (const void *a, const void *b)
714 {
715   const struct lwp_info *entry = (const struct lwp_info *) a;
716   const struct lwp_info *element = (const struct lwp_info *) b;
717
718   return ptid_get_lwp (entry->ptid) == ptid_get_lwp (element->ptid);
719 }
720
721 /* Create the lwp_lwpid_htab hash table.  */
722
723 static void
724 lwp_lwpid_htab_create (void)
725 {
726   lwp_lwpid_htab = htab_create (100, lwp_info_hash, lwp_lwpid_htab_eq, NULL);
727 }
728
729 /* Add LP to the hash table.  */
730
731 static void
732 lwp_lwpid_htab_add_lwp (struct lwp_info *lp)
733 {
734   void **slot;
735
736   slot = htab_find_slot (lwp_lwpid_htab, lp, INSERT);
737   gdb_assert (slot != NULL && *slot == NULL);
738   *slot = lp;
739 }
740
741 /* Head of doubly-linked list of known LWPs.  Sorted by reverse
742    creation order.  This order is assumed in some cases.  E.g.,
743    reaping status after killing alls lwps of a process: the leader LWP
744    must be reaped last.  */
745 struct lwp_info *lwp_list;
746
747 /* Add LP to sorted-by-reverse-creation-order doubly-linked list.  */
748
749 static void
750 lwp_list_add (struct lwp_info *lp)
751 {
752   lp->next = lwp_list;
753   if (lwp_list != NULL)
754     lwp_list->prev = lp;
755   lwp_list = lp;
756 }
757
758 /* Remove LP from sorted-by-reverse-creation-order doubly-linked
759    list.  */
760
761 static void
762 lwp_list_remove (struct lwp_info *lp)
763 {
764   /* Remove from sorted-by-creation-order list.  */
765   if (lp->next != NULL)
766     lp->next->prev = lp->prev;
767   if (lp->prev != NULL)
768     lp->prev->next = lp->next;
769   if (lp == lwp_list)
770     lwp_list = lp->next;
771 }
772
773 \f
774
775 /* Original signal mask.  */
776 static sigset_t normal_mask;
777
778 /* Signal mask for use with sigsuspend in linux_nat_wait, initialized in
779    _initialize_linux_nat.  */
780 static sigset_t suspend_mask;
781
782 /* Signals to block to make that sigsuspend work.  */
783 static sigset_t blocked_mask;
784
785 /* SIGCHLD action.  */
786 struct sigaction sigchld_action;
787
788 /* Block child signals (SIGCHLD and linux threads signals), and store
789    the previous mask in PREV_MASK.  */
790
791 static void
792 block_child_signals (sigset_t *prev_mask)
793 {
794   /* Make sure SIGCHLD is blocked.  */
795   if (!sigismember (&blocked_mask, SIGCHLD))
796     sigaddset (&blocked_mask, SIGCHLD);
797
798   sigprocmask (SIG_BLOCK, &blocked_mask, prev_mask);
799 }
800
801 /* Restore child signals mask, previously returned by
802    block_child_signals.  */
803
804 static void
805 restore_child_signals_mask (sigset_t *prev_mask)
806 {
807   sigprocmask (SIG_SETMASK, prev_mask, NULL);
808 }
809
810 /* Mask of signals to pass directly to the inferior.  */
811 static sigset_t pass_mask;
812
813 /* Update signals to pass to the inferior.  */
814 static void
815 linux_nat_pass_signals (struct target_ops *self,
816                         int numsigs, unsigned char *pass_signals)
817 {
818   int signo;
819
820   sigemptyset (&pass_mask);
821
822   for (signo = 1; signo < NSIG; signo++)
823     {
824       int target_signo = gdb_signal_from_host (signo);
825       if (target_signo < numsigs && pass_signals[target_signo])
826         sigaddset (&pass_mask, signo);
827     }
828 }
829
830 \f
831
832 /* Prototypes for local functions.  */
833 static int stop_wait_callback (struct lwp_info *lp, void *data);
834 static char *linux_child_pid_to_exec_file (struct target_ops *self, int pid);
835 static int resume_stopped_resumed_lwps (struct lwp_info *lp, void *data);
836 static int check_ptrace_stopped_lwp_gone (struct lwp_info *lp);
837
838 \f
839
840 /* Destroy and free LP.  */
841
842 static void
843 lwp_free (struct lwp_info *lp)
844 {
845   /* Let the arch specific bits release arch_lwp_info.  */
846   if (linux_nat_delete_thread != NULL)
847     linux_nat_delete_thread (lp->arch_private);
848   else
849     gdb_assert (lp->arch_private == NULL);
850
851   xfree (lp);
852 }
853
854 /* Traversal function for purge_lwp_list.  */
855
856 static int
857 lwp_lwpid_htab_remove_pid (void **slot, void *info)
858 {
859   struct lwp_info *lp = (struct lwp_info *) *slot;
860   int pid = *(int *) info;
861
862   if (ptid_get_pid (lp->ptid) == pid)
863     {
864       htab_clear_slot (lwp_lwpid_htab, slot);
865       lwp_list_remove (lp);
866       lwp_free (lp);
867     }
868
869   return 1;
870 }
871
872 /* Remove all LWPs belong to PID from the lwp list.  */
873
874 static void
875 purge_lwp_list (int pid)
876 {
877   htab_traverse_noresize (lwp_lwpid_htab, lwp_lwpid_htab_remove_pid, &pid);
878 }
879
880 /* Add the LWP specified by PTID to the list.  PTID is the first LWP
881    in the process.  Return a pointer to the structure describing the
882    new LWP.
883
884    This differs from add_lwp in that we don't let the arch specific
885    bits know about this new thread.  Current clients of this callback
886    take the opportunity to install watchpoints in the new thread, and
887    we shouldn't do that for the first thread.  If we're spawning a
888    child ("run"), the thread executes the shell wrapper first, and we
889    shouldn't touch it until it execs the program we want to debug.
890    For "attach", it'd be okay to call the callback, but it's not
891    necessary, because watchpoints can't yet have been inserted into
892    the inferior.  */
893
894 static struct lwp_info *
895 add_initial_lwp (ptid_t ptid)
896 {
897   struct lwp_info *lp;
898
899   gdb_assert (ptid_lwp_p (ptid));
900
901   lp = XNEW (struct lwp_info);
902
903   memset (lp, 0, sizeof (struct lwp_info));
904
905   lp->last_resume_kind = resume_continue;
906   lp->waitstatus.kind = TARGET_WAITKIND_IGNORE;
907
908   lp->ptid = ptid;
909   lp->core = -1;
910
911   /* Add to sorted-by-reverse-creation-order list.  */
912   lwp_list_add (lp);
913
914   /* Add to keyed-by-pid htab.  */
915   lwp_lwpid_htab_add_lwp (lp);
916
917   return lp;
918 }
919
920 /* Add the LWP specified by PID to the list.  Return a pointer to the
921    structure describing the new LWP.  The LWP should already be
922    stopped.  */
923
924 static struct lwp_info *
925 add_lwp (ptid_t ptid)
926 {
927   struct lwp_info *lp;
928
929   lp = add_initial_lwp (ptid);
930
931   /* Let the arch specific bits know about this new thread.  Current
932      clients of this callback take the opportunity to install
933      watchpoints in the new thread.  We don't do this for the first
934      thread though.  See add_initial_lwp.  */
935   if (linux_nat_new_thread != NULL)
936     linux_nat_new_thread (lp);
937
938   return lp;
939 }
940
941 /* Remove the LWP specified by PID from the list.  */
942
943 static void
944 delete_lwp (ptid_t ptid)
945 {
946   struct lwp_info *lp;
947   void **slot;
948   struct lwp_info dummy;
949
950   dummy.ptid = ptid;
951   slot = htab_find_slot (lwp_lwpid_htab, &dummy, NO_INSERT);
952   if (slot == NULL)
953     return;
954
955   lp = *(struct lwp_info **) slot;
956   gdb_assert (lp != NULL);
957
958   htab_clear_slot (lwp_lwpid_htab, slot);
959
960   /* Remove from sorted-by-creation-order list.  */
961   lwp_list_remove (lp);
962
963   /* Release.  */
964   lwp_free (lp);
965 }
966
967 /* Return a pointer to the structure describing the LWP corresponding
968    to PID.  If no corresponding LWP could be found, return NULL.  */
969
970 static struct lwp_info *
971 find_lwp_pid (ptid_t ptid)
972 {
973   struct lwp_info *lp;
974   int lwp;
975   struct lwp_info dummy;
976
977   if (ptid_lwp_p (ptid))
978     lwp = ptid_get_lwp (ptid);
979   else
980     lwp = ptid_get_pid (ptid);
981
982   dummy.ptid = ptid_build (0, lwp, 0);
983   lp = (struct lwp_info *) htab_find (lwp_lwpid_htab, &dummy);
984   return lp;
985 }
986
987 /* See nat/linux-nat.h.  */
988
989 struct lwp_info *
990 iterate_over_lwps (ptid_t filter,
991                    iterate_over_lwps_ftype callback,
992                    void *data)
993 {
994   struct lwp_info *lp, *lpnext;
995
996   for (lp = lwp_list; lp; lp = lpnext)
997     {
998       lpnext = lp->next;
999
1000       if (ptid_match (lp->ptid, filter))
1001         {
1002           if ((*callback) (lp, data) != 0)
1003             return lp;
1004         }
1005     }
1006
1007   return NULL;
1008 }
1009
1010 /* Update our internal state when changing from one checkpoint to
1011    another indicated by NEW_PTID.  We can only switch single-threaded
1012    applications, so we only create one new LWP, and the previous list
1013    is discarded.  */
1014
1015 void
1016 linux_nat_switch_fork (ptid_t new_ptid)
1017 {
1018   struct lwp_info *lp;
1019
1020   purge_lwp_list (ptid_get_pid (inferior_ptid));
1021
1022   lp = add_lwp (new_ptid);
1023   lp->stopped = 1;
1024
1025   /* This changes the thread's ptid while preserving the gdb thread
1026      num.  Also changes the inferior pid, while preserving the
1027      inferior num.  */
1028   thread_change_ptid (inferior_ptid, new_ptid);
1029
1030   /* We've just told GDB core that the thread changed target id, but,
1031      in fact, it really is a different thread, with different register
1032      contents.  */
1033   registers_changed ();
1034 }
1035
1036 /* Handle the exit of a single thread LP.  */
1037
1038 static void
1039 exit_lwp (struct lwp_info *lp)
1040 {
1041   struct thread_info *th = find_thread_ptid (lp->ptid);
1042
1043   if (th)
1044     {
1045       if (print_thread_events)
1046         printf_unfiltered (_("[%s exited]\n"), target_pid_to_str (lp->ptid));
1047
1048       delete_thread (lp->ptid);
1049     }
1050
1051   delete_lwp (lp->ptid);
1052 }
1053
1054 /* Wait for the LWP specified by LP, which we have just attached to.
1055    Returns a wait status for that LWP, to cache.  */
1056
1057 static int
1058 linux_nat_post_attach_wait (ptid_t ptid, int *signalled)
1059 {
1060   pid_t new_pid, pid = ptid_get_lwp (ptid);
1061   int status;
1062
1063   if (linux_proc_pid_is_stopped (pid))
1064     {
1065       if (debug_linux_nat)
1066         fprintf_unfiltered (gdb_stdlog,
1067                             "LNPAW: Attaching to a stopped process\n");
1068
1069       /* The process is definitely stopped.  It is in a job control
1070          stop, unless the kernel predates the TASK_STOPPED /
1071          TASK_TRACED distinction, in which case it might be in a
1072          ptrace stop.  Make sure it is in a ptrace stop; from there we
1073          can kill it, signal it, et cetera.
1074
1075          First make sure there is a pending SIGSTOP.  Since we are
1076          already attached, the process can not transition from stopped
1077          to running without a PTRACE_CONT; so we know this signal will
1078          go into the queue.  The SIGSTOP generated by PTRACE_ATTACH is
1079          probably already in the queue (unless this kernel is old
1080          enough to use TASK_STOPPED for ptrace stops); but since SIGSTOP
1081          is not an RT signal, it can only be queued once.  */
1082       kill_lwp (pid, SIGSTOP);
1083
1084       /* Finally, resume the stopped process.  This will deliver the SIGSTOP
1085          (or a higher priority signal, just like normal PTRACE_ATTACH).  */
1086       ptrace (PTRACE_CONT, pid, 0, 0);
1087     }
1088
1089   /* Make sure the initial process is stopped.  The user-level threads
1090      layer might want to poke around in the inferior, and that won't
1091      work if things haven't stabilized yet.  */
1092   new_pid = my_waitpid (pid, &status, __WALL);
1093   gdb_assert (pid == new_pid);
1094
1095   if (!WIFSTOPPED (status))
1096     {
1097       /* The pid we tried to attach has apparently just exited.  */
1098       if (debug_linux_nat)
1099         fprintf_unfiltered (gdb_stdlog, "LNPAW: Failed to stop %d: %s",
1100                             pid, status_to_str (status));
1101       return status;
1102     }
1103
1104   if (WSTOPSIG (status) != SIGSTOP)
1105     {
1106       *signalled = 1;
1107       if (debug_linux_nat)
1108         fprintf_unfiltered (gdb_stdlog,
1109                             "LNPAW: Received %s after attaching\n",
1110                             status_to_str (status));
1111     }
1112
1113   return status;
1114 }
1115
1116 static void
1117 linux_nat_create_inferior (struct target_ops *ops, 
1118                            const char *exec_file, const std::string &allargs,
1119                            char **env, int from_tty)
1120 {
1121   maybe_disable_address_space_randomization restore_personality
1122     (disable_randomization);
1123
1124   /* The fork_child mechanism is synchronous and calls target_wait, so
1125      we have to mask the async mode.  */
1126
1127   /* Make sure we report all signals during startup.  */
1128   linux_nat_pass_signals (ops, 0, NULL);
1129
1130   linux_ops->to_create_inferior (ops, exec_file, allargs, env, from_tty);
1131 }
1132
1133 /* Callback for linux_proc_attach_tgid_threads.  Attach to PTID if not
1134    already attached.  Returns true if a new LWP is found, false
1135    otherwise.  */
1136
1137 static int
1138 attach_proc_task_lwp_callback (ptid_t ptid)
1139 {
1140   struct lwp_info *lp;
1141
1142   /* Ignore LWPs we're already attached to.  */
1143   lp = find_lwp_pid (ptid);
1144   if (lp == NULL)
1145     {
1146       int lwpid = ptid_get_lwp (ptid);
1147
1148       if (ptrace (PTRACE_ATTACH, lwpid, 0, 0) < 0)
1149         {
1150           int err = errno;
1151
1152           /* Be quiet if we simply raced with the thread exiting.
1153              EPERM is returned if the thread's task still exists, and
1154              is marked as exited or zombie, as well as other
1155              conditions, so in that case, confirm the status in
1156              /proc/PID/status.  */
1157           if (err == ESRCH
1158               || (err == EPERM && linux_proc_pid_is_gone (lwpid)))
1159             {
1160               if (debug_linux_nat)
1161                 {
1162                   fprintf_unfiltered (gdb_stdlog,
1163                                       "Cannot attach to lwp %d: "
1164                                       "thread is gone (%d: %s)\n",
1165                                       lwpid, err, safe_strerror (err));
1166                 }
1167             }
1168           else
1169             {
1170               std::string reason
1171                 = linux_ptrace_attach_fail_reason_string (ptid, err);
1172
1173               warning (_("Cannot attach to lwp %d: %s"),
1174                        lwpid, reason.c_str ());
1175             }
1176         }
1177       else
1178         {
1179           if (debug_linux_nat)
1180             fprintf_unfiltered (gdb_stdlog,
1181                                 "PTRACE_ATTACH %s, 0, 0 (OK)\n",
1182                                 target_pid_to_str (ptid));
1183
1184           lp = add_lwp (ptid);
1185
1186           /* The next time we wait for this LWP we'll see a SIGSTOP as
1187              PTRACE_ATTACH brings it to a halt.  */
1188           lp->signalled = 1;
1189
1190           /* We need to wait for a stop before being able to make the
1191              next ptrace call on this LWP.  */
1192           lp->must_set_ptrace_flags = 1;
1193
1194           /* So that wait collects the SIGSTOP.  */
1195           lp->resumed = 1;
1196
1197           /* Also add the LWP to gdb's thread list, in case a
1198              matching libthread_db is not found (or the process uses
1199              raw clone).  */
1200           add_thread (lp->ptid);
1201           set_running (lp->ptid, 1);
1202           set_executing (lp->ptid, 1);
1203         }
1204
1205       return 1;
1206     }
1207   return 0;
1208 }
1209
1210 static void
1211 linux_nat_attach (struct target_ops *ops, const char *args, int from_tty)
1212 {
1213   struct lwp_info *lp;
1214   int status;
1215   ptid_t ptid;
1216
1217   /* Make sure we report all signals during attach.  */
1218   linux_nat_pass_signals (ops, 0, NULL);
1219
1220   TRY
1221     {
1222       linux_ops->to_attach (ops, args, from_tty);
1223     }
1224   CATCH (ex, RETURN_MASK_ERROR)
1225     {
1226       pid_t pid = parse_pid_to_attach (args);
1227       std::string reason = linux_ptrace_attach_fail_reason (pid);
1228
1229       if (!reason.empty ())
1230         throw_error (ex.error, "warning: %s\n%s", reason.c_str (), ex.message);
1231       else
1232         throw_error (ex.error, "%s", ex.message);
1233     }
1234   END_CATCH
1235
1236   /* The ptrace base target adds the main thread with (pid,0,0)
1237      format.  Decorate it with lwp info.  */
1238   ptid = ptid_build (ptid_get_pid (inferior_ptid),
1239                      ptid_get_pid (inferior_ptid),
1240                      0);
1241   thread_change_ptid (inferior_ptid, ptid);
1242
1243   /* Add the initial process as the first LWP to the list.  */
1244   lp = add_initial_lwp (ptid);
1245
1246   status = linux_nat_post_attach_wait (lp->ptid, &lp->signalled);
1247   if (!WIFSTOPPED (status))
1248     {
1249       if (WIFEXITED (status))
1250         {
1251           int exit_code = WEXITSTATUS (status);
1252
1253           target_terminal::ours ();
1254           target_mourn_inferior (inferior_ptid);
1255           if (exit_code == 0)
1256             error (_("Unable to attach: program exited normally."));
1257           else
1258             error (_("Unable to attach: program exited with code %d."),
1259                    exit_code);
1260         }
1261       else if (WIFSIGNALED (status))
1262         {
1263           enum gdb_signal signo;
1264
1265           target_terminal::ours ();
1266           target_mourn_inferior (inferior_ptid);
1267
1268           signo = gdb_signal_from_host (WTERMSIG (status));
1269           error (_("Unable to attach: program terminated with signal "
1270                    "%s, %s."),
1271                  gdb_signal_to_name (signo),
1272                  gdb_signal_to_string (signo));
1273         }
1274
1275       internal_error (__FILE__, __LINE__,
1276                       _("unexpected status %d for PID %ld"),
1277                       status, (long) ptid_get_lwp (ptid));
1278     }
1279
1280   lp->stopped = 1;
1281
1282   /* Save the wait status to report later.  */
1283   lp->resumed = 1;
1284   if (debug_linux_nat)
1285     fprintf_unfiltered (gdb_stdlog,
1286                         "LNA: waitpid %ld, saving status %s\n",
1287                         (long) ptid_get_pid (lp->ptid), status_to_str (status));
1288
1289   lp->status = status;
1290
1291   /* We must attach to every LWP.  If /proc is mounted, use that to
1292      find them now.  The inferior may be using raw clone instead of
1293      using pthreads.  But even if it is using pthreads, thread_db
1294      walks structures in the inferior's address space to find the list
1295      of threads/LWPs, and those structures may well be corrupted.
1296      Note that once thread_db is loaded, we'll still use it to list
1297      threads and associate pthread info with each LWP.  */
1298   linux_proc_attach_tgid_threads (ptid_get_pid (lp->ptid),
1299                                   attach_proc_task_lwp_callback);
1300
1301   if (target_can_async_p ())
1302     target_async (1);
1303 }
1304
1305 /* Get pending signal of THREAD as a host signal number, for detaching
1306    purposes.  This is the signal the thread last stopped for, which we
1307    need to deliver to the thread when detaching, otherwise, it'd be
1308    suppressed/lost.  */
1309
1310 static int
1311 get_detach_signal (struct lwp_info *lp)
1312 {
1313   enum gdb_signal signo = GDB_SIGNAL_0;
1314
1315   /* If we paused threads momentarily, we may have stored pending
1316      events in lp->status or lp->waitstatus (see stop_wait_callback),
1317      and GDB core hasn't seen any signal for those threads.
1318      Otherwise, the last signal reported to the core is found in the
1319      thread object's stop_signal.
1320
1321      There's a corner case that isn't handled here at present.  Only
1322      if the thread stopped with a TARGET_WAITKIND_STOPPED does
1323      stop_signal make sense as a real signal to pass to the inferior.
1324      Some catchpoint related events, like
1325      TARGET_WAITKIND_(V)FORK|EXEC|SYSCALL, have their stop_signal set
1326      to GDB_SIGNAL_SIGTRAP when the catchpoint triggers.  But,
1327      those traps are debug API (ptrace in our case) related and
1328      induced; the inferior wouldn't see them if it wasn't being
1329      traced.  Hence, we should never pass them to the inferior, even
1330      when set to pass state.  Since this corner case isn't handled by
1331      infrun.c when proceeding with a signal, for consistency, neither
1332      do we handle it here (or elsewhere in the file we check for
1333      signal pass state).  Normally SIGTRAP isn't set to pass state, so
1334      this is really a corner case.  */
1335
1336   if (lp->waitstatus.kind != TARGET_WAITKIND_IGNORE)
1337     signo = GDB_SIGNAL_0; /* a pending ptrace event, not a real signal.  */
1338   else if (lp->status)
1339     signo = gdb_signal_from_host (WSTOPSIG (lp->status));
1340   else if (target_is_non_stop_p () && !is_executing (lp->ptid))
1341     {
1342       struct thread_info *tp = find_thread_ptid (lp->ptid);
1343
1344       if (tp->suspend.waitstatus_pending_p)
1345         signo = tp->suspend.waitstatus.value.sig;
1346       else
1347         signo = tp->suspend.stop_signal;
1348     }
1349   else if (!target_is_non_stop_p ())
1350     {
1351       struct target_waitstatus last;
1352       ptid_t last_ptid;
1353
1354       get_last_target_status (&last_ptid, &last);
1355
1356       if (ptid_get_lwp (lp->ptid) == ptid_get_lwp (last_ptid))
1357         {
1358           struct thread_info *tp = find_thread_ptid (lp->ptid);
1359
1360           signo = tp->suspend.stop_signal;
1361         }
1362     }
1363
1364   if (signo == GDB_SIGNAL_0)
1365     {
1366       if (debug_linux_nat)
1367         fprintf_unfiltered (gdb_stdlog,
1368                             "GPT: lwp %s has no pending signal\n",
1369                             target_pid_to_str (lp->ptid));
1370     }
1371   else if (!signal_pass_state (signo))
1372     {
1373       if (debug_linux_nat)
1374         fprintf_unfiltered (gdb_stdlog,
1375                             "GPT: lwp %s had signal %s, "
1376                             "but it is in no pass state\n",
1377                             target_pid_to_str (lp->ptid),
1378                             gdb_signal_to_string (signo));
1379     }
1380   else
1381     {
1382       if (debug_linux_nat)
1383         fprintf_unfiltered (gdb_stdlog,
1384                             "GPT: lwp %s has pending signal %s\n",
1385                             target_pid_to_str (lp->ptid),
1386                             gdb_signal_to_string (signo));
1387
1388       return gdb_signal_to_host (signo);
1389     }
1390
1391   return 0;
1392 }
1393
1394 /* Detach from LP.  If SIGNO_P is non-NULL, then it points to the
1395    signal number that should be passed to the LWP when detaching.
1396    Otherwise pass any pending signal the LWP may have, if any.  */
1397
1398 static void
1399 detach_one_lwp (struct lwp_info *lp, int *signo_p)
1400 {
1401   int lwpid = ptid_get_lwp (lp->ptid);
1402   int signo;
1403
1404   gdb_assert (lp->status == 0 || WIFSTOPPED (lp->status));
1405
1406   if (debug_linux_nat && lp->status)
1407     fprintf_unfiltered (gdb_stdlog, "DC:  Pending %s for %s on detach.\n",
1408                         strsignal (WSTOPSIG (lp->status)),
1409                         target_pid_to_str (lp->ptid));
1410
1411   /* If there is a pending SIGSTOP, get rid of it.  */
1412   if (lp->signalled)
1413     {
1414       if (debug_linux_nat)
1415         fprintf_unfiltered (gdb_stdlog,
1416                             "DC: Sending SIGCONT to %s\n",
1417                             target_pid_to_str (lp->ptid));
1418
1419       kill_lwp (lwpid, SIGCONT);
1420       lp->signalled = 0;
1421     }
1422
1423   if (signo_p == NULL)
1424     {
1425       /* Pass on any pending signal for this LWP.  */
1426       signo = get_detach_signal (lp);
1427     }
1428   else
1429     signo = *signo_p;
1430
1431   /* Preparing to resume may try to write registers, and fail if the
1432      lwp is zombie.  If that happens, ignore the error.  We'll handle
1433      it below, when detach fails with ESRCH.  */
1434   TRY
1435     {
1436       if (linux_nat_prepare_to_resume != NULL)
1437         linux_nat_prepare_to_resume (lp);
1438     }
1439   CATCH (ex, RETURN_MASK_ERROR)
1440     {
1441       if (!check_ptrace_stopped_lwp_gone (lp))
1442         throw_exception (ex);
1443     }
1444   END_CATCH
1445
1446   if (ptrace (PTRACE_DETACH, lwpid, 0, signo) < 0)
1447     {
1448       int save_errno = errno;
1449
1450       /* We know the thread exists, so ESRCH must mean the lwp is
1451          zombie.  This can happen if one of the already-detached
1452          threads exits the whole thread group.  In that case we're
1453          still attached, and must reap the lwp.  */
1454       if (save_errno == ESRCH)
1455         {
1456           int ret, status;
1457
1458           ret = my_waitpid (lwpid, &status, __WALL);
1459           if (ret == -1)
1460             {
1461               warning (_("Couldn't reap LWP %d while detaching: %s"),
1462                        lwpid, strerror (errno));
1463             }
1464           else if (!WIFEXITED (status) && !WIFSIGNALED (status))
1465             {
1466               warning (_("Reaping LWP %d while detaching "
1467                          "returned unexpected status 0x%x"),
1468                        lwpid, status);
1469             }
1470         }
1471       else
1472         {
1473           error (_("Can't detach %s: %s"), target_pid_to_str (lp->ptid),
1474                  safe_strerror (save_errno));
1475         }
1476     }
1477   else if (debug_linux_nat)
1478     {
1479       fprintf_unfiltered (gdb_stdlog,
1480                           "PTRACE_DETACH (%s, %s, 0) (OK)\n",
1481                           target_pid_to_str (lp->ptid),
1482                           strsignal (signo));
1483     }
1484
1485   delete_lwp (lp->ptid);
1486 }
1487
1488 static int
1489 detach_callback (struct lwp_info *lp, void *data)
1490 {
1491   /* We don't actually detach from the thread group leader just yet.
1492      If the thread group exits, we must reap the zombie clone lwps
1493      before we're able to reap the leader.  */
1494   if (ptid_get_lwp (lp->ptid) != ptid_get_pid (lp->ptid))
1495     detach_one_lwp (lp, NULL);
1496   return 0;
1497 }
1498
1499 static void
1500 linux_nat_detach (struct target_ops *ops, inferior *inf, int from_tty)
1501 {
1502   struct lwp_info *main_lwp;
1503   int pid = inf->pid;
1504
1505   /* Don't unregister from the event loop, as there may be other
1506      inferiors running. */
1507
1508   /* Stop all threads before detaching.  ptrace requires that the
1509      thread is stopped to sucessfully detach.  */
1510   iterate_over_lwps (pid_to_ptid (pid), stop_callback, NULL);
1511   /* ... and wait until all of them have reported back that
1512      they're no longer running.  */
1513   iterate_over_lwps (pid_to_ptid (pid), stop_wait_callback, NULL);
1514
1515   iterate_over_lwps (pid_to_ptid (pid), detach_callback, NULL);
1516
1517   /* Only the initial process should be left right now.  */
1518   gdb_assert (num_lwps (pid) == 1);
1519
1520   main_lwp = find_lwp_pid (pid_to_ptid (pid));
1521
1522   if (forks_exist_p ())
1523     {
1524       /* Multi-fork case.  The current inferior_ptid is being detached
1525          from, but there are other viable forks to debug.  Detach from
1526          the current fork, and context-switch to the first
1527          available.  */
1528       linux_fork_detach (from_tty);
1529     }
1530   else
1531     {
1532       target_announce_detach (from_tty);
1533
1534       /* Pass on any pending signal for the last LWP.  */
1535       int signo = get_detach_signal (main_lwp);
1536
1537       detach_one_lwp (main_lwp, &signo);
1538
1539       inf_ptrace_detach_success (ops, inf);
1540     }
1541 }
1542
1543 /* Resume execution of the inferior process.  If STEP is nonzero,
1544    single-step it.  If SIGNAL is nonzero, give it that signal.  */
1545
1546 static void
1547 linux_resume_one_lwp_throw (struct lwp_info *lp, int step,
1548                             enum gdb_signal signo)
1549 {
1550   lp->step = step;
1551
1552   /* stop_pc doubles as the PC the LWP had when it was last resumed.
1553      We only presently need that if the LWP is stepped though (to
1554      handle the case of stepping a breakpoint instruction).  */
1555   if (step)
1556     {
1557       struct regcache *regcache = get_thread_regcache (lp->ptid);
1558
1559       lp->stop_pc = regcache_read_pc (regcache);
1560     }
1561   else
1562     lp->stop_pc = 0;
1563
1564   if (linux_nat_prepare_to_resume != NULL)
1565     linux_nat_prepare_to_resume (lp);
1566   linux_ops->to_resume (linux_ops, lp->ptid, step, signo);
1567
1568   /* Successfully resumed.  Clear state that no longer makes sense,
1569      and mark the LWP as running.  Must not do this before resuming
1570      otherwise if that fails other code will be confused.  E.g., we'd
1571      later try to stop the LWP and hang forever waiting for a stop
1572      status.  Note that we must not throw after this is cleared,
1573      otherwise handle_zombie_lwp_error would get confused.  */
1574   lp->stopped = 0;
1575   lp->core = -1;
1576   lp->stop_reason = TARGET_STOPPED_BY_NO_REASON;
1577   registers_changed_ptid (lp->ptid);
1578 }
1579
1580 /* Called when we try to resume a stopped LWP and that errors out.  If
1581    the LWP is no longer in ptrace-stopped state (meaning it's zombie,
1582    or about to become), discard the error, clear any pending status
1583    the LWP may have, and return true (we'll collect the exit status
1584    soon enough).  Otherwise, return false.  */
1585
1586 static int
1587 check_ptrace_stopped_lwp_gone (struct lwp_info *lp)
1588 {
1589   /* If we get an error after resuming the LWP successfully, we'd
1590      confuse !T state for the LWP being gone.  */
1591   gdb_assert (lp->stopped);
1592
1593   /* We can't just check whether the LWP is in 'Z (Zombie)' state,
1594      because even if ptrace failed with ESRCH, the tracee may be "not
1595      yet fully dead", but already refusing ptrace requests.  In that
1596      case the tracee has 'R (Running)' state for a little bit
1597      (observed in Linux 3.18).  See also the note on ESRCH in the
1598      ptrace(2) man page.  Instead, check whether the LWP has any state
1599      other than ptrace-stopped.  */
1600
1601   /* Don't assume anything if /proc/PID/status can't be read.  */
1602   if (linux_proc_pid_is_trace_stopped_nowarn (ptid_get_lwp (lp->ptid)) == 0)
1603     {
1604       lp->stop_reason = TARGET_STOPPED_BY_NO_REASON;
1605       lp->status = 0;
1606       lp->waitstatus.kind = TARGET_WAITKIND_IGNORE;
1607       return 1;
1608     }
1609   return 0;
1610 }
1611
1612 /* Like linux_resume_one_lwp_throw, but no error is thrown if the LWP
1613    disappears while we try to resume it.  */
1614
1615 static void
1616 linux_resume_one_lwp (struct lwp_info *lp, int step, enum gdb_signal signo)
1617 {
1618   TRY
1619     {
1620       linux_resume_one_lwp_throw (lp, step, signo);
1621     }
1622   CATCH (ex, RETURN_MASK_ERROR)
1623     {
1624       if (!check_ptrace_stopped_lwp_gone (lp))
1625         throw_exception (ex);
1626     }
1627   END_CATCH
1628 }
1629
1630 /* Resume LP.  */
1631
1632 static void
1633 resume_lwp (struct lwp_info *lp, int step, enum gdb_signal signo)
1634 {
1635   if (lp->stopped)
1636     {
1637       struct inferior *inf = find_inferior_ptid (lp->ptid);
1638
1639       if (inf->vfork_child != NULL)
1640         {
1641           if (debug_linux_nat)
1642             fprintf_unfiltered (gdb_stdlog,
1643                                 "RC: Not resuming %s (vfork parent)\n",
1644                                 target_pid_to_str (lp->ptid));
1645         }
1646       else if (!lwp_status_pending_p (lp))
1647         {
1648           if (debug_linux_nat)
1649             fprintf_unfiltered (gdb_stdlog,
1650                                 "RC: Resuming sibling %s, %s, %s\n",
1651                                 target_pid_to_str (lp->ptid),
1652                                 (signo != GDB_SIGNAL_0
1653                                  ? strsignal (gdb_signal_to_host (signo))
1654                                  : "0"),
1655                                 step ? "step" : "resume");
1656
1657           linux_resume_one_lwp (lp, step, signo);
1658         }
1659       else
1660         {
1661           if (debug_linux_nat)
1662             fprintf_unfiltered (gdb_stdlog,
1663                                 "RC: Not resuming sibling %s (has pending)\n",
1664                                 target_pid_to_str (lp->ptid));
1665         }
1666     }
1667   else
1668     {
1669       if (debug_linux_nat)
1670         fprintf_unfiltered (gdb_stdlog,
1671                             "RC: Not resuming sibling %s (not stopped)\n",
1672                             target_pid_to_str (lp->ptid));
1673     }
1674 }
1675
1676 /* Callback for iterate_over_lwps.  If LWP is EXCEPT, do nothing.
1677    Resume LWP with the last stop signal, if it is in pass state.  */
1678
1679 static int
1680 linux_nat_resume_callback (struct lwp_info *lp, void *except)
1681 {
1682   enum gdb_signal signo = GDB_SIGNAL_0;
1683
1684   if (lp == except)
1685     return 0;
1686
1687   if (lp->stopped)
1688     {
1689       struct thread_info *thread;
1690
1691       thread = find_thread_ptid (lp->ptid);
1692       if (thread != NULL)
1693         {
1694           signo = thread->suspend.stop_signal;
1695           thread->suspend.stop_signal = GDB_SIGNAL_0;
1696         }
1697     }
1698
1699   resume_lwp (lp, 0, signo);
1700   return 0;
1701 }
1702
1703 static int
1704 resume_clear_callback (struct lwp_info *lp, void *data)
1705 {
1706   lp->resumed = 0;
1707   lp->last_resume_kind = resume_stop;
1708   return 0;
1709 }
1710
1711 static int
1712 resume_set_callback (struct lwp_info *lp, void *data)
1713 {
1714   lp->resumed = 1;
1715   lp->last_resume_kind = resume_continue;
1716   return 0;
1717 }
1718
1719 static void
1720 linux_nat_resume (struct target_ops *ops,
1721                   ptid_t ptid, int step, enum gdb_signal signo)
1722 {
1723   struct lwp_info *lp;
1724   int resume_many;
1725
1726   if (debug_linux_nat)
1727     fprintf_unfiltered (gdb_stdlog,
1728                         "LLR: Preparing to %s %s, %s, inferior_ptid %s\n",
1729                         step ? "step" : "resume",
1730                         target_pid_to_str (ptid),
1731                         (signo != GDB_SIGNAL_0
1732                          ? strsignal (gdb_signal_to_host (signo)) : "0"),
1733                         target_pid_to_str (inferior_ptid));
1734
1735   /* A specific PTID means `step only this process id'.  */
1736   resume_many = (ptid_equal (minus_one_ptid, ptid)
1737                  || ptid_is_pid (ptid));
1738
1739   /* Mark the lwps we're resuming as resumed.  */
1740   iterate_over_lwps (ptid, resume_set_callback, NULL);
1741
1742   /* See if it's the current inferior that should be handled
1743      specially.  */
1744   if (resume_many)
1745     lp = find_lwp_pid (inferior_ptid);
1746   else
1747     lp = find_lwp_pid (ptid);
1748   gdb_assert (lp != NULL);
1749
1750   /* Remember if we're stepping.  */
1751   lp->last_resume_kind = step ? resume_step : resume_continue;
1752
1753   /* If we have a pending wait status for this thread, there is no
1754      point in resuming the process.  But first make sure that
1755      linux_nat_wait won't preemptively handle the event - we
1756      should never take this short-circuit if we are going to
1757      leave LP running, since we have skipped resuming all the
1758      other threads.  This bit of code needs to be synchronized
1759      with linux_nat_wait.  */
1760
1761   if (lp->status && WIFSTOPPED (lp->status))
1762     {
1763       if (!lp->step
1764           && WSTOPSIG (lp->status)
1765           && sigismember (&pass_mask, WSTOPSIG (lp->status)))
1766         {
1767           if (debug_linux_nat)
1768             fprintf_unfiltered (gdb_stdlog,
1769                                 "LLR: Not short circuiting for ignored "
1770                                 "status 0x%x\n", lp->status);
1771
1772           /* FIXME: What should we do if we are supposed to continue
1773              this thread with a signal?  */
1774           gdb_assert (signo == GDB_SIGNAL_0);
1775           signo = gdb_signal_from_host (WSTOPSIG (lp->status));
1776           lp->status = 0;
1777         }
1778     }
1779
1780   if (lwp_status_pending_p (lp))
1781     {
1782       /* FIXME: What should we do if we are supposed to continue
1783          this thread with a signal?  */
1784       gdb_assert (signo == GDB_SIGNAL_0);
1785
1786       if (debug_linux_nat)
1787         fprintf_unfiltered (gdb_stdlog,
1788                             "LLR: Short circuiting for status 0x%x\n",
1789                             lp->status);
1790
1791       if (target_can_async_p ())
1792         {
1793           target_async (1);
1794           /* Tell the event loop we have something to process.  */
1795           async_file_mark ();
1796         }
1797       return;
1798     }
1799
1800   if (resume_many)
1801     iterate_over_lwps (ptid, linux_nat_resume_callback, lp);
1802
1803   if (debug_linux_nat)
1804     fprintf_unfiltered (gdb_stdlog,
1805                         "LLR: %s %s, %s (resume event thread)\n",
1806                         step ? "PTRACE_SINGLESTEP" : "PTRACE_CONT",
1807                         target_pid_to_str (lp->ptid),
1808                         (signo != GDB_SIGNAL_0
1809                          ? strsignal (gdb_signal_to_host (signo)) : "0"));
1810
1811   linux_resume_one_lwp (lp, step, signo);
1812
1813   if (target_can_async_p ())
1814     target_async (1);
1815 }
1816
1817 /* Send a signal to an LWP.  */
1818
1819 static int
1820 kill_lwp (int lwpid, int signo)
1821 {
1822   int ret;
1823
1824   errno = 0;
1825   ret = syscall (__NR_tkill, lwpid, signo);
1826   if (errno == ENOSYS)
1827     {
1828       /* If tkill fails, then we are not using nptl threads, a
1829          configuration we no longer support.  */
1830       perror_with_name (("tkill"));
1831     }
1832   return ret;
1833 }
1834
1835 /* Handle a GNU/Linux syscall trap wait response.  If we see a syscall
1836    event, check if the core is interested in it: if not, ignore the
1837    event, and keep waiting; otherwise, we need to toggle the LWP's
1838    syscall entry/exit status, since the ptrace event itself doesn't
1839    indicate it, and report the trap to higher layers.  */
1840
1841 static int
1842 linux_handle_syscall_trap (struct lwp_info *lp, int stopping)
1843 {
1844   struct target_waitstatus *ourstatus = &lp->waitstatus;
1845   struct gdbarch *gdbarch = target_thread_architecture (lp->ptid);
1846   int syscall_number = (int) gdbarch_get_syscall_number (gdbarch, lp->ptid);
1847
1848   if (stopping)
1849     {
1850       /* If we're stopping threads, there's a SIGSTOP pending, which
1851          makes it so that the LWP reports an immediate syscall return,
1852          followed by the SIGSTOP.  Skip seeing that "return" using
1853          PTRACE_CONT directly, and let stop_wait_callback collect the
1854          SIGSTOP.  Later when the thread is resumed, a new syscall
1855          entry event.  If we didn't do this (and returned 0), we'd
1856          leave a syscall entry pending, and our caller, by using
1857          PTRACE_CONT to collect the SIGSTOP, skips the syscall return
1858          itself.  Later, when the user re-resumes this LWP, we'd see
1859          another syscall entry event and we'd mistake it for a return.
1860
1861          If stop_wait_callback didn't force the SIGSTOP out of the LWP
1862          (leaving immediately with LWP->signalled set, without issuing
1863          a PTRACE_CONT), it would still be problematic to leave this
1864          syscall enter pending, as later when the thread is resumed,
1865          it would then see the same syscall exit mentioned above,
1866          followed by the delayed SIGSTOP, while the syscall didn't
1867          actually get to execute.  It seems it would be even more
1868          confusing to the user.  */
1869
1870       if (debug_linux_nat)
1871         fprintf_unfiltered (gdb_stdlog,
1872                             "LHST: ignoring syscall %d "
1873                             "for LWP %ld (stopping threads), "
1874                             "resuming with PTRACE_CONT for SIGSTOP\n",
1875                             syscall_number,
1876                             ptid_get_lwp (lp->ptid));
1877
1878       lp->syscall_state = TARGET_WAITKIND_IGNORE;
1879       ptrace (PTRACE_CONT, ptid_get_lwp (lp->ptid), 0, 0);
1880       lp->stopped = 0;
1881       return 1;
1882     }
1883
1884   /* Always update the entry/return state, even if this particular
1885      syscall isn't interesting to the core now.  In async mode,
1886      the user could install a new catchpoint for this syscall
1887      between syscall enter/return, and we'll need to know to
1888      report a syscall return if that happens.  */
1889   lp->syscall_state = (lp->syscall_state == TARGET_WAITKIND_SYSCALL_ENTRY
1890                        ? TARGET_WAITKIND_SYSCALL_RETURN
1891                        : TARGET_WAITKIND_SYSCALL_ENTRY);
1892
1893   if (catch_syscall_enabled ())
1894     {
1895       if (catching_syscall_number (syscall_number))
1896         {
1897           /* Alright, an event to report.  */
1898           ourstatus->kind = lp->syscall_state;
1899           ourstatus->value.syscall_number = syscall_number;
1900
1901           if (debug_linux_nat)
1902             fprintf_unfiltered (gdb_stdlog,
1903                                 "LHST: stopping for %s of syscall %d"
1904                                 " for LWP %ld\n",
1905                                 lp->syscall_state
1906                                 == TARGET_WAITKIND_SYSCALL_ENTRY
1907                                 ? "entry" : "return",
1908                                 syscall_number,
1909                                 ptid_get_lwp (lp->ptid));
1910           return 0;
1911         }
1912
1913       if (debug_linux_nat)
1914         fprintf_unfiltered (gdb_stdlog,
1915                             "LHST: ignoring %s of syscall %d "
1916                             "for LWP %ld\n",
1917                             lp->syscall_state == TARGET_WAITKIND_SYSCALL_ENTRY
1918                             ? "entry" : "return",
1919                             syscall_number,
1920                             ptid_get_lwp (lp->ptid));
1921     }
1922   else
1923     {
1924       /* If we had been syscall tracing, and hence used PT_SYSCALL
1925          before on this LWP, it could happen that the user removes all
1926          syscall catchpoints before we get to process this event.
1927          There are two noteworthy issues here:
1928
1929          - When stopped at a syscall entry event, resuming with
1930            PT_STEP still resumes executing the syscall and reports a
1931            syscall return.
1932
1933          - Only PT_SYSCALL catches syscall enters.  If we last
1934            single-stepped this thread, then this event can't be a
1935            syscall enter.  If we last single-stepped this thread, this
1936            has to be a syscall exit.
1937
1938          The points above mean that the next resume, be it PT_STEP or
1939          PT_CONTINUE, can not trigger a syscall trace event.  */
1940       if (debug_linux_nat)
1941         fprintf_unfiltered (gdb_stdlog,
1942                             "LHST: caught syscall event "
1943                             "with no syscall catchpoints."
1944                             " %d for LWP %ld, ignoring\n",
1945                             syscall_number,
1946                             ptid_get_lwp (lp->ptid));
1947       lp->syscall_state = TARGET_WAITKIND_IGNORE;
1948     }
1949
1950   /* The core isn't interested in this event.  For efficiency, avoid
1951      stopping all threads only to have the core resume them all again.
1952      Since we're not stopping threads, if we're still syscall tracing
1953      and not stepping, we can't use PTRACE_CONT here, as we'd miss any
1954      subsequent syscall.  Simply resume using the inf-ptrace layer,
1955      which knows when to use PT_SYSCALL or PT_CONTINUE.  */
1956
1957   linux_resume_one_lwp (lp, lp->step, GDB_SIGNAL_0);
1958   return 1;
1959 }
1960
1961 /* Handle a GNU/Linux extended wait response.  If we see a clone
1962    event, we need to add the new LWP to our list (and not report the
1963    trap to higher layers).  This function returns non-zero if the
1964    event should be ignored and we should wait again.  If STOPPING is
1965    true, the new LWP remains stopped, otherwise it is continued.  */
1966
1967 static int
1968 linux_handle_extended_wait (struct lwp_info *lp, int status)
1969 {
1970   int pid = ptid_get_lwp (lp->ptid);
1971   struct target_waitstatus *ourstatus = &lp->waitstatus;
1972   int event = linux_ptrace_get_extended_event (status);
1973
1974   /* All extended events we currently use are mid-syscall.  Only
1975      PTRACE_EVENT_STOP is delivered more like a signal-stop, but
1976      you have to be using PTRACE_SEIZE to get that.  */
1977   lp->syscall_state = TARGET_WAITKIND_SYSCALL_ENTRY;
1978
1979   if (event == PTRACE_EVENT_FORK || event == PTRACE_EVENT_VFORK
1980       || event == PTRACE_EVENT_CLONE)
1981     {
1982       unsigned long new_pid;
1983       int ret;
1984
1985       ptrace (PTRACE_GETEVENTMSG, pid, 0, &new_pid);
1986
1987       /* If we haven't already seen the new PID stop, wait for it now.  */
1988       if (! pull_pid_from_list (&stopped_pids, new_pid, &status))
1989         {
1990           /* The new child has a pending SIGSTOP.  We can't affect it until it
1991              hits the SIGSTOP, but we're already attached.  */
1992           ret = my_waitpid (new_pid, &status, __WALL);
1993           if (ret == -1)
1994             perror_with_name (_("waiting for new child"));
1995           else if (ret != new_pid)
1996             internal_error (__FILE__, __LINE__,
1997                             _("wait returned unexpected PID %d"), ret);
1998           else if (!WIFSTOPPED (status))
1999             internal_error (__FILE__, __LINE__,
2000                             _("wait returned unexpected status 0x%x"), status);
2001         }
2002
2003       ourstatus->value.related_pid = ptid_build (new_pid, new_pid, 0);
2004
2005       if (event == PTRACE_EVENT_FORK || event == PTRACE_EVENT_VFORK)
2006         {
2007           /* The arch-specific native code may need to know about new
2008              forks even if those end up never mapped to an
2009              inferior.  */
2010           if (linux_nat_new_fork != NULL)
2011             linux_nat_new_fork (lp, new_pid);
2012         }
2013
2014       if (event == PTRACE_EVENT_FORK
2015           && linux_fork_checkpointing_p (ptid_get_pid (lp->ptid)))
2016         {
2017           /* Handle checkpointing by linux-fork.c here as a special
2018              case.  We don't want the follow-fork-mode or 'catch fork'
2019              to interfere with this.  */
2020
2021           /* This won't actually modify the breakpoint list, but will
2022              physically remove the breakpoints from the child.  */
2023           detach_breakpoints (ptid_build (new_pid, new_pid, 0));
2024
2025           /* Retain child fork in ptrace (stopped) state.  */
2026           if (!find_fork_pid (new_pid))
2027             add_fork (new_pid);
2028
2029           /* Report as spurious, so that infrun doesn't want to follow
2030              this fork.  We're actually doing an infcall in
2031              linux-fork.c.  */
2032           ourstatus->kind = TARGET_WAITKIND_SPURIOUS;
2033
2034           /* Report the stop to the core.  */
2035           return 0;
2036         }
2037
2038       if (event == PTRACE_EVENT_FORK)
2039         ourstatus->kind = TARGET_WAITKIND_FORKED;
2040       else if (event == PTRACE_EVENT_VFORK)
2041         ourstatus->kind = TARGET_WAITKIND_VFORKED;
2042       else if (event == PTRACE_EVENT_CLONE)
2043         {
2044           struct lwp_info *new_lp;
2045
2046           ourstatus->kind = TARGET_WAITKIND_IGNORE;
2047
2048           if (debug_linux_nat)
2049             fprintf_unfiltered (gdb_stdlog,
2050                                 "LHEW: Got clone event "
2051                                 "from LWP %d, new child is LWP %ld\n",
2052                                 pid, new_pid);
2053
2054           new_lp = add_lwp (ptid_build (ptid_get_pid (lp->ptid), new_pid, 0));
2055           new_lp->stopped = 1;
2056           new_lp->resumed = 1;
2057
2058           /* If the thread_db layer is active, let it record the user
2059              level thread id and status, and add the thread to GDB's
2060              list.  */
2061           if (!thread_db_notice_clone (lp->ptid, new_lp->ptid))
2062             {
2063               /* The process is not using thread_db.  Add the LWP to
2064                  GDB's list.  */
2065               target_post_attach (ptid_get_lwp (new_lp->ptid));
2066               add_thread (new_lp->ptid);
2067             }
2068
2069           /* Even if we're stopping the thread for some reason
2070              internal to this module, from the perspective of infrun
2071              and the user/frontend, this new thread is running until
2072              it next reports a stop.  */
2073           set_running (new_lp->ptid, 1);
2074           set_executing (new_lp->ptid, 1);
2075
2076           if (WSTOPSIG (status) != SIGSTOP)
2077             {
2078               /* This can happen if someone starts sending signals to
2079                  the new thread before it gets a chance to run, which
2080                  have a lower number than SIGSTOP (e.g. SIGUSR1).
2081                  This is an unlikely case, and harder to handle for
2082                  fork / vfork than for clone, so we do not try - but
2083                  we handle it for clone events here.  */
2084
2085               new_lp->signalled = 1;
2086
2087               /* We created NEW_LP so it cannot yet contain STATUS.  */
2088               gdb_assert (new_lp->status == 0);
2089
2090               /* Save the wait status to report later.  */
2091               if (debug_linux_nat)
2092                 fprintf_unfiltered (gdb_stdlog,
2093                                     "LHEW: waitpid of new LWP %ld, "
2094                                     "saving status %s\n",
2095                                     (long) ptid_get_lwp (new_lp->ptid),
2096                                     status_to_str (status));
2097               new_lp->status = status;
2098             }
2099           else if (report_thread_events)
2100             {
2101               new_lp->waitstatus.kind = TARGET_WAITKIND_THREAD_CREATED;
2102               new_lp->status = status;
2103             }
2104
2105           return 1;
2106         }
2107
2108       return 0;
2109     }
2110
2111   if (event == PTRACE_EVENT_EXEC)
2112     {
2113       if (debug_linux_nat)
2114         fprintf_unfiltered (gdb_stdlog,
2115                             "LHEW: Got exec event from LWP %ld\n",
2116                             ptid_get_lwp (lp->ptid));
2117
2118       ourstatus->kind = TARGET_WAITKIND_EXECD;
2119       ourstatus->value.execd_pathname
2120         = xstrdup (linux_child_pid_to_exec_file (NULL, pid));
2121
2122       /* The thread that execed must have been resumed, but, when a
2123          thread execs, it changes its tid to the tgid, and the old
2124          tgid thread might have not been resumed.  */
2125       lp->resumed = 1;
2126       return 0;
2127     }
2128
2129   if (event == PTRACE_EVENT_VFORK_DONE)
2130     {
2131       if (current_inferior ()->waiting_for_vfork_done)
2132         {
2133           if (debug_linux_nat)
2134             fprintf_unfiltered (gdb_stdlog,
2135                                 "LHEW: Got expected PTRACE_EVENT_"
2136                                 "VFORK_DONE from LWP %ld: stopping\n",
2137                                 ptid_get_lwp (lp->ptid));
2138
2139           ourstatus->kind = TARGET_WAITKIND_VFORK_DONE;
2140           return 0;
2141         }
2142
2143       if (debug_linux_nat)
2144         fprintf_unfiltered (gdb_stdlog,
2145                             "LHEW: Got PTRACE_EVENT_VFORK_DONE "
2146                             "from LWP %ld: ignoring\n",
2147                             ptid_get_lwp (lp->ptid));
2148       return 1;
2149     }
2150
2151   internal_error (__FILE__, __LINE__,
2152                   _("unknown ptrace event %d"), event);
2153 }
2154
2155 /* Suspend waiting for a signal.  We're mostly interested in
2156    SIGCHLD/SIGINT.  */
2157
2158 static void
2159 wait_for_signal ()
2160 {
2161   if (debug_linux_nat)
2162     fprintf_unfiltered (gdb_stdlog, "linux-nat: about to sigsuspend\n");
2163   sigsuspend (&suspend_mask);
2164
2165   /* If the quit flag is set, it means that the user pressed Ctrl-C
2166      and we're debugging a process that is running on a separate
2167      terminal, so we must forward the Ctrl-C to the inferior.  (If the
2168      inferior is sharing GDB's terminal, then the Ctrl-C reaches the
2169      inferior directly.)  We must do this here because functions that
2170      need to block waiting for a signal loop forever until there's an
2171      event to report before returning back to the event loop.  */
2172   if (!target_terminal::is_ours ())
2173     {
2174       if (check_quit_flag ())
2175         target_pass_ctrlc ();
2176     }
2177 }
2178
2179 /* Wait for LP to stop.  Returns the wait status, or 0 if the LWP has
2180    exited.  */
2181
2182 static int
2183 wait_lwp (struct lwp_info *lp)
2184 {
2185   pid_t pid;
2186   int status = 0;
2187   int thread_dead = 0;
2188   sigset_t prev_mask;
2189
2190   gdb_assert (!lp->stopped);
2191   gdb_assert (lp->status == 0);
2192
2193   /* Make sure SIGCHLD is blocked for sigsuspend avoiding a race below.  */
2194   block_child_signals (&prev_mask);
2195
2196   for (;;)
2197     {
2198       pid = my_waitpid (ptid_get_lwp (lp->ptid), &status, __WALL | WNOHANG);
2199       if (pid == -1 && errno == ECHILD)
2200         {
2201           /* The thread has previously exited.  We need to delete it
2202              now because if this was a non-leader thread execing, we
2203              won't get an exit event.  See comments on exec events at
2204              the top of the file.  */
2205           thread_dead = 1;
2206           if (debug_linux_nat)
2207             fprintf_unfiltered (gdb_stdlog, "WL: %s vanished.\n",
2208                                 target_pid_to_str (lp->ptid));
2209         }
2210       if (pid != 0)
2211         break;
2212
2213       /* Bugs 10970, 12702.
2214          Thread group leader may have exited in which case we'll lock up in
2215          waitpid if there are other threads, even if they are all zombies too.
2216          Basically, we're not supposed to use waitpid this way.
2217           tkill(pid,0) cannot be used here as it gets ESRCH for both
2218          for zombie and running processes.
2219
2220          As a workaround, check if we're waiting for the thread group leader and
2221          if it's a zombie, and avoid calling waitpid if it is.
2222
2223          This is racy, what if the tgl becomes a zombie right after we check?
2224          Therefore always use WNOHANG with sigsuspend - it is equivalent to
2225          waiting waitpid but linux_proc_pid_is_zombie is safe this way.  */
2226
2227       if (ptid_get_pid (lp->ptid) == ptid_get_lwp (lp->ptid)
2228           && linux_proc_pid_is_zombie (ptid_get_lwp (lp->ptid)))
2229         {
2230           thread_dead = 1;
2231           if (debug_linux_nat)
2232             fprintf_unfiltered (gdb_stdlog,
2233                                 "WL: Thread group leader %s vanished.\n",
2234                                 target_pid_to_str (lp->ptid));
2235           break;
2236         }
2237
2238       /* Wait for next SIGCHLD and try again.  This may let SIGCHLD handlers
2239          get invoked despite our caller had them intentionally blocked by
2240          block_child_signals.  This is sensitive only to the loop of
2241          linux_nat_wait_1 and there if we get called my_waitpid gets called
2242          again before it gets to sigsuspend so we can safely let the handlers
2243          get executed here.  */
2244       wait_for_signal ();
2245     }
2246
2247   restore_child_signals_mask (&prev_mask);
2248
2249   if (!thread_dead)
2250     {
2251       gdb_assert (pid == ptid_get_lwp (lp->ptid));
2252
2253       if (debug_linux_nat)
2254         {
2255           fprintf_unfiltered (gdb_stdlog,
2256                               "WL: waitpid %s received %s\n",
2257                               target_pid_to_str (lp->ptid),
2258                               status_to_str (status));
2259         }
2260
2261       /* Check if the thread has exited.  */
2262       if (WIFEXITED (status) || WIFSIGNALED (status))
2263         {
2264           if (report_thread_events
2265               || ptid_get_pid (lp->ptid) == ptid_get_lwp (lp->ptid))
2266             {
2267               if (debug_linux_nat)
2268                 fprintf_unfiltered (gdb_stdlog, "WL: LWP %d exited.\n",
2269                                     ptid_get_pid (lp->ptid));
2270
2271               /* If this is the leader exiting, it means the whole
2272                  process is gone.  Store the status to report to the
2273                  core.  Store it in lp->waitstatus, because lp->status
2274                  would be ambiguous (W_EXITCODE(0,0) == 0).  */
2275               store_waitstatus (&lp->waitstatus, status);
2276               return 0;
2277             }
2278
2279           thread_dead = 1;
2280           if (debug_linux_nat)
2281             fprintf_unfiltered (gdb_stdlog, "WL: %s exited.\n",
2282                                 target_pid_to_str (lp->ptid));
2283         }
2284     }
2285
2286   if (thread_dead)
2287     {
2288       exit_lwp (lp);
2289       return 0;
2290     }
2291
2292   gdb_assert (WIFSTOPPED (status));
2293   lp->stopped = 1;
2294
2295   if (lp->must_set_ptrace_flags)
2296     {
2297       struct inferior *inf = find_inferior_pid (ptid_get_pid (lp->ptid));
2298       int options = linux_nat_ptrace_options (inf->attach_flag);
2299
2300       linux_enable_event_reporting (ptid_get_lwp (lp->ptid), options);
2301       lp->must_set_ptrace_flags = 0;
2302     }
2303
2304   /* Handle GNU/Linux's syscall SIGTRAPs.  */
2305   if (WIFSTOPPED (status) && WSTOPSIG (status) == SYSCALL_SIGTRAP)
2306     {
2307       /* No longer need the sysgood bit.  The ptrace event ends up
2308          recorded in lp->waitstatus if we care for it.  We can carry
2309          on handling the event like a regular SIGTRAP from here
2310          on.  */
2311       status = W_STOPCODE (SIGTRAP);
2312       if (linux_handle_syscall_trap (lp, 1))
2313         return wait_lwp (lp);
2314     }
2315   else
2316     {
2317       /* Almost all other ptrace-stops are known to be outside of system
2318          calls, with further exceptions in linux_handle_extended_wait.  */
2319       lp->syscall_state = TARGET_WAITKIND_IGNORE;
2320     }
2321
2322   /* Handle GNU/Linux's extended waitstatus for trace events.  */
2323   if (WIFSTOPPED (status) && WSTOPSIG (status) == SIGTRAP
2324       && linux_is_extended_waitstatus (status))
2325     {
2326       if (debug_linux_nat)
2327         fprintf_unfiltered (gdb_stdlog,
2328                             "WL: Handling extended status 0x%06x\n",
2329                             status);
2330       linux_handle_extended_wait (lp, status);
2331       return 0;
2332     }
2333
2334   return status;
2335 }
2336
2337 /* Send a SIGSTOP to LP.  */
2338
2339 static int
2340 stop_callback (struct lwp_info *lp, void *data)
2341 {
2342   if (!lp->stopped && !lp->signalled)
2343     {
2344       int ret;
2345
2346       if (debug_linux_nat)
2347         {
2348           fprintf_unfiltered (gdb_stdlog,
2349                               "SC:  kill %s **<SIGSTOP>**\n",
2350                               target_pid_to_str (lp->ptid));
2351         }
2352       errno = 0;
2353       ret = kill_lwp (ptid_get_lwp (lp->ptid), SIGSTOP);
2354       if (debug_linux_nat)
2355         {
2356           fprintf_unfiltered (gdb_stdlog,
2357                               "SC:  lwp kill %d %s\n",
2358                               ret,
2359                               errno ? safe_strerror (errno) : "ERRNO-OK");
2360         }
2361
2362       lp->signalled = 1;
2363       gdb_assert (lp->status == 0);
2364     }
2365
2366   return 0;
2367 }
2368
2369 /* Request a stop on LWP.  */
2370
2371 void
2372 linux_stop_lwp (struct lwp_info *lwp)
2373 {
2374   stop_callback (lwp, NULL);
2375 }
2376
2377 /* See linux-nat.h  */
2378
2379 void
2380 linux_stop_and_wait_all_lwps (void)
2381 {
2382   /* Stop all LWP's ...  */
2383   iterate_over_lwps (minus_one_ptid, stop_callback, NULL);
2384
2385   /* ... and wait until all of them have reported back that
2386      they're no longer running.  */
2387   iterate_over_lwps (minus_one_ptid, stop_wait_callback, NULL);
2388 }
2389
2390 /* See linux-nat.h  */
2391
2392 void
2393 linux_unstop_all_lwps (void)
2394 {
2395   iterate_over_lwps (minus_one_ptid,
2396                      resume_stopped_resumed_lwps, &minus_one_ptid);
2397 }
2398
2399 /* Return non-zero if LWP PID has a pending SIGINT.  */
2400
2401 static int
2402 linux_nat_has_pending_sigint (int pid)
2403 {
2404   sigset_t pending, blocked, ignored;
2405
2406   linux_proc_pending_signals (pid, &pending, &blocked, &ignored);
2407
2408   if (sigismember (&pending, SIGINT)
2409       && !sigismember (&ignored, SIGINT))
2410     return 1;
2411
2412   return 0;
2413 }
2414
2415 /* Set a flag in LP indicating that we should ignore its next SIGINT.  */
2416
2417 static int
2418 set_ignore_sigint (struct lwp_info *lp, void *data)
2419 {
2420   /* If a thread has a pending SIGINT, consume it; otherwise, set a
2421      flag to consume the next one.  */
2422   if (lp->stopped && lp->status != 0 && WIFSTOPPED (lp->status)
2423       && WSTOPSIG (lp->status) == SIGINT)
2424     lp->status = 0;
2425   else
2426     lp->ignore_sigint = 1;
2427
2428   return 0;
2429 }
2430
2431 /* If LP does not have a SIGINT pending, then clear the ignore_sigint flag.
2432    This function is called after we know the LWP has stopped; if the LWP
2433    stopped before the expected SIGINT was delivered, then it will never have
2434    arrived.  Also, if the signal was delivered to a shared queue and consumed
2435    by a different thread, it will never be delivered to this LWP.  */
2436
2437 static void
2438 maybe_clear_ignore_sigint (struct lwp_info *lp)
2439 {
2440   if (!lp->ignore_sigint)
2441     return;
2442
2443   if (!linux_nat_has_pending_sigint (ptid_get_lwp (lp->ptid)))
2444     {
2445       if (debug_linux_nat)
2446         fprintf_unfiltered (gdb_stdlog,
2447                             "MCIS: Clearing bogus flag for %s\n",
2448                             target_pid_to_str (lp->ptid));
2449       lp->ignore_sigint = 0;
2450     }
2451 }
2452
2453 /* Fetch the possible triggered data watchpoint info and store it in
2454    LP.
2455
2456    On some archs, like x86, that use debug registers to set
2457    watchpoints, it's possible that the way to know which watched
2458    address trapped, is to check the register that is used to select
2459    which address to watch.  Problem is, between setting the watchpoint
2460    and reading back which data address trapped, the user may change
2461    the set of watchpoints, and, as a consequence, GDB changes the
2462    debug registers in the inferior.  To avoid reading back a stale
2463    stopped-data-address when that happens, we cache in LP the fact
2464    that a watchpoint trapped, and the corresponding data address, as
2465    soon as we see LP stop with a SIGTRAP.  If GDB changes the debug
2466    registers meanwhile, we have the cached data we can rely on.  */
2467
2468 static int
2469 check_stopped_by_watchpoint (struct lwp_info *lp)
2470 {
2471   if (linux_ops->to_stopped_by_watchpoint == NULL)
2472     return 0;
2473
2474   scoped_restore save_inferior_ptid = make_scoped_restore (&inferior_ptid);
2475   inferior_ptid = lp->ptid;
2476
2477   if (linux_ops->to_stopped_by_watchpoint (linux_ops))
2478     {
2479       lp->stop_reason = TARGET_STOPPED_BY_WATCHPOINT;
2480
2481       if (linux_ops->to_stopped_data_address != NULL)
2482         lp->stopped_data_address_p =
2483           linux_ops->to_stopped_data_address (&current_target,
2484                                               &lp->stopped_data_address);
2485       else
2486         lp->stopped_data_address_p = 0;
2487     }
2488
2489   return lp->stop_reason == TARGET_STOPPED_BY_WATCHPOINT;
2490 }
2491
2492 /* Returns true if the LWP had stopped for a watchpoint.  */
2493
2494 static int
2495 linux_nat_stopped_by_watchpoint (struct target_ops *ops)
2496 {
2497   struct lwp_info *lp = find_lwp_pid (inferior_ptid);
2498
2499   gdb_assert (lp != NULL);
2500
2501   return lp->stop_reason == TARGET_STOPPED_BY_WATCHPOINT;
2502 }
2503
2504 static int
2505 linux_nat_stopped_data_address (struct target_ops *ops, CORE_ADDR *addr_p)
2506 {
2507   struct lwp_info *lp = find_lwp_pid (inferior_ptid);
2508
2509   gdb_assert (lp != NULL);
2510
2511   *addr_p = lp->stopped_data_address;
2512
2513   return lp->stopped_data_address_p;
2514 }
2515
2516 /* Commonly any breakpoint / watchpoint generate only SIGTRAP.  */
2517
2518 static int
2519 sigtrap_is_event (int status)
2520 {
2521   return WIFSTOPPED (status) && WSTOPSIG (status) == SIGTRAP;
2522 }
2523
2524 /* Set alternative SIGTRAP-like events recognizer.  If
2525    breakpoint_inserted_here_p there then gdbarch_decr_pc_after_break will be
2526    applied.  */
2527
2528 void
2529 linux_nat_set_status_is_event (struct target_ops *t,
2530                                int (*status_is_event) (int status))
2531 {
2532   linux_nat_status_is_event = status_is_event;
2533 }
2534
2535 /* Wait until LP is stopped.  */
2536
2537 static int
2538 stop_wait_callback (struct lwp_info *lp, void *data)
2539 {
2540   struct inferior *inf = find_inferior_ptid (lp->ptid);
2541
2542   /* If this is a vfork parent, bail out, it is not going to report
2543      any SIGSTOP until the vfork is done with.  */
2544   if (inf->vfork_child != NULL)
2545     return 0;
2546
2547   if (!lp->stopped)
2548     {
2549       int status;
2550
2551       status = wait_lwp (lp);
2552       if (status == 0)
2553         return 0;
2554
2555       if (lp->ignore_sigint && WIFSTOPPED (status)
2556           && WSTOPSIG (status) == SIGINT)
2557         {
2558           lp->ignore_sigint = 0;
2559
2560           errno = 0;
2561           ptrace (PTRACE_CONT, ptid_get_lwp (lp->ptid), 0, 0);
2562           lp->stopped = 0;
2563           if (debug_linux_nat)
2564             fprintf_unfiltered (gdb_stdlog,
2565                                 "PTRACE_CONT %s, 0, 0 (%s) "
2566                                 "(discarding SIGINT)\n",
2567                                 target_pid_to_str (lp->ptid),
2568                                 errno ? safe_strerror (errno) : "OK");
2569
2570           return stop_wait_callback (lp, NULL);
2571         }
2572
2573       maybe_clear_ignore_sigint (lp);
2574
2575       if (WSTOPSIG (status) != SIGSTOP)
2576         {
2577           /* The thread was stopped with a signal other than SIGSTOP.  */
2578
2579           if (debug_linux_nat)
2580             fprintf_unfiltered (gdb_stdlog,
2581                                 "SWC: Pending event %s in %s\n",
2582                                 status_to_str ((int) status),
2583                                 target_pid_to_str (lp->ptid));
2584
2585           /* Save the sigtrap event.  */
2586           lp->status = status;
2587           gdb_assert (lp->signalled);
2588           save_stop_reason (lp);
2589         }
2590       else
2591         {
2592           /* We caught the SIGSTOP that we intended to catch, so
2593              there's no SIGSTOP pending.  */
2594
2595           if (debug_linux_nat)
2596             fprintf_unfiltered (gdb_stdlog,
2597                                 "SWC: Expected SIGSTOP caught for %s.\n",
2598                                 target_pid_to_str (lp->ptid));
2599
2600           /* Reset SIGNALLED only after the stop_wait_callback call
2601              above as it does gdb_assert on SIGNALLED.  */
2602           lp->signalled = 0;
2603         }
2604     }
2605
2606   return 0;
2607 }
2608
2609 /* Return non-zero if LP has a wait status pending.  Discard the
2610    pending event and resume the LWP if the event that originally
2611    caused the stop became uninteresting.  */
2612
2613 static int
2614 status_callback (struct lwp_info *lp, void *data)
2615 {
2616   /* Only report a pending wait status if we pretend that this has
2617      indeed been resumed.  */
2618   if (!lp->resumed)
2619     return 0;
2620
2621   if (!lwp_status_pending_p (lp))
2622     return 0;
2623
2624   if (lp->stop_reason == TARGET_STOPPED_BY_SW_BREAKPOINT
2625       || lp->stop_reason == TARGET_STOPPED_BY_HW_BREAKPOINT)
2626     {
2627       struct regcache *regcache = get_thread_regcache (lp->ptid);
2628       CORE_ADDR pc;
2629       int discard = 0;
2630
2631       pc = regcache_read_pc (regcache);
2632
2633       if (pc != lp->stop_pc)
2634         {
2635           if (debug_linux_nat)
2636             fprintf_unfiltered (gdb_stdlog,
2637                                 "SC: PC of %s changed.  was=%s, now=%s\n",
2638                                 target_pid_to_str (lp->ptid),
2639                                 paddress (target_gdbarch (), lp->stop_pc),
2640                                 paddress (target_gdbarch (), pc));
2641           discard = 1;
2642         }
2643
2644 #if !USE_SIGTRAP_SIGINFO
2645       else if (!breakpoint_inserted_here_p (regcache->aspace (), pc))
2646         {
2647           if (debug_linux_nat)
2648             fprintf_unfiltered (gdb_stdlog,
2649                                 "SC: previous breakpoint of %s, at %s gone\n",
2650                                 target_pid_to_str (lp->ptid),
2651                                 paddress (target_gdbarch (), lp->stop_pc));
2652
2653           discard = 1;
2654         }
2655 #endif
2656
2657       if (discard)
2658         {
2659           if (debug_linux_nat)
2660             fprintf_unfiltered (gdb_stdlog,
2661                                 "SC: pending event of %s cancelled.\n",
2662                                 target_pid_to_str (lp->ptid));
2663
2664           lp->status = 0;
2665           linux_resume_one_lwp (lp, lp->step, GDB_SIGNAL_0);
2666           return 0;
2667         }
2668     }
2669
2670   return 1;
2671 }
2672
2673 /* Count the LWP's that have had events.  */
2674
2675 static int
2676 count_events_callback (struct lwp_info *lp, void *data)
2677 {
2678   int *count = (int *) data;
2679
2680   gdb_assert (count != NULL);
2681
2682   /* Select only resumed LWPs that have an event pending.  */
2683   if (lp->resumed && lwp_status_pending_p (lp))
2684     (*count)++;
2685
2686   return 0;
2687 }
2688
2689 /* Select the LWP (if any) that is currently being single-stepped.  */
2690
2691 static int
2692 select_singlestep_lwp_callback (struct lwp_info *lp, void *data)
2693 {
2694   if (lp->last_resume_kind == resume_step
2695       && lp->status != 0)
2696     return 1;
2697   else
2698     return 0;
2699 }
2700
2701 /* Returns true if LP has a status pending.  */
2702
2703 static int
2704 lwp_status_pending_p (struct lwp_info *lp)
2705 {
2706   /* We check for lp->waitstatus in addition to lp->status, because we
2707      can have pending process exits recorded in lp->status and
2708      W_EXITCODE(0,0) happens to be 0.  */
2709   return lp->status != 0 || lp->waitstatus.kind != TARGET_WAITKIND_IGNORE;
2710 }
2711
2712 /* Select the Nth LWP that has had an event.  */
2713
2714 static int
2715 select_event_lwp_callback (struct lwp_info *lp, void *data)
2716 {
2717   int *selector = (int *) data;
2718
2719   gdb_assert (selector != NULL);
2720
2721   /* Select only resumed LWPs that have an event pending.  */
2722   if (lp->resumed && lwp_status_pending_p (lp))
2723     if ((*selector)-- == 0)
2724       return 1;
2725
2726   return 0;
2727 }
2728
2729 /* Called when the LWP stopped for a signal/trap.  If it stopped for a
2730    trap check what caused it (breakpoint, watchpoint, trace, etc.),
2731    and save the result in the LWP's stop_reason field.  If it stopped
2732    for a breakpoint, decrement the PC if necessary on the lwp's
2733    architecture.  */
2734
2735 static void
2736 save_stop_reason (struct lwp_info *lp)
2737 {
2738   struct regcache *regcache;
2739   struct gdbarch *gdbarch;
2740   CORE_ADDR pc;
2741   CORE_ADDR sw_bp_pc;
2742 #if USE_SIGTRAP_SIGINFO
2743   siginfo_t siginfo;
2744 #endif
2745
2746   gdb_assert (lp->stop_reason == TARGET_STOPPED_BY_NO_REASON);
2747   gdb_assert (lp->status != 0);
2748
2749   if (!linux_nat_status_is_event (lp->status))
2750     return;
2751
2752   regcache = get_thread_regcache (lp->ptid);
2753   gdbarch = regcache->arch ();
2754
2755   pc = regcache_read_pc (regcache);
2756   sw_bp_pc = pc - gdbarch_decr_pc_after_break (gdbarch);
2757
2758 #if USE_SIGTRAP_SIGINFO
2759   if (linux_nat_get_siginfo (lp->ptid, &siginfo))
2760     {
2761       if (siginfo.si_signo == SIGTRAP)
2762         {
2763           if (GDB_ARCH_IS_TRAP_BRKPT (siginfo.si_code)
2764               && GDB_ARCH_IS_TRAP_HWBKPT (siginfo.si_code))
2765             {
2766               /* The si_code is ambiguous on this arch -- check debug
2767                  registers.  */
2768               if (!check_stopped_by_watchpoint (lp))
2769                 lp->stop_reason = TARGET_STOPPED_BY_SW_BREAKPOINT;
2770             }
2771           else if (GDB_ARCH_IS_TRAP_BRKPT (siginfo.si_code))
2772             {
2773               /* If we determine the LWP stopped for a SW breakpoint,
2774                  trust it.  Particularly don't check watchpoint
2775                  registers, because at least on s390, we'd find
2776                  stopped-by-watchpoint as long as there's a watchpoint
2777                  set.  */
2778               lp->stop_reason = TARGET_STOPPED_BY_SW_BREAKPOINT;
2779             }
2780           else if (GDB_ARCH_IS_TRAP_HWBKPT (siginfo.si_code))
2781             {
2782               /* This can indicate either a hardware breakpoint or
2783                  hardware watchpoint.  Check debug registers.  */
2784               if (!check_stopped_by_watchpoint (lp))
2785                 lp->stop_reason = TARGET_STOPPED_BY_HW_BREAKPOINT;
2786             }
2787           else if (siginfo.si_code == TRAP_TRACE)
2788             {
2789               if (debug_linux_nat)
2790                 fprintf_unfiltered (gdb_stdlog,
2791                                     "CSBB: %s stopped by trace\n",
2792                                     target_pid_to_str (lp->ptid));
2793
2794               /* We may have single stepped an instruction that
2795                  triggered a watchpoint.  In that case, on some
2796                  architectures (such as x86), instead of TRAP_HWBKPT,
2797                  si_code indicates TRAP_TRACE, and we need to check
2798                  the debug registers separately.  */
2799               check_stopped_by_watchpoint (lp);
2800             }
2801         }
2802     }
2803 #else
2804   if ((!lp->step || lp->stop_pc == sw_bp_pc)
2805       && software_breakpoint_inserted_here_p (regcache->aspace (),
2806                                               sw_bp_pc))
2807     {
2808       /* The LWP was either continued, or stepped a software
2809          breakpoint instruction.  */
2810       lp->stop_reason = TARGET_STOPPED_BY_SW_BREAKPOINT;
2811     }
2812
2813   if (hardware_breakpoint_inserted_here_p (regcache->aspace (), pc))
2814     lp->stop_reason = TARGET_STOPPED_BY_HW_BREAKPOINT;
2815
2816   if (lp->stop_reason == TARGET_STOPPED_BY_NO_REASON)
2817     check_stopped_by_watchpoint (lp);
2818 #endif
2819
2820   if (lp->stop_reason == TARGET_STOPPED_BY_SW_BREAKPOINT)
2821     {
2822       if (debug_linux_nat)
2823         fprintf_unfiltered (gdb_stdlog,
2824                             "CSBB: %s stopped by software breakpoint\n",
2825                             target_pid_to_str (lp->ptid));
2826
2827       /* Back up the PC if necessary.  */
2828       if (pc != sw_bp_pc)
2829         regcache_write_pc (regcache, sw_bp_pc);
2830
2831       /* Update this so we record the correct stop PC below.  */
2832       pc = sw_bp_pc;
2833     }
2834   else if (lp->stop_reason == TARGET_STOPPED_BY_HW_BREAKPOINT)
2835     {
2836       if (debug_linux_nat)
2837         fprintf_unfiltered (gdb_stdlog,
2838                             "CSBB: %s stopped by hardware breakpoint\n",
2839                             target_pid_to_str (lp->ptid));
2840     }
2841   else if (lp->stop_reason == TARGET_STOPPED_BY_WATCHPOINT)
2842     {
2843       if (debug_linux_nat)
2844         fprintf_unfiltered (gdb_stdlog,
2845                             "CSBB: %s stopped by hardware watchpoint\n",
2846                             target_pid_to_str (lp->ptid));
2847     }
2848
2849   lp->stop_pc = pc;
2850 }
2851
2852
2853 /* Returns true if the LWP had stopped for a software breakpoint.  */
2854
2855 static int
2856 linux_nat_stopped_by_sw_breakpoint (struct target_ops *ops)
2857 {
2858   struct lwp_info *lp = find_lwp_pid (inferior_ptid);
2859
2860   gdb_assert (lp != NULL);
2861
2862   return lp->stop_reason == TARGET_STOPPED_BY_SW_BREAKPOINT;
2863 }
2864
2865 /* Implement the supports_stopped_by_sw_breakpoint method.  */
2866
2867 static int
2868 linux_nat_supports_stopped_by_sw_breakpoint (struct target_ops *ops)
2869 {
2870   return USE_SIGTRAP_SIGINFO;
2871 }
2872
2873 /* Returns true if the LWP had stopped for a hardware
2874    breakpoint/watchpoint.  */
2875
2876 static int
2877 linux_nat_stopped_by_hw_breakpoint (struct target_ops *ops)
2878 {
2879   struct lwp_info *lp = find_lwp_pid (inferior_ptid);
2880
2881   gdb_assert (lp != NULL);
2882
2883   return lp->stop_reason == TARGET_STOPPED_BY_HW_BREAKPOINT;
2884 }
2885
2886 /* Implement the supports_stopped_by_hw_breakpoint method.  */
2887
2888 static int
2889 linux_nat_supports_stopped_by_hw_breakpoint (struct target_ops *ops)
2890 {
2891   return USE_SIGTRAP_SIGINFO;
2892 }
2893
2894 /* Select one LWP out of those that have events pending.  */
2895
2896 static void
2897 select_event_lwp (ptid_t filter, struct lwp_info **orig_lp, int *status)
2898 {
2899   int num_events = 0;
2900   int random_selector;
2901   struct lwp_info *event_lp = NULL;
2902
2903   /* Record the wait status for the original LWP.  */
2904   (*orig_lp)->status = *status;
2905
2906   /* In all-stop, give preference to the LWP that is being
2907      single-stepped.  There will be at most one, and it will be the
2908      LWP that the core is most interested in.  If we didn't do this,
2909      then we'd have to handle pending step SIGTRAPs somehow in case
2910      the core later continues the previously-stepped thread, as
2911      otherwise we'd report the pending SIGTRAP then, and the core, not
2912      having stepped the thread, wouldn't understand what the trap was
2913      for, and therefore would report it to the user as a random
2914      signal.  */
2915   if (!target_is_non_stop_p ())
2916     {
2917       event_lp = iterate_over_lwps (filter,
2918                                     select_singlestep_lwp_callback, NULL);
2919       if (event_lp != NULL)
2920         {
2921           if (debug_linux_nat)
2922             fprintf_unfiltered (gdb_stdlog,
2923                                 "SEL: Select single-step %s\n",
2924                                 target_pid_to_str (event_lp->ptid));
2925         }
2926     }
2927
2928   if (event_lp == NULL)
2929     {
2930       /* Pick one at random, out of those which have had events.  */
2931
2932       /* First see how many events we have.  */
2933       iterate_over_lwps (filter, count_events_callback, &num_events);
2934       gdb_assert (num_events > 0);
2935
2936       /* Now randomly pick a LWP out of those that have had
2937          events.  */
2938       random_selector = (int)
2939         ((num_events * (double) rand ()) / (RAND_MAX + 1.0));
2940
2941       if (debug_linux_nat && num_events > 1)
2942         fprintf_unfiltered (gdb_stdlog,
2943                             "SEL: Found %d events, selecting #%d\n",
2944                             num_events, random_selector);
2945
2946       event_lp = iterate_over_lwps (filter,
2947                                     select_event_lwp_callback,
2948                                     &random_selector);
2949     }
2950
2951   if (event_lp != NULL)
2952     {
2953       /* Switch the event LWP.  */
2954       *orig_lp = event_lp;
2955       *status = event_lp->status;
2956     }
2957
2958   /* Flush the wait status for the event LWP.  */
2959   (*orig_lp)->status = 0;
2960 }
2961
2962 /* Return non-zero if LP has been resumed.  */
2963
2964 static int
2965 resumed_callback (struct lwp_info *lp, void *data)
2966 {
2967   return lp->resumed;
2968 }
2969
2970 /* Check if we should go on and pass this event to common code.
2971    Return the affected lwp if we are, or NULL otherwise.  */
2972
2973 static struct lwp_info *
2974 linux_nat_filter_event (int lwpid, int status)
2975 {
2976   struct lwp_info *lp;
2977   int event = linux_ptrace_get_extended_event (status);
2978
2979   lp = find_lwp_pid (pid_to_ptid (lwpid));
2980
2981   /* Check for stop events reported by a process we didn't already
2982      know about - anything not already in our LWP list.
2983
2984      If we're expecting to receive stopped processes after
2985      fork, vfork, and clone events, then we'll just add the
2986      new one to our list and go back to waiting for the event
2987      to be reported - the stopped process might be returned
2988      from waitpid before or after the event is.
2989
2990      But note the case of a non-leader thread exec'ing after the
2991      leader having exited, and gone from our lists.  The non-leader
2992      thread changes its tid to the tgid.  */
2993
2994   if (WIFSTOPPED (status) && lp == NULL
2995       && (WSTOPSIG (status) == SIGTRAP && event == PTRACE_EVENT_EXEC))
2996     {
2997       /* A multi-thread exec after we had seen the leader exiting.  */
2998       if (debug_linux_nat)
2999         fprintf_unfiltered (gdb_stdlog,
3000                             "LLW: Re-adding thread group leader LWP %d.\n",
3001                             lwpid);
3002
3003       lp = add_lwp (ptid_build (lwpid, lwpid, 0));
3004       lp->stopped = 1;
3005       lp->resumed = 1;
3006       add_thread (lp->ptid);
3007     }
3008
3009   if (WIFSTOPPED (status) && !lp)
3010     {
3011       if (debug_linux_nat)
3012         fprintf_unfiltered (gdb_stdlog,
3013                             "LHEW: saving LWP %ld status %s in stopped_pids list\n",
3014                             (long) lwpid, status_to_str (status));
3015       add_to_pid_list (&stopped_pids, lwpid, status);
3016       return NULL;
3017     }
3018
3019   /* Make sure we don't report an event for the exit of an LWP not in
3020      our list, i.e. not part of the current process.  This can happen
3021      if we detach from a program we originally forked and then it
3022      exits.  */
3023   if (!WIFSTOPPED (status) && !lp)
3024     return NULL;
3025
3026   /* This LWP is stopped now.  (And if dead, this prevents it from
3027      ever being continued.)  */
3028   lp->stopped = 1;
3029
3030   if (WIFSTOPPED (status) && lp->must_set_ptrace_flags)
3031     {
3032       struct inferior *inf = find_inferior_pid (ptid_get_pid (lp->ptid));
3033       int options = linux_nat_ptrace_options (inf->attach_flag);
3034
3035       linux_enable_event_reporting (ptid_get_lwp (lp->ptid), options);
3036       lp->must_set_ptrace_flags = 0;
3037     }
3038
3039   /* Handle GNU/Linux's syscall SIGTRAPs.  */
3040   if (WIFSTOPPED (status) && WSTOPSIG (status) == SYSCALL_SIGTRAP)
3041     {
3042       /* No longer need the sysgood bit.  The ptrace event ends up
3043          recorded in lp->waitstatus if we care for it.  We can carry
3044          on handling the event like a regular SIGTRAP from here
3045          on.  */
3046       status = W_STOPCODE (SIGTRAP);
3047       if (linux_handle_syscall_trap (lp, 0))
3048         return NULL;
3049     }
3050   else
3051     {
3052       /* Almost all other ptrace-stops are known to be outside of system
3053          calls, with further exceptions in linux_handle_extended_wait.  */
3054       lp->syscall_state = TARGET_WAITKIND_IGNORE;
3055     }
3056
3057   /* Handle GNU/Linux's extended waitstatus for trace events.  */
3058   if (WIFSTOPPED (status) && WSTOPSIG (status) == SIGTRAP
3059       && linux_is_extended_waitstatus (status))
3060     {
3061       if (debug_linux_nat)
3062         fprintf_unfiltered (gdb_stdlog,
3063                             "LLW: Handling extended status 0x%06x\n",
3064                             status);
3065       if (linux_handle_extended_wait (lp, status))
3066         return NULL;
3067     }
3068
3069   /* Check if the thread has exited.  */
3070   if (WIFEXITED (status) || WIFSIGNALED (status))
3071     {
3072       if (!report_thread_events
3073           && num_lwps (ptid_get_pid (lp->ptid)) > 1)
3074         {
3075           if (debug_linux_nat)
3076             fprintf_unfiltered (gdb_stdlog,
3077                                 "LLW: %s exited.\n",
3078                                 target_pid_to_str (lp->ptid));
3079
3080           /* If there is at least one more LWP, then the exit signal
3081              was not the end of the debugged application and should be
3082              ignored.  */
3083           exit_lwp (lp);
3084           return NULL;
3085         }
3086
3087       /* Note that even if the leader was ptrace-stopped, it can still
3088          exit, if e.g., some other thread brings down the whole
3089          process (calls `exit').  So don't assert that the lwp is
3090          resumed.  */
3091       if (debug_linux_nat)
3092         fprintf_unfiltered (gdb_stdlog,
3093                             "LWP %ld exited (resumed=%d)\n",
3094                             ptid_get_lwp (lp->ptid), lp->resumed);
3095
3096       /* Dead LWP's aren't expected to reported a pending sigstop.  */
3097       lp->signalled = 0;
3098
3099       /* Store the pending event in the waitstatus, because
3100          W_EXITCODE(0,0) == 0.  */
3101       store_waitstatus (&lp->waitstatus, status);
3102       return lp;
3103     }
3104
3105   /* Make sure we don't report a SIGSTOP that we sent ourselves in
3106      an attempt to stop an LWP.  */
3107   if (lp->signalled
3108       && WIFSTOPPED (status) && WSTOPSIG (status) == SIGSTOP)
3109     {
3110       lp->signalled = 0;
3111
3112       if (lp->last_resume_kind == resume_stop)
3113         {
3114           if (debug_linux_nat)
3115             fprintf_unfiltered (gdb_stdlog,
3116                                 "LLW: resume_stop SIGSTOP caught for %s.\n",
3117                                 target_pid_to_str (lp->ptid));
3118         }
3119       else
3120         {
3121           /* This is a delayed SIGSTOP.  Filter out the event.  */
3122
3123           if (debug_linux_nat)
3124             fprintf_unfiltered (gdb_stdlog,
3125                                 "LLW: %s %s, 0, 0 (discard delayed SIGSTOP)\n",
3126                                 lp->step ?
3127                                 "PTRACE_SINGLESTEP" : "PTRACE_CONT",
3128                                 target_pid_to_str (lp->ptid));
3129
3130           linux_resume_one_lwp (lp, lp->step, GDB_SIGNAL_0);
3131           gdb_assert (lp->resumed);
3132           return NULL;
3133         }
3134     }
3135
3136   /* Make sure we don't report a SIGINT that we have already displayed
3137      for another thread.  */
3138   if (lp->ignore_sigint
3139       && WIFSTOPPED (status) && WSTOPSIG (status) == SIGINT)
3140     {
3141       if (debug_linux_nat)
3142         fprintf_unfiltered (gdb_stdlog,
3143                             "LLW: Delayed SIGINT caught for %s.\n",
3144                             target_pid_to_str (lp->ptid));
3145
3146       /* This is a delayed SIGINT.  */
3147       lp->ignore_sigint = 0;
3148
3149       linux_resume_one_lwp (lp, lp->step, GDB_SIGNAL_0);
3150       if (debug_linux_nat)
3151         fprintf_unfiltered (gdb_stdlog,
3152                             "LLW: %s %s, 0, 0 (discard SIGINT)\n",
3153                             lp->step ?
3154                             "PTRACE_SINGLESTEP" : "PTRACE_CONT",
3155                             target_pid_to_str (lp->ptid));
3156       gdb_assert (lp->resumed);
3157
3158       /* Discard the event.  */
3159       return NULL;
3160     }
3161
3162   /* Don't report signals that GDB isn't interested in, such as
3163      signals that are neither printed nor stopped upon.  Stopping all
3164      threads can be a bit time-consuming so if we want decent
3165      performance with heavily multi-threaded programs, especially when
3166      they're using a high frequency timer, we'd better avoid it if we
3167      can.  */
3168   if (WIFSTOPPED (status))
3169     {
3170       enum gdb_signal signo = gdb_signal_from_host (WSTOPSIG (status));
3171
3172       if (!target_is_non_stop_p ())
3173         {
3174           /* Only do the below in all-stop, as we currently use SIGSTOP
3175              to implement target_stop (see linux_nat_stop) in
3176              non-stop.  */
3177           if (signo == GDB_SIGNAL_INT && signal_pass_state (signo) == 0)
3178             {
3179               /* If ^C/BREAK is typed at the tty/console, SIGINT gets
3180                  forwarded to the entire process group, that is, all LWPs
3181                  will receive it - unless they're using CLONE_THREAD to
3182                  share signals.  Since we only want to report it once, we
3183                  mark it as ignored for all LWPs except this one.  */
3184               iterate_over_lwps (pid_to_ptid (ptid_get_pid (lp->ptid)),
3185                                               set_ignore_sigint, NULL);
3186               lp->ignore_sigint = 0;
3187             }
3188           else
3189             maybe_clear_ignore_sigint (lp);
3190         }
3191
3192       /* When using hardware single-step, we need to report every signal.
3193          Otherwise, signals in pass_mask may be short-circuited
3194          except signals that might be caused by a breakpoint.  */
3195       if (!lp->step
3196           && WSTOPSIG (status) && sigismember (&pass_mask, WSTOPSIG (status))
3197           && !linux_wstatus_maybe_breakpoint (status))
3198         {
3199           linux_resume_one_lwp (lp, lp->step, signo);
3200           if (debug_linux_nat)
3201             fprintf_unfiltered (gdb_stdlog,
3202                                 "LLW: %s %s, %s (preempt 'handle')\n",
3203                                 lp->step ?
3204                                 "PTRACE_SINGLESTEP" : "PTRACE_CONT",
3205                                 target_pid_to_str (lp->ptid),
3206                                 (signo != GDB_SIGNAL_0
3207                                  ? strsignal (gdb_signal_to_host (signo))
3208                                  : "0"));
3209           return NULL;
3210         }
3211     }
3212
3213   /* An interesting event.  */
3214   gdb_assert (lp);
3215   lp->status = status;
3216   save_stop_reason (lp);
3217   return lp;
3218 }
3219
3220 /* Detect zombie thread group leaders, and "exit" them.  We can't reap
3221    their exits until all other threads in the group have exited.  */
3222
3223 static void
3224 check_zombie_leaders (void)
3225 {
3226   struct inferior *inf;
3227
3228   ALL_INFERIORS (inf)
3229     {
3230       struct lwp_info *leader_lp;
3231
3232       if (inf->pid == 0)
3233         continue;
3234
3235       leader_lp = find_lwp_pid (pid_to_ptid (inf->pid));
3236       if (leader_lp != NULL
3237           /* Check if there are other threads in the group, as we may
3238              have raced with the inferior simply exiting.  */
3239           && num_lwps (inf->pid) > 1
3240           && linux_proc_pid_is_zombie (inf->pid))
3241         {
3242           if (debug_linux_nat)
3243             fprintf_unfiltered (gdb_stdlog,
3244                                 "CZL: Thread group leader %d zombie "
3245                                 "(it exited, or another thread execd).\n",
3246                                 inf->pid);
3247
3248           /* A leader zombie can mean one of two things:
3249
3250              - It exited, and there's an exit status pending
3251              available, or only the leader exited (not the whole
3252              program).  In the latter case, we can't waitpid the
3253              leader's exit status until all other threads are gone.
3254
3255              - There are 3 or more threads in the group, and a thread
3256              other than the leader exec'd.  See comments on exec
3257              events at the top of the file.  We could try
3258              distinguishing the exit and exec cases, by waiting once
3259              more, and seeing if something comes out, but it doesn't
3260              sound useful.  The previous leader _does_ go away, and
3261              we'll re-add the new one once we see the exec event
3262              (which is just the same as what would happen if the
3263              previous leader did exit voluntarily before some other
3264              thread execs).  */
3265
3266           if (debug_linux_nat)
3267             fprintf_unfiltered (gdb_stdlog,
3268                                 "CZL: Thread group leader %d vanished.\n",
3269                                 inf->pid);
3270           exit_lwp (leader_lp);
3271         }
3272     }
3273 }
3274
3275 /* Convenience function that is called when the kernel reports an exit
3276    event.  This decides whether to report the event to GDB as a
3277    process exit event, a thread exit event, or to suppress the
3278    event.  */
3279
3280 static ptid_t
3281 filter_exit_event (struct lwp_info *event_child,
3282                    struct target_waitstatus *ourstatus)
3283 {
3284   ptid_t ptid = event_child->ptid;
3285
3286   if (num_lwps (ptid_get_pid (ptid)) > 1)
3287     {
3288       if (report_thread_events)
3289         ourstatus->kind = TARGET_WAITKIND_THREAD_EXITED;
3290       else
3291         ourstatus->kind = TARGET_WAITKIND_IGNORE;
3292
3293       exit_lwp (event_child);
3294     }
3295
3296   return ptid;
3297 }
3298
3299 static ptid_t
3300 linux_nat_wait_1 (struct target_ops *ops,
3301                   ptid_t ptid, struct target_waitstatus *ourstatus,
3302                   int target_options)
3303 {
3304   sigset_t prev_mask;
3305   enum resume_kind last_resume_kind;
3306   struct lwp_info *lp;
3307   int status;
3308
3309   if (debug_linux_nat)
3310     fprintf_unfiltered (gdb_stdlog, "LLW: enter\n");
3311
3312   /* The first time we get here after starting a new inferior, we may
3313      not have added it to the LWP list yet - this is the earliest
3314      moment at which we know its PID.  */
3315   if (ptid_is_pid (inferior_ptid))
3316     {
3317       /* Upgrade the main thread's ptid.  */
3318       thread_change_ptid (inferior_ptid,
3319                           ptid_build (ptid_get_pid (inferior_ptid),
3320                                       ptid_get_pid (inferior_ptid), 0));
3321
3322       lp = add_initial_lwp (inferior_ptid);
3323       lp->resumed = 1;
3324     }
3325
3326   /* Make sure SIGCHLD is blocked until the sigsuspend below.  */
3327   block_child_signals (&prev_mask);
3328
3329   /* First check if there is a LWP with a wait status pending.  */
3330   lp = iterate_over_lwps (ptid, status_callback, NULL);
3331   if (lp != NULL)
3332     {
3333       if (debug_linux_nat)
3334         fprintf_unfiltered (gdb_stdlog,
3335                             "LLW: Using pending wait status %s for %s.\n",
3336                             status_to_str (lp->status),
3337                             target_pid_to_str (lp->ptid));
3338     }
3339
3340   /* But if we don't find a pending event, we'll have to wait.  Always
3341      pull all events out of the kernel.  We'll randomly select an
3342      event LWP out of all that have events, to prevent starvation.  */
3343
3344   while (lp == NULL)
3345     {
3346       pid_t lwpid;
3347
3348       /* Always use -1 and WNOHANG, due to couple of a kernel/ptrace
3349          quirks:
3350
3351          - If the thread group leader exits while other threads in the
3352            thread group still exist, waitpid(TGID, ...) hangs.  That
3353            waitpid won't return an exit status until the other threads
3354            in the group are reapped.
3355
3356          - When a non-leader thread execs, that thread just vanishes
3357            without reporting an exit (so we'd hang if we waited for it
3358            explicitly in that case).  The exec event is reported to
3359            the TGID pid.  */
3360
3361       errno = 0;
3362       lwpid = my_waitpid (-1, &status,  __WALL | WNOHANG);
3363
3364       if (debug_linux_nat)
3365         fprintf_unfiltered (gdb_stdlog,
3366                             "LNW: waitpid(-1, ...) returned %d, %s\n",
3367                             lwpid, errno ? safe_strerror (errno) : "ERRNO-OK");
3368
3369       if (lwpid > 0)
3370         {
3371           if (debug_linux_nat)
3372             {
3373               fprintf_unfiltered (gdb_stdlog,
3374                                   "LLW: waitpid %ld received %s\n",
3375                                   (long) lwpid, status_to_str (status));
3376             }
3377
3378           linux_nat_filter_event (lwpid, status);
3379           /* Retry until nothing comes out of waitpid.  A single
3380              SIGCHLD can indicate more than one child stopped.  */
3381           continue;
3382         }
3383
3384       /* Now that we've pulled all events out of the kernel, resume
3385          LWPs that don't have an interesting event to report.  */
3386       iterate_over_lwps (minus_one_ptid,
3387                          resume_stopped_resumed_lwps, &minus_one_ptid);
3388
3389       /* ... and find an LWP with a status to report to the core, if
3390          any.  */
3391       lp = iterate_over_lwps (ptid, status_callback, NULL);
3392       if (lp != NULL)
3393         break;
3394
3395       /* Check for zombie thread group leaders.  Those can't be reaped
3396          until all other threads in the thread group are.  */
3397       check_zombie_leaders ();
3398
3399       /* If there are no resumed children left, bail.  We'd be stuck
3400          forever in the sigsuspend call below otherwise.  */
3401       if (iterate_over_lwps (ptid, resumed_callback, NULL) == NULL)
3402         {
3403           if (debug_linux_nat)
3404             fprintf_unfiltered (gdb_stdlog, "LLW: exit (no resumed LWP)\n");
3405
3406           ourstatus->kind = TARGET_WAITKIND_NO_RESUMED;
3407
3408           restore_child_signals_mask (&prev_mask);
3409           return minus_one_ptid;
3410         }
3411
3412       /* No interesting event to report to the core.  */
3413
3414       if (target_options & TARGET_WNOHANG)
3415         {
3416           if (debug_linux_nat)
3417             fprintf_unfiltered (gdb_stdlog, "LLW: exit (ignore)\n");
3418
3419           ourstatus->kind = TARGET_WAITKIND_IGNORE;
3420           restore_child_signals_mask (&prev_mask);
3421           return minus_one_ptid;
3422         }
3423
3424       /* We shouldn't end up here unless we want to try again.  */
3425       gdb_assert (lp == NULL);
3426
3427       /* Block until we get an event reported with SIGCHLD.  */
3428       wait_for_signal ();
3429     }
3430
3431   gdb_assert (lp);
3432
3433   status = lp->status;
3434   lp->status = 0;
3435
3436   if (!target_is_non_stop_p ())
3437     {
3438       /* Now stop all other LWP's ...  */
3439       iterate_over_lwps (minus_one_ptid, stop_callback, NULL);
3440
3441       /* ... and wait until all of them have reported back that
3442          they're no longer running.  */
3443       iterate_over_lwps (minus_one_ptid, stop_wait_callback, NULL);
3444     }
3445
3446   /* If we're not waiting for a specific LWP, choose an event LWP from
3447      among those that have had events.  Giving equal priority to all
3448      LWPs that have had events helps prevent starvation.  */
3449   if (ptid_equal (ptid, minus_one_ptid) || ptid_is_pid (ptid))
3450     select_event_lwp (ptid, &lp, &status);
3451
3452   gdb_assert (lp != NULL);
3453
3454   /* Now that we've selected our final event LWP, un-adjust its PC if
3455      it was a software breakpoint, and we can't reliably support the
3456      "stopped by software breakpoint" stop reason.  */
3457   if (lp->stop_reason == TARGET_STOPPED_BY_SW_BREAKPOINT
3458       && !USE_SIGTRAP_SIGINFO)
3459     {
3460       struct regcache *regcache = get_thread_regcache (lp->ptid);
3461       struct gdbarch *gdbarch = regcache->arch ();
3462       int decr_pc = gdbarch_decr_pc_after_break (gdbarch);
3463
3464       if (decr_pc != 0)
3465         {
3466           CORE_ADDR pc;
3467
3468           pc = regcache_read_pc (regcache);
3469           regcache_write_pc (regcache, pc + decr_pc);
3470         }
3471     }
3472
3473   /* We'll need this to determine whether to report a SIGSTOP as
3474      GDB_SIGNAL_0.  Need to take a copy because resume_clear_callback
3475      clears it.  */
3476   last_resume_kind = lp->last_resume_kind;
3477
3478   if (!target_is_non_stop_p ())
3479     {
3480       /* In all-stop, from the core's perspective, all LWPs are now
3481          stopped until a new resume action is sent over.  */
3482       iterate_over_lwps (minus_one_ptid, resume_clear_callback, NULL);
3483     }
3484   else
3485     {
3486       resume_clear_callback (lp, NULL);
3487     }
3488
3489   if (linux_nat_status_is_event (status))
3490     {
3491       if (debug_linux_nat)
3492         fprintf_unfiltered (gdb_stdlog,
3493                             "LLW: trap ptid is %s.\n",
3494                             target_pid_to_str (lp->ptid));
3495     }
3496
3497   if (lp->waitstatus.kind != TARGET_WAITKIND_IGNORE)
3498     {
3499       *ourstatus = lp->waitstatus;
3500       lp->waitstatus.kind = TARGET_WAITKIND_IGNORE;
3501     }
3502   else
3503     store_waitstatus (ourstatus, status);
3504
3505   if (debug_linux_nat)
3506     fprintf_unfiltered (gdb_stdlog, "LLW: exit\n");
3507
3508   restore_child_signals_mask (&prev_mask);
3509
3510   if (last_resume_kind == resume_stop
3511       && ourstatus->kind == TARGET_WAITKIND_STOPPED
3512       && WSTOPSIG (status) == SIGSTOP)
3513     {
3514       /* A thread that has been requested to stop by GDB with
3515          target_stop, and it stopped cleanly, so report as SIG0.  The
3516          use of SIGSTOP is an implementation detail.  */
3517       ourstatus->value.sig = GDB_SIGNAL_0;
3518     }
3519
3520   if (ourstatus->kind == TARGET_WAITKIND_EXITED
3521       || ourstatus->kind == TARGET_WAITKIND_SIGNALLED)
3522     lp->core = -1;
3523   else
3524     lp->core = linux_common_core_of_thread (lp->ptid);
3525
3526   if (ourstatus->kind == TARGET_WAITKIND_EXITED)
3527     return filter_exit_event (lp, ourstatus);
3528
3529   return lp->ptid;
3530 }
3531
3532 /* Resume LWPs that are currently stopped without any pending status
3533    to report, but are resumed from the core's perspective.  */
3534
3535 static int
3536 resume_stopped_resumed_lwps (struct lwp_info *lp, void *data)
3537 {
3538   ptid_t *wait_ptid_p = (ptid_t *) data;
3539
3540   if (!lp->stopped)
3541     {
3542       if (debug_linux_nat)
3543         fprintf_unfiltered (gdb_stdlog,
3544                             "RSRL: NOT resuming LWP %s, not stopped\n",
3545                             target_pid_to_str (lp->ptid));
3546     }
3547   else if (!lp->resumed)
3548     {
3549       if (debug_linux_nat)
3550         fprintf_unfiltered (gdb_stdlog,
3551                             "RSRL: NOT resuming LWP %s, not resumed\n",
3552                             target_pid_to_str (lp->ptid));
3553     }
3554   else if (lwp_status_pending_p (lp))
3555     {
3556       if (debug_linux_nat)
3557         fprintf_unfiltered (gdb_stdlog,
3558                             "RSRL: NOT resuming LWP %s, has pending status\n",
3559                             target_pid_to_str (lp->ptid));
3560     }
3561   else
3562     {
3563       struct regcache *regcache = get_thread_regcache (lp->ptid);
3564       struct gdbarch *gdbarch = regcache->arch ();
3565
3566       TRY
3567         {
3568           CORE_ADDR pc = regcache_read_pc (regcache);
3569           int leave_stopped = 0;
3570
3571           /* Don't bother if there's a breakpoint at PC that we'd hit
3572              immediately, and we're not waiting for this LWP.  */
3573           if (!ptid_match (lp->ptid, *wait_ptid_p))
3574             {
3575               if (breakpoint_inserted_here_p (regcache->aspace (), pc))
3576                 leave_stopped = 1;
3577             }
3578
3579           if (!leave_stopped)
3580             {
3581               if (debug_linux_nat)
3582                 fprintf_unfiltered (gdb_stdlog,
3583                                     "RSRL: resuming stopped-resumed LWP %s at "
3584                                     "%s: step=%d\n",
3585                                     target_pid_to_str (lp->ptid),
3586                                     paddress (gdbarch, pc),
3587                                     lp->step);
3588
3589               linux_resume_one_lwp_throw (lp, lp->step, GDB_SIGNAL_0);
3590             }
3591         }
3592       CATCH (ex, RETURN_MASK_ERROR)
3593         {
3594           if (!check_ptrace_stopped_lwp_gone (lp))
3595             throw_exception (ex);
3596         }
3597       END_CATCH
3598     }
3599
3600   return 0;
3601 }
3602
3603 static ptid_t
3604 linux_nat_wait (struct target_ops *ops,
3605                 ptid_t ptid, struct target_waitstatus *ourstatus,
3606                 int target_options)
3607 {
3608   ptid_t event_ptid;
3609
3610   if (debug_linux_nat)
3611     {
3612       char *options_string;
3613
3614       options_string = target_options_to_string (target_options);
3615       fprintf_unfiltered (gdb_stdlog,
3616                           "linux_nat_wait: [%s], [%s]\n",
3617                           target_pid_to_str (ptid),
3618                           options_string);
3619       xfree (options_string);
3620     }
3621
3622   /* Flush the async file first.  */
3623   if (target_is_async_p ())
3624     async_file_flush ();
3625
3626   /* Resume LWPs that are currently stopped without any pending status
3627      to report, but are resumed from the core's perspective.  LWPs get
3628      in this state if we find them stopping at a time we're not
3629      interested in reporting the event (target_wait on a
3630      specific_process, for example, see linux_nat_wait_1), and
3631      meanwhile the event became uninteresting.  Don't bother resuming
3632      LWPs we're not going to wait for if they'd stop immediately.  */
3633   if (target_is_non_stop_p ())
3634     iterate_over_lwps (minus_one_ptid, resume_stopped_resumed_lwps, &ptid);
3635
3636   event_ptid = linux_nat_wait_1 (ops, ptid, ourstatus, target_options);
3637
3638   /* If we requested any event, and something came out, assume there
3639      may be more.  If we requested a specific lwp or process, also
3640      assume there may be more.  */
3641   if (target_is_async_p ()
3642       && ((ourstatus->kind != TARGET_WAITKIND_IGNORE
3643            && ourstatus->kind != TARGET_WAITKIND_NO_RESUMED)
3644           || !ptid_equal (ptid, minus_one_ptid)))
3645     async_file_mark ();
3646
3647   return event_ptid;
3648 }
3649
3650 /* Kill one LWP.  */
3651
3652 static void
3653 kill_one_lwp (pid_t pid)
3654 {
3655   /* PTRACE_KILL may resume the inferior.  Send SIGKILL first.  */
3656
3657   errno = 0;
3658   kill_lwp (pid, SIGKILL);
3659   if (debug_linux_nat)
3660     {
3661       int save_errno = errno;
3662
3663       fprintf_unfiltered (gdb_stdlog,
3664                           "KC:  kill (SIGKILL) %ld, 0, 0 (%s)\n", (long) pid,
3665                           save_errno ? safe_strerror (save_errno) : "OK");
3666     }
3667
3668   /* Some kernels ignore even SIGKILL for processes under ptrace.  */
3669
3670   errno = 0;
3671   ptrace (PTRACE_KILL, pid, 0, 0);
3672   if (debug_linux_nat)
3673     {
3674       int save_errno = errno;
3675
3676       fprintf_unfiltered (gdb_stdlog,
3677                           "KC:  PTRACE_KILL %ld, 0, 0 (%s)\n", (long) pid,
3678                           save_errno ? safe_strerror (save_errno) : "OK");
3679     }
3680 }
3681
3682 /* Wait for an LWP to die.  */
3683
3684 static void
3685 kill_wait_one_lwp (pid_t pid)
3686 {
3687   pid_t res;
3688
3689   /* We must make sure that there are no pending events (delayed
3690      SIGSTOPs, pending SIGTRAPs, etc.) to make sure the current
3691      program doesn't interfere with any following debugging session.  */
3692
3693   do
3694     {
3695       res = my_waitpid (pid, NULL, __WALL);
3696       if (res != (pid_t) -1)
3697         {
3698           if (debug_linux_nat)
3699             fprintf_unfiltered (gdb_stdlog,
3700                                 "KWC: wait %ld received unknown.\n",
3701                                 (long) pid);
3702           /* The Linux kernel sometimes fails to kill a thread
3703              completely after PTRACE_KILL; that goes from the stop
3704              point in do_fork out to the one in get_signal_to_deliver
3705              and waits again.  So kill it again.  */
3706           kill_one_lwp (pid);
3707         }
3708     }
3709   while (res == pid);
3710
3711   gdb_assert (res == -1 && errno == ECHILD);
3712 }
3713
3714 /* Callback for iterate_over_lwps.  */
3715
3716 static int
3717 kill_callback (struct lwp_info *lp, void *data)
3718 {
3719   kill_one_lwp (ptid_get_lwp (lp->ptid));
3720   return 0;
3721 }
3722
3723 /* Callback for iterate_over_lwps.  */
3724
3725 static int
3726 kill_wait_callback (struct lwp_info *lp, void *data)
3727 {
3728   kill_wait_one_lwp (ptid_get_lwp (lp->ptid));
3729   return 0;
3730 }
3731
3732 /* Kill the fork children of any threads of inferior INF that are
3733    stopped at a fork event.  */
3734
3735 static void
3736 kill_unfollowed_fork_children (struct inferior *inf)
3737 {
3738   struct thread_info *thread;
3739
3740   ALL_NON_EXITED_THREADS (thread)
3741     if (thread->inf == inf)
3742       {
3743         struct target_waitstatus *ws = &thread->pending_follow;
3744
3745         if (ws->kind == TARGET_WAITKIND_FORKED
3746             || ws->kind == TARGET_WAITKIND_VFORKED)
3747           {
3748             ptid_t child_ptid = ws->value.related_pid;
3749             int child_pid = ptid_get_pid (child_ptid);
3750             int child_lwp = ptid_get_lwp (child_ptid);
3751
3752             kill_one_lwp (child_lwp);
3753             kill_wait_one_lwp (child_lwp);
3754
3755             /* Let the arch-specific native code know this process is
3756                gone.  */
3757             linux_nat_forget_process (child_pid);
3758           }
3759       }
3760 }
3761
3762 static void
3763 linux_nat_kill (struct target_ops *ops)
3764 {
3765   /* If we're stopped while forking and we haven't followed yet,
3766      kill the other task.  We need to do this first because the
3767      parent will be sleeping if this is a vfork.  */
3768   kill_unfollowed_fork_children (current_inferior ());
3769
3770   if (forks_exist_p ())
3771     linux_fork_killall ();
3772   else
3773     {
3774       ptid_t ptid = pid_to_ptid (ptid_get_pid (inferior_ptid));
3775
3776       /* Stop all threads before killing them, since ptrace requires
3777          that the thread is stopped to sucessfully PTRACE_KILL.  */
3778       iterate_over_lwps (ptid, stop_callback, NULL);
3779       /* ... and wait until all of them have reported back that
3780          they're no longer running.  */
3781       iterate_over_lwps (ptid, stop_wait_callback, NULL);
3782
3783       /* Kill all LWP's ...  */
3784       iterate_over_lwps (ptid, kill_callback, NULL);
3785
3786       /* ... and wait until we've flushed all events.  */
3787       iterate_over_lwps (ptid, kill_wait_callback, NULL);
3788     }
3789
3790   target_mourn_inferior (inferior_ptid);
3791 }
3792
3793 static void
3794 linux_nat_mourn_inferior (struct target_ops *ops)
3795 {
3796   int pid = ptid_get_pid (inferior_ptid);
3797
3798   purge_lwp_list (pid);
3799
3800   if (! forks_exist_p ())
3801     /* Normal case, no other forks available.  */
3802     linux_ops->to_mourn_inferior (ops);
3803   else
3804     /* Multi-fork case.  The current inferior_ptid has exited, but
3805        there are other viable forks to debug.  Delete the exiting
3806        one and context-switch to the first available.  */
3807     linux_fork_mourn_inferior ();
3808
3809   /* Let the arch-specific native code know this process is gone.  */
3810   linux_nat_forget_process (pid);
3811 }
3812
3813 /* Convert a native/host siginfo object, into/from the siginfo in the
3814    layout of the inferiors' architecture.  */
3815
3816 static void
3817 siginfo_fixup (siginfo_t *siginfo, gdb_byte *inf_siginfo, int direction)
3818 {
3819   int done = 0;
3820
3821   if (linux_nat_siginfo_fixup != NULL)
3822     done = linux_nat_siginfo_fixup (siginfo, inf_siginfo, direction);
3823
3824   /* If there was no callback, or the callback didn't do anything,
3825      then just do a straight memcpy.  */
3826   if (!done)
3827     {
3828       if (direction == 1)
3829         memcpy (siginfo, inf_siginfo, sizeof (siginfo_t));
3830       else
3831         memcpy (inf_siginfo, siginfo, sizeof (siginfo_t));
3832     }
3833 }
3834
3835 static enum target_xfer_status
3836 linux_xfer_siginfo (struct target_ops *ops, enum target_object object,
3837                     const char *annex, gdb_byte *readbuf,
3838                     const gdb_byte *writebuf, ULONGEST offset, ULONGEST len,
3839                     ULONGEST *xfered_len)
3840 {
3841   int pid;
3842   siginfo_t siginfo;
3843   gdb_byte inf_siginfo[sizeof (siginfo_t)];
3844
3845   gdb_assert (object == TARGET_OBJECT_SIGNAL_INFO);
3846   gdb_assert (readbuf || writebuf);
3847
3848   pid = ptid_get_lwp (inferior_ptid);
3849   if (pid == 0)
3850     pid = ptid_get_pid (inferior_ptid);
3851
3852   if (offset > sizeof (siginfo))
3853     return TARGET_XFER_E_IO;
3854
3855   errno = 0;
3856   ptrace (PTRACE_GETSIGINFO, pid, (PTRACE_TYPE_ARG3) 0, &siginfo);
3857   if (errno != 0)
3858     return TARGET_XFER_E_IO;
3859
3860   /* When GDB is built as a 64-bit application, ptrace writes into
3861      SIGINFO an object with 64-bit layout.  Since debugging a 32-bit
3862      inferior with a 64-bit GDB should look the same as debugging it
3863      with a 32-bit GDB, we need to convert it.  GDB core always sees
3864      the converted layout, so any read/write will have to be done
3865      post-conversion.  */
3866   siginfo_fixup (&siginfo, inf_siginfo, 0);
3867
3868   if (offset + len > sizeof (siginfo))
3869     len = sizeof (siginfo) - offset;
3870
3871   if (readbuf != NULL)
3872     memcpy (readbuf, inf_siginfo + offset, len);
3873   else
3874     {
3875       memcpy (inf_siginfo + offset, writebuf, len);
3876
3877       /* Convert back to ptrace layout before flushing it out.  */
3878       siginfo_fixup (&siginfo, inf_siginfo, 1);
3879
3880       errno = 0;
3881       ptrace (PTRACE_SETSIGINFO, pid, (PTRACE_TYPE_ARG3) 0, &siginfo);
3882       if (errno != 0)
3883         return TARGET_XFER_E_IO;
3884     }
3885
3886   *xfered_len = len;
3887   return TARGET_XFER_OK;
3888 }
3889
3890 static enum target_xfer_status
3891 linux_nat_xfer_partial (struct target_ops *ops, enum target_object object,
3892                         const char *annex, gdb_byte *readbuf,
3893                         const gdb_byte *writebuf,
3894                         ULONGEST offset, ULONGEST len, ULONGEST *xfered_len)
3895 {
3896   enum target_xfer_status xfer;
3897
3898   if (object == TARGET_OBJECT_SIGNAL_INFO)
3899     return linux_xfer_siginfo (ops, object, annex, readbuf, writebuf,
3900                                offset, len, xfered_len);
3901
3902   /* The target is connected but no live inferior is selected.  Pass
3903      this request down to a lower stratum (e.g., the executable
3904      file).  */
3905   if (object == TARGET_OBJECT_MEMORY && ptid_equal (inferior_ptid, null_ptid))
3906     return TARGET_XFER_EOF;
3907
3908   xfer = linux_ops->to_xfer_partial (ops, object, annex, readbuf, writebuf,
3909                                      offset, len, xfered_len);
3910
3911   return xfer;
3912 }
3913
3914 static int
3915 linux_nat_thread_alive (struct target_ops *ops, ptid_t ptid)
3916 {
3917   /* As long as a PTID is in lwp list, consider it alive.  */
3918   return find_lwp_pid (ptid) != NULL;
3919 }
3920
3921 /* Implement the to_update_thread_list target method for this
3922    target.  */
3923
3924 static void
3925 linux_nat_update_thread_list (struct target_ops *ops)
3926 {
3927   struct lwp_info *lwp;
3928
3929   /* We add/delete threads from the list as clone/exit events are
3930      processed, so just try deleting exited threads still in the
3931      thread list.  */
3932   delete_exited_threads ();
3933
3934   /* Update the processor core that each lwp/thread was last seen
3935      running on.  */
3936   ALL_LWPS (lwp)
3937     {
3938       /* Avoid accessing /proc if the thread hasn't run since we last
3939          time we fetched the thread's core.  Accessing /proc becomes
3940          noticeably expensive when we have thousands of LWPs.  */
3941       if (lwp->core == -1)
3942         lwp->core = linux_common_core_of_thread (lwp->ptid);
3943     }
3944 }
3945
3946 static const char *
3947 linux_nat_pid_to_str (struct target_ops *ops, ptid_t ptid)
3948 {
3949   static char buf[64];
3950
3951   if (ptid_lwp_p (ptid)
3952       && (ptid_get_pid (ptid) != ptid_get_lwp (ptid)
3953           || num_lwps (ptid_get_pid (ptid)) > 1))
3954     {
3955       snprintf (buf, sizeof (buf), "LWP %ld", ptid_get_lwp (ptid));
3956       return buf;
3957     }
3958
3959   return normal_pid_to_str (ptid);
3960 }
3961
3962 static const char *
3963 linux_nat_thread_name (struct target_ops *self, struct thread_info *thr)
3964 {
3965   return linux_proc_tid_get_name (thr->ptid);
3966 }
3967
3968 /* Accepts an integer PID; Returns a string representing a file that
3969    can be opened to get the symbols for the child process.  */
3970
3971 static char *
3972 linux_child_pid_to_exec_file (struct target_ops *self, int pid)
3973 {
3974   return linux_proc_pid_to_exec_file (pid);
3975 }
3976
3977 /* Implement the to_xfer_partial target method using /proc/<pid>/mem.
3978    Because we can use a single read/write call, this can be much more
3979    efficient than banging away at PTRACE_PEEKTEXT.  */
3980
3981 static enum target_xfer_status
3982 linux_proc_xfer_partial (struct target_ops *ops, enum target_object object,
3983                          const char *annex, gdb_byte *readbuf,
3984                          const gdb_byte *writebuf,
3985                          ULONGEST offset, LONGEST len, ULONGEST *xfered_len)
3986 {
3987   LONGEST ret;
3988   int fd;
3989   char filename[64];
3990
3991   if (object != TARGET_OBJECT_MEMORY)
3992     return TARGET_XFER_EOF;
3993
3994   /* Don't bother for one word.  */
3995   if (len < 3 * sizeof (long))
3996     return TARGET_XFER_EOF;
3997
3998   /* We could keep this file open and cache it - possibly one per
3999      thread.  That requires some juggling, but is even faster.  */
4000   xsnprintf (filename, sizeof filename, "/proc/%ld/mem",
4001              ptid_get_lwp (inferior_ptid));
4002   fd = gdb_open_cloexec (filename, ((readbuf ? O_RDONLY : O_WRONLY)
4003                                     | O_LARGEFILE), 0);
4004   if (fd == -1)
4005     return TARGET_XFER_EOF;
4006
4007   /* Use pread64/pwrite64 if available, since they save a syscall and can
4008      handle 64-bit offsets even on 32-bit platforms (for instance, SPARC
4009      debugging a SPARC64 application).  */
4010 #ifdef HAVE_PREAD64
4011   ret = (readbuf ? pread64 (fd, readbuf, len, offset)
4012          : pwrite64 (fd, writebuf, len, offset));
4013 #else
4014   ret = lseek (fd, offset, SEEK_SET);
4015   if (ret != -1)
4016     ret = (readbuf ? read (fd, readbuf, len)
4017            : write (fd, writebuf, len));
4018 #endif
4019
4020   close (fd);
4021
4022   if (ret == -1 || ret == 0)
4023     return TARGET_XFER_EOF;
4024   else
4025     {
4026       *xfered_len = ret;
4027       return TARGET_XFER_OK;
4028     }
4029 }
4030
4031
4032 /* Enumerate spufs IDs for process PID.  */
4033 static LONGEST
4034 spu_enumerate_spu_ids (int pid, gdb_byte *buf, ULONGEST offset, ULONGEST len)
4035 {
4036   enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch ());
4037   LONGEST pos = 0;
4038   LONGEST written = 0;
4039   char path[128];
4040   DIR *dir;
4041   struct dirent *entry;
4042
4043   xsnprintf (path, sizeof path, "/proc/%d/fd", pid);
4044   dir = opendir (path);
4045   if (!dir)
4046     return -1;
4047
4048   rewinddir (dir);
4049   while ((entry = readdir (dir)) != NULL)
4050     {
4051       struct stat st;
4052       struct statfs stfs;
4053       int fd;
4054
4055       fd = atoi (entry->d_name);
4056       if (!fd)
4057         continue;
4058
4059       xsnprintf (path, sizeof path, "/proc/%d/fd/%d", pid, fd);
4060       if (stat (path, &st) != 0)
4061         continue;
4062       if (!S_ISDIR (st.st_mode))
4063         continue;
4064
4065       if (statfs (path, &stfs) != 0)
4066         continue;
4067       if (stfs.f_type != SPUFS_MAGIC)
4068         continue;
4069
4070       if (pos >= offset && pos + 4 <= offset + len)
4071         {
4072           store_unsigned_integer (buf + pos - offset, 4, byte_order, fd);
4073           written += 4;
4074         }
4075       pos += 4;
4076     }
4077
4078   closedir (dir);
4079   return written;
4080 }
4081
4082 /* Implement the to_xfer_partial interface for the TARGET_OBJECT_SPU
4083    object type, using the /proc file system.  */
4084
4085 static enum target_xfer_status
4086 linux_proc_xfer_spu (struct target_ops *ops, enum target_object object,
4087                      const char *annex, gdb_byte *readbuf,
4088                      const gdb_byte *writebuf,
4089                      ULONGEST offset, ULONGEST len, ULONGEST *xfered_len)
4090 {
4091   char buf[128];
4092   int fd = 0;
4093   int ret = -1;
4094   int pid = ptid_get_lwp (inferior_ptid);
4095
4096   if (!annex)
4097     {
4098       if (!readbuf)
4099         return TARGET_XFER_E_IO;
4100       else
4101         {
4102           LONGEST l = spu_enumerate_spu_ids (pid, readbuf, offset, len);
4103
4104           if (l < 0)
4105             return TARGET_XFER_E_IO;
4106           else if (l == 0)
4107             return TARGET_XFER_EOF;
4108           else
4109             {
4110               *xfered_len = (ULONGEST) l;
4111               return TARGET_XFER_OK;
4112             }
4113         }
4114     }
4115
4116   xsnprintf (buf, sizeof buf, "/proc/%d/fd/%s", pid, annex);
4117   fd = gdb_open_cloexec (buf, writebuf? O_WRONLY : O_RDONLY, 0);
4118   if (fd <= 0)
4119     return TARGET_XFER_E_IO;
4120
4121   if (offset != 0
4122       && lseek (fd, (off_t) offset, SEEK_SET) != (off_t) offset)
4123     {
4124       close (fd);
4125       return TARGET_XFER_EOF;
4126     }
4127
4128   if (writebuf)
4129     ret = write (fd, writebuf, (size_t) len);
4130   else if (readbuf)
4131     ret = read (fd, readbuf, (size_t) len);
4132
4133   close (fd);
4134
4135   if (ret < 0)
4136     return TARGET_XFER_E_IO;
4137   else if (ret == 0)
4138     return TARGET_XFER_EOF;
4139   else
4140     {
4141       *xfered_len = (ULONGEST) ret;
4142       return TARGET_XFER_OK;
4143     }
4144 }
4145
4146
4147 /* Parse LINE as a signal set and add its set bits to SIGS.  */
4148
4149 static void
4150 add_line_to_sigset (const char *line, sigset_t *sigs)
4151 {
4152   int len = strlen (line) - 1;
4153   const char *p;
4154   int signum;
4155
4156   if (line[len] != '\n')
4157     error (_("Could not parse signal set: %s"), line);
4158
4159   p = line;
4160   signum = len * 4;
4161   while (len-- > 0)
4162     {
4163       int digit;
4164
4165       if (*p >= '0' && *p <= '9')
4166         digit = *p - '0';
4167       else if (*p >= 'a' && *p <= 'f')
4168         digit = *p - 'a' + 10;
4169       else
4170         error (_("Could not parse signal set: %s"), line);
4171
4172       signum -= 4;
4173
4174       if (digit & 1)
4175         sigaddset (sigs, signum + 1);
4176       if (digit & 2)
4177         sigaddset (sigs, signum + 2);
4178       if (digit & 4)
4179         sigaddset (sigs, signum + 3);
4180       if (digit & 8)
4181         sigaddset (sigs, signum + 4);
4182
4183       p++;
4184     }
4185 }
4186
4187 /* Find process PID's pending signals from /proc/pid/status and set
4188    SIGS to match.  */
4189
4190 void
4191 linux_proc_pending_signals (int pid, sigset_t *pending,
4192                             sigset_t *blocked, sigset_t *ignored)
4193 {
4194   char buffer[PATH_MAX], fname[PATH_MAX];
4195
4196   sigemptyset (pending);
4197   sigemptyset (blocked);
4198   sigemptyset (ignored);
4199   xsnprintf (fname, sizeof fname, "/proc/%d/status", pid);
4200   gdb_file_up procfile = gdb_fopen_cloexec (fname, "r");
4201   if (procfile == NULL)
4202     error (_("Could not open %s"), fname);
4203
4204   while (fgets (buffer, PATH_MAX, procfile.get ()) != NULL)
4205     {
4206       /* Normal queued signals are on the SigPnd line in the status
4207          file.  However, 2.6 kernels also have a "shared" pending
4208          queue for delivering signals to a thread group, so check for
4209          a ShdPnd line also.
4210
4211          Unfortunately some Red Hat kernels include the shared pending
4212          queue but not the ShdPnd status field.  */
4213
4214       if (startswith (buffer, "SigPnd:\t"))
4215         add_line_to_sigset (buffer + 8, pending);
4216       else if (startswith (buffer, "ShdPnd:\t"))
4217         add_line_to_sigset (buffer + 8, pending);
4218       else if (startswith (buffer, "SigBlk:\t"))
4219         add_line_to_sigset (buffer + 8, blocked);
4220       else if (startswith (buffer, "SigIgn:\t"))
4221         add_line_to_sigset (buffer + 8, ignored);
4222     }
4223 }
4224
4225 static enum target_xfer_status
4226 linux_nat_xfer_osdata (struct target_ops *ops, enum target_object object,
4227                        const char *annex, gdb_byte *readbuf,
4228                        const gdb_byte *writebuf, ULONGEST offset, ULONGEST len,
4229                        ULONGEST *xfered_len)
4230 {
4231   gdb_assert (object == TARGET_OBJECT_OSDATA);
4232
4233   *xfered_len = linux_common_xfer_osdata (annex, readbuf, offset, len);
4234   if (*xfered_len == 0)
4235     return TARGET_XFER_EOF;
4236   else
4237     return TARGET_XFER_OK;
4238 }
4239
4240 static enum target_xfer_status
4241 linux_xfer_partial (struct target_ops *ops, enum target_object object,
4242                     const char *annex, gdb_byte *readbuf,
4243                     const gdb_byte *writebuf, ULONGEST offset, ULONGEST len,
4244                     ULONGEST *xfered_len)
4245 {
4246   enum target_xfer_status xfer;
4247
4248   if (object == TARGET_OBJECT_AUXV)
4249     return memory_xfer_auxv (ops, object, annex, readbuf, writebuf,
4250                              offset, len, xfered_len);
4251
4252   if (object == TARGET_OBJECT_OSDATA)
4253     return linux_nat_xfer_osdata (ops, object, annex, readbuf, writebuf,
4254                                   offset, len, xfered_len);
4255
4256   if (object == TARGET_OBJECT_SPU)
4257     return linux_proc_xfer_spu (ops, object, annex, readbuf, writebuf,
4258                                 offset, len, xfered_len);
4259
4260   /* GDB calculates all the addresses in possibly larget width of the address.
4261      Address width needs to be masked before its final use - either by
4262      linux_proc_xfer_partial or inf_ptrace_xfer_partial.
4263
4264      Compare ADDR_BIT first to avoid a compiler warning on shift overflow.  */
4265
4266   if (object == TARGET_OBJECT_MEMORY)
4267     {
4268       int addr_bit = gdbarch_addr_bit (target_gdbarch ());
4269
4270       if (addr_bit < (sizeof (ULONGEST) * HOST_CHAR_BIT))
4271         offset &= ((ULONGEST) 1 << addr_bit) - 1;
4272     }
4273
4274   xfer = linux_proc_xfer_partial (ops, object, annex, readbuf, writebuf,
4275                                   offset, len, xfered_len);
4276   if (xfer != TARGET_XFER_EOF)
4277     return xfer;
4278
4279   return super_xfer_partial (ops, object, annex, readbuf, writebuf,
4280                              offset, len, xfered_len);
4281 }
4282
4283 static void
4284 cleanup_target_stop (void *arg)
4285 {
4286   ptid_t *ptid = (ptid_t *) arg;
4287
4288   gdb_assert (arg != NULL);
4289
4290   /* Unpause all */
4291   target_continue_no_signal (*ptid);
4292 }
4293
4294 static VEC(static_tracepoint_marker_p) *
4295 linux_child_static_tracepoint_markers_by_strid (struct target_ops *self,
4296                                                 const char *strid)
4297 {
4298   char s[IPA_CMD_BUF_SIZE];
4299   struct cleanup *old_chain;
4300   int pid = ptid_get_pid (inferior_ptid);
4301   VEC(static_tracepoint_marker_p) *markers = NULL;
4302   struct static_tracepoint_marker *marker = NULL;
4303   const char *p = s;
4304   ptid_t ptid = ptid_build (pid, 0, 0);
4305
4306   /* Pause all */
4307   target_stop (ptid);
4308
4309   memcpy (s, "qTfSTM", sizeof ("qTfSTM"));
4310   s[sizeof ("qTfSTM")] = 0;
4311
4312   agent_run_command (pid, s, strlen (s) + 1);
4313
4314   old_chain = make_cleanup (free_current_marker, &marker);
4315   make_cleanup (cleanup_target_stop, &ptid);
4316
4317   while (*p++ == 'm')
4318     {
4319       if (marker == NULL)
4320         marker = XCNEW (struct static_tracepoint_marker);
4321
4322       do
4323         {
4324           parse_static_tracepoint_marker_definition (p, &p, marker);
4325
4326           if (strid == NULL || strcmp (strid, marker->str_id) == 0)
4327             {
4328               VEC_safe_push (static_tracepoint_marker_p,
4329                              markers, marker);
4330               marker = NULL;
4331             }
4332           else
4333             {
4334               release_static_tracepoint_marker (marker);
4335               memset (marker, 0, sizeof (*marker));
4336             }
4337         }
4338       while (*p++ == ',');      /* comma-separated list */
4339
4340       memcpy (s, "qTsSTM", sizeof ("qTsSTM"));
4341       s[sizeof ("qTsSTM")] = 0;
4342       agent_run_command (pid, s, strlen (s) + 1);
4343       p = s;
4344     }
4345
4346   do_cleanups (old_chain);
4347
4348   return markers;
4349 }
4350
4351 /* Create a prototype generic GNU/Linux target.  The client can override
4352    it with local methods.  */
4353
4354 static void
4355 linux_target_install_ops (struct target_ops *t)
4356 {
4357   t->to_insert_fork_catchpoint = linux_child_insert_fork_catchpoint;
4358   t->to_remove_fork_catchpoint = linux_child_remove_fork_catchpoint;
4359   t->to_insert_vfork_catchpoint = linux_child_insert_vfork_catchpoint;
4360   t->to_remove_vfork_catchpoint = linux_child_remove_vfork_catchpoint;
4361   t->to_insert_exec_catchpoint = linux_child_insert_exec_catchpoint;
4362   t->to_remove_exec_catchpoint = linux_child_remove_exec_catchpoint;
4363   t->to_set_syscall_catchpoint = linux_child_set_syscall_catchpoint;
4364   t->to_pid_to_exec_file = linux_child_pid_to_exec_file;
4365   t->to_post_startup_inferior = linux_child_post_startup_inferior;
4366   t->to_post_attach = linux_child_post_attach;
4367   t->to_follow_fork = linux_child_follow_fork;
4368
4369   super_xfer_partial = t->to_xfer_partial;
4370   t->to_xfer_partial = linux_xfer_partial;
4371
4372   t->to_static_tracepoint_markers_by_strid
4373     = linux_child_static_tracepoint_markers_by_strid;
4374 }
4375
4376 struct target_ops *
4377 linux_target (void)
4378 {
4379   struct target_ops *t;
4380
4381   t = inf_ptrace_target ();
4382   linux_target_install_ops (t);
4383
4384   return t;
4385 }
4386
4387 struct target_ops *
4388 linux_trad_target (CORE_ADDR (*register_u_offset)(struct gdbarch *, int, int))
4389 {
4390   struct target_ops *t;
4391
4392   t = inf_ptrace_trad_target (register_u_offset);
4393   linux_target_install_ops (t);
4394
4395   return t;
4396 }
4397
4398 /* target_is_async_p implementation.  */
4399
4400 static int
4401 linux_nat_is_async_p (struct target_ops *ops)
4402 {
4403   return linux_is_async_p ();
4404 }
4405
4406 /* target_can_async_p implementation.  */
4407
4408 static int
4409 linux_nat_can_async_p (struct target_ops *ops)
4410 {
4411   /* We're always async, unless the user explicitly prevented it with the
4412      "maint set target-async" command.  */
4413   return target_async_permitted;
4414 }
4415
4416 static int
4417 linux_nat_supports_non_stop (struct target_ops *self)
4418 {
4419   return 1;
4420 }
4421
4422 /* to_always_non_stop_p implementation.  */
4423
4424 static int
4425 linux_nat_always_non_stop_p (struct target_ops *self)
4426 {
4427   return 1;
4428 }
4429
4430 /* True if we want to support multi-process.  To be removed when GDB
4431    supports multi-exec.  */
4432
4433 int linux_multi_process = 1;
4434
4435 static int
4436 linux_nat_supports_multi_process (struct target_ops *self)
4437 {
4438   return linux_multi_process;
4439 }
4440
4441 static int
4442 linux_nat_supports_disable_randomization (struct target_ops *self)
4443 {
4444 #ifdef HAVE_PERSONALITY
4445   return 1;
4446 #else
4447   return 0;
4448 #endif
4449 }
4450
4451 /* SIGCHLD handler that serves two purposes: In non-stop/async mode,
4452    so we notice when any child changes state, and notify the
4453    event-loop; it allows us to use sigsuspend in linux_nat_wait_1
4454    above to wait for the arrival of a SIGCHLD.  */
4455
4456 static void
4457 sigchld_handler (int signo)
4458 {
4459   int old_errno = errno;
4460
4461   if (debug_linux_nat)
4462     ui_file_write_async_safe (gdb_stdlog,
4463                               "sigchld\n", sizeof ("sigchld\n") - 1);
4464
4465   if (signo == SIGCHLD
4466       && linux_nat_event_pipe[0] != -1)
4467     async_file_mark (); /* Let the event loop know that there are
4468                            events to handle.  */
4469
4470   errno = old_errno;
4471 }
4472
4473 /* Callback registered with the target events file descriptor.  */
4474
4475 static void
4476 handle_target_event (int error, gdb_client_data client_data)
4477 {
4478   inferior_event_handler (INF_REG_EVENT, NULL);
4479 }
4480
4481 /* Create/destroy the target events pipe.  Returns previous state.  */
4482
4483 static int
4484 linux_async_pipe (int enable)
4485 {
4486   int previous = linux_is_async_p ();
4487
4488   if (previous != enable)
4489     {
4490       sigset_t prev_mask;
4491
4492       /* Block child signals while we create/destroy the pipe, as
4493          their handler writes to it.  */
4494       block_child_signals (&prev_mask);
4495
4496       if (enable)
4497         {
4498           if (gdb_pipe_cloexec (linux_nat_event_pipe) == -1)
4499             internal_error (__FILE__, __LINE__,
4500                             "creating event pipe failed.");
4501
4502           fcntl (linux_nat_event_pipe[0], F_SETFL, O_NONBLOCK);
4503           fcntl (linux_nat_event_pipe[1], F_SETFL, O_NONBLOCK);
4504         }
4505       else
4506         {
4507           close (linux_nat_event_pipe[0]);
4508           close (linux_nat_event_pipe[1]);
4509           linux_nat_event_pipe[0] = -1;
4510           linux_nat_event_pipe[1] = -1;
4511         }
4512
4513       restore_child_signals_mask (&prev_mask);
4514     }
4515
4516   return previous;
4517 }
4518
4519 /* target_async implementation.  */
4520
4521 static void
4522 linux_nat_async (struct target_ops *ops, int enable)
4523 {
4524   if (enable)
4525     {
4526       if (!linux_async_pipe (1))
4527         {
4528           add_file_handler (linux_nat_event_pipe[0],
4529                             handle_target_event, NULL);
4530           /* There may be pending events to handle.  Tell the event loop
4531              to poll them.  */
4532           async_file_mark ();
4533         }
4534     }
4535   else
4536     {
4537       delete_file_handler (linux_nat_event_pipe[0]);
4538       linux_async_pipe (0);
4539     }
4540   return;
4541 }
4542
4543 /* Stop an LWP, and push a GDB_SIGNAL_0 stop status if no other
4544    event came out.  */
4545
4546 static int
4547 linux_nat_stop_lwp (struct lwp_info *lwp, void *data)
4548 {
4549   if (!lwp->stopped)
4550     {
4551       if (debug_linux_nat)
4552         fprintf_unfiltered (gdb_stdlog,
4553                             "LNSL: running -> suspending %s\n",
4554                             target_pid_to_str (lwp->ptid));
4555
4556
4557       if (lwp->last_resume_kind == resume_stop)
4558         {
4559           if (debug_linux_nat)
4560             fprintf_unfiltered (gdb_stdlog,
4561                                 "linux-nat: already stopping LWP %ld at "
4562                                 "GDB's request\n",
4563                                 ptid_get_lwp (lwp->ptid));
4564           return 0;
4565         }
4566
4567       stop_callback (lwp, NULL);
4568       lwp->last_resume_kind = resume_stop;
4569     }
4570   else
4571     {
4572       /* Already known to be stopped; do nothing.  */
4573
4574       if (debug_linux_nat)
4575         {
4576           if (find_thread_ptid (lwp->ptid)->stop_requested)
4577             fprintf_unfiltered (gdb_stdlog,
4578                                 "LNSL: already stopped/stop_requested %s\n",
4579                                 target_pid_to_str (lwp->ptid));
4580           else
4581             fprintf_unfiltered (gdb_stdlog,
4582                                 "LNSL: already stopped/no "
4583                                 "stop_requested yet %s\n",
4584                                 target_pid_to_str (lwp->ptid));
4585         }
4586     }
4587   return 0;
4588 }
4589
4590 static void
4591 linux_nat_stop (struct target_ops *self, ptid_t ptid)
4592 {
4593   iterate_over_lwps (ptid, linux_nat_stop_lwp, NULL);
4594 }
4595
4596 static void
4597 linux_nat_close (struct target_ops *self)
4598 {
4599   /* Unregister from the event loop.  */
4600   if (linux_nat_is_async_p (self))
4601     linux_nat_async (self, 0);
4602
4603   if (linux_ops->to_close)
4604     linux_ops->to_close (linux_ops);
4605
4606   super_close (self);
4607 }
4608
4609 /* When requests are passed down from the linux-nat layer to the
4610    single threaded inf-ptrace layer, ptids of (lwpid,0,0) form are
4611    used.  The address space pointer is stored in the inferior object,
4612    but the common code that is passed such ptid can't tell whether
4613    lwpid is a "main" process id or not (it assumes so).  We reverse
4614    look up the "main" process id from the lwp here.  */
4615
4616 static struct address_space *
4617 linux_nat_thread_address_space (struct target_ops *t, ptid_t ptid)
4618 {
4619   struct lwp_info *lwp;
4620   struct inferior *inf;
4621   int pid;
4622
4623   if (ptid_get_lwp (ptid) == 0)
4624     {
4625       /* An (lwpid,0,0) ptid.  Look up the lwp object to get at the
4626          tgid.  */
4627       lwp = find_lwp_pid (ptid);
4628       pid = ptid_get_pid (lwp->ptid);
4629     }
4630   else
4631     {
4632       /* A (pid,lwpid,0) ptid.  */
4633       pid = ptid_get_pid (ptid);
4634     }
4635
4636   inf = find_inferior_pid (pid);
4637   gdb_assert (inf != NULL);
4638   return inf->aspace;
4639 }
4640
4641 /* Return the cached value of the processor core for thread PTID.  */
4642
4643 static int
4644 linux_nat_core_of_thread (struct target_ops *ops, ptid_t ptid)
4645 {
4646   struct lwp_info *info = find_lwp_pid (ptid);
4647
4648   if (info)
4649     return info->core;
4650   return -1;
4651 }
4652
4653 /* Implementation of to_filesystem_is_local.  */
4654
4655 static int
4656 linux_nat_filesystem_is_local (struct target_ops *ops)
4657 {
4658   struct inferior *inf = current_inferior ();
4659
4660   if (inf->fake_pid_p || inf->pid == 0)
4661     return 1;
4662
4663   return linux_ns_same (inf->pid, LINUX_NS_MNT);
4664 }
4665
4666 /* Convert the INF argument passed to a to_fileio_* method
4667    to a process ID suitable for passing to its corresponding
4668    linux_mntns_* function.  If INF is non-NULL then the
4669    caller is requesting the filesystem seen by INF.  If INF
4670    is NULL then the caller is requesting the filesystem seen
4671    by the GDB.  We fall back to GDB's filesystem in the case
4672    that INF is non-NULL but its PID is unknown.  */
4673
4674 static pid_t
4675 linux_nat_fileio_pid_of (struct inferior *inf)
4676 {
4677   if (inf == NULL || inf->fake_pid_p || inf->pid == 0)
4678     return getpid ();
4679   else
4680     return inf->pid;
4681 }
4682
4683 /* Implementation of to_fileio_open.  */
4684
4685 static int
4686 linux_nat_fileio_open (struct target_ops *self,
4687                        struct inferior *inf, const char *filename,
4688                        int flags, int mode, int warn_if_slow,
4689                        int *target_errno)
4690 {
4691   int nat_flags;
4692   mode_t nat_mode;
4693   int fd;
4694
4695   if (fileio_to_host_openflags (flags, &nat_flags) == -1
4696       || fileio_to_host_mode (mode, &nat_mode) == -1)
4697     {
4698       *target_errno = FILEIO_EINVAL;
4699       return -1;
4700     }
4701
4702   fd = linux_mntns_open_cloexec (linux_nat_fileio_pid_of (inf),
4703                                  filename, nat_flags, nat_mode);
4704   if (fd == -1)
4705     *target_errno = host_to_fileio_error (errno);
4706
4707   return fd;
4708 }
4709
4710 /* Implementation of to_fileio_readlink.  */
4711
4712 static char *
4713 linux_nat_fileio_readlink (struct target_ops *self,
4714                            struct inferior *inf, const char *filename,
4715                            int *target_errno)
4716 {
4717   char buf[PATH_MAX];
4718   int len;
4719   char *ret;
4720
4721   len = linux_mntns_readlink (linux_nat_fileio_pid_of (inf),
4722                               filename, buf, sizeof (buf));
4723   if (len < 0)
4724     {
4725       *target_errno = host_to_fileio_error (errno);
4726       return NULL;
4727     }
4728
4729   ret = (char *) xmalloc (len + 1);
4730   memcpy (ret, buf, len);
4731   ret[len] = '\0';
4732   return ret;
4733 }
4734
4735 /* Implementation of to_fileio_unlink.  */
4736
4737 static int
4738 linux_nat_fileio_unlink (struct target_ops *self,
4739                          struct inferior *inf, const char *filename,
4740                          int *target_errno)
4741 {
4742   int ret;
4743
4744   ret = linux_mntns_unlink (linux_nat_fileio_pid_of (inf),
4745                             filename);
4746   if (ret == -1)
4747     *target_errno = host_to_fileio_error (errno);
4748
4749   return ret;
4750 }
4751
4752 /* Implementation of the to_thread_events method.  */
4753
4754 static void
4755 linux_nat_thread_events (struct target_ops *ops, int enable)
4756 {
4757   report_thread_events = enable;
4758 }
4759
4760 void
4761 linux_nat_add_target (struct target_ops *t)
4762 {
4763   /* Save the provided single-threaded target.  We save this in a separate
4764      variable because another target we've inherited from (e.g. inf-ptrace)
4765      may have saved a pointer to T; we want to use it for the final
4766      process stratum target.  */
4767   linux_ops_saved = *t;
4768   linux_ops = &linux_ops_saved;
4769
4770   /* Override some methods for multithreading.  */
4771   t->to_create_inferior = linux_nat_create_inferior;
4772   t->to_attach = linux_nat_attach;
4773   t->to_detach = linux_nat_detach;
4774   t->to_resume = linux_nat_resume;
4775   t->to_wait = linux_nat_wait;
4776   t->to_pass_signals = linux_nat_pass_signals;
4777   t->to_xfer_partial = linux_nat_xfer_partial;
4778   t->to_kill = linux_nat_kill;
4779   t->to_mourn_inferior = linux_nat_mourn_inferior;
4780   t->to_thread_alive = linux_nat_thread_alive;
4781   t->to_update_thread_list = linux_nat_update_thread_list;
4782   t->to_pid_to_str = linux_nat_pid_to_str;
4783   t->to_thread_name = linux_nat_thread_name;
4784   t->to_has_thread_control = tc_schedlock;
4785   t->to_thread_address_space = linux_nat_thread_address_space;
4786   t->to_stopped_by_watchpoint = linux_nat_stopped_by_watchpoint;
4787   t->to_stopped_data_address = linux_nat_stopped_data_address;
4788   t->to_stopped_by_sw_breakpoint = linux_nat_stopped_by_sw_breakpoint;
4789   t->to_supports_stopped_by_sw_breakpoint = linux_nat_supports_stopped_by_sw_breakpoint;
4790   t->to_stopped_by_hw_breakpoint = linux_nat_stopped_by_hw_breakpoint;
4791   t->to_supports_stopped_by_hw_breakpoint = linux_nat_supports_stopped_by_hw_breakpoint;
4792   t->to_thread_events = linux_nat_thread_events;
4793
4794   t->to_can_async_p = linux_nat_can_async_p;
4795   t->to_is_async_p = linux_nat_is_async_p;
4796   t->to_supports_non_stop = linux_nat_supports_non_stop;
4797   t->to_always_non_stop_p = linux_nat_always_non_stop_p;
4798   t->to_async = linux_nat_async;
4799
4800   super_close = t->to_close;
4801   t->to_close = linux_nat_close;
4802
4803   t->to_stop = linux_nat_stop;
4804
4805   t->to_supports_multi_process = linux_nat_supports_multi_process;
4806
4807   t->to_supports_disable_randomization
4808     = linux_nat_supports_disable_randomization;
4809
4810   t->to_core_of_thread = linux_nat_core_of_thread;
4811
4812   t->to_filesystem_is_local = linux_nat_filesystem_is_local;
4813   t->to_fileio_open = linux_nat_fileio_open;
4814   t->to_fileio_readlink = linux_nat_fileio_readlink;
4815   t->to_fileio_unlink = linux_nat_fileio_unlink;
4816
4817   /* We don't change the stratum; this target will sit at
4818      process_stratum and thread_db will set at thread_stratum.  This
4819      is a little strange, since this is a multi-threaded-capable
4820      target, but we want to be on the stack below thread_db, and we
4821      also want to be used for single-threaded processes.  */
4822
4823   add_target (t);
4824 }
4825
4826 /* Register a method to call whenever a new thread is attached.  */
4827 void
4828 linux_nat_set_new_thread (struct target_ops *t,
4829                           void (*new_thread) (struct lwp_info *))
4830 {
4831   /* Save the pointer.  We only support a single registered instance
4832      of the GNU/Linux native target, so we do not need to map this to
4833      T.  */
4834   linux_nat_new_thread = new_thread;
4835 }
4836
4837 /* Register a method to call whenever a new thread is attached.  */
4838 void
4839 linux_nat_set_delete_thread (struct target_ops *t,
4840                              void (*delete_thread) (struct arch_lwp_info *))
4841 {
4842   /* Save the pointer.  We only support a single registered instance
4843      of the GNU/Linux native target, so we do not need to map this to
4844      T.  */
4845   linux_nat_delete_thread = delete_thread;
4846 }
4847
4848 /* See declaration in linux-nat.h.  */
4849
4850 void
4851 linux_nat_set_new_fork (struct target_ops *t,
4852                         linux_nat_new_fork_ftype *new_fork)
4853 {
4854   /* Save the pointer.  */
4855   linux_nat_new_fork = new_fork;
4856 }
4857
4858 /* See declaration in linux-nat.h.  */
4859
4860 void
4861 linux_nat_set_forget_process (struct target_ops *t,
4862                               linux_nat_forget_process_ftype *fn)
4863 {
4864   /* Save the pointer.  */
4865   linux_nat_forget_process_hook = fn;
4866 }
4867
4868 /* See declaration in linux-nat.h.  */
4869
4870 void
4871 linux_nat_forget_process (pid_t pid)
4872 {
4873   if (linux_nat_forget_process_hook != NULL)
4874     linux_nat_forget_process_hook (pid);
4875 }
4876
4877 /* Register a method that converts a siginfo object between the layout
4878    that ptrace returns, and the layout in the architecture of the
4879    inferior.  */
4880 void
4881 linux_nat_set_siginfo_fixup (struct target_ops *t,
4882                              int (*siginfo_fixup) (siginfo_t *,
4883                                                    gdb_byte *,
4884                                                    int))
4885 {
4886   /* Save the pointer.  */
4887   linux_nat_siginfo_fixup = siginfo_fixup;
4888 }
4889
4890 /* Register a method to call prior to resuming a thread.  */
4891
4892 void
4893 linux_nat_set_prepare_to_resume (struct target_ops *t,
4894                                  void (*prepare_to_resume) (struct lwp_info *))
4895 {
4896   /* Save the pointer.  */
4897   linux_nat_prepare_to_resume = prepare_to_resume;
4898 }
4899
4900 /* See linux-nat.h.  */
4901
4902 int
4903 linux_nat_get_siginfo (ptid_t ptid, siginfo_t *siginfo)
4904 {
4905   int pid;
4906
4907   pid = ptid_get_lwp (ptid);
4908   if (pid == 0)
4909     pid = ptid_get_pid (ptid);
4910
4911   errno = 0;
4912   ptrace (PTRACE_GETSIGINFO, pid, (PTRACE_TYPE_ARG3) 0, siginfo);
4913   if (errno != 0)
4914     {
4915       memset (siginfo, 0, sizeof (*siginfo));
4916       return 0;
4917     }
4918   return 1;
4919 }
4920
4921 /* See nat/linux-nat.h.  */
4922
4923 ptid_t
4924 current_lwp_ptid (void)
4925 {
4926   gdb_assert (ptid_lwp_p (inferior_ptid));
4927   return inferior_ptid;
4928 }
4929
4930 void
4931 _initialize_linux_nat (void)
4932 {
4933   add_setshow_zuinteger_cmd ("lin-lwp", class_maintenance,
4934                              &debug_linux_nat, _("\
4935 Set debugging of GNU/Linux lwp module."), _("\
4936 Show debugging of GNU/Linux lwp module."), _("\
4937 Enables printf debugging output."),
4938                              NULL,
4939                              show_debug_linux_nat,
4940                              &setdebuglist, &showdebuglist);
4941
4942   add_setshow_boolean_cmd ("linux-namespaces", class_maintenance,
4943                            &debug_linux_namespaces, _("\
4944 Set debugging of GNU/Linux namespaces module."), _("\
4945 Show debugging of GNU/Linux namespaces module."), _("\
4946 Enables printf debugging output."),
4947                            NULL,
4948                            NULL,
4949                            &setdebuglist, &showdebuglist);
4950
4951   /* Save this mask as the default.  */
4952   sigprocmask (SIG_SETMASK, NULL, &normal_mask);
4953
4954   /* Install a SIGCHLD handler.  */
4955   sigchld_action.sa_handler = sigchld_handler;
4956   sigemptyset (&sigchld_action.sa_mask);
4957   sigchld_action.sa_flags = SA_RESTART;
4958
4959   /* Make it the default.  */
4960   sigaction (SIGCHLD, &sigchld_action, NULL);
4961
4962   /* Make sure we don't block SIGCHLD during a sigsuspend.  */
4963   sigprocmask (SIG_SETMASK, NULL, &suspend_mask);
4964   sigdelset (&suspend_mask, SIGCHLD);
4965
4966   sigemptyset (&blocked_mask);
4967
4968   lwp_lwpid_htab_create ();
4969 }
4970 \f
4971
4972 /* FIXME: kettenis/2000-08-26: The stuff on this page is specific to
4973    the GNU/Linux Threads library and therefore doesn't really belong
4974    here.  */
4975
4976 /* Return the set of signals used by the threads library in *SET.  */
4977
4978 void
4979 lin_thread_get_thread_signals (sigset_t *set)
4980 {
4981   sigemptyset (set);
4982
4983   /* NPTL reserves the first two RT signals, but does not provide any
4984      way for the debugger to query the signal numbers - fortunately
4985      they don't change.  */
4986   sigaddset (set, __SIGRTMIN);
4987   sigaddset (set, __SIGRTMIN + 1);
4988 }