1 /* Low level interface to ptrace, for the remote server for GDB.
2 Copyright (C) 1995, 1996, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005,
3 2006, 2007, 2008 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/>. */
21 #include "linux-low.h"
25 #include <sys/param.h>
27 #include <sys/ptrace.h>
30 #include <sys/ioctl.h>
36 #include <sys/syscall.h>
39 #ifndef PTRACE_GETSIGINFO
40 # define PTRACE_GETSIGINFO 0x4202
41 # define PTRACE_SETSIGINFO 0x4203
48 /* If the system headers did not provide the constants, hard-code the normal
50 #ifndef PTRACE_EVENT_FORK
52 #define PTRACE_SETOPTIONS 0x4200
53 #define PTRACE_GETEVENTMSG 0x4201
55 /* options set using PTRACE_SETOPTIONS */
56 #define PTRACE_O_TRACESYSGOOD 0x00000001
57 #define PTRACE_O_TRACEFORK 0x00000002
58 #define PTRACE_O_TRACEVFORK 0x00000004
59 #define PTRACE_O_TRACECLONE 0x00000008
60 #define PTRACE_O_TRACEEXEC 0x00000010
61 #define PTRACE_O_TRACEVFORKDONE 0x00000020
62 #define PTRACE_O_TRACEEXIT 0x00000040
64 /* Wait extended result codes for the above trace options. */
65 #define PTRACE_EVENT_FORK 1
66 #define PTRACE_EVENT_VFORK 2
67 #define PTRACE_EVENT_CLONE 3
68 #define PTRACE_EVENT_EXEC 4
69 #define PTRACE_EVENT_VFORK_DONE 5
70 #define PTRACE_EVENT_EXIT 6
72 #endif /* PTRACE_EVENT_FORK */
74 /* We can't always assume that this flag is available, but all systems
75 with the ptrace event handlers also have __WALL, so it's safe to use
78 #define __WALL 0x40000000 /* Wait for any child. */
82 #if !(defined(__UCLIBC_HAS_MMU__) || defined(__ARCH_HAS_MMU__))
87 /* ``all_threads'' is keyed by the LWP ID, which we use as the GDB protocol
88 representation of the thread ID.
90 ``all_processes'' is keyed by the process ID - which on Linux is (presently)
91 the same as the LWP ID. */
93 struct inferior_list all_processes
;
95 /* A list of all unknown processes which receive stop signals. Some other
96 process will presumably claim each of these as forked children
99 struct inferior_list stopped_pids
;
101 /* FIXME this is a bit of a hack, and could be removed. */
102 int stopping_threads
;
104 /* FIXME make into a target method? */
105 int using_threads
= 1;
106 static int thread_db_active
;
108 static int must_set_ptrace_flags
;
110 static void linux_resume_one_process (struct inferior_list_entry
*entry
,
111 int step
, int signal
, siginfo_t
*info
);
112 static void linux_resume (struct thread_resume
*resume_info
);
113 static void stop_all_processes (void);
114 static int linux_wait_for_event (struct thread_info
*child
);
115 static int check_removed_breakpoint (struct process_info
*event_child
);
116 static void *add_process (unsigned long pid
);
118 struct pending_signals
122 struct pending_signals
*prev
;
125 #define PTRACE_ARG3_TYPE long
126 #define PTRACE_XFER_TYPE long
128 #ifdef HAVE_LINUX_REGSETS
129 static int use_regsets_p
= 1;
132 #define pid_of(proc) ((proc)->head.id)
134 /* FIXME: Delete eventually. */
135 #define inferior_pid (pid_of (get_thread_process (current_inferior)))
138 handle_extended_wait (struct process_info
*event_child
, int wstat
)
140 int event
= wstat
>> 16;
141 struct process_info
*new_process
;
143 if (event
== PTRACE_EVENT_CLONE
)
145 unsigned long new_pid
;
148 ptrace (PTRACE_GETEVENTMSG
, inferior_pid
, 0, &new_pid
);
150 /* If we haven't already seen the new PID stop, wait for it now. */
151 if (! pull_pid_from_list (&stopped_pids
, new_pid
))
153 /* The new child has a pending SIGSTOP. We can't affect it until it
154 hits the SIGSTOP, but we're already attached. */
157 ret
= waitpid (new_pid
, &status
, __WALL
);
158 } while (ret
== -1 && errno
== EINTR
);
161 perror_with_name ("waiting for new child");
162 else if (ret
!= new_pid
)
163 warning ("wait returned unexpected PID %d", ret
);
164 else if (!WIFSTOPPED (status
))
165 warning ("wait returned unexpected status 0x%x", status
);
168 ptrace (PTRACE_SETOPTIONS
, new_pid
, 0, PTRACE_O_TRACECLONE
);
170 new_process
= (struct process_info
*) add_process (new_pid
);
171 add_thread (new_pid
, new_process
, new_pid
);
172 new_thread_notify (thread_id_to_gdb_id (new_process
->lwpid
));
174 /* Normally we will get the pending SIGSTOP. But in some cases
175 we might get another signal delivered to the group first.
176 If we do, be sure not to lose it. */
177 if (WSTOPSIG (status
) == SIGSTOP
)
179 if (stopping_threads
)
180 new_process
->stopped
= 1;
182 ptrace (PTRACE_CONT
, new_pid
, 0, 0);
186 new_process
->stop_expected
= 1;
187 if (stopping_threads
)
189 new_process
->stopped
= 1;
190 new_process
->status_pending_p
= 1;
191 new_process
->status_pending
= status
;
194 /* Pass the signal on. This is what GDB does - except
195 shouldn't we really report it instead? */
196 ptrace (PTRACE_CONT
, new_pid
, 0, WSTOPSIG (status
));
199 /* Always resume the current thread. If we are stopping
200 threads, it will have a pending SIGSTOP; we may as well
202 linux_resume_one_process (&event_child
->head
,
203 event_child
->stepping
, 0, NULL
);
207 /* This function should only be called if the process got a SIGTRAP.
208 The SIGTRAP could mean several things.
210 On i386, where decr_pc_after_break is non-zero:
211 If we were single-stepping this process using PTRACE_SINGLESTEP,
212 we will get only the one SIGTRAP (even if the instruction we
213 stepped over was a breakpoint). The value of $eip will be the
215 If we continue the process using PTRACE_CONT, we will get a
216 SIGTRAP when we hit a breakpoint. The value of $eip will be
217 the instruction after the breakpoint (i.e. needs to be
218 decremented). If we report the SIGTRAP to GDB, we must also
219 report the undecremented PC. If we cancel the SIGTRAP, we
220 must resume at the decremented PC.
222 (Presumably, not yet tested) On a non-decr_pc_after_break machine
223 with hardware or kernel single-step:
224 If we single-step over a breakpoint instruction, our PC will
225 point at the following instruction. If we continue and hit a
226 breakpoint instruction, our PC will point at the breakpoint
232 CORE_ADDR stop_pc
= (*the_low_target
.get_pc
) ();
234 if (get_thread_process (current_inferior
)->stepping
)
237 return stop_pc
- the_low_target
.decr_pc_after_break
;
241 add_process (unsigned long pid
)
243 struct process_info
*process
;
245 process
= (struct process_info
*) malloc (sizeof (*process
));
246 memset (process
, 0, sizeof (*process
));
248 process
->head
.id
= pid
;
249 process
->lwpid
= pid
;
251 add_inferior_to_list (&all_processes
, &process
->head
);
256 /* Start an inferior process and returns its pid.
257 ALLARGS is a vector of program-name and args. */
260 linux_create_inferior (char *program
, char **allargs
)
265 #if defined(__UCLIBC__) && defined(HAS_NOMMU)
271 perror_with_name ("fork");
275 ptrace (PTRACE_TRACEME
, 0, 0, 0);
277 signal (__SIGRTMIN
+ 1, SIG_DFL
);
281 execv (program
, allargs
);
283 execvp (program
, allargs
);
285 fprintf (stderr
, "Cannot exec %s: %s.\n", program
,
291 new_process
= add_process (pid
);
292 add_thread (pid
, new_process
, pid
);
293 must_set_ptrace_flags
= 1;
298 /* Attach to an inferior process. */
301 linux_attach_lwp (unsigned long pid
)
303 struct process_info
*new_process
;
305 if (ptrace (PTRACE_ATTACH
, pid
, 0, 0) != 0)
307 if (all_threads
.head
!= NULL
)
309 /* If we fail to attach to an LWP, just warn. */
310 fprintf (stderr
, "Cannot attach to process %ld: %s (%d)\n", pid
,
311 strerror (errno
), errno
);
316 /* If we fail to attach to a process, report an error. */
317 error ("Cannot attach to process %ld: %s (%d)\n", pid
,
318 strerror (errno
), errno
);
321 ptrace (PTRACE_SETOPTIONS
, pid
, 0, PTRACE_O_TRACECLONE
);
323 new_process
= (struct process_info
*) add_process (pid
);
324 add_thread (pid
, new_process
, pid
);
325 new_thread_notify (thread_id_to_gdb_id (new_process
->lwpid
));
327 /* The next time we wait for this LWP we'll see a SIGSTOP as PTRACE_ATTACH
328 brings it to a halt. We should ignore that SIGSTOP and resume the process
329 (unless this is the first process, in which case the flag will be cleared
332 On the other hand, if we are currently trying to stop all threads, we
333 should treat the new thread as if we had sent it a SIGSTOP. This works
334 because we are guaranteed that add_process added us to the end of the
335 list, and so the new thread has not yet reached wait_for_sigstop (but
337 if (! stopping_threads
)
338 new_process
->stop_expected
= 1;
342 linux_attach (unsigned long pid
)
344 struct process_info
*process
;
346 linux_attach_lwp (pid
);
348 /* Don't ignore the initial SIGSTOP if we just attached to this process.
349 It will be collected by wait shortly. */
350 process
= (struct process_info
*) find_inferior_id (&all_processes
, pid
);
351 process
->stop_expected
= 0;
356 /* Kill the inferior process. Make us have no inferior. */
359 linux_kill_one_process (struct inferior_list_entry
*entry
)
361 struct thread_info
*thread
= (struct thread_info
*) entry
;
362 struct process_info
*process
= get_thread_process (thread
);
365 /* We avoid killing the first thread here, because of a Linux kernel (at
366 least 2.6.0-test7 through 2.6.8-rc4) bug; if we kill the parent before
367 the children get a chance to be reaped, it will remain a zombie
369 if (entry
== all_threads
.head
)
374 ptrace (PTRACE_KILL
, pid_of (process
), 0, 0);
376 /* Make sure it died. The loop is most likely unnecessary. */
377 wstat
= linux_wait_for_event (thread
);
378 } while (WIFSTOPPED (wstat
));
384 struct thread_info
*thread
= (struct thread_info
*) all_threads
.head
;
385 struct process_info
*process
;
391 for_each_inferior (&all_threads
, linux_kill_one_process
);
393 /* See the comment in linux_kill_one_process. We did not kill the first
394 thread in the list, so do so now. */
395 process
= get_thread_process (thread
);
398 ptrace (PTRACE_KILL
, pid_of (process
), 0, 0);
400 /* Make sure it died. The loop is most likely unnecessary. */
401 wstat
= linux_wait_for_event (thread
);
402 } while (WIFSTOPPED (wstat
));
405 free (all_processes
.head
);
406 all_processes
.head
= all_processes
.tail
= NULL
;
410 linux_detach_one_process (struct inferior_list_entry
*entry
)
412 struct thread_info
*thread
= (struct thread_info
*) entry
;
413 struct process_info
*process
= get_thread_process (thread
);
415 /* Make sure the process isn't stopped at a breakpoint that's
417 check_removed_breakpoint (process
);
419 /* If this process is stopped but is expecting a SIGSTOP, then make
420 sure we take care of that now. This isn't absolutely guaranteed
421 to collect the SIGSTOP, but is fairly likely to. */
422 if (process
->stop_expected
)
424 /* Clear stop_expected, so that the SIGSTOP will be reported. */
425 process
->stop_expected
= 0;
426 if (process
->stopped
)
427 linux_resume_one_process (&process
->head
, 0, 0, NULL
);
428 linux_wait_for_event (thread
);
431 /* Flush any pending changes to the process's registers. */
432 regcache_invalidate_one ((struct inferior_list_entry
*)
433 get_process_thread (process
));
435 /* Finally, let it resume. */
436 ptrace (PTRACE_DETACH
, pid_of (process
), 0, 0);
442 delete_all_breakpoints ();
443 for_each_inferior (&all_threads
, linux_detach_one_process
);
445 free (all_processes
.head
);
446 all_processes
.head
= all_processes
.tail
= NULL
;
453 extern unsigned long signal_pid
;
457 ret
= waitpid (signal_pid
, &status
, 0);
458 if (WIFEXITED (status
) || WIFSIGNALED (status
))
460 } while (ret
!= -1 || errno
!= ECHILD
);
463 /* Return nonzero if the given thread is still alive. */
465 linux_thread_alive (unsigned long lwpid
)
467 if (find_inferior_id (&all_threads
, lwpid
) != NULL
)
473 /* Return nonzero if this process stopped at a breakpoint which
474 no longer appears to be inserted. Also adjust the PC
475 appropriately to resume where the breakpoint used to be. */
477 check_removed_breakpoint (struct process_info
*event_child
)
480 struct thread_info
*saved_inferior
;
482 if (event_child
->pending_is_breakpoint
== 0)
486 fprintf (stderr
, "Checking for breakpoint in process %ld.\n",
489 saved_inferior
= current_inferior
;
490 current_inferior
= get_process_thread (event_child
);
492 stop_pc
= get_stop_pc ();
494 /* If the PC has changed since we stopped, then we shouldn't do
495 anything. This happens if, for instance, GDB handled the
496 decr_pc_after_break subtraction itself. */
497 if (stop_pc
!= event_child
->pending_stop_pc
)
500 fprintf (stderr
, "Ignoring, PC was changed. Old PC was 0x%08llx\n",
501 event_child
->pending_stop_pc
);
503 event_child
->pending_is_breakpoint
= 0;
504 current_inferior
= saved_inferior
;
508 /* If the breakpoint is still there, we will report hitting it. */
509 if ((*the_low_target
.breakpoint_at
) (stop_pc
))
512 fprintf (stderr
, "Ignoring, breakpoint is still present.\n");
513 current_inferior
= saved_inferior
;
518 fprintf (stderr
, "Removed breakpoint.\n");
520 /* For decr_pc_after_break targets, here is where we perform the
521 decrement. We go immediately from this function to resuming,
522 and can not safely call get_stop_pc () again. */
523 if (the_low_target
.set_pc
!= NULL
)
524 (*the_low_target
.set_pc
) (stop_pc
);
526 /* We consumed the pending SIGTRAP. */
527 event_child
->pending_is_breakpoint
= 0;
528 event_child
->status_pending_p
= 0;
529 event_child
->status_pending
= 0;
531 current_inferior
= saved_inferior
;
535 /* Return 1 if this process has an interesting status pending. This function
536 may silently resume an inferior process. */
538 status_pending_p (struct inferior_list_entry
*entry
, void *dummy
)
540 struct process_info
*process
= (struct process_info
*) entry
;
542 if (process
->status_pending_p
)
543 if (check_removed_breakpoint (process
))
545 /* This thread was stopped at a breakpoint, and the breakpoint
546 is now gone. We were told to continue (or step...) all threads,
547 so GDB isn't trying to single-step past this breakpoint.
548 So instead of reporting the old SIGTRAP, pretend we got to
549 the breakpoint just after it was removed instead of just
550 before; resume the process. */
551 linux_resume_one_process (&process
->head
, 0, 0, NULL
);
555 return process
->status_pending_p
;
559 linux_wait_for_process (struct process_info
**childp
, int *wstatp
)
562 int to_wait_for
= -1;
565 to_wait_for
= (*childp
)->lwpid
;
570 ret
= waitpid (to_wait_for
, wstatp
, WNOHANG
);
575 perror_with_name ("waitpid");
580 ret
= waitpid (to_wait_for
, wstatp
, WNOHANG
| __WCLONE
);
585 perror_with_name ("waitpid (WCLONE)");
594 && (!WIFSTOPPED (*wstatp
)
595 || (WSTOPSIG (*wstatp
) != 32
596 && WSTOPSIG (*wstatp
) != 33)))
597 fprintf (stderr
, "Got an event from %d (%x)\n", ret
, *wstatp
);
599 if (to_wait_for
== -1)
600 *childp
= (struct process_info
*) find_inferior_id (&all_processes
, ret
);
602 /* If we didn't find a process, one of two things presumably happened:
603 - A process we started and then detached from has exited. Ignore it.
604 - A process we are controlling has forked and the new child's stop
605 was reported to us by the kernel. Save its PID. */
606 if (*childp
== NULL
&& WIFSTOPPED (*wstatp
))
608 add_pid_to_list (&stopped_pids
, ret
);
611 else if (*childp
== NULL
)
614 (*childp
)->stopped
= 1;
615 (*childp
)->pending_is_breakpoint
= 0;
617 (*childp
)->last_status
= *wstatp
;
620 && WIFSTOPPED (*wstatp
))
622 current_inferior
= (struct thread_info
*)
623 find_inferior_id (&all_threads
, (*childp
)->lwpid
);
624 /* For testing only; i386_stop_pc prints out a diagnostic. */
625 if (the_low_target
.get_pc
!= NULL
)
631 linux_wait_for_event (struct thread_info
*child
)
634 struct process_info
*event_child
;
638 /* Check for a process with a pending status. */
639 /* It is possible that the user changed the pending task's registers since
640 it stopped. We correctly handle the change of PC if we hit a breakpoint
641 (in check_removed_breakpoint); signals should be reported anyway. */
644 event_child
= (struct process_info
*)
645 find_inferior (&all_processes
, status_pending_p
, NULL
);
646 if (debug_threads
&& event_child
)
647 fprintf (stderr
, "Got a pending child %ld\n", event_child
->lwpid
);
651 event_child
= get_thread_process (child
);
652 if (event_child
->status_pending_p
653 && check_removed_breakpoint (event_child
))
657 if (event_child
!= NULL
)
659 if (event_child
->status_pending_p
)
662 fprintf (stderr
, "Got an event from pending child %ld (%04x)\n",
663 event_child
->lwpid
, event_child
->status_pending
);
664 wstat
= event_child
->status_pending
;
665 event_child
->status_pending_p
= 0;
666 event_child
->status_pending
= 0;
667 current_inferior
= get_process_thread (event_child
);
672 /* We only enter this loop if no process has a pending wait status. Thus
673 any action taken in response to a wait status inside this loop is
674 responding as soon as we detect the status, not after any pending
681 event_child
= get_thread_process (child
);
683 linux_wait_for_process (&event_child
, &wstat
);
685 if (event_child
== NULL
)
686 error ("event from unknown child");
688 current_inferior
= (struct thread_info
*)
689 find_inferior_id (&all_threads
, event_child
->lwpid
);
691 /* Check for thread exit. */
692 if (! WIFSTOPPED (wstat
))
695 fprintf (stderr
, "LWP %ld exiting\n", event_child
->head
.id
);
697 /* If the last thread is exiting, just return. */
698 if (all_threads
.head
== all_threads
.tail
)
701 dead_thread_notify (thread_id_to_gdb_id (event_child
->lwpid
));
703 remove_inferior (&all_processes
, &event_child
->head
);
705 remove_thread (current_inferior
);
706 current_inferior
= (struct thread_info
*) all_threads
.head
;
708 /* If we were waiting for this particular child to do something...
709 well, it did something. */
713 /* Wait for a more interesting event. */
717 if (WIFSTOPPED (wstat
)
718 && WSTOPSIG (wstat
) == SIGSTOP
719 && event_child
->stop_expected
)
722 fprintf (stderr
, "Expected stop.\n");
723 event_child
->stop_expected
= 0;
724 linux_resume_one_process (&event_child
->head
,
725 event_child
->stepping
, 0, NULL
);
729 if (WIFSTOPPED (wstat
) && WSTOPSIG (wstat
) == SIGTRAP
732 handle_extended_wait (event_child
, wstat
);
736 /* If GDB is not interested in this signal, don't stop other
737 threads, and don't report it to GDB. Just resume the
738 inferior right away. We do this for threading-related
739 signals as well as any that GDB specifically requested we
740 ignore. But never ignore SIGSTOP if we sent it ourselves,
741 and do not ignore signals when stepping - they may require
742 special handling to skip the signal handler. */
743 /* FIXME drow/2002-06-09: Get signal numbers from the inferior's
745 if (WIFSTOPPED (wstat
)
746 && !event_child
->stepping
749 (thread_db_active
&& (WSTOPSIG (wstat
) == __SIGRTMIN
750 || WSTOPSIG (wstat
) == __SIGRTMIN
+ 1))
753 (pass_signals
[target_signal_from_host (WSTOPSIG (wstat
))]
754 && (WSTOPSIG (wstat
) != SIGSTOP
|| !stopping_threads
))))
756 siginfo_t info
, *info_p
;
759 fprintf (stderr
, "Ignored signal %d for LWP %ld.\n",
760 WSTOPSIG (wstat
), event_child
->head
.id
);
762 if (ptrace (PTRACE_GETSIGINFO
, event_child
->lwpid
, 0, &info
) == 0)
766 linux_resume_one_process (&event_child
->head
,
767 event_child
->stepping
,
768 WSTOPSIG (wstat
), info_p
);
772 /* If this event was not handled above, and is not a SIGTRAP, report
774 if (!WIFSTOPPED (wstat
) || WSTOPSIG (wstat
) != SIGTRAP
)
777 /* If this target does not support breakpoints, we simply report the
778 SIGTRAP; it's of no concern to us. */
779 if (the_low_target
.get_pc
== NULL
)
782 stop_pc
= get_stop_pc ();
784 /* bp_reinsert will only be set if we were single-stepping.
785 Notice that we will resume the process after hitting
786 a gdbserver breakpoint; single-stepping to/over one
787 is not supported (yet). */
788 if (event_child
->bp_reinsert
!= 0)
791 fprintf (stderr
, "Reinserted breakpoint.\n");
792 reinsert_breakpoint (event_child
->bp_reinsert
);
793 event_child
->bp_reinsert
= 0;
795 /* Clear the single-stepping flag and SIGTRAP as we resume. */
796 linux_resume_one_process (&event_child
->head
, 0, 0, NULL
);
800 bp_status
= check_breakpoints (stop_pc
);
805 fprintf (stderr
, "Hit a gdbserver breakpoint.\n");
807 /* We hit one of our own breakpoints. We mark it as a pending
808 breakpoint, so that check_removed_breakpoint () will do the PC
809 adjustment for us at the appropriate time. */
810 event_child
->pending_is_breakpoint
= 1;
811 event_child
->pending_stop_pc
= stop_pc
;
813 /* We may need to put the breakpoint back. We continue in the event
814 loop instead of simply replacing the breakpoint right away,
815 in order to not lose signals sent to the thread that hit the
816 breakpoint. Unfortunately this increases the window where another
817 thread could sneak past the removed breakpoint. For the current
818 use of server-side breakpoints (thread creation) this is
819 acceptable; but it needs to be considered before this breakpoint
820 mechanism can be used in more general ways. For some breakpoints
821 it may be necessary to stop all other threads, but that should
822 be avoided where possible.
824 If breakpoint_reinsert_addr is NULL, that means that we can
825 use PTRACE_SINGLESTEP on this platform. Uninsert the breakpoint,
826 mark it for reinsertion, and single-step.
828 Otherwise, call the target function to figure out where we need
829 our temporary breakpoint, create it, and continue executing this
832 /* No need to reinsert. */
833 linux_resume_one_process (&event_child
->head
, 0, 0, NULL
);
834 else if (the_low_target
.breakpoint_reinsert_addr
== NULL
)
836 event_child
->bp_reinsert
= stop_pc
;
837 uninsert_breakpoint (stop_pc
);
838 linux_resume_one_process (&event_child
->head
, 1, 0, NULL
);
842 reinsert_breakpoint_by_bp
843 (stop_pc
, (*the_low_target
.breakpoint_reinsert_addr
) ());
844 linux_resume_one_process (&event_child
->head
, 0, 0, NULL
);
851 fprintf (stderr
, "Hit a non-gdbserver breakpoint.\n");
853 /* If we were single-stepping, we definitely want to report the
854 SIGTRAP. The single-step operation has completed, so also
855 clear the stepping flag; in general this does not matter,
856 because the SIGTRAP will be reported to the client, which
857 will give us a new action for this thread, but clear it for
858 consistency anyway. It's safe to clear the stepping flag
859 because the only consumer of get_stop_pc () after this point
860 is check_removed_breakpoint, and pending_is_breakpoint is not
861 set. It might be wiser to use a step_completed flag instead. */
862 if (event_child
->stepping
)
864 event_child
->stepping
= 0;
868 /* A SIGTRAP that we can't explain. It may have been a breakpoint.
869 Check if it is a breakpoint, and if so mark the process information
870 accordingly. This will handle both the necessary fiddling with the
871 PC on decr_pc_after_break targets and suppressing extra threads
872 hitting a breakpoint if two hit it at once and then GDB removes it
873 after the first is reported. Arguably it would be better to report
874 multiple threads hitting breakpoints simultaneously, but the current
875 remote protocol does not allow this. */
876 if ((*the_low_target
.breakpoint_at
) (stop_pc
))
878 event_child
->pending_is_breakpoint
= 1;
879 event_child
->pending_stop_pc
= stop_pc
;
889 /* Wait for process, returns status. */
892 linux_wait (char *status
)
895 struct thread_info
*child
= NULL
;
898 /* If we were only supposed to resume one thread, only wait for
899 that thread - if it's still alive. If it died, however - which
900 can happen if we're coming from the thread death case below -
901 then we need to make sure we restart the other threads. We could
902 pick a thread at random or restart all; restarting all is less
904 if (cont_thread
!= 0 && cont_thread
!= -1)
906 child
= (struct thread_info
*) find_inferior_id (&all_threads
,
909 /* No stepping, no signal - unless one is pending already, of course. */
912 struct thread_resume resume_info
;
913 resume_info
.thread
= -1;
914 resume_info
.step
= resume_info
.sig
= resume_info
.leave_stopped
= 0;
915 linux_resume (&resume_info
);
919 w
= linux_wait_for_event (child
);
920 stop_all_processes ();
922 if (must_set_ptrace_flags
)
924 ptrace (PTRACE_SETOPTIONS
, inferior_pid
, 0, PTRACE_O_TRACECLONE
);
925 must_set_ptrace_flags
= 0;
928 /* If we are waiting for a particular child, and it exited,
929 linux_wait_for_event will return its exit status. Similarly if
930 the last child exited. If this is not the last child, however,
931 do not report it as exited until there is a 'thread exited' response
932 available in the remote protocol. Instead, just wait for another event.
933 This should be safe, because if the thread crashed we will already
934 have reported the termination signal to GDB; that should stop any
935 in-progress stepping operations, etc.
937 Report the exit status of the last thread to exit. This matches
938 LinuxThreads' behavior. */
940 if (all_threads
.head
== all_threads
.tail
)
944 fprintf (stderr
, "\nChild exited with retcode = %x \n", WEXITSTATUS (w
));
947 free (all_processes
.head
);
948 all_processes
.head
= all_processes
.tail
= NULL
;
949 return WEXITSTATUS (w
);
951 else if (!WIFSTOPPED (w
))
953 fprintf (stderr
, "\nChild terminated with signal = %x \n", WTERMSIG (w
));
956 free (all_processes
.head
);
957 all_processes
.head
= all_processes
.tail
= NULL
;
958 return target_signal_from_host (WTERMSIG (w
));
968 return target_signal_from_host (WSTOPSIG (w
));
971 /* Send a signal to an LWP. For LinuxThreads, kill is enough; however, if
972 thread groups are in use, we need to use tkill. */
975 kill_lwp (unsigned long lwpid
, int signo
)
977 static int tkill_failed
;
984 int ret
= syscall (SYS_tkill
, lwpid
, signo
);
992 return kill (lwpid
, signo
);
996 send_sigstop (struct inferior_list_entry
*entry
)
998 struct process_info
*process
= (struct process_info
*) entry
;
1000 if (process
->stopped
)
1003 /* If we already have a pending stop signal for this process, don't
1005 if (process
->stop_expected
)
1008 fprintf (stderr
, "Have pending sigstop for process %ld\n",
1011 /* We clear the stop_expected flag so that wait_for_sigstop
1012 will receive the SIGSTOP event (instead of silently resuming and
1013 waiting again). It'll be reset below. */
1014 process
->stop_expected
= 0;
1019 fprintf (stderr
, "Sending sigstop to process %ld\n", process
->head
.id
);
1021 kill_lwp (process
->head
.id
, SIGSTOP
);
1025 wait_for_sigstop (struct inferior_list_entry
*entry
)
1027 struct process_info
*process
= (struct process_info
*) entry
;
1028 struct thread_info
*saved_inferior
, *thread
;
1030 unsigned long saved_tid
;
1032 if (process
->stopped
)
1035 saved_inferior
= current_inferior
;
1036 saved_tid
= ((struct inferior_list_entry
*) saved_inferior
)->id
;
1037 thread
= (struct thread_info
*) find_inferior_id (&all_threads
,
1039 wstat
= linux_wait_for_event (thread
);
1041 /* If we stopped with a non-SIGSTOP signal, save it for later
1042 and record the pending SIGSTOP. If the process exited, just
1044 if (WIFSTOPPED (wstat
)
1045 && WSTOPSIG (wstat
) != SIGSTOP
)
1048 fprintf (stderr
, "LWP %ld stopped with non-sigstop status %06x\n",
1049 process
->lwpid
, wstat
);
1050 process
->status_pending_p
= 1;
1051 process
->status_pending
= wstat
;
1052 process
->stop_expected
= 1;
1055 if (linux_thread_alive (saved_tid
))
1056 current_inferior
= saved_inferior
;
1060 fprintf (stderr
, "Previously current thread died.\n");
1062 /* Set a valid thread as current. */
1063 set_desired_inferior (0);
1068 stop_all_processes (void)
1070 stopping_threads
= 1;
1071 for_each_inferior (&all_processes
, send_sigstop
);
1072 for_each_inferior (&all_processes
, wait_for_sigstop
);
1073 stopping_threads
= 0;
1076 /* Resume execution of the inferior process.
1077 If STEP is nonzero, single-step it.
1078 If SIGNAL is nonzero, give it that signal. */
1081 linux_resume_one_process (struct inferior_list_entry
*entry
,
1082 int step
, int signal
, siginfo_t
*info
)
1084 struct process_info
*process
= (struct process_info
*) entry
;
1085 struct thread_info
*saved_inferior
;
1087 if (process
->stopped
== 0)
1090 /* If we have pending signals or status, and a new signal, enqueue the
1091 signal. Also enqueue the signal if we are waiting to reinsert a
1092 breakpoint; it will be picked up again below. */
1094 && (process
->status_pending_p
|| process
->pending_signals
!= NULL
1095 || process
->bp_reinsert
!= 0))
1097 struct pending_signals
*p_sig
;
1098 p_sig
= malloc (sizeof (*p_sig
));
1099 p_sig
->prev
= process
->pending_signals
;
1100 p_sig
->signal
= signal
;
1102 memset (&p_sig
->info
, 0, sizeof (siginfo_t
));
1104 memcpy (&p_sig
->info
, info
, sizeof (siginfo_t
));
1105 process
->pending_signals
= p_sig
;
1108 if (process
->status_pending_p
&& !check_removed_breakpoint (process
))
1111 saved_inferior
= current_inferior
;
1112 current_inferior
= get_process_thread (process
);
1115 fprintf (stderr
, "Resuming process %ld (%s, signal %d, stop %s)\n", inferior_pid
,
1116 step
? "step" : "continue", signal
,
1117 process
->stop_expected
? "expected" : "not expected");
1119 /* This bit needs some thinking about. If we get a signal that
1120 we must report while a single-step reinsert is still pending,
1121 we often end up resuming the thread. It might be better to
1122 (ew) allow a stack of pending events; then we could be sure that
1123 the reinsert happened right away and not lose any signals.
1125 Making this stack would also shrink the window in which breakpoints are
1126 uninserted (see comment in linux_wait_for_process) but not enough for
1127 complete correctness, so it won't solve that problem. It may be
1128 worthwhile just to solve this one, however. */
1129 if (process
->bp_reinsert
!= 0)
1132 fprintf (stderr
, " pending reinsert at %08lx", (long)process
->bp_reinsert
);
1134 fprintf (stderr
, "BAD - reinserting but not stepping.\n");
1137 /* Postpone any pending signal. It was enqueued above. */
1141 check_removed_breakpoint (process
);
1143 if (debug_threads
&& the_low_target
.get_pc
!= NULL
)
1145 fprintf (stderr
, " ");
1146 (*the_low_target
.get_pc
) ();
1149 /* If we have pending signals, consume one unless we are trying to reinsert
1151 if (process
->pending_signals
!= NULL
&& process
->bp_reinsert
== 0)
1153 struct pending_signals
**p_sig
;
1155 p_sig
= &process
->pending_signals
;
1156 while ((*p_sig
)->prev
!= NULL
)
1157 p_sig
= &(*p_sig
)->prev
;
1159 signal
= (*p_sig
)->signal
;
1160 if ((*p_sig
)->info
.si_signo
!= 0)
1161 ptrace (PTRACE_SETSIGINFO
, process
->lwpid
, 0, &(*p_sig
)->info
);
1167 regcache_invalidate_one ((struct inferior_list_entry
*)
1168 get_process_thread (process
));
1170 process
->stopped
= 0;
1171 process
->stepping
= step
;
1172 ptrace (step
? PTRACE_SINGLESTEP
: PTRACE_CONT
, process
->lwpid
, 0, signal
);
1174 current_inferior
= saved_inferior
;
1176 perror_with_name ("ptrace");
1179 static struct thread_resume
*resume_ptr
;
1181 /* This function is called once per thread. We look up the thread
1182 in RESUME_PTR, and mark the thread with a pointer to the appropriate
1185 This algorithm is O(threads * resume elements), but resume elements
1186 is small (and will remain small at least until GDB supports thread
1189 linux_set_resume_request (struct inferior_list_entry
*entry
)
1191 struct process_info
*process
;
1192 struct thread_info
*thread
;
1195 thread
= (struct thread_info
*) entry
;
1196 process
= get_thread_process (thread
);
1199 while (resume_ptr
[ndx
].thread
!= -1 && resume_ptr
[ndx
].thread
!= entry
->id
)
1202 process
->resume
= &resume_ptr
[ndx
];
1205 /* This function is called once per thread. We check the thread's resume
1206 request, which will tell us whether to resume, step, or leave the thread
1207 stopped; and what signal, if any, it should be sent. For threads which
1208 we aren't explicitly told otherwise, we preserve the stepping flag; this
1209 is used for stepping over gdbserver-placed breakpoints. */
1212 linux_continue_one_thread (struct inferior_list_entry
*entry
)
1214 struct process_info
*process
;
1215 struct thread_info
*thread
;
1218 thread
= (struct thread_info
*) entry
;
1219 process
= get_thread_process (thread
);
1221 if (process
->resume
->leave_stopped
)
1224 if (process
->resume
->thread
== -1)
1225 step
= process
->stepping
|| process
->resume
->step
;
1227 step
= process
->resume
->step
;
1229 linux_resume_one_process (&process
->head
, step
, process
->resume
->sig
, NULL
);
1231 process
->resume
= NULL
;
1234 /* This function is called once per thread. We check the thread's resume
1235 request, which will tell us whether to resume, step, or leave the thread
1236 stopped; and what signal, if any, it should be sent. We queue any needed
1237 signals, since we won't actually resume. We already have a pending event
1238 to report, so we don't need to preserve any step requests; they should
1239 be re-issued if necessary. */
1242 linux_queue_one_thread (struct inferior_list_entry
*entry
)
1244 struct process_info
*process
;
1245 struct thread_info
*thread
;
1247 thread
= (struct thread_info
*) entry
;
1248 process
= get_thread_process (thread
);
1250 if (process
->resume
->leave_stopped
)
1253 /* If we have a new signal, enqueue the signal. */
1254 if (process
->resume
->sig
!= 0)
1256 struct pending_signals
*p_sig
;
1257 p_sig
= malloc (sizeof (*p_sig
));
1258 p_sig
->prev
= process
->pending_signals
;
1259 p_sig
->signal
= process
->resume
->sig
;
1260 memset (&p_sig
->info
, 0, sizeof (siginfo_t
));
1262 /* If this is the same signal we were previously stopped by,
1263 make sure to queue its siginfo. We can ignore the return
1264 value of ptrace; if it fails, we'll skip
1265 PTRACE_SETSIGINFO. */
1266 if (WIFSTOPPED (process
->last_status
)
1267 && WSTOPSIG (process
->last_status
) == process
->resume
->sig
)
1268 ptrace (PTRACE_GETSIGINFO
, process
->lwpid
, 0, &p_sig
->info
);
1270 process
->pending_signals
= p_sig
;
1273 process
->resume
= NULL
;
1276 /* Set DUMMY if this process has an interesting status pending. */
1278 resume_status_pending_p (struct inferior_list_entry
*entry
, void *flag_p
)
1280 struct process_info
*process
= (struct process_info
*) entry
;
1282 /* Processes which will not be resumed are not interesting, because
1283 we might not wait for them next time through linux_wait. */
1284 if (process
->resume
->leave_stopped
)
1287 /* If this thread has a removed breakpoint, we won't have any
1288 events to report later, so check now. check_removed_breakpoint
1289 may clear status_pending_p. We avoid calling check_removed_breakpoint
1290 for any thread that we are not otherwise going to resume - this
1291 lets us preserve stopped status when two threads hit a breakpoint.
1292 GDB removes the breakpoint to single-step a particular thread
1293 past it, then re-inserts it and resumes all threads. We want
1294 to report the second thread without resuming it in the interim. */
1295 if (process
->status_pending_p
)
1296 check_removed_breakpoint (process
);
1298 if (process
->status_pending_p
)
1299 * (int *) flag_p
= 1;
1305 linux_resume (struct thread_resume
*resume_info
)
1309 /* Yes, the use of a global here is rather ugly. */
1310 resume_ptr
= resume_info
;
1312 for_each_inferior (&all_threads
, linux_set_resume_request
);
1314 /* If there is a thread which would otherwise be resumed, which
1315 has a pending status, then don't resume any threads - we can just
1316 report the pending status. Make sure to queue any signals
1317 that would otherwise be sent. */
1319 find_inferior (&all_processes
, resume_status_pending_p
, &pending_flag
);
1324 fprintf (stderr
, "Not resuming, pending status\n");
1326 fprintf (stderr
, "Resuming, no pending status\n");
1330 for_each_inferior (&all_threads
, linux_queue_one_thread
);
1332 for_each_inferior (&all_threads
, linux_continue_one_thread
);
1335 #ifdef HAVE_LINUX_USRREGS
1338 register_addr (int regnum
)
1342 if (regnum
< 0 || regnum
>= the_low_target
.num_regs
)
1343 error ("Invalid register number %d.", regnum
);
1345 addr
= the_low_target
.regmap
[regnum
];
1350 /* Fetch one register. */
1352 fetch_register (int regno
)
1358 if (regno
>= the_low_target
.num_regs
)
1360 if ((*the_low_target
.cannot_fetch_register
) (regno
))
1363 regaddr
= register_addr (regno
);
1366 size
= (register_size (regno
) + sizeof (PTRACE_XFER_TYPE
) - 1)
1367 & - sizeof (PTRACE_XFER_TYPE
);
1368 buf
= alloca (size
);
1369 for (i
= 0; i
< size
; i
+= sizeof (PTRACE_XFER_TYPE
))
1372 *(PTRACE_XFER_TYPE
*) (buf
+ i
) =
1373 ptrace (PTRACE_PEEKUSER
, inferior_pid
, (PTRACE_ARG3_TYPE
) regaddr
, 0);
1374 regaddr
+= sizeof (PTRACE_XFER_TYPE
);
1377 /* Warning, not error, in case we are attached; sometimes the
1378 kernel doesn't let us at the registers. */
1379 char *err
= strerror (errno
);
1380 char *msg
= alloca (strlen (err
) + 128);
1381 sprintf (msg
, "reading register %d: %s", regno
, err
);
1386 if (the_low_target
.left_pad_xfer
1387 && register_size (regno
) < sizeof (PTRACE_XFER_TYPE
))
1388 supply_register (regno
, (buf
+ sizeof (PTRACE_XFER_TYPE
)
1389 - register_size (regno
)));
1391 supply_register (regno
, buf
);
1396 /* Fetch all registers, or just one, from the child process. */
1398 usr_fetch_inferior_registers (int regno
)
1400 if (regno
== -1 || regno
== 0)
1401 for (regno
= 0; regno
< the_low_target
.num_regs
; regno
++)
1402 fetch_register (regno
);
1404 fetch_register (regno
);
1407 /* Store our register values back into the inferior.
1408 If REGNO is -1, do this for all registers.
1409 Otherwise, REGNO specifies which register (so we can save time). */
1411 usr_store_inferior_registers (int regno
)
1419 if (regno
>= the_low_target
.num_regs
)
1422 if ((*the_low_target
.cannot_store_register
) (regno
) == 1)
1425 regaddr
= register_addr (regno
);
1429 size
= (register_size (regno
) + sizeof (PTRACE_XFER_TYPE
) - 1)
1430 & - sizeof (PTRACE_XFER_TYPE
);
1431 buf
= alloca (size
);
1432 memset (buf
, 0, size
);
1433 if (the_low_target
.left_pad_xfer
1434 && register_size (regno
) < sizeof (PTRACE_XFER_TYPE
))
1435 collect_register (regno
, (buf
+ sizeof (PTRACE_XFER_TYPE
)
1436 - register_size (regno
)));
1438 collect_register (regno
, buf
);
1439 for (i
= 0; i
< size
; i
+= sizeof (PTRACE_XFER_TYPE
))
1442 ptrace (PTRACE_POKEUSER
, inferior_pid
, (PTRACE_ARG3_TYPE
) regaddr
,
1443 *(PTRACE_XFER_TYPE
*) (buf
+ i
));
1446 if ((*the_low_target
.cannot_store_register
) (regno
) == 0)
1448 char *err
= strerror (errno
);
1449 char *msg
= alloca (strlen (err
) + 128);
1450 sprintf (msg
, "writing register %d: %s",
1456 regaddr
+= sizeof (PTRACE_XFER_TYPE
);
1460 for (regno
= 0; regno
< the_low_target
.num_regs
; regno
++)
1461 usr_store_inferior_registers (regno
);
1463 #endif /* HAVE_LINUX_USRREGS */
1467 #ifdef HAVE_LINUX_REGSETS
1470 regsets_fetch_inferior_registers ()
1472 struct regset_info
*regset
;
1473 int saw_general_regs
= 0;
1475 regset
= target_regsets
;
1477 while (regset
->size
>= 0)
1482 if (regset
->size
== 0)
1488 buf
= malloc (regset
->size
);
1489 res
= ptrace (regset
->get_request
, inferior_pid
, 0, buf
);
1494 /* If we get EIO on the first regset, do not try regsets again.
1495 If we get EIO on a later regset, disable that regset. */
1496 if (regset
== target_regsets
)
1510 sprintf (s
, "ptrace(regsets_fetch_inferior_registers) PID=%ld",
1515 else if (regset
->type
== GENERAL_REGS
)
1516 saw_general_regs
= 1;
1517 regset
->store_function (buf
);
1520 if (saw_general_regs
)
1527 regsets_store_inferior_registers ()
1529 struct regset_info
*regset
;
1530 int saw_general_regs
= 0;
1532 regset
= target_regsets
;
1534 while (regset
->size
>= 0)
1539 if (regset
->size
== 0)
1545 buf
= malloc (regset
->size
);
1547 /* First fill the buffer with the current register set contents,
1548 in case there are any items in the kernel's regset that are
1549 not in gdbserver's regcache. */
1550 res
= ptrace (regset
->get_request
, inferior_pid
, 0, buf
);
1554 /* Then overlay our cached registers on that. */
1555 regset
->fill_function (buf
);
1557 /* Only now do we write the register set. */
1558 res
= ptrace (regset
->set_request
, inferior_pid
, 0, buf
);
1565 /* If we get EIO on the first regset, do not try regsets again.
1566 If we get EIO on a later regset, disable that regset. */
1567 if (regset
== target_regsets
)
1580 perror ("Warning: ptrace(regsets_store_inferior_registers)");
1583 else if (regset
->type
== GENERAL_REGS
)
1584 saw_general_regs
= 1;
1588 if (saw_general_regs
)
1595 #endif /* HAVE_LINUX_REGSETS */
1599 linux_fetch_registers (int regno
)
1601 #ifdef HAVE_LINUX_REGSETS
1604 if (regsets_fetch_inferior_registers () == 0)
1608 #ifdef HAVE_LINUX_USRREGS
1609 usr_fetch_inferior_registers (regno
);
1614 linux_store_registers (int regno
)
1616 #ifdef HAVE_LINUX_REGSETS
1619 if (regsets_store_inferior_registers () == 0)
1623 #ifdef HAVE_LINUX_USRREGS
1624 usr_store_inferior_registers (regno
);
1629 /* Copy LEN bytes from inferior's memory starting at MEMADDR
1630 to debugger memory starting at MYADDR. */
1633 linux_read_memory (CORE_ADDR memaddr
, unsigned char *myaddr
, int len
)
1636 /* Round starting address down to longword boundary. */
1637 register CORE_ADDR addr
= memaddr
& -(CORE_ADDR
) sizeof (PTRACE_XFER_TYPE
);
1638 /* Round ending address up; get number of longwords that makes. */
1640 = (((memaddr
+ len
) - addr
) + sizeof (PTRACE_XFER_TYPE
) - 1)
1641 / sizeof (PTRACE_XFER_TYPE
);
1642 /* Allocate buffer of that many longwords. */
1643 register PTRACE_XFER_TYPE
*buffer
1644 = (PTRACE_XFER_TYPE
*) alloca (count
* sizeof (PTRACE_XFER_TYPE
));
1648 /* Try using /proc. Don't bother for one word. */
1649 if (len
>= 3 * sizeof (long))
1651 /* We could keep this file open and cache it - possibly one per
1652 thread. That requires some juggling, but is even faster. */
1653 sprintf (filename
, "/proc/%ld/mem", inferior_pid
);
1654 fd
= open (filename
, O_RDONLY
| O_LARGEFILE
);
1658 /* If pread64 is available, use it. It's faster if the kernel
1659 supports it (only one syscall), and it's 64-bit safe even on
1660 32-bit platforms (for instance, SPARC debugging a SPARC64
1663 if (pread64 (fd
, myaddr
, len
, memaddr
) != len
)
1665 if (lseek (fd
, memaddr
, SEEK_SET
) == -1 || read (fd
, memaddr
, len
) != len
)
1677 /* Read all the longwords */
1678 for (i
= 0; i
< count
; i
++, addr
+= sizeof (PTRACE_XFER_TYPE
))
1681 buffer
[i
] = ptrace (PTRACE_PEEKTEXT
, inferior_pid
, (PTRACE_ARG3_TYPE
) addr
, 0);
1686 /* Copy appropriate bytes out of the buffer. */
1687 memcpy (myaddr
, (char *) buffer
+ (memaddr
& (sizeof (PTRACE_XFER_TYPE
) - 1)), len
);
1692 /* Copy LEN bytes of data from debugger memory at MYADDR
1693 to inferior's memory at MEMADDR.
1694 On failure (cannot write the inferior)
1695 returns the value of errno. */
1698 linux_write_memory (CORE_ADDR memaddr
, const unsigned char *myaddr
, int len
)
1701 /* Round starting address down to longword boundary. */
1702 register CORE_ADDR addr
= memaddr
& -(CORE_ADDR
) sizeof (PTRACE_XFER_TYPE
);
1703 /* Round ending address up; get number of longwords that makes. */
1705 = (((memaddr
+ len
) - addr
) + sizeof (PTRACE_XFER_TYPE
) - 1) / sizeof (PTRACE_XFER_TYPE
);
1706 /* Allocate buffer of that many longwords. */
1707 register PTRACE_XFER_TYPE
*buffer
= (PTRACE_XFER_TYPE
*) alloca (count
* sizeof (PTRACE_XFER_TYPE
));
1712 fprintf (stderr
, "Writing %02x to %08lx\n", (unsigned)myaddr
[0], (long)memaddr
);
1715 /* Fill start and end extra bytes of buffer with existing memory data. */
1717 buffer
[0] = ptrace (PTRACE_PEEKTEXT
, inferior_pid
,
1718 (PTRACE_ARG3_TYPE
) addr
, 0);
1723 = ptrace (PTRACE_PEEKTEXT
, inferior_pid
,
1724 (PTRACE_ARG3_TYPE
) (addr
+ (count
- 1)
1725 * sizeof (PTRACE_XFER_TYPE
)),
1729 /* Copy data to be written over corresponding part of buffer */
1731 memcpy ((char *) buffer
+ (memaddr
& (sizeof (PTRACE_XFER_TYPE
) - 1)), myaddr
, len
);
1733 /* Write the entire buffer. */
1735 for (i
= 0; i
< count
; i
++, addr
+= sizeof (PTRACE_XFER_TYPE
))
1738 ptrace (PTRACE_POKETEXT
, inferior_pid
, (PTRACE_ARG3_TYPE
) addr
, buffer
[i
]);
1746 static int linux_supports_tracefork_flag
;
1748 /* Helper functions for linux_test_for_tracefork, called via clone (). */
1751 linux_tracefork_grandchild (void *arg
)
1756 #define STACK_SIZE 4096
1759 linux_tracefork_child (void *arg
)
1761 ptrace (PTRACE_TRACEME
, 0, 0, 0);
1762 kill (getpid (), SIGSTOP
);
1764 __clone2 (linux_tracefork_grandchild
, arg
, STACK_SIZE
,
1765 CLONE_VM
| SIGCHLD
, NULL
);
1767 clone (linux_tracefork_grandchild
, arg
+ STACK_SIZE
,
1768 CLONE_VM
| SIGCHLD
, NULL
);
1773 /* Wrapper function for waitpid which handles EINTR. */
1776 my_waitpid (int pid
, int *status
, int flags
)
1781 ret
= waitpid (pid
, status
, flags
);
1783 while (ret
== -1 && errno
== EINTR
);
1788 /* Determine if PTRACE_O_TRACEFORK can be used to follow fork events. Make
1789 sure that we can enable the option, and that it had the desired
1793 linux_test_for_tracefork (void)
1795 int child_pid
, ret
, status
;
1797 char *stack
= malloc (STACK_SIZE
* 4);
1799 linux_supports_tracefork_flag
= 0;
1801 /* Use CLONE_VM instead of fork, to support uClinux (no MMU). */
1803 child_pid
= __clone2 (linux_tracefork_child
, stack
, STACK_SIZE
,
1804 CLONE_VM
| SIGCHLD
, stack
+ STACK_SIZE
* 2);
1806 child_pid
= clone (linux_tracefork_child
, stack
+ STACK_SIZE
,
1807 CLONE_VM
| SIGCHLD
, stack
+ STACK_SIZE
* 2);
1809 if (child_pid
== -1)
1810 perror_with_name ("clone");
1812 ret
= my_waitpid (child_pid
, &status
, 0);
1814 perror_with_name ("waitpid");
1815 else if (ret
!= child_pid
)
1816 error ("linux_test_for_tracefork: waitpid: unexpected result %d.", ret
);
1817 if (! WIFSTOPPED (status
))
1818 error ("linux_test_for_tracefork: waitpid: unexpected status %d.", status
);
1820 ret
= ptrace (PTRACE_SETOPTIONS
, child_pid
, 0, PTRACE_O_TRACEFORK
);
1823 ret
= ptrace (PTRACE_KILL
, child_pid
, 0, 0);
1826 warning ("linux_test_for_tracefork: failed to kill child");
1830 ret
= my_waitpid (child_pid
, &status
, 0);
1831 if (ret
!= child_pid
)
1832 warning ("linux_test_for_tracefork: failed to wait for killed child");
1833 else if (!WIFSIGNALED (status
))
1834 warning ("linux_test_for_tracefork: unexpected wait status 0x%x from "
1835 "killed child", status
);
1840 ret
= ptrace (PTRACE_CONT
, child_pid
, 0, 0);
1842 warning ("linux_test_for_tracefork: failed to resume child");
1844 ret
= my_waitpid (child_pid
, &status
, 0);
1846 if (ret
== child_pid
&& WIFSTOPPED (status
)
1847 && status
>> 16 == PTRACE_EVENT_FORK
)
1850 ret
= ptrace (PTRACE_GETEVENTMSG
, child_pid
, 0, &second_pid
);
1851 if (ret
== 0 && second_pid
!= 0)
1855 linux_supports_tracefork_flag
= 1;
1856 my_waitpid (second_pid
, &second_status
, 0);
1857 ret
= ptrace (PTRACE_KILL
, second_pid
, 0, 0);
1859 warning ("linux_test_for_tracefork: failed to kill second child");
1860 my_waitpid (second_pid
, &status
, 0);
1864 warning ("linux_test_for_tracefork: unexpected result from waitpid "
1865 "(%d, status 0x%x)", ret
, status
);
1869 ret
= ptrace (PTRACE_KILL
, child_pid
, 0, 0);
1871 warning ("linux_test_for_tracefork: failed to kill child");
1872 my_waitpid (child_pid
, &status
, 0);
1874 while (WIFSTOPPED (status
));
1881 linux_look_up_symbols (void)
1883 #ifdef USE_THREAD_DB
1884 if (thread_db_active
)
1887 thread_db_active
= thread_db_init (!linux_supports_tracefork_flag
);
1892 linux_request_interrupt (void)
1894 extern unsigned long signal_pid
;
1896 if (cont_thread
!= 0 && cont_thread
!= -1)
1898 struct process_info
*process
;
1900 process
= get_thread_process (current_inferior
);
1901 kill_lwp (process
->lwpid
, SIGINT
);
1904 kill_lwp (signal_pid
, SIGINT
);
1907 /* Copy LEN bytes from inferior's auxiliary vector starting at OFFSET
1908 to debugger memory starting at MYADDR. */
1911 linux_read_auxv (CORE_ADDR offset
, unsigned char *myaddr
, unsigned int len
)
1913 char filename
[PATH_MAX
];
1916 snprintf (filename
, sizeof filename
, "/proc/%ld/auxv", inferior_pid
);
1918 fd
= open (filename
, O_RDONLY
);
1922 if (offset
!= (CORE_ADDR
) 0
1923 && lseek (fd
, (off_t
) offset
, SEEK_SET
) != (off_t
) offset
)
1926 n
= read (fd
, myaddr
, len
);
1933 /* These watchpoint related wrapper functions simply pass on the function call
1934 if the target has registered a corresponding function. */
1937 linux_insert_watchpoint (char type
, CORE_ADDR addr
, int len
)
1939 if (the_low_target
.insert_watchpoint
!= NULL
)
1940 return the_low_target
.insert_watchpoint (type
, addr
, len
);
1942 /* Unsupported (see target.h). */
1947 linux_remove_watchpoint (char type
, CORE_ADDR addr
, int len
)
1949 if (the_low_target
.remove_watchpoint
!= NULL
)
1950 return the_low_target
.remove_watchpoint (type
, addr
, len
);
1952 /* Unsupported (see target.h). */
1957 linux_stopped_by_watchpoint (void)
1959 if (the_low_target
.stopped_by_watchpoint
!= NULL
)
1960 return the_low_target
.stopped_by_watchpoint ();
1966 linux_stopped_data_address (void)
1968 if (the_low_target
.stopped_data_address
!= NULL
)
1969 return the_low_target
.stopped_data_address ();
1974 #if defined(__UCLIBC__) && defined(HAS_NOMMU)
1975 #if defined(__mcoldfire__)
1976 /* These should really be defined in the kernel's ptrace.h header. */
1977 #define PT_TEXT_ADDR 49*4
1978 #define PT_DATA_ADDR 50*4
1979 #define PT_TEXT_END_ADDR 51*4
1982 /* Under uClinux, programs are loaded at non-zero offsets, which we need
1983 to tell gdb about. */
1986 linux_read_offsets (CORE_ADDR
*text_p
, CORE_ADDR
*data_p
)
1988 #if defined(PT_TEXT_ADDR) && defined(PT_DATA_ADDR) && defined(PT_TEXT_END_ADDR)
1989 unsigned long text
, text_end
, data
;
1990 int pid
= get_thread_process (current_inferior
)->head
.id
;
1994 text
= ptrace (PTRACE_PEEKUSER
, pid
, (long)PT_TEXT_ADDR
, 0);
1995 text_end
= ptrace (PTRACE_PEEKUSER
, pid
, (long)PT_TEXT_END_ADDR
, 0);
1996 data
= ptrace (PTRACE_PEEKUSER
, pid
, (long)PT_DATA_ADDR
, 0);
2000 /* Both text and data offsets produced at compile-time (and so
2001 used by gdb) are relative to the beginning of the program,
2002 with the data segment immediately following the text segment.
2003 However, the actual runtime layout in memory may put the data
2004 somewhere else, so when we send gdb a data base-address, we
2005 use the real data base address and subtract the compile-time
2006 data base-address from it (which is just the length of the
2007 text segment). BSS immediately follows data in both
2010 *data_p
= data
- (text_end
- text
);
2020 linux_arch_string (void)
2022 return the_low_target
.arch_string
;
2025 static struct target_ops linux_target_ops
= {
2026 linux_create_inferior
,
2034 linux_fetch_registers
,
2035 linux_store_registers
,
2038 linux_look_up_symbols
,
2039 linux_request_interrupt
,
2041 linux_insert_watchpoint
,
2042 linux_remove_watchpoint
,
2043 linux_stopped_by_watchpoint
,
2044 linux_stopped_data_address
,
2045 #if defined(__UCLIBC__) && defined(HAS_NOMMU)
2050 #ifdef USE_THREAD_DB
2051 thread_db_get_tls_address
,
2057 hostio_last_error_from_errno
,
2061 linux_init_signals ()
2063 /* FIXME drow/2002-06-09: As above, we should check with LinuxThreads
2064 to find what the cancel signal actually is. */
2065 signal (__SIGRTMIN
+1, SIG_IGN
);
2069 initialize_low (void)
2071 thread_db_active
= 0;
2072 set_target_ops (&linux_target_ops
);
2073 set_breakpoint_data (the_low_target
.breakpoint
,
2074 the_low_target
.breakpoint_len
);
2075 the_low_target
.arch_setup ();
2076 linux_init_signals ();
2077 linux_test_for_tracefork ();