1 /* GNU/Linux native-dependent code common to multiple platforms.
3 Copyright (C) 2001-2014 Free Software Foundation, Inc.
5 This file is part of GDB.
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.
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.
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/>. */
23 #include "nat/linux-nat.h"
24 #include "nat/linux-waitpid.h"
27 #include "gdb_assert.h"
28 #ifdef HAVE_TKILL_SYSCALL
30 #include <sys/syscall.h>
32 #include <sys/ptrace.h>
33 #include "linux-nat.h"
34 #include "linux-ptrace.h"
35 #include "linux-procfs.h"
36 #include "linux-fork.h"
37 #include "gdbthread.h"
41 #include "inf-child.h"
42 #include "inf-ptrace.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 */
52 #include "event-loop.h"
53 #include "event-top.h"
55 #include <sys/types.h>
57 #include "xml-support.h"
61 #include "linux-osdata.h"
62 #include "linux-tdep.h"
65 #include "tracepoint.h"
66 #include "exceptions.h"
68 #include "target-descriptions.h"
69 #include "filestuff.h"
72 #define SPUFS_MAGIC 0x23c9b64e
75 #ifdef HAVE_PERSONALITY
76 # include <sys/personality.h>
77 # if !HAVE_DECL_ADDR_NO_RANDOMIZE
78 # define ADDR_NO_RANDOMIZE 0x0040000
80 #endif /* HAVE_PERSONALITY */
82 /* This comment documents high-level logic of this file.
84 Waiting for events in sync mode
85 ===============================
87 When waiting for an event in a specific thread, we just use waitpid, passing
88 the specific pid, and not passing WNOHANG.
90 When waiting for an event in all threads, waitpid is not quite good. Prior to
91 version 2.4, Linux can either wait for event in main thread, or in secondary
92 threads. (2.4 has the __WALL flag). So, if we use blocking waitpid, we might
93 miss an event. The solution is to use non-blocking waitpid, together with
94 sigsuspend. First, we use non-blocking waitpid to get an event in the main
95 process, if any. Second, we use non-blocking waitpid with the __WCLONED
96 flag to check for events in cloned processes. If nothing is found, we use
97 sigsuspend to wait for SIGCHLD. When SIGCHLD arrives, it means something
98 happened to a child process -- and SIGCHLD will be delivered both for events
99 in main debugged process and in cloned processes. As soon as we know there's
100 an event, we get back to calling nonblocking waitpid with and without
103 Note that SIGCHLD should be blocked between waitpid and sigsuspend calls,
104 so that we don't miss a signal. If SIGCHLD arrives in between, when it's
105 blocked, the signal becomes pending and sigsuspend immediately
106 notices it and returns.
108 Waiting for events in async mode
109 ================================
111 In async mode, GDB should always be ready to handle both user input
112 and target events, so neither blocking waitpid nor sigsuspend are
113 viable options. Instead, we should asynchronously notify the GDB main
114 event loop whenever there's an unprocessed event from the target. We
115 detect asynchronous target events by handling SIGCHLD signals. To
116 notify the event loop about target events, the self-pipe trick is used
117 --- a pipe is registered as waitable event source in the event loop,
118 the event loop select/poll's on the read end of this pipe (as well on
119 other event sources, e.g., stdin), and the SIGCHLD handler writes a
120 byte to this pipe. This is more portable than relying on
121 pselect/ppoll, since on kernels that lack those syscalls, libc
122 emulates them with select/poll+sigprocmask, and that is racy
123 (a.k.a. plain broken).
125 Obviously, if we fail to notify the event loop if there's a target
126 event, it's bad. OTOH, if we notify the event loop when there's no
127 event from the target, linux_nat_wait will detect that there's no real
128 event to report, and return event of type TARGET_WAITKIND_IGNORE.
129 This is mostly harmless, but it will waste time and is better avoided.
131 The main design point is that every time GDB is outside linux-nat.c,
132 we have a SIGCHLD handler installed that is called when something
133 happens to the target and notifies the GDB event loop. Whenever GDB
134 core decides to handle the event, and calls into linux-nat.c, we
135 process things as in sync mode, except that the we never block in
138 While processing an event, we may end up momentarily blocked in
139 waitpid calls. Those waitpid calls, while blocking, are guarantied to
140 return quickly. E.g., in all-stop mode, before reporting to the core
141 that an LWP hit a breakpoint, all LWPs are stopped by sending them
142 SIGSTOP, and synchronously waiting for the SIGSTOP to be reported.
143 Note that this is different from blocking indefinitely waiting for the
144 next event --- here, we're already handling an event.
149 We stop threads by sending a SIGSTOP. The use of SIGSTOP instead of another
150 signal is not entirely significant; we just need for a signal to be delivered,
151 so that we can intercept it. SIGSTOP's advantage is that it can not be
152 blocked. A disadvantage is that it is not a real-time signal, so it can only
153 be queued once; we do not keep track of other sources of SIGSTOP.
155 Two other signals that can't be blocked are SIGCONT and SIGKILL. But we can't
156 use them, because they have special behavior when the signal is generated -
157 not when it is delivered. SIGCONT resumes the entire thread group and SIGKILL
158 kills the entire thread group.
160 A delivered SIGSTOP would stop the entire thread group, not just the thread we
161 tkill'd. But we never let the SIGSTOP be delivered; we always intercept and
162 cancel it (by PTRACE_CONT without passing SIGSTOP).
164 We could use a real-time signal instead. This would solve those problems; we
165 could use PTRACE_GETSIGINFO to locate the specific stop signals sent by GDB.
166 But we would still have to have some support for SIGSTOP, since PTRACE_ATTACH
167 generates it, and there are races with trying to find a signal that is not
171 #define O_LARGEFILE 0
174 /* The single-threaded native GNU/Linux target_ops. We save a pointer for
175 the use of the multi-threaded target. */
176 static struct target_ops *linux_ops;
177 static struct target_ops linux_ops_saved;
179 /* The method to call, if any, when a new thread is attached. */
180 static void (*linux_nat_new_thread) (struct lwp_info *);
182 /* The method to call, if any, when a new fork is attached. */
183 static linux_nat_new_fork_ftype *linux_nat_new_fork;
185 /* The method to call, if any, when a process is no longer
187 static linux_nat_forget_process_ftype *linux_nat_forget_process_hook;
189 /* Hook to call prior to resuming a thread. */
190 static void (*linux_nat_prepare_to_resume) (struct lwp_info *);
192 /* The method to call, if any, when the siginfo object needs to be
193 converted between the layout returned by ptrace, and the layout in
194 the architecture of the inferior. */
195 static int (*linux_nat_siginfo_fixup) (siginfo_t *,
199 /* The saved to_xfer_partial method, inherited from inf-ptrace.c.
200 Called by our to_xfer_partial. */
201 static target_xfer_partial_ftype *super_xfer_partial;
203 static unsigned int debug_linux_nat;
205 show_debug_linux_nat (struct ui_file *file, int from_tty,
206 struct cmd_list_element *c, const char *value)
208 fprintf_filtered (file, _("Debugging of GNU/Linux lwp module is %s.\n"),
212 struct simple_pid_list
216 struct simple_pid_list *next;
218 struct simple_pid_list *stopped_pids;
220 /* Async mode support. */
222 /* The read/write ends of the pipe registered as waitable file in the
224 static int linux_nat_event_pipe[2] = { -1, -1 };
226 /* Flush the event pipe. */
229 async_file_flush (void)
236 ret = read (linux_nat_event_pipe[0], &buf, 1);
238 while (ret >= 0 || (ret == -1 && errno == EINTR));
241 /* Put something (anything, doesn't matter what, or how much) in event
242 pipe, so that the select/poll in the event-loop realizes we have
243 something to process. */
246 async_file_mark (void)
250 /* It doesn't really matter what the pipe contains, as long we end
251 up with something in it. Might as well flush the previous
257 ret = write (linux_nat_event_pipe[1], "+", 1);
259 while (ret == -1 && errno == EINTR);
261 /* Ignore EAGAIN. If the pipe is full, the event loop will already
262 be awakened anyway. */
265 static int kill_lwp (int lwpid, int signo);
267 static int stop_callback (struct lwp_info *lp, void *data);
269 static void block_child_signals (sigset_t *prev_mask);
270 static void restore_child_signals_mask (sigset_t *prev_mask);
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);
279 /* Trivial list manipulation functions to keep track of a list of
280 new stopped processes. */
282 add_to_pid_list (struct simple_pid_list **listp, int pid, int status)
284 struct simple_pid_list *new_pid = xmalloc (sizeof (struct simple_pid_list));
287 new_pid->status = status;
288 new_pid->next = *listp;
293 in_pid_list_p (struct simple_pid_list *list, int pid)
295 struct simple_pid_list *p;
297 for (p = list; p != NULL; p = p->next)
304 pull_pid_from_list (struct simple_pid_list **listp, int pid, int *statusp)
306 struct simple_pid_list **p;
308 for (p = listp; *p != NULL; p = &(*p)->next)
309 if ((*p)->pid == pid)
311 struct simple_pid_list *next = (*p)->next;
313 *statusp = (*p)->status;
321 /* Initialize ptrace warnings and check for supported ptrace
322 features given PID. */
325 linux_init_ptrace (pid_t pid)
327 linux_enable_event_reporting (pid);
328 linux_ptrace_init_warnings ();
332 linux_child_post_attach (struct target_ops *self, int pid)
334 linux_init_ptrace (pid);
338 linux_child_post_startup_inferior (struct target_ops *self, ptid_t ptid)
340 linux_init_ptrace (ptid_get_pid (ptid));
343 /* Return the number of known LWPs in the tgid given by PID. */
351 for (lp = lwp_list; lp; lp = lp->next)
352 if (ptid_get_pid (lp->ptid) == pid)
358 /* Call delete_lwp with prototype compatible for make_cleanup. */
361 delete_lwp_cleanup (void *lp_voidp)
363 struct lwp_info *lp = lp_voidp;
365 delete_lwp (lp->ptid);
369 linux_child_follow_fork (struct target_ops *ops, int follow_child,
373 int parent_pid, child_pid;
375 has_vforked = (inferior_thread ()->pending_follow.kind
376 == TARGET_WAITKIND_VFORKED);
377 parent_pid = ptid_get_lwp (inferior_ptid);
379 parent_pid = ptid_get_pid (inferior_ptid);
381 = ptid_get_pid (inferior_thread ()->pending_follow.value.related_pid);
384 && !non_stop /* Non-stop always resumes both branches. */
385 && (!target_is_async_p () || sync_execution)
386 && !(follow_child || detach_fork || sched_multi))
388 /* The parent stays blocked inside the vfork syscall until the
389 child execs or exits. If we don't let the child run, then
390 the parent stays blocked. If we're telling the parent to run
391 in the foreground, the user will not be able to ctrl-c to get
392 back the terminal, effectively hanging the debug session. */
393 fprintf_filtered (gdb_stderr, _("\
394 Can not resume the parent process over vfork in the foreground while\n\
395 holding the child stopped. Try \"set detach-on-fork\" or \
396 \"set schedule-multiple\".\n"));
397 /* FIXME output string > 80 columns. */
403 struct lwp_info *child_lp = NULL;
405 /* We're already attached to the parent, by default. */
407 /* Detach new forked process? */
410 struct cleanup *old_chain;
412 /* Before detaching from the child, remove all breakpoints
413 from it. If we forked, then this has already been taken
414 care of by infrun.c. If we vforked however, any
415 breakpoint inserted in the parent is visible in the
416 child, even those added while stopped in a vfork
417 catchpoint. This will remove the breakpoints from the
418 parent also, but they'll be reinserted below. */
421 /* keep breakpoints list in sync. */
422 remove_breakpoints_pid (ptid_get_pid (inferior_ptid));
425 if (info_verbose || debug_linux_nat)
427 target_terminal_ours ();
428 fprintf_filtered (gdb_stdlog,
429 "Detaching after fork from "
430 "child process %d.\n",
434 old_chain = save_inferior_ptid ();
435 inferior_ptid = ptid_build (child_pid, child_pid, 0);
437 child_lp = add_lwp (inferior_ptid);
438 child_lp->stopped = 1;
439 child_lp->last_resume_kind = resume_stop;
440 make_cleanup (delete_lwp_cleanup, child_lp);
442 if (linux_nat_prepare_to_resume != NULL)
443 linux_nat_prepare_to_resume (child_lp);
444 ptrace (PTRACE_DETACH, child_pid, 0, 0);
446 do_cleanups (old_chain);
450 struct inferior *parent_inf, *child_inf;
451 struct cleanup *old_chain;
453 /* Add process to GDB's tables. */
454 child_inf = add_inferior (child_pid);
456 parent_inf = current_inferior ();
457 child_inf->attach_flag = parent_inf->attach_flag;
458 copy_terminal_info (child_inf, parent_inf);
459 child_inf->gdbarch = parent_inf->gdbarch;
460 copy_inferior_target_desc_info (child_inf, parent_inf);
462 old_chain = save_inferior_ptid ();
463 save_current_program_space ();
465 inferior_ptid = ptid_build (child_pid, child_pid, 0);
466 add_thread (inferior_ptid);
467 child_lp = add_lwp (inferior_ptid);
468 child_lp->stopped = 1;
469 child_lp->last_resume_kind = resume_stop;
470 child_inf->symfile_flags = SYMFILE_NO_READ;
472 /* If this is a vfork child, then the address-space is
473 shared with the parent. */
476 child_inf->pspace = parent_inf->pspace;
477 child_inf->aspace = parent_inf->aspace;
479 /* The parent will be frozen until the child is done
480 with the shared region. Keep track of the
482 child_inf->vfork_parent = parent_inf;
483 child_inf->pending_detach = 0;
484 parent_inf->vfork_child = child_inf;
485 parent_inf->pending_detach = 0;
489 child_inf->aspace = new_address_space ();
490 child_inf->pspace = add_program_space (child_inf->aspace);
491 child_inf->removable = 1;
492 set_current_program_space (child_inf->pspace);
493 clone_program_space (child_inf->pspace, parent_inf->pspace);
495 /* Let the shared library layer (solib-svr4) learn about
496 this new process, relocate the cloned exec, pull in
497 shared libraries, and install the solib event
498 breakpoint. If a "cloned-VM" event was propagated
499 better throughout the core, this wouldn't be
501 solib_create_inferior_hook (0);
504 /* Let the thread_db layer learn about this new process. */
505 check_for_thread_db ();
507 do_cleanups (old_chain);
512 struct lwp_info *parent_lp;
513 struct inferior *parent_inf;
515 parent_inf = current_inferior ();
517 /* If we detached from the child, then we have to be careful
518 to not insert breakpoints in the parent until the child
519 is done with the shared memory region. However, if we're
520 staying attached to the child, then we can and should
521 insert breakpoints, so that we can debug it. A
522 subsequent child exec or exit is enough to know when does
523 the child stops using the parent's address space. */
524 parent_inf->waiting_for_vfork_done = detach_fork;
525 parent_inf->pspace->breakpoints_not_allowed = detach_fork;
527 parent_lp = find_lwp_pid (pid_to_ptid (parent_pid));
528 gdb_assert (linux_supports_tracefork () >= 0);
530 if (linux_supports_tracevforkdone ())
533 fprintf_unfiltered (gdb_stdlog,
534 "LCFF: waiting for VFORK_DONE on %d\n",
536 parent_lp->stopped = 1;
538 /* We'll handle the VFORK_DONE event like any other
539 event, in target_wait. */
543 /* We can't insert breakpoints until the child has
544 finished with the shared memory region. We need to
545 wait until that happens. Ideal would be to just
547 - ptrace (PTRACE_SYSCALL, parent_pid, 0, 0);
548 - waitpid (parent_pid, &status, __WALL);
549 However, most architectures can't handle a syscall
550 being traced on the way out if it wasn't traced on
553 We might also think to loop, continuing the child
554 until it exits or gets a SIGTRAP. One problem is
555 that the child might call ptrace with PTRACE_TRACEME.
557 There's no simple and reliable way to figure out when
558 the vforked child will be done with its copy of the
559 shared memory. We could step it out of the syscall,
560 two instructions, let it go, and then single-step the
561 parent once. When we have hardware single-step, this
562 would work; with software single-step it could still
563 be made to work but we'd have to be able to insert
564 single-step breakpoints in the child, and we'd have
565 to insert -just- the single-step breakpoint in the
566 parent. Very awkward.
568 In the end, the best we can do is to make sure it
569 runs for a little while. Hopefully it will be out of
570 range of any breakpoints we reinsert. Usually this
571 is only the single-step breakpoint at vfork's return
575 fprintf_unfiltered (gdb_stdlog,
576 "LCFF: no VFORK_DONE "
577 "support, sleeping a bit\n");
581 /* Pretend we've seen a PTRACE_EVENT_VFORK_DONE event,
582 and leave it pending. The next linux_nat_resume call
583 will notice a pending event, and bypasses actually
584 resuming the inferior. */
585 parent_lp->status = 0;
586 parent_lp->waitstatus.kind = TARGET_WAITKIND_VFORK_DONE;
587 parent_lp->stopped = 1;
589 /* If we're in async mode, need to tell the event loop
590 there's something here to process. */
591 if (target_can_async_p ())
598 struct inferior *parent_inf, *child_inf;
599 struct lwp_info *child_lp;
600 struct program_space *parent_pspace;
602 if (info_verbose || debug_linux_nat)
604 target_terminal_ours ();
606 fprintf_filtered (gdb_stdlog,
607 _("Attaching after process %d "
608 "vfork to child process %d.\n"),
609 parent_pid, child_pid);
611 fprintf_filtered (gdb_stdlog,
612 _("Attaching after process %d "
613 "fork to child process %d.\n"),
614 parent_pid, child_pid);
617 /* Add the new inferior first, so that the target_detach below
618 doesn't unpush the target. */
620 child_inf = add_inferior (child_pid);
622 parent_inf = current_inferior ();
623 child_inf->attach_flag = parent_inf->attach_flag;
624 copy_terminal_info (child_inf, parent_inf);
625 child_inf->gdbarch = parent_inf->gdbarch;
626 copy_inferior_target_desc_info (child_inf, parent_inf);
628 parent_pspace = parent_inf->pspace;
630 /* If we're vforking, we want to hold on to the parent until the
631 child exits or execs. At child exec or exit time we can
632 remove the old breakpoints from the parent and detach or
633 resume debugging it. Otherwise, detach the parent now; we'll
634 want to reuse it's program/address spaces, but we can't set
635 them to the child before removing breakpoints from the
636 parent, otherwise, the breakpoints module could decide to
637 remove breakpoints from the wrong process (since they'd be
638 assigned to the same address space). */
642 gdb_assert (child_inf->vfork_parent == NULL);
643 gdb_assert (parent_inf->vfork_child == NULL);
644 child_inf->vfork_parent = parent_inf;
645 child_inf->pending_detach = 0;
646 parent_inf->vfork_child = child_inf;
647 parent_inf->pending_detach = detach_fork;
648 parent_inf->waiting_for_vfork_done = 0;
650 else if (detach_fork)
651 target_detach (NULL, 0);
653 /* Note that the detach above makes PARENT_INF dangling. */
655 /* Add the child thread to the appropriate lists, and switch to
656 this new thread, before cloning the program space, and
657 informing the solib layer about this new process. */
659 inferior_ptid = ptid_build (child_pid, child_pid, 0);
660 add_thread (inferior_ptid);
661 child_lp = add_lwp (inferior_ptid);
662 child_lp->stopped = 1;
663 child_lp->last_resume_kind = resume_stop;
665 /* If this is a vfork child, then the address-space is shared
666 with the parent. If we detached from the parent, then we can
667 reuse the parent's program/address spaces. */
668 if (has_vforked || detach_fork)
670 child_inf->pspace = parent_pspace;
671 child_inf->aspace = child_inf->pspace->aspace;
675 child_inf->aspace = new_address_space ();
676 child_inf->pspace = add_program_space (child_inf->aspace);
677 child_inf->removable = 1;
678 child_inf->symfile_flags = SYMFILE_NO_READ;
679 set_current_program_space (child_inf->pspace);
680 clone_program_space (child_inf->pspace, parent_pspace);
682 /* Let the shared library layer (solib-svr4) learn about
683 this new process, relocate the cloned exec, pull in
684 shared libraries, and install the solib event breakpoint.
685 If a "cloned-VM" event was propagated better throughout
686 the core, this wouldn't be required. */
687 solib_create_inferior_hook (0);
690 /* Let the thread_db layer learn about this new process. */
691 check_for_thread_db ();
699 linux_child_insert_fork_catchpoint (struct target_ops *self, int pid)
701 return !linux_supports_tracefork ();
705 linux_child_remove_fork_catchpoint (struct target_ops *self, int pid)
711 linux_child_insert_vfork_catchpoint (struct target_ops *self, int pid)
713 return !linux_supports_tracefork ();
717 linux_child_remove_vfork_catchpoint (struct target_ops *self, int pid)
723 linux_child_insert_exec_catchpoint (struct target_ops *self, int pid)
725 return !linux_supports_tracefork ();
729 linux_child_remove_exec_catchpoint (struct target_ops *self, int pid)
735 linux_child_set_syscall_catchpoint (struct target_ops *self,
736 int pid, int needed, int any_count,
737 int table_size, int *table)
739 if (!linux_supports_tracesysgood ())
742 /* On GNU/Linux, we ignore the arguments. It means that we only
743 enable the syscall catchpoints, but do not disable them.
745 Also, we do not use the `table' information because we do not
746 filter system calls here. We let GDB do the logic for us. */
750 /* On GNU/Linux there are no real LWP's. The closest thing to LWP's
751 are processes sharing the same VM space. A multi-threaded process
752 is basically a group of such processes. However, such a grouping
753 is almost entirely a user-space issue; the kernel doesn't enforce
754 such a grouping at all (this might change in the future). In
755 general, we'll rely on the threads library (i.e. the GNU/Linux
756 Threads library) to provide such a grouping.
758 It is perfectly well possible to write a multi-threaded application
759 without the assistance of a threads library, by using the clone
760 system call directly. This module should be able to give some
761 rudimentary support for debugging such applications if developers
762 specify the CLONE_PTRACE flag in the clone system call, and are
763 using the Linux kernel 2.4 or above.
765 Note that there are some peculiarities in GNU/Linux that affect
768 - In general one should specify the __WCLONE flag to waitpid in
769 order to make it report events for any of the cloned processes
770 (and leave it out for the initial process). However, if a cloned
771 process has exited the exit status is only reported if the
772 __WCLONE flag is absent. Linux kernel 2.4 has a __WALL flag, but
773 we cannot use it since GDB must work on older systems too.
775 - When a traced, cloned process exits and is waited for by the
776 debugger, the kernel reassigns it to the original parent and
777 keeps it around as a "zombie". Somehow, the GNU/Linux Threads
778 library doesn't notice this, which leads to the "zombie problem":
779 When debugged a multi-threaded process that spawns a lot of
780 threads will run out of processes, even if the threads exit,
781 because the "zombies" stay around. */
783 /* List of known LWPs. */
784 struct lwp_info *lwp_list;
787 /* Original signal mask. */
788 static sigset_t normal_mask;
790 /* Signal mask for use with sigsuspend in linux_nat_wait, initialized in
791 _initialize_linux_nat. */
792 static sigset_t suspend_mask;
794 /* Signals to block to make that sigsuspend work. */
795 static sigset_t blocked_mask;
797 /* SIGCHLD action. */
798 struct sigaction sigchld_action;
800 /* Block child signals (SIGCHLD and linux threads signals), and store
801 the previous mask in PREV_MASK. */
804 block_child_signals (sigset_t *prev_mask)
806 /* Make sure SIGCHLD is blocked. */
807 if (!sigismember (&blocked_mask, SIGCHLD))
808 sigaddset (&blocked_mask, SIGCHLD);
810 sigprocmask (SIG_BLOCK, &blocked_mask, prev_mask);
813 /* Restore child signals mask, previously returned by
814 block_child_signals. */
817 restore_child_signals_mask (sigset_t *prev_mask)
819 sigprocmask (SIG_SETMASK, prev_mask, NULL);
822 /* Mask of signals to pass directly to the inferior. */
823 static sigset_t pass_mask;
825 /* Update signals to pass to the inferior. */
827 linux_nat_pass_signals (struct target_ops *self,
828 int numsigs, unsigned char *pass_signals)
832 sigemptyset (&pass_mask);
834 for (signo = 1; signo < NSIG; signo++)
836 int target_signo = gdb_signal_from_host (signo);
837 if (target_signo < numsigs && pass_signals[target_signo])
838 sigaddset (&pass_mask, signo);
844 /* Prototypes for local functions. */
845 static int stop_wait_callback (struct lwp_info *lp, void *data);
846 static int linux_thread_alive (ptid_t ptid);
847 static char *linux_child_pid_to_exec_file (struct target_ops *self, int pid);
850 /* Convert wait status STATUS to a string. Used for printing debug
854 status_to_str (int status)
858 if (WIFSTOPPED (status))
860 if (WSTOPSIG (status) == SYSCALL_SIGTRAP)
861 snprintf (buf, sizeof (buf), "%s (stopped at syscall)",
862 strsignal (SIGTRAP));
864 snprintf (buf, sizeof (buf), "%s (stopped)",
865 strsignal (WSTOPSIG (status)));
867 else if (WIFSIGNALED (status))
868 snprintf (buf, sizeof (buf), "%s (terminated)",
869 strsignal (WTERMSIG (status)));
871 snprintf (buf, sizeof (buf), "%d (exited)", WEXITSTATUS (status));
876 /* Destroy and free LP. */
879 lwp_free (struct lwp_info *lp)
881 xfree (lp->arch_private);
885 /* Remove all LWPs belong to PID from the lwp list. */
888 purge_lwp_list (int pid)
890 struct lwp_info *lp, *lpprev, *lpnext;
894 for (lp = lwp_list; lp; lp = lpnext)
898 if (ptid_get_pid (lp->ptid) == pid)
903 lpprev->next = lp->next;
912 /* Add the LWP specified by PTID to the list. PTID is the first LWP
913 in the process. Return a pointer to the structure describing the
916 This differs from add_lwp in that we don't let the arch specific
917 bits know about this new thread. Current clients of this callback
918 take the opportunity to install watchpoints in the new thread, and
919 we shouldn't do that for the first thread. If we're spawning a
920 child ("run"), the thread executes the shell wrapper first, and we
921 shouldn't touch it until it execs the program we want to debug.
922 For "attach", it'd be okay to call the callback, but it's not
923 necessary, because watchpoints can't yet have been inserted into
926 static struct lwp_info *
927 add_initial_lwp (ptid_t ptid)
931 gdb_assert (ptid_lwp_p (ptid));
933 lp = (struct lwp_info *) xmalloc (sizeof (struct lwp_info));
935 memset (lp, 0, sizeof (struct lwp_info));
937 lp->last_resume_kind = resume_continue;
938 lp->waitstatus.kind = TARGET_WAITKIND_IGNORE;
949 /* Add the LWP specified by PID to the list. Return a pointer to the
950 structure describing the new LWP. The LWP should already be
953 static struct lwp_info *
954 add_lwp (ptid_t ptid)
958 lp = add_initial_lwp (ptid);
960 /* Let the arch specific bits know about this new thread. Current
961 clients of this callback take the opportunity to install
962 watchpoints in the new thread. We don't do this for the first
963 thread though. See add_initial_lwp. */
964 if (linux_nat_new_thread != NULL)
965 linux_nat_new_thread (lp);
970 /* Remove the LWP specified by PID from the list. */
973 delete_lwp (ptid_t ptid)
975 struct lwp_info *lp, *lpprev;
979 for (lp = lwp_list; lp; lpprev = lp, lp = lp->next)
980 if (ptid_equal (lp->ptid, ptid))
987 lpprev->next = lp->next;
994 /* Return a pointer to the structure describing the LWP corresponding
995 to PID. If no corresponding LWP could be found, return NULL. */
997 static struct lwp_info *
998 find_lwp_pid (ptid_t ptid)
1000 struct lwp_info *lp;
1003 if (ptid_lwp_p (ptid))
1004 lwp = ptid_get_lwp (ptid);
1006 lwp = ptid_get_pid (ptid);
1008 for (lp = lwp_list; lp; lp = lp->next)
1009 if (lwp == ptid_get_lwp (lp->ptid))
1015 /* Call CALLBACK with its second argument set to DATA for every LWP in
1016 the list. If CALLBACK returns 1 for a particular LWP, return a
1017 pointer to the structure describing that LWP immediately.
1018 Otherwise return NULL. */
1021 iterate_over_lwps (ptid_t filter,
1022 int (*callback) (struct lwp_info *, void *),
1025 struct lwp_info *lp, *lpnext;
1027 for (lp = lwp_list; lp; lp = lpnext)
1031 if (ptid_match (lp->ptid, filter))
1033 if ((*callback) (lp, data))
1041 /* Update our internal state when changing from one checkpoint to
1042 another indicated by NEW_PTID. We can only switch single-threaded
1043 applications, so we only create one new LWP, and the previous list
1047 linux_nat_switch_fork (ptid_t new_ptid)
1049 struct lwp_info *lp;
1051 purge_lwp_list (ptid_get_pid (inferior_ptid));
1053 lp = add_lwp (new_ptid);
1056 /* This changes the thread's ptid while preserving the gdb thread
1057 num. Also changes the inferior pid, while preserving the
1059 thread_change_ptid (inferior_ptid, new_ptid);
1061 /* We've just told GDB core that the thread changed target id, but,
1062 in fact, it really is a different thread, with different register
1064 registers_changed ();
1067 /* Handle the exit of a single thread LP. */
1070 exit_lwp (struct lwp_info *lp)
1072 struct thread_info *th = find_thread_ptid (lp->ptid);
1076 if (print_thread_events)
1077 printf_unfiltered (_("[%s exited]\n"), target_pid_to_str (lp->ptid));
1079 delete_thread (lp->ptid);
1082 delete_lwp (lp->ptid);
1085 /* Wait for the LWP specified by LP, which we have just attached to.
1086 Returns a wait status for that LWP, to cache. */
1089 linux_nat_post_attach_wait (ptid_t ptid, int first, int *cloned,
1092 pid_t new_pid, pid = ptid_get_lwp (ptid);
1095 if (linux_proc_pid_is_stopped (pid))
1097 if (debug_linux_nat)
1098 fprintf_unfiltered (gdb_stdlog,
1099 "LNPAW: Attaching to a stopped process\n");
1101 /* The process is definitely stopped. It is in a job control
1102 stop, unless the kernel predates the TASK_STOPPED /
1103 TASK_TRACED distinction, in which case it might be in a
1104 ptrace stop. Make sure it is in a ptrace stop; from there we
1105 can kill it, signal it, et cetera.
1107 First make sure there is a pending SIGSTOP. Since we are
1108 already attached, the process can not transition from stopped
1109 to running without a PTRACE_CONT; so we know this signal will
1110 go into the queue. The SIGSTOP generated by PTRACE_ATTACH is
1111 probably already in the queue (unless this kernel is old
1112 enough to use TASK_STOPPED for ptrace stops); but since SIGSTOP
1113 is not an RT signal, it can only be queued once. */
1114 kill_lwp (pid, SIGSTOP);
1116 /* Finally, resume the stopped process. This will deliver the SIGSTOP
1117 (or a higher priority signal, just like normal PTRACE_ATTACH). */
1118 ptrace (PTRACE_CONT, pid, 0, 0);
1121 /* Make sure the initial process is stopped. The user-level threads
1122 layer might want to poke around in the inferior, and that won't
1123 work if things haven't stabilized yet. */
1124 new_pid = my_waitpid (pid, &status, 0);
1125 if (new_pid == -1 && errno == ECHILD)
1128 warning (_("%s is a cloned process"), target_pid_to_str (ptid));
1130 /* Try again with __WCLONE to check cloned processes. */
1131 new_pid = my_waitpid (pid, &status, __WCLONE);
1135 gdb_assert (pid == new_pid);
1137 if (!WIFSTOPPED (status))
1139 /* The pid we tried to attach has apparently just exited. */
1140 if (debug_linux_nat)
1141 fprintf_unfiltered (gdb_stdlog, "LNPAW: Failed to stop %d: %s",
1142 pid, status_to_str (status));
1146 if (WSTOPSIG (status) != SIGSTOP)
1149 if (debug_linux_nat)
1150 fprintf_unfiltered (gdb_stdlog,
1151 "LNPAW: Received %s after attaching\n",
1152 status_to_str (status));
1158 /* Attach to the LWP specified by PID. Return 0 if successful, -1 if
1159 the new LWP could not be attached, or 1 if we're already auto
1160 attached to this thread, but haven't processed the
1161 PTRACE_EVENT_CLONE event of its parent thread, so we just ignore
1162 its existance, without considering it an error. */
1165 lin_lwp_attach_lwp (ptid_t ptid)
1167 struct lwp_info *lp;
1170 gdb_assert (ptid_lwp_p (ptid));
1172 lp = find_lwp_pid (ptid);
1173 lwpid = ptid_get_lwp (ptid);
1175 /* We assume that we're already attached to any LWP that has an id
1176 equal to the overall process id, and to any LWP that is already
1177 in our list of LWPs. If we're not seeing exit events from threads
1178 and we've had PID wraparound since we last tried to stop all threads,
1179 this assumption might be wrong; fortunately, this is very unlikely
1181 if (lwpid != ptid_get_pid (ptid) && lp == NULL)
1183 int status, cloned = 0, signalled = 0;
1185 if (ptrace (PTRACE_ATTACH, lwpid, 0, 0) < 0)
1187 if (linux_supports_tracefork ())
1189 /* If we haven't stopped all threads when we get here,
1190 we may have seen a thread listed in thread_db's list,
1191 but not processed the PTRACE_EVENT_CLONE yet. If
1192 that's the case, ignore this new thread, and let
1193 normal event handling discover it later. */
1194 if (in_pid_list_p (stopped_pids, lwpid))
1196 /* We've already seen this thread stop, but we
1197 haven't seen the PTRACE_EVENT_CLONE extended
1206 /* See if we've got a stop for this new child
1207 pending. If so, we're already attached. */
1208 new_pid = my_waitpid (lwpid, &status, WNOHANG);
1209 if (new_pid == -1 && errno == ECHILD)
1210 new_pid = my_waitpid (lwpid, &status, __WCLONE | WNOHANG);
1213 if (WIFSTOPPED (status))
1214 add_to_pid_list (&stopped_pids, lwpid, status);
1220 /* If we fail to attach to the thread, issue a warning,
1221 but continue. One way this can happen is if thread
1222 creation is interrupted; as of Linux kernel 2.6.19, a
1223 bug may place threads in the thread list and then fail
1225 warning (_("Can't attach %s: %s"), target_pid_to_str (ptid),
1226 safe_strerror (errno));
1230 if (debug_linux_nat)
1231 fprintf_unfiltered (gdb_stdlog,
1232 "LLAL: PTRACE_ATTACH %s, 0, 0 (OK)\n",
1233 target_pid_to_str (ptid));
1235 status = linux_nat_post_attach_wait (ptid, 0, &cloned, &signalled);
1236 if (!WIFSTOPPED (status))
1239 lp = add_lwp (ptid);
1241 lp->cloned = cloned;
1242 lp->signalled = signalled;
1243 if (WSTOPSIG (status) != SIGSTOP)
1246 lp->status = status;
1249 target_post_attach (ptid_get_lwp (lp->ptid));
1251 if (debug_linux_nat)
1253 fprintf_unfiltered (gdb_stdlog,
1254 "LLAL: waitpid %s received %s\n",
1255 target_pid_to_str (ptid),
1256 status_to_str (status));
1261 /* We assume that the LWP representing the original process is
1262 already stopped. Mark it as stopped in the data structure
1263 that the GNU/linux ptrace layer uses to keep track of
1264 threads. Note that this won't have already been done since
1265 the main thread will have, we assume, been stopped by an
1266 attach from a different layer. */
1268 lp = add_lwp (ptid);
1272 lp->last_resume_kind = resume_stop;
1277 linux_nat_create_inferior (struct target_ops *ops,
1278 char *exec_file, char *allargs, char **env,
1281 #ifdef HAVE_PERSONALITY
1282 int personality_orig = 0, personality_set = 0;
1283 #endif /* HAVE_PERSONALITY */
1285 /* The fork_child mechanism is synchronous and calls target_wait, so
1286 we have to mask the async mode. */
1288 #ifdef HAVE_PERSONALITY
1289 if (disable_randomization)
1292 personality_orig = personality (0xffffffff);
1293 if (errno == 0 && !(personality_orig & ADDR_NO_RANDOMIZE))
1295 personality_set = 1;
1296 personality (personality_orig | ADDR_NO_RANDOMIZE);
1298 if (errno != 0 || (personality_set
1299 && !(personality (0xffffffff) & ADDR_NO_RANDOMIZE)))
1300 warning (_("Error disabling address space randomization: %s"),
1301 safe_strerror (errno));
1303 #endif /* HAVE_PERSONALITY */
1305 /* Make sure we report all signals during startup. */
1306 linux_nat_pass_signals (ops, 0, NULL);
1308 linux_ops->to_create_inferior (ops, exec_file, allargs, env, from_tty);
1310 #ifdef HAVE_PERSONALITY
1311 if (personality_set)
1314 personality (personality_orig);
1316 warning (_("Error restoring address space randomization: %s"),
1317 safe_strerror (errno));
1319 #endif /* HAVE_PERSONALITY */
1323 linux_nat_attach (struct target_ops *ops, char *args, int from_tty)
1325 struct lwp_info *lp;
1328 volatile struct gdb_exception ex;
1330 /* Make sure we report all signals during attach. */
1331 linux_nat_pass_signals (ops, 0, NULL);
1333 TRY_CATCH (ex, RETURN_MASK_ERROR)
1335 linux_ops->to_attach (ops, args, from_tty);
1339 pid_t pid = parse_pid_to_attach (args);
1340 struct buffer buffer;
1341 char *message, *buffer_s;
1343 message = xstrdup (ex.message);
1344 make_cleanup (xfree, message);
1346 buffer_init (&buffer);
1347 linux_ptrace_attach_warnings (pid, &buffer);
1349 buffer_grow_str0 (&buffer, "");
1350 buffer_s = buffer_finish (&buffer);
1351 make_cleanup (xfree, buffer_s);
1353 throw_error (ex.error, "%s%s", buffer_s, message);
1356 /* The ptrace base target adds the main thread with (pid,0,0)
1357 format. Decorate it with lwp info. */
1358 ptid = ptid_build (ptid_get_pid (inferior_ptid),
1359 ptid_get_pid (inferior_ptid),
1361 thread_change_ptid (inferior_ptid, ptid);
1363 /* Add the initial process as the first LWP to the list. */
1364 lp = add_initial_lwp (ptid);
1366 status = linux_nat_post_attach_wait (lp->ptid, 1, &lp->cloned,
1368 if (!WIFSTOPPED (status))
1370 if (WIFEXITED (status))
1372 int exit_code = WEXITSTATUS (status);
1374 target_terminal_ours ();
1375 target_mourn_inferior ();
1377 error (_("Unable to attach: program exited normally."));
1379 error (_("Unable to attach: program exited with code %d."),
1382 else if (WIFSIGNALED (status))
1384 enum gdb_signal signo;
1386 target_terminal_ours ();
1387 target_mourn_inferior ();
1389 signo = gdb_signal_from_host (WTERMSIG (status));
1390 error (_("Unable to attach: program terminated with signal "
1392 gdb_signal_to_name (signo),
1393 gdb_signal_to_string (signo));
1396 internal_error (__FILE__, __LINE__,
1397 _("unexpected status %d for PID %ld"),
1398 status, (long) ptid_get_lwp (ptid));
1403 /* Save the wait status to report later. */
1405 if (debug_linux_nat)
1406 fprintf_unfiltered (gdb_stdlog,
1407 "LNA: waitpid %ld, saving status %s\n",
1408 (long) ptid_get_pid (lp->ptid), status_to_str (status));
1410 lp->status = status;
1412 if (target_can_async_p ())
1413 target_async (inferior_event_handler, 0);
1416 /* Get pending status of LP. */
1418 get_pending_status (struct lwp_info *lp, int *status)
1420 enum gdb_signal signo = GDB_SIGNAL_0;
1422 /* If we paused threads momentarily, we may have stored pending
1423 events in lp->status or lp->waitstatus (see stop_wait_callback),
1424 and GDB core hasn't seen any signal for those threads.
1425 Otherwise, the last signal reported to the core is found in the
1426 thread object's stop_signal.
1428 There's a corner case that isn't handled here at present. Only
1429 if the thread stopped with a TARGET_WAITKIND_STOPPED does
1430 stop_signal make sense as a real signal to pass to the inferior.
1431 Some catchpoint related events, like
1432 TARGET_WAITKIND_(V)FORK|EXEC|SYSCALL, have their stop_signal set
1433 to GDB_SIGNAL_SIGTRAP when the catchpoint triggers. But,
1434 those traps are debug API (ptrace in our case) related and
1435 induced; the inferior wouldn't see them if it wasn't being
1436 traced. Hence, we should never pass them to the inferior, even
1437 when set to pass state. Since this corner case isn't handled by
1438 infrun.c when proceeding with a signal, for consistency, neither
1439 do we handle it here (or elsewhere in the file we check for
1440 signal pass state). Normally SIGTRAP isn't set to pass state, so
1441 this is really a corner case. */
1443 if (lp->waitstatus.kind != TARGET_WAITKIND_IGNORE)
1444 signo = GDB_SIGNAL_0; /* a pending ptrace event, not a real signal. */
1445 else if (lp->status)
1446 signo = gdb_signal_from_host (WSTOPSIG (lp->status));
1447 else if (non_stop && !is_executing (lp->ptid))
1449 struct thread_info *tp = find_thread_ptid (lp->ptid);
1451 signo = tp->suspend.stop_signal;
1455 struct target_waitstatus last;
1458 get_last_target_status (&last_ptid, &last);
1460 if (ptid_get_lwp (lp->ptid) == ptid_get_lwp (last_ptid))
1462 struct thread_info *tp = find_thread_ptid (lp->ptid);
1464 signo = tp->suspend.stop_signal;
1470 if (signo == GDB_SIGNAL_0)
1472 if (debug_linux_nat)
1473 fprintf_unfiltered (gdb_stdlog,
1474 "GPT: lwp %s has no pending signal\n",
1475 target_pid_to_str (lp->ptid));
1477 else if (!signal_pass_state (signo))
1479 if (debug_linux_nat)
1480 fprintf_unfiltered (gdb_stdlog,
1481 "GPT: lwp %s had signal %s, "
1482 "but it is in no pass state\n",
1483 target_pid_to_str (lp->ptid),
1484 gdb_signal_to_string (signo));
1488 *status = W_STOPCODE (gdb_signal_to_host (signo));
1490 if (debug_linux_nat)
1491 fprintf_unfiltered (gdb_stdlog,
1492 "GPT: lwp %s has pending signal %s\n",
1493 target_pid_to_str (lp->ptid),
1494 gdb_signal_to_string (signo));
1501 detach_callback (struct lwp_info *lp, void *data)
1503 gdb_assert (lp->status == 0 || WIFSTOPPED (lp->status));
1505 if (debug_linux_nat && lp->status)
1506 fprintf_unfiltered (gdb_stdlog, "DC: Pending %s for %s on detach.\n",
1507 strsignal (WSTOPSIG (lp->status)),
1508 target_pid_to_str (lp->ptid));
1510 /* If there is a pending SIGSTOP, get rid of it. */
1513 if (debug_linux_nat)
1514 fprintf_unfiltered (gdb_stdlog,
1515 "DC: Sending SIGCONT to %s\n",
1516 target_pid_to_str (lp->ptid));
1518 kill_lwp (ptid_get_lwp (lp->ptid), SIGCONT);
1522 /* We don't actually detach from the LWP that has an id equal to the
1523 overall process id just yet. */
1524 if (ptid_get_lwp (lp->ptid) != ptid_get_pid (lp->ptid))
1528 /* Pass on any pending signal for this LWP. */
1529 get_pending_status (lp, &status);
1531 if (linux_nat_prepare_to_resume != NULL)
1532 linux_nat_prepare_to_resume (lp);
1534 if (ptrace (PTRACE_DETACH, ptid_get_lwp (lp->ptid), 0,
1535 WSTOPSIG (status)) < 0)
1536 error (_("Can't detach %s: %s"), target_pid_to_str (lp->ptid),
1537 safe_strerror (errno));
1539 if (debug_linux_nat)
1540 fprintf_unfiltered (gdb_stdlog,
1541 "PTRACE_DETACH (%s, %s, 0) (OK)\n",
1542 target_pid_to_str (lp->ptid),
1543 strsignal (WSTOPSIG (status)));
1545 delete_lwp (lp->ptid);
1552 linux_nat_detach (struct target_ops *ops, const char *args, int from_tty)
1556 struct lwp_info *main_lwp;
1558 pid = ptid_get_pid (inferior_ptid);
1560 /* Don't unregister from the event loop, as there may be other
1561 inferiors running. */
1563 /* Stop all threads before detaching. ptrace requires that the
1564 thread is stopped to sucessfully detach. */
1565 iterate_over_lwps (pid_to_ptid (pid), stop_callback, NULL);
1566 /* ... and wait until all of them have reported back that
1567 they're no longer running. */
1568 iterate_over_lwps (pid_to_ptid (pid), stop_wait_callback, NULL);
1570 iterate_over_lwps (pid_to_ptid (pid), detach_callback, NULL);
1572 /* Only the initial process should be left right now. */
1573 gdb_assert (num_lwps (ptid_get_pid (inferior_ptid)) == 1);
1575 main_lwp = find_lwp_pid (pid_to_ptid (pid));
1577 /* Pass on any pending signal for the last LWP. */
1578 if ((args == NULL || *args == '\0')
1579 && get_pending_status (main_lwp, &status) != -1
1580 && WIFSTOPPED (status))
1584 /* Put the signal number in ARGS so that inf_ptrace_detach will
1585 pass it along with PTRACE_DETACH. */
1587 xsnprintf (tem, 8, "%d", (int) WSTOPSIG (status));
1589 if (debug_linux_nat)
1590 fprintf_unfiltered (gdb_stdlog,
1591 "LND: Sending signal %s to %s\n",
1593 target_pid_to_str (main_lwp->ptid));
1596 if (linux_nat_prepare_to_resume != NULL)
1597 linux_nat_prepare_to_resume (main_lwp);
1598 delete_lwp (main_lwp->ptid);
1600 if (forks_exist_p ())
1602 /* Multi-fork case. The current inferior_ptid is being detached
1603 from, but there are other viable forks to debug. Detach from
1604 the current fork, and context-switch to the first
1606 linux_fork_detach (args, from_tty);
1609 linux_ops->to_detach (ops, args, from_tty);
1615 resume_lwp (struct lwp_info *lp, int step, enum gdb_signal signo)
1619 struct inferior *inf = find_inferior_pid (ptid_get_pid (lp->ptid));
1621 if (inf->vfork_child != NULL)
1623 if (debug_linux_nat)
1624 fprintf_unfiltered (gdb_stdlog,
1625 "RC: Not resuming %s (vfork parent)\n",
1626 target_pid_to_str (lp->ptid));
1628 else if (lp->status == 0
1629 && lp->waitstatus.kind == TARGET_WAITKIND_IGNORE)
1631 if (debug_linux_nat)
1632 fprintf_unfiltered (gdb_stdlog,
1633 "RC: Resuming sibling %s, %s, %s\n",
1634 target_pid_to_str (lp->ptid),
1635 (signo != GDB_SIGNAL_0
1636 ? strsignal (gdb_signal_to_host (signo))
1638 step ? "step" : "resume");
1640 if (linux_nat_prepare_to_resume != NULL)
1641 linux_nat_prepare_to_resume (lp);
1642 linux_ops->to_resume (linux_ops,
1643 pid_to_ptid (ptid_get_lwp (lp->ptid)),
1647 lp->stopped_by_watchpoint = 0;
1651 if (debug_linux_nat)
1652 fprintf_unfiltered (gdb_stdlog,
1653 "RC: Not resuming sibling %s (has pending)\n",
1654 target_pid_to_str (lp->ptid));
1659 if (debug_linux_nat)
1660 fprintf_unfiltered (gdb_stdlog,
1661 "RC: Not resuming sibling %s (not stopped)\n",
1662 target_pid_to_str (lp->ptid));
1666 /* Resume LWP, with the last stop signal, if it is in pass state. */
1669 linux_nat_resume_callback (struct lwp_info *lp, void *data)
1671 enum gdb_signal signo = GDB_SIGNAL_0;
1675 struct thread_info *thread;
1677 thread = find_thread_ptid (lp->ptid);
1680 if (signal_pass_state (thread->suspend.stop_signal))
1681 signo = thread->suspend.stop_signal;
1682 thread->suspend.stop_signal = GDB_SIGNAL_0;
1686 resume_lwp (lp, 0, signo);
1691 resume_clear_callback (struct lwp_info *lp, void *data)
1694 lp->last_resume_kind = resume_stop;
1699 resume_set_callback (struct lwp_info *lp, void *data)
1702 lp->last_resume_kind = resume_continue;
1707 linux_nat_resume (struct target_ops *ops,
1708 ptid_t ptid, int step, enum gdb_signal signo)
1710 struct lwp_info *lp;
1713 if (debug_linux_nat)
1714 fprintf_unfiltered (gdb_stdlog,
1715 "LLR: Preparing to %s %s, %s, inferior_ptid %s\n",
1716 step ? "step" : "resume",
1717 target_pid_to_str (ptid),
1718 (signo != GDB_SIGNAL_0
1719 ? strsignal (gdb_signal_to_host (signo)) : "0"),
1720 target_pid_to_str (inferior_ptid));
1722 /* A specific PTID means `step only this process id'. */
1723 resume_many = (ptid_equal (minus_one_ptid, ptid)
1724 || ptid_is_pid (ptid));
1726 /* Mark the lwps we're resuming as resumed. */
1727 iterate_over_lwps (ptid, resume_set_callback, NULL);
1729 /* See if it's the current inferior that should be handled
1732 lp = find_lwp_pid (inferior_ptid);
1734 lp = find_lwp_pid (ptid);
1735 gdb_assert (lp != NULL);
1737 /* Remember if we're stepping. */
1739 lp->last_resume_kind = step ? resume_step : resume_continue;
1741 /* If we have a pending wait status for this thread, there is no
1742 point in resuming the process. But first make sure that
1743 linux_nat_wait won't preemptively handle the event - we
1744 should never take this short-circuit if we are going to
1745 leave LP running, since we have skipped resuming all the
1746 other threads. This bit of code needs to be synchronized
1747 with linux_nat_wait. */
1749 if (lp->status && WIFSTOPPED (lp->status))
1752 && WSTOPSIG (lp->status)
1753 && sigismember (&pass_mask, WSTOPSIG (lp->status)))
1755 if (debug_linux_nat)
1756 fprintf_unfiltered (gdb_stdlog,
1757 "LLR: Not short circuiting for ignored "
1758 "status 0x%x\n", lp->status);
1760 /* FIXME: What should we do if we are supposed to continue
1761 this thread with a signal? */
1762 gdb_assert (signo == GDB_SIGNAL_0);
1763 signo = gdb_signal_from_host (WSTOPSIG (lp->status));
1768 if (lp->status || lp->waitstatus.kind != TARGET_WAITKIND_IGNORE)
1770 /* FIXME: What should we do if we are supposed to continue
1771 this thread with a signal? */
1772 gdb_assert (signo == GDB_SIGNAL_0);
1774 if (debug_linux_nat)
1775 fprintf_unfiltered (gdb_stdlog,
1776 "LLR: Short circuiting for status 0x%x\n",
1779 if (target_can_async_p ())
1781 target_async (inferior_event_handler, 0);
1782 /* Tell the event loop we have something to process. */
1788 /* Mark LWP as not stopped to prevent it from being continued by
1789 linux_nat_resume_callback. */
1793 iterate_over_lwps (ptid, linux_nat_resume_callback, NULL);
1795 /* Convert to something the lower layer understands. */
1796 ptid = pid_to_ptid (ptid_get_lwp (lp->ptid));
1798 if (linux_nat_prepare_to_resume != NULL)
1799 linux_nat_prepare_to_resume (lp);
1800 linux_ops->to_resume (linux_ops, ptid, step, signo);
1801 lp->stopped_by_watchpoint = 0;
1803 if (debug_linux_nat)
1804 fprintf_unfiltered (gdb_stdlog,
1805 "LLR: %s %s, %s (resume event thread)\n",
1806 step ? "PTRACE_SINGLESTEP" : "PTRACE_CONT",
1807 target_pid_to_str (ptid),
1808 (signo != GDB_SIGNAL_0
1809 ? strsignal (gdb_signal_to_host (signo)) : "0"));
1811 if (target_can_async_p ())
1812 target_async (inferior_event_handler, 0);
1815 /* Send a signal to an LWP. */
1818 kill_lwp (int lwpid, int signo)
1820 /* Use tkill, if possible, in case we are using nptl threads. If tkill
1821 fails, then we are not using nptl threads and we should be using kill. */
1823 #ifdef HAVE_TKILL_SYSCALL
1825 static int tkill_failed;
1832 ret = syscall (__NR_tkill, lwpid, signo);
1833 if (errno != ENOSYS)
1840 return kill (lwpid, signo);
1843 /* Handle a GNU/Linux syscall trap wait response. If we see a syscall
1844 event, check if the core is interested in it: if not, ignore the
1845 event, and keep waiting; otherwise, we need to toggle the LWP's
1846 syscall entry/exit status, since the ptrace event itself doesn't
1847 indicate it, and report the trap to higher layers. */
1850 linux_handle_syscall_trap (struct lwp_info *lp, int stopping)
1852 struct target_waitstatus *ourstatus = &lp->waitstatus;
1853 struct gdbarch *gdbarch = target_thread_architecture (lp->ptid);
1854 int syscall_number = (int) gdbarch_get_syscall_number (gdbarch, lp->ptid);
1858 /* If we're stopping threads, there's a SIGSTOP pending, which
1859 makes it so that the LWP reports an immediate syscall return,
1860 followed by the SIGSTOP. Skip seeing that "return" using
1861 PTRACE_CONT directly, and let stop_wait_callback collect the
1862 SIGSTOP. Later when the thread is resumed, a new syscall
1863 entry event. If we didn't do this (and returned 0), we'd
1864 leave a syscall entry pending, and our caller, by using
1865 PTRACE_CONT to collect the SIGSTOP, skips the syscall return
1866 itself. Later, when the user re-resumes this LWP, we'd see
1867 another syscall entry event and we'd mistake it for a return.
1869 If stop_wait_callback didn't force the SIGSTOP out of the LWP
1870 (leaving immediately with LWP->signalled set, without issuing
1871 a PTRACE_CONT), it would still be problematic to leave this
1872 syscall enter pending, as later when the thread is resumed,
1873 it would then see the same syscall exit mentioned above,
1874 followed by the delayed SIGSTOP, while the syscall didn't
1875 actually get to execute. It seems it would be even more
1876 confusing to the user. */
1878 if (debug_linux_nat)
1879 fprintf_unfiltered (gdb_stdlog,
1880 "LHST: ignoring syscall %d "
1881 "for LWP %ld (stopping threads), "
1882 "resuming with PTRACE_CONT for SIGSTOP\n",
1884 ptid_get_lwp (lp->ptid));
1886 lp->syscall_state = TARGET_WAITKIND_IGNORE;
1887 ptrace (PTRACE_CONT, ptid_get_lwp (lp->ptid), 0, 0);
1891 if (catch_syscall_enabled ())
1893 /* Always update the entry/return state, even if this particular
1894 syscall isn't interesting to the core now. In async mode,
1895 the user could install a new catchpoint for this syscall
1896 between syscall enter/return, and we'll need to know to
1897 report a syscall return if that happens. */
1898 lp->syscall_state = (lp->syscall_state == TARGET_WAITKIND_SYSCALL_ENTRY
1899 ? TARGET_WAITKIND_SYSCALL_RETURN
1900 : TARGET_WAITKIND_SYSCALL_ENTRY);
1902 if (catching_syscall_number (syscall_number))
1904 /* Alright, an event to report. */
1905 ourstatus->kind = lp->syscall_state;
1906 ourstatus->value.syscall_number = syscall_number;
1908 if (debug_linux_nat)
1909 fprintf_unfiltered (gdb_stdlog,
1910 "LHST: stopping for %s of syscall %d"
1913 == TARGET_WAITKIND_SYSCALL_ENTRY
1914 ? "entry" : "return",
1916 ptid_get_lwp (lp->ptid));
1920 if (debug_linux_nat)
1921 fprintf_unfiltered (gdb_stdlog,
1922 "LHST: ignoring %s of syscall %d "
1924 lp->syscall_state == TARGET_WAITKIND_SYSCALL_ENTRY
1925 ? "entry" : "return",
1927 ptid_get_lwp (lp->ptid));
1931 /* If we had been syscall tracing, and hence used PT_SYSCALL
1932 before on this LWP, it could happen that the user removes all
1933 syscall catchpoints before we get to process this event.
1934 There are two noteworthy issues here:
1936 - When stopped at a syscall entry event, resuming with
1937 PT_STEP still resumes executing the syscall and reports a
1940 - Only PT_SYSCALL catches syscall enters. If we last
1941 single-stepped this thread, then this event can't be a
1942 syscall enter. If we last single-stepped this thread, this
1943 has to be a syscall exit.
1945 The points above mean that the next resume, be it PT_STEP or
1946 PT_CONTINUE, can not trigger a syscall trace event. */
1947 if (debug_linux_nat)
1948 fprintf_unfiltered (gdb_stdlog,
1949 "LHST: caught syscall event "
1950 "with no syscall catchpoints."
1951 " %d for LWP %ld, ignoring\n",
1953 ptid_get_lwp (lp->ptid));
1954 lp->syscall_state = TARGET_WAITKIND_IGNORE;
1957 /* The core isn't interested in this event. For efficiency, avoid
1958 stopping all threads only to have the core resume them all again.
1959 Since we're not stopping threads, if we're still syscall tracing
1960 and not stepping, we can't use PTRACE_CONT here, as we'd miss any
1961 subsequent syscall. Simply resume using the inf-ptrace layer,
1962 which knows when to use PT_SYSCALL or PT_CONTINUE. */
1964 /* Note that gdbarch_get_syscall_number may access registers, hence
1966 registers_changed ();
1967 if (linux_nat_prepare_to_resume != NULL)
1968 linux_nat_prepare_to_resume (lp);
1969 linux_ops->to_resume (linux_ops, pid_to_ptid (ptid_get_lwp (lp->ptid)),
1970 lp->step, GDB_SIGNAL_0);
1974 /* Handle a GNU/Linux extended wait response. If we see a clone
1975 event, we need to add the new LWP to our list (and not report the
1976 trap to higher layers). This function returns non-zero if the
1977 event should be ignored and we should wait again. If STOPPING is
1978 true, the new LWP remains stopped, otherwise it is continued. */
1981 linux_handle_extended_wait (struct lwp_info *lp, int status,
1984 int pid = ptid_get_lwp (lp->ptid);
1985 struct target_waitstatus *ourstatus = &lp->waitstatus;
1986 int event = status >> 16;
1988 if (event == PTRACE_EVENT_FORK || event == PTRACE_EVENT_VFORK
1989 || event == PTRACE_EVENT_CLONE)
1991 unsigned long new_pid;
1994 ptrace (PTRACE_GETEVENTMSG, pid, 0, &new_pid);
1996 /* If we haven't already seen the new PID stop, wait for it now. */
1997 if (! pull_pid_from_list (&stopped_pids, new_pid, &status))
1999 /* The new child has a pending SIGSTOP. We can't affect it until it
2000 hits the SIGSTOP, but we're already attached. */
2001 ret = my_waitpid (new_pid, &status,
2002 (event == PTRACE_EVENT_CLONE) ? __WCLONE : 0);
2004 perror_with_name (_("waiting for new child"));
2005 else if (ret != new_pid)
2006 internal_error (__FILE__, __LINE__,
2007 _("wait returned unexpected PID %d"), ret);
2008 else if (!WIFSTOPPED (status))
2009 internal_error (__FILE__, __LINE__,
2010 _("wait returned unexpected status 0x%x"), status);
2013 ourstatus->value.related_pid = ptid_build (new_pid, new_pid, 0);
2015 if (event == PTRACE_EVENT_FORK || event == PTRACE_EVENT_VFORK)
2017 /* The arch-specific native code may need to know about new
2018 forks even if those end up never mapped to an
2020 if (linux_nat_new_fork != NULL)
2021 linux_nat_new_fork (lp, new_pid);
2024 if (event == PTRACE_EVENT_FORK
2025 && linux_fork_checkpointing_p (ptid_get_pid (lp->ptid)))
2027 /* Handle checkpointing by linux-fork.c here as a special
2028 case. We don't want the follow-fork-mode or 'catch fork'
2029 to interfere with this. */
2031 /* This won't actually modify the breakpoint list, but will
2032 physically remove the breakpoints from the child. */
2033 detach_breakpoints (ptid_build (new_pid, new_pid, 0));
2035 /* Retain child fork in ptrace (stopped) state. */
2036 if (!find_fork_pid (new_pid))
2039 /* Report as spurious, so that infrun doesn't want to follow
2040 this fork. We're actually doing an infcall in
2042 ourstatus->kind = TARGET_WAITKIND_SPURIOUS;
2044 /* Report the stop to the core. */
2048 if (event == PTRACE_EVENT_FORK)
2049 ourstatus->kind = TARGET_WAITKIND_FORKED;
2050 else if (event == PTRACE_EVENT_VFORK)
2051 ourstatus->kind = TARGET_WAITKIND_VFORKED;
2054 struct lwp_info *new_lp;
2056 ourstatus->kind = TARGET_WAITKIND_IGNORE;
2058 if (debug_linux_nat)
2059 fprintf_unfiltered (gdb_stdlog,
2060 "LHEW: Got clone event "
2061 "from LWP %d, new child is LWP %ld\n",
2064 new_lp = add_lwp (ptid_build (ptid_get_pid (lp->ptid), new_pid, 0));
2066 new_lp->stopped = 1;
2068 if (WSTOPSIG (status) != SIGSTOP)
2070 /* This can happen if someone starts sending signals to
2071 the new thread before it gets a chance to run, which
2072 have a lower number than SIGSTOP (e.g. SIGUSR1).
2073 This is an unlikely case, and harder to handle for
2074 fork / vfork than for clone, so we do not try - but
2075 we handle it for clone events here. We'll send
2076 the other signal on to the thread below. */
2078 new_lp->signalled = 1;
2082 struct thread_info *tp;
2084 /* When we stop for an event in some other thread, and
2085 pull the thread list just as this thread has cloned,
2086 we'll have seen the new thread in the thread_db list
2087 before handling the CLONE event (glibc's
2088 pthread_create adds the new thread to the thread list
2089 before clone'ing, and has the kernel fill in the
2090 thread's tid on the clone call with
2091 CLONE_PARENT_SETTID). If that happened, and the core
2092 had requested the new thread to stop, we'll have
2093 killed it with SIGSTOP. But since SIGSTOP is not an
2094 RT signal, it can only be queued once. We need to be
2095 careful to not resume the LWP if we wanted it to
2096 stop. In that case, we'll leave the SIGSTOP pending.
2097 It will later be reported as GDB_SIGNAL_0. */
2098 tp = find_thread_ptid (new_lp->ptid);
2099 if (tp != NULL && tp->stop_requested)
2100 new_lp->last_resume_kind = resume_stop;
2107 /* Add the new thread to GDB's lists as soon as possible
2110 1) the frontend doesn't have to wait for a stop to
2113 2) we tag it with the correct running state. */
2115 /* If the thread_db layer is active, let it know about
2116 this new thread, and add it to GDB's list. */
2117 if (!thread_db_attach_lwp (new_lp->ptid))
2119 /* We're not using thread_db. Add it to GDB's
2121 target_post_attach (ptid_get_lwp (new_lp->ptid));
2122 add_thread (new_lp->ptid);
2127 set_running (new_lp->ptid, 1);
2128 set_executing (new_lp->ptid, 1);
2129 /* thread_db_attach_lwp -> lin_lwp_attach_lwp forced
2131 new_lp->last_resume_kind = resume_continue;
2137 /* We created NEW_LP so it cannot yet contain STATUS. */
2138 gdb_assert (new_lp->status == 0);
2140 /* Save the wait status to report later. */
2141 if (debug_linux_nat)
2142 fprintf_unfiltered (gdb_stdlog,
2143 "LHEW: waitpid of new LWP %ld, "
2144 "saving status %s\n",
2145 (long) ptid_get_lwp (new_lp->ptid),
2146 status_to_str (status));
2147 new_lp->status = status;
2150 /* Note the need to use the low target ops to resume, to
2151 handle resuming with PT_SYSCALL if we have syscall
2155 new_lp->resumed = 1;
2159 gdb_assert (new_lp->last_resume_kind == resume_continue);
2160 if (debug_linux_nat)
2161 fprintf_unfiltered (gdb_stdlog,
2162 "LHEW: resuming new LWP %ld\n",
2163 ptid_get_lwp (new_lp->ptid));
2164 if (linux_nat_prepare_to_resume != NULL)
2165 linux_nat_prepare_to_resume (new_lp);
2166 linux_ops->to_resume (linux_ops, pid_to_ptid (new_pid),
2168 new_lp->stopped = 0;
2172 if (debug_linux_nat)
2173 fprintf_unfiltered (gdb_stdlog,
2174 "LHEW: resuming parent LWP %d\n", pid);
2175 if (linux_nat_prepare_to_resume != NULL)
2176 linux_nat_prepare_to_resume (lp);
2177 linux_ops->to_resume (linux_ops,
2178 pid_to_ptid (ptid_get_lwp (lp->ptid)),
2187 if (event == PTRACE_EVENT_EXEC)
2189 if (debug_linux_nat)
2190 fprintf_unfiltered (gdb_stdlog,
2191 "LHEW: Got exec event from LWP %ld\n",
2192 ptid_get_lwp (lp->ptid));
2194 ourstatus->kind = TARGET_WAITKIND_EXECD;
2195 ourstatus->value.execd_pathname
2196 = xstrdup (linux_child_pid_to_exec_file (NULL, pid));
2201 if (event == PTRACE_EVENT_VFORK_DONE)
2203 if (current_inferior ()->waiting_for_vfork_done)
2205 if (debug_linux_nat)
2206 fprintf_unfiltered (gdb_stdlog,
2207 "LHEW: Got expected PTRACE_EVENT_"
2208 "VFORK_DONE from LWP %ld: stopping\n",
2209 ptid_get_lwp (lp->ptid));
2211 ourstatus->kind = TARGET_WAITKIND_VFORK_DONE;
2215 if (debug_linux_nat)
2216 fprintf_unfiltered (gdb_stdlog,
2217 "LHEW: Got PTRACE_EVENT_VFORK_DONE "
2218 "from LWP %ld: resuming\n",
2219 ptid_get_lwp (lp->ptid));
2220 ptrace (PTRACE_CONT, ptid_get_lwp (lp->ptid), 0, 0);
2224 internal_error (__FILE__, __LINE__,
2225 _("unknown ptrace event %d"), event);
2228 /* Wait for LP to stop. Returns the wait status, or 0 if the LWP has
2232 wait_lwp (struct lwp_info *lp)
2236 int thread_dead = 0;
2239 gdb_assert (!lp->stopped);
2240 gdb_assert (lp->status == 0);
2242 /* Make sure SIGCHLD is blocked for sigsuspend avoiding a race below. */
2243 block_child_signals (&prev_mask);
2247 /* If my_waitpid returns 0 it means the __WCLONE vs. non-__WCLONE kind
2248 was right and we should just call sigsuspend. */
2250 pid = my_waitpid (ptid_get_lwp (lp->ptid), &status, WNOHANG);
2251 if (pid == -1 && errno == ECHILD)
2252 pid = my_waitpid (ptid_get_lwp (lp->ptid), &status, __WCLONE | WNOHANG);
2253 if (pid == -1 && errno == ECHILD)
2255 /* The thread has previously exited. We need to delete it
2256 now because, for some vendor 2.4 kernels with NPTL
2257 support backported, there won't be an exit event unless
2258 it is the main thread. 2.6 kernels will report an exit
2259 event for each thread that exits, as expected. */
2261 if (debug_linux_nat)
2262 fprintf_unfiltered (gdb_stdlog, "WL: %s vanished.\n",
2263 target_pid_to_str (lp->ptid));
2268 /* Bugs 10970, 12702.
2269 Thread group leader may have exited in which case we'll lock up in
2270 waitpid if there are other threads, even if they are all zombies too.
2271 Basically, we're not supposed to use waitpid this way.
2272 __WCLONE is not applicable for the leader so we can't use that.
2273 LINUX_NAT_THREAD_ALIVE cannot be used here as it requires a STOPPED
2274 process; it gets ESRCH both for the zombie and for running processes.
2276 As a workaround, check if we're waiting for the thread group leader and
2277 if it's a zombie, and avoid calling waitpid if it is.
2279 This is racy, what if the tgl becomes a zombie right after we check?
2280 Therefore always use WNOHANG with sigsuspend - it is equivalent to
2281 waiting waitpid but linux_proc_pid_is_zombie is safe this way. */
2283 if (ptid_get_pid (lp->ptid) == ptid_get_lwp (lp->ptid)
2284 && linux_proc_pid_is_zombie (ptid_get_lwp (lp->ptid)))
2287 if (debug_linux_nat)
2288 fprintf_unfiltered (gdb_stdlog,
2289 "WL: Thread group leader %s vanished.\n",
2290 target_pid_to_str (lp->ptid));
2294 /* Wait for next SIGCHLD and try again. This may let SIGCHLD handlers
2295 get invoked despite our caller had them intentionally blocked by
2296 block_child_signals. This is sensitive only to the loop of
2297 linux_nat_wait_1 and there if we get called my_waitpid gets called
2298 again before it gets to sigsuspend so we can safely let the handlers
2299 get executed here. */
2301 sigsuspend (&suspend_mask);
2304 restore_child_signals_mask (&prev_mask);
2308 gdb_assert (pid == ptid_get_lwp (lp->ptid));
2310 if (debug_linux_nat)
2312 fprintf_unfiltered (gdb_stdlog,
2313 "WL: waitpid %s received %s\n",
2314 target_pid_to_str (lp->ptid),
2315 status_to_str (status));
2318 /* Check if the thread has exited. */
2319 if (WIFEXITED (status) || WIFSIGNALED (status))
2322 if (debug_linux_nat)
2323 fprintf_unfiltered (gdb_stdlog, "WL: %s exited.\n",
2324 target_pid_to_str (lp->ptid));
2334 gdb_assert (WIFSTOPPED (status));
2336 /* Handle GNU/Linux's syscall SIGTRAPs. */
2337 if (WIFSTOPPED (status) && WSTOPSIG (status) == SYSCALL_SIGTRAP)
2339 /* No longer need the sysgood bit. The ptrace event ends up
2340 recorded in lp->waitstatus if we care for it. We can carry
2341 on handling the event like a regular SIGTRAP from here
2343 status = W_STOPCODE (SIGTRAP);
2344 if (linux_handle_syscall_trap (lp, 1))
2345 return wait_lwp (lp);
2348 /* Handle GNU/Linux's extended waitstatus for trace events. */
2349 if (WIFSTOPPED (status) && WSTOPSIG (status) == SIGTRAP && status >> 16 != 0)
2351 if (debug_linux_nat)
2352 fprintf_unfiltered (gdb_stdlog,
2353 "WL: Handling extended status 0x%06x\n",
2355 if (linux_handle_extended_wait (lp, status, 1))
2356 return wait_lwp (lp);
2362 /* Send a SIGSTOP to LP. */
2365 stop_callback (struct lwp_info *lp, void *data)
2367 if (!lp->stopped && !lp->signalled)
2371 if (debug_linux_nat)
2373 fprintf_unfiltered (gdb_stdlog,
2374 "SC: kill %s **<SIGSTOP>**\n",
2375 target_pid_to_str (lp->ptid));
2378 ret = kill_lwp (ptid_get_lwp (lp->ptid), SIGSTOP);
2379 if (debug_linux_nat)
2381 fprintf_unfiltered (gdb_stdlog,
2382 "SC: lwp kill %d %s\n",
2384 errno ? safe_strerror (errno) : "ERRNO-OK");
2388 gdb_assert (lp->status == 0);
2394 /* Request a stop on LWP. */
2397 linux_stop_lwp (struct lwp_info *lwp)
2399 stop_callback (lwp, NULL);
2402 /* Return non-zero if LWP PID has a pending SIGINT. */
2405 linux_nat_has_pending_sigint (int pid)
2407 sigset_t pending, blocked, ignored;
2409 linux_proc_pending_signals (pid, &pending, &blocked, &ignored);
2411 if (sigismember (&pending, SIGINT)
2412 && !sigismember (&ignored, SIGINT))
2418 /* Set a flag in LP indicating that we should ignore its next SIGINT. */
2421 set_ignore_sigint (struct lwp_info *lp, void *data)
2423 /* If a thread has a pending SIGINT, consume it; otherwise, set a
2424 flag to consume the next one. */
2425 if (lp->stopped && lp->status != 0 && WIFSTOPPED (lp->status)
2426 && WSTOPSIG (lp->status) == SIGINT)
2429 lp->ignore_sigint = 1;
2434 /* If LP does not have a SIGINT pending, then clear the ignore_sigint flag.
2435 This function is called after we know the LWP has stopped; if the LWP
2436 stopped before the expected SIGINT was delivered, then it will never have
2437 arrived. Also, if the signal was delivered to a shared queue and consumed
2438 by a different thread, it will never be delivered to this LWP. */
2441 maybe_clear_ignore_sigint (struct lwp_info *lp)
2443 if (!lp->ignore_sigint)
2446 if (!linux_nat_has_pending_sigint (ptid_get_lwp (lp->ptid)))
2448 if (debug_linux_nat)
2449 fprintf_unfiltered (gdb_stdlog,
2450 "MCIS: Clearing bogus flag for %s\n",
2451 target_pid_to_str (lp->ptid));
2452 lp->ignore_sigint = 0;
2456 /* Fetch the possible triggered data watchpoint info and store it in
2459 On some archs, like x86, that use debug registers to set
2460 watchpoints, it's possible that the way to know which watched
2461 address trapped, is to check the register that is used to select
2462 which address to watch. Problem is, between setting the watchpoint
2463 and reading back which data address trapped, the user may change
2464 the set of watchpoints, and, as a consequence, GDB changes the
2465 debug registers in the inferior. To avoid reading back a stale
2466 stopped-data-address when that happens, we cache in LP the fact
2467 that a watchpoint trapped, and the corresponding data address, as
2468 soon as we see LP stop with a SIGTRAP. If GDB changes the debug
2469 registers meanwhile, we have the cached data we can rely on. */
2472 save_sigtrap (struct lwp_info *lp)
2474 struct cleanup *old_chain;
2476 if (linux_ops->to_stopped_by_watchpoint == NULL)
2478 lp->stopped_by_watchpoint = 0;
2482 old_chain = save_inferior_ptid ();
2483 inferior_ptid = lp->ptid;
2485 lp->stopped_by_watchpoint = linux_ops->to_stopped_by_watchpoint (linux_ops);
2487 if (lp->stopped_by_watchpoint)
2489 if (linux_ops->to_stopped_data_address != NULL)
2490 lp->stopped_data_address_p =
2491 linux_ops->to_stopped_data_address (¤t_target,
2492 &lp->stopped_data_address);
2494 lp->stopped_data_address_p = 0;
2497 do_cleanups (old_chain);
2500 /* See save_sigtrap. */
2503 linux_nat_stopped_by_watchpoint (struct target_ops *ops)
2505 struct lwp_info *lp = find_lwp_pid (inferior_ptid);
2507 gdb_assert (lp != NULL);
2509 return lp->stopped_by_watchpoint;
2513 linux_nat_stopped_data_address (struct target_ops *ops, CORE_ADDR *addr_p)
2515 struct lwp_info *lp = find_lwp_pid (inferior_ptid);
2517 gdb_assert (lp != NULL);
2519 *addr_p = lp->stopped_data_address;
2521 return lp->stopped_data_address_p;
2524 /* Commonly any breakpoint / watchpoint generate only SIGTRAP. */
2527 sigtrap_is_event (int status)
2529 return WIFSTOPPED (status) && WSTOPSIG (status) == SIGTRAP;
2532 /* SIGTRAP-like events recognizer. */
2534 static int (*linux_nat_status_is_event) (int status) = sigtrap_is_event;
2536 /* Check for SIGTRAP-like events in LP. */
2539 linux_nat_lp_status_is_event (struct lwp_info *lp)
2541 /* We check for lp->waitstatus in addition to lp->status, because we can
2542 have pending process exits recorded in lp->status
2543 and W_EXITCODE(0,0) == 0. We should probably have an additional
2544 lp->status_p flag. */
2546 return (lp->waitstatus.kind == TARGET_WAITKIND_IGNORE
2547 && linux_nat_status_is_event (lp->status));
2550 /* Set alternative SIGTRAP-like events recognizer. If
2551 breakpoint_inserted_here_p there then gdbarch_decr_pc_after_break will be
2555 linux_nat_set_status_is_event (struct target_ops *t,
2556 int (*status_is_event) (int status))
2558 linux_nat_status_is_event = status_is_event;
2561 /* Wait until LP is stopped. */
2564 stop_wait_callback (struct lwp_info *lp, void *data)
2566 struct inferior *inf = find_inferior_pid (ptid_get_pid (lp->ptid));
2568 /* If this is a vfork parent, bail out, it is not going to report
2569 any SIGSTOP until the vfork is done with. */
2570 if (inf->vfork_child != NULL)
2577 status = wait_lwp (lp);
2581 if (lp->ignore_sigint && WIFSTOPPED (status)
2582 && WSTOPSIG (status) == SIGINT)
2584 lp->ignore_sigint = 0;
2587 ptrace (PTRACE_CONT, ptid_get_lwp (lp->ptid), 0, 0);
2588 if (debug_linux_nat)
2589 fprintf_unfiltered (gdb_stdlog,
2590 "PTRACE_CONT %s, 0, 0 (%s) "
2591 "(discarding SIGINT)\n",
2592 target_pid_to_str (lp->ptid),
2593 errno ? safe_strerror (errno) : "OK");
2595 return stop_wait_callback (lp, NULL);
2598 maybe_clear_ignore_sigint (lp);
2600 if (WSTOPSIG (status) != SIGSTOP)
2602 /* The thread was stopped with a signal other than SIGSTOP. */
2606 if (debug_linux_nat)
2607 fprintf_unfiltered (gdb_stdlog,
2608 "SWC: Pending event %s in %s\n",
2609 status_to_str ((int) status),
2610 target_pid_to_str (lp->ptid));
2612 /* Save the sigtrap event. */
2613 lp->status = status;
2614 gdb_assert (!lp->stopped);
2615 gdb_assert (lp->signalled);
2620 /* We caught the SIGSTOP that we intended to catch, so
2621 there's no SIGSTOP pending. */
2623 if (debug_linux_nat)
2624 fprintf_unfiltered (gdb_stdlog,
2625 "SWC: Delayed SIGSTOP caught for %s.\n",
2626 target_pid_to_str (lp->ptid));
2630 /* Reset SIGNALLED only after the stop_wait_callback call
2631 above as it does gdb_assert on SIGNALLED. */
2639 /* Return non-zero if LP has a wait status pending. */
2642 status_callback (struct lwp_info *lp, void *data)
2644 /* Only report a pending wait status if we pretend that this has
2645 indeed been resumed. */
2649 if (lp->waitstatus.kind != TARGET_WAITKIND_IGNORE)
2651 /* A ptrace event, like PTRACE_FORK|VFORK|EXEC, syscall event,
2652 or a pending process exit. Note that `W_EXITCODE(0,0) ==
2653 0', so a clean process exit can not be stored pending in
2654 lp->status, it is indistinguishable from
2655 no-pending-status. */
2659 if (lp->status != 0)
2665 /* Return non-zero if LP isn't stopped. */
2668 running_callback (struct lwp_info *lp, void *data)
2670 return (!lp->stopped
2671 || ((lp->status != 0
2672 || lp->waitstatus.kind != TARGET_WAITKIND_IGNORE)
2676 /* Count the LWP's that have had events. */
2679 count_events_callback (struct lwp_info *lp, void *data)
2683 gdb_assert (count != NULL);
2685 /* Count only resumed LWPs that have a SIGTRAP event pending. */
2686 if (lp->resumed && linux_nat_lp_status_is_event (lp))
2692 /* Select the LWP (if any) that is currently being single-stepped. */
2695 select_singlestep_lwp_callback (struct lwp_info *lp, void *data)
2697 if (lp->last_resume_kind == resume_step
2704 /* Select the Nth LWP that has had a SIGTRAP event. */
2707 select_event_lwp_callback (struct lwp_info *lp, void *data)
2709 int *selector = data;
2711 gdb_assert (selector != NULL);
2713 /* Select only resumed LWPs that have a SIGTRAP event pending. */
2714 if (lp->resumed && linux_nat_lp_status_is_event (lp))
2715 if ((*selector)-- == 0)
2722 cancel_breakpoint (struct lwp_info *lp)
2724 /* Arrange for a breakpoint to be hit again later. We don't keep
2725 the SIGTRAP status and don't forward the SIGTRAP signal to the
2726 LWP. We will handle the current event, eventually we will resume
2727 this LWP, and this breakpoint will trap again.
2729 If we do not do this, then we run the risk that the user will
2730 delete or disable the breakpoint, but the LWP will have already
2733 struct regcache *regcache = get_thread_regcache (lp->ptid);
2734 struct gdbarch *gdbarch = get_regcache_arch (regcache);
2737 pc = regcache_read_pc (regcache) - target_decr_pc_after_break (gdbarch);
2738 if (breakpoint_inserted_here_p (get_regcache_aspace (regcache), pc))
2740 if (debug_linux_nat)
2741 fprintf_unfiltered (gdb_stdlog,
2742 "CB: Push back breakpoint for %s\n",
2743 target_pid_to_str (lp->ptid));
2745 /* Back up the PC if necessary. */
2746 if (target_decr_pc_after_break (gdbarch))
2747 regcache_write_pc (regcache, pc);
2755 cancel_breakpoints_callback (struct lwp_info *lp, void *data)
2757 struct lwp_info *event_lp = data;
2759 /* Leave the LWP that has been elected to receive a SIGTRAP alone. */
2763 /* If a LWP other than the LWP that we're reporting an event for has
2764 hit a GDB breakpoint (as opposed to some random trap signal),
2765 then just arrange for it to hit it again later. We don't keep
2766 the SIGTRAP status and don't forward the SIGTRAP signal to the
2767 LWP. We will handle the current event, eventually we will resume
2768 all LWPs, and this one will get its breakpoint trap again.
2770 If we do not do this, then we run the risk that the user will
2771 delete or disable the breakpoint, but the LWP will have already
2774 if (linux_nat_lp_status_is_event (lp)
2775 && cancel_breakpoint (lp))
2776 /* Throw away the SIGTRAP. */
2782 /* Select one LWP out of those that have events pending. */
2785 select_event_lwp (ptid_t filter, struct lwp_info **orig_lp, int *status)
2788 int random_selector;
2789 struct lwp_info *event_lp;
2791 /* Record the wait status for the original LWP. */
2792 (*orig_lp)->status = *status;
2794 /* Give preference to any LWP that is being single-stepped. */
2795 event_lp = iterate_over_lwps (filter,
2796 select_singlestep_lwp_callback, NULL);
2797 if (event_lp != NULL)
2799 if (debug_linux_nat)
2800 fprintf_unfiltered (gdb_stdlog,
2801 "SEL: Select single-step %s\n",
2802 target_pid_to_str (event_lp->ptid));
2806 /* No single-stepping LWP. Select one at random, out of those
2807 which have had SIGTRAP events. */
2809 /* First see how many SIGTRAP events we have. */
2810 iterate_over_lwps (filter, count_events_callback, &num_events);
2812 /* Now randomly pick a LWP out of those that have had a SIGTRAP. */
2813 random_selector = (int)
2814 ((num_events * (double) rand ()) / (RAND_MAX + 1.0));
2816 if (debug_linux_nat && num_events > 1)
2817 fprintf_unfiltered (gdb_stdlog,
2818 "SEL: Found %d SIGTRAP events, selecting #%d\n",
2819 num_events, random_selector);
2821 event_lp = iterate_over_lwps (filter,
2822 select_event_lwp_callback,
2826 if (event_lp != NULL)
2828 /* Switch the event LWP. */
2829 *orig_lp = event_lp;
2830 *status = event_lp->status;
2833 /* Flush the wait status for the event LWP. */
2834 (*orig_lp)->status = 0;
2837 /* Return non-zero if LP has been resumed. */
2840 resumed_callback (struct lwp_info *lp, void *data)
2845 /* Stop an active thread, verify it still exists, then resume it. If
2846 the thread ends up with a pending status, then it is not resumed,
2847 and *DATA (really a pointer to int), is set. */
2850 stop_and_resume_callback (struct lwp_info *lp, void *data)
2852 int *new_pending_p = data;
2856 ptid_t ptid = lp->ptid;
2858 stop_callback (lp, NULL);
2859 stop_wait_callback (lp, NULL);
2861 /* Resume if the lwp still exists, and the core wanted it
2863 lp = find_lwp_pid (ptid);
2866 if (lp->last_resume_kind == resume_stop
2869 /* The core wanted the LWP to stop. Even if it stopped
2870 cleanly (with SIGSTOP), leave the event pending. */
2871 if (debug_linux_nat)
2872 fprintf_unfiltered (gdb_stdlog,
2873 "SARC: core wanted LWP %ld stopped "
2874 "(leaving SIGSTOP pending)\n",
2875 ptid_get_lwp (lp->ptid));
2876 lp->status = W_STOPCODE (SIGSTOP);
2879 if (lp->status == 0)
2881 if (debug_linux_nat)
2882 fprintf_unfiltered (gdb_stdlog,
2883 "SARC: re-resuming LWP %ld\n",
2884 ptid_get_lwp (lp->ptid));
2885 resume_lwp (lp, lp->step, GDB_SIGNAL_0);
2889 if (debug_linux_nat)
2890 fprintf_unfiltered (gdb_stdlog,
2891 "SARC: not re-resuming LWP %ld "
2893 ptid_get_lwp (lp->ptid));
2902 /* Check if we should go on and pass this event to common code.
2903 Return the affected lwp if we are, or NULL otherwise. If we stop
2904 all lwps temporarily, we may end up with new pending events in some
2905 other lwp. In that case set *NEW_PENDING_P to true. */
2907 static struct lwp_info *
2908 linux_nat_filter_event (int lwpid, int status, int *new_pending_p)
2910 struct lwp_info *lp;
2914 lp = find_lwp_pid (pid_to_ptid (lwpid));
2916 /* Check for stop events reported by a process we didn't already
2917 know about - anything not already in our LWP list.
2919 If we're expecting to receive stopped processes after
2920 fork, vfork, and clone events, then we'll just add the
2921 new one to our list and go back to waiting for the event
2922 to be reported - the stopped process might be returned
2923 from waitpid before or after the event is.
2925 But note the case of a non-leader thread exec'ing after the
2926 leader having exited, and gone from our lists. The non-leader
2927 thread changes its tid to the tgid. */
2929 if (WIFSTOPPED (status) && lp == NULL
2930 && (WSTOPSIG (status) == SIGTRAP && status >> 16 == PTRACE_EVENT_EXEC))
2932 /* A multi-thread exec after we had seen the leader exiting. */
2933 if (debug_linux_nat)
2934 fprintf_unfiltered (gdb_stdlog,
2935 "LLW: Re-adding thread group leader LWP %d.\n",
2938 lp = add_lwp (ptid_build (lwpid, lwpid, 0));
2941 add_thread (lp->ptid);
2944 if (WIFSTOPPED (status) && !lp)
2946 add_to_pid_list (&stopped_pids, lwpid, status);
2950 /* Make sure we don't report an event for the exit of an LWP not in
2951 our list, i.e. not part of the current process. This can happen
2952 if we detach from a program we originally forked and then it
2954 if (!WIFSTOPPED (status) && !lp)
2957 /* Handle GNU/Linux's syscall SIGTRAPs. */
2958 if (WIFSTOPPED (status) && WSTOPSIG (status) == SYSCALL_SIGTRAP)
2960 /* No longer need the sysgood bit. The ptrace event ends up
2961 recorded in lp->waitstatus if we care for it. We can carry
2962 on handling the event like a regular SIGTRAP from here
2964 status = W_STOPCODE (SIGTRAP);
2965 if (linux_handle_syscall_trap (lp, 0))
2969 /* Handle GNU/Linux's extended waitstatus for trace events. */
2970 if (WIFSTOPPED (status) && WSTOPSIG (status) == SIGTRAP && status >> 16 != 0)
2972 if (debug_linux_nat)
2973 fprintf_unfiltered (gdb_stdlog,
2974 "LLW: Handling extended status 0x%06x\n",
2976 if (linux_handle_extended_wait (lp, status, 0))
2980 if (linux_nat_status_is_event (status))
2983 /* Check if the thread has exited. */
2984 if ((WIFEXITED (status) || WIFSIGNALED (status))
2985 && num_lwps (ptid_get_pid (lp->ptid)) > 1)
2987 /* If this is the main thread, we must stop all threads and verify
2988 if they are still alive. This is because in the nptl thread model
2989 on Linux 2.4, there is no signal issued for exiting LWPs
2990 other than the main thread. We only get the main thread exit
2991 signal once all child threads have already exited. If we
2992 stop all the threads and use the stop_wait_callback to check
2993 if they have exited we can determine whether this signal
2994 should be ignored or whether it means the end of the debugged
2995 application, regardless of which threading model is being
2997 if (ptid_get_pid (lp->ptid) == ptid_get_lwp (lp->ptid))
3000 iterate_over_lwps (pid_to_ptid (ptid_get_pid (lp->ptid)),
3001 stop_and_resume_callback, new_pending_p);
3004 if (debug_linux_nat)
3005 fprintf_unfiltered (gdb_stdlog,
3006 "LLW: %s exited.\n",
3007 target_pid_to_str (lp->ptid));
3009 if (num_lwps (ptid_get_pid (lp->ptid)) > 1)
3011 /* If there is at least one more LWP, then the exit signal
3012 was not the end of the debugged application and should be
3019 /* Check if the current LWP has previously exited. In the nptl
3020 thread model, LWPs other than the main thread do not issue
3021 signals when they exit so we must check whenever the thread has
3022 stopped. A similar check is made in stop_wait_callback(). */
3023 if (num_lwps (ptid_get_pid (lp->ptid)) > 1 && !linux_thread_alive (lp->ptid))
3025 ptid_t ptid = pid_to_ptid (ptid_get_pid (lp->ptid));
3027 if (debug_linux_nat)
3028 fprintf_unfiltered (gdb_stdlog,
3029 "LLW: %s exited.\n",
3030 target_pid_to_str (lp->ptid));
3034 /* Make sure there is at least one thread running. */
3035 gdb_assert (iterate_over_lwps (ptid, running_callback, NULL));
3037 /* Discard the event. */
3041 /* Make sure we don't report a SIGSTOP that we sent ourselves in
3042 an attempt to stop an LWP. */
3044 && WIFSTOPPED (status) && WSTOPSIG (status) == SIGSTOP)
3046 if (debug_linux_nat)
3047 fprintf_unfiltered (gdb_stdlog,
3048 "LLW: Delayed SIGSTOP caught for %s.\n",
3049 target_pid_to_str (lp->ptid));
3053 if (lp->last_resume_kind != resume_stop)
3055 /* This is a delayed SIGSTOP. */
3057 registers_changed ();
3059 if (linux_nat_prepare_to_resume != NULL)
3060 linux_nat_prepare_to_resume (lp);
3061 linux_ops->to_resume (linux_ops,
3062 pid_to_ptid (ptid_get_lwp (lp->ptid)),
3063 lp->step, GDB_SIGNAL_0);
3064 if (debug_linux_nat)
3065 fprintf_unfiltered (gdb_stdlog,
3066 "LLW: %s %s, 0, 0 (discard SIGSTOP)\n",
3068 "PTRACE_SINGLESTEP" : "PTRACE_CONT",
3069 target_pid_to_str (lp->ptid));
3072 gdb_assert (lp->resumed);
3074 /* Discard the event. */
3079 /* Make sure we don't report a SIGINT that we have already displayed
3080 for another thread. */
3081 if (lp->ignore_sigint
3082 && WIFSTOPPED (status) && WSTOPSIG (status) == SIGINT)
3084 if (debug_linux_nat)
3085 fprintf_unfiltered (gdb_stdlog,
3086 "LLW: Delayed SIGINT caught for %s.\n",
3087 target_pid_to_str (lp->ptid));
3089 /* This is a delayed SIGINT. */
3090 lp->ignore_sigint = 0;
3092 registers_changed ();
3093 if (linux_nat_prepare_to_resume != NULL)
3094 linux_nat_prepare_to_resume (lp);
3095 linux_ops->to_resume (linux_ops, pid_to_ptid (ptid_get_lwp (lp->ptid)),
3096 lp->step, GDB_SIGNAL_0);
3097 if (debug_linux_nat)
3098 fprintf_unfiltered (gdb_stdlog,
3099 "LLW: %s %s, 0, 0 (discard SIGINT)\n",
3101 "PTRACE_SINGLESTEP" : "PTRACE_CONT",
3102 target_pid_to_str (lp->ptid));
3105 gdb_assert (lp->resumed);
3107 /* Discard the event. */
3111 /* An interesting event. */
3113 lp->status = status;
3117 /* Detect zombie thread group leaders, and "exit" them. We can't reap
3118 their exits until all other threads in the group have exited. */
3121 check_zombie_leaders (void)
3123 struct inferior *inf;
3127 struct lwp_info *leader_lp;
3132 leader_lp = find_lwp_pid (pid_to_ptid (inf->pid));
3133 if (leader_lp != NULL
3134 /* Check if there are other threads in the group, as we may
3135 have raced with the inferior simply exiting. */
3136 && num_lwps (inf->pid) > 1
3137 && linux_proc_pid_is_zombie (inf->pid))
3139 if (debug_linux_nat)
3140 fprintf_unfiltered (gdb_stdlog,
3141 "CZL: Thread group leader %d zombie "
3142 "(it exited, or another thread execd).\n",
3145 /* A leader zombie can mean one of two things:
3147 - It exited, and there's an exit status pending
3148 available, or only the leader exited (not the whole
3149 program). In the latter case, we can't waitpid the
3150 leader's exit status until all other threads are gone.
3152 - There are 3 or more threads in the group, and a thread
3153 other than the leader exec'd. On an exec, the Linux
3154 kernel destroys all other threads (except the execing
3155 one) in the thread group, and resets the execing thread's
3156 tid to the tgid. No exit notification is sent for the
3157 execing thread -- from the ptracer's perspective, it
3158 appears as though the execing thread just vanishes.
3159 Until we reap all other threads except the leader and the
3160 execing thread, the leader will be zombie, and the
3161 execing thread will be in `D (disc sleep)'. As soon as
3162 all other threads are reaped, the execing thread changes
3163 it's tid to the tgid, and the previous (zombie) leader
3164 vanishes, giving place to the "new" leader. We could try
3165 distinguishing the exit and exec cases, by waiting once
3166 more, and seeing if something comes out, but it doesn't
3167 sound useful. The previous leader _does_ go away, and
3168 we'll re-add the new one once we see the exec event
3169 (which is just the same as what would happen if the
3170 previous leader did exit voluntarily before some other
3173 if (debug_linux_nat)
3174 fprintf_unfiltered (gdb_stdlog,
3175 "CZL: Thread group leader %d vanished.\n",
3177 exit_lwp (leader_lp);
3183 linux_nat_wait_1 (struct target_ops *ops,
3184 ptid_t ptid, struct target_waitstatus *ourstatus,
3187 static sigset_t prev_mask;
3188 enum resume_kind last_resume_kind;
3189 struct lwp_info *lp;
3192 if (debug_linux_nat)
3193 fprintf_unfiltered (gdb_stdlog, "LLW: enter\n");
3195 /* The first time we get here after starting a new inferior, we may
3196 not have added it to the LWP list yet - this is the earliest
3197 moment at which we know its PID. */
3198 if (ptid_is_pid (inferior_ptid))
3200 /* Upgrade the main thread's ptid. */
3201 thread_change_ptid (inferior_ptid,
3202 ptid_build (ptid_get_pid (inferior_ptid),
3203 ptid_get_pid (inferior_ptid), 0));
3205 lp = add_initial_lwp (inferior_ptid);
3209 /* Make sure SIGCHLD is blocked until the sigsuspend below. */
3210 block_child_signals (&prev_mask);
3216 /* First check if there is a LWP with a wait status pending. */
3217 if (ptid_equal (ptid, minus_one_ptid) || ptid_is_pid (ptid))
3219 /* Any LWP in the PTID group that's been resumed will do. */
3220 lp = iterate_over_lwps (ptid, status_callback, NULL);
3223 if (debug_linux_nat && lp->status)
3224 fprintf_unfiltered (gdb_stdlog,
3225 "LLW: Using pending wait status %s for %s.\n",
3226 status_to_str (lp->status),
3227 target_pid_to_str (lp->ptid));
3230 else if (ptid_lwp_p (ptid))
3232 if (debug_linux_nat)
3233 fprintf_unfiltered (gdb_stdlog,
3234 "LLW: Waiting for specific LWP %s.\n",
3235 target_pid_to_str (ptid));
3237 /* We have a specific LWP to check. */
3238 lp = find_lwp_pid (ptid);
3241 if (debug_linux_nat && lp->status)
3242 fprintf_unfiltered (gdb_stdlog,
3243 "LLW: Using pending wait status %s for %s.\n",
3244 status_to_str (lp->status),
3245 target_pid_to_str (lp->ptid));
3247 /* We check for lp->waitstatus in addition to lp->status,
3248 because we can have pending process exits recorded in
3249 lp->status and W_EXITCODE(0,0) == 0. We should probably have
3250 an additional lp->status_p flag. */
3251 if (lp->status == 0 && lp->waitstatus.kind == TARGET_WAITKIND_IGNORE)
3255 if (!target_can_async_p ())
3257 /* Causes SIGINT to be passed on to the attached process. */
3261 /* But if we don't find a pending event, we'll have to wait. */
3267 /* Always use -1 and WNOHANG, due to couple of a kernel/ptrace
3270 - If the thread group leader exits while other threads in the
3271 thread group still exist, waitpid(TGID, ...) hangs. That
3272 waitpid won't return an exit status until the other threads
3273 in the group are reapped.
3275 - When a non-leader thread execs, that thread just vanishes
3276 without reporting an exit (so we'd hang if we waited for it
3277 explicitly in that case). The exec event is reported to
3281 lwpid = my_waitpid (-1, &status, __WCLONE | WNOHANG);
3282 if (lwpid == 0 || (lwpid == -1 && errno == ECHILD))
3283 lwpid = my_waitpid (-1, &status, WNOHANG);
3285 if (debug_linux_nat)
3286 fprintf_unfiltered (gdb_stdlog,
3287 "LNW: waitpid(-1, ...) returned %d, %s\n",
3288 lwpid, errno ? safe_strerror (errno) : "ERRNO-OK");
3292 /* If this is true, then we paused LWPs momentarily, and may
3293 now have pending events to handle. */
3296 if (debug_linux_nat)
3298 fprintf_unfiltered (gdb_stdlog,
3299 "LLW: waitpid %ld received %s\n",
3300 (long) lwpid, status_to_str (status));
3303 lp = linux_nat_filter_event (lwpid, status, &new_pending);
3305 /* STATUS is now no longer valid, use LP->STATUS instead. */
3308 if (lp && !ptid_match (lp->ptid, ptid))
3310 gdb_assert (lp->resumed);
3312 if (debug_linux_nat)
3314 "LWP %ld got an event %06x, leaving pending.\n",
3315 ptid_get_lwp (lp->ptid), lp->status);
3317 if (WIFSTOPPED (lp->status))
3319 if (WSTOPSIG (lp->status) != SIGSTOP)
3321 /* Cancel breakpoint hits. The breakpoint may
3322 be removed before we fetch events from this
3323 process to report to the core. It is best
3324 not to assume the moribund breakpoints
3325 heuristic always handles these cases --- it
3326 could be too many events go through to the
3327 core before this one is handled. All-stop
3328 always cancels breakpoint hits in all
3331 && linux_nat_lp_status_is_event (lp)
3332 && cancel_breakpoint (lp))
3334 /* Throw away the SIGTRAP. */
3337 if (debug_linux_nat)
3339 "LLW: LWP %ld hit a breakpoint while"
3340 " waiting for another process;"
3342 ptid_get_lwp (lp->ptid));
3352 else if (WIFEXITED (lp->status) || WIFSIGNALED (lp->status))
3354 if (debug_linux_nat)
3356 "Process %ld exited while stopping LWPs\n",
3357 ptid_get_lwp (lp->ptid));
3359 /* This was the last lwp in the process. Since
3360 events are serialized to GDB core, and we can't
3361 report this one right now, but GDB core and the
3362 other target layers will want to be notified
3363 about the exit code/signal, leave the status
3364 pending for the next time we're able to report
3367 /* Prevent trying to stop this thread again. We'll
3368 never try to resume it because it has a pending
3372 /* Dead LWP's aren't expected to reported a pending
3376 /* Store the pending event in the waitstatus as
3377 well, because W_EXITCODE(0,0) == 0. */
3378 store_waitstatus (&lp->waitstatus, lp->status);
3387 /* Some LWP now has a pending event. Go all the way
3388 back to check it. */
3394 /* We got an event to report to the core. */
3398 /* Retry until nothing comes out of waitpid. A single
3399 SIGCHLD can indicate more than one child stopped. */
3403 /* Check for zombie thread group leaders. Those can't be reaped
3404 until all other threads in the thread group are. */
3405 check_zombie_leaders ();
3407 /* If there are no resumed children left, bail. We'd be stuck
3408 forever in the sigsuspend call below otherwise. */
3409 if (iterate_over_lwps (ptid, resumed_callback, NULL) == NULL)
3411 if (debug_linux_nat)
3412 fprintf_unfiltered (gdb_stdlog, "LLW: exit (no resumed LWP)\n");
3414 ourstatus->kind = TARGET_WAITKIND_NO_RESUMED;
3416 if (!target_can_async_p ())
3417 clear_sigint_trap ();
3419 restore_child_signals_mask (&prev_mask);
3420 return minus_one_ptid;
3423 /* No interesting event to report to the core. */
3425 if (target_options & TARGET_WNOHANG)
3427 if (debug_linux_nat)
3428 fprintf_unfiltered (gdb_stdlog, "LLW: exit (ignore)\n");
3430 ourstatus->kind = TARGET_WAITKIND_IGNORE;
3431 restore_child_signals_mask (&prev_mask);
3432 return minus_one_ptid;
3435 /* We shouldn't end up here unless we want to try again. */
3436 gdb_assert (lp == NULL);
3438 /* Block until we get an event reported with SIGCHLD. */
3439 sigsuspend (&suspend_mask);
3442 if (!target_can_async_p ())
3443 clear_sigint_trap ();
3447 status = lp->status;
3450 /* Don't report signals that GDB isn't interested in, such as
3451 signals that are neither printed nor stopped upon. Stopping all
3452 threads can be a bit time-consuming so if we want decent
3453 performance with heavily multi-threaded programs, especially when
3454 they're using a high frequency timer, we'd better avoid it if we
3457 if (WIFSTOPPED (status))
3459 enum gdb_signal signo = gdb_signal_from_host (WSTOPSIG (status));
3461 /* When using hardware single-step, we need to report every signal.
3462 Otherwise, signals in pass_mask may be short-circuited. */
3464 && WSTOPSIG (status) && sigismember (&pass_mask, WSTOPSIG (status)))
3466 /* FIMXE: kettenis/2001-06-06: Should we resume all threads
3467 here? It is not clear we should. GDB may not expect
3468 other threads to run. On the other hand, not resuming
3469 newly attached threads may cause an unwanted delay in
3470 getting them running. */
3471 registers_changed ();
3472 if (linux_nat_prepare_to_resume != NULL)
3473 linux_nat_prepare_to_resume (lp);
3474 linux_ops->to_resume (linux_ops,
3475 pid_to_ptid (ptid_get_lwp (lp->ptid)),
3477 if (debug_linux_nat)
3478 fprintf_unfiltered (gdb_stdlog,
3479 "LLW: %s %s, %s (preempt 'handle')\n",
3481 "PTRACE_SINGLESTEP" : "PTRACE_CONT",
3482 target_pid_to_str (lp->ptid),
3483 (signo != GDB_SIGNAL_0
3484 ? strsignal (gdb_signal_to_host (signo))
3492 /* Only do the below in all-stop, as we currently use SIGINT
3493 to implement target_stop (see linux_nat_stop) in
3495 if (signo == GDB_SIGNAL_INT && signal_pass_state (signo) == 0)
3497 /* If ^C/BREAK is typed at the tty/console, SIGINT gets
3498 forwarded to the entire process group, that is, all LWPs
3499 will receive it - unless they're using CLONE_THREAD to
3500 share signals. Since we only want to report it once, we
3501 mark it as ignored for all LWPs except this one. */
3502 iterate_over_lwps (pid_to_ptid (ptid_get_pid (ptid)),
3503 set_ignore_sigint, NULL);
3504 lp->ignore_sigint = 0;
3507 maybe_clear_ignore_sigint (lp);
3511 /* This LWP is stopped now. */
3514 if (debug_linux_nat)
3515 fprintf_unfiltered (gdb_stdlog, "LLW: Candidate event %s in %s.\n",
3516 status_to_str (status), target_pid_to_str (lp->ptid));
3520 /* Now stop all other LWP's ... */
3521 iterate_over_lwps (minus_one_ptid, stop_callback, NULL);
3523 /* ... and wait until all of them have reported back that
3524 they're no longer running. */
3525 iterate_over_lwps (minus_one_ptid, stop_wait_callback, NULL);
3527 /* If we're not waiting for a specific LWP, choose an event LWP
3528 from among those that have had events. Giving equal priority
3529 to all LWPs that have had events helps prevent
3531 if (ptid_equal (ptid, minus_one_ptid) || ptid_is_pid (ptid))
3532 select_event_lwp (ptid, &lp, &status);
3534 /* Now that we've selected our final event LWP, cancel any
3535 breakpoints in other LWPs that have hit a GDB breakpoint.
3536 See the comment in cancel_breakpoints_callback to find out
3538 iterate_over_lwps (minus_one_ptid, cancel_breakpoints_callback, lp);
3540 /* We'll need this to determine whether to report a SIGSTOP as
3541 TARGET_WAITKIND_0. Need to take a copy because
3542 resume_clear_callback clears it. */
3543 last_resume_kind = lp->last_resume_kind;
3545 /* In all-stop, from the core's perspective, all LWPs are now
3546 stopped until a new resume action is sent over. */
3547 iterate_over_lwps (minus_one_ptid, resume_clear_callback, NULL);
3552 last_resume_kind = lp->last_resume_kind;
3553 resume_clear_callback (lp, NULL);
3556 if (linux_nat_status_is_event (status))
3558 if (debug_linux_nat)
3559 fprintf_unfiltered (gdb_stdlog,
3560 "LLW: trap ptid is %s.\n",
3561 target_pid_to_str (lp->ptid));
3564 if (lp->waitstatus.kind != TARGET_WAITKIND_IGNORE)
3566 *ourstatus = lp->waitstatus;
3567 lp->waitstatus.kind = TARGET_WAITKIND_IGNORE;
3570 store_waitstatus (ourstatus, status);
3572 if (debug_linux_nat)
3573 fprintf_unfiltered (gdb_stdlog, "LLW: exit\n");
3575 restore_child_signals_mask (&prev_mask);
3577 if (last_resume_kind == resume_stop
3578 && ourstatus->kind == TARGET_WAITKIND_STOPPED
3579 && WSTOPSIG (status) == SIGSTOP)
3581 /* A thread that has been requested to stop by GDB with
3582 target_stop, and it stopped cleanly, so report as SIG0. The
3583 use of SIGSTOP is an implementation detail. */
3584 ourstatus->value.sig = GDB_SIGNAL_0;
3587 if (ourstatus->kind == TARGET_WAITKIND_EXITED
3588 || ourstatus->kind == TARGET_WAITKIND_SIGNALLED)
3591 lp->core = linux_common_core_of_thread (lp->ptid);
3596 /* Resume LWPs that are currently stopped without any pending status
3597 to report, but are resumed from the core's perspective. */
3600 resume_stopped_resumed_lwps (struct lwp_info *lp, void *data)
3602 ptid_t *wait_ptid_p = data;
3607 && lp->waitstatus.kind == TARGET_WAITKIND_IGNORE)
3609 struct regcache *regcache = get_thread_regcache (lp->ptid);
3610 struct gdbarch *gdbarch = get_regcache_arch (regcache);
3611 CORE_ADDR pc = regcache_read_pc (regcache);
3613 gdb_assert (is_executing (lp->ptid));
3615 /* Don't bother if there's a breakpoint at PC that we'd hit
3616 immediately, and we're not waiting for this LWP. */
3617 if (!ptid_match (lp->ptid, *wait_ptid_p))
3619 if (breakpoint_inserted_here_p (get_regcache_aspace (regcache), pc))
3623 if (debug_linux_nat)
3624 fprintf_unfiltered (gdb_stdlog,
3625 "RSRL: resuming stopped-resumed LWP %s at %s: step=%d\n",
3626 target_pid_to_str (lp->ptid),
3627 paddress (gdbarch, pc),
3630 registers_changed ();
3631 if (linux_nat_prepare_to_resume != NULL)
3632 linux_nat_prepare_to_resume (lp);
3633 linux_ops->to_resume (linux_ops, pid_to_ptid (ptid_get_lwp (lp->ptid)),
3634 lp->step, GDB_SIGNAL_0);
3636 lp->stopped_by_watchpoint = 0;
3643 linux_nat_wait (struct target_ops *ops,
3644 ptid_t ptid, struct target_waitstatus *ourstatus,
3649 if (debug_linux_nat)
3651 char *options_string;
3653 options_string = target_options_to_string (target_options);
3654 fprintf_unfiltered (gdb_stdlog,
3655 "linux_nat_wait: [%s], [%s]\n",
3656 target_pid_to_str (ptid),
3658 xfree (options_string);
3661 /* Flush the async file first. */
3662 if (target_can_async_p ())
3663 async_file_flush ();
3665 /* Resume LWPs that are currently stopped without any pending status
3666 to report, but are resumed from the core's perspective. LWPs get
3667 in this state if we find them stopping at a time we're not
3668 interested in reporting the event (target_wait on a
3669 specific_process, for example, see linux_nat_wait_1), and
3670 meanwhile the event became uninteresting. Don't bother resuming
3671 LWPs we're not going to wait for if they'd stop immediately. */
3673 iterate_over_lwps (minus_one_ptid, resume_stopped_resumed_lwps, &ptid);
3675 event_ptid = linux_nat_wait_1 (ops, ptid, ourstatus, target_options);
3677 /* If we requested any event, and something came out, assume there
3678 may be more. If we requested a specific lwp or process, also
3679 assume there may be more. */
3680 if (target_can_async_p ()
3681 && ((ourstatus->kind != TARGET_WAITKIND_IGNORE
3682 && ourstatus->kind != TARGET_WAITKIND_NO_RESUMED)
3683 || !ptid_equal (ptid, minus_one_ptid)))
3686 /* Get ready for the next event. */
3687 if (target_can_async_p ())
3688 target_async (inferior_event_handler, 0);
3694 kill_callback (struct lwp_info *lp, void *data)
3696 /* PTRACE_KILL may resume the inferior. Send SIGKILL first. */
3699 kill (ptid_get_lwp (lp->ptid), SIGKILL);
3700 if (debug_linux_nat)
3701 fprintf_unfiltered (gdb_stdlog,
3702 "KC: kill (SIGKILL) %s, 0, 0 (%s)\n",
3703 target_pid_to_str (lp->ptid),
3704 errno ? safe_strerror (errno) : "OK");
3706 /* Some kernels ignore even SIGKILL for processes under ptrace. */
3709 ptrace (PTRACE_KILL, ptid_get_lwp (lp->ptid), 0, 0);
3710 if (debug_linux_nat)
3711 fprintf_unfiltered (gdb_stdlog,
3712 "KC: PTRACE_KILL %s, 0, 0 (%s)\n",
3713 target_pid_to_str (lp->ptid),
3714 errno ? safe_strerror (errno) : "OK");
3720 kill_wait_callback (struct lwp_info *lp, void *data)
3724 /* We must make sure that there are no pending events (delayed
3725 SIGSTOPs, pending SIGTRAPs, etc.) to make sure the current
3726 program doesn't interfere with any following debugging session. */
3728 /* For cloned processes we must check both with __WCLONE and
3729 without, since the exit status of a cloned process isn't reported
3735 pid = my_waitpid (ptid_get_lwp (lp->ptid), NULL, __WCLONE);
3736 if (pid != (pid_t) -1)
3738 if (debug_linux_nat)
3739 fprintf_unfiltered (gdb_stdlog,
3740 "KWC: wait %s received unknown.\n",
3741 target_pid_to_str (lp->ptid));
3742 /* The Linux kernel sometimes fails to kill a thread
3743 completely after PTRACE_KILL; that goes from the stop
3744 point in do_fork out to the one in
3745 get_signal_to_deliever and waits again. So kill it
3747 kill_callback (lp, NULL);
3750 while (pid == ptid_get_lwp (lp->ptid));
3752 gdb_assert (pid == -1 && errno == ECHILD);
3757 pid = my_waitpid (ptid_get_lwp (lp->ptid), NULL, 0);
3758 if (pid != (pid_t) -1)
3760 if (debug_linux_nat)
3761 fprintf_unfiltered (gdb_stdlog,
3762 "KWC: wait %s received unk.\n",
3763 target_pid_to_str (lp->ptid));
3764 /* See the call to kill_callback above. */
3765 kill_callback (lp, NULL);
3768 while (pid == ptid_get_lwp (lp->ptid));
3770 gdb_assert (pid == -1 && errno == ECHILD);
3775 linux_nat_kill (struct target_ops *ops)
3777 struct target_waitstatus last;
3781 /* If we're stopped while forking and we haven't followed yet,
3782 kill the other task. We need to do this first because the
3783 parent will be sleeping if this is a vfork. */
3785 get_last_target_status (&last_ptid, &last);
3787 if (last.kind == TARGET_WAITKIND_FORKED
3788 || last.kind == TARGET_WAITKIND_VFORKED)
3790 ptrace (PT_KILL, ptid_get_pid (last.value.related_pid), 0, 0);
3793 /* Let the arch-specific native code know this process is
3795 linux_nat_forget_process (ptid_get_pid (last.value.related_pid));
3798 if (forks_exist_p ())
3799 linux_fork_killall ();
3802 ptid_t ptid = pid_to_ptid (ptid_get_pid (inferior_ptid));
3804 /* Stop all threads before killing them, since ptrace requires
3805 that the thread is stopped to sucessfully PTRACE_KILL. */
3806 iterate_over_lwps (ptid, stop_callback, NULL);
3807 /* ... and wait until all of them have reported back that
3808 they're no longer running. */
3809 iterate_over_lwps (ptid, stop_wait_callback, NULL);
3811 /* Kill all LWP's ... */
3812 iterate_over_lwps (ptid, kill_callback, NULL);
3814 /* ... and wait until we've flushed all events. */
3815 iterate_over_lwps (ptid, kill_wait_callback, NULL);
3818 target_mourn_inferior ();
3822 linux_nat_mourn_inferior (struct target_ops *ops)
3824 int pid = ptid_get_pid (inferior_ptid);
3826 purge_lwp_list (pid);
3828 if (! forks_exist_p ())
3829 /* Normal case, no other forks available. */
3830 linux_ops->to_mourn_inferior (ops);
3832 /* Multi-fork case. The current inferior_ptid has exited, but
3833 there are other viable forks to debug. Delete the exiting
3834 one and context-switch to the first available. */
3835 linux_fork_mourn_inferior ();
3837 /* Let the arch-specific native code know this process is gone. */
3838 linux_nat_forget_process (pid);
3841 /* Convert a native/host siginfo object, into/from the siginfo in the
3842 layout of the inferiors' architecture. */
3845 siginfo_fixup (siginfo_t *siginfo, gdb_byte *inf_siginfo, int direction)
3849 if (linux_nat_siginfo_fixup != NULL)
3850 done = linux_nat_siginfo_fixup (siginfo, inf_siginfo, direction);
3852 /* If there was no callback, or the callback didn't do anything,
3853 then just do a straight memcpy. */
3857 memcpy (siginfo, inf_siginfo, sizeof (siginfo_t));
3859 memcpy (inf_siginfo, siginfo, sizeof (siginfo_t));
3863 static enum target_xfer_status
3864 linux_xfer_siginfo (struct target_ops *ops, enum target_object object,
3865 const char *annex, gdb_byte *readbuf,
3866 const gdb_byte *writebuf, ULONGEST offset, ULONGEST len,
3867 ULONGEST *xfered_len)
3871 gdb_byte inf_siginfo[sizeof (siginfo_t)];
3873 gdb_assert (object == TARGET_OBJECT_SIGNAL_INFO);
3874 gdb_assert (readbuf || writebuf);
3876 pid = ptid_get_lwp (inferior_ptid);
3878 pid = ptid_get_pid (inferior_ptid);
3880 if (offset > sizeof (siginfo))
3881 return TARGET_XFER_E_IO;
3884 ptrace (PTRACE_GETSIGINFO, pid, (PTRACE_TYPE_ARG3) 0, &siginfo);
3886 return TARGET_XFER_E_IO;
3888 /* When GDB is built as a 64-bit application, ptrace writes into
3889 SIGINFO an object with 64-bit layout. Since debugging a 32-bit
3890 inferior with a 64-bit GDB should look the same as debugging it
3891 with a 32-bit GDB, we need to convert it. GDB core always sees
3892 the converted layout, so any read/write will have to be done
3894 siginfo_fixup (&siginfo, inf_siginfo, 0);
3896 if (offset + len > sizeof (siginfo))
3897 len = sizeof (siginfo) - offset;
3899 if (readbuf != NULL)
3900 memcpy (readbuf, inf_siginfo + offset, len);
3903 memcpy (inf_siginfo + offset, writebuf, len);
3905 /* Convert back to ptrace layout before flushing it out. */
3906 siginfo_fixup (&siginfo, inf_siginfo, 1);
3909 ptrace (PTRACE_SETSIGINFO, pid, (PTRACE_TYPE_ARG3) 0, &siginfo);
3911 return TARGET_XFER_E_IO;
3915 return TARGET_XFER_OK;
3918 static enum target_xfer_status
3919 linux_nat_xfer_partial (struct target_ops *ops, enum target_object object,
3920 const char *annex, gdb_byte *readbuf,
3921 const gdb_byte *writebuf,
3922 ULONGEST offset, ULONGEST len, ULONGEST *xfered_len)
3924 struct cleanup *old_chain;
3925 enum target_xfer_status xfer;
3927 if (object == TARGET_OBJECT_SIGNAL_INFO)
3928 return linux_xfer_siginfo (ops, object, annex, readbuf, writebuf,
3929 offset, len, xfered_len);
3931 /* The target is connected but no live inferior is selected. Pass
3932 this request down to a lower stratum (e.g., the executable
3934 if (object == TARGET_OBJECT_MEMORY && ptid_equal (inferior_ptid, null_ptid))
3935 return TARGET_XFER_EOF;
3937 old_chain = save_inferior_ptid ();
3939 if (ptid_lwp_p (inferior_ptid))
3940 inferior_ptid = pid_to_ptid (ptid_get_lwp (inferior_ptid));
3942 xfer = linux_ops->to_xfer_partial (ops, object, annex, readbuf, writebuf,
3943 offset, len, xfered_len);
3945 do_cleanups (old_chain);
3950 linux_thread_alive (ptid_t ptid)
3954 gdb_assert (ptid_lwp_p (ptid));
3956 /* Send signal 0 instead of anything ptrace, because ptracing a
3957 running thread errors out claiming that the thread doesn't
3959 err = kill_lwp (ptid_get_lwp (ptid), 0);
3961 if (debug_linux_nat)
3962 fprintf_unfiltered (gdb_stdlog,
3963 "LLTA: KILL(SIG0) %s (%s)\n",
3964 target_pid_to_str (ptid),
3965 err ? safe_strerror (tmp_errno) : "OK");
3974 linux_nat_thread_alive (struct target_ops *ops, ptid_t ptid)
3976 return linux_thread_alive (ptid);
3980 linux_nat_pid_to_str (struct target_ops *ops, ptid_t ptid)
3982 static char buf[64];
3984 if (ptid_lwp_p (ptid)
3985 && (ptid_get_pid (ptid) != ptid_get_lwp (ptid)
3986 || num_lwps (ptid_get_pid (ptid)) > 1))
3988 snprintf (buf, sizeof (buf), "LWP %ld", ptid_get_lwp (ptid));
3992 return normal_pid_to_str (ptid);
3996 linux_nat_thread_name (struct target_ops *self, struct thread_info *thr)
3998 int pid = ptid_get_pid (thr->ptid);
3999 long lwp = ptid_get_lwp (thr->ptid);
4000 #define FORMAT "/proc/%d/task/%ld/comm"
4001 char buf[sizeof (FORMAT) + 30];
4003 char *result = NULL;
4005 snprintf (buf, sizeof (buf), FORMAT, pid, lwp);
4006 comm_file = gdb_fopen_cloexec (buf, "r");
4009 /* Not exported by the kernel, so we define it here. */
4011 static char line[COMM_LEN + 1];
4013 if (fgets (line, sizeof (line), comm_file))
4015 char *nl = strchr (line, '\n');
4032 /* Accepts an integer PID; Returns a string representing a file that
4033 can be opened to get the symbols for the child process. */
4036 linux_child_pid_to_exec_file (struct target_ops *self, int pid)
4038 char *name1, *name2;
4040 name1 = xmalloc (PATH_MAX);
4041 name2 = xmalloc (PATH_MAX);
4042 make_cleanup (xfree, name1);
4043 make_cleanup (xfree, name2);
4044 memset (name2, 0, PATH_MAX);
4046 xsnprintf (name1, PATH_MAX, "/proc/%d/exe", pid);
4047 if (readlink (name1, name2, PATH_MAX - 1) > 0)
4053 /* Records the thread's register state for the corefile note
4057 linux_nat_collect_thread_registers (const struct regcache *regcache,
4058 ptid_t ptid, bfd *obfd,
4059 char *note_data, int *note_size,
4060 enum gdb_signal stop_signal)
4062 struct gdbarch *gdbarch = get_regcache_arch (regcache);
4063 const struct regset *regset;
4065 gdb_gregset_t gregs;
4066 gdb_fpregset_t fpregs;
4068 core_regset_p = gdbarch_regset_from_core_section_p (gdbarch);
4071 && (regset = gdbarch_regset_from_core_section (gdbarch, ".reg",
4073 != NULL && regset->collect_regset != NULL)
4074 regset->collect_regset (regset, regcache, -1, &gregs, sizeof (gregs));
4076 fill_gregset (regcache, &gregs, -1);
4078 note_data = (char *) elfcore_write_prstatus
4079 (obfd, note_data, note_size, ptid_get_lwp (ptid),
4080 gdb_signal_to_host (stop_signal), &gregs);
4083 && (regset = gdbarch_regset_from_core_section (gdbarch, ".reg2",
4085 != NULL && regset->collect_regset != NULL)
4086 regset->collect_regset (regset, regcache, -1, &fpregs, sizeof (fpregs));
4088 fill_fpregset (regcache, &fpregs, -1);
4090 note_data = (char *) elfcore_write_prfpreg (obfd, note_data, note_size,
4091 &fpregs, sizeof (fpregs));
4096 /* Fills the "to_make_corefile_note" target vector. Builds the note
4097 section for a corefile, and returns it in a malloc buffer. */
4100 linux_nat_make_corefile_notes (bfd *obfd, int *note_size)
4102 /* FIXME: uweigand/2011-10-06: Once all GNU/Linux architectures have been
4103 converted to gdbarch_core_regset_sections, this function can go away. */
4104 return linux_make_corefile_notes (target_gdbarch (), obfd, note_size,
4105 linux_nat_collect_thread_registers);
4108 /* Implement the to_xfer_partial interface for memory reads using the /proc
4109 filesystem. Because we can use a single read() call for /proc, this
4110 can be much more efficient than banging away at PTRACE_PEEKTEXT,
4111 but it doesn't support writes. */
4113 static enum target_xfer_status
4114 linux_proc_xfer_partial (struct target_ops *ops, enum target_object object,
4115 const char *annex, gdb_byte *readbuf,
4116 const gdb_byte *writebuf,
4117 ULONGEST offset, LONGEST len, ULONGEST *xfered_len)
4123 if (object != TARGET_OBJECT_MEMORY || !readbuf)
4126 /* Don't bother for one word. */
4127 if (len < 3 * sizeof (long))
4128 return TARGET_XFER_EOF;
4130 /* We could keep this file open and cache it - possibly one per
4131 thread. That requires some juggling, but is even faster. */
4132 xsnprintf (filename, sizeof filename, "/proc/%d/mem",
4133 ptid_get_pid (inferior_ptid));
4134 fd = gdb_open_cloexec (filename, O_RDONLY | O_LARGEFILE, 0);
4136 return TARGET_XFER_EOF;
4138 /* If pread64 is available, use it. It's faster if the kernel
4139 supports it (only one syscall), and it's 64-bit safe even on
4140 32-bit platforms (for instance, SPARC debugging a SPARC64
4143 if (pread64 (fd, readbuf, len, offset) != len)
4145 if (lseek (fd, offset, SEEK_SET) == -1 || read (fd, readbuf, len) != len)
4154 return TARGET_XFER_EOF;
4158 return TARGET_XFER_OK;
4163 /* Enumerate spufs IDs for process PID. */
4165 spu_enumerate_spu_ids (int pid, gdb_byte *buf, ULONGEST offset, ULONGEST len)
4167 enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch ());
4169 LONGEST written = 0;
4172 struct dirent *entry;
4174 xsnprintf (path, sizeof path, "/proc/%d/fd", pid);
4175 dir = opendir (path);
4180 while ((entry = readdir (dir)) != NULL)
4186 fd = atoi (entry->d_name);
4190 xsnprintf (path, sizeof path, "/proc/%d/fd/%d", pid, fd);
4191 if (stat (path, &st) != 0)
4193 if (!S_ISDIR (st.st_mode))
4196 if (statfs (path, &stfs) != 0)
4198 if (stfs.f_type != SPUFS_MAGIC)
4201 if (pos >= offset && pos + 4 <= offset + len)
4203 store_unsigned_integer (buf + pos - offset, 4, byte_order, fd);
4213 /* Implement the to_xfer_partial interface for the TARGET_OBJECT_SPU
4214 object type, using the /proc file system. */
4216 static enum target_xfer_status
4217 linux_proc_xfer_spu (struct target_ops *ops, enum target_object object,
4218 const char *annex, gdb_byte *readbuf,
4219 const gdb_byte *writebuf,
4220 ULONGEST offset, ULONGEST len, ULONGEST *xfered_len)
4225 int pid = ptid_get_pid (inferior_ptid);
4230 return TARGET_XFER_E_IO;
4233 LONGEST l = spu_enumerate_spu_ids (pid, readbuf, offset, len);
4236 return TARGET_XFER_E_IO;
4238 return TARGET_XFER_EOF;
4241 *xfered_len = (ULONGEST) l;
4242 return TARGET_XFER_OK;
4247 xsnprintf (buf, sizeof buf, "/proc/%d/fd/%s", pid, annex);
4248 fd = gdb_open_cloexec (buf, writebuf? O_WRONLY : O_RDONLY, 0);
4250 return TARGET_XFER_E_IO;
4253 && lseek (fd, (off_t) offset, SEEK_SET) != (off_t) offset)
4256 return TARGET_XFER_EOF;
4260 ret = write (fd, writebuf, (size_t) len);
4262 ret = read (fd, readbuf, (size_t) len);
4267 return TARGET_XFER_E_IO;
4269 return TARGET_XFER_EOF;
4272 *xfered_len = (ULONGEST) ret;
4273 return TARGET_XFER_OK;
4278 /* Parse LINE as a signal set and add its set bits to SIGS. */
4281 add_line_to_sigset (const char *line, sigset_t *sigs)
4283 int len = strlen (line) - 1;
4287 if (line[len] != '\n')
4288 error (_("Could not parse signal set: %s"), line);
4296 if (*p >= '0' && *p <= '9')
4298 else if (*p >= 'a' && *p <= 'f')
4299 digit = *p - 'a' + 10;
4301 error (_("Could not parse signal set: %s"), line);
4306 sigaddset (sigs, signum + 1);
4308 sigaddset (sigs, signum + 2);
4310 sigaddset (sigs, signum + 3);
4312 sigaddset (sigs, signum + 4);
4318 /* Find process PID's pending signals from /proc/pid/status and set
4322 linux_proc_pending_signals (int pid, sigset_t *pending,
4323 sigset_t *blocked, sigset_t *ignored)
4326 char buffer[PATH_MAX], fname[PATH_MAX];
4327 struct cleanup *cleanup;
4329 sigemptyset (pending);
4330 sigemptyset (blocked);
4331 sigemptyset (ignored);
4332 xsnprintf (fname, sizeof fname, "/proc/%d/status", pid);
4333 procfile = gdb_fopen_cloexec (fname, "r");
4334 if (procfile == NULL)
4335 error (_("Could not open %s"), fname);
4336 cleanup = make_cleanup_fclose (procfile);
4338 while (fgets (buffer, PATH_MAX, procfile) != NULL)
4340 /* Normal queued signals are on the SigPnd line in the status
4341 file. However, 2.6 kernels also have a "shared" pending
4342 queue for delivering signals to a thread group, so check for
4345 Unfortunately some Red Hat kernels include the shared pending
4346 queue but not the ShdPnd status field. */
4348 if (strncmp (buffer, "SigPnd:\t", 8) == 0)
4349 add_line_to_sigset (buffer + 8, pending);
4350 else if (strncmp (buffer, "ShdPnd:\t", 8) == 0)
4351 add_line_to_sigset (buffer + 8, pending);
4352 else if (strncmp (buffer, "SigBlk:\t", 8) == 0)
4353 add_line_to_sigset (buffer + 8, blocked);
4354 else if (strncmp (buffer, "SigIgn:\t", 8) == 0)
4355 add_line_to_sigset (buffer + 8, ignored);
4358 do_cleanups (cleanup);
4361 static enum target_xfer_status
4362 linux_nat_xfer_osdata (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)
4367 gdb_assert (object == TARGET_OBJECT_OSDATA);
4369 *xfered_len = linux_common_xfer_osdata (annex, readbuf, offset, len);
4370 if (*xfered_len == 0)
4371 return TARGET_XFER_EOF;
4373 return TARGET_XFER_OK;
4376 static enum target_xfer_status
4377 linux_xfer_partial (struct target_ops *ops, enum target_object object,
4378 const char *annex, gdb_byte *readbuf,
4379 const gdb_byte *writebuf, ULONGEST offset, ULONGEST len,
4380 ULONGEST *xfered_len)
4382 enum target_xfer_status xfer;
4384 if (object == TARGET_OBJECT_AUXV)
4385 return memory_xfer_auxv (ops, object, annex, readbuf, writebuf,
4386 offset, len, xfered_len);
4388 if (object == TARGET_OBJECT_OSDATA)
4389 return linux_nat_xfer_osdata (ops, object, annex, readbuf, writebuf,
4390 offset, len, xfered_len);
4392 if (object == TARGET_OBJECT_SPU)
4393 return linux_proc_xfer_spu (ops, object, annex, readbuf, writebuf,
4394 offset, len, xfered_len);
4396 /* GDB calculates all the addresses in possibly larget width of the address.
4397 Address width needs to be masked before its final use - either by
4398 linux_proc_xfer_partial or inf_ptrace_xfer_partial.
4400 Compare ADDR_BIT first to avoid a compiler warning on shift overflow. */
4402 if (object == TARGET_OBJECT_MEMORY)
4404 int addr_bit = gdbarch_addr_bit (target_gdbarch ());
4406 if (addr_bit < (sizeof (ULONGEST) * HOST_CHAR_BIT))
4407 offset &= ((ULONGEST) 1 << addr_bit) - 1;
4410 xfer = linux_proc_xfer_partial (ops, object, annex, readbuf, writebuf,
4411 offset, len, xfered_len);
4412 if (xfer != TARGET_XFER_EOF)
4415 return super_xfer_partial (ops, object, annex, readbuf, writebuf,
4416 offset, len, xfered_len);
4420 cleanup_target_stop (void *arg)
4422 ptid_t *ptid = (ptid_t *) arg;
4424 gdb_assert (arg != NULL);
4427 target_resume (*ptid, 0, GDB_SIGNAL_0);
4430 static VEC(static_tracepoint_marker_p) *
4431 linux_child_static_tracepoint_markers_by_strid (const char *strid)
4433 char s[IPA_CMD_BUF_SIZE];
4434 struct cleanup *old_chain;
4435 int pid = ptid_get_pid (inferior_ptid);
4436 VEC(static_tracepoint_marker_p) *markers = NULL;
4437 struct static_tracepoint_marker *marker = NULL;
4439 ptid_t ptid = ptid_build (pid, 0, 0);
4444 memcpy (s, "qTfSTM", sizeof ("qTfSTM"));
4445 s[sizeof ("qTfSTM")] = 0;
4447 agent_run_command (pid, s, strlen (s) + 1);
4449 old_chain = make_cleanup (free_current_marker, &marker);
4450 make_cleanup (cleanup_target_stop, &ptid);
4455 marker = XCNEW (struct static_tracepoint_marker);
4459 parse_static_tracepoint_marker_definition (p, &p, marker);
4461 if (strid == NULL || strcmp (strid, marker->str_id) == 0)
4463 VEC_safe_push (static_tracepoint_marker_p,
4469 release_static_tracepoint_marker (marker);
4470 memset (marker, 0, sizeof (*marker));
4473 while (*p++ == ','); /* comma-separated list */
4475 memcpy (s, "qTsSTM", sizeof ("qTsSTM"));
4476 s[sizeof ("qTsSTM")] = 0;
4477 agent_run_command (pid, s, strlen (s) + 1);
4481 do_cleanups (old_chain);
4486 /* Create a prototype generic GNU/Linux target. The client can override
4487 it with local methods. */
4490 linux_target_install_ops (struct target_ops *t)
4492 t->to_insert_fork_catchpoint = linux_child_insert_fork_catchpoint;
4493 t->to_remove_fork_catchpoint = linux_child_remove_fork_catchpoint;
4494 t->to_insert_vfork_catchpoint = linux_child_insert_vfork_catchpoint;
4495 t->to_remove_vfork_catchpoint = linux_child_remove_vfork_catchpoint;
4496 t->to_insert_exec_catchpoint = linux_child_insert_exec_catchpoint;
4497 t->to_remove_exec_catchpoint = linux_child_remove_exec_catchpoint;
4498 t->to_set_syscall_catchpoint = linux_child_set_syscall_catchpoint;
4499 t->to_pid_to_exec_file = linux_child_pid_to_exec_file;
4500 t->to_post_startup_inferior = linux_child_post_startup_inferior;
4501 t->to_post_attach = linux_child_post_attach;
4502 t->to_follow_fork = linux_child_follow_fork;
4503 t->to_make_corefile_notes = linux_nat_make_corefile_notes;
4505 super_xfer_partial = t->to_xfer_partial;
4506 t->to_xfer_partial = linux_xfer_partial;
4508 t->to_static_tracepoint_markers_by_strid
4509 = linux_child_static_tracepoint_markers_by_strid;
4515 struct target_ops *t;
4517 t = inf_ptrace_target ();
4518 linux_target_install_ops (t);
4524 linux_trad_target (CORE_ADDR (*register_u_offset)(struct gdbarch *, int, int))
4526 struct target_ops *t;
4528 t = inf_ptrace_trad_target (register_u_offset);
4529 linux_target_install_ops (t);
4534 /* target_is_async_p implementation. */
4537 linux_nat_is_async_p (struct target_ops *ops)
4539 /* NOTE: palves 2008-03-21: We're only async when the user requests
4540 it explicitly with the "set target-async" command.
4541 Someday, linux will always be async. */
4542 return target_async_permitted;
4545 /* target_can_async_p implementation. */
4548 linux_nat_can_async_p (struct target_ops *ops)
4550 /* NOTE: palves 2008-03-21: We're only async when the user requests
4551 it explicitly with the "set target-async" command.
4552 Someday, linux will always be async. */
4553 return target_async_permitted;
4557 linux_nat_supports_non_stop (void)
4562 /* True if we want to support multi-process. To be removed when GDB
4563 supports multi-exec. */
4565 int linux_multi_process = 1;
4568 linux_nat_supports_multi_process (void)
4570 return linux_multi_process;
4574 linux_nat_supports_disable_randomization (void)
4576 #ifdef HAVE_PERSONALITY
4583 static int async_terminal_is_ours = 1;
4585 /* target_terminal_inferior implementation. */
4588 linux_nat_terminal_inferior (struct target_ops *self)
4590 if (!target_is_async_p ())
4592 /* Async mode is disabled. */
4593 terminal_inferior (self);
4597 terminal_inferior (self);
4599 /* Calls to target_terminal_*() are meant to be idempotent. */
4600 if (!async_terminal_is_ours)
4603 delete_file_handler (input_fd);
4604 async_terminal_is_ours = 0;
4608 /* target_terminal_ours implementation. */
4611 linux_nat_terminal_ours (struct target_ops *self)
4613 if (!target_is_async_p ())
4615 /* Async mode is disabled. */
4616 terminal_ours (self);
4620 /* GDB should never give the terminal to the inferior if the
4621 inferior is running in the background (run&, continue&, etc.),
4622 but claiming it sure should. */
4623 terminal_ours (self);
4625 if (async_terminal_is_ours)
4628 clear_sigint_trap ();
4629 add_file_handler (input_fd, stdin_event_handler, 0);
4630 async_terminal_is_ours = 1;
4633 static void (*async_client_callback) (enum inferior_event_type event_type,
4635 static void *async_client_context;
4637 /* SIGCHLD handler that serves two purposes: In non-stop/async mode,
4638 so we notice when any child changes state, and notify the
4639 event-loop; it allows us to use sigsuspend in linux_nat_wait_1
4640 above to wait for the arrival of a SIGCHLD. */
4643 sigchld_handler (int signo)
4645 int old_errno = errno;
4647 if (debug_linux_nat)
4648 ui_file_write_async_safe (gdb_stdlog,
4649 "sigchld\n", sizeof ("sigchld\n") - 1);
4651 if (signo == SIGCHLD
4652 && linux_nat_event_pipe[0] != -1)
4653 async_file_mark (); /* Let the event loop know that there are
4654 events to handle. */
4659 /* Callback registered with the target events file descriptor. */
4662 handle_target_event (int error, gdb_client_data client_data)
4664 (*async_client_callback) (INF_REG_EVENT, async_client_context);
4667 /* Create/destroy the target events pipe. Returns previous state. */
4670 linux_async_pipe (int enable)
4672 int previous = (linux_nat_event_pipe[0] != -1);
4674 if (previous != enable)
4678 /* Block child signals while we create/destroy the pipe, as
4679 their handler writes to it. */
4680 block_child_signals (&prev_mask);
4684 if (gdb_pipe_cloexec (linux_nat_event_pipe) == -1)
4685 internal_error (__FILE__, __LINE__,
4686 "creating event pipe failed.");
4688 fcntl (linux_nat_event_pipe[0], F_SETFL, O_NONBLOCK);
4689 fcntl (linux_nat_event_pipe[1], F_SETFL, O_NONBLOCK);
4693 close (linux_nat_event_pipe[0]);
4694 close (linux_nat_event_pipe[1]);
4695 linux_nat_event_pipe[0] = -1;
4696 linux_nat_event_pipe[1] = -1;
4699 restore_child_signals_mask (&prev_mask);
4705 /* target_async implementation. */
4708 linux_nat_async (struct target_ops *ops,
4709 void (*callback) (enum inferior_event_type event_type,
4713 if (callback != NULL)
4715 async_client_callback = callback;
4716 async_client_context = context;
4717 if (!linux_async_pipe (1))
4719 add_file_handler (linux_nat_event_pipe[0],
4720 handle_target_event, NULL);
4721 /* There may be pending events to handle. Tell the event loop
4728 async_client_callback = callback;
4729 async_client_context = context;
4730 delete_file_handler (linux_nat_event_pipe[0]);
4731 linux_async_pipe (0);
4736 /* Stop an LWP, and push a GDB_SIGNAL_0 stop status if no other
4740 linux_nat_stop_lwp (struct lwp_info *lwp, void *data)
4744 if (debug_linux_nat)
4745 fprintf_unfiltered (gdb_stdlog,
4746 "LNSL: running -> suspending %s\n",
4747 target_pid_to_str (lwp->ptid));
4750 if (lwp->last_resume_kind == resume_stop)
4752 if (debug_linux_nat)
4753 fprintf_unfiltered (gdb_stdlog,
4754 "linux-nat: already stopping LWP %ld at "
4756 ptid_get_lwp (lwp->ptid));
4760 stop_callback (lwp, NULL);
4761 lwp->last_resume_kind = resume_stop;
4765 /* Already known to be stopped; do nothing. */
4767 if (debug_linux_nat)
4769 if (find_thread_ptid (lwp->ptid)->stop_requested)
4770 fprintf_unfiltered (gdb_stdlog,
4771 "LNSL: already stopped/stop_requested %s\n",
4772 target_pid_to_str (lwp->ptid));
4774 fprintf_unfiltered (gdb_stdlog,
4775 "LNSL: already stopped/no "
4776 "stop_requested yet %s\n",
4777 target_pid_to_str (lwp->ptid));
4784 linux_nat_stop (struct target_ops *self, ptid_t ptid)
4787 iterate_over_lwps (ptid, linux_nat_stop_lwp, NULL);
4789 linux_ops->to_stop (linux_ops, ptid);
4793 linux_nat_close (struct target_ops *self)
4795 /* Unregister from the event loop. */
4796 if (linux_nat_is_async_p (NULL))
4797 linux_nat_async (NULL, NULL, 0);
4799 if (linux_ops->to_close)
4800 linux_ops->to_close (linux_ops);
4803 /* When requests are passed down from the linux-nat layer to the
4804 single threaded inf-ptrace layer, ptids of (lwpid,0,0) form are
4805 used. The address space pointer is stored in the inferior object,
4806 but the common code that is passed such ptid can't tell whether
4807 lwpid is a "main" process id or not (it assumes so). We reverse
4808 look up the "main" process id from the lwp here. */
4810 static struct address_space *
4811 linux_nat_thread_address_space (struct target_ops *t, ptid_t ptid)
4813 struct lwp_info *lwp;
4814 struct inferior *inf;
4817 pid = ptid_get_lwp (ptid);
4818 if (ptid_get_lwp (ptid) == 0)
4820 /* An (lwpid,0,0) ptid. Look up the lwp object to get at the
4822 lwp = find_lwp_pid (ptid);
4823 pid = ptid_get_pid (lwp->ptid);
4827 /* A (pid,lwpid,0) ptid. */
4828 pid = ptid_get_pid (ptid);
4831 inf = find_inferior_pid (pid);
4832 gdb_assert (inf != NULL);
4836 /* Return the cached value of the processor core for thread PTID. */
4839 linux_nat_core_of_thread (struct target_ops *ops, ptid_t ptid)
4841 struct lwp_info *info = find_lwp_pid (ptid);
4849 linux_nat_add_target (struct target_ops *t)
4851 /* Save the provided single-threaded target. We save this in a separate
4852 variable because another target we've inherited from (e.g. inf-ptrace)
4853 may have saved a pointer to T; we want to use it for the final
4854 process stratum target. */
4855 linux_ops_saved = *t;
4856 linux_ops = &linux_ops_saved;
4858 /* Override some methods for multithreading. */
4859 t->to_create_inferior = linux_nat_create_inferior;
4860 t->to_attach = linux_nat_attach;
4861 t->to_detach = linux_nat_detach;
4862 t->to_resume = linux_nat_resume;
4863 t->to_wait = linux_nat_wait;
4864 t->to_pass_signals = linux_nat_pass_signals;
4865 t->to_xfer_partial = linux_nat_xfer_partial;
4866 t->to_kill = linux_nat_kill;
4867 t->to_mourn_inferior = linux_nat_mourn_inferior;
4868 t->to_thread_alive = linux_nat_thread_alive;
4869 t->to_pid_to_str = linux_nat_pid_to_str;
4870 t->to_thread_name = linux_nat_thread_name;
4871 t->to_has_thread_control = tc_schedlock;
4872 t->to_thread_address_space = linux_nat_thread_address_space;
4873 t->to_stopped_by_watchpoint = linux_nat_stopped_by_watchpoint;
4874 t->to_stopped_data_address = linux_nat_stopped_data_address;
4876 t->to_can_async_p = linux_nat_can_async_p;
4877 t->to_is_async_p = linux_nat_is_async_p;
4878 t->to_supports_non_stop = linux_nat_supports_non_stop;
4879 t->to_async = linux_nat_async;
4880 t->to_terminal_inferior = linux_nat_terminal_inferior;
4881 t->to_terminal_ours = linux_nat_terminal_ours;
4882 t->to_close = linux_nat_close;
4884 /* Methods for non-stop support. */
4885 t->to_stop = linux_nat_stop;
4887 t->to_supports_multi_process = linux_nat_supports_multi_process;
4889 t->to_supports_disable_randomization
4890 = linux_nat_supports_disable_randomization;
4892 t->to_core_of_thread = linux_nat_core_of_thread;
4894 /* We don't change the stratum; this target will sit at
4895 process_stratum and thread_db will set at thread_stratum. This
4896 is a little strange, since this is a multi-threaded-capable
4897 target, but we want to be on the stack below thread_db, and we
4898 also want to be used for single-threaded processes. */
4903 /* Register a method to call whenever a new thread is attached. */
4905 linux_nat_set_new_thread (struct target_ops *t,
4906 void (*new_thread) (struct lwp_info *))
4908 /* Save the pointer. We only support a single registered instance
4909 of the GNU/Linux native target, so we do not need to map this to
4911 linux_nat_new_thread = new_thread;
4914 /* See declaration in linux-nat.h. */
4917 linux_nat_set_new_fork (struct target_ops *t,
4918 linux_nat_new_fork_ftype *new_fork)
4920 /* Save the pointer. */
4921 linux_nat_new_fork = new_fork;
4924 /* See declaration in linux-nat.h. */
4927 linux_nat_set_forget_process (struct target_ops *t,
4928 linux_nat_forget_process_ftype *fn)
4930 /* Save the pointer. */
4931 linux_nat_forget_process_hook = fn;
4934 /* See declaration in linux-nat.h. */
4937 linux_nat_forget_process (pid_t pid)
4939 if (linux_nat_forget_process_hook != NULL)
4940 linux_nat_forget_process_hook (pid);
4943 /* Register a method that converts a siginfo object between the layout
4944 that ptrace returns, and the layout in the architecture of the
4947 linux_nat_set_siginfo_fixup (struct target_ops *t,
4948 int (*siginfo_fixup) (siginfo_t *,
4952 /* Save the pointer. */
4953 linux_nat_siginfo_fixup = siginfo_fixup;
4956 /* Register a method to call prior to resuming a thread. */
4959 linux_nat_set_prepare_to_resume (struct target_ops *t,
4960 void (*prepare_to_resume) (struct lwp_info *))
4962 /* Save the pointer. */
4963 linux_nat_prepare_to_resume = prepare_to_resume;
4966 /* See linux-nat.h. */
4969 linux_nat_get_siginfo (ptid_t ptid, siginfo_t *siginfo)
4973 pid = ptid_get_lwp (ptid);
4975 pid = ptid_get_pid (ptid);
4978 ptrace (PTRACE_GETSIGINFO, pid, (PTRACE_TYPE_ARG3) 0, siginfo);
4981 memset (siginfo, 0, sizeof (*siginfo));
4987 /* Provide a prototype to silence -Wmissing-prototypes. */
4988 extern initialize_file_ftype _initialize_linux_nat;
4991 _initialize_linux_nat (void)
4993 add_setshow_zuinteger_cmd ("lin-lwp", class_maintenance,
4994 &debug_linux_nat, _("\
4995 Set debugging of GNU/Linux lwp module."), _("\
4996 Show debugging of GNU/Linux lwp module."), _("\
4997 Enables printf debugging output."),
4999 show_debug_linux_nat,
5000 &setdebuglist, &showdebuglist);
5002 /* Save this mask as the default. */
5003 sigprocmask (SIG_SETMASK, NULL, &normal_mask);
5005 /* Install a SIGCHLD handler. */
5006 sigchld_action.sa_handler = sigchld_handler;
5007 sigemptyset (&sigchld_action.sa_mask);
5008 sigchld_action.sa_flags = SA_RESTART;
5010 /* Make it the default. */
5011 sigaction (SIGCHLD, &sigchld_action, NULL);
5013 /* Make sure we don't block SIGCHLD during a sigsuspend. */
5014 sigprocmask (SIG_SETMASK, NULL, &suspend_mask);
5015 sigdelset (&suspend_mask, SIGCHLD);
5017 sigemptyset (&blocked_mask);
5021 /* FIXME: kettenis/2000-08-26: The stuff on this page is specific to
5022 the GNU/Linux Threads library and therefore doesn't really belong
5025 /* Read variable NAME in the target and return its value if found.
5026 Otherwise return zero. It is assumed that the type of the variable
5030 get_signo (const char *name)
5032 struct minimal_symbol *ms;
5035 ms = lookup_minimal_symbol (name, NULL, NULL);
5039 if (target_read_memory (SYMBOL_VALUE_ADDRESS (ms), (gdb_byte *) &signo,
5040 sizeof (signo)) != 0)
5046 /* Return the set of signals used by the threads library in *SET. */
5049 lin_thread_get_thread_signals (sigset_t *set)
5051 struct sigaction action;
5052 int restart, cancel;
5054 sigemptyset (&blocked_mask);
5057 restart = get_signo ("__pthread_sig_restart");
5058 cancel = get_signo ("__pthread_sig_cancel");
5060 /* LinuxThreads normally uses the first two RT signals, but in some legacy
5061 cases may use SIGUSR1/SIGUSR2. NPTL always uses RT signals, but does
5062 not provide any way for the debugger to query the signal numbers -
5063 fortunately they don't change! */
5066 restart = __SIGRTMIN;
5069 cancel = __SIGRTMIN + 1;
5071 sigaddset (set, restart);
5072 sigaddset (set, cancel);
5074 /* The GNU/Linux Threads library makes terminating threads send a
5075 special "cancel" signal instead of SIGCHLD. Make sure we catch
5076 those (to prevent them from terminating GDB itself, which is
5077 likely to be their default action) and treat them the same way as
5080 action.sa_handler = sigchld_handler;
5081 sigemptyset (&action.sa_mask);
5082 action.sa_flags = SA_RESTART;
5083 sigaction (cancel, &action, NULL);
5085 /* We block the "cancel" signal throughout this code ... */
5086 sigaddset (&blocked_mask, cancel);
5087 sigprocmask (SIG_BLOCK, &blocked_mask, NULL);
5089 /* ... except during a sigsuspend. */
5090 sigdelset (&suspend_mask, cancel);