1 /* Low level interface to ptrace, for the remote server for GDB.
2 Copyright (C) 1995-1996, 1998-2012 Free Software Foundation, Inc.
4 This file is part of GDB.
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 3 of the License, or
9 (at your option) any later version.
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with this program. If not, see <http://www.gnu.org/licenses/>. */
20 #include "linux-low.h"
21 #include "linux-osdata.h"
26 #include <sys/param.h>
27 #include <sys/ptrace.h>
28 #include "linux-ptrace.h"
29 #include "linux-procfs.h"
31 #include <sys/ioctl.h>
37 #include <sys/syscall.h>
41 #include <sys/types.h>
47 /* Don't include <linux/elf.h> here. If it got included by gdb_proc_service.h
48 then ELFMAG0 will have been defined. If it didn't get included by
49 gdb_proc_service.h then including it will likely introduce a duplicate
50 definition of elf_fpregset_t. */
55 #define SPUFS_MAGIC 0x23c9b64e
58 #ifdef HAVE_PERSONALITY
59 # include <sys/personality.h>
60 # if !HAVE_DECL_ADDR_NO_RANDOMIZE
61 # define ADDR_NO_RANDOMIZE 0x0040000
70 #define W_STOPCODE(sig) ((sig) << 8 | 0x7f)
73 /* This is the kernel's hard limit. Not to be confused with
80 #if !(defined(__UCLIBC_HAS_MMU__) || defined(__ARCH_HAS_MMU__))
85 /* ``all_threads'' is keyed by the LWP ID, which we use as the GDB protocol
86 representation of the thread ID.
88 ``all_lwps'' is keyed by the process ID - which on Linux is (presently)
89 the same as the LWP ID.
91 ``all_processes'' is keyed by the "overall process ID", which
92 GNU/Linux calls tgid, "thread group ID". */
94 struct inferior_list all_lwps
;
96 /* A list of all unknown processes which receive stop signals. Some
97 other process will presumably claim each of these as forked
98 children momentarily. */
100 struct simple_pid_list
102 /* The process ID. */
105 /* The status as reported by waitpid. */
109 struct simple_pid_list
*next
;
111 struct simple_pid_list
*stopped_pids
;
113 /* Trivial list manipulation functions to keep track of a list of new
114 stopped processes. */
117 add_to_pid_list (struct simple_pid_list
**listp
, int pid
, int status
)
119 struct simple_pid_list
*new_pid
= xmalloc (sizeof (struct simple_pid_list
));
122 new_pid
->status
= status
;
123 new_pid
->next
= *listp
;
128 pull_pid_from_list (struct simple_pid_list
**listp
, int pid
, int *statusp
)
130 struct simple_pid_list
**p
;
132 for (p
= listp
; *p
!= NULL
; p
= &(*p
)->next
)
133 if ((*p
)->pid
== pid
)
135 struct simple_pid_list
*next
= (*p
)->next
;
137 *statusp
= (*p
)->status
;
145 /* FIXME this is a bit of a hack, and could be removed. */
146 int stopping_threads
;
148 /* FIXME make into a target method? */
149 int using_threads
= 1;
151 /* True if we're presently stabilizing threads (moving them out of
153 static int stabilizing_threads
;
155 /* This flag is true iff we've just created or attached to our first
156 inferior but it has not stopped yet. As soon as it does, we need
157 to call the low target's arch_setup callback. Doing this only on
158 the first inferior avoids reinializing the architecture on every
159 inferior, and avoids messing with the register caches of the
160 already running inferiors. NOTE: this assumes all inferiors under
161 control of gdbserver have the same architecture. */
162 static int new_inferior
;
164 static void linux_resume_one_lwp (struct lwp_info
*lwp
,
165 int step
, int signal
, siginfo_t
*info
);
166 static void linux_resume (struct thread_resume
*resume_info
, size_t n
);
167 static void stop_all_lwps (int suspend
, struct lwp_info
*except
);
168 static void unstop_all_lwps (int unsuspend
, struct lwp_info
*except
);
169 static int linux_wait_for_event (ptid_t ptid
, int *wstat
, int options
);
170 static void *add_lwp (ptid_t ptid
);
171 static int linux_stopped_by_watchpoint (void);
172 static void mark_lwp_dead (struct lwp_info
*lwp
, int wstat
);
173 static void proceed_all_lwps (void);
174 static int finish_step_over (struct lwp_info
*lwp
);
175 static CORE_ADDR
get_stop_pc (struct lwp_info
*lwp
);
176 static int kill_lwp (unsigned long lwpid
, int signo
);
177 static void linux_enable_event_reporting (int pid
);
179 /* True if the low target can hardware single-step. Such targets
180 don't need a BREAKPOINT_REINSERT_ADDR callback. */
183 can_hardware_single_step (void)
185 return (the_low_target
.breakpoint_reinsert_addr
== NULL
);
188 /* True if the low target supports memory breakpoints. If so, we'll
189 have a GET_PC implementation. */
192 supports_breakpoints (void)
194 return (the_low_target
.get_pc
!= NULL
);
197 /* Returns true if this target can support fast tracepoints. This
198 does not mean that the in-process agent has been loaded in the
202 supports_fast_tracepoints (void)
204 return the_low_target
.install_fast_tracepoint_jump_pad
!= NULL
;
207 struct pending_signals
211 struct pending_signals
*prev
;
214 #define PTRACE_ARG3_TYPE void *
215 #define PTRACE_ARG4_TYPE void *
216 #define PTRACE_XFER_TYPE long
218 #ifdef HAVE_LINUX_REGSETS
219 static char *disabled_regsets
;
220 static int num_regsets
;
223 /* The read/write ends of the pipe registered as waitable file in the
225 static int linux_event_pipe
[2] = { -1, -1 };
227 /* True if we're currently in async mode. */
228 #define target_is_async_p() (linux_event_pipe[0] != -1)
230 static void send_sigstop (struct lwp_info
*lwp
);
231 static void wait_for_sigstop (struct inferior_list_entry
*entry
);
233 /* Return non-zero if HEADER is a 64-bit ELF file. */
236 elf_64_header_p (const Elf64_Ehdr
*header
)
238 return (header
->e_ident
[EI_MAG0
] == ELFMAG0
239 && header
->e_ident
[EI_MAG1
] == ELFMAG1
240 && header
->e_ident
[EI_MAG2
] == ELFMAG2
241 && header
->e_ident
[EI_MAG3
] == ELFMAG3
242 && header
->e_ident
[EI_CLASS
] == ELFCLASS64
);
245 /* Return non-zero if FILE is a 64-bit ELF file,
246 zero if the file is not a 64-bit ELF file,
247 and -1 if the file is not accessible or doesn't exist. */
250 elf_64_file_p (const char *file
)
255 fd
= open (file
, O_RDONLY
);
259 if (read (fd
, &header
, sizeof (header
)) != sizeof (header
))
266 return elf_64_header_p (&header
);
269 /* Accepts an integer PID; Returns true if the executable PID is
270 running is a 64-bit ELF file.. */
273 linux_pid_exe_is_elf_64_file (int pid
)
275 char file
[MAXPATHLEN
];
277 sprintf (file
, "/proc/%d/exe", pid
);
278 return elf_64_file_p (file
);
282 delete_lwp (struct lwp_info
*lwp
)
284 remove_thread (get_lwp_thread (lwp
));
285 remove_inferior (&all_lwps
, &lwp
->head
);
286 free (lwp
->arch_private
);
290 /* Add a process to the common process list, and set its private
293 static struct process_info
*
294 linux_add_process (int pid
, int attached
)
296 struct process_info
*proc
;
298 /* Is this the first process? If so, then set the arch. */
299 if (all_processes
.head
== NULL
)
302 proc
= add_process (pid
, attached
);
303 proc
->private = xcalloc (1, sizeof (*proc
->private));
305 if (the_low_target
.new_process
!= NULL
)
306 proc
->private->arch_private
= the_low_target
.new_process ();
311 /* Wrapper function for waitpid which handles EINTR, and emulates
312 __WALL for systems where that is not available. */
315 my_waitpid (int pid
, int *status
, int flags
)
320 fprintf (stderr
, "my_waitpid (%d, 0x%x)\n", pid
, flags
);
324 sigset_t block_mask
, org_mask
, wake_mask
;
327 wnohang
= (flags
& WNOHANG
) != 0;
328 flags
&= ~(__WALL
| __WCLONE
);
331 /* Block all signals while here. This avoids knowing about
332 LinuxThread's signals. */
333 sigfillset (&block_mask
);
334 sigprocmask (SIG_BLOCK
, &block_mask
, &org_mask
);
336 /* ... except during the sigsuspend below. */
337 sigemptyset (&wake_mask
);
341 /* Since all signals are blocked, there's no need to check
343 ret
= waitpid (pid
, status
, flags
);
346 if (ret
== -1 && out_errno
!= ECHILD
)
351 if (flags
& __WCLONE
)
353 /* We've tried both flavors now. If WNOHANG is set,
354 there's nothing else to do, just bail out. */
359 fprintf (stderr
, "blocking\n");
361 /* Block waiting for signals. */
362 sigsuspend (&wake_mask
);
368 sigprocmask (SIG_SETMASK
, &org_mask
, NULL
);
373 ret
= waitpid (pid
, status
, flags
);
374 while (ret
== -1 && errno
== EINTR
);
379 fprintf (stderr
, "my_waitpid (%d, 0x%x): status(%x), %d\n",
380 pid
, flags
, status
? *status
: -1, ret
);
386 /* Handle a GNU/Linux extended wait response. If we see a clone
387 event, we need to add the new LWP to our list (and not report the
388 trap to higher layers). */
391 handle_extended_wait (struct lwp_info
*event_child
, int wstat
)
393 int event
= wstat
>> 16;
394 struct lwp_info
*new_lwp
;
396 if (event
== PTRACE_EVENT_CLONE
)
399 unsigned long new_pid
;
402 ptrace (PTRACE_GETEVENTMSG
, lwpid_of (event_child
), 0, &new_pid
);
404 /* If we haven't already seen the new PID stop, wait for it now. */
405 if (!pull_pid_from_list (&stopped_pids
, new_pid
, &status
))
407 /* The new child has a pending SIGSTOP. We can't affect it until it
408 hits the SIGSTOP, but we're already attached. */
410 ret
= my_waitpid (new_pid
, &status
, __WALL
);
413 perror_with_name ("waiting for new child");
414 else if (ret
!= new_pid
)
415 warning ("wait returned unexpected PID %d", ret
);
416 else if (!WIFSTOPPED (status
))
417 warning ("wait returned unexpected status 0x%x", status
);
420 linux_enable_event_reporting (new_pid
);
422 ptid
= ptid_build (pid_of (event_child
), new_pid
, 0);
423 new_lwp
= (struct lwp_info
*) add_lwp (ptid
);
424 add_thread (ptid
, new_lwp
);
426 /* Either we're going to immediately resume the new thread
427 or leave it stopped. linux_resume_one_lwp is a nop if it
428 thinks the thread is currently running, so set this first
429 before calling linux_resume_one_lwp. */
430 new_lwp
->stopped
= 1;
432 /* Normally we will get the pending SIGSTOP. But in some cases
433 we might get another signal delivered to the group first.
434 If we do get another signal, be sure not to lose it. */
435 if (WSTOPSIG (status
) == SIGSTOP
)
437 if (stopping_threads
)
438 new_lwp
->stop_pc
= get_stop_pc (new_lwp
);
440 linux_resume_one_lwp (new_lwp
, 0, 0, NULL
);
444 new_lwp
->stop_expected
= 1;
446 if (stopping_threads
)
448 new_lwp
->stop_pc
= get_stop_pc (new_lwp
);
449 new_lwp
->status_pending_p
= 1;
450 new_lwp
->status_pending
= status
;
453 /* Pass the signal on. This is what GDB does - except
454 shouldn't we really report it instead? */
455 linux_resume_one_lwp (new_lwp
, 0, WSTOPSIG (status
), NULL
);
458 /* Always resume the current thread. If we are stopping
459 threads, it will have a pending SIGSTOP; we may as well
461 linux_resume_one_lwp (event_child
, event_child
->stepping
, 0, NULL
);
465 /* Return the PC as read from the regcache of LWP, without any
469 get_pc (struct lwp_info
*lwp
)
471 struct thread_info
*saved_inferior
;
472 struct regcache
*regcache
;
475 if (the_low_target
.get_pc
== NULL
)
478 saved_inferior
= current_inferior
;
479 current_inferior
= get_lwp_thread (lwp
);
481 regcache
= get_thread_regcache (current_inferior
, 1);
482 pc
= (*the_low_target
.get_pc
) (regcache
);
485 fprintf (stderr
, "pc is 0x%lx\n", (long) pc
);
487 current_inferior
= saved_inferior
;
491 /* This function should only be called if LWP got a SIGTRAP.
492 The SIGTRAP could mean several things.
494 On i386, where decr_pc_after_break is non-zero:
495 If we were single-stepping this process using PTRACE_SINGLESTEP,
496 we will get only the one SIGTRAP (even if the instruction we
497 stepped over was a breakpoint). The value of $eip will be the
499 If we continue the process using PTRACE_CONT, we will get a
500 SIGTRAP when we hit a breakpoint. The value of $eip will be
501 the instruction after the breakpoint (i.e. needs to be
502 decremented). If we report the SIGTRAP to GDB, we must also
503 report the undecremented PC. If we cancel the SIGTRAP, we
504 must resume at the decremented PC.
506 (Presumably, not yet tested) On a non-decr_pc_after_break machine
507 with hardware or kernel single-step:
508 If we single-step over a breakpoint instruction, our PC will
509 point at the following instruction. If we continue and hit a
510 breakpoint instruction, our PC will point at the breakpoint
514 get_stop_pc (struct lwp_info
*lwp
)
518 if (the_low_target
.get_pc
== NULL
)
521 stop_pc
= get_pc (lwp
);
523 if (WSTOPSIG (lwp
->last_status
) == SIGTRAP
525 && !lwp
->stopped_by_watchpoint
526 && lwp
->last_status
>> 16 == 0)
527 stop_pc
-= the_low_target
.decr_pc_after_break
;
530 fprintf (stderr
, "stop pc is 0x%lx\n", (long) stop_pc
);
536 add_lwp (ptid_t ptid
)
538 struct lwp_info
*lwp
;
540 lwp
= (struct lwp_info
*) xmalloc (sizeof (*lwp
));
541 memset (lwp
, 0, sizeof (*lwp
));
545 if (the_low_target
.new_thread
!= NULL
)
546 lwp
->arch_private
= the_low_target
.new_thread ();
548 add_inferior_to_list (&all_lwps
, &lwp
->head
);
553 /* Start an inferior process and returns its pid.
554 ALLARGS is a vector of program-name and args. */
557 linux_create_inferior (char *program
, char **allargs
)
559 #ifdef HAVE_PERSONALITY
560 int personality_orig
= 0, personality_set
= 0;
562 struct lwp_info
*new_lwp
;
566 #ifdef HAVE_PERSONALITY
567 if (disable_randomization
)
570 personality_orig
= personality (0xffffffff);
571 if (errno
== 0 && !(personality_orig
& ADDR_NO_RANDOMIZE
))
574 personality (personality_orig
| ADDR_NO_RANDOMIZE
);
576 if (errno
!= 0 || (personality_set
577 && !(personality (0xffffffff) & ADDR_NO_RANDOMIZE
)))
578 warning ("Error disabling address space randomization: %s",
583 #if defined(__UCLIBC__) && defined(HAS_NOMMU)
589 perror_with_name ("fork");
593 ptrace (PTRACE_TRACEME
, 0, 0, 0);
595 #ifndef __ANDROID__ /* Bionic doesn't use SIGRTMIN the way glibc does. */
596 signal (__SIGRTMIN
+ 1, SIG_DFL
);
601 /* If gdbserver is connected to gdb via stdio, redirect the inferior's
602 stdout to stderr so that inferior i/o doesn't corrupt the connection.
603 Also, redirect stdin to /dev/null. */
604 if (remote_connection_is_stdio ())
607 open ("/dev/null", O_RDONLY
);
609 if (write (2, "stdin/stdout redirected\n",
610 sizeof ("stdin/stdout redirected\n") - 1) < 0)
611 /* Errors ignored. */;
614 execv (program
, allargs
);
616 execvp (program
, allargs
);
618 fprintf (stderr
, "Cannot exec %s: %s.\n", program
,
624 #ifdef HAVE_PERSONALITY
628 personality (personality_orig
);
630 warning ("Error restoring address space randomization: %s",
635 linux_add_process (pid
, 0);
637 ptid
= ptid_build (pid
, pid
, 0);
638 new_lwp
= add_lwp (ptid
);
639 add_thread (ptid
, new_lwp
);
640 new_lwp
->must_set_ptrace_flags
= 1;
645 /* Attach to an inferior process. */
648 linux_attach_lwp_1 (unsigned long lwpid
, int initial
)
651 struct lwp_info
*new_lwp
;
653 if (ptrace (PTRACE_ATTACH
, lwpid
, 0, 0) != 0)
657 /* If we fail to attach to an LWP, just warn. */
658 fprintf (stderr
, "Cannot attach to lwp %ld: %s (%d)\n", lwpid
,
659 strerror (errno
), errno
);
664 /* If we fail to attach to a process, report an error. */
665 error ("Cannot attach to lwp %ld: %s (%d)\n", lwpid
,
666 strerror (errno
), errno
);
670 /* If lwp is the tgid, we handle adding existing threads later.
671 Otherwise we just add lwp without bothering about any other
673 ptid
= ptid_build (lwpid
, lwpid
, 0);
676 /* Note that extracting the pid from the current inferior is
677 safe, since we're always called in the context of the same
678 process as this new thread. */
679 int pid
= pid_of (get_thread_lwp (current_inferior
));
680 ptid
= ptid_build (pid
, lwpid
, 0);
683 new_lwp
= (struct lwp_info
*) add_lwp (ptid
);
684 add_thread (ptid
, new_lwp
);
686 /* We need to wait for SIGSTOP before being able to make the next
687 ptrace call on this LWP. */
688 new_lwp
->must_set_ptrace_flags
= 1;
690 if (linux_proc_pid_is_stopped (lwpid
))
694 "Attached to a stopped process\n");
696 /* The process is definitely stopped. It is in a job control
697 stop, unless the kernel predates the TASK_STOPPED /
698 TASK_TRACED distinction, in which case it might be in a
699 ptrace stop. Make sure it is in a ptrace stop; from there we
700 can kill it, signal it, et cetera.
702 First make sure there is a pending SIGSTOP. Since we are
703 already attached, the process can not transition from stopped
704 to running without a PTRACE_CONT; so we know this signal will
705 go into the queue. The SIGSTOP generated by PTRACE_ATTACH is
706 probably already in the queue (unless this kernel is old
707 enough to use TASK_STOPPED for ptrace stops); but since
708 SIGSTOP is not an RT signal, it can only be queued once. */
709 kill_lwp (lwpid
, SIGSTOP
);
711 /* Finally, resume the stopped process. This will deliver the
712 SIGSTOP (or a higher priority signal, just like normal
713 PTRACE_ATTACH), which we'll catch later on. */
714 ptrace (PTRACE_CONT
, lwpid
, 0, 0);
717 /* The next time we wait for this LWP we'll see a SIGSTOP as PTRACE_ATTACH
720 There are several cases to consider here:
722 1) gdbserver has already attached to the process and is being notified
723 of a new thread that is being created.
724 In this case we should ignore that SIGSTOP and resume the
725 process. This is handled below by setting stop_expected = 1,
726 and the fact that add_thread sets last_resume_kind ==
729 2) This is the first thread (the process thread), and we're attaching
730 to it via attach_inferior.
731 In this case we want the process thread to stop.
732 This is handled by having linux_attach set last_resume_kind ==
733 resume_stop after we return.
735 If the pid we are attaching to is also the tgid, we attach to and
736 stop all the existing threads. Otherwise, we attach to pid and
737 ignore any other threads in the same group as this pid.
739 3) GDB is connecting to gdbserver and is requesting an enumeration of all
741 In this case we want the thread to stop.
742 FIXME: This case is currently not properly handled.
743 We should wait for the SIGSTOP but don't. Things work apparently
744 because enough time passes between when we ptrace (ATTACH) and when
745 gdb makes the next ptrace call on the thread.
747 On the other hand, if we are currently trying to stop all threads, we
748 should treat the new thread as if we had sent it a SIGSTOP. This works
749 because we are guaranteed that the add_lwp call above added us to the
750 end of the list, and so the new thread has not yet reached
751 wait_for_sigstop (but will). */
752 new_lwp
->stop_expected
= 1;
756 linux_attach_lwp (unsigned long lwpid
)
758 linux_attach_lwp_1 (lwpid
, 0);
761 /* Attach to PID. If PID is the tgid, attach to it and all
765 linux_attach (unsigned long pid
)
767 /* Attach to PID. We will check for other threads
769 linux_attach_lwp_1 (pid
, 1);
770 linux_add_process (pid
, 1);
774 struct thread_info
*thread
;
776 /* Don't ignore the initial SIGSTOP if we just attached to this
777 process. It will be collected by wait shortly. */
778 thread
= find_thread_ptid (ptid_build (pid
, pid
, 0));
779 thread
->last_resume_kind
= resume_stop
;
782 if (linux_proc_get_tgid (pid
) == pid
)
787 sprintf (pathname
, "/proc/%ld/task", pid
);
789 dir
= opendir (pathname
);
793 fprintf (stderr
, "Could not open /proc/%ld/task.\n", pid
);
798 /* At this point we attached to the tgid. Scan the task for
801 int new_threads_found
;
805 while (iterations
< 2)
807 new_threads_found
= 0;
808 /* Add all the other threads. While we go through the
809 threads, new threads may be spawned. Cycle through
810 the list of threads until we have done two iterations without
811 finding new threads. */
812 while ((dp
= readdir (dir
)) != NULL
)
815 lwp
= strtoul (dp
->d_name
, NULL
, 10);
817 /* Is this a new thread? */
819 && find_thread_ptid (ptid_build (pid
, lwp
, 0)) == NULL
)
821 linux_attach_lwp_1 (lwp
, 0);
826 Found and attached to new lwp %ld\n", lwp
);
830 if (!new_threads_found
)
851 second_thread_of_pid_p (struct inferior_list_entry
*entry
, void *args
)
853 struct counter
*counter
= args
;
855 if (ptid_get_pid (entry
->id
) == counter
->pid
)
857 if (++counter
->count
> 1)
865 last_thread_of_process_p (struct thread_info
*thread
)
867 ptid_t ptid
= ((struct inferior_list_entry
*)thread
)->id
;
868 int pid
= ptid_get_pid (ptid
);
869 struct counter counter
= { pid
, 0 };
871 return (find_inferior (&all_threads
,
872 second_thread_of_pid_p
, &counter
) == NULL
);
878 linux_kill_one_lwp (struct lwp_info
*lwp
)
880 int pid
= lwpid_of (lwp
);
882 /* PTRACE_KILL is unreliable. After stepping into a signal handler,
883 there is no signal context, and ptrace(PTRACE_KILL) (or
884 ptrace(PTRACE_CONT, SIGKILL), pretty much the same) acts like
885 ptrace(CONT, pid, 0,0) and just resumes the tracee. A better
886 alternative is to kill with SIGKILL. We only need one SIGKILL
887 per process, not one for each thread. But since we still support
888 linuxthreads, and we also support debugging programs using raw
889 clone without CLONE_THREAD, we send one for each thread. For
890 years, we used PTRACE_KILL only, so we're being a bit paranoid
891 about some old kernels where PTRACE_KILL might work better
892 (dubious if there are any such, but that's why it's paranoia), so
893 we try SIGKILL first, PTRACE_KILL second, and so we're fine
900 "LKL: kill (SIGKILL) %s, 0, 0 (%s)\n",
901 target_pid_to_str (ptid_of (lwp
)),
902 errno
? strerror (errno
) : "OK");
905 ptrace (PTRACE_KILL
, pid
, 0, 0);
908 "LKL: PTRACE_KILL %s, 0, 0 (%s)\n",
909 target_pid_to_str (ptid_of (lwp
)),
910 errno
? strerror (errno
) : "OK");
913 /* Callback for `find_inferior'. Kills an lwp of a given process,
914 except the leader. */
917 kill_one_lwp_callback (struct inferior_list_entry
*entry
, void *args
)
919 struct thread_info
*thread
= (struct thread_info
*) entry
;
920 struct lwp_info
*lwp
= get_thread_lwp (thread
);
922 int pid
= * (int *) args
;
924 if (ptid_get_pid (entry
->id
) != pid
)
927 /* We avoid killing the first thread here, because of a Linux kernel (at
928 least 2.6.0-test7 through 2.6.8-rc4) bug; if we kill the parent before
929 the children get a chance to be reaped, it will remain a zombie
932 if (lwpid_of (lwp
) == pid
)
935 fprintf (stderr
, "lkop: is last of process %s\n",
936 target_pid_to_str (entry
->id
));
942 linux_kill_one_lwp (lwp
);
944 /* Make sure it died. The loop is most likely unnecessary. */
945 pid
= linux_wait_for_event (lwp
->head
.id
, &wstat
, __WALL
);
946 } while (pid
> 0 && WIFSTOPPED (wstat
));
954 struct process_info
*process
;
955 struct lwp_info
*lwp
;
959 process
= find_process_pid (pid
);
963 /* If we're killing a running inferior, make sure it is stopped
964 first, as PTRACE_KILL will not work otherwise. */
965 stop_all_lwps (0, NULL
);
967 find_inferior (&all_threads
, kill_one_lwp_callback
, &pid
);
969 /* See the comment in linux_kill_one_lwp. We did not kill the first
970 thread in the list, so do so now. */
971 lwp
= find_lwp_pid (pid_to_ptid (pid
));
976 fprintf (stderr
, "lk_1: cannot find lwp %ld, for pid: %d\n",
977 lwpid_of (lwp
), pid
);
982 fprintf (stderr
, "lk_1: killing lwp %ld, for pid: %d\n",
983 lwpid_of (lwp
), pid
);
987 linux_kill_one_lwp (lwp
);
989 /* Make sure it died. The loop is most likely unnecessary. */
990 lwpid
= linux_wait_for_event (lwp
->head
.id
, &wstat
, __WALL
);
991 } while (lwpid
> 0 && WIFSTOPPED (wstat
));
994 the_target
->mourn (process
);
996 /* Since we presently can only stop all lwps of all processes, we
997 need to unstop lwps of other processes. */
998 unstop_all_lwps (0, NULL
);
1002 /* Get pending signal of THREAD, for detaching purposes. This is the
1003 signal the thread last stopped for, which we need to deliver to the
1004 thread when detaching, otherwise, it'd be suppressed/lost. */
1007 get_detach_signal (struct thread_info
*thread
)
1009 enum target_signal signo
= TARGET_SIGNAL_0
;
1011 struct lwp_info
*lp
= get_thread_lwp (thread
);
1013 if (lp
->status_pending_p
)
1014 status
= lp
->status_pending
;
1017 /* If the thread had been suspended by gdbserver, and it stopped
1018 cleanly, then it'll have stopped with SIGSTOP. But we don't
1019 want to deliver that SIGSTOP. */
1020 if (thread
->last_status
.kind
!= TARGET_WAITKIND_STOPPED
1021 || thread
->last_status
.value
.sig
== TARGET_SIGNAL_0
)
1024 /* Otherwise, we may need to deliver the signal we
1026 status
= lp
->last_status
;
1029 if (!WIFSTOPPED (status
))
1033 "GPS: lwp %s hasn't stopped: no pending signal\n",
1034 target_pid_to_str (ptid_of (lp
)));
1038 /* Extended wait statuses aren't real SIGTRAPs. */
1039 if (WSTOPSIG (status
) == SIGTRAP
&& status
>> 16 != 0)
1043 "GPS: lwp %s had stopped with extended "
1044 "status: no pending signal\n",
1045 target_pid_to_str (ptid_of (lp
)));
1049 signo
= target_signal_from_host (WSTOPSIG (status
));
1051 if (program_signals_p
&& !program_signals
[signo
])
1055 "GPS: lwp %s had signal %s, but it is in nopass state\n",
1056 target_pid_to_str (ptid_of (lp
)),
1057 target_signal_to_string (signo
));
1060 else if (!program_signals_p
1061 /* If we have no way to know which signals GDB does not
1062 want to have passed to the program, assume
1063 SIGTRAP/SIGINT, which is GDB's default. */
1064 && (signo
== TARGET_SIGNAL_TRAP
|| signo
== TARGET_SIGNAL_INT
))
1068 "GPS: lwp %s had signal %s, "
1069 "but we don't know if we should pass it. Default to not.\n",
1070 target_pid_to_str (ptid_of (lp
)),
1071 target_signal_to_string (signo
));
1078 "GPS: lwp %s has pending signal %s: delivering it.\n",
1079 target_pid_to_str (ptid_of (lp
)),
1080 target_signal_to_string (signo
));
1082 return WSTOPSIG (status
);
1087 linux_detach_one_lwp (struct inferior_list_entry
*entry
, void *args
)
1089 struct thread_info
*thread
= (struct thread_info
*) entry
;
1090 struct lwp_info
*lwp
= get_thread_lwp (thread
);
1091 int pid
= * (int *) args
;
1094 if (ptid_get_pid (entry
->id
) != pid
)
1097 /* If there is a pending SIGSTOP, get rid of it. */
1098 if (lwp
->stop_expected
)
1102 "Sending SIGCONT to %s\n",
1103 target_pid_to_str (ptid_of (lwp
)));
1105 kill_lwp (lwpid_of (lwp
), SIGCONT
);
1106 lwp
->stop_expected
= 0;
1109 /* Flush any pending changes to the process's registers. */
1110 regcache_invalidate_one ((struct inferior_list_entry
*)
1111 get_lwp_thread (lwp
));
1113 /* Pass on any pending signal for this thread. */
1114 sig
= get_detach_signal (thread
);
1116 /* Finally, let it resume. */
1117 if (the_low_target
.prepare_to_resume
!= NULL
)
1118 the_low_target
.prepare_to_resume (lwp
);
1119 if (ptrace (PTRACE_DETACH
, lwpid_of (lwp
), 0, sig
) < 0)
1120 error (_("Can't detach %s: %s"),
1121 target_pid_to_str (ptid_of (lwp
)),
1129 linux_detach (int pid
)
1131 struct process_info
*process
;
1133 process
= find_process_pid (pid
);
1134 if (process
== NULL
)
1137 /* Stop all threads before detaching. First, ptrace requires that
1138 the thread is stopped to sucessfully detach. Second, thread_db
1139 may need to uninstall thread event breakpoints from memory, which
1140 only works with a stopped process anyway. */
1141 stop_all_lwps (0, NULL
);
1143 #ifdef USE_THREAD_DB
1144 thread_db_detach (process
);
1147 /* Stabilize threads (move out of jump pads). */
1148 stabilize_threads ();
1150 find_inferior (&all_threads
, linux_detach_one_lwp
, &pid
);
1152 the_target
->mourn (process
);
1154 /* Since we presently can only stop all lwps of all processes, we
1155 need to unstop lwps of other processes. */
1156 unstop_all_lwps (0, NULL
);
1160 /* Remove all LWPs that belong to process PROC from the lwp list. */
1163 delete_lwp_callback (struct inferior_list_entry
*entry
, void *proc
)
1165 struct lwp_info
*lwp
= (struct lwp_info
*) entry
;
1166 struct process_info
*process
= proc
;
1168 if (pid_of (lwp
) == pid_of (process
))
1175 linux_mourn (struct process_info
*process
)
1177 struct process_info_private
*priv
;
1179 #ifdef USE_THREAD_DB
1180 thread_db_mourn (process
);
1183 find_inferior (&all_lwps
, delete_lwp_callback
, process
);
1185 /* Freeing all private data. */
1186 priv
= process
->private;
1187 free (priv
->arch_private
);
1189 process
->private = NULL
;
1191 remove_process (process
);
1195 linux_join (int pid
)
1200 ret
= my_waitpid (pid
, &status
, 0);
1201 if (WIFEXITED (status
) || WIFSIGNALED (status
))
1203 } while (ret
!= -1 || errno
!= ECHILD
);
1206 /* Return nonzero if the given thread is still alive. */
1208 linux_thread_alive (ptid_t ptid
)
1210 struct lwp_info
*lwp
= find_lwp_pid (ptid
);
1212 /* We assume we always know if a thread exits. If a whole process
1213 exited but we still haven't been able to report it to GDB, we'll
1214 hold on to the last lwp of the dead process. */
1221 /* Return 1 if this lwp has an interesting status pending. */
1223 status_pending_p_callback (struct inferior_list_entry
*entry
, void *arg
)
1225 struct lwp_info
*lwp
= (struct lwp_info
*) entry
;
1226 ptid_t ptid
= * (ptid_t
*) arg
;
1227 struct thread_info
*thread
;
1229 /* Check if we're only interested in events from a specific process
1231 if (!ptid_equal (minus_one_ptid
, ptid
)
1232 && ptid_get_pid (ptid
) != ptid_get_pid (lwp
->head
.id
))
1235 thread
= get_lwp_thread (lwp
);
1237 /* If we got a `vCont;t', but we haven't reported a stop yet, do
1238 report any status pending the LWP may have. */
1239 if (thread
->last_resume_kind
== resume_stop
1240 && thread
->last_status
.kind
!= TARGET_WAITKIND_IGNORE
)
1243 return lwp
->status_pending_p
;
1247 same_lwp (struct inferior_list_entry
*entry
, void *data
)
1249 ptid_t ptid
= *(ptid_t
*) data
;
1252 if (ptid_get_lwp (ptid
) != 0)
1253 lwp
= ptid_get_lwp (ptid
);
1255 lwp
= ptid_get_pid (ptid
);
1257 if (ptid_get_lwp (entry
->id
) == lwp
)
1264 find_lwp_pid (ptid_t ptid
)
1266 return (struct lwp_info
*) find_inferior (&all_lwps
, same_lwp
, &ptid
);
1269 static struct lwp_info
*
1270 linux_wait_for_lwp (ptid_t ptid
, int *wstatp
, int options
)
1273 int to_wait_for
= -1;
1274 struct lwp_info
*child
= NULL
;
1277 fprintf (stderr
, "linux_wait_for_lwp: %s\n", target_pid_to_str (ptid
));
1279 if (ptid_equal (ptid
, minus_one_ptid
))
1280 to_wait_for
= -1; /* any child */
1282 to_wait_for
= ptid_get_lwp (ptid
); /* this lwp only */
1288 ret
= my_waitpid (to_wait_for
, wstatp
, options
);
1289 if (ret
== 0 || (ret
== -1 && errno
== ECHILD
&& (options
& WNOHANG
)))
1292 perror_with_name ("waitpid");
1295 && (!WIFSTOPPED (*wstatp
)
1296 || (WSTOPSIG (*wstatp
) != 32
1297 && WSTOPSIG (*wstatp
) != 33)))
1298 fprintf (stderr
, "Got an event from %d (%x)\n", ret
, *wstatp
);
1300 child
= find_lwp_pid (pid_to_ptid (ret
));
1302 /* If we didn't find a process, one of two things presumably happened:
1303 - A process we started and then detached from has exited. Ignore it.
1304 - A process we are controlling has forked and the new child's stop
1305 was reported to us by the kernel. Save its PID. */
1306 if (child
== NULL
&& WIFSTOPPED (*wstatp
))
1308 add_to_pid_list (&stopped_pids
, ret
, *wstatp
);
1311 else if (child
== NULL
)
1316 child
->last_status
= *wstatp
;
1318 /* Architecture-specific setup after inferior is running.
1319 This needs to happen after we have attached to the inferior
1320 and it is stopped for the first time, but before we access
1321 any inferior registers. */
1324 the_low_target
.arch_setup ();
1325 #ifdef HAVE_LINUX_REGSETS
1326 memset (disabled_regsets
, 0, num_regsets
);
1331 /* Fetch the possibly triggered data watchpoint info and store it in
1334 On some archs, like x86, that use debug registers to set
1335 watchpoints, it's possible that the way to know which watched
1336 address trapped, is to check the register that is used to select
1337 which address to watch. Problem is, between setting the
1338 watchpoint and reading back which data address trapped, the user
1339 may change the set of watchpoints, and, as a consequence, GDB
1340 changes the debug registers in the inferior. To avoid reading
1341 back a stale stopped-data-address when that happens, we cache in
1342 LP the fact that a watchpoint trapped, and the corresponding data
1343 address, as soon as we see CHILD stop with a SIGTRAP. If GDB
1344 changes the debug registers meanwhile, we have the cached data we
1347 if (WIFSTOPPED (*wstatp
) && WSTOPSIG (*wstatp
) == SIGTRAP
)
1349 if (the_low_target
.stopped_by_watchpoint
== NULL
)
1351 child
->stopped_by_watchpoint
= 0;
1355 struct thread_info
*saved_inferior
;
1357 saved_inferior
= current_inferior
;
1358 current_inferior
= get_lwp_thread (child
);
1360 child
->stopped_by_watchpoint
1361 = the_low_target
.stopped_by_watchpoint ();
1363 if (child
->stopped_by_watchpoint
)
1365 if (the_low_target
.stopped_data_address
!= NULL
)
1366 child
->stopped_data_address
1367 = the_low_target
.stopped_data_address ();
1369 child
->stopped_data_address
= 0;
1372 current_inferior
= saved_inferior
;
1376 /* Store the STOP_PC, with adjustment applied. This depends on the
1377 architecture being defined already (so that CHILD has a valid
1378 regcache), and on LAST_STATUS being set (to check for SIGTRAP or
1380 if (WIFSTOPPED (*wstatp
))
1381 child
->stop_pc
= get_stop_pc (child
);
1384 && WIFSTOPPED (*wstatp
)
1385 && the_low_target
.get_pc
!= NULL
)
1387 struct thread_info
*saved_inferior
= current_inferior
;
1388 struct regcache
*regcache
;
1391 current_inferior
= get_lwp_thread (child
);
1392 regcache
= get_thread_regcache (current_inferior
, 1);
1393 pc
= (*the_low_target
.get_pc
) (regcache
);
1394 fprintf (stderr
, "linux_wait_for_lwp: pc is 0x%lx\n", (long) pc
);
1395 current_inferior
= saved_inferior
;
1401 /* This function should only be called if the LWP got a SIGTRAP.
1403 Handle any tracepoint steps or hits. Return true if a tracepoint
1404 event was handled, 0 otherwise. */
1407 handle_tracepoints (struct lwp_info
*lwp
)
1409 struct thread_info
*tinfo
= get_lwp_thread (lwp
);
1410 int tpoint_related_event
= 0;
1412 /* If this tracepoint hit causes a tracing stop, we'll immediately
1413 uninsert tracepoints. To do this, we temporarily pause all
1414 threads, unpatch away, and then unpause threads. We need to make
1415 sure the unpausing doesn't resume LWP too. */
1418 /* And we need to be sure that any all-threads-stopping doesn't try
1419 to move threads out of the jump pads, as it could deadlock the
1420 inferior (LWP could be in the jump pad, maybe even holding the
1423 /* Do any necessary step collect actions. */
1424 tpoint_related_event
|= tracepoint_finished_step (tinfo
, lwp
->stop_pc
);
1426 tpoint_related_event
|= handle_tracepoint_bkpts (tinfo
, lwp
->stop_pc
);
1428 /* See if we just hit a tracepoint and do its main collect
1430 tpoint_related_event
|= tracepoint_was_hit (tinfo
, lwp
->stop_pc
);
1434 gdb_assert (lwp
->suspended
== 0);
1435 gdb_assert (!stabilizing_threads
|| lwp
->collecting_fast_tracepoint
);
1437 if (tpoint_related_event
)
1440 fprintf (stderr
, "got a tracepoint event\n");
1447 /* Convenience wrapper. Returns true if LWP is presently collecting a
1451 linux_fast_tracepoint_collecting (struct lwp_info
*lwp
,
1452 struct fast_tpoint_collect_status
*status
)
1454 CORE_ADDR thread_area
;
1456 if (the_low_target
.get_thread_area
== NULL
)
1459 /* Get the thread area address. This is used to recognize which
1460 thread is which when tracing with the in-process agent library.
1461 We don't read anything from the address, and treat it as opaque;
1462 it's the address itself that we assume is unique per-thread. */
1463 if ((*the_low_target
.get_thread_area
) (lwpid_of (lwp
), &thread_area
) == -1)
1466 return fast_tracepoint_collecting (thread_area
, lwp
->stop_pc
, status
);
1469 /* The reason we resume in the caller, is because we want to be able
1470 to pass lwp->status_pending as WSTAT, and we need to clear
1471 status_pending_p before resuming, otherwise, linux_resume_one_lwp
1472 refuses to resume. */
1475 maybe_move_out_of_jump_pad (struct lwp_info
*lwp
, int *wstat
)
1477 struct thread_info
*saved_inferior
;
1479 saved_inferior
= current_inferior
;
1480 current_inferior
= get_lwp_thread (lwp
);
1483 || (WIFSTOPPED (*wstat
) && WSTOPSIG (*wstat
) != SIGTRAP
))
1484 && supports_fast_tracepoints ()
1485 && agent_loaded_p ())
1487 struct fast_tpoint_collect_status status
;
1492 Checking whether LWP %ld needs to move out of the jump pad.\n",
1495 r
= linux_fast_tracepoint_collecting (lwp
, &status
);
1498 || (WSTOPSIG (*wstat
) != SIGILL
1499 && WSTOPSIG (*wstat
) != SIGFPE
1500 && WSTOPSIG (*wstat
) != SIGSEGV
1501 && WSTOPSIG (*wstat
) != SIGBUS
))
1503 lwp
->collecting_fast_tracepoint
= r
;
1507 if (r
== 1 && lwp
->exit_jump_pad_bkpt
== NULL
)
1509 /* Haven't executed the original instruction yet.
1510 Set breakpoint there, and wait till it's hit,
1511 then single-step until exiting the jump pad. */
1512 lwp
->exit_jump_pad_bkpt
1513 = set_breakpoint_at (status
.adjusted_insn_addr
, NULL
);
1518 Checking whether LWP %ld needs to move out of the jump pad...it does\n",
1520 current_inferior
= saved_inferior
;
1527 /* If we get a synchronous signal while collecting, *and*
1528 while executing the (relocated) original instruction,
1529 reset the PC to point at the tpoint address, before
1530 reporting to GDB. Otherwise, it's an IPA lib bug: just
1531 report the signal to GDB, and pray for the best. */
1533 lwp
->collecting_fast_tracepoint
= 0;
1536 && (status
.adjusted_insn_addr
<= lwp
->stop_pc
1537 && lwp
->stop_pc
< status
.adjusted_insn_addr_end
))
1540 struct regcache
*regcache
;
1542 /* The si_addr on a few signals references the address
1543 of the faulting instruction. Adjust that as
1545 if ((WSTOPSIG (*wstat
) == SIGILL
1546 || WSTOPSIG (*wstat
) == SIGFPE
1547 || WSTOPSIG (*wstat
) == SIGBUS
1548 || WSTOPSIG (*wstat
) == SIGSEGV
)
1549 && ptrace (PTRACE_GETSIGINFO
, lwpid_of (lwp
), 0, &info
) == 0
1550 /* Final check just to make sure we don't clobber
1551 the siginfo of non-kernel-sent signals. */
1552 && (uintptr_t) info
.si_addr
== lwp
->stop_pc
)
1554 info
.si_addr
= (void *) (uintptr_t) status
.tpoint_addr
;
1555 ptrace (PTRACE_SETSIGINFO
, lwpid_of (lwp
), 0, &info
);
1558 regcache
= get_thread_regcache (get_lwp_thread (lwp
), 1);
1559 (*the_low_target
.set_pc
) (regcache
, status
.tpoint_addr
);
1560 lwp
->stop_pc
= status
.tpoint_addr
;
1562 /* Cancel any fast tracepoint lock this thread was
1564 force_unlock_trace_buffer ();
1567 if (lwp
->exit_jump_pad_bkpt
!= NULL
)
1571 "Cancelling fast exit-jump-pad: removing bkpt. "
1572 "stopping all threads momentarily.\n");
1574 stop_all_lwps (1, lwp
);
1575 cancel_breakpoints ();
1577 delete_breakpoint (lwp
->exit_jump_pad_bkpt
);
1578 lwp
->exit_jump_pad_bkpt
= NULL
;
1580 unstop_all_lwps (1, lwp
);
1582 gdb_assert (lwp
->suspended
>= 0);
1589 Checking whether LWP %ld needs to move out of the jump pad...no\n",
1592 current_inferior
= saved_inferior
;
1596 /* Enqueue one signal in the "signals to report later when out of the
1600 enqueue_one_deferred_signal (struct lwp_info
*lwp
, int *wstat
)
1602 struct pending_signals
*p_sig
;
1606 Deferring signal %d for LWP %ld.\n", WSTOPSIG (*wstat
), lwpid_of (lwp
));
1610 struct pending_signals
*sig
;
1612 for (sig
= lwp
->pending_signals_to_report
;
1616 " Already queued %d\n",
1619 fprintf (stderr
, " (no more currently queued signals)\n");
1622 /* Don't enqueue non-RT signals if they are already in the deferred
1623 queue. (SIGSTOP being the easiest signal to see ending up here
1625 if (WSTOPSIG (*wstat
) < __SIGRTMIN
)
1627 struct pending_signals
*sig
;
1629 for (sig
= lwp
->pending_signals_to_report
;
1633 if (sig
->signal
== WSTOPSIG (*wstat
))
1637 "Not requeuing already queued non-RT signal %d"
1646 p_sig
= xmalloc (sizeof (*p_sig
));
1647 p_sig
->prev
= lwp
->pending_signals_to_report
;
1648 p_sig
->signal
= WSTOPSIG (*wstat
);
1649 memset (&p_sig
->info
, 0, sizeof (siginfo_t
));
1650 ptrace (PTRACE_GETSIGINFO
, lwpid_of (lwp
), 0, &p_sig
->info
);
1652 lwp
->pending_signals_to_report
= p_sig
;
1655 /* Dequeue one signal from the "signals to report later when out of
1656 the jump pad" list. */
1659 dequeue_one_deferred_signal (struct lwp_info
*lwp
, int *wstat
)
1661 if (lwp
->pending_signals_to_report
!= NULL
)
1663 struct pending_signals
**p_sig
;
1665 p_sig
= &lwp
->pending_signals_to_report
;
1666 while ((*p_sig
)->prev
!= NULL
)
1667 p_sig
= &(*p_sig
)->prev
;
1669 *wstat
= W_STOPCODE ((*p_sig
)->signal
);
1670 if ((*p_sig
)->info
.si_signo
!= 0)
1671 ptrace (PTRACE_SETSIGINFO
, lwpid_of (lwp
), 0, &(*p_sig
)->info
);
1676 fprintf (stderr
, "Reporting deferred signal %d for LWP %ld.\n",
1677 WSTOPSIG (*wstat
), lwpid_of (lwp
));
1681 struct pending_signals
*sig
;
1683 for (sig
= lwp
->pending_signals_to_report
;
1687 " Still queued %d\n",
1690 fprintf (stderr
, " (no more queued signals)\n");
1699 /* Arrange for a breakpoint to be hit again later. We don't keep the
1700 SIGTRAP status and don't forward the SIGTRAP signal to the LWP. We
1701 will handle the current event, eventually we will resume this LWP,
1702 and this breakpoint will trap again. */
1705 cancel_breakpoint (struct lwp_info
*lwp
)
1707 struct thread_info
*saved_inferior
;
1709 /* There's nothing to do if we don't support breakpoints. */
1710 if (!supports_breakpoints ())
1713 /* breakpoint_at reads from current inferior. */
1714 saved_inferior
= current_inferior
;
1715 current_inferior
= get_lwp_thread (lwp
);
1717 if ((*the_low_target
.breakpoint_at
) (lwp
->stop_pc
))
1721 "CB: Push back breakpoint for %s\n",
1722 target_pid_to_str (ptid_of (lwp
)));
1724 /* Back up the PC if necessary. */
1725 if (the_low_target
.decr_pc_after_break
)
1727 struct regcache
*regcache
1728 = get_thread_regcache (current_inferior
, 1);
1729 (*the_low_target
.set_pc
) (regcache
, lwp
->stop_pc
);
1732 current_inferior
= saved_inferior
;
1739 "CB: No breakpoint found at %s for [%s]\n",
1740 paddress (lwp
->stop_pc
),
1741 target_pid_to_str (ptid_of (lwp
)));
1744 current_inferior
= saved_inferior
;
1748 /* When the event-loop is doing a step-over, this points at the thread
1750 ptid_t step_over_bkpt
;
1752 /* Wait for an event from child PID. If PID is -1, wait for any
1753 child. Store the stop status through the status pointer WSTAT.
1754 OPTIONS is passed to the waitpid call. Return 0 if no child stop
1755 event was found and OPTIONS contains WNOHANG. Return the PID of
1756 the stopped child otherwise. */
1759 linux_wait_for_event (ptid_t ptid
, int *wstat
, int options
)
1761 struct lwp_info
*event_child
, *requested_child
;
1765 requested_child
= NULL
;
1767 /* Check for a lwp with a pending status. */
1769 if (ptid_equal (ptid
, minus_one_ptid
) || ptid_is_pid (ptid
))
1771 event_child
= (struct lwp_info
*)
1772 find_inferior (&all_lwps
, status_pending_p_callback
, &ptid
);
1773 if (debug_threads
&& event_child
)
1774 fprintf (stderr
, "Got a pending child %ld\n", lwpid_of (event_child
));
1778 requested_child
= find_lwp_pid (ptid
);
1780 if (!stopping_threads
1781 && requested_child
->status_pending_p
1782 && requested_child
->collecting_fast_tracepoint
)
1784 enqueue_one_deferred_signal (requested_child
,
1785 &requested_child
->status_pending
);
1786 requested_child
->status_pending_p
= 0;
1787 requested_child
->status_pending
= 0;
1788 linux_resume_one_lwp (requested_child
, 0, 0, NULL
);
1791 if (requested_child
->suspended
1792 && requested_child
->status_pending_p
)
1793 fatal ("requesting an event out of a suspended child?");
1795 if (requested_child
->status_pending_p
)
1796 event_child
= requested_child
;
1799 if (event_child
!= NULL
)
1802 fprintf (stderr
, "Got an event from pending child %ld (%04x)\n",
1803 lwpid_of (event_child
), event_child
->status_pending
);
1804 *wstat
= event_child
->status_pending
;
1805 event_child
->status_pending_p
= 0;
1806 event_child
->status_pending
= 0;
1807 current_inferior
= get_lwp_thread (event_child
);
1808 return lwpid_of (event_child
);
1811 if (ptid_is_pid (ptid
))
1813 /* A request to wait for a specific tgid. This is not possible
1814 with waitpid, so instead, we wait for any child, and leave
1815 children we're not interested in right now with a pending
1816 status to report later. */
1817 wait_ptid
= minus_one_ptid
;
1822 /* We only enter this loop if no process has a pending wait status. Thus
1823 any action taken in response to a wait status inside this loop is
1824 responding as soon as we detect the status, not after any pending
1828 event_child
= linux_wait_for_lwp (wait_ptid
, wstat
, options
);
1830 if ((options
& WNOHANG
) && event_child
== NULL
)
1833 fprintf (stderr
, "WNOHANG set, no event found\n");
1837 if (event_child
== NULL
)
1838 error ("event from unknown child");
1840 if (ptid_is_pid (ptid
)
1841 && ptid_get_pid (ptid
) != ptid_get_pid (ptid_of (event_child
)))
1843 if (! WIFSTOPPED (*wstat
))
1844 mark_lwp_dead (event_child
, *wstat
);
1847 event_child
->status_pending_p
= 1;
1848 event_child
->status_pending
= *wstat
;
1853 current_inferior
= get_lwp_thread (event_child
);
1855 /* Check for thread exit. */
1856 if (! WIFSTOPPED (*wstat
))
1859 fprintf (stderr
, "LWP %ld exiting\n", lwpid_of (event_child
));
1861 /* If the last thread is exiting, just return. */
1862 if (last_thread_of_process_p (current_inferior
))
1865 fprintf (stderr
, "LWP %ld is last lwp of process\n",
1866 lwpid_of (event_child
));
1867 return lwpid_of (event_child
);
1872 current_inferior
= (struct thread_info
*) all_threads
.head
;
1874 fprintf (stderr
, "Current inferior is now %ld\n",
1875 lwpid_of (get_thread_lwp (current_inferior
)));
1879 current_inferior
= NULL
;
1881 fprintf (stderr
, "Current inferior is now <NULL>\n");
1884 /* If we were waiting for this particular child to do something...
1885 well, it did something. */
1886 if (requested_child
!= NULL
)
1888 int lwpid
= lwpid_of (event_child
);
1890 /* Cancel the step-over operation --- the thread that
1891 started it is gone. */
1892 if (finish_step_over (event_child
))
1893 unstop_all_lwps (1, event_child
);
1894 delete_lwp (event_child
);
1898 delete_lwp (event_child
);
1900 /* Wait for a more interesting event. */
1904 if (event_child
->must_set_ptrace_flags
)
1906 linux_enable_event_reporting (lwpid_of (event_child
));
1907 event_child
->must_set_ptrace_flags
= 0;
1910 if (WIFSTOPPED (*wstat
) && WSTOPSIG (*wstat
) == SIGTRAP
1911 && *wstat
>> 16 != 0)
1913 handle_extended_wait (event_child
, *wstat
);
1917 if (WIFSTOPPED (*wstat
)
1918 && WSTOPSIG (*wstat
) == SIGSTOP
1919 && event_child
->stop_expected
)
1924 fprintf (stderr
, "Expected stop.\n");
1925 event_child
->stop_expected
= 0;
1927 should_stop
= (current_inferior
->last_resume_kind
== resume_stop
1928 || stopping_threads
);
1932 linux_resume_one_lwp (event_child
,
1933 event_child
->stepping
, 0, NULL
);
1938 return lwpid_of (event_child
);
1945 /* Count the LWP's that have had events. */
1948 count_events_callback (struct inferior_list_entry
*entry
, void *data
)
1950 struct lwp_info
*lp
= (struct lwp_info
*) entry
;
1951 struct thread_info
*thread
= get_lwp_thread (lp
);
1954 gdb_assert (count
!= NULL
);
1956 /* Count only resumed LWPs that have a SIGTRAP event pending that
1957 should be reported to GDB. */
1958 if (thread
->last_status
.kind
== TARGET_WAITKIND_IGNORE
1959 && thread
->last_resume_kind
!= resume_stop
1960 && lp
->status_pending_p
1961 && WIFSTOPPED (lp
->status_pending
)
1962 && WSTOPSIG (lp
->status_pending
) == SIGTRAP
1963 && !breakpoint_inserted_here (lp
->stop_pc
))
1969 /* Select the LWP (if any) that is currently being single-stepped. */
1972 select_singlestep_lwp_callback (struct inferior_list_entry
*entry
, void *data
)
1974 struct lwp_info
*lp
= (struct lwp_info
*) entry
;
1975 struct thread_info
*thread
= get_lwp_thread (lp
);
1977 if (thread
->last_status
.kind
== TARGET_WAITKIND_IGNORE
1978 && thread
->last_resume_kind
== resume_step
1979 && lp
->status_pending_p
)
1985 /* Select the Nth LWP that has had a SIGTRAP event that should be
1989 select_event_lwp_callback (struct inferior_list_entry
*entry
, void *data
)
1991 struct lwp_info
*lp
= (struct lwp_info
*) entry
;
1992 struct thread_info
*thread
= get_lwp_thread (lp
);
1993 int *selector
= data
;
1995 gdb_assert (selector
!= NULL
);
1997 /* Select only resumed LWPs that have a SIGTRAP event pending. */
1998 if (thread
->last_resume_kind
!= resume_stop
1999 && thread
->last_status
.kind
== TARGET_WAITKIND_IGNORE
2000 && lp
->status_pending_p
2001 && WIFSTOPPED (lp
->status_pending
)
2002 && WSTOPSIG (lp
->status_pending
) == SIGTRAP
2003 && !breakpoint_inserted_here (lp
->stop_pc
))
2004 if ((*selector
)-- == 0)
2011 cancel_breakpoints_callback (struct inferior_list_entry
*entry
, void *data
)
2013 struct lwp_info
*lp
= (struct lwp_info
*) entry
;
2014 struct thread_info
*thread
= get_lwp_thread (lp
);
2015 struct lwp_info
*event_lp
= data
;
2017 /* Leave the LWP that has been elected to receive a SIGTRAP alone. */
2021 /* If a LWP other than the LWP that we're reporting an event for has
2022 hit a GDB breakpoint (as opposed to some random trap signal),
2023 then just arrange for it to hit it again later. We don't keep
2024 the SIGTRAP status and don't forward the SIGTRAP signal to the
2025 LWP. We will handle the current event, eventually we will resume
2026 all LWPs, and this one will get its breakpoint trap again.
2028 If we do not do this, then we run the risk that the user will
2029 delete or disable the breakpoint, but the LWP will have already
2032 if (thread
->last_resume_kind
!= resume_stop
2033 && thread
->last_status
.kind
== TARGET_WAITKIND_IGNORE
2034 && lp
->status_pending_p
2035 && WIFSTOPPED (lp
->status_pending
)
2036 && WSTOPSIG (lp
->status_pending
) == SIGTRAP
2038 && !lp
->stopped_by_watchpoint
2039 && cancel_breakpoint (lp
))
2040 /* Throw away the SIGTRAP. */
2041 lp
->status_pending_p
= 0;
2047 linux_cancel_breakpoints (void)
2049 find_inferior (&all_lwps
, cancel_breakpoints_callback
, NULL
);
2052 /* Select one LWP out of those that have events pending. */
2055 select_event_lwp (struct lwp_info
**orig_lp
)
2058 int random_selector
;
2059 struct lwp_info
*event_lp
;
2061 /* Give preference to any LWP that is being single-stepped. */
2063 = (struct lwp_info
*) find_inferior (&all_lwps
,
2064 select_singlestep_lwp_callback
, NULL
);
2065 if (event_lp
!= NULL
)
2069 "SEL: Select single-step %s\n",
2070 target_pid_to_str (ptid_of (event_lp
)));
2074 /* No single-stepping LWP. Select one at random, out of those
2075 which have had SIGTRAP events. */
2077 /* First see how many SIGTRAP events we have. */
2078 find_inferior (&all_lwps
, count_events_callback
, &num_events
);
2080 /* Now randomly pick a LWP out of those that have had a SIGTRAP. */
2081 random_selector
= (int)
2082 ((num_events
* (double) rand ()) / (RAND_MAX
+ 1.0));
2084 if (debug_threads
&& num_events
> 1)
2086 "SEL: Found %d SIGTRAP events, selecting #%d\n",
2087 num_events
, random_selector
);
2089 event_lp
= (struct lwp_info
*) find_inferior (&all_lwps
,
2090 select_event_lwp_callback
,
2094 if (event_lp
!= NULL
)
2096 /* Switch the event LWP. */
2097 *orig_lp
= event_lp
;
2101 /* Decrement the suspend count of an LWP. */
2104 unsuspend_one_lwp (struct inferior_list_entry
*entry
, void *except
)
2106 struct lwp_info
*lwp
= (struct lwp_info
*) entry
;
2108 /* Ignore EXCEPT. */
2114 gdb_assert (lwp
->suspended
>= 0);
2118 /* Decrement the suspend count of all LWPs, except EXCEPT, if non
2122 unsuspend_all_lwps (struct lwp_info
*except
)
2124 find_inferior (&all_lwps
, unsuspend_one_lwp
, except
);
2127 static void move_out_of_jump_pad_callback (struct inferior_list_entry
*entry
);
2128 static int stuck_in_jump_pad_callback (struct inferior_list_entry
*entry
,
2130 static int lwp_running (struct inferior_list_entry
*entry
, void *data
);
2131 static ptid_t
linux_wait_1 (ptid_t ptid
,
2132 struct target_waitstatus
*ourstatus
,
2133 int target_options
);
2135 /* Stabilize threads (move out of jump pads).
2137 If a thread is midway collecting a fast tracepoint, we need to
2138 finish the collection and move it out of the jump pad before
2139 reporting the signal.
2141 This avoids recursion while collecting (when a signal arrives
2142 midway, and the signal handler itself collects), which would trash
2143 the trace buffer. In case the user set a breakpoint in a signal
2144 handler, this avoids the backtrace showing the jump pad, etc..
2145 Most importantly, there are certain things we can't do safely if
2146 threads are stopped in a jump pad (or in its callee's). For
2149 - starting a new trace run. A thread still collecting the
2150 previous run, could trash the trace buffer when resumed. The trace
2151 buffer control structures would have been reset but the thread had
2152 no way to tell. The thread could even midway memcpy'ing to the
2153 buffer, which would mean that when resumed, it would clobber the
2154 trace buffer that had been set for a new run.
2156 - we can't rewrite/reuse the jump pads for new tracepoints
2157 safely. Say you do tstart while a thread is stopped midway while
2158 collecting. When the thread is later resumed, it finishes the
2159 collection, and returns to the jump pad, to execute the original
2160 instruction that was under the tracepoint jump at the time the
2161 older run had been started. If the jump pad had been rewritten
2162 since for something else in the new run, the thread would now
2163 execute the wrong / random instructions. */
2166 linux_stabilize_threads (void)
2168 struct thread_info
*save_inferior
;
2169 struct lwp_info
*lwp_stuck
;
2172 = (struct lwp_info
*) find_inferior (&all_lwps
,
2173 stuck_in_jump_pad_callback
, NULL
);
2174 if (lwp_stuck
!= NULL
)
2177 fprintf (stderr
, "can't stabilize, LWP %ld is stuck in jump pad\n",
2178 lwpid_of (lwp_stuck
));
2182 save_inferior
= current_inferior
;
2184 stabilizing_threads
= 1;
2187 for_each_inferior (&all_lwps
, move_out_of_jump_pad_callback
);
2189 /* Loop until all are stopped out of the jump pads. */
2190 while (find_inferior (&all_lwps
, lwp_running
, NULL
) != NULL
)
2192 struct target_waitstatus ourstatus
;
2193 struct lwp_info
*lwp
;
2196 /* Note that we go through the full wait even loop. While
2197 moving threads out of jump pad, we need to be able to step
2198 over internal breakpoints and such. */
2199 linux_wait_1 (minus_one_ptid
, &ourstatus
, 0);
2201 if (ourstatus
.kind
== TARGET_WAITKIND_STOPPED
)
2203 lwp
= get_thread_lwp (current_inferior
);
2208 if (ourstatus
.value
.sig
!= TARGET_SIGNAL_0
2209 || current_inferior
->last_resume_kind
== resume_stop
)
2211 wstat
= W_STOPCODE (target_signal_to_host (ourstatus
.value
.sig
));
2212 enqueue_one_deferred_signal (lwp
, &wstat
);
2217 find_inferior (&all_lwps
, unsuspend_one_lwp
, NULL
);
2219 stabilizing_threads
= 0;
2221 current_inferior
= save_inferior
;
2226 = (struct lwp_info
*) find_inferior (&all_lwps
,
2227 stuck_in_jump_pad_callback
, NULL
);
2228 if (lwp_stuck
!= NULL
)
2229 fprintf (stderr
, "couldn't stabilize, LWP %ld got stuck in jump pad\n",
2230 lwpid_of (lwp_stuck
));
2234 /* Wait for process, returns status. */
2237 linux_wait_1 (ptid_t ptid
,
2238 struct target_waitstatus
*ourstatus
, int target_options
)
2241 struct lwp_info
*event_child
;
2244 int step_over_finished
;
2245 int bp_explains_trap
;
2246 int maybe_internal_trap
;
2250 /* Translate generic target options into linux options. */
2252 if (target_options
& TARGET_WNOHANG
)
2256 bp_explains_trap
= 0;
2258 ourstatus
->kind
= TARGET_WAITKIND_IGNORE
;
2260 /* If we were only supposed to resume one thread, only wait for
2261 that thread - if it's still alive. If it died, however - which
2262 can happen if we're coming from the thread death case below -
2263 then we need to make sure we restart the other threads. We could
2264 pick a thread at random or restart all; restarting all is less
2267 && !ptid_equal (cont_thread
, null_ptid
)
2268 && !ptid_equal (cont_thread
, minus_one_ptid
))
2270 struct thread_info
*thread
;
2272 thread
= (struct thread_info
*) find_inferior_id (&all_threads
,
2275 /* No stepping, no signal - unless one is pending already, of course. */
2278 struct thread_resume resume_info
;
2279 resume_info
.thread
= minus_one_ptid
;
2280 resume_info
.kind
= resume_continue
;
2281 resume_info
.sig
= 0;
2282 linux_resume (&resume_info
, 1);
2288 if (ptid_equal (step_over_bkpt
, null_ptid
))
2289 pid
= linux_wait_for_event (ptid
, &w
, options
);
2293 fprintf (stderr
, "step_over_bkpt set [%s], doing a blocking wait\n",
2294 target_pid_to_str (step_over_bkpt
));
2295 pid
= linux_wait_for_event (step_over_bkpt
, &w
, options
& ~WNOHANG
);
2298 if (pid
== 0) /* only if TARGET_WNOHANG */
2301 event_child
= get_thread_lwp (current_inferior
);
2303 /* If we are waiting for a particular child, and it exited,
2304 linux_wait_for_event will return its exit status. Similarly if
2305 the last child exited. If this is not the last child, however,
2306 do not report it as exited until there is a 'thread exited' response
2307 available in the remote protocol. Instead, just wait for another event.
2308 This should be safe, because if the thread crashed we will already
2309 have reported the termination signal to GDB; that should stop any
2310 in-progress stepping operations, etc.
2312 Report the exit status of the last thread to exit. This matches
2313 LinuxThreads' behavior. */
2315 if (last_thread_of_process_p (current_inferior
))
2317 if (WIFEXITED (w
) || WIFSIGNALED (w
))
2321 ourstatus
->kind
= TARGET_WAITKIND_EXITED
;
2322 ourstatus
->value
.integer
= WEXITSTATUS (w
);
2326 "\nChild exited with retcode = %x \n",
2331 ourstatus
->kind
= TARGET_WAITKIND_SIGNALLED
;
2332 ourstatus
->value
.sig
= target_signal_from_host (WTERMSIG (w
));
2336 "\nChild terminated with signal = %x \n",
2341 return ptid_of (event_child
);
2346 if (!WIFSTOPPED (w
))
2350 /* If this event was not handled before, and is not a SIGTRAP, we
2351 report it. SIGILL and SIGSEGV are also treated as traps in case
2352 a breakpoint is inserted at the current PC. If this target does
2353 not support internal breakpoints at all, we also report the
2354 SIGTRAP without further processing; it's of no concern to us. */
2356 = (supports_breakpoints ()
2357 && (WSTOPSIG (w
) == SIGTRAP
2358 || ((WSTOPSIG (w
) == SIGILL
2359 || WSTOPSIG (w
) == SIGSEGV
)
2360 && (*the_low_target
.breakpoint_at
) (event_child
->stop_pc
))));
2362 if (maybe_internal_trap
)
2364 /* Handle anything that requires bookkeeping before deciding to
2365 report the event or continue waiting. */
2367 /* First check if we can explain the SIGTRAP with an internal
2368 breakpoint, or if we should possibly report the event to GDB.
2369 Do this before anything that may remove or insert a
2371 bp_explains_trap
= breakpoint_inserted_here (event_child
->stop_pc
);
2373 /* We have a SIGTRAP, possibly a step-over dance has just
2374 finished. If so, tweak the state machine accordingly,
2375 reinsert breakpoints and delete any reinsert (software
2376 single-step) breakpoints. */
2377 step_over_finished
= finish_step_over (event_child
);
2379 /* Now invoke the callbacks of any internal breakpoints there. */
2380 check_breakpoints (event_child
->stop_pc
);
2382 /* Handle tracepoint data collecting. This may overflow the
2383 trace buffer, and cause a tracing stop, removing
2385 trace_event
= handle_tracepoints (event_child
);
2387 if (bp_explains_trap
)
2389 /* If we stepped or ran into an internal breakpoint, we've
2390 already handled it. So next time we resume (from this
2391 PC), we should step over it. */
2393 fprintf (stderr
, "Hit a gdbserver breakpoint.\n");
2395 if (breakpoint_here (event_child
->stop_pc
))
2396 event_child
->need_step_over
= 1;
2401 /* We have some other signal, possibly a step-over dance was in
2402 progress, and it should be cancelled too. */
2403 step_over_finished
= finish_step_over (event_child
);
2406 /* We have all the data we need. Either report the event to GDB, or
2407 resume threads and keep waiting for more. */
2409 /* If we're collecting a fast tracepoint, finish the collection and
2410 move out of the jump pad before delivering a signal. See
2411 linux_stabilize_threads. */
2414 && WSTOPSIG (w
) != SIGTRAP
2415 && supports_fast_tracepoints ()
2416 && agent_loaded_p ())
2420 "Got signal %d for LWP %ld. Check if we need "
2421 "to defer or adjust it.\n",
2422 WSTOPSIG (w
), lwpid_of (event_child
));
2424 /* Allow debugging the jump pad itself. */
2425 if (current_inferior
->last_resume_kind
!= resume_step
2426 && maybe_move_out_of_jump_pad (event_child
, &w
))
2428 enqueue_one_deferred_signal (event_child
, &w
);
2432 "Signal %d for LWP %ld deferred (in jump pad)\n",
2433 WSTOPSIG (w
), lwpid_of (event_child
));
2435 linux_resume_one_lwp (event_child
, 0, 0, NULL
);
2440 if (event_child
->collecting_fast_tracepoint
)
2444 LWP %ld was trying to move out of the jump pad (%d). \
2445 Check if we're already there.\n",
2446 lwpid_of (event_child
),
2447 event_child
->collecting_fast_tracepoint
);
2451 event_child
->collecting_fast_tracepoint
2452 = linux_fast_tracepoint_collecting (event_child
, NULL
);
2454 if (event_child
->collecting_fast_tracepoint
!= 1)
2456 /* No longer need this breakpoint. */
2457 if (event_child
->exit_jump_pad_bkpt
!= NULL
)
2461 "No longer need exit-jump-pad bkpt; removing it."
2462 "stopping all threads momentarily.\n");
2464 /* Other running threads could hit this breakpoint.
2465 We don't handle moribund locations like GDB does,
2466 instead we always pause all threads when removing
2467 breakpoints, so that any step-over or
2468 decr_pc_after_break adjustment is always taken
2469 care of while the breakpoint is still
2471 stop_all_lwps (1, event_child
);
2472 cancel_breakpoints ();
2474 delete_breakpoint (event_child
->exit_jump_pad_bkpt
);
2475 event_child
->exit_jump_pad_bkpt
= NULL
;
2477 unstop_all_lwps (1, event_child
);
2479 gdb_assert (event_child
->suspended
>= 0);
2483 if (event_child
->collecting_fast_tracepoint
== 0)
2487 "fast tracepoint finished "
2488 "collecting successfully.\n");
2490 /* We may have a deferred signal to report. */
2491 if (dequeue_one_deferred_signal (event_child
, &w
))
2494 fprintf (stderr
, "dequeued one signal.\n");
2499 fprintf (stderr
, "no deferred signals.\n");
2501 if (stabilizing_threads
)
2503 ourstatus
->kind
= TARGET_WAITKIND_STOPPED
;
2504 ourstatus
->value
.sig
= TARGET_SIGNAL_0
;
2505 return ptid_of (event_child
);
2511 /* Check whether GDB would be interested in this event. */
2513 /* If GDB is not interested in this signal, don't stop other
2514 threads, and don't report it to GDB. Just resume the inferior
2515 right away. We do this for threading-related signals as well as
2516 any that GDB specifically requested we ignore. But never ignore
2517 SIGSTOP if we sent it ourselves, and do not ignore signals when
2518 stepping - they may require special handling to skip the signal
2520 /* FIXME drow/2002-06-09: Get signal numbers from the inferior's
2523 && current_inferior
->last_resume_kind
!= resume_step
2525 #if defined (USE_THREAD_DB) && !defined (__ANDROID__)
2526 (current_process ()->private->thread_db
!= NULL
2527 && (WSTOPSIG (w
) == __SIGRTMIN
2528 || WSTOPSIG (w
) == __SIGRTMIN
+ 1))
2531 (pass_signals
[target_signal_from_host (WSTOPSIG (w
))]
2532 && !(WSTOPSIG (w
) == SIGSTOP
2533 && current_inferior
->last_resume_kind
== resume_stop
))))
2535 siginfo_t info
, *info_p
;
2538 fprintf (stderr
, "Ignored signal %d for LWP %ld.\n",
2539 WSTOPSIG (w
), lwpid_of (event_child
));
2541 if (ptrace (PTRACE_GETSIGINFO
, lwpid_of (event_child
), 0, &info
) == 0)
2545 linux_resume_one_lwp (event_child
, event_child
->stepping
,
2546 WSTOPSIG (w
), info_p
);
2550 /* If GDB wanted this thread to single step, we always want to
2551 report the SIGTRAP, and let GDB handle it. Watchpoints should
2552 always be reported. So should signals we can't explain. A
2553 SIGTRAP we can't explain could be a GDB breakpoint --- we may or
2554 not support Z0 breakpoints. If we do, we're be able to handle
2555 GDB breakpoints on top of internal breakpoints, by handling the
2556 internal breakpoint and still reporting the event to GDB. If we
2557 don't, we're out of luck, GDB won't see the breakpoint hit. */
2558 report_to_gdb
= (!maybe_internal_trap
2559 || current_inferior
->last_resume_kind
== resume_step
2560 || event_child
->stopped_by_watchpoint
2561 || (!step_over_finished
2562 && !bp_explains_trap
&& !trace_event
)
2563 || (gdb_breakpoint_here (event_child
->stop_pc
)
2564 && gdb_condition_true_at_breakpoint (event_child
->stop_pc
)));
2566 /* We found no reason GDB would want us to stop. We either hit one
2567 of our own breakpoints, or finished an internal step GDB
2568 shouldn't know about. */
2573 if (bp_explains_trap
)
2574 fprintf (stderr
, "Hit a gdbserver breakpoint.\n");
2575 if (step_over_finished
)
2576 fprintf (stderr
, "Step-over finished.\n");
2578 fprintf (stderr
, "Tracepoint event.\n");
2581 /* We're not reporting this breakpoint to GDB, so apply the
2582 decr_pc_after_break adjustment to the inferior's regcache
2585 if (the_low_target
.set_pc
!= NULL
)
2587 struct regcache
*regcache
2588 = get_thread_regcache (get_lwp_thread (event_child
), 1);
2589 (*the_low_target
.set_pc
) (regcache
, event_child
->stop_pc
);
2592 /* We may have finished stepping over a breakpoint. If so,
2593 we've stopped and suspended all LWPs momentarily except the
2594 stepping one. This is where we resume them all again. We're
2595 going to keep waiting, so use proceed, which handles stepping
2596 over the next breakpoint. */
2598 fprintf (stderr
, "proceeding all threads.\n");
2600 if (step_over_finished
)
2601 unsuspend_all_lwps (event_child
);
2603 proceed_all_lwps ();
2609 if (current_inferior
->last_resume_kind
== resume_step
)
2610 fprintf (stderr
, "GDB wanted to single-step, reporting event.\n");
2611 if (event_child
->stopped_by_watchpoint
)
2612 fprintf (stderr
, "Stopped by watchpoint.\n");
2613 if (gdb_breakpoint_here (event_child
->stop_pc
))
2614 fprintf (stderr
, "Stopped by GDB breakpoint.\n");
2616 fprintf (stderr
, "Hit a non-gdbserver trap event.\n");
2619 /* Alright, we're going to report a stop. */
2621 if (!non_stop
&& !stabilizing_threads
)
2623 /* In all-stop, stop all threads. */
2624 stop_all_lwps (0, NULL
);
2626 /* If we're not waiting for a specific LWP, choose an event LWP
2627 from among those that have had events. Giving equal priority
2628 to all LWPs that have had events helps prevent
2630 if (ptid_equal (ptid
, minus_one_ptid
))
2632 event_child
->status_pending_p
= 1;
2633 event_child
->status_pending
= w
;
2635 select_event_lwp (&event_child
);
2637 event_child
->status_pending_p
= 0;
2638 w
= event_child
->status_pending
;
2641 /* Now that we've selected our final event LWP, cancel any
2642 breakpoints in other LWPs that have hit a GDB breakpoint.
2643 See the comment in cancel_breakpoints_callback to find out
2645 find_inferior (&all_lwps
, cancel_breakpoints_callback
, event_child
);
2647 /* If we were going a step-over, all other threads but the stepping one
2648 had been paused in start_step_over, with their suspend counts
2649 incremented. We don't want to do a full unstop/unpause, because we're
2650 in all-stop mode (so we want threads stopped), but we still need to
2651 unsuspend the other threads, to decrement their `suspended' count
2653 if (step_over_finished
)
2654 unsuspend_all_lwps (event_child
);
2656 /* Stabilize threads (move out of jump pads). */
2657 stabilize_threads ();
2661 /* If we just finished a step-over, then all threads had been
2662 momentarily paused. In all-stop, that's fine, we want
2663 threads stopped by now anyway. In non-stop, we need to
2664 re-resume threads that GDB wanted to be running. */
2665 if (step_over_finished
)
2666 unstop_all_lwps (1, event_child
);
2669 ourstatus
->kind
= TARGET_WAITKIND_STOPPED
;
2671 if (current_inferior
->last_resume_kind
== resume_stop
2672 && WSTOPSIG (w
) == SIGSTOP
)
2674 /* A thread that has been requested to stop by GDB with vCont;t,
2675 and it stopped cleanly, so report as SIG0. The use of
2676 SIGSTOP is an implementation detail. */
2677 ourstatus
->value
.sig
= TARGET_SIGNAL_0
;
2679 else if (current_inferior
->last_resume_kind
== resume_stop
2680 && WSTOPSIG (w
) != SIGSTOP
)
2682 /* A thread that has been requested to stop by GDB with vCont;t,
2683 but, it stopped for other reasons. */
2684 ourstatus
->value
.sig
= target_signal_from_host (WSTOPSIG (w
));
2688 ourstatus
->value
.sig
= target_signal_from_host (WSTOPSIG (w
));
2691 gdb_assert (ptid_equal (step_over_bkpt
, null_ptid
));
2694 fprintf (stderr
, "linux_wait ret = %s, %d, %d\n",
2695 target_pid_to_str (ptid_of (event_child
)),
2697 ourstatus
->value
.sig
);
2699 return ptid_of (event_child
);
2702 /* Get rid of any pending event in the pipe. */
2704 async_file_flush (void)
2710 ret
= read (linux_event_pipe
[0], &buf
, 1);
2711 while (ret
>= 0 || (ret
== -1 && errno
== EINTR
));
2714 /* Put something in the pipe, so the event loop wakes up. */
2716 async_file_mark (void)
2720 async_file_flush ();
2723 ret
= write (linux_event_pipe
[1], "+", 1);
2724 while (ret
== 0 || (ret
== -1 && errno
== EINTR
));
2726 /* Ignore EAGAIN. If the pipe is full, the event loop will already
2727 be awakened anyway. */
2731 linux_wait (ptid_t ptid
,
2732 struct target_waitstatus
*ourstatus
, int target_options
)
2737 fprintf (stderr
, "linux_wait: [%s]\n", target_pid_to_str (ptid
));
2739 /* Flush the async file first. */
2740 if (target_is_async_p ())
2741 async_file_flush ();
2743 event_ptid
= linux_wait_1 (ptid
, ourstatus
, target_options
);
2745 /* If at least one stop was reported, there may be more. A single
2746 SIGCHLD can signal more than one child stop. */
2747 if (target_is_async_p ()
2748 && (target_options
& TARGET_WNOHANG
) != 0
2749 && !ptid_equal (event_ptid
, null_ptid
))
2755 /* Send a signal to an LWP. */
2758 kill_lwp (unsigned long lwpid
, int signo
)
2760 /* Use tkill, if possible, in case we are using nptl threads. If tkill
2761 fails, then we are not using nptl threads and we should be using kill. */
2765 static int tkill_failed
;
2772 ret
= syscall (__NR_tkill
, lwpid
, signo
);
2773 if (errno
!= ENOSYS
)
2780 return kill (lwpid
, signo
);
2784 linux_stop_lwp (struct lwp_info
*lwp
)
2790 send_sigstop (struct lwp_info
*lwp
)
2794 pid
= lwpid_of (lwp
);
2796 /* If we already have a pending stop signal for this process, don't
2798 if (lwp
->stop_expected
)
2801 fprintf (stderr
, "Have pending sigstop for lwp %d\n", pid
);
2807 fprintf (stderr
, "Sending sigstop to lwp %d\n", pid
);
2809 lwp
->stop_expected
= 1;
2810 kill_lwp (pid
, SIGSTOP
);
2814 send_sigstop_callback (struct inferior_list_entry
*entry
, void *except
)
2816 struct lwp_info
*lwp
= (struct lwp_info
*) entry
;
2818 /* Ignore EXCEPT. */
2829 /* Increment the suspend count of an LWP, and stop it, if not stopped
2832 suspend_and_send_sigstop_callback (struct inferior_list_entry
*entry
,
2835 struct lwp_info
*lwp
= (struct lwp_info
*) entry
;
2837 /* Ignore EXCEPT. */
2843 return send_sigstop_callback (entry
, except
);
2847 mark_lwp_dead (struct lwp_info
*lwp
, int wstat
)
2849 /* It's dead, really. */
2852 /* Store the exit status for later. */
2853 lwp
->status_pending_p
= 1;
2854 lwp
->status_pending
= wstat
;
2856 /* Prevent trying to stop it. */
2859 /* No further stops are expected from a dead lwp. */
2860 lwp
->stop_expected
= 0;
2864 wait_for_sigstop (struct inferior_list_entry
*entry
)
2866 struct lwp_info
*lwp
= (struct lwp_info
*) entry
;
2867 struct thread_info
*saved_inferior
;
2876 fprintf (stderr
, "wait_for_sigstop: LWP %ld already stopped\n",
2881 saved_inferior
= current_inferior
;
2882 if (saved_inferior
!= NULL
)
2883 saved_tid
= ((struct inferior_list_entry
*) saved_inferior
)->id
;
2885 saved_tid
= null_ptid
; /* avoid bogus unused warning */
2887 ptid
= lwp
->head
.id
;
2890 fprintf (stderr
, "wait_for_sigstop: pulling one event\n");
2892 pid
= linux_wait_for_event (ptid
, &wstat
, __WALL
);
2894 /* If we stopped with a non-SIGSTOP signal, save it for later
2895 and record the pending SIGSTOP. If the process exited, just
2897 if (WIFSTOPPED (wstat
))
2900 fprintf (stderr
, "LWP %ld stopped with signal %d\n",
2901 lwpid_of (lwp
), WSTOPSIG (wstat
));
2903 if (WSTOPSIG (wstat
) != SIGSTOP
)
2906 fprintf (stderr
, "LWP %ld stopped with non-sigstop status %06x\n",
2907 lwpid_of (lwp
), wstat
);
2909 lwp
->status_pending_p
= 1;
2910 lwp
->status_pending
= wstat
;
2916 fprintf (stderr
, "Process %d exited while stopping LWPs\n", pid
);
2918 lwp
= find_lwp_pid (pid_to_ptid (pid
));
2921 /* Leave this status pending for the next time we're able to
2922 report it. In the mean time, we'll report this lwp as
2923 dead to GDB, so GDB doesn't try to read registers and
2924 memory from it. This can only happen if this was the
2925 last thread of the process; otherwise, PID is removed
2926 from the thread tables before linux_wait_for_event
2928 mark_lwp_dead (lwp
, wstat
);
2932 if (saved_inferior
== NULL
|| linux_thread_alive (saved_tid
))
2933 current_inferior
= saved_inferior
;
2937 fprintf (stderr
, "Previously current thread died.\n");
2941 /* We can't change the current inferior behind GDB's back,
2942 otherwise, a subsequent command may apply to the wrong
2944 current_inferior
= NULL
;
2948 /* Set a valid thread as current. */
2949 set_desired_inferior (0);
2954 /* Returns true if LWP ENTRY is stopped in a jump pad, and we can't
2955 move it out, because we need to report the stop event to GDB. For
2956 example, if the user puts a breakpoint in the jump pad, it's
2957 because she wants to debug it. */
2960 stuck_in_jump_pad_callback (struct inferior_list_entry
*entry
, void *data
)
2962 struct lwp_info
*lwp
= (struct lwp_info
*) entry
;
2963 struct thread_info
*thread
= get_lwp_thread (lwp
);
2965 gdb_assert (lwp
->suspended
== 0);
2966 gdb_assert (lwp
->stopped
);
2968 /* Allow debugging the jump pad, gdb_collect, etc.. */
2969 return (supports_fast_tracepoints ()
2970 && agent_loaded_p ()
2971 && (gdb_breakpoint_here (lwp
->stop_pc
)
2972 || lwp
->stopped_by_watchpoint
2973 || thread
->last_resume_kind
== resume_step
)
2974 && linux_fast_tracepoint_collecting (lwp
, NULL
));
2978 move_out_of_jump_pad_callback (struct inferior_list_entry
*entry
)
2980 struct lwp_info
*lwp
= (struct lwp_info
*) entry
;
2981 struct thread_info
*thread
= get_lwp_thread (lwp
);
2984 gdb_assert (lwp
->suspended
== 0);
2985 gdb_assert (lwp
->stopped
);
2987 wstat
= lwp
->status_pending_p
? &lwp
->status_pending
: NULL
;
2989 /* Allow debugging the jump pad, gdb_collect, etc. */
2990 if (!gdb_breakpoint_here (lwp
->stop_pc
)
2991 && !lwp
->stopped_by_watchpoint
2992 && thread
->last_resume_kind
!= resume_step
2993 && maybe_move_out_of_jump_pad (lwp
, wstat
))
2997 "LWP %ld needs stabilizing (in jump pad)\n",
3002 lwp
->status_pending_p
= 0;
3003 enqueue_one_deferred_signal (lwp
, wstat
);
3007 "Signal %d for LWP %ld deferred "
3009 WSTOPSIG (*wstat
), lwpid_of (lwp
));
3012 linux_resume_one_lwp (lwp
, 0, 0, NULL
);
3019 lwp_running (struct inferior_list_entry
*entry
, void *data
)
3021 struct lwp_info
*lwp
= (struct lwp_info
*) entry
;
3030 /* Stop all lwps that aren't stopped yet, except EXCEPT, if not NULL.
3031 If SUSPEND, then also increase the suspend count of every LWP,
3035 stop_all_lwps (int suspend
, struct lwp_info
*except
)
3037 stopping_threads
= 1;
3040 find_inferior (&all_lwps
, suspend_and_send_sigstop_callback
, except
);
3042 find_inferior (&all_lwps
, send_sigstop_callback
, except
);
3043 for_each_inferior (&all_lwps
, wait_for_sigstop
);
3044 stopping_threads
= 0;
3047 /* Resume execution of the inferior process.
3048 If STEP is nonzero, single-step it.
3049 If SIGNAL is nonzero, give it that signal. */
3052 linux_resume_one_lwp (struct lwp_info
*lwp
,
3053 int step
, int signal
, siginfo_t
*info
)
3055 struct thread_info
*saved_inferior
;
3056 int fast_tp_collecting
;
3058 if (lwp
->stopped
== 0)
3061 fast_tp_collecting
= lwp
->collecting_fast_tracepoint
;
3063 gdb_assert (!stabilizing_threads
|| fast_tp_collecting
);
3065 /* Cancel actions that rely on GDB not changing the PC (e.g., the
3066 user used the "jump" command, or "set $pc = foo"). */
3067 if (lwp
->stop_pc
!= get_pc (lwp
))
3069 /* Collecting 'while-stepping' actions doesn't make sense
3071 release_while_stepping_state_list (get_lwp_thread (lwp
));
3074 /* If we have pending signals or status, and a new signal, enqueue the
3075 signal. Also enqueue the signal if we are waiting to reinsert a
3076 breakpoint; it will be picked up again below. */
3078 && (lwp
->status_pending_p
3079 || lwp
->pending_signals
!= NULL
3080 || lwp
->bp_reinsert
!= 0
3081 || fast_tp_collecting
))
3083 struct pending_signals
*p_sig
;
3084 p_sig
= xmalloc (sizeof (*p_sig
));
3085 p_sig
->prev
= lwp
->pending_signals
;
3086 p_sig
->signal
= signal
;
3088 memset (&p_sig
->info
, 0, sizeof (siginfo_t
));
3090 memcpy (&p_sig
->info
, info
, sizeof (siginfo_t
));
3091 lwp
->pending_signals
= p_sig
;
3094 if (lwp
->status_pending_p
)
3097 fprintf (stderr
, "Not resuming lwp %ld (%s, signal %d, stop %s);"
3098 " has pending status\n",
3099 lwpid_of (lwp
), step
? "step" : "continue", signal
,
3100 lwp
->stop_expected
? "expected" : "not expected");
3104 saved_inferior
= current_inferior
;
3105 current_inferior
= get_lwp_thread (lwp
);
3108 fprintf (stderr
, "Resuming lwp %ld (%s, signal %d, stop %s)\n",
3109 lwpid_of (lwp
), step
? "step" : "continue", signal
,
3110 lwp
->stop_expected
? "expected" : "not expected");
3112 /* This bit needs some thinking about. If we get a signal that
3113 we must report while a single-step reinsert is still pending,
3114 we often end up resuming the thread. It might be better to
3115 (ew) allow a stack of pending events; then we could be sure that
3116 the reinsert happened right away and not lose any signals.
3118 Making this stack would also shrink the window in which breakpoints are
3119 uninserted (see comment in linux_wait_for_lwp) but not enough for
3120 complete correctness, so it won't solve that problem. It may be
3121 worthwhile just to solve this one, however. */
3122 if (lwp
->bp_reinsert
!= 0)
3125 fprintf (stderr
, " pending reinsert at 0x%s\n",
3126 paddress (lwp
->bp_reinsert
));
3128 if (lwp
->bp_reinsert
!= 0 && can_hardware_single_step ())
3130 if (fast_tp_collecting
== 0)
3133 fprintf (stderr
, "BAD - reinserting but not stepping.\n");
3135 fprintf (stderr
, "BAD - reinserting and suspended(%d).\n",
3142 /* Postpone any pending signal. It was enqueued above. */
3146 if (fast_tp_collecting
== 1)
3150 lwp %ld wants to get out of fast tracepoint jump pad (exit-jump-pad-bkpt)\n",
3153 /* Postpone any pending signal. It was enqueued above. */
3156 else if (fast_tp_collecting
== 2)
3160 lwp %ld wants to get out of fast tracepoint jump pad single-stepping\n",
3163 if (can_hardware_single_step ())
3166 fatal ("moving out of jump pad single-stepping"
3167 " not implemented on this target");
3169 /* Postpone any pending signal. It was enqueued above. */
3173 /* If we have while-stepping actions in this thread set it stepping.
3174 If we have a signal to deliver, it may or may not be set to
3175 SIG_IGN, we don't know. Assume so, and allow collecting
3176 while-stepping into a signal handler. A possible smart thing to
3177 do would be to set an internal breakpoint at the signal return
3178 address, continue, and carry on catching this while-stepping
3179 action only when that breakpoint is hit. A future
3181 if (get_lwp_thread (lwp
)->while_stepping
!= NULL
3182 && can_hardware_single_step ())
3186 "lwp %ld has a while-stepping action -> forcing step.\n",
3191 if (debug_threads
&& the_low_target
.get_pc
!= NULL
)
3193 struct regcache
*regcache
= get_thread_regcache (current_inferior
, 1);
3194 CORE_ADDR pc
= (*the_low_target
.get_pc
) (regcache
);
3195 fprintf (stderr
, " resuming from pc 0x%lx\n", (long) pc
);
3198 /* If we have pending signals, consume one unless we are trying to
3199 reinsert a breakpoint or we're trying to finish a fast tracepoint
3201 if (lwp
->pending_signals
!= NULL
3202 && lwp
->bp_reinsert
== 0
3203 && fast_tp_collecting
== 0)
3205 struct pending_signals
**p_sig
;
3207 p_sig
= &lwp
->pending_signals
;
3208 while ((*p_sig
)->prev
!= NULL
)
3209 p_sig
= &(*p_sig
)->prev
;
3211 signal
= (*p_sig
)->signal
;
3212 if ((*p_sig
)->info
.si_signo
!= 0)
3213 ptrace (PTRACE_SETSIGINFO
, lwpid_of (lwp
), 0, &(*p_sig
)->info
);
3219 if (the_low_target
.prepare_to_resume
!= NULL
)
3220 the_low_target
.prepare_to_resume (lwp
);
3222 regcache_invalidate_one ((struct inferior_list_entry
*)
3223 get_lwp_thread (lwp
));
3226 lwp
->stopped_by_watchpoint
= 0;
3227 lwp
->stepping
= step
;
3228 ptrace (step
? PTRACE_SINGLESTEP
: PTRACE_CONT
, lwpid_of (lwp
), 0,
3229 /* Coerce to a uintptr_t first to avoid potential gcc warning
3230 of coercing an 8 byte integer to a 4 byte pointer. */
3231 (PTRACE_ARG4_TYPE
) (uintptr_t) signal
);
3233 current_inferior
= saved_inferior
;
3236 /* ESRCH from ptrace either means that the thread was already
3237 running (an error) or that it is gone (a race condition). If
3238 it's gone, we will get a notification the next time we wait,
3239 so we can ignore the error. We could differentiate these
3240 two, but it's tricky without waiting; the thread still exists
3241 as a zombie, so sending it signal 0 would succeed. So just
3246 perror_with_name ("ptrace");
3250 struct thread_resume_array
3252 struct thread_resume
*resume
;
3256 /* This function is called once per thread. We look up the thread
3257 in RESUME_PTR, and mark the thread with a pointer to the appropriate
3260 This algorithm is O(threads * resume elements), but resume elements
3261 is small (and will remain small at least until GDB supports thread
3264 linux_set_resume_request (struct inferior_list_entry
*entry
, void *arg
)
3266 struct lwp_info
*lwp
;
3267 struct thread_info
*thread
;
3269 struct thread_resume_array
*r
;
3271 thread
= (struct thread_info
*) entry
;
3272 lwp
= get_thread_lwp (thread
);
3275 for (ndx
= 0; ndx
< r
->n
; ndx
++)
3277 ptid_t ptid
= r
->resume
[ndx
].thread
;
3278 if (ptid_equal (ptid
, minus_one_ptid
)
3279 || ptid_equal (ptid
, entry
->id
)
3280 || (ptid_is_pid (ptid
)
3281 && (ptid_get_pid (ptid
) == pid_of (lwp
)))
3282 || (ptid_get_lwp (ptid
) == -1
3283 && (ptid_get_pid (ptid
) == pid_of (lwp
))))
3285 if (r
->resume
[ndx
].kind
== resume_stop
3286 && thread
->last_resume_kind
== resume_stop
)
3289 fprintf (stderr
, "already %s LWP %ld at GDB's request\n",
3290 thread
->last_status
.kind
== TARGET_WAITKIND_STOPPED
3298 lwp
->resume
= &r
->resume
[ndx
];
3299 thread
->last_resume_kind
= lwp
->resume
->kind
;
3301 /* If we had a deferred signal to report, dequeue one now.
3302 This can happen if LWP gets more than one signal while
3303 trying to get out of a jump pad. */
3305 && !lwp
->status_pending_p
3306 && dequeue_one_deferred_signal (lwp
, &lwp
->status_pending
))
3308 lwp
->status_pending_p
= 1;
3312 "Dequeueing deferred signal %d for LWP %ld, "
3313 "leaving status pending.\n",
3314 WSTOPSIG (lwp
->status_pending
), lwpid_of (lwp
));
3321 /* No resume action for this thread. */
3328 /* Set *FLAG_P if this lwp has an interesting status pending. */
3330 resume_status_pending_p (struct inferior_list_entry
*entry
, void *flag_p
)
3332 struct lwp_info
*lwp
= (struct lwp_info
*) entry
;
3334 /* LWPs which will not be resumed are not interesting, because
3335 we might not wait for them next time through linux_wait. */
3336 if (lwp
->resume
== NULL
)
3339 if (lwp
->status_pending_p
)
3340 * (int *) flag_p
= 1;
3345 /* Return 1 if this lwp that GDB wants running is stopped at an
3346 internal breakpoint that we need to step over. It assumes that any
3347 required STOP_PC adjustment has already been propagated to the
3348 inferior's regcache. */
3351 need_step_over_p (struct inferior_list_entry
*entry
, void *dummy
)
3353 struct lwp_info
*lwp
= (struct lwp_info
*) entry
;
3354 struct thread_info
*thread
;
3355 struct thread_info
*saved_inferior
;
3358 /* LWPs which will not be resumed are not interesting, because we
3359 might not wait for them next time through linux_wait. */
3365 "Need step over [LWP %ld]? Ignoring, not stopped\n",
3370 thread
= get_lwp_thread (lwp
);
3372 if (thread
->last_resume_kind
== resume_stop
)
3376 "Need step over [LWP %ld]? Ignoring, should remain stopped\n",
3381 gdb_assert (lwp
->suspended
>= 0);
3387 "Need step over [LWP %ld]? Ignoring, suspended\n",
3392 if (!lwp
->need_step_over
)
3396 "Need step over [LWP %ld]? No\n", lwpid_of (lwp
));
3399 if (lwp
->status_pending_p
)
3403 "Need step over [LWP %ld]? Ignoring, has pending status.\n",
3408 /* Note: PC, not STOP_PC. Either GDB has adjusted the PC already,
3412 /* If the PC has changed since we stopped, then don't do anything,
3413 and let the breakpoint/tracepoint be hit. This happens if, for
3414 instance, GDB handled the decr_pc_after_break subtraction itself,
3415 GDB is OOL stepping this thread, or the user has issued a "jump"
3416 command, or poked thread's registers herself. */
3417 if (pc
!= lwp
->stop_pc
)
3421 "Need step over [LWP %ld]? Cancelling, PC was changed. "
3422 "Old stop_pc was 0x%s, PC is now 0x%s\n",
3423 lwpid_of (lwp
), paddress (lwp
->stop_pc
), paddress (pc
));
3425 lwp
->need_step_over
= 0;
3429 saved_inferior
= current_inferior
;
3430 current_inferior
= thread
;
3432 /* We can only step over breakpoints we know about. */
3433 if (breakpoint_here (pc
) || fast_tracepoint_jump_here (pc
))
3435 /* Don't step over a breakpoint that GDB expects to hit
3436 though. If the condition is being evaluated on the target's side
3437 and it evaluate to false, step over this breakpoint as well. */
3438 if (gdb_breakpoint_here (pc
)
3439 && gdb_condition_true_at_breakpoint (pc
))
3443 "Need step over [LWP %ld]? yes, but found"
3444 " GDB breakpoint at 0x%s; skipping step over\n",
3445 lwpid_of (lwp
), paddress (pc
));
3447 current_inferior
= saved_inferior
;
3454 "Need step over [LWP %ld]? yes, "
3455 "found breakpoint at 0x%s\n",
3456 lwpid_of (lwp
), paddress (pc
));
3458 /* We've found an lwp that needs stepping over --- return 1 so
3459 that find_inferior stops looking. */
3460 current_inferior
= saved_inferior
;
3462 /* If the step over is cancelled, this is set again. */
3463 lwp
->need_step_over
= 0;
3468 current_inferior
= saved_inferior
;
3472 "Need step over [LWP %ld]? No, no breakpoint found at 0x%s\n",
3473 lwpid_of (lwp
), paddress (pc
));
3478 /* Start a step-over operation on LWP. When LWP stopped at a
3479 breakpoint, to make progress, we need to remove the breakpoint out
3480 of the way. If we let other threads run while we do that, they may
3481 pass by the breakpoint location and miss hitting it. To avoid
3482 that, a step-over momentarily stops all threads while LWP is
3483 single-stepped while the breakpoint is temporarily uninserted from
3484 the inferior. When the single-step finishes, we reinsert the
3485 breakpoint, and let all threads that are supposed to be running,
3488 On targets that don't support hardware single-step, we don't
3489 currently support full software single-stepping. Instead, we only
3490 support stepping over the thread event breakpoint, by asking the
3491 low target where to place a reinsert breakpoint. Since this
3492 routine assumes the breakpoint being stepped over is a thread event
3493 breakpoint, it usually assumes the return address of the current
3494 function is a good enough place to set the reinsert breakpoint. */
3497 start_step_over (struct lwp_info
*lwp
)
3499 struct thread_info
*saved_inferior
;
3505 "Starting step-over on LWP %ld. Stopping all threads\n",
3508 stop_all_lwps (1, lwp
);
3509 gdb_assert (lwp
->suspended
== 0);
3512 fprintf (stderr
, "Done stopping all threads for step-over.\n");
3514 /* Note, we should always reach here with an already adjusted PC,
3515 either by GDB (if we're resuming due to GDB's request), or by our
3516 caller, if we just finished handling an internal breakpoint GDB
3517 shouldn't care about. */
3520 saved_inferior
= current_inferior
;
3521 current_inferior
= get_lwp_thread (lwp
);
3523 lwp
->bp_reinsert
= pc
;
3524 uninsert_breakpoints_at (pc
);
3525 uninsert_fast_tracepoint_jumps_at (pc
);
3527 if (can_hardware_single_step ())
3533 CORE_ADDR raddr
= (*the_low_target
.breakpoint_reinsert_addr
) ();
3534 set_reinsert_breakpoint (raddr
);
3538 current_inferior
= saved_inferior
;
3540 linux_resume_one_lwp (lwp
, step
, 0, NULL
);
3542 /* Require next event from this LWP. */
3543 step_over_bkpt
= lwp
->head
.id
;
3547 /* Finish a step-over. Reinsert the breakpoint we had uninserted in
3548 start_step_over, if still there, and delete any reinsert
3549 breakpoints we've set, on non hardware single-step targets. */
3552 finish_step_over (struct lwp_info
*lwp
)
3554 if (lwp
->bp_reinsert
!= 0)
3557 fprintf (stderr
, "Finished step over.\n");
3559 /* Reinsert any breakpoint at LWP->BP_REINSERT. Note that there
3560 may be no breakpoint to reinsert there by now. */
3561 reinsert_breakpoints_at (lwp
->bp_reinsert
);
3562 reinsert_fast_tracepoint_jumps_at (lwp
->bp_reinsert
);
3564 lwp
->bp_reinsert
= 0;
3566 /* Delete any software-single-step reinsert breakpoints. No
3567 longer needed. We don't have to worry about other threads
3568 hitting this trap, and later not being able to explain it,
3569 because we were stepping over a breakpoint, and we hold all
3570 threads but LWP stopped while doing that. */
3571 if (!can_hardware_single_step ())
3572 delete_reinsert_breakpoints ();
3574 step_over_bkpt
= null_ptid
;
3581 /* This function is called once per thread. We check the thread's resume
3582 request, which will tell us whether to resume, step, or leave the thread
3583 stopped; and what signal, if any, it should be sent.
3585 For threads which we aren't explicitly told otherwise, we preserve
3586 the stepping flag; this is used for stepping over gdbserver-placed
3589 If pending_flags was set in any thread, we queue any needed
3590 signals, since we won't actually resume. We already have a pending
3591 event to report, so we don't need to preserve any step requests;
3592 they should be re-issued if necessary. */
3595 linux_resume_one_thread (struct inferior_list_entry
*entry
, void *arg
)
3597 struct lwp_info
*lwp
;
3598 struct thread_info
*thread
;
3600 int leave_all_stopped
= * (int *) arg
;
3603 thread
= (struct thread_info
*) entry
;
3604 lwp
= get_thread_lwp (thread
);
3606 if (lwp
->resume
== NULL
)
3609 if (lwp
->resume
->kind
== resume_stop
)
3612 fprintf (stderr
, "resume_stop request for LWP %ld\n", lwpid_of (lwp
));
3617 fprintf (stderr
, "stopping LWP %ld\n", lwpid_of (lwp
));
3619 /* Stop the thread, and wait for the event asynchronously,
3620 through the event loop. */
3626 fprintf (stderr
, "already stopped LWP %ld\n",
3629 /* The LWP may have been stopped in an internal event that
3630 was not meant to be notified back to GDB (e.g., gdbserver
3631 breakpoint), so we should be reporting a stop event in
3634 /* If the thread already has a pending SIGSTOP, this is a
3635 no-op. Otherwise, something later will presumably resume
3636 the thread and this will cause it to cancel any pending
3637 operation, due to last_resume_kind == resume_stop. If
3638 the thread already has a pending status to report, we
3639 will still report it the next time we wait - see
3640 status_pending_p_callback. */
3642 /* If we already have a pending signal to report, then
3643 there's no need to queue a SIGSTOP, as this means we're
3644 midway through moving the LWP out of the jumppad, and we
3645 will report the pending signal as soon as that is
3647 if (lwp
->pending_signals_to_report
== NULL
)
3651 /* For stop requests, we're done. */
3653 thread
->last_status
.kind
= TARGET_WAITKIND_IGNORE
;
3657 /* If this thread which is about to be resumed has a pending status,
3658 then don't resume any threads - we can just report the pending
3659 status. Make sure to queue any signals that would otherwise be
3660 sent. In all-stop mode, we do this decision based on if *any*
3661 thread has a pending status. If there's a thread that needs the
3662 step-over-breakpoint dance, then don't resume any other thread
3663 but that particular one. */
3664 leave_pending
= (lwp
->status_pending_p
|| leave_all_stopped
);
3669 fprintf (stderr
, "resuming LWP %ld\n", lwpid_of (lwp
));
3671 step
= (lwp
->resume
->kind
== resume_step
);
3672 linux_resume_one_lwp (lwp
, step
, lwp
->resume
->sig
, NULL
);
3677 fprintf (stderr
, "leaving LWP %ld stopped\n", lwpid_of (lwp
));
3679 /* If we have a new signal, enqueue the signal. */
3680 if (lwp
->resume
->sig
!= 0)
3682 struct pending_signals
*p_sig
;
3683 p_sig
= xmalloc (sizeof (*p_sig
));
3684 p_sig
->prev
= lwp
->pending_signals
;
3685 p_sig
->signal
= lwp
->resume
->sig
;
3686 memset (&p_sig
->info
, 0, sizeof (siginfo_t
));
3688 /* If this is the same signal we were previously stopped by,
3689 make sure to queue its siginfo. We can ignore the return
3690 value of ptrace; if it fails, we'll skip
3691 PTRACE_SETSIGINFO. */
3692 if (WIFSTOPPED (lwp
->last_status
)
3693 && WSTOPSIG (lwp
->last_status
) == lwp
->resume
->sig
)
3694 ptrace (PTRACE_GETSIGINFO
, lwpid_of (lwp
), 0, &p_sig
->info
);
3696 lwp
->pending_signals
= p_sig
;
3700 thread
->last_status
.kind
= TARGET_WAITKIND_IGNORE
;
3706 linux_resume (struct thread_resume
*resume_info
, size_t n
)
3708 struct thread_resume_array array
= { resume_info
, n
};
3709 struct lwp_info
*need_step_over
= NULL
;
3711 int leave_all_stopped
;
3713 find_inferior (&all_threads
, linux_set_resume_request
, &array
);
3715 /* If there is a thread which would otherwise be resumed, which has
3716 a pending status, then don't resume any threads - we can just
3717 report the pending status. Make sure to queue any signals that
3718 would otherwise be sent. In non-stop mode, we'll apply this
3719 logic to each thread individually. We consume all pending events
3720 before considering to start a step-over (in all-stop). */
3723 find_inferior (&all_lwps
, resume_status_pending_p
, &any_pending
);
3725 /* If there is a thread which would otherwise be resumed, which is
3726 stopped at a breakpoint that needs stepping over, then don't
3727 resume any threads - have it step over the breakpoint with all
3728 other threads stopped, then resume all threads again. Make sure
3729 to queue any signals that would otherwise be delivered or
3731 if (!any_pending
&& supports_breakpoints ())
3733 = (struct lwp_info
*) find_inferior (&all_lwps
,
3734 need_step_over_p
, NULL
);
3736 leave_all_stopped
= (need_step_over
!= NULL
|| any_pending
);
3740 if (need_step_over
!= NULL
)
3741 fprintf (stderr
, "Not resuming all, need step over\n");
3742 else if (any_pending
)
3744 "Not resuming, all-stop and found "
3745 "an LWP with pending status\n");
3747 fprintf (stderr
, "Resuming, no pending status or step over needed\n");
3750 /* Even if we're leaving threads stopped, queue all signals we'd
3751 otherwise deliver. */
3752 find_inferior (&all_threads
, linux_resume_one_thread
, &leave_all_stopped
);
3755 start_step_over (need_step_over
);
3758 /* This function is called once per thread. We check the thread's
3759 last resume request, which will tell us whether to resume, step, or
3760 leave the thread stopped. Any signal the client requested to be
3761 delivered has already been enqueued at this point.
3763 If any thread that GDB wants running is stopped at an internal
3764 breakpoint that needs stepping over, we start a step-over operation
3765 on that particular thread, and leave all others stopped. */
3768 proceed_one_lwp (struct inferior_list_entry
*entry
, void *except
)
3770 struct lwp_info
*lwp
= (struct lwp_info
*) entry
;
3771 struct thread_info
*thread
;
3779 "proceed_one_lwp: lwp %ld\n", lwpid_of (lwp
));
3784 fprintf (stderr
, " LWP %ld already running\n", lwpid_of (lwp
));
3788 thread
= get_lwp_thread (lwp
);
3790 if (thread
->last_resume_kind
== resume_stop
3791 && thread
->last_status
.kind
!= TARGET_WAITKIND_IGNORE
)
3794 fprintf (stderr
, " client wants LWP to remain %ld stopped\n",
3799 if (lwp
->status_pending_p
)
3802 fprintf (stderr
, " LWP %ld has pending status, leaving stopped\n",
3807 gdb_assert (lwp
->suspended
>= 0);
3812 fprintf (stderr
, " LWP %ld is suspended\n", lwpid_of (lwp
));
3816 if (thread
->last_resume_kind
== resume_stop
3817 && lwp
->pending_signals_to_report
== NULL
3818 && lwp
->collecting_fast_tracepoint
== 0)
3820 /* We haven't reported this LWP as stopped yet (otherwise, the
3821 last_status.kind check above would catch it, and we wouldn't
3822 reach here. This LWP may have been momentarily paused by a
3823 stop_all_lwps call while handling for example, another LWP's
3824 step-over. In that case, the pending expected SIGSTOP signal
3825 that was queued at vCont;t handling time will have already
3826 been consumed by wait_for_sigstop, and so we need to requeue
3827 another one here. Note that if the LWP already has a SIGSTOP
3828 pending, this is a no-op. */
3832 "Client wants LWP %ld to stop. "
3833 "Making sure it has a SIGSTOP pending\n",
3839 step
= thread
->last_resume_kind
== resume_step
;
3840 linux_resume_one_lwp (lwp
, step
, 0, NULL
);
3845 unsuspend_and_proceed_one_lwp (struct inferior_list_entry
*entry
, void *except
)
3847 struct lwp_info
*lwp
= (struct lwp_info
*) entry
;
3853 gdb_assert (lwp
->suspended
>= 0);
3855 return proceed_one_lwp (entry
, except
);
3858 /* When we finish a step-over, set threads running again. If there's
3859 another thread that may need a step-over, now's the time to start
3860 it. Eventually, we'll move all threads past their breakpoints. */
3863 proceed_all_lwps (void)
3865 struct lwp_info
*need_step_over
;
3867 /* If there is a thread which would otherwise be resumed, which is
3868 stopped at a breakpoint that needs stepping over, then don't
3869 resume any threads - have it step over the breakpoint with all
3870 other threads stopped, then resume all threads again. */
3872 if (supports_breakpoints ())
3875 = (struct lwp_info
*) find_inferior (&all_lwps
,
3876 need_step_over_p
, NULL
);
3878 if (need_step_over
!= NULL
)
3881 fprintf (stderr
, "proceed_all_lwps: found "
3882 "thread %ld needing a step-over\n",
3883 lwpid_of (need_step_over
));
3885 start_step_over (need_step_over
);
3891 fprintf (stderr
, "Proceeding, no step-over needed\n");
3893 find_inferior (&all_lwps
, proceed_one_lwp
, NULL
);
3896 /* Stopped LWPs that the client wanted to be running, that don't have
3897 pending statuses, are set to run again, except for EXCEPT, if not
3898 NULL. This undoes a stop_all_lwps call. */
3901 unstop_all_lwps (int unsuspend
, struct lwp_info
*except
)
3907 "unstopping all lwps, except=(LWP %ld)\n", lwpid_of (except
));
3910 "unstopping all lwps\n");
3914 find_inferior (&all_lwps
, unsuspend_and_proceed_one_lwp
, except
);
3916 find_inferior (&all_lwps
, proceed_one_lwp
, except
);
3920 #ifdef HAVE_LINUX_REGSETS
3922 #define use_linux_regsets 1
3925 regsets_fetch_inferior_registers (struct regcache
*regcache
)
3927 struct regset_info
*regset
;
3928 int saw_general_regs
= 0;
3932 regset
= target_regsets
;
3934 pid
= lwpid_of (get_thread_lwp (current_inferior
));
3935 while (regset
->size
>= 0)
3940 if (regset
->size
== 0 || disabled_regsets
[regset
- target_regsets
])
3946 buf
= xmalloc (regset
->size
);
3948 nt_type
= regset
->nt_type
;
3952 iov
.iov_len
= regset
->size
;
3953 data
= (void *) &iov
;
3959 res
= ptrace (regset
->get_request
, pid
, nt_type
, data
);
3961 res
= ptrace (regset
->get_request
, pid
, data
, nt_type
);
3967 /* If we get EIO on a regset, do not try it again for
3969 disabled_regsets
[regset
- target_regsets
] = 1;
3976 sprintf (s
, "ptrace(regsets_fetch_inferior_registers) PID=%d",
3981 else if (regset
->type
== GENERAL_REGS
)
3982 saw_general_regs
= 1;
3983 regset
->store_function (regcache
, buf
);
3987 if (saw_general_regs
)
3994 regsets_store_inferior_registers (struct regcache
*regcache
)
3996 struct regset_info
*regset
;
3997 int saw_general_regs
= 0;
4001 regset
= target_regsets
;
4003 pid
= lwpid_of (get_thread_lwp (current_inferior
));
4004 while (regset
->size
>= 0)
4009 if (regset
->size
== 0 || disabled_regsets
[regset
- target_regsets
])
4015 buf
= xmalloc (regset
->size
);
4017 /* First fill the buffer with the current register set contents,
4018 in case there are any items in the kernel's regset that are
4019 not in gdbserver's regcache. */
4021 nt_type
= regset
->nt_type
;
4025 iov
.iov_len
= regset
->size
;
4026 data
= (void *) &iov
;
4032 res
= ptrace (regset
->get_request
, pid
, nt_type
, data
);
4034 res
= ptrace (regset
->get_request
, pid
, &iov
, data
);
4039 /* Then overlay our cached registers on that. */
4040 regset
->fill_function (regcache
, buf
);
4042 /* Only now do we write the register set. */
4044 res
= ptrace (regset
->set_request
, pid
, nt_type
, data
);
4046 res
= ptrace (regset
->set_request
, pid
, data
, nt_type
);
4054 /* If we get EIO on a regset, do not try it again for
4056 disabled_regsets
[regset
- target_regsets
] = 1;
4060 else if (errno
== ESRCH
)
4062 /* At this point, ESRCH should mean the process is
4063 already gone, in which case we simply ignore attempts
4064 to change its registers. See also the related
4065 comment in linux_resume_one_lwp. */
4071 perror ("Warning: ptrace(regsets_store_inferior_registers)");
4074 else if (regset
->type
== GENERAL_REGS
)
4075 saw_general_regs
= 1;
4079 if (saw_general_regs
)
4085 #else /* !HAVE_LINUX_REGSETS */
4087 #define use_linux_regsets 0
4088 #define regsets_fetch_inferior_registers(regcache) 1
4089 #define regsets_store_inferior_registers(regcache) 1
4093 /* Return 1 if register REGNO is supported by one of the regset ptrace
4094 calls or 0 if it has to be transferred individually. */
4097 linux_register_in_regsets (int regno
)
4099 unsigned char mask
= 1 << (regno
% 8);
4100 size_t index
= regno
/ 8;
4102 return (use_linux_regsets
4103 && (the_low_target
.regset_bitmap
== NULL
4104 || (the_low_target
.regset_bitmap
[index
] & mask
) != 0));
4107 #ifdef HAVE_LINUX_USRREGS
4110 register_addr (int regnum
)
4114 if (regnum
< 0 || regnum
>= the_low_target
.num_regs
)
4115 error ("Invalid register number %d.", regnum
);
4117 addr
= the_low_target
.regmap
[regnum
];
4122 /* Fetch one register. */
4124 fetch_register (struct regcache
*regcache
, int regno
)
4131 if (regno
>= the_low_target
.num_regs
)
4133 if ((*the_low_target
.cannot_fetch_register
) (regno
))
4136 regaddr
= register_addr (regno
);
4140 size
= ((register_size (regno
) + sizeof (PTRACE_XFER_TYPE
) - 1)
4141 & -sizeof (PTRACE_XFER_TYPE
));
4142 buf
= alloca (size
);
4144 pid
= lwpid_of (get_thread_lwp (current_inferior
));
4145 for (i
= 0; i
< size
; i
+= sizeof (PTRACE_XFER_TYPE
))
4148 *(PTRACE_XFER_TYPE
*) (buf
+ i
) =
4149 ptrace (PTRACE_PEEKUSER
, pid
,
4150 /* Coerce to a uintptr_t first to avoid potential gcc warning
4151 of coercing an 8 byte integer to a 4 byte pointer. */
4152 (PTRACE_ARG3_TYPE
) (uintptr_t) regaddr
, 0);
4153 regaddr
+= sizeof (PTRACE_XFER_TYPE
);
4155 error ("reading register %d: %s", regno
, strerror (errno
));
4158 if (the_low_target
.supply_ptrace_register
)
4159 the_low_target
.supply_ptrace_register (regcache
, regno
, buf
);
4161 supply_register (regcache
, regno
, buf
);
4164 /* Store one register. */
4166 store_register (struct regcache
*regcache
, int regno
)
4173 if (regno
>= the_low_target
.num_regs
)
4175 if ((*the_low_target
.cannot_store_register
) (regno
))
4178 regaddr
= register_addr (regno
);
4182 size
= ((register_size (regno
) + sizeof (PTRACE_XFER_TYPE
) - 1)
4183 & -sizeof (PTRACE_XFER_TYPE
));
4184 buf
= alloca (size
);
4185 memset (buf
, 0, size
);
4187 if (the_low_target
.collect_ptrace_register
)
4188 the_low_target
.collect_ptrace_register (regcache
, regno
, buf
);
4190 collect_register (regcache
, regno
, buf
);
4192 pid
= lwpid_of (get_thread_lwp (current_inferior
));
4193 for (i
= 0; i
< size
; i
+= sizeof (PTRACE_XFER_TYPE
))
4196 ptrace (PTRACE_POKEUSER
, pid
,
4197 /* Coerce to a uintptr_t first to avoid potential gcc warning
4198 about coercing an 8 byte integer to a 4 byte pointer. */
4199 (PTRACE_ARG3_TYPE
) (uintptr_t) regaddr
,
4200 (PTRACE_ARG4_TYPE
) *(PTRACE_XFER_TYPE
*) (buf
+ i
));
4203 /* At this point, ESRCH should mean the process is
4204 already gone, in which case we simply ignore attempts
4205 to change its registers. See also the related
4206 comment in linux_resume_one_lwp. */
4210 if ((*the_low_target
.cannot_store_register
) (regno
) == 0)
4211 error ("writing register %d: %s", regno
, strerror (errno
));
4213 regaddr
+= sizeof (PTRACE_XFER_TYPE
);
4217 /* Fetch all registers, or just one, from the child process.
4218 If REGNO is -1, do this for all registers, skipping any that are
4219 assumed to have been retrieved by regsets_fetch_inferior_registers,
4220 unless ALL is non-zero.
4221 Otherwise, REGNO specifies which register (so we can save time). */
4223 usr_fetch_inferior_registers (struct regcache
*regcache
, int regno
, int all
)
4227 for (regno
= 0; regno
< the_low_target
.num_regs
; regno
++)
4228 if (all
|| !linux_register_in_regsets (regno
))
4229 fetch_register (regcache
, regno
);
4232 fetch_register (regcache
, regno
);
4235 /* Store our register values back into the inferior.
4236 If REGNO is -1, do this for all registers, skipping any that are
4237 assumed to have been saved by regsets_store_inferior_registers,
4238 unless ALL is non-zero.
4239 Otherwise, REGNO specifies which register (so we can save time). */
4241 usr_store_inferior_registers (struct regcache
*regcache
, int regno
, int all
)
4245 for (regno
= 0; regno
< the_low_target
.num_regs
; regno
++)
4246 if (all
|| !linux_register_in_regsets (regno
))
4247 store_register (regcache
, regno
);
4250 store_register (regcache
, regno
);
4253 #else /* !HAVE_LINUX_USRREGS */
4255 #define usr_fetch_inferior_registers(regcache, regno, all) do {} while (0)
4256 #define usr_store_inferior_registers(regcache, regno, all) do {} while (0)
4262 linux_fetch_registers (struct regcache
*regcache
, int regno
)
4269 all
= regsets_fetch_inferior_registers (regcache
);
4270 usr_fetch_inferior_registers (regcache
, regno
, all
);
4274 use_regsets
= linux_register_in_regsets (regno
);
4276 all
= regsets_fetch_inferior_registers (regcache
);
4277 if (!use_regsets
|| all
)
4278 usr_fetch_inferior_registers (regcache
, regno
, 1);
4283 linux_store_registers (struct regcache
*regcache
, int regno
)
4290 all
= regsets_store_inferior_registers (regcache
);
4291 usr_store_inferior_registers (regcache
, regno
, all
);
4295 use_regsets
= linux_register_in_regsets (regno
);
4297 all
= regsets_store_inferior_registers (regcache
);
4298 if (!use_regsets
|| all
)
4299 usr_store_inferior_registers (regcache
, regno
, 1);
4304 /* Copy LEN bytes from inferior's memory starting at MEMADDR
4305 to debugger memory starting at MYADDR. */
4308 linux_read_memory (CORE_ADDR memaddr
, unsigned char *myaddr
, int len
)
4311 /* Round starting address down to longword boundary. */
4312 register CORE_ADDR addr
= memaddr
& -(CORE_ADDR
) sizeof (PTRACE_XFER_TYPE
);
4313 /* Round ending address up; get number of longwords that makes. */
4315 = (((memaddr
+ len
) - addr
) + sizeof (PTRACE_XFER_TYPE
) - 1)
4316 / sizeof (PTRACE_XFER_TYPE
);
4317 /* Allocate buffer of that many longwords. */
4318 register PTRACE_XFER_TYPE
*buffer
4319 = (PTRACE_XFER_TYPE
*) alloca (count
* sizeof (PTRACE_XFER_TYPE
));
4322 int pid
= lwpid_of (get_thread_lwp (current_inferior
));
4324 /* Try using /proc. Don't bother for one word. */
4325 if (len
>= 3 * sizeof (long))
4327 /* We could keep this file open and cache it - possibly one per
4328 thread. That requires some juggling, but is even faster. */
4329 sprintf (filename
, "/proc/%d/mem", pid
);
4330 fd
= open (filename
, O_RDONLY
| O_LARGEFILE
);
4334 /* If pread64 is available, use it. It's faster if the kernel
4335 supports it (only one syscall), and it's 64-bit safe even on
4336 32-bit platforms (for instance, SPARC debugging a SPARC64
4339 if (pread64 (fd
, myaddr
, len
, memaddr
) != len
)
4341 if (lseek (fd
, memaddr
, SEEK_SET
) == -1 || read (fd
, myaddr
, len
) != len
)
4353 /* Read all the longwords */
4354 for (i
= 0; i
< count
; i
++, addr
+= sizeof (PTRACE_XFER_TYPE
))
4357 /* Coerce the 3rd arg to a uintptr_t first to avoid potential gcc warning
4358 about coercing an 8 byte integer to a 4 byte pointer. */
4359 buffer
[i
] = ptrace (PTRACE_PEEKTEXT
, pid
,
4360 (PTRACE_ARG3_TYPE
) (uintptr_t) addr
, 0);
4365 /* Copy appropriate bytes out of the buffer. */
4367 (char *) buffer
+ (memaddr
& (sizeof (PTRACE_XFER_TYPE
) - 1)),
4373 /* Copy LEN bytes of data from debugger memory at MYADDR to inferior's
4374 memory at MEMADDR. On failure (cannot write to the inferior)
4375 returns the value of errno. */
4378 linux_write_memory (CORE_ADDR memaddr
, const unsigned char *myaddr
, int len
)
4381 /* Round starting address down to longword boundary. */
4382 register CORE_ADDR addr
= memaddr
& -(CORE_ADDR
) sizeof (PTRACE_XFER_TYPE
);
4383 /* Round ending address up; get number of longwords that makes. */
4385 = (((memaddr
+ len
) - addr
) + sizeof (PTRACE_XFER_TYPE
) - 1)
4386 / sizeof (PTRACE_XFER_TYPE
);
4388 /* Allocate buffer of that many longwords. */
4389 register PTRACE_XFER_TYPE
*buffer
= (PTRACE_XFER_TYPE
*)
4390 alloca (count
* sizeof (PTRACE_XFER_TYPE
));
4392 int pid
= lwpid_of (get_thread_lwp (current_inferior
));
4396 /* Dump up to four bytes. */
4397 unsigned int val
= * (unsigned int *) myaddr
;
4403 val
= val
& 0xffffff;
4404 fprintf (stderr
, "Writing %0*x to 0x%08lx\n", 2 * ((len
< 4) ? len
: 4),
4405 val
, (long)memaddr
);
4408 /* Fill start and end extra bytes of buffer with existing memory data. */
4411 /* Coerce the 3rd arg to a uintptr_t first to avoid potential gcc warning
4412 about coercing an 8 byte integer to a 4 byte pointer. */
4413 buffer
[0] = ptrace (PTRACE_PEEKTEXT
, pid
,
4414 (PTRACE_ARG3_TYPE
) (uintptr_t) addr
, 0);
4422 = ptrace (PTRACE_PEEKTEXT
, pid
,
4423 /* Coerce to a uintptr_t first to avoid potential gcc warning
4424 about coercing an 8 byte integer to a 4 byte pointer. */
4425 (PTRACE_ARG3_TYPE
) (uintptr_t) (addr
+ (count
- 1)
4426 * sizeof (PTRACE_XFER_TYPE
)),
4432 /* Copy data to be written over corresponding part of buffer. */
4434 memcpy ((char *) buffer
+ (memaddr
& (sizeof (PTRACE_XFER_TYPE
) - 1)),
4437 /* Write the entire buffer. */
4439 for (i
= 0; i
< count
; i
++, addr
+= sizeof (PTRACE_XFER_TYPE
))
4442 ptrace (PTRACE_POKETEXT
, pid
,
4443 /* Coerce to a uintptr_t first to avoid potential gcc warning
4444 about coercing an 8 byte integer to a 4 byte pointer. */
4445 (PTRACE_ARG3_TYPE
) (uintptr_t) addr
,
4446 (PTRACE_ARG4_TYPE
) buffer
[i
]);
4454 /* Non-zero if the kernel supports PTRACE_O_TRACEFORK. */
4455 static int linux_supports_tracefork_flag
;
4458 linux_enable_event_reporting (int pid
)
4460 if (!linux_supports_tracefork_flag
)
4463 ptrace (PTRACE_SETOPTIONS
, pid
, 0, (PTRACE_ARG4_TYPE
) PTRACE_O_TRACECLONE
);
4466 /* Helper functions for linux_test_for_tracefork, called via clone (). */
4469 linux_tracefork_grandchild (void *arg
)
4474 #define STACK_SIZE 4096
4477 linux_tracefork_child (void *arg
)
4479 ptrace (PTRACE_TRACEME
, 0, 0, 0);
4480 kill (getpid (), SIGSTOP
);
4482 #if !(defined(__UCLIBC__) && defined(HAS_NOMMU))
4485 linux_tracefork_grandchild (NULL
);
4487 #else /* defined(__UCLIBC__) && defined(HAS_NOMMU) */
4490 __clone2 (linux_tracefork_grandchild
, arg
, STACK_SIZE
,
4491 CLONE_VM
| SIGCHLD
, NULL
);
4493 clone (linux_tracefork_grandchild
, (char *) arg
+ STACK_SIZE
,
4494 CLONE_VM
| SIGCHLD
, NULL
);
4497 #endif /* defined(__UCLIBC__) && defined(HAS_NOMMU) */
4502 /* Determine if PTRACE_O_TRACEFORK can be used to follow fork events. Make
4503 sure that we can enable the option, and that it had the desired
4507 linux_test_for_tracefork (void)
4509 int child_pid
, ret
, status
;
4511 #if defined(__UCLIBC__) && defined(HAS_NOMMU)
4512 char *stack
= xmalloc (STACK_SIZE
* 4);
4513 #endif /* defined(__UCLIBC__) && defined(HAS_NOMMU) */
4515 linux_supports_tracefork_flag
= 0;
4517 #if !(defined(__UCLIBC__) && defined(HAS_NOMMU))
4519 child_pid
= fork ();
4521 linux_tracefork_child (NULL
);
4523 #else /* defined(__UCLIBC__) && defined(HAS_NOMMU) */
4525 /* Use CLONE_VM instead of fork, to support uClinux (no MMU). */
4527 child_pid
= __clone2 (linux_tracefork_child
, stack
, STACK_SIZE
,
4528 CLONE_VM
| SIGCHLD
, stack
+ STACK_SIZE
* 2);
4529 #else /* !__ia64__ */
4530 child_pid
= clone (linux_tracefork_child
, stack
+ STACK_SIZE
,
4531 CLONE_VM
| SIGCHLD
, stack
+ STACK_SIZE
* 2);
4532 #endif /* !__ia64__ */
4534 #endif /* defined(__UCLIBC__) && defined(HAS_NOMMU) */
4536 if (child_pid
== -1)
4537 perror_with_name ("clone");
4539 ret
= my_waitpid (child_pid
, &status
, 0);
4541 perror_with_name ("waitpid");
4542 else if (ret
!= child_pid
)
4543 error ("linux_test_for_tracefork: waitpid: unexpected result %d.", ret
);
4544 if (! WIFSTOPPED (status
))
4545 error ("linux_test_for_tracefork: waitpid: unexpected status %d.", status
);
4547 ret
= ptrace (PTRACE_SETOPTIONS
, child_pid
, 0,
4548 (PTRACE_ARG4_TYPE
) PTRACE_O_TRACEFORK
);
4551 ret
= ptrace (PTRACE_KILL
, child_pid
, 0, 0);
4554 warning ("linux_test_for_tracefork: failed to kill child");
4558 ret
= my_waitpid (child_pid
, &status
, 0);
4559 if (ret
!= child_pid
)
4560 warning ("linux_test_for_tracefork: failed to wait for killed child");
4561 else if (!WIFSIGNALED (status
))
4562 warning ("linux_test_for_tracefork: unexpected wait status 0x%x from "
4563 "killed child", status
);
4568 ret
= ptrace (PTRACE_CONT
, child_pid
, 0, 0);
4570 warning ("linux_test_for_tracefork: failed to resume child");
4572 ret
= my_waitpid (child_pid
, &status
, 0);
4574 if (ret
== child_pid
&& WIFSTOPPED (status
)
4575 && status
>> 16 == PTRACE_EVENT_FORK
)
4578 ret
= ptrace (PTRACE_GETEVENTMSG
, child_pid
, 0, &second_pid
);
4579 if (ret
== 0 && second_pid
!= 0)
4583 linux_supports_tracefork_flag
= 1;
4584 my_waitpid (second_pid
, &second_status
, 0);
4585 ret
= ptrace (PTRACE_KILL
, second_pid
, 0, 0);
4587 warning ("linux_test_for_tracefork: failed to kill second child");
4588 my_waitpid (second_pid
, &status
, 0);
4592 warning ("linux_test_for_tracefork: unexpected result from waitpid "
4593 "(%d, status 0x%x)", ret
, status
);
4597 ret
= ptrace (PTRACE_KILL
, child_pid
, 0, 0);
4599 warning ("linux_test_for_tracefork: failed to kill child");
4600 my_waitpid (child_pid
, &status
, 0);
4602 while (WIFSTOPPED (status
));
4604 #if defined(__UCLIBC__) && defined(HAS_NOMMU)
4606 #endif /* defined(__UCLIBC__) && defined(HAS_NOMMU) */
4611 linux_look_up_symbols (void)
4613 #ifdef USE_THREAD_DB
4614 struct process_info
*proc
= current_process ();
4616 if (proc
->private->thread_db
!= NULL
)
4619 /* If the kernel supports tracing forks then it also supports tracing
4620 clones, and then we don't need to use the magic thread event breakpoint
4621 to learn about threads. */
4622 thread_db_init (!linux_supports_tracefork_flag
);
4627 linux_request_interrupt (void)
4629 extern unsigned long signal_pid
;
4631 if (!ptid_equal (cont_thread
, null_ptid
)
4632 && !ptid_equal (cont_thread
, minus_one_ptid
))
4634 struct lwp_info
*lwp
;
4637 lwp
= get_thread_lwp (current_inferior
);
4638 lwpid
= lwpid_of (lwp
);
4639 kill_lwp (lwpid
, SIGINT
);
4642 kill_lwp (signal_pid
, SIGINT
);
4645 /* Copy LEN bytes from inferior's auxiliary vector starting at OFFSET
4646 to debugger memory starting at MYADDR. */
4649 linux_read_auxv (CORE_ADDR offset
, unsigned char *myaddr
, unsigned int len
)
4651 char filename
[PATH_MAX
];
4653 int pid
= lwpid_of (get_thread_lwp (current_inferior
));
4655 xsnprintf (filename
, sizeof filename
, "/proc/%d/auxv", pid
);
4657 fd
= open (filename
, O_RDONLY
);
4661 if (offset
!= (CORE_ADDR
) 0
4662 && lseek (fd
, (off_t
) offset
, SEEK_SET
) != (off_t
) offset
)
4665 n
= read (fd
, myaddr
, len
);
4672 /* These breakpoint and watchpoint related wrapper functions simply
4673 pass on the function call if the target has registered a
4674 corresponding function. */
4677 linux_insert_point (char type
, CORE_ADDR addr
, int len
)
4679 if (the_low_target
.insert_point
!= NULL
)
4680 return the_low_target
.insert_point (type
, addr
, len
);
4682 /* Unsupported (see target.h). */
4687 linux_remove_point (char type
, CORE_ADDR addr
, int len
)
4689 if (the_low_target
.remove_point
!= NULL
)
4690 return the_low_target
.remove_point (type
, addr
, len
);
4692 /* Unsupported (see target.h). */
4697 linux_stopped_by_watchpoint (void)
4699 struct lwp_info
*lwp
= get_thread_lwp (current_inferior
);
4701 return lwp
->stopped_by_watchpoint
;
4705 linux_stopped_data_address (void)
4707 struct lwp_info
*lwp
= get_thread_lwp (current_inferior
);
4709 return lwp
->stopped_data_address
;
4712 #if defined(__UCLIBC__) && defined(HAS_NOMMU)
4713 #if defined(__mcoldfire__)
4714 /* These should really be defined in the kernel's ptrace.h header. */
4715 #define PT_TEXT_ADDR 49*4
4716 #define PT_DATA_ADDR 50*4
4717 #define PT_TEXT_END_ADDR 51*4
4719 #define PT_TEXT_ADDR 220
4720 #define PT_TEXT_END_ADDR 224
4721 #define PT_DATA_ADDR 228
4722 #elif defined(__TMS320C6X__)
4723 #define PT_TEXT_ADDR (0x10000*4)
4724 #define PT_DATA_ADDR (0x10004*4)
4725 #define PT_TEXT_END_ADDR (0x10008*4)
4728 /* Under uClinux, programs are loaded at non-zero offsets, which we need
4729 to tell gdb about. */
4732 linux_read_offsets (CORE_ADDR
*text_p
, CORE_ADDR
*data_p
)
4734 #if defined(PT_TEXT_ADDR) && defined(PT_DATA_ADDR) && defined(PT_TEXT_END_ADDR)
4735 unsigned long text
, text_end
, data
;
4736 int pid
= lwpid_of (get_thread_lwp (current_inferior
));
4740 text
= ptrace (PTRACE_PEEKUSER
, pid
, (long)PT_TEXT_ADDR
, 0);
4741 text_end
= ptrace (PTRACE_PEEKUSER
, pid
, (long)PT_TEXT_END_ADDR
, 0);
4742 data
= ptrace (PTRACE_PEEKUSER
, pid
, (long)PT_DATA_ADDR
, 0);
4746 /* Both text and data offsets produced at compile-time (and so
4747 used by gdb) are relative to the beginning of the program,
4748 with the data segment immediately following the text segment.
4749 However, the actual runtime layout in memory may put the data
4750 somewhere else, so when we send gdb a data base-address, we
4751 use the real data base address and subtract the compile-time
4752 data base-address from it (which is just the length of the
4753 text segment). BSS immediately follows data in both
4756 *data_p
= data
- (text_end
- text
);
4766 linux_qxfer_osdata (const char *annex
,
4767 unsigned char *readbuf
, unsigned const char *writebuf
,
4768 CORE_ADDR offset
, int len
)
4770 return linux_common_xfer_osdata (annex
, readbuf
, offset
, len
);
4773 /* Convert a native/host siginfo object, into/from the siginfo in the
4774 layout of the inferiors' architecture. */
4777 siginfo_fixup (struct siginfo
*siginfo
, void *inf_siginfo
, int direction
)
4781 if (the_low_target
.siginfo_fixup
!= NULL
)
4782 done
= the_low_target
.siginfo_fixup (siginfo
, inf_siginfo
, direction
);
4784 /* If there was no callback, or the callback didn't do anything,
4785 then just do a straight memcpy. */
4789 memcpy (siginfo
, inf_siginfo
, sizeof (struct siginfo
));
4791 memcpy (inf_siginfo
, siginfo
, sizeof (struct siginfo
));
4796 linux_xfer_siginfo (const char *annex
, unsigned char *readbuf
,
4797 unsigned const char *writebuf
, CORE_ADDR offset
, int len
)
4800 struct siginfo siginfo
;
4801 char inf_siginfo
[sizeof (struct siginfo
)];
4803 if (current_inferior
== NULL
)
4806 pid
= lwpid_of (get_thread_lwp (current_inferior
));
4809 fprintf (stderr
, "%s siginfo for lwp %d.\n",
4810 readbuf
!= NULL
? "Reading" : "Writing",
4813 if (offset
>= sizeof (siginfo
))
4816 if (ptrace (PTRACE_GETSIGINFO
, pid
, 0, &siginfo
) != 0)
4819 /* When GDBSERVER is built as a 64-bit application, ptrace writes into
4820 SIGINFO an object with 64-bit layout. Since debugging a 32-bit
4821 inferior with a 64-bit GDBSERVER should look the same as debugging it
4822 with a 32-bit GDBSERVER, we need to convert it. */
4823 siginfo_fixup (&siginfo
, inf_siginfo
, 0);
4825 if (offset
+ len
> sizeof (siginfo
))
4826 len
= sizeof (siginfo
) - offset
;
4828 if (readbuf
!= NULL
)
4829 memcpy (readbuf
, inf_siginfo
+ offset
, len
);
4832 memcpy (inf_siginfo
+ offset
, writebuf
, len
);
4834 /* Convert back to ptrace layout before flushing it out. */
4835 siginfo_fixup (&siginfo
, inf_siginfo
, 1);
4837 if (ptrace (PTRACE_SETSIGINFO
, pid
, 0, &siginfo
) != 0)
4844 /* SIGCHLD handler that serves two purposes: In non-stop/async mode,
4845 so we notice when children change state; as the handler for the
4846 sigsuspend in my_waitpid. */
4849 sigchld_handler (int signo
)
4851 int old_errno
= errno
;
4857 /* fprintf is not async-signal-safe, so call write
4859 if (write (2, "sigchld_handler\n",
4860 sizeof ("sigchld_handler\n") - 1) < 0)
4861 break; /* just ignore */
4865 if (target_is_async_p ())
4866 async_file_mark (); /* trigger a linux_wait */
4872 linux_supports_non_stop (void)
4878 linux_async (int enable
)
4880 int previous
= (linux_event_pipe
[0] != -1);
4883 fprintf (stderr
, "linux_async (%d), previous=%d\n",
4886 if (previous
!= enable
)
4889 sigemptyset (&mask
);
4890 sigaddset (&mask
, SIGCHLD
);
4892 sigprocmask (SIG_BLOCK
, &mask
, NULL
);
4896 if (pipe (linux_event_pipe
) == -1)
4897 fatal ("creating event pipe failed.");
4899 fcntl (linux_event_pipe
[0], F_SETFL
, O_NONBLOCK
);
4900 fcntl (linux_event_pipe
[1], F_SETFL
, O_NONBLOCK
);
4902 /* Register the event loop handler. */
4903 add_file_handler (linux_event_pipe
[0],
4904 handle_target_event
, NULL
);
4906 /* Always trigger a linux_wait. */
4911 delete_file_handler (linux_event_pipe
[0]);
4913 close (linux_event_pipe
[0]);
4914 close (linux_event_pipe
[1]);
4915 linux_event_pipe
[0] = -1;
4916 linux_event_pipe
[1] = -1;
4919 sigprocmask (SIG_UNBLOCK
, &mask
, NULL
);
4926 linux_start_non_stop (int nonstop
)
4928 /* Register or unregister from event-loop accordingly. */
4929 linux_async (nonstop
);
4934 linux_supports_multi_process (void)
4940 linux_supports_disable_randomization (void)
4942 #ifdef HAVE_PERSONALITY
4950 linux_supports_agent (void)
4955 /* Enumerate spufs IDs for process PID. */
4957 spu_enumerate_spu_ids (long pid
, unsigned char *buf
, CORE_ADDR offset
, int len
)
4963 struct dirent
*entry
;
4965 sprintf (path
, "/proc/%ld/fd", pid
);
4966 dir
= opendir (path
);
4971 while ((entry
= readdir (dir
)) != NULL
)
4977 fd
= atoi (entry
->d_name
);
4981 sprintf (path
, "/proc/%ld/fd/%d", pid
, fd
);
4982 if (stat (path
, &st
) != 0)
4984 if (!S_ISDIR (st
.st_mode
))
4987 if (statfs (path
, &stfs
) != 0)
4989 if (stfs
.f_type
!= SPUFS_MAGIC
)
4992 if (pos
>= offset
&& pos
+ 4 <= offset
+ len
)
4994 *(unsigned int *)(buf
+ pos
- offset
) = fd
;
5004 /* Implements the to_xfer_partial interface for the TARGET_OBJECT_SPU
5005 object type, using the /proc file system. */
5007 linux_qxfer_spu (const char *annex
, unsigned char *readbuf
,
5008 unsigned const char *writebuf
,
5009 CORE_ADDR offset
, int len
)
5011 long pid
= lwpid_of (get_thread_lwp (current_inferior
));
5016 if (!writebuf
&& !readbuf
)
5024 return spu_enumerate_spu_ids (pid
, readbuf
, offset
, len
);
5027 sprintf (buf
, "/proc/%ld/fd/%s", pid
, annex
);
5028 fd
= open (buf
, writebuf
? O_WRONLY
: O_RDONLY
);
5033 && lseek (fd
, (off_t
) offset
, SEEK_SET
) != (off_t
) offset
)
5040 ret
= write (fd
, writebuf
, (size_t) len
);
5042 ret
= read (fd
, readbuf
, (size_t) len
);
5048 #if defined PT_GETDSBT || defined PTRACE_GETFDPIC
5049 struct target_loadseg
5051 /* Core address to which the segment is mapped. */
5053 /* VMA recorded in the program header. */
5055 /* Size of this segment in memory. */
5059 # if defined PT_GETDSBT
5060 struct target_loadmap
5062 /* Protocol version number, must be zero. */
5064 /* Pointer to the DSBT table, its size, and the DSBT index. */
5065 unsigned *dsbt_table
;
5066 unsigned dsbt_size
, dsbt_index
;
5067 /* Number of segments in this map. */
5069 /* The actual memory map. */
5070 struct target_loadseg segs
[/*nsegs*/];
5072 # define LINUX_LOADMAP PT_GETDSBT
5073 # define LINUX_LOADMAP_EXEC PTRACE_GETDSBT_EXEC
5074 # define LINUX_LOADMAP_INTERP PTRACE_GETDSBT_INTERP
5076 struct target_loadmap
5078 /* Protocol version number, must be zero. */
5080 /* Number of segments in this map. */
5082 /* The actual memory map. */
5083 struct target_loadseg segs
[/*nsegs*/];
5085 # define LINUX_LOADMAP PTRACE_GETFDPIC
5086 # define LINUX_LOADMAP_EXEC PTRACE_GETFDPIC_EXEC
5087 # define LINUX_LOADMAP_INTERP PTRACE_GETFDPIC_INTERP
5091 linux_read_loadmap (const char *annex
, CORE_ADDR offset
,
5092 unsigned char *myaddr
, unsigned int len
)
5094 int pid
= lwpid_of (get_thread_lwp (current_inferior
));
5096 struct target_loadmap
*data
= NULL
;
5097 unsigned int actual_length
, copy_length
;
5099 if (strcmp (annex
, "exec") == 0)
5100 addr
= (int) LINUX_LOADMAP_EXEC
;
5101 else if (strcmp (annex
, "interp") == 0)
5102 addr
= (int) LINUX_LOADMAP_INTERP
;
5106 if (ptrace (LINUX_LOADMAP
, pid
, addr
, &data
) != 0)
5112 actual_length
= sizeof (struct target_loadmap
)
5113 + sizeof (struct target_loadseg
) * data
->nsegs
;
5115 if (offset
< 0 || offset
> actual_length
)
5118 copy_length
= actual_length
- offset
< len
? actual_length
- offset
: len
;
5119 memcpy (myaddr
, (char *) data
+ offset
, copy_length
);
5123 # define linux_read_loadmap NULL
5124 #endif /* defined PT_GETDSBT || defined PTRACE_GETFDPIC */
5127 linux_process_qsupported (const char *query
)
5129 if (the_low_target
.process_qsupported
!= NULL
)
5130 the_low_target
.process_qsupported (query
);
5134 linux_supports_tracepoints (void)
5136 if (*the_low_target
.supports_tracepoints
== NULL
)
5139 return (*the_low_target
.supports_tracepoints
) ();
5143 linux_read_pc (struct regcache
*regcache
)
5145 if (the_low_target
.get_pc
== NULL
)
5148 return (*the_low_target
.get_pc
) (regcache
);
5152 linux_write_pc (struct regcache
*regcache
, CORE_ADDR pc
)
5154 gdb_assert (the_low_target
.set_pc
!= NULL
);
5156 (*the_low_target
.set_pc
) (regcache
, pc
);
5160 linux_thread_stopped (struct thread_info
*thread
)
5162 return get_thread_lwp (thread
)->stopped
;
5165 /* This exposes stop-all-threads functionality to other modules. */
5168 linux_pause_all (int freeze
)
5170 stop_all_lwps (freeze
, NULL
);
5173 /* This exposes unstop-all-threads functionality to other gdbserver
5177 linux_unpause_all (int unfreeze
)
5179 unstop_all_lwps (unfreeze
, NULL
);
5183 linux_prepare_to_access_memory (void)
5185 /* Neither ptrace nor /proc/PID/mem allow accessing memory through a
5188 linux_pause_all (1);
5193 linux_done_accessing_memory (void)
5195 /* Neither ptrace nor /proc/PID/mem allow accessing memory through a
5198 linux_unpause_all (1);
5202 linux_install_fast_tracepoint_jump_pad (CORE_ADDR tpoint
, CORE_ADDR tpaddr
,
5203 CORE_ADDR collector
,
5206 CORE_ADDR
*jump_entry
,
5207 CORE_ADDR
*trampoline
,
5208 ULONGEST
*trampoline_size
,
5209 unsigned char *jjump_pad_insn
,
5210 ULONGEST
*jjump_pad_insn_size
,
5211 CORE_ADDR
*adjusted_insn_addr
,
5212 CORE_ADDR
*adjusted_insn_addr_end
,
5215 return (*the_low_target
.install_fast_tracepoint_jump_pad
)
5216 (tpoint
, tpaddr
, collector
, lockaddr
, orig_size
,
5217 jump_entry
, trampoline
, trampoline_size
,
5218 jjump_pad_insn
, jjump_pad_insn_size
,
5219 adjusted_insn_addr
, adjusted_insn_addr_end
,
5223 static struct emit_ops
*
5224 linux_emit_ops (void)
5226 if (the_low_target
.emit_ops
!= NULL
)
5227 return (*the_low_target
.emit_ops
) ();
5233 linux_get_min_fast_tracepoint_insn_len (void)
5235 return (*the_low_target
.get_min_fast_tracepoint_insn_len
) ();
5238 /* Extract &phdr and num_phdr in the inferior. Return 0 on success. */
5241 get_phdr_phnum_from_proc_auxv (const int pid
, const int is_elf64
,
5242 CORE_ADDR
*phdr_memaddr
, int *num_phdr
)
5244 char filename
[PATH_MAX
];
5246 const int auxv_size
= is_elf64
5247 ? sizeof (Elf64_auxv_t
) : sizeof (Elf32_auxv_t
);
5248 char buf
[sizeof (Elf64_auxv_t
)]; /* The larger of the two. */
5250 xsnprintf (filename
, sizeof filename
, "/proc/%d/auxv", pid
);
5252 fd
= open (filename
, O_RDONLY
);
5258 while (read (fd
, buf
, auxv_size
) == auxv_size
5259 && (*phdr_memaddr
== 0 || *num_phdr
== 0))
5263 Elf64_auxv_t
*const aux
= (Elf64_auxv_t
*) buf
;
5265 switch (aux
->a_type
)
5268 *phdr_memaddr
= aux
->a_un
.a_val
;
5271 *num_phdr
= aux
->a_un
.a_val
;
5277 Elf32_auxv_t
*const aux
= (Elf32_auxv_t
*) buf
;
5279 switch (aux
->a_type
)
5282 *phdr_memaddr
= aux
->a_un
.a_val
;
5285 *num_phdr
= aux
->a_un
.a_val
;
5293 if (*phdr_memaddr
== 0 || *num_phdr
== 0)
5295 warning ("Unexpected missing AT_PHDR and/or AT_PHNUM: "
5296 "phdr_memaddr = %ld, phdr_num = %d",
5297 (long) *phdr_memaddr
, *num_phdr
);
5304 /* Return &_DYNAMIC (via PT_DYNAMIC) in the inferior, or 0 if not present. */
5307 get_dynamic (const int pid
, const int is_elf64
)
5309 CORE_ADDR phdr_memaddr
, relocation
;
5311 unsigned char *phdr_buf
;
5312 const int phdr_size
= is_elf64
? sizeof (Elf64_Phdr
) : sizeof (Elf32_Phdr
);
5314 if (get_phdr_phnum_from_proc_auxv (pid
, is_elf64
, &phdr_memaddr
, &num_phdr
))
5317 gdb_assert (num_phdr
< 100); /* Basic sanity check. */
5318 phdr_buf
= alloca (num_phdr
* phdr_size
);
5320 if (linux_read_memory (phdr_memaddr
, phdr_buf
, num_phdr
* phdr_size
))
5323 /* Compute relocation: it is expected to be 0 for "regular" executables,
5324 non-zero for PIE ones. */
5326 for (i
= 0; relocation
== -1 && i
< num_phdr
; i
++)
5329 Elf64_Phdr
*const p
= (Elf64_Phdr
*) (phdr_buf
+ i
* phdr_size
);
5331 if (p
->p_type
== PT_PHDR
)
5332 relocation
= phdr_memaddr
- p
->p_vaddr
;
5336 Elf32_Phdr
*const p
= (Elf32_Phdr
*) (phdr_buf
+ i
* phdr_size
);
5338 if (p
->p_type
== PT_PHDR
)
5339 relocation
= phdr_memaddr
- p
->p_vaddr
;
5342 if (relocation
== -1)
5344 /* PT_PHDR is optional, but necessary for PIE in general. Fortunately
5345 any real world executables, including PIE executables, have always
5346 PT_PHDR present. PT_PHDR is not present in some shared libraries or
5347 in fpc (Free Pascal 2.4) binaries but neither of those have a need for
5348 or present DT_DEBUG anyway (fpc binaries are statically linked).
5350 Therefore if there exists DT_DEBUG there is always also PT_PHDR.
5352 GDB could find RELOCATION also from AT_ENTRY - e_entry. */
5357 for (i
= 0; i
< num_phdr
; i
++)
5361 Elf64_Phdr
*const p
= (Elf64_Phdr
*) (phdr_buf
+ i
* phdr_size
);
5363 if (p
->p_type
== PT_DYNAMIC
)
5364 return p
->p_vaddr
+ relocation
;
5368 Elf32_Phdr
*const p
= (Elf32_Phdr
*) (phdr_buf
+ i
* phdr_size
);
5370 if (p
->p_type
== PT_DYNAMIC
)
5371 return p
->p_vaddr
+ relocation
;
5378 /* Return &_r_debug in the inferior, or -1 if not present. Return value
5379 can be 0 if the inferior does not yet have the library list initialized. */
5382 get_r_debug (const int pid
, const int is_elf64
)
5384 CORE_ADDR dynamic_memaddr
;
5385 const int dyn_size
= is_elf64
? sizeof (Elf64_Dyn
) : sizeof (Elf32_Dyn
);
5386 unsigned char buf
[sizeof (Elf64_Dyn
)]; /* The larger of the two. */
5388 dynamic_memaddr
= get_dynamic (pid
, is_elf64
);
5389 if (dynamic_memaddr
== 0)
5390 return (CORE_ADDR
) -1;
5392 while (linux_read_memory (dynamic_memaddr
, buf
, dyn_size
) == 0)
5396 Elf64_Dyn
*const dyn
= (Elf64_Dyn
*) buf
;
5398 if (dyn
->d_tag
== DT_DEBUG
)
5399 return dyn
->d_un
.d_val
;
5401 if (dyn
->d_tag
== DT_NULL
)
5406 Elf32_Dyn
*const dyn
= (Elf32_Dyn
*) buf
;
5408 if (dyn
->d_tag
== DT_DEBUG
)
5409 return dyn
->d_un
.d_val
;
5411 if (dyn
->d_tag
== DT_NULL
)
5415 dynamic_memaddr
+= dyn_size
;
5418 return (CORE_ADDR
) -1;
5421 /* Read one pointer from MEMADDR in the inferior. */
5424 read_one_ptr (CORE_ADDR memaddr
, CORE_ADDR
*ptr
, int ptr_size
)
5427 return linux_read_memory (memaddr
, (unsigned char *) ptr
, ptr_size
);
5430 struct link_map_offsets
5432 /* Offset and size of r_debug.r_version. */
5433 int r_version_offset
;
5435 /* Offset and size of r_debug.r_map. */
5438 /* Offset to l_addr field in struct link_map. */
5441 /* Offset to l_name field in struct link_map. */
5444 /* Offset to l_ld field in struct link_map. */
5447 /* Offset to l_next field in struct link_map. */
5450 /* Offset to l_prev field in struct link_map. */
5454 /* Construct qXfer:libraries:read reply. */
5457 linux_qxfer_libraries_svr4 (const char *annex
, unsigned char *readbuf
,
5458 unsigned const char *writebuf
,
5459 CORE_ADDR offset
, int len
)
5462 unsigned document_len
;
5463 struct process_info_private
*const priv
= current_process ()->private;
5464 char filename
[PATH_MAX
];
5467 static const struct link_map_offsets lmo_32bit_offsets
=
5469 0, /* r_version offset. */
5470 4, /* r_debug.r_map offset. */
5471 0, /* l_addr offset in link_map. */
5472 4, /* l_name offset in link_map. */
5473 8, /* l_ld offset in link_map. */
5474 12, /* l_next offset in link_map. */
5475 16 /* l_prev offset in link_map. */
5478 static const struct link_map_offsets lmo_64bit_offsets
=
5480 0, /* r_version offset. */
5481 8, /* r_debug.r_map offset. */
5482 0, /* l_addr offset in link_map. */
5483 8, /* l_name offset in link_map. */
5484 16, /* l_ld offset in link_map. */
5485 24, /* l_next offset in link_map. */
5486 32 /* l_prev offset in link_map. */
5488 const struct link_map_offsets
*lmo
;
5490 if (writebuf
!= NULL
)
5492 if (readbuf
== NULL
)
5495 pid
= lwpid_of (get_thread_lwp (current_inferior
));
5496 xsnprintf (filename
, sizeof filename
, "/proc/%d/exe", pid
);
5497 is_elf64
= elf_64_file_p (filename
);
5498 lmo
= is_elf64
? &lmo_64bit_offsets
: &lmo_32bit_offsets
;
5500 if (priv
->r_debug
== 0)
5501 priv
->r_debug
= get_r_debug (pid
, is_elf64
);
5503 if (priv
->r_debug
== (CORE_ADDR
) -1 || priv
->r_debug
== 0)
5505 document
= xstrdup ("<library-list-svr4 version=\"1.0\"/>\n");
5509 int allocated
= 1024;
5511 const int ptr_size
= is_elf64
? 8 : 4;
5512 CORE_ADDR lm_addr
, lm_prev
, l_name
, l_addr
, l_ld
, l_next
, l_prev
;
5513 int r_version
, header_done
= 0;
5515 document
= xmalloc (allocated
);
5516 strcpy (document
, "<library-list-svr4 version=\"1.0\"");
5517 p
= document
+ strlen (document
);
5520 if (linux_read_memory (priv
->r_debug
+ lmo
->r_version_offset
,
5521 (unsigned char *) &r_version
,
5522 sizeof (r_version
)) != 0
5525 warning ("unexpected r_debug version %d", r_version
);
5529 if (read_one_ptr (priv
->r_debug
+ lmo
->r_map_offset
,
5530 &lm_addr
, ptr_size
) != 0)
5532 warning ("unable to read r_map from 0x%lx",
5533 (long) priv
->r_debug
+ lmo
->r_map_offset
);
5538 while (read_one_ptr (lm_addr
+ lmo
->l_name_offset
,
5539 &l_name
, ptr_size
) == 0
5540 && read_one_ptr (lm_addr
+ lmo
->l_addr_offset
,
5541 &l_addr
, ptr_size
) == 0
5542 && read_one_ptr (lm_addr
+ lmo
->l_ld_offset
,
5543 &l_ld
, ptr_size
) == 0
5544 && read_one_ptr (lm_addr
+ lmo
->l_prev_offset
,
5545 &l_prev
, ptr_size
) == 0
5546 && read_one_ptr (lm_addr
+ lmo
->l_next_offset
,
5547 &l_next
, ptr_size
) == 0)
5549 unsigned char libname
[PATH_MAX
];
5551 if (lm_prev
!= l_prev
)
5553 warning ("Corrupted shared library list: 0x%lx != 0x%lx",
5554 (long) lm_prev
, (long) l_prev
);
5558 /* Not checking for error because reading may stop before
5559 we've got PATH_MAX worth of characters. */
5561 linux_read_memory (l_name
, libname
, sizeof (libname
) - 1);
5562 libname
[sizeof (libname
) - 1] = '\0';
5563 if (libname
[0] != '\0')
5565 /* 6x the size for xml_escape_text below. */
5566 size_t len
= 6 * strlen ((char *) libname
);
5571 /* Terminate `<library-list-svr4'. */
5576 while (allocated
< p
- document
+ len
+ 200)
5578 /* Expand to guarantee sufficient storage. */
5579 uintptr_t document_len
= p
- document
;
5581 document
= xrealloc (document
, 2 * allocated
);
5583 p
= document
+ document_len
;
5586 name
= xml_escape_text ((char *) libname
);
5587 p
+= sprintf (p
, "<library name=\"%s\" lm=\"0x%lx\" "
5588 "l_addr=\"0x%lx\" l_ld=\"0x%lx\"/>",
5589 name
, (unsigned long) lm_addr
,
5590 (unsigned long) l_addr
, (unsigned long) l_ld
);
5593 else if (lm_prev
== 0)
5595 sprintf (p
, " main-lm=\"0x%lx\"", (unsigned long) lm_addr
);
5606 strcpy (p
, "</library-list-svr4>");
5609 document_len
= strlen (document
);
5610 if (offset
< document_len
)
5611 document_len
-= offset
;
5614 if (len
> document_len
)
5617 memcpy (readbuf
, document
+ offset
, len
);
5623 static struct target_ops linux_target_ops
= {
5624 linux_create_inferior
,
5633 linux_fetch_registers
,
5634 linux_store_registers
,
5635 linux_prepare_to_access_memory
,
5636 linux_done_accessing_memory
,
5639 linux_look_up_symbols
,
5640 linux_request_interrupt
,
5644 linux_stopped_by_watchpoint
,
5645 linux_stopped_data_address
,
5646 #if defined(__UCLIBC__) && defined(HAS_NOMMU)
5651 #ifdef USE_THREAD_DB
5652 thread_db_get_tls_address
,
5657 hostio_last_error_from_errno
,
5660 linux_supports_non_stop
,
5662 linux_start_non_stop
,
5663 linux_supports_multi_process
,
5664 #ifdef USE_THREAD_DB
5665 thread_db_handle_monitor_command
,
5669 linux_common_core_of_thread
,
5671 linux_process_qsupported
,
5672 linux_supports_tracepoints
,
5675 linux_thread_stopped
,
5679 linux_cancel_breakpoints
,
5680 linux_stabilize_threads
,
5681 linux_install_fast_tracepoint_jump_pad
,
5683 linux_supports_disable_randomization
,
5684 linux_get_min_fast_tracepoint_insn_len
,
5685 linux_qxfer_libraries_svr4
,
5686 linux_supports_agent
,
5690 linux_init_signals ()
5692 /* FIXME drow/2002-06-09: As above, we should check with LinuxThreads
5693 to find what the cancel signal actually is. */
5694 #ifndef __ANDROID__ /* Bionic doesn't use SIGRTMIN the way glibc does. */
5695 signal (__SIGRTMIN
+1, SIG_IGN
);
5700 initialize_low (void)
5702 struct sigaction sigchld_action
;
5703 memset (&sigchld_action
, 0, sizeof (sigchld_action
));
5704 set_target_ops (&linux_target_ops
);
5705 set_breakpoint_data (the_low_target
.breakpoint
,
5706 the_low_target
.breakpoint_len
);
5707 linux_init_signals ();
5708 linux_test_for_tracefork ();
5709 #ifdef HAVE_LINUX_REGSETS
5710 for (num_regsets
= 0; target_regsets
[num_regsets
].size
>= 0; num_regsets
++)
5712 disabled_regsets
= xmalloc (num_regsets
);
5715 sigchld_action
.sa_handler
= sigchld_handler
;
5716 sigemptyset (&sigchld_action
.sa_mask
);
5717 sigchld_action
.sa_flags
= SA_RESTART
;
5718 sigaction (SIGCHLD
, &sigchld_action
, NULL
);