1 /* Low level interface to ptrace, for the remote server for GDB.
2 Copyright (C) 1995-2013 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__))
81 /* PTRACE_TEXT_ADDR and friends. */
82 #include <asm/ptrace.h>
87 #ifndef HAVE_ELF32_AUXV_T
88 /* Copied from glibc's elf.h. */
91 uint32_t a_type; /* Entry type */
94 uint32_t a_val; /* Integer value */
95 /* We use to have pointer elements added here. We cannot do that,
96 though, since it does not work when using 32-bit definitions
97 on 64-bit platforms and vice versa. */
102 #ifndef HAVE_ELF64_AUXV_T
103 /* Copied from glibc's elf.h. */
106 uint64_t a_type; /* Entry type */
109 uint64_t a_val; /* Integer value */
110 /* We use to have pointer elements added here. We cannot do that,
111 though, since it does not work when using 32-bit definitions
112 on 64-bit platforms and vice versa. */
117 /* ``all_threads'' is keyed by the LWP ID, which we use as the GDB protocol
118 representation of the thread ID.
120 ``all_lwps'' is keyed by the process ID - which on Linux is (presently)
121 the same as the LWP ID.
123 ``all_processes'' is keyed by the "overall process ID", which
124 GNU/Linux calls tgid, "thread group ID". */
126 struct inferior_list all_lwps;
128 /* A list of all unknown processes which receive stop signals. Some
129 other process will presumably claim each of these as forked
130 children momentarily. */
132 struct simple_pid_list
134 /* The process ID. */
137 /* The status as reported by waitpid. */
141 struct simple_pid_list *next;
143 struct simple_pid_list *stopped_pids;
145 /* Trivial list manipulation functions to keep track of a list of new
146 stopped processes. */
149 add_to_pid_list (struct simple_pid_list **listp, int pid, int status)
151 struct simple_pid_list *new_pid = xmalloc (sizeof (struct simple_pid_list));
154 new_pid->status = status;
155 new_pid->next = *listp;
160 pull_pid_from_list (struct simple_pid_list **listp, int pid, int *statusp)
162 struct simple_pid_list **p;
164 for (p = listp; *p != NULL; p = &(*p)->next)
165 if ((*p)->pid == pid)
167 struct simple_pid_list *next = (*p)->next;
169 *statusp = (*p)->status;
177 enum stopping_threads_kind
179 /* Not stopping threads presently. */
180 NOT_STOPPING_THREADS,
182 /* Stopping threads. */
185 /* Stopping and suspending threads. */
186 STOPPING_AND_SUSPENDING_THREADS
189 /* This is set while stop_all_lwps is in effect. */
190 enum stopping_threads_kind stopping_threads = NOT_STOPPING_THREADS;
192 /* FIXME make into a target method? */
193 int using_threads = 1;
195 /* True if we're presently stabilizing threads (moving them out of
197 static int stabilizing_threads;
199 /* This flag is true iff we've just created or attached to our first
200 inferior but it has not stopped yet. As soon as it does, we need
201 to call the low target's arch_setup callback. Doing this only on
202 the first inferior avoids reinializing the architecture on every
203 inferior, and avoids messing with the register caches of the
204 already running inferiors. NOTE: this assumes all inferiors under
205 control of gdbserver have the same architecture. */
206 static int new_inferior;
208 static void linux_resume_one_lwp (struct lwp_info *lwp,
209 int step, int signal, siginfo_t *info);
210 static void linux_resume (struct thread_resume *resume_info, size_t n);
211 static void stop_all_lwps (int suspend, struct lwp_info *except);
212 static void unstop_all_lwps (int unsuspend, struct lwp_info *except);
213 static int linux_wait_for_event (ptid_t ptid, int *wstat, int options);
214 static void *add_lwp (ptid_t ptid);
215 static int linux_stopped_by_watchpoint (void);
216 static void mark_lwp_dead (struct lwp_info *lwp, int wstat);
217 static void proceed_all_lwps (void);
218 static int finish_step_over (struct lwp_info *lwp);
219 static CORE_ADDR get_stop_pc (struct lwp_info *lwp);
220 static int kill_lwp (unsigned long lwpid, int signo);
221 static void linux_enable_event_reporting (int pid);
223 /* True if the low target can hardware single-step. Such targets
224 don't need a BREAKPOINT_REINSERT_ADDR callback. */
227 can_hardware_single_step (void)
229 return (the_low_target.breakpoint_reinsert_addr == NULL);
232 /* True if the low target supports memory breakpoints. If so, we'll
233 have a GET_PC implementation. */
236 supports_breakpoints (void)
238 return (the_low_target.get_pc != NULL);
241 /* Returns true if this target can support fast tracepoints. This
242 does not mean that the in-process agent has been loaded in the
246 supports_fast_tracepoints (void)
248 return the_low_target.install_fast_tracepoint_jump_pad != NULL;
251 struct pending_signals
255 struct pending_signals *prev;
258 #ifdef HAVE_LINUX_REGSETS
259 static char *disabled_regsets;
260 static int num_regsets;
263 /* The read/write ends of the pipe registered as waitable file in the
265 static int linux_event_pipe[2] = { -1, -1 };
267 /* True if we're currently in async mode. */
268 #define target_is_async_p() (linux_event_pipe[0] != -1)
270 static void send_sigstop (struct lwp_info *lwp);
271 static void wait_for_sigstop (struct inferior_list_entry *entry);
273 /* Return non-zero if HEADER is a 64-bit ELF file. */
276 elf_64_header_p (const Elf64_Ehdr *header, unsigned int *machine)
278 if (header->e_ident[EI_MAG0] == ELFMAG0
279 && header->e_ident[EI_MAG1] == ELFMAG1
280 && header->e_ident[EI_MAG2] == ELFMAG2
281 && header->e_ident[EI_MAG3] == ELFMAG3)
283 *machine = header->e_machine;
284 return header->e_ident[EI_CLASS] == ELFCLASS64;
291 /* Return non-zero if FILE is a 64-bit ELF file,
292 zero if the file is not a 64-bit ELF file,
293 and -1 if the file is not accessible or doesn't exist. */
296 elf_64_file_p (const char *file, unsigned int *machine)
301 fd = open (file, O_RDONLY);
305 if (read (fd, &header, sizeof (header)) != sizeof (header))
312 return elf_64_header_p (&header, machine);
315 /* Accepts an integer PID; Returns true if the executable PID is
316 running is a 64-bit ELF file.. */
319 linux_pid_exe_is_elf_64_file (int pid, unsigned int *machine)
321 char file[MAXPATHLEN];
323 sprintf (file, "/proc/%d/exe", pid);
324 return elf_64_file_p (file, machine);
328 delete_lwp (struct lwp_info *lwp)
330 remove_thread (get_lwp_thread (lwp));
331 remove_inferior (&all_lwps, &lwp->head);
332 free (lwp->arch_private);
336 /* Add a process to the common process list, and set its private
339 static struct process_info *
340 linux_add_process (int pid, int attached)
342 struct process_info *proc;
344 /* Is this the first process? If so, then set the arch. */
345 if (all_processes.head == NULL)
348 proc = add_process (pid, attached);
349 proc->private = xcalloc (1, sizeof (*proc->private));
351 if (the_low_target.new_process != NULL)
352 proc->private->arch_private = the_low_target.new_process ();
357 /* Wrapper function for waitpid which handles EINTR, and emulates
358 __WALL for systems where that is not available. */
361 my_waitpid (int pid, int *status, int flags)
366 fprintf (stderr, "my_waitpid (%d, 0x%x)\n", pid, flags);
370 sigset_t block_mask, org_mask, wake_mask;
373 wnohang = (flags & WNOHANG) != 0;
374 flags &= ~(__WALL | __WCLONE);
377 /* Block all signals while here. This avoids knowing about
378 LinuxThread's signals. */
379 sigfillset (&block_mask);
380 sigprocmask (SIG_BLOCK, &block_mask, &org_mask);
382 /* ... except during the sigsuspend below. */
383 sigemptyset (&wake_mask);
387 /* Since all signals are blocked, there's no need to check
389 ret = waitpid (pid, status, flags);
392 if (ret == -1 && out_errno != ECHILD)
397 if (flags & __WCLONE)
399 /* We've tried both flavors now. If WNOHANG is set,
400 there's nothing else to do, just bail out. */
405 fprintf (stderr, "blocking\n");
407 /* Block waiting for signals. */
408 sigsuspend (&wake_mask);
414 sigprocmask (SIG_SETMASK, &org_mask, NULL);
419 ret = waitpid (pid, status, flags);
420 while (ret == -1 && errno == EINTR);
425 fprintf (stderr, "my_waitpid (%d, 0x%x): status(%x), %d\n",
426 pid, flags, status ? *status : -1, ret);
432 /* Handle a GNU/Linux extended wait response. If we see a clone
433 event, we need to add the new LWP to our list (and not report the
434 trap to higher layers). */
437 handle_extended_wait (struct lwp_info *event_child, int wstat)
439 int event = wstat >> 16;
440 struct lwp_info *new_lwp;
442 if (event == PTRACE_EVENT_CLONE)
445 unsigned long new_pid;
448 ptrace (PTRACE_GETEVENTMSG, lwpid_of (event_child), (PTRACE_ARG3_TYPE) 0,
451 /* If we haven't already seen the new PID stop, wait for it now. */
452 if (!pull_pid_from_list (&stopped_pids, new_pid, &status))
454 /* The new child has a pending SIGSTOP. We can't affect it until it
455 hits the SIGSTOP, but we're already attached. */
457 ret = my_waitpid (new_pid, &status, __WALL);
460 perror_with_name ("waiting for new child");
461 else if (ret != new_pid)
462 warning ("wait returned unexpected PID %d", ret);
463 else if (!WIFSTOPPED (status))
464 warning ("wait returned unexpected status 0x%x", status);
467 linux_enable_event_reporting (new_pid);
469 ptid = ptid_build (pid_of (event_child), new_pid, 0);
470 new_lwp = (struct lwp_info *) add_lwp (ptid);
471 add_thread (ptid, new_lwp);
473 /* Either we're going to immediately resume the new thread
474 or leave it stopped. linux_resume_one_lwp is a nop if it
475 thinks the thread is currently running, so set this first
476 before calling linux_resume_one_lwp. */
477 new_lwp->stopped = 1;
479 /* If we're suspending all threads, leave this one suspended
481 if (stopping_threads == STOPPING_AND_SUSPENDING_THREADS)
482 new_lwp->suspended = 1;
484 /* Normally we will get the pending SIGSTOP. But in some cases
485 we might get another signal delivered to the group first.
486 If we do get another signal, be sure not to lose it. */
487 if (WSTOPSIG (status) == SIGSTOP)
489 if (stopping_threads != NOT_STOPPING_THREADS)
490 new_lwp->stop_pc = get_stop_pc (new_lwp);
492 linux_resume_one_lwp (new_lwp, 0, 0, NULL);
496 new_lwp->stop_expected = 1;
498 if (stopping_threads != NOT_STOPPING_THREADS)
500 new_lwp->stop_pc = get_stop_pc (new_lwp);
501 new_lwp->status_pending_p = 1;
502 new_lwp->status_pending = status;
505 /* Pass the signal on. This is what GDB does - except
506 shouldn't we really report it instead? */
507 linux_resume_one_lwp (new_lwp, 0, WSTOPSIG (status), NULL);
510 /* Always resume the current thread. If we are stopping
511 threads, it will have a pending SIGSTOP; we may as well
513 linux_resume_one_lwp (event_child, event_child->stepping, 0, NULL);
517 /* Return the PC as read from the regcache of LWP, without any
521 get_pc (struct lwp_info *lwp)
523 struct thread_info *saved_inferior;
524 struct regcache *regcache;
527 if (the_low_target.get_pc == NULL)
530 saved_inferior = current_inferior;
531 current_inferior = get_lwp_thread (lwp);
533 regcache = get_thread_regcache (current_inferior, 1);
534 pc = (*the_low_target.get_pc) (regcache);
537 fprintf (stderr, "pc is 0x%lx\n", (long) pc);
539 current_inferior = saved_inferior;
543 /* This function should only be called if LWP got a SIGTRAP.
544 The SIGTRAP could mean several things.
546 On i386, where decr_pc_after_break is non-zero:
547 If we were single-stepping this process using PTRACE_SINGLESTEP,
548 we will get only the one SIGTRAP (even if the instruction we
549 stepped over was a breakpoint). The value of $eip will be the
551 If we continue the process using PTRACE_CONT, we will get a
552 SIGTRAP when we hit a breakpoint. The value of $eip will be
553 the instruction after the breakpoint (i.e. needs to be
554 decremented). If we report the SIGTRAP to GDB, we must also
555 report the undecremented PC. If we cancel the SIGTRAP, we
556 must resume at the decremented PC.
558 (Presumably, not yet tested) On a non-decr_pc_after_break machine
559 with hardware or kernel single-step:
560 If we single-step over a breakpoint instruction, our PC will
561 point at the following instruction. If we continue and hit a
562 breakpoint instruction, our PC will point at the breakpoint
566 get_stop_pc (struct lwp_info *lwp)
570 if (the_low_target.get_pc == NULL)
573 stop_pc = get_pc (lwp);
575 if (WSTOPSIG (lwp->last_status) == SIGTRAP
577 && !lwp->stopped_by_watchpoint
578 && lwp->last_status >> 16 == 0)
579 stop_pc -= the_low_target.decr_pc_after_break;
582 fprintf (stderr, "stop pc is 0x%lx\n", (long) stop_pc);
588 add_lwp (ptid_t ptid)
590 struct lwp_info *lwp;
592 lwp = (struct lwp_info *) xmalloc (sizeof (*lwp));
593 memset (lwp, 0, sizeof (*lwp));
597 if (the_low_target.new_thread != NULL)
598 lwp->arch_private = the_low_target.new_thread ();
600 add_inferior_to_list (&all_lwps, &lwp->head);
605 /* Start an inferior process and returns its pid.
606 ALLARGS is a vector of program-name and args. */
609 linux_create_inferior (char *program, char **allargs)
611 #ifdef HAVE_PERSONALITY
612 int personality_orig = 0, personality_set = 0;
614 struct lwp_info *new_lwp;
618 #ifdef HAVE_PERSONALITY
619 if (disable_randomization)
622 personality_orig = personality (0xffffffff);
623 if (errno == 0 && !(personality_orig & ADDR_NO_RANDOMIZE))
626 personality (personality_orig | ADDR_NO_RANDOMIZE);
628 if (errno != 0 || (personality_set
629 && !(personality (0xffffffff) & ADDR_NO_RANDOMIZE)))
630 warning ("Error disabling address space randomization: %s",
635 #if defined(__UCLIBC__) && defined(HAS_NOMMU)
641 perror_with_name ("fork");
645 ptrace (PTRACE_TRACEME, 0, (PTRACE_ARG3_TYPE) 0, (PTRACE_ARG4_TYPE) 0);
647 #ifndef __ANDROID__ /* Bionic doesn't use SIGRTMIN the way glibc does. */
648 signal (__SIGRTMIN + 1, SIG_DFL);
653 /* If gdbserver is connected to gdb via stdio, redirect the inferior's
654 stdout to stderr so that inferior i/o doesn't corrupt the connection.
655 Also, redirect stdin to /dev/null. */
656 if (remote_connection_is_stdio ())
659 open ("/dev/null", O_RDONLY);
661 if (write (2, "stdin/stdout redirected\n",
662 sizeof ("stdin/stdout redirected\n") - 1) < 0)
664 /* Errors ignored. */;
668 execv (program, allargs);
670 execvp (program, allargs);
672 fprintf (stderr, "Cannot exec %s: %s.\n", program,
678 #ifdef HAVE_PERSONALITY
682 personality (personality_orig);
684 warning ("Error restoring address space randomization: %s",
689 linux_add_process (pid, 0);
691 ptid = ptid_build (pid, pid, 0);
692 new_lwp = add_lwp (ptid);
693 add_thread (ptid, new_lwp);
694 new_lwp->must_set_ptrace_flags = 1;
699 /* Attach to an inferior process. */
702 linux_attach_lwp_1 (unsigned long lwpid, int initial)
705 struct lwp_info *new_lwp;
707 if (ptrace (PTRACE_ATTACH, lwpid, (PTRACE_ARG3_TYPE) 0, (PTRACE_ARG4_TYPE) 0)
710 struct buffer buffer;
714 /* If we fail to attach to an LWP, just warn. */
715 fprintf (stderr, "Cannot attach to lwp %ld: %s (%d)\n", lwpid,
716 strerror (errno), errno);
721 /* If we fail to attach to a process, report an error. */
722 buffer_init (&buffer);
723 linux_ptrace_attach_warnings (lwpid, &buffer);
724 buffer_grow_str0 (&buffer, "");
725 error ("%sCannot attach to lwp %ld: %s (%d)", buffer_finish (&buffer),
726 lwpid, strerror (errno), errno);
730 /* If lwp is the tgid, we handle adding existing threads later.
731 Otherwise we just add lwp without bothering about any other
733 ptid = ptid_build (lwpid, lwpid, 0);
736 /* Note that extracting the pid from the current inferior is
737 safe, since we're always called in the context of the same
738 process as this new thread. */
739 int pid = pid_of (get_thread_lwp (current_inferior));
740 ptid = ptid_build (pid, lwpid, 0);
743 new_lwp = (struct lwp_info *) add_lwp (ptid);
744 add_thread (ptid, new_lwp);
746 /* We need to wait for SIGSTOP before being able to make the next
747 ptrace call on this LWP. */
748 new_lwp->must_set_ptrace_flags = 1;
750 if (linux_proc_pid_is_stopped (lwpid))
754 "Attached to a stopped process\n");
756 /* The process is definitely stopped. It is in a job control
757 stop, unless the kernel predates the TASK_STOPPED /
758 TASK_TRACED distinction, in which case it might be in a
759 ptrace stop. Make sure it is in a ptrace stop; from there we
760 can kill it, signal it, et cetera.
762 First make sure there is a pending SIGSTOP. Since we are
763 already attached, the process can not transition from stopped
764 to running without a PTRACE_CONT; so we know this signal will
765 go into the queue. The SIGSTOP generated by PTRACE_ATTACH is
766 probably already in the queue (unless this kernel is old
767 enough to use TASK_STOPPED for ptrace stops); but since
768 SIGSTOP is not an RT signal, it can only be queued once. */
769 kill_lwp (lwpid, SIGSTOP);
771 /* Finally, resume the stopped process. This will deliver the
772 SIGSTOP (or a higher priority signal, just like normal
773 PTRACE_ATTACH), which we'll catch later on. */
774 ptrace (PTRACE_CONT, lwpid, (PTRACE_ARG3_TYPE) 0, (PTRACE_ARG4_TYPE) 0);
777 /* The next time we wait for this LWP we'll see a SIGSTOP as PTRACE_ATTACH
780 There are several cases to consider here:
782 1) gdbserver has already attached to the process and is being notified
783 of a new thread that is being created.
784 In this case we should ignore that SIGSTOP and resume the
785 process. This is handled below by setting stop_expected = 1,
786 and the fact that add_thread sets last_resume_kind ==
789 2) This is the first thread (the process thread), and we're attaching
790 to it via attach_inferior.
791 In this case we want the process thread to stop.
792 This is handled by having linux_attach set last_resume_kind ==
793 resume_stop after we return.
795 If the pid we are attaching to is also the tgid, we attach to and
796 stop all the existing threads. Otherwise, we attach to pid and
797 ignore any other threads in the same group as this pid.
799 3) GDB is connecting to gdbserver and is requesting an enumeration of all
801 In this case we want the thread to stop.
802 FIXME: This case is currently not properly handled.
803 We should wait for the SIGSTOP but don't. Things work apparently
804 because enough time passes between when we ptrace (ATTACH) and when
805 gdb makes the next ptrace call on the thread.
807 On the other hand, if we are currently trying to stop all threads, we
808 should treat the new thread as if we had sent it a SIGSTOP. This works
809 because we are guaranteed that the add_lwp call above added us to the
810 end of the list, and so the new thread has not yet reached
811 wait_for_sigstop (but will). */
812 new_lwp->stop_expected = 1;
816 linux_attach_lwp (unsigned long lwpid)
818 linux_attach_lwp_1 (lwpid, 0);
821 /* Attach to PID. If PID is the tgid, attach to it and all
825 linux_attach (unsigned long pid)
827 /* Attach to PID. We will check for other threads
829 linux_attach_lwp_1 (pid, 1);
830 linux_add_process (pid, 1);
834 struct thread_info *thread;
836 /* Don't ignore the initial SIGSTOP if we just attached to this
837 process. It will be collected by wait shortly. */
838 thread = find_thread_ptid (ptid_build (pid, pid, 0));
839 thread->last_resume_kind = resume_stop;
842 if (linux_proc_get_tgid (pid) == pid)
847 sprintf (pathname, "/proc/%ld/task", pid);
849 dir = opendir (pathname);
853 fprintf (stderr, "Could not open /proc/%ld/task.\n", pid);
858 /* At this point we attached to the tgid. Scan the task for
861 int new_threads_found;
865 while (iterations < 2)
867 new_threads_found = 0;
868 /* Add all the other threads. While we go through the
869 threads, new threads may be spawned. Cycle through
870 the list of threads until we have done two iterations without
871 finding new threads. */
872 while ((dp = readdir (dir)) != NULL)
875 lwp = strtoul (dp->d_name, NULL, 10);
877 /* Is this a new thread? */
879 && find_thread_ptid (ptid_build (pid, lwp, 0)) == NULL)
881 linux_attach_lwp_1 (lwp, 0);
886 Found and attached to new lwp %ld\n", lwp);
890 if (!new_threads_found)
911 second_thread_of_pid_p (struct inferior_list_entry *entry, void *args)
913 struct counter *counter = args;
915 if (ptid_get_pid (entry->id) == counter->pid)
917 if (++counter->count > 1)
925 last_thread_of_process_p (struct thread_info *thread)
927 ptid_t ptid = ((struct inferior_list_entry *)thread)->id;
928 int pid = ptid_get_pid (ptid);
929 struct counter counter = { pid , 0 };
931 return (find_inferior (&all_threads,
932 second_thread_of_pid_p, &counter) == NULL);
938 linux_kill_one_lwp (struct lwp_info *lwp)
940 int pid = lwpid_of (lwp);
942 /* PTRACE_KILL is unreliable. After stepping into a signal handler,
943 there is no signal context, and ptrace(PTRACE_KILL) (or
944 ptrace(PTRACE_CONT, SIGKILL), pretty much the same) acts like
945 ptrace(CONT, pid, 0,0) and just resumes the tracee. A better
946 alternative is to kill with SIGKILL. We only need one SIGKILL
947 per process, not one for each thread. But since we still support
948 linuxthreads, and we also support debugging programs using raw
949 clone without CLONE_THREAD, we send one for each thread. For
950 years, we used PTRACE_KILL only, so we're being a bit paranoid
951 about some old kernels where PTRACE_KILL might work better
952 (dubious if there are any such, but that's why it's paranoia), so
953 we try SIGKILL first, PTRACE_KILL second, and so we're fine
960 "LKL: kill (SIGKILL) %s, 0, 0 (%s)\n",
961 target_pid_to_str (ptid_of (lwp)),
962 errno ? strerror (errno) : "OK");
965 ptrace (PTRACE_KILL, pid, (PTRACE_ARG3_TYPE) 0, (PTRACE_ARG4_TYPE) 0);
968 "LKL: PTRACE_KILL %s, 0, 0 (%s)\n",
969 target_pid_to_str (ptid_of (lwp)),
970 errno ? strerror (errno) : "OK");
973 /* Callback for `find_inferior'. Kills an lwp of a given process,
974 except the leader. */
977 kill_one_lwp_callback (struct inferior_list_entry *entry, void *args)
979 struct thread_info *thread = (struct thread_info *) entry;
980 struct lwp_info *lwp = get_thread_lwp (thread);
982 int pid = * (int *) args;
984 if (ptid_get_pid (entry->id) != pid)
987 /* We avoid killing the first thread here, because of a Linux kernel (at
988 least 2.6.0-test7 through 2.6.8-rc4) bug; if we kill the parent before
989 the children get a chance to be reaped, it will remain a zombie
992 if (lwpid_of (lwp) == pid)
995 fprintf (stderr, "lkop: is last of process %s\n",
996 target_pid_to_str (entry->id));
1002 linux_kill_one_lwp (lwp);
1004 /* Make sure it died. The loop is most likely unnecessary. */
1005 pid = linux_wait_for_event (lwp->head.id, &wstat, __WALL);
1006 } while (pid > 0 && WIFSTOPPED (wstat));
1012 linux_kill (int pid)
1014 struct process_info *process;
1015 struct lwp_info *lwp;
1019 process = find_process_pid (pid);
1020 if (process == NULL)
1023 /* If we're killing a running inferior, make sure it is stopped
1024 first, as PTRACE_KILL will not work otherwise. */
1025 stop_all_lwps (0, NULL);
1027 find_inferior (&all_threads, kill_one_lwp_callback , &pid);
1029 /* See the comment in linux_kill_one_lwp. We did not kill the first
1030 thread in the list, so do so now. */
1031 lwp = find_lwp_pid (pid_to_ptid (pid));
1036 fprintf (stderr, "lk_1: cannot find lwp %ld, for pid: %d\n",
1037 lwpid_of (lwp), pid);
1042 fprintf (stderr, "lk_1: killing lwp %ld, for pid: %d\n",
1043 lwpid_of (lwp), pid);
1047 linux_kill_one_lwp (lwp);
1049 /* Make sure it died. The loop is most likely unnecessary. */
1050 lwpid = linux_wait_for_event (lwp->head.id, &wstat, __WALL);
1051 } while (lwpid > 0 && WIFSTOPPED (wstat));
1054 the_target->mourn (process);
1056 /* Since we presently can only stop all lwps of all processes, we
1057 need to unstop lwps of other processes. */
1058 unstop_all_lwps (0, NULL);
1062 /* Get pending signal of THREAD, for detaching purposes. This is the
1063 signal the thread last stopped for, which we need to deliver to the
1064 thread when detaching, otherwise, it'd be suppressed/lost. */
1067 get_detach_signal (struct thread_info *thread)
1069 enum gdb_signal signo = GDB_SIGNAL_0;
1071 struct lwp_info *lp = get_thread_lwp (thread);
1073 if (lp->status_pending_p)
1074 status = lp->status_pending;
1077 /* If the thread had been suspended by gdbserver, and it stopped
1078 cleanly, then it'll have stopped with SIGSTOP. But we don't
1079 want to deliver that SIGSTOP. */
1080 if (thread->last_status.kind != TARGET_WAITKIND_STOPPED
1081 || thread->last_status.value.sig == GDB_SIGNAL_0)
1084 /* Otherwise, we may need to deliver the signal we
1086 status = lp->last_status;
1089 if (!WIFSTOPPED (status))
1093 "GPS: lwp %s hasn't stopped: no pending signal\n",
1094 target_pid_to_str (ptid_of (lp)));
1098 /* Extended wait statuses aren't real SIGTRAPs. */
1099 if (WSTOPSIG (status) == SIGTRAP && status >> 16 != 0)
1103 "GPS: lwp %s had stopped with extended "
1104 "status: no pending signal\n",
1105 target_pid_to_str (ptid_of (lp)));
1109 signo = gdb_signal_from_host (WSTOPSIG (status));
1111 if (program_signals_p && !program_signals[signo])
1115 "GPS: lwp %s had signal %s, but it is in nopass state\n",
1116 target_pid_to_str (ptid_of (lp)),
1117 gdb_signal_to_string (signo));
1120 else if (!program_signals_p
1121 /* If we have no way to know which signals GDB does not
1122 want to have passed to the program, assume
1123 SIGTRAP/SIGINT, which is GDB's default. */
1124 && (signo == GDB_SIGNAL_TRAP || signo == GDB_SIGNAL_INT))
1128 "GPS: lwp %s had signal %s, "
1129 "but we don't know if we should pass it. Default to not.\n",
1130 target_pid_to_str (ptid_of (lp)),
1131 gdb_signal_to_string (signo));
1138 "GPS: lwp %s has pending signal %s: delivering it.\n",
1139 target_pid_to_str (ptid_of (lp)),
1140 gdb_signal_to_string (signo));
1142 return WSTOPSIG (status);
1147 linux_detach_one_lwp (struct inferior_list_entry *entry, void *args)
1149 struct thread_info *thread = (struct thread_info *) entry;
1150 struct lwp_info *lwp = get_thread_lwp (thread);
1151 int pid = * (int *) args;
1154 if (ptid_get_pid (entry->id) != pid)
1157 /* If there is a pending SIGSTOP, get rid of it. */
1158 if (lwp->stop_expected)
1162 "Sending SIGCONT to %s\n",
1163 target_pid_to_str (ptid_of (lwp)));
1165 kill_lwp (lwpid_of (lwp), SIGCONT);
1166 lwp->stop_expected = 0;
1169 /* Flush any pending changes to the process's registers. */
1170 regcache_invalidate_one ((struct inferior_list_entry *)
1171 get_lwp_thread (lwp));
1173 /* Pass on any pending signal for this thread. */
1174 sig = get_detach_signal (thread);
1176 /* Finally, let it resume. */
1177 if (the_low_target.prepare_to_resume != NULL)
1178 the_low_target.prepare_to_resume (lwp);
1179 if (ptrace (PTRACE_DETACH, lwpid_of (lwp), (PTRACE_ARG3_TYPE) 0,
1180 (PTRACE_ARG4_TYPE) (long) sig) < 0)
1181 error (_("Can't detach %s: %s"),
1182 target_pid_to_str (ptid_of (lwp)),
1190 linux_detach (int pid)
1192 struct process_info *process;
1194 process = find_process_pid (pid);
1195 if (process == NULL)
1198 /* Stop all threads before detaching. First, ptrace requires that
1199 the thread is stopped to sucessfully detach. Second, thread_db
1200 may need to uninstall thread event breakpoints from memory, which
1201 only works with a stopped process anyway. */
1202 stop_all_lwps (0, NULL);
1204 #ifdef USE_THREAD_DB
1205 thread_db_detach (process);
1208 /* Stabilize threads (move out of jump pads). */
1209 stabilize_threads ();
1211 find_inferior (&all_threads, linux_detach_one_lwp, &pid);
1213 the_target->mourn (process);
1215 /* Since we presently can only stop all lwps of all processes, we
1216 need to unstop lwps of other processes. */
1217 unstop_all_lwps (0, NULL);
1221 /* Remove all LWPs that belong to process PROC from the lwp list. */
1224 delete_lwp_callback (struct inferior_list_entry *entry, void *proc)
1226 struct lwp_info *lwp = (struct lwp_info *) entry;
1227 struct process_info *process = proc;
1229 if (pid_of (lwp) == pid_of (process))
1236 linux_mourn (struct process_info *process)
1238 struct process_info_private *priv;
1240 #ifdef USE_THREAD_DB
1241 thread_db_mourn (process);
1244 find_inferior (&all_lwps, delete_lwp_callback, process);
1246 /* Freeing all private data. */
1247 priv = process->private;
1248 free (priv->arch_private);
1250 process->private = NULL;
1252 remove_process (process);
1256 linux_join (int pid)
1261 ret = my_waitpid (pid, &status, 0);
1262 if (WIFEXITED (status) || WIFSIGNALED (status))
1264 } while (ret != -1 || errno != ECHILD);
1267 /* Return nonzero if the given thread is still alive. */
1269 linux_thread_alive (ptid_t ptid)
1271 struct lwp_info *lwp = find_lwp_pid (ptid);
1273 /* We assume we always know if a thread exits. If a whole process
1274 exited but we still haven't been able to report it to GDB, we'll
1275 hold on to the last lwp of the dead process. */
1282 /* Return 1 if this lwp has an interesting status pending. */
1284 status_pending_p_callback (struct inferior_list_entry *entry, void *arg)
1286 struct lwp_info *lwp = (struct lwp_info *) entry;
1287 ptid_t ptid = * (ptid_t *) arg;
1288 struct thread_info *thread;
1290 /* Check if we're only interested in events from a specific process
1292 if (!ptid_equal (minus_one_ptid, ptid)
1293 && ptid_get_pid (ptid) != ptid_get_pid (lwp->head.id))
1296 thread = get_lwp_thread (lwp);
1298 /* If we got a `vCont;t', but we haven't reported a stop yet, do
1299 report any status pending the LWP may have. */
1300 if (thread->last_resume_kind == resume_stop
1301 && thread->last_status.kind != TARGET_WAITKIND_IGNORE)
1304 return lwp->status_pending_p;
1308 same_lwp (struct inferior_list_entry *entry, void *data)
1310 ptid_t ptid = *(ptid_t *) data;
1313 if (ptid_get_lwp (ptid) != 0)
1314 lwp = ptid_get_lwp (ptid);
1316 lwp = ptid_get_pid (ptid);
1318 if (ptid_get_lwp (entry->id) == lwp)
1325 find_lwp_pid (ptid_t ptid)
1327 return (struct lwp_info*) find_inferior (&all_lwps, same_lwp, &ptid);
1330 static struct lwp_info *
1331 linux_wait_for_lwp (ptid_t ptid, int *wstatp, int options)
1334 int to_wait_for = -1;
1335 struct lwp_info *child = NULL;
1338 fprintf (stderr, "linux_wait_for_lwp: %s\n", target_pid_to_str (ptid));
1340 if (ptid_equal (ptid, minus_one_ptid))
1341 to_wait_for = -1; /* any child */
1343 to_wait_for = ptid_get_lwp (ptid); /* this lwp only */
1349 ret = my_waitpid (to_wait_for, wstatp, options);
1350 if (ret == 0 || (ret == -1 && errno == ECHILD && (options & WNOHANG)))
1353 perror_with_name ("waitpid");
1356 && (!WIFSTOPPED (*wstatp)
1357 || (WSTOPSIG (*wstatp) != 32
1358 && WSTOPSIG (*wstatp) != 33)))
1359 fprintf (stderr, "Got an event from %d (%x)\n", ret, *wstatp);
1361 child = find_lwp_pid (pid_to_ptid (ret));
1363 /* If we didn't find a process, one of two things presumably happened:
1364 - A process we started and then detached from has exited. Ignore it.
1365 - A process we are controlling has forked and the new child's stop
1366 was reported to us by the kernel. Save its PID. */
1367 if (child == NULL && WIFSTOPPED (*wstatp))
1369 add_to_pid_list (&stopped_pids, ret, *wstatp);
1372 else if (child == NULL)
1377 child->last_status = *wstatp;
1379 /* Architecture-specific setup after inferior is running.
1380 This needs to happen after we have attached to the inferior
1381 and it is stopped for the first time, but before we access
1382 any inferior registers. */
1385 the_low_target.arch_setup ();
1386 #ifdef HAVE_LINUX_REGSETS
1387 memset (disabled_regsets, 0, num_regsets);
1392 /* Fetch the possibly triggered data watchpoint info and store it in
1395 On some archs, like x86, that use debug registers to set
1396 watchpoints, it's possible that the way to know which watched
1397 address trapped, is to check the register that is used to select
1398 which address to watch. Problem is, between setting the
1399 watchpoint and reading back which data address trapped, the user
1400 may change the set of watchpoints, and, as a consequence, GDB
1401 changes the debug registers in the inferior. To avoid reading
1402 back a stale stopped-data-address when that happens, we cache in
1403 LP the fact that a watchpoint trapped, and the corresponding data
1404 address, as soon as we see CHILD stop with a SIGTRAP. If GDB
1405 changes the debug registers meanwhile, we have the cached data we
1408 if (WIFSTOPPED (*wstatp) && WSTOPSIG (*wstatp) == SIGTRAP)
1410 if (the_low_target.stopped_by_watchpoint == NULL)
1412 child->stopped_by_watchpoint = 0;
1416 struct thread_info *saved_inferior;
1418 saved_inferior = current_inferior;
1419 current_inferior = get_lwp_thread (child);
1421 child->stopped_by_watchpoint
1422 = the_low_target.stopped_by_watchpoint ();
1424 if (child->stopped_by_watchpoint)
1426 if (the_low_target.stopped_data_address != NULL)
1427 child->stopped_data_address
1428 = the_low_target.stopped_data_address ();
1430 child->stopped_data_address = 0;
1433 current_inferior = saved_inferior;
1437 /* Store the STOP_PC, with adjustment applied. This depends on the
1438 architecture being defined already (so that CHILD has a valid
1439 regcache), and on LAST_STATUS being set (to check for SIGTRAP or
1441 if (WIFSTOPPED (*wstatp))
1442 child->stop_pc = get_stop_pc (child);
1445 && WIFSTOPPED (*wstatp)
1446 && the_low_target.get_pc != NULL)
1448 struct thread_info *saved_inferior = current_inferior;
1449 struct regcache *regcache;
1452 current_inferior = get_lwp_thread (child);
1453 regcache = get_thread_regcache (current_inferior, 1);
1454 pc = (*the_low_target.get_pc) (regcache);
1455 fprintf (stderr, "linux_wait_for_lwp: pc is 0x%lx\n", (long) pc);
1456 current_inferior = saved_inferior;
1462 /* This function should only be called if the LWP got a SIGTRAP.
1464 Handle any tracepoint steps or hits. Return true if a tracepoint
1465 event was handled, 0 otherwise. */
1468 handle_tracepoints (struct lwp_info *lwp)
1470 struct thread_info *tinfo = get_lwp_thread (lwp);
1471 int tpoint_related_event = 0;
1473 /* If this tracepoint hit causes a tracing stop, we'll immediately
1474 uninsert tracepoints. To do this, we temporarily pause all
1475 threads, unpatch away, and then unpause threads. We need to make
1476 sure the unpausing doesn't resume LWP too. */
1479 /* And we need to be sure that any all-threads-stopping doesn't try
1480 to move threads out of the jump pads, as it could deadlock the
1481 inferior (LWP could be in the jump pad, maybe even holding the
1484 /* Do any necessary step collect actions. */
1485 tpoint_related_event |= tracepoint_finished_step (tinfo, lwp->stop_pc);
1487 tpoint_related_event |= handle_tracepoint_bkpts (tinfo, lwp->stop_pc);
1489 /* See if we just hit a tracepoint and do its main collect
1491 tpoint_related_event |= tracepoint_was_hit (tinfo, lwp->stop_pc);
1495 gdb_assert (lwp->suspended == 0);
1496 gdb_assert (!stabilizing_threads || lwp->collecting_fast_tracepoint);
1498 if (tpoint_related_event)
1501 fprintf (stderr, "got a tracepoint event\n");
1508 /* Convenience wrapper. Returns true if LWP is presently collecting a
1512 linux_fast_tracepoint_collecting (struct lwp_info *lwp,
1513 struct fast_tpoint_collect_status *status)
1515 CORE_ADDR thread_area;
1517 if (the_low_target.get_thread_area == NULL)
1520 /* Get the thread area address. This is used to recognize which
1521 thread is which when tracing with the in-process agent library.
1522 We don't read anything from the address, and treat it as opaque;
1523 it's the address itself that we assume is unique per-thread. */
1524 if ((*the_low_target.get_thread_area) (lwpid_of (lwp), &thread_area) == -1)
1527 return fast_tracepoint_collecting (thread_area, lwp->stop_pc, status);
1530 /* The reason we resume in the caller, is because we want to be able
1531 to pass lwp->status_pending as WSTAT, and we need to clear
1532 status_pending_p before resuming, otherwise, linux_resume_one_lwp
1533 refuses to resume. */
1536 maybe_move_out_of_jump_pad (struct lwp_info *lwp, int *wstat)
1538 struct thread_info *saved_inferior;
1540 saved_inferior = current_inferior;
1541 current_inferior = get_lwp_thread (lwp);
1544 || (WIFSTOPPED (*wstat) && WSTOPSIG (*wstat) != SIGTRAP))
1545 && supports_fast_tracepoints ()
1546 && agent_loaded_p ())
1548 struct fast_tpoint_collect_status status;
1553 Checking whether LWP %ld needs to move out of the jump pad.\n",
1556 r = linux_fast_tracepoint_collecting (lwp, &status);
1559 || (WSTOPSIG (*wstat) != SIGILL
1560 && WSTOPSIG (*wstat) != SIGFPE
1561 && WSTOPSIG (*wstat) != SIGSEGV
1562 && WSTOPSIG (*wstat) != SIGBUS))
1564 lwp->collecting_fast_tracepoint = r;
1568 if (r == 1 && lwp->exit_jump_pad_bkpt == NULL)
1570 /* Haven't executed the original instruction yet.
1571 Set breakpoint there, and wait till it's hit,
1572 then single-step until exiting the jump pad. */
1573 lwp->exit_jump_pad_bkpt
1574 = set_breakpoint_at (status.adjusted_insn_addr, NULL);
1579 Checking whether LWP %ld needs to move out of the jump pad...it does\n",
1581 current_inferior = saved_inferior;
1588 /* If we get a synchronous signal while collecting, *and*
1589 while executing the (relocated) original instruction,
1590 reset the PC to point at the tpoint address, before
1591 reporting to GDB. Otherwise, it's an IPA lib bug: just
1592 report the signal to GDB, and pray for the best. */
1594 lwp->collecting_fast_tracepoint = 0;
1597 && (status.adjusted_insn_addr <= lwp->stop_pc
1598 && lwp->stop_pc < status.adjusted_insn_addr_end))
1601 struct regcache *regcache;
1603 /* The si_addr on a few signals references the address
1604 of the faulting instruction. Adjust that as
1606 if ((WSTOPSIG (*wstat) == SIGILL
1607 || WSTOPSIG (*wstat) == SIGFPE
1608 || WSTOPSIG (*wstat) == SIGBUS
1609 || WSTOPSIG (*wstat) == SIGSEGV)
1610 && ptrace (PTRACE_GETSIGINFO, lwpid_of (lwp),
1611 (PTRACE_ARG3_TYPE) 0, &info) == 0
1612 /* Final check just to make sure we don't clobber
1613 the siginfo of non-kernel-sent signals. */
1614 && (uintptr_t) info.si_addr == lwp->stop_pc)
1616 info.si_addr = (void *) (uintptr_t) status.tpoint_addr;
1617 ptrace (PTRACE_SETSIGINFO, lwpid_of (lwp),
1618 (PTRACE_ARG3_TYPE) 0, &info);
1621 regcache = get_thread_regcache (get_lwp_thread (lwp), 1);
1622 (*the_low_target.set_pc) (regcache, status.tpoint_addr);
1623 lwp->stop_pc = status.tpoint_addr;
1625 /* Cancel any fast tracepoint lock this thread was
1627 force_unlock_trace_buffer ();
1630 if (lwp->exit_jump_pad_bkpt != NULL)
1634 "Cancelling fast exit-jump-pad: removing bkpt. "
1635 "stopping all threads momentarily.\n");
1637 stop_all_lwps (1, lwp);
1638 cancel_breakpoints ();
1640 delete_breakpoint (lwp->exit_jump_pad_bkpt);
1641 lwp->exit_jump_pad_bkpt = NULL;
1643 unstop_all_lwps (1, lwp);
1645 gdb_assert (lwp->suspended >= 0);
1652 Checking whether LWP %ld needs to move out of the jump pad...no\n",
1655 current_inferior = saved_inferior;
1659 /* Enqueue one signal in the "signals to report later when out of the
1663 enqueue_one_deferred_signal (struct lwp_info *lwp, int *wstat)
1665 struct pending_signals *p_sig;
1669 Deferring signal %d for LWP %ld.\n", WSTOPSIG (*wstat), lwpid_of (lwp));
1673 struct pending_signals *sig;
1675 for (sig = lwp->pending_signals_to_report;
1679 " Already queued %d\n",
1682 fprintf (stderr, " (no more currently queued signals)\n");
1685 /* Don't enqueue non-RT signals if they are already in the deferred
1686 queue. (SIGSTOP being the easiest signal to see ending up here
1688 if (WSTOPSIG (*wstat) < __SIGRTMIN)
1690 struct pending_signals *sig;
1692 for (sig = lwp->pending_signals_to_report;
1696 if (sig->signal == WSTOPSIG (*wstat))
1700 "Not requeuing already queued non-RT signal %d"
1709 p_sig = xmalloc (sizeof (*p_sig));
1710 p_sig->prev = lwp->pending_signals_to_report;
1711 p_sig->signal = WSTOPSIG (*wstat);
1712 memset (&p_sig->info, 0, sizeof (siginfo_t));
1713 ptrace (PTRACE_GETSIGINFO, lwpid_of (lwp), (PTRACE_ARG3_TYPE) 0,
1716 lwp->pending_signals_to_report = p_sig;
1719 /* Dequeue one signal from the "signals to report later when out of
1720 the jump pad" list. */
1723 dequeue_one_deferred_signal (struct lwp_info *lwp, int *wstat)
1725 if (lwp->pending_signals_to_report != NULL)
1727 struct pending_signals **p_sig;
1729 p_sig = &lwp->pending_signals_to_report;
1730 while ((*p_sig)->prev != NULL)
1731 p_sig = &(*p_sig)->prev;
1733 *wstat = W_STOPCODE ((*p_sig)->signal);
1734 if ((*p_sig)->info.si_signo != 0)
1735 ptrace (PTRACE_SETSIGINFO, lwpid_of (lwp), (PTRACE_ARG3_TYPE) 0,
1741 fprintf (stderr, "Reporting deferred signal %d for LWP %ld.\n",
1742 WSTOPSIG (*wstat), lwpid_of (lwp));
1746 struct pending_signals *sig;
1748 for (sig = lwp->pending_signals_to_report;
1752 " Still queued %d\n",
1755 fprintf (stderr, " (no more queued signals)\n");
1764 /* Arrange for a breakpoint to be hit again later. We don't keep the
1765 SIGTRAP status and don't forward the SIGTRAP signal to the LWP. We
1766 will handle the current event, eventually we will resume this LWP,
1767 and this breakpoint will trap again. */
1770 cancel_breakpoint (struct lwp_info *lwp)
1772 struct thread_info *saved_inferior;
1774 /* There's nothing to do if we don't support breakpoints. */
1775 if (!supports_breakpoints ())
1778 /* breakpoint_at reads from current inferior. */
1779 saved_inferior = current_inferior;
1780 current_inferior = get_lwp_thread (lwp);
1782 if ((*the_low_target.breakpoint_at) (lwp->stop_pc))
1786 "CB: Push back breakpoint for %s\n",
1787 target_pid_to_str (ptid_of (lwp)));
1789 /* Back up the PC if necessary. */
1790 if (the_low_target.decr_pc_after_break)
1792 struct regcache *regcache
1793 = get_thread_regcache (current_inferior, 1);
1794 (*the_low_target.set_pc) (regcache, lwp->stop_pc);
1797 current_inferior = saved_inferior;
1804 "CB: No breakpoint found at %s for [%s]\n",
1805 paddress (lwp->stop_pc),
1806 target_pid_to_str (ptid_of (lwp)));
1809 current_inferior = saved_inferior;
1813 /* When the event-loop is doing a step-over, this points at the thread
1815 ptid_t step_over_bkpt;
1817 /* Wait for an event from child PID. If PID is -1, wait for any
1818 child. Store the stop status through the status pointer WSTAT.
1819 OPTIONS is passed to the waitpid call. Return 0 if no child stop
1820 event was found and OPTIONS contains WNOHANG. Return the PID of
1821 the stopped child otherwise. */
1824 linux_wait_for_event (ptid_t ptid, int *wstat, int options)
1826 struct lwp_info *event_child, *requested_child;
1830 requested_child = NULL;
1832 /* Check for a lwp with a pending status. */
1834 if (ptid_equal (ptid, minus_one_ptid) || ptid_is_pid (ptid))
1836 event_child = (struct lwp_info *)
1837 find_inferior (&all_lwps, status_pending_p_callback, &ptid);
1838 if (debug_threads && event_child)
1839 fprintf (stderr, "Got a pending child %ld\n", lwpid_of (event_child));
1843 requested_child = find_lwp_pid (ptid);
1845 if (stopping_threads == NOT_STOPPING_THREADS
1846 && requested_child->status_pending_p
1847 && requested_child->collecting_fast_tracepoint)
1849 enqueue_one_deferred_signal (requested_child,
1850 &requested_child->status_pending);
1851 requested_child->status_pending_p = 0;
1852 requested_child->status_pending = 0;
1853 linux_resume_one_lwp (requested_child, 0, 0, NULL);
1856 if (requested_child->suspended
1857 && requested_child->status_pending_p)
1858 fatal ("requesting an event out of a suspended child?");
1860 if (requested_child->status_pending_p)
1861 event_child = requested_child;
1864 if (event_child != NULL)
1867 fprintf (stderr, "Got an event from pending child %ld (%04x)\n",
1868 lwpid_of (event_child), event_child->status_pending);
1869 *wstat = event_child->status_pending;
1870 event_child->status_pending_p = 0;
1871 event_child->status_pending = 0;
1872 current_inferior = get_lwp_thread (event_child);
1873 return lwpid_of (event_child);
1876 if (ptid_is_pid (ptid))
1878 /* A request to wait for a specific tgid. This is not possible
1879 with waitpid, so instead, we wait for any child, and leave
1880 children we're not interested in right now with a pending
1881 status to report later. */
1882 wait_ptid = minus_one_ptid;
1887 /* We only enter this loop if no process has a pending wait status. Thus
1888 any action taken in response to a wait status inside this loop is
1889 responding as soon as we detect the status, not after any pending
1893 event_child = linux_wait_for_lwp (wait_ptid, wstat, options);
1895 if ((options & WNOHANG) && event_child == NULL)
1898 fprintf (stderr, "WNOHANG set, no event found\n");
1902 if (event_child == NULL)
1903 error ("event from unknown child");
1905 if (ptid_is_pid (ptid)
1906 && ptid_get_pid (ptid) != ptid_get_pid (ptid_of (event_child)))
1908 if (! WIFSTOPPED (*wstat))
1909 mark_lwp_dead (event_child, *wstat);
1912 event_child->status_pending_p = 1;
1913 event_child->status_pending = *wstat;
1918 current_inferior = get_lwp_thread (event_child);
1920 /* Check for thread exit. */
1921 if (! WIFSTOPPED (*wstat))
1924 fprintf (stderr, "LWP %ld exiting\n", lwpid_of (event_child));
1926 /* If the last thread is exiting, just return. */
1927 if (last_thread_of_process_p (current_inferior))
1930 fprintf (stderr, "LWP %ld is last lwp of process\n",
1931 lwpid_of (event_child));
1932 return lwpid_of (event_child);
1937 current_inferior = (struct thread_info *) all_threads.head;
1939 fprintf (stderr, "Current inferior is now %ld\n",
1940 lwpid_of (get_thread_lwp (current_inferior)));
1944 current_inferior = NULL;
1946 fprintf (stderr, "Current inferior is now <NULL>\n");
1949 /* If we were waiting for this particular child to do something...
1950 well, it did something. */
1951 if (requested_child != NULL)
1953 int lwpid = lwpid_of (event_child);
1955 /* Cancel the step-over operation --- the thread that
1956 started it is gone. */
1957 if (finish_step_over (event_child))
1958 unstop_all_lwps (1, event_child);
1959 delete_lwp (event_child);
1963 delete_lwp (event_child);
1965 /* Wait for a more interesting event. */
1969 if (event_child->must_set_ptrace_flags)
1971 linux_enable_event_reporting (lwpid_of (event_child));
1972 event_child->must_set_ptrace_flags = 0;
1975 if (WIFSTOPPED (*wstat) && WSTOPSIG (*wstat) == SIGTRAP
1976 && *wstat >> 16 != 0)
1978 handle_extended_wait (event_child, *wstat);
1982 if (WIFSTOPPED (*wstat)
1983 && WSTOPSIG (*wstat) == SIGSTOP
1984 && event_child->stop_expected)
1989 fprintf (stderr, "Expected stop.\n");
1990 event_child->stop_expected = 0;
1992 should_stop = (current_inferior->last_resume_kind == resume_stop
1993 || stopping_threads != NOT_STOPPING_THREADS);
1997 linux_resume_one_lwp (event_child,
1998 event_child->stepping, 0, NULL);
2003 return lwpid_of (event_child);
2010 /* Count the LWP's that have had events. */
2013 count_events_callback (struct inferior_list_entry *entry, void *data)
2015 struct lwp_info *lp = (struct lwp_info *) entry;
2016 struct thread_info *thread = get_lwp_thread (lp);
2019 gdb_assert (count != NULL);
2021 /* Count only resumed LWPs that have a SIGTRAP event pending that
2022 should be reported to GDB. */
2023 if (thread->last_status.kind == TARGET_WAITKIND_IGNORE
2024 && thread->last_resume_kind != resume_stop
2025 && lp->status_pending_p
2026 && WIFSTOPPED (lp->status_pending)
2027 && WSTOPSIG (lp->status_pending) == SIGTRAP
2028 && !breakpoint_inserted_here (lp->stop_pc))
2034 /* Select the LWP (if any) that is currently being single-stepped. */
2037 select_singlestep_lwp_callback (struct inferior_list_entry *entry, void *data)
2039 struct lwp_info *lp = (struct lwp_info *) entry;
2040 struct thread_info *thread = get_lwp_thread (lp);
2042 if (thread->last_status.kind == TARGET_WAITKIND_IGNORE
2043 && thread->last_resume_kind == resume_step
2044 && lp->status_pending_p)
2050 /* Select the Nth LWP that has had a SIGTRAP event that should be
2054 select_event_lwp_callback (struct inferior_list_entry *entry, void *data)
2056 struct lwp_info *lp = (struct lwp_info *) entry;
2057 struct thread_info *thread = get_lwp_thread (lp);
2058 int *selector = data;
2060 gdb_assert (selector != NULL);
2062 /* Select only resumed LWPs that have a SIGTRAP event pending. */
2063 if (thread->last_resume_kind != resume_stop
2064 && thread->last_status.kind == TARGET_WAITKIND_IGNORE
2065 && lp->status_pending_p
2066 && WIFSTOPPED (lp->status_pending)
2067 && WSTOPSIG (lp->status_pending) == SIGTRAP
2068 && !breakpoint_inserted_here (lp->stop_pc))
2069 if ((*selector)-- == 0)
2076 cancel_breakpoints_callback (struct inferior_list_entry *entry, void *data)
2078 struct lwp_info *lp = (struct lwp_info *) entry;
2079 struct thread_info *thread = get_lwp_thread (lp);
2080 struct lwp_info *event_lp = data;
2082 /* Leave the LWP that has been elected to receive a SIGTRAP alone. */
2086 /* If a LWP other than the LWP that we're reporting an event for has
2087 hit a GDB breakpoint (as opposed to some random trap signal),
2088 then just arrange for it to hit it again later. We don't keep
2089 the SIGTRAP status and don't forward the SIGTRAP signal to the
2090 LWP. We will handle the current event, eventually we will resume
2091 all LWPs, and this one will get its breakpoint trap again.
2093 If we do not do this, then we run the risk that the user will
2094 delete or disable the breakpoint, but the LWP will have already
2097 if (thread->last_resume_kind != resume_stop
2098 && thread->last_status.kind == TARGET_WAITKIND_IGNORE
2099 && lp->status_pending_p
2100 && WIFSTOPPED (lp->status_pending)
2101 && WSTOPSIG (lp->status_pending) == SIGTRAP
2103 && !lp->stopped_by_watchpoint
2104 && cancel_breakpoint (lp))
2105 /* Throw away the SIGTRAP. */
2106 lp->status_pending_p = 0;
2112 linux_cancel_breakpoints (void)
2114 find_inferior (&all_lwps, cancel_breakpoints_callback, NULL);
2117 /* Select one LWP out of those that have events pending. */
2120 select_event_lwp (struct lwp_info **orig_lp)
2123 int random_selector;
2124 struct lwp_info *event_lp;
2126 /* Give preference to any LWP that is being single-stepped. */
2128 = (struct lwp_info *) find_inferior (&all_lwps,
2129 select_singlestep_lwp_callback, NULL);
2130 if (event_lp != NULL)
2134 "SEL: Select single-step %s\n",
2135 target_pid_to_str (ptid_of (event_lp)));
2139 /* No single-stepping LWP. Select one at random, out of those
2140 which have had SIGTRAP events. */
2142 /* First see how many SIGTRAP events we have. */
2143 find_inferior (&all_lwps, count_events_callback, &num_events);
2145 /* Now randomly pick a LWP out of those that have had a SIGTRAP. */
2146 random_selector = (int)
2147 ((num_events * (double) rand ()) / (RAND_MAX + 1.0));
2149 if (debug_threads && num_events > 1)
2151 "SEL: Found %d SIGTRAP events, selecting #%d\n",
2152 num_events, random_selector);
2154 event_lp = (struct lwp_info *) find_inferior (&all_lwps,
2155 select_event_lwp_callback,
2159 if (event_lp != NULL)
2161 /* Switch the event LWP. */
2162 *orig_lp = event_lp;
2166 /* Decrement the suspend count of an LWP. */
2169 unsuspend_one_lwp (struct inferior_list_entry *entry, void *except)
2171 struct lwp_info *lwp = (struct lwp_info *) entry;
2173 /* Ignore EXCEPT. */
2179 gdb_assert (lwp->suspended >= 0);
2183 /* Decrement the suspend count of all LWPs, except EXCEPT, if non
2187 unsuspend_all_lwps (struct lwp_info *except)
2189 find_inferior (&all_lwps, unsuspend_one_lwp, except);
2192 static void move_out_of_jump_pad_callback (struct inferior_list_entry *entry);
2193 static int stuck_in_jump_pad_callback (struct inferior_list_entry *entry,
2195 static int lwp_running (struct inferior_list_entry *entry, void *data);
2196 static ptid_t linux_wait_1 (ptid_t ptid,
2197 struct target_waitstatus *ourstatus,
2198 int target_options);
2200 /* Stabilize threads (move out of jump pads).
2202 If a thread is midway collecting a fast tracepoint, we need to
2203 finish the collection and move it out of the jump pad before
2204 reporting the signal.
2206 This avoids recursion while collecting (when a signal arrives
2207 midway, and the signal handler itself collects), which would trash
2208 the trace buffer. In case the user set a breakpoint in a signal
2209 handler, this avoids the backtrace showing the jump pad, etc..
2210 Most importantly, there are certain things we can't do safely if
2211 threads are stopped in a jump pad (or in its callee's). For
2214 - starting a new trace run. A thread still collecting the
2215 previous run, could trash the trace buffer when resumed. The trace
2216 buffer control structures would have been reset but the thread had
2217 no way to tell. The thread could even midway memcpy'ing to the
2218 buffer, which would mean that when resumed, it would clobber the
2219 trace buffer that had been set for a new run.
2221 - we can't rewrite/reuse the jump pads for new tracepoints
2222 safely. Say you do tstart while a thread is stopped midway while
2223 collecting. When the thread is later resumed, it finishes the
2224 collection, and returns to the jump pad, to execute the original
2225 instruction that was under the tracepoint jump at the time the
2226 older run had been started. If the jump pad had been rewritten
2227 since for something else in the new run, the thread would now
2228 execute the wrong / random instructions. */
2231 linux_stabilize_threads (void)
2233 struct thread_info *save_inferior;
2234 struct lwp_info *lwp_stuck;
2237 = (struct lwp_info *) find_inferior (&all_lwps,
2238 stuck_in_jump_pad_callback, NULL);
2239 if (lwp_stuck != NULL)
2242 fprintf (stderr, "can't stabilize, LWP %ld is stuck in jump pad\n",
2243 lwpid_of (lwp_stuck));
2247 save_inferior = current_inferior;
2249 stabilizing_threads = 1;
2252 for_each_inferior (&all_lwps, move_out_of_jump_pad_callback);
2254 /* Loop until all are stopped out of the jump pads. */
2255 while (find_inferior (&all_lwps, lwp_running, NULL) != NULL)
2257 struct target_waitstatus ourstatus;
2258 struct lwp_info *lwp;
2261 /* Note that we go through the full wait even loop. While
2262 moving threads out of jump pad, we need to be able to step
2263 over internal breakpoints and such. */
2264 linux_wait_1 (minus_one_ptid, &ourstatus, 0);
2266 if (ourstatus.kind == TARGET_WAITKIND_STOPPED)
2268 lwp = get_thread_lwp (current_inferior);
2273 if (ourstatus.value.sig != GDB_SIGNAL_0
2274 || current_inferior->last_resume_kind == resume_stop)
2276 wstat = W_STOPCODE (gdb_signal_to_host (ourstatus.value.sig));
2277 enqueue_one_deferred_signal (lwp, &wstat);
2282 find_inferior (&all_lwps, unsuspend_one_lwp, NULL);
2284 stabilizing_threads = 0;
2286 current_inferior = save_inferior;
2291 = (struct lwp_info *) find_inferior (&all_lwps,
2292 stuck_in_jump_pad_callback, NULL);
2293 if (lwp_stuck != NULL)
2294 fprintf (stderr, "couldn't stabilize, LWP %ld got stuck in jump pad\n",
2295 lwpid_of (lwp_stuck));
2299 /* Wait for process, returns status. */
2302 linux_wait_1 (ptid_t ptid,
2303 struct target_waitstatus *ourstatus, int target_options)
2306 struct lwp_info *event_child;
2309 int step_over_finished;
2310 int bp_explains_trap;
2311 int maybe_internal_trap;
2315 /* Translate generic target options into linux options. */
2317 if (target_options & TARGET_WNOHANG)
2321 bp_explains_trap = 0;
2323 ourstatus->kind = TARGET_WAITKIND_IGNORE;
2325 /* If we were only supposed to resume one thread, only wait for
2326 that thread - if it's still alive. If it died, however - which
2327 can happen if we're coming from the thread death case below -
2328 then we need to make sure we restart the other threads. We could
2329 pick a thread at random or restart all; restarting all is less
2332 && !ptid_equal (cont_thread, null_ptid)
2333 && !ptid_equal (cont_thread, minus_one_ptid))
2335 struct thread_info *thread;
2337 thread = (struct thread_info *) find_inferior_id (&all_threads,
2340 /* No stepping, no signal - unless one is pending already, of course. */
2343 struct thread_resume resume_info;
2344 resume_info.thread = minus_one_ptid;
2345 resume_info.kind = resume_continue;
2346 resume_info.sig = 0;
2347 linux_resume (&resume_info, 1);
2353 if (ptid_equal (step_over_bkpt, null_ptid))
2354 pid = linux_wait_for_event (ptid, &w, options);
2358 fprintf (stderr, "step_over_bkpt set [%s], doing a blocking wait\n",
2359 target_pid_to_str (step_over_bkpt));
2360 pid = linux_wait_for_event (step_over_bkpt, &w, options & ~WNOHANG);
2363 if (pid == 0) /* only if TARGET_WNOHANG */
2366 event_child = get_thread_lwp (current_inferior);
2368 /* If we are waiting for a particular child, and it exited,
2369 linux_wait_for_event will return its exit status. Similarly if
2370 the last child exited. If this is not the last child, however,
2371 do not report it as exited until there is a 'thread exited' response
2372 available in the remote protocol. Instead, just wait for another event.
2373 This should be safe, because if the thread crashed we will already
2374 have reported the termination signal to GDB; that should stop any
2375 in-progress stepping operations, etc.
2377 Report the exit status of the last thread to exit. This matches
2378 LinuxThreads' behavior. */
2380 if (last_thread_of_process_p (current_inferior))
2382 if (WIFEXITED (w) || WIFSIGNALED (w))
2386 ourstatus->kind = TARGET_WAITKIND_EXITED;
2387 ourstatus->value.integer = WEXITSTATUS (w);
2391 "\nChild exited with retcode = %x \n",
2396 ourstatus->kind = TARGET_WAITKIND_SIGNALLED;
2397 ourstatus->value.sig = gdb_signal_from_host (WTERMSIG (w));
2401 "\nChild terminated with signal = %x \n",
2406 return ptid_of (event_child);
2411 if (!WIFSTOPPED (w))
2415 /* If this event was not handled before, and is not a SIGTRAP, we
2416 report it. SIGILL and SIGSEGV are also treated as traps in case
2417 a breakpoint is inserted at the current PC. If this target does
2418 not support internal breakpoints at all, we also report the
2419 SIGTRAP without further processing; it's of no concern to us. */
2421 = (supports_breakpoints ()
2422 && (WSTOPSIG (w) == SIGTRAP
2423 || ((WSTOPSIG (w) == SIGILL
2424 || WSTOPSIG (w) == SIGSEGV)
2425 && (*the_low_target.breakpoint_at) (event_child->stop_pc))));
2427 if (maybe_internal_trap)
2429 /* Handle anything that requires bookkeeping before deciding to
2430 report the event or continue waiting. */
2432 /* First check if we can explain the SIGTRAP with an internal
2433 breakpoint, or if we should possibly report the event to GDB.
2434 Do this before anything that may remove or insert a
2436 bp_explains_trap = breakpoint_inserted_here (event_child->stop_pc);
2438 /* We have a SIGTRAP, possibly a step-over dance has just
2439 finished. If so, tweak the state machine accordingly,
2440 reinsert breakpoints and delete any reinsert (software
2441 single-step) breakpoints. */
2442 step_over_finished = finish_step_over (event_child);
2444 /* Now invoke the callbacks of any internal breakpoints there. */
2445 check_breakpoints (event_child->stop_pc);
2447 /* Handle tracepoint data collecting. This may overflow the
2448 trace buffer, and cause a tracing stop, removing
2450 trace_event = handle_tracepoints (event_child);
2452 if (bp_explains_trap)
2454 /* If we stepped or ran into an internal breakpoint, we've
2455 already handled it. So next time we resume (from this
2456 PC), we should step over it. */
2458 fprintf (stderr, "Hit a gdbserver breakpoint.\n");
2460 if (breakpoint_here (event_child->stop_pc))
2461 event_child->need_step_over = 1;
2466 /* We have some other signal, possibly a step-over dance was in
2467 progress, and it should be cancelled too. */
2468 step_over_finished = finish_step_over (event_child);
2471 /* We have all the data we need. Either report the event to GDB, or
2472 resume threads and keep waiting for more. */
2474 /* If we're collecting a fast tracepoint, finish the collection and
2475 move out of the jump pad before delivering a signal. See
2476 linux_stabilize_threads. */
2479 && WSTOPSIG (w) != SIGTRAP
2480 && supports_fast_tracepoints ()
2481 && agent_loaded_p ())
2485 "Got signal %d for LWP %ld. Check if we need "
2486 "to defer or adjust it.\n",
2487 WSTOPSIG (w), lwpid_of (event_child));
2489 /* Allow debugging the jump pad itself. */
2490 if (current_inferior->last_resume_kind != resume_step
2491 && maybe_move_out_of_jump_pad (event_child, &w))
2493 enqueue_one_deferred_signal (event_child, &w);
2497 "Signal %d for LWP %ld deferred (in jump pad)\n",
2498 WSTOPSIG (w), lwpid_of (event_child));
2500 linux_resume_one_lwp (event_child, 0, 0, NULL);
2505 if (event_child->collecting_fast_tracepoint)
2509 LWP %ld was trying to move out of the jump pad (%d). \
2510 Check if we're already there.\n",
2511 lwpid_of (event_child),
2512 event_child->collecting_fast_tracepoint);
2516 event_child->collecting_fast_tracepoint
2517 = linux_fast_tracepoint_collecting (event_child, NULL);
2519 if (event_child->collecting_fast_tracepoint != 1)
2521 /* No longer need this breakpoint. */
2522 if (event_child->exit_jump_pad_bkpt != NULL)
2526 "No longer need exit-jump-pad bkpt; removing it."
2527 "stopping all threads momentarily.\n");
2529 /* Other running threads could hit this breakpoint.
2530 We don't handle moribund locations like GDB does,
2531 instead we always pause all threads when removing
2532 breakpoints, so that any step-over or
2533 decr_pc_after_break adjustment is always taken
2534 care of while the breakpoint is still
2536 stop_all_lwps (1, event_child);
2537 cancel_breakpoints ();
2539 delete_breakpoint (event_child->exit_jump_pad_bkpt);
2540 event_child->exit_jump_pad_bkpt = NULL;
2542 unstop_all_lwps (1, event_child);
2544 gdb_assert (event_child->suspended >= 0);
2548 if (event_child->collecting_fast_tracepoint == 0)
2552 "fast tracepoint finished "
2553 "collecting successfully.\n");
2555 /* We may have a deferred signal to report. */
2556 if (dequeue_one_deferred_signal (event_child, &w))
2559 fprintf (stderr, "dequeued one signal.\n");
2564 fprintf (stderr, "no deferred signals.\n");
2566 if (stabilizing_threads)
2568 ourstatus->kind = TARGET_WAITKIND_STOPPED;
2569 ourstatus->value.sig = GDB_SIGNAL_0;
2570 return ptid_of (event_child);
2576 /* Check whether GDB would be interested in this event. */
2578 /* If GDB is not interested in this signal, don't stop other
2579 threads, and don't report it to GDB. Just resume the inferior
2580 right away. We do this for threading-related signals as well as
2581 any that GDB specifically requested we ignore. But never ignore
2582 SIGSTOP if we sent it ourselves, and do not ignore signals when
2583 stepping - they may require special handling to skip the signal
2585 /* FIXME drow/2002-06-09: Get signal numbers from the inferior's
2588 && current_inferior->last_resume_kind != resume_step
2590 #if defined (USE_THREAD_DB) && !defined (__ANDROID__)
2591 (current_process ()->private->thread_db != NULL
2592 && (WSTOPSIG (w) == __SIGRTMIN
2593 || WSTOPSIG (w) == __SIGRTMIN + 1))
2596 (pass_signals[gdb_signal_from_host (WSTOPSIG (w))]
2597 && !(WSTOPSIG (w) == SIGSTOP
2598 && current_inferior->last_resume_kind == resume_stop))))
2600 siginfo_t info, *info_p;
2603 fprintf (stderr, "Ignored signal %d for LWP %ld.\n",
2604 WSTOPSIG (w), lwpid_of (event_child));
2606 if (ptrace (PTRACE_GETSIGINFO, lwpid_of (event_child),
2607 (PTRACE_ARG3_TYPE) 0, &info) == 0)
2611 linux_resume_one_lwp (event_child, event_child->stepping,
2612 WSTOPSIG (w), info_p);
2616 /* If GDB wanted this thread to single step, we always want to
2617 report the SIGTRAP, and let GDB handle it. Watchpoints should
2618 always be reported. So should signals we can't explain. A
2619 SIGTRAP we can't explain could be a GDB breakpoint --- we may or
2620 not support Z0 breakpoints. If we do, we're be able to handle
2621 GDB breakpoints on top of internal breakpoints, by handling the
2622 internal breakpoint and still reporting the event to GDB. If we
2623 don't, we're out of luck, GDB won't see the breakpoint hit. */
2624 report_to_gdb = (!maybe_internal_trap
2625 || current_inferior->last_resume_kind == resume_step
2626 || event_child->stopped_by_watchpoint
2627 || (!step_over_finished
2628 && !bp_explains_trap && !trace_event)
2629 || (gdb_breakpoint_here (event_child->stop_pc)
2630 && gdb_condition_true_at_breakpoint (event_child->stop_pc)
2631 && gdb_no_commands_at_breakpoint (event_child->stop_pc)));
2633 run_breakpoint_commands (event_child->stop_pc);
2635 /* We found no reason GDB would want us to stop. We either hit one
2636 of our own breakpoints, or finished an internal step GDB
2637 shouldn't know about. */
2642 if (bp_explains_trap)
2643 fprintf (stderr, "Hit a gdbserver breakpoint.\n");
2644 if (step_over_finished)
2645 fprintf (stderr, "Step-over finished.\n");
2647 fprintf (stderr, "Tracepoint event.\n");
2650 /* We're not reporting this breakpoint to GDB, so apply the
2651 decr_pc_after_break adjustment to the inferior's regcache
2654 if (the_low_target.set_pc != NULL)
2656 struct regcache *regcache
2657 = get_thread_regcache (get_lwp_thread (event_child), 1);
2658 (*the_low_target.set_pc) (regcache, event_child->stop_pc);
2661 /* We may have finished stepping over a breakpoint. If so,
2662 we've stopped and suspended all LWPs momentarily except the
2663 stepping one. This is where we resume them all again. We're
2664 going to keep waiting, so use proceed, which handles stepping
2665 over the next breakpoint. */
2667 fprintf (stderr, "proceeding all threads.\n");
2669 if (step_over_finished)
2670 unsuspend_all_lwps (event_child);
2672 proceed_all_lwps ();
2678 if (current_inferior->last_resume_kind == resume_step)
2679 fprintf (stderr, "GDB wanted to single-step, reporting event.\n");
2680 if (event_child->stopped_by_watchpoint)
2681 fprintf (stderr, "Stopped by watchpoint.\n");
2682 if (gdb_breakpoint_here (event_child->stop_pc))
2683 fprintf (stderr, "Stopped by GDB breakpoint.\n");
2685 fprintf (stderr, "Hit a non-gdbserver trap event.\n");
2688 /* Alright, we're going to report a stop. */
2690 if (!non_stop && !stabilizing_threads)
2692 /* In all-stop, stop all threads. */
2693 stop_all_lwps (0, NULL);
2695 /* If we're not waiting for a specific LWP, choose an event LWP
2696 from among those that have had events. Giving equal priority
2697 to all LWPs that have had events helps prevent
2699 if (ptid_equal (ptid, minus_one_ptid))
2701 event_child->status_pending_p = 1;
2702 event_child->status_pending = w;
2704 select_event_lwp (&event_child);
2706 event_child->status_pending_p = 0;
2707 w = event_child->status_pending;
2710 /* Now that we've selected our final event LWP, cancel any
2711 breakpoints in other LWPs that have hit a GDB breakpoint.
2712 See the comment in cancel_breakpoints_callback to find out
2714 find_inferior (&all_lwps, cancel_breakpoints_callback, event_child);
2716 /* If we were going a step-over, all other threads but the stepping one
2717 had been paused in start_step_over, with their suspend counts
2718 incremented. We don't want to do a full unstop/unpause, because we're
2719 in all-stop mode (so we want threads stopped), but we still need to
2720 unsuspend the other threads, to decrement their `suspended' count
2722 if (step_over_finished)
2723 unsuspend_all_lwps (event_child);
2725 /* Stabilize threads (move out of jump pads). */
2726 stabilize_threads ();
2730 /* If we just finished a step-over, then all threads had been
2731 momentarily paused. In all-stop, that's fine, we want
2732 threads stopped by now anyway. In non-stop, we need to
2733 re-resume threads that GDB wanted to be running. */
2734 if (step_over_finished)
2735 unstop_all_lwps (1, event_child);
2738 ourstatus->kind = TARGET_WAITKIND_STOPPED;
2740 if (current_inferior->last_resume_kind == resume_stop
2741 && WSTOPSIG (w) == SIGSTOP)
2743 /* A thread that has been requested to stop by GDB with vCont;t,
2744 and it stopped cleanly, so report as SIG0. The use of
2745 SIGSTOP is an implementation detail. */
2746 ourstatus->value.sig = GDB_SIGNAL_0;
2748 else if (current_inferior->last_resume_kind == resume_stop
2749 && WSTOPSIG (w) != SIGSTOP)
2751 /* A thread that has been requested to stop by GDB with vCont;t,
2752 but, it stopped for other reasons. */
2753 ourstatus->value.sig = gdb_signal_from_host (WSTOPSIG (w));
2757 ourstatus->value.sig = gdb_signal_from_host (WSTOPSIG (w));
2760 gdb_assert (ptid_equal (step_over_bkpt, null_ptid));
2763 fprintf (stderr, "linux_wait ret = %s, %d, %d\n",
2764 target_pid_to_str (ptid_of (event_child)),
2766 ourstatus->value.sig);
2768 return ptid_of (event_child);
2771 /* Get rid of any pending event in the pipe. */
2773 async_file_flush (void)
2779 ret = read (linux_event_pipe[0], &buf, 1);
2780 while (ret >= 0 || (ret == -1 && errno == EINTR));
2783 /* Put something in the pipe, so the event loop wakes up. */
2785 async_file_mark (void)
2789 async_file_flush ();
2792 ret = write (linux_event_pipe[1], "+", 1);
2793 while (ret == 0 || (ret == -1 && errno == EINTR));
2795 /* Ignore EAGAIN. If the pipe is full, the event loop will already
2796 be awakened anyway. */
2800 linux_wait (ptid_t ptid,
2801 struct target_waitstatus *ourstatus, int target_options)
2806 fprintf (stderr, "linux_wait: [%s]\n", target_pid_to_str (ptid));
2808 /* Flush the async file first. */
2809 if (target_is_async_p ())
2810 async_file_flush ();
2812 event_ptid = linux_wait_1 (ptid, ourstatus, target_options);
2814 /* If at least one stop was reported, there may be more. A single
2815 SIGCHLD can signal more than one child stop. */
2816 if (target_is_async_p ()
2817 && (target_options & TARGET_WNOHANG) != 0
2818 && !ptid_equal (event_ptid, null_ptid))
2824 /* Send a signal to an LWP. */
2827 kill_lwp (unsigned long lwpid, int signo)
2829 /* Use tkill, if possible, in case we are using nptl threads. If tkill
2830 fails, then we are not using nptl threads and we should be using kill. */
2834 static int tkill_failed;
2841 ret = syscall (__NR_tkill, lwpid, signo);
2842 if (errno != ENOSYS)
2849 return kill (lwpid, signo);
2853 linux_stop_lwp (struct lwp_info *lwp)
2859 send_sigstop (struct lwp_info *lwp)
2863 pid = lwpid_of (lwp);
2865 /* If we already have a pending stop signal for this process, don't
2867 if (lwp->stop_expected)
2870 fprintf (stderr, "Have pending sigstop for lwp %d\n", pid);
2876 fprintf (stderr, "Sending sigstop to lwp %d\n", pid);
2878 lwp->stop_expected = 1;
2879 kill_lwp (pid, SIGSTOP);
2883 send_sigstop_callback (struct inferior_list_entry *entry, void *except)
2885 struct lwp_info *lwp = (struct lwp_info *) entry;
2887 /* Ignore EXCEPT. */
2898 /* Increment the suspend count of an LWP, and stop it, if not stopped
2901 suspend_and_send_sigstop_callback (struct inferior_list_entry *entry,
2904 struct lwp_info *lwp = (struct lwp_info *) entry;
2906 /* Ignore EXCEPT. */
2912 return send_sigstop_callback (entry, except);
2916 mark_lwp_dead (struct lwp_info *lwp, int wstat)
2918 /* It's dead, really. */
2921 /* Store the exit status for later. */
2922 lwp->status_pending_p = 1;
2923 lwp->status_pending = wstat;
2925 /* Prevent trying to stop it. */
2928 /* No further stops are expected from a dead lwp. */
2929 lwp->stop_expected = 0;
2933 wait_for_sigstop (struct inferior_list_entry *entry)
2935 struct lwp_info *lwp = (struct lwp_info *) entry;
2936 struct thread_info *saved_inferior;
2945 fprintf (stderr, "wait_for_sigstop: LWP %ld already stopped\n",
2950 saved_inferior = current_inferior;
2951 if (saved_inferior != NULL)
2952 saved_tid = ((struct inferior_list_entry *) saved_inferior)->id;
2954 saved_tid = null_ptid; /* avoid bogus unused warning */
2956 ptid = lwp->head.id;
2959 fprintf (stderr, "wait_for_sigstop: pulling one event\n");
2961 pid = linux_wait_for_event (ptid, &wstat, __WALL);
2963 /* If we stopped with a non-SIGSTOP signal, save it for later
2964 and record the pending SIGSTOP. If the process exited, just
2966 if (WIFSTOPPED (wstat))
2969 fprintf (stderr, "LWP %ld stopped with signal %d\n",
2970 lwpid_of (lwp), WSTOPSIG (wstat));
2972 if (WSTOPSIG (wstat) != SIGSTOP)
2975 fprintf (stderr, "LWP %ld stopped with non-sigstop status %06x\n",
2976 lwpid_of (lwp), wstat);
2978 lwp->status_pending_p = 1;
2979 lwp->status_pending = wstat;
2985 fprintf (stderr, "Process %d exited while stopping LWPs\n", pid);
2987 lwp = find_lwp_pid (pid_to_ptid (pid));
2990 /* Leave this status pending for the next time we're able to
2991 report it. In the mean time, we'll report this lwp as
2992 dead to GDB, so GDB doesn't try to read registers and
2993 memory from it. This can only happen if this was the
2994 last thread of the process; otherwise, PID is removed
2995 from the thread tables before linux_wait_for_event
2997 mark_lwp_dead (lwp, wstat);
3001 if (saved_inferior == NULL || linux_thread_alive (saved_tid))
3002 current_inferior = saved_inferior;
3006 fprintf (stderr, "Previously current thread died.\n");
3010 /* We can't change the current inferior behind GDB's back,
3011 otherwise, a subsequent command may apply to the wrong
3013 current_inferior = NULL;
3017 /* Set a valid thread as current. */
3018 set_desired_inferior (0);
3023 /* Returns true if LWP ENTRY is stopped in a jump pad, and we can't
3024 move it out, because we need to report the stop event to GDB. For
3025 example, if the user puts a breakpoint in the jump pad, it's
3026 because she wants to debug it. */
3029 stuck_in_jump_pad_callback (struct inferior_list_entry *entry, void *data)
3031 struct lwp_info *lwp = (struct lwp_info *) entry;
3032 struct thread_info *thread = get_lwp_thread (lwp);
3034 gdb_assert (lwp->suspended == 0);
3035 gdb_assert (lwp->stopped);
3037 /* Allow debugging the jump pad, gdb_collect, etc.. */
3038 return (supports_fast_tracepoints ()
3039 && agent_loaded_p ()
3040 && (gdb_breakpoint_here (lwp->stop_pc)
3041 || lwp->stopped_by_watchpoint
3042 || thread->last_resume_kind == resume_step)
3043 && linux_fast_tracepoint_collecting (lwp, NULL));
3047 move_out_of_jump_pad_callback (struct inferior_list_entry *entry)
3049 struct lwp_info *lwp = (struct lwp_info *) entry;
3050 struct thread_info *thread = get_lwp_thread (lwp);
3053 gdb_assert (lwp->suspended == 0);
3054 gdb_assert (lwp->stopped);
3056 wstat = lwp->status_pending_p ? &lwp->status_pending : NULL;
3058 /* Allow debugging the jump pad, gdb_collect, etc. */
3059 if (!gdb_breakpoint_here (lwp->stop_pc)
3060 && !lwp->stopped_by_watchpoint
3061 && thread->last_resume_kind != resume_step
3062 && maybe_move_out_of_jump_pad (lwp, wstat))
3066 "LWP %ld needs stabilizing (in jump pad)\n",
3071 lwp->status_pending_p = 0;
3072 enqueue_one_deferred_signal (lwp, wstat);
3076 "Signal %d for LWP %ld deferred "
3078 WSTOPSIG (*wstat), lwpid_of (lwp));
3081 linux_resume_one_lwp (lwp, 0, 0, NULL);
3088 lwp_running (struct inferior_list_entry *entry, void *data)
3090 struct lwp_info *lwp = (struct lwp_info *) entry;
3099 /* Stop all lwps that aren't stopped yet, except EXCEPT, if not NULL.
3100 If SUSPEND, then also increase the suspend count of every LWP,
3104 stop_all_lwps (int suspend, struct lwp_info *except)
3106 /* Should not be called recursively. */
3107 gdb_assert (stopping_threads == NOT_STOPPING_THREADS);
3109 stopping_threads = (suspend
3110 ? STOPPING_AND_SUSPENDING_THREADS
3111 : STOPPING_THREADS);
3114 find_inferior (&all_lwps, suspend_and_send_sigstop_callback, except);
3116 find_inferior (&all_lwps, send_sigstop_callback, except);
3117 for_each_inferior (&all_lwps, wait_for_sigstop);
3118 stopping_threads = NOT_STOPPING_THREADS;
3121 /* Resume execution of the inferior process.
3122 If STEP is nonzero, single-step it.
3123 If SIGNAL is nonzero, give it that signal. */
3126 linux_resume_one_lwp (struct lwp_info *lwp,
3127 int step, int signal, siginfo_t *info)
3129 struct thread_info *saved_inferior;
3130 int fast_tp_collecting;
3132 if (lwp->stopped == 0)
3135 fast_tp_collecting = lwp->collecting_fast_tracepoint;
3137 gdb_assert (!stabilizing_threads || fast_tp_collecting);
3139 /* Cancel actions that rely on GDB not changing the PC (e.g., the
3140 user used the "jump" command, or "set $pc = foo"). */
3141 if (lwp->stop_pc != get_pc (lwp))
3143 /* Collecting 'while-stepping' actions doesn't make sense
3145 release_while_stepping_state_list (get_lwp_thread (lwp));
3148 /* If we have pending signals or status, and a new signal, enqueue the
3149 signal. Also enqueue the signal if we are waiting to reinsert a
3150 breakpoint; it will be picked up again below. */
3152 && (lwp->status_pending_p
3153 || lwp->pending_signals != NULL
3154 || lwp->bp_reinsert != 0
3155 || fast_tp_collecting))
3157 struct pending_signals *p_sig;
3158 p_sig = xmalloc (sizeof (*p_sig));
3159 p_sig->prev = lwp->pending_signals;
3160 p_sig->signal = signal;
3162 memset (&p_sig->info, 0, sizeof (siginfo_t));
3164 memcpy (&p_sig->info, info, sizeof (siginfo_t));
3165 lwp->pending_signals = p_sig;
3168 if (lwp->status_pending_p)
3171 fprintf (stderr, "Not resuming lwp %ld (%s, signal %d, stop %s);"
3172 " has pending status\n",
3173 lwpid_of (lwp), step ? "step" : "continue", signal,
3174 lwp->stop_expected ? "expected" : "not expected");
3178 saved_inferior = current_inferior;
3179 current_inferior = get_lwp_thread (lwp);
3182 fprintf (stderr, "Resuming lwp %ld (%s, signal %d, stop %s)\n",
3183 lwpid_of (lwp), step ? "step" : "continue", signal,
3184 lwp->stop_expected ? "expected" : "not expected");
3186 /* This bit needs some thinking about. If we get a signal that
3187 we must report while a single-step reinsert is still pending,
3188 we often end up resuming the thread. It might be better to
3189 (ew) allow a stack of pending events; then we could be sure that
3190 the reinsert happened right away and not lose any signals.
3192 Making this stack would also shrink the window in which breakpoints are
3193 uninserted (see comment in linux_wait_for_lwp) but not enough for
3194 complete correctness, so it won't solve that problem. It may be
3195 worthwhile just to solve this one, however. */
3196 if (lwp->bp_reinsert != 0)
3199 fprintf (stderr, " pending reinsert at 0x%s\n",
3200 paddress (lwp->bp_reinsert));
3202 if (can_hardware_single_step ())
3204 if (fast_tp_collecting == 0)
3207 fprintf (stderr, "BAD - reinserting but not stepping.\n");
3209 fprintf (stderr, "BAD - reinserting and suspended(%d).\n",
3216 /* Postpone any pending signal. It was enqueued above. */
3220 if (fast_tp_collecting == 1)
3224 lwp %ld wants to get out of fast tracepoint jump pad (exit-jump-pad-bkpt)\n",
3227 /* Postpone any pending signal. It was enqueued above. */
3230 else if (fast_tp_collecting == 2)
3234 lwp %ld wants to get out of fast tracepoint jump pad single-stepping\n",
3237 if (can_hardware_single_step ())
3240 fatal ("moving out of jump pad single-stepping"
3241 " not implemented on this target");
3243 /* Postpone any pending signal. It was enqueued above. */
3247 /* If we have while-stepping actions in this thread set it stepping.
3248 If we have a signal to deliver, it may or may not be set to
3249 SIG_IGN, we don't know. Assume so, and allow collecting
3250 while-stepping into a signal handler. A possible smart thing to
3251 do would be to set an internal breakpoint at the signal return
3252 address, continue, and carry on catching this while-stepping
3253 action only when that breakpoint is hit. A future
3255 if (get_lwp_thread (lwp)->while_stepping != NULL
3256 && can_hardware_single_step ())
3260 "lwp %ld has a while-stepping action -> forcing step.\n",
3265 if (debug_threads && the_low_target.get_pc != NULL)
3267 struct regcache *regcache = get_thread_regcache (current_inferior, 1);
3268 CORE_ADDR pc = (*the_low_target.get_pc) (regcache);
3269 fprintf (stderr, " resuming from pc 0x%lx\n", (long) pc);
3272 /* If we have pending signals, consume one unless we are trying to
3273 reinsert a breakpoint or we're trying to finish a fast tracepoint
3275 if (lwp->pending_signals != NULL
3276 && lwp->bp_reinsert == 0
3277 && fast_tp_collecting == 0)
3279 struct pending_signals **p_sig;
3281 p_sig = &lwp->pending_signals;
3282 while ((*p_sig)->prev != NULL)
3283 p_sig = &(*p_sig)->prev;
3285 signal = (*p_sig)->signal;
3286 if ((*p_sig)->info.si_signo != 0)
3287 ptrace (PTRACE_SETSIGINFO, lwpid_of (lwp), (PTRACE_ARG3_TYPE) 0,
3294 if (the_low_target.prepare_to_resume != NULL)
3295 the_low_target.prepare_to_resume (lwp);
3297 regcache_invalidate_one ((struct inferior_list_entry *)
3298 get_lwp_thread (lwp));
3301 lwp->stopped_by_watchpoint = 0;
3302 lwp->stepping = step;
3303 ptrace (step ? PTRACE_SINGLESTEP : PTRACE_CONT, lwpid_of (lwp),
3304 (PTRACE_ARG3_TYPE) 0,
3305 /* Coerce to a uintptr_t first to avoid potential gcc warning
3306 of coercing an 8 byte integer to a 4 byte pointer. */
3307 (PTRACE_ARG4_TYPE) (uintptr_t) signal);
3309 current_inferior = saved_inferior;
3312 /* ESRCH from ptrace either means that the thread was already
3313 running (an error) or that it is gone (a race condition). If
3314 it's gone, we will get a notification the next time we wait,
3315 so we can ignore the error. We could differentiate these
3316 two, but it's tricky without waiting; the thread still exists
3317 as a zombie, so sending it signal 0 would succeed. So just
3322 perror_with_name ("ptrace");
3326 struct thread_resume_array
3328 struct thread_resume *resume;
3332 /* This function is called once per thread. We look up the thread
3333 in RESUME_PTR, and mark the thread with a pointer to the appropriate
3336 This algorithm is O(threads * resume elements), but resume elements
3337 is small (and will remain small at least until GDB supports thread
3340 linux_set_resume_request (struct inferior_list_entry *entry, void *arg)
3342 struct lwp_info *lwp;
3343 struct thread_info *thread;
3345 struct thread_resume_array *r;
3347 thread = (struct thread_info *) entry;
3348 lwp = get_thread_lwp (thread);
3351 for (ndx = 0; ndx < r->n; ndx++)
3353 ptid_t ptid = r->resume[ndx].thread;
3354 if (ptid_equal (ptid, minus_one_ptid)
3355 || ptid_equal (ptid, entry->id)
3356 /* Handle both 'pPID' and 'pPID.-1' as meaning 'all threads
3358 || (ptid_get_pid (ptid) == pid_of (lwp)
3359 && (ptid_is_pid (ptid)
3360 || ptid_get_lwp (ptid) == -1)))
3362 if (r->resume[ndx].kind == resume_stop
3363 && thread->last_resume_kind == resume_stop)
3366 fprintf (stderr, "already %s LWP %ld at GDB's request\n",
3367 thread->last_status.kind == TARGET_WAITKIND_STOPPED
3375 lwp->resume = &r->resume[ndx];
3376 thread->last_resume_kind = lwp->resume->kind;
3378 /* If we had a deferred signal to report, dequeue one now.
3379 This can happen if LWP gets more than one signal while
3380 trying to get out of a jump pad. */
3382 && !lwp->status_pending_p
3383 && dequeue_one_deferred_signal (lwp, &lwp->status_pending))
3385 lwp->status_pending_p = 1;
3389 "Dequeueing deferred signal %d for LWP %ld, "
3390 "leaving status pending.\n",
3391 WSTOPSIG (lwp->status_pending), lwpid_of (lwp));
3398 /* No resume action for this thread. */
3405 /* Set *FLAG_P if this lwp has an interesting status pending. */
3407 resume_status_pending_p (struct inferior_list_entry *entry, void *flag_p)
3409 struct lwp_info *lwp = (struct lwp_info *) entry;
3411 /* LWPs which will not be resumed are not interesting, because
3412 we might not wait for them next time through linux_wait. */
3413 if (lwp->resume == NULL)
3416 if (lwp->status_pending_p)
3417 * (int *) flag_p = 1;
3422 /* Return 1 if this lwp that GDB wants running is stopped at an
3423 internal breakpoint that we need to step over. It assumes that any
3424 required STOP_PC adjustment has already been propagated to the
3425 inferior's regcache. */
3428 need_step_over_p (struct inferior_list_entry *entry, void *dummy)
3430 struct lwp_info *lwp = (struct lwp_info *) entry;
3431 struct thread_info *thread;
3432 struct thread_info *saved_inferior;
3435 /* LWPs which will not be resumed are not interesting, because we
3436 might not wait for them next time through linux_wait. */
3442 "Need step over [LWP %ld]? Ignoring, not stopped\n",
3447 thread = get_lwp_thread (lwp);
3449 if (thread->last_resume_kind == resume_stop)
3453 "Need step over [LWP %ld]? Ignoring, should remain stopped\n",
3458 gdb_assert (lwp->suspended >= 0);
3464 "Need step over [LWP %ld]? Ignoring, suspended\n",
3469 if (!lwp->need_step_over)
3473 "Need step over [LWP %ld]? No\n", lwpid_of (lwp));
3476 if (lwp->status_pending_p)
3480 "Need step over [LWP %ld]? Ignoring, has pending status.\n",
3485 /* Note: PC, not STOP_PC. Either GDB has adjusted the PC already,
3489 /* If the PC has changed since we stopped, then don't do anything,
3490 and let the breakpoint/tracepoint be hit. This happens if, for
3491 instance, GDB handled the decr_pc_after_break subtraction itself,
3492 GDB is OOL stepping this thread, or the user has issued a "jump"
3493 command, or poked thread's registers herself. */
3494 if (pc != lwp->stop_pc)
3498 "Need step over [LWP %ld]? Cancelling, PC was changed. "
3499 "Old stop_pc was 0x%s, PC is now 0x%s\n",
3500 lwpid_of (lwp), paddress (lwp->stop_pc), paddress (pc));
3502 lwp->need_step_over = 0;
3506 saved_inferior = current_inferior;
3507 current_inferior = thread;
3509 /* We can only step over breakpoints we know about. */
3510 if (breakpoint_here (pc) || fast_tracepoint_jump_here (pc))
3512 /* Don't step over a breakpoint that GDB expects to hit
3513 though. If the condition is being evaluated on the target's side
3514 and it evaluate to false, step over this breakpoint as well. */
3515 if (gdb_breakpoint_here (pc)
3516 && gdb_condition_true_at_breakpoint (pc)
3517 && gdb_no_commands_at_breakpoint (pc))
3521 "Need step over [LWP %ld]? yes, but found"
3522 " GDB breakpoint at 0x%s; skipping step over\n",
3523 lwpid_of (lwp), paddress (pc));
3525 current_inferior = saved_inferior;
3532 "Need step over [LWP %ld]? yes, "
3533 "found breakpoint at 0x%s\n",
3534 lwpid_of (lwp), paddress (pc));
3536 /* We've found an lwp that needs stepping over --- return 1 so
3537 that find_inferior stops looking. */
3538 current_inferior = saved_inferior;
3540 /* If the step over is cancelled, this is set again. */
3541 lwp->need_step_over = 0;
3546 current_inferior = saved_inferior;
3550 "Need step over [LWP %ld]? No, no breakpoint found at 0x%s\n",
3551 lwpid_of (lwp), paddress (pc));
3556 /* Start a step-over operation on LWP. When LWP stopped at a
3557 breakpoint, to make progress, we need to remove the breakpoint out
3558 of the way. If we let other threads run while we do that, they may
3559 pass by the breakpoint location and miss hitting it. To avoid
3560 that, a step-over momentarily stops all threads while LWP is
3561 single-stepped while the breakpoint is temporarily uninserted from
3562 the inferior. When the single-step finishes, we reinsert the
3563 breakpoint, and let all threads that are supposed to be running,
3566 On targets that don't support hardware single-step, we don't
3567 currently support full software single-stepping. Instead, we only
3568 support stepping over the thread event breakpoint, by asking the
3569 low target where to place a reinsert breakpoint. Since this
3570 routine assumes the breakpoint being stepped over is a thread event
3571 breakpoint, it usually assumes the return address of the current
3572 function is a good enough place to set the reinsert breakpoint. */
3575 start_step_over (struct lwp_info *lwp)
3577 struct thread_info *saved_inferior;
3583 "Starting step-over on LWP %ld. Stopping all threads\n",
3586 stop_all_lwps (1, lwp);
3587 gdb_assert (lwp->suspended == 0);
3590 fprintf (stderr, "Done stopping all threads for step-over.\n");
3592 /* Note, we should always reach here with an already adjusted PC,
3593 either by GDB (if we're resuming due to GDB's request), or by our
3594 caller, if we just finished handling an internal breakpoint GDB
3595 shouldn't care about. */
3598 saved_inferior = current_inferior;
3599 current_inferior = get_lwp_thread (lwp);
3601 lwp->bp_reinsert = pc;
3602 uninsert_breakpoints_at (pc);
3603 uninsert_fast_tracepoint_jumps_at (pc);
3605 if (can_hardware_single_step ())
3611 CORE_ADDR raddr = (*the_low_target.breakpoint_reinsert_addr) ();
3612 set_reinsert_breakpoint (raddr);
3616 current_inferior = saved_inferior;
3618 linux_resume_one_lwp (lwp, step, 0, NULL);
3620 /* Require next event from this LWP. */
3621 step_over_bkpt = lwp->head.id;
3625 /* Finish a step-over. Reinsert the breakpoint we had uninserted in
3626 start_step_over, if still there, and delete any reinsert
3627 breakpoints we've set, on non hardware single-step targets. */
3630 finish_step_over (struct lwp_info *lwp)
3632 if (lwp->bp_reinsert != 0)
3635 fprintf (stderr, "Finished step over.\n");
3637 /* Reinsert any breakpoint at LWP->BP_REINSERT. Note that there
3638 may be no breakpoint to reinsert there by now. */
3639 reinsert_breakpoints_at (lwp->bp_reinsert);
3640 reinsert_fast_tracepoint_jumps_at (lwp->bp_reinsert);
3642 lwp->bp_reinsert = 0;
3644 /* Delete any software-single-step reinsert breakpoints. No
3645 longer needed. We don't have to worry about other threads
3646 hitting this trap, and later not being able to explain it,
3647 because we were stepping over a breakpoint, and we hold all
3648 threads but LWP stopped while doing that. */
3649 if (!can_hardware_single_step ())
3650 delete_reinsert_breakpoints ();
3652 step_over_bkpt = null_ptid;
3659 /* This function is called once per thread. We check the thread's resume
3660 request, which will tell us whether to resume, step, or leave the thread
3661 stopped; and what signal, if any, it should be sent.
3663 For threads which we aren't explicitly told otherwise, we preserve
3664 the stepping flag; this is used for stepping over gdbserver-placed
3667 If pending_flags was set in any thread, we queue any needed
3668 signals, since we won't actually resume. We already have a pending
3669 event to report, so we don't need to preserve any step requests;
3670 they should be re-issued if necessary. */
3673 linux_resume_one_thread (struct inferior_list_entry *entry, void *arg)
3675 struct lwp_info *lwp;
3676 struct thread_info *thread;
3678 int leave_all_stopped = * (int *) arg;
3681 thread = (struct thread_info *) entry;
3682 lwp = get_thread_lwp (thread);
3684 if (lwp->resume == NULL)
3687 if (lwp->resume->kind == resume_stop)
3690 fprintf (stderr, "resume_stop request for LWP %ld\n", lwpid_of (lwp));
3695 fprintf (stderr, "stopping LWP %ld\n", lwpid_of (lwp));
3697 /* Stop the thread, and wait for the event asynchronously,
3698 through the event loop. */
3704 fprintf (stderr, "already stopped LWP %ld\n",
3707 /* The LWP may have been stopped in an internal event that
3708 was not meant to be notified back to GDB (e.g., gdbserver
3709 breakpoint), so we should be reporting a stop event in
3712 /* If the thread already has a pending SIGSTOP, this is a
3713 no-op. Otherwise, something later will presumably resume
3714 the thread and this will cause it to cancel any pending
3715 operation, due to last_resume_kind == resume_stop. If
3716 the thread already has a pending status to report, we
3717 will still report it the next time we wait - see
3718 status_pending_p_callback. */
3720 /* If we already have a pending signal to report, then
3721 there's no need to queue a SIGSTOP, as this means we're
3722 midway through moving the LWP out of the jumppad, and we
3723 will report the pending signal as soon as that is
3725 if (lwp->pending_signals_to_report == NULL)
3729 /* For stop requests, we're done. */
3731 thread->last_status.kind = TARGET_WAITKIND_IGNORE;
3735 /* If this thread which is about to be resumed has a pending status,
3736 then don't resume any threads - we can just report the pending
3737 status. Make sure to queue any signals that would otherwise be
3738 sent. In all-stop mode, we do this decision based on if *any*
3739 thread has a pending status. If there's a thread that needs the
3740 step-over-breakpoint dance, then don't resume any other thread
3741 but that particular one. */
3742 leave_pending = (lwp->status_pending_p || leave_all_stopped);
3747 fprintf (stderr, "resuming LWP %ld\n", lwpid_of (lwp));
3749 step = (lwp->resume->kind == resume_step);
3750 linux_resume_one_lwp (lwp, step, lwp->resume->sig, NULL);
3755 fprintf (stderr, "leaving LWP %ld stopped\n", lwpid_of (lwp));
3757 /* If we have a new signal, enqueue the signal. */
3758 if (lwp->resume->sig != 0)
3760 struct pending_signals *p_sig;
3761 p_sig = xmalloc (sizeof (*p_sig));
3762 p_sig->prev = lwp->pending_signals;
3763 p_sig->signal = lwp->resume->sig;
3764 memset (&p_sig->info, 0, sizeof (siginfo_t));
3766 /* If this is the same signal we were previously stopped by,
3767 make sure to queue its siginfo. We can ignore the return
3768 value of ptrace; if it fails, we'll skip
3769 PTRACE_SETSIGINFO. */
3770 if (WIFSTOPPED (lwp->last_status)
3771 && WSTOPSIG (lwp->last_status) == lwp->resume->sig)
3772 ptrace (PTRACE_GETSIGINFO, lwpid_of (lwp), (PTRACE_ARG3_TYPE) 0,
3775 lwp->pending_signals = p_sig;
3779 thread->last_status.kind = TARGET_WAITKIND_IGNORE;
3785 linux_resume (struct thread_resume *resume_info, size_t n)
3787 struct thread_resume_array array = { resume_info, n };
3788 struct lwp_info *need_step_over = NULL;
3790 int leave_all_stopped;
3792 find_inferior (&all_threads, linux_set_resume_request, &array);
3794 /* If there is a thread which would otherwise be resumed, which has
3795 a pending status, then don't resume any threads - we can just
3796 report the pending status. Make sure to queue any signals that
3797 would otherwise be sent. In non-stop mode, we'll apply this
3798 logic to each thread individually. We consume all pending events
3799 before considering to start a step-over (in all-stop). */
3802 find_inferior (&all_lwps, resume_status_pending_p, &any_pending);
3804 /* If there is a thread which would otherwise be resumed, which is
3805 stopped at a breakpoint that needs stepping over, then don't
3806 resume any threads - have it step over the breakpoint with all
3807 other threads stopped, then resume all threads again. Make sure
3808 to queue any signals that would otherwise be delivered or
3810 if (!any_pending && supports_breakpoints ())
3812 = (struct lwp_info *) find_inferior (&all_lwps,
3813 need_step_over_p, NULL);
3815 leave_all_stopped = (need_step_over != NULL || any_pending);
3819 if (need_step_over != NULL)
3820 fprintf (stderr, "Not resuming all, need step over\n");
3821 else if (any_pending)
3823 "Not resuming, all-stop and found "
3824 "an LWP with pending status\n");
3826 fprintf (stderr, "Resuming, no pending status or step over needed\n");
3829 /* Even if we're leaving threads stopped, queue all signals we'd
3830 otherwise deliver. */
3831 find_inferior (&all_threads, linux_resume_one_thread, &leave_all_stopped);
3834 start_step_over (need_step_over);
3837 /* This function is called once per thread. We check the thread's
3838 last resume request, which will tell us whether to resume, step, or
3839 leave the thread stopped. Any signal the client requested to be
3840 delivered has already been enqueued at this point.
3842 If any thread that GDB wants running is stopped at an internal
3843 breakpoint that needs stepping over, we start a step-over operation
3844 on that particular thread, and leave all others stopped. */
3847 proceed_one_lwp (struct inferior_list_entry *entry, void *except)
3849 struct lwp_info *lwp = (struct lwp_info *) entry;
3850 struct thread_info *thread;
3858 "proceed_one_lwp: lwp %ld\n", lwpid_of (lwp));
3863 fprintf (stderr, " LWP %ld already running\n", lwpid_of (lwp));
3867 thread = get_lwp_thread (lwp);
3869 if (thread->last_resume_kind == resume_stop
3870 && thread->last_status.kind != TARGET_WAITKIND_IGNORE)
3873 fprintf (stderr, " client wants LWP to remain %ld stopped\n",
3878 if (lwp->status_pending_p)
3881 fprintf (stderr, " LWP %ld has pending status, leaving stopped\n",
3886 gdb_assert (lwp->suspended >= 0);
3891 fprintf (stderr, " LWP %ld is suspended\n", lwpid_of (lwp));
3895 if (thread->last_resume_kind == resume_stop
3896 && lwp->pending_signals_to_report == NULL
3897 && lwp->collecting_fast_tracepoint == 0)
3899 /* We haven't reported this LWP as stopped yet (otherwise, the
3900 last_status.kind check above would catch it, and we wouldn't
3901 reach here. This LWP may have been momentarily paused by a
3902 stop_all_lwps call while handling for example, another LWP's
3903 step-over. In that case, the pending expected SIGSTOP signal
3904 that was queued at vCont;t handling time will have already
3905 been consumed by wait_for_sigstop, and so we need to requeue
3906 another one here. Note that if the LWP already has a SIGSTOP
3907 pending, this is a no-op. */
3911 "Client wants LWP %ld to stop. "
3912 "Making sure it has a SIGSTOP pending\n",
3918 step = thread->last_resume_kind == resume_step;
3919 linux_resume_one_lwp (lwp, step, 0, NULL);
3924 unsuspend_and_proceed_one_lwp (struct inferior_list_entry *entry, void *except)
3926 struct lwp_info *lwp = (struct lwp_info *) entry;
3932 gdb_assert (lwp->suspended >= 0);
3934 return proceed_one_lwp (entry, except);
3937 /* When we finish a step-over, set threads running again. If there's
3938 another thread that may need a step-over, now's the time to start
3939 it. Eventually, we'll move all threads past their breakpoints. */
3942 proceed_all_lwps (void)
3944 struct lwp_info *need_step_over;
3946 /* If there is a thread which would otherwise be resumed, which is
3947 stopped at a breakpoint that needs stepping over, then don't
3948 resume any threads - have it step over the breakpoint with all
3949 other threads stopped, then resume all threads again. */
3951 if (supports_breakpoints ())
3954 = (struct lwp_info *) find_inferior (&all_lwps,
3955 need_step_over_p, NULL);
3957 if (need_step_over != NULL)
3960 fprintf (stderr, "proceed_all_lwps: found "
3961 "thread %ld needing a step-over\n",
3962 lwpid_of (need_step_over));
3964 start_step_over (need_step_over);
3970 fprintf (stderr, "Proceeding, no step-over needed\n");
3972 find_inferior (&all_lwps, proceed_one_lwp, NULL);
3975 /* Stopped LWPs that the client wanted to be running, that don't have
3976 pending statuses, are set to run again, except for EXCEPT, if not
3977 NULL. This undoes a stop_all_lwps call. */
3980 unstop_all_lwps (int unsuspend, struct lwp_info *except)
3986 "unstopping all lwps, except=(LWP %ld)\n", lwpid_of (except));
3989 "unstopping all lwps\n");
3993 find_inferior (&all_lwps, unsuspend_and_proceed_one_lwp, except);
3995 find_inferior (&all_lwps, proceed_one_lwp, except);
3999 #ifdef HAVE_LINUX_REGSETS
4001 #define use_linux_regsets 1
4004 regsets_fetch_inferior_registers (struct regcache *regcache)
4006 struct regset_info *regset;
4007 int saw_general_regs = 0;
4011 regset = target_regsets;
4013 pid = lwpid_of (get_thread_lwp (current_inferior));
4014 while (regset->size >= 0)
4019 if (regset->size == 0 || disabled_regsets[regset - target_regsets])
4025 buf = xmalloc (regset->size);
4027 nt_type = regset->nt_type;
4031 iov.iov_len = regset->size;
4032 data = (void *) &iov;
4038 res = ptrace (regset->get_request, pid,
4039 (PTRACE_ARG3_TYPE) (long) nt_type, data);
4041 res = ptrace (regset->get_request, pid, data, nt_type);
4047 /* If we get EIO on a regset, do not try it again for
4049 disabled_regsets[regset - target_regsets] = 1;
4056 sprintf (s, "ptrace(regsets_fetch_inferior_registers) PID=%d",
4061 else if (regset->type == GENERAL_REGS)
4062 saw_general_regs = 1;
4063 regset->store_function (regcache, buf);
4067 if (saw_general_regs)
4074 regsets_store_inferior_registers (struct regcache *regcache)
4076 struct regset_info *regset;
4077 int saw_general_regs = 0;
4081 regset = target_regsets;
4083 pid = lwpid_of (get_thread_lwp (current_inferior));
4084 while (regset->size >= 0)
4089 if (regset->size == 0 || disabled_regsets[regset - target_regsets])
4095 buf = xmalloc (regset->size);
4097 /* First fill the buffer with the current register set contents,
4098 in case there are any items in the kernel's regset that are
4099 not in gdbserver's regcache. */
4101 nt_type = regset->nt_type;
4105 iov.iov_len = regset->size;
4106 data = (void *) &iov;
4112 res = ptrace (regset->get_request, pid,
4113 (PTRACE_ARG3_TYPE) (long) nt_type, data);
4115 res = ptrace (regset->get_request, pid, data, nt_type);
4120 /* Then overlay our cached registers on that. */
4121 regset->fill_function (regcache, buf);
4123 /* Only now do we write the register set. */
4125 res = ptrace (regset->set_request, pid,
4126 (PTRACE_ARG3_TYPE) (long) nt_type, data);
4128 res = ptrace (regset->set_request, pid, data, nt_type);
4136 /* If we get EIO on a regset, do not try it again for
4138 disabled_regsets[regset - target_regsets] = 1;
4142 else if (errno == ESRCH)
4144 /* At this point, ESRCH should mean the process is
4145 already gone, in which case we simply ignore attempts
4146 to change its registers. See also the related
4147 comment in linux_resume_one_lwp. */
4153 perror ("Warning: ptrace(regsets_store_inferior_registers)");
4156 else if (regset->type == GENERAL_REGS)
4157 saw_general_regs = 1;
4161 if (saw_general_regs)
4167 #else /* !HAVE_LINUX_REGSETS */
4169 #define use_linux_regsets 0
4170 #define regsets_fetch_inferior_registers(regcache) 1
4171 #define regsets_store_inferior_registers(regcache) 1
4175 /* Return 1 if register REGNO is supported by one of the regset ptrace
4176 calls or 0 if it has to be transferred individually. */
4179 linux_register_in_regsets (int regno)
4181 unsigned char mask = 1 << (regno % 8);
4182 size_t index = regno / 8;
4184 return (use_linux_regsets
4185 && (the_low_target.regset_bitmap == NULL
4186 || (the_low_target.regset_bitmap[index] & mask) != 0));
4189 #ifdef HAVE_LINUX_USRREGS
4192 register_addr (int regnum)
4196 if (regnum < 0 || regnum >= the_low_target.num_regs)
4197 error ("Invalid register number %d.", regnum);
4199 addr = the_low_target.regmap[regnum];
4204 /* Fetch one register. */
4206 fetch_register (struct regcache *regcache, int regno)
4213 if (regno >= the_low_target.num_regs)
4215 if ((*the_low_target.cannot_fetch_register) (regno))
4218 regaddr = register_addr (regno);
4222 size = ((register_size (regno) + sizeof (PTRACE_XFER_TYPE) - 1)
4223 & -sizeof (PTRACE_XFER_TYPE));
4224 buf = alloca (size);
4226 pid = lwpid_of (get_thread_lwp (current_inferior));
4227 for (i = 0; i < size; i += sizeof (PTRACE_XFER_TYPE))
4230 *(PTRACE_XFER_TYPE *) (buf + i) =
4231 ptrace (PTRACE_PEEKUSER, pid,
4232 /* Coerce to a uintptr_t first to avoid potential gcc warning
4233 of coercing an 8 byte integer to a 4 byte pointer. */
4234 (PTRACE_ARG3_TYPE) (uintptr_t) regaddr, (PTRACE_ARG4_TYPE) 0);
4235 regaddr += sizeof (PTRACE_XFER_TYPE);
4237 error ("reading register %d: %s", regno, strerror (errno));
4240 if (the_low_target.supply_ptrace_register)
4241 the_low_target.supply_ptrace_register (regcache, regno, buf);
4243 supply_register (regcache, regno, buf);
4246 /* Store one register. */
4248 store_register (struct regcache *regcache, int regno)
4255 if (regno >= the_low_target.num_regs)
4257 if ((*the_low_target.cannot_store_register) (regno))
4260 regaddr = register_addr (regno);
4264 size = ((register_size (regno) + sizeof (PTRACE_XFER_TYPE) - 1)
4265 & -sizeof (PTRACE_XFER_TYPE));
4266 buf = alloca (size);
4267 memset (buf, 0, size);
4269 if (the_low_target.collect_ptrace_register)
4270 the_low_target.collect_ptrace_register (regcache, regno, buf);
4272 collect_register (regcache, regno, buf);
4274 pid = lwpid_of (get_thread_lwp (current_inferior));
4275 for (i = 0; i < size; i += sizeof (PTRACE_XFER_TYPE))
4278 ptrace (PTRACE_POKEUSER, pid,
4279 /* Coerce to a uintptr_t first to avoid potential gcc warning
4280 about coercing an 8 byte integer to a 4 byte pointer. */
4281 (PTRACE_ARG3_TYPE) (uintptr_t) regaddr,
4282 (PTRACE_ARG4_TYPE) *(PTRACE_XFER_TYPE *) (buf + i));
4285 /* At this point, ESRCH should mean the process is
4286 already gone, in which case we simply ignore attempts
4287 to change its registers. See also the related
4288 comment in linux_resume_one_lwp. */
4292 if ((*the_low_target.cannot_store_register) (regno) == 0)
4293 error ("writing register %d: %s", regno, strerror (errno));
4295 regaddr += sizeof (PTRACE_XFER_TYPE);
4299 /* Fetch all registers, or just one, from the child process.
4300 If REGNO is -1, do this for all registers, skipping any that are
4301 assumed to have been retrieved by regsets_fetch_inferior_registers,
4302 unless ALL is non-zero.
4303 Otherwise, REGNO specifies which register (so we can save time). */
4305 usr_fetch_inferior_registers (struct regcache *regcache, int regno, int all)
4309 for (regno = 0; regno < the_low_target.num_regs; regno++)
4310 if (all || !linux_register_in_regsets (regno))
4311 fetch_register (regcache, regno);
4314 fetch_register (regcache, regno);
4317 /* Store our register values back into the inferior.
4318 If REGNO is -1, do this for all registers, skipping any that are
4319 assumed to have been saved by regsets_store_inferior_registers,
4320 unless ALL is non-zero.
4321 Otherwise, REGNO specifies which register (so we can save time). */
4323 usr_store_inferior_registers (struct regcache *regcache, int regno, int all)
4327 for (regno = 0; regno < the_low_target.num_regs; regno++)
4328 if (all || !linux_register_in_regsets (regno))
4329 store_register (regcache, regno);
4332 store_register (regcache, regno);
4335 #else /* !HAVE_LINUX_USRREGS */
4337 #define usr_fetch_inferior_registers(regcache, regno, all) do {} while (0)
4338 #define usr_store_inferior_registers(regcache, regno, all) do {} while (0)
4344 linux_fetch_registers (struct regcache *regcache, int regno)
4351 if (the_low_target.fetch_register != NULL)
4352 for (regno = 0; regno < the_low_target.num_regs; regno++)
4353 (*the_low_target.fetch_register) (regcache, regno);
4355 all = regsets_fetch_inferior_registers (regcache);
4356 usr_fetch_inferior_registers (regcache, -1, all);
4360 if (the_low_target.fetch_register != NULL
4361 && (*the_low_target.fetch_register) (regcache, regno))
4364 use_regsets = linux_register_in_regsets (regno);
4366 all = regsets_fetch_inferior_registers (regcache);
4367 if (!use_regsets || all)
4368 usr_fetch_inferior_registers (regcache, regno, 1);
4373 linux_store_registers (struct regcache *regcache, int regno)
4380 all = regsets_store_inferior_registers (regcache);
4381 usr_store_inferior_registers (regcache, regno, all);
4385 use_regsets = linux_register_in_regsets (regno);
4387 all = regsets_store_inferior_registers (regcache);
4388 if (!use_regsets || all)
4389 usr_store_inferior_registers (regcache, regno, 1);
4394 /* Copy LEN bytes from inferior's memory starting at MEMADDR
4395 to debugger memory starting at MYADDR. */
4398 linux_read_memory (CORE_ADDR memaddr, unsigned char *myaddr, int len)
4400 int pid = lwpid_of (get_thread_lwp (current_inferior));
4401 register PTRACE_XFER_TYPE *buffer;
4402 register CORE_ADDR addr;
4409 /* Try using /proc. Don't bother for one word. */
4410 if (len >= 3 * sizeof (long))
4414 /* We could keep this file open and cache it - possibly one per
4415 thread. That requires some juggling, but is even faster. */
4416 sprintf (filename, "/proc/%d/mem", pid);
4417 fd = open (filename, O_RDONLY | O_LARGEFILE);
4421 /* If pread64 is available, use it. It's faster if the kernel
4422 supports it (only one syscall), and it's 64-bit safe even on
4423 32-bit platforms (for instance, SPARC debugging a SPARC64
4426 bytes = pread64 (fd, myaddr, len, memaddr);
4429 if (lseek (fd, memaddr, SEEK_SET) != -1)
4430 bytes = read (fd, myaddr, len);
4437 /* Some data was read, we'll try to get the rest with ptrace. */
4447 /* Round starting address down to longword boundary. */
4448 addr = memaddr & -(CORE_ADDR) sizeof (PTRACE_XFER_TYPE);
4449 /* Round ending address up; get number of longwords that makes. */
4450 count = ((((memaddr + len) - addr) + sizeof (PTRACE_XFER_TYPE) - 1)
4451 / sizeof (PTRACE_XFER_TYPE));
4452 /* Allocate buffer of that many longwords. */
4453 buffer = (PTRACE_XFER_TYPE *) alloca (count * sizeof (PTRACE_XFER_TYPE));
4455 /* Read all the longwords */
4457 for (i = 0; i < count; i++, addr += sizeof (PTRACE_XFER_TYPE))
4459 /* Coerce the 3rd arg to a uintptr_t first to avoid potential gcc warning
4460 about coercing an 8 byte integer to a 4 byte pointer. */
4461 buffer[i] = ptrace (PTRACE_PEEKTEXT, pid,
4462 (PTRACE_ARG3_TYPE) (uintptr_t) addr,
4463 (PTRACE_ARG4_TYPE) 0);
4469 /* Copy appropriate bytes out of the buffer. */
4472 i *= sizeof (PTRACE_XFER_TYPE);
4473 i -= memaddr & (sizeof (PTRACE_XFER_TYPE) - 1);
4475 (char *) buffer + (memaddr & (sizeof (PTRACE_XFER_TYPE) - 1)),
4482 /* Copy LEN bytes of data from debugger memory at MYADDR to inferior's
4483 memory at MEMADDR. On failure (cannot write to the inferior)
4484 returns the value of errno. */
4487 linux_write_memory (CORE_ADDR memaddr, const unsigned char *myaddr, int len)
4490 /* Round starting address down to longword boundary. */
4491 register CORE_ADDR addr = memaddr & -(CORE_ADDR) sizeof (PTRACE_XFER_TYPE);
4492 /* Round ending address up; get number of longwords that makes. */
4494 = (((memaddr + len) - addr) + sizeof (PTRACE_XFER_TYPE) - 1)
4495 / sizeof (PTRACE_XFER_TYPE);
4497 /* Allocate buffer of that many longwords. */
4498 register PTRACE_XFER_TYPE *buffer = (PTRACE_XFER_TYPE *)
4499 alloca (count * sizeof (PTRACE_XFER_TYPE));
4501 int pid = lwpid_of (get_thread_lwp (current_inferior));
4505 /* Dump up to four bytes. */
4506 unsigned int val = * (unsigned int *) myaddr;
4512 val = val & 0xffffff;
4513 fprintf (stderr, "Writing %0*x to 0x%08lx\n", 2 * ((len < 4) ? len : 4),
4514 val, (long)memaddr);
4517 /* Fill start and end extra bytes of buffer with existing memory data. */
4520 /* Coerce the 3rd arg to a uintptr_t first to avoid potential gcc warning
4521 about coercing an 8 byte integer to a 4 byte pointer. */
4522 buffer[0] = ptrace (PTRACE_PEEKTEXT, pid,
4523 (PTRACE_ARG3_TYPE) (uintptr_t) addr,
4524 (PTRACE_ARG4_TYPE) 0);
4532 = ptrace (PTRACE_PEEKTEXT, pid,
4533 /* Coerce to a uintptr_t first to avoid potential gcc warning
4534 about coercing an 8 byte integer to a 4 byte pointer. */
4535 (PTRACE_ARG3_TYPE) (uintptr_t) (addr + (count - 1)
4536 * sizeof (PTRACE_XFER_TYPE)),
4537 (PTRACE_ARG4_TYPE) 0);
4542 /* Copy data to be written over corresponding part of buffer. */
4544 memcpy ((char *) buffer + (memaddr & (sizeof (PTRACE_XFER_TYPE) - 1)),
4547 /* Write the entire buffer. */
4549 for (i = 0; i < count; i++, addr += sizeof (PTRACE_XFER_TYPE))
4552 ptrace (PTRACE_POKETEXT, pid,
4553 /* Coerce to a uintptr_t first to avoid potential gcc warning
4554 about coercing an 8 byte integer to a 4 byte pointer. */
4555 (PTRACE_ARG3_TYPE) (uintptr_t) addr,
4556 (PTRACE_ARG4_TYPE) buffer[i]);
4564 /* Non-zero if the kernel supports PTRACE_O_TRACEFORK. */
4565 static int linux_supports_tracefork_flag;
4568 linux_enable_event_reporting (int pid)
4570 if (!linux_supports_tracefork_flag)
4573 ptrace (PTRACE_SETOPTIONS, pid, (PTRACE_ARG3_TYPE) 0,
4574 (PTRACE_ARG4_TYPE) PTRACE_O_TRACECLONE);
4577 /* Helper functions for linux_test_for_tracefork, called via clone (). */
4580 linux_tracefork_grandchild (void *arg)
4585 #define STACK_SIZE 4096
4588 linux_tracefork_child (void *arg)
4590 ptrace (PTRACE_TRACEME, 0, (PTRACE_ARG3_TYPE) 0, (PTRACE_ARG4_TYPE) 0);
4591 kill (getpid (), SIGSTOP);
4593 #if !(defined(__UCLIBC__) && defined(HAS_NOMMU))
4596 linux_tracefork_grandchild (NULL);
4598 #else /* defined(__UCLIBC__) && defined(HAS_NOMMU) */
4601 __clone2 (linux_tracefork_grandchild, arg, STACK_SIZE,
4602 CLONE_VM | SIGCHLD, NULL);
4604 clone (linux_tracefork_grandchild, (char *) arg + STACK_SIZE,
4605 CLONE_VM | SIGCHLD, NULL);
4608 #endif /* defined(__UCLIBC__) && defined(HAS_NOMMU) */
4613 /* Determine if PTRACE_O_TRACEFORK can be used to follow fork events. Make
4614 sure that we can enable the option, and that it had the desired
4618 linux_test_for_tracefork (void)
4620 int child_pid, ret, status;
4622 #if defined(__UCLIBC__) && defined(HAS_NOMMU)
4623 char *stack = xmalloc (STACK_SIZE * 4);
4624 #endif /* defined(__UCLIBC__) && defined(HAS_NOMMU) */
4626 linux_supports_tracefork_flag = 0;
4628 #if !(defined(__UCLIBC__) && defined(HAS_NOMMU))
4630 child_pid = fork ();
4632 linux_tracefork_child (NULL);
4634 #else /* defined(__UCLIBC__) && defined(HAS_NOMMU) */
4636 /* Use CLONE_VM instead of fork, to support uClinux (no MMU). */
4638 child_pid = __clone2 (linux_tracefork_child, stack, STACK_SIZE,
4639 CLONE_VM | SIGCHLD, stack + STACK_SIZE * 2);
4640 #else /* !__ia64__ */
4641 child_pid = clone (linux_tracefork_child, stack + STACK_SIZE,
4642 CLONE_VM | SIGCHLD, stack + STACK_SIZE * 2);
4643 #endif /* !__ia64__ */
4645 #endif /* defined(__UCLIBC__) && defined(HAS_NOMMU) */
4647 if (child_pid == -1)
4648 perror_with_name ("clone");
4650 ret = my_waitpid (child_pid, &status, 0);
4652 perror_with_name ("waitpid");
4653 else if (ret != child_pid)
4654 error ("linux_test_for_tracefork: waitpid: unexpected result %d.", ret);
4655 if (! WIFSTOPPED (status))
4656 error ("linux_test_for_tracefork: waitpid: unexpected status %d.", status);
4658 ret = ptrace (PTRACE_SETOPTIONS, child_pid, (PTRACE_ARG3_TYPE) 0,
4659 (PTRACE_ARG4_TYPE) PTRACE_O_TRACEFORK);
4662 ret = ptrace (PTRACE_KILL, child_pid, (PTRACE_ARG3_TYPE) 0,
4663 (PTRACE_ARG4_TYPE) 0);
4666 warning ("linux_test_for_tracefork: failed to kill child");
4670 ret = my_waitpid (child_pid, &status, 0);
4671 if (ret != child_pid)
4672 warning ("linux_test_for_tracefork: failed to wait for killed child");
4673 else if (!WIFSIGNALED (status))
4674 warning ("linux_test_for_tracefork: unexpected wait status 0x%x from "
4675 "killed child", status);
4680 ret = ptrace (PTRACE_CONT, child_pid, (PTRACE_ARG3_TYPE) 0,
4681 (PTRACE_ARG4_TYPE) 0);
4683 warning ("linux_test_for_tracefork: failed to resume child");
4685 ret = my_waitpid (child_pid, &status, 0);
4687 if (ret == child_pid && WIFSTOPPED (status)
4688 && status >> 16 == PTRACE_EVENT_FORK)
4691 ret = ptrace (PTRACE_GETEVENTMSG, child_pid, (PTRACE_ARG3_TYPE) 0,
4693 if (ret == 0 && second_pid != 0)
4697 linux_supports_tracefork_flag = 1;
4698 my_waitpid (second_pid, &second_status, 0);
4699 ret = ptrace (PTRACE_KILL, second_pid, (PTRACE_ARG3_TYPE) 0,
4700 (PTRACE_ARG4_TYPE) 0);
4702 warning ("linux_test_for_tracefork: failed to kill second child");
4703 my_waitpid (second_pid, &status, 0);
4707 warning ("linux_test_for_tracefork: unexpected result from waitpid "
4708 "(%d, status 0x%x)", ret, status);
4712 ret = ptrace (PTRACE_KILL, child_pid, (PTRACE_ARG3_TYPE) 0,
4713 (PTRACE_ARG4_TYPE) 0);
4715 warning ("linux_test_for_tracefork: failed to kill child");
4716 my_waitpid (child_pid, &status, 0);
4718 while (WIFSTOPPED (status));
4720 #if defined(__UCLIBC__) && defined(HAS_NOMMU)
4722 #endif /* defined(__UCLIBC__) && defined(HAS_NOMMU) */
4727 linux_look_up_symbols (void)
4729 #ifdef USE_THREAD_DB
4730 struct process_info *proc = current_process ();
4732 if (proc->private->thread_db != NULL)
4735 /* If the kernel supports tracing forks then it also supports tracing
4736 clones, and then we don't need to use the magic thread event breakpoint
4737 to learn about threads. */
4738 thread_db_init (!linux_supports_tracefork_flag);
4743 linux_request_interrupt (void)
4745 extern unsigned long signal_pid;
4747 if (!ptid_equal (cont_thread, null_ptid)
4748 && !ptid_equal (cont_thread, minus_one_ptid))
4750 struct lwp_info *lwp;
4753 lwp = get_thread_lwp (current_inferior);
4754 lwpid = lwpid_of (lwp);
4755 kill_lwp (lwpid, SIGINT);
4758 kill_lwp (signal_pid, SIGINT);
4761 /* Copy LEN bytes from inferior's auxiliary vector starting at OFFSET
4762 to debugger memory starting at MYADDR. */
4765 linux_read_auxv (CORE_ADDR offset, unsigned char *myaddr, unsigned int len)
4767 char filename[PATH_MAX];
4769 int pid = lwpid_of (get_thread_lwp (current_inferior));
4771 xsnprintf (filename, sizeof filename, "/proc/%d/auxv", pid);
4773 fd = open (filename, O_RDONLY);
4777 if (offset != (CORE_ADDR) 0
4778 && lseek (fd, (off_t) offset, SEEK_SET) != (off_t) offset)
4781 n = read (fd, myaddr, len);
4788 /* These breakpoint and watchpoint related wrapper functions simply
4789 pass on the function call if the target has registered a
4790 corresponding function. */
4793 linux_insert_point (char type, CORE_ADDR addr, int len)
4795 if (the_low_target.insert_point != NULL)
4796 return the_low_target.insert_point (type, addr, len);
4798 /* Unsupported (see target.h). */
4803 linux_remove_point (char type, CORE_ADDR addr, int len)
4805 if (the_low_target.remove_point != NULL)
4806 return the_low_target.remove_point (type, addr, len);
4808 /* Unsupported (see target.h). */
4813 linux_stopped_by_watchpoint (void)
4815 struct lwp_info *lwp = get_thread_lwp (current_inferior);
4817 return lwp->stopped_by_watchpoint;
4821 linux_stopped_data_address (void)
4823 struct lwp_info *lwp = get_thread_lwp (current_inferior);
4825 return lwp->stopped_data_address;
4828 #if defined(__UCLIBC__) && defined(HAS_NOMMU)
4829 #if ! (defined(PT_TEXT_ADDR) \
4830 || defined(PT_DATA_ADDR) \
4831 || defined(PT_TEXT_END_ADDR))
4832 #if defined(__mcoldfire__)
4833 /* These should really be defined in the kernel's ptrace.h header. */
4834 #define PT_TEXT_ADDR 49*4
4835 #define PT_DATA_ADDR 50*4
4836 #define PT_TEXT_END_ADDR 51*4
4838 #define PT_TEXT_ADDR 220
4839 #define PT_TEXT_END_ADDR 224
4840 #define PT_DATA_ADDR 228
4841 #elif defined(__TMS320C6X__)
4842 #define PT_TEXT_ADDR (0x10000*4)
4843 #define PT_DATA_ADDR (0x10004*4)
4844 #define PT_TEXT_END_ADDR (0x10008*4)
4848 /* Under uClinux, programs are loaded at non-zero offsets, which we need
4849 to tell gdb about. */
4852 linux_read_offsets (CORE_ADDR *text_p, CORE_ADDR *data_p)
4854 #if defined(PT_TEXT_ADDR) && defined(PT_DATA_ADDR) && defined(PT_TEXT_END_ADDR)
4855 unsigned long text, text_end, data;
4856 int pid = lwpid_of (get_thread_lwp (current_inferior));
4860 text = ptrace (PTRACE_PEEKUSER, pid, (PTRACE_ARG3_TYPE) PT_TEXT_ADDR,
4861 (PTRACE_ARG4_TYPE) 0);
4862 text_end = ptrace (PTRACE_PEEKUSER, pid, (PTRACE_ARG3_TYPE) PT_TEXT_END_ADDR,
4863 (PTRACE_ARG4_TYPE) 0);
4864 data = ptrace (PTRACE_PEEKUSER, pid, (PTRACE_ARG3_TYPE) PT_DATA_ADDR,
4865 (PTRACE_ARG4_TYPE) 0);
4869 /* Both text and data offsets produced at compile-time (and so
4870 used by gdb) are relative to the beginning of the program,
4871 with the data segment immediately following the text segment.
4872 However, the actual runtime layout in memory may put the data
4873 somewhere else, so when we send gdb a data base-address, we
4874 use the real data base address and subtract the compile-time
4875 data base-address from it (which is just the length of the
4876 text segment). BSS immediately follows data in both
4879 *data_p = data - (text_end - text);
4889 linux_qxfer_osdata (const char *annex,
4890 unsigned char *readbuf, unsigned const char *writebuf,
4891 CORE_ADDR offset, int len)
4893 return linux_common_xfer_osdata (annex, readbuf, offset, len);
4896 /* Convert a native/host siginfo object, into/from the siginfo in the
4897 layout of the inferiors' architecture. */
4900 siginfo_fixup (siginfo_t *siginfo, void *inf_siginfo, int direction)
4904 if (the_low_target.siginfo_fixup != NULL)
4905 done = the_low_target.siginfo_fixup (siginfo, inf_siginfo, direction);
4907 /* If there was no callback, or the callback didn't do anything,
4908 then just do a straight memcpy. */
4912 memcpy (siginfo, inf_siginfo, sizeof (siginfo_t));
4914 memcpy (inf_siginfo, siginfo, sizeof (siginfo_t));
4919 linux_xfer_siginfo (const char *annex, unsigned char *readbuf,
4920 unsigned const char *writebuf, CORE_ADDR offset, int len)
4924 char inf_siginfo[sizeof (siginfo_t)];
4926 if (current_inferior == NULL)
4929 pid = lwpid_of (get_thread_lwp (current_inferior));
4932 fprintf (stderr, "%s siginfo for lwp %d.\n",
4933 readbuf != NULL ? "Reading" : "Writing",
4936 if (offset >= sizeof (siginfo))
4939 if (ptrace (PTRACE_GETSIGINFO, pid, (PTRACE_ARG3_TYPE) 0, &siginfo) != 0)
4942 /* When GDBSERVER is built as a 64-bit application, ptrace writes into
4943 SIGINFO an object with 64-bit layout. Since debugging a 32-bit
4944 inferior with a 64-bit GDBSERVER should look the same as debugging it
4945 with a 32-bit GDBSERVER, we need to convert it. */
4946 siginfo_fixup (&siginfo, inf_siginfo, 0);
4948 if (offset + len > sizeof (siginfo))
4949 len = sizeof (siginfo) - offset;
4951 if (readbuf != NULL)
4952 memcpy (readbuf, inf_siginfo + offset, len);
4955 memcpy (inf_siginfo + offset, writebuf, len);
4957 /* Convert back to ptrace layout before flushing it out. */
4958 siginfo_fixup (&siginfo, inf_siginfo, 1);
4960 if (ptrace (PTRACE_SETSIGINFO, pid, (PTRACE_ARG3_TYPE) 0, &siginfo) != 0)
4967 /* SIGCHLD handler that serves two purposes: In non-stop/async mode,
4968 so we notice when children change state; as the handler for the
4969 sigsuspend in my_waitpid. */
4972 sigchld_handler (int signo)
4974 int old_errno = errno;
4980 /* fprintf is not async-signal-safe, so call write
4982 if (write (2, "sigchld_handler\n",
4983 sizeof ("sigchld_handler\n") - 1) < 0)
4984 break; /* just ignore */
4988 if (target_is_async_p ())
4989 async_file_mark (); /* trigger a linux_wait */
4995 linux_supports_non_stop (void)
5001 linux_async (int enable)
5003 int previous = (linux_event_pipe[0] != -1);
5006 fprintf (stderr, "linux_async (%d), previous=%d\n",
5009 if (previous != enable)
5012 sigemptyset (&mask);
5013 sigaddset (&mask, SIGCHLD);
5015 sigprocmask (SIG_BLOCK, &mask, NULL);
5019 if (pipe (linux_event_pipe) == -1)
5020 fatal ("creating event pipe failed.");
5022 fcntl (linux_event_pipe[0], F_SETFL, O_NONBLOCK);
5023 fcntl (linux_event_pipe[1], F_SETFL, O_NONBLOCK);
5025 /* Register the event loop handler. */
5026 add_file_handler (linux_event_pipe[0],
5027 handle_target_event, NULL);
5029 /* Always trigger a linux_wait. */
5034 delete_file_handler (linux_event_pipe[0]);
5036 close (linux_event_pipe[0]);
5037 close (linux_event_pipe[1]);
5038 linux_event_pipe[0] = -1;
5039 linux_event_pipe[1] = -1;
5042 sigprocmask (SIG_UNBLOCK, &mask, NULL);
5049 linux_start_non_stop (int nonstop)
5051 /* Register or unregister from event-loop accordingly. */
5052 linux_async (nonstop);
5057 linux_supports_multi_process (void)
5063 linux_supports_disable_randomization (void)
5065 #ifdef HAVE_PERSONALITY
5073 linux_supports_agent (void)
5078 /* Enumerate spufs IDs for process PID. */
5080 spu_enumerate_spu_ids (long pid, unsigned char *buf, CORE_ADDR offset, int len)
5086 struct dirent *entry;
5088 sprintf (path, "/proc/%ld/fd", pid);
5089 dir = opendir (path);
5094 while ((entry = readdir (dir)) != NULL)
5100 fd = atoi (entry->d_name);
5104 sprintf (path, "/proc/%ld/fd/%d", pid, fd);
5105 if (stat (path, &st) != 0)
5107 if (!S_ISDIR (st.st_mode))
5110 if (statfs (path, &stfs) != 0)
5112 if (stfs.f_type != SPUFS_MAGIC)
5115 if (pos >= offset && pos + 4 <= offset + len)
5117 *(unsigned int *)(buf + pos - offset) = fd;
5127 /* Implements the to_xfer_partial interface for the TARGET_OBJECT_SPU
5128 object type, using the /proc file system. */
5130 linux_qxfer_spu (const char *annex, unsigned char *readbuf,
5131 unsigned const char *writebuf,
5132 CORE_ADDR offset, int len)
5134 long pid = lwpid_of (get_thread_lwp (current_inferior));
5139 if (!writebuf && !readbuf)
5147 return spu_enumerate_spu_ids (pid, readbuf, offset, len);
5150 sprintf (buf, "/proc/%ld/fd/%s", pid, annex);
5151 fd = open (buf, writebuf? O_WRONLY : O_RDONLY);
5156 && lseek (fd, (off_t) offset, SEEK_SET) != (off_t) offset)
5163 ret = write (fd, writebuf, (size_t) len);
5165 ret = read (fd, readbuf, (size_t) len);
5171 #if defined PT_GETDSBT || defined PTRACE_GETFDPIC
5172 struct target_loadseg
5174 /* Core address to which the segment is mapped. */
5176 /* VMA recorded in the program header. */
5178 /* Size of this segment in memory. */
5182 # if defined PT_GETDSBT
5183 struct target_loadmap
5185 /* Protocol version number, must be zero. */
5187 /* Pointer to the DSBT table, its size, and the DSBT index. */
5188 unsigned *dsbt_table;
5189 unsigned dsbt_size, dsbt_index;
5190 /* Number of segments in this map. */
5192 /* The actual memory map. */
5193 struct target_loadseg segs[/*nsegs*/];
5195 # define LINUX_LOADMAP PT_GETDSBT
5196 # define LINUX_LOADMAP_EXEC PTRACE_GETDSBT_EXEC
5197 # define LINUX_LOADMAP_INTERP PTRACE_GETDSBT_INTERP
5199 struct target_loadmap
5201 /* Protocol version number, must be zero. */
5203 /* Number of segments in this map. */
5205 /* The actual memory map. */
5206 struct target_loadseg segs[/*nsegs*/];
5208 # define LINUX_LOADMAP PTRACE_GETFDPIC
5209 # define LINUX_LOADMAP_EXEC PTRACE_GETFDPIC_EXEC
5210 # define LINUX_LOADMAP_INTERP PTRACE_GETFDPIC_INTERP
5214 linux_read_loadmap (const char *annex, CORE_ADDR offset,
5215 unsigned char *myaddr, unsigned int len)
5217 int pid = lwpid_of (get_thread_lwp (current_inferior));
5219 struct target_loadmap *data = NULL;
5220 unsigned int actual_length, copy_length;
5222 if (strcmp (annex, "exec") == 0)
5223 addr = (int) LINUX_LOADMAP_EXEC;
5224 else if (strcmp (annex, "interp") == 0)
5225 addr = (int) LINUX_LOADMAP_INTERP;
5229 if (ptrace (LINUX_LOADMAP, pid, addr, &data) != 0)
5235 actual_length = sizeof (struct target_loadmap)
5236 + sizeof (struct target_loadseg) * data->nsegs;
5238 if (offset < 0 || offset > actual_length)
5241 copy_length = actual_length - offset < len ? actual_length - offset : len;
5242 memcpy (myaddr, (char *) data + offset, copy_length);
5246 # define linux_read_loadmap NULL
5247 #endif /* defined PT_GETDSBT || defined PTRACE_GETFDPIC */
5250 linux_process_qsupported (const char *query)
5252 if (the_low_target.process_qsupported != NULL)
5253 the_low_target.process_qsupported (query);
5257 linux_supports_tracepoints (void)
5259 if (*the_low_target.supports_tracepoints == NULL)
5262 return (*the_low_target.supports_tracepoints) ();
5266 linux_read_pc (struct regcache *regcache)
5268 if (the_low_target.get_pc == NULL)
5271 return (*the_low_target.get_pc) (regcache);
5275 linux_write_pc (struct regcache *regcache, CORE_ADDR pc)
5277 gdb_assert (the_low_target.set_pc != NULL);
5279 (*the_low_target.set_pc) (regcache, pc);
5283 linux_thread_stopped (struct thread_info *thread)
5285 return get_thread_lwp (thread)->stopped;
5288 /* This exposes stop-all-threads functionality to other modules. */
5291 linux_pause_all (int freeze)
5293 stop_all_lwps (freeze, NULL);
5296 /* This exposes unstop-all-threads functionality to other gdbserver
5300 linux_unpause_all (int unfreeze)
5302 unstop_all_lwps (unfreeze, NULL);
5306 linux_prepare_to_access_memory (void)
5308 /* Neither ptrace nor /proc/PID/mem allow accessing memory through a
5311 linux_pause_all (1);
5316 linux_done_accessing_memory (void)
5318 /* Neither ptrace nor /proc/PID/mem allow accessing memory through a
5321 linux_unpause_all (1);
5325 linux_install_fast_tracepoint_jump_pad (CORE_ADDR tpoint, CORE_ADDR tpaddr,
5326 CORE_ADDR collector,
5329 CORE_ADDR *jump_entry,
5330 CORE_ADDR *trampoline,
5331 ULONGEST *trampoline_size,
5332 unsigned char *jjump_pad_insn,
5333 ULONGEST *jjump_pad_insn_size,
5334 CORE_ADDR *adjusted_insn_addr,
5335 CORE_ADDR *adjusted_insn_addr_end,
5338 return (*the_low_target.install_fast_tracepoint_jump_pad)
5339 (tpoint, tpaddr, collector, lockaddr, orig_size,
5340 jump_entry, trampoline, trampoline_size,
5341 jjump_pad_insn, jjump_pad_insn_size,
5342 adjusted_insn_addr, adjusted_insn_addr_end,
5346 static struct emit_ops *
5347 linux_emit_ops (void)
5349 if (the_low_target.emit_ops != NULL)
5350 return (*the_low_target.emit_ops) ();
5356 linux_get_min_fast_tracepoint_insn_len (void)
5358 return (*the_low_target.get_min_fast_tracepoint_insn_len) ();
5361 /* Extract &phdr and num_phdr in the inferior. Return 0 on success. */
5364 get_phdr_phnum_from_proc_auxv (const int pid, const int is_elf64,
5365 CORE_ADDR *phdr_memaddr, int *num_phdr)
5367 char filename[PATH_MAX];
5369 const int auxv_size = is_elf64
5370 ? sizeof (Elf64_auxv_t) : sizeof (Elf32_auxv_t);
5371 char buf[sizeof (Elf64_auxv_t)]; /* The larger of the two. */
5373 xsnprintf (filename, sizeof filename, "/proc/%d/auxv", pid);
5375 fd = open (filename, O_RDONLY);
5381 while (read (fd, buf, auxv_size) == auxv_size
5382 && (*phdr_memaddr == 0 || *num_phdr == 0))
5386 Elf64_auxv_t *const aux = (Elf64_auxv_t *) buf;
5388 switch (aux->a_type)
5391 *phdr_memaddr = aux->a_un.a_val;
5394 *num_phdr = aux->a_un.a_val;
5400 Elf32_auxv_t *const aux = (Elf32_auxv_t *) buf;
5402 switch (aux->a_type)
5405 *phdr_memaddr = aux->a_un.a_val;
5408 *num_phdr = aux->a_un.a_val;
5416 if (*phdr_memaddr == 0 || *num_phdr == 0)
5418 warning ("Unexpected missing AT_PHDR and/or AT_PHNUM: "
5419 "phdr_memaddr = %ld, phdr_num = %d",
5420 (long) *phdr_memaddr, *num_phdr);
5427 /* Return &_DYNAMIC (via PT_DYNAMIC) in the inferior, or 0 if not present. */
5430 get_dynamic (const int pid, const int is_elf64)
5432 CORE_ADDR phdr_memaddr, relocation;
5434 unsigned char *phdr_buf;
5435 const int phdr_size = is_elf64 ? sizeof (Elf64_Phdr) : sizeof (Elf32_Phdr);
5437 if (get_phdr_phnum_from_proc_auxv (pid, is_elf64, &phdr_memaddr, &num_phdr))
5440 gdb_assert (num_phdr < 100); /* Basic sanity check. */
5441 phdr_buf = alloca (num_phdr * phdr_size);
5443 if (linux_read_memory (phdr_memaddr, phdr_buf, num_phdr * phdr_size))
5446 /* Compute relocation: it is expected to be 0 for "regular" executables,
5447 non-zero for PIE ones. */
5449 for (i = 0; relocation == -1 && i < num_phdr; i++)
5452 Elf64_Phdr *const p = (Elf64_Phdr *) (phdr_buf + i * phdr_size);
5454 if (p->p_type == PT_PHDR)
5455 relocation = phdr_memaddr - p->p_vaddr;
5459 Elf32_Phdr *const p = (Elf32_Phdr *) (phdr_buf + i * phdr_size);
5461 if (p->p_type == PT_PHDR)
5462 relocation = phdr_memaddr - p->p_vaddr;
5465 if (relocation == -1)
5467 /* PT_PHDR is optional, but necessary for PIE in general. Fortunately
5468 any real world executables, including PIE executables, have always
5469 PT_PHDR present. PT_PHDR is not present in some shared libraries or
5470 in fpc (Free Pascal 2.4) binaries but neither of those have a need for
5471 or present DT_DEBUG anyway (fpc binaries are statically linked).
5473 Therefore if there exists DT_DEBUG there is always also PT_PHDR.
5475 GDB could find RELOCATION also from AT_ENTRY - e_entry. */
5480 for (i = 0; i < num_phdr; i++)
5484 Elf64_Phdr *const p = (Elf64_Phdr *) (phdr_buf + i * phdr_size);
5486 if (p->p_type == PT_DYNAMIC)
5487 return p->p_vaddr + relocation;
5491 Elf32_Phdr *const p = (Elf32_Phdr *) (phdr_buf + i * phdr_size);
5493 if (p->p_type == PT_DYNAMIC)
5494 return p->p_vaddr + relocation;
5501 /* Return &_r_debug in the inferior, or -1 if not present. Return value
5502 can be 0 if the inferior does not yet have the library list initialized.
5503 We look for DT_MIPS_RLD_MAP first. MIPS executables use this instead of
5504 DT_DEBUG, although they sometimes contain an unused DT_DEBUG entry too. */
5507 get_r_debug (const int pid, const int is_elf64)
5509 CORE_ADDR dynamic_memaddr;
5510 const int dyn_size = is_elf64 ? sizeof (Elf64_Dyn) : sizeof (Elf32_Dyn);
5511 unsigned char buf[sizeof (Elf64_Dyn)]; /* The larger of the two. */
5514 dynamic_memaddr = get_dynamic (pid, is_elf64);
5515 if (dynamic_memaddr == 0)
5518 while (linux_read_memory (dynamic_memaddr, buf, dyn_size) == 0)
5522 Elf64_Dyn *const dyn = (Elf64_Dyn *) buf;
5523 #ifdef DT_MIPS_RLD_MAP
5527 unsigned char buf[sizeof (Elf64_Xword)];
5531 if (dyn->d_tag == DT_MIPS_RLD_MAP)
5533 if (linux_read_memory (dyn->d_un.d_val,
5534 rld_map.buf, sizeof (rld_map.buf)) == 0)
5539 #endif /* DT_MIPS_RLD_MAP */
5541 if (dyn->d_tag == DT_DEBUG && map == -1)
5542 map = dyn->d_un.d_val;
5544 if (dyn->d_tag == DT_NULL)
5549 Elf32_Dyn *const dyn = (Elf32_Dyn *) buf;
5550 #ifdef DT_MIPS_RLD_MAP
5554 unsigned char buf[sizeof (Elf32_Word)];
5558 if (dyn->d_tag == DT_MIPS_RLD_MAP)
5560 if (linux_read_memory (dyn->d_un.d_val,
5561 rld_map.buf, sizeof (rld_map.buf)) == 0)
5566 #endif /* DT_MIPS_RLD_MAP */
5568 if (dyn->d_tag == DT_DEBUG && map == -1)
5569 map = dyn->d_un.d_val;
5571 if (dyn->d_tag == DT_NULL)
5575 dynamic_memaddr += dyn_size;
5581 /* Read one pointer from MEMADDR in the inferior. */
5584 read_one_ptr (CORE_ADDR memaddr, CORE_ADDR *ptr, int ptr_size)
5588 /* Go through a union so this works on either big or little endian
5589 hosts, when the inferior's pointer size is smaller than the size
5590 of CORE_ADDR. It is assumed the inferior's endianness is the
5591 same of the superior's. */
5594 CORE_ADDR core_addr;
5599 ret = linux_read_memory (memaddr, &addr.uc, ptr_size);
5602 if (ptr_size == sizeof (CORE_ADDR))
5603 *ptr = addr.core_addr;
5604 else if (ptr_size == sizeof (unsigned int))
5607 gdb_assert_not_reached ("unhandled pointer size");
5612 struct link_map_offsets
5614 /* Offset and size of r_debug.r_version. */
5615 int r_version_offset;
5617 /* Offset and size of r_debug.r_map. */
5620 /* Offset to l_addr field in struct link_map. */
5623 /* Offset to l_name field in struct link_map. */
5626 /* Offset to l_ld field in struct link_map. */
5629 /* Offset to l_next field in struct link_map. */
5632 /* Offset to l_prev field in struct link_map. */
5636 /* Construct qXfer:libraries-svr4:read reply. */
5639 linux_qxfer_libraries_svr4 (const char *annex, unsigned char *readbuf,
5640 unsigned const char *writebuf,
5641 CORE_ADDR offset, int len)
5644 unsigned document_len;
5645 struct process_info_private *const priv = current_process ()->private;
5646 char filename[PATH_MAX];
5649 static const struct link_map_offsets lmo_32bit_offsets =
5651 0, /* r_version offset. */
5652 4, /* r_debug.r_map offset. */
5653 0, /* l_addr offset in link_map. */
5654 4, /* l_name offset in link_map. */
5655 8, /* l_ld offset in link_map. */
5656 12, /* l_next offset in link_map. */
5657 16 /* l_prev offset in link_map. */
5660 static const struct link_map_offsets lmo_64bit_offsets =
5662 0, /* r_version offset. */
5663 8, /* r_debug.r_map offset. */
5664 0, /* l_addr offset in link_map. */
5665 8, /* l_name offset in link_map. */
5666 16, /* l_ld offset in link_map. */
5667 24, /* l_next offset in link_map. */
5668 32 /* l_prev offset in link_map. */
5670 const struct link_map_offsets *lmo;
5671 unsigned int machine;
5673 if (writebuf != NULL)
5675 if (readbuf == NULL)
5678 pid = lwpid_of (get_thread_lwp (current_inferior));
5679 xsnprintf (filename, sizeof filename, "/proc/%d/exe", pid);
5680 is_elf64 = elf_64_file_p (filename, &machine);
5681 lmo = is_elf64 ? &lmo_64bit_offsets : &lmo_32bit_offsets;
5683 if (priv->r_debug == 0)
5684 priv->r_debug = get_r_debug (pid, is_elf64);
5686 /* We failed to find DT_DEBUG. Such situation will not change for this
5687 inferior - do not retry it. Report it to GDB as E01, see for the reasons
5688 at the GDB solib-svr4.c side. */
5689 if (priv->r_debug == (CORE_ADDR) -1)
5692 if (priv->r_debug == 0)
5694 document = xstrdup ("<library-list-svr4 version=\"1.0\"/>\n");
5698 int allocated = 1024;
5700 const int ptr_size = is_elf64 ? 8 : 4;
5701 CORE_ADDR lm_addr, lm_prev, l_name, l_addr, l_ld, l_next, l_prev;
5702 int r_version, header_done = 0;
5704 document = xmalloc (allocated);
5705 strcpy (document, "<library-list-svr4 version=\"1.0\"");
5706 p = document + strlen (document);
5709 if (linux_read_memory (priv->r_debug + lmo->r_version_offset,
5710 (unsigned char *) &r_version,
5711 sizeof (r_version)) != 0
5714 warning ("unexpected r_debug version %d", r_version);
5718 if (read_one_ptr (priv->r_debug + lmo->r_map_offset,
5719 &lm_addr, ptr_size) != 0)
5721 warning ("unable to read r_map from 0x%lx",
5722 (long) priv->r_debug + lmo->r_map_offset);
5727 while (read_one_ptr (lm_addr + lmo->l_name_offset,
5728 &l_name, ptr_size) == 0
5729 && read_one_ptr (lm_addr + lmo->l_addr_offset,
5730 &l_addr, ptr_size) == 0
5731 && read_one_ptr (lm_addr + lmo->l_ld_offset,
5732 &l_ld, ptr_size) == 0
5733 && read_one_ptr (lm_addr + lmo->l_prev_offset,
5734 &l_prev, ptr_size) == 0
5735 && read_one_ptr (lm_addr + lmo->l_next_offset,
5736 &l_next, ptr_size) == 0)
5738 unsigned char libname[PATH_MAX];
5740 if (lm_prev != l_prev)
5742 warning ("Corrupted shared library list: 0x%lx != 0x%lx",
5743 (long) lm_prev, (long) l_prev);
5747 /* Not checking for error because reading may stop before
5748 we've got PATH_MAX worth of characters. */
5750 linux_read_memory (l_name, libname, sizeof (libname) - 1);
5751 libname[sizeof (libname) - 1] = '\0';
5752 if (libname[0] != '\0')
5754 /* 6x the size for xml_escape_text below. */
5755 size_t len = 6 * strlen ((char *) libname);
5760 /* Terminate `<library-list-svr4'. */
5765 while (allocated < p - document + len + 200)
5767 /* Expand to guarantee sufficient storage. */
5768 uintptr_t document_len = p - document;
5770 document = xrealloc (document, 2 * allocated);
5772 p = document + document_len;
5775 name = xml_escape_text ((char *) libname);
5776 p += sprintf (p, "<library name=\"%s\" lm=\"0x%lx\" "
5777 "l_addr=\"0x%lx\" l_ld=\"0x%lx\"/>",
5778 name, (unsigned long) lm_addr,
5779 (unsigned long) l_addr, (unsigned long) l_ld);
5782 else if (lm_prev == 0)
5784 sprintf (p, " main-lm=\"0x%lx\"", (unsigned long) lm_addr);
5797 /* Empty list; terminate `<library-list-svr4'. */
5801 strcpy (p, "</library-list-svr4>");
5804 document_len = strlen (document);
5805 if (offset < document_len)
5806 document_len -= offset;
5809 if (len > document_len)
5812 memcpy (readbuf, document + offset, len);
5818 static struct target_ops linux_target_ops = {
5819 linux_create_inferior,
5828 linux_fetch_registers,
5829 linux_store_registers,
5830 linux_prepare_to_access_memory,
5831 linux_done_accessing_memory,
5834 linux_look_up_symbols,
5835 linux_request_interrupt,
5839 linux_stopped_by_watchpoint,
5840 linux_stopped_data_address,
5841 #if defined(__UCLIBC__) && defined(HAS_NOMMU)
5846 #ifdef USE_THREAD_DB
5847 thread_db_get_tls_address,
5852 hostio_last_error_from_errno,
5855 linux_supports_non_stop,
5857 linux_start_non_stop,
5858 linux_supports_multi_process,
5859 #ifdef USE_THREAD_DB
5860 thread_db_handle_monitor_command,
5864 linux_common_core_of_thread,
5866 linux_process_qsupported,
5867 linux_supports_tracepoints,
5870 linux_thread_stopped,
5874 linux_cancel_breakpoints,
5875 linux_stabilize_threads,
5876 linux_install_fast_tracepoint_jump_pad,
5878 linux_supports_disable_randomization,
5879 linux_get_min_fast_tracepoint_insn_len,
5880 linux_qxfer_libraries_svr4,
5881 linux_supports_agent,
5885 linux_init_signals ()
5887 /* FIXME drow/2002-06-09: As above, we should check with LinuxThreads
5888 to find what the cancel signal actually is. */
5889 #ifndef __ANDROID__ /* Bionic doesn't use SIGRTMIN the way glibc does. */
5890 signal (__SIGRTMIN+1, SIG_IGN);
5895 initialize_low (void)
5897 struct sigaction sigchld_action;
5898 memset (&sigchld_action, 0, sizeof (sigchld_action));
5899 set_target_ops (&linux_target_ops);
5900 set_breakpoint_data (the_low_target.breakpoint,
5901 the_low_target.breakpoint_len);
5902 linux_init_signals ();
5903 linux_test_for_tracefork ();
5904 linux_ptrace_init_warnings ();
5905 #ifdef HAVE_LINUX_REGSETS
5906 for (num_regsets = 0; target_regsets[num_regsets].size >= 0; num_regsets++)
5908 disabled_regsets = xmalloc (num_regsets);
5911 sigchld_action.sa_handler = sigchld_handler;
5912 sigemptyset (&sigchld_action.sa_mask);
5913 sigchld_action.sa_flags = SA_RESTART;
5914 sigaction (SIGCHLD, &sigchld_action, NULL);