1 /* Low level interface to ptrace, for the remote server for GDB.
2 Copyright (C) 1995, 1996, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005,
3 2006, 2007, 2008, 2009 Free Software Foundation, Inc.
5 This file is part of GDB.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program. If not, see <http://www.gnu.org/licenses/>. */
21 #include "linux-low.h"
22 #include "ansidecl.h" /* For ATTRIBUTE_PACKED, must be bug in external.h. */
23 #include "elf/common.h"
24 #include "elf/external.h"
28 #include <sys/param.h>
29 #include <sys/ptrace.h>
31 #include <sys/ioctl.h>
37 #include <sys/syscall.h>
41 #include <sys/types.h>
47 #define SPUFS_MAGIC 0x23c9b64e
50 #ifndef PTRACE_GETSIGINFO
51 # define PTRACE_GETSIGINFO 0x4202
52 # define PTRACE_SETSIGINFO 0x4203
59 /* If the system headers did not provide the constants, hard-code the normal
61 #ifndef PTRACE_EVENT_FORK
63 #define PTRACE_SETOPTIONS 0x4200
64 #define PTRACE_GETEVENTMSG 0x4201
66 /* options set using PTRACE_SETOPTIONS */
67 #define PTRACE_O_TRACESYSGOOD 0x00000001
68 #define PTRACE_O_TRACEFORK 0x00000002
69 #define PTRACE_O_TRACEVFORK 0x00000004
70 #define PTRACE_O_TRACECLONE 0x00000008
71 #define PTRACE_O_TRACEEXEC 0x00000010
72 #define PTRACE_O_TRACEVFORKDONE 0x00000020
73 #define PTRACE_O_TRACEEXIT 0x00000040
75 /* Wait extended result codes for the above trace options. */
76 #define PTRACE_EVENT_FORK 1
77 #define PTRACE_EVENT_VFORK 2
78 #define PTRACE_EVENT_CLONE 3
79 #define PTRACE_EVENT_EXEC 4
80 #define PTRACE_EVENT_VFORK_DONE 5
81 #define PTRACE_EVENT_EXIT 6
83 #endif /* PTRACE_EVENT_FORK */
85 /* We can't always assume that this flag is available, but all systems
86 with the ptrace event handlers also have __WALL, so it's safe to use
89 #define __WALL 0x40000000 /* Wait for any child. */
93 #if !(defined(__UCLIBC_HAS_MMU__) || defined(__ARCH_HAS_MMU__))
98 /* ``all_threads'' is keyed by the LWP ID, which we use as the GDB protocol
99 representation of the thread ID.
101 ``all_lwps'' is keyed by the process ID - which on Linux is (presently)
102 the same as the LWP ID.
104 ``all_processes'' is keyed by the "overall process ID", which
105 GNU/Linux calls tgid, "thread group ID". */
107 struct inferior_list all_lwps
;
109 /* A list of all unknown processes which receive stop signals. Some other
110 process will presumably claim each of these as forked children
113 struct inferior_list stopped_pids
;
115 /* FIXME this is a bit of a hack, and could be removed. */
116 int stopping_threads
;
118 /* FIXME make into a target method? */
119 int using_threads
= 1;
121 /* This flag is true iff we've just created or attached to our first
122 inferior but it has not stopped yet. As soon as it does, we need
123 to call the low target's arch_setup callback. Doing this only on
124 the first inferior avoids reinializing the architecture on every
125 inferior, and avoids messing with the register caches of the
126 already running inferiors. NOTE: this assumes all inferiors under
127 control of gdbserver have the same architecture. */
128 static int new_inferior
;
130 static void linux_resume_one_lwp (struct lwp_info
*lwp
,
131 int step
, int signal
, siginfo_t
*info
);
132 static void linux_resume (struct thread_resume
*resume_info
, size_t n
);
133 static void stop_all_lwps (void);
134 static int linux_wait_for_event (ptid_t ptid
, int *wstat
, int options
);
135 static int check_removed_breakpoint (struct lwp_info
*event_child
);
136 static void *add_lwp (ptid_t ptid
);
137 static int my_waitpid (int pid
, int *status
, int flags
);
138 static int linux_stopped_by_watchpoint (void);
139 static void mark_lwp_dead (struct lwp_info
*lwp
, int wstat
);
141 struct pending_signals
145 struct pending_signals
*prev
;
148 #define PTRACE_ARG3_TYPE long
149 #define PTRACE_XFER_TYPE long
151 #ifdef HAVE_LINUX_REGSETS
152 static char *disabled_regsets
;
153 static int num_regsets
;
156 /* The read/write ends of the pipe registered as waitable file in the
158 static int linux_event_pipe
[2] = { -1, -1 };
160 /* True if we're currently in async mode. */
161 #define target_is_async_p() (linux_event_pipe[0] != -1)
163 static void send_sigstop (struct inferior_list_entry
*entry
);
164 static void wait_for_sigstop (struct inferior_list_entry
*entry
);
166 /* Accepts an integer PID; Returns a string representing a file that
167 can be opened to get info for the child process.
168 Space for the result is malloc'd, caller must free. */
171 linux_child_pid_to_exec_file (int pid
)
175 name1
= xmalloc (MAXPATHLEN
);
176 name2
= xmalloc (MAXPATHLEN
);
177 memset (name2
, 0, MAXPATHLEN
);
179 sprintf (name1
, "/proc/%d/exe", pid
);
180 if (readlink (name1
, name2
, MAXPATHLEN
) > 0)
192 /* Return non-zero if HEADER is a 64-bit ELF file. */
195 elf_64_header_p (const Elf64_External_Ehdr
*header
)
197 return (header
->e_ident
[EI_MAG0
] == ELFMAG0
198 && header
->e_ident
[EI_MAG1
] == ELFMAG1
199 && header
->e_ident
[EI_MAG2
] == ELFMAG2
200 && header
->e_ident
[EI_MAG3
] == ELFMAG3
201 && header
->e_ident
[EI_CLASS
] == ELFCLASS64
);
204 /* Return non-zero if FILE is a 64-bit ELF file,
205 zero if the file is not a 64-bit ELF file,
206 and -1 if the file is not accessible or doesn't exist. */
209 elf_64_file_p (const char *file
)
211 Elf64_External_Ehdr header
;
214 fd
= open (file
, O_RDONLY
);
218 if (read (fd
, &header
, sizeof (header
)) != sizeof (header
))
225 return elf_64_header_p (&header
);
229 delete_lwp (struct lwp_info
*lwp
)
231 remove_thread (get_lwp_thread (lwp
));
232 remove_inferior (&all_lwps
, &lwp
->head
);
233 free (lwp
->arch_private
);
237 /* Add a process to the common process list, and set its private
240 static struct process_info
*
241 linux_add_process (int pid
, int attached
)
243 struct process_info
*proc
;
245 /* Is this the first process? If so, then set the arch. */
246 if (all_processes
.head
== NULL
)
249 proc
= add_process (pid
, attached
);
250 proc
->private = xcalloc (1, sizeof (*proc
->private));
252 if (the_low_target
.new_process
!= NULL
)
253 proc
->private->arch_private
= the_low_target
.new_process ();
258 /* Remove a process from the common process list,
259 also freeing all private data. */
262 linux_remove_process (struct process_info
*process
, int detaching
)
264 struct process_info_private
*priv
= process
->private;
267 thread_db_free (process
, detaching
);
270 free (priv
->arch_private
);
272 remove_process (process
);
275 /* Wrapper function for waitpid which handles EINTR, and emulates
276 __WALL for systems where that is not available. */
279 my_waitpid (int pid
, int *status
, int flags
)
284 fprintf (stderr
, "my_waitpid (%d, 0x%x)\n", pid
, flags
);
288 sigset_t block_mask
, org_mask
, wake_mask
;
291 wnohang
= (flags
& WNOHANG
) != 0;
292 flags
&= ~(__WALL
| __WCLONE
);
295 /* Block all signals while here. This avoids knowing about
296 LinuxThread's signals. */
297 sigfillset (&block_mask
);
298 sigprocmask (SIG_BLOCK
, &block_mask
, &org_mask
);
300 /* ... except during the sigsuspend below. */
301 sigemptyset (&wake_mask
);
305 /* Since all signals are blocked, there's no need to check
307 ret
= waitpid (pid
, status
, flags
);
310 if (ret
== -1 && out_errno
!= ECHILD
)
315 if (flags
& __WCLONE
)
317 /* We've tried both flavors now. If WNOHANG is set,
318 there's nothing else to do, just bail out. */
323 fprintf (stderr
, "blocking\n");
325 /* Block waiting for signals. */
326 sigsuspend (&wake_mask
);
332 sigprocmask (SIG_SETMASK
, &org_mask
, NULL
);
337 ret
= waitpid (pid
, status
, flags
);
338 while (ret
== -1 && errno
== EINTR
);
343 fprintf (stderr
, "my_waitpid (%d, 0x%x): status(%x), %d\n",
344 pid
, flags
, status
? *status
: -1, ret
);
350 /* Handle a GNU/Linux extended wait response. If we see a clone
351 event, we need to add the new LWP to our list (and not report the
352 trap to higher layers). */
355 handle_extended_wait (struct lwp_info
*event_child
, int wstat
)
357 int event
= wstat
>> 16;
358 struct lwp_info
*new_lwp
;
360 if (event
== PTRACE_EVENT_CLONE
)
363 unsigned long new_pid
;
364 int ret
, status
= W_STOPCODE (SIGSTOP
);
366 ptrace (PTRACE_GETEVENTMSG
, lwpid_of (event_child
), 0, &new_pid
);
368 /* If we haven't already seen the new PID stop, wait for it now. */
369 if (! pull_pid_from_list (&stopped_pids
, new_pid
))
371 /* The new child has a pending SIGSTOP. We can't affect it until it
372 hits the SIGSTOP, but we're already attached. */
374 ret
= my_waitpid (new_pid
, &status
, __WALL
);
377 perror_with_name ("waiting for new child");
378 else if (ret
!= new_pid
)
379 warning ("wait returned unexpected PID %d", ret
);
380 else if (!WIFSTOPPED (status
))
381 warning ("wait returned unexpected status 0x%x", status
);
384 ptrace (PTRACE_SETOPTIONS
, new_pid
, 0, PTRACE_O_TRACECLONE
);
386 ptid
= ptid_build (pid_of (event_child
), new_pid
, 0);
387 new_lwp
= (struct lwp_info
*) add_lwp (ptid
);
388 add_thread (ptid
, new_lwp
);
390 /* Either we're going to immediately resume the new thread
391 or leave it stopped. linux_resume_one_lwp is a nop if it
392 thinks the thread is currently running, so set this first
393 before calling linux_resume_one_lwp. */
394 new_lwp
->stopped
= 1;
396 /* Normally we will get the pending SIGSTOP. But in some cases
397 we might get another signal delivered to the group first.
398 If we do get another signal, be sure not to lose it. */
399 if (WSTOPSIG (status
) == SIGSTOP
)
401 if (! stopping_threads
)
402 linux_resume_one_lwp (new_lwp
, 0, 0, NULL
);
406 new_lwp
->stop_expected
= 1;
407 if (stopping_threads
)
409 new_lwp
->status_pending_p
= 1;
410 new_lwp
->status_pending
= status
;
413 /* Pass the signal on. This is what GDB does - except
414 shouldn't we really report it instead? */
415 linux_resume_one_lwp (new_lwp
, 0, WSTOPSIG (status
), NULL
);
418 /* Always resume the current thread. If we are stopping
419 threads, it will have a pending SIGSTOP; we may as well
421 linux_resume_one_lwp (event_child
, event_child
->stepping
, 0, NULL
);
425 /* This function should only be called if the process got a SIGTRAP.
426 The SIGTRAP could mean several things.
428 On i386, where decr_pc_after_break is non-zero:
429 If we were single-stepping this process using PTRACE_SINGLESTEP,
430 we will get only the one SIGTRAP (even if the instruction we
431 stepped over was a breakpoint). The value of $eip will be the
433 If we continue the process using PTRACE_CONT, we will get a
434 SIGTRAP when we hit a breakpoint. The value of $eip will be
435 the instruction after the breakpoint (i.e. needs to be
436 decremented). If we report the SIGTRAP to GDB, we must also
437 report the undecremented PC. If we cancel the SIGTRAP, we
438 must resume at the decremented PC.
440 (Presumably, not yet tested) On a non-decr_pc_after_break machine
441 with hardware or kernel single-step:
442 If we single-step over a breakpoint instruction, our PC will
443 point at the following instruction. If we continue and hit a
444 breakpoint instruction, our PC will point at the breakpoint
450 CORE_ADDR stop_pc
= (*the_low_target
.get_pc
) ();
452 if (! get_thread_lwp (current_inferior
)->stepping
)
453 stop_pc
-= the_low_target
.decr_pc_after_break
;
456 fprintf (stderr
, "stop pc is 0x%lx\n", (long) stop_pc
);
462 add_lwp (ptid_t ptid
)
464 struct lwp_info
*lwp
;
466 lwp
= (struct lwp_info
*) xmalloc (sizeof (*lwp
));
467 memset (lwp
, 0, sizeof (*lwp
));
471 if (the_low_target
.new_thread
!= NULL
)
472 lwp
->arch_private
= the_low_target
.new_thread ();
474 add_inferior_to_list (&all_lwps
, &lwp
->head
);
479 /* Start an inferior process and returns its pid.
480 ALLARGS is a vector of program-name and args. */
483 linux_create_inferior (char *program
, char **allargs
)
485 struct lwp_info
*new_lwp
;
489 #if defined(__UCLIBC__) && defined(HAS_NOMMU)
495 perror_with_name ("fork");
499 ptrace (PTRACE_TRACEME
, 0, 0, 0);
501 signal (__SIGRTMIN
+ 1, SIG_DFL
);
505 execv (program
, allargs
);
507 execvp (program
, allargs
);
509 fprintf (stderr
, "Cannot exec %s: %s.\n", program
,
515 linux_add_process (pid
, 0);
517 ptid
= ptid_build (pid
, pid
, 0);
518 new_lwp
= add_lwp (ptid
);
519 add_thread (ptid
, new_lwp
);
520 new_lwp
->must_set_ptrace_flags
= 1;
525 /* Attach to an inferior process. */
528 linux_attach_lwp_1 (unsigned long lwpid
, int initial
)
531 struct lwp_info
*new_lwp
;
533 if (ptrace (PTRACE_ATTACH
, lwpid
, 0, 0) != 0)
537 /* If we fail to attach to an LWP, just warn. */
538 fprintf (stderr
, "Cannot attach to lwp %ld: %s (%d)\n", lwpid
,
539 strerror (errno
), errno
);
544 /* If we fail to attach to a process, report an error. */
545 error ("Cannot attach to lwp %ld: %s (%d)\n", lwpid
,
546 strerror (errno
), errno
);
550 /* NOTE/FIXME: This lwp might have not been the tgid. */
551 ptid
= ptid_build (lwpid
, lwpid
, 0);
554 /* Note that extracting the pid from the current inferior is
555 safe, since we're always called in the context of the same
556 process as this new thread. */
557 int pid
= pid_of (get_thread_lwp (current_inferior
));
558 ptid
= ptid_build (pid
, lwpid
, 0);
561 new_lwp
= (struct lwp_info
*) add_lwp (ptid
);
562 add_thread (ptid
, new_lwp
);
564 /* We need to wait for SIGSTOP before being able to make the next
565 ptrace call on this LWP. */
566 new_lwp
->must_set_ptrace_flags
= 1;
568 /* The next time we wait for this LWP we'll see a SIGSTOP as PTRACE_ATTACH
571 There are several cases to consider here:
573 1) gdbserver has already attached to the process and is being notified
574 of a new thread that is being created.
575 In this case we should ignore that SIGSTOP and resume the process.
576 This is handled below by setting stop_expected = 1.
578 2) This is the first thread (the process thread), and we're attaching
579 to it via attach_inferior.
580 In this case we want the process thread to stop.
581 This is handled by having linux_attach clear stop_expected after
583 ??? If the process already has several threads we leave the other
586 3) GDB is connecting to gdbserver and is requesting an enumeration of all
588 In this case we want the thread to stop.
589 FIXME: This case is currently not properly handled.
590 We should wait for the SIGSTOP but don't. Things work apparently
591 because enough time passes between when we ptrace (ATTACH) and when
592 gdb makes the next ptrace call on the thread.
594 On the other hand, if we are currently trying to stop all threads, we
595 should treat the new thread as if we had sent it a SIGSTOP. This works
596 because we are guaranteed that the add_lwp call above added us to the
597 end of the list, and so the new thread has not yet reached
598 wait_for_sigstop (but will). */
599 if (! stopping_threads
)
600 new_lwp
->stop_expected
= 1;
604 linux_attach_lwp (unsigned long lwpid
)
606 linux_attach_lwp_1 (lwpid
, 0);
610 linux_attach (unsigned long pid
)
612 struct lwp_info
*lwp
;
614 linux_attach_lwp_1 (pid
, 1);
616 linux_add_process (pid
, 1);
620 /* Don't ignore the initial SIGSTOP if we just attached to this
621 process. It will be collected by wait shortly. */
622 lwp
= (struct lwp_info
*) find_inferior_id (&all_lwps
,
623 ptid_build (pid
, pid
, 0));
624 lwp
->stop_expected
= 0;
637 second_thread_of_pid_p (struct inferior_list_entry
*entry
, void *args
)
639 struct counter
*counter
= args
;
641 if (ptid_get_pid (entry
->id
) == counter
->pid
)
643 if (++counter
->count
> 1)
651 last_thread_of_process_p (struct thread_info
*thread
)
653 ptid_t ptid
= ((struct inferior_list_entry
*)thread
)->id
;
654 int pid
= ptid_get_pid (ptid
);
655 struct counter counter
= { pid
, 0 };
657 return (find_inferior (&all_threads
,
658 second_thread_of_pid_p
, &counter
) == NULL
);
661 /* Kill the inferior lwp. */
664 linux_kill_one_lwp (struct inferior_list_entry
*entry
, void *args
)
666 struct thread_info
*thread
= (struct thread_info
*) entry
;
667 struct lwp_info
*lwp
= get_thread_lwp (thread
);
669 int pid
= * (int *) args
;
671 if (ptid_get_pid (entry
->id
) != pid
)
674 /* We avoid killing the first thread here, because of a Linux kernel (at
675 least 2.6.0-test7 through 2.6.8-rc4) bug; if we kill the parent before
676 the children get a chance to be reaped, it will remain a zombie
679 if (lwpid_of (lwp
) == pid
)
682 fprintf (stderr
, "lkop: is last of process %s\n",
683 target_pid_to_str (entry
->id
));
687 /* If we're killing a running inferior, make sure it is stopped
688 first, as PTRACE_KILL will not work otherwise. */
690 send_sigstop (&lwp
->head
);
694 ptrace (PTRACE_KILL
, lwpid_of (lwp
), 0, 0);
696 /* Make sure it died. The loop is most likely unnecessary. */
697 pid
= linux_wait_for_event (lwp
->head
.id
, &wstat
, __WALL
);
698 } while (pid
> 0 && WIFSTOPPED (wstat
));
706 struct process_info
*process
;
707 struct lwp_info
*lwp
;
708 struct thread_info
*thread
;
712 process
= find_process_pid (pid
);
716 find_inferior (&all_threads
, linux_kill_one_lwp
, &pid
);
718 /* See the comment in linux_kill_one_lwp. We did not kill the first
719 thread in the list, so do so now. */
720 lwp
= find_lwp_pid (pid_to_ptid (pid
));
721 thread
= get_lwp_thread (lwp
);
724 fprintf (stderr
, "lk_1: killing lwp %ld, for pid: %d\n",
725 lwpid_of (lwp
), pid
);
727 /* If we're killing a running inferior, make sure it is stopped
728 first, as PTRACE_KILL will not work otherwise. */
730 send_sigstop (&lwp
->head
);
734 ptrace (PTRACE_KILL
, lwpid_of (lwp
), 0, 0);
736 /* Make sure it died. The loop is most likely unnecessary. */
737 lwpid
= linux_wait_for_event (lwp
->head
.id
, &wstat
, __WALL
);
738 } while (lwpid
> 0 && WIFSTOPPED (wstat
));
741 linux_remove_process (process
, 0);
746 linux_detach_one_lwp (struct inferior_list_entry
*entry
, void *args
)
748 struct thread_info
*thread
= (struct thread_info
*) entry
;
749 struct lwp_info
*lwp
= get_thread_lwp (thread
);
750 int pid
= * (int *) args
;
752 if (ptid_get_pid (entry
->id
) != pid
)
755 /* If we're detaching from a running inferior, make sure it is
756 stopped first, as PTRACE_DETACH will not work otherwise. */
759 int lwpid
= lwpid_of (lwp
);
761 stopping_threads
= 1;
762 send_sigstop (&lwp
->head
);
764 /* If this detects a new thread through a clone event, the new
765 thread is appended to the end of the lwp list, so we'll
766 eventually detach from it. */
767 wait_for_sigstop (&lwp
->head
);
768 stopping_threads
= 0;
770 /* If LWP exits while we're trying to stop it, there's nothing
772 lwp
= find_lwp_pid (pid_to_ptid (lwpid
));
777 /* Make sure the process isn't stopped at a breakpoint that's
779 check_removed_breakpoint (lwp
);
781 /* If this process is stopped but is expecting a SIGSTOP, then make
782 sure we take care of that now. This isn't absolutely guaranteed
783 to collect the SIGSTOP, but is fairly likely to. */
784 if (lwp
->stop_expected
)
787 /* Clear stop_expected, so that the SIGSTOP will be reported. */
788 lwp
->stop_expected
= 0;
790 linux_resume_one_lwp (lwp
, 0, 0, NULL
);
791 linux_wait_for_event (lwp
->head
.id
, &wstat
, __WALL
);
794 /* Flush any pending changes to the process's registers. */
795 regcache_invalidate_one ((struct inferior_list_entry
*)
796 get_lwp_thread (lwp
));
798 /* Finally, let it resume. */
799 ptrace (PTRACE_DETACH
, lwpid_of (lwp
), 0, 0);
806 any_thread_of (struct inferior_list_entry
*entry
, void *args
)
810 if (ptid_get_pid (entry
->id
) == *pid_p
)
817 linux_detach (int pid
)
819 struct process_info
*process
;
821 process
= find_process_pid (pid
);
826 (struct thread_info
*) find_inferior (&all_threads
, any_thread_of
, &pid
);
828 delete_all_breakpoints ();
829 find_inferior (&all_threads
, linux_detach_one_lwp
, &pid
);
830 linux_remove_process (process
, 1);
838 struct process_info
*process
;
840 process
= find_process_pid (pid
);
845 ret
= my_waitpid (pid
, &status
, 0);
846 if (WIFEXITED (status
) || WIFSIGNALED (status
))
848 } while (ret
!= -1 || errno
!= ECHILD
);
851 /* Return nonzero if the given thread is still alive. */
853 linux_thread_alive (ptid_t ptid
)
855 struct lwp_info
*lwp
= find_lwp_pid (ptid
);
857 /* We assume we always know if a thread exits. If a whole process
858 exited but we still haven't been able to report it to GDB, we'll
859 hold on to the last lwp of the dead process. */
866 /* Return nonzero if this process stopped at a breakpoint which
867 no longer appears to be inserted. Also adjust the PC
868 appropriately to resume where the breakpoint used to be. */
870 check_removed_breakpoint (struct lwp_info
*event_child
)
873 struct thread_info
*saved_inferior
;
875 if (event_child
->pending_is_breakpoint
== 0)
879 fprintf (stderr
, "Checking for breakpoint in lwp %ld.\n",
880 lwpid_of (event_child
));
882 saved_inferior
= current_inferior
;
883 current_inferior
= get_lwp_thread (event_child
);
885 stop_pc
= get_stop_pc ();
887 /* If the PC has changed since we stopped, then we shouldn't do
888 anything. This happens if, for instance, GDB handled the
889 decr_pc_after_break subtraction itself. */
890 if (stop_pc
!= event_child
->pending_stop_pc
)
893 fprintf (stderr
, "Ignoring, PC was changed. Old PC was 0x%08llx\n",
894 event_child
->pending_stop_pc
);
896 event_child
->pending_is_breakpoint
= 0;
897 current_inferior
= saved_inferior
;
901 /* If the breakpoint is still there, we will report hitting it. */
902 if ((*the_low_target
.breakpoint_at
) (stop_pc
))
905 fprintf (stderr
, "Ignoring, breakpoint is still present.\n");
906 current_inferior
= saved_inferior
;
911 fprintf (stderr
, "Removed breakpoint.\n");
913 /* For decr_pc_after_break targets, here is where we perform the
914 decrement. We go immediately from this function to resuming,
915 and can not safely call get_stop_pc () again. */
916 if (the_low_target
.set_pc
!= NULL
)
919 fprintf (stderr
, "Set pc to 0x%lx\n", (long) stop_pc
);
920 (*the_low_target
.set_pc
) (stop_pc
);
923 /* We consumed the pending SIGTRAP. */
924 event_child
->pending_is_breakpoint
= 0;
925 event_child
->status_pending_p
= 0;
926 event_child
->status_pending
= 0;
928 current_inferior
= saved_inferior
;
932 /* Return 1 if this lwp has an interesting status pending. This
933 function may silently resume an inferior lwp. */
935 status_pending_p (struct inferior_list_entry
*entry
, void *arg
)
937 struct lwp_info
*lwp
= (struct lwp_info
*) entry
;
938 ptid_t ptid
= * (ptid_t
*) arg
;
940 /* Check if we're only interested in events from a specific process
942 if (!ptid_equal (minus_one_ptid
, ptid
)
943 && ptid_get_pid (ptid
) != ptid_get_pid (lwp
->head
.id
))
946 if (lwp
->status_pending_p
&& !lwp
->suspended
)
947 if (check_removed_breakpoint (lwp
))
949 /* This thread was stopped at a breakpoint, and the breakpoint
950 is now gone. We were told to continue (or step...) all threads,
951 so GDB isn't trying to single-step past this breakpoint.
952 So instead of reporting the old SIGTRAP, pretend we got to
953 the breakpoint just after it was removed instead of just
954 before; resume the process. */
955 linux_resume_one_lwp (lwp
, 0, 0, NULL
);
959 return (lwp
->status_pending_p
&& !lwp
->suspended
);
963 same_lwp (struct inferior_list_entry
*entry
, void *data
)
965 ptid_t ptid
= *(ptid_t
*) data
;
968 if (ptid_get_lwp (ptid
) != 0)
969 lwp
= ptid_get_lwp (ptid
);
971 lwp
= ptid_get_pid (ptid
);
973 if (ptid_get_lwp (entry
->id
) == lwp
)
980 find_lwp_pid (ptid_t ptid
)
982 return (struct lwp_info
*) find_inferior (&all_lwps
, same_lwp
, &ptid
);
985 static struct lwp_info
*
986 linux_wait_for_lwp (ptid_t ptid
, int *wstatp
, int options
)
989 int to_wait_for
= -1;
990 struct lwp_info
*child
= NULL
;
993 fprintf (stderr
, "linux_wait_for_lwp: %s\n", target_pid_to_str (ptid
));
995 if (ptid_equal (ptid
, minus_one_ptid
))
996 to_wait_for
= -1; /* any child */
998 to_wait_for
= ptid_get_lwp (ptid
); /* this lwp only */
1004 ret
= my_waitpid (to_wait_for
, wstatp
, options
);
1005 if (ret
== 0 || (ret
== -1 && errno
== ECHILD
&& (options
& WNOHANG
)))
1008 perror_with_name ("waitpid");
1011 && (!WIFSTOPPED (*wstatp
)
1012 || (WSTOPSIG (*wstatp
) != 32
1013 && WSTOPSIG (*wstatp
) != 33)))
1014 fprintf (stderr
, "Got an event from %d (%x)\n", ret
, *wstatp
);
1016 child
= find_lwp_pid (pid_to_ptid (ret
));
1018 /* If we didn't find a process, one of two things presumably happened:
1019 - A process we started and then detached from has exited. Ignore it.
1020 - A process we are controlling has forked and the new child's stop
1021 was reported to us by the kernel. Save its PID. */
1022 if (child
== NULL
&& WIFSTOPPED (*wstatp
))
1024 add_pid_to_list (&stopped_pids
, ret
);
1027 else if (child
== NULL
)
1031 child
->pending_is_breakpoint
= 0;
1033 child
->last_status
= *wstatp
;
1035 /* Architecture-specific setup after inferior is running.
1036 This needs to happen after we have attached to the inferior
1037 and it is stopped for the first time, but before we access
1038 any inferior registers. */
1041 the_low_target
.arch_setup ();
1042 #ifdef HAVE_LINUX_REGSETS
1043 memset (disabled_regsets
, 0, num_regsets
);
1049 && WIFSTOPPED (*wstatp
)
1050 && the_low_target
.get_pc
!= NULL
)
1052 struct thread_info
*saved_inferior
= current_inferior
;
1055 current_inferior
= (struct thread_info
*)
1056 find_inferior_id (&all_threads
, child
->head
.id
);
1057 pc
= (*the_low_target
.get_pc
) ();
1058 fprintf (stderr
, "linux_wait_for_lwp: pc is 0x%lx\n", (long) pc
);
1059 current_inferior
= saved_inferior
;
1065 /* Wait for an event from child PID. If PID is -1, wait for any
1066 child. Store the stop status through the status pointer WSTAT.
1067 OPTIONS is passed to the waitpid call. Return 0 if no child stop
1068 event was found and OPTIONS contains WNOHANG. Return the PID of
1069 the stopped child otherwise. */
1072 linux_wait_for_event_1 (ptid_t ptid
, int *wstat
, int options
)
1075 struct lwp_info
*event_child
= NULL
;
1077 struct lwp_info
*requested_child
= NULL
;
1079 /* Check for a lwp with a pending status. */
1080 /* It is possible that the user changed the pending task's registers since
1081 it stopped. We correctly handle the change of PC if we hit a breakpoint
1082 (in check_removed_breakpoint); signals should be reported anyway. */
1084 if (ptid_equal (ptid
, minus_one_ptid
)
1085 || ptid_equal (pid_to_ptid (ptid_get_pid (ptid
)), ptid
))
1087 event_child
= (struct lwp_info
*)
1088 find_inferior (&all_lwps
, status_pending_p
, &ptid
);
1089 if (debug_threads
&& event_child
)
1090 fprintf (stderr
, "Got a pending child %ld\n", lwpid_of (event_child
));
1094 requested_child
= find_lwp_pid (ptid
);
1095 if (requested_child
->status_pending_p
1096 && !check_removed_breakpoint (requested_child
))
1097 event_child
= requested_child
;
1100 if (event_child
!= NULL
)
1103 fprintf (stderr
, "Got an event from pending child %ld (%04x)\n",
1104 lwpid_of (event_child
), event_child
->status_pending
);
1105 *wstat
= event_child
->status_pending
;
1106 event_child
->status_pending_p
= 0;
1107 event_child
->status_pending
= 0;
1108 current_inferior
= get_lwp_thread (event_child
);
1109 return lwpid_of (event_child
);
1112 /* We only enter this loop if no process has a pending wait status. Thus
1113 any action taken in response to a wait status inside this loop is
1114 responding as soon as we detect the status, not after any pending
1118 event_child
= linux_wait_for_lwp (ptid
, wstat
, options
);
1120 if ((options
& WNOHANG
) && event_child
== NULL
)
1123 if (event_child
== NULL
)
1124 error ("event from unknown child");
1126 current_inferior
= get_lwp_thread (event_child
);
1128 /* Check for thread exit. */
1129 if (! WIFSTOPPED (*wstat
))
1132 fprintf (stderr
, "LWP %ld exiting\n", lwpid_of (event_child
));
1134 /* If the last thread is exiting, just return. */
1135 if (last_thread_of_process_p (current_inferior
))
1138 fprintf (stderr
, "LWP %ld is last lwp of process\n",
1139 lwpid_of (event_child
));
1140 return lwpid_of (event_child
);
1143 delete_lwp (event_child
);
1147 current_inferior
= (struct thread_info
*) all_threads
.head
;
1149 fprintf (stderr
, "Current inferior is now %ld\n",
1150 lwpid_of (get_thread_lwp (current_inferior
)));
1154 current_inferior
= NULL
;
1156 fprintf (stderr
, "Current inferior is now <NULL>\n");
1159 /* If we were waiting for this particular child to do something...
1160 well, it did something. */
1161 if (requested_child
!= NULL
)
1162 return lwpid_of (event_child
);
1164 /* Wait for a more interesting event. */
1168 if (event_child
->must_set_ptrace_flags
)
1170 ptrace (PTRACE_SETOPTIONS
, lwpid_of (event_child
),
1171 0, PTRACE_O_TRACECLONE
);
1172 event_child
->must_set_ptrace_flags
= 0;
1175 if (WIFSTOPPED (*wstat
)
1176 && WSTOPSIG (*wstat
) == SIGSTOP
1177 && event_child
->stop_expected
)
1180 fprintf (stderr
, "Expected stop.\n");
1181 event_child
->stop_expected
= 0;
1182 linux_resume_one_lwp (event_child
, event_child
->stepping
, 0, NULL
);
1186 if (WIFSTOPPED (*wstat
) && WSTOPSIG (*wstat
) == SIGTRAP
1187 && *wstat
>> 16 != 0)
1189 handle_extended_wait (event_child
, *wstat
);
1193 /* If GDB is not interested in this signal, don't stop other
1194 threads, and don't report it to GDB. Just resume the
1195 inferior right away. We do this for threading-related
1196 signals as well as any that GDB specifically requested we
1197 ignore. But never ignore SIGSTOP if we sent it ourselves,
1198 and do not ignore signals when stepping - they may require
1199 special handling to skip the signal handler. */
1200 /* FIXME drow/2002-06-09: Get signal numbers from the inferior's
1202 if (WIFSTOPPED (*wstat
)
1203 && !event_child
->stepping
1205 #ifdef USE_THREAD_DB
1206 (current_process ()->private->thread_db
!= NULL
1207 && (WSTOPSIG (*wstat
) == __SIGRTMIN
1208 || WSTOPSIG (*wstat
) == __SIGRTMIN
+ 1))
1211 (pass_signals
[target_signal_from_host (WSTOPSIG (*wstat
))]
1212 && (WSTOPSIG (*wstat
) != SIGSTOP
|| !stopping_threads
))))
1214 siginfo_t info
, *info_p
;
1217 fprintf (stderr
, "Ignored signal %d for LWP %ld.\n",
1218 WSTOPSIG (*wstat
), lwpid_of (event_child
));
1220 if (ptrace (PTRACE_GETSIGINFO
, lwpid_of (event_child
), 0, &info
) == 0)
1224 linux_resume_one_lwp (event_child
,
1225 event_child
->stepping
,
1226 WSTOPSIG (*wstat
), info_p
);
1230 /* If this event was not handled above, and is not a SIGTRAP, report
1232 if (!WIFSTOPPED (*wstat
) || WSTOPSIG (*wstat
) != SIGTRAP
)
1233 return lwpid_of (event_child
);
1235 /* If this target does not support breakpoints, we simply report the
1236 SIGTRAP; it's of no concern to us. */
1237 if (the_low_target
.get_pc
== NULL
)
1238 return lwpid_of (event_child
);
1240 stop_pc
= get_stop_pc ();
1242 /* bp_reinsert will only be set if we were single-stepping.
1243 Notice that we will resume the process after hitting
1244 a gdbserver breakpoint; single-stepping to/over one
1245 is not supported (yet). */
1246 if (event_child
->bp_reinsert
!= 0)
1249 fprintf (stderr
, "Reinserted breakpoint.\n");
1250 reinsert_breakpoint (event_child
->bp_reinsert
);
1251 event_child
->bp_reinsert
= 0;
1253 /* Clear the single-stepping flag and SIGTRAP as we resume. */
1254 linux_resume_one_lwp (event_child
, 0, 0, NULL
);
1258 bp_status
= check_breakpoints (stop_pc
);
1263 fprintf (stderr
, "Hit a gdbserver breakpoint.\n");
1265 /* We hit one of our own breakpoints. We mark it as a pending
1266 breakpoint, so that check_removed_breakpoint () will do the PC
1267 adjustment for us at the appropriate time. */
1268 event_child
->pending_is_breakpoint
= 1;
1269 event_child
->pending_stop_pc
= stop_pc
;
1271 /* We may need to put the breakpoint back. We continue in the event
1272 loop instead of simply replacing the breakpoint right away,
1273 in order to not lose signals sent to the thread that hit the
1274 breakpoint. Unfortunately this increases the window where another
1275 thread could sneak past the removed breakpoint. For the current
1276 use of server-side breakpoints (thread creation) this is
1277 acceptable; but it needs to be considered before this breakpoint
1278 mechanism can be used in more general ways. For some breakpoints
1279 it may be necessary to stop all other threads, but that should
1280 be avoided where possible.
1282 If breakpoint_reinsert_addr is NULL, that means that we can
1283 use PTRACE_SINGLESTEP on this platform. Uninsert the breakpoint,
1284 mark it for reinsertion, and single-step.
1286 Otherwise, call the target function to figure out where we need
1287 our temporary breakpoint, create it, and continue executing this
1290 /* NOTE: we're lifting breakpoints in non-stop mode. This
1291 is currently only used for thread event breakpoints, so
1292 it isn't that bad as long as we have PTRACE_EVENT_CLONE
1295 /* No need to reinsert. */
1296 linux_resume_one_lwp (event_child
, 0, 0, NULL
);
1297 else if (the_low_target
.breakpoint_reinsert_addr
== NULL
)
1299 event_child
->bp_reinsert
= stop_pc
;
1300 uninsert_breakpoint (stop_pc
);
1301 linux_resume_one_lwp (event_child
, 1, 0, NULL
);
1305 reinsert_breakpoint_by_bp
1306 (stop_pc
, (*the_low_target
.breakpoint_reinsert_addr
) ());
1307 linux_resume_one_lwp (event_child
, 0, 0, NULL
);
1314 fprintf (stderr
, "Hit a non-gdbserver breakpoint.\n");
1316 /* If we were single-stepping, we definitely want to report the
1317 SIGTRAP. Although the single-step operation has completed,
1318 do not clear clear the stepping flag yet; we need to check it
1319 in wait_for_sigstop. */
1320 if (event_child
->stepping
)
1321 return lwpid_of (event_child
);
1323 /* A SIGTRAP that we can't explain. It may have been a breakpoint.
1324 Check if it is a breakpoint, and if so mark the process information
1325 accordingly. This will handle both the necessary fiddling with the
1326 PC on decr_pc_after_break targets and suppressing extra threads
1327 hitting a breakpoint if two hit it at once and then GDB removes it
1328 after the first is reported. Arguably it would be better to report
1329 multiple threads hitting breakpoints simultaneously, but the current
1330 remote protocol does not allow this. */
1331 if ((*the_low_target
.breakpoint_at
) (stop_pc
))
1333 event_child
->pending_is_breakpoint
= 1;
1334 event_child
->pending_stop_pc
= stop_pc
;
1337 return lwpid_of (event_child
);
1345 linux_wait_for_event (ptid_t ptid
, int *wstat
, int options
)
1349 if (ptid_is_pid (ptid
))
1351 /* A request to wait for a specific tgid. This is not possible
1352 with waitpid, so instead, we wait for any child, and leave
1353 children we're not interested in right now with a pending
1354 status to report later. */
1355 wait_ptid
= minus_one_ptid
;
1364 event_pid
= linux_wait_for_event_1 (wait_ptid
, wstat
, options
);
1367 && ptid_is_pid (ptid
) && ptid_get_pid (ptid
) != event_pid
)
1369 struct lwp_info
*event_child
= find_lwp_pid (pid_to_ptid (event_pid
));
1371 if (! WIFSTOPPED (*wstat
))
1372 mark_lwp_dead (event_child
, *wstat
);
1375 event_child
->status_pending_p
= 1;
1376 event_child
->status_pending
= *wstat
;
1384 /* Wait for process, returns status. */
1387 linux_wait_1 (ptid_t ptid
,
1388 struct target_waitstatus
*ourstatus
, int target_options
)
1391 struct thread_info
*thread
= NULL
;
1392 struct lwp_info
*lwp
= NULL
;
1396 /* Translate generic target options into linux options. */
1398 if (target_options
& TARGET_WNOHANG
)
1402 ourstatus
->kind
= TARGET_WAITKIND_IGNORE
;
1404 /* If we were only supposed to resume one thread, only wait for
1405 that thread - if it's still alive. If it died, however - which
1406 can happen if we're coming from the thread death case below -
1407 then we need to make sure we restart the other threads. We could
1408 pick a thread at random or restart all; restarting all is less
1411 && !ptid_equal (cont_thread
, null_ptid
)
1412 && !ptid_equal (cont_thread
, minus_one_ptid
))
1414 thread
= (struct thread_info
*) find_inferior_id (&all_threads
,
1417 /* No stepping, no signal - unless one is pending already, of course. */
1420 struct thread_resume resume_info
;
1421 resume_info
.thread
= minus_one_ptid
;
1422 resume_info
.kind
= resume_continue
;
1423 resume_info
.sig
= 0;
1424 linux_resume (&resume_info
, 1);
1430 pid
= linux_wait_for_event (ptid
, &w
, options
);
1431 if (pid
== 0) /* only if TARGET_WNOHANG */
1434 lwp
= get_thread_lwp (current_inferior
);
1436 /* If we are waiting for a particular child, and it exited,
1437 linux_wait_for_event will return its exit status. Similarly if
1438 the last child exited. If this is not the last child, however,
1439 do not report it as exited until there is a 'thread exited' response
1440 available in the remote protocol. Instead, just wait for another event.
1441 This should be safe, because if the thread crashed we will already
1442 have reported the termination signal to GDB; that should stop any
1443 in-progress stepping operations, etc.
1445 Report the exit status of the last thread to exit. This matches
1446 LinuxThreads' behavior. */
1448 if (last_thread_of_process_p (current_inferior
))
1450 if (WIFEXITED (w
) || WIFSIGNALED (w
))
1452 int pid
= pid_of (lwp
);
1453 struct process_info
*process
= find_process_pid (pid
);
1456 linux_remove_process (process
, 0);
1458 current_inferior
= NULL
;
1462 ourstatus
->kind
= TARGET_WAITKIND_EXITED
;
1463 ourstatus
->value
.integer
= WEXITSTATUS (w
);
1466 fprintf (stderr
, "\nChild exited with retcode = %x \n", WEXITSTATUS (w
));
1470 ourstatus
->kind
= TARGET_WAITKIND_SIGNALLED
;
1471 ourstatus
->value
.sig
= target_signal_from_host (WTERMSIG (w
));
1474 fprintf (stderr
, "\nChild terminated with signal = %x \n", WTERMSIG (w
));
1478 return pid_to_ptid (pid
);
1483 if (!WIFSTOPPED (w
))
1487 /* In all-stop, stop all threads. Be careful to only do this if
1488 we're about to report an event to GDB. */
1492 ourstatus
->kind
= TARGET_WAITKIND_STOPPED
;
1494 if (lwp
->suspended
&& WSTOPSIG (w
) == SIGSTOP
)
1496 /* A thread that has been requested to stop by GDB with vCont;t,
1497 and it stopped cleanly, so report as SIG0. The use of
1498 SIGSTOP is an implementation detail. */
1499 ourstatus
->value
.sig
= TARGET_SIGNAL_0
;
1501 else if (lwp
->suspended
&& WSTOPSIG (w
) != SIGSTOP
)
1503 /* A thread that has been requested to stop by GDB with vCont;t,
1504 but, it stopped for other reasons. Set stop_expected so the
1505 pending SIGSTOP is ignored and the LWP is resumed. */
1506 lwp
->stop_expected
= 1;
1507 ourstatus
->value
.sig
= target_signal_from_host (WSTOPSIG (w
));
1511 ourstatus
->value
.sig
= target_signal_from_host (WSTOPSIG (w
));
1515 fprintf (stderr
, "linux_wait ret = %s, %d, %d\n",
1516 target_pid_to_str (lwp
->head
.id
),
1518 ourstatus
->value
.sig
);
1520 return lwp
->head
.id
;
1523 /* Get rid of any pending event in the pipe. */
1525 async_file_flush (void)
1531 ret
= read (linux_event_pipe
[0], &buf
, 1);
1532 while (ret
>= 0 || (ret
== -1 && errno
== EINTR
));
1535 /* Put something in the pipe, so the event loop wakes up. */
1537 async_file_mark (void)
1541 async_file_flush ();
1544 ret
= write (linux_event_pipe
[1], "+", 1);
1545 while (ret
== 0 || (ret
== -1 && errno
== EINTR
));
1547 /* Ignore EAGAIN. If the pipe is full, the event loop will already
1548 be awakened anyway. */
1552 linux_wait (ptid_t ptid
,
1553 struct target_waitstatus
*ourstatus
, int target_options
)
1558 fprintf (stderr
, "linux_wait: [%s]\n", target_pid_to_str (ptid
));
1560 /* Flush the async file first. */
1561 if (target_is_async_p ())
1562 async_file_flush ();
1564 event_ptid
= linux_wait_1 (ptid
, ourstatus
, target_options
);
1566 /* If at least one stop was reported, there may be more. A single
1567 SIGCHLD can signal more than one child stop. */
1568 if (target_is_async_p ()
1569 && (target_options
& TARGET_WNOHANG
) != 0
1570 && !ptid_equal (event_ptid
, null_ptid
))
1576 /* Send a signal to an LWP. For LinuxThreads, kill is enough; however, if
1577 thread groups are in use, we need to use tkill. */
1580 kill_lwp (unsigned long lwpid
, int signo
)
1582 static int tkill_failed
;
1589 int ret
= syscall (SYS_tkill
, lwpid
, signo
);
1590 if (errno
!= ENOSYS
)
1597 return kill (lwpid
, signo
);
1601 send_sigstop (struct inferior_list_entry
*entry
)
1603 struct lwp_info
*lwp
= (struct lwp_info
*) entry
;
1609 pid
= lwpid_of (lwp
);
1611 /* If we already have a pending stop signal for this process, don't
1613 if (lwp
->stop_expected
)
1616 fprintf (stderr
, "Have pending sigstop for lwp %d\n", pid
);
1618 /* We clear the stop_expected flag so that wait_for_sigstop
1619 will receive the SIGSTOP event (instead of silently resuming and
1620 waiting again). It'll be reset below. */
1621 lwp
->stop_expected
= 0;
1626 fprintf (stderr
, "Sending sigstop to lwp %d\n", pid
);
1628 kill_lwp (pid
, SIGSTOP
);
1632 mark_lwp_dead (struct lwp_info
*lwp
, int wstat
)
1634 /* It's dead, really. */
1637 /* Store the exit status for later. */
1638 lwp
->status_pending_p
= 1;
1639 lwp
->status_pending
= wstat
;
1641 /* So that check_removed_breakpoint doesn't try to figure out if
1642 this is stopped at a breakpoint. */
1643 lwp
->pending_is_breakpoint
= 0;
1645 /* Prevent trying to stop it. */
1648 /* No further stops are expected from a dead lwp. */
1649 lwp
->stop_expected
= 0;
1653 wait_for_sigstop (struct inferior_list_entry
*entry
)
1655 struct lwp_info
*lwp
= (struct lwp_info
*) entry
;
1656 struct thread_info
*saved_inferior
;
1664 saved_inferior
= current_inferior
;
1665 if (saved_inferior
!= NULL
)
1666 saved_tid
= ((struct inferior_list_entry
*) saved_inferior
)->id
;
1668 saved_tid
= null_ptid
; /* avoid bogus unused warning */
1670 ptid
= lwp
->head
.id
;
1672 linux_wait_for_event (ptid
, &wstat
, __WALL
);
1674 /* If we stopped with a non-SIGSTOP signal, save it for later
1675 and record the pending SIGSTOP. If the process exited, just
1677 if (WIFSTOPPED (wstat
)
1678 && WSTOPSIG (wstat
) != SIGSTOP
)
1681 fprintf (stderr
, "LWP %ld stopped with non-sigstop status %06x\n",
1682 lwpid_of (lwp
), wstat
);
1684 /* Do not leave a pending single-step finish to be reported to
1685 the client. The client will give us a new action for this
1686 thread, possibly a continue request --- otherwise, the client
1687 would consider this pending SIGTRAP reported later a spurious
1689 if (WSTOPSIG (wstat
) == SIGTRAP
1691 && !linux_stopped_by_watchpoint ())
1694 fprintf (stderr
, " single-step SIGTRAP ignored\n");
1698 lwp
->status_pending_p
= 1;
1699 lwp
->status_pending
= wstat
;
1701 lwp
->stop_expected
= 1;
1703 else if (!WIFSTOPPED (wstat
))
1706 fprintf (stderr
, "Process %ld exited while stopping LWPs\n",
1709 /* Leave this status pending for the next time we're able to
1710 report it. In the mean time, we'll report this lwp as dead
1711 to GDB, so GDB doesn't try to read registers and memory from
1713 mark_lwp_dead (lwp
, wstat
);
1716 if (saved_inferior
== NULL
|| linux_thread_alive (saved_tid
))
1717 current_inferior
= saved_inferior
;
1721 fprintf (stderr
, "Previously current thread died.\n");
1725 /* We can't change the current inferior behind GDB's back,
1726 otherwise, a subsequent command may apply to the wrong
1728 current_inferior
= NULL
;
1732 /* Set a valid thread as current. */
1733 set_desired_inferior (0);
1739 stop_all_lwps (void)
1741 stopping_threads
= 1;
1742 for_each_inferior (&all_lwps
, send_sigstop
);
1743 for_each_inferior (&all_lwps
, wait_for_sigstop
);
1744 stopping_threads
= 0;
1747 /* Resume execution of the inferior process.
1748 If STEP is nonzero, single-step it.
1749 If SIGNAL is nonzero, give it that signal. */
1752 linux_resume_one_lwp (struct lwp_info
*lwp
,
1753 int step
, int signal
, siginfo_t
*info
)
1755 struct thread_info
*saved_inferior
;
1757 if (lwp
->stopped
== 0)
1760 /* If we have pending signals or status, and a new signal, enqueue the
1761 signal. Also enqueue the signal if we are waiting to reinsert a
1762 breakpoint; it will be picked up again below. */
1764 && (lwp
->status_pending_p
|| lwp
->pending_signals
!= NULL
1765 || lwp
->bp_reinsert
!= 0))
1767 struct pending_signals
*p_sig
;
1768 p_sig
= xmalloc (sizeof (*p_sig
));
1769 p_sig
->prev
= lwp
->pending_signals
;
1770 p_sig
->signal
= signal
;
1772 memset (&p_sig
->info
, 0, sizeof (siginfo_t
));
1774 memcpy (&p_sig
->info
, info
, sizeof (siginfo_t
));
1775 lwp
->pending_signals
= p_sig
;
1778 if (lwp
->status_pending_p
&& !check_removed_breakpoint (lwp
))
1781 saved_inferior
= current_inferior
;
1782 current_inferior
= get_lwp_thread (lwp
);
1785 fprintf (stderr
, "Resuming lwp %ld (%s, signal %d, stop %s)\n",
1786 lwpid_of (lwp
), step
? "step" : "continue", signal
,
1787 lwp
->stop_expected
? "expected" : "not expected");
1789 /* This bit needs some thinking about. If we get a signal that
1790 we must report while a single-step reinsert is still pending,
1791 we often end up resuming the thread. It might be better to
1792 (ew) allow a stack of pending events; then we could be sure that
1793 the reinsert happened right away and not lose any signals.
1795 Making this stack would also shrink the window in which breakpoints are
1796 uninserted (see comment in linux_wait_for_lwp) but not enough for
1797 complete correctness, so it won't solve that problem. It may be
1798 worthwhile just to solve this one, however. */
1799 if (lwp
->bp_reinsert
!= 0)
1802 fprintf (stderr
, " pending reinsert at %08lx", (long)lwp
->bp_reinsert
);
1804 fprintf (stderr
, "BAD - reinserting but not stepping.\n");
1807 /* Postpone any pending signal. It was enqueued above. */
1811 check_removed_breakpoint (lwp
);
1813 if (debug_threads
&& the_low_target
.get_pc
!= NULL
)
1815 CORE_ADDR pc
= (*the_low_target
.get_pc
) ();
1816 fprintf (stderr
, " resuming from pc 0x%lx\n", (long) pc
);
1819 /* If we have pending signals, consume one unless we are trying to reinsert
1821 if (lwp
->pending_signals
!= NULL
&& lwp
->bp_reinsert
== 0)
1823 struct pending_signals
**p_sig
;
1825 p_sig
= &lwp
->pending_signals
;
1826 while ((*p_sig
)->prev
!= NULL
)
1827 p_sig
= &(*p_sig
)->prev
;
1829 signal
= (*p_sig
)->signal
;
1830 if ((*p_sig
)->info
.si_signo
!= 0)
1831 ptrace (PTRACE_SETSIGINFO
, lwpid_of (lwp
), 0, &(*p_sig
)->info
);
1837 if (the_low_target
.prepare_to_resume
!= NULL
)
1838 the_low_target
.prepare_to_resume (lwp
);
1840 regcache_invalidate_one ((struct inferior_list_entry
*)
1841 get_lwp_thread (lwp
));
1844 lwp
->stepping
= step
;
1845 ptrace (step
? PTRACE_SINGLESTEP
: PTRACE_CONT
, lwpid_of (lwp
), 0, signal
);
1847 current_inferior
= saved_inferior
;
1850 /* ESRCH from ptrace either means that the thread was already
1851 running (an error) or that it is gone (a race condition). If
1852 it's gone, we will get a notification the next time we wait,
1853 so we can ignore the error. We could differentiate these
1854 two, but it's tricky without waiting; the thread still exists
1855 as a zombie, so sending it signal 0 would succeed. So just
1860 perror_with_name ("ptrace");
1864 struct thread_resume_array
1866 struct thread_resume
*resume
;
1870 /* This function is called once per thread. We look up the thread
1871 in RESUME_PTR, and mark the thread with a pointer to the appropriate
1874 This algorithm is O(threads * resume elements), but resume elements
1875 is small (and will remain small at least until GDB supports thread
1878 linux_set_resume_request (struct inferior_list_entry
*entry
, void *arg
)
1880 struct lwp_info
*lwp
;
1881 struct thread_info
*thread
;
1883 struct thread_resume_array
*r
;
1885 thread
= (struct thread_info
*) entry
;
1886 lwp
= get_thread_lwp (thread
);
1889 for (ndx
= 0; ndx
< r
->n
; ndx
++)
1891 ptid_t ptid
= r
->resume
[ndx
].thread
;
1892 if (ptid_equal (ptid
, minus_one_ptid
)
1893 || ptid_equal (ptid
, entry
->id
)
1894 || (ptid_is_pid (ptid
)
1895 && (ptid_get_pid (ptid
) == pid_of (lwp
)))
1896 || (ptid_get_lwp (ptid
) == -1
1897 && (ptid_get_pid (ptid
) == pid_of (lwp
))))
1899 lwp
->resume
= &r
->resume
[ndx
];
1904 /* No resume action for this thread. */
1911 /* Set *FLAG_P if this lwp has an interesting status pending. */
1913 resume_status_pending_p (struct inferior_list_entry
*entry
, void *flag_p
)
1915 struct lwp_info
*lwp
= (struct lwp_info
*) entry
;
1917 /* LWPs which will not be resumed are not interesting, because
1918 we might not wait for them next time through linux_wait. */
1919 if (lwp
->resume
== NULL
)
1922 /* If this thread has a removed breakpoint, we won't have any
1923 events to report later, so check now. check_removed_breakpoint
1924 may clear status_pending_p. We avoid calling check_removed_breakpoint
1925 for any thread that we are not otherwise going to resume - this
1926 lets us preserve stopped status when two threads hit a breakpoint.
1927 GDB removes the breakpoint to single-step a particular thread
1928 past it, then re-inserts it and resumes all threads. We want
1929 to report the second thread without resuming it in the interim. */
1930 if (lwp
->status_pending_p
)
1931 check_removed_breakpoint (lwp
);
1933 if (lwp
->status_pending_p
)
1934 * (int *) flag_p
= 1;
1939 /* This function is called once per thread. We check the thread's resume
1940 request, which will tell us whether to resume, step, or leave the thread
1941 stopped; and what signal, if any, it should be sent.
1943 For threads which we aren't explicitly told otherwise, we preserve
1944 the stepping flag; this is used for stepping over gdbserver-placed
1947 If pending_flags was set in any thread, we queue any needed
1948 signals, since we won't actually resume. We already have a pending
1949 event to report, so we don't need to preserve any step requests;
1950 they should be re-issued if necessary. */
1953 linux_resume_one_thread (struct inferior_list_entry
*entry
, void *arg
)
1955 struct lwp_info
*lwp
;
1956 struct thread_info
*thread
;
1958 int pending_flag
= * (int *) arg
;
1960 thread
= (struct thread_info
*) entry
;
1961 lwp
= get_thread_lwp (thread
);
1963 if (lwp
->resume
== NULL
)
1966 if (lwp
->resume
->kind
== resume_stop
)
1969 fprintf (stderr
, "suspending LWP %ld\n", lwpid_of (lwp
));
1974 fprintf (stderr
, "running -> suspending LWP %ld\n", lwpid_of (lwp
));
1977 send_sigstop (&lwp
->head
);
1984 fprintf (stderr
, "already stopped/suspended LWP %ld\n",
1987 fprintf (stderr
, "already stopped/not suspended LWP %ld\n",
1991 /* Make sure we leave the LWP suspended, so we don't try to
1992 resume it without GDB telling us to. FIXME: The LWP may
1993 have been stopped in an internal event that was not meant
1994 to be notified back to GDB (e.g., gdbserver breakpoint),
1995 so we should be reporting a stop event in that case
2000 /* For stop requests, we're done. */
2007 /* If this thread which is about to be resumed has a pending status,
2008 then don't resume any threads - we can just report the pending
2009 status. Make sure to queue any signals that would otherwise be
2010 sent. In all-stop mode, we do this decision based on if *any*
2011 thread has a pending status. */
2013 resume_status_pending_p (&lwp
->head
, &pending_flag
);
2018 fprintf (stderr
, "resuming LWP %ld\n", lwpid_of (lwp
));
2020 if (ptid_equal (lwp
->resume
->thread
, minus_one_ptid
)
2022 && lwp
->pending_is_breakpoint
)
2025 step
= (lwp
->resume
->kind
== resume_step
);
2027 linux_resume_one_lwp (lwp
, step
, lwp
->resume
->sig
, NULL
);
2032 fprintf (stderr
, "leaving LWP %ld stopped\n", lwpid_of (lwp
));
2034 /* If we have a new signal, enqueue the signal. */
2035 if (lwp
->resume
->sig
!= 0)
2037 struct pending_signals
*p_sig
;
2038 p_sig
= xmalloc (sizeof (*p_sig
));
2039 p_sig
->prev
= lwp
->pending_signals
;
2040 p_sig
->signal
= lwp
->resume
->sig
;
2041 memset (&p_sig
->info
, 0, sizeof (siginfo_t
));
2043 /* If this is the same signal we were previously stopped by,
2044 make sure to queue its siginfo. We can ignore the return
2045 value of ptrace; if it fails, we'll skip
2046 PTRACE_SETSIGINFO. */
2047 if (WIFSTOPPED (lwp
->last_status
)
2048 && WSTOPSIG (lwp
->last_status
) == lwp
->resume
->sig
)
2049 ptrace (PTRACE_GETSIGINFO
, lwpid_of (lwp
), 0, &p_sig
->info
);
2051 lwp
->pending_signals
= p_sig
;
2060 linux_resume (struct thread_resume
*resume_info
, size_t n
)
2063 struct thread_resume_array array
= { resume_info
, n
};
2065 find_inferior (&all_threads
, linux_set_resume_request
, &array
);
2067 /* If there is a thread which would otherwise be resumed, which
2068 has a pending status, then don't resume any threads - we can just
2069 report the pending status. Make sure to queue any signals
2070 that would otherwise be sent. In non-stop mode, we'll apply this
2071 logic to each thread individually. */
2074 find_inferior (&all_lwps
, resume_status_pending_p
, &pending_flag
);
2079 fprintf (stderr
, "Not resuming, pending status\n");
2081 fprintf (stderr
, "Resuming, no pending status\n");
2084 find_inferior (&all_threads
, linux_resume_one_thread
, &pending_flag
);
2087 #ifdef HAVE_LINUX_USRREGS
2090 register_addr (int regnum
)
2094 if (regnum
< 0 || regnum
>= the_low_target
.num_regs
)
2095 error ("Invalid register number %d.", regnum
);
2097 addr
= the_low_target
.regmap
[regnum
];
2102 /* Fetch one register. */
2104 fetch_register (int regno
)
2111 if (regno
>= the_low_target
.num_regs
)
2113 if ((*the_low_target
.cannot_fetch_register
) (regno
))
2116 regaddr
= register_addr (regno
);
2120 pid
= lwpid_of (get_thread_lwp (current_inferior
));
2121 size
= ((register_size (regno
) + sizeof (PTRACE_XFER_TYPE
) - 1)
2122 & - sizeof (PTRACE_XFER_TYPE
));
2123 buf
= alloca (size
);
2124 for (i
= 0; i
< size
; i
+= sizeof (PTRACE_XFER_TYPE
))
2127 *(PTRACE_XFER_TYPE
*) (buf
+ i
) =
2128 ptrace (PTRACE_PEEKUSER
, pid
, (PTRACE_ARG3_TYPE
) regaddr
, 0);
2129 regaddr
+= sizeof (PTRACE_XFER_TYPE
);
2132 /* Warning, not error, in case we are attached; sometimes the
2133 kernel doesn't let us at the registers. */
2134 char *err
= strerror (errno
);
2135 char *msg
= alloca (strlen (err
) + 128);
2136 sprintf (msg
, "reading register %d: %s", regno
, err
);
2142 if (the_low_target
.supply_ptrace_register
)
2143 the_low_target
.supply_ptrace_register (regno
, buf
);
2145 supply_register (regno
, buf
);
2150 /* Fetch all registers, or just one, from the child process. */
2152 usr_fetch_inferior_registers (int regno
)
2155 for (regno
= 0; regno
< the_low_target
.num_regs
; regno
++)
2156 fetch_register (regno
);
2158 fetch_register (regno
);
2161 /* Store our register values back into the inferior.
2162 If REGNO is -1, do this for all registers.
2163 Otherwise, REGNO specifies which register (so we can save time). */
2165 usr_store_inferior_registers (int regno
)
2174 if (regno
>= the_low_target
.num_regs
)
2177 if ((*the_low_target
.cannot_store_register
) (regno
) == 1)
2180 regaddr
= register_addr (regno
);
2184 size
= (register_size (regno
) + sizeof (PTRACE_XFER_TYPE
) - 1)
2185 & - sizeof (PTRACE_XFER_TYPE
);
2186 buf
= alloca (size
);
2187 memset (buf
, 0, size
);
2189 if (the_low_target
.collect_ptrace_register
)
2190 the_low_target
.collect_ptrace_register (regno
, buf
);
2192 collect_register (regno
, buf
);
2194 pid
= lwpid_of (get_thread_lwp (current_inferior
));
2195 for (i
= 0; i
< size
; i
+= sizeof (PTRACE_XFER_TYPE
))
2198 ptrace (PTRACE_POKEUSER
, pid
, (PTRACE_ARG3_TYPE
) regaddr
,
2199 *(PTRACE_XFER_TYPE
*) (buf
+ i
));
2202 /* At this point, ESRCH should mean the process is
2203 already gone, in which case we simply ignore attempts
2204 to change its registers. See also the related
2205 comment in linux_resume_one_lwp. */
2209 if ((*the_low_target
.cannot_store_register
) (regno
) == 0)
2211 char *err
= strerror (errno
);
2212 char *msg
= alloca (strlen (err
) + 128);
2213 sprintf (msg
, "writing register %d: %s",
2219 regaddr
+= sizeof (PTRACE_XFER_TYPE
);
2223 for (regno
= 0; regno
< the_low_target
.num_regs
; regno
++)
2224 usr_store_inferior_registers (regno
);
2226 #endif /* HAVE_LINUX_USRREGS */
2230 #ifdef HAVE_LINUX_REGSETS
2233 regsets_fetch_inferior_registers ()
2235 struct regset_info
*regset
;
2236 int saw_general_regs
= 0;
2239 regset
= target_regsets
;
2241 pid
= lwpid_of (get_thread_lwp (current_inferior
));
2242 while (regset
->size
>= 0)
2247 if (regset
->size
== 0 || disabled_regsets
[regset
- target_regsets
])
2253 buf
= xmalloc (regset
->size
);
2255 res
= ptrace (regset
->get_request
, pid
, 0, buf
);
2257 res
= ptrace (regset
->get_request
, pid
, buf
, 0);
2263 /* If we get EIO on a regset, do not try it again for
2265 disabled_regsets
[regset
- target_regsets
] = 1;
2272 sprintf (s
, "ptrace(regsets_fetch_inferior_registers) PID=%d",
2277 else if (regset
->type
== GENERAL_REGS
)
2278 saw_general_regs
= 1;
2279 regset
->store_function (buf
);
2283 if (saw_general_regs
)
2290 regsets_store_inferior_registers ()
2292 struct regset_info
*regset
;
2293 int saw_general_regs
= 0;
2296 regset
= target_regsets
;
2298 pid
= lwpid_of (get_thread_lwp (current_inferior
));
2299 while (regset
->size
>= 0)
2304 if (regset
->size
== 0 || disabled_regsets
[regset
- target_regsets
])
2310 buf
= xmalloc (regset
->size
);
2312 /* First fill the buffer with the current register set contents,
2313 in case there are any items in the kernel's regset that are
2314 not in gdbserver's regcache. */
2316 res
= ptrace (regset
->get_request
, pid
, 0, buf
);
2318 res
= ptrace (regset
->get_request
, pid
, buf
, 0);
2323 /* Then overlay our cached registers on that. */
2324 regset
->fill_function (buf
);
2326 /* Only now do we write the register set. */
2328 res
= ptrace (regset
->set_request
, pid
, 0, buf
);
2330 res
= ptrace (regset
->set_request
, pid
, buf
, 0);
2338 /* If we get EIO on a regset, do not try it again for
2340 disabled_regsets
[regset
- target_regsets
] = 1;
2344 else if (errno
== ESRCH
)
2346 /* At this point, ESRCH should mean the process is
2347 already gone, in which case we simply ignore attempts
2348 to change its registers. See also the related
2349 comment in linux_resume_one_lwp. */
2355 perror ("Warning: ptrace(regsets_store_inferior_registers)");
2358 else if (regset
->type
== GENERAL_REGS
)
2359 saw_general_regs
= 1;
2363 if (saw_general_regs
)
2370 #endif /* HAVE_LINUX_REGSETS */
2374 linux_fetch_registers (int regno
)
2376 #ifdef HAVE_LINUX_REGSETS
2377 if (regsets_fetch_inferior_registers () == 0)
2380 #ifdef HAVE_LINUX_USRREGS
2381 usr_fetch_inferior_registers (regno
);
2386 linux_store_registers (int regno
)
2388 #ifdef HAVE_LINUX_REGSETS
2389 if (regsets_store_inferior_registers () == 0)
2392 #ifdef HAVE_LINUX_USRREGS
2393 usr_store_inferior_registers (regno
);
2398 /* Copy LEN bytes from inferior's memory starting at MEMADDR
2399 to debugger memory starting at MYADDR. */
2402 linux_read_memory (CORE_ADDR memaddr
, unsigned char *myaddr
, int len
)
2405 /* Round starting address down to longword boundary. */
2406 register CORE_ADDR addr
= memaddr
& -(CORE_ADDR
) sizeof (PTRACE_XFER_TYPE
);
2407 /* Round ending address up; get number of longwords that makes. */
2409 = (((memaddr
+ len
) - addr
) + sizeof (PTRACE_XFER_TYPE
) - 1)
2410 / sizeof (PTRACE_XFER_TYPE
);
2411 /* Allocate buffer of that many longwords. */
2412 register PTRACE_XFER_TYPE
*buffer
2413 = (PTRACE_XFER_TYPE
*) alloca (count
* sizeof (PTRACE_XFER_TYPE
));
2416 int pid
= lwpid_of (get_thread_lwp (current_inferior
));
2418 /* Try using /proc. Don't bother for one word. */
2419 if (len
>= 3 * sizeof (long))
2421 /* We could keep this file open and cache it - possibly one per
2422 thread. That requires some juggling, but is even faster. */
2423 sprintf (filename
, "/proc/%d/mem", pid
);
2424 fd
= open (filename
, O_RDONLY
| O_LARGEFILE
);
2428 /* If pread64 is available, use it. It's faster if the kernel
2429 supports it (only one syscall), and it's 64-bit safe even on
2430 32-bit platforms (for instance, SPARC debugging a SPARC64
2433 if (pread64 (fd
, myaddr
, len
, memaddr
) != len
)
2435 if (lseek (fd
, memaddr
, SEEK_SET
) == -1 || read (fd
, myaddr
, len
) != len
)
2447 /* Read all the longwords */
2448 for (i
= 0; i
< count
; i
++, addr
+= sizeof (PTRACE_XFER_TYPE
))
2451 buffer
[i
] = ptrace (PTRACE_PEEKTEXT
, pid
, (PTRACE_ARG3_TYPE
) addr
, 0);
2456 /* Copy appropriate bytes out of the buffer. */
2458 (char *) buffer
+ (memaddr
& (sizeof (PTRACE_XFER_TYPE
) - 1)),
2464 /* Copy LEN bytes of data from debugger memory at MYADDR
2465 to inferior's memory at MEMADDR.
2466 On failure (cannot write the inferior)
2467 returns the value of errno. */
2470 linux_write_memory (CORE_ADDR memaddr
, const unsigned char *myaddr
, int len
)
2473 /* Round starting address down to longword boundary. */
2474 register CORE_ADDR addr
= memaddr
& -(CORE_ADDR
) sizeof (PTRACE_XFER_TYPE
);
2475 /* Round ending address up; get number of longwords that makes. */
2477 = (((memaddr
+ len
) - addr
) + sizeof (PTRACE_XFER_TYPE
) - 1) / sizeof (PTRACE_XFER_TYPE
);
2478 /* Allocate buffer of that many longwords. */
2479 register PTRACE_XFER_TYPE
*buffer
= (PTRACE_XFER_TYPE
*) alloca (count
* sizeof (PTRACE_XFER_TYPE
));
2480 int pid
= lwpid_of (get_thread_lwp (current_inferior
));
2484 /* Dump up to four bytes. */
2485 unsigned int val
= * (unsigned int *) myaddr
;
2491 val
= val
& 0xffffff;
2492 fprintf (stderr
, "Writing %0*x to 0x%08lx\n", 2 * ((len
< 4) ? len
: 4),
2493 val
, (long)memaddr
);
2496 /* Fill start and end extra bytes of buffer with existing memory data. */
2498 buffer
[0] = ptrace (PTRACE_PEEKTEXT
, pid
, (PTRACE_ARG3_TYPE
) addr
, 0);
2503 = ptrace (PTRACE_PEEKTEXT
, pid
,
2504 (PTRACE_ARG3_TYPE
) (addr
+ (count
- 1)
2505 * sizeof (PTRACE_XFER_TYPE
)),
2509 /* Copy data to be written over corresponding part of buffer */
2511 memcpy ((char *) buffer
+ (memaddr
& (sizeof (PTRACE_XFER_TYPE
) - 1)), myaddr
, len
);
2513 /* Write the entire buffer. */
2515 for (i
= 0; i
< count
; i
++, addr
+= sizeof (PTRACE_XFER_TYPE
))
2518 ptrace (PTRACE_POKETEXT
, pid
, (PTRACE_ARG3_TYPE
) addr
, buffer
[i
]);
2526 static int linux_supports_tracefork_flag
;
2528 /* Helper functions for linux_test_for_tracefork, called via clone (). */
2531 linux_tracefork_grandchild (void *arg
)
2536 #define STACK_SIZE 4096
2539 linux_tracefork_child (void *arg
)
2541 ptrace (PTRACE_TRACEME
, 0, 0, 0);
2542 kill (getpid (), SIGSTOP
);
2544 __clone2 (linux_tracefork_grandchild
, arg
, STACK_SIZE
,
2545 CLONE_VM
| SIGCHLD
, NULL
);
2547 clone (linux_tracefork_grandchild
, arg
+ STACK_SIZE
,
2548 CLONE_VM
| SIGCHLD
, NULL
);
2553 /* Determine if PTRACE_O_TRACEFORK can be used to follow fork events. Make
2554 sure that we can enable the option, and that it had the desired
2558 linux_test_for_tracefork (void)
2560 int child_pid
, ret
, status
;
2562 char *stack
= xmalloc (STACK_SIZE
* 4);
2564 linux_supports_tracefork_flag
= 0;
2566 /* Use CLONE_VM instead of fork, to support uClinux (no MMU). */
2568 child_pid
= __clone2 (linux_tracefork_child
, stack
, STACK_SIZE
,
2569 CLONE_VM
| SIGCHLD
, stack
+ STACK_SIZE
* 2);
2571 child_pid
= clone (linux_tracefork_child
, stack
+ STACK_SIZE
,
2572 CLONE_VM
| SIGCHLD
, stack
+ STACK_SIZE
* 2);
2574 if (child_pid
== -1)
2575 perror_with_name ("clone");
2577 ret
= my_waitpid (child_pid
, &status
, 0);
2579 perror_with_name ("waitpid");
2580 else if (ret
!= child_pid
)
2581 error ("linux_test_for_tracefork: waitpid: unexpected result %d.", ret
);
2582 if (! WIFSTOPPED (status
))
2583 error ("linux_test_for_tracefork: waitpid: unexpected status %d.", status
);
2585 ret
= ptrace (PTRACE_SETOPTIONS
, child_pid
, 0, PTRACE_O_TRACEFORK
);
2588 ret
= ptrace (PTRACE_KILL
, child_pid
, 0, 0);
2591 warning ("linux_test_for_tracefork: failed to kill child");
2595 ret
= my_waitpid (child_pid
, &status
, 0);
2596 if (ret
!= child_pid
)
2597 warning ("linux_test_for_tracefork: failed to wait for killed child");
2598 else if (!WIFSIGNALED (status
))
2599 warning ("linux_test_for_tracefork: unexpected wait status 0x%x from "
2600 "killed child", status
);
2605 ret
= ptrace (PTRACE_CONT
, child_pid
, 0, 0);
2607 warning ("linux_test_for_tracefork: failed to resume child");
2609 ret
= my_waitpid (child_pid
, &status
, 0);
2611 if (ret
== child_pid
&& WIFSTOPPED (status
)
2612 && status
>> 16 == PTRACE_EVENT_FORK
)
2615 ret
= ptrace (PTRACE_GETEVENTMSG
, child_pid
, 0, &second_pid
);
2616 if (ret
== 0 && second_pid
!= 0)
2620 linux_supports_tracefork_flag
= 1;
2621 my_waitpid (second_pid
, &second_status
, 0);
2622 ret
= ptrace (PTRACE_KILL
, second_pid
, 0, 0);
2624 warning ("linux_test_for_tracefork: failed to kill second child");
2625 my_waitpid (second_pid
, &status
, 0);
2629 warning ("linux_test_for_tracefork: unexpected result from waitpid "
2630 "(%d, status 0x%x)", ret
, status
);
2634 ret
= ptrace (PTRACE_KILL
, child_pid
, 0, 0);
2636 warning ("linux_test_for_tracefork: failed to kill child");
2637 my_waitpid (child_pid
, &status
, 0);
2639 while (WIFSTOPPED (status
));
2646 linux_look_up_symbols (void)
2648 #ifdef USE_THREAD_DB
2649 struct process_info
*proc
= current_process ();
2651 if (proc
->private->thread_db
!= NULL
)
2654 thread_db_init (!linux_supports_tracefork_flag
);
2659 linux_request_interrupt (void)
2661 extern unsigned long signal_pid
;
2663 if (!ptid_equal (cont_thread
, null_ptid
)
2664 && !ptid_equal (cont_thread
, minus_one_ptid
))
2666 struct lwp_info
*lwp
;
2669 lwp
= get_thread_lwp (current_inferior
);
2670 lwpid
= lwpid_of (lwp
);
2671 kill_lwp (lwpid
, SIGINT
);
2674 kill_lwp (signal_pid
, SIGINT
);
2677 /* Copy LEN bytes from inferior's auxiliary vector starting at OFFSET
2678 to debugger memory starting at MYADDR. */
2681 linux_read_auxv (CORE_ADDR offset
, unsigned char *myaddr
, unsigned int len
)
2683 char filename
[PATH_MAX
];
2685 int pid
= lwpid_of (get_thread_lwp (current_inferior
));
2687 snprintf (filename
, sizeof filename
, "/proc/%d/auxv", pid
);
2689 fd
= open (filename
, O_RDONLY
);
2693 if (offset
!= (CORE_ADDR
) 0
2694 && lseek (fd
, (off_t
) offset
, SEEK_SET
) != (off_t
) offset
)
2697 n
= read (fd
, myaddr
, len
);
2704 /* These breakpoint and watchpoint related wrapper functions simply
2705 pass on the function call if the target has registered a
2706 corresponding function. */
2709 linux_insert_point (char type
, CORE_ADDR addr
, int len
)
2711 if (the_low_target
.insert_point
!= NULL
)
2712 return the_low_target
.insert_point (type
, addr
, len
);
2714 /* Unsupported (see target.h). */
2719 linux_remove_point (char type
, CORE_ADDR addr
, int len
)
2721 if (the_low_target
.remove_point
!= NULL
)
2722 return the_low_target
.remove_point (type
, addr
, len
);
2724 /* Unsupported (see target.h). */
2729 linux_stopped_by_watchpoint (void)
2731 if (the_low_target
.stopped_by_watchpoint
!= NULL
)
2732 return the_low_target
.stopped_by_watchpoint ();
2738 linux_stopped_data_address (void)
2740 if (the_low_target
.stopped_data_address
!= NULL
)
2741 return the_low_target
.stopped_data_address ();
2746 #if defined(__UCLIBC__) && defined(HAS_NOMMU)
2747 #if defined(__mcoldfire__)
2748 /* These should really be defined in the kernel's ptrace.h header. */
2749 #define PT_TEXT_ADDR 49*4
2750 #define PT_DATA_ADDR 50*4
2751 #define PT_TEXT_END_ADDR 51*4
2754 /* Under uClinux, programs are loaded at non-zero offsets, which we need
2755 to tell gdb about. */
2758 linux_read_offsets (CORE_ADDR
*text_p
, CORE_ADDR
*data_p
)
2760 #if defined(PT_TEXT_ADDR) && defined(PT_DATA_ADDR) && defined(PT_TEXT_END_ADDR)
2761 unsigned long text
, text_end
, data
;
2762 int pid
= lwpid_of (get_thread_lwp (current_inferior
));
2766 text
= ptrace (PTRACE_PEEKUSER
, pid
, (long)PT_TEXT_ADDR
, 0);
2767 text_end
= ptrace (PTRACE_PEEKUSER
, pid
, (long)PT_TEXT_END_ADDR
, 0);
2768 data
= ptrace (PTRACE_PEEKUSER
, pid
, (long)PT_DATA_ADDR
, 0);
2772 /* Both text and data offsets produced at compile-time (and so
2773 used by gdb) are relative to the beginning of the program,
2774 with the data segment immediately following the text segment.
2775 However, the actual runtime layout in memory may put the data
2776 somewhere else, so when we send gdb a data base-address, we
2777 use the real data base address and subtract the compile-time
2778 data base-address from it (which is just the length of the
2779 text segment). BSS immediately follows data in both
2782 *data_p
= data
- (text_end
- text
);
2792 linux_qxfer_osdata (const char *annex
,
2793 unsigned char *readbuf
, unsigned const char *writebuf
,
2794 CORE_ADDR offset
, int len
)
2796 /* We make the process list snapshot when the object starts to be
2798 static const char *buf
;
2799 static long len_avail
= -1;
2800 static struct buffer buffer
;
2804 if (strcmp (annex
, "processes") != 0)
2807 if (!readbuf
|| writebuf
)
2812 if (len_avail
!= -1 && len_avail
!= 0)
2813 buffer_free (&buffer
);
2816 buffer_init (&buffer
);
2817 buffer_grow_str (&buffer
, "<osdata type=\"processes\">");
2819 dirp
= opendir ("/proc");
2823 while ((dp
= readdir (dirp
)) != NULL
)
2825 struct stat statbuf
;
2826 char procentry
[sizeof ("/proc/4294967295")];
2828 if (!isdigit (dp
->d_name
[0])
2829 || strlen (dp
->d_name
) > sizeof ("4294967295") - 1)
2832 sprintf (procentry
, "/proc/%s", dp
->d_name
);
2833 if (stat (procentry
, &statbuf
) == 0
2834 && S_ISDIR (statbuf
.st_mode
))
2838 char cmd
[MAXPATHLEN
+ 1];
2839 struct passwd
*entry
;
2841 sprintf (pathname
, "/proc/%s/cmdline", dp
->d_name
);
2842 entry
= getpwuid (statbuf
.st_uid
);
2844 if ((f
= fopen (pathname
, "r")) != NULL
)
2846 size_t len
= fread (cmd
, 1, sizeof (cmd
) - 1, f
);
2850 for (i
= 0; i
< len
; i
++)
2858 "<column name=\"pid\">%s</column>"
2859 "<column name=\"user\">%s</column>"
2860 "<column name=\"command\">%s</column>"
2863 entry
? entry
->pw_name
: "?",
2873 buffer_grow_str0 (&buffer
, "</osdata>\n");
2874 buf
= buffer_finish (&buffer
);
2875 len_avail
= strlen (buf
);
2878 if (offset
>= len_avail
)
2880 /* Done. Get rid of the data. */
2881 buffer_free (&buffer
);
2887 if (len
> len_avail
- offset
)
2888 len
= len_avail
- offset
;
2889 memcpy (readbuf
, buf
+ offset
, len
);
2894 /* Convert a native/host siginfo object, into/from the siginfo in the
2895 layout of the inferiors' architecture. */
2898 siginfo_fixup (struct siginfo
*siginfo
, void *inf_siginfo
, int direction
)
2902 if (the_low_target
.siginfo_fixup
!= NULL
)
2903 done
= the_low_target
.siginfo_fixup (siginfo
, inf_siginfo
, direction
);
2905 /* If there was no callback, or the callback didn't do anything,
2906 then just do a straight memcpy. */
2910 memcpy (siginfo
, inf_siginfo
, sizeof (struct siginfo
));
2912 memcpy (inf_siginfo
, siginfo
, sizeof (struct siginfo
));
2917 linux_xfer_siginfo (const char *annex
, unsigned char *readbuf
,
2918 unsigned const char *writebuf
, CORE_ADDR offset
, int len
)
2921 struct siginfo siginfo
;
2922 char inf_siginfo
[sizeof (struct siginfo
)];
2924 if (current_inferior
== NULL
)
2927 pid
= lwpid_of (get_thread_lwp (current_inferior
));
2930 fprintf (stderr
, "%s siginfo for lwp %d.\n",
2931 readbuf
!= NULL
? "Reading" : "Writing",
2934 if (offset
> sizeof (siginfo
))
2937 if (ptrace (PTRACE_GETSIGINFO
, pid
, 0, &siginfo
) != 0)
2940 /* When GDBSERVER is built as a 64-bit application, ptrace writes into
2941 SIGINFO an object with 64-bit layout. Since debugging a 32-bit
2942 inferior with a 64-bit GDBSERVER should look the same as debugging it
2943 with a 32-bit GDBSERVER, we need to convert it. */
2944 siginfo_fixup (&siginfo
, inf_siginfo
, 0);
2946 if (offset
+ len
> sizeof (siginfo
))
2947 len
= sizeof (siginfo
) - offset
;
2949 if (readbuf
!= NULL
)
2950 memcpy (readbuf
, inf_siginfo
+ offset
, len
);
2953 memcpy (inf_siginfo
+ offset
, writebuf
, len
);
2955 /* Convert back to ptrace layout before flushing it out. */
2956 siginfo_fixup (&siginfo
, inf_siginfo
, 1);
2958 if (ptrace (PTRACE_SETSIGINFO
, pid
, 0, &siginfo
) != 0)
2965 /* SIGCHLD handler that serves two purposes: In non-stop/async mode,
2966 so we notice when children change state; as the handler for the
2967 sigsuspend in my_waitpid. */
2970 sigchld_handler (int signo
)
2972 int old_errno
= errno
;
2975 /* fprintf is not async-signal-safe, so call write directly. */
2976 write (2, "sigchld_handler\n", sizeof ("sigchld_handler\n") - 1);
2978 if (target_is_async_p ())
2979 async_file_mark (); /* trigger a linux_wait */
2985 linux_supports_non_stop (void)
2991 linux_async (int enable
)
2993 int previous
= (linux_event_pipe
[0] != -1);
2995 if (previous
!= enable
)
2998 sigemptyset (&mask
);
2999 sigaddset (&mask
, SIGCHLD
);
3001 sigprocmask (SIG_BLOCK
, &mask
, NULL
);
3005 if (pipe (linux_event_pipe
) == -1)
3006 fatal ("creating event pipe failed.");
3008 fcntl (linux_event_pipe
[0], F_SETFL
, O_NONBLOCK
);
3009 fcntl (linux_event_pipe
[1], F_SETFL
, O_NONBLOCK
);
3011 /* Register the event loop handler. */
3012 add_file_handler (linux_event_pipe
[0],
3013 handle_target_event
, NULL
);
3015 /* Always trigger a linux_wait. */
3020 delete_file_handler (linux_event_pipe
[0]);
3022 close (linux_event_pipe
[0]);
3023 close (linux_event_pipe
[1]);
3024 linux_event_pipe
[0] = -1;
3025 linux_event_pipe
[1] = -1;
3028 sigprocmask (SIG_UNBLOCK
, &mask
, NULL
);
3035 linux_start_non_stop (int nonstop
)
3037 /* Register or unregister from event-loop accordingly. */
3038 linux_async (nonstop
);
3043 linux_supports_multi_process (void)
3049 /* Enumerate spufs IDs for process PID. */
3051 spu_enumerate_spu_ids (long pid
, unsigned char *buf
, CORE_ADDR offset
, int len
)
3057 struct dirent
*entry
;
3059 sprintf (path
, "/proc/%ld/fd", pid
);
3060 dir
= opendir (path
);
3065 while ((entry
= readdir (dir
)) != NULL
)
3071 fd
= atoi (entry
->d_name
);
3075 sprintf (path
, "/proc/%ld/fd/%d", pid
, fd
);
3076 if (stat (path
, &st
) != 0)
3078 if (!S_ISDIR (st
.st_mode
))
3081 if (statfs (path
, &stfs
) != 0)
3083 if (stfs
.f_type
!= SPUFS_MAGIC
)
3086 if (pos
>= offset
&& pos
+ 4 <= offset
+ len
)
3088 *(unsigned int *)(buf
+ pos
- offset
) = fd
;
3098 /* Implements the to_xfer_partial interface for the TARGET_OBJECT_SPU
3099 object type, using the /proc file system. */
3101 linux_qxfer_spu (const char *annex
, unsigned char *readbuf
,
3102 unsigned const char *writebuf
,
3103 CORE_ADDR offset
, int len
)
3105 long pid
= lwpid_of (get_thread_lwp (current_inferior
));
3110 if (!writebuf
&& !readbuf
)
3118 return spu_enumerate_spu_ids (pid
, readbuf
, offset
, len
);
3121 sprintf (buf
, "/proc/%ld/fd/%s", pid
, annex
);
3122 fd
= open (buf
, writebuf
? O_WRONLY
: O_RDONLY
);
3127 && lseek (fd
, (off_t
) offset
, SEEK_SET
) != (off_t
) offset
)
3134 ret
= write (fd
, writebuf
, (size_t) len
);
3136 ret
= read (fd
, readbuf
, (size_t) len
);
3142 static struct target_ops linux_target_ops
= {
3143 linux_create_inferior
,
3151 linux_fetch_registers
,
3152 linux_store_registers
,
3155 linux_look_up_symbols
,
3156 linux_request_interrupt
,
3160 linux_stopped_by_watchpoint
,
3161 linux_stopped_data_address
,
3162 #if defined(__UCLIBC__) && defined(HAS_NOMMU)
3167 #ifdef USE_THREAD_DB
3168 thread_db_get_tls_address
,
3173 hostio_last_error_from_errno
,
3176 linux_supports_non_stop
,
3178 linux_start_non_stop
,
3179 linux_supports_multi_process
,
3180 #ifdef USE_THREAD_DB
3181 thread_db_handle_monitor_command
3188 linux_init_signals ()
3190 /* FIXME drow/2002-06-09: As above, we should check with LinuxThreads
3191 to find what the cancel signal actually is. */
3192 signal (__SIGRTMIN
+1, SIG_IGN
);
3196 initialize_low (void)
3198 struct sigaction sigchld_action
;
3199 memset (&sigchld_action
, 0, sizeof (sigchld_action
));
3200 set_target_ops (&linux_target_ops
);
3201 set_breakpoint_data (the_low_target
.breakpoint
,
3202 the_low_target
.breakpoint_len
);
3203 linux_init_signals ();
3204 linux_test_for_tracefork ();
3205 #ifdef HAVE_LINUX_REGSETS
3206 for (num_regsets
= 0; target_regsets
[num_regsets
].size
>= 0; num_regsets
++)
3208 disabled_regsets
= xmalloc (num_regsets
);
3211 sigchld_action
.sa_handler
= sigchld_handler
;
3212 sigemptyset (&sigchld_action
.sa_mask
);
3213 sigchld_action
.sa_flags
= SA_RESTART
;
3214 sigaction (SIGCHLD
, &sigchld_action
, NULL
);