1 /* Low level interface to ptrace, for the remote server for GDB.
2 Copyright (C) 1995-2015 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 "nat/linux-osdata.h"
26 #include "nat/linux-nat.h"
27 #include "nat/linux-waitpid.h"
29 #include "nat/gdb_ptrace.h"
30 #include "nat/linux-ptrace.h"
31 #include "nat/linux-procfs.h"
32 #include "nat/linux-personality.h"
34 #include <sys/ioctl.h>
37 #include <sys/syscall.h>
41 #include <sys/types.h>
46 #include "filestuff.h"
47 #include "tracepoint.h"
50 /* Don't include <linux/elf.h> here. If it got included by gdb_proc_service.h
51 then ELFMAG0 will have been defined. If it didn't get included by
52 gdb_proc_service.h then including it will likely introduce a duplicate
53 definition of elf_fpregset_t. */
56 #include "nat/linux-namespaces.h"
59 #define SPUFS_MAGIC 0x23c9b64e
62 #ifdef HAVE_PERSONALITY
63 # include <sys/personality.h>
64 # if !HAVE_DECL_ADDR_NO_RANDOMIZE
65 # define ADDR_NO_RANDOMIZE 0x0040000
74 #define W_STOPCODE(sig) ((sig) << 8 | 0x7f)
77 /* This is the kernel's hard limit. Not to be confused with
83 /* Some targets did not define these ptrace constants from the start,
84 so gdbserver defines them locally here. In the future, these may
85 be removed after they are added to asm/ptrace.h. */
86 #if !(defined(PT_TEXT_ADDR) \
87 || defined(PT_DATA_ADDR) \
88 || defined(PT_TEXT_END_ADDR))
89 #if defined(__mcoldfire__)
90 /* These are still undefined in 3.10 kernels. */
91 #define PT_TEXT_ADDR 49*4
92 #define PT_DATA_ADDR 50*4
93 #define PT_TEXT_END_ADDR 51*4
94 /* BFIN already defines these since at least 2.6.32 kernels. */
96 #define PT_TEXT_ADDR 220
97 #define PT_TEXT_END_ADDR 224
98 #define PT_DATA_ADDR 228
99 /* These are still undefined in 3.10 kernels. */
100 #elif defined(__TMS320C6X__)
101 #define PT_TEXT_ADDR (0x10000*4)
102 #define PT_DATA_ADDR (0x10004*4)
103 #define PT_TEXT_END_ADDR (0x10008*4)
107 #ifdef HAVE_LINUX_BTRACE
108 # include "nat/linux-btrace.h"
109 # include "btrace-common.h"
112 #ifndef HAVE_ELF32_AUXV_T
113 /* Copied from glibc's elf.h. */
116 uint32_t a_type; /* Entry type */
119 uint32_t a_val; /* Integer value */
120 /* We use to have pointer elements added here. We cannot do that,
121 though, since it does not work when using 32-bit definitions
122 on 64-bit platforms and vice versa. */
127 #ifndef HAVE_ELF64_AUXV_T
128 /* Copied from glibc's elf.h. */
131 uint64_t a_type; /* Entry type */
134 uint64_t a_val; /* Integer value */
135 /* We use to have pointer elements added here. We cannot do that,
136 though, since it does not work when using 32-bit definitions
137 on 64-bit platforms and vice versa. */
142 /* Does the current host support PTRACE_GETREGSET? */
143 int have_ptrace_getregset = -1;
147 /* See nat/linux-nat.h. */
150 ptid_of_lwp (struct lwp_info *lwp)
152 return ptid_of (get_lwp_thread (lwp));
155 /* See nat/linux-nat.h. */
158 lwp_set_arch_private_info (struct lwp_info *lwp,
159 struct arch_lwp_info *info)
161 lwp->arch_private = info;
164 /* See nat/linux-nat.h. */
166 struct arch_lwp_info *
167 lwp_arch_private_info (struct lwp_info *lwp)
169 return lwp->arch_private;
172 /* See nat/linux-nat.h. */
175 lwp_is_stopped (struct lwp_info *lwp)
180 /* See nat/linux-nat.h. */
182 enum target_stop_reason
183 lwp_stop_reason (struct lwp_info *lwp)
185 return lwp->stop_reason;
188 /* A list of all unknown processes which receive stop signals. Some
189 other process will presumably claim each of these as forked
190 children momentarily. */
192 struct simple_pid_list
194 /* The process ID. */
197 /* The status as reported by waitpid. */
201 struct simple_pid_list *next;
203 struct simple_pid_list *stopped_pids;
205 /* Trivial list manipulation functions to keep track of a list of new
206 stopped processes. */
209 add_to_pid_list (struct simple_pid_list **listp, int pid, int status)
211 struct simple_pid_list *new_pid = XNEW (struct simple_pid_list);
214 new_pid->status = status;
215 new_pid->next = *listp;
220 pull_pid_from_list (struct simple_pid_list **listp, int pid, int *statusp)
222 struct simple_pid_list **p;
224 for (p = listp; *p != NULL; p = &(*p)->next)
225 if ((*p)->pid == pid)
227 struct simple_pid_list *next = (*p)->next;
229 *statusp = (*p)->status;
237 enum stopping_threads_kind
239 /* Not stopping threads presently. */
240 NOT_STOPPING_THREADS,
242 /* Stopping threads. */
245 /* Stopping and suspending threads. */
246 STOPPING_AND_SUSPENDING_THREADS
249 /* This is set while stop_all_lwps is in effect. */
250 enum stopping_threads_kind stopping_threads = NOT_STOPPING_THREADS;
252 /* FIXME make into a target method? */
253 int using_threads = 1;
255 /* True if we're presently stabilizing threads (moving them out of
257 static int stabilizing_threads;
259 static void linux_resume_one_lwp (struct lwp_info *lwp,
260 int step, int signal, siginfo_t *info);
261 static void linux_resume (struct thread_resume *resume_info, size_t n);
262 static void stop_all_lwps (int suspend, struct lwp_info *except);
263 static void unstop_all_lwps (int unsuspend, struct lwp_info *except);
264 static int linux_wait_for_event_filtered (ptid_t wait_ptid, ptid_t filter_ptid,
265 int *wstat, int options);
266 static int linux_wait_for_event (ptid_t ptid, int *wstat, int options);
267 static struct lwp_info *add_lwp (ptid_t ptid);
268 static int linux_stopped_by_watchpoint (void);
269 static void mark_lwp_dead (struct lwp_info *lwp, int wstat);
270 static int lwp_is_marked_dead (struct lwp_info *lwp);
271 static void proceed_all_lwps (void);
272 static int finish_step_over (struct lwp_info *lwp);
273 static int kill_lwp (unsigned long lwpid, int signo);
274 static void enqueue_pending_signal (struct lwp_info *lwp, int signal, siginfo_t *info);
275 static void complete_ongoing_step_over (void);
277 /* When the event-loop is doing a step-over, this points at the thread
279 ptid_t step_over_bkpt;
281 /* True if the low target can hardware single-step. Such targets
282 don't need a BREAKPOINT_REINSERT_ADDR callback. */
285 can_hardware_single_step (void)
287 return (the_low_target.breakpoint_reinsert_addr == NULL);
290 /* True if the low target supports memory breakpoints. If so, we'll
291 have a GET_PC implementation. */
294 supports_breakpoints (void)
296 return (the_low_target.get_pc != NULL);
299 /* Returns true if this target can support fast tracepoints. This
300 does not mean that the in-process agent has been loaded in the
304 supports_fast_tracepoints (void)
306 return the_low_target.install_fast_tracepoint_jump_pad != NULL;
309 /* True if LWP is stopped in its stepping range. */
312 lwp_in_step_range (struct lwp_info *lwp)
314 CORE_ADDR pc = lwp->stop_pc;
316 return (pc >= lwp->step_range_start && pc < lwp->step_range_end);
319 struct pending_signals
323 struct pending_signals *prev;
326 /* The read/write ends of the pipe registered as waitable file in the
328 static int linux_event_pipe[2] = { -1, -1 };
330 /* True if we're currently in async mode. */
331 #define target_is_async_p() (linux_event_pipe[0] != -1)
333 static void send_sigstop (struct lwp_info *lwp);
334 static void wait_for_sigstop (void);
336 /* Return non-zero if HEADER is a 64-bit ELF file. */
339 elf_64_header_p (const Elf64_Ehdr *header, unsigned int *machine)
341 if (header->e_ident[EI_MAG0] == ELFMAG0
342 && header->e_ident[EI_MAG1] == ELFMAG1
343 && header->e_ident[EI_MAG2] == ELFMAG2
344 && header->e_ident[EI_MAG3] == ELFMAG3)
346 *machine = header->e_machine;
347 return header->e_ident[EI_CLASS] == ELFCLASS64;
354 /* Return non-zero if FILE is a 64-bit ELF file,
355 zero if the file is not a 64-bit ELF file,
356 and -1 if the file is not accessible or doesn't exist. */
359 elf_64_file_p (const char *file, unsigned int *machine)
364 fd = open (file, O_RDONLY);
368 if (read (fd, &header, sizeof (header)) != sizeof (header))
375 return elf_64_header_p (&header, machine);
378 /* Accepts an integer PID; Returns true if the executable PID is
379 running is a 64-bit ELF file.. */
382 linux_pid_exe_is_elf_64_file (int pid, unsigned int *machine)
386 sprintf (file, "/proc/%d/exe", pid);
387 return elf_64_file_p (file, machine);
391 delete_lwp (struct lwp_info *lwp)
393 struct thread_info *thr = get_lwp_thread (lwp);
396 debug_printf ("deleting %ld\n", lwpid_of (thr));
399 free (lwp->arch_private);
403 /* Add a process to the common process list, and set its private
406 static struct process_info *
407 linux_add_process (int pid, int attached)
409 struct process_info *proc;
411 proc = add_process (pid, attached);
412 proc->priv = XCNEW (struct process_info_private);
414 if (the_low_target.new_process != NULL)
415 proc->priv->arch_private = the_low_target.new_process ();
420 static CORE_ADDR get_pc (struct lwp_info *lwp);
422 /* Handle a GNU/Linux extended wait response. If we see a clone
423 event, we need to add the new LWP to our list (and return 0 so as
424 not to report the trap to higher layers). */
427 handle_extended_wait (struct lwp_info *event_lwp, int wstat)
429 int event = linux_ptrace_get_extended_event (wstat);
430 struct thread_info *event_thr = get_lwp_thread (event_lwp);
431 struct lwp_info *new_lwp;
433 if ((event == PTRACE_EVENT_FORK) || (event == PTRACE_EVENT_VFORK)
434 || (event == PTRACE_EVENT_CLONE))
437 unsigned long new_pid;
440 /* Get the pid of the new lwp. */
441 ptrace (PTRACE_GETEVENTMSG, lwpid_of (event_thr), (PTRACE_TYPE_ARG3) 0,
444 /* If we haven't already seen the new PID stop, wait for it now. */
445 if (!pull_pid_from_list (&stopped_pids, new_pid, &status))
447 /* The new child has a pending SIGSTOP. We can't affect it until it
448 hits the SIGSTOP, but we're already attached. */
450 ret = my_waitpid (new_pid, &status, __WALL);
453 perror_with_name ("waiting for new child");
454 else if (ret != new_pid)
455 warning ("wait returned unexpected PID %d", ret);
456 else if (!WIFSTOPPED (status))
457 warning ("wait returned unexpected status 0x%x", status);
460 if (event == PTRACE_EVENT_FORK || event == PTRACE_EVENT_VFORK)
462 struct process_info *parent_proc;
463 struct process_info *child_proc;
464 struct lwp_info *child_lwp;
465 struct thread_info *child_thr;
466 struct target_desc *tdesc;
468 ptid = ptid_build (new_pid, new_pid, 0);
472 debug_printf ("HEW: Got fork event from LWP %ld, "
474 ptid_get_lwp (ptid_of (event_thr)),
475 ptid_get_pid (ptid));
478 /* Add the new process to the tables and clone the breakpoint
479 lists of the parent. We need to do this even if the new process
480 will be detached, since we will need the process object and the
481 breakpoints to remove any breakpoints from memory when we
482 detach, and the client side will access registers. */
483 child_proc = linux_add_process (new_pid, 0);
484 gdb_assert (child_proc != NULL);
485 child_lwp = add_lwp (ptid);
486 gdb_assert (child_lwp != NULL);
487 child_lwp->stopped = 1;
488 child_lwp->must_set_ptrace_flags = 1;
489 child_lwp->status_pending_p = 0;
490 child_thr = get_lwp_thread (child_lwp);
491 child_thr->last_resume_kind = resume_stop;
492 child_thr->last_status.kind = TARGET_WAITKIND_STOPPED;
494 /* If we're suspending all threads, leave this one suspended
496 if (stopping_threads == STOPPING_AND_SUSPENDING_THREADS)
499 debug_printf ("HEW: leaving child suspended\n");
500 child_lwp->suspended = 1;
503 parent_proc = get_thread_process (event_thr);
504 child_proc->attached = parent_proc->attached;
505 clone_all_breakpoints (&child_proc->breakpoints,
506 &child_proc->raw_breakpoints,
507 parent_proc->breakpoints);
509 tdesc = XNEW (struct target_desc);
510 copy_target_description (tdesc, parent_proc->tdesc);
511 child_proc->tdesc = tdesc;
513 /* Clone arch-specific process data. */
514 if (the_low_target.new_fork != NULL)
515 the_low_target.new_fork (parent_proc, child_proc);
517 /* Save fork info in the parent thread. */
518 if (event == PTRACE_EVENT_FORK)
519 event_lwp->waitstatus.kind = TARGET_WAITKIND_FORKED;
520 else if (event == PTRACE_EVENT_VFORK)
521 event_lwp->waitstatus.kind = TARGET_WAITKIND_VFORKED;
523 event_lwp->waitstatus.value.related_pid = ptid;
525 /* The status_pending field contains bits denoting the
526 extended event, so when the pending event is handled,
527 the handler will look at lwp->waitstatus. */
528 event_lwp->status_pending_p = 1;
529 event_lwp->status_pending = wstat;
531 /* Report the event. */
536 debug_printf ("HEW: Got clone event "
537 "from LWP %ld, new child is LWP %ld\n",
538 lwpid_of (event_thr), new_pid);
540 ptid = ptid_build (pid_of (event_thr), new_pid, 0);
541 new_lwp = add_lwp (ptid);
543 /* Either we're going to immediately resume the new thread
544 or leave it stopped. linux_resume_one_lwp is a nop if it
545 thinks the thread is currently running, so set this first
546 before calling linux_resume_one_lwp. */
547 new_lwp->stopped = 1;
549 /* If we're suspending all threads, leave this one suspended
551 if (stopping_threads == STOPPING_AND_SUSPENDING_THREADS)
552 new_lwp->suspended = 1;
554 /* Normally we will get the pending SIGSTOP. But in some cases
555 we might get another signal delivered to the group first.
556 If we do get another signal, be sure not to lose it. */
557 if (WSTOPSIG (status) != SIGSTOP)
559 new_lwp->stop_expected = 1;
560 new_lwp->status_pending_p = 1;
561 new_lwp->status_pending = status;
564 /* Don't report the event. */
567 else if (event == PTRACE_EVENT_VFORK_DONE)
569 event_lwp->waitstatus.kind = TARGET_WAITKIND_VFORK_DONE;
571 /* Report the event. */
575 internal_error (__FILE__, __LINE__, _("unknown ptrace event %d"), event);
578 /* Return the PC as read from the regcache of LWP, without any
582 get_pc (struct lwp_info *lwp)
584 struct thread_info *saved_thread;
585 struct regcache *regcache;
588 if (the_low_target.get_pc == NULL)
591 saved_thread = current_thread;
592 current_thread = get_lwp_thread (lwp);
594 regcache = get_thread_regcache (current_thread, 1);
595 pc = (*the_low_target.get_pc) (regcache);
598 debug_printf ("pc is 0x%lx\n", (long) pc);
600 current_thread = saved_thread;
604 /* This function should only be called if LWP got a SIGTRAP.
605 The SIGTRAP could mean several things.
607 On i386, where decr_pc_after_break is non-zero:
609 If we were single-stepping this process using PTRACE_SINGLESTEP, we
610 will get only the one SIGTRAP. The value of $eip will be the next
611 instruction. If the instruction we stepped over was a breakpoint,
612 we need to decrement the PC.
614 If we continue the process using PTRACE_CONT, we will get a
615 SIGTRAP when we hit a breakpoint. The value of $eip will be
616 the instruction after the breakpoint (i.e. needs to be
617 decremented). If we report the SIGTRAP to GDB, we must also
618 report the undecremented PC. If the breakpoint is removed, we
619 must resume at the decremented PC.
621 On a non-decr_pc_after_break machine with hardware or kernel
624 If we either single-step a breakpoint instruction, or continue and
625 hit a breakpoint instruction, our PC will point at the breakpoint
629 check_stopped_by_breakpoint (struct lwp_info *lwp)
632 CORE_ADDR sw_breakpoint_pc;
633 struct thread_info *saved_thread;
634 #if USE_SIGTRAP_SIGINFO
638 if (the_low_target.get_pc == NULL)
642 sw_breakpoint_pc = pc - the_low_target.decr_pc_after_break;
644 /* breakpoint_at reads from the current thread. */
645 saved_thread = current_thread;
646 current_thread = get_lwp_thread (lwp);
648 #if USE_SIGTRAP_SIGINFO
649 if (ptrace (PTRACE_GETSIGINFO, lwpid_of (current_thread),
650 (PTRACE_TYPE_ARG3) 0, &siginfo) == 0)
652 if (siginfo.si_signo == SIGTRAP)
654 if (GDB_ARCH_IS_TRAP_BRKPT (siginfo.si_code))
658 struct thread_info *thr = get_lwp_thread (lwp);
660 debug_printf ("CSBB: %s stopped by software breakpoint\n",
661 target_pid_to_str (ptid_of (thr)));
664 /* Back up the PC if necessary. */
665 if (pc != sw_breakpoint_pc)
667 struct regcache *regcache
668 = get_thread_regcache (current_thread, 1);
669 (*the_low_target.set_pc) (regcache, sw_breakpoint_pc);
672 lwp->stop_pc = sw_breakpoint_pc;
673 lwp->stop_reason = TARGET_STOPPED_BY_SW_BREAKPOINT;
674 current_thread = saved_thread;
677 else if (siginfo.si_code == TRAP_HWBKPT)
681 struct thread_info *thr = get_lwp_thread (lwp);
683 debug_printf ("CSBB: %s stopped by hardware "
684 "breakpoint/watchpoint\n",
685 target_pid_to_str (ptid_of (thr)));
689 lwp->stop_reason = TARGET_STOPPED_BY_HW_BREAKPOINT;
690 current_thread = saved_thread;
693 else if (siginfo.si_code == TRAP_TRACE)
697 struct thread_info *thr = get_lwp_thread (lwp);
699 debug_printf ("CSBB: %s stopped by trace\n",
700 target_pid_to_str (ptid_of (thr)));
703 lwp->stop_reason = TARGET_STOPPED_BY_SINGLE_STEP;
708 /* We may have just stepped a breakpoint instruction. E.g., in
709 non-stop mode, GDB first tells the thread A to step a range, and
710 then the user inserts a breakpoint inside the range. In that
711 case we need to report the breakpoint PC. */
712 if ((!lwp->stepping || lwp->stop_pc == sw_breakpoint_pc)
713 && (*the_low_target.breakpoint_at) (sw_breakpoint_pc))
717 struct thread_info *thr = get_lwp_thread (lwp);
719 debug_printf ("CSBB: %s stopped by software breakpoint\n",
720 target_pid_to_str (ptid_of (thr)));
723 /* Back up the PC if necessary. */
724 if (pc != sw_breakpoint_pc)
726 struct regcache *regcache
727 = get_thread_regcache (current_thread, 1);
728 (*the_low_target.set_pc) (regcache, sw_breakpoint_pc);
731 lwp->stop_pc = sw_breakpoint_pc;
732 lwp->stop_reason = TARGET_STOPPED_BY_SW_BREAKPOINT;
733 current_thread = saved_thread;
737 if (hardware_breakpoint_inserted_here (pc))
741 struct thread_info *thr = get_lwp_thread (lwp);
743 debug_printf ("CSBB: %s stopped by hardware breakpoint\n",
744 target_pid_to_str (ptid_of (thr)));
748 lwp->stop_reason = TARGET_STOPPED_BY_HW_BREAKPOINT;
749 current_thread = saved_thread;
754 current_thread = saved_thread;
758 static struct lwp_info *
759 add_lwp (ptid_t ptid)
761 struct lwp_info *lwp;
763 lwp = XCNEW (struct lwp_info);
765 lwp->waitstatus.kind = TARGET_WAITKIND_IGNORE;
767 if (the_low_target.new_thread != NULL)
768 the_low_target.new_thread (lwp);
770 lwp->thread = add_thread (ptid, lwp);
775 /* Start an inferior process and returns its pid.
776 ALLARGS is a vector of program-name and args. */
779 linux_create_inferior (char *program, char **allargs)
781 struct lwp_info *new_lwp;
784 struct cleanup *restore_personality
785 = maybe_disable_address_space_randomization (disable_randomization);
787 #if defined(__UCLIBC__) && defined(HAS_NOMMU)
793 perror_with_name ("fork");
798 ptrace (PTRACE_TRACEME, 0, (PTRACE_TYPE_ARG3) 0, (PTRACE_TYPE_ARG4) 0);
800 #ifndef __ANDROID__ /* Bionic doesn't use SIGRTMIN the way glibc does. */
801 signal (__SIGRTMIN + 1, SIG_DFL);
806 /* If gdbserver is connected to gdb via stdio, redirect the inferior's
807 stdout to stderr so that inferior i/o doesn't corrupt the connection.
808 Also, redirect stdin to /dev/null. */
809 if (remote_connection_is_stdio ())
812 open ("/dev/null", O_RDONLY);
814 if (write (2, "stdin/stdout redirected\n",
815 sizeof ("stdin/stdout redirected\n") - 1) < 0)
817 /* Errors ignored. */;
821 execv (program, allargs);
823 execvp (program, allargs);
825 fprintf (stderr, "Cannot exec %s: %s.\n", program,
831 do_cleanups (restore_personality);
833 linux_add_process (pid, 0);
835 ptid = ptid_build (pid, pid, 0);
836 new_lwp = add_lwp (ptid);
837 new_lwp->must_set_ptrace_flags = 1;
842 /* Implement the arch_setup target_ops method. */
845 linux_arch_setup (void)
847 the_low_target.arch_setup ();
850 /* Attach to an inferior process. Returns 0 on success, ERRNO on
854 linux_attach_lwp (ptid_t ptid)
856 struct lwp_info *new_lwp;
857 int lwpid = ptid_get_lwp (ptid);
859 if (ptrace (PTRACE_ATTACH, lwpid, (PTRACE_TYPE_ARG3) 0, (PTRACE_TYPE_ARG4) 0)
863 new_lwp = add_lwp (ptid);
865 /* We need to wait for SIGSTOP before being able to make the next
866 ptrace call on this LWP. */
867 new_lwp->must_set_ptrace_flags = 1;
869 if (linux_proc_pid_is_stopped (lwpid))
872 debug_printf ("Attached to a stopped process\n");
874 /* The process is definitely stopped. It is in a job control
875 stop, unless the kernel predates the TASK_STOPPED /
876 TASK_TRACED distinction, in which case it might be in a
877 ptrace stop. Make sure it is in a ptrace stop; from there we
878 can kill it, signal it, et cetera.
880 First make sure there is a pending SIGSTOP. Since we are
881 already attached, the process can not transition from stopped
882 to running without a PTRACE_CONT; so we know this signal will
883 go into the queue. The SIGSTOP generated by PTRACE_ATTACH is
884 probably already in the queue (unless this kernel is old
885 enough to use TASK_STOPPED for ptrace stops); but since
886 SIGSTOP is not an RT signal, it can only be queued once. */
887 kill_lwp (lwpid, SIGSTOP);
889 /* Finally, resume the stopped process. This will deliver the
890 SIGSTOP (or a higher priority signal, just like normal
891 PTRACE_ATTACH), which we'll catch later on. */
892 ptrace (PTRACE_CONT, lwpid, (PTRACE_TYPE_ARG3) 0, (PTRACE_TYPE_ARG4) 0);
895 /* The next time we wait for this LWP we'll see a SIGSTOP as PTRACE_ATTACH
898 There are several cases to consider here:
900 1) gdbserver has already attached to the process and is being notified
901 of a new thread that is being created.
902 In this case we should ignore that SIGSTOP and resume the
903 process. This is handled below by setting stop_expected = 1,
904 and the fact that add_thread sets last_resume_kind ==
907 2) This is the first thread (the process thread), and we're attaching
908 to it via attach_inferior.
909 In this case we want the process thread to stop.
910 This is handled by having linux_attach set last_resume_kind ==
911 resume_stop after we return.
913 If the pid we are attaching to is also the tgid, we attach to and
914 stop all the existing threads. Otherwise, we attach to pid and
915 ignore any other threads in the same group as this pid.
917 3) GDB is connecting to gdbserver and is requesting an enumeration of all
919 In this case we want the thread to stop.
920 FIXME: This case is currently not properly handled.
921 We should wait for the SIGSTOP but don't. Things work apparently
922 because enough time passes between when we ptrace (ATTACH) and when
923 gdb makes the next ptrace call on the thread.
925 On the other hand, if we are currently trying to stop all threads, we
926 should treat the new thread as if we had sent it a SIGSTOP. This works
927 because we are guaranteed that the add_lwp call above added us to the
928 end of the list, and so the new thread has not yet reached
929 wait_for_sigstop (but will). */
930 new_lwp->stop_expected = 1;
935 /* Callback for linux_proc_attach_tgid_threads. Attach to PTID if not
936 already attached. Returns true if a new LWP is found, false
940 attach_proc_task_lwp_callback (ptid_t ptid)
942 /* Is this a new thread? */
943 if (find_thread_ptid (ptid) == NULL)
945 int lwpid = ptid_get_lwp (ptid);
949 debug_printf ("Found new lwp %d\n", lwpid);
951 err = linux_attach_lwp (ptid);
953 /* Be quiet if we simply raced with the thread exiting. EPERM
954 is returned if the thread's task still exists, and is marked
955 as exited or zombie, as well as other conditions, so in that
956 case, confirm the status in /proc/PID/status. */
958 || (err == EPERM && linux_proc_pid_is_gone (lwpid)))
962 debug_printf ("Cannot attach to lwp %d: "
963 "thread is gone (%d: %s)\n",
964 lwpid, err, strerror (err));
969 warning (_("Cannot attach to lwp %d: %s"),
971 linux_ptrace_attach_fail_reason_string (ptid, err));
979 /* Attach to PID. If PID is the tgid, attach to it and all
983 linux_attach (unsigned long pid)
985 ptid_t ptid = ptid_build (pid, pid, 0);
988 /* Attach to PID. We will check for other threads
990 err = linux_attach_lwp (ptid);
992 error ("Cannot attach to process %ld: %s",
993 pid, linux_ptrace_attach_fail_reason_string (ptid, err));
995 linux_add_process (pid, 1);
999 struct thread_info *thread;
1001 /* Don't ignore the initial SIGSTOP if we just attached to this
1002 process. It will be collected by wait shortly. */
1003 thread = find_thread_ptid (ptid_build (pid, pid, 0));
1004 thread->last_resume_kind = resume_stop;
1007 /* We must attach to every LWP. If /proc is mounted, use that to
1008 find them now. On the one hand, the inferior may be using raw
1009 clone instead of using pthreads. On the other hand, even if it
1010 is using pthreads, GDB may not be connected yet (thread_db needs
1011 to do symbol lookups, through qSymbol). Also, thread_db walks
1012 structures in the inferior's address space to find the list of
1013 threads/LWPs, and those structures may well be corrupted. Note
1014 that once thread_db is loaded, we'll still use it to list threads
1015 and associate pthread info with each LWP. */
1016 linux_proc_attach_tgid_threads (pid, attach_proc_task_lwp_callback);
1027 second_thread_of_pid_p (struct inferior_list_entry *entry, void *args)
1029 struct counter *counter = args;
1031 if (ptid_get_pid (entry->id) == counter->pid)
1033 if (++counter->count > 1)
1041 last_thread_of_process_p (int pid)
1043 struct counter counter = { pid , 0 };
1045 return (find_inferior (&all_threads,
1046 second_thread_of_pid_p, &counter) == NULL);
1052 linux_kill_one_lwp (struct lwp_info *lwp)
1054 struct thread_info *thr = get_lwp_thread (lwp);
1055 int pid = lwpid_of (thr);
1057 /* PTRACE_KILL is unreliable. After stepping into a signal handler,
1058 there is no signal context, and ptrace(PTRACE_KILL) (or
1059 ptrace(PTRACE_CONT, SIGKILL), pretty much the same) acts like
1060 ptrace(CONT, pid, 0,0) and just resumes the tracee. A better
1061 alternative is to kill with SIGKILL. We only need one SIGKILL
1062 per process, not one for each thread. But since we still support
1063 linuxthreads, and we also support debugging programs using raw
1064 clone without CLONE_THREAD, we send one for each thread. For
1065 years, we used PTRACE_KILL only, so we're being a bit paranoid
1066 about some old kernels where PTRACE_KILL might work better
1067 (dubious if there are any such, but that's why it's paranoia), so
1068 we try SIGKILL first, PTRACE_KILL second, and so we're fine
1072 kill_lwp (pid, SIGKILL);
1075 int save_errno = errno;
1077 debug_printf ("LKL: kill_lwp (SIGKILL) %s, 0, 0 (%s)\n",
1078 target_pid_to_str (ptid_of (thr)),
1079 save_errno ? strerror (save_errno) : "OK");
1083 ptrace (PTRACE_KILL, pid, (PTRACE_TYPE_ARG3) 0, (PTRACE_TYPE_ARG4) 0);
1086 int save_errno = errno;
1088 debug_printf ("LKL: PTRACE_KILL %s, 0, 0 (%s)\n",
1089 target_pid_to_str (ptid_of (thr)),
1090 save_errno ? strerror (save_errno) : "OK");
1094 /* Kill LWP and wait for it to die. */
1097 kill_wait_lwp (struct lwp_info *lwp)
1099 struct thread_info *thr = get_lwp_thread (lwp);
1100 int pid = ptid_get_pid (ptid_of (thr));
1101 int lwpid = ptid_get_lwp (ptid_of (thr));
1106 debug_printf ("kwl: killing lwp %d, for pid: %d\n", lwpid, pid);
1110 linux_kill_one_lwp (lwp);
1112 /* Make sure it died. Notes:
1114 - The loop is most likely unnecessary.
1116 - We don't use linux_wait_for_event as that could delete lwps
1117 while we're iterating over them. We're not interested in
1118 any pending status at this point, only in making sure all
1119 wait status on the kernel side are collected until the
1122 - We don't use __WALL here as the __WALL emulation relies on
1123 SIGCHLD, and killing a stopped process doesn't generate
1124 one, nor an exit status.
1126 res = my_waitpid (lwpid, &wstat, 0);
1127 if (res == -1 && errno == ECHILD)
1128 res = my_waitpid (lwpid, &wstat, __WCLONE);
1129 } while (res > 0 && WIFSTOPPED (wstat));
1131 /* Even if it was stopped, the child may have already disappeared.
1132 E.g., if it was killed by SIGKILL. */
1133 if (res < 0 && errno != ECHILD)
1134 perror_with_name ("kill_wait_lwp");
1137 /* Callback for `find_inferior'. Kills an lwp of a given process,
1138 except the leader. */
1141 kill_one_lwp_callback (struct inferior_list_entry *entry, void *args)
1143 struct thread_info *thread = (struct thread_info *) entry;
1144 struct lwp_info *lwp = get_thread_lwp (thread);
1145 int pid = * (int *) args;
1147 if (ptid_get_pid (entry->id) != pid)
1150 /* We avoid killing the first thread here, because of a Linux kernel (at
1151 least 2.6.0-test7 through 2.6.8-rc4) bug; if we kill the parent before
1152 the children get a chance to be reaped, it will remain a zombie
1155 if (lwpid_of (thread) == pid)
1158 debug_printf ("lkop: is last of process %s\n",
1159 target_pid_to_str (entry->id));
1163 kill_wait_lwp (lwp);
1168 linux_kill (int pid)
1170 struct process_info *process;
1171 struct lwp_info *lwp;
1173 process = find_process_pid (pid);
1174 if (process == NULL)
1177 /* If we're killing a running inferior, make sure it is stopped
1178 first, as PTRACE_KILL will not work otherwise. */
1179 stop_all_lwps (0, NULL);
1181 find_inferior (&all_threads, kill_one_lwp_callback , &pid);
1183 /* See the comment in linux_kill_one_lwp. We did not kill the first
1184 thread in the list, so do so now. */
1185 lwp = find_lwp_pid (pid_to_ptid (pid));
1190 debug_printf ("lk_1: cannot find lwp for pid: %d\n",
1194 kill_wait_lwp (lwp);
1196 the_target->mourn (process);
1198 /* Since we presently can only stop all lwps of all processes, we
1199 need to unstop lwps of other processes. */
1200 unstop_all_lwps (0, NULL);
1204 /* Get pending signal of THREAD, for detaching purposes. This is the
1205 signal the thread last stopped for, which we need to deliver to the
1206 thread when detaching, otherwise, it'd be suppressed/lost. */
1209 get_detach_signal (struct thread_info *thread)
1211 enum gdb_signal signo = GDB_SIGNAL_0;
1213 struct lwp_info *lp = get_thread_lwp (thread);
1215 if (lp->status_pending_p)
1216 status = lp->status_pending;
1219 /* If the thread had been suspended by gdbserver, and it stopped
1220 cleanly, then it'll have stopped with SIGSTOP. But we don't
1221 want to deliver that SIGSTOP. */
1222 if (thread->last_status.kind != TARGET_WAITKIND_STOPPED
1223 || thread->last_status.value.sig == GDB_SIGNAL_0)
1226 /* Otherwise, we may need to deliver the signal we
1228 status = lp->last_status;
1231 if (!WIFSTOPPED (status))
1234 debug_printf ("GPS: lwp %s hasn't stopped: no pending signal\n",
1235 target_pid_to_str (ptid_of (thread)));
1239 /* Extended wait statuses aren't real SIGTRAPs. */
1240 if (WSTOPSIG (status) == SIGTRAP && linux_is_extended_waitstatus (status))
1243 debug_printf ("GPS: lwp %s had stopped with extended "
1244 "status: no pending signal\n",
1245 target_pid_to_str (ptid_of (thread)));
1249 signo = gdb_signal_from_host (WSTOPSIG (status));
1251 if (program_signals_p && !program_signals[signo])
1254 debug_printf ("GPS: lwp %s had signal %s, but it is in nopass state\n",
1255 target_pid_to_str (ptid_of (thread)),
1256 gdb_signal_to_string (signo));
1259 else if (!program_signals_p
1260 /* If we have no way to know which signals GDB does not
1261 want to have passed to the program, assume
1262 SIGTRAP/SIGINT, which is GDB's default. */
1263 && (signo == GDB_SIGNAL_TRAP || signo == GDB_SIGNAL_INT))
1266 debug_printf ("GPS: lwp %s had signal %s, "
1267 "but we don't know if we should pass it. "
1268 "Default to not.\n",
1269 target_pid_to_str (ptid_of (thread)),
1270 gdb_signal_to_string (signo));
1276 debug_printf ("GPS: lwp %s has pending signal %s: delivering it.\n",
1277 target_pid_to_str (ptid_of (thread)),
1278 gdb_signal_to_string (signo));
1280 return WSTOPSIG (status);
1285 linux_detach_one_lwp (struct inferior_list_entry *entry, void *args)
1287 struct thread_info *thread = (struct thread_info *) entry;
1288 struct lwp_info *lwp = get_thread_lwp (thread);
1289 int pid = * (int *) args;
1292 if (ptid_get_pid (entry->id) != pid)
1295 /* If there is a pending SIGSTOP, get rid of it. */
1296 if (lwp->stop_expected)
1299 debug_printf ("Sending SIGCONT to %s\n",
1300 target_pid_to_str (ptid_of (thread)));
1302 kill_lwp (lwpid_of (thread), SIGCONT);
1303 lwp->stop_expected = 0;
1306 /* Flush any pending changes to the process's registers. */
1307 regcache_invalidate_thread (thread);
1309 /* Pass on any pending signal for this thread. */
1310 sig = get_detach_signal (thread);
1312 /* Finally, let it resume. */
1313 if (the_low_target.prepare_to_resume != NULL)
1314 the_low_target.prepare_to_resume (lwp);
1315 if (ptrace (PTRACE_DETACH, lwpid_of (thread), (PTRACE_TYPE_ARG3) 0,
1316 (PTRACE_TYPE_ARG4) (long) sig) < 0)
1317 error (_("Can't detach %s: %s"),
1318 target_pid_to_str (ptid_of (thread)),
1326 linux_detach (int pid)
1328 struct process_info *process;
1330 process = find_process_pid (pid);
1331 if (process == NULL)
1334 /* As there's a step over already in progress, let it finish first,
1335 otherwise nesting a stabilize_threads operation on top gets real
1337 complete_ongoing_step_over ();
1339 /* Stop all threads before detaching. First, ptrace requires that
1340 the thread is stopped to sucessfully detach. Second, thread_db
1341 may need to uninstall thread event breakpoints from memory, which
1342 only works with a stopped process anyway. */
1343 stop_all_lwps (0, NULL);
1345 #ifdef USE_THREAD_DB
1346 thread_db_detach (process);
1349 /* Stabilize threads (move out of jump pads). */
1350 stabilize_threads ();
1352 find_inferior (&all_threads, linux_detach_one_lwp, &pid);
1354 the_target->mourn (process);
1356 /* Since we presently can only stop all lwps of all processes, we
1357 need to unstop lwps of other processes. */
1358 unstop_all_lwps (0, NULL);
1362 /* Remove all LWPs that belong to process PROC from the lwp list. */
1365 delete_lwp_callback (struct inferior_list_entry *entry, void *proc)
1367 struct thread_info *thread = (struct thread_info *) entry;
1368 struct lwp_info *lwp = get_thread_lwp (thread);
1369 struct process_info *process = proc;
1371 if (pid_of (thread) == pid_of (process))
1378 linux_mourn (struct process_info *process)
1380 struct process_info_private *priv;
1382 #ifdef USE_THREAD_DB
1383 thread_db_mourn (process);
1386 find_inferior (&all_threads, delete_lwp_callback, process);
1388 /* Freeing all private data. */
1389 priv = process->priv;
1390 free (priv->arch_private);
1392 process->priv = NULL;
1394 remove_process (process);
1398 linux_join (int pid)
1403 ret = my_waitpid (pid, &status, 0);
1404 if (WIFEXITED (status) || WIFSIGNALED (status))
1406 } while (ret != -1 || errno != ECHILD);
1409 /* Return nonzero if the given thread is still alive. */
1411 linux_thread_alive (ptid_t ptid)
1413 struct lwp_info *lwp = find_lwp_pid (ptid);
1415 /* We assume we always know if a thread exits. If a whole process
1416 exited but we still haven't been able to report it to GDB, we'll
1417 hold on to the last lwp of the dead process. */
1419 return !lwp_is_marked_dead (lwp);
1424 /* Return 1 if this lwp still has an interesting status pending. If
1425 not (e.g., it had stopped for a breakpoint that is gone), return
1429 thread_still_has_status_pending_p (struct thread_info *thread)
1431 struct lwp_info *lp = get_thread_lwp (thread);
1433 if (!lp->status_pending_p)
1436 /* If we got a `vCont;t', but we haven't reported a stop yet, do
1437 report any status pending the LWP may have. */
1438 if (thread->last_resume_kind == resume_stop
1439 && thread->last_status.kind != TARGET_WAITKIND_IGNORE)
1442 if (thread->last_resume_kind != resume_stop
1443 && (lp->stop_reason == TARGET_STOPPED_BY_SW_BREAKPOINT
1444 || lp->stop_reason == TARGET_STOPPED_BY_HW_BREAKPOINT))
1446 struct thread_info *saved_thread;
1450 gdb_assert (lp->last_status != 0);
1454 saved_thread = current_thread;
1455 current_thread = thread;
1457 if (pc != lp->stop_pc)
1460 debug_printf ("PC of %ld changed\n",
1465 #if !USE_SIGTRAP_SIGINFO
1466 else if (lp->stop_reason == TARGET_STOPPED_BY_SW_BREAKPOINT
1467 && !(*the_low_target.breakpoint_at) (pc))
1470 debug_printf ("previous SW breakpoint of %ld gone\n",
1474 else if (lp->stop_reason == TARGET_STOPPED_BY_HW_BREAKPOINT
1475 && !hardware_breakpoint_inserted_here (pc))
1478 debug_printf ("previous HW breakpoint of %ld gone\n",
1484 current_thread = saved_thread;
1489 debug_printf ("discarding pending breakpoint status\n");
1490 lp->status_pending_p = 0;
1498 /* Return 1 if this lwp has an interesting status pending. */
1500 status_pending_p_callback (struct inferior_list_entry *entry, void *arg)
1502 struct thread_info *thread = (struct thread_info *) entry;
1503 struct lwp_info *lp = get_thread_lwp (thread);
1504 ptid_t ptid = * (ptid_t *) arg;
1506 /* Check if we're only interested in events from a specific process
1507 or a specific LWP. */
1508 if (!ptid_match (ptid_of (thread), ptid))
1511 if (lp->status_pending_p
1512 && !thread_still_has_status_pending_p (thread))
1514 linux_resume_one_lwp (lp, lp->stepping, GDB_SIGNAL_0, NULL);
1518 return lp->status_pending_p;
1522 same_lwp (struct inferior_list_entry *entry, void *data)
1524 ptid_t ptid = *(ptid_t *) data;
1527 if (ptid_get_lwp (ptid) != 0)
1528 lwp = ptid_get_lwp (ptid);
1530 lwp = ptid_get_pid (ptid);
1532 if (ptid_get_lwp (entry->id) == lwp)
1539 find_lwp_pid (ptid_t ptid)
1541 struct inferior_list_entry *thread
1542 = find_inferior (&all_threads, same_lwp, &ptid);
1547 return get_thread_lwp ((struct thread_info *) thread);
1550 /* Return the number of known LWPs in the tgid given by PID. */
1555 struct inferior_list_entry *inf, *tmp;
1558 ALL_INFERIORS (&all_threads, inf, tmp)
1560 if (ptid_get_pid (inf->id) == pid)
1567 /* The arguments passed to iterate_over_lwps. */
1569 struct iterate_over_lwps_args
1571 /* The FILTER argument passed to iterate_over_lwps. */
1574 /* The CALLBACK argument passed to iterate_over_lwps. */
1575 iterate_over_lwps_ftype *callback;
1577 /* The DATA argument passed to iterate_over_lwps. */
1581 /* Callback for find_inferior used by iterate_over_lwps to filter
1582 calls to the callback supplied to that function. Returning a
1583 nonzero value causes find_inferiors to stop iterating and return
1584 the current inferior_list_entry. Returning zero indicates that
1585 find_inferiors should continue iterating. */
1588 iterate_over_lwps_filter (struct inferior_list_entry *entry, void *args_p)
1590 struct iterate_over_lwps_args *args
1591 = (struct iterate_over_lwps_args *) args_p;
1593 if (ptid_match (entry->id, args->filter))
1595 struct thread_info *thr = (struct thread_info *) entry;
1596 struct lwp_info *lwp = get_thread_lwp (thr);
1598 return (*args->callback) (lwp, args->data);
1604 /* See nat/linux-nat.h. */
1607 iterate_over_lwps (ptid_t filter,
1608 iterate_over_lwps_ftype callback,
1611 struct iterate_over_lwps_args args = {filter, callback, data};
1612 struct inferior_list_entry *entry;
1614 entry = find_inferior (&all_threads, iterate_over_lwps_filter, &args);
1618 return get_thread_lwp ((struct thread_info *) entry);
1621 /* Detect zombie thread group leaders, and "exit" them. We can't reap
1622 their exits until all other threads in the group have exited. */
1625 check_zombie_leaders (void)
1627 struct process_info *proc, *tmp;
1629 ALL_PROCESSES (proc, tmp)
1631 pid_t leader_pid = pid_of (proc);
1632 struct lwp_info *leader_lp;
1634 leader_lp = find_lwp_pid (pid_to_ptid (leader_pid));
1637 debug_printf ("leader_pid=%d, leader_lp!=NULL=%d, "
1638 "num_lwps=%d, zombie=%d\n",
1639 leader_pid, leader_lp!= NULL, num_lwps (leader_pid),
1640 linux_proc_pid_is_zombie (leader_pid));
1642 if (leader_lp != NULL
1643 /* Check if there are other threads in the group, as we may
1644 have raced with the inferior simply exiting. */
1645 && !last_thread_of_process_p (leader_pid)
1646 && linux_proc_pid_is_zombie (leader_pid))
1648 /* A leader zombie can mean one of two things:
1650 - It exited, and there's an exit status pending
1651 available, or only the leader exited (not the whole
1652 program). In the latter case, we can't waitpid the
1653 leader's exit status until all other threads are gone.
1655 - There are 3 or more threads in the group, and a thread
1656 other than the leader exec'd. On an exec, the Linux
1657 kernel destroys all other threads (except the execing
1658 one) in the thread group, and resets the execing thread's
1659 tid to the tgid. No exit notification is sent for the
1660 execing thread -- from the ptracer's perspective, it
1661 appears as though the execing thread just vanishes.
1662 Until we reap all other threads except the leader and the
1663 execing thread, the leader will be zombie, and the
1664 execing thread will be in `D (disc sleep)'. As soon as
1665 all other threads are reaped, the execing thread changes
1666 it's tid to the tgid, and the previous (zombie) leader
1667 vanishes, giving place to the "new" leader. We could try
1668 distinguishing the exit and exec cases, by waiting once
1669 more, and seeing if something comes out, but it doesn't
1670 sound useful. The previous leader _does_ go away, and
1671 we'll re-add the new one once we see the exec event
1672 (which is just the same as what would happen if the
1673 previous leader did exit voluntarily before some other
1678 "CZL: Thread group leader %d zombie "
1679 "(it exited, or another thread execd).\n",
1682 delete_lwp (leader_lp);
1687 /* Callback for `find_inferior'. Returns the first LWP that is not
1688 stopped. ARG is a PTID filter. */
1691 not_stopped_callback (struct inferior_list_entry *entry, void *arg)
1693 struct thread_info *thr = (struct thread_info *) entry;
1694 struct lwp_info *lwp;
1695 ptid_t filter = *(ptid_t *) arg;
1697 if (!ptid_match (ptid_of (thr), filter))
1700 lwp = get_thread_lwp (thr);
1707 /* Increment LWP's suspend count. */
1710 lwp_suspended_inc (struct lwp_info *lwp)
1714 if (debug_threads && lwp->suspended > 4)
1716 struct thread_info *thread = get_lwp_thread (lwp);
1718 debug_printf ("LWP %ld has a suspiciously high suspend count,"
1719 " suspended=%d\n", lwpid_of (thread), lwp->suspended);
1723 /* Decrement LWP's suspend count. */
1726 lwp_suspended_decr (struct lwp_info *lwp)
1730 if (lwp->suspended < 0)
1732 struct thread_info *thread = get_lwp_thread (lwp);
1734 internal_error (__FILE__, __LINE__,
1735 "unsuspend LWP %ld, suspended=%d\n", lwpid_of (thread),
1740 /* This function should only be called if the LWP got a SIGTRAP.
1742 Handle any tracepoint steps or hits. Return true if a tracepoint
1743 event was handled, 0 otherwise. */
1746 handle_tracepoints (struct lwp_info *lwp)
1748 struct thread_info *tinfo = get_lwp_thread (lwp);
1749 int tpoint_related_event = 0;
1751 gdb_assert (lwp->suspended == 0);
1753 /* If this tracepoint hit causes a tracing stop, we'll immediately
1754 uninsert tracepoints. To do this, we temporarily pause all
1755 threads, unpatch away, and then unpause threads. We need to make
1756 sure the unpausing doesn't resume LWP too. */
1757 lwp_suspended_inc (lwp);
1759 /* And we need to be sure that any all-threads-stopping doesn't try
1760 to move threads out of the jump pads, as it could deadlock the
1761 inferior (LWP could be in the jump pad, maybe even holding the
1764 /* Do any necessary step collect actions. */
1765 tpoint_related_event |= tracepoint_finished_step (tinfo, lwp->stop_pc);
1767 tpoint_related_event |= handle_tracepoint_bkpts (tinfo, lwp->stop_pc);
1769 /* See if we just hit a tracepoint and do its main collect
1771 tpoint_related_event |= tracepoint_was_hit (tinfo, lwp->stop_pc);
1773 lwp_suspended_decr (lwp);
1775 gdb_assert (lwp->suspended == 0);
1776 gdb_assert (!stabilizing_threads || lwp->collecting_fast_tracepoint);
1778 if (tpoint_related_event)
1781 debug_printf ("got a tracepoint event\n");
1788 /* Convenience wrapper. Returns true if LWP is presently collecting a
1792 linux_fast_tracepoint_collecting (struct lwp_info *lwp,
1793 struct fast_tpoint_collect_status *status)
1795 CORE_ADDR thread_area;
1796 struct thread_info *thread = get_lwp_thread (lwp);
1798 if (the_low_target.get_thread_area == NULL)
1801 /* Get the thread area address. This is used to recognize which
1802 thread is which when tracing with the in-process agent library.
1803 We don't read anything from the address, and treat it as opaque;
1804 it's the address itself that we assume is unique per-thread. */
1805 if ((*the_low_target.get_thread_area) (lwpid_of (thread), &thread_area) == -1)
1808 return fast_tracepoint_collecting (thread_area, lwp->stop_pc, status);
1811 /* The reason we resume in the caller, is because we want to be able
1812 to pass lwp->status_pending as WSTAT, and we need to clear
1813 status_pending_p before resuming, otherwise, linux_resume_one_lwp
1814 refuses to resume. */
1817 maybe_move_out_of_jump_pad (struct lwp_info *lwp, int *wstat)
1819 struct thread_info *saved_thread;
1821 saved_thread = current_thread;
1822 current_thread = get_lwp_thread (lwp);
1825 || (WIFSTOPPED (*wstat) && WSTOPSIG (*wstat) != SIGTRAP))
1826 && supports_fast_tracepoints ()
1827 && agent_loaded_p ())
1829 struct fast_tpoint_collect_status status;
1833 debug_printf ("Checking whether LWP %ld needs to move out of the "
1835 lwpid_of (current_thread));
1837 r = linux_fast_tracepoint_collecting (lwp, &status);
1840 || (WSTOPSIG (*wstat) != SIGILL
1841 && WSTOPSIG (*wstat) != SIGFPE
1842 && WSTOPSIG (*wstat) != SIGSEGV
1843 && WSTOPSIG (*wstat) != SIGBUS))
1845 lwp->collecting_fast_tracepoint = r;
1849 if (r == 1 && lwp->exit_jump_pad_bkpt == NULL)
1851 /* Haven't executed the original instruction yet.
1852 Set breakpoint there, and wait till it's hit,
1853 then single-step until exiting the jump pad. */
1854 lwp->exit_jump_pad_bkpt
1855 = set_breakpoint_at (status.adjusted_insn_addr, NULL);
1859 debug_printf ("Checking whether LWP %ld needs to move out of "
1860 "the jump pad...it does\n",
1861 lwpid_of (current_thread));
1862 current_thread = saved_thread;
1869 /* If we get a synchronous signal while collecting, *and*
1870 while executing the (relocated) original instruction,
1871 reset the PC to point at the tpoint address, before
1872 reporting to GDB. Otherwise, it's an IPA lib bug: just
1873 report the signal to GDB, and pray for the best. */
1875 lwp->collecting_fast_tracepoint = 0;
1878 && (status.adjusted_insn_addr <= lwp->stop_pc
1879 && lwp->stop_pc < status.adjusted_insn_addr_end))
1882 struct regcache *regcache;
1884 /* The si_addr on a few signals references the address
1885 of the faulting instruction. Adjust that as
1887 if ((WSTOPSIG (*wstat) == SIGILL
1888 || WSTOPSIG (*wstat) == SIGFPE
1889 || WSTOPSIG (*wstat) == SIGBUS
1890 || WSTOPSIG (*wstat) == SIGSEGV)
1891 && ptrace (PTRACE_GETSIGINFO, lwpid_of (current_thread),
1892 (PTRACE_TYPE_ARG3) 0, &info) == 0
1893 /* Final check just to make sure we don't clobber
1894 the siginfo of non-kernel-sent signals. */
1895 && (uintptr_t) info.si_addr == lwp->stop_pc)
1897 info.si_addr = (void *) (uintptr_t) status.tpoint_addr;
1898 ptrace (PTRACE_SETSIGINFO, lwpid_of (current_thread),
1899 (PTRACE_TYPE_ARG3) 0, &info);
1902 regcache = get_thread_regcache (current_thread, 1);
1903 (*the_low_target.set_pc) (regcache, status.tpoint_addr);
1904 lwp->stop_pc = status.tpoint_addr;
1906 /* Cancel any fast tracepoint lock this thread was
1908 force_unlock_trace_buffer ();
1911 if (lwp->exit_jump_pad_bkpt != NULL)
1914 debug_printf ("Cancelling fast exit-jump-pad: removing bkpt. "
1915 "stopping all threads momentarily.\n");
1917 stop_all_lwps (1, lwp);
1919 delete_breakpoint (lwp->exit_jump_pad_bkpt);
1920 lwp->exit_jump_pad_bkpt = NULL;
1922 unstop_all_lwps (1, lwp);
1924 gdb_assert (lwp->suspended >= 0);
1930 debug_printf ("Checking whether LWP %ld needs to move out of the "
1932 lwpid_of (current_thread));
1934 current_thread = saved_thread;
1938 /* Enqueue one signal in the "signals to report later when out of the
1942 enqueue_one_deferred_signal (struct lwp_info *lwp, int *wstat)
1944 struct pending_signals *p_sig;
1945 struct thread_info *thread = get_lwp_thread (lwp);
1948 debug_printf ("Deferring signal %d for LWP %ld.\n",
1949 WSTOPSIG (*wstat), lwpid_of (thread));
1953 struct pending_signals *sig;
1955 for (sig = lwp->pending_signals_to_report;
1958 debug_printf (" Already queued %d\n",
1961 debug_printf (" (no more currently queued signals)\n");
1964 /* Don't enqueue non-RT signals if they are already in the deferred
1965 queue. (SIGSTOP being the easiest signal to see ending up here
1967 if (WSTOPSIG (*wstat) < __SIGRTMIN)
1969 struct pending_signals *sig;
1971 for (sig = lwp->pending_signals_to_report;
1975 if (sig->signal == WSTOPSIG (*wstat))
1978 debug_printf ("Not requeuing already queued non-RT signal %d"
1987 p_sig = XCNEW (struct pending_signals);
1988 p_sig->prev = lwp->pending_signals_to_report;
1989 p_sig->signal = WSTOPSIG (*wstat);
1991 ptrace (PTRACE_GETSIGINFO, lwpid_of (thread), (PTRACE_TYPE_ARG3) 0,
1994 lwp->pending_signals_to_report = p_sig;
1997 /* Dequeue one signal from the "signals to report later when out of
1998 the jump pad" list. */
2001 dequeue_one_deferred_signal (struct lwp_info *lwp, int *wstat)
2003 struct thread_info *thread = get_lwp_thread (lwp);
2005 if (lwp->pending_signals_to_report != NULL)
2007 struct pending_signals **p_sig;
2009 p_sig = &lwp->pending_signals_to_report;
2010 while ((*p_sig)->prev != NULL)
2011 p_sig = &(*p_sig)->prev;
2013 *wstat = W_STOPCODE ((*p_sig)->signal);
2014 if ((*p_sig)->info.si_signo != 0)
2015 ptrace (PTRACE_SETSIGINFO, lwpid_of (thread), (PTRACE_TYPE_ARG3) 0,
2021 debug_printf ("Reporting deferred signal %d for LWP %ld.\n",
2022 WSTOPSIG (*wstat), lwpid_of (thread));
2026 struct pending_signals *sig;
2028 for (sig = lwp->pending_signals_to_report;
2031 debug_printf (" Still queued %d\n",
2034 debug_printf (" (no more queued signals)\n");
2043 /* Fetch the possibly triggered data watchpoint info and store it in
2046 On some archs, like x86, that use debug registers to set
2047 watchpoints, it's possible that the way to know which watched
2048 address trapped, is to check the register that is used to select
2049 which address to watch. Problem is, between setting the watchpoint
2050 and reading back which data address trapped, the user may change
2051 the set of watchpoints, and, as a consequence, GDB changes the
2052 debug registers in the inferior. To avoid reading back a stale
2053 stopped-data-address when that happens, we cache in LP the fact
2054 that a watchpoint trapped, and the corresponding data address, as
2055 soon as we see CHILD stop with a SIGTRAP. If GDB changes the debug
2056 registers meanwhile, we have the cached data we can rely on. */
2059 check_stopped_by_watchpoint (struct lwp_info *child)
2061 if (the_low_target.stopped_by_watchpoint != NULL)
2063 struct thread_info *saved_thread;
2065 saved_thread = current_thread;
2066 current_thread = get_lwp_thread (child);
2068 if (the_low_target.stopped_by_watchpoint ())
2070 child->stop_reason = TARGET_STOPPED_BY_WATCHPOINT;
2072 if (the_low_target.stopped_data_address != NULL)
2073 child->stopped_data_address
2074 = the_low_target.stopped_data_address ();
2076 child->stopped_data_address = 0;
2079 current_thread = saved_thread;
2082 return child->stop_reason == TARGET_STOPPED_BY_WATCHPOINT;
2085 /* Return the ptrace options that we want to try to enable. */
2088 linux_low_ptrace_options (int attached)
2093 options |= PTRACE_O_EXITKILL;
2095 if (report_fork_events)
2096 options |= PTRACE_O_TRACEFORK;
2098 if (report_vfork_events)
2099 options |= (PTRACE_O_TRACEVFORK | PTRACE_O_TRACEVFORKDONE);
2104 /* Do low-level handling of the event, and check if we should go on
2105 and pass it to caller code. Return the affected lwp if we are, or
2108 static struct lwp_info *
2109 linux_low_filter_event (int lwpid, int wstat)
2111 struct lwp_info *child;
2112 struct thread_info *thread;
2113 int have_stop_pc = 0;
2115 child = find_lwp_pid (pid_to_ptid (lwpid));
2117 /* If we didn't find a process, one of two things presumably happened:
2118 - A process we started and then detached from has exited. Ignore it.
2119 - A process we are controlling has forked and the new child's stop
2120 was reported to us by the kernel. Save its PID. */
2121 if (child == NULL && WIFSTOPPED (wstat))
2123 add_to_pid_list (&stopped_pids, lwpid, wstat);
2126 else if (child == NULL)
2129 thread = get_lwp_thread (child);
2133 child->last_status = wstat;
2135 /* Check if the thread has exited. */
2136 if ((WIFEXITED (wstat) || WIFSIGNALED (wstat)))
2139 debug_printf ("LLFE: %d exited.\n", lwpid);
2140 if (num_lwps (pid_of (thread)) > 1)
2143 /* If there is at least one more LWP, then the exit signal was
2144 not the end of the debugged application and should be
2151 /* This was the last lwp in the process. Since events are
2152 serialized to GDB core, and we can't report this one
2153 right now, but GDB core and the other target layers will
2154 want to be notified about the exit code/signal, leave the
2155 status pending for the next time we're able to report
2157 mark_lwp_dead (child, wstat);
2162 gdb_assert (WIFSTOPPED (wstat));
2164 if (WIFSTOPPED (wstat))
2166 struct process_info *proc;
2168 /* Architecture-specific setup after inferior is running. */
2169 proc = find_process_pid (pid_of (thread));
2170 if (proc->tdesc == NULL)
2174 struct thread_info *saved_thread;
2176 /* This needs to happen after we have attached to the
2177 inferior and it is stopped for the first time, but
2178 before we access any inferior registers. */
2179 saved_thread = current_thread;
2180 current_thread = thread;
2182 the_low_target.arch_setup ();
2184 current_thread = saved_thread;
2188 /* The process is started, but GDBserver will do
2189 architecture-specific setup after the program stops at
2190 the first instruction. */
2191 child->status_pending_p = 1;
2192 child->status_pending = wstat;
2198 if (WIFSTOPPED (wstat) && child->must_set_ptrace_flags)
2200 struct process_info *proc = find_process_pid (pid_of (thread));
2201 int options = linux_low_ptrace_options (proc->attached);
2203 linux_enable_event_reporting (lwpid, options);
2204 child->must_set_ptrace_flags = 0;
2207 /* Be careful to not overwrite stop_pc until
2208 check_stopped_by_breakpoint is called. */
2209 if (WIFSTOPPED (wstat) && WSTOPSIG (wstat) == SIGTRAP
2210 && linux_is_extended_waitstatus (wstat))
2212 child->stop_pc = get_pc (child);
2213 if (handle_extended_wait (child, wstat))
2215 /* The event has been handled, so just return without
2221 /* Check first whether this was a SW/HW breakpoint before checking
2222 watchpoints, because at least s390 can't tell the data address of
2223 hardware watchpoint hits, and returns stopped-by-watchpoint as
2224 long as there's a watchpoint set. */
2225 if (WIFSTOPPED (wstat) && linux_wstatus_maybe_breakpoint (wstat))
2227 if (check_stopped_by_breakpoint (child))
2231 /* Note that TRAP_HWBKPT can indicate either a hardware breakpoint
2232 or hardware watchpoint. Check which is which if we got
2233 TARGET_STOPPED_BY_HW_BREAKPOINT. Likewise, we may have single
2234 stepped an instruction that triggered a watchpoint. In that
2235 case, on some architectures (such as x86), instead of
2236 TRAP_HWBKPT, si_code indicates TRAP_TRACE, and we need to check
2237 the debug registers separately. */
2238 if (WIFSTOPPED (wstat) && WSTOPSIG (wstat) == SIGTRAP
2239 && child->stop_reason != TARGET_STOPPED_BY_SW_BREAKPOINT)
2240 check_stopped_by_watchpoint (child);
2243 child->stop_pc = get_pc (child);
2245 if (WIFSTOPPED (wstat) && WSTOPSIG (wstat) == SIGSTOP
2246 && child->stop_expected)
2249 debug_printf ("Expected stop.\n");
2250 child->stop_expected = 0;
2252 if (thread->last_resume_kind == resume_stop)
2254 /* We want to report the stop to the core. Treat the
2255 SIGSTOP as a normal event. */
2257 debug_printf ("LLW: resume_stop SIGSTOP caught for %s.\n",
2258 target_pid_to_str (ptid_of (thread)));
2260 else if (stopping_threads != NOT_STOPPING_THREADS)
2262 /* Stopping threads. We don't want this SIGSTOP to end up
2265 debug_printf ("LLW: SIGSTOP caught for %s "
2266 "while stopping threads.\n",
2267 target_pid_to_str (ptid_of (thread)));
2272 /* This is a delayed SIGSTOP. Filter out the event. */
2274 debug_printf ("LLW: %s %s, 0, 0 (discard delayed SIGSTOP)\n",
2275 child->stepping ? "step" : "continue",
2276 target_pid_to_str (ptid_of (thread)));
2278 linux_resume_one_lwp (child, child->stepping, 0, NULL);
2283 child->status_pending_p = 1;
2284 child->status_pending = wstat;
2288 /* Resume LWPs that are currently stopped without any pending status
2289 to report, but are resumed from the core's perspective. */
2292 resume_stopped_resumed_lwps (struct inferior_list_entry *entry)
2294 struct thread_info *thread = (struct thread_info *) entry;
2295 struct lwp_info *lp = get_thread_lwp (thread);
2299 && !lp->status_pending_p
2300 && thread->last_resume_kind != resume_stop
2301 && thread->last_status.kind == TARGET_WAITKIND_IGNORE)
2303 int step = thread->last_resume_kind == resume_step;
2306 debug_printf ("RSRL: resuming stopped-resumed LWP %s at %s: step=%d\n",
2307 target_pid_to_str (ptid_of (thread)),
2308 paddress (lp->stop_pc),
2311 linux_resume_one_lwp (lp, step, GDB_SIGNAL_0, NULL);
2315 /* Wait for an event from child(ren) WAIT_PTID, and return any that
2316 match FILTER_PTID (leaving others pending). The PTIDs can be:
2317 minus_one_ptid, to specify any child; a pid PTID, specifying all
2318 lwps of a thread group; or a PTID representing a single lwp. Store
2319 the stop status through the status pointer WSTAT. OPTIONS is
2320 passed to the waitpid call. Return 0 if no event was found and
2321 OPTIONS contains WNOHANG. Return -1 if no unwaited-for children
2322 was found. Return the PID of the stopped child otherwise. */
2325 linux_wait_for_event_filtered (ptid_t wait_ptid, ptid_t filter_ptid,
2326 int *wstatp, int options)
2328 struct thread_info *event_thread;
2329 struct lwp_info *event_child, *requested_child;
2330 sigset_t block_mask, prev_mask;
2333 /* N.B. event_thread points to the thread_info struct that contains
2334 event_child. Keep them in sync. */
2335 event_thread = NULL;
2337 requested_child = NULL;
2339 /* Check for a lwp with a pending status. */
2341 if (ptid_equal (filter_ptid, minus_one_ptid) || ptid_is_pid (filter_ptid))
2343 event_thread = (struct thread_info *)
2344 find_inferior (&all_threads, status_pending_p_callback, &filter_ptid);
2345 if (event_thread != NULL)
2346 event_child = get_thread_lwp (event_thread);
2347 if (debug_threads && event_thread)
2348 debug_printf ("Got a pending child %ld\n", lwpid_of (event_thread));
2350 else if (!ptid_equal (filter_ptid, null_ptid))
2352 requested_child = find_lwp_pid (filter_ptid);
2354 if (stopping_threads == NOT_STOPPING_THREADS
2355 && requested_child->status_pending_p
2356 && requested_child->collecting_fast_tracepoint)
2358 enqueue_one_deferred_signal (requested_child,
2359 &requested_child->status_pending);
2360 requested_child->status_pending_p = 0;
2361 requested_child->status_pending = 0;
2362 linux_resume_one_lwp (requested_child, 0, 0, NULL);
2365 if (requested_child->suspended
2366 && requested_child->status_pending_p)
2368 internal_error (__FILE__, __LINE__,
2369 "requesting an event out of a"
2370 " suspended child?");
2373 if (requested_child->status_pending_p)
2375 event_child = requested_child;
2376 event_thread = get_lwp_thread (event_child);
2380 if (event_child != NULL)
2383 debug_printf ("Got an event from pending child %ld (%04x)\n",
2384 lwpid_of (event_thread), event_child->status_pending);
2385 *wstatp = event_child->status_pending;
2386 event_child->status_pending_p = 0;
2387 event_child->status_pending = 0;
2388 current_thread = event_thread;
2389 return lwpid_of (event_thread);
2392 /* But if we don't find a pending event, we'll have to wait.
2394 We only enter this loop if no process has a pending wait status.
2395 Thus any action taken in response to a wait status inside this
2396 loop is responding as soon as we detect the status, not after any
2399 /* Make sure SIGCHLD is blocked until the sigsuspend below. Block
2400 all signals while here. */
2401 sigfillset (&block_mask);
2402 sigprocmask (SIG_BLOCK, &block_mask, &prev_mask);
2404 /* Always pull all events out of the kernel. We'll randomly select
2405 an event LWP out of all that have events, to prevent
2407 while (event_child == NULL)
2411 /* Always use -1 and WNOHANG, due to couple of a kernel/ptrace
2414 - If the thread group leader exits while other threads in the
2415 thread group still exist, waitpid(TGID, ...) hangs. That
2416 waitpid won't return an exit status until the other threads
2417 in the group are reaped.
2419 - When a non-leader thread execs, that thread just vanishes
2420 without reporting an exit (so we'd hang if we waited for it
2421 explicitly in that case). The exec event is reported to
2422 the TGID pid (although we don't currently enable exec
2425 ret = my_waitpid (-1, wstatp, options | WNOHANG);
2428 debug_printf ("LWFE: waitpid(-1, ...) returned %d, %s\n",
2429 ret, errno ? strerror (errno) : "ERRNO-OK");
2435 debug_printf ("LLW: waitpid %ld received %s\n",
2436 (long) ret, status_to_str (*wstatp));
2439 /* Filter all events. IOW, leave all events pending. We'll
2440 randomly select an event LWP out of all that have events
2442 linux_low_filter_event (ret, *wstatp);
2443 /* Retry until nothing comes out of waitpid. A single
2444 SIGCHLD can indicate more than one child stopped. */
2448 /* Now that we've pulled all events out of the kernel, resume
2449 LWPs that don't have an interesting event to report. */
2450 if (stopping_threads == NOT_STOPPING_THREADS)
2451 for_each_inferior (&all_threads, resume_stopped_resumed_lwps);
2453 /* ... and find an LWP with a status to report to the core, if
2455 event_thread = (struct thread_info *)
2456 find_inferior (&all_threads, status_pending_p_callback, &filter_ptid);
2457 if (event_thread != NULL)
2459 event_child = get_thread_lwp (event_thread);
2460 *wstatp = event_child->status_pending;
2461 event_child->status_pending_p = 0;
2462 event_child->status_pending = 0;
2466 /* Check for zombie thread group leaders. Those can't be reaped
2467 until all other threads in the thread group are. */
2468 check_zombie_leaders ();
2470 /* If there are no resumed children left in the set of LWPs we
2471 want to wait for, bail. We can't just block in
2472 waitpid/sigsuspend, because lwps might have been left stopped
2473 in trace-stop state, and we'd be stuck forever waiting for
2474 their status to change (which would only happen if we resumed
2475 them). Even if WNOHANG is set, this return code is preferred
2476 over 0 (below), as it is more detailed. */
2477 if ((find_inferior (&all_threads,
2478 not_stopped_callback,
2479 &wait_ptid) == NULL))
2482 debug_printf ("LLW: exit (no unwaited-for LWP)\n");
2483 sigprocmask (SIG_SETMASK, &prev_mask, NULL);
2487 /* No interesting event to report to the caller. */
2488 if ((options & WNOHANG))
2491 debug_printf ("WNOHANG set, no event found\n");
2493 sigprocmask (SIG_SETMASK, &prev_mask, NULL);
2497 /* Block until we get an event reported with SIGCHLD. */
2499 debug_printf ("sigsuspend'ing\n");
2501 sigsuspend (&prev_mask);
2502 sigprocmask (SIG_SETMASK, &prev_mask, NULL);
2506 sigprocmask (SIG_SETMASK, &prev_mask, NULL);
2508 current_thread = event_thread;
2510 /* Check for thread exit. */
2511 if (! WIFSTOPPED (*wstatp))
2513 gdb_assert (last_thread_of_process_p (pid_of (event_thread)));
2516 debug_printf ("LWP %d is the last lwp of process. "
2517 "Process %ld exiting.\n",
2518 pid_of (event_thread), lwpid_of (event_thread));
2519 return lwpid_of (event_thread);
2522 return lwpid_of (event_thread);
2525 /* Wait for an event from child(ren) PTID. PTIDs can be:
2526 minus_one_ptid, to specify any child; a pid PTID, specifying all
2527 lwps of a thread group; or a PTID representing a single lwp. Store
2528 the stop status through the status pointer WSTAT. OPTIONS is
2529 passed to the waitpid call. Return 0 if no event was found and
2530 OPTIONS contains WNOHANG. Return -1 if no unwaited-for children
2531 was found. Return the PID of the stopped child otherwise. */
2534 linux_wait_for_event (ptid_t ptid, int *wstatp, int options)
2536 return linux_wait_for_event_filtered (ptid, ptid, wstatp, options);
2539 /* Count the LWP's that have had events. */
2542 count_events_callback (struct inferior_list_entry *entry, void *data)
2544 struct thread_info *thread = (struct thread_info *) entry;
2545 struct lwp_info *lp = get_thread_lwp (thread);
2548 gdb_assert (count != NULL);
2550 /* Count only resumed LWPs that have an event pending. */
2551 if (thread->last_status.kind == TARGET_WAITKIND_IGNORE
2552 && lp->status_pending_p)
2558 /* Select the LWP (if any) that is currently being single-stepped. */
2561 select_singlestep_lwp_callback (struct inferior_list_entry *entry, void *data)
2563 struct thread_info *thread = (struct thread_info *) entry;
2564 struct lwp_info *lp = get_thread_lwp (thread);
2566 if (thread->last_status.kind == TARGET_WAITKIND_IGNORE
2567 && thread->last_resume_kind == resume_step
2568 && lp->status_pending_p)
2574 /* Select the Nth LWP that has had an event. */
2577 select_event_lwp_callback (struct inferior_list_entry *entry, void *data)
2579 struct thread_info *thread = (struct thread_info *) entry;
2580 struct lwp_info *lp = get_thread_lwp (thread);
2581 int *selector = data;
2583 gdb_assert (selector != NULL);
2585 /* Select only resumed LWPs that have an event pending. */
2586 if (thread->last_status.kind == TARGET_WAITKIND_IGNORE
2587 && lp->status_pending_p)
2588 if ((*selector)-- == 0)
2594 /* Select one LWP out of those that have events pending. */
2597 select_event_lwp (struct lwp_info **orig_lp)
2600 int random_selector;
2601 struct thread_info *event_thread = NULL;
2603 /* In all-stop, give preference to the LWP that is being
2604 single-stepped. There will be at most one, and it's the LWP that
2605 the core is most interested in. If we didn't do this, then we'd
2606 have to handle pending step SIGTRAPs somehow in case the core
2607 later continues the previously-stepped thread, otherwise we'd
2608 report the pending SIGTRAP, and the core, not having stepped the
2609 thread, wouldn't understand what the trap was for, and therefore
2610 would report it to the user as a random signal. */
2614 = (struct thread_info *) find_inferior (&all_threads,
2615 select_singlestep_lwp_callback,
2617 if (event_thread != NULL)
2620 debug_printf ("SEL: Select single-step %s\n",
2621 target_pid_to_str (ptid_of (event_thread)));
2624 if (event_thread == NULL)
2626 /* No single-stepping LWP. Select one at random, out of those
2627 which have had events. */
2629 /* First see how many events we have. */
2630 find_inferior (&all_threads, count_events_callback, &num_events);
2631 gdb_assert (num_events > 0);
2633 /* Now randomly pick a LWP out of those that have had
2635 random_selector = (int)
2636 ((num_events * (double) rand ()) / (RAND_MAX + 1.0));
2638 if (debug_threads && num_events > 1)
2639 debug_printf ("SEL: Found %d SIGTRAP events, selecting #%d\n",
2640 num_events, random_selector);
2643 = (struct thread_info *) find_inferior (&all_threads,
2644 select_event_lwp_callback,
2648 if (event_thread != NULL)
2650 struct lwp_info *event_lp = get_thread_lwp (event_thread);
2652 /* Switch the event LWP. */
2653 *orig_lp = event_lp;
2657 /* Decrement the suspend count of an LWP. */
2660 unsuspend_one_lwp (struct inferior_list_entry *entry, void *except)
2662 struct thread_info *thread = (struct thread_info *) entry;
2663 struct lwp_info *lwp = get_thread_lwp (thread);
2665 /* Ignore EXCEPT. */
2669 lwp_suspended_decr (lwp);
2673 /* Decrement the suspend count of all LWPs, except EXCEPT, if non
2677 unsuspend_all_lwps (struct lwp_info *except)
2679 find_inferior (&all_threads, unsuspend_one_lwp, except);
2682 static void move_out_of_jump_pad_callback (struct inferior_list_entry *entry);
2683 static int stuck_in_jump_pad_callback (struct inferior_list_entry *entry,
2685 static int lwp_running (struct inferior_list_entry *entry, void *data);
2686 static ptid_t linux_wait_1 (ptid_t ptid,
2687 struct target_waitstatus *ourstatus,
2688 int target_options);
2690 /* Stabilize threads (move out of jump pads).
2692 If a thread is midway collecting a fast tracepoint, we need to
2693 finish the collection and move it out of the jump pad before
2694 reporting the signal.
2696 This avoids recursion while collecting (when a signal arrives
2697 midway, and the signal handler itself collects), which would trash
2698 the trace buffer. In case the user set a breakpoint in a signal
2699 handler, this avoids the backtrace showing the jump pad, etc..
2700 Most importantly, there are certain things we can't do safely if
2701 threads are stopped in a jump pad (or in its callee's). For
2704 - starting a new trace run. A thread still collecting the
2705 previous run, could trash the trace buffer when resumed. The trace
2706 buffer control structures would have been reset but the thread had
2707 no way to tell. The thread could even midway memcpy'ing to the
2708 buffer, which would mean that when resumed, it would clobber the
2709 trace buffer that had been set for a new run.
2711 - we can't rewrite/reuse the jump pads for new tracepoints
2712 safely. Say you do tstart while a thread is stopped midway while
2713 collecting. When the thread is later resumed, it finishes the
2714 collection, and returns to the jump pad, to execute the original
2715 instruction that was under the tracepoint jump at the time the
2716 older run had been started. If the jump pad had been rewritten
2717 since for something else in the new run, the thread would now
2718 execute the wrong / random instructions. */
2721 linux_stabilize_threads (void)
2723 struct thread_info *saved_thread;
2724 struct thread_info *thread_stuck;
2727 = (struct thread_info *) find_inferior (&all_threads,
2728 stuck_in_jump_pad_callback,
2730 if (thread_stuck != NULL)
2733 debug_printf ("can't stabilize, LWP %ld is stuck in jump pad\n",
2734 lwpid_of (thread_stuck));
2738 saved_thread = current_thread;
2740 stabilizing_threads = 1;
2743 for_each_inferior (&all_threads, move_out_of_jump_pad_callback);
2745 /* Loop until all are stopped out of the jump pads. */
2746 while (find_inferior (&all_threads, lwp_running, NULL) != NULL)
2748 struct target_waitstatus ourstatus;
2749 struct lwp_info *lwp;
2752 /* Note that we go through the full wait even loop. While
2753 moving threads out of jump pad, we need to be able to step
2754 over internal breakpoints and such. */
2755 linux_wait_1 (minus_one_ptid, &ourstatus, 0);
2757 if (ourstatus.kind == TARGET_WAITKIND_STOPPED)
2759 lwp = get_thread_lwp (current_thread);
2762 lwp_suspended_inc (lwp);
2764 if (ourstatus.value.sig != GDB_SIGNAL_0
2765 || current_thread->last_resume_kind == resume_stop)
2767 wstat = W_STOPCODE (gdb_signal_to_host (ourstatus.value.sig));
2768 enqueue_one_deferred_signal (lwp, &wstat);
2773 find_inferior (&all_threads, unsuspend_one_lwp, NULL);
2775 stabilizing_threads = 0;
2777 current_thread = saved_thread;
2782 = (struct thread_info *) find_inferior (&all_threads,
2783 stuck_in_jump_pad_callback,
2785 if (thread_stuck != NULL)
2786 debug_printf ("couldn't stabilize, LWP %ld got stuck in jump pad\n",
2787 lwpid_of (thread_stuck));
2791 static void async_file_mark (void);
2793 /* Convenience function that is called when the kernel reports an
2794 event that is not passed out to GDB. */
2797 ignore_event (struct target_waitstatus *ourstatus)
2799 /* If we got an event, there may still be others, as a single
2800 SIGCHLD can indicate more than one child stopped. This forces
2801 another target_wait call. */
2804 ourstatus->kind = TARGET_WAITKIND_IGNORE;
2808 /* Wait for process, returns status. */
2811 linux_wait_1 (ptid_t ptid,
2812 struct target_waitstatus *ourstatus, int target_options)
2815 struct lwp_info *event_child;
2818 int step_over_finished;
2819 int bp_explains_trap;
2820 int maybe_internal_trap;
2828 debug_printf ("linux_wait_1: [%s]\n", target_pid_to_str (ptid));
2831 /* Translate generic target options into linux options. */
2833 if (target_options & TARGET_WNOHANG)
2836 bp_explains_trap = 0;
2839 ourstatus->kind = TARGET_WAITKIND_IGNORE;
2841 if (ptid_equal (step_over_bkpt, null_ptid))
2842 pid = linux_wait_for_event (ptid, &w, options);
2846 debug_printf ("step_over_bkpt set [%s], doing a blocking wait\n",
2847 target_pid_to_str (step_over_bkpt));
2848 pid = linux_wait_for_event (step_over_bkpt, &w, options & ~WNOHANG);
2853 gdb_assert (target_options & TARGET_WNOHANG);
2857 debug_printf ("linux_wait_1 ret = null_ptid, "
2858 "TARGET_WAITKIND_IGNORE\n");
2862 ourstatus->kind = TARGET_WAITKIND_IGNORE;
2869 debug_printf ("linux_wait_1 ret = null_ptid, "
2870 "TARGET_WAITKIND_NO_RESUMED\n");
2874 ourstatus->kind = TARGET_WAITKIND_NO_RESUMED;
2878 event_child = get_thread_lwp (current_thread);
2880 /* linux_wait_for_event only returns an exit status for the last
2881 child of a process. Report it. */
2882 if (WIFEXITED (w) || WIFSIGNALED (w))
2886 ourstatus->kind = TARGET_WAITKIND_EXITED;
2887 ourstatus->value.integer = WEXITSTATUS (w);
2891 debug_printf ("linux_wait_1 ret = %s, exited with "
2893 target_pid_to_str (ptid_of (current_thread)),
2900 ourstatus->kind = TARGET_WAITKIND_SIGNALLED;
2901 ourstatus->value.sig = gdb_signal_from_host (WTERMSIG (w));
2905 debug_printf ("linux_wait_1 ret = %s, terminated with "
2907 target_pid_to_str (ptid_of (current_thread)),
2913 return ptid_of (current_thread);
2916 /* If step-over executes a breakpoint instruction, it means a
2917 gdb/gdbserver breakpoint had been planted on top of a permanent
2918 breakpoint. The PC has been adjusted by
2919 check_stopped_by_breakpoint to point at the breakpoint address.
2920 Advance the PC manually past the breakpoint, otherwise the
2921 program would keep trapping the permanent breakpoint forever. */
2922 if (!ptid_equal (step_over_bkpt, null_ptid)
2923 && event_child->stop_reason == TARGET_STOPPED_BY_SW_BREAKPOINT)
2925 unsigned int increment_pc = the_low_target.breakpoint_len;
2929 debug_printf ("step-over for %s executed software breakpoint\n",
2930 target_pid_to_str (ptid_of (current_thread)));
2933 if (increment_pc != 0)
2935 struct regcache *regcache
2936 = get_thread_regcache (current_thread, 1);
2938 event_child->stop_pc += increment_pc;
2939 (*the_low_target.set_pc) (regcache, event_child->stop_pc);
2941 if (!(*the_low_target.breakpoint_at) (event_child->stop_pc))
2942 event_child->stop_reason = TARGET_STOPPED_BY_NO_REASON;
2946 /* If this event was not handled before, and is not a SIGTRAP, we
2947 report it. SIGILL and SIGSEGV are also treated as traps in case
2948 a breakpoint is inserted at the current PC. If this target does
2949 not support internal breakpoints at all, we also report the
2950 SIGTRAP without further processing; it's of no concern to us. */
2952 = (supports_breakpoints ()
2953 && (WSTOPSIG (w) == SIGTRAP
2954 || ((WSTOPSIG (w) == SIGILL
2955 || WSTOPSIG (w) == SIGSEGV)
2956 && (*the_low_target.breakpoint_at) (event_child->stop_pc))));
2958 if (maybe_internal_trap)
2960 /* Handle anything that requires bookkeeping before deciding to
2961 report the event or continue waiting. */
2963 /* First check if we can explain the SIGTRAP with an internal
2964 breakpoint, or if we should possibly report the event to GDB.
2965 Do this before anything that may remove or insert a
2967 bp_explains_trap = breakpoint_inserted_here (event_child->stop_pc);
2969 /* We have a SIGTRAP, possibly a step-over dance has just
2970 finished. If so, tweak the state machine accordingly,
2971 reinsert breakpoints and delete any reinsert (software
2972 single-step) breakpoints. */
2973 step_over_finished = finish_step_over (event_child);
2975 /* Now invoke the callbacks of any internal breakpoints there. */
2976 check_breakpoints (event_child->stop_pc);
2978 /* Handle tracepoint data collecting. This may overflow the
2979 trace buffer, and cause a tracing stop, removing
2981 trace_event = handle_tracepoints (event_child);
2983 if (bp_explains_trap)
2985 /* If we stepped or ran into an internal breakpoint, we've
2986 already handled it. So next time we resume (from this
2987 PC), we should step over it. */
2989 debug_printf ("Hit a gdbserver breakpoint.\n");
2991 if (breakpoint_here (event_child->stop_pc))
2992 event_child->need_step_over = 1;
2997 /* We have some other signal, possibly a step-over dance was in
2998 progress, and it should be cancelled too. */
2999 step_over_finished = finish_step_over (event_child);
3002 /* We have all the data we need. Either report the event to GDB, or
3003 resume threads and keep waiting for more. */
3005 /* If we're collecting a fast tracepoint, finish the collection and
3006 move out of the jump pad before delivering a signal. See
3007 linux_stabilize_threads. */
3010 && WSTOPSIG (w) != SIGTRAP
3011 && supports_fast_tracepoints ()
3012 && agent_loaded_p ())
3015 debug_printf ("Got signal %d for LWP %ld. Check if we need "
3016 "to defer or adjust it.\n",
3017 WSTOPSIG (w), lwpid_of (current_thread));
3019 /* Allow debugging the jump pad itself. */
3020 if (current_thread->last_resume_kind != resume_step
3021 && maybe_move_out_of_jump_pad (event_child, &w))
3023 enqueue_one_deferred_signal (event_child, &w);
3026 debug_printf ("Signal %d for LWP %ld deferred (in jump pad)\n",
3027 WSTOPSIG (w), lwpid_of (current_thread));
3029 linux_resume_one_lwp (event_child, 0, 0, NULL);
3031 return ignore_event (ourstatus);
3035 if (event_child->collecting_fast_tracepoint)
3038 debug_printf ("LWP %ld was trying to move out of the jump pad (%d). "
3039 "Check if we're already there.\n",
3040 lwpid_of (current_thread),
3041 event_child->collecting_fast_tracepoint);
3045 event_child->collecting_fast_tracepoint
3046 = linux_fast_tracepoint_collecting (event_child, NULL);
3048 if (event_child->collecting_fast_tracepoint != 1)
3050 /* No longer need this breakpoint. */
3051 if (event_child->exit_jump_pad_bkpt != NULL)
3054 debug_printf ("No longer need exit-jump-pad bkpt; removing it."
3055 "stopping all threads momentarily.\n");
3057 /* Other running threads could hit this breakpoint.
3058 We don't handle moribund locations like GDB does,
3059 instead we always pause all threads when removing
3060 breakpoints, so that any step-over or
3061 decr_pc_after_break adjustment is always taken
3062 care of while the breakpoint is still
3064 stop_all_lwps (1, event_child);
3066 delete_breakpoint (event_child->exit_jump_pad_bkpt);
3067 event_child->exit_jump_pad_bkpt = NULL;
3069 unstop_all_lwps (1, event_child);
3071 gdb_assert (event_child->suspended >= 0);
3075 if (event_child->collecting_fast_tracepoint == 0)
3078 debug_printf ("fast tracepoint finished "
3079 "collecting successfully.\n");
3081 /* We may have a deferred signal to report. */
3082 if (dequeue_one_deferred_signal (event_child, &w))
3085 debug_printf ("dequeued one signal.\n");
3090 debug_printf ("no deferred signals.\n");
3092 if (stabilizing_threads)
3094 ourstatus->kind = TARGET_WAITKIND_STOPPED;
3095 ourstatus->value.sig = GDB_SIGNAL_0;
3099 debug_printf ("linux_wait_1 ret = %s, stopped "
3100 "while stabilizing threads\n",
3101 target_pid_to_str (ptid_of (current_thread)));
3105 return ptid_of (current_thread);
3111 /* Check whether GDB would be interested in this event. */
3113 /* If GDB is not interested in this signal, don't stop other
3114 threads, and don't report it to GDB. Just resume the inferior
3115 right away. We do this for threading-related signals as well as
3116 any that GDB specifically requested we ignore. But never ignore
3117 SIGSTOP if we sent it ourselves, and do not ignore signals when
3118 stepping - they may require special handling to skip the signal
3119 handler. Also never ignore signals that could be caused by a
3121 /* FIXME drow/2002-06-09: Get signal numbers from the inferior's
3124 && current_thread->last_resume_kind != resume_step
3126 #if defined (USE_THREAD_DB) && !defined (__ANDROID__)
3127 (current_process ()->priv->thread_db != NULL
3128 && (WSTOPSIG (w) == __SIGRTMIN
3129 || WSTOPSIG (w) == __SIGRTMIN + 1))
3132 (pass_signals[gdb_signal_from_host (WSTOPSIG (w))]
3133 && !(WSTOPSIG (w) == SIGSTOP
3134 && current_thread->last_resume_kind == resume_stop)
3135 && !linux_wstatus_maybe_breakpoint (w))))
3137 siginfo_t info, *info_p;
3140 debug_printf ("Ignored signal %d for LWP %ld.\n",
3141 WSTOPSIG (w), lwpid_of (current_thread));
3143 if (ptrace (PTRACE_GETSIGINFO, lwpid_of (current_thread),
3144 (PTRACE_TYPE_ARG3) 0, &info) == 0)
3149 if (step_over_finished)
3151 /* We cancelled this thread's step-over above. We still
3152 need to unsuspend all other LWPs, and set them back
3153 running again while the signal handler runs. */
3154 unsuspend_all_lwps (event_child);
3156 /* Enqueue the pending signal info so that proceed_all_lwps
3158 enqueue_pending_signal (event_child, WSTOPSIG (w), info_p);
3160 proceed_all_lwps ();
3164 linux_resume_one_lwp (event_child, event_child->stepping,
3165 WSTOPSIG (w), info_p);
3167 return ignore_event (ourstatus);
3170 /* Note that all addresses are always "out of the step range" when
3171 there's no range to begin with. */
3172 in_step_range = lwp_in_step_range (event_child);
3174 /* If GDB wanted this thread to single step, and the thread is out
3175 of the step range, we always want to report the SIGTRAP, and let
3176 GDB handle it. Watchpoints should always be reported. So should
3177 signals we can't explain. A SIGTRAP we can't explain could be a
3178 GDB breakpoint --- we may or not support Z0 breakpoints. If we
3179 do, we're be able to handle GDB breakpoints on top of internal
3180 breakpoints, by handling the internal breakpoint and still
3181 reporting the event to GDB. If we don't, we're out of luck, GDB
3182 won't see the breakpoint hit. If we see a single-step event but
3183 the thread should be continuing, don't pass the trap to gdb.
3184 That indicates that we had previously finished a single-step but
3185 left the single-step pending -- see
3186 complete_ongoing_step_over. */
3187 report_to_gdb = (!maybe_internal_trap
3188 || (current_thread->last_resume_kind == resume_step
3190 || event_child->stop_reason == TARGET_STOPPED_BY_WATCHPOINT
3192 && !bp_explains_trap
3194 && !step_over_finished
3195 && !(current_thread->last_resume_kind == resume_continue
3196 && event_child->stop_reason == TARGET_STOPPED_BY_SINGLE_STEP))
3197 || (gdb_breakpoint_here (event_child->stop_pc)
3198 && gdb_condition_true_at_breakpoint (event_child->stop_pc)
3199 && gdb_no_commands_at_breakpoint (event_child->stop_pc))
3200 || event_child->waitstatus.kind != TARGET_WAITKIND_IGNORE);
3202 run_breakpoint_commands (event_child->stop_pc);
3204 /* We found no reason GDB would want us to stop. We either hit one
3205 of our own breakpoints, or finished an internal step GDB
3206 shouldn't know about. */
3211 if (bp_explains_trap)
3212 debug_printf ("Hit a gdbserver breakpoint.\n");
3213 if (step_over_finished)
3214 debug_printf ("Step-over finished.\n");
3216 debug_printf ("Tracepoint event.\n");
3217 if (lwp_in_step_range (event_child))
3218 debug_printf ("Range stepping pc 0x%s [0x%s, 0x%s).\n",
3219 paddress (event_child->stop_pc),
3220 paddress (event_child->step_range_start),
3221 paddress (event_child->step_range_end));
3224 /* We're not reporting this breakpoint to GDB, so apply the
3225 decr_pc_after_break adjustment to the inferior's regcache
3228 if (the_low_target.set_pc != NULL)
3230 struct regcache *regcache
3231 = get_thread_regcache (current_thread, 1);
3232 (*the_low_target.set_pc) (regcache, event_child->stop_pc);
3235 /* We may have finished stepping over a breakpoint. If so,
3236 we've stopped and suspended all LWPs momentarily except the
3237 stepping one. This is where we resume them all again. We're
3238 going to keep waiting, so use proceed, which handles stepping
3239 over the next breakpoint. */
3241 debug_printf ("proceeding all threads.\n");
3243 if (step_over_finished)
3244 unsuspend_all_lwps (event_child);
3246 proceed_all_lwps ();
3247 return ignore_event (ourstatus);
3252 if (event_child->waitstatus.kind != TARGET_WAITKIND_IGNORE)
3256 str = target_waitstatus_to_string (&event_child->waitstatus);
3257 debug_printf ("LWP %ld: extended event with waitstatus %s\n",
3258 lwpid_of (get_lwp_thread (event_child)), str);
3261 if (current_thread->last_resume_kind == resume_step)
3263 if (event_child->step_range_start == event_child->step_range_end)
3264 debug_printf ("GDB wanted to single-step, reporting event.\n");
3265 else if (!lwp_in_step_range (event_child))
3266 debug_printf ("Out of step range, reporting event.\n");
3268 if (event_child->stop_reason == TARGET_STOPPED_BY_WATCHPOINT)
3269 debug_printf ("Stopped by watchpoint.\n");
3270 else if (gdb_breakpoint_here (event_child->stop_pc))
3271 debug_printf ("Stopped by GDB breakpoint.\n");
3273 debug_printf ("Hit a non-gdbserver trap event.\n");
3276 /* Alright, we're going to report a stop. */
3278 if (!stabilizing_threads)
3280 /* In all-stop, stop all threads. */
3282 stop_all_lwps (0, NULL);
3284 /* If we're not waiting for a specific LWP, choose an event LWP
3285 from among those that have had events. Giving equal priority
3286 to all LWPs that have had events helps prevent
3288 if (ptid_equal (ptid, minus_one_ptid))
3290 event_child->status_pending_p = 1;
3291 event_child->status_pending = w;
3293 select_event_lwp (&event_child);
3295 /* current_thread and event_child must stay in sync. */
3296 current_thread = get_lwp_thread (event_child);
3298 event_child->status_pending_p = 0;
3299 w = event_child->status_pending;
3302 if (step_over_finished)
3306 /* If we were doing a step-over, all other threads but
3307 the stepping one had been paused in start_step_over,
3308 with their suspend counts incremented. We don't want
3309 to do a full unstop/unpause, because we're in
3310 all-stop mode (so we want threads stopped), but we
3311 still need to unsuspend the other threads, to
3312 decrement their `suspended' count back. */
3313 unsuspend_all_lwps (event_child);
3317 /* If we just finished a step-over, then all threads had
3318 been momentarily paused. In all-stop, that's fine,
3319 we want threads stopped by now anyway. In non-stop,
3320 we need to re-resume threads that GDB wanted to be
3322 unstop_all_lwps (1, event_child);
3326 /* Stabilize threads (move out of jump pads). */
3328 stabilize_threads ();
3332 /* If we just finished a step-over, then all threads had been
3333 momentarily paused. In all-stop, that's fine, we want
3334 threads stopped by now anyway. In non-stop, we need to
3335 re-resume threads that GDB wanted to be running. */
3336 if (step_over_finished)
3337 unstop_all_lwps (1, event_child);
3340 if (event_child->waitstatus.kind != TARGET_WAITKIND_IGNORE)
3342 /* If the reported event is an exit, fork, vfork or exec, let
3344 *ourstatus = event_child->waitstatus;
3345 /* Clear the event lwp's waitstatus since we handled it already. */
3346 event_child->waitstatus.kind = TARGET_WAITKIND_IGNORE;
3349 ourstatus->kind = TARGET_WAITKIND_STOPPED;
3351 /* Now that we've selected our final event LWP, un-adjust its PC if
3352 it was a software breakpoint, and the client doesn't know we can
3353 adjust the breakpoint ourselves. */
3354 if (event_child->stop_reason == TARGET_STOPPED_BY_SW_BREAKPOINT
3355 && !swbreak_feature)
3357 int decr_pc = the_low_target.decr_pc_after_break;
3361 struct regcache *regcache
3362 = get_thread_regcache (current_thread, 1);
3363 (*the_low_target.set_pc) (regcache, event_child->stop_pc + decr_pc);
3367 if (current_thread->last_resume_kind == resume_stop
3368 && WSTOPSIG (w) == SIGSTOP)
3370 /* A thread that has been requested to stop by GDB with vCont;t,
3371 and it stopped cleanly, so report as SIG0. The use of
3372 SIGSTOP is an implementation detail. */
3373 ourstatus->value.sig = GDB_SIGNAL_0;
3375 else if (current_thread->last_resume_kind == resume_stop
3376 && WSTOPSIG (w) != SIGSTOP)
3378 /* A thread that has been requested to stop by GDB with vCont;t,
3379 but, it stopped for other reasons. */
3380 ourstatus->value.sig = gdb_signal_from_host (WSTOPSIG (w));
3382 else if (ourstatus->kind == TARGET_WAITKIND_STOPPED)
3384 ourstatus->value.sig = gdb_signal_from_host (WSTOPSIG (w));
3387 gdb_assert (ptid_equal (step_over_bkpt, null_ptid));
3391 debug_printf ("linux_wait_1 ret = %s, %d, %d\n",
3392 target_pid_to_str (ptid_of (current_thread)),
3393 ourstatus->kind, ourstatus->value.sig);
3397 return ptid_of (current_thread);
3400 /* Get rid of any pending event in the pipe. */
3402 async_file_flush (void)
3408 ret = read (linux_event_pipe[0], &buf, 1);
3409 while (ret >= 0 || (ret == -1 && errno == EINTR));
3412 /* Put something in the pipe, so the event loop wakes up. */
3414 async_file_mark (void)
3418 async_file_flush ();
3421 ret = write (linux_event_pipe[1], "+", 1);
3422 while (ret == 0 || (ret == -1 && errno == EINTR));
3424 /* Ignore EAGAIN. If the pipe is full, the event loop will already
3425 be awakened anyway. */
3429 linux_wait (ptid_t ptid,
3430 struct target_waitstatus *ourstatus, int target_options)
3434 /* Flush the async file first. */
3435 if (target_is_async_p ())
3436 async_file_flush ();
3440 event_ptid = linux_wait_1 (ptid, ourstatus, target_options);
3442 while ((target_options & TARGET_WNOHANG) == 0
3443 && ptid_equal (event_ptid, null_ptid)
3444 && ourstatus->kind == TARGET_WAITKIND_IGNORE);
3446 /* If at least one stop was reported, there may be more. A single
3447 SIGCHLD can signal more than one child stop. */
3448 if (target_is_async_p ()
3449 && (target_options & TARGET_WNOHANG) != 0
3450 && !ptid_equal (event_ptid, null_ptid))
3456 /* Send a signal to an LWP. */
3459 kill_lwp (unsigned long lwpid, int signo)
3461 /* Use tkill, if possible, in case we are using nptl threads. If tkill
3462 fails, then we are not using nptl threads and we should be using kill. */
3466 static int tkill_failed;
3473 ret = syscall (__NR_tkill, lwpid, signo);
3474 if (errno != ENOSYS)
3481 return kill (lwpid, signo);
3485 linux_stop_lwp (struct lwp_info *lwp)
3491 send_sigstop (struct lwp_info *lwp)
3495 pid = lwpid_of (get_lwp_thread (lwp));
3497 /* If we already have a pending stop signal for this process, don't
3499 if (lwp->stop_expected)
3502 debug_printf ("Have pending sigstop for lwp %d\n", pid);
3508 debug_printf ("Sending sigstop to lwp %d\n", pid);
3510 lwp->stop_expected = 1;
3511 kill_lwp (pid, SIGSTOP);
3515 send_sigstop_callback (struct inferior_list_entry *entry, void *except)
3517 struct thread_info *thread = (struct thread_info *) entry;
3518 struct lwp_info *lwp = get_thread_lwp (thread);
3520 /* Ignore EXCEPT. */
3531 /* Increment the suspend count of an LWP, and stop it, if not stopped
3534 suspend_and_send_sigstop_callback (struct inferior_list_entry *entry,
3537 struct thread_info *thread = (struct thread_info *) entry;
3538 struct lwp_info *lwp = get_thread_lwp (thread);
3540 /* Ignore EXCEPT. */
3544 lwp_suspended_inc (lwp);
3546 return send_sigstop_callback (entry, except);
3550 mark_lwp_dead (struct lwp_info *lwp, int wstat)
3552 /* Store the exit status for later. */
3553 lwp->status_pending_p = 1;
3554 lwp->status_pending = wstat;
3556 /* Store in waitstatus as well, as there's nothing else to process
3558 if (WIFEXITED (wstat))
3560 lwp->waitstatus.kind = TARGET_WAITKIND_EXITED;
3561 lwp->waitstatus.value.integer = WEXITSTATUS (wstat);
3563 else if (WIFSIGNALED (wstat))
3565 lwp->waitstatus.kind = TARGET_WAITKIND_SIGNALLED;
3566 lwp->waitstatus.value.sig = gdb_signal_from_host (WTERMSIG (wstat));
3569 /* Prevent trying to stop it. */
3572 /* No further stops are expected from a dead lwp. */
3573 lwp->stop_expected = 0;
3576 /* Return true if LWP has exited already, and has a pending exit event
3577 to report to GDB. */
3580 lwp_is_marked_dead (struct lwp_info *lwp)
3582 return (lwp->status_pending_p
3583 && (WIFEXITED (lwp->status_pending)
3584 || WIFSIGNALED (lwp->status_pending)));
3587 /* Wait for all children to stop for the SIGSTOPs we just queued. */
3590 wait_for_sigstop (void)
3592 struct thread_info *saved_thread;
3597 saved_thread = current_thread;
3598 if (saved_thread != NULL)
3599 saved_tid = saved_thread->entry.id;
3601 saved_tid = null_ptid; /* avoid bogus unused warning */
3604 debug_printf ("wait_for_sigstop: pulling events\n");
3606 /* Passing NULL_PTID as filter indicates we want all events to be
3607 left pending. Eventually this returns when there are no
3608 unwaited-for children left. */
3609 ret = linux_wait_for_event_filtered (minus_one_ptid, null_ptid,
3611 gdb_assert (ret == -1);
3613 if (saved_thread == NULL || linux_thread_alive (saved_tid))
3614 current_thread = saved_thread;
3618 debug_printf ("Previously current thread died.\n");
3620 /* We can't change the current inferior behind GDB's back,
3621 otherwise, a subsequent command may apply to the wrong
3623 current_thread = NULL;
3627 /* Returns true if LWP ENTRY is stopped in a jump pad, and we can't
3628 move it out, because we need to report the stop event to GDB. For
3629 example, if the user puts a breakpoint in the jump pad, it's
3630 because she wants to debug it. */
3633 stuck_in_jump_pad_callback (struct inferior_list_entry *entry, void *data)
3635 struct thread_info *thread = (struct thread_info *) entry;
3636 struct lwp_info *lwp = get_thread_lwp (thread);
3638 if (lwp->suspended != 0)
3640 internal_error (__FILE__, __LINE__,
3641 "LWP %ld is suspended, suspended=%d\n",
3642 lwpid_of (thread), lwp->suspended);
3644 gdb_assert (lwp->stopped);
3646 /* Allow debugging the jump pad, gdb_collect, etc.. */
3647 return (supports_fast_tracepoints ()
3648 && agent_loaded_p ()
3649 && (gdb_breakpoint_here (lwp->stop_pc)
3650 || lwp->stop_reason == TARGET_STOPPED_BY_WATCHPOINT
3651 || thread->last_resume_kind == resume_step)
3652 && linux_fast_tracepoint_collecting (lwp, NULL));
3656 move_out_of_jump_pad_callback (struct inferior_list_entry *entry)
3658 struct thread_info *thread = (struct thread_info *) entry;
3659 struct thread_info *saved_thread;
3660 struct lwp_info *lwp = get_thread_lwp (thread);
3663 if (lwp->suspended != 0)
3665 internal_error (__FILE__, __LINE__,
3666 "LWP %ld is suspended, suspended=%d\n",
3667 lwpid_of (thread), lwp->suspended);
3669 gdb_assert (lwp->stopped);
3671 /* For gdb_breakpoint_here. */
3672 saved_thread = current_thread;
3673 current_thread = thread;
3675 wstat = lwp->status_pending_p ? &lwp->status_pending : NULL;
3677 /* Allow debugging the jump pad, gdb_collect, etc. */
3678 if (!gdb_breakpoint_here (lwp->stop_pc)
3679 && lwp->stop_reason != TARGET_STOPPED_BY_WATCHPOINT
3680 && thread->last_resume_kind != resume_step
3681 && maybe_move_out_of_jump_pad (lwp, wstat))
3684 debug_printf ("LWP %ld needs stabilizing (in jump pad)\n",
3689 lwp->status_pending_p = 0;
3690 enqueue_one_deferred_signal (lwp, wstat);
3693 debug_printf ("Signal %d for LWP %ld deferred "
3695 WSTOPSIG (*wstat), lwpid_of (thread));
3698 linux_resume_one_lwp (lwp, 0, 0, NULL);
3701 lwp_suspended_inc (lwp);
3703 current_thread = saved_thread;
3707 lwp_running (struct inferior_list_entry *entry, void *data)
3709 struct thread_info *thread = (struct thread_info *) entry;
3710 struct lwp_info *lwp = get_thread_lwp (thread);
3712 if (lwp_is_marked_dead (lwp))
3719 /* Stop all lwps that aren't stopped yet, except EXCEPT, if not NULL.
3720 If SUSPEND, then also increase the suspend count of every LWP,
3724 stop_all_lwps (int suspend, struct lwp_info *except)
3726 /* Should not be called recursively. */
3727 gdb_assert (stopping_threads == NOT_STOPPING_THREADS);
3732 debug_printf ("stop_all_lwps (%s, except=%s)\n",
3733 suspend ? "stop-and-suspend" : "stop",
3735 ? target_pid_to_str (ptid_of (get_lwp_thread (except)))
3739 stopping_threads = (suspend
3740 ? STOPPING_AND_SUSPENDING_THREADS
3741 : STOPPING_THREADS);
3744 find_inferior (&all_threads, suspend_and_send_sigstop_callback, except);
3746 find_inferior (&all_threads, send_sigstop_callback, except);
3747 wait_for_sigstop ();
3748 stopping_threads = NOT_STOPPING_THREADS;
3752 debug_printf ("stop_all_lwps done, setting stopping_threads "
3753 "back to !stopping\n");
3758 /* Enqueue one signal in the chain of signals which need to be
3759 delivered to this process on next resume. */
3762 enqueue_pending_signal (struct lwp_info *lwp, int signal, siginfo_t *info)
3764 struct pending_signals *p_sig = XNEW (struct pending_signals);
3766 p_sig->prev = lwp->pending_signals;
3767 p_sig->signal = signal;
3769 memset (&p_sig->info, 0, sizeof (siginfo_t));
3771 memcpy (&p_sig->info, info, sizeof (siginfo_t));
3772 lwp->pending_signals = p_sig;
3775 /* Resume execution of LWP. If STEP is nonzero, single-step it. If
3776 SIGNAL is nonzero, give it that signal. */
3779 linux_resume_one_lwp_throw (struct lwp_info *lwp,
3780 int step, int signal, siginfo_t *info)
3782 struct thread_info *thread = get_lwp_thread (lwp);
3783 struct thread_info *saved_thread;
3784 int fast_tp_collecting;
3785 struct process_info *proc = get_thread_process (thread);
3787 /* Note that target description may not be initialised
3788 (proc->tdesc == NULL) at this point because the program hasn't
3789 stopped at the first instruction yet. It means GDBserver skips
3790 the extra traps from the wrapper program (see option --wrapper).
3791 Code in this function that requires register access should be
3792 guarded by proc->tdesc == NULL or something else. */
3794 if (lwp->stopped == 0)
3797 fast_tp_collecting = lwp->collecting_fast_tracepoint;
3799 gdb_assert (!stabilizing_threads || fast_tp_collecting);
3801 /* Cancel actions that rely on GDB not changing the PC (e.g., the
3802 user used the "jump" command, or "set $pc = foo"). */
3803 if (thread->while_stepping != NULL && lwp->stop_pc != get_pc (lwp))
3805 /* Collecting 'while-stepping' actions doesn't make sense
3807 release_while_stepping_state_list (thread);
3810 /* If we have pending signals or status, and a new signal, enqueue the
3811 signal. Also enqueue the signal if we are waiting to reinsert a
3812 breakpoint; it will be picked up again below. */
3814 && (lwp->status_pending_p
3815 || lwp->pending_signals != NULL
3816 || lwp->bp_reinsert != 0
3817 || fast_tp_collecting))
3819 struct pending_signals *p_sig = XNEW (struct pending_signals);
3821 p_sig->prev = lwp->pending_signals;
3822 p_sig->signal = signal;
3824 memset (&p_sig->info, 0, sizeof (siginfo_t));
3826 memcpy (&p_sig->info, info, sizeof (siginfo_t));
3827 lwp->pending_signals = p_sig;
3830 if (lwp->status_pending_p)
3833 debug_printf ("Not resuming lwp %ld (%s, signal %d, stop %s);"
3834 " has pending status\n",
3835 lwpid_of (thread), step ? "step" : "continue", signal,
3836 lwp->stop_expected ? "expected" : "not expected");
3840 saved_thread = current_thread;
3841 current_thread = thread;
3844 debug_printf ("Resuming lwp %ld (%s, signal %d, stop %s)\n",
3845 lwpid_of (thread), step ? "step" : "continue", signal,
3846 lwp->stop_expected ? "expected" : "not expected");
3848 /* This bit needs some thinking about. If we get a signal that
3849 we must report while a single-step reinsert is still pending,
3850 we often end up resuming the thread. It might be better to
3851 (ew) allow a stack of pending events; then we could be sure that
3852 the reinsert happened right away and not lose any signals.
3854 Making this stack would also shrink the window in which breakpoints are
3855 uninserted (see comment in linux_wait_for_lwp) but not enough for
3856 complete correctness, so it won't solve that problem. It may be
3857 worthwhile just to solve this one, however. */
3858 if (lwp->bp_reinsert != 0)
3861 debug_printf (" pending reinsert at 0x%s\n",
3862 paddress (lwp->bp_reinsert));
3864 if (can_hardware_single_step ())
3866 if (fast_tp_collecting == 0)
3869 fprintf (stderr, "BAD - reinserting but not stepping.\n");
3871 fprintf (stderr, "BAD - reinserting and suspended(%d).\n",
3878 /* Postpone any pending signal. It was enqueued above. */
3882 if (fast_tp_collecting == 1)
3885 debug_printf ("lwp %ld wants to get out of fast tracepoint jump pad"
3886 " (exit-jump-pad-bkpt)\n",
3889 /* Postpone any pending signal. It was enqueued above. */
3892 else if (fast_tp_collecting == 2)
3895 debug_printf ("lwp %ld wants to get out of fast tracepoint jump pad"
3896 " single-stepping\n",
3899 if (can_hardware_single_step ())
3903 internal_error (__FILE__, __LINE__,
3904 "moving out of jump pad single-stepping"
3905 " not implemented on this target");
3908 /* Postpone any pending signal. It was enqueued above. */
3912 /* If we have while-stepping actions in this thread set it stepping.
3913 If we have a signal to deliver, it may or may not be set to
3914 SIG_IGN, we don't know. Assume so, and allow collecting
3915 while-stepping into a signal handler. A possible smart thing to
3916 do would be to set an internal breakpoint at the signal return
3917 address, continue, and carry on catching this while-stepping
3918 action only when that breakpoint is hit. A future
3920 if (thread->while_stepping != NULL
3921 && can_hardware_single_step ())
3924 debug_printf ("lwp %ld has a while-stepping action -> forcing step.\n",
3929 if (proc->tdesc != NULL && the_low_target.get_pc != NULL)
3931 struct regcache *regcache = get_thread_regcache (current_thread, 1);
3933 lwp->stop_pc = (*the_low_target.get_pc) (regcache);
3937 debug_printf (" %s from pc 0x%lx\n", step ? "step" : "continue",
3938 (long) lwp->stop_pc);
3942 /* If we have pending signals, consume one unless we are trying to
3943 reinsert a breakpoint or we're trying to finish a fast tracepoint
3945 if (lwp->pending_signals != NULL
3946 && lwp->bp_reinsert == 0
3947 && fast_tp_collecting == 0)
3949 struct pending_signals **p_sig;
3951 p_sig = &lwp->pending_signals;
3952 while ((*p_sig)->prev != NULL)
3953 p_sig = &(*p_sig)->prev;
3955 signal = (*p_sig)->signal;
3956 if ((*p_sig)->info.si_signo != 0)
3957 ptrace (PTRACE_SETSIGINFO, lwpid_of (thread), (PTRACE_TYPE_ARG3) 0,
3964 if (the_low_target.prepare_to_resume != NULL)
3965 the_low_target.prepare_to_resume (lwp);
3967 regcache_invalidate_thread (thread);
3969 lwp->stepping = step;
3970 ptrace (step ? PTRACE_SINGLESTEP : PTRACE_CONT, lwpid_of (thread),
3971 (PTRACE_TYPE_ARG3) 0,
3972 /* Coerce to a uintptr_t first to avoid potential gcc warning
3973 of coercing an 8 byte integer to a 4 byte pointer. */
3974 (PTRACE_TYPE_ARG4) (uintptr_t) signal);
3976 current_thread = saved_thread;
3978 perror_with_name ("resuming thread");
3980 /* Successfully resumed. Clear state that no longer makes sense,
3981 and mark the LWP as running. Must not do this before resuming
3982 otherwise if that fails other code will be confused. E.g., we'd
3983 later try to stop the LWP and hang forever waiting for a stop
3984 status. Note that we must not throw after this is cleared,
3985 otherwise handle_zombie_lwp_error would get confused. */
3987 lwp->stop_reason = TARGET_STOPPED_BY_NO_REASON;
3990 /* Called when we try to resume a stopped LWP and that errors out. If
3991 the LWP is no longer in ptrace-stopped state (meaning it's zombie,
3992 or about to become), discard the error, clear any pending status
3993 the LWP may have, and return true (we'll collect the exit status
3994 soon enough). Otherwise, return false. */
3997 check_ptrace_stopped_lwp_gone (struct lwp_info *lp)
3999 struct thread_info *thread = get_lwp_thread (lp);
4001 /* If we get an error after resuming the LWP successfully, we'd
4002 confuse !T state for the LWP being gone. */
4003 gdb_assert (lp->stopped);
4005 /* We can't just check whether the LWP is in 'Z (Zombie)' state,
4006 because even if ptrace failed with ESRCH, the tracee may be "not
4007 yet fully dead", but already refusing ptrace requests. In that
4008 case the tracee has 'R (Running)' state for a little bit
4009 (observed in Linux 3.18). See also the note on ESRCH in the
4010 ptrace(2) man page. Instead, check whether the LWP has any state
4011 other than ptrace-stopped. */
4013 /* Don't assume anything if /proc/PID/status can't be read. */
4014 if (linux_proc_pid_is_trace_stopped_nowarn (lwpid_of (thread)) == 0)
4016 lp->stop_reason = TARGET_STOPPED_BY_NO_REASON;
4017 lp->status_pending_p = 0;
4023 /* Like linux_resume_one_lwp_throw, but no error is thrown if the LWP
4024 disappears while we try to resume it. */
4027 linux_resume_one_lwp (struct lwp_info *lwp,
4028 int step, int signal, siginfo_t *info)
4032 linux_resume_one_lwp_throw (lwp, step, signal, info);
4034 CATCH (ex, RETURN_MASK_ERROR)
4036 if (!check_ptrace_stopped_lwp_gone (lwp))
4037 throw_exception (ex);
4042 struct thread_resume_array
4044 struct thread_resume *resume;
4048 /* This function is called once per thread via find_inferior.
4049 ARG is a pointer to a thread_resume_array struct.
4050 We look up the thread specified by ENTRY in ARG, and mark the thread
4051 with a pointer to the appropriate resume request.
4053 This algorithm is O(threads * resume elements), but resume elements
4054 is small (and will remain small at least until GDB supports thread
4058 linux_set_resume_request (struct inferior_list_entry *entry, void *arg)
4060 struct thread_info *thread = (struct thread_info *) entry;
4061 struct lwp_info *lwp = get_thread_lwp (thread);
4063 struct thread_resume_array *r;
4067 for (ndx = 0; ndx < r->n; ndx++)
4069 ptid_t ptid = r->resume[ndx].thread;
4070 if (ptid_equal (ptid, minus_one_ptid)
4071 || ptid_equal (ptid, entry->id)
4072 /* Handle both 'pPID' and 'pPID.-1' as meaning 'all threads
4074 || (ptid_get_pid (ptid) == pid_of (thread)
4075 && (ptid_is_pid (ptid)
4076 || ptid_get_lwp (ptid) == -1)))
4078 if (r->resume[ndx].kind == resume_stop
4079 && thread->last_resume_kind == resume_stop)
4082 debug_printf ("already %s LWP %ld at GDB's request\n",
4083 (thread->last_status.kind
4084 == TARGET_WAITKIND_STOPPED)
4092 lwp->resume = &r->resume[ndx];
4093 thread->last_resume_kind = lwp->resume->kind;
4095 lwp->step_range_start = lwp->resume->step_range_start;
4096 lwp->step_range_end = lwp->resume->step_range_end;
4098 /* If we had a deferred signal to report, dequeue one now.
4099 This can happen if LWP gets more than one signal while
4100 trying to get out of a jump pad. */
4102 && !lwp->status_pending_p
4103 && dequeue_one_deferred_signal (lwp, &lwp->status_pending))
4105 lwp->status_pending_p = 1;
4108 debug_printf ("Dequeueing deferred signal %d for LWP %ld, "
4109 "leaving status pending.\n",
4110 WSTOPSIG (lwp->status_pending),
4118 /* No resume action for this thread. */
4124 /* find_inferior callback for linux_resume.
4125 Set *FLAG_P if this lwp has an interesting status pending. */
4128 resume_status_pending_p (struct inferior_list_entry *entry, void *flag_p)
4130 struct thread_info *thread = (struct thread_info *) entry;
4131 struct lwp_info *lwp = get_thread_lwp (thread);
4133 /* LWPs which will not be resumed are not interesting, because
4134 we might not wait for them next time through linux_wait. */
4135 if (lwp->resume == NULL)
4138 if (thread_still_has_status_pending_p (thread))
4139 * (int *) flag_p = 1;
4144 /* Return 1 if this lwp that GDB wants running is stopped at an
4145 internal breakpoint that we need to step over. It assumes that any
4146 required STOP_PC adjustment has already been propagated to the
4147 inferior's regcache. */
4150 need_step_over_p (struct inferior_list_entry *entry, void *dummy)
4152 struct thread_info *thread = (struct thread_info *) entry;
4153 struct lwp_info *lwp = get_thread_lwp (thread);
4154 struct thread_info *saved_thread;
4156 struct process_info *proc = get_thread_process (thread);
4158 /* GDBserver is skipping the extra traps from the wrapper program,
4159 don't have to do step over. */
4160 if (proc->tdesc == NULL)
4163 /* LWPs which will not be resumed are not interesting, because we
4164 might not wait for them next time through linux_wait. */
4169 debug_printf ("Need step over [LWP %ld]? Ignoring, not stopped\n",
4174 if (thread->last_resume_kind == resume_stop)
4177 debug_printf ("Need step over [LWP %ld]? Ignoring, should remain"
4183 gdb_assert (lwp->suspended >= 0);
4188 debug_printf ("Need step over [LWP %ld]? Ignoring, suspended\n",
4193 if (!lwp->need_step_over)
4196 debug_printf ("Need step over [LWP %ld]? No\n", lwpid_of (thread));
4199 if (lwp->status_pending_p)
4202 debug_printf ("Need step over [LWP %ld]? Ignoring, has pending"
4208 /* Note: PC, not STOP_PC. Either GDB has adjusted the PC already,
4212 /* If the PC has changed since we stopped, then don't do anything,
4213 and let the breakpoint/tracepoint be hit. This happens if, for
4214 instance, GDB handled the decr_pc_after_break subtraction itself,
4215 GDB is OOL stepping this thread, or the user has issued a "jump"
4216 command, or poked thread's registers herself. */
4217 if (pc != lwp->stop_pc)
4220 debug_printf ("Need step over [LWP %ld]? Cancelling, PC was changed. "
4221 "Old stop_pc was 0x%s, PC is now 0x%s\n",
4223 paddress (lwp->stop_pc), paddress (pc));
4225 lwp->need_step_over = 0;
4229 saved_thread = current_thread;
4230 current_thread = thread;
4232 /* We can only step over breakpoints we know about. */
4233 if (breakpoint_here (pc) || fast_tracepoint_jump_here (pc))
4235 /* Don't step over a breakpoint that GDB expects to hit
4236 though. If the condition is being evaluated on the target's side
4237 and it evaluate to false, step over this breakpoint as well. */
4238 if (gdb_breakpoint_here (pc)
4239 && gdb_condition_true_at_breakpoint (pc)
4240 && gdb_no_commands_at_breakpoint (pc))
4243 debug_printf ("Need step over [LWP %ld]? yes, but found"
4244 " GDB breakpoint at 0x%s; skipping step over\n",
4245 lwpid_of (thread), paddress (pc));
4247 current_thread = saved_thread;
4253 debug_printf ("Need step over [LWP %ld]? yes, "
4254 "found breakpoint at 0x%s\n",
4255 lwpid_of (thread), paddress (pc));
4257 /* We've found an lwp that needs stepping over --- return 1 so
4258 that find_inferior stops looking. */
4259 current_thread = saved_thread;
4261 /* If the step over is cancelled, this is set again. */
4262 lwp->need_step_over = 0;
4267 current_thread = saved_thread;
4270 debug_printf ("Need step over [LWP %ld]? No, no breakpoint found"
4272 lwpid_of (thread), paddress (pc));
4277 /* Start a step-over operation on LWP. When LWP stopped at a
4278 breakpoint, to make progress, we need to remove the breakpoint out
4279 of the way. If we let other threads run while we do that, they may
4280 pass by the breakpoint location and miss hitting it. To avoid
4281 that, a step-over momentarily stops all threads while LWP is
4282 single-stepped while the breakpoint is temporarily uninserted from
4283 the inferior. When the single-step finishes, we reinsert the
4284 breakpoint, and let all threads that are supposed to be running,
4287 On targets that don't support hardware single-step, we don't
4288 currently support full software single-stepping. Instead, we only
4289 support stepping over the thread event breakpoint, by asking the
4290 low target where to place a reinsert breakpoint. Since this
4291 routine assumes the breakpoint being stepped over is a thread event
4292 breakpoint, it usually assumes the return address of the current
4293 function is a good enough place to set the reinsert breakpoint. */
4296 start_step_over (struct lwp_info *lwp)
4298 struct thread_info *thread = get_lwp_thread (lwp);
4299 struct thread_info *saved_thread;
4304 debug_printf ("Starting step-over on LWP %ld. Stopping all threads\n",
4307 stop_all_lwps (1, lwp);
4309 if (lwp->suspended != 0)
4311 internal_error (__FILE__, __LINE__,
4312 "LWP %ld suspended=%d\n", lwpid_of (thread),
4317 debug_printf ("Done stopping all threads for step-over.\n");
4319 /* Note, we should always reach here with an already adjusted PC,
4320 either by GDB (if we're resuming due to GDB's request), or by our
4321 caller, if we just finished handling an internal breakpoint GDB
4322 shouldn't care about. */
4325 saved_thread = current_thread;
4326 current_thread = thread;
4328 lwp->bp_reinsert = pc;
4329 uninsert_breakpoints_at (pc);
4330 uninsert_fast_tracepoint_jumps_at (pc);
4332 if (can_hardware_single_step ())
4338 CORE_ADDR raddr = (*the_low_target.breakpoint_reinsert_addr) ();
4339 set_reinsert_breakpoint (raddr);
4343 current_thread = saved_thread;
4345 linux_resume_one_lwp (lwp, step, 0, NULL);
4347 /* Require next event from this LWP. */
4348 step_over_bkpt = thread->entry.id;
4352 /* Finish a step-over. Reinsert the breakpoint we had uninserted in
4353 start_step_over, if still there, and delete any reinsert
4354 breakpoints we've set, on non hardware single-step targets. */
4357 finish_step_over (struct lwp_info *lwp)
4359 if (lwp->bp_reinsert != 0)
4362 debug_printf ("Finished step over.\n");
4364 /* Reinsert any breakpoint at LWP->BP_REINSERT. Note that there
4365 may be no breakpoint to reinsert there by now. */
4366 reinsert_breakpoints_at (lwp->bp_reinsert);
4367 reinsert_fast_tracepoint_jumps_at (lwp->bp_reinsert);
4369 lwp->bp_reinsert = 0;
4371 /* Delete any software-single-step reinsert breakpoints. No
4372 longer needed. We don't have to worry about other threads
4373 hitting this trap, and later not being able to explain it,
4374 because we were stepping over a breakpoint, and we hold all
4375 threads but LWP stopped while doing that. */
4376 if (!can_hardware_single_step ())
4377 delete_reinsert_breakpoints ();
4379 step_over_bkpt = null_ptid;
4386 /* If there's a step over in progress, wait until all threads stop
4387 (that is, until the stepping thread finishes its step), and
4388 unsuspend all lwps. The stepping thread ends with its status
4389 pending, which is processed later when we get back to processing
4393 complete_ongoing_step_over (void)
4395 if (!ptid_equal (step_over_bkpt, null_ptid))
4397 struct lwp_info *lwp;
4402 debug_printf ("detach: step over in progress, finish it first\n");
4404 /* Passing NULL_PTID as filter indicates we want all events to
4405 be left pending. Eventually this returns when there are no
4406 unwaited-for children left. */
4407 ret = linux_wait_for_event_filtered (minus_one_ptid, null_ptid,
4409 gdb_assert (ret == -1);
4411 lwp = find_lwp_pid (step_over_bkpt);
4413 finish_step_over (lwp);
4414 step_over_bkpt = null_ptid;
4415 unsuspend_all_lwps (lwp);
4419 /* This function is called once per thread. We check the thread's resume
4420 request, which will tell us whether to resume, step, or leave the thread
4421 stopped; and what signal, if any, it should be sent.
4423 For threads which we aren't explicitly told otherwise, we preserve
4424 the stepping flag; this is used for stepping over gdbserver-placed
4427 If pending_flags was set in any thread, we queue any needed
4428 signals, since we won't actually resume. We already have a pending
4429 event to report, so we don't need to preserve any step requests;
4430 they should be re-issued if necessary. */
4433 linux_resume_one_thread (struct inferior_list_entry *entry, void *arg)
4435 struct thread_info *thread = (struct thread_info *) entry;
4436 struct lwp_info *lwp = get_thread_lwp (thread);
4438 int leave_all_stopped = * (int *) arg;
4441 if (lwp->resume == NULL)
4444 if (lwp->resume->kind == resume_stop)
4447 debug_printf ("resume_stop request for LWP %ld\n", lwpid_of (thread));
4452 debug_printf ("stopping LWP %ld\n", lwpid_of (thread));
4454 /* Stop the thread, and wait for the event asynchronously,
4455 through the event loop. */
4461 debug_printf ("already stopped LWP %ld\n",
4464 /* The LWP may have been stopped in an internal event that
4465 was not meant to be notified back to GDB (e.g., gdbserver
4466 breakpoint), so we should be reporting a stop event in
4469 /* If the thread already has a pending SIGSTOP, this is a
4470 no-op. Otherwise, something later will presumably resume
4471 the thread and this will cause it to cancel any pending
4472 operation, due to last_resume_kind == resume_stop. If
4473 the thread already has a pending status to report, we
4474 will still report it the next time we wait - see
4475 status_pending_p_callback. */
4477 /* If we already have a pending signal to report, then
4478 there's no need to queue a SIGSTOP, as this means we're
4479 midway through moving the LWP out of the jumppad, and we
4480 will report the pending signal as soon as that is
4482 if (lwp->pending_signals_to_report == NULL)
4486 /* For stop requests, we're done. */
4488 thread->last_status.kind = TARGET_WAITKIND_IGNORE;
4492 /* If this thread which is about to be resumed has a pending status,
4493 then don't resume it - we can just report the pending status.
4494 Likewise if it is suspended, because e.g., another thread is
4495 stepping past a breakpoint. Make sure to queue any signals that
4496 would otherwise be sent. In all-stop mode, we do this decision
4497 based on if *any* thread has a pending status. If there's a
4498 thread that needs the step-over-breakpoint dance, then don't
4499 resume any other thread but that particular one. */
4500 leave_pending = (lwp->suspended
4501 || lwp->status_pending_p
4502 || leave_all_stopped);
4507 debug_printf ("resuming LWP %ld\n", lwpid_of (thread));
4509 step = (lwp->resume->kind == resume_step);
4510 linux_resume_one_lwp (lwp, step, lwp->resume->sig, NULL);
4515 debug_printf ("leaving LWP %ld stopped\n", lwpid_of (thread));
4517 /* If we have a new signal, enqueue the signal. */
4518 if (lwp->resume->sig != 0)
4520 struct pending_signals *p_sig = XCNEW (struct pending_signals);
4522 p_sig->prev = lwp->pending_signals;
4523 p_sig->signal = lwp->resume->sig;
4525 /* If this is the same signal we were previously stopped by,
4526 make sure to queue its siginfo. We can ignore the return
4527 value of ptrace; if it fails, we'll skip
4528 PTRACE_SETSIGINFO. */
4529 if (WIFSTOPPED (lwp->last_status)
4530 && WSTOPSIG (lwp->last_status) == lwp->resume->sig)
4531 ptrace (PTRACE_GETSIGINFO, lwpid_of (thread), (PTRACE_TYPE_ARG3) 0,
4534 lwp->pending_signals = p_sig;
4538 thread->last_status.kind = TARGET_WAITKIND_IGNORE;
4544 linux_resume (struct thread_resume *resume_info, size_t n)
4546 struct thread_resume_array array = { resume_info, n };
4547 struct thread_info *need_step_over = NULL;
4549 int leave_all_stopped;
4554 debug_printf ("linux_resume:\n");
4557 find_inferior (&all_threads, linux_set_resume_request, &array);
4559 /* If there is a thread which would otherwise be resumed, which has
4560 a pending status, then don't resume any threads - we can just
4561 report the pending status. Make sure to queue any signals that
4562 would otherwise be sent. In non-stop mode, we'll apply this
4563 logic to each thread individually. We consume all pending events
4564 before considering to start a step-over (in all-stop). */
4567 find_inferior (&all_threads, resume_status_pending_p, &any_pending);
4569 /* If there is a thread which would otherwise be resumed, which is
4570 stopped at a breakpoint that needs stepping over, then don't
4571 resume any threads - have it step over the breakpoint with all
4572 other threads stopped, then resume all threads again. Make sure
4573 to queue any signals that would otherwise be delivered or
4575 if (!any_pending && supports_breakpoints ())
4577 = (struct thread_info *) find_inferior (&all_threads,
4578 need_step_over_p, NULL);
4580 leave_all_stopped = (need_step_over != NULL || any_pending);
4584 if (need_step_over != NULL)
4585 debug_printf ("Not resuming all, need step over\n");
4586 else if (any_pending)
4587 debug_printf ("Not resuming, all-stop and found "
4588 "an LWP with pending status\n");
4590 debug_printf ("Resuming, no pending status or step over needed\n");
4593 /* Even if we're leaving threads stopped, queue all signals we'd
4594 otherwise deliver. */
4595 find_inferior (&all_threads, linux_resume_one_thread, &leave_all_stopped);
4598 start_step_over (get_thread_lwp (need_step_over));
4602 debug_printf ("linux_resume done\n");
4607 /* This function is called once per thread. We check the thread's
4608 last resume request, which will tell us whether to resume, step, or
4609 leave the thread stopped. Any signal the client requested to be
4610 delivered has already been enqueued at this point.
4612 If any thread that GDB wants running is stopped at an internal
4613 breakpoint that needs stepping over, we start a step-over operation
4614 on that particular thread, and leave all others stopped. */
4617 proceed_one_lwp (struct inferior_list_entry *entry, void *except)
4619 struct thread_info *thread = (struct thread_info *) entry;
4620 struct lwp_info *lwp = get_thread_lwp (thread);
4627 debug_printf ("proceed_one_lwp: lwp %ld\n", lwpid_of (thread));
4632 debug_printf (" LWP %ld already running\n", lwpid_of (thread));
4636 if (thread->last_resume_kind == resume_stop
4637 && thread->last_status.kind != TARGET_WAITKIND_IGNORE)
4640 debug_printf (" client wants LWP to remain %ld stopped\n",
4645 if (lwp->status_pending_p)
4648 debug_printf (" LWP %ld has pending status, leaving stopped\n",
4653 gdb_assert (lwp->suspended >= 0);
4658 debug_printf (" LWP %ld is suspended\n", lwpid_of (thread));
4662 if (thread->last_resume_kind == resume_stop
4663 && lwp->pending_signals_to_report == NULL
4664 && lwp->collecting_fast_tracepoint == 0)
4666 /* We haven't reported this LWP as stopped yet (otherwise, the
4667 last_status.kind check above would catch it, and we wouldn't
4668 reach here. This LWP may have been momentarily paused by a
4669 stop_all_lwps call while handling for example, another LWP's
4670 step-over. In that case, the pending expected SIGSTOP signal
4671 that was queued at vCont;t handling time will have already
4672 been consumed by wait_for_sigstop, and so we need to requeue
4673 another one here. Note that if the LWP already has a SIGSTOP
4674 pending, this is a no-op. */
4677 debug_printf ("Client wants LWP %ld to stop. "
4678 "Making sure it has a SIGSTOP pending\n",
4684 if (thread->last_resume_kind == resume_step)
4687 debug_printf (" stepping LWP %ld, client wants it stepping\n",
4691 else if (lwp->bp_reinsert != 0)
4694 debug_printf (" stepping LWP %ld, reinsert set\n",
4701 linux_resume_one_lwp (lwp, step, 0, NULL);
4706 unsuspend_and_proceed_one_lwp (struct inferior_list_entry *entry, void *except)
4708 struct thread_info *thread = (struct thread_info *) entry;
4709 struct lwp_info *lwp = get_thread_lwp (thread);
4714 lwp_suspended_decr (lwp);
4716 return proceed_one_lwp (entry, except);
4719 /* When we finish a step-over, set threads running again. If there's
4720 another thread that may need a step-over, now's the time to start
4721 it. Eventually, we'll move all threads past their breakpoints. */
4724 proceed_all_lwps (void)
4726 struct thread_info *need_step_over;
4728 /* If there is a thread which would otherwise be resumed, which is
4729 stopped at a breakpoint that needs stepping over, then don't
4730 resume any threads - have it step over the breakpoint with all
4731 other threads stopped, then resume all threads again. */
4733 if (supports_breakpoints ())
4736 = (struct thread_info *) find_inferior (&all_threads,
4737 need_step_over_p, NULL);
4739 if (need_step_over != NULL)
4742 debug_printf ("proceed_all_lwps: found "
4743 "thread %ld needing a step-over\n",
4744 lwpid_of (need_step_over));
4746 start_step_over (get_thread_lwp (need_step_over));
4752 debug_printf ("Proceeding, no step-over needed\n");
4754 find_inferior (&all_threads, proceed_one_lwp, NULL);
4757 /* Stopped LWPs that the client wanted to be running, that don't have
4758 pending statuses, are set to run again, except for EXCEPT, if not
4759 NULL. This undoes a stop_all_lwps call. */
4762 unstop_all_lwps (int unsuspend, struct lwp_info *except)
4768 debug_printf ("unstopping all lwps, except=(LWP %ld)\n",
4769 lwpid_of (get_lwp_thread (except)));
4771 debug_printf ("unstopping all lwps\n");
4775 find_inferior (&all_threads, unsuspend_and_proceed_one_lwp, except);
4777 find_inferior (&all_threads, proceed_one_lwp, except);
4781 debug_printf ("unstop_all_lwps done\n");
4787 #ifdef HAVE_LINUX_REGSETS
4789 #define use_linux_regsets 1
4791 /* Returns true if REGSET has been disabled. */
4794 regset_disabled (struct regsets_info *info, struct regset_info *regset)
4796 return (info->disabled_regsets != NULL
4797 && info->disabled_regsets[regset - info->regsets]);
4800 /* Disable REGSET. */
4803 disable_regset (struct regsets_info *info, struct regset_info *regset)
4807 dr_offset = regset - info->regsets;
4808 if (info->disabled_regsets == NULL)
4809 info->disabled_regsets = xcalloc (1, info->num_regsets);
4810 info->disabled_regsets[dr_offset] = 1;
4814 regsets_fetch_inferior_registers (struct regsets_info *regsets_info,
4815 struct regcache *regcache)
4817 struct regset_info *regset;
4818 int saw_general_regs = 0;
4822 pid = lwpid_of (current_thread);
4823 for (regset = regsets_info->regsets; regset->size >= 0; regset++)
4828 if (regset->size == 0 || regset_disabled (regsets_info, regset))
4831 buf = xmalloc (regset->size);
4833 nt_type = regset->nt_type;
4837 iov.iov_len = regset->size;
4838 data = (void *) &iov;
4844 res = ptrace (regset->get_request, pid,
4845 (PTRACE_TYPE_ARG3) (long) nt_type, data);
4847 res = ptrace (regset->get_request, pid, data, nt_type);
4853 /* If we get EIO on a regset, do not try it again for
4854 this process mode. */
4855 disable_regset (regsets_info, regset);
4857 else if (errno == ENODATA)
4859 /* ENODATA may be returned if the regset is currently
4860 not "active". This can happen in normal operation,
4861 so suppress the warning in this case. */
4866 sprintf (s, "ptrace(regsets_fetch_inferior_registers) PID=%d",
4873 if (regset->type == GENERAL_REGS)
4874 saw_general_regs = 1;
4875 regset->store_function (regcache, buf);
4879 if (saw_general_regs)
4886 regsets_store_inferior_registers (struct regsets_info *regsets_info,
4887 struct regcache *regcache)
4889 struct regset_info *regset;
4890 int saw_general_regs = 0;
4894 pid = lwpid_of (current_thread);
4895 for (regset = regsets_info->regsets; regset->size >= 0; regset++)
4900 if (regset->size == 0 || regset_disabled (regsets_info, regset)
4901 || regset->fill_function == NULL)
4904 buf = xmalloc (regset->size);
4906 /* First fill the buffer with the current register set contents,
4907 in case there are any items in the kernel's regset that are
4908 not in gdbserver's regcache. */
4910 nt_type = regset->nt_type;
4914 iov.iov_len = regset->size;
4915 data = (void *) &iov;
4921 res = ptrace (regset->get_request, pid,
4922 (PTRACE_TYPE_ARG3) (long) nt_type, data);
4924 res = ptrace (regset->get_request, pid, data, nt_type);
4929 /* Then overlay our cached registers on that. */
4930 regset->fill_function (regcache, buf);
4932 /* Only now do we write the register set. */
4934 res = ptrace (regset->set_request, pid,
4935 (PTRACE_TYPE_ARG3) (long) nt_type, data);
4937 res = ptrace (regset->set_request, pid, data, nt_type);
4945 /* If we get EIO on a regset, do not try it again for
4946 this process mode. */
4947 disable_regset (regsets_info, regset);
4949 else if (errno == ESRCH)
4951 /* At this point, ESRCH should mean the process is
4952 already gone, in which case we simply ignore attempts
4953 to change its registers. See also the related
4954 comment in linux_resume_one_lwp. */
4960 perror ("Warning: ptrace(regsets_store_inferior_registers)");
4963 else if (regset->type == GENERAL_REGS)
4964 saw_general_regs = 1;
4967 if (saw_general_regs)
4973 #else /* !HAVE_LINUX_REGSETS */
4975 #define use_linux_regsets 0
4976 #define regsets_fetch_inferior_registers(regsets_info, regcache) 1
4977 #define regsets_store_inferior_registers(regsets_info, regcache) 1
4981 /* Return 1 if register REGNO is supported by one of the regset ptrace
4982 calls or 0 if it has to be transferred individually. */
4985 linux_register_in_regsets (const struct regs_info *regs_info, int regno)
4987 unsigned char mask = 1 << (regno % 8);
4988 size_t index = regno / 8;
4990 return (use_linux_regsets
4991 && (regs_info->regset_bitmap == NULL
4992 || (regs_info->regset_bitmap[index] & mask) != 0));
4995 #ifdef HAVE_LINUX_USRREGS
4998 register_addr (const struct usrregs_info *usrregs, int regnum)
5002 if (regnum < 0 || regnum >= usrregs->num_regs)
5003 error ("Invalid register number %d.", regnum);
5005 addr = usrregs->regmap[regnum];
5010 /* Fetch one register. */
5012 fetch_register (const struct usrregs_info *usrregs,
5013 struct regcache *regcache, int regno)
5020 if (regno >= usrregs->num_regs)
5022 if ((*the_low_target.cannot_fetch_register) (regno))
5025 regaddr = register_addr (usrregs, regno);
5029 size = ((register_size (regcache->tdesc, regno)
5030 + sizeof (PTRACE_XFER_TYPE) - 1)
5031 & -sizeof (PTRACE_XFER_TYPE));
5032 buf = alloca (size);
5034 pid = lwpid_of (current_thread);
5035 for (i = 0; i < size; i += sizeof (PTRACE_XFER_TYPE))
5038 *(PTRACE_XFER_TYPE *) (buf + i) =
5039 ptrace (PTRACE_PEEKUSER, pid,
5040 /* Coerce to a uintptr_t first to avoid potential gcc warning
5041 of coercing an 8 byte integer to a 4 byte pointer. */
5042 (PTRACE_TYPE_ARG3) (uintptr_t) regaddr, (PTRACE_TYPE_ARG4) 0);
5043 regaddr += sizeof (PTRACE_XFER_TYPE);
5045 error ("reading register %d: %s", regno, strerror (errno));
5048 if (the_low_target.supply_ptrace_register)
5049 the_low_target.supply_ptrace_register (regcache, regno, buf);
5051 supply_register (regcache, regno, buf);
5054 /* Store one register. */
5056 store_register (const struct usrregs_info *usrregs,
5057 struct regcache *regcache, int regno)
5064 if (regno >= usrregs->num_regs)
5066 if ((*the_low_target.cannot_store_register) (regno))
5069 regaddr = register_addr (usrregs, regno);
5073 size = ((register_size (regcache->tdesc, regno)
5074 + sizeof (PTRACE_XFER_TYPE) - 1)
5075 & -sizeof (PTRACE_XFER_TYPE));
5076 buf = alloca (size);
5077 memset (buf, 0, size);
5079 if (the_low_target.collect_ptrace_register)
5080 the_low_target.collect_ptrace_register (regcache, regno, buf);
5082 collect_register (regcache, regno, buf);
5084 pid = lwpid_of (current_thread);
5085 for (i = 0; i < size; i += sizeof (PTRACE_XFER_TYPE))
5088 ptrace (PTRACE_POKEUSER, pid,
5089 /* Coerce to a uintptr_t first to avoid potential gcc warning
5090 about coercing an 8 byte integer to a 4 byte pointer. */
5091 (PTRACE_TYPE_ARG3) (uintptr_t) regaddr,
5092 (PTRACE_TYPE_ARG4) *(PTRACE_XFER_TYPE *) (buf + i));
5095 /* At this point, ESRCH should mean the process is
5096 already gone, in which case we simply ignore attempts
5097 to change its registers. See also the related
5098 comment in linux_resume_one_lwp. */
5102 if ((*the_low_target.cannot_store_register) (regno) == 0)
5103 error ("writing register %d: %s", regno, strerror (errno));
5105 regaddr += sizeof (PTRACE_XFER_TYPE);
5109 /* Fetch all registers, or just one, from the child process.
5110 If REGNO is -1, do this for all registers, skipping any that are
5111 assumed to have been retrieved by regsets_fetch_inferior_registers,
5112 unless ALL is non-zero.
5113 Otherwise, REGNO specifies which register (so we can save time). */
5115 usr_fetch_inferior_registers (const struct regs_info *regs_info,
5116 struct regcache *regcache, int regno, int all)
5118 struct usrregs_info *usr = regs_info->usrregs;
5122 for (regno = 0; regno < usr->num_regs; regno++)
5123 if (all || !linux_register_in_regsets (regs_info, regno))
5124 fetch_register (usr, regcache, regno);
5127 fetch_register (usr, regcache, regno);
5130 /* Store our register values back into the inferior.
5131 If REGNO is -1, do this for all registers, skipping any that are
5132 assumed to have been saved by regsets_store_inferior_registers,
5133 unless ALL is non-zero.
5134 Otherwise, REGNO specifies which register (so we can save time). */
5136 usr_store_inferior_registers (const struct regs_info *regs_info,
5137 struct regcache *regcache, int regno, int all)
5139 struct usrregs_info *usr = regs_info->usrregs;
5143 for (regno = 0; regno < usr->num_regs; regno++)
5144 if (all || !linux_register_in_regsets (regs_info, regno))
5145 store_register (usr, regcache, regno);
5148 store_register (usr, regcache, regno);
5151 #else /* !HAVE_LINUX_USRREGS */
5153 #define usr_fetch_inferior_registers(regs_info, regcache, regno, all) do {} while (0)
5154 #define usr_store_inferior_registers(regs_info, regcache, regno, all) do {} while (0)
5160 linux_fetch_registers (struct regcache *regcache, int regno)
5164 const struct regs_info *regs_info = (*the_low_target.regs_info) ();
5168 if (the_low_target.fetch_register != NULL
5169 && regs_info->usrregs != NULL)
5170 for (regno = 0; regno < regs_info->usrregs->num_regs; regno++)
5171 (*the_low_target.fetch_register) (regcache, regno);
5173 all = regsets_fetch_inferior_registers (regs_info->regsets_info, regcache);
5174 if (regs_info->usrregs != NULL)
5175 usr_fetch_inferior_registers (regs_info, regcache, -1, all);
5179 if (the_low_target.fetch_register != NULL
5180 && (*the_low_target.fetch_register) (regcache, regno))
5183 use_regsets = linux_register_in_regsets (regs_info, regno);
5185 all = regsets_fetch_inferior_registers (regs_info->regsets_info,
5187 if ((!use_regsets || all) && regs_info->usrregs != NULL)
5188 usr_fetch_inferior_registers (regs_info, regcache, regno, 1);
5193 linux_store_registers (struct regcache *regcache, int regno)
5197 const struct regs_info *regs_info = (*the_low_target.regs_info) ();
5201 all = regsets_store_inferior_registers (regs_info->regsets_info,
5203 if (regs_info->usrregs != NULL)
5204 usr_store_inferior_registers (regs_info, regcache, regno, all);
5208 use_regsets = linux_register_in_regsets (regs_info, regno);
5210 all = regsets_store_inferior_registers (regs_info->regsets_info,
5212 if ((!use_regsets || all) && regs_info->usrregs != NULL)
5213 usr_store_inferior_registers (regs_info, regcache, regno, 1);
5218 /* Copy LEN bytes from inferior's memory starting at MEMADDR
5219 to debugger memory starting at MYADDR. */
5222 linux_read_memory (CORE_ADDR memaddr, unsigned char *myaddr, int len)
5224 int pid = lwpid_of (current_thread);
5225 register PTRACE_XFER_TYPE *buffer;
5226 register CORE_ADDR addr;
5233 /* Try using /proc. Don't bother for one word. */
5234 if (len >= 3 * sizeof (long))
5238 /* We could keep this file open and cache it - possibly one per
5239 thread. That requires some juggling, but is even faster. */
5240 sprintf (filename, "/proc/%d/mem", pid);
5241 fd = open (filename, O_RDONLY | O_LARGEFILE);
5245 /* If pread64 is available, use it. It's faster if the kernel
5246 supports it (only one syscall), and it's 64-bit safe even on
5247 32-bit platforms (for instance, SPARC debugging a SPARC64
5250 bytes = pread64 (fd, myaddr, len, memaddr);
5253 if (lseek (fd, memaddr, SEEK_SET) != -1)
5254 bytes = read (fd, myaddr, len);
5261 /* Some data was read, we'll try to get the rest with ptrace. */
5271 /* Round starting address down to longword boundary. */
5272 addr = memaddr & -(CORE_ADDR) sizeof (PTRACE_XFER_TYPE);
5273 /* Round ending address up; get number of longwords that makes. */
5274 count = ((((memaddr + len) - addr) + sizeof (PTRACE_XFER_TYPE) - 1)
5275 / sizeof (PTRACE_XFER_TYPE));
5276 /* Allocate buffer of that many longwords. */
5277 buffer = XALLOCAVEC (PTRACE_XFER_TYPE, count);
5279 /* Read all the longwords */
5281 for (i = 0; i < count; i++, addr += sizeof (PTRACE_XFER_TYPE))
5283 /* Coerce the 3rd arg to a uintptr_t first to avoid potential gcc warning
5284 about coercing an 8 byte integer to a 4 byte pointer. */
5285 buffer[i] = ptrace (PTRACE_PEEKTEXT, pid,
5286 (PTRACE_TYPE_ARG3) (uintptr_t) addr,
5287 (PTRACE_TYPE_ARG4) 0);
5293 /* Copy appropriate bytes out of the buffer. */
5296 i *= sizeof (PTRACE_XFER_TYPE);
5297 i -= memaddr & (sizeof (PTRACE_XFER_TYPE) - 1);
5299 (char *) buffer + (memaddr & (sizeof (PTRACE_XFER_TYPE) - 1)),
5306 /* Copy LEN bytes of data from debugger memory at MYADDR to inferior's
5307 memory at MEMADDR. On failure (cannot write to the inferior)
5308 returns the value of errno. Always succeeds if LEN is zero. */
5311 linux_write_memory (CORE_ADDR memaddr, const unsigned char *myaddr, int len)
5314 /* Round starting address down to longword boundary. */
5315 register CORE_ADDR addr = memaddr & -(CORE_ADDR) sizeof (PTRACE_XFER_TYPE);
5316 /* Round ending address up; get number of longwords that makes. */
5318 = (((memaddr + len) - addr) + sizeof (PTRACE_XFER_TYPE) - 1)
5319 / sizeof (PTRACE_XFER_TYPE);
5321 /* Allocate buffer of that many longwords. */
5322 register PTRACE_XFER_TYPE *buffer = XALLOCAVEC (PTRACE_XFER_TYPE, count);
5324 int pid = lwpid_of (current_thread);
5328 /* Zero length write always succeeds. */
5334 /* Dump up to four bytes. */
5335 char str[4 * 2 + 1];
5337 int dump = len < 4 ? len : 4;
5339 for (i = 0; i < dump; i++)
5341 sprintf (p, "%02x", myaddr[i]);
5346 debug_printf ("Writing %s to 0x%08lx in process %d\n",
5347 str, (long) memaddr, pid);
5350 /* Fill start and end extra bytes of buffer with existing memory data. */
5353 /* Coerce the 3rd arg to a uintptr_t first to avoid potential gcc warning
5354 about coercing an 8 byte integer to a 4 byte pointer. */
5355 buffer[0] = ptrace (PTRACE_PEEKTEXT, pid,
5356 (PTRACE_TYPE_ARG3) (uintptr_t) addr,
5357 (PTRACE_TYPE_ARG4) 0);
5365 = ptrace (PTRACE_PEEKTEXT, pid,
5366 /* Coerce to a uintptr_t first to avoid potential gcc warning
5367 about coercing an 8 byte integer to a 4 byte pointer. */
5368 (PTRACE_TYPE_ARG3) (uintptr_t) (addr + (count - 1)
5369 * sizeof (PTRACE_XFER_TYPE)),
5370 (PTRACE_TYPE_ARG4) 0);
5375 /* Copy data to be written over corresponding part of buffer. */
5377 memcpy ((char *) buffer + (memaddr & (sizeof (PTRACE_XFER_TYPE) - 1)),
5380 /* Write the entire buffer. */
5382 for (i = 0; i < count; i++, addr += sizeof (PTRACE_XFER_TYPE))
5385 ptrace (PTRACE_POKETEXT, pid,
5386 /* Coerce to a uintptr_t first to avoid potential gcc warning
5387 about coercing an 8 byte integer to a 4 byte pointer. */
5388 (PTRACE_TYPE_ARG3) (uintptr_t) addr,
5389 (PTRACE_TYPE_ARG4) buffer[i]);
5398 linux_look_up_symbols (void)
5400 #ifdef USE_THREAD_DB
5401 struct process_info *proc = current_process ();
5403 if (proc->priv->thread_db != NULL)
5406 /* If the kernel supports tracing clones, then we don't need to
5407 use the magic thread event breakpoint to learn about
5409 thread_db_init (!linux_supports_traceclone ());
5414 linux_request_interrupt (void)
5416 extern unsigned long signal_pid;
5418 /* Send a SIGINT to the process group. This acts just like the user
5419 typed a ^C on the controlling terminal. */
5420 kill (-signal_pid, SIGINT);
5423 /* Copy LEN bytes from inferior's auxiliary vector starting at OFFSET
5424 to debugger memory starting at MYADDR. */
5427 linux_read_auxv (CORE_ADDR offset, unsigned char *myaddr, unsigned int len)
5429 char filename[PATH_MAX];
5431 int pid = lwpid_of (current_thread);
5433 xsnprintf (filename, sizeof filename, "/proc/%d/auxv", pid);
5435 fd = open (filename, O_RDONLY);
5439 if (offset != (CORE_ADDR) 0
5440 && lseek (fd, (off_t) offset, SEEK_SET) != (off_t) offset)
5443 n = read (fd, myaddr, len);
5450 /* These breakpoint and watchpoint related wrapper functions simply
5451 pass on the function call if the target has registered a
5452 corresponding function. */
5455 linux_supports_z_point_type (char z_type)
5457 return (the_low_target.supports_z_point_type != NULL
5458 && the_low_target.supports_z_point_type (z_type));
5462 linux_insert_point (enum raw_bkpt_type type, CORE_ADDR addr,
5463 int size, struct raw_breakpoint *bp)
5465 if (type == raw_bkpt_type_sw)
5466 return insert_memory_breakpoint (bp);
5467 else if (the_low_target.insert_point != NULL)
5468 return the_low_target.insert_point (type, addr, size, bp);
5470 /* Unsupported (see target.h). */
5475 linux_remove_point (enum raw_bkpt_type type, CORE_ADDR addr,
5476 int size, struct raw_breakpoint *bp)
5478 if (type == raw_bkpt_type_sw)
5479 return remove_memory_breakpoint (bp);
5480 else if (the_low_target.remove_point != NULL)
5481 return the_low_target.remove_point (type, addr, size, bp);
5483 /* Unsupported (see target.h). */
5487 /* Implement the to_stopped_by_sw_breakpoint target_ops
5491 linux_stopped_by_sw_breakpoint (void)
5493 struct lwp_info *lwp = get_thread_lwp (current_thread);
5495 return (lwp->stop_reason == TARGET_STOPPED_BY_SW_BREAKPOINT);
5498 /* Implement the to_supports_stopped_by_sw_breakpoint target_ops
5502 linux_supports_stopped_by_sw_breakpoint (void)
5504 return USE_SIGTRAP_SIGINFO;
5507 /* Implement the to_stopped_by_hw_breakpoint target_ops
5511 linux_stopped_by_hw_breakpoint (void)
5513 struct lwp_info *lwp = get_thread_lwp (current_thread);
5515 return (lwp->stop_reason == TARGET_STOPPED_BY_HW_BREAKPOINT);
5518 /* Implement the to_supports_stopped_by_hw_breakpoint target_ops
5522 linux_supports_stopped_by_hw_breakpoint (void)
5524 return USE_SIGTRAP_SIGINFO;
5527 /* Implement the supports_conditional_breakpoints target_ops
5531 linux_supports_conditional_breakpoints (void)
5533 /* GDBserver needs to step over the breakpoint if the condition is
5534 false. GDBserver software single step is too simple, so disable
5535 conditional breakpoints if the target doesn't have hardware single
5537 return can_hardware_single_step ();
5541 linux_stopped_by_watchpoint (void)
5543 struct lwp_info *lwp = get_thread_lwp (current_thread);
5545 return lwp->stop_reason == TARGET_STOPPED_BY_WATCHPOINT;
5549 linux_stopped_data_address (void)
5551 struct lwp_info *lwp = get_thread_lwp (current_thread);
5553 return lwp->stopped_data_address;
5556 #if defined(__UCLIBC__) && defined(HAS_NOMMU) \
5557 && defined(PT_TEXT_ADDR) && defined(PT_DATA_ADDR) \
5558 && defined(PT_TEXT_END_ADDR)
5560 /* This is only used for targets that define PT_TEXT_ADDR,
5561 PT_DATA_ADDR and PT_TEXT_END_ADDR. If those are not defined, supposedly
5562 the target has different ways of acquiring this information, like
5565 /* Under uClinux, programs are loaded at non-zero offsets, which we need
5566 to tell gdb about. */
5569 linux_read_offsets (CORE_ADDR *text_p, CORE_ADDR *data_p)
5571 unsigned long text, text_end, data;
5572 int pid = lwpid_of (current_thread);
5576 text = ptrace (PTRACE_PEEKUSER, pid, (PTRACE_TYPE_ARG3) PT_TEXT_ADDR,
5577 (PTRACE_TYPE_ARG4) 0);
5578 text_end = ptrace (PTRACE_PEEKUSER, pid, (PTRACE_TYPE_ARG3) PT_TEXT_END_ADDR,
5579 (PTRACE_TYPE_ARG4) 0);
5580 data = ptrace (PTRACE_PEEKUSER, pid, (PTRACE_TYPE_ARG3) PT_DATA_ADDR,
5581 (PTRACE_TYPE_ARG4) 0);
5585 /* Both text and data offsets produced at compile-time (and so
5586 used by gdb) are relative to the beginning of the program,
5587 with the data segment immediately following the text segment.
5588 However, the actual runtime layout in memory may put the data
5589 somewhere else, so when we send gdb a data base-address, we
5590 use the real data base address and subtract the compile-time
5591 data base-address from it (which is just the length of the
5592 text segment). BSS immediately follows data in both
5595 *data_p = data - (text_end - text);
5604 linux_qxfer_osdata (const char *annex,
5605 unsigned char *readbuf, unsigned const char *writebuf,
5606 CORE_ADDR offset, int len)
5608 return linux_common_xfer_osdata (annex, readbuf, offset, len);
5611 /* Convert a native/host siginfo object, into/from the siginfo in the
5612 layout of the inferiors' architecture. */
5615 siginfo_fixup (siginfo_t *siginfo, void *inf_siginfo, int direction)
5619 if (the_low_target.siginfo_fixup != NULL)
5620 done = the_low_target.siginfo_fixup (siginfo, inf_siginfo, direction);
5622 /* If there was no callback, or the callback didn't do anything,
5623 then just do a straight memcpy. */
5627 memcpy (siginfo, inf_siginfo, sizeof (siginfo_t));
5629 memcpy (inf_siginfo, siginfo, sizeof (siginfo_t));
5634 linux_xfer_siginfo (const char *annex, unsigned char *readbuf,
5635 unsigned const char *writebuf, CORE_ADDR offset, int len)
5639 char inf_siginfo[sizeof (siginfo_t)];
5641 if (current_thread == NULL)
5644 pid = lwpid_of (current_thread);
5647 debug_printf ("%s siginfo for lwp %d.\n",
5648 readbuf != NULL ? "Reading" : "Writing",
5651 if (offset >= sizeof (siginfo))
5654 if (ptrace (PTRACE_GETSIGINFO, pid, (PTRACE_TYPE_ARG3) 0, &siginfo) != 0)
5657 /* When GDBSERVER is built as a 64-bit application, ptrace writes into
5658 SIGINFO an object with 64-bit layout. Since debugging a 32-bit
5659 inferior with a 64-bit GDBSERVER should look the same as debugging it
5660 with a 32-bit GDBSERVER, we need to convert it. */
5661 siginfo_fixup (&siginfo, inf_siginfo, 0);
5663 if (offset + len > sizeof (siginfo))
5664 len = sizeof (siginfo) - offset;
5666 if (readbuf != NULL)
5667 memcpy (readbuf, inf_siginfo + offset, len);
5670 memcpy (inf_siginfo + offset, writebuf, len);
5672 /* Convert back to ptrace layout before flushing it out. */
5673 siginfo_fixup (&siginfo, inf_siginfo, 1);
5675 if (ptrace (PTRACE_SETSIGINFO, pid, (PTRACE_TYPE_ARG3) 0, &siginfo) != 0)
5682 /* SIGCHLD handler that serves two purposes: In non-stop/async mode,
5683 so we notice when children change state; as the handler for the
5684 sigsuspend in my_waitpid. */
5687 sigchld_handler (int signo)
5689 int old_errno = errno;
5695 /* fprintf is not async-signal-safe, so call write
5697 if (write (2, "sigchld_handler\n",
5698 sizeof ("sigchld_handler\n") - 1) < 0)
5699 break; /* just ignore */
5703 if (target_is_async_p ())
5704 async_file_mark (); /* trigger a linux_wait */
5710 linux_supports_non_stop (void)
5716 linux_async (int enable)
5718 int previous = target_is_async_p ();
5721 debug_printf ("linux_async (%d), previous=%d\n",
5724 if (previous != enable)
5727 sigemptyset (&mask);
5728 sigaddset (&mask, SIGCHLD);
5730 sigprocmask (SIG_BLOCK, &mask, NULL);
5734 if (pipe (linux_event_pipe) == -1)
5736 linux_event_pipe[0] = -1;
5737 linux_event_pipe[1] = -1;
5738 sigprocmask (SIG_UNBLOCK, &mask, NULL);
5740 warning ("creating event pipe failed.");
5744 fcntl (linux_event_pipe[0], F_SETFL, O_NONBLOCK);
5745 fcntl (linux_event_pipe[1], F_SETFL, O_NONBLOCK);
5747 /* Register the event loop handler. */
5748 add_file_handler (linux_event_pipe[0],
5749 handle_target_event, NULL);
5751 /* Always trigger a linux_wait. */
5756 delete_file_handler (linux_event_pipe[0]);
5758 close (linux_event_pipe[0]);
5759 close (linux_event_pipe[1]);
5760 linux_event_pipe[0] = -1;
5761 linux_event_pipe[1] = -1;
5764 sigprocmask (SIG_UNBLOCK, &mask, NULL);
5771 linux_start_non_stop (int nonstop)
5773 /* Register or unregister from event-loop accordingly. */
5774 linux_async (nonstop);
5776 if (target_is_async_p () != (nonstop != 0))
5783 linux_supports_multi_process (void)
5788 /* Check if fork events are supported. */
5791 linux_supports_fork_events (void)
5793 return linux_supports_tracefork ();
5796 /* Check if vfork events are supported. */
5799 linux_supports_vfork_events (void)
5801 return linux_supports_tracefork ();
5804 /* Callback for 'find_inferior'. Set the (possibly changed) ptrace
5805 options for the specified lwp. */
5808 reset_lwp_ptrace_options_callback (struct inferior_list_entry *entry,
5811 struct thread_info *thread = (struct thread_info *) entry;
5812 struct lwp_info *lwp = get_thread_lwp (thread);
5816 /* Stop the lwp so we can modify its ptrace options. */
5817 lwp->must_set_ptrace_flags = 1;
5818 linux_stop_lwp (lwp);
5822 /* Already stopped; go ahead and set the ptrace options. */
5823 struct process_info *proc = find_process_pid (pid_of (thread));
5824 int options = linux_low_ptrace_options (proc->attached);
5826 linux_enable_event_reporting (lwpid_of (thread), options);
5827 lwp->must_set_ptrace_flags = 0;
5833 /* Target hook for 'handle_new_gdb_connection'. Causes a reset of the
5834 ptrace flags for all inferiors. This is in case the new GDB connection
5835 doesn't support the same set of events that the previous one did. */
5838 linux_handle_new_gdb_connection (void)
5842 /* Request that all the lwps reset their ptrace options. */
5843 find_inferior (&all_threads, reset_lwp_ptrace_options_callback , &pid);
5847 linux_supports_disable_randomization (void)
5849 #ifdef HAVE_PERSONALITY
5857 linux_supports_agent (void)
5863 linux_supports_range_stepping (void)
5865 if (*the_low_target.supports_range_stepping == NULL)
5868 return (*the_low_target.supports_range_stepping) ();
5871 /* Enumerate spufs IDs for process PID. */
5873 spu_enumerate_spu_ids (long pid, unsigned char *buf, CORE_ADDR offset, int len)
5879 struct dirent *entry;
5881 sprintf (path, "/proc/%ld/fd", pid);
5882 dir = opendir (path);
5887 while ((entry = readdir (dir)) != NULL)
5893 fd = atoi (entry->d_name);
5897 sprintf (path, "/proc/%ld/fd/%d", pid, fd);
5898 if (stat (path, &st) != 0)
5900 if (!S_ISDIR (st.st_mode))
5903 if (statfs (path, &stfs) != 0)
5905 if (stfs.f_type != SPUFS_MAGIC)
5908 if (pos >= offset && pos + 4 <= offset + len)
5910 *(unsigned int *)(buf + pos - offset) = fd;
5920 /* Implements the to_xfer_partial interface for the TARGET_OBJECT_SPU
5921 object type, using the /proc file system. */
5923 linux_qxfer_spu (const char *annex, unsigned char *readbuf,
5924 unsigned const char *writebuf,
5925 CORE_ADDR offset, int len)
5927 long pid = lwpid_of (current_thread);
5932 if (!writebuf && !readbuf)
5940 return spu_enumerate_spu_ids (pid, readbuf, offset, len);
5943 sprintf (buf, "/proc/%ld/fd/%s", pid, annex);
5944 fd = open (buf, writebuf? O_WRONLY : O_RDONLY);
5949 && lseek (fd, (off_t) offset, SEEK_SET) != (off_t) offset)
5956 ret = write (fd, writebuf, (size_t) len);
5958 ret = read (fd, readbuf, (size_t) len);
5964 #if defined PT_GETDSBT || defined PTRACE_GETFDPIC
5965 struct target_loadseg
5967 /* Core address to which the segment is mapped. */
5969 /* VMA recorded in the program header. */
5971 /* Size of this segment in memory. */
5975 # if defined PT_GETDSBT
5976 struct target_loadmap
5978 /* Protocol version number, must be zero. */
5980 /* Pointer to the DSBT table, its size, and the DSBT index. */
5981 unsigned *dsbt_table;
5982 unsigned dsbt_size, dsbt_index;
5983 /* Number of segments in this map. */
5985 /* The actual memory map. */
5986 struct target_loadseg segs[/*nsegs*/];
5988 # define LINUX_LOADMAP PT_GETDSBT
5989 # define LINUX_LOADMAP_EXEC PTRACE_GETDSBT_EXEC
5990 # define LINUX_LOADMAP_INTERP PTRACE_GETDSBT_INTERP
5992 struct target_loadmap
5994 /* Protocol version number, must be zero. */
5996 /* Number of segments in this map. */
5998 /* The actual memory map. */
5999 struct target_loadseg segs[/*nsegs*/];
6001 # define LINUX_LOADMAP PTRACE_GETFDPIC
6002 # define LINUX_LOADMAP_EXEC PTRACE_GETFDPIC_EXEC
6003 # define LINUX_LOADMAP_INTERP PTRACE_GETFDPIC_INTERP
6007 linux_read_loadmap (const char *annex, CORE_ADDR offset,
6008 unsigned char *myaddr, unsigned int len)
6010 int pid = lwpid_of (current_thread);
6012 struct target_loadmap *data = NULL;
6013 unsigned int actual_length, copy_length;
6015 if (strcmp (annex, "exec") == 0)
6016 addr = (int) LINUX_LOADMAP_EXEC;
6017 else if (strcmp (annex, "interp") == 0)
6018 addr = (int) LINUX_LOADMAP_INTERP;
6022 if (ptrace (LINUX_LOADMAP, pid, addr, &data) != 0)
6028 actual_length = sizeof (struct target_loadmap)
6029 + sizeof (struct target_loadseg) * data->nsegs;
6031 if (offset < 0 || offset > actual_length)
6034 copy_length = actual_length - offset < len ? actual_length - offset : len;
6035 memcpy (myaddr, (char *) data + offset, copy_length);
6039 # define linux_read_loadmap NULL
6040 #endif /* defined PT_GETDSBT || defined PTRACE_GETFDPIC */
6043 linux_process_qsupported (const char *query)
6045 if (the_low_target.process_qsupported != NULL)
6046 the_low_target.process_qsupported (query);
6050 linux_supports_tracepoints (void)
6052 if (*the_low_target.supports_tracepoints == NULL)
6055 return (*the_low_target.supports_tracepoints) ();
6059 linux_read_pc (struct regcache *regcache)
6061 if (the_low_target.get_pc == NULL)
6064 return (*the_low_target.get_pc) (regcache);
6068 linux_write_pc (struct regcache *regcache, CORE_ADDR pc)
6070 gdb_assert (the_low_target.set_pc != NULL);
6072 (*the_low_target.set_pc) (regcache, pc);
6076 linux_thread_stopped (struct thread_info *thread)
6078 return get_thread_lwp (thread)->stopped;
6081 /* This exposes stop-all-threads functionality to other modules. */
6084 linux_pause_all (int freeze)
6086 stop_all_lwps (freeze, NULL);
6089 /* This exposes unstop-all-threads functionality to other gdbserver
6093 linux_unpause_all (int unfreeze)
6095 unstop_all_lwps (unfreeze, NULL);
6099 linux_prepare_to_access_memory (void)
6101 /* Neither ptrace nor /proc/PID/mem allow accessing memory through a
6104 linux_pause_all (1);
6109 linux_done_accessing_memory (void)
6111 /* Neither ptrace nor /proc/PID/mem allow accessing memory through a
6114 linux_unpause_all (1);
6118 linux_install_fast_tracepoint_jump_pad (CORE_ADDR tpoint, CORE_ADDR tpaddr,
6119 CORE_ADDR collector,
6122 CORE_ADDR *jump_entry,
6123 CORE_ADDR *trampoline,
6124 ULONGEST *trampoline_size,
6125 unsigned char *jjump_pad_insn,
6126 ULONGEST *jjump_pad_insn_size,
6127 CORE_ADDR *adjusted_insn_addr,
6128 CORE_ADDR *adjusted_insn_addr_end,
6131 return (*the_low_target.install_fast_tracepoint_jump_pad)
6132 (tpoint, tpaddr, collector, lockaddr, orig_size,
6133 jump_entry, trampoline, trampoline_size,
6134 jjump_pad_insn, jjump_pad_insn_size,
6135 adjusted_insn_addr, adjusted_insn_addr_end,
6139 static struct emit_ops *
6140 linux_emit_ops (void)
6142 if (the_low_target.emit_ops != NULL)
6143 return (*the_low_target.emit_ops) ();
6149 linux_get_min_fast_tracepoint_insn_len (void)
6151 return (*the_low_target.get_min_fast_tracepoint_insn_len) ();
6154 /* Extract &phdr and num_phdr in the inferior. Return 0 on success. */
6157 get_phdr_phnum_from_proc_auxv (const int pid, const int is_elf64,
6158 CORE_ADDR *phdr_memaddr, int *num_phdr)
6160 char filename[PATH_MAX];
6162 const int auxv_size = is_elf64
6163 ? sizeof (Elf64_auxv_t) : sizeof (Elf32_auxv_t);
6164 char buf[sizeof (Elf64_auxv_t)]; /* The larger of the two. */
6166 xsnprintf (filename, sizeof filename, "/proc/%d/auxv", pid);
6168 fd = open (filename, O_RDONLY);
6174 while (read (fd, buf, auxv_size) == auxv_size
6175 && (*phdr_memaddr == 0 || *num_phdr == 0))
6179 Elf64_auxv_t *const aux = (Elf64_auxv_t *) buf;
6181 switch (aux->a_type)
6184 *phdr_memaddr = aux->a_un.a_val;
6187 *num_phdr = aux->a_un.a_val;
6193 Elf32_auxv_t *const aux = (Elf32_auxv_t *) buf;
6195 switch (aux->a_type)
6198 *phdr_memaddr = aux->a_un.a_val;
6201 *num_phdr = aux->a_un.a_val;
6209 if (*phdr_memaddr == 0 || *num_phdr == 0)
6211 warning ("Unexpected missing AT_PHDR and/or AT_PHNUM: "
6212 "phdr_memaddr = %ld, phdr_num = %d",
6213 (long) *phdr_memaddr, *num_phdr);
6220 /* Return &_DYNAMIC (via PT_DYNAMIC) in the inferior, or 0 if not present. */
6223 get_dynamic (const int pid, const int is_elf64)
6225 CORE_ADDR phdr_memaddr, relocation;
6227 unsigned char *phdr_buf;
6228 const int phdr_size = is_elf64 ? sizeof (Elf64_Phdr) : sizeof (Elf32_Phdr);
6230 if (get_phdr_phnum_from_proc_auxv (pid, is_elf64, &phdr_memaddr, &num_phdr))
6233 gdb_assert (num_phdr < 100); /* Basic sanity check. */
6234 phdr_buf = alloca (num_phdr * phdr_size);
6236 if (linux_read_memory (phdr_memaddr, phdr_buf, num_phdr * phdr_size))
6239 /* Compute relocation: it is expected to be 0 for "regular" executables,
6240 non-zero for PIE ones. */
6242 for (i = 0; relocation == -1 && i < num_phdr; i++)
6245 Elf64_Phdr *const p = (Elf64_Phdr *) (phdr_buf + i * phdr_size);
6247 if (p->p_type == PT_PHDR)
6248 relocation = phdr_memaddr - p->p_vaddr;
6252 Elf32_Phdr *const p = (Elf32_Phdr *) (phdr_buf + i * phdr_size);
6254 if (p->p_type == PT_PHDR)
6255 relocation = phdr_memaddr - p->p_vaddr;
6258 if (relocation == -1)
6260 /* PT_PHDR is optional, but necessary for PIE in general. Fortunately
6261 any real world executables, including PIE executables, have always
6262 PT_PHDR present. PT_PHDR is not present in some shared libraries or
6263 in fpc (Free Pascal 2.4) binaries but neither of those have a need for
6264 or present DT_DEBUG anyway (fpc binaries are statically linked).
6266 Therefore if there exists DT_DEBUG there is always also PT_PHDR.
6268 GDB could find RELOCATION also from AT_ENTRY - e_entry. */
6273 for (i = 0; i < num_phdr; i++)
6277 Elf64_Phdr *const p = (Elf64_Phdr *) (phdr_buf + i * phdr_size);
6279 if (p->p_type == PT_DYNAMIC)
6280 return p->p_vaddr + relocation;
6284 Elf32_Phdr *const p = (Elf32_Phdr *) (phdr_buf + i * phdr_size);
6286 if (p->p_type == PT_DYNAMIC)
6287 return p->p_vaddr + relocation;
6294 /* Return &_r_debug in the inferior, or -1 if not present. Return value
6295 can be 0 if the inferior does not yet have the library list initialized.
6296 We look for DT_MIPS_RLD_MAP first. MIPS executables use this instead of
6297 DT_DEBUG, although they sometimes contain an unused DT_DEBUG entry too. */
6300 get_r_debug (const int pid, const int is_elf64)
6302 CORE_ADDR dynamic_memaddr;
6303 const int dyn_size = is_elf64 ? sizeof (Elf64_Dyn) : sizeof (Elf32_Dyn);
6304 unsigned char buf[sizeof (Elf64_Dyn)]; /* The larger of the two. */
6307 dynamic_memaddr = get_dynamic (pid, is_elf64);
6308 if (dynamic_memaddr == 0)
6311 while (linux_read_memory (dynamic_memaddr, buf, dyn_size) == 0)
6315 Elf64_Dyn *const dyn = (Elf64_Dyn *) buf;
6316 #if defined DT_MIPS_RLD_MAP || defined DT_MIPS_RLD_MAP_REL
6320 unsigned char buf[sizeof (Elf64_Xword)];
6324 #ifdef DT_MIPS_RLD_MAP
6325 if (dyn->d_tag == DT_MIPS_RLD_MAP)
6327 if (linux_read_memory (dyn->d_un.d_val,
6328 rld_map.buf, sizeof (rld_map.buf)) == 0)
6333 #endif /* DT_MIPS_RLD_MAP */
6334 #ifdef DT_MIPS_RLD_MAP_REL
6335 if (dyn->d_tag == DT_MIPS_RLD_MAP_REL)
6337 if (linux_read_memory (dyn->d_un.d_val + dynamic_memaddr,
6338 rld_map.buf, sizeof (rld_map.buf)) == 0)
6343 #endif /* DT_MIPS_RLD_MAP_REL */
6345 if (dyn->d_tag == DT_DEBUG && map == -1)
6346 map = dyn->d_un.d_val;
6348 if (dyn->d_tag == DT_NULL)
6353 Elf32_Dyn *const dyn = (Elf32_Dyn *) buf;
6354 #if defined DT_MIPS_RLD_MAP || defined DT_MIPS_RLD_MAP_REL
6358 unsigned char buf[sizeof (Elf32_Word)];
6362 #ifdef DT_MIPS_RLD_MAP
6363 if (dyn->d_tag == DT_MIPS_RLD_MAP)
6365 if (linux_read_memory (dyn->d_un.d_val,
6366 rld_map.buf, sizeof (rld_map.buf)) == 0)
6371 #endif /* DT_MIPS_RLD_MAP */
6372 #ifdef DT_MIPS_RLD_MAP_REL
6373 if (dyn->d_tag == DT_MIPS_RLD_MAP_REL)
6375 if (linux_read_memory (dyn->d_un.d_val + dynamic_memaddr,
6376 rld_map.buf, sizeof (rld_map.buf)) == 0)
6381 #endif /* DT_MIPS_RLD_MAP_REL */
6383 if (dyn->d_tag == DT_DEBUG && map == -1)
6384 map = dyn->d_un.d_val;
6386 if (dyn->d_tag == DT_NULL)
6390 dynamic_memaddr += dyn_size;
6396 /* Read one pointer from MEMADDR in the inferior. */
6399 read_one_ptr (CORE_ADDR memaddr, CORE_ADDR *ptr, int ptr_size)
6403 /* Go through a union so this works on either big or little endian
6404 hosts, when the inferior's pointer size is smaller than the size
6405 of CORE_ADDR. It is assumed the inferior's endianness is the
6406 same of the superior's. */
6409 CORE_ADDR core_addr;
6414 ret = linux_read_memory (memaddr, &addr.uc, ptr_size);
6417 if (ptr_size == sizeof (CORE_ADDR))
6418 *ptr = addr.core_addr;
6419 else if (ptr_size == sizeof (unsigned int))
6422 gdb_assert_not_reached ("unhandled pointer size");
6427 struct link_map_offsets
6429 /* Offset and size of r_debug.r_version. */
6430 int r_version_offset;
6432 /* Offset and size of r_debug.r_map. */
6435 /* Offset to l_addr field in struct link_map. */
6438 /* Offset to l_name field in struct link_map. */
6441 /* Offset to l_ld field in struct link_map. */
6444 /* Offset to l_next field in struct link_map. */
6447 /* Offset to l_prev field in struct link_map. */
6451 /* Construct qXfer:libraries-svr4:read reply. */
6454 linux_qxfer_libraries_svr4 (const char *annex, unsigned char *readbuf,
6455 unsigned const char *writebuf,
6456 CORE_ADDR offset, int len)
6459 unsigned document_len;
6460 struct process_info_private *const priv = current_process ()->priv;
6461 char filename[PATH_MAX];
6464 static const struct link_map_offsets lmo_32bit_offsets =
6466 0, /* r_version offset. */
6467 4, /* r_debug.r_map offset. */
6468 0, /* l_addr offset in link_map. */
6469 4, /* l_name offset in link_map. */
6470 8, /* l_ld offset in link_map. */
6471 12, /* l_next offset in link_map. */
6472 16 /* l_prev offset in link_map. */
6475 static const struct link_map_offsets lmo_64bit_offsets =
6477 0, /* r_version offset. */
6478 8, /* r_debug.r_map offset. */
6479 0, /* l_addr offset in link_map. */
6480 8, /* l_name offset in link_map. */
6481 16, /* l_ld offset in link_map. */
6482 24, /* l_next offset in link_map. */
6483 32 /* l_prev offset in link_map. */
6485 const struct link_map_offsets *lmo;
6486 unsigned int machine;
6488 CORE_ADDR lm_addr = 0, lm_prev = 0;
6489 int allocated = 1024;
6491 CORE_ADDR l_name, l_addr, l_ld, l_next, l_prev;
6492 int header_done = 0;
6494 if (writebuf != NULL)
6496 if (readbuf == NULL)
6499 pid = lwpid_of (current_thread);
6500 xsnprintf (filename, sizeof filename, "/proc/%d/exe", pid);
6501 is_elf64 = elf_64_file_p (filename, &machine);
6502 lmo = is_elf64 ? &lmo_64bit_offsets : &lmo_32bit_offsets;
6503 ptr_size = is_elf64 ? 8 : 4;
6505 while (annex[0] != '\0')
6511 sep = strchr (annex, '=');
6516 if (len == 5 && startswith (annex, "start"))
6518 else if (len == 4 && startswith (annex, "prev"))
6522 annex = strchr (sep, ';');
6529 annex = decode_address_to_semicolon (addrp, sep + 1);
6536 if (priv->r_debug == 0)
6537 priv->r_debug = get_r_debug (pid, is_elf64);
6539 /* We failed to find DT_DEBUG. Such situation will not change
6540 for this inferior - do not retry it. Report it to GDB as
6541 E01, see for the reasons at the GDB solib-svr4.c side. */
6542 if (priv->r_debug == (CORE_ADDR) -1)
6545 if (priv->r_debug != 0)
6547 if (linux_read_memory (priv->r_debug + lmo->r_version_offset,
6548 (unsigned char *) &r_version,
6549 sizeof (r_version)) != 0
6552 warning ("unexpected r_debug version %d", r_version);
6554 else if (read_one_ptr (priv->r_debug + lmo->r_map_offset,
6555 &lm_addr, ptr_size) != 0)
6557 warning ("unable to read r_map from 0x%lx",
6558 (long) priv->r_debug + lmo->r_map_offset);
6563 document = xmalloc (allocated);
6564 strcpy (document, "<library-list-svr4 version=\"1.0\"");
6565 p = document + strlen (document);
6568 && read_one_ptr (lm_addr + lmo->l_name_offset,
6569 &l_name, ptr_size) == 0
6570 && read_one_ptr (lm_addr + lmo->l_addr_offset,
6571 &l_addr, ptr_size) == 0
6572 && read_one_ptr (lm_addr + lmo->l_ld_offset,
6573 &l_ld, ptr_size) == 0
6574 && read_one_ptr (lm_addr + lmo->l_prev_offset,
6575 &l_prev, ptr_size) == 0
6576 && read_one_ptr (lm_addr + lmo->l_next_offset,
6577 &l_next, ptr_size) == 0)
6579 unsigned char libname[PATH_MAX];
6581 if (lm_prev != l_prev)
6583 warning ("Corrupted shared library list: 0x%lx != 0x%lx",
6584 (long) lm_prev, (long) l_prev);
6588 /* Ignore the first entry even if it has valid name as the first entry
6589 corresponds to the main executable. The first entry should not be
6590 skipped if the dynamic loader was loaded late by a static executable
6591 (see solib-svr4.c parameter ignore_first). But in such case the main
6592 executable does not have PT_DYNAMIC present and this function already
6593 exited above due to failed get_r_debug. */
6596 sprintf (p, " main-lm=\"0x%lx\"", (unsigned long) lm_addr);
6601 /* Not checking for error because reading may stop before
6602 we've got PATH_MAX worth of characters. */
6604 linux_read_memory (l_name, libname, sizeof (libname) - 1);
6605 libname[sizeof (libname) - 1] = '\0';
6606 if (libname[0] != '\0')
6608 /* 6x the size for xml_escape_text below. */
6609 size_t len = 6 * strlen ((char *) libname);
6614 /* Terminate `<library-list-svr4'. */
6619 while (allocated < p - document + len + 200)
6621 /* Expand to guarantee sufficient storage. */
6622 uintptr_t document_len = p - document;
6624 document = xrealloc (document, 2 * allocated);
6626 p = document + document_len;
6629 name = xml_escape_text ((char *) libname);
6630 p += sprintf (p, "<library name=\"%s\" lm=\"0x%lx\" "
6631 "l_addr=\"0x%lx\" l_ld=\"0x%lx\"/>",
6632 name, (unsigned long) lm_addr,
6633 (unsigned long) l_addr, (unsigned long) l_ld);
6644 /* Empty list; terminate `<library-list-svr4'. */
6648 strcpy (p, "</library-list-svr4>");
6650 document_len = strlen (document);
6651 if (offset < document_len)
6652 document_len -= offset;
6655 if (len > document_len)
6658 memcpy (readbuf, document + offset, len);
6664 #ifdef HAVE_LINUX_BTRACE
6666 /* See to_disable_btrace target method. */
6669 linux_low_disable_btrace (struct btrace_target_info *tinfo)
6671 enum btrace_error err;
6673 err = linux_disable_btrace (tinfo);
6674 return (err == BTRACE_ERR_NONE ? 0 : -1);
6677 /* Encode an Intel(R) Processor Trace configuration. */
6680 linux_low_encode_pt_config (struct buffer *buffer,
6681 const struct btrace_data_pt_config *config)
6683 buffer_grow_str (buffer, "<pt-config>\n");
6685 switch (config->cpu.vendor)
6688 buffer_xml_printf (buffer, "<cpu vendor=\"GenuineIntel\" family=\"%u\" "
6689 "model=\"%u\" stepping=\"%u\"/>\n",
6690 config->cpu.family, config->cpu.model,
6691 config->cpu.stepping);
6698 buffer_grow_str (buffer, "</pt-config>\n");
6701 /* Encode a raw buffer. */
6704 linux_low_encode_raw (struct buffer *buffer, const gdb_byte *data,
6710 /* We use hex encoding - see common/rsp-low.h. */
6711 buffer_grow_str (buffer, "<raw>\n");
6717 elem[0] = tohex ((*data >> 4) & 0xf);
6718 elem[1] = tohex (*data++ & 0xf);
6720 buffer_grow (buffer, elem, 2);
6723 buffer_grow_str (buffer, "</raw>\n");
6726 /* See to_read_btrace target method. */
6729 linux_low_read_btrace (struct btrace_target_info *tinfo, struct buffer *buffer,
6732 struct btrace_data btrace;
6733 struct btrace_block *block;
6734 enum btrace_error err;
6737 btrace_data_init (&btrace);
6739 err = linux_read_btrace (&btrace, tinfo, type);
6740 if (err != BTRACE_ERR_NONE)
6742 if (err == BTRACE_ERR_OVERFLOW)
6743 buffer_grow_str0 (buffer, "E.Overflow.");
6745 buffer_grow_str0 (buffer, "E.Generic Error.");
6750 switch (btrace.format)
6752 case BTRACE_FORMAT_NONE:
6753 buffer_grow_str0 (buffer, "E.No Trace.");
6756 case BTRACE_FORMAT_BTS:
6757 buffer_grow_str (buffer, "<!DOCTYPE btrace SYSTEM \"btrace.dtd\">\n");
6758 buffer_grow_str (buffer, "<btrace version=\"1.0\">\n");
6761 VEC_iterate (btrace_block_s, btrace.variant.bts.blocks, i, block);
6763 buffer_xml_printf (buffer, "<block begin=\"0x%s\" end=\"0x%s\"/>\n",
6764 paddress (block->begin), paddress (block->end));
6766 buffer_grow_str0 (buffer, "</btrace>\n");
6769 case BTRACE_FORMAT_PT:
6770 buffer_grow_str (buffer, "<!DOCTYPE btrace SYSTEM \"btrace.dtd\">\n");
6771 buffer_grow_str (buffer, "<btrace version=\"1.0\">\n");
6772 buffer_grow_str (buffer, "<pt>\n");
6774 linux_low_encode_pt_config (buffer, &btrace.variant.pt.config);
6776 linux_low_encode_raw (buffer, btrace.variant.pt.data,
6777 btrace.variant.pt.size);
6779 buffer_grow_str (buffer, "</pt>\n");
6780 buffer_grow_str0 (buffer, "</btrace>\n");
6784 buffer_grow_str0 (buffer, "E.Unsupported Trace Format.");
6788 btrace_data_fini (&btrace);
6792 btrace_data_fini (&btrace);
6796 /* See to_btrace_conf target method. */
6799 linux_low_btrace_conf (const struct btrace_target_info *tinfo,
6800 struct buffer *buffer)
6802 const struct btrace_config *conf;
6804 buffer_grow_str (buffer, "<!DOCTYPE btrace-conf SYSTEM \"btrace-conf.dtd\">\n");
6805 buffer_grow_str (buffer, "<btrace-conf version=\"1.0\">\n");
6807 conf = linux_btrace_conf (tinfo);
6810 switch (conf->format)
6812 case BTRACE_FORMAT_NONE:
6815 case BTRACE_FORMAT_BTS:
6816 buffer_xml_printf (buffer, "<bts");
6817 buffer_xml_printf (buffer, " size=\"0x%x\"", conf->bts.size);
6818 buffer_xml_printf (buffer, " />\n");
6821 case BTRACE_FORMAT_PT:
6822 buffer_xml_printf (buffer, "<pt");
6823 buffer_xml_printf (buffer, " size=\"0x%x\"", conf->pt.size);
6824 buffer_xml_printf (buffer, "/>\n");
6829 buffer_grow_str0 (buffer, "</btrace-conf>\n");
6832 #endif /* HAVE_LINUX_BTRACE */
6834 /* See nat/linux-nat.h. */
6837 current_lwp_ptid (void)
6839 return ptid_of (current_thread);
6842 static struct target_ops linux_target_ops = {
6843 linux_create_inferior,
6853 linux_fetch_registers,
6854 linux_store_registers,
6855 linux_prepare_to_access_memory,
6856 linux_done_accessing_memory,
6859 linux_look_up_symbols,
6860 linux_request_interrupt,
6862 linux_supports_z_point_type,
6865 linux_stopped_by_sw_breakpoint,
6866 linux_supports_stopped_by_sw_breakpoint,
6867 linux_stopped_by_hw_breakpoint,
6868 linux_supports_stopped_by_hw_breakpoint,
6869 linux_supports_conditional_breakpoints,
6870 linux_stopped_by_watchpoint,
6871 linux_stopped_data_address,
6872 #if defined(__UCLIBC__) && defined(HAS_NOMMU) \
6873 && defined(PT_TEXT_ADDR) && defined(PT_DATA_ADDR) \
6874 && defined(PT_TEXT_END_ADDR)
6879 #ifdef USE_THREAD_DB
6880 thread_db_get_tls_address,
6885 hostio_last_error_from_errno,
6888 linux_supports_non_stop,
6890 linux_start_non_stop,
6891 linux_supports_multi_process,
6892 linux_supports_fork_events,
6893 linux_supports_vfork_events,
6894 linux_handle_new_gdb_connection,
6895 #ifdef USE_THREAD_DB
6896 thread_db_handle_monitor_command,
6900 linux_common_core_of_thread,
6902 linux_process_qsupported,
6903 linux_supports_tracepoints,
6906 linux_thread_stopped,
6910 linux_stabilize_threads,
6911 linux_install_fast_tracepoint_jump_pad,
6913 linux_supports_disable_randomization,
6914 linux_get_min_fast_tracepoint_insn_len,
6915 linux_qxfer_libraries_svr4,
6916 linux_supports_agent,
6917 #ifdef HAVE_LINUX_BTRACE
6918 linux_supports_btrace,
6919 linux_enable_btrace,
6920 linux_low_disable_btrace,
6921 linux_low_read_btrace,
6922 linux_low_btrace_conf,
6930 linux_supports_range_stepping,
6931 linux_proc_pid_to_exec_file,
6932 linux_mntns_open_cloexec,
6934 linux_mntns_readlink,
6938 linux_init_signals ()
6940 /* FIXME drow/2002-06-09: As above, we should check with LinuxThreads
6941 to find what the cancel signal actually is. */
6942 #ifndef __ANDROID__ /* Bionic doesn't use SIGRTMIN the way glibc does. */
6943 signal (__SIGRTMIN+1, SIG_IGN);
6947 #ifdef HAVE_LINUX_REGSETS
6949 initialize_regsets_info (struct regsets_info *info)
6951 for (info->num_regsets = 0;
6952 info->regsets[info->num_regsets].size >= 0;
6953 info->num_regsets++)
6959 initialize_low (void)
6961 struct sigaction sigchld_action;
6962 memset (&sigchld_action, 0, sizeof (sigchld_action));
6963 set_target_ops (&linux_target_ops);
6964 set_breakpoint_data (the_low_target.breakpoint,
6965 the_low_target.breakpoint_len);
6966 linux_init_signals ();
6967 linux_ptrace_init_warnings ();
6969 sigchld_action.sa_handler = sigchld_handler;
6970 sigemptyset (&sigchld_action.sa_mask);
6971 sigchld_action.sa_flags = SA_RESTART;
6972 sigaction (SIGCHLD, &sigchld_action, NULL);
6974 initialize_low_arch ();
6976 linux_check_ptrace_features ();