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