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