1 /* GNU/Linux native-dependent code common to multiple platforms.
3 Copyright (C) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008
4 Free Software Foundation, Inc.
6 This file is part of GDB.
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 3 of the License, or
11 (at your option) any later version.
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program. If not, see <http://www.gnu.org/licenses/>. */
24 #include "gdb_string.h"
26 #include "gdb_assert.h"
27 #ifdef HAVE_TKILL_SYSCALL
29 #include <sys/syscall.h>
31 #include <sys/ptrace.h>
32 #include "linux-nat.h"
33 #include "linux-fork.h"
34 #include "gdbthread.h"
38 #include "inf-ptrace.h"
40 #include <sys/param.h> /* for MAXPATHLEN */
41 #include <sys/procfs.h> /* for elf_gregset etc. */
42 #include "elf-bfd.h" /* for elfcore_write_* */
43 #include "gregset.h" /* for gregset */
44 #include "gdbcore.h" /* for get_exec_file */
45 #include <ctype.h> /* for isdigit */
46 #include "gdbthread.h" /* for struct thread_info etc. */
47 #include "gdb_stat.h" /* for struct stat */
48 #include <fcntl.h> /* for O_RDONLY */
54 /* If the system headers did not provide the constants, hard-code the normal
56 #ifndef PTRACE_EVENT_FORK
58 #define PTRACE_SETOPTIONS 0x4200
59 #define PTRACE_GETEVENTMSG 0x4201
61 /* options set using PTRACE_SETOPTIONS */
62 #define PTRACE_O_TRACESYSGOOD 0x00000001
63 #define PTRACE_O_TRACEFORK 0x00000002
64 #define PTRACE_O_TRACEVFORK 0x00000004
65 #define PTRACE_O_TRACECLONE 0x00000008
66 #define PTRACE_O_TRACEEXEC 0x00000010
67 #define PTRACE_O_TRACEVFORKDONE 0x00000020
68 #define PTRACE_O_TRACEEXIT 0x00000040
70 /* Wait extended result codes for the above trace options. */
71 #define PTRACE_EVENT_FORK 1
72 #define PTRACE_EVENT_VFORK 2
73 #define PTRACE_EVENT_CLONE 3
74 #define PTRACE_EVENT_EXEC 4
75 #define PTRACE_EVENT_VFORK_DONE 5
76 #define PTRACE_EVENT_EXIT 6
78 #endif /* PTRACE_EVENT_FORK */
80 /* We can't always assume that this flag is available, but all systems
81 with the ptrace event handlers also have __WALL, so it's safe to use
84 #define __WALL 0x40000000 /* Wait for any child. */
87 #ifndef PTRACE_GETSIGINFO
88 #define PTRACE_GETSIGINFO 0x4202
91 /* The single-threaded native GNU/Linux target_ops. We save a pointer for
92 the use of the multi-threaded target. */
93 static struct target_ops
*linux_ops
;
94 static struct target_ops linux_ops_saved
;
96 /* The method to call, if any, when a new thread is attached. */
97 static void (*linux_nat_new_thread
) (ptid_t
);
99 /* The saved to_xfer_partial method, inherited from inf-ptrace.c.
100 Called by our to_xfer_partial. */
101 static LONGEST (*super_xfer_partial
) (struct target_ops
*,
103 const char *, gdb_byte
*,
107 static int debug_linux_nat
;
109 show_debug_linux_nat (struct ui_file
*file
, int from_tty
,
110 struct cmd_list_element
*c
, const char *value
)
112 fprintf_filtered (file
, _("Debugging of GNU/Linux lwp module is %s.\n"),
116 static int linux_parent_pid
;
118 struct simple_pid_list
122 struct simple_pid_list
*next
;
124 struct simple_pid_list
*stopped_pids
;
126 /* This variable is a tri-state flag: -1 for unknown, 0 if PTRACE_O_TRACEFORK
127 can not be used, 1 if it can. */
129 static int linux_supports_tracefork_flag
= -1;
131 /* If we have PTRACE_O_TRACEFORK, this flag indicates whether we also have
132 PTRACE_O_TRACEVFORKDONE. */
134 static int linux_supports_tracevforkdone_flag
= -1;
137 /* Trivial list manipulation functions to keep track of a list of
138 new stopped processes. */
140 add_to_pid_list (struct simple_pid_list
**listp
, int pid
, int status
)
142 struct simple_pid_list
*new_pid
= xmalloc (sizeof (struct simple_pid_list
));
144 new_pid
->status
= status
;
145 new_pid
->next
= *listp
;
150 pull_pid_from_list (struct simple_pid_list
**listp
, int pid
, int *status
)
152 struct simple_pid_list
**p
;
154 for (p
= listp
; *p
!= NULL
; p
= &(*p
)->next
)
155 if ((*p
)->pid
== pid
)
157 struct simple_pid_list
*next
= (*p
)->next
;
158 *status
= (*p
)->status
;
167 linux_record_stopped_pid (int pid
, int status
)
169 add_to_pid_list (&stopped_pids
, pid
, status
);
173 /* A helper function for linux_test_for_tracefork, called after fork (). */
176 linux_tracefork_child (void)
180 ptrace (PTRACE_TRACEME
, 0, 0, 0);
181 kill (getpid (), SIGSTOP
);
186 /* Wrapper function for waitpid which handles EINTR. */
189 my_waitpid (int pid
, int *status
, int flags
)
194 ret
= waitpid (pid
, status
, flags
);
196 while (ret
== -1 && errno
== EINTR
);
201 /* Determine if PTRACE_O_TRACEFORK can be used to follow fork events.
203 First, we try to enable fork tracing on ORIGINAL_PID. If this fails,
204 we know that the feature is not available. This may change the tracing
205 options for ORIGINAL_PID, but we'll be setting them shortly anyway.
207 However, if it succeeds, we don't know for sure that the feature is
208 available; old versions of PTRACE_SETOPTIONS ignored unknown options. We
209 create a child process, attach to it, use PTRACE_SETOPTIONS to enable
210 fork tracing, and let it fork. If the process exits, we assume that we
211 can't use TRACEFORK; if we get the fork notification, and we can extract
212 the new child's PID, then we assume that we can. */
215 linux_test_for_tracefork (int original_pid
)
217 int child_pid
, ret
, status
;
220 linux_supports_tracefork_flag
= 0;
221 linux_supports_tracevforkdone_flag
= 0;
223 ret
= ptrace (PTRACE_SETOPTIONS
, original_pid
, 0, PTRACE_O_TRACEFORK
);
229 perror_with_name (("fork"));
232 linux_tracefork_child ();
234 ret
= my_waitpid (child_pid
, &status
, 0);
236 perror_with_name (("waitpid"));
237 else if (ret
!= child_pid
)
238 error (_("linux_test_for_tracefork: waitpid: unexpected result %d."), ret
);
239 if (! WIFSTOPPED (status
))
240 error (_("linux_test_for_tracefork: waitpid: unexpected status %d."), status
);
242 ret
= ptrace (PTRACE_SETOPTIONS
, child_pid
, 0, PTRACE_O_TRACEFORK
);
245 ret
= ptrace (PTRACE_KILL
, child_pid
, 0, 0);
248 warning (_("linux_test_for_tracefork: failed to kill child"));
252 ret
= my_waitpid (child_pid
, &status
, 0);
253 if (ret
!= child_pid
)
254 warning (_("linux_test_for_tracefork: failed to wait for killed child"));
255 else if (!WIFSIGNALED (status
))
256 warning (_("linux_test_for_tracefork: unexpected wait status 0x%x from "
257 "killed child"), status
);
262 /* Check whether PTRACE_O_TRACEVFORKDONE is available. */
263 ret
= ptrace (PTRACE_SETOPTIONS
, child_pid
, 0,
264 PTRACE_O_TRACEFORK
| PTRACE_O_TRACEVFORKDONE
);
265 linux_supports_tracevforkdone_flag
= (ret
== 0);
267 ret
= ptrace (PTRACE_CONT
, child_pid
, 0, 0);
269 warning (_("linux_test_for_tracefork: failed to resume child"));
271 ret
= my_waitpid (child_pid
, &status
, 0);
273 if (ret
== child_pid
&& WIFSTOPPED (status
)
274 && status
>> 16 == PTRACE_EVENT_FORK
)
277 ret
= ptrace (PTRACE_GETEVENTMSG
, child_pid
, 0, &second_pid
);
278 if (ret
== 0 && second_pid
!= 0)
282 linux_supports_tracefork_flag
= 1;
283 my_waitpid (second_pid
, &second_status
, 0);
284 ret
= ptrace (PTRACE_KILL
, second_pid
, 0, 0);
286 warning (_("linux_test_for_tracefork: failed to kill second child"));
287 my_waitpid (second_pid
, &status
, 0);
291 warning (_("linux_test_for_tracefork: unexpected result from waitpid "
292 "(%d, status 0x%x)"), ret
, status
);
294 ret
= ptrace (PTRACE_KILL
, child_pid
, 0, 0);
296 warning (_("linux_test_for_tracefork: failed to kill child"));
297 my_waitpid (child_pid
, &status
, 0);
300 /* Return non-zero iff we have tracefork functionality available.
301 This function also sets linux_supports_tracefork_flag. */
304 linux_supports_tracefork (int pid
)
306 if (linux_supports_tracefork_flag
== -1)
307 linux_test_for_tracefork (pid
);
308 return linux_supports_tracefork_flag
;
312 linux_supports_tracevforkdone (int pid
)
314 if (linux_supports_tracefork_flag
== -1)
315 linux_test_for_tracefork (pid
);
316 return linux_supports_tracevforkdone_flag
;
321 linux_enable_event_reporting (ptid_t ptid
)
323 int pid
= ptid_get_lwp (ptid
);
327 pid
= ptid_get_pid (ptid
);
329 if (! linux_supports_tracefork (pid
))
332 options
= PTRACE_O_TRACEFORK
| PTRACE_O_TRACEVFORK
| PTRACE_O_TRACEEXEC
333 | PTRACE_O_TRACECLONE
;
334 if (linux_supports_tracevforkdone (pid
))
335 options
|= PTRACE_O_TRACEVFORKDONE
;
337 /* Do not enable PTRACE_O_TRACEEXIT until GDB is more prepared to support
338 read-only process state. */
340 ptrace (PTRACE_SETOPTIONS
, pid
, 0, options
);
344 linux_child_post_attach (int pid
)
346 linux_enable_event_reporting (pid_to_ptid (pid
));
347 check_for_thread_db ();
351 linux_child_post_startup_inferior (ptid_t ptid
)
353 linux_enable_event_reporting (ptid
);
354 check_for_thread_db ();
358 linux_child_follow_fork (struct target_ops
*ops
, int follow_child
)
361 struct target_waitstatus last_status
;
363 int parent_pid
, child_pid
;
365 get_last_target_status (&last_ptid
, &last_status
);
366 has_vforked
= (last_status
.kind
== TARGET_WAITKIND_VFORKED
);
367 parent_pid
= ptid_get_lwp (last_ptid
);
369 parent_pid
= ptid_get_pid (last_ptid
);
370 child_pid
= last_status
.value
.related_pid
;
374 /* We're already attached to the parent, by default. */
376 /* Before detaching from the child, remove all breakpoints from
377 it. (This won't actually modify the breakpoint list, but will
378 physically remove the breakpoints from the child.) */
379 /* If we vforked this will remove the breakpoints from the parent
380 also, but they'll be reinserted below. */
381 detach_breakpoints (child_pid
);
383 /* Detach new forked process? */
386 if (info_verbose
|| debug_linux_nat
)
388 target_terminal_ours ();
389 fprintf_filtered (gdb_stdlog
,
390 "Detaching after fork from child process %d.\n",
394 ptrace (PTRACE_DETACH
, child_pid
, 0, 0);
398 struct fork_info
*fp
;
399 /* Retain child fork in ptrace (stopped) state. */
400 fp
= find_fork_pid (child_pid
);
402 fp
= add_fork (child_pid
);
403 fork_save_infrun_state (fp
, 0);
408 gdb_assert (linux_supports_tracefork_flag
>= 0);
409 if (linux_supports_tracevforkdone (0))
413 ptrace (PTRACE_CONT
, parent_pid
, 0, 0);
414 my_waitpid (parent_pid
, &status
, __WALL
);
415 if ((status
>> 16) != PTRACE_EVENT_VFORK_DONE
)
416 warning (_("Unexpected waitpid result %06x when waiting for "
417 "vfork-done"), status
);
421 /* We can't insert breakpoints until the child has
422 finished with the shared memory region. We need to
423 wait until that happens. Ideal would be to just
425 - ptrace (PTRACE_SYSCALL, parent_pid, 0, 0);
426 - waitpid (parent_pid, &status, __WALL);
427 However, most architectures can't handle a syscall
428 being traced on the way out if it wasn't traced on
431 We might also think to loop, continuing the child
432 until it exits or gets a SIGTRAP. One problem is
433 that the child might call ptrace with PTRACE_TRACEME.
435 There's no simple and reliable way to figure out when
436 the vforked child will be done with its copy of the
437 shared memory. We could step it out of the syscall,
438 two instructions, let it go, and then single-step the
439 parent once. When we have hardware single-step, this
440 would work; with software single-step it could still
441 be made to work but we'd have to be able to insert
442 single-step breakpoints in the child, and we'd have
443 to insert -just- the single-step breakpoint in the
444 parent. Very awkward.
446 In the end, the best we can do is to make sure it
447 runs for a little while. Hopefully it will be out of
448 range of any breakpoints we reinsert. Usually this
449 is only the single-step breakpoint at vfork's return
455 /* Since we vforked, breakpoints were removed in the parent
456 too. Put them back. */
457 reattach_breakpoints (parent_pid
);
462 char child_pid_spelling
[40];
464 /* Needed to keep the breakpoint lists in sync. */
466 detach_breakpoints (child_pid
);
468 /* Before detaching from the parent, remove all breakpoints from it. */
469 remove_breakpoints ();
471 if (info_verbose
|| debug_linux_nat
)
473 target_terminal_ours ();
474 fprintf_filtered (gdb_stdlog
,
475 "Attaching after fork to child process %d.\n",
479 /* If we're vforking, we may want to hold on to the parent until
480 the child exits or execs. At exec time we can remove the old
481 breakpoints from the parent and detach it; at exit time we
482 could do the same (or even, sneakily, resume debugging it - the
483 child's exec has failed, or something similar).
485 This doesn't clean up "properly", because we can't call
486 target_detach, but that's OK; if the current target is "child",
487 then it doesn't need any further cleanups, and lin_lwp will
488 generally not encounter vfork (vfork is defined to fork
491 The holding part is very easy if we have VFORKDONE events;
492 but keeping track of both processes is beyond GDB at the
493 moment. So we don't expose the parent to the rest of GDB.
494 Instead we quietly hold onto it until such time as we can
498 linux_parent_pid
= parent_pid
;
499 else if (!detach_fork
)
501 struct fork_info
*fp
;
502 /* Retain parent fork in ptrace (stopped) state. */
503 fp
= find_fork_pid (parent_pid
);
505 fp
= add_fork (parent_pid
);
506 fork_save_infrun_state (fp
, 0);
510 target_detach (NULL
, 0);
513 inferior_ptid
= ptid_build (child_pid
, child_pid
, 0);
515 /* Reinstall ourselves, since we might have been removed in
516 target_detach (which does other necessary cleanup). */
519 linux_nat_switch_fork (inferior_ptid
);
520 check_for_thread_db ();
522 /* Reset breakpoints in the child as appropriate. */
523 follow_inferior_reset_breakpoints ();
531 linux_child_insert_fork_catchpoint (int pid
)
533 if (! linux_supports_tracefork (pid
))
534 error (_("Your system does not support fork catchpoints."));
538 linux_child_insert_vfork_catchpoint (int pid
)
540 if (!linux_supports_tracefork (pid
))
541 error (_("Your system does not support vfork catchpoints."));
545 linux_child_insert_exec_catchpoint (int pid
)
547 if (!linux_supports_tracefork (pid
))
548 error (_("Your system does not support exec catchpoints."));
551 /* On GNU/Linux there are no real LWP's. The closest thing to LWP's
552 are processes sharing the same VM space. A multi-threaded process
553 is basically a group of such processes. However, such a grouping
554 is almost entirely a user-space issue; the kernel doesn't enforce
555 such a grouping at all (this might change in the future). In
556 general, we'll rely on the threads library (i.e. the GNU/Linux
557 Threads library) to provide such a grouping.
559 It is perfectly well possible to write a multi-threaded application
560 without the assistance of a threads library, by using the clone
561 system call directly. This module should be able to give some
562 rudimentary support for debugging such applications if developers
563 specify the CLONE_PTRACE flag in the clone system call, and are
564 using the Linux kernel 2.4 or above.
566 Note that there are some peculiarities in GNU/Linux that affect
569 - In general one should specify the __WCLONE flag to waitpid in
570 order to make it report events for any of the cloned processes
571 (and leave it out for the initial process). However, if a cloned
572 process has exited the exit status is only reported if the
573 __WCLONE flag is absent. Linux kernel 2.4 has a __WALL flag, but
574 we cannot use it since GDB must work on older systems too.
576 - When a traced, cloned process exits and is waited for by the
577 debugger, the kernel reassigns it to the original parent and
578 keeps it around as a "zombie". Somehow, the GNU/Linux Threads
579 library doesn't notice this, which leads to the "zombie problem":
580 When debugged a multi-threaded process that spawns a lot of
581 threads will run out of processes, even if the threads exit,
582 because the "zombies" stay around. */
584 /* List of known LWPs. */
585 struct lwp_info
*lwp_list
;
587 /* Number of LWPs in the list. */
591 #define GET_LWP(ptid) ptid_get_lwp (ptid)
592 #define GET_PID(ptid) ptid_get_pid (ptid)
593 #define is_lwp(ptid) (GET_LWP (ptid) != 0)
594 #define BUILD_LWP(lwp, pid) ptid_build (pid, lwp, 0)
596 /* If the last reported event was a SIGTRAP, this variable is set to
597 the process id of the LWP/thread that got it. */
601 /* Since we cannot wait (in linux_nat_wait) for the initial process and
602 any cloned processes with a single call to waitpid, we have to use
603 the WNOHANG flag and call waitpid in a loop. To optimize
604 things a bit we use `sigsuspend' to wake us up when a process has
605 something to report (it will send us a SIGCHLD if it has). To make
606 this work we have to juggle with the signal mask. We save the
607 original signal mask such that we can restore it before creating a
608 new process in order to avoid blocking certain signals in the
609 inferior. We then block SIGCHLD during the waitpid/sigsuspend
612 /* Original signal mask. */
613 static sigset_t normal_mask
;
615 /* Signal mask for use with sigsuspend in linux_nat_wait, initialized in
616 _initialize_linux_nat. */
617 static sigset_t suspend_mask
;
619 /* Signals to block to make that sigsuspend work. */
620 static sigset_t blocked_mask
;
623 /* Prototypes for local functions. */
624 static int stop_wait_callback (struct lwp_info
*lp
, void *data
);
625 static int linux_nat_thread_alive (ptid_t ptid
);
626 static char *linux_child_pid_to_exec_file (int pid
);
628 /* Convert wait status STATUS to a string. Used for printing debug
632 status_to_str (int status
)
636 if (WIFSTOPPED (status
))
637 snprintf (buf
, sizeof (buf
), "%s (stopped)",
638 strsignal (WSTOPSIG (status
)));
639 else if (WIFSIGNALED (status
))
640 snprintf (buf
, sizeof (buf
), "%s (terminated)",
641 strsignal (WSTOPSIG (status
)));
643 snprintf (buf
, sizeof (buf
), "%d (exited)", WEXITSTATUS (status
));
648 /* Initialize the list of LWPs. Note that this module, contrary to
649 what GDB's generic threads layer does for its thread list,
650 re-initializes the LWP lists whenever we mourn or detach (which
651 doesn't involve mourning) the inferior. */
656 struct lwp_info
*lp
, *lpnext
;
658 for (lp
= lwp_list
; lp
; lp
= lpnext
)
668 /* Add the LWP specified by PID to the list. Return a pointer to the
669 structure describing the new LWP. The LWP should already be stopped
670 (with an exception for the very first LWP). */
672 static struct lwp_info
*
673 add_lwp (ptid_t ptid
)
677 gdb_assert (is_lwp (ptid
));
679 lp
= (struct lwp_info
*) xmalloc (sizeof (struct lwp_info
));
681 memset (lp
, 0, sizeof (struct lwp_info
));
683 lp
->waitstatus
.kind
= TARGET_WAITKIND_IGNORE
;
691 if (num_lwps
> 1 && linux_nat_new_thread
!= NULL
)
692 linux_nat_new_thread (ptid
);
697 /* Remove the LWP specified by PID from the list. */
700 delete_lwp (ptid_t ptid
)
702 struct lwp_info
*lp
, *lpprev
;
706 for (lp
= lwp_list
; lp
; lpprev
= lp
, lp
= lp
->next
)
707 if (ptid_equal (lp
->ptid
, ptid
))
716 lpprev
->next
= lp
->next
;
723 /* Return a pointer to the structure describing the LWP corresponding
724 to PID. If no corresponding LWP could be found, return NULL. */
726 static struct lwp_info
*
727 find_lwp_pid (ptid_t ptid
)
733 lwp
= GET_LWP (ptid
);
735 lwp
= GET_PID (ptid
);
737 for (lp
= lwp_list
; lp
; lp
= lp
->next
)
738 if (lwp
== GET_LWP (lp
->ptid
))
744 /* Call CALLBACK with its second argument set to DATA for every LWP in
745 the list. If CALLBACK returns 1 for a particular LWP, return a
746 pointer to the structure describing that LWP immediately.
747 Otherwise return NULL. */
750 iterate_over_lwps (int (*callback
) (struct lwp_info
*, void *), void *data
)
752 struct lwp_info
*lp
, *lpnext
;
754 for (lp
= lwp_list
; lp
; lp
= lpnext
)
757 if ((*callback
) (lp
, data
))
764 /* Update our internal state when changing from one fork (checkpoint,
765 et cetera) to another indicated by NEW_PTID. We can only switch
766 single-threaded applications, so we only create one new LWP, and
767 the previous list is discarded. */
770 linux_nat_switch_fork (ptid_t new_ptid
)
775 lp
= add_lwp (new_ptid
);
779 /* Record a PTID for later deletion. */
784 struct saved_ptids
*next
;
786 static struct saved_ptids
*threads_to_delete
;
789 record_dead_thread (ptid_t ptid
)
791 struct saved_ptids
*p
= xmalloc (sizeof (struct saved_ptids
));
793 p
->next
= threads_to_delete
;
794 threads_to_delete
= p
;
797 /* Delete any dead threads which are not the current thread. */
802 struct saved_ptids
**p
= &threads_to_delete
;
805 if (! ptid_equal ((*p
)->ptid
, inferior_ptid
))
807 struct saved_ptids
*tmp
= *p
;
808 delete_thread (tmp
->ptid
);
816 /* Callback for iterate_over_threads that finds a thread corresponding
820 find_thread_from_lwp (struct thread_info
*thr
, void *dummy
)
822 ptid_t
*ptid_p
= dummy
;
824 if (GET_LWP (thr
->ptid
) && GET_LWP (thr
->ptid
) == GET_LWP (*ptid_p
))
830 /* Handle the exit of a single thread LP. */
833 exit_lwp (struct lwp_info
*lp
)
835 if (in_thread_list (lp
->ptid
))
837 /* Core GDB cannot deal with us deleting the current thread. */
838 if (!ptid_equal (lp
->ptid
, inferior_ptid
))
839 delete_thread (lp
->ptid
);
841 record_dead_thread (lp
->ptid
);
842 printf_unfiltered (_("[%s exited]\n"),
843 target_pid_to_str (lp
->ptid
));
847 /* Even if LP->PTID is not in the global GDB thread list, the
848 LWP may be - with an additional thread ID. We don't need
849 to print anything in this case; thread_db is in use and
850 already took care of that. But it didn't delete the thread
851 in order to handle zombies correctly. */
853 struct thread_info
*thr
;
855 thr
= iterate_over_threads (find_thread_from_lwp
, &lp
->ptid
);
858 if (!ptid_equal (thr
->ptid
, inferior_ptid
))
859 delete_thread (thr
->ptid
);
861 record_dead_thread (thr
->ptid
);
865 delete_lwp (lp
->ptid
);
868 /* Attach to the LWP specified by PID. If VERBOSE is non-zero, print
869 a message telling the user that a new LWP has been added to the
870 process. Return 0 if successful or -1 if the new LWP could not
874 lin_lwp_attach_lwp (ptid_t ptid
)
878 gdb_assert (is_lwp (ptid
));
880 /* Make sure SIGCHLD is blocked. We don't want SIGCHLD events
881 to interrupt either the ptrace() or waitpid() calls below. */
882 if (!sigismember (&blocked_mask
, SIGCHLD
))
884 sigaddset (&blocked_mask
, SIGCHLD
);
885 sigprocmask (SIG_BLOCK
, &blocked_mask
, NULL
);
888 lp
= find_lwp_pid (ptid
);
890 /* We assume that we're already attached to any LWP that has an id
891 equal to the overall process id, and to any LWP that is already
892 in our list of LWPs. If we're not seeing exit events from threads
893 and we've had PID wraparound since we last tried to stop all threads,
894 this assumption might be wrong; fortunately, this is very unlikely
896 if (GET_LWP (ptid
) != GET_PID (ptid
) && lp
== NULL
)
902 if (ptrace (PTRACE_ATTACH
, GET_LWP (ptid
), 0, 0) < 0)
904 /* If we fail to attach to the thread, issue a warning,
905 but continue. One way this can happen is if thread
906 creation is interrupted; as of Linux kernel 2.6.19, a
907 bug may place threads in the thread list and then fail
909 warning (_("Can't attach %s: %s"), target_pid_to_str (ptid
),
910 safe_strerror (errno
));
915 fprintf_unfiltered (gdb_stdlog
,
916 "LLAL: PTRACE_ATTACH %s, 0, 0 (OK)\n",
917 target_pid_to_str (ptid
));
919 pid
= my_waitpid (GET_LWP (ptid
), &status
, 0);
920 if (pid
== -1 && errno
== ECHILD
)
922 /* Try again with __WCLONE to check cloned processes. */
923 pid
= my_waitpid (GET_LWP (ptid
), &status
, __WCLONE
);
927 gdb_assert (pid
== GET_LWP (ptid
)
928 && WIFSTOPPED (status
) && WSTOPSIG (status
));
934 target_post_attach (pid
);
940 fprintf_unfiltered (gdb_stdlog
,
941 "LLAL: waitpid %s received %s\n",
942 target_pid_to_str (ptid
),
943 status_to_str (status
));
948 /* We assume that the LWP representing the original process is
949 already stopped. Mark it as stopped in the data structure
950 that the GNU/linux ptrace layer uses to keep track of
951 threads. Note that this won't have already been done since
952 the main thread will have, we assume, been stopped by an
953 attach from a different layer. */
963 linux_nat_attach (char *args
, int from_tty
)
970 /* FIXME: We should probably accept a list of process id's, and
971 attach all of them. */
972 linux_ops
->to_attach (args
, from_tty
);
974 /* Make sure the initial process is stopped. The user-level threads
975 layer might want to poke around in the inferior, and that won't
976 work if things haven't stabilized yet. */
977 pid
= my_waitpid (GET_PID (inferior_ptid
), &status
, 0);
978 if (pid
== -1 && errno
== ECHILD
)
980 warning (_("%s is a cloned process"), target_pid_to_str (inferior_ptid
));
982 /* Try again with __WCLONE to check cloned processes. */
983 pid
= my_waitpid (GET_PID (inferior_ptid
), &status
, __WCLONE
);
987 gdb_assert (pid
== GET_PID (inferior_ptid
)
988 && WIFSTOPPED (status
) && WSTOPSIG (status
) == SIGSTOP
);
990 /* Add the initial process as the first LWP to the list. */
991 inferior_ptid
= BUILD_LWP (GET_PID (inferior_ptid
), GET_PID (inferior_ptid
));
992 lp
= add_lwp (inferior_ptid
);
997 /* Fake the SIGSTOP that core GDB expects. */
998 lp
->status
= W_STOPCODE (SIGSTOP
);
1000 if (debug_linux_nat
)
1002 fprintf_unfiltered (gdb_stdlog
,
1003 "LLA: waitpid %ld, faking SIGSTOP\n", (long) pid
);
1008 detach_callback (struct lwp_info
*lp
, void *data
)
1010 gdb_assert (lp
->status
== 0 || WIFSTOPPED (lp
->status
));
1012 if (debug_linux_nat
&& lp
->status
)
1013 fprintf_unfiltered (gdb_stdlog
, "DC: Pending %s for %s on detach.\n",
1014 strsignal (WSTOPSIG (lp
->status
)),
1015 target_pid_to_str (lp
->ptid
));
1017 while (lp
->signalled
&& lp
->stopped
)
1020 if (ptrace (PTRACE_CONT
, GET_LWP (lp
->ptid
), 0,
1021 WSTOPSIG (lp
->status
)) < 0)
1022 error (_("Can't continue %s: %s"), target_pid_to_str (lp
->ptid
),
1023 safe_strerror (errno
));
1025 if (debug_linux_nat
)
1026 fprintf_unfiltered (gdb_stdlog
,
1027 "DC: PTRACE_CONTINUE (%s, 0, %s) (OK)\n",
1028 target_pid_to_str (lp
->ptid
),
1029 status_to_str (lp
->status
));
1034 /* FIXME drow/2003-08-26: There was a call to stop_wait_callback
1035 here. But since lp->signalled was cleared above,
1036 stop_wait_callback didn't do anything; the process was left
1037 running. Shouldn't we be waiting for it to stop?
1038 I've removed the call, since stop_wait_callback now does do
1039 something when called with lp->signalled == 0. */
1041 gdb_assert (lp
->status
== 0 || WIFSTOPPED (lp
->status
));
1044 /* We don't actually detach from the LWP that has an id equal to the
1045 overall process id just yet. */
1046 if (GET_LWP (lp
->ptid
) != GET_PID (lp
->ptid
))
1049 if (ptrace (PTRACE_DETACH
, GET_LWP (lp
->ptid
), 0,
1050 WSTOPSIG (lp
->status
)) < 0)
1051 error (_("Can't detach %s: %s"), target_pid_to_str (lp
->ptid
),
1052 safe_strerror (errno
));
1054 if (debug_linux_nat
)
1055 fprintf_unfiltered (gdb_stdlog
,
1056 "PTRACE_DETACH (%s, %s, 0) (OK)\n",
1057 target_pid_to_str (lp
->ptid
),
1058 strsignal (WSTOPSIG (lp
->status
)));
1060 delete_lwp (lp
->ptid
);
1067 linux_nat_detach (char *args
, int from_tty
)
1069 iterate_over_lwps (detach_callback
, NULL
);
1071 /* Only the initial process should be left right now. */
1072 gdb_assert (num_lwps
== 1);
1074 trap_ptid
= null_ptid
;
1076 /* Destroy LWP info; it's no longer valid. */
1079 /* Restore the original signal mask. */
1080 sigprocmask (SIG_SETMASK
, &normal_mask
, NULL
);
1081 sigemptyset (&blocked_mask
);
1083 inferior_ptid
= pid_to_ptid (GET_PID (inferior_ptid
));
1084 linux_ops
->to_detach (args
, from_tty
);
1090 resume_callback (struct lwp_info
*lp
, void *data
)
1092 if (lp
->stopped
&& lp
->status
== 0)
1094 linux_ops
->to_resume (pid_to_ptid (GET_LWP (lp
->ptid
)),
1095 0, TARGET_SIGNAL_0
);
1096 if (debug_linux_nat
)
1097 fprintf_unfiltered (gdb_stdlog
,
1098 "RC: PTRACE_CONT %s, 0, 0 (resume sibling)\n",
1099 target_pid_to_str (lp
->ptid
));
1102 memset (&lp
->siginfo
, 0, sizeof (lp
->siginfo
));
1109 resume_clear_callback (struct lwp_info
*lp
, void *data
)
1116 resume_set_callback (struct lwp_info
*lp
, void *data
)
1123 linux_nat_resume (ptid_t ptid
, int step
, enum target_signal signo
)
1125 struct lwp_info
*lp
;
1128 if (debug_linux_nat
)
1129 fprintf_unfiltered (gdb_stdlog
,
1130 "LLR: Preparing to %s %s, %s, inferior_ptid %s\n",
1131 step
? "step" : "resume",
1132 target_pid_to_str (ptid
),
1133 signo
? strsignal (signo
) : "0",
1134 target_pid_to_str (inferior_ptid
));
1138 /* A specific PTID means `step only this process id'. */
1139 resume_all
= (PIDGET (ptid
) == -1);
1142 iterate_over_lwps (resume_set_callback
, NULL
);
1144 iterate_over_lwps (resume_clear_callback
, NULL
);
1146 /* If PID is -1, it's the current inferior that should be
1147 handled specially. */
1148 if (PIDGET (ptid
) == -1)
1149 ptid
= inferior_ptid
;
1151 lp
= find_lwp_pid (ptid
);
1152 gdb_assert (lp
!= NULL
);
1154 ptid
= pid_to_ptid (GET_LWP (lp
->ptid
));
1156 /* Remember if we're stepping. */
1159 /* Mark this LWP as resumed. */
1162 /* If we have a pending wait status for this thread, there is no
1163 point in resuming the process. But first make sure that
1164 linux_nat_wait won't preemptively handle the event - we
1165 should never take this short-circuit if we are going to
1166 leave LP running, since we have skipped resuming all the
1167 other threads. This bit of code needs to be synchronized
1168 with linux_nat_wait. */
1170 if (lp
->status
&& WIFSTOPPED (lp
->status
))
1172 int saved_signo
= target_signal_from_host (WSTOPSIG (lp
->status
));
1174 if (signal_stop_state (saved_signo
) == 0
1175 && signal_print_state (saved_signo
) == 0
1176 && signal_pass_state (saved_signo
) == 1)
1178 if (debug_linux_nat
)
1179 fprintf_unfiltered (gdb_stdlog
,
1180 "LLR: Not short circuiting for ignored "
1181 "status 0x%x\n", lp
->status
);
1183 /* FIXME: What should we do if we are supposed to continue
1184 this thread with a signal? */
1185 gdb_assert (signo
== TARGET_SIGNAL_0
);
1186 signo
= saved_signo
;
1193 /* FIXME: What should we do if we are supposed to continue
1194 this thread with a signal? */
1195 gdb_assert (signo
== TARGET_SIGNAL_0
);
1197 if (debug_linux_nat
)
1198 fprintf_unfiltered (gdb_stdlog
,
1199 "LLR: Short circuiting for status 0x%x\n",
1205 /* Mark LWP as not stopped to prevent it from being continued by
1210 iterate_over_lwps (resume_callback
, NULL
);
1212 linux_ops
->to_resume (ptid
, step
, signo
);
1213 memset (&lp
->siginfo
, 0, sizeof (lp
->siginfo
));
1215 if (debug_linux_nat
)
1216 fprintf_unfiltered (gdb_stdlog
,
1217 "LLR: %s %s, %s (resume event thread)\n",
1218 step
? "PTRACE_SINGLESTEP" : "PTRACE_CONT",
1219 target_pid_to_str (ptid
),
1220 signo
? strsignal (signo
) : "0");
1223 /* Issue kill to specified lwp. */
1225 static int tkill_failed
;
1228 kill_lwp (int lwpid
, int signo
)
1232 /* Use tkill, if possible, in case we are using nptl threads. If tkill
1233 fails, then we are not using nptl threads and we should be using kill. */
1235 #ifdef HAVE_TKILL_SYSCALL
1238 int ret
= syscall (__NR_tkill
, lwpid
, signo
);
1239 if (errno
!= ENOSYS
)
1246 return kill (lwpid
, signo
);
1249 /* Handle a GNU/Linux extended wait response. If we see a clone
1250 event, we need to add the new LWP to our list (and not report the
1251 trap to higher layers). This function returns non-zero if the
1252 event should be ignored and we should wait again. If STOPPING is
1253 true, the new LWP remains stopped, otherwise it is continued. */
1256 linux_handle_extended_wait (struct lwp_info
*lp
, int status
,
1259 int pid
= GET_LWP (lp
->ptid
);
1260 struct target_waitstatus
*ourstatus
= &lp
->waitstatus
;
1261 struct lwp_info
*new_lp
= NULL
;
1262 int event
= status
>> 16;
1264 if (event
== PTRACE_EVENT_FORK
|| event
== PTRACE_EVENT_VFORK
1265 || event
== PTRACE_EVENT_CLONE
)
1267 unsigned long new_pid
;
1270 ptrace (PTRACE_GETEVENTMSG
, pid
, 0, &new_pid
);
1272 /* If we haven't already seen the new PID stop, wait for it now. */
1273 if (! pull_pid_from_list (&stopped_pids
, new_pid
, &status
))
1275 /* The new child has a pending SIGSTOP. We can't affect it until it
1276 hits the SIGSTOP, but we're already attached. */
1277 ret
= my_waitpid (new_pid
, &status
,
1278 (event
== PTRACE_EVENT_CLONE
) ? __WCLONE
: 0);
1280 perror_with_name (_("waiting for new child"));
1281 else if (ret
!= new_pid
)
1282 internal_error (__FILE__
, __LINE__
,
1283 _("wait returned unexpected PID %d"), ret
);
1284 else if (!WIFSTOPPED (status
))
1285 internal_error (__FILE__
, __LINE__
,
1286 _("wait returned unexpected status 0x%x"), status
);
1289 ourstatus
->value
.related_pid
= new_pid
;
1291 if (event
== PTRACE_EVENT_FORK
)
1292 ourstatus
->kind
= TARGET_WAITKIND_FORKED
;
1293 else if (event
== PTRACE_EVENT_VFORK
)
1294 ourstatus
->kind
= TARGET_WAITKIND_VFORKED
;
1297 ourstatus
->kind
= TARGET_WAITKIND_IGNORE
;
1298 new_lp
= add_lwp (BUILD_LWP (new_pid
, GET_PID (inferior_ptid
)));
1301 if (WSTOPSIG (status
) != SIGSTOP
)
1303 /* This can happen if someone starts sending signals to
1304 the new thread before it gets a chance to run, which
1305 have a lower number than SIGSTOP (e.g. SIGUSR1).
1306 This is an unlikely case, and harder to handle for
1307 fork / vfork than for clone, so we do not try - but
1308 we handle it for clone events here. We'll send
1309 the other signal on to the thread below. */
1311 new_lp
->signalled
= 1;
1317 new_lp
->stopped
= 1;
1320 new_lp
->resumed
= 1;
1321 ptrace (PTRACE_CONT
, lp
->waitstatus
.value
.related_pid
, 0,
1322 status
? WSTOPSIG (status
) : 0);
1325 if (debug_linux_nat
)
1326 fprintf_unfiltered (gdb_stdlog
,
1327 "LHEW: Got clone event from LWP %ld, resuming\n",
1328 GET_LWP (lp
->ptid
));
1329 ptrace (PTRACE_CONT
, GET_LWP (lp
->ptid
), 0, 0);
1337 if (event
== PTRACE_EVENT_EXEC
)
1339 ourstatus
->kind
= TARGET_WAITKIND_EXECD
;
1340 ourstatus
->value
.execd_pathname
1341 = xstrdup (linux_child_pid_to_exec_file (pid
));
1343 if (linux_parent_pid
)
1345 detach_breakpoints (linux_parent_pid
);
1346 ptrace (PTRACE_DETACH
, linux_parent_pid
, 0, 0);
1348 linux_parent_pid
= 0;
1354 internal_error (__FILE__
, __LINE__
,
1355 _("unknown ptrace event %d"), event
);
1358 /* Wait for LP to stop. Returns the wait status, or 0 if the LWP has
1362 wait_lwp (struct lwp_info
*lp
)
1366 int thread_dead
= 0;
1368 gdb_assert (!lp
->stopped
);
1369 gdb_assert (lp
->status
== 0);
1371 pid
= my_waitpid (GET_LWP (lp
->ptid
), &status
, 0);
1372 if (pid
== -1 && errno
== ECHILD
)
1374 pid
= my_waitpid (GET_LWP (lp
->ptid
), &status
, __WCLONE
);
1375 if (pid
== -1 && errno
== ECHILD
)
1377 /* The thread has previously exited. We need to delete it
1378 now because, for some vendor 2.4 kernels with NPTL
1379 support backported, there won't be an exit event unless
1380 it is the main thread. 2.6 kernels will report an exit
1381 event for each thread that exits, as expected. */
1383 if (debug_linux_nat
)
1384 fprintf_unfiltered (gdb_stdlog
, "WL: %s vanished.\n",
1385 target_pid_to_str (lp
->ptid
));
1391 gdb_assert (pid
== GET_LWP (lp
->ptid
));
1393 if (debug_linux_nat
)
1395 fprintf_unfiltered (gdb_stdlog
,
1396 "WL: waitpid %s received %s\n",
1397 target_pid_to_str (lp
->ptid
),
1398 status_to_str (status
));
1402 /* Check if the thread has exited. */
1403 if (WIFEXITED (status
) || WIFSIGNALED (status
))
1406 if (debug_linux_nat
)
1407 fprintf_unfiltered (gdb_stdlog
, "WL: %s exited.\n",
1408 target_pid_to_str (lp
->ptid
));
1417 gdb_assert (WIFSTOPPED (status
));
1419 /* Handle GNU/Linux's extended waitstatus for trace events. */
1420 if (WIFSTOPPED (status
) && WSTOPSIG (status
) == SIGTRAP
&& status
>> 16 != 0)
1422 if (debug_linux_nat
)
1423 fprintf_unfiltered (gdb_stdlog
,
1424 "WL: Handling extended status 0x%06x\n",
1426 if (linux_handle_extended_wait (lp
, status
, 1))
1427 return wait_lwp (lp
);
1433 /* Save the most recent siginfo for LP. This is currently only called
1434 for SIGTRAP; some ports use the si_addr field for
1435 target_stopped_data_address. In the future, it may also be used to
1436 restore the siginfo of requeued signals. */
1439 save_siginfo (struct lwp_info
*lp
)
1442 ptrace (PTRACE_GETSIGINFO
, GET_LWP (lp
->ptid
),
1443 (PTRACE_TYPE_ARG3
) 0, &lp
->siginfo
);
1446 memset (&lp
->siginfo
, 0, sizeof (lp
->siginfo
));
1449 /* Send a SIGSTOP to LP. */
1452 stop_callback (struct lwp_info
*lp
, void *data
)
1454 if (!lp
->stopped
&& !lp
->signalled
)
1458 if (debug_linux_nat
)
1460 fprintf_unfiltered (gdb_stdlog
,
1461 "SC: kill %s **<SIGSTOP>**\n",
1462 target_pid_to_str (lp
->ptid
));
1465 ret
= kill_lwp (GET_LWP (lp
->ptid
), SIGSTOP
);
1466 if (debug_linux_nat
)
1468 fprintf_unfiltered (gdb_stdlog
,
1469 "SC: lwp kill %d %s\n",
1471 errno
? safe_strerror (errno
) : "ERRNO-OK");
1475 gdb_assert (lp
->status
== 0);
1481 /* Wait until LP is stopped. If DATA is non-null it is interpreted as
1482 a pointer to a set of signals to be flushed immediately. */
1485 stop_wait_callback (struct lwp_info
*lp
, void *data
)
1487 sigset_t
*flush_mask
= data
;
1493 status
= wait_lwp (lp
);
1497 /* Ignore any signals in FLUSH_MASK. */
1498 if (flush_mask
&& sigismember (flush_mask
, WSTOPSIG (status
)))
1507 ptrace (PTRACE_CONT
, GET_LWP (lp
->ptid
), 0, 0);
1508 if (debug_linux_nat
)
1509 fprintf_unfiltered (gdb_stdlog
,
1510 "PTRACE_CONT %s, 0, 0 (%s)\n",
1511 target_pid_to_str (lp
->ptid
),
1512 errno
? safe_strerror (errno
) : "OK");
1514 return stop_wait_callback (lp
, flush_mask
);
1517 if (WSTOPSIG (status
) != SIGSTOP
)
1519 if (WSTOPSIG (status
) == SIGTRAP
)
1521 /* If a LWP other than the LWP that we're reporting an
1522 event for has hit a GDB breakpoint (as opposed to
1523 some random trap signal), then just arrange for it to
1524 hit it again later. We don't keep the SIGTRAP status
1525 and don't forward the SIGTRAP signal to the LWP. We
1526 will handle the current event, eventually we will
1527 resume all LWPs, and this one will get its breakpoint
1530 If we do not do this, then we run the risk that the
1531 user will delete or disable the breakpoint, but the
1532 thread will have already tripped on it. */
1534 /* Save the trap's siginfo in case we need it later. */
1537 /* Now resume this LWP and get the SIGSTOP event. */
1539 ptrace (PTRACE_CONT
, GET_LWP (lp
->ptid
), 0, 0);
1540 if (debug_linux_nat
)
1542 fprintf_unfiltered (gdb_stdlog
,
1543 "PTRACE_CONT %s, 0, 0 (%s)\n",
1544 target_pid_to_str (lp
->ptid
),
1545 errno
? safe_strerror (errno
) : "OK");
1547 fprintf_unfiltered (gdb_stdlog
,
1548 "SWC: Candidate SIGTRAP event in %s\n",
1549 target_pid_to_str (lp
->ptid
));
1551 /* Hold the SIGTRAP for handling by linux_nat_wait. */
1552 stop_wait_callback (lp
, data
);
1553 /* If there's another event, throw it back into the queue. */
1556 if (debug_linux_nat
)
1558 fprintf_unfiltered (gdb_stdlog
,
1559 "SWC: kill %s, %s\n",
1560 target_pid_to_str (lp
->ptid
),
1561 status_to_str ((int) status
));
1563 kill_lwp (GET_LWP (lp
->ptid
), WSTOPSIG (lp
->status
));
1565 /* Save the sigtrap event. */
1566 lp
->status
= status
;
1571 /* The thread was stopped with a signal other than
1572 SIGSTOP, and didn't accidentally trip a breakpoint. */
1574 if (debug_linux_nat
)
1576 fprintf_unfiltered (gdb_stdlog
,
1577 "SWC: Pending event %s in %s\n",
1578 status_to_str ((int) status
),
1579 target_pid_to_str (lp
->ptid
));
1581 /* Now resume this LWP and get the SIGSTOP event. */
1583 ptrace (PTRACE_CONT
, GET_LWP (lp
->ptid
), 0, 0);
1584 if (debug_linux_nat
)
1585 fprintf_unfiltered (gdb_stdlog
,
1586 "SWC: PTRACE_CONT %s, 0, 0 (%s)\n",
1587 target_pid_to_str (lp
->ptid
),
1588 errno
? safe_strerror (errno
) : "OK");
1590 /* Hold this event/waitstatus while we check to see if
1591 there are any more (we still want to get that SIGSTOP). */
1592 stop_wait_callback (lp
, data
);
1593 /* If the lp->status field is still empty, use it to hold
1594 this event. If not, then this event must be returned
1595 to the event queue of the LWP. */
1596 if (lp
->status
== 0)
1597 lp
->status
= status
;
1600 if (debug_linux_nat
)
1602 fprintf_unfiltered (gdb_stdlog
,
1603 "SWC: kill %s, %s\n",
1604 target_pid_to_str (lp
->ptid
),
1605 status_to_str ((int) status
));
1607 kill_lwp (GET_LWP (lp
->ptid
), WSTOPSIG (status
));
1614 /* We caught the SIGSTOP that we intended to catch, so
1615 there's no SIGSTOP pending. */
1624 /* Check whether PID has any pending signals in FLUSH_MASK. If so set
1625 the appropriate bits in PENDING, and return 1 - otherwise return 0. */
1628 linux_nat_has_pending (int pid
, sigset_t
*pending
, sigset_t
*flush_mask
)
1630 sigset_t blocked
, ignored
;
1633 linux_proc_pending_signals (pid
, pending
, &blocked
, &ignored
);
1638 for (i
= 1; i
< NSIG
; i
++)
1639 if (sigismember (pending
, i
))
1640 if (!sigismember (flush_mask
, i
)
1641 || sigismember (&blocked
, i
)
1642 || sigismember (&ignored
, i
))
1643 sigdelset (pending
, i
);
1645 if (sigisemptyset (pending
))
1651 /* DATA is interpreted as a mask of signals to flush. If LP has
1652 signals pending, and they are all in the flush mask, then arrange
1653 to flush them. LP should be stopped, as should all other threads
1654 it might share a signal queue with. */
1657 flush_callback (struct lwp_info
*lp
, void *data
)
1659 sigset_t
*flush_mask
= data
;
1660 sigset_t pending
, intersection
, blocked
, ignored
;
1663 /* Normally, when an LWP exits, it is removed from the LWP list. The
1664 last LWP isn't removed till later, however. So if there is only
1665 one LWP on the list, make sure it's alive. */
1666 if (lwp_list
== lp
&& lp
->next
== NULL
)
1667 if (!linux_nat_thread_alive (lp
->ptid
))
1670 /* Just because the LWP is stopped doesn't mean that new signals
1671 can't arrive from outside, so this function must be careful of
1672 race conditions. However, because all threads are stopped, we
1673 can assume that the pending mask will not shrink unless we resume
1674 the LWP, and that it will then get another signal. We can't
1675 control which one, however. */
1679 if (debug_linux_nat
)
1680 printf_unfiltered (_("FC: LP has pending status %06x\n"), lp
->status
);
1681 if (WIFSTOPPED (lp
->status
) && sigismember (flush_mask
, WSTOPSIG (lp
->status
)))
1685 /* While there is a pending signal we would like to flush, continue
1686 the inferior and collect another signal. But if there's already
1687 a saved status that we don't want to flush, we can't resume the
1688 inferior - if it stopped for some other reason we wouldn't have
1689 anywhere to save the new status. In that case, we must leave the
1690 signal unflushed (and possibly generate an extra SIGINT stop).
1691 That's much less bad than losing a signal. */
1692 while (lp
->status
== 0
1693 && linux_nat_has_pending (GET_LWP (lp
->ptid
), &pending
, flush_mask
))
1698 ret
= ptrace (PTRACE_CONT
, GET_LWP (lp
->ptid
), 0, 0);
1699 if (debug_linux_nat
)
1700 fprintf_unfiltered (gdb_stderr
,
1701 "FC: Sent PTRACE_CONT, ret %d %d\n", ret
, errno
);
1704 stop_wait_callback (lp
, flush_mask
);
1705 if (debug_linux_nat
)
1706 fprintf_unfiltered (gdb_stderr
,
1707 "FC: Wait finished; saved status is %d\n",
1714 /* Return non-zero if LP has a wait status pending. */
1717 status_callback (struct lwp_info
*lp
, void *data
)
1719 /* Only report a pending wait status if we pretend that this has
1720 indeed been resumed. */
1721 return (lp
->status
!= 0 && lp
->resumed
);
1724 /* Return non-zero if LP isn't stopped. */
1727 running_callback (struct lwp_info
*lp
, void *data
)
1729 return (lp
->stopped
== 0 || (lp
->status
!= 0 && lp
->resumed
));
1732 /* Count the LWP's that have had events. */
1735 count_events_callback (struct lwp_info
*lp
, void *data
)
1739 gdb_assert (count
!= NULL
);
1741 /* Count only LWPs that have a SIGTRAP event pending. */
1743 && WIFSTOPPED (lp
->status
) && WSTOPSIG (lp
->status
) == SIGTRAP
)
1749 /* Select the LWP (if any) that is currently being single-stepped. */
1752 select_singlestep_lwp_callback (struct lwp_info
*lp
, void *data
)
1754 if (lp
->step
&& lp
->status
!= 0)
1760 /* Select the Nth LWP that has had a SIGTRAP event. */
1763 select_event_lwp_callback (struct lwp_info
*lp
, void *data
)
1765 int *selector
= data
;
1767 gdb_assert (selector
!= NULL
);
1769 /* Select only LWPs that have a SIGTRAP event pending. */
1771 && WIFSTOPPED (lp
->status
) && WSTOPSIG (lp
->status
) == SIGTRAP
)
1772 if ((*selector
)-- == 0)
1779 cancel_breakpoints_callback (struct lwp_info
*lp
, void *data
)
1781 struct lwp_info
*event_lp
= data
;
1783 /* Leave the LWP that has been elected to receive a SIGTRAP alone. */
1787 /* If a LWP other than the LWP that we're reporting an event for has
1788 hit a GDB breakpoint (as opposed to some random trap signal),
1789 then just arrange for it to hit it again later. We don't keep
1790 the SIGTRAP status and don't forward the SIGTRAP signal to the
1791 LWP. We will handle the current event, eventually we will resume
1792 all LWPs, and this one will get its breakpoint trap again.
1794 If we do not do this, then we run the risk that the user will
1795 delete or disable the breakpoint, but the LWP will have already
1799 && WIFSTOPPED (lp
->status
) && WSTOPSIG (lp
->status
) == SIGTRAP
1800 && breakpoint_inserted_here_p (read_pc_pid (lp
->ptid
) -
1801 gdbarch_decr_pc_after_break
1804 if (debug_linux_nat
)
1805 fprintf_unfiltered (gdb_stdlog
,
1806 "CBC: Push back breakpoint for %s\n",
1807 target_pid_to_str (lp
->ptid
));
1809 /* Back up the PC if necessary. */
1810 if (gdbarch_decr_pc_after_break (current_gdbarch
))
1811 write_pc_pid (read_pc_pid (lp
->ptid
) - gdbarch_decr_pc_after_break
1815 /* Throw away the SIGTRAP. */
1822 /* Select one LWP out of those that have events pending. */
1825 select_event_lwp (struct lwp_info
**orig_lp
, int *status
)
1828 int random_selector
;
1829 struct lwp_info
*event_lp
;
1831 /* Record the wait status for the original LWP. */
1832 (*orig_lp
)->status
= *status
;
1834 /* Give preference to any LWP that is being single-stepped. */
1835 event_lp
= iterate_over_lwps (select_singlestep_lwp_callback
, NULL
);
1836 if (event_lp
!= NULL
)
1838 if (debug_linux_nat
)
1839 fprintf_unfiltered (gdb_stdlog
,
1840 "SEL: Select single-step %s\n",
1841 target_pid_to_str (event_lp
->ptid
));
1845 /* No single-stepping LWP. Select one at random, out of those
1846 which have had SIGTRAP events. */
1848 /* First see how many SIGTRAP events we have. */
1849 iterate_over_lwps (count_events_callback
, &num_events
);
1851 /* Now randomly pick a LWP out of those that have had a SIGTRAP. */
1852 random_selector
= (int)
1853 ((num_events
* (double) rand ()) / (RAND_MAX
+ 1.0));
1855 if (debug_linux_nat
&& num_events
> 1)
1856 fprintf_unfiltered (gdb_stdlog
,
1857 "SEL: Found %d SIGTRAP events, selecting #%d\n",
1858 num_events
, random_selector
);
1860 event_lp
= iterate_over_lwps (select_event_lwp_callback
,
1864 if (event_lp
!= NULL
)
1866 /* Switch the event LWP. */
1867 *orig_lp
= event_lp
;
1868 *status
= event_lp
->status
;
1871 /* Flush the wait status for the event LWP. */
1872 (*orig_lp
)->status
= 0;
1875 /* Return non-zero if LP has been resumed. */
1878 resumed_callback (struct lwp_info
*lp
, void *data
)
1883 /* Stop an active thread, verify it still exists, then resume it. */
1886 stop_and_resume_callback (struct lwp_info
*lp
, void *data
)
1888 struct lwp_info
*ptr
;
1890 if (!lp
->stopped
&& !lp
->signalled
)
1892 stop_callback (lp
, NULL
);
1893 stop_wait_callback (lp
, NULL
);
1894 /* Resume if the lwp still exists. */
1895 for (ptr
= lwp_list
; ptr
; ptr
= ptr
->next
)
1898 resume_callback (lp
, NULL
);
1899 resume_set_callback (lp
, NULL
);
1905 /* Check if we should go on and pass this event to common code.
1906 Return the affected lpw if we are, or NULL otherwise. */
1907 static struct lwp_info
*
1908 linux_nat_filter_event (int lwpid
, int status
, int options
)
1910 struct lwp_info
*lp
;
1912 lp
= find_lwp_pid (pid_to_ptid (lwpid
));
1914 /* Check for stop events reported by a process we didn't already
1915 know about - anything not already in our LWP list.
1917 If we're expecting to receive stopped processes after
1918 fork, vfork, and clone events, then we'll just add the
1919 new one to our list and go back to waiting for the event
1920 to be reported - the stopped process might be returned
1921 from waitpid before or after the event is. */
1922 if (WIFSTOPPED (status
) && !lp
)
1924 linux_record_stopped_pid (lwpid
, status
);
1928 /* Make sure we don't report an event for the exit of an LWP not in
1929 our list, i.e. not part of the current process. This can happen
1930 if we detach from a program we original forked and then it
1932 if (!WIFSTOPPED (status
) && !lp
)
1935 /* NOTE drow/2003-06-17: This code seems to be meant for debugging
1936 CLONE_PTRACE processes which do not use the thread library -
1937 otherwise we wouldn't find the new LWP this way. That doesn't
1938 currently work, and the following code is currently unreachable
1939 due to the two blocks above. If it's fixed some day, this code
1940 should be broken out into a function so that we can also pick up
1941 LWPs from the new interface. */
1944 lp
= add_lwp (BUILD_LWP (lwpid
, GET_PID (inferior_ptid
)));
1945 if (options
& __WCLONE
)
1948 gdb_assert (WIFSTOPPED (status
)
1949 && WSTOPSIG (status
) == SIGSTOP
);
1952 if (!in_thread_list (inferior_ptid
))
1954 inferior_ptid
= BUILD_LWP (GET_PID (inferior_ptid
),
1955 GET_PID (inferior_ptid
));
1956 add_thread (inferior_ptid
);
1959 add_thread (lp
->ptid
);
1962 /* Save the trap's siginfo in case we need it later. */
1963 if (WIFSTOPPED (status
) && WSTOPSIG (status
) == SIGTRAP
)
1966 /* Handle GNU/Linux's extended waitstatus for trace events. */
1967 if (WIFSTOPPED (status
) && WSTOPSIG (status
) == SIGTRAP
&& status
>> 16 != 0)
1969 if (debug_linux_nat
)
1970 fprintf_unfiltered (gdb_stdlog
,
1971 "LLW: Handling extended status 0x%06x\n",
1973 if (linux_handle_extended_wait (lp
, status
, 0))
1977 /* Check if the thread has exited. */
1978 if ((WIFEXITED (status
) || WIFSIGNALED (status
)) && num_lwps
> 1)
1980 /* If this is the main thread, we must stop all threads and
1981 verify if they are still alive. This is because in the nptl
1982 thread model, there is no signal issued for exiting LWPs
1983 other than the main thread. We only get the main thread exit
1984 signal once all child threads have already exited. If we
1985 stop all the threads and use the stop_wait_callback to check
1986 if they have exited we can determine whether this signal
1987 should be ignored or whether it means the end of the debugged
1988 application, regardless of which threading model is being
1990 if (GET_PID (lp
->ptid
) == GET_LWP (lp
->ptid
))
1993 iterate_over_lwps (stop_and_resume_callback
, NULL
);
1996 if (debug_linux_nat
)
1997 fprintf_unfiltered (gdb_stdlog
,
1998 "LLW: %s exited.\n",
1999 target_pid_to_str (lp
->ptid
));
2003 /* If there is at least one more LWP, then the exit signal was
2004 not the end of the debugged application and should be
2008 /* Make sure there is at least one thread running. */
2009 gdb_assert (iterate_over_lwps (running_callback
, NULL
));
2011 /* Discard the event. */
2016 /* Check if the current LWP has previously exited. In the nptl
2017 thread model, LWPs other than the main thread do not issue
2018 signals when they exit so we must check whenever the thread has
2019 stopped. A similar check is made in stop_wait_callback(). */
2020 if (num_lwps
> 1 && !linux_nat_thread_alive (lp
->ptid
))
2022 if (debug_linux_nat
)
2023 fprintf_unfiltered (gdb_stdlog
,
2024 "LLW: %s exited.\n",
2025 target_pid_to_str (lp
->ptid
));
2029 /* Make sure there is at least one thread running. */
2030 gdb_assert (iterate_over_lwps (running_callback
, NULL
));
2032 /* Discard the event. */
2036 /* Make sure we don't report a SIGSTOP that we sent ourselves in
2037 an attempt to stop an LWP. */
2039 && WIFSTOPPED (status
) && WSTOPSIG (status
) == SIGSTOP
)
2041 if (debug_linux_nat
)
2042 fprintf_unfiltered (gdb_stdlog
,
2043 "LLW: Delayed SIGSTOP caught for %s.\n",
2044 target_pid_to_str (lp
->ptid
));
2046 /* This is a delayed SIGSTOP. */
2049 registers_changed ();
2051 linux_ops
->to_resume (pid_to_ptid (GET_LWP (lp
->ptid
)),
2052 lp
->step
, TARGET_SIGNAL_0
);
2053 if (debug_linux_nat
)
2054 fprintf_unfiltered (gdb_stdlog
,
2055 "LLW: %s %s, 0, 0 (discard SIGSTOP)\n",
2057 "PTRACE_SINGLESTEP" : "PTRACE_CONT",
2058 target_pid_to_str (lp
->ptid
));
2061 gdb_assert (lp
->resumed
);
2063 /* Discard the event. */
2067 /* An interesting event. */
2073 linux_nat_wait (ptid_t ptid
, struct target_waitstatus
*ourstatus
)
2075 struct lwp_info
*lp
= NULL
;
2078 pid_t pid
= PIDGET (ptid
);
2079 sigset_t flush_mask
;
2081 /* The first time we get here after starting a new inferior, we may
2082 not have added it to the LWP list yet - this is the earliest
2083 moment at which we know its PID. */
2086 gdb_assert (!is_lwp (inferior_ptid
));
2088 inferior_ptid
= BUILD_LWP (GET_PID (inferior_ptid
),
2089 GET_PID (inferior_ptid
));
2090 lp
= add_lwp (inferior_ptid
);
2094 sigemptyset (&flush_mask
);
2096 /* Make sure SIGCHLD is blocked. */
2097 if (!sigismember (&blocked_mask
, SIGCHLD
))
2099 sigaddset (&blocked_mask
, SIGCHLD
);
2100 sigprocmask (SIG_BLOCK
, &blocked_mask
, NULL
);
2105 /* Make sure there is at least one LWP that has been resumed. */
2106 gdb_assert (iterate_over_lwps (resumed_callback
, NULL
));
2108 /* First check if there is a LWP with a wait status pending. */
2111 /* Any LWP that's been resumed will do. */
2112 lp
= iterate_over_lwps (status_callback
, NULL
);
2115 status
= lp
->status
;
2118 if (debug_linux_nat
&& status
)
2119 fprintf_unfiltered (gdb_stdlog
,
2120 "LLW: Using pending wait status %s for %s.\n",
2121 status_to_str (status
),
2122 target_pid_to_str (lp
->ptid
));
2125 /* But if we don't fine one, we'll have to wait, and check both
2126 cloned and uncloned processes. We start with the cloned
2128 options
= __WCLONE
| WNOHANG
;
2130 else if (is_lwp (ptid
))
2132 if (debug_linux_nat
)
2133 fprintf_unfiltered (gdb_stdlog
,
2134 "LLW: Waiting for specific LWP %s.\n",
2135 target_pid_to_str (ptid
));
2137 /* We have a specific LWP to check. */
2138 lp
= find_lwp_pid (ptid
);
2140 status
= lp
->status
;
2143 if (debug_linux_nat
&& status
)
2144 fprintf_unfiltered (gdb_stdlog
,
2145 "LLW: Using pending wait status %s for %s.\n",
2146 status_to_str (status
),
2147 target_pid_to_str (lp
->ptid
));
2149 /* If we have to wait, take into account whether PID is a cloned
2150 process or not. And we have to convert it to something that
2151 the layer beneath us can understand. */
2152 options
= lp
->cloned
? __WCLONE
: 0;
2153 pid
= GET_LWP (ptid
);
2156 if (status
&& lp
->signalled
)
2158 /* A pending SIGSTOP may interfere with the normal stream of
2159 events. In a typical case where interference is a problem,
2160 we have a SIGSTOP signal pending for LWP A while
2161 single-stepping it, encounter an event in LWP B, and take the
2162 pending SIGSTOP while trying to stop LWP A. After processing
2163 the event in LWP B, LWP A is continued, and we'll never see
2164 the SIGTRAP associated with the last time we were
2165 single-stepping LWP A. */
2167 /* Resume the thread. It should halt immediately returning the
2169 registers_changed ();
2170 linux_ops
->to_resume (pid_to_ptid (GET_LWP (lp
->ptid
)),
2171 lp
->step
, TARGET_SIGNAL_0
);
2172 if (debug_linux_nat
)
2173 fprintf_unfiltered (gdb_stdlog
,
2174 "LLW: %s %s, 0, 0 (expect SIGSTOP)\n",
2175 lp
->step
? "PTRACE_SINGLESTEP" : "PTRACE_CONT",
2176 target_pid_to_str (lp
->ptid
));
2178 gdb_assert (lp
->resumed
);
2180 /* This should catch the pending SIGSTOP. */
2181 stop_wait_callback (lp
, NULL
);
2184 set_sigint_trap (); /* Causes SIGINT to be passed on to the
2185 attached process. */
2192 lwpid
= my_waitpid (pid
, &status
, options
);
2195 gdb_assert (pid
== -1 || lwpid
== pid
);
2197 if (debug_linux_nat
)
2199 fprintf_unfiltered (gdb_stdlog
,
2200 "LLW: waitpid %ld received %s\n",
2201 (long) lwpid
, status_to_str (status
));
2204 lp
= linux_nat_filter_event (lwpid
, status
, options
);
2207 /* A discarded event. */
2217 /* Alternate between checking cloned and uncloned processes. */
2218 options
^= __WCLONE
;
2220 /* And suspend every time we have checked both. */
2221 if (options
& __WCLONE
)
2222 sigsuspend (&suspend_mask
);
2225 /* We shouldn't end up here unless we want to try again. */
2226 gdb_assert (status
== 0);
2229 clear_sigio_trap ();
2230 clear_sigint_trap ();
2234 /* Don't report signals that GDB isn't interested in, such as
2235 signals that are neither printed nor stopped upon. Stopping all
2236 threads can be a bit time-consuming so if we want decent
2237 performance with heavily multi-threaded programs, especially when
2238 they're using a high frequency timer, we'd better avoid it if we
2241 if (WIFSTOPPED (status
))
2243 int signo
= target_signal_from_host (WSTOPSIG (status
));
2245 /* If we get a signal while single-stepping, we may need special
2246 care, e.g. to skip the signal handler. Defer to common code. */
2248 && signal_stop_state (signo
) == 0
2249 && signal_print_state (signo
) == 0
2250 && signal_pass_state (signo
) == 1)
2252 /* FIMXE: kettenis/2001-06-06: Should we resume all threads
2253 here? It is not clear we should. GDB may not expect
2254 other threads to run. On the other hand, not resuming
2255 newly attached threads may cause an unwanted delay in
2256 getting them running. */
2257 registers_changed ();
2258 linux_ops
->to_resume (pid_to_ptid (GET_LWP (lp
->ptid
)),
2260 if (debug_linux_nat
)
2261 fprintf_unfiltered (gdb_stdlog
,
2262 "LLW: %s %s, %s (preempt 'handle')\n",
2264 "PTRACE_SINGLESTEP" : "PTRACE_CONT",
2265 target_pid_to_str (lp
->ptid
),
2266 signo
? strsignal (signo
) : "0");
2272 if (signo
== TARGET_SIGNAL_INT
&& signal_pass_state (signo
) == 0)
2274 /* If ^C/BREAK is typed at the tty/console, SIGINT gets
2275 forwarded to the entire process group, that is, all LWP's
2276 will receive it. Since we only want to report it once,
2277 we try to flush it from all LWPs except this one. */
2278 sigaddset (&flush_mask
, SIGINT
);
2282 /* This LWP is stopped now. */
2285 if (debug_linux_nat
)
2286 fprintf_unfiltered (gdb_stdlog
, "LLW: Candidate event %s in %s.\n",
2287 status_to_str (status
), target_pid_to_str (lp
->ptid
));
2289 /* Now stop all other LWP's ... */
2290 iterate_over_lwps (stop_callback
, NULL
);
2292 /* ... and wait until all of them have reported back that they're no
2294 iterate_over_lwps (stop_wait_callback
, &flush_mask
);
2295 iterate_over_lwps (flush_callback
, &flush_mask
);
2297 /* If we're not waiting for a specific LWP, choose an event LWP from
2298 among those that have had events. Giving equal priority to all
2299 LWPs that have had events helps prevent starvation. */
2301 select_event_lwp (&lp
, &status
);
2303 /* Now that we've selected our final event LWP, cancel any
2304 breakpoints in other LWPs that have hit a GDB breakpoint. See
2305 the comment in cancel_breakpoints_callback to find out why. */
2306 iterate_over_lwps (cancel_breakpoints_callback
, lp
);
2308 if (WIFSTOPPED (status
) && WSTOPSIG (status
) == SIGTRAP
)
2310 trap_ptid
= lp
->ptid
;
2311 if (debug_linux_nat
)
2312 fprintf_unfiltered (gdb_stdlog
,
2313 "LLW: trap_ptid is %s.\n",
2314 target_pid_to_str (trap_ptid
));
2317 trap_ptid
= null_ptid
;
2319 if (lp
->waitstatus
.kind
!= TARGET_WAITKIND_IGNORE
)
2321 *ourstatus
= lp
->waitstatus
;
2322 lp
->waitstatus
.kind
= TARGET_WAITKIND_IGNORE
;
2325 store_waitstatus (ourstatus
, status
);
2331 kill_callback (struct lwp_info
*lp
, void *data
)
2334 ptrace (PTRACE_KILL
, GET_LWP (lp
->ptid
), 0, 0);
2335 if (debug_linux_nat
)
2336 fprintf_unfiltered (gdb_stdlog
,
2337 "KC: PTRACE_KILL %s, 0, 0 (%s)\n",
2338 target_pid_to_str (lp
->ptid
),
2339 errno
? safe_strerror (errno
) : "OK");
2345 kill_wait_callback (struct lwp_info
*lp
, void *data
)
2349 /* We must make sure that there are no pending events (delayed
2350 SIGSTOPs, pending SIGTRAPs, etc.) to make sure the current
2351 program doesn't interfere with any following debugging session. */
2353 /* For cloned processes we must check both with __WCLONE and
2354 without, since the exit status of a cloned process isn't reported
2360 pid
= my_waitpid (GET_LWP (lp
->ptid
), NULL
, __WCLONE
);
2361 if (pid
!= (pid_t
) -1)
2363 if (debug_linux_nat
)
2364 fprintf_unfiltered (gdb_stdlog
,
2365 "KWC: wait %s received unknown.\n",
2366 target_pid_to_str (lp
->ptid
));
2367 /* The Linux kernel sometimes fails to kill a thread
2368 completely after PTRACE_KILL; that goes from the stop
2369 point in do_fork out to the one in
2370 get_signal_to_deliever and waits again. So kill it
2372 kill_callback (lp
, NULL
);
2375 while (pid
== GET_LWP (lp
->ptid
));
2377 gdb_assert (pid
== -1 && errno
== ECHILD
);
2382 pid
= my_waitpid (GET_LWP (lp
->ptid
), NULL
, 0);
2383 if (pid
!= (pid_t
) -1)
2385 if (debug_linux_nat
)
2386 fprintf_unfiltered (gdb_stdlog
,
2387 "KWC: wait %s received unk.\n",
2388 target_pid_to_str (lp
->ptid
));
2389 /* See the call to kill_callback above. */
2390 kill_callback (lp
, NULL
);
2393 while (pid
== GET_LWP (lp
->ptid
));
2395 gdb_assert (pid
== -1 && errno
== ECHILD
);
2400 linux_nat_kill (void)
2402 struct target_waitstatus last
;
2406 /* If we're stopped while forking and we haven't followed yet,
2407 kill the other task. We need to do this first because the
2408 parent will be sleeping if this is a vfork. */
2410 get_last_target_status (&last_ptid
, &last
);
2412 if (last
.kind
== TARGET_WAITKIND_FORKED
2413 || last
.kind
== TARGET_WAITKIND_VFORKED
)
2415 ptrace (PT_KILL
, last
.value
.related_pid
, 0, 0);
2419 if (forks_exist_p ())
2420 linux_fork_killall ();
2423 /* Kill all LWP's ... */
2424 iterate_over_lwps (kill_callback
, NULL
);
2426 /* ... and wait until we've flushed all events. */
2427 iterate_over_lwps (kill_wait_callback
, NULL
);
2430 target_mourn_inferior ();
2434 linux_nat_mourn_inferior (void)
2436 trap_ptid
= null_ptid
;
2438 /* Destroy LWP info; it's no longer valid. */
2441 /* Restore the original signal mask. */
2442 sigprocmask (SIG_SETMASK
, &normal_mask
, NULL
);
2443 sigemptyset (&blocked_mask
);
2445 if (! forks_exist_p ())
2446 /* Normal case, no other forks available. */
2447 linux_ops
->to_mourn_inferior ();
2449 /* Multi-fork case. The current inferior_ptid has exited, but
2450 there are other viable forks to debug. Delete the exiting
2451 one and context-switch to the first available. */
2452 linux_fork_mourn_inferior ();
2456 linux_nat_xfer_partial (struct target_ops
*ops
, enum target_object object
,
2457 const char *annex
, gdb_byte
*readbuf
,
2458 const gdb_byte
*writebuf
,
2459 ULONGEST offset
, LONGEST len
)
2461 struct cleanup
*old_chain
= save_inferior_ptid ();
2464 if (is_lwp (inferior_ptid
))
2465 inferior_ptid
= pid_to_ptid (GET_LWP (inferior_ptid
));
2467 xfer
= linux_ops
->to_xfer_partial (ops
, object
, annex
, readbuf
, writebuf
,
2470 do_cleanups (old_chain
);
2475 linux_nat_thread_alive (ptid_t ptid
)
2477 gdb_assert (is_lwp (ptid
));
2480 ptrace (PTRACE_PEEKUSER
, GET_LWP (ptid
), 0, 0);
2481 if (debug_linux_nat
)
2482 fprintf_unfiltered (gdb_stdlog
,
2483 "LLTA: PTRACE_PEEKUSER %s, 0, 0 (%s)\n",
2484 target_pid_to_str (ptid
),
2485 errno
? safe_strerror (errno
) : "OK");
2487 /* Not every Linux kernel implements PTRACE_PEEKUSER. But we can
2488 handle that case gracefully since ptrace will first do a lookup
2489 for the process based upon the passed-in pid. If that fails we
2490 will get either -ESRCH or -EPERM, otherwise the child exists and
2492 if (errno
== ESRCH
|| errno
== EPERM
)
2499 linux_nat_pid_to_str (ptid_t ptid
)
2501 static char buf
[64];
2503 if (lwp_list
&& lwp_list
->next
&& is_lwp (ptid
))
2505 snprintf (buf
, sizeof (buf
), "LWP %ld", GET_LWP (ptid
));
2509 return normal_pid_to_str (ptid
);
2513 sigchld_handler (int signo
)
2515 /* Do nothing. The only reason for this handler is that it allows
2516 us to use sigsuspend in linux_nat_wait above to wait for the
2517 arrival of a SIGCHLD. */
2520 /* Accepts an integer PID; Returns a string representing a file that
2521 can be opened to get the symbols for the child process. */
2524 linux_child_pid_to_exec_file (int pid
)
2526 char *name1
, *name2
;
2528 name1
= xmalloc (MAXPATHLEN
);
2529 name2
= xmalloc (MAXPATHLEN
);
2530 make_cleanup (xfree
, name1
);
2531 make_cleanup (xfree
, name2
);
2532 memset (name2
, 0, MAXPATHLEN
);
2534 sprintf (name1
, "/proc/%d/exe", pid
);
2535 if (readlink (name1
, name2
, MAXPATHLEN
) > 0)
2541 /* Service function for corefiles and info proc. */
2544 read_mapping (FILE *mapfile
,
2549 char *device
, long long *inode
, char *filename
)
2551 int ret
= fscanf (mapfile
, "%llx-%llx %s %llx %s %llx",
2552 addr
, endaddr
, permissions
, offset
, device
, inode
);
2555 if (ret
> 0 && ret
!= EOF
)
2557 /* Eat everything up to EOL for the filename. This will prevent
2558 weird filenames (such as one with embedded whitespace) from
2559 confusing this code. It also makes this code more robust in
2560 respect to annotations the kernel may add after the filename.
2562 Note the filename is used for informational purposes
2564 ret
+= fscanf (mapfile
, "%[^\n]\n", filename
);
2567 return (ret
!= 0 && ret
!= EOF
);
2570 /* Fills the "to_find_memory_regions" target vector. Lists the memory
2571 regions in the inferior for a corefile. */
2574 linux_nat_find_memory_regions (int (*func
) (CORE_ADDR
,
2576 int, int, int, void *), void *obfd
)
2578 long long pid
= PIDGET (inferior_ptid
);
2579 char mapsfilename
[MAXPATHLEN
];
2581 long long addr
, endaddr
, size
, offset
, inode
;
2582 char permissions
[8], device
[8], filename
[MAXPATHLEN
];
2583 int read
, write
, exec
;
2586 /* Compose the filename for the /proc memory map, and open it. */
2587 sprintf (mapsfilename
, "/proc/%lld/maps", pid
);
2588 if ((mapsfile
= fopen (mapsfilename
, "r")) == NULL
)
2589 error (_("Could not open %s."), mapsfilename
);
2592 fprintf_filtered (gdb_stdout
,
2593 "Reading memory regions from %s\n", mapsfilename
);
2595 /* Now iterate until end-of-file. */
2596 while (read_mapping (mapsfile
, &addr
, &endaddr
, &permissions
[0],
2597 &offset
, &device
[0], &inode
, &filename
[0]))
2599 size
= endaddr
- addr
;
2601 /* Get the segment's permissions. */
2602 read
= (strchr (permissions
, 'r') != 0);
2603 write
= (strchr (permissions
, 'w') != 0);
2604 exec
= (strchr (permissions
, 'x') != 0);
2608 fprintf_filtered (gdb_stdout
,
2609 "Save segment, %lld bytes at 0x%s (%c%c%c)",
2610 size
, paddr_nz (addr
),
2612 write
? 'w' : ' ', exec
? 'x' : ' ');
2614 fprintf_filtered (gdb_stdout
, " for %s", filename
);
2615 fprintf_filtered (gdb_stdout
, "\n");
2618 /* Invoke the callback function to create the corefile
2620 func (addr
, size
, read
, write
, exec
, obfd
);
2626 /* Records the thread's register state for the corefile note
2630 linux_nat_do_thread_registers (bfd
*obfd
, ptid_t ptid
,
2631 char *note_data
, int *note_size
)
2633 gdb_gregset_t gregs
;
2634 gdb_fpregset_t fpregs
;
2635 #ifdef FILL_FPXREGSET
2636 gdb_fpxregset_t fpxregs
;
2638 unsigned long lwp
= ptid_get_lwp (ptid
);
2639 struct regcache
*regcache
= get_thread_regcache (ptid
);
2640 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
2641 const struct regset
*regset
;
2643 struct cleanup
*old_chain
;
2645 old_chain
= save_inferior_ptid ();
2646 inferior_ptid
= ptid
;
2647 target_fetch_registers (regcache
, -1);
2648 do_cleanups (old_chain
);
2650 core_regset_p
= gdbarch_regset_from_core_section_p (gdbarch
);
2652 && (regset
= gdbarch_regset_from_core_section (gdbarch
, ".reg",
2653 sizeof (gregs
))) != NULL
2654 && regset
->collect_regset
!= NULL
)
2655 regset
->collect_regset (regset
, regcache
, -1,
2656 &gregs
, sizeof (gregs
));
2658 fill_gregset (regcache
, &gregs
, -1);
2660 note_data
= (char *) elfcore_write_prstatus (obfd
,
2664 stop_signal
, &gregs
);
2667 && (regset
= gdbarch_regset_from_core_section (gdbarch
, ".reg2",
2668 sizeof (fpregs
))) != NULL
2669 && regset
->collect_regset
!= NULL
)
2670 regset
->collect_regset (regset
, regcache
, -1,
2671 &fpregs
, sizeof (fpregs
));
2673 fill_fpregset (regcache
, &fpregs
, -1);
2675 note_data
= (char *) elfcore_write_prfpreg (obfd
,
2678 &fpregs
, sizeof (fpregs
));
2680 #ifdef FILL_FPXREGSET
2682 && (regset
= gdbarch_regset_from_core_section (gdbarch
, ".reg-xfp",
2683 sizeof (fpxregs
))) != NULL
2684 && regset
->collect_regset
!= NULL
)
2685 regset
->collect_regset (regset
, regcache
, -1,
2686 &fpxregs
, sizeof (fpxregs
));
2688 fill_fpxregset (regcache
, &fpxregs
, -1);
2690 note_data
= (char *) elfcore_write_prxfpreg (obfd
,
2693 &fpxregs
, sizeof (fpxregs
));
2698 struct linux_nat_corefile_thread_data
2706 /* Called by gdbthread.c once per thread. Records the thread's
2707 register state for the corefile note section. */
2710 linux_nat_corefile_thread_callback (struct lwp_info
*ti
, void *data
)
2712 struct linux_nat_corefile_thread_data
*args
= data
;
2714 args
->note_data
= linux_nat_do_thread_registers (args
->obfd
,
2723 /* Records the register state for the corefile note section. */
2726 linux_nat_do_registers (bfd
*obfd
, ptid_t ptid
,
2727 char *note_data
, int *note_size
)
2729 return linux_nat_do_thread_registers (obfd
,
2730 ptid_build (ptid_get_pid (inferior_ptid
),
2731 ptid_get_pid (inferior_ptid
),
2733 note_data
, note_size
);
2736 /* Fills the "to_make_corefile_note" target vector. Builds the note
2737 section for a corefile, and returns it in a malloc buffer. */
2740 linux_nat_make_corefile_notes (bfd
*obfd
, int *note_size
)
2742 struct linux_nat_corefile_thread_data thread_args
;
2743 struct cleanup
*old_chain
;
2744 /* The variable size must be >= sizeof (prpsinfo_t.pr_fname). */
2745 char fname
[16] = { '\0' };
2746 /* The variable size must be >= sizeof (prpsinfo_t.pr_psargs). */
2747 char psargs
[80] = { '\0' };
2748 char *note_data
= NULL
;
2749 ptid_t current_ptid
= inferior_ptid
;
2753 if (get_exec_file (0))
2755 strncpy (fname
, strrchr (get_exec_file (0), '/') + 1, sizeof (fname
));
2756 strncpy (psargs
, get_exec_file (0), sizeof (psargs
));
2757 if (get_inferior_args ())
2760 char *psargs_end
= psargs
+ sizeof (psargs
);
2762 /* linux_elfcore_write_prpsinfo () handles zero unterminated
2764 string_end
= memchr (psargs
, 0, sizeof (psargs
));
2765 if (string_end
!= NULL
)
2767 *string_end
++ = ' ';
2768 strncpy (string_end
, get_inferior_args (),
2769 psargs_end
- string_end
);
2772 note_data
= (char *) elfcore_write_prpsinfo (obfd
,
2774 note_size
, fname
, psargs
);
2777 /* Dump information for threads. */
2778 thread_args
.obfd
= obfd
;
2779 thread_args
.note_data
= note_data
;
2780 thread_args
.note_size
= note_size
;
2781 thread_args
.num_notes
= 0;
2782 iterate_over_lwps (linux_nat_corefile_thread_callback
, &thread_args
);
2783 if (thread_args
.num_notes
== 0)
2785 /* iterate_over_threads didn't come up with any threads; just
2786 use inferior_ptid. */
2787 note_data
= linux_nat_do_registers (obfd
, inferior_ptid
,
2788 note_data
, note_size
);
2792 note_data
= thread_args
.note_data
;
2795 auxv_len
= target_read_alloc (¤t_target
, TARGET_OBJECT_AUXV
,
2799 note_data
= elfcore_write_note (obfd
, note_data
, note_size
,
2800 "CORE", NT_AUXV
, auxv
, auxv_len
);
2804 make_cleanup (xfree
, note_data
);
2808 /* Implement the "info proc" command. */
2811 linux_nat_info_proc_cmd (char *args
, int from_tty
)
2813 long long pid
= PIDGET (inferior_ptid
);
2816 char buffer
[MAXPATHLEN
];
2817 char fname1
[MAXPATHLEN
], fname2
[MAXPATHLEN
];
2830 /* Break up 'args' into an argv array. */
2831 if ((argv
= buildargv (args
)) == NULL
)
2834 make_cleanup_freeargv (argv
);
2836 while (argv
!= NULL
&& *argv
!= NULL
)
2838 if (isdigit (argv
[0][0]))
2840 pid
= strtoul (argv
[0], NULL
, 10);
2842 else if (strncmp (argv
[0], "mappings", strlen (argv
[0])) == 0)
2846 else if (strcmp (argv
[0], "status") == 0)
2850 else if (strcmp (argv
[0], "stat") == 0)
2854 else if (strcmp (argv
[0], "cmd") == 0)
2858 else if (strncmp (argv
[0], "exe", strlen (argv
[0])) == 0)
2862 else if (strcmp (argv
[0], "cwd") == 0)
2866 else if (strncmp (argv
[0], "all", strlen (argv
[0])) == 0)
2872 /* [...] (future options here) */
2877 error (_("No current process: you must name one."));
2879 sprintf (fname1
, "/proc/%lld", pid
);
2880 if (stat (fname1
, &dummy
) != 0)
2881 error (_("No /proc directory: '%s'"), fname1
);
2883 printf_filtered (_("process %lld\n"), pid
);
2884 if (cmdline_f
|| all
)
2886 sprintf (fname1
, "/proc/%lld/cmdline", pid
);
2887 if ((procfile
= fopen (fname1
, "r")) != NULL
)
2889 fgets (buffer
, sizeof (buffer
), procfile
);
2890 printf_filtered ("cmdline = '%s'\n", buffer
);
2894 warning (_("unable to open /proc file '%s'"), fname1
);
2898 sprintf (fname1
, "/proc/%lld/cwd", pid
);
2899 memset (fname2
, 0, sizeof (fname2
));
2900 if (readlink (fname1
, fname2
, sizeof (fname2
)) > 0)
2901 printf_filtered ("cwd = '%s'\n", fname2
);
2903 warning (_("unable to read link '%s'"), fname1
);
2907 sprintf (fname1
, "/proc/%lld/exe", pid
);
2908 memset (fname2
, 0, sizeof (fname2
));
2909 if (readlink (fname1
, fname2
, sizeof (fname2
)) > 0)
2910 printf_filtered ("exe = '%s'\n", fname2
);
2912 warning (_("unable to read link '%s'"), fname1
);
2914 if (mappings_f
|| all
)
2916 sprintf (fname1
, "/proc/%lld/maps", pid
);
2917 if ((procfile
= fopen (fname1
, "r")) != NULL
)
2919 long long addr
, endaddr
, size
, offset
, inode
;
2920 char permissions
[8], device
[8], filename
[MAXPATHLEN
];
2922 printf_filtered (_("Mapped address spaces:\n\n"));
2923 if (gdbarch_addr_bit (current_gdbarch
) == 32)
2925 printf_filtered ("\t%10s %10s %10s %10s %7s\n",
2928 " Size", " Offset", "objfile");
2932 printf_filtered (" %18s %18s %10s %10s %7s\n",
2935 " Size", " Offset", "objfile");
2938 while (read_mapping (procfile
, &addr
, &endaddr
, &permissions
[0],
2939 &offset
, &device
[0], &inode
, &filename
[0]))
2941 size
= endaddr
- addr
;
2943 /* FIXME: carlton/2003-08-27: Maybe the printf_filtered
2944 calls here (and possibly above) should be abstracted
2945 out into their own functions? Andrew suggests using
2946 a generic local_address_string instead to print out
2947 the addresses; that makes sense to me, too. */
2949 if (gdbarch_addr_bit (current_gdbarch
) == 32)
2951 printf_filtered ("\t%#10lx %#10lx %#10x %#10x %7s\n",
2952 (unsigned long) addr
, /* FIXME: pr_addr */
2953 (unsigned long) endaddr
,
2955 (unsigned int) offset
,
2956 filename
[0] ? filename
: "");
2960 printf_filtered (" %#18lx %#18lx %#10x %#10x %7s\n",
2961 (unsigned long) addr
, /* FIXME: pr_addr */
2962 (unsigned long) endaddr
,
2964 (unsigned int) offset
,
2965 filename
[0] ? filename
: "");
2972 warning (_("unable to open /proc file '%s'"), fname1
);
2974 if (status_f
|| all
)
2976 sprintf (fname1
, "/proc/%lld/status", pid
);
2977 if ((procfile
= fopen (fname1
, "r")) != NULL
)
2979 while (fgets (buffer
, sizeof (buffer
), procfile
) != NULL
)
2980 puts_filtered (buffer
);
2984 warning (_("unable to open /proc file '%s'"), fname1
);
2988 sprintf (fname1
, "/proc/%lld/stat", pid
);
2989 if ((procfile
= fopen (fname1
, "r")) != NULL
)
2995 if (fscanf (procfile
, "%d ", &itmp
) > 0)
2996 printf_filtered (_("Process: %d\n"), itmp
);
2997 if (fscanf (procfile
, "(%[^)]) ", &buffer
[0]) > 0)
2998 printf_filtered (_("Exec file: %s\n"), buffer
);
2999 if (fscanf (procfile
, "%c ", &ctmp
) > 0)
3000 printf_filtered (_("State: %c\n"), ctmp
);
3001 if (fscanf (procfile
, "%d ", &itmp
) > 0)
3002 printf_filtered (_("Parent process: %d\n"), itmp
);
3003 if (fscanf (procfile
, "%d ", &itmp
) > 0)
3004 printf_filtered (_("Process group: %d\n"), itmp
);
3005 if (fscanf (procfile
, "%d ", &itmp
) > 0)
3006 printf_filtered (_("Session id: %d\n"), itmp
);
3007 if (fscanf (procfile
, "%d ", &itmp
) > 0)
3008 printf_filtered (_("TTY: %d\n"), itmp
);
3009 if (fscanf (procfile
, "%d ", &itmp
) > 0)
3010 printf_filtered (_("TTY owner process group: %d\n"), itmp
);
3011 if (fscanf (procfile
, "%lu ", <mp
) > 0)
3012 printf_filtered (_("Flags: 0x%lx\n"), ltmp
);
3013 if (fscanf (procfile
, "%lu ", <mp
) > 0)
3014 printf_filtered (_("Minor faults (no memory page): %lu\n"),
3015 (unsigned long) ltmp
);
3016 if (fscanf (procfile
, "%lu ", <mp
) > 0)
3017 printf_filtered (_("Minor faults, children: %lu\n"),
3018 (unsigned long) ltmp
);
3019 if (fscanf (procfile
, "%lu ", <mp
) > 0)
3020 printf_filtered (_("Major faults (memory page faults): %lu\n"),
3021 (unsigned long) ltmp
);
3022 if (fscanf (procfile
, "%lu ", <mp
) > 0)
3023 printf_filtered (_("Major faults, children: %lu\n"),
3024 (unsigned long) ltmp
);
3025 if (fscanf (procfile
, "%ld ", <mp
) > 0)
3026 printf_filtered (_("utime: %ld\n"), ltmp
);
3027 if (fscanf (procfile
, "%ld ", <mp
) > 0)
3028 printf_filtered (_("stime: %ld\n"), ltmp
);
3029 if (fscanf (procfile
, "%ld ", <mp
) > 0)
3030 printf_filtered (_("utime, children: %ld\n"), ltmp
);
3031 if (fscanf (procfile
, "%ld ", <mp
) > 0)
3032 printf_filtered (_("stime, children: %ld\n"), ltmp
);
3033 if (fscanf (procfile
, "%ld ", <mp
) > 0)
3034 printf_filtered (_("jiffies remaining in current time slice: %ld\n"),
3036 if (fscanf (procfile
, "%ld ", <mp
) > 0)
3037 printf_filtered (_("'nice' value: %ld\n"), ltmp
);
3038 if (fscanf (procfile
, "%lu ", <mp
) > 0)
3039 printf_filtered (_("jiffies until next timeout: %lu\n"),
3040 (unsigned long) ltmp
);
3041 if (fscanf (procfile
, "%lu ", <mp
) > 0)
3042 printf_filtered (_("jiffies until next SIGALRM: %lu\n"),
3043 (unsigned long) ltmp
);
3044 if (fscanf (procfile
, "%ld ", <mp
) > 0)
3045 printf_filtered (_("start time (jiffies since system boot): %ld\n"),
3047 if (fscanf (procfile
, "%lu ", <mp
) > 0)
3048 printf_filtered (_("Virtual memory size: %lu\n"),
3049 (unsigned long) ltmp
);
3050 if (fscanf (procfile
, "%lu ", <mp
) > 0)
3051 printf_filtered (_("Resident set size: %lu\n"), (unsigned long) ltmp
);
3052 if (fscanf (procfile
, "%lu ", <mp
) > 0)
3053 printf_filtered (_("rlim: %lu\n"), (unsigned long) ltmp
);
3054 if (fscanf (procfile
, "%lu ", <mp
) > 0)
3055 printf_filtered (_("Start of text: 0x%lx\n"), ltmp
);
3056 if (fscanf (procfile
, "%lu ", <mp
) > 0)
3057 printf_filtered (_("End of text: 0x%lx\n"), ltmp
);
3058 if (fscanf (procfile
, "%lu ", <mp
) > 0)
3059 printf_filtered (_("Start of stack: 0x%lx\n"), ltmp
);
3060 #if 0 /* Don't know how architecture-dependent the rest is...
3061 Anyway the signal bitmap info is available from "status". */
3062 if (fscanf (procfile
, "%lu ", <mp
) > 0) /* FIXME arch? */
3063 printf_filtered (_("Kernel stack pointer: 0x%lx\n"), ltmp
);
3064 if (fscanf (procfile
, "%lu ", <mp
) > 0) /* FIXME arch? */
3065 printf_filtered (_("Kernel instr pointer: 0x%lx\n"), ltmp
);
3066 if (fscanf (procfile
, "%ld ", <mp
) > 0)
3067 printf_filtered (_("Pending signals bitmap: 0x%lx\n"), ltmp
);
3068 if (fscanf (procfile
, "%ld ", <mp
) > 0)
3069 printf_filtered (_("Blocked signals bitmap: 0x%lx\n"), ltmp
);
3070 if (fscanf (procfile
, "%ld ", <mp
) > 0)
3071 printf_filtered (_("Ignored signals bitmap: 0x%lx\n"), ltmp
);
3072 if (fscanf (procfile
, "%ld ", <mp
) > 0)
3073 printf_filtered (_("Catched signals bitmap: 0x%lx\n"), ltmp
);
3074 if (fscanf (procfile
, "%lu ", <mp
) > 0) /* FIXME arch? */
3075 printf_filtered (_("wchan (system call): 0x%lx\n"), ltmp
);
3080 warning (_("unable to open /proc file '%s'"), fname1
);
3084 /* Implement the to_xfer_partial interface for memory reads using the /proc
3085 filesystem. Because we can use a single read() call for /proc, this
3086 can be much more efficient than banging away at PTRACE_PEEKTEXT,
3087 but it doesn't support writes. */
3090 linux_proc_xfer_partial (struct target_ops
*ops
, enum target_object object
,
3091 const char *annex
, gdb_byte
*readbuf
,
3092 const gdb_byte
*writebuf
,
3093 ULONGEST offset
, LONGEST len
)
3099 if (object
!= TARGET_OBJECT_MEMORY
|| !readbuf
)
3102 /* Don't bother for one word. */
3103 if (len
< 3 * sizeof (long))
3106 /* We could keep this file open and cache it - possibly one per
3107 thread. That requires some juggling, but is even faster. */
3108 sprintf (filename
, "/proc/%d/mem", PIDGET (inferior_ptid
));
3109 fd
= open (filename
, O_RDONLY
| O_LARGEFILE
);
3113 /* If pread64 is available, use it. It's faster if the kernel
3114 supports it (only one syscall), and it's 64-bit safe even on
3115 32-bit platforms (for instance, SPARC debugging a SPARC64
3118 if (pread64 (fd
, readbuf
, len
, offset
) != len
)
3120 if (lseek (fd
, offset
, SEEK_SET
) == -1 || read (fd
, readbuf
, len
) != len
)
3130 /* Parse LINE as a signal set and add its set bits to SIGS. */
3133 add_line_to_sigset (const char *line
, sigset_t
*sigs
)
3135 int len
= strlen (line
) - 1;
3139 if (line
[len
] != '\n')
3140 error (_("Could not parse signal set: %s"), line
);
3148 if (*p
>= '0' && *p
<= '9')
3150 else if (*p
>= 'a' && *p
<= 'f')
3151 digit
= *p
- 'a' + 10;
3153 error (_("Could not parse signal set: %s"), line
);
3158 sigaddset (sigs
, signum
+ 1);
3160 sigaddset (sigs
, signum
+ 2);
3162 sigaddset (sigs
, signum
+ 3);
3164 sigaddset (sigs
, signum
+ 4);
3170 /* Find process PID's pending signals from /proc/pid/status and set
3174 linux_proc_pending_signals (int pid
, sigset_t
*pending
, sigset_t
*blocked
, sigset_t
*ignored
)
3177 char buffer
[MAXPATHLEN
], fname
[MAXPATHLEN
];
3180 sigemptyset (pending
);
3181 sigemptyset (blocked
);
3182 sigemptyset (ignored
);
3183 sprintf (fname
, "/proc/%d/status", pid
);
3184 procfile
= fopen (fname
, "r");
3185 if (procfile
== NULL
)
3186 error (_("Could not open %s"), fname
);
3188 while (fgets (buffer
, MAXPATHLEN
, procfile
) != NULL
)
3190 /* Normal queued signals are on the SigPnd line in the status
3191 file. However, 2.6 kernels also have a "shared" pending
3192 queue for delivering signals to a thread group, so check for
3195 Unfortunately some Red Hat kernels include the shared pending
3196 queue but not the ShdPnd status field. */
3198 if (strncmp (buffer
, "SigPnd:\t", 8) == 0)
3199 add_line_to_sigset (buffer
+ 8, pending
);
3200 else if (strncmp (buffer
, "ShdPnd:\t", 8) == 0)
3201 add_line_to_sigset (buffer
+ 8, pending
);
3202 else if (strncmp (buffer
, "SigBlk:\t", 8) == 0)
3203 add_line_to_sigset (buffer
+ 8, blocked
);
3204 else if (strncmp (buffer
, "SigIgn:\t", 8) == 0)
3205 add_line_to_sigset (buffer
+ 8, ignored
);
3212 linux_xfer_partial (struct target_ops
*ops
, enum target_object object
,
3213 const char *annex
, gdb_byte
*readbuf
,
3214 const gdb_byte
*writebuf
, ULONGEST offset
, LONGEST len
)
3218 if (object
== TARGET_OBJECT_AUXV
)
3219 return procfs_xfer_auxv (ops
, object
, annex
, readbuf
, writebuf
,
3222 xfer
= linux_proc_xfer_partial (ops
, object
, annex
, readbuf
, writebuf
,
3227 return super_xfer_partial (ops
, object
, annex
, readbuf
, writebuf
,
3231 /* Create a prototype generic GNU/Linux target. The client can override
3232 it with local methods. */
3235 linux_target_install_ops (struct target_ops
*t
)
3237 t
->to_insert_fork_catchpoint
= linux_child_insert_fork_catchpoint
;
3238 t
->to_insert_vfork_catchpoint
= linux_child_insert_vfork_catchpoint
;
3239 t
->to_insert_exec_catchpoint
= linux_child_insert_exec_catchpoint
;
3240 t
->to_pid_to_exec_file
= linux_child_pid_to_exec_file
;
3241 t
->to_post_startup_inferior
= linux_child_post_startup_inferior
;
3242 t
->to_post_attach
= linux_child_post_attach
;
3243 t
->to_follow_fork
= linux_child_follow_fork
;
3244 t
->to_find_memory_regions
= linux_nat_find_memory_regions
;
3245 t
->to_make_corefile_notes
= linux_nat_make_corefile_notes
;
3247 super_xfer_partial
= t
->to_xfer_partial
;
3248 t
->to_xfer_partial
= linux_xfer_partial
;
3254 struct target_ops
*t
;
3256 t
= inf_ptrace_target ();
3257 linux_target_install_ops (t
);
3263 linux_trad_target (CORE_ADDR (*register_u_offset
)(struct gdbarch
*, int, int))
3265 struct target_ops
*t
;
3267 t
= inf_ptrace_trad_target (register_u_offset
);
3268 linux_target_install_ops (t
);
3274 linux_nat_add_target (struct target_ops
*t
)
3276 /* Save the provided single-threaded target. We save this in a separate
3277 variable because another target we've inherited from (e.g. inf-ptrace)
3278 may have saved a pointer to T; we want to use it for the final
3279 process stratum target. */
3280 linux_ops_saved
= *t
;
3281 linux_ops
= &linux_ops_saved
;
3283 /* Override some methods for multithreading. */
3284 t
->to_attach
= linux_nat_attach
;
3285 t
->to_detach
= linux_nat_detach
;
3286 t
->to_resume
= linux_nat_resume
;
3287 t
->to_wait
= linux_nat_wait
;
3288 t
->to_xfer_partial
= linux_nat_xfer_partial
;
3289 t
->to_kill
= linux_nat_kill
;
3290 t
->to_mourn_inferior
= linux_nat_mourn_inferior
;
3291 t
->to_thread_alive
= linux_nat_thread_alive
;
3292 t
->to_pid_to_str
= linux_nat_pid_to_str
;
3293 t
->to_has_thread_control
= tc_schedlock
;
3295 /* We don't change the stratum; this target will sit at
3296 process_stratum and thread_db will set at thread_stratum. This
3297 is a little strange, since this is a multi-threaded-capable
3298 target, but we want to be on the stack below thread_db, and we
3299 also want to be used for single-threaded processes. */
3303 /* TODO: Eliminate this and have libthread_db use
3304 find_target_beneath. */
3308 /* Register a method to call whenever a new thread is attached. */
3310 linux_nat_set_new_thread (struct target_ops
*t
, void (*new_thread
) (ptid_t
))
3312 /* Save the pointer. We only support a single registered instance
3313 of the GNU/Linux native target, so we do not need to map this to
3315 linux_nat_new_thread
= new_thread
;
3318 /* Return the saved siginfo associated with PTID. */
3320 linux_nat_get_siginfo (ptid_t ptid
)
3322 struct lwp_info
*lp
= find_lwp_pid (ptid
);
3324 gdb_assert (lp
!= NULL
);
3326 return &lp
->siginfo
;
3330 _initialize_linux_nat (void)
3332 struct sigaction action
;
3334 add_info ("proc", linux_nat_info_proc_cmd
, _("\
3335 Show /proc process information about any running process.\n\
3336 Specify any process id, or use the program being debugged by default.\n\
3337 Specify any of the following keywords for detailed info:\n\
3338 mappings -- list of mapped memory regions.\n\
3339 stat -- list a bunch of random process info.\n\
3340 status -- list a different bunch of random process info.\n\
3341 all -- list all available /proc info."));
3343 /* Save the original signal mask. */
3344 sigprocmask (SIG_SETMASK
, NULL
, &normal_mask
);
3346 action
.sa_handler
= sigchld_handler
;
3347 sigemptyset (&action
.sa_mask
);
3348 action
.sa_flags
= SA_RESTART
;
3349 sigaction (SIGCHLD
, &action
, NULL
);
3351 /* Make sure we don't block SIGCHLD during a sigsuspend. */
3352 sigprocmask (SIG_SETMASK
, NULL
, &suspend_mask
);
3353 sigdelset (&suspend_mask
, SIGCHLD
);
3355 sigemptyset (&blocked_mask
);
3357 add_setshow_zinteger_cmd ("lin-lwp", no_class
, &debug_linux_nat
, _("\
3358 Set debugging of GNU/Linux lwp module."), _("\
3359 Show debugging of GNU/Linux lwp module."), _("\
3360 Enables printf debugging output."),
3362 show_debug_linux_nat
,
3363 &setdebuglist
, &showdebuglist
);
3367 /* FIXME: kettenis/2000-08-26: The stuff on this page is specific to
3368 the GNU/Linux Threads library and therefore doesn't really belong
3371 /* Read variable NAME in the target and return its value if found.
3372 Otherwise return zero. It is assumed that the type of the variable
3376 get_signo (const char *name
)
3378 struct minimal_symbol
*ms
;
3381 ms
= lookup_minimal_symbol (name
, NULL
, NULL
);
3385 if (target_read_memory (SYMBOL_VALUE_ADDRESS (ms
), (gdb_byte
*) &signo
,
3386 sizeof (signo
)) != 0)
3392 /* Return the set of signals used by the threads library in *SET. */
3395 lin_thread_get_thread_signals (sigset_t
*set
)
3397 struct sigaction action
;
3398 int restart
, cancel
;
3402 restart
= get_signo ("__pthread_sig_restart");
3403 cancel
= get_signo ("__pthread_sig_cancel");
3405 /* LinuxThreads normally uses the first two RT signals, but in some legacy
3406 cases may use SIGUSR1/SIGUSR2. NPTL always uses RT signals, but does
3407 not provide any way for the debugger to query the signal numbers -
3408 fortunately they don't change! */
3411 restart
= __SIGRTMIN
;
3414 cancel
= __SIGRTMIN
+ 1;
3416 sigaddset (set
, restart
);
3417 sigaddset (set
, cancel
);
3419 /* The GNU/Linux Threads library makes terminating threads send a
3420 special "cancel" signal instead of SIGCHLD. Make sure we catch
3421 those (to prevent them from terminating GDB itself, which is
3422 likely to be their default action) and treat them the same way as
3425 action
.sa_handler
= sigchld_handler
;
3426 sigemptyset (&action
.sa_mask
);
3427 action
.sa_flags
= SA_RESTART
;
3428 sigaction (cancel
, &action
, NULL
);
3430 /* We block the "cancel" signal throughout this code ... */
3431 sigaddset (&blocked_mask
, cancel
);
3432 sigprocmask (SIG_BLOCK
, &blocked_mask
, NULL
);
3434 /* ... except during a sigsuspend. */
3435 sigdelset (&suspend_mask
, cancel
);