Update copyright year range in all GDB files
[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               warning (_("Cannot attach to lwp %d: %s"),
1171                        lwpid,
1172                        linux_ptrace_attach_fail_reason_string (ptid,
1173                                                                err));
1174             }
1175         }
1176       else
1177         {
1178           if (debug_linux_nat)
1179             fprintf_unfiltered (gdb_stdlog,
1180                                 "PTRACE_ATTACH %s, 0, 0 (OK)\n",
1181                                 target_pid_to_str (ptid));
1182
1183           lp = add_lwp (ptid);
1184
1185           /* The next time we wait for this LWP we'll see a SIGSTOP as
1186              PTRACE_ATTACH brings it to a halt.  */
1187           lp->signalled = 1;
1188
1189           /* We need to wait for a stop before being able to make the
1190              next ptrace call on this LWP.  */
1191           lp->must_set_ptrace_flags = 1;
1192
1193           /* So that wait collects the SIGSTOP.  */
1194           lp->resumed = 1;
1195
1196           /* Also add the LWP to gdb's thread list, in case a
1197              matching libthread_db is not found (or the process uses
1198              raw clone).  */
1199           add_thread (lp->ptid);
1200           set_running (lp->ptid, 1);
1201           set_executing (lp->ptid, 1);
1202         }
1203
1204       return 1;
1205     }
1206   return 0;
1207 }
1208
1209 static void
1210 linux_nat_attach (struct target_ops *ops, const char *args, int from_tty)
1211 {
1212   struct lwp_info *lp;
1213   int status;
1214   ptid_t ptid;
1215
1216   /* Make sure we report all signals during attach.  */
1217   linux_nat_pass_signals (ops, 0, NULL);
1218
1219   TRY
1220     {
1221       linux_ops->to_attach (ops, args, from_tty);
1222     }
1223   CATCH (ex, RETURN_MASK_ERROR)
1224     {
1225       pid_t pid = parse_pid_to_attach (args);
1226       struct buffer buffer;
1227       char *message, *buffer_s;
1228
1229       message = xstrdup (ex.message);
1230       make_cleanup (xfree, message);
1231
1232       buffer_init (&buffer);
1233       linux_ptrace_attach_fail_reason (pid, &buffer);
1234
1235       buffer_grow_str0 (&buffer, "");
1236       buffer_s = buffer_finish (&buffer);
1237       make_cleanup (xfree, buffer_s);
1238
1239       if (*buffer_s != '\0')
1240         throw_error (ex.error, "warning: %s\n%s", buffer_s, message);
1241       else
1242         throw_error (ex.error, "%s", message);
1243     }
1244   END_CATCH
1245
1246   /* The ptrace base target adds the main thread with (pid,0,0)
1247      format.  Decorate it with lwp info.  */
1248   ptid = ptid_build (ptid_get_pid (inferior_ptid),
1249                      ptid_get_pid (inferior_ptid),
1250                      0);
1251   thread_change_ptid (inferior_ptid, ptid);
1252
1253   /* Add the initial process as the first LWP to the list.  */
1254   lp = add_initial_lwp (ptid);
1255
1256   status = linux_nat_post_attach_wait (lp->ptid, &lp->signalled);
1257   if (!WIFSTOPPED (status))
1258     {
1259       if (WIFEXITED (status))
1260         {
1261           int exit_code = WEXITSTATUS (status);
1262
1263           target_terminal::ours ();
1264           target_mourn_inferior (inferior_ptid);
1265           if (exit_code == 0)
1266             error (_("Unable to attach: program exited normally."));
1267           else
1268             error (_("Unable to attach: program exited with code %d."),
1269                    exit_code);
1270         }
1271       else if (WIFSIGNALED (status))
1272         {
1273           enum gdb_signal signo;
1274
1275           target_terminal::ours ();
1276           target_mourn_inferior (inferior_ptid);
1277
1278           signo = gdb_signal_from_host (WTERMSIG (status));
1279           error (_("Unable to attach: program terminated with signal "
1280                    "%s, %s."),
1281                  gdb_signal_to_name (signo),
1282                  gdb_signal_to_string (signo));
1283         }
1284
1285       internal_error (__FILE__, __LINE__,
1286                       _("unexpected status %d for PID %ld"),
1287                       status, (long) ptid_get_lwp (ptid));
1288     }
1289
1290   lp->stopped = 1;
1291
1292   /* Save the wait status to report later.  */
1293   lp->resumed = 1;
1294   if (debug_linux_nat)
1295     fprintf_unfiltered (gdb_stdlog,
1296                         "LNA: waitpid %ld, saving status %s\n",
1297                         (long) ptid_get_pid (lp->ptid), status_to_str (status));
1298
1299   lp->status = status;
1300
1301   /* We must attach to every LWP.  If /proc is mounted, use that to
1302      find them now.  The inferior may be using raw clone instead of
1303      using pthreads.  But even if it is using pthreads, thread_db
1304      walks structures in the inferior's address space to find the list
1305      of threads/LWPs, and those structures may well be corrupted.
1306      Note that once thread_db is loaded, we'll still use it to list
1307      threads and associate pthread info with each LWP.  */
1308   linux_proc_attach_tgid_threads (ptid_get_pid (lp->ptid),
1309                                   attach_proc_task_lwp_callback);
1310
1311   if (target_can_async_p ())
1312     target_async (1);
1313 }
1314
1315 /* Get pending signal of THREAD as a host signal number, for detaching
1316    purposes.  This is the signal the thread last stopped for, which we
1317    need to deliver to the thread when detaching, otherwise, it'd be
1318    suppressed/lost.  */
1319
1320 static int
1321 get_detach_signal (struct lwp_info *lp)
1322 {
1323   enum gdb_signal signo = GDB_SIGNAL_0;
1324
1325   /* If we paused threads momentarily, we may have stored pending
1326      events in lp->status or lp->waitstatus (see stop_wait_callback),
1327      and GDB core hasn't seen any signal for those threads.
1328      Otherwise, the last signal reported to the core is found in the
1329      thread object's stop_signal.
1330
1331      There's a corner case that isn't handled here at present.  Only
1332      if the thread stopped with a TARGET_WAITKIND_STOPPED does
1333      stop_signal make sense as a real signal to pass to the inferior.
1334      Some catchpoint related events, like
1335      TARGET_WAITKIND_(V)FORK|EXEC|SYSCALL, have their stop_signal set
1336      to GDB_SIGNAL_SIGTRAP when the catchpoint triggers.  But,
1337      those traps are debug API (ptrace in our case) related and
1338      induced; the inferior wouldn't see them if it wasn't being
1339      traced.  Hence, we should never pass them to the inferior, even
1340      when set to pass state.  Since this corner case isn't handled by
1341      infrun.c when proceeding with a signal, for consistency, neither
1342      do we handle it here (or elsewhere in the file we check for
1343      signal pass state).  Normally SIGTRAP isn't set to pass state, so
1344      this is really a corner case.  */
1345
1346   if (lp->waitstatus.kind != TARGET_WAITKIND_IGNORE)
1347     signo = GDB_SIGNAL_0; /* a pending ptrace event, not a real signal.  */
1348   else if (lp->status)
1349     signo = gdb_signal_from_host (WSTOPSIG (lp->status));
1350   else if (target_is_non_stop_p () && !is_executing (lp->ptid))
1351     {
1352       struct thread_info *tp = find_thread_ptid (lp->ptid);
1353
1354       if (tp->suspend.waitstatus_pending_p)
1355         signo = tp->suspend.waitstatus.value.sig;
1356       else
1357         signo = tp->suspend.stop_signal;
1358     }
1359   else if (!target_is_non_stop_p ())
1360     {
1361       struct target_waitstatus last;
1362       ptid_t last_ptid;
1363
1364       get_last_target_status (&last_ptid, &last);
1365
1366       if (ptid_get_lwp (lp->ptid) == ptid_get_lwp (last_ptid))
1367         {
1368           struct thread_info *tp = find_thread_ptid (lp->ptid);
1369
1370           signo = tp->suspend.stop_signal;
1371         }
1372     }
1373
1374   if (signo == GDB_SIGNAL_0)
1375     {
1376       if (debug_linux_nat)
1377         fprintf_unfiltered (gdb_stdlog,
1378                             "GPT: lwp %s has no pending signal\n",
1379                             target_pid_to_str (lp->ptid));
1380     }
1381   else if (!signal_pass_state (signo))
1382     {
1383       if (debug_linux_nat)
1384         fprintf_unfiltered (gdb_stdlog,
1385                             "GPT: lwp %s had signal %s, "
1386                             "but it is in no pass state\n",
1387                             target_pid_to_str (lp->ptid),
1388                             gdb_signal_to_string (signo));
1389     }
1390   else
1391     {
1392       if (debug_linux_nat)
1393         fprintf_unfiltered (gdb_stdlog,
1394                             "GPT: lwp %s has pending signal %s\n",
1395                             target_pid_to_str (lp->ptid),
1396                             gdb_signal_to_string (signo));
1397
1398       return gdb_signal_to_host (signo);
1399     }
1400
1401   return 0;
1402 }
1403
1404 /* Detach from LP.  If SIGNO_P is non-NULL, then it points to the
1405    signal number that should be passed to the LWP when detaching.
1406    Otherwise pass any pending signal the LWP may have, if any.  */
1407
1408 static void
1409 detach_one_lwp (struct lwp_info *lp, int *signo_p)
1410 {
1411   int lwpid = ptid_get_lwp (lp->ptid);
1412   int signo;
1413
1414   gdb_assert (lp->status == 0 || WIFSTOPPED (lp->status));
1415
1416   if (debug_linux_nat && lp->status)
1417     fprintf_unfiltered (gdb_stdlog, "DC:  Pending %s for %s on detach.\n",
1418                         strsignal (WSTOPSIG (lp->status)),
1419                         target_pid_to_str (lp->ptid));
1420
1421   /* If there is a pending SIGSTOP, get rid of it.  */
1422   if (lp->signalled)
1423     {
1424       if (debug_linux_nat)
1425         fprintf_unfiltered (gdb_stdlog,
1426                             "DC: Sending SIGCONT to %s\n",
1427                             target_pid_to_str (lp->ptid));
1428
1429       kill_lwp (lwpid, SIGCONT);
1430       lp->signalled = 0;
1431     }
1432
1433   if (signo_p == NULL)
1434     {
1435       /* Pass on any pending signal for this LWP.  */
1436       signo = get_detach_signal (lp);
1437     }
1438   else
1439     signo = *signo_p;
1440
1441   /* Preparing to resume may try to write registers, and fail if the
1442      lwp is zombie.  If that happens, ignore the error.  We'll handle
1443      it below, when detach fails with ESRCH.  */
1444   TRY
1445     {
1446       if (linux_nat_prepare_to_resume != NULL)
1447         linux_nat_prepare_to_resume (lp);
1448     }
1449   CATCH (ex, RETURN_MASK_ERROR)
1450     {
1451       if (!check_ptrace_stopped_lwp_gone (lp))
1452         throw_exception (ex);
1453     }
1454   END_CATCH
1455
1456   if (ptrace (PTRACE_DETACH, lwpid, 0, signo) < 0)
1457     {
1458       int save_errno = errno;
1459
1460       /* We know the thread exists, so ESRCH must mean the lwp is
1461          zombie.  This can happen if one of the already-detached
1462          threads exits the whole thread group.  In that case we're
1463          still attached, and must reap the lwp.  */
1464       if (save_errno == ESRCH)
1465         {
1466           int ret, status;
1467
1468           ret = my_waitpid (lwpid, &status, __WALL);
1469           if (ret == -1)
1470             {
1471               warning (_("Couldn't reap LWP %d while detaching: %s"),
1472                        lwpid, strerror (errno));
1473             }
1474           else if (!WIFEXITED (status) && !WIFSIGNALED (status))
1475             {
1476               warning (_("Reaping LWP %d while detaching "
1477                          "returned unexpected status 0x%x"),
1478                        lwpid, status);
1479             }
1480         }
1481       else
1482         {
1483           error (_("Can't detach %s: %s"), target_pid_to_str (lp->ptid),
1484                  safe_strerror (save_errno));
1485         }
1486     }
1487   else if (debug_linux_nat)
1488     {
1489       fprintf_unfiltered (gdb_stdlog,
1490                           "PTRACE_DETACH (%s, %s, 0) (OK)\n",
1491                           target_pid_to_str (lp->ptid),
1492                           strsignal (signo));
1493     }
1494
1495   delete_lwp (lp->ptid);
1496 }
1497
1498 static int
1499 detach_callback (struct lwp_info *lp, void *data)
1500 {
1501   /* We don't actually detach from the thread group leader just yet.
1502      If the thread group exits, we must reap the zombie clone lwps
1503      before we're able to reap the leader.  */
1504   if (ptid_get_lwp (lp->ptid) != ptid_get_pid (lp->ptid))
1505     detach_one_lwp (lp, NULL);
1506   return 0;
1507 }
1508
1509 static void
1510 linux_nat_detach (struct target_ops *ops, const char *args, int from_tty)
1511 {
1512   int pid;
1513   struct lwp_info *main_lwp;
1514
1515   pid = ptid_get_pid (inferior_ptid);
1516
1517   /* Don't unregister from the event loop, as there may be other
1518      inferiors running. */
1519
1520   /* Stop all threads before detaching.  ptrace requires that the
1521      thread is stopped to sucessfully detach.  */
1522   iterate_over_lwps (pid_to_ptid (pid), stop_callback, NULL);
1523   /* ... and wait until all of them have reported back that
1524      they're no longer running.  */
1525   iterate_over_lwps (pid_to_ptid (pid), stop_wait_callback, NULL);
1526
1527   iterate_over_lwps (pid_to_ptid (pid), detach_callback, NULL);
1528
1529   /* Only the initial process should be left right now.  */
1530   gdb_assert (num_lwps (ptid_get_pid (inferior_ptid)) == 1);
1531
1532   main_lwp = find_lwp_pid (pid_to_ptid (pid));
1533
1534   if (forks_exist_p ())
1535     {
1536       /* Multi-fork case.  The current inferior_ptid is being detached
1537          from, but there are other viable forks to debug.  Detach from
1538          the current fork, and context-switch to the first
1539          available.  */
1540       linux_fork_detach (args, from_tty);
1541     }
1542   else
1543     {
1544       int signo;
1545
1546       target_announce_detach (from_tty);
1547
1548       /* Pass on any pending signal for the last LWP, unless the user
1549          requested detaching with a different signal (most likely 0,
1550          meaning, discard the signal).  */
1551       if (args != NULL)
1552         signo = atoi (args);
1553       else
1554         signo = get_detach_signal (main_lwp);
1555
1556       detach_one_lwp (main_lwp, &signo);
1557
1558       inf_ptrace_detach_success (ops);
1559     }
1560 }
1561
1562 /* Resume execution of the inferior process.  If STEP is nonzero,
1563    single-step it.  If SIGNAL is nonzero, give it that signal.  */
1564
1565 static void
1566 linux_resume_one_lwp_throw (struct lwp_info *lp, int step,
1567                             enum gdb_signal signo)
1568 {
1569   lp->step = step;
1570
1571   /* stop_pc doubles as the PC the LWP had when it was last resumed.
1572      We only presently need that if the LWP is stepped though (to
1573      handle the case of stepping a breakpoint instruction).  */
1574   if (step)
1575     {
1576       struct regcache *regcache = get_thread_regcache (lp->ptid);
1577
1578       lp->stop_pc = regcache_read_pc (regcache);
1579     }
1580   else
1581     lp->stop_pc = 0;
1582
1583   if (linux_nat_prepare_to_resume != NULL)
1584     linux_nat_prepare_to_resume (lp);
1585   linux_ops->to_resume (linux_ops, lp->ptid, step, signo);
1586
1587   /* Successfully resumed.  Clear state that no longer makes sense,
1588      and mark the LWP as running.  Must not do this before resuming
1589      otherwise if that fails other code will be confused.  E.g., we'd
1590      later try to stop the LWP and hang forever waiting for a stop
1591      status.  Note that we must not throw after this is cleared,
1592      otherwise handle_zombie_lwp_error would get confused.  */
1593   lp->stopped = 0;
1594   lp->core = -1;
1595   lp->stop_reason = TARGET_STOPPED_BY_NO_REASON;
1596   registers_changed_ptid (lp->ptid);
1597 }
1598
1599 /* Called when we try to resume a stopped LWP and that errors out.  If
1600    the LWP is no longer in ptrace-stopped state (meaning it's zombie,
1601    or about to become), discard the error, clear any pending status
1602    the LWP may have, and return true (we'll collect the exit status
1603    soon enough).  Otherwise, return false.  */
1604
1605 static int
1606 check_ptrace_stopped_lwp_gone (struct lwp_info *lp)
1607 {
1608   /* If we get an error after resuming the LWP successfully, we'd
1609      confuse !T state for the LWP being gone.  */
1610   gdb_assert (lp->stopped);
1611
1612   /* We can't just check whether the LWP is in 'Z (Zombie)' state,
1613      because even if ptrace failed with ESRCH, the tracee may be "not
1614      yet fully dead", but already refusing ptrace requests.  In that
1615      case the tracee has 'R (Running)' state for a little bit
1616      (observed in Linux 3.18).  See also the note on ESRCH in the
1617      ptrace(2) man page.  Instead, check whether the LWP has any state
1618      other than ptrace-stopped.  */
1619
1620   /* Don't assume anything if /proc/PID/status can't be read.  */
1621   if (linux_proc_pid_is_trace_stopped_nowarn (ptid_get_lwp (lp->ptid)) == 0)
1622     {
1623       lp->stop_reason = TARGET_STOPPED_BY_NO_REASON;
1624       lp->status = 0;
1625       lp->waitstatus.kind = TARGET_WAITKIND_IGNORE;
1626       return 1;
1627     }
1628   return 0;
1629 }
1630
1631 /* Like linux_resume_one_lwp_throw, but no error is thrown if the LWP
1632    disappears while we try to resume it.  */
1633
1634 static void
1635 linux_resume_one_lwp (struct lwp_info *lp, int step, enum gdb_signal signo)
1636 {
1637   TRY
1638     {
1639       linux_resume_one_lwp_throw (lp, step, signo);
1640     }
1641   CATCH (ex, RETURN_MASK_ERROR)
1642     {
1643       if (!check_ptrace_stopped_lwp_gone (lp))
1644         throw_exception (ex);
1645     }
1646   END_CATCH
1647 }
1648
1649 /* Resume LP.  */
1650
1651 static void
1652 resume_lwp (struct lwp_info *lp, int step, enum gdb_signal signo)
1653 {
1654   if (lp->stopped)
1655     {
1656       struct inferior *inf = find_inferior_ptid (lp->ptid);
1657
1658       if (inf->vfork_child != NULL)
1659         {
1660           if (debug_linux_nat)
1661             fprintf_unfiltered (gdb_stdlog,
1662                                 "RC: Not resuming %s (vfork parent)\n",
1663                                 target_pid_to_str (lp->ptid));
1664         }
1665       else if (!lwp_status_pending_p (lp))
1666         {
1667           if (debug_linux_nat)
1668             fprintf_unfiltered (gdb_stdlog,
1669                                 "RC: Resuming sibling %s, %s, %s\n",
1670                                 target_pid_to_str (lp->ptid),
1671                                 (signo != GDB_SIGNAL_0
1672                                  ? strsignal (gdb_signal_to_host (signo))
1673                                  : "0"),
1674                                 step ? "step" : "resume");
1675
1676           linux_resume_one_lwp (lp, step, signo);
1677         }
1678       else
1679         {
1680           if (debug_linux_nat)
1681             fprintf_unfiltered (gdb_stdlog,
1682                                 "RC: Not resuming sibling %s (has pending)\n",
1683                                 target_pid_to_str (lp->ptid));
1684         }
1685     }
1686   else
1687     {
1688       if (debug_linux_nat)
1689         fprintf_unfiltered (gdb_stdlog,
1690                             "RC: Not resuming sibling %s (not stopped)\n",
1691                             target_pid_to_str (lp->ptid));
1692     }
1693 }
1694
1695 /* Callback for iterate_over_lwps.  If LWP is EXCEPT, do nothing.
1696    Resume LWP with the last stop signal, if it is in pass state.  */
1697
1698 static int
1699 linux_nat_resume_callback (struct lwp_info *lp, void *except)
1700 {
1701   enum gdb_signal signo = GDB_SIGNAL_0;
1702
1703   if (lp == except)
1704     return 0;
1705
1706   if (lp->stopped)
1707     {
1708       struct thread_info *thread;
1709
1710       thread = find_thread_ptid (lp->ptid);
1711       if (thread != NULL)
1712         {
1713           signo = thread->suspend.stop_signal;
1714           thread->suspend.stop_signal = GDB_SIGNAL_0;
1715         }
1716     }
1717
1718   resume_lwp (lp, 0, signo);
1719   return 0;
1720 }
1721
1722 static int
1723 resume_clear_callback (struct lwp_info *lp, void *data)
1724 {
1725   lp->resumed = 0;
1726   lp->last_resume_kind = resume_stop;
1727   return 0;
1728 }
1729
1730 static int
1731 resume_set_callback (struct lwp_info *lp, void *data)
1732 {
1733   lp->resumed = 1;
1734   lp->last_resume_kind = resume_continue;
1735   return 0;
1736 }
1737
1738 static void
1739 linux_nat_resume (struct target_ops *ops,
1740                   ptid_t ptid, int step, enum gdb_signal signo)
1741 {
1742   struct lwp_info *lp;
1743   int resume_many;
1744
1745   if (debug_linux_nat)
1746     fprintf_unfiltered (gdb_stdlog,
1747                         "LLR: Preparing to %s %s, %s, inferior_ptid %s\n",
1748                         step ? "step" : "resume",
1749                         target_pid_to_str (ptid),
1750                         (signo != GDB_SIGNAL_0
1751                          ? strsignal (gdb_signal_to_host (signo)) : "0"),
1752                         target_pid_to_str (inferior_ptid));
1753
1754   /* A specific PTID means `step only this process id'.  */
1755   resume_many = (ptid_equal (minus_one_ptid, ptid)
1756                  || ptid_is_pid (ptid));
1757
1758   /* Mark the lwps we're resuming as resumed.  */
1759   iterate_over_lwps (ptid, resume_set_callback, NULL);
1760
1761   /* See if it's the current inferior that should be handled
1762      specially.  */
1763   if (resume_many)
1764     lp = find_lwp_pid (inferior_ptid);
1765   else
1766     lp = find_lwp_pid (ptid);
1767   gdb_assert (lp != NULL);
1768
1769   /* Remember if we're stepping.  */
1770   lp->last_resume_kind = step ? resume_step : resume_continue;
1771
1772   /* If we have a pending wait status for this thread, there is no
1773      point in resuming the process.  But first make sure that
1774      linux_nat_wait won't preemptively handle the event - we
1775      should never take this short-circuit if we are going to
1776      leave LP running, since we have skipped resuming all the
1777      other threads.  This bit of code needs to be synchronized
1778      with linux_nat_wait.  */
1779
1780   if (lp->status && WIFSTOPPED (lp->status))
1781     {
1782       if (!lp->step
1783           && WSTOPSIG (lp->status)
1784           && sigismember (&pass_mask, WSTOPSIG (lp->status)))
1785         {
1786           if (debug_linux_nat)
1787             fprintf_unfiltered (gdb_stdlog,
1788                                 "LLR: Not short circuiting for ignored "
1789                                 "status 0x%x\n", lp->status);
1790
1791           /* FIXME: What should we do if we are supposed to continue
1792              this thread with a signal?  */
1793           gdb_assert (signo == GDB_SIGNAL_0);
1794           signo = gdb_signal_from_host (WSTOPSIG (lp->status));
1795           lp->status = 0;
1796         }
1797     }
1798
1799   if (lwp_status_pending_p (lp))
1800     {
1801       /* FIXME: What should we do if we are supposed to continue
1802          this thread with a signal?  */
1803       gdb_assert (signo == GDB_SIGNAL_0);
1804
1805       if (debug_linux_nat)
1806         fprintf_unfiltered (gdb_stdlog,
1807                             "LLR: Short circuiting for status 0x%x\n",
1808                             lp->status);
1809
1810       if (target_can_async_p ())
1811         {
1812           target_async (1);
1813           /* Tell the event loop we have something to process.  */
1814           async_file_mark ();
1815         }
1816       return;
1817     }
1818
1819   if (resume_many)
1820     iterate_over_lwps (ptid, linux_nat_resume_callback, lp);
1821
1822   if (debug_linux_nat)
1823     fprintf_unfiltered (gdb_stdlog,
1824                         "LLR: %s %s, %s (resume event thread)\n",
1825                         step ? "PTRACE_SINGLESTEP" : "PTRACE_CONT",
1826                         target_pid_to_str (lp->ptid),
1827                         (signo != GDB_SIGNAL_0
1828                          ? strsignal (gdb_signal_to_host (signo)) : "0"));
1829
1830   linux_resume_one_lwp (lp, step, signo);
1831
1832   if (target_can_async_p ())
1833     target_async (1);
1834 }
1835
1836 /* Send a signal to an LWP.  */
1837
1838 static int
1839 kill_lwp (int lwpid, int signo)
1840 {
1841   int ret;
1842
1843   errno = 0;
1844   ret = syscall (__NR_tkill, lwpid, signo);
1845   if (errno == ENOSYS)
1846     {
1847       /* If tkill fails, then we are not using nptl threads, a
1848          configuration we no longer support.  */
1849       perror_with_name (("tkill"));
1850     }
1851   return ret;
1852 }
1853
1854 /* Handle a GNU/Linux syscall trap wait response.  If we see a syscall
1855    event, check if the core is interested in it: if not, ignore the
1856    event, and keep waiting; otherwise, we need to toggle the LWP's
1857    syscall entry/exit status, since the ptrace event itself doesn't
1858    indicate it, and report the trap to higher layers.  */
1859
1860 static int
1861 linux_handle_syscall_trap (struct lwp_info *lp, int stopping)
1862 {
1863   struct target_waitstatus *ourstatus = &lp->waitstatus;
1864   struct gdbarch *gdbarch = target_thread_architecture (lp->ptid);
1865   int syscall_number = (int) gdbarch_get_syscall_number (gdbarch, lp->ptid);
1866
1867   if (stopping)
1868     {
1869       /* If we're stopping threads, there's a SIGSTOP pending, which
1870          makes it so that the LWP reports an immediate syscall return,
1871          followed by the SIGSTOP.  Skip seeing that "return" using
1872          PTRACE_CONT directly, and let stop_wait_callback collect the
1873          SIGSTOP.  Later when the thread is resumed, a new syscall
1874          entry event.  If we didn't do this (and returned 0), we'd
1875          leave a syscall entry pending, and our caller, by using
1876          PTRACE_CONT to collect the SIGSTOP, skips the syscall return
1877          itself.  Later, when the user re-resumes this LWP, we'd see
1878          another syscall entry event and we'd mistake it for a return.
1879
1880          If stop_wait_callback didn't force the SIGSTOP out of the LWP
1881          (leaving immediately with LWP->signalled set, without issuing
1882          a PTRACE_CONT), it would still be problematic to leave this
1883          syscall enter pending, as later when the thread is resumed,
1884          it would then see the same syscall exit mentioned above,
1885          followed by the delayed SIGSTOP, while the syscall didn't
1886          actually get to execute.  It seems it would be even more
1887          confusing to the user.  */
1888
1889       if (debug_linux_nat)
1890         fprintf_unfiltered (gdb_stdlog,
1891                             "LHST: ignoring syscall %d "
1892                             "for LWP %ld (stopping threads), "
1893                             "resuming with PTRACE_CONT for SIGSTOP\n",
1894                             syscall_number,
1895                             ptid_get_lwp (lp->ptid));
1896
1897       lp->syscall_state = TARGET_WAITKIND_IGNORE;
1898       ptrace (PTRACE_CONT, ptid_get_lwp (lp->ptid), 0, 0);
1899       lp->stopped = 0;
1900       return 1;
1901     }
1902
1903   /* Always update the entry/return state, even if this particular
1904      syscall isn't interesting to the core now.  In async mode,
1905      the user could install a new catchpoint for this syscall
1906      between syscall enter/return, and we'll need to know to
1907      report a syscall return if that happens.  */
1908   lp->syscall_state = (lp->syscall_state == TARGET_WAITKIND_SYSCALL_ENTRY
1909                        ? TARGET_WAITKIND_SYSCALL_RETURN
1910                        : TARGET_WAITKIND_SYSCALL_ENTRY);
1911
1912   if (catch_syscall_enabled ())
1913     {
1914       if (catching_syscall_number (syscall_number))
1915         {
1916           /* Alright, an event to report.  */
1917           ourstatus->kind = lp->syscall_state;
1918           ourstatus->value.syscall_number = syscall_number;
1919
1920           if (debug_linux_nat)
1921             fprintf_unfiltered (gdb_stdlog,
1922                                 "LHST: stopping for %s of syscall %d"
1923                                 " for LWP %ld\n",
1924                                 lp->syscall_state
1925                                 == TARGET_WAITKIND_SYSCALL_ENTRY
1926                                 ? "entry" : "return",
1927                                 syscall_number,
1928                                 ptid_get_lwp (lp->ptid));
1929           return 0;
1930         }
1931
1932       if (debug_linux_nat)
1933         fprintf_unfiltered (gdb_stdlog,
1934                             "LHST: ignoring %s of syscall %d "
1935                             "for LWP %ld\n",
1936                             lp->syscall_state == TARGET_WAITKIND_SYSCALL_ENTRY
1937                             ? "entry" : "return",
1938                             syscall_number,
1939                             ptid_get_lwp (lp->ptid));
1940     }
1941   else
1942     {
1943       /* If we had been syscall tracing, and hence used PT_SYSCALL
1944          before on this LWP, it could happen that the user removes all
1945          syscall catchpoints before we get to process this event.
1946          There are two noteworthy issues here:
1947
1948          - When stopped at a syscall entry event, resuming with
1949            PT_STEP still resumes executing the syscall and reports a
1950            syscall return.
1951
1952          - Only PT_SYSCALL catches syscall enters.  If we last
1953            single-stepped this thread, then this event can't be a
1954            syscall enter.  If we last single-stepped this thread, this
1955            has to be a syscall exit.
1956
1957          The points above mean that the next resume, be it PT_STEP or
1958          PT_CONTINUE, can not trigger a syscall trace event.  */
1959       if (debug_linux_nat)
1960         fprintf_unfiltered (gdb_stdlog,
1961                             "LHST: caught syscall event "
1962                             "with no syscall catchpoints."
1963                             " %d for LWP %ld, ignoring\n",
1964                             syscall_number,
1965                             ptid_get_lwp (lp->ptid));
1966       lp->syscall_state = TARGET_WAITKIND_IGNORE;
1967     }
1968
1969   /* The core isn't interested in this event.  For efficiency, avoid
1970      stopping all threads only to have the core resume them all again.
1971      Since we're not stopping threads, if we're still syscall tracing
1972      and not stepping, we can't use PTRACE_CONT here, as we'd miss any
1973      subsequent syscall.  Simply resume using the inf-ptrace layer,
1974      which knows when to use PT_SYSCALL or PT_CONTINUE.  */
1975
1976   linux_resume_one_lwp (lp, lp->step, GDB_SIGNAL_0);
1977   return 1;
1978 }
1979
1980 /* Handle a GNU/Linux extended wait response.  If we see a clone
1981    event, we need to add the new LWP to our list (and not report the
1982    trap to higher layers).  This function returns non-zero if the
1983    event should be ignored and we should wait again.  If STOPPING is
1984    true, the new LWP remains stopped, otherwise it is continued.  */
1985
1986 static int
1987 linux_handle_extended_wait (struct lwp_info *lp, int status)
1988 {
1989   int pid = ptid_get_lwp (lp->ptid);
1990   struct target_waitstatus *ourstatus = &lp->waitstatus;
1991   int event = linux_ptrace_get_extended_event (status);
1992
1993   /* All extended events we currently use are mid-syscall.  Only
1994      PTRACE_EVENT_STOP is delivered more like a signal-stop, but
1995      you have to be using PTRACE_SEIZE to get that.  */
1996   lp->syscall_state = TARGET_WAITKIND_SYSCALL_ENTRY;
1997
1998   if (event == PTRACE_EVENT_FORK || event == PTRACE_EVENT_VFORK
1999       || event == PTRACE_EVENT_CLONE)
2000     {
2001       unsigned long new_pid;
2002       int ret;
2003
2004       ptrace (PTRACE_GETEVENTMSG, pid, 0, &new_pid);
2005
2006       /* If we haven't already seen the new PID stop, wait for it now.  */
2007       if (! pull_pid_from_list (&stopped_pids, new_pid, &status))
2008         {
2009           /* The new child has a pending SIGSTOP.  We can't affect it until it
2010              hits the SIGSTOP, but we're already attached.  */
2011           ret = my_waitpid (new_pid, &status, __WALL);
2012           if (ret == -1)
2013             perror_with_name (_("waiting for new child"));
2014           else if (ret != new_pid)
2015             internal_error (__FILE__, __LINE__,
2016                             _("wait returned unexpected PID %d"), ret);
2017           else if (!WIFSTOPPED (status))
2018             internal_error (__FILE__, __LINE__,
2019                             _("wait returned unexpected status 0x%x"), status);
2020         }
2021
2022       ourstatus->value.related_pid = ptid_build (new_pid, new_pid, 0);
2023
2024       if (event == PTRACE_EVENT_FORK || event == PTRACE_EVENT_VFORK)
2025         {
2026           /* The arch-specific native code may need to know about new
2027              forks even if those end up never mapped to an
2028              inferior.  */
2029           if (linux_nat_new_fork != NULL)
2030             linux_nat_new_fork (lp, new_pid);
2031         }
2032
2033       if (event == PTRACE_EVENT_FORK
2034           && linux_fork_checkpointing_p (ptid_get_pid (lp->ptid)))
2035         {
2036           /* Handle checkpointing by linux-fork.c here as a special
2037              case.  We don't want the follow-fork-mode or 'catch fork'
2038              to interfere with this.  */
2039
2040           /* This won't actually modify the breakpoint list, but will
2041              physically remove the breakpoints from the child.  */
2042           detach_breakpoints (ptid_build (new_pid, new_pid, 0));
2043
2044           /* Retain child fork in ptrace (stopped) state.  */
2045           if (!find_fork_pid (new_pid))
2046             add_fork (new_pid);
2047
2048           /* Report as spurious, so that infrun doesn't want to follow
2049              this fork.  We're actually doing an infcall in
2050              linux-fork.c.  */
2051           ourstatus->kind = TARGET_WAITKIND_SPURIOUS;
2052
2053           /* Report the stop to the core.  */
2054           return 0;
2055         }
2056
2057       if (event == PTRACE_EVENT_FORK)
2058         ourstatus->kind = TARGET_WAITKIND_FORKED;
2059       else if (event == PTRACE_EVENT_VFORK)
2060         ourstatus->kind = TARGET_WAITKIND_VFORKED;
2061       else if (event == PTRACE_EVENT_CLONE)
2062         {
2063           struct lwp_info *new_lp;
2064
2065           ourstatus->kind = TARGET_WAITKIND_IGNORE;
2066
2067           if (debug_linux_nat)
2068             fprintf_unfiltered (gdb_stdlog,
2069                                 "LHEW: Got clone event "
2070                                 "from LWP %d, new child is LWP %ld\n",
2071                                 pid, new_pid);
2072
2073           new_lp = add_lwp (ptid_build (ptid_get_pid (lp->ptid), new_pid, 0));
2074           new_lp->stopped = 1;
2075           new_lp->resumed = 1;
2076
2077           /* If the thread_db layer is active, let it record the user
2078              level thread id and status, and add the thread to GDB's
2079              list.  */
2080           if (!thread_db_notice_clone (lp->ptid, new_lp->ptid))
2081             {
2082               /* The process is not using thread_db.  Add the LWP to
2083                  GDB's list.  */
2084               target_post_attach (ptid_get_lwp (new_lp->ptid));
2085               add_thread (new_lp->ptid);
2086             }
2087
2088           /* Even if we're stopping the thread for some reason
2089              internal to this module, from the perspective of infrun
2090              and the user/frontend, this new thread is running until
2091              it next reports a stop.  */
2092           set_running (new_lp->ptid, 1);
2093           set_executing (new_lp->ptid, 1);
2094
2095           if (WSTOPSIG (status) != SIGSTOP)
2096             {
2097               /* This can happen if someone starts sending signals to
2098                  the new thread before it gets a chance to run, which
2099                  have a lower number than SIGSTOP (e.g. SIGUSR1).
2100                  This is an unlikely case, and harder to handle for
2101                  fork / vfork than for clone, so we do not try - but
2102                  we handle it for clone events here.  */
2103
2104               new_lp->signalled = 1;
2105
2106               /* We created NEW_LP so it cannot yet contain STATUS.  */
2107               gdb_assert (new_lp->status == 0);
2108
2109               /* Save the wait status to report later.  */
2110               if (debug_linux_nat)
2111                 fprintf_unfiltered (gdb_stdlog,
2112                                     "LHEW: waitpid of new LWP %ld, "
2113                                     "saving status %s\n",
2114                                     (long) ptid_get_lwp (new_lp->ptid),
2115                                     status_to_str (status));
2116               new_lp->status = status;
2117             }
2118           else if (report_thread_events)
2119             {
2120               new_lp->waitstatus.kind = TARGET_WAITKIND_THREAD_CREATED;
2121               new_lp->status = status;
2122             }
2123
2124           return 1;
2125         }
2126
2127       return 0;
2128     }
2129
2130   if (event == PTRACE_EVENT_EXEC)
2131     {
2132       if (debug_linux_nat)
2133         fprintf_unfiltered (gdb_stdlog,
2134                             "LHEW: Got exec event from LWP %ld\n",
2135                             ptid_get_lwp (lp->ptid));
2136
2137       ourstatus->kind = TARGET_WAITKIND_EXECD;
2138       ourstatus->value.execd_pathname
2139         = xstrdup (linux_child_pid_to_exec_file (NULL, pid));
2140
2141       /* The thread that execed must have been resumed, but, when a
2142          thread execs, it changes its tid to the tgid, and the old
2143          tgid thread might have not been resumed.  */
2144       lp->resumed = 1;
2145       return 0;
2146     }
2147
2148   if (event == PTRACE_EVENT_VFORK_DONE)
2149     {
2150       if (current_inferior ()->waiting_for_vfork_done)
2151         {
2152           if (debug_linux_nat)
2153             fprintf_unfiltered (gdb_stdlog,
2154                                 "LHEW: Got expected PTRACE_EVENT_"
2155                                 "VFORK_DONE from LWP %ld: stopping\n",
2156                                 ptid_get_lwp (lp->ptid));
2157
2158           ourstatus->kind = TARGET_WAITKIND_VFORK_DONE;
2159           return 0;
2160         }
2161
2162       if (debug_linux_nat)
2163         fprintf_unfiltered (gdb_stdlog,
2164                             "LHEW: Got PTRACE_EVENT_VFORK_DONE "
2165                             "from LWP %ld: ignoring\n",
2166                             ptid_get_lwp (lp->ptid));
2167       return 1;
2168     }
2169
2170   internal_error (__FILE__, __LINE__,
2171                   _("unknown ptrace event %d"), event);
2172 }
2173
2174 /* Wait for LP to stop.  Returns the wait status, or 0 if the LWP has
2175    exited.  */
2176
2177 static int
2178 wait_lwp (struct lwp_info *lp)
2179 {
2180   pid_t pid;
2181   int status = 0;
2182   int thread_dead = 0;
2183   sigset_t prev_mask;
2184
2185   gdb_assert (!lp->stopped);
2186   gdb_assert (lp->status == 0);
2187
2188   /* Make sure SIGCHLD is blocked for sigsuspend avoiding a race below.  */
2189   block_child_signals (&prev_mask);
2190
2191   for (;;)
2192     {
2193       pid = my_waitpid (ptid_get_lwp (lp->ptid), &status, __WALL | WNOHANG);
2194       if (pid == -1 && errno == ECHILD)
2195         {
2196           /* The thread has previously exited.  We need to delete it
2197              now because if this was a non-leader thread execing, we
2198              won't get an exit event.  See comments on exec events at
2199              the top of the file.  */
2200           thread_dead = 1;
2201           if (debug_linux_nat)
2202             fprintf_unfiltered (gdb_stdlog, "WL: %s vanished.\n",
2203                                 target_pid_to_str (lp->ptid));
2204         }
2205       if (pid != 0)
2206         break;
2207
2208       /* Bugs 10970, 12702.
2209          Thread group leader may have exited in which case we'll lock up in
2210          waitpid if there are other threads, even if they are all zombies too.
2211          Basically, we're not supposed to use waitpid this way.
2212           tkill(pid,0) cannot be used here as it gets ESRCH for both
2213          for zombie and running processes.
2214
2215          As a workaround, check if we're waiting for the thread group leader and
2216          if it's a zombie, and avoid calling waitpid if it is.
2217
2218          This is racy, what if the tgl becomes a zombie right after we check?
2219          Therefore always use WNOHANG with sigsuspend - it is equivalent to
2220          waiting waitpid but linux_proc_pid_is_zombie is safe this way.  */
2221
2222       if (ptid_get_pid (lp->ptid) == ptid_get_lwp (lp->ptid)
2223           && linux_proc_pid_is_zombie (ptid_get_lwp (lp->ptid)))
2224         {
2225           thread_dead = 1;
2226           if (debug_linux_nat)
2227             fprintf_unfiltered (gdb_stdlog,
2228                                 "WL: Thread group leader %s vanished.\n",
2229                                 target_pid_to_str (lp->ptid));
2230           break;
2231         }
2232
2233       /* Wait for next SIGCHLD and try again.  This may let SIGCHLD handlers
2234          get invoked despite our caller had them intentionally blocked by
2235          block_child_signals.  This is sensitive only to the loop of
2236          linux_nat_wait_1 and there if we get called my_waitpid gets called
2237          again before it gets to sigsuspend so we can safely let the handlers
2238          get executed here.  */
2239
2240       if (debug_linux_nat)
2241         fprintf_unfiltered (gdb_stdlog, "WL: about to sigsuspend\n");
2242       sigsuspend (&suspend_mask);
2243     }
2244
2245   restore_child_signals_mask (&prev_mask);
2246
2247   if (!thread_dead)
2248     {
2249       gdb_assert (pid == ptid_get_lwp (lp->ptid));
2250
2251       if (debug_linux_nat)
2252         {
2253           fprintf_unfiltered (gdb_stdlog,
2254                               "WL: waitpid %s received %s\n",
2255                               target_pid_to_str (lp->ptid),
2256                               status_to_str (status));
2257         }
2258
2259       /* Check if the thread has exited.  */
2260       if (WIFEXITED (status) || WIFSIGNALED (status))
2261         {
2262           if (report_thread_events
2263               || ptid_get_pid (lp->ptid) == ptid_get_lwp (lp->ptid))
2264             {
2265               if (debug_linux_nat)
2266                 fprintf_unfiltered (gdb_stdlog, "WL: LWP %d exited.\n",
2267                                     ptid_get_pid (lp->ptid));
2268
2269               /* If this is the leader exiting, it means the whole
2270                  process is gone.  Store the status to report to the
2271                  core.  Store it in lp->waitstatus, because lp->status
2272                  would be ambiguous (W_EXITCODE(0,0) == 0).  */
2273               store_waitstatus (&lp->waitstatus, status);
2274               return 0;
2275             }
2276
2277           thread_dead = 1;
2278           if (debug_linux_nat)
2279             fprintf_unfiltered (gdb_stdlog, "WL: %s exited.\n",
2280                                 target_pid_to_str (lp->ptid));
2281         }
2282     }
2283
2284   if (thread_dead)
2285     {
2286       exit_lwp (lp);
2287       return 0;
2288     }
2289
2290   gdb_assert (WIFSTOPPED (status));
2291   lp->stopped = 1;
2292
2293   if (lp->must_set_ptrace_flags)
2294     {
2295       struct inferior *inf = find_inferior_pid (ptid_get_pid (lp->ptid));
2296       int options = linux_nat_ptrace_options (inf->attach_flag);
2297
2298       linux_enable_event_reporting (ptid_get_lwp (lp->ptid), options);
2299       lp->must_set_ptrace_flags = 0;
2300     }
2301
2302   /* Handle GNU/Linux's syscall SIGTRAPs.  */
2303   if (WIFSTOPPED (status) && WSTOPSIG (status) == SYSCALL_SIGTRAP)
2304     {
2305       /* No longer need the sysgood bit.  The ptrace event ends up
2306          recorded in lp->waitstatus if we care for it.  We can carry
2307          on handling the event like a regular SIGTRAP from here
2308          on.  */
2309       status = W_STOPCODE (SIGTRAP);
2310       if (linux_handle_syscall_trap (lp, 1))
2311         return wait_lwp (lp);
2312     }
2313   else
2314     {
2315       /* Almost all other ptrace-stops are known to be outside of system
2316          calls, with further exceptions in linux_handle_extended_wait.  */
2317       lp->syscall_state = TARGET_WAITKIND_IGNORE;
2318     }
2319
2320   /* Handle GNU/Linux's extended waitstatus for trace events.  */
2321   if (WIFSTOPPED (status) && WSTOPSIG (status) == SIGTRAP
2322       && linux_is_extended_waitstatus (status))
2323     {
2324       if (debug_linux_nat)
2325         fprintf_unfiltered (gdb_stdlog,
2326                             "WL: Handling extended status 0x%06x\n",
2327                             status);
2328       linux_handle_extended_wait (lp, status);
2329       return 0;
2330     }
2331
2332   return status;
2333 }
2334
2335 /* Send a SIGSTOP to LP.  */
2336
2337 static int
2338 stop_callback (struct lwp_info *lp, void *data)
2339 {
2340   if (!lp->stopped && !lp->signalled)
2341     {
2342       int ret;
2343
2344       if (debug_linux_nat)
2345         {
2346           fprintf_unfiltered (gdb_stdlog,
2347                               "SC:  kill %s **<SIGSTOP>**\n",
2348                               target_pid_to_str (lp->ptid));
2349         }
2350       errno = 0;
2351       ret = kill_lwp (ptid_get_lwp (lp->ptid), SIGSTOP);
2352       if (debug_linux_nat)
2353         {
2354           fprintf_unfiltered (gdb_stdlog,
2355                               "SC:  lwp kill %d %s\n",
2356                               ret,
2357                               errno ? safe_strerror (errno) : "ERRNO-OK");
2358         }
2359
2360       lp->signalled = 1;
2361       gdb_assert (lp->status == 0);
2362     }
2363
2364   return 0;
2365 }
2366
2367 /* Request a stop on LWP.  */
2368
2369 void
2370 linux_stop_lwp (struct lwp_info *lwp)
2371 {
2372   stop_callback (lwp, NULL);
2373 }
2374
2375 /* See linux-nat.h  */
2376
2377 void
2378 linux_stop_and_wait_all_lwps (void)
2379 {
2380   /* Stop all LWP's ...  */
2381   iterate_over_lwps (minus_one_ptid, stop_callback, NULL);
2382
2383   /* ... and wait until all of them have reported back that
2384      they're no longer running.  */
2385   iterate_over_lwps (minus_one_ptid, stop_wait_callback, NULL);
2386 }
2387
2388 /* See linux-nat.h  */
2389
2390 void
2391 linux_unstop_all_lwps (void)
2392 {
2393   iterate_over_lwps (minus_one_ptid,
2394                      resume_stopped_resumed_lwps, &minus_one_ptid);
2395 }
2396
2397 /* Return non-zero if LWP PID has a pending SIGINT.  */
2398
2399 static int
2400 linux_nat_has_pending_sigint (int pid)
2401 {
2402   sigset_t pending, blocked, ignored;
2403
2404   linux_proc_pending_signals (pid, &pending, &blocked, &ignored);
2405
2406   if (sigismember (&pending, SIGINT)
2407       && !sigismember (&ignored, SIGINT))
2408     return 1;
2409
2410   return 0;
2411 }
2412
2413 /* Set a flag in LP indicating that we should ignore its next SIGINT.  */
2414
2415 static int
2416 set_ignore_sigint (struct lwp_info *lp, void *data)
2417 {
2418   /* If a thread has a pending SIGINT, consume it; otherwise, set a
2419      flag to consume the next one.  */
2420   if (lp->stopped && lp->status != 0 && WIFSTOPPED (lp->status)
2421       && WSTOPSIG (lp->status) == SIGINT)
2422     lp->status = 0;
2423   else
2424     lp->ignore_sigint = 1;
2425
2426   return 0;
2427 }
2428
2429 /* If LP does not have a SIGINT pending, then clear the ignore_sigint flag.
2430    This function is called after we know the LWP has stopped; if the LWP
2431    stopped before the expected SIGINT was delivered, then it will never have
2432    arrived.  Also, if the signal was delivered to a shared queue and consumed
2433    by a different thread, it will never be delivered to this LWP.  */
2434
2435 static void
2436 maybe_clear_ignore_sigint (struct lwp_info *lp)
2437 {
2438   if (!lp->ignore_sigint)
2439     return;
2440
2441   if (!linux_nat_has_pending_sigint (ptid_get_lwp (lp->ptid)))
2442     {
2443       if (debug_linux_nat)
2444         fprintf_unfiltered (gdb_stdlog,
2445                             "MCIS: Clearing bogus flag for %s\n",
2446                             target_pid_to_str (lp->ptid));
2447       lp->ignore_sigint = 0;
2448     }
2449 }
2450
2451 /* Fetch the possible triggered data watchpoint info and store it in
2452    LP.
2453
2454    On some archs, like x86, that use debug registers to set
2455    watchpoints, it's possible that the way to know which watched
2456    address trapped, is to check the register that is used to select
2457    which address to watch.  Problem is, between setting the watchpoint
2458    and reading back which data address trapped, the user may change
2459    the set of watchpoints, and, as a consequence, GDB changes the
2460    debug registers in the inferior.  To avoid reading back a stale
2461    stopped-data-address when that happens, we cache in LP the fact
2462    that a watchpoint trapped, and the corresponding data address, as
2463    soon as we see LP stop with a SIGTRAP.  If GDB changes the debug
2464    registers meanwhile, we have the cached data we can rely on.  */
2465
2466 static int
2467 check_stopped_by_watchpoint (struct lwp_info *lp)
2468 {
2469   if (linux_ops->to_stopped_by_watchpoint == NULL)
2470     return 0;
2471
2472   scoped_restore save_inferior_ptid = make_scoped_restore (&inferior_ptid);
2473   inferior_ptid = lp->ptid;
2474
2475   if (linux_ops->to_stopped_by_watchpoint (linux_ops))
2476     {
2477       lp->stop_reason = TARGET_STOPPED_BY_WATCHPOINT;
2478
2479       if (linux_ops->to_stopped_data_address != NULL)
2480         lp->stopped_data_address_p =
2481           linux_ops->to_stopped_data_address (&current_target,
2482                                               &lp->stopped_data_address);
2483       else
2484         lp->stopped_data_address_p = 0;
2485     }
2486
2487   return lp->stop_reason == TARGET_STOPPED_BY_WATCHPOINT;
2488 }
2489
2490 /* Returns true if the LWP had stopped for a watchpoint.  */
2491
2492 static int
2493 linux_nat_stopped_by_watchpoint (struct target_ops *ops)
2494 {
2495   struct lwp_info *lp = find_lwp_pid (inferior_ptid);
2496
2497   gdb_assert (lp != NULL);
2498
2499   return lp->stop_reason == TARGET_STOPPED_BY_WATCHPOINT;
2500 }
2501
2502 static int
2503 linux_nat_stopped_data_address (struct target_ops *ops, CORE_ADDR *addr_p)
2504 {
2505   struct lwp_info *lp = find_lwp_pid (inferior_ptid);
2506
2507   gdb_assert (lp != NULL);
2508
2509   *addr_p = lp->stopped_data_address;
2510
2511   return lp->stopped_data_address_p;
2512 }
2513
2514 /* Commonly any breakpoint / watchpoint generate only SIGTRAP.  */
2515
2516 static int
2517 sigtrap_is_event (int status)
2518 {
2519   return WIFSTOPPED (status) && WSTOPSIG (status) == SIGTRAP;
2520 }
2521
2522 /* Set alternative SIGTRAP-like events recognizer.  If
2523    breakpoint_inserted_here_p there then gdbarch_decr_pc_after_break will be
2524    applied.  */
2525
2526 void
2527 linux_nat_set_status_is_event (struct target_ops *t,
2528                                int (*status_is_event) (int status))
2529 {
2530   linux_nat_status_is_event = status_is_event;
2531 }
2532
2533 /* Wait until LP is stopped.  */
2534
2535 static int
2536 stop_wait_callback (struct lwp_info *lp, void *data)
2537 {
2538   struct inferior *inf = find_inferior_ptid (lp->ptid);
2539
2540   /* If this is a vfork parent, bail out, it is not going to report
2541      any SIGSTOP until the vfork is done with.  */
2542   if (inf->vfork_child != NULL)
2543     return 0;
2544
2545   if (!lp->stopped)
2546     {
2547       int status;
2548
2549       status = wait_lwp (lp);
2550       if (status == 0)
2551         return 0;
2552
2553       if (lp->ignore_sigint && WIFSTOPPED (status)
2554           && WSTOPSIG (status) == SIGINT)
2555         {
2556           lp->ignore_sigint = 0;
2557
2558           errno = 0;
2559           ptrace (PTRACE_CONT, ptid_get_lwp (lp->ptid), 0, 0);
2560           lp->stopped = 0;
2561           if (debug_linux_nat)
2562             fprintf_unfiltered (gdb_stdlog,
2563                                 "PTRACE_CONT %s, 0, 0 (%s) "
2564                                 "(discarding SIGINT)\n",
2565                                 target_pid_to_str (lp->ptid),
2566                                 errno ? safe_strerror (errno) : "OK");
2567
2568           return stop_wait_callback (lp, NULL);
2569         }
2570
2571       maybe_clear_ignore_sigint (lp);
2572
2573       if (WSTOPSIG (status) != SIGSTOP)
2574         {
2575           /* The thread was stopped with a signal other than SIGSTOP.  */
2576
2577           if (debug_linux_nat)
2578             fprintf_unfiltered (gdb_stdlog,
2579                                 "SWC: Pending event %s in %s\n",
2580                                 status_to_str ((int) status),
2581                                 target_pid_to_str (lp->ptid));
2582
2583           /* Save the sigtrap event.  */
2584           lp->status = status;
2585           gdb_assert (lp->signalled);
2586           save_stop_reason (lp);
2587         }
2588       else
2589         {
2590           /* We caught the SIGSTOP that we intended to catch, so
2591              there's no SIGSTOP pending.  */
2592
2593           if (debug_linux_nat)
2594             fprintf_unfiltered (gdb_stdlog,
2595                                 "SWC: Expected SIGSTOP caught for %s.\n",
2596                                 target_pid_to_str (lp->ptid));
2597
2598           /* Reset SIGNALLED only after the stop_wait_callback call
2599              above as it does gdb_assert on SIGNALLED.  */
2600           lp->signalled = 0;
2601         }
2602     }
2603
2604   return 0;
2605 }
2606
2607 /* Return non-zero if LP has a wait status pending.  Discard the
2608    pending event and resume the LWP if the event that originally
2609    caused the stop became uninteresting.  */
2610
2611 static int
2612 status_callback (struct lwp_info *lp, void *data)
2613 {
2614   /* Only report a pending wait status if we pretend that this has
2615      indeed been resumed.  */
2616   if (!lp->resumed)
2617     return 0;
2618
2619   if (!lwp_status_pending_p (lp))
2620     return 0;
2621
2622   if (lp->stop_reason == TARGET_STOPPED_BY_SW_BREAKPOINT
2623       || lp->stop_reason == TARGET_STOPPED_BY_HW_BREAKPOINT)
2624     {
2625       struct regcache *regcache = get_thread_regcache (lp->ptid);
2626       CORE_ADDR pc;
2627       int discard = 0;
2628
2629       pc = regcache_read_pc (regcache);
2630
2631       if (pc != lp->stop_pc)
2632         {
2633           if (debug_linux_nat)
2634             fprintf_unfiltered (gdb_stdlog,
2635                                 "SC: PC of %s changed.  was=%s, now=%s\n",
2636                                 target_pid_to_str (lp->ptid),
2637                                 paddress (target_gdbarch (), lp->stop_pc),
2638                                 paddress (target_gdbarch (), pc));
2639           discard = 1;
2640         }
2641
2642 #if !USE_SIGTRAP_SIGINFO
2643       else if (!breakpoint_inserted_here_p (regcache->aspace (), pc))
2644         {
2645           if (debug_linux_nat)
2646             fprintf_unfiltered (gdb_stdlog,
2647                                 "SC: previous breakpoint of %s, at %s gone\n",
2648                                 target_pid_to_str (lp->ptid),
2649                                 paddress (target_gdbarch (), lp->stop_pc));
2650
2651           discard = 1;
2652         }
2653 #endif
2654
2655       if (discard)
2656         {
2657           if (debug_linux_nat)
2658             fprintf_unfiltered (gdb_stdlog,
2659                                 "SC: pending event of %s cancelled.\n",
2660                                 target_pid_to_str (lp->ptid));
2661
2662           lp->status = 0;
2663           linux_resume_one_lwp (lp, lp->step, GDB_SIGNAL_0);
2664           return 0;
2665         }
2666     }
2667
2668   return 1;
2669 }
2670
2671 /* Count the LWP's that have had events.  */
2672
2673 static int
2674 count_events_callback (struct lwp_info *lp, void *data)
2675 {
2676   int *count = (int *) data;
2677
2678   gdb_assert (count != NULL);
2679
2680   /* Select only resumed LWPs that have an event pending.  */
2681   if (lp->resumed && lwp_status_pending_p (lp))
2682     (*count)++;
2683
2684   return 0;
2685 }
2686
2687 /* Select the LWP (if any) that is currently being single-stepped.  */
2688
2689 static int
2690 select_singlestep_lwp_callback (struct lwp_info *lp, void *data)
2691 {
2692   if (lp->last_resume_kind == resume_step
2693       && lp->status != 0)
2694     return 1;
2695   else
2696     return 0;
2697 }
2698
2699 /* Returns true if LP has a status pending.  */
2700
2701 static int
2702 lwp_status_pending_p (struct lwp_info *lp)
2703 {
2704   /* We check for lp->waitstatus in addition to lp->status, because we
2705      can have pending process exits recorded in lp->status and
2706      W_EXITCODE(0,0) happens to be 0.  */
2707   return lp->status != 0 || lp->waitstatus.kind != TARGET_WAITKIND_IGNORE;
2708 }
2709
2710 /* Select the Nth LWP that has had an event.  */
2711
2712 static int
2713 select_event_lwp_callback (struct lwp_info *lp, void *data)
2714 {
2715   int *selector = (int *) data;
2716
2717   gdb_assert (selector != NULL);
2718
2719   /* Select only resumed LWPs that have an event pending.  */
2720   if (lp->resumed && lwp_status_pending_p (lp))
2721     if ((*selector)-- == 0)
2722       return 1;
2723
2724   return 0;
2725 }
2726
2727 /* Called when the LWP stopped for a signal/trap.  If it stopped for a
2728    trap check what caused it (breakpoint, watchpoint, trace, etc.),
2729    and save the result in the LWP's stop_reason field.  If it stopped
2730    for a breakpoint, decrement the PC if necessary on the lwp's
2731    architecture.  */
2732
2733 static void
2734 save_stop_reason (struct lwp_info *lp)
2735 {
2736   struct regcache *regcache;
2737   struct gdbarch *gdbarch;
2738   CORE_ADDR pc;
2739   CORE_ADDR sw_bp_pc;
2740 #if USE_SIGTRAP_SIGINFO
2741   siginfo_t siginfo;
2742 #endif
2743
2744   gdb_assert (lp->stop_reason == TARGET_STOPPED_BY_NO_REASON);
2745   gdb_assert (lp->status != 0);
2746
2747   if (!linux_nat_status_is_event (lp->status))
2748     return;
2749
2750   regcache = get_thread_regcache (lp->ptid);
2751   gdbarch = regcache->arch ();
2752
2753   pc = regcache_read_pc (regcache);
2754   sw_bp_pc = pc - gdbarch_decr_pc_after_break (gdbarch);
2755
2756 #if USE_SIGTRAP_SIGINFO
2757   if (linux_nat_get_siginfo (lp->ptid, &siginfo))
2758     {
2759       if (siginfo.si_signo == SIGTRAP)
2760         {
2761           if (GDB_ARCH_IS_TRAP_BRKPT (siginfo.si_code)
2762               && GDB_ARCH_IS_TRAP_HWBKPT (siginfo.si_code))
2763             {
2764               /* The si_code is ambiguous on this arch -- check debug
2765                  registers.  */
2766               if (!check_stopped_by_watchpoint (lp))
2767                 lp->stop_reason = TARGET_STOPPED_BY_SW_BREAKPOINT;
2768             }
2769           else if (GDB_ARCH_IS_TRAP_BRKPT (siginfo.si_code))
2770             {
2771               /* If we determine the LWP stopped for a SW breakpoint,
2772                  trust it.  Particularly don't check watchpoint
2773                  registers, because at least on s390, we'd find
2774                  stopped-by-watchpoint as long as there's a watchpoint
2775                  set.  */
2776               lp->stop_reason = TARGET_STOPPED_BY_SW_BREAKPOINT;
2777             }
2778           else if (GDB_ARCH_IS_TRAP_HWBKPT (siginfo.si_code))
2779             {
2780               /* This can indicate either a hardware breakpoint or
2781                  hardware watchpoint.  Check debug registers.  */
2782               if (!check_stopped_by_watchpoint (lp))
2783                 lp->stop_reason = TARGET_STOPPED_BY_HW_BREAKPOINT;
2784             }
2785           else if (siginfo.si_code == TRAP_TRACE)
2786             {
2787               if (debug_linux_nat)
2788                 fprintf_unfiltered (gdb_stdlog,
2789                                     "CSBB: %s stopped by trace\n",
2790                                     target_pid_to_str (lp->ptid));
2791
2792               /* We may have single stepped an instruction that
2793                  triggered a watchpoint.  In that case, on some
2794                  architectures (such as x86), instead of TRAP_HWBKPT,
2795                  si_code indicates TRAP_TRACE, and we need to check
2796                  the debug registers separately.  */
2797               check_stopped_by_watchpoint (lp);
2798             }
2799         }
2800     }
2801 #else
2802   if ((!lp->step || lp->stop_pc == sw_bp_pc)
2803       && software_breakpoint_inserted_here_p (regcache->aspace (),
2804                                               sw_bp_pc))
2805     {
2806       /* The LWP was either continued, or stepped a software
2807          breakpoint instruction.  */
2808       lp->stop_reason = TARGET_STOPPED_BY_SW_BREAKPOINT;
2809     }
2810
2811   if (hardware_breakpoint_inserted_here_p (regcache->aspace (), pc))
2812     lp->stop_reason = TARGET_STOPPED_BY_HW_BREAKPOINT;
2813
2814   if (lp->stop_reason == TARGET_STOPPED_BY_NO_REASON)
2815     check_stopped_by_watchpoint (lp);
2816 #endif
2817
2818   if (lp->stop_reason == TARGET_STOPPED_BY_SW_BREAKPOINT)
2819     {
2820       if (debug_linux_nat)
2821         fprintf_unfiltered (gdb_stdlog,
2822                             "CSBB: %s stopped by software breakpoint\n",
2823                             target_pid_to_str (lp->ptid));
2824
2825       /* Back up the PC if necessary.  */
2826       if (pc != sw_bp_pc)
2827         regcache_write_pc (regcache, sw_bp_pc);
2828
2829       /* Update this so we record the correct stop PC below.  */
2830       pc = sw_bp_pc;
2831     }
2832   else if (lp->stop_reason == TARGET_STOPPED_BY_HW_BREAKPOINT)
2833     {
2834       if (debug_linux_nat)
2835         fprintf_unfiltered (gdb_stdlog,
2836                             "CSBB: %s stopped by hardware breakpoint\n",
2837                             target_pid_to_str (lp->ptid));
2838     }
2839   else if (lp->stop_reason == TARGET_STOPPED_BY_WATCHPOINT)
2840     {
2841       if (debug_linux_nat)
2842         fprintf_unfiltered (gdb_stdlog,
2843                             "CSBB: %s stopped by hardware watchpoint\n",
2844                             target_pid_to_str (lp->ptid));
2845     }
2846
2847   lp->stop_pc = pc;
2848 }
2849
2850
2851 /* Returns true if the LWP had stopped for a software breakpoint.  */
2852
2853 static int
2854 linux_nat_stopped_by_sw_breakpoint (struct target_ops *ops)
2855 {
2856   struct lwp_info *lp = find_lwp_pid (inferior_ptid);
2857
2858   gdb_assert (lp != NULL);
2859
2860   return lp->stop_reason == TARGET_STOPPED_BY_SW_BREAKPOINT;
2861 }
2862
2863 /* Implement the supports_stopped_by_sw_breakpoint method.  */
2864
2865 static int
2866 linux_nat_supports_stopped_by_sw_breakpoint (struct target_ops *ops)
2867 {
2868   return USE_SIGTRAP_SIGINFO;
2869 }
2870
2871 /* Returns true if the LWP had stopped for a hardware
2872    breakpoint/watchpoint.  */
2873
2874 static int
2875 linux_nat_stopped_by_hw_breakpoint (struct target_ops *ops)
2876 {
2877   struct lwp_info *lp = find_lwp_pid (inferior_ptid);
2878
2879   gdb_assert (lp != NULL);
2880
2881   return lp->stop_reason == TARGET_STOPPED_BY_HW_BREAKPOINT;
2882 }
2883
2884 /* Implement the supports_stopped_by_hw_breakpoint method.  */
2885
2886 static int
2887 linux_nat_supports_stopped_by_hw_breakpoint (struct target_ops *ops)
2888 {
2889   return USE_SIGTRAP_SIGINFO;
2890 }
2891
2892 /* Select one LWP out of those that have events pending.  */
2893
2894 static void
2895 select_event_lwp (ptid_t filter, struct lwp_info **orig_lp, int *status)
2896 {
2897   int num_events = 0;
2898   int random_selector;
2899   struct lwp_info *event_lp = NULL;
2900
2901   /* Record the wait status for the original LWP.  */
2902   (*orig_lp)->status = *status;
2903
2904   /* In all-stop, give preference to the LWP that is being
2905      single-stepped.  There will be at most one, and it will be the
2906      LWP that the core is most interested in.  If we didn't do this,
2907      then we'd have to handle pending step SIGTRAPs somehow in case
2908      the core later continues the previously-stepped thread, as
2909      otherwise we'd report the pending SIGTRAP then, and the core, not
2910      having stepped the thread, wouldn't understand what the trap was
2911      for, and therefore would report it to the user as a random
2912      signal.  */
2913   if (!target_is_non_stop_p ())
2914     {
2915       event_lp = iterate_over_lwps (filter,
2916                                     select_singlestep_lwp_callback, NULL);
2917       if (event_lp != NULL)
2918         {
2919           if (debug_linux_nat)
2920             fprintf_unfiltered (gdb_stdlog,
2921                                 "SEL: Select single-step %s\n",
2922                                 target_pid_to_str (event_lp->ptid));
2923         }
2924     }
2925
2926   if (event_lp == NULL)
2927     {
2928       /* Pick one at random, out of those which have had events.  */
2929
2930       /* First see how many events we have.  */
2931       iterate_over_lwps (filter, count_events_callback, &num_events);
2932       gdb_assert (num_events > 0);
2933
2934       /* Now randomly pick a LWP out of those that have had
2935          events.  */
2936       random_selector = (int)
2937         ((num_events * (double) rand ()) / (RAND_MAX + 1.0));
2938
2939       if (debug_linux_nat && num_events > 1)
2940         fprintf_unfiltered (gdb_stdlog,
2941                             "SEL: Found %d events, selecting #%d\n",
2942                             num_events, random_selector);
2943
2944       event_lp = iterate_over_lwps (filter,
2945                                     select_event_lwp_callback,
2946                                     &random_selector);
2947     }
2948
2949   if (event_lp != NULL)
2950     {
2951       /* Switch the event LWP.  */
2952       *orig_lp = event_lp;
2953       *status = event_lp->status;
2954     }
2955
2956   /* Flush the wait status for the event LWP.  */
2957   (*orig_lp)->status = 0;
2958 }
2959
2960 /* Return non-zero if LP has been resumed.  */
2961
2962 static int
2963 resumed_callback (struct lwp_info *lp, void *data)
2964 {
2965   return lp->resumed;
2966 }
2967
2968 /* Check if we should go on and pass this event to common code.
2969    Return the affected lwp if we are, or NULL otherwise.  */
2970
2971 static struct lwp_info *
2972 linux_nat_filter_event (int lwpid, int status)
2973 {
2974   struct lwp_info *lp;
2975   int event = linux_ptrace_get_extended_event (status);
2976
2977   lp = find_lwp_pid (pid_to_ptid (lwpid));
2978
2979   /* Check for stop events reported by a process we didn't already
2980      know about - anything not already in our LWP list.
2981
2982      If we're expecting to receive stopped processes after
2983      fork, vfork, and clone events, then we'll just add the
2984      new one to our list and go back to waiting for the event
2985      to be reported - the stopped process might be returned
2986      from waitpid before or after the event is.
2987
2988      But note the case of a non-leader thread exec'ing after the
2989      leader having exited, and gone from our lists.  The non-leader
2990      thread changes its tid to the tgid.  */
2991
2992   if (WIFSTOPPED (status) && lp == NULL
2993       && (WSTOPSIG (status) == SIGTRAP && event == PTRACE_EVENT_EXEC))
2994     {
2995       /* A multi-thread exec after we had seen the leader exiting.  */
2996       if (debug_linux_nat)
2997         fprintf_unfiltered (gdb_stdlog,
2998                             "LLW: Re-adding thread group leader LWP %d.\n",
2999                             lwpid);
3000
3001       lp = add_lwp (ptid_build (lwpid, lwpid, 0));
3002       lp->stopped = 1;
3003       lp->resumed = 1;
3004       add_thread (lp->ptid);
3005     }
3006
3007   if (WIFSTOPPED (status) && !lp)
3008     {
3009       if (debug_linux_nat)
3010         fprintf_unfiltered (gdb_stdlog,
3011                             "LHEW: saving LWP %ld status %s in stopped_pids list\n",
3012                             (long) lwpid, status_to_str (status));
3013       add_to_pid_list (&stopped_pids, lwpid, status);
3014       return NULL;
3015     }
3016
3017   /* Make sure we don't report an event for the exit of an LWP not in
3018      our list, i.e. not part of the current process.  This can happen
3019      if we detach from a program we originally forked and then it
3020      exits.  */
3021   if (!WIFSTOPPED (status) && !lp)
3022     return NULL;
3023
3024   /* This LWP is stopped now.  (And if dead, this prevents it from
3025      ever being continued.)  */
3026   lp->stopped = 1;
3027
3028   if (WIFSTOPPED (status) && lp->must_set_ptrace_flags)
3029     {
3030       struct inferior *inf = find_inferior_pid (ptid_get_pid (lp->ptid));
3031       int options = linux_nat_ptrace_options (inf->attach_flag);
3032
3033       linux_enable_event_reporting (ptid_get_lwp (lp->ptid), options);
3034       lp->must_set_ptrace_flags = 0;
3035     }
3036
3037   /* Handle GNU/Linux's syscall SIGTRAPs.  */
3038   if (WIFSTOPPED (status) && WSTOPSIG (status) == SYSCALL_SIGTRAP)
3039     {
3040       /* No longer need the sysgood bit.  The ptrace event ends up
3041          recorded in lp->waitstatus if we care for it.  We can carry
3042          on handling the event like a regular SIGTRAP from here
3043          on.  */
3044       status = W_STOPCODE (SIGTRAP);
3045       if (linux_handle_syscall_trap (lp, 0))
3046         return NULL;
3047     }
3048   else
3049     {
3050       /* Almost all other ptrace-stops are known to be outside of system
3051          calls, with further exceptions in linux_handle_extended_wait.  */
3052       lp->syscall_state = TARGET_WAITKIND_IGNORE;
3053     }
3054
3055   /* Handle GNU/Linux's extended waitstatus for trace events.  */
3056   if (WIFSTOPPED (status) && WSTOPSIG (status) == SIGTRAP
3057       && linux_is_extended_waitstatus (status))
3058     {
3059       if (debug_linux_nat)
3060         fprintf_unfiltered (gdb_stdlog,
3061                             "LLW: Handling extended status 0x%06x\n",
3062                             status);
3063       if (linux_handle_extended_wait (lp, status))
3064         return NULL;
3065     }
3066
3067   /* Check if the thread has exited.  */
3068   if (WIFEXITED (status) || WIFSIGNALED (status))
3069     {
3070       if (!report_thread_events
3071           && num_lwps (ptid_get_pid (lp->ptid)) > 1)
3072         {
3073           if (debug_linux_nat)
3074             fprintf_unfiltered (gdb_stdlog,
3075                                 "LLW: %s exited.\n",
3076                                 target_pid_to_str (lp->ptid));
3077
3078           /* If there is at least one more LWP, then the exit signal
3079              was not the end of the debugged application and should be
3080              ignored.  */
3081           exit_lwp (lp);
3082           return NULL;
3083         }
3084
3085       /* Note that even if the leader was ptrace-stopped, it can still
3086          exit, if e.g., some other thread brings down the whole
3087          process (calls `exit').  So don't assert that the lwp is
3088          resumed.  */
3089       if (debug_linux_nat)
3090         fprintf_unfiltered (gdb_stdlog,
3091                             "LWP %ld exited (resumed=%d)\n",
3092                             ptid_get_lwp (lp->ptid), lp->resumed);
3093
3094       /* Dead LWP's aren't expected to reported a pending sigstop.  */
3095       lp->signalled = 0;
3096
3097       /* Store the pending event in the waitstatus, because
3098          W_EXITCODE(0,0) == 0.  */
3099       store_waitstatus (&lp->waitstatus, status);
3100       return lp;
3101     }
3102
3103   /* Make sure we don't report a SIGSTOP that we sent ourselves in
3104      an attempt to stop an LWP.  */
3105   if (lp->signalled
3106       && WIFSTOPPED (status) && WSTOPSIG (status) == SIGSTOP)
3107     {
3108       lp->signalled = 0;
3109
3110       if (lp->last_resume_kind == resume_stop)
3111         {
3112           if (debug_linux_nat)
3113             fprintf_unfiltered (gdb_stdlog,
3114                                 "LLW: resume_stop SIGSTOP caught for %s.\n",
3115                                 target_pid_to_str (lp->ptid));
3116         }
3117       else
3118         {
3119           /* This is a delayed SIGSTOP.  Filter out the event.  */
3120
3121           if (debug_linux_nat)
3122             fprintf_unfiltered (gdb_stdlog,
3123                                 "LLW: %s %s, 0, 0 (discard delayed SIGSTOP)\n",
3124                                 lp->step ?
3125                                 "PTRACE_SINGLESTEP" : "PTRACE_CONT",
3126                                 target_pid_to_str (lp->ptid));
3127
3128           linux_resume_one_lwp (lp, lp->step, GDB_SIGNAL_0);
3129           gdb_assert (lp->resumed);
3130           return NULL;
3131         }
3132     }
3133
3134   /* Make sure we don't report a SIGINT that we have already displayed
3135      for another thread.  */
3136   if (lp->ignore_sigint
3137       && WIFSTOPPED (status) && WSTOPSIG (status) == SIGINT)
3138     {
3139       if (debug_linux_nat)
3140         fprintf_unfiltered (gdb_stdlog,
3141                             "LLW: Delayed SIGINT caught for %s.\n",
3142                             target_pid_to_str (lp->ptid));
3143
3144       /* This is a delayed SIGINT.  */
3145       lp->ignore_sigint = 0;
3146
3147       linux_resume_one_lwp (lp, lp->step, GDB_SIGNAL_0);
3148       if (debug_linux_nat)
3149         fprintf_unfiltered (gdb_stdlog,
3150                             "LLW: %s %s, 0, 0 (discard SIGINT)\n",
3151                             lp->step ?
3152                             "PTRACE_SINGLESTEP" : "PTRACE_CONT",
3153                             target_pid_to_str (lp->ptid));
3154       gdb_assert (lp->resumed);
3155
3156       /* Discard the event.  */
3157       return NULL;
3158     }
3159
3160   /* Don't report signals that GDB isn't interested in, such as
3161      signals that are neither printed nor stopped upon.  Stopping all
3162      threads can be a bit time-consuming so if we want decent
3163      performance with heavily multi-threaded programs, especially when
3164      they're using a high frequency timer, we'd better avoid it if we
3165      can.  */
3166   if (WIFSTOPPED (status))
3167     {
3168       enum gdb_signal signo = gdb_signal_from_host (WSTOPSIG (status));
3169
3170       if (!target_is_non_stop_p ())
3171         {
3172           /* Only do the below in all-stop, as we currently use SIGSTOP
3173              to implement target_stop (see linux_nat_stop) in
3174              non-stop.  */
3175           if (signo == GDB_SIGNAL_INT && signal_pass_state (signo) == 0)
3176             {
3177               /* If ^C/BREAK is typed at the tty/console, SIGINT gets
3178                  forwarded to the entire process group, that is, all LWPs
3179                  will receive it - unless they're using CLONE_THREAD to
3180                  share signals.  Since we only want to report it once, we
3181                  mark it as ignored for all LWPs except this one.  */
3182               iterate_over_lwps (pid_to_ptid (ptid_get_pid (lp->ptid)),
3183                                               set_ignore_sigint, NULL);
3184               lp->ignore_sigint = 0;
3185             }
3186           else
3187             maybe_clear_ignore_sigint (lp);
3188         }
3189
3190       /* When using hardware single-step, we need to report every signal.
3191          Otherwise, signals in pass_mask may be short-circuited
3192          except signals that might be caused by a breakpoint.  */
3193       if (!lp->step
3194           && WSTOPSIG (status) && sigismember (&pass_mask, WSTOPSIG (status))
3195           && !linux_wstatus_maybe_breakpoint (status))
3196         {
3197           linux_resume_one_lwp (lp, lp->step, signo);
3198           if (debug_linux_nat)
3199             fprintf_unfiltered (gdb_stdlog,
3200                                 "LLW: %s %s, %s (preempt 'handle')\n",
3201                                 lp->step ?
3202                                 "PTRACE_SINGLESTEP" : "PTRACE_CONT",
3203                                 target_pid_to_str (lp->ptid),
3204                                 (signo != GDB_SIGNAL_0
3205                                  ? strsignal (gdb_signal_to_host (signo))
3206                                  : "0"));
3207           return NULL;
3208         }
3209     }
3210
3211   /* An interesting event.  */
3212   gdb_assert (lp);
3213   lp->status = status;
3214   save_stop_reason (lp);
3215   return lp;
3216 }
3217
3218 /* Detect zombie thread group leaders, and "exit" them.  We can't reap
3219    their exits until all other threads in the group have exited.  */
3220
3221 static void
3222 check_zombie_leaders (void)
3223 {
3224   struct inferior *inf;
3225
3226   ALL_INFERIORS (inf)
3227     {
3228       struct lwp_info *leader_lp;
3229
3230       if (inf->pid == 0)
3231         continue;
3232
3233       leader_lp = find_lwp_pid (pid_to_ptid (inf->pid));
3234       if (leader_lp != NULL
3235           /* Check if there are other threads in the group, as we may
3236              have raced with the inferior simply exiting.  */
3237           && num_lwps (inf->pid) > 1
3238           && linux_proc_pid_is_zombie (inf->pid))
3239         {
3240           if (debug_linux_nat)
3241             fprintf_unfiltered (gdb_stdlog,
3242                                 "CZL: Thread group leader %d zombie "
3243                                 "(it exited, or another thread execd).\n",
3244                                 inf->pid);
3245
3246           /* A leader zombie can mean one of two things:
3247
3248              - It exited, and there's an exit status pending
3249              available, or only the leader exited (not the whole
3250              program).  In the latter case, we can't waitpid the
3251              leader's exit status until all other threads are gone.
3252
3253              - There are 3 or more threads in the group, and a thread
3254              other than the leader exec'd.  See comments on exec
3255              events at the top of the file.  We could try
3256              distinguishing the exit and exec cases, by waiting once
3257              more, and seeing if something comes out, but it doesn't
3258              sound useful.  The previous leader _does_ go away, and
3259              we'll re-add the new one once we see the exec event
3260              (which is just the same as what would happen if the
3261              previous leader did exit voluntarily before some other
3262              thread execs).  */
3263
3264           if (debug_linux_nat)
3265             fprintf_unfiltered (gdb_stdlog,
3266                                 "CZL: Thread group leader %d vanished.\n",
3267                                 inf->pid);
3268           exit_lwp (leader_lp);
3269         }
3270     }
3271 }
3272
3273 /* Convenience function that is called when the kernel reports an exit
3274    event.  This decides whether to report the event to GDB as a
3275    process exit event, a thread exit event, or to suppress the
3276    event.  */
3277
3278 static ptid_t
3279 filter_exit_event (struct lwp_info *event_child,
3280                    struct target_waitstatus *ourstatus)
3281 {
3282   ptid_t ptid = event_child->ptid;
3283
3284   if (num_lwps (ptid_get_pid (ptid)) > 1)
3285     {
3286       if (report_thread_events)
3287         ourstatus->kind = TARGET_WAITKIND_THREAD_EXITED;
3288       else
3289         ourstatus->kind = TARGET_WAITKIND_IGNORE;
3290
3291       exit_lwp (event_child);
3292     }
3293
3294   return ptid;
3295 }
3296
3297 static ptid_t
3298 linux_nat_wait_1 (struct target_ops *ops,
3299                   ptid_t ptid, struct target_waitstatus *ourstatus,
3300                   int target_options)
3301 {
3302   sigset_t prev_mask;
3303   enum resume_kind last_resume_kind;
3304   struct lwp_info *lp;
3305   int status;
3306
3307   if (debug_linux_nat)
3308     fprintf_unfiltered (gdb_stdlog, "LLW: enter\n");
3309
3310   /* The first time we get here after starting a new inferior, we may
3311      not have added it to the LWP list yet - this is the earliest
3312      moment at which we know its PID.  */
3313   if (ptid_is_pid (inferior_ptid))
3314     {
3315       /* Upgrade the main thread's ptid.  */
3316       thread_change_ptid (inferior_ptid,
3317                           ptid_build (ptid_get_pid (inferior_ptid),
3318                                       ptid_get_pid (inferior_ptid), 0));
3319
3320       lp = add_initial_lwp (inferior_ptid);
3321       lp->resumed = 1;
3322     }
3323
3324   /* Make sure SIGCHLD is blocked until the sigsuspend below.  */
3325   block_child_signals (&prev_mask);
3326
3327   /* First check if there is a LWP with a wait status pending.  */
3328   lp = iterate_over_lwps (ptid, status_callback, NULL);
3329   if (lp != NULL)
3330     {
3331       if (debug_linux_nat)
3332         fprintf_unfiltered (gdb_stdlog,
3333                             "LLW: Using pending wait status %s for %s.\n",
3334                             status_to_str (lp->status),
3335                             target_pid_to_str (lp->ptid));
3336     }
3337
3338   /* But if we don't find a pending event, we'll have to wait.  Always
3339      pull all events out of the kernel.  We'll randomly select an
3340      event LWP out of all that have events, to prevent starvation.  */
3341
3342   while (lp == NULL)
3343     {
3344       pid_t lwpid;
3345
3346       /* Always use -1 and WNOHANG, due to couple of a kernel/ptrace
3347          quirks:
3348
3349          - If the thread group leader exits while other threads in the
3350            thread group still exist, waitpid(TGID, ...) hangs.  That
3351            waitpid won't return an exit status until the other threads
3352            in the group are reapped.
3353
3354          - When a non-leader thread execs, that thread just vanishes
3355            without reporting an exit (so we'd hang if we waited for it
3356            explicitly in that case).  The exec event is reported to
3357            the TGID pid.  */
3358
3359       errno = 0;
3360       lwpid = my_waitpid (-1, &status,  __WALL | WNOHANG);
3361
3362       if (debug_linux_nat)
3363         fprintf_unfiltered (gdb_stdlog,
3364                             "LNW: waitpid(-1, ...) returned %d, %s\n",
3365                             lwpid, errno ? safe_strerror (errno) : "ERRNO-OK");
3366
3367       if (lwpid > 0)
3368         {
3369           if (debug_linux_nat)
3370             {
3371               fprintf_unfiltered (gdb_stdlog,
3372                                   "LLW: waitpid %ld received %s\n",
3373                                   (long) lwpid, status_to_str (status));
3374             }
3375
3376           linux_nat_filter_event (lwpid, status);
3377           /* Retry until nothing comes out of waitpid.  A single
3378              SIGCHLD can indicate more than one child stopped.  */
3379           continue;
3380         }
3381
3382       /* Now that we've pulled all events out of the kernel, resume
3383          LWPs that don't have an interesting event to report.  */
3384       iterate_over_lwps (minus_one_ptid,
3385                          resume_stopped_resumed_lwps, &minus_one_ptid);
3386
3387       /* ... and find an LWP with a status to report to the core, if
3388          any.  */
3389       lp = iterate_over_lwps (ptid, status_callback, NULL);
3390       if (lp != NULL)
3391         break;
3392
3393       /* Check for zombie thread group leaders.  Those can't be reaped
3394          until all other threads in the thread group are.  */
3395       check_zombie_leaders ();
3396
3397       /* If there are no resumed children left, bail.  We'd be stuck
3398          forever in the sigsuspend call below otherwise.  */
3399       if (iterate_over_lwps (ptid, resumed_callback, NULL) == NULL)
3400         {
3401           if (debug_linux_nat)
3402             fprintf_unfiltered (gdb_stdlog, "LLW: exit (no resumed LWP)\n");
3403
3404           ourstatus->kind = TARGET_WAITKIND_NO_RESUMED;
3405
3406           restore_child_signals_mask (&prev_mask);
3407           return minus_one_ptid;
3408         }
3409
3410       /* No interesting event to report to the core.  */
3411
3412       if (target_options & TARGET_WNOHANG)
3413         {
3414           if (debug_linux_nat)
3415             fprintf_unfiltered (gdb_stdlog, "LLW: exit (ignore)\n");
3416
3417           ourstatus->kind = TARGET_WAITKIND_IGNORE;
3418           restore_child_signals_mask (&prev_mask);
3419           return minus_one_ptid;
3420         }
3421
3422       /* We shouldn't end up here unless we want to try again.  */
3423       gdb_assert (lp == NULL);
3424
3425       /* Block until we get an event reported with SIGCHLD.  */
3426       if (debug_linux_nat)
3427         fprintf_unfiltered (gdb_stdlog, "LNW: about to sigsuspend\n");
3428       sigsuspend (&suspend_mask);
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 static int async_terminal_is_ours = 1;
4452
4453 /* target_terminal_inferior implementation.
4454
4455    This is a wrapper around child_terminal_inferior to add async support.  */
4456
4457 static void
4458 linux_nat_terminal_inferior (struct target_ops *self)
4459 {
4460   child_terminal_inferior (self);
4461
4462   /* Calls to target_terminal_*() are meant to be idempotent.  */
4463   if (!async_terminal_is_ours)
4464     return;
4465
4466   async_terminal_is_ours = 0;
4467   set_sigint_trap ();
4468 }
4469
4470 /* target_terminal::ours implementation.
4471
4472    This is a wrapper around child_terminal_ours to add async support (and
4473    implement the target_terminal::ours vs target_terminal::ours_for_output
4474    distinction).  child_terminal_ours is currently no different than
4475    child_terminal_ours_for_output.
4476    We leave target_terminal::ours_for_output alone, leaving it to
4477    child_terminal_ours_for_output.  */
4478
4479 static void
4480 linux_nat_terminal_ours (struct target_ops *self)
4481 {
4482   /* GDB should never give the terminal to the inferior if the
4483      inferior is running in the background (run&, continue&, etc.),
4484      but claiming it sure should.  */
4485   child_terminal_ours (self);
4486
4487   if (async_terminal_is_ours)
4488     return;
4489
4490   clear_sigint_trap ();
4491   async_terminal_is_ours = 1;
4492 }
4493
4494 /* SIGCHLD handler that serves two purposes: In non-stop/async mode,
4495    so we notice when any child changes state, and notify the
4496    event-loop; it allows us to use sigsuspend in linux_nat_wait_1
4497    above to wait for the arrival of a SIGCHLD.  */
4498
4499 static void
4500 sigchld_handler (int signo)
4501 {
4502   int old_errno = errno;
4503
4504   if (debug_linux_nat)
4505     ui_file_write_async_safe (gdb_stdlog,
4506                               "sigchld\n", sizeof ("sigchld\n") - 1);
4507
4508   if (signo == SIGCHLD
4509       && linux_nat_event_pipe[0] != -1)
4510     async_file_mark (); /* Let the event loop know that there are
4511                            events to handle.  */
4512
4513   errno = old_errno;
4514 }
4515
4516 /* Callback registered with the target events file descriptor.  */
4517
4518 static void
4519 handle_target_event (int error, gdb_client_data client_data)
4520 {
4521   inferior_event_handler (INF_REG_EVENT, NULL);
4522 }
4523
4524 /* Create/destroy the target events pipe.  Returns previous state.  */
4525
4526 static int
4527 linux_async_pipe (int enable)
4528 {
4529   int previous = linux_is_async_p ();
4530
4531   if (previous != enable)
4532     {
4533       sigset_t prev_mask;
4534
4535       /* Block child signals while we create/destroy the pipe, as
4536          their handler writes to it.  */
4537       block_child_signals (&prev_mask);
4538
4539       if (enable)
4540         {
4541           if (gdb_pipe_cloexec (linux_nat_event_pipe) == -1)
4542             internal_error (__FILE__, __LINE__,
4543                             "creating event pipe failed.");
4544
4545           fcntl (linux_nat_event_pipe[0], F_SETFL, O_NONBLOCK);
4546           fcntl (linux_nat_event_pipe[1], F_SETFL, O_NONBLOCK);
4547         }
4548       else
4549         {
4550           close (linux_nat_event_pipe[0]);
4551           close (linux_nat_event_pipe[1]);
4552           linux_nat_event_pipe[0] = -1;
4553           linux_nat_event_pipe[1] = -1;
4554         }
4555
4556       restore_child_signals_mask (&prev_mask);
4557     }
4558
4559   return previous;
4560 }
4561
4562 /* target_async implementation.  */
4563
4564 static void
4565 linux_nat_async (struct target_ops *ops, int enable)
4566 {
4567   if (enable)
4568     {
4569       if (!linux_async_pipe (1))
4570         {
4571           add_file_handler (linux_nat_event_pipe[0],
4572                             handle_target_event, NULL);
4573           /* There may be pending events to handle.  Tell the event loop
4574              to poll them.  */
4575           async_file_mark ();
4576         }
4577     }
4578   else
4579     {
4580       delete_file_handler (linux_nat_event_pipe[0]);
4581       linux_async_pipe (0);
4582     }
4583   return;
4584 }
4585
4586 /* Stop an LWP, and push a GDB_SIGNAL_0 stop status if no other
4587    event came out.  */
4588
4589 static int
4590 linux_nat_stop_lwp (struct lwp_info *lwp, void *data)
4591 {
4592   if (!lwp->stopped)
4593     {
4594       if (debug_linux_nat)
4595         fprintf_unfiltered (gdb_stdlog,
4596                             "LNSL: running -> suspending %s\n",
4597                             target_pid_to_str (lwp->ptid));
4598
4599
4600       if (lwp->last_resume_kind == resume_stop)
4601         {
4602           if (debug_linux_nat)
4603             fprintf_unfiltered (gdb_stdlog,
4604                                 "linux-nat: already stopping LWP %ld at "
4605                                 "GDB's request\n",
4606                                 ptid_get_lwp (lwp->ptid));
4607           return 0;
4608         }
4609
4610       stop_callback (lwp, NULL);
4611       lwp->last_resume_kind = resume_stop;
4612     }
4613   else
4614     {
4615       /* Already known to be stopped; do nothing.  */
4616
4617       if (debug_linux_nat)
4618         {
4619           if (find_thread_ptid (lwp->ptid)->stop_requested)
4620             fprintf_unfiltered (gdb_stdlog,
4621                                 "LNSL: already stopped/stop_requested %s\n",
4622                                 target_pid_to_str (lwp->ptid));
4623           else
4624             fprintf_unfiltered (gdb_stdlog,
4625                                 "LNSL: already stopped/no "
4626                                 "stop_requested yet %s\n",
4627                                 target_pid_to_str (lwp->ptid));
4628         }
4629     }
4630   return 0;
4631 }
4632
4633 static void
4634 linux_nat_stop (struct target_ops *self, ptid_t ptid)
4635 {
4636   iterate_over_lwps (ptid, linux_nat_stop_lwp, NULL);
4637 }
4638
4639 static void
4640 linux_nat_close (struct target_ops *self)
4641 {
4642   /* Unregister from the event loop.  */
4643   if (linux_nat_is_async_p (self))
4644     linux_nat_async (self, 0);
4645
4646   if (linux_ops->to_close)
4647     linux_ops->to_close (linux_ops);
4648
4649   super_close (self);
4650 }
4651
4652 /* When requests are passed down from the linux-nat layer to the
4653    single threaded inf-ptrace layer, ptids of (lwpid,0,0) form are
4654    used.  The address space pointer is stored in the inferior object,
4655    but the common code that is passed such ptid can't tell whether
4656    lwpid is a "main" process id or not (it assumes so).  We reverse
4657    look up the "main" process id from the lwp here.  */
4658
4659 static struct address_space *
4660 linux_nat_thread_address_space (struct target_ops *t, ptid_t ptid)
4661 {
4662   struct lwp_info *lwp;
4663   struct inferior *inf;
4664   int pid;
4665
4666   if (ptid_get_lwp (ptid) == 0)
4667     {
4668       /* An (lwpid,0,0) ptid.  Look up the lwp object to get at the
4669          tgid.  */
4670       lwp = find_lwp_pid (ptid);
4671       pid = ptid_get_pid (lwp->ptid);
4672     }
4673   else
4674     {
4675       /* A (pid,lwpid,0) ptid.  */
4676       pid = ptid_get_pid (ptid);
4677     }
4678
4679   inf = find_inferior_pid (pid);
4680   gdb_assert (inf != NULL);
4681   return inf->aspace;
4682 }
4683
4684 /* Return the cached value of the processor core for thread PTID.  */
4685
4686 static int
4687 linux_nat_core_of_thread (struct target_ops *ops, ptid_t ptid)
4688 {
4689   struct lwp_info *info = find_lwp_pid (ptid);
4690
4691   if (info)
4692     return info->core;
4693   return -1;
4694 }
4695
4696 /* Implementation of to_filesystem_is_local.  */
4697
4698 static int
4699 linux_nat_filesystem_is_local (struct target_ops *ops)
4700 {
4701   struct inferior *inf = current_inferior ();
4702
4703   if (inf->fake_pid_p || inf->pid == 0)
4704     return 1;
4705
4706   return linux_ns_same (inf->pid, LINUX_NS_MNT);
4707 }
4708
4709 /* Convert the INF argument passed to a to_fileio_* method
4710    to a process ID suitable for passing to its corresponding
4711    linux_mntns_* function.  If INF is non-NULL then the
4712    caller is requesting the filesystem seen by INF.  If INF
4713    is NULL then the caller is requesting the filesystem seen
4714    by the GDB.  We fall back to GDB's filesystem in the case
4715    that INF is non-NULL but its PID is unknown.  */
4716
4717 static pid_t
4718 linux_nat_fileio_pid_of (struct inferior *inf)
4719 {
4720   if (inf == NULL || inf->fake_pid_p || inf->pid == 0)
4721     return getpid ();
4722   else
4723     return inf->pid;
4724 }
4725
4726 /* Implementation of to_fileio_open.  */
4727
4728 static int
4729 linux_nat_fileio_open (struct target_ops *self,
4730                        struct inferior *inf, const char *filename,
4731                        int flags, int mode, int warn_if_slow,
4732                        int *target_errno)
4733 {
4734   int nat_flags;
4735   mode_t nat_mode;
4736   int fd;
4737
4738   if (fileio_to_host_openflags (flags, &nat_flags) == -1
4739       || fileio_to_host_mode (mode, &nat_mode) == -1)
4740     {
4741       *target_errno = FILEIO_EINVAL;
4742       return -1;
4743     }
4744
4745   fd = linux_mntns_open_cloexec (linux_nat_fileio_pid_of (inf),
4746                                  filename, nat_flags, nat_mode);
4747   if (fd == -1)
4748     *target_errno = host_to_fileio_error (errno);
4749
4750   return fd;
4751 }
4752
4753 /* Implementation of to_fileio_readlink.  */
4754
4755 static char *
4756 linux_nat_fileio_readlink (struct target_ops *self,
4757                            struct inferior *inf, const char *filename,
4758                            int *target_errno)
4759 {
4760   char buf[PATH_MAX];
4761   int len;
4762   char *ret;
4763
4764   len = linux_mntns_readlink (linux_nat_fileio_pid_of (inf),
4765                               filename, buf, sizeof (buf));
4766   if (len < 0)
4767     {
4768       *target_errno = host_to_fileio_error (errno);
4769       return NULL;
4770     }
4771
4772   ret = (char *) xmalloc (len + 1);
4773   memcpy (ret, buf, len);
4774   ret[len] = '\0';
4775   return ret;
4776 }
4777
4778 /* Implementation of to_fileio_unlink.  */
4779
4780 static int
4781 linux_nat_fileio_unlink (struct target_ops *self,
4782                          struct inferior *inf, const char *filename,
4783                          int *target_errno)
4784 {
4785   int ret;
4786
4787   ret = linux_mntns_unlink (linux_nat_fileio_pid_of (inf),
4788                             filename);
4789   if (ret == -1)
4790     *target_errno = host_to_fileio_error (errno);
4791
4792   return ret;
4793 }
4794
4795 /* Implementation of the to_thread_events method.  */
4796
4797 static void
4798 linux_nat_thread_events (struct target_ops *ops, int enable)
4799 {
4800   report_thread_events = enable;
4801 }
4802
4803 void
4804 linux_nat_add_target (struct target_ops *t)
4805 {
4806   /* Save the provided single-threaded target.  We save this in a separate
4807      variable because another target we've inherited from (e.g. inf-ptrace)
4808      may have saved a pointer to T; we want to use it for the final
4809      process stratum target.  */
4810   linux_ops_saved = *t;
4811   linux_ops = &linux_ops_saved;
4812
4813   /* Override some methods for multithreading.  */
4814   t->to_create_inferior = linux_nat_create_inferior;
4815   t->to_attach = linux_nat_attach;
4816   t->to_detach = linux_nat_detach;
4817   t->to_resume = linux_nat_resume;
4818   t->to_wait = linux_nat_wait;
4819   t->to_pass_signals = linux_nat_pass_signals;
4820   t->to_xfer_partial = linux_nat_xfer_partial;
4821   t->to_kill = linux_nat_kill;
4822   t->to_mourn_inferior = linux_nat_mourn_inferior;
4823   t->to_thread_alive = linux_nat_thread_alive;
4824   t->to_update_thread_list = linux_nat_update_thread_list;
4825   t->to_pid_to_str = linux_nat_pid_to_str;
4826   t->to_thread_name = linux_nat_thread_name;
4827   t->to_has_thread_control = tc_schedlock;
4828   t->to_thread_address_space = linux_nat_thread_address_space;
4829   t->to_stopped_by_watchpoint = linux_nat_stopped_by_watchpoint;
4830   t->to_stopped_data_address = linux_nat_stopped_data_address;
4831   t->to_stopped_by_sw_breakpoint = linux_nat_stopped_by_sw_breakpoint;
4832   t->to_supports_stopped_by_sw_breakpoint = linux_nat_supports_stopped_by_sw_breakpoint;
4833   t->to_stopped_by_hw_breakpoint = linux_nat_stopped_by_hw_breakpoint;
4834   t->to_supports_stopped_by_hw_breakpoint = linux_nat_supports_stopped_by_hw_breakpoint;
4835   t->to_thread_events = linux_nat_thread_events;
4836
4837   t->to_can_async_p = linux_nat_can_async_p;
4838   t->to_is_async_p = linux_nat_is_async_p;
4839   t->to_supports_non_stop = linux_nat_supports_non_stop;
4840   t->to_always_non_stop_p = linux_nat_always_non_stop_p;
4841   t->to_async = linux_nat_async;
4842   t->to_terminal_inferior = linux_nat_terminal_inferior;
4843   t->to_terminal_ours = linux_nat_terminal_ours;
4844
4845   super_close = t->to_close;
4846   t->to_close = linux_nat_close;
4847
4848   t->to_stop = linux_nat_stop;
4849
4850   t->to_supports_multi_process = linux_nat_supports_multi_process;
4851
4852   t->to_supports_disable_randomization
4853     = linux_nat_supports_disable_randomization;
4854
4855   t->to_core_of_thread = linux_nat_core_of_thread;
4856
4857   t->to_filesystem_is_local = linux_nat_filesystem_is_local;
4858   t->to_fileio_open = linux_nat_fileio_open;
4859   t->to_fileio_readlink = linux_nat_fileio_readlink;
4860   t->to_fileio_unlink = linux_nat_fileio_unlink;
4861
4862   /* We don't change the stratum; this target will sit at
4863      process_stratum and thread_db will set at thread_stratum.  This
4864      is a little strange, since this is a multi-threaded-capable
4865      target, but we want to be on the stack below thread_db, and we
4866      also want to be used for single-threaded processes.  */
4867
4868   add_target (t);
4869 }
4870
4871 /* Register a method to call whenever a new thread is attached.  */
4872 void
4873 linux_nat_set_new_thread (struct target_ops *t,
4874                           void (*new_thread) (struct lwp_info *))
4875 {
4876   /* Save the pointer.  We only support a single registered instance
4877      of the GNU/Linux native target, so we do not need to map this to
4878      T.  */
4879   linux_nat_new_thread = new_thread;
4880 }
4881
4882 /* Register a method to call whenever a new thread is attached.  */
4883 void
4884 linux_nat_set_delete_thread (struct target_ops *t,
4885                              void (*delete_thread) (struct arch_lwp_info *))
4886 {
4887   /* Save the pointer.  We only support a single registered instance
4888      of the GNU/Linux native target, so we do not need to map this to
4889      T.  */
4890   linux_nat_delete_thread = delete_thread;
4891 }
4892
4893 /* See declaration in linux-nat.h.  */
4894
4895 void
4896 linux_nat_set_new_fork (struct target_ops *t,
4897                         linux_nat_new_fork_ftype *new_fork)
4898 {
4899   /* Save the pointer.  */
4900   linux_nat_new_fork = new_fork;
4901 }
4902
4903 /* See declaration in linux-nat.h.  */
4904
4905 void
4906 linux_nat_set_forget_process (struct target_ops *t,
4907                               linux_nat_forget_process_ftype *fn)
4908 {
4909   /* Save the pointer.  */
4910   linux_nat_forget_process_hook = fn;
4911 }
4912
4913 /* See declaration in linux-nat.h.  */
4914
4915 void
4916 linux_nat_forget_process (pid_t pid)
4917 {
4918   if (linux_nat_forget_process_hook != NULL)
4919     linux_nat_forget_process_hook (pid);
4920 }
4921
4922 /* Register a method that converts a siginfo object between the layout
4923    that ptrace returns, and the layout in the architecture of the
4924    inferior.  */
4925 void
4926 linux_nat_set_siginfo_fixup (struct target_ops *t,
4927                              int (*siginfo_fixup) (siginfo_t *,
4928                                                    gdb_byte *,
4929                                                    int))
4930 {
4931   /* Save the pointer.  */
4932   linux_nat_siginfo_fixup = siginfo_fixup;
4933 }
4934
4935 /* Register a method to call prior to resuming a thread.  */
4936
4937 void
4938 linux_nat_set_prepare_to_resume (struct target_ops *t,
4939                                  void (*prepare_to_resume) (struct lwp_info *))
4940 {
4941   /* Save the pointer.  */
4942   linux_nat_prepare_to_resume = prepare_to_resume;
4943 }
4944
4945 /* See linux-nat.h.  */
4946
4947 int
4948 linux_nat_get_siginfo (ptid_t ptid, siginfo_t *siginfo)
4949 {
4950   int pid;
4951
4952   pid = ptid_get_lwp (ptid);
4953   if (pid == 0)
4954     pid = ptid_get_pid (ptid);
4955
4956   errno = 0;
4957   ptrace (PTRACE_GETSIGINFO, pid, (PTRACE_TYPE_ARG3) 0, siginfo);
4958   if (errno != 0)
4959     {
4960       memset (siginfo, 0, sizeof (*siginfo));
4961       return 0;
4962     }
4963   return 1;
4964 }
4965
4966 /* See nat/linux-nat.h.  */
4967
4968 ptid_t
4969 current_lwp_ptid (void)
4970 {
4971   gdb_assert (ptid_lwp_p (inferior_ptid));
4972   return inferior_ptid;
4973 }
4974
4975 void
4976 _initialize_linux_nat (void)
4977 {
4978   add_setshow_zuinteger_cmd ("lin-lwp", class_maintenance,
4979                              &debug_linux_nat, _("\
4980 Set debugging of GNU/Linux lwp module."), _("\
4981 Show debugging of GNU/Linux lwp module."), _("\
4982 Enables printf debugging output."),
4983                              NULL,
4984                              show_debug_linux_nat,
4985                              &setdebuglist, &showdebuglist);
4986
4987   add_setshow_boolean_cmd ("linux-namespaces", class_maintenance,
4988                            &debug_linux_namespaces, _("\
4989 Set debugging of GNU/Linux namespaces module."), _("\
4990 Show debugging of GNU/Linux namespaces module."), _("\
4991 Enables printf debugging output."),
4992                            NULL,
4993                            NULL,
4994                            &setdebuglist, &showdebuglist);
4995
4996   /* Save this mask as the default.  */
4997   sigprocmask (SIG_SETMASK, NULL, &normal_mask);
4998
4999   /* Install a SIGCHLD handler.  */
5000   sigchld_action.sa_handler = sigchld_handler;
5001   sigemptyset (&sigchld_action.sa_mask);
5002   sigchld_action.sa_flags = SA_RESTART;
5003
5004   /* Make it the default.  */
5005   sigaction (SIGCHLD, &sigchld_action, NULL);
5006
5007   /* Make sure we don't block SIGCHLD during a sigsuspend.  */
5008   sigprocmask (SIG_SETMASK, NULL, &suspend_mask);
5009   sigdelset (&suspend_mask, SIGCHLD);
5010
5011   sigemptyset (&blocked_mask);
5012
5013   lwp_lwpid_htab_create ();
5014 }
5015 \f
5016
5017 /* FIXME: kettenis/2000-08-26: The stuff on this page is specific to
5018    the GNU/Linux Threads library and therefore doesn't really belong
5019    here.  */
5020
5021 /* Return the set of signals used by the threads library in *SET.  */
5022
5023 void
5024 lin_thread_get_thread_signals (sigset_t *set)
5025 {
5026   sigemptyset (set);
5027
5028   /* NPTL reserves the first two RT signals, but does not provide any
5029      way for the debugger to query the signal numbers - fortunately
5030      they don't change.  */
5031   sigaddset (set, __SIGRTMIN);
5032   sigaddset (set, __SIGRTMIN + 1);
5033 }