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