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 (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 (int pid)
701 return !linux_supports_tracefork ();
705 linux_child_remove_fork_catchpoint (int pid)
711 linux_child_insert_vfork_catchpoint (int pid)
713 return !linux_supports_tracefork ();
717 linux_child_remove_vfork_catchpoint (int pid)
723 linux_child_insert_exec_catchpoint (int pid)
725 return !linux_supports_tracefork ();
729 linux_child_remove_exec_catchpoint (int pid)
735 linux_child_set_syscall_catchpoint (int pid, int needed, int any_count,
736 int table_size, int *table)
738 if (!linux_supports_tracesysgood ())
741 /* On GNU/Linux, we ignore the arguments. It means that we only
742 enable the syscall catchpoints, but do not disable them.
744 Also, we do not use the `table' information because we do not
745 filter system calls here. We let GDB do the logic for us. */
749 /* On GNU/Linux there are no real LWP's. The closest thing to LWP's
750 are processes sharing the same VM space. A multi-threaded process
751 is basically a group of such processes. However, such a grouping
752 is almost entirely a user-space issue; the kernel doesn't enforce
753 such a grouping at all (this might change in the future). In
754 general, we'll rely on the threads library (i.e. the GNU/Linux
755 Threads library) to provide such a grouping.
757 It is perfectly well possible to write a multi-threaded application
758 without the assistance of a threads library, by using the clone
759 system call directly. This module should be able to give some
760 rudimentary support for debugging such applications if developers
761 specify the CLONE_PTRACE flag in the clone system call, and are
762 using the Linux kernel 2.4 or above.
764 Note that there are some peculiarities in GNU/Linux that affect
767 - In general one should specify the __WCLONE flag to waitpid in
768 order to make it report events for any of the cloned processes
769 (and leave it out for the initial process). However, if a cloned
770 process has exited the exit status is only reported if the
771 __WCLONE flag is absent. Linux kernel 2.4 has a __WALL flag, but
772 we cannot use it since GDB must work on older systems too.
774 - When a traced, cloned process exits and is waited for by the
775 debugger, the kernel reassigns it to the original parent and
776 keeps it around as a "zombie". Somehow, the GNU/Linux Threads
777 library doesn't notice this, which leads to the "zombie problem":
778 When debugged a multi-threaded process that spawns a lot of
779 threads will run out of processes, even if the threads exit,
780 because the "zombies" stay around. */
782 /* List of known LWPs. */
783 struct lwp_info *lwp_list;
786 /* Original signal mask. */
787 static sigset_t normal_mask;
789 /* Signal mask for use with sigsuspend in linux_nat_wait, initialized in
790 _initialize_linux_nat. */
791 static sigset_t suspend_mask;
793 /* Signals to block to make that sigsuspend work. */
794 static sigset_t blocked_mask;
796 /* SIGCHLD action. */
797 struct sigaction sigchld_action;
799 /* Block child signals (SIGCHLD and linux threads signals), and store
800 the previous mask in PREV_MASK. */
803 block_child_signals (sigset_t *prev_mask)
805 /* Make sure SIGCHLD is blocked. */
806 if (!sigismember (&blocked_mask, SIGCHLD))
807 sigaddset (&blocked_mask, SIGCHLD);
809 sigprocmask (SIG_BLOCK, &blocked_mask, prev_mask);
812 /* Restore child signals mask, previously returned by
813 block_child_signals. */
816 restore_child_signals_mask (sigset_t *prev_mask)
818 sigprocmask (SIG_SETMASK, prev_mask, NULL);
821 /* Mask of signals to pass directly to the inferior. */
822 static sigset_t pass_mask;
824 /* Update signals to pass to the inferior. */
826 linux_nat_pass_signals (int numsigs, unsigned char *pass_signals)
830 sigemptyset (&pass_mask);
832 for (signo = 1; signo < NSIG; signo++)
834 int target_signo = gdb_signal_from_host (signo);
835 if (target_signo < numsigs && pass_signals[target_signo])
836 sigaddset (&pass_mask, signo);
842 /* Prototypes for local functions. */
843 static int stop_wait_callback (struct lwp_info *lp, void *data);
844 static int linux_thread_alive (ptid_t ptid);
845 static char *linux_child_pid_to_exec_file (int pid);
848 /* Convert wait status STATUS to a string. Used for printing debug
852 status_to_str (int status)
856 if (WIFSTOPPED (status))
858 if (WSTOPSIG (status) == SYSCALL_SIGTRAP)
859 snprintf (buf, sizeof (buf), "%s (stopped at syscall)",
860 strsignal (SIGTRAP));
862 snprintf (buf, sizeof (buf), "%s (stopped)",
863 strsignal (WSTOPSIG (status)));
865 else if (WIFSIGNALED (status))
866 snprintf (buf, sizeof (buf), "%s (terminated)",
867 strsignal (WTERMSIG (status)));
869 snprintf (buf, sizeof (buf), "%d (exited)", WEXITSTATUS (status));
874 /* Destroy and free LP. */
877 lwp_free (struct lwp_info *lp)
879 xfree (lp->arch_private);
883 /* Remove all LWPs belong to PID from the lwp list. */
886 purge_lwp_list (int pid)
888 struct lwp_info *lp, *lpprev, *lpnext;
892 for (lp = lwp_list; lp; lp = lpnext)
896 if (ptid_get_pid (lp->ptid) == pid)
901 lpprev->next = lp->next;
910 /* Add the LWP specified by PTID to the list. PTID is the first LWP
911 in the process. Return a pointer to the structure describing the
914 This differs from add_lwp in that we don't let the arch specific
915 bits know about this new thread. Current clients of this callback
916 take the opportunity to install watchpoints in the new thread, and
917 we shouldn't do that for the first thread. If we're spawning a
918 child ("run"), the thread executes the shell wrapper first, and we
919 shouldn't touch it until it execs the program we want to debug.
920 For "attach", it'd be okay to call the callback, but it's not
921 necessary, because watchpoints can't yet have been inserted into
924 static struct lwp_info *
925 add_initial_lwp (ptid_t ptid)
929 gdb_assert (ptid_lwp_p (ptid));
931 lp = (struct lwp_info *) xmalloc (sizeof (struct lwp_info));
933 memset (lp, 0, sizeof (struct lwp_info));
935 lp->last_resume_kind = resume_continue;
936 lp->waitstatus.kind = TARGET_WAITKIND_IGNORE;
947 /* Add the LWP specified by PID to the list. Return a pointer to the
948 structure describing the new LWP. The LWP should already be
951 static struct lwp_info *
952 add_lwp (ptid_t ptid)
956 lp = add_initial_lwp (ptid);
958 /* Let the arch specific bits know about this new thread. Current
959 clients of this callback take the opportunity to install
960 watchpoints in the new thread. We don't do this for the first
961 thread though. See add_initial_lwp. */
962 if (linux_nat_new_thread != NULL)
963 linux_nat_new_thread (lp);
968 /* Remove the LWP specified by PID from the list. */
971 delete_lwp (ptid_t ptid)
973 struct lwp_info *lp, *lpprev;
977 for (lp = lwp_list; lp; lpprev = lp, lp = lp->next)
978 if (ptid_equal (lp->ptid, ptid))
985 lpprev->next = lp->next;
992 /* Return a pointer to the structure describing the LWP corresponding
993 to PID. If no corresponding LWP could be found, return NULL. */
995 static struct lwp_info *
996 find_lwp_pid (ptid_t ptid)
1001 if (ptid_lwp_p (ptid))
1002 lwp = ptid_get_lwp (ptid);
1004 lwp = ptid_get_pid (ptid);
1006 for (lp = lwp_list; lp; lp = lp->next)
1007 if (lwp == ptid_get_lwp (lp->ptid))
1013 /* Call CALLBACK with its second argument set to DATA for every LWP in
1014 the list. If CALLBACK returns 1 for a particular LWP, return a
1015 pointer to the structure describing that LWP immediately.
1016 Otherwise return NULL. */
1019 iterate_over_lwps (ptid_t filter,
1020 int (*callback) (struct lwp_info *, void *),
1023 struct lwp_info *lp, *lpnext;
1025 for (lp = lwp_list; lp; lp = lpnext)
1029 if (ptid_match (lp->ptid, filter))
1031 if ((*callback) (lp, data))
1039 /* Update our internal state when changing from one checkpoint to
1040 another indicated by NEW_PTID. We can only switch single-threaded
1041 applications, so we only create one new LWP, and the previous list
1045 linux_nat_switch_fork (ptid_t new_ptid)
1047 struct lwp_info *lp;
1049 purge_lwp_list (ptid_get_pid (inferior_ptid));
1051 lp = add_lwp (new_ptid);
1054 /* This changes the thread's ptid while preserving the gdb thread
1055 num. Also changes the inferior pid, while preserving the
1057 thread_change_ptid (inferior_ptid, new_ptid);
1059 /* We've just told GDB core that the thread changed target id, but,
1060 in fact, it really is a different thread, with different register
1062 registers_changed ();
1065 /* Handle the exit of a single thread LP. */
1068 exit_lwp (struct lwp_info *lp)
1070 struct thread_info *th = find_thread_ptid (lp->ptid);
1074 if (print_thread_events)
1075 printf_unfiltered (_("[%s exited]\n"), target_pid_to_str (lp->ptid));
1077 delete_thread (lp->ptid);
1080 delete_lwp (lp->ptid);
1083 /* Wait for the LWP specified by LP, which we have just attached to.
1084 Returns a wait status for that LWP, to cache. */
1087 linux_nat_post_attach_wait (ptid_t ptid, int first, int *cloned,
1090 pid_t new_pid, pid = ptid_get_lwp (ptid);
1093 if (linux_proc_pid_is_stopped (pid))
1095 if (debug_linux_nat)
1096 fprintf_unfiltered (gdb_stdlog,
1097 "LNPAW: Attaching to a stopped process\n");
1099 /* The process is definitely stopped. It is in a job control
1100 stop, unless the kernel predates the TASK_STOPPED /
1101 TASK_TRACED distinction, in which case it might be in a
1102 ptrace stop. Make sure it is in a ptrace stop; from there we
1103 can kill it, signal it, et cetera.
1105 First make sure there is a pending SIGSTOP. Since we are
1106 already attached, the process can not transition from stopped
1107 to running without a PTRACE_CONT; so we know this signal will
1108 go into the queue. The SIGSTOP generated by PTRACE_ATTACH is
1109 probably already in the queue (unless this kernel is old
1110 enough to use TASK_STOPPED for ptrace stops); but since SIGSTOP
1111 is not an RT signal, it can only be queued once. */
1112 kill_lwp (pid, SIGSTOP);
1114 /* Finally, resume the stopped process. This will deliver the SIGSTOP
1115 (or a higher priority signal, just like normal PTRACE_ATTACH). */
1116 ptrace (PTRACE_CONT, pid, 0, 0);
1119 /* Make sure the initial process is stopped. The user-level threads
1120 layer might want to poke around in the inferior, and that won't
1121 work if things haven't stabilized yet. */
1122 new_pid = my_waitpid (pid, &status, 0);
1123 if (new_pid == -1 && errno == ECHILD)
1126 warning (_("%s is a cloned process"), target_pid_to_str (ptid));
1128 /* Try again with __WCLONE to check cloned processes. */
1129 new_pid = my_waitpid (pid, &status, __WCLONE);
1133 gdb_assert (pid == new_pid);
1135 if (!WIFSTOPPED (status))
1137 /* The pid we tried to attach has apparently just exited. */
1138 if (debug_linux_nat)
1139 fprintf_unfiltered (gdb_stdlog, "LNPAW: Failed to stop %d: %s",
1140 pid, status_to_str (status));
1144 if (WSTOPSIG (status) != SIGSTOP)
1147 if (debug_linux_nat)
1148 fprintf_unfiltered (gdb_stdlog,
1149 "LNPAW: Received %s after attaching\n",
1150 status_to_str (status));
1156 /* Attach to the LWP specified by PID. Return 0 if successful, -1 if
1157 the new LWP could not be attached, or 1 if we're already auto
1158 attached to this thread, but haven't processed the
1159 PTRACE_EVENT_CLONE event of its parent thread, so we just ignore
1160 its existance, without considering it an error. */
1163 lin_lwp_attach_lwp (ptid_t ptid)
1165 struct lwp_info *lp;
1168 gdb_assert (ptid_lwp_p (ptid));
1170 lp = find_lwp_pid (ptid);
1171 lwpid = ptid_get_lwp (ptid);
1173 /* We assume that we're already attached to any LWP that has an id
1174 equal to the overall process id, and to any LWP that is already
1175 in our list of LWPs. If we're not seeing exit events from threads
1176 and we've had PID wraparound since we last tried to stop all threads,
1177 this assumption might be wrong; fortunately, this is very unlikely
1179 if (lwpid != ptid_get_pid (ptid) && lp == NULL)
1181 int status, cloned = 0, signalled = 0;
1183 if (ptrace (PTRACE_ATTACH, lwpid, 0, 0) < 0)
1185 if (linux_supports_tracefork ())
1187 /* If we haven't stopped all threads when we get here,
1188 we may have seen a thread listed in thread_db's list,
1189 but not processed the PTRACE_EVENT_CLONE yet. If
1190 that's the case, ignore this new thread, and let
1191 normal event handling discover it later. */
1192 if (in_pid_list_p (stopped_pids, lwpid))
1194 /* We've already seen this thread stop, but we
1195 haven't seen the PTRACE_EVENT_CLONE extended
1204 /* See if we've got a stop for this new child
1205 pending. If so, we're already attached. */
1206 new_pid = my_waitpid (lwpid, &status, WNOHANG);
1207 if (new_pid == -1 && errno == ECHILD)
1208 new_pid = my_waitpid (lwpid, &status, __WCLONE | WNOHANG);
1211 if (WIFSTOPPED (status))
1212 add_to_pid_list (&stopped_pids, lwpid, status);
1218 /* If we fail to attach to the thread, issue a warning,
1219 but continue. One way this can happen is if thread
1220 creation is interrupted; as of Linux kernel 2.6.19, a
1221 bug may place threads in the thread list and then fail
1223 warning (_("Can't attach %s: %s"), target_pid_to_str (ptid),
1224 safe_strerror (errno));
1228 if (debug_linux_nat)
1229 fprintf_unfiltered (gdb_stdlog,
1230 "LLAL: PTRACE_ATTACH %s, 0, 0 (OK)\n",
1231 target_pid_to_str (ptid));
1233 status = linux_nat_post_attach_wait (ptid, 0, &cloned, &signalled);
1234 if (!WIFSTOPPED (status))
1237 lp = add_lwp (ptid);
1239 lp->cloned = cloned;
1240 lp->signalled = signalled;
1241 if (WSTOPSIG (status) != SIGSTOP)
1244 lp->status = status;
1247 target_post_attach (ptid_get_lwp (lp->ptid));
1249 if (debug_linux_nat)
1251 fprintf_unfiltered (gdb_stdlog,
1252 "LLAL: waitpid %s received %s\n",
1253 target_pid_to_str (ptid),
1254 status_to_str (status));
1259 /* We assume that the LWP representing the original process is
1260 already stopped. Mark it as stopped in the data structure
1261 that the GNU/linux ptrace layer uses to keep track of
1262 threads. Note that this won't have already been done since
1263 the main thread will have, we assume, been stopped by an
1264 attach from a different layer. */
1266 lp = add_lwp (ptid);
1270 lp->last_resume_kind = resume_stop;
1275 linux_nat_create_inferior (struct target_ops *ops,
1276 char *exec_file, char *allargs, char **env,
1279 #ifdef HAVE_PERSONALITY
1280 int personality_orig = 0, personality_set = 0;
1281 #endif /* HAVE_PERSONALITY */
1283 /* The fork_child mechanism is synchronous and calls target_wait, so
1284 we have to mask the async mode. */
1286 #ifdef HAVE_PERSONALITY
1287 if (disable_randomization)
1290 personality_orig = personality (0xffffffff);
1291 if (errno == 0 && !(personality_orig & ADDR_NO_RANDOMIZE))
1293 personality_set = 1;
1294 personality (personality_orig | ADDR_NO_RANDOMIZE);
1296 if (errno != 0 || (personality_set
1297 && !(personality (0xffffffff) & ADDR_NO_RANDOMIZE)))
1298 warning (_("Error disabling address space randomization: %s"),
1299 safe_strerror (errno));
1301 #endif /* HAVE_PERSONALITY */
1303 /* Make sure we report all signals during startup. */
1304 linux_nat_pass_signals (0, NULL);
1306 linux_ops->to_create_inferior (ops, exec_file, allargs, env, from_tty);
1308 #ifdef HAVE_PERSONALITY
1309 if (personality_set)
1312 personality (personality_orig);
1314 warning (_("Error restoring address space randomization: %s"),
1315 safe_strerror (errno));
1317 #endif /* HAVE_PERSONALITY */
1321 linux_nat_attach (struct target_ops *ops, char *args, int from_tty)
1323 struct lwp_info *lp;
1326 volatile struct gdb_exception ex;
1328 /* Make sure we report all signals during attach. */
1329 linux_nat_pass_signals (0, NULL);
1331 TRY_CATCH (ex, RETURN_MASK_ERROR)
1333 linux_ops->to_attach (ops, args, from_tty);
1337 pid_t pid = parse_pid_to_attach (args);
1338 struct buffer buffer;
1339 char *message, *buffer_s;
1341 message = xstrdup (ex.message);
1342 make_cleanup (xfree, message);
1344 buffer_init (&buffer);
1345 linux_ptrace_attach_warnings (pid, &buffer);
1347 buffer_grow_str0 (&buffer, "");
1348 buffer_s = buffer_finish (&buffer);
1349 make_cleanup (xfree, buffer_s);
1351 throw_error (ex.error, "%s%s", buffer_s, message);
1354 /* The ptrace base target adds the main thread with (pid,0,0)
1355 format. Decorate it with lwp info. */
1356 ptid = ptid_build (ptid_get_pid (inferior_ptid),
1357 ptid_get_pid (inferior_ptid),
1359 thread_change_ptid (inferior_ptid, ptid);
1361 /* Add the initial process as the first LWP to the list. */
1362 lp = add_initial_lwp (ptid);
1364 status = linux_nat_post_attach_wait (lp->ptid, 1, &lp->cloned,
1366 if (!WIFSTOPPED (status))
1368 if (WIFEXITED (status))
1370 int exit_code = WEXITSTATUS (status);
1372 target_terminal_ours ();
1373 target_mourn_inferior ();
1375 error (_("Unable to attach: program exited normally."));
1377 error (_("Unable to attach: program exited with code %d."),
1380 else if (WIFSIGNALED (status))
1382 enum gdb_signal signo;
1384 target_terminal_ours ();
1385 target_mourn_inferior ();
1387 signo = gdb_signal_from_host (WTERMSIG (status));
1388 error (_("Unable to attach: program terminated with signal "
1390 gdb_signal_to_name (signo),
1391 gdb_signal_to_string (signo));
1394 internal_error (__FILE__, __LINE__,
1395 _("unexpected status %d for PID %ld"),
1396 status, (long) ptid_get_lwp (ptid));
1401 /* Save the wait status to report later. */
1403 if (debug_linux_nat)
1404 fprintf_unfiltered (gdb_stdlog,
1405 "LNA: waitpid %ld, saving status %s\n",
1406 (long) ptid_get_pid (lp->ptid), status_to_str (status));
1408 lp->status = status;
1410 if (target_can_async_p ())
1411 target_async (inferior_event_handler, 0);
1414 /* Get pending status of LP. */
1416 get_pending_status (struct lwp_info *lp, int *status)
1418 enum gdb_signal signo = GDB_SIGNAL_0;
1420 /* If we paused threads momentarily, we may have stored pending
1421 events in lp->status or lp->waitstatus (see stop_wait_callback),
1422 and GDB core hasn't seen any signal for those threads.
1423 Otherwise, the last signal reported to the core is found in the
1424 thread object's stop_signal.
1426 There's a corner case that isn't handled here at present. Only
1427 if the thread stopped with a TARGET_WAITKIND_STOPPED does
1428 stop_signal make sense as a real signal to pass to the inferior.
1429 Some catchpoint related events, like
1430 TARGET_WAITKIND_(V)FORK|EXEC|SYSCALL, have their stop_signal set
1431 to GDB_SIGNAL_SIGTRAP when the catchpoint triggers. But,
1432 those traps are debug API (ptrace in our case) related and
1433 induced; the inferior wouldn't see them if it wasn't being
1434 traced. Hence, we should never pass them to the inferior, even
1435 when set to pass state. Since this corner case isn't handled by
1436 infrun.c when proceeding with a signal, for consistency, neither
1437 do we handle it here (or elsewhere in the file we check for
1438 signal pass state). Normally SIGTRAP isn't set to pass state, so
1439 this is really a corner case. */
1441 if (lp->waitstatus.kind != TARGET_WAITKIND_IGNORE)
1442 signo = GDB_SIGNAL_0; /* a pending ptrace event, not a real signal. */
1443 else if (lp->status)
1444 signo = gdb_signal_from_host (WSTOPSIG (lp->status));
1445 else if (non_stop && !is_executing (lp->ptid))
1447 struct thread_info *tp = find_thread_ptid (lp->ptid);
1449 signo = tp->suspend.stop_signal;
1453 struct target_waitstatus last;
1456 get_last_target_status (&last_ptid, &last);
1458 if (ptid_get_lwp (lp->ptid) == ptid_get_lwp (last_ptid))
1460 struct thread_info *tp = find_thread_ptid (lp->ptid);
1462 signo = tp->suspend.stop_signal;
1468 if (signo == GDB_SIGNAL_0)
1470 if (debug_linux_nat)
1471 fprintf_unfiltered (gdb_stdlog,
1472 "GPT: lwp %s has no pending signal\n",
1473 target_pid_to_str (lp->ptid));
1475 else if (!signal_pass_state (signo))
1477 if (debug_linux_nat)
1478 fprintf_unfiltered (gdb_stdlog,
1479 "GPT: lwp %s had signal %s, "
1480 "but it is in no pass state\n",
1481 target_pid_to_str (lp->ptid),
1482 gdb_signal_to_string (signo));
1486 *status = W_STOPCODE (gdb_signal_to_host (signo));
1488 if (debug_linux_nat)
1489 fprintf_unfiltered (gdb_stdlog,
1490 "GPT: lwp %s has pending signal %s\n",
1491 target_pid_to_str (lp->ptid),
1492 gdb_signal_to_string (signo));
1499 detach_callback (struct lwp_info *lp, void *data)
1501 gdb_assert (lp->status == 0 || WIFSTOPPED (lp->status));
1503 if (debug_linux_nat && lp->status)
1504 fprintf_unfiltered (gdb_stdlog, "DC: Pending %s for %s on detach.\n",
1505 strsignal (WSTOPSIG (lp->status)),
1506 target_pid_to_str (lp->ptid));
1508 /* If there is a pending SIGSTOP, get rid of it. */
1511 if (debug_linux_nat)
1512 fprintf_unfiltered (gdb_stdlog,
1513 "DC: Sending SIGCONT to %s\n",
1514 target_pid_to_str (lp->ptid));
1516 kill_lwp (ptid_get_lwp (lp->ptid), SIGCONT);
1520 /* We don't actually detach from the LWP that has an id equal to the
1521 overall process id just yet. */
1522 if (ptid_get_lwp (lp->ptid) != ptid_get_pid (lp->ptid))
1526 /* Pass on any pending signal for this LWP. */
1527 get_pending_status (lp, &status);
1529 if (linux_nat_prepare_to_resume != NULL)
1530 linux_nat_prepare_to_resume (lp);
1532 if (ptrace (PTRACE_DETACH, ptid_get_lwp (lp->ptid), 0,
1533 WSTOPSIG (status)) < 0)
1534 error (_("Can't detach %s: %s"), target_pid_to_str (lp->ptid),
1535 safe_strerror (errno));
1537 if (debug_linux_nat)
1538 fprintf_unfiltered (gdb_stdlog,
1539 "PTRACE_DETACH (%s, %s, 0) (OK)\n",
1540 target_pid_to_str (lp->ptid),
1541 strsignal (WSTOPSIG (status)));
1543 delete_lwp (lp->ptid);
1550 linux_nat_detach (struct target_ops *ops, const char *args, int from_tty)
1554 struct lwp_info *main_lwp;
1556 pid = ptid_get_pid (inferior_ptid);
1558 /* Don't unregister from the event loop, as there may be other
1559 inferiors running. */
1561 /* Stop all threads before detaching. ptrace requires that the
1562 thread is stopped to sucessfully detach. */
1563 iterate_over_lwps (pid_to_ptid (pid), stop_callback, NULL);
1564 /* ... and wait until all of them have reported back that
1565 they're no longer running. */
1566 iterate_over_lwps (pid_to_ptid (pid), stop_wait_callback, NULL);
1568 iterate_over_lwps (pid_to_ptid (pid), detach_callback, NULL);
1570 /* Only the initial process should be left right now. */
1571 gdb_assert (num_lwps (ptid_get_pid (inferior_ptid)) == 1);
1573 main_lwp = find_lwp_pid (pid_to_ptid (pid));
1575 /* Pass on any pending signal for the last LWP. */
1576 if ((args == NULL || *args == '\0')
1577 && get_pending_status (main_lwp, &status) != -1
1578 && WIFSTOPPED (status))
1582 /* Put the signal number in ARGS so that inf_ptrace_detach will
1583 pass it along with PTRACE_DETACH. */
1585 xsnprintf (tem, 8, "%d", (int) WSTOPSIG (status));
1587 if (debug_linux_nat)
1588 fprintf_unfiltered (gdb_stdlog,
1589 "LND: Sending signal %s to %s\n",
1591 target_pid_to_str (main_lwp->ptid));
1594 if (linux_nat_prepare_to_resume != NULL)
1595 linux_nat_prepare_to_resume (main_lwp);
1596 delete_lwp (main_lwp->ptid);
1598 if (forks_exist_p ())
1600 /* Multi-fork case. The current inferior_ptid is being detached
1601 from, but there are other viable forks to debug. Detach from
1602 the current fork, and context-switch to the first
1604 linux_fork_detach (args, from_tty);
1607 linux_ops->to_detach (ops, args, from_tty);
1613 resume_lwp (struct lwp_info *lp, int step, enum gdb_signal signo)
1617 struct inferior *inf = find_inferior_pid (ptid_get_pid (lp->ptid));
1619 if (inf->vfork_child != NULL)
1621 if (debug_linux_nat)
1622 fprintf_unfiltered (gdb_stdlog,
1623 "RC: Not resuming %s (vfork parent)\n",
1624 target_pid_to_str (lp->ptid));
1626 else if (lp->status == 0
1627 && lp->waitstatus.kind == TARGET_WAITKIND_IGNORE)
1629 if (debug_linux_nat)
1630 fprintf_unfiltered (gdb_stdlog,
1631 "RC: Resuming sibling %s, %s, %s\n",
1632 target_pid_to_str (lp->ptid),
1633 (signo != GDB_SIGNAL_0
1634 ? strsignal (gdb_signal_to_host (signo))
1636 step ? "step" : "resume");
1638 if (linux_nat_prepare_to_resume != NULL)
1639 linux_nat_prepare_to_resume (lp);
1640 linux_ops->to_resume (linux_ops,
1641 pid_to_ptid (ptid_get_lwp (lp->ptid)),
1645 lp->stopped_by_watchpoint = 0;
1649 if (debug_linux_nat)
1650 fprintf_unfiltered (gdb_stdlog,
1651 "RC: Not resuming sibling %s (has pending)\n",
1652 target_pid_to_str (lp->ptid));
1657 if (debug_linux_nat)
1658 fprintf_unfiltered (gdb_stdlog,
1659 "RC: Not resuming sibling %s (not stopped)\n",
1660 target_pid_to_str (lp->ptid));
1664 /* Resume LWP, with the last stop signal, if it is in pass state. */
1667 linux_nat_resume_callback (struct lwp_info *lp, void *data)
1669 enum gdb_signal signo = GDB_SIGNAL_0;
1673 struct thread_info *thread;
1675 thread = find_thread_ptid (lp->ptid);
1678 if (signal_pass_state (thread->suspend.stop_signal))
1679 signo = thread->suspend.stop_signal;
1680 thread->suspend.stop_signal = GDB_SIGNAL_0;
1684 resume_lwp (lp, 0, signo);
1689 resume_clear_callback (struct lwp_info *lp, void *data)
1692 lp->last_resume_kind = resume_stop;
1697 resume_set_callback (struct lwp_info *lp, void *data)
1700 lp->last_resume_kind = resume_continue;
1705 linux_nat_resume (struct target_ops *ops,
1706 ptid_t ptid, int step, enum gdb_signal signo)
1708 struct lwp_info *lp;
1711 if (debug_linux_nat)
1712 fprintf_unfiltered (gdb_stdlog,
1713 "LLR: Preparing to %s %s, %s, inferior_ptid %s\n",
1714 step ? "step" : "resume",
1715 target_pid_to_str (ptid),
1716 (signo != GDB_SIGNAL_0
1717 ? strsignal (gdb_signal_to_host (signo)) : "0"),
1718 target_pid_to_str (inferior_ptid));
1720 /* A specific PTID means `step only this process id'. */
1721 resume_many = (ptid_equal (minus_one_ptid, ptid)
1722 || ptid_is_pid (ptid));
1724 /* Mark the lwps we're resuming as resumed. */
1725 iterate_over_lwps (ptid, resume_set_callback, NULL);
1727 /* See if it's the current inferior that should be handled
1730 lp = find_lwp_pid (inferior_ptid);
1732 lp = find_lwp_pid (ptid);
1733 gdb_assert (lp != NULL);
1735 /* Remember if we're stepping. */
1737 lp->last_resume_kind = step ? resume_step : resume_continue;
1739 /* If we have a pending wait status for this thread, there is no
1740 point in resuming the process. But first make sure that
1741 linux_nat_wait won't preemptively handle the event - we
1742 should never take this short-circuit if we are going to
1743 leave LP running, since we have skipped resuming all the
1744 other threads. This bit of code needs to be synchronized
1745 with linux_nat_wait. */
1747 if (lp->status && WIFSTOPPED (lp->status))
1750 && WSTOPSIG (lp->status)
1751 && sigismember (&pass_mask, WSTOPSIG (lp->status)))
1753 if (debug_linux_nat)
1754 fprintf_unfiltered (gdb_stdlog,
1755 "LLR: Not short circuiting for ignored "
1756 "status 0x%x\n", lp->status);
1758 /* FIXME: What should we do if we are supposed to continue
1759 this thread with a signal? */
1760 gdb_assert (signo == GDB_SIGNAL_0);
1761 signo = gdb_signal_from_host (WSTOPSIG (lp->status));
1766 if (lp->status || lp->waitstatus.kind != TARGET_WAITKIND_IGNORE)
1768 /* FIXME: What should we do if we are supposed to continue
1769 this thread with a signal? */
1770 gdb_assert (signo == GDB_SIGNAL_0);
1772 if (debug_linux_nat)
1773 fprintf_unfiltered (gdb_stdlog,
1774 "LLR: Short circuiting for status 0x%x\n",
1777 if (target_can_async_p ())
1779 target_async (inferior_event_handler, 0);
1780 /* Tell the event loop we have something to process. */
1786 /* Mark LWP as not stopped to prevent it from being continued by
1787 linux_nat_resume_callback. */
1791 iterate_over_lwps (ptid, linux_nat_resume_callback, NULL);
1793 /* Convert to something the lower layer understands. */
1794 ptid = pid_to_ptid (ptid_get_lwp (lp->ptid));
1796 if (linux_nat_prepare_to_resume != NULL)
1797 linux_nat_prepare_to_resume (lp);
1798 linux_ops->to_resume (linux_ops, ptid, step, signo);
1799 lp->stopped_by_watchpoint = 0;
1801 if (debug_linux_nat)
1802 fprintf_unfiltered (gdb_stdlog,
1803 "LLR: %s %s, %s (resume event thread)\n",
1804 step ? "PTRACE_SINGLESTEP" : "PTRACE_CONT",
1805 target_pid_to_str (ptid),
1806 (signo != GDB_SIGNAL_0
1807 ? strsignal (gdb_signal_to_host (signo)) : "0"));
1809 if (target_can_async_p ())
1810 target_async (inferior_event_handler, 0);
1813 /* Send a signal to an LWP. */
1816 kill_lwp (int lwpid, int signo)
1818 /* Use tkill, if possible, in case we are using nptl threads. If tkill
1819 fails, then we are not using nptl threads and we should be using kill. */
1821 #ifdef HAVE_TKILL_SYSCALL
1823 static int tkill_failed;
1830 ret = syscall (__NR_tkill, lwpid, signo);
1831 if (errno != ENOSYS)
1838 return kill (lwpid, signo);
1841 /* Handle a GNU/Linux syscall trap wait response. If we see a syscall
1842 event, check if the core is interested in it: if not, ignore the
1843 event, and keep waiting; otherwise, we need to toggle the LWP's
1844 syscall entry/exit status, since the ptrace event itself doesn't
1845 indicate it, and report the trap to higher layers. */
1848 linux_handle_syscall_trap (struct lwp_info *lp, int stopping)
1850 struct target_waitstatus *ourstatus = &lp->waitstatus;
1851 struct gdbarch *gdbarch = target_thread_architecture (lp->ptid);
1852 int syscall_number = (int) gdbarch_get_syscall_number (gdbarch, lp->ptid);
1856 /* If we're stopping threads, there's a SIGSTOP pending, which
1857 makes it so that the LWP reports an immediate syscall return,
1858 followed by the SIGSTOP. Skip seeing that "return" using
1859 PTRACE_CONT directly, and let stop_wait_callback collect the
1860 SIGSTOP. Later when the thread is resumed, a new syscall
1861 entry event. If we didn't do this (and returned 0), we'd
1862 leave a syscall entry pending, and our caller, by using
1863 PTRACE_CONT to collect the SIGSTOP, skips the syscall return
1864 itself. Later, when the user re-resumes this LWP, we'd see
1865 another syscall entry event and we'd mistake it for a return.
1867 If stop_wait_callback didn't force the SIGSTOP out of the LWP
1868 (leaving immediately with LWP->signalled set, without issuing
1869 a PTRACE_CONT), it would still be problematic to leave this
1870 syscall enter pending, as later when the thread is resumed,
1871 it would then see the same syscall exit mentioned above,
1872 followed by the delayed SIGSTOP, while the syscall didn't
1873 actually get to execute. It seems it would be even more
1874 confusing to the user. */
1876 if (debug_linux_nat)
1877 fprintf_unfiltered (gdb_stdlog,
1878 "LHST: ignoring syscall %d "
1879 "for LWP %ld (stopping threads), "
1880 "resuming with PTRACE_CONT for SIGSTOP\n",
1882 ptid_get_lwp (lp->ptid));
1884 lp->syscall_state = TARGET_WAITKIND_IGNORE;
1885 ptrace (PTRACE_CONT, ptid_get_lwp (lp->ptid), 0, 0);
1889 if (catch_syscall_enabled ())
1891 /* Always update the entry/return state, even if this particular
1892 syscall isn't interesting to the core now. In async mode,
1893 the user could install a new catchpoint for this syscall
1894 between syscall enter/return, and we'll need to know to
1895 report a syscall return if that happens. */
1896 lp->syscall_state = (lp->syscall_state == TARGET_WAITKIND_SYSCALL_ENTRY
1897 ? TARGET_WAITKIND_SYSCALL_RETURN
1898 : TARGET_WAITKIND_SYSCALL_ENTRY);
1900 if (catching_syscall_number (syscall_number))
1902 /* Alright, an event to report. */
1903 ourstatus->kind = lp->syscall_state;
1904 ourstatus->value.syscall_number = syscall_number;
1906 if (debug_linux_nat)
1907 fprintf_unfiltered (gdb_stdlog,
1908 "LHST: stopping for %s of syscall %d"
1911 == TARGET_WAITKIND_SYSCALL_ENTRY
1912 ? "entry" : "return",
1914 ptid_get_lwp (lp->ptid));
1918 if (debug_linux_nat)
1919 fprintf_unfiltered (gdb_stdlog,
1920 "LHST: ignoring %s of syscall %d "
1922 lp->syscall_state == TARGET_WAITKIND_SYSCALL_ENTRY
1923 ? "entry" : "return",
1925 ptid_get_lwp (lp->ptid));
1929 /* If we had been syscall tracing, and hence used PT_SYSCALL
1930 before on this LWP, it could happen that the user removes all
1931 syscall catchpoints before we get to process this event.
1932 There are two noteworthy issues here:
1934 - When stopped at a syscall entry event, resuming with
1935 PT_STEP still resumes executing the syscall and reports a
1938 - Only PT_SYSCALL catches syscall enters. If we last
1939 single-stepped this thread, then this event can't be a
1940 syscall enter. If we last single-stepped this thread, this
1941 has to be a syscall exit.
1943 The points above mean that the next resume, be it PT_STEP or
1944 PT_CONTINUE, can not trigger a syscall trace event. */
1945 if (debug_linux_nat)
1946 fprintf_unfiltered (gdb_stdlog,
1947 "LHST: caught syscall event "
1948 "with no syscall catchpoints."
1949 " %d for LWP %ld, ignoring\n",
1951 ptid_get_lwp (lp->ptid));
1952 lp->syscall_state = TARGET_WAITKIND_IGNORE;
1955 /* The core isn't interested in this event. For efficiency, avoid
1956 stopping all threads only to have the core resume them all again.
1957 Since we're not stopping threads, if we're still syscall tracing
1958 and not stepping, we can't use PTRACE_CONT here, as we'd miss any
1959 subsequent syscall. Simply resume using the inf-ptrace layer,
1960 which knows when to use PT_SYSCALL or PT_CONTINUE. */
1962 /* Note that gdbarch_get_syscall_number may access registers, hence
1964 registers_changed ();
1965 if (linux_nat_prepare_to_resume != NULL)
1966 linux_nat_prepare_to_resume (lp);
1967 linux_ops->to_resume (linux_ops, pid_to_ptid (ptid_get_lwp (lp->ptid)),
1968 lp->step, GDB_SIGNAL_0);
1972 /* Handle a GNU/Linux extended wait response. If we see a clone
1973 event, we need to add the new LWP to our list (and not report the
1974 trap to higher layers). This function returns non-zero if the
1975 event should be ignored and we should wait again. If STOPPING is
1976 true, the new LWP remains stopped, otherwise it is continued. */
1979 linux_handle_extended_wait (struct lwp_info *lp, int status,
1982 int pid = ptid_get_lwp (lp->ptid);
1983 struct target_waitstatus *ourstatus = &lp->waitstatus;
1984 int event = status >> 16;
1986 if (event == PTRACE_EVENT_FORK || event == PTRACE_EVENT_VFORK
1987 || event == PTRACE_EVENT_CLONE)
1989 unsigned long new_pid;
1992 ptrace (PTRACE_GETEVENTMSG, pid, 0, &new_pid);
1994 /* If we haven't already seen the new PID stop, wait for it now. */
1995 if (! pull_pid_from_list (&stopped_pids, new_pid, &status))
1997 /* The new child has a pending SIGSTOP. We can't affect it until it
1998 hits the SIGSTOP, but we're already attached. */
1999 ret = my_waitpid (new_pid, &status,
2000 (event == PTRACE_EVENT_CLONE) ? __WCLONE : 0);
2002 perror_with_name (_("waiting for new child"));
2003 else if (ret != new_pid)
2004 internal_error (__FILE__, __LINE__,
2005 _("wait returned unexpected PID %d"), ret);
2006 else if (!WIFSTOPPED (status))
2007 internal_error (__FILE__, __LINE__,
2008 _("wait returned unexpected status 0x%x"), status);
2011 ourstatus->value.related_pid = ptid_build (new_pid, new_pid, 0);
2013 if (event == PTRACE_EVENT_FORK || event == PTRACE_EVENT_VFORK)
2015 /* The arch-specific native code may need to know about new
2016 forks even if those end up never mapped to an
2018 if (linux_nat_new_fork != NULL)
2019 linux_nat_new_fork (lp, new_pid);
2022 if (event == PTRACE_EVENT_FORK
2023 && linux_fork_checkpointing_p (ptid_get_pid (lp->ptid)))
2025 /* Handle checkpointing by linux-fork.c here as a special
2026 case. We don't want the follow-fork-mode or 'catch fork'
2027 to interfere with this. */
2029 /* This won't actually modify the breakpoint list, but will
2030 physically remove the breakpoints from the child. */
2031 detach_breakpoints (ptid_build (new_pid, new_pid, 0));
2033 /* Retain child fork in ptrace (stopped) state. */
2034 if (!find_fork_pid (new_pid))
2037 /* Report as spurious, so that infrun doesn't want to follow
2038 this fork. We're actually doing an infcall in
2040 ourstatus->kind = TARGET_WAITKIND_SPURIOUS;
2042 /* Report the stop to the core. */
2046 if (event == PTRACE_EVENT_FORK)
2047 ourstatus->kind = TARGET_WAITKIND_FORKED;
2048 else if (event == PTRACE_EVENT_VFORK)
2049 ourstatus->kind = TARGET_WAITKIND_VFORKED;
2052 struct lwp_info *new_lp;
2054 ourstatus->kind = TARGET_WAITKIND_IGNORE;
2056 if (debug_linux_nat)
2057 fprintf_unfiltered (gdb_stdlog,
2058 "LHEW: Got clone event "
2059 "from LWP %d, new child is LWP %ld\n",
2062 new_lp = add_lwp (ptid_build (ptid_get_pid (lp->ptid), new_pid, 0));
2064 new_lp->stopped = 1;
2066 if (WSTOPSIG (status) != SIGSTOP)
2068 /* This can happen if someone starts sending signals to
2069 the new thread before it gets a chance to run, which
2070 have a lower number than SIGSTOP (e.g. SIGUSR1).
2071 This is an unlikely case, and harder to handle for
2072 fork / vfork than for clone, so we do not try - but
2073 we handle it for clone events here. We'll send
2074 the other signal on to the thread below. */
2076 new_lp->signalled = 1;
2080 struct thread_info *tp;
2082 /* When we stop for an event in some other thread, and
2083 pull the thread list just as this thread has cloned,
2084 we'll have seen the new thread in the thread_db list
2085 before handling the CLONE event (glibc's
2086 pthread_create adds the new thread to the thread list
2087 before clone'ing, and has the kernel fill in the
2088 thread's tid on the clone call with
2089 CLONE_PARENT_SETTID). If that happened, and the core
2090 had requested the new thread to stop, we'll have
2091 killed it with SIGSTOP. But since SIGSTOP is not an
2092 RT signal, it can only be queued once. We need to be
2093 careful to not resume the LWP if we wanted it to
2094 stop. In that case, we'll leave the SIGSTOP pending.
2095 It will later be reported as GDB_SIGNAL_0. */
2096 tp = find_thread_ptid (new_lp->ptid);
2097 if (tp != NULL && tp->stop_requested)
2098 new_lp->last_resume_kind = resume_stop;
2105 /* Add the new thread to GDB's lists as soon as possible
2108 1) the frontend doesn't have to wait for a stop to
2111 2) we tag it with the correct running state. */
2113 /* If the thread_db layer is active, let it know about
2114 this new thread, and add it to GDB's list. */
2115 if (!thread_db_attach_lwp (new_lp->ptid))
2117 /* We're not using thread_db. Add it to GDB's
2119 target_post_attach (ptid_get_lwp (new_lp->ptid));
2120 add_thread (new_lp->ptid);
2125 set_running (new_lp->ptid, 1);
2126 set_executing (new_lp->ptid, 1);
2127 /* thread_db_attach_lwp -> lin_lwp_attach_lwp forced
2129 new_lp->last_resume_kind = resume_continue;
2135 /* We created NEW_LP so it cannot yet contain STATUS. */
2136 gdb_assert (new_lp->status == 0);
2138 /* Save the wait status to report later. */
2139 if (debug_linux_nat)
2140 fprintf_unfiltered (gdb_stdlog,
2141 "LHEW: waitpid of new LWP %ld, "
2142 "saving status %s\n",
2143 (long) ptid_get_lwp (new_lp->ptid),
2144 status_to_str (status));
2145 new_lp->status = status;
2148 /* Note the need to use the low target ops to resume, to
2149 handle resuming with PT_SYSCALL if we have syscall
2153 new_lp->resumed = 1;
2157 gdb_assert (new_lp->last_resume_kind == resume_continue);
2158 if (debug_linux_nat)
2159 fprintf_unfiltered (gdb_stdlog,
2160 "LHEW: resuming new LWP %ld\n",
2161 ptid_get_lwp (new_lp->ptid));
2162 if (linux_nat_prepare_to_resume != NULL)
2163 linux_nat_prepare_to_resume (new_lp);
2164 linux_ops->to_resume (linux_ops, pid_to_ptid (new_pid),
2166 new_lp->stopped = 0;
2170 if (debug_linux_nat)
2171 fprintf_unfiltered (gdb_stdlog,
2172 "LHEW: resuming parent LWP %d\n", pid);
2173 if (linux_nat_prepare_to_resume != NULL)
2174 linux_nat_prepare_to_resume (lp);
2175 linux_ops->to_resume (linux_ops,
2176 pid_to_ptid (ptid_get_lwp (lp->ptid)),
2185 if (event == PTRACE_EVENT_EXEC)
2187 if (debug_linux_nat)
2188 fprintf_unfiltered (gdb_stdlog,
2189 "LHEW: Got exec event from LWP %ld\n",
2190 ptid_get_lwp (lp->ptid));
2192 ourstatus->kind = TARGET_WAITKIND_EXECD;
2193 ourstatus->value.execd_pathname
2194 = xstrdup (linux_child_pid_to_exec_file (pid));
2199 if (event == PTRACE_EVENT_VFORK_DONE)
2201 if (current_inferior ()->waiting_for_vfork_done)
2203 if (debug_linux_nat)
2204 fprintf_unfiltered (gdb_stdlog,
2205 "LHEW: Got expected PTRACE_EVENT_"
2206 "VFORK_DONE from LWP %ld: stopping\n",
2207 ptid_get_lwp (lp->ptid));
2209 ourstatus->kind = TARGET_WAITKIND_VFORK_DONE;
2213 if (debug_linux_nat)
2214 fprintf_unfiltered (gdb_stdlog,
2215 "LHEW: Got PTRACE_EVENT_VFORK_DONE "
2216 "from LWP %ld: resuming\n",
2217 ptid_get_lwp (lp->ptid));
2218 ptrace (PTRACE_CONT, ptid_get_lwp (lp->ptid), 0, 0);
2222 internal_error (__FILE__, __LINE__,
2223 _("unknown ptrace event %d"), event);
2226 /* Wait for LP to stop. Returns the wait status, or 0 if the LWP has
2230 wait_lwp (struct lwp_info *lp)
2234 int thread_dead = 0;
2237 gdb_assert (!lp->stopped);
2238 gdb_assert (lp->status == 0);
2240 /* Make sure SIGCHLD is blocked for sigsuspend avoiding a race below. */
2241 block_child_signals (&prev_mask);
2245 /* If my_waitpid returns 0 it means the __WCLONE vs. non-__WCLONE kind
2246 was right and we should just call sigsuspend. */
2248 pid = my_waitpid (ptid_get_lwp (lp->ptid), &status, WNOHANG);
2249 if (pid == -1 && errno == ECHILD)
2250 pid = my_waitpid (ptid_get_lwp (lp->ptid), &status, __WCLONE | WNOHANG);
2251 if (pid == -1 && errno == ECHILD)
2253 /* The thread has previously exited. We need to delete it
2254 now because, for some vendor 2.4 kernels with NPTL
2255 support backported, there won't be an exit event unless
2256 it is the main thread. 2.6 kernels will report an exit
2257 event for each thread that exits, as expected. */
2259 if (debug_linux_nat)
2260 fprintf_unfiltered (gdb_stdlog, "WL: %s vanished.\n",
2261 target_pid_to_str (lp->ptid));
2266 /* Bugs 10970, 12702.
2267 Thread group leader may have exited in which case we'll lock up in
2268 waitpid if there are other threads, even if they are all zombies too.
2269 Basically, we're not supposed to use waitpid this way.
2270 __WCLONE is not applicable for the leader so we can't use that.
2271 LINUX_NAT_THREAD_ALIVE cannot be used here as it requires a STOPPED
2272 process; it gets ESRCH both for the zombie and for running processes.
2274 As a workaround, check if we're waiting for the thread group leader and
2275 if it's a zombie, and avoid calling waitpid if it is.
2277 This is racy, what if the tgl becomes a zombie right after we check?
2278 Therefore always use WNOHANG with sigsuspend - it is equivalent to
2279 waiting waitpid but linux_proc_pid_is_zombie is safe this way. */
2281 if (ptid_get_pid (lp->ptid) == ptid_get_lwp (lp->ptid)
2282 && linux_proc_pid_is_zombie (ptid_get_lwp (lp->ptid)))
2285 if (debug_linux_nat)
2286 fprintf_unfiltered (gdb_stdlog,
2287 "WL: Thread group leader %s vanished.\n",
2288 target_pid_to_str (lp->ptid));
2292 /* Wait for next SIGCHLD and try again. This may let SIGCHLD handlers
2293 get invoked despite our caller had them intentionally blocked by
2294 block_child_signals. This is sensitive only to the loop of
2295 linux_nat_wait_1 and there if we get called my_waitpid gets called
2296 again before it gets to sigsuspend so we can safely let the handlers
2297 get executed here. */
2299 sigsuspend (&suspend_mask);
2302 restore_child_signals_mask (&prev_mask);
2306 gdb_assert (pid == ptid_get_lwp (lp->ptid));
2308 if (debug_linux_nat)
2310 fprintf_unfiltered (gdb_stdlog,
2311 "WL: waitpid %s received %s\n",
2312 target_pid_to_str (lp->ptid),
2313 status_to_str (status));
2316 /* Check if the thread has exited. */
2317 if (WIFEXITED (status) || WIFSIGNALED (status))
2320 if (debug_linux_nat)
2321 fprintf_unfiltered (gdb_stdlog, "WL: %s exited.\n",
2322 target_pid_to_str (lp->ptid));
2332 gdb_assert (WIFSTOPPED (status));
2334 /* Handle GNU/Linux's syscall SIGTRAPs. */
2335 if (WIFSTOPPED (status) && WSTOPSIG (status) == SYSCALL_SIGTRAP)
2337 /* No longer need the sysgood bit. The ptrace event ends up
2338 recorded in lp->waitstatus if we care for it. We can carry
2339 on handling the event like a regular SIGTRAP from here
2341 status = W_STOPCODE (SIGTRAP);
2342 if (linux_handle_syscall_trap (lp, 1))
2343 return wait_lwp (lp);
2346 /* Handle GNU/Linux's extended waitstatus for trace events. */
2347 if (WIFSTOPPED (status) && WSTOPSIG (status) == SIGTRAP && status >> 16 != 0)
2349 if (debug_linux_nat)
2350 fprintf_unfiltered (gdb_stdlog,
2351 "WL: Handling extended status 0x%06x\n",
2353 if (linux_handle_extended_wait (lp, status, 1))
2354 return wait_lwp (lp);
2360 /* Send a SIGSTOP to LP. */
2363 stop_callback (struct lwp_info *lp, void *data)
2365 if (!lp->stopped && !lp->signalled)
2369 if (debug_linux_nat)
2371 fprintf_unfiltered (gdb_stdlog,
2372 "SC: kill %s **<SIGSTOP>**\n",
2373 target_pid_to_str (lp->ptid));
2376 ret = kill_lwp (ptid_get_lwp (lp->ptid), SIGSTOP);
2377 if (debug_linux_nat)
2379 fprintf_unfiltered (gdb_stdlog,
2380 "SC: lwp kill %d %s\n",
2382 errno ? safe_strerror (errno) : "ERRNO-OK");
2386 gdb_assert (lp->status == 0);
2392 /* Request a stop on LWP. */
2395 linux_stop_lwp (struct lwp_info *lwp)
2397 stop_callback (lwp, NULL);
2400 /* Return non-zero if LWP PID has a pending SIGINT. */
2403 linux_nat_has_pending_sigint (int pid)
2405 sigset_t pending, blocked, ignored;
2407 linux_proc_pending_signals (pid, &pending, &blocked, &ignored);
2409 if (sigismember (&pending, SIGINT)
2410 && !sigismember (&ignored, SIGINT))
2416 /* Set a flag in LP indicating that we should ignore its next SIGINT. */
2419 set_ignore_sigint (struct lwp_info *lp, void *data)
2421 /* If a thread has a pending SIGINT, consume it; otherwise, set a
2422 flag to consume the next one. */
2423 if (lp->stopped && lp->status != 0 && WIFSTOPPED (lp->status)
2424 && WSTOPSIG (lp->status) == SIGINT)
2427 lp->ignore_sigint = 1;
2432 /* If LP does not have a SIGINT pending, then clear the ignore_sigint flag.
2433 This function is called after we know the LWP has stopped; if the LWP
2434 stopped before the expected SIGINT was delivered, then it will never have
2435 arrived. Also, if the signal was delivered to a shared queue and consumed
2436 by a different thread, it will never be delivered to this LWP. */
2439 maybe_clear_ignore_sigint (struct lwp_info *lp)
2441 if (!lp->ignore_sigint)
2444 if (!linux_nat_has_pending_sigint (ptid_get_lwp (lp->ptid)))
2446 if (debug_linux_nat)
2447 fprintf_unfiltered (gdb_stdlog,
2448 "MCIS: Clearing bogus flag for %s\n",
2449 target_pid_to_str (lp->ptid));
2450 lp->ignore_sigint = 0;
2454 /* Fetch the possible triggered data watchpoint info and store it in
2457 On some archs, like x86, that use debug registers to set
2458 watchpoints, it's possible that the way to know which watched
2459 address trapped, is to check the register that is used to select
2460 which address to watch. Problem is, between setting the watchpoint
2461 and reading back which data address trapped, the user may change
2462 the set of watchpoints, and, as a consequence, GDB changes the
2463 debug registers in the inferior. To avoid reading back a stale
2464 stopped-data-address when that happens, we cache in LP the fact
2465 that a watchpoint trapped, and the corresponding data address, as
2466 soon as we see LP stop with a SIGTRAP. If GDB changes the debug
2467 registers meanwhile, we have the cached data we can rely on. */
2470 save_sigtrap (struct lwp_info *lp)
2472 struct cleanup *old_chain;
2474 if (linux_ops->to_stopped_by_watchpoint == NULL)
2476 lp->stopped_by_watchpoint = 0;
2480 old_chain = save_inferior_ptid ();
2481 inferior_ptid = lp->ptid;
2483 lp->stopped_by_watchpoint = linux_ops->to_stopped_by_watchpoint (linux_ops);
2485 if (lp->stopped_by_watchpoint)
2487 if (linux_ops->to_stopped_data_address != NULL)
2488 lp->stopped_data_address_p =
2489 linux_ops->to_stopped_data_address (¤t_target,
2490 &lp->stopped_data_address);
2492 lp->stopped_data_address_p = 0;
2495 do_cleanups (old_chain);
2498 /* See save_sigtrap. */
2501 linux_nat_stopped_by_watchpoint (struct target_ops *ops)
2503 struct lwp_info *lp = find_lwp_pid (inferior_ptid);
2505 gdb_assert (lp != NULL);
2507 return lp->stopped_by_watchpoint;
2511 linux_nat_stopped_data_address (struct target_ops *ops, CORE_ADDR *addr_p)
2513 struct lwp_info *lp = find_lwp_pid (inferior_ptid);
2515 gdb_assert (lp != NULL);
2517 *addr_p = lp->stopped_data_address;
2519 return lp->stopped_data_address_p;
2522 /* Commonly any breakpoint / watchpoint generate only SIGTRAP. */
2525 sigtrap_is_event (int status)
2527 return WIFSTOPPED (status) && WSTOPSIG (status) == SIGTRAP;
2530 /* SIGTRAP-like events recognizer. */
2532 static int (*linux_nat_status_is_event) (int status) = sigtrap_is_event;
2534 /* Check for SIGTRAP-like events in LP. */
2537 linux_nat_lp_status_is_event (struct lwp_info *lp)
2539 /* We check for lp->waitstatus in addition to lp->status, because we can
2540 have pending process exits recorded in lp->status
2541 and W_EXITCODE(0,0) == 0. We should probably have an additional
2542 lp->status_p flag. */
2544 return (lp->waitstatus.kind == TARGET_WAITKIND_IGNORE
2545 && linux_nat_status_is_event (lp->status));
2548 /* Set alternative SIGTRAP-like events recognizer. If
2549 breakpoint_inserted_here_p there then gdbarch_decr_pc_after_break will be
2553 linux_nat_set_status_is_event (struct target_ops *t,
2554 int (*status_is_event) (int status))
2556 linux_nat_status_is_event = status_is_event;
2559 /* Wait until LP is stopped. */
2562 stop_wait_callback (struct lwp_info *lp, void *data)
2564 struct inferior *inf = find_inferior_pid (ptid_get_pid (lp->ptid));
2566 /* If this is a vfork parent, bail out, it is not going to report
2567 any SIGSTOP until the vfork is done with. */
2568 if (inf->vfork_child != NULL)
2575 status = wait_lwp (lp);
2579 if (lp->ignore_sigint && WIFSTOPPED (status)
2580 && WSTOPSIG (status) == SIGINT)
2582 lp->ignore_sigint = 0;
2585 ptrace (PTRACE_CONT, ptid_get_lwp (lp->ptid), 0, 0);
2586 if (debug_linux_nat)
2587 fprintf_unfiltered (gdb_stdlog,
2588 "PTRACE_CONT %s, 0, 0 (%s) "
2589 "(discarding SIGINT)\n",
2590 target_pid_to_str (lp->ptid),
2591 errno ? safe_strerror (errno) : "OK");
2593 return stop_wait_callback (lp, NULL);
2596 maybe_clear_ignore_sigint (lp);
2598 if (WSTOPSIG (status) != SIGSTOP)
2600 /* The thread was stopped with a signal other than SIGSTOP. */
2604 if (debug_linux_nat)
2605 fprintf_unfiltered (gdb_stdlog,
2606 "SWC: Pending event %s in %s\n",
2607 status_to_str ((int) status),
2608 target_pid_to_str (lp->ptid));
2610 /* Save the sigtrap event. */
2611 lp->status = status;
2612 gdb_assert (!lp->stopped);
2613 gdb_assert (lp->signalled);
2618 /* We caught the SIGSTOP that we intended to catch, so
2619 there's no SIGSTOP pending. */
2621 if (debug_linux_nat)
2622 fprintf_unfiltered (gdb_stdlog,
2623 "SWC: Delayed SIGSTOP caught for %s.\n",
2624 target_pid_to_str (lp->ptid));
2628 /* Reset SIGNALLED only after the stop_wait_callback call
2629 above as it does gdb_assert on SIGNALLED. */
2637 /* Return non-zero if LP has a wait status pending. */
2640 status_callback (struct lwp_info *lp, void *data)
2642 /* Only report a pending wait status if we pretend that this has
2643 indeed been resumed. */
2647 if (lp->waitstatus.kind != TARGET_WAITKIND_IGNORE)
2649 /* A ptrace event, like PTRACE_FORK|VFORK|EXEC, syscall event,
2650 or a pending process exit. Note that `W_EXITCODE(0,0) ==
2651 0', so a clean process exit can not be stored pending in
2652 lp->status, it is indistinguishable from
2653 no-pending-status. */
2657 if (lp->status != 0)
2663 /* Return non-zero if LP isn't stopped. */
2666 running_callback (struct lwp_info *lp, void *data)
2668 return (!lp->stopped
2669 || ((lp->status != 0
2670 || lp->waitstatus.kind != TARGET_WAITKIND_IGNORE)
2674 /* Count the LWP's that have had events. */
2677 count_events_callback (struct lwp_info *lp, void *data)
2681 gdb_assert (count != NULL);
2683 /* Count only resumed LWPs that have a SIGTRAP event pending. */
2684 if (lp->resumed && linux_nat_lp_status_is_event (lp))
2690 /* Select the LWP (if any) that is currently being single-stepped. */
2693 select_singlestep_lwp_callback (struct lwp_info *lp, void *data)
2695 if (lp->last_resume_kind == resume_step
2702 /* Select the Nth LWP that has had a SIGTRAP event. */
2705 select_event_lwp_callback (struct lwp_info *lp, void *data)
2707 int *selector = data;
2709 gdb_assert (selector != NULL);
2711 /* Select only resumed LWPs that have a SIGTRAP event pending. */
2712 if (lp->resumed && linux_nat_lp_status_is_event (lp))
2713 if ((*selector)-- == 0)
2720 cancel_breakpoint (struct lwp_info *lp)
2722 /* Arrange for a breakpoint to be hit again later. We don't keep
2723 the SIGTRAP status and don't forward the SIGTRAP signal to the
2724 LWP. We will handle the current event, eventually we will resume
2725 this LWP, and this breakpoint will trap again.
2727 If we do not do this, then we run the risk that the user will
2728 delete or disable the breakpoint, but the LWP will have already
2731 struct regcache *regcache = get_thread_regcache (lp->ptid);
2732 struct gdbarch *gdbarch = get_regcache_arch (regcache);
2735 pc = regcache_read_pc (regcache) - target_decr_pc_after_break (gdbarch);
2736 if (breakpoint_inserted_here_p (get_regcache_aspace (regcache), pc))
2738 if (debug_linux_nat)
2739 fprintf_unfiltered (gdb_stdlog,
2740 "CB: Push back breakpoint for %s\n",
2741 target_pid_to_str (lp->ptid));
2743 /* Back up the PC if necessary. */
2744 if (target_decr_pc_after_break (gdbarch))
2745 regcache_write_pc (regcache, pc);
2753 cancel_breakpoints_callback (struct lwp_info *lp, void *data)
2755 struct lwp_info *event_lp = data;
2757 /* Leave the LWP that has been elected to receive a SIGTRAP alone. */
2761 /* If a LWP other than the LWP that we're reporting an event for has
2762 hit a GDB breakpoint (as opposed to some random trap signal),
2763 then just arrange for it to hit it again later. We don't keep
2764 the SIGTRAP status and don't forward the SIGTRAP signal to the
2765 LWP. We will handle the current event, eventually we will resume
2766 all LWPs, and this one will get its breakpoint trap again.
2768 If we do not do this, then we run the risk that the user will
2769 delete or disable the breakpoint, but the LWP will have already
2772 if (linux_nat_lp_status_is_event (lp)
2773 && cancel_breakpoint (lp))
2774 /* Throw away the SIGTRAP. */
2780 /* Select one LWP out of those that have events pending. */
2783 select_event_lwp (ptid_t filter, struct lwp_info **orig_lp, int *status)
2786 int random_selector;
2787 struct lwp_info *event_lp;
2789 /* Record the wait status for the original LWP. */
2790 (*orig_lp)->status = *status;
2792 /* Give preference to any LWP that is being single-stepped. */
2793 event_lp = iterate_over_lwps (filter,
2794 select_singlestep_lwp_callback, NULL);
2795 if (event_lp != NULL)
2797 if (debug_linux_nat)
2798 fprintf_unfiltered (gdb_stdlog,
2799 "SEL: Select single-step %s\n",
2800 target_pid_to_str (event_lp->ptid));
2804 /* No single-stepping LWP. Select one at random, out of those
2805 which have had SIGTRAP events. */
2807 /* First see how many SIGTRAP events we have. */
2808 iterate_over_lwps (filter, count_events_callback, &num_events);
2810 /* Now randomly pick a LWP out of those that have had a SIGTRAP. */
2811 random_selector = (int)
2812 ((num_events * (double) rand ()) / (RAND_MAX + 1.0));
2814 if (debug_linux_nat && num_events > 1)
2815 fprintf_unfiltered (gdb_stdlog,
2816 "SEL: Found %d SIGTRAP events, selecting #%d\n",
2817 num_events, random_selector);
2819 event_lp = iterate_over_lwps (filter,
2820 select_event_lwp_callback,
2824 if (event_lp != NULL)
2826 /* Switch the event LWP. */
2827 *orig_lp = event_lp;
2828 *status = event_lp->status;
2831 /* Flush the wait status for the event LWP. */
2832 (*orig_lp)->status = 0;
2835 /* Return non-zero if LP has been resumed. */
2838 resumed_callback (struct lwp_info *lp, void *data)
2843 /* Stop an active thread, verify it still exists, then resume it. If
2844 the thread ends up with a pending status, then it is not resumed,
2845 and *DATA (really a pointer to int), is set. */
2848 stop_and_resume_callback (struct lwp_info *lp, void *data)
2850 int *new_pending_p = data;
2854 ptid_t ptid = lp->ptid;
2856 stop_callback (lp, NULL);
2857 stop_wait_callback (lp, NULL);
2859 /* Resume if the lwp still exists, and the core wanted it
2861 lp = find_lwp_pid (ptid);
2864 if (lp->last_resume_kind == resume_stop
2867 /* The core wanted the LWP to stop. Even if it stopped
2868 cleanly (with SIGSTOP), leave the event pending. */
2869 if (debug_linux_nat)
2870 fprintf_unfiltered (gdb_stdlog,
2871 "SARC: core wanted LWP %ld stopped "
2872 "(leaving SIGSTOP pending)\n",
2873 ptid_get_lwp (lp->ptid));
2874 lp->status = W_STOPCODE (SIGSTOP);
2877 if (lp->status == 0)
2879 if (debug_linux_nat)
2880 fprintf_unfiltered (gdb_stdlog,
2881 "SARC: re-resuming LWP %ld\n",
2882 ptid_get_lwp (lp->ptid));
2883 resume_lwp (lp, lp->step, GDB_SIGNAL_0);
2887 if (debug_linux_nat)
2888 fprintf_unfiltered (gdb_stdlog,
2889 "SARC: not re-resuming LWP %ld "
2891 ptid_get_lwp (lp->ptid));
2900 /* Check if we should go on and pass this event to common code.
2901 Return the affected lwp if we are, or NULL otherwise. If we stop
2902 all lwps temporarily, we may end up with new pending events in some
2903 other lwp. In that case set *NEW_PENDING_P to true. */
2905 static struct lwp_info *
2906 linux_nat_filter_event (int lwpid, int status, int *new_pending_p)
2908 struct lwp_info *lp;
2912 lp = find_lwp_pid (pid_to_ptid (lwpid));
2914 /* Check for stop events reported by a process we didn't already
2915 know about - anything not already in our LWP list.
2917 If we're expecting to receive stopped processes after
2918 fork, vfork, and clone events, then we'll just add the
2919 new one to our list and go back to waiting for the event
2920 to be reported - the stopped process might be returned
2921 from waitpid before or after the event is.
2923 But note the case of a non-leader thread exec'ing after the
2924 leader having exited, and gone from our lists. The non-leader
2925 thread changes its tid to the tgid. */
2927 if (WIFSTOPPED (status) && lp == NULL
2928 && (WSTOPSIG (status) == SIGTRAP && status >> 16 == PTRACE_EVENT_EXEC))
2930 /* A multi-thread exec after we had seen the leader exiting. */
2931 if (debug_linux_nat)
2932 fprintf_unfiltered (gdb_stdlog,
2933 "LLW: Re-adding thread group leader LWP %d.\n",
2936 lp = add_lwp (ptid_build (lwpid, lwpid, 0));
2939 add_thread (lp->ptid);
2942 if (WIFSTOPPED (status) && !lp)
2944 add_to_pid_list (&stopped_pids, lwpid, status);
2948 /* Make sure we don't report an event for the exit of an LWP not in
2949 our list, i.e. not part of the current process. This can happen
2950 if we detach from a program we originally forked and then it
2952 if (!WIFSTOPPED (status) && !lp)
2955 /* Handle GNU/Linux's syscall SIGTRAPs. */
2956 if (WIFSTOPPED (status) && WSTOPSIG (status) == SYSCALL_SIGTRAP)
2958 /* No longer need the sysgood bit. The ptrace event ends up
2959 recorded in lp->waitstatus if we care for it. We can carry
2960 on handling the event like a regular SIGTRAP from here
2962 status = W_STOPCODE (SIGTRAP);
2963 if (linux_handle_syscall_trap (lp, 0))
2967 /* Handle GNU/Linux's extended waitstatus for trace events. */
2968 if (WIFSTOPPED (status) && WSTOPSIG (status) == SIGTRAP && status >> 16 != 0)
2970 if (debug_linux_nat)
2971 fprintf_unfiltered (gdb_stdlog,
2972 "LLW: Handling extended status 0x%06x\n",
2974 if (linux_handle_extended_wait (lp, status, 0))
2978 if (linux_nat_status_is_event (status))
2981 /* Check if the thread has exited. */
2982 if ((WIFEXITED (status) || WIFSIGNALED (status))
2983 && num_lwps (ptid_get_pid (lp->ptid)) > 1)
2985 /* If this is the main thread, we must stop all threads and verify
2986 if they are still alive. This is because in the nptl thread model
2987 on Linux 2.4, there is no signal issued for exiting LWPs
2988 other than the main thread. We only get the main thread exit
2989 signal once all child threads have already exited. If we
2990 stop all the threads and use the stop_wait_callback to check
2991 if they have exited we can determine whether this signal
2992 should be ignored or whether it means the end of the debugged
2993 application, regardless of which threading model is being
2995 if (ptid_get_pid (lp->ptid) == ptid_get_lwp (lp->ptid))
2998 iterate_over_lwps (pid_to_ptid (ptid_get_pid (lp->ptid)),
2999 stop_and_resume_callback, new_pending_p);
3002 if (debug_linux_nat)
3003 fprintf_unfiltered (gdb_stdlog,
3004 "LLW: %s exited.\n",
3005 target_pid_to_str (lp->ptid));
3007 if (num_lwps (ptid_get_pid (lp->ptid)) > 1)
3009 /* If there is at least one more LWP, then the exit signal
3010 was not the end of the debugged application and should be
3017 /* Check if the current LWP has previously exited. In the nptl
3018 thread model, LWPs other than the main thread do not issue
3019 signals when they exit so we must check whenever the thread has
3020 stopped. A similar check is made in stop_wait_callback(). */
3021 if (num_lwps (ptid_get_pid (lp->ptid)) > 1 && !linux_thread_alive (lp->ptid))
3023 ptid_t ptid = pid_to_ptid (ptid_get_pid (lp->ptid));
3025 if (debug_linux_nat)
3026 fprintf_unfiltered (gdb_stdlog,
3027 "LLW: %s exited.\n",
3028 target_pid_to_str (lp->ptid));
3032 /* Make sure there is at least one thread running. */
3033 gdb_assert (iterate_over_lwps (ptid, running_callback, NULL));
3035 /* Discard the event. */
3039 /* Make sure we don't report a SIGSTOP that we sent ourselves in
3040 an attempt to stop an LWP. */
3042 && WIFSTOPPED (status) && WSTOPSIG (status) == SIGSTOP)
3044 if (debug_linux_nat)
3045 fprintf_unfiltered (gdb_stdlog,
3046 "LLW: Delayed SIGSTOP caught for %s.\n",
3047 target_pid_to_str (lp->ptid));
3051 if (lp->last_resume_kind != resume_stop)
3053 /* This is a delayed SIGSTOP. */
3055 registers_changed ();
3057 if (linux_nat_prepare_to_resume != NULL)
3058 linux_nat_prepare_to_resume (lp);
3059 linux_ops->to_resume (linux_ops,
3060 pid_to_ptid (ptid_get_lwp (lp->ptid)),
3061 lp->step, GDB_SIGNAL_0);
3062 if (debug_linux_nat)
3063 fprintf_unfiltered (gdb_stdlog,
3064 "LLW: %s %s, 0, 0 (discard SIGSTOP)\n",
3066 "PTRACE_SINGLESTEP" : "PTRACE_CONT",
3067 target_pid_to_str (lp->ptid));
3070 gdb_assert (lp->resumed);
3072 /* Discard the event. */
3077 /* Make sure we don't report a SIGINT that we have already displayed
3078 for another thread. */
3079 if (lp->ignore_sigint
3080 && WIFSTOPPED (status) && WSTOPSIG (status) == SIGINT)
3082 if (debug_linux_nat)
3083 fprintf_unfiltered (gdb_stdlog,
3084 "LLW: Delayed SIGINT caught for %s.\n",
3085 target_pid_to_str (lp->ptid));
3087 /* This is a delayed SIGINT. */
3088 lp->ignore_sigint = 0;
3090 registers_changed ();
3091 if (linux_nat_prepare_to_resume != NULL)
3092 linux_nat_prepare_to_resume (lp);
3093 linux_ops->to_resume (linux_ops, pid_to_ptid (ptid_get_lwp (lp->ptid)),
3094 lp->step, GDB_SIGNAL_0);
3095 if (debug_linux_nat)
3096 fprintf_unfiltered (gdb_stdlog,
3097 "LLW: %s %s, 0, 0 (discard SIGINT)\n",
3099 "PTRACE_SINGLESTEP" : "PTRACE_CONT",
3100 target_pid_to_str (lp->ptid));
3103 gdb_assert (lp->resumed);
3105 /* Discard the event. */
3109 /* An interesting event. */
3111 lp->status = status;
3115 /* Detect zombie thread group leaders, and "exit" them. We can't reap
3116 their exits until all other threads in the group have exited. */
3119 check_zombie_leaders (void)
3121 struct inferior *inf;
3125 struct lwp_info *leader_lp;
3130 leader_lp = find_lwp_pid (pid_to_ptid (inf->pid));
3131 if (leader_lp != NULL
3132 /* Check if there are other threads in the group, as we may
3133 have raced with the inferior simply exiting. */
3134 && num_lwps (inf->pid) > 1
3135 && linux_proc_pid_is_zombie (inf->pid))
3137 if (debug_linux_nat)
3138 fprintf_unfiltered (gdb_stdlog,
3139 "CZL: Thread group leader %d zombie "
3140 "(it exited, or another thread execd).\n",
3143 /* A leader zombie can mean one of two things:
3145 - It exited, and there's an exit status pending
3146 available, or only the leader exited (not the whole
3147 program). In the latter case, we can't waitpid the
3148 leader's exit status until all other threads are gone.
3150 - There are 3 or more threads in the group, and a thread
3151 other than the leader exec'd. On an exec, the Linux
3152 kernel destroys all other threads (except the execing
3153 one) in the thread group, and resets the execing thread's
3154 tid to the tgid. No exit notification is sent for the
3155 execing thread -- from the ptracer's perspective, it
3156 appears as though the execing thread just vanishes.
3157 Until we reap all other threads except the leader and the
3158 execing thread, the leader will be zombie, and the
3159 execing thread will be in `D (disc sleep)'. As soon as
3160 all other threads are reaped, the execing thread changes
3161 it's tid to the tgid, and the previous (zombie) leader
3162 vanishes, giving place to the "new" leader. We could try
3163 distinguishing the exit and exec cases, by waiting once
3164 more, and seeing if something comes out, but it doesn't
3165 sound useful. The previous leader _does_ go away, and
3166 we'll re-add the new one once we see the exec event
3167 (which is just the same as what would happen if the
3168 previous leader did exit voluntarily before some other
3171 if (debug_linux_nat)
3172 fprintf_unfiltered (gdb_stdlog,
3173 "CZL: Thread group leader %d vanished.\n",
3175 exit_lwp (leader_lp);
3181 linux_nat_wait_1 (struct target_ops *ops,
3182 ptid_t ptid, struct target_waitstatus *ourstatus,
3185 static sigset_t prev_mask;
3186 enum resume_kind last_resume_kind;
3187 struct lwp_info *lp;
3190 if (debug_linux_nat)
3191 fprintf_unfiltered (gdb_stdlog, "LLW: enter\n");
3193 /* The first time we get here after starting a new inferior, we may
3194 not have added it to the LWP list yet - this is the earliest
3195 moment at which we know its PID. */
3196 if (ptid_is_pid (inferior_ptid))
3198 /* Upgrade the main thread's ptid. */
3199 thread_change_ptid (inferior_ptid,
3200 ptid_build (ptid_get_pid (inferior_ptid),
3201 ptid_get_pid (inferior_ptid), 0));
3203 lp = add_initial_lwp (inferior_ptid);
3207 /* Make sure SIGCHLD is blocked until the sigsuspend below. */
3208 block_child_signals (&prev_mask);
3214 /* First check if there is a LWP with a wait status pending. */
3215 if (ptid_equal (ptid, minus_one_ptid) || ptid_is_pid (ptid))
3217 /* Any LWP in the PTID group that's been resumed will do. */
3218 lp = iterate_over_lwps (ptid, status_callback, NULL);
3221 if (debug_linux_nat && lp->status)
3222 fprintf_unfiltered (gdb_stdlog,
3223 "LLW: Using pending wait status %s for %s.\n",
3224 status_to_str (lp->status),
3225 target_pid_to_str (lp->ptid));
3228 else if (ptid_lwp_p (ptid))
3230 if (debug_linux_nat)
3231 fprintf_unfiltered (gdb_stdlog,
3232 "LLW: Waiting for specific LWP %s.\n",
3233 target_pid_to_str (ptid));
3235 /* We have a specific LWP to check. */
3236 lp = find_lwp_pid (ptid);
3239 if (debug_linux_nat && lp->status)
3240 fprintf_unfiltered (gdb_stdlog,
3241 "LLW: Using pending wait status %s for %s.\n",
3242 status_to_str (lp->status),
3243 target_pid_to_str (lp->ptid));
3245 /* We check for lp->waitstatus in addition to lp->status,
3246 because we can have pending process exits recorded in
3247 lp->status and W_EXITCODE(0,0) == 0. We should probably have
3248 an additional lp->status_p flag. */
3249 if (lp->status == 0 && lp->waitstatus.kind == TARGET_WAITKIND_IGNORE)
3253 if (!target_can_async_p ())
3255 /* Causes SIGINT to be passed on to the attached process. */
3259 /* But if we don't find a pending event, we'll have to wait. */
3265 /* Always use -1 and WNOHANG, due to couple of a kernel/ptrace
3268 - If the thread group leader exits while other threads in the
3269 thread group still exist, waitpid(TGID, ...) hangs. That
3270 waitpid won't return an exit status until the other threads
3271 in the group are reapped.
3273 - When a non-leader thread execs, that thread just vanishes
3274 without reporting an exit (so we'd hang if we waited for it
3275 explicitly in that case). The exec event is reported to
3279 lwpid = my_waitpid (-1, &status, __WCLONE | WNOHANG);
3280 if (lwpid == 0 || (lwpid == -1 && errno == ECHILD))
3281 lwpid = my_waitpid (-1, &status, WNOHANG);
3283 if (debug_linux_nat)
3284 fprintf_unfiltered (gdb_stdlog,
3285 "LNW: waitpid(-1, ...) returned %d, %s\n",
3286 lwpid, errno ? safe_strerror (errno) : "ERRNO-OK");
3290 /* If this is true, then we paused LWPs momentarily, and may
3291 now have pending events to handle. */
3294 if (debug_linux_nat)
3296 fprintf_unfiltered (gdb_stdlog,
3297 "LLW: waitpid %ld received %s\n",
3298 (long) lwpid, status_to_str (status));
3301 lp = linux_nat_filter_event (lwpid, status, &new_pending);
3303 /* STATUS is now no longer valid, use LP->STATUS instead. */
3306 if (lp && !ptid_match (lp->ptid, ptid))
3308 gdb_assert (lp->resumed);
3310 if (debug_linux_nat)
3312 "LWP %ld got an event %06x, leaving pending.\n",
3313 ptid_get_lwp (lp->ptid), lp->status);
3315 if (WIFSTOPPED (lp->status))
3317 if (WSTOPSIG (lp->status) != SIGSTOP)
3319 /* Cancel breakpoint hits. The breakpoint may
3320 be removed before we fetch events from this
3321 process to report to the core. It is best
3322 not to assume the moribund breakpoints
3323 heuristic always handles these cases --- it
3324 could be too many events go through to the
3325 core before this one is handled. All-stop
3326 always cancels breakpoint hits in all
3329 && linux_nat_lp_status_is_event (lp)
3330 && cancel_breakpoint (lp))
3332 /* Throw away the SIGTRAP. */
3335 if (debug_linux_nat)
3337 "LLW: LWP %ld hit a breakpoint while"
3338 " waiting for another process;"
3340 ptid_get_lwp (lp->ptid));
3350 else if (WIFEXITED (lp->status) || WIFSIGNALED (lp->status))
3352 if (debug_linux_nat)
3354 "Process %ld exited while stopping LWPs\n",
3355 ptid_get_lwp (lp->ptid));
3357 /* This was the last lwp in the process. Since
3358 events are serialized to GDB core, and we can't
3359 report this one right now, but GDB core and the
3360 other target layers will want to be notified
3361 about the exit code/signal, leave the status
3362 pending for the next time we're able to report
3365 /* Prevent trying to stop this thread again. We'll
3366 never try to resume it because it has a pending
3370 /* Dead LWP's aren't expected to reported a pending
3374 /* Store the pending event in the waitstatus as
3375 well, because W_EXITCODE(0,0) == 0. */
3376 store_waitstatus (&lp->waitstatus, lp->status);
3385 /* Some LWP now has a pending event. Go all the way
3386 back to check it. */
3392 /* We got an event to report to the core. */
3396 /* Retry until nothing comes out of waitpid. A single
3397 SIGCHLD can indicate more than one child stopped. */
3401 /* Check for zombie thread group leaders. Those can't be reaped
3402 until all other threads in the thread group are. */
3403 check_zombie_leaders ();
3405 /* If there are no resumed children left, bail. We'd be stuck
3406 forever in the sigsuspend call below otherwise. */
3407 if (iterate_over_lwps (ptid, resumed_callback, NULL) == NULL)
3409 if (debug_linux_nat)
3410 fprintf_unfiltered (gdb_stdlog, "LLW: exit (no resumed LWP)\n");
3412 ourstatus->kind = TARGET_WAITKIND_NO_RESUMED;
3414 if (!target_can_async_p ())
3415 clear_sigint_trap ();
3417 restore_child_signals_mask (&prev_mask);
3418 return minus_one_ptid;
3421 /* No interesting event to report to the core. */
3423 if (target_options & TARGET_WNOHANG)
3425 if (debug_linux_nat)
3426 fprintf_unfiltered (gdb_stdlog, "LLW: exit (ignore)\n");
3428 ourstatus->kind = TARGET_WAITKIND_IGNORE;
3429 restore_child_signals_mask (&prev_mask);
3430 return minus_one_ptid;
3433 /* We shouldn't end up here unless we want to try again. */
3434 gdb_assert (lp == NULL);
3436 /* Block until we get an event reported with SIGCHLD. */
3437 sigsuspend (&suspend_mask);
3440 if (!target_can_async_p ())
3441 clear_sigint_trap ();
3445 status = lp->status;
3448 /* Don't report signals that GDB isn't interested in, such as
3449 signals that are neither printed nor stopped upon. Stopping all
3450 threads can be a bit time-consuming so if we want decent
3451 performance with heavily multi-threaded programs, especially when
3452 they're using a high frequency timer, we'd better avoid it if we
3455 if (WIFSTOPPED (status))
3457 enum gdb_signal signo = gdb_signal_from_host (WSTOPSIG (status));
3459 /* When using hardware single-step, we need to report every signal.
3460 Otherwise, signals in pass_mask may be short-circuited. */
3462 && WSTOPSIG (status) && sigismember (&pass_mask, WSTOPSIG (status)))
3464 /* FIMXE: kettenis/2001-06-06: Should we resume all threads
3465 here? It is not clear we should. GDB may not expect
3466 other threads to run. On the other hand, not resuming
3467 newly attached threads may cause an unwanted delay in
3468 getting them running. */
3469 registers_changed ();
3470 if (linux_nat_prepare_to_resume != NULL)
3471 linux_nat_prepare_to_resume (lp);
3472 linux_ops->to_resume (linux_ops,
3473 pid_to_ptid (ptid_get_lwp (lp->ptid)),
3475 if (debug_linux_nat)
3476 fprintf_unfiltered (gdb_stdlog,
3477 "LLW: %s %s, %s (preempt 'handle')\n",
3479 "PTRACE_SINGLESTEP" : "PTRACE_CONT",
3480 target_pid_to_str (lp->ptid),
3481 (signo != GDB_SIGNAL_0
3482 ? strsignal (gdb_signal_to_host (signo))
3490 /* Only do the below in all-stop, as we currently use SIGINT
3491 to implement target_stop (see linux_nat_stop) in
3493 if (signo == GDB_SIGNAL_INT && signal_pass_state (signo) == 0)
3495 /* If ^C/BREAK is typed at the tty/console, SIGINT gets
3496 forwarded to the entire process group, that is, all LWPs
3497 will receive it - unless they're using CLONE_THREAD to
3498 share signals. Since we only want to report it once, we
3499 mark it as ignored for all LWPs except this one. */
3500 iterate_over_lwps (pid_to_ptid (ptid_get_pid (ptid)),
3501 set_ignore_sigint, NULL);
3502 lp->ignore_sigint = 0;
3505 maybe_clear_ignore_sigint (lp);
3509 /* This LWP is stopped now. */
3512 if (debug_linux_nat)
3513 fprintf_unfiltered (gdb_stdlog, "LLW: Candidate event %s in %s.\n",
3514 status_to_str (status), target_pid_to_str (lp->ptid));
3518 /* Now stop all other LWP's ... */
3519 iterate_over_lwps (minus_one_ptid, stop_callback, NULL);
3521 /* ... and wait until all of them have reported back that
3522 they're no longer running. */
3523 iterate_over_lwps (minus_one_ptid, stop_wait_callback, NULL);
3525 /* If we're not waiting for a specific LWP, choose an event LWP
3526 from among those that have had events. Giving equal priority
3527 to all LWPs that have had events helps prevent
3529 if (ptid_equal (ptid, minus_one_ptid) || ptid_is_pid (ptid))
3530 select_event_lwp (ptid, &lp, &status);
3532 /* Now that we've selected our final event LWP, cancel any
3533 breakpoints in other LWPs that have hit a GDB breakpoint.
3534 See the comment in cancel_breakpoints_callback to find out
3536 iterate_over_lwps (minus_one_ptid, cancel_breakpoints_callback, lp);
3538 /* We'll need this to determine whether to report a SIGSTOP as
3539 TARGET_WAITKIND_0. Need to take a copy because
3540 resume_clear_callback clears it. */
3541 last_resume_kind = lp->last_resume_kind;
3543 /* In all-stop, from the core's perspective, all LWPs are now
3544 stopped until a new resume action is sent over. */
3545 iterate_over_lwps (minus_one_ptid, resume_clear_callback, NULL);
3550 last_resume_kind = lp->last_resume_kind;
3551 resume_clear_callback (lp, NULL);
3554 if (linux_nat_status_is_event (status))
3556 if (debug_linux_nat)
3557 fprintf_unfiltered (gdb_stdlog,
3558 "LLW: trap ptid is %s.\n",
3559 target_pid_to_str (lp->ptid));
3562 if (lp->waitstatus.kind != TARGET_WAITKIND_IGNORE)
3564 *ourstatus = lp->waitstatus;
3565 lp->waitstatus.kind = TARGET_WAITKIND_IGNORE;
3568 store_waitstatus (ourstatus, status);
3570 if (debug_linux_nat)
3571 fprintf_unfiltered (gdb_stdlog, "LLW: exit\n");
3573 restore_child_signals_mask (&prev_mask);
3575 if (last_resume_kind == resume_stop
3576 && ourstatus->kind == TARGET_WAITKIND_STOPPED
3577 && WSTOPSIG (status) == SIGSTOP)
3579 /* A thread that has been requested to stop by GDB with
3580 target_stop, and it stopped cleanly, so report as SIG0. The
3581 use of SIGSTOP is an implementation detail. */
3582 ourstatus->value.sig = GDB_SIGNAL_0;
3585 if (ourstatus->kind == TARGET_WAITKIND_EXITED
3586 || ourstatus->kind == TARGET_WAITKIND_SIGNALLED)
3589 lp->core = linux_common_core_of_thread (lp->ptid);
3594 /* Resume LWPs that are currently stopped without any pending status
3595 to report, but are resumed from the core's perspective. */
3598 resume_stopped_resumed_lwps (struct lwp_info *lp, void *data)
3600 ptid_t *wait_ptid_p = data;
3605 && lp->waitstatus.kind == TARGET_WAITKIND_IGNORE)
3607 struct regcache *regcache = get_thread_regcache (lp->ptid);
3608 struct gdbarch *gdbarch = get_regcache_arch (regcache);
3609 CORE_ADDR pc = regcache_read_pc (regcache);
3611 gdb_assert (is_executing (lp->ptid));
3613 /* Don't bother if there's a breakpoint at PC that we'd hit
3614 immediately, and we're not waiting for this LWP. */
3615 if (!ptid_match (lp->ptid, *wait_ptid_p))
3617 if (breakpoint_inserted_here_p (get_regcache_aspace (regcache), pc))
3621 if (debug_linux_nat)
3622 fprintf_unfiltered (gdb_stdlog,
3623 "RSRL: resuming stopped-resumed LWP %s at %s: step=%d\n",
3624 target_pid_to_str (lp->ptid),
3625 paddress (gdbarch, pc),
3628 registers_changed ();
3629 if (linux_nat_prepare_to_resume != NULL)
3630 linux_nat_prepare_to_resume (lp);
3631 linux_ops->to_resume (linux_ops, pid_to_ptid (ptid_get_lwp (lp->ptid)),
3632 lp->step, GDB_SIGNAL_0);
3634 lp->stopped_by_watchpoint = 0;
3641 linux_nat_wait (struct target_ops *ops,
3642 ptid_t ptid, struct target_waitstatus *ourstatus,
3647 if (debug_linux_nat)
3649 char *options_string;
3651 options_string = target_options_to_string (target_options);
3652 fprintf_unfiltered (gdb_stdlog,
3653 "linux_nat_wait: [%s], [%s]\n",
3654 target_pid_to_str (ptid),
3656 xfree (options_string);
3659 /* Flush the async file first. */
3660 if (target_can_async_p ())
3661 async_file_flush ();
3663 /* Resume LWPs that are currently stopped without any pending status
3664 to report, but are resumed from the core's perspective. LWPs get
3665 in this state if we find them stopping at a time we're not
3666 interested in reporting the event (target_wait on a
3667 specific_process, for example, see linux_nat_wait_1), and
3668 meanwhile the event became uninteresting. Don't bother resuming
3669 LWPs we're not going to wait for if they'd stop immediately. */
3671 iterate_over_lwps (minus_one_ptid, resume_stopped_resumed_lwps, &ptid);
3673 event_ptid = linux_nat_wait_1 (ops, ptid, ourstatus, target_options);
3675 /* If we requested any event, and something came out, assume there
3676 may be more. If we requested a specific lwp or process, also
3677 assume there may be more. */
3678 if (target_can_async_p ()
3679 && ((ourstatus->kind != TARGET_WAITKIND_IGNORE
3680 && ourstatus->kind != TARGET_WAITKIND_NO_RESUMED)
3681 || !ptid_equal (ptid, minus_one_ptid)))
3684 /* Get ready for the next event. */
3685 if (target_can_async_p ())
3686 target_async (inferior_event_handler, 0);
3692 kill_callback (struct lwp_info *lp, void *data)
3694 /* PTRACE_KILL may resume the inferior. Send SIGKILL first. */
3697 kill (ptid_get_lwp (lp->ptid), SIGKILL);
3698 if (debug_linux_nat)
3699 fprintf_unfiltered (gdb_stdlog,
3700 "KC: kill (SIGKILL) %s, 0, 0 (%s)\n",
3701 target_pid_to_str (lp->ptid),
3702 errno ? safe_strerror (errno) : "OK");
3704 /* Some kernels ignore even SIGKILL for processes under ptrace. */
3707 ptrace (PTRACE_KILL, ptid_get_lwp (lp->ptid), 0, 0);
3708 if (debug_linux_nat)
3709 fprintf_unfiltered (gdb_stdlog,
3710 "KC: PTRACE_KILL %s, 0, 0 (%s)\n",
3711 target_pid_to_str (lp->ptid),
3712 errno ? safe_strerror (errno) : "OK");
3718 kill_wait_callback (struct lwp_info *lp, void *data)
3722 /* We must make sure that there are no pending events (delayed
3723 SIGSTOPs, pending SIGTRAPs, etc.) to make sure the current
3724 program doesn't interfere with any following debugging session. */
3726 /* For cloned processes we must check both with __WCLONE and
3727 without, since the exit status of a cloned process isn't reported
3733 pid = my_waitpid (ptid_get_lwp (lp->ptid), NULL, __WCLONE);
3734 if (pid != (pid_t) -1)
3736 if (debug_linux_nat)
3737 fprintf_unfiltered (gdb_stdlog,
3738 "KWC: wait %s received unknown.\n",
3739 target_pid_to_str (lp->ptid));
3740 /* The Linux kernel sometimes fails to kill a thread
3741 completely after PTRACE_KILL; that goes from the stop
3742 point in do_fork out to the one in
3743 get_signal_to_deliever and waits again. So kill it
3745 kill_callback (lp, NULL);
3748 while (pid == ptid_get_lwp (lp->ptid));
3750 gdb_assert (pid == -1 && errno == ECHILD);
3755 pid = my_waitpid (ptid_get_lwp (lp->ptid), NULL, 0);
3756 if (pid != (pid_t) -1)
3758 if (debug_linux_nat)
3759 fprintf_unfiltered (gdb_stdlog,
3760 "KWC: wait %s received unk.\n",
3761 target_pid_to_str (lp->ptid));
3762 /* See the call to kill_callback above. */
3763 kill_callback (lp, NULL);
3766 while (pid == ptid_get_lwp (lp->ptid));
3768 gdb_assert (pid == -1 && errno == ECHILD);
3773 linux_nat_kill (struct target_ops *ops)
3775 struct target_waitstatus last;
3779 /* If we're stopped while forking and we haven't followed yet,
3780 kill the other task. We need to do this first because the
3781 parent will be sleeping if this is a vfork. */
3783 get_last_target_status (&last_ptid, &last);
3785 if (last.kind == TARGET_WAITKIND_FORKED
3786 || last.kind == TARGET_WAITKIND_VFORKED)
3788 ptrace (PT_KILL, ptid_get_pid (last.value.related_pid), 0, 0);
3791 /* Let the arch-specific native code know this process is
3793 linux_nat_forget_process (ptid_get_pid (last.value.related_pid));
3796 if (forks_exist_p ())
3797 linux_fork_killall ();
3800 ptid_t ptid = pid_to_ptid (ptid_get_pid (inferior_ptid));
3802 /* Stop all threads before killing them, since ptrace requires
3803 that the thread is stopped to sucessfully PTRACE_KILL. */
3804 iterate_over_lwps (ptid, stop_callback, NULL);
3805 /* ... and wait until all of them have reported back that
3806 they're no longer running. */
3807 iterate_over_lwps (ptid, stop_wait_callback, NULL);
3809 /* Kill all LWP's ... */
3810 iterate_over_lwps (ptid, kill_callback, NULL);
3812 /* ... and wait until we've flushed all events. */
3813 iterate_over_lwps (ptid, kill_wait_callback, NULL);
3816 target_mourn_inferior ();
3820 linux_nat_mourn_inferior (struct target_ops *ops)
3822 int pid = ptid_get_pid (inferior_ptid);
3824 purge_lwp_list (pid);
3826 if (! forks_exist_p ())
3827 /* Normal case, no other forks available. */
3828 linux_ops->to_mourn_inferior (ops);
3830 /* Multi-fork case. The current inferior_ptid has exited, but
3831 there are other viable forks to debug. Delete the exiting
3832 one and context-switch to the first available. */
3833 linux_fork_mourn_inferior ();
3835 /* Let the arch-specific native code know this process is gone. */
3836 linux_nat_forget_process (pid);
3839 /* Convert a native/host siginfo object, into/from the siginfo in the
3840 layout of the inferiors' architecture. */
3843 siginfo_fixup (siginfo_t *siginfo, gdb_byte *inf_siginfo, int direction)
3847 if (linux_nat_siginfo_fixup != NULL)
3848 done = linux_nat_siginfo_fixup (siginfo, inf_siginfo, direction);
3850 /* If there was no callback, or the callback didn't do anything,
3851 then just do a straight memcpy. */
3855 memcpy (siginfo, inf_siginfo, sizeof (siginfo_t));
3857 memcpy (inf_siginfo, siginfo, sizeof (siginfo_t));
3861 static enum target_xfer_status
3862 linux_xfer_siginfo (struct target_ops *ops, enum target_object object,
3863 const char *annex, gdb_byte *readbuf,
3864 const gdb_byte *writebuf, ULONGEST offset, ULONGEST len,
3865 ULONGEST *xfered_len)
3869 gdb_byte inf_siginfo[sizeof (siginfo_t)];
3871 gdb_assert (object == TARGET_OBJECT_SIGNAL_INFO);
3872 gdb_assert (readbuf || writebuf);
3874 pid = ptid_get_lwp (inferior_ptid);
3876 pid = ptid_get_pid (inferior_ptid);
3878 if (offset > sizeof (siginfo))
3879 return TARGET_XFER_E_IO;
3882 ptrace (PTRACE_GETSIGINFO, pid, (PTRACE_TYPE_ARG3) 0, &siginfo);
3884 return TARGET_XFER_E_IO;
3886 /* When GDB is built as a 64-bit application, ptrace writes into
3887 SIGINFO an object with 64-bit layout. Since debugging a 32-bit
3888 inferior with a 64-bit GDB should look the same as debugging it
3889 with a 32-bit GDB, we need to convert it. GDB core always sees
3890 the converted layout, so any read/write will have to be done
3892 siginfo_fixup (&siginfo, inf_siginfo, 0);
3894 if (offset + len > sizeof (siginfo))
3895 len = sizeof (siginfo) - offset;
3897 if (readbuf != NULL)
3898 memcpy (readbuf, inf_siginfo + offset, len);
3901 memcpy (inf_siginfo + offset, writebuf, len);
3903 /* Convert back to ptrace layout before flushing it out. */
3904 siginfo_fixup (&siginfo, inf_siginfo, 1);
3907 ptrace (PTRACE_SETSIGINFO, pid, (PTRACE_TYPE_ARG3) 0, &siginfo);
3909 return TARGET_XFER_E_IO;
3913 return TARGET_XFER_OK;
3916 static enum target_xfer_status
3917 linux_nat_xfer_partial (struct target_ops *ops, enum target_object object,
3918 const char *annex, gdb_byte *readbuf,
3919 const gdb_byte *writebuf,
3920 ULONGEST offset, ULONGEST len, ULONGEST *xfered_len)
3922 struct cleanup *old_chain;
3923 enum target_xfer_status xfer;
3925 if (object == TARGET_OBJECT_SIGNAL_INFO)
3926 return linux_xfer_siginfo (ops, object, annex, readbuf, writebuf,
3927 offset, len, xfered_len);
3929 /* The target is connected but no live inferior is selected. Pass
3930 this request down to a lower stratum (e.g., the executable
3932 if (object == TARGET_OBJECT_MEMORY && ptid_equal (inferior_ptid, null_ptid))
3933 return TARGET_XFER_EOF;
3935 old_chain = save_inferior_ptid ();
3937 if (ptid_lwp_p (inferior_ptid))
3938 inferior_ptid = pid_to_ptid (ptid_get_lwp (inferior_ptid));
3940 xfer = linux_ops->to_xfer_partial (ops, object, annex, readbuf, writebuf,
3941 offset, len, xfered_len);
3943 do_cleanups (old_chain);
3948 linux_thread_alive (ptid_t ptid)
3952 gdb_assert (ptid_lwp_p (ptid));
3954 /* Send signal 0 instead of anything ptrace, because ptracing a
3955 running thread errors out claiming that the thread doesn't
3957 err = kill_lwp (ptid_get_lwp (ptid), 0);
3959 if (debug_linux_nat)
3960 fprintf_unfiltered (gdb_stdlog,
3961 "LLTA: KILL(SIG0) %s (%s)\n",
3962 target_pid_to_str (ptid),
3963 err ? safe_strerror (tmp_errno) : "OK");
3972 linux_nat_thread_alive (struct target_ops *ops, ptid_t ptid)
3974 return linux_thread_alive (ptid);
3978 linux_nat_pid_to_str (struct target_ops *ops, ptid_t ptid)
3980 static char buf[64];
3982 if (ptid_lwp_p (ptid)
3983 && (ptid_get_pid (ptid) != ptid_get_lwp (ptid)
3984 || num_lwps (ptid_get_pid (ptid)) > 1))
3986 snprintf (buf, sizeof (buf), "LWP %ld", ptid_get_lwp (ptid));
3990 return normal_pid_to_str (ptid);
3994 linux_nat_thread_name (struct thread_info *thr)
3996 int pid = ptid_get_pid (thr->ptid);
3997 long lwp = ptid_get_lwp (thr->ptid);
3998 #define FORMAT "/proc/%d/task/%ld/comm"
3999 char buf[sizeof (FORMAT) + 30];
4001 char *result = NULL;
4003 snprintf (buf, sizeof (buf), FORMAT, pid, lwp);
4004 comm_file = gdb_fopen_cloexec (buf, "r");
4007 /* Not exported by the kernel, so we define it here. */
4009 static char line[COMM_LEN + 1];
4011 if (fgets (line, sizeof (line), comm_file))
4013 char *nl = strchr (line, '\n');
4030 /* Accepts an integer PID; Returns a string representing a file that
4031 can be opened to get the symbols for the child process. */
4034 linux_child_pid_to_exec_file (int pid)
4036 char *name1, *name2;
4038 name1 = xmalloc (PATH_MAX);
4039 name2 = xmalloc (PATH_MAX);
4040 make_cleanup (xfree, name1);
4041 make_cleanup (xfree, name2);
4042 memset (name2, 0, PATH_MAX);
4044 xsnprintf (name1, PATH_MAX, "/proc/%d/exe", pid);
4045 if (readlink (name1, name2, PATH_MAX - 1) > 0)
4051 /* Records the thread's register state for the corefile note
4055 linux_nat_collect_thread_registers (const struct regcache *regcache,
4056 ptid_t ptid, bfd *obfd,
4057 char *note_data, int *note_size,
4058 enum gdb_signal stop_signal)
4060 struct gdbarch *gdbarch = get_regcache_arch (regcache);
4061 const struct regset *regset;
4063 gdb_gregset_t gregs;
4064 gdb_fpregset_t fpregs;
4066 core_regset_p = gdbarch_regset_from_core_section_p (gdbarch);
4069 && (regset = gdbarch_regset_from_core_section (gdbarch, ".reg",
4071 != NULL && regset->collect_regset != NULL)
4072 regset->collect_regset (regset, regcache, -1, &gregs, sizeof (gregs));
4074 fill_gregset (regcache, &gregs, -1);
4076 note_data = (char *) elfcore_write_prstatus
4077 (obfd, note_data, note_size, ptid_get_lwp (ptid),
4078 gdb_signal_to_host (stop_signal), &gregs);
4081 && (regset = gdbarch_regset_from_core_section (gdbarch, ".reg2",
4083 != NULL && regset->collect_regset != NULL)
4084 regset->collect_regset (regset, regcache, -1, &fpregs, sizeof (fpregs));
4086 fill_fpregset (regcache, &fpregs, -1);
4088 note_data = (char *) elfcore_write_prfpreg (obfd, note_data, note_size,
4089 &fpregs, sizeof (fpregs));
4094 /* Fills the "to_make_corefile_note" target vector. Builds the note
4095 section for a corefile, and returns it in a malloc buffer. */
4098 linux_nat_make_corefile_notes (bfd *obfd, int *note_size)
4100 /* FIXME: uweigand/2011-10-06: Once all GNU/Linux architectures have been
4101 converted to gdbarch_core_regset_sections, this function can go away. */
4102 return linux_make_corefile_notes (target_gdbarch (), obfd, note_size,
4103 linux_nat_collect_thread_registers);
4106 /* Implement the to_xfer_partial interface for memory reads using the /proc
4107 filesystem. Because we can use a single read() call for /proc, this
4108 can be much more efficient than banging away at PTRACE_PEEKTEXT,
4109 but it doesn't support writes. */
4111 static enum target_xfer_status
4112 linux_proc_xfer_partial (struct target_ops *ops, enum target_object object,
4113 const char *annex, gdb_byte *readbuf,
4114 const gdb_byte *writebuf,
4115 ULONGEST offset, LONGEST len, ULONGEST *xfered_len)
4121 if (object != TARGET_OBJECT_MEMORY || !readbuf)
4124 /* Don't bother for one word. */
4125 if (len < 3 * sizeof (long))
4126 return TARGET_XFER_EOF;
4128 /* We could keep this file open and cache it - possibly one per
4129 thread. That requires some juggling, but is even faster. */
4130 xsnprintf (filename, sizeof filename, "/proc/%d/mem",
4131 ptid_get_pid (inferior_ptid));
4132 fd = gdb_open_cloexec (filename, O_RDONLY | O_LARGEFILE, 0);
4134 return TARGET_XFER_EOF;
4136 /* If pread64 is available, use it. It's faster if the kernel
4137 supports it (only one syscall), and it's 64-bit safe even on
4138 32-bit platforms (for instance, SPARC debugging a SPARC64
4141 if (pread64 (fd, readbuf, len, offset) != len)
4143 if (lseek (fd, offset, SEEK_SET) == -1 || read (fd, readbuf, len) != len)
4152 return TARGET_XFER_EOF;
4156 return TARGET_XFER_OK;
4161 /* Enumerate spufs IDs for process PID. */
4163 spu_enumerate_spu_ids (int pid, gdb_byte *buf, ULONGEST offset, ULONGEST len)
4165 enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch ());
4167 LONGEST written = 0;
4170 struct dirent *entry;
4172 xsnprintf (path, sizeof path, "/proc/%d/fd", pid);
4173 dir = opendir (path);
4178 while ((entry = readdir (dir)) != NULL)
4184 fd = atoi (entry->d_name);
4188 xsnprintf (path, sizeof path, "/proc/%d/fd/%d", pid, fd);
4189 if (stat (path, &st) != 0)
4191 if (!S_ISDIR (st.st_mode))
4194 if (statfs (path, &stfs) != 0)
4196 if (stfs.f_type != SPUFS_MAGIC)
4199 if (pos >= offset && pos + 4 <= offset + len)
4201 store_unsigned_integer (buf + pos - offset, 4, byte_order, fd);
4211 /* Implement the to_xfer_partial interface for the TARGET_OBJECT_SPU
4212 object type, using the /proc file system. */
4214 static enum target_xfer_status
4215 linux_proc_xfer_spu (struct target_ops *ops, enum target_object object,
4216 const char *annex, gdb_byte *readbuf,
4217 const gdb_byte *writebuf,
4218 ULONGEST offset, ULONGEST len, ULONGEST *xfered_len)
4223 int pid = ptid_get_pid (inferior_ptid);
4228 return TARGET_XFER_E_IO;
4231 LONGEST l = spu_enumerate_spu_ids (pid, readbuf, offset, len);
4234 return TARGET_XFER_E_IO;
4236 return TARGET_XFER_EOF;
4239 *xfered_len = (ULONGEST) l;
4240 return TARGET_XFER_OK;
4245 xsnprintf (buf, sizeof buf, "/proc/%d/fd/%s", pid, annex);
4246 fd = gdb_open_cloexec (buf, writebuf? O_WRONLY : O_RDONLY, 0);
4248 return TARGET_XFER_E_IO;
4251 && lseek (fd, (off_t) offset, SEEK_SET) != (off_t) offset)
4254 return TARGET_XFER_EOF;
4258 ret = write (fd, writebuf, (size_t) len);
4260 ret = read (fd, readbuf, (size_t) len);
4265 return TARGET_XFER_E_IO;
4267 return TARGET_XFER_EOF;
4270 *xfered_len = (ULONGEST) ret;
4271 return TARGET_XFER_OK;
4276 /* Parse LINE as a signal set and add its set bits to SIGS. */
4279 add_line_to_sigset (const char *line, sigset_t *sigs)
4281 int len = strlen (line) - 1;
4285 if (line[len] != '\n')
4286 error (_("Could not parse signal set: %s"), line);
4294 if (*p >= '0' && *p <= '9')
4296 else if (*p >= 'a' && *p <= 'f')
4297 digit = *p - 'a' + 10;
4299 error (_("Could not parse signal set: %s"), line);
4304 sigaddset (sigs, signum + 1);
4306 sigaddset (sigs, signum + 2);
4308 sigaddset (sigs, signum + 3);
4310 sigaddset (sigs, signum + 4);
4316 /* Find process PID's pending signals from /proc/pid/status and set
4320 linux_proc_pending_signals (int pid, sigset_t *pending,
4321 sigset_t *blocked, sigset_t *ignored)
4324 char buffer[PATH_MAX], fname[PATH_MAX];
4325 struct cleanup *cleanup;
4327 sigemptyset (pending);
4328 sigemptyset (blocked);
4329 sigemptyset (ignored);
4330 xsnprintf (fname, sizeof fname, "/proc/%d/status", pid);
4331 procfile = gdb_fopen_cloexec (fname, "r");
4332 if (procfile == NULL)
4333 error (_("Could not open %s"), fname);
4334 cleanup = make_cleanup_fclose (procfile);
4336 while (fgets (buffer, PATH_MAX, procfile) != NULL)
4338 /* Normal queued signals are on the SigPnd line in the status
4339 file. However, 2.6 kernels also have a "shared" pending
4340 queue for delivering signals to a thread group, so check for
4343 Unfortunately some Red Hat kernels include the shared pending
4344 queue but not the ShdPnd status field. */
4346 if (strncmp (buffer, "SigPnd:\t", 8) == 0)
4347 add_line_to_sigset (buffer + 8, pending);
4348 else if (strncmp (buffer, "ShdPnd:\t", 8) == 0)
4349 add_line_to_sigset (buffer + 8, pending);
4350 else if (strncmp (buffer, "SigBlk:\t", 8) == 0)
4351 add_line_to_sigset (buffer + 8, blocked);
4352 else if (strncmp (buffer, "SigIgn:\t", 8) == 0)
4353 add_line_to_sigset (buffer + 8, ignored);
4356 do_cleanups (cleanup);
4359 static enum target_xfer_status
4360 linux_nat_xfer_osdata (struct target_ops *ops, enum target_object object,
4361 const char *annex, gdb_byte *readbuf,
4362 const gdb_byte *writebuf, ULONGEST offset, ULONGEST len,
4363 ULONGEST *xfered_len)
4365 gdb_assert (object == TARGET_OBJECT_OSDATA);
4367 *xfered_len = linux_common_xfer_osdata (annex, readbuf, offset, len);
4368 if (*xfered_len == 0)
4369 return TARGET_XFER_EOF;
4371 return TARGET_XFER_OK;
4374 static enum target_xfer_status
4375 linux_xfer_partial (struct target_ops *ops, enum target_object object,
4376 const char *annex, gdb_byte *readbuf,
4377 const gdb_byte *writebuf, ULONGEST offset, ULONGEST len,
4378 ULONGEST *xfered_len)
4380 enum target_xfer_status xfer;
4382 if (object == TARGET_OBJECT_AUXV)
4383 return memory_xfer_auxv (ops, object, annex, readbuf, writebuf,
4384 offset, len, xfered_len);
4386 if (object == TARGET_OBJECT_OSDATA)
4387 return linux_nat_xfer_osdata (ops, object, annex, readbuf, writebuf,
4388 offset, len, xfered_len);
4390 if (object == TARGET_OBJECT_SPU)
4391 return linux_proc_xfer_spu (ops, object, annex, readbuf, writebuf,
4392 offset, len, xfered_len);
4394 /* GDB calculates all the addresses in possibly larget width of the address.
4395 Address width needs to be masked before its final use - either by
4396 linux_proc_xfer_partial or inf_ptrace_xfer_partial.
4398 Compare ADDR_BIT first to avoid a compiler warning on shift overflow. */
4400 if (object == TARGET_OBJECT_MEMORY)
4402 int addr_bit = gdbarch_addr_bit (target_gdbarch ());
4404 if (addr_bit < (sizeof (ULONGEST) * HOST_CHAR_BIT))
4405 offset &= ((ULONGEST) 1 << addr_bit) - 1;
4408 xfer = linux_proc_xfer_partial (ops, object, annex, readbuf, writebuf,
4409 offset, len, xfered_len);
4410 if (xfer != TARGET_XFER_EOF)
4413 return super_xfer_partial (ops, object, annex, readbuf, writebuf,
4414 offset, len, xfered_len);
4418 cleanup_target_stop (void *arg)
4420 ptid_t *ptid = (ptid_t *) arg;
4422 gdb_assert (arg != NULL);
4425 target_resume (*ptid, 0, GDB_SIGNAL_0);
4428 static VEC(static_tracepoint_marker_p) *
4429 linux_child_static_tracepoint_markers_by_strid (const char *strid)
4431 char s[IPA_CMD_BUF_SIZE];
4432 struct cleanup *old_chain;
4433 int pid = ptid_get_pid (inferior_ptid);
4434 VEC(static_tracepoint_marker_p) *markers = NULL;
4435 struct static_tracepoint_marker *marker = NULL;
4437 ptid_t ptid = ptid_build (pid, 0, 0);
4442 memcpy (s, "qTfSTM", sizeof ("qTfSTM"));
4443 s[sizeof ("qTfSTM")] = 0;
4445 agent_run_command (pid, s, strlen (s) + 1);
4447 old_chain = make_cleanup (free_current_marker, &marker);
4448 make_cleanup (cleanup_target_stop, &ptid);
4453 marker = XCNEW (struct static_tracepoint_marker);
4457 parse_static_tracepoint_marker_definition (p, &p, marker);
4459 if (strid == NULL || strcmp (strid, marker->str_id) == 0)
4461 VEC_safe_push (static_tracepoint_marker_p,
4467 release_static_tracepoint_marker (marker);
4468 memset (marker, 0, sizeof (*marker));
4471 while (*p++ == ','); /* comma-separated list */
4473 memcpy (s, "qTsSTM", sizeof ("qTsSTM"));
4474 s[sizeof ("qTsSTM")] = 0;
4475 agent_run_command (pid, s, strlen (s) + 1);
4479 do_cleanups (old_chain);
4484 /* Create a prototype generic GNU/Linux target. The client can override
4485 it with local methods. */
4488 linux_target_install_ops (struct target_ops *t)
4490 t->to_insert_fork_catchpoint = linux_child_insert_fork_catchpoint;
4491 t->to_remove_fork_catchpoint = linux_child_remove_fork_catchpoint;
4492 t->to_insert_vfork_catchpoint = linux_child_insert_vfork_catchpoint;
4493 t->to_remove_vfork_catchpoint = linux_child_remove_vfork_catchpoint;
4494 t->to_insert_exec_catchpoint = linux_child_insert_exec_catchpoint;
4495 t->to_remove_exec_catchpoint = linux_child_remove_exec_catchpoint;
4496 t->to_set_syscall_catchpoint = linux_child_set_syscall_catchpoint;
4497 t->to_pid_to_exec_file = linux_child_pid_to_exec_file;
4498 t->to_post_startup_inferior = linux_child_post_startup_inferior;
4499 t->to_post_attach = linux_child_post_attach;
4500 t->to_follow_fork = linux_child_follow_fork;
4501 t->to_make_corefile_notes = linux_nat_make_corefile_notes;
4503 super_xfer_partial = t->to_xfer_partial;
4504 t->to_xfer_partial = linux_xfer_partial;
4506 t->to_static_tracepoint_markers_by_strid
4507 = linux_child_static_tracepoint_markers_by_strid;
4513 struct target_ops *t;
4515 t = inf_ptrace_target ();
4516 linux_target_install_ops (t);
4522 linux_trad_target (CORE_ADDR (*register_u_offset)(struct gdbarch *, int, int))
4524 struct target_ops *t;
4526 t = inf_ptrace_trad_target (register_u_offset);
4527 linux_target_install_ops (t);
4532 /* target_is_async_p implementation. */
4535 linux_nat_is_async_p (struct target_ops *ops)
4537 /* NOTE: palves 2008-03-21: We're only async when the user requests
4538 it explicitly with the "set target-async" command.
4539 Someday, linux will always be async. */
4540 return target_async_permitted;
4543 /* target_can_async_p implementation. */
4546 linux_nat_can_async_p (struct target_ops *ops)
4548 /* NOTE: palves 2008-03-21: We're only async when the user requests
4549 it explicitly with the "set target-async" command.
4550 Someday, linux will always be async. */
4551 return target_async_permitted;
4555 linux_nat_supports_non_stop (void)
4560 /* True if we want to support multi-process. To be removed when GDB
4561 supports multi-exec. */
4563 int linux_multi_process = 1;
4566 linux_nat_supports_multi_process (void)
4568 return linux_multi_process;
4572 linux_nat_supports_disable_randomization (void)
4574 #ifdef HAVE_PERSONALITY
4581 static int async_terminal_is_ours = 1;
4583 /* target_terminal_inferior implementation. */
4586 linux_nat_terminal_inferior (struct target_ops *self)
4588 if (!target_is_async_p ())
4590 /* Async mode is disabled. */
4591 terminal_inferior (self);
4595 terminal_inferior (self);
4597 /* Calls to target_terminal_*() are meant to be idempotent. */
4598 if (!async_terminal_is_ours)
4601 delete_file_handler (input_fd);
4602 async_terminal_is_ours = 0;
4606 /* target_terminal_ours implementation. */
4609 linux_nat_terminal_ours (struct target_ops *self)
4611 if (!target_is_async_p ())
4613 /* Async mode is disabled. */
4614 terminal_ours (self);
4618 /* GDB should never give the terminal to the inferior if the
4619 inferior is running in the background (run&, continue&, etc.),
4620 but claiming it sure should. */
4621 terminal_ours (self);
4623 if (async_terminal_is_ours)
4626 clear_sigint_trap ();
4627 add_file_handler (input_fd, stdin_event_handler, 0);
4628 async_terminal_is_ours = 1;
4631 static void (*async_client_callback) (enum inferior_event_type event_type,
4633 static void *async_client_context;
4635 /* SIGCHLD handler that serves two purposes: In non-stop/async mode,
4636 so we notice when any child changes state, and notify the
4637 event-loop; it allows us to use sigsuspend in linux_nat_wait_1
4638 above to wait for the arrival of a SIGCHLD. */
4641 sigchld_handler (int signo)
4643 int old_errno = errno;
4645 if (debug_linux_nat)
4646 ui_file_write_async_safe (gdb_stdlog,
4647 "sigchld\n", sizeof ("sigchld\n") - 1);
4649 if (signo == SIGCHLD
4650 && linux_nat_event_pipe[0] != -1)
4651 async_file_mark (); /* Let the event loop know that there are
4652 events to handle. */
4657 /* Callback registered with the target events file descriptor. */
4660 handle_target_event (int error, gdb_client_data client_data)
4662 (*async_client_callback) (INF_REG_EVENT, async_client_context);
4665 /* Create/destroy the target events pipe. Returns previous state. */
4668 linux_async_pipe (int enable)
4670 int previous = (linux_nat_event_pipe[0] != -1);
4672 if (previous != enable)
4676 /* Block child signals while we create/destroy the pipe, as
4677 their handler writes to it. */
4678 block_child_signals (&prev_mask);
4682 if (gdb_pipe_cloexec (linux_nat_event_pipe) == -1)
4683 internal_error (__FILE__, __LINE__,
4684 "creating event pipe failed.");
4686 fcntl (linux_nat_event_pipe[0], F_SETFL, O_NONBLOCK);
4687 fcntl (linux_nat_event_pipe[1], F_SETFL, O_NONBLOCK);
4691 close (linux_nat_event_pipe[0]);
4692 close (linux_nat_event_pipe[1]);
4693 linux_nat_event_pipe[0] = -1;
4694 linux_nat_event_pipe[1] = -1;
4697 restore_child_signals_mask (&prev_mask);
4703 /* target_async implementation. */
4706 linux_nat_async (struct target_ops *ops,
4707 void (*callback) (enum inferior_event_type event_type,
4711 if (callback != NULL)
4713 async_client_callback = callback;
4714 async_client_context = context;
4715 if (!linux_async_pipe (1))
4717 add_file_handler (linux_nat_event_pipe[0],
4718 handle_target_event, NULL);
4719 /* There may be pending events to handle. Tell the event loop
4726 async_client_callback = callback;
4727 async_client_context = context;
4728 delete_file_handler (linux_nat_event_pipe[0]);
4729 linux_async_pipe (0);
4734 /* Stop an LWP, and push a GDB_SIGNAL_0 stop status if no other
4738 linux_nat_stop_lwp (struct lwp_info *lwp, void *data)
4742 if (debug_linux_nat)
4743 fprintf_unfiltered (gdb_stdlog,
4744 "LNSL: running -> suspending %s\n",
4745 target_pid_to_str (lwp->ptid));
4748 if (lwp->last_resume_kind == resume_stop)
4750 if (debug_linux_nat)
4751 fprintf_unfiltered (gdb_stdlog,
4752 "linux-nat: already stopping LWP %ld at "
4754 ptid_get_lwp (lwp->ptid));
4758 stop_callback (lwp, NULL);
4759 lwp->last_resume_kind = resume_stop;
4763 /* Already known to be stopped; do nothing. */
4765 if (debug_linux_nat)
4767 if (find_thread_ptid (lwp->ptid)->stop_requested)
4768 fprintf_unfiltered (gdb_stdlog,
4769 "LNSL: already stopped/stop_requested %s\n",
4770 target_pid_to_str (lwp->ptid));
4772 fprintf_unfiltered (gdb_stdlog,
4773 "LNSL: already stopped/no "
4774 "stop_requested yet %s\n",
4775 target_pid_to_str (lwp->ptid));
4782 linux_nat_stop (ptid_t ptid)
4785 iterate_over_lwps (ptid, linux_nat_stop_lwp, NULL);
4787 linux_ops->to_stop (ptid);
4791 linux_nat_close (struct target_ops *self)
4793 /* Unregister from the event loop. */
4794 if (linux_nat_is_async_p (NULL))
4795 linux_nat_async (NULL, NULL, 0);
4797 if (linux_ops->to_close)
4798 linux_ops->to_close (linux_ops);
4801 /* When requests are passed down from the linux-nat layer to the
4802 single threaded inf-ptrace layer, ptids of (lwpid,0,0) form are
4803 used. The address space pointer is stored in the inferior object,
4804 but the common code that is passed such ptid can't tell whether
4805 lwpid is a "main" process id or not (it assumes so). We reverse
4806 look up the "main" process id from the lwp here. */
4808 static struct address_space *
4809 linux_nat_thread_address_space (struct target_ops *t, ptid_t ptid)
4811 struct lwp_info *lwp;
4812 struct inferior *inf;
4815 pid = ptid_get_lwp (ptid);
4816 if (ptid_get_lwp (ptid) == 0)
4818 /* An (lwpid,0,0) ptid. Look up the lwp object to get at the
4820 lwp = find_lwp_pid (ptid);
4821 pid = ptid_get_pid (lwp->ptid);
4825 /* A (pid,lwpid,0) ptid. */
4826 pid = ptid_get_pid (ptid);
4829 inf = find_inferior_pid (pid);
4830 gdb_assert (inf != NULL);
4834 /* Return the cached value of the processor core for thread PTID. */
4837 linux_nat_core_of_thread (struct target_ops *ops, ptid_t ptid)
4839 struct lwp_info *info = find_lwp_pid (ptid);
4847 linux_nat_add_target (struct target_ops *t)
4849 /* Save the provided single-threaded target. We save this in a separate
4850 variable because another target we've inherited from (e.g. inf-ptrace)
4851 may have saved a pointer to T; we want to use it for the final
4852 process stratum target. */
4853 linux_ops_saved = *t;
4854 linux_ops = &linux_ops_saved;
4856 /* Override some methods for multithreading. */
4857 t->to_create_inferior = linux_nat_create_inferior;
4858 t->to_attach = linux_nat_attach;
4859 t->to_detach = linux_nat_detach;
4860 t->to_resume = linux_nat_resume;
4861 t->to_wait = linux_nat_wait;
4862 t->to_pass_signals = linux_nat_pass_signals;
4863 t->to_xfer_partial = linux_nat_xfer_partial;
4864 t->to_kill = linux_nat_kill;
4865 t->to_mourn_inferior = linux_nat_mourn_inferior;
4866 t->to_thread_alive = linux_nat_thread_alive;
4867 t->to_pid_to_str = linux_nat_pid_to_str;
4868 t->to_thread_name = linux_nat_thread_name;
4869 t->to_has_thread_control = tc_schedlock;
4870 t->to_thread_address_space = linux_nat_thread_address_space;
4871 t->to_stopped_by_watchpoint = linux_nat_stopped_by_watchpoint;
4872 t->to_stopped_data_address = linux_nat_stopped_data_address;
4874 t->to_can_async_p = linux_nat_can_async_p;
4875 t->to_is_async_p = linux_nat_is_async_p;
4876 t->to_supports_non_stop = linux_nat_supports_non_stop;
4877 t->to_async = linux_nat_async;
4878 t->to_terminal_inferior = linux_nat_terminal_inferior;
4879 t->to_terminal_ours = linux_nat_terminal_ours;
4880 t->to_close = linux_nat_close;
4882 /* Methods for non-stop support. */
4883 t->to_stop = linux_nat_stop;
4885 t->to_supports_multi_process = linux_nat_supports_multi_process;
4887 t->to_supports_disable_randomization
4888 = linux_nat_supports_disable_randomization;
4890 t->to_core_of_thread = linux_nat_core_of_thread;
4892 /* We don't change the stratum; this target will sit at
4893 process_stratum and thread_db will set at thread_stratum. This
4894 is a little strange, since this is a multi-threaded-capable
4895 target, but we want to be on the stack below thread_db, and we
4896 also want to be used for single-threaded processes. */
4901 /* Register a method to call whenever a new thread is attached. */
4903 linux_nat_set_new_thread (struct target_ops *t,
4904 void (*new_thread) (struct lwp_info *))
4906 /* Save the pointer. We only support a single registered instance
4907 of the GNU/Linux native target, so we do not need to map this to
4909 linux_nat_new_thread = new_thread;
4912 /* See declaration in linux-nat.h. */
4915 linux_nat_set_new_fork (struct target_ops *t,
4916 linux_nat_new_fork_ftype *new_fork)
4918 /* Save the pointer. */
4919 linux_nat_new_fork = new_fork;
4922 /* See declaration in linux-nat.h. */
4925 linux_nat_set_forget_process (struct target_ops *t,
4926 linux_nat_forget_process_ftype *fn)
4928 /* Save the pointer. */
4929 linux_nat_forget_process_hook = fn;
4932 /* See declaration in linux-nat.h. */
4935 linux_nat_forget_process (pid_t pid)
4937 if (linux_nat_forget_process_hook != NULL)
4938 linux_nat_forget_process_hook (pid);
4941 /* Register a method that converts a siginfo object between the layout
4942 that ptrace returns, and the layout in the architecture of the
4945 linux_nat_set_siginfo_fixup (struct target_ops *t,
4946 int (*siginfo_fixup) (siginfo_t *,
4950 /* Save the pointer. */
4951 linux_nat_siginfo_fixup = siginfo_fixup;
4954 /* Register a method to call prior to resuming a thread. */
4957 linux_nat_set_prepare_to_resume (struct target_ops *t,
4958 void (*prepare_to_resume) (struct lwp_info *))
4960 /* Save the pointer. */
4961 linux_nat_prepare_to_resume = prepare_to_resume;
4964 /* See linux-nat.h. */
4967 linux_nat_get_siginfo (ptid_t ptid, siginfo_t *siginfo)
4971 pid = ptid_get_lwp (ptid);
4973 pid = ptid_get_pid (ptid);
4976 ptrace (PTRACE_GETSIGINFO, pid, (PTRACE_TYPE_ARG3) 0, siginfo);
4979 memset (siginfo, 0, sizeof (*siginfo));
4985 /* Provide a prototype to silence -Wmissing-prototypes. */
4986 extern initialize_file_ftype _initialize_linux_nat;
4989 _initialize_linux_nat (void)
4991 add_setshow_zuinteger_cmd ("lin-lwp", class_maintenance,
4992 &debug_linux_nat, _("\
4993 Set debugging of GNU/Linux lwp module."), _("\
4994 Show debugging of GNU/Linux lwp module."), _("\
4995 Enables printf debugging output."),
4997 show_debug_linux_nat,
4998 &setdebuglist, &showdebuglist);
5000 /* Save this mask as the default. */
5001 sigprocmask (SIG_SETMASK, NULL, &normal_mask);
5003 /* Install a SIGCHLD handler. */
5004 sigchld_action.sa_handler = sigchld_handler;
5005 sigemptyset (&sigchld_action.sa_mask);
5006 sigchld_action.sa_flags = SA_RESTART;
5008 /* Make it the default. */
5009 sigaction (SIGCHLD, &sigchld_action, NULL);
5011 /* Make sure we don't block SIGCHLD during a sigsuspend. */
5012 sigprocmask (SIG_SETMASK, NULL, &suspend_mask);
5013 sigdelset (&suspend_mask, SIGCHLD);
5015 sigemptyset (&blocked_mask);
5019 /* FIXME: kettenis/2000-08-26: The stuff on this page is specific to
5020 the GNU/Linux Threads library and therefore doesn't really belong
5023 /* Read variable NAME in the target and return its value if found.
5024 Otherwise return zero. It is assumed that the type of the variable
5028 get_signo (const char *name)
5030 struct minimal_symbol *ms;
5033 ms = lookup_minimal_symbol (name, NULL, NULL);
5037 if (target_read_memory (SYMBOL_VALUE_ADDRESS (ms), (gdb_byte *) &signo,
5038 sizeof (signo)) != 0)
5044 /* Return the set of signals used by the threads library in *SET. */
5047 lin_thread_get_thread_signals (sigset_t *set)
5049 struct sigaction action;
5050 int restart, cancel;
5052 sigemptyset (&blocked_mask);
5055 restart = get_signo ("__pthread_sig_restart");
5056 cancel = get_signo ("__pthread_sig_cancel");
5058 /* LinuxThreads normally uses the first two RT signals, but in some legacy
5059 cases may use SIGUSR1/SIGUSR2. NPTL always uses RT signals, but does
5060 not provide any way for the debugger to query the signal numbers -
5061 fortunately they don't change! */
5064 restart = __SIGRTMIN;
5067 cancel = __SIGRTMIN + 1;
5069 sigaddset (set, restart);
5070 sigaddset (set, cancel);
5072 /* The GNU/Linux Threads library makes terminating threads send a
5073 special "cancel" signal instead of SIGCHLD. Make sure we catch
5074 those (to prevent them from terminating GDB itself, which is
5075 likely to be their default action) and treat them the same way as
5078 action.sa_handler = sigchld_handler;
5079 sigemptyset (&action.sa_mask);
5080 action.sa_flags = SA_RESTART;
5081 sigaction (cancel, &action, NULL);
5083 /* We block the "cancel" signal throughout this code ... */
5084 sigaddset (&blocked_mask, cancel);
5085 sigprocmask (SIG_BLOCK, &blocked_mask, NULL);
5087 /* ... except during a sigsuspend. */
5088 sigdelset (&suspend_mask, cancel);